diff --git a/.dockerignore b/.dockerignore
index 586a34e..8daaba8 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -49,4 +49,4 @@ arbitrator/prover/test-cases/**/*
 arbitrator/prover/test-cases
 
 # external tools and IDEs
-.vscode
\ No newline at end of file
+.vscode
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..891c617
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,27 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..bbcbbe7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/.github/codeql/codeql-config.yml b/.github/codeql/codeql-config.yml
new file mode 100644
index 0000000..0cc7db7
--- /dev/null
+++ b/.github/codeql/codeql-config.yml
@@ -0,0 +1,2 @@
+name: "Nitro CodeQL config"
+
diff --git a/.github/workflows/arbitrator-ci.yml b/.github/workflows/arbitrator-ci.yml
new file mode 100644
index 0000000..4764601
--- /dev/null
+++ b/.github/workflows/arbitrator-ci.yml
@@ -0,0 +1,189 @@
+name: Arbitrator CI
+run-name: Arbitrator CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      enable_tmate:
+        type: boolean
+        description: 'Enable tmate'
+        required: false
+        default: false
+  merge_group:
+  pull_request:
+    paths:
+      - 'arbitrator/**'
+      - 'contracts'
+      - '.github/workflows/arbitrator-ci.yml'
+      - 'Makefile'
+  push:
+    branches:
+      - master
+
+env:
+  RUST_BACKTRACE: 1
+# RUSTFLAGS: -Dwarnings            # TODO: re-enable after wasmer upgrade
+  WABT_VERSION: 1.0.32
+
+jobs:
+  arbitrator:
+    name: Run Arbitrator tests
+    runs-on: ubuntu-8
+    steps:
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@v3
+        if: ${{ github.event_name == 'workflow_dispatch' && inputs.enable_tmate }}
+        with:
+          detached: true
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Ubuntu dependencies
+        run: |
+          sudo apt-get update && sudo apt-get install -y \
+            build-essential cmake lld-14 libudev-dev
+          sudo ln -s /usr/bin/wasm-ld-14 /usr/local/bin/wasm-ld
+
+      - name: Install go
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.23.x
+
+      - name: Install custom go-ethereum
+        run: |
+          cd /tmp
+          git clone --branch v1.14.11 --depth 1 https://github.com/ethereum/go-ethereum.git
+          cd go-ethereum
+          go build -o /usr/local/bin/geth ./cmd/geth
+
+      - name: Setup nodejs
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: 'yarn'
+          cache-dependency-path: '**/yarn.lock'
+
+      - name: Install rust stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: 'stable'
+          components: 'llvm-tools-preview, rustfmt, clippy'
+
+      - name: Install rust nightly
+        uses: dtolnay/rust-toolchain@nightly
+        id: install-rust-nightly
+        with:
+          toolchain: 'nightly-2024-08-06'
+          targets: 'wasm32-wasi, wasm32-unknown-unknown'
+          components: 'rust-src, rustfmt, clippy'
+
+      - name: Set STYLUS_NIGHTLY_VER environment variable
+        run: echo "STYLUS_NIGHTLY_VER=+$(rustup toolchain list | grep '^nightly' | head -n1 | cut -d' ' -f1)" >> "$GITHUB_ENV"
+
+      - name: Cache Rust intermediate build products
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            arbitrator/target/
+            arbitrator/wasm-libraries/target/
+          key: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-full-${{ hashFiles('arbitrator/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-full-
+            ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-
+
+      - name: Cache wabt build
+        id: cache-wabt
+        uses: actions/cache@v3
+        with:
+          path: ~/wabt-prefix
+          key: ${{ runner.os }}-wabt-${{ env.WABT_VERSION }}
+
+      - name: Install latest wabt
+        if: steps.cache-wabt.outputs.cache-hit != 'true'
+        run: |
+          cd "$(mktemp -d)"
+          git clone --recursive -b "$WABT_VERSION" https://github.com/WebAssembly/wabt .
+          mkdir build
+          cd build
+          mkdir -p ~/wabt-prefix
+          cmake .. -DCMAKE_INSTALL_PREFIX="$HOME/wabt-prefix"
+          make -j
+          make install
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Cache cbrotli
+        uses: actions/cache@v3
+        id: cache-cbrotli
+        with:
+          path: |
+            target/include/brotli/
+            target/lib-wasm/
+            target/lib/libbrotlicommon-static.a
+            target/lib/libbrotlienc-static.a
+            target/lib/libbrotlidec-static.a
+          key: ${{ runner.os }}-brotli-3-${{ hashFiles('scripts/build-brotli.sh') }}-${{ hashFiles('.github/workflows/arbitrator-ci.yaml') }}
+          restore-keys: ${{ runner.os }}-brotli-2-
+
+      - name: Build cbrotli-local
+        if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+        run: ./scripts/build-brotli.sh -l
+
+      - name: Setup emsdk
+        if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+        uses: mymindstorm/setup-emsdk@v12
+        with:
+          # Make sure to set a version number!
+          version: 3.1.6
+          # This is the name of the cache folder.
+          # The cache folder will be placed in the build directory,
+          #  so make sure it doesn't conflict with anything!
+          actions-cache-folder: 'emsdk-cache'
+          no-cache: true
+
+      - name: Build cbrotli-wasm
+        if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+        run: ./scripts/build-brotli.sh -w
+
+      - name: Add wabt to path
+        run: echo "$HOME/wabt-prefix/bin" >> "$GITHUB_PATH"
+
+      - name: Make arbitrator libraries
+        run: make -j wasm-ci-build
+
+      - name: Clippy check
+        run: cargo clippy --all --manifest-path arbitrator/Cargo.toml -- -D warnings
+
+      - name: Run rust tests
+        run: cargo test -p arbutil -p prover -p jit -p stylus --release --manifest-path arbitrator/prover/Cargo.toml
+
+      - name: Rustfmt
+        run: cargo fmt -p arbutil -p prover -p jit -p stylus --manifest-path arbitrator/Cargo.toml -- --check
+
+      - name: Rustfmt - langs/rust
+        run: cargo fmt --all --manifest-path arbitrator/langs/rust/Cargo.toml -- --check
+
+      - name: Make proofs from test cases
+        run: make -j test-gen-proofs
+
+      - name: Start geth server
+        run: |
+          geth --dev --http --http.port 8545 &
+          sleep 2
+
+      - name: Run proof validation tests
+        run: |
+          npm install --global yarn
+          cd contracts
+          yarn install
+          yarn build
+          yarn build:forge:yul
+          yarn hardhat --network localhost test test/prover/*.ts
diff --git a/.github/workflows/arbitrator-skip-ci.yml b/.github/workflows/arbitrator-skip-ci.yml
new file mode 100644
index 0000000..10c9bf9
--- /dev/null
+++ b/.github/workflows/arbitrator-skip-ci.yml
@@ -0,0 +1,21 @@
+name: Arbitrator skip CI
+run-name: Arbitrator skip CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  merge_group:
+  pull_request:
+    paths-ignore:
+      - 'arbitrator/**'
+      - 'contracts/src/osp/**'
+      - 'contracts/src/mock/**'
+      - 'contracts/test/**'
+      - 'contracts/hardhat.config.ts'
+      - 'Makefile'
+
+jobs:
+  arbitrator:
+    name: Run Arbitrator tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Do nothing
+        run: echo "doing nothing"
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..a944f08
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,198 @@
+name: Go tests CI
+run-name: Go tests CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+
+jobs:
+  test:
+    name: Go Tests
+    runs-on: ubuntu-8
+
+    # Creates a redis container for redis tests
+    services:
+      redis:
+        image: redis
+        ports:
+            - 6379:6379
+
+    strategy:
+      fail-fast: false
+      matrix:
+        test-mode: [defaults, race, challenge, stylus, long]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Install dependencies
+        run: sudo apt update && sudo apt install -y wabt gotestsum
+
+      - name: Setup nodejs
+        uses: actions/setup-node@v3
+        with:
+          node-version: '18'
+          cache: 'yarn'
+          cache-dependency-path: '**/yarn.lock'
+
+      - name: Install go
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.23.x
+
+      - name: Install wasm-ld
+        run: |
+          sudo apt-get update && sudo apt-get install -y lld-14
+          sudo ln -s /usr/bin/wasm-ld-14 /usr/local/bin/wasm-ld
+
+      - name: Install rust stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: 'stable'
+          targets: 'wasm32-wasi, wasm32-unknown-unknown'
+          components: 'llvm-tools-preview, rustfmt, clippy'
+
+      - name: Install rust nightly
+        uses: dtolnay/rust-toolchain@nightly
+        id: install-rust-nightly
+        with:
+          toolchain: 'nightly-2024-08-06'
+          targets: 'wasm32-wasi, wasm32-unknown-unknown'
+          components: 'rust-src, rustfmt, clippy'
+
+      - name: Set STYLUS_NIGHTLY_VER environment variable
+        run: echo "STYLUS_NIGHTLY_VER=+$(rustup toolchain list | grep '^nightly' | head -n1 | cut -d' ' -f1)" >> "$GITHUB_ENV"
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Cache Build Products
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/go/pkg/mod
+            ~/.cache/go-build
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}-${{ matrix.test-mode }}
+          restore-keys: ${{ runner.os }}-go-
+
+      - name: Cache Rust Build Products
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/
+            arbitrator/target/
+            arbitrator/wasm-libraries/target/
+            arbitrator/wasm-libraries/soft-float/
+            target/etc/initial-machine-cache/
+            /home/runner/.rustup/toolchains/
+          key: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-min-${{ hashFiles('arbitrator/Cargo.lock') }}-${{ matrix.test-mode }}
+          restore-keys: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-
+
+      - name: Cache cbrotli
+        uses: actions/cache@v3
+        id: cache-cbrotli
+        with:
+          path: |
+            target/include/brotli/
+            target/lib-wasm/
+            target/lib/libbrotlicommon-static.a
+            target/lib/libbrotlienc-static.a
+            target/lib/libbrotlidec-static.a
+          key: ${{ runner.os }}-brotli-${{ hashFiles('scripts/build-brotli.sh') }}-${{ hashFiles('.github/workflows/arbitrator-ci.yaml') }}-${{ matrix.test-mode }}
+          restore-keys: ${{ runner.os }}-brotli-
+
+      - name: Build cbrotli-local
+        if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+        run: ./scripts/build-brotli.sh -l
+
+      - name: Build cbrotli-wasm in docker
+        if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+        run: ./scripts/build-brotli.sh -w -d
+
+      - name: Build
+        run: make build test-go-deps -j
+
+      - name: Build all lint dependencies
+        run: make -j build-node-deps
+
+      - name: Lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: latest
+          skip-pkg-cache: true
+      - name: Custom Lint
+        run: |
+          go run ./linters ./...
+
+      - name: Set environment variables
+        run: |
+          mkdir -p target/tmp/deadbeefbee
+          echo "TMPDIR=$(pwd)/target/tmp/deadbeefbee" >> "$GITHUB_ENV"
+          echo "GOMEMLIMIT=6GiB" >> "$GITHUB_ENV"
+          echo "GOGC=80" >> "$GITHUB_ENV"
+          echo "GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }}" >> "$GITHUB_ENV"
+
+      - name: run tests without race detection and path state scheme
+        if: matrix.test-mode == 'defaults'
+        env:
+          TEST_STATE_SCHEME: path
+        run: |
+          echo "Running tests with Path Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags cionly --timeout 20m --cover
+
+      - name: run tests without race detection and hash state scheme
+        if: matrix.test-mode == 'defaults'
+        env:
+          TEST_STATE_SCHEME: hash
+        run: |
+          echo "Running tests with Hash Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags cionly --timeout 20m
+
+      - name: run tests with race detection and hash state scheme
+        if: matrix.test-mode == 'race'
+        env:
+          TEST_STATE_SCHEME: hash
+        run: |
+          echo "Running tests with Hash Scheme" >> full.log
+          ${{ github.workspace }}/.github/workflows/gotestsum.sh --race --timeout 30m
+
+      - name: run redis tests
+        if: matrix.test-mode == 'defaults'
+        run: |
+          echo "Running redis tests" >> full.log
+          TEST_REDIS=redis://localhost:6379/0 gotestsum --format short-verbose -- -p 1 -run TestRedis ./arbnode/... ./system_tests/... -coverprofile=coverage-redis.txt -covermode=atomic -coverpkg=./...
+
+      - name: run challenge tests
+        if: matrix.test-mode == 'challenge'
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags challengetest --run TestChallenge --cover
+
+      - name: run stylus tests
+        if: matrix.test-mode == 'stylus'
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags stylustest --run TestProgramArbitrator --timeout 60m --cover
+
+      - name: run long stylus tests
+        if: matrix.test-mode == 'long'
+        run: ${{ github.workspace }}/.github/workflows/gotestsum.sh --tags stylustest --run TestProgramLong --timeout 60m --cover
+
+      - name: Archive detailed run log
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.test-mode }}-full.log
+          path: full.log
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v2
+        if: matrix.test-mode == 'defaults'
+        with:
+          fail_ci_if_error: false
+          files: ./coverage.txt,./coverage-redis.txt
+          verbose: false
+          token: ${{ secrets.CODECOV_TOKEN }}
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 0000000..2644794
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,144 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  merge_group:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '18 21 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    if: github.repository == 'OffchainLabs/nitro' # don't run in any forks without "Advanced Security" enabled
+    runs-on: ubuntu-8
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    env:
+      WABT_VERSION: 1.0.32
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - name: Install dependencies
+      run: sudo apt update && sudo apt install -y wabt
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+        config-file: ./.github/codeql/codeql-config.yml
+
+    - name: Setup nodejs
+      uses: actions/setup-node@v3
+      with:
+        node-version: '18'
+        cache: 'yarn'
+        cache-dependency-path: '**/yarn.lock'
+
+    - name: Install go
+      uses: actions/setup-go@v4
+      with:
+        go-version: 1.23.x
+
+    - name: Install rust stable
+      uses: dtolnay/rust-toolchain@stable
+
+    - name: Install Foundry
+      uses: foundry-rs/foundry-toolchain@v1
+
+    - name: Cache Rust Build Products
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/.cargo/registry/
+          ~/.cargo/git/
+          arbitrator/target/
+          arbitrator/wasm-libraries/target/
+          arbitrator/wasm-libraries/soft-float/SoftFloat/build
+          target/etc/initial-machine-cache/
+        key: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-min-${{ hashFiles('arbitrator/Cargo.lock') }}
+        restore-keys: ${{ runner.os }}-cargo-${{ steps.install-rust.outputs.rustc_hash }}-
+
+    - name: Cache wabt build
+      id: cache-wabt
+      uses: actions/cache@v3
+      with:
+        path: ~/wabt-prefix
+        key: ${{ runner.os }}-wabt-codeql-${{ env.WABT_VERSION }}
+
+    - name: Cache cbrotli
+      uses: actions/cache@v3
+      id: cache-cbrotli
+      with:
+        path: |
+          target/include/brotli/
+          target/lib-wasm/
+          target/lib/libbrotlicommon-static.a
+          target/lib/libbrotlienc-static.a
+          target/lib/libbrotlidec-static.a
+        key: ${{ runner.os }}-brotli-3a-${{ hashFiles('scripts/build-brotli.sh') }}-${{ hashFiles('.github/workflows/arbitrator-ci.yaml') }}
+        restore-keys: ${{ runner.os }}-brotli-
+
+    - name: Build cbrotli-local
+      if: steps.cache-cbrotli.outputs.cache-hit != 'true'
+      run: ./scripts/build-brotli.sh -l
+
+    - name: Cache Build Products
+      uses: actions/cache@v3
+      with:
+        path: |
+          ~/go/pkg/mod
+          ~/.cache/go-build
+        key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+        restore-keys: ${{ runner.os }}-go-
+
+    - name: Build all lint dependencies
+      run: make -j build-node-deps
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
new file mode 100644
index 0000000..2aacf32
--- /dev/null
+++ b/.github/workflows/docker.yml
@@ -0,0 +1,104 @@
+name: Docker build CI
+run-name: Docker build CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - master
+      - develop
+
+jobs:
+  docker:
+    name: Docker build
+    runs-on: ubuntu-8
+    services:
+      # local registery
+      registry:
+        image: registry:2
+        ports:
+          - 5000:5000
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver-opts: network=host
+
+      - name: Cache Docker layers
+        uses: actions/cache@v3
+        with:
+          path: /tmp/.buildx-cache
+          key: ${{ runner.os }}-buildx-${{ hashFiles('Dockerfile') }}
+          restore-keys: ${{ runner.os }}-buildx-
+
+      - name: Build nitro-node docker
+        uses: docker/build-push-action@v5
+        with:
+          target: nitro-node
+          push: true
+          context: .
+          tags: localhost:5000/nitro-node:latest
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+      - name: Build nitro-node-dev docker
+        uses: docker/build-push-action@v5
+        with:
+          target: nitro-node-dev
+          push: true
+          context: .
+          tags: localhost:5000/nitro-node-dev:latest
+          cache-from: type=local,src=/tmp/.buildx-cache
+          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
+
+      - name: Start background nitro-testnode
+        shell: bash
+        run: |
+          cd nitro-testnode
+          ./test-node.bash --init --dev &
+
+      - name: Wait for rpc to come up
+        shell: bash
+        run: |
+          ${{ github.workspace }}/.github/workflows/waitForNitro.sh
+
+      - name: Print WAVM module root
+        id: module-root
+        run: |
+          # Unfortunately, `docker cp` seems to always result in a "permission denied"
+          # We work around this by piping a tarball through stdout
+          docker run --rm --entrypoint tar localhost:5000/nitro-node-dev:latest -cf - target/machines/latest | tar xf -
+          module_root="$(cat "target/machines/latest/module-root.txt")"
+          echo "module-root=$module_root" >> "$GITHUB_OUTPUT"
+          echo -e "\x1b[1;34mWAVM module root:\x1b[0m $module_root"
+
+      - name: Upload WAVM machine as artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: wavm-machine-${{ steps.module-root.outputs.module-root }}
+          path: target/machines/latest/*
+          if-no-files-found: error
+
+      - name: Move cache
+        # Temp fix
+        # https://github.com/docker/build-push-action/issues/252
+        # https://github.com/moby/buildkit/issues/1896
+        run: |
+          rm -rf /tmp/.buildx-cache
+          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
+
+      - name: Clear cache on failure
+        if: failure()
+        run: |
+          keys=(${{ runner.os }}-buildx- ${{ runner.os }}-buildx-${{ hashFiles('Dockerfile') }})
+          for key in "${keys[@]}"; do
+            curl -X DELETE -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" "https://api.github.com/repos/${{ github.repository }}/actions/caches/$key"
+          done
diff --git a/.github/workflows/gotestsum.sh b/.github/workflows/gotestsum.sh
new file mode 100755
index 0000000..ed63184
--- /dev/null
+++ b/.github/workflows/gotestsum.sh
@@ -0,0 +1,83 @@
+#!/bin/bash
+
+check_missing_value() {
+    if [[ $1 -eq 0 || $2 == -* ]]; then
+        echo "missing $3 argument value"
+        exit 1
+    fi
+}
+
+timeout=""
+tags=""
+run=""
+race=false
+cover=false
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --timeout)
+      shift
+      check_missing_value $# "$1" "--timeout"
+      timeout=$1
+      shift
+      ;;
+    --tags)
+      shift
+      check_missing_value $# "$1" "--tags"
+      tags=$1
+      shift
+      ;;
+    --run)
+      shift
+      check_missing_value $# "$1" "--run"
+      run=$1
+      shift
+      ;;
+    --race)
+      race=true
+      shift
+      ;;
+    --cover)
+      cover=true
+      shift
+      ;;
+    *)
+      echo "Invalid argument: $1"
+      exit 1
+      ;;
+  esac
+done
+
+packages=$(go list ./...)
+for package in $packages; do
+  cmd="stdbuf -oL gotestsum --format short-verbose --packages=\"$package\" --rerun-fails=2 --no-color=false --"
+
+  if [ "$timeout" != "" ]; then
+    cmd="$cmd -timeout $timeout"
+  fi
+
+  if [ "$tags" != "" ]; then
+    cmd="$cmd -tags=$tags"
+  fi
+
+  if [ "$run" != "" ]; then
+    cmd="$cmd -run=$run"
+  fi
+
+  if [ "$race" == true ]; then
+    cmd="$cmd -race"
+  fi
+
+  if [ "$cover" == true ]; then
+    cmd="$cmd -coverprofile=coverage.txt -covermode=atomic -coverpkg=./...,./go-ethereum/..."
+  fi
+
+  cmd="$cmd > >(stdbuf -oL tee -a full.log | grep -vE \"INFO|seal\")"
+
+  echo ""
+  echo running tests for "$package"
+  echo "$cmd"
+
+  if ! eval "$cmd"; then
+    exit 1
+  fi
+done
diff --git a/.github/workflows/merge-checks.yml b/.github/workflows/merge-checks.yml
new file mode 100644
index 0000000..c9f7957
--- /dev/null
+++ b/.github/workflows/merge-checks.yml
@@ -0,0 +1,42 @@
+name: Merge Checks
+
+on:
+  pull_request_target:
+    branches: [ master ]
+    types: [synchronize, opened, reopened, labeled, unlabeled]
+
+permissions:
+  statuses: write
+
+jobs:
+  check-design-approved:
+    name: Check if Design Approved
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check if design approved and update status
+        run: |
+          set -x pipefail
+          status_state="pending"
+          if ${{ contains(github.event.pull_request.labels.*.name, 'design-approved') && !contains(github.event.pull_request.labels.*.name, 'after-next-version') }}; then
+            status_state="success"
+          else
+            resp="$(curl -sSL --fail-with-body \
+              -H "Accept: application/vnd.github+json" \
+              -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
+              -H "X-GitHub-Api-Version: 2022-11-28" \
+              "https://api.github.com/repos/$GITHUB_REPOSITORY/commits/${{ github.event.pull_request.head.sha }}/statuses")"
+            if ! jq -e '.[] | select(.context == "Design Approved Check")' > /dev/null <<< "$resp"; then
+              # Design not approved yet and no status exists
+              # Keep it without a status to keep the green checkmark appearing
+              # Otherwise, the commit and PR's CI will appear to be indefinitely pending
+              # Merging will still be blocked until the required status appears
+              exit 0
+            fi
+          fi
+          curl -sSL --fail-with-body \
+            -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            "https://api.github.com/repos/$GITHUB_REPOSITORY/statuses/${{ github.event.pull_request.head.sha }}" \
+            -d '{"context":"Design Approved Check","state":"'"$status_state"'"}'
diff --git a/.github/workflows/release-ci.yml b/.github/workflows/release-ci.yml
new file mode 100644
index 0000000..5282510
--- /dev/null
+++ b/.github/workflows/release-ci.yml
@@ -0,0 +1,30 @@
+name: Release CI
+run-name: Release CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build_and_run:
+    runs-on: ubuntu-8
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        driver-opts: network=host
+
+    - name: Cache Docker layers
+      uses: actions/cache@v3
+      with:
+        path: /tmp/.buildx-cache
+        key: ${{ runner.os }}-buildx-${{ hashFiles('Dockerfile') }}
+        restore-keys: ${{ runner.os }}-buildx-
+
+    - name:  Startup Nitro testnode
+      run: ./scripts/startup-testnode.bash
diff --git a/.github/workflows/shellcheck-ci.yml b/.github/workflows/shellcheck-ci.yml
new file mode 100644
index 0000000..d1c7b58
--- /dev/null
+++ b/.github/workflows/shellcheck-ci.yml
@@ -0,0 +1,30 @@
+name: ShellCheck CI
+run-name: ShellCheck CI triggered from @${{ github.actor }} of ${{ github.head_ref }}
+
+on:
+  workflow_dispatch:
+  merge_group:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  shellcheck:
+    name: Run ShellCheck
+    runs-on: ubuntu-8
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Run ShellCheck
+        uses: ludeeus/action-shellcheck@master
+        with:
+          ignore_paths: >-
+            ./fastcache/**
+            ./contracts/**
+            ./safe-smart-account/**
+            ./go-ethereum/**
+            ./nitro-testnode/**
+            ./brotli/**
+            ./arbitrator/**
diff --git a/.github/workflows/submodule-pin-check.yml b/.github/workflows/submodule-pin-check.yml
new file mode 100644
index 0000000..90419b5
--- /dev/null
+++ b/.github/workflows/submodule-pin-check.yml
@@ -0,0 +1,69 @@
+name: Merge Checks
+
+on:
+  pull_request_target:
+    branches: [ master ]
+    types: [synchronize, opened, reopened]
+
+permissions:
+  statuses: write
+
+jobs:
+  submodule-pin-check:
+    name: Check Submodule Pin
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: true
+          ref: "${{ github.event.pull_request.merge_commit_sha }}"
+
+      - name: Check all submodules are ancestors of origin/HEAD or configured branch
+        run: |
+          status_state="pending"
+          declare -Ar exceptions=(
+            [contracts]=origin/develop
+            [nitro-testnode]=origin/master
+            
+            #TODO Rachel to check these are the intended branches.
+            [arbitrator/langs/c]=origin/vm-storage-cache
+            [arbitrator/tools/wasmer]=origin/adopt-v4.2.8
+          )
+          divergent=0
+          for mod in `git submodule --quiet foreach 'echo $name'`; do
+            branch=origin/HEAD
+            if [[ -v exceptions[$mod] ]]; then
+              branch=${exceptions[$mod]}
+            fi
+            
+            if ! git -C $mod merge-base --is-ancestor HEAD $branch; then
+              echo $mod diverges from $branch
+              divergent=1
+            fi
+          done
+          if [ $divergent -eq 0 ]; then
+            status_state="success"
+          else
+            resp="$(curl -sSL --fail-with-body \
+              -H "Accept: application/vnd.github+json" \
+              -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
+              -H "X-GitHub-Api-Version: 2022-11-28" \
+              "https://api.github.com/repos/$GITHUB_REPOSITORY/commits/${{ github.event.pull_request.head.sha }}/statuses")"
+
+            if ! jq -e '.[] | select(.context == "Submodule Pin Check")' > /dev/null <<< "$resp"; then
+              # Submodule pin check is failling and no status exists
+              # Keep it without a status to keep the green checkmark appearing
+              # Otherwise, the commit and PR's CI will appear to be indefinitely pending
+              # Merging will still be blocked until the required status appears
+              exit 0
+            fi
+          fi
+          curl -sSL --fail-with-body \
+            -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            "https://api.github.com/repos/$GITHUB_REPOSITORY/statuses/${{ github.event.pull_request.head.sha }}" \
+            -d '{"context":"Submodule Pin Check","state":"'"$status_state"'"}'
diff --git a/.github/workflows/waitForNitro.sh b/.github/workflows/waitForNitro.sh
new file mode 100755
index 0000000..cf3f648
--- /dev/null
+++ b/.github/workflows/waitForNitro.sh
@@ -0,0 +1,13 @@
+#!/bin/bash
+# poll the nitro endpoint until we get a 0 return code or 30mins have passed, in that case exit 1
+timeout_time=$(($(date +%s) + 1800))
+
+while (( $(date +%s) <= timeout_time )); do
+  if curl -X POST -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":45678,"method":"eth_chainId","params":[]}' 'http://localhost:8547'; then
+    exit 0
+  else
+    sleep 20
+  fi
+done
+
+exit 1
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index d6b9398..b94d61e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,4 +23,3 @@ system_tests/test-data/*
 .configs/
 system_tests/testdata/*
 arbos/testdata/*
-keys/*
diff --git a/.gitmodules b/.gitmodules
index a120835..28a725c 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,18 +1,18 @@
+[submodule "contracts"]
+	path = contracts
+	url = https://github.com/OffchainLabs/nitro-contracts
 [submodule "fastcache"]
 	path = fastcache
 	url = https://github.com/OffchainLabs/fastcache
-[submodule "nitro-testnode"]
-	path = nitro-testnode
-	url = https://github.com/OffchainLabs/nitro-testnode
 [submodule "fhevm-go"]
 	path = fhevm-go
 	url = git@github.com:z1labs/Cypher-fhEVM-Go.git
-[submodule "go-ethereum"]
-	path = go-ethereum
-	url = git@github.com:z1labs/Cypher-Go-Ethereum.git
+[submodule "nitro-testnode"]
+	path = nitro-testnode
+	url = https://github.com/OffchainLabs/nitro-testnode
 [submodule "safe-smart-account"]
 	path = safe-smart-account
 	url = https://github.com/safe-global/safe-smart-account.git
-[submodule "contracts"]
-	path = contracts
-	url = https://github.com/OffchainLabs/nitro-contracts
+[submodule "go-ethereum"]
+	path = go-ethereum
+	url = git@github.com:z1labs/Cypher-Go-Ethereum.git
diff --git a/.golangci.yml b/.golangci.yml
index fe90dd2..0594670 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -44,7 +44,6 @@ linters-settings:
   gosec:
     excludes:
       - G404  # checks that random numbers are securely generated
-      - G402
 
   govet:
     enable-all: true
diff --git a/Dockerfile b/Dockerfile
index b5af904..25bcd51 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -235,7 +235,7 @@ COPY ./scripts/download-machine.sh .
 #RUN ./download-machine.sh consensus-v20 0x8b104a2e80ac6165dc58b9048de12f301d70b02a0ab51396c22b4b4b802a16a4
 RUN ./download-machine.sh consensus-v30 0xb0de9cb89e4d944ae6023a3b62276e54804c242fd8c4c2d8e6cc4450f5fa8b1b && true
 RUN ./download-machine.sh consensus-v31 0x260f5fa5c3176a856893642e149cf128b5a8de9f828afec8d11184415dd8dc69
-
+RUN ./download-machine.sh consensus-v32 0x184884e1eb9fefdc158f6c8ac912bb183bf3cf83f0090317e0bc4ac5860baa39
 
 FROM rust-base AS tfhe-builder
 WORKDIR /workspace
@@ -265,18 +265,20 @@ ARG modified=""
 ENV NITRO_VERSION=$version
 ENV NITRO_DATETIME=$datetime
 ENV NITRO_MODIFIED=$modified
+
 RUN export DEBIAN_FRONTEND=noninteractive && \
     apt-get update && \
     apt-get install -y wabt binutils binutils-gold gcc g++
 
-
 COPY go.mod go.sum ./
 COPY go-ethereum/go.mod go-ethereum/go.sum go-ethereum/
 COPY fastcache/go.mod fastcache/go.sum fastcache/
 COPY fhevm-go/go.mod fhevm-go/go.sum fhevm-go/
 RUN go mod download
-
 COPY . ./
+RUN go run solgen/gen.go
+RUN ls -R solgen/go/
+
 
 COPY --from=contracts-builder /workspace/contracts/build/contracts/src/precompiles/ contracts/build/contracts/src/precompiles/
 COPY --from=contracts-builder /workspace/contracts/out/ contracts/out/
diff --git a/LICENSE.md b/LICENSE.md
index ea9a53d..25768b3 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -22,7 +22,7 @@ Additional Use Grant: You may use the Licensed Work in a production environment
                       Expansion Program Term of Use](https://docs.arbitrum.foundation/assets/files/Arbitrum%20Expansion%20Program%20Jan182024-4f08b0c2cb476a55dc153380fa3e64b0.pdf). For purposes of this
                       Additional Use Grant, the "Covered Arbitrum Chains" are 
                       (a) Arbitrum One (chainid:42161), Arbitrum Nova (chainid:42170), 
-                      rbitrum Rinkeby testnet/Rinkarby (chainid:421611),Arbitrum Nitro
+                      Arbitrum Rinkeby testnet/Rinkarby (chainid:421611),Arbitrum Nitro
                       Goerli testnet (chainid:421613), and Arbitrum Sepolia Testnet
                       (chainid:421614); (b) any future blockchains authorized to be
                       designated as Covered Arbitrum Chains by the decentralized autonomous
diff --git a/README.md b/README.md
index f825da0..56c1cc0 100644
--- a/README.md
+++ b/README.md
@@ -246,4 +246,4 @@ Check the documetation for a step by step guide how to run own
 
 [Build and deploy smart contracts]: <https://github.com/z1labs/Cypher>
 
-[Use Metamask Cypher snap to for an easy access to decryption service]: <https://github.com/z1labs/Cypher>
+[Use Metamask Cypher snap to for an easy access to decryption service]: <https://github.com/z1labs/Cypher>
\ No newline at end of file
diff --git a/arbcompress/compress_common.go b/arbcompress/compress_common.go
index a61dd9a..997232e 100644
--- a/arbcompress/compress_common.go
+++ b/arbcompress/compress_common.go
@@ -17,6 +17,8 @@ func compressedBufferSizeFor(length int) int {
 	return length + (length>>10)*8 + 64 // actual limit is: length + (length >> 14) * 4 + 6
 }
 
-func CompressLevel(input []byte, level int) ([]byte, error) {
+func CompressLevel(input []byte, level uint64) ([]byte, error) {
+	// level is trusted and shouldn't be anything crazy
+	// #nosec G115
 	return Compress(input, uint32(level), EmptyDictionary)
 }
diff --git a/arbcompress/native.go b/arbcompress/native.go
index 8244010..f7b8f0b 100644
--- a/arbcompress/native.go
+++ b/arbcompress/native.go
@@ -7,7 +7,7 @@
 package arbcompress
 
 /*
-#cgo CFLAGS: -g -Wall -I${SRCDIR}/../target/include/
+#cgo CFLAGS: -g -I${SRCDIR}/../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../target/lib/libstylus.a -lm
 #include "arbitrator.h"
 */
diff --git a/arbitrator/Cargo.lock b/arbitrator/Cargo.lock
index 79a9117..8644114 100644
--- a/arbitrator/Cargo.lock
+++ b/arbitrator/Cargo.lock
@@ -215,7 +215,6 @@ dependencies = [
  "prover",
  "serde",
  "serde_json",
- "serde_with 3.9.0",
 ]
 
 [[package]]
@@ -496,6 +495,12 @@ version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1462739cb27611015575c0c11df5df7601141071f07518d56fcc1be504cbec97"
 
+[[package]]
+name = "clru"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbd0f76e066e64fdc5631e3bb46381254deab9ef1158292f27c8c57e3bf3fe59"
+
 [[package]]
 name = "colorchoice"
 version = "1.0.2"
@@ -705,38 +710,14 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "darling"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
-dependencies = [
- "darling_core 0.13.4",
- "darling_macro 0.13.4",
-]
-
 [[package]]
 name = "darling"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.10",
- "darling_macro 0.20.10",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
@@ -753,24 +734,13 @@ dependencies = [
  "syn 2.0.72",
 ]
 
-[[package]]
-name = "darling_macro"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
-dependencies = [
- "darling_core 0.13.4",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "darling_macro"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.20.10",
+ "darling_core",
  "quote",
  "syn 2.0.72",
 ]
@@ -928,7 +898,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59c3b24c345d8c314966bdc1832f6c2635bfcce8e7cf363bd115987bba2ee242"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -1289,9 +1259,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.159"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -1750,7 +1720,7 @@ dependencies = [
  "rustc-demangle",
  "serde",
  "serde_json",
- "serde_with 1.14.0",
+ "serde_with",
  "sha2 0.9.9",
  "sha3 0.9.1",
  "smallvec",
@@ -2073,16 +2043,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_with"
-version = "1.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff"
-dependencies = [
- "serde",
- "serde_with_macros 1.5.2",
-]
-
 [[package]]
 name = "serde_with"
 version = "3.9.0"
@@ -2097,29 +2057,17 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_json",
- "serde_with_macros 3.9.0",
+ "serde_with_macros",
  "time",
 ]
 
-[[package]]
-name = "serde_with_macros"
-version = "1.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082"
-dependencies = [
- "darling 0.13.4",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "serde_with_macros"
 version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -2226,12 +2174,6 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -2270,13 +2212,13 @@ dependencies = [
  "bincode",
  "brotli",
  "caller-env",
+ "clru",
  "derivative",
  "eyre",
  "fnv",
  "hex",
  "lazy_static",
  "libc",
- "lru",
  "num-bigint",
  "parking_lot",
  "prover",
diff --git a/arbitrator/Cargo.toml b/arbitrator/Cargo.toml
index 94ca08b..eaafb6e 100644
--- a/arbitrator/Cargo.toml
+++ b/arbitrator/Cargo.toml
@@ -24,9 +24,7 @@ repository = "https://github.com/OffchainLabs/nitro.git"
 rust-version = "1.67"
 
 [workspace.dependencies]
-cfg-if = "1.0.0"
 lazy_static = "1.4.0"
-lru = "0.12.3"
 num_enum = { version = "0.7.2", default-features = false }
 ruint2 = "1.9.0"
 wasmparser = "0.121"
diff --git a/arbitrator/arbutil/src/evm/api.rs b/arbitrator/arbutil/src/evm/api.rs
index 093e7f2..9d4c78c 100644
--- a/arbitrator/arbutil/src/evm/api.rs
+++ b/arbitrator/arbutil/src/evm/api.rs
@@ -77,7 +77,7 @@ pub trait EvmApi<D: DataReader>: Send + 'static {
     /// Reads the 32-byte value in the EVM state trie at offset `key`.
     /// Returns the value and the access cost in gas.
     /// Analogous to `vm.SLOAD`.
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64);
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64);
 
     /// Stores the given value at the given key in Stylus VM's cache of the EVM state trie.
     /// Note that the actual values only get written after calls to `set_trie_slots`.
diff --git a/arbitrator/arbutil/src/evm/mod.rs b/arbitrator/arbutil/src/evm/mod.rs
index 1671e67..36dadd9 100644
--- a/arbitrator/arbutil/src/evm/mod.rs
+++ b/arbitrator/arbutil/src/evm/mod.rs
@@ -74,9 +74,12 @@ pub const GASPRICE_GAS: u64 = GAS_QUICK_STEP;
 // vm.GasQuickStep (see jump_table.go)
 pub const ORIGIN_GAS: u64 = GAS_QUICK_STEP;
 
+pub const ARBOS_VERSION_STYLUS_CHARGING_FIXES: u64 = 32;
+
 #[derive(Clone, Copy, Debug, Default)]
 #[repr(C)]
 pub struct EvmData {
+    pub arbos_version: u64,
     pub block_basefee: Bytes32,
     pub chainid: u64,
     pub block_coinbase: Bytes20,
diff --git a/arbitrator/arbutil/src/evm/req.rs b/arbitrator/arbutil/src/evm/req.rs
index b1c8d99..0304f2d 100644
--- a/arbitrator/arbutil/src/evm/req.rs
+++ b/arbitrator/arbutil/src/evm/req.rs
@@ -7,8 +7,6 @@ use crate::{
         storage::{StorageCache, StorageWord},
         user::UserOutcomeKind,
     },
-    format::Utf8OrHex,
-    pricing::EVM_API_INK,
     Bytes20, Bytes32,
 };
 use eyre::{bail, eyre, Result};
@@ -100,13 +98,13 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApiRequestor<D, H> {
 }
 
 impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let cache = &mut self.storage_cache;
         let mut cost = cache.read_gas();
 
         let value = cache.entry(key).or_insert_with(|| {
             let (res, _, gas) = self.handler.request(EvmApiMethod::GetBytes32, key);
-            cost = cost.saturating_add(gas).saturating_add(EVM_API_INK);
+            cost = cost.saturating_add(gas).saturating_add(evm_api_gas_to_use);
             StorageWord::known(res.try_into().unwrap())
         });
         (value.value, cost)
@@ -140,8 +138,13 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         }
 
         let (res, _, cost) = self.request(EvmApiMethod::SetTrieSlots, data);
-        if res[0] != EvmApiStatus::Success.into() {
-            bail!("{}", String::from_utf8_or_hex(res));
+        let status = res
+            .first()
+            .copied()
+            .map(EvmApiStatus::from)
+            .unwrap_or(EvmApiStatus::Failure);
+        if status != EvmApiStatus::Success {
+            bail!("{:?}", status);
         }
         Ok(cost)
     }
@@ -156,8 +159,13 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         data.extend(key);
         data.extend(value);
         let (res, ..) = self.request(EvmApiMethod::SetTransientBytes32, data);
-        if res[0] != EvmApiStatus::Success.into() {
-            bail!("{}", String::from_utf8_or_hex(res));
+        let status = res
+            .first()
+            .copied()
+            .map(EvmApiStatus::from)
+            .unwrap_or(EvmApiStatus::Failure);
+        if status != EvmApiStatus::Success {
+            bail!("{:?}", status);
         }
         Ok(())
     }
@@ -290,9 +298,10 @@ impl<D: DataReader, H: RequestHandler<D>> EvmApi<D> for EvmApiRequestor<D, H> {
         let mut request = Vec::with_capacity(2 * 8 + 3 * 2 + name.len() + args.len() + outs.len());
         request.extend(start_ink.to_be_bytes());
         request.extend(end_ink.to_be_bytes());
-        request.extend((name.len() as u16).to_be_bytes());
-        request.extend((args.len() as u16).to_be_bytes());
-        request.extend((outs.len() as u16).to_be_bytes());
+        // u32 is enough to represent the slices lengths because the WASM environment runs in 32 bits.
+        request.extend((name.len() as u32).to_be_bytes());
+        request.extend((args.len() as u32).to_be_bytes());
+        request.extend((outs.len() as u32).to_be_bytes());
         request.extend(name.as_bytes());
         request.extend(args);
         request.extend(outs);
diff --git a/arbitrator/arbutil/src/types.rs b/arbitrator/arbutil/src/types.rs
index 6cf1d6c..722a89b 100644
--- a/arbitrator/arbutil/src/types.rs
+++ b/arbitrator/arbutil/src/types.rs
@@ -8,6 +8,7 @@ use std::{
     borrow::Borrow,
     fmt,
     ops::{Deref, DerefMut},
+    str::FromStr,
 };
 
 // These values must be kept in sync with `arbutil/preimage_type.go`,
@@ -83,6 +84,32 @@ impl From<usize> for Bytes32 {
     }
 }
 
+impl FromStr for Bytes32 {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // Remove the "0x" prefix if present
+        let s = s.strip_prefix("0x").unwrap_or(s);
+
+        // Pad with leading zeros if the string is shorter than 64 characters (32 bytes)
+        let padded = format!("{:0>64}", s);
+
+        // Decode the hex string using the hex crate
+        let decoded_bytes = hex::decode(padded).map_err(|_| "Invalid hex string")?;
+
+        // Ensure the decoded bytes is exactly 32 bytes
+        if decoded_bytes.len() != 32 {
+            return Err("Hex string too long for Bytes32");
+        }
+
+        // Create a 32-byte array and fill it with the decoded bytes.
+        let mut b = [0u8; 32];
+        b.copy_from_slice(&decoded_bytes);
+
+        Ok(Bytes32(b))
+    }
+}
+
 impl TryFrom<&[u8]> for Bytes32 {
     type Error = std::array::TryFromSliceError;
 
@@ -249,3 +276,77 @@ impl From<GenericBytes20> for Bytes20 {
         <[u8; 20]>::from(x).into()
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_bytes32() {
+        let b = Bytes32::from(0x12345678u32);
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_short() {
+        // Short hex string
+        let b = Bytes32::from_str("0x12345678").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_very_short() {
+        // Short hex string
+        let b = Bytes32::from_str("0x1").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0x1,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_no_prefix() {
+        // Short hex string
+        let b = Bytes32::from_str("12345678").unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_full() {
+        // Full-length hex string
+        let b =
+            Bytes32::from_str("0x0000000000000000000000000000000000000000000000000000000012345678")
+                .unwrap();
+        let expected = [
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0x12, 0x34, 0x56, 0x78,
+        ];
+        assert_eq!(b, Bytes32(expected));
+    }
+
+    #[test]
+    fn test_from_str_invalid_non_hex() {
+        let s = "0x123g5678"; // Invalid character 'g'
+        assert!(Bytes32::from_str(s).is_err());
+    }
+
+    #[test]
+    fn test_from_str_too_big() {
+        let s =
+            "0123456789ABCDEF0123456789ABCDEF01234567890123456789ABCDEF01234567890123456789ABCDEF0"; // 65 characters
+        assert!(Bytes32::from_str(s).is_err());
+    }
+}
diff --git a/arbitrator/bench/Cargo.toml b/arbitrator/bench/Cargo.toml
index 3ab5b99..74b948a 100644
--- a/arbitrator/bench/Cargo.toml
+++ b/arbitrator/bench/Cargo.toml
@@ -3,10 +3,6 @@ name = "bench"
 version = "0.1.0"
 edition = "2021"
 
-[lib]
-name = "bench"
-path = "src/lib.rs"
-
 [[bin]]
 name = "benchbin"
 path = "src/bin.rs"
@@ -20,7 +16,6 @@ clap = { version = "4.4.8", features = ["derive"] }
 gperftools = { version = "0.2.0", optional = true }
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.67"
-serde_with = { version = "3.8.1", features = ["base64"] }
 
 [features]
 counters = []
diff --git a/arbitrator/bench/src/bin.rs b/arbitrator/bench/src/bin.rs
index f7e69f5..60a7036 100644
--- a/arbitrator/bench/src/bin.rs
+++ b/arbitrator/bench/src/bin.rs
@@ -1,6 +1,5 @@
 use std::{path::PathBuf, time::Duration};
 
-use bench::prepare::*;
 use clap::Parser;
 use eyre::bail;
 
@@ -10,11 +9,12 @@ use gperftools::profiler::PROFILER;
 #[cfg(feature = "heapprof")]
 use gperftools::heap_profiler::HEAP_PROFILER;
 
-use prover::machine::MachineStatus;
-
 #[cfg(feature = "counters")]
 use prover::{machine, memory, merkle};
 
+use prover::machine::MachineStatus;
+use prover::prepare::prepare_machine;
+
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
 struct Args {
diff --git a/arbitrator/jit/src/machine.rs b/arbitrator/jit/src/machine.rs
index 2a3c5c5..02523f7 100644
--- a/arbitrator/jit/src/machine.rs
+++ b/arbitrator/jit/src/machine.rs
@@ -129,7 +129,9 @@ pub fn create(opts: &Opts, env: WasmEnv) -> (Instance, FunctionEnv<WasmEnv>, Sto
             "send_response" => func!(program::send_response),
             "create_stylus_config" => func!(program::create_stylus_config),
             "create_evm_data" => func!(program::create_evm_data),
+            "create_evm_data_v2" => func!(program::create_evm_data_v2),
             "activate" => func!(program::activate),
+            "activate_v2" => func!(program::activate_v2),
         },
     };
 
diff --git a/arbitrator/jit/src/program.rs b/arbitrator/jit/src/program.rs
index c608a3c..084afe9 100644
--- a/arbitrator/jit/src/program.rs
+++ b/arbitrator/jit/src/program.rs
@@ -16,8 +16,45 @@ use prover::{
     programs::{config::PricingParams, prelude::*},
 };
 
-/// activates a user program
+const DEFAULT_STYLUS_ARBOS_VERSION: u64 = 31;
+
 pub fn activate(
+    env: WasmEnvMut,
+    wasm_ptr: GuestPtr,
+    wasm_size: u32,
+    pages_ptr: GuestPtr,
+    asm_estimate_ptr: GuestPtr,
+    init_cost_ptr: GuestPtr,
+    cached_init_cost_ptr: GuestPtr,
+    stylus_version: u16,
+    debug: u32,
+    codehash: GuestPtr,
+    module_hash_ptr: GuestPtr,
+    gas_ptr: GuestPtr,
+    err_buf: GuestPtr,
+    err_buf_len: u32,
+) -> Result<u32, Escape> {
+    activate_v2(
+        env,
+        wasm_ptr,
+        wasm_size,
+        pages_ptr,
+        asm_estimate_ptr,
+        init_cost_ptr,
+        cached_init_cost_ptr,
+        stylus_version,
+        DEFAULT_STYLUS_ARBOS_VERSION,
+        debug,
+        codehash,
+        module_hash_ptr,
+        gas_ptr,
+        err_buf,
+        err_buf_len,
+    )
+}
+
+/// activates a user program
+pub fn activate_v2(
     mut env: WasmEnvMut,
     wasm_ptr: GuestPtr,
     wasm_size: u32,
@@ -25,7 +62,8 @@ pub fn activate(
     asm_estimate_ptr: GuestPtr,
     init_cost_ptr: GuestPtr,
     cached_init_cost_ptr: GuestPtr,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: u32,
     codehash: GuestPtr,
     module_hash_ptr: GuestPtr,
@@ -40,7 +78,15 @@ pub fn activate(
 
     let page_limit = mem.read_u16(pages_ptr);
     let gas_left = &mut mem.read_u64(gas_ptr);
-    match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) {
+    match Module::activate(
+        &wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas_left,
+    ) {
         Ok((module, data)) => {
             mem.write_u64(gas_ptr, *gas_left);
             mem.write_u16(pages_ptr, data.footprint);
@@ -222,9 +268,47 @@ pub fn create_stylus_config(
     Ok(res as u64)
 }
 
-/// Creates an `EvmData` handler from its component parts.
 pub fn create_evm_data(
+    env: WasmEnvMut,
+    block_basefee_ptr: GuestPtr,
+    chainid: u64,
+    block_coinbase_ptr: GuestPtr,
+    block_gas_limit: u64,
+    block_number: u64,
+    block_timestamp: u64,
+    contract_address_ptr: GuestPtr,
+    module_hash_ptr: GuestPtr,
+    msg_sender_ptr: GuestPtr,
+    msg_value_ptr: GuestPtr,
+    tx_gas_price_ptr: GuestPtr,
+    tx_origin_ptr: GuestPtr,
+    cached: u32,
+    reentrant: u32,
+) -> Result<u64, Escape> {
+    create_evm_data_v2(
+        env,
+        DEFAULT_STYLUS_ARBOS_VERSION,
+        block_basefee_ptr,
+        chainid,
+        block_coinbase_ptr,
+        block_gas_limit,
+        block_number,
+        block_timestamp,
+        contract_address_ptr,
+        module_hash_ptr,
+        msg_sender_ptr,
+        msg_value_ptr,
+        tx_gas_price_ptr,
+        tx_origin_ptr,
+        cached,
+        reentrant,
+    )
+}
+
+/// Creates an `EvmData` handler from its component parts.
+pub fn create_evm_data_v2(
     mut env: WasmEnvMut,
+    arbos_version: u64,
     block_basefee_ptr: GuestPtr,
     chainid: u64,
     block_coinbase_ptr: GuestPtr,
@@ -243,6 +327,7 @@ pub fn create_evm_data(
     let (mut mem, _) = env.jit_env();
 
     let evm_data = EvmData {
+        arbos_version,
         block_basefee: mem.read_bytes32(block_basefee_ptr),
         cached: cached != 0,
         chainid,
diff --git a/arbitrator/jit/src/wavmio.rs b/arbitrator/jit/src/wavmio.rs
index 062d18d..0ca666d 100644
--- a/arbitrator/jit/src/wavmio.rs
+++ b/arbitrator/jit/src/wavmio.rs
@@ -8,8 +8,6 @@ use crate::{
 };
 use arbutil::{Color, PreimageType};
 use caller_env::{GuestPtr, MemAccess};
-use sha2::Sha256;
-use sha3::{Digest, Keccak256};
 use std::{
     io,
     io::{BufReader, BufWriter, ErrorKind},
@@ -170,19 +168,25 @@ pub fn resolve_preimage_impl(
         error!("Missing requested preimage for hash {hash_hex} in {name}")
     };
 
-    // Check if preimage rehashes to the provided hash. Exclude blob preimages
-    let calculated_hash: [u8; 32] = match preimage_type {
-        PreimageType::Keccak256 => Keccak256::digest(preimage).into(),
-        PreimageType::Sha2_256 => Sha256::digest(preimage).into(),
-        PreimageType::EthVersionedHash => *hash,
-    };
-    if calculated_hash != *hash {
-        error!(
-            "Calculated hash {} of preimage {} does not match provided hash {}",
-            hex::encode(calculated_hash),
-            hex::encode(preimage),
-            hex::encode(*hash)
-        );
+    #[cfg(debug_assertions)]
+    {
+        use sha2::Sha256;
+        use sha3::{Digest, Keccak256};
+
+        // Check if preimage rehashes to the provided hash. Exclude blob preimages
+        let calculated_hash: [u8; 32] = match preimage_type {
+            PreimageType::Keccak256 => Keccak256::digest(preimage).into(),
+            PreimageType::Sha2_256 => Sha256::digest(preimage).into(),
+            PreimageType::EthVersionedHash => *hash,
+        };
+        if calculated_hash != *hash {
+            error!(
+                "Calculated hash {} of preimage {} does not match provided hash {}",
+                hex::encode(calculated_hash),
+                hex::encode(preimage),
+                hex::encode(*hash)
+            );
+        }
     }
 
     if offset % 32 != 0 {
diff --git a/arbitrator/prover/Cargo.toml b/arbitrator/prover/Cargo.toml
index 5475647..da329b1 100644
--- a/arbitrator/prover/Cargo.toml
+++ b/arbitrator/prover/Cargo.toml
@@ -19,10 +19,10 @@ num = "0.4"
 rustc-demangle = "0.1.21"
 serde = { version = "1.0.130", features = ["derive", "rc"] }
 serde_json = "1.0.67"
+serde_with = { version = "3.8.1", features = ["base64"] }
 sha3 = "0.9.1"
 static_assertions = "1.1.0"
 structopt = "0.3.23"
-serde_with = "1.12.1"
 parking_lot = "0.12.1"
 lazy_static.workspace = true
 itertools = "0.10.5"
diff --git a/arbitrator/prover/src/binary.rs b/arbitrator/prover/src/binary.rs
index aa55374..2260f6b 100644
--- a/arbitrator/prover/src/binary.rs
+++ b/arbitrator/prover/src/binary.rs
@@ -9,7 +9,9 @@ use crate::{
     },
     value::{ArbValueType, FunctionType, IntegerValType, Value},
 };
-use arbutil::{math::SaturatingSum, Bytes32, Color, DebugColor};
+use arbutil::{
+    evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES, math::SaturatingSum, Bytes32, Color, DebugColor,
+};
 use eyre::{bail, ensure, eyre, Result, WrapErr};
 use fnv::{FnvHashMap as HashMap, FnvHashSet as HashSet};
 use nom::{
@@ -641,6 +643,7 @@ impl<'a> WasmBinary<'a> {
     /// Parses and instruments a user wasm
     pub fn parse_user(
         wasm: &'a [u8],
+        arbos_version_for_gas: u64,
         page_limit: u16,
         compile: &CompileConfig,
         codehash: &Bytes32,
@@ -678,6 +681,10 @@ impl<'a> WasmBinary<'a> {
             limit!(65536, code.expr.len(), "opcodes in func body");
         }
 
+        if arbos_version_for_gas >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            limit!(513, bin.imports.len(), "imports")
+        }
+
         let table_entries = bin.tables.iter().map(|x| x.initial).saturating_sum();
         limit!(4096, table_entries, "table entries");
 
diff --git a/arbitrator/prover/src/lib.rs b/arbitrator/prover/src/lib.rs
index 0f53747..08473c2 100644
--- a/arbitrator/prover/src/lib.rs
+++ b/arbitrator/prover/src/lib.rs
@@ -11,6 +11,8 @@ pub mod machine;
 /// cbindgen:ignore
 pub mod memory;
 pub mod merkle;
+pub mod parse_input;
+pub mod prepare;
 mod print;
 pub mod programs;
 mod reinterpret;
diff --git a/arbitrator/prover/src/machine.rs b/arbitrator/prover/src/machine.rs
index 358876b..4ece1f7 100644
--- a/arbitrator/prover/src/machine.rs
+++ b/arbitrator/prover/src/machine.rs
@@ -371,13 +371,16 @@ impl Module {
         for import in &bin.imports {
             let module = import.module;
             let have_ty = &bin.types[import.offset as usize];
-            let (forward, import_name) = match import.name.strip_prefix(Module::FORWARDING_PREFIX) {
-                Some(name) => (true, name),
-                None => (false, import.name),
-            };
+            // allow_hostapi is only set for system modules like the
+            // forwarder. We restrict stripping the prefix for user modules.
+            let (forward, import_name) =
+                if allow_hostapi && import.name.starts_with(Self::FORWARDING_PREFIX) {
+                    (true, &import.name[Self::FORWARDING_PREFIX.len()..])
+                } else {
+                    (false, import.name)
+                };
 
-            let mut qualified_name = format!("{module}__{import_name}");
-            qualified_name = qualified_name.replace(&['/', '.', '-'] as &[char], "_");
+            let qualified_name = format!("{module}__{import_name}");
 
             let func = if let Some(import) = available_imports.get(&qualified_name) {
                 let call = match forward {
diff --git a/arbitrator/prover/src/main.rs b/arbitrator/prover/src/main.rs
index dba32e0..a889cc6 100644
--- a/arbitrator/prover/src/main.rs
+++ b/arbitrator/prover/src/main.rs
@@ -8,6 +8,7 @@ use eyre::{eyre, Context, Result};
 use fnv::{FnvHashMap as HashMap, FnvHashSet as HashSet};
 use prover::{
     machine::{GlobalState, InboxIdentifier, Machine, MachineStatus, PreimageResolver, ProofInfo},
+    prepare::prepare_machine,
     utils::{file_bytes, hash_preimage, CBytes},
     wavm::Opcode,
 };
@@ -86,6 +87,10 @@ struct Opts {
     skip_until_host_io: bool,
     #[structopt(long)]
     max_steps: Option<u64>,
+    // JSON inputs supercede any of the command-line inputs which could
+    // be specified in the JSON file.
+    #[structopt(long)]
+    json_inputs: Option<PathBuf>,
 }
 
 fn file_with_stub_header(path: &Path, headerlength: usize) -> Result<Vec<u8>> {
@@ -135,83 +140,8 @@ fn main() -> Result<()> {
             }
         }
     }
-    let mut inbox_contents = HashMap::default();
-    let mut inbox_position = opts.inbox_position;
-    let mut delayed_position = opts.delayed_inbox_position;
-    let inbox_header_len;
-    let delayed_header_len;
-    if opts.inbox_add_stub_headers {
-        inbox_header_len = INBOX_HEADER_LEN;
-        delayed_header_len = DELAYED_HEADER_LEN + 1;
-    } else {
-        inbox_header_len = 0;
-        delayed_header_len = 0;
-    }
-
-    for path in opts.inbox {
-        inbox_contents.insert(
-            (InboxIdentifier::Sequencer, inbox_position),
-            file_with_stub_header(&path, inbox_header_len)?,
-        );
-        println!("read file {:?} to seq. inbox {}", &path, inbox_position);
-        inbox_position += 1;
-    }
-    for path in opts.delayed_inbox {
-        inbox_contents.insert(
-            (InboxIdentifier::Delayed, delayed_position),
-            file_with_stub_header(&path, delayed_header_len)?,
-        );
-        delayed_position += 1;
-    }
 
-    let mut preimages: HashMap<PreimageType, HashMap<Bytes32, CBytes>> = HashMap::default();
-    if let Some(path) = opts.preimages {
-        let mut file = BufReader::new(File::open(path)?);
-        loop {
-            let mut ty_buf = [0u8; 1];
-            match file.read_exact(&mut ty_buf) {
-                Ok(()) => {}
-                Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
-                Err(e) => return Err(e.into()),
-            }
-            let preimage_ty: PreimageType = ty_buf[0].try_into()?;
-
-            let mut size_buf = [0u8; 8];
-            file.read_exact(&mut size_buf)?;
-            let size = u64::from_le_bytes(size_buf) as usize;
-            let mut buf = vec![0u8; size];
-            file.read_exact(&mut buf)?;
-
-            let hash = hash_preimage(&buf, preimage_ty)?;
-            preimages
-                .entry(preimage_ty)
-                .or_default()
-                .insert(hash.into(), buf.as_slice().into());
-        }
-    }
-    let preimage_resolver =
-        Arc::new(move |_, ty, hash| preimages.get(&ty).and_then(|m| m.get(&hash)).cloned())
-            as PreimageResolver;
-
-    let last_block_hash = decode_hex_arg(&opts.last_block_hash, "--last-block-hash")?;
-    let last_send_root = decode_hex_arg(&opts.last_send_root, "--last-send-root")?;
-
-    let global_state = GlobalState {
-        u64_vals: [opts.inbox_position, opts.position_within_message],
-        bytes32_vals: [last_block_hash, last_send_root],
-    };
-
-    let mut mach = Machine::from_paths(
-        &opts.libraries,
-        &opts.binary,
-        true,
-        opts.allow_hostapi,
-        opts.debug_funcs,
-        true,
-        global_state,
-        inbox_contents,
-        preimage_resolver,
-    )?;
+    let mut mach = initialize_machine(&opts)?;
 
     for path in &opts.stylus_modules {
         let err = || eyre!("failed to read module at {}", path.to_string_lossy().red());
@@ -414,6 +344,13 @@ fn main() -> Result<()> {
         });
     }
 
+    println!(
+        "End GlobalState:\n  BlockHash: {:?}\n  SendRoot: {:?}\n  Batch: {}\n  PosInBatch: {}",
+        mach.get_global_state().bytes32_vals[0],
+        mach.get_global_state().bytes32_vals[1],
+        mach.get_global_state().u64_vals[0],
+        mach.get_global_state().u64_vals[1]
+    );
     println!("End machine status: {:?}", mach.get_status());
     println!("End machine hash: {}", mach.hash());
     println!("End machine stack: {:?}", mach.get_data_stack());
@@ -462,7 +399,6 @@ fn main() -> Result<()> {
                 }
             }
         }
-
         let opts_binary = opts.binary;
         let opts_libraries = opts.libraries;
         let format_pc = |module_num: usize, func_num: usize| -> (String, String) {
@@ -543,3 +479,87 @@ fn main() -> Result<()> {
     }
     Ok(())
 }
+
+fn initialize_machine(opts: &Opts) -> eyre::Result<Machine> {
+    if let Some(json_inputs) = opts.json_inputs.clone() {
+        prepare_machine(json_inputs, opts.binary.clone())
+    } else {
+        let mut inbox_contents = HashMap::default();
+        let mut inbox_position = opts.inbox_position;
+        let mut delayed_position = opts.delayed_inbox_position;
+        let inbox_header_len;
+        let delayed_header_len;
+        if opts.inbox_add_stub_headers {
+            inbox_header_len = INBOX_HEADER_LEN;
+            delayed_header_len = DELAYED_HEADER_LEN + 1;
+        } else {
+            inbox_header_len = 0;
+            delayed_header_len = 0;
+        }
+
+        for path in opts.inbox.clone() {
+            inbox_contents.insert(
+                (InboxIdentifier::Sequencer, inbox_position),
+                file_with_stub_header(&path, inbox_header_len)?,
+            );
+            println!("read file {:?} to seq. inbox {}", &path, inbox_position);
+            inbox_position += 1;
+        }
+        for path in opts.delayed_inbox.clone() {
+            inbox_contents.insert(
+                (InboxIdentifier::Delayed, delayed_position),
+                file_with_stub_header(&path, delayed_header_len)?,
+            );
+            delayed_position += 1;
+        }
+
+        let mut preimages: HashMap<PreimageType, HashMap<Bytes32, CBytes>> = HashMap::default();
+        if let Some(path) = opts.preimages.clone() {
+            let mut file = BufReader::new(File::open(path)?);
+            loop {
+                let mut ty_buf = [0u8; 1];
+                match file.read_exact(&mut ty_buf) {
+                    Ok(()) => {}
+                    Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
+                    Err(e) => return Err(e.into()),
+                }
+                let preimage_ty: PreimageType = ty_buf[0].try_into()?;
+
+                let mut size_buf = [0u8; 8];
+                file.read_exact(&mut size_buf)?;
+                let size = u64::from_le_bytes(size_buf) as usize;
+                let mut buf = vec![0u8; size];
+                file.read_exact(&mut buf)?;
+
+                let hash = hash_preimage(&buf, preimage_ty)?;
+                preimages
+                    .entry(preimage_ty)
+                    .or_default()
+                    .insert(hash.into(), buf.as_slice().into());
+            }
+        }
+        let preimage_resolver =
+            Arc::new(move |_, ty, hash| preimages.get(&ty).and_then(|m| m.get(&hash)).cloned())
+                as PreimageResolver;
+
+        let last_block_hash = decode_hex_arg(&opts.last_block_hash, "--last-block-hash")?;
+        let last_send_root = decode_hex_arg(&opts.last_send_root, "--last-send-root")?;
+
+        let global_state = GlobalState {
+            u64_vals: [opts.inbox_position, opts.position_within_message],
+            bytes32_vals: [last_block_hash, last_send_root],
+        };
+
+        Machine::from_paths(
+            &opts.libraries,
+            &opts.binary,
+            true,
+            opts.allow_hostapi,
+            opts.debug_funcs,
+            true,
+            global_state,
+            inbox_contents,
+            preimage_resolver,
+        )
+    }
+}
diff --git a/arbitrator/prover/src/parse_input.rs b/arbitrator/prover/src/parse_input.rs
new file mode 100644
index 0000000..fa7adb4
--- /dev/null
+++ b/arbitrator/prover/src/parse_input.rs
@@ -0,0 +1,112 @@
+use arbutil::Bytes32;
+use serde::Deserialize;
+use serde_json;
+use serde_with::base64::Base64;
+use serde_with::As;
+use serde_with::DisplayFromStr;
+use std::{
+    collections::HashMap,
+    io::{self, BufRead},
+};
+
+/// prefixed_hex deserializes hex strings which are prefixed with `0x`
+///
+/// The default hex deserializer does not support prefixed hex strings.
+///
+/// It is an error to use this deserializer on a string that does not
+/// begin with `0x`.
+mod prefixed_hex {
+    use serde::{self, Deserialize, Deserializer};
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        if let Some(s) = s.strip_prefix("0x") {
+            hex::decode(s).map_err(serde::de::Error::custom)
+        } else {
+            Err(serde::de::Error::custom("missing 0x prefix"))
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct UserWasm(Vec<u8>);
+
+/// UserWasm is a wrapper around Vec<u8>
+///
+/// It is useful for decompressing a brotli-compressed wasm module.
+///
+/// Note: The wrapped Vec<u8> is already Base64 decoded before
+/// from(Vec<u8>) is called by serde.
+impl UserWasm {
+    /// as_vec returns the decompressed wasm module as a Vec<u8>
+    pub fn as_vec(&self) -> Vec<u8> {
+        self.0.clone()
+    }
+}
+
+impl AsRef<[u8]> for UserWasm {
+    fn as_ref(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+/// The Vec<u8> is compressed using brotli, and must be decompressed before use.
+impl From<Vec<u8>> for UserWasm {
+    fn from(data: Vec<u8>) -> Self {
+        let decompressed = brotli::decompress(&data, brotli::Dictionary::Empty).unwrap();
+        Self(decompressed)
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct BatchInfo {
+    pub number: u64,
+    #[serde(with = "As::<Base64>")]
+    pub data_b64: Vec<u8>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct StartState {
+    #[serde(with = "prefixed_hex")]
+    pub block_hash: Vec<u8>,
+    #[serde(with = "prefixed_hex")]
+    pub send_root: Vec<u8>,
+    pub batch: u64,
+    pub pos_in_batch: u64,
+}
+
+/// FileData is the deserialized form of the input JSON file.
+///
+/// The go JSON library in json.go uses some custom serialization and
+/// compression logic that needs to be reversed when deserializing the
+/// JSON in rust.
+///
+/// Note: It is important to change this file whenever the go JSON
+/// serialization changes.
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct FileData {
+    pub id: u64,
+    pub has_delayed_msg: bool,
+    pub delayed_msg_nr: u64,
+    #[serde(with = "As::<HashMap<DisplayFromStr, HashMap<Base64, Base64>>>")]
+    pub preimages_b64: HashMap<u32, HashMap<Bytes32, Vec<u8>>>,
+    pub batch_info: Vec<BatchInfo>,
+    #[serde(with = "As::<Base64>")]
+    pub delayed_msg_b64: Vec<u8>,
+    pub start_state: StartState,
+    #[serde(with = "As::<HashMap<DisplayFromStr, HashMap<DisplayFromStr, Base64>>>")]
+    pub user_wasms: HashMap<String, HashMap<Bytes32, UserWasm>>,
+}
+
+impl FileData {
+    pub fn from_reader<R: BufRead>(mut reader: R) -> io::Result<Self> {
+        let data = serde_json::from_reader(&mut reader)?;
+        Ok(data)
+    }
+}
diff --git a/arbitrator/prover/src/prepare.rs b/arbitrator/prover/src/prepare.rs
new file mode 100644
index 0000000..a485267
--- /dev/null
+++ b/arbitrator/prover/src/prepare.rs
@@ -0,0 +1,65 @@
+use arbutil::{Bytes32, PreimageType};
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use crate::machine::{argument_data_to_inbox, GlobalState, Machine};
+use crate::parse_input::*;
+use crate::utils::CBytes;
+
+pub fn prepare_machine(preimages: PathBuf, machines: PathBuf) -> eyre::Result<Machine> {
+    let file = File::open(preimages)?;
+    let reader = BufReader::new(file);
+
+    let data = FileData::from_reader(reader)?;
+    let preimages = data
+        .preimages_b64
+        .into_iter()
+        .flat_map(|preimage| preimage.1.into_iter())
+        .collect::<HashMap<Bytes32, Vec<u8>>>();
+    let preimage_resolver = move |_: u64, _: PreimageType, hash: Bytes32| -> Option<CBytes> {
+        preimages
+            .get(&hash)
+            .map(|data| CBytes::from(data.as_slice()))
+    };
+    let preimage_resolver = Arc::new(Box::new(preimage_resolver));
+
+    let binary_path = Path::new(&machines);
+    let mut mach = Machine::new_from_wavm(binary_path)?;
+
+    let block_hash: [u8; 32] = data.start_state.block_hash.try_into().unwrap();
+    let block_hash: Bytes32 = block_hash.into();
+    let send_root: [u8; 32] = data.start_state.send_root.try_into().unwrap();
+    let send_root: Bytes32 = send_root.into();
+    let bytes32_vals: [Bytes32; 2] = [block_hash, send_root];
+    let u64_vals: [u64; 2] = [data.start_state.batch, data.start_state.pos_in_batch];
+    let start_state = GlobalState {
+        bytes32_vals,
+        u64_vals,
+    };
+
+    for (arch, wasm) in data.user_wasms.iter() {
+        if arch != "wavm" {
+            continue;
+        }
+        for (id, wasm) in wasm.iter() {
+            mach.add_stylus_module(*id, wasm.as_vec());
+        }
+    }
+
+    mach.set_global_state(start_state);
+
+    mach.set_preimage_resolver(preimage_resolver);
+
+    let identifier = argument_data_to_inbox(0).unwrap();
+    for batch_info in data.batch_info.iter() {
+        mach.add_inbox_msg(identifier, batch_info.number, batch_info.data_b64.clone());
+    }
+
+    let identifier = argument_data_to_inbox(1).unwrap();
+    mach.add_inbox_msg(identifier, data.delayed_msg_nr, data.delayed_msg_b64);
+
+    Ok(mach)
+}
diff --git a/arbitrator/prover/src/programs/config.rs b/arbitrator/prover/src/programs/config.rs
index 1a37294..0353589 100644
--- a/arbitrator/prover/src/programs/config.rs
+++ b/arbitrator/prover/src/programs/config.rs
@@ -17,7 +17,7 @@ use {
         meter::Meter, start::StartMover, MiddlewareWrapper,
     },
     std::sync::Arc,
-    wasmer::{Cranelift, CraneliftOptLevel, Engine, Store},
+    wasmer::{Cranelift, CraneliftOptLevel, Engine, Store, Target},
     wasmer_compiler_singlepass::Singlepass,
 };
 
@@ -180,17 +180,19 @@ impl CompileConfig {
     }
 
     #[cfg(feature = "native")]
-    pub fn store(&self) -> Store {
-        let mut compiler: Box<dyn wasmer::CompilerConfig> = match self.debug.cranelift {
+    pub fn engine(&self, target: Target) -> Engine {
+        use wasmer::sys::EngineBuilder;
+
+        let mut wasmer_config: Box<dyn wasmer::CompilerConfig> = match self.debug.cranelift {
             true => {
-                let mut compiler = Cranelift::new();
-                compiler.opt_level(CraneliftOptLevel::Speed);
-                Box::new(compiler)
+                let mut wasmer_config = Cranelift::new();
+                wasmer_config.opt_level(CraneliftOptLevel::Speed);
+                Box::new(wasmer_config)
             }
             false => Box::new(Singlepass::new()),
         };
-        compiler.canonicalize_nans(true);
-        compiler.enable_verifier();
+        wasmer_config.canonicalize_nans(true);
+        wasmer_config.enable_verifier();
 
         let start = MiddlewareWrapper::new(StartMover::new(self.debug.debug_info));
         let meter = MiddlewareWrapper::new(Meter::new(&self.pricing));
@@ -200,22 +202,24 @@ impl CompileConfig {
 
         // add the instrumentation in the order of application
         // note: this must be consistent with the prover
-        compiler.push_middleware(Arc::new(start));
-        compiler.push_middleware(Arc::new(meter));
-        compiler.push_middleware(Arc::new(dygas));
-        compiler.push_middleware(Arc::new(depth));
-        compiler.push_middleware(Arc::new(bound));
+        wasmer_config.push_middleware(Arc::new(start));
+        wasmer_config.push_middleware(Arc::new(meter));
+        wasmer_config.push_middleware(Arc::new(dygas));
+        wasmer_config.push_middleware(Arc::new(depth));
+        wasmer_config.push_middleware(Arc::new(bound));
 
         if self.debug.count_ops {
             let counter = Counter::new();
-            compiler.push_middleware(Arc::new(MiddlewareWrapper::new(counter)));
+            wasmer_config.push_middleware(Arc::new(MiddlewareWrapper::new(counter)));
         }
 
-        Store::new(compiler)
+        EngineBuilder::new(wasmer_config)
+            .set_target(Some(target))
+            .into()
     }
 
     #[cfg(feature = "native")]
-    pub fn engine(&self) -> Engine {
-        self.store().engine().clone()
+    pub fn store(&self, target: Target) -> Store {
+        Store::new(self.engine(target))
     }
 }
diff --git a/arbitrator/prover/src/programs/mod.rs b/arbitrator/prover/src/programs/mod.rs
index a5df2e3..a35308e 100644
--- a/arbitrator/prover/src/programs/mod.rs
+++ b/arbitrator/prover/src/programs/mod.rs
@@ -8,7 +8,7 @@ use crate::{
     programs::config::CompileConfig,
     value::{FunctionType as ArbFunctionType, Value},
 };
-use arbutil::{math::SaturatingSum, Bytes32, Color};
+use arbutil::{evm::ARBOS_VERSION_STYLUS_CHARGING_FIXES, math::SaturatingSum, Bytes32, Color};
 use eyre::{bail, eyre, Report, Result, WrapErr};
 use fnv::FnvHashMap as HashMap;
 use std::fmt::Debug;
@@ -418,58 +418,64 @@ impl Module {
     pub fn activate(
         wasm: &[u8],
         codehash: &Bytes32,
-        version: u16,
+        stylus_version: u16,
+        arbos_version_for_gas: u64, // must only be used for activation gas
         page_limit: u16,
         debug: bool,
         gas: &mut u64,
     ) -> Result<(Self, StylusData)> {
-        // converts a number of microseconds to gas
-        // TODO: collapse to a single value after finalizing factors
-        let us_to_gas = |us: u64| {
-            let fudge = 2;
-            let sync_rate = 1_000_000 / 2;
-            let speed = 7_000_000;
-            us.saturating_mul(fudge * speed) / sync_rate
-        };
-
-        macro_rules! pay {
-            ($us:expr) => {
-                let amount = us_to_gas($us);
-                if *gas < amount {
-                    *gas = 0;
-                    bail!("out of gas");
-                }
-                *gas -= amount;
+        let compile = CompileConfig::version(stylus_version, debug);
+        let (bin, stylus_data) =
+            WasmBinary::parse_user(wasm, arbos_version_for_gas, page_limit, &compile, codehash)
+                .wrap_err("failed to parse wasm")?;
+
+        if arbos_version_for_gas > 0 {
+            // converts a number of microseconds to gas
+            // TODO: collapse to a single value after finalizing factors
+            let us_to_gas = |us: u64| {
+                let fudge = 2;
+                let sync_rate = 1_000_000 / 2;
+                let speed = 7_000_000;
+                us.saturating_mul(fudge * speed) / sync_rate
             };
-        }
-
-        // pay for wasm
-        let wasm_len = wasm.len() as u64;
-        pay!(wasm_len.saturating_mul(31_733 / 100_000));
-
-        let compile = CompileConfig::version(version, debug);
-        let (bin, stylus_data) = WasmBinary::parse_user(wasm, page_limit, &compile, codehash)
-            .wrap_err("failed to parse wasm")?;
 
-        // pay for funcs
-        let funcs = bin.functions.len() as u64;
-        pay!(funcs.saturating_mul(17_263) / 100_000);
-
-        // pay for data
-        let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64;
-        pay!(data.saturating_mul(17_376) / 100_000);
-
-        // pay for elements
-        let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64;
-        pay!(elems.saturating_mul(17_376) / 100_000);
-
-        // pay for memory
-        let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default();
-        pay!(mem.saturating_mul(2217));
-
-        // pay for code
-        let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64;
-        pay!(code.saturating_mul(535) / 1_000);
+            macro_rules! pay {
+                ($us:expr) => {
+                    let amount = us_to_gas($us);
+                    if *gas < amount {
+                        *gas = 0;
+                        bail!("out of gas");
+                    }
+                    *gas -= amount;
+                };
+            }
+
+            // pay for wasm
+            if arbos_version_for_gas >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+                let wasm_len = wasm.len() as u64;
+                pay!(wasm_len.saturating_mul(31_733) / 100_000);
+            }
+
+            // pay for funcs
+            let funcs = bin.functions.len() as u64;
+            pay!(funcs.saturating_mul(17_263) / 100_000);
+
+            // pay for data
+            let data = bin.datas.iter().map(|x| x.data.len()).saturating_sum() as u64;
+            pay!(data.saturating_mul(17_376) / 100_000);
+
+            // pay for elements
+            let elems = bin.elements.iter().map(|x| x.range.len()).saturating_sum() as u64;
+            pay!(elems.saturating_mul(17_376) / 100_000);
+
+            // pay for memory
+            let mem = bin.memories.first().map(|x| x.initial).unwrap_or_default();
+            pay!(mem.saturating_mul(2217));
+
+            // pay for code
+            let code = bin.codes.iter().map(|x| x.expr.len()).saturating_sum() as u64;
+            pay!(code.saturating_mul(535) / 1_000);
+        }
 
         let module = Self::from_user_binary(&bin, compile.debug.debug_funcs, Some(stylus_data))
             .wrap_err("failed to build user module")?;
diff --git a/arbitrator/stylus/Cargo.toml b/arbitrator/stylus/Cargo.toml
index 4717bd6..ea1d878 100644
--- a/arbitrator/stylus/Cargo.toml
+++ b/arbitrator/stylus/Cargo.toml
@@ -21,11 +21,11 @@ thiserror = "1.0.33"
 bincode = "1.3.3"
 lazy_static.workspace = true
 libc = "0.2.108"
-lru.workspace = true
 eyre = "0.6.5"
 rand = "0.8.5"
 fnv = "1.0.7"
 hex = "0.4.3"
+clru = "0.6.2"
 
 [dev-dependencies]
 num-bigint = "0.4.4"
diff --git a/arbitrator/stylus/src/cache.rs b/arbitrator/stylus/src/cache.rs
index 06739f2..c1fdaac 100644
--- a/arbitrator/stylus/src/cache.rs
+++ b/arbitrator/stylus/src/cache.rs
@@ -2,16 +2,19 @@
 // For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
 
 use arbutil::Bytes32;
+use clru::{CLruCache, CLruCacheConfig, WeightScale};
 use eyre::Result;
 use lazy_static::lazy_static;
-use lru::LruCache;
 use parking_lot::Mutex;
 use prover::programs::config::CompileConfig;
+use std::hash::RandomState;
 use std::{collections::HashMap, num::NonZeroUsize};
 use wasmer::{Engine, Module, Store};
 
+use crate::target_cache::target_native;
+
 lazy_static! {
-    static ref INIT_CACHE: Mutex<InitCache> = Mutex::new(InitCache::new(256));
+    static ref INIT_CACHE: Mutex<InitCache> = Mutex::new(InitCache::new(256 * 1024 * 1024));
 }
 
 macro_rules! cache {
@@ -20,9 +23,16 @@ macro_rules! cache {
     };
 }
 
+pub struct LruCounters {
+    pub hits: u32,
+    pub misses: u32,
+    pub does_not_fit: u32,
+}
+
 pub struct InitCache {
     long_term: HashMap<CacheKey, CacheItem>,
-    lru: LruCache<CacheKey, CacheItem>,
+    lru: CLruCache<CacheKey, CacheItem, RandomState, CustomWeightScale>,
+    lru_counters: LruCounters,
 }
 
 #[derive(Clone, Copy, Hash, PartialEq, Eq)]
@@ -46,11 +56,16 @@ impl CacheKey {
 struct CacheItem {
     module: Module,
     engine: Engine,
+    entry_size_estimate_bytes: usize,
 }
 
 impl CacheItem {
-    fn new(module: Module, engine: Engine) -> Self {
-        Self { module, engine }
+    fn new(module: Module, engine: Engine, entry_size_estimate_bytes: usize) -> Self {
+        Self {
+            module,
+            engine,
+            entry_size_estimate_bytes,
+        }
     }
 
     fn data(&self) -> (Module, Store) {
@@ -58,23 +73,66 @@ impl CacheItem {
     }
 }
 
+struct CustomWeightScale;
+impl WeightScale<CacheKey, CacheItem> for CustomWeightScale {
+    fn weight(&self, _key: &CacheKey, val: &CacheItem) -> usize {
+        // clru defines that each entry consumes (weight + 1) of the cache capacity.
+        // We subtract 1 since we only want to use the weight as the size of the entry.
+        val.entry_size_estimate_bytes.saturating_sub(1)
+    }
+}
+
+#[repr(C)]
+pub struct LruCacheMetrics {
+    pub size_bytes: u64,
+    pub count: u32,
+    pub hits: u32,
+    pub misses: u32,
+    pub does_not_fit: u32,
+}
+
+pub fn deserialize_module(
+    module: &[u8],
+    version: u16,
+    debug: bool,
+) -> Result<(Module, Engine, usize)> {
+    let engine = CompileConfig::version(version, debug).engine(target_native());
+    let module = unsafe { Module::deserialize_unchecked(&engine, module)? };
+
+    let asm_size_estimate_bytes = module.serialize()?.len();
+    // add 128 bytes for the cache item overhead
+    let entry_size_estimate_bytes = asm_size_estimate_bytes + 128;
+
+    Ok((module, engine, entry_size_estimate_bytes))
+}
+
 impl InitCache {
     // current implementation only has one tag that stores to the long_term
     // future implementations might have more, but 0 is a reserved tag
     // that will never modify long_term state
     const ARBOS_TAG: u32 = 1;
 
-    fn new(size: usize) -> Self {
+    const DOES_NOT_FIT_MSG: &'static str = "Failed to insert into LRU cache, item too large";
+
+    fn new(size_bytes: usize) -> Self {
         Self {
             long_term: HashMap::new(),
-            lru: LruCache::new(NonZeroUsize::new(size).unwrap()),
+            lru: CLruCache::with_config(
+                CLruCacheConfig::new(NonZeroUsize::new(size_bytes).unwrap())
+                    .with_scale(CustomWeightScale),
+            ),
+            lru_counters: LruCounters {
+                hits: 0,
+                misses: 0,
+                does_not_fit: 0,
+            },
         }
     }
 
-    pub fn set_lru_size(size: u32) {
+    pub fn set_lru_capacity(capacity_bytes: u64) {
         cache!()
             .lru
-            .resize(NonZeroUsize::new(size.try_into().unwrap()).unwrap())
+            .resize(NonZeroUsize::new(capacity_bytes.try_into().unwrap()).unwrap())
     }
 
     /// Retrieves a cached value, updating items as necessary.
@@ -89,8 +147,11 @@ impl InitCache {
 
         // See if the item is in the LRU cache, promoting if so
         if let Some(item) = cache.lru.get(&key) {
-            return Some(item.data());
+            let data = item.data();
+            cache.lru_counters.hits += 1;
+            return Some(data);
         }
+        cache.lru_counters.misses += 1;
         None
     }
 
@@ -114,20 +175,24 @@ impl InitCache {
             if long_term_tag == Self::ARBOS_TAG {
                 cache.long_term.insert(key, item.clone());
             } else {
-                cache.lru.promote(&key)
+                // only calls get to move the key to the head of the LRU list
+                cache.lru.get(&key);
             }
             return Ok(item.data());
         }
         drop(cache);
 
-        let engine = CompileConfig::version(version, debug).engine();
-        let module = unsafe { Module::deserialize_unchecked(&engine, module)? };
+        let (module, engine, entry_size_estimate_bytes) =
+            deserialize_module(module, version, debug)?;
 
-        let item = CacheItem::new(module, engine);
+        let item = CacheItem::new(module, engine, entry_size_estimate_bytes);
         let data = item.data();
         let mut cache = cache!();
         if long_term_tag != Self::ARBOS_TAG {
-            cache.lru.put(key, item);
+            if cache.lru.put_with_weight(key, item).is_err() {
+                cache.lru_counters.does_not_fit += 1;
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            };
         } else {
             cache.long_term.insert(key, item);
         }
@@ -142,7 +207,9 @@ impl InitCache {
         let key = CacheKey::new(module_hash, version, debug);
         let mut cache = cache!();
         if let Some(item) = cache.long_term.remove(&key) {
-            cache.lru.put(key, item);
+            if cache.lru.put_with_weight(key, item).is_err() {
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            }
         }
     }
 
@@ -153,7 +220,48 @@ impl InitCache {
         let mut cache = cache!();
         let cache = &mut *cache;
         for (key, item) in cache.long_term.drain() {
-            cache.lru.put(key, item); // not all will fit, just a heuristic
+            // not all will fit, just a heuristic
+            if cache.lru.put_with_weight(key, item).is_err() {
+                eprintln!("{}", Self::DOES_NOT_FIT_MSG);
+            }
         }
     }
+
+    pub fn get_lru_metrics() -> LruCacheMetrics {
+        let mut cache = cache!();
+
+        let count = cache.lru.len();
+        let metrics = LruCacheMetrics {
+            // add 1 to each entry to account that we subtracted 1 in the weight calculation
+            size_bytes: (cache.lru.weight() + count).try_into().unwrap(),
+
+            count: count.try_into().unwrap(),
+
+            hits: cache.lru_counters.hits,
+            misses: cache.lru_counters.misses,
+            does_not_fit: cache.lru_counters.does_not_fit,
+        };
+
+        // Empty counters.
+        // go side, which is the only consumer of this function besides tests,
+        // will read those counters and increment its own prometheus counters with them.
+        cache.lru_counters = LruCounters {
+            hits: 0,
+            misses: 0,
+            does_not_fit: 0,
+        };
+
+        metrics
+    }
+
+    // only used for testing
+    pub fn clear_lru_cache() {
+        let mut cache = cache!();
+        cache.lru.clear();
+        cache.lru_counters = LruCounters {
+            hits: 0,
+            misses: 0,
+            does_not_fit: 0,
+        };
+    }
 }
diff --git a/arbitrator/stylus/src/lib.rs b/arbitrator/stylus/src/lib.rs
index 3c53359..abea428 100644
--- a/arbitrator/stylus/src/lib.rs
+++ b/arbitrator/stylus/src/lib.rs
@@ -11,13 +11,14 @@ use arbutil::{
     format::DebugBytes,
     Bytes32,
 };
-use cache::InitCache;
+use cache::{deserialize_module, InitCache, LruCacheMetrics};
 use evm_api::NativeRequestHandler;
 use eyre::ErrReport;
 use native::NativeInstance;
 use prover::programs::{prelude::*, StylusData};
 use run::RunProgram;
 use std::{marker::PhantomData, mem, ptr};
+use target_cache::{target_cache_get, target_cache_set};
 
 pub use brotli;
 pub use prover;
@@ -29,6 +30,7 @@ pub mod run;
 
 mod cache;
 mod evm_api;
+mod target_cache;
 mod util;
 
 #[cfg(test)]
@@ -122,9 +124,9 @@ impl RustBytes {
     }
 }
 
-/// Instruments and "activates" a user wasm.
+/// "activates" a user wasm.
 ///
-/// The `output` is either the serialized asm & module pair or an error string.
+/// The `output` is either the module or an error string.
 /// Returns consensus info such as the module hash and footprint on success.
 ///
 /// Note that this operation costs gas and is limited by the amount supplied via the `gas` pointer.
@@ -137,10 +139,10 @@ impl RustBytes {
 pub unsafe extern "C" fn stylus_activate(
     wasm: GoSliceData,
     page_limit: u16,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: bool,
     output: *mut RustBytes,
-    asm_len: *mut usize,
     codehash: *const Bytes32,
     module_hash: *mut Bytes32,
     stylus_data: *mut StylusData,
@@ -152,18 +154,105 @@ pub unsafe extern "C" fn stylus_activate(
     let codehash = &*codehash;
     let gas = &mut *gas;
 
-    let (asm, module, info) =
-        match native::activate(wasm, codehash, version, page_limit, debug, gas) {
-            Ok(val) => val,
-            Err(err) => return output.write_err(err),
-        };
-    *asm_len = asm.len();
+    let (module, info) = match native::activate(
+        wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas,
+    ) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err),
+    };
+
     *module_hash = module.hash();
     *stylus_data = info;
 
-    let mut data = asm;
-    data.extend(&*module.into_bytes());
-    output.write(data);
+    output.write(module.into_bytes());
+    UserOutcomeKind::Success
+}
+
+/// "compiles" a user wasm.
+///
+/// The `output` is either the asm or an error string.
+/// Returns consensus info such as the module hash and footprint on success.
+///
+/// # Safety
+///
+/// `output` must not be null.
+#[no_mangle]
+pub unsafe extern "C" fn stylus_compile(
+    wasm: GoSliceData,
+    version: u16,
+    debug: bool,
+    name: GoSliceData,
+    output: *mut RustBytes,
+) -> UserOutcomeKind {
+    let wasm = wasm.slice();
+    let output = &mut *output;
+    let name = match String::from_utf8(name.slice().to_vec()) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err.into()),
+    };
+    let target = match target_cache_get(&name) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err),
+    };
+
+    let asm = match native::compile(wasm, version, debug, target) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err),
+    };
+
+    output.write(asm);
+    UserOutcomeKind::Success
+}
+
+#[no_mangle]
+/// # Safety
+///
+/// `output` must not be null.
+pub unsafe extern "C" fn wat_to_wasm(wat: GoSliceData, output: *mut RustBytes) -> UserOutcomeKind {
+    let output = &mut *output;
+    let wasm = match wasmer::wat2wasm(wat.slice()) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err.into()),
+    };
+    output.write(wasm.into_owned());
+    UserOutcomeKind::Success
+}
+
+/// sets target index to a string
+///
+/// String format is: Triple+CpuFeature+CpuFeature..
+///
+/// # Safety
+///
+/// `output` must not be null.
+#[no_mangle]
+pub unsafe extern "C" fn stylus_target_set(
+    name: GoSliceData,
+    description: GoSliceData,
+    output: *mut RustBytes,
+    native: bool,
+) -> UserOutcomeKind {
+    let output = &mut *output;
+    let name = match String::from_utf8(name.slice().to_vec()) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err.into()),
+    };
+
+    let desc_str = match String::from_utf8(description.slice().to_vec()) {
+        Ok(val) => val,
+        Err(err) => return output.write_err(err.into()),
+    };
+
+    if let Err(err) = target_cache_set(name, desc_str, native) {
+        return output.write_err(err);
+    };
+
     UserOutcomeKind::Success
 }
 
@@ -220,10 +309,10 @@ pub unsafe extern "C" fn stylus_call(
     status
 }
 
-/// resize lru
+/// set lru cache capacity
 #[no_mangle]
-pub extern "C" fn stylus_cache_lru_resize(size: u32) {
-    InitCache::set_lru_size(size);
+pub extern "C" fn stylus_set_cache_lru_capacity(capacity_bytes: u64) {
+    InitCache::set_lru_capacity(capacity_bytes);
 }
 
 /// Caches an activated user program.
@@ -274,3 +363,32 @@ pub unsafe extern "C" fn stylus_drop_vec(vec: RustBytes) {
         mem::drop(vec.into_vec())
     }
 }
+
+/// Gets lru cache metrics.
+#[no_mangle]
+pub extern "C" fn stylus_get_lru_cache_metrics() -> LruCacheMetrics {
+    InitCache::get_lru_metrics()
+}
+
+/// Clears lru cache.
+/// Only used for testing purposes.
+#[no_mangle]
+pub extern "C" fn stylus_clear_lru_cache() {
+    InitCache::clear_lru_cache()
+}
+
+/// Gets lru entry size in bytes.
+/// Only used for testing purposes.
+#[no_mangle]
+pub extern "C" fn stylus_get_lru_entry_size_estimate_bytes(
+    module: GoSliceData,
+    version: u16,
+    debug: bool,
+) -> u64 {
+    match deserialize_module(module.slice(), version, debug) {
+        Err(error) => panic!("tried to get invalid asm!: {error}"),
+        Ok((_, _, lru_entry_size_estimate_bytes)) => {
+            lru_entry_size_estimate_bytes.try_into().unwrap()
+        }
+    }
+}
diff --git a/arbitrator/stylus/src/native.rs b/arbitrator/stylus/src/native.rs
index a7b996e..516c660 100644
--- a/arbitrator/stylus/src/native.rs
+++ b/arbitrator/stylus/src/native.rs
@@ -4,7 +4,7 @@
 use crate::{
     cache::InitCache,
     env::{MeterData, WasmEnv},
-    host, util,
+    host,
 };
 use arbutil::{
     evm::{
@@ -33,11 +33,13 @@ use std::{
     ops::{Deref, DerefMut},
 };
 use wasmer::{
-    imports, AsStoreMut, Function, FunctionEnv, Instance, Memory, Module, Pages, Store,
+    imports, AsStoreMut, Function, FunctionEnv, Instance, Memory, Module, Pages, Store, Target,
     TypedFunction, Value, WasmTypeList,
 };
 use wasmer_vm::VMExtern;
 
+use crate::target_cache::target_native;
+
 #[derive(Debug)]
 pub struct NativeInstance<D: DataReader, E: EvmApi<D>> {
     pub instance: Instance,
@@ -98,7 +100,7 @@ impl<D: DataReader, E: EvmApi<D>> NativeInstance<D, E> {
         evm_data: EvmData,
     ) -> Result<Self> {
         let env = WasmEnv::new(compile, None, evm, evm_data);
-        let store = env.compile.store();
+        let store = env.compile.store(target_native());
         let module = unsafe { Module::deserialize_unchecked(&store, module)? };
         Self::from_module(module, store, env)
     }
@@ -137,9 +139,10 @@ impl<D: DataReader, E: EvmApi<D>> NativeInstance<D, E> {
         evm_data: EvmData,
         compile: &CompileConfig,
         config: StylusConfig,
+        target: Target,
     ) -> Result<Self> {
         let env = WasmEnv::new(compile.clone(), Some(config), evm_api, evm_data);
-        let store = env.compile.store();
+        let store = env.compile.store(target);
         let wat_or_wasm = std::fs::read(path)?;
         let module = Module::new(&store, wat_or_wasm)?;
         Self::from_module(module, store, env)
@@ -347,8 +350,8 @@ impl<D: DataReader, E: EvmApi<D>> StartlessMachine for NativeInstance<D, E> {
     }
 }
 
-pub fn module(wasm: &[u8], compile: CompileConfig) -> Result<Vec<u8>> {
-    let mut store = compile.store();
+pub fn module(wasm: &[u8], compile: CompileConfig, target: Target) -> Result<Vec<u8>> {
+    let mut store = compile.store(target);
     let module = Module::new(&store, wasm)?;
     macro_rules! stub {
         (u8 <- $($types:tt)+) => {
@@ -428,7 +431,6 @@ pub fn module(wasm: &[u8], compile: CompileConfig) -> Result<Vec<u8>> {
         imports.define("console", "tee_f64", stub!(f64 <- |_: f64|));
         imports.define("debug", "null_host", stub!(||));
     }
-    Instance::new(&mut store, &module, &imports)?;
 
     let module = module.serialize()?;
     Ok(module.to_vec())
@@ -437,18 +439,26 @@ pub fn module(wasm: &[u8], compile: CompileConfig) -> Result<Vec<u8>> {
 pub fn activate(
     wasm: &[u8],
     codehash: &Bytes32,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     page_limit: u16,
     debug: bool,
     gas: &mut u64,
-) -> Result<(Vec<u8>, ProverModule, StylusData)> {
-    let compile = CompileConfig::version(version, debug);
-    let (module, stylus_data) =
-        ProverModule::activate(wasm, codehash, version, page_limit, debug, gas)?;
+) -> Result<(ProverModule, StylusData)> {
+    let (module, stylus_data) = ProverModule::activate(
+        wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas,
+    )?;
+
+    Ok((module, stylus_data))
+}
 
-    let asm = match self::module(wasm, compile) {
-        Ok(asm) => asm,
-        Err(err) => util::panic_with_wasm(wasm, err),
-    };
-    Ok((asm, module, stylus_data))
+pub fn compile(wasm: &[u8], version: u16, debug: bool, target: Target) -> Result<Vec<u8>> {
+    let compile = CompileConfig::version(version, debug);
+    self::module(wasm, compile, target)
 }
diff --git a/arbitrator/stylus/src/target_cache.rs b/arbitrator/stylus/src/target_cache.rs
new file mode 100644
index 0000000..a1d6382
--- /dev/null
+++ b/arbitrator/stylus/src/target_cache.rs
@@ -0,0 +1,81 @@
+// Copyright 2022-2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+use eyre::{eyre, OptionExt, Result};
+use lazy_static::lazy_static;
+use parking_lot::RwLock;
+use std::{collections::HashMap, str::FromStr};
+use wasmer_types::{CpuFeature, Target, Triple};
+
+lazy_static! {
+    static ref TARGET_CACHE: RwLock<HashMap<String, Target>> = RwLock::new(HashMap::new());
+    static ref TARGET_NATIVE: RwLock<Target> = RwLock::new(Target::default());
+}
+
+fn target_from_string(input: String) -> Result<Target> {
+    if input.is_empty() {
+        return Ok(Target::default());
+    }
+    let mut parts = input.split('+');
+
+    let Some(triple_string) = parts.next() else {
+        return Err(eyre!("no architecture"));
+    };
+
+    let triple = match Triple::from_str(triple_string) {
+        Ok(val) => val,
+        Err(e) => return Err(eyre!(e)),
+    };
+
+    let mut features = CpuFeature::set();
+    for flag in parts {
+        features.insert(CpuFeature::from_str(flag)?);
+    }
+
+    Ok(Target::new(triple, features))
+}
+
+/// Populates `TARGET_CACHE` inserting target specified by `description` under `name` key.
+/// Additionally, if `native` is set it sets `TARGET_NATIVE` to the specified target.
+pub fn target_cache_set(name: String, description: String, native: bool) -> Result<()> {
+    let target = target_from_string(description)?;
+
+    if native {
+        if !target.is_native() {
+            return Err(eyre!("arch not native"));
+        }
+        let flags_not_supported = Target::default()
+            .cpu_features()
+            .complement()
+            .intersection(*target.cpu_features());
+        if !flags_not_supported.is_empty() {
+            let mut err_message = String::new();
+            err_message.push_str("cpu flags not supported on local cpu for: ");
+            for item in flags_not_supported.iter() {
+                err_message.push('+');
+                err_message.push_str(&item.to_string());
+            }
+            return Err(eyre!(err_message));
+        }
+        *TARGET_NATIVE.write() = target.clone();
+    }
+
+    TARGET_CACHE.write().insert(name, target);
+
+    Ok(())
+}
+
+pub fn target_native() -> Target {
+    TARGET_NATIVE.read().clone()
+}
+
+pub fn target_cache_get(name: &str) -> Result<Target> {
+    if name.is_empty() {
+        return Ok(TARGET_NATIVE.read().clone());
+    }
+    TARGET_CACHE
+        .read()
+        .get(name)
+        .cloned()
+        .ok_or_eyre("arch not set")
+}
diff --git a/arbitrator/stylus/src/test/api.rs b/arbitrator/stylus/src/test/api.rs
index 92d7317..66d600a 100644
--- a/arbitrator/stylus/src/test/api.rs
+++ b/arbitrator/stylus/src/test/api.rs
@@ -14,6 +14,7 @@ use eyre::Result;
 use parking_lot::Mutex;
 use prover::programs::{memory::MemoryModel, prelude::*};
 use std::{collections::HashMap, sync::Arc};
+use wasmer::Target;
 
 use super::TestInstance;
 
@@ -53,7 +54,7 @@ impl TestEvmApi {
     pub fn deploy(&mut self, address: Bytes20, config: StylusConfig, name: &str) -> Result<()> {
         let file = format!("tests/{name}/target/wasm32-unknown-unknown/release/{name}.wasm");
         let wasm = std::fs::read(file)?;
-        let module = native::module(&wasm, self.compile.clone())?;
+        let module = native::module(&wasm, self.compile.clone(), Target::default())?;
         self.contracts.lock().insert(address, module);
         self.configs.lock().insert(address, config);
         Ok(())
@@ -67,7 +68,7 @@ impl TestEvmApi {
 }
 
 impl EvmApi<VecReader> for TestEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let storage = &mut self.storage.lock();
         let storage = storage.get_mut(&self.program).unwrap();
         let value = storage.get(&key).cloned().unwrap_or_default();
diff --git a/arbitrator/stylus/src/test/misc.rs b/arbitrator/stylus/src/test/misc.rs
index ae44a88..92c4394 100644
--- a/arbitrator/stylus/src/test/misc.rs
+++ b/arbitrator/stylus/src/test/misc.rs
@@ -9,12 +9,12 @@ use crate::{
 };
 use eyre::Result;
 use prover::programs::{prelude::*, start::StartMover};
-use wasmer::{imports, Function};
+use wasmer::{imports, Function, Target};
 
 #[test]
 fn test_bulk_memory() -> Result<()> {
     let (compile, config, ink) = test_configs();
-    let mut store = compile.store();
+    let mut store = compile.store(Target::default());
     let filename = "../prover/test-cases/bulk-memory.wat";
     let imports = imports! {
         "env" => {
diff --git a/arbitrator/stylus/src/test/mod.rs b/arbitrator/stylus/src/test/mod.rs
index 236e563..00c9c62 100644
--- a/arbitrator/stylus/src/test/mod.rs
+++ b/arbitrator/stylus/src/test/mod.rs
@@ -16,7 +16,7 @@ use rand::prelude::*;
 use std::{collections::HashMap, path::Path, sync::Arc};
 use wasmer::{
     imports, wasmparser::Operator, CompilerConfig, Function, FunctionEnv, Imports, Instance,
-    Module, Store,
+    Module, Store, Target,
 };
 use wasmer_compiler_singlepass::Singlepass;
 
@@ -33,7 +33,7 @@ type TestInstance = NativeInstance<VecReader, TestEvmApi>;
 
 impl TestInstance {
     fn new_test(path: &str, compile: CompileConfig) -> Result<Self> {
-        let mut store = compile.store();
+        let mut store = compile.store(Target::default());
         let imports = imports! {
             "test" => {
                 "noop" => Function::new_typed(&mut store, || {}),
@@ -86,7 +86,14 @@ impl TestInstance {
         config: StylusConfig,
     ) -> Result<(Self, TestEvmApi)> {
         let (mut evm, evm_data) = TestEvmApi::new(compile.clone());
-        let native = Self::from_path(path, evm.clone(), evm_data, compile, config)?;
+        let native = Self::from_path(
+            path,
+            evm.clone(),
+            evm_data,
+            compile,
+            config,
+            Target::default(),
+        )?;
         let footprint = native.memory().ty(&native.store).minimum.0 as u16;
         evm.set_pages(footprint);
         Ok((native, evm))
diff --git a/arbitrator/stylus/src/test/native.rs b/arbitrator/stylus/src/test/native.rs
index 503e587..9669932 100644
--- a/arbitrator/stylus/src/test/native.rs
+++ b/arbitrator/stylus/src/test/native.rs
@@ -381,7 +381,7 @@ fn test_storage() -> Result<()> {
 
     let (mut native, mut evm) = TestInstance::new_with_evm(filename, &compile, config)?;
     run_native(&mut native, &store_args, ink)?;
-    assert_eq!(evm.get_bytes32(key.into()).0, Bytes32(value));
+    assert_eq!(evm.get_bytes32(key.into(), 0).0, Bytes32(value));
     assert_eq!(run_native(&mut native, &load_args, ink)?, value);
 
     let mut machine = Machine::from_user_path(Path::new(filename), &compile)?;
@@ -465,7 +465,7 @@ fn test_calls() -> Result<()> {
     run_native(&mut native, &args, ink)?;
 
     for (key, value) in slots {
-        assert_eq!(evm.get_bytes32(key).0, value);
+        assert_eq!(evm.get_bytes32(key, 0).0, value);
     }
     Ok(())
 }
diff --git a/arbitrator/stylus/tests/erc20/Cargo.lock b/arbitrator/stylus/tests/erc20/Cargo.lock
index c3e2159..f5e1e0b 100644
--- a/arbitrator/stylus/tests/erc20/Cargo.lock
+++ b/arbitrator/stylus/tests/erc20/Cargo.lock
@@ -575,9 +575,9 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "0.37.23"
+version = "0.37.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
+checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
 dependencies = [
  "bitflags",
  "errno",
diff --git a/arbitrator/stylus/tests/write-result-len.wat b/arbitrator/stylus/tests/write-result-len.wat
new file mode 100644
index 0000000..4c9ad35
--- /dev/null
+++ b/arbitrator/stylus/tests/write-result-len.wat
@@ -0,0 +1,24 @@
+;; Copyright 2024, Offchain Labs, Inc.
+;; For license information, see https://github.com/nitro/blob/master/LICENSE
+
+(module
+    (import "vm_hooks" "read_args"    (func $read_args    (param i32)))
+    (import "vm_hooks" "write_result" (func $write_result (param i32 i32)))
+    (memory (export "memory") 2 2)
+    (func $main (export "user_entrypoint") (param $args_len i32) (result i32)
+        (local $len i32)
+
+        ;; write args to 0x0
+        (call $read_args (i32.const 0))
+
+        ;; treat first 4 bytes as size to write
+        (i32.load (i32.const 0))
+        local.set $len
+
+        ;; call write
+        (call $write_result (i32.const 0) (local.get $len))
+
+        ;; return success
+        i32.const 0
+    )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/.config/nextest.toml b/arbitrator/tools/module_roots/wasmer/.config/nextest.toml
new file mode 100644
index 0000000..3d30908
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.config/nextest.toml
@@ -0,0 +1,10 @@
+[profile.ci]
+# Print out output for failing tests as soon as they fail, and also at the end
+# of the run (for easy scrollability).
+failure-output = "immediate-final"
+# Do not cancel the test run on the first failure.
+fail-fast = false
+# Automatically mark a test as "slow" after 60 seconds, then kill it after 180s
+slow-timeout = { period = "60s", terminate-after = 3 }
+# Retry a couple times in case there are flaky tests
+retries = 3
diff --git a/arbitrator/tools/module_roots/wasmer/.devcontainer/Dockerfile b/arbitrator/tools/module_roots/wasmer/.devcontainer/Dockerfile
new file mode 100644
index 0000000..0db8981
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.devcontainer/Dockerfile
@@ -0,0 +1 @@
+FROM rust:1
diff --git a/arbitrator/tools/module_roots/wasmer/.devcontainer/devcontainer.json b/arbitrator/tools/module_roots/wasmer/.devcontainer/devcontainer.json
new file mode 100644
index 0000000..775daa3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.devcontainer/devcontainer.json
@@ -0,0 +1,18 @@
+{
+	"name": "Wasmer dev environment",
+	"dockerFile": "Dockerfile",
+
+	// Set *default* container specific settings.json values on container create.
+	"settings": {
+		"terminal.integrated.shell.linux": "/bin/bash",
+		"lldb.executable": "/usr/bin/lldb"
+	},
+
+	// Add the IDs of extensions you want installed when the container is created.
+	"extensions": [
+		"rust-lang.rust-analyzer",
+		"dtsvet.vscode-wasm",
+		"bungcip.better-toml",
+		"vadimcn.vscode-lldb"
+	]
+}
diff --git a/arbitrator/tools/module_roots/wasmer/.gitattributes b/arbitrator/tools/module_roots/wasmer/.gitattributes
new file mode 100644
index 0000000..6486387
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.gitattributes
@@ -0,0 +1,4 @@
+CHANGELOG.md merge=union
+*.wast linguist-vendored
+*.wat linguist-vendored
+scene*.txt -text
diff --git a/arbitrator/tools/module_roots/wasmer/.github/CODEOWNERS b/arbitrator/tools/module_roots/wasmer/.github/CODEOWNERS
new file mode 100644
index 0000000..1508856
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/CODEOWNERS
@@ -0,0 +1,23 @@
+benches                            @syrusakbary
+examples                           
+fuzz                               @syrusakbary
+lib/api                            @syrusakbary
+lib/c-api                          
+lib/cache                          @syrusakbary
+lib/cli                            @syrusakbary
+lib/compiler                       @syrusakbary
+lib/compiler-cranelift             @syrusakbary
+lib/compiler-llvm                  
+lib/compiler-singlepass            @syrusakbary
+lib/deprecated                     
+lib/emscripten                     
+lib/engine                         @syrusakbary
+lib/engine-jit                     @syrusakbary
+lib/engine-native                  @syrusakbary
+lib/engine-object-file             @syrusakbary
+lib/object                         @syrusakbary
+lib/vm                             @syrusakbary
+lib/wasi                           
+lib/wasmer-types                   @syrusakbary
+scripts                            @syrusakbary
+tests                              
diff --git a/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---bug-report.md b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---bug-report.md
new file mode 100644
index 0000000..6d6491e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---bug-report.md
@@ -0,0 +1,50 @@
+---
+name: "\U0001F41E Bug report"
+about: Create a report to help us improve
+title: ''
+labels: "\U0001F41E bug"
+assignees: ''
+
+---
+
+<!-- Thanks for the bug report! -->
+
+### Describe the bug
+
+<!--
+A clear and concise description of what the bug is.
+
+Copy and paste the result of executing the following in your shell, so we can know the version of wasmer, Rust (if available) and architecture of your environment.
+-->
+
+```sh
+wasmer -vV; rustc -vV
+```
+
+
+### Steps to reproduce
+<!--
+Include steps that will help us recreate the issue.
+
+For example,
+1. Go to '…'
+2. Compile with '…'
+3. Run '…'
+4. See error
+
+If applicable, add a link to a test case (as a zip file or link to a repository we can clone).
+-->
+
+### Expected behavior
+<!-- A clear and concise description of what you expected to happen. -->
+
+### Actual behavior
+
+<!--
+A clear and concise description of what actually happened.
+
+If applicable, add screenshots to help explain your problem.
+-->
+
+### Additional context
+<!-- Add any other context about the problem here. -->
diff --git a/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---feature-request.md b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---feature-request.md
new file mode 100644
index 0000000..be57463
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/---feature-request.md
@@ -0,0 +1,26 @@
+---
+name: "\U0001F389 Feature request"
+about: Suggest an idea for this project
+title: ''
+labels: "\U0001F389 enhancement"
+assignees: ''
+
+---
+
+Thanks for proposing a new feature!
+
+### Motivation
+
+A clear and concise description of what the motivation for the new feature is, and what problem it is solving.
+
+### Proposed solution
+
+A clear and concise description of the feature you would like to add, and how it solves the motivating problem.
+
+### Alternatives
+
+A clear and concise description of any alternative solutions or features you've considered, and why you're proposed solution is better.
+
+### Additional context
+
+Add any other context or screenshots about the feature request here.
diff --git a/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/--question.md b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/--question.md
new file mode 100644
index 0000000..ad79ab2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/ISSUE_TEMPLATE/--question.md
@@ -0,0 +1,16 @@
+---
+name: "❓ Question"
+about: Ask a question about this project
+title: ''
+labels: "❓ question"
+assignees: ''
+
+---
+
+### Summary
+
+A clear and concise summary of your question.
+
+### Additional details
+
+Provide any additional details here.
diff --git a/arbitrator/tools/module_roots/wasmer/.github/cross-linux-aarch64/Dockerfile b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-aarch64/Dockerfile
new file mode 100644
index 0000000..88b177a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-aarch64/Dockerfile
@@ -0,0 +1,11 @@
+FROM rust:1
+#FROM ghcr.io/cross-rs/aarch64-unknown-linux-gnu:edge
+
+# set CROSS_DOCKER_IN_DOCKER to inform `cross` that it is executed from within a container
+ENV CROSS_DOCKER_IN_DOCKER=true
+
+RUN cargo install cross
+RUN dpkg --add-architecture arm64 && \
+    apt-get update && \
+    apt-get install -qy curl && \
+    curl -sSL https://get.docker.com/ | sh
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/Dockerfile b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/Dockerfile
new file mode 100644
index 0000000..b158afb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/Dockerfile
@@ -0,0 +1,70 @@
+FROM debian:stable AS openssl_riscv64
+#FROM ghcr.io/cross-rs/riscv64gc-unknown-linux-gnu:edge AS openssl_riscv64
+
+# set CROSS_DOCKER_IN_DOCKER to inform `cross` that it is executed from within a container
+ENV CROSS_DOCKER_IN_DOCKER=true
+
+RUN apt-get update  && \
+    apt-get install --assume-yes --no-install-recommends \
+    ca-certificates \
+    curl \
+    cpio \
+    sharutils \
+    gnupg \
+    build-essential \
+    libc6-dev
+
+#COPY install_deb.sh /
+
+#install libssl-dev for riscv64!
+#RUN /install_deb.sh riscv64 libssl-dev
+#RUN dpkg --add-architecture riscv64
+#RUN apt-get update
+#RUN apt-get install libssl-dev:riscv64
+#ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR=/usr/include
+#ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR=/usr/lib/riscv64-linux-gnu
+
+
+# install rust tools
+RUN curl --proto "=https" --tlsv1.2 --retry 3 -sSfL https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+RUN rustup -v toolchain install 1.73
+# add docker the manual way
+COPY install_docker.sh /
+RUN /install_docker.sh
+
+RUN apt-get update && \
+    apt-get install --assume-yes --no-install-recommends \
+    docker-ce \
+    docker-ce-cli \
+    containerd.io \
+    docker-buildx-plugin \
+    docker-compose-plugin
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gcc-riscv64-linux-gnu \
+    g++-riscv64-linux-gnu \
+    qemu-user-static \
+    libssl-dev \
+    pkg-config \
+    libc6-dev-riscv64-cross
+
+ENV CROSS_TOOLCHAIN_PREFIX=riscv64-linux-gnu-
+ENV CROSS_SYSROOT=/usr/riscv64-linux-gnu
+ENV CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER="$CROSS_TOOLCHAIN_PREFIX"gcc \
+    AR_riscv64gc_unknown_linux_gnu="$CROSS_TOOLCHAIN_PREFIX"ar \
+    CC_riscv64gc_unknown_linux_gnu="$CROSS_TOOLCHAIN_PREFIX"gcc \
+    CXX_riscv64gc_unknown_linux_gnu="$CROSS_TOOLCHAIN_PREFIX"g++ \
+    CFLAGS_riscv64gc_unknown_linux_gnu="-march=rv64gc -mabi=lp64d" \
+    BINDGEN_EXTRA_CLANG_ARGS_riscv64gc_unknown_linux_gnu="--sysroot=$CROSS_SYSROOT" \
+    QEMU_LD_PREFIX="$CROSS_SYSROOT" \
+    RUST_TEST_THREADS=1 \
+    PKG_CONFIG_PATH="/usr/lib/riscv64-linux-gnu/pkgconfig/:${PKG_CONFIG_PATH}"
+
+RUN rustup target add riscv64gc-unknown-linux-gnu --toolchain 1.73-x86_64-unknown-linux-gnu
+
+#compile libssl-dev for riscv64!
+COPY build_openssl.sh /
+RUN /build_openssl.sh
+ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR=/openssl_riscv64/include
+ENV RISCV64GC_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR=/openssl_riscv64/lib
diff --git a/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/build_openssl.sh b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/build_openssl.sh
new file mode 100755
index 0000000..f42adc1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/build_openssl.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+set -x
+set -euo pipefail
+
+apt-get install wget
+
+wget https://www.openssl.org/source/openssl-3.1.1.tar.gz
+
+tar xf openssl-3.1.1.tar.gz
+rm openssl-3.1.1.tar.gz
+cd openssl-3.1.1
+
+AR=riscv64-linux-gnu-ar NM=riscv64-linux-gnu-nm CC=riscv64-linux-gnu-gcc \
+   ./Configure -static no-asm no-tests --prefix=/openssl_riscv64 linux64-riscv64
+
+make -j
+make install
diff --git a/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_deb.sh b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_deb.sh
new file mode 100755
index 0000000..20f3e36
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_deb.sh
@@ -0,0 +1,57 @@
+#!/bin/bash
+set -x
+set -euo pipefail
+
+arch="${1}"
+shift
+
+# need to install certain local dependencies
+export DEBIAN_FRONTEND=noninteractive
+apt-get update
+apt-get install --assume-yes --no-install-recommends \
+  ca-certificates \
+  curl \
+  cpio \
+  sharutils \
+  debian-ports-archive-keyring \
+  gnupg
+
+# Add port from bookworm to get some riscv packages
+debsource="deb http://deb.debian.org/debian-ports unstable main"
+
+# temporarily use debian sources rather than ubuntu.
+touch /etc/apt/sources.list
+mv /etc/apt/sources.list /etc/apt/sources.list.bak
+echo -e "${debsource}" > /etc/apt/sources.list
+
+dpkg --add-architecture "${arch}" || echo "foreign-architecture ${arch}" \
+  > /etc/dpkg/dpkg.cfg.d/multiarch
+
+## Add Debian keys.
+#curl --retry 3 -sSfL 'https://ftp-master.debian.org/keys/archive-key-{11,12}.asc' -O
+#curl --retry 3 -sSfL 'https://ftp-master.debian.org/keys/archive-key-{11,12}-security.asc' -O
+#curl --retry 3 -sSfL 'https://ftp-master.debian.org/keys/release-{11,12}.asc' -O
+#curl --retry 3 -sSfL 'https://www.ports.debian.org/archive_{2023}.key' -O
+#
+#for key in *.asc *.key; do
+#  apt-key add "${key}"
+#  rm "${key}"
+#done
+
+# allow apt-get to retry downloads
+echo 'APT::Acquire::Retries "3";' > /etc/apt/apt.conf.d/80-retries
+
+apt-get update
+for dep in $@; do
+  apt-get install "${dep}:${arch}" --assume-yes
+done
+
+# restore our old sources list
+mv -f /etc/apt/sources.list.bak /etc/apt/sources.list
+if [ -f /etc/dpkg/dpkg.cfg.d/multiarch.bak ]; then
+    mv /etc/dpkg/dpkg.cfg.d/multiarch.bak /etc/dpkg/dpkg.cfg.d/multiarch
+fi
+
+# can fail if arch is used (amd64 and/or i386)
+dpkg --remove-architecture "${arch}" || true
+apt-get update
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_docker.sh b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_docker.sh
new file mode 100755
index 0000000..ea7e7ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/cross-linux-riscv64/install_docker.sh
@@ -0,0 +1,11 @@
+#!/bin/bash
+set -x
+set -euo pipefail
+
+mkdir -m 0755 -p /etc/apt/keyrings
+curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+
+echo \
+  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
+  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
+  tee /etc/apt/sources.list.d/docker.list > /dev/null
diff --git a/arbitrator/tools/module_roots/wasmer/.github/pull_request_template.md b/arbitrator/tools/module_roots/wasmer/.github/pull_request_template.md
new file mode 100644
index 0000000..96866a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/pull_request_template.md
@@ -0,0 +1,11 @@
+<!-- 
+Prior to submitting a PR, review the CONTRIBUTING.md document for recommendations on how to test:
+https://github.com/wasmerio/wasmer/blob/master/CONTRIBUTING.md#pull-requests
+
+-->
+
+# Description
+<!-- 
+Provide details regarding the change including motivation,
+links to related issues, and the context of the PR.
+-->
diff --git a/arbitrator/tools/module_roots/wasmer/.github/s3-cache-cleanup.py b/arbitrator/tools/module_roots/wasmer/.github/s3-cache-cleanup.py
new file mode 100755
index 0000000..c28d7a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/s3-cache-cleanup.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+
+# Deletes all objects in an S3 bucket that are older than a given number of days.
+# Used for cleaning up the custom Github Actions cache.
+
+import boto3
+import datetime
+import os
+
+# Define the S3 bucket name and the number of days to retain objects
+days_to_retain = 7
+
+bucket_name = os.environ['AWS_BUCKET_NAME']
+access_key = os.environ['AWS_ACCESS_KEY_ID']
+secret_key = os.environ['AWS_SECRET_ACCESS_KEY']
+endpoint = os.environ['AWS_ENDPOINT']
+
+# Create a connection to the S3 service
+s3 = boto3.resource('s3',
+  endpoint_url = endpoint,
+  aws_access_key_id = access_key,
+  aws_secret_access_key = secret_key,
+  region_name = 'auto',
+)
+
+bucket = s3.Bucket(bucket_name)
+
+# Calculate the retention date.
+cutoff_date = (datetime.datetime.now() - datetime.timedelta(days=days_to_retain))
+cutoff_date = cutoff_date.replace(tzinfo=datetime.timezone.utc)
+
+print(f'Deleting all objects in bucket {bucket_name} older than {cutoff_date}...')
+
+total_count = 0
+deleted_count = 0
+
+for obj in bucket.objects.all():
+    total_count += 1
+    if obj.last_modified < cutoff_date:
+        print(f'Deleting {obj.key}...')
+        obj.delete()
+        deleted_count += 1
+
+print(f'Complete! Deleted {deleted_count} objects out of a total {total_count}.')
diff --git a/arbitrator/tools/module_roots/wasmer/.github/stale.yml b/arbitrator/tools/module_roots/wasmer/.github/stale.yml
new file mode 100644
index 0000000..f992c78
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/stale.yml
@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 365
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 30
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - "🐞 bug"
+# Label to use when marking an issue as stale
+staleLabel: "🏚 stale"
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: >
+  Feel free to reopen the issue if it has been closed by mistake.
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/benchmark.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/benchmark.yaml
new file mode 100644
index 0000000..ae78b55
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/benchmark.yaml
@@ -0,0 +1,75 @@
+name: Run Benchmarks and upload results
+
+on:
+  push:
+    branches:
+    - benchmark  # TODO: change it back to master once we really track the results. We commented this as speed.wasmer.io is failing
+
+env:
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
+  MSRV: "1.73"
+
+jobs:
+  run_benchmark:
+    name: Benchmark on ${{ matrix.build }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        build: [linux]
+        include:
+          - build: linux
+            os: ubuntu-latest
+    env:
+      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
+      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+      - name: Configure cargo data directory
+        # After this point, all cargo registry and crate data is stored in
+        # $GITHUB_WORKSPACE/.cargo_home. This allows us to cache only the files
+        # that are needed during the build process. Additionally, this works
+        # around a bug in the 'cache' action that causes directories outside of
+        # the workspace dir to be saved/restored incorrectly.
+        run: echo "CARGO_HOME=$(pwd)/.cargo_home" >> $GITHUB_ENV
+      - name: Cache
+        uses: actions/cache@master
+        with:
+          # Note: crates from the git repo always get rebuilt
+          # so we cache only those subdirectories of target/{debug|release} that
+          # contain the build output for crates that come from the registry.
+          path: |-
+            .cargo_home
+            target/*/.*
+            target/*/build
+            target/*/deps
+          key: ${{ matrix.os }}-${{ hashFiles('Cargo.lock') }}
+          restore-keys: |
+            ${{ matrix.os }}
+      - name: Install LLVM (Linux)
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.0/clang+llvm-10.0.0-x86_64-linux-gnu-ubuntu-18.04.tar.xz -L -o llvm.tar.xz
+          mkdir -p /opt/llvm-10
+          tar xf llvm.tar.xz --strip-components=1 -C /opt/llvm-10
+          echo '/opt/llvm-10/bin' >> $GITHUB_PATH
+          echo 'name=LLVM_SYS_100_PREFIX=/opt/llvm-10' >> $GITHUB_ENV
+      - name: Install Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.8
+      - name: Install Python dependencies
+        run: |
+          pip install codespeed-client
+          pip install toml
+      - name: Run Benchmark
+        run: |
+          make bench
+          git clone https://github.com/wasmerio/wasmer-bench
+
+          python3 wasmer-bench/send_metrics.py
+
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/build.yml b/arbitrator/tools/module_roots/wasmer/.github/workflows/build.yml
new file mode 100644
index 0000000..a46e46f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/build.yml
@@ -0,0 +1,607 @@
+name: Builds
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
+  MSRV: "1.73"
+
+on:
+  push:
+    branches:
+      - 'master'
+    tags:
+      # this is _not_ a regex, see: https://docs.github.com/en/actions/reference/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet
+      - '[0-9]+.[0-9]+.[0-9]+*'
+  workflow_dispatch:
+    inputs:
+      release:
+          description: 'Make release'
+jobs:
+  setup:
+    name: Set up
+    runs-on: ubuntu-latest
+    outputs:
+      VERSION: ${{ steps.setup.outputs.VERSION }}
+      DOING_RELEASE: ${{ steps.setup.outputs.DOING_RELEASE }}
+    steps:
+      - name: Set up env vars
+        id: setup
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF/refs\/tags\//}
+          echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
+          DOING_RELEASE=$(echo $VERSION | grep -c '^[0-9]\+\.[0-9]\+\.[0-9]\+\(-\([a-zA-Z]\+\)\?[0-9]*\)\?$' || true)
+          echo "DOING_RELEASE=${DOING_RELEASE}" >> $GITHUB_OUTPUT
+          echo $VERSION
+          echo $DOING_RELEASE
+
+  build:
+    name: Build on ${{ matrix.build }}
+    runs-on: ${{ matrix.os }}
+    needs: setup
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - build: linux-x64
+            os: ubuntu-20.04
+            artifact_name: 'wasmer-linux-amd64'
+            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-linux-amd64.tar.xz'
+            cross_compilation_artifact_name: 'cross_compiled_from_linux'
+            use_sccache: false
+            use_llvm: true
+            build_wasm: true
+          - build: macos-x64
+            os: macos-11
+            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-darwin-amd64.tar.xz'
+            artifact_name: 'wasmer-darwin-amd64'
+            cross_compilation_artifact_name: 'cross_compiled_from_mac'
+            use_sccache: false
+            use_llvm: true
+            build_wasm: false
+          - build: macos-arm64
+            os: macos-14
+            target: aarch64-apple-darwin
+            artifact_name: 'wasmer-darwin-arm64'
+            use_sccache: false
+            use_llvm: false
+            build_wasm: false
+          - build: windows-x64
+            os: windows-2019
+            artifact_name: 'wasmer-windows-amd64'
+            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
+            cross_compilation_artifact_name: 'cross_compiled_from_win'
+            use_sccache: false
+            use_llvm: true
+            build_wasm: false
+          - build: linux-musl-x64
+            os: ubuntu-latest
+            artifact_name: 'wasmer-linux-musl-amd64'
+            #llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-linux-amd64.tar.xz'
+            container: alpine:latest
+            use_sccache: false
+            use_llvm: false
+            build_wasm: true
+    container: ${{ matrix.container }}
+    env:
+      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
+      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+      TARGET: ${{ matrix.target }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up base deps on musl
+        if: matrix.build == 'linux-musl-x64'
+        run: ./scripts/alpine-linux-install-deps.sh
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+        if: matrix.use_sccache != true
+      - name: Install LLVM (macOS Apple Silicon)
+        if: matrix.os == 'macos-11.0' && !matrix.llvm_url
+        run: |
+          brew install llvm
+      - name: Install LLVM
+        if: matrix.llvm_url
+        shell: bash
+        run: |
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir -p ${LLVM_DIR}
+          curl --proto '=https' --tlsv1.2 -sSf "${{ matrix.llvm_url }}" -L -o - | tar xJv -C ${LLVM_DIR}
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+        env:
+          LLVM_DIR: .llvm
+      - name: Configure LLVM (Windows)
+        # The Custom Windows build does not contains llvm-config.exe, so need to setup manualy here
+        if: matrix.build == 'windows-x64' && matrix.llvm_url
+        shell: bash
+        run: |
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          echo LLVM_SYS_150_PREFIX="${LLVM_DIR}" >> $GITHUB_ENV
+          echo LLVM_ENABLE=1 >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+      - name: Set up dependencies for Mac OS
+        run: |
+          brew install automake
+          # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
+          brew install gnu-tar
+          echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
+        if: matrix.os == 'macos-latest' || matrix.os == 'macos-11.0'
+      - uses: actions/cache@v2
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: ${{ matrix.build }}-${{ matrix.target }}-cargo-${{ hashFiles('Cargo.lock') }}-v1
+      - uses: actions/cache@v2
+        if: matrix.use_sccache
+        with:
+          path: ${{ runner.tool_cache }}/cargo-sccache
+          key: ${{ matrix.build }}-${{ matrix.target }}-sccache-bin-${{ env.CARGO_SCCACHE_VERSION }}-v1
+      - name: Install sccache
+        if: matrix.use_sccache
+        run: |
+          if [ ! -f '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' ]; then
+            cargo install sccache --no-default-features --features=dist-client,azure --root '${{ runner.tool_cache }}/cargo-sccache'
+          fi
+        shell: bash
+      - name: Setup Rust target
+        run: |
+          mkdir -p .cargo
+          cat << EOF > .cargo/config.toml
+          [build]
+          target = "${{ matrix.target }}"
+          EOF
+        if: matrix.target
+      - name: Set sccache port
+        if: matrix.use_sccache && matrix.random_sccache_port
+        run: |
+          netstat -aln | awk '
+            $6 == "LISTEN" {
+              if ($4 ~ "[.:][0-9]+$") {
+                n = split($4, a, /[:.]/);
+                port = a[n];
+                p[port] = 1
+              }
+            }
+            END {
+              for (i = 3000; i < 65000 && p[i]; i++){};
+              if (i == 65000) {exit 1};
+              print "SCCACHE_SERVER_PORT=" i
+            }
+          ' >> $GITHUB_ENV
+          # echo "SCCACHE_SERVER_PORT=9000"
+          echo "Setting random sccache port to: $SCCACHE_SERVER_PORT"
+        shell: bash
+      - name: Start sccache
+        if: matrix.use_sccache
+        run: |
+          chmod +x '${{ runner.tool_cache }}/cargo-sccache/bin/sccache'
+          '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' --start-server
+          '${{ runner.tool_cache }}/cargo-sccache/bin/sccache' -s
+          echo 'RUSTC_WRAPPER=${{ runner.tool_cache }}/cargo-sccache/bin/sccache' >> $GITHUB_ENV
+        shell: bash
+      - name: Build C API headless
+        shell: bash
+        run: |
+          make package-capi-headless
+      - name: Build C API
+        shell: bash
+        run: |
+          make build-capi
+      - name: Build Wasmer binary with LLVM
+        if: matrix.use_llvm
+        shell: bash
+        run: |
+          make build-wasmer
+        env:
+          ENABLE_LLVM: 1
+      - name: Build Wasmer binary without LLVM
+        if: matrix.use_llvm != true
+        shell: bash
+        run: |
+          make build-wasmer
+     #- name: Build Wasmer binary on Wasm32-WASI without LLVM
+     #  if: matrix.build_wasm
+     #  shell: bash
+     #  run: |
+     #    make build-wasmer-wasm
+      - name: Install Nightly Rust for Headless
+        if: matrix.build != 'linux-musl-x64'
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "nightly-2023-10-05"
+          target: ${{ matrix.target }}
+          components: "rust-src"
+      - name: Build Minimal Wasmer Headless
+        if: matrix.build != 'linux-musl-x64'
+        run: |
+          cargo install xargo
+          echo "" >> Cargo.toml
+          echo "[profile.release]" >> Cargo.toml
+          echo "opt-level = 'z'" >> Cargo.toml
+          echo "debug = false" >> Cargo.toml
+          echo "debug-assertions = false" >> Cargo.toml
+          echo "overflow-checks = false" >> Cargo.toml
+          echo "lto = true" >> Cargo.toml
+          echo "panic = 'abort'" >> Cargo.toml
+          echo "incremental = false" >> Cargo.toml
+          echo "codegen-units = 1" >> Cargo.toml
+          echo "rpath = false" >> Cargo.toml
+          rustup override set nightly-2023-10-05
+          make build-wasmer-headless-minimal
+          rustup override unset
+      - name: Dist
+        run: |
+          make distribution
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ matrix.artifact_name }}
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  windows_gnu:
+    name: Windows GNU
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Windows-GNU linker
+        shell: bash
+        run: |
+          sudo apt install -y mingw-w64
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: x86_64-pc-windows-gnu
+      - name: Install Windows-GNU target
+        shell: bash
+        run: |
+          rustup target add x86_64-pc-windows-gnu
+      - name: Install Windows 10 SDK with xwin
+        shell: bash
+        run: |
+          mkdir -p /tmp/xwin
+          mkdir -p /tmp/xwindownload
+          mkdir -p /tmp/xwincache
+          git clone https://github.com/wasmerio/xwin --depth=1 /tmp/xwin
+          cargo build --release --manifest-path=/tmp/xwin/Cargo.toml
+          /tmp/xwin/target/release/xwin --accept-license --cache-dir /tmp/xwincache splat --output /tmp/xwindownload
+          mkdir -p /tmp/winsdk
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/WS2_32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/KERNEL32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/BCRYPT.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/ADVAPI32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/USERENV.lib /tmp/winsdk/
+          echo "WinSDK files:"
+          ls -laH /tmp/winsdk
+          echo ""
+          mkdir -p package
+          mkdir -p package/winsdk
+          cp -r /tmp/winsdk/* package/winsdk
+      - name: Build Wasmer C-API without LLVM
+        shell: bash
+        run: |
+          make build-capi
+        env:
+          RUSTFLAGS: -Cpanic=abort
+          CARGO_TARGET: x86_64-pc-windows-gnu
+          ENABLE_LLVM: 0
+      - name: Build Wasmer C-API headless without LLVM
+        shell: bash
+        run: |
+          make build-capi-headless
+        env:
+          RUSTFLAGS: -Cpanic=abort
+          CARGO_TARGET: x86_64-pc-windows-gnu
+          ENABLE_LLVM: 0
+      - name: Dist
+        run: |
+          make distribution-gnu
+        env:
+          CARGO_TARGET: x86_64-pc-windows-gnu
+          TARGET_DIR: target/x86_64-pc-windows-gnu/release
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: 'wasmer-windows-gnu64'
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  darwin_aarch64_jsc:
+    name: macOS aarch64 (JSC)
+    runs-on: macos-11.0
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: aarch64-apple-darwin
+      - name: Install Darwin-aarch64 target
+        shell: bash
+        run: |
+          rustup target add aarch64-apple-darwin
+      - name: Build Wasmer C-API (JSC)
+        shell: bash
+        run: |
+          make build-capi-jsc
+        env:
+          RUSTFLAGS: -Cpanic=abort
+          CARGO_TARGET: aarch64-apple-darwin
+      - name: Dist
+        run: |
+          make distribution
+        env:
+          CARGO_TARGET: aarch64-apple-darwin
+          TARGET_DIR: target/aarch64-apple-darwin/release
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: 'aarch64-apple-darwin-jsc'
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  darwin_x86_64_jsc:
+    name: macOS x86_64 (JSC)
+    runs-on: macos-11.0
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: x86_64-apple-darwin
+      - name: Build Wasmer C-API (JSC)
+        shell: bash
+        run: |
+          make build-capi-jsc
+        env:
+          RUSTFLAGS: -Cpanic=abort
+          CARGO_TARGET: x86_64-apple-darwin
+      - name: Dist
+        run: |
+          make distribution
+        env:
+          CARGO_TARGET: x86_64-apple-darwin
+          TARGET_DIR: target/x86_64-apple-darwin/release
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: 'x86_64-apple-darwin-jsc'
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  linux_aarch64:
+    name: Linux aarch64
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: aarch64-unknown-linux-gnu
+      - name: Build cross image
+        run: |
+          docker build -t wasmer/aarch64 ${GITHUB_WORKSPACE}/.github/cross-linux-aarch64/
+        env:
+          CROSS_DOCKER_IN_DOCKER: true
+      - name: Build Wasmer binary
+        run: |
+          make build-wasmer
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+      - name: Build C API headless
+        shell: bash
+        run: |
+          make package-capi-headless
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+          TARGET: aarch64-unknown-linux-gnu
+          TARGET_DIR: target/aarch64-unknown-linux-gnu/release
+      - name: Build C API
+        run: |
+          make build-capi
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+      - name: Dist
+        run: |
+          make distribution
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          TARGET: aarch64-unknown-linux-gnu
+          TARGET_DIR: target/aarch64-unknown-linux-gnu/release
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: wasmer-linux-aarch64
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  linux_riscv64:
+    name: Linux riscv64
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          target: riscv64gc-unknown-linux-gnu
+      - name: Build cross image
+        run: |
+          docker build -t wasmer/riscv64 ${GITHUB_WORKSPACE}/.github/cross-linux-riscv64/
+        env:
+          CROSS_DOCKER_IN_DOCKER: true
+      - name: Build Wasmer binary
+        run: |
+          make build-wasmer
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64:latest cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+      - name: Build C API headless
+        shell: bash
+        run: |
+          make package-capi-headless
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64:latest cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+          TARGET: riscv64gc-unknown-linux-gnu
+          TARGET_DIR: target/riscv64gc-unknown-linux-gnu/release
+      - name: Build C API
+        run: |
+          make build-capi
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64:latest cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+      - name: Dist
+        run: |
+          make distribution
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64:latest cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          TARGET: riscv64gc-unknown-linux-gnu
+          TARGET_DIR: target/riscv64gc-unknown-linux-gnu/release
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: wasmer-linux-riscv64
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  release:
+    needs: [setup, build, linux_aarch64, windows_gnu, linux_riscv64]
+    runs-on: ubuntu-latest
+    if: needs.setup.outputs.DOING_RELEASE == '1' || github.event.inputs.release != ''
+    steps:
+      - name: Download the Artifacts
+        uses: actions/download-artifact@v2
+        with:
+          path: artifacts
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ needs.setup.outputs.VERSION }}
+          release_name: Release ${{ needs.setup.outputs.VERSION }}
+          draft: true
+          prerelease: false
+      - name: Upload Release Asset Windows Installer
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-windows-amd64/WasmerInstaller.exe
+          asset_name: wasmer-windows.exe
+          asset_content_type: application/vnd.microsoft.portable-executable
+      - name: Upload Release Asset Windows
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-windows-amd64/wasmer.tar.gz
+          asset_name: wasmer-windows-amd64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Linux amd64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-linux-amd64/wasmer.tar.gz
+          asset_name: wasmer-linux-amd64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Linux aarch64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-linux-aarch64/wasmer.tar.gz
+          asset_name: wasmer-linux-aarch64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Linux riscv64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-linux-riscv64/wasmer.tar.gz
+          asset_name: wasmer-linux-riscv64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Windows gnu64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-windows-gnu64/wasmer.tar.gz
+          asset_name: wasmer-windows-gnu64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Linux amd64 (musl)
+        id: upload-release-asset-linux-musl-amd64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-linux-musl-amd64/wasmer.tar.gz
+          asset_name: wasmer-linux-musl-amd64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Mac amd64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-darwin-amd64/wasmer.tar.gz
+          asset_name: wasmer-darwin-amd64.tar.gz
+          asset_content_type: application/gzip
+      - name: Upload Release Asset Mac arm64
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: artifacts/wasmer-darwin-arm64/wasmer.tar.gz
+          asset_name: wasmer-darwin-arm64.tar.gz
+          asset_content_type: application/gzip
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/cache-bucket-cleanup.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/cache-bucket-cleanup.yaml
new file mode 100644
index 0000000..03ae072
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/cache-bucket-cleanup.yaml
@@ -0,0 +1,29 @@
+# Cleans up the custom Github Actions cache bucket.
+
+name: Actions Cache Bucket Cleanup
+
+on:
+  schedule:
+    # Run once a day.
+    - cron: "0 3 * * *"
+
+     # A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  # This workflow contains a single job called "cron"
+  cron:
+    # The type of runner that the job will run on
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install boto3 library
+        run: pip install boto3
+      - name: Clone repository
+        uses: actions/checkout@v3
+      - name: Run cleanup
+        env:
+          AWS_ENDPOINT: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          AWS_ACCESS_KEY_ID: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          AWS_BUCKET_NAME: wasmer-rust-artifacts-cache
+        run: |
+          ./.github/s3-cache-cleanup.py
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/check-public-api.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/check-public-api.yaml
new file mode 100644
index 0000000..fe2ff30
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/check-public-api.yaml
@@ -0,0 +1,47 @@
+name: Check public API
+
+env:
+  RUST_BACKTRACE: 1
+on:
+  workflow_dispatch:
+    inputs:
+      compareMasterWithVersion:
+        required: false
+        description: 'Version to compare with (i.e. "1.0.2")'
+jobs:
+  setup:
+    name: Set up
+    runs-on: ubuntu-latest
+    outputs:
+      VERSION: ${{ steps.setup.outputs.VERSION }}
+      SHOULD_CHECK_API: ${{ steps.setup.outputs.SHOULD_CHECK_API }}
+    steps:
+      
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Install latest nightly
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: nightly
+            profile: minimal
+            override: true
+
+      - name: Generate API change report
+        shell: bash
+        run: |
+          cargo install cargo-public-api
+          CARGO_LATEST_VERSION = git tag --list | tail -n 1
+          LATEST_VERSION=${INPUT_COMPAREMASTERWITHVERSION:=$CARGO_LATEST_VERSION}
+          cargo public-api --manifest-path=lib/api/Cargo.toml --diff-git-checkouts $LATEST_VERSION master > diff.txt
+      
+      - name: Archive change report
+        uses: actions/upload-artifact@v3
+        with:
+          name: api-diff-report
+          path: |
+            diff.txt
+
+
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/cloudcompiler.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/cloudcompiler.yaml
new file mode 100644
index 0000000..2c82c07
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/cloudcompiler.yaml
@@ -0,0 +1,78 @@
+name: Release cloudcompiler.wasm
+
+env:
+  RUST_BACKTRACE: 1
+  MSRV: "1.73"
+
+on:
+  push:
+    tags:
+      # trigger action on release branch
+      - '[0-9]+.[0-9]+.[0-9]+*'
+  workflow_dispatch:
+
+jobs:
+  setup:
+    name: Set up
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: ${{ matrix.target }}
+      - name: Install wasm32-wasi target
+        shell: bash
+        run: |
+          rustup target add wasm32-wasi
+      - name: Setup Wasmer
+        uses: wasmerio/setup-wasmer@v1
+      - name: Build cloudcompiler.wasm
+        shell: bash
+        run: |
+          make build-wasmer-wasm &&
+          mkdir target/wasm32-wasi/release/cloudcompiler
+          cp target/wasm32-wasi/release/wasmer-compiler.wasm target/wasm32-wasi/release/cloudcompiler/cloudcompiler.wasm &&
+          cat << EOF > target/wasm32-wasi/release/cloudcompiler/wasmer.toml
+          [package]
+          name = "${{ secrets.WAPM_DEV_USERNAME }}/cloudcompiler"
+          version = "0.1.0"
+          description = "cloudcompiler.wasm"
+          license = "MIT"
+          repository = "https://github.com/wasmerio/wasmer"
+
+          [[module]]
+          name = "cloudcompiler"
+          source = "cloudcompiler.wasm"
+          abi = "wasi"
+
+          [module.interfaces]
+          wasi = "0.1.0-unstable"
+
+          [[command]]
+          name = "cloudcompiler"
+          module = "cloudcompiler"
+          EOF
+      - name: Fix wasmer.toml version
+        run: |
+          echo $(git tag | tail -n1) > ./version.txt
+          v=$(git describe --tags --abbrev=0) && \
+          echo "version = ${v}" &&
+          sed -i "s/version = \".*\"/version = \"${v}\"/g" target/wasm32-wasi/release/cloudcompiler/wasmer.toml \
+      - name: Build cloudcompiler.wasm
+        shell: bash
+        run: |
+          git tag &&
+          cat target/wasm32-wasi/release/cloudcompiler/wasmer.toml &&
+          echo "ls" &&
+          ls target/wasm32-wasi/release/cloudcompiler
+      - name: Publish to WAPM
+        uses: wasmerio/wapm-publish@v1
+        with:
+          registry: https://registry.wapm.dev
+          directory: target/wasm32-wasi/release/cloudcompiler
+          username: ${{ secrets.WAPM_DEV_USERNAME }}
+          password: ${{ secrets.WAPM_DEV_PASSWORD }}
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/documentation.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/documentation.yaml
new file mode 100644
index 0000000..c13e09d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/documentation.yaml
@@ -0,0 +1,40 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - 'master'
+    paths:
+      - 'lib/**'
+
+env:
+  MSRV: "1.73"
+
+jobs:
+  documentation:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+      - name: Install LLVM
+        shell: bash
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf ${{ env.LLVM_URL }} -L -o llvm.tar.xz
+          mkdir ${{ env.LLVM_DIR }}
+          tar xf llvm.tar.xz --strip-components=1 -C ${{ env.LLVM_DIR }}
+          echo "${{ env.LLVM_DIR }}/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_120_PREFIX=${{ env.LLVM_DIR }}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: ${{ github.workspace }}/llvm-13
+          LLVM_URL: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-13.0.0/clang+llvm-13.0.0-x86_64-linux-gnu-ubuntu-16.04.tar.xz'
+      - name: Build & package documentation
+        run: make package-docs
+      - name: Publish documentation
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./package/docs
diff --git a/arbitrator/tools/module_roots/wasmer/.github/workflows/test.yaml b/arbitrator/tools/module_roots/wasmer/.github/workflows/test.yaml
new file mode 100644
index 0000000..573f712
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.github/workflows/test.yaml
@@ -0,0 +1,825 @@
+name: test-sys
+
+on:
+  push:
+    branches:
+      - master
+      - 'with-ci-.*'
+      - 'v3.0.x'
+      - 'v3.1.x'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      release:
+          description: 'Make release'
+
+# Automatically cancel previous workflow runs when a new commit is pushed.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  RUST_BACKTRACE: 1
+  # Sparse will be enabled by dtolnay/rust-toolchain when installing nightly
+  # Rust, but it's not stable on 1.69 yet. By explicitly setting the protocol we
+  # can override that behaviour
+  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: git
+  MSRV: "1.73"
+  NEXTEST_PROFILE: "ci"
+
+jobs:
+
+  setup:
+    name: Set up
+    runs-on: ubuntu-22.04
+    outputs:
+      VERSION: ${{ steps.setup.outputs.VERSION }}
+      DOING_RELEASE: ${{ steps.setup.outputs.DOING_RELEASE }}
+    steps:
+      - name: Set up env vars
+        id: setup
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF/refs\/tags\//}
+          echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT
+          DOING_RELEASE=$(echo $VERSION | grep -c '^[0-9]\+\.[0-9]\+\.[0-9]\+\(-\([a-zA-Z]\+\)\?[0-9]*\)\?$' || true)
+          echo "DOING_RELEASE=${DOING_RELEASE}" >> $GITHUB_OUTPUT
+          echo $VERSION
+          echo $DOING_RELEASE
+
+  lint:
+    name: Code lint
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          components: rustfmt, clippy
+      - name: Install libtinfo
+        shell: bash
+        run: |
+          sudo apt install -y libtinfo5
+      - name: Install LLVM (Linux)
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz -L -o /opt/llvm.tar.xz
+          mkdir -p /opt/llvm-15
+          tar xf /opt/llvm.tar.xz --strip-components=1 -C /opt/llvm-15
+          echo '/opt/llvm-15/bin' >> $GITHUB_PATH
+          echo 'LLVM_SYS_150_PREFIX=/opt/llvm-15' >> $GITHUB_ENV
+      - name: Cache
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-lint-linux-x64
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
+      - run: make lint
+        env:
+          ENABLE_CRANELIFT: "1"
+          ENABLE_LLVM: "1"
+          ENABLE_SINGLEPASS: "1"
+      - name: Assert no files have changed
+        run: |
+          git status
+          ! [[ $(git status -s) ]]
+
+  cargo_deny:
+    name: cargo-deny
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - uses: EmbarkStudios/cargo-deny-action@v1
+        with:
+          log-level: error
+
+  test_nodejs:
+    name: Test on NodeJS
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+      - name: Install NodeJS
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - name: Install wasm-pack
+        run: |
+          curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+      - name: make test-js
+        run: |
+          make test-js
+
+  test_wasi_fyi:
+    name: Test wasi-fyi
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: nightly
+          targets: "wasm32-wasi"
+      - name: Install wasm-pack
+        run: |
+          curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+      - name: make test-wasi-fyi
+        run: |
+          make test-wasi-fyi
+
+      # The no_std functionality doesn't work at the moment - no point in testing it.
+      # - name: make test-js-core
+      #   run: |
+      #     make test-js-core
+
+  test_wasm_build:
+    name: Test wasm build
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - name: rustup target add wasm32-wasi
+        run: rustup target add wasm32-wasi
+      - name: make build-wasmer-wasm
+        run: make build-wasmer-wasm
+
+  test_build_jsc:
+    name: Test JSC build
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: x86_64-unknown-linux-gnu
+      - name: Install NodeJS
+        uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - name: Install libjavascriptcoregtk-4.0-dev
+        run: sudo apt update && sudo apt install -y libjavascriptcoregtk-4.0-dev
+      - name: make build-wasmer-jsc
+        run: make build-wasmer-jsc
+
+  test_build_docs_rs:
+    name: Test build docs rs
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: "nightly-2023-10-05"
+          target: x86_64-unknown-linux-gnu
+      - run: cargo install toml-cli # toml-cli is required to run `make test-build-docs-rs`
+      - name: make test-build-docs-rs-ci
+        run: make test-build-docs-rs-ci
+
+  build_linux_aarch64:
+    name: ${{ matrix.build-what.name }} on linux-aarch64
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        build-what: [
+          {
+            key: capi,
+            build-cmd: 'make build-capi && make package-capi',
+            name: 'Build C-API'
+          },
+          {
+            key: wasmer,
+            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
+            name: 'Build wasmer-cli'
+          }
+        ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: aarch64-unknown-linux-gnu
+      - name: Build cross image
+        run: |
+          docker build -t wasmer/aarch64 ${GITHUB_WORKSPACE}/.github/cross-linux-aarch64/
+        env:
+          CROSS_DOCKER_IN_DOCKER: true
+      - name: Build ${{ matrix.build-what.key }}
+        run: |
+          ${{ matrix.build-what.build-cmd }}
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          ENABLE_LLVM: 0
+      - name: Dist
+        if: ${{ matrix.build-what.key == 'capi' }}
+        run: |
+          make distribution
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/aarch64 cross
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: aarch64-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/aarch64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          TARGET: aarch64-unknown-linux-gnu
+          TARGET_DIR: target/aarch64-unknown-linux-gnu/release
+      - name: Upload Artifacts
+        if: ${{ matrix.build-what.key == 'capi' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: capi-linux-aarch64
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  build_linux_riscv64:
+    name: ${{ matrix.build-what.name }} on linux-riscv64
+    runs-on: ubuntu-22.04
+    strategy:
+      fail-fast: false
+      matrix:
+        build-what: [
+          {
+            key: capi,
+            build-cmd: 'make build-capi && make package-capi',
+            name: 'Build C-API'
+          },
+          {
+            key: wasmer,
+            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
+            name: 'Build wasmer-cli'
+          }
+        ]
+    steps:
+      - uses: actions/checkout@v3
+      #- uses: dtolnay/rust-toolchain@stable
+      #  with:
+      #    toolchain: ${{ env.MSRV }}
+      #    target: riscv64gc-unknown-linux-gnu
+      - name: Build cross image
+        run: |
+          docker build -t wasmer/riscv64 ${GITHUB_WORKSPACE}/.github/cross-linux-riscv64/
+        env:
+          CROSS_DOCKER_IN_DOCKER: true
+      - name: Build ${{ matrix.build-what.key }}
+        run: |
+          ${{ matrix.build-what.build-cmd }}
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64 cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          ENABLE_LLVM: 0
+      - name: Dist
+        if: ${{ matrix.build-what.key == 'capi' }}
+        run: |
+          make distribution
+        env:
+          CARGO_BINARY: docker run -v /var/run/docker.sock:/var/run/docker.sock -v ${GITHUB_WORKSPACE}:/project -w /project wasmer/riscv64 cargo
+          CROSS_DOCKER_IN_DOCKER: true
+          CARGO_TARGET: riscv64gc-unknown-linux-gnu
+          PKG_CONFIG_PATH: /usr/lib/riscv64-linux-gnu/pkgconfig
+          PKG_CONFIG_ALLOW_CROSS: true
+          TARGET: riscv64gc-unknown-linux-gnu
+          TARGET_DIR: target/riscv64gc-unknown-linux-gnu/release
+      - name: Upload Artifacts
+        if: ${{ matrix.build-what.key == 'capi' }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: capi-linux-riscv64
+          path: dist
+          if-no-files-found: error
+          retention-days: 2
+
+  build:
+    name: ${{ matrix.build-what.name }} on ${{ matrix.metadata.build }}
+    runs-on: ${{ matrix.metadata.os }}
+    needs: setup
+    strategy:
+      fail-fast: false
+      matrix:
+        build-what: [
+          {
+            key: capi,
+            build-cmd: 'make build-capi && make build-capi-headless && make package-capi && make tar-capi',
+            name: 'Build and test C-API'
+          },
+          {
+            key: wasmer,
+            build-cmd: 'make build-wasmer && make package-wasmer && make tar-wasmer',
+            name: 'Build wasmer-cli'
+          }
+        ]
+        metadata: [
+          {
+            build: linux-x64,
+            os: ubuntu-22.04,
+            target: x86_64-unknown-linux-gnu,
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
+          },
+          {
+            build: linux-musl,
+            target: x86_64-unknown-linux-musl,
+            os: ubuntu-22.04,
+            container: 'alpine:latest'
+          },
+          {
+            build: macos-x64,
+            os: macos-11,
+            target: x86_64-apple-darwin,
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
+          },
+          {
+            build: macos-arm,
+            os: macos-11,
+            target: aarch64-apple-darwin,
+          },
+          {
+            build: windows-x64,
+            os: windows-2019,
+            target: x86_64-pc-windows-msvc,
+            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
+          },
+          {
+            build: windows-gnu,
+            target: x86_64-pc-windows-gnu,
+            os: ubuntu-22.04,
+          }
+        ]
+    container: ${{ matrix.metadata.container }}
+    env:
+      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
+      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up libstdc++ on Linux
+        if: matrix.metadata.build == 'linux-x64'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --allow-downgrades libstdc++6 libtinfo5
+          sudo apt-get install --reinstall g++
+      - name: Set up base deps on musl
+        if: matrix.metadata.build == 'linux-musl'
+        run: ./scripts/alpine-linux-install-deps.sh
+      - name: Set up dependencies for Mac OS
+        run: |
+          brew install automake
+          # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
+          brew install gnu-tar
+          echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
+        if: matrix.metadata.os == 'macos-latest' || matrix.metadata.os == 'macos-11.0'
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: ${{ matrix.metadata.target }}
+      - name: Install Nextest
+        uses: taiki-e/install-action@nextest
+      - name: Install Windows-GNU linker
+        if: ${{ matrix.metadata.build == 'windows-gnu' }}
+        shell: bash
+        run: |
+          sudo apt install -y mingw-w64
+      - name: Install Windows-GNU target
+        if: ${{ matrix.metadata.build == 'windows-gnu' }}
+        shell: bash
+        run: |
+          rustup target add x86_64-pc-windows-gnu
+      - name: Install Windows 10 SDK with xwin
+        if: ${{ matrix.metadata.build == 'windows-gnu' }}
+        shell: bash
+        run: |
+          mkdir -p /tmp/xwin
+          mkdir -p /tmp/xwindownload
+          mkdir -p /tmp/xwincache
+          git clone https://github.com/wasmerio/xwin --depth=1 /tmp/xwin
+          cargo build --release --manifest-path=/tmp/xwin/Cargo.toml
+          /tmp/xwin/target/release/xwin --accept-license --cache-dir /tmp/xwincache splat --output /tmp/xwindownload
+          mkdir -p /tmp/winsdk
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/WS2_32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/KERNEL32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/BCRYPT.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/ADVAPI32.lib /tmp/winsdk/
+          cp /tmp/xwindownload/sdk/lib/10.0.20348/um/x86_64/USERENV.lib /tmp/winsdk/
+          echo "WinSDK files:"
+          ls -laH /tmp/winsdk
+          echo ""
+          mkdir -p package
+          mkdir -p package/winsdk
+          cp -r /tmp/winsdk/* package/winsdk
+      - name: Install LLVM (macOS Apple Silicon)
+        if: matrix.metadata.os == 'macos-11.0' && !matrix.metadata.llvm_url
+        run: |
+          brew install llvm
+      - name: Install LLVM
+        if: matrix.metadata.llvm_url
+        shell: bash
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf ${{ matrix.metadata.llvm_url }} -L -o llvm.tar.xz
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "ENABLE_LLVM=1" >> $GITHUB_ENV
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "${LLVM_DIR}/usr/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_150_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+      - name: Setup Rust target
+        shell: bash
+        run: |
+          mkdir -p .cargo
+          cat << EOF > .cargo/config.toml
+          [build]
+          target = "${{ matrix.metadata.target }}"
+          EOF
+        if: matrix.metadata.target
+      - name: which cargo
+        if: ${{ matrix.build-what.key == 'capi' && matrix.metadata.build == 'windows-x64' }}
+        run: which cargo
+      - name: Set cargo env
+        run: echo "CARGO_ROOT_DIR=$(dirname $(dirname $( which cargo )))" >> $GITHUB_ENV
+      - name: List root dir
+        shell: bash
+        if: ${{ matrix.build-what.key == 'capi' && matrix.metadata.build == 'windows-x64' }}
+        run: ls -R $CARGO_ROOT_DIR
+      - name: Cache
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+            $CARGO_ROOT_DIR/*
+          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-build-wasmer-${{ matrix.build-what.key }}-${{ matrix.metadata.build }}
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
+      - name: Build C-API
+        shell: bash
+        run: ${{ matrix.build-what.build-cmd }}
+        if: ${{ matrix.build-what.key == 'capi' }}
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: Build Wasmer
+        shell: bash
+        if: ${{ matrix.build-what.key == 'wasmer' && matrix.metadata.build != 'windows-gnu' }}
+        run: ${{ matrix.build-what.build-cmd }}
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: Test C-API
+        shell: bash
+        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'macos-arm' || matrix.metadata.build == 'windows-gnu') }}
+        run: make test-capi-ci
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+      # C-API tests were disabled for linux-musl and macos-arm (we can't run them)
+      - name: Test C-API integration
+        shell: bash
+        if: ${{ matrix.build-what.key == 'capi' && !(matrix.metadata.build == 'linux-musl' || matrix.metadata.build == 'macos-arm' || matrix.metadata.build == 'windows-gnu') }}
+        run: export WASMER_DIR=`pwd`/package && make test-stage-7-capi-integration-tests
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: wasmer-cli-${{ matrix.metadata.build }}
+          path: build-wasmer.tar.gz
+          if-no-files-found: ignore
+          retention-days: 2
+      - name: Archive production artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: capi-${{ matrix.metadata.build }}
+          path: build-capi.tar.gz
+          if-no-files-found: ignore
+          retention-days: 2
+
+  test:
+    name: ${{ matrix.stage.description }} on ${{ matrix.metadata.build }}
+    runs-on: ${{ matrix.metadata.os }}
+    needs: setup
+    strategy:
+      fail-fast: false
+      matrix:
+        stage: [
+          {
+            description: 'Run wast test suite for all compilers',
+            make: 'test-stage-0-wast',
+          },
+          {
+            description: 'Unit-test packages on std',
+            make: 'test-stage-1-test-all',
+          },
+          {
+            description: 'Unit-test cranelift on no-std',
+            make: 'test-stage-2-test-compiler-cranelift-nostd',
+          },
+          {
+            description: 'Unit-test singlepass on no-std',
+            make: 'test-stage-3-test-compiler-singlepass-nostd',
+          },
+          {
+            description: 'Unit-test wasmer-cli',
+            make: 'test-stage-4-wasmer-cli',
+          },
+          {
+            description: 'Unit-test examples',
+            make: 'test-stage-5-test-examples',
+          }
+        ]
+        metadata: [
+          # We cannot test on macos-arm since we don't have ARM runners
+          {
+            build: linux-x64,
+            os: ubuntu-22.04,
+            target: x86_64-unknown-linux-gnu,
+            exe: '',
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
+          },
+          {
+            build: macos-x64,
+            os: macos-11,
+            target: x86_64-apple-darwin,
+            exe: '',
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
+          },
+          {
+            build: macos-arm64,
+            os: macos-14,
+            target: aarch64-apple-darwin,
+            exe: '',
+          },
+          {
+            build: windows-x64,
+            os: windows-2019,
+            target: x86_64-pc-windows-msvc,
+            exe: '.exe',
+            llvm_url: 'https://github.com/wasmerio/llvm-custom-builds/releases/download/15.x/llvm-windows-amd64.tar.xz'
+          },
+          {
+            build: linux-musl,
+            target: x86_64-unknown-linux-musl,
+            os: ubuntu-22.04,
+            exe: '',
+            container: 'alpine:latest'
+          }
+        ]
+    container: ${{ matrix.metadata.container }}
+    env:
+      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
+      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up libstdc++ on Linux
+        if: matrix.metadata.build == 'linux-x64'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y --allow-downgrades libstdc++6
+          sudo apt-get install --reinstall g++
+      - name: Set up base deps on musl
+        if: matrix.metadata.build == 'linux-musl'
+        run: ./scripts/alpine-linux-install-deps.sh
+      - name: Set up dependencies for Mac OS
+        run: |
+          brew install automake
+          # using gnu-tar is a workaround for https://github.com/actions/cache/issues/403
+          brew install gnu-tar
+          echo PATH="/usr/local/opt/gnu-tar/libexec/gnubin:$PATH" >> $GITHUB_ENV
+        if: matrix.metadata.os == 'macos-latest' || matrix.metadata.os == 'macos-11.0'
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: ${{ matrix.metadata.target }}
+      - name: Install Nextest
+        uses: taiki-e/install-action@nextest
+      - name: Install LLVM (macOS Apple Silicon)
+        if: matrix.metadata.os == 'macos-11.0' && !matrix.metadata.llvm_url
+        run: |
+          brew install llvm
+      - name: Install LLVM
+        if: matrix.metadata.llvm_url
+        shell: bash
+        run: |
+          curl --proto '=https' --tlsv1.2 -sSf ${{ matrix.metadata.llvm_url }} -L -o llvm.tar.xz
+          LLVM_DIR=$(pwd)/${{ env.LLVM_DIR }}
+          mkdir ${LLVM_DIR}
+          tar xf llvm.tar.xz --strip-components=1 -C ${LLVM_DIR}
+          echo "${LLVM_DIR}/bin" >> $GITHUB_PATH
+          echo "LLVM_SYS_120_PREFIX=${LLVM_DIR}" >> $GITHUB_ENV
+        env:
+          LLVM_DIR: .llvm
+      - name: Setup Rust target
+        shell: bash
+        run: |
+          mkdir -p .cargo
+          cat << EOF > .cargo/config.toml
+          [build]
+          target = "${{ matrix.metadata.target }}"
+          EOF
+        if: matrix.metadata.target
+      - name: Cache
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-stage-${{ matrix.stage.make }}-${{ matrix.metadata.build }}
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
+      - name: ${{ matrix.stage.description }}
+        run: make ${{ matrix.stage.make }}
+        env:
+          TARGET: ${{ matrix.metadata.target }}
+          TARGET_DIR: target/${{ matrix.metadata.target }}/release
+          CARGO_TARGET: ${{ matrix.metadata.target }}
+
+  test_integration_cli:
+    name: CLI integration tests on ${{ matrix.build }}
+    runs-on: ${{ matrix.os }}
+    needs: [build, build_linux_aarch64, build_linux_riscv64]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - build: linux-x64
+            os: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.6/clang+llvm-15.0.6-x86_64-linux-gnu-ubuntu-18.04.tar.xz'
+          - build: macos-x64
+            os: macos-11
+            target: x86_64-apple-darwin
+            llvm_url: 'https://github.com/llvm/llvm-project/releases/download/llvmorg-15.0.7/clang+llvm-15.0.7-x86_64-apple-darwin21.0.tar.xz'
+          # we only build the integration-test CLI, we don't run tests
+          - build: macos-arm
+            os: macos-11
+            target: aarch64-apple-darwin,
+          - build: linux-musl
+            target: x86_64-unknown-linux-musl
+            os: ubuntu-22.04
+            container: alpine:latest
+          - build: windows-x64
+            os: windows-2019
+            target: x86_64-pc-windows-msvc
+    container: ${{ matrix.container }}
+    env:
+      SCCACHE_AZURE_BLOB_CONTAINER: wasmerstoragesccacheblob
+      SCCACHE_AZURE_CONNECTION_STRING: ${{ secrets.SCCACHE_AZURE_CONNECTION_STRING }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.10.0
+      - name: Set up base deps on musl
+        if: matrix.build == 'linux-musl'
+        run: ./scripts/alpine-linux-install-deps.sh
+      - uses: actions/download-artifact@v3
+        id: download
+        with:
+          name: capi-${{ matrix.build }}
+      - uses: actions/download-artifact@v3
+        with:
+          name: wasmer-cli-${{ matrix.build }}
+      - name: 'Echo download path'
+        run: echo ${{steps.download.outputs.download-path}}
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: ${{ env.MSRV }}
+          target: ${{ matrix.metadata.target }}
+      - name: Install Nextest
+        uses: taiki-e/install-action@nextest
+      - name: Cache
+        uses: whywaita/actions-cache-s3@v2
+        with:
+          path: |
+            ~/.cargo/*
+            ./target/*
+          key: r22-${{ github.repository }}-${{ runner.os }}-${{ hashFiles('Cargo.lock') }}-wasmer-make-test-integration-cli-${{ matrix.build }}
+          aws-s3-bucket: wasmer-rust-artifacts-cache
+          aws-access-key-id: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_TOKEN }}
+          aws-secret-access-key: ${{ secrets.CLOUDFLARE_ARTIFACTS_CACHE_ACCESS_KEY }}
+          aws-region: auto
+          aws-endpoint: https://1541b1e8a3fc6ad155ce67ef38899700.r2.cloudflarestorage.com
+          aws-s3-bucket-endpoint: false
+          aws-s3-force-path-style: true
+      - name: Prepare package directory
+        shell: bash
+        run: |
+          mkdir -p package
+          mkdir -p package/cache
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-linux-aarch64
+          path: package/cache/wasmercache1
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-windows-gnu
+          path: package/cache/wasmercache2
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-macos-arm
+          path: package/cache/wasmercache3
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-macos-x64
+          path: package/cache/wasmercache4
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-linux-x64
+          path: package/cache/wasmercache5
+      - uses: actions/download-artifact@v3
+        with:
+          name: capi-linux-riscv64
+          path: package/cache/wasmercache6
+      - name: Copy .tar.gz files to proper location
+        shell: bash
+        run: |
+          ls package/cache/wasmercache1
+          ls package/cache/wasmercache2
+          ls package/cache/wasmercache3
+          ls package/cache/wasmercache4
+          ls package/cache/wasmercache5
+          cp package/cache/wasmercache1/wasmer.tar.gz package/cache/wasmer-linux-aarch64.tar.gz
+          cp package/cache/wasmercache2/build-capi.tar.gz package/cache/wasmer-windows-gnu64.tar.gz
+          cp package/cache/wasmercache3/build-capi.tar.gz package/cache/wasmer-darwin-arm64.tar.gz
+          cp package/cache/wasmercache4/build-capi.tar.gz package/cache/wasmer-darwin-amd64.tar.gz
+          cp package/cache/wasmercache5/build-capi.tar.gz package/cache/wasmer-linux-amd64.tar.gz
+          cp package/cache/wasmercache6/wasmer.tar.gz package/cache/wasmer-linux-riscv64.tar.gz
+      - uses: actions/download-artifact@v3
+        if: ${{ matrix.build == 'windows-x64' }}
+        with:
+          name: capi-windows-gnu
+          path: download_link
+      - uses: actions/download-artifact@v3
+        if: ${{ matrix.build == 'linux-musl' }}
+        with:
+          name: capi-linux-musl
+          path: download_link
+      - uses: actions/download-artifact@v3
+        if: ${{ matrix.build == 'macos-arm' }}
+        with:
+          name: capi-macos-arm
+          path: download_link
+      - uses: actions/download-artifact@v3
+        if: ${{ matrix.build == 'macos-x64' }}
+        with:
+          name: capi-macos-x64
+          path: download_link
+      - uses: actions/download-artifact@v3
+        if: ${{ matrix.build == 'linux-x64' }}
+        with:
+          name: capi-linux-x64
+          path: download_link
+      - name: Copy build-capi.tar.gz to link.tar.gz
+        shell: bash
+        run: |
+          cp download_link/build-capi.tar.gz link.tar.gz
+      - name: Unzip Artifacts
+        shell: bash
+        run: |
+          make untar-capi
+      - name: Unzip Artifacts
+        shell: bash
+        run: |
+          make untar-wasmer
+      - name: Test integration CLI
+        if: matrix.build != 'macos-arm'
+        shell: bash
+        run: |
+          export WASMER_PATH=`pwd`/target/${{ matrix.target }}/release/wasmer${{ matrix.exe }}
+          export WASMER_DIR=`pwd`/package && make test-integration-cli-ci
+        env:
+          TARGET: ${{ matrix.target }}
+          TARGET_DIR: target/${{ matrix.target }}/release
+          CARGO_TARGET: ${{ matrix.target }}
+          WAPM_DEV_TOKEN: ${{ secrets.WAPM_DEV_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/arbitrator/tools/module_roots/wasmer/.gitignore b/arbitrator/tools/module_roots/wasmer/.gitignore
new file mode 100644
index 0000000..ed9fd0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.gitignore
@@ -0,0 +1,30 @@
+**/target
+**/*.rs.bk
+.DS_Store
+.idea
+.gdb_history
+/.cargo/
+**/.vscode/*
+!/.vscode/settings.json
+api-docs-repo/
+/.cargo_home/
+/package/
+/dist/
+/wapm-cli/
+/src/windows-installer/WasmerInstaller.exe
+/lib/c-api/wasmer.h
+.xwin-cache
+wapm.toml
+wasmer.toml
+*.snap.new
+# Generated by tests on Android
+/avd
+/core
+/vendor
+out.txt
+wapm.toml
+build-capi.tar.gz
+build-wasmer.tar.gz
+lcov.info
+link/
+link.tar.gz
diff --git a/arbitrator/tools/module_roots/wasmer/.tarpaulin.toml b/arbitrator/tools/module_roots/wasmer/.tarpaulin.toml
new file mode 100644
index 0000000..08fe94c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/.tarpaulin.toml
@@ -0,0 +1,17 @@
+[cranelift_coverage]
+features = "cranelift,singlepass,llvm,coverage,test-cranelift,test-jit"
+examples = ["early-exit", "engine-jit", "engine-native", "engine-headless", "cross-compilation", "compiler-cranelift", "exported-function", "wasi"]
+release = true
+
+[llvm_coverage]
+features = "cranelift,singlepass,llvm,coverage,test-llvm,test-jit"
+examples = ["compiler-llvm"]
+release = true
+
+[singlepass_coverage]
+features = "cranelift,singlepass,llvm,coverage,test-singlepass,test-jit"
+examples = ["compiler-singlepass"]
+release = true
+
+[report]
+out = ["Xml"]
diff --git a/arbitrator/tools/module_roots/wasmer/ATTRIBUTIONS.md b/arbitrator/tools/module_roots/wasmer/ATTRIBUTIONS.md
new file mode 100644
index 0000000..1f1cca7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/ATTRIBUTIONS.md
@@ -0,0 +1,605 @@
+# Wasmer Attributions
+
+Wasmer is a community effort and makes use of code from various other
+projects ❤️.
+Listed below are notable sections of code that are licensed
+from other projects and the relevant license of those projects.
+
+These are the projects that were used as inspiration and/or that we are using code from.
+Each of the subcrates we have have an `Aknowledgements` section with more details.
+
+Projects:
+
+- [Emscripten](https://github.com/kripken/emscripten): for emtests test sources to ensure compatibility - [LICENSE](#emscripten)
+- [Nebulet](https://github.com/nebulet/nebulet): as the base for creating a great Rust WebAssembly runtime - [LICENSE](#nebulet)
+- [WAVM](https://github.com/wavm/wavm): for their great integration and testing framework - [LICENSE](#wavm)
+- [wasmtime](https://github.com/CraneStation/wasmtime): for their API and internal documentation, as well as some internal implementations - [LICENSE](#wasmtime)
+- [WebAssembly spec](https://github.com/WebAssembly/spec/tree/master/test): for the spectests implementation
+
+🙏 Please let us know if you believe there is an error or omission in
+this list and we will correct.
+
+## Licenses
+
+### Nebulet
+
+```text
+MIT License
+
+Copyright (c) 2018
+
+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.
+```
+
+### WAVM
+
+```text
+Copyright (c) 2018, Andrew Scheidecker
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* Neither the name of WAVM nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The contents of [Test/spec](Test/spec) is covered by the license in [Test/spec/LICENSE](Test/spec/LICENSE).
+
+[Source/ThirdParty/dtoa/dtoa.c](Source/ThirdParty/dtoa/dtoa.c) is covered by the license in that file.
+
+[Source/ThirdParty/libunwind](Source/ThirdParty/libunwind) is covered by the license in [Source/ThirdParty/libunwind/LICENSE.TXT](Source/ThirdParty/libunwind/LICENSE.TXT).
+
+[Source/ThirdParty/xxhash](Source/ThirdParty/xxhash) is covered by the license in [Source/ThirdParty/xxhash/LICENSE](Source/ThirdParty/xxhash/LICENSE).
+```
+
+### Greenwasm
+
+```text
+                              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.
+```
+
+### Wasmtime
+
+```text
+                                 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.
+
+
+--- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
+```
+
+### Emscripten
+```text
+Emscripten is available under 2 licenses, the MIT license and the
+University of Illinois/NCSA Open Source License.
+
+Both are permissive open source licenses, with little if any
+practical difference between them.
+
+The reason for offering both is that (1) the MIT license is
+well-known, while (2) the University of Illinois/NCSA Open Source
+License allows Emscripten's code to be integrated upstream into
+LLVM, which uses that license, should the opportunity arise.
+
+The full text of both licenses follows.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+
+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.
+
+==============================================================================
+
+Copyright (c) 2010-2014 Emscripten authors, see AUTHORS file.
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal with 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:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimers.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimers
+    in the documentation and/or other materials provided with the
+    distribution.
+
+    Neither the names of Mozilla,
+    nor the names of its contributors may be used to endorse
+    or promote products derived from this Software without specific prior
+    written permission.
+
+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 CONTRIBUTORS 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 WITH THE SOFTWARE.
+
+==============================================================================
+
+This program uses portions of Node.js source code located in src/library_path.js,
+in accordance with the terms of the MIT license. Node's license follows:
+
+    """
+        Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+        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.
+    """
+
+The musl libc project is bundled in this repo, and it has the MIT license, see
+system/lib/libc/musl/COPYRIGHT
+
+The third_party/ subdirectory contains code with other licenses. None of it is
+used by default, but certain options use it (e.g., the optional closure compiler
+flag will run closure compiler from third_party/).
+
+```
diff --git a/arbitrator/tools/module_roots/wasmer/CHANGELOG.md b/arbitrator/tools/module_roots/wasmer/CHANGELOG.md
new file mode 100644
index 0000000..070cf7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/CHANGELOG.md
@@ -0,0 +1,1907 @@
+# Changelog
+
+*The format is based on [Keep a Changelog].*
+
+[Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
+
+Looking for changes that affect our C API? See the [C API Changelog](lib/c-api/CHANGELOG.md).
+
+
+## **Unreleased**
+
+## 4.2.8 - 05/04/2024
+
+This release improves journal support and improves the performance of the singlepass backend.
+Also contains fixes to the Edge CLI.
+
+## Added
+
+  - [#4510](https://github.com/wasmerio/wasmer/pull/4510) Added support for creating log file journals directly from buffers
+  - [#4506](https://github.com/wasmerio/wasmer/pull/4506) feat: add wasmer-argus
+  - [#4508](https://github.com/wasmerio/wasmer/pull/4508) Upgrade edge-{schema,util} crates + add some helper methdos
+
+## Changed
+
+  - [#4541](https://github.com/wasmerio/wasmer/pull/4541) Removed some dead code
+  - [#4539](https://github.com/wasmerio/wasmer/pull/4539) deps: Upgrade h2 due to RUSTSEC advisory
+  - [#4527](https://github.com/wasmerio/wasmer/pull/4527) allow owner field in app.yaml
+  - [#4526](https://github.com/wasmerio/wasmer/pull/4526) feat(singlepass): use SIMD insts for popcount
+  - [#4507](https://github.com/wasmerio/wasmer/pull/4507) deps: Upgrade edge-schema to 0.0.3
+  - [#4462](https://github.com/wasmerio/wasmer/pull/4462) DProxy
+
+## Fixed
+
+  - [#4542](https://github.com/wasmerio/wasmer/pull/4542) Various fixes detected in the build
+  - [#4537](https://github.com/wasmerio/wasmer/pull/4537) Fix owner issues with app create
+  - [#4535](https://github.com/wasmerio/wasmer/pull/4535) fix(cli): Fix Edge WinterJS template
+  - [#4525](https://github.com/wasmerio/wasmer/pull/4525) Fix bug with `app deploy`: app URL is stale
+  - [#4520](https://github.com/wasmerio/wasmer/pull/4520) Fix singlepass panic
+
+
+
+## 4.2.7 - 19/03/2024
+
+This release adds the `wasmer domain` command for DNS records management, and also includes an important fix to the `stack_restore` WASIX syscall (used by the `longjmp` function).
+
+## Added
+
+  - [#4478](https://github.com/wasmerio/wasmer/pull/4478) chore(backend-api): Add size to PackageDistribution
+
+## Changed
+
+  - [#4492](https://github.com/wasmerio/wasmer/pull/4492) No longer restoring the thread local memory when we longjmp
+  - [#4487](https://github.com/wasmerio/wasmer/pull/4487) Manage DNS records
+  - [#4220](https://github.com/wasmerio/wasmer/pull/4220) Ability to detect a tainted instance
+  - [#4455](https://github.com/wasmerio/wasmer/pull/4455) Implemented an exponential CPU backoff that kicks in when a run token is not held
+  - [#4470](https://github.com/wasmerio/wasmer/pull/4470) chore: Completely remove wasix_http_client
+
+## Fixed
+
+  - [#4490](https://github.com/wasmerio/wasmer/pull/4490) Fix for a panic in the sock_recv when a file handle is missing
+  - [#4335](https://github.com/wasmerio/wasmer/pull/4335) Fixed an issue where the package loader was blocking the tokio runtime
+  - [#4473](https://github.com/wasmerio/wasmer/pull/4473) fix: fix feature = "cargo-clippy" deprecation
+
+
+
+## 4.2.6 - 03/03/2024
+
+This release includes a number of DX improvements for the Wasmer CLI, as well as fixes to WASI and its filesystem implementation.
+
+## Added
+
+  - [#4459](https://github.com/wasmerio/wasmer/pull/4459) feat(backend-api): Add download_url to PackageDistribution
+  - [#4460](https://github.com/wasmerio/wasmer/pull/4460) fix(cli): Add missing output in "app get" command and fix output of "app info"
+  - [#4448](https://github.com/wasmerio/wasmer/pull/4448) Add wasi-fyi tests and run them in CI
+  - [#4454](https://github.com/wasmerio/wasmer/pull/4454) add pagination to app list queries
+  - [#4443](https://github.com/wasmerio/wasmer/pull/4443) feat(backend-api): Add get_app_by_id_opt
+  - [#4385](https://github.com/wasmerio/wasmer/pull/4385) feat(api): Add SharedMemoryHandle
+  - [#3517](https://github.com/wasmerio/wasmer/pull/3517) Add HTTP example which does dynamic allocation
+
+## Changed
+
+  - [#4472](https://github.com/wasmerio/wasmer/pull/4472) feat(cli): "wasmer deploy": return app version as json if --json specified
+  - [#4471](https://github.com/wasmerio/wasmer/pull/4471) chore: Remove wasi-experimental-io-devices
+  - [#4466](https://github.com/wasmerio/wasmer/pull/4466) Clean up wasmer-wasix-types and remove wasix-http-client
+  - [#4458](https://github.com/wasmerio/wasmer/pull/4458) tests: Disable flaky network tests on MUSL
+  - [#4440](https://github.com/wasmerio/wasmer/pull/4440) cli: allow filtering by log stream
+  - [#4435](https://github.com/wasmerio/wasmer/pull/4435) Use M1 runner for building & testing m1
+  - [#4434](https://github.com/wasmerio/wasmer/pull/4434) Update Rust toolchain to 1.73
+  - [#4428](https://github.com/wasmerio/wasmer/pull/4428) Try to build the package before publishing it
+  - [#4441](https://github.com/wasmerio/wasmer/pull/4441) increase pagination size for app logs
+  - [#4429](https://github.com/wasmerio/wasmer/pull/4429) Return Notsup for absolute symlinks instead of panicking
+  - [#4427](https://github.com/wasmerio/wasmer/pull/4427) Migrate deprecated usage
+  - [#4426](https://github.com/wasmerio/wasmer/pull/4426) deps: Unify wasmparser usage to a single version
+  - [#4292](https://github.com/wasmerio/wasmer/pull/4292) deps: Upgrade wasmparser
+  - [#4398](https://github.com/wasmerio/wasmer/pull/4398) Make public API consistent
+  - [#4407](https://github.com/wasmerio/wasmer/pull/4407) CLI: Big CLI cleanup + merge Edge CLI
+  - [#4395](https://github.com/wasmerio/wasmer/pull/4395) chore(wasix): Increase log level for WapmSource
+  - [#4403](https://github.com/wasmerio/wasmer/pull/4403) Allow users to provide custom host functions to `WasiRunner` and `WasiEnvBuilder`
+  - [#4359](https://github.com/wasmerio/wasmer/pull/4359) Use nanoseconds in `filestat` for directories
+  - [#4100](https://github.com/wasmerio/wasmer/pull/4100) Tweak logging annotations to simplify performance troubleshooting
+  - [#4175](https://github.com/wasmerio/wasmer/pull/4175) Update dependencies and remove unused dependencies
+  - [#4302](https://github.com/wasmerio/wasmer/pull/4302) Allow `WasiRunner` to mount `FileSystem` instances
+  - [#4394](https://github.com/wasmerio/wasmer/pull/4394) ignore append when truncate is set
+  - [#4263](https://github.com/wasmerio/wasmer/pull/4263) WASI journal and stateful persistence
+  - [#4389](https://github.com/wasmerio/wasmer/pull/4389) remove memory footprint computation
+  - [#4352](https://github.com/wasmerio/wasmer/pull/4352) Wait for webc, bindings, exe generation during package-publish with `--wait` flag
+  - [#4388](https://github.com/wasmerio/wasmer/pull/4388) Temporarily exclude tokio from docs builds
+  - [#4345](https://github.com/wasmerio/wasmer/pull/4345) Asyncify filesystem cache
+
+## Fixed
+
+  - [#4467](https://github.com/wasmerio/wasmer/pull/4467) fix(cli): Fix auto-package version bumping in 'wasmer deploy'
+  - [#4452](https://github.com/wasmerio/wasmer/pull/4452) CLI: Fix logic error in indexing in app logs command
+  - [#4444](https://github.com/wasmerio/wasmer/pull/4444) Fix note about unaligned references in `WasmRef` docs
+  - [#4338](https://github.com/wasmerio/wasmer/pull/4338) [SINGLEPASS]Fix bug #4092 which was due to resource leak while doing …
+  - [#4430](https://github.com/wasmerio/wasmer/pull/4430) deps: Fix accidental hyper 1.0 upgrade + remove some duplicate dependencies
+  - [#4322](https://github.com/wasmerio/wasmer/pull/4322) fix: Prevent panicking in VirtualTaskManagerExt::spawn_and_block_on
+  - [#4411](https://github.com/wasmerio/wasmer/pull/4411) chore: Fix clippy lints for headless CLI build
+  - [#4410](https://github.com/wasmerio/wasmer/pull/4410) fix(cli): publish: Fix panic + Make waiting for build results more modular
+  - [#4402](https://github.com/wasmerio/wasmer/pull/4402) Fixed some compilation errors introduced by #4204 that assume `tokio::task::block_in_place()` always exists
+  - [#3448](https://github.com/wasmerio/wasmer/pull/3448) Fix make install-capi-lib
+  - [#4393](https://github.com/wasmerio/wasmer/pull/4393) fix(api): Provide stub impls for new LinearMemory methods
+  - [#4391](https://github.com/wasmerio/wasmer/pull/4391) Fixed an issue where the caching compiled modules were not saving properly
+  - [#4386](https://github.com/wasmerio/wasmer/pull/4386) chore: Fix clippy lints in API crate
+  - [#4387](https://github.com/wasmerio/wasmer/pull/4387) fix: Don't log the `FmtSpan::ENTER` event because it generates unnecessary logs
+
+
+
+## 4.2.5 - 23/12/2023
+
+This release includes substantial improvements to Wasmer's startup time when loading cached modules. Also includes a couple of filesystem-related fixes and updates the Edge application templates.
+
+## Added
+
+  - [#4370](https://github.com/wasmerio/wasmer/pull/4370) feat(wasix): Add optional chunk timeout to ReqwestHttpClient
+  - [#4369](https://github.com/wasmerio/wasmer/pull/4369) WASIX: Add QueryError::Timeout
+  - [#4336](https://github.com/wasmerio/wasmer/pull/4336) fix(docs): add cpp in Chinese
+
+## Changed
+
+  - [#4372](https://github.com/wasmerio/wasmer/pull/4372) use faster hash algorithm when loading and saving a module
+  - [#4367](https://github.com/wasmerio/wasmer/pull/4367) deps: Bump edge cli to 0.1.4
+  - [#4366](https://github.com/wasmerio/wasmer/pull/4366) Always use the download URL provided by the Wasmer registry instead of going through the frontend redirect
+  - [#4350](https://github.com/wasmerio/wasmer/pull/4350) Optimize sleep_now for TokioTaskManager
+  - [#4351](https://github.com/wasmerio/wasmer/pull/4351) Remove the wasmer-web crate and all tests
+  - [#4229](https://github.com/wasmerio/wasmer/pull/4229) Use `cargo nextest` when running tests in CI
+  - [#4339](https://github.com/wasmerio/wasmer/pull/4339) deps: Bump edge-cli version
+
+## Fixed
+
+  - [#4368](https://github.com/wasmerio/wasmer/pull/4368) fix(wasix): http client: use reasonable default connect timeout
+  - [#4365](https://github.com/wasmerio/wasmer/pull/4365) lib/api/src/js/store.rs: fix typo
+  - [#4356](https://github.com/wasmerio/wasmer/pull/4356) Fixed a subtract-with-overflow in `StaticFile::poll_read_ready()`
+  - [#4355](https://github.com/wasmerio/wasmer/pull/4355) Fix the `virtual_fs::StaticFile` implementation
+  - [#4348](https://github.com/wasmerio/wasmer/pull/4348) fix sync
+
+
+
+## 4.2.4 - 30/11/2023
+
+This release allows publishing private packages and fixes the issue of the file system being accessible by WASI modules in the abscence of directory mapping. Also improves startup speed, and fixes multiple issues around the WASI filesystem, packages and apps.
+
+## Added
+
+  - [#4334](https://github.com/wasmerio/wasmer/pull/4334) Add `application/wasm` to list of accepted content-types for webcs
+  - [#4328](https://github.com/wasmerio/wasmer/pull/4328) Add `--wait` and `--timeout` flags to `wamer publish`
+  - [#4315](https://github.com/wasmerio/wasmer/pull/4315) Add TTY aware output to the wasmer package and wasmer container commands
+  - [#4287](https://github.com/wasmerio/wasmer/pull/4287) feat(cli): Add package commands
+  - [#4247](https://github.com/wasmerio/wasmer/pull/4247) Add support for publishing private packages
+  - [#4291](https://github.com/wasmerio/wasmer/pull/4291) feat(cli): add pnpm support
+
+## Changed
+
+  - [#4333](https://github.com/wasmerio/wasmer/pull/4333) deps: Bump edge-cli
+  - [#4332](https://github.com/wasmerio/wasmer/pull/4332) use rusty_pool instead of rayon
+  - [#4321](https://github.com/wasmerio/wasmer/pull/4321) deps(cli): Upgrade Edge CLI
+  - [#4326](https://github.com/wasmerio/wasmer/pull/4326) Always re-execute a registry query when cache lookups fail
+  - [#4317](https://github.com/wasmerio/wasmer/pull/4317) Bump min enumset version to 1.1.0
+  - [#4300](https://github.com/wasmerio/wasmer/pull/4300) Use authentication when running a package
+  - [#4294](https://github.com/wasmerio/wasmer/pull/4294) Terminate after flushing file descriptors
+  - [#4273](https://github.com/wasmerio/wasmer/pull/4273) Update memoffset to 0.9.0
+
+## Fixed
+
+  - [#4307](https://github.com/wasmerio/wasmer/pull/4307) Fix for the non-flushing of file descriptors and a nasty deadlock
+  - [#4331](https://github.com/wasmerio/wasmer/pull/4331) Fix visibility validation to work when publishing a new package
+  - [#4314](https://github.com/wasmerio/wasmer/pull/4314) fix(cli): Prevent temporary file issues in "package download"
+  - [#4296](https://github.com/wasmerio/wasmer/pull/4296) fix: prevent potential UB by deriving repr C for union
+  - [#4192](https://github.com/wasmerio/wasmer/pull/4192) More fixes to support Wasmer JS
+
+
+
+## 4.2.3 - 26/10/2023
+
+This new version fixes a bug in module bindings path.
+
+## Added
+
+
+## Changed
+
+
+## Fixed
+
+  - [#4272](https://github.com/wasmerio/wasmer/pull/4272) fix: Fix async runtime mismatch in virtual "wasmer run" command
+  - [#4276](https://github.com/wasmerio/wasmer/pull/4276) fix: module path using stripping a prefix
+  - [#4241](https://github.com/wasmerio/wasmer/pull/4241) Fix FreeBSD ucontext_t issues
+  - [#4246](https://github.com/wasmerio/wasmer/pull/4246) Fix Cargo.lock for 4.2.2 release
+
+
+
+## 4.2.2 - 04/10/2023
+New wasmer version that utilizes the more recent LLVM15 to compile WASM modules. Also adds new application templates for Wasmer Edge.
+
+## Added
+
+
+## Changed
+
+  - [#4239](https://github.com/wasmerio/wasmer/pull/4239) Wasmer Deploy CLI with js and py worker templates
+  - [#4238](https://github.com/wasmerio/wasmer/pull/4238) Using hard coded package version number in test...
+  - [#4206](https://github.com/wasmerio/wasmer/pull/4206) Remove StdioMode::Reserved variant
+  - [#4234](https://github.com/wasmerio/wasmer/pull/4234) Migration to LLVM15
+  - [#4236](https://github.com/wasmerio/wasmer/pull/4236) Updated tugstsenite
+
+## Fixed
+
+
+
+
+## 4.2.1 - 28/09/2023
+New release of wasmer with improved WASIX compatibility. MSRV was bumped to 1.70 for this release. 
+
+Now it is possible for packages to execute atoms from their dependencies, enabling e.g. python packages to not include the binary but use the one from the official python package.
+
+## Added
+
+  - [#4213](https://github.com/wasmerio/wasmer/pull/4213) feat(wasix): Add BuiltinPackageLoader::insert_cached
+  - [#4202](https://github.com/wasmerio/wasmer/pull/4202) Add support for `JoinFlags::NON_BLOCKING` to `proc_join`
+
+## Changed
+
+  - [#4223](https://github.com/wasmerio/wasmer/pull/4223) Allow packages to have commands that use a dependency's atom
+  - [#4224](https://github.com/wasmerio/wasmer/pull/4224) Use write instead of send for pipe, to accomodate socketpair
+  - [#4221](https://github.com/wasmerio/wasmer/pull/4221) Bump the MSRV from 1.69 to 1.70
+  - [#4214](https://github.com/wasmerio/wasmer/pull/4214) Rephrase the docstring for `--forward-host-env` flag on `wasmer run`
+  - [#4215](https://github.com/wasmerio/wasmer/pull/4215) Ignore `fd_close(3)` to avoid breaking POSIX programs that blindly close all file descriptors
+  - [#4204](https://github.com/wasmerio/wasmer/pull/4204) Stability improvements
+
+## Fixed
+
+  - [#4211](https://github.com/wasmerio/wasmer/pull/4211) Fixes for sockets
+  - [#4193](https://github.com/wasmerio/wasmer/pull/4193) Fix sockets
+  - [#4205](https://github.com/wasmerio/wasmer/pull/4205) Fix File System Merging Problems
+
+
+
+## 4.2.0 - 05/09/2023
+New release of wasmer, with a new 0-copy module deserialization for shorter startup time, some fixes to avoid misaligned pointer acces, and faster internal stack handling, among some other fixes.
+
+## Added
+
+  - [#4199](https://github.com/wasmerio/wasmer/pull/4199) Added some Socket filtype return for fdstat syscall
+  - [#4186](https://github.com/wasmerio/wasmer/pull/4186) Add stdin/stdout/stderr streams to `WasiRunner` and only use async threading when requested
+
+## Changed
+
+  - [#4170](https://github.com/wasmerio/wasmer/pull/4170) deps: Bump Edge client CLI to 0.1.25
+  - [#4179](https://github.com/wasmerio/wasmer/pull/4179) Faster compiles for debug by using release version of cranelift
+  - [#4196](https://github.com/wasmerio/wasmer/pull/4196) Replace stack pool mutex with lock-free queue
+  - [#4180](https://github.com/wasmerio/wasmer/pull/4180) NativeEngineExt::deserialize now returns Module
+  - [#4190](https://github.com/wasmerio/wasmer/pull/4190) Early check that a cached artifact is compatible with current CPU Features
+  - [#4167](https://github.com/wasmerio/wasmer/pull/4167) Make sure vmoffset are aligned to pointer size (for #4059)
+  - [#4184](https://github.com/wasmerio/wasmer/pull/4184) Allow `VirtualTaskManager` to explicitly transfer a module to a blocking task on the threadpool
+  - [#4176](https://github.com/wasmerio/wasmer/pull/4176) Js integrity checks
+  - [#4171](https://github.com/wasmerio/wasmer/pull/4171) Revive "0-copy module deserialization"
+  - [#4173](https://github.com/wasmerio/wasmer/pull/4173) deps: Bump Edge CLI version
+
+## Fixed
+
+  - [#4198](https://github.com/wasmerio/wasmer/pull/4198) chore: fix unavailable document url
+  - [#4191](https://github.com/wasmerio/wasmer/pull/4191) Fix invalid access to wasi instance handles in wasix proc_spawn
+  - [#4165](https://github.com/wasmerio/wasmer/pull/4165) Fix writing to middle of files and improve performance
+
+
+
+## 4.1.2 - 21/08/2023
+Another maintenance release, bringing some networking improvements, and centralising all wasmer caches under the same folder.
+
+
+## Added
+
+  - [#4127](https://github.com/wasmerio/wasmer/pull/4127) Add regression test for path_rename
+
+## Changed
+
+  - [#4164](https://github.com/wasmerio/wasmer/pull/4164) deps: Bump Edge client CLI to 0.1.22
+  - [#4163](https://github.com/wasmerio/wasmer/pull/4163) Bumped virtual-net crate to 0.5.0
+  - [#4156](https://github.com/wasmerio/wasmer/pull/4156) Disable auto-format of toml files in VS Code
+  - [#4141](https://github.com/wasmerio/wasmer/pull/4141) Web http client
+  - [#4152](https://github.com/wasmerio/wasmer/pull/4152) Test virtual-net bincode and mpsc only on linux
+  - [#4115](https://github.com/wasmerio/wasmer/pull/4115) Browser cfg, smaller WASM, VPN and HTTPS redirect
+  - [#4138](https://github.com/wasmerio/wasmer/pull/4138) Upgrade wasmer-wasix to the newest version of wasm-bindgen
+  - [#4135](https://github.com/wasmerio/wasmer/pull/4135) Update to time 0.3
+  - [#4109](https://github.com/wasmerio/wasmer/pull/4109) Update MSRV to 1.69
+  - [#4130](https://github.com/wasmerio/wasmer/pull/4130) Update to tracing-subscriber 0.3
+
+## Fixed
+
+  - [#4160](https://github.com/wasmerio/wasmer/pull/4160) fix: Make the "wasmer cache" command use the same cache directory as the rest of the CLI
+  - [#4148](https://github.com/wasmerio/wasmer/pull/4148) fix(cli): Prevent panics in "wasmer login" after API failures
+
+
+
+## 4.1.1 - 03/08/2023
+Bug-fix release, fixing rename in wasi(x), using newer Rust and some macOS ARM64 speicifc issues, among other things.
+
+## Added
+
+  - [#4120](https://github.com/wasmerio/wasmer/pull/4120) Added proper definition of ucontext for macos/aarch64 to avoid unaligned issue
+  - [#4107](https://github.com/wasmerio/wasmer/pull/4107) Added a forced shutdown on tokio runtimes as the STDIN blocks the shu…
+  - [#4108](https://github.com/wasmerio/wasmer/pull/4108) Add a temporary workaround for nanasess/setup-chromedriver#190
+
+## Changed
+
+  - [#4123](https://github.com/wasmerio/wasmer/pull/4123) Upgrade Edge CLI dependency
+  - [#4109](https://github.com/wasmerio/wasmer/pull/4109) Update MSRV to 1.69
+  - [#4111](https://github.com/wasmerio/wasmer/pull/4111) Update login.rs
+  - [#4102](https://github.com/wasmerio/wasmer/pull/4102) Update to criterion 0.5
+
+## Fixed
+
+  - [#4121](https://github.com/wasmerio/wasmer/pull/4121) Fix path_rename syscall failing
+  - [#4117](https://github.com/wasmerio/wasmer/pull/4117) Fixed an issue where inheritance was inverted
+  - [#4096](https://github.com/wasmerio/wasmer/pull/4096) Fix benchmark
+
+
+
+## 4.1.0 - 24/07/2023
+This version added some more improvements and fixes, with a faster async execution, a new login flow and muliple bugfix to the `--mapdir` command among other things.
+More detail in the blog post about the 4.1 Release: https://wasmer.io/posts/wasmer-4.1
+
+## Added
+
+  - [#4081](https://github.com/wasmerio/wasmer/pull/4081) Add WebcHash::parse_hex helper
+  - [#4046](https://github.com/wasmerio/wasmer/pull/4046) Add C API function to create Module from Engine instead of Store
+
+## Changed
+
+  - [#4095](https://github.com/wasmerio/wasmer/pull/4095) Bumped the webc version
+  - [#4038](https://github.com/wasmerio/wasmer/pull/4038) Clean up the integration tests
+  - [#4085](https://github.com/wasmerio/wasmer/pull/4085) Switch to lazily loading a Wasmer package directly from disk
+  - [#4084](https://github.com/wasmerio/wasmer/pull/4084) Remove unused atty dependency
+  - [#4057](https://github.com/wasmerio/wasmer/pull/4057) login with browser using nonce
+  - [#4073](https://github.com/wasmerio/wasmer/pull/4073) deps(wasmer-wasix): Remove two unused dependencies
+  - [#4068](https://github.com/wasmerio/wasmer/pull/4068) Enable tokio's "net" feature in the virtual-net crate
+  - [#4065](https://github.com/wasmerio/wasmer/pull/4065) deps: Upgrade edge CLI version
+  - [#4064](https://github.com/wasmerio/wasmer/pull/4064) Enable the `cfg_doc` feature on docs.rs
+  - [#4052](https://github.com/wasmerio/wasmer/pull/4052) Selenium-style tests for wasmer.sh
+  - [#4061](https://github.com/wasmerio/wasmer/pull/4061) Use is-terminal to check tty
+  - [#4056](https://github.com/wasmerio/wasmer/pull/4056) Update hermit-abi crate, used version was yanked
+  - [#4055](https://github.com/wasmerio/wasmer/pull/4055) Use a no-op package loader by default in PluggableRuntime
+  - [#4011](https://github.com/wasmerio/wasmer/pull/4011) Move Artifact Register FrameInfo
+  - [#4042](https://github.com/wasmerio/wasmer/pull/4042) Disable unused cbindgen feature
+  - [#4044](https://github.com/wasmerio/wasmer/pull/4044) Update tempfile crate
+  - [#4041](https://github.com/wasmerio/wasmer/pull/4041) Canonicalize host folder on mapdir
+  - [#4040](https://github.com/wasmerio/wasmer/pull/4040) Removed error message when a deserializzation error occurs in Artifact
+  - [#4032](https://github.com/wasmerio/wasmer/pull/4032) Make the CLI respect the `--token` flag
+  - [#4030](https://github.com/wasmerio/wasmer/pull/4030) Remove rustup build dependency
+  - [#4031](https://github.com/wasmerio/wasmer/pull/4031) Speed up the module cache 6x by removing LZW compression
+
+## Fixed
+
+  - [#4096](https://github.com/wasmerio/wasmer/pull/4096) Fix benchmark
+  - [#4050](https://github.com/wasmerio/wasmer/pull/4050) `epoll` with fs fixes
+  - [#4074](https://github.com/wasmerio/wasmer/pull/4074) fix(wasix): Expose FileSystemMapping struct
+  - [#4063](https://github.com/wasmerio/wasmer/pull/4063) Fix docstring for MemoryView struct
+  - [#4047](https://github.com/wasmerio/wasmer/pull/4047) Fixed create exe when zig is not present
+  - [#3970](https://github.com/wasmerio/wasmer/pull/3970) Fixes for wasmer.sh
+  - [#4035](https://github.com/wasmerio/wasmer/pull/4035) Fix help text for `use_system_linker` option in `create_exe` CLI command
+
+
+
+## 4.0.0 - 22/06/2023
+
+Some more behind-the-scene unification and bug fixe since the last beta, mostly on the CLI, but make sure to check all the other changes of the previous beta and alpha release if you came from last stable version.
+
+## Added
+
+  - [#4013](https://github.com/wasmerio/wasmer/pull/4013) Added a `WasmerEnv` abstraction to the CLI
+
+## Changed
+
+  - [#4021](https://github.com/wasmerio/wasmer/pull/4021) Put all cached artifacts under the `~/.wasmer/cache/` directory
+  - [#4018](https://github.com/wasmerio/wasmer/pull/4018) Canonicalize the host path passed to `--mapdir`
+  - [#4019](https://github.com/wasmerio/wasmer/pull/4019) Make sure `ExecutableTarget::from_file()` for `*.wasm` files checks the module cache
+  - [#4022](https://github.com/wasmerio/wasmer/pull/4022) [CI] Defined wich nightly to use to avoid not ready error
+  - [#4001](https://github.com/wasmerio/wasmer/pull/4001) deps: Bump edge CLI
+  - [#4012](https://github.com/wasmerio/wasmer/pull/4012) update links in Wasmer's README
+  - [#3985](https://github.com/wasmerio/wasmer/pull/3985) Display human-friendly progress when starting `wasmer run`
+  - [#4004](https://github.com/wasmerio/wasmer/pull/4004) Ignoring archived package versions when querying the registry
+  - [#3980](https://github.com/wasmerio/wasmer/pull/3980) Re-work logging and command-line argument parsing
+  - [#3983](https://github.com/wasmerio/wasmer/pull/3983) Introduce WAPM query caching to reduce `wasmer run`'s startup delay
+  - [#4002](https://github.com/wasmerio/wasmer/pull/4002) [RISCV64][CI] Use simpler way to install riscv64 packages
+
+## Fixed
+
+
+
+
+## 4.0.0-beta.3 - 15/06/2023
+
+More fixes and improvement to the virtual filesystem, and behind the scene work to unify wasmer tools for this new beta.
+RISC-V will now be built on newest Bookworm Debian release.
+
+## Added
+
+  - [#3990](https://github.com/wasmerio/wasmer/pull/3990) fix(cli): Fix deploy command and add some aliases
+
+## Changed
+
+  - [#3998](https://github.com/wasmerio/wasmer/pull/3998) deps: Upgrade edge cli
+  - [#3989](https://github.com/wasmerio/wasmer/pull/3989) OverlayFS now has COW
+  - [#3991](https://github.com/wasmerio/wasmer/pull/3991) Renamed most appearances of Wapm to Wasmer
+  - [#3992](https://github.com/wasmerio/wasmer/pull/3992) [CI][RISCV64] Try to use bookworm debian instead of sid
+
+## Fixed
+
+
+
+
+## 4.0.0-beta.2 - 09/06/2023
+
+This version added a missing `sock_accept` function to WASI preview1, and also greatly improved the filesystem mappings for the resolver, improving the ease of use of the abilty to run packages with the `wasmer run` command.
+
+## Added
+
+  - [#3913](https://github.com/wasmerio/wasmer/pull/3913) Add filesystem mappings to the resolver
+  - [#3971](https://github.com/wasmerio/wasmer/pull/3971) Added the missing sock_accept for preview1
+  - [#3957](https://github.com/wasmerio/wasmer/pull/3957) Added a test for small Stack (for #3808)
+  - [#3956](https://github.com/wasmerio/wasmer/pull/3956) feat(virtual-fs): Add FsError::StorageFull variant
+
+## Changed
+
+  - [#3710](https://github.com/wasmerio/wasmer/pull/3710) Implemented an asyncify based implementation of asynchronous threading
+  - [#3950](https://github.com/wasmerio/wasmer/pull/3950) tests: Remove debug_output option from snapshot tests.
+  - [#3961](https://github.com/wasmerio/wasmer/pull/3961) chore: Rename wasi dir to wasiX
+  - [#3967](https://github.com/wasmerio/wasmer/pull/3967) Use logs instead of timing to determine if the package cache was hit
+  - [#3955](https://github.com/wasmerio/wasmer/pull/3955) chore(cli): Remove redundant CLI feature flags
+  - [#3953](https://github.com/wasmerio/wasmer/pull/3953) feat: Allow custom manifest file paths in "wasmer publish"
+  - [#3433](https://github.com/wasmerio/wasmer/pull/3433) Module.deserialize - accept AsEngineRef
+  - [#3946](https://github.com/wasmerio/wasmer/pull/3946) Allow deserialized WAPM JSON even if some version have some NULL infos
+  - [#3944](https://github.com/wasmerio/wasmer/pull/3944) Port create-exe and the wasmer C API over to the webc compatibility layer
+
+## Fixed
+
+  - [#3975](https://github.com/wasmerio/wasmer/pull/3975) CLI: Fix deploy Command
+  - [#3969](https://github.com/wasmerio/wasmer/pull/3969) fix: Fix incorrect archive construction in wasmer publish
+
+
+
+## 4.0.0-beta.1 - 01/06/2023
+
+This version introduce WASIX! The superset of WASI. Go to https://wasix.org for more details.
+This version also merged `wasmer run` and `wasmer run-unstable`. Both command still exists but are now exactly the same. `run-unstable` will be removed later, so switch to `wasmer run` if you were using it.
+
+## Added
+
+  - [#3818](https://github.com/wasmerio/wasmer/pull/3818) Added a quickfix for mounting relative directories
+
+## Changed
+
+  - [#3924](https://github.com/wasmerio/wasmer/pull/3924) Rename "wasmer run-unstable" to "wasmer run"
+  - [#3938](https://github.com/wasmerio/wasmer/pull/3938) Use unchecked deserialization for `_unchecked` module functions
+  - [#3918](https://github.com/wasmerio/wasmer/pull/3918) Workspace metadata
+  - [#3919](https://github.com/wasmerio/wasmer/pull/3919) Handle non-200 status codes when downloading packages
+  - [#3917](https://github.com/wasmerio/wasmer/pull/3917) Rename WasiRuntime to Runtime
+
+## Fixed
+
+  - [#3933](https://github.com/wasmerio/wasmer/pull/3933) Fix deserialize calls in doc comments
+  - [#3936](https://github.com/wasmerio/wasmer/pull/3936) Fix for excessive allocation
+  - [#3920](https://github.com/wasmerio/wasmer/pull/3920) Fix filesystem access when running python with `wasmer run-unstable .`
+  - [#3867](https://github.com/wasmerio/wasmer/pull/3867) lib/wasi: try quick fix for WasiFS::get_inode_at_path
+
+
+
+## 4.0.0-alpha.1 - 25/05/2023
+
+A new major release, with a few breaking changes and the removal of many deprecated functions. Also, some methods previously available from on `Engine` has been moved to the `NativeEngineExt` trait.
+Deserialize has changed, with the default version using artifact layout validation. The old function has been renamed to `_unchecked` variant. The speed impact is usually negligeable , but the old function are still present if needed
+Many bugfixes and improvements on `wasmer run` and `wasmer run-unstable` (that will be merged into just `wasmer run` soon). `--allow-multiple-wasi-versions` CLI flag is now removed that is now removed and active by default. Logic for `wasmer config set registry.url` that has been fixed to work with `localhost:1234`
+
+## Added
+
+  - [#3879](https://github.com/wasmerio/wasmer/pull/3879) Add compiler features to wai-bindgen-wasmer
+  - [#1212](https://github.com/wasmerio/wasmer/pull/1212) Add support for GDB JIT debugging
+
+## Changed
+
+  - [#3852](https://github.com/wasmerio/wasmer/pull/3852) Re-work package resolution and make runners use it
+  - [#3910](https://github.com/wasmerio/wasmer/pull/3910) Removed all deprecated functions
+  - [#3900](https://github.com/wasmerio/wasmer/pull/3900) lib/virtual-net: tokio::net::lookup_host requires host:port format
+  - [#3906](https://github.com/wasmerio/wasmer/pull/3906) WASIX updates after superset changes
+  - [#3907](https://github.com/wasmerio/wasmer/pull/3907) Choose subversion of tracing crate in wasix
+  - [#3873](https://github.com/wasmerio/wasmer/pull/3873) Initial implementation for poll on pipe
+  - [#3904](https://github.com/wasmerio/wasmer/pull/3904) Changed tunables to have a VMConfig settings
+  - [#3902](https://github.com/wasmerio/wasmer/pull/3902) TmpFs Memory Usage Tracking and Limiting
+  - [#3894](https://github.com/wasmerio/wasmer/pull/3894) Rework Module deserialization functions
+  - [#3899](https://github.com/wasmerio/wasmer/pull/3899) enable integration tests with debug binary
+  - [#3889](https://github.com/wasmerio/wasmer/pull/3889) Bump llvm
+  - [#3881](https://github.com/wasmerio/wasmer/pull/3881) Use `js-default` feature in wai-bindgen-wasmer
+  - [#3874](https://github.com/wasmerio/wasmer/pull/3874) refactor!: Memory API Modifications (try_clone/copy, duplicate_in_store)
+  - [#3763](https://github.com/wasmerio/wasmer/pull/3763) Implement NativeWasmTypeInto for u32 and u64
+  - [#3866](https://github.com/wasmerio/wasmer/pull/3866) Align vfs and vnet directories with crate names
+  - [#3864](https://github.com/wasmerio/wasmer/pull/3864) feat(cli): Integrate deploy commands
+  - [#3771](https://github.com/wasmerio/wasmer/pull/3771) Asynchronous threading phase2
+  - [#3710](https://github.com/wasmerio/wasmer/pull/3710) Implemented an asyncify based implementation of asynchronous threading
+  - [#3859](https://github.com/wasmerio/wasmer/pull/3859) Support static linking on Windows
+  - [#3856](https://github.com/wasmerio/wasmer/pull/3856) Switch FileSystemCache to use checked artifact deserialization
+  - [#3854](https://github.com/wasmerio/wasmer/pull/3854) deps: Upgrade clap to v4
+  - [#3849](https://github.com/wasmerio/wasmer/pull/3849) Support MinGW
+  - [#3841](https://github.com/wasmerio/wasmer/pull/3841) Introduce a module cache abstraction
+  - [#3400](https://github.com/wasmerio/wasmer/pull/3400) Use the wasm_bindgen_downcast crate for downcasting JsValues
+  - [#3831](https://github.com/wasmerio/wasmer/pull/3831) Introduce a package resolver
+  - [#3843](https://github.com/wasmerio/wasmer/pull/3843) Adapted the publishing script
+
+## Fixed
+
+  - [#3867](https://github.com/wasmerio/wasmer/pull/3867) lib/wasi: try quick fix for WasiFS::get_inode_at_path
+  - [#3891](https://github.com/wasmerio/wasmer/pull/3891) Fix typos in docs
+  - [#3898](https://github.com/wasmerio/wasmer/pull/3898) fix: Use fallback home directory detection in config commands.
+  - [#3861](https://github.com/wasmerio/wasmer/pull/3861) fuzz: fix build error
+  - [#3853](https://github.com/wasmerio/wasmer/pull/3853) Fix cargo update
+
+
+
+## 3.3.0 - 03/05/2023
+
+Along a few important bugfixes, this version introduce JavaScriptCore support, with full WASI support.
+
+## Added
+
+  - [#3825](https://github.com/wasmerio/wasmer/pull/3825) Added support for JavascriptCore
+  - [#3837](https://github.com/wasmerio/wasmer/pull/3837) Cleaned up the GraphQL endpoint logic and added tests
+  - [#3833](https://github.com/wasmerio/wasmer/pull/3833) Fix Missing WaiterError export + Add notify/wait to fd_mmap memory
+  - [#3819](https://github.com/wasmerio/wasmer/pull/3819) ci: add docs.ts test builds
+  - [#3782](https://github.com/wasmerio/wasmer/pull/3782) Add FreeBSD x86 support
+
+## Changed
+
+  - [#3838](https://github.com/wasmerio/wasmer/pull/3838) Re-export `wasmer::EngineRef`
+  - [#3820](https://github.com/wasmerio/wasmer/pull/3820) fd_write: Flush on every write to a file
+  - [#3813](https://github.com/wasmerio/wasmer/pull/3813) Better errors
+
+## Fixed
+
+  - [#3796](https://github.com/wasmerio/wasmer/pull/3796) Fix returning negative i64 values on web target
+  - [#3836](https://github.com/wasmerio/wasmer/pull/3836) Fixed Chinese README example
+  - [#3827](https://github.com/wasmerio/wasmer/pull/3827) Made test-build-docs-rs tests docs generation for all crates under libs, and fixed broken ones
+  - [#3796](https://github.com/wasmerio/wasmer/pull/3796) Fix returning negative i64 values on web target
+
+
+
+## 3.2.1 - 21/04/2023
+
+Some quick fixes for this maintenance release, mainly oriented towards Docs.
+
+## Added
+
+  - [#3782](https://github.com/wasmerio/wasmer/pull/3782) Add FreeBSD x86 support
+
+## Changed
+
+  - [#3786](https://github.com/wasmerio/wasmer/pull/3786) Made Stack Size parametrable (for #3760)
+  - [#3805](https://github.com/wasmerio/wasmer/pull/3805) Wasi runner args
+  - [#3795](https://github.com/wasmerio/wasmer/pull/3795) Make sure the compile function passed to runners is Send+Sync
+  - [#3777](https://github.com/wasmerio/wasmer/pull/3777) Use webc's compat layer in more places
+
+## Fixed
+
+  - [#3806](https://github.com/wasmerio/wasmer/pull/3806) Fixed FunctionEnv migration doc to 3.0
+  - [#3804](https://github.com/wasmerio/wasmer/pull/3804) Fixed doc comment in memory_view.rs
+  - [#3791](https://github.com/wasmerio/wasmer/pull/3791) Fix doc api
+
+
+
+## 3.2.0 - 18/04/2023
+
+A lot of new features since last stable version:
+RISCV Support, new Runners (WCGI), API convergence for JS/SYS, and WASI eXtended.
+
+ * RISCV support, on both Cranelift and LLVM Compiler.
+ * New Runners, with WCGI as a new one
+ * Most WAPM command are now available on the wasmer CLI directly
+ * Using Wasmer on `sys` or `js` backend is more transparent now, with now support for running wasmer on`JavaScriptCore`
+
+ * The WASI implementation has undergone a major refactoring, and will continue evolve significantly over the coming months.
+    - The old `wasmer_wasi` crate was deprecated.
+
+    - To continue using WASI, please switch to the new `wasmer_wasix` crate, which follows a different versioning scheme than the main Wasmer releases.
+    Major changes:
+    - An async runtime is now required. The runtime is pluggable, but only tokio is officially supported at the moment.
+    - The virtual file system layer was renamed from `wasmer-vfs` to `virtual-fs`, and now is built around an async interface that builds on top of `tokio::{AsyncRead/Write}`
+
+    This refactor will unlock many exciting new features that will be announced soon!
+    Just be aware that you will have to expect some instability and frequent releases with potential breaking changes until our new implementation settles. down.
+
+## Added
+
+  - [#3706](https://github.com/wasmerio/wasmer/pull/3706) [CI] Add RISCV in test and build
+  - [#3765](https://github.com/wasmerio/wasmer/pull/3765) Added basic support to inode in filestat_get (for #3583 and #3239)
+  - [#3751](https://github.com/wasmerio/wasmer/pull/3751) Added some unit testing to singlepass compiler
+  - [#3752](https://github.com/wasmerio/wasmer/pull/3752) Added new snapshots tests that use a fixed MIO and TOKIO
+  - [#3759](https://github.com/wasmerio/wasmer/pull/3759) Added the wasmer.sh website to the main repo and a CI/CD build test
+  - [#3747](https://github.com/wasmerio/wasmer/pull/3747) Added missing crate version bump
+
+## Changed
+
+  - [#3778](https://github.com/wasmerio/wasmer/pull/3778) Upgrade to webc v5.0.0
+  - [#3775](https://github.com/wasmerio/wasmer/pull/3775) Ran Cargo update before release
+  - [#3774](https://github.com/wasmerio/wasmer/pull/3774) Wasi threads
+  - [#3772](https://github.com/wasmerio/wasmer/pull/3772) [DOC] Removed paragraph about default-compiler, as it's doesn't exist anymore
+  - [#3766](https://github.com/wasmerio/wasmer/pull/3766) deps: Upgrade memoffset
+  - [#3690](https://github.com/wasmerio/wasmer/pull/3690) Introduce a WebcVolumeFileSystem that works for any WEBC version
+  - [#3424](https://github.com/wasmerio/wasmer/pull/3424) Use "wasmer --version --verbose" in the issue template
+  - [#3757](https://github.com/wasmerio/wasmer/pull/3757) WASI without VM internals
+  - [#3758](https://github.com/wasmerio/wasmer/pull/3758) More and better snapshot tests
+  - [#3756](https://github.com/wasmerio/wasmer/pull/3756) Aarch64 stackprobe
+  - [#3753](https://github.com/wasmerio/wasmer/pull/3753) Upgrade webc from webc 5.0.0-rc.5 to webc 5.0.0-rc.6
+
+## Fixed
+
+  - [#3767](https://github.com/wasmerio/wasmer/pull/3767) Fix Snapshot0 fd_filestat_get and path_filestat_get
+  - [#3723](https://github.com/wasmerio/wasmer/pull/3723) Fix Wait/Notify opcode, the waiters hashmap is now on the Memory itself
+  - [#3749](https://github.com/wasmerio/wasmer/pull/3749) Fixed publish script with latest needed changes
+  - [#3750](https://github.com/wasmerio/wasmer/pull/3750) Fixes Chinese docs links (for #3746)
+  - [#3761](https://github.com/wasmerio/wasmer/pull/3761) Fix error in Korean translation
+
+
+
+## 3.2.0-beta.2 - 05/04/2023
+
+Bug fixes for this beta release, and some exciting new possibilities with the `run-unstable` function from the CLI tools.
+ - New wcgi runner
+ - Caching of runners
+ - Many fixes to wasix
+
+Known issue: RISC-V build is currently broken and will be fixes on next version
+
+## Added
+
+  - [#3731](https://github.com/wasmerio/wasmer/pull/3731) Added missing ASM instructions for wasix on singlepass
+
+## Changed
+
+  - [#3743](https://github.com/wasmerio/wasmer/pull/3743) Bumped crates version pre-beta.2 release
+  - [#3742](https://github.com/wasmerio/wasmer/pull/3742) Update versions of wcgi
+  - [#3739](https://github.com/wasmerio/wasmer/pull/3739) Use cache in runners
+  - [#3735](https://github.com/wasmerio/wasmer/pull/3735) [CI] More WAPM_DEV_TOKEN check for CI
+  - [#3734](https://github.com/wasmerio/wasmer/pull/3734) Updated spin to 0.9.8
+  - [#3733](https://github.com/wasmerio/wasmer/pull/3733) [CI] Use early exit for wasmer_init_works_1 and wasmer_init_works_2 when WAPM_DEV_TOKEN is empty
+  - [#3693](https://github.com/wasmerio/wasmer/pull/3693) Validate Module Artifacts (CLI + WASIX ModuleCache)
+  - [#3724](https://github.com/wasmerio/wasmer/pull/3724) ci: Cancel previous workflow runs when new commits are pushed
+  - [#3722](https://github.com/wasmerio/wasmer/pull/3722) Revert #3715
+  - [#3718](https://github.com/wasmerio/wasmer/pull/3718) Apply CGI environment variables in the correct order
+  - [#3716](https://github.com/wasmerio/wasmer/pull/3716) Move Package Build/Publish Logic to wasmer-registry
+
+## Fixed
+
+  - [#3740](https://github.com/wasmerio/wasmer/pull/3740) Fix fuzz build
+  - [#3741](https://github.com/wasmerio/wasmer/pull/3741) Fixed an issue where blocking polls were being treated as nonblocking
+  - [#3737](https://github.com/wasmerio/wasmer/pull/3737) Fixed FileSystem createdir when parent_inode is an ArcDirectory
+  - [#3736](https://github.com/wasmerio/wasmer/pull/3736) Fixed Vectored IO when a partial operation occurs
+  - [#3726](https://github.com/wasmerio/wasmer/pull/3726) fix CI-Badge on README.md
+  - [#3687](https://github.com/wasmerio/wasmer/pull/3687) Master with fixes
+  - [#3719](https://github.com/wasmerio/wasmer/pull/3719) Fixes a bug which causes libc to thrash the futex_wake_all
+  - [#3715](https://github.com/wasmerio/wasmer/pull/3715) Fix annotation deserializing for the Wasi and Wcgi runners
+  - [#3704](https://github.com/wasmerio/wasmer/pull/3704) Fix the absolute/relative path weirdness when setting up WASI-based runner filesystems
+  - [#3705](https://github.com/wasmerio/wasmer/pull/3705) Fixes post 3.2.0-beta.1 release (but needed for the crates publication)
+
+
+
+## 3.2.0-beta.1 - 22/03/2023
+
+Lots of new things in the release!
+
+  - WASIX, the new WASI eXtended library, that alows WASM to use Threads, Network, and more in both Runtime and inside a Browser.
+  - RISC-V support, on both LLVM and Cranelift compiler.
+  - Improved CLI, with more commands and more WAPM integration.
+  - Lots of behind the scene refactoring, with sys/js convergence on the API side, and a lot of crate changes.
+
+## Added
+
+  - [#3700](https://github.com/wasmerio/wasmer/pull/3700) Added back all removed function for Engine to avoid API breaking changes
+  - [#3654](https://github.com/wasmerio/wasmer/pull/3654) [SINGLEPASS] Add more ROR emitter to ARM64 backend (for #3647)
+  - [#3664](https://github.com/wasmerio/wasmer/pull/3664) feat(wasi): Add CapabilityThreading with max thread count
+  - [#3556](https://github.com/wasmerio/wasmer/pull/3556) Use standard API for js and sys for Module. Added Engine in js
+  - [#3635](https://github.com/wasmerio/wasmer/pull/3635) Added some fixes for the browser version to work again
+  - [#3626](https://github.com/wasmerio/wasmer/pull/3626) add basic coredump generation
+  - [#3631](https://github.com/wasmerio/wasmer/pull/3631) [CI] Add opened type for pull_request on test.yaml
+  - [#3612](https://github.com/wasmerio/wasmer/pull/3612) Added conveniance function FunctionEnvMut::data_and_store_mut
+  - [#3536](https://github.com/wasmerio/wasmer/pull/3536) Add documentation for create-exe syntax
+  - [#3512](https://github.com/wasmerio/wasmer/pull/3512) Add unit test for verifying that caching works when running packages twice
+  - [#3490](https://github.com/wasmerio/wasmer/pull/3490) Fix JS sample code by adding "&mut store"
+
+## Changed
+
+  - [#3244](https://github.com/wasmerio/wasmer/pull/3244) Feat riscv llvm and cranelift
+  - [#3650](https://github.com/wasmerio/wasmer/pull/3650) Wasmer run-unstable
+  - [#3692](https://github.com/wasmerio/wasmer/pull/3692) PluggableRuntime Cleanup
+  - [#3681](https://github.com/wasmerio/wasmer/pull/3681) (feat) Ability to supply your own shared tokio runtime
+  - [#3689](https://github.com/wasmerio/wasmer/pull/3689) Increased CURRENT_VERSION to 3
+  - [#3691](https://github.com/wasmerio/wasmer/pull/3691) Don't error out on webc/wasi run when exiting normaly
+  - [#3683](https://github.com/wasmerio/wasmer/pull/3683) Renamed some crates and changed their version to 0.1.0
+  - [#3677](https://github.com/wasmerio/wasmer/pull/3677) Overlay FileSystem
+  - [#3580](https://github.com/wasmerio/wasmer/pull/3580) Make memoryView lifetime linked to StoreRef instead of Memory
+  - [#3682](https://github.com/wasmerio/wasmer/pull/3682) Update wasmparser to v0.95
+  - [#3676](https://github.com/wasmerio/wasmer/pull/3676) Switch `wasmer_vfs::host_fs` tests over to using temp directories
+  - [#3670](https://github.com/wasmerio/wasmer/pull/3670) Bumped cranelift to 0.91.1 following a critical security alert
+  - [#3666](https://github.com/wasmerio/wasmer/pull/3666) refactor(wasi): Move capabilities into root submodule
+  - [#3644](https://github.com/wasmerio/wasmer/pull/3644) Improvements to the tracing and logging in wasmer
+  - [#3656](https://github.com/wasmerio/wasmer/pull/3656) Re-enable (most) WASIX Snapshot Tests
+  - [#3658](https://github.com/wasmerio/wasmer/pull/3658) [CI] This should setup LLVM on Windows correctly this time
+  - [#3655](https://github.com/wasmerio/wasmer/pull/3655) [CI] Manually setup LLVM because Custom build doesn't include llvm-config.exe
+  - [#3599](https://github.com/wasmerio/wasmer/pull/3599) Move the `wcgi-runner` into Wasmer
+  - [#3646](https://github.com/wasmerio/wasmer/pull/3646) deps: Remove tempdir dependency
+  - [#3641](https://github.com/wasmerio/wasmer/pull/3641) Upgrade LLVM to 14.0
+  - [#3640](https://github.com/wasmerio/wasmer/pull/3640) Zero memory copies on IO
+  - [#3636](https://github.com/wasmerio/wasmer/pull/3636) Removed choice for object-format in create-exe and create-obj commands
+  - [#3637](https://github.com/wasmerio/wasmer/pull/3637) Remove unused import in lib.rs example
+  - [#3632](https://github.com/wasmerio/wasmer/pull/3632) [CI] Another attempt to get Test on external PR
+  - [#3628](https://github.com/wasmerio/wasmer/pull/3628) Registry: Implement App Publishing and Token Generation
+  - [#3627](https://github.com/wasmerio/wasmer/pull/3627) wasi: Remove vbus leftovers and improve task joining
+  - [#3620](https://github.com/wasmerio/wasmer/pull/3620) ci: Remove deleted vbus crate from build workflow
+  - [#3422](https://github.com/wasmerio/wasmer/pull/3422) WASIX
+  - [#3539](https://github.com/wasmerio/wasmer/pull/3539) Document release process and update release script
+  - [#3593](https://github.com/wasmerio/wasmer/pull/3593) Update rkyv 0.7.40 and prettytable-rs to 0.10.0
+  - [#3585](https://github.com/wasmerio/wasmer/pull/3585) CI: Purge Cache with Scheduled Action
+  - [#3590](https://github.com/wasmerio/wasmer/pull/3590) Optimize getting byteLength in MemoryView::new
+  - [#3586](https://github.com/wasmerio/wasmer/pull/3586) Make AsStoreRef and friends work for anything that implements Deref
+  - [#3582](https://github.com/wasmerio/wasmer/pull/3582) bump inkwell to 0.1.1
+  - [#3577](https://github.com/wasmerio/wasmer/pull/3577) Use Cloudflare as CI Cache
+  - [#3353](https://github.com/wasmerio/wasmer/pull/3353) Speed up CI
+  - [#3564](https://github.com/wasmerio/wasmer/pull/3564) Updated Cranelift to 0.91
+  - [#3537](https://github.com/wasmerio/wasmer/pull/3537) bump inkwell to 0.1.0
+  - [#3562](https://github.com/wasmerio/wasmer/pull/3562) Improved handling of wasmer-headless generation and use on local run
+  - [#3563](https://github.com/wasmerio/wasmer/pull/3563) Revert "bump inkwell to 0.1.0"
+  - [#3558](https://github.com/wasmerio/wasmer/pull/3558) Reduce libwasmer-headless size
+  - [#3552](https://github.com/wasmerio/wasmer/pull/3552) create-exe: link with libwasmer-headless
+  - [#3547](https://github.com/wasmerio/wasmer/pull/3547) Remove setting memory for WASI compatibility
+  - [#3531](https://github.com/wasmerio/wasmer/pull/3531) Reenable create-exe tests
+  - [#3534](https://github.com/wasmerio/wasmer/pull/3534) Use JS VM store instead of artificially replicate it
+  - [#3532](https://github.com/wasmerio/wasmer/pull/3532) VMInstance cannot be Clone
+
+## Fixed
+
+  - [#3663](https://github.com/wasmerio/wasmer/pull/3663) Dash fixes and pthreads
+  - [#3684](https://github.com/wasmerio/wasmer/pull/3684) Fix: module cache delta overflow
+  - [#3680](https://github.com/wasmerio/wasmer/pull/3680) Fix for the vectored IO
+  - [#3668](https://github.com/wasmerio/wasmer/pull/3668) Fix doc build
+  - [#3665](https://github.com/wasmerio/wasmer/pull/3665) Fix doc, threads are enabled by default now
+  - [#3662](https://github.com/wasmerio/wasmer/pull/3662) Why is it so difficult to type LLVM_SYS_140_PREFIX
+  - [#3661](https://github.com/wasmerio/wasmer/pull/3661) [CI] New attempt at fixing the Windows build on the CI
+  - [#3659](https://github.com/wasmerio/wasmer/pull/3659) Fixed building with with just the sys feature
+  - [#3648](https://github.com/wasmerio/wasmer/pull/3648) Fix CI and llvm detection
+  - [#3643](https://github.com/wasmerio/wasmer/pull/3643) fix(wasi): Memory leak due to cyclical WasiControlPlane references
+  - [#3639](https://github.com/wasmerio/wasmer/pull/3639) wasi: Thread Lifecycle Fix
+  - [#3630](https://github.com/wasmerio/wasmer/pull/3630) Fix linter
+  - [#3591](https://github.com/wasmerio/wasmer/pull/3591) fix: experimental io
+  - [#3629](https://github.com/wasmerio/wasmer/pull/3629) Webc Inheritance Fixes
+  - [#3598](https://github.com/wasmerio/wasmer/pull/3598) Wasix multithreading fix
+  - [#3601](https://github.com/wasmerio/wasmer/pull/3601) Update CI script to fix deprecation notices
+  - [#3623](https://github.com/wasmerio/wasmer/pull/3623) ci: Fix build.yaml workflow
+  - [#3581](https://github.com/wasmerio/wasmer/pull/3581) Fix WASI example that initialized wasi_config 2 times
+  - [#3584](https://github.com/wasmerio/wasmer/pull/3584) Wasix major fixes and tweaks
+  - [#3557](https://github.com/wasmerio/wasmer/pull/3557) Fix make-test-integration CLI producing files when running locally
+  - [#3566](https://github.com/wasmerio/wasmer/pull/3566) Fix create-exe with create-obj when using dashes in atom names
+  - [#3573](https://github.com/wasmerio/wasmer/pull/3573) Fix/compile not in memory
+  - [#3569](https://github.com/wasmerio/wasmer/pull/3569) Fix error message due to wapm.dev backend change
+  - [#3551](https://github.com/wasmerio/wasmer/pull/3551) Fix markup in Japanese README
+  - [#3493](https://github.com/wasmerio/wasmer/pull/3493) Fixed some memory leak issue with InstanceHandle
+  - [#3523](https://github.com/wasmerio/wasmer/pull/3523) Fix Windows-GNU distribution
+
+
+
+## 3.2.0-alpha.1 - 23/01/2023
+
+## Added
+
+  - [#3477](https://github.com/wasmerio/wasmer/pull/3477) Added support for Wasm Module custom sections in js
+  - [#3462](https://github.com/wasmerio/wasmer/pull/3462) [SINGLEPASS] Added a special case on SSE4.2 backend when dst == src1
+
+## Changed
+
+  - [#3511](https://github.com/wasmerio/wasmer/pull/3511) Incremented CURRENT_VERSION, so all cache will be invalidate and be rebuilt with the 3.2 version
+  - [#3498](https://github.com/wasmerio/wasmer/pull/3498) Wasix Control Plane - Thread Limit + Cleanup
+  - [#3465](https://github.com/wasmerio/wasmer/pull/3465) Remove assert in sse_round_fn and handle case where src2 is in memory
+  - [#3494](https://github.com/wasmerio/wasmer/pull/3494) Update wasmer-toml version
+  - [#3426](https://github.com/wasmerio/wasmer/pull/3426) WASIX Preparation
+  - [#3480](https://github.com/wasmerio/wasmer/pull/3480) Ignore Create-exe with serialize test, something is wrong with the generated exe
+  - [#3471](https://github.com/wasmerio/wasmer/pull/3471) Rename `WasiState::new()` to `WasiState::builder()`
+  - [#3430](https://github.com/wasmerio/wasmer/pull/3430) Implement support for multiple commands in one native executable
+  - [#3455](https://github.com/wasmerio/wasmer/pull/3455) Remove hardcoded rust-toolchain and use panic=abort on windows-gnu
+  - [#3353](https://github.com/wasmerio/wasmer/pull/3353) Speed up CI
+  - [#3433](https://github.com/wasmerio/wasmer/pull/3433) Module.deserialize - accept AsEngineRef
+  - [#3428](https://github.com/wasmerio/wasmer/pull/3428) Implement wasmer config
+  - [#3432](https://github.com/wasmerio/wasmer/pull/3432) Amend changes to wasmer init
+  - [#3439](https://github.com/wasmerio/wasmer/pull/3439) Use GNU/Linux frame registration code for FreeBSD too
+  - [#3324](https://github.com/wasmerio/wasmer/pull/3324) Implement wasmer init and wasmer publish
+  - [#3431](https://github.com/wasmerio/wasmer/pull/3431) Revert "Implement wasmer init and wasmer publish"
+
+## Fixed
+
+  - [#3483](https://github.com/wasmerio/wasmer/pull/3483) Fix feature flags for make-build-wasmer-headless
+  - [#3496](https://github.com/wasmerio/wasmer/pull/3496) Fixed create-exe tests for object-format serialized
+  - [#3479](https://github.com/wasmerio/wasmer/pull/3479) This should fix CI build of CAPI Headless
+  - [#3473](https://github.com/wasmerio/wasmer/pull/3473) Fix wasm publish validation
+  - [#3467](https://github.com/wasmerio/wasmer/pull/3467) Fix wasmer-wasi-js compilation
+  - [#3443](https://github.com/wasmerio/wasmer/pull/3443) Fix fuzz errors
+  - [#3456](https://github.com/wasmerio/wasmer/pull/3456) Fix wasmer-rust readme example
+  - [#3440](https://github.com/wasmerio/wasmer/pull/3440) Fix CI for external collaborator PRs
+  - [#3427](https://github.com/wasmerio/wasmer/pull/3427) Fix cargo-deny failing on webc crate
+  - [#3423](https://github.com/wasmerio/wasmer/pull/3423) Fix minor typo
+  - [#3419](https://github.com/wasmerio/wasmer/pull/3419) Fix CHANGELOG generation to list by PR merged date, not created date
+
+
+
+## Fixed
+
+  - [#3439](https://github.com/wasmerio/wasmer/pull/3439) Use GNU/Linux frame registration code for FreeBSD too
+  - [#3448](https://github.com/wasmerio/wasmer/pull/3448) Fix `make install-capi-lib` install paths
+
+## 3.1.0 - 12/12/2022
+
+## Added
+
+  - [#3403](https://github.com/wasmerio/wasmer/pull/3403) Add wasm_importtype_copy to C API
+
+## Changed
+
+  - [#3416](https://github.com/wasmerio/wasmer/pull/3416) Download and install packages via .tar.gz URLs and improve installation error message
+  - [#3402](https://github.com/wasmerio/wasmer/pull/3402) Do not run first command of wapm file and print all commands instead
+  - [#3400](https://github.com/wasmerio/wasmer/pull/3400) Use the wasm_bindgen_downcast crate for downcasting JsValues
+  - [#3363](https://github.com/wasmerio/wasmer/pull/3363) Store Used CpuFeature in Artifact instead of Present CpuFeatures for Singlepass
+  - [#3378](https://github.com/wasmerio/wasmer/pull/3378) Introduced EngineRef and AsEngineRef trait
+  - [#3386](https://github.com/wasmerio/wasmer/pull/3386) Restore Support For All Wasi Clock Types
+  - [#3153](https://github.com/wasmerio/wasmer/pull/3153) SharedMemory & Atomics
+
+## Fixed
+
+  - [#3415](https://github.com/wasmerio/wasmer/pull/3415) Fix singlepass for Aarch64
+  - [#3395](https://github.com/wasmerio/wasmer/pull/3395) Fix create-exe to be able to cross-compile on Windows
+  - [#3396](https://github.com/wasmerio/wasmer/pull/3396) Fix build doc and minimum-sys build
+
+## 3.0.2 - 25/11/2022
+
+## Added
+
+  - [#3364](https://github.com/wasmerio/wasmer/pull/3364) Added the actual LZCNT / TZCNT implementation
+
+## Changed
+
+  - [#3365](https://github.com/wasmerio/wasmer/pull/3365) Improve FreeBSD support
+  - [#3368](https://github.com/wasmerio/wasmer/pull/3368) Remove wasi conditional compilation from wasmer-registry
+  - [#3367](https://github.com/wasmerio/wasmer/pull/3367) Change LLVM detection in Makefile
+
+## Fixed
+
+  - [#3370](https://github.com/wasmerio/wasmer/pull/3370) Fix wasmer run not interpreting URLs correctly + display fixes
+  - [#3371](https://github.com/wasmerio/wasmer/pull/3371) Fix cargo binstall
+
+
+## 3.0.1 - 23/11/2022
+
+## Added
+
+  - [#3361](https://github.com/wasmerio/wasmer/pull/3361) Give users feedback when they are running "wasmer add ..."
+
+## Changed
+
+  - [#3360](https://github.com/wasmerio/wasmer/pull/3360) Introduce a "wasmer_registry::queries" module with all GraphQL queries
+  - [#3355](https://github.com/wasmerio/wasmer/pull/3355) Fetch the pirita download URL
+  - [#3344](https://github.com/wasmerio/wasmer/pull/3344) Revert #3145
+  - [#3302](https://github.com/wasmerio/wasmer/pull/3302) Some Refactor of Singlepass compiler to have better error and cpu features handling
+  - [#3296](https://github.com/wasmerio/wasmer/pull/3296) Use the right collection when parsing type section
+  - [#3292](https://github.com/wasmerio/wasmer/pull/3292) Precompute offsets in VMOffsets
+  - [#3290](https://github.com/wasmerio/wasmer/pull/3290) Limit the use of clone when handling Compilation object
+  - [#3316](https://github.com/wasmerio/wasmer/pull/3316) Implement wasmer whoami
+  - [#3341](https://github.com/wasmerio/wasmer/pull/3341) Update CHANGELOG.md
+
+## Fixed
+
+  - [#3342](https://github.com/wasmerio/wasmer/pull/3342) Fixes for 3.0.0 release
+
+## 3.0.0 - 20/11/2022
+
+## Added
+
+  - [#3339](https://github.com/wasmerio/wasmer/pull/3339) Fixes for wasmer login / wasmer add
+  - [#3337](https://github.com/wasmerio/wasmer/pull/3337) Add automation script to automate deploying releases on GitHub
+  - [#3338](https://github.com/wasmerio/wasmer/pull/3338) Re-add codecov to get coverage reports
+
+## Changed
+
+  - [#3295](https://github.com/wasmerio/wasmer/pull/3295) Implement wasmer run {url}
+
+## Fixed
+
+
+## 3.0.0-rc.3 - 2022/11/18
+
+## Added
+
+  - [#3314](https://github.com/wasmerio/wasmer/pull/3314) Add windows-gnu workflow
+
+## Changed
+
+  - [#3317](https://github.com/wasmerio/wasmer/pull/3317) Port "wapm install" to Wasmer
+  - [#3318](https://github.com/wasmerio/wasmer/pull/3318) Bump the MSRV to 1.63
+  - [#3319](https://github.com/wasmerio/wasmer/pull/3319) Disable 'Test integration CLI' on CI for the Windows platform as it's not working at all
+  - [#3297](https://github.com/wasmerio/wasmer/pull/3297) Implement wasmer login
+  - [#3311](https://github.com/wasmerio/wasmer/pull/3311) Export Module::IoCompileError as it's an error returned by an exported function
+  - [#2800](https://github.com/wasmerio/wasmer/pull/2800) RISC-V support
+  - [#3293](https://github.com/wasmerio/wasmer/pull/3293) Removed call to to_vec() on assembler.finalise()
+  - [#3288](https://github.com/wasmerio/wasmer/pull/3288) Rollback all the TARGET_DIR changes
+  - [#3284](https://github.com/wasmerio/wasmer/pull/3284) Makefile now handle TARGET_DIR env. var. for build too
+  - [#3276](https://github.com/wasmerio/wasmer/pull/3276) Remove unnecessary checks to test internet connection
+  - [#3266](https://github.com/wasmerio/wasmer/pull/3266) Return ENotCapable error when accessing unknown files on root (for #3263 and #3264)
+  - [#3275](https://github.com/wasmerio/wasmer/pull/3275) Disable printing "local package ... not found" in release mode
+  - [#3273](https://github.com/wasmerio/wasmer/pull/3273) Undo Makefile commit
+
+## Fixed
+
+  - [#3299](https://github.com/wasmerio/wasmer/pull/3299) Fix "create-exe" for windows-x86_64 target
+  - [#3294](https://github.com/wasmerio/wasmer/pull/3294) Fix test sys yaml syntax
+  - [#3287](https://github.com/wasmerio/wasmer/pull/3287) Fix Makefile with TARGET_DIR end with release folder, removing it
+  - [#3286](https://github.com/wasmerio/wasmer/pull/3286) Fix Makefile with TARGET_DIR end with release folder
+  - [#3285](https://github.com/wasmerio/wasmer/pull/3285) Fix CI to setup TARGET_DIR to target/release directly
+  - [#3277](https://github.com/wasmerio/wasmer/pull/3277) Fix red CI on master
+
+
+## 3.0.0-rc.2 - 2022/11/02
+
+## Added
+
+
+## Changed
+
+  - [#3258](https://github.com/wasmerio/wasmer/pull/3258) Migrate pirita / native executables feature from wasmer-private
+
+## Fixed
+
+  - [#3268](https://github.com/wasmerio/wasmer/pull/3268) Fix fd_right nightly test to avoid foo.txt file leftover
+  - [#3260](https://github.com/wasmerio/wasmer/pull/3260) Fix bug in wasmer run
+  - [#3257](https://github.com/wasmerio/wasmer/pull/3257) Fix linux-aarch64 build
+
+
+## 3.0.0-rc.1 - 2022/10/25
+
+## Added
+
+  - [#3222](https://github.com/wasmerio/wasmer/pull/3222) Add function to retrieve function name from wasm_frame_t
+  - [#3240](https://github.com/wasmerio/wasmer/pull/3240) Fix filesystem rights on WASI, add integration test for file permissions
+  - [#3238](https://github.com/wasmerio/wasmer/pull/3238) Fixed main README ocaml homepage link and added ocaml in other language README
+  - [#3145](https://github.com/wasmerio/wasmer/pull/3145) C-API: add functions to overwrite stdin / stdout / stderr handlers
+
+## Changed
+
+  - [#3215](https://github.com/wasmerio/wasmer/pull/3215) Update wasmer --version logic, integrate wapm-cli
+  - [#3248](https://github.com/wasmerio/wasmer/pull/3248) Move loupe CHANGELOG entry from 2.3.0 to 3.x
+  - [#3230](https://github.com/wasmerio/wasmer/pull/3230) Remove test if dest file exist on path_rename wasi syscall (for #3228)
+  - [#3061](https://github.com/wasmerio/wasmer/pull/3061) Removed trailing zero in WASI::fd_prestat_dir_name name return (for #3025)
+  - [#3223](https://github.com/wasmerio/wasmer/pull/3223) Delete lib/wasi-types-generated directory
+  - [#3178](https://github.com/wasmerio/wasmer/pull/3178) Feat enhanced tinytunable test
+  - [#3177](https://github.com/wasmerio/wasmer/pull/3177) Auto-generate wasi-types from .wit files
+  - [#3218](https://github.com/wasmerio/wasmer/pull/3218) Seal `HostFunctionKind`
+
+## Fixed
+
+  - [#3221](https://github.com/wasmerio/wasmer/pull/3221) Fix #3197
+  - [#3229](https://github.com/wasmerio/wasmer/pull/3229) Fixed version to nightly-2022-10-09 for the CI build Minimal Wasmer Headless again
+  - [#3227](https://github.com/wasmerio/wasmer/pull/3227) Fixed version to nightly-2022-10-09 for the CI build Minimal Wasmer Headless
+  - [#3226](https://github.com/wasmerio/wasmer/pull/3226) Fixed version to nightly-2002-10-09 for the CI build Minimal Wasmer Headless
+  - [#3211](https://github.com/wasmerio/wasmer/pull/3211) fix popcnt for aarch64
+  - [#3204](https://github.com/wasmerio/wasmer/pull/3204) Fixed a typo in README
+
+
+## 3.0.0-beta.2 - 2022/09/26
+
+## Added
+
+  - [#3176](https://github.com/wasmerio/wasmer/pull/3176) Add support for `cargo-binstall`
+  - [#3141](https://github.com/wasmerio/wasmer/pull/3141) The API breaking changes from future WASIX/Network/Threading addition
+  - [#3119](https://github.com/wasmerio/wasmer/pull/3119) Added LinearMemory trait
+  - [#3117](https://github.com/wasmerio/wasmer/pull/3117) Add tests for wasmer-cli create-{exe,obj} commands
+  - [#3101](https://github.com/wasmerio/wasmer/pull/3101) CI/build.yaml: add libwasmer headless in default distribution
+  - [#3090](https://github.com/wasmerio/wasmer/pull/3090) Added version to the wasmer cli
+  - [#3089](https://github.com/wasmerio/wasmer/pull/3089) Add wasi_* C-API function changes in migration guide for 3.0.0
+  - [#3076](https://github.com/wasmerio/wasmer/pull/3076) Add support for cross-compiling in create-exe with zig cc WIP
+  - [#3072](https://github.com/wasmerio/wasmer/pull/3072) Add back `Function::*_with_env(…)`
+  - [#3048](https://github.com/wasmerio/wasmer/pull/3048) Add cloudcompiler.yaml
+  - [#3068](https://github.com/wasmerio/wasmer/pull/3068) create-{exe,obj}: add documentations and header file generation for create-obj
+  - [#3065](https://github.com/wasmerio/wasmer/pull/3065) Added '.' and '..' special folder t WASI fd_readdir return (for #3033)
+
+## Changed
+
+  - [#3184](https://github.com/wasmerio/wasmer/pull/3184) Test libwasmer.dll on Windows
+  - [#3164](https://github.com/wasmerio/wasmer/pull/3164) Synchronize between -sys and -js tests
+  - [#3165](https://github.com/wasmerio/wasmer/pull/3165) Initial port of make test-js-core (port wasmer API to core)
+  - [#3138](https://github.com/wasmerio/wasmer/pull/3138) Js imports revamp
+  - [#3142](https://github.com/wasmerio/wasmer/pull/3142) Bump rust toolchain
+  - [#3116](https://github.com/wasmerio/wasmer/pull/3116) Multithreading, full networking and RPC for WebAssembly
+  - [#3130](https://github.com/wasmerio/wasmer/pull/3130) Remove panics from Artifact::deserialize
+  - [#3134](https://github.com/wasmerio/wasmer/pull/3134) Bring libwasmer-headless.a from 22MiB to 7.2MiB (on my machine)
+  - [#3131](https://github.com/wasmerio/wasmer/pull/3131) Update for migration-to-3.0.0 for MemoryView changes
+  - [#3123](https://github.com/wasmerio/wasmer/pull/3123) Lower libwasmer headless size
+  - [#3132](https://github.com/wasmerio/wasmer/pull/3132) Revert "Lower libwasmer headless size"
+  - [#3128](https://github.com/wasmerio/wasmer/pull/3128) scripts/publish.py: validate crates version before publishing
+  - [#3126](https://github.com/wasmerio/wasmer/pull/3126) scripts/publish.py: replace toposort dependency with python std graphlib module
+  - [#3122](https://github.com/wasmerio/wasmer/pull/3122) Update Cargo.lock dependencies
+  - [#3118](https://github.com/wasmerio/wasmer/pull/3118) Refactor Artifact enum into a struct
+  - [#3114](https://github.com/wasmerio/wasmer/pull/3114) Implemented shared memory for Wasmer in preparation for multithreading
+  - [#3104](https://github.com/wasmerio/wasmer/pull/3104) Re-enabled ExternRef tests
+  - [#3103](https://github.com/wasmerio/wasmer/pull/3103) create-exe: prefer libwasmer headless when cross-compiling
+  - [#3097](https://github.com/wasmerio/wasmer/pull/3097) MemoryView lifetime tied to memory and not StoreRef
+  - [#3095](https://github.com/wasmerio/wasmer/pull/3095) create-exe: list supported cross-compilation target triples in help …
+  - [#3096](https://github.com/wasmerio/wasmer/pull/3096) create-exe: use cached wasmer tarballs for network fetches
+  - [#3083](https://github.com/wasmerio/wasmer/pull/3083) Disable wasm build in build CI
+  - [#3081](https://github.com/wasmerio/wasmer/pull/3081) 3.0.0-beta release
+  - [#3079](https://github.com/wasmerio/wasmer/pull/3079) Migrate to clap from structopt
+  - [#3075](https://github.com/wasmerio/wasmer/pull/3075) Remove __wbindgen_thread_id
+  - [#3074](https://github.com/wasmerio/wasmer/pull/3074) Update chrono to 0.4.20, avoiding RUSTSEC-2020-0159
+  - [#3070](https://github.com/wasmerio/wasmer/pull/3070) wasmer-cli: Allow create-exe to receive a static object as input
+  - [#3069](https://github.com/wasmerio/wasmer/pull/3069) Remove native feature entry from docs.rs metadata
+  - [#3057](https://github.com/wasmerio/wasmer/pull/3057) wasmer-cli: create-obj command
+  - [#3060](https://github.com/wasmerio/wasmer/pull/3060) CI: Unset rustup override after usage instead of setting it to stable
+
+## Fixed
+
+  - [#3192](https://github.com/wasmerio/wasmer/pull/3192) fix the typos
+  - [#3185](https://github.com/wasmerio/wasmer/pull/3185) Fix `wasmer compile` command for non-x86 target
+  - [#3129](https://github.com/wasmerio/wasmer/pull/3129) Fix differences between -sys and -js API
+  - [#3137](https://github.com/wasmerio/wasmer/pull/3137) Fix cache path not being present during installation of cross-tarball
+  - [#3115](https://github.com/wasmerio/wasmer/pull/3115) Fix static object signature deserialization
+  - [#3093](https://github.com/wasmerio/wasmer/pull/3093) Fixed a potential issue when renaming a file
+  - [#3088](https://github.com/wasmerio/wasmer/pull/3088) Fixed an issue when renaming a file from a preopened dir directly (for 3084)
+  - [#3078](https://github.com/wasmerio/wasmer/pull/3078) Fix errors from "make lint"
+  - [#3052](https://github.com/wasmerio/wasmer/pull/3052) Fixed a memory corruption issue with JS memory operations that were r…
+  - [#3058](https://github.com/wasmerio/wasmer/pull/3058) Fix trap tracking
+
+
+## 3.0.0-alpha.4 - 2022/07/28
+
+## Added
+
+  - [#3035](https://github.com/wasmerio/wasmer/pull/3035) Added a simple divide by zero trap wast test (for #1899)
+  - [#3008](https://github.com/wasmerio/wasmer/pull/3008) Add check-public-api.yaml workflow
+  - [#3021](https://github.com/wasmerio/wasmer/pull/3021) Added back some needed relocation for arm64 llvm compiler
+  - [#2982](https://github.com/wasmerio/wasmer/pull/2982) Add a `rustfmt.toml` file to the repository
+  - [#2953](https://github.com/wasmerio/wasmer/pull/2953) Makefile: add `check` target
+  - [#2952](https://github.com/wasmerio/wasmer/pull/2952) CI: add make build-wasmer-wasm test
+
+## Changed
+
+  - [#3051](https://github.com/wasmerio/wasmer/pull/3051) Updated Crenelift to v0.86.1
+  - [#3038](https://github.com/wasmerio/wasmer/pull/3038) Re-introduce create-exe to wasmer-cli v3.0
+  - [#3049](https://github.com/wasmerio/wasmer/pull/3049) Disable traps::trap_display_multi_module test for Windows+singlepass
+  - [#3047](https://github.com/wasmerio/wasmer/pull/3047) Improved EngineBuilder API
+  - [#3046](https://github.com/wasmerio/wasmer/pull/3046) Merge Backend into EngineBuilder and refactor feature flags
+  - [#3039](https://github.com/wasmerio/wasmer/pull/3039) Improved hashing/ids of function envs
+  - [#3029](https://github.com/wasmerio/wasmer/pull/3029) Remove Engine, Artifact traits, merge all Engines into one, make everything rkyv serialazable
+  - [#2892](https://github.com/wasmerio/wasmer/pull/2892) Implement new Context API for Wasmer 3.0
+  - [#3031](https://github.com/wasmerio/wasmer/pull/3031) Update docs/migration_to_3.0.0.md
+  - [#3030](https://github.com/wasmerio/wasmer/pull/3030) Remove cranelift dependency from wasmer-wasi
+  - [#3028](https://github.com/wasmerio/wasmer/pull/3028) Ctx store rename
+  - [#3023](https://github.com/wasmerio/wasmer/pull/3023) Changed CI rust install action to dtolnay one
+  - [#3013](https://github.com/wasmerio/wasmer/pull/3013) Context api refactor
+  - [#2999](https://github.com/wasmerio/wasmer/pull/2999) Support --invoke option for emscripten files without _start function
+  - [#3003](https://github.com/wasmerio/wasmer/pull/3003) Remove RuntimeError::raise from public API
+  - [#3000](https://github.com/wasmerio/wasmer/pull/3000) Allow debugging of EXC_BAD_INSTRUCTION on macOS
+  - [#2946](https://github.com/wasmerio/wasmer/pull/2946) Removing dylib and staticlib engines in favor of a single Universal Engine
+  - [#2996](https://github.com/wasmerio/wasmer/pull/2996) Migrated al examples to new Context API
+  - [#2973](https://github.com/wasmerio/wasmer/pull/2973) Port C API to new Context API
+  - [#2974](https://github.com/wasmerio/wasmer/pull/2974) Context api tests
+  - [#2988](https://github.com/wasmerio/wasmer/pull/2988) Have make targets install-capi-lib,install-pkgconfig work without building the wasmer binary
+  - [#2976](https://github.com/wasmerio/wasmer/pull/2976) Upgrade enumset minimum version to one that compiles
+  - [#2969](https://github.com/wasmerio/wasmer/pull/2969) Port JS API to new Context API
+  - [#2966](https://github.com/wasmerio/wasmer/pull/2966) Singlepass nopanic
+  - [#2949](https://github.com/wasmerio/wasmer/pull/2949) Switch back to using custom LLVM builds on CI
+  - [#2963](https://github.com/wasmerio/wasmer/pull/2963) Remove libxcb and libwayland dependencies from wasmer-cli release build
+  - [#2957](https://github.com/wasmerio/wasmer/pull/2957) Enable multi-value handling in Singlepass compiler
+  - [#2941](https://github.com/wasmerio/wasmer/pull/2941) Implementation of WASIX and a fully networking for Web Assembly
+  - [#2947](https://github.com/wasmerio/wasmer/pull/2947) - Converted the WASI js test into a generic stdio test that works for…
+  - [#2940](https://github.com/wasmerio/wasmer/pull/2940) Merge `wasmer3` back to `master` branch
+  - [#2939](https://github.com/wasmerio/wasmer/pull/2939) Rename NativeFunc to TypedFunction
+
+## Fixed
+
+  - [#3045](https://github.com/wasmerio/wasmer/pull/3045) Fixed WASI fd_read syscall when reading multiple iovs and read is partial (for #2904)
+  - [#2997](https://github.com/wasmerio/wasmer/pull/2997) Fix "run --invoke [function]" to behave the same as "run"
+  - [#3027](https://github.com/wasmerio/wasmer/pull/3027) Fixed residual package-doc issues
+  - [#3026](https://github.com/wasmerio/wasmer/pull/3026) test-js.yaml: fix typo
+  - [#3017](https://github.com/wasmerio/wasmer/pull/3017) Fixed translation in README.md
+  - [#3001](https://github.com/wasmerio/wasmer/pull/3001) Fix context capi ci errors
+  - [#2967](https://github.com/wasmerio/wasmer/pull/2967) Fix singlepass on arm64 that was trying to emit a sub opcode with a constant as destination (for #2959)
+  - [#2954](https://github.com/wasmerio/wasmer/pull/2954) Some fixes to x86_64 Singlepass compiler, when using atomics
+  - [#2950](https://github.com/wasmerio/wasmer/pull/2950) compiler-cranelift: Fix typo in enum variant
+  - [#2948](https://github.com/wasmerio/wasmer/pull/2948) Fix regression on gen_import_call_trampoline_arm64()
+  - [#2943](https://github.com/wasmerio/wasmer/pull/2943) Fix build error on some archs by using c_char instead of i8
+  - [#2944](https://github.com/wasmerio/wasmer/pull/2944) Fix duplicate entries in the CHANGELOG
+  - [#2942](https://github.com/wasmerio/wasmer/pull/2942) Fix clippy lints
+
+## 2.3.0 - 2022/06/06
+
+### Added
+- [#2862](https://github.com/wasmerio/wasmer/pull/2862) Added CI builds for linux-aarch64 target.
+- [#2811](https://github.com/wasmerio/wasmer/pull/2811) Added support for EH Frames in singlepass
+- [#2851](https://github.com/wasmerio/wasmer/pull/2851) Allow Wasmer to compile to Wasm/WASI
+
+### Changed
+- [#2807](https://github.com/wasmerio/wasmer/pull/2807) Run Wasm code in a separate stack
+- [#2802](https://github.com/wasmerio/wasmer/pull/2802) Support Dylib engine with Singlepass
+- [#2836](https://github.com/wasmerio/wasmer/pull/2836) Improve TrapInformation data stored at runtime
+- [#2864](https://github.com/wasmerio/wasmer/pull/2864) `wasmer-cli`: remove wasi-experimental-io-devices from default builds
+- [#2933](https://github.com/wasmerio/wasmer/pull/2933) Rename NativeFunc to TypedFunction.
+
+### Fixed
+- [#2829](https://github.com/wasmerio/wasmer/pull/2829) Improve error message oriented from JS object.
+- [#2828](https://github.com/wasmerio/wasmer/pull/2828) Fix JsImportObject resolver.
+- [#2872](https://github.com/wasmerio/wasmer/pull/2872) Fix `WasmerEnv` finalizer
+- [#2821](https://github.com/wasmerio/wasmer/pull/2821) Opt in `sys` feature
+
+## 2.2.1 - 2022/03/15
+
+### Fixed
+- [#2812](https://github.com/wasmerio/wasmer/pull/2812) Fixed another panic due to incorrect drop ordering.
+
+## 2.2.0 - 2022/02/28
+
+### Added
+- [#2775](https://github.com/wasmerio/wasmer/pull/2775) Added support for SSE 4.2 in the Singlepass compiler as an alternative to AVX.
+- [#2805](https://github.com/wasmerio/wasmer/pull/2805) Enabled WASI experimental I/O devices by default in releases.
+
+### Fixed
+- [#2795](https://github.com/wasmerio/wasmer/pull/2795) Fixed a bug in the Singlepass compiler introduced in #2775.
+- [#2806](https://github.com/wasmerio/wasmer/pull/2806) Fixed a panic due to incorrect drop ordering of `Module` fields.
+
+## 2.2.0-rc2 - 2022/02/15
+
+### Fixed
+- [#2778](https://github.com/wasmerio/wasmer/pull/2778) Fixed f32_load/f64_load in Singlepass. Also fixed issues with out-of-range conditional branches.
+- [#2786](https://github.com/wasmerio/wasmer/pull/2786) Fixed a potential integer overflow in WasmPtr memory access methods.
+- [#2787](https://github.com/wasmerio/wasmer/pull/2787) Fixed a codegen regression in the Singlepass compiler due to non-determinism of `HashSet` iteration.
+
+## 2.2.0-rc1 - 2022/01/28
+
+### Added
+- [#2750](https://github.com/wasmerio/wasmer/pull/2750) Added Aarch64 support to Singlepass (both Linux and macOS).
+- [#2753](https://github.com/wasmerio/wasmer/pull/2753) Re-add "dylib" to the list of default features.
+
+### Changed
+- [#2747](https://github.com/wasmerio/wasmer/pull/2747) Use a standard header for metadata in all serialized modules.
+- [#2759](https://github.com/wasmerio/wasmer/pull/2759) Use exact version for Wasmer crate dependencies.
+
+### Fixed
+- [#2769](https://github.com/wasmerio/wasmer/pull/2769) Fixed deadlock in emscripten dynamic calls.
+- [#2742](https://github.com/wasmerio/wasmer/pull/2742) Fixed WASMER_METADATA alignment in the dylib engine.
+- [#2746](https://github.com/wasmerio/wasmer/pull/2746) Fixed invoking `wasmer binfmt register` from `$PATH`.
+- [#2748](https://github.com/wasmerio/wasmer/pull/2748) Use trampolines for all libcalls in engine-universal and engine-dylib.
+- [#2766](https://github.com/wasmerio/wasmer/pull/2766) Remove an attempt to reserve a GPR when no GPR clobbering is occurring.
+- [#2768](https://github.com/wasmerio/wasmer/pull/2768) Fixed serialization of FrameInfo on Dylib engine.
+
+## 2.1.1 - 2021/12/20
+
+### Added
+- [#2726](https://github.com/wasmerio/wasmer/pull/2726) Added `externs_vec` method to `ImportObject`.
+- [#2724](https://github.com/wasmerio/wasmer/pull/2724) Added access to the raw `Instance` JS object in Wsasmer-js.
+
+### CHanged
+- [#2711](https://github.com/wasmerio/wasmer/pull/2711) Make C-API and Wasi dependencies more lean
+- [#2706](https://github.com/wasmerio/wasmer/pull/2706) Refactored the Singlepass compiler in preparation for AArch64 support (no user visible changes).
+### Fixed
+- [#2717](https://github.com/wasmerio/wasmer/pull/2717) Allow `Exports` to be modified after being cloned.
+- [#2719](https://github.com/wasmerio/wasmer/pull/2719) Fixed `wasm_importtype_new`'s Rust signature to not assume boxed vectors.
+- [#2723](https://github.com/wasmerio/wasmer/pull/2723) Fixed a bug in parameter passing in the Singlepass compiler.
+- [#2768](https://github.com/wasmerio/wasmer/pull/2768) Fixed issue with Frame Info on dylib engine.
+
+## 2.1.0 - 2021/11/30
+
+### Added
+- [#2574](https://github.com/wasmerio/wasmer/pull/2574) Added Windows support to Singlepass.
+- [#2535](https://github.com/wasmerio/wasmer/pull/2435) Added iOS support for Wasmer. This relies on the `dylib-engine`.
+- [#2460](https://github.com/wasmerio/wasmer/pull/2460) Wasmer can now compile to Javascript via `wasm-bindgen`. Use the `js-default` (and no default features) feature to try it!.
+- [#2491](https://github.com/wasmerio/wasmer/pull/2491) Added support for WASI to Wasmer-js.
+- [#2436](https://github.com/wasmerio/wasmer/pull/2436) Added the x86-32 bit variant support to LLVM compiler.
+- [#2499](https://github.com/wasmerio/wasmer/pull/2499) Added a subcommand to linux wasmer-cli to register wasmer with binfmt_misc
+- [#2511](https://github.com/wasmerio/wasmer/pull/2511) Added support for calling dynamic functions defined on the host
+- [#2491](https://github.com/wasmerio/wasmer/pull/2491) Added support for WASI in Wasmer-js
+- [#2592](https://github.com/wasmerio/wasmer/pull/2592) Added `ImportObject::get_namespace_exports` to allow modifying the contents of an existing namespace in an `ImportObject`.
+- [#2694](https://github.com/wasmerio/wasmer/pull/2694) wasmer-js: Allow an `ImportObject` to be extended with a JS object.
+- [#2698](https://github.com/wasmerio/wasmer/pull/2698) Provide WASI imports when invoking an explicit export from the CLI.
+- [#2701](https://github.com/wasmerio/wasmer/pull/2701) Improved VFS API for usage from JS
+
+### Changed
+- [#2460](https://github.com/wasmerio/wasmer/pull/2460) **breaking change** `wasmer` API usage with `no-default-features` requires now the `sys` feature to preserve old behavior.
+- [#2476](https://github.com/wasmerio/wasmer/pull/2476) Removed unncessary abstraction `ModuleInfoTranslate` from `wasmer-compiler`.
+- [#2442](https://github.com/wasmerio/wasmer/pull/2442) **breaking change** Improved `WasmPtr`, added `WasmCell` for host/guest interaction. `WasmPtr::deref` will now return `WasmCell<'a, T>` instead of `&'a Cell<T>`, `WasmPtr::deref_mut` is now deleted from the API.
+- [#2427](https://github.com/wasmerio/wasmer/pull/2427) Update `loupe` to 0.1.3.
+- [#2685](https://github.com/wasmerio/wasmer/pull/2685) The minimum LLVM version for the LLVM compiler is now 12. LLVM 13 is used by default.
+- [#2569](https://github.com/wasmerio/wasmer/pull/2569) Add `Send` and `Sync` to uses of the `LikeNamespace` trait object.
+- [#2692](https://github.com/wasmerio/wasmer/pull/2692) Made module serialization deterministic.
+- [#2693](https://github.com/wasmerio/wasmer/pull/2693) Validate CPU features when loading a deserialized module.
+
+### Fixed
+- [#2599](https://github.com/wasmerio/wasmer/pull/2599) Fixed Universal engine for Linux/Aarch64 target.
+- [#2587](https://github.com/wasmerio/wasmer/pull/2587) Fixed deriving `WasmerEnv` when aliasing `Result`.
+- [#2518](https://github.com/wasmerio/wasmer/pull/2518) Remove temporary file used to creating an artifact when creating a Dylib engine artifact.
+- [#2494](https://github.com/wasmerio/wasmer/pull/2494) Fixed `WasmerEnv` access when using `call_indirect` with the Singlepass compiler.
+- [#2479](https://github.com/wasmerio/wasmer/pull/2479) Improved `wasmer validate` error message on non-wasm inputs.
+- [#2454](https://github.com/wasmerio/wasmer/issues/2454) Won't set `WASMER_CACHE_DIR` for Windows.
+- [#2426](https://github.com/wasmerio/wasmer/pull/2426) Fix the `wax` script generation.
+- [#2635](https://github.com/wasmerio/wasmer/pull/2635) Fix cross-compilation for singlepass.
+- [#2672](https://github.com/wasmerio/wasmer/pull/2672) Use `ENOENT` instead of `EINVAL` in some WASI syscalls for a non-existent file
+- [#2547](https://github.com/wasmerio/wasmer/pull/2547) Delete temporary files created by the dylib engine.
+- [#2548](https://github.com/wasmerio/wasmer/pull/2548) Fix stack probing on x86_64 linux with the cranelift compiler.
+- [#2557](https://github.com/wasmerio/wasmer/pull/2557) [#2559](https://github.com/wasmerio/wasmer/pull/2559) Fix WASI dir path renaming.
+- [#2560](https://github.com/wasmerio/wasmer/pull/2560) Fix signal handling on M1 MacOS.
+- [#2474](https://github.com/wasmerio/wasmer/pull/2474) Fix permissions on `WASMER_CACHE_DIR` on Windows.
+- [#2528](https://github.com/wasmerio/wasmer/pull/2528) [#2525](https://github.com/wasmerio/wasmer/pull/2525) [#2523](https://github.com/wasmerio/wasmer/pull/2523) [#2522](https://github.com/wasmerio/wasmer/pull/2522) [#2545](https://github.com/wasmerio/wasmer/pull/2545) [#2550](https://github.com/wasmerio/wasmer/pull/2550) [#2551](https://github.com/wasmerio/wasmer/pull/2551)  Fix various bugs in the new VFS implementation.
+- [#2552](https://github.com/wasmerio/wasmer/pull/2552) Fix stack guard handling on Windows.
+- [#2585](https://github.com/wasmerio/wasmer/pull/2585) Fix build with 64-bit MinGW toolchain.
+- [#2587](https://github.com/wasmerio/wasmer/pull/2587) Fix absolute import of `Result` in derive.
+- [#2599](https://github.com/wasmerio/wasmer/pull/2599) Fix AArch64 support in the LLVM compiler.
+- [#2655](https://github.com/wasmerio/wasmer/pull/2655) Fix argument parsing of `--dir` and `--mapdir`.
+- [#2666](https://github.com/wasmerio/wasmer/pull/2666) Fix performance on Windows by using static memories by default.
+- [#2667](https://github.com/wasmerio/wasmer/pull/2667) Fix error code for path_rename of a non-existant file
+- [#2672](https://github.com/wasmerio/wasmer/pull/2672) Fix error code returned by some wasi fs syscalls for a non-existent file
+- [#2673](https://github.com/wasmerio/wasmer/pull/2673) Fix BrTable codegen on the LLVM compiler
+- [#2674](https://github.com/wasmerio/wasmer/pull/2674) Add missing `__WASI_RIGHT_FD_DATASYNC` for preopened directories
+- [#2677](https://github.com/wasmerio/wasmer/pull/2677) Support 32-bit memories with 65536 pages
+- [#2681](https://github.com/wasmerio/wasmer/pull/2681) Fix slow compilation in singlepass by using dynasm's `VecAssembler`.
+- [#2690](https://github.com/wasmerio/wasmer/pull/2690) Fix memory leak when obtaining the stack bounds of a thread
+- [#2699](https://github.com/wasmerio/wasmer/pull/2699) Partially fix unbounded memory leak from the FuncDataRegistry
+
+## 2.0.0 - 2021/06/16
+
+### Added
+- [#2411](https://github.com/wasmerio/wasmer/pull/2411) Extract types from `wasi` to a new `wasi-types` crate.
+- [#2390](https://github.com/wasmerio/wasmer/pull/2390) Make `wasmer-vm` to compile on Windows 32bits.
+- [#2402](https://github.com/wasmerio/wasmer/pull/2402) Add more examples and more doctests for `wasmer-middlewares`.
+
+### Changed
+- [#2399](https://github.com/wasmerio/wasmer/pull/2399) Add the Dart integration in the `README.md`.
+
+### Fixed
+- [#2386](https://github.com/wasmerio/wasmer/pull/2386) Handle properly when a module has no exported functions in the CLI.
+
+## 2.0.0-rc2 - 2021/06/03
+
+### Fixed
+- [#2383](https://github.com/wasmerio/wasmer/pull/2383) Fix bugs in the Wasmer CLI tool with the way `--version` and the name of the CLI tool itself were printed.
+
+## 2.0.0-rc1 - 2021/06/02
+
+### Added
+- [#2348](https://github.com/wasmerio/wasmer/pull/2348) Make Wasmer available on `aarch64-linux-android`.
+- [#2315](https://github.com/wasmerio/wasmer/pull/2315) Make the Cranelift compiler working with the Native engine.
+- [#2306](https://github.com/wasmerio/wasmer/pull/2306) Add support for the latest version of the Wasm SIMD proposal to compiler LLVM.
+- [#2296](https://github.com/wasmerio/wasmer/pull/2296) Add support for the bulk memory proposal in compiler Singlepass and compiler LLVM.
+- [#2291](https://github.com/wasmerio/wasmer/pull/2291) Type check tables when importing.
+- [#2262](https://github.com/wasmerio/wasmer/pull/2262) Make parallelism optional for the Singlepass compiler.
+- [#2249](https://github.com/wasmerio/wasmer/pull/2249) Make Cranelift unwind feature optional.
+- [#2208](https://github.com/wasmerio/wasmer/pull/2208) Add a new CHANGELOG.md specific to our C API to make it easier for users primarily consuming our C API to keep up to date with changes that affect them.
+- [#2154](https://github.com/wasmerio/wasmer/pull/2154) Implement Reference Types in the LLVM compiler.
+- [#2003](https://github.com/wasmerio/wasmer/pull/2003) Wasmer works with musl, and is built, tested and packaged for musl.
+- [#2250](https://github.com/wasmerio/wasmer/pull/2250) Use `rkyv` for the JIT/Universal engine.
+- [#2190](https://github.com/wasmerio/wasmer/pull/2190) Use `rkyv` to read native `Module` artifact.
+- [#2186](https://github.com/wasmerio/wasmer/pull/2186) Update and improve the Fuzz Testing infrastructure.
+- [#2161](https://github.com/wasmerio/wasmer/pull/2161) Make NaN canonicalization configurable.
+- [#2116](https://github.com/wasmerio/wasmer/pull/2116) Add a package for Windows that is not an installer, but all the `lib` and `include` files as for macOS and Linux.
+- [#2123](https://github.com/wasmerio/wasmer/pull/2123) Use `ENABLE_{{compiler_name}}=(0|1)` to resp. force to disable or enable a compiler when running the `Makefile`, e.g. `ENABLE_LLVM=1 make build-wasmer`.
+- [#2123](https://github.com/wasmerio/wasmer/pull/2123) `libwasmer` comes with all available compilers per target instead of Cranelift only.
+- [#2135](https://github.com/wasmerio/wasmer/pull/2135) [Documentation](./PACKAGING.md) for Linux distribution maintainers
+- [#2104](https://github.com/wasmerio/wasmer/pull/2104) Update WAsm core spectests and wasmparser.
+
+### Changed
+- [#2369](https://github.com/wasmerio/wasmer/pull/2369) Remove the deprecated `--backend` option in the CLI.
+- [#2368](https://github.com/wasmerio/wasmer/pull/2368) Remove the deprecated code in the `wasmer-wasi` crate.
+- [#2367](https://github.com/wasmerio/wasmer/pull/2367) Remove the `deprecated` features and associated code in the `wasmer` crate.
+- [#2366](https://github.com/wasmerio/wasmer/pull/2366) Remove the deprecated crates.
+- [#2364](https://github.com/wasmerio/wasmer/pull/2364) Rename `wasmer-engine-object-file` to `wasmer-engine-staticlib`.
+- [#2356](https://github.com/wasmerio/wasmer/pull/2356) Rename `wasmer-engine-native` to `wasmer-engine-dylib`.
+- [#2340](https://github.com/wasmerio/wasmer/pull/2340) Rename `wasmer-engine-jit` to `wasmer-engine-universal`.
+- [#2307](https://github.com/wasmerio/wasmer/pull/2307) Update Cranelift, implement low hanging fruit SIMD opcodes.
+- [#2305](https://github.com/wasmerio/wasmer/pull/2305) Clean up and improve the trap API, more deterministic errors etc.
+- [#2299](https://github.com/wasmerio/wasmer/pull/2299) Unused trap codes (due to Wasm spec changes), `HeapSetterOutOfBounds` and `TableSetterOutOfBounds` were removed from `wasmer_vm::TrapCode` and the numbering of the remaining variants has been adjusted.
+- [#2293](https://github.com/wasmerio/wasmer/pull/2293) The `Memory::ty` trait method now returns `MemoryType` by value. `wasmer_vm::LinearMemory` now recomputes `MemoryType`'s `minimum` field when accessing its type. This behavior is what's expected by the latest spectests. `wasmer::Memory::ty` has also been updated to follow suit, it now returns `MemoryType` by value.
+- [#2286](https://github.com/wasmerio/wasmer/pull/2286) Replace the `goblin` crate by the `object` crate.
+- [#2281](https://github.com/wasmerio/wasmer/pull/2281) Refactor the `wasmer_vm` crate to remove unnecessary structs, reuse data when available etc.
+- [#2251](https://github.com/wasmerio/wasmer/pull/2251) Wasmer CLI will now execute WASI modules with multiple WASI namespaces in them by default. Use `--allow-multiple-wasi-versions` to suppress the warning and use `--deny-multiple-wasi-versions` to make it an error.
+- [#2201](https://github.com/wasmerio/wasmer/pull/2201) Implement `loupe::MemoryUsage` for `wasmer::Instance`.
+- [#2200](https://github.com/wasmerio/wasmer/pull/2200) Implement `loupe::MemoryUsage` for `wasmer::Module`.
+- [#2199](https://github.com/wasmerio/wasmer/pull/2199) Implement `loupe::MemoryUsage` for `wasmer::Store`.
+- [#2195](https://github.com/wasmerio/wasmer/pull/2195) Remove dependency to `cranelift-entity`.
+- [#2140](https://github.com/wasmerio/wasmer/pull/2140) Reduce the number of dependencies in the `wasmer.dll` shared library by statically compiling CRT.
+- [#2113](https://github.com/wasmerio/wasmer/pull/2113) Bump minimum supported Rust version to 1.49
+- [#2144](https://github.com/wasmerio/wasmer/pull/2144) Bump cranelift version to 0.70
+- [#2149](https://github.com/wasmerio/wasmer/pull/2144) `wasmer-engine-native` looks for clang-11 instead of clang-10.
+- [#2157](https://github.com/wasmerio/wasmer/pull/2157) Simplify the code behind `WasmPtr`
+
+### Fixed
+- [#2397](https://github.com/wasmerio/wasmer/pull/2397) Fix WASI rename temporary file issue.
+- [#2391](https://github.com/wasmerio/wasmer/pull/2391) Fix Singlepass emit bug, [#2347](https://github.com/wasmerio/wasmer/issues/2347) and [#2159](https://github.com/wasmerio/wasmer/issues/2159)
+- [#2327](https://github.com/wasmerio/wasmer/pull/2327) Fix memory leak preventing internal instance memory from being freed when a WasmerEnv contained an exported extern (e.g. Memory, etc.).
+- [#2247](https://github.com/wasmerio/wasmer/pull/2247) Internal WasiFS logic updated to be closer to what WASI libc does when finding a preopened fd for a path.
+- [#2241](https://github.com/wasmerio/wasmer/pull/2241) Fix Undefined Behavior in setting memory in emscripten `EmEnv`.
+- [#2224](https://github.com/wasmerio/wasmer/pull/2224) Enable SIMD based on actual Wasm features in the Cranelift compiler.
+- [#2217](https://github.com/wasmerio/wasmer/pull/2217) Fix bug in `i64.rotr X 0` in the LLVM compiler.
+- [#2290](https://github.com/wasmerio/wasmer/pull/2290) Handle Wasm modules with no imports in the CLI.
+- [#2108](https://github.com/wasmerio/wasmer/pull/2108) The Object Native Engine generates code that now compiles correctly with C++.
+- [#2125](https://github.com/wasmerio/wasmer/pull/2125) Fix RUSTSEC-2021-0023.
+- [#2155](https://github.com/wasmerio/wasmer/pull/2155) Fix the implementation of shift and rotate in the LLVM compiler.
+- [#2101](https://github.com/wasmerio/wasmer/pull/2101) cflags emitted by `wasmer config --pkg-config` are now correct.
+
+## 1.0.2 - 2021-02-04
+
+### Added
+- [#2053](https://github.com/wasmerio/wasmer/pull/2053) Implement the non-standard `wasi_get_unordered_imports` function in the C API.
+- [#2072](https://github.com/wasmerio/wasmer/pull/2072) Add `wasm_config_set_target`, along with `wasm_target_t`, `wasm_triple_t` and `wasm_cpu_features_t` in the unstable C API.
+- [#2059](https://github.com/wasmerio/wasmer/pull/2059) Ability to capture `stdout` and `stderr` with WASI in the C API.
+- [#2040](https://github.com/wasmerio/wasmer/pull/2040) Add `InstanceHandle::vmoffsets` to expose the offsets of the `vmctx` region.
+- [#2026](https://github.com/wasmerio/wasmer/pull/2026) Expose trap code of a `RuntimeError`, if it's a `Trap`.
+- [#2054](https://github.com/wasmerio/wasmer/pull/2054) Add `wasm_config_delete` to the Wasm C API.
+- [#2072](https://github.com/wasmerio/wasmer/pull/2072) Added cross-compilation to Wasm C API.
+
+### Changed
+- [#2085](https://github.com/wasmerio/wasmer/pull/2085) Update to latest inkwell and LLVM 11.
+- [#2037](https://github.com/wasmerio/wasmer/pull/2037) Improved parallelism of LLVM with the Native/Object engine
+- [#2012](https://github.com/wasmerio/wasmer/pull/2012) Refactor Singlepass init stack assembly (more performant now)
+- [#2036](https://github.com/wasmerio/wasmer/pull/2036) Optimize memory allocated for Function type definitions
+- [#2083](https://github.com/wasmerio/wasmer/pull/2083) Mark `wasi_env_set_instance` and `wasi_env_set_memory` as deprecated. You may simply remove the calls with no side-effect.
+- [#2056](https://github.com/wasmerio/wasmer/pull/2056) Change back to depend on the `enumset` crate instead of `wasmer_enumset`
+
+### Fixed
+- [#2066](https://github.com/wasmerio/wasmer/pull/2066) Include 'extern "C"' in our C headers when included by C++ code.
+- [#2090](https://github.com/wasmerio/wasmer/pull/2090) `wasi_env_t` needs to be freed with `wasi_env_delete` in the C API.
+- [#2084](https://github.com/wasmerio/wasmer/pull/2084) Avoid calling the function environment finalizer more than once when the environment has been cloned in the C API.
+- [#2069](https://github.com/wasmerio/wasmer/pull/2069) Use the new documentation for `include/README.md` in the Wasmer package.
+- [#2042](https://github.com/wasmerio/wasmer/pull/2042) Parse more exotic environment variables in `wasmer run`.
+- [#2041](https://github.com/wasmerio/wasmer/pull/2041) Documentation diagrams now have a solid white background rather than a transparent background.
+- [#2070](https://github.com/wasmerio/wasmer/pull/2070) Do not drain the entire captured stream at first read with `wasi_env_read_stdout` or `_stderr` in the C API.
+- [#2058](https://github.com/wasmerio/wasmer/pull/2058) Expose WASI versions to C correctly.
+- [#2044](https://github.com/wasmerio/wasmer/pull/2044) Do not build C headers on docs.rs.
+
+## 1.0.1 - 2021-01-12
+
+This release includes a breaking change in the API (changing the trait `enumset::EnumsetType` to `wasmer_enumset::EnumSetType` and changing `enumset::EnumSet` in signatures to `wasmer_enumset::EnumSet` to work around a breaking change introduced by `syn`) but is being released as a minor version because `1.0.0` is also in a broken state due to a breaking change introduced by `syn` which affects `enumset` and thus `wasmer`.
+
+This change is unlikely to affect any users of `wasmer`, but if it does please change uses of the `enumset` crate to the `wasmer_enumset` crate where possible.
+
+### Added
+- [#2010](https://github.com/wasmerio/wasmer/pull/2010) A new, experimental, minified build of `wasmer` called `wasmer-headless` will now be included with releases. `wasmer-headless` is the `wasmer` VM without any compilers attached, so it can only run precompiled Wasm modules.
+- [#2005](https://github.com/wasmerio/wasmer/pull/2005) Added the arguments `alias` and `optional` to `WasmerEnv` derive's `export` attribute.
+
+### Changed
+- [#2006](https://github.com/wasmerio/wasmer/pull/2006) Use `wasmer_enumset`, a fork of the `enumset` crate to work around a breaking change in `syn`
+- [#1985](https://github.com/wasmerio/wasmer/pull/1985) Bump minimum supported Rust version to 1.48
+
+### Fixed
+- [#2007](https://github.com/wasmerio/wasmer/pull/2007) Fix packaging of wapm on Windows
+- [#2005](https://github.com/wasmerio/wasmer/pull/2005) Emscripten is now working again.
+
+## 1.0.0 - 2021-01-05
+
+### Added
+
+- [#1969](https://github.com/wasmerio/wasmer/pull/1969) Added D integration to the README
+
+### Changed
+- [#1979](https://github.com/wasmerio/wasmer/pull/1979) `WasmPtr::get_utf8_string` was renamed to `WasmPtr::get_utf8_str` and made `unsafe`.
+
+### Fixed
+- [#1979](https://github.com/wasmerio/wasmer/pull/1979) `WasmPtr::get_utf8_string` now returns a `String`, fixing a soundness issue in certain circumstances. The old functionality is available under a new `unsafe` function, `WasmPtr::get_utf8_str`.
+
+## 1.0.0-rc1 - 2020-12-23
+
+### Added
+
+* [#1894](https://github.com/wasmerio/wasmer/pull/1894) Added exports `wasmer::{CraneliftOptLevel, LLVMOptLevel}` to allow using `Cranelift::opt_level` and `LLVM::opt_level` directly via the `wasmer` crate
+
+### Changed
+
+* [#1941](https://github.com/wasmerio/wasmer/pull/1941) Turn `get_remaining_points`/`set_remaining_points` of the `Metering` middleware into free functions to allow using them in an ahead-of-time compilation setup
+* [#1955](https://github.com/wasmerio/wasmer/pull/1955) Set `jit` as a default feature of the `wasmer-wasm-c-api` crate
+* [#1944](https://github.com/wasmerio/wasmer/pull/1944) Require `WasmerEnv` to be `Send + Sync` even in dynamic functions.
+* [#1963](https://github.com/wasmerio/wasmer/pull/1963) Removed `to_wasm_error` in favour of `impl From<BinaryReaderError> for WasmError`
+* [#1962](https://github.com/wasmerio/wasmer/pull/1962) Replace `wasmparser::Result<()>` with `Result<(), MiddlewareError>` in middleware, allowing implementors to return errors in `FunctionMiddleware::feed`
+
+### Fixed
+
+- [#1949](https://github.com/wasmerio/wasmer/pull/1949) `wasm_<type>_vec_delete` functions no longer crash when the given vector is uninitialized, in the Wasmer C API
+- [#1949](https://github.com/wasmerio/wasmer/pull/1949) The `wasm_frame_vec_t`, `wasm_functype_vec_t`, `wasm_globaltype_vec_t`, `wasm_memorytype_vec_t`, and `wasm_tabletype_vec_t` are now boxed vectors in the Wasmer C API
+
+## 1.0.0-beta2 - 2020-12-16
+
+### Added
+
+* [#1916](https://github.com/wasmerio/wasmer/pull/1916) Add the `WASMER_VERSION*` constants with the `wasmer_version*` functions in the Wasmer C API
+* [#1867](https://github.com/wasmerio/wasmer/pull/1867) Added `Metering::get_remaining_points` and `Metering::set_remaining_points`
+* [#1881](https://github.com/wasmerio/wasmer/pull/1881) Added `UnsupportedTarget` error to `CompileError`
+* [#1908](https://github.com/wasmerio/wasmer/pull/1908) Implemented `TryFrom<Value<T>>` for `i32`/`u32`/`i64`/`u64`/`f32`/`f64`
+* [#1927](https://github.com/wasmerio/wasmer/pull/1927) Added mmap support in `Engine::deserialize_from_file` to speed up artifact loading
+* [#1911](https://github.com/wasmerio/wasmer/pull/1911) Generalized signature type in `Function::new` and `Function::new_with_env` to accept owned and reference `FunctionType` as well as array pairs. This allows users to define signatures as constants. Implemented `From<([Type; $N], [Type; $M])>` for `FunctionType` to support this.
+
+### Changed
+
+- [#1865](https://github.com/wasmerio/wasmer/pull/1865) Require that implementors of `WasmerEnv` also implement `Send`, `Sync`, and `Clone`.
+- [#1851](https://github.com/wasmerio/wasmer/pull/1851) Improve test suite and documentation of the Wasmer C API
+- [#1874](https://github.com/wasmerio/wasmer/pull/1874) Set `CompilerConfig` to be owned (following wasm-c-api)
+- [#1880](https://github.com/wasmerio/wasmer/pull/1880) Remove cmake dependency for tests
+- [#1924](https://github.com/wasmerio/wasmer/pull/1924) Rename reference implementation `wasmer::Tunables` to `wasmer::BaseTunables`. Export trait `wasmer_engine::Tunables` as `wasmer::Tunables`.
+
+### Fixed
+
+- [#1865](https://github.com/wasmerio/wasmer/pull/1865) Fix memory leaks with host function environments.
+- [#1870](https://github.com/wasmerio/wasmer/pull/1870) Fixed Trap instruction address maps in Singlepass
+* [#1914](https://github.com/wasmerio/wasmer/pull/1914) Implemented `TryFrom<Bytes> for Pages` instead of `From<Bytes> for Pages` to properly handle overflow errors
+
+## 1.0.0-beta1 - 2020-12-01
+
+### Added
+
+- [#1839](https://github.com/wasmerio/wasmer/pull/1839) Added support for Metering Middleware
+- [#1837](https://github.com/wasmerio/wasmer/pull/1837) It is now possible to use exports of an `Instance` even after the `Instance` has been freed
+- [#1831](https://github.com/wasmerio/wasmer/pull/1831) Added support for Apple Silicon chips (`arm64-apple-darwin`)
+- [#1739](https://github.com/wasmerio/wasmer/pull/1739) Improved function environment setup via `WasmerEnv` proc macro.
+- [#1649](https://github.com/wasmerio/wasmer/pull/1649) Add outline of migration to 1.0.0 docs.
+
+### Changed
+
+- [#1739](https://github.com/wasmerio/wasmer/pull/1739) Environments passed to host function- must now implement the `WasmerEnv` trait. You can implement it on your existing type with `#[derive(WasmerEnv)]`.
+- [#1838](https://github.com/wasmerio/wasmer/pull/1838) Deprecate `WasiEnv::state_mut`: prefer `WasiEnv::state` instead.
+- [#1663](https://github.com/wasmerio/wasmer/pull/1663) Function environments passed to host functions now must be passed by `&` instead of `&mut`. This is a breaking change. This change fixes a race condition when a host function is called from multiple threads. If you need mutability in your environment, consider using `std::sync::Mutex` or other synchronization primitives.
+- [#1830](https://github.com/wasmerio/wasmer/pull/1830) Minimum supported Rust version bumped to 1.47.0
+- [#1810](https://github.com/wasmerio/wasmer/pull/1810) Make the `state` field of `WasiEnv` public
+
+### Fixed
+
+- [#1857](https://github.com/wasmerio/wasmer/pull/1857) Fix dynamic function with new Environment API
+- [#1855](https://github.com/wasmerio/wasmer/pull/1855) Fix memory leak when using `wat2wasm` in the C API, the function now takes its output parameter by pointer rather than returning an allocated `wasm_byte_vec_t`.
+- [#1841](https://github.com/wasmerio/wasmer/pull/1841) We will now panic when attempting to use a native function with a captured env as a host function. Previously this would silently do the wrong thing. See [#1840](https://github.com/wasmerio/wasmer/pull/1840) for info about Wasmer's support of closures as host functions.
+- [#1764](https://github.com/wasmerio/wasmer/pull/1764) Fix bug in WASI `path_rename` allowing renamed files to be 1 directory below a preopened directory.
+
+## 1.0.0-alpha5 - 2020-11-06
+
+### Added
+
+- [#1761](https://github.com/wasmerio/wasmer/pull/1761) Implement the `wasm_trap_t**` argument of `wasm_instance_new` in the Wasm C API.
+- [#1687](https://github.com/wasmerio/wasmer/pull/1687) Add basic table example; fix ownership of local memory and local table metadata in the VM.
+- [#1751](https://github.com/wasmerio/wasmer/pull/1751) Implement `wasm_trap_t` inside a function declared with `wasm_func_new_with_env` in the Wasm C API.
+- [#1741](https://github.com/wasmerio/wasmer/pull/1741) Implement `wasm_memory_type` in the Wasm C API.
+- [#1736](https://github.com/wasmerio/wasmer/pull/1736) Implement `wasm_global_type` in the Wasm C API.
+- [#1699](https://github.com/wasmerio/wasmer/pull/1699) Update `wasm.h` to its latest version.
+- [#1685](https://github.com/wasmerio/wasmer/pull/1685) Implement `wasm_exporttype_delete` in the Wasm C API.
+- [#1725](https://github.com/wasmerio/wasmer/pull/1725) Implement `wasm_func_type` in the Wasm C API.
+- [#1715](https://github.com/wasmerio/wasmer/pull/1715) Register errors from `wasm_module_serialize` in the Wasm C API.
+- [#1709](https://github.com/wasmerio/wasmer/pull/1709) Implement `wasm_module_name` and `wasm_module_set_name` in the Wasm(er) C API.
+- [#1700](https://github.com/wasmerio/wasmer/pull/1700) Implement `wasm_externtype_copy` in the Wasm C API.
+- [#1785](https://github.com/wasmerio/wasmer/pull/1785) Add more examples on the Rust API.
+- [#1783](https://github.com/wasmerio/wasmer/pull/1783) Handle initialized but empty results in `wasm_func_call` in the Wasm C API.
+- [#1780](https://github.com/wasmerio/wasmer/pull/1780) Implement new SIMD zero-extend loads in compiler-llvm.
+- [#1754](https://github.com/wasmerio/wasmer/pull/1754) Implement aarch64 ABI for compiler-llvm.
+- [#1693](https://github.com/wasmerio/wasmer/pull/1693) Add `wasmer create-exe` subcommand.
+
+### Changed
+
+- [#1772](https://github.com/wasmerio/wasmer/pull/1772) Remove lifetime parameter from `NativeFunc`.
+- [#1762](https://github.com/wasmerio/wasmer/pull/1762) Allow the `=` sign in a WASI environment variable value.
+- [#1710](https://github.com/wasmerio/wasmer/pull/1710) Memory for function call trampolines is now owned by the Artifact.
+- [#1781](https://github.com/wasmerio/wasmer/pull/1781) Cranelift upgrade to 0.67.
+- [#1777](https://github.com/wasmerio/wasmer/pull/1777) Wasmparser update to 0.65.
+- [#1775](https://github.com/wasmerio/wasmer/pull/1775) Improve LimitingTunables implementation.
+- [#1720](https://github.com/wasmerio/wasmer/pull/1720) Autodetect llvm regardless of architecture.
+
+### Fixed
+
+- [#1718](https://github.com/wasmerio/wasmer/pull/1718) Fix panic in the API in some situations when the memory's min bound was greater than the memory's max bound.
+- [#1731](https://github.com/wasmerio/wasmer/pull/1731) In compiler-llvm always load before store, to trigger any traps before any bytes are written.
+
+## 1.0.0-alpha4 - 2020-10-08
+
+### Added
+- [#1635](https://github.com/wasmerio/wasmer/pull/1635) Implement `wat2wasm` in the Wasm C API.
+- [#1636](https://github.com/wasmerio/wasmer/pull/1636) Implement `wasm_module_validate` in the Wasm C API.
+- [#1657](https://github.com/wasmerio/wasmer/pull/1657) Implement `wasm_trap_t` and `wasm_frame_t` for Wasm C API; add examples in Rust and C of exiting early with a host function.
+
+### Fixed
+- [#1690](https://github.com/wasmerio/wasmer/pull/1690) Fix `wasm_memorytype_limits` where `min` and `max` represents pages, not bytes. Additionally, fixes the max limit sentinel value.
+- [#1671](https://github.com/wasmerio/wasmer/pull/1671) Fix probestack firing inappropriately, and sometimes over/under allocating stack.
+- [#1660](https://github.com/wasmerio/wasmer/pull/1660) Fix issue preventing map-dir aliases starting with `/` from working properly.
+- [#1624](https://github.com/wasmerio/wasmer/pull/1624) Add Value::I32/Value::I64 converters from unsigned ints.
+
+### Changed
+- [#1682](https://github.com/wasmerio/wasmer/pull/1682) Improve error reporting when making a memory with invalid settings.
+- [#1691](https://github.com/wasmerio/wasmer/pull/1691) Bump minimum supported Rust version to 1.46.0
+- [#1645](https://github.com/wasmerio/wasmer/pull/1645) Move the install script to https://github.com/wasmerio/wasmer-install
+
+## 1.0.0-alpha3 - 2020-09-14
+
+### Fixed
+
+- [#1620](https://github.com/wasmerio/wasmer/pull/1620) Fix bug causing the Wapm binary to not be packaged with the release
+- [#1619](https://github.com/wasmerio/wasmer/pull/1619) Improve error message in engine-native when C compiler is missing
+
+## 1.0.0-alpha02.0 - 2020-09-11
+
+### Added
+
+- [#1566](https://github.com/wasmerio/wasmer/pull/1566) Add support for opening special Unix files to the WASI FS
+
+### Fixed
+
+- [#1602](https://github.com/wasmerio/wasmer/pull/1602) Fix panic when calling host functions with negative numbers in certain situations
+- [#1590](https://github.com/wasmerio/wasmer/pull/1590) Fix soundness issue in API of vm::Global
+
+## TODO: 1.0.0-alpha01.0
+
+- Wasmer refactor lands
+
+## 0.17.1 - 2020-06-24
+
+### Changed
+- [#1439](https://github.com/wasmerio/wasmer/pull/1439) Move `wasmer-interface-types` into its own repository
+
+### Fixed
+
+- [#1554](https://github.com/wasmerio/wasmer/pull/1554) Update supported stable Rust version to 1.45.2.
+- [#1552](https://github.com/wasmerio/wasmer/pull/1552) Disable `sigint` handler by default.
+
+## 0.17.0 - 2020-05-11
+
+### Added
+- [#1331](https://github.com/wasmerio/wasmer/pull/1331) Implement the `record` type and instrutions for WIT
+- [#1345](https://github.com/wasmerio/wasmer/pull/1345) Adding ARM testing in Azure Pipelines
+- [#1329](https://github.com/wasmerio/wasmer/pull/1329) New numbers and strings instructions for WIT
+- [#1285](https://github.com/wasmerio/wasmer/pull/1285) Greatly improve errors in `wasmer-interface-types`
+- [#1303](https://github.com/wasmerio/wasmer/pull/1303) NaN canonicalization for singlepass backend.
+- [#1313](https://github.com/wasmerio/wasmer/pull/1313) Add new high-level public API through `wasmer` crate. Includes many updates including:
+  - Minor improvement: `imports!` macro now handles no trailing comma as well as a trailing comma in namespaces and between namespaces.
+  - New methods on `Module`: `exports`, `imports`, and `custom_sections`.
+  - New way to get exports from an instance with `let func_name: Func<i32, i64> = instance.exports.get("func_name");`.
+  - Improved `Table` APIs including `set` which now allows setting functions directly.  TODO: update this more if `Table::get` gets made public in this PR
+  - TODO: finish the list of changes here
+- [#1305](https://github.com/wasmerio/wasmer/pull/1305) Handle panics from DynamicFunc.
+- [#1300](https://github.com/wasmerio/wasmer/pull/1300) Add support for multiple versions of WASI tests: wasitests now test all versions of WASI.
+- [#1292](https://github.com/wasmerio/wasmer/pull/1292) Experimental Support for Android (x86_64 and AArch64)
+
+### Fixed
+- [#1283](https://github.com/wasmerio/wasmer/pull/1283) Workaround for floating point arguments and return values in `DynamicFunc`s.
+
+### Changed
+- [#1401](https://github.com/wasmerio/wasmer/pull/1401) Make breaking change to `RuntimeError`: `RuntimeError` is now more explicit about its possible error values allowing for better insight into why a call into Wasm failed.
+- [#1382](https://github.com/wasmerio/wasmer/pull/1382) Refactored test infranstructure (part 2)
+- [#1380](https://github.com/wasmerio/wasmer/pull/1380) Refactored test infranstructure (part 1)
+- [#1357](https://github.com/wasmerio/wasmer/pull/1357) Refactored bin commands into separate files
+- [#1335](https://github.com/wasmerio/wasmer/pull/1335) Change mutability of `memory` to `const` in `wasmer_memory_data_length` in the C API
+- [#1332](https://github.com/wasmerio/wasmer/pull/1332) Add option to `CompilerConfig` to force compiler IR verification off even when `debug_assertions` are enabled. This can be used to make debug builds faster, which may be important if you're creating a library that wraps Wasmer and depend on the speed of debug builds.
+- [#1320](https://github.com/wasmerio/wasmer/pull/1320) Change `custom_sections` field in `ModuleInfo` to be more standards compliant by allowing multiple custom sections with the same name. To get the old behavior with the new API, you can add `.last().unwrap()` to accesses. For example, `module_info.custom_sections["custom_section_name"].last().unwrap()`.
+- [#1301](https://github.com/wasmerio/wasmer/pull/1301) Update supported stable Rust version to 1.41.1.
+
+## 0.16.2 - 2020-03-11
+
+### Fixed
+
+- [#1294](https://github.com/wasmerio/wasmer/pull/1294) Fix bug related to system calls in WASI that rely on reading from WasmPtrs as arrays of length 0. `WasmPtr` will now succeed on length 0 arrays again.
+
+## 0.16.1 - 2020-03-11
+
+### Fixed
+
+- [#1291](https://github.com/wasmerio/wasmer/pull/1291) Fix installation packaging script to package the `wax` command.
+
+## 0.16.0 - 2020-03-11
+
+### Added
+- [#1286](https://github.com/wasmerio/wasmer/pull/1286) Updated Windows Wasmer icons. Add wax
+- [#1284](https://github.com/wasmerio/wasmer/pull/1284) Implement string and memory instructions in `wasmer-interface-types`
+
+### Fixed
+- [#1272](https://github.com/wasmerio/wasmer/pull/1272) Fix off-by-one error bug when accessing memory with a `WasmPtr` that contains the last valid byte of memory. Also changes the behavior of `WasmPtr<T, Array>` with a length of 0 and `WasmPtr<T>` where `std::mem::size_of::<T>()` is 0 to always return `None`
+
+## 0.15.0 - 2020-03-04
+
+- [#1263](https://github.com/wasmerio/wasmer/pull/1263) Changed the behavior of some WASI syscalls to now handle preopened directories more properly. Changed default `--debug` logging to only show Wasmer-related messages.
+- [#1217](https://github.com/wasmerio/wasmer/pull/1217) Polymorphic host functions based on dynamic trampoline generation.
+- [#1252](https://github.com/wasmerio/wasmer/pull/1252) Allow `/` in wasi `--mapdir` wasm path.
+- [#1212](https://github.com/wasmerio/wasmer/pull/1212) Add support for GDB JIT debugging:
+  - Add `--generate-debug-info` and `-g` flags to `wasmer run` to generate debug information during compilation. The debug info is passed via the GDB JIT interface to a debugger to allow source-level debugging of Wasm files. Currently only available on clif-backend.
+  - Break public middleware APIs: there is now a `source_loc` parameter that should be passed through if applicable.
+  - Break compiler trait methods such as `feed_local`, `feed_event` as well as `ModuleCodeGenerator::finalize`.
+
+## 0.14.1 - 2020-02-24
+
+- [#1245](https://github.com/wasmerio/wasmer/pull/1245) Use Ubuntu 16.04 in CI so that we use an earlier version of GLIBC.
+- [#1234](https://github.com/wasmerio/wasmer/pull/1234) Check for unused excluded spectest failures.
+- [#1232](https://github.com/wasmerio/wasmer/pull/1232) `wasmer-interface-types` has a WAT decoder.
+
+## 0.14.0 - 2020-02-20
+
+- [#1233](https://github.com/wasmerio/wasmer/pull/1233) Improved Wasmer C API release artifacts.
+- [#1216](https://github.com/wasmerio/wasmer/pull/1216) `wasmer-interface-types` receives a binary encoder.
+- [#1228](https://github.com/wasmerio/wasmer/pull/1228) Singlepass cleanup: Resolve several FIXMEs and remove protect_unix.
+- [#1218](https://github.com/wasmerio/wasmer/pull/1218) Enable Cranelift verifier in debug mode. Fix bug with table indices being the wrong type.
+- [#787](https://github.com/wasmerio/wasmer/pull/787) New crate `wasmer-interface-types` to implement WebAssembly Interface Types.
+- [#1213](https://github.com/wasmerio/wasmer/pull/1213) Fixed WASI `fdstat` to detect `isatty` properly.
+- [#1192](https://github.com/wasmerio/wasmer/pull/1192) Use `ExceptionCode` for error representation.
+- [#1191](https://github.com/wasmerio/wasmer/pull/1191) Fix singlepass miscompilation on `Operator::CallIndirect`.
+- [#1180](https://github.com/wasmerio/wasmer/pull/1180) Fix compilation for target `x86_64-unknown-linux-musl`.
+- [#1170](https://github.com/wasmerio/wasmer/pull/1170) Improve the WasiFs builder API with convenience methods for overriding stdin, stdout, and stderr as well as a new sub-builder for controlling the permissions and properties of preopened directories.  Also breaks that implementations of `WasiFile` must be `Send` -- please file an issue if this change causes you any issues.
+- [#1161](https://github.com/wasmerio/wasmer/pull/1161) Require imported functions to be `Send`. This is a breaking change that fixes a soundness issue in the API.
+- [#1140](https://github.com/wasmerio/wasmer/pull/1140) Use [`blake3`](https://github.com/BLAKE3-team/BLAKE3) as default hashing algorithm for caching.
+- [#1129](https://github.com/wasmerio/wasmer/pull/1129) Standard exception types for singlepass backend.
+
+## 0.13.1 - 2020-01-16
+- Fix bug in wapm related to the `package.wasmer_extra_flags` entry in the manifest
+
+## 0.13.0 - 2020-01-15
+
+Special thanks to [@repi](https://github.com/repi) and [@srenatus](https://github.com/srenatus) for their contributions!
+
+- [#1153](https://github.com/wasmerio/wasmer/pull/1153) Added Wasmex, an Elixir language integration, to the README
+- [#1133](https://github.com/wasmerio/wasmer/pull/1133) New `wasmer_trap` function in the C API, to properly error from within a host function
+- [#1147](https://github.com/wasmerio/wasmer/pull/1147) Remove `log` and `trace` macros from `wasmer-runtime-core`, remove `debug` and `trace` features from `wasmer-*` crates, use the `log` crate for logging and use `fern` in the Wasmer CLI binary to output log messages.  Colorized output will be enabled automatically if printing to a terminal, to force colorization on or off, set the `WASMER_COLOR` environment variable to `true` or `false`.
+- [#1128](https://github.com/wasmerio/wasmer/pull/1128) Fix a crash when a host function is missing and the `allow_missing_functions` flag is enabled
+- [#1099](https://github.com/wasmerio/wasmer/pull/1099) Remove `backend::Backend` from `wasmer_runtime_core`
+- [#1097](https://github.com/wasmerio/wasmer/pull/1097) Move inline breakpoint outside of runtime backend
+- [#1095](https://github.com/wasmerio/wasmer/pull/1095) Update to cranelift 0.52.
+- [#1092](https://github.com/wasmerio/wasmer/pull/1092) Add `get_utf8_string_with_nul` to `WasmPtr` to read nul-terminated strings from memory.
+- [#1071](https://github.com/wasmerio/wasmer/pull/1071) Add support for non-trapping float-to-int conversions, enabled by default.
+
+## 0.12.0 - 2019-12-18
+
+Special thanks to [@ethanfrey](https://github.com/ethanfrey), [@AdamSLevy](https://github.com/AdamSLevy), [@Jasper-Bekkers](https://github.com/Jasper-Bekkers), [@srenatus](https://github.com/srenatus) for their contributions!
+
+- [#1078](https://github.com/wasmerio/wasmer/pull/1078) Increase the maximum number of parameters `Func` can take
+- [#1062](https://github.com/wasmerio/wasmer/pull/1062) Expose some opt-in Emscripten functions to the C API
+- [#1032](https://github.com/wasmerio/wasmer/pull/1032) Change the signature of the Emscripten `abort` function to work with Emscripten 1.38.30
+- [#1060](https://github.com/wasmerio/wasmer/pull/1060) Test the capi with all the backends
+- [#1069](https://github.com/wasmerio/wasmer/pull/1069) Add function `get_memory_and_data` to `Ctx` to help prevent undefined behavior and mutable aliasing. It allows accessing memory while borrowing data mutably for the `Ctx` lifetime. This new function is now being used in `wasmer-wasi`.
+- [#1058](https://github.com/wasmerio/wasmer/pull/1058) Fix minor panic issue when `wasmer::compile_with` called with llvm backend.
+- [#858](https://github.com/wasmerio/wasmer/pull/858) Minor panic fix when wasmer binary with `loader` option run a module without exported `_start` function.
+- [#1056](https://github.com/wasmerio/wasmer/pull/1056) Improved `--invoke` args parsing (supporting `i32`, `i64`, `f32` and `f32`) in Wasmer CLI
+- [#1054](https://github.com/wasmerio/wasmer/pull/1054) Improve `--invoke` output in Wasmer CLI
+- [#1053](https://github.com/wasmerio/wasmer/pull/1053) For RuntimeError and breakpoints, use Box<Any + Send> instead of Box<Any>.
+- [#1052](https://github.com/wasmerio/wasmer/pull/1052) Fix minor panic and improve Error handling in singlepass backend.
+- [#1050](https://github.com/wasmerio/wasmer/pull/1050) Attach C & C++ headers to releases.
+- [#1033](https://github.com/wasmerio/wasmer/pull/1033) Set cranelift backend as default compiler backend again, require at least one backend to be enabled for Wasmer CLI
+- [#1044](https://github.com/wasmerio/wasmer/pull/1044) Enable AArch64 support in the LLVM backend.
+- [#1030](https://github.com/wasmerio/wasmer/pull/1030) Ability to generate `ImportObject` for a specific version WASI version with the C API.
+- [#1028](https://github.com/wasmerio/wasmer/pull/1028) Introduce strict/non-strict modes for `get_wasi_version`
+- [#1029](https://github.com/wasmerio/wasmer/pull/1029) Add the “floating” `WasiVersion::Latest` version.
+- [#1006](https://github.com/wasmerio/wasmer/pull/1006) Fix minor panic issue when `wasmer::compile_with` called with llvm backend
+- [#1009](https://github.com/wasmerio/wasmer/pull/1009) Enable LLVM verifier for all tests, add new llvm-backend-tests crate.
+- [#1022](https://github.com/wasmerio/wasmer/pull/1022) Add caching support for Singlepass backend.
+- [#1004](https://github.com/wasmerio/wasmer/pull/1004) Add the Auto backend to enable to adapt backend usage depending on wasm file executed.
+- [#1068](https://github.com/wasmerio/wasmer/pull/1068) Various cleanups for the singlepass backend on AArch64.
+
+## 0.11.0 - 2019-11-22
+
+- [#713](https://github.com/wasmerio/wasmer/pull/713) Add AArch64 support for singlepass.
+- [#995](https://github.com/wasmerio/wasmer/pull/995) Detect when a global is read without being initialized (emit a proper error instead of panicking)
+- [#996](https://github.com/wasmerio/wasmer/pull/997) Refactored spectests, emtests and wasitests to use default compiler logic
+- [#992](https://github.com/wasmerio/wasmer/pull/992) Updates WAPM version to 0.4.1, fix arguments issue introduced in #990
+- [#990](https://github.com/wasmerio/wasmer/pull/990) Default wasmer CLI to `run`.  Wasmer will now attempt to parse unrecognized command line options as if they were applied to the run command: `wasmer mywasm.wasm --dir=.` now works!
+- [#987](https://github.com/wasmerio/wasmer/pull/987) Fix `runtime-c-api` header files when compiled by gnuc.
+- [#957](https://github.com/wasmerio/wasmer/pull/957) Change the meaning of `wasmer_wasix::is_wasi_module` to detect any type of WASI module, add support for new wasi snapshot_preview1
+- [#934](https://github.com/wasmerio/wasmer/pull/934) Simplify float expressions in the LLVM backend.
+
+## 0.10.2 - 2019-11-18
+
+- [#968](https://github.com/wasmerio/wasmer/pull/968) Added `--invoke` option to the command
+- [#964](https://github.com/wasmerio/wasmer/pull/964) Enable cross-compilation for specific target
+- [#971](https://github.com/wasmerio/wasmer/pull/971) In LLVM backend, use unaligned loads and stores for non-atomic accesses to wasmer memory.
+- [#960](https://github.com/wasmerio/wasmer/pull/960) Fix `runtime-c-api` header files when compiled by clang.
+- [#925](https://github.com/wasmerio/wasmer/pull/925) Host functions can be closures with a captured environment.
+- [#917](https://github.com/wasmerio/wasmer/pull/917) Host functions (aka imported functions) may not have `&mut vm::Ctx` as first argument, i.e. the presence of the `&mut vm::Ctx` argument is optional.
+- [#915](https://github.com/wasmerio/wasmer/pull/915) All backends share the same definition of `Trampoline` (defined in `wasmer-runtime-core`).
+
+## 0.10.1 - 2019-11-11
+
+- [#952](https://github.com/wasmerio/wasmer/pull/952) Use C preprocessor to properly hide trampoline functions on Windows and non-x86_64 targets.
+
+## 0.10.0 - 2019-11-11
+
+Special thanks to [@newpavlov](https://github.com/newpavlov) and [@Maxgy](https://github.com/Maxgy) for their contributions!
+
+- [#942](https://github.com/wasmerio/wasmer/pull/942) Deny missing docs in runtime core and add missing docs
+- [#939](https://github.com/wasmerio/wasmer/pull/939) Fix bug causing attempts to append to files with WASI to delete the contents of the file
+- [#940](https://github.com/wasmerio/wasmer/pull/940) Update supported Rust version to 1.38+
+- [#923](https://github.com/wasmerio/wasmer/pull/923) Fix memory leak in the C API caused by an incorrect cast in `wasmer_trampoline_buffer_destroy`
+- [#921](https://github.com/wasmerio/wasmer/pull/921) In LLVM backend, annotate all memory accesses with TBAA metadata.
+- [#883](https://github.com/wasmerio/wasmer/pull/883) Allow floating point operations to have arbitrary inputs, even including SNaNs.
+- [#856](https://github.com/wasmerio/wasmer/pull/856) Expose methods in the runtime C API to get a WASI import object
+
+## 0.9.0 - 2019-10-23
+
+Special thanks to @alocquet for their contributions!
+
+- [#898](https://github.com/wasmerio/wasmer/pull/898) State tracking is now disabled by default in the LLVM backend. It can be enabled with `--track-state`.
+- [#861](https://github.com/wasmerio/wasmer/pull/861) Add descriptions to `unimplemented!` macro in various places
+- [#897](https://github.com/wasmerio/wasmer/pull/897) Removes special casing of stdin, stdout, and stderr in WASI.  Closing these files now works.  Removes `stdin`, `stdout`, and `stderr` from `WasiFS`, replaced by the methods `stdout`, `stdout_mut`, and so on.
+- [#863](https://github.com/wasmerio/wasmer/pull/863) Fix min and max for cases involving NaN and negative zero when using the LLVM backend.
+
+## 0.8.0 - 2019-10-02
+
+Special thanks to @jdanford for their contributions!
+
+- [#850](https://github.com/wasmerio/wasmer/pull/850) New `WasiStateBuilder` API. small, add misc. breaking changes to existing API (for example, changing the preopen dirs arg on `wasi::generate_import_object` from `Vec<String>` to `Vec<Pathbuf>`)
+- [#852](https://github.com/wasmerio/wasmer/pull/852) Make minor grammar/capitalization fixes to README.md
+- [#841](https://github.com/wasmerio/wasmer/pull/841) Slightly improve rustdoc documentation and small updates to outdated info in readme files
+- [#836](https://github.com/wasmerio/wasmer/pull/836) Update Cranelift fork version to `0.44.0`
+- [#839](https://github.com/wasmerio/wasmer/pull/839) Change supported version to stable Rust 1.37+
+- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when unwraping `wasmer` arguments
+- [#835](https://github.com/wasmerio/wasmer/pull/835) Add parallel execution example (independent instances created from the same `ImportObject` and `Module` run with rayon)
+- [#834](https://github.com/wasmerio/wasmer/pull/834) Fix panic when parsing numerical arguments for no-ABI targets run with the wasmer binary
+- [#833](https://github.com/wasmerio/wasmer/pull/833) Add doc example of using ImportObject's new `maybe_with_namespace` method
+- [#832](https://github.com/wasmerio/wasmer/pull/832) Delete unused runtime ABI
+- [#809](https://github.com/wasmerio/wasmer/pull/809) Fix bugs leading to panics in `LocalBacking`.
+- [#831](https://github.com/wasmerio/wasmer/pull/831) Add support for atomic operations, excluding wait and notify, to singlepass.
+- [#822](https://github.com/wasmerio/wasmer/pull/822) Update Cranelift fork version to `0.43.1`
+- [#829](https://github.com/wasmerio/wasmer/pull/829) Fix deps on `make bench-*` commands; benchmarks don't compile other backends now
+- [#807](https://github.com/wasmerio/wasmer/pull/807) Implement Send for `Instance`, breaking change on `ImportObject`, remove method `get_namespace` replaced with `with_namespace` and `maybe_with_namespace`
+- [#817](https://github.com/wasmerio/wasmer/pull/817) Add document for tracking features across backends and language integrations, [docs/feature_matrix.md]
+- [#823](https://github.com/wasmerio/wasmer/issues/823) Improved Emscripten / WASI integration
+- [#821](https://github.com/wasmerio/wasmer/issues/821) Remove patch version on most deps Cargo manifests.  This gives Wasmer library users more control over which versions of the deps they use.
+- [#820](https://github.com/wasmerio/wasmer/issues/820) Remove null-pointer checks in `WasmPtr` from runtime-core, re-add them in Emscripten
+- [#803](https://github.com/wasmerio/wasmer/issues/803) Add method to `Ctx` to invoke functions by their `TableIndex`
+- [#790](https://github.com/wasmerio/wasmer/pull/790) Fix flaky test failure with LLVM, switch to large code model.
+- [#788](https://github.com/wasmerio/wasmer/pull/788) Use union merge on the changelog file.
+- [#785](https://github.com/wasmerio/wasmer/pull/785) Include Apache license file for spectests.
+- [#786](https://github.com/wasmerio/wasmer/pull/786) In the LLVM backend, lower atomic wasm operations to atomic machine instructions.
+- [#784](https://github.com/wasmerio/wasmer/pull/784) Fix help string for wasmer run.
+
+## 0.7.0 - 2019-09-12
+
+Special thanks to @YaronWittenstein @penberg for their contributions.
+
+- [#776](https://github.com/wasmerio/wasmer/issues/776) Allow WASI preopened fds to be closed
+- [#774](https://github.com/wasmerio/wasmer/issues/774) Add more methods to the `WasiFile` trait
+- [#772](https://github.com/wasmerio/wasmer/issues/772) [#770](https://github.com/wasmerio/wasmer/issues/770) Handle more internal failures by passing back errors
+- [#756](https://github.com/wasmerio/wasmer/issues/756) Allow NULL parameter and 0 arity in `wasmer_export_func_call` C API
+- [#747](https://github.com/wasmerio/wasmer/issues/747) Return error instead of panicking on traps when using the Wasmer binary
+- [#741](https://github.com/wasmerio/wasmer/issues/741) Add validate Wasm fuzz target
+- [#733](https://github.com/wasmerio/wasmer/issues/733) Remove dependency on compiler backends for `middleware-common`
+- [#732](https://github.com/wasmerio/wasmer/issues/732) [#731](https://github.com/wasmerio/wasmer/issues/731) WASI bug fixes and improvements
+- [#726](https://github.com/wasmerio/wasmer/issues/726) Add serialization and deserialization for Wasi State
+- [#716](https://github.com/wasmerio/wasmer/issues/716) Improve portability of install script
+- [#714](https://github.com/wasmerio/wasmer/issues/714) Add Code of Conduct
+- [#708](https://github.com/wasmerio/wasmer/issues/708) Remove unconditional dependency on Cranelift in the C API
+- [#703](https://github.com/wasmerio/wasmer/issues/703) Fix compilation on AArch64 Linux
+- [#702](https://github.com/wasmerio/wasmer/issues/702) Add SharedMemory to Wasmer. Add `--enable-threads` flag, add partial implementation of atomics to LLVM backend.
+- [#698](https://github.com/wasmerio/wasmer/issues/698) [#690](https://github.com/wasmerio/wasmer/issues/690) [#687](https://github.com/wasmerio/wasmer/issues/690) Fix panics in Emscripten
+- [#689](https://github.com/wasmerio/wasmer/issues/689) Replace `wasmer_runtime_code::memory::Atomic` with `std::sync::atomic` atomics, changing its interface
+- [#680](https://github.com/wasmerio/wasmer/issues/680) [#673](https://github.com/wasmerio/wasmer/issues/673) [#669](https://github.com/wasmerio/wasmer/issues/669) [#660](https://github.com/wasmerio/wasmer/issues/660) [#659](https://github.com/wasmerio/wasmer/issues/659) Misc. runtime and singlepass fixes
+- [#677](https://github.com/wasmerio/wasmer/issues/677) [#675](https://github.com/wasmerio/wasmer/issues/675) [#674](https://github.com/wasmerio/wasmer/issues/674) LLVM backend fixes and improvements
+- [#671](https://github.com/wasmerio/wasmer/issues/671) Implement fs polling in `wasi::poll_oneoff` for Unix-like platforms
+- [#656](https://github.com/wasmerio/wasmer/issues/656) Move CI to Azure Pipelines
+- [#650](https://github.com/wasmerio/wasmer/issues/650) Implement `wasi::path_rename`, improve WASI FS public api, and allow open files to exist even when the underlying file is deleted
+- [#643](https://github.com/wasmerio/wasmer/issues/643) Implement `wasi::path_symlink` and improve WASI FS public api IO error reporting
+- [#608](https://github.com/wasmerio/wasmer/issues/608) Implement wasi syscalls `fd_allocate`, `fd_sync`, `fd_pread`, `path_link`, `path_filestat_set_times`; update WASI fs API in a WIP way; reduce coupling of WASI code to host filesystem; make debug messages from WASI more readable; improve rights-checking when calling syscalls; implement reference counting on inodes; misc bug fixes and improvements
+- [#616](https://github.com/wasmerio/wasmer/issues/616) Create the import object separately from instance instantiation in `runtime-c-api`
+- [#620](https://github.com/wasmerio/wasmer/issues/620) Replace one `throw()` with `noexcept` in llvm backend
+- [#618](https://github.com/wasmerio/wasmer/issues/618) Implement `InternalEvent::Breakpoint` in the llvm backend to allow metering in llvm
+- [#615](https://github.com/wasmerio/wasmer/issues/615) Eliminate `FunctionEnvironment` construction in `feed_event()` speeding up to 70% of compilation in clif
+- [#609](https://github.com/wasmerio/wasmer/issues/609) Update dependencies
+- [#602](https://github.com/wasmerio/wasmer/issues/602) C api extract instance context from instance
+- [#590](https://github.com/wasmerio/wasmer/issues/590) Error visibility changes in wasmer-c-api
+- [#589](https://github.com/wasmerio/wasmer/issues/589) Make `wasmer_byte_array` fields `public` in wasmer-c-api
+
+## 0.6.0 - 2019-07-31
+- [#603](https://github.com/wasmerio/wasmer/pull/603) Update Wapm-cli, bump version numbers
+- [#595](https://github.com/wasmerio/wasmer/pull/595) Add unstable public API for interfacing with the WASI file system in plugin-like usecases
+- [#598](https://github.com/wasmerio/wasmer/pull/598) LLVM Backend is now supported in Windows
+- [#599](https://github.com/wasmerio/wasmer/pull/599) Fix llvm backend failures in fat spec tests and simd_binaryen spec test.
+- [#579](https://github.com/wasmerio/wasmer/pull/579) Fix bug in caching with LLVM and Singlepass backends.
+  Add `default-backend-singlepass`, `default-backend-llvm`, and `default-backend-cranelift` features to `wasmer-runtime`
+  to control the `default_compiler()` function (this is a breaking change).  Add `compiler_for_backend` function in `wasmer-runtime`
+- [#561](https://github.com/wasmerio/wasmer/pull/561) Call the `data_finalizer` field on the `Ctx`
+- [#576](https://github.com/wasmerio/wasmer/pull/576) fix `Drop` of uninit `Ctx`
+- [#542](https://github.com/wasmerio/wasmer/pull/542) Add SIMD support to Wasmer (LLVM backend only)
+  - Updates LLVM to version 8.0
+
+## 0.5.7 - 2019-07-23
+- [#575](https://github.com/wasmerio/wasmer/pull/575) Prepare for release; update wapm to 0.3.6
+- [#555](https://github.com/wasmerio/wasmer/pull/555) WASI filesystem rewrite.  Major improvements
+  - adds virtual root showing all preopened directories
+  - improved sandboxing and code-reuse
+  - symlinks work in a lot more situations
+  - many misc. improvements to most syscalls touching the filesystem
+
+## 0.5.6 - 2019-07-16
+- [#565](https://github.com/wasmerio/wasmer/pull/565) Update wapm and bump version to 0.5.6
+- [#563](https://github.com/wasmerio/wasmer/pull/563) Improve wasi testing infrastructure
+  - fixes arg parsing from comments & fixes the mapdir test to have the native code doing the same thing as the WASI code
+  - makes wasitests-generate output stdout/stderr by default & adds function to print stdout and stderr for a command if it fails
+  - compiles wasm with size optimizations & strips generated wasm with wasm-strip
+- [#554](https://github.com/wasmerio/wasmer/pull/554) Finish implementation of `wasi::fd_seek`, fix bug in filestat
+- [#550](https://github.com/wasmerio/wasmer/pull/550) Fix singlepass compilation error with `imul` instruction
+
+
+## 0.5.5 - 2019-07-10
+- [#541](https://github.com/wasmerio/wasmer/pull/541) Fix dependency graph by making separate test crates; ABI implementations should not depend on compilers. Add Cranelift fork as git submodule of clif-backend
+- [#537](https://github.com/wasmerio/wasmer/pull/537) Add hidden flag (`--cache-key`) to use prehashed key into the compiled wasm cache and change compiler backend-specific caching to use directories
+- [#536](https://github.com/wasmerio/wasmer/pull/536) ~Update cache to use compiler backend name in cache key~
+
+## 0.5.4 - 2019-07-06
+- [#529](https://github.com/wasmerio/wasmer/pull/529) Updates the Wasm Interface library, which is used by wapm, with bug fixes and error message improvements
+
+## 0.5.3 - 2019-07-03
+- [#523](https://github.com/wasmerio/wasmer/pull/523) Update wapm version to fix bug related to signed packages in the global namespace and locally-stored public keys
+
+## 0.5.2 - 2019-07-02
+- [#516](https://github.com/wasmerio/wasmer/pull/516) Add workaround for singlepass miscompilation on GetLocal
+- [#521](https://github.com/wasmerio/wasmer/pull/521) Update Wapm-cli, bump version numbers
+- [#518](https://github.com/wasmerio/wasmer/pull/518) Update Cranelift and WasmParser
+- [#514](https://github.com/wasmerio/wasmer/pull/514) [#519](https://github.com/wasmerio/wasmer/pull/519) Improved Emscripten network related calls, added a null check to `WasmPtr`
+- [#515](https://github.com/wasmerio/wasmer/pull/515) Improved Emscripten dyncalls
+- [#513](https://github.com/wasmerio/wasmer/pull/513) Fix emscripten lseek implementation.
+- [#510](https://github.com/wasmerio/wasmer/pull/510) Simplify construction of floating point constants in LLVM backend. Fix LLVM assertion failure due to definition of %ctx.
+
+## 0.5.1 - 2019-06-24
+- [#508](https://github.com/wasmerio/wasmer/pull/508) Update wapm version, includes bug fixes
+
+## 0.5.0 - 2019-06-17
+
+- [#471](https://github.com/wasmerio/wasmer/pull/471) Added missing functions to run Python. Improved Emscripten bindings
+- [#494](https://github.com/wasmerio/wasmer/pull/494) Remove deprecated type aliases from libc in the runtime C API
+- [#493](https://github.com/wasmerio/wasmer/pull/493) `wasmer_module_instantiate` has better error messages in the runtime C API
+- [#474](https://github.com/wasmerio/wasmer/pull/474) Set the install name of the dylib to `@rpath`
+- [#490](https://github.com/wasmerio/wasmer/pull/490) Add MiddlewareChain and StreamingCompiler to runtime
+- [#487](https://github.com/wasmerio/wasmer/pull/487) Fix stack offset check in singlepass backend
+- [#450](https://github.com/wasmerio/wasmer/pull/450) Added Metering
+- [#481](https://github.com/wasmerio/wasmer/pull/481) Added context trampoline into runtime
+- [#484](https://github.com/wasmerio/wasmer/pull/484) Fix bugs in emscripten socket syscalls
+- [#476](https://github.com/wasmerio/wasmer/pull/476) Fix bug with wasi::environ_get, fix off by one error in wasi::environ_sizes_get
+- [#470](https://github.com/wasmerio/wasmer/pull/470) Add mapdir support to Emscripten, implement getdents for Unix
+- [#467](https://github.com/wasmerio/wasmer/pull/467) `wasmer_instantiate` returns better error messages in the runtime C API
+- [#463](https://github.com/wasmerio/wasmer/pull/463) Fix bug in WASI path_open allowing one level above preopened dir to be accessed
+- [#461](https://github.com/wasmerio/wasmer/pull/461) Prevent passing negative lengths in various places in the runtime C API
+- [#459](https://github.com/wasmerio/wasmer/pull/459) Add monotonic and real time clocks for wasi on windows
+- [#447](https://github.com/wasmerio/wasmer/pull/447) Add trace macro (`--features trace`) for more verbose debug statements
+- [#451](https://github.com/wasmerio/wasmer/pull/451) Add `--mapdir=src:dest` flag to rename host directories in the guest context
+- [#457](https://github.com/wasmerio/wasmer/pull/457) Implement file metadata for WASI, fix bugs in WASI clock code for Unix platforms
+
+## 0.4.2 - 2019-05-16
+
+- [#416](https://github.com/wasmerio/wasmer/pull/416) Remote code loading framework
+- [#449](https://github.com/wasmerio/wasmer/pull/449) Fix bugs: opening host files in filestat and opening with write permissions unconditionally in path_open
+- [#442](https://github.com/wasmerio/wasmer/pull/442) Misc. WASI FS fixes and implement readdir
+- [#440](https://github.com/wasmerio/wasmer/pull/440) Fix type mismatch between `wasmer_instance_call` and `wasmer_export_func_*_arity` functions in the runtime C API.
+- [#269](https://github.com/wasmerio/wasmer/pull/269) Add better runtime docs
+- [#432](https://github.com/wasmerio/wasmer/pull/432) Fix returned value of `wasmer_last_error_message` in the runtime C API
+- [#429](https://github.com/wasmerio/wasmer/pull/429) Get wasi::path_filestat_get working for some programs; misc. minor WASI FS improvements
+- [#413](https://github.com/wasmerio/wasmer/pull/413) Update LLVM backend to use new parser codegen traits
+
+## 0.4.1 - 2019-05-06
+
+- [#426](https://github.com/wasmerio/wasmer/pull/426) Update wapm-cli submodule, bump version to 0.4.1
+- [#422](https://github.com/wasmerio/wasmer/pull/422) Improved Emscripten functions to run optipng and pngquant compiled to wasm
+- [#409](https://github.com/wasmerio/wasmer/pull/409) Improved Emscripten functions to run JavascriptCore compiled to wasm
+- [#399](https://github.com/wasmerio/wasmer/pull/399) Add example of using a plugin extended from WASI
+- [#397](https://github.com/wasmerio/wasmer/pull/397) Fix WASI fs abstraction to work on Windows
+- [#390](https://github.com/wasmerio/wasmer/pull/390) Pin released wapm version and add it as a git submodule
+- [#408](https://github.com/wasmerio/wasmer/pull/408) Add images to windows installer and update installer to add wapm bin directory to path
+
+## 0.4.0 - 2019-04-23
+
+- [#383](https://github.com/wasmerio/wasmer/pull/383) Hook up wasi exit code to wasmer cli.
+- [#382](https://github.com/wasmerio/wasmer/pull/382) Improve error message on `--backend` flag to only suggest currently enabled backends
+- [#381](https://github.com/wasmerio/wasmer/pull/381) Allow retrieving propagated user errors.
+- [#379](https://github.com/wasmerio/wasmer/pull/379) Fix small return types from imported functions.
+- [#371](https://github.com/wasmerio/wasmer/pull/371) Add more Debug impl for WASI types
+- [#368](https://github.com/wasmerio/wasmer/pull/368) Fix issue with write buffering
+- [#343](https://github.com/wasmerio/wasmer/pull/343) Implement preopened files for WASI and fix aligment issue when accessing WASI memory
+- [#367](https://github.com/wasmerio/wasmer/pull/367) Add caching support to the LLVM backend.
+- [#366](https://github.com/wasmerio/wasmer/pull/366) Remove `UserTrapper` trait to fix [#365](https://github.com/wasmerio/wasmer/issues/365).
+- [#348](https://github.com/wasmerio/wasmer/pull/348) Refactor internal runtime ↔️ backend abstraction.
+- [#355](https://github.com/wasmerio/wasmer/pull/355) Misc changes to `Cargo.toml`s for publishing
+- [#352](https://github.com/wasmerio/wasmer/pull/352) Bump version numbers to 0.3.0
+- [#351](https://github.com/wasmerio/wasmer/pull/351) Add hidden option to specify wasm program name (can be used to improve error messages)
+- [#350](https://github.com/wasmerio/wasmer/pull/350) Enforce that CHANGELOG.md is updated through CI.
+- [#349](https://github.com/wasmerio/wasmer/pull/349) Add [CHANGELOG.md](https://github.com/wasmerio/wasmer/blob/master/CHANGELOG.md).
+
+## 0.3.0 - 2019-04-12
+
+- [#276](https://github.com/wasmerio/wasmer/pull/276) [#288](https://github.com/wasmerio/wasmer/pull/288) [#344](https://github.com/wasmerio/wasmer/pull/344) Use new singlepass backend (with the `--backend=singlepass` when running Wasmer)
+- [#338](https://github.com/wasmerio/wasmer/pull/338) Actually catch traps/panics/etc when using a typed func.
+- [#325](https://github.com/wasmerio/wasmer/pull/325) Fixed func_index in debug mode
+- [#323](https://github.com/wasmerio/wasmer/pull/323) Add validate subcommand to validate Wasm files
+- [#321](https://github.com/wasmerio/wasmer/pull/321) Upgrade to Cranelift 0.3.0
+- [#319](https://github.com/wasmerio/wasmer/pull/319) Add Export and GlobalDescriptor to Runtime API
+- [#310](https://github.com/wasmerio/wasmer/pull/310) Cleanup warnings
+- [#299](https://github.com/wasmerio/wasmer/pull/299) [#300](https://github.com/wasmerio/wasmer/pull/300) [#301](https://github.com/wasmerio/wasmer/pull/301) [#303](https://github.com/wasmerio/wasmer/pull/303) [#304](https://github.com/wasmerio/wasmer/pull/304) [#305](https://github.com/wasmerio/wasmer/pull/305) [#306](https://github.com/wasmerio/wasmer/pull/306) [#307](https://github.com/wasmerio/wasmer/pull/307) Add support for WASI 🎉
+- [#286](https://github.com/wasmerio/wasmer/pull/286) Add extend to imports
+- [#278](https://github.com/wasmerio/wasmer/pull/278) Add versioning to cache
+- [#250](https://github.com/wasmerio/wasmer/pull/250) Setup bors
diff --git a/arbitrator/tools/module_roots/wasmer/CODE_OF_CONDUCT.md b/arbitrator/tools/module_roots/wasmer/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..d9965c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/CODE_OF_CONDUCT.md
@@ -0,0 +1,76 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+ advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+ address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at contact@wasmer.io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq
diff --git a/arbitrator/tools/module_roots/wasmer/CONTRIBUTING.md b/arbitrator/tools/module_roots/wasmer/CONTRIBUTING.md
new file mode 100644
index 0000000..e2b5d10
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/CONTRIBUTING.md
@@ -0,0 +1,28 @@
+# How to Contribute to Wasmer
+
+Thank you for your interest in contributing to Wasmer. This document outlines some recommendations on how to contribute.
+
+## Issues & Feature Requests
+
+Please use the issue template and provide a failing example if possible to help us recreate the issue.
+
+## Pull Requests
+
+For large changes, please try reaching communicating with the Wasmer maintainers via GitHub Issues or Spectrum Chat to ensure we can accept the change once it is ready.
+
+We recommend trying the following commands before sending a pull request to ensure code quality:
+
+- `cargo fmt --all` Ensures all code is correctly formatted.
+- Run `cargo test` in the crates that you are modifying.
+- Run `cargo build --all`.
+
+A comprehensive CI test suite will be run by a Wasmer team member after the PR has been created.
+
+### Common Build Issues
+
+#### LLVM Dependency
+
+`Didn't find usable system-wide LLVM`
+
+Building Wasmer with the LLVM backend requires LLVM 14 or better to be installed
+On debian family you need `sudo apt install llvm14 libclang-common-14-dev libpolly-14-dev`
diff --git a/arbitrator/tools/module_roots/wasmer/Cargo.lock b/arbitrator/tools/module_roots/wasmer/Cargo.lock
new file mode 100644
index 0000000..9910cd9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/Cargo.lock
@@ -0,0 +1,7457 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+dependencies = [
+ "gimli 0.28.1",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "ahash"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
+dependencies = [
+ "cfg-if 1.0.0",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "aliasable"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd"
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
+
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstream"
+version = "0.6.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d96bd03f33fe50a863e394ee9718a706f988b9079b20c3784fb726e7678b62fb"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
+dependencies = [
+ "anstyle",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "any_ascii"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70033777eb8b5124a81a1889416543dddef2de240019b674c81285a2635a7e1e"
+
+[[package]]
+name = "anyhow"
+version = "1.0.81"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247"
+
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b4930d2cb77ce62f89ee5d5289b4ac049559b1c45539271f5ed4fdc7db34545"
+
+[[package]]
+name = "arrayvec"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
+[[package]]
+name = "ascii"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eab1c04a571841102f5345a8fc0f6bb3d31c315dec879b5c6e42e40ce7ffa34e"
+
+[[package]]
+name = "assert_cmd"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c98233c6673d8601ab23e77eb38f999c51100d46c5703b17288c57fddf3a1ffe"
+dependencies = [
+ "bstr 0.2.17",
+ "doc-comment",
+ "predicates 2.1.5",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "assert_cmd"
+version = "2.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8"
+dependencies = [
+ "anstyle",
+ "bstr 1.9.1",
+ "doc-comment",
+ "predicates 3.1.0",
+ "predicates-core",
+ "predicates-tree",
+ "wait-timeout",
+]
+
+[[package]]
+name = "async-compression"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86a9249d1447a85f95810c620abea82e001fe58a31713fcce614caf52499f905"
+dependencies = [
+ "flate2",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio 1.37.0",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "async-tungstenite"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e9efbe14612da0a19fb983059a0b621e9cf6225d7018ecab4f9988215540dc"
+dependencies = [
+ "futures-io",
+ "futures-util",
+ "log 0.4.21",
+ "pin-project-lite",
+ "tungstenite",
+]
+
+[[package]]
+name = "atomic-polyfill"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+dependencies = [
+ "critical-section",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
+
+[[package]]
+name = "backtrace"
+version = "0.3.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if 1.0.0",
+ "libc",
+ "miniz_oxide",
+ "object 0.32.2",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "bincode"
+version = "1.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake3"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cca6d3674597c30ddf2c587bf8d9d65c9a84d2326d941cc79c9842dfe0ef52"
+dependencies = [
+ "arrayref",
+ "arrayvec 0.7.4",
+ "cc",
+ "cfg-if 1.0.0",
+ "constant_time_eq",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[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.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
+dependencies = [
+ "memchr",
+ "regex-automata 0.4.6",
+ "serde",
+]
+
+[[package]]
+name = "build-deps"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64f14468960818ce4f3e3553c32d524446687884f8e7af5d3e252331d8a87e43"
+dependencies = [
+ "glob",
+]
+
+[[package]]
+name = "build_const"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ae4235e6dac0694637c763029ecea1a2ec9e4e06ec2729bd21ba4d9c863eb7"
+
+[[package]]
+name = "bumpalo"
+version = "3.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ff69b9dd49fd426c69a0db9fc04dd934cdb6645ff000864d98f7e2af8830eaa"
+
+[[package]]
+name = "bytecheck"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206fdffcfa2df7cbe15601ef46c813fce0965eb3286db6b56c583b814b51c81c"
+dependencies = [
+ "byteorder",
+ "iovec",
+]
+
+[[package]]
+name = "bytes"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bytesize"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "camino"
+version = "1.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c59e92b5a388f549b863a7bea62612c09f24c8393560709a54558a9abdfb3b9c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24b1f0365a6c6bb4020cd05806fd0d33c44d38046b8bd7f0e40814b9763cabfc"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.15.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver 1.0.22",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cbindgen"
+version = "0.24.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b922faaf31122819ec80c4047cc684c6979a087366c069611e33649bf98e18d"
+dependencies = [
+ "heck 0.4.1",
+ "indexmap 1.9.3",
+ "log 0.4.21",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "syn 1.0.109",
+ "tempfile",
+ "toml 0.5.11",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cd6604a82acf3039f1144f54b8eb34e91ffba622051189e71b781822d5ee1f5"
+dependencies = [
+ "jobserver",
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "chrono"
+version = "0.4.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a0d04d43504c61aa6c7531f1871dd0d418d91130162063b789da00fd7057a5e"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets 0.52.4",
+]
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half 2.4.0",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "clap"
+version = "4.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfaff671f6b22ca62406885ece523383b9b64022e341e53e009a62ebc47a45f2"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a216b506622bb1d316cd51328dce24e07bdff4a6128a47c7e7fad11878d5adbb"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
+
+[[package]]
+name = "cloudabi"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddfc5b9aa5d4507acaf872de71051dfd0e309860e88966e1051e462a077aac4f"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
+
+[[package]]
+name = "colored"
+version = "1.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f741c91823341bebf717d4c71bda820630ce065443b58bd1b7451af008355"
+dependencies = [
+ "is-terminal",
+ "lazy_static",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "colored"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cbf2150cce219b664a8a70df7a1f933836724b503f8a413af9365b4dcc4d90b8"
+dependencies = [
+ "lazy_static",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "combine"
+version = "3.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3da6baa321ec19e1cc41d31bf599f00c783d0517095cdaf0332e3fe8d20680"
+dependencies = [
+ "ascii",
+ "byteorder",
+ "either",
+ "memchr",
+ "unreachable",
+]
+
+[[package]]
+name = "comfy-table"
+version = "7.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c64043d6c7b7a4c58e39e7efccfdea7b93d885a795d0c054a69dbbf4dd52686"
+dependencies = [
+ "crossterm",
+ "strum",
+ "strum_macros",
+ "unicode-width",
+]
+
+[[package]]
+name = "compiler-test-derive"
+version = "0.0.1"
+dependencies = [
+ "pretty_assertions",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "trybuild",
+]
+
+[[package]]
+name = "compiletest_rs"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0086d6ad78cf409c3061618cd98e2789d5c9ce598fc9651611cf62eae0a599cb"
+dependencies = [
+ "diff",
+ "filetime",
+ "getopts",
+ "lazy_static",
+ "libc",
+ "log 0.4.21",
+ "miow 0.3.7",
+ "regex",
+ "rustfix",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tester",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "console"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+dependencies = [
+ "encode_unicode",
+ "lazy_static",
+ "libc",
+ "unicode-width",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "console_error_panic_hook"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a06aeb73f470f66dcdbf7223caeebb85984942f22f1adb2a088cf9668146bbbc"
+dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7144d30dcf0fafbce74250a3963025d8d52177934239851c917d29f1df280c2"
+
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
+name = "cooked-waker"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147be55d677052dabc6b22252d5dd0fd4c29c8c27aa4f2fbef0f94aa003b406f"
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+
+[[package]]
+name = "corosensei"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e"
+dependencies = [
+ "autocfg",
+ "cfg-if 1.0.0",
+ "libc",
+ "scopeguard",
+ "windows-sys 0.33.0",
+]
+
+[[package]]
+name = "counter"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d458e66999348f56fd3ffcfbb7f7951542075ca8359687c703de6500c1ddccd"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cranelift-bforest"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2ab4512dfd3a6f4be184403a195f76e81a8a9f9e6c898e19d2dc3ce20e0115"
+dependencies = [
+ "cranelift-entity",
+]
+
+[[package]]
+name = "cranelift-codegen"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98b022ed2a5913a38839dfbafe6cf135342661293b08049843362df4301261dc"
+dependencies = [
+ "arrayvec 0.7.4",
+ "bumpalo",
+ "cranelift-bforest",
+ "cranelift-codegen-meta",
+ "cranelift-codegen-shared",
+ "cranelift-egraph",
+ "cranelift-entity",
+ "cranelift-isle",
+ "gimli 0.26.2",
+ "hashbrown 0.12.3",
+ "log 0.4.21",
+ "regalloc2",
+ "smallvec 1.13.2",
+ "target-lexicon 0.12.14",
+]
+
+[[package]]
+name = "cranelift-codegen-meta"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "639307b45434ad112a98f8300c0f0ab085cbefcd767efcdef9ef19d4c0756e74"
+dependencies = [
+ "cranelift-codegen-shared",
+]
+
+[[package]]
+name = "cranelift-codegen-shared"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "278e52e29c53fcf32431ef08406c295699a70306d05a0715c5b1bf50e33a9ab7"
+
+[[package]]
+name = "cranelift-egraph"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624b54323b06e675293939311943ba82d323bb340468ce1889be5da7932c8d73"
+dependencies = [
+ "cranelift-entity",
+ "fxhash",
+ "hashbrown 0.12.3",
+ "indexmap 1.9.3",
+ "log 0.4.21",
+ "smallvec 1.13.2",
+]
+
+[[package]]
+name = "cranelift-entity"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a59bcbca89c3f1b70b93ab3cbba5e5e0cbf3e63dadb23c7525cb142e21a9d4c"
+
+[[package]]
+name = "cranelift-frontend"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d70abacb8cfef3dc8ff7e8836e9c1d70f7967dfdac824a4cd5e30223415aca6"
+dependencies = [
+ "cranelift-codegen",
+ "hashbrown 0.12.3",
+ "log 0.4.21",
+ "smallvec 1.13.2",
+ "target-lexicon 0.12.14",
+]
+
+[[package]]
+name = "cranelift-isle"
+version = "0.91.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "393bc73c451830ff8dbb3a07f61843d6cb41a084f9996319917c0b291ed785bb"
+
+[[package]]
+name = "crc"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d663548de7f5cca343f1e0a48d14dcfb0e9eb4e079ec58883b7251539fa10aeb"
+dependencies = [
+ "build_const",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools 0.10.5",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools 0.10.5",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7059fff8937831a9ae6f0fe4d658ffabf58f2ca96aa9dec1c889f936f705f216"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3db02a9c5b5121e1e42fbdb1aeb65f5e02624cc58c43f2884c6ccac0b82f95"
+dependencies = [
+ "crossbeam-utils 0.8.19",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20ff29ded3204c5106278a81a38f4b482636ed4fa1e6cfbeef193291beb29ed"
+dependencies = [
+ "crossbeam-epoch 0.8.2",
+ "crossbeam-utils 0.7.2",
+ "maybe-uninit",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+dependencies = [
+ "crossbeam-epoch 0.9.18",
+ "crossbeam-utils 0.8.19",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
+dependencies = [
+ "autocfg",
+ "cfg-if 0.1.10",
+ "crossbeam-utils 0.7.2",
+ "lazy_static",
+ "maybe-uninit",
+ "memoffset 0.5.6",
+ "scopeguard",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils 0.8.19",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570"
+dependencies = [
+ "cfg-if 0.1.10",
+ "crossbeam-utils 0.7.2",
+ "maybe-uninit",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+dependencies = [
+ "crossbeam-utils 0.8.19",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
+dependencies = [
+ "autocfg",
+ "cfg-if 0.1.10",
+ "lazy_static",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
+
+[[package]]
+name = "crossterm"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
+dependencies = [
+ "bitflags 2.5.0",
+ "crossterm_winapi",
+ "libc",
+ "parking_lot 0.12.1",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctor"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
+dependencies = [
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "cynic"
+version = "3.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7335114540697c7b1c1a0131cbe0e983fdb1e646f881234afe9e2a66133ac99a"
+dependencies = [
+ "cynic-proc-macros",
+ "ref-cast",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "static_assertions",
+ "thiserror",
+]
+
+[[package]]
+name = "cynic-codegen"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ac40efa3e97024222fa95d4c85ce093e2337ed5cdf7279374777132b419f50c"
+dependencies = [
+ "counter",
+ "darling 0.20.8",
+ "graphql-parser",
+ "once_cell",
+ "ouroboros",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.58",
+ "thiserror",
+]
+
+[[package]]
+name = "cynic-proc-macros"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff4890059f47b6864d53231fd7d336893fc4a28bc1fff62c3ad4966a82994b84"
+dependencies = [
+ "cynic-codegen",
+ "darling 0.20.8",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "darling"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b750cb3417fd1b327431a470f388520309479ab0bf5e323505daf0290cd3850"
+dependencies = [
+ "darling_core 0.14.4",
+ "darling_macro 0.14.4",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "54e36fcd13ed84ffdfda6f5be89b31287cbb80c439841fe69e04841435464391"
+dependencies = [
+ "darling_core 0.20.8",
+ "darling_macro 0.20.8",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "109c1ca6e6b7f82cc233a97004ea8ed7ca123a9af07a8230878fcfda9b158bf0"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c2cf1c23a687a1feeb728783b993c4e1ad83d99f351801977dd809b48d0a70f"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4aab4dbc9f7611d8b55048a3a16d2d010c2c8334e46304b40ac1cc14bf3b48e"
+dependencies = [
+ "darling_core 0.14.4",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a668eda54683121533a393014d8692171709ff57a7d61f187b6e782719f8933f"
+dependencies = [
+ "darling_core 0.20.8",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "dashmap"
+version = "5.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if 1.0.0",
+ "hashbrown 0.14.3",
+ "lock_api 0.4.11",
+ "once_cell",
+ "parking_lot_core 0.9.9",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
+
+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+ "serde",
+]
+
+[[package]]
+name = "derivative"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "derive_builder"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d67778784b508018359cbc8696edb3db78160bab2c2a28ba7f56ef6932997f8"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c11bdc11a0c47bc7d37d582b5285da6849c96681023680b906673c5707af7b0f"
+dependencies = [
+ "darling 0.14.4",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebcda35c7a396850a55ffeac740804b40ffec779b98fffbb1738f4033f0ee79e"
+dependencies = [
+ "derive_builder_core",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "derive_more"
+version = "0.99.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.4.0",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "dialoguer"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bce805d770f407bc62102fca7c2c64ceef2fbcb2b8bd19d2765ce093980de"
+dependencies = [
+ "console",
+ "shell-words",
+ "tempfile",
+ "thiserror",
+ "zeroize",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "difflib"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "dirs"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-next"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+dependencies = [
+ "cfg-if 1.0.0",
+ "dirs-sys-next",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "dirs-sys-next"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+dependencies = [
+ "libc",
+ "redox_users",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "distance"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d9d8664cf849d7d0f3114a3a387d2f5e4303176d746d5a951aaddc66dfe9240"
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d6ef0072f8a535281e4876be788938b528e9a1d43900b82c2569af7da799125"
+
+[[package]]
+name = "dynasm"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "add9a102807b524ec050363f09e06f1504214b0e1c7797f64261c891022dce8b"
+dependencies = [
+ "bitflags 1.3.2",
+ "byteorder",
+ "lazy_static",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "dynasmrt"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64fba5a42bd76a17cad4bfa00de168ee1cbfa06a5e8ce992ae880218c05641a9"
+dependencies = [
+ "byteorder",
+ "dynasm",
+ "memmap2 0.5.10",
+]
+
+[[package]]
+name = "edge-schema"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "183ddfb52c2441be9d8c3c870632135980ba98e0c4f688da11bcbebb4e26f128"
+dependencies = [
+ "anyhow",
+ "bytesize",
+ "once_cell",
+ "parking_lot 0.12.1",
+ "rand_chacha",
+ "rand_core",
+ "schemars",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_yaml 0.8.26",
+ "sparx",
+ "time 0.3.34",
+ "url",
+ "uuid",
+ "wcgi-host",
+]
+
+[[package]]
+name = "edge-schema"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0966f1fd49610cc67a835124e6fb4d00a36104e1aa34383c5ef5a265ca00ea2a"
+dependencies = [
+ "anyhow",
+ "bytesize",
+ "once_cell",
+ "parking_lot 0.12.1",
+ "rand_chacha",
+ "rand_core",
+ "schemars",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_yaml 0.8.26",
+ "sparx",
+ "time 0.3.34",
+ "url",
+ "uuid",
+ "wcgi-host",
+]
+
+[[package]]
+name = "edge-util"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60d06780ae676369e0a9ac2c75f7d1a6d22e157ef5b10cfeda0ee6a465cf7337"
+dependencies = [
+ "edge-schema 0.0.3",
+ "http",
+ "serde",
+ "wasmparser 0.121.2",
+]
+
+[[package]]
+name = "educe"
+version = "0.4.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f0042ff8246a363dbe77d2ceedb073339e85a804b9a47636c6e016a9a32c05f"
+dependencies = [
+ "enum-ordinalize",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "either"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
+
+[[package]]
+name = "encode_unicode"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "enum-iterator"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6"
+dependencies = [
+ "enum-iterator-derive",
+]
+
+[[package]]
+name = "enum-iterator-derive"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "enum-ordinalize"
+version = "3.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf1fa3f06bbff1ea5b1a9c7b14aa992a39657db60a2759457328d7e058f49ee"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "enumset"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "226c0da7462c13fb57e5cc9e0dc8f0635e7d27f276a3a7fd30054647f669007d"
+dependencies = [
+ "enumset_derive",
+]
+
+[[package]]
+name = "enumset_derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08b6c6ab82d70f08844964ba10c7babb716de2ecaeab9be5717918a5177d3af"
+dependencies = [
+ "darling 0.20.8",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "erased-serde"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c138974f9d5e7fe373eb04df7cae98833802ae4b11c24ac7039a21d5af4b26c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fastrand"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
+
+[[package]]
+name = "fern"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f0c14694cbd524c8720dd69b0e3179344f04ebb5f90f2e4a440c6ea3b2f1ee"
+dependencies = [
+ "colored 1.9.4",
+ "log 0.4.21",
+]
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset 0.9.1",
+ "rustc_version 0.4.0",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall 0.4.1",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "flate2"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "float-cmp"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98de4bbd547a563b716d8dfa9aad1cb19bfab00f4fa09a6a4ed21dbcf44ce9c4"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "fuchsia-zircon"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
+dependencies = [
+ "bitflags 1.3.2",
+ "fuchsia-zircon-sys",
+]
+
+[[package]]
+name = "fuchsia-zircon-sys"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "fuse"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80e57070510966bfef93662a81cb8aa2b1c7db0964354fa9921434f04b9e8660"
+dependencies = [
+ "libc",
+ "log 0.3.9",
+ "pkg-config",
+ "thread-scoped",
+ "time 0.1.45",
+]
+
+[[package]]
+name = "futures"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a471a38ef8ed83cd6e40aa59c1ffe17db6855c18e3604d9c4ed8c08ebc28678"
+
+[[package]]
+name = "futures"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
+
+[[package]]
+name = "futures-task"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
+
+[[package]]
+name = "futures-util"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getopts"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
+dependencies = [
+ "cfg-if 1.0.0",
+ "js-sys",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "ghost"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0e085ded9f1267c32176b40921b9754c474f7dd96f7e808d4a982e48aa1e854"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "gimli"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
+dependencies = [
+ "fallible-iterator",
+ "indexmap 1.9.3",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "gimli"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
+
+[[package]]
+name = "glob"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+
+[[package]]
+name = "graphql-introspection-query"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f2a4732cf5140bd6c082434494f785a19cfb566ab07d1382c3671f5812fed6d"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "graphql-parser"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ebc8013b4426d5b81a4364c419a95ed0b404af2b82e2457de52d9348f0e474"
+dependencies = [
+ "combine",
+ "thiserror",
+]
+
+[[package]]
+name = "graphql-ws-client"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0063064d93204da0f0baf4dc0e03bf8a9307f6924a37e604b912a63b08aa7ea"
+dependencies = [
+ "async-tungstenite",
+ "futures 0.3.30",
+ "graphql_client",
+ "log 0.4.21",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "thiserror",
+ "uuid",
+]
+
+[[package]]
+name = "graphql_client"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cdf7b487d864c2939b23902291a5041bc4a84418268f25fda1c8d4e15ad8fa"
+dependencies = [
+ "graphql_query_derive",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "graphql_client_codegen"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a40f793251171991c4eb75bd84bc640afa8b68ff6907bc89d3b712a22f700506"
+dependencies = [
+ "graphql-introspection-query",
+ "graphql-parser",
+ "heck 0.4.1",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "graphql_query_derive"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00bda454f3d313f909298f626115092d348bc231025699f557b27e248475f48c"
+dependencies = [
+ "graphql_client_codegen",
+ "proc-macro2",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "gumdrop"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bc700f989d2f6f0248546222d9b4258f5b02a171a431f8285a81c08142629e3"
+dependencies = [
+ "gumdrop_derive",
+]
+
+[[package]]
+name = "gumdrop_derive"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "729f9bd3449d77e7831a18abfb7ba2f99ee813dfd15b8c2167c9a54ba20aa99d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "h2"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
+dependencies = [
+ "bytes 1.6.0",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http",
+ "indexmap 2.2.6",
+ "slab",
+ "tokio 1.37.0",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
+
+[[package]]
+name = "half"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5eceaaeec696539ddaf7b333340f1af35a5aa87ae3e4f3ead0532f72affab2e"
+dependencies = [
+ "cfg-if 1.0.0",
+ "crunchy",
+]
+
+[[package]]
+name = "handlebars"
+version = "3.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4498fc115fa7d34de968184e473529abb40eeb6be8bc5f7faba3d08c316cb3e3"
+dependencies = [
+ "log 0.4.21",
+ "pest",
+ "pest_derive",
+ "quick-error",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "harsh"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6fce2283849822530a18d7d8eeb1719ac65a27cfb6649c0dc8dfd2d2cc5edfb"
+
+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
+[[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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.8",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+dependencies = [
+ "ahash 0.8.11",
+ "allocator-api2",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8094feaf31ff591f651a2664fb9cfd92bba7a60ce3197265e9482ebe753c8f7"
+dependencies = [
+ "hashbrown 0.14.3",
+]
+
+[[package]]
+name = "heapless"
+version = "0.7.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+dependencies = [
+ "atomic-polyfill",
+ "hash32",
+ "rustc_version 0.4.0",
+ "spin",
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "heck"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "hermit-abi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes 1.6.0",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes 1.6.0",
+ "http",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-range-header"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f"
+
+[[package]]
+name = "http-serde"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f560b665ad9f1572cfcaf034f7fb84338a7ce945216d64a90fd81f046a3caee"
+dependencies = [
+ "http",
+ "serde",
+]
+
+[[package]]
+name = "httparse"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "hyper"
+version = "0.14.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
+dependencies = [
+ "bytes 1.6.0",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "socket2 0.5.6",
+ "tokio 1.37.0",
+ "tower-service",
+ "tracing",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.24.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
+dependencies = [
+ "futures-util",
+ "http",
+ "hyper",
+ "rustls 0.21.10",
+ "tokio 1.37.0",
+ "tokio-rustls",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+dependencies = [
+ "bytes 1.6.0",
+ "hyper",
+ "native-tls",
+ "tokio 1.37.0",
+ "tokio-native-tls",
+]
+
+[[package]]
+name = "hyper-tungstenite"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cc7dcb1ab67cd336f468a12491765672e61a3b6b148634dbfe2fe8acd3fe7d9"
+dependencies = [
+ "hyper",
+ "pin-project-lite",
+ "tokio 1.37.0",
+ "tokio-tungstenite",
+ "tungstenite",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25a2bc672d1148e28034f176e01fffebb08b35768468cc954630da77a1449005"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
+dependencies = [
+ "matches",
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "idna"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.14.3",
+ "serde",
+]
+
+[[package]]
+name = "indicatif"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "763a5a8f45087d6bcea4222e7b72c291a054edf80e4ef6efd2a4979878c7bea3"
+dependencies = [
+ "console",
+ "instant",
+ "number_prefix",
+ "portable-atomic",
+ "unicode-width",
+]
+
+[[package]]
+name = "inkwell"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbac11e485159a525867fb7e6aa61981453e6a72f625fde6a4ab3047b0c6dec9"
+dependencies = [
+ "either",
+ "inkwell_internals",
+ "libc",
+ "llvm-sys",
+ "once_cell",
+ "parking_lot 0.12.1",
+]
+
+[[package]]
+name = "inkwell_internals"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87d00c17e264ce02be5bc23d7bff959188ec7137beddd06b8b6b05a7c680ea85"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "inline-c"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "340dd3d6102fa919bd20987024a6d84954c36ec691ac1efea37742ee983c8dd5"
+dependencies = [
+ "assert_cmd 1.0.8",
+ "cc",
+ "inline-c-macro",
+ "lazy_static",
+ "predicates 2.1.5",
+ "regex",
+ "rustc_version 0.3.3",
+ "target-lexicon 0.11.2",
+ "tempfile",
+]
+
+[[package]]
+name = "inline-c-macro"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17f5621ec7adacda881d7c2826c064f5c29c72fd44333f97df61b458a583ae15"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.3.3",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "insta"
+version = "1.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3eab73f58e59ca6526037208f0e98851159ec1633cf17b6cd2e1f2c3fd5d53cc"
+dependencies = [
+ "console",
+ "lazy_static",
+ "linked-hash-map",
+ "serde",
+ "similar",
+]
+
+[[package]]
+name = "instant"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "interfaces"
+version = "0.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb6250a98af259a26fd5a4a6081fccea9ac116e4c3178acf4aeb86d32d2b7715"
+dependencies = [
+ "bitflags 2.5.0",
+ "cc",
+ "handlebars",
+ "lazy_static",
+ "libc",
+ "nix 0.26.4",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "inventory"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84344c6e0b90a9e2b6f3f9abe5cc74402684e348df7b32adca28747e0cef091a"
+dependencies = [
+ "ctor",
+ "ghost",
+]
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
+
+[[package]]
+name = "jobserver"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab46a6e9526ddef3ae7f787c06f0f2600639ba80ea3eade3d8e670a2230f51d6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
+dependencies = [
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "kernel32-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "leb128"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
+
+[[package]]
+name = "lexical-core"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
+dependencies = [
+ "arrayvec 0.5.2",
+ "bitflags 1.3.2",
+ "cfg-if 1.0.0",
+ "ryu",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-sort"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c09e4591611e231daf4d4c685a66cb0410cc1e502027a20ae55f2bb9e997207a"
+dependencies = [
+ "any_ascii",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.153"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "linked_hash_set"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47186c6da4d81ca383c7c47c1bfc80f4b95f4720514d860a5407aaf4233f9588"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
+
+[[package]]
+name = "llvm-sys"
+version = "150.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfd60e740af945d99c2446a52e3ab8cdba2f740a40a16c51f6871bdea2abc687"
+dependencies = [
+ "cc",
+ "lazy_static",
+ "libc",
+ "regex",
+ "semver 1.0.22",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4da24a77a3d8a6d4862d95f72e6fdb9c09a643ecdb402d754004a557f2bec75"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e19e8d5c34a3e0e2223db8e060f9e8264aeeb5c5fc64a4ee9965c062211c024b"
+dependencies = [
+ "log 0.4.21",
+]
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+
+[[package]]
+name = "lz4_flex"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75761162ae2b0e580d7e7c390558127e5f01b4194debd6221fd8c207fc80e3f5"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "lzma-rs"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aba8ecb0450dfabce4ad72085eed0a75dffe8f21f7ada05638564ea9db2d7fb1"
+dependencies = [
+ "byteorder",
+ "crc",
+]
+
+[[package]]
+name = "mac_address"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4863ee94f19ed315bf3bc00299338d857d4b5bc856af375cc97d237382ad3856"
+dependencies = [
+ "nix 0.23.2",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "mach"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "macro-wasmer-universal-test"
+version = "4.2.8"
+dependencies = [
+ "proc-macro2",
+ "proc-quote",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "managed"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ca88d725a0a943b096803bd34e73a4437208b6077654cc4ecb2947a5f91618d"
+
+[[package]]
+name = "matchers"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+dependencies = [
+ "regex-automata 0.1.10",
+]
+
+[[package]]
+name = "matches"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2532096657941c2fea9c289d370a250971c689d4f143798ff67113ec042024a5"
+
+[[package]]
+name = "maybe-uninit"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
+
+[[package]]
+name = "memchr"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+
+[[package]]
+name = "memmap2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memmap2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d28bba84adfe6646737845bc5ebbfa2c08424eb1c37e94a1fd2a82adb56a872"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "minisign"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4225fad231f4cfb67990de1750bb53f10ff1d5b42b91beb2a49e6ebd36c9ab4a"
+dependencies = [
+ "getrandom",
+ "rpassword",
+ "scrypt",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "mio"
+version = "0.6.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
+dependencies = [
+ "cfg-if 0.1.10",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log 0.4.21",
+ "miow 0.2.2",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
+[[package]]
+name = "mio"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
+dependencies = [
+ "libc",
+ "log 0.4.21",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "mio-uds"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afcb699eb26d4332647cc848492bbc15eafb26f08d0304550d5aa1f612e066f0"
+dependencies = [
+ "iovec",
+ "libc",
+ "mio 0.6.23",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
+]
+
+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "more-asserts"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389"
+
+[[package]]
+name = "native-tls"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "log 0.4.21",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "net2"
+version = "0.2.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
+dependencies = [
+ "cfg-if 0.1.10",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "nix"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
+dependencies = [
+ "bitflags 1.3.2",
+ "cc",
+ "cfg-if 1.0.0",
+ "libc",
+ "memoffset 0.6.5",
+]
+
+[[package]]
+name = "nix"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "598beaf3cc6fdd9a5dfb1630c2800c7acd31df7aaf0f565796fba2b53ca1af1b"
+dependencies = [
+ "bitflags 1.3.2",
+ "cfg-if 1.0.0",
+ "libc",
+ "memoffset 0.7.1",
+ "pin-utils",
+]
+
+[[package]]
+name = "nom"
+version = "5.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b"
+dependencies = [
+ "lexical-core",
+ "memchr",
+ "version_check",
+]
+
+[[package]]
+name = "normalize-line-endings"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be"
+
+[[package]]
+name = "normpath"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec60c60a693226186f5d6edf073232bfb6464ed97eb22cf3b01c1e8198fd97f5"
+dependencies = [
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+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-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
+dependencies = [
+ "num_enum_derive",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
+dependencies = [
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "number_prefix"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3"
+
+[[package]]
+name = "object"
+version = "0.28.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e42c982f2d955fac81dd7e1d0e1426a7d702acd9c98d19ab01083a6a0328c424"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "object"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
+dependencies = [
+ "crc32fast",
+ "hashbrown 0.12.3",
+ "indexmap 1.9.3",
+ "memchr",
+]
+
+[[package]]
+name = "object"
+version = "0.30.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b4680b86d9cfafba8fc491dc9b6df26b68cf40e9e6cd73909194759a63c385"
+dependencies = [
+ "flate2",
+ "memchr",
+]
+
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "flate2",
+ "memchr",
+ "ruzstd",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "oorandom"
+version = "11.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
+
+[[package]]
+name = "opener"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c62dcb6174f9cb326eac248f07e955d5d559c272730b6c03e396b443b562788"
+dependencies = [
+ "bstr 1.9.1",
+ "normpath",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "openssl"
+version = "0.10.64"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
+dependencies = [
+ "bitflags 2.5.0",
+ "cfg-if 1.0.0",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "ouroboros"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97b7be5a8a3462b752f4be3ff2b2bf2f7f1d00834902e46be2a4d68b87b0573c"
+dependencies = [
+ "aliasable",
+ "ouroboros_macro",
+ "static_assertions",
+]
+
+[[package]]
+name = "ouroboros_macro"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b645dcde5f119c2c454a92d0dfa271a2a3b205da92e4292a68ead4bdbfde1f33"
+dependencies = [
+ "heck 0.4.1",
+ "itertools 0.12.1",
+ "proc-macro2",
+ "proc-macro2-diagnostics",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
+[[package]]
+name = "parking_lot"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f842b1982eb6c2fe34036a4fbfb06dd185a3f5c8edfaacdf7d1ea10b07de6252"
+dependencies = [
+ "lock_api 0.3.4",
+ "parking_lot_core 0.6.3",
+ "rustc_version 0.2.3",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api 0.4.11",
+ "parking_lot_core 0.9.9",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66b810a62be75176a80873726630147a5ca780cd33921e0b5709033e66b0a"
+dependencies = [
+ "cfg-if 0.1.10",
+ "cloudabi",
+ "libc",
+ "redox_syscall 0.1.57",
+ "rustc_version 0.2.3",
+ "smallvec 0.6.14",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall 0.4.1",
+ "smallvec 1.13.2",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
+[[package]]
+name = "path-clean"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17359afc20d7ab31fdb42bb844c8b3bb1dabd7dcf7e68428492da7f16966fcef"
+
+[[package]]
+name = "pathdiff"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest",
+ "hmac",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+
+[[package]]
+name = "pest"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "311fb059dee1a7b802f036316d790138c613a4e8b180c822e3925a662e9f0c95"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f73541b156d32197eecda1a4014d7f868fd2bcb3c550d5386087cfba442bf69c"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c35eeed0a3fab112f75165fdc026b3913f4183133f19b49be773ac9ea966e8bd"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2adbf29bb9776f28caece835398781ab24435585fe0d4dc1374a61db5accedca"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
+
+[[package]]
+name = "petgraph"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.2.6",
+]
+
+[[package]]
+name = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "portable-atomic"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
+
+[[package]]
+name = "predicates"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59230a63c37f3e18569bdb90e4a89cbf5bf8b06fea0b84e65ea10cc4df47addd"
+dependencies = [
+ "difflib",
+ "float-cmp",
+ "itertools 0.10.5",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68b87bfd4605926cdfefc1c3b5f8fe560e3feca9d5552cf68c466d3d8236c7e8"
+dependencies = [
+ "anstyle",
+ "difflib",
+ "float-cmp",
+ "normalize-line-endings",
+ "predicates-core",
+ "regex",
+]
+
+[[package]]
+name = "predicates-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b794032607612e7abeb4db69adb4e33590fa6cf1149e95fd7cb00e634b92f174"
+
+[[package]]
+name = "predicates-tree"
+version = "1.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368ba315fb8c5052ab692e68a0eefec6ec57b23a36959c14496f0b0df2c0cecf"
+dependencies = [
+ "predicates-core",
+ "termtree",
+]
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af7cee1a6c8a5b9208b3cb1061f10c0cb689087b3d8ce85fb9d2dd7a29b6ba66"
+dependencies = [
+ "diff",
+ "yansi 0.5.1",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-hack"
+version = "0.5.20+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "proc-macro2-diagnostics"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+ "version_check",
+ "yansi 1.0.1",
+]
+
+[[package]]
+name = "proc-quote"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e84ab161de78c915302ca325a19bee6df272800e2ae1a43fe3ef430bab2a100"
+dependencies = [
+ "proc-macro-hack",
+ "proc-macro2",
+ "proc-quote-impl",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "proc-quote-impl"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fb3ec628b063cdbcf316e06a8b8c1a541d28fa6c0a8eacd2bfb2b7f49e88aa0"
+dependencies = [
+ "proc-macro-hack",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "ptr_meta"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pulldown-cmark"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ffade02495f22453cd593159ea2f59827aae7f53fa8323f756799b670881dcf8"
+dependencies = [
+ "bitflags 1.3.2",
+ "memchr",
+ "unicase",
+]
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quote"
+version = "1.0.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque 0.8.5",
+ "crossbeam-utils 0.8.19",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
+dependencies = [
+ "getrandom",
+ "libredox",
+ "thiserror",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4846d4c50d1721b1a3bef8af76924eef20d5e723647333798c1b519b3a9473f"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fddb4f8d99b0a2ebafc65a87a69a7b9875e4b1ae1f00db265d300ef7f28bccc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "regalloc2"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300d4fbfb40c1c66a78ba3ddd41c1110247cf52f97b87d0f2fc9209bd49b030c"
+dependencies = [
+ "fxhash",
+ "log 0.4.21",
+ "slice-group-by",
+ "smallvec 1.13.2",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata 0.4.6",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+dependencies = [
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.3",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+
+[[package]]
+name = "region"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6b6ebd13bc009aef9cd476c1310d49ac354d36e240cf1bd753290f3dc7199a7"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+ "mach2",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rend"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+dependencies = [
+ "bytecheck",
+]
+
+[[package]]
+name = "replace_with"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a8614ee435691de62bcffcf4a66d91b3594bf1428a5722e79103249a095690"
+
+[[package]]
+name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "async-compression",
+ "base64 0.21.7",
+ "bytes 1.6.0",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "hyper",
+ "hyper-rustls",
+ "hyper-tls",
+ "ipnet",
+ "js-sys",
+ "log 0.4.21",
+ "mime",
+ "mime_guess",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls 0.21.10",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "system-configuration",
+ "tokio 1.37.0",
+ "tokio-native-tls",
+ "tokio-rustls",
+ "tokio-util",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams",
+ "web-sys",
+ "webpki-roots 0.25.4",
+ "winreg",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c17fa4cb658e3583423e915b9f3acc01cceaee1860e33d59ebae66adc3a2dc0d"
+dependencies = [
+ "cc",
+ "cfg-if 1.0.0",
+ "getrandom",
+ "libc",
+ "spin",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rkyv"
+version = "0.7.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5cba464629b3394fc4dbc6f940ff8f5b4ff5c7aef40f29166fd4ad12acbc99c0"
+dependencies = [
+ "bitvec",
+ "bytecheck",
+ "bytes 1.6.0",
+ "hashbrown 0.12.3",
+ "indexmap 1.9.3",
+ "ptr_meta",
+ "rend",
+ "rkyv_derive",
+ "seahash",
+ "tinyvec",
+ "uuid",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.7.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7dddfff8de25e6f62b9d64e6e432bf1c6736c57d20323e15ee10435fbda7c65"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "rmp"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f9860a6cc38ed1da53456442089b4dfa35e7cedaa326df63017af88385e6b20"
+dependencies = [
+ "byteorder",
+ "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "rmp-serde"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "723ecff9ad04f4ad92fe1c8ca6c20d2196d9286e9c60727c4cb5511629260e9d"
+dependencies = [
+ "byteorder",
+ "rmp",
+ "serde",
+]
+
+[[package]]
+name = "rpassword"
+version = "7.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80472be3c897911d0137b2d2b9055faf6eeac5b14e324073d83bc17b191d7e3f"
+dependencies = [
+ "libc",
+ "rtoolbox",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "rtoolbox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c247d24e63230cdb56463ae328478bd5eac8b8faa8c69461a77e8e323afac90e"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
+dependencies = [
+ "bitflags 1.3.2",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libsqlite3-sys",
+ "smallvec 1.13.2",
+]
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
+[[package]]
+name = "rustc_version"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
+dependencies = [
+ "semver 0.9.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
+dependencies = [
+ "semver 0.11.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+dependencies = [
+ "semver 1.0.22",
+]
+
+[[package]]
+name = "rustfix"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2c50b74badcddeb8f7652fa8323ce440b95286f8e4b64ebfd871c609672704e"
+dependencies = [
+ "anyhow",
+ "log 0.4.21",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
+dependencies = [
+ "log 0.4.21",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
+[[package]]
+name = "rustls"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99008d7ad0bbbea527ec27bddbc0e432c5b87d8175178cee68d2eec9c4a1813c"
+dependencies = [
+ "log 0.4.21",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.2",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe",
+ "rustls-pemfile",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecd36cc4259e3e4514335c4a138c6b43171a8d61d8f5c9348f9fc7529416f247"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faaa0a62740bedb9b2ef5afa303da42764c012f743917351dc9a237ea1663610"
+dependencies = [
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+
+[[package]]
+name = "rusty_jsc"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f8f838ac489c4fec2ae60bcd620e70ca829b75f83d4516f2708fd2a9edafdd0"
+dependencies = [
+ "rusty_jsc_macros",
+ "rusty_jsc_sys",
+]
+
+[[package]]
+name = "rusty_jsc_macros"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2407097cc2d172aedd2da887e68c1724c96f7828bad033096d0bb911dc4071"
+dependencies = [
+ "pkg-config",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "rusty_jsc_sys"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927443ab7a267331865e31bfe0ffb70216cbbadb8e3b15c09774fae6caa9d8df"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "rusty_pool"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ed36cdb20de66d89a17ea04b8883fc7a386f2cf877aaedca5005583ce4876ff"
+dependencies = [
+ "crossbeam-channel",
+ "futures 0.3.30",
+ "futures-channel",
+ "futures-executor",
+ "num_cpus",
+]
+
+[[package]]
+name = "ruzstd"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58c4eb8a81997cf040a091d1f7e1938aeab6749d3a0dfa73af43cdc32393483d"
+dependencies = [
+ "byteorder",
+ "derive_more",
+ "twox-hash",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
+dependencies = [
+ "dyn-clone",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "scoped-tls"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "332ffa32bf586782a3efaeb58f127980944bbc8c4d6913a86107ac2a5ab24b28"
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2",
+ "salsa20",
+ "sha2",
+]
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "security-framework"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "self_cell"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "58bf37232d3bb9a2c4e641ca2a11d83b5062066f88df7fed36c28772046d65ba"
+
+[[package]]
+name = "semver"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
+dependencies = [
+ "semver-parser 0.7.0",
+]
+
+[[package]]
+name = "semver"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
+dependencies = [
+ "semver-parser 0.10.2",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92d43fe69e652f3df9bdc2b85b2854a0825b86e4fb76bc44d945137d053639ca"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "semver-parser"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
+
+[[package]]
+name = "semver-parser"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
+dependencies = [
+ "pest",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.197"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-wasm-bindgen"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3b4c031cd0d9014307d82b8abf653c0290fbdaeb4c02d00c63cf52f728628bf"
+dependencies = [
+ "js-sys",
+ "serde",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "serde_bytes"
+version = "0.11.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half 1.8.3",
+ "serde",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.197"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.115"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12dc5c46daa8e9fdf4f5e71b6cf9a53f2487da0e86e55808e2d35539666497dd"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
+dependencies = [
+ "itoa",
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.8.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
+dependencies = [
+ "indexmap 1.9.3",
+ "ryu",
+ "serde",
+ "yaml-rust",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.2.6",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
+name = "serial_test"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e56dd856803e253c8f298af3f4d7eb0ae5e23a737252cd90bb4f3b435033b2d"
+dependencies = [
+ "dashmap",
+ "futures 0.3.30",
+ "lazy_static",
+ "log 0.4.21",
+ "parking_lot 0.12.1",
+ "serial_test_derive",
+]
+
+[[package]]
+name = "serial_test_derive"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shared-buffer"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6c99835bad52957e7aa241d3975ed17c1e5f8c92026377d117a606f36b84b16"
+dependencies = [
+ "bytes 1.6.0",
+ "memmap2 0.6.2",
+]
+
+[[package]]
+name = "shell-words"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a"
+
+[[package]]
+name = "similar"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa42c91313f1d05da9b26f267f931cf178d4aba455b4c4622dd7355eb80c6640"
+
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "slice-group-by"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826167069c09b99d56f31e9ae5c99049e932a98c9dc2dac47645b08dbbf76ba7"
+
+[[package]]
+name = "smallvec"
+version = "0.6.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97fcaeba89edba30f044a10c6a3cc39df9c3f17d7cd829dd1446cab35f890e0"
+dependencies = [
+ "maybe-uninit",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "smoltcp"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee34c1e1bfc7e9206cc0fb8030a90129b4e319ab53856249bb27642cab914fb3"
+dependencies = [
+ "bitflags 1.3.2",
+ "byteorder",
+ "managed",
+]
+
+[[package]]
+name = "socket2"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "socket2"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "sparx"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc2257c28eacecfc38c658124ed239e7ecfc9b89082c0794b0672420b63b84c6"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api 0.4.11",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strsim"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+
+[[package]]
+name = "strum"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
+
+[[package]]
+name = "strum_macros"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44cfb93f38070beee36b3fef7d4f5a16f27751d94b187b666a5cc5e9b0d30687"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tar"
+version = "0.4.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "422045212ea98508ae3d28025bc5aaa2bd4a9cdaecd442a08da2ee620ee9ea95"
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
+
+[[package]]
+name = "tempfile"
+version = "3.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+dependencies = [
+ "cfg-if 1.0.0",
+ "fastrand",
+ "rustix",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "term"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+dependencies = [
+ "dirs-next",
+ "rustversion",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "term_size"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e4129646ca0ed8f45d09b929036bafad5377103edd06e50bf574b353d2b08d9"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "termios"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "411c5bf740737c7918b8b1fe232dca4dc9f8e754b8ad5e20966814001ed0ac6b"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "termtree"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76"
+
+[[package]]
+name = "test-generator"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "target-lexicon 0.12.14",
+]
+
+[[package]]
+name = "test-log"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b319995299c65d522680decf80f2c108d85b861d81dfe340a10d16cee29d9e6"
+dependencies = [
+ "test-log-macros",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "test-log-macros"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8f546451eaa38373f549093fe9fd05e7d2bade739e2ddf834b9968621d60107"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "tester"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e8bf7e0eb2dd7b4228cc1b6821fc5114cd6841ae59f652a85488c016091e5f"
+dependencies = [
+ "cfg-if 1.0.0",
+ "getopts",
+ "libc",
+ "num_cpus",
+ "term",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03468839009160513471e86a034bb2c5c0e4baae3b43f79ffc55c4a5427b3297"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61f3ba182994efc43764a46c018c347bc492c79f024e705f46567b418f6d4f7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "thread-scoped"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcbb6aa301e5d3b0b5ef639c9a9c7e2f1c944f177b460c04dc24c69b1fa2bd99"
+
+[[package]]
+name = "thread_local"
+version = "1.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+dependencies = [
+ "cfg-if 1.0.0",
+ "once_cell",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "time"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tldextract"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec03259a0567ad58eed30812bc3e5eda8030f154abc70317ab57b14f00699ca4"
+dependencies = [
+ "idna 0.2.3",
+ "log 0.4.21",
+ "regex",
+ "serde_json",
+ "thiserror",
+ "url",
+]
+
+[[package]]
+name = "tokio"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "mio 0.6.23",
+ "num_cpus",
+ "tokio-codec",
+ "tokio-current-thread",
+ "tokio-executor",
+ "tokio-fs",
+ "tokio-io",
+ "tokio-reactor",
+ "tokio-sync",
+ "tokio-tcp",
+ "tokio-threadpool",
+ "tokio-timer",
+ "tokio-udp",
+ "tokio-uds",
+]
+
+[[package]]
+name = "tokio"
+version = "1.37.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
+dependencies = [
+ "backtrace",
+ "bytes 1.6.0",
+ "libc",
+ "mio 0.8.11",
+ "num_cpus",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.5.6",
+ "tokio-macros",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "tokio-codec"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "tokio-io",
+]
+
+[[package]]
+name = "tokio-core"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87b1395334443abca552f63d4f61d0486f12377c2ba8b368e523f89e828cffd4"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "iovec",
+ "log 0.4.21",
+ "mio 0.6.23",
+ "scoped-tls 0.1.2",
+ "tokio 0.1.22",
+ "tokio-executor",
+ "tokio-io",
+ "tokio-reactor",
+ "tokio-timer",
+]
+
+[[package]]
+name = "tokio-current-thread"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1de0e32a83f131e002238d7ccde18211c0a5397f60cbfffcb112868c2e0e20e"
+dependencies = [
+ "futures 0.1.31",
+ "tokio-executor",
+]
+
+[[package]]
+name = "tokio-executor"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb2d1b8f4548dbf5e1f7818512e9c406860678f29c300cdf0ebac72d1a3a1671"
+dependencies = [
+ "crossbeam-utils 0.7.2",
+ "futures 0.1.31",
+]
+
+[[package]]
+name = "tokio-fs"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4"
+dependencies = [
+ "futures 0.1.31",
+ "tokio-io",
+ "tokio-threadpool",
+]
+
+[[package]]
+name = "tokio-io"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "log 0.4.21",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio 1.37.0",
+]
+
+[[package]]
+name = "tokio-reactor"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09bc590ec4ba8ba87652da2068d150dcada2cfa2e07faae270a5e0409aa51351"
+dependencies = [
+ "crossbeam-utils 0.7.2",
+ "futures 0.1.31",
+ "lazy_static",
+ "log 0.4.21",
+ "mio 0.6.23",
+ "num_cpus",
+ "parking_lot 0.9.0",
+ "slab",
+ "tokio-executor",
+ "tokio-io",
+ "tokio-sync",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.10",
+ "tokio 1.37.0",
+]
+
+[[package]]
+name = "tokio-serde"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "911a61637386b789af998ee23f50aa30d5fd7edcec8d6d3dedae5e5815205466"
+dependencies = [
+ "bincode",
+ "bytes 1.6.0",
+ "educe",
+ "futures-core",
+ "futures-sink",
+ "pin-project",
+ "rmp-serde",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio 1.37.0",
+ "tokio-util",
+]
+
+[[package]]
+name = "tokio-sync"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edfe50152bc8164fcc456dab7891fa9bf8beaf01c5ee7e1dd43a397c3cf87dee"
+dependencies = [
+ "fnv",
+ "futures 0.1.31",
+]
+
+[[package]]
+name = "tokio-tcp"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98df18ed66e3b72e742f185882a9e201892407957e45fbff8da17ae7a7c51f72"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "iovec",
+ "mio 0.6.23",
+ "tokio-io",
+ "tokio-reactor",
+]
+
+[[package]]
+name = "tokio-threadpool"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df720b6581784c118f0eb4310796b12b1d242a7eb95f716a8367855325c25f89"
+dependencies = [
+ "crossbeam-deque 0.7.4",
+ "crossbeam-queue 0.2.3",
+ "crossbeam-utils 0.7.2",
+ "futures 0.1.31",
+ "lazy_static",
+ "log 0.4.21",
+ "num_cpus",
+ "slab",
+ "tokio-executor",
+]
+
+[[package]]
+name = "tokio-timer"
+version = "0.2.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93044f2d313c95ff1cb7809ce9a7a05735b012288a888b62d4434fd58c94f296"
+dependencies = [
+ "crossbeam-utils 0.7.2",
+ "futures 0.1.31",
+ "slab",
+ "tokio-executor",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
+dependencies = [
+ "futures-util",
+ "log 0.4.21",
+ "rustls 0.21.10",
+ "rustls-native-certs",
+ "tokio 1.37.0",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.25.4",
+]
+
+[[package]]
+name = "tokio-udp"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "log 0.4.21",
+ "mio 0.6.23",
+ "tokio-codec",
+ "tokio-io",
+ "tokio-reactor",
+]
+
+[[package]]
+name = "tokio-uds"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab57a4ac4111c8c9dbcf70779f6fc8bc35ae4b2454809febac840ad19bd7e4e0"
+dependencies = [
+ "bytes 0.4.12",
+ "futures 0.1.31",
+ "iovec",
+ "libc",
+ "log 0.4.21",
+ "mio 0.6.23",
+ "mio-uds",
+ "tokio-codec",
+ "tokio-io",
+ "tokio-reactor",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
+dependencies = [
+ "bytes 1.6.0",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio 1.37.0",
+ "tracing",
+]
+
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.9",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.2.6",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e40bb779c5187258fd7aad0eb68cb8706a0a81fa712fbea808ab43c4b8374c4"
+dependencies = [
+ "indexmap 2.2.6",
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow 0.6.5",
+]
+
+[[package]]
+name = "tower"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project",
+ "pin-project-lite",
+ "tokio 1.37.0",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c5bb1d698276a2443e5ecfabc1008bf15a36c12e6a7176e7bf089ea9131140"
+dependencies = [
+ "bitflags 2.5.0",
+ "bytes 1.6.0",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-range-header",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+
+[[package]]
+name = "tower-service"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
+
+[[package]]
+name = "tracing"
+version = "0.1.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
+dependencies = [
+ "log 0.4.21",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log 0.4.21",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-serde"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc6b213177105856957181934e4920de57730fc69bf42c37ee5bb664d406d9e1"
+dependencies = [
+ "serde",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex",
+ "serde",
+ "serde_json",
+ "sharded-slab",
+ "smallvec 1.13.2",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+ "tracing-serde",
+]
+
+[[package]]
+name = "tracing-test"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a2c0ff408fe918a94c428a3f2ad04e4afd5c95bbc08fcf868eff750c15728a4"
+dependencies = [
+ "lazy_static",
+ "tracing-core",
+ "tracing-subscriber",
+ "tracing-test-macro",
+]
+
+[[package]]
+name = "tracing-test-macro"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "258bc1c4f8e2e73a977812ab339d503e6feeb92700f6d07a6de4d321522d5c08"
+dependencies = [
+ "lazy_static",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "tracing-wasm"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4575c663a174420fa2d78f4108ff68f65bf2fbb7dd89f33749b6e826b3626e07"
+dependencies = [
+ "tracing",
+ "tracing-subscriber",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "trybuild"
+version = "1.0.91"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ad7eb6319ebadebca3dacf1f85a93bc54b73dd81b9036795f73de7ddfe27d5a"
+dependencies = [
+ "glob",
+ "once_cell",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "termcolor",
+ "toml 0.8.12",
+]
+
+[[package]]
+name = "tun-tap"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a477a4e9367c72ac875d23cd07ac99ffa932497d8428767fed0cfa27bbabe50"
+dependencies = [
+ "cc",
+ "futures 0.1.31",
+ "libc",
+ "mio 0.6.23",
+ "tokio-core",
+]
+
+[[package]]
+name = "tungstenite"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
+dependencies = [
+ "byteorder",
+ "bytes 1.6.0",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log 0.4.21",
+ "rand",
+ "rustls 0.21.10",
+ "sha1",
+ "thiserror",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if 1.0.0",
+ "static_assertions",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "typetag"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4080564c5b2241b5bff53ab610082234e0c57b0417f4bd10596f183001505b8a"
+dependencies = [
+ "erased-serde",
+ "inventory",
+ "once_cell",
+ "serde",
+ "typetag-impl",
+]
+
+[[package]]
+name = "typetag-impl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e60147782cc30833c05fba3bab1d9b5771b2685a2557672ac96fa5d154099c0e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
+
+[[package]]
+name = "unicase"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
+dependencies = [
+ "version_check",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
+[[package]]
+name = "unix_mode"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b55eedc365f81a3c32aea49baf23fa965e3cd85bcc28fb8045708c7388d124ef"
+
+[[package]]
+name = "unreachable"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
+dependencies = [
+ "void",
+]
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "2.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11f214ce18d8b2cbe84ed3aa6486ed3f5b285cf8d8fbdbce9f3f767a724adc35"
+dependencies = [
+ "base64 0.21.7",
+ "flate2",
+ "log 0.4.21",
+ "once_cell",
+ "rustls 0.22.3",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.2",
+ "url",
+ "webpki-roots 0.26.1",
+]
+
+[[package]]
+name = "url"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+dependencies = [
+ "form_urlencoded",
+ "idna 0.5.0",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "urlencoding"
+version = "2.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
+
+[[package]]
+name = "uuid"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+dependencies = [
+ "getrandom",
+ "serde",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "virtual-fs"
+version = "0.11.2"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "bytes 1.6.0",
+ "derivative",
+ "filetime",
+ "fs_extra",
+ "futures 0.3.30",
+ "getrandom",
+ "indexmap 1.9.3",
+ "lazy_static",
+ "libc",
+ "pin-project-lite",
+ "pretty_assertions",
+ "replace_with",
+ "serde",
+ "shared-buffer",
+ "slab",
+ "tempfile",
+ "thiserror",
+ "tokio 1.37.0",
+ "tracing",
+ "tracing-test",
+ "typetag",
+ "webc",
+]
+
+[[package]]
+name = "virtual-mio"
+version = "0.3.1"
+dependencies = [
+ "async-trait",
+ "bytes 1.6.0",
+ "derivative",
+ "futures 0.3.30",
+ "mio 0.8.11",
+ "serde",
+ "socket2 0.4.10",
+ "thiserror",
+ "tracing",
+]
+
+[[package]]
+name = "virtual-net"
+version = "0.6.3"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "base64 0.21.7",
+ "bincode",
+ "bytecheck",
+ "bytes 1.6.0",
+ "derivative",
+ "futures-util",
+ "hyper",
+ "hyper-tungstenite",
+ "libc",
+ "mio 0.8.11",
+ "pin-project-lite",
+ "rkyv",
+ "serde",
+ "serial_test",
+ "smoltcp",
+ "socket2 0.4.10",
+ "thiserror",
+ "tokio 1.37.0",
+ "tokio-serde",
+ "tokio-tungstenite",
+ "tokio-util",
+ "tracing",
+ "tracing-test",
+ "virtual-mio",
+]
+
+[[package]]
+name = "void"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+
+[[package]]
+name = "wai-bindgen-gen-core"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa3dc41b510811122b3088197234c27e08fcad63ef936306dd8e11e2803876c"
+dependencies = [
+ "anyhow",
+ "wai-parser",
+]
+
+[[package]]
+name = "wai-bindgen-gen-rust"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19bc05e8380515c4337c40ef03b2ff233e391315b178a320de8640703d522efe"
+dependencies = [
+ "heck 0.3.3",
+ "wai-bindgen-gen-core",
+]
+
+[[package]]
+name = "wai-bindgen-gen-rust-wasm"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f35ce5e74086fac87f3a7bd50f643f00fe3559adb75c88521ecaa01c8a6199"
+dependencies = [
+ "heck 0.3.3",
+ "wai-bindgen-gen-core",
+ "wai-bindgen-gen-rust",
+]
+
+[[package]]
+name = "wai-bindgen-gen-wasmer"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f61484185d8c520a86d5a7f7f8265f446617c2f9774b2e20a52de19b6e53432"
+dependencies = [
+ "heck 0.3.3",
+ "wai-bindgen-gen-core",
+ "wai-bindgen-gen-rust",
+]
+
+[[package]]
+name = "wai-bindgen-rust"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e5601c6f448c063e83a5e931b8fefcdf7e01ada424ad42372c948d2e3d67741"
+dependencies = [
+ "bitflags 1.3.2",
+ "wai-bindgen-rust-impl",
+]
+
+[[package]]
+name = "wai-bindgen-rust-impl"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdeeb5c1170246de8425a3e123e7ef260dc05ba2b522a1d369fe2315376efea4"
+dependencies = [
+ "proc-macro2",
+ "syn 1.0.109",
+ "wai-bindgen-gen-core",
+ "wai-bindgen-gen-rust-wasm",
+]
+
+[[package]]
+name = "wai-bindgen-wasmer"
+version = "0.18.3"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "bitflags 1.3.2",
+ "once_cell",
+ "thiserror",
+ "tracing",
+ "wai-bindgen-wasmer-impl",
+ "wasmer",
+]
+
+[[package]]
+name = "wai-bindgen-wasmer-impl"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b3488ed88d4dd0e3bf85bad4e27dac6cb31aae5d122a5dda2424803c8dc863a"
+dependencies = [
+ "proc-macro2",
+ "syn 1.0.109",
+ "wai-bindgen-gen-core",
+ "wai-bindgen-gen-wasmer",
+]
+
+[[package]]
+name = "wai-parser"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9bd0acb6d70885ea0c343749019ba74f015f64a9d30542e66db69b49b7e28186"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "pulldown-cmark",
+ "unicode-normalization",
+ "unicode-xid",
+]
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "waker-fn"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi-test-generator"
+version = "4.2.8"
+dependencies = [
+ "glob",
+ "gumdrop",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "wast 24.0.0",
+]
+
+[[package]]
+name = "wasite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
+dependencies = [
+ "cfg-if 1.0.0",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
+dependencies = [
+ "bumpalo",
+ "log 0.4.21",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
+dependencies = [
+ "cfg-if 1.0.0",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.92"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
+
+[[package]]
+name = "wasm-bindgen-test"
+version = "0.3.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bf62a58e0780af3e852044583deee40983e5886da43a271dd772379987667b"
+dependencies = [
+ "console_error_panic_hook",
+ "js-sys",
+ "scoped-tls 1.0.1",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-bindgen-test-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-test-macro"
+version = "0.3.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f89739351a2e03cb94beb799d47fb2cac01759b40ec441f7de39b00cbf7ef0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "wasm-coredump-builder"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31ca262b320e4530a60946ba16a1cbf987d3f7d4aa6a953bfcc96e179e3e7458"
+dependencies = [
+ "wasm-coredump-encoder",
+ "wasm-coredump-types",
+ "wasm-encoder 0.23.0",
+]
+
+[[package]]
+name = "wasm-coredump-encoder"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f36ccfe604720ce093fce7d7b0d609c086c646ec4bb9bba58cb9f4dc2c5623"
+dependencies = [
+ "leb128",
+ "wasm-coredump-types",
+]
+
+[[package]]
+name = "wasm-coredump-types"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2763d9807903c461b41275a13489396d04695d7bc365743b8ea430cfd72f336"
+
+[[package]]
+name = "wasm-encoder"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51b4949d4f2b25a4b208317dcf86aacef9e7a5884e48dfc45d4aeb91808d6f86"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c3e4bc09095436c8e7584d86d33e6c3ee67045af8fb262cbb9cc321de553428"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.32.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ba64e81215916eaeb48fee292f29401d69235d62d8b8fd92a7b2844ec5ae5f7"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wasm-smith"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7e95fdeed16adeffed44efdc7ccf27d4f57ff2e99de417c75bcee7dee09049b"
+dependencies = [
+ "arbitrary",
+ "indexmap 1.9.3",
+ "leb128",
+ "wasm-encoder 0.4.1",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmer"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "bytes 1.6.0",
+ "cfg-if 1.0.0",
+ "derivative",
+ "hashbrown 0.11.2",
+ "indexmap 1.9.3",
+ "js-sys",
+ "macro-wasmer-universal-test",
+ "more-asserts",
+ "rustc-demangle",
+ "rusty_jsc",
+ "serde",
+ "serde-wasm-bindgen",
+ "shared-buffer",
+ "target-lexicon 0.12.14",
+ "tempfile",
+ "thiserror",
+ "tracing",
+ "wasm-bindgen",
+ "wasm-bindgen-test",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
+ "wasmer-compiler-singlepass",
+ "wasmer-derive",
+ "wasmer-types",
+ "wasmer-vm",
+ "wasmparser 0.121.2",
+ "wat",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "wasmer-api"
+version = "0.0.25"
+dependencies = [
+ "anyhow",
+ "base64 0.13.1",
+ "cynic",
+ "edge-schema 0.1.0",
+ "futures 0.3.30",
+ "harsh",
+ "pin-project-lite",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "serde_path_to_error",
+ "time 0.3.34",
+ "tokio 1.37.0",
+ "tracing",
+ "url",
+ "uuid",
+ "webc",
+]
+
+[[package]]
+name = "wasmer-argus"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "clap",
+ "cynic",
+ "derive_more",
+ "futures 0.3.30",
+ "indicatif",
+ "log 0.4.21",
+ "reqwest",
+ "serde",
+ "serde_json",
+ "tokio 1.37.0",
+ "tracing",
+ "tracing-subscriber",
+ "url",
+ "wasmer",
+ "wasmer-api",
+ "webc",
+]
+
+[[package]]
+name = "wasmer-bin-fuzz"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "libfuzzer-sys",
+ "wasm-smith",
+ "wasmer",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
+ "wasmer-compiler-singlepass",
+ "wasmer-middlewares",
+ "wasmprinter",
+]
+
+[[package]]
+name = "wasmer-c-api"
+version = "4.2.8"
+dependencies = [
+ "cbindgen",
+ "cfg-if 1.0.0",
+ "enumset",
+ "field-offset",
+ "inline-c",
+ "lazy_static",
+ "libc",
+ "paste",
+ "thiserror",
+ "tokio 1.37.0",
+ "typetag",
+ "virtual-fs",
+ "wasmer",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
+ "wasmer-compiler-singlepass",
+ "wasmer-emscripten",
+ "wasmer-inline-c",
+ "wasmer-middlewares",
+ "wasmer-types",
+ "wasmer-wasix",
+ "webc",
+]
+
+[[package]]
+name = "wasmer-c-api-test-runner"
+version = "4.2.8"
+dependencies = [
+ "cc",
+ "regex",
+ "target-lexicon 0.11.2",
+ "walkdir",
+]
+
+[[package]]
+name = "wasmer-cache"
+version = "4.2.8"
+dependencies = [
+ "blake3",
+ "clap",
+ "clap_builder",
+ "clap_derive",
+ "clap_lex",
+ "criterion",
+ "hex",
+ "rand",
+ "tempfile",
+ "thiserror",
+ "wasmer",
+ "wasmer-compiler-singlepass",
+]
+
+[[package]]
+name = "wasmer-capi-examples-runner"
+version = "4.2.8"
+dependencies = [
+ "cc",
+ "regex",
+ "target-lexicon 0.11.2",
+ "walkdir",
+]
+
+[[package]]
+name = "wasmer-cli"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "assert_cmd 2.0.14",
+ "async-trait",
+ "bytes 1.6.0",
+ "bytesize",
+ "cargo_metadata",
+ "cfg-if 1.0.0",
+ "chrono",
+ "clap",
+ "colored 2.1.0",
+ "comfy-table",
+ "dialoguer",
+ "dirs",
+ "edge-schema 0.1.0",
+ "edge-util",
+ "flate2",
+ "fuse",
+ "futures 0.3.30",
+ "futures-util",
+ "hex",
+ "http",
+ "humantime",
+ "hyper",
+ "indexmap 1.9.3",
+ "indicatif",
+ "interfaces",
+ "is-terminal",
+ "libc",
+ "log 0.4.21",
+ "mac_address",
+ "mio 0.8.11",
+ "normpath",
+ "object 0.32.2",
+ "once_cell",
+ "opener",
+ "parking_lot 0.12.1",
+ "pathdiff",
+ "predicates 3.1.0",
+ "pretty_assertions",
+ "regex",
+ "reqwest",
+ "rkyv",
+ "semver 1.0.22",
+ "serde",
+ "serde_json",
+ "serde_yaml 0.8.26",
+ "sha2",
+ "shared-buffer",
+ "tar",
+ "target-lexicon 0.12.14",
+ "tempfile",
+ "thiserror",
+ "time 0.1.45",
+ "time 0.3.34",
+ "tldextract",
+ "tokio 1.37.0",
+ "tokio-tungstenite",
+ "toml 0.5.11",
+ "tracing",
+ "tracing-subscriber",
+ "tun-tap",
+ "unix_mode",
+ "url",
+ "uuid",
+ "virtual-fs",
+ "virtual-mio",
+ "virtual-net",
+ "walkdir",
+ "wasm-coredump-builder",
+ "wasmer",
+ "wasmer-api",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
+ "wasmer-compiler-singlepass",
+ "wasmer-emscripten",
+ "wasmer-object",
+ "wasmer-registry",
+ "wasmer-toml",
+ "wasmer-types",
+ "wasmer-vm",
+ "wasmer-wasix",
+ "wasmer-wast",
+ "webc",
+]
+
+[[package]]
+name = "wasmer-compiler"
+version = "4.2.8"
+dependencies = [
+ "backtrace",
+ "bytes 1.6.0",
+ "cfg-if 1.0.0",
+ "enum-iterator",
+ "enumset",
+ "hashbrown 0.11.2",
+ "lazy_static",
+ "leb128",
+ "memmap2 0.5.10",
+ "more-asserts",
+ "region",
+ "rkyv",
+ "self_cell",
+ "serde",
+ "serde_bytes",
+ "shared-buffer",
+ "smallvec 1.13.2",
+ "thiserror",
+ "wasmer-object",
+ "wasmer-types",
+ "wasmer-vm",
+ "wasmparser 0.121.2",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "wasmer-compiler-cli"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "bytesize",
+ "cfg-if 1.0.0",
+ "clap",
+ "colored 2.1.0",
+ "distance",
+ "fern",
+ "is-terminal",
+ "log 0.4.21",
+ "target-lexicon 0.12.14",
+ "unix_mode",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-singlepass",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-compiler-cranelift"
+version = "4.2.8"
+dependencies = [
+ "cranelift-codegen",
+ "cranelift-entity",
+ "cranelift-frontend",
+ "gimli 0.26.2",
+ "hashbrown 0.11.2",
+ "lazy_static",
+ "more-asserts",
+ "rayon",
+ "smallvec 1.13.2",
+ "target-lexicon 0.12.14",
+ "tracing",
+ "wasmer-compiler",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-compiler-llvm"
+version = "4.2.8"
+dependencies = [
+ "byteorder",
+ "cc",
+ "inkwell",
+ "itertools 0.10.5",
+ "lazy_static",
+ "libc",
+ "object 0.28.4",
+ "rayon",
+ "regex",
+ "rustc_version 0.4.0",
+ "semver 1.0.22",
+ "smallvec 1.13.2",
+ "target-lexicon 0.12.14",
+ "wasmer-compiler",
+ "wasmer-types",
+ "wasmer-vm",
+]
+
+[[package]]
+name = "wasmer-compiler-singlepass"
+version = "4.2.8"
+dependencies = [
+ "byteorder",
+ "dynasm",
+ "dynasmrt",
+ "enumset",
+ "gimli 0.26.2",
+ "hashbrown 0.11.2",
+ "lazy_static",
+ "more-asserts",
+ "rayon",
+ "smallvec 1.13.2",
+ "target-lexicon 0.12.14",
+ "wasmer-compiler",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-derive"
+version = "4.2.8"
+dependencies = [
+ "compiletest_rs",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-emscripten"
+version = "4.2.8"
+dependencies = [
+ "byteorder",
+ "getrandom",
+ "lazy_static",
+ "libc",
+ "log 0.4.21",
+ "time 0.3.34",
+ "wasmer",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-inline-c"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c4e7a2a3363ceeb2ee60371af9460748f2bf53569b58627f1f640284ab07778"
+dependencies = [
+ "assert_cmd 1.0.8",
+ "cc",
+ "lazy_static",
+ "predicates 2.1.5",
+ "regex",
+ "rustc_version 0.3.3",
+ "target-lexicon 0.11.2",
+ "tempfile",
+ "wasmer-inline-c-macro",
+]
+
+[[package]]
+name = "wasmer-inline-c-macro"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058581df4116836c51906e346d6f49ad1b1de0129243fba6b1e1d3c206cd36d1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version 0.3.3",
+]
+
+[[package]]
+name = "wasmer-integration-tests-cli"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "assert_cmd 2.0.14",
+ "derivative",
+ "dirs",
+ "flate2",
+ "futures 0.3.30",
+ "hex",
+ "insta",
+ "libc",
+ "md5",
+ "object 0.30.4",
+ "once_cell",
+ "predicates 2.1.5",
+ "pretty_assertions",
+ "rand",
+ "regex",
+ "reqwest",
+ "serde",
+ "tar",
+ "target-lexicon 0.12.14",
+ "tempfile",
+ "tokio 1.37.0",
+ "wasmer-registry",
+]
+
+[[package]]
+name = "wasmer-integration-tests-ios"
+version = "4.2.8"
+
+[[package]]
+name = "wasmer-journal"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "base64 0.21.7",
+ "bincode",
+ "bytecheck",
+ "bytes 1.6.0",
+ "derivative",
+ "lz4_flex",
+ "num_enum",
+ "rkyv",
+ "serde",
+ "serde_json",
+ "shared-buffer",
+ "tempfile",
+ "thiserror",
+ "tracing",
+ "tracing-test",
+ "virtual-fs",
+ "virtual-net",
+ "wasmer",
+ "wasmer-wasix-types",
+]
+
+[[package]]
+name = "wasmer-middlewares"
+version = "4.2.8"
+dependencies = [
+ "wasmer",
+ "wasmer-types",
+ "wasmer-vm",
+]
+
+[[package]]
+name = "wasmer-object"
+version = "4.2.8"
+dependencies = [
+ "object 0.29.0",
+ "thiserror",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-registry"
+version = "5.10.4"
+dependencies = [
+ "anyhow",
+ "clap",
+ "console",
+ "dialoguer",
+ "dirs",
+ "filetime",
+ "flate2",
+ "futures 0.3.30",
+ "futures-util",
+ "graphql-ws-client",
+ "graphql_client",
+ "hex",
+ "indexmap 1.9.3",
+ "indicatif",
+ "lazy_static",
+ "log 0.4.21",
+ "lzma-rs",
+ "minisign",
+ "pretty_assertions",
+ "regex",
+ "reqwest",
+ "rpassword",
+ "rusqlite",
+ "semver 1.0.22",
+ "serde",
+ "serde_json",
+ "tar",
+ "tempfile",
+ "thiserror",
+ "time 0.3.34",
+ "tldextract",
+ "tokio 1.37.0",
+ "tokio-tungstenite",
+ "toml 0.5.11",
+ "tracing",
+ "url",
+ "wasmer-toml",
+ "wasmer-wasm-interface",
+ "wasmparser 0.121.2",
+ "whoami",
+]
+
+[[package]]
+name = "wasmer-sys-utils"
+version = "0.18.3"
+dependencies = [
+ "libc",
+ "region",
+ "tracing",
+ "tracing-subscriber",
+ "wasmer",
+ "wasmer-types",
+ "wasmer-vm",
+ "wasmer-wasix",
+]
+
+[[package]]
+name = "wasmer-toml"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d21472954ee9443235ca32522b17fc8f0fe58e2174556266a0d9766db055cc52"
+dependencies = [
+ "anyhow",
+ "derive_builder",
+ "indexmap 2.2.6",
+ "semver 1.0.22",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "serde_yaml 0.9.34+deprecated",
+ "thiserror",
+ "toml 0.8.12",
+]
+
+[[package]]
+name = "wasmer-types"
+version = "4.2.8"
+dependencies = [
+ "bytecheck",
+ "enum-iterator",
+ "enumset",
+ "indexmap 1.9.3",
+ "memoffset 0.9.1",
+ "more-asserts",
+ "rkyv",
+ "serde",
+ "serde_bytes",
+ "target-lexicon 0.12.14",
+ "thiserror",
+]
+
+[[package]]
+name = "wasmer-vm"
+version = "4.2.8"
+dependencies = [
+ "backtrace",
+ "cc",
+ "cfg-if 1.0.0",
+ "corosensei",
+ "crossbeam-queue 0.3.11",
+ "dashmap",
+ "derivative",
+ "enum-iterator",
+ "fnv",
+ "indexmap 1.9.3",
+ "lazy_static",
+ "libc",
+ "mach",
+ "memoffset 0.9.1",
+ "more-asserts",
+ "region",
+ "scopeguard",
+ "serde",
+ "thiserror",
+ "tracing",
+ "wasmer-types",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "wasmer-wasix"
+version = "0.18.3"
+dependencies = [
+ "anyhow",
+ "async-trait",
+ "base64 0.21.7",
+ "bincode",
+ "blake3",
+ "bytecheck",
+ "bytes 1.6.0",
+ "cfg-if 1.0.0",
+ "chrono",
+ "cooked-waker",
+ "dashmap",
+ "derivative",
+ "futures 0.3.30",
+ "getrandom",
+ "heapless",
+ "hex",
+ "http",
+ "hyper",
+ "js-sys",
+ "lazy_static",
+ "libc",
+ "linked_hash_set",
+ "lz4_flex",
+ "num_enum",
+ "once_cell",
+ "petgraph",
+ "pin-project",
+ "pretty_assertions",
+ "rand",
+ "rayon",
+ "reqwest",
+ "rkyv",
+ "rusty_pool",
+ "semver 1.0.22",
+ "serde",
+ "serde_cbor",
+ "serde_derive",
+ "serde_json",
+ "serde_yaml 0.9.34+deprecated",
+ "sha2",
+ "shared-buffer",
+ "tempfile",
+ "term_size",
+ "termios",
+ "thiserror",
+ "tokio 1.37.0",
+ "tokio-stream",
+ "tower",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+ "tracing-test",
+ "tracing-wasm",
+ "typetag",
+ "url",
+ "urlencoding",
+ "virtual-fs",
+ "virtual-mio",
+ "virtual-net",
+ "waker-fn",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-bindgen-test",
+ "wasmer",
+ "wasmer-emscripten",
+ "wasmer-journal",
+ "wasmer-types",
+ "wasmer-wasix-types",
+ "wcgi",
+ "wcgi-host",
+ "web-sys",
+ "webc",
+ "weezl",
+ "winapi 0.3.9",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "wasmer-wasix-types"
+version = "0.18.3"
+dependencies = [
+ "anyhow",
+ "bitflags 1.3.2",
+ "byteorder",
+ "cfg-if 1.0.0",
+ "num_enum",
+ "pretty_assertions",
+ "serde",
+ "time 0.3.34",
+ "tracing",
+ "wai-bindgen-gen-core",
+ "wai-bindgen-gen-rust",
+ "wai-bindgen-gen-rust-wasm",
+ "wai-bindgen-rust",
+ "wai-parser",
+ "wasmer",
+ "wasmer-derive",
+ "wasmer-types",
+]
+
+[[package]]
+name = "wasmer-wasm-interface"
+version = "4.2.8"
+dependencies = [
+ "bincode",
+ "either",
+ "nom",
+ "serde",
+ "wasmparser 0.121.2",
+ "wat",
+]
+
+[[package]]
+name = "wasmer-wast"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "futures 0.3.30",
+ "serde",
+ "tempfile",
+ "thiserror",
+ "tokio 1.37.0",
+ "virtual-fs",
+ "wasmer",
+ "wasmer-wasix",
+ "wast 38.0.1",
+]
+
+[[package]]
+name = "wasmer-workspace"
+version = "4.2.8"
+dependencies = [
+ "anyhow",
+ "build-deps",
+ "cfg-if 1.0.0",
+ "clap",
+ "clap_builder",
+ "clap_derive",
+ "clap_lex",
+ "compiler-test-derive",
+ "criterion",
+ "crossbeam-queue 0.3.11",
+ "glob",
+ "lazy_static",
+ "rustc_version 0.4.0",
+ "serial_test",
+ "tempfile",
+ "test-generator",
+ "test-log",
+ "tokio 1.37.0",
+ "tracing",
+ "tracing-subscriber",
+ "ureq",
+ "wasi-test-generator",
+ "wasmer",
+ "wasmer-cache",
+ "wasmer-compiler",
+ "wasmer-compiler-cranelift",
+ "wasmer-compiler-llvm",
+ "wasmer-compiler-singlepass",
+ "wasmer-emscripten",
+ "wasmer-middlewares",
+ "wasmer-types",
+ "wasmer-wasix",
+ "wasmer-wast",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.95.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2ea896273ea99b15132414be1da01ab0d8836415083298ecaffbe308eaac87a"
+dependencies = [
+ "indexmap 1.9.3",
+ "url",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.121.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dbe55c8f9d0dbd25d9447a5a889ff90c0cc3feaa7395310d3d826b2c703eaab"
+dependencies = [
+ "bitflags 2.5.0",
+ "indexmap 2.2.6",
+ "semver 1.0.22",
+]
+
+[[package]]
+name = "wasmprinter"
+version = "0.2.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60e73986a6b7fdfedb7c5bf9e7eb71135486507c8fbc4c0c42cffcb6532988b7"
+dependencies = [
+ "anyhow",
+ "wasmparser 0.121.2",
+]
+
+[[package]]
+name = "wast"
+version = "24.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ff1e3bd3ad0b2ee7784add89c30dc96b89a54b43e5d6d95d774eda1863b3500"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wast"
+version = "38.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae0d7b256bef26c898fa7344a2d627e8499f5a749432ce0a05eae1a64ff0c271"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "wast"
+version = "64.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a259b226fd6910225aa7baeba82f9d9933b6d00f2ce1b49b80fa4214328237cc"
+dependencies = [
+ "leb128",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder 0.32.0",
+]
+
+[[package]]
+name = "wat"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53253d920ab413fca1c7dc2161d601c79b4fdf631d0ba51dd4343bf9b556c3f6"
+dependencies = [
+ "wast 64.0.0",
+]
+
+[[package]]
+name = "wcgi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39ca8f334eec3a8197bd25a612c74f415b8691d219ee11f1acd20f15a3e2bf77"
+dependencies = [
+ "http",
+ "http-serde",
+ "serde",
+ "serde_json",
+ "url",
+]
+
+[[package]]
+name = "wcgi-host"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a762cf2b0ed389a2a2fb591d63a398c1a4c0f8bef938cfd040285a3c63b695cc"
+dependencies = [
+ "http",
+ "schemars",
+ "serde",
+ "tokio 1.37.0",
+ "wasmparser 0.95.0",
+ "wcgi",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webc"
+version = "5.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "973ca5a91b4fb3e4bb37cfebe03ef9364d0aff2765256abefdb7e79dc9188483"
+dependencies = [
+ "anyhow",
+ "base64 0.21.7",
+ "byteorder",
+ "bytes 1.6.0",
+ "flate2",
+ "indexmap 1.9.3",
+ "leb128",
+ "lexical-sort",
+ "once_cell",
+ "path-clean",
+ "rand",
+ "semver 1.0.22",
+ "serde",
+ "serde_cbor",
+ "serde_json",
+ "sha2",
+ "shared-buffer",
+ "tar",
+ "tempfile",
+ "thiserror",
+ "toml 0.7.8",
+ "url",
+ "walkdir",
+ "wasmer-toml",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.25.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3de34ae270483955a94f4b21bdaaeb83d508bb84a01435f393818edb0012009"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"
+
+[[package]]
+name = "whoami"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
+dependencies = [
+ "redox_syscall 0.4.1",
+ "wasite",
+ "web-sys",
+]
+
+[[package]]
+name = "winapi"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-build"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.4",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75"
+dependencies = [
+ "windows_aarch64_msvc 0.33.0",
+ "windows_i686_gnu 0.33.0",
+ "windows_i686_msvc 0.33.0",
+ "windows_x86_64_gnu 0.33.0",
+ "windows_x86_64_msvc 0.33.0",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.4",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.4",
+ "windows_aarch64_msvc 0.52.4",
+ "windows_i686_gnu 0.52.4",
+ "windows_i686_msvc 0.52.4",
+ "windows_x86_64_gnu 0.52.4",
+ "windows_x86_64_gnullvm 0.52.4",
+ "windows_x86_64_msvc 0.52.4",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dffa400e67ed5a4dd237983829e66475f0a4a26938c4b04c21baede6262215b8"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if 1.0.0",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "ws2_32-sys"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
+dependencies = [
+ "winapi 0.2.8",
+ "winapi-build",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "xattr"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
+dependencies = [
+ "libc",
+ "linux-raw-sys",
+ "rustix",
+]
+
+[[package]]
+name = "xxhash-rust"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03"
+
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
+
+[[package]]
+name = "yansi"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.58",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
diff --git a/arbitrator/tools/module_roots/wasmer/Cargo.toml b/arbitrator/tools/module_roots/wasmer/Cargo.toml
new file mode 100644
index 0000000..c5edd62
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/Cargo.toml
@@ -0,0 +1,330 @@
+[package]
+name = "wasmer-workspace"
+description = "Wasmer workspace"
+publish = false
+autoexamples = false
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer = { version = "=4.2.8", path = "lib/api", default-features = false }
+wasmer-compiler = { version = "=4.2.8", path = "lib/compiler", features = [
+    "compiler",
+], optional = true }
+wasmer-compiler-cranelift = { version = "=4.2.8", path = "lib/compiler-cranelift", optional = true }
+wasmer-compiler-singlepass = { version = "=4.2.8", path = "lib/compiler-singlepass", optional = true }
+wasmer-compiler-llvm = { version = "=4.2.8", path = "lib/compiler-llvm", optional = true }
+wasmer-emscripten = { version = "=4.2.8", path = "lib/emscripten", optional = true }
+wasmer-wasix = { version = "0.18.3", path = "lib/wasix", optional = true }
+wasmer-wast = { version = "=4.2.8", path = "tests/lib/wast", optional = true }
+wasi-test-generator = { version = "=4.2.8", path = "tests/wasi-wast", optional = true }
+wasmer-cache = { version = "=4.2.8", path = "lib/cache", optional = true }
+wasmer-types = { version = "=4.2.8", path = "lib/types" }
+wasmer-middlewares = { version = "=4.2.8", path = "lib/middlewares", optional = true }
+cfg-if = "1.0"
+tokio = { version = "1", features = [
+    "rt",
+    "rt-multi-thread",
+    "macros",
+], optional = true }
+crossbeam-queue = "0.3.8"
+
+[workspace]
+members = [
+    "fuzz",
+    "lib/api",
+    "lib/api/macro-wasmer-universal-test",
+    "lib/backend-api",
+    "lib/c-api",
+    "lib/c-api/examples/wasmer-capi-examples-runner",
+    "lib/c-api/tests/wasmer-c-api-test-runner",
+    "lib/cache",
+    "lib/cli-compiler",
+    "lib/cli",
+    "lib/compiler-cranelift",
+    "lib/compiler-llvm",
+    "lib/compiler-singlepass",
+    "lib/compiler",
+    "lib/derive",
+    "lib/emscripten",
+    "lib/object",
+    "lib/registry",
+    "lib/sys-utils",
+    "lib/types",
+    "lib/virtual-io",
+    "lib/virtual-fs",
+    "lib/virtual-net",
+    "lib/vm",
+    "lib/wai-bindgen-wasmer",
+    "lib/wasi-types",
+    "lib/wasix",
+    "lib/wasm-interface",
+    "lib/journal",
+    "tests/integration/cli",
+    "tests/integration/ios",
+    "tests/lib/compiler-test-derive",
+    "tests/lib/wast",
+    "tests/wasi-wast",
+    "tests/wasmer-argus",
+]
+resolver = "2"
+
+[workspace.package]
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2021"
+homepage = "https://wasmer.io/"
+license = "MIT"
+repository = "https://github.com/wasmerio/wasmer"
+rust-version = "1.73"
+version = "4.2.8"
+
+[workspace.dependencies]
+enumset = "1.1.0"
+memoffset = "0.9.0"
+wasmer-toml = "0.9.2"
+wasmparser = { version = "0.121.0", default-features = false }
+webc = { version = "5.8.0", default-features = false, features = ["package"] }
+shared-buffer = "0.1.4"
+rkyv = { version = "0.7.40", features = ["indexmap", "validation", "strict"] }
+memmap2 = { version = "0.6.2" }
+edge-schema = { version = "=0.1.0" }
+
+[build-dependencies]
+test-generator = { path = "tests/lib/test-generator" }
+build-deps = "0.1.4"
+anyhow = "1.0"
+glob = "0.3"
+rustc_version = "0.4"
+
+[dev-dependencies]
+wasmer = { version = "=4.2.8", path = "lib/api", features = [
+    "compiler",
+    "singlepass",
+    "sys",
+] }
+anyhow = "1.0"
+criterion = { version = "0.5", default-features = false }
+clap = { version = "=4.4.11" }
+clap_builder = { version = "=4.4.11" }
+clap_derive = { version = "=4.4.7" }
+clap_lex = { version = "=0.6.0" }
+lazy_static = "1.4"
+serial_test = { version = "2.0", default-features = false }
+compiler-test-derive = { path = "tests/lib/compiler-test-derive" }
+tempfile = "3.6.0"
+ureq = "2.6"
+# For logging tests using the `RUST_LOG=debug` when testing
+test-log = { version = "0.2", default-features = false, features = ["trace"] }
+tracing = { version = "0.1", default-features = false, features = ["log"] }
+tracing-subscriber = { version = "0.3", default-features = false, features = [
+    "env-filter",
+    "fmt",
+] }
+
+[features]
+# Don't add the compiler features in default, please add them on the Makefile
+# since we might want to autoconfigure them depending on the availability on the host.
+default = ["wat", "wast", "cache", "wasi", "engine", "emscripten", "middlewares"]
+# backend means that the `wasmer` crate will be compiled with the `wasmer-compiler` or the `jsc`.
+# That means: that is able to execute modules
+backend = []
+jsc = ["wasmer/jsc", "backend", "wat", "wasmer/std"]
+engine = ["universal"]
+universal = []
+cache = ["wasmer-cache"]
+wast = ["wasmer-wast"]
+wasi = ["wasmer-wasix"]
+emscripten = ["wasmer-emscripten"]
+wat = ["wasmer/wat"]
+compiler = ["wasmer/compiler", "backend", "wasmer-compiler/translator"]
+singlepass = ["compiler", "wasmer-compiler-singlepass", "wasmer/singlepass"]
+cranelift = ["compiler", "wasmer-compiler-cranelift", "wasmer/cranelift"]
+llvm = ["compiler", "wasmer-compiler-llvm", "wasmer/llvm"]
+middlewares = ["wasmer-middlewares"]
+wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
+wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
+static-artifact-load = ["wasmer-compiler/static-artifact-load"]
+static-artifact-create = ["wasmer-compiler/static-artifact-create"]
+
+# Testing features
+test-singlepass = ["singlepass"]
+test-cranelift = ["cranelift"]
+test-llvm = ["llvm"]
+
+test-universal = ["test-generator/test-universal"]
+
+# Specifies that we're running in coverage testing mode. This disables tests
+# that raise signals because that interferes with tarpaulin.
+coverage = []
+
+#[profile.release]
+#debug = true
+
+# Enable optimizations for a few crates, even for debug builds.
+# This greatly speeds up using debug builds, because these crates are extremely
+# slow without optimizations.
+[profile.dev.package.cranelift-codegen]
+opt-level = 3
+[profile.dev.package.regalloc2]
+opt-level = 3
+[profile.dev.package.wasmparser]
+opt-level = 3
+[profile.dev.package.rkyv]
+opt-level = 3
+[profile.dev.package.wasmer-types]
+opt-level = 3
+[profile.dev.package.weezl]
+opt-level = 3
+[profile.dev.package.sha2]
+opt-level = 3
+[profile.dev.package.digest]
+opt-level = 3
+
+[[bench]]
+name = "static_and_dynamic_functions"
+harness = false
+
+[[example]]
+name = "early-exit"
+path = "examples/early_exit.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "engine"
+path = "examples/engine.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "engine-headless"
+path = "examples/engine_headless.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "platform-headless-ios"
+path = "examples/platform_ios_headless.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "cross-compilation"
+path = "examples/engine_cross_compilation.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "compiler-singlepass"
+path = "examples/compiler_singlepass.rs"
+required-features = ["singlepass"]
+
+[[example]]
+name = "compiler-cranelift"
+path = "examples/compiler_cranelift.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "compiler-llvm"
+path = "examples/compiler_llvm.rs"
+required-features = ["llvm"]
+
+[[example]]
+name = "exported-function"
+path = "examples/exports_function.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "exported-global"
+path = "examples/exports_global.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "exported-memory"
+path = "examples/exports_memory.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "imported-function"
+path = "examples/imports_function.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "imported-global"
+path = "examples/imports_global.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "tunables-limit-memory"
+path = "examples/tunables_limit_memory.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "wasi"
+path = "examples/wasi.rs"
+required-features = ["backend", "wasi"]
+
+[[example]]
+name = "wasi-manual-setup"
+path = "examples/wasi_manual_setup.rs"
+required-features = ["tokio", "backend", "wasi"]
+
+[[example]]
+name = "wasi-pipes"
+path = "examples/wasi_pipes.rs"
+required-features = ["tokio", "backend", "wasi"]
+
+[[example]]
+name = "table"
+path = "examples/table.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "memory"
+path = "examples/memory.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "instance"
+path = "examples/instance.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "errors"
+path = "examples/errors.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "imported-function-env"
+path = "examples/imports_function_env.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "imported-function-env-global"
+path = "examples/imports_function_env_global.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "hello-world"
+path = "examples/hello_world.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "metering"
+path = "examples/metering.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "imports-exports"
+path = "examples/imports_exports.rs"
+required-features = ["backend"]
+
+[[example]]
+name = "features"
+path = "examples/features.rs"
+required-features = ["cranelift"]
+
+[[example]]
+name = "http-dynamic-size"
+path = "examples/http_dynamic_size.rs"
+required-features = ["cranelift"]
diff --git a/arbitrator/tools/module_roots/wasmer/LICENSE b/arbitrator/tools/module_roots/wasmer/LICENSE
new file mode 100644
index 0000000..62bb543
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present Wasmer, Inc. and its affiliates.
+
+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/arbitrator/tools/module_roots/wasmer/Makefile b/arbitrator/tools/module_roots/wasmer/Makefile
new file mode 100644
index 0000000..9050822
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/Makefile
@@ -0,0 +1,947 @@
+SHELL=/usr/bin/env bash
+
+#####
+#
+# The Matrix
+#
+#####
+
+# The matrix is the product of the following columns:
+#
+# |------------|----------|--------------|-------|
+# | Compiler   ⨯ Platform ⨯ Architecture ⨯ libc  |
+# |------------|----------|--------------|-------|
+# | Cranelift  | Linux    | amd64        | glibc |
+# | LLVM       | Darwin   | aarch64      | musl  |
+# | Singlepass | Windows  | riscv        |       |
+# |------------|----------|--------------|-------|
+#
+# Here is what works and what doesn't:
+#
+# * Cranelift works everywhere,
+#
+# * LLVM works on Linux+Darwin/`amd64`,
+#   and linux+`aarch64`, linux+`riscv`
+#   but it doesn't work on Darwin/`aarch64` or Windows/`aarch64`.
+#
+# * Singlepass works on Linux+Darwin+Windows/`amd64`,
+#   and Linux+Darwin/`aarch64`
+#   it doesn't work on */`riscv`.
+#
+# * Windows isn't tested on `aarch64`, that's why we consider it's not
+#   working, but it might possibly be.
+# * The Only target for `riscv` familly of processor is the RV64, with the `GC` extensions
+
+
+#####
+#
+# Define the “Platform” and “Architecture” columns of the matrix.
+#
+#####
+
+
+
+IS_DARWIN := 0
+IS_LINUX := 0
+IS_FREEBSD := 0
+IS_WINDOWS := 0
+IS_AMD64 := 0
+IS_AARCH64 := 0
+IS_RISCV64 := 0
+
+# Test Windows apart because it doesn't support `uname -s`.
+ifeq ($(OS), Windows_NT)
+	# We can assume it will likely be in amd64.
+	IS_AMD64 := 1
+	IS_WINDOWS := 1
+else
+	# Platform
+	uname := $(shell uname -s)
+
+	ifeq ($(uname), Darwin)
+		IS_DARWIN := 1
+	else ifeq ($(uname), Linux)
+		IS_LINUX := 1
+	else ifeq ($(uname), FreeBSD)
+		IS_FREEBSD := 1
+	else
+		# We use spaces instead of tabs to indent `$(error)`
+		# otherwise it's considered as a command outside a
+		# target and it will fail.
+                $(error Unrecognized platform, expect `Darwin`, `Linux` or `Windows_NT`)
+	endif
+
+	# Architecture
+	uname := $(shell uname -m)
+
+	ifneq (, $(filter $(uname), x86_64 amd64))
+		IS_AMD64 := 1
+	else ifneq (, $(filter $(uname), aarch64 arm64))
+		IS_AARCH64 := 1
+	else ifneq (, $(filter $(uname), riscv64))
+		IS_RISCV64 := 1
+	else
+		# We use spaces instead of tabs to indent `$(error)`
+		# otherwise it's considered as a command outside a
+		# target and it will fail.
+                $(error Unrecognized architecture, expect `x86_64`, `aarch64`, `arm64`, 'riscv64')
+	endif
+
+	# Libc
+	LIBC ?= $(shell ldd 2>&1 | grep -o musl | head -n1)
+endif
+
+
+#####
+#
+# Define the “Compiler” column of the matrix.
+#
+#####
+
+CARGO_BINARY ?= cargo
+CARGO_TARGET ?=
+CARGO_TARGET_FLAG ?=
+
+ifneq ($(CARGO_TARGET),)
+CARGO_TARGET_FLAG := --target $(CARGO_TARGET)
+endif
+
+# Variables that can be overridden by the users to force to enable or
+# to disable a specific compiler.
+ENABLE_CRANELIFT ?=
+ENABLE_LLVM ?=
+ENABLE_SINGLEPASS ?=
+
+# Which compilers we build. These have dependencies that may not be on the system.
+compilers :=
+
+##
+# Cranelift
+##
+
+# If the user didn't disable the Cranelift compiler…
+ifneq ($(ENABLE_CRANELIFT), 0)
+        # … then maybe the user forced to enable the Cranelift compiler.
+        ifeq ($(ENABLE_CRANELIFT), 1)
+                compilers += cranelift
+        # … otherwise, we try to check whether Cranelift works on this host.
+        else
+                compilers += cranelift
+        endif
+endif
+
+ifneq (, $(findstring cranelift,$(compilers)))
+	ENABLE_CRANELIFT := 1
+endif
+
+##
+# LLVM
+##
+
+# If the user didn't disable the LLVM compiler…
+ifeq ($(ENABLE_LLVM), 0)
+	LLVM_VERSION :=
+	# … then maybe the user forced to enable the LLVM compiler.
+else ifeq ($(ENABLE_LLVM), 1)
+	LLVM_VERSION := $(shell llvm-config --version)
+	compilers += llvm
+	# … or try to autodetect LLVM from `llvm-config-<version>`.
+else ifneq (, $(shell which llvm-config-15 2>/dev/null))
+	LLVM_VERSION := $(shell llvm-config-15 --version)
+	compilers += llvm
+	# need force LLVM_SYS_150_PREFIX, or llvm_sys will not build in the case
+	export LLVM_SYS_150_PREFIX = $(shell llvm-config-15 --prefix)
+else ifneq (, $(shell which llvm-config 2>/dev/null))
+	LLVM_VERSION := $(shell llvm-config --version)
+	ifneq (, $(findstring 15,$(LLVM_VERSION)))
+		compilers += llvm
+		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
+	else ifneq (, $(findstring 14,$(LLVM_VERSION)))
+		compilers += llvm
+		export LLVM_SYS_150_PREFIX = $(shell llvm-config --prefix)
+	endif
+endif
+
+# If findstring is not empty, then it have found the value
+
+exclude_tests := --exclude wasmer-c-api --exclude wasmer-cli --exclude wasmer-compiler-cli
+# We run integration tests separately (it requires building the c-api)
+exclude_tests += --exclude wasmer-integration-tests-cli
+exclude_tests += --exclude wasmer-integration-tests-ios
+
+ifneq (, $(findstring llvm,$(compilers)))
+	ENABLE_LLVM := 1
+else
+	# We exclude LLVM from our package testing
+	exclude_tests += --exclude wasmer-compiler-llvm
+endif
+
+##
+# Singlepass
+##
+
+# If the user didn't disable the Singlepass compiler…
+ifneq ($(ENABLE_SINGLEPASS), 0)
+	# … then maybe the user forced to enable the Singlepass compiler.
+	ifeq ($(ENABLE_SINGLEPASS), 1)
+		compilers += singlepass
+	# … otherwise, we try to check whether Singlepass works on this host.
+	else ifneq (, $(filter 1, $(IS_DARWIN) $(IS_LINUX) $(IS_FREEBSD) $(IS_WINDOWS)))
+		ifeq ($(IS_AMD64), 1)
+			compilers += singlepass
+		endif
+		ifeq ($(IS_AARCH64), 1)
+			ifneq ($(IS_WINDOWS), 1)
+				compilers += singlepass
+			endif
+		endif
+	endif
+endif
+
+ifneq (, $(findstring singlepass,$(compilers)))
+	ENABLE_SINGLEPASS := 1
+endif
+
+##
+# Clean the `compilers` variable.
+##
+
+compilers := $(strip $(compilers))
+
+
+#####
+#
+# Define the “Engine” column of the matrix.
+#
+#####
+
+
+# The engine is part of a pair of kind (compiler, engine). All the
+# pairs are stored in the `compilers_engines` variable.
+compilers_engines :=
+
+##
+# The Cranelift case.
+##
+
+ifeq ($(ENABLE_CRANELIFT), 1)
+	compilers_engines += cranelift-universal
+endif
+
+##
+# The LLVM case.
+##
+
+ifeq ($(ENABLE_LLVM), 1)
+	ifneq (, $(filter 1, $(IS_WINDOWS) $(IS_DARWIN) $(IS_LINUX) $(IS_FREEBSD)))
+		ifeq ($(IS_AMD64), 1)
+			compilers_engines += llvm-universal
+		else ifeq ($(IS_AARCH64), 1)
+			compilers_engines += llvm-universal
+		else ifeq ($(IS_RISCV64), 1)
+			compilers_engines += llvm-universal
+		endif
+	endif
+endif
+
+##
+# The Singlepass case.
+##
+
+ifeq ($(ENABLE_SINGLEPASS), 1)
+	ifneq (, $(filter 1, $(IS_WINDOWS) $(IS_DARWIN) $(IS_LINUX) $(IS_FREEBSD)))
+		ifeq ($(IS_AMD64), 1)
+			compilers_engines += singlepass-universal
+		endif
+		ifeq ($(IS_AARCH64), 1)
+			compilers_engines += singlepass-universal
+		endif
+	endif
+endif
+
+# Clean the `compilers_engines` variable.
+compilers_engines := $(strip $(compilers_engines))
+
+
+#####
+#
+# Cargo features.
+#
+#####
+
+# Small trick to define a space and a comma.
+space := $() $()
+comma := ,
+
+# Define the compiler Cargo features for all crates.
+compiler_features := --features $(subst $(space),$(comma),$(compilers)),wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load
+capi_compilers_engines_exclude :=
+
+# Define the compiler Cargo features for the C API. It always excludes
+# LLVM for the moment because it causes the linker to fail since LLVM is not statically linked.
+# TODO: Reenable LLVM in C-API
+capi_compiler_features := --features $(subst $(space),$(comma),$(filter-out llvm, $(compilers))),wasmer-artifact-create,static-artifact-create,wasmer-artifact-load,static-artifact-load
+capi_compilers_engines_exclude += llvm-universal
+
+# We exclude singlepass-universal because it doesn't support multivalue (required in wasm-c-api tests)
+capi_compilers_engines_exclude += singlepass-universal
+
+capi_compilers_engines := $(filter-out $(capi_compilers_engines_exclude),$(compilers_engines))
+
+#####
+#
+# Display information.
+#
+#####
+
+ifneq (, $(filter 1, $(IS_DARWIN) $(IS_LINUX) $(IS_FREEBSD)))
+	bold := $(shell tput bold 2>/dev/null || echo -n '')
+	green := $(shell tput setaf 2 2>/dev/null || echo -n '')
+	yellow := $(shell tput setaf 3 2>/dev/null || echo -n '')
+	reset := $(shell tput sgr0 2>/dev/null || echo -n '')
+endif
+
+HOST_TARGET=$(shell rustc -Vv | grep 'host: ' | cut -d':' -f2 | tr -d ' ')
+
+TARGET_DIR ?= target/release
+
+ifneq (, $(TARGET))
+	TARGET_DIR ?= target/$(TARGET)/release
+endif
+
+$(info -----------)
+$(info $(bold)$(green)INFORMATION$(reset))
+$(info -----------)
+$(info )
+$(info Host Target: `$(bold)$(green)$(HOST_TARGET)$(reset)`.)
+ifneq (, $(TARGET))
+	# We use spaces instead of tabs to indent `$(info)`
+	# otherwise it's considered as a command outside a
+	# target and it will fail.
+        $(info Build Target: $(bold)$(green)$(TARGET)$(reset) $(yellow)($(TARGET_DIR))$(reset))
+endif
+ifneq (, $(LIBC))
+	# We use spaces instead of tabs to indent `$(info)`
+	# otherwise it's considered as a command outside a
+	# target and it will fail.
+        $(info C standard library: $(bold)$(green)$(LIBC)$(reset))
+endif
+$(info Enabled Compilers: $(bold)$(green)$(subst $(space),$(reset)$(comma)$(space)$(bold)$(green),$(compilers))$(reset).)
+$(info Testing the following compilers & engines:)
+$(info   * API: $(bold)$(green)${compilers_engines}$(reset),)
+$(info   * C-API: $(bold)$(green)${capi_compilers_engines}$(reset).)
+$(info Cargo features:)
+$(info   * Compilers: `$(bold)$(green)${compiler_features}$(reset)`.)
+$(info Rust version: $(bold)$(green)$(shell rustc --version)$(reset).)
+$(info NodeJS version: $(bold)$(green)$(shell node --version)$(reset).)
+ifeq ($(ENABLE_LLVM), 1)
+        $(info LLVM version: $(bold)$(green)${LLVM_VERSION}$(reset).)
+endif
+$(info )
+$(info )
+$(info --------------)
+$(info $(bold)$(green)RULE EXECUTION$(reset))
+$(info --------------)
+$(info )
+$(info )
+
+#####
+#
+# Configure `sed -i` for a cross-platform usage.
+#
+#####
+
+SEDI ?=
+
+ifeq ($(IS_DARWIN), 1)
+	SEDI := "-i ''"
+else ifeq ($(IS_FREEBSD), 1)
+	SEDI := "-i ''"
+else ifeq ($(IS_LINUX), 1)
+	SEDI := "-i"
+endif
+
+#####
+#
+# Building.
+#
+#####
+
+# Not really "all", just the default target that builds enough so make
+# install will go through.
+all: build-wasmer build-capi build-capi-headless
+
+check: check-wasmer check-wasmer-wasm check-capi
+
+check-wasmer:
+	$(CARGO_BINARY) check $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
+
+check-wasmer-wasm:
+	$(CARGO_BINARY) check --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasi --features singlepass,cranelift --bin wasmer-compiler --locked
+
+check-capi:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) check $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml  \
+		--no-default-features --features wat,compiler,wasi,middlewares $(capi_compiler_features)
+
+
+build-wasmer:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
+
+build-wasmer-jsc:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --release --manifest-path lib/cli/Cargo.toml --no-default-features --features="jsc,wat" --bin wasmer --locked
+
+build-wasmer-debug:
+	$(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --bin wasmer --locked
+
+bench:
+	$(CARGO_BINARY) bench $(CARGO_TARGET_FLAG) $(compiler_features)
+
+build-wasmer-wasm:
+	$(CARGO_BINARY) build --release --manifest-path lib/cli-compiler/Cargo.toml --target wasm32-wasi --features singlepass,cranelift --bin wasmer-compiler --locked
+
+# For best results ensure the release profile looks like the following
+# in Cargo.toml:
+# [profile.release]
+# opt-level = 'z'
+# debug = false
+# debug-assertions = false
+# overflow-checks = false
+# lto = true
+# panic = 'abort'
+# incremental = false
+# codegen-units = 1
+# rpath = false
+build-wasmer-headless-minimal: RUSTFLAGS += -C panic=abort
+build-wasmer-headless-minimal:
+	RUSTFLAGS="${RUSTFLAGS}" xargo build --target $(HOST_TARGET) --release --manifest-path=lib/cli/Cargo.toml --no-default-features --features sys,headless-minimal --bin wasmer-headless
+ifeq ($(IS_DARWIN), 1)
+	strip target/$(HOST_TARGET)/release/wasmer-headless
+else ifeq ($(IS_WINDOWS), 1)
+	strip --strip-unneeded target/$(HOST_TARGET)/release/wasmer-headless.exe
+else
+	strip --strip-unneeded target/$(HOST_TARGET)/release/wasmer-headless
+endif
+
+build-docs:
+	$(CARGO_BINARY) doc $(CARGO_TARGET_FLAG) --release $(compiler_features) --document-private-items --no-deps --workspace --exclude wasmer-c-api --locked
+
+# The tokio crate was excluded from the docs build because the code (which is not under our control)
+# does not currently compile its docs successfully
+#
+# ```
+# error[E0432]: unresolved import `self::doc::os`
+#    --> /home/runner/.cargo/registry/src/github.com-1ecc6299db9ec823/tokio-1.35.1/src/lib.rs:636:16
+#     |
+# 636 | pub(crate) use self::doc::os;
+#     |                ^^^^^^^^^^^^^ no `os` in `doc`
+# ```
+test-build-docs-rs:
+	@manifest_docs_rs_features_path="package.metadata.docs.rs.features"; \
+	for manifest_path in lib/*/Cargo.toml; do \
+		toml get "$$manifest_path" "$$manifest_docs_rs_features_path" >/dev/null 2>&1; \
+		if [ $$? -ne 0 ]; then \
+			features=""; \
+		else \
+			features=$$(toml get "$$manifest_path" "$$manifest_docs_rs_features_path" | sed 's/\[//; s/\]//; s/"\([^"]*\)"/\1/g'); \
+		fi; \
+		printf "*** Building doc for package with manifest $$manifest_path ***\n\n"; \
+
+		if [ -z "$$features" ]; then \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --exclude tokio --locked || exit 1; \
+		else \
+			printf "Following features are inferred from Cargo.toml: $$features\n\n\n"; \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --exclude tokio --features "$$features" --locked || exit 1; \
+		fi; \
+	done
+
+test-build-docs-rs-ci:
+	@manifest_docs_rs_features_path="package.metadata.docs.rs.features"; \
+	for manifest_path in lib/*/Cargo.toml; do \
+		toml get "$$manifest_path" "$$manifest_docs_rs_features_path" >/dev/null 2>&1; \
+		if [ $$? -ne 0 ]; then \
+			features=""; \
+		else \
+			features=$$(toml get "$$manifest_path" "$$manifest_docs_rs_features_path" | sed 's/\[//; s/\]//; s/"\([^"]*\)"/\1/g'); \
+		fi; \
+		printf "*** Building doc for package with manifest $$manifest_path ***\n\n"; \
+		if [ -z "$$features" ]; then \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2023-10-05  doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --locked || exit 1; \
+		else \
+			printf "Following features are inferred from Cargo.toml: $$features\n\n\n"; \
+			RUSTDOCFLAGS="--cfg=docsrs" $(CARGO_BINARY) +nightly-2023-10-05 doc $(CARGO_TARGET_FLAG) --manifest-path "$$manifest_path" --no-deps --features "$$features" --locked || exit 1; \
+		fi; \
+	done
+
+build-docs-capi:
+	# `wasmer-c-api` lib's name is `wasmer`. To avoid a conflict
+	# when generating the documentation, we rename it to its
+	# crate's name. Then we restore the lib's name.
+	sed "$(SEDI)"  -e 's/name = "wasmer" # ##lib.name##/name = "wasmer_c_api" # ##lib.name##/' lib/c-api/Cargo.toml
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) doc $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --no-deps --features wat,compiler,cranelift,wasi --locked
+	sed "$(SEDI)"  -e 's/name = "wasmer_c_api" # ##lib.name##/name = "wasmer" # ##lib.name##/' lib/c-api/Cargo.toml
+
+build-capi:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,wasi,middlewares,webc_runner $(capi_compiler_features) --locked
+
+build-capi-singlepass:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,singlepass,wasi,middlewares,webc_runner --locked
+
+build-capi-singlepass-universal:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,singlepass,wasi,middlewares,webc_runner --locked
+
+build-capi-cranelift:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,cranelift,wasi,middlewares,webc_runner --locked
+
+build-capi-cranelift-universal:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,cranelift,wasi,middlewares,webc_runner --locked
+
+build-capi-llvm:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,llvm,wasi,middlewares,webc_runner --locked
+
+build-capi-llvm-universal:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,llvm,wasi,middlewares,webc_runner --locked
+
+build-capi-jsc:
+	RUSTFLAGS="${RUSTFLAGS}" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,jsc,wasi --locked
+
+# Headless (we include the minimal to be able to run)
+
+build-capi-headless:
+ifeq ($(CARGO_TARGET_FLAG),)
+	RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build --target $(HOST_TARGET) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner  --target-dir target/headless --locked
+else
+	RUSTFLAGS="${RUSTFLAGS} -C panic=abort -C link-dead-code -C lto -O -C embed-bitcode=yes" $(CARGO_BINARY) build $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner --target-dir target/headless --locked
+endif
+
+build-capi-headless-ios:
+	RUSTFLAGS="${RUSTFLAGS} -C panic=abort" cargo lipo --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features compiler-headless,wasi,webc_runner --target-dir target/$(CARGO_TARGET)/headless
+
+#####
+#
+# Testing.
+#
+#####
+
+# test compilers
+test-stage-0-wast:
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --release $(compiler_features) --locked
+
+# test packages
+test-stage-1-test-all:
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked
+	$(CARGO_BINARY) test --doc $(CARGO_TARGET_FLAG) --workspace --release $(exclude_tests) --exclude wasmer-c-api-test-runner --exclude wasmer-capi-examples-runner $(compiler_features) --locked
+test-stage-2-test-compiler-cranelift-nostd:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/compiler-cranelift/Cargo.toml --release --no-default-features --features=std --locked
+test-stage-3-test-compiler-singlepass-nostd:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/compiler-singlepass/Cargo.toml --release --no-default-features --features=std --locked
+test-stage-4-wasmer-cli:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/virtual-fs/Cargo.toml --release --locked
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/cli/Cargo.toml $(compiler_features) --release --locked
+
+# test examples
+test-stage-5-test-examples:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) $(compiler_features) --features wasi --examples --locked
+test-stage-6-test-examples-release:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release $(compiler_features) --features wasi --examples --locked
+
+test-stage-7-capi-integration-tests:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-c-api-test-runner --locked
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --package wasmer-capi-examples-runner --locked
+
+test: test-compilers test-packages test-examples
+
+test-compilers: test-stage-0-wast
+
+test-packages: test-stage-1-test-all test-stage-2-test-compiler-cranelift-nostd test-stage-3-test-compiler-singlepass-nostd test-stage-4-wasmer-cli
+
+test-examples: test-stage-5-test-examples test-stage-6-test-examples-release
+
+test-js: test-js-api test-js-wasi
+
+# TODO: disabled because the no-std / core feature doesn't actually work at the moment.
+# See https://github.com/wasmerio/wasmer/issues/3429
+# test-js-core:
+# 	cd lib/api && wasm-pack test --node -- --no-default-features --features js,core,wasm-types-polyfill,wat
+
+test-js-api:
+	cd lib/api && wasm-pack test --node -- --no-default-features --features js-default,wat
+
+test-js-wasi:
+	cd lib/wasix && wasm-pack test --node -- --no-default-features --features test-js,wasmer/js,wasmer/std
+
+#####
+#
+# Testing compilers.
+#
+#####
+
+test-compilers-compat: $(foreach compiler,$(compilers),test-$(compiler))
+
+test-singlepass-universal:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --tests $(compiler_features) --locked -- singlepass::universal
+
+test-cranelift-universal:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --tests $(compiler_features) --locked -- cranelift::universal
+
+test-llvm-universal:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --tests $(compiler_features) --locked -- llvm::universal
+
+test-singlepass: $(foreach singlepass_engine,$(filter singlepass-%,$(compilers_engines)),test-$(singlepass_engine))
+
+test-cranelift: $(foreach cranelift_engine,$(filter cranelift-%,$(compilers_engines)),test-$(cranelift_engine))
+
+test-llvm: $(foreach llvm_engine,$(filter llvm-%,$(compilers_engines)),test-$(llvm_engine))
+
+# same as test-capi, but without the build-capi step first
+test-capi-ci: $(foreach compiler_engine,$(capi_compilers_engines),test-capi-crate-$(compiler_engine) test-capi-integration-$(compiler_engine))
+
+# This test requires building the capi with all the available
+# compilers first
+test-capi: build-capi package-capi test-capi-ci
+
+test-capi-jsc: build-capi-jsc package-capi test-capi-integration-jsc
+
+test-capi-crate-%:
+	WASMER_CAPI_CONFIG=$(shell echo $@ | sed -e s/test-capi-crate-//) $(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/c-api/Cargo.toml --release \
+		--no-default-features --features wat,compiler,wasi,middlewares,webc_runner $(capi_compiler_features) --locked -- --nocapture
+
+test-capi-integration-%:
+	# note: you need to do make build-capi and make package-capi first!
+	# Test the Wasmer C API tests for C
+	cd lib/c-api/tests; WASMER_CAPI_CONFIG=$(shell echo $@ | sed -e s/test-capi-integration-//) WASMER_DIR=`pwd`/../../../package make test
+	# Test the Wasmer C API examples
+	cd lib/c-api/examples; WASMER_CAPI_CONFIG=$(shell echo $@ | sed -e s/test-capi-integration-//) WASMER_DIR=`pwd`/../../../package make run
+
+test-wasi-unit:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --manifest-path lib/wasi/Cargo.toml --release --locked
+
+test-wasi:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --release --tests $(compiler_features) --locked -- wasi::wasitests
+
+test-wasi-fyi: build-wasmer
+	cd tests/wasi-fyi; \
+	./test.sh
+
+test-integration-cli: build-wasmer build-capi package-capi-headless package distribution
+	cp ./dist/wasmer.tar.gz ./link.tar.gz
+	rustup target add wasm32-wasi
+	WASMER_DIR=`pwd`/package $(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --features webc_runner --no-fail-fast -p wasmer-integration-tests-cli --locked
+
+# Before running this in the CI, we need to set up link.tar.gz and /cache/wasmer-[target].tar.gz
+test-integration-cli-ci: require-nextest
+	rustup target add wasm32-wasi
+	$(CARGO_BINARY) nextest run $(CARGO_TARGET_FLAG) --features webc_runner -p wasmer-integration-tests-cli --locked
+
+test-integration-ios:
+	$(CARGO_BINARY) test $(CARGO_TARGET_FLAG) --features webc_runner -p wasmer-integration-tests-ios --locked
+
+generate-wasi-tests:
+# Uncomment the following for installing the toolchain
+#   cargo run -p wasi-test-generator -- -s
+	$(CARGO_BINARY) run $(CARGO_TARGET_FLAG) -p wasi-test-generator -- -g
+#####
+#
+# Packaging.
+#
+#####
+
+package-minimal-headless-wasmer:
+ifeq ($(IS_WINDOWS), 1)
+	if [ -f "target/$(HOST_TARGET)/release/wasmer-headless.exe" ]; then \
+		cp target/$(HOST_TARGET)/release/wasmer-headless.exe package/bin ;\
+	fi
+else
+	if [ -f "target/$(HOST_TARGET)/release/wasmer-headless" ]; then \
+		cp target/$(HOST_TARGET)/release/wasmer-headless package/bin ;\
+	fi
+endif
+
+package-wasmer:
+	mkdir -p "package/bin"
+	ls -R target
+ifeq ($(IS_WINDOWS), 1)
+	if [ -f "$(TARGET_DIR)/wasmer.exe" ]; then \
+		cp "$(TARGET_DIR)/wasmer.exe" package/bin ;\
+	fi
+	if [ -f "target/$(HOST_TARGET)/release/wasmer.exe" ]; then \
+		cp "target/$(HOST_TARGET)/release/wasmer.exe" package/bin ;\
+	fi
+else
+	if [ -f "$(TARGET_DIR)/wasmer" ]; then \
+		cp $(TARGET_DIR)/wasmer package/bin ;\
+	fi
+	if [ -f "target/$(HOST_TARGET)/release/wasmer" ]; then \
+		cp "target/$(HOST_TARGET)/release/wasmer" package/bin ;\
+	fi
+ifeq ($(IS_DARWIN), 1)
+	codesign -s - package/bin/wasmer || true
+endif
+endif
+
+package-capi-headless: build-capi-headless package-capi
+
+package-capi-jsc: build-capi-jsc package-capi
+
+package-capi:
+	mkdir -p "package/include"
+	mkdir -p "package/lib"
+	mkdir -p "package/winsdk"
+	cp lib/c-api/wasmer.h* package/include
+	cp lib/c-api/wasmer_wasm.h* package/include
+	cp lib/c-api/tests/wasm-c-api/include/wasm.h* package/include
+	cp lib/c-api/README.md package/include/README.md
+	if [ -f $(TARGET_DIR)/wasmer.dll ]; then \
+		cp $(TARGET_DIR)/wasmer.dll package/lib/wasmer.dll ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/wasmer.dll ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/wasmer.dll package/lib/wasmer-headless.dll ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/wasmer.dll ]; then \
+		cp target/headless/$(HOST_TARGET)/release/wasmer.dll package/lib/wasmer-headless.dll ;\
+	fi
+
+	if [ -f $(TARGET_DIR)/wasmer.dll.lib ]; then \
+		cp $(TARGET_DIR)/wasmer.dll.lib package/lib/wasmer.dll.lib ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/wasmer.dll.lib ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/wasmer.dll.lib package/lib/wasmer-headless.dll.lib ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/wasmer.dll.lib ]; then \
+		cp target/headless/$(HOST_TARGET)/release/wasmer.dll.lib package/lib/wasmer-headless.dll.lib ;\
+	fi
+
+	if [ -f $(TARGET_DIR)/wasmer.lib ]; then \
+		cp $(TARGET_DIR)/wasmer.lib package/lib/wasmer.lib ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/wasmer.lib ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/wasmer.lib package/lib/wasmer-headless.lib ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/wasmer.lib ]; then \
+		cp target/headless/$(HOST_TARGET)/release/wasmer.lib package/lib/wasmer-headless.lib ;\
+	fi
+
+	if [ -f $(TARGET_DIR)/libwasmer.dylib ]; then \
+		cp $(TARGET_DIR)/libwasmer.dylib package/lib/libwasmer.dylib ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/libwasmer.dylib ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/libwasmer.dylib package/lib/libwasmer-headless.dylib ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/libwasmer.dylib ]; then \
+		cp target/headless/$(HOST_TARGET)/release/libwasmer.dylib package/lib/libwasmer-headless.dylib ;\
+	fi
+
+	if [ -f $(TARGET_DIR)/libwasmer.so ]; then \
+		cp $(TARGET_DIR)/libwasmer.so package/lib/libwasmer.so ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/libwasmer.so ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/libwasmer.so package/lib/libwasmer-headless.so ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/libwasmer.so ]; then \
+		cp target/headless/$(HOST_TARGET)/release/libwasmer.so package/lib/libwasmer-headless.so ;\
+	fi
+
+	if [ -f $(TARGET_DIR)/libwasmer.a ]; then \
+		cp $(TARGET_DIR)/libwasmer.a package/lib/libwasmer.a ;\
+	fi
+
+	if [ -f target/headless/$(CARGO_TARGET)/release/libwasmer.a ]; then \
+		cp target/headless/$(CARGO_TARGET)/release/libwasmer.a package/lib/libwasmer-headless.a ;\
+	fi
+
+	if [ -f target/headless/$(HOST_TARGET)/release/libwasmer.a ]; then \
+		cp target/headless/$(HOST_TARGET)/release/libwasmer.a package/lib/libwasmer-headless.a ;\
+	fi
+
+	if [ -f target/$(HOST_TARGET)/release/wasmer.dll ]; then \
+		cp target/$(HOST_TARGET)/release/wasmer.dll package/lib/wasmer.dll ;\
+	fi
+
+	if [ -f target/$(HOST_TARGET)/release/wasmer.dll.lib ]; then \
+		cp target/$(HOST_TARGET)/release/wasmer.dll.lib package/lib/wasmer.dll.lib ;\
+	fi
+	if [ -f target/$(HOST_TARGET)/release/wasmer.lib ]; then \
+		cp target/$(HOST_TARGET)/release/wasmer.lib package/lib/wasmer.lib ;\
+	fi
+
+	if [ -f target/$(HOST_TARGET)/release/libwasmer.dylib ]; then \
+		cp target/$(HOST_TARGET)/release/libwasmer.dylib package/lib/libwasmer.dylib ;\
+	fi
+
+	if [ -f target/$(HOST_TARGET)/release/libwasmer.so ]; then \
+		cp target/$(HOST_TARGET)/release/libwasmer.so package/lib/libwasmer.so ;\
+	fi
+	if [ -f target/$(HOST_TARGET)/release/libwasmer.a ]; then \
+		cp target/$(HOST_TARGET)/release/libwasmer.a package/lib/libwasmer.a ;\
+	fi
+
+package-docs: build-docs build-docs-capi
+	mkdir -p "package/docs/crates"
+	cp -R target/doc/ package/docs/crates
+	echo '<meta http-equiv="refresh" content="0; url=crates/wasmer/index.html">' > package/docs/index.html
+	echo '<meta http-equiv="refresh" content="0; url=wasmer/index.html">' > package/docs/crates/index.html
+
+package: package-wasmer package-minimal-headless-wasmer package-capi
+
+tar-capi:
+	ls -R package
+	tar -C package -zcvf build-capi.tar.gz lib include winsdk
+
+untar-capi:
+	mkdir -p package
+	mkdir -p target/release
+	mkdir -p target/$(HOST_TARGET)/release
+	tar -C package -xf ./build-capi.tar.gz
+	cp package/lib/* target/release
+	cp package/lib/* target/$(HOST_TARGET)/release
+	mkdir -p target/debug
+	mkdir -p target/$(HOST_TARGET)/debug
+	tar -C package -xf ./build-capi.tar.gz
+	cp package/lib/* target/debug
+	cp package/lib/* target/$(HOST_TARGET)/debug
+	echo "untar capi"
+	ls -R target
+	echo "package"
+	ls -R package
+
+tar-wasmer:
+	ls -R package
+	tar -C package -zcvf build-wasmer.tar.gz bin
+
+untar-wasmer:
+	mkdir -p package
+	mkdir -p target/release
+	mkdir -p target/$(HOST_TARGET)/release
+	tar -C package -xf ./build-wasmer.tar.gz
+	cp package/bin/* target/release
+	cp package/bin/* target/$(HOST_TARGET)/release
+	mkdir -p target/debug
+	mkdir -p target/$(HOST_TARGET)/debug
+	tar -C package -xf ./build-wasmer.tar.gz
+	cp package/bin/* target/debug
+	cp package/bin/* target/$(HOST_TARGET)/debug
+	echo "untar wasmer"
+	ls -R target
+	echo "package"
+	ls -R package
+
+distribution-gnu: package-capi
+	cp LICENSE package/LICENSE
+	cp ATTRIBUTIONS.md package/ATTRIBUTIONS
+	mkdir -p dist
+	tar -C package -zcvf wasmer.tar.gz lib include winsdk LICENSE ATTRIBUTIONS
+	mv wasmer.tar.gz dist/
+
+distribution: package
+	cp LICENSE package/LICENSE
+	cp ATTRIBUTIONS.md package/ATTRIBUTIONS
+	mkdir -p dist
+ifeq ($(IS_WINDOWS), 1)
+	iscc scripts/windows-installer/wasmer.iss
+	cp scripts/windows-installer/WasmerInstaller.exe dist/
+endif
+	tar -C package -zcvf wasmer.tar.gz bin lib include LICENSE ATTRIBUTIONS
+	mv wasmer.tar.gz dist/
+
+#####
+#
+# Installation (for Distros).
+#
+#####
+
+DESTDIR ?= /usr/local
+
+install: install-wasmer install-capi-headers install-capi-lib install-pkgconfig install-misc
+
+install-capi: install-capi-headers install-capi-lib install-capi-pkgconfig install-misc
+
+install-wasmer:
+	install -Dm755 target/release/wasmer $(DESTDIR)/bin/wasmer
+
+install-capi-headers:
+	for header in lib/c-api/*.h; do install -Dm644 "$$header" $(DESTDIR)/include/$$(basename $$header); done
+	install -Dm644 lib/c-api/README.md $(DESTDIR)/include/wasmer-README.md
+
+# Currently implemented for linux only. TODO
+install-capi-lib:
+	pkgver=$$($(CARGO_BINARY) pkgid --manifest-path lib/c-api/Cargo.toml | sed 's/^.*wasmer-c-api@//') && \
+	shortver="$${pkgver%.*}" && \
+	majorver="$${shortver%.*}" && \
+	install -Dm755 target/release/libwasmer.so "$(DESTDIR)/lib/libwasmer.so.$$pkgver" && \
+	ln -sf "libwasmer.so.$$pkgver" "$(DESTDIR)/lib/libwasmer.so.$$shortver" && \
+	ln -sf "libwasmer.so.$$pkgver" "$(DESTDIR)/lib/libwasmer.so.$$majorver" && \
+	ln -sf "libwasmer.so.$$pkgver" "$(DESTDIR)/lib/libwasmer.so"
+
+install-misc:
+	install -Dm644 LICENSE "$(DESTDIR)"/share/licenses/wasmer/LICENSE
+
+install-capi-pkgconfig:
+	@pkgver=$$($(CARGO_BINARY) pkgid --manifest-path lib/c-api/Cargo.toml | sed --posix 's/^.*wasmer-c-api:\([0-9.]*\)$\/\1/') && \
+	printf "prefix=%s\nincludedir=\044{prefix}/include\nlibdir=\044{prefix}/lib\n\nName: wasmer\nDescription: The Wasmer library for running WebAssembly\nVersion: %s\nCflags: -I\044{prefix}/include\nLibs: -L\044{prefix}/lib -lwasmer\n" "$(DESTDIR)" "$${pkgver}" | install -Dm644 /dev/stdin "$(DESTDIR)"/lib/pkgconfig/wasmer.pc
+
+install-pkgconfig:
+	# Make sure WASMER_INSTALL_PREFIX is set during build
+	unset WASMER_DIR; \
+	if pc="$$(target/release/wasmer config --pkg-config 2>/dev/null)"; then \
+		echo "$$pc" | install -Dm644 /dev/stdin "$(DESTDIR)"/lib/pkgconfig/wasmer.pc; \
+	else \
+		echo 1>&2 "WASMER_INSTALL_PREFIX was not set during build, not installing wasmer.pc"; \
+	fi
+
+install-wasmer-headless-minimal:
+	install -Dm755 target/release/wasmer-headless $(DESTDIR)/bin/wasmer-headless
+
+#####
+#
+# Miscellaneous.
+#
+#####
+
+# Updates the spectests from the repo
+update-testsuite:
+	git subtree pull --prefix tests/wast/spec https://github.com/WebAssembly/testsuite.git master --squash
+
+lint-packages: RUSTFLAGS += -D dead-code -D nonstandard-style -D unused-imports -D unused-mut -D unused-variables -D unused-unsafe -D unreachable-patterns -D bad-style -D improper-ctypes -D unused-allocation -D unused-comparisons -D while-true -D unconditional-recursion -D bare-trait-objects -D function_item_references # TODO: add `-D missing-docs`
+lint-packages:
+	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --all --exclude wasmer-cli --locked -- -D clippy::all
+	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path lib/cli/Cargo.toml --locked $(compiler_features) -- -D clippy::all
+	RUSTFLAGS="${RUSTFLAGS}" cargo clippy --manifest-path fuzz/Cargo.toml --locked $(compiler_features) -- -D clippy::all
+
+lint-formatting:
+	cargo fmt --all -- --check
+	cargo fmt --manifest-path fuzz/Cargo.toml -- --check
+
+lint: lint-formatting lint-packages
+
+install-local: package
+	tar -C ~/.wasmer -zxvf wasmer.tar.gz
+
+test-minimal-versions:
+	rm -f Cargo.lock
+	cargo +nightly build --tests -Z minimal-versions --all-features
+
+update-graphql-schema:
+	curl -sSfL https://registry.wapm.io/graphql/schema.graphql > lib/registry/graphql/schema.graphql
+
+require-nextest:
+	cargo nextest --version > /dev/null || cargo binstall cargo-nextest --secure || cargo install cargo-nextest
diff --git a/arbitrator/tools/module_roots/wasmer/PACKAGING.md b/arbitrator/tools/module_roots/wasmer/PACKAGING.md
new file mode 100644
index 0000000..7d32cc8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/PACKAGING.md
@@ -0,0 +1,55 @@
+# Wasmer OS distro packaging notes
+
+* Wasmer is written in Rust. To build Wasmer, where possible, do not
+  directly invoke `cargo`, but use the supplied `Makefile`
+
+* Wasmer provides several compilers and the `Makefile` autodetects
+  when compilers can be compiled and/or installed. Set the environment
+  variables `ENABLE_{CRANELIFT,LLVM,SINGLEPASS}=1` to force compiler
+  to be build or to fail trying, e.g:
+
+  ```sh
+  $ ENABLE_LLVM=1 make build-wasmer
+  ```
+
+* `make install` respects `DESTDIR`, but `prefix` must be configured
+  with `WASMER_INSTALL_PREFIX`. Note that `DESTDIR` must include
+  `WASMER_INSTALL_PREFIX`, e.g.:
+
+  ```sh
+  export WASMER_INSTALL_PREFIX=/usr
+  make
+  DESTDIR=/tmp/staging/usr make install
+  ```
+
+* In case you must build/install directly with `cargo`, make sure to
+  enable at least one compiler feature, like e.g. `--features
+  cranelift`,
+
+  * Beware that compiling with `cargo build --workspace --features …`
+    will not enable features on the subcrates in the workspace and
+    result in a headless Wasmer binary that can not compile Wasm files
+    directly.
+
+* If you split the package into several subpackages, beware that the
+  `create-exe` command of the `wasmer` CLI requires `libwasmer.a` to
+  be installed at `$WASMER_INSTALL_PREFIX/lib/libwasmer.a`. Suggestions for splitting:
+
+  * The `wasmer-headless` CLI contains a subset of the `wasmer`'s functionalities
+    and should only be packaged when splitting — it must be built
+    explicitly with:
+    
+    ```sh
+    $ make build-wasmer-headless-minimal install-wasmer-headless-minimal
+    ```
+  * `libwasmer`, containing `libwasmer.so*`,
+  * `libwasmer-dev`, containing the header files and a `.pc` file,
+  * `libwasmer-static`, containing `libwasmer.a`.
+
+The Wasmer distro packaging story is still in its infancy, so feedback is very welcome.
+
+## Miscellaneous: binfmt_misc
+
+Wasmer can be registered as a binfmt interpreter for wasm binaries.
+An example systemd [.service](./scripts/wasmer-binfmt.service.example) is included here.
+Please consider statically linking the wasmer binary so that this capability is also available in mount namespaces.
diff --git a/arbitrator/tools/module_roots/wasmer/README.md b/arbitrator/tools/module_roots/wasmer/README.md
new file mode 100644
index 0000000..31aad97
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/README.md
@@ -0,0 +1,259 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank">
+    <picture>
+      <source srcset="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo-white.png"  media="(prefers-color-scheme: dark)">
+      <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
+    </picture>
+  </a>
+
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?event=push" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
+    </a>
+    <a href="https://docs.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Docs&message=docs.wasmer.io&color=blue" alt="Wasmer Docs">
+    </a>
+    <a href="https://discord.gg/rWkMNStrEW">
+      <img src="https://img.shields.io/discord/1110300506942881873" alt="Wasmer on Discord">
+    </a>
+  </p>
+</div>
+
+<br />
+
+Wasmer is a _blazing fast_ and _secure_ [**WebAssembly**](https://webassembly.org) runtime that enables incredibly
+_lightweight containers_ to run anywhere: from _Desktop_ to the _Cloud_, _Edge_ and your browser.
+
+- **Secure** by default. No file, network, or environment access, unless explicitly enabled.
+- **Pluggable**. supports [**WASIX**](https://wasix.org/), [WASI](https://github.com/WebAssembly/WASI) and [Emscripten](https://emscripten.org/) out of the box.
+- **Incredibly Fast**. Run WebAssembly at near-native speeds.
+- **Embeddable** [anywhere via Wasmer SDKs](https://github.com/wasmerio/wasmer/#wasmer-sdk)
+
+### Install Wasmer
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+<details>
+  <summary>Other installation options (Powershell, Brew, Cargo, ...)</summary>
+  
+  _Wasmer can be installed from various package managers. Choose the one that fits best for your environment:_
+  
+  * Powershell (Windows)
+    ```powershell
+    iwr https://win.wasmer.io -useb | iex
+    ```
+
+- <a href="https://formulae.brew.sh/formula/wasmer">Homebrew</a> (macOS, Linux)
+
+  ```sh
+  brew install wasmer
+  ```
+
+- <a href="https://github.com/ScoopInstaller/Main/blob/master/bucket/wasmer.json">Scoop</a> (Windows)
+
+  ```sh
+  scoop install wasmer
+  ```
+
+- <a href="https://chocolatey.org/packages/wasmer">Chocolatey</a> (Windows)
+
+  ```sh
+  choco install wasmer
+  ```
+
+- <a href="https://crates.io/crates/cargo-binstall/">Cargo binstall</a>
+
+  ```sh
+  cargo binstall wasmer-cli
+  ```
+
+- <a href="https://crates.io/crates/wasmer-cli/">Cargo</a>
+
+  _Note: All the available
+  features are described in the [`wasmer-cli`
+  crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md)_
+
+  ```sh
+  cargo install wasmer-cli
+  ```
+
+> Looking for more installation options? See [the `wasmer-install`
+> repository](https://github.com/wasmerio/wasmer-install) to learn
+> more!
+
+</details>
+
+> Note: You can also try Wasmer online in [wasmer.sh](https://wasmer.sh/)
+> 
+### Quickstart
+
+You can start by running
+[Cowsay](https://wasmer.io/syrusakbary/cowsay):
+
+```bash
+$ wasmer run cowsay "hello world"
+ _____________
+< hello world >
+ -------------
+        \   ^__^
+         \  (oo)\_______
+            (__)\       )\/\
+               ||----w |
+                ||     ||
+```
+
+> There are many more available packages, such as [`wasmer/python`](https://wasmer.io/wasmer/python) or [`quickjs`](https://wasmer.io/saghul/quickjs). [Create your own package](https://docs.wasmer.io/registry/get-started), or explore packages from the community: https://wasmer.io/explore
+
+#### Here is what you can do next:
+
+- [Run a package](https://docs.wasmer.io/runtime/get-started)
+- [Publish a package](https://docs.wasmer.io/registry/get-started)
+- [Deploy your website](https://docs.wasmer.io/edge/get-started)
+- [Read more about Wasmer](https://wasmer.io/posts)
+
+## Wasmer SDK
+
+You can use the Wasmer runtime **embedded in different
+languages** with the Wasmer SDK:
+
+|                  | Language                             | Package                               | Documentation          |
+| ---------------- | ------------------------------------ | ------------------------------------- | ---------------------- |
+| ![Rust logo]     | [**Rust**][Rust integration]         | [`wasmer` Rust crate]                 | [Learn][rust docs]     |
+| ![C logo]        | [**C**][C integration]               | [`wasm.h` header]                     | [Learn][c docs]        |
+| ![C++ logo]      | [**C++**][C integration]             | [`wasm.hh` header]                    | [Learn][c docs]        |
+| ![C# logo]       | [**C#**][C# integration]             | [`WasmerSharp` NuGet package]         | [Learn][c# docs]       |
+| ![D logo]        | [**D**][D integration]               | [`wasmer` Dub package]                | [Learn][d docs]        |
+| ![Python logo]   | [**Python**][Python integration]     | [`wasmer` PyPI package]               | [Learn][python docs]   |
+| ![JS logo]       | [**Javascript**][JS integration]     | [`@wasmerio` NPM packages]            | [Learn][js docs]       |
+| ![Go logo]       | [**Go**][Go integration]             | [`wasmer` Go package]                 | [Learn][go docs]       |
+| ![PHP logo]      | [**PHP**][PHP integration]           | [`wasm` PECL package]                 | [Learn][php docs]      |
+| ![Ruby logo]     | [**Ruby**][Ruby integration]         | [`wasmer` Ruby Gem]                   | [Learn][ruby docs]     |
+| ![Java logo]     | [**Java**][Java integration]         | [`wasmer/wasmer-jni` Bintray package] | [Learn][java docs]     |
+| ![R logo]        | [**R**][R integration]               | _no published package_                | [Learn][r docs]        |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | _no published package_                | [Learn][postgres docs] |
+| ![Swift logo]    | [**Swift**][Swift integration]       | _no published package_                |                        |
+| ![Zig logo]      | [**Zig**][Zig integration]           | _no published package_                |                        |
+| ![Dart logo]     | [**Dart**][Dart integration]         | [`wasm` pub package]                  |                        |
+| ![Crystal logo]  | [**Crystal**][Crystal integration]   | _no published package_                | [Learn][crystal docs]  |
+| ![Lisp logo]     | [**Lisp**][Lisp integration]         | _no published package_                |                        |
+| ![Julia logo]    | [**Julia**][Julia integration]       | _no published package_                |                        |
+| ![VLang logo]    | [**V**][vlang integration]           | _no published package_                |                        |
+| ![Ocaml logo]    | [**OCaml**][OCaml integration]       | [`wasmer` OCaml package]              |                        |
+
+[👋&nbsp;&nbsp;Missing a language?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://docs.rs/wasmer/
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasm.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/tests/wasm-c-api/include/wasm.h
+[c docs]: https://docs.rs/wasmer-c-api/*/wasmer/wasm_c_api/index.html
+[c++ logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/cpp.svg
+[`wasm.hh` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/tests/wasm-c-api/include/wasm.hh
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+[swift logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/swift.svg
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg
+[dart integration]: https://github.com/dart-lang/wasm
+[`wasm` pub package]: https://pub.dev/packages/wasm
+[lisp logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/lisp.svg
+[lisp integration]: https://github.com/helmutkian/cl-wasm-runtime
+[crystal logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/crystal.svg
+[crystal integration]: https://github.com/naqvis/wasmer-crystal
+[crystal docs]: https://naqvis.github.io/wasmer-crystal/
+[julia logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/julia.svg
+[julia integration]: https://github.com/Pangoraw/Wasmer.jl
+[vlang logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/vlang.svg
+[vlang integration]: https://github.com/vlang/wasmer
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## Contribute
+
+We appreciate your help! 💜
+
+We recommend reading the following guide on how to contribute into a complex project successfully:
+https://mitchellh.com/writing/contributing-to-complex-projects
+
+Check our docs on how to [build Wasmer from
+source](https://docs.wasmer.io/developers/build-from-source) or [test your changes](https://docs.wasmer.io/developers/testing).
+
+<!-- ## Bounties
+
+For some issues we offer paid bounties. You'll get paid automatically as soon as your PR solving the issue is merged!
+
+<a href="https://console.algora.io/org/wasmerio/bounties?status=open">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://console.algora.io/api/og/wasmerio/bounties.png?p=0&status=open&theme=dark">
+    <img alt="Bounties of wasmerio" src="https://console.algora.io/api/og/wasmerio/bounties.png?p=0&status=open&theme=light">
+  </picture>
+</a> -->
+
+## Community
+
+Wasmer has an amazing community of developers and contributors. Welcome, please join us! 👋
+
+- [Wasmer Community Discord](https://discord.gg/rWkMNStrEW)
+- [Wasmer on Twitter](https://twitter.com/wasmerio)
+
+--------
+
+> _README also in:
+> [🇨🇳 中 文 -Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) •
+> [🇩🇪 Deutsch-German](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) •
+> [🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) •
+> [🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) •
+> [🇯🇵 日本 語 -Japanese](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md) •
+> [🇰🇷 한국어 -Korean](https://github.com/wasmerio/wasmer/blob/master/docs/ko/README.md)_.
+
diff --git a/arbitrator/tools/module_roots/wasmer/SECURITY.md b/arbitrator/tools/module_roots/wasmer/SECURITY.md
new file mode 100644
index 0000000..0f8b874
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/SECURITY.md
@@ -0,0 +1,23 @@
+# Security Policy
+
+## Supported Versions
+
+The table below summarizes which versions are still supported, and which aren't.
+
+| Version | Supported |
+|-|-|
+| 0.x | ❌ |
+| 1.x | ❌ |
+| 2.x | ✅ |
+| 3.x | ✅ |
+
+## Reporting a Vulnerability
+
+The Wasmer team and community take security bugs in Wasmer seriously.
+We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.
+
+To report a security issue, email security@wasmer.io or
+hello@wasmer.io and include the word "SECURITY" in the subject line.
+
+The Wasmer team will send a response indicating the next steps in handling your report.
+After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.
diff --git a/arbitrator/tools/module_roots/wasmer/Xargo.toml b/arbitrator/tools/module_roots/wasmer/Xargo.toml
new file mode 100644
index 0000000..2b87983
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/Xargo.toml
@@ -0,0 +1,2 @@
+[dependencies]
+std = {}
diff --git a/arbitrator/tools/module_roots/wasmer/assets/README.md b/arbitrator/tools/module_roots/wasmer/assets/README.md
new file mode 100644
index 0000000..b32a943
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/README.md
@@ -0,0 +1,3 @@
+# Wasmer Documentation Assets
+
+This directory contains documentation assets.
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.png b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.png
new file mode 100644
index 0000000..5ed33a7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.png differ
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.svg b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.svg
new file mode 100644
index 0000000..f930d20
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_compilation.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1004" height="352" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2020-07-20T09:19:59.698Z&quot; agent=&quot;5.0 (Macintosh)&quot; version=&quot;13.4.8&quot; etag=&quot;7basM_j3VExUdDWLz-Ua&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;lbpiYurgNz5VTBNmSIvc&quot;&gt;7Vptb9sgEP41+bjI4NhOPi5psk7atEmZ1PZTxWJqs2LwMHnbrx/Y4JfE2dIubbwqaqVwB5w57rnnwEnPnSSbDwKl8WceYtqDTrjpuVc9CGEQOOpDa7aFBoAAFppIkNDoKsWc/MJGaSZGSxLirDFQck4lSZvKBWcML2RDh4Tg6+awB06bT01RhPcU8wWi+9obEsq40A5hUOmvMYli+2Tgj4qeBNnBxpMsRiFfN1R4I2ecSbPELylmSjlHLOt501hK7eL7Hpyp/wc9rB9xHlGMUpL1FzxR6kWmhsweUEKo3uDCwji3EEy+IinI4lGZvEYsfKbJ0sg4N6KW7U577kRwLotWsplgqoNuw1n4NjvQW+6nwEweM8HAZYXo0oSkB32qpo61A3pf5dYEy/+55LbjXZZDSfnqgGG6qTo1CNCiOWFnp2pj/Uh/rlGWYKGtue8VxpcUF22G13YxZkPtDBPycmlQ8CULsfbJ0QZjIvE8LdaxVqmjdLFMqJKAamaPWC5iK0jBH/GEUy5yU+7VyBl4sOyxsMw1FmP6IQ+E0rlZAVpKblQ1SzNH/UGzYzMb8o8sJFitfkb5Wns9nn3bptpIVDq2wkLizcGIghInihgwT7AUWzXETHgHHOD2vWKa4YWBY1JiXSUZsOQR1xLMNzpkkiYqzVcYUg0Do3ZIuXvRwaFKeiNyIWMecYbotNKOm/GrxnziPDWB+oGl3BoGM/tdiyneEHlba99pU2oXCulqYyznwtYKTHl2Wxdqs7RYTcslO+9E+HkiKPQmNiCR8aUwmQYHhruRiLBsZPYRwBGYIklWTev/goBBB0jlRpGK6vy+laq+HckiygtV+PBrMshf6WLHzxegCzgMGmThjlrIAraQxfAEZOF1ACqH6o+q2ClRQrdrUBcKji0bBkEebEHQCNiidOqC4/9/BacflEXmzhr5Q8UJURbniz0hdE5ZfoJOlZ+gM5xyj1lEmKGTaa19oZbjqGXogp2jbBu3QM99GWYZtiDp9ammgwnv7Sd8cHRwT57wo0uY2sNkX/PU4+SdL052OR1g5v3TnloUCZG8cPLfLwzB8AhSBtWoU9MyAHvReMUTn9OH9ph3V+tqP/J1/eQG9wnCZulZGOLw+8iQrJ5DEDZ7z3QANAe9Bt9M2YoIzpJ8d7VaCsQy+ifuKdX5LlwYafcCOmzykT/Y5yPXC16Ijc76wvNJbFS7gDbun9WN883cPy2TnIXFBudFRB0QzrGAeFtvJEC3bijg8HvOt1DXJg3J9N0nxen6UtOeU9P8Y0qa/0Jf4QH/cqM+wCttB+bXu1IrsfptQN5X+2WIO/0N&lt;/diagram&gt;&lt;/mxfile&gt;" version="1.1" viewBox="-.5 -.5 1004 352"><defs/><defs><style type="text/css">@import url(https://fonts.googleapis.com/css?family=Open+Sans);@import url(https://fonts.googleapis.com/css?family=Patrick+Hand);</style></defs><path fill="none" stroke="none" d="M294.5 31h170v60h-170z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M294.52 30.97s0 0 0 0m0 0s0 0 0 0m.72 10.93c2.07-2.93 6.6-9.03 9.2-11.05m-9.64 12.33c2.69-3.38 5.99-7.05 11-11.44m-11.17 25.24c7.09-9.4 10.8-16.49 23-24.5m-22.39 22.35c6.41-8.52 12.73-16.14 20-23.05m-22.27 34.33c9.83-8.7 18.57-17.87 31.47-33.64m-30.09 35.9c8.42-10.71 16.88-19.26 31.34-36.55m-30.7 47.97c10.64-13.44 23.26-28.26 41.33-48.7M293.8 80.53c12.16-14.44 23.75-28.06 42.29-50.65m-40.27 63.17c12.81-16.67 23.03-31.15 51.88-61.63M294.95 91.4c12.38-13.8 25.41-28.45 52.37-60.28M305.1 90.63c16.27-16.95 29.74-32.93 54.14-59.73m-53.99 60.17c19.21-21.25 38.39-44.1 53.9-59.32m-40.99 59.27c15.79-19.88 36.92-44.34 49.13-60.15m-50.56 60.96c17.76-20.37 35.78-40.69 51.29-62.07M326.37 90.8c21.26-22.39 37.67-41.71 52.93-58.63m-52.57 59.52c10.98-14.57 24.64-26.94 53.13-61.05M338.05 92.3c8.68-14.35 21.88-28.63 53.24-63.64M336.1 92.13c13.38-15.59 25.63-29.58 53.71-62.04M346.53 90.1c13.94-15.49 30.01-31.04 52.73-59.28m-51.58 61.04c11.5-12.93 22.08-27.11 53.35-62.12m-43.36 61.44c19.81-19.1 35.58-37.95 54.32-59.14m-52.9 58.99c18.89-21.75 37.38-42.35 50.76-60.41m-39.92 62.77c13.92-18.73 26.52-35.38 51.16-60.22m-51.91 57.75c18.07-19.48 37.03-41.85 51.94-59.03m-40 57.96c15.97-18.53 33.16-40.29 49.37-57.22m-50.37 59.81c14.59-18.24 30.13-35.19 52-60.41m-42.27 58.42c12.2-15.36 29.12-33.96 52.69-59.51m-51.35 59.92c17.95-22.32 38.59-44.32 50.71-59.25m-42.93 61.82c14.59-15.68 27.63-31.65 55.78-60.41m-53.18 58.44c14.54-16.63 29.96-34.98 50.88-60.77m-39.43 60.26c13.54-17.28 28.81-34.9 50.23-59.18m-51.13 60.58c13.91-16.33 27-31.93 51.36-61.75m-41.84 62.06c14.83-19.61 29.53-36.69 50-57.74m-49.49 57.17c11.38-14.58 24.61-28.46 47.42-56.18m-36.54 55.32c8.3-10.27 18.82-19.04 37.25-43.68m-37.05 42.94c12.93-14.39 28.65-31.82 37.64-41.4M441.4 89.96c7.99-6.19 16.64-12.25 28.28-28.9m-25.77 31.21c9.67-12.03 18.52-21.1 26.9-31.55m-18.47 31.57c5.99-6.51 10.56-11.88 18.45-20.38m-17.2 19.89c5.05-5.16 9.62-9.58 16.12-19.5" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M294.69 31.94c46.87.22 96.52-1.44 169.1-1.92m-168.97.12c67.24.39 132.72-.28 169.8 1.04m-1.09 1.33c2.06 22.08-.4 46.45.67 59.5m1.3-60.23c-.38 23.33-1.16 46.03-1.99 58.99m1.9.09c-59.57-.02-114.34 3.32-169.75 1.22m168.29-1.63c-51.37.88-103.16-.52-169.82.94m1.71-.31c-2.74-18.98-1.78-35.46-2.49-59.09m1.44 58.82c-.31-15.53-.59-30.46.6-59.85" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:168px;height:1px;padding-top:61px;margin-left:296px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::new</font></div></div></div></foreignObject><text x="380" y="65" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer::Module::new</text></switch><path fill="none" stroke="none" d="M141 61h145.26" pointer-events="stroke"/><path fill="none" stroke="none" d="M292.26 61l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M140.14 59.89c57.25.5 117.15.29 145.73 2.34M140 60.26c36.81 1.09 73.28 1.73 146.77.56" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M284.51 56.72s0 0 0 0m0 0s0 0 0 0m2.58 9.25c2-1.51 3.09-4.2 4.2-5.25m-4.93 5.76c1.22-1.81 2.82-3.15 5.7-6.18" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M292.67999999999995 60.63c-1.8 1.02-4 1.78-7.86 4.96m7.28-4.31c-1.1.54-3.23 1.62-8.26 3.77m.4.02c1-1.25 1.74-2.67 1.97-4.18m-2.16 4.32c.85-1.26 1.12-2.19 2.39-4.07m.25-.11c-1.24-1.14-2.13-2.81-2.81-4.04m2.2 4c-.22-.8-.6-1.57-1.72-4.15m-.86-.23c2.66 1.83 5.49 2.24 9.52 3.88M284 57.18c2.98 1.13 6.08 2.4 8.19 4.18" pointer-events="all"/><ellipse cx="81" cy="61" fill="transparent" stroke="none" pointer-events="all" rx="60" ry="40"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M29.56 39.14s0 0 0 0m0 0s0 0 0 0m-7.14 20.71C29.51 53 36.47 39.8 52.16 26.32m-31.34 35.8c8.91-9.65 17.39-20.63 31.38-35.96M24.13 68.91c10.67-13.68 23.25-25.32 41.7-45.3M24.46 68.5c16.17-16.85 31.75-36 41.71-46.21M28.45 78.61C39.9 62.64 51.97 50.35 75.24 22.08M28.55 76.16C42.3 60.61 56.61 45.92 77.3 22.59M33.77 84.75c14.7-17.42 31.25-36.25 51.91-61.19M31.92 84.47C47.83 67.1 61.12 50 86.87 22.55m-49.01 66c11.9-12.32 26.74-26.79 61.29-68.83M39.23 89.69c17.71-21.3 36.28-42.02 59.73-67.84M46.01 94.61c13.92-16.13 24.12-30.01 59.73-68.53M46.62 94.1c12.22-15.28 24.23-31.14 59.71-69.6M53.71 96.04c18.7-23.73 39.6-46.36 59.81-68.98M52.67 97.21c13.65-15.66 28.37-32.9 61.01-68.28M60.7 102.18c17.99-23.31 43.7-48.14 61.41-68.91m-62.13 69.3c21-26.04 42.2-50.44 59.64-71.12m-49.28 71.57c13.96-15.36 26.72-32.03 55.71-68.36m-57.21 69.58c14.88-18.18 31.09-37.79 58.6-67.82m-48.33 70.26c11.11-18.66 24.7-32.24 54.36-63.92m-55.23 62.66c18.62-23.69 37.17-44.77 54-62.79M87.9 103.28c11.18-10.62 21.14-21.27 47.6-53.26m-46.05 54.4c18.97-20.44 36.03-41.51 48.23-54.72m-32.91 50.22c12.1-16.18 25.66-28.09 38.93-46.34m-39.42 45.1c13.39-14.28 25.9-27.5 37.55-42.69m-21.37 39.17c3.89-9.06 9.29-14.33 20.41-24.45m-21.91 24.66c5.92-7.35 11.59-14.8 22.46-26.28" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M64.58 20.63c9.47-2.48 23.16-2.26 33.03-.18 9.87 2.09 19.33 7.48 26.19 12.69 6.85 5.21 12.85 11.6 14.95 18.59 2.11 6.98 1.13 16.37-2.32 23.32-3.46 6.95-10.4 13.63-18.42 18.39-8.03 4.76-19.32 9.38-29.72 10.19-10.41.81-23.28-2.01-32.71-5.34-9.44-3.32-18.08-8.43-23.9-14.59s-10.62-15-11.01-22.39c-.38-7.38 3.47-15.86 8.68-21.92 5.21-6.06 14.81-11.01 22.58-14.44 7.77-3.44 17.8-5.26 24.04-6.16 6.23-.89 13.07.09 13.36.78m-32.07 3.27c8.48-2.97 21.38-3.43 31.83-2.67 10.46.77 22.63 2.82 30.89 7.26 8.27 4.43 15.62 12.1 18.7 19.37 3.08 7.28 2.13 17.22-.2 24.28-2.32 7.05-6.55 12.83-13.74 18.04-7.2 5.22-19.16 11.36-29.42 13.23-10.27 1.87-22.47.34-32.19-2.03-9.72-2.36-19.22-6.5-26.13-12.16-6.9-5.66-13.45-14.45-15.32-21.79-1.86-7.34.16-15.57 4.16-22.25 4.01-6.69 14.76-14.36 19.88-17.84 5.12-3.48 8.94-2.64 10.84-3.03 1.9-.4-.22.16.55.67" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:118px;height:1px;padding-top:61px;margin-left:22px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Patrick Hand;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">Wasm bytes</font></div></div></div></foreignObject><text x="81" y="65" fill="#000" font-family="Patrick Hand" font-size="12" text-anchor="middle">Wasm bytes</text></switch><path fill="none" stroke="none" d="M248 151h191.5v60H248z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M248.07 150.92s0 0 0 0m0 0s0 0 0 0m-.22 13.36c4.67-4.78 8.42-10.69 12.21-11.89m-12.39 9.92c4.67-4.36 8.47-9.04 10.39-11.75m-8.6 24.29c4.42-8.24 10.06-13.52 18.91-22.44m-20.61 23.25c4.17-6.82 9.44-11.68 20.86-25.48m-19.43 36.57c8.74-11.09 19.77-23.18 31.45-34.04m-33.44 35.41c8.24-8.6 15.02-15.14 33.05-38.21m-31.9 51.4c12.42-14.35 24.95-30.54 44.03-51.99m-44.98 50.26c15.67-16.53 30.48-33.61 42.95-49.71m-42.94 61.4c15.84-17.11 28.02-32.19 52.39-61.55m-51.83 61.08c10.95-12.21 22.88-25.42 52.61-60.65m-43.15 60.27c23.6-22.69 39.42-43.18 55.17-59.54m-53.9 60.28c15.93-19.26 30.84-35.79 52.83-60.18m-42.6 59.89c18-17.49 32.47-33.79 53.38-62m-51.56 61.65c11.03-13.13 22.81-26.7 50.79-59.64m-41.11 61.41c14.13-16.67 28.26-32.55 54.26-59.82m-54.97 58.51c21.26-23.62 41.27-46.58 53.75-60.15m-41.8 60.98c15.06-17.33 28.44-34.02 49.75-62.23m-50.2 61.77c19.33-23.73 41.13-46.14 51.7-60.09m-42.95 58.89c17.44-17.67 33.39-33 55.14-60.35m-53.36 62.09c12.08-13.47 22.63-28.74 51.84-60.7m-42.29 59.09c16.7-15.53 29.89-33.95 54.45-59.71m-53.6 60.87c16.06-17.93 31.33-34.61 52.1-60.5m-40.3 60.79c12-15.46 26.73-31.86 51.75-59.88m-53.96 60.56c15.09-17.83 28.97-33.6 52.33-61.12m-41.12 61c17.05-20.06 36.09-44.43 54.46-61.9m-54.28 60.52c12.7-13.54 25.63-28.45 51.75-60.42m-42.48 63.07c15.12-19.82 30.9-34.44 53.4-64.11M343.05 211c12.32-13.39 25.42-28.03 52.84-60.65m-42.03 60.3c13.31-16.96 27.75-30.96 54.75-58.28m-53.45 58.46c17.08-18.9 33.68-39.78 51.43-60.33m-39.84 59.25c15.71-14.2 27.93-34.57 52.06-57.53m-53.96 58.63c18.53-19.64 35.82-39.51 52.63-60.31m-42.79 59.22c14.94-13.33 23.67-24.97 54.27-60.33m-52.9 62.58c10.49-12.96 21.06-26.47 52.89-61.76m-43.05 61.69c18.87-24.62 38.14-47.37 53.69-62.57m-53.51 62.52c14.51-16.97 27.38-31.49 51.97-60.13m-42.5 57.78c19.5-19.77 38.12-40.29 50.07-52.97m-49.23 54.4c17.74-19.02 33.06-38.79 48.98-54.7m-39.21 53.11c12.07-10.2 21.58-19.33 39.19-42.38m-37.9 43.74c12.58-13.29 25.98-28.7 37.03-41.76m-24.51 40.53c5.77-5.4 10.9-16.6 23.34-27.84m-25.78 30.28c9.07-9.74 17.24-20.25 27.67-30.81m-17.9 31.69c5.31-7.57 10.29-13.82 19.69-21.96m-17.51 19.87c5.25-7.61 11.16-15.15 15.26-17.77" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M248.76 152.83c53.36-2.4 108.32-.74 189.65-3.63m-191.04 2.74c48.93-2.68 99.77-3.06 191.51-1.5m2.26-1.18c-2.28 18.17-2.67 33.08.23 62.14m-.98-61.02c-.58 23.46-.29 47.13-1.66 60.44m-1.16 1.4c-71.92.19-147.12 1.89-188.9.65m190.45-1.85c-43.53 2.59-89.4 2.38-191.67-.5m1.73 1.71c-.31-22.34-.54-41.32-2.56-61.86m1.32 60.43c.2-19.96-.55-41.11-.72-59.87" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:190px;height:1px;padding-top:181px;margin-left:249px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::compile</font></div></div></div></foreignObject><text x="344" y="185" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer::Module::compile</text></switch><path fill="none" stroke="none" d="M729.5 181h20v-60H422V99.24" pointer-events="stroke"/><path fill="none" stroke="none" d="M422 93.24l4 8-4-2-4 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M728.23 181.92c8.65-.92 15.57-1.87 21.4-.58m-20.3-.84c7.95-.42 14.8.24 21.05.71m-1.74-1.54c.48-13.42 1.37-27.97.73-59.05m.91 60.07c-1.64-20.19-1.65-40.26-1.08-60.29m-.89.46c-84.33-2.77-168.47-1.68-326.49 1.1m327.32-1.57c-89.8-.75-180.73-.85-327.62.06m1.06-1.06c.3-1.7-2.13-5.85-.96-18.33m1.13 19.85c-.4-4.98-.45-9.94-.93-22.13" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M422.24 92.97s0 0 0 0m0 0s0 0 0 0m2.69 9.06c.27-.4.53-.67.73-.87m-.67.88c.24-.29.35-.53.62-.84" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M421.21999999999997 93.15c1.44 1.35 2.95 4.13 4.67 8.72m-4.13-9.03c1.43 2.31 2.09 4.45 3.93 8.04m.44 0c-.77.21-2.16-.11-4.22-1.23m4.26 1.57c-1.06-.42-2.04-.83-4.21-2.08m.28-.07c-1.5.59-3.38 2.12-4.15 1.74m3.86-1.78c-.97.78-1.99 1.21-3.96 2.3m.56-.68c1.01-1.75 2.08-3.66 2.61-7.64m-3.32 8.39c.53-1.71 1.93-3.71 3.92-7.75" pointer-events="all"/><path fill="none" stroke="none" d="M476.5 151h253v60h-253z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M476.63 150.85s0 0 0 0m0 0s0 0 0 0m1.6 12.04c1.72-4.38 5.57-7.29 8.95-11.11m-10.65 10.73c2.33-2.68 4.73-4.74 10.73-11.32m-12.59 23.99c7.47-6.03 16.36-14.64 21.32-24.17m-19.8 24.62c7.91-9.64 15.64-18.14 22.27-25.36m-21.16 39.3c6.73-12.29 17.72-24.23 32.79-36.82m-33.89 35.9c11.55-12.61 21.38-25.4 32.28-38.09m-32.97 49.87c15.21-19.53 30.55-34.12 44.93-50.42m-44.47 49.2c16.51-18.37 32.4-35.28 43.17-48.73m-42.5 58.82c19.86-23.35 42.35-46.68 52.57-60.2m-52.19 62.11c18.27-20.42 35.51-42.54 53.35-60.1m-42.78 62.61c16.11-22.87 36.1-45.09 50.84-61.57m-51.86 60.4c15.68-16.75 28.69-33.38 53.8-61.88m-41.8 59.52c14.74-14.03 28.33-28.95 53.47-59.95m-53.23 61.88c11.22-15.73 25.08-29.74 51.28-61.5m-43.38 59.2c15.52-11.49 25.99-24.62 52.5-59.21m-50.23 61.83c16.02-19.88 31.46-38.59 51.08-61.51m-42.48 62c14.67-14.99 24.66-29.84 55.48-63.34m-54.76 62.79c18.5-19.83 35.21-39.05 53.25-60.36m-40.39 58.1c18.69-19.12 36.83-43.8 50.83-58.3m-51.5 59.36c10.18-12.69 23.43-27.04 50.89-59.14m-42.83 60.55c18.77-21.02 38.59-43.32 53.16-61.22m-51.83 59.5c11.62-12.68 21.65-24.69 52.54-59.88m-39.75 61.47c19.29-24.1 39.05-49.8 49.28-62.44m-51.32 61.5c16.94-17.94 33.29-36.19 53.14-60.47m-42.83 62c12.67-15.89 22.67-27.73 52.16-63.46m-52.26 62.09c17.04-18.67 33.28-36.92 53-59.75m-41.88 61.29c11.27-12.65 20.49-24.59 50.97-62.99m-51.21 61.43c14.2-15.14 27.61-30.68 52.88-60.44m-40.4 58.46c17.32-18.41 35.72-42.44 53.07-58.91m-53.53 61.13c17.26-21.63 34.92-40.68 50.94-60.18m-41.97 61.58c13.46-16.16 22.5-28.09 53.99-62.31m-52.89 61.32c19.27-22.44 38.63-44.4 51.72-60.5m-39.78 59.6c17.92-24.44 38.67-47.11 51.5-59.44m-53.85 58.62c13.03-12.65 22.32-23.59 53.19-59.85m-41.03 61.39c13.2-19.22 29.81-35.83 51.48-61.75m-51.3 61.26c17.18-20.68 36.87-42.11 51.71-60.59m-40.47 59.63c12.73-16.53 28.96-33.77 50.05-59.89m-51.1 61.03c18.06-22.54 37.11-42.62 51.06-59.97m-40.84 57.84c20.84-20.55 37.86-42.08 51.52-57.68m-51.55 58.33c15.41-17.28 31.1-33.69 53.42-59.16m-42.32 58.31c19.29-19.7 40.11-40.71 50.36-58.14m-49.91 60.25c15.48-20 32.5-39.69 52.38-60.22m-41.01 61.09c9.12-17.24 24.33-30.02 49.24-61.46m-49.97 59.53c14.74-18.53 29.4-36.34 51.92-59.14m-40.41 57.94c7.64-10.36 21.16-22.88 49.01-59.03m-50.57 60.66c14.62-16.63 28.82-35.26 51.46-60.81m-39.91 61.34c14.57-17.29 27.16-34.33 50.08-58.69m-50.45 58.09c12.7-14.79 24.78-29.44 50.13-59.25m-41.52 57.64c11.15-5.84 15.94-17.42 42.47-45.62m-40.94 47.25c11.99-13.2 24.4-28.51 41.97-47.59m-32.57 49.02c13.31-12.67 21.78-27.48 30.8-35.34m-30.37 34.51c8.85-8.85 15.9-17.67 29.77-36.01m-18 36.39c7.38-11.5 12.8-18.72 18-25.49m-18.39 25.04c4.27-6.29 9.04-11.01 19.89-22.52m-11.03 21.4c4.49-.92 4.49-2.22 9.85-9.89m-8.46 11.34c3.37-4.72 6.41-7.84 9.76-11.49" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M476.19 151.65c69.69-.76 141.43-1.76 253.41-.17m-253.32-.31c71.11-1.04 140.98-.19 253.06-.82m1.33-.84c.41 18.2-3.29 31.29.09 63.02m-1.07-61.95c-1.05 15.51.26 32.16.45 59.6m.27.01c-52.62 3.86-103.59 1.56-253.5.37m252.33 1.15c-52.91-.51-106.07-.9-253.24-.26m-1.04-1.5c1.84-12.79-.13-27.28 2.75-58.79m-2.05 59.64c1.44-19.44 1.19-36.66 1.5-59.89" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:251px;height:1px;padding-top:181px;margin-left:478px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Engine::compile</font></div></div></div></foreignObject><text x="603" y="185" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer_engine::Engine::compile</text></switch><path fill="none" stroke="none" d="M439.5 181h20-3 11.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M474.26 181l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M437.83 182.1c9.82-2.56 17.88-2.13 23.66-.47m-21.36-.19c5.4.48 9.27.6 19.38-.92m-.06.26c-.56.42-1.38.34-2.8-.01m2.94.38c-1.1-.11-2.04-.08-2.95-.29m-.66-.59c4.49.51 7.27.46 11.19 1.77m-10.13-.57c2.71-.19 6.63-.42 11.79-.13" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M465.96 177.35s0 0 0 0m0 0s0 0 0 0m2.55 9.62c1.2-2.51 3.26-3.28 5.08-6.26m-5.75 6.38c2.6-1.92 4.34-4.63 6.17-6.54" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M473.85999999999996 180.44c-1.1 1.59-3.47 2.61-8.43 5.35m9.24-4.44c-3.33 1.02-5.74 2.12-7.98 3.91m-.37-.25c.87-1.73 1.61-2.35 1.77-3.64m-1.91 3.67c.8-1.22 1-2.14 2.26-4.04m-.2.13c-.49-1.02-.73-1.47-2.01-3.94m2.24 3.95c-.7-.8-1.27-1.82-2.39-3.99m.36-.92c1.27 2.27 4.12 2.4 8.63 5.22m-9.21-4.05c3.48 1.04 5.78 1.87 8.63 3.44" pointer-events="all"/><path fill="none" stroke="none" d="M208 181h31.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M245.76 181l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M208.65 182.94c6.7-3.29 15.64-.98 32.67-2.86m-34.13 1.54c10.56-1.12 19.91-1.51 32.4.36" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M238.05 176.66s0 0 0 0m0 0s0 0 0 0m2.69 9.54c1.06-1.75 2.52-2.78 4.57-5.92m-5.06 6.05c1.13-1.25 2.7-3.61 5.43-6.28" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M245.8 181.42c-1.67-.02-3.83.86-8.65 3.69m8.61-4.32c-1.94.78-3.52 2.31-7.96 4.59m.19-.48c.2-.86.51-1.69 1.76-4.25m-2.12 4.31c.59-1.03 1.01-1.8 2.27-4.12m-.22.53c-.43-1.59-1.37-2.11-1.62-4.42m1.87 4.26c-.71-.86-1.11-1.99-2.21-4.4m.5.46c1.96 1.7 5.15 2.92 7.96 3.6m-8.51-4.32c1.98 1.34 4.18 2.8 8.23 4.18" pointer-events="all"/><path fill="none" stroke="none" d="M29.5 151H208v60H29.5z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M29.8 150.66s0 0 0 0m0 0s0 0 0 0m-.44 11.46c1.97-.98 5.93-4.1 8.9-10.32m-8.91 11.53c3.45-3.61 6.54-7.07 11.06-12.49m-11.93 24.53c6.3-7.97 14.21-15.64 23.09-25.14m-22.33 25.25c4.65-6.85 10.35-11.84 21.02-24.5m-20.24 37.3c7.84-8.69 14.62-16.3 29.47-38.87M29.8 187.06c7.01-9.06 15.31-16.52 30.87-35.22m-29.39 47.58c5.34-9.9 14.83-20.92 41.18-48.09m-43.3 47.38c8.69-9.1 17-17.87 42.73-46.99m-42.06 60.23c17.37-20.46 35.69-39.96 52.74-58.84m-52.55 59.14c13.9-17.51 27.94-32.46 52.1-61.56m-43.1 61.45c16.16-17.48 31.89-36.93 53.19-62.08M39.7 211.07c13.08-14.9 25.82-29.22 53.46-60.08m-43.69 61.64c15.48-14.56 28.19-28.1 53.57-61.91m-52.91 60.11c14.63-14.31 30.57-32.76 53.79-59.35m-42.31 59.74c11.88-11.55 18.86-26.13 51.39-59.35m-52.15 59.91c13.03-14.43 26.17-29.19 53.07-61.63m-41.81 59.77c20.77-21.77 41.87-46.87 53.2-60.46M72 211.28c12.46-12.87 24.07-26.92 52.79-60.63m-41.83 59.31c10.66-13.54 24.48-27.5 50.51-60.24m-49.64 62.63c11.49-14.97 23.44-30.4 51.94-61.59m-41.36 60.02c11.54-10.45 19.51-24.55 51.88-58.74m-52.07 60.12c15.68-20.44 32.96-39.85 50.99-61.24M106 213.06c16.08-20.67 30.39-39.59 50.81-60.99m-52.67 58.44c17.57-21.1 36.39-41.84 51.93-59.84m-42.53 59.01c16-14.73 31.44-34.14 53.85-57.02m-52.23 59.66c18.18-21.79 35.71-43.39 52.25-61.08m-41.28 61.51c17.91-21.56 35.08-42.89 52.54-61.86m-53.68 61.31c15.3-18.89 31.03-35.34 52.93-62.25m-42.77 62.63c14.82-16.82 26.7-30.81 55.39-63.54m-53.62 61.8c18.66-21.39 37.37-42.62 52.46-60.03m-42.11 61.91c18.92-22.19 35.27-45.76 51.94-63.09m-51.84 62c20.82-23.22 40.25-47.27 52.82-60.69m-42.77 61.99c18.16-23.2 36.2-44.54 52.07-61.79m-52.13 59.92c20.57-23.09 40.83-47.24 52.83-59.2m-40.35 60.33c5.04-12.09 16.64-19.84 37.45-47.34m-39.28 46.41c10.34-11.99 21.42-22.87 41.65-47.46m-30.65 47.9c6.81-7.42 10.56-14.36 27.8-36.62m-28.73 35.46c10.13-11.45 21.82-23.38 30.9-35.06m-18.24 34.39c2.88-4.74 11.76-11.45 19.96-21.89m-21.31 23.83c3.97-6.43 10.76-12.69 19.93-23.46m-9.99 21.51c3.37-1.6 6.71-3.63 8.69-9.61m-7.75 10.86c2.86-3.84 5.02-7.31 8.49-10.45" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M27.97 150.76c51.37 1.2 102.21 1.08 181.36-.78m-179.75.49c53.37.57 107.79 1.05 178.64 1.48m.49-2.18c.29 18.22-2.72 33.49-.06 59.89m-1.17-58.88c.49 19.55.83 39.2.57 60.75m.12.26c-40.84.07-78.35.69-178.33.27m177.89-1.33c-67.89-1.88-138.06-.63-178.9-.13m.41 1.07c-.02-19.25.28-37.23.07-59.71m.56 58.84c-1.32-16.92-1.06-32.22-.27-59.9" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:177px;height:1px;padding-top:181px;margin-left:31px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::validate</font></div></div></div></foreignObject><text x="119" y="185" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer::Module::validate</text></switch><path fill="none" stroke="none" d="M337 91v30H118.8v21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M118.8 148.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M335.96999999999997 89.78c2.46 9.53-.6 19.88 2.17 32.76m-1.38-30.73c.96 10.61 1.05 20.79-.1 29.63m1.6-.39c-81.81-.31-163.23-2.1-220.95 1m219.76-.43c-54.22-1.35-107.74-1.74-217.75-.13m.53-1.35c-.22 7.93.18 12.98-1.93 21.34m-.03-20.21c.45 6.51.48 12.45.14 20.61" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M114.65 140.94s0 0 0 0m0 0s0 0 0 0m4.84 7.17c1.17-1.28 2.27-2.66 4.63-6.27m-5.03 6.42c.75-.79 1.55-2.29 4.59-5.94" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M119.27000000000001 148.38c-1.17-1.23-2.05-3.69-4.87-8.19m3.99 8.69c-.96-2.34-2.13-4.93-3.93-8.51m.73.19c.62.47 2.51 1.66 3.76 2.02m-4.33-1.93c.86.42 1.93 1.09 4.27 2.24m-.22-.41c1.53-.59 2.7-1.45 3.87-2m-3.61 2.11c.51-.49 1.55-.86 3.98-1.92m.63-.39c-2.49 3.22-2.42 5.94-4.7 7.77m4.18-7.69c-1.17 2.46-1.61 3.62-4.16 8.02" pointer-events="all"/><path fill="none" stroke="none" d="M223 271h357v60H223z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M223.05 270.94s0 0 0 0m0 0s0 0 0 0m-1.16 12.59c4.07-6.41 10.24-8.94 12.03-12.73m-10.35 12.33c2.95-4.54 6.74-7.81 9.79-12.06m-10.32 24.22c9.33-10.16 16.48-17.15 21.5-22.87m-21.52 22.64c8.31-9.59 14.4-18.14 20.42-24.39m-20.61 36.79c12.4-13.47 25.72-28.48 31.45-38.42m-30.8 38.91c10.49-13.89 22.01-27.8 30.76-37.86m-31.1 48.81c13.22-11.25 21.67-24.81 42.72-47.27m-43.44 49.07c10.65-11.94 20.16-22.69 43.61-50.77m-41.61 59.65c14.88-14.62 29.02-30.3 52.91-57.49m-52.91 58.18c19.22-22.68 40.56-46.53 50.85-59.02m-40.08 59.03c12.43-16.35 28.11-29.27 52.2-59.34m-53.82 60.38c12.66-14.21 25.31-26.41 53.78-61.03m-42.23 60.51c12.22-11.1 24.04-23.25 53.65-59.86m-54.58 60.34c16.82-17.96 32.84-36.85 52.29-61.21m-39.25 62.28c15.95-22.63 37.94-46.74 50.29-63.5m-52.06 61.99c18.54-22.01 37.87-42.89 53.05-59.74m-41.79 60.29c16.59-19.67 34.52-39.19 51.57-62.32m-52.52 63.59c19.16-23.3 36.4-44.51 53-61.65m-43.93 59.27c17.12-18.99 33.13-34.3 54.2-58.18M275.26 332c14.79-14.19 25.45-28.7 52.98-60.03m-41.89 61.49c13.61-19.96 28.21-33.94 54.59-60.27m-54.3 58.75c12.44-15.18 24.49-29.92 53.44-60.61m-40.68 58.82c10.09-13.24 22.94-29.39 52.35-59.55m-54.03 61.38c19.41-23.21 38.71-46.44 52.73-61.2m-44.24 60.02c22.13-21.58 39.02-44.55 55.56-58.58m-54.21 59.23c12.03-12.84 22.36-25.71 53.51-60.42m-40.69 61.73c14.05-17.33 24.67-31.98 50.11-60.73m-52.15 59.19c17.19-17.59 31.24-34.94 52.98-60.05m-41.14 60.79c16.03-18.26 31.87-38.28 49.71-60.16m-49.7 60.47c18.83-22.12 38.61-45.53 51.97-61.88m-40.24 62.23c12.66-19.1 25.84-34.23 49.87-59.86m-52.77 58.68c11.86-13.93 22.85-26 53.9-60.88m-43.75 60.38c20.09-18.52 35.88-39.09 53.95-61.65M351.39 332c20.16-23.08 39.4-46.96 51.79-60.05m-42.99 60.78c15.13-21.54 32.94-37.94 55.05-60.1m-54.88 58.74c18.83-20.13 35.66-41.29 53.2-59.5m-42.43 61.33c17.5-20.72 32.48-40.04 54.15-60.67m-52.98 59.22c18.82-22.4 36.62-41.98 51.35-61.47m-42.24 60.26c11.07-10.46 22.66-24.06 54.02-57.58m-52.68 58.8c10.18-11.74 20.27-24.47 52.03-61.23m-39.75 59.16c16.81-21.05 36.51-41.47 49.21-59.88m-50.98 61.33c17.97-18.95 34.45-38.32 52.62-60.2m-42.05 61.03c19.06-24.06 39.1-44.51 52.15-61.44m-52.72 59.84c16.15-19.11 32.5-36.98 53.08-58.86m-43.47 59.3c23.48-22.41 44.13-45.83 55.03-58.92m-53.03 59.43c10.82-14.13 21.84-27.77 53-59.79m-44.17 57.89c19.05-17.01 37.96-39.84 51.87-57.82m-50.83 59.36c16.35-17.86 32.9-35.78 52.53-60.68m-41.57 62.17c16.94-20.41 35.05-41.66 52.49-62.43m-53.26 61.94c17.54-18.55 33.65-37.06 53.44-61.31m-43.03 61.08c16.71-17.59 31.16-34.77 52.55-61.85m-51.16 60.47c21.17-23.48 40.88-46.51 52.07-60.53m-43.23 60.12c11.74-12.61 22.95-22.87 55.49-60.04m-53.55 60.32c15.3-15.32 29.45-32.83 52.36-59.31m-42.79 59.34c18.64-21.67 35.77-42.04 54.58-57.69m-55.11 58.77c18.53-18.93 33.7-36.69 52.85-59.69m-39.79 60.46c18.54-22.24 36.22-46.62 50.9-62.4m-52.61 62.09c10.22-12.59 22.71-26.46 53.69-61.83m-44.31 62.82c11.54-15.38 22.95-26.89 55.35-62.48m-54.41 61.42c20.33-23.84 40.7-47.36 53.58-60.97m-42.53 61.21c13.97-16.45 27.78-33.2 51.28-61.89m-51.58 62.57c11.55-14.52 23.39-27.11 53.51-61.19m-42.79 58.88c15.4-19.84 35.35-38.26 53.26-58.35m-54.1 60.15c13.18-15.33 25.75-29.33 52.43-60.68m-42.25 58.33c18.48-15.52 31.75-37.05 51.56-56.92m-49.81 58.13c19.43-22.47 37.72-44.11 50.8-60.2m-39.54 61.33c14.47-21.62 32.44-40.07 50.38-58.93m-52.16 58.7c16.09-17.82 31.27-37.17 51.76-59.1m-39.59 58.73c15.57-16.27 29.16-36.29 39.78-45.78m-40.54 45.07c14.41-17.25 30.85-35.37 40.13-46.05m-29.65 47.37c7.09-11.02 16.37-19.24 28.73-35.23m-28.86 33.74c9.07-11.53 18.85-23 30.39-34.42m-21.71 35.65c9.47-10.3 16.66-19.31 20.8-21.38m-19.63 21.38c7.26-8.15 13.82-14.79 19.41-23.1m-8.54 23.08c3.5-2.78 6.84-6.85 8.66-10.13m-8.26 10.27c1.9-3.31 3.81-5.62 8.2-10.79" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M223.85 270.19c100.14 2.84 197.97 3.47 355.21 1.69m-355.79-.41c114.06.94 229.14.89 357.14-.02m-.16-1.43c.18 18.25 1.86 35.7-.21 60.78m.74-59.82c-.78 23.59-1.42 48.23-1.33 59.9m.05-.79c-81.84 3.63-165.82 3.67-356.38.05m356.75 1.24c-129.02.7-256.93.05-357.34.03m1.49-2.02c-1.87-9.71.7-23.19-2.62-56.64m1.19 58.05c-.08-14.4.68-27.77-.05-59.91" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:355px;height:1px;padding-top:301px;margin-left:224px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><div style="font-size:18px"><font face="Patrick Hand" style="font-size:18px">wasmer_compiler::ModuleEnvironment::translate</font></div></div></div></div></foreignObject><text x="402" y="305" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer_compiler::ModuleEnvironment::translate</text></switch><path fill="none" stroke="none" d="M539.75 211l.05 30H401.5v21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M401.5 268.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M541.44 210.43c-1.97 6.39-1.95 13.67-2.79 30.28m.61-29.65c-.61 9.51.83 20.91.9 30.54m1.48.38c-38.38-2.81-72.68-1.78-140.38-1.25m137.59-.46c-27.6 1.49-55.93.35-138.12.34m1.94-1.24c-3.06 5.66-.57 11.95.02 24.22m-.45-23.27c.04 8.43-1.37 15.56-.04 22.47" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M397.41 260.86s0 0 0 0m0 0s0 0 0 0m4.1 7.58c2.43-1.68 3.4-4.87 6-6.46m-5.98 6.52c1.09-2.11 3.12-3.43 5.57-6.49" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M402.03 268.03000000000003c-2.44-2.1-2.38-3.93-4-6.9m3.8 7.33c-1.37-2.32-3.36-5.19-4.02-7.69m-.58.21c1.66.19 2.62.98 4.67 1.81m-4.38-1.83c1.4.46 2.74 1.29 3.81 1.67m.25-.22c.91-.12 2.74-.56 4.12-1.89m-4.36 2.24c1.18-.32 2.04-1.14 4.14-2.05m-.37.78c-.93 1.11-2.96 3.73-3.82 7.09m4.08-7.52c-.78 1.59-1.89 3.11-3.47 7.77" pointer-events="all"/><path fill="none" stroke="none" d="M803 271v-30H666.3l-.04-21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M666.25 213.24l4.02 7.99-4.01-1.99-3.99 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M804.0500000000001 272.76c-2.65-9.81.89-16.71-1.35-32.96m.69 30.89c-1.13-6.73-1.05-13.43.32-30.02m-.67-.23c-42.81-.21-83.73 2.36-138.24 1.55m137.74-1.44c-38.41 1.81-79.31 1.32-136.7.59m-.3 1.84c-.35-6.8 1.17-15.2.94-23.86m.38 21.73c-.29-7.47-1.42-15.59-.16-22.13" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M666.04 213.48s0 0 0 0m0 0s0 0 0 0m3.37 8.3c.29-.34.51-.66.74-.72m-.66.72c.09-.23.3-.35.61-.79" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M665.9100000000001 214.13c.75 1.55 2.48 2.4 4.46 7.04m-3.87-8c1.38 3.09 2.35 5.91 3.97 7.83m.1.66c-1.7-1.23-2.86-1.45-4.23-2.74m4.05 2.21c-1.06-.29-1.62-.62-4.21-1.7m.26-.12c-.72.87-1.7 1.31-3.75 2.16m3.49-2.37c-.98.76-1.82 1.07-3.78 2.33m.7.26c.45-2.51.47-3.49 3.72-9.26m-4.4 9.02c.99-3.24 2.42-5.52 3.5-7.91" pointer-events="all"/><path fill="none" stroke="none" d="M623 271h360v60H623z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M622.77 271.26s0 0 0 0m0 0s0 0 0 0m.66 11.27c4.33-3.02 7.39-5.75 8.77-11.95m-8.6 13.13c2.46-5.47 6.96-10.14 10.12-13.23M623.4 296c8.86-8.36 15.25-18.66 19.92-24.59m-20.7 24.01c5.28-7.07 11.57-12.36 21.82-24.27m-21.68 34.77c9.42-10.41 22.48-25.01 32.13-36.46m-32.59 38.65c9.19-10.29 19.15-20.85 33.34-36.98m-33.52 46.53c15.79-16.18 30.82-31.88 42.97-44.95m-42.27 47.25c11.32-12.44 21.74-24.82 43.17-49.03m-41.17 61.06c8.4-11.72 22.35-27.58 53.08-60.13m-55.27 59.22c18.05-18.83 34.19-37.51 53.59-60.48m-43.05 62.62c11.51-16.27 23.14-30.68 55.21-60.62m-55.12 59.75c12.23-12.56 22.8-24.66 54.09-61.98m-40.77 59.38c19.45-19.71 40.88-46.55 49.74-57.81m-52.25 58.57c18.22-18.55 36.32-37.88 52.79-59.07m-42.18 58.82c17.51-18.69 36.01-40.25 53.17-59.64m-51.97 60.07c13.55-16.56 28.58-33.48 51.04-59.86m-42.47 61.32c17.19-18.14 31.51-35.57 52.64-62.69m-50.41 61.85c12.89-16.07 26.8-31.83 51.88-61.16m-40.71 59.73c18.37-21.49 40.56-46.15 49.89-60.13m-51.93 61.18c12.9-13.41 26.25-29.01 54.03-60.48m-44.42 60.96c20.88-21.46 34.12-39.32 53.3-61.79M688.19 331c18.5-20.95 35.8-41.1 51.88-59.99m-44.13 59.5c21.37-21.88 43.26-47.33 53.87-58.1m-51.37 58.31c10.75-12.29 22.03-25.93 51.52-60.55m-39.94 61.02c10.96-13.4 22.81-31.86 49.25-60.14m-50.17 60.81c14.36-15.97 27.99-32.18 52.75-61.76m-44.09 61.95c10.19-14.16 22.27-26.13 55.67-59.6m-54.6 59.06c17.07-19.33 33.43-39.59 53.02-59.84m-43.51 58.95c13.54-12.67 22.85-22.66 52.03-60.79m-49.79 61.15c19.02-23.9 39.85-47.48 51.49-59.74m-42.38 60.57c11.62-13.07 21.62-27.76 51.82-60.65m-51.72 59.36c13.4-13.67 26.47-27.83 53-59.06m-40.74 60.76c16.57-20.5 29.88-36.03 51.17-60.75m-52.66 58.75c19.47-21.73 39.44-43.04 52.08-60.14m-41.62 63.23c9.59-13.36 24.89-27.78 53.49-64.04m-53.32 62.24c11.15-15.01 24.46-29.17 53.6-60.72m-45.07 59.94c13.24-12.78 28.34-27.1 54.2-59.06M771 330.98c18.59-20.32 36.77-40.65 53.5-60.21m-41.94 60.47c16.06-21.5 35.44-39.2 51.26-59.53m-51.24 60.03c18.46-22.04 36.25-42 51.33-61.26m-40.47 59.58c12.93-15.16 26.82-29.25 50.65-60.75m-51.52 61.87c17.21-18.9 34.43-38.11 53.74-60.18m-43.58 61c16.19-16.91 31.39-35.17 53.62-59.43m-53.1 59.98c11.61-14.83 22.55-28.69 53.66-60.71m-42 59.98c17.54-21.88 36.51-44.71 52.04-60.86m-52.27 60.82c19.03-23.45 40.96-47.66 51.77-61.29m-42.29 60.16c21.19-22.77 39.17-42.39 52.44-59.01m-51.7 60.63c12.86-15.8 23.31-29.22 52.41-61.03m-41.28 61.06c10.26-13.81 21.38-26.49 51.93-60.41m-51.84 59.86c14.44-18.34 29.72-37.53 51.59-59.76m-42.67 59.71c13.11-16.38 26.44-28.02 54.26-60.29m-52.39 59.63c18.27-22.58 37.29-44.49 51.05-59.97m-41.67 60.16c15.38-17.73 31.53-38.17 53.82-58.44m-53.72 58.08c16.09-18.66 32.41-36.53 52.19-58.83m-41.47 61.07c14.76-21.49 34.89-40.19 51.62-63.32m-52.33 60.96c20.4-22.78 41.1-45 54.09-60.24m-43.78 61.26c14.62-13.77 26.51-32.61 55.27-59.97m-54.27 59.9c16.5-19.06 34.71-38.59 53.54-60.74m-43.53 59.29c15.04-13.62 24.09-28.85 55.03-58.11m-54.55 58.97c12.58-12.22 22.44-25.19 53-59.59m-41.31 61.02c15.09-22 33.82-39.23 51.79-60.04m-52.65 59.05c18.65-21.76 37.86-42.91 52.63-60.72m-39.94 61.13c16.89-22.92 32.91-41.16 49.04-60.71m-51.9 60.33c21.39-22.91 39.65-43.6 54.26-60.76m-41.11 60.75c9.08-13.88 23.1-26.89 48.91-59.68m-50.91 58.66c14.32-16.44 28.5-31.84 53.44-59.01m-41.89 60.95c21.03-25.28 40.29-48.11 52.17-61.14m-53.07 60.07c18.76-20.67 35.78-41.89 53.37-61.48m-43.26 60.4c10.74-10.2 19.65-19.72 43.03-45.09m-42.77 46.33c11.17-11.63 20.14-21.34 41.81-48.01m-31.59 47.97c8.68-12.72 17.19-20.04 31.31-34.54m-30.97 34.65c7.15-8.38 13.17-15.48 31.14-35.56m-19.26 33.68c7.12-6.22 11.22-11.99 20.97-22.81m-21.24 23.36c5.68-5.28 11.44-12.39 21.02-23.46m-10.06 23.6c1.74-2.11 6.85-8.52 7.93-9.27m-8.69 9.91c2.84-3.07 3.96-4.61 9.51-10.65" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M623.12 272.07c100.23-2.31 201.31-.99 359.71-1.22m-359.34.15c123.41-1.96 246.91-1.12 358.91.29m.38-1.02c.07 18.28 2.44 37.91-.34 61.66m.64-60.75c.75 15.64-.86 31.27.78 59.05m-1.95 1c-88.21 1.07-177.71.77-358.9-.07m359.89-.51c-120.88-1.05-241.91-.61-360.4.15m-1.2.31c4.27-16.16 1.11-33.15 2.69-61.56m-.18 61.25c-.85-11.88.42-23.32.17-59.92" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:358px;height:1px;padding-top:301px;margin-left:624px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Indie Flower;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><div style="font-size:18px"><font face="Patrick Hand" style="font-size:18px">wasmer_compiler::Compiler::compile_module</font></div></div></div></div></foreignObject><text x="803" y="305" fill="#000" font-family="Indie Flower" font-size="12" text-anchor="middle">wasmer_compiler::Compiler::compile_module</text></switch><path fill="none" stroke="none" d="M580 301h34.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M620.76 301l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M579.37 299.59000000000003c13.34 1.19 24.94-.01 34.66 2.67m-33.08-1.38c9.14.92 19.8.56 34.34-.74" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M612.75 297.01s0 0 0 0m0 0s0 0 0 0m1.95 9.93c2.44-2.25 3.77-5.1 5.94-6.1m-6.02 6.15c2.27-2.57 4.27-4.75 5.61-6.03" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M620.85 301.08c-2.91.74-4.1 2.19-7.77 3.18m7.52-3c-1.61.44-4.2 1.34-8.03 3.63m-.24.43c1.26-1.01 1.58-2.08 2.67-4.46m-2.17 3.97c.9-1.34 1.33-2.73 1.8-3.8m.26.28c-1.14-1.11-1.47-2.14-2.27-4.31m2.02 3.93c-.13-.7-.78-1.86-2.05-4.08m-.51-.15c3.86 1.31 6.92 4.14 8.86 4.7m-8.62-4.14c2.74 1.31 5.51 2.14 8.03 3.92" pointer-events="all"/></svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.png b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.png
new file mode 100644
index 0000000..69e01ed
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.png differ
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.svg b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.svg
new file mode 100644
index 0000000..a3d049d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_instantiation.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1462" height="462" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2020-07-20T09:21:57.702Z&quot; agent=&quot;5.0 (Macintosh)&quot; version=&quot;13.4.8&quot; etag=&quot;3Sb7SC4d8sVG8JZU-d_n&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;QskjrULfAQqA6fvHmlu-&quot;&gt;5VptT9swEP41/UgV570fodAxadOQmLTxqTLJNfFw7MxxabtfPyexk6YBLRqUFiqQmnvsu55999zFVkfONFt/EjhPv/IY6Mi24vXIuRzZth0ElvookU2NuL5fA4kgcQ2hFrglf0CDWi9ZkhiKzkTJOZUk74IRZwwi2cGwEHzVnbbgtPutOU6gB9xGmPbRHySWaY2GdtDi10CS1Hwz8if1SIbNZL2SIsUxX3UgWMsZZ1K7+C0HpsBbzIqRd5VKWS7xfGTP1P+inDZOOE8o4JwU44hnCo4KNWW2wBmh5f7WFi4qC8H0BktBogdl8hqz+D9NNkYuKiPKbedq5EwF57J+ytZToGXMTTjrtc2eGW32UwCTQxTsWuER06UOycj2qVK9KBdQ7qvc6GD5v5fcDJwVVSqptVoozNftYJkEOOoq7OzU1lw/KT9XuMhAlNac88+skJhFUEsMVsYdvaVGRwe9cc4WfMliKFdllSZTIuE2rz1ZKe4oLJUZVRJSj8UDyCg1ghT8AaacclGZci4nluvZzYhJzBJZEEq3Zs4s9Wc37jyCkLB+NhKoia/iM/AMpNioKVrhzPd13mouI9cAq5YaKNRYukULMw/rVE8a423k1YMO/tOJ4BxZIqhat6Q6DUiVFJJgCSeUDoHXTQcv7KdDU8hfOx3c3o5CrCq3FrmQKU84w/SqRS+6e97O+cJ5rjf3F0i50W0ILyXvxgHWRP4s1ceelu62Ri7X2nIlbIzA1Mq2lErxbnusVaskoxfjIq18fVEC6EYT73S5gi+Fzn1TYSUWCcgO1wYkgwCKJXnsWn9JXL2jofkcWEKYZvi5kETZkSfM9zDcKf+B9QTfQ3/s7Yfx/mEZb38gyjt9ynuHo3xwnJQXUHD6aNq9luYky1UaFadDe+S6/ni31Yd2n/qOg/ZF/fDdUP/NKOz1KRwMju2rU3hynBT+vmT4nkJRS5EA1bDnGWRcEDglCluBNx7EYGc//DWHgE5+vD2j98nHoM/HyeH4iNA7IqSsoZOhY2C5A7iIwn11U/TUndrHYuOkz0Y0PFCvT0fnsC8w2+8vzSvLv44uQefsgo7l7ILcozq8GHfeRaVNKL/H9IRKrTP07GLv6ZoSPXWf9bFqrSmsnWLrHpCR/off8j3UO616w0lVtAyBPG+HPYGzw4o67FpvJ0qNI8MCF5xWlyxrr3YL2fsmadgn6QFv+Y07x9Y1u9f8C8JIkc7b237C2en0Ts8bcN/vuK/TOJXY/qagrh3tD0qcq78=&lt;/diagram&gt;&lt;/mxfile&gt;" version="1.1" viewBox="-.5 -.5 1462 462"><defs/><defs><style type="text/css">@import url(https://fonts.googleapis.com/css?family=Open+Sans);@import url(https://fonts.googleapis.com/css?family=Patrick+Hand);</style></defs><path fill="none" stroke="none" d="M807 21h180v60H807z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M807.19 20.78s0 0 0 0m0 0s0 0 0 0m-.3 11.57c3.33-2.06 6.43-4.89 10.26-11.65m-10.57 12.58c4.07-3.24 6.46-7.14 10.5-12.09m-10.95 25.94c5.16-9.89 13.01-13.91 24.03-27.05m-22.62 25.56c4.62-5.66 7.97-11.12 19.96-24.06m-19.78 34.61c9.67-9.32 17.55-21 32.31-35.49m-33.54 36.01c12.52-11.03 22.41-24.48 31.99-36.69M806.47 70.4c12.6-12.44 19.71-25.31 44.46-50.91m-44.06 50.58c13.77-14.27 26.65-30.2 43.26-49.99m-42.29 59.99c18.31-19.51 39.14-42.79 49.92-57.26m-49.62 57.96c10.48-11.16 20.98-24.01 51.47-59.78m-43.54 62.07c23.44-25.72 41.86-47.39 55.02-60.02m-53.81 58.24c16.54-16.69 31.14-34.33 52.11-59.35m-40.32 58.75c9.55-11.25 23.11-26.99 50.46-57.94m-50.41 58.19c12.68-16.69 28.56-33.61 51.98-59.22m-40.85 59.37c12.03-14.5 24.84-29.83 50.49-57.83m-51.12 57.62c19.94-22.91 40.52-47.99 52.35-59.9m-41.53 61.97c15.45-22.08 31.92-39.63 50.73-61.89M849.2 81.32c15.21-16.81 27.86-31.29 52.83-59.18M862.25 83.1c13.4-16.67 26.38-34.55 52.17-63.66m-53.88 61.33c11.03-12.75 21.94-25.75 51.32-60.22m-41.44 59.64c17.78-21.22 36.83-42.39 53.2-60.09M870.4 81.16c11.68-12.31 24.04-27.08 54.05-59.45m-44.2 60.53c14.19-12.02 24.28-24.19 53.55-59.47m-52.36 58.28c19.76-23.1 41.12-46.6 53.55-60.6m-41.08 61.87c8.17-14.3 20.93-29.16 50.35-61.5m-52.23 60.03c17.33-18.41 35.25-39.75 52.66-60.76m-39.82 62.07c17.65-22.36 34.65-45.29 50.09-61.22m-52.93 61.03c22.05-25.25 42.94-49.77 52.55-60.28m-42.34 58.1c18.2-14.47 31.72-33.17 52.64-57.09m-52.21 59.33c17.15-18.61 31.34-34.5 52.67-60.88m-42.17 59.97c19.8-22.07 41.13-42.42 55.25-58.9m-54.13 59.82c16.73-18.65 32.8-37.21 52.83-61.55M935.2 79.61c14.48-13.94 31.72-34.2 52.54-59.83M934.2 81.57c15.94-19.04 34.3-39.67 53.1-60.6M946.65 79.9c14.97-16.95 31.37-36.82 42.01-48.38m-44.19 50.45c11.09-11.96 20.26-23.56 43.41-49.58m-32.89 48.99c7.75-7.69 16.43-16.72 30.87-35.78m-30.1 35.94c11.71-13.85 21.91-26.78 30.32-34.76m-18.85 35.1c5.4-7.66 11.71-14.3 19.19-22.88m-19.3 21.7c4.98-6.68 11.73-12.79 20.16-21.89m-9.26 22.42c2.84-4.06 6.86-8.55 10.27-11.52m-10.62 11.51c2.18-2.57 5.73-6.95 9.68-11.68" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M808.19 20.23c50.41.83 102.4 1.05 179.09 2.24m-179.55-2.36c57.52-.05 116.66.92 179.46.35m-1.97 1.69c.47 13.1 1.25 23.06 1.28 58.47m-.19-60.5c.19 22.41-.43 44.71 1.23 61.47m-.1-.23c-50.57.48-103.94-1.74-180.52.93m180.43-.82c-47.32 1.47-95.12 1.39-181.25-.28m2.41 1.12c-2.22-21.49-3.63-39.94-.44-62.81m-1.78 61.54c1.37-14.46-.5-29.1.47-59.55" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:178px;height:1px;padding-top:51px;margin-left:808px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Instance::new</font></div></div></div></foreignObject><text x="897" y="55" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer::Instance::new</text></switch><path fill="none" stroke="none" d="M792 141h210v60H792z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M791.8 141.23s0 0 0 0m0 0s0 0 0 0m1.52 13.44c2.48-7.48 7.79-9.73 10.2-14.06m-12.02 13.38c3.82-4.17 6.91-7.87 10.83-13.25m-10.29 26.48c8.02-7.46 10.94-14.6 21.79-28.03m-21.15 26.19c5.65-8.24 13.26-15.12 20.71-25.19m-20.85 38.59c6.75-10.32 18.41-21.64 32.99-37.53m-33.34 35.76c7.23-9.46 15.58-17.58 30.57-35.82m-33.08 48.85c15.39-13.63 29.31-28.9 45.36-49.34m-43.54 49.52c14.61-16.96 28.56-32.72 43.47-49.01m-41.19 60.64c15.83-20.62 32.48-36.07 50.1-59.89m-51.99 58.98c17.81-21.37 35.61-41.12 52.23-59.23m-40.52 59.65c19.71-20.58 38.09-43.73 50.03-61.28m-51.12 61.6c14.12-17.03 28.63-32.57 52.43-60.3m-42.87 61.63c20.79-23.87 43.96-50.3 54.55-63.89m-52.08 62.41c16.08-19.28 32.04-36.63 52.48-61.07m-43.78 61.91c13.59-14.56 22.92-27.34 53.38-61.98m-53.03 61.7c16.94-20.41 33.22-39.53 52.34-62.01m-42.86 59.74c15.05-16.79 32.13-32.5 52.44-59m-50.52 61.29c19.67-23.93 39.72-47.31 52.38-61.46m-41.22 62.18c18.65-23.17 33.82-42.4 51.86-61.6m-52.03 60.6c11.13-13.97 22.74-26.06 52.37-60.67m-43.97 61.11c13.35-14.64 24.54-27.62 55.91-61.61m-53.45 59.68c17.73-18.07 33.35-38.24 52.5-58.81m-43.67 61.2c17.48-20.66 36.61-42.13 55.08-62.03m-53.71 61.22c13.1-15.13 24.44-29.04 52.35-61.96m-40.79 62.88c15.5-22.2 29.71-36.62 52.05-63.06m-52.2 61.6c19.67-23.53 38.89-46.21 51.91-60.09m-43.22 60.29c17.79-19.2 32.24-35.44 51.65-60.1M887.4 200.4c12.65-11.88 23.36-25.23 52.6-60.09m-40.71 62.26c18.2-24.95 39.69-45.69 50.96-61.71m-52.3 60.01c17.34-18.39 32.58-36.45 54.19-60.74m-42.31 60.3c13.56-16.03 31.7-35.94 53.19-59.68m-53.07 60.5c18.27-19.43 34.41-40.09 51.92-59.73m-43.56 60.26c15.13-17.17 30.06-32.59 54.42-59.69m-53.14 60.58c16.68-19.92 33.97-38.21 52.06-61.44m-43.29 59.37c17.21-16.2 30.95-34.53 54.3-59.63m-52.48 61.27c18.24-19.49 34.71-40.85 51.66-60.12m-39.37 60.92c18.13-21.51 34.54-43.49 52.57-63.08m-53.69 60.94c18.53-21.01 38.98-43.74 52.11-60.41m-44.19 62.22c23.26-24.8 42.05-49.55 51.92-61.06m-49.36 59.16c13.33-13.83 26.87-30.14 50.96-58.15m-41.22 59.08c10.88-12.82 21.43-25.12 43.33-48.68m-42.91 48.33c11.82-12.85 23.22-27.66 40.24-48m-29.14 47.74c6.46-7.94 15.01-13.38 30.99-34.17m-32.14 34.73c11.72-13.49 23.5-26.9 30.46-35.41m-17.34 34.75c3.96-6.31 10.54-11.18 16.81-22.85m-19.16 23.55c5.61-5.15 10.55-10.66 20.02-23.67m-8.1 24.53c2.37-3.69 4.3-8.93 7.52-12.61m-7.91 11.05c1.79-1.11 3.83-3.73 8.83-9.62" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M792.05 139.41c57.99 2.38 118.2 3.55 211.26 1.47m-212.12.45c74.73-.31 147.86.04 211.35-1.02m1.22 2.09c-.85 13.13-3.38 25.27-2.87 59.35m1.72-61.43c-1.08 14.46-.67 27.74-.66 60.62m-.4-1.58c-62.55.31-126.42 1.4-209.77.66m210.58.38c-51.17.25-100.97-.06-211.21-.07m-.36-.31c-.08-11.94.78-21.89.87-59.72m.85 60.73c-1.4-11.93-.76-24.64-1.31-59.55" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:208px;height:1px;padding-top:171px;margin-left:793px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::instantiate</font></div></div></div></foreignObject><text x="897" y="175" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer::Module::instantiate</text></switch><path fill="none" stroke="none" d="M897 81v51.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M897 138.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M896.23 81.95c.38 15.04-.39 33.37 1.62 51.89m-1.23-53.36c.46 15.26.54 30.39.32 52.78" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M892.8 130.98s0 0 0 0m0 0s0 0 0 0m3.55 6.82c2.96-1.14 4.5-4.23 6.29-6.22m-5.94 7c2.15-2.73 4.54-5.26 6.14-7.09" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M896.5 138.4c-1.75-3.12-3.32-5.06-4.25-7.36m4.71 7.63c-.67-1.73-2.01-3.76-3.98-8.08m.25-.07c.92.96 2.24 1.79 4.06 2.16m-4.28-1.99c.86.76 2.13.99 3.77 2.22m.49-.41c1.07-.18 1.99-.97 3.73-1.61m-3.9 1.94c1.04-.78 2.46-1.33 3.99-2.27m-.7-.15c-1.22 2.37-2.67 4.78-3.16 7.95m3.71-8.02c-1.47 3.23-2.22 5.91-4.08 8.71" pointer-events="all"/><path fill="none" stroke="none" d="M587 261h286.5v60H587z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M586.84 261.19s0 0 0 0m0 0s0 0 0 0m-.03 13.15c5.44-6.14 8.55-10.51 12.06-12.81m-11.97 11.83c3.48-3.36 5.05-6.67 10.11-11.8m-11.72 22.2c7.5-4.03 13.3-14.47 22.99-22.04m-21.27 22.56c4.38-4.63 8.32-10.08 21.57-22.74m-22.8 36.91c12.27-12.09 19.07-24.9 34.27-39.03m-33.27 38.77c8.46-8.76 16.52-18.42 31.78-37.28M586 308.17c14.73-14.87 30.85-34.12 45.13-46.75m-44.23 48.13c13.42-13.36 25.44-27.82 42.3-49.44m-41.46 59.75c20.19-21.08 38.38-44.91 53.87-58.04m-53.92 59.71c14.77-17.36 28.22-33.93 52.67-61.27m-44.01 62.58c12.13-14.49 24.94-26.39 56.26-61.22m-53.79 59.71c17.44-22.58 37.51-43.99 51.3-61.26m-40.77 60.87c14.04-16.88 26.74-33 52.49-58.84m-52.83 59.48c16.86-18.43 33.15-37.27 51.46-59.96m-40.29 59.82c18.41-18.55 33.03-39.6 53.01-61.16m-53.15 61.44c9.96-13.94 19.55-24.67 52.05-60.59m-42.12 60.77c11.7-16.36 22.71-28.11 54.32-59.53m-54.71 59.74c19.85-24.16 40.25-46.21 52.41-61.37m-42.91 58.8c20.34-21.97 39.59-42.35 52.95-60.34m-51.13 62.54c14.6-17.23 29.65-35.16 51.4-60.43m-39.65 61.37c10.6-18.15 24.85-32.03 51.54-63.06m-52.56 61.47c20.63-24.48 41.94-48.7 52.32-60.91m-43.78 60.05c12.84-10.5 21.42-23.49 52.77-58.22m-51.48 59.86c14.81-16.79 30.55-35.15 53.92-61.91m-42.33 61.08c11.89-15.63 30.03-31.77 53.39-61.38m-53.59 62.15c18.14-22.86 38.93-44.69 51.43-61.48m-40.09 59.11c10.39-13.53 26.26-27.29 50.19-59.23m-51.63 60.24c15.61-17.73 32.31-36.8 53.58-59.67m-42.81 61.81c20.24-26.41 38.5-47.23 54.04-63.46m-54.23 62.77c12.38-13.68 21.94-25.47 53.54-61.48m-43.96 60.3c18.77-19.63 39.14-42.74 52.54-61.61m-52.42 62.29c15.67-16.44 30-33.08 54.6-60.64m-41.24 62.77c18.74-25.76 36.98-46.33 48.71-63.24m-51.18 60.77c13.58-14.67 27.13-30.33 53.91-58.81m-44.12 59.92c20.41-19.74 36.8-39.69 53.58-61.52m-51.82 61.55c9.52-13.16 20.59-25.54 52.01-60.19m-40.87 59.64c13.22-16.34 26.81-29 49.61-59.66m-50.33 59.07c19.59-24.5 40.3-47.8 51.3-58.87m-39.53 60.84c9.45-15.46 24.75-29.84 51.98-60.7m-52.45 59.08c13.21-16.58 27.84-32.91 52.31-59.72m-43.65 61.16c14.95-20.57 30.35-37.6 53.93-60.7m-51.86 59.11c17.07-18.93 33.74-39.87 52.02-60.55m-43.8 61.89c15.19-17.8 29.21-32.86 52.77-62.84m-52.04 60.92c17.69-19.96 35.48-39.08 52.88-59.13m-40.69 58.56c18.52-17.96 33.58-39.9 51.87-59.3m-53.13 59.78c17.57-18.98 33.12-38.5 53.82-60.25m-41.42 62.7c11.14-14.06 25.08-30.31 50.67-61.39m-51.73 60.84c12.01-17.07 25.13-30.05 51.23-60.59m-40.52 58.36c9.77-10.75 20.39-24.98 50.65-57.42m-51.77 58.47c12.91-12.79 23.6-27.08 53.97-59.87m-44.17 61.9c16.6-21.01 33.99-40.93 53.37-62.8m-52.36 60.6c18.82-21.37 35.85-41.18 52.38-59.73m-39.41 60.56c7.48-14.68 20.39-24.06 50.46-62m-52.62 62.05c14.51-16.7 27.92-33.77 53.25-60.81m-44.13 60.15c18.17-18.54 35.54-38.17 49-53.25m-46.95 53.64c15.65-18.49 32.19-37.52 48.27-56.42m-35.82 56.42c7.1-11.06 14.08-20.46 33.42-43.64m-35.7 42.52c11.82-10.99 21.6-23.94 36.84-42.61m-27.48 41.76c6.52-5.15 15.72-13.5 27.43-27.61m-25.01 29.11c4.5-6.65 11.1-12.93 25.11-31.71m-14.78 30.39c2.78-2.27 8.6-7.84 14.91-17.86m-14.49 19.29c3.29-5.19 8.67-9.88 15.71-18.23" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M586.18 260.55c81.62 1.79 162.57.03 287.34.82m-285.91-.22c62.35 1.12 125.06 2.54 285.77-.32m-.31-.91c1.42 13.78-1.9 25.85 1.92 62.7m-2.34-61.88c1.06 19.4-.01 40.49 1.75 59.95m-1.92 1.41c-70.27-3.18-141.08-2.22-285.36-2.6m286.12 1.62c-88.77.55-177.4.3-286.47 0m-.83.71c-.47-17.96 2.27-36.92 1.74-60.07m-1.38 59.23c1.02-12.44.79-24.76 1.6-59.77" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:285px;height:1px;padding-top:291px;margin-left:588px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Artifact::instantiate</font></div></div></div></foreignObject><text x="730" y="295" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Artifact::instantiate</text></switch><path fill="none" stroke="none" d="M844.5 201v30H730.3l-.04 21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M730.25 258.76l-3.98-8 3.99 2 4.01-1.99z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M842.7600000000001 200.36c1.83 10.27 2.2 17.49 1.2 29.76m.5-29.54c.18 11.12.93 20.38.13 31.08m1.38.75c-32.94-2.74-66.93-2.02-116.26-1.5m115.06.74c-40.09-1.76-81-1.13-114.74-.54m.48-.67c-.85 8.02 1.46 19.42.66 21.38M730.15 231c-.8 5.34-.63 8.89.97 21.41" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M726.04 251.02s0 0 0 0m0 0s0 0 0 0m4.54 7.94c1.97-1.88 3.95-5.45 5.93-7.73m-6.82 7.2c2.14-1.47 3.68-3.98 5.96-6.79" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M730.35 258.51c-2-3.32-2.52-5.14-3.67-8.17m3.5 8.42c-1.17-1.29-1.91-3.39-3.52-8.16m-.11.29c.25.43 1.46.79 3.99 2m-4.47-2.12c1.35.79 3.02 1.29 4.33 1.77m-.13-.12c1.15.1 2.38-.93 4.19-1.33m-4.04 1.48c.63-.45 1.9-.71 3.99-1.99m.12-.59c-2.04 3.82-2.15 6.7-3.62 8.12m2.99-7.59c-.72 2.82-2.18 4.26-3.86 7.83" pointer-events="all"/><path fill="none" stroke="none" d="M20.25 381h331.5v60H20.25z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M20.34 380.9s0 0 0 0m0 0s0 0 0 0m-1.41 11.83c5.45-2.55 8.66-7.12 12.01-12.03m-10.23 12.63c2.99-4.08 5.27-7.2 10.44-12.97m-12.36 24.25c7.23-6.46 16.48-16.45 22.06-24.52m-21.12 24.69c7.76-7.18 14.31-14.43 21.64-23.38m-23.19 36.41c10.45-8.89 17.41-17.77 32.26-38.58m-30.38 38.02c11.94-13.59 23.22-27.71 31.68-35.92M22.1 431.07c8.99-14.25 19.4-26.08 42.04-49.18m-43.72 47.07c14.26-14.06 27.36-30.34 42.52-48.46m-41.02 61.16c16.5-19.24 30.51-39.24 50.05-60.68m-50.28 60.75c9.59-12.46 21.84-25.86 51.41-60.74m-40.99 60.18c18.91-21.45 38.17-46.89 51.27-58.5m-51.09 59.08c17.02-19.88 34.99-41.19 51.61-60.21m-43.97 58.5c14.94-13.6 26.91-28.52 53.24-57.55m-51.15 58.46c17.27-20.34 35.86-41.87 52.61-60.56M50.75 443.5c15.98-18.61 35.11-41.12 55.9-61.31m-55.06 59.53c17.47-19.52 35.25-38.38 54.03-60.71m-41.44 62.54c19.01-27.14 41.12-49.14 52.03-60.64m-53.26 58.75c15.82-17.2 31.12-34.06 51.96-59.63m-40.35 58.01c11.09-12.4 26.04-30.06 52.64-58.29m-53.28 59.81c15.91-16.45 29.67-35.46 52.45-60.87m-42.18 60.84c16.67-19.65 29.55-37.41 54.25-60.58m-54.79 60.09c16.19-18.17 32.26-35.71 52.76-60.28m-43.24 60.73c20.14-18.09 37.75-40.39 54.31-60.77m-52.83 60.79c16.64-19.94 32.85-38.8 52.71-61.26m-42.03 62.09c19.22-22.48 38.81-42.19 51.08-62.95m-51.56 61.72c11.99-11.91 23.58-27 52.68-60.81m-43.49 59.33c21.03-21.39 40.85-44.54 55.75-58.11m-54.09 60.12c18.7-19.48 35.73-39.45 53.63-61.47m-41.18 61.98c10.96-15.78 26.68-30.55 52.36-60.09m-54.32 59.44c12.57-12.4 23.18-26.36 53.05-61.33m-41.43 59.87c12.29-17.33 29.25-31.73 53.83-57.63m-54.71 58.22c17.03-17.02 31.24-35.54 53.03-60.07m-41.57 60.4c19.23-20.8 34.99-44.32 53.94-58.35m-54.12 58.82c14.1-14.37 26.38-29.47 52.2-60.91m-42.09 61.62c14.73-15.39 28.47-29.2 51.37-60.7m-51.61 60.28c16.19-17.92 32.08-37.2 53.75-60.64m-42.85 61.49c18.25-24.47 38.46-44.21 53.66-62.06m-54.27 61.18c22.57-24.43 43.66-48.48 53.45-61.62m-43.23 63.05c19.66-22.49 38.74-44.99 53.22-62.65m-51.02 60.31c11-12.81 22.83-26.3 51.63-59.75m-40.38 61.58c16.37-22.75 36.45-49.53 51.36-61.58m-52.39 59.66c16.31-19.92 35.72-40.71 51.14-60.53m-39.32 61.85c8.3-15.7 21.49-28.55 50.23-60.82m-52.42 61.07c13.15-15.69 25.53-28.8 53.46-61m-43.22 59.25c16.58-17.42 33.96-38.78 52.88-61.25m-52.36 61.17c14.07-16.21 30.03-34.23 52.59-59.74m-43.55 58.96c17.29-15.81 30.3-28.85 55.24-58.57m-52.6 60.11c19.01-22.03 38.53-44.58 51.1-60.94m-40.21 59.25c13.58-16.23 27.7-29.96 50.09-59.41m-50.36 60.4c11.01-12.59 22.88-27.55 52.13-60.31M242 442.7c18.22-19.8 30.49-34.18 55.09-61.23m-53.6 59.74c15.93-18.46 32.27-39.15 53.37-61.16m-43.85 62.6c15.13-19.81 32.97-39.36 52.8-60.41M255 442.07c14.51-20.05 30.11-37.49 51.09-62.34m-42.8 59.87c17.04-16.11 34.97-35.85 54.63-60.15m-52.77 61.11c10.6-12.03 19.68-23.17 52.09-60.24m-43.05 61.25c18.32-17.78 33.61-37.86 53.53-59.33m-53.1 60.44c10.02-13.58 21.63-27.4 52.44-61.63m-42.45 60.34c16.55-18.46 29.77-33.87 52.7-60.66m-52.74 60.08c13.73-14.36 25.79-28.46 54.11-59.77m-41.78 60.4c17.86-17.93 34.25-39.06 52.15-58.27m-52.3 58.03c10.09-12.54 20.29-25.17 51.57-60.02m-42.91 61.48c12.17-14.19 27.46-28.34 50.87-58.36m-50.11 57.57c15.58-17.05 31.31-34.08 49.96-56.53M317.7 441.5c9.2-9.59 17.44-21.41 36.7-45.99m-37.86 46.82c14.05-13.99 24.61-28.86 38.97-44.99m-27.12 44.7c7.34-10.32 18.67-21.1 29.53-33.96m-29.63 34.43c7.55-11.35 16.91-19.56 28.03-33.52m-19.28 31.08c6.33-4.17 10.07-6.72 18.92-17.61m-17.28 19.19c4.81-7.23 11.17-12.26 17.89-21.43m-6.89 22.26c1.61-3.24 4.02-7.47 7.24-9.88m-7.36 8.82c1.21-1.79 2.75-3.51 6.47-7.95" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M21.45 379.89c93.62-.86 187.27-1.69 331.14.35m-332.91.39c80.04-.2 159.43-.67 332.25.05m-1.07-.51c1.3 13.81 2.68 28.06 1.77 59.59m-.43-58.82c-.21 11.44-.26 23.52-.14 59.1m.85.44c-89.31-.35-175.49.14-332.66.25m331.3-.4c-94.08.29-189.39-.12-331.55.12m.47-.9c-2.32-12.42-1.31-22.87-.95-56.99m1.25 58.43c.26-21.92.53-44.31-.18-59.79" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:330px;height:1px;padding-top:411px;margin-left:21px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::resolver::resolve_imports</font></div></div></div></foreignObject><text x="186" y="415" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::resolver::resolve_imports</text></switch><path fill="none" stroke="none" d="M658.63 321l-.03 30H186.1v21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M186.1 378.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M658.8100000000001 321.38c-.91 9.99.85 22.82.68 31.48m-1.54-31.16c.26 6.76 1 15.2-.32 28.73m.47-.31c-167.45.28-334.23.32-472.35.94m473.21-.15c-143.95 1.72-287.7 1.13-472.51.33m-2.32.35c3.19 7.43.4 16.97 1.77 23.07m.58-23.25c-.17 7.83-.85 13.94-.73 20.65" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M182.25 370.59s0 0 0 0m0 0s0 0 0 0m3.33 8.01c.81-2.05 2.1-2.55 6.33-6.5m-6.58 7.01c2.23-2.11 3.64-3.35 6.57-7.19" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M185.22 379.03c-.02-3.75-2.86-6.53-3.21-7.42m4.26 7.34c-1.36-2.55-3.02-5.84-4.32-8.51m.53.71c.94.05 1.76.56 3.97 1.87m-4.41-2.26c1.6.68 2.78 1.33 3.93 2.17m-.17.03c.76-.84 2.38-.96 4.71-2.4m-4.48 1.98c.76-.26 1.62-.73 4.18-1.8m.07.09c-.5.8-1.52 3.94-4.05 7.38m3.57-7.41c-.72 2.65-2.02 5.24-3.52 7.77" pointer-events="all"/><path fill="none" stroke="none" d="M391.5 381h333v60h-333z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M391.22 381.32s0 0 0 0m0 0s0 0 0 0m.41 10.51c2.5-2.36 2.62-3.93 8.75-11.24m-8.48 13.43c2.51-5.02 7.07-7.94 9.17-12.54m-10.1 23.19c6.06-8.42 14.34-17.49 19.82-21.49m-19.64 21.32c5.01-4.85 9.54-10.61 20.38-22.52m-18.25 34.4c3.55-5.94 10.33-14.5 28.93-36.62m-30.17 37.77c9.37-10.01 17.09-20.76 30.25-37.06m-30.05 49.46c12.56-14.36 25.58-28.36 42.29-46.86m-42.56 47.26c14.89-18.49 28.84-34.34 42.09-48.73m-40.58 58.58c10.01-12.35 23.84-28.53 50.22-59.33m-52.64 59.78c17.71-18.67 35.26-38.98 54.16-60.18m-43.96 59.76c19.18-21.37 38.39-40.29 54.27-59.77m-52.39 60.45c16.59-18.24 32.48-37.43 51.92-59.16m-41.85 60.61c11.52-13.95 22.45-27.3 52.67-62.75m-52.17 61.95c18.45-22.67 38.9-44.39 52.46-59.67m-42.16 58.9c13.55-17.62 29.19-33.58 50.8-61.46m-50.98 61.61c12.48-14.08 25.95-28.98 52.02-60.83m-42.77 60.32c18.61-20.8 37.33-40.97 53.75-57.76m-51.82 57.77c9.79-11.29 19.99-24.97 51.51-59.9m-41.79 59.22c17.55-17.84 34.68-36.85 52.33-60.23m-51.43 61.08c14.01-16.72 30.47-34.82 51.51-59.31m-42.72 58.31c19.93-21.16 39.45-42.79 52.96-58.11m-51.02 60.72c9.74-14.91 22.58-27.78 51.21-61.64m-42.7 61.39c14.13-14.65 30.29-34.17 55.84-59.32m-54.19 57.73c18.49-20.05 37.17-41.39 51.51-58.62m-41.74 61.09c10.85-13.25 25.39-28.44 52.78-60.5m-51.53 59.29c14.33-17.04 29.22-33.48 51.94-60.15m-42.9 61.55c17.17-22.22 34.44-38.68 53.32-60.97m-52.55 60c18.58-22.19 37.92-43.06 53.67-61.28m-43.55 60.14c18.96-21.21 34.64-42.02 54.68-60.71m-54.4 60.11c12.74-14.17 24.42-28.31 52.56-59.18m-39.57 58.2c7.25-10.24 21.03-24.2 51.77-58.41m-53.65 60.9c16.57-19.81 34.85-40.42 52.13-60.26m-42.56 60.78c19.71-19.83 32.99-42.31 55.16-61.44m-55.05 60.85c13.41-16.07 26.42-28.6 52.49-61m-40.07 61.31c18.34-22.06 35.93-41.8 53.16-59.88m-53.4 59.03c20.86-24.69 41.57-48.86 51.49-61.1m-42.82 59.34c13.99-16.53 30.32-31.27 53.7-60.44m-52.21 61.26c20.35-24.35 41.81-47.16 51.6-60.36m-41.58 60.01c14.35-16.61 30.9-31.35 51.12-57.35m-52.24 58.3c19.52-23.4 41.29-46.42 53.58-60.54m-41.74 62.76c12.48-16.87 30.75-33.31 52.79-62.45m-52.94 60.2c17.56-19.88 35.7-40.5 52.26-58.52m-40.84 59.82c15.93-20.62 34.78-43.35 51.7-62.81m-52.8 63.22c19.11-22.55 36.57-43.72 52.04-60.85m-39.76 59.92c14.66-17.93 30.35-38.71 49.9-59.19m-51.6 58.55c13.78-14.49 26.16-31.01 53.36-59.23m-43.67 59.24c15.43-17.57 31.52-35.4 51.81-59.76M592.4 442.6c15.51-19.96 32.93-38.02 52.98-61.28m-39.91 62.14c17.38-22.75 35.01-43.99 49.52-61.4m-50.94 60.33c11.12-15.33 24.16-28.98 52.29-60.76m-43.49 61.14c15.84-15.63 26.99-28.47 52.81-59.66M614.83 442c15.03-17.55 30.68-35.13 52.36-60.59m-42.31 58.63c13.49-12.85 21.78-26.5 51.14-58.8m-50.99 59.59c18.51-19.4 36.29-39.2 52.92-59.86m-43.47 61.59c17.16-18.88 30.09-32.94 55.68-61.76m-54.01 61.29c13.69-15.89 28.29-33.48 51.34-60.79m-40.38 59.29c17.91-21.16 41.71-47.54 53.24-60.15m-54.11 61.5c16.17-19.89 33.37-39.21 51.64-61.79m-41.03 62.07c16.06-20.71 34.93-39.83 52.39-60.29m-52.88 59.62c14.48-17.87 28.53-33.49 53.53-60.39m-41.21 60.96c19.15-22.62 40.62-48.43 53.31-61.18m-54.02 61.27c16.55-21.95 36.26-41.3 51.34-60.3M678.6 440.4c13.81-12.42 25.34-26.57 51.3-57.47m-52.56 58.49c13.66-14.01 24.98-26.09 50.45-57.36m-39.95 55.34c12.87-15.35 26.91-29.06 38.71-41.51M688.93 442c8.52-9.8 16.5-20.19 40.27-46.57m-30.14 47.08c12.21-12.19 23.21-25.5 30.02-34.66m-29.23 34.28c8.78-12.5 18.73-23.15 28.32-32.37m-17.63 33.23c5.29-6.67 7.92-11.42 17.51-20.17m-18.85 17.7c8.2-5.53 14.02-14.12 18.91-20.62m-7.59 22.17c2.44-3.79 4.33-7.41 8.3-9.09m-8.18 7.81c2.7-2.13 4.67-4.31 7.64-8.17" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M391.92 381.9c93.25-1.64 189.88-1.72 331.52-.03m-332.27-.38c86.89.1 174.87-.76 333.79-.97m-1.82-.1c1.19 13.84 3.26 30.27 1.63 60.47m-.52-59.75c-.68 15.48.29 32.56-.03 60.25m.79.3c-92.21-3.08-185.84-2.95-333.62.13m332.95-.91c-87.26 1.72-173.02 1.13-333.13.25m1.79.11c-.18-18.88-.9-32.83.37-61.92m-2.13 61.64c.29-19.4-.93-39.86.04-59.8" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:331px;height:1px;padding-top:411px;margin-left:393px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Tunables::create_memories</font></div></div></div></foreignObject><text x="558" y="415" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Tunables::create_memories</text></switch><path fill="none" stroke="none" d="M351.75 411h20.05-.3 11.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M389.26 411l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M351.2 411.65000000000003c7.45-.61 9.37-.02 21.11.45m-20.98-1c6.76-1.08 13.33.34 20.43-.28m.06.19c-.12.01-.28-.02-.33-.01m.32 0c-.09-.01-.2.01-.31 0m-1.09.11c3.9-.75 6.06 1.16 13.89.86m-12.84-1.11c3.78.13 6.91-.28 12.08-.3" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M381.2 407.06s0 0 0 0m0 0s0 0 0 0m2.61 9.85c1.46-1.77 3.07-3.07 4.12-6.4m-4.77 6.63c1.92-2.08 3.39-3.97 5.37-6.16" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M388.43 411.09c-.86.2-3.07 2.56-6.38 4.65m7.18-4.85c-2.34 1.41-5.17 2.32-7.76 3.77m-.4.35c1.1-1.23 1.85-2.49 1.88-4.12m-1.86 4.1c.88-1.76 1.78-3.09 2.08-3.96m.06-.01c-.45-.65-.65-1.37-1.72-3.88m1.92 3.87c-.7-1.27-1.41-2.37-2.34-4.2m-.36-.07c2.03 1.65 4.74 2.65 8.18 4.76m-7.88-4.85c2.3 1.12 4.31 2.92 8.65 4.46" pointer-events="all"/><path fill="none" stroke="none" d="M763 381h318.5v60H763z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M762.9 381.11s0 0 0 0m0 0s0 0 0 0m-.97 12.39c4.85-4.58 7.17-8.77 11.89-13.66m-11.53 12.63c5.46-4.34 9.12-8.67 11.1-12.1m-10.09 24.48c9.1-6.61 16.62-19 22.24-23.21m-22.84 22.69c8.19-7.16 15.12-14.48 21.79-22.41m-19.98 37.15c11.87-14.42 20.92-30.1 30.26-39.42m-30.62 38.27c6.31-9.32 12.72-15 31.49-36.94m-33.77 48.69c15.54-15.78 31.57-36.4 43.84-50.04m-42.7 50.94c15.95-18.59 31.2-36.52 42.97-50.5m-44.14 62c11.53-14.51 21.17-26.86 54.39-61.97m-53 60.81c14.54-15.76 26.9-30.9 52.91-59.64m-40.94 61.34c15.46-20.23 30.62-40.64 53.28-61.03m-53.7 59.81c14.17-17.53 29.97-34.62 52.24-60.11m-40.4 59.49c18.76-22.56 39.3-46.61 48.76-60.7m-49.83 62.17c20.64-25.26 41.17-49.42 50.95-61.53m-39.09 61.45c11.12-17.68 23.27-31.1 49.69-61.6m-50.89 59.68c17.99-20.7 37.65-43.73 52-58.94m-42.1 60.09c14.22-19.51 29.56-33.84 51.48-58.87m-52.37 58.79c18.24-20.41 33.85-38.99 53.05-60.17m-43.22 58.43c24-24.34 43.32-48.71 56-58.17m-53.56 60.35c15.31-17.94 30.48-37.13 52.55-61.76m-41.25 61.77c11.5-14.58 19.16-28.02 51.68-59.62m-53.26 59.34c17.8-20.67 33.89-40.95 51.65-61.01m-42.15 62.07c21.42-23.29 42.62-48.12 53.36-61.87m-51.54 60.67c20.33-25.21 41.49-49.05 52.31-59.99m-43.44 58.11c18.18-17.15 34.17-35.91 54.48-58.07m-53.5 58.87c17.46-19.22 35.65-41 53.18-59.49m-42.96 62.52c13.48-15.23 24.36-33.19 51.55-64.6m-51.68 62.64c18.72-22.22 38.62-44.28 52.38-59.83m-40.58 59.05c8.47-11.62 21.62-26.39 53.01-57.34M868.78 442c14.14-14.9 26.87-31.21 52.09-61.04m-41.71 62.53c19.49-20.27 36.59-41.87 53.71-63.19m-52.59 61.58c19.32-22.59 37.66-43.29 51.22-60.44m-39.54 59.17c12.18-17.82 26.99-35.26 52.38-60.55m-53.99 60.9c12.73-12.72 24.46-26.69 52.79-59.11m-40.05 61.01c12.66-17.7 27.59-35.3 50.94-63.05m-53.19 61.77c15.83-17.38 30.87-34.38 53.24-59.56m-40.8 59.19c20.22-23.62 39.18-45.43 49.75-58.84m-52.15 59.37c23.33-24.29 43.17-47.85 53.75-61.11M924 440.1c8.67-11.36 18.32-21.92 51.71-58.55m-54.14 60.78c18.26-21.35 36.99-41.23 54.23-61.83m-43.81 62.43c19.1-23.05 42.06-45.24 54.22-63.32m-53.47 62.74c17.59-21.82 36.46-42.28 53.38-60.5m-42.36 59.79c17.04-17.47 31.05-38 53.15-60.8m-53.17 61.36c12.56-16.26 26.62-31.43 52.62-60.7m-42.29 60.6c17.93-17.39 31.94-37.58 50.91-61.13m-50.84 59.94c12.28-11.73 23.07-26.75 52.14-60.73m-41.81 61.51c17.59-19.33 36.74-41.95 52.38-60.94m-52.33 60.63c12.01-13.89 23.33-27.45 52.85-59.62m-43.61 61.02c14.69-12.15 25.33-24.82 52.96-63.38m-51.53 62.25c13.23-14.07 25.45-28.4 52.45-61.2m-43.13 61.76c22.74-23.54 43.26-50.91 54.52-62.09m-52.07 62.04c12.13-16.64 27.1-33.1 51.35-62.02m-40.76 60.66c17.14-19.02 34.37-38.84 53.48-61.2m-55.17 61.36c20.51-20.75 40.47-42.91 52.76-59.38m-42.14 59.3c14.47-14.69 26.41-27.08 52.71-59.37m-51.24 59.48c17.58-19.75 35.69-39.79 52.58-59.34m-44.36 58.09c15.19-16.69 29.21-33.54 53.61-57.73M1018 441.32c11.96-14.28 24.39-29.19 53.5-60.7m-42.25 62.55c20.75-22.96 37.28-45.8 52.06-63.92m-53.01 61.16c16.02-16.33 32.05-35.46 52.94-59.01m-40.63 61.52c9.92-14.88 24.8-31.92 45.88-58.79m-47.15 57.21c13.22-15.86 26.69-30.41 48.52-55.29m-39.93 56.21c12.05-11.67 20.38-21.86 38.62-45.49m-35.9 44.33c11.98-14.19 26.18-31.41 35.82-43.11m-24.35 43.42c5.2-7.97 13.74-18.57 23.59-29.93m-24.24 30.31c6.77-9.99 15.96-20.27 26.44-31.05m-18.03 28.37c4.6-.28 6.78-6.35 18.04-17.03m-16.37 19.81c4.87-7.85 10.8-13.65 16.15-18.9" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M762.64 381.21c91.05.23 180.64.92 318.61-.44m-318.35.22c90.66 1.75 180.03 1.87 317.97-.67m-1.19.35c1.08 17.87 3.83 32.48 1.48 61.35m-.61-60.68c.85 19.53.85 39.59.07 59.41m.75-.59c-93.19-.32-186.93-.57-318.6 0m318.61 1.35c-75.23-1.39-150.28-.79-318.72-1.01m-.88 2.49c1.97-25.33-.49-46.79 1.68-62.84m.5 60.84c-.47-18.88-1.18-35.41-1.74-59.81" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:317px;height:1px;padding-top:411px;margin-left:764px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Tunables::create_tables</font></div></div></div></foreignObject><text x="922" y="415" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Tunables::create_tables</text></switch><path fill="none" stroke="none" d="M724.5 411h20-1.5 11.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M760.76 411l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M725.6300000000001 410.81c5.6.2 13.68-1.08 19.81-1.16m-21.93 1.27c7.26.49 12.01.42 21.12.44m-.12-.39c-.41.18-.82.06-1.44-.08m1.43.1c-.61.04-1.13.01-1.47-.05m.66 1.24c2.29-1.18 4.16-1.43 11.83-1.66m-12.03-.09c2.09.11 4.27.89 10.89 1.14" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M752.88 406.86s0 0 0 0m0 0s0 0 0 0m2.42 9.94c1.35-2.24 3.33-3.19 5.67-6.04m-5.61 6.25c1.5-2.53 2.94-4.49 4.61-6.49" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M761.29 411.89c-2.09.03-4.51.75-7.95 2.74m7.79-4.06c-2.12.83-4.17 2.31-8.66 4.87m-.07-.32c.55-1.3 1.33-1.55 2.78-4.4m-2.54 4.35c.61-1.15.89-1.83 2.08-3.88m.06-.41c-.9-.93-1.7-2.37-2.11-3.41m2.29 3.57c-.68-1.24-1.56-2.7-2.07-3.79m-.95.34c2.95 1.39 5.13 2.1 8.85 2.81m-7.68-3.7c2.01 1.73 5.02 2.89 7.26 4.62" pointer-events="all"/><path fill="none" stroke="none" d="M1280.25 381l.05-30H801.9l-.02-21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M801.88 323.24l4 7.99-4-1.99-4 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M1282.1100000000001 380.55c-.97-7.89-3.42-15.91-.49-30.14m-.61 31.1c-.03-6.62.06-14.49-1.5-30.54m1.65.58c-134.06-.73-266.19-.35-479.01-1.09m478.18.52c-164.88 1.62-330.37 1.19-478.02-.07m.65-1.51c.47-6.36-2.81-13.74-1.76-20.73m-.01 22.01c.88-5.29.34-9.98 1.21-22.42" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M801.72 323.43s0 0 0 0m0 0s0 0 0 0m3.38 8.25c.27-.09.26-.3.69-.68m-.63.74c.19-.3.44-.54.63-.85" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M802.35 322.53000000000003c1.94 4.16 2.06 7.88 3.23 8.44m-4.02-7.87c1.34 2.07 2.1 4.42 4.55 7.69m-.01.04c-1.79.16-3.08-.82-4.03-1.5m3.8 1.97c-1.61-.8-3.13-1.61-4.08-2.18m-.16.08c-.88.68-2.8 1.62-3.68 2.08m3.9-1.88c-.96.25-1.58.78-4 1.71m-.07.95c1.76-3.46 1.63-4.52 4.62-8.79m-4.23 7.96c1.36-2.66 2.59-5.8 3.97-8.07" pointer-events="all"/><path fill="none" stroke="none" d="M1120.25 381h320v60h-320z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M1120.56 380.64s0 0 0 0m0 0s0 0 0 0m.2 11.82c1.9-1.19 4.32-5.58 8.62-9.67m-9.78 10.23c2.87-2.65 5.14-4.37 11.43-11.67m-10.09 24.18c8.15-8.39 14.91-16.1 20.66-24.95m-22.02 24.08c5.65-5.06 10.77-11.13 21.19-24.3m-19.7 37.89c9.15-11.03 18.19-22.59 31.59-38.21m-33.07 36.77c9.55-11.25 20.94-23.1 32.73-34.82m-30.19 46.4c5.65-10.98 15.82-20.01 40.08-47.72m-41.52 49.13c17.51-18.99 33.57-38.45 42.52-48.76m-43.69 59.41c19.54-19.69 35.5-40.3 54.56-60.62m-53.36 61.85c18.66-22.93 38.32-44.97 51.66-61.1m-41.92 60.93c15.74-16.16 30.85-34.04 52.3-62.3m-51.01 63.18c13.74-15.89 27.46-32.87 52.55-61.06m-42.94 58.36c19.5-19.1 39.16-41.76 52.85-58.65m-51.5 60.4c11.54-14.83 23.66-27.35 51.45-59.39m-42.02 57.99c12.68-12.69 21.34-23.56 52.58-57.75m-52.81 59.77c15-19.26 30.36-36.33 53.99-61.07m-41.43 61.87c9.83-18.22 21.77-30.71 49.2-59.99m-50.93 57.82c13.43-14.51 25.93-27.9 52.61-60.44m-40.67 59.64c14.76-13.72 25.76-31.36 51.69-60.12m-51.7 61.62c15.41-17.16 31.28-35.42 51.59-60.2m-41.77 59.24c14.77-16.08 29.07-33.4 50.38-61.14m-51.49 61.97c14.57-15.41 27.42-29.03 54.1-60.38m-43.61 58.75c18.21-19.86 33.96-37.92 54.89-60.43m-52.89 61.6c11.68-13.24 24.81-27.49 51.11-59.35m-43.15 59.12c20.3-20 41.74-42.32 56.18-59.63m-53.48 60.44c19.81-24.34 39.29-47.47 52.44-60.83m-41.71 61.99c19.96-22.89 38.62-46.07 52.47-62.71m-53.49 61.76c21.57-24.64 41.54-47.31 51.76-60.87m-42.29 62.45c16.47-21.06 33.59-37.86 55.33-61.96m-54.58 59.46c14.31-14.67 28.11-31.16 53.6-58.89m-41.84 60.86c14.45-18.24 28.36-35.39 51.65-59.97m-51.53 58.26c18.85-22.33 39.26-45.12 52.31-60.63m-42.53 61.56c13.87-16.86 26.2-33.25 53.61-59.66m-52.94 58.94c10.05-12.42 22.51-25.81 51.09-61.2m-42.02 62.71c21.47-25.43 40.25-48.96 52.72-62.23m-50.98 60.5c18.51-23.08 40.37-44.99 50.99-60.01m-40.78 61.04c14.75-19.67 29.83-36.49 53.8-61.22m-54.09 59.46c10.6-12.14 20.31-24.38 51.89-59.86m-42.32 59.68c18.87-18.4 36.3-37.07 52.95-60.5m-52.71 62.01c16.05-17.58 31.98-34.62 53.54-59.86m-40.53 60.86c11.21-18.21 28.36-34.07 51.65-60.2m-54.01 59.29c18.84-20.83 36.44-41.13 52.5-60.5m-42.54 60.52c14.33-14.51 27.68-33.03 55.27-59.55m-54.2 60.27c18.75-23.39 38.14-44.89 51.86-61.31m-43.48 62.03c15.99-17.9 32.31-33.5 55.92-63.07m-54.07 61.33c20.48-24.09 40.18-47.68 52.91-60.22m-41.94 61.78c19.73-25.09 37.96-44.5 52.95-62.13m-53.2 61.89c19.01-23.9 36.73-45.03 52.73-61.97m-43.31 61.92c14.5-17.62 28.64-33.8 52.39-61.37m-52.11 60.18c13.33-13.87 24.73-28.87 52.61-59.65m-42.79 60.38c20.36-22.33 39.76-44.15 52.25-60.52m-51.32 59.19c13.24-13.73 25.52-27.08 52.35-59.45m-39.22 60.7c11.5-16.08 23.17-30 51.82-59.61m-53.34 59.13c19.3-24.09 41.44-46.62 52.59-60.9m-42.82 59.02c10.59-9.46 21.53-24.17 53.76-56.99m-52.47 59.66c10.16-14.57 21.3-26.99 51.81-61.88m-42.34 62.89c18.98-23.25 37.71-46.63 53.98-63.31m-53.44 61.12c18.23-20.75 36.39-41.31 53.35-59.61m-41.48 59.03c20.26-25.21 42.43-47.76 51.75-59.55m-53.16 60.7c16.78-19.83 34.79-40.49 52.37-61.63m-40.06 60.09c15.15-15.5 31.04-33.11 47.7-54.46m-49.53 55.21c10.47-10.69 19.4-22.4 48.94-56.33m-38.39 55.97c9.67-9.94 22.19-24.09 39.06-44.6m-38.36 45.26c10.87-12.05 21.53-25.33 38.31-43.95m-27.87 42.6c11.49-11.51 20.42-22.39 25.61-29.46m-26 31.61c6.48-7.22 12.26-14.38 27.74-32.62m-15.05 30.75c1.19-5.91 6.79-10.23 15.83-19.24m-17.28 21.17c2.68-5.08 5.89-9.5 15.77-21.27m-5.36 20.59c1.14-2.92 2.68-4.73 7.05-8m-7.69 7.71c1.77-1.39 3.82-3.57 7.17-7.87" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M1119.09 380.48c93.45.48 183.31-.85 321.75-.84m-320.44.84c97.28-1.08 195.05-1.36 319.51 1.07m2.06-.63c-.24 17.9-.79 34.69-2.67 58.23m1.3-57.61c-.42 11.57.6 24.63.18 58.56m-1.33 1.32c-98.66-3.14-196.95-.97-319.55-.14m320.27-.57c-68.68 2.79-135.76 1.8-320.3.52m.44-.52c.11-15.79-.08-32.75-1.01-59.77m1.12 60.05c-1.23-16.36.57-30.97.49-59.82" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:318px;height:1px;padding-top:411px;margin-left:1121px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Tunables::create_globals</font></div></div></div></foreignObject><text x="1280" y="415" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Tunables::create_globals</text></switch><path fill="none" stroke="none" d="M1081.5 411h20-1.2 11.71" pointer-events="stroke"/><path fill="none" stroke="none" d="M1118.01 411l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M1080.3200000000002 409.97999999999996c7.76 1.4 14.01 2.24 22.54 1.21m-20.91-.46c3.77.07 8.72.51 19.86 1.17m-.36-.97c-.19-.03-.45.17-1.25.14m1.26-.07c-.48-.06-.87-.06-1.13.03m.09-.14c3.02.74 4.59.69 12.06.52m-12.33-.24c3.91-.15 7.46-.51 11.99.24" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M1109.89 407.14s0 0 0 0m0 0s0 0 0 0m2.23 10.05c1.23-2.71 3.58-4.92 5.6-5.69m-5.64 5.08c.71-.99 1.87-2.59 5.46-6.04" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M1118.1000000000001 410.91c-1.52 1.64-4.14 2.5-7.73 4.4m7.53-4.18c-2.62 1.23-5.5 2.28-7.79 4.18m.27-.08c.33-1.32.64-3.15 1.89-3.79m-2.33 3.7c.37-1.33 1.33-2.17 2.07-4.24m.07.53c-.96-1.26-1.05-2.62-2.49-4.72m2.21 4.16c-.66-1.22-1.27-2.57-1.8-3.82m.7-.59c1.99 2.74 5.43 3.16 7.73 4.42m-8.38-4.33c3.52 2.33 5.72 3.76 7.65 4.78" pointer-events="all"/><path fill="none" stroke="none" d="M873.5 291h20-1.5 11.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M909.76 291l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M873.0400000000001 289.71c6.55 1.7 15.78.1 22.21 2.24m-21.55-.62c6.57-.58 15.22.61 19.18.18m.7-.47c-.48.01-.71-.17-1.43.06m1.3-.09c-.6-.07-1.14.03-1.52-.08m.12.19c3.43.9 8.22-.53 11.03.44m-10.96-.01c4.08-.17 8.11-.86 11.28-.11" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M901.68 287.1s0 0 0 0m0 0s0 0 0 0m1.65 9.75c2.1-1.17 2.38-2.52 5.51-6.68m-5.12 7.09c1.82-2.79 3.81-5.61 5.12-6.28" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M909.8000000000001 291.09c-4.07 2.42-7.12 2.91-8.56 4.34m8.61-4.01c-3.05 1.48-6.12 2.41-8.36 3.91m.32-.62c.54-.62 1.31-1.28 1.98-3.79m-1.99 4.23c.45-.94.99-1.85 1.92-4.11m-.16-.32c-.14-1.03-.62-2.23-2.06-3.45m2.27 3.82c-.51-1.07-.86-1.77-2.19-3.87m-.21-.43c3.68 1 5.84 2.75 7.5 4.82m-7.14-4.67c1.86.92 4.02 1.91 8.38 4.1" pointer-events="all"/><path fill="none" stroke="none" d="M1087 261v-30H949.5v-21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M949.5 203.24l4 8-4-2-4 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M1088.26 261.35c-1.87-10.09.18-21.9-3.03-32.34m1.33 32.19c-.13-12.08.6-23.48.25-30.41m1.2.46c-49.38-.09-96.24 2.02-138.01-1.79m137.85.75c-51.66-.04-100.83.35-137.58.28m.92 1.57c-.06-5.42-.28-10.63-3.6-23.46m1.84 22.18c-.91-7.6.3-15.8.54-22.21" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M949.72 202.99s0 0 0 0m0 0s0 0 0 0m2.8 9.11c.19-.29.28-.57.59-.79m-.64.66c.27-.25.4-.45.66-.69" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M950.25 203.70999999999998c1.05 1.71 1.88 3.51 2.4 7.24m-3.18-7.81c1.2 3.52 3.3 6.78 4.24 7.8m-.07.72c-1.82-.96-2.94-1.74-4.43-2.54m4.3 2.33c-1.3-1.11-2.74-1.64-4.01-2.32m-.35.23c-1.22.11-2.21 1.27-3.34 1.9m3.65-2.16c-1.21.6-2.29 1.42-4.03 2.13m-.25.59c1.93-2.59 2.73-5.03 4.59-7.99m-4.71 7.21c1.16-1.65 3.05-4.03 4.12-7.69" pointer-events="all"/><path fill="none" stroke="none" d="M917 261h340v60H917z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M917.16 260.81s0 0 0 0m0 0s0 0 0 0m-.75 11.12c3.93-2.94 5.88-2.88 10.07-12.52m-8.71 12.68c2.31-2.33 5.84-6.27 9.84-12m-11.32 24.92c5.89-7.32 14.23-16.96 23.44-23.8m-23.12 24.86c5.62-7.03 11.43-14.38 22.54-25.82m-22.39 38.15c8.3-10.99 14.83-18.61 30.84-36.03m-30.82 36.04c10.68-12.59 21.67-24.44 33.27-38.23m-31.81 48.88c14.51-15.39 29.67-33.72 42.81-46.88m-43.28 47.05c12.92-15.87 28.32-33.27 41.55-49.08m-43.53 61.17c22.54-24.56 44.03-47.22 56.2-62.02m-54.48 62.56c20.77-24.24 41.44-47.42 51.99-62.09m-40.91 61.73c13.89-16.42 32.11-37.54 51.61-59.14m-52.81 58.88c20.59-22.82 41.74-47 53.61-60.69m-40.63 59.72c12.42-12.99 25.91-31.72 51.41-59.27m-53.94 61.08c12.77-14.16 25.31-29.17 53.93-61.26m-41.07 61.67c13.76-18.02 29.8-39.41 52.47-61.94m-54.33 62.06c12.59-15.74 24.62-28.96 53.6-60.46m-41.99 59.32c11.12-14.8 26.26-30.66 51.12-60.32m-51 61.39c12.06-17.41 26.73-31.42 51.47-62.22m-40.43 60.72c10.54-14.62 21.43-26.65 50.58-60.44m-51.8 60.44c9.91-12.04 21.64-23.66 51.96-59.07m-43.18 59.78c17.09-16.9 31.92-38.13 52.99-61.24m-50.22 60.14c15.08-17.02 30.44-36.22 51.04-60.06m-41.94 62.32c17.02-19.77 31.51-38.17 51.3-62.49m-50.13 60.81c18.57-20.73 36.9-42.79 52.25-60.83m-40.61 60.39c11.67-15.25 23.71-27.99 49.39-60.88m-50.66 61.99c19.26-21.4 36.4-42.93 52.7-61.57m-44.38 62.34c14.53-17.08 29.78-31.13 53.97-61.93m-52.98 60.23c13.15-13.43 24.34-28 53.06-59.05m-42.97 59.13c14.66-15.5 32.82-34.4 54.66-60.08m-53.13 60.93c15.05-17.23 28.57-32.68 51.56-60.61m-39.78 58.42c12.3-13.36 22.95-26.52 51.93-58.61m-52.81 60.08c15.56-17.52 29.94-36.65 51.97-60.11m-41.11 58.77c20.72-20.86 37.69-43.37 53.14-57.69m-54.22 60.18c15.29-17.17 29.8-34.27 53.66-61.99m-43.34 61.87c22-23.57 44.36-49.94 52.51-62.36m-50.84 61.97c15.79-20.83 32.51-39.83 51.54-61.28m-42.12 60.72c22.39-22.18 41.5-46.98 51.16-58.55m-50.3 58.28c12.9-15.13 25.51-29.21 52.11-59.56m-41.55 61.77c9.45-15.58 23.61-28.04 53.08-61.03m-53.12 59.82c19.65-23.92 39.9-47.05 51.38-60.93m-41.33 59.15c20.91-22.91 37.54-44.4 53.1-57.5m-53.55 59.03c11.93-11.98 22.25-25.56 52.96-60.12m-42.04 58.87c15.84-18.88 36.8-37.99 52.96-60.47m-52.42 61.83c14.02-17.77 28.82-33.66 52.03-60.37m-40.24 60.95c10.56-15.25 27-33.98 49.26-63.39m-49.89 61.53c11.88-14.83 25.51-29.23 51.31-59.52m-39.72 59.66c13.54-17.61 28.35-31.61 49.5-60.52m-50.33 60.5c14.09-17.3 29.99-34.75 51.1-59.93m-40.63 59.69c17.65-21.12 38.98-46.33 52.03-59.05m-53.07 60.13c14.43-15.81 25.94-30.6 53.24-60.57m-40.7 58.35c18.93-21.4 36.81-42.97 50.06-59.02m-51.22 60.56c12.86-13.67 25.2-28.99 51.14-60.94m-43.09 62.48c19.82-24.06 41.56-44.16 56.36-62.1m-55.2 61.26c15.74-17.38 30.87-36.28 54.46-61.87m-42.95 61.63c11.3-12.78 25.8-27.2 51.96-59.81m-52.22 61.06c12.71-15.98 26.87-30.71 51.75-61.73m-41.86 60.07c11.44-9.31 22.45-21.36 52.67-61.1m-51.65 61.56c14.23-16.23 28.1-31.7 51.1-59.98m-39.05 60.88c12.4-15.54 27.5-33.44 50.56-60.74m-53.27 59.33c18.85-18.72 36.46-41.11 53.51-59.62m-41.3 60.48c9.89-12.61 21.69-26.51 53.24-59.18m-53.41 59.54c14.12-17.56 30.39-35.76 52.2-60.99m-42.74 59.73c18.97-22.69 41.72-48.24 51.2-57.67m-51.06 58.98c14.35-15.01 27.07-29.51 51.97-60.95m-41.37 59.44c16.11-16.54 30.66-30.86 49.84-53.88m-48.76 55.39c14.73-16.42 28.66-32.5 47.25-56.44m-36.4 53.97c9.42-11.59 19.61-22.35 38.79-43.81m-38.65 45.27c7.3-9.07 13.57-18.62 37.3-42.44m-26.51 41.53c6.03-7.31 9.69-14.67 27.04-30.19m-28.54 32.03c10.34-11.44 20.08-23.8 27.54-32.31m-16.44 32.57c6.52-8.06 9.83-10 17.88-19.33m-17.53 18.68c6.06-6.86 11.28-14.14 16.3-18.71" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M917.8 261.81c94.98 1.46 193.99.25 339.09-1.18m-339.62.32c109.6-.09 219.8-.71 339.52-.2m.49-.56c.03 22.76-.46 46.75 1.09 59.75m-1.39-58.58c.05 22.82.75 46.62-.65 59.95m.27-.04c-123.81 1.14-245.98.7-340.43-1.14m340.51 1.15c-106.86-2.48-212.98-2-339.89.08m1.37 1.18c-2.45-22.99-.88-45.45-2.95-62.58m1.29 60.98c-.56-13.23-.09-25.94.94-60.12" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:338px;height:1px;padding-top:291px;margin-left:918px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Artifact::finish_instantiation</font></div></div></div></foreignObject><text x="1087" y="295" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Artifact::finish_instantiation</text></switch></svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.png b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.png
new file mode 100644
index 0000000..cc83a82
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.png differ
diff --git a/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.svg b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.svg
new file mode 100644
index 0000000..1ce98d3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/diagrams/Diagram_module_serialization.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="762" height="222" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2020-07-20T09:20:34.245Z&quot; agent=&quot;5.0 (Macintosh)&quot; version=&quot;13.4.8&quot; etag=&quot;rDKBPPV5QoUVm1hLuxiG&quot; type=&quot;device&quot;&gt;&lt;diagram id=&quot;2alLs4ajSNHMKkMwH0tN&quot;&gt;7VhLc5swEP41PsYDwmD76GdzSKeZ8aHtqaOADGoEokKO7f76rkDiEXDiSeLYM+4kM9audlfax7cs9JxZvPsicBp95QFhPWQFu54z7yGEhkMLfhRnX3AGnlcwQkGDgmVXjBX9SzRT64UbGpCsISg5Z5KmTabPk4T4ssHDQvBtU2zNWfPUFIekxVj5mLW532kgo4I7QsOKf0toGJmTbW9c7MTYCGtPsggHfNtgkZ1c8kTqK35LSQLMFU6ynruIpFQuTnpoCf9rJdYPOQ8ZwSnN+j6Pge1nILJc45gyFd/CwjS3MJzdYymo/wgmb3ESvNFkaWSaG4FrO4ueMxOcy2IV72aEqZybdBa+LQ/slvEUJJHHKKBC4QmzjU6JDqfcmxyFgm9SLUaEJLuuysAPRtxqX8EuHYNCJjwmUuxBRBu6sdFIK+kqHht6W9WEZ3hRvR4ME+skh6X1ymdYaLe7Q+B0hMBjcMJU5bARC+/PhpuNmyxHE6TbskfprtpUOMB+U+FZsdRkvVD9bnEWE6GsORNA+YaRYp0RQTFTB+kr6coyeq1kQa6SgCjPLGU2opKs0uI2W2ghwItkDJGY27DMHon0I0NIwR/JjDMuclPOfGwNXKS8pYzV+EsL/lCpYXCLyut0VEm9GtAr1dDOPbI6cu99QOoHF5x66MtXl/xBV/LRiZLvvt76SABPK01yISMe8gSzRcWdNkNeydxxnurY/iZS7vWjF28kf1MaDoVb3fDlYINDfCN0UZpmJ7EIiayBoJ0SQRiW9Klp/T3x9g6CLaBPR2MtB84zCL0JtF2GNhlRTubFhgNG4GENIU5CmhzGYMnOvWhyL8axNRSUGohwnLLSlQfxIZc7MiId0LrDDzDPNuAA/S5MYO1DEauuOFX9hMLAONEbMQ2CAnkE7qjHDoW9lFM967nTnjvXjmjc2SNNL1uTV9GWX2hfx0w47svPNKtvjS09uR6NK23uXvlVE+HrdQbQfQ688tSjsDg8R6sjOyp/KPX+0NXkT21Nree7OrE3RAJO1bUU/dNYVESll1NGMcBZlN/2DF121O6yzid12dHFjDS/dOPMp5kJoBjsyKsdawfNVxwbdUw63okmnfF50Y7qaLePRTtqoN26YLR3zFSjT0K7mZf/N/LTpNa227n9rHnZnH3ZrfwaX1Odoft6Mx+fqJnbZ3lNvZ5uPmgj3j7wAfO9kAey+tJbTPHVZ35n8Q8=&lt;/diagram&gt;&lt;/mxfile&gt;" version="1.1" viewBox="-.5 -.5 762 222"><defs/><defs><style type="text/css">@import url(https://fonts.googleapis.com/css?family=Open+Sans);@import url(https://fonts.googleapis.com/css?family=Patrick+Hand);</style></defs><path fill="none" stroke="none" d="M51 21h200v60H51z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M51.22 20.74s0 0 0 0m0 0s0 0 0 0m-1.77 13.65c4.15-4.22 9.68-8.41 11.86-14.74M50.74 34.04c4.08-5.06 8-11.2 10.87-13.76M48.96 46.6c9.71-9.97 18.89-21.24 24.07-24.27M50.36 45.5c7.34-7.92 15.49-17.32 21.65-23.92M51.23 55.7c8.33-7.48 20.74-20.75 33.42-33.87M50.04 57.38c8.51-8.11 17.52-17.69 32.56-36.18M51.42 68.63c13.1-12.25 24.19-28.4 41.63-47.11m-42.64 49.1C61.78 58.01 72.02 46 92.98 20.61m-43.4 61.9c16.63-17.66 32.55-34.9 53.57-61.76M50.7 80.71C70.19 62 87.18 41.14 104.19 20.39M61.74 80.95c16.21-17.15 35.73-38.46 52.97-59.6M62.29 82.13c18.87-23.76 38.94-44.5 52.54-60.02M71.26 80.43c13.48-14.18 25.99-24.76 54.51-59.61M73.36 81.97c9.49-13.09 20.44-25.16 51.4-60.29m-39.7 60.61c8.23-12.57 22.73-29.21 49.71-63.01M83.43 82.12c15.73-18.73 30.1-36.61 53.13-60.57M94.04 82.96c10.95-13.61 19.45-25.9 51.35-63.34M93 80.72c21.62-23 41.36-46.76 53.63-59.63m-40.84 61.08c9.67-15.21 20.56-25.61 51.59-60.44m-52.76 58.89c17.13-19.36 33.42-38.92 52.61-58.59m-41.76 59.11c13.21-14.57 27.39-30.83 51.86-58.46m-52.35 58.06c11.93-13.01 23.36-25.93 52.65-59.93M126.6 82.75c12-19.25 25.5-33.5 52.91-59.89m-53.5 57.64c16.32-17.87 31.7-34.51 52.2-58.46m-40.33 59.7c16.92-22.65 33.75-43.12 52.79-59.49m-53.68 58.97c12.16-14.1 25.75-29.96 52.49-60.33m-41.49 60.02c17.47-17.31 33.48-38.37 52.9-58.38m-53.27 57.98c9.68-10.54 20-22.42 52.64-60.04M158.4 81.26c17.07-21.57 35.07-42.63 51.91-61.95m-52.19 62.41c18.08-22.21 37.67-43.67 52.6-61.43m-44.53 61.95c19.77-21.32 39.55-44.08 55.85-61.93M168.31 82.3c17.92-23.32 38.68-45.34 52.19-60.7m-41.61 58.3c16.86-18.04 31.6-36.4 52.01-58.35m-51.14 59.67c13.64-17.07 28.55-34.48 52.02-59.36m-40.53 61.21c12.24-20.59 27.27-37.11 51.01-61.55m-53.44 59.87c13.22-14.83 24.22-28.11 52.57-61.3m-41.34 59.5c18.79-19.85 39.43-42.5 52.17-57.45m-51.49 58.91c15.25-16.51 28.82-34.73 50.53-58.97m-42.29 58.36C219.42 69.7 231.02 57.88 250.48 32m-39.75 48.2c7.94-8.84 17.36-20.28 41.89-47.38m-33.29 49.16c8.81-8.72 13.91-16.08 32.82-34.37m-30.01 34.37c7.14-11.63 16.64-20.2 29.84-36.01m-21.02 36.12c5.96-6.72 14.49-14.33 19.26-24.34m-18.74 23.31c4.16-5.2 9.91-11 19.54-23.58m-9.57 24.54c3.47-4.15 8.47-8.72 9.32-12.64m-8.23 11.73c2.47-3.37 5.54-7.42 9.09-10.14" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M52.08 21.85c57.06.07 113.05.91 197.17-1.6m-197.62.92c53.74-.62 107.91-1.4 199.71.7m-.28-.91c.02 23.81-.27 48.06-.02 58.55m-.64-59.12c.11 24.31.64 46.81 1.17 60.25m-2.15-.6c-59.84.27-123.05.56-197.49-.33m198.62 1.64c-54.32-.39-108.57.7-199.96-1.25m2.35 2.59c-1.35-12.93-.41-25.9-1.02-62.94m-.8 61.12c-.45-20.96-.27-42.2.75-60.47" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:198px;height:1px;padding-top:51px;margin-left:52px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::serialize</font></div></div></div></foreignObject><text x="151" y="55" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer::Module::serialize</text></switch><path fill="none" stroke="none" d="M471 21h220v60H471z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M470.87 21.15s0 0 0 0m0 0s0 0 0 0m.77 11.53c.96-3.78 6.27-7.93 11.11-13.09m-11.41 14.34c1.25-3.28 5.15-6.44 10.56-12.52m-11.99 25.23c4.3-7.05 8.27-12.52 21.83-25.24m-21.21 23.8c6.58-5.57 10.7-11.45 22.4-25.06m-21.85 38.11c10.14-12.48 18.33-21.4 30.1-35.91m-30.41 35.3c11.58-13.85 23.41-27.41 31.15-37.32m-32.25 47.91c16.08-17.66 34.18-32.44 43.18-46.29m-42.78 48.79c12.37-12.64 23.85-26.66 43.45-49.79m-42.96 59.32c14.14-10.77 25.88-24.18 53.74-60.4m-52.81 60.99C484.6 64 500.4 48.31 523.73 21.07M480.3 83.22c16.49-21.07 31.96-35.86 55.98-60.87M482.56 80.5C501 61.44 518.98 40.81 535.4 21.52m-42.11 61.2c20.73-26.79 42.85-48.06 50.6-61.56m-52.08 59.38c13.69-12.73 24.72-27.24 53.9-60.15m-42.63 59.15c20.29-23.66 41.81-45.82 52.6-59.15M502.43 81.3c12.74-13.27 24.8-27.2 53.12-60.68M515.69 79.8c17.06-19.34 36.67-41.87 49.08-60.45m-50.94 62.12c15.58-18.04 32.22-36.62 53.17-59.9m-42.28 60.29c16.13-16.66 29.21-36.41 51.27-62.38M525.1 81.64c16.43-21.63 33.43-40.28 51.65-61.04m-42.29 58.58c19.27-16.07 36.09-36.21 54.57-59.98m-54.58 62.69c17.99-21.83 34.67-42.15 53.1-61.3M547.06 79.2c19.28-22.83 37.82-46.39 50.43-58.44m-50.84 60.58c18.16-21.03 36.01-42.16 50.99-59.82m-40.03 60.71c8.55-13.43 20.33-29.38 50.49-61.06m-51.65 60.55c16.49-19.23 31.38-36.43 51.73-61.67m-42.89 60.23c17.61-14.13 31.08-32.5 54.47-61.24M568.03 80.9c10.76-14.29 23.41-27.07 50.68-59.84m-42.89 59.7c15.96-15.11 27.58-26.3 54.89-59.33m-52.94 59.85c18.51-22.27 39.41-44.19 52.78-60.05m-43.32 61.04c14.72-19.28 31.33-33.6 53.79-62.71m-52.67 62.67c19.46-24.11 40.29-48.22 51.28-60.89m-42.59 60.69c17.33-17.07 29.59-34.39 53.23-61.45m-52.08 61.71c14.96-17.72 28.59-32.57 52.31-61.46M608 79.74c21.06-20.31 43.93-46.77 52.8-56.73m-51.24 58.61c15.89-19.59 33.72-39.78 52.32-59.76m-43.32 59.35c17.57-15.14 30.57-33.07 52.87-60.59m-52.08 61.76c15.21-18.66 31.35-35.86 53.33-60.48m-42.64 59.33c17.94-19.68 35.81-42.47 53.91-59.21m-53.48 60.26c18.63-23.96 38.11-45.34 52.35-60.25m-41.15 60.41c16.29-20.46 35.02-39.25 51.89-60.15m-52.19 59.82c14.41-16.84 28.88-34.44 50.61-60.89m-42.2 60.99c10.1-12.15 20.62-25.41 41.72-46.49m-40.11 45.62c13.69-15.39 28.23-31.5 41.12-47.59m-29.59 45.77c10.04-9.42 21.8-22.62 31.39-31.62m-32.06 33.76c9.16-9.99 18.15-21.41 30.82-35.6m-20.11 35.77c5.35-3.05 9.17-9.54 21.25-21.47m-20.73 20.2c6.99-5.75 13-13.73 19.78-22.56M682.6 80.4c4.06-3.84 7.02-6.09 11.44-9.36m-10.32 10.01c2.96-1.94 5.05-5.33 9.53-10.73" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M471.05 20.92c61.74-1.95 126.72-.19 219.31 1.44m-220.18-1.84c64.81.89 128.78 1.38 221.51 1.11m-1.09-.42c-.1 11.84.3 26.27-.17 59.43m1.26-60.05c-.35 16.36-.8 31.84-.71 61.4m1.14-.36c-73.11.36-144.85.16-220.36-.49m218.86-.8c-53.7.08-109.04-.84-220.07.7m-.33-.63c.8-19.39 0-35.86.3-59.87m-.18 60.33c.79-18.44 1.47-37.76.97-60.48" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:218px;height:1px;padding-top:51px;margin-left:472px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer::Module::deserialize</font></div></div></div></foreignObject><text x="581" y="55" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer::Module::deserialize</text></switch><path fill="none" stroke="none" d="M251 51h211.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M468.76 51l-8 4 2-4-2-4z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M251.88 49.39c79.38 3.36 157.97 4.68 209.57.26m-210.73.93c57.02 2.02 112.17 2.64 211.63.18" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M460.85 46.9s0 0 0 0m0 0s0 0 0 0m2.11 9.16c1.66-1 2.07-1.85 5.32-5.46m-5.67 6.32c1.93-2.4 4.3-4.42 5.25-5.97" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M468.7 51.45c-2.4.58-4.87 2.3-8.43 4.2m8.09-4.54c-1.35 1.02-3.2 1.79-7.72 4.27m.42-.82c.54-.96.87-1.85 1.28-3.78m-1.76 4.39c.92-1.41 1.49-2.82 2.05-4.3m.28.23c-1.28-1.43-1.62-3.2-2.1-4.49m1.93 4.46c-.5-.7-.76-1.8-2.04-3.97m-.69.35c3.38 1.26 4.8 2.08 8.83 3.83m-8.24-4.46c2.71 1.49 6.2 3.19 8.04 4.51" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:1px;height:1px;padding-top:52px;margin-left:352px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:18px;font-family:Patrick Hand;color:#000;line-height:1.2;pointer-events:all;background-color:#fff;white-space:nowrap"><div style="font-size:18px"><font style="font-size:18px">use a headless engine</font></div><div style="font-size:18px"><font style="font-size:18px">for example<br style="font-size:18px"/></font></div></div></div></div></foreignObject><text x="352" y="57" fill="#000" font-family="Patrick Hand" font-size="18" text-anchor="middle">use a headless engine...</text></switch><path fill="none" stroke="none" d="M216 141v-30h-15V89.24" pointer-events="stroke"/><path fill="none" stroke="none" d="M201 83.24l4 8-4-2-4 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M215.32 140.01000000000002c.81-6.96.8-15.14-1.23-28.09m2.16 28.79c-.64-8.78.77-18.27-.89-30.52m1.92 1.27c-5.26.29-6.69-1.51-16.35-1m15.14.59c-4.68-.29-9.81-.4-15.04.66m.8-1.51c-.62-4.52.27-15.23-1.45-21.03m.81 22.81c-.13-8.43-.37-15.63.68-23.63" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M200.94 83.31s0 0 0 0m0 0s0 0 0 0m3.44 8.18c.22-.05.22-.2.67-.73m-.71.84c.21-.24.41-.49.66-.8" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M201.37 82.88c.93 3.9 2.66 5.02 3.35 8.33m-3.63-7.53c1.36 1.82 2.51 4.18 4.3 7.16m-.82.75c-1.16-1.02-2.23-2.16-3.83-2.4m4.48 2.14c-1.37-.68-2.22-1.39-4.4-1.93m.28.18c-1.25.06-1.4.22-3.71 1.93m3.56-2.13c-.99.09-1.49.58-3.86 2.07m-.56-.51c2.58-2.25 2.81-4.92 4.16-8m-3.54 8.17c.91-2.03 2.18-5.18 3.64-7.65" pointer-events="all"/><path fill="none" stroke="none" d="M21 141h260v60H21z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M20.73 141.31s0 0 0 0m0 0s0 0 0 0m-.6 13.4c4.4-3.59 6.62-7.94 11.04-12.31m-9.66 10.35c2.37-2.61 5.36-5.58 9.29-12.08m-10.38 26.52c3.34-5.25 10.55-14.03 20.25-26.97m-20.4 25.18c7.76-7.89 16.27-17.34 21.81-24.95M20.5 177.31c7.42-9.1 15.59-13.88 31.43-34.71m-30.86 35.79c9.25-11.15 17.76-21.64 32.38-37.19m-30.66 49.62c7.16-12.86 19.4-24.04 39.43-47.96m-41.61 46.97c13.02-15.12 25.37-28.74 43.01-48.05M21.1 202.51c18.15-21 36.21-42.67 53.91-63.05m-53.17 62.03c20.44-24.02 41.54-48.61 52.99-61.23m-42.4 61.73c12.76-15.94 28.19-32.21 50.99-62.14m-51.03 61.52c16.01-19.41 33.91-37.94 51.16-59.93m-42.66 60.08c21.47-23.34 42.7-43.22 54.69-59.52m-53.75 59.61c15.09-15.33 28.2-32.28 52.4-60.01m-39.56 59.7c17.85-23.72 35.88-43.34 51.49-59.31m-53.17 59c18.25-20.86 36.51-40.9 53.11-60.8m-43.19 60.96c16.66-18.05 32.89-38.75 54.8-61.57m-53.5 61.14c12.76-12.14 24.31-27.53 52.72-60.17m-43.72 61.5c22.59-23.16 41.86-44.26 54.97-60.32m-53.05 59.43c16.54-20.86 34.24-40.58 52.7-59.49m-40.81 60.05c18.54-21.57 37.99-45.59 49.27-61.5m-50.81 61.32c12.76-15.52 26.2-29.18 51.55-60.67m-39.95 59.29c17.28-19.4 34.37-36.19 51.97-61m-54.2 61.52c22-21.14 42.32-44.76 53.79-59.19m-41.74 61.72c15.88-20.27 29.11-35.79 52.19-62.61m-53.63 60.11c19.64-20.35 37.82-40.9 52.99-59m-42.3 58.45c24.25-23.04 41.67-46.8 52.04-60.11m-50.2 61.74c12.66-14.99 25.62-30.68 50.73-61.64m-40.6 59.11c15.79-17.42 35.22-38.47 52.56-59.2m-52.37 61.76c20.44-22.71 40.16-46.53 51.64-61.14m-40.8 60.61c8.47-13.24 21.89-27.12 51.72-59.49m-51.6 59.35c10.5-11.77 20.9-25.89 52.36-61.07m-41.57 59.07c9.81-11.06 23.6-27.33 50.45-56.56m-51.01 57.75c12.27-15.41 26.63-31.69 52.6-59.55m-42.48 58.61c15.38-14.91 31.6-35.23 50.59-59.91m-51.03 61.35c12.07-13.23 24.22-26.24 52.06-60.22m-39.94 61.96c20.07-23.57 39.94-48.87 49.56-63.74m-50.67 62.62c14.39-16.82 31.09-34.99 52.14-59.98m-41 60.29c13.65-14.64 24.81-33.46 51.15-61.17m-52.04 61.5c16.41-20.19 33.09-38.73 51.66-60.29m-41.88 60.84c12.63-15.86 25.76-28.56 53.98-61.77m-53.38 61.11c15.84-18.06 31.23-35.71 52.38-61.64m-40.37 61.72c20.67-24.47 39.73-46.91 50.98-62.06m-52.29 61.35c13.16-14.74 26.34-29.51 51.51-61.02m-41.93 60.03c19.78-17.62 33.35-38.85 54.71-59.23m-53.6 60.81c12.31-14.84 26.16-32.18 51.9-60.75m-40.55 61.7c10.03-16.12 23.49-26.97 50.62-60.39m-52.4 59.2c14.66-16.28 29.46-32.29 52.46-60.65m-41.54 58.59c11.67-9.75 21.84-23.29 49.17-54.38m-48.72 57.25c14.63-18.21 29.11-33.6 51.16-58.8m-39.85 59.03c11.28-13.26 21.89-26.55 41.15-46.62m-42.57 44.78c10.57-9.94 20.85-22.81 41.41-45.54m-30.82 46.69c13.18-12.2 19.57-25.78 31.36-35.89m-30.23 35.62c7.49-7.76 12.76-17.18 28.73-35.11m-18.18 36.08c8.1-9.89 13.74-19.3 16.38-24.31m-15.72 22.7c3.88-5.88 8.73-9.98 17.49-20.7m-8.51 20.63c2.92-1.73 5.15-5.78 8.96-8.54m-8.27 9.12c2.52-2.67 5.63-5.83 8.58-9.81" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M20.14 140.1c75.45-.2 148.25 2.31 261.24.87m-260.86.6c81.27.89 163.82.89 259.85-.19m-.23.08c-.22 11.87.87 28.48-.32 60.31m1.17-60.98c-.82 20.4-.24 38.88-.61 60.56m.9-1.54c-90.23 3.71-178.15 3.1-259.71 2.6m259.12-1.33c-58.28.92-114.85 1.46-260.15-.81m.96 1.86c-1.06-25.85.42-49.82-2.39-60.79m2.45 59.53c-1.18-15.92-1.99-33.31-.81-60.49" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:258px;height:1px;padding-top:171px;margin-left:22px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Artifact::serialize</font></div></div></div></foreignObject><text x="151" y="175" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Artifact::serialize</text></switch><path fill="none" stroke="none" d="M101 81v30H86v21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M86 138.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M99.35000000000001 82.42c2.47 6.43 3.59 9.29 2.34 27.55m-.11-29.16c-1.1 10.6-1.02 22.78-1.07 29.54m1.64 1.81c-6.14-.16-11.45.32-14.79-.09m14.22-.33c-3.57.01-6.53-.97-15.14-1.34m-2.28.05c2.87 6.46 2.32 15.45 3.82 20.67m-1.86-20.94c.56 6.11-.83 12.39-.35 21.73" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M81.9 130.88s0 0 0 0m0 0s0 0 0 0m3.54 7.79c2.5-1.18 2.93-2.8 5.06-5.56m-4.82 5.28c2.6-1.92 4.49-4.28 5.85-6.16" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M85.18 138.51c-.09-3.43-1.77-5.74-2.3-8.48m3.18 8.36c-.75-1.89-2.42-3.74-4.16-8.01m-.27.2c1.23.92 3.07 1.72 4.1 2.34m-3.72-1.98c1.34.45 2.63 1.1 4.17 1.61m-.34.47c1.35-.47 2.23-1.35 3.84-2.7M86 132.65c1.53-.36 2.89-1.26 4.14-1.67m.27-.96c-1.18 3.5-2.65 7.42-4.28 8.2m3.7-7.42c-.84 1.65-1.83 3.96-4.1 8.37" pointer-events="all"/><path fill="none" stroke="none" d="M653.5 141v-30H636V89.24" pointer-events="stroke"/><path fill="none" stroke="none" d="M636 83.24l4 8-4-2-4 2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M651.5400000000001 140.66c3.94-8.97 2.99-19.08 1.76-30.56m.21 31.86c-.47-10.24.27-18.87.05-31.62m-1.72 2c-1.81-2.63-9.97-2.02-14.63.24m15.47-1.04c-4.74-.93-9.59.07-16.1-.55m.37-1.56c.51-6.61-.52-11.89.5-22.16m-1.61 23.76c-.21-8.5.12-16.51.5-21.77" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M635.69 83.6s0 0 0 0m0 0s0 0 0 0m3.34 8.23c.18-.12.57-.49.64-.75m-.62.75c.24-.21.49-.53.67-.67" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M636.4200000000001 82.54c1.44 2.9 2.3 6.38 4.23 7.82m-4.72-7.1c1.19 2.62 2.78 5.43 4.22 7.99m-.34-.13c-.8-.36-2.61-.9-3.83-1.72m3.99 1.79c-.61-.31-1.45-.99-3.97-2.05m.31.37c-1.03.6-2.37.33-4.36 2.04m4.15-2.44c-.86.69-1.63.78-4.14 1.93m.22-.67c.77-2.81 2.6-5.83 3.27-6.9m-3.65 7.45c1.61-2.42 3.33-4.77 4.33-7.91" pointer-events="all"/><path fill="none" stroke="none" d="M436 141h290v60H436z" pointer-events="all"/><path fill="none" stroke="#f0f0f2" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M436.21 140.75s0 0 0 0m0 0s0 0 0 0m-.55 13.13c3.8-4.14 6.38-7.42 10.13-12.65m-9.74 11.89c4.25-4.43 8.04-8.25 10.16-11.61m-10.82 23.64c4.62-8.2 12.62-14.46 21.36-22.92m-20.73 22.44c8.52-7.5 14.6-17.68 21.54-24.92m-21.36 38.16c8.02-13.43 21.8-22.82 33.35-37.35m-32.8 37.06c5.75-8.56 14.47-16.79 31.97-37.06m-34.02 50.2c15.27-14.94 25.58-31.43 41.91-48.66m-40.76 48.4c15.3-17.56 28.93-33.31 42.49-49.54m-41.46 62.08c13.85-17.83 24.91-32.41 50.21-61.12m-50.19 59.85c15.17-18.4 32.83-36.38 51.67-59.64m-40.82 61.43c11.3-15.59 19.52-29.12 50.25-61.9m-51.62 59.74c16.86-19.92 36.05-40 52.97-59.74m-40.18 61.93c19.43-22.02 38.04-47.53 48.9-64.32m-51.51 63.37c19.64-21.31 37.34-43.06 52.88-60.46m-40.87 59.22c19.37-22.84 40.23-47.09 51.8-58.92m-53.03 58.98c21.29-23.15 42.93-47.1 52.77-59.74m-40.42 61.31c17.03-20.76 31.51-40.09 49.82-61.44m-51.35 60.65c19.83-22.7 39.43-45.36 53.4-60.88m-41.72 61.74c12.24-16.24 21.15-30.41 51.11-60.88m-50.58 59.17c10.22-12.75 20.97-25.49 50.87-60.57m-40.09 60.71c20.7-21.51 40.63-45.99 53.04-59.51M499.58 201c12.82-14.12 26.74-29.89 52.7-58.88m-40.44 58.17c20.01-22.03 39.17-42.18 50.25-60.85m-52.03 62.97c18.74-23.14 38.37-42.61 53.75-61.21m-44.38 58.94c18.55-16.27 33.56-32.12 54.61-57.62m-52.92 59.38c16.63-18.03 31.77-37.68 52.25-60.4M532 201.44c18.56-18.89 36.25-40.19 51.27-59.87m-51.83 60.71c21.69-25.04 41.6-49.16 53.86-60.62m-41.82 59.14c20.56-20.16 38.15-43.32 50.61-58.82m-50.57 58.54c17.24-18.28 34.45-40.35 51.53-59.45m-42.19 58.85c14.41-13.49 26.79-29.06 52.24-59m-51.12 60.43c11.54-14.94 24.14-29.11 51.66-59.79m-42.21 60.74c16.24-16.95 30.07-35.44 53.07-62.18m-52.52 60.82c20.23-21.46 39.74-43.72 51.99-59.96m-41.9 61c14.84-16.42 28.25-36 51.23-59.33m-51.73 57.84c20.16-21.18 39.37-43.92 53.65-59.65m-40.73 59.48c10.2-13.32 21.86-26.08 50.09-58.74m-52.48 60.28c18.99-19.86 34.89-40.64 53.12-61.93m-40.78 62.79c13.29-16.96 29.54-33.37 50.29-61.9m-50.18 60.36c19.18-24.46 40.88-48.39 52.28-61.21m-43.81 59.44c18.07-18.92 36.92-38.42 53.71-59.59m-52.78 60.69c18.45-19.39 36.14-41.04 52.37-59.31m-40.44 60.94c12.87-16.44 30.05-36.31 51.49-59.78m-51.66 59.07c16.33-20.32 34.29-39.72 52.01-61.41M628.5 201c16.87-19.01 37.3-41.71 52-59.77m-52.48 59.47c12.5-15.61 26.63-29.75 51.21-60.08m-41.81 60.49c13.74-14.74 22-25.07 52.89-62.04m-52.07 62.76c14.05-18.93 28.91-35.18 53.33-61.24m-44.7 59.57c15.83-15.02 26.23-28.28 53.68-59.12m-51.96 60.49c15.24-16.99 31.87-36.28 51.78-60.95m-41.78 61.54c13.32-14.9 27.67-29.8 52.55-61.73m-51.98 61.88c19.01-24.08 39.23-46.98 52.7-61.64m-42.68 61.91c10.78-16.45 25.7-28.51 52.84-62.41m-51.68 62.31c10.85-12.69 22.11-27.12 51.56-61.64m-41.93 61.47c19.94-21.49 35.13-39.64 49.92-56.9m-50.03 55.59c10.18-13.48 22.87-25.8 49.95-56.59m-38.19 56.59c5.87-7.58 17.47-19.89 38.4-43.91m-39.59 44.61c14.58-16.33 29.39-34.52 38.88-45.28m-29.97 45.43c12.98-15.4 25.57-28.05 31.3-34.49m-28.44 33.59c8.53-8.5 16.07-18.64 27.83-32.93m-17.86 32.36c5.38-3.19 9.03-10.14 18.34-19.18m-19.42 20.08c5.66-4.86 9.18-9.72 19.14-20.36m-6.74 20.42c.87-3.06 3.38-4.62 5.7-8.11m-6.29 8.03c1.23-2.22 3.26-4.25 6.82-8.14" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M434.76 141.73c82.88.44 165.83-.46 290.21-.91m-288.83.43c70.89 1.23 142.95 1.05 289.64-.03m-.22-1.5c.51 16.62-1.11 35.71.03 62.32m.84-60.23c.31 13.47.48 26.73.13 59.34m-.06-.77c-98.5.41-194.32 1.64-290.03 1.88m288.8-1.63c-63.28.82-127.42.73-289.35-.28m.56.74c-.2-23.23-2.04-42.7-1.58-59.9m.11 59.64c.95-22.88.79-44.08.76-60.75" pointer-events="all"/><switch transform="translate(-.5 -.5)"><foreignObject width="100%" height="100%" pointer-events="none" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility" style="overflow:visible;text-align:left"><div xmlns="http://www.w3.org/1999/xhtml" style="display:flex;align-items:unsafe center;justify-content:unsafe center;width:288px;height:1px;padding-top:171px;margin-left:437px"><div style="box-sizing:border-box;font-size:0;text-align:center"><div style="display:inline-block;font-size:12px;font-family:Helvetica;color:#000;line-height:1.2;pointer-events:all;white-space:normal;word-wrap:normal"><font face="Patrick Hand" style="font-size:18px">wasmer_engine::Artifact::deserialize</font></div></div></div></foreignObject><text x="581" y="175" fill="#000" font-family="Helvetica" font-size="12" text-anchor="middle">wasmer_engine::Artifact::deserialize</text></switch><path fill="none" stroke="none" d="M526 81v30h-17.5v21.76" pointer-events="stroke"/><path fill="none" stroke="none" d="M508.5 138.76l-4-8 4 2 4-2z" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-dasharray="6 6" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M526.36 81.5c.37 6.29-.34 10.42-.99 31.05m1.2-32.4c.31 11.74-.28 22.02-.68 31.66m-.76-2.3c-7.27-.13-12.93-.2-16.62.76m17.33 1.15c-4.92 0-8.3-1.03-16.9.22m1.48-.01c-.94 8.28-1.49 13.01.01 21.63m-1-21.49c-1.48 5.03-1.29 10.24-1.45 21.28" pointer-events="stroke"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" d="M504.27 131.02s0 0 0 0m0 0s0 0 0 0m3.67 7.05c1.61-2.3 2.89-4.29 5.85-7.16m-5.57 7.18c1.85-1.35 3.26-3.3 6.01-6.57" pointer-events="all"/><path fill="none" stroke="#d90452" stroke-linecap="round" stroke-linejoin="round" stroke-miterlimit="10" stroke-width="2" d="M509.36 139.04c-1.72-2.13-3.29-5.87-4-8.05m3.56 8.11c-1.5-2.15-2.41-4.23-4.65-8.21m.2-.36c1.15.46 2.46 1.45 4.18 2.56m-4.23-2.45c1.57.9 2.89 1.41 4.04 2.31m.3-.57c1.04.22 1.86-.88 4.02-1.54m-4.22 1.86c.83-.2 1.53-.65 4.04-2.04m.37.26c-2.68 1.87-2.85 5.27-3.62 7.49m3.26-7.92c-.98 2.1-2.25 4.63-4.06 7.93" pointer-events="all"/></svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/c.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/c.svg
new file mode 100644
index 0000000..3d37c89
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/c.svg
@@ -0,0 +1 @@
+<svg width="20" height="22" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><path d="m1 17.22 2.19 1.24 13.6-14.92L11 .26a2 2 0 0 0-2 0L1 4.78a2 2 0 0 0-1 1.74v9a2 2 0 0 0 1 1.7z" style="fill:#7f8b99"/><path d="m19 4.78-2.21-1.24L3.21 18.46 9 21.74a2 2 0 0 0 2 0l8-4.52a2 2 0 0 0 1-1.74v-9a2 2 0 0 0-1-1.7z" style="fill:#a9b9cb"/><path d="M12.07 9.58h3.11a4.84 4.84 0 0 0-5.08-4.33A5.42 5.42 0 0 0 4.48 11a5.31 5.31 0 0 0 5.62 5.66c4 0 4.94-2.86 4.94-4.38h-3a1.73 1.73 0 0 1-2 1.75c-1.91 0-2.22-2.27-2.22-3 0-1.18.42-3 2.22-3a1.86 1.86 0 0 1 2.03 1.55z" style="fill:#fff"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/cpp.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/cpp.svg
new file mode 100644
index 0000000..db14db4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/cpp.svg
@@ -0,0 +1 @@
+<svg width="20" height="22" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><defs><style>.cls-4{fill:#fff}</style></defs><path d="M19.72 5.5a2 2 0 0 0-.72-.73L11 .25a2 2 0 0 0-2 0L1 4.77a2 2 0 0 0-1 1.75v9a2 2 0 0 0 .28 1z" style="fill:#659ad2"/><path d="M.28 16.5a2 2 0 0 0 .74.73l8 4.52a2 2 0 0 0 2 0l8-4.52a2 2 0 0 0 .74-.73L10 11z" style="fill:#0e4580"/><path d="M20 6.52a2 2 0 0 0-.28-1L10 11l9.72 5.5a2 2 0 0 0 .28-1z" style="fill:#035a9d"/><path class="cls-4" d="M16.67 10.69h-.74V10h-.75v.73h-.74v.73h.74v.72h.75v-.72h.74zM19.44 10.69h-.74V10H18v.73h-.74v.73H18v.72h.74v-.72h.74z"/><path class="cls-4" d="M12.86 12.62a3.3 3.3 0 1 1 0-3.24l2.8-1.58a6.5 6.5 0 1 0 0 6.4z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/crystal.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/crystal.svg
new file mode 100644
index 0000000..2993192
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/crystal.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.0.0, 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" width="30" height="32" x="0px" y="0px"
+	 viewBox="0 0 193.2 206.7" style="enable-background:new 0 0 193.2 206.7;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:none;}
+</style>
+<g>
+	<path d="M165.4,122l-50,49.9c-0.2,0.2-0.5,0.3-0.7,0.2l-68.3-18.3c-0.3-0.1-0.5-0.3-0.5-0.5L27.5,85.1c-0.1-0.3,0-0.5,0.2-0.7
+		l50-49.9c0.2-0.2,0.5-0.3,0.7-0.2l68.3,18.3c0.3,0.1,0.5,0.3,0.5,0.5l18.3,68.2C165.7,121.6,165.6,121.8,165.4,122z M98.4,67.7
+		L31.3,85.6c-0.1,0-0.2,0.2-0.1,0.3l49.1,49c0.1,0.1,0.3,0.1,0.3-0.1l18-67C98.7,67.8,98.5,67.6,98.4,67.7z"/>
+	<g>
+		<rect class="st0" width="193.2" height="206.7"/>
+	</g>
+</g>
+</svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/csharp.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/csharp.svg
new file mode 100644
index 0000000..aeba5f7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/csharp.svg
@@ -0,0 +1 @@
+<svg width="20" height="20" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><defs><style>.cls-4{fill:#fff}</style></defs><path d="M17.07 2.93a10 10 0 0 0-14.14 0l14.14 14.14a10 10 0 0 0 0-14.14z" style="fill:#0c9438"/><path d="M2.93 2.93a10 10 0 0 0 14.14 14.14z" style="fill:#219e38;opacity:.85"/><path d="M1 10.23a.76.76 0 0 1 0-.15v.45z" style="opacity:.1;isolation:isolate"/><path class="cls-4" d="M9.51 13.64a4.6 4.6 0 0 1-2.19.46 3.46 3.46 0 0 1-1.46-.25A3.66 3.66 0 0 1 4.63 13a4.05 4.05 0 0 1-1-2.84 4.34 4.34 0 0 1 .26-1.64 4.2 4.2 0 0 1 .88-1.41 4 4 0 0 1 1.32-.94A3.81 3.81 0 0 1 7.65 6a4.42 4.42 0 0 1 1.84.25v1a3.72 3.72 0 0 0-1.85-.45 2.9 2.9 0 0 0-1.2.2 2.81 2.81 0 0 0-1 .69 3.4 3.4 0 0 0-.85 2.42 3.24 3.24 0 0 0 .79 2.29 2.68 2.68 0 0 0 .94.66 2.9 2.9 0 0 0 1.13.2 4 4 0 0 0 2.05-.53zM16.49 8.3l-.13.58h-1.43l-.35 1.65h1.55l-.15.58h-1.51L14 13.3h-.69l.47-2.19h-1.39l-.46 2.19h-.68l.46-2.19h-1.45l.11-.58h1.46l.33-1.65h-1.52l.12-.58h1.52l.46-2.21h.69L13 8.3h1.38l.47-2.17h.66l-.46 2.17zm-2.24.58h-1.39l-.36 1.65h1.4z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/d.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/d.svg
new file mode 100644
index 0000000..f19e305
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/d.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.0" width="26" height="20"><defs><linearGradient id="c"><stop style="stop-color:#000;stop-opacity:.19791667" offset="0"/><stop style="stop-color:#000;stop-opacity:.82291669" offset="1"/></linearGradient><linearGradient id="b"><stop style="stop-color:#fff;stop-opacity:1" offset="0"/><stop style="stop-color:#fff;stop-opacity:.33333334" offset="1"/></linearGradient><linearGradient id="a"><stop style="stop-color:#f2f2f0;stop-opacity:.13541667" offset="0"/><stop style="stop-color:#eeeeec;stop-opacity:.39583334" offset="1"/></linearGradient><linearGradient x1="27.248" y1="33.563" x2="44.496" y2="47.031" id="d" xlink:href="#a" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1 0 0 .99176 -.678 .501)" spreadMethod="reflect"/><linearGradient x1="24.482" y1="30.994" x2="104.024" y2="90.719" id="e" xlink:href="#b" gradientUnits="userSpaceOnUse" gradientTransform="matrix(.99719 0 0 .98872 -.497 .687)"/><linearGradient x1="27.248" y1="33.563" x2="44.496" y2="47.031" id="f" xlink:href="#a" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1 0 0 -.99176 -.678 121.014)" spreadMethod="reflect"/></defs><g transform="matrix(.30906 0 0 .31271 -6.987 -9.286)" style="display:inline"><rect width="80.582" height="60.168" rx="7.694" ry="8.543" x="25.996" y="33.484" style="fill:#2e3436;fill-opacity:.2745098;fill-rule:nonzero;stroke:none"/><rect width="80.582" height="60.168" rx="7.694" ry="8.543" x="23.285" y="30.772" style="fill:#a40000;fill-opacity:1;fill-rule:nonzero;stroke:none"/><rect width="74.011" height="54.138" rx="5.221" ry="5.62" x="26.57" y="33.787" style="fill:url(#d);fill-opacity:1;fill-rule:nonzero;stroke:none"/><path d="M32.333 39.188c-.81.1-1.445.747-1.448 1.53l.051 39.977a1.503 1.503 0 0 0 0 .174 1.3 1.3 0 0 0 0 .27v.04c.01.037.03.077.042.115v.02c.01.038.01.078.021.115v.04c.02.038.04.078.063.115v.02c.028.039.071.079.103.115v.02c.02.038.04.078.063.116v.038c.04.03.082.05.124.077v.04c.03.029.051.049.083.076l.042.039c.03.03.05.05.083.077h.02c.076.064.162.124.25.174h.04c.04.02.083.04.125.058h.02c.04.02.084.04.125.057.06.013.125.013.187.02.1.018.208.037.31.038h.166l15.31-.062c4.376-.007 7.307-.082 9.053-.303h.041c1.67-.232 3.44-.66 5.364-1.284 3.345-1.046 6.311-2.591 8.861-4.655 2.497-2 4.432-4.366 5.792-7.029 1.36-2.663 2.046-5.478 2.04-8.397-.007-4.062-1.236-7.867-3.702-11.289-2.466-3.423-5.832-6.044-9.974-7.78-4.212-1.785-9.703-2.599-16.515-2.586l-16.533.024c-.07 0-.138-.008-.207 0zm8.898 8.226 7.127-.01c3.33-.006 5.7.095 7.044.28 1.363.187 2.855.582 4.435 1.192 1.567.597 2.932 1.328 4.105 2.238v.038c3.228 2.471 4.75 5.441 4.756 9.373.007 4.027-1.463 7.163-4.607 9.793a15.313 15.313 0 0 1-3.23 2.036c-1.12.522-2.584.972-4.431 1.36-1.742.349-4.387.547-7.83.553l-7.334.01-.035-26.863z" style="font-style:normal;font-variant:normal;font-weight:400;font-stretch:normal;font-size:64px;line-height:125%;font-family:'Gill Sans MT';text-align:start;writing-mode:lr-tb;text-anchor:start;fill:#eeeeec;fill-opacity:1;stroke:none"/><path d="M89.368 35.648a5.969 5.472 0 1 1-11.938 0 5.969 5.472 0 1 1 11.938 0z" transform="matrix(1.95002 0 0 1.95002 -82.918 -16.343)" style="fill:#eeeeec;fill-opacity:1;fill-rule:nonzero;stroke:none"/><rect width="78.006" height="57.75" rx="6.57" ry="7.306" x="24.572" y="31.981" style="fill:none;stroke:url(#e);stroke-width:1.34628034;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"/><rect width="80.582" height="60.168" rx="7.694" ry="8.543" x="23.285" y="30.772" style="fill:none;stroke:#323232;stroke-width:1.3558476;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"/><path d="M31.791 87.728H95.36c2.892 0 5.22-2.506 5.22-5.62v-9.001c-22.704-8.734-55.576-13.412-74.01-13.559v22.56c0 3.114 2.329 5.62 5.221 5.62z" style="fill:url(#f);fill-opacity:1;fill-rule:nonzero;stroke:none"/><path d="M89.368 35.648a5.969 5.472 0 1 1-11.938 0 5.969 5.472 0 1 1 11.938 0z" transform="matrix(.62657 0 0 .62657 40.72 19.11)" style="display:inline;fill:#eeeeec;fill-opacity:1;fill-rule:nonzero;stroke:none"/></g></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/dart.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/dart.svg
new file mode 100644
index 0000000..ab1636f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/dart.svg
@@ -0,0 +1 @@
+<svg width="30" height="30" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid"><path d="M70.534 69.696L53.988 53.15l.07 119.6.198 5.59c.082 2.63.57 5.598 1.384 8.674l131.104 46.23 32.772-14.52.012-.04L70.534 69.696" fill="#00D2B8"/><path d="M55.64 187.014l.008.008c-.008-.054-.036-.114-.036-.17 0 .056.008.108.028.162zm163.876 31.71l-32.772 14.52-131.096-46.222c2.504 9.608 8.048 20.408 14.014 26.314l42.784 42.54 95.13.124 11.952-37.316-.012.04z" fill="#55DDCA"/><path d="M3.034 130.116c-4.236 4.522-2.132 13.85 4.688 20.722L37.14 180.5l18.5 6.514c-.814-3.076-1.302-6.044-1.384-8.674l-.198-5.59-.07-119.6-50.954 76.966z" fill="#0081C6"/><path d="M187.82 54.686c-3.076-.786-6.026-1.272-8.7-1.356l-5.908-.204-119.224.016 165.556 165.542h.014l14.54-32.804L187.82 54.686" fill="#0079B3"/><path d="M187.67 54.654c.064.014.114.032.156.038l-.006-.006c-.036-.018-.086-.018-.15-.032zm26.448 14.078c-6.008-6.058-16.666-11.564-26.292-14.04l46.272 131.188-14.54 32.804h-.014l35.532-11.348.076-97.416-41.034-41.188z" fill="#00A4E4"/><path d="M181.338 36.298L151.684 6.862c-6.858-6.794-16.19-8.908-20.7-4.684L53.988 53.142l119.224-.016 5.908.204c2.674.084 5.624.57 8.7 1.356l-6.482-18.388z" fill="#00D2B8"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/elixir.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/elixir.svg
new file mode 100644
index 0000000..1976dfb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/elixir.svg
@@ -0,0 +1 @@
+<svg width="16" height="25" viewBox="0 0 259 398" xmlns="http://www.w3.org/2000/svg"><defs><linearGradient x1="52.258%" y1="7.389%" x2="50%" y2="100%" id="a"><stop stop-color="#D9D8DC" offset="0%"/><stop stop-color="#FFF" stop-opacity=".385" offset="100%"/></linearGradient><linearGradient x1="71.179%" y1="7.691%" x2="50%" y2="100%" id="b"><stop stop-color="#8D67AF" stop-opacity=".672" offset="0%"/><stop stop-color="#9F8DAF" offset="100%"/></linearGradient><linearGradient x1="54.233%" y1="31.435%" x2="54.233%" y2="98.228%" id="c"><stop stop-color="#26053D" stop-opacity=".762" offset="0%"/><stop stop-color="#B7B4B4" stop-opacity=".278" offset="100%"/></linearGradient><linearGradient x1="10.133%" y1="12.539%" x2="50%" y2="92.768%" id="d"><stop stop-color="#91739F" stop-opacity=".46" offset="0%"/><stop stop-color="#32054F" stop-opacity=".54" offset="100%"/></linearGradient><linearGradient x1="80.023%" y1="96.41%" x2="9.647%" y2="21.227%" id="e"><stop stop-color="#463D49" stop-opacity=".331" offset="0%"/><stop stop-color="#340A50" stop-opacity=".821" offset="100%"/></linearGradient><linearGradient x1="76.347%" y1="7.419%" x2="50%" y2="100%" id="f"><stop stop-color="#715383" stop-opacity=".145" offset="0%"/><stop stop-color="#F4F4F4" stop-opacity=".234" offset="100%"/></linearGradient><linearGradient x1="131.792%" y1="72.665%" x2="11.347%" y2="50%" id="g"><stop stop-color="#A5A1A8" stop-opacity=".356" offset="0%"/><stop stop-color="#370C50" stop-opacity=".582" offset="100%"/></linearGradient></defs><g fill="none" fill-rule="evenodd"><path d="M140.473 1c-28.87 10.233-56.74 40.102-83.608 89.605-40.303 74.255-92.356 179.773-20.678 263.318 33.16 38.65 87.911 61.461 159.764 25.333 57.723-29.023 73.776-112.312 53.053-151.45-42.748-80.737-86.118-100.65-97.732-150.719-7.742-33.38-11.342-58.742-10.8-76.087z" fill="url(#a)"/><path d="M140.473 0c-29.017 10.339-56.886 40.207-83.608 89.605-40.083 74.097-92.356 179.773-20.678 263.318 33.16 38.65 87.206 51.14 117.196 28.217 19.55-14.944 32.847-29.188 40.508-59.201 8.53-33.42 1.985-78.412-2.5-99.08-5.674-26.154-7.532-54.86-5.572-86.118l-1.548-1.89c-15.613-19.106-27.66-35.75-32.999-58.764-7.742-33.38-11.342-58.742-10.8-76.087z" fill="url(#b)"/><path d="M116.447 13C89.42 34.36 69.325 70.188 56.16 120.485 36.417 195.929 34.277 265.5 41.241 305.968c13.5 78.447 83.486 108.224 155.272 71.71 44.178-22.471 62.579-70.705 61.604-123.062-1.01-54.211-105.77-115.65-124.322-160.893-12.368-30.162-18.151-57.07-17.348-80.723z" fill="url(#c)"/><path d="M184.965 154.444c32.414 41.57 39.48 70.507 21.197 86.812-27.424 24.458-94.486 40.415-136.206 10.83-27.813-19.724-38.336-62.036-31.57-126.936-11.481 23.977-21.189 48.267-29.123 72.868-7.933 24.601-10.25 50.346-6.95 77.235 9.943 20.115 34.118 33.55 72.524 40.303 57.61 10.131 112.136 5.125 148.724-13.318 24.391-12.296 35.928-24.536 34.61-36.72.881-17.994-4.667-35.122-16.645-51.385-11.977-16.264-30.83-36.16-56.56-59.689z" fill="url(#d)"/><path d="M58.3 112.936c-.271 30.022 7.448 58.56 23.158 85.617 23.564 40.585 51.07 80.688 92.231 113.93 27.44 22.161 49.367 29.32 65.778 21.48-13.48 24.124-27.812 35.945-42.999 35.463-22.779-.723-50.554-10.678-95.058-64.158-29.669-35.654-49.965-69.38-60.89-101.177 1.733-12.615 3.57-25.18 5.511-37.694 1.942-12.515 6.031-30.335 12.269-53.46z" fill="url(#e)"/><path d="M127.916 154.136c2.517 24.456 12.034 63.578 0 89.625-12.035 26.047-67.621 73.102-52.277 114.553 15.344 41.452 52.737 32.146 76.193 13.043 23.456-19.103 36.012-50.165 38.795-72.01 2.783-21.844-6.659-63.877-9.73-100.437-2.047-24.374-.658-45.271 4.167-62.693l-7.187-9.045-42.305-12.526c-6.783 10.023-9.335 23.186-7.656 39.49z" fill="url(#f)"/><path d="M143.017 33c-13.693 5.786-26.666 17.25-38.919 34.393-18.38 25.714-27.741 41.128-20.812 92.1 4.62 33.98 7.926 65.243 9.92 93.786L152.458 81.12c-2.179-8.772-3.99-16.695-5.436-23.768-1.445-7.072-2.78-15.19-4.006-24.353z" fill="url(#g)"/><path d="M152.345 80.778c-15.042 8.78-26.697 26.767-34.966 53.962-8.269 27.195-15.834 65.212-22.695 114.052 9.15-31.064 15.221-53.564 18.21-67.499 4.485-20.903 6.017-50.462 17.923-70.53 7.938-13.378 15.114-23.373 21.528-29.985z" fill-opacity=".316" fill="#330A4C"/><path d="M82.698 372.158c24.754 3.536 37.697 6.68 38.831 9.432 1.701 4.127-3.133 7.903-16.873 5.365-9.16-1.69-16.48-6.623-21.958-14.797z" fill="#FFF"/><path d="M95.134 33C81.52 49.265 69.721 66.509 59.741 84.73c-9.98 18.223-17.111 31.817-21.394 40.784-1.327 6.687-1.975 16.555-1.943 29.603.032 13.048 1.16 27.556 3.386 43.524 1.948-31.268 7.913-61.62 17.895-91.053C67.666 78.154 80.149 53.29 95.135 33z" fill-opacity=".603" fill="#EDEDED"/></g></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/go.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/go.svg
new file mode 100644
index 0000000..76f70ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/go.svg
@@ -0,0 +1 @@
+<svg width="32" height="12" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><defs><style>.cls-1{fill:#38b6ac}</style></defs><path class="cls-1" d="M2.4 3.62s-.07 0 0-.09l.33-.42A.25.25 0 0 1 2.86 3h5.57c.05 0 .08 0 0 .09l-.25.4a.24.24 0 0 1-.17.09zM.06 5.06C0 5.06 0 5 0 5l.32-.42a.3.3 0 0 1 .17-.08h7.13a.08.08 0 0 1 .08.1l-.13.4a.15.15 0 0 1-.14.1zM3.84 6.49c-.06 0-.09 0-.06-.09L4 6a.2.2 0 0 1 .16-.09h3.12a.09.09 0 0 1 .09.09v.37a.13.13 0 0 1-.12.11zM31.94 4.55a4.86 4.86 0 0 0-2.2-3.49 5.72 5.72 0 0 0-4.43-.81A6.56 6.56 0 0 0 21 2.87a6.74 6.74 0 0 0-1.08 2.05h-5a.43.43 0 0 0-.38.25c-.22.41-.6 1.24-.8 1.71-.11.27 0 .47.29.47h3c-.16.22-.28.41-.43.58a2.88 2.88 0 0 1-2.65 1 2.45 2.45 0 0 1-2.15-2.44 3.36 3.36 0 0 1 1.6-3 2.69 2.69 0 0 1 2.81-.23 2 2 0 0 1 .73.6c.2.23.22.21.45.15 1-.25 1.64-.45 2.62-.69.18 0 .24-.12.18-.25a5 5 0 0 0-1.8-2.2 5.48 5.48 0 0 0-4.13-.76A6.88 6.88 0 0 0 9.9 2.82a6.12 6.12 0 0 0-1.32 4.59 4.93 4.93 0 0 0 2 3.47 5.49 5.49 0 0 0 4.18 1 6.45 6.45 0 0 0 4.44-2.66 6.88 6.88 0 0 0 .64-1.07 5 5 0 0 0 1.54 2.43A5.77 5.77 0 0 0 25.16 12c.41-.05.78-.06 1.19-.14a7.21 7.21 0 0 0 3.79-2 6.07 6.07 0 0 0 1.8-5.31zm-5 4.1a2.83 2.83 0 0 1-2.55.09 2.58 2.58 0 0 1-1.42-2.95 3.37 3.37 0 0 1 2.72-2.73 2.58 2.58 0 0 1 3.18 2.09c0 .16 0 .32.05.52a3.44 3.44 0 0 1-2.02 2.98z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/java.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/java.svg
new file mode 100644
index 0000000..15083c7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/java.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="21.779" height="29.53" preserveAspectRatio="xMidYMid"><path fill="#5382a1" d="M7.014 22.837s-1.128.657.803.879c2.34.267 3.536.228 6.115-.26 0 0 .678.425 1.625.794-5.78 2.477-13.083-.144-8.543-1.413m-.706-3.233s-1.266.937.667 1.137c2.5.258 4.474.28 7.89-.379 0 0 .472.48 1.215.741-6.99 2.044-14.774.162-9.772-1.499"/><path fill="#e76f00" d="M12.263 14.12c1.424 1.64-.374 3.116-.374 3.116s3.617-1.867 1.956-4.206c-1.552-2.18-2.742-3.263 3.699-6.999 0 0-10.11 2.525-5.281 8.089"/><path fill="#5382a1" d="M19.909 25.229s.835.688-.92 1.22c-3.337 1.011-13.888 1.316-16.82.04-1.053-.458.923-1.094 1.545-1.227.648-.14 1.018-.115 1.018-.115-1.172-.825-7.574 1.621-3.252 2.322 11.787 1.911 21.486-.861 18.429-2.24M7.557 16.255s-5.367 1.274-1.9 1.737c1.463.196 4.38.152 7.099-.076 2.22-.187 4.451-.586 4.451-.586s-.783.336-1.35.723c-5.45 1.433-15.979.766-12.948-.7 2.564-1.239 4.648-1.099 4.648-1.099m9.628 5.382c5.54-2.879 2.979-5.645 1.19-5.273-.438.092-.633.17-.633.17s.163-.254.473-.365c3.538-1.243 6.258 3.668-1.142 5.613 0 0 .086-.076.112-.145"/><path fill="#e76f00" d="M13.845 0s3.068 3.07-2.91 7.79c-4.795 3.785-1.094 5.944-.003 8.41-2.798-2.524-4.852-4.747-3.474-6.816C9.48 6.348 15.083 4.875 13.845 0"/><path fill="#5382a1" d="M8.101 29.438c5.318.34 13.485-.19 13.678-2.706 0 0-.371.954-4.395 1.712-4.539.854-10.137.754-13.458.207 0 0 .68.563 4.175.787"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/js.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/js.svg
new file mode 100644
index 0000000..39e20b3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/js.svg
@@ -0,0 +1 @@
+<svg width="20" height="20" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid"><path d="M0 0h256v256H0V0z" fill="#F7DF1E"/><path d="m67.312 213.932 19.59-11.856c3.78 6.701 7.218 12.371 15.465 12.371 7.905 0 12.89-3.092 12.89-15.12v-81.798h24.057v82.138c0 24.917-14.606 36.259-35.916 36.259-19.245 0-30.416-9.967-36.087-21.996M152.381 211.354l19.588-11.341c5.157 8.421 11.859 14.607 23.715 14.607 9.969 0 16.325-4.984 16.325-11.858 0-8.248-6.53-11.17-17.528-15.98l-6.013-2.58c-17.357-7.387-28.87-16.667-28.87-36.257 0-18.044 13.747-31.792 35.228-31.792 15.294 0 26.292 5.328 34.196 19.247L210.29 147.43c-4.125-7.389-8.591-10.31-15.465-10.31-7.046 0-11.514 4.468-11.514 10.31 0 7.217 4.468 10.14 14.778 14.608l6.014 2.577c20.45 8.765 31.963 17.7 31.963 37.804 0 21.654-17.012 33.51-39.867 33.51-22.339 0-36.774-10.654-43.819-24.574"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/julia.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/julia.svg
new file mode 100644
index 0000000..3668e0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/julia.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="22" height="22" viewBox="-0.006 2.335 64.006 59.33"><path d="M14.518 61.665C6.493 61.656-.006 55.144 0 47.12s6.515-14.526 14.54-14.523 14.53 6.51 14.53 14.534c-.01 8.03-6.52 14.534-14.55 14.534z" fill="#ca3c32"/><path d="M49.45 61.665c-8.025-.01-14.524-6.52-14.518-14.545s6.515-14.526 14.54-14.523S64 39.105 64 47.13c-.01 8.03-6.52 14.534-14.55 14.534z" fill="#9259a3"/><path d="M31.992 31.404c-8.027 0-14.534-6.507-14.534-14.534S23.965 2.335 31.992 2.335 46.526 8.843 46.526 16.87a14.52 14.52 0 0 1-14.534 14.534z" fill="#399746"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/lisp.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/lisp.svg
new file mode 100644
index 0000000..0d58753
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/lisp.svg
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg" width="24" height="24">
+  <circle cx="256" cy="256" r="235" fill="#fff"/>
+  <path stroke="#000" stroke-width="5" d="m255.56 20.008c-62.374 0.1169-122.17 24.922-166.3 68.992-92.236 92.091-92.353 241.52-0.2617 333.75 92.09 92.236 241.52 92.353 333.75 0.262 92.236-92.091 92.353-241.52 0.262-333.75-44.377-44.447-104.64-69.371-167.45-69.254zm2.281 1.0059c59.934 0.4846 119.39 23.809 164.46 68.953 91.701 91.845 91.585 240.64-0.259 332.34-45.922 45.851-120.32 45.793-166.17-0.129-45.851-45.922-45.793-120.32 0.129-166.17 46.412-46.339 46.471-121.53 0.13-167.94-37.084-37.141-94.457-46.553-140.66-21.658 42.416-31.541 92.711-45.798 142.37-45.396zm-190.84 130.26h40c9.943 42.147 25.204 79.418 40.75 116.43 15.9-41.326 33.203-81.249 55.25-116.43h40c-48.928 97.364-102.19 164.06-24 250h-40c-47.567-77.243-82.439-147.67-112-250z"/>
+  <path d="m293 110.72c78.194 85.936 24.928 152.64-24 250h40c22.047-35.179 39.35-75.102 55.25-116.43 15.546 37.01 30.807 74.282 40.75 116.43h40c-29.561-102.33-64.433-172.76-112-250z"/>
+</svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/ocaml.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/ocaml.svg
new file mode 100644
index 0000000..75550c6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/ocaml.svg
@@ -0,0 +1,66 @@
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="28" x="0px" y="0px"
+	 viewBox="0 0 46 40" style="enable-background:new 0 0 46 40;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#FFFFFF;}
+	.st1{fill:#484444;}
+	.st2{fill:url(#SVGID_1_);}
+	.st3{fill:url(#SVGID_00000019666355307410372800000003889290272895494073_);}
+	.st4{fill:url(#SVGID_00000078009838544920653140000003022816676572672415_);}
+	.st5{fill:url(#SVGID_00000155143267251231807990000005331660806572861321_);}
+</style>
+<path class="st0" d="M23.9,35.2c-0.1-0.4,0.1-0.8-0.1-1.2c-0.1-0.3-0.3-0.4-0.5-0.6c-0.4-0.7-0.8-1.6-0.9-2.4c0-0.8-0.3-1.4-0.4-2.2
+	c0-0.4,0-0.7,0-1.1c0-0.2,0-0.3-0.1-0.5c0,0,0-0.2-0.1-0.3l0.1-0.2c0-0.1,0.8-0.1,1.1-0.1c0.4,0,0.8,0,1.3,0c0.9,0,1.7,0,2.5-0.1
+	c1.9-0.3,2.8-1.1,3.2-1.4c1.7-1.3,2.5-3.3,2.5-3.3c0.3-0.6,0.3-1.8,0.9-2.3c0.7-0.6,1.9-0.6,2.8-0.9c0.5-0.2,0.8-0.3,1.3-0.2
+	c0.4,0.1,1,0.5,1.2-0.1c-0.1-0.1-0.2-0.2-0.2-0.3c0.7-0.1,0-1.7-0.3-2c-0.4-0.5-1.1-0.7-1.9-0.9c-0.9-0.2-1.7-0.5-2.5-0.3
+	c-1.5,0.3-1.3-0.5-2.2-0.5c-1,0-2.9,0.1-3.2,1c-0.1,0.5-0.3,0.5-0.6,0.8c-0.2,0.3,0,0.6-0.1,0.9c-0.1,0.4-0.3,1.6-0.5,2.1
+	c-0.3,0.7-0.6,1.7-1.3,1.7c-0.9,0.1-1.6,0.1-2.3-0.1c-0.4-0.2-1.2-0.4-1.5-0.6c-1.7-0.7-2-1.5-2-1.5c-0.2-0.3-0.7-0.8-0.8-1.4
+	c-0.2-0.7-0.5-1.3-0.7-1.6c-0.1-0.4-0.5-1-0.7-1.6c-0.3-0.8-0.8-1.4-1.1-1.8c-0.5-0.5-1-1.2-2.1-1c-0.2,0-0.9,0.1-1.4,0.5
+	c-0.4,0.3-0.5,0.9-0.8,1.5c-0.2,0.3-0.5,1.2-0.8,1.9c-0.2,0.5-0.3,0.9-0.5,1.1c-0.2,0.1-0.4,0.3-0.7,0.2c-0.2-0.1-0.4-0.2-0.5-0.3
+	c-0.2-0.2-0.8-1.1-1.2-1.9c-0.3-0.6-0.9-1.5-1.3-2c-0.5-0.7-0.8-0.9-1.6-0.9c-1.7,0-1.8,0.9-2.5,2.3c-0.3,0.6-0.4,1.6-1.1,2.3
+	c-0.4,0.4-1.6,2.2-2.4,2.5v0l0,0v12.5l0,0v-0.1c0.1-0.2,0.1-0.3,0.2-0.5c0.3-0.7,1.1-1.3,1.5-2c0.2-0.4,0.5-0.8,0.6-1.2
+	c0.1-0.3,0.2-0.9,0.4-1.2c0.2-0.4,0.6-0.5,0.9-0.6c0.6-0.1,1.1,0.8,1.8,1.2c0.3,0.1,1.7,0.6,2.2,0.8c0.7,0.2,1.5,0.3,2.2,0.5
+	C10.2,28,10.6,28,11,28c0.4,0,1.7,0.1,1.8,0.2c-0.7,0.3-1.1,1.3-1.3,2c-0.3,0.7-0.4,1.5-0.8,2.2c-0.4,0.8-1.1,1.1-1,2
+	c0,0.4,0.1,0.7,0,1.1c-0.1,0.4-0.2,0.7-0.4,1.1c-0.2,0.5-0.3,2.2-0.6,2.7l1.5-0.2l0,0c0.2-0.4,0.3-2,0.4-2.2
+	c0.3-0.8,0.6-1.5,1.2-2.1c0.6-0.6,0.5-1.4,0.8-2.1c0.3-0.8,0.8-1.4,1.3-2.1c0.8-1.3,1.3-3,3-3.3c0.2,0,1.2,0.7,1.7,1.2
+	c0.5,0.5,1.1,1.1,1.5,1.8c0.7,1.4,1.2,3.3,1.5,4.4c0.1,0.6,0.2,0.7,0.6,1.2c0.2,0.2,0.6,0.9,0.7,1.2c0.1,0.3,0.3,0.9,0.5,1.3
+	c0.1,0.2,0.3,0.8,0.5,1.3l1.4,0c0,0,0,0,0,0c0,0,0,0,0,0c0,0,0,0,0,0C24.6,38.3,24.1,36.7,23.9,35.2L23.9,35.2z"/>
+<path class="st1" d="M23,27.1L23,27.1C23,27.1,23,27,23,27.1z"/>
+<linearGradient id="SVGID_1_" gradientUnits="userSpaceOnUse" x1="23.0419" y1="14.9337" x2="23.0419" y2="14.8833" gradientTransform="matrix(1 0 0 -1 0 42)">
+	<stop  offset="0" style="stop-color:#F29100"/>
+	<stop  offset="1" style="stop-color:#EC670F"/>
+</linearGradient>
+<path class="st2" d="M23,27.1L23,27.1C23,27.1,23,27,23,27.1z"/>
+<linearGradient id="SVGID_00000159432202981495199820000013440889407401948575_" gradientUnits="userSpaceOnUse" x1="16.9034" y1="14.6172" x2="16.9034" y2="2.0709" gradientTransform="matrix(1 0 0 -1 0 42)">
+	<stop  offset="0" style="stop-color:#F29100"/>
+	<stop  offset="1" style="stop-color:#EC670F"/>
+</linearGradient>
+<path style="fill:url(#SVGID_00000159432202981495199820000013440889407401948575_);" d="M23.2,38.4c-0.2-0.3-0.4-1-0.5-1.3
+	c-0.1-0.3-0.5-1-0.7-1.2c-0.4-0.5-0.5-0.5-0.6-1.2c-0.2-1.1-0.8-3-1.5-4.4c-0.3-0.7-0.9-1.3-1.5-1.8c-0.5-0.4-1.5-1.2-1.7-1.2
+	c-1.7,0.3-2.2,2-3,3.3c-0.4,0.7-0.9,1.3-1.3,2.1c-0.3,0.7-0.3,1.5-0.8,2.1c-0.6,0.6-0.9,1.3-1.2,2.1c-0.1,0.2-0.2,1.8-0.4,2.2l0,0
+	l2.5-0.2c2.3,0.2,1.7,1.1,5.3,0.9l5.8-0.2C23.5,39.2,23.3,38.6,23.2,38.4L23.2,38.4z"/>
+<linearGradient id="SVGID_00000089567650013081133770000010991480540068032155_" gradientUnits="userSpaceOnUse" x1="23.0024" y1="42" x2="23.0024" y2="2.0465" gradientTransform="matrix(1 0 0 -1 0 42)">
+	<stop  offset="0" style="stop-color:#F29100"/>
+	<stop  offset="1" style="stop-color:#EC670F"/>
+</linearGradient>
+<path style="fill:url(#SVGID_00000089567650013081133770000010991480540068032155_);" d="M40.2,0H5.9C2.7,0,0.1,2.6,0.1,5.8v12.6
+	c0.8-0.3,2-2.1,2.4-2.5c0.7-0.7,0.8-1.7,1.1-2.3c0.7-1.4,0.9-2.3,2.5-2.3c0.8,0,1.1,0.2,1.6,0.9c0.4,0.5,1,1.4,1.3,2
+	c0.3,0.7,0.9,1.7,1.2,1.9c0.2,0.1,0.4,0.3,0.5,0.3c0.3,0.1,0.5-0.1,0.7-0.2c0.2-0.2,0.3-0.6,0.5-1.1c0.3-0.7,0.6-1.6,0.8-1.9
+	c0.3-0.5,0.4-1.1,0.8-1.5c0.5-0.4,1.2-0.5,1.4-0.5c1.1-0.2,1.6,0.5,2.1,1c0.3,0.3,0.8,0.9,1.1,1.8c0.3,0.6,0.6,1.2,0.7,1.6
+	c0.1,0.4,0.5,0.9,0.7,1.6c0.2,0.6,0.7,1.1,0.8,1.4c0,0,0.3,0.8,2,1.5c0.4,0.2,1.1,0.4,1.5,0.6c0.7,0.3,1.4,0.2,2.3,0.1
+	c0.6,0,1-0.9,1.3-1.7c0.2-0.4,0.3-1.7,0.5-2.1c0.1-0.3-0.1-0.6,0.1-0.9c0.3-0.4,0.4-0.4,0.6-0.8c0.3-1,2.1-1,3.2-1
+	c0.9,0,0.7,0.8,2.2,0.5c0.8-0.2,1.6,0.1,2.5,0.3c0.7,0.2,1.4,0.4,1.9,0.9c0.3,0.3,0.9,1.9,0.3,2c0.1,0.1,0.1,0.2,0.2,0.3
+	c-0.2,0.6-0.8,0.2-1.2,0.1c-0.5-0.1-0.8,0-1.3,0.2c-0.8,0.4-2,0.3-2.8,0.9c-0.6,0.5-0.6,1.7-0.9,2.3c0,0-0.8,2-2.5,3.3
+	c-0.4,0.3-1.3,1.1-3.2,1.4c-0.8,0.1-1.6,0.1-2.5,0.1c-0.4,0-0.8,0-1.3,0c-0.3,0-1.1,0-1.1,0.1l-0.1,0.2c0,0.1,0,0.3,0.1,0.3
+	c0,0.2,0,0.3,0.1,0.5c0,0.4,0,0.7,0,1.1c0,0.8,0.3,1.4,0.4,2.2c0,0.8,0.5,1.7,0.9,2.4c0.2,0.3,0.4,0.3,0.5,0.6
+	c0.1,0.4,0,0.8,0.1,1.2c0.2,1.5,0.7,3.1,1.4,4.5c0,0,0,0,0,0c0.9-0.1,1.7-0.4,2.8-0.6c2-0.3,4.8-0.1,6.7-0.3
+	c4.6-0.4,7.1,1.9,11.2,0.9V5.8C45.9,2.6,43.3,0,40.2,0z M23,27.1C23,27,23,27.1,23,27.1L23,27.1z"/>
+<linearGradient id="SVGID_00000104673081434150911260000016506419810385994163_" gradientUnits="userSpaceOnUse" x1="6.4072" y1="16.4857" x2="6.4072" y2="2.3223" gradientTransform="matrix(1 0 0 -1 0 42)">
+	<stop  offset="0" style="stop-color:#F29100"/>
+	<stop  offset="1" style="stop-color:#EC670F"/>
+</linearGradient>
+<path style="fill:url(#SVGID_00000104673081434150911260000016506419810385994163_);" d="M10.6,32.4c0.3-0.7,0.5-1.5,0.8-2.2
+	c0.3-0.7,0.6-1.7,1.3-2c-0.1-0.1-1.4-0.1-1.8-0.2c-0.4,0-0.8-0.1-1.1-0.2c-0.7-0.1-1.5-0.3-2.2-0.5c-0.4-0.1-1.9-0.6-2.2-0.8
+	c-0.7-0.3-1.2-1.2-1.8-1.2c-0.4,0.1-0.7,0.2-0.9,0.6c-0.2,0.3-0.2,0.8-0.4,1.2c-0.1,0.4-0.4,0.8-0.6,1.2c-0.4,0.7-1.2,1.3-1.5,2
+	c-0.1,0.1-0.1,0.3-0.2,0.5v7.8c0.4,0.1,0.8,0.1,1.2,0.3c3.2,0.9,4,0.9,7.2,0.6l0.3,0v0c0.2-0.5,0.4-2.2,0.6-2.7
+	c0.1-0.4,0.3-0.7,0.4-1.1c0.1-0.4,0-0.8,0-1.1C9.5,33.5,10.3,33.2,10.6,32.4L10.6,32.4z"/>
+</svg>
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/php.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/php.svg
new file mode 100644
index 0000000..f88c8ac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/php.svg
@@ -0,0 +1 @@
+<svg width="27" height="14" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><path d="M2.14 2.94h4A3.05 3.05 0 0 1 8.69 4a3.59 3.59 0 0 1 .53 2.82 5.59 5.59 0 0 1-.47 1.61 4.6 4.6 0 0 1-1 1.42 3.31 3.31 0 0 1-1.6 1 6.9 6.9 0 0 1-1.76.22H2.64L2.08 14H0zM3.88 4.7 3 9.33h.39a7.55 7.55 0 0 0 2.39-.29c.63-.22 1.06-1 1.28-2.25.18-1.08 0-1.7-.54-1.87a6.6 6.6 0 0 0-2-.23H3.87zM11.59 0h2.06l-.59 2.94h1.86a3.72 3.72 0 0 1 2.27.65c.51.41.66 1.19.45 2.35l-1 5.13h-2.1l1-4.9a1.44 1.44 0 0 0-.09-1.1 1.26 1.26 0 0 0-1-.32h-1.66l-1.29 6.32H9.43zM19.85 2.94h4A3.08 3.08 0 0 1 26.41 4a3.59 3.59 0 0 1 .52 2.82 5.56 5.56 0 0 1-.46 1.61 4.81 4.81 0 0 1-1 1.42 3.31 3.31 0 0 1-1.6 1 6.79 6.79 0 0 1-1.76.22h-1.75L19.79 14h-2.08zM21.6 4.7l-.9 4.63h.39a7.51 7.51 0 0 0 2.39-.29q1-.33 1.29-2.25c.17-1.08 0-1.7-.54-1.87a6.67 6.67 0 0 0-2-.23h-.66z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/postgres.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/postgres.svg
new file mode 100644
index 0000000..e7b5622
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/postgres.svg
@@ -0,0 +1 @@
+<svg width="21" height="22" viewBox="0 0 432.071 445.383" xml:space="preserve" xmlns="http://www.w3.org/2000/svg"><g style="fill-rule:nonzero;clip-rule:nonzero;fill:none;stroke:#fff;stroke-width:12.4651;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4"><path style="fill:#000;stroke:#000;stroke-width:37.3953;stroke-linecap:butt;stroke-linejoin:miter" d="M323.205 324.227c2.833-23.601 1.984-27.062 19.563-23.239l4.463.392c13.517.615 31.199-2.174 41.587-7 22.362-10.376 35.622-27.7 13.572-23.148-50.297 10.376-53.755-6.655-53.755-6.655 53.111-78.803 75.313-178.836 56.149-203.322-52.27-66.789-142.748-35.206-144.262-34.386l-.482.089c-9.938-2.062-21.06-3.294-33.554-3.496-22.761-.374-40.032 5.967-53.133 15.904 0 0-161.408-66.498-153.899 83.628 1.597 31.936 45.777 241.655 98.47 178.31 19.259-23.163 37.871-42.748 37.871-42.748 9.242 6.14 20.307 9.272 31.912 8.147l.897-.765c-.281 2.876-.157 5.689.359 9.019-13.572 15.167-9.584 17.83-36.723 23.416-27.457 5.659-11.326 15.734-.797 18.367 12.768 3.193 42.305 7.716 62.268-20.224l-.795 3.188c5.325 4.26 4.965 30.619 5.72 49.452.756 18.834 2.017 36.409 5.856 46.771 3.839 10.36 8.369 37.05 44.036 29.406 29.809-6.388 52.6-15.582 54.677-101.107"/><path style="fill:#336791;stroke:none" d="M402.395 271.23c-50.302 10.376-53.76-6.655-53.76-6.655 53.111-78.808 75.313-178.843 56.153-203.326-52.27-66.785-142.752-35.2-144.262-34.38l-.486.087c-9.938-2.063-21.06-3.292-33.56-3.496-22.761-.373-40.026 5.967-53.127 15.902 0 0-161.411-66.495-153.904 83.63 1.597 31.938 45.776 241.657 98.471 178.312 19.26-23.163 37.869-42.748 37.869-42.748 9.243 6.14 20.308 9.272 31.908 8.147l.901-.765c-.28 2.876-.152 5.689.361 9.019-13.575 15.167-9.586 17.83-36.723 23.416-27.459 5.659-11.328 15.734-.796 18.367 12.768 3.193 42.307 7.716 62.266-20.224l-.796 3.188c5.319 4.26 9.054 27.711 8.428 48.969-.626 21.259-1.044 35.854 3.147 47.254 4.191 11.4 8.368 37.05 44.042 29.406 29.809-6.388 45.256-22.942 47.405-50.555 1.525-19.631 4.976-16.729 5.194-34.28l2.768-8.309c3.192-26.611.507-35.196 18.872-31.203l4.463.392c13.517.615 31.208-2.174 41.591-7 22.358-10.376 35.618-27.7 13.573-23.148z"/><path d="M215.866 286.484c-1.385 49.516.348 99.377 5.193 111.495 4.848 12.118 15.223 35.688 50.9 28.045 29.806-6.39 40.651-18.756 45.357-46.051 3.466-20.082 10.148-75.854 11.005-87.281M173.104 38.256S11.583-27.76 19.092 122.365c1.597 31.938 45.779 241.664 98.473 178.316 19.256-23.166 36.671-41.335 36.671-41.335M260.349 26.207c-5.591 1.753 89.848-34.889 144.087 34.417 19.159 24.484-3.043 124.519-56.153 203.329"/><path style="stroke-linejoin:bevel" d="M348.282 263.953s3.461 17.036 53.764 6.653c22.04-4.552 8.776 12.774-13.577 23.155-18.345 8.514-59.474 10.696-60.146-1.069-1.729-30.355 21.647-21.133 19.96-28.739-1.525-6.85-11.979-13.573-18.894-30.338-6.037-14.633-82.796-126.849 21.287-110.183 3.813-.789-27.146-99.002-124.553-100.599-97.385-1.597-94.19 119.762-94.19 119.762"/><path d="M188.604 274.334c-13.577 15.166-9.584 17.829-36.723 23.417-27.459 5.66-11.326 15.733-.797 18.365 12.768 3.195 42.307 7.718 62.266-20.229 6.078-8.509-.036-22.086-8.385-25.547-4.034-1.671-9.428-3.765-16.361 3.994z"/><path d="M187.715 274.069c-1.368-8.917 2.93-19.528 7.536-31.942 6.922-18.626 22.893-37.255 10.117-96.339-9.523-44.029-73.396-9.163-73.436-3.193-.039 5.968 2.889 30.26-1.067 58.548-5.162 36.913 23.488 68.132 56.479 64.938"/><path style="fill:#fff;stroke-width:4.155;stroke-linecap:butt;stroke-linejoin:miter" d="M172.517 141.7c-.288 2.039 3.733 7.48 8.976 8.207 5.234.73 9.714-3.522 9.998-5.559.284-2.039-3.732-4.285-8.977-5.015-5.237-.731-9.719.333-9.996 2.367z"/><path style="fill:#fff;stroke-width:2.0775;stroke-linecap:butt;stroke-linejoin:miter" d="M331.941 137.543c.284 2.039-3.732 7.48-8.976 8.207-5.238.73-9.718-3.522-10.005-5.559-.277-2.039 3.74-4.285 8.979-5.015 5.239-.73 9.718.333 10.002 2.368z"/><path d="M350.676 123.432c.863 15.994-3.445 26.888-3.988 43.914-.804 24.748 11.799 53.074-7.191 81.435"/></g></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/python.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/python.svg
new file mode 100644
index 0000000..3a223e7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/python.svg
@@ -0,0 +1 @@
+<svg width="20" height="20" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><path d="M9.93 0C4.87 0 5.18 2.21 5.18 2.21V4.5H10v.7H3.25S0 4.82 0 10s2.84 5 2.84 5h1.69v-2.44A2.71 2.71 0 0 1 7.32 9.7h4.79a2.58 2.58 0 0 0 2.69-2.62V2.67S15.23 0 9.93 0zM7.26 1.53a.88.88 0 1 1-.87.88.88.88 0 0 1 .87-.88z" style="fill:#387ab0"/><path d="M10.07 20c5.06 0 4.75-2.21 4.75-2.21V15.5H10v-.7h6.76S20 15.18 20 10s-2.84-5-2.84-5h-1.69v2.44a2.71 2.71 0 0 1-2.79 2.86H7.89a2.58 2.58 0 0 0-2.69 2.62v4.41S4.77 20 10.07 20zm2.67-1.53a.88.88 0 1 1 .87-.88.88.88 0 0 1-.87.88z" style="fill:#feca3d"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/r.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/r.svg
new file mode 100644
index 0000000..73ef658
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/r.svg
@@ -0,0 +1 @@
+<svg width="24" height="18" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMidYMid" viewBox="0 0 724 561"><defs><linearGradient id="a" x1="0" x2="1" y1="0" y2="1" gradientUnits="objectBoundingBox" spreadMethod="pad"><stop offset="0" stop-color="#CBCED0"/><stop offset="1" stop-color="#84838B"/></linearGradient><linearGradient id="b" x1="0" x2="1" y1="0" y2="1" gradientUnits="objectBoundingBox" spreadMethod="pad"><stop offset="0" stop-color="#276DC3"/><stop offset="1" stop-color="#165CAA"/></linearGradient></defs><path d="M361.453 485.937C162.329 485.937.906 377.828.906 244.469.906 111.109 162.329 3 361.453 3 560.578 3 722 111.109 722 244.469c0 133.359-161.422 241.468-360.547 241.468zm55.188-388.531c-151.352 0-274.047 73.908-274.047 165.078s122.695 165.078 274.047 165.078c151.351 0 263.046-50.529 263.046-165.078 0-114.513-111.695-165.078-263.046-165.078z" fill="url(#a)" fill-rule="evenodd"/><path d="M550 377s21.822 6.585 34.5 13c4.399 2.226 12.01 6.668 17.5 12.5 5.378 5.712 8 11.5 8 11.5l86 145-139 .062L492 437s-13.31-22.869-21.5-29.5c-6.832-5.531-9.745-7.5-16.5-7.5h-33.026L421 558.974l-123 .052V152.938h247S657.5 154.967 657.5 262 550 377 550 377zm-53.5-135.976-74.463-.048-.037 69.05 74.5-.024s34.5-.107 34.5-35.125c0-35.722-34.5-33.853-34.5-33.853z" fill="url(#b)" fill-rule="evenodd"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/ruby.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/ruby.svg
new file mode 100644
index 0000000..aad08a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/ruby.svg
@@ -0,0 +1 @@
+<svg width="20" height="20" id="Layer_1" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><defs><style>.cls-1{fill:#b11917}</style></defs><path class="cls-1" d="m2 12.84-.42-1C1.21 11 .86 10.15.51 9.3a.08.08 0 0 1 0-.1C1.23 8 2 6.73 2.67 5.49a.61.61 0 0 1 .12-.16l3.9-3.65a.74.74 0 0 1 .21-.13L10.2.33a.11.11 0 0 1 .1 0l2.77 2v.09c-.47 1.48-.93 3-1.4 4.44a.41.41 0 0 1 0 .09l-5.28 4.87H6.3L2 12.83zM5.12 19.94Q6 16.38 6.9 12.83l6.78 2.63h-.07A22.89 22.89 0 0 1 11 17.58a14.7 14.7 0 0 1-4.29 2 13.17 13.17 0 0 1-1.54.33zM12.68 7.55l6.67-.15c-.08.19-.14.37-.22.55a18.59 18.59 0 0 1-2.54 4.3c-.54.7-1.11 1.35-1.69 2zM7.39 12.08l4.48-4.19 2.21 6.79zM15.29 15.19l.05-.05c.59-.64 1.17-1.29 1.71-2a21.07 21.07 0 0 0 2.38-3.74l.21-.4q-.37 4.79-.73 9.55M19.73 6.08l-5.34-3.9 3.22-1.8a.06.06 0 0 1 .06 0 3.5 3.5 0 0 1 2 2A4.49 4.49 0 0 1 20 3.54a6.5 6.5 0 0 1-.12 1.92c-.07.2-.11.4-.15.62zM18.46 19.09 9 19.74a21.13 21.13 0 0 0 5.66-4l.42.38M12.66 6.67c.4-1.27.8-2.53 1.19-3.8l5 3.65zM4.32 19.48c-.67-1.94-1.43-3.87-2.11-5.81L6 12.83c-.56 2.23-1.12 4.44-1.67 6.65zM1.64 14.4c.64 1.87 1.29 3.73 1.94 5.6h-.3A4.44 4.44 0 0 1 2 19.53 3.32 3.32 0 0 1 .54 18.1 4.57 4.57 0 0 1 .15 17a.19.19 0 0 1 0-.08l1.45-2.49zM11.33 0h5.15l-2.81 1.58h-.09L11.36 0zM0 15.47v-5.12.08c.39.94.79 1.89 1.18 2.84a.08.08 0 0 1 0 .1L0 15.42a.13.13 0 0 1 0 .05z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/rust.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/rust.svg
new file mode 100644
index 0000000..c88b70b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/rust.svg
@@ -0,0 +1 @@
+<svg width="22" height="22" data-name="Layer 1" xmlns="http://www.w3.org/2000/svg"><path d="m21.85 10.73-.92-.57v-.27l.79-.74a.34.34 0 0 0 .1-.3.33.33 0 0 0-.2-.23l-1-.38a2 2 0 0 0-.13-.24l.64-.88a.34.34 0 0 0 0-.31.31.31 0 0 0-.24-.19l-1.07-.18c0-.08-.08-.16-.13-.24l.45-1a.31.31 0 0 0-.3-.45h-1.08l-.18-.21.25-1.06a.31.31 0 0 0-.38-.38l-1.06.25a1.73 1.73 0 0 0-.21-.17V2.09a.32.32 0 0 0-.14-.28.31.31 0 0 0-.31 0l-1 .45-.24-.13-.09-1.05a.31.31 0 0 0-.19-.24.34.34 0 0 0-.31 0l-.9.67-.26-.08-.38-1a.33.33 0 0 0-.23-.2.34.34 0 0 0-.3.1l-.74.79h-.27l-.55-.97a.32.32 0 0 0-.54 0l-.57.92h-.27L9.15.31a.32.32 0 0 0-.53.1l-.38 1-.24.1-.9-.64a.32.32 0 0 0-.5.21l-.18 1.07-.24.13-1-.45a.31.31 0 0 0-.31 0 .32.32 0 0 0-.14.28V3.2l-.21.17-1-.23a.31.31 0 0 0-.38.38l.25 1.06-.17.21H2.13a.32.32 0 0 0-.28.14.31.31 0 0 0 0 .31l.45 1-.13.24-1.09.12a.31.31 0 0 0-.24.19.34.34 0 0 0 0 .31l.67.9a2 2 0 0 0-.08.26l-1 .38a.33.33 0 0 0-.2.23.34.34 0 0 0 .1.3l.79.74v.27l-.92.57a.32.32 0 0 0 0 .54l.92.57v.27l-.79.74a.34.34 0 0 0-.1.3.33.33 0 0 0 .2.23l1 .38a2 2 0 0 0 .08.26l-.64.88a.34.34 0 0 0 0 .31.31.31 0 0 0 .24.19l1.07.18.13.24-.45 1a.31.31 0 0 0 0 .31.32.32 0 0 0 .28.14h1.09a1.73 1.73 0 0 0 .17.21l-.25 1.06a.31.31 0 0 0 .38.38l1.06-.25.21.17v1.09a.32.32 0 0 0 .14.28.31.31 0 0 0 .31 0l1-.45.24.13.18 1.07a.31.31 0 0 0 .19.24.34.34 0 0 0 .31 0l.83-.73.26.08.38 1a.33.33 0 0 0 .23.2.34.34 0 0 0 .3-.1l.74-.79h.27l.57.92a.32.32 0 0 0 .54 0l.57-.92h.27l.74.79a.34.34 0 0 0 .3.1.33.33 0 0 0 .23-.2l.38-1 .26-.08.88.64a.34.34 0 0 0 .31 0 .31.31 0 0 0 .19-.24l.18-1.07.24-.13 1 .45a.31.31 0 0 0 .31 0 .32.32 0 0 0 .14-.28v-1.09a1.73 1.73 0 0 0 .21-.17l1.06.25a.31.31 0 0 0 .38-.38l-.25-1.06.18-.21h1.08a.31.31 0 0 0 .3-.45l-.45-1c.05-.08.09-.16.13-.24l1.07-.18a.31.31 0 0 0 .24-.19.34.34 0 0 0 0-.31l-.75-.83a2 2 0 0 0 .08-.26l1-.38a.33.33 0 0 0 .2-.23.34.34 0 0 0-.1-.3l-.79-.74v-.27l.92-.57a.32.32 0 0 0 0-.54zm-6.18 7.66a.65.65 0 0 1 .27-1.28.66.66 0 0 1 .5.78.64.64 0 0 1-.77.5zm-.32-2.12a.59.59 0 0 0-.7.46l-.33 1.53A8 8 0 0 1 11 19a8.16 8.16 0 0 1-3.39-.74l-.33-1.56a.58.58 0 0 0-.7-.46l-1.35.29a7.88 7.88 0 0 1-.7-.83h6.57c.08 0 .12 0 .12-.08V13.3c0-.07 0-.08-.12-.08H9.18v-1.48h2.08a1.32 1.32 0 0 1 1.28 1.11c.08.33.26 1.38.38 1.72s.63 1.13 1.17 1.13h3.39a10.43 10.43 0 0 1-.74.88zm-9.09 2.09a.64.64 0 0 1-.77-.5.65.65 0 0 1 .5-.78.65.65 0 0 1 .27 1.28zM3.77 8.25a.65.65 0 1 1-.86-.33.64.64 0 0 1 .86.33zM3 10.07l1.41-.63a.59.59 0 0 0 .3-.79L4.42 8h1.14v5.14h-2.3A8.54 8.54 0 0 1 3 10.07zm6.18-.5V8.05h2.71c.14 0 1 .16 1 .8s-.65.72-1.18.72zM19 10.93v.6h-.8c-.09 0-.12.05-.12.13V12c0 .89-.5 1.09-.94 1.14s-.89-.18-.95-.44a2.81 2.81 0 0 0-1.31-2.2 3 3 0 0 0 1.65-2.29 2.59 2.59 0 0 0-1.26-2.12 3.63 3.63 0 0 0-1.73-.57H5A8.07 8.07 0 0 1 9.51 3l1 1.06a.6.6 0 0 0 .85 0L12.48 3A8.07 8.07 0 0 1 18 6.94l-.77 1.74a.59.59 0 0 0 .3.79l1.48.66a7 7 0 0 1-.01.8zm-8.53-8.8a.66.66 0 0 1 .93 0 .65.65 0 0 1 0 .92.66.66 0 0 1-.93 0 .65.65 0 0 1 .04-.92zm7.65 6.15A.65.65 0 0 1 19 8a.65.65 0 1 1-.86.33z"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/swift.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/swift.svg
new file mode 100644
index 0000000..6678248
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/swift.svg
@@ -0,0 +1 @@
+<svg width="20" height="18" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 40 36"><defs><linearGradient id="a" x2="50%" x1="50%" y2="100%"><stop stop-color="#F88A36" offset="0"/><stop stop-color="#FD2020" offset="1"/></linearGradient></defs><path d="M29.885 33.047c-4.667 2.696-11.084 2.973-17.54.206C7.118 31.029 2.78 27.136 0 22.688c1.335 1.112 2.892 2.002 4.56 2.78 6.667 3.125 13.333 2.911 18.024.008l-.007-.008C15.904 20.352 10.232 13.679 6.006 8.23c-.89-.89-1.558-2.002-2.225-3.003 5.116 4.671 13.235 10.565 16.126 12.234C13.791 11.011 8.341 3.003 8.563 3.225c9.676 9.787 18.685 15.348 18.685 15.348.298.168.528.308.713.433.195-.496.366-1.01.51-1.545 1.557-5.672-.222-12.123-4.115-17.46 9.008 5.449 14.347 15.68 12.122 24.244-.058.231-.12.46-.189.683l.078.096c4.448 5.561 3.225 11.455 2.67 10.343-2.414-4.722-6.88-3.278-9.152-2.32z" fill="url(#a)"/></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/languages/vlang.svg b/arbitrator/tools/module_roots/wasmer/assets/languages/vlang.svg
new file mode 100644
index 0000000..8407d7d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/assets/languages/vlang.svg
@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!-- Generator: Gravit.io --><svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" style="isolation:isolate" viewBox="0 0 32 32" width="24px" height="24px"><defs><clipPath id="_clipPath_ufTXO6xqzZr110CHnBiHYhaulAuRvYq4"><rect width="32" height="32"/></clipPath></defs><g clip-path="url(#_clipPath_ufTXO6xqzZr110CHnBiHYhaulAuRvYq4)"><path d=" M 20.786 30.237 L 30.948 1.978 C 31.121 1.499 30.849 1.15 30.342 1.198 L 22.35 1.968 C 21.843 2.017 21.296 2.447 21.128 2.928 L 11.722 29.935 C 11.555 30.416 11.832 30.806 12.341 30.806 L 20.12 30.806 C 20.375 30.806 20.651 30.612 20.737 30.372 L 20.786 30.237 Z " fill="rgb(83,107,138)"/><path d=" M 1.658 1.198 L 9.65 1.968 C 10.157 2.017 10.705 2.447 10.873 2.928 L 20.478 30.371 C 20.562 30.611 20.424 30.806 20.169 30.806 L 12.341 30.806 C 11.832 30.806 11.279 30.417 11.106 29.938 L 1.052 1.978 C 0.879 1.499 1.151 1.15 1.658 1.198 Z " fill="rgb(93,135,191)"/></g></svg>
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/assets/logo-white.png b/arbitrator/tools/module_roots/wasmer/assets/logo-white.png
new file mode 100644
index 0000000..8b2cbc2
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/assets/logo-white.png differ
diff --git a/arbitrator/tools/module_roots/wasmer/assets/logo.png b/arbitrator/tools/module_roots/wasmer/assets/logo.png
new file mode 100644
index 0000000..e691e92
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/assets/logo.png differ
diff --git a/arbitrator/tools/module_roots/wasmer/benches/README.md b/arbitrator/tools/module_roots/wasmer/benches/README.md
new file mode 100644
index 0000000..cb81186
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/benches/README.md
@@ -0,0 +1,4 @@
+# Wasmer Benches
+
+This directory contains small, punctual benches. Other benchmarks are
+landing somewhere else. We will update this section soon.
diff --git a/arbitrator/tools/module_roots/wasmer/benches/static_and_dynamic_functions.rs b/arbitrator/tools/module_roots/wasmer/benches/static_and_dynamic_functions.rs
new file mode 100644
index 0000000..4a8bf30
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/benches/static_and_dynamic_functions.rs
@@ -0,0 +1,195 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+
+use wasmer::*;
+
+static BASIC_WAT: &str = r#"(module
+    (func $multiply (import "env" "multiply") (param i32 i32) (result i32))
+    (func (export "add") (param i32 i32) (result i32)
+       (i32.add (local.get 0)
+                (local.get 1)))
+    (func (export "add20") (param i32 i32 i32 i32 i32
+                                  i32 i32 i32 i32 i32
+                                  i32 i32 i32 i32 i32
+                                  i32 i32 i32 i32 i32) (result i32)
+       (i32.add
+                (i32.add
+                         (i32.add (i32.add (i32.add (local.get 0)  (local.get 1))
+                                           (i32.add (local.get 2)  (local.get 3)))
+                                  (i32.add (i32.add (local.get 4)  (local.get 5))
+                                           (i32.add (local.get 6)  (local.get 7))))
+                         (i32.add
+                                  (i32.add (i32.add (local.get 8)  (local.get 9))
+                                           (i32.add (local.get 10) (local.get 11)))
+                                  (i32.add (i32.add (local.get 12) (local.get 13))
+                                           (i32.add (local.get 14) (local.get 15)))))
+
+                (i32.add (i32.add (local.get 16) (local.get 17))
+                         (i32.add (local.get 18) (local.get 19))))
+)
+    (func (export "double_then_add") (param i32 i32) (result i32)
+       (i32.add (call $multiply (local.get 0) (i32.const 2))
+                (call $multiply (local.get 1) (i32.const 2))))
+)"#;
+
+pub fn run_basic_static_function(store: &mut Store, compiler_name: &str, c: &mut Criterion) {
+    let module = Module::new(store, BASIC_WAT).unwrap();
+    let import_object = imports! {
+        "env" => {
+            "multiply" => Function::new_typed(store, |a: i32, b: i32| a * b),
+        },
+    };
+    let instance = Instance::new(store, &module, &import_object).unwrap();
+    let dyn_f: &Function = instance.exports.get("add").unwrap();
+    let f: TypedFunction<(i32, i32), i32> = dyn_f.typed(store).unwrap();
+
+    c.bench_function(&format!("basic static func {}", compiler_name), |b| {
+        b.iter(|| {
+            let result = black_box(f.call(store, 4, 6).unwrap());
+            assert_eq!(result, 10);
+        })
+    });
+
+    let dyn_f_many: &Function = instance.exports.get("add20").unwrap();
+    let f_many: TypedFunction<
+        (
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+            i32,
+        ),
+        i32,
+    > = dyn_f_many.typed(store).unwrap();
+    c.bench_function(
+        &format!("basic static func with many args {}", compiler_name),
+        |b| {
+            b.iter(|| {
+                let result = black_box(
+                    f_many
+                        .call(
+                            store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+                            19, 20,
+                        )
+                        .unwrap(),
+                );
+                assert_eq!(result, 210);
+            })
+        },
+    );
+}
+
+pub fn run_basic_dynamic_function(store: &mut Store, compiler_name: &str, c: &mut Criterion) {
+    let module = Module::new(store, BASIC_WAT).unwrap();
+    let import_object = imports! {
+        "env" => {
+            "multiply" => Function::new_typed(store, |a: i32, b: i32| a * b),
+        },
+    };
+    let instance = Instance::new(store, &module, &import_object).unwrap();
+
+    let dyn_f: &Function = instance.exports.get("add").unwrap();
+    c.bench_function(&format!("basic dynfunc {}", compiler_name), |b| {
+        b.iter(|| {
+            let dyn_result = black_box(dyn_f.call(store, &[Value::I32(4), Value::I32(6)]).unwrap());
+            assert_eq!(dyn_result[0], Value::I32(10));
+        })
+    });
+
+    let dyn_f_many: &Function = instance.exports.get("add20").unwrap();
+    c.bench_function(
+        &format!("basic dynfunc with many args {}", compiler_name),
+        |b| {
+            b.iter(|| {
+                let dyn_result = black_box(
+                    dyn_f_many
+                        .call(
+                            store,
+                            &[
+                                Value::I32(1),
+                                Value::I32(2),
+                                Value::I32(3),
+                                Value::I32(4),
+                                Value::I32(5),
+                                Value::I32(6),
+                                Value::I32(7),
+                                Value::I32(8),
+                                Value::I32(9),
+                                Value::I32(10),
+                                Value::I32(11),
+                                Value::I32(12),
+                                Value::I32(13),
+                                Value::I32(14),
+                                Value::I32(15),
+                                Value::I32(16),
+                                Value::I32(17),
+                                Value::I32(18),
+                                Value::I32(19),
+                                Value::I32(20),
+                            ],
+                        )
+                        .unwrap(),
+                );
+                assert_eq!(dyn_result[0], Value::I32(210));
+            })
+        },
+    );
+}
+
+fn run_static_benchmarks(_c: &mut Criterion) {
+    #[cfg(feature = "llvm")]
+    {
+        let mut store = Store::new(wasmer_compiler_llvm::LLVM::new());
+        run_basic_static_function(&mut store, "llvm", _c);
+    }
+
+    #[cfg(feature = "cranelift")]
+    {
+        let mut store = Store::new(wasmer_compiler_cranelift::Cranelift::new());
+        run_basic_static_function(&mut store, "cranelift", _c);
+    }
+
+    #[cfg(feature = "singlepass")]
+    {
+        let mut store = Store::new(wasmer_compiler_singlepass::Singlepass::new());
+        run_basic_static_function(&mut store, "singlepass", _c);
+    }
+}
+
+fn run_dynamic_benchmarks(_c: &mut Criterion) {
+    #[cfg(feature = "llvm")]
+    {
+        let mut store = Store::new(wasmer_compiler_llvm::LLVM::new());
+        run_basic_dynamic_function(&mut store, "llvm", _c);
+    }
+
+    #[cfg(feature = "cranelift")]
+    {
+        let mut store = Store::new(wasmer_compiler_cranelift::Cranelift::new());
+        run_basic_dynamic_function(&mut store, "cranelift", _c);
+    }
+
+    #[cfg(feature = "singlepass")]
+    {
+        let mut store = Store::new(wasmer_compiler_singlepass::Singlepass::new());
+        run_basic_dynamic_function(&mut store, "singlepass", _c);
+    }
+}
+
+criterion_group!(benches, run_static_benchmarks, run_dynamic_benchmarks);
+
+criterion_main!(benches);
diff --git a/arbitrator/tools/module_roots/wasmer/build.rs b/arbitrator/tools/module_roots/wasmer/build.rs
new file mode 100644
index 0000000..d069178
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/build.rs
@@ -0,0 +1,109 @@
+//! The logic that gets executed before building the binary and tests.
+//! We use it to auto-generate the Wasm spectests for each of the
+//! available compilers.
+//!
+//! Please try to keep this file as clean as possible.
+
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+use test_generator::{
+    test_directory, test_directory_module, wasi_processor, wast_processor, with_test_module,
+    Testsuite,
+};
+
+fn main() -> anyhow::Result<()> {
+    // As rerun-if-changed doesn't support globs, we use another crate
+    // to check changes in directories.
+    build_deps::rerun_if_changed_paths("tests/wasi-wast/wasi/unstable/*")
+        .expect("Can't get directory");
+    build_deps::rerun_if_changed_paths("tests/wasi-wast/wasi/snapshot1/*")
+        .expect("Can't get directory");
+    build_deps::rerun_if_changed_paths("tests/wasi-wast/wasi/nightly-2022-10-18/*")
+        .expect("Can't get directory");
+
+    let out_dir = PathBuf::from(
+        env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
+    );
+
+    // Spectests test generation
+    {
+        let mut spectests = Testsuite {
+            buffer: String::new(),
+            path: vec![],
+        };
+
+        with_test_module(&mut spectests, "spec", |spectests| {
+            let _spec_tests = test_directory(spectests, "tests/wast/spec", wast_processor)?;
+            test_directory_module(
+                spectests,
+                "tests/wast/spec/proposals/multi-value",
+                wast_processor,
+            )?;
+            test_directory_module(spectests, "tests/wast/spec/proposals/simd", wast_processor)?;
+            test_directory_module(
+                spectests,
+                "tests/wast/spec/proposals/threads",
+                wast_processor,
+            )?;
+            // test_directory_module(spectests, "tests/wast/spec/proposals/bulk-memory-operations", wast_processor)?;
+            Ok(())
+        })?;
+        with_test_module(&mut spectests, "wasmer", |spectests| {
+            let _spec_tests = test_directory(spectests, "tests/wast/wasmer", wast_processor)?;
+            Ok(())
+        })?;
+
+        let spectests_output = out_dir.join("generated_spectests.rs");
+        fs::write(&spectests_output, spectests.buffer)?;
+
+        // Write out our auto-generated tests and opportunistically format them with
+        // `rustfmt` if it's installed.
+        // Note: We need drop because we don't want to run `unwrap` or `expect` as
+        // the command might fail, but we don't care about it's result.
+        drop(Command::new("rustfmt").arg(&spectests_output).status());
+    }
+
+    // Wasitest test generation
+    {
+        let mut wasitests = Testsuite {
+            buffer: String::new(),
+            path: vec![],
+        };
+
+        with_test_module(&mut wasitests, "wasitests", |wasitests| {
+            for wasi_version in &["unstable", "snapshot1", "nightly_2022_10_18"] {
+                with_test_module(wasitests, wasi_version, |wasitests| {
+                    for (wasi_filesystem_test_name, wasi_filesystem_kind) in &[
+                        ("host_fs", "WasiFileSystemKind::Host"),
+                        ("mem_fs", "WasiFileSystemKind::InMemory"),
+                        ("tmp_fs", "WasiFileSystemKind::Tmp"),
+                        ("passthru_fs", "WasiFileSystemKind::PassthruMemory"),
+                        ("union_fs", "WasiFileSystemKind::UnionHostMemory"),
+                        ("root_fs", "WasiFileSystemKind::RootFileSystemBuilder"),
+                    ] {
+                        with_test_module(wasitests, wasi_filesystem_test_name, |wasitests| {
+                            test_directory(
+                                wasitests,
+                                format!("tests/wasi-wast/wasi/{}", wasi_version),
+                                |out, path| wasi_processor(out, path, wasi_filesystem_kind),
+                            )
+                        })?;
+                    }
+
+                    Ok(())
+                })?;
+            }
+
+            Ok(())
+        })?;
+
+        let wasitests_output = out_dir.join("generated_wasitests.rs");
+        fs::write(&wasitests_output, wasitests.buffer)?;
+
+        drop(Command::new("rustfmt").arg(&wasitests_output).status());
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/deny.toml b/arbitrator/tools/module_roots/wasmer/deny.toml
new file mode 100644
index 0000000..949f572
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/deny.toml
@@ -0,0 +1,222 @@
+# This template contains all of the possible sections and their default values
+
+# Note that all fields that take a lint level have these possible values:
+# * deny - An error will be produced and the check will fail
+# * warn - A warning will be produced, but the check will not fail
+# * allow - No warning or error will be produced, though in some cases a note
+# will be
+
+# The values provided in this template are the default values that will be used
+# when any section or field is not specified in your own configuration
+
+# If 1 or more target triples (and optionally, target_features) are specified,
+# only the specified targets will be checked when running `cargo deny check`.
+# This means, if a particular package is only ever used as a target specific
+# dependency, such as, for example, the `nix` crate only being used via the
+# `target_family = "unix"` configuration, that only having windows targets in
+# this list would mean the nix crate, as well as any of its exclusive
+# dependencies not shared by any other crates, would be ignored, as the target
+# list here is effectively saying which targets you are building for.
+targets = [
+    # The triple can be any string, but only the target triples built in to
+    # rustc (as of 1.40) can be checked against actual config expressions
+    #{ triple = "x86_64-unknown-linux-musl" },
+    # You can also specify which target_features you promise are enabled for a
+    # particular target. target_features are currently not validated against
+    # the actual valid features supported by the target architecture.
+    #{ triple = "wasm32-unknown-unknown", features = ["atomics"] },
+]
+
+# This section is considered when running `cargo deny check advisories`
+# More documentation for the advisories section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/advisories/cfg.html
+[advisories]
+# The path where the advisory database is cloned/fetched into
+db-path = "~/.cargo/advisory-db"
+# The url(s) of the advisory databases to use
+db-urls = ["https://github.com/rustsec/advisory-db"]
+# The lint level for security vulnerabilities
+vulnerability = "deny"
+# The lint level for unmaintained crates
+unmaintained = "warn"
+# The lint level for crates that have been yanked from their source registry
+yanked = "deny"
+# The lint level for crates with security notices. Note that as of
+# 2019-12-17 there are no security notice advisories in
+# https://github.com/rustsec/advisory-db
+notice = "warn"
+# A list of advisory IDs to ignore. Note that ignored advisories will still
+# output a note when they are encountered.
+ignore = [
+    #"RUSTSEC-0000-0000",
+
+]
+# If this is true, then cargo deny will use the git executable to fetch advisory database.
+# If this is false, then it uses a built-in git library.
+# Setting this to true can be helpful if you have special authentication requirements that cargo-deny does not support.
+# See Git Authentication for more information about setting up git authentication.
+git-fetch-with-cli = true
+# Threshold for security vulnerabilities, any vulnerability with a CVSS score
+# lower than the range specified will be ignored. Note that ignored advisories
+# will still output a note when they are encountered.
+# * None - CVSS Score 0.0
+# * Low - CVSS Score 0.1 - 3.9
+# * Medium - CVSS Score 4.0 - 6.9
+# * High - CVSS Score 7.0 - 8.9
+# * Critical - CVSS Score 9.0 - 10.0
+#severity-threshold =
+
+# This section is considered when running `cargo deny check licenses`
+# More documentation for the licenses section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/licenses/cfg.html
+[licenses]
+# The lint level for crates which do not have a detectable license
+unlicensed = "deny"
+# List of explicitly allowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.7 short identifier (+ optional exception)].
+allow = [
+    "MIT",
+    "Apache-2.0",
+    "Apache-2.0 WITH LLVM-exception",
+]
+# List of explicitly disallowed licenses
+# See https://spdx.org/licenses/ for list of possible licenses
+# [possible values: any SPDX 3.7 short identifier (+ optional exception)].
+deny = [
+    "AGPL-1.0",
+    "AGPL-3.0",
+]
+# Lint level for licenses considered copyleft
+copyleft = "warn"
+# Blanket approval or denial for OSI-approved or FSF Free/Libre licenses
+# * both - The license will be approved if it is both OSI-approved *AND* FSF
+# * either - The license will be approved if it is either OSI-approved *OR* FSF
+# * osi-only - The license will be approved if is OSI-approved *AND NOT* FSF
+# * fsf-only - The license will be approved if is FSF *AND NOT* OSI-approved
+# * neither - This predicate is ignored and the default lint level is used
+allow-osi-fsf-free = "either"
+# Lint level used when no other predicates are matched
+# 1. License isn't in the allow or deny lists
+# 2. License isn't copyleft
+# 3. License isn't OSI/FSF, or allow-osi-fsf-free = "neither"
+default = "deny"
+# The confidence threshold for detecting a license from license text.
+# The higher the value, the more closely the license text must be to the
+# canonical license text of a valid SPDX license file.
+# [possible values: any between 0.0 and 1.0].
+confidence-threshold = 0.8
+# Allow 1 or more licenses on a per-crate basis, so that particular licenses
+# aren't accepted for every possible crate as with the normal allow list
+exceptions = [
+    # Each entry is the crate and version constraint, and its specific allow
+    # list
+]
+
+
+
+# Some crates don't have (easily) machine readable licensing information,
+# adding a clarification entry for it allows you to manually specify the
+# licensing information
+[[licenses.clarify]]
+name = "webc"
+version = "*"
+expression = "BSL-1.0"
+license-files = [
+  { path = "LICENSE.txt", hash = 0xa2180a97 }
+]
+
+[[licenses.clarify]]
+name = "ring"
+version = "*"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [
+    # Each entry is a crate relative path, and the (opaque) hash of its contents
+    { path = "LICENSE", hash = 0xbd0eed23 }
+]
+
+[licenses.private]
+# If true, ignores workspace crates that aren't published, or are only
+# published to private registries
+ignore = false
+# One or more private registries that you might publish crates to, if a crate
+# is only published to private registries, and ignore is true, the crate will
+# not have its license(s) checked
+registries = [
+    #"https://sekretz.com/registry
+]
+
+# This section is considered when running `cargo deny check bans`.
+# More documentation about the 'bans' section can be found here:
+# https://embarkstudios.github.io/cargo-deny/checks/bans/cfg.html
+[bans]
+# Lint level for when multiple versions of the same crate are detected
+multiple-versions = "warn"
+# Lint level for when a crate version requirement is `*`
+wildcards = "allow"
+# The graph highlighting used when creating dotgraphs for crates
+# with multiple versions
+# * lowest-version - The path to the lowest versioned duplicate is highlighted
+# * simplest-path - The path to the version with the fewest edges is highlighted
+# * all - Both lowest-version and simplest-path are used
+highlight = "all"
+# List of crates that are allowed. Use with care!
+allow = [
+    #{ name = "ansi_term", version = "=0.11.0" },
+]
+# List of crates to deny
+deny = [
+    # Each entry the name of a crate and a version range. If version is
+    # not specified, all versions will be matched.
+    #{ name = "ansi_term", version = "=0.11.0" },
+    #
+    # Wrapper crates can optionally be specified to allow the crate when it
+    # is a direct dependency of the otherwise banned crate
+    #{ name = "ansi_term", version = "=0.11.0", wrappers = [] },
+]
+# Certain crates/versions that will be skipped when doing duplicate detection.
+skip = [
+    { name = "webc" },  # licence is not fetched correctly and end up as unknown
+    { name = "ahash", version = "=0.4.7" },
+    { name = "hashbrown", version = "=0.9.1" },
+    { name = "cfg-if", version = "=0.1.10" },
+    { name = "gimli", version = "=0.25.0" },
+    { name = "strsim", version = "=0.8.0" },
+    { name = "semver", version = "=0.9.0" },
+    { name = "semver", version = "=0.11.0" },
+    { name = "semver-parser", version = "=0.7.0" },
+    { name = "rustc_version", version = "=0.2.3" },
+    { name = "itoa", version = "=0.4.8" },
+    { name = "object", version = "=0.27.1" },
+]
+# Similarly to `skip` allows you to skip certain crates during duplicate
+# detection. Unlike skip, it also includes the entire tree of transitive
+# dependencies starting at the specified crate, up to a certain depth, which is
+# by default infinite
+skip-tree = [
+    #{ name = "ansi_term", version = "=0.11.0", depth = 20 },
+]
+
+# 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
+[sources]
+# Lint level for what to happen when a crate from a crate registry that is not
+# in the allow list is encountered
+unknown-registry = "deny"
+# Lint level for what to happen when a crate from a git repository that is not
+# in the allow list is encountered
+unknown-git = "deny"
+# List of URLs for allowed crate registries. Defaults to the crates.io index
+# if not specified. If it is specified but empty, no registries are allowed.
+allow-registry = ["https://github.com/rust-lang/crates.io-index"]
+# List of URLs for allowed Git repositories
+allow-git = []
+
+#[sources.allow-org]
+# 1 or more github.com organizations to allow git sources for
+#github = [""]
+# 1 or more gitlab.com organizations to allow git sources for
+#gitlab = [""]
+# 1 or more bitbucket.org organizations to allow git sources for
+#bitbucket = [""]
diff --git a/arbitrator/tools/module_roots/wasmer/docs/README.md b/arbitrator/tools/module_roots/wasmer/docs/README.md
new file mode 100644
index 0000000..18ac2c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/README.md
@@ -0,0 +1,24 @@
+# Wasmer Documentation
+
+Wasmer provides multiple documentations. Here are some pointers:
+
+* [The Wasmer runtime
+  `README.md`](https://github.com/wasmerio/wasmer/blob/master/README.md)
+  is a good start for the first steps, like installations, first runs etc.,
+* [The public documentation](https://docs.wasmer.io/) contains all the
+  documentation you need to learn about Wasmer and WebAssembly,
+* [The Rust crates documentations](https://wasmerio.github.io/wasmer/)
+  contain all the documentations to use the `wasmer-*` Rust crates,
+  with many examples,
+* [The collection of
+  examples](https://github.com/wasmerio/wasmer/blob/master/examples/README.md)
+  illustrates how to use Wasmer and its numerous features through very
+  commented examples,
+* [Documentations for all embeddings/language
+  integrations](https://github.com/wasmerio/wasmer/blob/master/README.md):
+  the Wasmer runtime can be embedded in various languages or
+  environments, each embedding provides its own documentation, book
+  etc.,
+* [OS distro packaging
+  notes](https://github.com/wasmerio/wasmer/blob/master/PACKAGING.md)
+  contains notes about how to package Wasmer for OS distributions.
diff --git a/arbitrator/tools/module_roots/wasmer/docs/RISCV.md b/arbitrator/tools/module_roots/wasmer/docs/RISCV.md
new file mode 100755
index 0000000..0cd470a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/RISCV.md
@@ -0,0 +1,12 @@
+# Current state of the RISCV support
+
+Only Cranelift and LLVM compiler are supported.
+Singlepass can be done, but no ressources are allocated on this task for now.
+
+Both LLVM and Cranelift support are quite new, and so it is expected to have a few things not working well.
+
+LLVM code needs a hack to force the ABI to "lp64d", and some tested with funciton & float/double values are still not working correctly and have be disable for now.
+
+On Cranelift, SIMD is not supported as the CPU doesn't have official SIMD/Vector extension for now, and no Workaround is in place.
+
+Test have be conducted on actual hardware, with a Vision Fixe 2 board running Debian. Some previous tests have also be done on a Vison Five 1 running Fedora (with LLVM only).
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/docs/cn/README.md b/arbitrator/tools/module_roots/wasmer/docs/cn/README.md
new file mode 100644
index 0000000..f2cf547
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/cn/README.md
@@ -0,0 +1,206 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
+  </a>
+
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/actions/workflows/build.yml/badge.svg?event=push" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
+    </a>
+    <a href="https://docs.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Docs&message=docs.wasmer.io&color=blue" alt="Wasmer Docs">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20us!&color=brighgreen" alt="Slack channel">
+    </a>
+  </p>
+
+  <h3>
+    <a href="https://wasmer.io/">网站</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">文档</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">聊天</a>
+  </h3>
+
+</div>
+
+<br />
+
+[Wasmer](https://wasmer.io/) 提供基于 [WebAssembly](https://webassembly.org/) 的超轻量级容器，其可以在任何地方运行：从桌面到云、以及 IoT 设备，并且也能嵌入到 [*任何编程语言*](https://github.com/wasmerio/wasmer#language-integrations) 中.
+
+> 其他语言的 Readme: [🇩🇪 Deutsch-德語](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-英文](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-西班牙语](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇫🇷 Français-法语](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • [🇯🇵 日本語-日文](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md).
+
+## 特性
+
+* **快速又安全**. Wasmer在完全沙盒化的环境中以“接近本机”的速度运行 WebAssembly。
+
+* **可插拔**. Wasmer 可以根据你的需求支持不同的编译框架 (LLVM，Cranelift ...).
+
+* **通用的**. 你可以在**任何平台**(macOS, Linux and Windows) 和芯片组运行 Wasmer.  
+
+* **符合标准**. 运行时通过了[官方WebAssembly测试集](https://github.com/WebAssembly/testsuite) 支持[WASI](https://github.com/WebAssembly/WASI) 和[Emscripten](https://emscripten.org/).
+
+## 快速开始
+
+Wasmer 不需要安装其他依赖. 你可以使用以下安装程序进行安装:
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+<details>
+  <summary>使用Powershell (Windows)</summary>
+  <p>
+
+```powershell
+iwr https://win.wasmer.io -useb | iex
+```
+
+</p>
+</details>
+
+> 有关更多安装选项，请参见 [wasmer-install](https://github.com/wasmerio/wasmer-install): Homebrew, Scoop, Cargo...
+
+
+#### 执行WebAssembly文件
+
+安装Wasmer之后，你已经准备好执行第一个WebAssembly文件了! 🎉
+
+您可以通过运行 QuickJS 开始: [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs > const i = 1 + 2;
+qjs > console.log("hello " + i);
+hello 3
+```
+
+#### 接下来是你可以做的:
+
+- [在你的Rust应用程序中使用Wasmer](https://docs.wasmer.io/integrations/rust)
+- [在WAPM上发布Wasm程序包](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [阅读有关Wasmer的更多信息](https://medium.com/wasmer/)
+
+## 语言整合
+
+📦 Wasmer 运行时能以库的形式**嵌入到不同的语言**，因此你可以在任何地方使用WebAssembly.
+
+| &nbsp; | 语言 | 程序包 | 文档 |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [文档][rust docs]
+| ![C logo] | [**C**][C integration] | [`wasm.h` header] | [文档][c docs] |
+| ![C++ logo] | [**C++**][C integration] | [`wasm.hh` header] | [文档][c docs] |
+| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [文档][c# docs] |
+| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [文档][d docs] |
+| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [文档][python docs] |
+| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [文档][js docs] |
+| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [文档][go docs] |
+| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [文档][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [文档][ruby docs] |
+| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [文档][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [文档][elixir docs] |
+| ![R logo] | [**R**][R integration] | *没有已发布的软件包* | [文档][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | *没有已发布的软件包* | [文档][postgres docs] |
+|  | [**Swift**][Swift integration] | *没有已发布的软件包* | |
+| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋 缺少语言？](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://docs.rs/wasmer/
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/
+[c docs]: https://docs.rs/wasmer-c-api/*/wasmer/wasm_c_api/index.html
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://wasmerio.github.io/wasmer-php/
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/wasm/
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://www.rubydoc.info/gems/wasmer/
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## 贡献
+
+**我们欢迎任何形式的贡献，尤其是来自社区新成员的贡献** 💜
+
+你可以在[我们的出色文档](https://docs.wasmer.io/developers/build-from-source) 中学习如何构建 Wasmer 运行时!
+
+### 测试
+
+想要测试吗?  [参考 Wasmer 文档](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing).
+
+## 社区
+
+Wasmer 拥有一个由出色的开发人员和贡献者组成的社区。 欢迎你，请加入我们! 👋
+
+### 频道
+
+- [Slack](https://slack.wasmer.io/)
+- [Twitter](https://twitter.com/wasmerio)
+- [Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/de/README.md b/arbitrator/tools/module_roots/wasmer/docs/de/README.md
new file mode 100644
index 0000000..da66f04
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/de/README.md
@@ -0,0 +1,230 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer Logo">
+  </a>
+
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="Lizenz">
+    </a>
+    <a href="https://docs.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Docs&message=docs.wasmer.io&color=blue" alt="Wasmer Doku">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=teilnehmen&color=brighgreen" alt="Slack Kanal">
+    </a>
+  </p>
+</div>
+
+<br />
+
+Wasmer ist eine _schnelle_ und _sichere_ [**WebAssembly**](https://webassembly.org) Runtime, die das Ausführen von
+_schlanken Containern_ überall ermöglicht: auf dem *Desktop* in der *Cloud*, so wie auf *Edge* und *IoT* Geräten.
+
+> _Die README ist auch in folgenden Sprachen verfügbar:
+[🇨🇳 中文-Chinesisch](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • 
+[🇬🇧 English-Englisch](https://github.com/wasmerio/wasmer/blob/master/README.md) •
+[🇪🇸 Español-Spanisch](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • 
+[🇫🇷 Français-Französisch](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • 
+[🇯🇵 日本語-Japanisch](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md)_.
+
+### Leistungsmerkmale
+
+* Standardmäßig sicher. Kein Datei-, Netzwerk- oder Umgebungszugriff, sofern nicht explizit aktiviert.
+* Unterstützt [WASI](https://github.com/WebAssembly/WASI) und [Emscripten](https://emscripten.org/) standardmäßig.
+* Schnell. Führt WebAssembly in nahezu nativer Geschwindigkeit aus.
+* Einbettbar in [mehrere Programmiersprachen](https://github.com/wasmerio/wasmer/#-language-integrations)
+* Kompatibel mit den neuesten Empfehlungen für WebAssembly (SIMD, Referenztypen, Threads, ...)
+
+### Installation
+
+Wasmer CLI wird als eine einzige ausführbare Datei ohne Abhängigkeiten ausgeliefert.
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+
+<details>
+  <summary>Weitere Installationsmöglichkeiten (Powershell, Brew, Cargo, ...)</summary>
+  
+  _Wasmer kann über verschiedene Paketmanager installiert werden. Wählen Sie den für Ihre Umgebung am besten geeigneten aus:_
+  
+  * Powershell (Windows)
+    ```powershell
+    iwr https://win.wasmer.io -useb | iex
+    ```
+
+  * <a href="https://formulae.brew.sh/formula/wasmer">Homebrew</a> (macOS, Linux)
+
+    ```sh
+    brew install wasmer
+    ```
+
+  * <a href="https://github.com/ScoopInstaller/Main/blob/master/bucket/wasmer.json">Scoop</a> (Windows)
+
+    ```sh
+    scoop install wasmer
+    ```
+
+  * <a href="https://chocolatey.org/packages/wasmer">Chocolatey</a> (Windows)
+
+    ```sh
+    choco install wasmer
+    ```
+  
+  * <a href="https://crates.io/crates/wasmer-cli/">Cargo</a>
+
+    _Note: All the available
+    features are described in the [`wasmer-cli`
+    crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md)_
+
+    ```sh
+    cargo install wasmer-cli
+    ```
+
+  > Suchen Sie nach weiteren Installationsmöglichkeiten? Im [`wasmer-install`
+  Repository](https://github.com/wasmerio/wasmer-install) können Si mehr erfahren!
+</details>
+
+### Schnellstart
+
+Sie können beginnen,
+[QuickJS](https://github.com/bellard/quickjs/) auszuführen, eine kleine und
+einbettbare Javascript Engine, die als WebAssembly Modul kompiliert ist: ([`qjs.wasm`](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)):
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs > const i = 1 + 2;
+qjs > console.log("hello " + i);
+hello 3
+```
+
+#### Folgendes können Sie als nächstes tun:
+
+- [Wasmer für eine Rust Anwendung nutzen](https://docs.wasmer.io/integrations/rust)
+- [Ein asm Paket auf WAPM veröffentlichen](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [Mehr zu Wasmer lesen](https://medium.com/wasmer/)
+
+## 📦 Unterstützte Sprachen
+
+Die Wasmer-Laufzeit kann als Bibliothek **eingebettet in verschiedenen
+Sprachen** verwendet werden, so dass Sie WebAssembly _überall_ einsetzen können.
+
+| | Sprache | Paket | Dokumentation |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust Integration] | [`wasmer` Rust crate] | [Lernen][rust docs]
+| ![C logo] | [**C/C++**][C Integration] | [`wasmer.h` header] | [Lernen][c docs] |
+| ![C# logo] | [**C#**][C# Integration] | [`WasmerSharp` NuGet Paket] | [Lernen][c# docs] |
+| ![D logo] | [**D**][D Integration] | [`wasmer` Dub Paket] | [Lernen][d docs] |
+| ![Python logo] | [**Python**][Python Integration] | [`wasmer` PyPI Paket] | [Lernen][python docs] |
+| ![JS logo] | [**Javascript**][JS Integration] | [`@wasmerio` NPM Paket] | [Lernen][js docs] |
+| ![Go logo] | [**Go**][Go Integration] | [`wasmer` Go Paket] | [Lernen][go docs] |
+| ![PHP logo] | [**PHP**][PHP Integration] | [`wasm` PECL Paket] | [Lernen][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby Integration] | [`wasmer` Ruby Gem] | [Lernen][ruby docs] |
+| ![Java logo] | [**Java**][Java Integration] | [`wasmer/wasmer-jni` Bintray Paket] | [Lernen][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir Integration] | [`wasmex` hex Paket] | [Lernen][elixir docs] |
+| ![R logo] | [**R**][R Integration] | *kein Paket veröffentlicht* | [Lernen][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres Integration] | *kein Paket veröffentlicht* | [Lernen][postgres docs] |
+|  | [**Swift**][Swift Integration] | *kein Paket veröffentlicht* | |
+| ![Zig logo] | [**Zig**][Zig Integration] | *kein Paket veröffentlicht* | |
+| ![Dart logo] | [**Dart**][Dart Integration] | [`wasm` pub Paket] | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋&nbsp;&nbsp;Fehlt eine Sprache?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasmer.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/wasmer.h
+[c docs]: https://wasmerio.github.io/wasmer/crates/wasmer_c_api
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer/
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/wasm/
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg
+[dart integration]: https://github.com/dart-lang/wasm
+[`wasm` pub package]: https://pub.dev/packages/wasm
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## Unterstützen
+
+Wir sind dankbar für Ihre Hilfe! 💜
+
+Lesen Sie in unserer Dokumentation nach, wie man [Wasmer aus dem
+Quellcode kompiliert](https://docs.wasmer.io/ecosystem/wasmer/building-from-source) oder [testen Sie Änderungen](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing).
+
+## Community
+
+Wasmer hat eine wunderbare Community von Entwicklern und Mitwirkenden. Sie sind herzlich willkommen, bitte machen Sie mit! 👋
+
+- [Wasmer Community auf Slack](https://slack.wasmer.io/)
+- [Wasmer auf Twitter](https://twitter.com/wasmerio)
+- [Wasmer auf Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.dot b/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.dot
new file mode 100644
index 0000000..d86c4ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.dot
@@ -0,0 +1,72 @@
+digraph dependencies {
+        newrank=true;
+
+	n0 [label="wasmer", color=orange];
+	n1 [label="wasmer-compiler", color=orange];
+	n5 [label="wasmer-engine", color=orange];
+	n6 [label="wasmer-engine-universal", color=orange];
+	n8 [label="wasmer-types", color=orange];
+	n9 [label="wasmer-vm", color=orange];
+	n10 [label="wasmer-c-api", color=orange];
+	n11 [label="wasmer-emscripten", color=orange];
+	n12 [label="wasmer-wasi", color=orange];
+	n13 [label="wasmer-cache", color=orange];
+	n14 [label="wasmer-cli", color=orange];
+
+        
+	subgraph cluster_compiler {
+		label="Compilers";
+		color=brown;
+
+		n2 [label="wasmer-compiler-cranelift", color=orange];
+		n3 [label="wasmer-compiler-llvm", color=orange];
+		n4 [label="wasmer-compiler-singlepass", color=orange];
+	}
+
+	subgraph cluster_engine {
+		label="Engines";
+		color=brown;
+
+		n6 [label="wasmer-engine-universal", color=orange];
+	}
+
+        {
+        rank=same;
+        n2;
+        n3;
+        n4;
+        n6;
+        n7;
+        }
+        
+
+	subgraph cluster_abi {
+		label="Provided ABIs";
+		color=brown;
+
+		n12 [label="wasmer-wasi", color=orange];
+		n11 [label="wasmer-emscripten", color=orange];
+	}
+
+	n14 -> n13 [color=orange, style=dashed];
+	n14 -> n12 [color=orange, style=dashed];
+	n14 -> n11 [color=orange, style=dashed];
+	n13 -> n0 [color=orange, style=dashed];
+	n10 -> n11 [color=orange, style=dashed];
+	n10 -> n12 [color=orange, style=dashed];
+	n11 -> n0 [color=orange, style=dashed];
+	n12 -> n0 [color=orange, style=dashed];
+	n0 -> n2 [color=orange, style=dashed];
+	n0 -> n3 [color=orange, style=dashed];
+	n0 -> n4 [color=orange, style=dashed];
+	n0 -> n6 [color=orange, style=dashed];
+	n0 -> n7 [color=orange, style=dashed];
+	n2 -> n1 [color=orange, style=dashed];
+	n3 -> n1 [color=orange, style=dashed];
+	n4 -> n1 [color=orange, style=dashed];
+	n6 -> n5 [color=orange, style=dashed];
+	n7 -> n5 [color=orange, style=dashed];
+	n5 -> n1 [color=orange, style=dashed];
+	n1 -> n9 [color=orange, style=dashed];
+	n9 -> n8 [color=orange, style=dashed];
+}
diff --git a/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.svg b/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.svg
new file mode 100644
index 0000000..e05f2b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/deps_dedup.svg
@@ -0,0 +1,232 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
+ "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Generated by graphviz version 2.47.1 (20210417.1919)
+ -->
+<!-- Title: dependencies Pages: 1 -->
+<svg width="1111pt" height="554pt"
+ viewBox="0.00 0.00 1111.00 554.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(4 550)">
+<title>dependencies</title>
+<polygon fill="white" stroke="transparent" points="-4,4 -4,-550 1107,-550 1107,4 -4,4"/>
+<g id="clust1" class="cluster">
+<title>cluster_compiler</title>
+<polygon fill="none" stroke="brown" points="422,-280 422,-355 1095,-355 1095,-280 422,-280"/>
+<text text-anchor="middle" x="758.5" y="-339.8" font-family="Times,serif" font-size="14.00">Compilers</text>
+</g>
+<g id="clust2" class="cluster">
+<title>cluster_engine</title>
+<polygon fill="none" stroke="brown" points="8,-280 8,-355 414,-355 414,-280 8,-280"/>
+<text text-anchor="middle" x="211" y="-339.8" font-family="Times,serif" font-size="14.00">Engines</text>
+</g>
+<g id="clust4" class="cluster">
+<title>cluster_abi</title>
+<polygon fill="none" stroke="brown" points="301,-427 301,-502 612,-502 612,-427 301,-427"/>
+<text text-anchor="middle" x="456.5" y="-486.8" font-family="Times,serif" font-size="14.00">Provided ABIs</text>
+</g>
+<!-- n0 -->
+<g id="node1" class="node">
+<title>n0</title>
+<ellipse fill="none" stroke="orange" cx="523" cy="-381" rx="38.19" ry="18"/>
+<text text-anchor="middle" x="523" y="-377.3" font-family="Times,serif" font-size="14.00">wasmer</text>
+</g>
+<!-- n6 -->
+<g id="node4" class="node">
+<title>n6</title>
+<ellipse fill="none" stroke="orange" cx="306" cy="-306" rx="100.18" ry="18"/>
+<text text-anchor="middle" x="306" y="-302.3" font-family="Times,serif" font-size="14.00">wasmer&#45;engine&#45;universal</text>
+</g>
+<!-- n0&#45;&gt;n6 -->
+<g id="edge12" class="edge">
+<title>n0&#45;&gt;n6</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M488.06,-373.25C467.43,-368.88 440.95,-362.59 418,-355 394.49,-347.23 369.06,-336.52 348.38,-327.2"/>
+<polygon fill="orange" stroke="orange" points="349.79,-323.99 339.24,-323.02 346.88,-330.36 349.79,-323.99"/>
+</g>
+<!-- n2 -->
+<g id="node13" class="node">
+<title>n2</title>
+<ellipse fill="none" stroke="orange" cx="982" cy="-306" rx="105.08" ry="18"/>
+<text text-anchor="middle" x="982" y="-302.3" font-family="Times,serif" font-size="14.00">wasmer&#45;compiler&#45;cranelift</text>
+</g>
+<!-- n0&#45;&gt;n2 -->
+<g id="edge9" class="edge">
+<title>n0&#45;&gt;n2</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M561.13,-378.78C638.16,-376.05 809.84,-368.62 867,-355 892.67,-348.88 919.98,-337.7 941.54,-327.67"/>
+<polygon fill="orange" stroke="orange" points="943.18,-330.76 950.71,-323.31 940.18,-324.44 943.18,-330.76"/>
+</g>
+<!-- n3 -->
+<g id="node14" class="node">
+<title>n3</title>
+<ellipse fill="none" stroke="orange" cx="523" cy="-306" rx="92.88" ry="18"/>
+<text text-anchor="middle" x="523" y="-302.3" font-family="Times,serif" font-size="14.00">wasmer&#45;compiler&#45;llvm</text>
+</g>
+<!-- n0&#45;&gt;n3 -->
+<g id="edge10" class="edge">
+<title>n0&#45;&gt;n3</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M523,-362.7C523,-354.25 523,-343.87 523,-334.37"/>
+<polygon fill="orange" stroke="orange" points="526.5,-334.18 523,-324.18 519.5,-334.18 526.5,-334.18"/>
+</g>
+<!-- n4 -->
+<g id="node15" class="node">
+<title>n4</title>
+<ellipse fill="none" stroke="orange" cx="746" cy="-306" rx="112.38" ry="18"/>
+<text text-anchor="middle" x="746" y="-302.3" font-family="Times,serif" font-size="14.00">wasmer&#45;compiler&#45;singlepass</text>
+</g>
+<!-- n0&#45;&gt;n4 -->
+<g id="edge11" class="edge">
+<title>n0&#45;&gt;n4</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M557.33,-372.82C577.27,-368.35 602.77,-362.1 625,-355 650.24,-346.94 677.75,-336.2 700.14,-326.91"/>
+<polygon fill="orange" stroke="orange" points="701.53,-330.13 709.41,-323.04 698.83,-323.67 701.53,-330.13"/>
+</g>
+<!-- n1 -->
+<g id="node2" class="node">
+<title>n1</title>
+<ellipse fill="none" stroke="orange" cx="634" cy="-162" rx="73.39" ry="18"/>
+<text text-anchor="middle" x="634" y="-158.3" font-family="Times,serif" font-size="14.00">wasmer&#45;compiler</text>
+</g>
+<!-- n9 -->
+<g id="node7" class="node">
+<title>n9</title>
+<ellipse fill="none" stroke="orange" cx="634" cy="-90" rx="53.09" ry="18"/>
+<text text-anchor="middle" x="634" y="-86.3" font-family="Times,serif" font-size="14.00">wasmer&#45;vm</text>
+</g>
+<!-- n1&#45;&gt;n9 -->
+<g id="edge20" class="edge">
+<title>n1&#45;&gt;n9</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M634,-143.7C634,-135.98 634,-126.71 634,-118.11"/>
+<polygon fill="orange" stroke="orange" points="637.5,-118.1 634,-108.1 630.5,-118.1 637.5,-118.1"/>
+</g>
+<!-- n5 -->
+<g id="node3" class="node">
+<title>n5</title>
+<ellipse fill="none" stroke="orange" cx="306" cy="-234" rx="64.99" ry="18"/>
+<text text-anchor="middle" x="306" y="-230.3" font-family="Times,serif" font-size="14.00">wasmer&#45;engine</text>
+</g>
+<!-- n5&#45;&gt;n1 -->
+<g id="edge19" class="edge">
+<title>n5&#45;&gt;n1</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M355.82,-222.37C413.2,-210.12 507.6,-189.98 570.28,-176.6"/>
+<polygon fill="orange" stroke="orange" points="571.39,-179.94 580.44,-174.43 569.93,-173.09 571.39,-179.94"/>
+</g>
+<!-- n6&#45;&gt;n5 -->
+<g id="edge17" class="edge">
+<title>n6&#45;&gt;n5</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M306,-287.7C306,-279.98 306,-270.71 306,-262.11"/>
+<polygon fill="orange" stroke="orange" points="309.5,-262.1 306,-252.1 302.5,-262.1 309.5,-262.1"/>
+</g>
+<!-- n7&#45;&gt;n5 -->
+<g id="edge18" class="edge">
+<title>n7&#45;&gt;n5</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M144.77,-290.33C177.52,-279.09 222.74,-263.57 256.96,-251.83"/>
+<polygon fill="orange" stroke="orange" points="258.42,-255.03 266.75,-248.47 256.15,-248.4 258.42,-255.03"/>
+</g>
+<!-- n8 -->
+<g id="node6" class="node">
+<title>n8</title>
+<ellipse fill="none" stroke="orange" cx="634" cy="-18" rx="59.59" ry="18"/>
+<text text-anchor="middle" x="634" y="-14.3" font-family="Times,serif" font-size="14.00">wasmer&#45;types</text>
+</g>
+<!-- n9&#45;&gt;n8 -->
+<g id="edge21" class="edge">
+<title>n9&#45;&gt;n8</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M634,-71.7C634,-63.98 634,-54.71 634,-46.11"/>
+<polygon fill="orange" stroke="orange" points="637.5,-46.1 634,-36.1 630.5,-46.1 637.5,-46.1"/>
+</g>
+<!-- n10 -->
+<g id="node8" class="node">
+<title>n10</title>
+<ellipse fill="none" stroke="orange" cx="382" cy="-528" rx="59.29" ry="18"/>
+<text text-anchor="middle" x="382" y="-524.3" font-family="Times,serif" font-size="14.00">wasmer&#45;c&#45;api</text>
+</g>
+<!-- n11 -->
+<g id="node9" class="node">
+<title>n11</title>
+<ellipse fill="none" stroke="orange" cx="523" cy="-453" rx="80.69" ry="18"/>
+<text text-anchor="middle" x="523" y="-449.3" font-family="Times,serif" font-size="14.00">wasmer&#45;emscripten</text>
+</g>
+<!-- n10&#45;&gt;n11 -->
+<g id="edge5" class="edge">
+<title>n10&#45;&gt;n11</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M412.64,-512.56C419.69,-509.16 427.13,-505.5 434,-502 451,-493.34 469.6,-483.38 485.39,-474.79"/>
+<polygon fill="orange" stroke="orange" points="487.22,-477.77 494.32,-469.91 483.87,-471.63 487.22,-477.77"/>
+</g>
+<!-- n12 -->
+<g id="node10" class="node">
+<title>n12</title>
+<ellipse fill="none" stroke="orange" cx="367" cy="-453" rx="57.69" ry="18"/>
+<text text-anchor="middle" x="367" y="-449.3" font-family="Times,serif" font-size="14.00">wasmer&#45;wasi</text>
+</g>
+<!-- n10&#45;&gt;n12 -->
+<g id="edge6" class="edge">
+<title>n10&#45;&gt;n12</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M378.45,-509.7C376.69,-501.15 374.53,-490.65 372.56,-481.07"/>
+<polygon fill="orange" stroke="orange" points="375.97,-480.27 370.53,-471.18 369.11,-481.68 375.97,-480.27"/>
+</g>
+<!-- n11&#45;&gt;n0 -->
+<g id="edge7" class="edge">
+<title>n11&#45;&gt;n0</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M523,-434.7C523,-426.98 523,-417.71 523,-409.11"/>
+<polygon fill="orange" stroke="orange" points="526.5,-409.1 523,-399.1 519.5,-409.1 526.5,-409.1"/>
+</g>
+<!-- n12&#45;&gt;n0 -->
+<g id="edge8" class="edge">
+<title>n12&#45;&gt;n0</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M398.57,-437.83C424.1,-426.38 460.07,-410.24 486.77,-398.26"/>
+<polygon fill="orange" stroke="orange" points="488.46,-401.33 496.15,-394.05 485.6,-394.95 488.46,-401.33"/>
+</g>
+<!-- n13 -->
+<g id="node11" class="node">
+<title>n13</title>
+<ellipse fill="none" stroke="orange" cx="683" cy="-453" rx="61.99" ry="18"/>
+<text text-anchor="middle" x="683" y="-449.3" font-family="Times,serif" font-size="14.00">wasmer&#45;cache</text>
+</g>
+<!-- n13&#45;&gt;n0 -->
+<g id="edge4" class="edge">
+<title>n13&#45;&gt;n0</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M650.24,-437.67C623.82,-426.11 586.7,-409.87 559.37,-397.91"/>
+<polygon fill="orange" stroke="orange" points="560.71,-394.68 550.14,-393.87 557.9,-401.09 560.71,-394.68"/>
+</g>
+<!-- n14 -->
+<g id="node12" class="node">
+<title>n14</title>
+<ellipse fill="none" stroke="orange" cx="523" cy="-528" rx="50.09" ry="18"/>
+<text text-anchor="middle" x="523" y="-524.3" font-family="Times,serif" font-size="14.00">wasmer&#45;cli</text>
+</g>
+<!-- n14&#45;&gt;n11 -->
+<g id="edge3" class="edge">
+<title>n14&#45;&gt;n11</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M523,-509.7C523,-501.25 523,-490.87 523,-481.37"/>
+<polygon fill="orange" stroke="orange" points="526.5,-481.18 523,-471.18 519.5,-481.18 526.5,-481.18"/>
+</g>
+<!-- n14&#45;&gt;n12 -->
+<g id="edge2" class="edge">
+<title>n14&#45;&gt;n12</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M480.19,-518.44C464.87,-514.52 447.75,-509.12 433,-502 419.04,-495.26 404.95,-485.51 393.4,-476.55"/>
+<polygon fill="orange" stroke="orange" points="395.47,-473.73 385.47,-470.23 391.11,-479.2 395.47,-473.73"/>
+</g>
+<!-- n14&#45;&gt;n13 -->
+<g id="edge1" class="edge">
+<title>n14&#45;&gt;n13</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M566.27,-518.78C582.34,-514.85 600.44,-509.37 616,-502 630.15,-495.3 644.45,-485.56 656.18,-476.6"/>
+<polygon fill="orange" stroke="orange" points="658.53,-479.2 664.23,-470.26 654.21,-473.7 658.53,-479.2"/>
+</g>
+<!-- n2&#45;&gt;n1 -->
+<g id="edge14" class="edge">
+<title>n2&#45;&gt;n1</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M943.09,-289.12C878.21,-262.65 748.27,-209.63 679.35,-181.5"/>
+<polygon fill="orange" stroke="orange" points="680.62,-178.24 670.04,-177.71 677.98,-184.72 680.62,-178.24"/>
+</g>
+<!-- n3&#45;&gt;n1 -->
+<g id="edge15" class="edge">
+<title>n3&#45;&gt;n1</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M536.17,-288.15C555.61,-263.28 592.12,-216.57 614.62,-187.79"/>
+<polygon fill="orange" stroke="orange" points="617.45,-189.86 620.85,-179.82 611.93,-185.55 617.45,-189.86"/>
+</g>
+<!-- n4&#45;&gt;n1 -->
+<g id="edge16" class="edge">
+<title>n4&#45;&gt;n1</title>
+<path fill="none" stroke="orange" stroke-dasharray="5,2" d="M732.49,-287.87C712.79,-262.9 676.08,-216.35 653.46,-187.68"/>
+<polygon fill="orange" stroke="orange" points="656.15,-185.43 647.21,-179.75 650.65,-189.77 656.15,-185.43"/>
+</g>
+</g>
+</svg>
diff --git a/arbitrator/tools/module_roots/wasmer/docs/dev/create-exe.md b/arbitrator/tools/module_roots/wasmer/docs/dev/create-exe.md
new file mode 100644
index 0000000..293b0a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/dev/create-exe.md
@@ -0,0 +1,114 @@
+# wasmer create-exe
+
+## Motivation and Goal
+
+The goal of create-exe is to create easily runnable executables on every
+operating system. 
+
+In order to speed up the compilation process, the compilation and the create-exe
+steps are split into three separate functions: `create-obj`, `create-exe` and `gen-c-header`.
+
+By default, running `create-exe` is relatively simple:
+
+```sh
+wasmer create-exe myfile.wasm -o myfile.exe
+./myfile.exe
+```
+
+When running `create-exe` on a wapm package that contains more than one .wasm file, 
+the resulting executable requires a `--command` or `-c` flag to select which module to start:
+
+```sh 
+wasmer create-exe wabt@0.1.0.wasmer -o wabt.exe
+./wabt.exe
+No --command given, available commands are:
+
+    wabt
+    wasm-interp
+    wasm-strip
+    wasm-validate
+    wasm2wat
+    wast2json
+    wat2wasm
+
+./wabt.exe -c wasm2wat --version
+1.0.37 (git~v1.0.37)
+```
+
+## create-obj
+
+Some compilers have different advantages over other compilers, for example, the `-llvm`
+compiler emits the best code, but is the slowest to compile, the `-singlepass` compiler
+emits slow code, but is very fast to compile.
+
+In order to cache compiled object and re-use them for recompilation, `wasmer create-obj`
+exists to cache the output of the `wasm -> obj` compilation
+
+```sh
+# Requires wasmer >= 3.2.0-alpha.1
+wasmer create-obj myfile.wasm -llvm -o myfile.o
+# Run create-exe with the cached object file
+wasmer create-exe myfile.wasm --precompiled-atom=myfile:myfile.o -o myfile.exe
+```
+
+The WebAssembly module (atom) name specified in the `--precompiled-atom` flag is the `.wasm` filename
+without the extension or the module name in a multi-webassembly wapm package.
+
+## Multi-command executables
+
+When compiling multiple `.wasm` atoms into one executable, it could happen that
+the function names generated by wasmer would clash with each other (ex. 
+`wasmer_function_1` from `object1.o` and `wasmer_function_1` from `object2.o`).
+
+Therefore, wasmer inserts a prefix for these functions, which is apparent when running
+`wasmer gen-c-header`:
+
+```c
+wasmer gen-c-header myfile.wasm -o myfile.h
+cat myfile.h
+
+// ...
+
+// Compiled Wasm function pointers ordered by function index: the order they
+// appeared in in the Wasm module.
+extern void wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0(void);
+extern void wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_1(void);
+extern void wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_2(void);
+
+// ...
+```
+
+By default, this "prefix" is the Sha256 hash of the input `.wasm` file and can be changed with the 
+`--prefix` flag on both `gen-c-header` and `create-obj`:
+
+```c
+wasmer gen-c-header myfile.wasm -o myfile.h --prefix abc123
+cat myfile.h
+
+// ...
+
+// Compiled Wasm function pointers ordered by function index: the order they
+// appeared in in the Wasm module.
+extern void wasmer_function_abc123_0(void);
+extern void wasmer_function_abc123_1(void);
+extern void wasmer_function_abc123_2(void);
+
+// ...
+```
+
+In order to instruct `create-exe` to use these object files, we can use the `--precompiled-atom` syntax
+with `ATOM_NAME:PREFIX:PATH_TO_FILE` where `PREFIX` is optional and defaults to the Sha256 hash of the wasm file.
+
+```sh
+wasmer create-obj myfile.wasm -o myfile.o --prefix abc123
+wasmer create-exe myfile.wasm -o myfile.exe --precompiled-atom myfile:abc123:myfile.o
+```
+
+The speedup is apparent when timing this command against the non-cached version:
+
+```
+time wasmer create-exe myfile.wasm -o myfile.exe
+1,53s user 0,24s system 157% cpu 1,124 total
+time wasmer create-exe myfile.wasm -o myfile.exe --precompiled-atom myfile:myfile.o
+0,72s user 0,19s system 105% cpu 0,856 total
+```
diff --git a/arbitrator/tools/module_roots/wasmer/docs/dev/release.md b/arbitrator/tools/module_roots/wasmer/docs/dev/release.md
new file mode 100644
index 0000000..025ca5e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/dev/release.md
@@ -0,0 +1,85 @@
+# Release Process
+
+The release process of wasmer is mostly automated, including generating the CHANGELOG,
+tagging the release and starting the `build.yaml` action 
+
+In the `/scripts` folder, you will see three files:
+
+- `update-version.py`: iterates through all `Cargo.toml` files and bumps the version number
+according to `PREVIOUS_VERSION` and `NEXT_VERSION`
+- `publish.py`: resolves the dependency order and publishes all crates to crates.io
+- `make-release.py`: creates a new pull request from the current master branch, generates the
+CHANGELOG, waits until all checks have passed and the release PR is merged, then starts the 
+GitHub action to trigger the actual release on GitHub.
+
+In theory, all you need to do to create a new release is to look that master is green, then
+run `python3 scripts/make-release.py 3.2.0` - in practice the script can sometimes lock up or
+break due to unexpected delays for example it takes a couple of seconds between a pull request
+being merged and master being updated. Therefore it's best to run each step individually and
+make sure that every step finishes properly.
+
+```sh
+# required before starting
+gh login
+
+# Script will create a release PR (release-3.2.0) and loop until the 
+# release PR is merged into master (after checks are green)
+python3 scripts/make-release.py 3.2.0
+
+# After the release PR is merged, the build.yml workflow should be
+# triggered automatically - if it isn't, trigger it manually
+git checkout master
+git tag v3.2.0 && git push origin v3.2.0
+gh workflow run build.yml --ref v3.2.0 --field release=v3.2.0
+
+# After the release is done on GitHub, run the script again 
+# to update the release notes
+python3 scripts/make-release.py 3.2.0
+
+# Once the release on GitHub is properly done and verified that all
+# artifacts exist, checkout the tag and run the publishing to crates.io
+git checkout v3.2.0
+python3 scripts/publish.py publish
+``` 
+
+After the GitHub release (first command), the crates need to be 
+published to crates.io - the order is important because if anything 
+goes wrong in the first command or a release needs to be amended
+because of last-minute fixes, we can still revert the GitHub release, 
+but publishing on crates.io is final because we can't yank crates 
+(this has caused a lot of version-renumbering issues in the past).
+
+## Issues to watch out for
+
+There are a couple of problems with the scripts that you should watch out for:
+
+- On the release pull request, the CHANGELOG might be generated incorrectly or with wrong line endings
+- If the script fails, there should be an audible message (implemented using the `say` command), so that you
+  can leave the script running in the background and get notified if anything goes wrong.
+- The script might not trigger the `build.yml` action, in some cases it has to be run manually
+- Publishing to crates.io might fail because of new crates that have to be published manually.
+    - It is important to adjust the `SETTINGS` in the `publish.py` script if some crates need default-features
+      to be enabled when publishing
+    - crates that were never published before need to usually be published for the first time 
+      by `cd lib/crate && cargo publish`
+- After publishing new crates, check that the crate ownership is set to `github:wasmerio:wasmer-core`.
+- The CHANGELOG is generated from the pull request titles since the last release. Sometimes these titles need
+  to be fixed up to make any sense for a reader
+- The release notes should just highlight the most important changes for a release, not dump everything.
+- The following files should be released (TODO: more consistent naming schema):
+  - wasmer-darwin-amd64.tar.gz
+  - wasmer-darwin-arm64.tar.gz
+  - wasmer-linux-aarch64.tar.gz
+  - wasmer-linux-amd64.tar.gz
+  - wasmer-linux-musl-amd64.tar.gz
+  - wasmer-windows-amd64.tar.gz
+  - wasmer-windows-gnu64.tar.gz
+  - wasmer-windows.exe
+
+## Videos
+
+- [Creating the release pull request](https://www.youtube.com/watch?v=RMPTT-rnykA)
+- [Triggering the build.yml action manually](https://www.youtube.com/watch?v=7mF0nlfpQfA)
+   - Note that the version should always be tagged with a "v" tag
+   - The commit to tag for the version should be the merge commit of the release PR
+- [Publishing to crates.io](https://www.youtube.com/watch?v=uLdxIr6YwuY)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/en/examples-coredump.md b/arbitrator/tools/module_roots/wasmer/docs/en/examples-coredump.md
new file mode 100644
index 0000000..19a7754
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/en/examples-coredump.md
@@ -0,0 +1,62 @@
+# Using Wasm coredump
+
+The following steps describe how to debug using Wasm coredump in Wasmer:
+
+1. Compile your WebAssembly with debug info enabled; for example: 
+
+    ```sh
+    $ rustc foo.rs --target=wasm32-wasi -C debuginfo=2
+    ```
+
+<details>
+    <summary>foo.rs</summary>
+
+    fn c(v: usize) {
+        a(v - 3);
+    }
+
+    fn b(v: usize) {
+        c(v - 3);
+    }
+
+    fn a(v: usize) {
+        b(v - 3);
+    }
+
+    pub fn main() {
+        a(10);
+    }
+</details>
+
+2. Run with Wasmer and Wasm coredump enabled:
+
+    ```sh
+    $ wasmer --coredump-on-trap=/tmp/coredump foo.wasm
+
+    thread 'main' panicked at 'attempt to subtract with overflow', foo.rs:10:7
+    note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+    Error: failed to run main module `foo.wasm`
+
+    Caused by:
+        0: Core dumped at /tmp/coredump
+        1: failed to invoke command default
+        2: error while executing at wasm backtrace:
+                    ...
+    ```
+
+3. Use [wasmgdb] to debug:
+    ```sh
+    $ wasmgdb foo.wasm /tmp/coredump
+
+    wasmgdb> bt
+    ...
+    #13     000175 as panic () at library/core/src/panicking.rs
+    #12     000010 as a (v=???) at /path/to/foo.rs
+    #11     000009 as c (v=???) at /path/to/foo.rs
+    #10     000011 as b (v=???) at /path/to/foo.rs
+    #9      000010 as a (v=???) at /path/to/foo.rs
+    #8      000012 as main () at /path/to/foo.rs
+    ...
+    ```
+
+[wasmgdb]: https://crates.io/crates/wasmgdb
diff --git a/arbitrator/tools/module_roots/wasmer/docs/es/README.md b/arbitrator/tools/module_roots/wasmer/docs/es/README.md
new file mode 100644
index 0000000..34fbafc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/es/README.md
@@ -0,0 +1,200 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
+  </a>
+  
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="License">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square" alt="Slack channel">
+    </a> 
+  </p>
+
+  <h3>
+    <a href="https://wasmer.io/">Web</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">Documentación</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">Chat</a>
+  </h3>
+
+</div>
+
+<br />
+
+[Wasmer](https://wasmer.io/) hace posible tener contenedores ultraligeros basados en [WebAssembly](https://webassembly.org/) que pueden ser ejecutados en cualquier sitio: desde tu ordenador hasta la nube y dispositivos de IoT, además de poder ser ejecutados [*en cualquier lenguaje de programación*](https://github.com/wasmerio/wasmer#language-integrations).
+
+> This README is also available in: [🇩🇪 Deutsch-Alemán](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-Inglés](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇫🇷 Français-Francés](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • [🇨🇳 中文-Chino](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇯🇵 日本語-japonés](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md).
+
+## Funcionalidades
+
+* **Rápido y Seguro**. Wasmer ejecuta WebAssembly a velocidades *nativas* en un entorno completamente protegido.
+
+* **Extendible**. Wasmer soporta diferentes métodos de compilación dependiendo de tus necesidades (LLVM, Cranelift...).
+
+* **Universal**. Puedes ejecutar Wasmer en cualquier *platforma* (macOS, Linux y Windows) y *chip*.
+
+* **Respeta los estándares**. Wasmer pasa los [tests oficiales de WebAssembly](https://github.com/WebAssembly/testsuite) siendo compatible con [WASI](https://github.com/WebAssembly/WASI) y [Emscripten](https://emscripten.org/).
+
+## Empezamos?
+
+Wasmer no requiere ninguna dependencia. Puedes instalarlo con uno de estos instaladores:
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+<details>
+  <summary>Con PowerShell (Windows)</summary>
+  <p>
+
+```powershell
+iwr https://win.wasmer.io -useb | iex
+```
+
+</p>
+</details>
+
+> Visita [wasmer-install](https://github.com/wasmerio/wasmer-install) para más opciones de instalación: Homebrew, Scoop, Cargo...
+
+
+#### Ejecuta un archivo WebAssembly
+
+¡Después de instalar Wasmer deberías estar listo para ejecutar tu primer módulo de WebAssembly! 🎉
+
+Puedes empezar corriendo QuickJS: [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs >
+```
+
+#### Esto es lo que puedes hacer:
+
+- [Usa Wasmer desde tu aplicación de Rust](https://docs.wasmer.io/integrations/rust)
+- [Publica un paquete de Wasm en WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [Lee más sobre Wasmer](https://medium.com/wasmer/)
+
+## Integraciones en diferentes Lenguajes
+
+📦 Wasmer puede ser usado como una librería **integrada en diferentes lenguajes de programación**, para que puedas ejecutar WebAssembly _en cualquier sitio_.
+
+| &nbsp; | Lenguaje | Librería | Documentación |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` en crates.io] | [Documentación][rust docs]
+| ![C logo] | [**C/C++**][C integration] | [cabecera `wasmer.h`] | [Documentación][c docs] |
+| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` en NuGet] | [Documentación][c# docs] |
+| ![D logo] | [**D**][D integration] | [`wasmer` en Dug] | [Documentación][d docs] |
+| ![Python logo] | [**Python**][Python integration] | [`wasmer` en PyPI] | [Documentación][python docs] |
+| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` en NPM] | [Documentación][js docs] |
+| ![Go logo] | [**Go**][Go integration] | [`wasmer` en Go] | [Documentación][go docs] |
+| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` en PECL] | [Documentación][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` en Ruby Gems] | [Documentación][ruby docs] |
+| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` en Bintray] | [Documentación][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` en hex] | [Documentación][elixir docs] |
+| ![R logo] | [**R**][R integration] | *sin paquete publicado* | [Documentación][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | *sin paquete publicado* | [Documentación][postgres docs] |
+|  | [**Swift**][Swift integration] | *sin paquete publicado* | |
+| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋 Falta algún lenguaje?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` en crates.io]: https://crates.io/crates/wasmer/
+[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[cabecera `wasmer.h`]: https://wasmerio.github.io/wasmer/c/
+[c docs]: https://wasmerio.github.io/wasmer/c/
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` en NuGet]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` en Dub]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` en pypi]: https://pypi.org/project/wasmer/
+[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` en go]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[php docs]: https://wasmerio.github.io/wasmer-php/wasm/
+[`wasm` en pecl]: https://pecl.php.net/package/wasm
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` en npm]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` en ruby gems]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://www.rubydoc.info/gems/wasmer/
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` en bintray]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` en hex]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## Contribuye
+
+**Damos la bienvenida a cualquier forma de contribución, especialmente a los nuevos miembros de la comunidad** 💜
+
+¡Puedes ver cómo crear el binario de Wasmer con [nuestros increíbles documentos](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)!
+
+### Tests
+
+¿Quieres testear? Los [documentos de Wasmer te enseñarán cómo](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing).
+
+## Comunidad
+
+Wasmer tiene una comunidad increíble de desarrolladores y colaboradores ¡Bienvenido, únete a nosotros! 👋
+
+### Medios
+
+- [Slack](https://slack.wasmer.io/)
+- [Twitter](https://twitter.com/wasmerio)
+- [Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/fr/README.md b/arbitrator/tools/module_roots/wasmer/docs/fr/README.md
new file mode 100644
index 0000000..409daf1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/fr/README.md
@@ -0,0 +1,200 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Logo Wasmer">
+  </a>
+  
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="État des tests">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="Licence">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square" alt="Salon Slack">
+    </a> 
+  </p>
+
+  <h3>
+    <a href="https://wasmer.io/">Web</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">Documentation</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">Chat</a>
+  </h3>
+
+</div>
+
+<br />
+
+[Wasmer](https://wasmer.io/) permet l'utilisation de conteneurs super légers basés sur [WebAssembly](https://webassembly.org/) qui peuvent fonctionner n'importe où : du bureau au cloud en passant par les appareils IoT, et également intégrés dans [*une multitude de langages de programmation*](https://github.com/wasmerio/wasmer#language-integrations).
+
+> This readme is also available in: [🇩🇪 Deutsch-Allemand](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇬🇧 English-Anglaise](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-Espagnol](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇨🇳 中文-Chinoise](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇯🇵 日本語-japonais](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md)
+
+## Fonctionnalités
+
+* **Rapide et sûr**. Wasmer exécute WebAssembly à une vitesse *quasi native* dans un environnement entièrement contrôlé (bac à sable, _sandbox_).
+
+* **Modulaire**. Wasmer prend en charge différents frameworks de compilation pour répondre au mieux à vos besoins (LLVM, Cranelift ...).
+
+* **Universel**. Vous pouvez exécuter Wasmer sur n'importe quelle *plate-forme* (macOS, Linux et Windows) et *processeur*.
+
+* **Conforme aux normes**. Wasmer passe [la suite de tests officielle de WebAssembly](https://github.com/WebAssembly/testsuite) prenant en charge [WASI](https://github.com/WebAssembly/WASI) et [Emscripten](https://emscripten.org/)
+
+## Quickstart
+
+Wasmer est livré sans aucune dépendance. Vous pouvez l'installer à l'aide des programmes d'installation ci-dessous :
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+<details>
+  <summary>Avec PowerShell (Windows)</summary>
+  <p>
+
+```powershell
+iwr https://win.wasmer.io -useb | iex
+```
+
+</p>
+</details>
+
+> Voir [wasmer-install](https://github.com/wasmerio/wasmer-install) pour plus d'options d'installation: Homebrew, Scoop, Cargo...
+
+
+#### Exécution d'un fichier WebAssembly
+
+Après avoir installé Wasmer, vous devriez être prêt à exécuter votre premier fichier WebAssemby ! 🎉
+
+Vous pouvez commencer par exécuter QuickJS : [qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs >
+```
+
+#### Voici ce que vous pouvez faire ensuite
+
+- [Utilisez Wasmer depuis votre application Rust](https://docs.wasmer.io/integrations/rust)
+- [Publier un paquet Wasm sur WAPM](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [En savoir plus sur Wasmer](https://medium.com/wasmer/)
+
+## Intégrations
+
+📦  Wasmer peut être utilisé comme une bibliothèque **intégrée dans différents langages**, vous pouvez donc utiliser WebAssembly _n'import où_.
+
+| &nbsp; | Langage de programmation | Package | Docs |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Docs][rust docs]
+| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` headers] | [Docs][c docs] |
+| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Docs][c# docs] |
+| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Docs][d docs] |
+| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Docs][python docs] |
+| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Docs][js docs] |
+| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Docs][go docs] |
+| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Docs][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Docs][ruby docs] |
+| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Docs][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Docs][elixir docs] |
+| ![R logo] | [**R**][R integration] | *no published package* | [Docs][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | *no published package* | [Docs][postgres docs] |
+|  | [**Swift**][Swift integration] | *no published package* | |
+| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋  Il manque un langage ?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/
+[c docs]: https://wasmerio.github.io/wasmer/c/
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/wasm/
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://www.rubydoc.info/gems/wasmer/
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## Contribuer
+
+**Nous accueillons toutes formes de contributions, en particulier de la part des nouveaux membres de notre communauté**. 💜
+
+Vous pouvez vérifier comment compiler Wasmer dans [notre documentation](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)!
+
+### Test
+
+Vous voulez des tests ? La [documentation de Wasmer](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing) vous montrera comment les exécuter.
+
+## Communauté
+
+Wasmer a une incroyable communauté de développeurs et de contributeurs. Bienvenue et rejoignez-nous ! 👋
+
+### Canaux de communications
+
+- [Slack](https://slack.wasmer.io/)
+- [Twitter](https://twitter.com/wasmerio)
+- [Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/ja/README.md b/arbitrator/tools/module_roots/wasmer/docs/ja/README.md
new file mode 100644
index 0000000..c7110dd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/ja/README.md
@@ -0,0 +1,200 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmerロゴ">
+  </a>
+  
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="ビルドステータス">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square" alt="ライセンス">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square" alt="Slackチャンネル">
+    </a> 
+  </p>
+
+  <h3>
+    <a href="https://wasmer.io/">Website</a>
+    <span> • </span>
+    <a href="https://docs.wasmer.io">Docs</a>
+    <span> • </span>
+    <a href="https://slack.wasmer.io/">Chat</a>
+  </h3>
+
+</div>
+
+<br />
+
+[Wasmer](https://wasmer.io/) は、[WebAssembly](https://webassembly.org/) をベースとした非常に軽量なコンテナを実現します。デスクトップからクラウドや IoT デバイス上まで、どんな環境でも実行でき、さらに[*任意のプログラミング言語*](#他の言語とのインテグレーション)に埋め込むこともできます。
+
+> この readme は、次の言語でも利用可能です。[🇩🇪 Deutsch-ドイツ語](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • [🇨🇳 中文-Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • [🇬🇧 English-英語](https://github.com/wasmerio/wasmer/blob/master/README.md) • [🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • [🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md)
+
+## 機能
+
+* **高速かつ安全**。WebAssembly を完全なサンドボックス環境内で*ネイティブに近い*スピードで実行します。
+
+* **プラガブル**。異なるコンパイルフレームワーク (LLVM、Cranelift など...) をサポートしているため、ニーズに合った最適なフレームワークを選択できます。
+
+* **ユニバーサル**。どんなプラットフォーム上 (macOS、Linux、Windows) でも、どんな*チップセット*上でも実行できます。
+
+* **標準に準拠**。ランタイムは[公式の WebAssembly テストスイート](https://github.com/WebAssembly/testsuite)に通っており、[WASI](https://github.com/WebAssembly/WASI) と [Emscripten](https://emscripten.org/) をサポートします。
+
+## クイックスタート
+
+Wasmer は依存関係なしで動作します。以下のコマンドでインストーラーを使用してインストールできます。
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+<details>
+  <summary>PowerShell の場合 (Windows)</summary>
+  <p>
+
+```powershell
+iwr https://win.wasmer.io -useb | iex
+```
+
+</p>
+</details>
+
+> Homebrew、Scoop、Cargo など、他のインストール方法については、[wasmer-install](https://github.com/wasmerio/wasmer-install) を参照してください。
+
+
+#### WebAssembly ファイルの実行
+
+Wasmer をインストールしたら、初めての WebAssembly ファイルの実行準備が完了です！ 🎉
+
+QuickJS ([qjs.wasm](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm)) を実行することで、すぐに始められます。
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs >
+```
+
+#### 次にできること
+
+- [Rust アプリケーションから Wasmer を使用する](https://docs.wasmer.io/integrations/rust)
+- [WAPM で Wasm パッケージを公開する](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [Wasmer についてさらに学ぶ](https://medium.com/wasmer/)
+
+## 他の言語とのインテグレーション
+
+📦 Wasmer ランタイムは**他の言語に組み込んで**使用できるため、WebAssembly は*どんな場所でも*利用できます。
+
+| &nbsp; | Language | Package | Docs |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Docs][rust docs]
+| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` headers] | [Docs][c docs] |
+| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Docs][c# docs] |
+| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Docs][d docs] |
+| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Docs][python docs] |
+| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Docs][js docs] |
+| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Docs][go docs] |
+| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Docs][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Docs][ruby docs] |
+| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Docs][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Docs][elixir docs] |
+| ![R logo] | [**R**][R integration] | *公開パッケージなし* | [Docs][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | *公開パッケージなし* | [Docs][postgres docs] |
+|  | [**Swift**][Swift integration] | *公開パッケージなし* | |
+| ![Zig logo] | [**Zig**][Zig integration] | *no published package* | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋 言語が見当たらない？](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://wasmerio.github.io/wasmer/crates/wasmer
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasmer.h` headers]: https://wasmerio.github.io/wasmer/c/
+[c docs]: https://wasmerio.github.io/wasmer/c/
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://github.com/wasmerio/wasmer-python#api-of-the-wasmer-extensionmodule
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/wasm/
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://www.rubydoc.info/gems/wasmer/
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## コントリビューション
+
+**どんな形での貢献も歓迎です。コミュニティの新しいメンバーからの貢献は特に歓迎します。** 💜
+
+Wasmer ランタイムのビルド方法は、[素晴らしいドキュメント](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)で確認できます！
+
+### テスト
+
+テストを実行したいですか？ [Wasmer docs で方法を説明](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing)しています。
+
+## コミュニティ
+
+Wasmer には、開発者とコントリビューターの素晴らしいコミュニティがあります。ようこそ！ あなたも是非参加してください！ 👋
+
+### チャンネル
+
+- [Slack](https://slack.wasmer.io/)
+- [Twitter](https://twitter.com/wasmerio)
+- [Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/journal.md b/arbitrator/tools/module_roots/wasmer/docs/journal.md
new file mode 100644
index 0000000..70c1d89
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/journal.md
@@ -0,0 +1,148 @@
+# WASM Journal Functionality
+
+Wasmer now supports journals for the state of a WASM process. This gives the ability
+to persist changes made to the temporary file system and to save and store snapshots
+of the running process.
+
+The journal file is a linear history of events that occurred when the process was
+running that if replayed will bring the process made to a discrete and deterministic
+state.
+
+Journal files can be concatenated, compacted and filtered to change the discrete state.
+
+These journals are maintained in a consistent and durable way thus ensuring that
+failures of the system while the process is running does not corrupt the journal.
+
+# Snapshot Triggers
+
+The journal will record state changes to the sandbox built around the WASM process as
+it runs however it may be important to certain use-cases to take explicit snapshot
+restoration points in the journal at key points that make sense.
+
+When a snapshot is triggered all the running threads of the process are paused and
+the state of the WASM memory and thread stacks are recorded into the journal so that
+they can be restored.
+
+In order to use the snapshot functionality the WASM process must be compiled with
+the `asyncify` modifications, this can be done using the `wasm-opt` tool.
+
+Note: If a process does not have the `asyncify` modifications you can still use
+the journal functionality for recording the file system and WASM memory state
+however the stacks of the threads will be omitted meaning a restoration will
+restart the main thread.
+
+Various triggers are possible that will cause a snapshot to be taken at a specific
+point in time, these are as follows:
+
+## On Idle
+
+Triggered when all the threads in the process go into an idle state. This trigger
+is useful to take snapshots at convenient moments without causing unnecessary overhead.
+
+For processes that have TTY/STDIN input this is particularly useful.
+
+## On FirstListen
+
+Triggered when a listen syscall is invoked on a socket. This can be an important
+milestone to take a snapshot when one wants to speed up the boot time of a WASM process
+up to the moment where it is ready to accept requests.
+    
+## On FirstStdin
+
+Triggered when the process reads stdin for the first time. This can be useful to
+speed up the boot time of a WASM process.
+
+## On FirstEnviron
+
+Triggered when the process reads an environment variable for the first time. This can
+be useful to speed up the boot time of a CGI WASM process which reads the environment
+variables to parse the request that it must execute.
+
+## On Timer Interval
+
+Triggered periodically based on a timer (default 10 seconds) which can be specified
+using the `journal-interval` option. This can be useful for asynchronous replication
+of a WASM process from one machine to another with a particular lag latency.
+
+## On Sigint (Ctrl+C)
+
+Issued if the user sends an interrupt signal (Ctrl + C).
+
+## On Sigalrm
+
+Alarm clock signal (used for timers)
+(see `man alarm`)
+
+## On Sigtstp
+
+The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop
+temporarily. It is commonly initiated by the user pressing Ctrl-Z.
+
+# On Sigstop
+
+The SIGSTOP signal instructs the operating system to stop a process for later resumption
+
+# On Non Deterministic Call
+
+When a non-deterministic call is made from WASM process to the outside world (i.e. it reaches
+out of the sandbox)
+
+# Limitations
+
+- The WASM process that wish to record the state of the threads must have had the `asyncify`
+  post processing step applied to the binary (see `wasm-opt`).
+- Taking a snapshot can consume large amounts of memory while its processing.
+- Snapshots are not instant and have overhead when generating.
+- The layout of the memory must be known by the runtime in order to take snapshots.
+
+# Design
+
+On startup if the restore journal file is specified then the runtime will restore the
+state of the WASM process by reading and processing the log entries in the snapshot
+journal. This restoration will bring the memory and the thread stacks back to a previous
+point in time and then resume all the threads.
+
+When a trigger occurs a new journal will be taken of the WASM process which will
+take the following steps:
+
+1. Pause all threads
+2. Capture the stack of each thread
+3. Write the thread state to the journal
+4. Write the memory (excluding stacks) to the journal
+5. Resume execution.
+
+The implementation is currently able to save and restore the following:
+
+- WASM Memory
+- Stack memory
+- Call stack
+- Open sockets
+- Open files
+- Terminal text
+
+# Journal Capturer Implementations
+
+## Log File Journal
+
+Writes the log events to a linear log file on the local file system
+as they are received by the trait. Log files can be concatenated
+together to make larger log files.
+
+## Unsupported Journal
+
+The default implementation does not support snapshots and will error
+out if an attempt is made to send it events. Using the unsupported
+capturer as a restoration point will restore nothing but will not
+error out.
+
+## Compacting Journal
+
+Deduplicates memory and stacks to reduce the number of volume of
+log events sent to its inner capturer. Compacting the events occurs
+in line as the events are generated
+
+## Filtered Journal
+
+Filters out a specific set of log events and drops the rest, this
+capturer can be useful for restoring to a previous call point but
+retaining the memory changes (e.g. WCGI runner).
diff --git a/arbitrator/tools/module_roots/wasmer/docs/ko/README.md b/arbitrator/tools/module_roots/wasmer/docs/ko/README.md
new file mode 100644
index 0000000..81843fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/ko/README.md
@@ -0,0 +1,228 @@
+<div align="center">
+  <a href="https://wasmer.io" target="_blank" rel="noopener noreferrer">
+    <img width="300" src="https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/logo.png" alt="Wasmer logo">
+  </a>
+
+  <p>
+    <a href="https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild">
+      <img src="https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square" alt="Build Status">
+    </a>
+    <a href="https://github.com/wasmerio/wasmer/blob/master/LICENSE">
+      <img src="https://img.shields.io/github/license/wasmerio/wasmer.svg" alt="License">
+    </a>
+    <a href="https://docs.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Docs&message=docs.wasmer.io&color=blue" alt="Wasmer Docs">
+    </a>
+    <a href="https://slack.wasmer.io">
+      <img src="https://img.shields.io/static/v1?label=Slack&message=join%20us!&color=brighgreen" alt="Slack channel">
+    </a>
+  </p>
+</div>
+
+<br />
+
+Wasmer는 _초경량 컨테이너_ 를 *Desktop*에서부터 *Cloud*, *Edge*, *IoT* 기기들까지 어디에서나 실행할 수 있는 _빠르고 안전한_ [**WebAssembly**](https://webassembly.org) 런타임 입니다.
+
+> _이 문서는 아래와 같은 언어들을 지원합니다.:
+[🇨🇳 中 文 -Chinese](https://github.com/wasmerio/wasmer/blob/master/docs/cn/README.md) • 
+[🇩🇪 Deutsch-German](https://github.com/wasmerio/wasmer/blob/master/docs/de/README.md) • 
+[🇪🇸 Español-Spanish](https://github.com/wasmerio/wasmer/blob/master/docs/es/README.md) • 
+[🇫🇷 Français-French](https://github.com/wasmerio/wasmer/blob/master/docs/fr/README.md) • 
+[🇯🇵 日本 語 -Japanese](https://github.com/wasmerio/wasmer/blob/master/docs/ja/README.md)_.
+[🇰🇷 한국어 -Korean](https://github.com/wasmerio/wasmer/blob/master/docs/ko/README.md)_.
+
+### 특징
+
+* 기본적으로 안전합니다. 명시적으로 설정하지 않는 한 파일, 네트워크 또는 환경에 액세스할 수 없습니다.
+* [WASI](https://github.com/WebAssembly/WASI)와 [Emscripten](https://emscripten.org/)을 즉시 지원합니다.
+* 빠릅니다. native에 가까운 속도로 WebAssembly를 실행합니다.
+* [여러 프로그래밍 언어](https://github.com/wasmerio/wasmer/#-language-integrations)에 임베디드 가능합니다.
+* 최신 WebAssembly 제안(SIMD, Reference Types, Threads, ...)을 준수합니다.
+
+### 설치
+
+Wasmer CLI는 종속성이 없는 단일 실행 파일로 제공됩니다.
+
+```sh
+curl https://get.wasmer.io -sSfL | sh
+```
+
+
+<details>
+  <summary>다른 설치 옵션 (Powershell, Brew, Cargo, ...)</summary>
+  
+  _Wasmer는 다양한 패키지 매니저를 통해 설치 할 수 있습니다. 환경에 가장 적합한 것을 선택하십시오.:_
+  
+  * Powershell (Windows)
+    ```powershell
+    iwr https://win.wasmer.io -useb | iex
+    ```
+
+  * <a href="https://formulae.brew.sh/formula/wasmer">Homebrew</a> (macOS, Linux)
+
+    ```sh
+    brew install wasmer
+    ```
+
+  * <a href="https://github.com/ScoopInstaller/Main/blob/master/bucket/wasmer.json">Scoop</a> (Windows)
+
+    ```sh
+    scoop install wasmer
+    ```
+
+  * <a href="https://chocolatey.org/packages/wasmer">Chocolatey</a> (Windows)
+
+    ```sh
+    choco install wasmer
+    ```
+  
+  * <a href="https://crates.io/crates/wasmer-cli/">Cargo</a>
+
+    _Note: 사용 가능한 모든 기능은 [`wasmer-cli`
+    crate docs](https://github.com/wasmerio/wasmer/tree/master/lib/cli/README.md) 문서에 설명되어 있습니다._
+
+    ```sh
+    cargo install wasmer-cli
+    ```
+
+  > 더 많은 설치 옵션을 찾고 계십니까? 자세한 내용은 [the `wasmer-install`
+  repository](https://github.com/wasmerio/wasmer-install)를 참조하십시오!
+</details>
+
+### 빠른 시작
+
+WebAssembly 모듈([`qjs.wasm`](https://registry-cdn.wapm.io/contents/_/quickjs/0.0.3/build/qjs.wasm))로 컴파일된
+작고 포함 가능한 Javascript 엔진인 [QuickJS](https://github.com/bellard/quickjs/)를 실행하여 시작할 수 있습니다.:
+
+```bash
+$ wasmer qjs.wasm
+QuickJS - Type "\h" for help
+qjs > const i = 1 + 2;
+qjs > console.log("hello " + i);
+hello 3
+```
+
+#### 다음에 할 수 있는 일 :
+
+- [어플리케이션에서 wasmer 사용](https://docs.wasmer.io/integrations/rust)
+- [WAPM에 wasm 패키지 게시](https://docs.wasmer.io/ecosystem/wapm/publishing-your-package)
+- [Wasmer에 대해 자세히 알아보기](https://medium.com/wasmer/)
+
+## 📦 다른 언어와의 통합
+
+Wasmer 런타임은 **다른 언어에 내장된** 라이브러리로 사용할 수 있으므로 _어디에서나_ WebAssembly를 사용할 수 있습니다.
+
+| | Language | Package | Documentation |
+|-|-|-|-|
+| ![Rust logo] | [**Rust**][Rust integration] | [`wasmer` Rust crate] | [Learn][rust docs]
+| ![C logo] | [**C/C++**][C integration] | [`wasmer.h` header] | [Learn][c docs] |
+| ![C# logo] | [**C#**][C# integration] | [`WasmerSharp` NuGet package] | [Learn][c# docs] |
+| ![D logo] | [**D**][D integration] | [`wasmer` Dub package] | [Learn][d docs] |
+| ![Python logo] | [**Python**][Python integration] | [`wasmer` PyPI package] | [Learn][python docs] |
+| ![JS logo] | [**Javascript**][JS integration] | [`@wasmerio` NPM packages] | [Learn][js docs] |
+| ![Go logo] | [**Go**][Go integration] | [`wasmer` Go package] | [Learn][go docs] |
+| ![PHP logo] | [**PHP**][PHP integration] | [`wasm` PECL package] | [Learn][php docs] |
+| ![Ruby logo] | [**Ruby**][Ruby integration] | [`wasmer` Ruby Gem] | [Learn][ruby docs] |
+| ![Java logo] | [**Java**][Java integration] | [`wasmer/wasmer-jni` Bintray package] | [Learn][java docs] |
+| ![Elixir logo] | [**Elixir**][Elixir integration] | [`wasmex` hex package] | [Learn][elixir docs] |
+| ![R logo] | [**R**][R integration] | *공개 패키지 없음* | [Learn][r docs] |
+| ![Postgres logo] | [**Postgres**][Postgres integration] | *공개 패키지 없음* | [Learn][postgres docs] |
+|  | [**Swift**][Swift integration] | *공개 패키지 없음* | |
+| ![Zig logo] | [**Zig**][Zig integration] | *공개 패키지 없음* | |
+| ![Dart logo] | [**Dart**][Dart integration] | [`wasm` pub package] | |
+|  | [**Lisp**][Lisp integration] | *under heavy development - no published package* | |
+| ![Ocaml logo] | [**OCaml**][OCaml integration] | [`wasmer` OCaml package] | |
+
+[👋&nbsp;&nbsp;없는 언어가 있습니까?](https://github.com/wasmerio/wasmer/issues/new?assignees=&labels=%F0%9F%8E%89+enhancement&template=---feature-request.md&title=)
+
+[rust logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/rust.svg
+[rust integration]: https://github.com/wasmerio/wasmer/tree/master/lib/api
+[`wasmer` rust crate]: https://crates.io/crates/wasmer/
+[rust docs]: https://docs.rs/wasmer/
+
+[c logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/c.svg
+[c integration]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+[`wasmer.h` header]: https://github.com/wasmerio/wasmer/blob/master/lib/c-api/wasmer.h
+[c docs]: https://docs.rs/wasmer-c-api/*/wasmer_c_api/wasm_c_api/index.html
+
+[c# logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/csharp.svg
+[c# integration]: https://github.com/migueldeicaza/WasmerSharp
+[`wasmersharp` nuget package]: https://www.nuget.org/packages/WasmerSharp/
+[c# docs]: https://migueldeicaza.github.io/WasmerSharp/
+
+[d logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/d.svg
+[d integration]: https://github.com/chances/wasmer-d
+[`wasmer` Dub package]: https://code.dlang.org/packages/wasmer
+[d docs]: https://chances.github.io/wasmer-d
+
+[python logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/python.svg
+[python integration]: https://github.com/wasmerio/wasmer-python
+[`wasmer` pypi package]: https://pypi.org/project/wasmer/
+[python docs]: https://wasmerio.github.io/wasmer-python/api/wasmer/
+
+[go logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/go.svg
+[go integration]: https://github.com/wasmerio/wasmer-go
+[`wasmer` go package]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer
+[go docs]: https://pkg.go.dev/github.com/wasmerio/wasmer-go/wasmer?tab=doc
+
+[php logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/php.svg
+[php integration]: https://github.com/wasmerio/wasmer-php
+[`wasm` pecl package]: https://pecl.php.net/package/wasm
+[php docs]: https://wasmerio.github.io/wasmer-php/
+
+[js logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/js.svg
+[js integration]: https://github.com/wasmerio/wasmer-js
+[`@wasmerio` npm packages]: https://www.npmjs.com/org/wasmer
+[js docs]: https://docs.wasmer.io/integrations/js/reference-api
+
+[ruby logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ruby.svg
+[ruby integration]: https://github.com/wasmerio/wasmer-ruby
+[`wasmer` ruby gem]: https://rubygems.org/gems/wasmer
+[ruby docs]: https://wasmerio.github.io/wasmer-ruby/wasmer_ruby/index.html
+
+[java logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/java.svg
+[java integration]: https://github.com/wasmerio/wasmer-java
+[`wasmer/wasmer-jni` bintray package]: https://bintray.com/wasmer/wasmer-jni/wasmer-jni
+[java docs]: https://github.com/wasmerio/wasmer-java/#api-of-the-wasmer-library
+
+[elixir logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/elixir.svg
+[elixir integration]: https://github.com/tessi/wasmex
+[elixir docs]: https://hexdocs.pm/wasmex/api-reference.html
+[`wasmex` hex package]: https://hex.pm/packages/wasmex
+
+[r logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/r.svg
+[r integration]: https://github.com/dirkschumacher/wasmr
+[r docs]: https://github.com/dirkschumacher/wasmr#example
+
+[postgres logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/postgres.svg
+[postgres integration]: https://github.com/wasmerio/wasmer-postgres
+[postgres docs]: https://github.com/wasmerio/wasmer-postgres#usage--documentation
+
+[swift integration]: https://github.com/AlwaysRightInstitute/SwiftyWasmer
+
+[zig logo]: https://raw.githubusercontent.com/ziglang/logo/master/zig-favicon.png
+[zig integration]: https://github.com/zigwasm/wasmer-zig
+
+[dart logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/dart.svg
+[dart integration]: https://github.com/dart-lang/wasm
+[`wasm` pub package]: https://pub.dev/packages/wasm
+
+[lisp integration]: https://github.com/helmutkian/cl-wasm-runtime
+
+[OCaml logo]: https://raw.githubusercontent.com/wasmerio/wasmer/master/assets/languages/ocaml.svg
+[OCaml integration]: https://github.com/wasmerio/wasmer-ocaml
+[`wasmer` OCaml package]: https://opam.ocaml.org/packages/wasmer/
+
+## 기여
+
+도움을 주셔서 감사합니다! 💜
+
+[Wasmer를 빌드](https://docs.wasmer.io/ecosystem/wasmer/building-from-source)하거나 [변경 사항을 테스트](https://docs.wasmer.io/ecosystem/wasmer/building-from-source/testing)하는 방법에 대한 문서를 확인하십시오.
+
+## 커뮤니티
+Wasmer에는 개발자의 기여가 있는 훌륭한 커뮤니티가 있습니다. 환영합니다! 꼭 참여해주세요! 👋
+
+- [Wasmer Community Slack](https://slack.wasmer.io/)
+- [Wasmer on Twitter](https://twitter.com/wasmerio)
+- [Wasmer on Facebook](https://www.facebook.com/wasmerio)
+- [Email](mailto:hello@wasmer.io)
diff --git a/arbitrator/tools/module_roots/wasmer/docs/migration_to_1.0.0.md b/arbitrator/tools/module_roots/wasmer/docs/migration_to_1.0.0.md
new file mode 100644
index 0000000..5da6c35
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/migration_to_1.0.0.md
@@ -0,0 +1,358 @@
+# Migrating from Wasmer 0.x to Wasmer 1.0.0
+
+Wasmer 1.0.0 is getting ready for a full release and is our primary focus. This document will
+describe the differences between Wasmer 0.x and Wasmer 1.0.0 and provide examples
+to make migrating to the new API as simple as possible.
+
+## Table of Contents
+
+- [Rationale for changes in 1.0.0](#rationale-for-changes-in-100)
+- [How to use Wasmer 1.0.0](#how-to-use-wasmer-100)
+  - [Installing Wasmer CLI](#installing-wamser-cli)
+  - [Using Wasmer 1.0.0](#using-wamser-100)
+- [Project structure](#project-structure)
+- [Differences](#differences)
+  - [Instantiating modules](#instantiating-modules)
+  - [Passing host functions](#passing-host-functions)
+  - [Accessing the environment as a host function](#accessing-the-environment-as-a-host-function)
+  - [Error handling](#error-handling)
+  - [Caching modules](#caching-modules)
+
+## Rationale for changes in 1.0.0
+
+Wasmer 0.x was great but as the Wasm community and standards evolve we felt the need to make Wasmer also follow these 
+changes.
+
+Wasmer 1.x is what we think a necessary rewrite of a big part of the project to make it more future-proof. 
+
+This version introduces many new features and makes using Wasmer more natural. We did a hard work making it as close 
+to the standard API as possible while always providing good performances, flexibility and stability. 
+
+The rewrite of the Wasmer Runtime also comes with a rewrite of the languages integrations to achieve the same goals: 
+providing a clearer API and improving the feature set.
+
+In this document you will discover the major changes between Wasmer 0.x and Wasmer 1.x by highlighting how to use the 
+new Rust API.
+
+## How to use Wasmer 1.0.0
+
+### Installing Wasmer CLI
+
+See [wasmer.io] for installation instructions.
+
+If you already have wasmer installed, run `wasmer self-update`.
+
+Install the latest versions of Wasmer with [wasmer-nightly] or by following the steps described in the 
+documentation: [Getting Started][getting-started].
+
+### Using Wasmer 1.0.0
+
+The CLI interface for Wasmer 1.0.0 is mostly the same as it was in Wasmer 0.x.
+
+One difference is that rather than specifying the compiler with `--backend=cranelift`,
+in Wasmer 1.0.0 we prefer using the name of the backend as a flag directly,
+for example: `--cranelift`.
+
+The top-level crates that users will usually interface with are:
+
+- [wasmer] - Wasmer's core runtime API
+- [wasmer-wasi] - Wasmer's WASI implementation
+- [wasmer-emscripten] - Wasmer's Emscripten implementation
+- TODO:
+
+See the [examples] to find out how to do specific things in Wasmer 1.0.0.
+
+## Project Structure
+
+![Wasmer dependencies graph](./deps_dedup.svg)
+
+The figure above shows the core Wasmer crates and their dependencies with transitive dependencies deduplicated.
+
+Wasmer 1.0.0 has two core architectural abstractions: engines and compilers.
+
+An engine is a system that processes Wasm with a compiler and prepares it to be executed.
+
+A compiler is a system that translates Wasm into a format that can be understood
+more directly by a real computer: machine code.
+
+For example, in the [examples] you'll see that we are using the JIT engine and the Cranelift compiler. The JIT engine 
+will generate machine code at runtime, using Cranelift, and then execute it.  
+
+For most uses, users will primarily use the [wasmer] crate directly, perhaps with one of our
+provided ABIs such as [wasmer-wasi]. However, for users that need finer grained control over
+the behavior of wasmer, other crates such as [wasmer-compiler] and [wasmer-engine] may be used
+to implement custom compilers and engines respectively.
+
+## Differences
+
+### Instantiating modules
+
+With Wasmer 0.x, instantiating a module was a matter of calling `wasmer::compiler::compile` and then calling 
+`instantiate` on the compiled module.
+
+While simple, this did not give you full-control over Wasmer's configuration. For example, choosing another compiler
+was not straightforward.
+
+With Wasmer 1.x, we changed this part and made the API look more like how Wasmer works internally to give you more 
+control:
+
+```diff
+- let module = compile(&wasm_bytes[..])?; 
++ let engine = JIT::new(Cranelift::default()).engine();
++ let store = Store::new(&engine);
++ let module = Module::new(&store, wasm_bytes)?;
+- let instance = module.instantiate(&imports)?;
++ let instance = Instance::new(&module, &import_object)?;
+```
+
+Note that we did not cover how to create the import object here. This is because this part works the same as it used to 
+with Wasmer 0.x.
+
+To get more information on how instantiation now works, have a look at the [dedicated example][instance-example]
+
+### Passing host functions
+
+With Wasmer 0.x passing host functions to the guest was primarily done using the `func!` macro or by directly using 
+`Func::new` or `DynamicFunc::new`.
+
+In Wasmer 1.0 the equivalent of `Func::new` is `Function::new_native` /
+`Function::new_native_with_env` and the equivalent of `DynamicFunc::new` 
+is `Function::new` / `Function::new_with_env`.
+
+Given we have a function like:
+
+```rust
+fn sum(a: i32, b: i32) -> i32 {
+    a + b
+}
+```
+
+We want to import this function in the guest module, let's have a look at how it differs between Wasmer 0.x and 
+Wasmer 1.x:
+
+```diff
+let import_object = imports! {
+    "env" => {
+-         "sum" => func!(sum),
++         "sum" => Function::new_native(&store, sum),
+    }
+}
+```
+
+The above example illustrates how to import what we call "native functions". There were already available in Wasmer 
+0.x through the `func!` macro or with `Func::new`.
+
+There is a second flavor for imported functions: dynamic functions. With Wasmer 0.x you would have created such a 
+function using `DynamicFunc::new`, here is how it's done with Wasmer 1.x:
+
+```rust
+let sum_signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]);
+let sum = Function::new(&store, &sum_signature, |args| {
+    let result = args[0].unwrap_I32() + args[1].unwrap_i32();
+    
+    Ok(vec![Value::I32(result)])
+});
+```
+
+Both examples address different needs and have their own pros and cons. We encourage you to have a look at the 
+dedicated example: [Exposing host functions][host-functions-example].
+
+Note that having this API for functions now looks more like the other entities APIs: globals, memories, tables. Here is 
+a quick example introducing each of them: [Imports & Exports][imports-exports-example]
+
+### Accessing the environment as a host function
+
+With Wasmer 0.x each function had its own `vm::Ctx`. This was your entrypoint to the module internals and allowed
+access to the context of the currently running instance.
+
+With Wasmer 1.0.0 this was changed to provide a simpler yet powerful API.
+
+Let's see an example where we want to have access to the module memory. Here is how that changed from 0.x to 1.0.0:
+
+```diff
++ #[derive(WasmerEnv, Clone, Default)]
++ struct MyEnv {
++     #[wasmer(export)]
++     memory: LazyInit<Memory>,
++ }
++ let env = MyEnv::default();
++
+- let get_at = |ctx: &mut vm::Ctx, ptr: WasmPtr<u8, Array>, len: u32| {
++ let get_at = |env: &MyEnv, ptr: WasmPtr<u8, Array>, len: u32| {
+-     let mem_desc = ctx.memory(0);
+-     let mem = mem_desc.deref();
++     let mem = env.memory_ref().unwrap();
+  
+      println!("Memory: {:?}", mem);
+  
+      let string = ptr.get_utf8_string(mem, len).unwrap();
+      println!("string: {}", string);
+  };
+
+  let import_object = imports! {
+      "env" => {
+-         "get_at" => func!(get_at),
++         "get_at" => Function::new_native_with_env(&store, env.clone(), get_at),
+      }
+  };
+
+- let instance = instantiate(wasm_bytes, &import_object)?;
++ let instance = Instance::new(&wasm_bytes, &import_object)?;
+```
+
+Here we have a module which provides one exported function: `get`. Each time we call this function it will in turn 
+call our imported function `get_at`.
+
+The `get_at` function is responsible for reading the guest module-s memory through the `vm::Ctx`.
+
+With Wasmer 1.0.0 (where the `vm::Ctx` does not exist anymore) we can achieve the same result with something more 
+natural: we only use imports and exports to read from the memory and write to it.
+
+However in order to provide an easy to use interface, we now have a trait
+that can be implemented with a derive macro: `WasmerEnv`. We must make our
+env types implement `WasmerEnv` and `Clone`. We mark an internal field
+wrapped with `LazyInit` with `#[wasmer(export)]` to indicate that the type
+should be found in the Wasm exports with the name of the field
+(`"memory"`). The derive macro then generates helper functions such as
+`memory_ref` on the type for easy access to these fields.
+
+See the [`WasmerEnv`](https://docs.rs/wasmer/*/wasmer/trait.WasmerEnv.html)
+docs for more information.
+
+Take a look at the following examples to get more details:
+* [Interacting with memory][memory]
+* [Using memory pointers][memory-pointers]
+
+The other thing where `vm::Ctx` was useful was to pass data from and to host functions. This has also been made simpler
+with Wasmer 1.x:
+
+```rust
+let shared_counter: Arc<RefCell<i32>> = Arc::new(RefCell::new(0));
+
+#[derive(WasmerEnv, Clone)]
+struct Env {
+    counter: Arc<RefCell<i32>>,
+}
+
+fn get_counter(env: &Env) -> i32 {
+    *env.counter.borrow()
+}
+
+let get_counter_func = Function::new_native_with_env(
+    &store, 
+    Env { counter: shared_counter.clone() }, 
+    get_counter
+);
+```
+
+A dedicated example describes how to use this feature: [Exposing host functions][host-functions].
+
+### Error handling
+
+Handling errors with Wasmer 0.x was a bit hard, especially, the `wasmer_runtime::error::RuntimeError`. It was rather 
+complex: it had many variants that you had to handle when pattern matching results. This has been made way simpler with 
+Wasmer 1.0.0:
+
+```diff
+// Retrieve the `get` function from module's exports and then call it
+let result = get.call(0, 13);
+
+match result {
+-     Err(RuntimeError::InvokeError(InvokeError::TrapCode { .. })) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InvokeError(InvokeError::FailedWithNoError)) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InvokeError(InvokeError::UnknownTrap { .. })) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InvokeError(InvokeError::UnknownTrapCode { .. })) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InvokeError(InvokeError::EarlyTrap(_))) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InvokeError(InvokeError::Breakpoint(_))) => {
+-         // ...
+-     }
+-     Err(RuntimeError::Metering(_)) => {
+-         // ...
+-     }
+-     Err(RuntimeError::InstanceImage(_)) => {
+-         // ...
+-     }
+-     Err(RuntimeError::User(_)) => {
+-         // ...
+-     }
++     Error(e) => {
++         println!("Error caught from `div_by_zero`: {}", e.message());
++          
++         let frames = e.trace();
++         let frames_len = frames.len();
++         
++         // ...
++     }
+    Ok(_) => {
+        // ...
+    },
+}
+``` 
+
+As you can see here, handling errors is really easy now! You may find the following examples useful to get more familiar
+with this topic:
+* [Handling Errors][errors]
+* [Interrupting Execution][exit-early]
+
+Note that with Wasmer 1.0.0, each function that is part of the API has its own kind of error. For example:
+* Instantiating a module may return `InstantiationError`s;
+* Getting exports from the guest module may return `ExportError`s;
+* Calling an exported function may return `RuntimeError`s;
+* ...
+
+### Caching modules
+
+You may be aware Wasmer, since 0.x, allows you to cache compiled module so that further executions of your program
+will be faster.
+
+Because caching may bring a significant boost when running Wasm modules we wanted to make it easier to use with 
+Wasmer 1.0.0.
+
+With Wasmer 0.x you had to handle the whole caching process inside your program's code. With Wasmer 1.0.0
+you'll be able to delegate most of the work to Wasmer:
+
+```diff
+- let artifact = module.cache().unwrap();
+- let bytes = artifact.serialize().unwrap();
+- 
+- let path = "module_cached.so";
+- fs::write(path, bytes).unwrap();
++ module.serialize_to_file(path)?;
+
+- let mut file = File::open(path).unwrap();
+- let cached_bytes = &mut vec![];
+- file.read_to_end(cached_bytes);
+- drop(file);
+- 
+- let cached_artifact = Artifact::deserialize(&cached_bytes).unwrap();
+- let cached_module = unsafe { load_cache_with(cached_artifact, &default_compiler()) }.unwrap();
++ let cached_module = unsafe { Module::deserialize_from_file(&store, path) }?;
+``` 
+
+[examples]: https://docs.wasmer.io/integrations/examples
+[wasmer]: https://crates.io/crates/wasmer
+[wasmer-wasi]: https://crates.io/crates/wasmer-wasi
+[wasmer-emscripten]: https://crates.io/crates/wasmer-emscripten
+[wasmer-engine]: https://crates.io/crates/wasmer-engine
+[wasmer-compiler]: https://crates.io/crates/wasmer-compiler
+[wasmer.io]: https://wasmer.io
+[wasmer-nightly]: https://github.com/wasmerio/wasmer-nightly/
+[getting-started]: https://docs.wasmer.io/ecosystem/wasmer/getting-started
+[instance-example]: https://docs.wasmer.io/integrations/examples/instance
+[imports-exports-example]: https://docs.wasmer.io/integrations/examples/imports-and-exports
+[host-functions-example]: https://docs.wasmer.io/integrations/examples/host-functions
+[memory]: https://docs.wasmer.io/integrations/examples/memory
+[memory-pointers]: https://docs.wasmer.io/integrations/examples/memory-pointers
+[host-functions]: https://docs.wasmer.io/integrations/examples/host-functions
+[errors]: https://docs.wasmer.io/integrations/examples/errors
+[exit-early]: https://docs.wasmer.io/integrations/examples/exit-early
diff --git a/arbitrator/tools/module_roots/wasmer/docs/migration_to_3.0.0.md b/arbitrator/tools/module_roots/wasmer/docs/migration_to_3.0.0.md
new file mode 100644
index 0000000..91582cf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/docs/migration_to_3.0.0.md
@@ -0,0 +1,312 @@
+# Migrating from Wasmer 2.x to Wasmer 3.0.0
+
+This document will describe the differences between Wasmer 2.x and Wasmer 3.0.0
+and provide examples to make migrating to the new API as simple as possible.
+
+## Table of Contents
+
+- [Rationale for changes in 3.0.0](#rationale-for-changes-in-300)
+- [How to use Wasmer 3.0.0](#how-to-use-wasmer-300)
+  - [Installing Wasmer CLI](#installing-wamser-cli)
+  - [Using Wasmer 3.0.0](#using-wamser-300)
+- [Project structure](#project-structure)
+- [Differences](#differences)
+  - [Managing imports](#managing-imports)
+  - [Engines](#engines)
+  - [C-API changes](#c-api)
+
+## Rationale for changes in 3.0.0
+
+This version introduces the following changes to make the Wasmer API more ergonomic and safe:
+
+1. `ImportsObject` and the traits `Resolver`, `NamedResolver`, etc have been removed and replaced with a single simple type `Imports`. This reduces the complexity of setting up an `Instance`. The helper macro `imports!` can still be used.
+2. The `Store` will keep track of all memory and functions used, removing old tracking and Weak/Strong pointer usage. Every function and memory that can be defined is associated to a specific `Store`, and cannot be mixed with another `Store`
+3. `NativeFunc` has been renamed to `TypedFunction`, accordingly the following functions have been renamed:
+   * `Function::native(…)` → `Function::typed(…)`
+   * `Function::new_native(…)` → `Function::new_typed(…)`
+   * `Function::new_native_with_env(…)` → `Function::new_typed_with_env(…)`
+   The previous variants still exist in order to support the migration, but they have been deprecated.
+4. `WasmerEnv` and associated traits and macro have been removed. To use a function environment, you will need to create a `FunctionEnv` object and pass it along when you construct the function. For convenience, these functions also exist in a variant without the environment for simpler use cases that don't need it. For the variants with the environment, it can be retrieved from the first argument of the function. Because the `WasmerEnv` and all helpers don't exists anymore, you have to import memory yourself, there isn't any per instance initialisation automatically done anymore. It's especially important in wasi use with `WasiEnv`. `Env` can be accessed from a `FunctionEnvMut<'_, WasiEnv>` using `FunctionEnvMut::data()` or `FunctionEnvMut::data_mut()`.
+5. The `Engine`s API has been simplified, Instead of the user choosing and setting up an engine explicitly, everything now uses a single engine. All functionalities of the `universal`, `staticlib` and `dylib` engines should be available in this new engine unless explicitly stated as unsupported.
+6. Loupe has been removed. Memory inspection should be done manually
+
+## How to use Wasmer 3.0.0
+
+### Installing Wasmer CLI
+
+See [wasmer.io] for installation instructions.
+
+If you already have wasmer installed, run `wasmer self-update`.
+
+Install the latest versions of Wasmer with [wasmer-nightly] or by following the
+steps described in the documentation: [Getting Started][getting-started].
+
+### Using Wasmer 3.0.0
+
+One of the main changes in 3.0.0 is that `Store` now owns all WebAssembly objects; thus exports like a `Memory` are merely handles to the actual memory object inside the store. To read/write any such value you will always need a `Store` reference.
+
+If you define your own function, when the function is called it will hence need a reference to the store in order to access WebAssembly objects. This is achieved by the `StoreRef<'_>` and `StoreMut<'_>` types, which borrow from the store and provide access to its data. Furthermore, to prevent borrowing issues you can create new `StoreRef` and `StoreMut`s whenever you need to pass one at another function. This is done with the `AsStoreRef`, `AsStoreMut` traits.
+
+See the [examples] to find out how to do specific things in Wasmer 3.0.0.
+
+## Project Structure
+
+A lot of types were moved to `wasmer-types` crate. There are no `engine` crates anymore; all the logic is included in `wasmer-compiler`.
+
+## Differences
+
+### `WasmerEnv` is removed in favor of `FunctionEnv`
+
+`WasmerEnv` has been removed in Wasmer 3.0 in favor of `FunctionEnv`, which is now shareable automatically between functions without requiring the environment to be clonable.
+
+```rust
+let my_counter = 0_i32;
+let env = FunctionEnv::new(&mut store, my_counter);
+```
+
+Note: Any type can be passed as the environment: (*Nota bene* the passed type `T` must implement the `Any` trait, that is, any type which contains a non-`'static` reference.)
+
+```rust
+struct Env {
+    counter: i32,
+}
+let env = FunctionEnv::new(&mut store, Env {counter: 0});
+```
+
+Here's how the code depending on `WasmerEnv` should evolve:
+
+#### Before
+
+```rust
+#[derive(wasmer::WasmerEnv, Clone)]
+pub struct MyEnv {
+    #[wasmer(export)]
+    pub memory: wasmer::LazyInit<Memory>,
+    #[wasmer(export(name = "__alloc"))]
+    pub alloc_guest_memory: LazyInit<NativeFunc<u32, i32>>,
+
+    pub multiply_by: u32,
+}
+
+let my_env = MyEnv {
+  memory: Default::default(),
+  alloc_guest_memory: Default::default(),
+  multiply_by: 10,
+};
+
+let instance = Instance::new(&module, &imports);
+```
+
+#### After
+
+```rust
+pub struct MyEnv {
+    pub memory: Option<Memory>,
+    pub alloc_guest_memory: Option<TypedFunction<i32, i32>>,
+    pub multiply_by: u32,
+}
+
+let env = FunctionEnv::new(&mut store, MyEnv {
+  memory: None,
+  alloc_guest_memory: None,
+  multiply_by: 10,
+});
+
+let instance = Instance::new(&mut store, &module, &imports)?;
+let mut env_mut = env.into_mut(&mut store); // change to a FunctionEnvMut
+let (mut data_mut, mut store_mut) = env_mut.data_and_store_mut(); // grab data and a new store_mut
+data_mut.memory = Some(instance.exports.get_memory("memory")?.clone());
+data_mut.alloc_guest_memory = Some(instance.exports.get_typed_function(&mut store_mut, "__alloc")?);
+```
+
+### New `MemoryView` API (preparation for shared memory)
+
+Reading from memory has slightly changed compared to 2.x:
+
+```rust
+// 2.x
+let memory = instance.exports.get_memory("mem")?;
+println!("Memory size (pages) {:?}", memory.size());
+println!("Memory size (bytes) {:?}", memory.data_size());
+
+let load = instance
+    .exports
+    .get_native_function::<(), (WasmPtr<u8, Array>, i32)>("load")?;
+
+let (ptr, length) = load.call(&mut store)?;
+let str = ptr.get_utf8_string(memory, length as u32).unwrap();
+println!("Memory contents: {:?}", str);
+```
+
+```rust
+// 3.x
+let memory = instance.exports.get_memory("mem")?;
+let memory_view = memory.view(&store);
+println!("Memory size (pages) {:?}", memory_view.size());
+println!("Memory size (bytes) {:?}", memory_view.data_size());
+
+let load: TypedFunction<(), (WasmPtr<u8>, i32)> =
+    instance.exports.get_typed_function(&mut store, "load")?;
+
+let (ptr, length) = load.call(&mut store)?;
+let memory_view = memory.view(&store);
+let str = ptr.read_utf8_string(&memory_view, length as u32).unwrap();
+println!("Memory contents: {:?}", str);
+```
+
+The reason for this change is that in the future this will enable
+safely sharing memory across threads. The same thing goes for reading slices:
+
+```rust
+// 2.x
+let new_str = b"Hello, Wasmer!";
+let values = ptr.deref(memory, 0, new_str.len() as u32).unwrap();
+for i in 0..new_str.len() {
+    values[i].set(new_str[i]);
+}
+```
+
+```rust
+// 3.x
+let memory_view = memory.view(&store); // (can be reused)
+let new_str = b"Hello, Wasmer!";
+let values = ptr.slice(&memory_view, new_str.len() as u32).unwrap();
+for i in 0..new_str.len() {
+    values.index(i as u64).write(new_str[i]).unwrap();
+}
+```
+
+### Managing imports
+
+Instantiating a Wasm module is similar to 2.x;
+
+```rust
+let import_object: Imports = imports! {
+    "env" => {
+        "host_function" => host_function,
+    },
+};
+let instance = Instance::new(&mut store, &module, &import_object).expect("Could not instantiate module.");
+```
+
+You can also build the `Imports` object manually:
+
+```rust
+let mut import_object: Imports = Imports::new();
+import_object.define("env", "host_function", host_function);
+let instance = Instance::new(&mut store, &module, &import_object).expect("Could not instantiate module.");
+```
+
+For WASI, don't forget to initialize the `WasiEnv` (it will import the memory)
+
+```rust
+let mut wasi_env = WasiState::builder("hello").finalize()?;
+let import_object = wasi_env.import_object(&mut store, &module)?;
+let instance = Instance::new(&mut store, &module, &import_object).expect("Could not instantiate module.");
+wasi_env.initialize(&mut store, &instance).unwrap();
+```
+
+#### `ChainableNamedResolver` is removed
+
+Chaining imports with a trait has been deemed too complex for what it does; it's possible to chain (i.e. override) an `Imports`' contents by using its implementation of `std::iter::Extend`  from the Rust standard library:
+
+```rust
+let imports1: Imports = todo!();
+let mut imports2: Imports = todo!();
+
+imports2.extend(&imports);
+// This is equivalent to the following:
+// for ((ns, name), ext) in imports1.into_iter() {
+//     imports2.define(&ns &name, ext);
+// }
+```
+
+### Engines
+
+#### Before
+
+In Wasmer 2.0, you had to explicitly define the Engine you want to use:
+
+```rust
+let wasm_bytes = wat2wasm(
+    "..".as_bytes(),
+)?;
+
+let compiler_config = Cranelift::default();
+let engine = Universal::new(compiler_config).engine();
+let mut store = Store::new(&engine);
+let module = Module::new(&store, wasm_bytes)?;
+let instance = Instance::new(&module, &imports! {})?;
+```
+
+#### After
+
+In Wasmer 3.0, there's only one engine. The user can ignore the engine details when using the API:
+
+```rust
+let wasm_bytes = wat2wasm(
+    "..".as_bytes(),
+)?;
+
+let compiler = Cranelift::default();
+let mut store = Store::new(compiler);
+let module = Module::new(&store, wasm_bytes)?;
+let instance = Instance::new(&mut store, &module, &imports! {})?;
+```
+
+#### Advanced configuration
+
+The previous ability to define target and features remains in a new `EngineBuilder` interface:
+
+```rust
+let compiler = Cranelift::default();
+
+let mut features = Features::new();
+// Enable the multi-value feature.
+features.multi_value(true);
+
+let engine = EngineBuilder::new(compiler).set_features(Some(features));
+let store = Store::new(engine);
+```
+
+### C-API
+
+The WASM C-API hasn't changed. Some wasmer-specific functions have changed, that relate to setting up WASI environments.
+
+- `wasi_env_new` function changed input parameters to accommodate the new Store API, it now is:
+  ```C
+  struct wasi_env_t *wasi_env_new(wasm_store_t *store, struct wasi_config_t *config);
+  ```
+- `wasi_get_imports` function changed input parameters to accommodate the new Store API, it now is:
+  ```c
+  bool wasi_get_imports(const wasm_store_t *_store,
+                        struct wasi_env_t *wasi_env,
+                        const wasm_module_t *module,
+                        wasm_extern_vec_t *imports);
+  ```
+- `wasi_env_set_memory` was added. It's necessary to set the `WasiEnv` memory by getting it from `Instance`s memory exports after its initialization. This must be performed in a specific order:
+  1. Create WasiEnv
+  2. Create Instance
+  3. Get Instance Exports
+  4. Find Memory from Instance Exports and store it to WasiEnv
+  The function's signature is:
+  ```c
+  void wasi_env_set_memory(struct wasi_env_t *env, const wasm_memory_t *memory);
+  ```
+
+[examples]: https://docs.wasmer.io/integrations/examples
+[wasmer]: https://crates.io/crates/wasmer
+[wasmer-wasi]: https://crates.io/crates/wasmer-wasi
+[wasmer-emscripten]: https://crates.io/crates/wasmer-emscripten
+[wasmer-compiler]: https://crates.io/crates/wasmer-compiler
+[wasmer.io]: https://wasmer.io
+[wasmer-nightly]: https://github.com/wasmerio/wasmer-nightly/
+[getting-started]: https://docs.wasmer.io/ecosystem/wasmer/getting-started
+[instance-example]: https://docs.wasmer.io/integrations/examples/instance
+[imports-exports-example]: https://docs.wasmer.io/integrations/examples/imports-and-exports
+[host-functions-example]: https://docs.wasmer.io/integrations/examples/host-functions
+[memory]: https://docs.wasmer.io/integrations/examples/memory
+[memory-pointers]: https://docs.wasmer.io/integrations/examples/memory-pointers
+[host-functions]: https://docs.wasmer.io/integrations/examples/host-functions
+[errors]: https://docs.wasmer.io/integrations/examples/errors
+[exit-early]: https://docs.wasmer.io/integrations/examples/exit-early
diff --git a/arbitrator/tools/module_roots/wasmer/examples/README.md b/arbitrator/tools/module_roots/wasmer/examples/README.md
new file mode 100644
index 0000000..8502a7d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/README.md
@@ -0,0 +1,385 @@
+# Wasmer Examples
+
+This directory contains a collection of examples. This isn't an
+exhaustive collection though, if one example is missing, please ask,
+we will be happy to fulfill your needs!
+
+## Handy Diagrams
+
+As a quick introduction to Wasmer's main workflows, here are three
+diagrams. We hope it provides an overview of how the crates assemble
+together.
+
+1. **Module compilation**, illustrates how WebAssembly bytes are
+   validated, parsed, and compiled, with the help of the
+   `wasmer::Module`, `wasmer_engine::Engine`, and
+   `wasmer_compiler::Compiler` API.
+
+   ![Module compilation](../assets/diagrams/Diagram_module_compilation.png)
+
+2. **Module serialization**, illustrates how a module can be
+   serialized and deserialized, with the help of
+   `wasmer::Module::serialize` and `wasmer::Module::deserialize`. The
+   important part is that the engine can changed between those two
+   steps, and thus how a headless engine can be used for the
+   deserialization.
+
+   ![Module serialization](../assets/diagrams/Diagram_module_serialization.png)
+
+3. **Module instantiation**, illustrates what happens when
+   `wasmer::Instance::new` is called.
+
+   ![Module instantiation](../assets/diagrams/Diagram_module_instantiation.png)
+
+## Examples
+
+The examples are written in a difficulty/discovery order. Concepts that
+are explained in an example is not necessarily re-explained in a next
+example.
+
+### Basics
+
+1. [**Hello World**][hello-world], explains the core concepts of the Wasmer
+   API for compiling and executing WebAssembly.
+
+   _Keywords_: introduction, instance, module.
+
+   <details>
+    <summary><em>Execute the example</em></summary>
+
+    ```shell
+    $ cargo run --example hello-world --release --features "cranelift"
+    ```
+
+   </details>
+
+2. [**Instantiating a module**][instance], explains the basics of using Wasmer
+   and how to create an instance out of a Wasm module.
+   
+   _Keywords_: instance, module.
+   
+   <details>
+    <summary><em>Execute the example</em></summary>
+
+    ```shell
+    $ cargo run --example instance --release --features "cranelift"
+    ```
+
+   </details>
+
+3. [**Handling errors**][errors], explains the basics of interacting with
+   Wasm module memory.
+   
+   _Keywords_: instance, error.
+   
+   <details>
+    <summary><em>Execute the example</em></summary>
+
+    ```shell
+    $ cargo run --example errors --release --features "cranelift"
+    ```
+
+   </details>
+
+4. [**Interacting with memory**][memory], explains the basics of interacting with
+   Wasm module memory.
+   
+   _Keywords_: memory, module.
+   
+   <details>
+    <summary><em>Execute the example</em></summary>
+
+    ```shell
+    $ cargo run --example memory --release --features "cranelift"
+    ```
+
+   </details>
+
+### Exports
+
+1. [**Exported global**][exported-global], explains how to work with
+   exported globals: get/set their value, have information about their 
+   type.
+   
+   _Keywords_: export, global.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example exported-global --release --features "cranelift"
+   ```
+
+   </details>
+   
+2. [**Exported function**][exported-function], explains how to get and
+   how to call an exported function. They come in 2 flavors: dynamic,
+   and “static”/native. The pros and cons are discussed briefly.
+   
+   _Keywords_: export, function, dynamic, static, native.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example exported-function --release --features "cranelift"
+   ```
+
+   </details>
+
+
+3. [**Exported memory**][exported-memory], explains how to read from 
+    and write to exported memory.
+   
+   _Keywords_: export, memory.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example exported-memory --release --features "cranelift"
+   ```
+
+   </details>
+
+### Imports
+
+1. [**Imported global**][imported-global], explains how to work with
+   imported globals: create globals, import them, get/set their value.
+   
+   _Keywords_: import, global.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example imported-global --release --features "cranelift"
+   ```
+
+   </details>
+
+2. [**Imported function**][imported-function], explains how to define 
+   an imported function. They come in 2 flavors: dynamic,
+   and “static”/native.
+   
+   _Keywords_: import, function, dynamic, static, native.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example imported-function --release --features "cranelift"
+   ```
+
+   </details>
+
+### Externs
+
+1. [**Table**][table], explains how to use Wasm Tables from the Wasmer API.
+
+   _Keywords_: basic, table, call_indirect
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example table --release --features "cranelift"
+   ```
+
+   </details>
+   
+2. [**Memory**][memory], explains how to use Wasm Memories from
+   the Wasmer API.  Memory example is a work in progress.
+
+   _Keywords_: basic, memory
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example memory --release --features "cranelift"
+   ```
+
+   </details>
+
+### Tunables
+
+1. [**Limit memory**][tunables-limit-memory], explains how to use Tunables to limit the
+   size of an exported Wasm memory
+
+   _Keywords_: basic, tunables, memory
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example tunables-limit-memory --release --features "cranelift"
+   ```
+
+   </details>
+
+### Engines
+
+1. [**Engine**][engine], explains what an engine is and how to set it up. The
+   example completes itself with the compilation of the Wasm module, its
+   instantiation, and finally, by calling an exported function.
+   
+   _Keywords_: engine, in-memory, executable code.
+   
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example engine --release --features "cranelift"
+   ```
+
+   </details>
+
+2. [**Headless engines**][engine-headless], explains what a headless
+   engine is, what problem it does solve, and what are the benefits of
+   it. The example completes itself with the instantiation of a
+   pre-compiled Wasm module, and finally, by calling an exported
+   function.
+   
+   _Keywords_: native, engine, constrained environment, ahead-of-time
+   compilation, cross-compilation, executable code, serialization.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example engine-headless --release --features "cranelift"
+   ```
+
+   </details>
+
+4. [**Cross-compilation**][cross-compilation], illustrates the power
+   of the abstraction over the engines and the compilers, such as it
+   is possible to cross-compile a Wasm module for a custom target.
+   
+   _Keywords_: engine, compiler, cross-compilation.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example cross-compilation --release --features "cranelift"
+   ```
+
+   </details>
+   
+5. [**Features**][features], illustrates how to enable WebAssembly
+   features that aren't yet stable.
+   
+   _Keywords_: engine, features.
+   
+   <details>
+   <summary><em>Execute the example</em></summary>
+   
+   ```shell
+   $ cargo run --example features --release --features "cranelift"
+   ```
+   
+   </details>
+
+### Compilers
+
+1. [**Singlepass compiler**][compiler-singlepass], explains how to use
+   the [`wasmer-compiler-singlepass`] compiler.
+   
+   _Keywords_: compiler, singlepass.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example compiler-singlepass --release --features "singlepass"
+   ```
+
+   </details>
+
+2. [**Cranelift compiler**][compiler-cranelift], explains how to use
+   the [`wasmer-compiler-cranelift`] compiler.
+   
+   _Keywords_: compiler, cranelift.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example compiler-cranelift --release --features "cranelift"
+   ```
+
+   </details>
+
+3. [**LLVM compiler**][compiler-llvm], explains how to use the
+   [`wasmer-compiler-llvm`] compiler.
+   
+   _Keywords_: compiler, llvm.
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example compiler-llvm --release --features "llvm"
+   ```
+
+   </details>
+
+### Integrations
+
+1. [**WASI**][wasi], explains how to use the [WebAssembly System
+   Interface][WASI] (WASI), i.e. the [`wasmer-wasi`] crate.
+   
+   _Keywords_: wasi, system, interface
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example wasi --release --features "cranelift,wasi"
+   ```
+
+   </details>
+
+2. [**WASI Pipes**][wasi-pipes], builds on the WASI example to show off
+   stdio piping in Wasmer.
+
+   _Keywords_: wasi, system, interface
+
+   <details>
+   <summary><em>Execute the example</em></summary>
+
+   ```shell
+   $ cargo run --example wasi-pipes --release --features "cranelift,wasi"
+   ```
+
+   </details>
+
+[hello-world]: ./hello_world.rs
+[engine]: ./engine.rs
+[engine-headless]: ./engine_headless.rs
+[compiler-singlepass]: ./compiler_singlepass.rs
+[compiler-cranelift]: ./compiler_cranelift.rs
+[compiler-llvm]: ./compiler_llvm.rs
+[cross-compilation]: ./engine_cross_compilation.rs
+[exported-global]: ./exports_global.rs
+[exported-function]: ./exports_function.rs
+[exported-memory]: ./exports_memory.rs
+[imported-global]: ./imports_global.rs
+[imported-function]: ./imports_function.rs
+[imported-function-env]: ./imports_function_env.rs
+[imported-function-env-global]: ./imports_function_env_global.rs
+[instance]: ./instance.rs
+[wasi]: ./wasi.rs
+[wasi-pipes]: ./wasi_pipes.rs
+[table]: ./table.rs
+[memory]: ./memory.rs
+[errors]: ./errors.rs
+[tunables-limit-memory]: ./tunables_limit_memory.rs
+[features]: ./features.rs
+[`wasmer-compiler-singlepass`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass
+[`wasmer-compiler-cranelift`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-cranelift
+[`wasmer-compiler-llvm`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm
+[`wasmer-wasi`]: https://github.com/wasmerio/wasmer/tree/master/lib/wasi
+[WASI]: https://github.com/WebAssembly/WASI
diff --git a/arbitrator/tools/module_roots/wasmer/examples/compiler_cranelift.rs b/arbitrator/tools/module_roots/wasmer/examples/compiler_cranelift.rs
new file mode 100644
index 0000000..cb8b8f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/compiler_cranelift.rs
@@ -0,0 +1,65 @@
+//! A Wasm module can be compiled with multiple compilers.
+//!
+//! This example illustrates how to use the Cranelift compiler.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example compiler-cranelift --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer_compiler_cranelift::Cranelift;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Use Cranelift compiler with the default settings
+    let compiler = Cranelift::default();
+
+    // Create the store
+    let mut store = Store::new(compiler);
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let sum = instance.exports.get_function("sum")?;
+
+    println!("Calling `sum` function...");
+    // Let's call the `sum` exported function. The parameters are a
+    // slice of `Value`s. The results are a boxed slice of `Value`s.
+    let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
+
+    println!("Results: {:?}", results);
+    assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "cranelift")]
+fn test_compiler_cranelift() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/compiler_llvm.rs b/arbitrator/tools/module_roots/wasmer/examples/compiler_llvm.rs
new file mode 100644
index 0000000..2622227
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/compiler_llvm.rs
@@ -0,0 +1,65 @@
+//! A Wasm module can be compiled with multiple compilers.
+//!
+//! This example illustrates how to use the LLVM compiler.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example compiler-llvm --release --features "llvm"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer_compiler_llvm::LLVM;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Use LLVM compiler with the default settings
+    let compiler = LLVM::default();
+
+    // Create the store
+    let mut store = Store::new(compiler);
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let sum = instance.exports.get_function("sum")?;
+
+    println!("Calling `sum` function...");
+    // Let's call the `sum` exported function. The parameters are a
+    // slice of `Value`s. The results are a boxed slice of `Value`s.
+    let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
+
+    println!("Results: {:?}", results);
+    assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "llvm")]
+fn test_compiler_llvm() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/compiler_singlepass.rs b/arbitrator/tools/module_roots/wasmer/examples/compiler_singlepass.rs
new file mode 100644
index 0000000..01fb181
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/compiler_singlepass.rs
@@ -0,0 +1,65 @@
+//! A Wasm module can be compiled with multiple compilers.
+//!
+//! This example illustrates how to use the Singlepass compiler.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example compiler-singlepass --release --features "singlepass"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer_compiler_singlepass::Singlepass;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Use Singlepass compiler with the default settings
+    let compiler = Singlepass::default();
+
+    // Create the store
+    let mut store = Store::new(compiler);
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let sum = instance.exports.get_function("sum")?;
+
+    println!("Calling `sum` function...");
+    // Let's call the `sum` exported function. The parameters are a
+    // slice of `Value`s. The results are a boxed slice of `Value`s.
+    let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
+
+    println!("Results: {:?}", results);
+    assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "singlepass")]
+fn test_compiler_singlepass() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/early_exit.rs b/arbitrator/tools/module_roots/wasmer/examples/early_exit.rs
new file mode 100644
index 0000000..95d9a80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/early_exit.rs
@@ -0,0 +1,110 @@
+//! There are cases where you may want to interrupt this synchronous execution of the Wasm module
+//! while the it is calling a host function. This can be useful for saving resources, and not
+//! returning back to the guest Wasm for execution, when you already know the Wasm execution will
+//! fail, or no longer be needed.
+//!
+//! In this example, we will run a Wasm module that calls the imported host function
+//! interrupt_execution. This host function will immediately stop executing the WebAssembly module.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example early-exit --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use anyhow::bail;
+use std::fmt;
+use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, TypedFunction};
+
+// First we need to create an error type that we'll use to signal the end of execution.
+#[derive(Debug, Clone, Copy)]
+struct ExitCode(u32);
+
+// This type must implement `std::error::Error` so we must also implement `std::fmt::Display` for it.
+impl fmt::Display for ExitCode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+// And then we implement `std::error::Error`.
+impl std::error::Error for ExitCode {}
+
+fn main() -> anyhow::Result<()> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $run_t (func (param i32 i32) (result i32)))
+  (type $early_exit_t (func (param) (result)))
+  (import "env" "early_exit" (func $early_exit (type $early_exit_t)))
+  (func $run (type $run_t) (param $x i32) (param $y i32) (result i32)
+    (call $early_exit)
+    (i32.add
+        local.get $x
+        local.get $y))
+  (export "run" (func $run)))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // We declare the host function that we'll use to terminate execution.
+    fn early_exit() -> Result<(), ExitCode> {
+        // This is where it happens.
+        Err(ExitCode(1))
+    }
+
+    // Create an import object.
+    let import_object = imports! {
+        "env" => {
+            "early_exit" => Function::new_typed(&mut store, early_exit),
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // Get the `run` function which we'll use as our entrypoint.
+    println!("Calling `run` function...");
+    let run_func: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "run")?;
+
+    // When we call a function it can either succeed or fail. We expect it to fail.
+    match run_func.call(&mut store, 1, 7) {
+        Ok(result) => {
+            bail!(
+                "Expected early termination with `ExitCode`, found: {}",
+                result
+            );
+        }
+        // In case of a failure, which we expect, we attempt to downcast the error into the error
+        // type that we were expecting.
+        Err(e) => match e.downcast::<ExitCode>() {
+            // We found the exit code used to terminate execution.
+            Ok(exit_code) => {
+                println!("Exited early with exit code: {}", exit_code);
+
+                Ok(())
+            }
+            Err(e) => {
+                bail!("Unknown error `{}` found. expected `ErrorCode`", e);
+            }
+        },
+    }
+}
+
+#[test]
+fn test_early_exit() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/engine.rs b/arbitrator/tools/module_roots/wasmer/examples/engine.rs
new file mode 100644
index 0000000..1bb2001
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/engine.rs
@@ -0,0 +1,90 @@
+//! Defining an engine in Wasmer is one of the fundamental steps.
+//!
+//! This example illustrates how to use the `wasmer_compiler`,
+//! aka the Universal engine. An engine applies roughly 2 steps:
+//!
+//!   1. It compiles the Wasm module bytes to executable code, through
+//!      the intervention of a compiler,
+//!   2. It stores the executable code somewhere.
+//!
+//! In the particular context of the Universal engine, the executable
+//! code is stored in memory.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example engine-universal --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, Value};
+use wasmer_compiler_cranelift::Cranelift;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Define a compiler configuration.
+    //
+    // In this situation, the compiler is
+    // `wasmer_compiler_cranelift`. The compiler is responsible to
+    // compile the Wasm module into executable code.
+    let compiler_config = Cranelift::default();
+
+    println!("Creating Universal engine...");
+    // Define the engine that will drive everything.
+    //
+    // In this case, the engine is `wasmer_compiler` which roughly
+    // means that the executable code will live in memory.
+    let engine = EngineBuilder::new(compiler_config);
+
+    // Create a store, that holds the engine.
+    let mut store = Store::new(engine);
+
+    println!("Compiling module...");
+    // Here we go.
+    //
+    // Let's compile the Wasm module. It is at this step that the Wasm
+    // text is transformed into Wasm bytes (if necessary), and then
+    // compiled to executable code by the compiler, which is then
+    // stored in memory by the engine.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Congrats, the Wasm module is compiled! Now let's execute it for
+    // the sake of having a complete example.
+
+    // Create an import object. Since our Wasm module didn't declare
+    // any imports, it's an empty object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // And here we go again. Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    println!("Calling `sum` function...");
+    // The Wasm module exports a function called `sum`.
+    let sum = instance.exports.get_function("sum")?;
+    let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
+
+    println!("Results: {:?}", results);
+    assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+
+    Ok(())
+}
+
+#[test]
+fn test_engine_universal() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/engine_cross_compilation.rs b/arbitrator/tools/module_roots/wasmer/examples/engine_cross_compilation.rs
new file mode 100644
index 0000000..9021694
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/engine_cross_compilation.rs
@@ -0,0 +1,101 @@
+//! Defining an engine in Wasmer is one of the fundamental steps.
+//!
+//! As a reminder, an engine applies roughly 2 steps:
+//!
+//!   1. It compiles the Wasm module bytes to executable code, through
+//!      the intervention of a compiler,
+//!   2. It stores the executable code somewhere.
+//!
+//! This example focuses on the first step: the compiler. It
+//! illustrates how the abstraction over the compiler is so powerful
+//! that it is possible to cross-compile a Wasm module.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example cross-compilation --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use std::str::FromStr;
+use wasmer::{wat2wasm, EngineBuilder, Module, RuntimeError, Store};
+use wasmer_compiler_cranelift::Cranelift;
+use wasmer_types::{CpuFeature, Target, Triple};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#,
+    )?;
+
+    // Define a compiler configuration.
+    //
+    // In this situation, the compiler is
+    // `wasmer_compiler_cranelift`. The compiler is responsible to
+    // compile the Wasm module into executable code.
+    let compiler_config = Cranelift::default();
+
+    // Here we go.
+    //
+    // Let's define the target “triple”. Historically, such things had
+    // three fields, though additional fields have been added over
+    // time.
+    let triple = Triple::from_str("x86_64-linux-musl")
+        .map_err(|error| RuntimeError::new(error.to_string()))?;
+
+    // Here we go again.
+    //
+    // Let's define a CPU feature.
+    let mut cpu_feature = CpuFeature::set();
+    cpu_feature.insert(CpuFeature::from_str("sse2")?);
+
+    // Here we go finally.
+    //
+    // Let's build the target.
+    let target = Target::new(triple, cpu_feature);
+    println!("Chosen target: {:?}", target);
+
+    // Define the engine that will drive everything.
+    //
+    // That's where we specify the target for the compiler.
+    //
+    // Use the Universal engine.
+    let engine = EngineBuilder::new(compiler_config).set_target(Some(target));
+
+    // Create a store, that holds the engine.
+    let store = Store::new(engine);
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let _module = Module::new(&store, wasm_bytes)?;
+
+    println!("Module compiled successfully.");
+
+    // Congrats, the Wasm module is cross-compiled!
+    //
+    // What to do with that? It is possible to use an engine (probably
+    // a headless engine) to execute the cross-compiled Wasm module an
+    // the targeted platform.
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(any(
+    windows,
+    // We don't support yet crosscompilation in macOS with Apple Silicon
+    all(target_os = "macos", target_arch = "aarch64"),
+    target_env = "musl",
+)))]
+fn test_cross_compilation() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/engine_dylib.rs b/arbitrator/tools/module_roots/wasmer/examples/engine_dylib.rs
new file mode 100644
index 0000000..07fa3cd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/engine_dylib.rs
@@ -0,0 +1,96 @@
+//! Defining an engine in Wasmer is one of the fundamental steps.
+//!
+//! This example illustrates how to use the `wasmer_engine_dylib`,
+//! aka the Dylib engine. An engine applies roughly 2 steps:
+//!
+//!   1. It compiles the Wasm module bytes to executable code, through
+//!      the intervention of a compiler,
+//!   2. It stores the executable code somewhere.
+//!
+//! In the particular context of the Dylib engine, the executable code
+//! is stored in a shared object (`.dylib`, `.so` or `.dll` file).
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example engine-dylib --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, Value};
+use wasmer_compiler_cranelift::Cranelift;
+/*
+use wasmer_engine_dylib::Dylib;
+*/
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /*
+        // Let's declare the Wasm module with the text representation.
+        let wasm_bytes = wat2wasm(
+            r#"
+    (module
+      (type $sum_t (func (param i32 i32) (result i32)))
+      (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+        local.get $x
+        local.get $y
+        i32.add)
+      (export "sum" (func $sum_f)))
+    "#
+            .as_bytes(),
+        )?;
+
+        // Define a compiler configuration.
+        //
+        // In this situation, the compiler is
+        // `wasmer_compiler_cranelift`. The compiler is responsible to
+        // compile the Wasm module into executable code.
+        let compiler_config = Cranelift::default();
+
+        println!("Creating Dylib engine...");
+        // Define the engine that will drive everything.
+        //
+        // In this case, the engine is `wasmer_engine_dylib` which means
+        // that a shared object is going to be generated.
+        let engine = Dylib::new(compiler_config);
+
+        // Create a store, that holds the engine.
+        let mut store = Store::new(engine);
+
+        println!("Compiling module...");
+        // Here we go.
+        //
+        // Let's compile the Wasm module. It is at this step that the Wasm
+        // text is transformed into Wasm bytes (if necessary), and then
+        // compiled to executable code by the compiler, which is then
+        // stored into a shared object by the engine.
+        let module = Module::new(&store, wasm_bytes)?;
+
+        // Congrats, the Wasm module is compiled! Now let's execute it for
+        // the sake of having a complete example.
+
+        // Create an import object. Since our Wasm module didn't declare
+        // any imports, it's an empty object.
+        let import_object = imports! {};
+
+        println!("Instantiating module...");
+        // And here we go again. Let's instantiate the Wasm module.
+        let instance = Instance::new(&module, &import_object)?;
+
+        println!("Calling `sum` function...");
+        // The Wasm module exports a function called `sum`.
+        let sum = instance.exports.get_function("sum")?;
+        let results = sum.call(&[Value::I32(1), Value::I32(2)])?;
+
+        println!("Results: {:?}", results);
+        assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+        */
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(any(target_arch = "aarch64", target_env = "musl")))]
+fn test_engine_dylib() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/engine_headless.rs b/arbitrator/tools/module_roots/wasmer/examples/engine_headless.rs
new file mode 100644
index 0000000..c0cbf2b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/engine_headless.rs
@@ -0,0 +1,136 @@
+//! Defining an engine in Wasmer is one of the fundamental steps.
+//!
+//! This example illustrates a neat feature of engines: their ability
+//! to run in a headless mode. At the time of writing, all engines
+//! have a headless mode, but it's not a requirement of the `Engine`
+//! trait (defined in the `wasmer_engine` crate).
+//!
+//! What problem does it solve, and what does it mean?
+//!
+//! Once a Wasm module is compiled into executable code and stored
+//! somewhere (e.g. in memory with the Universal engine), the module
+//! can be instantiated and executed. But imagine for a second the
+//! following scenario:
+//!
+//!   * Modules are compiled ahead of time, to be instantiated later
+//!     on.
+//!   * Modules are cross-compiled on a machine ahead of time
+//!     to be run on another machine later one.
+//!
+//! In both scenarios, the environment where the compiled Wasm module
+//! will be executed can be very constrained. For such particular
+//! contexts, Wasmer can be compiled _without_ the compilers, so that
+//! the `wasmer` binary is as small as possible. Indeed, there is no
+//! need for a compiler since the Wasm module is already compiled. All
+//! we need is an engine that _only_ drives the instantiation and
+//! execution of the Wasm module.
+//!
+//! And that, that's a headless engine.
+//!
+//! To achieve such a scenario, a Wasm module must be compiled, then
+//! serialized —for example into a file—, then later, potentially on
+//! another machine, deserialized. The next steps are classical: The
+//! Wasm module is instantiated and executed.
+//!
+//! This example uses a `compiler` because it illustrates the entire
+//! workflow, but keep in mind the compiler isn't required after the
+//! compilation step.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example engine-headless --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use tempfile::NamedTempFile;
+use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, Value};
+use wasmer_compiler_cranelift::Cranelift;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // First step, let's compile the Wasm module and serialize it.
+    // Note: we need a compiler here.
+    let serialized_module_file = {
+        // Let's declare the Wasm module with the text representation.
+        let wasm_bytes = wat2wasm(
+            r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+            .as_bytes(),
+        )?;
+
+        // Define a compiler configuration.
+        //
+        // In this situation, the compiler is
+        // `wasmer_compiler_cranelift`. The compiler is responsible to
+        // compile the Wasm module into executable code.
+        let compiler = Cranelift::default();
+
+        // Create a store, that holds the engine.
+        let store = Store::new(compiler);
+
+        println!("Compiling module...");
+        // Let's compile the Wasm module.
+        let module = Module::new(&store, wasm_bytes)?;
+
+        println!("Serializing module...");
+        // Here we go. Let's serialize the compiled Wasm module in a
+        // file.
+        let serialized_module_file = NamedTempFile::new()?;
+        module.serialize_to_file(&serialized_module_file)?;
+
+        serialized_module_file
+    };
+
+    // Second step, deserialize the compiled Wasm module, and execute
+    // it, for example with Wasmer without a compiler.
+    {
+        println!("Creating headless Universal engine...");
+        // We create a headless Universal engine.
+        let engine = EngineBuilder::headless();
+        let mut store = Store::new(engine);
+
+        println!("Deserializing module...");
+        // Here we go.
+        //
+        // Deserialize the compiled Wasm module. This code is unsafe
+        // because Wasmer can't assert the bytes are valid (see the
+        // `wasmer::Module::deserialize`'s documentation to learn
+        // more).
+        let module = unsafe { Module::deserialize_from_file(&store, serialized_module_file) }?;
+
+        // Congrats, the Wasm module has been deserialized! Now let's
+        // execute it for the sake of having a complete example.
+
+        // Create an import object. Since our Wasm module didn't declare
+        // any imports, it's an empty object.
+        let import_object = imports! {};
+
+        println!("Instantiating module...");
+        // Let's instantiate the Wasm module.
+        let instance = Instance::new(&mut store, &module, &import_object)?;
+
+        println!("Calling `sum` function...");
+        // The Wasm module exports a function called `sum`.
+        let sum = instance.exports.get_function("sum")?;
+        let results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)])?;
+
+        println!("Results: {:?}", results);
+        assert_eq!(results.to_vec(), vec![Value::I32(3)]);
+    }
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(any(windows, target_arch = "aarch64", target_env = "musl")))]
+fn test_engine_headless() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/errors.rs b/arbitrator/tools/module_roots/wasmer/examples/errors.rs
new file mode 100644
index 0000000..c034c40
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/errors.rs
@@ -0,0 +1,101 @@
+//! A Wasm module can sometimes be invalid or trigger traps, and in those case we will get
+//! an error back from the API.
+//!
+//! In this example we'll see how to handle such errors in the most
+//! basic way. To do that we'll use a Wasm module that we know will
+//! produce an error.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example errors --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $do_div_by_zero_t (func (result i32)))
+  (func $do_div_by_zero_f (type $do_div_by_zero_t) (result i32)
+    i32.const 4
+    i32.const 0
+    i32.div_s)
+
+  (type $div_by_zero_t (func (result i32)))
+  (func $div_by_zero_f (type $div_by_zero_t) (result i32)
+    call $do_div_by_zero_f)
+  (export "div_by_zero" (func $div_by_zero_f)))
+"#,
+    )?;
+
+    // Create a Store.
+    // Note that we don't need to specify the engine/compiler if we want to use
+    // the default provided by Wasmer.
+    // You can use `Store::default()` for that.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a function called `div_by_zero`. As its name
+    // implies, this function will try to do a division by zero and thus
+    // produce an error.
+    //
+    // Let's get it.
+    let div_by_zero: TypedFunction<(), i32> = instance
+        .exports
+        .get_function("div_by_zero")?
+        .typed(&mut store)?;
+
+    println!("Calling `div_by_zero` function...");
+    // Let's call the `div_by_zero` exported function.
+    let result = div_by_zero.call(&mut store);
+
+    // When we call a function it can either succeed or fail. We expect it to fail.
+    match result {
+        Ok(_) => {
+            // This should have thrown an error, return an error
+            panic!("div_by_zero did not error");
+        }
+        Err(e) => {
+            // Log the error
+            println!("Error caught from `div_by_zero`: {}", e.message());
+
+            // Errors come with a trace we can inspect to get more
+            // information on the execution flow.
+            let frames = e.trace();
+            let frames_len = frames.len();
+
+            for i in 0..frames_len {
+                println!(
+                    "  Frame #{}: {:?}::{:?}",
+                    frames_len - i,
+                    frames[i].module_name(),
+                    frames[i].function_name().or(Some("<func>")).unwrap()
+                );
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_function() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/exports_function.rs b/arbitrator/tools/module_roots/wasmer/examples/exports_function.rs
new file mode 100644
index 0000000..e984322
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/exports_function.rs
@@ -0,0 +1,107 @@
+//! A Wasm module can export entities, like functions, memories,
+//! globals and tables.
+//!
+//! This example illustrates how to use exported functions. They come
+//! in 2 flavors:
+//!
+//!   1. Dynamic functions, where parameters and results are of a
+//!      slice of `Value`,
+//!   2. Native function, where parameters and results are statically
+//!      typed Rust values.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example exported-function --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction, Value};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a function called `sum`. Let's get
+    // it. Note that
+    //
+    //     ```
+    //     get_function(name)
+    //     ```
+    //
+    // is just an alias to
+    //
+    //     ```
+    //     get::<Function>(name)`.
+    //     ```
+    let sum = instance.exports.get_function("sum")?;
+
+    println!("Calling `sum` function...");
+    // Let's call the `sum` exported function. The parameters are a
+    // slice of `Value`s. The results are a boxed slice of `Value`s.
+    let args = [Value::I32(1), Value::I32(2)];
+    let result = sum.call(&mut store, &args)?;
+
+    println!("Results: {:?}", result);
+    assert_eq!(result.to_vec(), vec![Value::I32(3)]);
+
+    // That was fun. But what if we can get rid of the `Value`s? Well,
+    // that's possible with the `TypedFunction` API. The function
+    // will use native Rust values.
+    //
+    // Note that `typed` takes 2 generic parameters: `Args` and
+    // `Rets`, respectively for the parameters and the results. If
+    // those values don't match the exported function signature, an
+    // error will be raised.
+    let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&mut store)?;
+
+    println!("Calling `sum` function (natively)...");
+    // Let's call the `sum` exported function. The parameters are
+    // statically typed Rust values of type `i32` and `i32`. The
+    // result, in this case particular case, in a unit of type `i32`.
+    let result = sum_typed.call(&mut store, 3, 4)?;
+
+    println!("Results: {:?}", result);
+    assert_eq!(result, 7);
+
+    // Much nicer, isn't it?
+    //
+    // Those two API exist because they address different needs. The
+    // former has a more dynamic approach, while the second has a more
+    // static approach.
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_function() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/exports_global.rs b/arbitrator/tools/module_roots/wasmer/examples/exports_global.rs
new file mode 100644
index 0000000..cdb8455
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/exports_global.rs
@@ -0,0 +1,140 @@
+//! A Wasm module can export entities, like functions, memories,
+//! globals and tables.
+//!
+//! This example illustrates how to use exported globals. They come
+//! in 2 flavors:
+//!
+//!   1. Immutable globals (const),
+//!   2. Mutable globals.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example exported-global --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Mutability, Store, Type, TypedFunction, Value};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (global $one (export "one") f32 (f32.const 1))
+  (global $some (export "some") (mut f32) (f32.const 0))
+
+  (func (export "get_one") (result f32) (global.get $one))
+  (func (export "get_some") (result f32) (global.get $some))
+
+  (func (export "set_some") (param f32) (global.set $some (local.get 0))))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports some globals. Let's get them.
+    // Note that
+    //
+    //     ```
+    //     get_global(name)
+    //     ```
+    //
+    // is just an alias to
+    //
+    //     ```
+    //     get::<Global>(name)`.
+    //     ```
+    let one = instance.exports.get_global("one")?;
+    let some = instance.exports.get_global("some")?;
+
+    println!("Getting globals types information...");
+    // Let's get the globals types. The results are `GlobalType`s.
+    let one_type = one.ty(&store);
+    let some_type = some.ty(&store);
+
+    println!("`one` type: {:?} {:?}", one_type.mutability, one_type.ty);
+    assert_eq!(one_type.mutability, Mutability::Const);
+    assert_eq!(one_type.ty, Type::F32);
+
+    println!("`some` type: {:?} {:?}", some_type.mutability, some_type.ty);
+    assert_eq!(some_type.mutability, Mutability::Var);
+    assert_eq!(some_type.ty, Type::F32);
+
+    println!("Getting global values...");
+    // Getting the values of globals can be done in two ways:
+    //   1. Through an exported function,
+    //   2. Using the Global API directly.
+    //
+    // We will use an exported function for the `one` global
+    // and the Global API for `some`.
+    let get_one: TypedFunction<(), f32> = instance
+        .exports
+        .get_function("get_one")?
+        .typed(&mut store)?;
+
+    let one_value = get_one.call(&mut store)?;
+    let some_value = some.get(&mut store);
+
+    println!("`one` value: {:?}", one_value);
+    assert_eq!(one_value, 1.0);
+
+    println!("`some` value: {:?}", some_value);
+    assert_eq!(some_value, Value::F32(0.0));
+
+    println!("Setting global values...");
+    // Trying to set the value of a immutable global (`const`)
+    // will result in a `RuntimeError`.
+    let result = one.set(&mut store, Value::F32(42.0));
+    // The global is immutable
+    assert!(result.is_err());
+    // assert_eq!(
+    //     result.expect_err("Expected an error").message(),
+    //     "Attempted to set an immutable global"
+    // );
+
+    let one_result = one.get(&mut store);
+    println!("`one` value after `set`: {:?}", one_result);
+    assert_eq!(one_result, Value::F32(1.0));
+
+    // Setting the values of globals can be done in two ways:
+    //   1. Through an exported function,
+    //   2. Using the Global API directly.
+    //
+    // We will use both for the `some` global.
+    let set_some: TypedFunction<f32, ()> = instance
+        .exports
+        .get_function("set_some")?
+        .typed(&mut store)?;
+    set_some.call(&mut store, 21.0)?;
+    let some_result = some.get(&mut store);
+    println!("`some` value after `set_some`: {:?}", some_result);
+    assert_eq!(some_result, Value::F32(21.0));
+
+    some.set(&mut store, Value::F32(42.0))?;
+    let some_result = some.get(&mut store);
+    println!("`some` value after `set`: {:?}", some_result);
+    assert_eq!(some_result, Value::F32(42.0));
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_global() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/exports_memory.rs b/arbitrator/tools/module_roots/wasmer/examples/exports_memory.rs
new file mode 100644
index 0000000..3990efc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/exports_memory.rs
@@ -0,0 +1,113 @@
+//! A Wasm module can export entities, like functions, memories,
+//! globals and tables.
+//!
+//! This example illustrates how to use exported memories
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example exported-memory --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction, WasmPtr};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (memory (export "mem") 1)
+
+  (global $offset i32 (i32.const 42))
+  (global $length (mut i32) (i32.const 13))
+
+  (func (export "load") (result i32 i32)
+    global.get $offset
+    global.get $length)
+
+  (data (i32.const 42) "Hello, World!"))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let load: TypedFunction<(), (WasmPtr<u8>, i32)> =
+        instance.exports.get_typed_function(&mut store, "load")?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a memory under "mem". Let's get it.
+    let memory = instance.exports.get_memory("mem")?;
+
+    // Now that we have the exported memory, let's get some
+    // information about it.
+    //
+    // The first thing we might be intersted in is the size of the memory.
+    // Let's get it!
+    let memory_view = memory.view(&store);
+    println!("Memory size (pages) {:?}", memory_view.size());
+    println!("Memory size (bytes) {:?}", memory_view.data_size());
+
+    // Oh! Wait, before reading the contents, we need to know
+    // where to find what we are looking for.
+    //
+    // Fortunately, the Wasm module exports a `load` function
+    // which will tell us the offset and length of the string.
+    let (ptr, length) = load.call(&mut store)?;
+    println!("String offset: {:?}", ptr.offset());
+    println!("String length: {:?}", length);
+
+    // We now know where to find our string, let's read it.
+    //
+    // We will get bytes out of the memory so we need to
+    // decode them into a string.
+    let memory_view = memory.view(&store);
+    let str = ptr.read_utf8_string(&memory_view, length as u32).unwrap();
+    println!("Memory contents: {:?}", str);
+
+    // What about changing the contents of the memory with a more
+    // appropriate string?
+    //
+    // To do that, we'll make a slice from our pointer and change the content
+    // of each element.
+    let new_str = b"Hello, Wasmer!";
+    let values = ptr.slice(&memory_view, new_str.len() as u32).unwrap();
+    for i in 0..new_str.len() {
+        values.index(i as u64).write(new_str[i]).unwrap();
+    }
+
+    // And now, let's see the result.
+    //
+    // Since the new strings is bigger than the older one, we
+    // query the length again. The offset remains the same as
+    // before.
+    println!("New string length: {:?}", new_str.len());
+
+    let str = ptr
+        .read_utf8_string(&memory_view, new_str.len() as u32)
+        .unwrap();
+    println!("New memory contents: {:?}", str);
+
+    // Much better, don't you think?
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_memory() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/features.rs b/arbitrator/tools/module_roots/wasmer/examples/features.rs
new file mode 100644
index 0000000..28ea86e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/features.rs
@@ -0,0 +1,60 @@
+//! WebAssembly is a living standard. Wasmer integrates some
+//! WebAssembly features that aren't yet stable but can still be
+//! turned on. This example explains how.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example features --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, EngineBuilder, Features, Instance, Module, Store, Value};
+use wasmer_compiler_cranelift::Cranelift;
+
+fn main() -> anyhow::Result<()> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $swap_t (func (param i32 i64) (result i64 i32)))
+  (func $swap (type $swap_t) (param $x i32) (param $y i64) (result i64 i32)
+    (local.get $y)
+    (local.get $x))
+  (export "swap" (func $swap)))
+"#,
+    )?;
+
+    // Set up the compiler.
+    let compiler = Cranelift::default();
+
+    // Let's declare the features.
+    let mut features = Features::new();
+    // Enable the multi-value feature.
+    features.multi_value(true);
+
+    // Set up the engine. That's where we define the features!
+    let engine = EngineBuilder::new(compiler).set_features(Some(features));
+
+    // Now, let's define the store, and compile the module.
+    let mut store = Store::new(engine);
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Finally, let's instantiate the module, and execute something
+    // :-).
+    let import_object = imports! {};
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+    let swap = instance.exports.get_function("swap")?;
+
+    let results = swap.call(&mut store, &[Value::I32(1), Value::I64(2)])?;
+
+    assert_eq!(results.to_vec(), vec![Value::I64(2), Value::I32(1)]);
+
+    Ok(())
+}
+
+#[test]
+fn test_features() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/hello_world.rs b/arbitrator/tools/module_roots/wasmer/examples/hello_world.rs
new file mode 100644
index 0000000..83d16ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/hello_world.rs
@@ -0,0 +1,80 @@
+//! This is a simple example introducing the core concepts of the Wasmer API.
+//!
+//! You can run the example directly by executing the following in the Wasmer root:
+//!
+//! ```shell
+//! cargo run --example hello-world --release --features "cranelift"
+//! ```
+
+use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, TypedFunction};
+
+fn main() -> anyhow::Result<()> {
+    // First we create a simple Wasm program to use with Wasmer.
+    // We use the WebAssembly text format and use `wasmer::wat2wasm` to compile
+    // it into a WebAssembly binary.
+    //
+    // Most WebAssembly programs come from compiling source code in a high level
+    // language and will already be in the binary format.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  ;; First we define a type with no parameters and no results.
+  (type $no_args_no_rets_t (func (param) (result)))
+
+  ;; Then we declare that we want to import a function named "env" "say_hello" with
+  ;; that type signature.
+  (import "env" "say_hello" (func $say_hello (type $no_args_no_rets_t)))
+
+  ;; Finally we create an entrypoint that calls our imported function.
+  (func $run (type $no_args_no_rets_t)
+    (call $say_hello))
+  ;; And mark it as an exported function named "run".
+  (export "run" (func $run)))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    // We then use our store and Wasm bytes to compile a `Module`.
+    // A `Module` is a compiled WebAssembly module that isn't ready to execute yet.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // We define a function to act as our "env" "say_hello" function imported in the
+    // Wasm program above.
+    fn say_hello_world() {
+        println!("Hello, world!")
+    }
+
+    // We then create an import object so that the `Module`'s imports can be satisfied.
+    let import_object = imports! {
+        // We use the default namespace "env".
+        "env" => {
+            // And call our function "say_hello".
+            "say_hello" => Function::new_typed(&mut store, say_hello_world),
+        }
+    };
+
+    // We then use the `Module` and the import object to create an `Instance`.
+    //
+    // An `Instance` is a compiled WebAssembly module that has been set up
+    // and is ready to execute.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // We get the `TypedFunction` with no parameters and no results from the instance.
+    //
+    // Recall that the Wasm module exported a function named "run", this is getting
+    // that exported function from the `Instance`.
+    let run_func: TypedFunction<(), ()> = instance.exports.get_typed_function(&mut store, "run")?;
+
+    // Finally, we call our exported Wasm function which will call our "say_hello"
+    // function and return.
+    run_func.call(&mut store)?;
+
+    Ok(())
+}
+
+#[test]
+fn test_hello_world() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/http_dynamic_size.rs b/arbitrator/tools/module_roots/wasmer/examples/http_dynamic_size.rs
new file mode 100644
index 0000000..91317f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/http_dynamic_size.rs
@@ -0,0 +1,130 @@
+use anyhow::Result;
+use wasmer::{
+    imports, wat2wasm, AsStoreRef, Function, FunctionEnv, FunctionEnvMut, Instance, Memory,
+    MemoryView, Module, Store, WasmPtr,
+};
+
+// Utils
+pub fn read_string(view: &MemoryView, start: u32, len: u32) -> Result<String> {
+    Ok(WasmPtr::<u8>::new(start).read_utf8_string(view, len)?)
+}
+
+// Environment
+pub struct ExampleEnv {
+    memory: Option<Memory>,
+}
+
+impl ExampleEnv {
+    fn set_memory(&mut self, memory: Memory) {
+        self.memory = Some(memory);
+    }
+
+    fn get_memory(&self) -> &Memory {
+        self.memory.as_ref().unwrap()
+    }
+
+    fn view<'a>(&'a self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        self.get_memory().view(store)
+    }
+}
+
+fn http_get(mut ctx: FunctionEnvMut<ExampleEnv>, url: u32, url_len: u32) -> u32 {
+    // Setup environment
+    let (response, memory_size) = {
+        // Read url from memory
+        let view = ctx.data().view(&ctx);
+        let memory_size = view.data_size() as usize;
+        let address = read_string(&view, url, url_len).unwrap();
+
+        // Get request
+        let response = ureq::get(&address).call().unwrap();
+        let capacity = match response
+            .header("Content-Length")
+            .map(|it| it.parse::<usize>())
+        {
+            Some(Ok(len)) => len,
+            _ => 1024,
+        };
+        let mut buffer = Vec::with_capacity(capacity);
+        let mut reader = response.into_reader();
+        reader.read_to_end(&mut buffer).unwrap();
+        (buffer, memory_size)
+    };
+
+    // If the response is too big, grow memory
+    if 1114112 + response.len() > memory_size {
+        let delta = (1114112 + response.len() - memory_size) / wasmer::WASM_PAGE_SIZE + 1;
+        let memory = ctx.data().get_memory().clone();
+        memory.grow(&mut ctx, delta as u32).unwrap();
+    }
+
+    // Write response as string [ptr, cap, len] to wasm memory and return pointer
+    let view = ctx.data().view(&ctx);
+    view.write(1114112, &u32::to_le_bytes(1114124)).unwrap();
+    view.write(1114116, &u32::to_le_bytes(response.len() as u32))
+        .unwrap();
+    view.write(1114120, &u32::to_le_bytes(response.len() as u32))
+        .unwrap();
+    view.write(1114124, &response).unwrap();
+    1114112
+}
+
+fn main() -> Result<()> {
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type (;0;) (func (param i32 i32) (result i32)))
+  (type (;1;) (func (result i32)))
+  (type (;2;) (func))
+  (import "env" "http_get" (func (;0;) (type 0)))
+  (func (;1;) (type 1) (result i32)
+    i32.const 1048576
+    i32.const 45
+    call 0
+    i32.const 8
+    i32.add
+    i32.load)
+  (func (;2;) (type 2))
+  (func (;3;) (type 2)
+    call 2
+    call 2)
+  (func (;4;) (type 1) (result i32)
+    call 1
+    call 3)
+  (table (;0;) 1 1 funcref)
+  (memory (;0;) 17)
+  (global (;0;) (mut i32) (i32.const 1048576))
+  (export "memory" (memory 0))
+  (export "fetch" (func 4))
+  (data (;0;) (i32.const 1048576) "https://postman-echo.com/bytes/5/mb?type=json"))
+"#,
+    )?;
+
+    // Load module
+    let mut store = Store::default();
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Add host functions
+    let function_env = FunctionEnv::new(&mut store, ExampleEnv { memory: None });
+    let import_object = imports! {
+        // We use the default namespace "env".
+        "env" => {
+            // And call our function "http_get".
+            "http_get" => Function::new_typed_with_env(&mut store, &function_env, http_get),
+        }
+    };
+
+    // Create instance
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+    let memory = instance.exports.get_memory("memory")?;
+
+    // Give reference to memory
+    function_env.as_mut(&mut store).set_memory(memory.clone());
+
+    // Call function
+    let fetch = instance.exports.get_function("fetch")?;
+    let result = fetch.call(&mut store, &[])?;
+    println!("Response size: {result:?}");
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/imports_exports.rs b/arbitrator/tools/module_roots/wasmer/examples/imports_exports.rs
new file mode 100644
index 0000000..bb430b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/imports_exports.rs
@@ -0,0 +1,120 @@
+//! A Wasm module can import and export entities, like functions, memories, globals and tables.
+//! This example illustrates the basics of using these entities.
+//!
+//! In this example we'll be using a sample Wasm module which exports some entities and requires us
+//! to also import some of them.
+//!
+//! The goal here is to give you an idea of how to work with imports and exports. We won't go into
+//! the details of each entities, they'll be covered in more details in the other examples.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example imports-exports --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{
+    imports, wat2wasm, Function, FunctionType, Global, Instance, Memory, Module, Store, Table,
+    Type, Value,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module.
+    //
+    // We are using the text representation of the module here but you can also load `.wasm`
+    // files using the `include_bytes!` macro.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (func $host_function (import "" "host_function") (result i32))
+  (global $host_global (import "env" "host_global") i32)
+
+  (func $function (export "guest_function") (result i32) (global.get $global))
+  (global $global (export "guest_global") i32 (i32.const 42))
+  (table $table (export "guest_table") 1 1 funcref)
+  (memory $memory (export "guest_memory") 1))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Here we go.
+    //
+    // Before we can instantiate our module, we need to define
+    // the entities we will import.
+    //
+    // We won't go into details here as creating entities will be
+    // covered in more detail in other examples.
+    println!("Creating the imported function...");
+    let host_function_signature = FunctionType::new(vec![], vec![Type::I32]);
+    let host_function = Function::new(&mut store, &host_function_signature, |_args| {
+        Ok(vec![Value::I32(42)])
+    });
+
+    println!("Creating the imported global...");
+    let host_global = Global::new(&mut store, Value::I32(42));
+
+    // Create an import object.
+    //
+    // Imports are stored in namespaces. We'll need to register each of the
+    // namespaces with a name and add the imported entities there.
+    //
+    // Note that the namespace can also have an empty name.
+    //
+    // Our module requires us to import:
+    //   * A function `host_function` in a namespace with an empty name;
+    //   * A global `host_global` in the `env` namespace.
+    //
+    // Let's do this!
+    let import_object = imports! {
+        "" => {
+            "host_function" => host_function,
+        },
+        "env" => {
+            "host_global" => host_global,
+        },
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports some entities:
+    //   * A function: `guest_function`
+    //   * A global: `guest_global`
+    //   * A memory: `guest_memory`
+    //   * A table: `guest_table`
+    //
+    // Let's get them.
+    println!("Getting the exported function...");
+    let function = instance.exports.get::<Function>("guest_function")?;
+    println!("Got exported function of type: {:?}", function.ty(&store));
+
+    println!("Getting the exported global...");
+    let global = instance.exports.get::<Global>("guest_global")?;
+    println!("Got exported global of type: {:?}", global.ty(&store));
+
+    println!("Getting the exported memory...");
+    let memory = instance.exports.get::<Memory>("guest_memory")?;
+    println!("Got exported memory of type: {:?}", memory.ty(&store));
+
+    println!("Getting the exported table...");
+    let table = instance.exports.get::<Table>("guest_table")?;
+    println!("Got exported table of type: {:?}", table.ty(&store));
+
+    Ok(())
+}
+
+#[test]
+fn test_imports_exports() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/imports_function.rs b/arbitrator/tools/module_roots/wasmer/examples/imports_function.rs
new file mode 100644
index 0000000..b8eff99
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/imports_function.rs
@@ -0,0 +1,106 @@
+//! A Wasm module can import entities, like functions, memories,
+//! globals and tables.
+//!
+//! This example illustrates how to use imported functions. They come
+//! in 2 flavors:
+//!
+//!   1. Dynamic functions, where parameters and results are of a
+//!      slice of `Value`,
+//!   2. Native function, where parameters and results are statically
+//!      typed Rust values.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example imported-function --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{
+    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, FunctionType, Instance, Module,
+    Store, Type, TypedFunction, Value,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (func $multiply_dynamic (import "env" "multiply_dynamic") (param i32) (result i32))
+  (func $multiply_typed (import "env" "multiply_typed") (param i32) (result i32))
+
+  (type $sum_t (func (param i32) (param i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    (call $multiply_dynamic (local.get $x))
+    (call $multiply_typed (local.get $y))
+    i32.add)
+  (export "sum" (func $sum_f)))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    struct MyEnv;
+    let env = FunctionEnv::new(&mut store, MyEnv {});
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create the functions
+    let multiply_dynamic_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]);
+    let multiply_dynamic = Function::new(&mut store, &multiply_dynamic_signature, |args| {
+        println!("Calling `multiply_dynamic`...");
+
+        let result = args[0].unwrap_i32() * 2;
+
+        println!("Result of `multiply_dynamic`: {:?}", result);
+
+        Ok(vec![Value::I32(result)])
+    });
+
+    fn multiply(_env: FunctionEnvMut<MyEnv>, a: i32) -> i32 {
+        println!("Calling `multiply_typed`...");
+        let result = a * 3;
+
+        println!("Result of `multiply_typed`: {:?}", result);
+
+        result
+    }
+    let multiply_typed = Function::new_typed_with_env(&mut store, &env, multiply);
+
+    // Create an import object.
+    let import_object = imports! {
+        "env" => {
+            "multiply_dynamic" => multiply_dynamic,
+            "multiply_typed" => multiply_typed,
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a function called `sum`. Let's get it.
+    let sum: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_function("sum")?.typed(&mut store)?;
+
+    println!("Calling `sum` function...");
+    // Let's call the `sum` exported function. It will call each
+    // of the imported functions.
+    let result = sum.call(&mut store, 1, 2)?;
+
+    println!("Results of `sum`: {:?}", result);
+    assert_eq!(result, 8);
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_function() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/imports_function_env.rs b/arbitrator/tools/module_roots/wasmer/examples/imports_function_env.rs
new file mode 100644
index 0000000..fa0f338
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/imports_function_env.rs
@@ -0,0 +1,135 @@
+//! A Wasm module can import entities, like functions, memories,
+//! globals and tables.
+//!
+//! In this example, we'll create a system for getting and adjusting a counter value. However, host
+//! functions are not limited to storing data outside of Wasm, they're normal host functions and
+//! can do anything that the host can do.
+//!
+//!   1. There will be a `get_counter` function that will return an i32 of
+//!      the current global counter,
+//!   2. There will be an `add_to_counter` function will add the passed
+//!      i32 value to the counter, and return an i32 of the current
+//!      global counter.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example imported-function-env --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use std::sync::{Arc, Mutex};
+use wasmer::{
+    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, Instance, Module, Store,
+    TypedFunction,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (func $get_counter (import "env" "get_counter") (result i32))
+  (func $add_to_counter (import "env" "add_to_counter") (param i32) (result i32))
+
+  (type $increment_t (func (param i32) (result i32)))
+  (func $increment_f (type $increment_t) (param $x i32) (result i32)
+    (block
+      (loop
+        (call $add_to_counter (i32.const 1))
+        (set_local $x (i32.sub (get_local $x) (i32.const 1)))
+        (br_if 1 (i32.eq (get_local $x) (i32.const 0)))
+        (br 0)))
+    call $get_counter)
+  (export "increment_counter_loop" (func $increment_f)))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // We create some shared data here, `Arc` is required because we may
+    // move our WebAssembly instance to another thread to run it. Mutex
+    // lets us get shared mutabilty which is fine because we know we won't
+    // run host calls concurrently.  If concurrency is a possibilty, we'd have
+    // to use a `Mutex`.
+    let shared_counter: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));
+
+    // Once we have our counter we'll wrap it inside en `Env` which we'll pass
+    // to our imported functionsvia the FunctionEnv.
+    //
+    // This struct may have been anything. The only constraint is it must be
+    // possible to know the size of the `Env` at compile time (i.e it has to
+    // implement the `Sized` trait).
+    // The Env is then accessed using `data()` or `data_mut()` method.
+    #[derive(Clone)]
+    struct Env {
+        counter: Arc<Mutex<i32>>,
+    }
+
+    // Create the functions
+    fn get_counter(env: FunctionEnvMut<Env>) -> i32 {
+        *env.data().counter.lock().unwrap()
+    }
+    fn add_to_counter(env: FunctionEnvMut<Env>, add: i32) -> i32 {
+        let mut counter_ref = env.data().counter.lock().unwrap();
+
+        *counter_ref += add;
+        *counter_ref
+    }
+
+    let env = FunctionEnv::new(
+        &mut store,
+        Env {
+            counter: shared_counter.clone(),
+        },
+    );
+
+    // Create an import object.
+    let import_object = imports! {
+        "env" => {
+            "get_counter" => Function::new_typed_with_env(&mut store, &env, get_counter),
+            "add_to_counter" => Function::new_typed_with_env(&mut store, &env, add_to_counter),
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a function called `increment_counter_loop`. Let's get it.
+    let increment_counter_loop: TypedFunction<i32, i32> = instance
+        .exports
+        .get_function("increment_counter_loop")?
+        .typed(&mut store)?;
+
+    let counter_value: i32 = *shared_counter.lock().unwrap();
+    println!("Initial ounter value: {:?}", counter_value);
+
+    println!("Calling `increment_counter_loop` function...");
+    // Let's call the `increment_counter_loop` exported function.
+    //
+    // It will loop five times thus incrementing our counter five times.
+    let result = increment_counter_loop.call(&mut store, 5)?;
+
+    let counter_value: i32 = *shared_counter.lock().unwrap();
+    println!("New counter value (host): {:?}", counter_value);
+    assert_eq!(counter_value, 5);
+
+    println!("New counter value (guest): {:?}", result);
+    assert_eq!(result, 5);
+
+    Ok(())
+}
+
+#[test]
+fn test_imported_function_env() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/imports_function_env_global.rs b/arbitrator/tools/module_roots/wasmer/examples/imports_function_env_global.rs
new file mode 100644
index 0000000..46126f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/imports_function_env_global.rs
@@ -0,0 +1,153 @@
+//! A Wasm module can import entities, like functions, memories,
+//! globals and tables.
+//!
+//! In this example, we'll create a system for getting and adjusting a counter value. However, host
+//! functions are not limited to storing data outside of Wasm, they're normal host functions and
+//! can do anything that the host can do.
+//! we will also demonstrate how a Function can also get globals from within a wasm call
+//!
+//!   1. There will be a `get_counter` function that will return an i32 of
+//!      the current global counter, The function will also increment a global value
+//!   2. There will be an `add_to_counter` function will add the passed
+//!      i32 value to the counter, and return an i32 of the current
+//!      global counter.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example imported-function-env-global --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use std::sync::{Arc, Mutex};
+use wasmer::{
+    imports, wat2wasm, Function, FunctionEnv, FunctionEnvMut, Global, Instance, Module, Store,
+    TypedFunction, Value,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (global $g_counter (import "env" "g_counter") (mut i32))
+  (func $get_counter (import "env" "get_counter") (result i32))
+  (func $add_to_counter (import "env" "add_to_counter") (param i32) (result i32))
+
+  (type $increment_t (func (param i32) (result i32)))
+  (func $increment_f (type $increment_t) (param $x i32) (result i32)
+    (block
+      (loop
+        (call $add_to_counter (i32.const 1))
+        (set_local $x (i32.sub (get_local $x) (i32.const 1)))
+        (br_if 1 (i32.eq (get_local $x) (i32.const 0)))
+        (br 0)))
+    call $get_counter)
+  (export "increment_counter_loop" (func $increment_f)))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create the global
+    let g_counter = Global::new_mut(&mut store, Value::I32(5));
+
+    // We create some shared data here, `Arc` is required because we may
+    // move our WebAssembly instance to another thread to run it. Mutex
+    // lets us get shared mutabilty which is fine because we know we won't
+    // run host calls concurrently.  If concurrency is a possibilty, we'd have
+    // to use a `Mutex`.
+    let shared_counter: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));
+
+    // Once we have our counter we'll wrap it inside en `Env` which we'll pass
+    // to our imported functionsvia the FunctionEnv.
+    //
+    // This struct may have been anything. The only constraint is it must be
+    // possible to know the size of the `Env` at compile time (i.e it has to
+    // implement the `Sized` trait).
+    // The Env is then accessed using `data()` or `data_mut()` method.
+    #[derive(Clone)]
+    struct Env {
+        counter: Arc<Mutex<i32>>,
+        g_counter: Global,
+    }
+
+    // Create the functions
+    fn get_counter(env: FunctionEnvMut<Env>) -> i32 {
+        *env.data().counter.lock().unwrap()
+    }
+    fn add_to_counter(mut env: FunctionEnvMut<Env>, add: i32) -> i32 {
+        let (data, mut storemut) = env.data_and_store_mut();
+        let mut counter_ref = data.counter.lock().unwrap();
+
+        let global_count = data.g_counter.get(&mut storemut).unwrap_i32();
+        data.g_counter
+            .set(&mut storemut, Value::I32(global_count + add))
+            .unwrap();
+
+        *counter_ref += add;
+        *counter_ref
+    }
+
+    let env = FunctionEnv::new(
+        &mut store,
+        Env {
+            counter: shared_counter.clone(),
+            g_counter: g_counter.clone(),
+        },
+    );
+
+    // Create an import object.
+    let import_object = imports! {
+        "env" => {
+            "get_counter" => Function::new_typed_with_env(&mut store, &env, get_counter),
+            "add_to_counter" => Function::new_typed_with_env(&mut store, &env, add_to_counter),
+            "g_counter" => g_counter.clone(),
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module exports a function called `increment_counter_loop`. Let's get it.
+    let increment_counter_loop: TypedFunction<i32, i32> = instance
+        .exports
+        .get_function("increment_counter_loop")?
+        .typed(&mut store)?;
+
+    let counter_value: i32 = *shared_counter.lock().unwrap();
+    println!("Initial ounter value: {:?}", counter_value);
+
+    println!("Calling `increment_counter_loop` function...");
+    // Let's call the `increment_counter_loop` exported function.
+    //
+    // It will loop five times thus incrementing our counter five times.
+    let result = increment_counter_loop.call(&mut store, 5)?;
+
+    let counter_value: i32 = *shared_counter.lock().unwrap();
+    println!("New counter value (host): {:?}", counter_value);
+    assert_eq!(counter_value, 5);
+
+    println!("New counter value (guest): {:?}", result);
+    assert_eq!(result, 5);
+
+    let global_counter = g_counter.get(&mut store);
+    println!("New global counter value: {:?}", global_counter);
+    assert_eq!(global_counter.unwrap_i32(), 10);
+
+    Ok(())
+}
+
+#[test]
+fn test_imported_function_env() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/imports_global.rs b/arbitrator/tools/module_roots/wasmer/examples/imports_global.rs
new file mode 100644
index 0000000..7080f6b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/imports_global.rs
@@ -0,0 +1,112 @@
+//! A Wasm module can import entities, like functions, memories,
+//! globals and tables.
+//!
+//! This example illustrates how to use imported globals. They come
+//! in 2 flavors:
+//!
+//!   1. Immutable globals (const),
+//!   2. Mutable globals.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example imported-global --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Global, Instance, Module, Store, TypedFunction, Value};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (global $some (import "env" "some") f32)
+  (global $other (import "env" "other") (mut f32))
+
+  (func (export "get_some") (result f32) (global.get $some))
+  (func (export "get_other") (result f32) (global.get $other))
+
+  (func (export "set_other") (param f32) (global.set $other (local.get 0))))
+"#,
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create the globals
+    let some = Global::new(&mut store, Value::F32(1.0));
+    let other = Global::new_mut(&mut store, Value::F32(2.0));
+
+    // Create an import object.
+    // We add the two required globals in the `env` namespace.
+    let import_object = imports! {
+        "env" => {
+            "some" => some.clone(),
+            "other" => other.clone(),
+        }
+    };
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Here we go.
+    //
+    // The Wasm module only imports some globals. We'll have to interact
+    // with them either using the Global API or exported functions.
+    let get_some: TypedFunction<(), f32> = instance
+        .exports
+        .get_function("get_some")?
+        .typed(&mut store)?;
+    let get_other: TypedFunction<(), f32> = instance
+        .exports
+        .get_function("get_other")?
+        .typed(&mut store)?;
+
+    let some_result = get_some.call(&mut store)?;
+    let other_result = get_other.call(&mut store)?;
+
+    println!("some value (via `get_some`): {:?}", some_result);
+    println!("some value (via Global API): {:?}", some.get(&mut store));
+    println!("other value (via `get_other`): {:?}", other_result);
+    println!("other value (via Global API): {:?}", other.get(&mut store));
+
+    assert_eq!(some_result, some.get(&mut store).f32().unwrap());
+    assert_eq!(other_result, other.get(&mut store).f32().unwrap());
+
+    println!("Setting global values...");
+    // Trying to set the value of a immutable global (`const`)
+    // will result in a `RuntimeError`.
+    let result = some.set(&mut store, Value::F32(42.0));
+    assert!(result.is_err());
+
+    other.set(&mut store, Value::F32(21.0))?;
+    let other_result = other.get(&mut store);
+    println!("other value after `set`: {:?}", other_result);
+    assert_eq!(other_result, Value::F32(21.0));
+
+    println!("Altering global values through exported functions...");
+    // Changes made to global through exported functions will
+    // be reflected on the host side.
+    let set_other: TypedFunction<f32, ()> = instance
+        .exports
+        .get_function("set_other")?
+        .typed(&mut store)?;
+    set_other.call(&mut store, 42.0)?;
+
+    println!("other value (via Global API): {:?}", other.get(&mut store));
+    assert_eq!(other.get(&mut store), Value::F32(42.0));
+
+    Ok(())
+}
+
+#[test]
+fn test_imported_global() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/instance.rs b/arbitrator/tools/module_roots/wasmer/examples/instance.rs
new file mode 100644
index 0000000..35cc707
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/instance.rs
@@ -0,0 +1,78 @@
+//! Wasmer will let you easily run Wasm module in a Rust host.
+//!
+//! This example illustrates the basics of using Wasmer through a "Hello World"-like project:
+//!
+//!   1. How to load a Wasm modules as bytes
+//!   2. How to compile the module
+//!   3. How to create an instance of the module
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example instance --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{imports, wat2wasm, Instance, Module, Store, TypedFunction};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // Let's declare the Wasm module.
+    //
+    // We are using the text representation of the module here but you can also load `.wasm`
+    // files using the `include_bytes!` macro.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $add_one_t (func (param i32) (result i32)))
+  (func $add_one_f (type $add_one_t) (param $value i32) (result i32)
+    local.get $value
+    i32.const 1
+    i32.add)
+  (export "add_one" (func $add_one_f)))
+"#,
+    )?;
+
+    // Create a Store.
+    // Note that we don't need to specify the engine/compiler if we want to use
+    // the default provided by Wasmer.
+    // You can use `Store::default()` for that.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // We now have an instance ready to be used.
+    //
+    // From an `Instance` we can retrieve any exported entities.
+    // Each of these entities is covered in others examples.
+    //
+    // Here we are retrieving the exported function. We won't go into details here
+    // as the main focus of this example is to show how to create an instance out
+    // of a Wasm module and have basic interactions with it.
+    let add_one: TypedFunction<i32, i32> = instance
+        .exports
+        .get_function("add_one")?
+        .typed(&mut store)?;
+
+    println!("Calling `add_one` function...");
+    let result = add_one.call(&mut store, 1)?;
+
+    println!("Results of `add_one`: {:?}", result);
+    assert_eq!(result, 2);
+
+    Ok(())
+}
+
+#[test]
+fn test_exported_function() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/memory.rs b/arbitrator/tools/module_roots/wasmer/examples/memory.rs
new file mode 100644
index 0000000..15ed18c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/memory.rs
@@ -0,0 +1,149 @@
+//! With Wasmer you'll be able to interact with guest module memory.
+//!
+//! This example illustrates the basics of interacting with Wasm module memory.:
+//!
+//!   1. How to load a Wasm modules as bytes
+//!   2. How to compile the module
+//!   3. How to create an instance of the module
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example memory --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use std::mem;
+use wasmer::{imports, wat2wasm, Bytes, Instance, Module, Pages, Store, TypedFunction};
+
+// this example is a work in progress:
+// TODO: clean it up and comment it https://github.com/wasmerio/wasmer/issues/1749
+
+fn main() -> anyhow::Result<()> {
+    // Let's declare the Wasm module.
+    //
+    // We are using the text representation of the module here but you can also load `.wasm`
+    // files using the `include_bytes!` macro.
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  (type $mem_size_t (func (result i32)))
+  (type $get_at_t (func (param i32) (result i32)))
+  (type $set_at_t (func (param i32) (param i32)))
+
+  (memory $mem 1)
+
+  (func $get_at (type $get_at_t) (param $idx i32) (result i32)
+    (i32.load (local.get $idx)))
+
+  (func $set_at (type $set_at_t) (param $idx i32) (param $val i32)
+    (i32.store (local.get $idx) (local.get $val)))
+
+  (func $mem_size (type $mem_size_t) (result i32)
+    (memory.size))
+
+  (export "get_at" (func $get_at))
+  (export "set_at" (func $set_at))
+  (export "mem_size" (func $mem_size))
+  (export "memory" (memory $mem)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // The module exports some utility functions, let's get them.
+    //
+    // These function will be used later in this example.
+    let mem_size: TypedFunction<(), i32> = instance
+        .exports
+        .get_typed_function(&mut store, "mem_size")?;
+    let get_at: TypedFunction<i32, i32> =
+        instance.exports.get_typed_function(&mut store, "get_at")?;
+    let set_at: TypedFunction<(i32, i32), ()> =
+        instance.exports.get_typed_function(&mut store, "set_at")?;
+    let memory = instance.exports.get_memory("memory")?;
+
+    // We now have an instance ready to be used.
+    //
+    // We will start by querying the most intersting information
+    // about the memory: its size. There are mainly two ways of getting
+    // this:
+    // * the size as a number of `Page`s
+    // * the size as a number of bytes
+    //
+    // The size in bytes can be found either by querying its pages or by
+    // querying the memory directly.
+    println!("Querying memory size...");
+    let memory_view = memory.view(&store);
+    assert_eq!(memory_view.size(), Pages::from(1));
+    assert_eq!(memory_view.size().bytes(), Bytes::from(65536 as usize));
+    assert_eq!(memory_view.data_size(), 65536);
+
+    // Sometimes, the guest module may also export a function to let you
+    // query the memory. Here we have a `mem_size` function, let's try it:
+    let result = mem_size.call(&mut store)?;
+
+    let memory_view = memory.view(&store);
+    println!("Memory size: {:?}", result);
+    assert_eq!(Pages::from(result as u32), memory_view.size());
+
+    // Now that we know the size of our memory, it's time to see how wa
+    // can change this.
+    //
+    // A memory can be grown to allow storing more things into it. Let's
+    // see how we can do that:
+    println!("Growing memory...");
+
+    // Here we are requesting two more pages for our memory.
+    memory.grow(&mut store, 2)?;
+
+    let memory_view = memory.view(&store);
+    assert_eq!(memory_view.size(), Pages::from(3));
+    assert_eq!(memory_view.data_size(), 65536 * 3);
+
+    // Now that we know how to query and adjust the size of the memory,
+    // let's see how wa can write to it or read from it.
+    //
+    // We'll only focus on how to do this using exported functions, the goal
+    // is to show how to work with memory addresses. Here we'll use absolute
+    // addresses to write and read a value.
+    let mem_addr = 0x2220;
+    let val = 0xFEFEFFE;
+    set_at.call(&mut store, mem_addr, val)?;
+
+    let result = get_at.call(&mut store, mem_addr)?;
+    println!("Value at {:#x?}: {:?}", mem_addr, result);
+    assert_eq!(result, val);
+
+    // Now instead of using hard coded memory addresses, let's try to write
+    // something at the end of the second memory page and read it.
+    let page_size = 0x1_0000;
+    let mem_addr = (page_size * 2) - mem::size_of_val(&val) as i32;
+    let val = 0xFEA09;
+    set_at.call(&mut store, mem_addr, val)?;
+
+    let result = get_at.call(&mut store, mem_addr)?;
+    println!("Value at {:#x?}: {:?}", mem_addr, result);
+    assert_eq!(result, val);
+
+    Ok(())
+}
+
+#[test]
+fn test_memory() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/metering.rs b/arbitrator/tools/module_roots/wasmer/examples/metering.rs
new file mode 100644
index 0000000..e5d8c70
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/metering.rs
@@ -0,0 +1,172 @@
+//! Wasmer will let you easily run Wasm module in a Rust host.
+//!
+//! This example illustrates the basics of using Wasmer metering features:
+//!
+//!   1. How to enable metering in a module
+//!   2. How to meter a specific function call
+//!   3. How to make execution fails if cost exceeds a given limit
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example metering --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+
+use anyhow::bail;
+use std::sync::Arc;
+use wasmer::wasmparser::Operator;
+use wasmer::CompilerConfig;
+use wasmer::{imports, wat2wasm, EngineBuilder, Instance, Module, Store, TypedFunction};
+use wasmer_compiler_cranelift::Cranelift;
+use wasmer_middlewares::{
+    metering::{get_remaining_points, set_remaining_points, MeteringPoints},
+    Metering,
+};
+
+fn main() -> anyhow::Result<()> {
+    // Let's declare the Wasm module.
+    //
+    // We are using the text representation of the module here but you can also load `.wasm`
+    // files using the `include_bytes!` macro.
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (type $add_t (func (param i32) (result i32)))
+  (func $add_one_f (type $add_t) (param $value i32) (result i32)
+    local.get $value
+    i32.const 1
+    i32.add)
+  (export "add_one" (func $add_one_f)))
+"#,
+    )?;
+
+    // Let's define our cost function.
+    //
+    // This function will be called for each `Operator` encountered during
+    // the Wasm module execution. It should return the cost of the operator
+    // that it received as it first argument.
+    let cost_function = |operator: &Operator| -> u64 {
+        match operator {
+            Operator::LocalGet { .. } | Operator::I32Const { .. } => 1,
+            Operator::I32Add { .. } => 2,
+            _ => 0,
+        }
+    };
+
+    // Now let's create our metering middleware.
+    //
+    // `Metering` needs to be configured with a limit and a cost function.
+    //
+    // For each `Operator`, the metering middleware will call the cost
+    // function and subtract the cost from the remaining points.
+    let metering = Arc::new(Metering::new(10, cost_function));
+    let mut compiler_config = Cranelift::default();
+    compiler_config.push_middleware(metering);
+
+    // Create a Store.
+    //
+    // We use our previously create compiler configuration
+    // with the Universal engine.
+    let mut store = Store::new(EngineBuilder::new(compiler_config));
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    // Create an empty import object.
+    let import_object = imports! {};
+
+    println!("Instantiating module...");
+    // Let's instantiate the Wasm module.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // We now have an instance ready to be used.
+    //
+    // Our module exports a single `add_one`  function. We want to
+    // measure the cost of executing this function.
+    let add_one: TypedFunction<i32, i32> = instance
+        .exports
+        .get_function("add_one")?
+        .typed(&mut store)?;
+
+    println!("Calling `add_one` function once...");
+    add_one.call(&mut store, 1)?;
+
+    // As you can see here, after the first call we have 6 remaining points.
+    //
+    // This is correct, here are the details of how it has been computed:
+    // * `local.get $value` is a `Operator::LocalGet` which costs 1 point;
+    // * `i32.const` is a `Operator::I32Const` which costs 1 point;
+    // * `i32.add` is a `Operator::I32Add` which costs 2 points.
+    let remaining_points_after_first_call = get_remaining_points(&mut store, &instance);
+    assert_eq!(
+        remaining_points_after_first_call,
+        MeteringPoints::Remaining(6)
+    );
+
+    println!(
+        "Remaining points after the first call: {:?}",
+        remaining_points_after_first_call
+    );
+
+    println!("Calling `add_one` function twice...");
+    add_one.call(&mut store, 1)?;
+
+    // We spent 4 more points with the second call.
+    // We have 2 remaining points.
+    let remaining_points_after_second_call = get_remaining_points(&mut store, &instance);
+    assert_eq!(
+        remaining_points_after_second_call,
+        MeteringPoints::Remaining(2)
+    );
+
+    println!(
+        "Remaining points after the second call: {:?}",
+        remaining_points_after_second_call
+    );
+
+    // Because calling our `add_one` function consumes 4 points,
+    // calling it a third time will fail: we already consume 8
+    // points, there are only two remaining.
+    println!("Calling `add_one` function a third time...");
+    match add_one.call(&mut store, 1) {
+        Ok(result) => {
+            bail!(
+                "Expected failure while calling `add_one`, found: {}",
+                result
+            );
+        }
+        Err(_) => {
+            println!("Calling `add_one` failed.");
+
+            // Because the last needed more than the remaining points, we should have an error.
+            let remaining_points = get_remaining_points(&mut store, &instance);
+
+            match remaining_points {
+                MeteringPoints::Remaining(..) => {
+                    bail!("No metering error: there are remaining points")
+                }
+                MeteringPoints::Exhausted => println!("Not enough points remaining"),
+            }
+        }
+    }
+
+    // Now let's see how we can set a new limit...
+    println!("Set new remaining points to 10");
+    let new_limit = 10;
+    set_remaining_points(&mut store, &instance, new_limit);
+
+    let remaining_points = get_remaining_points(&mut store, &instance);
+    assert_eq!(remaining_points, MeteringPoints::Remaining(new_limit));
+
+    println!("Remaining points: {:?}", remaining_points);
+
+    Ok(())
+}
+
+#[test]
+fn test_metering() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/platform_ios_headless.rs b/arbitrator/tools/module_roots/wasmer/examples/platform_ios_headless.rs
new file mode 100644
index 0000000..7b133b2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/platform_ios_headless.rs
@@ -0,0 +1,75 @@
+//! Defining an engine in Wasmer is one of the fundamental steps.
+//!
+//! This example builds on that of 'engine_headless.rs' but instead of
+//! serializing a module and then deserializing it again for your host machines target,
+//! We instead create an engine for our target architecture (In this case an ARM64 iOS device),
+//! serialize a simple module to a .dylib file that can be copied to an iOS project and
+//! deserialized/ran using the 'Headless C-API'.
+//!
+//! ```shell
+//! cargo run --example platform-headless-ios --release --features "cranelift"
+//! ```
+//!
+//! Ready?
+#![allow(unused)]
+use std::path::Path;
+use std::str::FromStr;
+use wasmer::{wat2wasm, Module, RuntimeError, Store};
+use wasmer_compiler_cranelift::Cranelift;
+use wasmer_types::{CpuFeature, Target, Triple};
+/*
+use wasmer_engine_dylib::Dylib;
+*/
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    /*
+        // Let's declare the Wasm module with the text representation.
+        let wasm_bytes = wat2wasm(
+            r#"
+    (module
+    (type $sum_t (func (param i32 i32) (result i32)))
+    (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+    (export "sum" (func $sum_f)))
+    "#
+            .as_bytes(),
+        )?;
+
+        // Create a compiler for iOS
+        let compiler_config = Cranelift::default();
+        // Change it to `x86_64-apple-ios` if you want to target the iOS simulator
+        let triple = Triple::from_str("aarch64-apple-ios")
+            .map_err(|error| RuntimeError::new(error.to_string()))?;
+
+        // Let's build the target.
+        let mut cpu_feature = CpuFeature::set();
+        cpu_feature.insert(CpuFeature::from_str("sse2")?);
+        let target = Target::new(triple, cpu_feature);
+        println!("Chosen target: {:?}", target);
+
+        println!("Creating Dylib engine...");
+        let engine = Dylib::new(compiler_config).target(target);
+
+        // Create a store, that holds the engine.
+        let mut store = Store::new(engine);
+
+        println!("Compiling module...");
+        // Let's compile the Wasm module.
+        let module = Module::new(&store, wasm_bytes)?;
+        // Here we go. Let's serialize the compiled Wasm module in a
+        // file.
+        println!("Serializing module...");
+        let dylib_file = Path::new("./sum.dylib");
+        module.serialize_to_file(dylib_file)?;
+    */
+
+    Ok(())
+}
+
+#[test]
+#[cfg(target_os = "macos")]
+fn test_engine_headless_ios() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/table.rs b/arbitrator/tools/module_roots/wasmer/examples/table.rs
new file mode 100644
index 0000000..cd74083
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/table.rs
@@ -0,0 +1,161 @@
+use wasmer::{
+    imports, wat2wasm, Function, Instance, Module, Store, TableType, Type, TypedFunction, Value,
+};
+
+/// A function we'll call through a table.
+fn host_callback(arg1: i32, arg2: i32) -> i32 {
+    arg1 + arg2
+}
+
+fn main() -> anyhow::Result<()> {
+    let wasm_bytes = wat2wasm(
+        r#"
+(module
+  ;; All our callbacks will take 2 i32s and return an i32.
+  ;; Wasm tables are not limited to 1 type of function, but the code using the
+  ;; table must have code to handle the type it finds.
+  (type $callback_t (func (param i32 i32) (result i32)))
+
+  ;; We'll call a callback by passing a table index as an i32 and then the two
+  ;; arguments that the function expects.
+  (type $call_callback_t (func (param i32 i32 i32) (result i32)))
+
+  ;; Our table of functions that's exactly size 3 (min 3, max 3).
+  (table $t1 3 6 funcref)
+
+  ;; Call the function at the given index with the two supplied arguments.
+  (func $call_callback (type $call_callback_t) (param $idx i32)
+                                               (param $arg1 i32) (param $arg2 i32)
+                                               (result i32)
+    (call_indirect (type $callback_t) 
+                   (local.get $arg1) (local.get $arg2)
+                   (local.get $idx)))
+
+  ;; A default function that we'll pad the table with.
+  ;; This function doubles both its inputs and then sums them.
+  (func $default_fn (type $callback_t) (param $a i32) (param $b i32) (result i32)
+     (i32.add 
+       (i32.mul (local.get $a) (i32.const 2))
+       (i32.mul (local.get $b) (i32.const 2))))
+
+  ;; Fill our table with the default function.
+  (elem $t1 (i32.const 0) $default_fn $default_fn $default_fn)
+
+  ;; Export things for the host to call.
+  (export "call_callback" (func $call_callback))
+  (export "__indirect_function_table" (table $t1)))
+"#
+        .as_bytes(),
+    )?;
+
+    // Create a Store.
+    let mut store = Store::default();
+    // Then compile our Wasm.
+    let module = Module::new(&store, wasm_bytes)?;
+    let import_object = imports! {};
+    // And instantiate it with no imports.
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // We get our function that calls (i32, i32) -> i32 functions via table.
+    // The first argument is the table index and the next 2 are the 2 arguments
+    // to be passed to the function found in the table.
+    let call_via_table: TypedFunction<(i32, i32, i32), i32> = instance
+        .exports
+        .get_typed_function(&mut store, "call_callback")?;
+
+    // And then call it with table index 1 and arguments 2 and 7.
+    let result = call_via_table.call(&mut store, 1, 2, 7)?;
+    // Because it's the default function, we expect it to double each number and
+    // then sum it, giving us 18.
+    assert_eq!(result, 18);
+
+    // We then get the table from the instance.
+    let guest_table = instance.exports.get_table("__indirect_function_table")?;
+    // And demonstrate that it has the properties that we set in the Wasm.
+    assert_eq!(guest_table.size(&mut store), 3);
+    assert_eq!(
+        guest_table.ty(&store),
+        TableType {
+            ty: Type::FuncRef,
+            minimum: 3,
+            maximum: Some(6)
+        }
+    );
+
+    // == Setting elements in a table ==
+
+    // We first construct a `Function` over our host_callback.
+    let func = Function::new_typed(&mut store, host_callback);
+
+    // And set table index 1 of that table to the host_callback `Function`.
+    guest_table.set(&mut store, 1, func.into())?;
+
+    // We then repeat the call from before but this time it will find the host function
+    // that we put at table index 1.
+    let result = call_via_table.call(&mut store, 1, 2, 7)?;
+    // And because our host function simply sums the numbers, we expect 9.
+    assert_eq!(result, 9);
+
+    // == Growing a table ==
+
+    // We again construct a `Function` over our host_callback.
+    let func = Function::new_typed(&mut store, host_callback);
+
+    // And grow the table by 3 elements, filling in our host_callback in all the
+    // new elements of the table.
+    let previous_size = guest_table.grow(&mut store, 3, func.into())?;
+    assert_eq!(previous_size, 3);
+
+    assert_eq!(guest_table.size(&mut store), 6);
+    assert_eq!(
+        guest_table.ty(&store),
+        TableType {
+            ty: Type::FuncRef,
+            minimum: 3,
+            maximum: Some(6)
+        }
+    );
+    // Now demonstrate that the function we grew the table with is actually in the table.
+    for table_index in 3..6 {
+        if let Value::FuncRef(Some(f)) = guest_table.get(&mut store, table_index as _).unwrap() {
+            let result = f.call(&mut store, &[Value::I32(1), Value::I32(9)])?;
+            assert_eq!(result[0], Value::I32(10));
+        } else {
+            panic!("expected to find funcref in table!");
+        }
+    }
+
+    // Call function at index 0 to show that it's still the same.
+    let result = call_via_table.call(&mut store, 0, 2, 7)?;
+    assert_eq!(result, 18);
+
+    // Now overwrite index 0 with our host_callback.
+    let func = Function::new_typed(&mut store, host_callback);
+    guest_table.set(&mut store, 0, func.into())?;
+    // And verify that it does what we expect.
+    let result = call_via_table.call(&mut store, 0, 2, 7)?;
+    assert_eq!(result, 9);
+
+    // Now demonstrate that the host and guest see the same table and that both
+    // get the same result.
+    for table_index in 3..6 {
+        if let Value::FuncRef(Some(f)) = guest_table.get(&mut store, table_index as _).unwrap() {
+            let result = f.call(&mut store, &[Value::I32(1), Value::I32(9)])?;
+            assert_eq!(result[0], Value::I32(10));
+        } else {
+            panic!("expected to find funcref in table!");
+        }
+        let result = call_via_table.call(&mut store, table_index, 1, 9)?;
+        assert_eq!(result, 10);
+    }
+
+    Ok(())
+}
+
+// This test is currently failing with:
+// not implemented: Native function definitions can't be directly called from the host yet
+#[cfg(FALSE)]
+#[test]
+fn test_table() -> anyhow::Result<()> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/tunables_limit_memory.rs b/arbitrator/tools/module_roots/wasmer/examples/tunables_limit_memory.rs
new file mode 100644
index 0000000..da2c7a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/tunables_limit_memory.rs
@@ -0,0 +1,179 @@
+use std::ptr::NonNull;
+
+use wasmer::{
+    imports,
+    vm::{self, MemoryError, MemoryStyle, TableStyle, VMMemoryDefinition, VMTableDefinition},
+    wat2wasm, BaseTunables, Engine, Instance, Memory, MemoryType, Module, Pages, Store, TableType,
+    Target, Tunables,
+};
+use wasmer_compiler_cranelift::Cranelift;
+// This is to be able to set the tunables
+use wasmer::NativeEngineExt;
+
+/// A custom tunables that allows you to set a memory limit.
+///
+/// After adjusting the memory limits, it delegates all other logic
+/// to the base tunables.
+pub struct LimitingTunables<T: Tunables> {
+    /// The maximum a linear memory is allowed to be (in Wasm pages, 64 KiB each).
+    /// Since Wasmer ensures there is only none or one memory, this is practically
+    /// an upper limit for the guest memory.
+    limit: Pages,
+    /// The base implementation we delegate all the logic to
+    base: T,
+}
+
+impl<T: Tunables> LimitingTunables<T> {
+    pub fn new(base: T, limit: Pages) -> Self {
+        Self { limit, base }
+    }
+
+    /// Takes an input memory type as requested by the guest and sets
+    /// a maximum if missing. The resulting memory type is final if
+    /// valid. However, this can produce invalid types, such that
+    /// validate_memory must be called before creating the memory.
+    fn adjust_memory(&self, requested: &MemoryType) -> MemoryType {
+        let mut adjusted = requested.clone();
+        if requested.maximum.is_none() {
+            adjusted.maximum = Some(self.limit);
+        }
+        adjusted
+    }
+
+    /// Ensures the a given memory type does not exceed the memory limit.
+    /// Call this after adjusting the memory.
+    fn validate_memory(&self, ty: &MemoryType) -> Result<(), MemoryError> {
+        if ty.minimum > self.limit {
+            return Err(MemoryError::Generic(
+                "Minimum exceeds the allowed memory limit".to_string(),
+            ));
+        }
+
+        if let Some(max) = ty.maximum {
+            if max > self.limit {
+                return Err(MemoryError::Generic(
+                    "Maximum exceeds the allowed memory limit".to_string(),
+                ));
+            }
+        } else {
+            return Err(MemoryError::Generic("Maximum unset".to_string()));
+        }
+
+        Ok(())
+    }
+}
+
+impl<T: Tunables> Tunables for LimitingTunables<T> {
+    /// Construct a `MemoryStyle` for the provided `MemoryType`
+    ///
+    /// Delegated to base.
+    fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+        let adjusted = self.adjust_memory(memory);
+        self.base.memory_style(&adjusted)
+    }
+
+    /// Construct a `TableStyle` for the provided `TableType`
+    ///
+    /// Delegated to base.
+    fn table_style(&self, table: &TableType) -> TableStyle {
+        self.base.table_style(table)
+    }
+
+    /// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`].
+    ///
+    /// The requested memory type is validated, adjusted to the limited and then passed to base.
+    fn create_host_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+    ) -> Result<vm::VMMemory, MemoryError> {
+        let adjusted = self.adjust_memory(ty);
+        self.validate_memory(&adjusted)?;
+        self.base.create_host_memory(&adjusted, style)
+    }
+
+    /// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`].
+    ///
+    /// Delegated to base.
+    unsafe fn create_vm_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+        vm_definition_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<vm::VMMemory, MemoryError> {
+        let adjusted = self.adjust_memory(ty);
+        self.validate_memory(&adjusted)?;
+        self.base
+            .create_vm_memory(&adjusted, style, vm_definition_location)
+    }
+
+    /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
+    ///
+    /// Delegated to base.
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<vm::VMTable, String> {
+        self.base.create_host_table(ty, style)
+    }
+
+    /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`].
+    ///
+    /// Delegated to base.
+    unsafe fn create_vm_table(
+        &self,
+        ty: &TableType,
+        style: &TableStyle,
+        vm_definition_location: NonNull<VMTableDefinition>,
+    ) -> Result<vm::VMTable, String> {
+        self.base.create_vm_table(ty, style, vm_definition_location)
+    }
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    // A Wasm module with one exported memory (min: 7 pages, max: unset)
+    let wat = br#"(module (memory 7) (export "memory" (memory 0)))"#;
+
+    // Alternatively: A Wasm module with one exported memory (min: 7 pages, max: 80 pages)
+    // let wat = br#"(module (memory 7 80) (export "memory" (memory 0)))"#;
+
+    let wasm_bytes = wat2wasm(wat)?;
+
+    // Any compiler do the job here
+    let compiler = Cranelift::default();
+
+    // Here is where the fun begins
+    let base = BaseTunables::for_target(&Target::default());
+    let tunables = LimitingTunables::new(base, Pages(24));
+    let mut engine: Engine = compiler.into();
+    engine.set_tunables(tunables);
+
+    // Create a store, that holds the engine and our custom tunables
+    let mut store = Store::new(engine);
+
+    println!("Compiling module...");
+    let module = Module::new(&store, wasm_bytes)?;
+
+    println!("Instantiating module...");
+    let import_object = imports! {};
+
+    // Now at this point, our custom tunables are used
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    // Check what happened
+    let mut memories: Vec<Memory> = instance
+        .exports
+        .iter()
+        .memories()
+        .map(|pair| pair.1.clone())
+        .collect();
+    assert_eq!(memories.len(), 1);
+
+    let first_memory = memories.pop().unwrap();
+    println!("Memory of this instance: {:?}", first_memory);
+    assert_eq!(first_memory.ty(&store).maximum.unwrap(), Pages(24));
+
+    Ok(())
+}
+
+#[test]
+fn test_tunables_limit_memory() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/wasi.rs b/arbitrator/tools/module_roots/wasmer/examples/wasi.rs
new file mode 100644
index 0000000..c055d35
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/wasi.rs
@@ -0,0 +1,60 @@
+//! Running a WASI compiled WebAssembly module with Wasmer.
+//!
+//! This example illustrates how to run WASI modules with
+//! Wasmer.
+//!
+//! If you need more manual control over the instantiation, including custom
+//! imports, then check out the ./wasi_manual_setup.rs example.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example wasi --release --features "cranelift,wasi"
+//! ```
+//!
+//! Ready?
+
+use std::io::Read;
+
+use wasmer::{Module, Store};
+use wasmer_wasix::{Pipe, WasiEnv};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let wasm_path = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/wasi-wast/wasi/unstable/hello.wasm"
+    );
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = std::fs::read(wasm_path)?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    let (stdout_tx, mut stdout_rx) = Pipe::channel();
+
+    // Run the module.
+    WasiEnv::builder("hello")
+        // .args(&["world"])
+        // .env("KEY", "Value")
+        .stdout(Box::new(stdout_tx))
+        .run_with_store(module, &mut store)?;
+
+    eprintln!("Run complete - reading output");
+
+    let mut buf = String::new();
+    stdout_rx.read_to_string(&mut buf).unwrap();
+
+    eprintln!("Output: {buf}");
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "wasi")]
+fn test_wasi() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/wasi_manual_setup.rs b/arbitrator/tools/module_roots/wasmer/examples/wasi_manual_setup.rs
new file mode 100644
index 0000000..d08de6d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/wasi_manual_setup.rs
@@ -0,0 +1,77 @@
+//! Running a WASI compiled WebAssembly module with Wasmer.
+//!
+//! This example illustrates how to run WASI modules with
+//! Wasmer. To run WASI we have to have to do mainly 3 steps:
+//!
+//!   1. Create a `WasiEnv` instance
+//!   2. Attach the imports from the `WasiEnv` to a new instance
+//!   3. Run the `WASI` module.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example wasi-manual-setup --release --features "cranelift,wasi"
+//! ```
+//!
+//! Ready?
+
+use wasmer::{Instance, Module, Store};
+use wasmer_wasix::WasiEnv;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let wasm_path = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/wasi-wast/wasi/unstable/hello.wasm"
+    );
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = std::fs::read(wasm_path)?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    println!("Starting `tokio` runtime...");
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    let _guard = runtime.enter();
+
+    println!("Creating `WasiEnv`...");
+    // First, we create the `WasiEnv`
+    let mut wasi_env = WasiEnv::builder("hello")
+        // .args(&["world"])
+        // .env("KEY", "Value")
+        .finalize(&mut store)?;
+
+    println!("Instantiating module with WASI imports...");
+    // Then, we get the import object related to our WASI
+    // and attach it to the Wasm instance.
+    let import_object = wasi_env.import_object(&mut store, &module)?;
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    println!("Attach WASI memory...");
+    // // Attach the memory export
+    // let memory = instance.exports.get_memory("memory")?;
+    // wasi_env.data_mut(&mut store).set_memory(memory.clone());
+
+    wasi_env.initialize(&mut store, instance.clone())?;
+
+    println!("Call WASI `_start` function...");
+    // And we just call the `_start` function!
+    let start = instance.exports.get_function("_start")?;
+    start.call(&mut store, &[])?;
+
+    wasi_env.on_exit(&mut store, None);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "wasi")]
+fn test_wasi() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/examples/wasi_pipes.rs b/arbitrator/tools/module_roots/wasmer/examples/wasi_pipes.rs
new file mode 100644
index 0000000..925c880
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/examples/wasi_pipes.rs
@@ -0,0 +1,60 @@
+//! Piping to and from a WASI compiled WebAssembly module with Wasmer.
+//!
+//! This example builds on the WASI example, showing how you can pipe to and
+//! from a WebAssembly module.
+//!
+//! You can run the example directly by executing in Wasmer root:
+//!
+//! ```shell
+//! cargo run --example wasi-pipes --release --features "cranelift,wasi"
+//! ```
+//!
+//! Ready?
+
+use std::io::{Read, Write};
+use wasmer::{Module, Store};
+use wasmer_wasix::{Pipe, WasiEnv};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let wasm_path = concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm"
+    );
+    // Let's declare the Wasm module with the text representation.
+    let wasm_bytes = std::fs::read(wasm_path)?;
+
+    // Create a Store.
+    let mut store = Store::default();
+
+    println!("Compiling module...");
+    // Let's compile the Wasm module.
+    let module = Module::new(&store, wasm_bytes)?;
+
+    let msg = "racecar go zoom";
+    println!("Writing \"{}\" to the WASI stdin...", msg);
+    let (mut stdin_sender, stdin_reader) = Pipe::channel();
+    let (stdout_sender, mut stdout_reader) = Pipe::channel();
+
+    // To write to the stdin
+    writeln!(stdin_sender, "{}", msg)?;
+
+    println!("Running module...");
+    // First, we create the `WasiEnv` with the stdio pipes
+    WasiEnv::builder("hello")
+        .stdin(Box::new(stdin_reader))
+        .stdout(Box::new(stdout_sender))
+        .run_with_store(module, &mut store)?;
+
+    // To read from the stdout
+    let mut buf = String::new();
+    stdout_reader.read_to_string(&mut buf)?;
+    println!("Read \"{}\" from the WASI stdout!", buf.trim());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "wasi")]
+fn test_wasi() -> Result<(), Box<dyn std::error::Error>> {
+    main()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/flake.lock b/arbitrator/tools/module_roots/wasmer/flake.lock
new file mode 100644
index 0000000..3a9822e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/flake.lock
@@ -0,0 +1,59 @@
+{
+  "nodes": {
+    "flakeutils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1685518550,
+        "narHash": "sha256-o2d0KcvaXzTrPRIo0kOLV0/QXHhDQ5DTi+OxcjO8xqY=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "a1720a10a6cfe8234c0e93907ffe81be440f4cef",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1686089707,
+        "narHash": "sha256-LTNlJcru2qJ0XhlhG9Acp5KyjB774Pza3tRH0pKIb3o=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "af21c31b2a1ec5d361ed8050edd0303c31306397",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "type": "indirect"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flakeutils": "flakeutils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/arbitrator/tools/module_roots/wasmer/flake.nix b/arbitrator/tools/module_roots/wasmer/flake.nix
new file mode 100644
index 0000000..dbecdfb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/flake.nix
@@ -0,0 +1,63 @@
+{
+  description = "wasmer Webassembly runtime";
+
+  inputs = {
+    flakeutils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flakeutils }:
+    flakeutils.lib.eachDefaultSystem (system:
+      let
+        NAME = "wasmer";
+        VERSION = "0.1";
+
+        pkgs = import nixpkgs {
+          inherit system;
+        };
+
+      in
+      rec {
+
+        # packages.${NAME} = pkgs.stdenv.mkDerivation {
+        #   pname = NAME;
+        #   version = VERSION;
+
+        #   buildPhase = "echo 'no-build'";
+        # };
+
+        # defaultPackage = packages.${NAME};
+
+        # # For `nix run`.
+        # apps.${NAME} = flakeutils.lib.mkApp {
+        #   drv = packages.${NAME};
+        # };
+        # defaultApp = apps.${NAME};
+
+        devShell = pkgs.stdenv.mkDerivation {
+          name = NAME;
+          src = self;
+          buildInputs = with pkgs; [
+            pkgconfig
+            openssl
+            llvmPackages_15.libllvm
+            # Snapshot testing
+            cargo-insta
+            wabt
+            binaryen
+
+            # LLVM and related dependencies
+            llvmPackages_15.llvm
+            libxml2
+            libffi
+
+            # Test runner
+            cargo-nextest
+          ];
+          runtimeDependencies = with pkgs; [ ];
+
+          LD_LIBRARY_PATH = "${pkgs.openssl.out}/lib";
+          LLVM_SYS_150_PREFIX = "${pkgs.llvmPackages_15.llvm.dev}";
+        };
+      }
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/.gitignore b/arbitrator/tools/module_roots/wasmer/fuzz/.gitignore
new file mode 100644
index 0000000..572e03b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/.gitignore
@@ -0,0 +1,4 @@
+
+target
+corpus
+artifacts
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/Cargo.toml b/arbitrator/tools/module_roots/wasmer/fuzz/Cargo.toml
new file mode 100644
index 0000000..d4a2e6a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "wasmer-bin-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2018"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+anyhow = "1"
+wasm-smith = "0.4.4"
+libfuzzer-sys = "0.4.0"
+wasmer = { path = "../lib/api" }
+wasmer-compiler-cranelift = { path = "../lib/compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { path = "../lib/compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { path = "../lib/compiler-singlepass", optional = true }
+wasmer-compiler = { path = "../lib/compiler", optional = true }
+wasmer-middlewares = { path = "../lib/middlewares" }
+wasmprinter = "0.2"
+
+[features]
+cranelift = [ "wasmer-compiler-cranelift" ]
+llvm = [ "wasmer-compiler-llvm" ]
+singlepass = [ "wasmer-compiler-singlepass" ]
+universal = [ "wasmer-compiler" ]
+wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
+wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
+static-artifact-load = ["wasmer-compiler/static-artifact-load"]
+static-artifact-create = ["wasmer-compiler/static-artifact-create"]
+
+[[bin]]
+name = "equivalence_universal"
+path = "fuzz_targets/equivalence_universal.rs"
+required-features = ["universal"]
+
+[[bin]]
+name = "universal_cranelift"
+path = "fuzz_targets/universal_cranelift.rs"
+required-features = ["universal", "cranelift"]
+
+[[bin]]
+name = "universal_llvm"
+path = "fuzz_targets/universal_llvm.rs"
+required-features = ["universal", "llvm"]
+
+[[bin]]
+name = "universal_singlepass"
+path = "fuzz_targets/universal_singlepass.rs"
+required-features = ["universal", "singlepass"]
+
+[[bin]]
+name = "metering"
+path = "fuzz_targets/metering.rs"
+required-features = ["universal", "cranelift"]
+
+[[bin]]
+name = "deterministic"
+path = "fuzz_targets/deterministic.rs"
+required-features = ["universal", "cranelift", "llvm", "singlepass"]
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/README.md b/arbitrator/tools/module_roots/wasmer/fuzz/README.md
new file mode 100644
index 0000000..13e40a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/README.md
@@ -0,0 +1,80 @@
+# Wasmer Fuzz Testing
+
+[Fuzz testing](https://en.wikipedia.org/wiki/Fuzzing) is:
+
+> An automated testing technique that involves providing invalid,
+> unexpected, or random data as inputs to a program.
+
+We use fuzz testing to automatically discover bugs in the Wasmer runtime.
+
+This `fuzz/` directory contains the configuration and the fuzz tests
+for Wasmer. To generate and to run the fuzz tests, we use the
+[`cargo-fuzz`] library.
+
+## Installation
+
+You may need to install the [`cargo-fuzz`] library to get the `cargo
+fuzz` subcommand. Use
+
+```sh
+$ cargo install cargo-fuzz
+```
+
+`cargo-fuzz` is documented in the [Rust Fuzz
+Book](https://rust-fuzz.github.io/book/cargo-fuzz.html).
+
+## Running a fuzzer
+
+This directory provides multiple fuzzers, like for example `validate`. You can run it with:
+
+```sh
+$ cargo fuzz run validate
+```
+
+Another example with the `universal_cranelift` fuzzer:
+
+```sh
+$ cargo fuzz run universal_cranelift
+```
+
+See the
+[`fuzz/fuzz_targets`](https://github.com/wasmerio/wasmer/tree/fuzz/fuzz_targets/)
+directory for the full list of fuzzers.
+
+You should see output that looks something like this:
+
+```
+#1408022        NEW    cov: 115073 ft: 503843 corp: 4659/1807Kb lim: 4096 exec/s: 889 rss: 857Mb L: 2588/4096 MS: 1 ChangeASCIIInt-
+#1408273        NEW    cov: 115073 ft: 503844 corp: 4660/1808Kb lim: 4096 exec/s: 888 rss: 857Mb L: 1197/4096 MS: 1 ShuffleBytes-
+#1408534        NEW    cov: 115073 ft: 503866 corp: 4661/1809Kb lim: 4096 exec/s: 886 rss: 857Mb L: 977/4096 MS: 1 ShuffleBytes-
+#1408540        NEW    cov: 115073 ft: 503869 corp: 4662/1811Kb lim: 4096 exec/s: 886 rss: 857Mb L: 2067/4096 MS: 1 ChangeBit-
+#1408831        NEW    cov: 115073 ft: 503945 corp: 4663/1811Kb lim: 4096 exec/s: 885 rss: 857Mb L: 460/4096 MS: 1 CMP- DE: "\x16\x00\x00\x00\x00\x00\x00\x00"-
+#1408977        NEW    cov: 115073 ft: 503946 corp: 4664/1813Kb lim: 4096 exec/s: 885 rss: 857Mb L: 1972/4096 MS: 1 ShuffleBytes-
+#1408999        NEW    cov: 115073 ft: 503949 corp: 4665/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 964/4096 MS: 2 ChangeBit-ShuffleBytes-
+#1409040        NEW    cov: 115073 ft: 503950 corp: 4666/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 90/4096 MS: 1 ChangeBit-
+#1409042        NEW    cov: 115073 ft: 503951 corp: 4667/1814Kb lim: 4096 exec/s: 884 rss: 857Mb L: 174/4096 MS: 2 ChangeByte-ChangeASCIIInt-
+```
+
+It will continue to generate random inputs forever, until it finds a
+bug or is terminated. The testcases for bugs it finds go into
+`fuzz/artifacts/universal_cranelift` and you can rerun the fuzzer on a
+single input by passing it on the command line `cargo fuzz run
+universal_cranelift /path/to/testcase`.
+
+## The corpus
+
+Each fuzzer has an individual corpus under `fuzz/corpus/test_name`,
+created on first run if not already present. The fuzzers use
+`wasm-smith` which means that the testcase files are random number
+seeds input to the Wasm generator, not `.wasm` files themselves. In
+order to debug a testcase, you may find that you need to convert it
+into a `.wasm` file. Using the standalone `wasm-smith` tool doesn't
+work for this purpose because we use a custom configuration to our
+`wasm_smith::Module`. Instead, our fuzzers use an environment variable
+`DUMP_TESTCASE=path`. For example:
+
+```sh
+$ DUMP_TESTCASE=/tmp/crash.wasm cargo fuzz run --features=universal,singlepass universal_singlepass fuzz/artifacts/universal_singlepass/crash-0966412eab4f89c52ce5d681807c8030349470f6
+```
+
+[`cargo-fuzz`]: https://github.com/rust-fuzz/cargo-fuzz
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/deterministic.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/deterministic.rs
new file mode 100644
index 0000000..d2e8212
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/deterministic.rs
@@ -0,0 +1,69 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::{CompilerConfig, EngineBuilder, Module, Store};
+use wasmer_compiler::Engine;
+use wasmer_compiler_cranelift::Cranelift;
+use wasmer_compiler_llvm::LLVM;
+use wasmer_compiler_singlepass::Singlepass;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct NoImportsConfig;
+impl Config for NoImportsConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn allow_start_export(&self) -> bool {
+        false
+    }
+}
+
+fn compile_and_compare(name: &str, engine: Engine, wasm: &[u8]) {
+    let store = Store::new(engine);
+
+    // compile for first time
+    let module = Module::new(&store, wasm).unwrap();
+    let first = module.serialize().unwrap();
+
+    // compile for second time
+    let module = Module::new(&store, wasm).unwrap();
+    let second = module.serialize().unwrap();
+
+    if first != second {
+        panic!("non-deterministic compilation from {}", name);
+    }
+}
+
+fuzz_target!(|module: ConfiguredModule<NoImportsConfig>| {
+    let wasm_bytes = module.to_bytes();
+
+    let mut compiler = Cranelift::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    compile_and_compare(
+        "universal-cranelift",
+        EngineBuilder::new(compiler.clone()).engine(),
+        &wasm_bytes,
+    );
+
+    let mut compiler = LLVM::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    compile_and_compare(
+        "universal-llvm",
+        EngineBuilder::new(compiler.clone()).engine(),
+        &wasm_bytes,
+    );
+
+    let compiler = Singlepass::default();
+    compile_and_compare(
+        "universal-singlepass",
+        EngineBuilder::new(compiler.clone()).engine(),
+        &wasm_bytes,
+    );
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/equivalence_universal.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/equivalence_universal.rs
new file mode 100644
index 0000000..4db992f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/equivalence_universal.rs
@@ -0,0 +1,206 @@
+#![no_main]
+#![deny(unused_variables)]
+
+use anyhow::Result;
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::{imports, CompilerConfig, EngineBuilder, Instance, Module, Store, Val};
+#[cfg(feature = "cranelift")]
+use wasmer_compiler_cranelift::Cranelift;
+#[cfg(feature = "llvm")]
+use wasmer_compiler_llvm::LLVM;
+#[cfg(feature = "singlepass")]
+use wasmer_compiler_singlepass::Singlepass;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct ExportedFunctionConfig;
+impl Config for ExportedFunctionConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn min_funcs(&self) -> usize {
+        1
+    }
+    fn min_exports(&self) -> usize {
+        1
+    }
+}
+
+struct WasmSmithModule(ConfiguredModule<ExportedFunctionConfig>);
+impl<'a> arbitrary::Arbitrary<'a> for WasmSmithModule {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        let mut module = ConfiguredModule::<ExportedFunctionConfig>::arbitrary(u)?;
+        module.ensure_termination(100000);
+        Ok(WasmSmithModule(module))
+    }
+}
+impl std::fmt::Debug for WasmSmithModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+#[cfg(feature = "singlepass")]
+fn maybe_instantiate_singlepass(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+    let compiler = Singlepass::default();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes);
+    let module = match module {
+        Ok(m) => m,
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.contains("Validation error: invalid result arity: func type returns multiple values") || error_message.contains("Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled") || error_message.contains("multi-value returns not yet implemented") {
+                return Ok(None);
+            }
+            return Err(e.into());
+        }
+    };
+    let instance = Instance::new(&module, &imports! {})?;
+    Ok(Some(instance))
+}
+
+#[cfg(feature = "cranelift")]
+fn maybe_instantiate_cranelift(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+    let mut compiler = Cranelift::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes)?;
+    let instance = Instance::new(&module, &imports! {})?;
+    Ok(Some(instance))
+}
+
+#[cfg(feature = "llvm")]
+fn maybe_instantiate_llvm(wasm_bytes: &[u8]) -> Result<Option<Instance>> {
+    let mut compiler = LLVM::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes)?;
+    let instance = Instance::new(&module, &imports! {})?;
+    Ok(Some(instance))
+}
+
+#[derive(Debug)]
+enum FunctionResult {
+    Error(String),
+    Values(Vec<Val>),
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum InstanceResult {
+    Error(String),
+    Functions(Vec<FunctionResult>),
+}
+
+impl PartialEq for FunctionResult {
+    fn eq(&self, other: &Self) -> bool {
+        /*
+        match self {
+            FunctionResult::Error(self_message) => {
+                if let FunctionResult::Error(other_message) = other {
+                    return self_message == other_message;
+                }
+            }
+            FunctionResult::Values(self_values) => {
+                if let FunctionResult::Values(other_values) = other {
+                    return self_values == other_values;
+                }
+            }
+        }
+        false
+         */
+        match (self, other) {
+            (FunctionResult::Values(self_values), FunctionResult::Values(other_values)) => {
+                self_values.len() == other_values.len()
+                    && self_values
+                        .iter()
+                        .zip(other_values.iter())
+                        .all(|(x, y)| match (x, y) {
+                            (Val::F32(x), Val::F32(y)) => x.to_bits() == y.to_bits(),
+                            (Val::F64(x), Val::F64(y)) => x.to_bits() == y.to_bits(),
+                            _ => x == y,
+                        })
+            }
+            _ => true,
+        }
+    }
+}
+
+impl Eq for FunctionResult {}
+
+fn evaluate_instance(instance: Result<Instance>) -> InstanceResult {
+    if let Err(_err) = instance {
+        /*let mut error_message = format!("{}", err);
+        // Remove the stack trace.
+        if error_message.starts_with("RuntimeError: unreachable\n") {
+            error_message = "RuntimeError: unreachable\n".into();
+        }
+        InstanceResult::Error(error_message)*/
+        InstanceResult::Error("".into())
+    } else {
+        let instance = instance.unwrap();
+        let mut results = vec![];
+        for it in instance.exports.iter().functions() {
+            let (_, f) = it;
+            // TODO: support functions which take params.
+            if f.ty().params().is_empty() {
+                let result = f.call(&[]);
+                let result = if let Ok(values) = result {
+                    FunctionResult::Values(values.into())
+                } else {
+                    /*
+                    let err = result.unwrap_err();
+                    let error_message = err.message();
+                    FunctionResult::Error(error_message)
+                     */
+                    FunctionResult::Error("".into())
+                };
+                results.push(result);
+            }
+        }
+        InstanceResult::Functions(results)
+    }
+}
+
+fuzz_target!(|module: WasmSmithModule| {
+    let wasm_bytes = module.0.to_bytes();
+
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(path).unwrap();
+        file.write_all(&wasm_bytes).unwrap();
+        return;
+    }
+
+    #[cfg(feature = "singlepass")]
+    let singlepass = maybe_instantiate_singlepass(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
+    #[cfg(feature = "cranelift")]
+    let cranelift = maybe_instantiate_cranelift(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
+    #[cfg(feature = "llvm")]
+    let llvm = maybe_instantiate_llvm(&wasm_bytes)
+        .transpose()
+        .map(evaluate_instance);
+
+    #[cfg(all(feature = "singlepass", feature = "cranelift"))]
+    if singlepass.is_some() && cranelift.is_some() {
+        assert_eq!(singlepass.as_ref().unwrap(), cranelift.as_ref().unwrap());
+    }
+    #[cfg(all(feature = "singlepass", feature = "llvm"))]
+    if singlepass.is_some() && llvm.is_some() {
+        assert_eq!(singlepass.as_ref().unwrap(), llvm.as_ref().unwrap());
+    }
+    #[cfg(all(feature = "cranelift", feature = "llvm"))]
+    if cranelift.is_some() && llvm.is_some() {
+        assert_eq!(cranelift.as_ref().unwrap(), llvm.as_ref().unwrap());
+    }
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/metering.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/metering.rs
new file mode 100644
index 0000000..6c4f7f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/metering.rs
@@ -0,0 +1,72 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use std::sync::Arc;
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::wasmparser::Operator;
+use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer_compiler_cranelift::Cranelift;
+use wasmer_middlewares::Metering;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct NoImportsConfig;
+impl Config for NoImportsConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn allow_start_export(&self) -> bool {
+        false
+    }
+}
+
+#[derive(Arbitrary)]
+struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
+impl std::fmt::Debug for WasmSmithModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+fn cost(operator: &Operator) -> u64 {
+    match operator {
+        Operator::LocalGet { .. } | Operator::I32Const { .. } => 1,
+        Operator::I32Add { .. } => 2,
+        _ => 0,
+    }
+}
+
+fuzz_target!(|module: WasmSmithModule| {
+    let wasm_bytes = module.0.to_bytes();
+
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(path).unwrap();
+        file.write_all(&wasm_bytes).unwrap();
+        return;
+    }
+
+    let mut compiler = Cranelift::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    let metering = Arc::new(Metering::new(10, cost));
+    compiler.push_middleware(metering);
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes).unwrap();
+    match Instance::new(&mut store, &module, &imports! {}) {
+        Ok(_) => {}
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.starts_with("RuntimeError: ")
+                && error_message.contains("out of bounds")
+            {
+                return;
+            }
+            panic!("{}", e);
+        }
+    }
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_cranelift.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_cranelift.rs
new file mode 100644
index 0000000..764947f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_cranelift.rs
@@ -0,0 +1,58 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer_compiler_cranelift::Cranelift;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct NoImportsConfig;
+impl Config for NoImportsConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn allow_start_export(&self) -> bool {
+        false
+    }
+}
+#[derive(Arbitrary)]
+struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
+impl std::fmt::Debug for WasmSmithModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+fuzz_target!(|module: WasmSmithModule| {
+    let wasm_bytes = module.0.to_bytes();
+
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(path).unwrap();
+        file.write_all(&wasm_bytes).unwrap();
+        return;
+    }
+
+    let mut compiler = Cranelift::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes).unwrap();
+    match Instance::new(&mut store, &module, &imports! {}) {
+        Ok(_) => {}
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.starts_with("RuntimeError: ")
+                && error_message.contains("out of bounds")
+            {
+                return;
+            }
+            panic!("{}", e);
+        }
+    }
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_llvm.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_llvm.rs
new file mode 100644
index 0000000..1f051f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_llvm.rs
@@ -0,0 +1,58 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::{imports, CompilerConfig, Instance, Module, Store};
+use wasmer_compiler_llvm::LLVM;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct NoImportsConfig;
+impl Config for NoImportsConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn allow_start_export(&self) -> bool {
+        false
+    }
+}
+#[derive(Arbitrary)]
+struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
+impl std::fmt::Debug for WasmSmithModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+fuzz_target!(|module: WasmSmithModule| {
+    let wasm_bytes = module.0.to_bytes();
+
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(path).unwrap();
+        file.write_all(&wasm_bytes).unwrap();
+        return;
+    }
+
+    let mut compiler = LLVM::default();
+    compiler.canonicalize_nans(true);
+    compiler.enable_verifier();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes).unwrap();
+    match Instance::new(&mut store, &module, &imports! {}) {
+        Ok(_) => {}
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.starts_with("RuntimeError: ")
+                && error_message.contains("out of bounds")
+            {
+                return;
+            }
+            panic!("{}", e);
+        }
+    }
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_singlepass.rs b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_singlepass.rs
new file mode 100644
index 0000000..762f6ec
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzz/fuzz_targets/universal_singlepass.rs
@@ -0,0 +1,66 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary, arbitrary::Arbitrary, fuzz_target};
+use wasm_smith::{Config, ConfiguredModule};
+use wasmer::{imports, Instance, Module, Store};
+use wasmer_compiler_singlepass::Singlepass;
+
+#[derive(Arbitrary, Debug, Default, Copy, Clone)]
+struct NoImportsConfig;
+impl Config for NoImportsConfig {
+    fn max_imports(&self) -> usize {
+        0
+    }
+    fn max_memory_pages(&self) -> u32 {
+        // https://github.com/wasmerio/wasmer/issues/2187
+        65535
+    }
+    fn allow_start_export(&self) -> bool {
+        false
+    }
+}
+#[derive(Arbitrary)]
+struct WasmSmithModule(ConfiguredModule<NoImportsConfig>);
+impl std::fmt::Debug for WasmSmithModule {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&wasmprinter::print_bytes(self.0.to_bytes()).unwrap())
+    }
+}
+
+fuzz_target!(|module: WasmSmithModule| {
+    let wasm_bytes = module.0.to_bytes();
+
+    if let Ok(path) = std::env::var("DUMP_TESTCASE") {
+        use std::fs::File;
+        use std::io::Write;
+        let mut file = File::create(path).unwrap();
+        file.write_all(&wasm_bytes).unwrap();
+        return;
+    }
+
+    let compiler = Singlepass::default();
+    let mut store = Store::new(compiler);
+    let module = Module::new(&store, &wasm_bytes);
+    let module = match module {
+        Ok(m) => m,
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.contains("Validation error: invalid result arity: func type returns multiple values") || error_message.contains("Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled") || error_message.contains("multi-value returns not yet implemented") {
+                return;
+            }
+            panic!("{}", e);
+        }
+    };
+    match Instance::new(&mut store, &module, &imports! {}) {
+        Ok(_) => {}
+        Err(e) => {
+            let error_message = format!("{}", e);
+            if error_message.starts_with("RuntimeError: ")
+                && error_message.contains("out of bounds")
+            {
+                return;
+            }
+            panic!("{}", e);
+        }
+    }
+});
diff --git a/arbitrator/tools/module_roots/wasmer/fuzzbuzz.yaml b/arbitrator/tools/module_roots/wasmer/fuzzbuzz.yaml
new file mode 100644
index 0000000..cbf6d4a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/fuzzbuzz.yaml
@@ -0,0 +1,9 @@
+wasmer:
+  language: rust
+  features:
+    - universal
+    - cranelift
+    - singlepass
+  deps:
+    - run: apt update
+    - run: apt install -y zlib1g-dev libffi-dev build-essential
diff --git a/arbitrator/tools/module_roots/wasmer/lib/README.md b/arbitrator/tools/module_roots/wasmer/lib/README.md
new file mode 100644
index 0000000..1cff03e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/README.md
@@ -0,0 +1,42 @@
+# The Wasmer runtime crates
+
+The philosophy of Wasmer is to be very modular by design. It's
+composed of a set of crates. We can group them as follows:
+
+* `api` — The public Rust or JS API exposes everything a user needs to use Wasmer
+  programatically through the `wasmer` crate,
+* `c-api` — The public C API exposes everything a C user needs to use
+  Wasmer programatically,
+* `cache` — The traits and types to cache compiled WebAssembly
+  modules,
+* `cli` — The Wasmer CLI itself,
+* `compiler` — The base for the compiler implementations, it defines
+  the framework for the compilers and provides everything they need:
+  * `compiler-cranelift` — A WebAssembly compiler based on the
+    Cranelift compiler infrastructure,
+  * `compiler-llvm` — A WebAssembly compiler based on the LLVM
+    compiler infrastructure; recommended for runtime speed
+    performance,
+  * `compiler-singlepass` — A WebAssembly compiler based on our own
+    compilation infrastructure; recommended for compilation-time speed
+    performance.
+* `derive` — A set of procedural macros used inside Wasmer,
+* ABI:
+  * `emscripten` — Emscripten ABI implementation inside Wasmer,
+  * `wasi` — WASI ABI implementation inside Wasmer:
+    * `wasi-types` — All the WASI types,
+* `engine` — The general abstraction for creating an engine, which is
+  responsible of leading the compiling and running flow. Using the
+  same compiler, the runtime performance will be approximately the
+  same, however the way it stores and loads the executable code will
+  differ:
+  * `engine-universal` — stores the code in a custom file format, and
+    loads it in memory,
+  * `object` — A library to cross-generate native objects for various
+    platforms.
+* `middlewares` — A collection of middlewares, like `metering` that
+  tracks how many operators are executed in total and putting a limit
+  on the total number of operators executed,
+* `types` — The basic structures to use WebAssembly,
+* `vm` — The Wasmer VM runtime library, the low-level base of
+  everything.
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/api/Cargo.toml
new file mode 100644
index 0000000..34db9d4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/Cargo.toml
@@ -0,0 +1,153 @@
+[package]
+name = "wasmer"
+description = "High-performance WebAssembly runtime"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly", "runtime", "vm"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+#####
+# This crate comes in 2 major flavors:
+#
+# - `sys`, where `wasmer` will be compiled to a native executable
+#    which provides compilers, engines, a full VM etc.
+# - `js`, where `wasmer` will be compiled to WebAssembly to run in a
+#   JavaScript host.
+#####
+
+# Shared dependencies.
+[dependencies]
+# - Mandatory shared dependencies.
+indexmap = { version = "1.6" }
+cfg-if = "1.0"
+thiserror = "1.0"
+more-asserts = "0.2"
+derivative = { version = "^2" }
+bytes = "1"
+tracing = { version = "0.1" }
+# - Optional shared dependencies.
+wat = { version = "=1.0.71", optional = true }
+rustc-demangle = "0.1"
+shared-buffer = { workspace = true }
+
+# Dependencies and Development Dependencies for `sys`.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+# - Mandatory dependencies for `sys`.
+wasmer-vm = { path = "../vm", version = "=4.2.8" }
+wasmer-compiler = { path = "../compiler", version = "=4.2.8" }
+wasmer-derive = { path = "../derive", version = "=4.2.8" }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+target-lexicon = { version = "0.12.2", default-features = false }
+# - Optional dependencies for `sys`.
+wasmer-compiler-singlepass = { path = "../compiler-singlepass", version = "=4.2.8", optional = true }
+wasmer-compiler-cranelift = { path = "../compiler-cranelift", version = "=4.2.8", optional = true }
+wasmer-compiler-llvm = { path = "../compiler-llvm", version = "=4.2.8", optional = true }
+
+wasm-bindgen = { version = "0.2.74", optional = true }
+js-sys = { version = "0.3.51", optional = true }
+rusty_jsc = { version = "0.1.0", optional = true }
+wasmparser = { workspace = true, default-features = false, optional = true }
+
+# - Mandatory dependencies for `sys` on Windows.
+[target.'cfg(all(not(target_arch = "wasm32"), target_os = "windows"))'.dependencies]
+winapi = "0.3"
+# - Development Dependencies for `sys`.
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+wat = "1.0"
+tempfile = "3.6.0"
+anyhow = "1.0"
+macro-wasmer-universal-test = { version = "4.2.8", path = "./macro-wasmer-universal-test" }
+
+# Dependencies and Develoment Dependencies for `js`.
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+# - Mandatory dependencies for `js`.
+wasmer-types = { path = "../types", version = "=4.2.8", default-features = false, features = ["std"] }
+wasm-bindgen = "0.2.74"
+js-sys = "0.3.51"
+wasmer-derive = { path = "../derive", version = "=4.2.8" }
+# - Optional dependencies for `js`.
+wasmparser = { workspace = true, default-features = false, optional = true }
+hashbrown = { version = "0.11", optional = true }
+serde-wasm-bindgen = { version = "0.4.5" }
+serde = { version = "1.0", features = ["derive"] }
+
+# - Development Dependencies for `js`.
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wat = "1.0"
+anyhow = "1.0"
+wasm-bindgen-test = "0.3.0"
+macro-wasmer-universal-test = { version = "4.2.8", path = "./macro-wasmer-universal-test" }
+
+# Specific to `js`.
+#
+# `wasm-opt` is on by default in for the release profile, but it can be
+# disabled by setting it to `false`
+[package.metadata.wasm-pack.profile.release]
+wasm-opt = false
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[features]
+default = ["sys-default"]
+# default = ["js-default"]
+std = []
+core = ["hashbrown"]
+
+# Features for `sys`.
+sys = ["wasmer-compiler/translator", "wasmer-compiler/compiler", "std"]
+sys-default = ["sys", "wat", "cranelift"]
+# - Compilers.
+compiler = ["sys"]
+singlepass = ["compiler", "wasmer-compiler-singlepass"]
+cranelift = ["compiler", "wasmer-compiler-cranelift"]
+llvm = ["compiler", "wasmer-compiler-llvm"]
+# - Engines.
+engine = ["sys"]
+# - Deprecated features.
+jit = ["engine"]
+
+# Features for `js`.
+js = ["wasm-bindgen", "js-sys"]
+js-default = ["js", "std", "wasm-types-polyfill"]
+
+wasm-types-polyfill = ["wasmparser"]
+
+jsc = ["rusty_jsc", "wasm-types-polyfill", "wasmparser"]
+
+js-serializable-module = []
+
+# Optional
+enable-serde = [
+  "wasmer-vm/enable-serde",
+  "wasmer-compiler/enable-serde",
+  "wasmer-types/enable-serde",
+]
+
+wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
+wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
+static-artifact-load = ["wasmer-compiler/static-artifact-load"]
+static-artifact-create = ["wasmer-compiler/static-artifact-create"]
+
+[package.metadata.docs.rs]
+features = [
+  "compiler",
+  "core",
+  "cranelift",
+  "engine",
+  "jit",
+  "singlepass",
+  "static-artifact-create",
+  "static-artifact-load",
+  "sys",
+  "sys-default",
+  "wasmer-artifact-create",
+  "wasmer-artifact-load",
+]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/README.md b/arbitrator/tools/module_roots/wasmer/lib/api/README.md
new file mode 100644
index 0000000..38b4f28
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/README.md
@@ -0,0 +1,94 @@
+# `wasmer` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer.svg)](https://crates.io/crates/wasmer)
+
+[`Wasmer`](https://wasmer.io/) is the most popular
+[WebAssembly](https://webassembly.org/) runtime for Rust. It supports
+JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as
+pluggable compilers suited to your needs.
+
+It's designed to be safe and secure, and runnable in any kind of environment.
+
+## Usage
+
+Here is a small example of using Wasmer to run a WebAssembly module
+written with its WAT format (textual format):
+
+```rust
+use wasmer::{Store, Module, Instance, Value, imports};
+
+fn main() -> anyhow::Result<()> {
+    let module_wat = r#"
+    (module
+    (type $t0 (func (param i32) (result i32)))
+    (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
+        get_local $p0
+        i32.const 1
+        i32.add))
+    "#;
+
+    let mut store = Store::default();
+    let module = Module::new(&store, &module_wat)?;
+    // The module doesn't import anything, so we create an empty import object.
+    let import_object = imports! {};
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let add_one = instance.exports.get_function("add_one")?;
+    let result = add_one.call(&mut store, &[Value::I32(42)])?;
+    assert_eq!(result[0], Value::I32(43));
+
+    Ok(())
+}
+```
+
+[Discover the full collection of examples](https://github.com/wasmerio/wasmer/tree/master/examples).
+
+## Features
+
+Wasmer is not only fast, but also designed to be *highly customizable*:
+
+* **Pluggable compilers** — A compiler is used by the engine to
+  transform WebAssembly into executable code:
+  * [`wasmer-compiler-singlepass`] provides a fast compilation-time
+    but an unoptimized runtime speed,
+  * [`wasmer-compiler-cranelift`] provides the right balance between
+    compilation-time and runtime performance, useful for development,
+  * [`wasmer-compiler-llvm`] provides a deeply optimized executable
+    code with the fastest runtime speed, ideal for production.
+    
+* **Headless mode** — Once a WebAssembly module has been compiled, it
+  is possible to serialize it in a file for example, and later execute
+  it with Wasmer with headless mode turned on. Headless Wasmer has no
+  compiler, which makes it more portable and faster to load. It's
+  ideal for constrainted environments.
+  
+* **Cross-compilation** — Most compilers support cross-compilation. It
+  means it possible to pre-compile a WebAssembly module targetting a
+  different architecture or platform and serialize it, to then run it
+  on the targetted architecture and platform later.
+
+* **Run Wasmer in a JavaScript environment** — With the `js` Cargo
+  feature, it is possible to compile a Rust program using Wasmer to
+  WebAssembly. In this context, the resulting WebAssembly module will
+  expect to run in a JavaScript environment, like a browser, Node.js,
+  Deno and so on. In this specific scenario, there is no engines or
+  compilers available, it's the one available in the JavaScript
+  environment that will be used.
+
+Wasmer ships by default with the Cranelift compiler as its great for
+development purposes.  However, we strongly encourage to use the LLVM
+compiler in production as it performs about 50% faster, achieving
+near-native speeds.
+
+Note: if one wants to use multiple compilers at the same time, it's
+also possible! One will need to import them directly via each of the
+compiler crates.
+
+Read [the documentation to learn
+more](https://wasmerio.github.io/wasmer/crates/doc/wasmer/).
+
+---
+
+Made with ❤️ by the Wasmer team, for the community
+
+[`wasmer-compiler-singlepass`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass
+[`wasmer-compiler-cranelift`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-cranelift
+[`wasmer-compiler-llvm`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/Cargo.toml
new file mode 100644
index 0000000..08e425f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "macro-wasmer-universal-test"
+version = "4.2.8"
+edition = "2021"
+license = "MIT"
+description = "Universal test macro for wasmer-test"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-quote = "0.4.0"
+proc-macro2 = "1.0.43"     
+syn = { version = "1.0.99", features = ["full"] }
+quote = "1.0.21"
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/src/lib.rs
new file mode 100644
index 0000000..9af4a8c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/macro-wasmer-universal-test/src/lib.rs
@@ -0,0 +1,36 @@
+extern crate proc_macro;
+
+use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span};
+
+#[proc_macro_attribute]
+pub fn universal_test(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let item_clone = item.clone();
+    let mut iter = item_clone.into_iter();
+    let _ = iter.next().unwrap(); // fn
+    let item_tree: proc_macro::TokenTree = iter.next().unwrap(); // fn ...
+    let n = match &item_tree {
+        proc_macro::TokenTree::Ident(i) => i.to_string(),
+        _ => panic!("expected fn ...() -> Result<(), String>"),
+    };
+
+    let function_name_normal = Ident::new(&n, Span::call_site());
+    let function_name_js = Ident::new(&format!("{}_js", n), Span::call_site());
+    let parsed = match syn::parse::<syn::ItemFn>(item) {
+        Ok(o) => o,
+        Err(e) => {
+            return proc_macro::TokenStream::from(e.to_compile_error());
+        }
+    };
+
+    let tokens = quote::quote! {
+        #[cfg(feature = "js")]
+        #[cfg_attr(feature = "js", wasm_bindgen_test)]
+        fn #function_name_js() { #function_name_normal().unwrap(); }
+
+        #[cfg_attr(any(feature = "sys", feature = "jsc"), test)]
+        #parsed
+    };
+
+    proc_macro::TokenStream::from(tokens)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/access.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/access.rs
new file mode 100644
index 0000000..7d10348
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/access.rs
@@ -0,0 +1,205 @@
+use std::mem::MaybeUninit;
+
+use crate::mem_access::{WasmRef, WasmSlice};
+
+pub(super) enum SliceCow<'a, T> {
+    #[allow(dead_code)]
+    Borrowed(&'a mut [T]),
+    #[allow(dead_code)]
+    Owned(Vec<T>, bool),
+}
+
+impl<'a, T> AsRef<[T]> for SliceCow<'a, T> {
+    fn as_ref(&self) -> &[T] {
+        match self {
+            Self::Borrowed(buf) => buf,
+            Self::Owned(buf, _) => buf,
+        }
+    }
+}
+
+impl<'a, T> AsMut<[T]> for SliceCow<'a, T> {
+    fn as_mut(&mut self) -> &mut [T] {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        match self {
+            Self::Borrowed(buf) => buf,
+            Self::Owned(buf, modified) => {
+                *modified = true;
+                buf.as_mut()
+            }
+        }
+    }
+}
+
+/// Provides direct memory access to a piece of memory that
+/// is owned by WASM
+pub struct WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(super) slice: WasmSlice<'a, T>,
+    pub(super) buf: SliceCow<'a, T>,
+}
+
+impl<'a, T> AsRef<[T]> for WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_ref(&self) -> &[T] {
+        self.buf.as_ref()
+    }
+}
+
+impl<'a, T> AsMut<[T]> for WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_mut(&mut self) -> &mut [T] {
+        self.buf.as_mut()
+    }
+}
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns an iterator of all the elements in the slice
+    pub fn iter(&'a self) -> std::slice::Iter<'a, T> {
+        self.as_ref().iter()
+    }
+
+    /// Returns an iterator of all the elements in the slice
+    pub fn iter_mut(&'a mut self) -> std::slice::IterMut<'a, T> {
+        self.buf.as_mut().iter_mut()
+    }
+
+    /// Number of elements in this slice
+    pub fn len(&self) -> usize {
+        self.buf.as_ref().len()
+    }
+
+    /// If the slice is empty
+    pub fn is_empty(&self) -> bool {
+        self.buf.as_ref().is_empty()
+    }
+}
+
+impl<'a> WasmSliceAccess<'a, u8> {
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn copy_from_slice(&mut self, src: &[u8]) {
+        let dst = self.buf.as_mut();
+        dst.copy_from_slice(src);
+    }
+}
+
+impl<'a, T> Drop for WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn drop(&mut self) {
+        if let SliceCow::Owned(buf, modified) = &self.buf {
+            if *modified {
+                self.slice.write_slice(buf.as_ref()).ok();
+            }
+        }
+    }
+}
+
+pub(super) enum RefCow<'a, T> {
+    #[allow(dead_code)]
+    Borrowed(&'a mut T),
+    #[allow(dead_code)]
+    Owned(T, bool),
+}
+
+impl<'a, T> AsRef<T> for RefCow<'a, T> {
+    fn as_ref(&self) -> &T {
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val, _) => val,
+        }
+    }
+}
+
+impl<'a, T> AsMut<T> for RefCow<'a, T> {
+    fn as_mut(&mut self) -> &mut T {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        match self {
+            Self::Borrowed(val) => val,
+            Self::Owned(val, modified) => {
+                *modified = true;
+                val
+            }
+        }
+    }
+}
+
+/// Provides direct memory access to a piece of memory that
+/// is owned by WASM
+pub struct WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(super) ptr: WasmRef<'a, T>,
+    pub(super) buf: RefCow<'a, T>,
+}
+
+impl<'a, T> AsRef<T> for WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_ref(&self) -> &T {
+        self.buf.as_ref()
+    }
+}
+
+impl<'a, T> AsMut<T> for WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn as_mut(&mut self) -> &mut T {
+        self.buf.as_mut()
+    }
+}
+
+impl<'a, T> Drop for WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    fn drop(&mut self) {
+        if let RefCow::Owned(val, modified) = &self.buf {
+            if *modified {
+                self.ptr.write(*val).ok();
+            }
+        }
+    }
+}
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns a mutable slice that is not yet initialized
+    pub fn as_mut_uninit(&mut self) -> &mut [MaybeUninit<T>] {
+        let ret: &mut [T] = self.buf.as_mut();
+        let ret: &mut [MaybeUninit<T>] = unsafe { std::mem::transmute(ret) };
+        ret
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Returns a reference to an unitialized reference to this value
+    pub fn as_mut_uninit(&mut self) -> &mut MaybeUninit<T> {
+        let ret: &mut T = self.buf.as_mut();
+        let ret: &mut MaybeUninit<T> = unsafe { std::mem::transmute(ret) };
+        ret
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/engine.rs
new file mode 100644
index 0000000..820d4d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/engine.rs
@@ -0,0 +1,170 @@
+use core::ops::Deref;
+
+#[cfg(feature = "sys")]
+use crate::sys::engine as engine_imp;
+#[cfg(feature = "sys")]
+pub(crate) use crate::sys::engine::default_engine;
+#[cfg(feature = "sys")]
+use crate::IntoBytes;
+#[cfg(feature = "sys")]
+use shared_buffer::OwnedBuffer;
+#[cfg(feature = "sys")]
+use std::path::Path;
+#[cfg(feature = "sys")]
+use std::sync::Arc;
+#[cfg(feature = "sys")]
+#[allow(unused_imports)]
+pub use wasmer_compiler::{Artifact, CompilerConfig, EngineInner, Features, Tunables};
+#[cfg(feature = "sys")]
+use wasmer_types::DeserializeError;
+
+#[cfg(feature = "js")]
+use crate::js::engine as engine_imp;
+#[cfg(feature = "js")]
+pub(crate) use crate::js::engine::default_engine;
+
+#[cfg(feature = "jsc")]
+use crate::jsc::engine as engine_imp;
+#[cfg(feature = "jsc")]
+pub(crate) use crate::jsc::engine::default_engine;
+
+/// The engine type
+#[derive(Clone, Debug)]
+pub struct Engine(pub(crate) engine_imp::Engine);
+
+impl Engine {
+    /// Returns the deterministic id of this engine
+    pub fn deterministic_id(&self) -> &str {
+        self.0.deterministic_id()
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`.
+    ///
+    /// NOTE: you should almost always prefer [`Self::deserialize`].
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    pub unsafe fn deserialize_unchecked(
+        &self,
+        bytes: impl IntoBytes,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        Ok(Arc::new(Artifact::deserialize_unchecked(
+            &self.0,
+            bytes.into_bytes().into(),
+        )?))
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// `Module::serialize`.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    pub unsafe fn deserialize(
+        &self,
+        bytes: impl IntoBytes,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        Ok(Arc::new(Artifact::deserialize(
+            &self.0,
+            bytes.into_bytes().into(),
+        )?))
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// NOTE: you should almost always prefer [`Self::deserialize_from_file`].
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    pub unsafe fn deserialize_from_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        Ok(Arc::new(Artifact::deserialize_unchecked(
+            &self.0,
+            OwnedBuffer::from_file(&file)
+                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
+        )?))
+    }
+
+    #[cfg(all(feature = "sys", not(target_arch = "wasm32")))]
+    /// Load a serialized WebAssembly module from a file and deserialize it.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    pub unsafe fn deserialize_from_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        let bytes = std::fs::read(file_ref)?;
+        Ok(Arc::new(Artifact::deserialize(&self.0, bytes.into())?))
+    }
+}
+
+impl AsEngineRef for Engine {
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef {
+        EngineRef { inner: self }
+    }
+}
+
+impl Default for Engine {
+    fn default() -> Self {
+        Self(default_engine())
+    }
+}
+
+impl<T: Into<engine_imp::Engine>> From<T> for Engine {
+    fn from(t: T) -> Self {
+        Self(t.into())
+    }
+}
+
+/// A temporary handle to an [`Engine`]
+/// EngineRef can be used to build a [`Module`][super::Module]
+/// It can be created directly with an [`Engine`]
+/// Or from anything implementing [`AsEngineRef`]
+/// like from [`Store`][super::Store] typicaly.
+pub struct EngineRef<'a> {
+    /// The inner engine
+    pub(crate) inner: &'a Engine,
+}
+
+impl<'a> EngineRef<'a> {
+    /// Get inner [`Engine`]
+    pub fn engine(&self) -> &Engine {
+        self.inner
+    }
+    /// Create an EngineRef from an Engine
+    pub fn new(engine: &'a Engine) -> Self {
+        EngineRef { inner: engine }
+    }
+}
+
+/// Helper trait for a value that is convertible to a [`EngineRef`].
+pub trait AsEngineRef {
+    /// Returns a `EngineRef` pointing to the underlying context.
+    fn as_engine_ref(&self) -> EngineRef<'_>;
+}
+
+impl AsEngineRef for EngineRef<'_> {
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef { inner: self.inner }
+    }
+}
+
+impl<P> AsEngineRef for P
+where
+    P: Deref,
+    P::Target: AsEngineRef,
+{
+    #[inline]
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        (**self).as_engine_ref()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/errors.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/errors.rs
new file mode 100644
index 0000000..88c596d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/errors.rs
@@ -0,0 +1,287 @@
+#[cfg(feature = "js")]
+use crate::js::trap::Trap;
+#[cfg(feature = "jsc")]
+use crate::jsc::trap::Trap;
+use std::fmt;
+use std::sync::Arc;
+use thiserror::Error;
+use wasmer_types::{FrameInfo, TrapCode};
+#[cfg(feature = "sys")]
+use wasmer_vm::Trap;
+
+use wasmer_types::ImportError;
+
+/// The WebAssembly.LinkError object indicates an error during
+/// module instantiation (besides traps from the start function).
+///
+/// This is based on the [link error][link-error] API.
+///
+/// [link-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "std", derive(Error))]
+#[cfg_attr(feature = "std", error("Link error: {0}"))]
+pub enum LinkError {
+    /// An error occurred when checking the import types.
+    #[cfg_attr(feature = "std", error("Error while importing {0:?}.{1:?}: {2}"))]
+    Import(String, String, ImportError),
+
+    /// A trap ocurred during linking.
+    #[cfg_attr(feature = "std", error("RuntimeError occurred during linking: {0}"))]
+    Trap(#[source] RuntimeError),
+    /// Insufficient resources available for linking.
+    #[cfg_attr(feature = "std", error("Insufficient resources: {0}"))]
+    Resource(String),
+}
+
+/// An error while instantiating a module.
+///
+/// This is not a common WebAssembly error, however
+/// we need to differentiate from a `LinkError` (an error
+/// that happens while linking, on instantiation), a
+/// Trap that occurs when calling the WebAssembly module
+/// start function, and an error when initializing the user's
+/// host environments.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "std", derive(Error))]
+pub enum InstantiationError {
+    /// A linking ocurred during instantiation.
+    #[cfg_attr(feature = "std", error(transparent))]
+    Link(LinkError),
+
+    /// A runtime error occured while invoking the start function
+    #[cfg_attr(feature = "std", error(transparent))]
+    Start(RuntimeError),
+
+    /// The module was compiled with a CPU feature that is not available on
+    /// the current host.
+    #[cfg_attr(feature = "std", error("missing required CPU features: {0:?}"))]
+    CpuFeature(String),
+
+    /// Import from a different [`Store`][super::Store].
+    /// This error occurs when an import from a different store is used.
+    #[cfg_attr(feature = "std", error("cannot mix imports from different stores"))]
+    DifferentStores,
+
+    /// Import from a different Store.
+    /// This error occurs when an import from a different store is used.
+    #[cfg_attr(feature = "std", error("incorrect OS or architecture"))]
+    DifferentArchOS,
+}
+
+/// A struct representing an aborted instruction execution, with a message
+/// indicating the cause.
+#[derive(Clone)]
+pub struct RuntimeError {
+    pub(crate) inner: Arc<RuntimeErrorInner>,
+}
+
+#[derive(Debug)]
+struct RuntimeStringError {
+    details: String,
+}
+
+impl RuntimeStringError {
+    fn new(msg: String) -> Self {
+        Self { details: msg }
+    }
+}
+
+impl fmt::Display for RuntimeStringError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.details)
+    }
+}
+
+impl std::error::Error for RuntimeStringError {
+    fn description(&self) -> &str {
+        &self.details
+    }
+}
+
+pub(crate) struct RuntimeErrorInner {
+    /// The source error
+    pub(crate) source: Trap,
+    /// The trap code (if any)
+    trap_code: Option<TrapCode>,
+    /// The reconstructed Wasm trace (from the native trace and the `GlobalFrameInfo`).
+    wasm_trace: Vec<FrameInfo>,
+}
+
+impl RuntimeError {
+    /// Creates a new generic `RuntimeError` with the given `message`.
+    ///
+    /// # Example
+    /// ```
+    /// let trap = wasmer::RuntimeError::new("unexpected error");
+    /// assert_eq!("unexpected error", trap.message());
+    /// ```
+    pub fn new<I: Into<String>>(message: I) -> Self {
+        let msg = message.into();
+        let source = RuntimeStringError::new(msg);
+        Self::user(Box::new(source))
+    }
+
+    /// Creates `RuntimeError` from an error and a WasmTrace
+    ///
+    /// # Example
+    /// ```ignore
+    /// let wasm_trace = vec![wasmer_types::FrameInfo::new(
+    ///   "my_module".to_string(),
+    ///   0,
+    ///   Some("my_function".to_string()),
+    ///   0.into(),
+    ///   2.into()
+    /// )];
+    /// let trap = wasmer::RuntimeError::new_from_source(my_error, wasm_trace, None);
+    /// assert_eq!("unexpected error", trap.message());
+    /// ```
+    pub fn new_from_source(
+        source: Trap,
+        wasm_trace: Vec<FrameInfo>,
+        trap_code: Option<TrapCode>,
+    ) -> Self {
+        Self {
+            inner: Arc::new(RuntimeErrorInner {
+                source,
+                wasm_trace,
+                trap_code,
+            }),
+        }
+    }
+
+    /// Creates a custom user Error.
+    ///
+    /// This error object can be passed through Wasm frames and later retrieved
+    /// using the `downcast` method.
+    pub fn user(error: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        match error.downcast::<Self>() {
+            Ok(err) => *err,
+            Err(error) => error.into(),
+        }
+    }
+
+    /// Returns a reference the `message` stored in `Trap`.
+    pub fn message(&self) -> String {
+        if let Some(trap_code) = self.inner.trap_code {
+            trap_code.message().to_string()
+        } else {
+            self.inner.source.to_string()
+        }
+    }
+
+    /// Returns a list of function frames in WebAssembly code that led to this
+    /// trap happening.
+    pub fn trace(&self) -> &[FrameInfo] {
+        &self.inner.wasm_trace
+    }
+
+    /// Returns trap code, if it's a Trap
+    pub fn to_trap(self) -> Option<TrapCode> {
+        self.inner.trap_code
+    }
+
+    // /// Returns trap code, if it's a Trap
+    // pub fn to_source(self) -> &'static Trap {
+    //     &self.inner.as_ref().source
+    // }
+
+    /// Attempts to downcast the `RuntimeError` to a concrete type.
+    pub fn downcast<T: std::error::Error + 'static>(self) -> Result<T, Self> {
+        match Arc::try_unwrap(self.inner) {
+            Ok(inner) if inner.source.is::<T>() => Ok(inner.source.downcast::<T>().unwrap()),
+            Ok(inner) => Err(Self {
+                inner: Arc::new(inner),
+            }),
+            Err(inner) => Err(Self { inner }),
+        }
+    }
+
+    /// Attempts to downcast the `RuntimeError` to a concrete type.
+    pub fn downcast_ref<T: std::error::Error + 'static>(&self) -> Option<&T> {
+        self.inner.as_ref().source.downcast_ref::<T>()
+    }
+
+    /// Returns true if the `RuntimeError` is the same as T
+    pub fn is<T: std::error::Error + 'static>(&self) -> bool {
+        self.inner.source.is::<T>()
+    }
+}
+
+impl fmt::Debug for RuntimeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RuntimeError")
+            .field("source", &self.inner.source)
+            .field("wasm_trace", &self.inner.wasm_trace)
+            .finish()
+    }
+}
+
+impl fmt::Display for RuntimeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "RuntimeError: {}", self.message())?;
+        let trace = self.trace();
+        if trace.is_empty() {
+            return Ok(());
+        }
+        for frame in self.trace().iter() {
+            let name = frame.module_name();
+            let func_index = frame.func_index();
+            writeln!(f)?;
+            write!(f, "    at ")?;
+            match frame.function_name() {
+                Some(name) => match rustc_demangle::try_demangle(name) {
+                    Ok(name) => write!(f, "{}", name)?,
+                    Err(_) => write!(f, "{}", name)?,
+                },
+                None => write!(f, "<unnamed>")?,
+            }
+            write!(
+                f,
+                " ({}[{}]:0x{:x})",
+                name,
+                func_index,
+                frame.module_offset()
+            )?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for RuntimeError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        self.inner.source.source()
+    }
+}
+
+impl From<Box<dyn std::error::Error + Send + Sync>> for RuntimeError {
+    fn from(error: Box<dyn std::error::Error + Send + Sync>) -> Self {
+        match error.downcast::<Self>() {
+            // The error is already a RuntimeError, we return it directly
+            Ok(runtime_error) => *runtime_error,
+            Err(error) => Trap::user(error).into(),
+        }
+    }
+}
+
+/// Error that can occur during atomic operations. (notify/wait)
+// Non-exhaustive to allow for future variants without breaking changes!
+#[derive(PartialEq, Eq, Debug, Error)]
+#[non_exhaustive]
+pub enum AtomicsError {
+    /// Atomic operations are not supported by this memory.
+    Unimplemented,
+    /// To many waiter for address.
+    TooManyWaiters,
+    /// Atomic operations are disabled.
+    AtomicsDisabled,
+}
+
+impl std::fmt::Display for AtomicsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Unimplemented => write!(f, "Atomic operations are not supported"),
+            Self::TooManyWaiters => write!(f, "Too many waiters for address"),
+            Self::AtomicsDisabled => write!(f, "Atomic operations are disabled"),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/exports.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/exports.rs
new file mode 100644
index 0000000..d2f8211
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/exports.rs
@@ -0,0 +1,306 @@
+use crate::store::AsStoreRef;
+use crate::{Extern, Function, Global, Memory, Table, TypedFunction, WasmTypeList};
+use indexmap::IndexMap;
+use std::fmt;
+use std::iter::{ExactSizeIterator, FromIterator};
+use thiserror::Error;
+
+/// The `ExportError` can happen when trying to get a specific
+/// export [`Extern`] from the [`Instance`] exports.
+///
+/// [`Instance`]: crate::Instance
+///
+/// # Examples
+///
+/// ## Incompatible export type
+///
+/// ```should_panic
+/// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value, ExportError};
+/// # let mut store = Store::default();
+/// # let wasm_bytes = wat2wasm(r#"
+/// # (module
+/// #   (global $one (export "glob") f32 (f32.const 1)))
+/// # "#.as_bytes()).unwrap();
+/// # let module = Module::new(&store, wasm_bytes).unwrap();
+/// # let import_object = imports! {};
+/// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+/// #
+/// // This results with an error: `ExportError::IncompatibleType`.
+/// let export = instance.exports.get_function("glob").unwrap();
+/// ```
+///
+/// ## Missing export
+///
+/// ```should_panic
+/// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value, ExportError};
+/// # let mut store = Store::default();
+/// # let wasm_bytes = wat2wasm("(module)".as_bytes()).unwrap();
+/// # let module = Module::new(&store, wasm_bytes).unwrap();
+/// # let import_object = imports! {};
+/// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+/// #
+/// // This results with an error: `ExportError::Missing`.
+/// let export = instance.exports.get_function("unknown").unwrap();
+/// ```
+#[derive(Error, Debug, Clone)]
+pub enum ExportError {
+    /// An error than occurs when the exported type and the expected type
+    /// are incompatible.
+    #[error("Incompatible Export Type")]
+    IncompatibleType,
+    /// This error arises when an export is missing
+    #[error("Missing export {0}")]
+    Missing(String),
+}
+
+/// Exports is a special kind of map that allows easily unwrapping
+/// the types of instances.
+///
+/// TODO: add examples of using exports
+#[derive(Clone, Default, PartialEq, Eq)]
+pub struct Exports {
+    map: IndexMap<String, Extern>,
+}
+
+impl Exports {
+    /// Creates a new `Exports`.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Creates a new `Exports` with capacity `n`.
+    pub fn with_capacity(n: usize) -> Self {
+        Self {
+            map: IndexMap::with_capacity(n),
+        }
+    }
+
+    /// Return the number of exports in the `Exports` map.
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Return whether or not there are no exports
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Insert a new export into this `Exports` map.
+    pub fn insert<S, E>(&mut self, name: S, value: E)
+    where
+        S: Into<String>,
+        E: Into<Extern>,
+    {
+        self.map.insert(name.into(), value.into());
+    }
+
+    /// Get an export given a `name`.
+    ///
+    /// The `get` method is specifically made for usage inside of
+    /// Rust APIs, as we can detect what's the desired type easily.
+    ///
+    /// If you want to get an export dynamically with type checking
+    /// please use the following functions: `get_func`, `get_memory`,
+    /// `get_table` or `get_global` instead.
+    ///
+    /// If you want to get an export dynamically handling manually
+    /// type checking manually, please use `get_extern`.
+    pub fn get<'a, T: Exportable<'a>>(&'a self, name: &str) -> Result<&'a T, ExportError> {
+        match self.map.get(name) {
+            None => Err(ExportError::Missing(name.to_string())),
+            Some(extern_) => T::get_self_from_extern(extern_),
+        }
+    }
+
+    /// Get an export as a `Global`.
+    pub fn get_global(&self, name: &str) -> Result<&Global, ExportError> {
+        self.get(name)
+    }
+
+    /// Get an export as a `Memory`.
+    pub fn get_memory(&self, name: &str) -> Result<&Memory, ExportError> {
+        self.get(name)
+    }
+
+    /// Get an export as a `Table`.
+    pub fn get_table(&self, name: &str) -> Result<&Table, ExportError> {
+        self.get(name)
+    }
+
+    /// Get an export as a `Func`.
+    pub fn get_function(&self, name: &str) -> Result<&Function, ExportError> {
+        self.get(name)
+    }
+
+    /// Get an export as a `TypedFunction`.
+    pub fn get_typed_function<Args, Rets>(
+        &self,
+        store: &impl AsStoreRef,
+        name: &str,
+    ) -> Result<TypedFunction<Args, Rets>, ExportError>
+    where
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        self.get_function(name)?
+            .typed(store)
+            .map_err(|_| ExportError::IncompatibleType)
+    }
+
+    /// Hack to get this working with nativefunc too
+    pub fn get_with_generics<'a, T, Args, Rets>(&'a self, name: &str) -> Result<T, ExportError>
+    where
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+        T: ExportableWithGenerics<'a, Args, Rets>,
+    {
+        match self.map.get(name) {
+            None => Err(ExportError::Missing(name.to_string())),
+            Some(extern_) => T::get_self_from_extern_with_generics(extern_),
+        }
+    }
+
+    /// Get an export as an `Extern`.
+    pub fn get_extern(&self, name: &str) -> Option<&Extern> {
+        self.map.get(name)
+    }
+
+    /// Returns true if the `Exports` contains the given export name.
+    pub fn contains<S>(&self, name: S) -> bool
+    where
+        S: Into<String>,
+    {
+        self.map.contains_key(&name.into())
+    }
+
+    /// Get an iterator over the exports.
+    pub fn iter(&self) -> ExportsIterator<impl Iterator<Item = (&String, &Extern)>> {
+        ExportsIterator {
+            iter: self.map.iter(),
+        }
+    }
+}
+
+impl fmt::Debug for Exports {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+/// An iterator over exports.
+pub struct ExportsIterator<'a, I>
+where
+    I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
+{
+    iter: I,
+}
+
+impl<'a, I> Iterator for ExportsIterator<'a, I>
+where
+    I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
+{
+    type Item = (&'a String, &'a Extern);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+impl<'a, I> ExactSizeIterator for ExportsIterator<'a, I>
+where
+    I: Iterator<Item = (&'a String, &'a Extern)> + ExactSizeIterator + Sized,
+{
+    fn len(&self) -> usize {
+        self.iter.len()
+    }
+}
+
+impl<'a, I> ExportsIterator<'a, I>
+where
+    I: Iterator<Item = (&'a String, &'a Extern)> + Sized,
+{
+    /// Get only the functions.
+    pub fn functions(self) -> impl Iterator<Item = (&'a String, &'a Function)> + Sized {
+        self.iter.filter_map(|(name, export)| match export {
+            Extern::Function(function) => Some((name, function)),
+            _ => None,
+        })
+    }
+
+    /// Get only the memories.
+    pub fn memories(self) -> impl Iterator<Item = (&'a String, &'a Memory)> + Sized {
+        self.iter.filter_map(|(name, export)| match export {
+            Extern::Memory(memory) => Some((name, memory)),
+            _ => None,
+        })
+    }
+
+    /// Get only the globals.
+    pub fn globals(self) -> impl Iterator<Item = (&'a String, &'a Global)> + Sized {
+        self.iter.filter_map(|(name, export)| match export {
+            Extern::Global(global) => Some((name, global)),
+            _ => None,
+        })
+    }
+
+    /// Get only the tables.
+    pub fn tables(self) -> impl Iterator<Item = (&'a String, &'a Table)> + Sized {
+        self.iter.filter_map(|(name, export)| match export {
+            Extern::Table(table) => Some((name, table)),
+            _ => None,
+        })
+    }
+}
+
+impl FromIterator<(String, Extern)> for Exports {
+    fn from_iter<I: IntoIterator<Item = (String, Extern)>>(iter: I) -> Self {
+        Self {
+            map: IndexMap::from_iter(iter),
+        }
+    }
+}
+
+impl IntoIterator for Exports {
+    type IntoIter = indexmap::map::IntoIter<String, Extern>;
+    type Item = (String, Extern);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a Exports {
+    type IntoIter = indexmap::map::Iter<'a, String, Extern>;
+    type Item = (&'a String, &'a Extern);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.iter()
+    }
+}
+
+/// This trait is used to mark types as gettable from an [`Instance`].
+///
+/// [`Instance`]: crate::Instance
+pub trait Exportable<'a>: Sized {
+    /// Implementation of how to get the export corresponding to the implementing type
+    /// from an [`Instance`] by name.
+    ///
+    /// [`Instance`]: crate::Instance
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError>;
+}
+
+/// A trait for accessing exports (like [`Exportable`]) but it takes generic
+/// `Args` and `Rets` parameters so that `TypedFunction` can be accessed directly
+/// as well.
+pub trait ExportableWithGenerics<'a, Args: WasmTypeList, Rets: WasmTypeList>: Sized {
+    /// Get an export with the given generics.
+    fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError>;
+}
+
+/// We implement it for all concrete [`Exportable`] types (that are `Clone`)
+/// with empty `Args` and `Rets`.
+impl<'a, T: Exportable<'a> + Clone + 'static> ExportableWithGenerics<'a, (), ()> for T {
+    fn get_self_from_extern_with_generics(_extern: &'a Extern) -> Result<Self, ExportError> {
+        T::get_self_from_extern(_extern).map(|i| i.clone())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/extern_ref.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/extern_ref.rs
new file mode 100644
index 0000000..038c7e4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/extern_ref.rs
@@ -0,0 +1,59 @@
+use std::any::Any;
+
+use crate::store::{AsStoreMut, AsStoreRef};
+
+#[cfg(feature = "js")]
+use crate::js::extern_ref as extern_ref_imp;
+#[cfg(feature = "jsc")]
+use crate::jsc::extern_ref as extern_ref_imp;
+#[cfg(feature = "sys")]
+use crate::sys::extern_ref as extern_ref_imp;
+use crate::vm::VMExternRef;
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+/// An opaque reference to some data. This reference can be passed through Wasm.
+pub struct ExternRef(pub(crate) extern_ref_imp::ExternRef);
+
+impl ExternRef {
+    /// Make a new extern reference
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        Self(extern_ref_imp::ExternRef::new(store, value))
+    }
+
+    /// Try to downcast to the given value.
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        self.0.downcast(store)
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        self.0.vm_externref()
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExternRef,
+    ) -> Self {
+        Self(extern_ref_imp::ExternRef::from_vm_externref(
+            store,
+            vm_externref,
+        ))
+    }
+
+    /// Checks whether this `ExternRef` can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/function.rs
new file mode 100644
index 0000000..70d18c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/function.rs
@@ -0,0 +1,468 @@
+#[cfg(feature = "js")]
+use crate::js::externals::function as function_impl;
+#[cfg(feature = "jsc")]
+use crate::jsc::externals::function as function_impl;
+#[cfg(feature = "sys")]
+use crate::sys::externals::function as function_impl;
+
+use crate::exports::{ExportError, Exportable};
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::vm::{VMExtern, VMExternFunction, VMFuncRef, VMFunctionCallback, VMTrampoline};
+use crate::{
+    Extern, FunctionEnv, FunctionEnvMut, FunctionType, RuntimeError, TypedFunction, Value,
+};
+use wasmer_types::RawValue;
+
+use crate::native_type::WasmTypeList;
+
+/// The `HostFunction` trait represents the set of functions that
+/// can be used as host function. To uphold this statement, it is
+/// necessary for a function to be transformed into a
+/// `VMFunctionCallback`.
+pub trait HostFunction<T, Args, Rets, Kind>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+    Kind: HostFunctionKind,
+{
+    /// Get the pointer to the function body.
+    fn function_callback(&self) -> VMFunctionCallback;
+
+    /// Get the pointer to the function call trampoline.
+    fn call_trampoline_address() -> VMTrampoline {
+        // This is not implemented in JS
+        unimplemented!();
+    }
+}
+
+/// Empty trait to specify the kind of `HostFunction`: With or
+/// without an environment.
+///
+/// This trait is never aimed to be used by a user. It is used by
+/// the trait system to automatically generate the appropriate
+/// host functions.
+#[doc(hidden)]
+pub trait HostFunctionKind: private::HostFunctionKindSealed {}
+
+/// An empty struct to help Rust typing to determine
+/// when a `HostFunction` does have an environment.
+pub struct WithEnv;
+
+impl HostFunctionKind for WithEnv {}
+
+/// An empty struct to help Rust typing to determine
+/// when a `HostFunction` does not have an environment.
+pub struct WithoutEnv;
+
+impl HostFunctionKind for WithoutEnv {}
+
+mod private {
+    //! Sealing the HostFunctionKind because it shouldn't be implemented
+    //! by any type outside.
+    //! See:
+    //! <https://rust-lang.github.io/api-guidelines/future-proofing.html#c-sealed>
+    pub trait HostFunctionKindSealed {}
+    impl HostFunctionKindSealed for super::WithEnv {}
+    impl HostFunctionKindSealed for super::WithoutEnv {}
+}
+
+/// A WebAssembly `function` instance.
+///
+/// A function instance is the runtime representation of a function.
+/// It effectively is a closure of the original function (defined in either
+/// the host or the WebAssembly module) over the runtime `Instance` of its
+/// originating `Module`.
+///
+/// The module instance is used to resolve references to other definitions
+/// during execution of the function.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#function-instances>
+///
+/// # Panics
+/// - Closures (functions with captured environments) are not currently supported
+///   with native functions. Attempting to create a native `Function` with one will
+///   result in a panic.
+///   [Closures as host functions tracking issue](https://github.com/wasmerio/wasmer/issues/1840)
+#[derive(Debug, Clone, PartialEq)]
+pub struct Function(pub(crate) function_impl::Function);
+
+impl Function {
+    /// Creates a new host `Function` (dynamic) with the provided signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Function::new_typed`] for less runtime overhead.
+    pub fn new<FT, F>(store: &mut impl AsStoreMut, ty: FT, func: F) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(&[Value]) -> Result<Vec<Value>, RuntimeError> + 'static + Send + Sync,
+    {
+        let env = FunctionEnv::new(&mut store.as_store_mut(), ());
+        let wrapped_func = move |_env: FunctionEnvMut<()>,
+                                 args: &[Value]|
+              -> Result<Vec<Value>, RuntimeError> { func(args) };
+        Self::new_with_env(store, &env, ty, wrapped_func)
+    }
+
+    /// Creates a new host `Function` (dynamic) with the provided signature.
+    ///
+    /// If you know the signature of the host function at compile time,
+    /// consider using [`Function::new_typed_with_env`] for less runtime overhead.
+    ///
+    /// Takes a [`FunctionEnv`] that is passed into func. If that is not required,
+    /// [`Function::new`] might be an option as well.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionType, Type, Store, Value};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// let signature = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]);
+    ///
+    /// let f = Function::new_with_env(&mut store, &env, &signature, |_env, args| {
+    ///     let sum = args[0].unwrap_i32() + args[1].unwrap_i32();
+    ///     Ok(vec![Value::I32(sum)])
+    /// });
+    /// ```
+    ///
+    /// With constant signature:
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionType, Type, Store, Value};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// const I32_I32_TO_I32: ([Type; 2], [Type; 1]) = ([Type::I32, Type::I32], [Type::I32]);
+    ///
+    /// let f = Function::new_with_env(&mut store, &env, I32_I32_TO_I32, |_env, args| {
+    ///     let sum = args[0].unwrap_i32() + args[1].unwrap_i32();
+    ///     Ok(vec![Value::I32(sum)])
+    /// });
+    /// ```
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        Self(function_impl::Function::new_with_env(store, env, ty, func))
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        Self(function_impl::Function::new_typed(store, func))
+    }
+
+    /// Creates a new host `Function` with an environment from a typed function.
+    ///
+    /// The function signature is automatically retrieved using the
+    /// Rust typing system.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Store, Function, FunctionEnv, FunctionEnvMut};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    /// ```
+    pub fn new_typed_with_env<T: Send + 'static, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        Self(function_impl::Function::new_typed_with_env(
+            store, env, func,
+        ))
+    }
+
+    /// Returns the [`FunctionType`] of the `Function`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.ty(&mut store).params(), vec![Type::I32, Type::I32]);
+    /// assert_eq!(f.ty(&mut store).results(), vec![Type::I32]);
+    /// ```
+    pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
+        self.0.ty(store)
+    }
+
+    /// Returns the number of parameters that this function takes.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.param_arity(&mut store), 2);
+    /// ```
+    pub fn param_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).params().len()
+    }
+
+    /// Returns the number of results this function produces.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Function, FunctionEnv, FunctionEnvMut, Store, Type};
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// fn sum(_env: FunctionEnvMut<()>, a: i32, b: i32) -> i32 {
+    ///     a + b
+    /// }
+    ///
+    /// let f = Function::new_typed_with_env(&mut store, &env, sum);
+    ///
+    /// assert_eq!(f.result_arity(&mut store), 1);
+    /// ```
+    pub fn result_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).results().len()
+    }
+
+    /// Call the `Function` function.
+    ///
+    /// Depending on where the Function is defined, it will call it.
+    /// 1. If the function is defined inside a WebAssembly, it will call the trampoline
+    ///    for the function signature.
+    /// 2. If the function is defined in the host (in a native way), it will
+    ///    call the trampoline.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// assert_eq!(sum.call(&mut store, &[Value::I32(1), Value::I32(2)]).unwrap().to_vec(), vec![Value::I32(3)]);
+    /// ```
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        self.0.call(store, params)
+    }
+
+    #[doc(hidden)]
+    #[allow(missing_docs)]
+    pub fn call_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        self.0.call_raw(store, params)
+    }
+
+    pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
+        self.0.vm_funcref(store)
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
+        Self(function_impl::Function::from_vm_funcref(store, funcref))
+    }
+
+    /// Transform this WebAssembly function into a typed function.
+    /// See [`TypedFunction`] to learn more.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    /// let sum_typed: TypedFunction<(i32, i32), i32> = sum.typed(&mut store).unwrap();
+    ///
+    /// assert_eq!(sum_typed.call(&mut store, 1, 2).unwrap(), 3);
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// If the `Args` generic parameter does not match the exported function
+    /// an error will be raised:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// // This results in an error: `RuntimeError`
+    /// let sum_typed : TypedFunction<(i64, i64), i32> = sum.typed(&mut store).unwrap();
+    /// ```
+    ///
+    /// If the `Rets` generic parameter does not match the exported function
+    /// an error will be raised:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{imports, wat2wasm, Function, Instance, Module, Store, Type, TypedFunction, Value};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// # let wasm_bytes = wat2wasm(r#"
+    /// # (module
+    /// #   (func (export "sum") (param $x i32) (param $y i32) (result i32)
+    /// #     local.get $x
+    /// #     local.get $y
+    /// #     i32.add
+    /// #   ))
+    /// # "#.as_bytes()).unwrap();
+    /// # let module = Module::new(&store, wasm_bytes).unwrap();
+    /// # let import_object = imports! {};
+    /// # let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+    /// #
+    /// let sum = instance.exports.get_function("sum").unwrap();
+    ///
+    /// // This results in an error: `RuntimeError`
+    /// let sum_typed: TypedFunction<(i32, i32), i64> = sum.typed(&mut store).unwrap();
+    /// ```
+    pub fn typed<Args, Rets>(
+        &self,
+        store: &impl AsStoreRef,
+    ) -> Result<TypedFunction<Args, Rets>, RuntimeError>
+    where
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let ty = self.ty(store);
+
+        // type check
+        {
+            let expected = ty.params();
+            let given = Args::wasm_types();
+
+            if expected != given {
+                return Err(RuntimeError::new(format!(
+                    "given types (`{:?}`) for the function arguments don't match the actual types (`{:?}`)",
+                    given,
+                    expected,
+                )));
+            }
+        }
+
+        {
+            let expected = ty.results();
+            let given = Rets::wasm_types();
+
+            if expected != given {
+                // todo: error result types don't match
+                return Err(RuntimeError::new(format!(
+                    "given types (`{:?}`) for the function results don't match the actual types (`{:?}`)",
+                    given,
+                    expected,
+                )));
+            }
+        }
+
+        Ok(TypedFunction::new(store, self.clone()))
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternFunction) -> Self {
+        Self(function_impl::Function::from_vm_extern(store, vm_extern))
+    }
+
+    /// Checks whether this `Function` can be used with the given store.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl std::cmp::Eq for Function {}
+
+impl<'a> Exportable<'a> for Function {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Function(func) => Ok(func),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/global.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/global.rs
new file mode 100644
index 0000000..3420562
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/global.rs
@@ -0,0 +1,175 @@
+use crate::exports::{ExportError, Exportable};
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::VMExtern;
+use crate::vm::VMExternGlobal;
+use crate::Extern;
+use crate::GlobalType;
+use crate::Mutability;
+use crate::RuntimeError;
+
+#[cfg(feature = "js")]
+use crate::js::externals::global as global_impl;
+#[cfg(feature = "jsc")]
+use crate::jsc::externals::global as global_impl;
+#[cfg(feature = "sys")]
+use crate::sys::externals::global as global_impl;
+
+/// A WebAssembly `global` instance.
+///
+/// A global instance is the runtime representation of a global variable.
+/// It consists of an individual value and a flag indicating whether it is mutable.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#global-instances>
+#[derive(Debug, Clone, PartialEq)]
+pub struct Global(pub(crate) global_impl::Global);
+
+impl Global {
+    /// Create a new `Global` with the initial value [`Value`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// assert_eq!(g.ty(&mut store).mutability, Mutability::Const);
+    /// ```
+    pub fn new(store: &mut impl AsStoreMut, val: Value) -> Self {
+        Self::from_value(store, val, Mutability::Const).unwrap()
+    }
+
+    /// Create a mutable `Global` with the initial value [`Value`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new_mut(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// assert_eq!(g.ty(&mut store).mutability, Mutability::Var);
+    /// ```
+    pub fn new_mut(store: &mut impl AsStoreMut, val: Value) -> Self {
+        Self::from_value(store, val, Mutability::Var).unwrap()
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        Ok(Self(global_impl::Global::from_value(
+            store, val, mutability,
+        )?))
+    }
+
+    /// Returns the [`GlobalType`] of the `Global`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Mutability, Store, Type, Value, GlobalType};
+    /// # let mut store = Store::default();
+    /// #
+    /// let c = Global::new(&mut store, Value::I32(1));
+    /// let v = Global::new_mut(&mut store, Value::I64(1));
+    ///
+    /// assert_eq!(c.ty(&mut store), GlobalType::new(Type::I32, Mutability::Const));
+    /// assert_eq!(v.ty(&mut store), GlobalType::new(Type::I64, Mutability::Var));
+    /// ```
+    pub fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
+        self.0.ty(store)
+    }
+
+    /// Retrieves the current value [`Value`] that the Global has.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    /// ```
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        self.0.get(store)
+    }
+
+    /// Sets a custom value [`Value`] to the runtime Global.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new_mut(&mut store, Value::I32(1));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(1));
+    ///
+    /// g.set(&mut store, Value::I32(2));
+    ///
+    /// assert_eq!(g.get(&mut store), Value::I32(2));
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Trying to mutate a immutable global will raise an error:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// g.set(&mut store, Value::I32(2)).unwrap();
+    /// ```
+    ///
+    /// Trying to set a value of a incompatible type will raise an error:
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Global, Store, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let g = Global::new(&mut store, Value::I32(1));
+    ///
+    /// // This results in an error: `RuntimeError`.
+    /// g.set(&mut store, Value::I64(2)).unwrap();
+    /// ```
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        self.0.set(store, val)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternGlobal) -> Self {
+        Self(global_impl::Global::from_vm_extern(store, vm_extern))
+    }
+
+    /// Checks whether this `Global` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl std::cmp::Eq for Global {}
+
+impl<'a> Exportable<'a> for Global {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Global(global) => Ok(global),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory.rs
new file mode 100644
index 0000000..3e2b07e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory.rs
@@ -0,0 +1,363 @@
+#[cfg(feature = "js")]
+use crate::js::externals::memory as memory_impl;
+#[cfg(feature = "jsc")]
+use crate::jsc::externals::memory as memory_impl;
+#[cfg(feature = "sys")]
+use crate::sys::externals::memory as memory_impl;
+
+use super::memory_view::MemoryView;
+use crate::exports::{ExportError, Exportable};
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::vm::{VMExtern, VMExternMemory, VMMemory};
+use crate::MemoryAccessError;
+use crate::MemoryType;
+use crate::{AtomicsError, Extern};
+use std::mem::MaybeUninit;
+use wasmer_types::{MemoryError, Pages};
+
+/// A WebAssembly `memory` instance.
+///
+/// A memory instance is the runtime representation of a linear memory.
+/// It consists of a vector of bytes and an optional maximum size.
+///
+/// The length of the vector always is a multiple of the WebAssembly
+/// page size, which is defined to be the constant 65536 – abbreviated 64Ki.
+/// Like in a memory type, the maximum size in a memory instance is
+/// given in units of this page size.
+///
+/// A memory created by the host or in WebAssembly code will be accessible and
+/// mutable from both host and WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#memory-instances>
+#[derive(Debug, Clone, PartialEq)]
+pub struct Memory(pub(crate) memory_impl::Memory);
+
+impl Memory {
+    /// Creates a new host `Memory` from the provided [`MemoryType`].
+    ///
+    /// This function will construct the `Memory` using the store
+    /// `BaseTunables`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    /// ```
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        Ok(Self(memory_impl::Memory::new(store, ty)?))
+    }
+
+    /// Create a memory object from an existing memory and attaches it to the store
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self(memory_impl::Memory::new_from_existing(new_store, memory))
+    }
+
+    /// Returns the [`MemoryType`] of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let mt = MemoryType::new(1, None, false);
+    /// let m = Memory::new(&mut store, mt).unwrap();
+    ///
+    /// assert_eq!(m.ty(&mut store), mt);
+    /// ```
+    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        self.0.ty(store)
+    }
+
+    /// Creates a view into the memory that then allows for
+    /// read and write
+    pub fn view<'a>(&self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    /// Grow memory by the specified amount of WebAssembly [`Pages`] and return
+    /// the previous memory size.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(3), false)).unwrap();
+    /// let p = m.grow(&mut store, 2).unwrap();
+    ///
+    /// assert_eq!(p, Pages(1));
+    /// assert_eq!(m.view(&mut store).size(), Pages(3));
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if memory can't be grown by the specified amount
+    /// of pages.
+    ///
+    /// ```should_panic
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value, WASM_MAX_PAGES};
+    /// # use wasmer::FunctionEnv;
+    /// # let mut store = Store::default();
+    /// # let env = FunctionEnv::new(&mut store, ());
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, Some(1), false)).unwrap();
+    ///
+    /// // This results in an error: `MemoryError::CouldNotGrow`.
+    /// let s = m.grow(&mut store, 1).unwrap();
+    /// ```
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        self.0.grow(store, delta)
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        self.0.grow_at_least(store, min_size)
+    }
+
+    /// Resets the memory back to zero length
+    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        self.0.reset(store)?;
+        Ok(())
+    }
+
+    /// Attempts to duplicate this memory (if its clonable) in a new store
+    /// (copied memory)
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        if !self.ty(store).shared {
+            // We should only be able to duplicate in a new store if the memory is shared
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
+        }
+        self.0
+            .try_copy(&store)
+            .map(|new_memory| Self::new_from_existing(new_store, new_memory.into()))
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternMemory) -> Self {
+        Self(memory_impl::Memory::from_vm_extern(store, vm_extern))
+    }
+
+    /// Checks whether this `Memory` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.0.try_clone(store)
+    }
+
+    /// Attempts to clone this memory (if its clonable) in a new store
+    /// (cloned memory will be shared between those that clone it)
+    pub fn share_in_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        if !self.ty(store).shared {
+            // We should only be able to duplicate in a new store if the memory is shared
+            return Err(MemoryError::InvalidMemory {
+                reason: "memory is not a shared memory type".to_string(),
+            });
+        }
+        self.0
+            .try_clone(&store)
+            .map(|new_memory| Self::new_from_existing(new_store, new_memory))
+    }
+
+    /// Get a [`SharedMemory`].
+    ///
+    /// Only returns `Some(_)` if the memory is shared, and if the target
+    /// backend supports shared memory operations.
+    ///
+    /// See [`SharedMemory`] and its methods for more information.
+    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<SharedMemory> {
+        if !self.ty(store).shared {
+            return None;
+        }
+        self.0.as_shared(store)
+    }
+
+    /// To `VMExtern`.
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+impl<'a> Exportable<'a> for Memory {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Memory(memory) => Ok(memory),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
+
+/// Location in a WebAssembly memory.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct MemoryLocation {
+    // NOTE: must be expanded to an enum that also supports 64bit memory in
+    // the future
+    // That's why this is private.
+    pub(crate) address: u32,
+}
+
+impl MemoryLocation {
+    /// Create a new memory location for a 32bit memory.
+    pub fn new_32(address: u32) -> Self {
+        Self { address }
+    }
+}
+
+impl From<u32> for MemoryLocation {
+    fn from(value: u32) -> Self {
+        Self::new_32(value)
+    }
+}
+
+/// See [`SharedMemory`].
+pub(crate) trait SharedMemoryOps {
+    /// See [`SharedMemory::disable_atomics`].
+    fn disable_atomics(&self) -> Result<(), MemoryError> {
+        Err(MemoryError::AtomicsNotSupported)
+    }
+
+    /// See [`SharedMemory::wake_all_atomic_waiters`].
+    fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
+        Err(MemoryError::AtomicsNotSupported)
+    }
+
+    /// See [`SharedMemory::notify`].
+    fn notify(&self, _dst: MemoryLocation, _count: u32) -> Result<u32, AtomicsError> {
+        Err(AtomicsError::Unimplemented)
+    }
+
+    /// See [`SharedMemory::wait`].
+    fn wait(
+        &self,
+        _dst: MemoryLocation,
+        _timeout: Option<std::time::Duration>,
+    ) -> Result<u32, AtomicsError> {
+        Err(AtomicsError::Unimplemented)
+    }
+}
+
+/// A handle that exposes operations only relevant for shared memories.
+///
+/// Enables interaction independent from the [`crate::Store`], and thus allows calling
+/// some methods an instane is running.
+///
+/// **NOTE**: Not all methods are supported by all backends.
+#[derive(Clone)]
+pub struct SharedMemory {
+    memory: Memory,
+    ops: std::sync::Arc<dyn SharedMemoryOps + Send + Sync>,
+}
+
+impl std::fmt::Debug for SharedMemory {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SharedMemory").finish()
+    }
+}
+
+impl SharedMemory {
+    /// Get the underlying memory.
+    pub fn memory(&self) -> &Memory {
+        &self.memory
+    }
+
+    /// Create a new handle from ops.
+    #[allow(unused)]
+    pub(crate) fn new(memory: Memory, ops: impl SharedMemoryOps + Send + Sync + 'static) -> Self {
+        Self {
+            memory,
+            ops: std::sync::Arc::new(ops),
+        }
+    }
+
+    /// Notify up to `count` waiters waiting for the memory location.
+    pub fn notify(&self, location: MemoryLocation, count: u32) -> Result<u32, AtomicsError> {
+        self.ops.notify(location, count)
+    }
+
+    /// Wait for the memory location to be notified.
+    pub fn wait(
+        &self,
+        location: MemoryLocation,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<u32, AtomicsError> {
+        self.ops.wait(location, timeout)
+    }
+
+    /// Disable atomics for this memory.
+    ///
+    /// All subsequent atomic wait calls will produce a trap.
+    ///
+    /// This can be used or forced shutdown of instances that continuously try
+    /// to wait on atomics.
+    ///
+    /// NOTE: this operation might not be supported by all memory implementations.
+    /// In that case, this function will return an error.
+    pub fn disable_atomics(&self) -> Result<(), MemoryError> {
+        self.ops.disable_atomics()
+    }
+
+    /// Wake up all atomic waiters.
+    ///
+    /// This can be used to force-resume waiting execution.
+    ///
+    /// NOTE: this operation might not be supported by all memory implementations.
+    /// In that case, this function will return an error.
+    pub fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
+        self.ops.wake_all_atomic_waiters()
+    }
+}
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a>(pub(crate) memory_impl::MemoryBuffer<'a>);
+
+impl<'a> MemoryBuffer<'a> {
+    #[allow(unused)]
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.0.read(offset, buf)
+    }
+
+    #[allow(unused)]
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.0.read_uninit(offset, buf)
+    }
+
+    #[allow(unused)]
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.0.write(offset, data)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory_view.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory_view.rs
new file mode 100644
index 0000000..1fbda5c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/memory_view.rs
@@ -0,0 +1,183 @@
+use super::memory::{Memory, MemoryBuffer};
+use crate::store::AsStoreRef;
+use crate::MemoryAccessError;
+use std::mem::MaybeUninit;
+use std::ops::Range;
+use wasmer_types::Pages;
+
+#[cfg(feature = "js")]
+use crate::js::externals::memory_view as memory_view_impl;
+#[cfg(feature = "jsc")]
+use crate::jsc::externals::memory_view as memory_view_impl;
+#[cfg(feature = "sys")]
+use crate::sys::externals::memory_view as memory_view_impl;
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.view() method.
+#[derive(Debug)]
+pub struct MemoryView<'a>(pub(crate) memory_view_impl::MemoryView<'a>);
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        MemoryView(memory_view_impl::MemoryView::new(&memory.0, store))
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.0.data_ptr()
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.0.data_size()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.0.data_unchecked()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        self.0.data_unchecked_mut()
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        self.0.size()
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        MemoryBuffer(self.0.buffer())
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.0.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        self.0.read_u8(offset)
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.0.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.0.write(offset, data)
+    }
+
+    /// Safely writes a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        self.0.write_u8(offset, val)
+    }
+
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/mod.rs
new file mode 100644
index 0000000..c5b46e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/mod.rs
@@ -0,0 +1,128 @@
+pub(crate) mod function;
+mod global;
+pub(crate) mod memory;
+mod memory_view;
+mod table;
+
+pub use self::function::{Function, HostFunction};
+pub use self::global::Global;
+pub use self::memory::{Memory, MemoryLocation, SharedMemory};
+pub use self::memory_view::MemoryView;
+pub use self::table::Table;
+
+use crate::exports::{ExportError, Exportable};
+use crate::ExternType;
+use std::fmt;
+
+#[cfg(feature = "js")]
+use crate::js::vm::VMExtern;
+#[cfg(feature = "jsc")]
+use crate::jsc::vm::VMExtern;
+#[cfg(feature = "sys")]
+use wasmer_vm::VMExtern;
+
+use crate::store::{AsStoreMut, AsStoreRef};
+
+/// An `Extern` is the runtime representation of an entity that
+/// can be imported or exported.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#external-values>
+#[derive(Clone, PartialEq, Eq)]
+pub enum Extern {
+    /// A external [`Function`].
+    Function(Function),
+    /// A external [`Global`].
+    Global(Global),
+    /// A external [`Table`].
+    Table(Table),
+    /// A external [`Memory`].
+    Memory(Memory),
+}
+
+impl Extern {
+    /// Return the underlying type of the inner `Extern`.
+    pub fn ty(&self, store: &impl AsStoreRef) -> ExternType {
+        match self {
+            Self::Function(ft) => ExternType::Function(ft.ty(store)),
+            Self::Memory(ft) => ExternType::Memory(ft.ty(store)),
+            Self::Table(tt) => ExternType::Table(tt.ty(store)),
+            Self::Global(gt) => ExternType::Global(gt.ty(store)),
+        }
+    }
+
+    /// Create an `Extern` from an `wasmer_engine::Export`.
+    pub fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExtern) -> Self {
+        match vm_extern {
+            VMExtern::Function(f) => Self::Function(Function::from_vm_extern(store, f)),
+            VMExtern::Memory(m) => Self::Memory(Memory::from_vm_extern(store, m)),
+            VMExtern::Global(g) => Self::Global(Global::from_vm_extern(store, g)),
+            VMExtern::Table(t) => Self::Table(Table::from_vm_extern(store, t)),
+        }
+    }
+
+    /// Checks whether this `Extern` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match self {
+            Self::Function(f) => f.is_from_store(store),
+            Self::Global(g) => g.is_from_store(store),
+            Self::Memory(m) => m.is_from_store(store),
+            Self::Table(t) => t.is_from_store(store),
+        }
+    }
+
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        match self {
+            Self::Function(f) => f.to_vm_extern(),
+            Self::Global(g) => g.to_vm_extern(),
+            Self::Memory(m) => m.to_vm_extern(),
+            Self::Table(t) => t.to_vm_extern(),
+        }
+    }
+}
+
+impl<'a> Exportable<'a> for Extern {
+    fn get_self_from_extern(_extern: &'a Self) -> Result<&'a Self, ExportError> {
+        // Since this is already an extern, we can just return it.
+        Ok(_extern)
+    }
+}
+
+impl fmt::Debug for Extern {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::Function(_) => "Function(...)",
+                Self::Global(_) => "Global(...)",
+                Self::Memory(_) => "Memory(...)",
+                Self::Table(_) => "Table(...)",
+            }
+        )
+    }
+}
+
+impl From<Function> for Extern {
+    fn from(r: Function) -> Self {
+        Self::Function(r)
+    }
+}
+
+impl From<Global> for Extern {
+    fn from(r: Global) -> Self {
+        Self::Global(r)
+    }
+}
+
+impl From<Memory> for Extern {
+    fn from(r: Memory) -> Self {
+        Self::Memory(r)
+    }
+}
+
+impl From<Table> for Extern {
+    fn from(r: Table) -> Self {
+        Self::Table(r)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/table.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/table.rs
new file mode 100644
index 0000000..49eb389
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/externals/table.rs
@@ -0,0 +1,145 @@
+#[cfg(feature = "js")]
+use crate::js::externals::table as table_impl;
+#[cfg(feature = "jsc")]
+use crate::jsc::externals::table as table_impl;
+#[cfg(feature = "sys")]
+use crate::sys::externals::table as table_impl;
+
+use crate::exports::{ExportError, Exportable};
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::vm::{VMExtern, VMExternTable};
+use crate::Extern;
+use crate::RuntimeError;
+use crate::TableType;
+use crate::Value;
+
+/// A WebAssembly `table` instance.
+///
+/// The `Table` struct is an array-like structure representing a WebAssembly Table,
+/// which stores function references.
+///
+/// A table created by the host or in WebAssembly code will be accessible and
+/// mutable from both host and WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#table-instances>
+#[derive(Debug, Clone, PartialEq)]
+pub struct Table(pub(crate) table_impl::Table);
+
+impl Table {
+    /// Creates a new `Table` with the provided [`TableType`] definition.
+    ///
+    /// All the elements in the table will be set to the `init` value.
+    ///
+    /// This function will construct the `Table` using the store `BaseTunables`.
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        Ok(Self(table_impl::Table::new(store, ty, init)?))
+    }
+
+    /// Returns the [`TableType`] of the `Table`.
+    pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
+        self.0.ty(store)
+    }
+
+    /// Retrieves an element of the table at the provided `index`.
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        self.0.get(store, index)
+    }
+
+    /// Sets an element `val` in the Table at the provided `index`.
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        self.0.set(store, index, val)
+    }
+
+    /// Retrieves the size of the `Table` (in elements)
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        self.0.size(store)
+    }
+
+    /// Grows the size of the `Table` by `delta`, initializating
+    /// the elements with the provided `init` value.
+    ///
+    /// It returns the previous size of the `Table` in case is able
+    /// to grow the Table successfully.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `delta` is out of bounds for the table.
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        self.0.grow(store, delta, init)
+    }
+
+    /// Copies the `len` elements of `src_table` starting at `src_index`
+    /// to the destination table `dst_table` at index `dst_index`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables.
+    pub fn copy(
+        store: &mut impl AsStoreMut,
+        dst_table: &Self,
+        dst_index: u32,
+        src_table: &Self,
+        src_index: u32,
+        len: u32,
+    ) -> Result<(), RuntimeError> {
+        table_impl::Table::copy(store, &dst_table.0, dst_index, &src_table.0, src_index, len)
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, extern_: VMExternTable) -> Self {
+        Self(table_impl::Table::from_vm_extern(store, extern_))
+    }
+
+    /// Checks whether this `Table` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.0.is_from_store(store)
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        self.0.to_vm_extern()
+    }
+}
+
+impl std::cmp::Eq for Table {}
+
+impl<'a> Exportable<'a> for Table {
+    fn get_self_from_extern(_extern: &'a Extern) -> Result<&'a Self, ExportError> {
+        match _extern {
+            Extern::Table(table) => Ok(table),
+            _ => Err(ExportError::IncompatibleType),
+        }
+    }
+}
+
+/// Check the example from <https://github.com/wasmerio/wasmer/issues/3197>.
+#[test]
+fn test_table_grow_issue_3197() {
+    use crate::{imports, Instance, Module, Store, Table, TableType, Type, Value};
+
+    const WAT: &str = r#"(module (table (import "env" "table") 100 funcref))"#;
+
+    // Tests that the table type of `table` is compatible with the export in the WAT
+    // This tests that `wasmer_types::types::is_table_compatible` works as expected.
+    let mut store = Store::default();
+    let module = Module::new(&store, WAT).unwrap();
+    let ty = TableType::new(Type::FuncRef, 0, None);
+    let table = Table::new(&mut store, ty, Value::FuncRef(None)).unwrap();
+    table.grow(&mut store, 100, Value::FuncRef(None)).unwrap();
+    assert_eq!(table.ty(&store).minimum, 0);
+    let imports = imports! {"env" => {"table" => table}};
+    let _instance = Instance::new(&mut store, &module, &imports).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/function_env.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/function_env.rs
new file mode 100644
index 0000000..89c1de7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/function_env.rs
@@ -0,0 +1,168 @@
+use std::{any::Any, fmt::Debug, marker::PhantomData};
+
+use crate::vm::VMFunctionEnvironment;
+
+use crate::store::{AsStoreMut, AsStoreRef, StoreHandle, StoreMut, StoreObjects, StoreRef};
+
+#[derive(Debug)]
+#[repr(transparent)]
+/// An opaque reference to a function environment.
+/// The function environment data is owned by the `Store`.
+pub struct FunctionEnv<T> {
+    pub(crate) handle: StoreHandle<VMFunctionEnvironment>,
+    marker: PhantomData<T>,
+}
+
+impl<T> FunctionEnv<T> {
+    /// Make a new FunctionEnv
+    pub fn new(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(
+                store.as_store_mut().objects_mut(),
+                VMFunctionEnvironment::new(value),
+            ),
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as reference
+    pub fn as_ref<'a>(&self, store: &'a impl AsStoreRef) -> &'a T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects())
+            .as_ref()
+            .downcast_ref::<T>()
+            .unwrap()
+    }
+
+    #[allow(dead_code)] // This function is only used in js
+    pub(crate) fn from_handle(handle: StoreHandle<VMFunctionEnvironment>) -> Self {
+        Self {
+            handle,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the data as mutable
+    pub fn as_mut<'a>(&self, store: &'a mut impl AsStoreMut) -> &'a mut T
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        self.handle
+            .get_mut(store.objects_mut())
+            .as_mut()
+            .downcast_mut::<T>()
+            .unwrap()
+    }
+
+    /// Convert it into a `FunctionEnvMut`
+    pub fn into_mut(self, store: &mut impl AsStoreMut) -> FunctionEnvMut<T>
+    where
+        T: Any + Send + 'static + Sized,
+    {
+        FunctionEnvMut {
+            store_mut: store.as_store_mut(),
+            func_env: self,
+        }
+    }
+}
+
+impl<T> PartialEq for FunctionEnv<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl<T> Eq for FunctionEnv<T> {}
+
+impl<T> std::hash::Hash for FunctionEnv<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.handle.hash(state);
+        self.marker.hash(state);
+    }
+}
+
+impl<T> Clone for FunctionEnv<T> {
+    fn clone(&self) -> Self {
+        Self {
+            handle: self.handle.clone(),
+            marker: self.marker,
+        }
+    }
+}
+
+/// A temporary handle to a [`FunctionEnv`].
+pub struct FunctionEnvMut<'a, T: 'a> {
+    pub(crate) store_mut: StoreMut<'a>,
+    pub(crate) func_env: FunctionEnv<T>,
+}
+
+impl<'a, T> Debug for FunctionEnvMut<'a, T>
+where
+    T: Send + Debug + 'static,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.func_env.as_ref(&self.store_mut).fmt(f)
+    }
+}
+
+impl<T: Send + 'static> FunctionEnvMut<'_, T> {
+    /// Returns a reference to the host state in this function environement.
+    pub fn data(&self) -> &T {
+        self.func_env.as_ref(&self.store_mut)
+    }
+
+    /// Returns a mutable- reference to the host state in this function environement.
+    pub fn data_mut(&mut self) -> &mut T {
+        self.func_env.as_mut(&mut self.store_mut)
+    }
+
+    /// Borrows a new immmutable reference
+    pub fn as_ref(&self) -> FunctionEnv<T> {
+        self.func_env.clone()
+    }
+
+    /// Borrows a new mutable reference
+    pub fn as_mut(&mut self) -> FunctionEnvMut<'_, T> {
+        FunctionEnvMut {
+            store_mut: self.store_mut.as_store_mut(),
+            func_env: self.func_env.clone(),
+        }
+    }
+
+    /// Borrows a new mutable reference of both the attached Store and host state
+    pub fn data_and_store_mut(&mut self) -> (&mut T, StoreMut) {
+        let data = self.func_env.as_mut(&mut self.store_mut) as *mut T;
+        // telling the borrow check to close his eyes here
+        // this is still relatively safe to do as func_env are
+        // stored in a specific vec of Store, separate from the other objects
+        // and not really directly accessible with the StoreMut
+        let data = unsafe { &mut *data };
+        (data, self.store_mut.as_store_mut())
+    }
+}
+
+impl<T> AsStoreRef for FunctionEnvMut<'_, T> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef {
+            inner: self.store_mut.inner,
+        }
+    }
+}
+
+impl<T> AsStoreMut for FunctionEnvMut<'_, T> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: self.store_mut.inner,
+        }
+    }
+    #[inline]
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.store_mut.inner.objects
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/imports.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/imports.rs
new file mode 100644
index 0000000..344bc24
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/imports.rs
@@ -0,0 +1,476 @@
+//! The import module contains the implementation data structures and helper functions used to
+//! manipulate and access a wasm module's imports including memories, tables, globals, and
+//! functions.
+use crate::{Exports, Extern, LinkError, Module};
+use std::collections::HashMap;
+use std::fmt;
+use wasmer_types::ImportError;
+
+/// All of the import data used when instantiating.
+///
+/// It's suggested that you use the [`imports!`] macro
+/// instead of creating an `Imports` by hand.
+///
+/// [`imports!`]: macro.imports.html
+///
+/// # Usage:
+/// ```no_run
+/// use wasmer::{Store, Exports, Module, Instance, imports, Imports, Function, FunctionEnvMut};
+/// # fn foo_test(mut store: &mut Store, module: Module) {
+///
+/// let host_fn = Function::new_typed(&mut store, foo);
+/// let import_object: Imports = imports! {
+///     "env" => {
+///         "foo" => host_fn,
+///     },
+/// };
+///
+/// let instance = Instance::new(&mut store, &module, &import_object).expect("Could not instantiate module.");
+///
+/// fn foo(n: i32) -> i32 {
+///     n
+/// }
+///
+/// # }
+/// ```
+#[derive(Clone, Default)]
+pub struct Imports {
+    pub(crate) map: HashMap<(String, String), Extern>,
+}
+
+impl Imports {
+    /// Create a new `Imports`.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Gets an export given a module and a name
+    ///
+    /// # Usage
+    /// ```no_run
+    /// # use wasmer::Imports;
+    /// let mut import_object = Imports::new();
+    /// import_object.get_export("module", "name");
+    /// ```
+    pub fn get_export(&self, module: &str, name: &str) -> Option<Extern> {
+        if self.exists(module, name) {
+            let ext = &self.map[&(module.to_string(), name.to_string())];
+            return Some(ext.clone());
+        }
+        None
+    }
+
+    /// Returns if an export exist for a given module and name.
+    ///
+    /// # Usage
+    /// ```no_run
+    /// # use wasmer::Imports;
+    /// let mut import_object = Imports::new();
+    /// import_object.exists("module", "name");
+    /// ```
+    pub fn exists(&self, module: &str, name: &str) -> bool {
+        self.map
+            .contains_key(&(module.to_string(), name.to_string()))
+    }
+
+    /// Returns true if the Imports contains namespace with the provided name.
+    pub fn contains_namespace(&self, name: &str) -> bool {
+        self.map.keys().any(|(k, _)| (k == name))
+    }
+
+    /// Register a list of externs into a namespace.
+    ///
+    /// # Usage:
+    /// ```no_run
+    /// # use wasmer::{Imports, Exports, Memory};
+    /// # fn foo_test(memory: Memory) {
+    /// let mut exports = Exports::new();
+    /// exports.insert("memory", memory);
+    ///
+    /// let mut import_object = Imports::new();
+    /// import_object.register_namespace("env", exports);
+    /// // ...
+    /// # }
+    /// ```
+    pub fn register_namespace(
+        &mut self,
+        ns: &str,
+        contents: impl IntoIterator<Item = (String, Extern)>,
+    ) {
+        for (name, extern_) in contents.into_iter() {
+            self.map.insert((ns.to_string(), name.clone()), extern_);
+        }
+    }
+
+    /// Add a single import with a namespace `ns` and name `name`.
+    ///
+    /// # Usage
+    /// ```no_run
+    /// # use wasmer::{FunctionEnv, Store};
+    /// # let mut store: Store = Default::default();
+    /// use wasmer::{StoreMut, Imports, Function, FunctionEnvMut};
+    /// fn foo(n: i32) -> i32 {
+    ///     n
+    /// }
+    /// let mut import_object = Imports::new();
+    /// import_object.define("env", "foo", Function::new_typed(&mut store, foo));
+    /// ```
+    pub fn define(&mut self, ns: &str, name: &str, val: impl Into<Extern>) {
+        self.map
+            .insert((ns.to_string(), name.to_string()), val.into());
+    }
+
+    /// Returns the contents of a namespace as an `Exports`.
+    ///
+    /// Returns `None` if the namespace doesn't exist.
+    pub fn get_namespace_exports(&self, name: &str) -> Option<Exports> {
+        let ret: Exports = self
+            .map
+            .iter()
+            .filter(|((ns, _), _)| ns == name)
+            .map(|((_, name), e)| (name.clone(), e.clone()))
+            .collect();
+        if ret.is_empty() {
+            None
+        } else {
+            Some(ret)
+        }
+    }
+
+    /// Resolve and return a vector of imports in the order they are defined in the `module`'s source code.
+    ///
+    /// This means the returned `Vec<Extern>` might be a subset of the imports contained in `self`.
+    #[allow(clippy::result_large_err)]
+    pub fn imports_for_module(&self, module: &Module) -> Result<Vec<Extern>, LinkError> {
+        let mut ret = vec![];
+        for import in module.imports() {
+            if let Some(imp) = self
+                .map
+                .get(&(import.module().to_string(), import.name().to_string()))
+            {
+                ret.push(imp.clone());
+            } else {
+                return Err(LinkError::Import(
+                    import.module().to_string(),
+                    import.name().to_string(),
+                    ImportError::UnknownImport(import.ty().clone()),
+                ));
+            }
+        }
+        Ok(ret)
+    }
+
+    /// Iterates through all the imports in this structure
+    pub fn iter(&self) -> ImportsIterator<'_> {
+        ImportsIterator::new(self)
+    }
+}
+
+pub struct ImportsIterator<'a> {
+    iter: std::collections::hash_map::Iter<'a, (String, String), Extern>,
+}
+
+impl<'a> ImportsIterator<'a> {
+    fn new(imports: &'a Imports) -> Self {
+        let iter = imports.map.iter();
+        Self { iter }
+    }
+}
+
+impl<'a> Iterator for ImportsIterator<'a> {
+    type Item = (&'a str, &'a str, &'a Extern);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter
+            .next()
+            .map(|(k, v)| (k.0.as_str(), k.1.as_str(), v))
+    }
+}
+
+impl IntoIterator for &Imports {
+    type IntoIter = std::collections::hash_map::IntoIter<(String, String), Extern>;
+    type Item = ((String, String), Extern);
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.map.clone().into_iter()
+    }
+}
+
+impl Extend<((String, String), Extern)> for Imports {
+    fn extend<T: IntoIterator<Item = ((String, String), Extern)>>(&mut self, iter: T) {
+        for ((ns, name), ext) in iter.into_iter() {
+            self.define(&ns, &name, ext);
+        }
+    }
+}
+
+impl fmt::Debug for Imports {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        enum SecretMap {
+            Empty,
+            Some(usize),
+        }
+
+        impl SecretMap {
+            fn new(len: usize) -> Self {
+                if len == 0 {
+                    Self::Empty
+                } else {
+                    Self::Some(len)
+                }
+            }
+        }
+
+        impl fmt::Debug for SecretMap {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                match self {
+                    Self::Empty => write!(f, "(empty)"),
+                    Self::Some(len) => write!(f, "(... {} item(s) ...)", len),
+                }
+            }
+        }
+
+        f.debug_struct("Imports")
+            .field("map", &SecretMap::new(self.map.len()))
+            .finish()
+    }
+}
+
+// The import! macro for Imports
+
+/// Generate an [`Imports`] easily with the `imports!` macro.
+///
+/// [`Imports`]: struct.Imports.html
+///
+/// # Usage
+///
+/// ```
+/// # use wasmer::{StoreMut, Function, FunctionEnvMut, Store};
+/// # let mut store = Store::default();
+/// use wasmer::imports;
+///
+/// let import_object = imports! {
+///     "env" => {
+///         "foo" => Function::new_typed(&mut store, foo)
+///     },
+/// };
+///
+/// fn foo(n: i32) -> i32 {
+///     n
+/// }
+/// ```
+#[macro_export]
+macro_rules! imports {
+    ( $( $ns_name:expr => $ns:tt ),* $(,)? ) => {
+        {
+            #[allow(unused_mut)]
+            let mut import_object = $crate::Imports::new();
+
+            $({
+                let namespace = $crate::import_namespace!($ns);
+
+                import_object.register_namespace($ns_name, namespace);
+            })*
+
+            import_object
+        }
+    };
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! namespace {
+    ($( $import_name:expr => $import_item:expr ),* $(,)? ) => {
+        $crate::import_namespace!( { $( $import_name => $import_item, )* } )
+    };
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! import_namespace {
+    ( { $( $import_name:expr => $import_item:expr ),* $(,)? } ) => {{
+        let mut namespace = $crate::Exports::new();
+
+        $(
+            namespace.insert($import_name, $import_item);
+        )*
+
+        namespace
+    }};
+
+    ( $namespace:ident ) => {
+        $namespace
+    };
+}
+
+#[cfg(test)]
+mod test {
+    use crate::store::Store;
+    use crate::value::Value;
+    use crate::Extern;
+    use crate::Global;
+    use wasmer_types::Type;
+
+    #[test]
+    fn namespace() {
+        let mut store = Store::default();
+        let g1 = Global::new(&mut store, Value::I32(0));
+        let namespace = namespace! {
+            "happy" => g1
+        };
+        let imports1 = imports! {
+            "dog" => namespace
+        };
+
+        let happy_dog_entry = imports1.get_export("dog", "happy").unwrap();
+
+        assert!(if let Extern::Global(happy_dog_global) = happy_dog_entry {
+            happy_dog_global.get(&mut store).ty() == Type::I32
+        } else {
+            false
+        });
+    }
+
+    #[test]
+    fn imports_macro_allows_trailing_comma_and_none() {
+        use crate::Function;
+
+        let mut store: Store = Default::default();
+
+        fn func(arg: i32) -> i32 {
+            arg + 1
+        }
+
+        let _ = imports! {
+            "env" => {
+                "func" => Function::new_typed(&mut store, func),
+            },
+        };
+        let _ = imports! {
+            "env" => {
+                "func" => Function::new_typed(&mut store, func),
+            }
+        };
+        let _ = imports! {
+            "env" => {
+                "func" => Function::new_typed(&mut store, func),
+            },
+            "abc" => {
+                "def" => Function::new_typed(&mut store, func),
+            }
+        };
+        let _ = imports! {
+            "env" => {
+                "func" => Function::new_typed(&mut store, func)
+            },
+        };
+        let _ = imports! {
+            "env" => {
+                "func" => Function::new_typed(&mut store, func)
+            }
+        };
+        let _ = imports! {
+            "env" => {
+                "func1" => Function::new_typed(&mut store, func),
+                "func2" => Function::new_typed(&mut store, func)
+            }
+        };
+        let _ = imports! {
+            "env" => {
+                "func1" => Function::new_typed(&mut store, func),
+                "func2" => Function::new_typed(&mut store, func),
+            }
+        };
+    }
+
+    #[test]
+    fn chaining_works() {
+        let mut store = Store::default();
+
+        let g = Global::new(&mut store, Value::I32(0));
+
+        let mut imports1 = imports! {
+            "dog" => {
+                "happy" => g.clone()
+            }
+        };
+
+        let imports2 = imports! {
+            "dog" => {
+                "small" => g.clone()
+            },
+            "cat" => {
+                "small" => g
+            }
+        };
+
+        imports1.extend(&imports2);
+
+        let small_cat_export = imports1.get_export("cat", "small");
+        assert!(small_cat_export.is_some());
+
+        let happy = imports1.get_export("dog", "happy");
+        let small = imports1.get_export("dog", "small");
+        assert!(happy.is_some());
+        assert!(small.is_some());
+    }
+
+    #[test]
+    fn extending_conflict_overwrites() {
+        let mut store = Store::default();
+        let g1 = Global::new(&mut store, Value::I32(0));
+        let g2 = Global::new(&mut store, Value::I64(0));
+
+        let mut imports1 = imports! {
+            "dog" => {
+                "happy" => g1,
+            },
+        };
+
+        let imports2 = imports! {
+            "dog" => {
+                "happy" => g2,
+            },
+        };
+
+        imports1.extend(&imports2);
+        let _happy_dog_entry = imports1.get_export("dog", "happy").unwrap();
+        /*
+        assert!(
+            if let Exports::Global(happy_dog_global) = happy_dog_entry.to_vm_extern() {
+                happy_dog_global.from.ty().ty == Type::I64
+            } else {
+                false
+            }
+        );
+        */
+        // now test it in reverse
+        let mut store = Store::default();
+        let g1 = Global::new(&mut store, Value::I32(0));
+        let g2 = Global::new(&mut store, Value::I64(0));
+
+        let imports1 = imports! {
+            "dog" => {
+                "happy" => g1,
+            },
+        };
+
+        let mut imports2 = imports! {
+            "dog" => {
+                "happy" => g2,
+            },
+        };
+
+        imports2.extend(&imports1);
+        let _happy_dog_entry = imports2.get_export("dog", "happy").unwrap();
+        /*
+        assert!(
+            if let Exports::Global(happy_dog_global) = happy_dog_entry.to_vm_extern() {
+                happy_dog_global.from.ty().ty == Type::I32
+            } else {
+                false
+            }
+        );
+        */
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/instance.rs
new file mode 100644
index 0000000..ff31210
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/instance.rs
@@ -0,0 +1,113 @@
+use crate::exports::Exports;
+use crate::module::Module;
+use crate::{Extern, InstantiationError};
+use std::fmt;
+
+use crate::imports::Imports;
+use crate::store::AsStoreMut;
+
+#[cfg(feature = "js")]
+use crate::js::instance as instance_imp;
+#[cfg(feature = "jsc")]
+use crate::jsc::instance as instance_imp;
+#[cfg(feature = "sys")]
+use crate::sys::instance as instance_imp;
+
+/// A WebAssembly Instance is a stateful, executable
+/// instance of a WebAssembly [`Module`].
+///
+/// Instance objects contain all the exported WebAssembly
+/// functions, memories, tables and globals that allow
+/// interacting with WebAssembly.
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#module-instances>
+#[derive(Clone, PartialEq, Eq)]
+pub struct Instance {
+    pub(crate) _inner: instance_imp::Instance,
+    pub(crate) module: Module,
+    /// The exports for an instance.
+    pub exports: Exports,
+}
+
+impl Instance {
+    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
+    /// set of imports using [`Imports`] or the [`imports!`] macro helper.
+    ///
+    /// [`imports!`]: crate::imports!
+    /// [`Imports!`]: crate::Imports!
+    ///
+    /// ```
+    /// # use wasmer::{imports, Store, Module, Global, Value, Instance};
+    /// # use wasmer::FunctionEnv;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let mut store = Store::default();
+    /// let env = FunctionEnv::new(&mut store, ());
+    /// let module = Module::new(&store, "(module)")?;
+    /// let imports = imports!{
+    ///   "host" => {
+    ///     "var" => Global::new(&mut store, Value::I32(2))
+    ///   }
+    /// };
+    /// let instance = Instance::new(&mut store, &module, &imports)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// ## Errors
+    ///
+    /// The function can return [`InstantiationError`]s.
+    ///
+    /// Those are, as defined by the spec:
+    ///  * Link errors that happen when plugging the imports into the instance
+    ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<Self, InstantiationError> {
+        let (_inner, exports) = instance_imp::Instance::new(store, module, imports)?;
+        Ok(Self {
+            _inner,
+            module: module.clone(),
+            exports,
+        })
+    }
+
+    /// Creates a new `Instance` from a WebAssembly [`Module`] and a
+    /// vector of imports.
+    ///
+    /// ## Errors
+    ///
+    /// The function can return [`InstantiationError`]s.
+    ///
+    /// Those are, as defined by the spec:
+    ///  * Link errors that happen when plugging the imports into the instance
+    ///  * Runtime errors that happen when running the module `start` function.
+    #[allow(clippy::result_large_err)]
+    pub fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<Self, InstantiationError> {
+        let (_inner, exports) = instance_imp::Instance::new_by_index(store, module, externs)?;
+        Ok(Self {
+            _inner,
+            module: module.clone(),
+            exports,
+        })
+    }
+
+    /// Gets the [`Module`] associated with this instance.
+    pub fn module(&self) -> &Module {
+        &self.module
+    }
+}
+
+impl fmt::Debug for Instance {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Instance")
+            .field("exports", &self.exports)
+            .finish()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/into_bytes.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/into_bytes.rs
new file mode 100644
index 0000000..2016036
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/into_bytes.rs
@@ -0,0 +1,50 @@
+use bytes::Bytes;
+use std::borrow::Cow;
+
+/// Convert binary data into [`bytes::Bytes`].
+pub trait IntoBytes {
+    /// Convert binary data into [`bytes::Bytes`].
+    fn into_bytes(self) -> Bytes;
+}
+
+impl IntoBytes for Bytes {
+    fn into_bytes(self) -> Bytes {
+        self
+    }
+}
+
+impl IntoBytes for Vec<u8> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self)
+    }
+}
+
+impl IntoBytes for &Vec<u8> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.clone())
+    }
+}
+
+impl IntoBytes for &[u8] {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}
+
+impl<const N: usize> IntoBytes for &[u8; N] {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}
+
+impl IntoBytes for &str {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.as_bytes().to_vec())
+    }
+}
+
+impl IntoBytes for Cow<'_, [u8]> {
+    fn into_bytes(self) -> Bytes {
+        Bytes::from(self.to_vec())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/as_js.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/as_js.rs
new file mode 100644
index 0000000..5068c8b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/as_js.rs
@@ -0,0 +1,334 @@
+//use crate::js::externals::Function;
+// use crate::store::{Store, StoreObject};
+// use crate::js::RuntimeError;
+use crate::imports::Imports;
+use crate::instance::Instance;
+use crate::js::instance::Instance as JsInstance;
+use crate::js::vm::{VMFunction, VMGlobal, VMMemory, VMTable};
+use crate::js::wasm_bindgen_polyfill::Global as JsGlobal;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::Type;
+use crate::{Extern, Function, Global, Memory, Table};
+use js_sys::Function as JsFunction;
+use js_sys::WebAssembly::{Memory as JsMemory, Table as JsTable};
+use std::collections::HashMap;
+use std::convert::TryInto;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::{JsError, JsValue};
+use wasmer_types::ExternType;
+
+/// Convert the given type to a [`JsValue`].
+pub trait AsJs: Sized {
+    /// The inner definition type from this Javascript object
+    type DefinitionType;
+    /// Convert the given type to a [`JsValue`].
+    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JsValue;
+    /// Convert the given type to a [`JsValue`].
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        type_: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError>;
+}
+
+#[inline]
+pub fn param_from_js(ty: &Type, js_val: &JsValue) -> Value {
+    match ty {
+        Type::I32 => Value::I32(js_val.as_f64().unwrap() as _),
+        Type::I64 => Value::I64(if js_val.is_bigint() {
+            js_val.clone().try_into().unwrap()
+        } else {
+            js_val.as_f64().unwrap() as _
+        }),
+        Type::F32 => Value::F32(js_val.as_f64().unwrap() as _),
+        Type::F64 => Value::F64(js_val.as_f64().unwrap()),
+        Type::V128 => {
+            let big_num: u128 = js_sys::BigInt::from(js_val.clone()).try_into().unwrap();
+            Value::V128(big_num)
+        }
+        Type::ExternRef | Type::FuncRef => unimplemented!(
+            "The type `{:?}` is not yet supported in the JS Function API",
+            ty
+        ),
+    }
+}
+
+impl AsJs for Value {
+    type DefinitionType = Type;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> JsValue {
+        match self {
+            Self::I32(i) => JsValue::from(*i),
+            Self::I64(i) => JsValue::from(*i),
+            Self::F32(f) => JsValue::from(*f),
+            Self::F64(f) => JsValue::from(*f),
+            Self::V128(v) => JsValue::from(*v),
+            Self::FuncRef(Some(func)) => func.0.handle.function.clone().into(),
+            Self::FuncRef(None) => JsValue::null(),
+            Self::ExternRef(_) => unimplemented!(),
+        }
+    }
+
+    fn from_jsvalue(
+        _store: &mut impl AsStoreMut,
+        type_: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        Ok(param_from_js(type_, value))
+    }
+}
+
+impl AsJs for Imports {
+    type DefinitionType = crate::module::Module;
+
+    // Annotation is here to prevent spurious IDE warnings.
+    #[allow(unused_unsafe)]
+    fn as_jsvalue(&self, store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        let imports_object = js_sys::Object::new();
+        for (namespace, name, extern_) in self.iter() {
+            let val = unsafe { js_sys::Reflect::get(&imports_object, &namespace.into()).unwrap() };
+            if !val.is_undefined() {
+                // If the namespace is already set
+
+                // Annotation is here to prevent spurious IDE warnings.
+                #[allow(unused_unsafe)]
+                unsafe {
+                    js_sys::Reflect::set(
+                        &val,
+                        &name.into(),
+                        &extern_.as_jsvalue(&store.as_store_ref()),
+                    )
+                    .unwrap();
+                }
+            } else {
+                // If the namespace doesn't exist
+                let import_namespace = js_sys::Object::new();
+                #[allow(unused_unsafe)]
+                unsafe {
+                    js_sys::Reflect::set(
+                        &import_namespace,
+                        &name.into(),
+                        &extern_.as_jsvalue(&store.as_store_ref()),
+                    )
+                    .unwrap();
+                    js_sys::Reflect::set(
+                        &imports_object,
+                        &namespace.into(),
+                        &import_namespace.into(),
+                    )
+                    .unwrap();
+                }
+            }
+        }
+        imports_object.into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        module: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        let module_imports: HashMap<(String, String), ExternType> = module
+            .imports()
+            .map(|import| {
+                (
+                    (import.module().to_string(), import.name().to_string()),
+                    import.ty().clone(),
+                )
+            })
+            .collect::<HashMap<(String, String), ExternType>>();
+
+        let mut map: HashMap<(String, String), Extern> = HashMap::new();
+        let object: js_sys::Object = value.clone().into();
+        for module_entry in js_sys::Object::entries(&object).iter() {
+            let module_entry: js_sys::Array = module_entry.into();
+            let module_name = module_entry.get(0).as_string().unwrap().to_string();
+            let module_import_object: js_sys::Object = module_entry.get(1).into();
+            for import_entry in js_sys::Object::entries(&module_import_object).iter() {
+                let import_entry: js_sys::Array = import_entry.into();
+                let import_name = import_entry.get(0).as_string().unwrap().to_string();
+                let import_js: wasm_bindgen::JsValue = import_entry.get(1);
+                let key = (module_name.clone(), import_name);
+                let extern_type = module_imports.get(&key).unwrap();
+                let extern_ = Extern::from_jsvalue(store, extern_type, &import_js)?;
+                map.insert(key, extern_);
+            }
+        }
+
+        Ok(Self { map })
+    }
+}
+
+impl AsJs for Extern {
+    type DefinitionType = ExternType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        match self {
+            Self::Memory(memory) => memory.0.handle.memory.clone().into(),
+            Self::Function(function) => function.0.handle.function.clone().into(),
+            Self::Table(table) => table.0.handle.table.clone().into(),
+            Self::Global(global) => global.0.handle.global.clone().into(),
+        }
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        extern_type: &Self::DefinitionType,
+        val: &JsValue,
+    ) -> Result<Self, JsError> {
+        // Note: this function do a soft check over the type
+        // We only check the "kind" of Extern, but nothing else
+        match extern_type {
+            ExternType::Memory(memory_type) => {
+                Ok(Self::Memory(Memory::from_jsvalue(store, memory_type, val)?))
+            }
+            ExternType::Global(global_type) => {
+                Ok(Self::Global(Global::from_jsvalue(store, global_type, val)?))
+            }
+            ExternType::Function(function_type) => Ok(Self::Function(Function::from_jsvalue(
+                store,
+                function_type,
+                val,
+            )?)),
+            ExternType::Table(table_type) => {
+                Ok(Self::Table(Table::from_jsvalue(store, table_type, val)?))
+            }
+        }
+    }
+}
+
+impl AsJs for Instance {
+    type DefinitionType = crate::module::Module;
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self._inner._handle.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        module: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        let js_instance: js_sys::WebAssembly::Instance = value.clone().into();
+        let (instance, exports) = JsInstance::from_module_and_instance(store, module, js_instance)
+            .map_err(|e| JsError::new(&format!("Can't get the instance: {:?}", e)))?;
+        Ok(Instance {
+            _inner: instance,
+            module: module.clone(),
+            exports,
+        })
+    }
+}
+
+impl AsJs for Memory {
+    type DefinitionType = crate::MemoryType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self.0.handle.memory.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        memory_type: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        if let Some(memory) = value.dyn_ref::<JsMemory>() {
+            Ok(Memory::from_vm_extern(
+                store,
+                VMMemory::new(memory.clone(), memory_type.clone()),
+            ))
+        } else {
+            Err(JsError::new(&format!(
+                "Extern expect to be of type Memory, but received {:?}",
+                value
+            )))
+        }
+    }
+}
+
+impl AsJs for Function {
+    type DefinitionType = crate::FunctionType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self.0.handle.function.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        function_type: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        if value.is_instance_of::<JsFunction>() {
+            Ok(Function::from_vm_extern(
+                store,
+                VMFunction::new(
+                    value.clone().unchecked_into::<JsFunction>(),
+                    function_type.clone(),
+                ),
+            ))
+        } else {
+            Err(JsError::new(&format!(
+                "Extern expect to be of type Function, but received {:?}",
+                value
+            )))
+        }
+    }
+}
+
+impl AsJs for Global {
+    type DefinitionType = crate::GlobalType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self.0.handle.global.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        global_type: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        if value.is_instance_of::<JsGlobal>() {
+            Ok(Global::from_vm_extern(
+                store,
+                VMGlobal::new(
+                    value.clone().unchecked_into::<JsGlobal>(),
+                    global_type.clone(),
+                ),
+            ))
+        } else {
+            Err(JsError::new(&format!(
+                "Extern expect to be of type Global, but received {:?}",
+                value
+            )))
+        }
+    }
+}
+
+impl AsJs for Table {
+    type DefinitionType = crate::TableType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> wasm_bindgen::JsValue {
+        self.0.handle.table.clone().into()
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        table_type: &Self::DefinitionType,
+        value: &JsValue,
+    ) -> Result<Self, JsError> {
+        if value.is_instance_of::<JsTable>() {
+            Ok(Table::from_vm_extern(
+                store,
+                VMTable::new(
+                    value.clone().unchecked_into::<JsTable>(),
+                    table_type.clone(),
+                ),
+            ))
+        } else {
+            Err(JsError::new(&format!(
+                "Extern expect to be of type Table, but received {:?}",
+                value
+            )))
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/engine.rs
new file mode 100644
index 0000000..b56d104
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/engine.rs
@@ -0,0 +1,21 @@
+/// A WebAssembly `Universal` Engine.
+#[derive(Clone, Debug)]
+pub struct Engine;
+
+impl Engine {
+    pub(crate) fn deterministic_id(&self) -> &str {
+        // All js engines have the same id
+        "js-generic"
+    }
+}
+
+impl Default for Engine {
+    fn default() -> Self {
+        Engine
+    }
+}
+
+/// Returns the default engine for the JS engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/errors.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/errors.rs
new file mode 100644
index 0000000..b4f6e02
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/errors.rs
@@ -0,0 +1,28 @@
+use crate::js::trap::Trap;
+use crate::RuntimeError;
+use wasm_bindgen::prelude::*;
+
+impl From<Trap> for RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<RuntimeError>() {
+            return trap.downcast::<RuntimeError>().unwrap();
+        }
+        let wasm_trace = vec![];
+        let trap_code = None;
+        // let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
+        RuntimeError::new_from_source(trap, wasm_trace, trap_code)
+    }
+}
+
+impl From<RuntimeError> for JsValue {
+    fn from(_err: RuntimeError) -> Self {
+        // err.inner.source.into()
+        unimplemented!();
+    }
+}
+
+pub(crate) fn raise(error: Box<dyn std::error::Error + Send + Sync>) -> ! {
+    let error = Trap::user(error);
+    let js_error: JsValue = error.into();
+    wasm_bindgen::throw_val(js_error)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/extern_ref.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/extern_ref.rs
new file mode 100644
index 0000000..fc0771e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/extern_ref.rs
@@ -0,0 +1,39 @@
+use std::any::Any;
+
+use crate::js::vm::VMExternRef;
+use crate::store::{AsStoreMut, AsStoreRef};
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct ExternRef;
+
+impl ExternRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        _store: &mut impl AsStoreMut,
+        _vm_externref: VMExternRef,
+    ) -> Self {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/function.rs
new file mode 100644
index 0000000..1d588ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/function.rs
@@ -0,0 +1,487 @@
+use crate::errors::RuntimeError;
+use crate::externals::function::{HostFunction, HostFunctionKind, WithEnv, WithoutEnv};
+use crate::function_env::{FunctionEnv, FunctionEnvMut};
+use crate::js::as_js::{param_from_js, AsJs}; /* ValFuncRef */
+use crate::js::store::{InternalStoreHandle, StoreHandle};
+use crate::js::vm::{VMExtern, VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment};
+use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
+use crate::store::{AsStoreMut, AsStoreRef, StoreMut};
+use crate::value::Value;
+use std::fmt;
+use std::iter::FromIterator;
+use std::marker::PhantomData;
+use std::panic::{self, AssertUnwindSafe};
+
+use wasmer_types::{FunctionType, NativeWasmType, RawValue};
+
+use js_sys::{Array, Function as JSFunction};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+
+#[inline]
+fn result_to_js(val: &Value) -> JsValue {
+    match val {
+        Value::I32(i) => JsValue::from_f64(*i as _),
+        Value::I64(i) => JsValue::from_f64(*i as _),
+        Value::F32(f) => JsValue::from_f64(*f as _),
+        Value::F64(f) => JsValue::from_f64(*f),
+        Value::V128(f) => JsValue::from_f64(*f as _),
+        val => unimplemented!(
+            "The value `{:?}` is not yet supported in the JS Function API",
+            val
+        ),
+    }
+}
+
+#[inline]
+fn results_to_js_array(values: &[Value]) -> Array {
+    Array::from_iter(values.iter().map(result_to_js))
+}
+
+#[derive(Clone, PartialEq)]
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+// Function can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Function(self.handle.clone())
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let mut store = store.as_store_mut();
+        let function_type = ty.into();
+        let func_ty = function_type.clone();
+        let raw_store = store.as_raw() as *mut u8;
+        let raw_env = env.clone();
+        let wrapped_func: JsValue = match function_type.results().len() {
+            0 => Closure::wrap(Box::new(move |args: &Array| {
+                let mut store: StoreMut = unsafe { StoreMut::from_raw(raw_store as _) };
+                let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
+                let wasm_arguments = function_type
+                    .params()
+                    .iter()
+                    .enumerate()
+                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .collect::<Vec<_>>();
+                let _results = func(env, &wasm_arguments)?;
+                Ok(())
+            })
+                as Box<dyn FnMut(&Array) -> Result<(), JsValue>>)
+            .into_js_value(),
+            1 => Closure::wrap(Box::new(move |args: &Array| {
+                let mut store: StoreMut = unsafe { StoreMut::from_raw(raw_store as _) };
+                let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
+                let wasm_arguments = function_type
+                    .params()
+                    .iter()
+                    .enumerate()
+                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .collect::<Vec<_>>();
+                let results = func(env, &wasm_arguments)?;
+                return Ok(result_to_js(&results[0]));
+            })
+                as Box<dyn FnMut(&Array) -> Result<JsValue, JsValue>>)
+            .into_js_value(),
+            _n => Closure::wrap(Box::new(move |args: &Array| {
+                let mut store: StoreMut = unsafe { StoreMut::from_raw(raw_store as _) };
+                let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
+                let wasm_arguments = function_type
+                    .params()
+                    .iter()
+                    .enumerate()
+                    .map(|(i, param)| param_from_js(param, &args.get(i as u32)))
+                    .collect::<Vec<_>>();
+                let results = func(env, &wasm_arguments)?;
+                return Ok(results_to_js_array(&results));
+            })
+                as Box<dyn FnMut(&Array) -> Result<Array, JsValue>>)
+            .into_js_value(),
+        };
+
+        let dyn_func =
+            JSFunction::new_with_args("f", "return f(Array.prototype.slice.call(arguments, 1))");
+        let binded_func = dyn_func.bind1(&JsValue::UNDEFINED, &wrapped_func);
+        let vm_function = VMFunction::new(binded_func, func_ty);
+        Self::from_vm_extern(&mut store, vm_function)
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        if std::mem::size_of::<F>() != 0 {
+            Self::closures_unsupported_panic();
+        }
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let address = function.address() as usize as u32;
+
+        let ft = wasm_bindgen::function_table();
+        let as_table = ft.unchecked_ref::<js_sys::WebAssembly::Table>();
+        let func = as_table.get(address).unwrap();
+
+        let binded_func = func.bind1(
+            &JsValue::UNDEFINED,
+            &JsValue::from_f64(store.as_raw() as *mut u8 as usize as f64),
+        );
+        let ty = function.ty();
+        let vm_function = VMFunction::new(binded_func, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        if std::mem::size_of::<F>() != 0 {
+            Self::closures_unsupported_panic();
+        }
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let address = function.address() as usize as u32;
+
+        let ft = wasm_bindgen::function_table();
+        let as_table = ft.unchecked_ref::<js_sys::WebAssembly::Table>();
+        let func = as_table.get(address).unwrap();
+
+        let binded_func = func.bind2(
+            &JsValue::UNDEFINED,
+            &JsValue::from_f64(store.as_raw() as *mut u8 as usize as f64),
+            &JsValue::from_f64(env.handle.internal_handle().index() as f64),
+        );
+        let ty = function.ty();
+        let vm_function = VMFunction::new(binded_func, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        self.handle.ty.clone()
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JS, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // Annotation is here to prevent spurious IDE warnings.
+        let arr = js_sys::Array::new_with_length(params.len() as u32);
+
+        // let raw_env = env.as_raw() as *mut u8;
+        // let mut env = unsafe { FunctionEnvMut::from_raw(raw_env as *mut StoreInner<()>) };
+
+        for (i, param) in params.iter().enumerate() {
+            let js_value = param.as_jsvalue(&store.as_store_ref());
+            arr.set(i as u32, js_value);
+        }
+
+        let result = {
+            let mut r;
+            // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+            loop {
+                r = js_sys::Reflect::apply(
+                    &self.handle.function,
+                    &wasm_bindgen::JsValue::NULL,
+                    &arr,
+                );
+                let store_mut = store.as_store_mut();
+                if let Some(callback) = store_mut.inner.on_called.take() {
+                    match callback(store_mut) {
+                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                            continue;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Finish) => {
+                            break;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                            return Err(RuntimeError::user(trap))
+                        }
+                        Err(trap) => return Err(RuntimeError::user(trap)),
+                    }
+                }
+                break;
+            }
+            r?
+        };
+
+        let result_types = self.handle.ty.results();
+        match result_types.len() {
+            0 => Ok(Box::new([])),
+            1 => {
+                let value = param_from_js(&result_types[0], &result);
+                Ok(vec![value].into_boxed_slice())
+            }
+            _n => {
+                let result_array: Array = result.into();
+                Ok(result_array
+                    .iter()
+                    .enumerate()
+                    .map(|(i, js_val)| param_from_js(&result_types[i], &js_val))
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice())
+            }
+        }
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMFunction) -> Self {
+        Self { handle: internal }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    #[track_caller]
+    fn closures_unsupported_panic() -> ! {
+        unimplemented!("Closures (functions with captured environments) are currently unsupported with native functions. See: https://github.com/wasmerio/wasmer/issues/1840")
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+/// Represents a low-level Wasm static host function. See
+/// `super::Function::new` and `super::Function::new_env` to learn
+/// more.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct WasmFunction<Args = (), Rets = ()> {
+    address: VMFunctionCallback,
+    _phantom: PhantomData<(Args, Rets)>,
+}
+
+unsafe impl<Args, Rets> Send for WasmFunction<Args, Rets> {}
+
+impl<Args, Rets> WasmFunction<Args, Rets>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    /// Creates a new `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn new<F, T, Kind: HostFunctionKind>(function: F) -> Self
+    where
+        F: HostFunction<T, Args, Rets, Kind>,
+        T: Sized,
+    {
+        Self {
+            address: function.function_callback(),
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Get the function type of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn ty(&self) -> FunctionType {
+        FunctionType::new(Args::wasm_types(), Rets::wasm_types())
+    }
+
+    /// Get the address of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn address(&self) -> VMFunctionCallback {
+        self.address
+    }
+}
+
+macro_rules! impl_host_function {
+        ( [$c_struct_representation:ident]
+           $c_struct_name:ident,
+           $( $x:ident ),* ) => {
+
+            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
+            // arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, T, Func >
+                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                T: Send + 'static,
+                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+                    /// This is a function that wraps the real host
+                    /// function. Its address will be used inside the
+                    /// runtime.
+                    unsafe extern "C" fn func_wrapper<T, $( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, handle_index: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        T: Send + 'static,
+                        Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+                    {
+                        let mut store = StoreMut::from_raw(store_ptr as *mut _);
+                        let mut store2 = StoreMut::from_raw(store_ptr as *mut _);
+
+                        let result = {
+                            // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                            let func: &Func = &*(&() as *const () as *const Func);
+                            panic::catch_unwind(AssertUnwindSafe(|| {
+                                let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store2.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
+                                let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store2);
+                                func(env, $( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                            }))
+                        };
+
+                        match result {
+                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                            #[allow(deprecated)]
+                            #[cfg(feature = "std")]
+                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
+                            #[cfg(feature = "core")]
+                            #[allow(deprecated)]
+                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
+                            Err(_panic) => unimplemented!(),
+                        }
+                    }
+
+                    func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                }
+            }
+
+            // Implement `HostFunction` for a function that has the same arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, Func >
+                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+                    /// This is a function that wraps the real host
+                    /// function. Its address will be used inside the
+                    /// runtime.
+                    unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( store_ptr: usize, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                    {
+                        // let env: &Env = unsafe { &*(ptr as *const u8 as *const Env) };
+                        let func: &Func = &*(&() as *const () as *const Func);
+                        let mut store = StoreMut::from_raw(store_ptr as *mut _);
+
+                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                            func($( FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x)) ),* ).into_result()
+                        }));
+
+                        match result {
+                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                            #[cfg(feature = "std")]
+                            #[allow(deprecated)]
+                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
+                            #[cfg(feature = "core")]
+                            #[allow(deprecated)]
+                            Ok(Err(trap)) => crate::js::errors::raise(Box::new(trap)),
+                            Err(_panic) => unimplemented!(),
+                        }
+                    }
+
+                    func_wrapper::< $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                }
+            }
+        };
+    }
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/global.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/global.rs
new file mode 100644
index 0000000..d9be955
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/global.rs
@@ -0,0 +1,139 @@
+use crate::errors::RuntimeError;
+use crate::js::wasm_bindgen_polyfill::Global as JSGlobal;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::{VMExtern, VMGlobal};
+use crate::GlobalType;
+use crate::Mutability;
+use wasm_bindgen::JsValue;
+use wasmer_types::{RawValue, Type};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+// Global can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Global {}
+
+impl Global {
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Global(self.handle.clone())
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new(
+                "cross-`WasmerEnv` values are not supported",
+            ));
+        }
+        let global_ty = GlobalType {
+            mutability,
+            ty: val.ty(),
+        };
+        let descriptor = js_sys::Object::new();
+        let (type_str, value) = match val {
+            Value::I32(i) => ("i32", JsValue::from_f64(i as _)),
+            Value::I64(i) => ("i64", JsValue::from_f64(i as _)),
+            Value::F32(f) => ("f32", JsValue::from_f64(f as _)),
+            Value::F64(f) => ("f64", JsValue::from_f64(f)),
+            _ => unimplemented!("The type is not yet supported in the JS Global API"),
+        };
+        // This is the value type as string, even though is incorrectly called "value"
+        // in the JS API.
+        js_sys::Reflect::set(&descriptor, &"value".into(), &type_str.into())?;
+        js_sys::Reflect::set(
+            &descriptor,
+            &"mutable".into(),
+            &mutability.is_mutable().into(),
+        )?;
+
+        let js_global = JSGlobal::new(&descriptor, &value).unwrap();
+        let vm_global = VMGlobal::new(js_global, global_ty);
+
+        Ok(Self::from_vm_extern(store, vm_global))
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        unsafe {
+            let value = self.handle.global.value();
+            let ty = self.handle.ty;
+            let raw = match ty.ty {
+                Type::I32 => RawValue {
+                    i32: value.as_f64().unwrap_or_default() as _,
+                },
+                Type::I64 => RawValue {
+                    i64: value.as_f64().unwrap_or_default() as _,
+                },
+                Type::F32 => RawValue {
+                    f32: value.as_f64().unwrap_or_default() as _,
+                },
+                Type::F64 => RawValue {
+                    f64: value.as_f64().unwrap_or_default(),
+                },
+                Type::V128 => RawValue {
+                    u128: value.as_f64().unwrap_or_default() as _,
+                },
+                Type::FuncRef => {
+                    unimplemented!();
+                    // Self::FuncRef(VMFuncRef::from_raw(raw).map(|f| Function::from_vm_funcref(store, f)))
+                }
+                Type::ExternRef => {
+                    unimplemented!();
+                    // Self::ExternRef(
+                    //     VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e)),
+                    // )
+                }
+            };
+            Value::from_raw(store, ty.ty, raw)
+        }
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new(
+                "cross-`WasmerEnv` values are not supported",
+            ));
+        }
+        let global_ty = self.ty(&store);
+        if global_ty.mutability == Mutability::Const {
+            return Err(RuntimeError::new("The global is immutable".to_owned()));
+        }
+        if val.ty() != global_ty.ty {
+            return Err(RuntimeError::new("The types don't match".to_owned()));
+        }
+        let new_value = match val {
+            Value::I32(i) => JsValue::from_f64(i as _),
+            Value::I64(i) => JsValue::from_f64(i as _),
+            Value::F32(f) => JsValue::from_f64(f as _),
+            Value::F64(f) => JsValue::from_f64(f),
+            _ => {
+                return Err(RuntimeError::new(
+                    "The type is not yet supported in the JS Global API".to_owned(),
+                ))
+            }
+        };
+        self.handle.global.set_value(&new_value);
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMGlobal) -> Self {
+        use crate::js::store::StoreObject;
+        VMGlobal::list_mut(store.objects_mut()).push(vm_global.clone());
+        Self { handle: vm_global }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory.rs
new file mode 100644
index 0000000..ebd8b3e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory.rs
@@ -0,0 +1,281 @@
+use crate::js::vm::{VMExtern, VMMemory};
+use crate::mem_access::MemoryAccessError;
+use crate::store::{AsStoreMut, AsStoreRef, StoreObjects};
+use crate::MemoryType;
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
+use std::slice;
+
+use tracing::warn;
+
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsCast;
+use wasmer_types::Pages;
+
+use super::memory_view::MemoryView;
+
+pub use wasmer_types::MemoryError;
+
+#[wasm_bindgen]
+extern "C" {
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory)
+    #[wasm_bindgen(js_namespace = WebAssembly, extends = js_sys::Object, typescript_type = "WebAssembly.Memory")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type JSMemory;
+
+    /// The `grow()` protoype method of the `Memory` object increases the
+    /// size of the memory instance by a specified number of WebAssembly
+    /// pages.
+    ///
+    /// Takes the number of pages to grow (64KiB in size) and returns the
+    /// previous size of memory, in pages.
+    ///
+    /// # Reimplementation
+    ///
+    /// We re-implement `WebAssembly.Memory.grow` because it is
+    /// different from what `wasm-bindgen` declares. It marks the function
+    /// as `catch`, which means it can throw an exception.
+    ///
+    /// See [the opened patch](https://github.com/rustwasm/wasm-bindgen/pull/2599).
+    ///
+    /// # Exceptions
+    ///
+    /// A `RangeError` is thrown if adding pages would exceed the maximum
+    /// memory.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory/grow)
+    #[wasm_bindgen(catch, method, js_namespace = WebAssembly)]
+    pub fn grow(this: &JSMemory, pages: u32) -> Result<u32, JsValue>;
+}
+
+#[derive(Debug, Clone)]
+pub struct Memory {
+    pub(crate) handle: VMMemory,
+}
+
+// Only SharedMemories can be Send in js, becuase they support `structuredClone`.
+// Normal memories will fail while doing structuredClone.
+// In this case, we implement Send just in case as it can be a shared memory.
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// ```js
+// const memory = new WebAssembly.Memory({
+//   initial: 10,
+//   maximum: 100,
+//   shared: true // <--- It must be shared, otherwise structuredClone will fail
+// });
+// structuredClone(memory)
+// ```
+unsafe impl Send for Memory {}
+unsafe impl Sync for Memory {}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        let vm_memory = VMMemory::new(Self::js_memory_from_type(&ty)?, ty);
+        Ok(Self::from_vm_extern(store, vm_memory))
+    }
+
+    pub(crate) fn js_memory_from_type(
+        ty: &MemoryType,
+    ) -> Result<js_sys::WebAssembly::Memory, MemoryError> {
+        let descriptor = js_sys::Object::new();
+        // Annotation is here to prevent spurious IDE warnings.
+        #[allow(unused_unsafe)]
+        unsafe {
+            js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.0.into()).unwrap();
+            if let Some(max) = ty.maximum {
+                js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.0.into()).unwrap();
+            }
+            js_sys::Reflect::set(&descriptor, &"shared".into(), &ty.shared.into()).unwrap();
+        }
+
+        let js_memory = js_sys::WebAssembly::Memory::new(&descriptor).map_err(|e| {
+            let error_message = if let Some(s) = e.as_string() {
+                s
+            } else if let Some(obj) = e.dyn_ref::<js_sys::Object>() {
+                obj.to_string().into()
+            } else {
+                "Error while creating the memory".to_string()
+            };
+            MemoryError::Generic(error_message)
+        })?;
+
+        Ok(js_memory)
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self::from_vm_extern(new_store, memory)
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Memory(self.handle.clone())
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
+        self.handle.ty
+    }
+
+    /// Creates a view into the memory that then allows for
+    /// read and write
+    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        let pages = delta.into();
+        let js_memory = &self.handle.memory;
+        let our_js_memory: &JSMemory = JsCast::unchecked_from_js_ref(js_memory);
+        let new_pages = our_js_memory.grow(pages.0).map_err(|err| {
+            if err.is_instance_of::<js_sys::RangeError>() {
+                MemoryError::CouldNotGrow {
+                    current: self.view(&store.as_store_ref()).size(),
+                    attempted_delta: pages,
+                }
+            } else {
+                MemoryError::Generic(err.as_string().unwrap())
+            }
+        })?;
+        Ok(Pages(new_pages))
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        let cur_size = self.view(store).data_size();
+        if min_size > cur_size {
+            let delta = min_size - cur_size;
+            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE as u64) + 1;
+
+            self.grow(store, Pages(pages as u32))?;
+        }
+        Ok(())
+    }
+
+    pub fn reset(&self, _store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMMemory) -> Self {
+        Self { handle: internal }
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.handle.try_clone()
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let mut cloned = self.try_clone(store)?;
+        cloned.copy()
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
+        // Not supported.
+        None
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl From<Memory> for crate::Memory {
+    fn from(value: Memory) -> Self {
+        crate::Memory(value)
+    }
+}
+
+impl From<crate::Memory> for Memory {
+    fn from(value: crate::Memory) -> Self {
+        value.0
+    }
+}
+
+/// Underlying buffer for a memory.
+#[derive(Copy, Clone, Debug)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut js_sys::Uint8Array,
+    pub(crate) marker: PhantomData<(&'a Memory, &'a StoreObjects)>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &*(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        view.subarray(offset as _, end as _)
+            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.len()) });
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &*(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        view.subarray(offset as _, end as _)
+            .copy_to(unsafe { &mut slice::from_raw_parts_mut(buf_ptr, buf.len()) });
+
+        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let view = unsafe { &mut *(self.base) };
+        if end > view.length().into() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                view.length()
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        view.subarray(offset as _, end as _).copy_from(data);
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory_view.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory_view.rs
new file mode 100644
index 0000000..f4830ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/memory_view.rs
@@ -0,0 +1,285 @@
+use std::{convert::TryInto, marker::PhantomData, mem::MaybeUninit, ops::Range, slice};
+use wasm_bindgen::JsCast;
+use wasmer_types::{Bytes, Pages};
+
+use crate::{
+    js::externals::memory::{Memory, MemoryBuffer},
+    mem_access::MemoryAccessError,
+    store::AsStoreRef,
+};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.grow() method.
+#[derive(Debug)]
+pub struct MemoryView<'a> {
+    view: js_sys::Uint8Array,
+    size: u64,
+    marker: PhantomData<&'a Memory>,
+}
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, _store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        Self::new_raw(&memory.handle.memory)
+    }
+
+    pub(crate) fn new_raw(memory: &js_sys::WebAssembly::Memory) -> Self {
+        let buffer = memory.buffer();
+
+        // This also works for SharedArrayBuffer.
+        let size = buffer
+            .unchecked_ref::<js_sys::ArrayBuffer>()
+            .byte_length()
+            .into();
+
+        let view = js_sys::Uint8Array::new(&buffer);
+
+        Self {
+            view,
+            size,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        unimplemented!("direct data pointer access is not possible in JavaScript");
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.size
+    }
+
+    // TODO: do we want a proper implementation here instead?
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        unimplemented!("direct data pointer access is not possible in JavaScript");
+    }
+
+    // TODO: do we want a proper implementation here instead?
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        unimplemented!("direct data pointer access is not possible in JavaScript");
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        Bytes(self.size as usize).try_into().unwrap()
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&self) -> MemoryBuffer<'a> {
+        MemoryBuffer {
+            base: &self.view as *const _ as *mut _,
+            marker: PhantomData,
+        }
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, data: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let view = &self.view;
+        let offset: u32 = offset.try_into().map_err(|_| MemoryAccessError::Overflow)?;
+        let len: u32 = data
+            .len()
+            .try_into()
+            .map_err(|_| MemoryAccessError::Overflow)?;
+        let end = offset.checked_add(len).ok_or(MemoryAccessError::Overflow)?;
+        if end > view.length() {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                len,
+                end,
+                view.length()
+            );
+            Err(MemoryAccessError::HeapOutOfBounds)?;
+        }
+        view.subarray(offset, end).copy_to(data);
+        Ok(())
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        let view = &self.view;
+        let offset: u32 = offset.try_into().map_err(|_| MemoryAccessError::Overflow)?;
+        if offset >= view.length() {
+            tracing::warn!(
+                "attempted to read beyond the bounds of the memory view ({} >= {})",
+                offset,
+                view.length()
+            );
+            Err(MemoryAccessError::HeapOutOfBounds)?;
+        }
+        Ok(view.get_index(offset))
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let view = &self.view;
+        let offset: u32 = offset.try_into().map_err(|_| MemoryAccessError::Overflow)?;
+        let len: u32 = buf
+            .len()
+            .try_into()
+            .map_err(|_| MemoryAccessError::Overflow)?;
+        let end = offset.checked_add(len).ok_or(MemoryAccessError::Overflow)?;
+        if end > view.length() {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                len,
+                end,
+                view.length()
+            );
+            Err(MemoryAccessError::HeapOutOfBounds)?;
+        }
+
+        // Zero-initialize the buffer to avoid undefined behavior with
+        // uninitialized data.
+        for elem in buf.iter_mut() {
+            *elem = MaybeUninit::new(0);
+        }
+        let buf = unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut u8, buf.len()) };
+
+        view.subarray(offset, end).copy_to(buf);
+        Ok(buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let offset: u32 = offset.try_into().map_err(|_| MemoryAccessError::Overflow)?;
+        let len: u32 = data
+            .len()
+            .try_into()
+            .map_err(|_| MemoryAccessError::Overflow)?;
+        let view = &self.view;
+        let end = offset.checked_add(len).ok_or(MemoryAccessError::Overflow)?;
+        if end > view.length() {
+            tracing::warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                len,
+                end,
+                view.length()
+            );
+            Err(MemoryAccessError::HeapOutOfBounds)?;
+        }
+        view.subarray(offset, end).copy_from(data);
+        Ok(())
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        let view = &self.view;
+        let offset: u32 = offset.try_into().map_err(|_| MemoryAccessError::Overflow)?;
+        if offset >= view.length() {
+            tracing::warn!(
+                "attempted to write beyond the bounds of the memory view ({} >= {})",
+                offset,
+                view.length()
+            );
+            Err(MemoryAccessError::HeapOutOfBounds)?;
+        }
+        view.set_index(offset, val);
+        Ok(())
+    }
+
+    /// Copies the memory and returns it as a vector of bytes
+    #[allow(unused)]
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    /// Copies a range of the memory and returns it as a vector of bytes
+    #[allow(unused)]
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/mod.rs
new file mode 100644
index 0000000..3575fe2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/mod.rs
@@ -0,0 +1,5 @@
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod memory;
+pub(crate) mod memory_view;
+pub(crate) mod table;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/table.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/table.rs
new file mode 100644
index 0000000..f7c2cdd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/externals/table.rs
@@ -0,0 +1,119 @@
+use crate::errors::RuntimeError;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::VMExternTable;
+use crate::vm::{VMExtern, VMFunction, VMTable};
+use crate::{FunctionType, TableType};
+use js_sys::Function;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+// Table can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Table {}
+
+fn set_table_item(table: &VMTable, item_index: u32, item: &Function) -> Result<(), RuntimeError> {
+    table.table.set(item_index, item).map_err(|e| e.into())
+}
+
+fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<Function, RuntimeError> {
+    if !val.is_from_store(store) {
+        return Err(RuntimeError::new("cannot pass Value across contexts"));
+    }
+    match val {
+        Value::FuncRef(Some(ref func)) => Ok(func.0.handle.function.clone().into_inner()),
+        // Only funcrefs is supported by the spec atm
+        _ => unimplemented!("The {val:?} is not yet supported"),
+    }
+}
+
+impl Table {
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let mut store = store;
+        let descriptor = js_sys::Object::new();
+        js_sys::Reflect::set(&descriptor, &"initial".into(), &ty.minimum.into())?;
+        if let Some(max) = ty.maximum {
+            js_sys::Reflect::set(&descriptor, &"maximum".into(), &max.into())?;
+        }
+        js_sys::Reflect::set(&descriptor, &"element".into(), &"anyfunc".into())?;
+
+        let js_table = js_sys::WebAssembly::Table::new(&descriptor)?;
+        let table = VMTable::new(js_table, ty);
+
+        let num_elements = table.table.length();
+        let func = get_function(&mut store, init)?;
+        for i in 0..num_elements {
+            set_table_item(&table, i, &func)?;
+        }
+
+        Ok(Self { handle: table })
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Table(self.handle.clone())
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        if let Some(func) = self.handle.table.get(index).ok() {
+            let ty = FunctionType::new(vec![], vec![]);
+            let vm_function = VMFunction::new(func, ty);
+            let function = crate::Function::from_vm_extern(store, vm_function);
+            Some(Value::FuncRef(Some(function)))
+        } else {
+            None
+        }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        let item = get_function(store, val)?;
+        set_table_item(&self.handle, index, &item)
+    }
+
+    pub fn size(&self, _store: &impl AsStoreRef) -> u32 {
+        self.handle.table.length()
+    }
+
+    pub fn grow(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _delta: u32,
+        _init: Value,
+    ) -> Result<u32, RuntimeError> {
+        unimplemented!();
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Table.copy is not natively supported in Javascript");
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self { handle: vm_extern }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/instance.rs
new file mode 100644
index 0000000..4972641
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/instance.rs
@@ -0,0 +1,76 @@
+use crate::exports::Exports;
+use crate::imports::Imports;
+use crate::js::as_js::AsJs;
+use crate::js::vm::VMInstance;
+use crate::module::Module;
+use crate::store::AsStoreMut;
+use crate::Extern;
+use crate::{errors::InstantiationError, js::js_handle::JsHandle};
+use js_sys::WebAssembly;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Instance {
+    pub(crate) _handle: JsHandle<VMInstance>,
+}
+
+// Instance can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Instance {}
+
+impl Instance {
+    pub(crate) fn new(
+        mut store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let instance = module
+            .0
+            .instantiate(&mut store, imports)
+            .map_err(|e| InstantiationError::Start(e))?;
+
+        Self::from_module_and_instance(store, &module, instance)
+    }
+
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let mut imports = Imports::new();
+        for (import_ty, extern_ty) in module.imports().zip(externs.iter()) {
+            imports.define(import_ty.module(), import_ty.name(), extern_ty.clone());
+        }
+        Self::new(store, module, &imports)
+    }
+
+    /// Creates a Wasmer `Instance` from a Wasmer `Module` and a WebAssembly Instance
+    pub(crate) fn from_module_and_instance(
+        mut store: &mut impl AsStoreMut,
+        module: &Module,
+        instance: WebAssembly::Instance,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let instance_exports = instance.exports();
+
+        let exports = module
+            .exports()
+            .map(|export_type| {
+                let name = export_type.name();
+                let extern_type = export_type.ty();
+                // Annotation is here to prevent spurious IDE warnings.
+                #[allow(unused_unsafe)]
+                let js_export =
+                    unsafe { js_sys::Reflect::get(&instance_exports, &name.into()).unwrap() };
+                let extern_ = Extern::from_jsvalue(&mut store, extern_type, &js_export)
+                    .map_err(|e| wasm_bindgen::JsValue::from(e))
+                    .unwrap();
+                Ok((name.to_string(), extern_))
+            })
+            .collect::<Result<Exports, InstantiationError>>()?;
+
+        let instance = Instance {
+            _handle: JsHandle::new(instance),
+        };
+
+        Ok((instance, exports))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/js_handle.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/js_handle.rs
new file mode 100644
index 0000000..043cc1e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/js_handle.rs
@@ -0,0 +1,221 @@
+use std::{
+    ops::{Deref, DerefMut},
+    sync::atomic::{AtomicU32, Ordering},
+};
+
+use js_sys::Symbol;
+use wasm_bindgen::JsValue;
+
+use self::integrity_check::IntegrityCheck;
+
+/// A handle that lets you detect thread-safety issues when passing a
+/// [`JsValue`] (or derived type) around.
+#[derive(Debug, Clone)]
+pub(crate) struct JsHandle<T> {
+    value: T,
+    integrity: IntegrityCheck,
+}
+
+impl<T> JsHandle<T> {
+    #[track_caller]
+    pub fn new(value: T) -> Self {
+        JsHandle {
+            value,
+            integrity: IntegrityCheck::new(std::any::type_name::<T>()),
+        }
+    }
+
+    #[track_caller]
+    pub fn into_inner(self) -> T {
+        self.integrity.check();
+        self.value
+    }
+}
+
+impl<T: PartialEq> PartialEq for JsHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        let JsHandle {
+            value,
+            integrity: _,
+        } = self;
+
+        *value == other.value
+    }
+}
+
+impl<T: Eq> Eq for JsHandle<T> {}
+
+impl<T> From<T> for JsHandle<T> {
+    #[track_caller]
+    fn from(value: T) -> Self {
+        JsHandle::new(value)
+    }
+}
+
+impl<T: Into<JsValue>> From<JsHandle<T>> for JsValue {
+    fn from(value: JsHandle<T>) -> Self {
+        value.into_inner().into()
+    }
+}
+
+impl<A, T> AsRef<A> for JsHandle<T>
+where
+    T: AsRef<A>,
+{
+    #[track_caller]
+    fn as_ref(&self) -> &A {
+        self.integrity.check();
+        self.value.as_ref()
+    }
+}
+
+impl<T> Deref for JsHandle<T> {
+    type Target = T;
+
+    #[track_caller]
+    fn deref(&self) -> &Self::Target {
+        self.integrity.check();
+        &self.value
+    }
+}
+
+impl<T> DerefMut for JsHandle<T> {
+    #[track_caller]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.integrity.check();
+        &mut self.value
+    }
+}
+
+#[cfg(not(debug_assertions))]
+mod integrity_check {
+
+    #[derive(Debug, Clone, PartialEq)]
+    pub(crate) struct IntegrityCheck;
+
+    impl IntegrityCheck {
+        #[track_caller]
+        pub(crate) fn new(_type_name: &'static str) -> Self {
+            IntegrityCheck
+        }
+
+        pub(crate) fn check(&self) {}
+    }
+}
+
+#[cfg(debug_assertions)]
+mod integrity_check {
+    use std::{fmt::Write as _, panic::Location};
+
+    use js_sys::JsString;
+
+    #[derive(Debug, Clone, PartialEq)]
+    pub(crate) struct IntegrityCheck {
+        original_thread: u32,
+        created: &'static Location<'static>,
+        type_name: &'static str,
+        backtrace: Option<String>,
+    }
+
+    impl IntegrityCheck {
+        #[track_caller]
+        pub(crate) fn new(type_name: &'static str) -> Self {
+            IntegrityCheck {
+                original_thread: super::current_thread_id(),
+                created: Location::caller(),
+                type_name,
+                backtrace: record_backtrace(),
+            }
+        }
+
+        #[track_caller]
+        pub(crate) fn check(&self) {
+            let current_thread = super::current_thread_id();
+
+            if current_thread != self.original_thread {
+                let IntegrityCheck {
+                    original_thread,
+                    created,
+                    type_name,
+                    backtrace,
+                } = self;
+                let mut error_message = String::new();
+
+                writeln!(
+                    error_message,
+                    "Thread-safety integrity check for {type_name} failed."
+                )
+                .unwrap();
+
+                writeln!(
+                    error_message,
+                    "Created at {created} on thread #{original_thread}"
+                )
+                .unwrap();
+
+                if let Some(bt) = backtrace {
+                    writeln!(error_message, "{bt}").unwrap();
+                    writeln!(error_message).unwrap();
+                }
+
+                let caller = Location::caller();
+
+                writeln!(
+                    error_message,
+                    "Accessed from {caller} on thread #{current_thread}"
+                )
+                .unwrap();
+
+                if let Some(bt) = record_backtrace() {
+                    writeln!(error_message, "{bt}").unwrap();
+                    writeln!(error_message).unwrap();
+                }
+
+                panic!("{error_message}");
+            }
+        }
+    }
+
+    fn record_backtrace() -> Option<String> {
+        let err = js_sys::Error::new("");
+        let stack = JsString::from(wasm_bindgen::intern("stack"));
+
+        js_sys::Reflect::get(&err, &stack)
+            .ok()
+            .and_then(|v| v.as_string())
+    }
+}
+
+/// A browser polyfill for [`std::thread::ThreadId`] [`std::thread::current()`].
+///
+/// This works by creating a `$WASMER_THREAD_ID` symbol and setting it on
+/// the global object. As long as they use the same `SharedArrayBuffer` for
+/// their linear memory, each thread (i.e. web worker or the UI thread) is
+/// guaranteed to get a unique ID.
+///
+/// This is mainly intended for use in `wasmer-wasix` and `wasmer-js`, and may
+/// go away in the future.
+#[doc(hidden)]
+pub fn current_thread_id() -> u32 {
+    static NEXT_ID: AtomicU32 = AtomicU32::new(0);
+
+    let global = js_sys::global();
+    let thread_id_symbol = Symbol::for_("$WASMER_THREAD_ID");
+
+    if let Some(v) = js_sys::Reflect::get(&global, &thread_id_symbol)
+        .ok()
+        .and_then(|v| v.as_f64())
+    {
+        // Note: we use a symbol so we know for sure that nobody else created
+        // this field.
+        return v as u32;
+    }
+
+    // Looks like we haven't set the thread ID yet.
+    let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
+
+    js_sys::Reflect::set(&global, &thread_id_symbol, &JsValue::from(id))
+        .expect("Setting a field on the global object should never fail");
+
+    id
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mem_access.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mem_access.rs
new file mode 100644
index 0000000..f8a822d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mem_access.rs
@@ -0,0 +1,65 @@
+use crate::access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess};
+use crate::{MemoryAccessError, WasmRef, WasmSlice};
+use std::mem::{self, MaybeUninit};
+use std::slice;
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
+        let buf = slice.read_to_vec()?;
+        Ok(Self {
+            slice,
+            buf: SliceCow::Owned(buf, false),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
+        let mut out = MaybeUninit::uninit();
+        let buf =
+            unsafe { slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, mem::size_of::<T>()) };
+        ptr.buffer.read(ptr.offset, buf)?;
+        let val = unsafe { out.assume_init() };
+
+        Ok(Self {
+            ptr,
+            buf: RefCow::Owned(val, false),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Reads the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    #[allow(clippy::clone_on_copy)]
+    pub fn read(&self) -> T
+    where
+        T: Clone,
+    {
+        self.as_ref().clone()
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn write(&mut self, val: T) {
+        let mut data = MaybeUninit::new(val);
+        let data = unsafe {
+            slice::from_raw_parts_mut(
+                data.as_mut_ptr() as *mut MaybeUninit<u8>,
+                mem::size_of::<T>(),
+            )
+        };
+        val.zero_padding_bytes(data);
+        let data = unsafe { slice::from_raw_parts(data.as_ptr() as *const _, data.len()) };
+        self.ptr.buffer.write(self.ptr.offset, data).unwrap()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mod.rs
new file mode 100644
index 0000000..0584da2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/mod.rs
@@ -0,0 +1,41 @@
+#[cfg(all(feature = "std", feature = "core"))]
+compile_error!(
+    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
+);
+
+#[cfg(all(not(feature = "std"), not(feature = "core")))]
+compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
+
+#[cfg(feature = "core")]
+pub(crate) extern crate alloc;
+
+mod lib {
+    #[cfg(feature = "core")]
+    pub mod std {
+        pub use crate::alloc::{borrow, boxed, str, string, sync, vec};
+        pub use core::fmt;
+        pub use hashbrown as collections;
+    }
+
+    #[cfg(feature = "std")]
+    pub mod std {
+        pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec};
+    }
+}
+
+mod as_js;
+pub(crate) mod engine;
+pub(crate) mod errors;
+pub(crate) mod extern_ref;
+pub(crate) mod externals;
+pub(crate) mod instance;
+mod js_handle;
+pub(crate) mod mem_access;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod trap;
+pub(crate) mod typed_function;
+pub(crate) mod vm;
+mod wasm_bindgen_polyfill;
+
+pub use self::{as_js::AsJs, js_handle::current_thread_id, module::ModuleTypeHints};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/module.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/module.rs
new file mode 100644
index 0000000..61866ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/module.rs
@@ -0,0 +1,479 @@
+use crate::errors::RuntimeError;
+use crate::imports::Imports;
+use crate::js::AsJs;
+use crate::store::AsStoreMut;
+use crate::vm::VMInstance;
+use crate::Extern;
+use crate::IntoBytes;
+use crate::{errors::InstantiationError, js::js_handle::JsHandle};
+use crate::{AsEngineRef, ExportType, ImportType};
+use bytes::Bytes;
+use js_sys::{Reflect, Uint8Array, WebAssembly};
+use std::path::Path;
+use tracing::{debug, warn};
+use wasm_bindgen::JsValue;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportsIterator, ExternType, FunctionType, GlobalType,
+    ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages, SerializeError, TableType, Type,
+};
+
+/// WebAssembly in the browser doesn't yet output the descriptor/types
+/// corresponding to each extern (import and export).
+///
+/// This should be fixed once the JS-Types Wasm proposal is adopted
+/// by the browsers:
+/// <https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md>
+///
+/// Until that happens, we annotate the module with the expected
+/// types so we can built on top of them at runtime.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ModuleTypeHints {
+    /// The type hints for the imported types
+    pub imports: Vec<ExternType>,
+    /// The type hints for the exported types
+    pub exports: Vec<ExternType>,
+}
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Module {
+    module: JsHandle<WebAssembly::Module>,
+    name: Option<String>,
+    // WebAssembly type hints
+    type_hints: Option<ModuleTypeHints>,
+    #[cfg(feature = "js-serializable-module")]
+    raw_bytes: Option<Bytes>,
+}
+
+// Module implements `structuredClone` in js, so it's safe it to make it Send.
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// ```js
+// const module = new WebAssembly.Module(new Uint8Array([
+//   0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00
+// ]));
+// structuredClone(module)
+// ```
+unsafe impl Send for Module {}
+unsafe impl Sync for Module {}
+
+impl From<Module> for JsValue {
+    fn from(val: Module) -> Self {
+        Self::from(val.module)
+    }
+}
+
+impl Module {
+    pub(crate) fn from_binary(
+        _engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        unsafe { Self::from_binary_unchecked(_engine, binary) }
+    }
+
+    pub(crate) unsafe fn from_binary_unchecked(
+        _engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        let js_bytes = Uint8Array::view(binary);
+        let module = WebAssembly::Module::new(&js_bytes.into())
+            .map_err(|e| CompileError::Validate(format!("{}", e.as_string().unwrap())))?;
+        Ok(Self::from_js_module(module, binary))
+    }
+
+    /// Creates a new WebAssembly module skipping any kind of validation from a javascript module
+    pub(crate) unsafe fn from_js_module(
+        module: WebAssembly::Module,
+        binary: impl IntoBytes,
+    ) -> Self {
+        let binary = binary.into_bytes();
+
+        // The module is now validated, so we can safely parse it's types
+        #[cfg(feature = "wasm-types-polyfill")]
+        let (type_hints, name) = {
+            let info = crate::module_info_polyfill::translate_module(&binary[..]).unwrap();
+
+            (
+                Some(ModuleTypeHints {
+                    imports: info
+                        .info
+                        .imports()
+                        .map(|import| import.ty().clone())
+                        .collect::<Vec<_>>(),
+                    exports: info
+                        .info
+                        .exports()
+                        .map(|export| export.ty().clone())
+                        .collect::<Vec<_>>(),
+                }),
+                info.info.name,
+            )
+        };
+        #[cfg(not(feature = "wasm-types-polyfill"))]
+        let (type_hints, name) = (None, None);
+
+        Self {
+            module: JsHandle::new(module),
+            type_hints,
+            name,
+            #[cfg(feature = "js-serializable-module")]
+            raw_bytes: Some(binary),
+        }
+    }
+
+    pub fn validate(_engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        let js_bytes = unsafe { Uint8Array::view(binary) };
+        // Annotation is here to prevent spurious IDE warnings.
+        #[allow(unused_unsafe)]
+        unsafe {
+            match WebAssembly::validate(&js_bytes.into()) {
+                Ok(true) => Ok(()),
+                _ => Err(CompileError::Validate("Invalid Wasm file".to_owned())),
+            }
+        }
+    }
+
+    pub(crate) fn instantiate(
+        &self,
+        store: &mut impl AsStoreMut,
+        imports: &Imports,
+    ) -> Result<VMInstance, RuntimeError> {
+        // Ensure all imports come from the same store.
+        if imports
+            .into_iter()
+            .any(|(_, import)| !import.is_from_store(store))
+        {
+            return Err(RuntimeError::user(Box::new(
+                InstantiationError::DifferentStores,
+            )));
+        }
+
+        let imports_object = js_sys::Object::new();
+        let mut import_externs: Vec<Extern> = vec![];
+        for import_type in self.imports() {
+            let resolved_import = imports.get_export(import_type.module(), import_type.name());
+            // Annotation is here to prevent spurious IDE warnings.
+            #[allow(unused_variables)]
+            if let wasmer_types::ExternType::Memory(mem_ty) = import_type.ty() {
+                if resolved_import.is_some() {
+                    debug!("imported shared memory {:?}", &mem_ty);
+                } else {
+                    warn!(
+                        "Error while importing {0:?}.{1:?}: memory. Expected {2:?}",
+                        import_type.module(),
+                        import_type.name(),
+                        import_type.ty(),
+                    );
+                }
+            }
+            // Annotation is here to prevent spurious IDE warnings.
+            #[allow(unused_unsafe)]
+            unsafe {
+                if let Some(import) = resolved_import {
+                    let val = js_sys::Reflect::get(&imports_object, &import_type.module().into())?;
+                    if !val.is_undefined() {
+                        // If the namespace is already set
+                        js_sys::Reflect::set(
+                            &val,
+                            &import_type.name().into(),
+                            &import.as_jsvalue(&store.as_store_ref()),
+                        )?;
+                    } else {
+                        // If the namespace doesn't exist
+                        let import_namespace = js_sys::Object::new();
+                        js_sys::Reflect::set(
+                            &import_namespace,
+                            &import_type.name().into(),
+                            &import.as_jsvalue(&store.as_store_ref()),
+                        )?;
+                        js_sys::Reflect::set(
+                            &imports_object,
+                            &import_type.module().into(),
+                            &import_namespace.into(),
+                        )?;
+                    }
+                    import_externs.push(import);
+                } else {
+                    warn!(
+                        "import not found {}:{}",
+                        import_type.module(),
+                        import_type.name()
+                    );
+                }
+            }
+            // in case the import is not found, the JS Wasm VM will handle
+            // the error for us, so we don't need to handle it
+        }
+        Ok(WebAssembly::Instance::new(&self.module, &imports_object)
+            .map_err(|e: JsValue| -> RuntimeError { e.into() })?)
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|s| s.as_ref())
+    }
+
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        #[cfg(feature = "js-serializable-module")]
+        return self.raw_bytes.clone().ok_or(SerializeError::Generic(
+            "Not able to serialize module".to_string(),
+        ));
+
+        #[cfg(not(feature = "js-serializable-module"))]
+        return Err(SerializeError::Generic(
+            "You need to enable the `js-serializable-module` feature flag to serialize a `Module`"
+                .to_string(),
+        ));
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub unsafe fn deserialize_unchecked(
+        _engine: &impl AsEngineRef,
+        _bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        #[cfg(feature = "js-serializable-module")]
+        return Self::from_binary(_engine, &_bytes.into_bytes())
+            .map_err(|e| DeserializeError::Compiler(e));
+
+        #[cfg(not(feature = "js-serializable-module"))]
+        return Err(DeserializeError::Generic("You need to enable the `js-serializable-module` feature flag to deserialize a `Module`".to_string()));
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub unsafe fn deserialize(
+        _engine: &impl AsEngineRef,
+        _bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        #[cfg(feature = "js-serializable-module")]
+        return Self::from_binary(_engine, &_bytes.into_bytes())
+            .map_err(|e| DeserializeError::Compiler(e));
+
+        #[cfg(not(feature = "js-serializable-module"))]
+        return Err(DeserializeError::Generic("You need to enable the `js-serializable-module` feature flag to deserialize a `Module`".to_string()));
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.name = Some(name.to_string());
+        true
+        // match Reflect::set(self.module.as_ref(), &"wasmer_name".into(), &name.into()) {
+        //     Ok(_) => true,
+        //     _ => false
+        // }
+        // Arc::get_mut(&mut self.artifact)
+        //     .and_then(|artifact| artifact.module_mut())
+        //     .map(|mut module_info| {
+        //         module_info.info.name = Some(name.to_string());
+        //         true
+        //     })
+        //     .unwrap_or(false)
+    }
+
+    pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
+        let imports = WebAssembly::Module::imports(&self.module);
+        let iter = imports
+            .iter()
+            .enumerate()
+            .map(move |(i, val)| {
+                // Annotation is here to prevent spurious IDE warnings.
+                #[allow(unused_unsafe)]
+                unsafe {
+                    let module = Reflect::get(val.as_ref(), &"module".into())
+                        .unwrap()
+                        .as_string()
+                        .unwrap();
+                    let field = Reflect::get(val.as_ref(), &"name".into())
+                        .unwrap()
+                        .as_string()
+                        .unwrap();
+                    let kind = Reflect::get(val.as_ref(), &"kind".into())
+                        .unwrap()
+                        .as_string()
+                        .unwrap();
+                    let type_hint = self
+                        .type_hints
+                        .as_ref()
+                        .map(|hints| hints.imports.get(i).unwrap().clone());
+                    let extern_type = if let Some(hint) = type_hint {
+                        hint
+                    } else {
+                        match kind.as_str() {
+                            "function" => {
+                                let func_type = FunctionType::new(vec![], vec![]);
+                                ExternType::Function(func_type)
+                            }
+                            "global" => {
+                                let global_type = GlobalType::new(Type::I32, Mutability::Const);
+                                ExternType::Global(global_type)
+                            }
+                            "memory" => {
+                                // The javascript API does not yet expose these properties so without
+                                // the type_hints we don't know what memory to import.
+                                let memory_type = MemoryType::new(Pages(1), None, false);
+                                ExternType::Memory(memory_type)
+                            }
+                            "table" => {
+                                let table_type = TableType::new(Type::FuncRef, 1, None);
+                                ExternType::Table(table_type)
+                            }
+                            _ => unimplemented!(),
+                        }
+                    };
+                    ImportType::new(&module, &field, extern_type)
+                }
+            })
+            .collect::<Vec<_>>()
+            .into_iter();
+        ImportsIterator::new(iter, imports.length() as usize)
+    }
+
+    /// Set the type hints for this module.
+    ///
+    /// Returns an error if the hints doesn't match the shape of
+    /// import or export types of the module.
+    #[allow(unused)]
+    pub fn set_type_hints(&mut self, type_hints: ModuleTypeHints) -> Result<(), String> {
+        let exports = WebAssembly::Module::exports(&self.module);
+        // Check exports
+        if exports.length() as usize != type_hints.exports.len() {
+            return Err("The exports length must match the type hints lenght".to_owned());
+        }
+        for (i, val) in exports.iter().enumerate() {
+            // Annotation is here to prevent spurious IDE warnings.
+            #[allow(unused_unsafe)]
+            let kind = unsafe {
+                Reflect::get(val.as_ref(), &"kind".into())
+                    .unwrap()
+                    .as_string()
+                    .unwrap()
+            };
+            // It is safe to unwrap as we have already checked for the exports length
+            let type_hint = type_hints.exports.get(i).unwrap();
+            let expected_kind = match type_hint {
+                ExternType::Function(_) => "function",
+                ExternType::Global(_) => "global",
+                ExternType::Memory(_) => "memory",
+                ExternType::Table(_) => "table",
+            };
+            if expected_kind != kind.as_str() {
+                return Err(format!("The provided type hint for the export {} is {} which doesn't match the expected kind: {}", i, kind.as_str(), expected_kind));
+            }
+        }
+        self.type_hints = Some(type_hints);
+        Ok(())
+    }
+
+    pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
+        let exports = WebAssembly::Module::exports(&self.module);
+        let iter = exports
+            .iter()
+            .enumerate()
+            .map(move |(i, val)| {
+                // Annotation is here to prevent spurious IDE warnings.
+                #[allow(unused_unsafe)]
+                let field = unsafe {
+                    Reflect::get(val.as_ref(), &"name".into())
+                        .unwrap()
+                        .as_string()
+                        .unwrap()
+                };
+                // Annotation is here to prevent spurious IDE warnings.
+                #[allow(unused_unsafe)]
+                let kind = unsafe {
+                    Reflect::get(val.as_ref(), &"kind".into())
+                        .unwrap()
+                        .as_string()
+                        .unwrap()
+                };
+                let type_hint = self
+                    .type_hints
+                    .as_ref()
+                    .map(|hints| hints.exports.get(i).unwrap().clone());
+                let extern_type = if let Some(hint) = type_hint {
+                    hint
+                } else {
+                    // The default types
+                    match kind.as_str() {
+                        "function" => {
+                            let func_type = FunctionType::new(vec![], vec![]);
+                            ExternType::Function(func_type)
+                        }
+                        "global" => {
+                            let global_type = GlobalType::new(Type::I32, Mutability::Const);
+                            ExternType::Global(global_type)
+                        }
+                        "memory" => {
+                            let memory_type = MemoryType::new(Pages(1), None, false);
+                            ExternType::Memory(memory_type)
+                        }
+                        "table" => {
+                            let table_type = TableType::new(Type::FuncRef, 1, None);
+                            ExternType::Table(table_type)
+                        }
+                        _ => unimplemented!(),
+                    }
+                };
+                ExportType::new(&field, extern_type)
+            })
+            .collect::<Vec<_>>()
+            .into_iter();
+        ExportsIterator::new(iter, exports.length() as usize)
+    }
+
+    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        WebAssembly::Module::custom_sections(&self.module, name)
+            .iter()
+            .map(move |buf_val| {
+                let typebuf: js_sys::Uint8Array = js_sys::Uint8Array::new(&buf_val);
+                typebuf.to_vec().into_boxed_slice()
+            })
+            .collect::<Vec<Box<[u8]>>>()
+            .into_iter()
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        unimplemented!()
+    }
+}
+
+impl From<WebAssembly::Module> for Module {
+    #[track_caller]
+    fn from(module: WebAssembly::Module) -> Module {
+        Module {
+            module: JsHandle::new(module),
+            name: None,
+            type_hints: None,
+            #[cfg(feature = "js-serializable-module")]
+            raw_bytes: None,
+        }
+    }
+}
+
+impl<T: IntoBytes> From<(WebAssembly::Module, T)> for crate::module::Module {
+    fn from((module, binary): (WebAssembly::Module, T)) -> crate::module::Module {
+        unsafe { crate::module::Module(Module::from_js_module(module, binary.into_bytes())) }
+    }
+}
+
+impl From<WebAssembly::Module> for crate::module::Module {
+    fn from(module: WebAssembly::Module) -> crate::module::Module {
+        crate::module::Module(module.into())
+    }
+}
+impl From<crate::module::Module> for WebAssembly::Module {
+    fn from(value: crate::module::Module) -> Self {
+        value.0.module.into_inner()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/store.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/store.rs
new file mode 100644
index 0000000..03f229a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/store.rs
@@ -0,0 +1,266 @@
+pub(crate) use objects::{InternalStoreHandle, StoreObject};
+pub use objects::{StoreHandle, StoreObjects};
+
+mod objects {
+    use std::{fmt, marker::PhantomData, num::NonZeroUsize};
+
+    use wasm_bindgen::JsValue;
+
+    use crate::js::vm::{VMFunctionEnvironment, VMGlobal};
+
+    pub use wasmer_types::StoreId;
+
+    /// Trait to represent an object managed by a context. This is implemented on
+    /// the VM types managed by the context.
+    pub trait StoreObject: Sized {
+        fn list(store: &StoreObjects) -> &Vec<Self>;
+        fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+    }
+
+    macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+    };
+}
+
+    impl_store_object! {
+        // Note: we store the globals in order to be able to access them later via
+        // `StoreObjects::iter_globals`.
+        globals => VMGlobal,
+        // functions => VMFunction,
+        // tables => VMTable,
+        // memories => VMMemory,
+        // The function environments are the only things attached to a store,
+        // since the other JS objects (table, globals, memory and functions)
+        // live in the JS VM Store by default
+        function_environments => VMFunctionEnvironment,
+    }
+
+    /// Set of objects managed by a context.
+    #[derive(Default, Debug)]
+    pub struct StoreObjects {
+        id: StoreId,
+        globals: Vec<VMGlobal>,
+        function_environments: Vec<VMFunctionEnvironment>,
+    }
+
+    impl StoreObjects {
+        /// Returns the ID of this context.
+        pub fn id(&self) -> StoreId {
+            self.id
+        }
+
+        /// Sets the ID of this store
+        pub fn set_id(&mut self, id: StoreId) {
+            self.id = id;
+        }
+
+        /// Returns a pair of mutable references from two handles.
+        ///
+        /// Panics if both handles point to the same object.
+        pub fn get_2_mut<T: StoreObject>(
+            &mut self,
+            a: InternalStoreHandle<T>,
+            b: InternalStoreHandle<T>,
+        ) -> (&mut T, &mut T) {
+            assert_ne!(a.index(), b.index());
+            let list = T::list_mut(self);
+            if a.index() < b.index() {
+                let (low, high) = list.split_at_mut(b.index());
+                (&mut low[a.index()], &mut high[0])
+            } else {
+                let (low, high) = list.split_at_mut(a.index());
+                (&mut high[0], &mut low[a.index()])
+            }
+        }
+
+        /// Return an immutable iterator over all globals
+        pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+            self.globals.iter()
+        }
+
+        /// Return an vector of all globals and converted to u128
+        pub fn as_u128_globals(&self) -> Vec<u128> {
+            self.iter_globals()
+                .map(|v| v.global.value().as_f64().unwrap() as u128)
+                .collect()
+        }
+
+        /// Set a global, at index idx. Will panic if idx is out of range
+        /// Safety: the caller should check that the raw value is compatible
+        /// with destination VMGlobal type
+        pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+            assert!(idx < self.globals.len());
+
+            let g = &self.globals[idx].global;
+            let cur_val = g.value().as_f64().unwrap();
+            let new_val = new_val as f64;
+            if cur_val != new_val {
+                let new_value = JsValue::from(new_val);
+                g.set_value(&new_value);
+            }
+        }
+    }
+
+    /// Handle to an object managed by a context.
+    ///
+    /// Internally this is just an integer index into a context. A reference to the
+    /// context must be passed in separately to access the actual object.
+    pub struct StoreHandle<T> {
+        id: StoreId,
+        internal: InternalStoreHandle<T>,
+    }
+
+    impl<T> core::cmp::PartialEq for StoreHandle<T> {
+        fn eq(&self, other: &Self) -> bool {
+            self.id == other.id
+        }
+    }
+
+    impl<T> std::hash::Hash for StoreHandle<T> {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            self.id.hash(state);
+            self.internal.idx.hash(state);
+        }
+    }
+
+    impl<T> Clone for StoreHandle<T> {
+        fn clone(&self) -> Self {
+            Self {
+                id: self.id,
+                internal: self.internal,
+            }
+        }
+    }
+
+    impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("StoreHandle")
+                .field("id", &self.id)
+                .field("internal", &self.internal.index())
+                .finish()
+        }
+    }
+
+    impl<T: StoreObject> StoreHandle<T> {
+        /// Moves the given object into a context and returns a handle to it.
+        pub fn new(store: &mut StoreObjects, val: T) -> Self {
+            Self {
+                id: store.id,
+                internal: InternalStoreHandle::new(store, val),
+            }
+        }
+
+        /// Returns a reference to the object that this handle points to.
+        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+            assert_eq!(self.id, store.id, "object used with the wrong context");
+            self.internal.get(store)
+        }
+
+        /// Returns a mutable reference to the object that this handle points to.
+        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+            assert_eq!(self.id, store.id, "object used with the wrong context");
+            self.internal.get_mut(store)
+        }
+
+        /// Returns the internal handle contains within this handle.
+        pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+            self.internal
+        }
+
+        /// Returns the ID of the context associated with the handle.
+        #[allow(unused)]
+        pub fn store_id(&self) -> StoreId {
+            self.id
+        }
+
+        /// Overrides the store id with a new ID
+        #[allow(unused)]
+        pub fn set_store_id(&mut self, id: StoreId) {
+            self.id = id;
+        }
+
+        /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+        ///
+        /// # Safety
+        /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+        pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+            Self { id, internal }
+        }
+    }
+
+    /// Internal handle to an object owned by the current context.
+    ///
+    /// Unlike `StoreHandle` this does not track the context ID: it is only
+    /// intended to be used within objects already owned by a context.
+    #[repr(transparent)]
+    pub struct InternalStoreHandle<T> {
+        // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+        idx: NonZeroUsize,
+        marker: PhantomData<fn() -> T>,
+    }
+
+    impl<T> Clone for InternalStoreHandle<T> {
+        fn clone(&self) -> Self {
+            *self
+        }
+    }
+    impl<T> Copy for InternalStoreHandle<T> {}
+
+    impl<T> fmt::Debug for InternalStoreHandle<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("InternalStoreHandle")
+                .field("idx", &self.idx)
+                .finish()
+        }
+    }
+    impl<T> PartialEq for InternalStoreHandle<T> {
+        fn eq(&self, other: &Self) -> bool {
+            self.idx == other.idx
+        }
+    }
+    impl<T> Eq for InternalStoreHandle<T> {}
+
+    impl<T: StoreObject> InternalStoreHandle<T> {
+        /// Moves the given object into a context and returns a handle to it.
+        pub fn new(store: &mut StoreObjects, val: T) -> Self {
+            let list = T::list_mut(store);
+            let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+            list.push(val);
+            Self {
+                idx,
+                marker: PhantomData,
+            }
+        }
+
+        /// Returns a reference to the object that this handle points to.
+        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+            &T::list(store)[self.idx.get() - 1]
+        }
+
+        /// Returns a mutable reference to the object that this handle points to.
+        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+            &mut T::list_mut(store)[self.idx.get() - 1]
+        }
+
+        pub(crate) fn index(&self) -> usize {
+            self.idx.get()
+        }
+
+        pub(crate) fn from_index(idx: usize) -> Option<Self> {
+            NonZeroUsize::new(idx).map(|idx| Self {
+                idx,
+                marker: PhantomData,
+            })
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/trap.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/trap.rs
new file mode 100644
index 0000000..23a002e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/trap.rs
@@ -0,0 +1,179 @@
+use std::{
+    error::Error,
+    fmt::{self, Display},
+};
+
+use js_sys::Reflect;
+use wasm_bindgen::{prelude::*, JsValue};
+
+use crate::RuntimeError;
+
+#[derive(Debug)]
+enum InnerTrap {
+    User(Box<dyn Error + Send + Sync>),
+    Js(JsTrap),
+}
+
+/// A struct representing a Trap
+#[wasm_bindgen(skip_typescript)]
+#[derive(Debug)]
+pub struct Trap {
+    inner: InnerTrap,
+}
+
+impl Trap {
+    pub fn user(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self {
+            inner: InnerTrap::User(error),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match &self.inner {
+            InnerTrap::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+}
+
+#[wasm_bindgen]
+impl Trap {
+    /// A marker method to indicate that an object is an instance of the `Trap`
+    /// class.
+    pub fn __wbg_wasmer_trap() {}
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            InnerTrap::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Trap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "user: {e}"),
+            InnerTrap::Js(value) => write!(f, "js: {value}"),
+        }
+    }
+}
+
+impl From<JsValue> for RuntimeError {
+    fn from(value: JsValue) -> Self {
+        // We try to downcast the error and see if it's an instance of Trap
+        // instead, so we don't need to re-wrap it.
+        if let Some(obj) = value.dyn_ref() {
+            if let Some(trap) = downcast_from_ptr(obj) {
+                return trap.into();
+            }
+        }
+
+        RuntimeError::from(Trap {
+            inner: InnerTrap::Js(value.into()),
+        })
+    }
+}
+
+/// This whole mechanism works because the JavaScript wrapper class has a static
+/// `__wbg_wasmer_trap()` method which marks that it is a [`Trap`].
+///
+/// If that method exists, we assume the pointer is valid and safe to cast back
+/// to our type.
+fn downcast_from_ptr(value: &JsValue) -> Option<Trap> {
+    if !value.is_object() {
+        return None;
+    }
+
+    let prototype = &Reflect::get_prototype_of(value).ok()?;
+    let class = prototype.constructor();
+    let key = JsValue::from_str("__wbg_wasmer_trap");
+
+    let marker_func: Option<js_sys::Function> = Reflect::get(&class, &key)
+        .and_then(|v: JsValue| v.dyn_into())
+        .ok();
+
+    if marker_func.is_none() {
+        // We couldn't find the marker, so it's something else.
+        return None;
+    }
+
+    // Safety: The marker function exists, therefore it's safe to convert back
+    // to a Trap.
+    unsafe {
+        // Note: this assumes the wrapper class generated by #[wasm_bindgen] will
+        // always have a `__destroy_into_raw()` method which consumes the `Trap`
+        // wrapper and returns a pointer.
+        //
+        // This is valid as of wasm-bindgen version 0.2.87
+        let key = JsValue::from_str("__destroy_into_raw");
+        let ptr = Reflect::get(value, &key)
+            .ok()
+            .and_then(|v| v.dyn_into::<js_sys::Function>().ok())
+            .and_then(|destroy_into_raw| destroy_into_raw.call0(value).ok())
+            .and_then(|ret| ret.as_f64())?;
+
+        Some(<Trap as wasm_bindgen::convert::FromWasmAbi>::from_abi(
+            ptr as u32,
+        ))
+    }
+}
+
+/// A `Send+Sync` version of a JavaScript error.
+#[derive(Debug)]
+enum JsTrap {
+    /// An error message.
+    Message(String),
+    /// Unable to determine the underlying error.
+    Unknown,
+}
+
+impl From<JsValue> for JsTrap {
+    fn from(value: JsValue) -> Self {
+        // Let's try some easy special cases first
+        if let Some(error) = value.dyn_ref::<js_sys::Error>() {
+            return JsTrap::Message(error.message().into());
+        }
+
+        if let Some(s) = value.as_string() {
+            return JsTrap::Message(s);
+        }
+
+        // Otherwise, we'll try to stringify the error and hope for the best
+        if let Some(obj) = value.dyn_ref::<js_sys::Object>() {
+            return JsTrap::Message(obj.to_string().into());
+        }
+
+        JsTrap::Unknown
+    }
+}
+
+impl Display for JsTrap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            JsTrap::Message(m) => write!(f, "{m}"),
+            JsTrap::Unknown => write!(f, "unknown"),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/typed_function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/typed_function.rs
new file mode 100644
index 0000000..22cd2bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/typed_function.rs
@@ -0,0 +1,116 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
+//! ```
+use crate::native_type::NativeWasmTypeInto;
+use crate::Value;
+use crate::{AsStoreMut, TypedFunction};
+use crate::{FromToNativeWasmType, RuntimeError, WasmTypeList};
+// use std::panic::{catch_unwind, AssertUnwindSafe};
+use crate::js::as_js::{param_from_js, AsJs};
+use js_sys::Array;
+use std::iter::FromIterator;
+use wasm_bindgen::JsValue;
+use wasmer_types::RawValue;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+        impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+        where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+        {
+            /// Call the typed func and return results.
+            #[allow(clippy::too_many_arguments)]
+            pub fn call(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType + NativeWasmTypeInto, )*
+            {
+                #[allow(unused_unsafe)]
+                let params_list: Vec<_> = unsafe {
+                    vec![ $( ($x::WASM_TYPE, $x.into_raw(store) ) ),* ]
+                };
+                let results = {
+                    let mut r;
+                    // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+                    loop {
+                        r = self.func.0.handle.function.apply(
+                            &JsValue::UNDEFINED,
+                            unsafe {
+                                &Array::from_iter(params_list.clone()
+                                .into_iter()
+                                .map(|(b, a)| Value::from_raw(store, b, a).as_jsvalue(store)))
+                                }
+                        );
+                        let store_mut = store.as_store_mut();
+                        if let Some(callback) = store_mut.inner.on_called.take() {
+                            match callback(store_mut) {
+                                Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                                Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                                Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                                Err(trap) => { return Err(RuntimeError::user(trap)) },
+                            }
+                        }
+                        break;
+                    }
+                    r?
+                };
+                let mut rets_list_array = Rets::empty_array();
+                let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
+                match Rets::size() {
+                    0 => {},
+                    1 => unsafe {
+                        let ty = Rets::wasm_types()[0];
+                        let val = param_from_js(&ty, &results);
+                        *mut_rets = val.as_raw(&mut store);
+                    }
+                    _n => {
+                        let results: Array = results.into();
+                        for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
+                            let ret = results.get(i as u32);
+                            unsafe {
+                                let val = param_from_js(&ret_type, &ret);
+                                let slot = mut_rets.add(i);
+                                *slot = val.as_raw(&mut store);
+                            }
+                        }
+                    }
+                }
+                Ok(unsafe { Rets::from_array(store, rets_list_array) })
+            }
+        }
+    };
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/vm.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/vm.rs
new file mode 100644
index 0000000..3d22705
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/vm.rs
@@ -0,0 +1,291 @@
+/// This module is mainly used to create the `VM` types that will hold both
+/// the JS values of the `Memory`, `Table`, `Global` and `Function` and also
+/// it's types.
+/// This module should not be needed any longer (with the exception of the memory)
+/// once the type reflection is added to the WebAssembly JS API.
+/// https://github.com/WebAssembly/js-types/
+use std::{any::Any, fmt};
+
+use js_sys::{
+    Function as JsFunction,
+    WebAssembly::{self, Memory as JsMemory, Table as JsTable},
+};
+use serde::{Deserialize, Serialize};
+use tracing::trace;
+use wasm_bindgen::{JsCast, JsValue};
+use wasmer_types::{
+    FunctionType, GlobalType, MemoryError, MemoryType, Pages, RawValue, TableType, WASM_PAGE_SIZE,
+};
+
+use crate::js::{js_handle::JsHandle, wasm_bindgen_polyfill::Global as JsGlobal};
+
+/// Represents linear memory that is managed by the javascript runtime
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMMemory {
+    pub(crate) memory: JsHandle<JsMemory>,
+    pub(crate) ty: MemoryType,
+}
+
+unsafe impl Send for VMMemory {}
+unsafe impl Sync for VMMemory {}
+
+#[derive(Serialize, Deserialize)]
+struct DummyBuffer {
+    #[serde(rename = "byteLength")]
+    byte_length: u32,
+}
+
+impl VMMemory {
+    /// Creates a new memory directly from a WebAssembly javascript object
+    pub fn new(memory: JsMemory, ty: MemoryType) -> Self {
+        Self {
+            memory: JsHandle::new(memory),
+            ty,
+        }
+    }
+
+    /// Returns the size of the memory buffer in pages
+    pub fn get_runtime_size(&self) -> u32 {
+        let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
+            Ok(o) => o,
+            Err(_) => return 0,
+        };
+        if dummy.byte_length == 0 {
+            return 0;
+        }
+        dummy.byte_length / WASM_PAGE_SIZE as u32
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    #[deprecated = "use `copy` instead"]
+    pub fn duplicate(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
+        self.copy()
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<VMMemory, wasmer_types::MemoryError> {
+        let new_memory = crate::js::externals::memory::Memory::js_memory_from_type(&self.ty)?;
+
+        let src = crate::js::externals::memory_view::MemoryView::new_raw(&self.memory);
+        let amount = src.data_size() as usize;
+
+        trace!(%amount, "memory copy started");
+
+        let mut dst = crate::js::externals::memory_view::MemoryView::new_raw(&new_memory);
+        let dst_size = dst.data_size() as usize;
+
+        if amount > dst_size {
+            let delta = amount - dst_size;
+            let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
+
+            let our_js_memory: &crate::js::externals::memory::JSMemory =
+                JsCast::unchecked_from_js_ref(&new_memory);
+            our_js_memory.grow(pages as u32).map_err(|err| {
+                if err.is_instance_of::<js_sys::RangeError>() {
+                    let cur_pages = dst_size;
+                    MemoryError::CouldNotGrow {
+                        current: Pages(cur_pages as u32),
+                        attempted_delta: Pages(pages as u32),
+                    }
+                } else {
+                    MemoryError::Generic(err.as_string().unwrap())
+                }
+            })?;
+
+            dst = crate::js::externals::memory_view::MemoryView::new_raw(&new_memory);
+        }
+
+        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
+            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
+        })?;
+
+        trace!("memory copy finished (size={})", dst.size().bytes().0);
+
+        Ok(Self {
+            memory: JsHandle::new(new_memory),
+            ty: self.ty.clone(),
+        })
+    }
+}
+
+impl From<VMMemory> for JsValue {
+    fn from(value: VMMemory) -> Self {
+        JsValue::from(value.memory)
+    }
+}
+
+impl From<VMMemory> for (JsValue, MemoryType) {
+    fn from(value: VMMemory) -> Self {
+        (JsValue::from(value.memory), value.ty)
+    }
+}
+
+/// The shared memory is the same as the normal memory
+pub type VMSharedMemory = VMMemory;
+
+/// The VM Global type
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMGlobal {
+    pub(crate) global: JsGlobal,
+    pub(crate) ty: GlobalType,
+}
+
+impl VMGlobal {
+    pub(crate) fn new(global: JsGlobal, ty: GlobalType) -> Self {
+        Self { global, ty }
+    }
+}
+
+unsafe impl Send for VMGlobal {}
+unsafe impl Sync for VMGlobal {}
+
+/// The VM Table type
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMTable {
+    pub(crate) table: JsTable,
+    pub(crate) ty: TableType,
+}
+
+unsafe impl Send for VMTable {}
+unsafe impl Sync for VMTable {}
+
+impl VMTable {
+    pub(crate) fn new(table: JsTable, ty: TableType) -> Self {
+        Self { table, ty }
+    }
+
+    /// Get the table size at runtime
+    pub fn get_runtime_size(&self) -> u32 {
+        self.table.length()
+    }
+}
+
+/// The VM Function type
+#[derive(Clone)]
+pub struct VMFunction {
+    pub(crate) function: JsHandle<JsFunction>,
+    pub(crate) ty: FunctionType,
+}
+
+unsafe impl Send for VMFunction {}
+unsafe impl Sync for VMFunction {}
+
+impl VMFunction {
+    pub(crate) fn new(function: JsFunction, ty: FunctionType) -> Self {
+        Self {
+            function: JsHandle::new(function),
+            ty,
+        }
+    }
+}
+
+impl PartialEq for VMFunction {
+    fn eq(&self, other: &Self) -> bool {
+        self.function == other.function
+    }
+}
+
+impl fmt::Debug for VMFunction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("VMFunction")
+            .field("function", &self.function)
+            .finish()
+    }
+}
+
+/// The value of an export passed from one instance to another.
+pub enum VMExtern {
+    /// A function export value.
+    Function(VMFunction),
+
+    /// A table export value.
+    Table(VMTable),
+
+    /// A memory export value.
+    Memory(VMMemory),
+
+    /// A global export value.
+    Global(VMGlobal),
+}
+
+pub type VMInstance = WebAssembly::Instance;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
+
+pub(crate) struct VMExternRef;
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+#[repr(C)]
+pub struct VMFunctionBody(u8);
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct VMFuncRef;
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMFuncRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw.funcref` must be a valid pointer.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub struct VMTrampoline;
+
+pub(crate) type VMExternTable = VMTable;
+pub(crate) type VMExternMemory = VMMemory;
+pub(crate) type VMExternGlobal = VMGlobal;
+pub(crate) type VMExternFunction = VMFunction;
+
+pub type VMFunctionCallback = *const VMFunctionBody;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/js/wasm_bindgen_polyfill.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/wasm_bindgen_polyfill.rs
new file mode 100644
index 0000000..80f89a6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/js/wasm_bindgen_polyfill.rs
@@ -0,0 +1,33 @@
+use js_sys::Object;
+use wasm_bindgen::prelude::*;
+
+// WebAssembly.Global
+#[wasm_bindgen]
+extern "C" {
+    /// The `WebAssembly.Global()` constructor creates a new `Global` object
+    /// of the given type and value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+    #[wasm_bindgen(js_namespace = WebAssembly, extends = Object, typescript_type = "WebAssembly.Global")]
+    #[derive(Clone, Debug, PartialEq, Eq)]
+    pub type Global;
+
+    /// The `WebAssembly.Global()` constructor creates a new `Global` object
+    /// of the given type and value.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+    #[allow(unused_doc_comments)]
+    #[wasm_bindgen(constructor, js_namespace = WebAssembly, catch)]
+    pub fn new(global_descriptor: &Object, value: &JsValue) -> Result<Global, JsValue>;
+
+    /// The value prototype property of the `WebAssembly.Global` object
+    /// returns the value of the global.
+    ///
+    /// [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Global)
+    #[allow(unused_doc_comments)]
+    #[wasm_bindgen(method, getter, structural, js_namespace = WebAssembly)]
+    pub fn value(this: &Global) -> JsValue;
+
+    #[wasm_bindgen(method, setter = value, structural, js_namespace = WebAssembly)]
+    pub fn set_value(this: &Global, value: &JsValue);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/as_js.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/as_js.rs
new file mode 100644
index 0000000..77175fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/as_js.rs
@@ -0,0 +1,154 @@
+use crate::imports::Imports;
+use crate::instance::Instance;
+use crate::jsc::engine::JSC;
+use crate::jsc::instance::Instance as JsInstance;
+use crate::jsc::vm::{VMFunction, VMGlobal, VMMemory, VMTable};
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::Type;
+use crate::{Extern, Function, Global, Memory, Table};
+use rusty_jsc::{JSContext, JSObject, JSValue};
+use std::collections::HashMap;
+use std::convert::TryInto;
+use wasmer_types::ExternType;
+
+/// Convert the given type to a [`JsValue`].
+pub trait AsJs: Sized {
+    /// The inner definition type from this Javascript object
+    type DefinitionType;
+    /// Convert the given type to a [`JsValue`].
+    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JSValue;
+    /// Convert the given type to a [`JsValue`].
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        type_: &Self::DefinitionType,
+        value: &JSValue,
+    ) -> Result<Self, JSValue>;
+}
+
+#[inline]
+pub fn param_from_js(context: &JSContext, ty: &Type, js_val: &JSValue) -> Value {
+    match ty {
+        Type::I32 => Value::I32(js_val.to_number(&context).unwrap() as _),
+        Type::I64 => {
+            let number = if js_val.is_number(&context) {
+                js_val.to_number(&context).unwrap() as _
+            } else {
+                js_val
+                    .to_string(&context)
+                    .unwrap()
+                    .to_string()
+                    .parse()
+                    .unwrap()
+            };
+            Value::I64(number)
+        }
+        Type::F32 => Value::F32(js_val.to_number(&context).unwrap() as _),
+        Type::F64 => Value::F64(js_val.to_number(&context).unwrap()),
+        Type::V128 => {
+            let number = if js_val.is_number(&context) {
+                js_val.to_number(&context).unwrap() as _
+            } else {
+                js_val
+                    .to_string(&context)
+                    .unwrap()
+                    .to_string()
+                    .parse()
+                    .unwrap()
+            };
+            Value::V128(number)
+        }
+        Type::ExternRef | Type::FuncRef => unimplemented!(
+            "The type `{:?}` is not yet supported in the JS Function API",
+            ty
+        ),
+    }
+}
+
+impl AsJs for Value {
+    type DefinitionType = Type;
+
+    fn as_jsvalue(&self, store: &impl AsStoreRef) -> JSValue {
+        let engine = store.as_store_ref();
+        let context = engine.jsc().context();
+        match self {
+            Self::I32(i) => JSValue::number(&context, *i as _),
+            // JavascriptCore will fail with:
+            // new WebAssembly.Global({value: "i64", mutable: false}, 3);
+            // But will succeed with
+            // new WebAssembly.Global({value: "i64", mutable: false}, "3");
+            Self::I64(i) => JSValue::string(&context, (*i).to_string()),
+            Self::F32(f) => JSValue::number(&context, *f as _),
+            Self::F64(f) => JSValue::number(&context, *f),
+            Self::V128(v) => JSValue::number(&context, *v as _),
+            Self::FuncRef(Some(func)) => func.0.handle.function.clone().to_jsvalue(),
+            Self::FuncRef(None) => JSValue::null(&context),
+            Self::ExternRef(_) => unimplemented!(),
+        }
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        type_: &Self::DefinitionType,
+        value: &JSValue,
+    ) -> Result<Self, JSValue> {
+        let engine = store.as_store_ref();
+        let context = engine.jsc().context();
+        Ok(param_from_js(context, type_, value))
+    }
+}
+
+impl AsJs for Extern {
+    type DefinitionType = ExternType;
+
+    fn as_jsvalue(&self, _store: &impl AsStoreRef) -> JSValue {
+        match self {
+            Self::Memory(memory) => memory.0.handle.memory.clone().to_jsvalue(),
+            Self::Function(function) => function.0.handle.function.clone().to_jsvalue(),
+            Self::Table(table) => table.0.handle.table.clone().to_jsvalue(),
+            Self::Global(global) => global.0.handle.global.clone().to_jsvalue(),
+        }
+    }
+
+    fn from_jsvalue(
+        store: &mut impl AsStoreMut,
+        extern_type: &Self::DefinitionType,
+        val: &JSValue,
+    ) -> Result<Self, JSValue> {
+        // Note: this function do a soft check over the type
+        // We only check the "kind" of Extern, but nothing else
+        // unimplemented!();
+        let engine = store.as_store_mut();
+        let context = engine.jsc().context();
+        match extern_type {
+            ExternType::Function(function_type) => {
+                let obj_val = val.to_object(&context).unwrap();
+                Ok(Self::Function(Function::from_vm_extern(
+                    store,
+                    VMFunction::new(obj_val, function_type.clone()),
+                )))
+            }
+            ExternType::Global(global_type) => {
+                let obj_val = val.to_object(&context).unwrap();
+                Ok(Self::Global(Global::from_vm_extern(
+                    store,
+                    VMGlobal::new(obj_val, global_type.clone()),
+                )))
+            }
+            ExternType::Memory(memory_type) => {
+                let obj_val = val.to_object(&context).unwrap();
+                Ok(Self::Memory(Memory::from_vm_extern(
+                    store,
+                    VMMemory::new(obj_val, memory_type.clone()),
+                )))
+            }
+            ExternType::Table(table_type) => {
+                let obj_val = val.to_object(&context).unwrap();
+                Ok(Self::Table(Table::from_vm_extern(
+                    store,
+                    VMTable::new(obj_val, table_type.clone()),
+                )))
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/engine.rs
new file mode 100644
index 0000000..adbf7a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/engine.rs
@@ -0,0 +1,220 @@
+use rusty_jsc::{JSContext, JSObject};
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub(crate) struct JSCEngine {
+    context: JSContext,
+    global_wasm: JSObject,
+    wasm_validate_type: JSObject,
+    wasm_module_type: JSObject,
+    wasm_instance_type: JSObject,
+    wasm_global_type: JSObject,
+    wasm_table_type: JSObject,
+    wasm_memory_type: JSObject,
+}
+
+impl Default for JSCEngine {
+    fn default() -> Self {
+        let context = JSContext::default();
+        let mut global = context.get_global_object();
+        let mut global_wasm = global
+            .get_property(&context, "WebAssembly".to_string())
+            .to_object(&context)
+            .expect("WebAssembly is not available in JavascriptCore");
+
+        let mut wasm_validate_type = global_wasm
+            .get_property(&context, "validate".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let mut wasm_module_type = global_wasm
+            .get_property(&context, "Module".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let mut wasm_instance_type = global_wasm
+            .get_property(&context, "Instance".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let mut wasm_global_type = global_wasm
+            .get_property(&context, "Global".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let mut wasm_table_type = global_wasm
+            .get_property(&context, "Table".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let mut wasm_memory_type = global_wasm
+            .get_property(&context, "Memory".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        Self {
+            context,
+            global_wasm,
+            wasm_validate_type,
+            wasm_module_type,
+            wasm_instance_type,
+            wasm_global_type,
+            wasm_table_type,
+            wasm_memory_type,
+        }
+    }
+}
+
+/// A WebAssembly `Universal` Engine.
+#[derive(Clone, Debug, Default)]
+pub struct Engine {
+    inner: Arc<JSCEngine>,
+}
+
+unsafe impl Send for Engine {}
+unsafe impl Sync for Engine {}
+
+impl From<&crate::engine::Engine> for Engine {
+    fn from(engine: &crate::engine::Engine) -> Self {
+        engine.0.clone()
+    }
+}
+
+pub(crate) trait JSC {
+    fn jsc(&self) -> &JSCEngine;
+}
+
+impl JSC for crate::Engine {
+    #[inline]
+    fn jsc(&self) -> &JSCEngine {
+        &self.0.inner
+    }
+}
+
+impl JSC for crate::engine::EngineRef<'_> {
+    #[inline]
+    fn jsc(&self) -> &JSCEngine {
+        &self.engine().0.inner
+    }
+}
+
+impl JSC for crate::store::StoreRef<'_> {
+    #[inline]
+    fn jsc(&self) -> &JSCEngine {
+        &self.engine().jsc()
+    }
+}
+
+impl JSC for crate::store::StoreMut<'_> {
+    #[inline]
+    fn jsc(&self) -> &JSCEngine {
+        &self.engine().jsc()
+    }
+}
+
+impl JSC for crate::Store {
+    #[inline]
+    fn jsc(&self) -> &JSCEngine {
+        &self.engine().jsc()
+    }
+}
+
+impl JSCEngine {
+    #[inline]
+    pub(crate) fn context(&self) -> &JSContext {
+        &self.context
+    }
+
+    #[inline]
+    pub(crate) fn global_wasm(&self) -> &JSObject {
+        &self.global_wasm
+    }
+
+    #[inline]
+    pub(crate) fn wasm_module_type(&self) -> &JSObject {
+        &self.wasm_module_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_validate_type(&self) -> &JSObject {
+        &self.wasm_validate_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_instance_type(&self) -> &JSObject {
+        &self.wasm_instance_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_global_type(&self) -> &JSObject {
+        &self.wasm_global_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_table_type(&self) -> &JSObject {
+        &self.wasm_table_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_memory_type(&self) -> &JSObject {
+        &self.wasm_memory_type
+    }
+}
+
+impl Engine {
+    pub(crate) fn deterministic_id(&self) -> &str {
+        // All js engines have the same id
+        "javascriptcore"
+    }
+
+    #[inline]
+    pub(crate) fn context(&self) -> &JSContext {
+        &self.inner.context
+    }
+
+    #[inline]
+    pub(crate) fn global_wasm(&self) -> &JSObject {
+        &self.inner.global_wasm
+    }
+
+    #[inline]
+    pub(crate) fn wasm_module_type(&self) -> &JSObject {
+        &self.inner.wasm_module_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_validate_type(&self) -> &JSObject {
+        &self.inner.wasm_validate_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_instance_type(&self) -> &JSObject {
+        &self.inner.wasm_instance_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_global_type(&self) -> &JSObject {
+        &self.inner.wasm_global_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_table_type(&self) -> &JSObject {
+        &self.inner.wasm_table_type
+    }
+
+    #[inline]
+    pub(crate) fn wasm_memory_type(&self) -> &JSObject {
+        &self.inner.wasm_memory_type
+    }
+}
+
+// impl Default for Engine {
+//     fn default() -> Self {
+//         Engine
+//     }
+// }
+
+/// Returns the default engine for the JS engine
+pub(crate) fn default_engine() -> Engine {
+    Engine::default()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/errors.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/errors.rs
new file mode 100644
index 0000000..88f20ba
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/errors.rs
@@ -0,0 +1,30 @@
+use rusty_jsc::JSValue;
+
+use crate::jsc::trap::Trap;
+use crate::RuntimeError;
+
+impl From<Trap> for RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<RuntimeError>() {
+            return trap.downcast::<RuntimeError>().unwrap();
+        }
+        let wasm_trace = vec![];
+        let trap_code = None;
+        // let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
+        RuntimeError::new_from_source(trap, wasm_trace, trap_code)
+    }
+}
+
+impl From<RuntimeError> for JSValue {
+    fn from(_err: RuntimeError) -> Self {
+        // err.inner.source.into()
+        unimplemented!();
+    }
+}
+
+pub(crate) fn raise(error: Box<dyn std::error::Error + Send + Sync>) -> ! {
+    unimplemented!()
+    // let error = Trap::user(error);
+    // let js_error: JsValue = error.into();
+    // wasm_bindgen::throw_val(js_error)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/extern_ref.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/extern_ref.rs
new file mode 100644
index 0000000..410a35b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/extern_ref.rs
@@ -0,0 +1,39 @@
+use std::any::Any;
+
+use crate::jsc::vm::VMExternRef;
+use crate::store::{AsStoreMut, AsStoreRef};
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct ExternRef;
+
+impl ExternRef {
+    pub fn new<T>(_store: &mut impl AsStoreMut, _value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub fn downcast<'a, T>(&self, _store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        _store: &mut impl AsStoreMut,
+        _vm_externref: VMExternRef,
+    ) -> Self {
+        unimplemented!("ExternRef is not yet supported in Javascript");
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/function.rs
new file mode 100644
index 0000000..bfe64f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/function.rs
@@ -0,0 +1,582 @@
+use crate::errors::RuntimeError;
+use crate::externals::function::{HostFunction, HostFunctionKind, WithEnv, WithoutEnv};
+use crate::function_env::{FunctionEnv, FunctionEnvMut};
+use crate::jsc::as_js::{param_from_js, AsJs};
+use crate::jsc::engine::JSC;
+use crate::jsc::store::{InternalStoreHandle, StoreHandle};
+use crate::jsc::trap::Trap;
+use crate::jsc::vm::{VMExtern, VMFuncRef, VMFunction, VMFunctionCallback, VMFunctionEnvironment};
+use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
+use crate::store::{AsStoreMut, AsStoreRef, StoreMut};
+use crate::value::Value;
+use std::fmt;
+use std::marker::PhantomData;
+use std::panic::{self, AssertUnwindSafe};
+
+use wasmer_types::{FunctionType, RawValue};
+
+use rusty_jsc::{
+    callback, callback_closure, JSContext, JSObject, JSObjectCallAsFunctionCallback, JSValue,
+};
+
+#[derive(Clone, PartialEq)]
+pub struct Function {
+    pub(crate) handle: VMFunction,
+}
+
+// Function can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Function {}
+
+impl From<VMFunction> for Function {
+    fn from(handle: VMFunction) -> Self {
+        Self { handle }
+    }
+}
+
+impl Function {
+    /// To `VMExtern`.
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Function(self.handle.clone())
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<'_, T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let store = store.as_store_mut();
+        let context = store.jsc().context();
+        let function_type = ty.into();
+
+        let new_function_type = function_type.clone();
+        let raw_env = env.clone();
+
+        let callback = callback_closure!(&context, move |ctx: JSContext,
+                                                         function: JSObject,
+                                                         this: JSObject,
+                                                         args: &[JSValue]|
+              -> Result<JSValue, JSValue> {
+            let global = ctx.get_global_object();
+            let store_ptr = global
+                .get_property(&ctx, "__store_ptr".to_string())
+                .to_number(&ctx)
+                .unwrap();
+
+            let mut store = unsafe { StoreMut::from_raw(store_ptr as usize as *mut _) };
+
+            let env: FunctionEnvMut<T> = raw_env.clone().into_mut(&mut store);
+
+            let wasm_arguments = new_function_type
+                .params()
+                .iter()
+                .enumerate()
+                .map(|(i, param)| param_from_js(&ctx, param, &args[i]))
+                .collect::<Vec<_>>();
+            let results = func(env, &wasm_arguments).map_err(|e| {
+                let value = format!("{}", e);
+                JSValue::string(&ctx, value)
+            })?;
+            match new_function_type.results().len() {
+                0 => Ok(JSValue::undefined(&ctx)),
+                1 => Ok(results[0].as_jsvalue(&mut store)),
+                _ => Ok(JSObject::new_array(
+                    &ctx,
+                    &results
+                        .into_iter()
+                        .map(|result| result.as_jsvalue(&mut store))
+                        .collect::<Vec<_>>(),
+                )?
+                .to_jsvalue()),
+            }
+        });
+
+        let vm_function = VMFunction::new(callback, function_type);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let callback = function.callback(store.jsc().context());
+
+        let ty = function.ty();
+        let vm_function = VMFunction::new(callback, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn new_typed_with_env<T, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv>,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let store = store.as_store_mut();
+        let context = store.jsc().context();
+        let function = WasmFunction::<Args, Rets>::new(func);
+        let callback = function.callback(store.jsc().context());
+
+        let bind = callback
+            .get_property(&context, "bind".to_string())
+            .to_object(&context)
+            .unwrap();
+        let callback_with_env = bind
+            .call(
+                &context,
+                Some(&callback),
+                &[
+                    JSValue::undefined(&context),
+                    JSValue::number(&context, env.handle.internal_handle().index() as f64),
+                ],
+            )
+            .unwrap()
+            .to_object(&context)
+            .unwrap();
+
+        let ty = function.ty();
+        let vm_function = VMFunction::new(callback_with_env, ty);
+        Self {
+            handle: vm_function,
+        }
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> FunctionType {
+        self.handle.ty.clone()
+    }
+
+    pub fn call_raw(
+        &self,
+        _store: &mut impl AsStoreMut,
+        _params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        // There is no optimal call_raw in JSC, so we just
+        // simply rely the call
+        // self.call(store, params)
+        unimplemented!();
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+
+        let mut global = context.get_global_object();
+        let store_ptr = store_mut.as_raw() as usize;
+        global.set_property(
+            &context,
+            "__store_ptr".to_string(),
+            JSValue::number(&context, store_ptr as _),
+        );
+
+        let params_list = params
+            .iter()
+            .map(|v| v.as_jsvalue(&store_mut))
+            .collect::<Vec<_>>();
+        let result = {
+            let mut r;
+            // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+            loop {
+                let store_mut = store.as_store_mut();
+                let engine = store_mut.engine();
+                let context = engine.0.context();
+                r = self.handle.function.call(&context, None, &params_list);
+                if let Some(callback) = store_mut.inner.on_called.take() {
+                    match callback(store_mut) {
+                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                            continue;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Finish) => {
+                            break;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                            return Err(RuntimeError::user(trap))
+                        }
+                        Err(trap) => return Err(RuntimeError::user(trap)),
+                    }
+                }
+                break;
+            }
+            r?
+        };
+        let result_types = self.handle.ty.results();
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        match result_types.len() {
+            0 => Ok(Box::new([])),
+            1 => {
+                let value = param_from_js(&context, &result_types[0], &result);
+                Ok(vec![value].into_boxed_slice())
+            }
+            n => {
+                let result = result.to_object(&context).unwrap();
+                Ok((0..n)
+                    .map(|i| {
+                        let js_val = result.get_property_at_index(&context, i as _).unwrap();
+                        param_from_js(&context, &result_types[i], &js_val)
+                    })
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice())
+            }
+        }
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMFunction) -> Self {
+        Self { handle: internal }
+    }
+
+    pub(crate) fn vm_funcref(&self, _store: &impl AsStoreRef) -> VMFuncRef {
+        unimplemented!();
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(
+        _store: &mut impl AsStoreMut,
+        _funcref: VMFuncRef,
+    ) -> Self {
+        unimplemented!();
+    }
+
+    /// Checks whether this `Function` can be used with the given context.
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+impl fmt::Debug for Function {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.debug_struct("Function").finish()
+    }
+}
+
+/// Represents a low-level Wasm static host function. See
+/// `super::Function::new` and `super::Function::new_env` to learn
+/// more.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct WasmFunction<Args = (), Rets = ()> {
+    callback: JSObjectCallAsFunctionCallback,
+    _phantom: PhantomData<(Args, Rets)>,
+}
+
+unsafe impl<Args, Rets> Send for WasmFunction<Args, Rets> {}
+
+impl<Args, Rets> WasmFunction<Args, Rets>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    /// Creates a new `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn new<F, T, Kind: HostFunctionKind>(function: F) -> Self
+    where
+        F: HostFunction<T, Args, Rets, Kind>,
+        T: Sized,
+    {
+        Self {
+            callback: function.function_callback(),
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Get the function type of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn ty(&self) -> FunctionType {
+        FunctionType::new(Args::wasm_types(), Rets::wasm_types())
+    }
+
+    /// Get the address of this `WasmFunction`.
+    #[allow(dead_code)]
+    pub fn callback(&self, context: &JSContext) -> JSObject {
+        JSObject::new_function_with_callback(context, "FunctionCallback".to_string(), self.callback)
+    }
+}
+
+macro_rules! impl_host_function {
+        ( [$c_struct_representation:ident]
+           $c_struct_name:ident,
+           $( $x:ident ),* ) => {
+
+            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
+            // arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, T, Func >
+                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                T: Send + 'static,
+                Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+                    #[callback]
+                    fn fn_callback<T, $( $x, )* Rets, RetsAsResult, Func>(
+                        ctx: JSContext,
+                        function: JSObject,
+                        this_object: JSObject,
+                        arguments: &[JSValue],
+                    ) -> Result<JSValue, JSValue>
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        Func: Fn(FunctionEnvMut<'_, T>, $( $x , )*) -> RetsAsResult + 'static,
+                        T: Send + 'static,
+                    {
+                        use std::convert::TryInto;
+
+                        let func: &Func = &*(&() as *const () as *const Func);
+                        let global = ctx.get_global_object();
+                        let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
+                        if store_ptr.is_nan() {
+                            panic!("Store pointer is invalid. Received {}", store_ptr as usize)
+                        }
+                        let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+
+                        let handle_index = arguments[0].to_number(&ctx).unwrap() as usize;
+                        let handle: StoreHandle<VMFunctionEnvironment> = StoreHandle::from_internal(store.objects_mut().id(), InternalStoreHandle::from_index(handle_index).unwrap());
+                        let env: FunctionEnvMut<T> = FunctionEnv::from_handle(handle).into_mut(&mut store);
+
+                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                            type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
+                            let args_without_store: JSArray = arguments[1..].try_into().unwrap();
+                            let [ $( $x ),* ] = args_without_store;
+                            let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+                            func(env, $( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
+                                // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
+                                // so the only thing we can do is parse from the string repr
+                                if $x.is_number(&ctx) {
+                                    $x.to_number(&ctx).unwrap() as _
+                                }
+                                else {
+                                    $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
+                                }
+                            } }) ) ),* ).into_result()
+                        }));
+
+                        match result {
+                            Ok(Ok(result)) => {
+                                match Rets::size() {
+                                    0 => {Ok(JSValue::undefined(&ctx))},
+                                    1 => {
+                                        // unimplemented!();
+
+                                        let ty = Rets::wasm_types()[0];
+                                        let mut arr = result.into_array(&mut store);
+                                        // Value::from_raw(&store, ty, arr[0])
+                                        let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
+                                        let value: JSValue = val.as_jsvalue(&store);
+                                        Ok(value)
+                                        // *mut_rets = val.as_raw(&mut store);
+                                    }
+                                    _n => {
+                                        // if !results.is_array(&context) {
+                                        //     panic!("Expected results to be an array.")
+                                        // }
+                                        let mut arr = result.into_array(&mut store);
+                                        let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                            let raw = arr.as_mut()[i];
+                                            Value::from_raw(&mut store, *ret_type, raw).as_jsvalue(&mut store)
+                                        }).collect::<Vec<_>>();
+                                        Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                                    }
+                                }
+                            },
+                            #[cfg(feature = "std")]
+                            Ok(Err(err)) => {
+                                let trap: Trap = Trap::user(Box::new(err));
+                                Err(trap.into_jsvalue(&ctx))
+                            },
+                            #[cfg(feature = "core")]
+                            Ok(Err(err)) => {
+                                let trap: Trap = Trap::user(Box::new(err));
+                                Err(trap.into_jsvalue(&ctx))
+                            },
+                            Err(panic) => {
+                                Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
+                                // We can't just resume the unwind, because it will put
+                                // JavacriptCore in a bad state, so we need to transform
+                                // the error
+
+                                // std::panic::resume_unwind(panic)
+                            },
+                        }
+
+                    }
+                    Some(fn_callback::<T, $( $x, )* Rets, RetsAsResult, Self > as _)
+                }
+            }
+
+            // Implement `HostFunction` for a function that has the same arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, Func >
+                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+
+                    #[callback]
+                    fn fn_callback<$( $x, )* Rets, RetsAsResult, Func>(
+                        ctx: JSContext,
+                        function: JSObject,
+                        this_object: JSObject,
+                        arguments: &[JSValue],
+                    ) -> Result<JSValue, JSValue>
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                        // $( $x: NativeWasmTypeInto, )*
+                    {
+                        use std::convert::TryInto;
+
+                        let func: &Func = &*(&() as *const () as *const Func);
+                        let global = ctx.get_global_object();
+                        let store_ptr = global.get_property(&ctx, "__store_ptr".to_string()).to_number(&ctx).unwrap();
+                        if store_ptr.is_nan() {
+                            panic!("Store pointer is invalid. Received {}", store_ptr as usize)
+                        }
+
+                        let mut store = StoreMut::from_raw(store_ptr as usize as *mut _);
+                        let result = panic::catch_unwind(AssertUnwindSafe(|| {
+                            type JSArray<'a> = &'a [JSValue; count_idents!( $( $x ),* )];
+                            let args_without_store: JSArray = arguments.try_into().unwrap();
+                            let [ $( $x ),* ] = args_without_store;
+                            func($( FromToNativeWasmType::from_native( $x::Native::from_raw(&mut store, RawValue { u128: {
+                                // TODO: This may not be the fastest way, but JSC doesn't expose a BigInt interface
+                                // so the only thing we can do is parse from the string repr
+                                if $x.is_number(&ctx) {
+                                    $x.to_number(&ctx).unwrap() as _
+                                }
+                                else {
+                                    $x.to_string(&ctx).unwrap().to_string().parse::<u128>().unwrap()
+                                }
+                            } }) ) ),* ).into_result()
+                        }));
+
+                        match result {
+                            Ok(Ok(result)) => {
+                                match Rets::size() {
+                                    0 => {Ok(JSValue::undefined(&ctx))},
+                                    1 => {
+                                        let ty = Rets::wasm_types()[0];
+                                        let mut arr = result.into_array(&mut store);
+                                        let val = Value::from_raw(&mut store, ty, arr.as_mut()[0]);
+                                        let value: JSValue = val.as_jsvalue(&store);
+                                        Ok(value)
+                                    }
+                                    _n => {
+                                        let mut arr = result.into_array(&mut store);
+                                        let result_values = Rets::wasm_types().iter().enumerate().map(|(i, ret_type)| {
+                                            let raw = arr.as_mut()[i];
+                                            Value::from_raw(&mut store, *ret_type, raw).as_jsvalue(&mut store)
+                                        }).collect::<Vec<_>>();
+                                        Ok(JSObject::new_array(&ctx, &result_values).unwrap().to_jsvalue())
+                                    }
+                                }
+                            },
+                            #[cfg(feature = "std")]
+                            Ok(Err(err)) => {
+                                let trap: Trap = Trap::user(Box::new(err));
+                                Err(trap.into_jsvalue(&ctx))
+                            },
+                            #[cfg(feature = "core")]
+                            Ok(Err(err)) => {
+                                let trap: Trap = Trap::user(Box::new(err));
+                                Err(trap.into_jsvalue(&ctx))
+                            },
+                            Err(panic) => {
+                                Err(JSValue::string(&ctx, format!("panic: {:?}", panic)))
+                                // We can't just resume the unwind, because it will put
+                                // JavacriptCore in a bad state, so we need to transform
+                                // the error
+
+                                // std::panic::resume_unwind(panic)
+                            },
+                        }
+
+                    }
+                    Some(fn_callback::< $( $x, )* Rets, RetsAsResult, Self > as _)
+                }
+            }
+        };
+    }
+
+// Black-magic to count the number of identifiers at compile-time.
+macro_rules! count_idents {
+    ( $($idents:ident),* ) => {
+        {
+            #[allow(dead_code, non_camel_case_types)]
+            enum Idents { $( $idents, )* __CountIdentsLast }
+            const COUNT: usize = Idents::__CountIdentsLast as usize;
+            COUNT
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/global.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/global.rs
new file mode 100644
index 0000000..ca83f52
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/global.rs
@@ -0,0 +1,112 @@
+use crate::errors::RuntimeError;
+use crate::jsc::as_js::param_from_js;
+use crate::jsc::as_js::AsJs;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::{VMExtern, VMGlobal};
+use crate::GlobalType;
+use crate::Mutability;
+use rusty_jsc::{JSObject, JSValue};
+use wasmer_types::{RawValue, Type};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Global {
+    pub(crate) handle: VMGlobal,
+}
+
+// Global can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Global {}
+
+impl Global {
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Global(self.handle.clone())
+    }
+
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new("cross-`Store` values are not supported"));
+        }
+        let global_ty = GlobalType {
+            mutability,
+            ty: val.ty(),
+        };
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+
+        let mut descriptor = JSObject::new(&context);
+        let type_str = match val.ty() {
+            Type::I32 => "i32",
+            Type::I64 => "i64",
+            Type::F32 => "f32",
+            Type::F64 => "f64",
+            ty => unimplemented!(
+                "The type: {:?} is not yet supported in the JS Global API",
+                ty
+            ),
+        };
+        // This is the value type as string, even though is incorrectly called "value"
+        // in the JS API.
+        descriptor.set_property(
+            &context,
+            "value".to_string(),
+            JSValue::string(&context, type_str.to_string()),
+        );
+        descriptor.set_property(
+            &context,
+            "mutable".to_string(),
+            JSValue::boolean(&context, mutability.is_mutable()),
+        );
+
+        let value: JSValue = val.as_jsvalue(&store_mut);
+        let js_global = engine
+            .0
+            .wasm_global_type()
+            .construct(&context, &[descriptor.to_jsvalue(), value])
+            .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))?;
+        let vm_global = VMGlobal::new(js_global, global_ty);
+        Ok(Self::from_vm_extern(store, vm_global))
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> GlobalType {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        let value = self
+            .handle
+            .global
+            .get_property(&context, "value".to_string());
+        param_from_js(&context, &self.handle.ty.ty, &value)
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let new_value = val.as_jsvalue(&store_mut);
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        self.handle
+            .global
+            .set_property(&context, "value".to_string(), new_value)
+            .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_global: VMGlobal) -> Self {
+        use crate::jsc::store::StoreObject;
+        VMGlobal::list_mut(store.objects_mut()).push(vm_global.clone());
+        Self { handle: vm_global }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory.rs
new file mode 100644
index 0000000..bcb9361
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory.rs
@@ -0,0 +1,359 @@
+use crate::jsc::vm::{VMExtern, VMMemory};
+use crate::mem_access::MemoryAccessError;
+use crate::store::{AsStoreMut, AsStoreRef, StoreObjects};
+use crate::MemoryType;
+use rusty_jsc::{JSObject, JSValue};
+use std::convert::TryInto;
+use std::marker::PhantomData;
+use std::mem::{self, MaybeUninit};
+use std::slice;
+
+use tracing::warn;
+
+use wasmer_types::{Pages, WASM_PAGE_SIZE};
+
+use super::memory_view::MemoryView;
+
+pub use wasmer_types::MemoryError;
+
+#[derive(Debug, Clone)]
+pub struct Memory {
+    pub(crate) handle: VMMemory,
+}
+
+// Only SharedMemories can be Send in js, becuase they support `structuredClone`.
+// Normal memories will fail while doing structuredClone.
+// In this case, we implement Send just in case as it can be a shared memory.
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// ```js
+// const memory = new WebAssembly.Memory({
+//   initial: 10,
+//   maximum: 100,
+//   shared: true // <--- It must be shared, otherwise structuredClone will fail
+// });
+// structuredClone(memory)
+// ```
+unsafe impl Send for Memory {}
+unsafe impl Sync for Memory {}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        let vm_memory = VMMemory::new(Self::js_memory_from_type(store, &ty)?, ty);
+        Ok(Self::from_vm_extern(store, vm_memory))
+    }
+
+    pub(crate) fn js_memory_from_type(
+        store: &impl AsStoreRef,
+        ty: &MemoryType,
+    ) -> Result<JSObject, MemoryError> {
+        let store_ref = store.as_store_ref();
+        let engine = store_ref.engine();
+        let context = engine.0.context();
+
+        let mut descriptor = JSObject::new(&context);
+        descriptor.set_property(
+            &context,
+            "initial".to_string(),
+            JSValue::number(&context, ty.minimum.0.into()),
+        );
+        if let Some(max) = ty.maximum {
+            descriptor.set_property(
+                &context,
+                "maximum".to_string(),
+                JSValue::number(&context, max.0.into()),
+            );
+        }
+        descriptor.set_property(
+            &context,
+            "shared".to_string(),
+            JSValue::boolean(&context, ty.shared),
+        );
+
+        engine
+            .0
+            .wasm_memory_type()
+            .construct(&context, &[descriptor.to_jsvalue()])
+            .map_err(|e| MemoryError::Generic(format!("{:?}", e)))
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        Self::from_vm_extern(new_store, memory)
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Memory(self.handle.clone())
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> MemoryType {
+        self.handle.ty
+    }
+
+    pub fn view<'a>(&self, store: &'a impl AsStoreRef) -> MemoryView<'a> {
+        MemoryView::new(self, store)
+    }
+
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        let pages = delta.into();
+
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        let func = self
+            .handle
+            .memory
+            .get_property(&context, "grow".to_string())
+            .to_object(&context)
+            .unwrap();
+        match func.call(
+            &context,
+            Some(&self.handle.memory),
+            &[JSValue::number(&context, pages.0 as _)],
+        ) {
+            Ok(val) => Ok(Pages(val.to_number(&context).unwrap() as _)),
+            Err(e) => {
+                let old_pages = pages;
+                Err(MemoryError::CouldNotGrow {
+                    current: old_pages,
+                    attempted_delta: pages,
+                })
+            }
+        }
+        // let js_memory = &self.handle.memory;
+        // let our_js_memory: &JSMemory = JsCast::unchecked_from_js_ref(js_memory);
+        // let new_pages = our_js_memory.grow(pages.0).map_err(|err| {
+        //     if err.is_instance_of::<js_sys::RangeError>() {
+        //         MemoryError::CouldNotGrow {
+        //             current: self.view(&store.as_store_ref()).size(),
+        //             attempted_delta: pages,
+        //         }
+        //     } else {
+        //         MemoryError::Generic(err.as_string().unwrap())
+        //     }
+        // })?;
+        // Ok(Pages(new_pages))
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        let cur_size = self.view(store).data_size();
+        if min_size > cur_size {
+            let delta = min_size - cur_size;
+            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE as u64) + 1;
+
+            self.grow(store, Pages(pages as u32))?;
+        }
+        Ok(())
+    }
+
+    pub fn reset(&self, _store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        Ok(())
+    }
+
+    pub fn copy_to_store(
+        &self,
+        store: &impl AsStoreRef,
+        new_store: &mut impl AsStoreMut,
+    ) -> Result<Self, MemoryError> {
+        let view = self.view(store);
+        let ty = self.ty(store);
+        let amount = view.data_size() as usize;
+
+        let new_memory = Self::new(new_store, ty)?;
+        let mut new_view = new_memory.view(&new_store);
+        let new_view_size = new_view.data_size() as usize;
+        if amount > new_view_size {
+            let delta = amount - new_view_size;
+            let pages = ((delta - 1) / wasmer_types::WASM_PAGE_SIZE) + 1;
+            new_memory.grow(new_store, Pages(pages as u32))?;
+            new_view = new_memory.view(&new_store);
+        }
+
+        // Copy the bytes
+        view.copy_to_memory(amount as u64, &new_view)
+            .map_err(|err| MemoryError::Generic(err.to_string()))?;
+        // // Return the new memory
+        Ok(new_memory)
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, internal: VMMemory) -> Self {
+        Self { handle: internal }
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, _store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.handle.try_clone()
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let mut cloned = self.try_clone(store)?;
+        cloned.copy(store)
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+
+    #[allow(unused)]
+    pub fn duplicate(&mut self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        self.handle.duplicate(store)
+    }
+
+    pub fn as_shared(&self, _store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
+        // Not supported.
+        None
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut u8,
+    pub(crate) len: usize,
+    pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf.as_mut_ptr(), buf.len());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
+        }
+
+        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_write(data.as_ptr(), self.base.add(offset as usize), data.len());
+        }
+        Ok(())
+    }
+}
+
+// We can't use a normal memcpy here because it has undefined behavior if the
+// memory is being concurrently modified. So we need to write our own memcpy
+// implementation which uses volatile operations.
+//
+// The implementation of these functions can optimize very well when inlined
+// with a fixed length: they should compile down to a single load/store
+// instruction for small (8/16/32/64-bit) copies.
+#[inline]
+unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read_volatile();
+        (*dst as *mut Unaligned<T>).write(val);
+        *src = src.add(mem::size_of::<T>());
+        *dst = dst.add(mem::size_of::<T>());
+        *len -= mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+#[inline]
+unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read();
+        (*dst as *mut Unaligned<T>).write_volatile(val);
+        *src = src.add(mem::size_of::<T>());
+        *dst = dst.add(mem::size_of::<T>());
+        *len -= mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory_view.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory_view.rs
new file mode 100644
index 0000000..bb89129
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/memory_view.rs
@@ -0,0 +1,217 @@
+use crate::store::AsStoreRef;
+use crate::MemoryAccessError;
+use rusty_jsc::JSObject;
+use std::convert::TryFrom;
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
+use std::slice;
+use std::{convert::TryInto, ops::Range};
+use wasmer_types::{Bytes, Pages};
+
+use super::memory::{Memory, MemoryBuffer};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.grow() method.
+#[derive(Debug)]
+pub struct MemoryView<'a> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    // pub(crate) size: Pages,
+}
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        Self::new_raw(&memory.handle.memory, store)
+    }
+
+    pub(crate) fn new_raw(memory: &JSObject, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        let store_ref = store.as_store_ref();
+        let engine = store_ref.engine();
+        let context = engine.0.context();
+
+        let buffer = memory
+            .get_property(&context, "buffer".to_string())
+            .to_object(&context)
+            .unwrap();
+        let typed_buffer = JSObject::create_typed_array_from_buffer(&context, buffer).unwrap();
+
+        let mut buffer_data = typed_buffer.get_typed_array_buffer(&context).unwrap();
+        // println!("BUFFER DATA {}", buffer_data.to_string(&context));
+
+        // let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();
+        // let def = unsafe { definition.as_ref() };
+        Self {
+            buffer: MemoryBuffer {
+                base: buffer_data.as_mut_ptr(),
+                len: buffer_data.len(),
+                marker: PhantomData,
+            },
+            // size,
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.buffer.base
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.buffer.len.try_into().unwrap()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.data_unchecked_mut()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        Bytes(self.buffer.len).try_into().unwrap()
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        self.buffer
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        let mut buf = [0u8; 1];
+        self.read(offset, &mut buf)?;
+        Ok(buf[0])
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.buffer.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.write(offset, data)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        let buf = [val];
+        self.write(offset, &buf)?;
+        Ok(())
+    }
+
+    #[allow(unused)]
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    #[allow(unused)]
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    #[allow(unused)]
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/mod.rs
new file mode 100644
index 0000000..3575fe2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/mod.rs
@@ -0,0 +1,5 @@
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod memory;
+pub(crate) mod memory_view;
+pub(crate) mod table;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/table.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/table.rs
new file mode 100644
index 0000000..2415977
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/externals/table.rs
@@ -0,0 +1,158 @@
+use crate::errors::RuntimeError;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::VMExternTable;
+use crate::vm::{VMExtern, VMFunction, VMTable};
+use crate::{FunctionType, TableType};
+use rusty_jsc::{JSObject, JSValue};
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Table {
+    pub(crate) handle: VMTable,
+}
+
+// Table can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Table {}
+
+fn set_table_item(table: &VMTable, item_index: u32, item: &JSObject) -> Result<(), RuntimeError> {
+    unimplemented!();
+    // table.table.set(item_index, item).map_err(|e| e.into())
+}
+
+fn get_function(store: &mut impl AsStoreMut, val: Value) -> Result<JSObject, RuntimeError> {
+    unimplemented!();
+    // if !val.is_from_store(store) {
+    //     return Err(RuntimeError::new("cannot pass Value across contexts"));
+    // }
+    // match val {
+    //     Value::FuncRef(Some(ref func)) => Ok(func.0.handle.function.clone().into()),
+    //     // Only funcrefs is supported by the spec atm
+    //     _ => unimplemented!("The {val:?} is not yet supported"),
+    // }
+}
+
+impl Table {
+    pub fn new(
+        store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+
+        let mut descriptor = JSObject::new(&context);
+        descriptor.set_property(
+            &context,
+            "initial".to_string(),
+            JSValue::number(&context, ty.minimum.into()),
+        );
+        if let Some(max) = ty.maximum {
+            descriptor.set_property(
+                &context,
+                "maximum".to_string(),
+                JSValue::number(&context, max.into()),
+            );
+        }
+        descriptor.set_property(
+            &context,
+            "element".to_string(),
+            JSValue::string(&context, "anyfunc".to_string()),
+        );
+
+        let js_table = engine
+            .0
+            .wasm_table_type()
+            .construct(&context, &[descriptor.to_jsvalue()])
+            .map_err(|e| <JSValue as Into<RuntimeError>>::into(e))?;
+        let vm_table = VMTable::new(js_table, ty);
+        Ok(Self::from_vm_extern(store, vm_table))
+    }
+
+    pub fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Table(self.handle.clone())
+    }
+
+    pub fn ty(&self, _store: &impl AsStoreRef) -> TableType {
+        self.handle.ty
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        unimplemented!();
+        // if let Some(func) = self.handle.table.get(index).ok() {
+        //     let ty = FunctionType::new(vec![], vec![]);
+        //     let vm_function = VMFunction::new(func, ty);
+        //     let function = crate::Function::from_vm_extern(store, vm_function);
+        //     Some(Value::FuncRef(Some(function)))
+        // } else {
+        //     None
+        // }
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!();
+        // let item = get_function(store, val)?;
+        // set_table_item(&self.handle, index, &item)
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        let store_mut = store.as_store_ref();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        self.handle
+            .table
+            .get_property(&context, "length".to_string())
+            .to_number(&context)
+            .unwrap() as _
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        _init: Value,
+    ) -> Result<u32, RuntimeError> {
+        let store_mut = store.as_store_mut();
+        let engine = store_mut.engine();
+        let context = engine.0.context();
+        let func = self
+            .handle
+            .table
+            .get_property(&context, "grow".to_string())
+            .to_object(&context)
+            .unwrap();
+        match func.call(
+            &context,
+            Some(&self.handle.table),
+            &[JSValue::number(&context, delta as _)],
+        ) {
+            Ok(val) => Ok(val.to_number(&context).unwrap() as _),
+            Err(e) => Err(<JSValue as Into<RuntimeError>>::into(e)),
+        }
+    }
+
+    pub fn copy(
+        _store: &mut impl AsStoreMut,
+        _dst_table: &Self,
+        _dst_index: u32,
+        _src_table: &Self,
+        _src_index: u32,
+        _len: u32,
+    ) -> Result<(), RuntimeError> {
+        unimplemented!("Table.copy is not natively supported in Javascript");
+    }
+
+    pub(crate) fn from_vm_extern(_store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self { handle: vm_extern }
+    }
+
+    pub fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/instance.rs
new file mode 100644
index 0000000..614eb76
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/instance.rs
@@ -0,0 +1,77 @@
+use crate::errors::InstantiationError;
+use crate::exports::Exports;
+use crate::imports::Imports;
+use crate::jsc::as_js::AsJs;
+use crate::jsc::engine::JSC;
+use crate::jsc::vm::VMInstance;
+use crate::module::Module;
+use crate::store::AsStoreMut;
+use crate::Extern;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Instance {
+    pub(crate) _handle: VMInstance,
+}
+
+// Instance can't be Send in js because it dosen't support `structuredClone`
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// unsafe impl Send for Instance {}
+
+impl Instance {
+    pub(crate) fn new(
+        mut store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let instance = module
+            .0
+            .instantiate(&mut store, imports)
+            .map_err(|e| InstantiationError::Start(e))?;
+
+        Self::from_module_and_instance(store, &module, instance)
+    }
+
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let mut imports = Imports::new();
+        for (import_ty, extern_ty) in module.imports().zip(externs.iter()) {
+            imports.define(import_ty.module(), import_ty.name(), extern_ty.clone());
+        }
+        Self::new(store, module, &imports)
+    }
+
+    pub(crate) fn from_module_and_instance(
+        mut store: &mut impl AsStoreMut,
+        module: &Module,
+        instance: VMInstance,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let engine = store.as_store_mut();
+        let context = engine.jsc().context();
+
+        let mut instance_exports = instance
+            .get_property(&context, "exports".to_string())
+            .to_object(&context)
+            .unwrap();
+
+        let exports_ty = module.exports().collect::<Vec<_>>();
+
+        let exports = exports_ty
+            .iter()
+            .map(|export_type| {
+                let name = export_type.name();
+                let mut store = store.as_store_mut();
+                let context = store.jsc().context();
+                let extern_type = export_type.ty();
+                // Annotation is here to prevent spurious IDE warnings.
+                let js_export = instance_exports.get_property(&context, name.to_string());
+                let extern_ = Extern::from_jsvalue(&mut store, extern_type, &js_export).unwrap();
+                Ok((name.to_string(), extern_))
+            })
+            .collect::<Result<Exports, InstantiationError>>()?;
+
+        Ok((Self { _handle: instance }, exports))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mem_access.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mem_access.rs
new file mode 100644
index 0000000..f878ed6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mem_access.rs
@@ -0,0 +1,92 @@
+use crate::access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess};
+use crate::{MemoryAccessError, WasmRef, WasmSlice};
+use std::mem;
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = slice
+            .len
+            .checked_mul(mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let end = slice
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > slice.buffer.0.len as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                slice.buffer.0.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf = unsafe {
+            let buf_ptr: *mut u8 = slice.buffer.0.base.add(slice.offset as usize);
+            let buf_ptr: *mut T = std::mem::transmute(buf_ptr);
+            std::slice::from_raw_parts_mut(buf_ptr, slice.len as usize)
+        };
+        Ok(Self {
+            slice,
+            buf: SliceCow::Borrowed(buf),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = mem::size_of::<T>() as u64;
+        let end = ptr
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > ptr.buffer.0.len as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                ptr.buffer.0.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let val = unsafe {
+            let val_ptr: *mut u8 = ptr.buffer.0.base.add(ptr.offset as usize);
+            let val_ptr: *mut T = std::mem::transmute(val_ptr);
+            &mut *val_ptr
+        };
+        Ok(Self {
+            ptr,
+            buf: RefCow::Borrowed(val),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Reads the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    #[allow(clippy::clone_on_copy)]
+    pub fn read(&self) -> T
+    where
+        T: Clone,
+    {
+        self.as_ref().clone()
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn write(&mut self, val: T) {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        *(self.as_mut()) = val;
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mod.rs
new file mode 100644
index 0000000..3a195e3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/mod.rs
@@ -0,0 +1,39 @@
+//! The JavascriptCore integration in the Wasmer API
+
+#[cfg(all(feature = "std", feature = "core"))]
+compile_error!(
+    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
+);
+
+#[cfg(all(not(feature = "std"), not(feature = "core")))]
+compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
+
+#[cfg(feature = "core")]
+pub(crate) extern crate alloc;
+
+mod lib {
+    #[cfg(feature = "core")]
+    pub mod std {
+        pub use crate::alloc::{borrow, boxed, str, string, sync, vec};
+        pub use core::fmt;
+        pub use hashbrown as collections;
+    }
+
+    #[cfg(feature = "std")]
+    pub mod std {
+        pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec};
+    }
+}
+
+pub(crate) mod as_js;
+pub(crate) mod engine;
+pub(crate) mod errors;
+pub(crate) mod extern_ref;
+pub(crate) mod externals;
+pub(crate) mod instance;
+pub(crate) mod mem_access;
+pub(crate) mod module;
+pub(crate) mod store;
+pub(crate) mod trap;
+pub(crate) mod typed_function;
+pub(crate) mod vm;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/module.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/module.rs
new file mode 100644
index 0000000..1eda38c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/module.rs
@@ -0,0 +1,259 @@
+use crate::errors::InstantiationError;
+use crate::errors::RuntimeError;
+use crate::imports::Imports;
+use crate::jsc::as_js::AsJs;
+use crate::jsc::engine::JSC;
+use crate::store::AsStoreMut;
+use crate::store::AsStoreRef;
+use crate::vm::VMInstance;
+use crate::Extern;
+use crate::IntoBytes;
+use crate::{AsEngineRef, ExportType, ImportType};
+use bytes::Bytes;
+use rusty_jsc::{JSObject, JSString, JSValue};
+use std::path::Path;
+use tracing::{debug, warn};
+use wasmer_types::{
+    CompileError, DeserializeError, ExportsIterator, ExternType, FunctionType, GlobalType,
+    ImportsIterator, MemoryType, ModuleInfo, Mutability, Pages, SerializeError, TableType, Type,
+};
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Module {
+    module: JSObject,
+    name: Option<String>,
+    raw_bytes: Option<Bytes>,
+    info: ModuleInfo,
+}
+
+// Module implements `structuredClone` in js, so it's safe it to make it Send.
+// https://developer.mozilla.org/en-US/docs/Web/API/structuredClone
+// ```js
+// const module = new WebAssembly.Module(new Uint8Array([
+//   0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00
+// ]));
+// structuredClone(module)
+// ```
+unsafe impl Send for Module {}
+unsafe impl Sync for Module {}
+
+impl Module {
+    pub(crate) fn from_binary(
+        _engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        unsafe { Self::from_binary_unchecked(_engine, binary) }
+    }
+
+    pub(crate) unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        let mut binary = binary.to_vec();
+        let engine = engine.as_engine_ref();
+        let jsc = engine.jsc();
+        let context = jsc.context();
+        let bytes = JSObject::create_typed_array_with_bytes(&context, &mut binary).unwrap();
+        let module_type = jsc.wasm_module_type();
+        let global_wasm = jsc.global_wasm();
+        let module = module_type
+            .construct(&context, &[bytes.to_jsvalue()])
+            .map_err(|e| CompileError::Validate(format!("{}", e.to_string(&context).unwrap())))?;
+
+        Ok(Self::from_js_module(module, binary))
+    }
+
+    /// Creates a new WebAssembly module skipping any kind of validation from a javascript module
+    ///
+    pub(crate) unsafe fn from_js_module(module: JSObject, binary: impl IntoBytes) -> Self {
+        let binary = binary.into_bytes();
+        // The module is now validated, so we can safely parse it's types
+        let info = crate::module_info_polyfill::translate_module(&binary[..])
+            .unwrap()
+            .info;
+
+        Self {
+            module,
+            name: info.name.clone(),
+            raw_bytes: Some(binary.into_bytes()),
+            info,
+        }
+    }
+
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        let engine = engine.as_engine_ref();
+        let jsc = engine.jsc();
+        let context = jsc.context();
+        let mut binary = binary.to_vec();
+        let bytes = JSObject::create_typed_array_with_bytes(&context, &mut binary).unwrap();
+
+        let global_wasm = jsc.global_wasm();
+        let validate_type = jsc.wasm_validate_type();
+
+        match validate_type.call(&context, Some(&global_wasm), &[bytes.to_jsvalue()]) {
+            Ok(val) => {
+                if val.to_bool(&context) {
+                    Ok(())
+                } else {
+                    Err(CompileError::Validate(format!("Not a valid wasm binary")))
+                }
+            }
+            Err(e) => Err(CompileError::Validate(format!(
+                "Error while validating: {}",
+                e.to_string(&context).unwrap()
+            ))),
+        }
+    }
+
+    pub(crate) fn instantiate(
+        &self,
+        store: &mut impl AsStoreMut,
+        imports: &Imports,
+    ) -> Result<VMInstance, RuntimeError> {
+        // Ensure all imports come from the same store.
+        if imports
+            .into_iter()
+            .any(|(_, import)| !import.is_from_store(store))
+        {
+            return Err(RuntimeError::user(Box::new(
+                InstantiationError::DifferentStores,
+            )));
+        }
+
+        let store = store.as_store_mut();
+        let context = store.jsc().context();
+
+        let mut imports_object = JSObject::new(&context);
+        for import_type in self.imports() {
+            let resolved_import = imports.get_export(import_type.module(), import_type.name());
+            if let Some(import) = resolved_import {
+                let val = imports_object.get_property(&context, import_type.module().to_string());
+                if !val.is_undefined(&context) {
+                    // If the namespace is already set
+                    let mut obj_val = val.to_object(&context).unwrap();
+                    obj_val.set_property(
+                        &context,
+                        import_type.name().to_string(),
+                        import.as_jsvalue(&store.as_store_ref()),
+                    );
+                } else {
+                    // If the namespace doesn't exist
+                    let mut import_namespace = JSObject::new(&context);
+                    import_namespace.set_property(
+                        &context,
+                        import_type.name().to_string(),
+                        import.as_jsvalue(&store.as_store_ref()),
+                    );
+                    imports_object
+                        .set_property(
+                            &context,
+                            import_type.module().to_string(),
+                            import_namespace.to_jsvalue(),
+                        )
+                        .unwrap();
+                }
+            } else {
+                warn!(
+                    "import not found {}:{}",
+                    import_type.module(),
+                    import_type.name()
+                );
+            }
+            // in case the import is not found, the JS Wasm VM will handle
+            // the error for us, so we don't need to handle it
+        }
+
+        let instance_type = store.jsc().wasm_instance_type();
+        let instance = instance_type.construct(
+            &context,
+            &[self.module.to_jsvalue(), imports_object.to_jsvalue()],
+        );
+        Ok(instance.map_err(|e: JSValue| -> RuntimeError { e.into() })?)
+    }
+
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_ref().map(|s| s.as_ref())
+    }
+
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        return self.raw_bytes.clone().ok_or(SerializeError::Generic(
+            "Not able to serialize module".to_string(),
+        ));
+    }
+
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Self::deserialize(engine, bytes)
+    }
+
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        return Self::from_binary(engine, &bytes.into_bytes())
+            .map_err(|e| DeserializeError::Compiler(e));
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize_unchecked(engine, bytes)
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = std::fs::read(path.as_ref())?;
+        Self::deserialize(engine, bytes)
+    }
+
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.name = Some(name.to_string());
+        true
+    }
+
+    pub fn imports<'a>(&'a self) -> ImportsIterator<impl Iterator<Item = ImportType> + 'a> {
+        self.info().imports()
+    }
+
+    pub fn exports<'a>(&'a self) -> ExportsIterator<impl Iterator<Item = ExportType> + 'a> {
+        self.info().exports()
+    }
+
+    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        self.info().custom_sections(name)
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        &self.info
+    }
+}
+
+// impl From<WebAssembly::Module> for Module {
+//     fn from(module: WebAssembly::Module) -> Module {
+//         Module {
+//             module,
+//             name: None,
+//             type_hints: None,
+//             #[cfg(feature = "js-serializable-module")]
+//             raw_bytes: None,
+//         }
+//     }
+// }
+
+// impl<T: IntoBytes> From<(WebAssembly::Module, T)> for crate::module::Module {
+//     fn from((module, binary): (WebAssembly::Module, T)) -> crate::module::Module {
+//         unsafe { crate::module::Module(Module::from_js_module(module, binary.into_bytes())) }
+//     }
+// }
+
+// impl From<WebAssembly::Module> for crate::module::Module {
+//     fn from(module: WebAssembly::Module) -> crate::module::Module {
+//         crate::module::Module(module.into())
+//     }
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/store.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/store.rs
new file mode 100644
index 0000000..b6e28dc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/store.rs
@@ -0,0 +1,264 @@
+pub(crate) use objects::{InternalStoreHandle, StoreObject};
+pub use objects::{StoreHandle, StoreObjects};
+
+mod objects {
+    use rusty_jsc::{JSContext, JSObject, JSValue};
+
+    use crate::jsc::vm::{VMFunctionEnvironment, VMGlobal};
+    use std::{fmt, marker::PhantomData, num::NonZeroUsize};
+    pub use wasmer_types::StoreId;
+
+    /// Trait to represent an object managed by a context. This is implemented on
+    /// the VM types managed by the context.
+    pub trait StoreObject: Sized {
+        fn list(store: &StoreObjects) -> &Vec<Self>;
+        fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self>;
+    }
+
+    macro_rules! impl_store_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(store: &StoreObjects) -> &Vec<Self> {
+                    &store.$field
+                }
+                fn list_mut(store: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut store.$field
+                }
+            }
+        )*
+    };
+}
+
+    impl_store_object! {
+        // Note: we store the globals in order to be able to access them later via
+        // `StoreObjects::iter_globals`.
+        globals => VMGlobal,
+        // functions => VMFunction,
+        // tables => VMTable,
+        // memories => VMMemory,
+        // The function environments are the only things attached to a store,
+        // since the other JS objects (table, globals, memory and functions)
+        // live in the JS VM Store by default
+        function_environments => VMFunctionEnvironment,
+    }
+
+    /// Set of objects managed by a context.
+    #[derive(Default, Debug)]
+    pub struct StoreObjects {
+        id: StoreId,
+        globals: Vec<VMGlobal>,
+        function_environments: Vec<VMFunctionEnvironment>,
+    }
+
+    impl StoreObjects {
+        /// Returns the ID of this context.
+        pub fn id(&self) -> StoreId {
+            self.id
+        }
+
+        /// Sets the ID of this store
+        pub fn set_id(&mut self, id: StoreId) {
+            self.id = id;
+        }
+
+        /// Returns a pair of mutable references from two handles.
+        ///
+        /// Panics if both handles point to the same object.
+        pub fn get_2_mut<T: StoreObject>(
+            &mut self,
+            a: InternalStoreHandle<T>,
+            b: InternalStoreHandle<T>,
+        ) -> (&mut T, &mut T) {
+            assert_ne!(a.index(), b.index());
+            let list = T::list_mut(self);
+            if a.index() < b.index() {
+                let (low, high) = list.split_at_mut(b.index());
+                (&mut low[a.index()], &mut high[0])
+            } else {
+                let (low, high) = list.split_at_mut(a.index());
+                (&mut high[0], &mut low[a.index()])
+            }
+        }
+
+        /// Return an immutable iterator over all globals
+        pub fn iter_globals(&self) -> core::slice::Iter<VMGlobal> {
+            self.globals.iter()
+        }
+
+        /// Return an vector of all globals and converted to u128
+        pub fn as_u128_globals(&self) -> Vec<u128> {
+            vec![]
+            // self.iter_globals()
+            //     .map(|v| v.global.value().as_f64().unwrap() as u128)
+            //     .collect()
+        }
+
+        /// Set a global, at index idx. Will panic if idx is out of range
+        /// Safety: the caller should check taht the raw value is compatible
+        /// with destination VMGlobal type
+        pub fn set_global_unchecked(&self, idx: usize, new_val: u128) {
+            assert!(idx < self.globals.len());
+            // let g = &self.globals[idx].global;
+            // let cur_val = g.value().as_f64().unwrap();
+            // let new_val = new_val as f64;
+            // if cur_val != new_val {
+            //     let new_value = JSValue::from(new_val);
+            //     g.set_value(&new_value);
+            // }
+        }
+    }
+
+    /// Handle to an object managed by a context.
+    ///
+    /// Internally this is just an integer index into a context. A reference to the
+    /// context must be passed in separately to access the actual object.
+    pub struct StoreHandle<T> {
+        id: StoreId,
+        internal: InternalStoreHandle<T>,
+    }
+
+    impl<T> core::cmp::PartialEq for StoreHandle<T> {
+        fn eq(&self, other: &Self) -> bool {
+            self.id == other.id
+        }
+    }
+
+    impl<T> std::hash::Hash for StoreHandle<T> {
+        fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+            self.id.hash(state);
+            self.internal.idx.hash(state);
+        }
+    }
+
+    impl<T> Clone for StoreHandle<T> {
+        fn clone(&self) -> Self {
+            Self {
+                id: self.id,
+                internal: self.internal,
+            }
+        }
+    }
+
+    impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("StoreHandle")
+                .field("id", &self.id)
+                .field("internal", &self.internal.index())
+                .finish()
+        }
+    }
+
+    impl<T: StoreObject> StoreHandle<T> {
+        /// Moves the given object into a context and returns a handle to it.
+        pub fn new(store: &mut StoreObjects, val: T) -> Self {
+            Self {
+                id: store.id,
+                internal: InternalStoreHandle::new(store, val),
+            }
+        }
+
+        /// Returns a reference to the object that this handle points to.
+        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+            assert_eq!(self.id, store.id, "object used with the wrong context");
+            self.internal.get(store)
+        }
+
+        /// Returns a mutable reference to the object that this handle points to.
+        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+            assert_eq!(self.id, store.id, "object used with the wrong context");
+            self.internal.get_mut(store)
+        }
+
+        /// Returns the internal handle contains within this handle.
+        pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+            self.internal
+        }
+
+        /// Returns the ID of the context associated with the handle.
+        #[allow(unused)]
+        pub fn store_id(&self) -> StoreId {
+            self.id
+        }
+
+        /// Overrides the store id with a new ID
+        #[allow(unused)]
+        pub fn set_store_id(&mut self, id: StoreId) {
+            self.id = id;
+        }
+
+        /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+        ///
+        /// # Safety
+        /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+        pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+            Self { id, internal }
+        }
+    }
+
+    /// Internal handle to an object owned by the current context.
+    ///
+    /// Unlike `StoreHandle` this does not track the context ID: it is only
+    /// intended to be used within objects already owned by a context.
+    #[repr(transparent)]
+    pub struct InternalStoreHandle<T> {
+        // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+        idx: NonZeroUsize,
+        marker: PhantomData<fn() -> T>,
+    }
+
+    impl<T> Clone for InternalStoreHandle<T> {
+        fn clone(&self) -> Self {
+            *self
+        }
+    }
+    impl<T> Copy for InternalStoreHandle<T> {}
+
+    impl<T> fmt::Debug for InternalStoreHandle<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("InternalStoreHandle")
+                .field("idx", &self.idx)
+                .finish()
+        }
+    }
+    impl<T> PartialEq for InternalStoreHandle<T> {
+        fn eq(&self, other: &Self) -> bool {
+            self.idx == other.idx
+        }
+    }
+    impl<T> Eq for InternalStoreHandle<T> {}
+
+    impl<T: StoreObject> InternalStoreHandle<T> {
+        /// Moves the given object into a context and returns a handle to it.
+        pub fn new(store: &mut StoreObjects, val: T) -> Self {
+            let list = T::list_mut(store);
+            let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+            list.push(val);
+            Self {
+                idx,
+                marker: PhantomData,
+            }
+        }
+
+        /// Returns a reference to the object that this handle points to.
+        pub fn get<'a>(&self, store: &'a StoreObjects) -> &'a T {
+            &T::list(store)[self.idx.get() - 1]
+        }
+
+        /// Returns a mutable reference to the object that this handle points to.
+        pub fn get_mut<'a>(&self, store: &'a mut StoreObjects) -> &'a mut T {
+            &mut T::list_mut(store)[self.idx.get() - 1]
+        }
+
+        pub(crate) fn index(&self) -> usize {
+            self.idx.get()
+        }
+
+        pub(crate) fn from_index(idx: usize) -> Option<Self> {
+            NonZeroUsize::new(idx).map(|idx| Self {
+                idx,
+                marker: PhantomData,
+            })
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/trap.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/trap.rs
new file mode 100644
index 0000000..fa606fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/trap.rs
@@ -0,0 +1,117 @@
+use rusty_jsc::{JSContext, JSObject, JSValue};
+
+use crate::RuntimeError;
+use std::error::Error;
+use std::fmt;
+
+#[derive(Debug)]
+enum InnerTrap {
+    User(Box<dyn Error + Send + Sync>),
+    JSC(JSValue),
+}
+
+/// A struct representing a Trap
+#[derive(Debug)]
+pub struct Trap {
+    inner: InnerTrap,
+}
+
+unsafe impl Send for Trap {}
+unsafe impl Sync for Trap {}
+
+impl Trap {
+    pub fn user(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self {
+            inner: InnerTrap::User(error),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self.inner {
+            // We only try to downcast user errors
+            InnerTrap::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match &self.inner {
+            InnerTrap::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+
+    pub(crate) fn into_jsvalue(self, ctx: &JSContext) -> JSValue {
+        match self.inner {
+            InnerTrap::User(err) => {
+                let obj = JSObject::new(ctx);
+                let err_ptr = Box::leak(Box::new(err));
+                let wasmer_error_ptr = JSValue::number(&ctx, err_ptr as *mut _ as usize as _);
+                obj.set_property(&ctx, "wasmer_error_ptr".to_string(), wasmer_error_ptr)
+                    .unwrap();
+                obj.to_jsvalue()
+            }
+            InnerTrap::JSC(value) => value,
+        }
+    }
+
+    pub(crate) fn from_jsvalue(ctx: &JSContext, val: JSValue) -> Self {
+        let obj_val = val.to_object(ctx).unwrap();
+        let wasmer_error_ptr = obj_val.get_property(&ctx, "wasmer_error_ptr".to_string());
+        if wasmer_error_ptr.is_number(ctx) {
+            let err_ptr = wasmer_error_ptr.to_number(ctx).unwrap() as usize
+                as *mut Box<dyn Error + Send + Sync>;
+            let err = unsafe { Box::from_raw(err_ptr) };
+            return Self::user(*err);
+        }
+        Self {
+            inner: InnerTrap::JSC(val),
+        }
+    }
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self.inner {
+            InnerTrap::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Trap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.inner {
+            InnerTrap::User(e) => write!(f, "user: {}", e),
+            InnerTrap::JSC(value) => write!(f, "jsc: obscure"),
+        }
+    }
+}
+
+impl From<JSValue> for RuntimeError {
+    fn from(original: JSValue) -> Self {
+        let trap = Trap {
+            inner: InnerTrap::JSC(original),
+        };
+        trap.into()
+        // unimplemented!("TODO: implement Trap::from(JSValue) for RuntimeError");
+        // // We try to downcast the error and see if it's
+        // // an instance of RuntimeError instead, so we don't need
+        // // to re-wrap it.
+        // let trap = Trap::downcast_js(original).unwrap_or_else(|o| Trap {
+        //     inner: InnerTrap::JSC(o),
+        // });
+        // trap.into()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/typed_function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/typed_function.rs
new file mode 100644
index 0000000..ff3cf39
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/typed_function.rs
@@ -0,0 +1,145 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.typed().unwrap();
+//! ```
+use crate::jsc::as_js::{param_from_js, AsJs};
+use crate::jsc::engine::JSC;
+use crate::jsc::trap::Trap;
+use crate::native_type::NativeWasmTypeInto;
+use crate::Value;
+use crate::{AsStoreMut, TypedFunction};
+use crate::{FromToNativeWasmType, RuntimeError, WasmTypeList};
+use rusty_jsc::JSValue;
+// use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::iter::FromIterator;
+use wasmer_types::RawValue;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+        impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+        where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+        {
+            /// Call the typed func and return results.
+            #[allow(clippy::too_many_arguments)]
+            pub fn call(&self, mut store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> where
+            $( $x: FromToNativeWasmType + NativeWasmTypeInto, )*
+            {
+                // let store_ptr = Value::I64(store.as_store_mut().as_raw() as _).as_jsvalue(store);
+                #[allow(unused_unsafe)]
+                let params_list: Vec<_> = unsafe {
+                    vec![ $( {
+                        let raw = $x.into_raw(store);
+                        let value = Value::from_raw(&mut store, $x::WASM_TYPE, raw);
+                        value.as_jsvalue(store)
+                    } ),* ]
+                };
+
+                let store_mut = store.as_store_mut();
+                let context = store_mut.jsc().context();
+
+                let global = context.get_global_object();
+                let store_ptr = store_mut.as_raw() as usize;
+                global.set_property(&context, "__store_ptr".to_string(), JSValue::number(&context, store_ptr as _)).unwrap();
+
+                let results = {
+                    let mut r;
+                    // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+                    loop {
+
+                        let store_mut = store.as_store_mut();
+                        let context = store_mut.jsc().context();
+                        r = self.func.0.handle.function
+                            .call(
+                                &context,
+                                None,
+                                &params_list,
+                            );
+
+                        // let store_mut = store.as_store_mut();
+                        if let Some(callback) = store_mut.inner.on_called.take() {
+                            match callback(store_mut) {
+                                Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                                Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                                Ok(wasmer_types::OnCalledAction::Trap(trap)) => { let err = Err(RuntimeError::user(trap));
+                                    return err;
+                                },
+                                Err(trap) => {
+                                    return Err(RuntimeError::user(trap))
+                                },
+                            }
+                        }
+                        break;
+                    }
+                    let store_mut = store.as_store_mut();
+                    let context = store_mut.jsc().context();
+                    r.map_err(|e| Trap::from_jsvalue(context, e))?
+                };
+                let mut rets_list_array = Rets::empty_array();
+                let mut_rets = rets_list_array.as_mut() as *mut [RawValue] as *mut RawValue;
+                let store_mut = store.as_store_mut();
+                let context = store_mut.jsc().context();
+                match Rets::size() {
+                    0 => {},
+                    1 => unsafe {
+                        let ty = Rets::wasm_types()[0];
+                        let val = param_from_js(&context, &ty, &results);
+                        *mut_rets = val.as_raw(&mut store);
+                    }
+                    _n => {
+                        if !results.is_array(&context) {
+                            panic!("Expected results to be an array.")
+                        }
+                        let results = results.to_object(&context).unwrap();
+                        for (i, ret_type) in Rets::wasm_types().iter().enumerate() {
+                            let store_mut = store.as_store_mut();
+                            let context = store_mut.jsc().context();
+                            let ret = results.get_property_at_index(&context, i as _).unwrap();
+                            unsafe {
+                                let val = param_from_js(&context, &ret_type, &ret);
+                                let slot = mut_rets.add(i);
+                                *slot = val.as_raw(&mut store);
+                            }
+                        }
+                    }
+                }
+                Ok(unsafe { Rets::from_array(store, rets_list_array) })
+            }
+        }
+    };
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/vm.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/vm.rs
new file mode 100644
index 0000000..23bcf68
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/jsc/vm.rs
@@ -0,0 +1,270 @@
+/// This module is mainly used to create the `VM` types that will hold both
+/// the JS values of the `Memory`, `Table`, `Global` and `Function` and also
+/// it's types.
+/// This module should not be needed any longer (with the exception of the memory)
+/// once the type reflection is added to the WebAssembly JS API.
+/// https://github.com/WebAssembly/js-types/
+use crate::store::AsStoreRef;
+use rusty_jsc::{JSObject, JSObjectCallAsFunctionCallback, JSValue};
+use std::any::Any;
+use std::fmt;
+use tracing::trace;
+use wasmer_types::RawValue;
+use wasmer_types::{
+    FunctionType, GlobalType, MemoryError, MemoryType, Pages, TableType, WASM_PAGE_SIZE,
+};
+
+/// Represents linear memory that is managed by the javascript runtime
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMMemory {
+    pub(crate) memory: JSObject,
+    pub(crate) ty: MemoryType,
+}
+
+unsafe impl Send for VMMemory {}
+unsafe impl Sync for VMMemory {}
+
+impl VMMemory {
+    /// Creates a new memory directly from a WebAssembly javascript object
+    pub fn new(memory: JSObject, ty: MemoryType) -> Self {
+        Self { memory, ty }
+    }
+
+    /// Returns the size of the memory buffer in pages
+    pub fn get_runtime_size(&self) -> u32 {
+        unimplemented!();
+        // let dummy: DummyBuffer = match serde_wasm_bindgen::from_value(self.memory.buffer()) {
+        //     Ok(o) => o,
+        //     Err(_) => return 0,
+        // };
+        // if dummy.byte_length == 0 {
+        //     return 0;
+        // }
+        // dummy.byte_length / WASM_PAGE_SIZE as u32
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    pub(crate) fn try_clone(&self) -> Result<VMMemory, MemoryError> {
+        Ok(self.clone())
+    }
+
+    /// Copies this memory to a new memory
+    #[deprecated = "use `copy` instead"]
+    pub fn duplicate(
+        &mut self,
+        store: &impl AsStoreRef,
+    ) -> Result<VMMemory, wasmer_types::MemoryError> {
+        self.copy(store)
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&self, store: &impl AsStoreRef) -> Result<VMMemory, wasmer_types::MemoryError> {
+        let new_memory =
+            crate::jsc::externals::memory::Memory::js_memory_from_type(&store, &self.ty)?;
+
+        trace!("memory copy started");
+
+        let src = crate::jsc::externals::memory_view::MemoryView::new_raw(&self.memory, store);
+        let amount = src.data_size() as usize;
+        let mut dst = crate::jsc::externals::memory_view::MemoryView::new_raw(&new_memory, store);
+        let dst_size = dst.data_size() as usize;
+
+        // if amount > dst_size {
+        //     let delta = amount - dst_size;
+        //     let pages = ((delta - 1) / WASM_PAGE_SIZE) + 1;
+
+        //     let our_js_memory: &crate::jsc::externals::memory::JSMemory =
+        //         JsCast::unchecked_from_js_ref(&new_memory);
+        //     our_js_memory.grow(pages as u32).map_err(|err| {
+        //         if err.is_instance_of::<js_sys::RangeError>() {
+        //             let cur_pages = dst_size;
+        //             MemoryError::CouldNotGrow {
+        //                 current: Pages(cur_pages as u32),
+        //                 attempted_delta: Pages(pages as u32),
+        //             }
+        //         } else {
+        //             MemoryError::Generic(err.as_string().unwrap())
+        //         }
+        //     })?;
+
+        //     dst = crate::jsc::externals::memory_view::MemoryView::new_raw(&new_memory);
+        // }
+
+        src.copy_to_memory(amount as u64, &dst).map_err(|err| {
+            wasmer_types::MemoryError::Generic(format!("failed to copy the memory - {}", err))
+        })?;
+
+        trace!("memory copy finished (size={})", dst.size().bytes().0);
+
+        Ok(Self {
+            memory: new_memory,
+            ty: self.ty.clone(),
+        })
+    }
+}
+
+// impl From<VMMemory> for JSValue {
+//     fn from(value: VMMemory) -> Self {
+//         JSValue::from(value.memory)
+//     }
+// }
+
+/// The shared memory is the same as the normal memory
+pub type VMSharedMemory = VMMemory;
+
+/// The VM Global type
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMGlobal {
+    pub(crate) global: JSObject,
+    pub(crate) ty: GlobalType,
+}
+
+impl VMGlobal {
+    pub(crate) fn new(global: JSObject, ty: GlobalType) -> Self {
+        Self { global, ty }
+    }
+}
+
+unsafe impl Send for VMGlobal {}
+unsafe impl Sync for VMGlobal {}
+
+/// The VM Table type
+#[derive(Clone, Debug, PartialEq)]
+pub struct VMTable {
+    pub(crate) table: JSObject,
+    pub(crate) ty: TableType,
+}
+
+unsafe impl Send for VMTable {}
+unsafe impl Sync for VMTable {}
+
+impl VMTable {
+    pub(crate) fn new(table: JSObject, ty: TableType) -> Self {
+        Self { table, ty }
+    }
+
+    /// Get the table size at runtime
+    pub fn get_runtime_size(&self) -> u32 {
+        unimplemented!();
+        // self.table.length()
+    }
+}
+
+/// The VM Function type
+#[derive(Clone)]
+pub struct VMFunction {
+    pub(crate) function: JSObject,
+    pub(crate) ty: FunctionType,
+}
+
+unsafe impl Send for VMFunction {}
+unsafe impl Sync for VMFunction {}
+
+impl VMFunction {
+    pub(crate) fn new(function: JSObject, ty: FunctionType) -> Self {
+        Self { function, ty }
+    }
+}
+
+impl PartialEq for VMFunction {
+    fn eq(&self, other: &Self) -> bool {
+        self.function == other.function
+    }
+}
+
+impl fmt::Debug for VMFunction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("VMFunction")
+            .field("function", &self.function)
+            .finish()
+    }
+}
+
+/// The value of an export passed from one instance to another.
+pub enum VMExtern {
+    /// A function export value.
+    Function(VMFunction),
+
+    /// A table export value.
+    Table(VMTable),
+
+    /// A memory export value.
+    Memory(VMMemory),
+
+    /// A global export value.
+    Global(VMGlobal),
+}
+
+pub type VMInstance = JSObject;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Debug)]
+pub struct VMFunctionEnvironment {
+    contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
+
+pub(crate) struct VMExternRef;
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct VMFuncRef;
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        unimplemented!();
+    }
+
+    /// Extracts a `VMFuncRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw.funcref` must be a valid pointer.
+    pub unsafe fn from_raw(_raw: RawValue) -> Option<Self> {
+        unimplemented!();
+    }
+}
+
+pub struct VMTrampoline;
+
+pub(crate) type VMExternTable = VMTable;
+pub(crate) type VMExternMemory = VMMemory;
+pub(crate) type VMExternGlobal = VMGlobal;
+pub(crate) type VMExternFunction = VMFunction;
+
+pub type VMFunctionCallback = JSObjectCallAsFunctionCallback;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/lib.rs
new file mode 100644
index 0000000..0f2ed2d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/lib.rs
@@ -0,0 +1,530 @@
+#![doc(
+    html_logo_url = "https://github.com/wasmerio.png?size=200",
+    html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png"
+)]
+#![deny(
+    missing_docs,
+    trivial_numeric_casts,
+    unused_extern_crates,
+    rustdoc::broken_intra_doc_links
+)]
+#![warn(unused_import_braces)]
+#![allow(clippy::new_without_default, clippy::vtable_address_comparisons)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![allow(deprecated_cfg_attr_crate_type_name)]
+#![cfg_attr(feature = "js", crate_type = "cdylib")]
+
+//! [`Wasmer`](https://wasmer.io/) is the most popular
+//! [WebAssembly](https://webassembly.org/) runtime for Rust. It supports
+//! JIT (Just In Time) and AOT (Ahead Of Time) compilation as well as
+//! pluggable compilers suited to your needs.
+//!
+//! It's designed to be safe and secure, and runnable in any kind of environment.
+//!
+//! # Usage
+//!
+//! Here is a small example of using Wasmer to run a WebAssembly module
+//! written with its WAT format (textual format):
+//!
+//! ```rust
+//! use wasmer::{Store, Module, Instance, Value, imports};
+//!
+//! fn main() -> anyhow::Result<()> {
+//!     let module_wat = r#"
+//!     (module
+//!       (type $t0 (func (param i32) (result i32)))
+//!       (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
+//!         get_local $p0
+//!         i32.const 1
+//!         i32.add))
+//!     "#;
+//!
+//!     let mut store = Store::default();
+//!     let module = Module::new(&store, &module_wat)?;
+//!     // The module doesn't import anything, so we create an empty import object.
+//!     let import_object = imports! {};
+//!     let instance = Instance::new(&mut store, &module, &import_object)?;
+//!
+//!     let add_one = instance.exports.get_function("add_one")?;
+//!     let result = add_one.call(&mut store, &[Value::I32(42)])?;
+//!     assert_eq!(result[0], Value::I32(43));
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! [Discover the full collection of examples](https://github.com/wasmerio/wasmer/tree/master/examples).
+//!
+//! # Overview of the Features
+//!
+//! Wasmer is not only fast, but also designed to be *highly customizable*:
+//!
+//! * **Pluggable compilers** — A compiler is used by the engine to
+//!   transform WebAssembly into executable code:
+//!   * [`wasmer-compiler-singlepass`] provides a fast compilation-time
+//!     but an unoptimized runtime speed,
+//!   * [`wasmer-compiler-cranelift`] provides the right balance between
+//!     compilation-time and runtime performance, useful for development,
+//!   * [`wasmer-compiler-llvm`] provides a deeply optimized executable
+//!     code with the fastest runtime speed, ideal for production.
+//!
+//! * **Headless mode** — Once a WebAssembly module has been compiled, it
+//!   is possible to serialize it in a file for example, and later execute
+//!   it with Wasmer with headless mode turned on. Headless Wasmer has no
+//!   compiler, which makes it more portable and faster to load. It's
+//!   ideal for constrainted environments.
+//!
+//! * **Cross-compilation** — Most compilers support cross-compilation. It
+//!   means it possible to pre-compile a WebAssembly module targetting a
+//!   different architecture or platform and serialize it, to then run it
+//!   on the targetted architecture and platform later.
+//!
+//! * **Run Wasmer in a JavaScript environment** — With the `js` Cargo
+//!   feature, it is possible to compile a Rust program using Wasmer to
+//!   WebAssembly. In this context, the resulting WebAssembly module will
+//!   expect to run in a JavaScript environment, like a browser, Node.js,
+//!   Deno and so on. In this specific scenario, there is no engines or
+//!   compilers available, it's the one available in the JavaScript
+//!   environment that will be used.
+//!
+//! Wasmer ships by default with the Cranelift compiler as its great for
+//! development purposes.  However, we strongly encourage to use the LLVM
+//! compiler in production as it performs about 50% faster, achieving
+//! near-native speeds.
+//!
+//! Note: if one wants to use multiple compilers at the same time, it's
+//! also possible! One will need to import them directly via each of the
+//! compiler crates.
+//!
+//! # Table of Contents
+//!
+//! - [WebAssembly Primitives](#webassembly-primitives)
+//!   - [Externs](#externs)
+//!     - [Functions](#functions)
+//!     - [Memories](#memories)
+//!     - [Globals](#globals)
+//!     - [Tables](#tables)
+//! - [Project Layout](#project-layout)
+//!   - [Engines](#engines)
+//!   - [Compilers](#compilers)
+//! - [Cargo Features](#cargo-features)
+//! - [Using Wasmer in a JavaScript environment](#using-wasmer-in-a-javascript-environment)
+//!
+//!
+//! # WebAssembly Primitives
+//!
+//! In order to make use of the power of the `wasmer` API, it's important
+//! to understand the primitives around which the API is built.
+//!
+//! Wasm only deals with a small number of core data types, these data
+//! types can be found in the [`Value`] type.
+//!
+//! In addition to the core Wasm types, the core types of the API are
+//! referred to as "externs".
+//!
+//! ## Externs
+//!
+//! An [`Extern`] is a type that can be imported or exported from a Wasm
+//! module.
+//!
+//! To import an extern, simply give it a namespace and a name with the
+//! [`imports!`] macro:
+//!
+//! ```
+//! # use wasmer::{imports, Function, FunctionEnv, FunctionEnvMut, Memory, MemoryType, Store, Imports};
+//! # fn imports_example(mut store: &mut Store) -> Imports {
+//! let memory = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+//! imports! {
+//!     "env" => {
+//!          "my_function" => Function::new_typed(&mut store, || println!("Hello")),
+//!          "memory" => memory,
+//!     }
+//! }
+//! # }
+//! ```
+//!
+//! And to access an exported extern, see the [`Exports`] API, accessible
+//! from any instance via `instance.exports`:
+//!
+//! ```
+//! # use wasmer::{imports, Instance, FunctionEnv, Memory, TypedFunction, Store};
+//! # fn exports_example(mut env: FunctionEnv<()>, mut store: &mut Store, instance: &Instance) -> anyhow::Result<()> {
+//! let memory = instance.exports.get_memory("memory")?;
+//! let memory: &Memory = instance.exports.get("some_other_memory")?;
+//! let add: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&mut store, "add")?;
+//! let result = add.call(&mut store, 5, 37)?;
+//! assert_eq!(result, 42);
+//! # Ok(())
+//! # }
+//! ```
+//!
+//! These are the primary types that the `wasmer` API uses.
+//!
+//! ### Functions
+//!
+//! There are 2 types of functions in `wasmer`:
+//! 1. Wasm functions,
+//! 2. Host functions.
+//!
+//! A Wasm function is a function defined in a WebAssembly module that can
+//! only perform computation without side effects and call other functions.
+//!
+//! Wasm functions take 0 or more arguments and return 0 or more results.
+//! Wasm functions can only deal with the primitive types defined in
+//! [`Value`].
+//!
+//! A Host function is any function implemented on the host, in this case in
+//! Rust.
+//!
+//! Thus WebAssembly modules by themselves cannot do anything but computation
+//! on the core types in [`Value`]. In order to make them more useful we
+//! give them access to the outside world with [`imports!`].
+//!
+//! If you're looking for a sandboxed, POSIX-like environment to execute Wasm
+//! in, check out the [`wasmer-wasix`] crate for our implementation of WASI,
+//! the WebAssembly System Interface, and WASIX, the Extended version of WASI.
+//!
+//! In the `wasmer` API we support functions which take their arguments and
+//! return their results dynamically, [`Function`], and functions which
+//! take their arguments and return their results statically, [`TypedFunction`].
+//!
+//! ### Memories
+//!
+//! Memories store data.
+//!
+//! In most Wasm programs, nearly all data will live in a [`Memory`].
+//!
+//! This data can be shared between the host and guest to allow for more
+//! interesting programs.
+//!
+//! ### Globals
+//!
+//! A [`Global`] is a type that may be either mutable or immutable, and
+//! contains one of the core Wasm types defined in [`Value`].
+//!
+//! ### Tables
+//!
+//! A [`Table`] is an indexed list of items.
+//!
+//! # Project Layout
+//!
+//! The Wasmer project is divided into a number of crates, below is a dependency
+//! graph with transitive dependencies removed.
+//!
+//! <div>
+//! <img src="https://raw.githubusercontent.com/wasmerio/wasmer/master/docs/deps_dedup.svg" />
+//! </div>
+//!
+//! While this crate is the top level API, we also publish crates built
+//! on top of this API that you may be interested in using, including:
+//!
+//! - [`wasmer-cache`] for caching compiled Wasm modules,
+//! - [`wasmer-emscripten`] for running Wasm modules compiled to the
+//!   Emscripten ABI,
+//! - [`wasmer-wasix`] for running Wasm modules compiled to the WASI ABI.
+//!
+//! The Wasmer project has two major abstractions:
+//! 1. [Engine][wasmer-compiler],
+//! 2. [Compilers][wasmer-compiler].
+//!
+//! These two abstractions have multiple options that can be enabled
+//! with features.
+//!
+//! ## Engine
+//!
+//! The engine is a system that uses a compiler to make a WebAssembly
+//! module executable.
+//!
+//! ## Compilers
+//!
+//! A compiler is a system that handles the details of making a Wasm
+//! module executable. For example, by generating native machine code
+//! for each Wasm function.
+//!
+//! # Cargo Features
+//!
+//! This crate comes in 2 flavors:
+//!
+//! 1. `sys`
+#![cfg_attr(feature = "sys", doc = "(enabled),")]
+#![cfg_attr(not(feature = "sys"), doc = "(disabled),")]
+//!    where `wasmer` will be compiled to a native executable
+//!    which provides compilers, engines, a full VM etc.
+//! 2. `js`
+#![cfg_attr(feature = "js", doc = "(enabled),")]
+#![cfg_attr(not(feature = "js"), doc = "(disabled),")]
+//!    where `wasmer` will be compiled to WebAssembly to run in a
+//!    JavaScript host (see [Using Wasmer in a JavaScript
+//!    environment](#using-wasmer-in-a-javascript-environment)).
+//!
+//! Consequently, we can group the features by the `sys` or `js`
+//! features.
+//!
+#![cfg_attr(
+    feature = "sys",
+    doc = "## Features for the `sys` feature group (enabled)"
+)]
+#![cfg_attr(
+    not(feature = "sys"),
+    doc = "## Features for the `sys` feature group (disabled)"
+)]
+//!
+//! The default features can be enabled with the `sys-default` feature.
+//!
+//! The features for the `sys` feature group can be broken down into 2
+//! kinds: features that enable new functionality and features that
+//! set defaults.
+//!
+//! The features that enable new functionality are:
+//! - `cranelift`
+#![cfg_attr(feature = "cranelift", doc = "(enabled),")]
+#![cfg_attr(not(feature = "cranelift"), doc = "(disabled),")]
+//!   enables Wasmer's [Cranelift compiler][wasmer-compiler-cranelift],
+//! - `llvm`
+#![cfg_attr(feature = "llvm", doc = "(enabled),")]
+#![cfg_attr(not(feature = "llvm"), doc = "(disabled),")]
+//!   enables Wasmer's [LLVM compiler][wasmer-compiler-lvm],
+//! - `singlepass`
+#![cfg_attr(feature = "singlepass", doc = "(enabled),")]
+#![cfg_attr(not(feature = "singlepass"), doc = "(disabled),")]
+//!   enables Wasmer's [Singlepass compiler][wasmer-compiler-singlepass],
+//! - `wat`
+#![cfg_attr(feature = "wat", doc = "(enabled),")]
+#![cfg_attr(not(feature = "wat"), doc = "(disabled),")]
+//!   enables `wasmer` to parse the WebAssembly text format,
+//! - `compilation`
+#![cfg_attr(feature = "compiler", doc = "(enabled),")]
+#![cfg_attr(not(feature = "compiler"), doc = "(disabled),")]
+//!   enables compilation with the wasmer engine.
+//!
+#![cfg_attr(
+    feature = "js",
+    doc = "## Features for the `js` feature group (enabled)"
+)]
+#![cfg_attr(
+    not(feature = "js"),
+    doc = "## Features for the `js` feature group (disabled)"
+)]
+//!
+//! The default features can be enabled with the `js-default` feature.
+//!
+//! Here are the detailed list of features:
+//!
+//! - `wasm-types-polyfill`
+#![cfg_attr(feature = "wasm-types-polyfill", doc = "(enabled),")]
+#![cfg_attr(not(feature = "wasm-types-polyfill"), doc = "(disabled),")]
+//!   parses the Wasm file, allowing to do type reflection of the
+//!   inner Wasm types. It adds 100kb to the Wasm bundle (28kb
+//!   gzipped). It is possible to disable it and to use
+//!   `Module::set_type_hints` manually instead for a lightweight
+//!   alternative. This is needed until the [Wasm JS introspection API
+//!   proposal](https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md)
+//!   is adopted by browsers,
+//! - `wat`
+#![cfg_attr(feature = "wat", doc = "(enabled),")]
+#![cfg_attr(not(feature = "wat"), doc = "(disabled),")]
+//!  allows to read a Wasm file in its text format. This feature is
+//!  normally used only in development environments. It will add
+//!  around 650kb to the Wasm bundle (120Kb gzipped).
+//!
+//! # Using Wasmer in a JavaScript environment
+//!
+//! Imagine a Rust program that uses this `wasmer` crate to execute a
+//! WebAssembly module. It is possible to compile this Rust progam to
+//! WebAssembly by turning on the `js` Cargo feature of this `wasmer`
+//! crate.
+//!
+//! Here is a small example illustrating such a Rust program, and how
+//! to compile it with [`wasm-pack`] and [`wasm-bindgen`]:
+//!
+//! ```ignore
+//! use wasm_bindgen::prelude::*;
+//! use wasmer::{imports, Instance, Module, Store, Value};
+//!
+//! #[wasm_bindgen]
+//! pub extern fn do_add_one_in_wasmer() -> i32 {
+//!     let module_wat = r#"
+//!     (module
+//!       (type $t0 (func (param i32) (result i32)))
+//!       (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
+//!         get_local $p0
+//!         i32.const 1
+//!         i32.add))
+//!     "#;
+//!     let mut store = Store::default();
+//!     let module = Module::new(&store, &module_wat).unwrap();
+//!     // The module doesn't import anything, so we create an empty import object.
+//!     let import_object = imports! {};
+//!     let instance = Instance::new(&mut store, &module, &import_object).unwrap();
+//!
+//!     let add_one = instance.exports.get_function("add_one").unwrap();
+//!     let result = add_one.call(&mut store, &[Value::I32(42)]).unwrap();
+//!     assert_eq!(result[0], Value::I32(43));
+//!
+//!     result[0].unwrap_i32()
+//! }
+//! ```
+//!
+//! Note that it's the same code as above with the former example. The
+//! API is the same!
+//!
+//! Then, compile with `wasm-pack build`. Take care of using the `js`
+//! or `js-default` Cargo features.
+//!
+//! [wasm]: https://webassembly.org/
+//! [wasmer-examples]: https://github.com/wasmerio/wasmer/tree/master/examples
+//! [`wasmer-cache`]: https://docs.rs/wasmer-cache/
+//! [wasmer-compiler]: https://docs.rs/wasmer-compiler/
+//! [`wasmer-emscripten`]: https://docs.rs/wasmer-emscripten/
+//! [`wasmer-compiler-singlepass`]: https://docs.rs/wasmer-compiler-singlepass/
+//! [`wasmer-compiler-llvm`]: https://docs.rs/wasmer-compiler-llvm/
+//! [`wasmer-compiler-cranelift`]: https://docs.rs/wasmer-compiler-cranelift/
+//! [`wasmer-wasix`]: https://docs.rs/wasmer-wasix/
+//! [`wasm-pack`]: https://github.com/rustwasm/wasm-pack/
+//! [`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen
+
+#[cfg(all(not(feature = "sys"), not(feature = "js"), not(feature = "jsc")))]
+compile_error!("One of: `sys`, `js` or `jsc` features must be enabled. Please, pick one.");
+
+#[cfg(all(feature = "sys", feature = "js"))]
+compile_error!(
+    "Cannot have both `sys` and `js` features enabled at the same time. Please, pick one."
+);
+
+#[cfg(all(feature = "js", feature = "jsc"))]
+compile_error!(
+    "Cannot have both `js` and `jsc` features enabled at the same time. Please, pick one."
+);
+
+#[cfg(all(feature = "sys", feature = "jsc"))]
+compile_error!(
+    "Cannot have both `sys` and `jsc` features enabled at the same time. Please, pick one."
+);
+
+#[cfg(all(feature = "sys", target_arch = "wasm32"))]
+compile_error!("The `sys` feature must be enabled only for non-`wasm32` target.");
+
+#[cfg(all(feature = "jsc", target_arch = "wasm32"))]
+compile_error!("The `jsc` feature must be enabled only for non-`wasm32` target.");
+
+#[cfg(all(feature = "js", not(target_arch = "wasm32")))]
+compile_error!(
+    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasi`)."
+);
+
+mod access;
+mod engine;
+mod errors;
+mod exports;
+mod extern_ref;
+mod externals;
+mod function_env;
+mod imports;
+mod instance;
+mod into_bytes;
+mod mem_access;
+mod module;
+mod native_type;
+mod ptr;
+mod store;
+mod typed_function;
+mod value;
+pub mod vm;
+
+#[cfg(any(feature = "wasm-types-polyfill", feature = "jsc"))]
+mod module_info_polyfill;
+
+#[cfg(feature = "sys")]
+/// sys
+pub mod sys;
+
+#[cfg(feature = "sys")]
+pub use sys::*;
+
+#[cfg(feature = "sys")]
+#[deprecated(note = "wasmer::Artifact is deprecated, use wasmer::sys::Artifact instead")]
+/// A compiled wasm module, ready to be instantiated.
+pub type Artifact = sys::Artifact;
+#[cfg(feature = "sys")]
+#[deprecated(note = "wasmer::EngineBuilder is deprecated, use wasmer::sys::EngineBuilder instead")]
+/// The Builder contents of `Engine`
+pub type EngineBuilder = sys::EngineBuilder;
+#[cfg(feature = "sys")]
+#[deprecated(note = "wasmer::Features is deprecated, use wasmer::sys::Features instead")]
+/// Controls which experimental features will be enabled.
+pub type Features = sys::Features;
+#[cfg(feature = "sys")]
+#[deprecated(note = "wasmer::BaseTunables is deprecated, use wasmer::sys::BaseTunables instead")]
+/// Tunable parameters for WebAssembly compilation.
+/// This is the reference implementation of the `Tunables` trait,
+/// used by default.
+pub type BaseTunables = sys::BaseTunables;
+#[cfg(feature = "sys")]
+#[deprecated(note = "wasmer::VMConfig is deprecated, use wasmer::sys::VMConfig instead")]
+/// Configuration for the the runtime VM
+/// Currently only the stack size is configurable
+pub type VMConfig = sys::VMConfig;
+
+#[cfg(feature = "js")]
+mod js;
+
+#[cfg(feature = "js")]
+pub use js::*;
+
+#[cfg(feature = "jsc")]
+mod jsc;
+
+#[cfg(feature = "jsc")]
+pub use jsc::*;
+
+pub use crate::externals::{
+    Extern, Function, Global, HostFunction, Memory, MemoryLocation, MemoryView, SharedMemory, Table,
+};
+pub use access::WasmSliceAccess;
+pub use engine::{AsEngineRef, Engine, EngineRef};
+pub use errors::{AtomicsError, InstantiationError, LinkError, RuntimeError};
+pub use exports::{ExportError, Exportable, Exports, ExportsIterator};
+pub use extern_ref::ExternRef;
+pub use function_env::{FunctionEnv, FunctionEnvMut};
+pub use imports::Imports;
+pub use instance::Instance;
+pub use into_bytes::IntoBytes;
+pub use mem_access::{MemoryAccessError, WasmRef, WasmSlice, WasmSliceIter};
+pub use module::{IoCompileError, Module};
+pub use native_type::{FromToNativeWasmType, NativeWasmTypeInto, WasmTypeList};
+pub use ptr::{Memory32, Memory64, MemorySize, WasmPtr, WasmPtr64};
+pub use store::{AsStoreMut, AsStoreRef, OnCalledHandler, Store, StoreId, StoreMut, StoreRef};
+#[cfg(feature = "sys")]
+pub use store::{TrapHandlerFn, Tunables};
+#[cfg(any(feature = "sys", feature = "jsc"))]
+pub use target_lexicon::{Architecture, CallingConvention, OperatingSystem, Triple, HOST};
+pub use typed_function::TypedFunction;
+pub use value::Value;
+
+// Reexport from other modules
+
+pub use wasmer_derive::ValueType;
+// TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+pub use wasmer_types::{
+    is_wasm, Bytes, CompileError, CpuFeature, DeserializeError, ExportIndex, ExportType,
+    ExternType, FrameInfo, FunctionType, GlobalInit, GlobalType, ImportType, LocalFunctionIndex,
+    MemoryError, MemoryType, MiddlewareError, Mutability, OnCalledAction, Pages,
+    ParseCpuFeatureError, SerializeError, TableType, Target, Type, ValueType, WasmError,
+    WasmResult, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
+};
+#[cfg(feature = "wat")]
+pub use wat::parse_bytes as wat2wasm;
+
+#[cfg(feature = "wasmparser")]
+pub use wasmparser;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/mem_access.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/mem_access.rs
new file mode 100644
index 0000000..7c0b031
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/mem_access.rs
@@ -0,0 +1,404 @@
+use crate::access::WasmRefAccess;
+use crate::externals::memory::MemoryBuffer;
+use crate::{Memory32, Memory64, MemorySize, MemoryView, WasmPtr};
+use crate::{RuntimeError, WasmSliceAccess};
+use std::convert::TryInto;
+use std::fmt;
+use std::marker::PhantomData;
+use std::mem::{self, MaybeUninit};
+use std::ops::Range;
+use std::slice;
+use std::string::FromUtf8Error;
+use thiserror::Error;
+use wasmer_types::ValueType;
+
+/// Error for invalid [`Memory`][super::Memory] access.
+#[derive(Clone, Copy, Debug, Error)]
+#[non_exhaustive]
+pub enum MemoryAccessError {
+    /// Memory access is outside heap bounds.
+    #[error("memory access out of bounds")]
+    HeapOutOfBounds,
+    /// Address calculation overflow.
+    #[error("address calculation overflow")]
+    Overflow,
+    /// String is not valid UTF-8.
+    #[error("string is not valid utf-8")]
+    NonUtf8String,
+}
+
+impl From<MemoryAccessError> for RuntimeError {
+    fn from(err: MemoryAccessError) -> Self {
+        Self::new(err.to_string())
+    }
+}
+impl From<FromUtf8Error> for MemoryAccessError {
+    fn from(_err: FromUtf8Error) -> Self {
+        Self::NonUtf8String
+    }
+}
+
+/// Reference to a value in Wasm memory.
+///
+/// The type of the value must satisfy the requirements of the `ValueType`
+/// trait which guarantees that reading and writing such a value to untrusted
+/// memory is safe.
+///
+/// The address is required to be aligned: unaligned accesses cause undefined behavior.
+///
+/// This wrapper safely handles concurrent modifications of the data by another
+/// thread.
+#[derive(Clone, Copy)]
+pub struct WasmRef<'a, T: ValueType> {
+    #[allow(unused)]
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) offset: u64,
+    marker: PhantomData<*mut T>,
+}
+
+impl<'a, T: ValueType> WasmRef<'a, T> {
+    /// Creates a new `WasmRef` at the given offset in a memory.
+    #[inline]
+    pub fn new(view: &'a MemoryView, offset: u64) -> Self {
+        Self {
+            buffer: view.buffer(),
+            offset,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get the offset into Wasm linear memory for this `WasmRef`.
+    #[inline]
+    pub fn offset(self) -> u64 {
+        self.offset
+    }
+
+    /// Get a `WasmPtr` for this `WasmRef`.
+    #[inline]
+    pub fn as_ptr32(self) -> WasmPtr<T, Memory32> {
+        WasmPtr::new(self.offset as u32)
+    }
+
+    /// Get a 64-bit `WasmPtr` for this `WasmRef`.
+    #[inline]
+    pub fn as_ptr64(self) -> WasmPtr<T, Memory64> {
+        WasmPtr::new(self.offset)
+    }
+
+    /// Get a `WasmPtr` for this `WasmRef`.
+    #[inline]
+    pub fn as_ptr<M: MemorySize>(self) -> WasmPtr<T, M> {
+        let offset: M::Offset = self
+            .offset
+            .try_into()
+            .map_err(|_| "invalid offset into memory")
+            .unwrap();
+        WasmPtr::<T, M>::new(offset)
+    }
+
+    /// Reads the location pointed to by this `WasmRef`.
+    #[inline]
+    pub fn read(self) -> Result<T, MemoryAccessError> {
+        let mut out = MaybeUninit::uninit();
+        let buf =
+            unsafe { slice::from_raw_parts_mut(out.as_mut_ptr() as *mut u8, mem::size_of::<T>()) };
+        self.buffer.read(self.offset, buf)?;
+        Ok(unsafe { out.assume_init() })
+        // Ok(self.access()?.read())
+    }
+
+    /// Writes to the location pointed to by this `WasmRef`.
+    #[inline]
+    pub fn write(self, val: T) -> Result<(), MemoryAccessError> {
+        self.access()?.write(val);
+        Ok(())
+    }
+
+    /// Gains direct access to the memory of this slice
+    #[inline]
+    pub fn access(self) -> Result<WasmRefAccess<'a, T>, MemoryAccessError> {
+        WasmRefAccess::new(self)
+    }
+}
+
+impl<'a, T: ValueType> fmt::Debug for WasmRef<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "WasmRef(offset: {}, pointer: {:#x})",
+            self.offset, self.offset
+        )
+    }
+}
+
+/// Reference to an array of values in Wasm memory.
+///
+/// The type of the value must satisfy the requirements of the `ValueType`
+/// trait which guarantees that reading and writing such a value to untrusted
+/// memory is safe.
+///
+/// The address is not required to be aligned: unaligned accesses are fully
+/// supported.
+///
+/// This wrapper safely handles concurrent modifications of the data by another
+/// thread.
+#[derive(Clone, Copy)]
+pub struct WasmSlice<'a, T: ValueType> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) offset: u64,
+    pub(crate) len: u64,
+    marker: PhantomData<*mut T>,
+}
+
+impl<'a, T: ValueType> WasmSlice<'a, T> {
+    /// Creates a new `WasmSlice` starting at the given offset in memory and
+    /// with the given number of elements.
+    ///
+    /// Returns a `MemoryAccessError` if the slice length overflows.
+    #[inline]
+    pub fn new(view: &'a MemoryView, offset: u64, len: u64) -> Result<Self, MemoryAccessError> {
+        let total_len = len
+            .checked_mul(mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        Ok(Self {
+            buffer: view.buffer(),
+            offset,
+            len,
+            marker: PhantomData,
+        })
+    }
+
+    /// Get the offset into Wasm linear memory for this `WasmSlice`.
+    #[inline]
+    pub fn offset(self) -> u64 {
+        self.offset
+    }
+
+    /// Get a 32-bit `WasmPtr` for this `WasmRef`.
+    #[inline]
+    pub fn as_ptr32(self) -> WasmPtr<T, Memory32> {
+        WasmPtr::new(self.offset as u32)
+    }
+
+    /// Get a 64-bit `WasmPtr` for this `WasmRef`.
+    #[inline]
+    pub fn as_ptr64(self) -> WasmPtr<T, Memory64> {
+        WasmPtr::new(self.offset)
+    }
+
+    /// Get the number of elements in this slice.
+    #[inline]
+    pub fn len(self) -> u64 {
+        self.len
+    }
+
+    /// Returns `true` if the number of elements is 0.
+    #[inline]
+    pub fn is_empty(self) -> bool {
+        self.len == 0
+    }
+
+    /// Get a `WasmRef` to an element in the slice.
+    #[inline]
+    pub fn index(self, idx: u64) -> WasmRef<'a, T> {
+        if idx >= self.len {
+            panic!("WasmSlice out of bounds");
+        }
+        let offset = self.offset + idx * mem::size_of::<T>() as u64;
+        WasmRef {
+            buffer: self.buffer,
+            offset,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get a `WasmSlice` for a subslice of this slice.
+    #[inline]
+    pub fn subslice(self, range: Range<u64>) -> WasmSlice<'a, T> {
+        if range.start > range.end || range.end > self.len {
+            panic!("WasmSlice out of bounds");
+        }
+        let offset = self.offset + range.start * mem::size_of::<T>() as u64;
+        Self {
+            buffer: self.buffer,
+            offset,
+            len: range.end - range.start,
+            marker: PhantomData,
+        }
+    }
+
+    /// Get an iterator over the elements in this slice.
+    #[inline]
+    pub fn iter(self) -> WasmSliceIter<'a, T> {
+        WasmSliceIter { slice: self }
+    }
+
+    /// Gains direct access to the memory of this slice
+    #[inline]
+    pub fn access(self) -> Result<WasmSliceAccess<'a, T>, MemoryAccessError> {
+        WasmSliceAccess::new(self)
+    }
+
+    /// Reads an element of this slice.
+    #[inline]
+    pub fn read(self, idx: u64) -> Result<T, MemoryAccessError> {
+        self.index(idx).read()
+    }
+
+    /// Writes to an element of this slice.
+    #[inline]
+    pub fn write(self, idx: u64, val: T) -> Result<(), MemoryAccessError> {
+        self.index(idx).write(val)
+    }
+
+    /// Reads the entire slice into the given buffer.
+    ///
+    /// The length of the buffer must match the length of the slice.
+    #[inline]
+    pub fn read_slice(self, buf: &mut [T]) -> Result<(), MemoryAccessError> {
+        assert_eq!(
+            buf.len() as u64,
+            self.len,
+            "slice length doesn't match WasmSlice length"
+        );
+        let size = std::mem::size_of_val(buf);
+        let bytes =
+            unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut MaybeUninit<u8>, size) };
+        self.buffer.read_uninit(self.offset, bytes)?;
+        Ok(())
+    }
+
+    /// Reads the entire slice into the given uninitialized buffer.
+    ///
+    /// The length of the buffer must match the length of the slice.
+    ///
+    /// This method returns an initialized view of the buffer.
+    #[inline]
+    pub fn read_slice_uninit(
+        self,
+        buf: &mut [MaybeUninit<T>],
+    ) -> Result<&mut [T], MemoryAccessError> {
+        assert_eq!(
+            buf.len() as u64,
+            self.len,
+            "slice length doesn't match WasmSlice length"
+        );
+        let bytes = unsafe {
+            slice::from_raw_parts_mut(
+                buf.as_mut_ptr() as *mut MaybeUninit<u8>,
+                buf.len() * mem::size_of::<T>(),
+            )
+        };
+        self.buffer.read_uninit(self.offset, bytes)?;
+        Ok(unsafe { slice::from_raw_parts_mut(buf.as_mut_ptr() as *mut T, buf.len()) })
+    }
+
+    /// Write the given slice into this `WasmSlice`.
+    ///
+    /// The length of the slice must match the length of the `WasmSlice`.
+    #[inline]
+    pub fn write_slice(self, data: &[T]) -> Result<(), MemoryAccessError> {
+        assert_eq!(
+            data.len() as u64,
+            self.len,
+            "slice length doesn't match WasmSlice length"
+        );
+        let size = std::mem::size_of_val(data);
+        let bytes = unsafe { slice::from_raw_parts(data.as_ptr() as *const u8, size) };
+        self.buffer.write(self.offset, bytes)
+    }
+
+    /// Reads this `WasmSlice` into a `slice`.
+    #[inline]
+    pub fn read_to_slice(self, buf: &mut [MaybeUninit<u8>]) -> Result<usize, MemoryAccessError> {
+        let len = self.len.try_into().expect("WasmSlice length overflow");
+        self.buffer.read_uninit(self.offset, buf)?;
+        Ok(len)
+    }
+
+    /// Reads this `WasmSlice` into a `Vec`.
+    #[inline]
+    pub fn read_to_vec(self) -> Result<Vec<T>, MemoryAccessError> {
+        let len = self.len.try_into().expect("WasmSlice length overflow");
+        let mut vec = Vec::with_capacity(len);
+        let bytes = unsafe {
+            slice::from_raw_parts_mut(
+                vec.as_mut_ptr() as *mut MaybeUninit<u8>,
+                len * mem::size_of::<T>(),
+            )
+        };
+        self.buffer.read_uninit(self.offset, bytes)?;
+        unsafe {
+            vec.set_len(len);
+        }
+        Ok(vec)
+    }
+
+    /// Reads this `WasmSlice` into a `BytesMut`
+    #[inline]
+    pub fn read_to_bytes(self) -> Result<bytes::BytesMut, MemoryAccessError> {
+        let len = self.len.try_into().expect("WasmSlice length overflow");
+        let mut ret = bytes::BytesMut::with_capacity(len);
+        let bytes = unsafe {
+            slice::from_raw_parts_mut(
+                ret.as_mut_ptr() as *mut MaybeUninit<u8>,
+                len * mem::size_of::<T>(),
+            )
+        };
+        self.buffer.read_uninit(self.offset, bytes)?;
+        unsafe {
+            ret.set_len(len);
+        }
+        Ok(ret)
+    }
+}
+
+impl<'a, T: ValueType> fmt::Debug for WasmSlice<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "WasmSlice(offset: {}, len: {}, pointer: {:#x})",
+            self.offset, self.len, self.offset
+        )
+    }
+}
+
+/// Iterator over the elements of a `WasmSlice`.
+pub struct WasmSliceIter<'a, T: ValueType> {
+    slice: WasmSlice<'a, T>,
+}
+
+impl<'a, T: ValueType> Iterator for WasmSliceIter<'a, T> {
+    type Item = WasmRef<'a, T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.slice.is_empty() {
+            let elem = self.slice.index(0);
+            self.slice = self.slice.subslice(1..self.slice.len());
+            Some(elem)
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0..self.slice.len()).size_hint()
+    }
+}
+
+impl<'a, T: ValueType> DoubleEndedIterator for WasmSliceIter<'a, T> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if !self.slice.is_empty() {
+            let elem = self.slice.index(self.slice.len() - 1);
+            self.slice = self.slice.subslice(0..self.slice.len() - 1);
+            Some(elem)
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a, T: ValueType> ExactSizeIterator for WasmSliceIter<'a, T> {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/module.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/module.rs
new file mode 100644
index 0000000..52bf98a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/module.rs
@@ -0,0 +1,484 @@
+use bytes::Bytes;
+use std::fmt;
+use std::fs;
+use std::io;
+use std::path::Path;
+
+use crate::engine::AsEngineRef;
+use thiserror::Error;
+#[cfg(feature = "wat")]
+use wasmer_types::WasmError;
+use wasmer_types::{
+    CompileError, DeserializeError, ExportsIterator, ImportsIterator, ModuleInfo, SerializeError,
+};
+use wasmer_types::{ExportType, ImportType};
+
+use crate::into_bytes::IntoBytes;
+
+#[cfg(feature = "js")]
+use crate::js::module as module_imp;
+#[cfg(feature = "jsc")]
+use crate::jsc::module as module_imp;
+#[cfg(feature = "sys")]
+use crate::sys::module as module_imp;
+
+/// IO Error on a Module Compilation
+#[derive(Error, Debug)]
+pub enum IoCompileError {
+    /// An IO error
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// A compilation error
+    #[error(transparent)]
+    Compile(#[from] CompileError),
+}
+
+/// A WebAssembly Module contains stateless WebAssembly
+/// code that has already been compiled and can be instantiated
+/// multiple times.
+///
+/// ## Cloning a module
+///
+/// Cloning a module is cheap: it does a shallow copy of the compiled
+/// contents rather than a deep copy.
+#[derive(Clone, PartialEq, Eq)]
+pub struct Module(pub(crate) module_imp::Module);
+
+impl Module {
+    /// Creates a new WebAssembly Module given the configuration
+    /// in the store.
+    ///
+    /// If the provided bytes are not WebAssembly-like (start with `b"\0asm"`),
+    /// and the "wat" feature is enabled for this crate, this function will try to
+    /// to convert the bytes assuming they correspond to the WebAssembly text
+    /// format.
+    ///
+    /// ## Security
+    ///
+    /// Before the code is compiled, it will be validated using the store
+    /// features.
+    ///
+    /// ## Errors
+    ///
+    /// Creating a WebAssembly module from bytecode can result in a
+    /// [`CompileError`] since this operation requires to transorm the Wasm
+    /// bytecode into code the machine can easily execute.
+    ///
+    /// ## Example
+    ///
+    /// Reading from a WAT file.
+    ///
+    /// ```
+    /// use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = "(module)";
+    /// let module = Module::new(&store, wat)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Reading from bytes:
+    ///
+    /// ```
+    /// use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// // The following is the same as:
+    /// // (module
+    /// //   (type $t0 (func (param i32) (result i32)))
+    /// //   (func $add_one (export "add_one") (type $t0) (param $p0 i32) (result i32)
+    /// //     get_local $p0
+    /// //     i32.const 1
+    /// //     i32.add)
+    /// // )
+    /// let bytes: Vec<u8> = vec![
+    ///     0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x06, 0x01, 0x60,
+    ///     0x01, 0x7f, 0x01, 0x7f, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0b, 0x01, 0x07,
+    ///     0x61, 0x64, 0x64, 0x5f, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x0a, 0x09, 0x01,
+    ///     0x07, 0x00, 0x20, 0x00, 0x41, 0x01, 0x6a, 0x0b, 0x00, 0x1a, 0x04, 0x6e,
+    ///     0x61, 0x6d, 0x65, 0x01, 0x0a, 0x01, 0x00, 0x07, 0x61, 0x64, 0x64, 0x5f,
+    ///     0x6f, 0x6e, 0x65, 0x02, 0x07, 0x01, 0x00, 0x01, 0x00, 0x02, 0x70, 0x30,
+    /// ];
+    /// let module = Module::new(&store, bytes)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    /// # Example of loading a module using just an `Engine` and no `Store`
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// #
+    /// # let engine: Engine = Cranelift::default().into();
+    ///
+    /// let module = Module::from_file(&engine, "path/to/foo.wasm");
+    /// ```
+    pub fn new(engine: &impl AsEngineRef, bytes: impl AsRef<[u8]>) -> Result<Self, CompileError> {
+        #[cfg(feature = "wat")]
+        let bytes = wat::parse_bytes(bytes.as_ref()).map_err(|e| {
+            CompileError::Wasm(WasmError::Generic(format!(
+                "Error when converting wat: {}",
+                e
+            )))
+        })?;
+        Self::from_binary(engine, bytes.as_ref())
+    }
+
+    /// Creates a new WebAssembly module from a file path.
+    pub fn from_file(
+        engine: &impl AsEngineRef,
+        file: impl AsRef<Path>,
+    ) -> Result<Self, IoCompileError> {
+        let file_ref = file.as_ref();
+        let canonical = file_ref.canonicalize()?;
+        let wasm_bytes = std::fs::read(file_ref)?;
+        let mut module = Self::new(engine, wasm_bytes)?;
+        // Set the module name to the absolute path of the filename.
+        // This is useful for debugging the stack traces.
+        let filename = canonical.as_path().to_str().unwrap();
+        module.set_name(filename);
+        Ok(module)
+    }
+
+    /// Creates a new WebAssembly module from a Wasm binary.
+    ///
+    /// Opposed to [`Module::new`], this function is not compatible with
+    /// the WebAssembly text format (if the "wat" feature is enabled for
+    /// this crate).
+    pub fn from_binary(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        Ok(Self(module_imp::Module::from_binary(engine, binary)?))
+    }
+
+    /// Creates a new WebAssembly module from a Wasm binary,
+    /// skipping any kind of validation on the WebAssembly file.
+    ///
+    /// # Safety
+    ///
+    /// This can speed up compilation time a bit, but it should be only used
+    /// in environments where the WebAssembly modules are trusted and validated
+    /// beforehand.
+    pub unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        Ok(Self(module_imp::Module::from_binary_unchecked(
+            engine, binary,
+        )?))
+    }
+
+    /// Validates a new WebAssembly Module given the configuration
+    /// in the Store.
+    ///
+    /// This validation is normally pretty fast and checks the enabled
+    /// WebAssembly features in the Store Engine to assure deterministic
+    /// validation of the Module.
+    pub fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        module_imp::Module::validate(engine, binary)
+    }
+
+    /// Serializes a module into a binary representation that the `Engine`
+    /// can later process via [`Module::deserialize`].
+    ///
+    /// # Important
+    ///
+    /// This function will return a custom binary format that will be different than
+    /// the `wasm` binary format, but faster to load in Native hosts.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// # let module = Module::from_file(&store, "path/to/foo.wasm")?;
+    /// let serialized = module.serialize()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn serialize(&self) -> Result<Bytes, SerializeError> {
+        self.0.serialize()
+    }
+
+    /// Serializes a module into a file that the `Engine`
+    /// can later process via [`Module::deserialize_from_file`].
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// # let module = Module::from_file(&store, "path/to/foo.wasm")?;
+    /// module.serialize_to_file("path/to/foo.so")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn serialize_to_file(&self, path: impl AsRef<Path>) -> Result<(), SerializeError> {
+        let serialized = self.0.serialize()?;
+        fs::write(path, serialized)?;
+        Ok(())
+    }
+
+    /// Deserializes a serialized module binary into a `Module`.
+    ///
+    /// Note: You should usually prefer the safer [`Module::deserialize`].
+    ///
+    /// # Important
+    ///
+    /// This function only accepts a custom binary format, which will be different
+    /// than the `wasm` binary format and may change among Wasmer versions.
+    /// (it should be the result of the serialization of a Module via the
+    /// `Module::serialize` method.).
+    ///
+    /// # Safety
+    ///
+    /// This function is inherently **unsafe** as the provided bytes:
+    /// 1. Are going to be deserialized directly into Rust objects.
+    /// 2. Contains the function assembly bodies and, if intercepted,
+    ///    a malicious actor could inject code into executable
+    ///    memory.
+    ///
+    /// And as such, the `deserialize_unchecked` method is unsafe.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let module = Module::deserialize_unchecked(&store, serialized_data)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Ok(Self(module_imp::Module::deserialize_unchecked(
+            engine, bytes,
+        )?))
+    }
+
+    /// Deserializes a serialized Module binary into a `Module`.
+    ///
+    /// # Important
+    ///
+    /// This function only accepts a custom binary format, which will be different
+    /// than the `wasm` binary format and may change among Wasmer versions.
+    /// (it should be the result of the serialization of a Module via the
+    /// `Module::serialize` method.).
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let module = Module::deserialize(&store, serialized_data)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Safety
+    /// This function is inherently **unsafe**, because it loads executable code
+    /// into memory.
+    /// The loaded bytes must be trusted to contain a valid artifact previously
+    /// built with [`Self::serialize`].
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        Ok(Self(module_imp::Module::deserialize(engine, bytes)?))
+    }
+
+    /// Deserializes a serialized Module located in a `Path` into a `Module`.
+    /// > Note: the module has to be serialized before with the `serialize` method.
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # let mut store = Store::default();
+    /// # fn main() -> anyhow::Result<()> {
+    /// let module = Module::deserialize_from_file(&store, path)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// # Safety
+    ///
+    /// See [`Self::deserialize`].
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        Ok(Self(module_imp::Module::deserialize_from_file(
+            engine, path,
+        )?))
+    }
+
+    /// Deserializes a serialized Module located in a `Path` into a `Module`.
+    /// > Note: the module has to be serialized before with the `serialize` method.
+    ///
+    /// You should usually prefer the safer [`Module::deserialize_from_file`].
+    ///
+    /// # Safety
+    ///
+    /// Please check [`Module::deserialize_unchecked`].
+    ///
+    /// # Usage
+    ///
+    /// ```ignore
+    /// # use wasmer::*;
+    /// # let mut store = Store::default();
+    /// # fn main() -> anyhow::Result<()> {
+    /// let module = Module::deserialize_from_file_unchecked(&store, path)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        Ok(Self(module_imp::Module::deserialize_from_file_unchecked(
+            engine, path,
+        )?))
+    }
+
+    /// Returns the name of the current module.
+    ///
+    /// This name is normally set in the WebAssembly bytecode by some
+    /// compilers, but can be also overwritten using the [`Module::set_name`] method.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = "(module $moduleName)";
+    /// let module = Module::new(&store, wat)?;
+    /// assert_eq!(module.name(), Some("moduleName"));
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn name(&self) -> Option<&str> {
+        self.0.name()
+    }
+
+    /// Sets the name of the current module.
+    /// This is normally useful for stacktraces and debugging.
+    ///
+    /// It will return `true` if the module name was changed successfully,
+    /// and return `false` otherwise (in case the module is cloned or
+    /// already instantiated).
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = "(module)";
+    /// let mut module = Module::new(&store, wat)?;
+    /// assert_eq!(module.name(), None);
+    /// module.set_name("foo");
+    /// assert_eq!(module.name(), Some("foo"));
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn set_name(&mut self, name: &str) -> bool {
+        self.0.set_name(name)
+    }
+
+    /// Returns an iterator over the imported types in the Module.
+    ///
+    /// The order of the imports is guaranteed to be the same as in the
+    /// WebAssembly bytecode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = r#"(module
+    ///     (import "host" "func1" (func))
+    ///     (import "host" "func2" (func))
+    /// )"#;
+    /// let module = Module::new(&store, wat)?;
+    /// for import in module.imports() {
+    ///     assert_eq!(import.module(), "host");
+    ///     assert!(import.name().contains("func"));
+    ///     import.ty();
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn imports(&self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+        self.0.imports()
+    }
+
+    /// Returns an iterator over the exported types in the Module.
+    ///
+    /// The order of the exports is guaranteed to be the same as in the
+    /// WebAssembly bytecode.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let wat = r#"(module
+    ///     (func (export "namedfunc"))
+    ///     (memory (export "namedmemory") 1)
+    /// )"#;
+    /// let module = Module::new(&store, wat)?;
+    /// for export_ in module.exports() {
+    ///     assert!(export_.name().contains("named"));
+    ///     export_.ty();
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn exports(&self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+        self.0.exports()
+    }
+
+    /// Get the custom sections of the module given a `name`.
+    ///
+    /// # Important
+    ///
+    /// Following the WebAssembly spec, one name can have multiple
+    /// custom sections. That's why an iterator (rather than one element)
+    /// is returned.
+    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        self.0.custom_sections(name)
+    }
+
+    /// The ABI of the [`ModuleInfo`] is very unstable, we refactor it very often.
+    /// This function is public because in some cases it can be useful to get some
+    /// extra information from the module.
+    ///
+    /// However, the usage is highly discouraged.
+    #[doc(hidden)]
+    pub fn info(&self) -> &ModuleInfo {
+        self.0.info()
+    }
+}
+
+impl fmt::Debug for Module {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Module")
+            .field("name", &self.name())
+            .finish()
+    }
+}
+
+#[cfg(feature = "js")]
+impl From<Module> for wasm_bindgen::JsValue {
+    fn from(value: Module) -> Self {
+        wasm_bindgen::JsValue::from(value.0)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/module_info_polyfill.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/module_info_polyfill.rs
new file mode 100644
index 0000000..43c3aa3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/module_info_polyfill.rs
@@ -0,0 +1,626 @@
+//! Polyfill skeleton that traverses the whole WebAssembly module and
+//! creates the corresponding import and export types.
+//!
+//! This shall not be needed once the JS type reflection API is available
+//! for the Wasm imports and exports.
+//!
+//! <https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md>
+use core::convert::TryFrom;
+use std::vec::Vec;
+use wasmer_types::entity::EntityRef;
+use wasmer_types::{
+    ExportIndex, FunctionIndex, FunctionType, GlobalIndex, GlobalType, ImportIndex, MemoryIndex,
+    MemoryType, ModuleInfo, Pages, SignatureIndex, TableIndex, TableType, Type,
+};
+
+use wasmparser::{
+    self, BinaryReaderError, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
+    GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, MemorySectionReader,
+    MemoryType as WPMemoryType, NameSectionReader, Parser, Payload, TableSectionReader, TypeRef,
+    TypeSectionReader,
+};
+
+pub type WasmResult<T> = Result<T, String>;
+
+#[derive(Default)]
+pub struct ModuleInfoPolyfill {
+    pub(crate) info: ModuleInfo,
+}
+
+impl ModuleInfoPolyfill {
+    pub(crate) fn declare_export(&mut self, export: ExportIndex, name: &str) -> WasmResult<()> {
+        self.info.exports.insert(String::from(name), export);
+        Ok(())
+    }
+
+    pub(crate) fn declare_import(
+        &mut self,
+        import: ImportIndex,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        self.info.imports.insert(
+            wasmer_types::ImportKey {
+                module: String::from(module),
+                field: String::from(field),
+                import_idx: self.info.imports.len() as u32,
+            },
+            import,
+        );
+        Ok(())
+    }
+
+    pub(crate) fn reserve_signatures(&mut self, num: u32) -> WasmResult<()> {
+        self.info
+            .signatures
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_signature(&mut self, sig: FunctionType) -> WasmResult<()> {
+        self.info.signatures.push(sig);
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_import(
+        &mut self,
+        sig_index: SignatureIndex,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.info.functions.len(),
+            self.info.num_imported_functions,
+            "Imported functions must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Function(FunctionIndex::from_u32(
+                self.info.num_imported_functions as _,
+            )),
+            module,
+            field,
+        )?;
+        self.info.functions.push(sig_index);
+        self.info.num_imported_functions += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_table_import(
+        &mut self,
+        table: TableType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.info.tables.len(),
+            self.info.num_imported_tables,
+            "Imported tables must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Table(TableIndex::from_u32(self.info.num_imported_tables as _)),
+            module,
+            field,
+        )?;
+        self.info.tables.push(table);
+        self.info.num_imported_tables += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_memory_import(
+        &mut self,
+        memory: MemoryType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.info.memories.len(),
+            self.info.num_imported_memories,
+            "Imported memories must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Memory(MemoryIndex::from_u32(self.info.num_imported_memories as _)),
+            module,
+            field,
+        )?;
+        self.info.memories.push(memory);
+        self.info.num_imported_memories += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_global_import(
+        &mut self,
+        global: GlobalType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.info.globals.len(),
+            self.info.num_imported_globals,
+            "Imported globals must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Global(GlobalIndex::from_u32(self.info.num_imported_globals as _)),
+            module,
+            field,
+        )?;
+        self.info.globals.push(global);
+        self.info.num_imported_globals += 1;
+        Ok(())
+    }
+
+    pub(crate) fn reserve_func_types(&mut self, num: u32) -> WasmResult<()> {
+        self.info
+            .functions
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()> {
+        self.info.functions.push(sig_index);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_tables(&mut self, num: u32) -> WasmResult<()> {
+        self.info
+            .tables
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_table(&mut self, table: TableType) -> WasmResult<()> {
+        self.info.tables.push(table);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_memories(&mut self, num: u32) -> WasmResult<()> {
+        self.info
+            .memories
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_memory(&mut self, memory: MemoryType) -> WasmResult<()> {
+        self.info.memories.push(memory);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_globals(&mut self, num: u32) -> WasmResult<()> {
+        self.info
+            .globals
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_global(&mut self, global: GlobalType) -> WasmResult<()> {
+        self.info.globals.push(global);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_exports(&mut self, num: u32) -> WasmResult<()> {
+        self.info.exports.reserve(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn reserve_imports(&mut self, num: u32) -> WasmResult<()> {
+        self.info.imports.reserve(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_export(
+        &mut self,
+        func_index: FunctionIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Function(func_index), name)
+    }
+
+    pub(crate) fn declare_table_export(
+        &mut self,
+        table_index: TableIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Table(table_index), name)
+    }
+
+    pub(crate) fn declare_memory_export(
+        &mut self,
+        memory_index: MemoryIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Memory(memory_index), name)
+    }
+
+    pub(crate) fn declare_global_export(
+        &mut self,
+        global_index: GlobalIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Global(global_index), name)
+    }
+
+    pub(crate) fn declare_module_name(&mut self, name: &str) -> WasmResult<()> {
+        self.info.name = Some(name.to_string());
+        Ok(())
+    }
+}
+
+fn transform_err(err: BinaryReaderError) -> String {
+    err.message().into()
+}
+
+/// Translate a sequence of bytes forming a valid Wasm binary into a
+/// parsed ModuleInfo `ModuleInfoPolyfill`.
+pub fn translate_module<'data>(data: &'data [u8]) -> WasmResult<ModuleInfoPolyfill> {
+    let mut module_info: ModuleInfoPolyfill = Default::default();
+
+    for payload in Parser::new(0).parse_all(data) {
+        match payload.map_err(transform_err)? {
+            Payload::TypeSection(types) => {
+                parse_type_section(types, &mut module_info)?;
+            }
+
+            Payload::ImportSection(imports) => {
+                parse_import_section(imports, &mut module_info)?;
+            }
+
+            Payload::FunctionSection(functions) => {
+                parse_function_section(functions, &mut module_info)?;
+            }
+
+            Payload::TableSection(tables) => {
+                parse_table_section(tables, &mut module_info)?;
+            }
+
+            Payload::MemorySection(memories) => {
+                parse_memory_section(memories, &mut module_info)?;
+            }
+
+            Payload::GlobalSection(globals) => {
+                parse_global_section(globals, &mut module_info)?;
+            }
+
+            Payload::ExportSection(exports) => {
+                parse_export_section(exports, &mut module_info)?;
+            }
+
+            Payload::CustomSection(sectionreader) => {
+                // We still add the custom section data, but also read it as name section reader
+                let name = sectionreader.name();
+                if name == "name" {
+                    parse_name_section(
+                        NameSectionReader::new(sectionreader.data(), sectionreader.data_offset()),
+                        &mut module_info,
+                    )?;
+                }
+            }
+
+            _ => {}
+        }
+    }
+
+    Ok(module_info)
+}
+
+/// Helper function translating wasmparser types to Wasm Type.
+pub fn wptype_to_type(ty: wasmparser::ValType) -> WasmResult<Type> {
+    match ty {
+        wasmparser::ValType::I32 => Ok(Type::I32),
+        wasmparser::ValType::I64 => Ok(Type::I64),
+        wasmparser::ValType::F32 => Ok(Type::F32),
+        wasmparser::ValType::F64 => Ok(Type::F64),
+        wasmparser::ValType::V128 => Ok(Type::V128),
+        wasmparser::ValType::Ref(ty) => wpreftype_to_type(ty),
+    }
+}
+
+/// Converts a wasmparser ref type to a [`Type`].
+pub fn wpreftype_to_type(ty: wasmparser::RefType) -> WasmResult<Type> {
+    if ty.is_extern_ref() {
+        Ok(Type::ExternRef)
+    } else if ty.is_func_ref() {
+        Ok(Type::FuncRef)
+    } else {
+        Err(format!("Unsupported ref type: {:?}", ty))
+    }
+}
+
+/// Parses the Type section of the wasm module.
+pub fn parse_type_section(
+    reader: TypeSectionReader,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_signatures(reader.count())?;
+
+    for res in reader {
+        let group = res.map_err(transform_err)?;
+
+        for ty in group.into_types() {
+            match ty.composite_type {
+                wasmparser::CompositeType::Func(functype) => {
+                    let params = functype.params();
+                    let returns = functype.results();
+                    let sig_params: Vec<Type> = params
+                        .iter()
+                        .map(|ty| {
+                            wptype_to_type(*ty)
+                                .expect("only numeric types are supported in function signatures")
+                        })
+                        .collect();
+                    let sig_returns: Vec<Type> = returns
+                        .iter()
+                        .map(|ty| {
+                            wptype_to_type(*ty)
+                                .expect("only numeric types are supported in function signatures")
+                        })
+                        .collect();
+                    let sig = FunctionType::new(sig_params, sig_returns);
+                    module_info.declare_signature(sig)?;
+                }
+                _ => {
+                    unimplemented!("GC is  not implemented yet")
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parses the Import section of the wasm module.
+pub fn parse_import_section<'data>(
+    imports: ImportSectionReader<'data>,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_imports(imports.count())?;
+
+    for entry in imports {
+        let import = entry.map_err(transform_err)?;
+        let module_name = import.module;
+        let field_name = import.name;
+
+        match import.ty {
+            TypeRef::Func(sig) => {
+                module_info.declare_func_import(
+                    SignatureIndex::from_u32(sig),
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Tag(_) => {
+                unimplemented!("exception handling not implemented yet")
+            }
+            TypeRef::Memory(WPMemoryType {
+                shared,
+                memory64,
+                initial,
+                maximum,
+            }) => {
+                if memory64 {
+                    unimplemented!("64bit memory not implemented yet");
+                }
+                module_info.declare_memory_import(
+                    MemoryType {
+                        minimum: Pages(initial as u32),
+                        maximum: maximum.map(|p| Pages(p as u32)),
+                        shared,
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Global(ref ty) => {
+                module_info.declare_global_import(
+                    GlobalType {
+                        ty: wptype_to_type(ty.content_type).unwrap(),
+                        mutability: ty.mutable.into(),
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Table(ref tab) => {
+                module_info.declare_table_import(
+                    TableType {
+                        ty: wpreftype_to_type(tab.element_type).unwrap(),
+                        minimum: tab.initial,
+                        maximum: tab.maximum,
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Function section of the wasm module.
+pub fn parse_function_section(
+    functions: FunctionSectionReader,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    let num_functions = functions.count();
+    module_info.reserve_func_types(num_functions)?;
+
+    for entry in functions {
+        let sigindex = entry.map_err(transform_err)?;
+        module_info.declare_func_type(SignatureIndex::from_u32(sigindex))?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Table section of the wasm module.
+pub fn parse_table_section(
+    tables: TableSectionReader,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_tables(tables.count())?;
+
+    for entry in tables {
+        let table = entry.map_err(transform_err)?;
+        module_info.declare_table(TableType {
+            ty: wpreftype_to_type(table.ty.element_type).unwrap(),
+            minimum: table.ty.initial,
+            maximum: table.ty.maximum,
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Memory section of the wasm module.
+pub fn parse_memory_section(
+    memories: MemorySectionReader,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_memories(memories.count())?;
+
+    for entry in memories {
+        let WPMemoryType {
+            shared,
+            memory64,
+            initial,
+            maximum,
+        } = entry.map_err(transform_err)?;
+        if memory64 {
+            unimplemented!("64bit memory not implemented yet");
+        }
+        module_info.declare_memory(MemoryType {
+            minimum: Pages(initial as u32),
+            maximum: maximum.map(|p| Pages(p as u32)),
+            shared,
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Global section of the wasm module.
+pub fn parse_global_section(
+    globals: GlobalSectionReader,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_globals(globals.count())?;
+
+    for entry in globals {
+        let WPGlobalType {
+            content_type,
+            mutable,
+        } = entry.map_err(transform_err)?.ty;
+        let global = GlobalType {
+            ty: wptype_to_type(content_type).unwrap(),
+            mutability: mutable.into(),
+        };
+        module_info.declare_global(global)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Export section of the wasm module.
+pub fn parse_export_section<'data>(
+    exports: ExportSectionReader<'data>,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    module_info.reserve_exports(exports.count())?;
+
+    for entry in exports {
+        let Export {
+            name,
+            ref kind,
+            index,
+        } = entry.map_err(transform_err)?;
+
+        // The input has already been validated, so we should be able to
+        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
+        // becomes a concern here.
+        let index = index as usize;
+        match *kind {
+            ExternalKind::Func => {
+                module_info.declare_func_export(FunctionIndex::new(index), name)?
+            }
+            ExternalKind::Table => {
+                module_info.declare_table_export(TableIndex::new(index), name)?
+            }
+            ExternalKind::Memory => {
+                module_info.declare_memory_export(MemoryIndex::new(index), name)?
+            }
+            ExternalKind::Global => {
+                module_info.declare_global_export(GlobalIndex::new(index), name)?
+            }
+            ExternalKind::Tag => {
+                unimplemented!("exception handling not implemented yet")
+            }
+        }
+    }
+    Ok(())
+}
+
+// /// Parses the Start section of the wasm module.
+// pub fn parse_start_section(index: u32, module_info: &mut ModuleInfoPolyfill) -> WasmResult<()> {
+//     module_info.declare_start_function(FunctionIndex::from_u32(index))?;
+//     Ok(())
+// }
+
+/// Parses the Name section of the wasm module.
+pub fn parse_name_section<'data>(
+    mut names: NameSectionReader<'data>,
+    module_info: &mut ModuleInfoPolyfill,
+) -> WasmResult<()> {
+    while let Some(Ok(subsection)) = names.next() {
+        match subsection {
+            wasmparser::Name::Function(_function_subsection) => {
+                //for naming in function_subsection.into_iter().flatten() {
+                //    if naming.index != std::u32::MAX {
+                //        environ.declare_function_name(
+                //            FunctionIndex::from_u32(naming.index),
+                //            naming.name,
+                //        )?;
+                //    }
+                //}
+            }
+            wasmparser::Name::Module {
+                name,
+                name_range: _,
+            } => {
+                module_info.declare_module_name(name)?;
+            }
+            wasmparser::Name::Local(_) => {}
+            wasmparser::Name::Label(_)
+            | wasmparser::Name::Type(_)
+            | wasmparser::Name::Table(_)
+            | wasmparser::Name::Memory(_)
+            | wasmparser::Name::Global(_)
+            | wasmparser::Name::Element(_)
+            | wasmparser::Name::Data(_)
+            | wasmparser::Name::Tag(_)
+            | wasmparser::Name::Unknown { .. } => {}
+        };
+    }
+    Ok(())
+}
+
+// fn parse_function_name_subsection(
+//     mut naming_reader: NamingReader<'_>,
+// ) -> Option<HashMap<FunctionIndex, &str>> {
+//     let mut function_names = HashMap::new();
+//     for _ in 0..naming_reader.count() {
+//         let Naming { index, name } = naming_reader.read().ok()?;
+//         if index == std::u32::MAX {
+//             // We reserve `u32::MAX` for our own use.
+//             return None;
+//         }
+
+//         if function_names
+//             .insert(FunctionIndex::from_u32(index), name)
+//             .is_some()
+//         {
+//             // If the function index has been previously seen, then we
+//             // break out of the loop and early return `None`, because these
+//             // should be unique.
+//             return None;
+//         }
+//     }
+//     Some(function_names)
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/native_type.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/native_type.rs
new file mode 100644
index 0000000..5879ff3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/native_type.rs
@@ -0,0 +1,966 @@
+//! This module permits to create native functions
+//! easily in Rust, thanks to its advanced typing system.
+
+use wasmer_types::{NativeWasmType, RawValue, Type};
+
+use crate::store::AsStoreRef;
+use crate::vm::{VMExternRef, VMFuncRef};
+
+use crate::{ExternRef, Function, TypedFunction};
+use std::array::TryFromSliceError;
+use std::convert::Infallible;
+use std::convert::TryInto;
+use std::error::Error;
+
+use crate::store::AsStoreMut;
+
+/// `NativeWasmTypeInto` performs conversions from and into `NativeWasmType`
+/// types with a context.
+pub trait NativeWasmTypeInto: NativeWasmType + Sized {
+    #[doc(hidden)]
+    fn into_abi(self, store: &mut impl AsStoreMut) -> Self::Abi;
+
+    #[doc(hidden)]
+    unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self;
+
+    /// Convert self to raw value representation.
+    fn into_raw(self, store: &mut impl AsStoreMut) -> RawValue;
+
+    /// Convert to self from raw value representation.
+    ///
+    /// # Safety
+    ///
+    unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self;
+}
+
+impl NativeWasmTypeInto for i32 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { i32: self }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.i32
+    }
+}
+
+impl NativeWasmTypeInto for u32 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { i32: self as _ }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.i32 as _
+    }
+}
+
+impl NativeWasmTypeInto for i64 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { i64: self }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.i64
+    }
+}
+
+impl NativeWasmTypeInto for u64 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { i64: self as _ }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.i64 as _
+    }
+}
+
+impl NativeWasmTypeInto for f32 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { f32: self }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.f32
+    }
+}
+
+impl NativeWasmTypeInto for f64 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { f64: self }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.f64
+    }
+}
+
+impl NativeWasmTypeInto for u128 {
+    #[inline]
+    unsafe fn from_abi(_store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        abi
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        RawValue { u128: self }
+    }
+
+    #[inline]
+    unsafe fn from_raw(_store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        raw.u128
+    }
+}
+
+impl NativeWasmType for ExternRef {
+    const WASM_TYPE: Type = Type::ExternRef;
+    type Abi = usize;
+}
+
+impl NativeWasmTypeInto for Option<ExternRef> {
+    #[inline]
+    unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        VMExternRef::from_raw(RawValue { externref: abi })
+            .map(|e| ExternRef::from_vm_externref(store, e))
+    }
+
+    #[inline]
+    fn into_abi(self, _store: &mut impl AsStoreMut) -> Self::Abi {
+        self.map_or(0, |e| unsafe { e.vm_externref().into_raw().externref })
+    }
+
+    #[inline]
+    fn into_raw(self, _store: &mut impl AsStoreMut) -> RawValue {
+        self.map_or(RawValue { externref: 0 }, |e| e.vm_externref().into_raw())
+    }
+
+    #[inline]
+    unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e))
+    }
+}
+
+impl<Args, Rets> From<TypedFunction<Args, Rets>> for Function
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    fn from(other: TypedFunction<Args, Rets>) -> Self {
+        other.into_function()
+    }
+}
+
+impl NativeWasmType for Function {
+    const WASM_TYPE: Type = Type::FuncRef;
+    type Abi = usize;
+}
+
+impl NativeWasmTypeInto for Option<Function> {
+    #[inline]
+    unsafe fn from_abi(store: &mut impl AsStoreMut, abi: Self::Abi) -> Self {
+        VMFuncRef::from_raw(RawValue { funcref: abi }).map(|f| Function::from_vm_funcref(store, f))
+    }
+
+    #[inline]
+    fn into_abi(self, store: &mut impl AsStoreMut) -> Self::Abi {
+        self.map_or(0, |f| unsafe { f.vm_funcref(store).into_raw().externref })
+    }
+
+    #[inline]
+    fn into_raw(self, store: &mut impl AsStoreMut) -> RawValue {
+        self.map_or(RawValue { externref: 0 }, |e| {
+            e.vm_funcref(store).into_raw()
+        })
+    }
+
+    #[inline]
+    unsafe fn from_raw(store: &mut impl AsStoreMut, raw: RawValue) -> Self {
+        VMFuncRef::from_raw(raw).map(|f| Function::from_vm_funcref(store, f))
+    }
+}
+
+/// A trait to convert a Rust value to a `WasmNativeType` value,
+/// or to convert `WasmNativeType` value to a Rust value.
+///
+/// This trait should ideally be split into two traits:
+/// `FromNativeWasmType` and `ToNativeWasmType` but it creates a
+/// non-negligible complexity in the `WasmTypeList`
+/// implementation.
+///
+/// # Safety
+/// This trait is unsafe given the nature of how values are written and read from the native
+/// stack
+pub unsafe trait FromToNativeWasmType
+where
+    Self: Sized,
+{
+    /// Native Wasm type.
+    type Native: NativeWasmTypeInto;
+
+    /// Convert a value of kind `Self::Native` to `Self`.
+    ///
+    /// # Panics
+    ///
+    /// This method panics if `native` cannot fit in the `Self`
+    /// type`.
+    fn from_native(native: Self::Native) -> Self;
+
+    /// Convert self to `Self::Native`.
+    ///
+    /// # Panics
+    ///
+    /// This method panics if `self` cannot fit in the
+    /// `Self::Native` type.
+    fn to_native(self) -> Self::Native;
+
+    /// Returns whether the given value is from the given store.
+    ///
+    /// This always returns true for primitive types that can be used with
+    /// any context.
+    fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true
+    }
+}
+
+macro_rules! from_to_native_wasm_type {
+    ( $( $type:ty => $native_type:ty ),* ) => {
+        $(
+            #[allow(clippy::use_self)]
+            unsafe impl FromToNativeWasmType for $type {
+                type Native = $native_type;
+
+                #[inline]
+                fn from_native(native: Self::Native) -> Self {
+                    native as Self
+                }
+
+                #[inline]
+                fn to_native(self) -> Self::Native {
+                    self as Self::Native
+                }
+            }
+        )*
+    };
+}
+
+macro_rules! from_to_native_wasm_type_same_size {
+    ( $( $type:ty => $native_type:ty ),* ) => {
+        $(
+            #[allow(clippy::use_self)]
+            unsafe impl FromToNativeWasmType for $type {
+                type Native = $native_type;
+
+                #[inline]
+                fn from_native(native: Self::Native) -> Self {
+                    Self::from_ne_bytes(Self::Native::to_ne_bytes(native))
+                }
+
+                #[inline]
+                fn to_native(self) -> Self::Native {
+                    Self::Native::from_ne_bytes(Self::to_ne_bytes(self))
+                }
+            }
+        )*
+    };
+}
+
+from_to_native_wasm_type!(
+    i8 => i32,
+    u8 => i32,
+    i16 => i32,
+    u16 => i32
+);
+
+from_to_native_wasm_type_same_size!(
+    i32 => i32,
+    u32 => i32,
+    i64 => i64,
+    u64 => i64,
+    f32 => f32,
+    f64 => f64
+);
+
+unsafe impl FromToNativeWasmType for Option<ExternRef> {
+    type Native = Self;
+
+    fn to_native(self) -> Self::Native {
+        self
+    }
+    fn from_native(n: Self::Native) -> Self {
+        n
+    }
+    fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.as_ref().map_or(true, |e| e.is_from_store(store))
+    }
+}
+
+unsafe impl FromToNativeWasmType for Option<Function> {
+    type Native = Self;
+
+    fn to_native(self) -> Self::Native {
+        self
+    }
+    fn from_native(n: Self::Native) -> Self {
+        n
+    }
+    fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.as_ref().map_or(true, |f| f.is_from_store(store))
+    }
+}
+
+#[cfg(test)]
+mod test_from_to_native_wasm_type {
+    use super::*;
+
+    #[test]
+    fn test_to_native() {
+        assert_eq!(7i8.to_native(), 7i32);
+        assert_eq!(7u8.to_native(), 7i32);
+        assert_eq!(7i16.to_native(), 7i32);
+        assert_eq!(7u16.to_native(), 7i32);
+        assert_eq!(u32::MAX.to_native(), -1);
+    }
+
+    #[test]
+    fn test_to_native_same_size() {
+        assert_eq!(7i32.to_native(), 7i32);
+        assert_eq!(7u32.to_native(), 7i32);
+        assert_eq!(7i64.to_native(), 7i64);
+        assert_eq!(7u64.to_native(), 7i64);
+        assert_eq!(7f32.to_native(), 7f32);
+        assert_eq!(7f64.to_native(), 7f64);
+    }
+}
+
+/// The `WasmTypeList` trait represents a tuple (list) of Wasm
+/// typed values. It is used to get low-level representation of
+/// such a tuple.
+pub trait WasmTypeList
+where
+    Self: Sized,
+{
+    /// The C type (a struct) that can hold/represent all the
+    /// represented values.
+    type CStruct;
+
+    /// The array type that can hold all the represented values.
+    ///
+    /// Note that all values are stored in their binary form.
+    type Array: AsMut<[RawValue]>;
+
+    /// The size of the array
+    fn size() -> u32;
+
+    /// Constructs `Self` based on an array of values.
+    ///
+    /// # Safety
+    unsafe fn from_array(store: &mut impl AsStoreMut, array: Self::Array) -> Self;
+
+    /// Constructs `Self` based on a slice of values.
+    ///
+    /// `from_slice` returns a `Result` because it is possible
+    /// that the slice doesn't have the same size than
+    /// `Self::Array`, in which circumstance an error of kind
+    /// `TryFromSliceError` will be returned.
+    ///
+    /// # Safety
+    unsafe fn from_slice(
+        store: &mut impl AsStoreMut,
+        slice: &[RawValue],
+    ) -> Result<Self, TryFromSliceError>;
+
+    /// Builds and returns an array of type `Array` from a tuple
+    /// (list) of values.
+    ///
+    /// # Safety
+    unsafe fn into_array(self, store: &mut impl AsStoreMut) -> Self::Array;
+
+    /// Allocates and return an empty array of type `Array` that
+    /// will hold a tuple (list) of values, usually to hold the
+    /// returned values of a WebAssembly function call.
+    fn empty_array() -> Self::Array;
+
+    /// Builds a tuple (list) of values from a C struct of type
+    /// `CStruct`.
+    ///
+    /// # Safety
+    unsafe fn from_c_struct(store: &mut impl AsStoreMut, c_struct: Self::CStruct) -> Self;
+
+    /// Builds and returns a C struct of type `CStruct` from a
+    /// tuple (list) of values.
+    ///
+    /// # Safety
+    unsafe fn into_c_struct(self, store: &mut impl AsStoreMut) -> Self::CStruct;
+
+    /// Writes the contents of a C struct to an array of `RawValue`.
+    ///
+    /// # Safety
+    unsafe fn write_c_struct_to_ptr(c_struct: Self::CStruct, ptr: *mut RawValue);
+
+    /// Get the Wasm types for the tuple (list) of currently
+    /// represented values.
+    fn wasm_types() -> &'static [Type];
+}
+
+/// The `IntoResult` trait turns a `WasmTypeList` into a
+/// `Result<WasmTypeList, Self::Error>`.
+///
+/// It is mostly used to turn result values of a Wasm function
+/// call into a `Result`.
+pub trait IntoResult<T>
+where
+    T: WasmTypeList,
+{
+    /// The error type for this trait.
+    type Error: Error + Sync + Send + 'static;
+
+    /// Transforms `Self` into a `Result`.
+    fn into_result(self) -> Result<T, Self::Error>;
+}
+
+impl<T> IntoResult<T> for T
+where
+    T: WasmTypeList,
+{
+    // `T` is not a `Result`, it's already a value, so no error
+    // can be built.
+    type Error = Infallible;
+
+    fn into_result(self) -> Result<Self, Infallible> {
+        Ok(self)
+    }
+}
+
+impl<T, E> IntoResult<T> for Result<T, E>
+where
+    T: WasmTypeList,
+    E: Error + Sync + Send + 'static,
+{
+    type Error = E;
+
+    fn into_result(self) -> Self {
+        self
+    }
+}
+
+#[cfg(test)]
+mod test_into_result {
+    use super::*;
+    use std::convert::Infallible;
+
+    #[test]
+    fn test_into_result_over_t() {
+        let x: i32 = 42;
+        let result_of_x: Result<i32, Infallible> = x.into_result();
+
+        assert_eq!(result_of_x.unwrap(), x);
+    }
+
+    #[test]
+    fn test_into_result_over_result() {
+        {
+            let x: Result<i32, Infallible> = Ok(42);
+            let result_of_x: Result<i32, Infallible> = x.into_result();
+
+            assert_eq!(result_of_x, x);
+        }
+
+        {
+            use std::{error, fmt};
+
+            #[derive(Debug, PartialEq)]
+            struct E;
+
+            impl fmt::Display for E {
+                fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                    write!(formatter, "E")
+                }
+            }
+
+            impl error::Error for E {}
+
+            let x: Result<Infallible, E> = Err(E);
+            let result_of_x: Result<Infallible, E> = x.into_result();
+
+            assert_eq!(result_of_x.unwrap_err(), E);
+        }
+    }
+}
+
+// Implement `WasmTypeList` on `Infallible`, which means that
+// `Infallible` can be used as a returned type of a host function
+// to express that it doesn't return, or to express that it cannot
+// fail (with `Result<_, Infallible>`).
+impl WasmTypeList for Infallible {
+    type CStruct = Self;
+    type Array = [RawValue; 0];
+
+    fn size() -> u32 {
+        0
+    }
+
+    unsafe fn from_array(_: &mut impl AsStoreMut, _: Self::Array) -> Self {
+        unreachable!()
+    }
+
+    unsafe fn from_slice(
+        _: &mut impl AsStoreMut,
+        _: &[RawValue],
+    ) -> Result<Self, TryFromSliceError> {
+        unreachable!()
+    }
+
+    unsafe fn into_array(self, _: &mut impl AsStoreMut) -> Self::Array {
+        []
+    }
+
+    fn empty_array() -> Self::Array {
+        []
+    }
+
+    unsafe fn from_c_struct(_: &mut impl AsStoreMut, self_: Self::CStruct) -> Self {
+        self_
+    }
+
+    unsafe fn into_c_struct(self, _: &mut impl AsStoreMut) -> Self::CStruct {
+        self
+    }
+
+    unsafe fn write_c_struct_to_ptr(_: Self::CStruct, _: *mut RawValue) {}
+
+    fn wasm_types() -> &'static [Type] {
+        &[]
+    }
+}
+
+macro_rules! impl_wasmtypelist {
+    ( [$c_struct_representation:ident]
+       $c_struct_name:ident,
+       $( $x:ident ),* ) => {
+
+        /// A structure with a C-compatible representation that can hold a set of Wasm values.
+        /// This type is used by `WasmTypeList::CStruct`.
+        #[repr($c_struct_representation)]
+        pub struct $c_struct_name< $( $x ),* > ( $( <<$x as FromToNativeWasmType>::Native as NativeWasmType>::Abi ),* )
+        where
+            $( $x: FromToNativeWasmType ),*;
+
+        // Implement `WasmTypeList` for a specific tuple.
+        #[allow(unused_parens, dead_code)]
+        impl< $( $x ),* >
+            WasmTypeList
+        for
+            ( $( $x ),* )
+        where
+            $( $x: FromToNativeWasmType ),*
+        {
+            type CStruct = $c_struct_name< $( $x ),* >;
+
+            type Array = [RawValue; count_idents!( $( $x ),* )];
+
+            fn size() -> u32 {
+                count_idents!( $( $x ),* ) as _
+            }
+
+            #[allow(unused_mut)]
+            #[allow(clippy::unused_unit)]
+            #[allow(clippy::missing_safety_doc)]
+            unsafe fn from_array(mut _store: &mut impl AsStoreMut, array: Self::Array) -> Self {
+                // Unpack items of the array.
+                #[allow(non_snake_case)]
+                let [ $( $x ),* ] = array;
+
+                // Build the tuple.
+                (
+                    $(
+                        FromToNativeWasmType::from_native(NativeWasmTypeInto::from_raw(_store, $x))
+                    ),*
+                )
+            }
+
+            #[allow(clippy::missing_safety_doc)]
+            unsafe fn from_slice(store: &mut impl AsStoreMut, slice: &[RawValue]) -> Result<Self, TryFromSliceError> {
+                Ok(Self::from_array(store, slice.try_into()?))
+            }
+
+            #[allow(unused_mut)]
+            #[allow(clippy::missing_safety_doc)]
+            unsafe fn into_array(self, mut _store: &mut impl AsStoreMut) -> Self::Array {
+                // Unpack items of the tuple.
+                #[allow(non_snake_case)]
+                let ( $( $x ),* ) = self;
+
+                // Build the array.
+                [
+                    $(
+                        FromToNativeWasmType::to_native($x).into_raw(_store)
+                    ),*
+                ]
+            }
+
+            fn empty_array() -> Self::Array {
+                // Build an array initialized with `0`.
+                [RawValue { i32: 0 }; count_idents!( $( $x ),* )]
+            }
+
+            #[allow(unused_mut)]
+            #[allow(clippy::unused_unit)]
+            #[allow(clippy::missing_safety_doc)]
+            unsafe fn from_c_struct(mut _store: &mut impl AsStoreMut, c_struct: Self::CStruct) -> Self {
+                // Unpack items of the C structure.
+                #[allow(non_snake_case)]
+                let $c_struct_name( $( $x ),* ) = c_struct;
+
+                (
+                    $(
+                        FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(_store, $x))
+                    ),*
+                )
+            }
+
+            #[allow(unused_parens, non_snake_case, unused_mut)]
+            #[allow(clippy::missing_safety_doc)]
+            unsafe fn into_c_struct(self, mut _store: &mut impl AsStoreMut) -> Self::CStruct {
+                // Unpack items of the tuple.
+                let ( $( $x ),* ) = self;
+
+                // Build the C structure.
+                $c_struct_name(
+                    $(
+                        FromToNativeWasmType::to_native($x).into_abi(_store)
+                    ),*
+                )
+            }
+
+            #[allow(non_snake_case)]
+            unsafe fn write_c_struct_to_ptr(c_struct: Self::CStruct, _ptr: *mut RawValue) {
+                // Unpack items of the tuple.
+                let $c_struct_name( $( $x ),* ) = c_struct;
+
+                let mut _n = 0;
+                $(
+                    *_ptr.add(_n).cast() = $x;
+                    _n += 1;
+                )*
+            }
+
+            fn wasm_types() -> &'static [Type] {
+                &[
+                    $(
+                        $x::Native::WASM_TYPE
+                    ),*
+                ]
+            }
+        }
+
+    };
+}
+
+// Black-magic to count the number of identifiers at compile-time.
+macro_rules! count_idents {
+    ( $($idents:ident),* ) => {
+        {
+            #[allow(dead_code, non_camel_case_types)]
+            enum Idents { $( $idents, )* __CountIdentsLast }
+            const COUNT: usize = Idents::__CountIdentsLast as usize;
+            COUNT
+        }
+    };
+}
+
+// Here we go! Let's generate all the C struct and `WasmTypeList`
+// implementations.
+impl_wasmtypelist!([C] S0,);
+impl_wasmtypelist!([transparent] S1, A1);
+impl_wasmtypelist!([C] S2, A1, A2);
+impl_wasmtypelist!([C] S3, A1, A2, A3);
+impl_wasmtypelist!([C] S4, A1, A2, A3, A4);
+impl_wasmtypelist!([C] S5, A1, A2, A3, A4, A5);
+impl_wasmtypelist!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_wasmtypelist!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_wasmtypelist!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_wasmtypelist!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_wasmtypelist!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_wasmtypelist!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_wasmtypelist!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_wasmtypelist!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_wasmtypelist!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_wasmtypelist!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_wasmtypelist!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_wasmtypelist!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_wasmtypelist!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_wasmtypelist!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_wasmtypelist!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_wasmtypelist!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_wasmtypelist!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_wasmtypelist!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_wasmtypelist!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_wasmtypelist!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_wasmtypelist!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
+
+#[cfg(test)]
+mod test_wasm_type_list {
+    use super::*;
+    use wasmer_types::Type;
+    /*
+    #[test]
+    fn test_from_array() {
+        let mut store = Store::default();
+        let env = FunctionEnv::new(&mut store, ());
+        assert_eq!(<()>::from_array(&mut env, []), ());
+        assert_eq!(<i32>::from_array(&mut env, [RawValue{i32: 1}]), (1i32));
+        assert_eq!(<(i32, i64)>::from_array(&mut env, [RawValue{i32:1}, RawValue{i64:2}]), (1i32, 2i64));
+        assert_eq!(
+            <(i32, i64, f32, f64)>::from_array(&mut env, [
+                RawValue{i32:1},
+                RawValue{i64:2},
+                RawValue{f32: 3.1f32},
+                RawValue{f64: 4.2f64}
+            ]),
+            (1, 2, 3.1f32, 4.2f64)
+        );
+    }
+
+    #[test]
+    fn test_into_array() {
+        let mut store = Store::default();
+        let env = FunctionEnv::new(&mut store, ());
+        assert_eq!(().into_array(&mut store), [0i128; 0]);
+        assert_eq!((1i32).into_array(&mut store), [1i32]);
+        assert_eq!((1i32, 2i64).into_array(&mut store), [RawValue{i32: 1}, RawValue{i64: 2}]);
+        assert_eq!(
+            (1i32, 2i32, 3.1f32, 4.2f64).into_array(&mut store),
+            [RawValue{i32: 1}, RawValue{i32: 2}, RawValue{ f32: 3.1f32}, RawValue{f64: 4.2f64}]
+        );
+    }
+    */
+    #[test]
+    fn test_empty_array() {
+        assert_eq!(<()>::empty_array().len(), 0);
+        assert_eq!(<i32>::empty_array().len(), 1);
+        assert_eq!(<(i32, i64)>::empty_array().len(), 2);
+    }
+    /*
+    #[test]
+    fn test_from_c_struct() {
+        let mut store = Store::default();
+        let env = FunctionEnv::new(&mut store, ());
+        assert_eq!(<()>::from_c_struct(&mut store, S0()), ());
+        assert_eq!(<i32>::from_c_struct(&mut store, S1(1)), (1i32));
+        assert_eq!(<(i32, i64)>::from_c_struct(&mut store, S2(1, 2)), (1i32, 2i64));
+        assert_eq!(
+            <(i32, i64, f32, f64)>::from_c_struct(&mut store, S4(1, 2, 3.1, 4.2)),
+            (1i32, 2i64, 3.1f32, 4.2f64)
+        );
+    }
+    */
+    #[test]
+    fn test_wasm_types_for_uni_values() {
+        assert_eq!(<i32>::wasm_types(), [Type::I32]);
+        assert_eq!(<i64>::wasm_types(), [Type::I64]);
+        assert_eq!(<f32>::wasm_types(), [Type::F32]);
+        assert_eq!(<f64>::wasm_types(), [Type::F64]);
+    }
+
+    #[test]
+    fn test_wasm_types_for_multi_values() {
+        assert_eq!(<(i32, i32)>::wasm_types(), [Type::I32, Type::I32]);
+        assert_eq!(<(i64, i64)>::wasm_types(), [Type::I64, Type::I64]);
+        assert_eq!(<(f32, f32)>::wasm_types(), [Type::F32, Type::F32]);
+        assert_eq!(<(f64, f64)>::wasm_types(), [Type::F64, Type::F64]);
+
+        assert_eq!(
+            <(i32, i64, f32, f64)>::wasm_types(),
+            [Type::I32, Type::I64, Type::F32, Type::F64]
+        );
+    }
+}
+/*
+    #[allow(non_snake_case)]
+    #[cfg(test)]
+    mod test_function {
+        use super::*;
+        use crate::Store;
+        use crate::FunctionEnv;
+        use wasmer_types::Type;
+
+        fn func() {}
+        fn func__i32() -> i32 {
+            0
+        }
+        fn func_i32( _a: i32) {}
+        fn func_i32__i32( a: i32) -> i32 {
+            a * 2
+        }
+        fn func_i32_i32__i32( a: i32, b: i32) -> i32 {
+            a + b
+        }
+        fn func_i32_i32__i32_i32( a: i32, b: i32) -> (i32, i32) {
+            (a, b)
+        }
+        fn func_f32_i32__i32_f32( a: f32, b: i32) -> (i32, f32) {
+            (b, a)
+        }
+
+        #[test]
+        fn test_function_types() {
+            let mut store = Store::default();
+            let env = FunctionEnv::new(&mut store, ());
+            use wasmer_types::FunctionType;
+            assert_eq!(
+                StaticFunction::new(func).ty(&mut store),
+                FunctionType::new(vec![], vec![])
+            );
+            assert_eq!(
+                StaticFunction::new(func__i32).ty(&mut store),
+                FunctionType::new(vec![], vec![Type::I32])
+            );
+            assert_eq!(
+                StaticFunction::new(func_i32).ty(),
+                FunctionType::new(vec![Type::I32], vec![])
+            );
+            assert_eq!(
+                StaticFunction::new(func_i32__i32).ty(),
+                FunctionType::new(vec![Type::I32], vec![Type::I32])
+            );
+            assert_eq!(
+                StaticFunction::new(func_i32_i32__i32).ty(),
+                FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32])
+            );
+            assert_eq!(
+                StaticFunction::new(func_i32_i32__i32_i32).ty(),
+                FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32, Type::I32])
+            );
+            assert_eq!(
+                StaticFunction::new(func_f32_i32__i32_f32).ty(),
+                FunctionType::new(vec![Type::F32, Type::I32], vec![Type::I32, Type::F32])
+            );
+        }
+
+        #[test]
+        fn test_function_pointer() {
+            let f = StaticFunction::new(func_i32__i32);
+            let function = unsafe { std::mem::transmute::<_, fn(usize, i32) -> i32>(f.address) };
+            assert_eq!(function(0, 3), 6);
+        }
+    }
+*/
+
+#[cfg(test)]
+mod test_native_type {
+    use super::*;
+    use wasmer_types::Type;
+
+    #[test]
+    fn test_wasm_types() {
+        assert_eq!(i32::WASM_TYPE, Type::I32);
+        assert_eq!(i64::WASM_TYPE, Type::I64);
+        assert_eq!(f32::WASM_TYPE, Type::F32);
+        assert_eq!(f64::WASM_TYPE, Type::F64);
+        assert_eq!(u128::WASM_TYPE, Type::V128);
+    }
+    /*
+    #[test]
+    fn test_roundtrip() {
+        unsafe {
+            assert_eq!(i32::from_raw(42i32.into_raw()), 42i32);
+            assert_eq!(i64::from_raw(42i64.into_raw()), 42i64);
+            assert_eq!(f32::from_raw(42f32.into_raw()), 42f32);
+            assert_eq!(f64::from_raw(42f64.into_raw()), 42f64);
+            assert_eq!(u128::from_raw(42u128.into_raw()), 42u128);
+        }
+    }
+    */
+}
+
+// pub trait IntegerAtomic
+// where
+//     Self: Sized
+// {
+//     type Primitive;
+
+//     fn add(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn sub(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn and(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn or(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn xor(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn load(&self) -> Self::Primitive;
+//     fn store(&self, other: Self::Primitive) -> Self::Primitive;
+//     fn compare_exchange(&self, expected: Self::Primitive, new: Self::Primitive) -> Self::Primitive;
+//     fn swap(&self, other: Self::Primitive) -> Self::Primitive;
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/ptr.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/ptr.rs
new file mode 100644
index 0000000..b1443a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/ptr.rs
@@ -0,0 +1,280 @@
+use crate::access::WasmRefAccess;
+use crate::mem_access::{MemoryAccessError, WasmRef, WasmSlice};
+use crate::{AsStoreRef, FromToNativeWasmType, MemoryView, NativeWasmTypeInto};
+use std::convert::TryFrom;
+use std::{fmt, marker::PhantomData, mem};
+pub use wasmer_types::Memory32;
+pub use wasmer_types::Memory64;
+pub use wasmer_types::MemorySize;
+use wasmer_types::ValueType;
+
+/// Alias for `WasmPtr<T, Memory64>.
+pub type WasmPtr64<T> = WasmPtr<T, Memory64>;
+
+/// A zero-cost type that represents a pointer to something in Wasm linear
+/// memory.
+///
+/// This type can be used directly in the host function arguments:
+/// ```
+/// # use wasmer::Memory;
+/// # use wasmer::WasmPtr;
+/// # use wasmer::FunctionEnvMut;
+/// pub fn host_import(mut env: FunctionEnvMut<()>, memory: Memory, ptr: WasmPtr<u32>) {
+///     let memory = memory.view(&env);
+///     let derefed_ptr = ptr.deref(&memory);
+///     let inner_val: u32 = derefed_ptr.read().expect("pointer in bounds");
+///     println!("Got {} from Wasm memory address 0x{:X}", inner_val, ptr.offset());
+///     // update the value being pointed to
+///     derefed_ptr.write(inner_val + 1).expect("pointer in bounds");
+/// }
+/// ```
+///
+/// This type can also be used with primitive-filled structs, but be careful of
+/// guarantees required by `ValueType`.
+/// ```
+/// # use wasmer::Memory;
+/// # use wasmer::WasmPtr;
+/// # use wasmer::ValueType;
+/// # use wasmer::FunctionEnvMut;
+///
+/// // This is safe as the 12 bytes represented by this struct
+/// // are valid for all bit combinations.
+/// #[derive(Copy, Clone, Debug, ValueType)]
+/// #[repr(C)]
+/// struct V3 {
+///     x: f32,
+///     y: f32,
+///     z: f32
+/// }
+///
+/// fn update_vector_3(mut env: FunctionEnvMut<()>, memory: Memory, ptr: WasmPtr<V3>) {
+///     let memory = memory.view(&env);
+///     let derefed_ptr = ptr.deref(&memory);
+///     let mut inner_val: V3 = derefed_ptr.read().expect("pointer in bounds");
+///     println!("Got {:?} from Wasm memory address 0x{:X}", inner_val, ptr.offset());
+///     // update the value being pointed to
+///     inner_val.x = 10.4;
+///     derefed_ptr.write(inner_val).expect("pointer in bounds");
+/// }
+/// ```
+#[repr(transparent)]
+pub struct WasmPtr<T, M: MemorySize = Memory32> {
+    offset: M::Offset,
+    _phantom: PhantomData<T>,
+}
+
+impl<T, M: MemorySize> WasmPtr<T, M> {
+    /// Create a new `WasmPtr` at the given offset.
+    #[inline]
+    pub fn new(offset: M::Offset) -> Self {
+        Self {
+            offset,
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Get the offset into Wasm linear memory for this `WasmPtr`.
+    #[inline]
+    pub fn offset(&self) -> M::Offset {
+        self.offset
+    }
+
+    /// Casts this `WasmPtr` to a `WasmPtr` of a different type.
+    #[inline]
+    pub fn cast<U>(self) -> WasmPtr<U, M> {
+        WasmPtr {
+            offset: self.offset,
+            _phantom: PhantomData,
+        }
+    }
+
+    /// Returns a null `UserPtr`.
+    #[inline]
+    pub fn null() -> Self {
+        Self::new(M::ZERO)
+    }
+
+    /// Checks whether the `WasmPtr` is null.
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        self.offset.into() == 0
+    }
+
+    /// Calculates an offset from the current pointer address. The argument is
+    /// in units of `T`.
+    ///
+    /// This method returns an error if an address overflow occurs.
+    #[inline]
+    pub fn add_offset(self, offset: M::Offset) -> Result<Self, MemoryAccessError> {
+        let base = self.offset.into();
+        let index = offset.into();
+        let offset = index
+            .checked_mul(mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let address = base
+            .checked_add(offset)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let address = M::Offset::try_from(address).map_err(|_| MemoryAccessError::Overflow)?;
+        Ok(Self::new(address))
+    }
+
+    /// Calculates an offset from the current pointer address. The argument is
+    /// in units of `T`.
+    ///
+    /// This method returns an error if an address underflow occurs.
+    #[inline]
+    pub fn sub_offset(self, offset: M::Offset) -> Result<Self, MemoryAccessError> {
+        let base = self.offset.into();
+        let index = offset.into();
+        let offset = index
+            .checked_mul(mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let address = base
+            .checked_sub(offset)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let address = M::Offset::try_from(address).map_err(|_| MemoryAccessError::Overflow)?;
+        Ok(Self::new(address))
+    }
+}
+
+impl<T: ValueType, M: MemorySize> WasmPtr<T, M> {
+    /// Creates a `WasmRef` from this `WasmPtr` which allows reading and
+    /// mutating of the value being pointed to.
+    #[inline]
+    pub fn deref<'a>(&self, view: &'a MemoryView) -> WasmRef<'a, T> {
+        WasmRef::new(view, self.offset.into())
+    }
+
+    /// Reads the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn read(&self, view: &MemoryView) -> Result<T, MemoryAccessError> {
+        self.deref(view).read()
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn write(&self, view: &MemoryView, val: T) -> Result<(), MemoryAccessError> {
+        self.deref(view).write(val)
+    }
+
+    /// Creates a `WasmSlice` starting at this `WasmPtr` which allows reading
+    /// and mutating of an array of value being pointed to.
+    ///
+    /// Returns a `MemoryAccessError` if the slice length overflows a 64-bit
+    /// address.
+    #[inline]
+    pub fn slice<'a>(
+        &self,
+        view: &'a MemoryView,
+        len: M::Offset,
+    ) -> Result<WasmSlice<'a, T>, MemoryAccessError> {
+        WasmSlice::new(view, self.offset.into(), len.into())
+    }
+
+    /// Reads a sequence of values from this `WasmPtr` until a value that
+    /// matches the given condition is found.
+    ///
+    /// This last value is not included in the returned vector.
+    #[inline]
+    pub fn read_until(
+        &self,
+        view: &MemoryView,
+        mut end: impl FnMut(&T) -> bool,
+    ) -> Result<Vec<T>, MemoryAccessError> {
+        let mut vec = Vec::new();
+        for i in 0u64.. {
+            let i = M::Offset::try_from(i).map_err(|_| MemoryAccessError::Overflow)?;
+            let val = self.add_offset(i)?.deref(view).read()?;
+            if end(&val) {
+                break;
+            }
+            vec.push(val);
+        }
+        Ok(vec)
+    }
+
+    /// Creates a `WasmAccess`
+    #[inline]
+    pub fn access<'a>(
+        &self,
+        view: &'a MemoryView,
+    ) -> Result<WasmRefAccess<'a, T>, MemoryAccessError> {
+        self.deref(view).access()
+    }
+}
+
+impl<M: MemorySize> WasmPtr<u8, M> {
+    /// Reads a UTF-8 string from the `WasmPtr` with the given length.
+    ///
+    /// This method is safe to call even if the memory is being concurrently
+    /// modified.
+    #[inline]
+    pub fn read_utf8_string(
+        &self,
+        view: &MemoryView,
+        len: M::Offset,
+    ) -> Result<String, MemoryAccessError> {
+        let vec = self.slice(view, len)?.read_to_vec()?;
+        Ok(String::from_utf8(vec)?)
+    }
+
+    /// Reads a null-terminated UTF-8 string from the `WasmPtr`.
+    ///
+    /// This method is safe to call even if the memory is being concurrently
+    /// modified.
+    #[inline]
+    pub fn read_utf8_string_with_nul(
+        &self,
+        view: &MemoryView,
+    ) -> Result<String, MemoryAccessError> {
+        let vec = self.read_until(view, |&byte| byte == 0)?;
+        Ok(String::from_utf8(vec)?)
+    }
+}
+
+unsafe impl<T: ValueType, M: MemorySize> FromToNativeWasmType for WasmPtr<T, M>
+where
+    <M as wasmer_types::MemorySize>::Native: NativeWasmTypeInto,
+{
+    type Native = M::Native;
+
+    fn to_native(self) -> Self::Native {
+        M::offset_to_native(self.offset)
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self {
+            offset: M::native_to_offset(n),
+            _phantom: PhantomData,
+        }
+    }
+    #[inline]
+    fn is_from_store(&self, _store: &impl AsStoreRef) -> bool {
+        true // in Javascript there are no different stores
+    }
+}
+
+unsafe impl<T: ValueType, M: MemorySize> ValueType for WasmPtr<T, M> {
+    fn zero_padding_bytes(&self, _bytes: &mut [mem::MaybeUninit<u8>]) {}
+}
+
+impl<T: ValueType, M: MemorySize> Clone for WasmPtr<T, M> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: ValueType, M: MemorySize> Copy for WasmPtr<T, M> {}
+
+impl<T: ValueType, M: MemorySize> PartialEq for WasmPtr<T, M> {
+    fn eq(&self, other: &Self) -> bool {
+        self.offset.into() == other.offset.into()
+    }
+}
+
+impl<T: ValueType, M: MemorySize> Eq for WasmPtr<T, M> {}
+
+impl<T: ValueType, M: MemorySize> fmt::Debug for WasmPtr<T, M> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}(@{})", std::any::type_name::<T>(), self.offset.into())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/store.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/store.rs
new file mode 100644
index 0000000..3dea7e6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/store.rs
@@ -0,0 +1,291 @@
+use crate::engine::{AsEngineRef, Engine, EngineRef};
+use derivative::Derivative;
+use std::{
+    fmt,
+    ops::{Deref, DerefMut},
+};
+#[cfg(feature = "sys")]
+pub use wasmer_compiler::Tunables;
+pub use wasmer_types::{OnCalledAction, StoreId};
+#[cfg(feature = "sys")]
+use wasmer_vm::init_traps;
+#[cfg(feature = "sys")]
+pub use wasmer_vm::TrapHandlerFn;
+
+#[cfg(feature = "sys")]
+pub use wasmer_vm::{StoreHandle, StoreObjects};
+
+#[cfg(feature = "js")]
+pub use crate::js::store::{StoreHandle, StoreObjects};
+
+#[cfg(feature = "jsc")]
+pub use crate::jsc::store::{StoreHandle, StoreObjects};
+
+/// Call handler for a store.
+// TODO: better documentation!
+pub type OnCalledHandler = Box<
+    dyn FnOnce(StoreMut<'_>) -> Result<OnCalledAction, Box<dyn std::error::Error + Send + Sync>>,
+>;
+
+/// We require the context to have a fixed memory address for its lifetime since
+/// various bits of the VM have raw pointers that point back to it. Hence we
+/// wrap the actual context in a box.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub(crate) struct StoreInner {
+    pub(crate) objects: StoreObjects,
+    #[derivative(Debug = "ignore")]
+    pub(crate) engine: Engine,
+    #[cfg(feature = "sys")]
+    #[derivative(Debug = "ignore")]
+    pub(crate) trap_handler: Option<Box<TrapHandlerFn<'static>>>,
+    #[derivative(Debug = "ignore")]
+    pub(crate) on_called: Option<OnCalledHandler>,
+}
+
+/// The store represents all global state that can be manipulated by
+/// WebAssembly programs. It consists of the runtime representation
+/// of all instances of functions, tables, memories, and globals that
+/// have been allocated during the lifetime of the abstract machine.
+///
+/// The `Store` holds the engine (that is —amongst many things— used to compile
+/// the Wasm bytes into a valid module artifact).
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#store>
+pub struct Store {
+    pub(crate) inner: Box<StoreInner>,
+}
+
+impl Store {
+    /// Creates a new `Store` with a specific [`Engine`].
+    pub fn new(engine: impl Into<Engine>) -> Self {
+        // Make sure the signal handlers are installed.
+        // This is required for handling traps.
+        #[cfg(feature = "sys")]
+        init_traps();
+
+        Self {
+            inner: Box::new(StoreInner {
+                objects: Default::default(),
+                engine: engine.into(),
+                #[cfg(feature = "sys")]
+                trap_handler: None,
+                on_called: None,
+            }),
+        }
+    }
+
+    #[cfg(feature = "sys")]
+    /// Set the trap handler in this store.
+    pub fn set_trap_handler(&mut self, handler: Option<Box<TrapHandlerFn<'static>>>) {
+        self.inner.trap_handler = handler;
+    }
+
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        &self.inner.engine
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        a.id() == b.id()
+    }
+
+    /// Returns the ID of this store
+    pub fn id(&self) -> StoreId {
+        self.inner.objects.id()
+    }
+}
+
+impl PartialEq for Store {
+    fn eq(&self, other: &Self) -> bool {
+        Self::same(self, other)
+    }
+}
+
+// This is required to be able to set the trap_handler in the
+// Store.
+unsafe impl Send for Store {}
+unsafe impl Sync for Store {}
+
+impl Default for Store {
+    fn default() -> Self {
+        Self::new(Engine::default())
+    }
+}
+
+impl AsStoreRef for Store {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: &self.inner }
+    }
+}
+impl AsStoreMut for Store {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut {
+            inner: &mut self.inner,
+        }
+    }
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.inner.objects
+    }
+}
+
+impl AsEngineRef for Store {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.inner.engine)
+    }
+}
+
+impl AsEngineRef for StoreRef<'_> {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.inner.engine)
+    }
+}
+
+impl AsEngineRef for StoreMut<'_> {
+    fn as_engine_ref(&self) -> EngineRef<'_> {
+        EngineRef::new(&self.inner.engine)
+    }
+}
+
+impl fmt::Debug for Store {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Store").finish()
+    }
+}
+
+/// A temporary handle to a [`Store`].
+#[derive(Debug)]
+pub struct StoreRef<'a> {
+    pub(crate) inner: &'a StoreInner,
+}
+
+impl<'a> StoreRef<'a> {
+    pub(crate) fn objects(&self) -> &'a StoreObjects {
+        &self.inner.objects
+    }
+
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        &self.inner.engine
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        a.inner.objects.id() == b.inner.objects.id()
+    }
+
+    /// The signal handler
+    #[cfg(feature = "sys")]
+    #[inline]
+    pub fn signal_handler(&self) -> Option<*const TrapHandlerFn<'static>> {
+        self.inner
+            .trap_handler
+            .as_ref()
+            .map(|handler| handler.as_ref() as *const _)
+    }
+}
+
+/// A temporary handle to a [`Store`].
+pub struct StoreMut<'a> {
+    pub(crate) inner: &'a mut StoreInner,
+}
+
+impl<'a> StoreMut<'a> {
+    /// Returns the [`Engine`].
+    pub fn engine(&self) -> &Engine {
+        &self.inner.engine
+    }
+
+    /// Checks whether two stores are identical. A store is considered
+    /// equal to another store if both have the same engine.
+    pub fn same(a: &Self, b: &Self) -> bool {
+        a.inner.objects.id() == b.inner.objects.id()
+    }
+
+    #[allow(unused)]
+    pub(crate) fn engine_and_objects_mut(&mut self) -> (&Engine, &mut StoreObjects) {
+        (&self.inner.engine, &mut self.inner.objects)
+    }
+
+    pub(crate) fn as_raw(&self) -> *mut StoreInner {
+        self.inner as *const StoreInner as *mut StoreInner
+    }
+
+    pub(crate) unsafe fn from_raw(raw: *mut StoreInner) -> Self {
+        Self { inner: &mut *raw }
+    }
+
+    // TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+    /// Sets the unwind callback which will be invoked when the call finishes
+    pub fn on_called<F>(&mut self, callback: F)
+    where
+        F: FnOnce(StoreMut<'_>) -> Result<OnCalledAction, Box<dyn std::error::Error + Send + Sync>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        self.inner.on_called.replace(Box::new(callback));
+    }
+}
+
+/// Helper trait for a value that is convertible to a [`StoreRef`].
+pub trait AsStoreRef {
+    /// Returns a `StoreRef` pointing to the underlying context.
+    fn as_store_ref(&self) -> StoreRef<'_>;
+}
+
+/// Helper trait for a value that is convertible to a [`StoreMut`].
+pub trait AsStoreMut: AsStoreRef {
+    /// Returns a `StoreMut` pointing to the underlying context.
+    fn as_store_mut(&mut self) -> StoreMut<'_>;
+
+    /// Returns the ObjectMutable
+    fn objects_mut(&mut self) -> &mut StoreObjects;
+}
+
+impl AsStoreRef for StoreRef<'_> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: self.inner }
+    }
+}
+
+impl AsStoreRef for StoreMut<'_> {
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        StoreRef { inner: self.inner }
+    }
+}
+impl AsStoreMut for StoreMut<'_> {
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        StoreMut { inner: self.inner }
+    }
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        &mut self.inner.objects
+    }
+}
+
+impl<P> AsStoreRef for P
+where
+    P: Deref,
+    P::Target: AsStoreRef,
+{
+    fn as_store_ref(&self) -> StoreRef<'_> {
+        (**self).as_store_ref()
+    }
+}
+
+impl<P> AsStoreMut for P
+where
+    P: DerefMut,
+    P::Target: AsStoreMut,
+{
+    fn as_store_mut(&mut self) -> StoreMut<'_> {
+        (**self).as_store_mut()
+    }
+
+    fn objects_mut(&mut self) -> &mut StoreObjects {
+        (**self).objects_mut()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/engine.rs
new file mode 100644
index 0000000..1bf6a23
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/engine.rs
@@ -0,0 +1,152 @@
+use std::{path::Path, sync::Arc};
+
+use shared_buffer::OwnedBuffer;
+pub use wasmer_compiler::{
+    Artifact, BaseTunables, CompilerConfig, Engine, EngineBuilder, Tunables,
+};
+#[cfg(feature = "compiler")]
+use wasmer_types::Features;
+use wasmer_types::{DeserializeError, Target};
+
+/// Get the default config for the sys Engine
+#[allow(unreachable_code)]
+pub fn get_default_compiler_config() -> Option<Box<dyn wasmer_compiler::CompilerConfig>> {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "cranelift")] {
+            Some(Box::<wasmer_compiler_cranelift::Cranelift>::default())
+        } else if #[cfg(feature = "llvm")] {
+            Some(Box::<wasmer_compiler_llvm::LLVM>::default())
+        } else if #[cfg(feature = "singlepass")] {
+            Some(Box::<wasmer_compiler_singlepass::Singlepass>::default())
+        }
+        else {
+            None
+        }
+    }
+}
+
+/// Returns the default engine for the Sys engine
+pub(crate) fn default_engine() -> Engine {
+    #[allow(unreachable_code, unused_mut)]
+    fn get_engine() -> Engine {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "compiler")] {
+                if let Some(config) = get_default_compiler_config() {
+                    EngineBuilder::new(config)
+                        .engine()
+                } else {
+                    EngineBuilder::headless()
+                        .engine()
+                }
+            } else {
+                EngineBuilder::headless().engine()
+            }
+        }
+    }
+
+    let mut engine = get_engine();
+    let tunables = BaseTunables::for_target(engine.target());
+    engine.set_tunables(tunables);
+    engine
+}
+
+/// The custom trait to access to all the `sys` function in the common
+/// engine.
+pub trait NativeEngineExt {
+    /// Create a new `Engine` with the given config
+    #[cfg(feature = "compiler")]
+    fn new(compiler_config: Box<dyn CompilerConfig>, target: Target, features: Features) -> Self;
+
+    /// Create a headless `Engine`
+    ///
+    /// A headless engine is an engine without any compiler attached.
+    /// This is useful for assuring a minimal runtime for running
+    /// WebAssembly modules.
+    ///
+    /// For example, for running in IoT devices where compilers are very
+    /// expensive, or also to optimize startup speed.
+    ///
+    /// # Important
+    ///
+    /// Headless engines can't compile or validate any modules,
+    /// they just take already processed Modules (via `Module::serialize`).
+    fn headless() -> Self;
+
+    /// Gets the target
+    fn target(&self) -> &Target;
+
+    /// Attach a Tunable to this engine
+    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static);
+
+    /// Get a reference to attached Tunable of this engine
+    fn tunables(&self) -> &dyn Tunables;
+
+    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
+    ///
+    /// NOTE: you should almost always prefer [`Self::deserialize_from_mmapped_file`].
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize_unchecked`].
+    unsafe fn deserialize_from_mmapped_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError>;
+
+    /// Load a serialized WebAssembly module from a memory mapped file and deserialize it.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    unsafe fn deserialize_from_mmapped_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError>;
+}
+
+impl NativeEngineExt for crate::engine::Engine {
+    #[cfg(feature = "compiler")]
+    fn new(compiler_config: Box<dyn CompilerConfig>, target: Target, features: Features) -> Self {
+        Self(Engine::new(compiler_config, target, features))
+    }
+
+    fn headless() -> Self {
+        Self(Engine::headless())
+    }
+
+    fn target(&self) -> &Target {
+        self.0.target()
+    }
+
+    fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static) {
+        self.0.set_tunables(tunables)
+    }
+
+    fn tunables(&self) -> &dyn Tunables {
+        self.0.tunables()
+    }
+
+    unsafe fn deserialize_from_mmapped_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError> {
+        let bytes = std::fs::read(file_ref)?;
+        let artifact = Arc::new(Artifact::deserialize_unchecked(&self.0, bytes.into())?);
+        Ok(crate::Module(super::module::Module::from_artifact(
+            artifact,
+        )))
+    }
+
+    unsafe fn deserialize_from_mmapped_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<crate::Module, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        let artifact = Arc::new(Artifact::deserialize(
+            &self.0,
+            OwnedBuffer::from_file(&file)
+                .map_err(|e| DeserializeError::Generic(format!("{e:?}")))?,
+        )?);
+        Ok(crate::Module(super::module::Module::from_artifact(
+            artifact,
+        )))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/errors.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/errors.rs
new file mode 100644
index 0000000..b5943be
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/errors.rs
@@ -0,0 +1,24 @@
+use crate::{LinkError, RuntimeError};
+use wasmer_vm::Trap;
+
+impl From<wasmer_compiler::LinkError> for LinkError {
+    fn from(other: wasmer_compiler::LinkError) -> Self {
+        match other {
+            wasmer_compiler::LinkError::Import(namespace, name, error) => {
+                Self::Import(namespace, name, error)
+            }
+            wasmer_compiler::LinkError::Trap(e) => Self::Trap(e.into()),
+            wasmer_compiler::LinkError::Resource(e) => Self::Resource(e),
+        }
+    }
+}
+
+impl From<Trap> for RuntimeError {
+    fn from(trap: Trap) -> Self {
+        if trap.is::<Self>() {
+            return trap.downcast::<Self>().unwrap();
+        }
+        let (wasm_trace, trap_code) = wasmer_compiler::get_trace_and_trapcode(&trap);
+        Self::new_from_source(trap, wasm_trace, trap_code)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/extern_ref.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/extern_ref.rs
new file mode 100644
index 0000000..2f50751
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/extern_ref.rs
@@ -0,0 +1,49 @@
+use std::any::Any;
+use wasmer_vm::VMExternRef;
+use wasmer_vm::{StoreHandle, VMExternObj};
+
+use crate::store::{AsStoreMut, AsStoreRef};
+
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct ExternRef {
+    handle: StoreHandle<VMExternObj>,
+}
+
+impl ExternRef {
+    pub fn new<T>(store: &mut impl AsStoreMut, value: T) -> Self
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        Self {
+            handle: StoreHandle::new(store.objects_mut(), VMExternObj::new(value)),
+        }
+    }
+
+    pub fn downcast<'a, T>(&self, store: &'a impl AsStoreRef) -> Option<&'a T>
+    where
+        T: Any + Send + Sync + 'static + Sized,
+    {
+        self.handle
+            .get(store.as_store_ref().objects())
+            .as_ref()
+            .downcast_ref::<T>()
+    }
+
+    pub(crate) fn vm_externref(&self) -> VMExternRef {
+        VMExternRef(self.handle.internal_handle())
+    }
+
+    pub(crate) unsafe fn from_vm_externref(
+        store: &mut impl AsStoreMut,
+        vm_externref: VMExternRef,
+    ) -> Self {
+        Self {
+            handle: StoreHandle::from_internal(store.objects_mut().id(), vm_externref.0),
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/function.rs
new file mode 100644
index 0000000..41c292f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/function.rs
@@ -0,0 +1,661 @@
+use crate::externals::function::{HostFunction, WithEnv, WithoutEnv};
+use crate::native_type::{FromToNativeWasmType, IntoResult, NativeWasmTypeInto, WasmTypeList};
+use crate::store::{AsStoreMut, AsStoreRef, StoreInner, StoreMut};
+use crate::sys::engine::NativeEngineExt;
+use crate::vm::{VMExternFunction, VMFunctionCallback};
+use crate::{FunctionEnv, FunctionEnvMut, FunctionType, RuntimeError, Value};
+use std::panic::{self, AssertUnwindSafe};
+use std::{cell::UnsafeCell, cmp::max, ffi::c_void};
+use wasmer_types::{NativeWasmType, RawValue};
+use wasmer_vm::{
+    on_host_stack, raise_user_trap, resume_panic, wasmer_call_trampoline, MaybeInstanceOwned,
+    StoreHandle, VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMExtern, VMFuncRef,
+    VMFunction, VMFunctionContext, VMFunctionKind, VMTrampoline,
+};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Function {
+    pub(crate) handle: StoreHandle<VMFunction>,
+}
+
+impl From<StoreHandle<VMFunction>> for Function {
+    fn from(handle: StoreHandle<VMFunction>) -> Self {
+        Self { handle }
+    }
+}
+
+impl Function {
+    pub fn new_with_env<FT, F, T: Send + 'static>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        ty: FT,
+        func: F,
+    ) -> Self
+    where
+        FT: Into<FunctionType>,
+        F: Fn(FunctionEnvMut<T>, &[Value]) -> Result<Vec<Value>, RuntimeError>
+            + 'static
+            + Send
+            + Sync,
+    {
+        let function_type = ty.into();
+        let func_ty = function_type.clone();
+        let func_env = env.clone();
+        let raw_store = store.as_store_mut().as_raw() as *mut u8;
+        let wrapper = move |values_vec: *mut RawValue| -> Result<(), RuntimeError> {
+            unsafe {
+                let mut store = StoreMut::from_raw(raw_store as *mut StoreInner);
+                let mut args = Vec::with_capacity(func_ty.params().len());
+                for (i, ty) in func_ty.params().iter().enumerate() {
+                    args.push(Value::from_raw(&mut store, *ty, *values_vec.add(i)));
+                }
+                let store_mut = StoreMut::from_raw(raw_store as *mut StoreInner);
+                let env = FunctionEnvMut {
+                    store_mut,
+                    func_env: func_env.clone(),
+                };
+                let returns = func(env, &args)?;
+
+                // We need to dynamically check that the returns
+                // match the expected types, as well as expected length.
+                let return_types = returns.iter().map(|ret| ret.ty());
+                if return_types.ne(func_ty.results().iter().copied()) {
+                    return Err(RuntimeError::new(format!(
+                        "Dynamic function returned wrong signature. Expected {:?} but got {:?}",
+                        func_ty.results(),
+                        returns.iter().map(|ret| ret.ty())
+                    )));
+                }
+                for (i, ret) in returns.iter().enumerate() {
+                    *values_vec.add(i) = ret.as_raw(&store);
+                }
+            }
+            Ok(())
+        };
+        let mut host_data = Box::new(VMDynamicFunctionContext {
+            address: std::ptr::null(),
+            ctx: DynamicFunction { func: wrapper },
+        });
+        host_data.address = host_data.ctx.func_body_ptr();
+
+        // We don't yet have the address with the Wasm ABI signature.
+        // The engine linker will replace the address with one pointing to a
+        // generated dynamic trampoline.
+        let func_ptr = std::ptr::null() as VMFunctionCallback;
+        let type_index = store
+            .as_store_mut()
+            .engine()
+            .0
+            .register_signature(&function_type);
+        let vmctx = VMFunctionContext {
+            host_env: host_data.as_ref() as *const _ as *mut c_void,
+        };
+        let call_trampoline = host_data.ctx.call_trampoline_address();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Dynamic,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+        }
+    }
+
+    /// Creates a new host `Function` from a native function.
+    pub fn new_typed<F, Args, Rets>(store: &mut impl AsStoreMut, func: F) -> Self
+    where
+        F: HostFunction<(), Args, Rets, WithoutEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let env = FunctionEnv::new(store, ());
+        let func_ptr = func.function_callback();
+        let host_data = Box::new(StaticFunction {
+            raw_store: store.as_store_mut().as_raw() as *mut u8,
+            env,
+            func,
+        });
+        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+
+        let type_index = store
+            .as_store_mut()
+            .engine()
+            .0
+            .register_signature(&function_type);
+        let vmctx = VMFunctionContext {
+            host_env: host_data.as_ref() as *const _ as *mut c_void,
+        };
+        let call_trampoline =
+            <F as HostFunction<(), Args, Rets, WithoutEnv>>::call_trampoline_address();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Static,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+        }
+    }
+
+    pub fn new_typed_with_env<T: Send + 'static, F, Args, Rets>(
+        store: &mut impl AsStoreMut,
+        env: &FunctionEnv<T>,
+        func: F,
+    ) -> Self
+    where
+        F: HostFunction<T, Args, Rets, WithEnv> + 'static + Send + Sync,
+        Args: WasmTypeList,
+        Rets: WasmTypeList,
+    {
+        let func_ptr = func.function_callback();
+        let host_data = Box::new(StaticFunction {
+            raw_store: store.as_store_mut().as_raw() as *mut u8,
+            env: env.clone(),
+            func,
+        });
+        let function_type = FunctionType::new(Args::wasm_types(), Rets::wasm_types());
+
+        let type_index = store
+            .as_store_mut()
+            .engine()
+            .0
+            .register_signature(&function_type);
+        let vmctx = VMFunctionContext {
+            host_env: host_data.as_ref() as *const _ as *mut c_void,
+        };
+        let call_trampoline =
+            <F as HostFunction<T, Args, Rets, WithEnv>>::call_trampoline_address();
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr,
+            type_index,
+            vmctx,
+            call_trampoline,
+        };
+
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(anyfunc))),
+            kind: VMFunctionKind::Static,
+            signature: function_type,
+            host_data,
+        };
+        Self {
+            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+        }
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> FunctionType {
+        self.handle
+            .get(store.as_store_ref().objects())
+            .signature
+            .clone()
+    }
+
+    fn call_wasm(
+        &self,
+        store: &mut impl AsStoreMut,
+        trampoline: VMTrampoline,
+        params: &[Value],
+        results: &mut [Value],
+    ) -> Result<(), RuntimeError> {
+        let format_types_for_error_message = |items: &[Value]| {
+            items
+                .iter()
+                .map(|param| param.ty().to_string())
+                .collect::<Vec<String>>()
+                .join(", ")
+        };
+        // TODO: Avoid cloning the signature here, it's expensive.
+        let signature = self.ty(store);
+        if signature.params().len() != params.len() {
+            return Err(RuntimeError::new(format!(
+                "Parameters of type [{}] did not match signature {}",
+                format_types_for_error_message(params),
+                &signature
+            )));
+        }
+        if signature.results().len() != results.len() {
+            return Err(RuntimeError::new(format!(
+                "Results of type [{}] did not match signature {}",
+                format_types_for_error_message(results),
+                &signature,
+            )));
+        }
+
+        let mut values_vec = vec![RawValue { i32: 0 }; max(params.len(), results.len())];
+
+        // Store the argument values into `values_vec`.
+        let param_tys = signature.params().iter();
+        for ((arg, slot), ty) in params.iter().zip(&mut values_vec).zip(param_tys) {
+            if arg.ty() != *ty {
+                let param_types = format_types_for_error_message(params);
+                return Err(RuntimeError::new(format!(
+                    "Parameters of type [{}] did not match signature {}",
+                    param_types, &signature,
+                )));
+            }
+            if !arg.is_from_store(store) {
+                return Err(RuntimeError::new("cross-`Store` values are not supported"));
+            }
+            *slot = arg.as_raw(store);
+        }
+
+        // Invoke the call
+        self.call_wasm_raw(store, trampoline, values_vec, results)?;
+        Ok(())
+    }
+
+    fn call_wasm_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        trampoline: VMTrampoline,
+        mut params: Vec<RawValue>,
+        results: &mut [Value],
+    ) -> Result<(), RuntimeError> {
+        // Call the trampoline.
+        let result = {
+            let mut r;
+            // TODO: This loop is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+            loop {
+                let storeref = store.as_store_ref();
+                let vm_function = self.handle.get(storeref.objects());
+                let config = storeref.engine().tunables().vmconfig();
+                r = unsafe {
+                    wasmer_call_trampoline(
+                        store.as_store_ref().signal_handler(),
+                        config,
+                        vm_function.anyfunc.as_ptr().as_ref().vmctx,
+                        trampoline,
+                        vm_function.anyfunc.as_ptr().as_ref().func_ptr,
+                        params.as_mut_ptr() as *mut u8,
+                    )
+                };
+                let store_mut = store.as_store_mut();
+                if let Some(callback) = store_mut.inner.on_called.take() {
+                    match callback(store_mut) {
+                        Ok(wasmer_types::OnCalledAction::InvokeAgain) => {
+                            continue;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Finish) => {
+                            break;
+                        }
+                        Ok(wasmer_types::OnCalledAction::Trap(trap)) => {
+                            return Err(RuntimeError::user(trap));
+                        }
+                        Err(trap) => return Err(RuntimeError::user(trap)),
+                    }
+                }
+                break;
+            }
+            r
+        };
+        if let Err(error) = result {
+            return Err(error.into());
+        }
+
+        // Load the return values out of `values_vec`.
+        let signature = self.ty(store);
+        for (index, &value_type) in signature.results().iter().enumerate() {
+            unsafe {
+                results[index] = Value::from_raw(store, value_type, params[index]);
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn result_arity(&self, store: &impl AsStoreRef) -> usize {
+        self.ty(store).results().len()
+    }
+
+    pub fn call(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: &[Value],
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let trampoline = unsafe {
+            self.handle
+                .get(store.as_store_ref().objects())
+                .anyfunc
+                .as_ptr()
+                .as_ref()
+                .call_trampoline
+        };
+        let mut results = vec![Value::null(); self.result_arity(store)];
+        self.call_wasm(store, trampoline, params, &mut results)?;
+        Ok(results.into_boxed_slice())
+    }
+
+    #[doc(hidden)]
+    #[allow(missing_docs)]
+    pub fn call_raw(
+        &self,
+        store: &mut impl AsStoreMut,
+        params: Vec<RawValue>,
+    ) -> Result<Box<[Value]>, RuntimeError> {
+        let trampoline = unsafe {
+            self.handle
+                .get(store.as_store_ref().objects())
+                .anyfunc
+                .as_ptr()
+                .as_ref()
+                .call_trampoline
+        };
+        let mut results = vec![Value::null(); self.result_arity(store)];
+        self.call_wasm_raw(store, trampoline, params, &mut results)?;
+        Ok(results.into_boxed_slice())
+    }
+
+    pub(crate) fn vm_funcref(&self, store: &impl AsStoreRef) -> VMFuncRef {
+        let vm_function = self.handle.get(store.as_store_ref().objects());
+        if vm_function.kind == VMFunctionKind::Dynamic {
+            panic!("dynamic functions cannot be used in tables or as funcrefs");
+        }
+        VMFuncRef(vm_function.anyfunc.as_ptr())
+    }
+
+    pub(crate) unsafe fn from_vm_funcref(store: &mut impl AsStoreMut, funcref: VMFuncRef) -> Self {
+        let signature = store
+            .as_store_ref()
+            .engine()
+            .0
+            .lookup_signature(funcref.0.as_ref().type_index)
+            .expect("Signature not found in store");
+        let vm_function = VMFunction {
+            anyfunc: MaybeInstanceOwned::Instance(funcref.0),
+            signature,
+            // All functions in tables are already Static (as dynamic functions
+            // are converted to use the trampolines with static signatures).
+            kind: wasmer_vm::VMFunctionKind::Static,
+            host_data: Box::new(()),
+        };
+        Self {
+            handle: StoreHandle::new(store.as_store_mut().objects_mut(), vm_function),
+        }
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternFunction) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+            },
+        }
+    }
+
+    /// Checks whether this `Function` can be used with the given store.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Function(self.handle.internal_handle())
+    }
+}
+
+/// Host state for a dynamic function.
+pub(crate) struct DynamicFunction<F> {
+    func: F,
+}
+
+impl<F> DynamicFunction<F>
+where
+    F: Fn(*mut RawValue) -> Result<(), RuntimeError> + 'static,
+{
+    // This function wraps our func, to make it compatible with the
+    // reverse trampoline signature
+    unsafe extern "C" fn func_wrapper(
+        this: &mut VMDynamicFunctionContext<Self>,
+        values_vec: *mut RawValue,
+    ) {
+        let result =
+            on_host_stack(|| panic::catch_unwind(AssertUnwindSafe(|| (this.ctx.func)(values_vec))));
+
+        match result {
+            Ok(Ok(())) => {}
+            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
+            Err(panic) => resume_panic(panic),
+        }
+    }
+
+    fn func_body_ptr(&self) -> VMFunctionCallback {
+        Self::func_wrapper as VMFunctionCallback
+    }
+
+    fn call_trampoline_address(&self) -> VMTrampoline {
+        Self::call_trampoline
+    }
+
+    unsafe extern "C" fn call_trampoline(
+        vmctx: *mut VMContext,
+        _body: VMFunctionCallback,
+        args: *mut RawValue,
+    ) {
+        // The VMFunctionCallback is null here: it is only filled in later
+        // by the engine linker.
+        let dynamic_function = &mut *(vmctx as *mut VMDynamicFunctionContext<Self>);
+        Self::func_wrapper(dynamic_function, args);
+    }
+}
+
+/// Represents a low-level Wasm static host function. See
+/// [`crate::Function::new_typed`] and
+/// [`crate::Function::new_typed_with_env`] to learn more.
+pub(crate) struct StaticFunction<F, T> {
+    pub(crate) raw_store: *mut u8,
+    pub(crate) env: FunctionEnv<T>,
+    pub(crate) func: F,
+}
+
+macro_rules! impl_host_function {
+        ( [$c_struct_representation:ident]
+           $c_struct_name:ident,
+           $( $x:ident ),* ) => {
+
+            // Implement `HostFunction` for a function with a [`FunctionEnvMut`] that has the same
+            // arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, T: Send + 'static, Func >
+                HostFunction<T, ( $( $x ),* ), Rets, WithEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+                    /// This is a function that wraps the real host
+                    /// function. Its address will be used inside the
+                    /// runtime.
+                    unsafe extern "C" fn func_wrapper<T: Send + 'static, $( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, T>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        Func: Fn(FunctionEnvMut<T>, $( $x , )*) -> RetsAsResult + 'static,
+                    {
+                        // println!("func wrapper");
+                        let mut store = StoreMut::from_raw(env.raw_store as *mut _);
+                        let result = on_host_stack(|| {
+                            // println!("func wrapper1");
+                            panic::catch_unwind(AssertUnwindSafe(|| {
+                                $(
+                                    let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                                )*
+                                // println!("func wrapper2 {:p}", *env.raw_env);
+                                let store_mut = StoreMut::from_raw(env.raw_store as *mut _);
+                                let f_env = FunctionEnvMut {
+                                    store_mut,
+                                    func_env: env.env.clone(),
+                                };
+                                // println!("func wrapper3");
+                                (env.func)(f_env, $($x),* ).into_result()
+                            }))
+                        });
+
+                        match result {
+                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
+                            Err(panic) => resume_panic(panic) ,
+                        }
+                    }
+
+                    func_wrapper::< T, $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                }
+
+                #[allow(non_snake_case)]
+                fn call_trampoline_address() -> VMTrampoline {
+                    unsafe extern "C" fn call_trampoline<
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                    >(
+                        vmctx: *mut VMContext,
+                        body: VMFunctionCallback,
+                        args: *mut RawValue,
+                    ) {
+                            let body: unsafe extern "C" fn(
+                                vmctx: *mut VMContext,
+                                $( $x: <$x::Native as NativeWasmType>::Abi, )*
+                            ) -> Rets::CStruct
+                                = std::mem::transmute(body);
+
+                            let mut _n = 0;
+                            $(
+                                let $x = *args.add(_n).cast();
+                                _n += 1;
+                            )*
+
+                            let results = body(vmctx, $( $x ),*);
+                            Rets::write_c_struct_to_ptr(results, args);
+                    }
+
+                    call_trampoline::<$( $x, )* Rets>
+                }
+
+            }
+
+            // Implement `HostFunction` for a function that has the same arity than the tuple.
+            #[allow(unused_parens)]
+            impl< $( $x, )* Rets, RetsAsResult, Func >
+                HostFunction<(), ( $( $x ),* ), Rets, WithoutEnv>
+            for
+                Func
+            where
+                $( $x: FromToNativeWasmType, )*
+                Rets: WasmTypeList,
+                RetsAsResult: IntoResult<Rets>,
+                Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+            {
+                #[allow(non_snake_case)]
+                fn function_callback(&self) -> VMFunctionCallback {
+                    /// This is a function that wraps the real host
+                    /// function. Its address will be used inside the
+                    /// runtime.
+                    unsafe extern "C" fn func_wrapper<$( $x, )* Rets, RetsAsResult, Func>( env: &StaticFunction<Func, ()>, $( $x: <$x::Native as NativeWasmType>::Abi, )* ) -> Rets::CStruct
+                    where
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                        RetsAsResult: IntoResult<Rets>,
+                        Func: Fn($( $x , )*) -> RetsAsResult + 'static,
+                    {
+                        // println!("func wrapper");
+                        let mut store = StoreMut::from_raw(env.raw_store as *mut _);
+                        let result = on_host_stack(|| {
+                            // println!("func wrapper1");
+                            panic::catch_unwind(AssertUnwindSafe(|| {
+                                $(
+                                    let $x = FromToNativeWasmType::from_native(NativeWasmTypeInto::from_abi(&mut store, $x));
+                                )*
+                                (env.func)($($x),* ).into_result()
+                            }))
+                        });
+
+                        match result {
+                            Ok(Ok(result)) => return result.into_c_struct(&mut store),
+                            Ok(Err(trap)) => raise_user_trap(Box::new(trap)),
+                            Err(panic) => resume_panic(panic) ,
+                        }
+                    }
+
+                    func_wrapper::< $( $x, )* Rets, RetsAsResult, Self > as VMFunctionCallback
+                }
+
+                #[allow(non_snake_case)]
+                fn call_trampoline_address() -> VMTrampoline {
+                    unsafe extern "C" fn call_trampoline<
+                        $( $x: FromToNativeWasmType, )*
+                        Rets: WasmTypeList,
+                    >(
+                        vmctx: *mut VMContext,
+                        body: VMFunctionCallback,
+                        args: *mut RawValue,
+                    ) {
+                            let body: unsafe extern "C" fn(
+                                vmctx: *mut VMContext,
+                                $( $x: <$x::Native as NativeWasmType>::Abi, )*
+                            ) -> Rets::CStruct
+                                = std::mem::transmute(body);
+
+                            let mut _n = 0;
+                            $(
+                                let $x = *args.add(_n).cast();
+                                _n += 1;
+                            )*
+
+                            let results = body(vmctx, $( $x ),*);
+                            Rets::write_c_struct_to_ptr(results, args);
+                    }
+
+                    call_trampoline::<$( $x, )* Rets>
+                }
+
+            }
+        };
+    }
+
+// Here we go! Let's generate all the C struct, `WasmTypeList`
+// implementations and `HostFunction` implementations.
+impl_host_function!([C] S0,);
+impl_host_function!([transparent] S1, A1);
+impl_host_function!([C] S2, A1, A2);
+impl_host_function!([C] S3, A1, A2, A3);
+impl_host_function!([C] S4, A1, A2, A3, A4);
+impl_host_function!([C] S5, A1, A2, A3, A4, A5);
+impl_host_function!([C] S6, A1, A2, A3, A4, A5, A6);
+impl_host_function!([C] S7, A1, A2, A3, A4, A5, A6, A7);
+impl_host_function!([C] S8, A1, A2, A3, A4, A5, A6, A7, A8);
+impl_host_function!([C] S9, A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_host_function!([C] S10, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_host_function!([C] S11, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_host_function!([C] S12, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_host_function!([C] S13, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_host_function!([C] S14, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_host_function!([C] S15, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_host_function!([C] S16, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_host_function!([C] S17, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_host_function!([C] S18, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
+impl_host_function!([C] S19, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
+impl_host_function!([C] S20, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20);
+impl_host_function!([C] S21, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21);
+impl_host_function!([C] S22, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22);
+impl_host_function!([C] S23, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23);
+impl_host_function!([C] S24, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24);
+impl_host_function!([C] S25, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25);
+impl_host_function!([C] S26, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/global.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/global.rs
new file mode 100644
index 0000000..8d43e80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/global.rs
@@ -0,0 +1,95 @@
+use crate::errors::RuntimeError;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::value::Value;
+use crate::vm::VMExternGlobal;
+use crate::GlobalType;
+use crate::Mutability;
+use wasmer_vm::{StoreHandle, VMExtern, VMGlobal};
+
+#[derive(Debug, Clone)]
+pub struct Global {
+    handle: StoreHandle<VMGlobal>,
+}
+
+impl Global {
+    /// Create a `Global` with the initial value [`Value`] and the provided [`Mutability`].
+    pub(crate) fn from_value(
+        store: &mut impl AsStoreMut,
+        val: Value,
+        mutability: Mutability,
+    ) -> Result<Self, RuntimeError> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new("cross-`Store` values are not supported"));
+        }
+        let global = VMGlobal::new(GlobalType {
+            mutability,
+            ty: val.ty(),
+        });
+        unsafe {
+            global.vmglobal().as_mut().val = val.as_raw(store);
+        }
+
+        Ok(Self {
+            handle: StoreHandle::new(store.objects_mut(), global),
+        })
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> GlobalType {
+        *self.handle.get(store.as_store_ref().objects()).ty()
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut) -> Value {
+        unsafe {
+            let global = self.handle.get(store.as_store_ref().objects());
+            let raw = global.vmglobal().as_ref().val;
+            let ty = global.ty().ty;
+            Value::from_raw(store, ty, raw)
+        }
+    }
+
+    pub fn set(&self, store: &mut impl AsStoreMut, val: Value) -> Result<(), RuntimeError> {
+        if !val.is_from_store(store) {
+            return Err(RuntimeError::new("cross-`Store` values are not supported"));
+        }
+        let global = self.handle.get_mut(store.objects_mut());
+        if global.ty().mutability != Mutability::Var {
+            return Err(RuntimeError::new("Attempted to set an immutable global"));
+        }
+        if val.ty() != global.ty().ty {
+            return Err(RuntimeError::new(format!(
+                "Attempted to operate on a global of type {expected} as a global of type {found}",
+                expected = global.ty().ty,
+                found = val.ty(),
+            )));
+        }
+        unsafe {
+            let mut dest = global.vmglobal();
+            dest.as_mut().val = val.as_raw(store);
+        }
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternGlobal) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+            },
+        }
+    }
+
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Global(self.handle.internal_handle())
+    }
+}
+
+impl std::cmp::PartialEq for Global {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Global {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory.rs
new file mode 100644
index 0000000..b61adc4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory.rs
@@ -0,0 +1,310 @@
+use std::{
+    convert::TryInto,
+    marker::PhantomData,
+    mem::{self, MaybeUninit},
+    slice,
+};
+
+use tracing::warn;
+use wasmer_types::Pages;
+use wasmer_vm::{
+    LinearMemory, MemoryError, StoreHandle, ThreadConditionsHandle, VMExtern, VMMemory,
+};
+
+use crate::{
+    store::{AsStoreMut, AsStoreRef},
+    sys::{engine::NativeEngineExt, externals::memory_view::MemoryView},
+    vm::VMExternMemory,
+    MemoryAccessError, MemoryType,
+};
+
+#[derive(Debug, Clone)]
+pub struct Memory {
+    pub(crate) handle: StoreHandle<VMMemory>,
+}
+
+impl Memory {
+    pub fn new(store: &mut impl AsStoreMut, ty: MemoryType) -> Result<Self, MemoryError> {
+        let mut store = store.as_store_mut();
+        let tunables = store.engine().tunables();
+        let style = tunables.memory_style(&ty);
+        let memory = tunables.create_host_memory(&ty, &style)?;
+
+        Ok(Self {
+            handle: StoreHandle::new(store.objects_mut(), memory),
+        })
+    }
+
+    pub fn new_from_existing(new_store: &mut impl AsStoreMut, memory: VMMemory) -> Self {
+        let handle = StoreHandle::new(new_store.objects_mut(), memory);
+        Self::from_vm_extern(new_store, handle.internal_handle())
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> MemoryType {
+        self.handle.get(store.as_store_ref().objects()).ty()
+    }
+
+    pub fn grow<IntoPages>(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        self.handle.get_mut(store.objects_mut()).grow(delta.into())
+    }
+
+    pub fn grow_at_least(
+        &self,
+        store: &mut impl AsStoreMut,
+        min_size: u64,
+    ) -> Result<(), MemoryError> {
+        self.handle
+            .get_mut(store.objects_mut())
+            .grow_at_least(min_size)
+    }
+
+    pub fn reset(&self, store: &mut impl AsStoreMut) -> Result<(), MemoryError> {
+        self.handle.get_mut(store.objects_mut()).reset()?;
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &impl AsStoreRef, vm_extern: VMExternMemory) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+            },
+        }
+    }
+
+    /// Checks whether this `Memory` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    /// Cloning memory will create another reference to the same memory that
+    /// can be put into a new store
+    pub fn try_clone(&self, store: &impl AsStoreRef) -> Result<VMMemory, MemoryError> {
+        let mem = self.handle.get(store.as_store_ref().objects());
+        let cloned = mem.try_clone()?;
+        Ok(cloned.into())
+    }
+
+    /// Copying the memory will actually copy all the bytes in the memory to
+    /// a identical byte copy of the original that can be put into a new store
+    pub fn try_copy(
+        &self,
+        store: &impl AsStoreRef,
+    ) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        let mut mem = self.try_clone(store)?;
+        mem.copy()
+    }
+
+    pub fn as_shared(&self, store: &impl AsStoreRef) -> Option<crate::SharedMemory> {
+        let mem = self.handle.get(store.as_store_ref().objects());
+        let conds = mem.thread_conditions()?.downgrade();
+
+        Some(crate::SharedMemory::new(crate::Memory(self.clone()), conds))
+    }
+
+    /// To `VMExtern`.
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Memory(self.handle.internal_handle())
+    }
+}
+
+impl crate::externals::memory::SharedMemoryOps for ThreadConditionsHandle {
+    fn notify(
+        &self,
+        dst: crate::externals::memory::MemoryLocation,
+        count: u32,
+    ) -> Result<u32, crate::AtomicsError> {
+        let count = self
+            .upgrade()
+            .ok_or(crate::AtomicsError::Unimplemented)?
+            .do_notify(
+                wasmer_vm::NotifyLocation {
+                    address: dst.address,
+                },
+                count,
+            );
+        Ok(count)
+    }
+
+    fn wait(
+        &self,
+        dst: crate::externals::memory::MemoryLocation,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<u32, crate::AtomicsError> {
+        self.upgrade()
+            .ok_or(crate::AtomicsError::Unimplemented)?
+            .do_wait(
+                wasmer_vm::NotifyLocation {
+                    address: dst.address,
+                },
+                timeout,
+            )
+            .map_err(|e| match e {
+                wasmer_vm::WaiterError::Unimplemented => crate::AtomicsError::Unimplemented,
+                wasmer_vm::WaiterError::TooManyWaiters => crate::AtomicsError::TooManyWaiters,
+                wasmer_vm::WaiterError::AtomicsDisabled => crate::AtomicsError::AtomicsDisabled,
+                _ => crate::AtomicsError::Unimplemented,
+            })
+    }
+
+    fn disable_atomics(&self) -> Result<(), MemoryError> {
+        self.upgrade()
+            .ok_or_else(|| MemoryError::Generic("memory was dropped".to_string()))?
+            .disable_atomics();
+        Ok(())
+    }
+
+    fn wake_all_atomic_waiters(&self) -> Result<(), MemoryError> {
+        self.upgrade()
+            .ok_or_else(|| MemoryError::Generic("memory was dropped".to_string()))?
+            .wake_all_atomic_waiters();
+        Ok(())
+    }
+}
+
+impl std::cmp::PartialEq for Memory {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Memory {}
+
+/// Underlying buffer for a memory.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct MemoryBuffer<'a> {
+    pub(crate) base: *mut u8,
+    pub(crate) len: usize,
+    pub(crate) marker: PhantomData<&'a MemoryView<'a>>,
+}
+
+impl<'a> MemoryBuffer<'a> {
+    pub(crate) fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf.as_mut_ptr(), buf.len());
+        }
+        Ok(())
+    }
+
+    pub(crate) fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        let end = offset
+            .checked_add(buf.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                buf.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf_ptr = buf.as_mut_ptr() as *mut u8;
+        unsafe {
+            volatile_memcpy_read(self.base.add(offset as usize), buf_ptr, buf.len());
+        }
+
+        Ok(unsafe { slice::from_raw_parts_mut(buf_ptr, buf.len()) })
+    }
+
+    pub(crate) fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        let end = offset
+            .checked_add(data.len() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > self.len.try_into().unwrap() {
+            warn!(
+                "attempted to write ({} bytes) beyond the bounds of the memory view ({} > {})",
+                data.len(),
+                end,
+                self.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        unsafe {
+            volatile_memcpy_write(data.as_ptr(), self.base.add(offset as usize), data.len());
+        }
+        Ok(())
+    }
+}
+
+// We can't use a normal memcpy here because it has undefined behavior if the
+// memory is being concurrently modified. So we need to write our own memcpy
+// implementation which uses volatile operations.
+//
+// The implementation of these functions can optimize very well when inlined
+// with a fixed length: they should compile down to a single load/store
+// instruction for small (8/16/32/64-bit) copies.
+#[inline]
+unsafe fn volatile_memcpy_read(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read_volatile();
+        (*dst as *mut Unaligned<T>).write(val);
+        *src = src.add(mem::size_of::<T>());
+        *dst = dst.add(mem::size_of::<T>());
+        *len -= mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
+#[inline]
+unsafe fn volatile_memcpy_write(mut src: *const u8, mut dst: *mut u8, mut len: usize) {
+    #[inline]
+    unsafe fn copy_one<T>(src: &mut *const u8, dst: &mut *mut u8, len: &mut usize) {
+        #[repr(packed)]
+        struct Unaligned<T>(T);
+        let val = (*src as *const Unaligned<T>).read();
+        (*dst as *mut Unaligned<T>).write_volatile(val);
+        *src = src.add(mem::size_of::<T>());
+        *dst = dst.add(mem::size_of::<T>());
+        *len -= mem::size_of::<T>();
+    }
+
+    while len >= 8 {
+        copy_one::<u64>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 4 {
+        copy_one::<u32>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 2 {
+        copy_one::<u16>(&mut src, &mut dst, &mut len);
+    }
+    if len >= 1 {
+        copy_one::<u8>(&mut src, &mut dst, &mut len);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory_view.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory_view.rs
new file mode 100644
index 0000000..b1dc5e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/memory_view.rs
@@ -0,0 +1,202 @@
+use crate::store::AsStoreRef;
+use crate::MemoryAccessError;
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
+use std::slice;
+use std::{convert::TryInto, ops::Range};
+use wasmer_types::Pages;
+use wasmer_vm::LinearMemory;
+
+use super::memory::{Memory, MemoryBuffer};
+
+/// A WebAssembly `memory` view.
+///
+/// A memory view is used to read and write to the linear memory.
+///
+/// After a memory is grown a view must not be used anymore. Views are
+/// created using the Memory.grow() method.
+#[derive(Debug)]
+pub struct MemoryView<'a> {
+    pub(crate) buffer: MemoryBuffer<'a>,
+    pub(crate) size: Pages,
+}
+
+impl<'a> MemoryView<'a> {
+    pub(crate) fn new(memory: &Memory, store: &'a (impl AsStoreRef + ?Sized)) -> Self {
+        let size = memory.handle.get(store.as_store_ref().objects()).size();
+
+        let definition = memory.handle.get(store.as_store_ref().objects()).vmmemory();
+        let def = unsafe { definition.as_ref() };
+
+        Self {
+            buffer: MemoryBuffer {
+                base: def.base,
+                len: def.current_length,
+                marker: PhantomData,
+            },
+            size,
+        }
+    }
+
+    /// Returns the pointer to the raw bytes of the `Memory`.
+    //
+    // This used by wasmer-emscripten and wasmer-c-api, but should be treated
+    // as deprecated and not used in future code.
+    #[doc(hidden)]
+    pub fn data_ptr(&self) -> *mut u8 {
+        self.buffer.base
+    }
+
+    /// Returns the size (in bytes) of the `Memory`.
+    pub fn data_size(&self) -> u64 {
+        self.buffer.len.try_into().unwrap()
+    }
+
+    /// Retrieve a slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// Until the returned slice is dropped, it is undefined behaviour to
+    /// modify the memory contents in any way including by calling a wasm
+    /// function that writes to the memory or by resizing the memory.
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked(&self) -> &[u8] {
+        self.data_unchecked_mut()
+    }
+
+    /// Retrieve a mutable slice of the memory contents.
+    ///
+    /// # Safety
+    ///
+    /// This method provides interior mutability without an UnsafeCell. Until
+    /// the returned value is dropped, it is undefined behaviour to read or
+    /// write to the pointed-to memory in any way except through this slice,
+    /// including by calling a wasm function that reads the memory contents or
+    /// by resizing this Memory.
+    #[allow(clippy::mut_from_ref)]
+    #[doc(hidden)]
+    pub unsafe fn data_unchecked_mut(&self) -> &mut [u8] {
+        slice::from_raw_parts_mut(self.buffer.base, self.buffer.len)
+    }
+
+    /// Returns the size (in [`Pages`]) of the `Memory`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmer::{Memory, MemoryType, Pages, Store, Type, Value};
+    /// # let mut store = Store::default();
+    /// #
+    /// let m = Memory::new(&mut store, MemoryType::new(1, None, false)).unwrap();
+    ///
+    /// assert_eq!(m.view(&mut store).size(), Pages(1));
+    /// ```
+    pub fn size(&self) -> Pages {
+        self.size
+    }
+
+    #[inline]
+    pub(crate) fn buffer(&'a self) -> MemoryBuffer<'a> {
+        self.buffer
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read(&self, offset: u64, buf: &mut [u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.read(offset, buf)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_u8(&self, offset: u64) -> Result<u8, MemoryAccessError> {
+        let mut buf = [0u8; 1];
+        self.read(offset, &mut buf)?;
+        Ok(buf[0])
+    }
+
+    /// Safely reads bytes from the memory at the given offset.
+    ///
+    /// This method is similar to `read` but allows reading into an
+    /// uninitialized buffer. An initialized view of the buffer is returned.
+    ///
+    /// The full buffer will be filled, otherwise a `MemoryAccessError` is returned
+    /// to indicate an out-of-bounds access.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn read_uninit<'b>(
+        &self,
+        offset: u64,
+        buf: &'b mut [MaybeUninit<u8>],
+    ) -> Result<&'b mut [u8], MemoryAccessError> {
+        self.buffer.read_uninit(offset, buf)
+    }
+
+    /// Safely writes bytes to the memory at the given offset.
+    ///
+    /// If the write exceeds the bounds of the memory then a `MemoryAccessError` is
+    /// returned.
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent reads/writes.
+    pub fn write(&self, offset: u64, data: &[u8]) -> Result<(), MemoryAccessError> {
+        self.buffer.write(offset, data)
+    }
+
+    /// Safely reads a single byte from memory at the given offset
+    ///
+    /// This method is guaranteed to be safe (from the host side) in the face of
+    /// concurrent writes.
+    pub fn write_u8(&self, offset: u64, val: u8) -> Result<(), MemoryAccessError> {
+        let buf = [val];
+        self.write(offset, &buf)?;
+        Ok(())
+    }
+
+    #[allow(unused)]
+    /// Copies the memory and returns it as a vector of bytes
+    pub fn copy_to_vec(&self) -> Result<Vec<u8>, MemoryAccessError> {
+        self.copy_range_to_vec(0..self.data_size())
+    }
+
+    #[allow(unused)]
+    /// Copies a range of the memory and returns it as a vector of bytes
+    pub fn copy_range_to_vec(&self, range: Range<u64>) -> Result<Vec<u8>, MemoryAccessError> {
+        let mut new_memory = Vec::new();
+        let mut offset = range.start;
+        let end = range.end.min(self.data_size());
+        let mut chunk = [0u8; 40960];
+        while offset < end {
+            let remaining = end - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+            new_memory.extend_from_slice(&chunk[..sublen]);
+            offset += sublen as u64;
+        }
+        Ok(new_memory)
+    }
+
+    #[allow(unused)]
+    /// Copies the memory to another new memory object
+    pub fn copy_to_memory(&self, amount: u64, new_memory: &Self) -> Result<(), MemoryAccessError> {
+        let mut offset = 0;
+        let mut chunk = [0u8; 40960];
+        while offset < amount {
+            let remaining = amount - offset;
+            let sublen = remaining.min(chunk.len() as u64) as usize;
+            self.read(offset, &mut chunk[..sublen])?;
+
+            new_memory.write(offset, &chunk[..sublen])?;
+
+            offset += sublen as u64;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/mod.rs
new file mode 100644
index 0000000..3575fe2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/mod.rs
@@ -0,0 +1,5 @@
+pub(crate) mod function;
+pub(crate) mod global;
+pub(crate) mod memory;
+pub(crate) mod memory_view;
+pub(crate) mod table;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/table.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/table.rs
new file mode 100644
index 0000000..aba6844
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/externals/table.rs
@@ -0,0 +1,161 @@
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::sys::engine::NativeEngineExt;
+use crate::TableType;
+use crate::Value;
+use crate::{vm::VMExternTable, ExternRef, Function, RuntimeError};
+use wasmer_vm::{StoreHandle, TableElement, Trap, VMExtern, VMTable};
+
+#[derive(Debug, Clone)]
+pub struct Table {
+    handle: StoreHandle<VMTable>,
+}
+
+fn set_table_item(
+    table: &mut VMTable,
+    item_index: u32,
+    item: TableElement,
+) -> Result<(), RuntimeError> {
+    table.set(item_index, item).map_err(|e| e.into())
+}
+
+fn value_to_table_element(
+    store: &mut impl AsStoreMut,
+    val: Value,
+) -> Result<wasmer_vm::TableElement, RuntimeError> {
+    if !val.is_from_store(store) {
+        return Err(RuntimeError::new("cannot pass Value across contexts"));
+    }
+    Ok(match val {
+        Value::ExternRef(extern_ref) => {
+            wasmer_vm::TableElement::ExternRef(extern_ref.map(|e| e.vm_externref()))
+        }
+        Value::FuncRef(func_ref) => {
+            wasmer_vm::TableElement::FuncRef(func_ref.map(|f| f.vm_funcref(store)))
+        }
+        _ => return Err(RuntimeError::new("val is not reference")),
+    })
+}
+
+fn value_from_table_element(store: &mut impl AsStoreMut, item: wasmer_vm::TableElement) -> Value {
+    match item {
+        wasmer_vm::TableElement::FuncRef(funcref) => {
+            Value::FuncRef(funcref.map(|f| unsafe { Function::from_vm_funcref(store, f) }))
+        }
+        wasmer_vm::TableElement::ExternRef(extern_ref) => {
+            Value::ExternRef(extern_ref.map(|e| unsafe { ExternRef::from_vm_externref(store, e) }))
+        }
+    }
+}
+
+impl Table {
+    pub fn new(
+        mut store: &mut impl AsStoreMut,
+        ty: TableType,
+        init: Value,
+    ) -> Result<Self, RuntimeError> {
+        let item = value_to_table_element(&mut store, init)?;
+        let mut store = store.as_store_mut();
+        let tunables = store.engine().tunables();
+        let style = tunables.table_style(&ty);
+        let mut table = tunables
+            .create_host_table(&ty, &style)
+            .map_err(RuntimeError::new)?;
+
+        let num_elements = table.size();
+        for i in 0..num_elements {
+            set_table_item(&mut table, i, item.clone())?;
+        }
+
+        Ok(Self {
+            handle: StoreHandle::new(store.objects_mut(), table),
+        })
+    }
+
+    pub fn ty(&self, store: &impl AsStoreRef) -> TableType {
+        *self.handle.get(store.as_store_ref().objects()).ty()
+    }
+
+    pub fn get(&self, store: &mut impl AsStoreMut, index: u32) -> Option<Value> {
+        let item = self.handle.get(store.as_store_ref().objects()).get(index)?;
+        Some(value_from_table_element(store, item))
+    }
+
+    pub fn set(
+        &self,
+        store: &mut impl AsStoreMut,
+        index: u32,
+        val: Value,
+    ) -> Result<(), RuntimeError> {
+        let item = value_to_table_element(store, val)?;
+        set_table_item(self.handle.get_mut(store.objects_mut()), index, item)
+    }
+
+    pub fn size(&self, store: &impl AsStoreRef) -> u32 {
+        self.handle.get(store.as_store_ref().objects()).size()
+    }
+
+    pub fn grow(
+        &self,
+        store: &mut impl AsStoreMut,
+        delta: u32,
+        init: Value,
+    ) -> Result<u32, RuntimeError> {
+        let item = value_to_table_element(store, init)?;
+        self.handle
+            .get_mut(store.objects_mut())
+            .grow(delta, item)
+            .ok_or_else(|| RuntimeError::new(format!("failed to grow table by `{}`", delta)))
+    }
+
+    pub fn copy(
+        store: &mut impl AsStoreMut,
+        dst_table: &Self,
+        dst_index: u32,
+        src_table: &Self,
+        src_index: u32,
+        len: u32,
+    ) -> Result<(), RuntimeError> {
+        if dst_table.handle.store_id() != src_table.handle.store_id() {
+            return Err(RuntimeError::new(
+                "cross-`Store` table copies are not supported",
+            ));
+        }
+        if dst_table.handle.internal_handle() == src_table.handle.internal_handle() {
+            let table = dst_table.handle.get_mut(store.objects_mut());
+            table.copy_within(dst_index, src_index, len)
+        } else {
+            let (src_table, dst_table) = store.objects_mut().get_2_mut(
+                src_table.handle.internal_handle(),
+                dst_table.handle.internal_handle(),
+            );
+            VMTable::copy(dst_table, src_table, dst_index, src_index, len)
+        }
+        .map_err(Into::<Trap>::into)?;
+        Ok(())
+    }
+
+    pub(crate) fn from_vm_extern(store: &mut impl AsStoreMut, vm_extern: VMExternTable) -> Self {
+        Self {
+            handle: unsafe {
+                StoreHandle::from_internal(store.as_store_ref().objects().id(), vm_extern)
+            },
+        }
+    }
+
+    /// Checks whether this `Table` can be used with the given context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        self.handle.store_id() == store.as_store_ref().objects().id()
+    }
+
+    pub(crate) fn to_vm_extern(&self) -> VMExtern {
+        VMExtern::Table(self.handle.internal_handle())
+    }
+}
+
+impl std::cmp::PartialEq for Table {
+    fn eq(&self, other: &Self) -> bool {
+        self.handle == other.handle
+    }
+}
+
+impl std::cmp::Eq for Table {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/instance.rs
new file mode 100644
index 0000000..bbeab94
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/instance.rs
@@ -0,0 +1,92 @@
+use crate::errors::InstantiationError;
+use crate::exports::Exports;
+use crate::module::Module;
+use wasmer_vm::{StoreHandle, VMInstance};
+
+use crate::imports::Imports;
+use crate::store::AsStoreMut;
+use crate::Extern;
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Instance {
+    _handle: StoreHandle<VMInstance>,
+}
+
+#[cfg(test)]
+mod send_test {
+    use super::*;
+
+    // Only here to statically ensure that `Instance` is `Send`.
+    // Will fail to compile otherwise.
+    #[allow(dead_code)]
+    fn instance_is_send(inst: Instance) {
+        fn is_send(t: impl Send) {
+            let _ = t;
+        }
+
+        is_send(inst);
+    }
+}
+
+impl From<wasmer_compiler::InstantiationError> for InstantiationError {
+    fn from(other: wasmer_compiler::InstantiationError) -> Self {
+        match other {
+            wasmer_compiler::InstantiationError::Link(e) => Self::Link(e.into()),
+            wasmer_compiler::InstantiationError::Start(e) => Self::Start(e.into()),
+            wasmer_compiler::InstantiationError::CpuFeature(e) => Self::CpuFeature(e),
+        }
+    }
+}
+
+impl Instance {
+    #[allow(clippy::result_large_err)]
+    pub(crate) fn new(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        imports: &Imports,
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let externs = imports
+            .imports_for_module(module)
+            .map_err(InstantiationError::Link)?;
+        let mut handle = module.0.instantiate(store, &externs)?;
+        let exports = Self::get_exports(store, module, &mut handle);
+
+        let instance = Self {
+            _handle: StoreHandle::new(store.objects_mut(), handle),
+        };
+
+        Ok((instance, exports))
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub(crate) fn new_by_index(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        externs: &[Extern],
+    ) -> Result<(Self, Exports), InstantiationError> {
+        let externs = externs.to_vec();
+        let mut handle = module.0.instantiate(store, &externs)?;
+        let exports = Self::get_exports(store, module, &mut handle);
+        let instance = Self {
+            _handle: StoreHandle::new(store.objects_mut(), handle),
+        };
+
+        Ok((instance, exports))
+    }
+
+    fn get_exports(
+        store: &mut impl AsStoreMut,
+        module: &Module,
+        handle: &mut VMInstance,
+    ) -> Exports {
+        module
+            .exports()
+            .map(|export| {
+                let name = export.name().to_string();
+                let export = handle.lookup(&name).expect("export");
+                let extern_ = Extern::from_vm_extern(store, export);
+                (name, extern_)
+            })
+            .collect::<Exports>()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mem_access.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mem_access.rs
new file mode 100644
index 0000000..376c724
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mem_access.rs
@@ -0,0 +1,95 @@
+use std::mem;
+
+use crate::{
+    access::{RefCow, SliceCow, WasmRefAccess, WasmSliceAccess},
+    MemoryAccessError, WasmRef, WasmSlice,
+};
+
+impl<'a, T> WasmSliceAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(slice: WasmSlice<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = slice
+            .len
+            .checked_mul(mem::size_of::<T>() as u64)
+            .ok_or(MemoryAccessError::Overflow)?;
+        let end = slice
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > slice.buffer.0.len as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                slice.buffer.0.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let buf = unsafe {
+            let buf_ptr: *mut u8 = slice.buffer.0.base.add(slice.offset as usize);
+            let buf_ptr: *mut T = std::mem::transmute(buf_ptr);
+            std::slice::from_raw_parts_mut(buf_ptr, slice.len as usize)
+        };
+        Ok(Self {
+            slice,
+            buf: SliceCow::Borrowed(buf),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    pub(crate) fn new(ptr: WasmRef<'a, T>) -> Result<Self, MemoryAccessError> {
+        let total_len = mem::size_of::<T>() as u64;
+        let end = ptr
+            .offset
+            .checked_add(total_len)
+            .ok_or(MemoryAccessError::Overflow)?;
+        if end > ptr.buffer.0.len as u64 {
+            tracing::warn!(
+                "attempted to read ({} bytes) beyond the bounds of the memory view ({} > {})",
+                total_len,
+                end,
+                ptr.buffer.0.len
+            );
+            return Err(MemoryAccessError::HeapOutOfBounds);
+        }
+        let val = unsafe {
+            let val_ptr: *mut u8 = ptr.buffer.0.base.add(ptr.offset as usize);
+            let val_ptr: *mut T = std::mem::transmute(val_ptr);
+            &mut *val_ptr
+        };
+        Ok(Self {
+            ptr,
+            buf: RefCow::Borrowed(val),
+        })
+    }
+}
+
+impl<'a, T> WasmRefAccess<'a, T>
+where
+    T: wasmer_types::ValueType,
+{
+    /// Reads the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    #[allow(clippy::clone_on_copy)]
+    pub fn read(&self) -> T
+    where
+        T: Clone,
+    {
+        self.as_ref().clone()
+    }
+
+    /// Writes to the address pointed to by this `WasmPtr` in a memory.
+    #[inline]
+    pub fn write(&mut self, val: T) {
+        // Note: Zero padding is not required here as its a typed copy which does
+        //       not leak the bytes into the memory
+        // https://stackoverflow.com/questions/61114026/does-stdptrwrite-transfer-the-uninitialized-ness-of-the-bytes-it-writes
+        *(self.as_mut()) = val;
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mod.rs
new file mode 100644
index 0000000..5ed4ebb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/mod.rs
@@ -0,0 +1,41 @@
+pub(crate) mod engine;
+pub(crate) mod errors;
+pub(crate) mod extern_ref;
+pub(crate) mod externals;
+pub(crate) mod instance;
+pub(crate) mod mem_access;
+pub(crate) mod module;
+pub(super) mod tunables;
+pub(crate) mod typed_function;
+
+pub use crate::sys::engine::{get_default_compiler_config, NativeEngineExt};
+pub use crate::sys::tunables::BaseTunables;
+#[cfg(feature = "compiler")]
+pub use wasmer_compiler::{
+    wasmparser, CompilerConfig, FunctionMiddleware, MiddlewareReaderState, ModuleMiddleware,
+};
+pub use wasmer_compiler::{Artifact, EngineBuilder, Features, Tunables};
+#[cfg(feature = "cranelift")]
+pub use wasmer_compiler_cranelift::{Cranelift, CraneliftOptLevel};
+#[cfg(feature = "llvm")]
+pub use wasmer_compiler_llvm::{LLVMOptLevel, LLVM};
+#[cfg(feature = "singlepass")]
+pub use wasmer_compiler_singlepass::Singlepass;
+
+pub use wasmer_vm::VMConfig;
+
+pub(crate) mod vm {
+    //! The `vm` module re-exports wasmer-vm types.
+    use wasmer_vm::InternalStoreHandle;
+    pub(crate) use wasmer_vm::{
+        VMExtern, VMExternRef, VMFuncRef, VMFunction, VMFunctionBody, VMFunctionEnvironment,
+        VMGlobal, VMInstance, VMMemory, VMTable, VMTrampoline,
+    };
+
+    pub(crate) type VMExternTable = InternalStoreHandle<VMTable>;
+    pub(crate) type VMExternMemory = InternalStoreHandle<VMMemory>;
+    pub(crate) type VMExternGlobal = InternalStoreHandle<VMGlobal>;
+    pub(crate) type VMExternFunction = InternalStoreHandle<VMFunction>;
+
+    pub type VMFunctionCallback = *const VMFunctionBody;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/module.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/module.rs
new file mode 100644
index 0000000..3aae35d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/module.rs
@@ -0,0 +1,201 @@
+use std::path::Path;
+use std::sync::Arc;
+
+use bytes::Bytes;
+use wasmer_compiler::{Artifact, ArtifactCreate};
+use wasmer_types::{
+    CompileError, DeserializeError, ExportsIterator, ImportsIterator, ModuleInfo, SerializeError,
+};
+use wasmer_types::{ExportType, ImportType};
+
+use crate::{
+    engine::AsEngineRef, sys::engine::NativeEngineExt, vm::VMInstance, AsStoreMut, AsStoreRef,
+    InstantiationError, IntoBytes,
+};
+
+#[derive(Clone, PartialEq, Eq)]
+pub struct Module {
+    // The field ordering here is actually significant because of the drop
+    // order: we want to drop the artifact before dropping the engine.
+    //
+    // The reason for this is that dropping the Artifact will de-register the
+    // trap handling metadata from the global registry. This must be done before
+    // the code memory for the artifact is freed (which happens when the store
+    // is dropped) since there is a chance that this memory could be reused by
+    // another module which will try to register its own trap information.
+    //
+    // Note that in Rust, the drop order for struct fields is from top to
+    // bottom: the opposite of C++.
+    //
+    // In the future, this code should be refactored to properly describe the
+    // ownership of the code and its metadata.
+    artifact: Arc<Artifact>,
+}
+
+impl Module {
+    pub(crate) fn from_binary(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        Self::validate(engine, binary)?;
+        unsafe { Self::from_binary_unchecked(engine, binary) }
+    }
+
+    pub(crate) unsafe fn from_binary_unchecked(
+        engine: &impl AsEngineRef,
+        binary: &[u8],
+    ) -> Result<Self, CompileError> {
+        let module = Self::compile(engine, binary)?;
+        Ok(module)
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub(crate) fn validate(engine: &impl AsEngineRef, binary: &[u8]) -> Result<(), CompileError> {
+        engine.as_engine_ref().engine().0.validate(binary)
+    }
+
+    #[cfg(feature = "compiler")]
+    fn compile(engine: &impl AsEngineRef, binary: &[u8]) -> Result<Self, CompileError> {
+        let artifact = engine.as_engine_ref().engine().0.compile(binary)?;
+        Ok(Self::from_artifact(artifact))
+    }
+
+    #[cfg(not(feature = "compiler"))]
+    fn compile(_engine: &impl AsEngineRef, _binary: &[u8]) -> Result<Self, CompileError> {
+        Err(CompileError::UnsupportedTarget(
+            "The compiler feature is not enabled, but is required to compile a Module".to_string(),
+        ))
+    }
+
+    pub(crate) fn serialize(&self) -> Result<Bytes, SerializeError> {
+        self.artifact.serialize().map(|bytes| bytes.into())
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub unsafe fn deserialize_unchecked(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = bytes.into_bytes();
+        let artifact = engine
+            .as_engine_ref()
+            .engine()
+            .0
+            .deserialize_unchecked(bytes.into())?;
+        Ok(Self::from_artifact(artifact))
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub unsafe fn deserialize(
+        engine: &impl AsEngineRef,
+        bytes: impl IntoBytes,
+    ) -> Result<Self, DeserializeError> {
+        let bytes = bytes.into_bytes();
+        let artifact = engine
+            .as_engine_ref()
+            .engine()
+            .0
+            .deserialize(bytes.into())?;
+        Ok(Self::from_artifact(artifact))
+    }
+
+    pub unsafe fn deserialize_from_file_unchecked(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let artifact = engine
+            .as_engine_ref()
+            .engine()
+            .0
+            .deserialize_from_file_unchecked(path.as_ref())?;
+        Ok(Self::from_artifact(artifact))
+    }
+
+    pub unsafe fn deserialize_from_file(
+        engine: &impl AsEngineRef,
+        path: impl AsRef<Path>,
+    ) -> Result<Self, DeserializeError> {
+        let artifact = engine
+            .as_engine_ref()
+            .engine()
+            .0
+            .deserialize_from_file(path.as_ref())?;
+        Ok(Self::from_artifact(artifact))
+    }
+
+    pub(super) fn from_artifact(artifact: Arc<Artifact>) -> Self {
+        Self { artifact }
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub(crate) fn instantiate(
+        &self,
+        store: &mut impl AsStoreMut,
+        imports: &[crate::Extern],
+    ) -> Result<VMInstance, InstantiationError> {
+        if !self.artifact.allocated() {
+            // Return an error mentioning that the artifact is compiled for a different
+            // platform.
+            return Err(InstantiationError::DifferentArchOS);
+        }
+        // Ensure all imports come from the same context.
+        for import in imports {
+            if !import.is_from_store(store) {
+                return Err(InstantiationError::DifferentStores);
+            }
+        }
+        let signal_handler = store.as_store_ref().signal_handler();
+        let mut store_mut = store.as_store_mut();
+        let (engine, objects) = store_mut.engine_and_objects_mut();
+        let config = engine.tunables().vmconfig();
+        unsafe {
+            let mut instance_handle = self.artifact.instantiate(
+                engine.tunables(),
+                &imports
+                    .iter()
+                    .map(crate::Extern::to_vm_extern)
+                    .collect::<Vec<_>>(),
+                objects,
+            )?;
+
+            // After the instance handle is created, we need to initialize
+            // the data, call the start function and so. However, if any
+            // of this steps traps, we still need to keep the instance alive
+            // as some of the Instance elements may have placed in other
+            // instance tables.
+            self.artifact
+                .finish_instantiation(config, signal_handler, &mut instance_handle)?;
+
+            Ok(instance_handle)
+        }
+    }
+
+    pub(crate) fn name(&self) -> Option<&str> {
+        self.info().name.as_deref()
+    }
+
+    pub(crate) fn set_name(&mut self, name: &str) -> bool {
+        Arc::get_mut(&mut self.artifact).map_or(false, |artifact| {
+            artifact.set_module_info_name(name.to_string())
+        })
+    }
+
+    pub(crate) fn imports(&self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+        self.info().imports()
+    }
+
+    pub(crate) fn exports(&self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+        self.info().exports()
+    }
+
+    pub(crate) fn custom_sections<'a>(
+        &'a self,
+        name: &'a str,
+    ) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        self.info().custom_sections(name)
+    }
+
+    pub(crate) fn info(&self) -> &ModuleInfo {
+        self.artifact.module_info()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/tunables.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/tunables.rs
new file mode 100644
index 0000000..df63e3b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/tunables.rs
@@ -0,0 +1,471 @@
+pub use wasmer_compiler::BaseTunables;
+
+// All BaseTunable definition now is in wasmer_compile crate
+// Tests are still here
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[allow(unused)]
+    use crate::sys::NativeEngineExt;
+    use crate::TableType;
+    use std::cell::UnsafeCell;
+    use std::ptr::NonNull;
+    use wasmer_compiler::Tunables;
+    use wasmer_types::{MemoryType, Pages, WASM_PAGE_SIZE};
+    use wasmer_vm::{
+        LinearMemory, MemoryError, MemoryStyle, TableStyle, VMConfig, VMMemory, VMMemoryDefinition,
+        VMTable, VMTableDefinition,
+    };
+
+    #[test]
+    fn memory_style() {
+        let tunables = BaseTunables {
+            static_memory_bound: Pages(2048),
+            static_memory_offset_guard_size: 128,
+            dynamic_memory_offset_guard_size: 256,
+        };
+
+        // No maximum
+        let requested = MemoryType::new(3, None, true);
+        let style = tunables.memory_style(&requested);
+        match style {
+            MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256),
+            s => panic!("Unexpected memory style: {:?}", s),
+        }
+
+        // Large maximum
+        let requested = MemoryType::new(3, Some(5_000_000), true);
+        let style = tunables.memory_style(&requested);
+        match style {
+            MemoryStyle::Dynamic { offset_guard_size } => assert_eq!(offset_guard_size, 256),
+            s => panic!("Unexpected memory style: {:?}", s),
+        }
+
+        // Small maximum
+        let requested = MemoryType::new(3, Some(16), true);
+        let style = tunables.memory_style(&requested);
+        match style {
+            MemoryStyle::Static {
+                bound,
+                offset_guard_size,
+            } => {
+                assert_eq!(bound, Pages(2048));
+                assert_eq!(offset_guard_size, 128);
+            }
+            s => panic!("Unexpected memory style: {:?}", s),
+        }
+    }
+
+    #[derive(Debug)]
+    struct VMTinyMemory {
+        mem: Vec<u8>,
+        memory_definition: Option<UnsafeCell<VMMemoryDefinition>>,
+    }
+
+    unsafe impl Send for VMTinyMemory {}
+    unsafe impl Sync for VMTinyMemory {}
+
+    impl VMTinyMemory {
+        pub fn new() -> Result<Self, MemoryError> {
+            let sz = 18 * WASM_PAGE_SIZE;
+            let mut memory = Vec::new();
+            memory.resize(sz, 0);
+            let mut ret = Self {
+                mem: memory,
+                memory_definition: None,
+            };
+            ret.memory_definition = Some(UnsafeCell::new(VMMemoryDefinition {
+                base: ret.mem.as_ptr() as _,
+                current_length: sz,
+            }));
+            Ok(ret)
+        }
+    }
+
+    impl LinearMemory for VMTinyMemory {
+        fn ty(&self) -> MemoryType {
+            MemoryType {
+                minimum: Pages::from(18u32),
+                maximum: Some(Pages::from(18u32)),
+                shared: false,
+            }
+        }
+        fn size(&self) -> Pages {
+            Pages::from(18u32)
+        }
+        fn style(&self) -> MemoryStyle {
+            MemoryStyle::Static {
+                bound: Pages::from(18u32),
+                offset_guard_size: 0,
+            }
+        }
+        fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+            Err(MemoryError::CouldNotGrow {
+                current: Pages::from(100u32),
+                attempted_delta: delta,
+            })
+        }
+
+        fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+            let cur_size = self.size().0 as u64 * WASM_PAGE_SIZE as u64;
+            if min_size > cur_size {
+                let delta = min_size - cur_size;
+                return Err(MemoryError::CouldNotGrow {
+                    current: Pages::from(100u32),
+                    attempted_delta: Pages(delta as u32),
+                });
+            }
+            Ok(())
+        }
+
+        fn reset(&mut self) -> Result<(), MemoryError> {
+            self.mem.fill(0);
+            Ok(())
+        }
+
+        fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+            unsafe {
+                NonNull::new(
+                    self.memory_definition
+                        .as_ref()
+                        .unwrap()
+                        .get()
+                        .as_mut()
+                        .unwrap() as _,
+                )
+                .unwrap()
+            }
+        }
+
+        fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+            Err(MemoryError::InvalidMemory {
+                reason: "VMTinyMemory can not be cloned".to_string(),
+            })
+        }
+
+        fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+            let mem = self.mem.clone();
+            Ok(Box::new(Self {
+                memory_definition: Some(UnsafeCell::new(VMMemoryDefinition {
+                    base: mem.as_ptr() as _,
+                    current_length: mem.len(),
+                })),
+                mem,
+            }))
+        }
+        /*
+        // this code allow custom memory to be ignoring init_memory
+        use wasmer_vm::Trap;
+        unsafe fn initialize_with_data(&self, _start: usize, _data: &[u8]) -> Result<(), Trap> {
+            Ok(())
+        }
+        */
+    }
+
+    impl From<VMTinyMemory> for wasmer_vm::VMMemory {
+        fn from(mem: VMTinyMemory) -> Self {
+            Self(Box::new(mem))
+        }
+    }
+
+    struct TinyTunables;
+    impl Tunables for TinyTunables {
+        fn memory_style(&self, _memory: &MemoryType) -> MemoryStyle {
+            MemoryStyle::Static {
+                bound: Pages::from(18u32),
+                offset_guard_size: 0,
+            }
+        }
+
+        /// Construct a `TableStyle` for the provided `TableType`
+        fn table_style(&self, _table: &TableType) -> TableStyle {
+            TableStyle::CallerChecksSignature
+        }
+        fn create_host_memory(
+            &self,
+            _ty: &MemoryType,
+            _style: &MemoryStyle,
+        ) -> Result<VMMemory, MemoryError> {
+            let memory = VMTinyMemory::new().unwrap();
+            Ok(VMMemory::from_custom(memory))
+        }
+        unsafe fn create_vm_memory(
+            &self,
+            _ty: &MemoryType,
+            _style: &MemoryStyle,
+            vm_definition_location: NonNull<VMMemoryDefinition>,
+        ) -> Result<VMMemory, MemoryError> {
+            let memory = VMTinyMemory::new().unwrap();
+            // now, it's important to update vm_definition_location with the memory information!
+            let mut ptr = vm_definition_location;
+            let md = ptr.as_mut();
+            let unsafecell = memory.memory_definition.as_ref().unwrap();
+            let def = unsafecell.get().as_ref().unwrap();
+            md.base = def.base;
+            md.current_length = def.current_length;
+            Ok(memory.into())
+        }
+
+        /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
+        fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
+            VMTable::new(ty, style)
+        }
+
+        /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`].
+        ///
+        /// # Safety
+        /// - `vm_definition_location` must point to a valid location in VM memory.
+        unsafe fn create_vm_table(
+            &self,
+            ty: &TableType,
+            style: &TableStyle,
+            vm_definition_location: NonNull<VMTableDefinition>,
+        ) -> Result<VMTable, String> {
+            VMTable::from_definition(ty, style, vm_definition_location)
+        }
+
+        // Will use a minimum stack size of 8kb, not the 1Mb default
+        fn vmconfig(&self) -> &crate::vm::VMConfig {
+            &VMConfig {
+                wasm_stack_size: Some(8 * 1024),
+            }
+        }
+    }
+
+    #[test]
+    fn check_linearmemory() {
+        let tunables = TinyTunables {};
+        let vmmemory = tunables.create_host_memory(
+            &MemoryType::new(1u32, Some(100u32), true),
+            &MemoryStyle::Static {
+                bound: Pages::from(18u32),
+                offset_guard_size: 0u64,
+            },
+        );
+        let mut vmmemory = vmmemory.unwrap();
+        assert!(vmmemory.grow(Pages::from(50u32)).is_err());
+        assert_eq!(vmmemory.size(), Pages::from(18u32));
+        assert_eq!(
+            vmmemory.grow(Pages::from(0u32)).err().unwrap(),
+            MemoryError::CouldNotGrow {
+                current: Pages::from(100u32),
+                attempted_delta: Pages::from(0u32)
+            }
+        );
+    }
+
+    #[test]
+    fn check_customtunables() -> Result<(), Box<dyn std::error::Error>> {
+        use crate::{imports, wat2wasm, Engine, Instance, Memory, Module, Store};
+        use wasmer_compiler_cranelift::Cranelift;
+
+        let wasm_bytes = wat2wasm(
+            br#"(module
+            (memory (;0;) 18)
+            (global (;0;) (mut i32) i32.const 1048576)
+            (export "memory" (memory 0))
+            (data (;0;) (i32.const 1048576) "*\00\00\00")
+          )"#,
+        )?;
+        let compiler = Cranelift::default();
+
+        let tunables = TinyTunables {};
+        #[allow(deprecated)]
+        let mut engine = Engine::new(compiler.into(), Default::default(), Default::default());
+        engine.set_tunables(tunables);
+        let mut store = Store::new(engine);
+        //let mut store = Store::new(compiler);
+        let module = Module::new(&store, wasm_bytes)?;
+        let import_object = imports! {};
+        let instance = Instance::new(&mut store, &module, &import_object)?;
+
+        let mut memories: Vec<Memory> = instance
+            .exports
+            .iter()
+            .memories()
+            .map(|pair| pair.1.clone())
+            .collect();
+        assert_eq!(memories.len(), 1);
+        let first_memory = memories.pop().unwrap();
+        assert_eq!(first_memory.ty(&store).maximum.unwrap(), Pages(18));
+        let view = first_memory.view(&store);
+        let x = unsafe { view.data_unchecked_mut() }[0];
+        assert_eq!(x, 0);
+
+        Ok(())
+    }
+
+    #[test]
+    #[cfg(all(
+        feature = "singlepass",
+        not(any(
+            target_os = "windows",
+            all(target_os = "macos", target_arch = "aarch64")
+        ))
+    ))]
+    fn check_small_stack() -> Result<(), Box<dyn std::error::Error>> {
+        use crate::{imports, wat2wasm, Engine, Instance, Module, Store};
+        use wasmer_compiler_singlepass::Singlepass;
+        // This test needs Singlepass compiler
+        // because Cranelift will optimize the webassembly file
+        // and remove all the unused local, even at optimization level "None"
+        // But this test needs the huge amount of locals (1024 + a few)
+        // so that the small stack is overflown (stack is only 8K, 1024 i64 local = 8K)
+        // tWindows is disable as it seems Stack frame protection is not 100% efficient
+        let wasm_bytes = wat2wasm(
+            br#"(module
+                (func (;0;) (result i64)
+                  (local i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+                  i64.const 0
+                  i64.const 5555
+                  i64.add
+                  local.set 8
+                  i64.const 0
+                  i64.const 5555
+                  i64.add
+                  local.set 9
+                  i64.const 0
+                  i64.const 5555
+                  i64.add
+                  local.set 10
+                  local.get 10
+                )
+                (func $large_local (export "large_local") (result i64)
+                  (local
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+                   i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+
+                   i64
+                  )
+                  (local.set 0 (i64.const 1))
+                  (local.set 1 (i64.const 1))
+                  (local.set 2 (i64.const 1))
+                  (local.set 3 (i64.const 1))
+                  (local.set 1024 (i64.const 2))
+                  (call 0)
+                  local.set 1024
+                  local.get 6
+                  local.get 7
+                  i64.add
+                  local.get 8
+                  i64.add
+                  (call 0)
+                  local.set 10
+                  local.get 9
+                  i64.add
+                  local.get 10
+                  i64.add
+                  local.get 11
+                  i64.add
+                  local.get 12
+                  i64.add
+                  (call 0)
+                  local.set 512
+                  local.get 13
+                  i64.add
+                  local.get 14
+                  i64.add
+                  local.get 15
+                  i64.add
+                  local.get 1024
+                  i64.add
+                  local.get 0
+                  i64.add
+                )
+              )
+            "#,
+        )?;
+        let compiler = Singlepass::default();
+
+        let tunables = TinyTunables {};
+        #[allow(deprecated)]
+        let mut engine = Engine::new(compiler.into(), Default::default(), Default::default());
+        engine.set_tunables(tunables);
+        let mut store = Store::new(engine);
+        let module = Module::new(&store, wasm_bytes)?;
+        let import_object = imports! {};
+        let instance = Instance::new(&mut store, &module, &import_object)?;
+
+        let result = instance
+            .exports
+            .get_function("large_local")?
+            .call(&mut store, &[]);
+
+        println!("result = {:?}", result);
+        assert!(result.is_err());
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/typed_function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/typed_function.rs
new file mode 100644
index 0000000..1ff5d25
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/sys/typed_function.rs
@@ -0,0 +1,216 @@
+use crate::{FromToNativeWasmType, RuntimeError, TypedFunction, WasmTypeList};
+use wasmer_types::RawValue;
+
+use crate::native_type::NativeWasmTypeInto;
+use crate::store::{AsStoreMut, AsStoreRef};
+use crate::sys::engine::NativeEngineExt;
+
+macro_rules! impl_native_traits {
+    (  $( $x:ident ),* ) => {
+        #[allow(unused_parens, non_snake_case)]
+        impl<$( $x , )* Rets> TypedFunction<( $( $x ),* ), Rets>
+        where
+            $( $x: FromToNativeWasmType, )*
+            Rets: WasmTypeList,
+        {
+            /// Call the typed func and return results.
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call(&self, store: &mut impl AsStoreMut, $( $x: $x, )* ) -> Result<Rets, RuntimeError> {
+                let anyfunc = unsafe {
+                    *self.func.0
+                        .handle
+                        .get(store.as_store_ref().objects())
+                        .anyfunc
+                        .as_ptr()
+                        .as_ref()
+                };
+                // Ensure all parameters come from the same context.
+                if $(!FromToNativeWasmType::is_from_store(&$x, store) ||)* false {
+                    return Err(RuntimeError::new(
+                        "cross-`Store` values are not supported",
+                    ));
+                }
+                // TODO: when `const fn` related features mature more, we can declare a single array
+                // of the correct size here.
+                let mut params_list = [ $( $x.to_native().into_raw(store) ),* ];
+                let mut rets_list_array = Rets::empty_array();
+                let rets_list: &mut [RawValue] = rets_list_array.as_mut();
+                let using_rets_array;
+                let args_rets: &mut [RawValue] = if params_list.len() > rets_list.len() {
+                    using_rets_array = false;
+                    params_list.as_mut()
+                } else {
+                    using_rets_array = true;
+                    for (i, &arg) in params_list.iter().enumerate() {
+                        rets_list[i] = arg;
+                    }
+                    rets_list.as_mut()
+                };
+
+                let mut r;
+                loop {
+                    let storeref = store.as_store_ref();
+                    let config = storeref.engine().tunables().vmconfig();
+                    r = unsafe {
+                        wasmer_vm::wasmer_call_trampoline(
+                            store.as_store_ref().signal_handler(),
+                            config,
+                            anyfunc.vmctx,
+                            anyfunc.call_trampoline,
+                            anyfunc.func_ptr,
+                            args_rets.as_mut_ptr() as *mut u8,
+                        )
+                    };
+                    let store_mut = store.as_store_mut();
+                    if let Some(callback) = store_mut.inner.on_called.take() {
+                        match callback(store_mut) {
+                            Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                            Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                            Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                            Err(trap) => { return Err(RuntimeError::user(trap)) },
+                        }
+                    }
+                    break;
+                }
+                r?;
+
+                let num_rets = rets_list.len();
+                if !using_rets_array && num_rets > 0 {
+                    let src_pointer = params_list.as_ptr();
+                    let rets_list = &mut rets_list_array.as_mut()[0] as *mut RawValue;
+                    unsafe {
+                        // TODO: we can probably remove this copy by doing some clever `transmute`s.
+                        // we know it's not overlapping because `using_rets_array` is false
+                        std::ptr::copy_nonoverlapping(src_pointer,
+                                                        rets_list,
+                                                        num_rets);
+                    }
+                }
+                Ok(unsafe { Rets::from_array(store, rets_list_array) })
+                // TODO: When the Host ABI and Wasm ABI are the same, we could do this instead:
+                // but we can't currently detect whether that's safe.
+                //
+                // let results = unsafe {
+                //     wasmer_vm::catch_traps_with_result(self.vmctx, || {
+                //         let f = std::mem::transmute::<_, unsafe extern "C" fn( *mut VMContext, $( $x, )*) -> Rets::CStruct>(self.address());
+                //         // We always pass the vmctx
+                //         f( self.vmctx, $( $x, )* )
+                //     }).map_err(RuntimeError::from_trap)?
+                // };
+                // Ok(Rets::from_c_struct(results))
+            }
+
+            #[doc(hidden)]
+            #[allow(missing_docs)]
+            #[allow(unused_mut)]
+            #[allow(clippy::too_many_arguments)]
+            pub fn call_raw(&self, store: &mut impl AsStoreMut, mut params_list: Vec<RawValue> ) -> Result<Rets, RuntimeError> {
+                let anyfunc = unsafe {
+                    *self.func.0
+                        .handle
+                        .get(store.as_store_ref().objects())
+                        .anyfunc
+                        .as_ptr()
+                        .as_ref()
+                };
+                // TODO: when `const fn` related features mature more, we can declare a single array
+                // of the correct size here.
+                let mut rets_list_array = Rets::empty_array();
+                let rets_list: &mut [RawValue] = rets_list_array.as_mut();
+                let using_rets_array;
+                let args_rets: &mut [RawValue] = if params_list.len() > rets_list.len() {
+                    using_rets_array = false;
+                    params_list.as_mut()
+                } else {
+                    using_rets_array = true;
+                    for (i, &arg) in params_list.iter().enumerate() {
+                        rets_list[i] = arg;
+                    }
+                    rets_list.as_mut()
+                };
+
+                let mut r;
+                loop {
+                    let storeref = store.as_store_ref();
+                    let config = storeref.engine().tunables().vmconfig();
+                    r = unsafe {
+                        wasmer_vm::wasmer_call_trampoline(
+                            store.as_store_ref().signal_handler(),
+                            config,
+                            anyfunc.vmctx,
+                            anyfunc.call_trampoline,
+                            anyfunc.func_ptr,
+                            args_rets.as_mut_ptr() as *mut u8,
+                        )
+                    };
+                    let store_mut = store.as_store_mut();
+                    if let Some(callback) = store_mut.inner.on_called.take() {
+                        // TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+                        match callback(store_mut) {
+                            Ok(wasmer_types::OnCalledAction::InvokeAgain) => { continue; }
+                            Ok(wasmer_types::OnCalledAction::Finish) => { break; }
+                            Ok(wasmer_types::OnCalledAction::Trap(trap)) => { return Err(RuntimeError::user(trap)) },
+                            Err(trap) => { return Err(RuntimeError::user(trap)) },
+                        }
+                    }
+                    break;
+                }
+                r?;
+
+                let num_rets = rets_list.len();
+                if !using_rets_array && num_rets > 0 {
+                    let src_pointer = params_list.as_ptr();
+                    let rets_list = &mut rets_list_array.as_mut()[0] as *mut RawValue;
+                    unsafe {
+                        // TODO: we can probably remove this copy by doing some clever `transmute`s.
+                        // we know it's not overlapping because `using_rets_array` is false
+                        std::ptr::copy_nonoverlapping(src_pointer,
+                                                        rets_list,
+                                                        num_rets);
+                    }
+                }
+                Ok(unsafe { Rets::from_array(store, rets_list_array) })
+                // TODO: When the Host ABI and Wasm ABI are the same, we could do this instead:
+                // but we can't currently detect whether that's safe.
+                //
+                // let results = unsafe {
+                //     wasmer_vm::catch_traps_with_result(self.vmctx, || {
+                //         let f = std::mem::transmute::<_, unsafe extern "C" fn( *mut VMContext, $( $x, )*) -> Rets::CStruct>(self.address());
+                //         // We always pass the vmctx
+                //         f( self.vmctx, $( $x, )* )
+                //     }).map_err(RuntimeError::from_trap)?
+                // };
+                // Ok(Rets::from_c_struct(results))
+            }
+        }
+    };
+}
+
+impl_native_traits!();
+impl_native_traits!(A1);
+impl_native_traits!(A1, A2);
+impl_native_traits!(A1, A2, A3);
+impl_native_traits!(A1, A2, A3, A4);
+impl_native_traits!(A1, A2, A3, A4, A5);
+impl_native_traits!(A1, A2, A3, A4, A5, A6);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
+impl_native_traits!(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19
+);
+impl_native_traits!(
+    A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20
+);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/typed_function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/typed_function.rs
new file mode 100644
index 0000000..ccaadcf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/typed_function.rs
@@ -0,0 +1,42 @@
+//! Native Functions.
+//!
+//! This module creates the helper `TypedFunction` that let us call WebAssembly
+//! functions with the native ABI, that is:
+//!
+//! ```ignore
+//! let add_one = instance.exports.get_function("function_name")?;
+//! let add_one_native: TypedFunction<i32, i32> = add_one.native().unwrap();
+//! ```
+use crate::{Function, WasmTypeList};
+use std::marker::PhantomData;
+
+use crate::store::AsStoreRef;
+
+/// A WebAssembly function that can be called natively
+/// (using the Native ABI).
+#[derive(Clone)]
+pub struct TypedFunction<Args, Rets> {
+    pub(crate) func: Function,
+    _phantom: PhantomData<fn(Args) -> Rets>,
+}
+
+unsafe impl<Args, Rets> Send for TypedFunction<Args, Rets> {}
+unsafe impl<Args, Rets> Sync for TypedFunction<Args, Rets> {}
+
+impl<Args, Rets> TypedFunction<Args, Rets>
+where
+    Args: WasmTypeList,
+    Rets: WasmTypeList,
+{
+    #[allow(dead_code)]
+    pub(crate) fn new(_store: &impl AsStoreRef, func: Function) -> Self {
+        Self {
+            func,
+            _phantom: PhantomData,
+        }
+    }
+
+    pub(crate) fn into_function(self) -> Function {
+        self.func
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/value.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/value.rs
new file mode 100644
index 0000000..15ec16e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/value.rs
@@ -0,0 +1,475 @@
+use std::convert::TryFrom;
+use std::fmt;
+use std::string::{String, ToString};
+
+use wasmer_types::Type;
+
+use crate::vm::{VMExternRef, VMFuncRef};
+
+use crate::ExternRef;
+use crate::Function;
+
+use crate::store::AsStoreRef;
+
+pub use wasmer_types::RawValue;
+
+/// WebAssembly computations manipulate values of basic value types:
+/// * Integers (32 or 64 bit width)
+/// * Floating-point (32 or 64 bit width)
+/// * Vectors (128 bits, with 32 or 64 bit lanes)
+///
+/// Spec: <https://webassembly.github.io/spec/core/exec/runtime.html#values>
+#[derive(Clone)]
+pub enum Value {
+    /// A 32-bit integer.
+    ///
+    /// In Wasm integers are sign-agnostic, i.e. this can either be signed or unsigned.
+    I32(i32),
+
+    /// A 64-bit integer.
+    ///
+    /// In Wasm integers are sign-agnostic, i.e. this can either be signed or unsigned.
+    I64(i64),
+
+    /// A 32-bit float.
+    F32(f32),
+
+    /// A 64-bit float.
+    F64(f64),
+
+    /// An `externref` value which can hold opaque data to the wasm instance itself.
+    ExternRef(Option<ExternRef>),
+
+    /// A first-class reference to a WebAssembly function.
+    FuncRef(Option<Function>),
+
+    /// A 128-bit number
+    V128(u128),
+}
+
+macro_rules! accessors {
+    ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($(
+        /// Attempt to access the underlying value of this `Value`, returning
+        /// `None` if it is not the correct type.
+        pub fn $get(&self) -> Option<$ty> {
+            if let Self::$variant($bind) = self {
+                Some($cvt)
+            } else {
+                None
+            }
+        }
+
+        /// Returns the underlying value of this `Value`, panicking if it's the
+        /// wrong type.
+        ///
+        /// # Panics
+        ///
+        /// Panics if `self` is not of the right type.
+        pub fn $unwrap(&self) -> $ty {
+            self.$get().expect(concat!("expected ", stringify!($ty)))
+        }
+    )*)
+}
+
+impl Value {
+    /// Returns a null `externref` value.
+    pub fn null() -> Self {
+        Self::ExternRef(None)
+    }
+
+    /// Returns the corresponding [`Type`] for this `Value`.
+    pub fn ty(&self) -> Type {
+        match self {
+            Self::I32(_) => Type::I32,
+            Self::I64(_) => Type::I64,
+            Self::F32(_) => Type::F32,
+            Self::F64(_) => Type::F64,
+            Self::ExternRef(_) => Type::ExternRef,
+            Self::FuncRef(_) => Type::FuncRef,
+            Self::V128(_) => Type::V128,
+        }
+    }
+
+    /// Converts the `Value` into a `RawValue`.
+    pub fn as_raw(&self, store: &impl AsStoreRef) -> RawValue {
+        match *self {
+            Self::I32(i32) => RawValue { i32 },
+            Self::I64(i64) => RawValue { i64 },
+            Self::F32(f32) => RawValue { f32 },
+            Self::F64(f64) => RawValue { f64 },
+            Self::V128(u128) => RawValue { u128 },
+            Self::FuncRef(Some(ref f)) => f.vm_funcref(store).into_raw(),
+
+            Self::FuncRef(None) => RawValue { funcref: 0 },
+            Self::ExternRef(Some(ref e)) => e.vm_externref().into_raw(),
+            Self::ExternRef(None) => RawValue { externref: 0 },
+        }
+    }
+
+    /// Converts a `RawValue` to a `Value`.
+    ///
+    /// # Safety
+    ///
+    pub unsafe fn from_raw(store: &mut impl crate::AsStoreMut, ty: Type, raw: RawValue) -> Self {
+        match ty {
+            Type::I32 => Self::I32(raw.i32),
+            Type::I64 => Self::I64(raw.i64),
+            Type::F32 => Self::F32(raw.f32),
+            Type::F64 => Self::F64(raw.f64),
+            Type::V128 => Self::V128(raw.u128),
+            Type::FuncRef => {
+                Self::FuncRef(VMFuncRef::from_raw(raw).map(|f| Function::from_vm_funcref(store, f)))
+            }
+            Type::ExternRef => Self::ExternRef(
+                VMExternRef::from_raw(raw).map(|e| ExternRef::from_vm_externref(store, e)),
+            ),
+        }
+    }
+
+    /// Checks whether a value can be used with the given context.
+    ///
+    /// Primitive (`i32`, `i64`, etc) and null funcref/externref values are not
+    /// tied to a context and can be freely shared between contexts.
+    ///
+    /// Externref and funcref values are tied to a context and can only be used
+    /// with that context.
+    pub fn is_from_store(&self, store: &impl AsStoreRef) -> bool {
+        match self {
+            Self::I32(_)
+            | Self::I64(_)
+            | Self::F32(_)
+            | Self::F64(_)
+            | Self::V128(_)
+            | Self::ExternRef(None)
+            | Self::FuncRef(None) => true,
+            Self::ExternRef(Some(e)) => e.is_from_store(store),
+            Self::FuncRef(Some(f)) => f.is_from_store(store),
+        }
+    }
+
+    accessors! {
+        e
+        (I32(i32) i32 unwrap_i32 *e)
+        (I64(i64) i64 unwrap_i64 *e)
+        (F32(f32) f32 unwrap_f32 *e)
+        (F64(f64) f64 unwrap_f64 *e)
+        (ExternRef(&Option<ExternRef>) externref unwrap_externref e)
+        (FuncRef(&Option<Function>) funcref unwrap_funcref e)
+        (V128(u128) v128 unwrap_v128 *e)
+    }
+}
+
+impl fmt::Debug for Value {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::I32(v) => write!(f, "I32({:?})", v),
+            Self::I64(v) => write!(f, "I64({:?})", v),
+            Self::F32(v) => write!(f, "F32({:?})", v),
+            Self::F64(v) => write!(f, "F64({:?})", v),
+            Self::ExternRef(None) => write!(f, "Null ExternRef"),
+            Self::ExternRef(Some(v)) => write!(f, "ExternRef({:?})", v),
+            Self::FuncRef(None) => write!(f, "Null FuncRef"),
+            Self::FuncRef(Some(v)) => write!(f, "FuncRef({:?})", v),
+            Self::V128(v) => write!(f, "V128({:?})", v),
+        }
+    }
+}
+
+impl ToString for Value {
+    fn to_string(&self) -> String {
+        match self {
+            Self::I32(v) => v.to_string(),
+            Self::I64(v) => v.to_string(),
+            Self::F32(v) => v.to_string(),
+            Self::F64(v) => v.to_string(),
+            Self::ExternRef(_) => "externref".to_string(),
+            Self::FuncRef(_) => "funcref".to_string(),
+            Self::V128(v) => v.to_string(),
+        }
+    }
+}
+
+impl PartialEq for Value {
+    fn eq(&self, o: &Self) -> bool {
+        match (self, o) {
+            (Self::I32(a), Self::I32(b)) => a == b,
+            (Self::I64(a), Self::I64(b)) => a == b,
+            (Self::F32(a), Self::F32(b)) => a == b,
+            (Self::F64(a), Self::F64(b)) => a == b,
+            (Self::V128(a), Self::V128(b)) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl From<i32> for Value {
+    fn from(val: i32) -> Self {
+        Self::I32(val)
+    }
+}
+
+impl From<u32> for Value {
+    fn from(val: u32) -> Self {
+        // In Wasm integers are sign-agnostic, so i32 is basically a 4 byte storage we can use for signed or unsigned 32-bit integers.
+        Self::I32(val as i32)
+    }
+}
+
+impl From<i64> for Value {
+    fn from(val: i64) -> Self {
+        Self::I64(val)
+    }
+}
+
+impl From<u64> for Value {
+    fn from(val: u64) -> Self {
+        // In Wasm integers are sign-agnostic, so i64 is basically an 8 byte storage we can use for signed or unsigned 64-bit integers.
+        Self::I64(val as i64)
+    }
+}
+
+impl From<f32> for Value {
+    fn from(val: f32) -> Self {
+        Self::F32(val)
+    }
+}
+
+impl From<f64> for Value {
+    fn from(val: f64) -> Self {
+        Self::F64(val)
+    }
+}
+
+impl From<Function> for Value {
+    fn from(val: Function) -> Self {
+        Self::FuncRef(Some(val))
+    }
+}
+
+impl From<Option<Function>> for Value {
+    fn from(val: Option<Function>) -> Self {
+        Self::FuncRef(val)
+    }
+}
+
+impl From<ExternRef> for Value {
+    fn from(val: ExternRef) -> Self {
+        Self::ExternRef(Some(val))
+    }
+}
+
+impl From<Option<ExternRef>> for Value {
+    fn from(val: Option<ExternRef>) -> Self {
+        Self::ExternRef(val)
+    }
+}
+
+const NOT_I32: &str = "Value is not of Wasm type i32";
+const NOT_I64: &str = "Value is not of Wasm type i64";
+const NOT_F32: &str = "Value is not of Wasm type f32";
+const NOT_F64: &str = "Value is not of Wasm type f64";
+const NOT_FUNCREF: &str = "Value is not of Wasm type funcref";
+const NOT_EXTERNREF: &str = "Value is not of Wasm type externref";
+
+impl TryFrom<Value> for i32 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.i32().ok_or(NOT_I32)
+    }
+}
+
+impl TryFrom<Value> for u32 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.i32().ok_or(NOT_I32).map(|int| int as Self)
+    }
+}
+
+impl TryFrom<Value> for i64 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.i64().ok_or(NOT_I64)
+    }
+}
+
+impl TryFrom<Value> for u64 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.i64().ok_or(NOT_I64).map(|int| int as Self)
+    }
+}
+
+impl TryFrom<Value> for f32 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.f32().ok_or(NOT_F32)
+    }
+}
+
+impl TryFrom<Value> for f64 {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        value.f64().ok_or(NOT_F64)
+    }
+}
+
+impl TryFrom<Value> for Option<Function> {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        match value {
+            Value::FuncRef(f) => Ok(f),
+            _ => Err(NOT_FUNCREF),
+        }
+    }
+}
+
+impl TryFrom<Value> for Option<ExternRef> {
+    type Error = &'static str;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        match value {
+            Value::ExternRef(e) => Ok(e),
+            _ => Err(NOT_EXTERNREF),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_value_i32_from_u32() {
+        let bytes = [0x00, 0x00, 0x00, 0x00];
+        let v = Value::from(u32::from_be_bytes(bytes));
+        assert_eq!(v, Value::I32(i32::from_be_bytes(bytes)));
+
+        let bytes = [0x00, 0x00, 0x00, 0x01];
+        let v = Value::from(u32::from_be_bytes(bytes));
+        assert_eq!(v, Value::I32(i32::from_be_bytes(bytes)));
+
+        let bytes = [0xAA, 0xBB, 0xCC, 0xDD];
+        let v = Value::from(u32::from_be_bytes(bytes));
+        assert_eq!(v, Value::I32(i32::from_be_bytes(bytes)));
+
+        let bytes = [0xFF, 0xFF, 0xFF, 0xFF];
+        let v = Value::from(u32::from_be_bytes(bytes));
+        assert_eq!(v, Value::I32(i32::from_be_bytes(bytes)));
+    }
+
+    #[test]
+    fn test_value_i64_from_u64() {
+        let bytes = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        let v = Value::from(u64::from_be_bytes(bytes));
+        assert_eq!(v, Value::I64(i64::from_be_bytes(bytes)));
+
+        let bytes = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01];
+        let v = Value::from(u64::from_be_bytes(bytes));
+        assert_eq!(v, Value::I64(i64::from_be_bytes(bytes)));
+
+        let bytes = [0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00, 0x11];
+        let v = Value::from(u64::from_be_bytes(bytes));
+        assert_eq!(v, Value::I64(i64::from_be_bytes(bytes)));
+
+        let bytes = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+        let v = Value::from(u64::from_be_bytes(bytes));
+        assert_eq!(v, Value::I64(i64::from_be_bytes(bytes)));
+    }
+
+    #[test]
+    fn convert_value_to_i32() {
+        let value = Value::I32(5678);
+        let result = i32::try_from(value);
+        assert_eq!(result.unwrap(), 5678);
+
+        let value = Value::from(u32::MAX);
+        let result = i32::try_from(value);
+        assert_eq!(result.unwrap(), -1);
+
+        let value = Value::V128(42);
+        let result = i32::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type i32");
+    }
+
+    #[test]
+    fn convert_value_to_u32() {
+        let value = Value::from(u32::MAX);
+        let result = u32::try_from(value);
+        assert_eq!(result.unwrap(), u32::MAX);
+
+        let value = Value::I32(-1);
+        let result = u32::try_from(value);
+        assert_eq!(result.unwrap(), u32::MAX);
+
+        let value = Value::V128(42);
+        let result = u32::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type i32");
+    }
+
+    #[test]
+    fn convert_value_to_i64() {
+        let value = Value::I64(5678);
+        let result = i64::try_from(value);
+        assert_eq!(result.unwrap(), 5678);
+
+        let value = Value::from(u64::MAX);
+        let result = i64::try_from(value);
+        assert_eq!(result.unwrap(), -1);
+
+        let value = Value::V128(42);
+        let result = i64::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type i64");
+    }
+
+    #[test]
+    fn convert_value_to_u64() {
+        let value = Value::from(u64::MAX);
+        let result = u64::try_from(value);
+        assert_eq!(result.unwrap(), u64::MAX);
+
+        let value = Value::I64(-1);
+        let result = u64::try_from(value);
+        assert_eq!(result.unwrap(), u64::MAX);
+
+        let value = Value::V128(42);
+        let result = u64::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type i64");
+    }
+
+    #[test]
+    fn convert_value_to_f32() {
+        let value = Value::F32(1.234);
+        let result = f32::try_from(value);
+        assert_eq!(result.unwrap(), 1.234);
+
+        let value = Value::V128(42);
+        let result = f32::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type f32");
+
+        let value = Value::F64(1.234);
+        let result = f32::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type f32");
+    }
+
+    #[test]
+    fn convert_value_to_f64() {
+        let value = Value::F64(1.234);
+        let result = f64::try_from(value);
+        assert_eq!(result.unwrap(), 1.234);
+
+        let value = Value::V128(42);
+        let result = f64::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type f64");
+
+        let value = Value::F32(1.234);
+        let result = f64::try_from(value);
+        assert_eq!(result.unwrap_err(), "Value is not of Wasm type f64");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/src/vm.rs b/arbitrator/tools/module_roots/wasmer/lib/api/src/vm.rs
new file mode 100644
index 0000000..2347c0b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/src/vm.rs
@@ -0,0 +1,40 @@
+//! The `vm` module re-exports wasmer-vm types.
+
+#[cfg(feature = "js")]
+pub(crate) use crate::js::vm::{
+    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
+    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
+};
+
+#[cfg(feature = "jsc")]
+pub(crate) use crate::jsc::vm::{
+    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
+    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
+};
+
+#[cfg(feature = "sys")]
+pub(crate) use crate::sys::vm::{
+    VMExtern, VMExternFunction, VMExternGlobal, VMExternMemory, VMExternRef, VMExternTable,
+    VMFuncRef, VMFunctionCallback, VMFunctionEnvironment, VMInstance, VMTrampoline,
+};
+
+#[cfg(feature = "js")]
+pub use crate::js::vm::{VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
+
+#[cfg(feature = "sys")]
+pub use wasmer_vm::{VMConfig, VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
+
+#[cfg(feature = "jsc")]
+pub use crate::jsc::vm::{VMFunction, VMGlobal, VMMemory, VMSharedMemory, VMTable};
+
+// Needed for tunables customization (those are public types now)
+#[cfg(feature = "sys")]
+pub use wasmer_vm::{
+    // An extra one for VMMemory implementors
+    LinearMemory,
+    VMMemoryDefinition,
+    VMTableDefinition,
+};
+
+// Deprecated exports
+pub use wasmer_types::{MemoryError, MemoryStyle, TableStyle};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/externals.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/externals.rs
new file mode 100644
index 0000000..9a991dc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/externals.rs
@@ -0,0 +1,402 @@
+use macro_wasmer_universal_test::universal_test;
+#[cfg(feature = "js")]
+use wasm_bindgen_test::*;
+
+use wasmer::*;
+
+#[universal_test]
+fn global_new() -> Result<(), String> {
+    let mut store = Store::default();
+    let global = Global::new(&mut store, Value::I32(10));
+    assert_eq!(
+        global.ty(&store),
+        GlobalType {
+            ty: Type::I32,
+            mutability: Mutability::Const
+        }
+    );
+
+    let global_mut = Global::new_mut(&mut store, Value::I32(10));
+    assert_eq!(
+        global_mut.ty(&store),
+        GlobalType {
+            ty: Type::I32,
+            mutability: Mutability::Var
+        }
+    );
+
+    Ok(())
+}
+
+#[universal_test]
+fn global_get() -> Result<(), String> {
+    let mut store = Store::default();
+
+    let global_i32 = Global::new(&mut store, Value::I32(10));
+    assert_eq!(global_i32.get(&mut store), Value::I32(10));
+
+    // 64-bit values are not yet fully supported in some versions of Node
+    #[cfg(feature = "sys")]
+    {
+        let global_i64 = Global::new(&mut store, Value::I64(20));
+        assert_eq!(global_i64.get(&mut store), Value::I64(20));
+    }
+
+    let global_f32 = Global::new(&mut store, Value::F32(10.0));
+    assert_eq!(global_f32.get(&mut store), Value::F32(10.0));
+
+    // 64-bit values are not yet fully supported in some versions of Node
+    #[cfg(feature = "sys")]
+    {
+        let global_f64 = Global::new(&mut store, Value::F64(20.0));
+        assert_eq!(global_f64.get(&mut store), Value::F64(20.0));
+    }
+
+    Ok(())
+}
+
+#[universal_test]
+fn global_set() -> Result<(), String> {
+    let mut store = Store::default();
+    let global_i32 = Global::new(&mut store, Value::I32(10));
+    // Set on a constant should error
+    assert!(global_i32.set(&mut store, Value::I32(20)).is_err());
+
+    let global_i32_mut = Global::new_mut(&mut store, Value::I32(10));
+    // Set on different type should error
+    assert!(global_i32_mut.set(&mut store, Value::I64(20)).is_err());
+
+    // Set on same type should succeed
+    global_i32_mut
+        .set(&mut store, Value::I32(20))
+        .map_err(|e| format!("{e:?}"))?;
+    assert_eq!(global_i32_mut.get(&mut store), Value::I32(20));
+
+    Ok(())
+}
+
+#[universal_test]
+fn table_new() -> Result<(), String> {
+    let mut store = Store::default();
+    let table_type = TableType {
+        ty: Type::FuncRef,
+        minimum: 0,
+        maximum: None,
+    };
+    let f = Function::new_typed(&mut store, || {});
+    let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f)))
+        .map_err(|e| format!("{e:?}"))?;
+    assert_eq!(table.ty(&store), table_type);
+
+    // Anyrefs not yet supported
+    // let table_type = TableType {
+    //     ty: Type::ExternRef,
+    //     minimum: 0,
+    //     maximum: None,
+    // };
+    // let table = Table::new(&store, table_type, Value::ExternRef(ExternRef::Null)).map_err(|e| format!("{e:?}"))?;
+    // assert_eq!(*table.ty(), table_type);
+
+    Ok(())
+}
+
+#[universal_test]
+fn table_get() -> Result<(), String> {
+    // Tables are not yet fully supported in Wasm
+    // This test was marked as #[ignore] on -sys, which is why it is commented out.
+
+    //    let mut store = Store::default();
+    //    let table_type = TableType {
+    //        ty: Type::FuncRef,
+    //        minimum: 0,
+    //        maximum: Some(1),
+    //    };
+    //    let f = Function::new_typed(&mut store, |num: i32| num + 1);
+    //    let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f)))
+    //        .map_err(|e| format!("{e:?}"))?;
+    //    assert_eq!(table.ty(&mut store), table_type);
+    //    let _elem = table.get(&mut store, 0).unwrap();
+    //    assert_eq!(elem.funcref().unwrap(), f);
+
+    Ok(())
+}
+
+#[universal_test]
+fn table_set() -> Result<(), String> {
+    // Table set not yet tested
+    Ok(())
+}
+
+#[universal_test]
+fn table_grow() -> Result<(), String> {
+    // Tables are not yet fully supported in Wasm
+    #[cfg(feature = "sys")]
+    {
+        let mut store = Store::default();
+        let table_type = TableType {
+            ty: Type::FuncRef,
+            minimum: 0,
+            maximum: Some(10),
+        };
+        let f = Function::new_typed(&mut store, |num: i32| num + 1);
+        let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f.clone())))
+            .map_err(|e| format!("{e:?}"))?;
+        // Growing to a bigger maximum should return None
+        let old_len = table.grow(&mut store, 12, Value::FuncRef(Some(f.clone())));
+        assert!(old_len.is_err());
+
+        // Growing to a bigger maximum should return None
+        let old_len = table
+            .grow(&mut store, 5, Value::FuncRef(Some(f)))
+            .map_err(|e| format!("{e:?}"))?;
+        assert_eq!(old_len, 0);
+    }
+
+    Ok(())
+}
+
+#[universal_test]
+fn table_copy() -> Result<(), String> {
+    // TODO: table copy test not yet implemented
+    Ok(())
+}
+
+#[universal_test]
+fn memory_new() -> Result<(), String> {
+    let mut store = Store::default();
+    let memory_type = MemoryType {
+        shared: false,
+        minimum: Pages(0),
+        maximum: Some(Pages(10)),
+    };
+    let memory = Memory::new(&mut store, memory_type).map_err(|e| format!("{e:?}"))?;
+    assert_eq!(memory.view(&store).size(), Pages(0));
+    assert_eq!(memory.ty(&store), memory_type);
+    Ok(())
+}
+
+#[universal_test]
+fn memory_grow() -> Result<(), String> {
+    let mut store = Store::default();
+    let desc = MemoryType::new(Pages(10), Some(Pages(16)), false);
+    let memory = Memory::new(&mut store, desc).map_err(|e| format!("{e:?}"))?;
+    assert_eq!(memory.view(&store).size(), Pages(10));
+
+    let result = memory.grow(&mut store, Pages(2)).unwrap();
+    assert_eq!(result, Pages(10));
+    assert_eq!(memory.view(&store).size(), Pages(12));
+
+    let result = memory.grow(&mut store, Pages(10));
+    assert_eq!(
+        result,
+        Err(MemoryError::CouldNotGrow {
+            current: 12.into(),
+            attempted_delta: 10.into()
+        })
+    );
+
+    // JS will never give BadMemory unless V8 is broken somehow
+    #[cfg(feature = "sys")]
+    {
+        let bad_desc = MemoryType::new(Pages(15), Some(Pages(10)), false);
+        let bad_result = Memory::new(&mut store, bad_desc);
+        assert!(matches!(bad_result, Err(MemoryError::InvalidMemory { .. })));
+    }
+
+    Ok(())
+}
+
+#[universal_test]
+fn function_new() -> Result<(), String> {
+    let mut store = Store::default();
+    let function = Function::new_typed(&mut store, || {});
+    assert_eq!(function.ty(&store), FunctionType::new(vec![], vec![]));
+    let function = Function::new_typed(&mut store, |_a: i32| {});
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![Type::I32], vec![])
+    );
+    let function = Function::new_typed(&mut store, |_a: i32, _b: i64, _c: f32, _d: f64| {});
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
+    );
+    let function = Function::new_typed(&mut store, || -> i32 { 1 });
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![], vec![Type::I32])
+    );
+    let function = Function::new_typed(&mut store, || -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) });
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
+    );
+    Ok(())
+}
+
+#[universal_test]
+fn function_new_env() -> Result<(), String> {
+    let mut store = Store::default();
+    #[derive(Clone)]
+    struct MyEnv {}
+
+    let my_env = MyEnv {};
+    let env = FunctionEnv::new(&mut store, my_env);
+    let function = Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>| {});
+    assert_eq!(function.ty(&store), FunctionType::new(vec![], vec![]));
+    let function =
+        Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>, _a: i32| {});
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![Type::I32], vec![])
+    );
+    let function = Function::new_typed_with_env(
+        &mut store,
+        &env,
+        |_env: FunctionEnvMut<MyEnv>, _a: i32, _b: i64, _c: f32, _d: f64| {},
+    );
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
+    );
+    let function =
+        Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<MyEnv>| -> i32 { 1 });
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![], vec![Type::I32])
+    );
+    let function = Function::new_typed_with_env(
+        &mut store,
+        &env,
+        |_env: FunctionEnvMut<MyEnv>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
+    );
+    assert_eq!(
+        function.ty(&store),
+        FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
+    );
+    Ok(())
+}
+
+#[universal_test]
+fn function_new_dynamic() -> Result<(), String> {
+    let mut store = Store::default();
+
+    // Using &FunctionType signature
+    let function_type = FunctionType::new(vec![], vec![]);
+    let function = Function::new(
+        &mut store,
+        &function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![Type::I32], vec![]);
+    let function = Function::new(
+        &mut store,
+        &function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
+    let function = Function::new(
+        &mut store,
+        &function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![], vec![Type::I32]);
+    let function = Function::new(
+        &mut store,
+        &function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
+    let function = Function::new(
+        &mut store,
+        &function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+
+    // Using array signature
+    let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
+    let function = Function::new(
+        &mut store,
+        function_type,
+        |_values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store).params(), [Type::V128]);
+    assert_eq!(
+        function.ty(&store).results(),
+        [Type::I32, Type::F32, Type::F64]
+    );
+
+    Ok(())
+}
+
+#[universal_test]
+fn function_new_dynamic_env() -> Result<(), String> {
+    let mut store = Store::default();
+    #[derive(Clone)]
+    struct MyEnv {}
+    let my_env = MyEnv {};
+    let env = FunctionEnv::new(&mut store, my_env);
+
+    // Using &FunctionType signature
+    let function_type = FunctionType::new(vec![], vec![]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        &function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![Type::I32], vec![]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        &function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        &function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![], vec![Type::I32]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        &function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+    let function_type = FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        &function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store), function_type);
+
+    // Using array signature
+    let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
+    let function = Function::new_with_env(
+        &mut store,
+        &env,
+        function_type,
+        |_env: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
+    );
+    assert_eq!(function.ty(&store).params(), [Type::V128]);
+    assert_eq!(
+        function.ty(&store).results(),
+        [Type::I32, Type::F32, Type::F64]
+    );
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/function_env.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/function_env.rs
new file mode 100644
index 0000000..87e1904
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/function_env.rs
@@ -0,0 +1,43 @@
+use macro_wasmer_universal_test::universal_test;
+#[cfg(feature = "js")]
+use wasm_bindgen_test::*;
+
+use wasmer::*;
+
+#[universal_test]
+fn data_and_store_mut() -> Result<(), String> {
+    let mut store = Store::default();
+    let global_mut = Global::new_mut(&mut store, Value::I32(10));
+    struct Env {
+        value: i32,
+        global: Global,
+    }
+    let env = FunctionEnv::new(
+        &mut store,
+        Env {
+            value: 0i32,
+            global: global_mut,
+        },
+    );
+    let mut envmut = env.into_mut(&mut store);
+
+    let (mut data, mut storemut) = envmut.data_and_store_mut();
+
+    assert_eq!(
+        data.global.ty(&storemut),
+        GlobalType {
+            ty: Type::I32,
+            mutability: Mutability::Var
+        }
+    );
+    assert_eq!(data.global.get(&mut storemut), Value::I32(10));
+    data.value = data.global.get(&mut storemut).unwrap_i32() + 10;
+
+    data.global
+        .set(&mut storemut, Value::I32(data.value))
+        .unwrap();
+
+    assert_eq!(data.global.get(&mut storemut), Value::I32(data.value));
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/import_function.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/import_function.rs
new file mode 100644
index 0000000..007b82c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/import_function.rs
@@ -0,0 +1,151 @@
+use macro_wasmer_universal_test::universal_test;
+#[cfg(feature = "js")]
+use wasm_bindgen_test::*;
+
+use anyhow::Result;
+use wasmer::*;
+
+#[universal_test]
+fn pass_i64_between_host_and_plugin() -> Result<(), String> {
+    let mut store = Store::default();
+
+    let wat = r#"(module
+        (func $add_one_i64 (import "host" "add_one_i64") (param i64) (result i64))
+        (func (export "add_three_i64") (param i64) (result i64)
+            (i64.add (call $add_one_i64 (i64.add (local.get 0) (i64.const 1))) (i64.const 1))
+        )
+    )"#;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+
+    let imports = {
+        imports! {
+            "host" => {
+                "add_one_i64" => Function::new_typed(&mut store, |value: i64| value.wrapping_add(1)),
+            },
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &imports).map_err(|e| format!("{e:?}"))?;
+    let add_three_i64 = instance
+        .exports
+        .get_typed_function::<i64, i64>(&store, "add_three_i64")
+        .map_err(|e| format!("{e:?}"))?;
+
+    let mut numbers = Vec::<i64>::new();
+    numbers.extend(-4..=4);
+    numbers.extend((i64::MAX - 4)..=i64::MAX);
+    numbers.extend((i64::MIN)..=(i64::MIN + 4));
+
+    for number in numbers {
+        let wasm_result = add_three_i64
+            .call(&mut store, number)
+            .map_err(|e| format!("{e:?}"))?;
+        let compare_result = number.wrapping_add(3);
+
+        assert_eq!(wasm_result, compare_result)
+    }
+    Ok(())
+}
+
+#[universal_test]
+fn pass_u64_between_host_and_plugin() -> Result<(), String> {
+    let mut store = Store::default();
+
+    let wat = r#"(module
+        (func $add_one_u64 (import "host" "add_one_u64") (param i64) (result i64))
+        (func (export "add_three_u64") (param i64) (result i64)
+            (i64.add (call $add_one_u64 (i64.add (local.get 0) (i64.const 1))) (i64.const 1))
+        )
+    )"#;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+
+    let imports = {
+        imports! {
+            "host" => {
+                "add_one_u64" => Function::new_typed(&mut store, |value: u64| value.wrapping_add(1)),
+            },
+        }
+    };
+
+    let instance = Instance::new(&mut store, &module, &imports).map_err(|e| format!("{e:?}"))?;
+    let add_three_u64 = instance
+        .exports
+        .get_typed_function::<u64, u64>(&store, "add_three_u64")
+        .map_err(|e| format!("{e:?}"))?;
+
+    let mut numbers = Vec::<u64>::new();
+    numbers.extend(0..=4);
+    numbers.extend((u64::MAX / 2 - 4)..=(u64::MAX / 2 + 4));
+    numbers.extend((u64::MAX - 4)..=u64::MAX);
+
+    for number in numbers {
+        let wasm_result = add_three_u64
+            .call(&mut store, number)
+            .map_err(|e| format!("{e:?}"))?;
+        let compare_result = number.wrapping_add(3);
+
+        assert_eq!(wasm_result, compare_result)
+    }
+    Ok(())
+}
+
+#[universal_test]
+fn calling_function_exports() -> Result<()> {
+    let mut store = Store::default();
+    let wat = r#"(module
+    (func (export "add") (param $lhs i32) (param $rhs i32) (result i32)
+        local.get $lhs
+        local.get $rhs
+        i32.add)
+)"#;
+    let module = Module::new(&store, wat)?;
+    let imports = imports! {
+        // "host" => {
+        //     "host_func1" => Function::new_typed(&mut store, |p: u64| {
+        //         println!("host_func1: Found number {}", p);
+        //         // assert_eq!(p, u64::max_value());
+        //     }),
+        // }
+    };
+    let instance = Instance::new(&mut store, &module, &imports)?;
+
+    let add: TypedFunction<(i32, i32), i32> = instance.exports.get_typed_function(&store, "add")?;
+
+    let result = add.call(&mut store, 10, 20)?;
+    assert_eq!(result, 30);
+
+    Ok(())
+}
+
+#[universal_test]
+fn back_and_forth_with_imports() -> Result<()> {
+    let mut store = Store::default();
+    // We can use the WAT syntax as well!
+    let module = Module::new(
+        &store,
+        br#"(module
+            (func $sum (import "env" "sum") (param i32 i32) (result i32))
+            (func (export "add_one") (param i32) (result i32)
+                (call $sum (local.get 0) (i32.const 1))
+            )
+        )"#,
+    )?;
+
+    fn sum(a: i32, b: i32) -> i32 {
+        println!("Summing: {}+{}", a, b);
+        a + b
+    }
+
+    let import_object = imports! {
+        "env" => {
+            "sum" => Function::new_typed(&mut store, sum),
+        }
+    };
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let add_one: TypedFunction<i32, i32> =
+        instance.exports.get_typed_function(&store, "add_one")?;
+    add_one.call(&mut store, 1)?;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/instance.rs
new file mode 100644
index 0000000..bffdfd8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/instance.rs
@@ -0,0 +1,80 @@
+use macro_wasmer_universal_test::universal_test;
+#[cfg(feature = "js")]
+use wasm_bindgen_test::*;
+
+use wasmer::*;
+
+#[universal_test]
+fn exports_work_after_multiple_instances_have_been_freed() -> Result<(), String> {
+    let mut store = Store::default();
+    let module = Module::new(
+        &store,
+        "
+(module
+  (type $sum_t (func (param i32 i32) (result i32)))
+  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+    local.get $x
+    local.get $y
+    i32.add)
+  (export \"sum\" (func $sum_f)))
+",
+    )
+    .map_err(|e| format!("{e:?}"))?;
+
+    let imports = Imports::new();
+    let instance = Instance::new(&mut store, &module, &imports).map_err(|e| format!("{e:?}"))?;
+    let instance2 = instance.clone();
+    let instance3 = instance.clone();
+
+    // The function is cloned to “break” the connection with `instance`.
+    let sum = instance
+        .exports
+        .get_function("sum")
+        .map_err(|e| format!("{e:?}"))?
+        .clone();
+
+    drop(instance);
+    drop(instance2);
+    drop(instance3);
+
+    // All instances have been dropped, but `sum` continues to work!
+    assert_eq!(
+        sum.call(&mut store, &[Value::I32(1), Value::I32(2)])
+            .map_err(|e| format!("{e:?}"))?
+            .into_vec(),
+        vec![Value::I32(3)],
+    );
+
+    Ok(())
+}
+
+#[universal_test]
+fn unit_native_function_env() -> Result<(), String> {
+    let mut store = Store::default();
+
+    #[derive(Clone)]
+    struct Env {
+        multiplier: u32,
+    }
+
+    fn imported_fn(env: FunctionEnvMut<Env>, args: &[Value]) -> Result<Vec<Value>, RuntimeError> {
+        let value = env.data().multiplier * args[0].unwrap_i32() as u32;
+        Ok(vec![Value::I32(value as _)])
+    }
+
+    // We create the environment
+    let env = Env { multiplier: 3 };
+    // We move the environment to the store, so it can be used by the `Function`
+    let env = FunctionEnv::new(&mut store, env);
+
+    let imported_signature = FunctionType::new(vec![Type::I32], vec![Type::I32]);
+    let imported = Function::new_with_env(&mut store, &env, imported_signature, imported_fn);
+
+    let expected = vec![Value::I32(12)].into_boxed_slice();
+    let result = imported
+        .call(&mut store, &[Value::I32(4)])
+        .map_err(|e| format!("{e:?}"))?;
+    assert_eq!(result, expected);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/memory.rs
new file mode 100644
index 0000000..bf5f6ec
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/memory.rs
@@ -0,0 +1,78 @@
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use wasmer::{imports, Instance, Memory, MemoryLocation, MemoryType, Module, Store};
+
+#[test]
+fn test_shared_memory_atomics_notify_send() {
+    let mut store = Store::default();
+    let wat = r#"(module
+(import "host" "memory" (memory 10 65536 shared))
+)"#;
+    let module = Module::new(&store, wat)
+        .map_err(|e| format!("{e:?}"))
+        .unwrap();
+
+    let mem = Memory::new(&mut store, MemoryType::new(10, Some(65536), true)).unwrap();
+
+    let imports = imports! {
+        "host" => {
+            "memory" => mem.clone(),
+        },
+    };
+
+    let _inst = Instance::new(&mut store, &module, &imports).unwrap();
+
+    let mem = if let Some(m) = mem.as_shared(&store) {
+        m
+    } else {
+        #[cfg(feature = "sys")]
+        panic!("Memory is not shared");
+        #[cfg(not(feature = "sys"))]
+        return;
+    };
+
+    // Test basic notify.
+    let mem2 = mem.clone();
+    std::thread::spawn(move || loop {
+        if mem2.notify(MemoryLocation::new_32(10), 1).unwrap() > 0 {
+            break;
+        }
+    });
+
+    mem.wait(MemoryLocation::new_32(10), None).unwrap();
+
+    // Test wake_all
+
+    let done = Arc::new(AtomicBool::new(false));
+
+    std::thread::spawn({
+        let mem = mem.clone();
+        let done = done.clone();
+        move || {
+            while !done.load(Ordering::SeqCst) {
+                mem.wake_all_atomic_waiters().ok();
+            }
+        }
+    });
+
+    mem.wait(MemoryLocation::new_32(10), None).unwrap();
+    done.store(true, Ordering::SeqCst);
+}
+
+#[cfg(feature = "sys")]
+#[test]
+fn test_shared_memory_disable_atomics() {
+    use wasmer::AtomicsError;
+
+    let mut store = Store::default();
+    let mem = Memory::new(&mut store, MemoryType::new(10, Some(65536), true)).unwrap();
+
+    let mem = mem.as_shared(&store).unwrap();
+    mem.disable_atomics().unwrap();
+
+    let err = mem.wait(MemoryLocation::new_32(1), None).unwrap_err();
+    assert_eq!(err, AtomicsError::AtomicsDisabled);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/module.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/module.rs
new file mode 100644
index 0000000..22683f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/module.rs
@@ -0,0 +1,292 @@
+use macro_wasmer_universal_test::universal_test;
+#[cfg(feature = "js")]
+use wasm_bindgen_test::*;
+
+use wasmer::*;
+
+#[universal_test]
+fn module_get_name() -> Result<(), String> {
+    let store = Store::default();
+    let wat = r#"(module)"#;
+    let module = Module::new(&store, wat)
+        .map_err(|e| format!("{e:?}"))
+        .map_err(|e| format!("{e:?}"))?;
+    assert_eq!(module.name(), None);
+
+    Ok(())
+}
+
+#[universal_test]
+fn module_set_name() -> Result<(), String> {
+    let store = Store::default();
+    let wat = r#"(module $name)"#;
+    let mut module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+    assert_eq!(module.name(), Some("name"));
+
+    module.set_name("new_name");
+    assert_eq!(module.name(), Some("new_name"));
+
+    Ok(())
+}
+
+#[universal_test]
+fn imports() -> Result<(), String> {
+    let store = Store::default();
+    let wat = r#"(module
+(import "host" "func" (func))
+(import "host" "memory" (memory 1))
+(import "host" "table" (table 1 anyfunc))
+(import "host" "global" (global i32))
+)"#;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+    assert_eq!(
+        module.imports().collect::<Vec<_>>(),
+        vec![
+            ImportType::new(
+                "host",
+                "func",
+                ExternType::Function(FunctionType::new(vec![], vec![]))
+            ),
+            ImportType::new(
+                "host",
+                "memory",
+                ExternType::Memory(MemoryType::new(Pages(1), None, false))
+            ),
+            ImportType::new(
+                "host",
+                "table",
+                ExternType::Table(TableType::new(Type::FuncRef, 1, None))
+            ),
+            ImportType::new(
+                "host",
+                "global",
+                ExternType::Global(GlobalType::new(Type::I32, Mutability::Const))
+            )
+        ]
+    );
+
+    // Now we test the iterators
+    assert_eq!(
+        module.imports().functions().collect::<Vec<_>>(),
+        vec![ImportType::new(
+            "host",
+            "func",
+            FunctionType::new(vec![], vec![])
+        ),]
+    );
+    assert_eq!(
+        module.imports().memories().collect::<Vec<_>>(),
+        vec![ImportType::new(
+            "host",
+            "memory",
+            MemoryType::new(Pages(1), None, false)
+        ),]
+    );
+    assert_eq!(
+        module.imports().tables().collect::<Vec<_>>(),
+        vec![ImportType::new(
+            "host",
+            "table",
+            TableType::new(Type::FuncRef, 1, None)
+        ),]
+    );
+    assert_eq!(
+        module.imports().globals().collect::<Vec<_>>(),
+        vec![ImportType::new(
+            "host",
+            "global",
+            GlobalType::new(Type::I32, Mutability::Const)
+        ),]
+    );
+    Ok(())
+}
+
+#[test]
+fn exports() -> Result<(), String> {
+    let store = Store::default();
+    let wat = r#"(module
+(func (export "func") nop)
+(memory (export "memory") 1)
+(table (export "table") 1 funcref)
+(global (export "global") i32 (i32.const 0))
+)"#;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+    assert_eq!(
+        module.exports().collect::<Vec<_>>(),
+        vec![
+            ExportType::new(
+                "func",
+                ExternType::Function(FunctionType::new(vec![], vec![]))
+            ),
+            ExportType::new(
+                "memory",
+                ExternType::Memory(MemoryType::new(Pages(1), None, false))
+            ),
+            ExportType::new(
+                "table",
+                ExternType::Table(TableType::new(Type::FuncRef, 1, None))
+            ),
+            ExportType::new(
+                "global",
+                ExternType::Global(GlobalType::new(Type::I32, Mutability::Const))
+            )
+        ]
+    );
+
+    // Now we test the iterators
+    assert_eq!(
+        module.exports().functions().collect::<Vec<_>>(),
+        vec![ExportType::new("func", FunctionType::new(vec![], vec![])),]
+    );
+    assert_eq!(
+        module.exports().memories().collect::<Vec<_>>(),
+        vec![ExportType::new(
+            "memory",
+            MemoryType::new(Pages(1), None, false)
+        ),]
+    );
+    assert_eq!(
+        module.exports().tables().collect::<Vec<_>>(),
+        vec![ExportType::new(
+            "table",
+            TableType::new(Type::FuncRef, 1, None)
+        ),]
+    );
+    assert_eq!(
+        module.exports().globals().collect::<Vec<_>>(),
+        vec![ExportType::new(
+            "global",
+            GlobalType::new(Type::I32, Mutability::Const)
+        ),]
+    );
+    Ok(())
+}
+
+#[universal_test]
+fn calling_host_functions_with_negative_values_works() -> Result<(), String> {
+    let mut store = Store::default();
+    let wat = r#"(module
+(import "host" "host_func1" (func (param i64)))
+(import "host" "host_func2" (func (param i32)))
+(import "host" "host_func3" (func (param i64)))
+(import "host" "host_func4" (func (param i32)))
+(import "host" "host_func5" (func (param i32)))
+(import "host" "host_func6" (func (param i32)))
+(import "host" "host_func7" (func (param i32)))
+(import "host" "host_func8" (func (param i32)))
+
+(func (export "call_host_func1")
+      (call 0 (i64.const -1)))
+(func (export "call_host_func2")
+      (call 1 (i32.const -1)))
+(func (export "call_host_func3")
+      (call 2 (i64.const -1)))
+(func (export "call_host_func4")
+      (call 3 (i32.const -1)))
+(func (export "call_host_func5")
+      (call 4 (i32.const -1)))
+(func (export "call_host_func6")
+      (call 5 (i32.const -1)))
+(func (export "call_host_func7")
+      (call 6 (i32.const -1)))
+(func (export "call_host_func8")
+      (call 7 (i32.const -1)))
+)"#;
+    let module = Module::new(&store, wat).map_err(|e| format!("{e:?}"))?;
+    let imports = imports! {
+        "host" => {
+            "host_func1" => Function::new_typed(&mut store, |p: u64| {
+                println!("host_func1: Found number {}", p);
+                assert_eq!(p, u64::max_value());
+            }),
+            "host_func2" => Function::new_typed(&mut store, |p: u32| {
+                println!("host_func2: Found number {}", p);
+                assert_eq!(p, u32::max_value());
+            }),
+            "host_func3" => Function::new_typed(&mut store, |p: i64| {
+                println!("host_func3: Found number {}", p);
+                assert_eq!(p, -1);
+            }),
+            "host_func4" => Function::new_typed(&mut store, |p: i32| {
+                println!("host_func4: Found number {}", p);
+                assert_eq!(p, -1);
+            }),
+            "host_func5" => Function::new_typed(&mut store, |p: i16| {
+                println!("host_func5: Found number {}", p);
+                assert_eq!(p, -1);
+            }),
+            "host_func6" => Function::new_typed(&mut store, |p: u16| {
+                println!("host_func6: Found number {}", p);
+                assert_eq!(p, u16::max_value());
+            }),
+            "host_func7" => Function::new_typed(&mut store, |p: i8| {
+                println!("host_func7: Found number {}", p);
+                assert_eq!(p, -1);
+            }),
+            "host_func8" => Function::new_typed(&mut store, |p: u8| {
+                println!("host_func8: Found number {}", p);
+                assert_eq!(p, u8::max_value());
+            }),
+        }
+    };
+    let instance = Instance::new(&mut store, &module, &imports).map_err(|e| format!("{e:?}"))?;
+
+    let f1: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func1")
+        .map_err(|e| format!("{e:?}"))?;
+    let f2: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func2")
+        .map_err(|e| format!("{e:?}"))?;
+    let f3: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func3")
+        .map_err(|e| format!("{e:?}"))?;
+    let f4: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func4")
+        .map_err(|e| format!("{e:?}"))?;
+    let f5: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func5")
+        .map_err(|e| format!("{e:?}"))?;
+    let f6: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func6")
+        .map_err(|e| format!("{e:?}"))?;
+    let f7: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func7")
+        .map_err(|e| format!("{e:?}"))?;
+    let f8: TypedFunction<(), ()> = instance
+        .exports
+        .get_typed_function(&store, "call_host_func8")
+        .map_err(|e| format!("{e:?}"))?;
+
+    f1.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f2.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f3.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f4.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f5.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f6.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f7.call(&mut store).map_err(|e| format!("{e:?}"))?;
+    f8.call(&mut store).map_err(|e| format!("{e:?}"))?;
+
+    Ok(())
+}
+
+#[universal_test]
+fn module_custom_sections() -> Result<(), String> {
+    let store = Store::default();
+    let custom_section_wasm_bytes = include_bytes!("simple-name-section.wasm");
+    let module = Module::new(&store, custom_section_wasm_bytes).map_err(|e| format!("{e:?}"))?;
+    let sections = module.custom_sections("name");
+    let sections_vec: Vec<Box<[u8]>> = sections.collect();
+    assert_eq!(sections_vec.len(), 1);
+    assert_eq!(
+        sections_vec[0],
+        vec![2, 2, 36, 105, 1, 0, 0, 0].into_boxed_slice()
+    );
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/reference_types.rs b/arbitrator/tools/module_roots/wasmer/lib/api/tests/reference_types.rs
new file mode 100644
index 0000000..b713854
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/api/tests/reference_types.rs
@@ -0,0 +1,490 @@
+#[cfg(feature = "sys")]
+pub mod reference_types {
+
+    use anyhow::Result;
+    use macro_wasmer_universal_test::universal_test;
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Arc;
+    #[cfg(feature = "js")]
+    use wasm_bindgen_test::*;
+    use wasmer::*;
+
+    #[universal_test]
+    fn func_ref_passed_and_returned() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+(import "env" "func_ref_identity" (func (param funcref) (result funcref)))
+(type $ret_i32_ty (func (result i32)))
+(table $table (export "table") 2 2 funcref)
+
+(func (export "run") (param) (result funcref)
+      (call 0 (ref.null func)))
+(func (export "call_set_value") (param $fr funcref) (result i32)
+      (table.set $table (i32.const 0) (local.get $fr))
+      (call_indirect $table (type $ret_i32_ty) (i32.const 0)))
+)"#;
+        let module = Module::new(&store, wat)?;
+        #[derive(Clone, Debug)]
+        pub struct Env(Arc<AtomicBool>);
+        let env = Env(Arc::new(AtomicBool::new(false)));
+        let env = FunctionEnv::new(&mut store, env);
+        let imports = imports! {
+            "env" => {
+                "func_ref_identity" => Function::new_with_env(&mut store, &env, FunctionType::new([Type::FuncRef], [Type::FuncRef]), |_env: FunctionEnvMut<Env>, values: &[Value]| -> Result<Vec<_>, _> {
+                    Ok(vec![values[0].clone()])
+                })
+            },
+        };
+
+        let instance = Instance::new(&mut store, &module, &imports)?;
+
+        let f: &Function = instance.exports.get_function("run")?;
+        let results = f.call(&mut store, &[]).unwrap();
+        if let Value::FuncRef(fr) = &results[0] {
+            assert!(fr.is_none());
+        } else {
+            panic!("funcref not found!");
+        }
+
+        let func_to_call =
+            Function::new_typed_with_env(&mut store, &env, |env: FunctionEnvMut<Env>| -> i32 {
+                env.data().0.store(true, Ordering::SeqCst);
+                343
+            });
+        let call_set_value: &Function = instance.exports.get_function("call_set_value")?;
+        let results: Box<[Value]> =
+            call_set_value.call(&mut store, &[Value::FuncRef(Some(func_to_call))])?;
+        assert!(env.as_ref(&store.as_store_ref()).0.load(Ordering::SeqCst));
+        assert_eq!(&*results, &[Value::I32(343)]);
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn func_ref_passed_and_called() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+(func $func_ref_call (import "env" "func_ref_call") (param funcref) (result i32))
+(type $ret_i32_ty (func (result i32)))
+(table $table (export "table") 2 2 funcref)
+
+(func $product (param $x i32) (param $y i32) (result i32)
+      (i32.mul (local.get $x) (local.get $y)))
+;; TODO: figure out exactly why this statement is needed
+(elem declare func $product)
+(func (export "call_set_value") (param $fr funcref) (result i32)
+      (table.set $table (i32.const 0) (local.get $fr))
+      (call_indirect $table (type $ret_i32_ty) (i32.const 0)))
+(func (export "call_func") (param $fr funcref) (result i32)
+      (call $func_ref_call (local.get $fr)))
+(func (export "call_host_func_with_wasm_func") (result i32)
+      (call $func_ref_call (ref.func $product)))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let env = FunctionEnv::new(&mut store, ());
+        fn func_ref_call(
+            mut env: FunctionEnvMut<()>,
+            values: &[Value],
+        ) -> Result<Vec<Value>, RuntimeError> {
+            // TODO: look into `Box<[Value]>` being returned breakage
+            let f = values[0].unwrap_funcref().as_ref().unwrap();
+            let f: TypedFunction<(i32, i32), i32> = f.typed(&env)?;
+            Ok(vec![Value::I32(f.call(&mut env, 7, 9)?)])
+        }
+
+        let imports = imports! {
+            "env" => {
+                "func_ref_call" => Function::new_with_env(
+                    &mut store,
+                    &env,
+                    FunctionType::new([Type::FuncRef], [Type::I32]),
+                    func_ref_call
+                ),
+                // "func_ref_call_native" => Function::new_native(&mut store, |f: Function| -> Result<i32, RuntimeError> {
+                //     let f: TypedFunction::<(i32, i32), i32> = f.typed(&mut store)?;
+                //     f.call(&mut store, 7, 9)
+                // })
+            },
+        };
+
+        let instance = Instance::new(&mut store, &module, &imports)?;
+        {
+            fn sum(a: i32, b: i32) -> i32 {
+                a + b
+            }
+            let sum_func = Function::new_typed(&mut store, sum);
+
+            let call_func: &Function = instance.exports.get_function("call_func")?;
+            let result = call_func.call(&mut store, &[Value::FuncRef(Some(sum_func))])?;
+            assert_eq!(result[0].unwrap_i32(), 16);
+        }
+
+        {
+            let f: TypedFunction<(), i32> = instance
+                .exports
+                .get_typed_function(&store, "call_host_func_with_wasm_func")?;
+            let result = f.call(&mut store)?;
+            assert_eq!(result, 63);
+        }
+
+        Ok(())
+    }
+
+    #[macro_wasmer_universal_test::universal_test]
+    fn extern_ref_passed_and_returned() -> Result<()> {
+        use std::collections::HashMap;
+        let mut store = Store::default();
+        let wat = r#"(module
+    (func $extern_ref_identity (import "env" "extern_ref_identity") (param externref) (result externref))
+    (func $extern_ref_identity_native (import "env" "extern_ref_identity_native") (param externref) (result externref))
+    (func $get_new_extern_ref (import "env" "get_new_extern_ref") (result externref))
+    (func $get_new_extern_ref_native (import "env" "get_new_extern_ref_native") (result externref))
+
+    (func (export "run") (param) (result externref)
+          (call $extern_ref_identity (ref.null extern)))
+    (func (export "run_native") (param) (result externref)
+          (call $extern_ref_identity_native (ref.null extern)))
+    (func (export "get_hashmap") (param) (result externref)
+          (call $get_new_extern_ref))
+    (func (export "get_hashmap_native") (param) (result externref)
+          (call $get_new_extern_ref_native))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let env = FunctionEnv::new(&mut store, ());
+        let imports = imports! {
+            "env" => {
+                "extern_ref_identity" => Function::new_with_env(&mut store, &env, FunctionType::new([Type::ExternRef], [Type::ExternRef]), |_env, values| -> Result<Vec<_>, _> {
+                    Ok(vec![values[0].clone()])
+                }),
+                "extern_ref_identity_native" => Function::new_typed(&mut store, |er: Option<ExternRef>| -> Option<ExternRef> {
+                    er
+                }),
+                "get_new_extern_ref" => Function::new_with_env(&mut store, &env, FunctionType::new([], [Type::ExternRef]), |mut env, _| -> Result<Vec<_>, _> {
+                    let inner =
+                        [("hello".to_string(), "world".to_string()),
+                         ("color".to_string(), "orange".to_string())]
+                        .iter()
+                        .cloned()
+                        .collect::<HashMap<String, String>>();
+                    let new_extern_ref = ExternRef::new(&mut env, inner);
+                    Ok(vec![Value::ExternRef(Some(new_extern_ref))])
+                }),
+                "get_new_extern_ref_native" => Function::new_typed_with_env(&mut store, &env, |mut env: FunctionEnvMut<()>| -> Option<ExternRef> {
+                    let inner =
+                        [("hello".to_string(), "world".to_string()),
+                         ("color".to_string(), "orange".to_string())]
+                        .iter()
+                        .cloned()
+                        .collect::<HashMap<String, String>>();
+                    Some(ExternRef::new(&mut env.as_store_mut(), inner))
+                })
+            },
+        };
+
+        let instance = Instance::new(&mut store, &module, &imports)?;
+        for run in &["run", "run_native"] {
+            let f: &Function = instance.exports.get_function(run)?;
+            let results = f.call(&mut store, &[]).unwrap();
+            if let Value::ExternRef(er) = &results[0] {
+                assert!(er.is_none());
+            } else {
+                panic!("result is not an extern ref!");
+            }
+
+            let f: TypedFunction<(), Option<ExternRef>> =
+                instance.exports.get_typed_function(&store, run)?;
+            let result: Option<ExternRef> = f.call(&mut store)?;
+            assert!(result.is_none());
+        }
+
+        for get_hashmap in &["get_hashmap", "get_hashmap_native"] {
+            let f: &Function = instance.exports.get_function(get_hashmap)?;
+            let results = f.call(&mut store, &[]).unwrap();
+            if let Value::ExternRef(er) = &results[0] {
+                let inner: &HashMap<String, String> =
+                    er.as_ref().unwrap().downcast(&store).unwrap();
+                assert_eq!(inner["hello"], "world");
+                assert_eq!(inner["color"], "orange");
+            } else {
+                panic!("result is not an extern ref!");
+            }
+
+            let f: TypedFunction<(), Option<ExternRef>> =
+                instance.exports.get_typed_function(&store, get_hashmap)?;
+
+            let result: Option<ExternRef> = f.call(&mut store)?;
+            let inner: &HashMap<String, String> = result.unwrap().downcast(&store).unwrap();
+            assert_eq!(inner["hello"], "world");
+            assert_eq!(inner["color"], "orange");
+        }
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_basic() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (func (export "drop") (param $er externref) (result)
+          (drop (local.get $er)))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+        let f: TypedFunction<Option<ExternRef>, ()> =
+            instance.exports.get_typed_function(&store, "drop")?;
+
+        let er = ExternRef::new(&mut store, 3u32);
+        f.call(&mut store, Some(er.clone()))?;
+
+        let tmp: Option<&u32> = er.downcast(&store);
+        assert_eq!(tmp.unwrap(), &3);
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn refs_in_globals() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (global $er_global (export "er_global") (mut externref) (ref.null extern))
+    (global $fr_global (export "fr_global") (mut funcref) (ref.null func))
+    (global $fr_immutable_global (export "fr_immutable_global") funcref (ref.func $hello))
+    (func $hello (param) (result i32)
+          (i32.const 73))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+        {
+            let er_global: &Global = instance.exports.get_global("er_global")?;
+
+            if let Value::ExternRef(er) = er_global.get(&mut store) {
+                assert!(er.is_none());
+            } else {
+                panic!("Did not find extern ref in the global");
+            }
+            let extref = Some(ExternRef::new(&mut store, 3u32));
+            er_global.set(&mut store, Value::ExternRef(extref))?;
+
+            if let Value::ExternRef(er) = er_global.get(&mut store) {
+                let tmp: Option<&u32> = er.unwrap().downcast(&store);
+                assert_eq!(tmp.unwrap(), &3);
+            } else {
+                panic!("Did not find extern ref in the global");
+            }
+        }
+
+        {
+            let fr_global: &Global = instance.exports.get_global("fr_immutable_global")?;
+
+            if let Value::FuncRef(Some(f)) = fr_global.get(&mut store) {
+                let native_func: TypedFunction<(), u32> = f.typed(&store)?;
+                assert_eq!(native_func.call(&mut store)?, 73);
+            } else {
+                panic!("Did not find non-null func ref in the global");
+            }
+        }
+
+        {
+            let fr_global: &Global = instance.exports.get_global("fr_global")?;
+
+            if let Value::FuncRef(None) = fr_global.get(&mut store) {
+            } else {
+                panic!("Did not find a null func ref in the global");
+            }
+
+            let f = Function::new_typed(&mut store, |arg1: i32, arg2: i32| -> i32 { arg1 + arg2 });
+
+            fr_global.set(&mut store, Value::FuncRef(Some(f)))?;
+
+            if let Value::FuncRef(Some(f)) = fr_global.get(&mut store) {
+                let native: TypedFunction<(i32, i32), i32> = f.typed(&store)?;
+                assert_eq!(native.call(&mut store, 5, 7)?, 12);
+            } else {
+                panic!("Did not find extern ref in the global");
+            }
+        }
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_table_basic() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (global $global (export "global") (mut externref) (ref.null extern))
+    (table $table (export "table") 4 4 externref)
+    (func $insert (param $er externref) (param $idx i32)
+           (table.set $table (local.get $idx) (local.get $er)))
+    (func $intermediate (param $er externref) (param $idx i32)
+          (call $insert (local.get $er) (local.get $idx)))
+    (func $insert_into_table (export "insert_into_table") (param $er externref) (param $idx i32) (result externref)
+          (call $intermediate (local.get $er) (local.get $idx))
+          (local.get $er))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+
+        let f: TypedFunction<(Option<ExternRef>, i32), Option<ExternRef>> = instance
+            .exports
+            .get_typed_function(&store, "insert_into_table")?;
+
+        let er = ExternRef::new(&mut store, 3usize);
+
+        let er = f.call(&mut store, Some(er), 1)?;
+        assert!(er.is_some());
+
+        let table: &Table = instance.exports.get_table("table")?;
+
+        {
+            let er2 = table.get(&mut store, 1).unwrap();
+            let er2 = er2.externref().unwrap();
+            assert!(er2.is_some());
+        }
+
+        assert!(er.is_some());
+        table.set(&mut store, 1, Value::ExternRef(None))?;
+
+        assert!(er.is_some());
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_global_basic() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (global $global (export "global") (mut externref) (ref.null extern))
+    (func $get_from_global (export "get_from_global") (result externref)
+          (drop (global.get $global))
+          (global.get $global))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+
+        let global: &Global = instance.exports.get_global("global")?;
+        {
+            let er = ExternRef::new(&mut store, 3usize);
+            global.set(&mut store, Value::ExternRef(Some(er)))?;
+        }
+        let get_from_global: TypedFunction<(), Option<ExternRef>> = instance
+            .exports
+            .get_typed_function(&store, "get_from_global")?;
+
+        let er = get_from_global.call(&mut store)?;
+        assert!(er.is_some());
+        global.set(&mut store, Value::ExternRef(None))?;
+        assert!(er.is_some());
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_traps() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (func $pass_er (export "pass_extern_ref") (param externref)
+          (local.get 0)
+          (unreachable))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+
+        let pass_extern_ref: TypedFunction<Option<ExternRef>, ()> = instance
+            .exports
+            .get_typed_function(&store, "pass_extern_ref")?;
+
+        let er = ExternRef::new(&mut store, 3usize);
+
+        let result = pass_extern_ref.call(&mut store, Some(er));
+        assert!(result.is_err());
+
+        Ok(())
+    }
+
+    #[universal_test]
+    fn extern_ref_ref_counting_table_instructions() -> Result<()> {
+        let mut store = Store::default();
+        let wat = r#"(module
+    (table $table1 (export "table1") 2 12 externref)
+    (table $table2 (export "table2") 6 12 externref)
+    (func $grow_table_with_ref (export "grow_table_with_ref") (param $er externref) (param $size i32) (result i32)
+          (table.grow $table1 (local.get $er) (local.get $size)))
+    (func $fill_table_with_ref (export "fill_table_with_ref") (param $er externref) (param $start i32) (param $end i32)
+          (table.fill $table1 (local.get $start) (local.get $er) (local.get $end)))
+    (func $copy_into_table2 (export "copy_into_table2")
+          (table.copy $table2 $table1 (i32.const 0) (i32.const 0) (i32.const 4)))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+
+        let grow_table_with_ref: TypedFunction<(Option<ExternRef>, i32), i32> = instance
+            .exports
+            .get_typed_function(&store, "grow_table_with_ref")?;
+        let fill_table_with_ref: TypedFunction<(Option<ExternRef>, i32, i32), ()> = instance
+            .exports
+            .get_typed_function(&store, "fill_table_with_ref")?;
+        let copy_into_table2: TypedFunction<(), ()> = instance
+            .exports
+            .get_typed_function(&store, "copy_into_table2")?;
+        let table1: &Table = instance.exports.get_table("table1")?;
+        let table2: &Table = instance.exports.get_table("table2")?;
+
+        let er1 = ExternRef::new(&mut store, 3usize);
+        let er2 = ExternRef::new(&mut store, 5usize);
+        let er3 = ExternRef::new(&mut store, 7usize);
+        {
+            let result = grow_table_with_ref.call(&mut store, Some(er1.clone()), 0)?;
+            assert_eq!(result, 2);
+
+            let result = grow_table_with_ref.call(&mut store, Some(er1.clone()), 10_000)?;
+            assert_eq!(result, -1);
+
+            let result = grow_table_with_ref.call(&mut store, Some(er1), 8)?;
+            assert_eq!(result, 2);
+
+            for i in 2..10 {
+                let v = table1.get(&mut store, i);
+                let e = v.as_ref().unwrap().unwrap_externref();
+                let e_val: Option<&usize> = e.as_ref().unwrap().downcast(&store);
+                assert_eq!(*e_val.unwrap(), 3);
+            }
+        }
+
+        {
+            fill_table_with_ref.call(&mut store, Some(er2), 0, 2)?;
+        }
+
+        {
+            table2.set(&mut store, 0, Value::ExternRef(Some(er3.clone())))?;
+            table2.set(&mut store, 1, Value::ExternRef(Some(er3.clone())))?;
+            table2.set(&mut store, 2, Value::ExternRef(Some(er3.clone())))?;
+            table2.set(&mut store, 3, Value::ExternRef(Some(er3.clone())))?;
+            table2.set(&mut store, 4, Value::ExternRef(Some(er3)))?;
+        }
+
+        {
+            copy_into_table2.call(&mut store)?;
+            for i in 1..5 {
+                let v = table2.get(&mut store, i);
+                let e = v.as_ref().unwrap().unwrap_externref();
+                let value: &usize = e.as_ref().unwrap().downcast(&store).unwrap();
+                match i {
+                    0 | 1 => assert_eq!(*value, 5),
+                    4 => assert_eq!(*value, 7),
+                    _ => assert_eq!(*value, 3),
+                }
+            }
+        }
+
+        {
+            for i in 0..table1.size(&store) {
+                table1.set(&mut store, i, Value::ExternRef(None))?;
+            }
+            for i in 0..table2.size(&store) {
+                table2.set(&mut store, i, Value::ExternRef(None))?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/api/tests/simple-name-section.wasm b/arbitrator/tools/module_roots/wasmer/lib/api/tests/simple-name-section.wasm
new file mode 100644
index 0000000..2969b62
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/api/tests/simple-name-section.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/CHANGELOG.md b/arbitrator/tools/module_roots/wasmer/lib/backend-api/CHANGELOG.md
new file mode 100644
index 0000000..5d313e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/CHANGELOG.md
@@ -0,0 +1,94 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.0.1 (2023-04-27)
+
+* Removed legacy API implementation in favour of the new cynic client
+* Fixed log querying
+* Added methods for retrieving DeployApp/Version by unique id
+
+## 0.1.0-alpha.1 (2023-03-29)
+
+<csr-id-7195702c618c0fb0937244034ee4600531b97034/>
+<csr-id-b8b9af7429a8c9b0880be9bf72f1b8a732d05d75/>
+<csr-id-a40f5127796316069aa2ac646ea5c3817f7a29fa/>
+<csr-id-065513b5f6ee350b9f2607d5aa7003df352f5cbc/>
+<csr-id-38336ebe12a85b142871a4c0fa50541df815a441/>
+<csr-id-8febcde88d1d7df8a7a86c79afcf960c2cb868a3/>
+<csr-id-33f822d9701e87c0f0564574a76adef83ccf72a5/>
+<csr-id-d968694ade1191afff80e6d141598b9c10b2f3c7/>
+<csr-id-b1245bfa194e05d49809973b716e2565689bfccf/>
+
+### Refactor (BREAKING)
+
+ - <csr-id-7195702c618c0fb0937244034ee4600531b97034/> Rename wasmer-deploy-core to wasmer-deploy-schema
+   -schema is a more sensible / expressive name for the crate,
+   since it just holds type definitions.
+   
+   Done in preparation for publishing the crate, since it will need to be
+   used by downstream consumers like the Wasmer repo
+
+### Chore
+
+ - <csr-id-bbc3105d5f04bc4c35dad794443f53980106981e/> Add description to wasmer-api Cargo.toml
+   Required for releasing.
+
+### Other
+
+ - <csr-id-b8b9af7429a8c9b0880be9bf72f1b8a732d05d75/> Dependency cleanup
+   * Lift some dependencies to workspace.dependencies to avoid duplication
+   * Remove a bunch of unused dependencies
+ - <csr-id-a40f5127796316069aa2ac646ea5c3817f7a29fa/> Add crate metadata and prepare for first CLI release
+ - <csr-id-065513b5f6ee350b9f2607d5aa7003df352f5cbc/> "app list" filters
+   Extend the "app list" command to query either a namespace, a users apps,
+   or all apps accessible by a user.
+   (--namepsace X, --all)
+ - <csr-id-38336ebe12a85b142871a4c0fa50541df815a441/> Add a webc app config fetch tests
+ - <csr-id-8febcde88d1d7df8a7a86c79afcf960c2cb868a3/> Make serde_json a workspace dependency
+   To avoid duplication...
+ - <csr-id-33f822d9701e87c0f0564574a76adef83ccf72a5/> Lift serde to be a workspace dependency
+   Easier version management...
+ - <csr-id-d968694ade1191afff80e6d141598b9c10b2f3c7/> Lift anyhow, time and clap to workspace dependnecies
+   Less version management...
+
+### Bug Fixes
+
+ - <csr-id-07a199f0bcccd3178e8f773ae96d100febfb88d0/> Use token for webc fetching
+   If the api is configured with a token, use the token for fetching webcs.
+   Previously it just used anonymous access.
+ - <csr-id-c6ad494a45968bb4a69455f3c292b6fcf9631770/> Update deployment config generation to backend changes
+   The generateDeployConfig GraphQL API has changed
+   
+   * Takes a DeployConfigVersion id instead of DeployConfig id
+* Returns a DeployConfigVersion
+
+### New Features
+
+ - <csr-id-f96944cd8097aff11d51e8e0c3f6fa1efc6b1ec6/> Add generate_deploy_token to new cynic GQL api client
+   Will be needed for various commands
+ - <csr-id-33e469b921256a241866a5a972278665905dcdf4/> Add getPackage GQL query
+ - <csr-id-4783d6a5c53875724bbea3ed5a65b13e5056c001/> Add query for DeployAppVersion
+ - <csr-id-b4aa770fb388970c837f2e5429caa5803eef64bf/> Add new namespace and app commands
+ - <csr-id-63ec5f98dca19c417df0e42a5bfbbd963c9b19c2/> Add a CapabilityLoggingV1 config
+   Allows to configure the logging behaviour of workloads.
+   
+   Will be used very soon to implement instance log forwarding.
+
+### Documentation
+
+ - <csr-id-98b9313b34e93c7973b778ef0867f042bf7aed57/> add some changelogs
+ - <csr-id-845a8b3ebece96d5fff941110a425ab19a3a2eed/> Add REAMDE to Cargo.toml of to-be-published crates
+
+### Chore
+
+ - <csr-id-b1245bfa194e05d49809973b716e2565689bfccf/> Remove download_url from WebcPackageIdentifierV1
+   Not needed anymore, since now we have a deployment config registry.
+
+<csr-unknown>
+Needed to update relevant callsites<csr-unknown/>
+<csr-unknown/>
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/backend-api/Cargo.toml
new file mode 100644
index 0000000..194f92d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "wasmer-api"
+version = "0.0.25"
+description = "Client library for the Wasmer GraphQL API"
+readme = "README.md"
+documentation = "https://docs.rs/wasmer-api"
+
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Wasmer dependencies.
+edge-schema.workspace = true
+webc = "5"
+
+# crates.io dependencies.
+anyhow = "1"
+serde = { version = "1", features = ["derive"] }
+time = { version = "0.3", features = ["formatting", "parsing"] }
+tokio = { version = "1.23.0" }
+serde_json = "1"
+url = "2"
+futures = "0.3"
+tracing = "0.1"
+cynic = { version = "=3.4.3", features = ["http-reqwest"] }
+pin-project-lite = "0.2.10"
+serde_path_to_error = "0.1.14"
+harsh = "0.2.2"
+reqwest = { version = "0.11.13", default-features = false, features = ["json"] }
+
+[dev-dependencies]
+base64 = "0.13.1"
+tokio = { version = "1.3", features = ["macros", "rt"] }
+uuid = { version = "1", features = ["v4"] }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/README.md b/arbitrator/tools/module_roots/wasmer/lib/backend-api/README.md
new file mode 100644
index 0000000..a5c2839
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/README.md
@@ -0,0 +1,46 @@
+# wasmer-api
+
+GraphQL API client for the [Wasmer](https://wasmer.io) backend.
+
+## Development
+
+This client is built on the [cynic][cynic-api-docs] crate,
+a GraphQL client library that allows tight integration between Rust and
+GraphQL types.
+
+It was chosen over other implementations like `graphql-client` because it
+significantly reduces boilerplate and improves the development experience.
+
+The downside is that the underlying GraphQL queries are much less obvious when
+looking at the code. This can be remedied with some strategies mentioned below.
+
+Consult the Cynic docs at [cynic-rs.dev][cynic-website] for more
+information.
+
+### Backend GraphQL Schema
+
+The GraphQL schema for the backend is stored in `./schema.graphql`.
+
+To update the schema, simply download the latest version and replace the local
+file.
+
+It can be retrieved from
+https://github.com/wasmerio/wapm.io-backend/blob/master/backend/graphql/schema.graphql.
+
+### Writing/Updating Queries
+
+You can use the [Cynic web UI][cynic-web-ui] to easily create the types for new
+queries.
+
+Simply upload the local schema from `./schema.graphql` and use the UI to build
+your desired query.
+
+NOTE: Where possible, do not duplicate types that are already defined,
+and instead reuse/extend them where possible.
+
+This is not always sensible though, depending on which nested data you want to
+fetch.
+
+[cynic-api-docs]: https://docs.rs/cynic/latest/cynic/
+[cynic-web-ui]: https://generator.cynic-rs.dev/
+[cynic-website]: https://cynic-rs.dev
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/schema.graphql b/arbitrator/tools/module_roots/wasmer/lib/backend-api/schema.graphql
new file mode 100644
index 0000000..b290541
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/schema.graphql
@@ -0,0 +1,3920 @@
+"""
+Directs the executor to include this field or fragment only when the user is not logged in.
+"""
+directive @includeIfLoggedIn on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+"""
+Directs the executor to skip this field or fragment when the user is not logged in.
+"""
+directive @skipIfLoggedIn on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+interface Node {
+  """The ID of the object"""
+  id: ID!
+}
+
+type PublicKey implements Node {
+  """The ID of the object"""
+  id: ID!
+  owner: User!
+  keyId: String!
+  key: String!
+  revokedAt: DateTime
+  uploadedAt: DateTime!
+  verifyingSignature: Signature
+  revoked: Boolean!
+}
+
+type User implements Node & PackageOwner & Owner {
+  firstName: String!
+  lastName: String!
+  email: String!
+  dateJoined: DateTime!
+
+  """Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."""
+  username: String!
+  isEmailValidated: Boolean!
+  bio: String
+  location: String
+  websiteUrl: String
+
+  """The ID of the object"""
+  id: ID!
+  globalName: String!
+  globalId: ID!
+  avatar(size: Int = 80): String!
+  isViewer: Boolean!
+  hasUsablePassword: Boolean
+  fullName: String!
+  githubUrl: String
+  twitterUrl: String
+  companyRole: String
+  companyDescription: String
+  publicActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  billing: Billing
+  waitlist(name: String!): WaitlistMember
+  namespaces(role: GrapheneRole, offset: Int, before: String, after: String, first: Int, last: Int): NamespaceConnection!
+  packages(collaborating: Boolean = false, offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  apps(collaborating: Boolean = false, sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
+  isStaff: Boolean
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
+  packageInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
+  namespaceInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  apiTokens(before: String, after: String, first: Int, last: Int): APITokenConnection!
+  notifications(before: String, after: String, first: Int, last: Int): UserNotificationConnection!
+  dashboardActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  loginMethods: [LoginMethod!]!
+  githubUser: SocialAuth
+  githubScopes: [String]!
+}
+
+"""Setup for backwards compatibility with existing frontends."""
+interface PackageOwner {
+  globalName: String!
+  globalId: ID!
+}
+
+"""An owner of a package."""
+interface Owner {
+  globalName: String!
+  globalId: ID!
+}
+
+"""
+The `DateTime` scalar type represents a DateTime
+value as specified by
+[iso8601](https://en.wikipedia.org/wiki/ISO_8601).
+"""
+scalar DateTime
+
+type ActivityEventConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [ActivityEventEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
+"""
+type PageInfo {
+  """When paginating forwards, are there more items?"""
+  hasNextPage: Boolean!
+
+  """When paginating backwards, are there more items?"""
+  hasPreviousPage: Boolean!
+
+  """When paginating backwards, the cursor to continue."""
+  startCursor: String
+
+  """When paginating forwards, the cursor to continue."""
+  endCursor: String
+}
+
+"""A Relay edge containing a `ActivityEvent` and its cursor."""
+type ActivityEventEdge {
+  """The item at the end of the edge"""
+  node: ActivityEvent
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type ActivityEvent implements Node {
+  """The ID of the object"""
+  id: ID!
+  body: EventBody!
+  actorIcon: String!
+  createdAt: DateTime!
+}
+
+type EventBody {
+  text: String!
+  ranges: [NodeBodyRange!]!
+}
+
+type NodeBodyRange {
+  entity: Node!
+  offset: Int!
+  length: Int!
+}
+
+type WaitlistMember implements Node {
+  waitlist: Waitlist!
+  joinedAt: DateTime!
+  approvedAt: DateTime
+
+  """The ID of the object"""
+  id: ID!
+  member: Owner!
+  approved: Boolean!
+}
+
+type Waitlist implements Node {
+  name: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+type NamespaceConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Namespace` and its cursor."""
+type NamespaceEdge {
+  """The item at the end of the edge"""
+  node: Namespace
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Namespace implements Node & PackageOwner & Owner {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  displayName: String
+  description: String!
+  avatar: String!
+  avatarUpdatedAt: DateTime
+  twitterHandle: String
+  githubHandle: String
+  websiteUrl: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  maintainerInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  userSet(offset: Int, before: String, after: String, first: Int, last: Int): UserConnection!
+  globalName: String!
+  globalId: ID!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  apps(sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorConnection!
+  publicActivity(before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  viewerHasRole(role: GrapheneRole!): Boolean!
+  viewerAsCollaborator(role: GrapheneRole): NamespaceCollaborator
+
+  """Whether the current user is invited to the namespace"""
+  viewerIsInvited: Boolean!
+
+  """The invitation for the current user to the namespace"""
+  viewerInvitation: NamespaceCollaboratorInvite
+  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  domains(offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
+}
+
+type NamespaceCollaboratorInviteConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceCollaboratorInviteEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+A Relay edge containing a `NamespaceCollaboratorInvite` and its cursor.
+"""
+type NamespaceCollaboratorInviteEdge {
+  """The item at the end of the edge"""
+  node: NamespaceCollaboratorInvite
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type NamespaceCollaboratorInvite implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  user: User
+  inviteEmail: String
+  namespace: Namespace!
+  role: RegistryNamespaceMaintainerInviteRoleChoices!
+  accepted: NamespaceCollaborator
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+}
+
+enum RegistryNamespaceMaintainerInviteRoleChoices {
+  """Owner"""
+  OWNER
+
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type NamespaceCollaborator implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  role: RegistryNamespaceMaintainerRoleChoices!
+  namespace: Namespace!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  invite: NamespaceCollaboratorInvite
+}
+
+enum RegistryNamespaceMaintainerRoleChoices {
+  """Owner"""
+  OWNER
+
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type UserConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [UserEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `User` and its cursor."""
+type UserEdge {
+  """The item at the end of the edge"""
+  node: User
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Package` and its cursor."""
+type PackageEdge {
+  """The item at the end of the edge"""
+  node: Package
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Package implements Likeable & Node & PackageOwner {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  private: Boolean!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  maintainers: [User]! @deprecated(reason: "Please use collaborators instead")
+  curated: Boolean!
+  ownerObjectId: Int!
+  lastVersion: PackageVersion
+
+  """The app icon. It should be formatted in the same way as Apple icons"""
+  icon: String!
+  totalDownloads: Int!
+  iconUpdatedAt: DateTime
+  watchersCount: Int!
+  webcs(offset: Int, before: String, after: String, first: Int, last: Int): WebcImageConnection!
+
+  """List of app templates for this package"""
+  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
+  packagewebcSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageWebcConnection!
+  versions: [PackageVersion]!
+  collectionSet: [Collection!]!
+  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
+  keywords(offset: Int, before: String, after: String, first: Int, last: Int): PackageKeywordConnection!
+  likersCount: Int!
+  viewerHasLiked: Boolean!
+  globalName: String!
+  globalId: ID!
+  alias: String
+  namespace: String!
+  displayName: String!
+
+  """The name of the package without the owner"""
+  packageName: String!
+
+  """The app icon. It should be formatted in the same way as Apple icons"""
+  appIcon: String! @deprecated(reason: "Please use icon instead")
+
+  """The total number of downloads of the package"""
+  downloadsCount: Int
+
+  """The public keys for all the published versions"""
+  publicKeys: [PublicKey!]!
+  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorConnection!
+  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
+  viewerHasRole(role: GrapheneRole!): Boolean!
+  viewerAsCollaborator(role: GrapheneRole): PackageCollaborator
+  owner: PackageOwner!
+  isTransferring: Boolean!
+  activeTransferRequest: PackageTransferRequest
+  isArchived: Boolean!
+  viewerIsWatching: Boolean!
+  showDeployButton: Boolean!
+  similarPackageVersions(before: String, after: String, first: Int, last: Int): PackageSearchConnection!
+
+  """Whether the current user is invited to the package"""
+  viewerIsInvited: Boolean!
+
+  """The invitation for the current user to the package"""
+  viewerInvitation: PackageCollaboratorInvite
+}
+
+interface Likeable {
+  id: ID!
+  likersCount: Int!
+  viewerHasLiked: Boolean!
+}
+
+type PackageVersion implements Node & PackageInstance {
+  """The ID of the object"""
+  id: ID!
+  package: Package!
+  webcGenerationErrors: String
+  version: String!
+  description: String!
+  manifest: String!
+  license: String
+  licenseFile: String
+  readme: String
+  witMd: String
+  repository: String
+  homepage: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  staticObjectsCompiled: Boolean!
+  nativeExecutablesCompiled: Boolean!
+  publishedBy: User!
+  clientName: String
+  signature: Signature
+  isArchived: Boolean!
+  file: String!
+
+  """"""
+  fileSize: BigInt!
+  webc: WebcImage
+  totalDownloads: Int!
+  bindingsState: RegistryPackageVersionBindingsStateChoices!
+  nativeExecutablesState: RegistryPackageVersionNativeExecutablesStateChoices!
+
+  """List of direct dependencies of this package version"""
+  dependencies(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  deployappversionSet(offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  lastversionPackage(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  commands: [Command!]!
+  nativeexecutableSet(offset: Int, before: String, after: String, first: Int, last: Int): NativeExecutableConnection!
+  bindingsgeneratorSet(offset: Int, before: String, after: String, first: Int, last: Int): BindingsGeneratorConnection!
+  javascriptlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
+  pythonlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
+  piritaManifest: JSONString
+  piritaOffsets: JSONString
+  piritaVolumes: JSONString
+  piritaFile: String @deprecated(reason: "Please use distribution.piritaDownloadUrl instead.")
+  piritaFileSize: Int @deprecated(reason: "Please use distribution.piritaSize instead.")
+  pirita256hash: String @deprecated(reason: "Please use distribution.piritaSha256Hash instead.")
+  distribution: PackageDistribution!
+  filesystem: [PackageVersionFilesystem]!
+  isLastVersion: Boolean!
+  witFile: String
+  isSigned: Boolean!
+  moduleInterfaces: [InterfaceVersion!]!
+  modules: [PackageVersionModule!]!
+  getPiritaContents(volume: String! = "atom", base: String! = ""): [PiritaFilesystemItem!]!
+  getWebcContents(volume: String! = "atom", base: String! = "/"): [WEBCFilesystemItem!]!
+  nativeExecutables(triple: String, wasmerCompilerVersion: String): [NativeExecutable]
+  bindings: [PackageVersionLanguageBinding]!
+  npmBindings: PackageVersionNPMBinding
+  pythonBindings: PackageVersionPythonBinding
+  bindingsSet(before: String, after: String, first: Int, last: Int): PackageVersionBindingConnection
+  hasBindings: Boolean!
+  hasCommands: Boolean!
+  showDeployButton: Boolean!
+  isCorrupt: Boolean!
+}
+
+interface PackageInstance {
+  piritaManifest: JSONString
+  piritaOffsets: JSONString
+  piritaVolumes: JSONString
+  isArchived: Boolean!
+  clientName: String
+  publishedBy: User!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  package: Package!
+  webc: WebcImage
+}
+
+"""
+Allows use of a JSON String for input / output from the GraphQL schema.
+
+Use of this type is *not recommended* as you lose the benefits of having a defined, static
+schema (one of the key benefits of GraphQL).
+"""
+scalar JSONString
+
+type WebcImage implements Node {
+  """The ID of the object"""
+  id: ID!
+
+  """"""
+  fileSize: BigInt!
+  manifest: JSONString!
+  volumes: JSONString!
+  offsets: JSONString!
+  webcSha256: String!
+  targzSha256: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  webcUrl: String!
+}
+
+"""
+The `BigInt` scalar type represents non-fractional whole numeric values.
+`BigInt` is not constrained to 32-bit like the `Int` type and thus is a less
+compatible type.
+"""
+scalar BigInt
+
+enum RegistryPackageVersionBindingsStateChoices {
+  """Bindings are not detected"""
+  NOT_PRESENT
+
+  """Bindings are being built"""
+  GENERATING
+
+  """Bindings generation has failed"""
+  ERROR
+
+  """Bindings are built and present"""
+  GENERATED_AND_PRESENT
+}
+
+enum RegistryPackageVersionNativeExecutablesStateChoices {
+  """Native Executables are not detected"""
+  NOT_PRESENT
+
+  """Native Executables are being built"""
+  GENERATING
+
+  """Native Executables generation has failed"""
+  ERROR
+
+  """Native Executables are built and present"""
+  GENERATED_AND_PRESENT
+}
+
+type PackageVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageVersion` and its cursor."""
+type PackageVersionEdge {
+  """The item at the end of the edge"""
+  node: PackageVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DeployAppVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DeployAppVersion` and its cursor."""
+type DeployAppVersionEdge {
+  """The item at the end of the edge"""
+  node: DeployAppVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppVersion implements Node {
+  """The ID of the object"""
+  id: ID!
+  app: DeployApp!
+  yamlConfig: String!
+  userYamlConfig: String!
+  clientName: String
+  signature: String
+  description: String
+  publishedBy: User!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  configWebc: String @deprecated(reason: "webc support has been deprecated for apps")
+  config: String! @deprecated(reason: "Please use jsonConfig instead")
+  jsonConfig: String!
+  url: String!
+  permalink: String!
+  urls: [String]!
+  version: String!
+  isActive: Boolean!
+  manifest: String!
+  logs(
+    """
+    Get logs starting from this timestamp. Takes EPOCH timestamp in seconds.
+    """
+    startingFrom: Float
+
+    """Get logs starting from this timestamp. Takes ISO timestamp."""
+    startingFromISO: DateTime
+
+    """Fetch logs until this timestamp. Takes EPOCH timestamp in seconds."""
+    until: Float
+
+    """List of streams to fetch logs from. e.g. stdout, stderr."""
+    streams: [LogStream]
+
+    """List of instance ids to fetch logs from."""
+    instanceIds: [String]
+    before: String
+    after: String
+    first: Int
+    last: Int
+  ): LogConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  sourcePackageVersion: PackageVersion!
+  aggregateMetrics: AggregateMetrics!
+  volumes: [AppVersionVolume]
+  favicon: URL
+  screenshot: URL
+}
+
+type DeployApp implements Node & Owner {
+  """The ID of the object"""
+  id: ID!
+  createdBy: User!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  activeVersion: DeployAppVersion!
+  globalName: String!
+  globalId: ID!
+  url: String!
+  adminUrl: String!
+  permalink: String!
+  urls: [String]!
+  description: String
+  name: String!
+  owner: Owner!
+  versions(sortBy: DeployAppVersionsSortBy, createdAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  aggregateMetrics: AggregateMetrics!
+  aliases(offset: Int, before: String, after: String, first: Int, last: Int): AppAliasConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  deleted: Boolean!
+  favicon: URL
+  screenshot: URL
+}
+
+enum DeployAppVersionsSortBy {
+  NEWEST
+  OLDEST
+}
+
+type AggregateMetrics {
+  cpuTime: String!
+  memoryTime: String!
+  ingress: String!
+  egress: String!
+  noRequests: String!
+  noFailedRequests: String!
+  monthlyCost: String!
+}
+
+type AppAliasConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [AppAliasEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `AppAlias` and its cursor."""
+type AppAliasEdge {
+  """The item at the end of the edge"""
+  node: AppAlias
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type AppAlias implements Node {
+  name: String!
+  app: DeployApp!
+  isDefault: Boolean!
+
+  """The ID of the object"""
+  id: ID!
+  url: String!
+}
+
+type UsageMetric {
+  variant: MetricType!
+  value: Float!
+  unit: MetricUnit!
+  timestamp: DateTime!
+}
+
+enum MetricType {
+  cpu_time
+  memory_time
+  network_egress
+  network_ingress
+  no_of_requests
+  no_of_failed_requests
+  cost
+}
+
+"""Units for metrics"""
+enum MetricUnit {
+  """represents the unit of "seconds"."""
+  SEC
+
+  """represents the unit of "milliseconds"."""
+  MS
+
+  """represents the unit of "kilobytes"."""
+  KB
+
+  """represents the unit of "kilobytes per second"."""
+  KBS
+
+  """represents the unit of "number of requests"."""
+  NO_REQUESTS
+
+  """represents the unit of "cost" in USD."""
+  DOLLARS
+}
+
+enum MetricRange {
+  LAST_24_HOURS
+  LAST_30_DAYS
+  LAST_1_HOUR
+}
+
+"""
+The `URL` scalar type represents a URL as text, represented as UTF-8
+character sequences.
+"""
+scalar URL
+
+type LogConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [LogEdge]!
+}
+
+"""A Relay edge containing a `Log` and its cursor."""
+type LogEdge {
+  """The item at the end of the edge"""
+  node: Log
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum LogStream {
+  STDOUT
+  STDERR
+  RUNTIME
+}
+
+type AppVersionVolume {
+  name: String!
+  mountPaths: [AppVersionVolumeMountPath]!
+  size: Int
+  usedSize: Int
+}
+
+type AppVersionVolumeMountPath {
+  path: String!
+  subpath: String!
+}
+
+type Command {
+  command: String!
+  packageVersion: PackageVersion!
+  module: PackageVersionModule!
+}
+
+type PackageVersionModule {
+  name: String!
+  source: String!
+  abi: String
+  publicUrl: String!
+  atom: PiritaFilesystemFile!
+  rangeHeader: String!
+}
+
+type PiritaFilesystemFile {
+  name(display: PiritaFilesystemNameDisplay): String!
+  size: Int!
+  offset: Int!
+}
+
+enum PiritaFilesystemNameDisplay {
+  RELATIVE
+  ABSOLUTE
+}
+
+type NativeExecutableConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NativeExecutableEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `NativeExecutable` and its cursor."""
+type NativeExecutableEdge {
+  """The item at the end of the edge"""
+  node: NativeExecutable
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type NativeExecutable implements Node {
+  """The ID of the object"""
+  id: ID!
+  module: String! @deprecated(reason: "Use filename instead")
+  filename: String!
+  filesize: Int!
+  targetTriple: String!
+  downloadUrl: String!
+}
+
+type BindingsGeneratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BindingsGeneratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `BindingsGenerator` and its cursor."""
+type BindingsGeneratorEdge {
+  """The item at the end of the edge"""
+  node: BindingsGenerator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type BindingsGenerator implements Node {
+  """The ID of the object"""
+  id: ID!
+  packageVersion: PackageVersion!
+  active: Boolean!
+  commandName: String!
+  registryJavascriptlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
+  registryPythonlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
+}
+
+type PackageVersionNPMBindingConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionNPMBindingEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageVersionNPMBinding` and its cursor."""
+type PackageVersionNPMBindingEdge {
+  """The item at the end of the edge"""
+  node: PackageVersionNPMBinding
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageVersionNPMBinding implements PackageVersionLanguageBinding & Node {
+  """The ID of the object"""
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  npmDefaultInstallPackageName(url: String): String! @deprecated(reason: "Please use packageName instead")
+}
+
+interface PackageVersionLanguageBinding {
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+}
+
+enum ProgrammingLanguage {
+  PYTHON
+  JAVASCRIPT
+}
+
+type PackageVersionPythonBindingConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionPythonBindingEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+A Relay edge containing a `PackageVersionPythonBinding` and its cursor.
+"""
+type PackageVersionPythonBindingEdge {
+  """The item at the end of the edge"""
+  node: PackageVersionPythonBinding
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageVersionPythonBinding implements PackageVersionLanguageBinding & Node {
+  """The ID of the object"""
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  pythonDefaultInstallPackageName(url: String): String!
+}
+
+type PackageDistribution {
+  """
+  Download URL of the tar.gz file.
+  If the package was published with webc only,this will contain download URL for webc file instead.
+  """
+  downloadUrl: String!
+  expiresInSeconds: Int
+  size: Int
+  piritaDownloadUrl: String
+  piritaExpiresInSeconds: Int
+  piritaSize: Int
+  piritaSha256Hash: String
+  webcDownloadUrl: String
+  webcExpiresInSeconds: Int
+  webcSize: Int
+  webcSha256Hash: String
+}
+
+type PackageVersionFilesystem {
+  wasm: String!
+  host: String!
+}
+
+type InterfaceVersion implements Node {
+  """The ID of the object"""
+  id: ID!
+  interface: Interface!
+  version: String!
+  content: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  publishedBy: User!
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+}
+
+type Interface implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  displayName: String!
+  description: String!
+  homepage: String
+  icon: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  versions(offset: Int, before: String, after: String, first: Int, last: Int): InterfaceVersionConnection!
+  lastVersion: InterfaceVersion
+}
+
+type InterfaceVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [InterfaceVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `InterfaceVersion` and its cursor."""
+type InterfaceVersionEdge {
+  """The item at the end of the edge"""
+  node: InterfaceVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union PiritaFilesystemItem = PiritaFilesystemFile | PiritaFilesystemDir
+
+type PiritaFilesystemDir {
+  name(display: PiritaFilesystemNameDisplay): String!
+}
+
+type WEBCFilesystemItem {
+  name: String!
+  checksum: String!
+  size: Int!
+  offset: Int!
+}
+
+type PackageVersionBindingConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionBindingEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageVersionBinding` and its cursor."""
+type PackageVersionBindingEdge {
+  """The item at the end of the edge"""
+  node: PackageVersionBinding
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union PackageVersionBinding = PackageVersionNPMBinding | PackageVersionPythonBinding
+
+type WebcImageConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [WebcImageEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `WebcImage` and its cursor."""
+type WebcImageEdge {
+  """The item at the end of the edge"""
+  node: WebcImage
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type AppTemplateConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [AppTemplateEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `AppTemplate` and its cursor."""
+type AppTemplateEdge {
+  """The item at the end of the edge"""
+  node: AppTemplate
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type AppTemplate implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  slug: String!
+  description: String!
+  demoUrl: String!
+  repoUrl: String!
+  category: AppTemplateCategory!
+  isPublic: Boolean!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  readme: String!
+  useCases: JSONString!
+  framework: String!
+  language: String!
+  repoLicense: String!
+  usingPackage: Package
+  defaultImage: String
+}
+
+type AppTemplateCategory implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  slug: String!
+  description: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  appTemplates(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection!
+}
+
+type PackageWebcConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageWebcEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageWebc` and its cursor."""
+type PackageWebcEdge {
+  """The item at the end of the edge"""
+  node: PackageWebc
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageWebc implements Node & PackageInstance {
+  """The ID of the object"""
+  id: ID!
+  package: Package!
+  webc: WebcImage
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  piritaManifest: JSONString
+  piritaOffsets: JSONString
+  piritaVolumes: JSONString
+  isArchived: Boolean!
+  clientName: String
+  publishedBy: User!
+  webcUrl: String!
+}
+
+type Collection {
+  slug: String!
+  displayName: String!
+  description: String!
+  createdAt: DateTime!
+  banner: String!
+  packages(before: String, after: String, first: Int, last: Int): PackageConnection!
+}
+
+type CategoryConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [CategoryEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Category` and its cursor."""
+type CategoryEdge {
+  """The item at the end of the edge"""
+  node: Category
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Category implements Node {
+  """The ID of the object"""
+  id: ID!
+
+  """A category is a label that can be attached to a package."""
+  name: String!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
+}
+
+type PackageKeywordConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageKeywordEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageKeyword` and its cursor."""
+type PackageKeywordEdge {
+  """The item at the end of the edge"""
+  node: PackageKeyword
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageKeyword implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+}
+
+type PackageCollaboratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageCollaboratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageCollaborator` and its cursor."""
+type PackageCollaboratorEdge {
+  """The item at the end of the edge"""
+  node: PackageCollaborator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageCollaborator implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  role: RegistryPackageMaintainerRoleChoices!
+  package: Package!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  invite: PackageCollaboratorInvite
+}
+
+enum RegistryPackageMaintainerRoleChoices {
+  """Owner"""
+  OWNER
+
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type PackageCollaboratorInvite implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  user: User
+  inviteEmail: String
+  package: Package!
+  role: RegistryPackageMaintainerInviteRoleChoices!
+  accepted: PackageCollaborator
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+}
+
+enum RegistryPackageMaintainerInviteRoleChoices {
+  """Owner"""
+  OWNER
+
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type PackageCollaboratorInviteConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageCollaboratorInviteEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageCollaboratorInvite` and its cursor."""
+type PackageCollaboratorInviteEdge {
+  """The item at the end of the edge"""
+  node: PackageCollaboratorInvite
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum GrapheneRole {
+  OWNER
+  ADMIN
+  EDITOR
+  VIEWER
+}
+
+type PackageTransferRequest implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  previousOwnerObjectId: Int!
+  newOwnerObjectId: Int!
+  package: Package!
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+  previousOwner: PackageOwner!
+  newOwner: PackageOwner!
+}
+
+type PackageSearchConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageSearchEdge]!
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageSearch` and its cursor."""
+type PackageSearchEdge {
+  """The item at the end of the edge"""
+  node: PackageVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DeployAppEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DeployApp` and its cursor."""
+type DeployAppEdge {
+  """The item at the end of the edge"""
+  node: DeployApp
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum DeployAppsSortBy {
+  NEWEST
+  OLDEST
+  MOST_ACTIVE
+}
+
+type NamespaceCollaboratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceCollaboratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `NamespaceCollaborator` and its cursor."""
+type NamespaceCollaboratorEdge {
+  """The item at the end of the edge"""
+  node: NamespaceCollaborator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageTransferRequestConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageTransferRequestEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageTransferRequest` and its cursor."""
+type PackageTransferRequestEdge {
+  """The item at the end of the edge"""
+  node: PackageTransferRequest
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DNSDomainConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DNSDomainEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DNSDomain` and its cursor."""
+type DNSDomainEdge {
+  """The item at the end of the edge"""
+  node: DNSDomain
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DNSDomain implements Node {
+  name: String!
+
+  """This zone will be accessible at /dns/{slug}/."""
+  slug: String!
+  zoneFile: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+
+  """The ID of the object"""
+  id: ID!
+  records: [DNSRecord]
+  owner: Owner!
+}
+
+union DNSRecord = ARecord | AAAARecord | CNAMERecord | TXTRecord | MXRecord | NSRecord | CAARecord | DNAMERecord | PTRRecord | SOARecord | SRVRecord | SSHFPRecord
+
+type ARecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  address: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+interface DNSRecordInterface {
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+}
+
+type AAAARecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  address: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type CNAMERecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+
+  """This domain name will alias to this canonical name."""
+  cName: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type TXTRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  data: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type MXRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  preference: Int!
+  exchange: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type NSRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  nsdname: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type CAARecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  flags: Int!
+  tag: DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices!
+  value: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+enum DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
+  """issue"""
+  ISSUE
+
+  """issue wildcard"""
+  ISSUEWILD
+
+  """Incident object description exchange format"""
+  IODEF
+}
+
+type DNAMERecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+
+  """
+  This domain name will alias to the entire subtree of that delegation domain.
+  """
+  dName: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type PTRRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  ptrdname: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type SOARecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+
+  """Primary master name server for this zone."""
+  mname: String!
+
+  """Email address of the administrator responsible for this zone."""
+  rname: String!
+
+  """
+  A slave name server will initiate a zone transfer if this serial is incremented.
+  """
+  serial: BigInt!
+
+  """
+  Number of seconds after which secondary name servers should query the master to detect zone changes.
+  """
+  refresh: BigInt!
+
+  """
+  Number of seconds after which secondary name servers should retry to request the serial number from the master if the master does not respond.
+  """
+  retry: BigInt!
+
+  """
+  Number of seconds after which secondary name servers should stop answering request for this zone if the master does not respond.
+  """
+  expire: BigInt!
+
+  """Time to live for purposes of negative caching."""
+  minimum: BigInt!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type SRVRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+
+  """The symbolic name of the desired service."""
+  service: String!
+
+  """
+  The transport protocol of the desired service, usually either TCP or UDP.
+  """
+  protocol: String!
+
+  """The priority of the target host, lower value means more preferred."""
+  priority: Int!
+
+  """
+  A relative weight for records with the same priority, higher value means higher chance of getting picked.
+  """
+  weight: Int!
+  port: Int!
+
+  """
+  The canonical hostname of the machine providing the service, ending in a dot.
+  """
+  target: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+type SSHFPRecord implements Node & DNSRecordInterface {
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  deletedAt: DateTime
+  algorithm: DnsmanagerSshFingerprintRecordAlgorithmChoices!
+  type: DnsmanagerSshFingerprintRecordTypeChoices!
+  fingerprint: String!
+
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  ttl: Int!
+  dnsClass: String
+  text: String!
+  domain: DNSDomain!
+}
+
+enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
+  """RSA"""
+  A_1
+
+  """DSA"""
+  A_2
+
+  """ECDSA"""
+  A_3
+
+  """Ed25519"""
+  A_4
+}
+
+enum DnsmanagerSshFingerprintRecordTypeChoices {
+  """SHA-1"""
+  A_1
+
+  """SHA-256"""
+  A_2
+}
+
+type APITokenConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [APITokenEdge]!
+}
+
+"""A Relay edge containing a `APIToken` and its cursor."""
+type APITokenEdge {
+  """The item at the end of the edge"""
+  node: APIToken
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type APIToken {
+  id: ID!
+  user: User!
+  identifier: String
+  createdAt: DateTime!
+  revokedAt: DateTime
+  lastUsedAt: DateTime
+  nonceSet(offset: Int, before: String, after: String, first: Int, last: Int): NonceConnection!
+}
+
+type NonceConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NonceEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Nonce` and its cursor."""
+type NonceEdge {
+  """The item at the end of the edge"""
+  node: Nonce
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Nonce implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  callbackUrl: String!
+  createdAt: DateTime!
+  isValidated: Boolean!
+  secret: String!
+  token: String!
+  expired: Boolean!
+  authUrl: String!
+}
+
+type UserNotificationConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [UserNotificationEdge]!
+  hasPendingNotifications: Boolean!
+  pendingNotificationsCount: Int!
+}
+
+"""A Relay edge containing a `UserNotification` and its cursor."""
+type UserNotificationEdge {
+  """The item at the end of the edge"""
+  node: UserNotification
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type UserNotification implements Node {
+  """The ID of the object"""
+  id: ID!
+  icon: String
+  body: EventBody!
+  seenState: UserNotificationSeenState!
+  kind: UserNotificationKind
+  createdAt: DateTime!
+}
+
+enum UserNotificationSeenState {
+  UNSEEN
+  SEEN
+  SEEN_AND_READ
+}
+
+union UserNotificationKind = UserNotificationKindPublishedPackageVersion | UserNotificationKindIncomingPackageTransfer | UserNotificationKindIncomingPackageInvite | UserNotificationKindIncomingNamespaceInvite | UserNotificationKindValidateEmail
+
+type UserNotificationKindPublishedPackageVersion {
+  packageVersion: PackageVersion!
+}
+
+type UserNotificationKindIncomingNamespaceInvite {
+  namespaceInvite: NamespaceCollaboratorInvite!
+}
+
+type UserNotificationKindValidateEmail {
+  user: User!
+}
+
+"""
+
+    Enum of ways a user can login. One user can have many login methods
+    associated with their account.
+
+"""
+enum LoginMethod {
+  GOOGLE
+  GITHUB
+  PASSWORD
+}
+
+type SocialAuth implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  provider: String!
+  uid: String!
+  extraData: JSONString!
+  created: DateTime!
+  modified: DateTime!
+  username: String!
+}
+
+type Signature {
+  id: ID!
+  publicKey: PublicKey!
+  data: String!
+  createdAt: DateTime!
+}
+
+type StripeCustomer {
+  id: ID!
+}
+
+type Billing {
+  stripeCustomer: StripeCustomer!
+  payments: [PaymentIntent]!
+  paymentMethods: [PaymentMethod]!
+}
+
+type PaymentIntent implements Node {
+  """The datetime this object was created in stripe."""
+  created: DateTime
+
+  """Three-letter ISO currency code"""
+  currency: String!
+
+  """
+  Status of this PaymentIntent, one of requires_payment_method, requires_confirmation, requires_action, processing, requires_capture, canceled, or succeeded. You can read more about PaymentIntent statuses here.
+  """
+  status: DjstripePaymentIntentStatusChoices!
+
+  """The ID of the object"""
+  id: ID!
+  amount: String!
+}
+
+enum DjstripePaymentIntentStatusChoices {
+  """
+  Cancellation invalidates the intent for future confirmation and cannot be undone.
+  """
+  CANCELED
+
+  """Required actions have been handled."""
+  PROCESSING
+
+  """Payment Method require additional action, such as 3D secure."""
+  REQUIRES_ACTION
+
+  """Capture the funds on the cards which have been put on holds."""
+  REQUIRES_CAPTURE
+
+  """Intent is ready to be confirmed."""
+  REQUIRES_CONFIRMATION
+
+  """Intent created and requires a Payment Method to be attached."""
+  REQUIRES_PAYMENT_METHOD
+
+  """The funds are in your account."""
+  SUCCEEDED
+}
+
+union PaymentMethod = CardPaymentMethod
+
+type CardPaymentMethod implements Node {
+  """The ID of the object"""
+  id: ID!
+  brand: CardBrand!
+  country: String!
+  expMonth: Int!
+  expYear: Int!
+  funding: CardFunding!
+  last4: String!
+  isDefault: Boolean!
+}
+
+"""
+Card brand.
+
+Can be amex, diners, discover, jcb, mastercard, unionpay, visa, or unknown.
+"""
+enum CardBrand {
+  AMEX
+  DINERS
+  DISCOVER
+  JCB
+  MASTERCARD
+  UNIONPAY
+  VISA
+  UNKNOWN
+}
+
+"""
+Card funding type.
+
+Can be credit, debit, prepaid, or unknown.
+"""
+enum CardFunding {
+  CREDIT
+  DEBIT
+  PREPAID
+  UNKNOWN
+}
+
+type Payment {
+  id: ID
+  amount: String
+  paidOn: DateTime
+}
+
+"""Log entry for deploy app."""
+type Log {
+  """Timestamp in nanoseconds"""
+  timestamp: Float!
+
+  """ISO 8601 string in UTC"""
+  datetime: DateTime!
+
+  """Log message"""
+  message: String!
+
+  """Log stream"""
+  stream: LogStream
+}
+
+type UserNotificationKindIncomingPackageTransfer {
+  packageTransferRequest: PackageTransferRequest!
+}
+
+type UserNotificationKindIncomingPackageInvite {
+  packageInvite: PackageCollaboratorInvite!
+}
+
+input DeploymentV1 {
+  name: String!
+  workload: WorkloadV1!
+}
+
+input WorkloadV1 {
+  capability: CapabilityMapV1
+  name: String = null
+  runner: WorkloadRunnerV1!
+}
+
+input AppV1Spec {
+  aliases: [String] = []
+  workload: WorkloadV2!
+}
+
+input WorkloadV2 {
+  source: String!
+}
+
+input CapabilityCpuV1 {
+  maximumThreads: Int
+  maximumUsage: Int
+}
+
+input FileSystemPermissionsV1 {
+  delete: Boolean
+  read: Boolean
+  write: Boolean
+}
+
+input FileSystemVolumeMountV1 {
+  path: String!
+  permissions: [FileSystemPermissionsV1]
+}
+
+input FileSystemVolumeSourceLocalV1 {
+  maximumSize: String!
+}
+
+input FileSystemVolumeSourceV1 {
+  local: FileSystemVolumeSourceLocalV1!
+}
+
+input FileSystemVolumeConfigV1 {
+  mounts: [FileSystemVolumeMountV1]!
+  name: String!
+  source: FileSystemVolumeSourceV1!
+}
+
+input CapabilityFileSystemV1 {
+  volumes: [FileSystemVolumeConfigV1]!
+}
+
+input CapabilityPersistentMemoryV1 {
+  volumes: [String]
+}
+
+input CapabilityMemorySwapV1 {
+  maximumSize: String
+  memoryId: String
+}
+
+input CapabilityNetworkV1 {
+  egress: NetworkEgressV1
+}
+
+input NetworkEgressV1 {
+  enabled: Boolean
+}
+
+input CapabilityNetworkDnsV1 {
+  enabled: Boolean
+  servers: [String]
+  allowedHosts: NetworkDnsAllowedHostsV1
+}
+
+input NetworkDnsAllowedHostsV1 {
+  allowAllHosts: Boolean
+  hosts: [String]
+  regexPatterns: [String]
+  wildcardPatterns: [String]
+}
+
+input CapabilityNetworkGatewayV1 {
+  domains: [String]
+  enforceHttps: Boolean
+}
+
+input CapabilityMapV1 {
+  memorySwap: CapabilityCpuV1
+}
+
+input WebcSourceV1 {
+  name: String!
+  namespace: String!
+  repository: String! = "https://registry.wasmer.wtf"
+  tag: String
+  authToken: String
+}
+
+input WorkloadRunnerV1 {
+  webProxy: RunnerWebProxyV1
+  wcgi: RunnerWCGIV1
+}
+
+"""Run a webassembly file."""
+input RunnerWCGIV1 {
+  source: WorkloadRunnerWasmSourceV1!
+  dialect: String
+}
+
+input RunnerWebProxyV1 {
+  source: WorkloadRunnerWasmSourceV1!
+}
+
+input WorkloadRunnerWasmSourceV1 {
+  webc: WebcSourceV1!
+}
+
+type Query {
+  latestTOS: TermsOfService!
+  getDeployAppVersion(name: String!, owner: String, version: String): DeployAppVersion
+  getAllDomains(namespace: String, offset: Int, before: String, after: String, first: Int, last: Int): DNSDomainConnection!
+  getAllDNSRecords(sortBy: DNSRecordsSortBy, updatedAfter: DateTime, before: String, after: String, first: Int, last: Int): DNSRecordConnection!
+  getDomain(name: String!): DNSDomain
+  getDeployApp(
+    name: String!
+
+    """Owner of the app. Defaults to logged in user."""
+    owner: String
+  ): DeployApp
+  getAppByGlobalAlias(alias: String!): DeployApp
+  getDeployApps(sortBy: DeployAppsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  getAppVersions(sortBy: DeployAppVersionsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  getAppTemplates(categorySlug: String, offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateConnection
+  getAppTemplate(slug: String!): AppTemplate
+  getAppTemplateCategories(offset: Int, before: String, after: String, first: Int, last: Int): AppTemplateCategoryConnection
+  viewer: User
+  getUser(username: String!): User
+  getPasswordResetToken(token: String!): GetPasswordResetToken
+  getAuthNonce(name: String!): Nonce
+
+  """Can the logged in user create app templates?"""
+  canDeployAppToGithub: Boolean!
+
+  """Check if a repo exists in the logged in user's github account."""
+  checkRepoExists(
+    """The namespace of the repo to check."""
+    namespace: String!
+
+    """The name of the repo to check."""
+    name: String!
+  ): Boolean!
+
+  """Generate a unique repo name in the logged in user's github account."""
+  newRepoName(
+    """The github namespace of the repo to create the repo in."""
+    namespace: String!
+
+    """The template to use."""
+    templateSlug: String!
+  ): String!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
+  recentPackageVersions(curated: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  allPackageVersions(sortBy: PackageVersionSortBy, createdAfter: DateTime, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  getWebcImage(hash: String!): WebcImage
+  getNamespace(name: String!): Namespace
+  getPackage(name: String!): Package
+  getPackages(names: [String!]!): [Package]!
+  getPackageVersion(name: String!, version: String = "latest"): PackageVersion
+  getPackageVersions(names: [String!]!): [PackageVersion]
+  getPackageVersionByHash(name: String!, hash: String!): PackageVersion
+  getInterface(name: String!): Interface
+  getInterfaces(names: [String!]!): [Interface]!
+  getInterfaceVersion(name: String!, version: String = "latest"): InterfaceVersion
+  getContract(name: String!): Interface @deprecated(reason: "Please use getInterface instead")
+  getContracts(names: [String!]!): [Interface]! @deprecated(reason: "Please use getInterfaces instead")
+  getContractVersion(name: String!, version: String): InterfaceVersion @deprecated(reason: "Please use getInterfaceVersion instead")
+  getCommand(name: String!): Command
+  getCommands(names: [String!]!): [Command]
+  getCollections(before: String, after: String, first: Int, last: Int): CollectionConnection
+  getSignedUrlForPackageUpload(name: String!, version: String = "latest", expiresAfterSeconds: Int = 60): SignedUrl
+  getPackageHash(name: String!, hash: String!): PackageWebc!
+  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
+  blogposts(tags: [String!], before: String, after: String, first: Int, last: Int): BlogPostConnection!
+  getBlogpost(slug: String, featured: Boolean): BlogPost
+  allBlogpostTags(offset: Int, before: String, after: String, first: Int, last: Int): BlogPostTagConnection
+  search(query: String!, packages: PackagesFilter, namespaces: NamespacesFilter, users: UsersFilter, apps: AppFilter, blogposts: BlogPostsFilter, appTemplates: AppTemplateFilter, before: String, after: String, first: Int, last: Int): SearchConnection!
+  searchAutocomplete(kind: [SearchKind!], query: String!, before: String, after: String, first: Int, last: Int): SearchConnection!
+  getGlobalObject(slug: String!): GlobalObject
+  node(
+    """The ID of the object"""
+    id: ID!
+  ): Node
+  nodes(ids: [ID!]!): [Node]
+  info: RegistryInfo
+}
+
+type TermsOfService implements Node {
+  """The ID of the object"""
+  id: ID!
+  content: String!
+  createdAt: DateTime!
+  viewerHasAccepted: Boolean!
+}
+
+type DNSRecordConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DNSRecordEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DNSRecord` and its cursor."""
+type DNSRecordEdge {
+  """The item at the end of the edge"""
+  node: DNSRecord
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum DNSRecordsSortBy {
+  NEWEST
+  OLDEST
+}
+
+type AppTemplateCategoryConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [AppTemplateCategoryEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `AppTemplateCategory` and its cursor."""
+type AppTemplateCategoryEdge {
+  """The item at the end of the edge"""
+  node: AppTemplateCategory
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type GetPasswordResetToken {
+  valid: Boolean!
+  user: User
+}
+
+enum PackageVersionSortBy {
+  NEWEST
+  OLDEST
+}
+
+type CollectionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [CollectionEdge]!
+}
+
+"""A Relay edge containing a `Collection` and its cursor."""
+type CollectionEdge {
+  """The item at the end of the edge"""
+  node: Collection
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type SignedUrl {
+  url: String!
+}
+
+type BlogPostConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BlogPostEdge]!
+}
+
+"""A Relay edge containing a `BlogPost` and its cursor."""
+type BlogPostEdge {
+  """The item at the end of the edge"""
+  node: BlogPost
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type BlogPost implements Node {
+  """The ID of the object"""
+  id: ID!
+  live: Boolean!
+
+  """The page title as you'd like it to be seen by the public"""
+  title: String!
+
+  """
+  The name of the page as it will appear in URLs e.g http://domain.com/blog/[my-slug]/
+  """
+  slug: String!
+  owner: User
+  body: String!
+  publishDate: DateTime
+  theme: BlogBlogPostThemeChoices!
+  url: String!
+  coverImageUrl: String
+  opengraphImageUrl: String
+  tagline: String!
+  relatedArticles: [BlogPost!]
+  updatedAt: DateTime!
+  tags: [BlogPostTag!]
+  editUrl: String
+}
+
+enum BlogBlogPostThemeChoices {
+  """Green"""
+  GREEN
+
+  """Purple"""
+  PURPLE
+
+  """Orange"""
+  ORANGE
+
+  """Blue"""
+  BLUE
+}
+
+type BlogPostTag implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  slug: String!
+}
+
+type BlogPostTagConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BlogPostTagEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `BlogPostTag` and its cursor."""
+type BlogPostTagEdge {
+  """The item at the end of the edge"""
+  node: BlogPostTag
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type SearchConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [SearchEdge]!
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Search` and its cursor."""
+type SearchEdge {
+  """The item at the end of the edge"""
+  node: SearchResult
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union SearchResult = PackageVersion | User | Namespace | DeployApp | BlogPost | AppTemplate
+
+input PackagesFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter packages by being curated."""
+  curated: Boolean
+
+  """Filter packages by publish date."""
+  publishDate: SearchPublishDate
+
+  """Filter packages by having bindings."""
+  hasBindings: Boolean = false
+
+  """Filter packages by being standalone."""
+  isStandalone: Boolean = false
+
+  """Filter packages by having commands."""
+  hasCommands: Boolean = false
+
+  """Filter packages by interface."""
+  withInterfaces: [String]
+
+  """Filter packages by deployable status."""
+  deployable: Boolean
+
+  """Filter packages by license."""
+  license: String
+
+  """Filter packages created after this date."""
+  createdAfter: DateTime
+
+  """Filter packages created before this date."""
+  createdBefore: DateTime
+
+  """Filter packages with version published after this date."""
+  lastPublishedAfter: DateTime
+
+  """Filter packages with version published before this date."""
+  lastPublishedBefore: DateTime
+
+  """Filter packages by size."""
+  size: CountFilter
+
+  """Filter packages by download count."""
+  downloads: CountFilter
+
+  """Filter packages by like count."""
+  likes: CountFilter
+
+  """Filter packages by owner."""
+  owner: String
+
+  """Filter packages by published by."""
+  publishedBy: String
+
+  """Order packages by field."""
+  orderBy: PackageOrderBy = PUBLISHED_DATE
+}
+
+enum SearchOrderSort {
+  ASC
+  DESC
+}
+
+enum SearchPublishDate {
+  LAST_DAY
+  LAST_WEEK
+  LAST_MONTH
+  LAST_YEAR
+}
+
+input CountFilter {
+  count: Int = 0
+  comparison: CountComparison = GREATER_THAN_OR_EQUAL
+}
+
+enum CountComparison {
+  EQUAL
+  GREATER_THAN
+  LESS_THAN
+  GREATER_THAN_OR_EQUAL
+  LESS_THAN_OR_EQUAL
+}
+
+enum PackageOrderBy {
+  ALPHABETICALLY
+  SIZE
+  TOTAL_DOWNLOADS
+  PUBLISHED_DATE
+  CREATED_DATE
+  TOTAL_LIKES
+}
+
+input NamespacesFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter namespaces by package count."""
+  packageCount: CountFilter
+
+  """Filter namespaces created after this date."""
+  createdAfter: DateTime
+
+  """Filter namespaces created before this date."""
+  createdBefore: DateTime
+
+  """Filter namespaces by user count."""
+  userCount: CountFilter
+
+  """Filter namespaces by collaborator."""
+  collaborator: String
+
+  """Order namespaces by field."""
+  orderBy: NamespaceOrderBy = CREATED_DATE
+}
+
+enum NamespaceOrderBy {
+  PACKAGE_COUNT
+  COLLABORATOR_COUNT
+  APP_COUNT
+  CREATED_DATE
+}
+
+input UsersFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter users by package count."""
+  packageCount: CountFilter
+
+  """Filter users by namespace count."""
+  namespaceCount: CountFilter
+
+  """Filter users joined after this date."""
+  joinedAfter: DateTime
+
+  """Filter users joined before this date."""
+  joinedBefore: DateTime
+
+  """Order users by field."""
+  orderBy: UserOrderBy = CREATED_DATE
+}
+
+enum UserOrderBy {
+  PACKAGE_COUNT
+  APP_COUNT
+  CREATED_DATE
+}
+
+input AppFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter apps by deployed by."""
+  deployedBy: String
+
+  """Filter apps last deployed after this date."""
+  lastDeployedAfter: DateTime
+
+  """Filter apps last deployed before this date."""
+  lastDeployedBefore: DateTime
+
+  """Filter apps by owner."""
+  owner: String
+
+  """Order apps by field."""
+  orderBy: AppOrderBy = CREATED_DATE
+
+  """Filter apps by client name."""
+  clientName: String
+}
+
+enum AppOrderBy {
+  PUBLISHED_DATE
+  CREATED_DATE
+}
+
+input BlogPostsFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter blog posts by tag."""
+  tags: [String]
+}
+
+input AppTemplateFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Order app templates by field."""
+  orderBy: AppTemplateOrderBy = CREATED_DATE
+
+  """Filter by app template framework"""
+  framework: String
+
+  """Filter by app template language"""
+  language: String
+
+  """Filter by one or more of the use-cases for the app template"""
+  useCases: [String]
+}
+
+enum AppTemplateOrderBy {
+  CREATED_DATE
+}
+
+enum SearchKind {
+  PACKAGE
+  NAMESPACE
+  USER
+}
+
+union GlobalObject = User | Namespace
+
+type RegistryInfo {
+  """Base URL for this registry"""
+  baseUrl: String!
+
+  """Base URL for the default frontend"""
+  defaultFrontend: String!
+
+  """URL to the graphql endpoint"""
+  graphqlUrl: String!
+
+  """URL to the graphql endpoint"""
+  createBlogpostUrl: String
+
+  """Public metadata about packages"""
+  packages: PackageInfo!
+
+  """Public metadata about the graphql schema"""
+  schema: SchemaInfo!
+}
+
+type PackageInfo {
+  """Number of package versions published this month"""
+  versionsPublishedThisMonth: Int!
+
+  """Number of new packages published this month"""
+  newPackagesThisMonth: Int!
+
+  """Number of package downloads this month"""
+  packageDownloadsThisMonth: Int!
+}
+
+type SchemaInfo {
+  """Download link for graphql schema"""
+  downloadUrl: String!
+
+  """SHA256 hash of the schema data"""
+  SHA256Hash: String!
+
+  """Timestamp when the schema was last updated"""
+  lastUpdated: DateTime!
+}
+
+type Mutation {
+  """Viewer accepts the latest ToS."""
+  acceptTOS(input: AcceptTOSInput!): AcceptTOSPayload
+  publishDeployApp(input: PublishDeployAppInput!): PublishDeployAppPayload
+  deleteApp(input: DeleteAppInput!): DeleteAppPayload
+
+  """Add current user to the waitlist."""
+  joinWaitlist(input: JoinWaitlistInput!): JoinWaitlistPayload
+
+  """Add stripe payment to the user"""
+  addPayment(input: AddPaymentInput!): AddPaymentPayload
+
+  """
+  Mutation to change the active version of a DeployApp to another DeployAppVersion.
+  """
+  markAppVersionAsActive(input: MarkAppVersionAsActiveInput!): MarkAppVersionAsActivePayload
+
+  """Set a payment method as default for the user."""
+  makePaymentDefault(input: SetDefaultPaymentMethodInput!): SetDefaultPaymentMethodPayload
+
+  """
+  Try to detach a payment method from customer.
+  Fails if trying to detach a default method,
+  or if it's the only payment method.
+  """
+  detachPaymentMethod(input: DetachPaymentMethodInput!): DetachPaymentMethodPayload
+  generateDeployConfigToken(input: GenerateDeployConfigTokenInput!): GenerateDeployConfigTokenPayload
+  renameApp(input: RenameAppInput!): RenameAppPayload
+  renameAppAlias(input: RenameAppAliasInput!): RenameAppAliasPayload
+  requestAppTransfer(input: RequestAppTransferInput!): RequestAppTransferPayload
+  acceptAppTransferRequest(input: AcceptAppTransferRequestInput!): AcceptAppTransferRequestPayload
+  removeAppTransferRequest(input: RemoveAppTransferRequestInput!): RemoveAppTransferRequestPayload
+  createRepoForAppTemplate(input: CreateRepoForAppTemplateInput!): CreateRepoForAppTemplatePayload
+  registerDomain(input: RegisterDomainInput!): RegisterDomainPayload
+  upsertDNSRecord(input: UpsertDNSRecordInput!): UpsertDNSRecordPayload
+  deleteDnsRecord(input: DeleteDNSRecordInput!): DeleteDNSRecordPayload
+  upsertDomainFromZoneFile(input: UpsertDomainFromZoneFileInput!): UpsertDomainFromZoneFilePayload
+  deleteDomain(input: DeleteDomainInput!): DeleteDomainPayload
+  tokenAuth(input: ObtainJSONWebTokenInput!): ObtainJSONWebTokenPayload
+  generateDeployToken(input: GenerateDeployTokenInput!): GenerateDeployTokenPayload
+  verifyAccessToken(token: String): Verify
+  refreshAccessToken(refreshToken: String): Refresh
+  revokeAccessToken(refreshToken: String): Revoke
+  registerUser(input: RegisterUserInput!): RegisterUserPayload
+  socialAuth(input: SocialAuthJWTInput!): SocialAuthJWTPayload
+  validateUserEmail(input: ValidateUserEmailInput!): ValidateUserEmailPayload
+  requestPasswordReset(input: RequestPasswordResetInput!): RequestPasswordResetPayload
+  requestValidationEmail(input: RequestValidationEmailInput!): RequestValidationEmailPayload
+  changeUserPassword(input: ChangeUserPasswordInput!): ChangeUserPasswordPayload
+  changeUserUsername(input: ChangeUserUsernameInput!): ChangeUserUsernamePayload
+  changeUserEmail(input: ChangeUserEmailInput!): ChangeUserEmailPayload
+  updateUserInfo(input: UpdateUserInfoInput!): UpdateUserInfoPayload
+  validateUserPassword(input: ValidateUserPasswordInput!): ValidateUserPasswordPayload
+  generateApiToken(input: GenerateAPITokenInput!): GenerateAPITokenPayload
+  revokeApiToken(input: RevokeAPITokenInput!): RevokeAPITokenPayload
+  checkUserExists(input: CheckUserExistsInput!): CheckUserExistsPayload
+  readNotification(input: ReadNotificationInput!): ReadNotificationPayload
+  seePendingNotifications(input: SeePendingNotificationsInput!): SeePendingNotificationsPayload
+  newNonce(input: NewNonceInput!): NewNoncePayload
+  validateNonce(input: ValidateNonceInput!): ValidateNoncePayload
+  mfa2totpGetToken(input: MFATOTPGetTokenInput!): MFATOTPTokenType
+  mfa2totpVerify(input: MFATOTPVerifyInput!): MFATOTPVerifyPayload
+  mfa2totpAuth(input: MFATOTPAuthInput!): MFAAuthResponse
+  mfa2RecoveryGetToken(input: MFAGenerateRecoveryTokenInput!): MFARecoveryCodes
+  mfa2RecoveryAuth(input: MFARecoveryAuthInput!): MFAAuthResponse
+  mfa2EmailAuth(input: MFAEmailAuthInput!): MFAAuthResponse
+  mfa2EmailGetToken(input: MFAGenerateEmailOTPInput!): MFAEmailGenerationResponse
+  publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
+  publishPackage(input: PublishPackageInput!): PublishPackagePayload
+  updatePackage(input: UpdatePackageInput!): UpdatePackagePayload
+  likePackage(input: LikePackageInput!): LikePackagePayload
+  unlikePackage(input: UnlikePackageInput!): UnlikePackagePayload
+  watchPackage(input: WatchPackageInput!): WatchPackagePayload
+  unwatchPackage(input: UnwatchPackageInput!): UnwatchPackagePayload
+  archivePackage(input: ArchivePackageInput!): ArchivePackagePayload
+  renamePackage(input: RenamePackageInput!): RenamePackagePayload
+  changePackageVersionArchivedStatus(input: ChangePackageVersionArchivedStatusInput!): ChangePackageVersionArchivedStatusPayload
+  createNamespace(input: CreateNamespaceInput!): CreateNamespacePayload
+  updateNamespace(input: UpdateNamespaceInput!): UpdateNamespacePayload
+  deleteNamespace(input: DeleteNamespaceInput!): DeleteNamespacePayload
+  inviteNamespaceCollaborator(input: InviteNamespaceCollaboratorInput!): InviteNamespaceCollaboratorPayload
+  acceptNamespaceCollaboratorInvite(input: AcceptNamespaceCollaboratorInviteInput!): AcceptNamespaceCollaboratorInvitePayload
+  removeNamespaceCollaboratorInvite(input: RemoveNamespaceCollaboratorInviteInput!): RemoveNamespaceCollaboratorInvitePayload
+  removeNamespaceCollaborator(input: RemoveNamespaceCollaboratorInput!): RemoveNamespaceCollaboratorPayload
+  updateNamespaceCollaboratorRole(input: UpdateNamespaceCollaboratorRoleInput!): UpdateNamespaceCollaboratorRolePayload
+  updateNamespaceCollaboratorInviteRole(input: UpdateNamespaceCollaboratorInviteRoleInput!): UpdateNamespaceCollaboratorInviteRolePayload
+  invitePackageCollaborator(input: InvitePackageCollaboratorInput!): InvitePackageCollaboratorPayload
+  acceptPackageCollaboratorInvite(input: AcceptPackageCollaboratorInviteInput!): AcceptPackageCollaboratorInvitePayload
+  removePackageCollaboratorInvite(input: RemovePackageCollaboratorInviteInput!): RemovePackageCollaboratorInvitePayload
+  updatePackageCollaboratorRole(input: UpdatePackageCollaboratorRoleInput!): UpdatePackageCollaboratorRolePayload
+  updatePackageCollaboratorInviteRole(input: UpdatePackageCollaboratorInviteRoleInput!): UpdatePackageCollaboratorInviteRolePayload
+  removePackageCollaborator(input: RemovePackageCollaboratorInput!): RemovePackageCollaboratorPayload
+  requestPackageTransfer(input: RequestPackageTransferInput!): RequestPackageTransferPayload
+  acceptPackageTransferRequest(input: AcceptPackageTransferRequestInput!): AcceptPackageTransferRequestPayload
+  removePackageTransferRequest(input: RemovePackageTransferRequestInput!): RemovePackageTransferRequestPayload
+  generateBindingsForAllPackages(input: GenerateBindingsForAllPackagesInput!): GenerateBindingsForAllPackagesPayload
+  makePackagePublic(input: MakePackagePublicInput!): MakePackagePublicPayload
+}
+
+"""Viewer accepts the latest ToS."""
+type AcceptTOSPayload {
+  TOS: TermsOfService!
+  clientMutationId: String
+}
+
+input AcceptTOSInput {
+  clientMutationId: String
+}
+
+type PublishDeployAppPayload {
+  deployAppVersion: DeployAppVersion!
+  clientMutationId: String
+}
+
+input PublishDeployAppInput {
+  """The configuration of the app."""
+  config: Configuration!
+
+  """The name of the app."""
+  name: ID
+
+  """The owner of the app."""
+  owner: ID
+
+  """The description of the app."""
+  description: String
+
+  """If true, the new version will be set as the default version."""
+  makeDefault: Boolean = true
+
+  """
+  If true, Publishing will fail if the source package does not have a valid webc.
+  """
+  strict: Boolean = false
+  clientMutationId: String
+}
+
+input Configuration {
+  deployment: AppV0
+  yamlConfig: String
+}
+
+input AppV0 {
+  kind: String = "wasmer.io/App.v0"
+  appId: ID
+  name: String!
+  description: String
+  package: String!
+}
+
+type DeleteAppPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteAppInput {
+  """App ID to delete."""
+  id: ID!
+  clientMutationId: String
+}
+
+"""Add current user to the waitlist."""
+type JoinWaitlistPayload {
+  waitlistMember: WaitlistMember!
+  clientMutationId: String
+}
+
+input JoinWaitlistInput {
+  name: String!
+  clientMutationId: String
+}
+
+"""Add stripe payment to the user"""
+type AddPaymentPayload {
+  customerSecret: String!
+  clientMutationId: String
+}
+
+input AddPaymentInput {
+  clientMutationId: String
+}
+
+"""
+Mutation to change the active version of a DeployApp to another DeployAppVersion.
+"""
+type MarkAppVersionAsActivePayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input MarkAppVersionAsActiveInput {
+  """The ID of the DeployAppVersion to set as the new active version."""
+  appVersion: ID!
+  clientMutationId: String
+}
+
+"""Set a payment method as default for the user."""
+type SetDefaultPaymentMethodPayload {
+  success: Boolean!
+  billing: Billing!
+  clientMutationId: String
+}
+
+input SetDefaultPaymentMethodInput {
+  paymentMethod: ID!
+  clientMutationId: String
+}
+
+"""
+Try to detach a payment method from customer.
+Fails if trying to detach a default method,
+or if it's the only payment method.
+"""
+type DetachPaymentMethodPayload {
+  success: Boolean!
+  billing: Billing!
+  clientMutationId: String
+}
+
+input DetachPaymentMethodInput {
+  paymentMethod: ID!
+  clientMutationId: String
+}
+
+type GenerateDeployConfigTokenPayload {
+  token: String!
+  config: String!
+  clientMutationId: String
+}
+
+input GenerateDeployConfigTokenInput {
+  config: String!
+  clientMutationId: String
+}
+
+type RenameAppPayload {
+  success: Boolean!
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input RenameAppInput {
+  """App ID to delete."""
+  id: ID!
+
+  """New name for the app."""
+  name: String!
+  clientMutationId: String
+}
+
+type RenameAppAliasPayload {
+  success: Boolean!
+  alias: AppAlias!
+  clientMutationId: String
+}
+
+input RenameAppAliasInput {
+  """App alias ID to delete."""
+  id: ID!
+
+  """New name for the alias."""
+  name: String!
+  clientMutationId: String
+}
+
+type RequestAppTransferPayload {
+  appTransferRequest: AppTransferRequest
+  wasInstantlyTransferred: Boolean!
+  clientMutationId: String
+}
+
+type AppTransferRequest implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  previousOwnerObjectId: Int!
+  newOwnerObjectId: Int!
+  app: DeployApp!
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+  previousOwner: Owner!
+  newOwner: Owner!
+}
+
+input RequestAppTransferInput {
+  appId: ID!
+  newOwnerId: ID!
+  clientMutationId: String
+}
+
+type AcceptAppTransferRequestPayload {
+  app: DeployApp!
+  appTransferRequest: AppTransferRequest!
+  clientMutationId: String
+}
+
+input AcceptAppTransferRequestInput {
+  appTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type RemoveAppTransferRequestPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input RemoveAppTransferRequestInput {
+  appTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type CreateRepoForAppTemplatePayload {
+  success: Boolean!
+  repoId: ID!
+  clientMutationId: String
+}
+
+input CreateRepoForAppTemplateInput {
+  templateId: ID!
+  name: String!
+  namespace: String!
+  private: Boolean = false
+  clientMutationId: String
+}
+
+type RegisterDomainPayload {
+  success: Boolean!
+  domain: DNSDomain
+  clientMutationId: String
+}
+
+input RegisterDomainInput {
+  name: String!
+  namespace: String
+  importRecords: Boolean = true
+  clientMutationId: String
+}
+
+type UpsertDNSRecordPayload {
+  success: Boolean!
+  record: DNSRecord!
+  clientMutationId: String
+}
+
+input UpsertDNSRecordInput {
+  kind: RecordKind!
+  domainId: String!
+  name: String!
+  value: String!
+  ttl: Int
+  recordId: String
+  mx: DNSMXExtraInput
+  clientMutationId: String
+}
+
+enum RecordKind {
+  A
+  AAAA
+  CNAME
+  MX
+  NS
+  TXT
+  DNAME
+  PTR
+  SOA
+  SRV
+  CAA
+  SSHFP
+}
+
+input DNSMXExtraInput {
+  preference: Int!
+}
+
+type DeleteDNSRecordPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteDNSRecordInput {
+  recordId: ID!
+  clientMutationId: String
+}
+
+type UpsertDomainFromZoneFilePayload {
+  success: Boolean!
+  domain: DNSDomain!
+  clientMutationId: String
+}
+
+input UpsertDomainFromZoneFileInput {
+  zoneFile: String!
+  deleteMissingRecords: Boolean
+  clientMutationId: String
+}
+
+type DeleteDomainPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteDomainInput {
+  domainId: ID!
+  clientMutationId: String
+}
+
+type ObtainJSONWebTokenPayload {
+  payload: GenericScalar!
+  refreshExpiresIn: Int!
+  username: CaseInsensitiveString!
+  clientMutationId: String
+  token: String!
+  refreshToken: String!
+}
+
+"""
+The `GenericScalar` scalar type represents a generic
+GraphQL scalar value that could be:
+String, Boolean, Int, Float, List or Object.
+"""
+scalar GenericScalar
+
+"""
+The `CaseInsensitiveString` scalar type represents textual data, represented as UTF-8
+character sequences. The String type is most often used by GraphQL to
+represent free-form human-readable text.
+"""
+scalar CaseInsensitiveString
+
+input ObtainJSONWebTokenInput {
+  clientMutationId: String
+  username: String!
+  password: String!
+}
+
+type GenerateDeployTokenPayload {
+  token: String!
+  deployConfigVersion: DeployAppVersion!
+  clientMutationId: String
+}
+
+input GenerateDeployTokenInput {
+  deployConfigVersionId: String!
+  clientMutationId: String
+}
+
+type Verify {
+  payload: GenericScalar!
+}
+
+type Refresh {
+  payload: GenericScalar!
+  refreshExpiresIn: Int!
+  token: String!
+  refreshToken: String!
+}
+
+type Revoke {
+  revoked: Int!
+}
+
+type RegisterUserPayload {
+  token: String
+  clientMutationId: String
+}
+
+input RegisterUserInput {
+  fullName: String!
+  email: String!
+  username: CaseInsensitiveString!
+  password: String!
+  acceptedTos: Boolean
+  clientMutationId: String
+}
+
+type SocialAuthJWTPayload {
+  social: SocialAuth
+  token: String
+  clientMutationId: String
+}
+
+input SocialAuthJWTInput {
+  provider: String!
+  accessToken: String!
+  register: Boolean = false
+  clientMutationId: String
+}
+
+type ValidateUserEmailPayload {
+  user: User
+  clientMutationId: String
+}
+
+input ValidateUserEmailInput {
+  """The user id"""
+  userId: ID
+  challenge: String!
+  clientMutationId: String
+}
+
+type RequestPasswordResetPayload {
+  email: String!
+  errors: [ErrorType]
+  clientMutationId: String
+}
+
+type ErrorType {
+  field: String!
+  messages: [String!]!
+}
+
+input RequestPasswordResetInput {
+  email: String!
+  clientMutationId: String
+}
+
+type RequestValidationEmailPayload {
+  user: User
+  success: Boolean!
+  clientMutationId: String
+}
+
+input RequestValidationEmailInput {
+  """The user id"""
+  userId: ID
+  clientMutationId: String
+}
+
+type ChangeUserPasswordPayload {
+  token: String
+  clientMutationId: String
+}
+
+input ChangeUserPasswordInput {
+  """
+  The token associated to change the password. If not existing it will use the request user by default
+  """
+  token: String
+  oldPassword: String
+  password: String!
+  clientMutationId: String
+}
+
+type ChangeUserUsernamePayload {
+  user: User
+  token: String
+  clientMutationId: String
+}
+
+input ChangeUserUsernameInput {
+  """The new user username"""
+  username: CaseInsensitiveString!
+  clientMutationId: String
+}
+
+type ChangeUserEmailPayload {
+  user: User!
+  clientMutationId: String
+}
+
+input ChangeUserEmailInput {
+  newEmail: String!
+  clientMutationId: String
+}
+
+type UpdateUserInfoPayload {
+  user: User
+  clientMutationId: String
+}
+
+input UpdateUserInfoInput {
+  """The user id"""
+  userId: ID
+
+  """The user full name"""
+  fullName: String
+
+  """The user bio"""
+  bio: String
+
+  """The user avatar"""
+  avatar: String
+
+  """
+  The user Twitter (it can be the url, or the handle with or without the @)
+  """
+  twitter: String
+
+  """
+  The user Github (it can be the url, or the handle with or without the @)
+  """
+  github: String
+
+  """The user website (it must be a valid url)"""
+  websiteUrl: String
+
+  """The user location"""
+  location: String
+  clientMutationId: String
+}
+
+type ValidateUserPasswordPayload {
+  success: Boolean
+  clientMutationId: String
+}
+
+input ValidateUserPasswordInput {
+  password: String!
+  clientMutationId: String
+}
+
+type GenerateAPITokenPayload {
+  token: APIToken
+  tokenRaw: String
+  user: User
+  clientMutationId: String
+}
+
+input GenerateAPITokenInput {
+  identifier: String
+  clientMutationId: String
+}
+
+type RevokeAPITokenPayload {
+  token: APIToken
+  success: Boolean
+  clientMutationId: String
+}
+
+input RevokeAPITokenInput {
+  """The API token ID"""
+  tokenId: ID!
+  clientMutationId: String
+}
+
+type CheckUserExistsPayload {
+  exists: Boolean!
+
+  """The user is only returned if the user input was the username"""
+  user: User
+  clientMutationId: String
+}
+
+input CheckUserExistsInput {
+  """The user"""
+  user: String!
+  clientMutationId: String
+}
+
+type ReadNotificationPayload {
+  notification: UserNotification
+  clientMutationId: String
+}
+
+input ReadNotificationInput {
+  notificationId: ID!
+  clientMutationId: String
+}
+
+type SeePendingNotificationsPayload {
+  success: Boolean
+  clientMutationId: String
+}
+
+input SeePendingNotificationsInput {
+  clientMutationId: String
+}
+
+type NewNoncePayload {
+  nonce: Nonce!
+  clientMutationId: String
+}
+
+input NewNonceInput {
+  name: String!
+  callbackUrl: String!
+  clientMutationId: String
+}
+
+type ValidateNoncePayload {
+  nonce: Nonce!
+  clientMutationId: String
+}
+
+input ValidateNonceInput {
+  id: ID!
+  secret: String!
+  clientMutationId: String
+}
+
+type MFATOTPTokenType {
+  qr: String
+  secretKey: String
+}
+
+input MFATOTPGetTokenInput {
+  clientMutationId: String
+}
+
+type MFATOTPVerifyPayload {
+  status: MFATOTPVerifyStatus
+  clientMutationId: String
+}
+
+enum MFATOTPVerifyStatus {
+  SUCCESS
+  RECOVERY
+}
+
+input MFATOTPVerifyInput {
+  answer: String!
+  secretKey: String!
+  clientMutationId: String
+}
+
+"""Response object for MFAAuth mutation."""
+type MFAAuthResponse {
+  success: Boolean!
+  token: String
+  refreshToken: String
+  username: String
+  refreshTokenExpiresIn: Int
+}
+
+input MFATOTPAuthInput {
+  username: String!
+  otp: String!
+  clientMutationId: String
+}
+
+type MFARecoveryCodes {
+  codes: [String]!
+}
+
+input MFAGenerateRecoveryTokenInput {
+  clientMutationId: String
+}
+
+input MFARecoveryAuthInput {
+  username: String!
+  otp: String!
+  clientMutationId: String
+}
+
+input MFAEmailAuthInput {
+  username: String!
+  otp: String!
+  clientMutationId: String
+}
+
+type MFAEmailGenerationResponse {
+  success: Boolean!
+}
+
+input MFAGenerateEmailOTPInput {
+  clientMutationId: String
+}
+
+type PublishPublicKeyPayload {
+  success: Boolean!
+  publicKey: PublicKey!
+  clientMutationId: String
+}
+
+input PublishPublicKeyInput {
+  keyId: String!
+  key: String!
+  verifyingSignatureId: String
+  clientMutationId: String
+}
+
+type PublishPackagePayload {
+  success: Boolean!
+  packageVersion: PackageVersion!
+  clientMutationId: String
+}
+
+input PublishPackageInput {
+  name: String!
+  version: String!
+  description: String!
+  manifest: String!
+  license: String
+  licenseFile: String
+  readme: String
+  repository: String
+  homepage: String
+  file: String
+  signedUrl: String
+  signature: InputSignature
+
+  """The package icon"""
+  icon: String
+
+  """Whether the package is private"""
+  private: Boolean = false
+
+  """The upload format of the package"""
+  uploadFormat: UploadFormat = targz
+
+  """Whether to wait for webc generation to finish"""
+  wait: Boolean = false
+  clientMutationId: String
+}
+
+input InputSignature {
+  publicKeyKeyId: String!
+  data: String!
+}
+
+enum UploadFormat {
+  targz
+  webcv2
+}
+
+type UpdatePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UpdatePackageInput {
+  packageId: ID!
+
+  """The package icon"""
+  icon: String
+  clientMutationId: String
+}
+
+type LikePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input LikePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type UnlikePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UnlikePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type WatchPackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input WatchPackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type UnwatchPackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UnwatchPackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type ArchivePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input ArchivePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type RenamePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RenamePackageInput {
+  packageId: ID!
+  newName: String!
+  clientMutationId: String
+}
+
+type ChangePackageVersionArchivedStatusPayload {
+  packageVersion: PackageVersion!
+  clientMutationId: String
+}
+
+input ChangePackageVersionArchivedStatusInput {
+  packageVersionId: ID!
+  isArchived: Boolean
+  clientMutationId: String
+}
+
+type CreateNamespacePayload {
+  namespace: Namespace!
+  user: User!
+  clientMutationId: String
+}
+
+input CreateNamespaceInput {
+  name: String!
+
+  """The namespace display name"""
+  displayName: String
+
+  """The namespace description"""
+  description: String
+
+  """The namespace avatar"""
+  avatar: String
+  clientMutationId: String
+}
+
+type UpdateNamespacePayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input UpdateNamespaceInput {
+  namespaceId: ID!
+
+  """The namespace slug name"""
+  name: String
+
+  """The namespace display name"""
+  displayName: String
+
+  """The namespace description"""
+  description: String
+
+  """The namespace avatar"""
+  avatar: String
+
+  """
+  The user Twitter (it can be the url, or the handle with or without the @)
+  """
+  twitter: String
+
+  """
+  The user Github (it can be the url, or the handle with or without the @)
+  """
+  github: String
+
+  """The user website (it must be a valid url)"""
+  websiteUrl: String
+  clientMutationId: String
+}
+
+type DeleteNamespacePayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteNamespaceInput {
+  namespaceId: ID!
+  clientMutationId: String
+}
+
+type InviteNamespaceCollaboratorPayload {
+  invite: NamespaceCollaboratorInvite!
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input InviteNamespaceCollaboratorInput {
+  namespaceId: ID!
+  role: GrapheneRole!
+  username: String
+  email: String
+  clientMutationId: String
+}
+
+type AcceptNamespaceCollaboratorInvitePayload {
+  namespaceCollaboratorInvite: NamespaceCollaboratorInvite!
+  clientMutationId: String
+}
+
+input AcceptNamespaceCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemoveNamespaceCollaboratorInvitePayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input RemoveNamespaceCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemoveNamespaceCollaboratorPayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input RemoveNamespaceCollaboratorInput {
+  namespaceCollaboratorId: ID!
+  clientMutationId: String
+}
+
+type UpdateNamespaceCollaboratorRolePayload {
+  collaborator: NamespaceCollaborator!
+  clientMutationId: String
+}
+
+input UpdateNamespaceCollaboratorRoleInput {
+  namespaceCollaboratorId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type UpdateNamespaceCollaboratorInviteRolePayload {
+  collaboratorInvite: NamespaceCollaboratorInvite!
+  clientMutationId: String
+}
+
+input UpdateNamespaceCollaboratorInviteRoleInput {
+  namespaceCollaboratorInviteId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type InvitePackageCollaboratorPayload {
+  invite: PackageCollaboratorInvite!
+  package: Package!
+  clientMutationId: String
+}
+
+input InvitePackageCollaboratorInput {
+  packageName: String!
+  role: GrapheneRole!
+  username: String
+  email: String
+  clientMutationId: String
+}
+
+type AcceptPackageCollaboratorInvitePayload {
+  packageCollaboratorInvite: PackageCollaboratorInvite!
+  clientMutationId: String
+}
+
+input AcceptPackageCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemovePackageCollaboratorInvitePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type UpdatePackageCollaboratorRolePayload {
+  collaborator: PackageCollaborator!
+  clientMutationId: String
+}
+
+input UpdatePackageCollaboratorRoleInput {
+  packageCollaboratorId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type UpdatePackageCollaboratorInviteRolePayload {
+  collaboratorInvite: PackageCollaboratorInvite!
+  clientMutationId: String
+}
+
+input UpdatePackageCollaboratorInviteRoleInput {
+  packageCollaboratorInviteId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type RemovePackageCollaboratorPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageCollaboratorInput {
+  packageCollaboratorId: ID!
+  clientMutationId: String
+}
+
+type RequestPackageTransferPayload {
+  package: Package!
+  wasInstantlyTransferred: Boolean!
+  packageTransferRequest: PackageTransferRequest
+  clientMutationId: String
+}
+
+input RequestPackageTransferInput {
+  packageId: ID!
+  newOwnerId: ID!
+  clientMutationId: String
+}
+
+type AcceptPackageTransferRequestPayload {
+  package: Package!
+  packageTransferRequest: PackageTransferRequest!
+  clientMutationId: String
+}
+
+input AcceptPackageTransferRequestInput {
+  packageTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type RemovePackageTransferRequestPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageTransferRequestInput {
+  packageTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type GenerateBindingsForAllPackagesPayload {
+  message: String!
+  clientMutationId: String
+}
+
+input GenerateBindingsForAllPackagesInput {
+  bindingsGeneratorId: ID
+  bindingsGeneratorCommand: String
+  clientMutationId: String
+}
+
+type MakePackagePublicPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input MakePackagePublicInput {
+  """The ID of the package to make public"""
+  id: ID!
+  clientMutationId: String
+}
+
+type Subscription {
+  streamLogs(
+    appVersionId: ID!
+
+    """
+    Get logs starting from this timestamp. Takes ISO timestamp in UTC timezone.
+    """
+    startingFromISO: DateTime
+
+    """
+    Fetch logs until this timestamp. Takes ISO timestamp in UTC timezone. If specified, the subscription will at this time.
+    """
+    untilISO: DateTime
+
+    """Filter logs by stream"""
+    streams: [LogStream]
+
+    """Filter logs by instance ids"""
+    instanceIds: [String]
+
+    """Search logs for this term"""
+    searchTerm: String
+  ): Log!
+  waitOnRepoCreation(repoId: ID!): Boolean!
+  appIsPublishedFromRepo(repoId: ID!): DeployAppVersion!
+  packageVersionCreated(publishedBy: ID, ownerId: ID): PackageVersion!
+
+  """Subscribe to package version ready"""
+  packageVersionReady(packageVersionId: ID!): PackageVersionReadyResponse!
+  userNotificationCreated(userId: ID!): UserNotificationCreated!
+}
+
+type PackageVersionReadyResponse {
+  state: PackageVersionState!
+  packageVersion: PackageVersion!
+  success: Boolean!
+}
+
+enum PackageVersionState {
+  WEBC_GENERATED
+  BINDINGS_GENERATED
+  NATIVE_EXES_GENERATED
+}
+
+type UserNotificationCreated {
+  notification: UserNotification
+  notificationDeletedId: ID
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/client.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/client.rs
new file mode 100644
index 0000000..66270ed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/client.rs
@@ -0,0 +1,209 @@
+use std::time::Duration;
+
+use anyhow::{bail, Context as _};
+use cynic::{http::CynicReqwestError, GraphQlResponse, Operation};
+use url::Url;
+
+use crate::GraphQLApiFailure;
+
+/// API client for the Wasmer API.
+///
+/// Use the queries in [`crate::queries`] to interact with the API.
+#[derive(Clone, Debug)]
+pub struct WasmerClient {
+    auth_token: Option<String>,
+    graphql_endpoint: Url,
+
+    pub(crate) client: reqwest::Client,
+    pub(crate) user_agent: reqwest::header::HeaderValue,
+    #[allow(unused)]
+    extra_debugging: bool,
+}
+
+impl WasmerClient {
+    pub fn graphql_endpoint(&self) -> &Url {
+        &self.graphql_endpoint
+    }
+
+    pub fn auth_token(&self) -> Option<&str> {
+        self.auth_token.as_deref()
+    }
+
+    fn parse_user_agent(user_agent: &str) -> Result<reqwest::header::HeaderValue, anyhow::Error> {
+        if user_agent.is_empty() {
+            bail!("user agent must not be empty");
+        }
+        user_agent
+            .parse()
+            .with_context(|| format!("invalid user agent: '{}'", user_agent))
+    }
+
+    pub fn new_with_client(
+        client: reqwest::Client,
+        graphql_endpoint: Url,
+        user_agent: &str,
+    ) -> Result<Self, anyhow::Error> {
+        Ok(Self {
+            client,
+            auth_token: None,
+            user_agent: Self::parse_user_agent(user_agent)?,
+            graphql_endpoint,
+            extra_debugging: false,
+        })
+    }
+
+    pub fn new(graphql_endpoint: Url, user_agent: &str) -> Result<Self, anyhow::Error> {
+        let client = reqwest::Client::builder()
+            .connect_timeout(Duration::from_secs(10))
+            .timeout(Duration::from_secs(90))
+            .build()
+            .context("could not construct http client")?;
+        Self::new_with_client(client, graphql_endpoint, user_agent)
+    }
+
+    pub fn with_auth_token(mut self, auth_token: String) -> Self {
+        self.auth_token = Some(auth_token);
+        self
+    }
+
+    pub(crate) async fn run_graphql_raw<ResponseData, Vars>(
+        &self,
+        operation: Operation<ResponseData, Vars>,
+    ) -> Result<cynic::GraphQlResponse<ResponseData>, anyhow::Error>
+    where
+        Vars: serde::Serialize + std::fmt::Debug,
+        ResponseData: serde::de::DeserializeOwned + std::fmt::Debug + 'static,
+    {
+        let req = self
+            .client
+            .post(self.graphql_endpoint.as_str())
+            .header(reqwest::header::USER_AGENT, &self.user_agent);
+        let req = if let Some(token) = &self.auth_token {
+            req.bearer_auth(token)
+        } else {
+            req
+        };
+
+        if self.extra_debugging {
+            tracing::trace!(
+                query=%operation.query,
+                vars=?operation.variables,
+                "running GraphQL query"
+            );
+        }
+        let query = operation.query.clone();
+
+        tracing::trace!(
+            endpoint=%self.graphql_endpoint,
+            query=serde_json::to_string(&operation).unwrap_or_default(),
+            "sending graphql query"
+        );
+
+        let res = req.json(&operation).send().await;
+
+        let res = match res {
+            Ok(response) => {
+                let status = response.status();
+                if !status.is_success() {
+                    let body_string = match response.text().await {
+                        Ok(b) => b,
+                        Err(err) => {
+                            tracing::error!("could not load response body: {err}");
+                            "<could not retrieve body>".to_string()
+                        }
+                    };
+
+                    match serde_json::from_str::<GraphQlResponse<ResponseData>>(&body_string) {
+                        Ok(response) => Ok(response),
+                        Err(_) => Err(CynicReqwestError::ErrorResponse(status, body_string)),
+                    }
+                } else {
+                    let body = response.bytes().await?;
+
+                    let jd = &mut serde_json::Deserializer::from_slice(&body);
+                    let data: Result<GraphQlResponse<ResponseData>, _> =
+                        serde_path_to_error::deserialize(jd).map_err(|err| {
+                            let body_txt = String::from_utf8_lossy(&body);
+                            CynicReqwestError::ErrorResponse(
+                                reqwest::StatusCode::INTERNAL_SERVER_ERROR,
+                                format!("Could not decode JSON response: {err} -- '{body_txt}'"),
+                            )
+                        });
+
+                    data
+                }
+            }
+            Err(e) => Err(CynicReqwestError::ReqwestError(e)),
+        };
+        let res = match res {
+            Ok(res) => {
+                tracing::trace!(?res, "GraphQL query succeeded");
+                res
+            }
+            Err(err) => {
+                tracing::error!(?err, "GraphQL query failed");
+                return Err(err.into());
+            }
+        };
+
+        if let Some(errors) = &res.errors {
+            if !errors.is_empty() {
+                tracing::warn!(
+                    ?errors,
+                    data=?res.data,
+                    %query,
+                    endpoint=%self.graphql_endpoint,
+                    "GraphQL query succeeded, but returned errors",
+                );
+            }
+        }
+
+        Ok(res)
+    }
+
+    pub(crate) async fn run_graphql<ResponseData, Vars>(
+        &self,
+        operation: Operation<ResponseData, Vars>,
+    ) -> Result<ResponseData, anyhow::Error>
+    where
+        Vars: serde::Serialize + std::fmt::Debug,
+        ResponseData: serde::de::DeserializeOwned + std::fmt::Debug + 'static,
+    {
+        let res = self.run_graphql_raw(operation).await?;
+
+        if let Some(data) = res.data {
+            Ok(data)
+        } else if let Some(errs) = res.errors {
+            let errs = GraphQLApiFailure { errors: errs };
+            Err(errs).context("GraphQL query failed")
+        } else {
+            Err(anyhow::anyhow!("Query did not return any data"))
+        }
+    }
+
+    /// Run a GraphQL query, but fail (return an Error) if any error is returned
+    /// in the response.
+    pub(crate) async fn run_graphql_strict<ResponseData, Vars>(
+        &self,
+        operation: Operation<ResponseData, Vars>,
+    ) -> Result<ResponseData, anyhow::Error>
+    where
+        Vars: serde::Serialize + std::fmt::Debug,
+        ResponseData: serde::de::DeserializeOwned + std::fmt::Debug + 'static,
+    {
+        let res = self.run_graphql_raw(operation).await?;
+
+        if let Some(errs) = res.errors {
+            if !errs.is_empty() {
+                let errs = GraphQLApiFailure { errors: errs };
+                return Err(errs).context("GraphQL query failed");
+            }
+        }
+
+        if let Some(data) = res.data {
+            Ok(data)
+        } else {
+            Err(anyhow::anyhow!("Query did not return any data"))
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/error.rs
new file mode 100644
index 0000000..76f5fa9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/error.rs
@@ -0,0 +1,36 @@
+///  One or multiple errors returned by the GraphQL API.
+// Mainly exists to implement [`std::error::Error`].
+#[derive(Debug)]
+pub struct GraphQLApiFailure {
+    pub errors: Vec<cynic::GraphQlError>,
+}
+
+impl GraphQLApiFailure {
+    pub fn from_errors(
+        msg: impl Into<String>,
+        errors: Option<Vec<cynic::GraphQlError>>,
+    ) -> anyhow::Error {
+        let msg = msg.into();
+        if let Some(errs) = errors {
+            if !errs.is_empty() {
+                let err = GraphQLApiFailure { errors: errs };
+                return anyhow::Error::new(err).context(msg);
+            }
+        }
+        anyhow::anyhow!("{msg} - query did not return any data")
+    }
+}
+
+impl std::fmt::Display for GraphQLApiFailure {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let errs = self
+            .errors
+            .iter()
+            .map(|err| err.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+        write!(f, "GraphQL API failure: {}", errs)
+    }
+}
+
+impl std::error::Error for GraphQLApiFailure {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/global_id.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/global_id.rs
new file mode 100644
index 0000000..e7481cd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/global_id.rs
@@ -0,0 +1,483 @@
+//! [`GlobalId`]s are used by the backend to identify a specific object.
+//!
+//! This module provides a parser/encoder and related type defintions
+//! for global ids.
+
+use std::fmt::Display;
+
+#[repr(u16)]
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum NodeKind {
+    User = 0,
+    SocialAuth = 1,
+    Namespace = 2,
+    Package = 3,
+    PackageVersion = 4,
+    PackageCollaborator = 5,
+    PackageCollaboratorInvite = 6,
+    NativeExecutable = 7,
+    PackageVersionNPMBinding = 8,
+    PackageVersionPythonBinding = 9,
+    PackageTransferRequest = 10,
+    Interface = 11,
+    InterfaceVersion = 12,
+    PublicKey = 13,
+    UserNotification = 14,
+    ActivityEvent = 15,
+    NamespaceCollaborator = 16,
+    NamespaceCollaboratorInvite = 17,
+    BindingsGenerator = 18,
+    DeployConfigVersion = 19,
+    DeployConfigInfo = 20,
+    DeployApp = 21,
+    DeployAppVersion = 22,
+    Waitlist = 23,
+    WaitlistMember = 24,
+    CardPaymentMethod = 25,
+    PaymentIntent = 26,
+    AppAlias = 27,
+    Nonce = 28,
+    TermsOfService = 29,
+}
+
+impl NodeKind {
+    pub fn from_num(x: u64) -> Option<Self> {
+        match x {
+            0 => Some(Self::User),
+            1 => Some(Self::SocialAuth),
+            2 => Some(Self::Namespace),
+            3 => Some(Self::Package),
+            4 => Some(Self::PackageVersion),
+            5 => Some(Self::PackageCollaborator),
+            6 => Some(Self::PackageCollaboratorInvite),
+            7 => Some(Self::NativeExecutable),
+            8 => Some(Self::PackageVersionNPMBinding),
+            9 => Some(Self::PackageVersionPythonBinding),
+            10 => Some(Self::PackageTransferRequest),
+            11 => Some(Self::Interface),
+            12 => Some(Self::InterfaceVersion),
+            13 => Some(Self::PublicKey),
+            14 => Some(Self::UserNotification),
+            15 => Some(Self::ActivityEvent),
+            16 => Some(Self::NamespaceCollaborator),
+            17 => Some(Self::NamespaceCollaboratorInvite),
+            18 => Some(Self::BindingsGenerator),
+            19 => Some(Self::DeployConfigVersion),
+            20 => Some(Self::DeployConfigInfo),
+            21 => Some(Self::DeployApp),
+            22 => Some(Self::DeployAppVersion),
+            23 => Some(Self::Waitlist),
+            24 => Some(Self::WaitlistMember),
+            25 => Some(Self::CardPaymentMethod),
+            26 => Some(Self::PaymentIntent),
+            27 => Some(Self::AppAlias),
+            28 => Some(Self::Nonce),
+            29 => Some(Self::TermsOfService),
+            _ => None,
+        }
+    }
+
+    pub fn parse_prefix(s: &str) -> Option<NodeKind> {
+        match s {
+            "u" => Some(Self::User),
+            "su" => Some(Self::SocialAuth),
+            "ns" => Some(Self::Namespace),
+            "pk" => Some(Self::Package),
+            "pkv" => Some(Self::PackageVersion),
+            "pc" => Some(Self::PackageCollaborator),
+            "pci" => Some(Self::PackageCollaboratorInvite),
+            "ne" => Some(Self::NativeExecutable),
+            "pkvbjs" => Some(Self::PackageVersionNPMBinding),
+            "pkvbpy" => Some(Self::PackageVersionPythonBinding),
+            "pt" => Some(Self::PackageTransferRequest),
+            "in" => Some(Self::Interface),
+            "inv" => Some(Self::InterfaceVersion),
+            "pub" => Some(Self::PublicKey),
+            "nt" => Some(Self::UserNotification),
+            "ae" => Some(Self::ActivityEvent),
+            "nsc" => Some(Self::NamespaceCollaborator),
+            "nsci" => Some(Self::NamespaceCollaboratorInvite),
+            "bg" => Some(Self::BindingsGenerator),
+            "dcv" => Some(Self::DeployConfigVersion),
+            "dci" => Some(Self::DeployConfigInfo),
+            "da" => Some(Self::DeployApp),
+            "dav" => Some(Self::DeployAppVersion),
+            "wl" => Some(Self::Waitlist),
+            "wlm" => Some(Self::WaitlistMember),
+            "cpm" => Some(Self::CardPaymentMethod),
+            "pi" => Some(Self::PaymentIntent),
+            "daa" => Some(Self::AppAlias),
+            "nnc" => Some(Self::Nonce),
+            "tos" => Some(Self::TermsOfService),
+            _ => None,
+        }
+    }
+
+    fn as_prefix(&self) -> &'static str {
+        match self {
+            Self::User => "u",
+            Self::SocialAuth => "su",
+            Self::Namespace => "ns",
+            Self::Package => "pk",
+            Self::PackageVersion => "pkv",
+            Self::PackageCollaborator => "pc",
+            Self::PackageCollaboratorInvite => "pci",
+            Self::NativeExecutable => "ne",
+            Self::PackageVersionNPMBinding => "pkvbjs",
+            Self::PackageVersionPythonBinding => "pkvbpy",
+            Self::PackageTransferRequest => "pt",
+            Self::Interface => "in",
+            Self::InterfaceVersion => "inv",
+            Self::PublicKey => "pub",
+            Self::UserNotification => "nt",
+            Self::ActivityEvent => "ae",
+            Self::NamespaceCollaborator => "nsc",
+            Self::NamespaceCollaboratorInvite => "nsci",
+            Self::BindingsGenerator => "bg",
+            Self::DeployConfigVersion => "dcv",
+            Self::DeployConfigInfo => "dci",
+            Self::DeployApp => "da",
+            Self::DeployAppVersion => "dav",
+            Self::Waitlist => "wl",
+            Self::WaitlistMember => "wlm",
+            Self::CardPaymentMethod => "cpm",
+            Self::PaymentIntent => "pi",
+            Self::AppAlias => "daa",
+            Self::Nonce => "nnc",
+            Self::TermsOfService => "tos",
+        }
+    }
+}
+
+impl Display for NodeKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let name = match self {
+            Self::User => "User",
+            Self::SocialAuth => "SocialAuth",
+            Self::Namespace => "Namespace",
+            Self::Package => "Package",
+            Self::PackageVersion => "PackageVersion",
+            Self::PackageCollaborator => "PackageCollaborator",
+            Self::PackageCollaboratorInvite => "PackageCollaboratorInvite",
+            Self::NativeExecutable => "NativeExecutable",
+            Self::PackageVersionNPMBinding => "PackageVersionNPMBinding",
+            Self::PackageVersionPythonBinding => "PackageVersionPythonBinding",
+            Self::PackageTransferRequest => "PackageTransferRequest",
+            Self::Interface => "Interface",
+            Self::InterfaceVersion => "InterfaceVersion",
+            Self::PublicKey => "PublicKey",
+            Self::UserNotification => "UserNotification",
+            Self::ActivityEvent => "ActivityEvent",
+            Self::NamespaceCollaborator => "NamespaceCollaborator",
+            Self::NamespaceCollaboratorInvite => "NamespaceCollaboratorInvite",
+            Self::BindingsGenerator => "BindingsGenerator",
+            Self::DeployConfigVersion => "DeployConfigVersion",
+            Self::DeployConfigInfo => "DeployConfigInfo",
+            Self::DeployApp => "DeployApp",
+            Self::DeployAppVersion => "DeployAppVersion",
+            Self::Waitlist => "Waitlist",
+            Self::WaitlistMember => "WaitlistMember",
+            Self::CardPaymentMethod => "CardPaymentMethod",
+            Self::PaymentIntent => "PaymentIntent",
+            Self::AppAlias => "AppAlias",
+            Self::Nonce => "Nonce",
+            Self::TermsOfService => "TermsOfService",
+        };
+        write!(f, "{name}")
+    }
+}
+
+/// Global id of backend nodes.
+///
+/// IDs are encoded using the "hashid" scheme, which uses a given alphabet and
+/// a salt to encode u64 numbers into a string hash.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlobalId {
+    /// The node type of the ID.
+    kind: NodeKind,
+    /// The database ID of the node.
+    database_id: u64,
+}
+
+impl GlobalId {
+    /// Salt used by the backend to encode hashes.
+    const SALT: &'static str = "wasmer salt hashid";
+    /// Minimum length of the encoded hashes.
+    const MIN_LENGTH: usize = 12;
+
+    /// Hash alphabet used for the prefix id variant.
+    const ALPHABET_PREFIXED: &'static str =
+        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+
+    /// Hash alphabet used for the non-prefixed id variant.
+    const ALPHABET_URL: &'static str = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+    pub fn new(kind: NodeKind, database_id: u64) -> Self {
+        Self { kind, database_id }
+    }
+
+    fn build_harsh(alphabet: &str, salt: &[u8]) -> harsh::Harsh {
+        harsh::HarshBuilder::new()
+            .alphabet(alphabet.as_bytes())
+            .salt(salt)
+            .length(GlobalId::MIN_LENGTH)
+            .build()
+            .unwrap()
+    }
+
+    fn build_harsh_prefixed() -> harsh::Harsh {
+        Self::build_harsh(Self::ALPHABET_PREFIXED, Self::SALT.as_bytes())
+    }
+
+    fn build_harsh_url() -> harsh::Harsh {
+        Self::build_harsh(Self::ALPHABET_URL, Self::SALT.as_bytes())
+    }
+
+    pub fn kind(&self) -> NodeKind {
+        self.kind
+    }
+
+    pub fn database_id(&self) -> u64 {
+        self.database_id
+    }
+
+    /// Encode a prefixed global id.
+    pub fn encode_prefixed(&self) -> String {
+        let hash = Self::build_harsh_prefixed().encode(&[
+            // scope
+            1,
+            // version
+            2,
+            self.kind as u64,
+            self.database_id,
+        ]);
+
+        format!("{}_{}", self.kind.as_prefix(), hash)
+    }
+
+    fn parse_values(values: &[u64]) -> Result<Self, ErrorKind> {
+        let scope = values.first().cloned().ok_or(ErrorKind::MissingScope)?;
+
+        if scope != 1 {
+            return Err(ErrorKind::UnknownScope(scope));
+        }
+
+        let version = values.get(1).cloned().ok_or(ErrorKind::MissingVersion)?;
+        if version != 2 {
+            return Err(ErrorKind::UnknownVersion(version));
+        }
+
+        let ty_raw = values.get(2).cloned().ok_or(ErrorKind::MissingNodeType)?;
+        let ty_parsed = NodeKind::from_num(ty_raw).ok_or(ErrorKind::UnknownNodeType(ty_raw))?;
+
+        let db_id = values.get(3).cloned().ok_or(ErrorKind::MissingDatabaseId)?;
+
+        Ok(Self {
+            kind: ty_parsed,
+            database_id: db_id,
+        })
+    }
+
+    /// Parse a prefixed global id.
+    pub fn parse_prefixed(hash: &str) -> Result<Self, GlobalIdParseError> {
+        let (prefix, value) = hash
+            .split_once('_')
+            .ok_or_else(|| GlobalIdParseError::new(hash, ErrorKind::MissingPrefix))?;
+
+        if prefix.is_empty() {
+            return Err(GlobalIdParseError::new(hash, ErrorKind::MissingPrefix));
+        }
+
+        let ty_prefix = NodeKind::parse_prefix(prefix).ok_or_else(|| {
+            GlobalIdParseError::new(hash, ErrorKind::UnknownPrefix(prefix.to_string()))
+        })?;
+
+        let values = Self::build_harsh_prefixed()
+            .decode(value)
+            .map_err(|err| GlobalIdParseError::new(hash, ErrorKind::Decode(err.to_string())))?;
+
+        let s = Self::parse_values(&values).map_err(|kind| GlobalIdParseError::new(hash, kind))?;
+
+        if ty_prefix != s.kind {
+            return Err(GlobalIdParseError::new(hash, ErrorKind::PrefixTypeMismatch));
+        }
+
+        Ok(s)
+    }
+
+    /// Encode a non-prefixed global id.
+    ///
+    /// Note: URL ids use a different alphabet than prefixed ids.
+    pub fn encode_url(&self) -> String {
+        Self::build_harsh_url().encode(&[
+            // scope
+            1,
+            // version
+            2,
+            self.kind as u64,
+            self.database_id,
+        ])
+    }
+
+    /// Parse a non-prefixed URL global id variant.
+    ///
+    /// Note: URL ids use a different alphabet than prefixed ids.
+    pub fn parse_url(hash: &str) -> Result<Self, GlobalIdParseError> {
+        let values = Self::build_harsh_url()
+            .decode(hash)
+            .map_err(|err| GlobalIdParseError::new(hash, ErrorKind::Decode(err.to_string())))?;
+
+        Self::parse_values(&values).map_err(|kind| GlobalIdParseError::new(hash, kind))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GlobalIdParseError {
+    id: String,
+    kind: ErrorKind,
+}
+
+impl GlobalIdParseError {
+    fn new(id: impl Into<String>, kind: ErrorKind) -> Self {
+        Self {
+            id: id.into(),
+            kind,
+        }
+    }
+}
+
+/// Error type for parsing of [`GlobalId`]s.
+// Note: kept private on purpose, not useful to export.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+enum ErrorKind {
+    MissingPrefix,
+    UnknownPrefix(String),
+    PrefixTypeMismatch,
+    MissingScope,
+    UnknownScope(u64),
+    MissingVersion,
+    UnknownVersion(u64),
+    MissingNodeType,
+    UnknownNodeType(u64),
+    MissingDatabaseId,
+    Decode(String),
+}
+
+impl std::fmt::Display for GlobalIdParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "could not parse global id '{}': ", self.id)?;
+
+        match &self.kind {
+            ErrorKind::UnknownPrefix(p) => {
+                write!(f, "unknown type prefix '{}'", p)
+            }
+            ErrorKind::Decode(s) => {
+                write!(f, "decode error: {}", s)
+            }
+            ErrorKind::MissingScope => {
+                write!(f, "missing scope value")
+            }
+            ErrorKind::UnknownScope(x) => {
+                write!(f, "unknown scope value {}", x)
+            }
+            ErrorKind::MissingVersion => {
+                write!(f, "missing version value")
+            }
+            ErrorKind::UnknownVersion(v) => {
+                write!(f, "unknown version value {}", v)
+            }
+            ErrorKind::UnknownNodeType(t) => {
+                write!(f, "unknown node type '{}'", t)
+            }
+            ErrorKind::MissingPrefix => write!(f, "missing prefix"),
+            ErrorKind::PrefixTypeMismatch => write!(f, "prefix type mismatch"),
+            ErrorKind::MissingNodeType => write!(f, "missing node type"),
+            ErrorKind::MissingDatabaseId => write!(f, "missing database id"),
+        }
+    }
+}
+
+impl std::error::Error for GlobalIdParseError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_global_id() {
+        // Roundtrip.
+        let x1 = GlobalId {
+            kind: NodeKind::DeployApp,
+            database_id: 123,
+        };
+        assert_eq!(Ok(x1), GlobalId::parse_prefixed(&x1.encode_prefixed()),);
+        assert_eq!(Ok(x1), GlobalId::parse_url(&x1.encode_url()));
+
+        assert_eq!(
+            GlobalId::parse_prefixed("da_MRrWI0t5U582"),
+            Ok(GlobalId {
+                kind: NodeKind::DeployApp,
+                database_id: 273,
+            })
+        );
+
+        // Error conditions.
+        assert_eq!(
+            GlobalId::parse_prefixed("oOtQIDI7q").err().unwrap().kind,
+            ErrorKind::MissingPrefix,
+        );
+        assert_eq!(
+            GlobalId::parse_prefixed("oOtQIDI7q").err().unwrap().kind,
+            ErrorKind::MissingPrefix,
+        );
+        assert_eq!(
+            GlobalId::parse_prefixed("_oOtQIDI7q").err().unwrap().kind,
+            ErrorKind::MissingPrefix,
+        );
+        assert_eq!(
+            GlobalId::parse_prefixed("lala_oOtQIDI7q")
+                .err()
+                .unwrap()
+                .kind,
+            ErrorKind::UnknownPrefix("lala".to_string()),
+        );
+
+        let kind = GlobalId::parse_prefixed("da_xxx").err().unwrap().kind;
+        assert!(matches!(kind, ErrorKind::Decode(_)));
+    }
+
+    #[test]
+    fn test_global_id_parse_values() {
+        assert_eq!(GlobalId::parse_values(&[]), Err(ErrorKind::MissingScope),);
+        assert_eq!(
+            GlobalId::parse_values(&[2]),
+            Err(ErrorKind::UnknownScope(2)),
+        );
+        assert_eq!(GlobalId::parse_values(&[1]), Err(ErrorKind::MissingVersion),);
+        assert_eq!(
+            GlobalId::parse_values(&[1, 999]),
+            Err(ErrorKind::UnknownVersion(999)),
+        );
+        assert_eq!(
+            GlobalId::parse_values(&[1, 2]),
+            Err(ErrorKind::MissingNodeType),
+        );
+        assert_eq!(
+            GlobalId::parse_values(&[1, 2, 99999]),
+            Err(ErrorKind::UnknownNodeType(99999)),
+        );
+        assert_eq!(
+            GlobalId::parse_values(&[1, 2, 1]),
+            Err(ErrorKind::MissingDatabaseId),
+        );
+        assert_eq!(
+            GlobalId::parse_values(&[1, 2, 1, 1]),
+            Ok(GlobalId {
+                kind: NodeKind::SocialAuth,
+                database_id: 1,
+            }),
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/gql.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/gql.rs
new file mode 100644
index 0000000..d9657ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/gql.rs
@@ -0,0 +1,2 @@
+
+types
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/lib.rs
new file mode 100644
index 0000000..ff6c2d1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/lib.rs
@@ -0,0 +1,29 @@
+// Allowed because it makes code more readable.
+#![allow(clippy::bool_comparison, clippy::match_like_matches_macro)]
+
+mod client;
+mod error;
+
+pub mod global_id;
+pub mod query;
+pub mod stream;
+pub mod types;
+
+use url::Url;
+
+pub use self::{client::WasmerClient, error::GraphQLApiFailure};
+
+/// Api endpoint for the dev environment.
+pub const ENDPOINT_DEV: &str = "https://registry.wasmer.wtf/graphql";
+/// Api endpoint for the prod environment.
+pub const ENDPOINT_PROD: &str = "https://registry.wasmer.io/graphql";
+
+/// API endpoint for the dev environment.
+pub fn endpoint_dev() -> Url {
+    Url::parse(ENDPOINT_DEV).unwrap()
+}
+
+/// API endpoint for the prod environment.
+pub fn endpoint_prod() -> Url {
+    Url::parse(ENDPOINT_PROD).unwrap()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/query.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/query.rs
new file mode 100644
index 0000000..5e804e7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/query.rs
@@ -0,0 +1,990 @@
+use std::{collections::HashSet, pin::Pin, time::Duration};
+
+use anyhow::{bail, Context};
+use cynic::{MutationBuilder, QueryBuilder};
+use edge_schema::schema::{NetworkTokenV1, WebcIdent};
+use futures::{Stream, StreamExt};
+use time::OffsetDateTime;
+use tracing::Instrument;
+use url::Url;
+
+use crate::{
+    types::{
+        self, CreateNamespaceVars, DeployApp, DeployAppConnection, DeployAppVersion,
+        DeployAppVersionConnection, DnsDomain, GetCurrentUserWithAppsVars, GetDeployAppAndVersion,
+        GetDeployAppVersionsVars, GetNamespaceAppsVars, Log, LogStream, PackageVersionConnection,
+        PublishDeployAppVars, UpsertDomainFromZoneFileVars,
+    },
+    GraphQLApiFailure, WasmerClient,
+};
+
+/// Load a webc package from the registry.
+///
+/// NOTE: this uses the public URL instead of the download URL available through
+/// the API, and should not be used where possible.
+pub async fn fetch_webc_package(
+    client: &WasmerClient,
+    ident: &WebcIdent,
+    default_registry: &Url,
+) -> Result<webc::compat::Container, anyhow::Error> {
+    let url = ident.build_download_url_with_default_registry(default_registry);
+    let data = client
+        .client
+        .get(url)
+        .header(reqwest::header::USER_AGENT, &client.user_agent)
+        .header(reqwest::header::ACCEPT, "application/webc")
+        .send()
+        .await?
+        .error_for_status()?
+        .bytes()
+        .await?;
+
+    webc::compat::Container::from_bytes(data).context("failed to parse webc package")
+}
+
+/// Get the currently logged in used, together with all accessible namespaces.
+///
+/// You can optionally filter the namespaces by the user role.
+pub async fn current_user_with_namespaces(
+    client: &WasmerClient,
+    namespace_role: Option<types::GrapheneRole>,
+) -> Result<types::UserWithNamespaces, anyhow::Error> {
+    client
+        .run_graphql(types::GetCurrentUser::build(types::GetCurrentUserVars {
+            namespace_role,
+        }))
+        .await?
+        .viewer
+        .context("not logged in")
+}
+
+/// Retrieve an app.
+pub async fn get_app(
+    client: &WasmerClient,
+    owner: String,
+    name: String,
+) -> Result<Option<types::DeployApp>, anyhow::Error> {
+    client
+        .run_graphql(types::GetDeployApp::build(types::GetDeployAppVars {
+            name,
+            owner,
+        }))
+        .await
+        .map(|x| x.get_deploy_app)
+}
+
+/// Retrieve an app by its global alias.
+pub async fn get_app_by_alias(
+    client: &WasmerClient,
+    alias: String,
+) -> Result<Option<types::DeployApp>, anyhow::Error> {
+    client
+        .run_graphql(types::GetDeployAppByAlias::build(
+            types::GetDeployAppByAliasVars { alias },
+        ))
+        .await
+        .map(|x| x.get_app_by_global_alias)
+}
+
+/// Retrieve an app version.
+pub async fn get_app_version(
+    client: &WasmerClient,
+    owner: String,
+    name: String,
+    version: String,
+) -> Result<Option<types::DeployAppVersion>, anyhow::Error> {
+    client
+        .run_graphql(types::GetDeployAppVersion::build(
+            types::GetDeployAppVersionVars {
+                name,
+                owner,
+                version,
+            },
+        ))
+        .await
+        .map(|x| x.get_deploy_app_version)
+}
+
+/// Retrieve an app together with a specific version.
+pub async fn get_app_with_version(
+    client: &WasmerClient,
+    owner: String,
+    name: String,
+    version: String,
+) -> Result<GetDeployAppAndVersion, anyhow::Error> {
+    client
+        .run_graphql(types::GetDeployAppAndVersion::build(
+            types::GetDeployAppAndVersionVars {
+                name,
+                owner,
+                version,
+            },
+        ))
+        .await
+}
+
+/// Retrieve an app together with a specific version.
+pub async fn get_app_and_package_by_name(
+    client: &WasmerClient,
+    vars: types::GetPackageAndAppVars,
+) -> Result<(Option<types::Package>, Option<types::DeployApp>), anyhow::Error> {
+    let res = client
+        .run_graphql(types::GetPackageAndApp::build(vars))
+        .await?;
+    Ok((res.get_package, res.get_deploy_app))
+}
+
+/// Retrieve apps.
+pub async fn get_deploy_apps(
+    client: &WasmerClient,
+    vars: types::GetDeployAppsVars,
+) -> Result<DeployAppConnection, anyhow::Error> {
+    let res = client
+        .run_graphql(types::GetDeployApps::build(vars))
+        .await?;
+    res.get_deploy_apps.context("no apps returned")
+}
+
+/// Retrieve apps as a stream that will automatically paginate.
+pub fn get_deploy_apps_stream(
+    client: &WasmerClient,
+    vars: types::GetDeployAppsVars,
+) -> impl futures::Stream<Item = Result<Vec<DeployApp>, anyhow::Error>> + '_ {
+    futures::stream::try_unfold(
+        Some(vars),
+        move |vars: Option<types::GetDeployAppsVars>| async move {
+            let vars = match vars {
+                Some(vars) => vars,
+                None => return Ok(None),
+            };
+
+            let page = get_deploy_apps(client, vars.clone()).await?;
+
+            let end_cursor = page.page_info.end_cursor;
+
+            let items = page
+                .edges
+                .into_iter()
+                .filter_map(|x| x.and_then(|x| x.node))
+                .collect::<Vec<_>>();
+
+            let new_vars = end_cursor.map(|c| types::GetDeployAppsVars {
+                after: Some(c),
+                ..vars
+            });
+
+            Ok(Some((items, new_vars)))
+        },
+    )
+}
+
+/// Retrieve versions for an app.
+pub async fn get_deploy_app_versions(
+    client: &WasmerClient,
+    vars: GetDeployAppVersionsVars,
+) -> Result<DeployAppVersionConnection, anyhow::Error> {
+    let res = client
+        .run_graphql_strict(types::GetDeployAppVersions::build(vars))
+        .await?;
+    let versions = res.get_deploy_app.context("app not found")?.versions;
+    Ok(versions)
+}
+
+/// Load all versions of an app.
+///
+/// Will paginate through all versions and return them in a single list.
+pub async fn all_app_versions(
+    client: &WasmerClient,
+    owner: String,
+    name: String,
+) -> Result<Vec<DeployAppVersion>, anyhow::Error> {
+    let mut vars = GetDeployAppVersionsVars {
+        owner,
+        name,
+        offset: None,
+        before: None,
+        after: None,
+        first: Some(10),
+        last: None,
+        sort_by: None,
+    };
+
+    let mut all_versions = Vec::<DeployAppVersion>::new();
+
+    loop {
+        let page = get_deploy_app_versions(client, vars.clone()).await?;
+        if page.edges.is_empty() {
+            break;
+        }
+
+        for edge in page.edges {
+            let edge = match edge {
+                Some(edge) => edge,
+                None => continue,
+            };
+            let version = match edge.node {
+                Some(item) => item,
+                None => continue,
+            };
+
+            // Sanity check to avoid duplication.
+            if all_versions.iter().any(|v| v.id == version.id) == false {
+                all_versions.push(version);
+            }
+
+            // Update pagination.
+            vars.after = Some(edge.cursor);
+        }
+    }
+
+    Ok(all_versions)
+}
+
+/// Activate a particular version of an app.
+pub async fn app_version_activate(
+    client: &WasmerClient,
+    version: String,
+) -> Result<DeployApp, anyhow::Error> {
+    let res = client
+        .run_graphql_strict(types::MarkAppVersionAsActive::build(
+            types::MarkAppVersionAsActiveVars {
+                input: types::MarkAppVersionAsActiveInput {
+                    app_version: version.into(),
+                },
+            },
+        ))
+        .await?;
+    res.mark_app_version_as_active
+        .context("app not found")
+        .map(|x| x.app)
+}
+
+/// Retrieve a node based on its global id.
+pub async fn get_node(
+    client: &WasmerClient,
+    id: String,
+) -> Result<Option<types::Node>, anyhow::Error> {
+    client
+        .run_graphql(types::GetNode::build(types::GetNodeVars { id: id.into() }))
+        .await
+        .map(|x| x.node)
+}
+
+/// Retrieve an app by its global id.
+pub async fn get_app_by_id(
+    client: &WasmerClient,
+    app_id: String,
+) -> Result<DeployApp, anyhow::Error> {
+    get_app_by_id_opt(client, app_id)
+        .await?
+        .context("app not found")
+}
+
+/// Retrieve an app by its global id.
+pub async fn get_app_by_id_opt(
+    client: &WasmerClient,
+    app_id: String,
+) -> Result<Option<DeployApp>, anyhow::Error> {
+    let app_opt = client
+        .run_graphql(types::GetDeployAppById::build(
+            types::GetDeployAppByIdVars {
+                app_id: app_id.into(),
+            },
+        ))
+        .await?
+        .app;
+
+    if let Some(app) = app_opt {
+        let app = app.into_deploy_app().context("app conversion failed")?;
+        Ok(Some(app))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Retrieve an app together with a specific version.
+pub async fn get_app_with_version_by_id(
+    client: &WasmerClient,
+    app_id: String,
+    version_id: String,
+) -> Result<(DeployApp, DeployAppVersion), anyhow::Error> {
+    let res = client
+        .run_graphql(types::GetDeployAppAndVersionById::build(
+            types::GetDeployAppAndVersionByIdVars {
+                app_id: app_id.into(),
+                version_id: version_id.into(),
+            },
+        ))
+        .await?;
+
+    let app = res
+        .app
+        .context("app not found")?
+        .into_deploy_app()
+        .context("app conversion failed")?;
+    let version = res
+        .version
+        .context("version not found")?
+        .into_deploy_app_version()
+        .context("version conversion failed")?;
+
+    Ok((app, version))
+}
+
+/// Retrieve an app version by its global id.
+pub async fn get_app_version_by_id(
+    client: &WasmerClient,
+    version_id: String,
+) -> Result<DeployAppVersion, anyhow::Error> {
+    client
+        .run_graphql(types::GetDeployAppVersionById::build(
+            types::GetDeployAppVersionByIdVars {
+                version_id: version_id.into(),
+            },
+        ))
+        .await?
+        .version
+        .context("app not found")?
+        .into_deploy_app_version()
+        .context("app version conversion failed")
+}
+
+pub async fn get_app_version_by_id_with_app(
+    client: &WasmerClient,
+    version_id: String,
+) -> Result<(DeployApp, DeployAppVersion), anyhow::Error> {
+    let version = client
+        .run_graphql(types::GetDeployAppVersionById::build(
+            types::GetDeployAppVersionByIdVars {
+                version_id: version_id.into(),
+            },
+        ))
+        .await?
+        .version
+        .context("app not found")?
+        .into_deploy_app_version()
+        .context("app version conversion failed")?;
+
+    let app_id = version
+        .app
+        .as_ref()
+        .context("could not load app for version")?
+        .id
+        .clone();
+
+    let app = get_app_by_id(client, app_id.into_inner()).await?;
+
+    Ok((app, version))
+}
+
+/// List all apps that are accessible by the current user.
+///
+/// NOTE: this will only include the first pages and does not provide pagination.
+pub async fn user_apps(
+    client: &WasmerClient,
+) -> impl futures::Stream<Item = Result<Vec<types::DeployApp>, anyhow::Error>> + '_ {
+    futures::stream::try_unfold(None, move |cursor| async move {
+        let user = client
+            .run_graphql(types::GetCurrentUserWithApps::build(
+                GetCurrentUserWithAppsVars { after: cursor },
+            ))
+            .await?
+            .viewer
+            .context("not logged in")?;
+
+        let apps: Vec<_> = user
+            .apps
+            .edges
+            .into_iter()
+            .flatten()
+            .filter_map(|x| x.node)
+            .collect();
+
+        let cursor = user.apps.page_info.end_cursor;
+
+        if apps.is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some((apps, cursor)))
+        }
+    })
+}
+
+/// List all apps that are accessible by the current user.
+pub async fn user_accessible_apps(
+    client: &WasmerClient,
+) -> Result<
+    impl futures::Stream<Item = Result<Vec<types::DeployApp>, anyhow::Error>> + '_,
+    anyhow::Error,
+> {
+    let apps: Pin<Box<dyn Stream<Item = Result<Vec<DeployApp>, anyhow::Error>> + Send + Sync>> =
+        Box::pin(user_apps(client).await);
+
+    // Get all aps in user-accessible namespaces.
+    let namespace_res = client
+        .run_graphql(types::GetCurrentUser::build(types::GetCurrentUserVars {
+            namespace_role: None,
+        }))
+        .await?;
+    let active_user = namespace_res.viewer.context("not logged in")?;
+    let namespace_names = active_user
+        .namespaces
+        .edges
+        .iter()
+        .filter_map(|edge| edge.as_ref())
+        .filter_map(|edge| edge.node.as_ref())
+        .map(|node| node.name.clone())
+        .collect::<Vec<_>>();
+
+    let mut all_apps = vec![apps];
+    for ns in namespace_names {
+        let apps: Pin<Box<dyn Stream<Item = Result<Vec<DeployApp>, anyhow::Error>> + Send + Sync>> =
+            Box::pin(namespace_apps(client, ns).await);
+
+        all_apps.push(apps);
+    }
+
+    let apps = futures::stream::select_all(all_apps);
+
+    Ok(apps)
+}
+
+/// Get apps for a specific namespace.
+///
+/// NOTE: only retrieves the first page and does not do pagination.
+pub async fn namespace_apps(
+    client: &WasmerClient,
+    namespace: String,
+) -> impl futures::Stream<Item = Result<Vec<types::DeployApp>, anyhow::Error>> + '_ {
+    let namespace = namespace.clone();
+
+    futures::stream::try_unfold((None, namespace), move |(cursor, namespace)| async move {
+        let res = client
+            .run_graphql(types::GetNamespaceApps::build(GetNamespaceAppsVars {
+                name: namespace.to_string(),
+                after: cursor,
+            }))
+            .await?;
+
+        let ns = res
+            .get_namespace
+            .with_context(|| format!("failed to get namespace '{}'", namespace))?;
+
+        let apps: Vec<_> = ns
+            .apps
+            .edges
+            .into_iter()
+            .flatten()
+            .filter_map(|x| x.node)
+            .collect();
+
+        let cursor = ns.apps.page_info.end_cursor;
+
+        if apps.is_empty() {
+            Ok(None)
+        } else {
+            Ok(Some((apps, (cursor, namespace))))
+        }
+    })
+}
+
+/// Publish a new app (version).
+pub async fn publish_deploy_app(
+    client: &WasmerClient,
+    vars: PublishDeployAppVars,
+) -> Result<DeployAppVersion, anyhow::Error> {
+    let res = client
+        .run_graphql_raw(types::PublishDeployApp::build(vars))
+        .await?;
+
+    if let Some(app) = res
+        .data
+        .and_then(|d| d.publish_deploy_app)
+        .map(|d| d.deploy_app_version)
+    {
+        Ok(app)
+    } else {
+        Err(GraphQLApiFailure::from_errors(
+            "could not publish app",
+            res.errors,
+        ))
+    }
+}
+
+/// Delete an app.
+pub async fn delete_app(client: &WasmerClient, app_id: String) -> Result<(), anyhow::Error> {
+    let res = client
+        .run_graphql_strict(types::DeleteApp::build(types::DeleteAppVars {
+            app_id: app_id.into(),
+        }))
+        .await?
+        .delete_app
+        .context("API did not return data for the delete_app mutation")?;
+
+    if !res.success {
+        bail!("App deletion failed for an unknown reason");
+    }
+
+    Ok(())
+}
+
+/// Get all namespaces accessible by the current user.
+pub async fn user_namespaces(
+    client: &WasmerClient,
+) -> Result<Vec<types::Namespace>, anyhow::Error> {
+    let user = client
+        .run_graphql(types::GetCurrentUser::build(types::GetCurrentUserVars {
+            namespace_role: None,
+        }))
+        .await?
+        .viewer
+        .context("not logged in")?;
+
+    let ns = user
+        .namespaces
+        .edges
+        .into_iter()
+        .flatten()
+        // .filter_map(|x| x)
+        .filter_map(|x| x.node)
+        .collect();
+
+    Ok(ns)
+}
+
+/// Retrieve a namespace by its name.
+pub async fn get_namespace(
+    client: &WasmerClient,
+    name: String,
+) -> Result<Option<types::Namespace>, anyhow::Error> {
+    client
+        .run_graphql(types::GetNamespace::build(types::GetNamespaceVars { name }))
+        .await
+        .map(|x| x.get_namespace)
+}
+
+/// Create a new namespace.
+pub async fn create_namespace(
+    client: &WasmerClient,
+    vars: CreateNamespaceVars,
+) -> Result<types::Namespace, anyhow::Error> {
+    client
+        .run_graphql(types::CreateNamespace::build(vars))
+        .await?
+        .create_namespace
+        .map(|x| x.namespace)
+        .context("no namespace returned")
+}
+
+/// Retrieve a package by its name.
+pub async fn get_package(
+    client: &WasmerClient,
+    name: String,
+) -> Result<Option<types::Package>, anyhow::Error> {
+    client
+        .run_graphql_strict(types::GetPackage::build(types::GetPackageVars { name }))
+        .await
+        .map(|x| x.get_package)
+}
+
+/// Retrieve a package version by its name.
+pub async fn get_package_version(
+    client: &WasmerClient,
+    name: String,
+    version: String,
+) -> Result<Option<types::PackageVersionWithPackage>, anyhow::Error> {
+    client
+        .run_graphql_strict(types::GetPackageVersion::build(
+            types::GetPackageVersionVars { name, version },
+        ))
+        .await
+        .map(|x| x.get_package_version)
+}
+
+/// Retrieve package versions for an app.
+pub async fn get_package_versions(
+    client: &WasmerClient,
+    vars: types::AllPackageVersionsVars,
+) -> Result<PackageVersionConnection, anyhow::Error> {
+    let res = client
+        .run_graphql(types::GetAllPackageVersions::build(vars))
+        .await?;
+    Ok(res.all_package_versions)
+}
+
+/// Retrieve all versions of a package as a stream that auto-paginates.
+pub fn get_package_versions_stream(
+    client: &WasmerClient,
+    vars: types::AllPackageVersionsVars,
+) -> impl futures::Stream<Item = Result<Vec<types::PackageVersionWithPackage>, anyhow::Error>> + '_
+{
+    futures::stream::try_unfold(
+        Some(vars),
+        move |vars: Option<types::AllPackageVersionsVars>| async move {
+            let vars = match vars {
+                Some(vars) => vars,
+                None => return Ok(None),
+            };
+
+            let page = get_package_versions(client, vars.clone()).await?;
+
+            let end_cursor = page.page_info.end_cursor;
+
+            let items = page
+                .edges
+                .into_iter()
+                .filter_map(|x| x.and_then(|x| x.node))
+                .collect::<Vec<_>>();
+
+            let new_vars = end_cursor.map(|cursor| types::AllPackageVersionsVars {
+                after: Some(cursor),
+                ..vars
+            });
+
+            Ok(Some((items, new_vars)))
+        },
+    )
+}
+
+/// Generate a new Edge token.
+pub async fn generate_deploy_token_raw(
+    client: &WasmerClient,
+    app_version_id: String,
+) -> Result<String, anyhow::Error> {
+    let res = client
+        .run_graphql(types::GenerateDeployToken::build(
+            types::GenerateDeployTokenVars { app_version_id },
+        ))
+        .await?;
+
+    res.generate_deploy_token
+        .map(|x| x.token)
+        .context("no token returned")
+}
+
+#[derive(Debug, PartialEq)]
+pub enum GenerateTokenBy {
+    Id(NetworkTokenV1),
+}
+
+#[derive(Debug, PartialEq)]
+pub enum TokenKind {
+    SSH,
+    Network(GenerateTokenBy),
+}
+
+pub async fn generate_deploy_config_token_raw(
+    client: &WasmerClient,
+    token_kind: TokenKind,
+) -> Result<String, anyhow::Error> {
+    let res = client
+        .run_graphql(types::GenerateDeployConfigToken::build(
+            types::GenerateDeployConfigTokenVars {
+                input: match token_kind {
+                    TokenKind::SSH => "{}".to_string(),
+                    TokenKind::Network(by) => match by {
+                        GenerateTokenBy::Id(token) => serde_json::to_string(&token)?,
+                    },
+                },
+            },
+        ))
+        .await?;
+
+    res.generate_deploy_config_token
+        .map(|x| x.token)
+        .context("no token returned")
+}
+
+/// Get pages of logs associated with an application that lie within the
+/// specified date range.
+// NOTE: this is not public due to severe usability issues.
+// The stream can loop forever due to re-fetching the same logs over and over.
+#[tracing::instrument(skip_all, level = "debug")]
+#[allow(clippy::let_with_type_underscore)]
+#[allow(clippy::too_many_arguments)]
+fn get_app_logs(
+    client: &WasmerClient,
+    name: String,
+    owner: String,
+    tag: Option<String>,
+    start: OffsetDateTime,
+    end: Option<OffsetDateTime>,
+    watch: bool,
+    streams: Option<Vec<LogStream>>,
+) -> impl futures::Stream<Item = Result<Vec<Log>, anyhow::Error>> + '_ {
+    // Note: the backend will limit responses to a certain number of log
+    // messages, so we use try_unfold() to keep calling it until we stop getting
+    // new log messages.
+    let span = tracing::Span::current();
+
+    futures::stream::try_unfold(start, move |start| {
+        let variables = types::GetDeployAppLogsVars {
+            name: name.clone(),
+            owner: owner.clone(),
+            version: tag.clone(),
+            first: Some(100),
+            starting_from: unix_timestamp(start),
+            until: end.map(unix_timestamp),
+            streams: streams.clone(),
+        };
+
+        let fut = async move {
+            loop {
+                let deploy_app_version = client
+                    .run_graphql(types::GetDeployAppLogs::build(variables.clone()))
+                    .await?
+                    .get_deploy_app_version
+                    .context("unknown package version")?;
+
+                let page: Vec<_> = deploy_app_version
+                    .logs
+                    .edges
+                    .into_iter()
+                    .flatten()
+                    .filter_map(|edge| edge.node)
+                    .collect();
+
+                if page.is_empty() {
+                    if watch {
+                        /*
+                            TODO: the resolution of watch should be configurable
+                            TODO: should this be async?
+                        */
+                        tokio::time::sleep(Duration::from_secs(1)).await;
+                        continue;
+                    }
+
+                    break Ok(None);
+                } else {
+                    let last_message = page.last().expect("The page is non-empty");
+                    let timestamp = last_message.timestamp;
+                    // NOTE: adding 1 microsecond to the timestamp to avoid fetching
+                    // the last message again.
+                    let timestamp = OffsetDateTime::from_unix_timestamp_nanos(timestamp as i128)
+                        .with_context(|| {
+                            format!("Unable to interpret {timestamp} as a unix timestamp")
+                        })?;
+
+                    // FIXME: We need a better way to tell the backend "give me the
+                    // next set of logs". Adding 1 nanosecond could theoretically
+                    // mean we miss messages if multiple log messages arrived at
+                    // the same nanosecond and the page ended midway.
+
+                    let next_timestamp = timestamp + Duration::from_nanos(1_000);
+
+                    break Ok(Some((page, next_timestamp)));
+                }
+            }
+        };
+
+        fut.instrument(span.clone())
+    })
+}
+
+/// Get pages of logs associated with an application that lie within the
+/// specified date range.
+///
+/// In contrast to [`get_app_logs`], this function collects the stream into a
+/// final vector.
+#[tracing::instrument(skip_all, level = "debug")]
+#[allow(clippy::let_with_type_underscore)]
+#[allow(clippy::too_many_arguments)]
+pub async fn get_app_logs_paginated(
+    client: &WasmerClient,
+    name: String,
+    owner: String,
+    tag: Option<String>,
+    start: OffsetDateTime,
+    end: Option<OffsetDateTime>,
+    watch: bool,
+    streams: Option<Vec<LogStream>>,
+) -> impl futures::Stream<Item = Result<Vec<Log>, anyhow::Error>> + '_ {
+    let stream = get_app_logs(client, name, owner, tag, start, end, watch, streams);
+
+    stream.map(|res| {
+        let mut logs = Vec::new();
+        let mut hasher = HashSet::new();
+        let mut page = res?;
+
+        // Prevent duplicates.
+        // TODO: don't clone the message, just hash it.
+        page.retain(|log| hasher.insert((log.message.clone(), log.timestamp.round() as i128)));
+
+        logs.extend(page);
+
+        Ok(logs)
+    })
+}
+
+/// Retrieve a domain by its name.
+///
+/// Specify with_records to also retrieve all records for the domain.
+pub async fn get_domain(
+    client: &WasmerClient,
+    domain: String,
+) -> Result<Option<types::DnsDomain>, anyhow::Error> {
+    let vars = types::GetDomainVars { domain };
+
+    let opt = client
+        .run_graphql(types::GetDomain::build(vars))
+        .await
+        .map_err(anyhow::Error::from)?
+        .get_domain;
+    Ok(opt)
+}
+
+/// Retrieve a domain by its name.
+///
+/// Specify with_records to also retrieve all records for the domain.
+pub async fn get_domain_zone_file(
+    client: &WasmerClient,
+    domain: String,
+) -> Result<Option<types::DnsDomainWithZoneFile>, anyhow::Error> {
+    let vars = types::GetDomainVars { domain };
+
+    let opt = client
+        .run_graphql(types::GetDomainWithZoneFile::build(vars))
+        .await
+        .map_err(anyhow::Error::from)?
+        .get_domain;
+    Ok(opt)
+}
+
+/// Retrieve a domain by its name, along with all it's records.
+pub async fn get_domain_with_records(
+    client: &WasmerClient,
+    domain: String,
+) -> Result<Option<types::DnsDomainWithRecords>, anyhow::Error> {
+    let vars = types::GetDomainVars { domain };
+
+    let opt = client
+        .run_graphql(types::GetDomainWithRecords::build(vars))
+        .await
+        .map_err(anyhow::Error::from)?
+        .get_domain;
+    Ok(opt)
+}
+
+/// Register a new domain
+pub async fn register_domain(
+    client: &WasmerClient,
+    name: String,
+    namespace: Option<String>,
+    import_records: Option<bool>,
+) -> Result<types::DnsDomain, anyhow::Error> {
+    let vars = types::RegisterDomainVars {
+        name,
+        namespace,
+        import_records,
+    };
+    let opt = client
+        .run_graphql_strict(types::RegisterDomain::build(vars))
+        .await
+        .map_err(anyhow::Error::from)?
+        .register_domain
+        .context("Domain registration failed")?
+        .domain
+        .context("Domain registration failed, no associatede domain found.")?;
+    Ok(opt)
+}
+
+/// Retrieve all DNS records.
+///
+/// NOTE: this is a privileged operation that requires extra permissions.
+pub async fn get_all_dns_records(
+    client: &WasmerClient,
+    vars: types::GetAllDnsRecordsVariables,
+) -> Result<types::DnsRecordConnection, anyhow::Error> {
+    client
+        .run_graphql_strict(types::GetAllDnsRecords::build(vars))
+        .await
+        .map_err(anyhow::Error::from)
+        .map(|x| x.get_all_dnsrecords)
+}
+
+/// Retrieve all DNS domains.
+pub async fn get_all_domains(
+    client: &WasmerClient,
+    vars: types::GetAllDomainsVariables,
+) -> Result<Vec<DnsDomain>, anyhow::Error> {
+    let connection = client
+        .run_graphql_strict(types::GetAllDomains::build(vars))
+        .await
+        .map_err(anyhow::Error::from)
+        .map(|x| x.get_all_domains)
+        .context("no domains returned")?;
+    Ok(connection
+        .edges
+        .into_iter()
+        .flatten()
+        .filter_map(|x| x.node)
+        .collect())
+}
+
+/// Retrieve a domain by its name.
+///
+/// Specify with_records to also retrieve all records for the domain.
+pub fn get_all_dns_records_stream(
+    client: &WasmerClient,
+    vars: types::GetAllDnsRecordsVariables,
+) -> impl futures::Stream<Item = Result<Vec<types::DnsRecord>, anyhow::Error>> + '_ {
+    futures::stream::try_unfold(
+        Some(vars),
+        move |vars: Option<types::GetAllDnsRecordsVariables>| async move {
+            let vars = match vars {
+                Some(vars) => vars,
+                None => return Ok(None),
+            };
+
+            let page = get_all_dns_records(client, vars.clone()).await?;
+
+            let end_cursor = page.page_info.end_cursor;
+
+            let items = page
+                .edges
+                .into_iter()
+                .filter_map(|x| x.and_then(|x| x.node))
+                .collect::<Vec<_>>();
+
+            let new_vars = end_cursor.map(|c| types::GetAllDnsRecordsVariables {
+                after: Some(c),
+                ..vars
+            });
+
+            Ok(Some((items, new_vars)))
+        },
+    )
+}
+
+/// Convert a [`OffsetDateTime`] to a unix timestamp that the WAPM backend
+/// understands.
+fn unix_timestamp(ts: OffsetDateTime) -> f64 {
+    let nanos_per_second = 1_000_000_000;
+    let timestamp = ts.unix_timestamp_nanos();
+    let nanos = timestamp % nanos_per_second;
+    let secs = timestamp / nanos_per_second;
+
+    (secs as f64) + (nanos as f64 / nanos_per_second as f64)
+}
+
+/// Publish a new app (version).
+pub async fn upsert_domain_from_zone_file(
+    client: &WasmerClient,
+    zone_file_contents: String,
+    delete_missing_records: bool,
+) -> Result<DnsDomain, anyhow::Error> {
+    let vars = UpsertDomainFromZoneFileVars {
+        zone_file: zone_file_contents,
+        delete_missing_records: Some(delete_missing_records),
+    };
+    let res = client
+        .run_graphql_strict(types::UpsertDomainFromZoneFile::build(vars))
+        .await?;
+
+    let domain = res
+        .upsert_domain_from_zone_file
+        .context("Upserting domain from zonefile failed")?
+        .domain;
+
+    Ok(domain)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/stream.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/stream.rs
new file mode 100644
index 0000000..c2a8f8e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/stream.rs
@@ -0,0 +1,119 @@
+use std::{collections::VecDeque, task::Poll};
+
+use futures::{
+    future::{BoxFuture, OptionFuture},
+    Future,
+};
+
+use super::WasmerClient;
+
+type PaginationFuture<I, P> = BoxFuture<'static, Result<(Vec<I>, Option<P>), anyhow::Error>>;
+
+pub trait PaginatedQuery {
+    type Vars;
+    type Paginator;
+    type Item;
+
+    fn query(
+        &self,
+        client: WasmerClient,
+        paginator: Option<Self::Paginator>,
+    ) -> PaginationFuture<Self::Item, Self::Paginator>;
+}
+
+pin_project_lite::pin_project! {
+    pub struct QueryStream<Q: PaginatedQuery> {
+        query: Q,
+
+        client: WasmerClient,
+        page: usize,
+        paginator: Option<Q::Paginator>,
+        finished: bool,
+        items: VecDeque<Q::Item>,
+
+        #[pin]
+        fut: OptionFuture<PaginationFuture<Q::Item, Q::Paginator>>,
+    }
+}
+
+impl<Q: PaginatedQuery> QueryStream<Q> {
+    pub fn new(query: Q, client: WasmerClient) -> Self {
+        Self {
+            query,
+            client,
+            page: 0,
+            finished: false,
+            paginator: None,
+            items: VecDeque::new(),
+            fut: None.into(),
+        }
+    }
+}
+
+impl<Q: PaginatedQuery> futures::Stream for QueryStream<Q> {
+    type Item = Result<Q::Item, anyhow::Error>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        let mut this = self.project();
+
+        if let Some(item) = this.items.pop_front() {
+            return Poll::Ready(Some(Ok(item)));
+        }
+
+        match this.fut.as_mut().poll(cx) {
+            Poll::Ready(None) => {}
+            Poll::Ready(Some(Ok((items, paginator)))) => {
+                *this.paginator = paginator;
+                *this.page += 1;
+                // *this.fut = None.into();
+                this.items.extend(items);
+                this.fut.set(None.into());
+
+                if let Some(item) = this.items.pop_front() {
+                    return Poll::Ready(Some(Ok(item)));
+                }
+            }
+            Poll::Ready(Some(Err(err))) => {
+                return Poll::Ready(Some(Err(err)));
+            }
+            Poll::Pending => {
+                return Poll::Pending;
+            }
+        };
+
+        let pager = match this.paginator.take() {
+            Some(p) => Some(p),
+            None if *this.page == 0 => None,
+            None => {
+                return Poll::Ready(None);
+            }
+        };
+
+        let f = this.query.query(this.client.clone(), pager);
+        this.fut.set(Some(f).into());
+
+        match this.fut.as_mut().poll(cx) {
+            Poll::Ready(None) => {
+                unreachable!()
+            }
+            Poll::Ready(Some(Ok((items, paginator)))) => {
+                *this.paginator = paginator;
+                *this.page += 1;
+                // *this.fut = None.into();
+                this.items.extend(items);
+                this.fut.set(None.into());
+
+                if let Some(item) = this.items.pop_front() {
+                    Poll::Ready(Some(Ok(item)))
+                } else {
+                    Poll::Ready(None)
+                }
+            }
+            Poll::Ready(Some(Err(err))) => Poll::Ready(Some(Err(err))),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/types.rs b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/types.rs
new file mode 100644
index 0000000..bd481e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/backend-api/src/types.rs
@@ -0,0 +1,1342 @@
+pub use queries::*;
+
+pub use cynic::Id;
+
+#[cynic::schema_for_derives(file = r#"schema.graphql"#, module = "schema")]
+mod queries {
+    use serde::Serialize;
+    use time::OffsetDateTime;
+
+    use super::schema;
+
+    #[derive(cynic::Scalar, Debug, Clone)]
+    pub struct DateTime(pub String);
+
+    impl TryFrom<OffsetDateTime> for DateTime {
+        type Error = time::error::Format;
+
+        fn try_from(value: OffsetDateTime) -> Result<Self, Self::Error> {
+            value
+                .format(&time::format_description::well_known::Rfc3339)
+                .map(Self)
+        }
+    }
+
+    impl TryFrom<DateTime> for OffsetDateTime {
+        type Error = time::error::Parse;
+
+        fn try_from(value: DateTime) -> Result<Self, Self::Error> {
+            OffsetDateTime::parse(&value.0, &time::format_description::well_known::Rfc3339)
+        }
+    }
+
+    #[derive(cynic::Scalar, Debug, Clone)]
+    pub struct JSONString(pub String);
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum GrapheneRole {
+        Owner,
+        Admin,
+        Editor,
+        Viewer,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetCurrentUserVars {
+        pub namespace_role: Option<GrapheneRole>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetCurrentUserVars")]
+    pub struct GetCurrentUser {
+        pub viewer: Option<UserWithNamespaces>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct User {
+        pub id: cynic::Id,
+        pub username: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct Package {
+        pub id: cynic::Id,
+        pub package_name: String,
+        pub namespace: Option<String>,
+        pub last_version: Option<PackageVersion>,
+        pub private: bool,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct PackageDistribution {
+        pub pirita_sha256_hash: Option<String>,
+        pub pirita_download_url: Option<String>,
+        pub download_url: Option<String>,
+        pub size: Option<i32>,
+        pub pirita_size: Option<i32>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct PackageVersion {
+        pub id: cynic::Id,
+        pub version: String,
+        pub created_at: DateTime,
+        pub distribution: PackageDistribution,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "PackageVersion")]
+    pub struct PackageVersionWithPackage {
+        pub id: cynic::Id,
+        pub version: String,
+        pub created_at: DateTime,
+        pub pirita_manifest: Option<JSONString>,
+        pub distribution: PackageDistribution,
+
+        pub package: Package,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetPackageVars {
+        pub name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetPackageVars")]
+    pub struct GetPackage {
+        #[arguments(name: $name)]
+        pub get_package: Option<Package>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetPackageVersionVars {
+        pub name: String,
+        pub version: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetPackageVersionVars")]
+    pub struct GetPackageVersion {
+        #[arguments(name: $name, version: $version)]
+        pub get_package_version: Option<PackageVersionWithPackage>,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum PackageVersionSortBy {
+        Newest,
+        Oldest,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone, Default)]
+    pub struct AllPackageVersionsVars {
+        pub offset: Option<i32>,
+        pub before: Option<String>,
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub last: Option<i32>,
+
+        pub created_after: Option<DateTime>,
+        pub updated_after: Option<DateTime>,
+        pub sort_by: Option<PackageVersionSortBy>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "AllPackageVersionsVars")]
+    pub struct GetAllPackageVersions {
+        #[arguments(
+            first: $first,
+            last: $last,
+            after: $after,
+            before: $before,
+            offset: $offset,
+            updatedAfter: $updated_after,
+            createdAfter: $created_after,
+            sortBy: $sort_by,
+        )]
+        pub all_package_versions: PackageVersionConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PackageVersionConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<PackageVersionEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PackageVersionEdge {
+        pub node: Option<PackageVersionWithPackage>,
+        pub cursor: String,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetPackageAndAppVars {
+        pub package: String,
+        pub app_owner: String,
+        pub app_name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetPackageAndAppVars")]
+    pub struct GetPackageAndApp {
+        #[arguments(name: $package)]
+        pub get_package: Option<Package>,
+        #[arguments(owner: $app_owner, name: $app_name)]
+        pub get_deploy_app: Option<DeployApp>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetCurrentUserWithAppsVars {
+        pub after: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetCurrentUserWithAppsVars")]
+    pub struct GetCurrentUserWithApps {
+        pub viewer: Option<UserWithApps>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "User")]
+    #[cynic(variables = "GetCurrentUserWithAppsVars")]
+    pub struct UserWithApps {
+        pub id: cynic::Id,
+        pub username: String,
+        #[arguments(after: $after)]
+        pub apps: DeployAppConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct Owner {
+        pub global_name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "User", variables = "GetCurrentUserVars")]
+    pub struct UserWithNamespaces {
+        pub id: cynic::Id,
+        pub username: String,
+        #[arguments(role: $namespace_role)]
+        pub namespaces: NamespaceConnection,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetUserAppsVars {
+        pub username: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetUserAppsVars")]
+    pub struct GetUserApps {
+        #[arguments(username: $username)]
+        pub get_user: Option<User>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppVars {
+        pub name: String,
+        pub owner: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppVars")]
+    pub struct GetDeployApp {
+        #[arguments(owner: $owner, name: $name)]
+        pub get_deploy_app: Option<DeployApp>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct PaginationVars {
+        pub offset: Option<i32>,
+        pub before: Option<String>,
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub last: Option<i32>,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum DeployAppsSortBy {
+        Newest,
+        Oldest,
+        MostActive,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone, Default)]
+    pub struct GetDeployAppsVars {
+        pub offset: Option<i32>,
+        pub before: Option<String>,
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub last: Option<i32>,
+
+        pub updated_after: Option<DateTime>,
+        pub sort_by: Option<DeployAppsSortBy>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppsVars")]
+    pub struct GetDeployApps {
+        #[arguments(
+            first: $first,
+            last: $last,
+            after: $after,
+            before: $before,
+            offset: $offset,
+            updatedAfter: $updated_after,
+            sortBy: $sort_by,
+        )]
+        pub get_deploy_apps: Option<DeployAppConnection>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppByAliasVars {
+        pub alias: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppByAliasVars")]
+    pub struct GetDeployAppByAlias {
+        #[arguments(alias: $alias)]
+        pub get_app_by_global_alias: Option<DeployApp>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppAndVersionVars {
+        pub name: String,
+        pub owner: String,
+        pub version: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppAndVersionVars")]
+    pub struct GetDeployAppAndVersion {
+        #[arguments(owner: $owner, name: $name)]
+        pub get_deploy_app: Option<DeployApp>,
+        #[arguments(owner: $owner, name: $name, version: $version)]
+        pub get_deploy_app_version: Option<DeployAppVersion>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppVersionVars {
+        pub name: String,
+        pub owner: String,
+        pub version: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppVersionVars")]
+    pub struct GetDeployAppVersion {
+        #[arguments(owner: $owner, name: $name, version: $version)]
+        pub get_deploy_app_version: Option<DeployAppVersion>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct RegisterDomainPayload {
+        pub success: bool,
+        pub domain: Option<DnsDomain>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct RegisterDomainVars {
+        pub name: String,
+        pub namespace: Option<String>,
+        pub import_records: Option<bool>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "RegisterDomainVars")]
+    pub struct RegisterDomain {
+        #[arguments(input: {name: $name, importRecords: $import_records, namespace: $namespace})]
+        pub register_domain: Option<RegisterDomainPayload>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct UpsertDomainFromZoneFileVars {
+        pub zone_file: String,
+        pub delete_missing_records: Option<bool>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "UpsertDomainFromZoneFileVars")]
+    pub struct UpsertDomainFromZoneFile {
+        #[arguments(input: {zoneFile: $zone_file, deleteMissingRecords: $delete_missing_records})]
+        pub upsert_domain_from_zone_file: Option<UpsertDomainFromZoneFilePayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct UpsertDomainFromZoneFilePayload {
+        pub success: bool,
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct CreateNamespaceVars {
+        pub name: String,
+        pub description: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "CreateNamespaceVars")]
+    pub struct CreateNamespace {
+        #[arguments(input: {name: $name, description: $description})]
+        pub create_namespace: Option<CreateNamespacePayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct CreateNamespacePayload {
+        pub namespace: Namespace,
+    }
+
+    #[derive(cynic::InputObject, Debug)]
+    pub struct CreateNamespaceInput {
+        pub name: String,
+        pub display_name: Option<String>,
+        pub description: Option<String>,
+        pub avatar: Option<String>,
+        pub client_mutation_id: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct NamespaceEdge {
+        pub node: Option<Namespace>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct NamespaceConnection {
+        pub edges: Vec<Option<NamespaceEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct Namespace {
+        pub id: cynic::Id,
+        pub name: String,
+        pub global_name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct DeployApp {
+        pub id: cynic::Id,
+        pub name: String,
+        pub created_at: DateTime,
+        pub description: Option<String>,
+        pub active_version: DeployAppVersion,
+        pub admin_url: String,
+        pub owner: Owner,
+        pub url: String,
+        pub deleted: bool,
+        pub aliases: AppAliasConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct AppAliasConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<AppAliasEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct AppAliasEdge {
+        pub node: Option<AppAlias>,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct AppAlias {
+        pub name: String,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct DeleteAppVars {
+        pub app_id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct DeleteAppPayload {
+        pub success: bool,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "DeleteAppVars")]
+    pub struct DeleteApp {
+        #[arguments(input: { id: $app_id })]
+        pub delete_app: Option<DeleteAppPayload>,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum DeployAppVersionsSortBy {
+        Newest,
+        Oldest,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct GetDeployAppVersionsVars {
+        pub owner: String,
+        pub name: String,
+
+        pub offset: Option<i32>,
+        pub before: Option<String>,
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub last: Option<i32>,
+        pub sort_by: Option<DeployAppVersionsSortBy>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppVersionsVars")]
+    pub struct GetDeployAppVersions {
+        #[arguments(owner: $owner, name: $name)]
+        pub get_deploy_app: Option<DeployAppVersions>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DeployApp", variables = "GetDeployAppVersionsVars")]
+    pub struct DeployAppVersions {
+        #[arguments(
+            first: $first,
+            last: $last,
+            before: $before,
+            after: $after,
+            offset: $offset,
+            sortBy: $sort_by
+        )]
+        pub versions: DeployAppVersionConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    #[cynic(graphql_type = "DeployApp")]
+    pub struct SparseDeployApp {
+        pub id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct DeployAppVersion {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub version: String,
+        pub description: Option<String>,
+        pub yaml_config: String,
+        pub user_yaml_config: String,
+        pub config: String,
+        pub json_config: String,
+        pub url: String,
+
+        pub app: Option<SparseDeployApp>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct DeployAppVersionConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<DeployAppVersionEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    pub struct DeployAppVersionEdge {
+        pub node: Option<DeployAppVersion>,
+        pub cursor: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct DeployAppConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<DeployAppEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct DeployAppEdge {
+        pub node: Option<DeployApp>,
+        pub cursor: String,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct PageInfo {
+        pub has_next_page: bool,
+        pub end_cursor: Option<String>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetNamespaceVars {
+        pub name: String,
+    }
+
+    #[derive(cynic::QueryFragment, Serialize, Debug, Clone)]
+    pub struct MarkAppVersionAsActivePayload {
+        pub app: DeployApp,
+    }
+
+    #[derive(cynic::InputObject, Debug)]
+    pub struct MarkAppVersionAsActiveInput {
+        pub app_version: cynic::Id,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct MarkAppVersionAsActiveVars {
+        pub input: MarkAppVersionAsActiveInput,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "MarkAppVersionAsActiveVars")]
+    pub struct MarkAppVersionAsActive {
+        #[arguments(input: $input)]
+        pub mark_app_version_as_active: Option<MarkAppVersionAsActivePayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetNamespaceVars")]
+    pub struct GetNamespace {
+        #[arguments(name: $name)]
+        pub get_namespace: Option<Namespace>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetNamespaceAppsVars {
+        pub name: String,
+        pub after: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetNamespaceAppsVars")]
+    pub struct GetNamespaceApps {
+        #[arguments(name: $name)]
+        pub get_namespace: Option<NamespaceWithApps>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Namespace")]
+    #[cynic(variables = "GetNamespaceAppsVars")]
+    pub struct NamespaceWithApps {
+        pub id: cynic::Id,
+        pub name: String,
+        #[arguments(after: $after)]
+        pub apps: DeployAppConnection,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct PublishDeployAppVars {
+        pub config: String,
+        pub name: cynic::Id,
+        pub owner: Option<cynic::Id>,
+        pub make_default: Option<bool>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "PublishDeployAppVars")]
+    pub struct PublishDeployApp {
+        #[arguments(input: { config: { yamlConfig: $config }, name: $name, owner: $owner, makeDefault: $make_default })]
+        pub publish_deploy_app: Option<PublishDeployAppPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct PublishDeployAppPayload {
+        pub deploy_app_version: DeployAppVersion,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GenerateDeployTokenVars {
+        pub app_version_id: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "GenerateDeployTokenVars")]
+    pub struct GenerateDeployToken {
+        #[arguments(input: { deployConfigVersionId: $app_version_id })]
+        pub generate_deploy_token: Option<GenerateDeployTokenPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct GenerateDeployTokenPayload {
+        pub token: String,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum LogStream {
+        Stdout,
+        Stderr,
+        Runtime,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct GetDeployAppLogsVars {
+        pub name: String,
+        pub owner: String,
+        /// The tag associated with a particular app version. Uses the active
+        /// version if not provided.
+        pub version: Option<String>,
+        /// The lower bound for log messages, in nanoseconds since the Unix
+        /// epoch.
+        pub starting_from: f64,
+        /// The upper bound for log messages, in nanoseconds since the Unix
+        /// epoch.
+        pub until: Option<f64>,
+        pub first: Option<i32>,
+
+        pub streams: Option<Vec<LogStream>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppLogsVars")]
+    pub struct GetDeployAppLogs {
+        #[arguments(name: $name, owner: $owner, version: $version)]
+        pub get_deploy_app_version: Option<DeployAppVersionLogs>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DeployAppVersion", variables = "GetDeployAppLogsVars")]
+    pub struct DeployAppVersionLogs {
+        #[arguments(startingFrom: $starting_from, until: $until, first: $first)]
+        pub logs: LogConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct LogConnection {
+        pub edges: Vec<Option<LogEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct LogEdge {
+        pub node: Option<Log>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, serde::Serialize, PartialEq)]
+    pub struct Log {
+        pub message: String,
+        /// When the message was recorded, in nanoseconds since the Unix epoch.
+        pub timestamp: f64,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GenerateDeployConfigTokenVars {
+        pub input: String,
+    }
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Mutation", variables = "GenerateDeployConfigTokenVars")]
+    pub struct GenerateDeployConfigToken {
+        #[arguments(input: { config: $input })]
+        pub generate_deploy_config_token: Option<GenerateDeployConfigTokenPayload>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    pub struct GenerateDeployConfigTokenPayload {
+        pub token: String,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetNodeVars {
+        pub id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetNodeVars")]
+    pub struct GetNode {
+        #[arguments(id: $id)]
+        pub node: Option<Node>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppByIdVars {
+        pub app_id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppByIdVars")]
+    pub struct GetDeployAppById {
+        #[arguments(id: $app_id)]
+        #[cynic(rename = "node")]
+        pub app: Option<Node>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppAndVersionByIdVars {
+        pub app_id: cynic::Id,
+        pub version_id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppAndVersionByIdVars")]
+    pub struct GetDeployAppAndVersionById {
+        #[arguments(id: $app_id)]
+        #[cynic(rename = "node")]
+        pub app: Option<Node>,
+        #[arguments(id: $version_id)]
+        #[cynic(rename = "node")]
+        pub version: Option<Node>,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDeployAppVersionByIdVars {
+        pub version_id: cynic::Id,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDeployAppVersionByIdVars")]
+    pub struct GetDeployAppVersionById {
+        #[arguments(id: $version_id)]
+        #[cynic(rename = "node")]
+        pub version: Option<Node>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "TXTRecord")]
+    pub struct TxtRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub data: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "SSHFPRecord")]
+    pub struct SshfpRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        #[cynic(rename = "type")]
+        pub type_: DnsmanagerSshFingerprintRecordTypeChoices,
+        pub algorithm: DnsmanagerSshFingerprintRecordAlgorithmChoices,
+        pub fingerprint: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "SRVRecord")]
+    pub struct SrvRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub service: String,
+        pub protocol: String,
+        pub priority: i32,
+        pub weight: i32,
+        pub port: i32,
+        pub target: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "SOARecord")]
+    pub struct SoaRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub mname: String,
+        pub rname: String,
+        pub serial: BigInt,
+        pub refresh: BigInt,
+        pub retry: BigInt,
+        pub expire: BigInt,
+        pub minimum: BigInt,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::Enum, Debug, Clone, Copy)]
+    pub enum DNSRecordsSortBy {
+        Newest,
+        Oldest,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct GetAllDnsRecordsVariables {
+        pub after: Option<String>,
+        pub updated_after: Option<DateTime>,
+        pub sort_by: Option<DNSRecordsSortBy>,
+        pub first: Option<i32>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetAllDnsRecordsVariables")]
+    pub struct GetAllDnsRecords {
+        #[arguments(
+            first: $first,
+            after: $after,
+            updatedAfter: $updated_after,
+            sortBy: $sort_by
+        )]
+        #[cynic(rename = "getAllDNSRecords")]
+        pub get_all_dnsrecords: DnsRecordConnection,
+    }
+
+    #[derive(cynic::QueryVariables, Debug, Clone)]
+    pub struct GetAllDomainsVariables {
+        pub after: Option<String>,
+        pub first: Option<i32>,
+        pub namespace: Option<String>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetAllDomainsVariables")]
+    pub struct GetAllDomains {
+        #[arguments(
+            first: $first,
+            after: $after,
+            namespace: $namespace,
+        )]
+        #[cynic(rename = "getAllDomains")]
+        pub get_all_domains: DnsDomainConnection,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "PTRRecord")]
+    pub struct PtrRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub ptrdname: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "NSRecord")]
+    pub struct NsRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub nsdname: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "MXRecord")]
+    pub struct MxRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub preference: i32,
+        pub exchange: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DNSRecordConnection")]
+    pub struct DnsRecordConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<DnsRecordEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DNSRecordEdge")]
+    pub struct DnsRecordEdge {
+        pub node: Option<DnsRecord>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DNSDomainConnection")]
+    pub struct DnsDomainConnection {
+        pub page_info: PageInfo,
+        pub edges: Vec<Option<DnsDomainEdge>>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "DNSDomainEdge")]
+    pub struct DnsDomainEdge {
+        pub node: Option<DnsDomain>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DNAMERecord")]
+    pub struct DNameRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub d_name: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "CNAMERecord")]
+    pub struct CNameRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub c_name: String,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "CAARecord")]
+    pub struct CaaRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub value: String,
+        pub flags: i32,
+        pub tag: DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices,
+
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "ARecord")]
+    pub struct ARecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub address: String,
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "AAAARecord")]
+    pub struct AaaaRecord {
+        pub id: cynic::Id,
+        pub created_at: DateTime,
+        pub updated_at: DateTime,
+        pub deleted_at: Option<DateTime>,
+        pub name: Option<String>,
+        pub text: String,
+        pub ttl: Option<i32>,
+        pub address: String,
+        pub domain: DnsDomain,
+    }
+
+    #[derive(cynic::InlineFragments, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DNSRecord")]
+    pub enum DnsRecord {
+        A(ARecord),
+        AAAA(AaaaRecord),
+        CName(CNameRecord),
+        Txt(TxtRecord),
+        Mx(MxRecord),
+        Ns(NsRecord),
+        CAA(CaaRecord),
+        DName(DNameRecord),
+        Ptr(PtrRecord),
+        Soa(SoaRecord),
+        Srv(SrvRecord),
+        Sshfp(SshfpRecord),
+        #[cynic(fallback)]
+        Unknown,
+    }
+
+    impl DnsRecord {
+        pub fn id(&self) -> &str {
+            match self {
+                DnsRecord::A(record) => record.id.inner(),
+                DnsRecord::AAAA(record) => record.id.inner(),
+                DnsRecord::CName(record) => record.id.inner(),
+                DnsRecord::Txt(record) => record.id.inner(),
+                DnsRecord::Mx(record) => record.id.inner(),
+                DnsRecord::Ns(record) => record.id.inner(),
+                DnsRecord::CAA(record) => record.id.inner(),
+                DnsRecord::DName(record) => record.id.inner(),
+                DnsRecord::Ptr(record) => record.id.inner(),
+                DnsRecord::Soa(record) => record.id.inner(),
+                DnsRecord::Srv(record) => record.id.inner(),
+                DnsRecord::Sshfp(record) => record.id.inner(),
+                DnsRecord::Unknown => "",
+            }
+        }
+        pub fn name(&self) -> Option<&str> {
+            match self {
+                DnsRecord::A(record) => record.name.as_deref(),
+                DnsRecord::AAAA(record) => record.name.as_deref(),
+                DnsRecord::CName(record) => record.name.as_deref(),
+                DnsRecord::Txt(record) => record.name.as_deref(),
+                DnsRecord::Mx(record) => record.name.as_deref(),
+                DnsRecord::Ns(record) => record.name.as_deref(),
+                DnsRecord::CAA(record) => record.name.as_deref(),
+                DnsRecord::DName(record) => record.name.as_deref(),
+                DnsRecord::Ptr(record) => record.name.as_deref(),
+                DnsRecord::Soa(record) => record.name.as_deref(),
+                DnsRecord::Srv(record) => record.name.as_deref(),
+                DnsRecord::Sshfp(record) => record.name.as_deref(),
+                DnsRecord::Unknown => None,
+            }
+        }
+        pub fn ttl(&self) -> Option<i32> {
+            match self {
+                DnsRecord::A(record) => record.ttl,
+                DnsRecord::AAAA(record) => record.ttl,
+                DnsRecord::CName(record) => record.ttl,
+                DnsRecord::Txt(record) => record.ttl,
+                DnsRecord::Mx(record) => record.ttl,
+                DnsRecord::Ns(record) => record.ttl,
+                DnsRecord::CAA(record) => record.ttl,
+                DnsRecord::DName(record) => record.ttl,
+                DnsRecord::Ptr(record) => record.ttl,
+                DnsRecord::Soa(record) => record.ttl,
+                DnsRecord::Srv(record) => record.ttl,
+                DnsRecord::Sshfp(record) => record.ttl,
+                DnsRecord::Unknown => None,
+            }
+        }
+
+        pub fn text(&self) -> &str {
+            match self {
+                DnsRecord::A(record) => record.text.as_str(),
+                DnsRecord::AAAA(record) => record.text.as_str(),
+                DnsRecord::CName(record) => record.text.as_str(),
+                DnsRecord::Txt(record) => record.text.as_str(),
+                DnsRecord::Mx(record) => record.text.as_str(),
+                DnsRecord::Ns(record) => record.text.as_str(),
+                DnsRecord::CAA(record) => record.text.as_str(),
+                DnsRecord::DName(record) => record.text.as_str(),
+                DnsRecord::Ptr(record) => record.text.as_str(),
+                DnsRecord::Soa(record) => record.text.as_str(),
+                DnsRecord::Srv(record) => record.text.as_str(),
+                DnsRecord::Sshfp(record) => record.text.as_str(),
+                DnsRecord::Unknown => "",
+            }
+        }
+        pub fn record_type(&self) -> &str {
+            match self {
+                DnsRecord::A(_) => "A",
+                DnsRecord::AAAA(_) => "AAAA",
+                DnsRecord::CName(_) => "CNAME",
+                DnsRecord::Txt(_) => "TXT",
+                DnsRecord::Mx(_) => "MX",
+                DnsRecord::Ns(_) => "NS",
+                DnsRecord::CAA(_) => "CAA",
+                DnsRecord::DName(_) => "DNAME",
+                DnsRecord::Ptr(_) => "PTR",
+                DnsRecord::Soa(_) => "SOA",
+                DnsRecord::Srv(_) => "SRV",
+                DnsRecord::Sshfp(_) => "SSHFP",
+                DnsRecord::Unknown => "",
+            }
+        }
+
+        pub fn domain(&self) -> Option<&DnsDomain> {
+            match self {
+                DnsRecord::A(record) => Some(&record.domain),
+                DnsRecord::AAAA(record) => Some(&record.domain),
+                DnsRecord::CName(record) => Some(&record.domain),
+                DnsRecord::Txt(record) => Some(&record.domain),
+                DnsRecord::Mx(record) => Some(&record.domain),
+                DnsRecord::Ns(record) => Some(&record.domain),
+                DnsRecord::CAA(record) => Some(&record.domain),
+                DnsRecord::DName(record) => Some(&record.domain),
+                DnsRecord::Ptr(record) => Some(&record.domain),
+                DnsRecord::Soa(record) => Some(&record.domain),
+                DnsRecord::Srv(record) => Some(&record.domain),
+                DnsRecord::Sshfp(record) => Some(&record.domain),
+                DnsRecord::Unknown => None,
+            }
+        }
+
+        pub fn created_at(&self) -> Option<&DateTime> {
+            match self {
+                DnsRecord::A(record) => Some(&record.created_at),
+                DnsRecord::AAAA(record) => Some(&record.created_at),
+                DnsRecord::CName(record) => Some(&record.created_at),
+                DnsRecord::Txt(record) => Some(&record.created_at),
+                DnsRecord::Mx(record) => Some(&record.created_at),
+                DnsRecord::Ns(record) => Some(&record.created_at),
+                DnsRecord::CAA(record) => Some(&record.created_at),
+                DnsRecord::DName(record) => Some(&record.created_at),
+                DnsRecord::Ptr(record) => Some(&record.created_at),
+                DnsRecord::Soa(record) => Some(&record.created_at),
+                DnsRecord::Srv(record) => Some(&record.created_at),
+                DnsRecord::Sshfp(record) => Some(&record.created_at),
+                DnsRecord::Unknown => None,
+            }
+        }
+
+        pub fn updated_at(&self) -> Option<&DateTime> {
+            match self {
+                Self::A(record) => Some(&record.updated_at),
+                Self::AAAA(record) => Some(&record.updated_at),
+                Self::CName(record) => Some(&record.updated_at),
+                Self::Txt(record) => Some(&record.updated_at),
+                Self::Mx(record) => Some(&record.updated_at),
+                Self::Ns(record) => Some(&record.updated_at),
+                Self::CAA(record) => Some(&record.updated_at),
+                Self::DName(record) => Some(&record.updated_at),
+                Self::Ptr(record) => Some(&record.updated_at),
+                Self::Soa(record) => Some(&record.updated_at),
+                Self::Srv(record) => Some(&record.updated_at),
+                Self::Sshfp(record) => Some(&record.updated_at),
+                Self::Unknown => None,
+            }
+        }
+
+        pub fn deleted_at(&self) -> Option<&DateTime> {
+            match self {
+                Self::A(record) => record.deleted_at.as_ref(),
+                Self::AAAA(record) => record.deleted_at.as_ref(),
+                Self::CName(record) => record.deleted_at.as_ref(),
+                Self::Txt(record) => record.deleted_at.as_ref(),
+                Self::Mx(record) => record.deleted_at.as_ref(),
+                Self::Ns(record) => record.deleted_at.as_ref(),
+                Self::CAA(record) => record.deleted_at.as_ref(),
+                Self::DName(record) => record.deleted_at.as_ref(),
+                Self::Ptr(record) => record.deleted_at.as_ref(),
+                Self::Soa(record) => record.deleted_at.as_ref(),
+                Self::Srv(record) => record.deleted_at.as_ref(),
+                Self::Sshfp(record) => record.deleted_at.as_ref(),
+                Self::Unknown => None,
+            }
+        }
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
+        Issue,
+        Issuewild,
+        Iodef,
+    }
+
+    impl DnsmanagerCertificationAuthorityAuthorizationRecordTagChoices {
+        pub fn as_str(self) -> &'static str {
+            match self {
+                Self::Issue => "issue",
+                Self::Issuewild => "issuewild",
+                Self::Iodef => "iodef",
+            }
+        }
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum DnsmanagerSshFingerprintRecordAlgorithmChoices {
+        #[cynic(rename = "A_1")]
+        A1,
+        #[cynic(rename = "A_2")]
+        A2,
+        #[cynic(rename = "A_3")]
+        A3,
+        #[cynic(rename = "A_4")]
+        A4,
+    }
+
+    #[derive(cynic::Enum, Clone, Copy, Debug)]
+    pub enum DnsmanagerSshFingerprintRecordTypeChoices {
+        #[cynic(rename = "A_1")]
+        A1,
+        #[cynic(rename = "A_2")]
+        A2,
+    }
+
+    #[derive(cynic::QueryVariables, Debug)]
+    pub struct GetDomainVars {
+        pub domain: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDomainVars")]
+    pub struct GetDomain {
+        #[arguments(name: $domain)]
+        pub get_domain: Option<DnsDomain>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDomainVars")]
+    pub struct GetDomainWithZoneFile {
+        #[arguments(name: $domain)]
+        pub get_domain: Option<DnsDomainWithZoneFile>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug)]
+    #[cynic(graphql_type = "Query", variables = "GetDomainVars")]
+    pub struct GetDomainWithRecords {
+        #[arguments(name: $domain)]
+        pub get_domain: Option<DnsDomainWithRecords>,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DNSDomain")]
+    pub struct DnsDomain {
+        pub id: cynic::Id,
+        pub name: String,
+        pub slug: String,
+        pub owner: Owner,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DNSDomain")]
+    pub struct DnsDomainWithZoneFile {
+        pub id: cynic::Id,
+        pub name: String,
+        pub slug: String,
+        pub zone_file: String,
+    }
+
+    #[derive(cynic::QueryFragment, Debug, Clone, Serialize)]
+    #[cynic(graphql_type = "DNSDomain")]
+    pub struct DnsDomainWithRecords {
+        pub id: cynic::Id,
+        pub name: String,
+        pub slug: String,
+        pub records: Option<Vec<Option<DnsRecord>>>,
+    }
+
+    #[derive(cynic::Scalar, Debug, Clone)]
+    pub struct BigInt(pub i64);
+
+    #[derive(cynic::InlineFragments, Debug)]
+    pub enum Node {
+        DeployApp(Box<DeployApp>),
+        DeployAppVersion(Box<DeployAppVersion>),
+        #[cynic(fallback)]
+        Unknown,
+    }
+
+    impl Node {
+        pub fn into_deploy_app(self) -> Option<DeployApp> {
+            match self {
+                Node::DeployApp(app) => Some(*app),
+                _ => None,
+            }
+        }
+
+        pub fn into_deploy_app_version(self) -> Option<DeployAppVersion> {
+            match self {
+                Node::DeployAppVersion(version) => Some(*version),
+                _ => None,
+            }
+        }
+    }
+}
+
+#[allow(non_snake_case, non_camel_case_types)]
+mod schema {
+    cynic::use_schema!(r#"schema.graphql"#);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/c-api/.gitignore
new file mode 100644
index 0000000..66de34f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/.gitignore
@@ -0,0 +1 @@
+doc/deprecated/html/
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/CHANGELOG.md b/arbitrator/tools/module_roots/wasmer/lib/c-api/CHANGELOG.md
new file mode 100644
index 0000000..6602d4a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/CHANGELOG.md
@@ -0,0 +1,48 @@
+# C API Changelog
+
+*The format is based on [Keep a Changelog].*
+
+[Keep a Changelog]: http://keepachangelog.com/en/1.0.0/
+
+Looking for changes to the Wasmer CLI and the Rust API? See our [Primary Changelog](../../CHANGELOG.md)
+
+## **[Unreleased]**
+
+## 2.1.0 - 2021/11/30
+
+### Added
+- [#2521](https://github.com/wasmerio/wasmer/pull/2521) Create `OrderedResolver` from a parallel iterator, which improves performances of `wasm_new_instance` when a large set of imports is given.
+- [#2449](https://github.com/wasmerio/wasmer/pull/2449) Configure `soname`, `install_name`, `out-implib`, etc.
+
+### Changed
+- [#2478](https://github.com/wasmerio/wasmer/pull/2478) Rename `traps` input to `wasm_instance_new()` to `trap`.
+
+### Fixed
+- [#2485](https://github.com/wasmerio/wasmer/pull/2493) Document wasm_limits_t’s members publicly.
+- [#2444](https://github.com/wasmerio/wasmer/pull/2444) Trap's messages are always null terminated.
+- [#2683](https://github.com/wasmerio/wasmer/pull/2683) Fix memory leaks in the C API.
+
+## 2.0.0 - 2020/06/16
+
+## 2.0.0-rc1 - 2020/06/02
+
+### Added
+- [#2346](https://github.com/wasmerio/wasmer/pull/2346) Add missing `wasm_func_copy` function.
+- [#2208](https://github.com/wasmerio/wasmer/pull/2208) Add a new CHANGELOG.md specific to our C API to make it easier for users primarily consuming our C API to keep up to date with changes that affect them.
+- [#2103](https://github.com/wasmerio/wasmer/pull/2103) Add middleware (incl. metering) API.
+- [#2153](https://github.com/wasmerio/wasmer/pull/2153) Add a `wasmer_features_t` unstable C API to define features for the engine and the compiler in the Wasm C API.
+- [#2118](https://github.com/wasmerio/wasmer/pull/2118) Add an unstable non-standard C API to query available engines and compilers.
+
+### Changed
+- [#2375](https://github.com/wasmerio/wasmer/pull/2375) Rename `wasmer_wasm.h` to `wasmer.h` (old behavior still continues to work).
+- [#2370](https://github.com/wasmerio/wasmer/pull/2370) Remove the deprecated C API.
+
+### Fixed
+- [#2208](https://github.com/wasmerio/wasmer/pull/2208) Fix ownership of `wasm_extern_as_func`, `wasm_extern_as_memory`, `wasm_extern_as_table`, `wasm_extern_as_global`, `wasm_func_as_extern`, `wasm_memory_as_extern`, `wasm_table_as_extern`, and `wasm_global_as_extern`. These functions no longer allocate memory and thus their results should not be freed. This is a breaking change to align more closely with the Wasm C API's stated ownership.
+- [#2210](https://github.com/wasmerio/wasmer/pull/2210) Fix a memory leak in the strings used to identify imports and exports coming from user code.
+- [#2117](https://github.com/wasmerio/wasmer/pull/2117) Formalize API prefixes. Only unstable functions have been renamed.
+- [#2097](https://github.com/wasmerio/wasmer/pull/2097) Fix how string's length is computed in `wasm_cpu_features_add`.
+
+## Changes before 2020-04-06
+
+See the [Primary Changelog](../../CHANGELOG.md).
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/c-api/Cargo.toml
new file mode 100644
index 0000000..716f429
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/Cargo.toml
@@ -0,0 +1,109 @@
+[package]
+name = "wasmer-c-api"
+description = "Wasmer C API library"
+categories = ["wasm", "api-bindings"]
+keywords = ["wasm", "webassembly", "runtime"]
+documentation = "https://wasmerio.github.io/wasmer/c-api/"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[lib]
+# The library name is `wasmer` so that we generate dylib like
+# `libwasmer.so`, `libwasmer.dylib`, `wasmer.dll` etc. But it creates
+# a conflict with the existing `wasmer` crate, see below.
+name = "wasmer" # ##lib.name##
+                # ^ DO NOT REMOVE, it's used the `Makefile`, see `build-docs-capi`.
+crate-type = ["staticlib", "cdylib"] #"cdylib", "rlib", "staticlib"]
+
+[dependencies]
+# We rename `wasmer` to `wasmer-api` to avoid the conflict with this
+# library name (see `[lib]`).
+wasmer-api = { version = "=4.2.8", path = "../api", default-features = false, package = "wasmer" }
+wasmer-compiler = { version = "=4.2.8", path = "../compiler", optional = true }
+wasmer-compiler-cranelift = { version = "=4.2.8", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-llvm = { version = "=4.2.8", path = "../compiler-llvm", optional = true }
+wasmer-compiler-singlepass = { version = "=4.2.8", path = "../compiler-singlepass", optional = true }
+wasmer-emscripten = { version = "=4.2.8", path = "../emscripten", optional = true }
+wasmer-middlewares = { version = "=4.2.8", path = "../middlewares", optional = true }
+wasmer-types = { version = "=4.2.8", path = "../types" }
+wasmer-wasix = { version = "0.18.3", path = "../wasix", features = ["host-fs", "host-vnet"], optional = true }
+webc = { version = "5.0", optional = true }
+virtual-fs = { version = "0.11.2", path = "../virtual-fs", optional = true, default-features = false, features = ["static-fs"] }
+enumset.workspace = true
+cfg-if = "1.0"
+lazy_static = "1.4"
+libc = { version = "^0.2", default-features = false }
+thiserror = "1"
+typetag = { version = "0.1", optional = true }
+paste = "1.0"
+tokio = { version = "1", features = [ "rt", "rt-multi-thread", "io-util", "sync", "macros"], default_features = false }
+
+[dev-dependencies]
+field-offset = "0.3.3"
+
+[target.'cfg(target_os = "windows")'.dev-dependencies]
+wasmer-inline-c = "0.1.1"
+
+[target.'cfg(not(target_os = "windows"))'.dev-dependencies]
+inline-c = "0.1.7"
+
+[features]
+default = [
+    "wat",
+    "cranelift",
+    "compiler",
+    "wasi",
+    "middlewares",
+]
+sys = []
+jsc = ["wasmer-api/jsc", "wasmer-api/std"]
+wat = ["wasmer-api/wat"]
+wasi = ["wasmer-wasix"]
+middlewares = [
+    "compiler",
+    "wasmer-middlewares",
+]
+compiler = [
+    "wasmer-compiler",
+    "wasmer-api/compiler",
+    "wasmer-compiler/translator",
+    "wasmer-compiler/compiler",
+]
+compiler-headless = [
+    "wasmer-artifact-load",
+    "static-artifact-load",
+    "wasmer-api/compiler",
+    "wasmer-compiler/translator",
+    "wasmer-compiler/compiler",
+]
+singlepass = [
+    "wasmer-compiler-singlepass",
+    "compiler",
+]
+cranelift = [
+    "wasmer-compiler-cranelift",
+    "compiler",
+]
+llvm = [
+    "wasmer-compiler-llvm",
+    "compiler",
+]
+wasmer-artifact-load = ["wasmer-compiler/wasmer-artifact-load"]
+wasmer-artifact-create = ["wasmer-compiler/wasmer-artifact-create"]
+static-artifact-load = ["wasmer-compiler/static-artifact-load"]
+static-artifact-create = ["wasmer-compiler/static-artifact-create"]
+webc_runner = ["virtual-fs", "webc"]
+# Deprecated features.
+jit = ["compiler"]
+
+# TODO: Port this feature.
+#emscripten = ["wasmer-emscripten"]
+
+[build-dependencies]
+cbindgen = { version = "0.24", default-features = false }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/README.md b/arbitrator/tools/module_roots/wasmer/lib/c-api/README.md
new file mode 100644
index 0000000..2651ddb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/README.md
@@ -0,0 +1,206 @@
+# `wasmer-c-api` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate exposes a C and a C++ API for the Wasmer runtime. It also fully supports the [wasm-c-api common API](https://github.com/WebAssembly/wasm-c-api).
+
+##  Usage
+
+Once you [install Wasmer in your system](https://github.com/wasmerio/wasmer-install), the *shared object files* and the *headers* are available **inside the Wasmer installed path**.
+
+```
+$WASMER_DIR/
+  lib/
+    libwasmer.{so,dylib,dll}
+  include/
+    wasm.h
+    wasmer.h
+    wasmer.hh
+    wasmer.h
+```
+
+Wasmer binary also ships with [`wasmer-config`](#wasmer-config)
+an utility tool that outputs config information needed to compile programs which use Wasmer.
+
+[The full C API documentation can be found here](https://wasmerio.github.io/wasmer/crates/doc/wasmer_c_api/).
+
+Here is a simple example to use the C API:
+
+```c
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "  (type $sum_t (func (param i32 i32) (result i32)))\n"
+        "  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)\n"
+        "    local.get $x\n"
+        "    local.get $y\n"
+        "    i32.add)\n"
+        "  (export \"sum\" (func $sum_f)))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating imports...\n");
+    wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+        return 1;
+    }
+
+    printf("Retrieving the `sum` function...\n");
+    wasm_func_t* sum_func = wasm_extern_as_func(exports.data[0]);
+
+    if (sum_func == NULL) {
+        printf("> Failed to get the `sum` function!\n");
+        return 1;
+    }
+
+    printf("Calling `sum` function...\n");
+    wasm_val_t args_val[2] = { WASM_I32_VAL(3), WASM_I32_VAL(4) };
+    wasm_val_t results_val[1] = { WASM_INIT_VAL };
+    wasm_val_vec_t args = WASM_ARRAY_VEC(args_val);
+    wasm_val_vec_t results = WASM_ARRAY_VEC(results_val);
+
+    if (wasm_func_call(sum_func, &args, &results)) {
+        printf("> Error calling the `sum` function!\n");
+
+        return 1;
+    }
+
+    printf("Results of `sum`: %d\n", results_val[0].of.i32);
+
+    wasm_module_delete(module);
+    wasm_extern_vec_delete(&exports);
+    wasm_instance_delete(instance);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
+```
+
+## Building
+
+You can compile Wasmer shared library from source:
+
+```text
+make build-capi
+```
+
+This will generate the shared library \(depending on your system\):
+
+* Windows: `target/release/libwasmer_c_api.dll`
+* macOS: `target/release/libwasmer_runtime_c_api.dylib`
+* Linux: `target/release/libwasmer_runtime_c_api.so`
+
+If you want to generate the library and headers in a friendly format as shown in [Usage](#usage), you can execute the following in Wasmer root:
+
+```bash
+make package-capi
+```
+
+This command will generate a `package` directory, that you can then use easily in the [Wasmer C API examples](https://docs.wasmer.io/integrations/examples).
+
+
+## Testing
+
+Tests are run using the release build of the library.  If you make
+changes or compile with non-default features, please ensure you
+rebuild in release mode for the tests to see the changes.
+
+To run all the full suite of tests, enter Wasmer root directory
+and run the following commands:
+
+```sh
+$ make test-capi
+```
+
+## `wasmer config`
+
+`wasmer config` output various configuration information needed to compile programs which use Wasmer.
+
+### `wasmer config --pkg-config`
+
+It outputs the necessary details for compiling and linking a program to Wasmer,
+using the `pkg-config` format:
+
+```bash
+$ wasmer config --pkg-config > $PKG_CONFIG_PATH/wasmer.pc
+```
+
+### `wasmer config --includedir`
+
+Directory containing Wasmer headers:
+
+```bash
+$ wasmer config --includedir
+/users/myuser/.wasmer/include
+```
+
+### `wasmer config --libdir`
+
+Directory containing Wasmer libraries:
+
+```bash
+$ wasmer config --libdir
+/users/myuser/.wasmer/lib
+```
+
+### `wasmer config --libs`
+
+Libraries needed to link against Wasmer components:
+
+```bash
+$ wasmer config --libs
+-L/Users/myuser/.wasmer/lib -lwasmer
+```
+
+### `wasmer config --cflags`
+
+Headers needed to build against Wasmer components:
+
+```bash
+$ wasmer config --cflags
+-I/Users/myuser/.wasmer/include/wasmer
+```
+
+## License
+
+Wasmer is primarily distributed under the terms of the [MIT
+license][mit-license] ([LICENSE][license]).
+
+
+[wasmer_h]: ./wasmer.h
+[wasmer_hh]: ./wasmer.hh
+[mit-license]: http://opensource.org/licenses/MIT
+[license]: https://github.com/wasmerio/wasmer/blob/master/LICENSE
+[Wasmer release page]: https://github.com/wasmerio/wasmer/releases
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/build.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/build.rs
new file mode 100644
index 0000000..0ae35c7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/build.rs
@@ -0,0 +1,364 @@
+//! This build script aims at:
+//!
+//! * generating the C header files for the C API,
+//! * setting `wasmer-inline-c` up.
+
+use cbindgen::{Builder, Language};
+use std::{
+    env,
+    ffi::OsStr,
+    fs,
+    path::{Path, PathBuf},
+};
+
+const PRE_HEADER: &str = r#"
+// Define the `ARCH_X86_X64` constant.
+#if defined(MSVC) && defined(_M_AMD64)
+#  define ARCH_X86_64
+#elif (defined(GCC) || defined(__GNUC__) || defined(__clang__)) && defined(__x86_64__)
+#  define ARCH_X86_64
+#endif
+
+// Compatibility with non-Clang compilers.
+#if !defined(__has_attribute)
+#  define __has_attribute(x) 0
+#endif
+
+// Compatibility with non-Clang compilers.
+#if !defined(__has_declspec_attribute)
+#  define __has_declspec_attribute(x) 0
+#endif
+
+// Define the `DEPRECATED` macro.
+#if defined(GCC) || defined(__GNUC__) || __has_attribute(deprecated)
+#  define DEPRECATED(message) __attribute__((deprecated(message)))
+#elif defined(MSVC) || __has_declspec_attribute(deprecated)
+#  define DEPRECATED(message) __declspec(deprecated(message))
+#endif
+"#;
+
+#[allow(unused)]
+const UNIVERSAL_FEATURE_AS_C_DEFINE: &str = "WASMER_UNIVERSAL_ENABLED";
+
+#[allow(unused)]
+const COMPILER_FEATURE_AS_C_DEFINE: &str = "WASMER_COMPILER_ENABLED";
+
+#[allow(unused)]
+const WASI_FEATURE_AS_C_DEFINE: &str = "WASMER_WASI_ENABLED";
+
+#[allow(unused)]
+const MIDDLEWARES_FEATURE_AS_C_DEFINE: &str = "WASMER_MIDDLEWARES_ENABLED";
+
+#[allow(unused)]
+const EMSCRIPTEN_FEATURE_AS_C_DEFINE: &str = "WASMER_EMSCRIPTEN_ENABLED";
+
+#[allow(unused)]
+const JSC_FEATURE_AS_C_DEFINE: &str = "WASMER_JSC_BACKEND";
+
+macro_rules! map_feature_as_c_define {
+    ($feature:expr, $c_define:ident, $accumulator:ident) => {
+        #[cfg(feature = $feature)]
+        {
+            use std::fmt::Write;
+            let _ = write!(
+                $accumulator,
+                r#"
+// The `{feature}` feature has been enabled for this build.
+#define {define}
+"#,
+                feature = $feature,
+                define = $c_define,
+            );
+        }
+    };
+}
+
+fn main() {
+    if !running_self() {
+        return;
+    }
+
+    let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let out_dir = env::var("OUT_DIR").unwrap();
+
+    build_wasm_c_api_headers(&crate_dir, &out_dir);
+    build_inline_c_env_vars();
+    build_cdylib_link_arg();
+}
+
+/// Check whether we should build the C API headers or set `wasmer-inline-c` up.
+fn running_self() -> bool {
+    env::var("DOCS_RS").is_err()
+        && env::var("_CBINDGEN_IS_RUNNING").is_err()
+        && env::var("WASMER_PUBLISH_SCRIPT_IS_RUNNING").is_err()
+}
+
+/// Build the header files for the `wasm_c_api` API.
+fn build_wasm_c_api_headers(crate_dir: &str, out_dir: &str) {
+    let mut crate_header_file = PathBuf::from(crate_dir);
+    crate_header_file.push("wasmer");
+
+    let mut out_header_file = PathBuf::from(out_dir);
+    out_header_file.push("wasmer");
+
+    let mut pre_header = format!(
+        r#"// The Wasmer C/C++ header file compatible with the [`wasm-c-api`]
+// standard API, as `wasm.h` (included here).
+//
+// This file is automatically generated by `lib/c-api/build.rs` of the
+// [`wasmer-c-api`] Rust crate.
+//
+// # Stability
+//
+// The [`wasm-c-api`] standard API is a _living_ standard. There is no
+// commitment for stability yet. We (Wasmer) will try our best to keep
+// backward compatibility as much as possible. Nonetheless, some
+// necessary API aren't yet standardized, and as such, we provide a
+// custom API, e.g. `wasi_*` types and functions.
+//
+// The documentation makes it clear whether a function is unstable.
+// 
+// When a type or a function will be deprecated, it will be marked as
+// such with the appropriated compiler warning, and will be removed at
+// the next release round.
+//
+// # Documentation
+//
+// At the time of writing, the [`wasm-c-api`] standard has no
+// documentation. This file also does not include inline
+// documentation. However, we have made (and we continue to make) an
+// important effort to document everything. [See the documentation
+// online][documentation]. Please refer to this page for the real
+// canonical documentation. It also contains numerous examples.
+//
+// To generate the documentation locally, run `cargo doc --open` from
+// within the [`wasmer-c-api`] Rust crate.
+//
+// [`wasm-c-api`]: https://github.com/WebAssembly/wasm-c-api
+// [`wasmer-c-api`]: https://github.com/wasmerio/wasmer/tree/master/lib/c-api
+// [documentation]: https://wasmerio.github.io/wasmer/crates/wasmer_c_api/
+
+#if !defined(WASMER_H_PRELUDE)
+
+#define WASMER_H_PRELUDE
+{pre_header}"#,
+        pre_header = PRE_HEADER
+    );
+
+    map_feature_as_c_define!("jsc", JSC_FEATURE_AS_C_DEFINE, pre_header);
+    map_feature_as_c_define!("compiler", UNIVERSAL_FEATURE_AS_C_DEFINE, pre_header);
+    map_feature_as_c_define!("compiler", COMPILER_FEATURE_AS_C_DEFINE, pre_header);
+    map_feature_as_c_define!("wasi", WASI_FEATURE_AS_C_DEFINE, pre_header);
+    map_feature_as_c_define!("middlewares", MIDDLEWARES_FEATURE_AS_C_DEFINE, pre_header);
+    map_feature_as_c_define!("emscripten", EMSCRIPTEN_FEATURE_AS_C_DEFINE, pre_header);
+
+    add_wasmer_version(&mut pre_header);
+
+    // Close pre header.
+    pre_header.push_str(
+        r#"
+#endif // WASMER_H_PRELUDE
+
+
+//
+// OK, here we go. The code below is automatically generated.
+//
+"#,
+    );
+
+    let guard = "WASMER_H";
+
+    // C bindings.
+    {
+        // Generate the bindings in the `OUT_DIR`.
+        out_header_file.set_extension("h");
+
+        // Build and generate the header file.
+        new_builder(Language::C, crate_dir, guard, &pre_header)
+            .with_include("wasm.h")
+            .generate()
+            .expect("Unable to generate C bindings")
+            .write_to_file(out_header_file.as_path());
+
+        // Copy the generated bindings from `OUT_DIR` to
+        // `CARGO_MANIFEST_DIR`.
+        crate_header_file.set_extension("h");
+
+        fs::copy(out_header_file.as_path(), crate_header_file.as_path())
+            .expect("Unable to copy the generated C bindings");
+    }
+}
+
+fn add_wasmer_version(pre_header: &mut String) {
+    use std::fmt::Write;
+    let _ = write!(
+        pre_header,
+        r#"
+// This file corresponds to the following Wasmer version.
+#define WASMER_VERSION "{full}"
+#define WASMER_VERSION_MAJOR {major}
+#define WASMER_VERSION_MINOR {minor}
+#define WASMER_VERSION_PATCH {patch}
+#define WASMER_VERSION_PRE "{pre}"
+"#,
+        full = env!("CARGO_PKG_VERSION"),
+        major = env!("CARGO_PKG_VERSION_MAJOR"),
+        minor = env!("CARGO_PKG_VERSION_MINOR"),
+        patch = env!("CARGO_PKG_VERSION_PATCH"),
+        pre = env!("CARGO_PKG_VERSION_PRE"),
+    );
+}
+
+/// Create a fresh new `Builder`, already pre-configured.
+fn new_builder(language: Language, crate_dir: &str, include_guard: &str, header: &str) -> Builder {
+    Builder::new()
+        .with_config(cbindgen::Config {
+            sort_by: cbindgen::SortKey::Name,
+            cpp_compat: true,
+            ..cbindgen::Config::default()
+        })
+        .with_language(language)
+        .with_crate(crate_dir)
+        .with_include_guard(include_guard)
+        .with_header(header)
+        .with_documentation(false)
+        .with_define("target_family", "windows", "_WIN32")
+        .with_define("target_arch", "x86_64", "ARCH_X86_64")
+        .with_define("feature", "universal", UNIVERSAL_FEATURE_AS_C_DEFINE)
+        .with_define("feature", "compiler", COMPILER_FEATURE_AS_C_DEFINE)
+        .with_define("feature", "wasi", WASI_FEATURE_AS_C_DEFINE)
+        .with_define("feature", "emscripten", EMSCRIPTEN_FEATURE_AS_C_DEFINE)
+}
+
+fn build_inline_c_env_vars() {
+    let shared_object_dir = shared_object_dir();
+    let shared_object_dir = shared_object_dir.as_path().to_string_lossy();
+    let include_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+
+    // The following options mean:
+    //
+    // * `-I`, add `include_dir` to include search path,
+    // * `-L`, add `shared_object_dir` to library search path,
+    // * `-D_DEBUG`, enable debug mode to enable `assert.h`.
+    // * `-D_CRT_SECURE_NO_WARNINGS`, disable security features in the
+    //   Windows C runtime, which allows to use `getenv` without any
+    //   warnings.
+    println!(
+        "cargo:rustc-env=INLINE_C_RS_CFLAGS=-I{I} -L{L} -D_DEBUG -D_CRT_SECURE_NO_WARNINGS",
+        I = include_dir,
+        L = shared_object_dir.clone(),
+    );
+
+    if let Ok(compiler_engine) = env::var("TEST") {
+        println!(
+            "cargo:rustc-env=INLINE_C_RS_TEST={test}",
+            test = compiler_engine
+        );
+    }
+
+    println!(
+        "cargo:rustc-env=INLINE_C_RS_LDFLAGS=-rpath,{shared_object_dir} {shared_object_dir}/{lib}",
+        shared_object_dir = shared_object_dir,
+        lib = if cfg!(target_os = "windows") {
+            "wasmer.dll".to_string()
+        } else if cfg!(target_vendor = "apple") {
+            "libwasmer.dylib".to_string()
+        } else {
+            let path = format!(
+                "{shared_object_dir}/{lib}",
+                shared_object_dir = shared_object_dir,
+                lib = "libwasmer.so"
+            );
+
+            if Path::new(path.as_str()).exists() {
+                "libwasmer.so".to_string()
+            } else {
+                "libwasmer.a".to_string()
+            }
+        }
+    );
+}
+
+fn build_cdylib_link_arg() {
+    // Code inspired by the `cdylib-link-lines` crate.
+    let mut lines = Vec::new();
+    let os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let env = env::var("CARGO_CFG_TARGET_ENV").unwrap();
+    let version_major = env::var("CARGO_PKG_VERSION_MAJOR").unwrap();
+    let version_minor = env::var("CARGO_PKG_VERSION_MINOR").unwrap();
+    let version_patch = env::var("CARGO_PKG_VERSION_PATCH").unwrap();
+    let shared_object_dir = shared_object_dir();
+
+    match (os.as_str(), env.as_str()) {
+        ("android", _) => {
+            lines.push("-Wl,-soname,libwasmer.so".to_string());
+        }
+
+        ("linux", _) | ("freebsd", _) | ("dragonfly", _) | ("netbsd", _) if env != "musl" => {
+            lines.push("-Wl,-soname,libwasmer.so".to_string());
+        }
+
+        ("macos", _) | ("ios", _) => {
+            lines.push(format!(
+                "-Wl,-install_name,@rpath/libwasmer.dylib,-current_version,{x}.{y}.{z},-compatibility_version,{x}",
+                x = version_major,
+                y = version_minor,
+                z = version_patch,
+            ));
+        }
+
+        ("windows", "gnu") => {
+            // This is only set up to work on GNU toolchain versions of Rust
+            lines.push(format!(
+                "-Wl,--out-implib,{}",
+                shared_object_dir.join("wasmer.dll.a").display()
+            ));
+            lines.push(format!(
+                "-Wl,--output-def,{}",
+                shared_object_dir.join("wasmer.def").display()
+            ));
+        }
+
+        _ => {}
+    }
+
+    for line in lines {
+        println!("cargo:rustc-cdylib-link-arg={}", line);
+    }
+}
+
+fn shared_object_dir() -> PathBuf {
+    // We start from `OUT_DIR` because `cargo publish` uses a different directory
+    // so traversing from `CARGO_MANIFEST_DIR` is less reliable.
+    let mut shared_object_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+
+    assert_eq!(shared_object_dir.file_name(), Some(OsStr::new("out")));
+    shared_object_dir.pop();
+
+    assert!(shared_object_dir
+        .file_name()
+        .as_ref()
+        .unwrap()
+        .to_string_lossy()
+        .to_string()
+        .starts_with("wasmer-c-api"));
+    shared_object_dir.pop();
+
+    assert_eq!(shared_object_dir.file_name(), Some(OsStr::new("build")));
+    shared_object_dir.pop();
+    shared_object_dir.pop(); // "debug" or "release"
+
+    // We either find `target` or the target triple if cross-compiling.
+    if shared_object_dir.file_name() != Some(OsStr::new("target")) {
+        let target = env::var("TARGET").unwrap();
+        if shared_object_dir.file_name() != Some(OsStr::new("llvm-cov-target")) {
+            assert_eq!(shared_object_dir.file_name(), Some(OsStr::new(&target)));
+        } else {
+            shared_object_dir.set_file_name(&target);
+        }
+    }
+
+    shared_object_dir.push(env::var("PROFILE").unwrap());
+
+    shared_object_dir
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/doc/.empty b/arbitrator/tools/module_roots/wasmer/lib/c-api/doc/.empty
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/Makefile b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/Makefile
new file mode 100644
index 0000000..e2c919c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/Makefile
@@ -0,0 +1,44 @@
+WASMER_DIR:=$(realpath $(WASMER_DIR))
+
+$(info Using provided WASMER_DIR=$(WASMER_DIR))
+
+ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+ROOT_DIR_PARENT:=$(shell dirname $(ROOT_DIR))
+
+MSVC_CFLAGS:=""
+MSVC_LDFLAGS:=""
+MSVC_LDLIBS:=""
+
+ifeq (,$(wildcard $(WASMER_DIR)/bin/wasmer))
+	CFLAGS = -g -I $(ROOT_DIR)/ -I $(WASMER_DIR)/include
+	LDFLAGS = -Wl,-rpath,$(WASMER_DIR)/lib
+	LDLIBS = -L $(WASMER_DIR)/lib -lwasmer
+
+	MSVC_CFLAGS:= /DEBUG /I $(ROOT_DIR)/ /I $(WASMER_DIR)/include
+	MSVC_LDFLAGS:= ""
+	MSVC_LDLIBS:= /LIBPATH:$(WASMER_DIR)/lib wasmer.dll.lib
+else
+	CFLAGS = -g -I $(ROOT_DIR)/ -I $(shell $(WASMER_DIR)/bin/wasmer config --includedir)
+	LDFLAGS = -Wl,-rpath,$(shell $(WASMER_DIR)/bin/wasmer config --libdir)
+	LDLIBS = $(shell $(WASMER_DIR)/bin/wasmer config --libs)
+
+	MSVC_CFLAGS:= /DEBUG /I $(ROOT_DIR)/ /I $(shell $(WASMER_DIR)/bin/wasmer config --includedir)
+	MSVC_LDFLAGS:= ""
+	MSVC_LDLIBS:= /LIBPATH:$(shell $(WASMER_DIR)/bin/wasmer config --libs) wasmer.dll.lib
+endif
+
+$(info * CFLAGS: $(CFLAGS))
+$(info * LDFLAGS: $(LDFLAGS))
+$(info * LDLIBS: $(LDLIBS))
+
+ALL = deprecated-header early-exit instance imports-exports exports-function exports-global memory memory2 features wasi
+
+.PHONY: run
+.SILENT: run
+run: 	
+	WASMER_DIR="$(WASMER_DIR)" ROOT_DIR="$(ROOT_DIR)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)" LDLIBS="$(LDLIBS)" cargo test --manifest-path="./wasmer-capi-examples-runner/Cargo.toml" -- --nocapture 2>&1
+
+.SILENT: clean
+.PHONY: clean
+clean:
+	$(foreach file,$(ALL),rm -f $(file).o $(file))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wasm
new file mode 100644
index 0000000..44cbb27
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wat
new file mode 100644
index 0000000..febd5f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/call_trap.wat
@@ -0,0 +1,11 @@
+(module
+  (type $run_t (func (param i32 i32) (result i32)))
+  (type $early_exit_t (func (param) (result)))
+  (import "env" "early_exit" (func $early_exit (type $early_exit_t)))
+  (func $run (type $run_t) (param $x i32) (param $y i32) (result i32)
+    (call $early_exit)
+    (i32.add
+        (local.get $x)
+        (local.get $y)))
+  (export "run" (func $run)))
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/python-0.1.0.wasmer b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/python-0.1.0.wasmer
new file mode 100644
index 0000000..cf6fb44
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/python-0.1.0.wasmer differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs-wasmer.toml b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs-wasmer.toml
new file mode 100644
index 0000000..53751a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs-wasmer.toml
@@ -0,0 +1,13 @@
+[package]
+name = "adamz/qjs"
+version = "0.0.1"
+description = "https://github.com/bellard/quickjs"
+license = "MIT"
+
+[[command]]
+name = "qjs"
+module = "qjs"
+
+[[module]]
+name = "qjs"
+source = "qjs.wasm"
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs.wasm
new file mode 100755
index 0000000..91f73f1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/qjs.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/staticserver.webc b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/staticserver.webc
new file mode 100644
index 0000000..3cd4135
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/staticserver.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/wabt-1.0.37.wasmer b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/wabt-1.0.37.wasmer
new file mode 100644
index 0000000..aa2859a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/assets/wabt-1.0.37.wasmer differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/deprecated-header.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/deprecated-header.c
new file mode 100644
index 0000000..fca3e2e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/deprecated-header.c
@@ -0,0 +1,137 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// This is now deprecated, but it should work regardless
+#include "wasmer_wasm.h"
+
+#define own
+
+// Use the last_error API to retrieve error messages
+own char* get_wasmer_error() {
+  int error_len = wasmer_last_error_length();
+  printf("Error len: `%d`\n", error_len);
+  char *error_str = malloc(error_len);
+  wasmer_last_error_message(error_str, error_len);
+  return error_str;
+}
+
+int main(int argc, const char *argv[]) {
+  printf("Initializing...\n");
+  own wasm_engine_t* engine = wasm_engine_new();
+  own wasm_store_t* store = wasm_store_new(engine);
+
+  // =====================
+  wasm_limits_t limits1 = {
+    .min = 0,
+    .max = 0x7FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype1 = wasm_memorytype_new(&limits1);
+  own wasm_memory_t* memory1 = wasm_memory_new(store, memtype1);
+  assert(memory1 == NULL);
+  char* error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The maximum requested memory (2147483647 pages) is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype1);
+
+  // =====================
+  wasm_limits_t limits2 = {
+    .min = 15,
+    .max = 25,
+  };
+  own wasm_memorytype_t* memtype2 = wasm_memorytype_new(&limits2);
+  own wasm_memory_t* memory2 = wasm_memory_new(store, memtype2);
+  assert(memory2 != NULL);
+
+  wasm_memorytype_delete(memtype2);
+  wasm_memory_delete(memory2);
+
+  // =====================
+  wasm_limits_t limits3 = {
+    .min = 15,
+    .max = wasm_limits_max_default,
+  };
+  own wasm_memorytype_t* memtype3 = wasm_memorytype_new(&limits3);
+  own wasm_memory_t* memory3 = wasm_memory_new(store, memtype3);
+  assert(memory3 != NULL);
+  int size = wasm_memory_size(memory3);
+  printf("memory size: %d\n", size);
+
+  wasm_memorytype_delete(memtype3);
+  wasm_memory_delete(memory3);
+
+  // =====================
+  wasm_limits_t limits4 = {
+    .min = 0x7FFFFFFF,
+    .max = 0x7FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype4 = wasm_memorytype_new(&limits4);
+  own wasm_memory_t* memory4 = wasm_memory_new(store, memtype4);
+  assert(memory4 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype4);
+
+  // =====================
+  wasm_limits_t limits5 = {
+    .min = 0x7FFFFFFF,
+    .max = 0x0FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype5 = wasm_memorytype_new(&limits5);
+  own wasm_memory_t* memory5 = wasm_memory_new(store, memtype5);
+  assert(memory5 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype5);
+
+  // =====================
+  wasm_limits_t limits6 = {
+    .min = 15,
+    .max = 10,
+  };
+  own wasm_memorytype_t* memtype6 = wasm_memorytype_new(&limits6);
+  own wasm_memory_t* memory6 = wasm_memory_new(store, memtype6);
+  assert(memory6 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The memory is invalid because the maximum (10 pages) is less than the minimum (15 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype6);
+
+  // =====================
+  wasm_limits_t limits7 = {
+    .min = 0x7FFFFFFF,
+    .max = 10,
+  };
+  own wasm_memorytype_t* memtype7 = wasm_memorytype_new(&limits7);
+  own wasm_memory_t* memory7 = wasm_memory_new(store, memtype7);
+  assert(memory7 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype7);
+
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/early-exit.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/early-exit.c
new file mode 100644
index 0000000..6c4bb08
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/early-exit.c
@@ -0,0 +1,168 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "wasmer.h"
+
+#define own
+
+// Use the last_error API to retrieve error messages
+void print_wasmer_error() {
+  int error_len = wasmer_last_error_length();
+  if (error_len > 0) {
+    printf("Error len: `%d`\n", error_len);
+    char *error_str = malloc(error_len);
+    wasmer_last_error_message(error_str, error_len);
+    printf("Error str: `%s`\n", error_str);
+  }
+}
+
+void print_frame(wasm_frame_t* frame) {
+  printf("> %p @ 0x%zx = %"PRIu32".0x%zx\n",
+    wasm_frame_instance(frame),
+    wasm_frame_module_offset(frame),
+    wasm_frame_func_index(frame),
+    wasm_frame_func_offset(frame)
+  );
+}
+
+wasm_store_t *store = NULL;
+
+own wasm_trap_t* early_exit(const wasm_val_vec_t* args, wasm_val_vec_t* results) {
+  own wasm_message_t trap_message;
+  wasm_name_new_from_string_nt(&trap_message, "trapping from a host import");
+  own wasm_trap_t *trap = wasm_trap_new(store, &trap_message);
+  wasm_name_delete(&trap_message);
+  return trap;
+}
+
+int main(int argc, const char *argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t *engine = wasm_engine_new();
+  store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE *file = fopen("assets/call_trap.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t *module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+
+  wasm_functype_t *host_func_type = wasm_functype_new_0_0();
+  wasm_func_t *host_func = wasm_func_new(store, host_func_type, early_exit);
+
+  wasm_functype_delete(host_func_type);
+
+  wasm_extern_vec_t imports;
+  wasm_extern_vec_new_uninitialized(&imports, 1);
+  imports.data[0] = wasm_func_as_extern(host_func);
+
+  own wasm_instance_t *instance =
+      wasm_instance_new(store, module, &imports, NULL);
+
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  fprintf(stderr, "found %zu exports\n", exports.size);
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+
+  wasm_func_t *run_func = wasm_extern_as_func(exports.data[0]);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  // Call.
+  printf("Calling export...\n");
+  wasm_val_t values[2] = { WASM_I32_VAL(1), WASM_I32_VAL(7) };
+  own wasm_val_vec_t args = WASM_ARRAY_VEC(values);
+  wasm_val_t result = WASM_INIT_VAL;
+  own wasm_val_vec_t rets = { 1, &result };
+  own wasm_trap_t *trap = wasm_func_call(run_func, &args, &rets);
+
+  if (!trap) {
+    printf("> Error calling function: expected trap!\n");
+    return 1;
+  }
+
+  printf("Printing message...\n");
+  own wasm_name_t message;
+  wasm_trap_message(trap, &message);
+  printf("> %s\n", message.data);
+
+  printf("Printing origin...\n");
+  own wasm_frame_t* frame = wasm_trap_origin(trap);
+  if (frame) {
+    print_frame(frame);
+    wasm_frame_delete(frame);
+  } else {
+    printf("> Empty origin.\n");
+  }
+
+  printf("Printing trace...\n");
+  own wasm_frame_vec_t trace;
+  wasm_trap_trace(trap, &trace);
+  if (trace.size > 0) {
+    for (size_t i = 0; i < trace.size; ++i) {
+      print_frame(trace.data[i]);
+    }
+  } else {
+    printf("> Empty trace.\n");
+  }
+
+  wasm_frame_vec_delete(&trace);
+  wasm_trap_delete(trap);
+  wasm_name_delete(&message);
+
+  wasm_extern_vec_delete(&exports);
+  wasm_extern_vec_delete(&imports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-function.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-function.c
new file mode 100644
index 0000000..8c64463
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-function.c
@@ -0,0 +1,85 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "  (type $sum_t (func (param i32 i32) (result i32)))\n"
+        "  (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)\n"
+        "    local.get $x\n"
+        "    local.get $y\n"
+        "    i32.add)\n"
+        "  (export \"sum\" (func $sum_f)))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating imports...\n");
+    wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    printf("Retrieving the `sum` function...\n");
+    wasm_func_t* sum_func = wasm_extern_as_func(exports.data[0]);
+
+    if (sum_func == NULL) {
+        printf("> Failed to get the `sum` function!\n");
+
+        return 1;
+    }
+
+    printf("Calling `sum` function...\n");
+    wasm_val_t args_val[2] = { WASM_I32_VAL(3), WASM_I32_VAL(4) };
+    wasm_val_t results_val[1] = { WASM_INIT_VAL };
+    wasm_val_vec_t args = WASM_ARRAY_VEC(args_val);
+    wasm_val_vec_t results = WASM_ARRAY_VEC(results_val);
+
+    if (wasm_func_call(sum_func, &args, &results)) {
+        printf("> Error calling the `sum` function!\n");
+
+        return 1;
+    }
+
+    printf("Results of `sum`: %d\n", results_val[0].of.i32);
+
+    wasm_module_delete(module);
+    wasm_instance_delete(instance);
+    wasm_extern_vec_delete(&exports);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-global.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-global.c
new file mode 100644
index 0000000..ff20dfd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/exports-global.c
@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "  (global $one (export \"one\") f32 (f32.const 1))\n"
+        "  (global $some (export \"some\") (mut f32) (f32.const 0))\n"
+        "  (func (export \"get_one\") (result f32) (global.get $one))\n"
+        "  (func (export \"get_some\") (result f32) (global.get $some))\n"
+        "  (func (export \"set_some\") (param f32) (global.set $some (local.get 0))))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating imports...\n");
+    wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    wasm_global_t* one = wasm_extern_as_global(exports.data[0]);
+
+    if (one == NULL) {
+        printf("> Failed to get the `one` global!\n");
+
+        return 1;
+    }
+
+    wasm_global_t* some = wasm_extern_as_global(exports.data[1]);
+
+    if (some == NULL) {
+        printf("> Failed to get the `some` global!\n");
+
+        return 1;
+    }
+
+    printf("Getting globals types information...\n");
+    wasm_globaltype_t* one_type = wasm_global_type(one);
+    wasm_globaltype_t* some_type = wasm_global_type(some);
+
+    wasm_mutability_t one_mutability = wasm_globaltype_mutability(one_type);
+    const wasm_valtype_t* one_content = wasm_globaltype_content(one_type);
+    wasm_valkind_t one_kind = wasm_valtype_kind(one_content);
+
+    wasm_mutability_t some_mutability = wasm_globaltype_mutability(some_type);
+    const wasm_valtype_t* some_content = wasm_globaltype_content(some_type);
+    wasm_valkind_t some_kind = wasm_valtype_kind(some_content);
+
+    printf("`one` type: %s %hhu\n", one_mutability == WASM_CONST ? "const" : "", one_kind);
+    printf("`some` type: %s %hhu\n", some_mutability == WASM_CONST ? "const" : "", some_kind);
+
+    printf("Getting global values...");
+    wasm_val_t one_value;
+    wasm_global_get(one, &one_value);
+    printf("`one` value: %.1f\n", one_value.of.f32);
+
+    wasm_val_t some_value;
+    wasm_global_get(some, &some_value);
+    printf("`some` value: %.1f\n", some_value.of.f32);
+
+    printf("Setting global values...\n");
+    wasm_val_t one_set_value = WASM_F32_VAL(42);
+    wasm_global_set(one, &one_set_value);
+
+    int error_length = wasmer_last_error_length();
+    if (error_length > 0) {
+        char *error_message = malloc(error_length);
+        wasmer_last_error_message(error_message, error_length);
+
+        printf("Attempted to set an immutable global: `%s`\n", error_message);
+        free(error_message);
+    }
+
+    wasm_val_t some_set_value = WASM_F32_VAL(21);
+    wasm_global_set(some, &some_set_value);
+    printf("`some` value: %.1f\n", some_value.of.f32);
+
+    wasm_globaltype_delete(one_type);
+    wasm_globaltype_delete(some_type);
+    wasm_module_delete(module);
+    wasm_extern_vec_delete(&exports);
+    wasm_instance_delete(instance);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/features.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/features.c
new file mode 100644
index 0000000..103017c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/features.c
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    // This is not enabled in JavascriptCore
+    #ifndef WASMER_JSC_BACKEND
+
+    const char *wat_string =
+        "(module\n"
+        "  (type $swap_t (func (param i32 i64) (result i64 i32)))\n"
+        "  (func $swap (type $swap_t) (param $x i32) (param $y i64) (result i64 i32)\n"
+        "    (local.get $y)\n"
+        "    (local.get $x))\n"
+        "  (export \"swap\" (func $swap)))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the config and the features...\n");
+    wasm_config_t* config = wasm_config_new();
+
+    wasmer_features_t* features = wasmer_features_new();
+    wasmer_features_multi_value(features, true); // enable multi-value!
+    wasm_config_set_features(config, features);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new_with_config(config);
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Instantiating module...\n");
+    wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+    wasm_trap_t* trap = NULL;
+    wasm_instance_t* instance = wasm_instance_new(store, module, &imports,&trap);
+
+    if (!instance) {
+        printf("> Error instantiating module!\n");
+
+        return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    printf("Executing `swap(1, 2)`...\n");
+    wasm_func_t* swap = wasm_extern_as_func(exports.data[0]);
+
+    wasm_val_t arguments[2] = { WASM_I32_VAL(1), WASM_I64_VAL(2) };
+    wasm_val_t results[2] = { WASM_INIT_VAL, WASM_INIT_VAL };
+    wasm_val_vec_t arguments_as_array = WASM_ARRAY_VEC(arguments);
+    wasm_val_vec_t results_as_array = WASM_ARRAY_VEC(results);
+
+    trap = wasm_func_call(swap, &arguments_as_array, &results_as_array);
+
+    if (trap != NULL) {
+        printf("> Failed to call `swap`.\n");
+
+        return 1;
+    }
+
+    if (results[0].of.i64 != 2 || results[1].of.i32 != 1) {
+        printf("> Multi-value failed.\n");
+
+        return 1;
+    }
+
+    printf("Got `(2, 1)`!\n");
+
+    wasm_extern_vec_delete(&exports);
+    wasm_module_delete(module);
+    wasm_instance_delete(instance);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+
+    #endif //WASMER_JSC_BACKEND
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/imports-exports.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/imports-exports.c
new file mode 100644
index 0000000..e56a723
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/imports-exports.c
@@ -0,0 +1,134 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+wasm_trap_t* host_func_callback(const wasm_val_vec_t* args, wasm_val_vec_t* results) {
+    printf("Calling back...\n> ");
+
+    wasm_val_t val = WASM_I32_VAL(42);
+    wasm_val_copy(&results->data[0], &val);
+
+    wasm_val_delete(&val);
+
+    return NULL;
+}
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "  (func $host_function (import \"\" \"host_function\") (result i32))\n"
+        "  (global $host_global (import \"env\" \"host_global\") i32)\n"
+        "  (func $function (export \"guest_function\") (result i32) (global.get $global))\n"
+        "  (global $global (export \"guest_global\") i32 (i32.const 42))\n"
+        "  (table $table (export \"guest_table\") 1 1 funcref)\n"
+        "  (memory $memory (export \"guest_memory\") 1))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating the imported function...\n");
+    wasm_functype_t* host_func_type = wasm_functype_new_0_1(wasm_valtype_new_i32());
+    wasm_func_t* host_func = wasm_func_new(store, host_func_type, host_func_callback);
+    wasm_functype_delete(host_func_type);
+
+    printf("Creating the imported global...\n");
+    wasm_globaltype_t* host_global_type = wasm_globaltype_new(wasm_valtype_new(WASM_F32), WASM_CONST);
+    wasm_val_t host_global_val = WASM_I32_VAL(42);
+    wasm_global_t* host_global = wasm_global_new(store, host_global_type, &host_global_val);
+    wasm_globaltype_delete(host_global_type);
+
+    wasm_extern_t* externs[] = {
+        wasm_func_as_extern(host_func),
+        wasm_global_as_extern(host_global)
+    };
+
+    wasm_extern_vec_t import_object = WASM_ARRAY_VEC(externs);
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+    wasm_func_delete(host_func);
+    wasm_global_delete(host_global);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    printf("Retrieving the exported function...\n");
+    wasm_func_t* func = wasm_extern_as_func(exports.data[0]);
+
+    if (func == NULL) {
+        printf("> Failed to get the exported function!\n");
+
+        return 1;
+    }
+
+    printf("Got the exported function: %p\n", func);
+
+    printf("Retrieving the exported global...\n");
+    wasm_global_t* global = wasm_extern_as_global(exports.data[1]);
+
+    if (global == NULL) {
+        printf("> Failed to get the exported global!\n");
+
+        return 1;
+    }
+
+    printf("Got the exported global: %p\n", global);
+
+    printf("Retrieving the exported table...\n");
+    wasm_table_t* table = wasm_extern_as_table(exports.data[2]);
+
+    if (table == NULL) {
+        printf("> Failed to get the exported table!\n");
+
+        return 1;
+    }
+
+    printf("Got the exported table: %p\n", table);
+
+    printf("Retrieving the exported memory...\n");
+    wasm_memory_t* memory = wasm_extern_as_memory(exports.data[3]);
+
+    if (memory == NULL) {
+        printf("> Failed to get the exported memory!\n");
+
+        return 1;
+    }
+
+    printf("Got the exported memory: %p\n", memory);
+
+    wasm_module_delete(module);
+    wasm_extern_vec_delete(&exports);
+    wasm_instance_delete(instance);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/instance.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/instance.c
new file mode 100644
index 0000000..6eb867d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/instance.c
@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "  (type $add_one_t (func (param i32) (result i32)))\n"
+        "  (func $add_one_f (type $add_one_t) (param $value i32) (result i32)\n"
+        "    local.get $value\n"
+        "    i32.const 1\n"
+        "    i32.add)\n"
+        "  (export \"add_one\" (func $add_one_f)))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating imports...\n");
+    wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &imports, NULL);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    const wasm_func_t* add_one_func = wasm_extern_as_func(exports.data[0]);
+    if (add_one_func == NULL) {
+        printf("> Error accessing export!\n");
+
+        return 1;
+    }
+
+    wasm_module_delete(module);
+    wasm_instance_delete(instance);
+
+    printf("Calling `add_one` function...\n");
+    wasm_val_t args_val[1] = { WASM_I32_VAL(1) };
+    wasm_val_t results_val[1] = { WASM_INIT_VAL };
+    wasm_val_vec_t args = WASM_ARRAY_VEC(args_val);
+    wasm_val_vec_t results = WASM_ARRAY_VEC(results_val);
+
+    if (wasm_func_call(add_one_func, &args, &results)) {
+        printf("> Error calling function!\n");
+
+        return 1;
+    }
+
+    printf("Results of `add_one`: %d\n", results_val[0].of.i32);
+
+    wasm_extern_vec_delete(&exports);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory.c
new file mode 100644
index 0000000..d332951
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory.c
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include "wasmer.h"
+
+int main(int argc, const char* argv[]) {
+    const char *wat_string =
+        "(module\n"
+        "   (type $mem_size_t (func (result i32)))\n"
+        "   (type $get_at_t (func (param i32) (result i32)))\n"
+        "   (type $set_at_t (func (param i32) (param i32)))\n"
+        "   (memory $mem 1)\n"
+        "   (func $get_at (type $get_at_t) (param $idx i32) (result i32)\n"
+        "     (i32.load (local.get $idx)))\n"
+        "   (func $set_at (type $set_at_t) (param $idx i32) (param $val i32)\n"
+        "     (i32.store (local.get $idx) (local.get $val)))\n"
+        "   (func $mem_size (type $mem_size_t) (result i32)\n"
+        "     (memory.size))\n"
+        "   (export \"get_at\" (func $get_at))\n"
+        "   (export \"set_at\" (func $set_at))\n"
+        "   (export \"mem_size\" (func $mem_size))\n"
+        "   (export \"memory\" (memory $mem)))";
+
+    wasm_byte_vec_t wat;
+    wasm_byte_vec_new(&wat, strlen(wat_string), wat_string);
+    wasm_byte_vec_t wasm_bytes;
+    wat2wasm(&wat, &wasm_bytes);
+    wasm_byte_vec_delete(&wat);
+
+    printf("Creating the store...\n");
+    wasm_engine_t* engine = wasm_engine_new();
+    wasm_store_t* store = wasm_store_new(engine);
+
+    printf("Compiling module...\n");
+    wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+
+    if (!module) {
+        printf("> Error compiling module!\n");
+
+        return 1;
+    }
+
+    wasm_byte_vec_delete(&wasm_bytes);
+
+    printf("Creating imports...\n");
+    wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+
+    printf("Instantiating module...\n");
+    wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+
+      return 1;
+    }
+
+    printf("Retrieving exports...\n");
+    wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+
+    if (exports.size == 0) {
+        printf("> Error accessing exports!\n");
+
+        return 1;
+    }
+
+    wasm_func_t* get_at = wasm_extern_as_func(exports.data[0]);
+    wasm_func_t* set_at = wasm_extern_as_func(exports.data[1]);
+    wasm_func_t* mem_size = wasm_extern_as_func(exports.data[2]);
+    wasm_memory_t* memory = wasm_extern_as_memory(exports.data[3]);
+
+    printf("Querying memory size...\n");
+    wasm_memory_pages_t pages = wasm_memory_size(memory);
+    size_t data_size = wasm_memory_data_size(memory);
+    printf("Memory size (pages): %d\n", pages);
+    printf("Memory size (bytes): %d\n", (int) data_size);
+
+    printf("Growing memory...\n");
+    if (!wasm_memory_grow(memory, 2)) {
+        printf("> Error growing memory!\n");
+
+        return 1;
+    }
+
+    wasm_memory_pages_t new_pages = wasm_memory_size(memory);
+    printf("New memory size (pages): %d\n", new_pages);
+
+    int mem_addr = 0x2220;
+    int val = 0xFEFEFFE;
+
+    wasm_val_t set_at_args_val[2] = { WASM_I32_VAL(mem_addr), WASM_I32_VAL(val) };
+    wasm_val_vec_t set_at_args = WASM_ARRAY_VEC(set_at_args_val);
+    wasm_val_vec_t set_at_results = WASM_EMPTY_VEC;
+    wasm_func_call(set_at, &set_at_args, &set_at_results);
+
+    wasm_val_t get_at_args_val[1] = { WASM_I32_VAL(mem_addr) };
+    wasm_val_vec_t get_at_args = WASM_ARRAY_VEC(get_at_args_val);
+    wasm_val_t get_at_results_val[1] = { WASM_INIT_VAL };
+    wasm_val_vec_t get_at_results = WASM_ARRAY_VEC(get_at_results_val);
+    wasm_func_call(get_at, &get_at_args, &get_at_results);
+
+    printf("Value at 0x%04x: %d\n", mem_addr, get_at_results_val[0].of.i32);
+
+    wasm_extern_vec_delete(&exports);
+    wasm_module_delete(module);
+    wasm_instance_delete(instance);
+    wasm_store_delete(store);
+    wasm_engine_delete(engine);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory2.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory2.c
new file mode 100644
index 0000000..8091f0a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/memory2.c
@@ -0,0 +1,136 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "wasmer.h"
+
+#define own
+
+// Use the last_error API to retrieve error messages
+own char* get_wasmer_error() {
+  int error_len = wasmer_last_error_length();
+  printf("Error len: `%d`\n", error_len);
+  char *error_str = malloc(error_len);
+  wasmer_last_error_message(error_str, error_len);
+  return error_str;
+}
+
+int main(int argc, const char *argv[]) {
+  printf("Initializing...\n");
+  own wasm_engine_t* engine = wasm_engine_new();
+  own wasm_store_t* store = wasm_store_new(engine);
+
+  // =====================
+  wasm_limits_t limits1 = {
+    .min = 0,
+    .max = 0x7FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype1 = wasm_memorytype_new(&limits1);
+  own wasm_memory_t* memory1 = wasm_memory_new(store, memtype1);
+  assert(memory1 == NULL);
+  char* error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The maximum requested memory (2147483647 pages) is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype1);
+
+  // =====================
+  wasm_limits_t limits2 = {
+    .min = 15,
+    .max = 25,
+  };
+  own wasm_memorytype_t* memtype2 = wasm_memorytype_new(&limits2);
+  own wasm_memory_t* memory2 = wasm_memory_new(store, memtype2);
+  assert(memory2 != NULL);
+
+  wasm_memorytype_delete(memtype2);
+  wasm_memory_delete(memory2);
+
+  // =====================
+  wasm_limits_t limits3 = {
+    .min = 15,
+    .max = wasm_limits_max_default,
+  };
+  own wasm_memorytype_t* memtype3 = wasm_memorytype_new(&limits3);
+  own wasm_memory_t* memory3 = wasm_memory_new(store, memtype3);
+  assert(memory3 != NULL);
+  int size = wasm_memory_size(memory3);
+  printf("memory size: %d\n", size);
+
+  wasm_memorytype_delete(memtype3);
+  wasm_memory_delete(memory3);
+
+  // =====================
+  wasm_limits_t limits4 = {
+    .min = 0x7FFFFFFF,
+    .max = 0x7FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype4 = wasm_memorytype_new(&limits4);
+  own wasm_memory_t* memory4 = wasm_memory_new(store, memtype4);
+  assert(memory4 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype4);
+
+  // =====================
+  wasm_limits_t limits5 = {
+    .min = 0x7FFFFFFF,
+    .max = 0x0FFFFFFF,
+  };
+  own wasm_memorytype_t* memtype5 = wasm_memorytype_new(&limits5);
+  own wasm_memory_t* memory5 = wasm_memory_new(store, memtype5);
+  assert(memory5 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype5);
+
+  // =====================
+  wasm_limits_t limits6 = {
+    .min = 15,
+    .max = 10,
+  };
+  own wasm_memorytype_t* memtype6 = wasm_memorytype_new(&limits6);
+  own wasm_memory_t* memory6 = wasm_memory_new(store, memtype6);
+  assert(memory6 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The memory is invalid because the maximum (10 pages) is less than the minimum (15 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype6);
+
+  // =====================
+  wasm_limits_t limits7 = {
+    .min = 0x7FFFFFFF,
+    .max = 10,
+  };
+  own wasm_memorytype_t* memtype7 = wasm_memorytype_new(&limits7);
+  own wasm_memory_t* memory7 = wasm_memory_new(store, memtype7);
+  assert(memory7 == NULL);
+  error = get_wasmer_error();
+  printf("Found error string: %s\n", error);
+  // We can't validate the exact error message because it's not universal for the engines
+  // assert(0 == strcmp("The minimum requested (2147483647 pages) memory is greater than the maximum allowed memory (65536 pages)", error));
+  free(error);
+
+  wasm_memorytype_delete(memtype7);
+
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasi.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasi.c
new file mode 100644
index 0000000..3e1fb38
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasi.c
@@ -0,0 +1,192 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasmer.h"
+
+#define BUF_SIZE 128
+#define own
+
+// Use the last_error API to retrieve error messages
+void print_wasmer_error()
+{
+    int error_len = wasmer_last_error_length();
+    if (error_len > 0) {
+      printf("Error len: `%d`\n", error_len);
+      char *error_str = malloc(error_len);
+      wasmer_last_error_message(error_str, error_len);
+      printf("Error str: `%s`\n", error_str);
+    }
+}
+
+int main(int argc, const char* argv[]) {
+  #ifdef WASMER_WASI_ENABLED // If WASI is enabled
+
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  printf("Setting up WASI...\n");
+  wasi_config_t* config = wasi_config_new("example_program");
+  // TODO: error checking
+  const char* js_string = "function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));";
+  wasi_config_arg(config, "--eval");
+  wasi_config_arg(config, js_string);
+  wasi_config_capture_stdout(config);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("assets/qjs.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error initializing module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  wasi_env_t* wasi_env = wasi_env_new(store, config);
+
+  if (!wasi_env) {
+    printf("> Error building WASI env!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_vec_t imports;
+  bool get_imports_result = wasi_get_imports(store, wasi_env,module,&imports);
+
+  if (!get_imports_result) {
+    printf("> Error getting WASI imports!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  if (!wasi_env_initialize_instance(wasi_env, store, instance)) {
+    printf("> Error initializing wasi env memory!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  fprintf(stderr, "found %zu exports\n", exports.size);
+
+  wasm_func_t* run_func = wasi_get_start_function(instance);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  // Call.
+  printf("Calling export...\n");
+  printf("Evaluating \"%s\"\n", js_string);
+
+  wasm_val_vec_t args = WASM_EMPTY_VEC;
+  wasm_val_vec_t res = WASM_EMPTY_VEC;
+
+  if (wasm_func_call(run_func, &args, &res)) {
+    printf("> Error calling function!\n");
+    return 1;
+  }
+  printf("Call completed\n");
+
+  if(true) {
+
+    // NOTE: previously, this used open_memstream,
+    // which is not cross-platform
+    FILE *memory_stream = NULL;
+    memory_stream = tmpfile(); // stdio.h
+
+    if (NULL == memory_stream) {
+      printf("> Error creating a memory stream.\n");
+      return 1;
+    }
+
+    char buffer[BUF_SIZE] = { 0 };
+    size_t data_read_size = BUF_SIZE;
+
+    do {
+      data_read_size = wasi_env_read_stdout(wasi_env, buffer, BUF_SIZE);
+      if (data_read_size == -1) {
+        printf("failed to read stdout: %s\n", strerror(errno));
+        print_wasmer_error();
+        return -1;
+      }
+
+      if (data_read_size > 0) {
+        fwrite(buffer, sizeof(char), data_read_size, memory_stream);
+      }
+    } while (BUF_SIZE == data_read_size);
+
+    // print memory_stream
+    rewind(memory_stream);
+    fputs("WASI Stdout: ", stdout);
+    char buffer2[256];
+    while (!feof(memory_stream)) {
+      if (fgets(buffer2, 256, memory_stream) == NULL) break;
+      fputs(buffer2, stdout);
+    }
+    fputs("\n", stdout);
+    fclose(memory_stream);
+  }
+
+
+  wasm_extern_vec_delete(&exports);
+  wasm_extern_vec_delete(&imports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_func_delete(run_func);
+  wasi_env_delete(wasi_env);
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+
+  #endif // WASMER_WASI_ENABLED
+
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/.gitignore
new file mode 100644
index 0000000..1b04d33
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/.gitignore
@@ -0,0 +1,4 @@
+*.bat
+*.ilk
+*.pdb
+*.exe
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
new file mode 100644
index 0000000..d43a4a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/examples/wasmer-capi-examples-runner/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "wasmer-capi-examples-runner"
+version = "4.2.8"
+edition = "2021"
+license = "MIT"
+description = "wasmer-capi-examples-runner"
+
+[dependencies]
+cc = "1.0"
+target-lexicon = "0.11"
+regex = "1.6"
+walkdir = "2.3.2"
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/error.rs
new file mode 100644
index 0000000..adb9884
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/error.rs
@@ -0,0 +1,158 @@
+//! Utilities to read errors.
+//!
+//! Only one error can be registered at a time. Error are registered
+//! by Rust only, and are usually read by C or C++.
+//!
+//! Reading an error from C or C++ happens in 2 steps: Getting the
+//! error's length with [`wasmer_last_error_length`], and then reading
+//! the actual error with [`wasmer_last_error_message`].
+//!
+//! # Example
+//!
+//! ```rust
+//! # use wasmer_inline_c::assert_c;
+//! # fn main() {
+//! #    (assert_c! {
+//! # #include "tests/wasmer.h"
+//! #
+//! int main() {
+//!     // Create an invalid WebAssembly module from a WAT definition,
+//!     // it will generate an error!
+//!     wasm_byte_vec_t wat;
+//!     wasmer_byte_vec_new_from_string(&wat, "(foobar)");
+//!     wasm_byte_vec_t wasm;
+//!     wat2wasm(&wat, &wasm);
+//!
+//!     int error_length = wasmer_last_error_length();
+//!
+//!     // There is an error!
+//!     assert(error_length > 0);
+//!
+//!     char *error_message = malloc(error_length);
+//!     wasmer_last_error_message(error_message, error_length);
+//!     printf("Error message: %s\n", error_message);
+//!
+//!     // Side note: The error has now been cleared on the Rust side!
+//!     assert(wasmer_last_error_length() == 0);
+//!
+//!     // Free everything.
+//!     free(error_message);
+//!     wasm_byte_vec_delete(&wasm);
+//!     wasm_byte_vec_delete(&wat);
+//!
+//!     return 0;
+//! }
+//! #    })
+//! #    .success();
+//! # }
+//! ```
+
+use libc::{c_char, c_int};
+use std::cell::RefCell;
+use std::fmt::Display;
+use std::ptr::{self, NonNull};
+use std::slice;
+
+thread_local! {
+    static LAST_ERROR: RefCell<Option<String>> = RefCell::new(None);
+}
+
+/// Rust function to register a new error.
+///
+/// # Example
+///
+/// ```rust,no_run
+/// # use wasmer::error::update_last_error;
+///
+/// update_last_error("Hello, World!");
+/// ```
+pub fn update_last_error<E: Display>(err: E) {
+    LAST_ERROR.with(|prev| {
+        *prev.borrow_mut() = Some(err.to_string());
+    });
+}
+
+/// Retrieve the most recent error, clearing it in the process.
+pub(crate) fn take_last_error() -> Option<String> {
+    LAST_ERROR.with(|prev| prev.borrow_mut().take())
+}
+
+/// Gets the length in bytes of the last error if any, zero otherwise. This
+/// includes th NUL terminator byte.
+///
+/// This can be used to dynamically allocate a buffer with the correct number of
+/// bytes needed to store a message.
+///
+/// # Example
+///
+/// See this module's documentation to get a complete example.
+// TODO(Amanieu): This should use size_t
+#[no_mangle]
+pub extern "C" fn wasmer_last_error_length() -> c_int {
+    LAST_ERROR.with(|prev| match *prev.borrow() {
+        Some(ref err) => err.len() as c_int + 1,
+        None => 0,
+    })
+}
+
+/// Gets the last error message if any into the provided buffer
+/// `buffer` up to the given `length`.
+///
+/// The `length` parameter must be large enough to store the last
+/// error message. Ideally, the value should come from
+/// [`wasmer_last_error_length`].
+///
+/// The function returns the length of the string in bytes, `-1` if an
+/// error occurs. Potential errors are:
+///
+///  * The `buffer` is a null pointer,
+///  * The `buffer` is too small to hold the error message.
+///
+/// Note: The error message always has a trailing NUL character.
+///
+/// Important note: If the provided `buffer` is non-null, once this
+/// function has been called, regardless whether it fails or succeeds,
+/// the error is cleared.
+///
+/// # Example
+///
+/// See this module's documentation to get a complete example.
+// TODO(Amanieu): This should use size_t
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_last_error_message(
+    buffer: Option<NonNull<c_char>>,
+    length: c_int,
+) -> c_int {
+    let buffer = if let Some(buffer_inner) = buffer {
+        buffer_inner
+    } else {
+        // buffer pointer is null
+        return -1;
+    };
+
+    let error_message = match take_last_error() {
+        Some(err) => err,
+        None => return 0,
+    };
+
+    let length = length as usize;
+
+    if error_message.len() >= length {
+        // buffer is too small to hold the error message
+        return -1;
+    }
+
+    let buffer = slice::from_raw_parts_mut(buffer.cast::<u8>().as_ptr(), length);
+
+    ptr::copy_nonoverlapping(
+        error_message.as_ptr(),
+        buffer.as_mut_ptr(),
+        error_message.len(),
+    );
+
+    // Add a trailing null so people using the string as a `char *` don't
+    // accidentally read into garbage.
+    buffer[error_message.len()] = 0;
+
+    error_message.len() as c_int + 1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/lib.rs
new file mode 100644
index 0000000..5b59ab7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/lib.rs
@@ -0,0 +1,32 @@
+//! Wasmer C API.
+//!
+//! [Wasmer](https://github.com/wasmerio/wasmer) is the leading
+//! WebAssembly runtime. Wasmer is written in Rust; this crate
+//! exposes its C and C++ bindings.
+//!
+//! This crate provides an API that follows the [official WebAssembly
+//! C API](https://github.com/WebAssembly/wasm-c-api). This standard
+//! can be characterized as a _living standard_. The API is not yet
+//! stable, even though it shows maturity over time. It is described
+//! by the `wasm.h` C header file. However, this crate API provides
+//! some extensions, like the `wasi_*` or `wasmer_*` types and
+//! functions, which aren't yet defined by the standard. The
+//! `wasmer.h` header file already depends on the `wasm.h`
+//! file. A copy lands in this repository for the sake of simplicity.
+
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![deny(
+    dead_code,
+    unused_imports,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+// Because this crate exposes a lot of C APIs which are unsafe by definition,
+// we allow unsafe without explicit safety documentation for each of them.
+#![allow(clippy::missing_safety_doc)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub mod error;
+pub mod wasm_c_api;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/DEVELOPMENT.md b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/DEVELOPMENT.md
new file mode 100644
index 0000000..048a82c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/DEVELOPMENT.md
@@ -0,0 +1,137 @@
+# Development Notes
+
+## Ownerships
+
+The [`wasm.h`] header thankfully defines the [`own`] “annotation”. It
+specifies _who_ owns _what_. For example, in the following code:
+
+```c
+WASM_API_EXTERN own wasm_importtype_t* wasm_importtype_new(
+  own wasm_name_t* module, own wasm_name_t* name, own wasm_externtype_t*);
+```
+
+We must read that `wasm_importtype_new` takes the ownership of all its
+three arguments. This function is then responsible to free those
+data. We must also read that the returned value is owned by the caller
+of this function.
+
+### Rust Pattern
+
+This ownership property translates well in Rust. We have decided to
+use the `Box<T>` type to represent an owned pointer. `Box<T>` drops
+its content when it's dropped.
+
+However, vectors (such as `wasm_name_t`) are a special case: for those, `own`
+means that the ownership of contents of the vector are transfered, not the
+allocation of the vector type itself. Hence these are represented using
+`&mut T` instead.
+
+Consequently, apart from other patterns, the code above can be written
+as follows in Rust:
+
+```rust
+#[no_mangle]
+pub extern "C" fn wasm_importtype_new(
+    module: &mut wasm_name_t,
+    name: &mut wasm_name_t,
+    extern_type: Box<wasm_externtype_t>,
+) -> Box<wasm_importtype_t> {
+    …
+}
+```
+
+By reading the code, it is clear that `wasm_importtype_new` takes the
+ownership for `module`, `name`, and `extern_type`, and that the result
+is owned by the caller.
+
+## `const *T`
+
+A constant pointer can be interpreted in C as an immutable
+pointer. Without the [`own`] annotation, it means the ownership is not
+transfered anywhere (see [the Ownerships Section][#ownerships]).
+
+### Rust Pattern
+
+`const *T` translates to Rust as `&T`, it's a reference.
+
+## Null Pointer
+
+The [`wasm.h`] header does not say anything about null pointer. The
+behavior we agreed on in that passing a null pointer where it is not
+expected (i.e. everywhere) will make the function to return null too
+with no error.
+
+### Rust Pattern
+
+A nice type property in Rust is that it is possible to write
+`Option<NonNull<T>>` to nicely handle null pointer of kind `T`. For an
+argument, it translates as follows:
+
+* When the given pointer is null, the argument holds `None`,
+* When the given pointer is not null, the arguments holds
+  `Some(NonNull<T>)`.
+
+Considering [the Ownerships Section][#ownerships], if the pointer is
+owned, we can also write `Option<Box<T>>`. This pattern is largely
+used in this codebase to represent a “nullable” owned
+pointer. Consequently, a code like:
+
+```c
+WASM_API_EXTERN own wasm_importtype_t* wasm_importtype_new(
+  own wasm_name_t* module, own wasm_name_t* name, own wasm_externtype_t*);
+```
+
+translates into Rust as:
+
+```rust
+#[no_mangle]
+pub extern "C" fn wasm_importtype_new(
+    module: Option<&mut wasm_name_t>,
+    name: Option<&mut wasm_name_t>,
+    extern_type: Option<Box<wasm_externtype_t>>,
+) -> Option<Box<wasm_importtype_t>> {
+    Some(Box::new(wasm_importtype_t {
+        name: name?.take().into(),
+        module: module?.take().into(),
+        extern_type: extern_type?,
+    }))
+}
+```
+
+What `name?` (and others) means? It is basically [the `Try` trait
+implemented for
+`Option`](https://doc.rust-lang.org/std/ops/trait.Try.html#impl-Try):
+It returns `None` if the value is `None`, otherwise it unwraps the
+`Option`.
+
+Because the function returns `Option<Box<T>>`, `None` represents a
+null pointer.
+
+Considering [the `const *T` Section][#const-t], if the pointer is not
+owned, we can either write `Option<NonNull<T>>` or `Option<&T>`. It
+has been decided to use the second pattern in all the codebase.
+
+## Destructors
+
+The [`wasm.h`] defines `wasm_*_delete` functions. It represents destructors.
+
+### Rust Pattern
+
+The destructors in Rust translate as follow:
+
+```rust
+#[no_mangle]
+pub unsafe extern "C" fn wasm_*_delete(_: Option<Box<wasm_*_t>>) {}
+```
+
+`Box<T>` will take the ownership of the value. It means that Rust will
+drop it automatically as soon as it goes out of the
+scope. Consequently, the “C destructors” really are the “Rust
+destructors”.
+
+The `Option` is here to handle the situation where a null pointer is
+passed to the destructor.
+
+
+[`own`]: https://github.com/wasmerio/wasmer/blob/f548f268f2335693b97ad7ca08af72c320daf59a/lib/c-api/tests/wasm_c_api/wasm-c-api/include/wasm.h#L46-L65
+[`wasm.h`]: https://github.com/wasmerio/wasmer/blob/f548f268f2335693b97ad7ca08af72c320daf59a/lib/c-api/tests/wasm_c_api/wasm-c-api/include/wasm.h
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/engine.rs
new file mode 100644
index 0000000..f5705d8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/engine.rs
@@ -0,0 +1,486 @@
+#[cfg(feature = "compiler")]
+pub use super::unstable::engine::wasmer_is_compiler_available;
+pub use super::unstable::engine::{wasm_config_set_features, wasm_config_set_target};
+use super::unstable::features::wasmer_features_t;
+#[cfg(feature = "middlewares")]
+pub use super::unstable::middlewares::wasm_config_push_middleware;
+#[cfg(feature = "middlewares")]
+use super::unstable::middlewares::wasmer_middleware_t;
+use super::unstable::target_lexicon::wasmer_target_t;
+use crate::error::update_last_error;
+use cfg_if::cfg_if;
+#[cfg(not(any(feature = "compiler", feature = "compiler-headless")))]
+use wasmer_api::Engine;
+#[cfg(any(feature = "compiler", feature = "compiler-headless"))]
+use wasmer_compiler::{Engine, EngineBuilder};
+
+/// Kind of compilers that can be used by the engines.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+#[cfg(feature = "compiler")]
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub enum wasmer_compiler_t {
+    /// Variant to represent the Cranelift compiler. See the
+    /// [`wasmer_compiler_cranelift`] Rust crate.
+    CRANELIFT = 0,
+
+    /// Variant to represent the LLVM compiler. See the
+    /// [`wasmer_compiler_llvm`] Rust crate.
+    LLVM = 1,
+
+    /// Variant to represent the Singlepass compiler. See the
+    /// [`wasmer_compiler_singlepass`] Rust crate.
+    SINGLEPASS = 2,
+}
+
+#[cfg(feature = "compiler")]
+impl Default for wasmer_compiler_t {
+    fn default() -> Self {
+        cfg_if! {
+            if #[cfg(feature = "cranelift")] {
+                Self::CRANELIFT
+            } else if #[cfg(feature = "llvm")] {
+                Self::LLVM
+            } else if #[cfg(feature = "singlepass")] {
+                Self::SINGLEPASS
+            } else {
+                compile_error!("Please enable one of the compiler backends")
+            }
+        }
+    }
+}
+
+/// Kind of engines that can be used by the store.
+///
+/// This is a Wasmer-specific type with Wasmer-specific functions for
+/// manipulating it.
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum wasmer_engine_t {
+    /// Variant to represent the Universal engine. See the
+    /// [`wasmer_engine_universal`] Rust crate.
+    UNIVERSAL = 0,
+}
+
+impl Default for wasmer_engine_t {
+    fn default() -> Self {
+        Self::UNIVERSAL
+    }
+}
+
+/// A configuration holds the compiler and the engine used by the store.
+///
+/// cbindgen:ignore
+#[derive(Debug, Default)]
+#[repr(C)]
+pub struct wasm_config_t {
+    engine: wasmer_engine_t,
+    #[cfg(feature = "compiler")]
+    compiler: wasmer_compiler_t,
+    #[cfg(feature = "middlewares")]
+    pub(super) middlewares: Vec<wasmer_middleware_t>,
+    pub(super) nan_canonicalization: bool,
+    pub(super) features: Option<Box<wasmer_features_t>>,
+    pub(super) target: Option<Box<wasmer_target_t>>,
+}
+
+/// Create a new default Wasmer configuration.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_config_new() -> Box<wasm_config_t> {
+    Box::<wasm_config_t>::default()
+}
+
+/// Delete a Wasmer config object.
+///
+/// This function does not need to be called if `wasm_engine_new_with_config` or
+/// another function that takes ownership of the `wasm_config_t` is called.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Delete the configuration
+///     wasm_config_delete(config);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_config_delete(_config: Option<Box<wasm_config_t>>) {}
+
+/// Updates the configuration to specify a particular compiler to use.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Use the Cranelift compiler, if available.
+///     if (wasmer_is_compiler_available(CRANELIFT)) {
+///         wasm_config_set_compiler(config, CRANELIFT);
+///     }
+///     // Or maybe LLVM?
+///     else if (wasmer_is_compiler_available(LLVM)) {
+///         wasm_config_set_compiler(config, LLVM);
+///     }
+///     // Or maybe Singlepass?
+///     else if (wasmer_is_compiler_available(SINGLEPASS)) {
+///         wasm_config_set_compiler(config, SINGLEPASS);
+///     }
+///     // OK, let's run with no particular compiler.
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[cfg(feature = "compiler")]
+#[no_mangle]
+pub extern "C" fn wasm_config_set_compiler(
+    config: &mut wasm_config_t,
+    compiler: wasmer_compiler_t,
+) {
+    config.compiler = compiler;
+}
+
+/// Updates the configuration to specify a particular engine to use.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_set_engine(config: &mut wasm_config_t, engine: wasmer_engine_t) {
+    config.engine = engine;
+}
+
+/// An engine is used by the store to drive the compilation and the
+/// execution of a WebAssembly module.
+///
+/// cbindgen:ignore
+#[repr(C)]
+pub struct wasm_engine_t {
+    pub(crate) inner: Engine,
+}
+
+#[cfg(feature = "compiler")]
+use wasmer_api::CompilerConfig;
+
+#[cfg(all(feature = "compiler", any(feature = "compiler", feature = "dylib")))]
+fn get_default_compiler_config() -> Box<dyn CompilerConfig> {
+    cfg_if! {
+        if #[cfg(feature = "cranelift")] {
+            Box::<wasmer_compiler_cranelift::Cranelift>::default()
+        } else if #[cfg(feature = "llvm")] {
+            Box::<wasmer_compiler_llvm::LLVM>::default()
+        } else if #[cfg(feature = "singlepass")] {
+            Box::<wasmer_compiler_singlepass::Singlepass>::default()
+        } else {
+            compile_error!("Please enable one of the compiler backends")
+        }
+    }
+}
+
+cfg_if! {
+    if #[cfg(feature = "compiler")] {
+        /// Creates a new Universal engine with the default compiler.
+        ///
+        /// # Example
+        ///
+        /// See [`wasm_engine_delete`].
+        ///
+        /// cbindgen:ignore
+        #[no_mangle]
+        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
+            let compiler_config: Box<dyn CompilerConfig> = get_default_compiler_config();
+            let engine: Engine = EngineBuilder::new(compiler_config).engine();
+            Box::new(wasm_engine_t { inner: engine })
+        }
+    } else if #[cfg(feature = "compiler-headless")] {
+        /// Creates a new headless Universal engine.
+        ///
+        /// # Example
+        ///
+        /// See [`wasm_engine_delete`].
+        ///
+        /// cbindgen:ignore
+        #[no_mangle]
+        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
+            let engine: Engine = EngineBuilder::headless().engine();
+            Box::new(wasm_engine_t { inner: engine })
+        }
+    } else if #[cfg(feature = "jsc")] {
+        /// Creates the JavascriptCore Engine.
+        ///
+        /// # Example
+        ///
+        /// See [`wasm_engine_delete`].
+        ///
+        /// cbindgen:ignore
+        #[no_mangle]
+        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
+            let engine: Engine = Engine::default();
+            Box::new(wasm_engine_t { inner: engine })
+        }
+    } else {
+        /// Creates a new unknown engine, i.e. it will panic with an error message.
+        ///
+        /// # Example
+        ///
+        /// See [`wasm_engine_delete`].
+        ///
+        /// cbindgen:ignore
+        #[no_mangle]
+        pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
+            unimplemented!("No engine attached; You might want to recompile `wasmer_c_api` with for example `--feature compiler`");
+        }
+    }
+}
+
+/// Deletes an engine.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create a default engine.
+///     wasm_engine_t* engine = wasm_engine_new();
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub unsafe extern "C" fn wasm_engine_delete(_engine: Option<Box<wasm_engine_t>>) {}
+
+/// Creates an engine with a particular configuration.
+///
+/// # Example
+///
+/// See [`wasm_config_new`].
+///
+/// cbindgen:ignore
+#[no_mangle]
+pub extern "C" fn wasm_engine_new_with_config(
+    config: Option<Box<wasm_config_t>>,
+) -> Option<Box<wasm_engine_t>> {
+    #[allow(dead_code)]
+    fn return_with_error(msg: &str) -> Option<Box<wasm_engine_t>> {
+        update_last_error(msg);
+        None
+    }
+
+    #[allow(unused)]
+    let config = config?;
+    #[cfg(not(any(feature = "compiler", feature = "compiler-headless")))]
+    return return_with_error("Wasmer has not been compiled with the `compiler` feature.");
+    cfg_if! {
+        if #[cfg(feature = "compiler")] {
+            #[allow(unused_mut)]
+            let mut compiler_config: Box<dyn CompilerConfig> = match config.compiler {
+                wasmer_compiler_t::CRANELIFT => {
+                    cfg_if! {
+                        if #[cfg(feature = "cranelift")] {
+                            Box::<wasmer_compiler_cranelift::Cranelift>::default()
+                        } else {
+                            return return_with_error("Wasmer has not been compiled with the `cranelift` feature.");
+                        }
+                    }
+                },
+                wasmer_compiler_t::LLVM => {
+                    cfg_if! {
+                        if #[cfg(feature = "llvm")] {
+                            Box::<wasmer_compiler_llvm::LLVM>::default()
+                        } else {
+                            return return_with_error("Wasmer has not been compiled with the `llvm` feature.");
+                        }
+                    }
+                },
+                wasmer_compiler_t::SINGLEPASS => {
+                    cfg_if! {
+                        if #[cfg(feature = "singlepass")] {
+                            Box::<wasmer_compiler_singlepass::Singlepass>::default()
+                        } else {
+                            return return_with_error("Wasmer has not been compiled with the `singlepass` feature.");
+                        }
+                    }
+                },
+            };
+
+            #[cfg(feature = "middlewares")]
+            for middleware in config.middlewares {
+                compiler_config.push_middleware(middleware.inner);
+            }
+
+            if config.nan_canonicalization {
+                compiler_config.canonicalize_nans(true);
+            }
+
+            let inner: Engine =
+                         {
+                            let mut builder = EngineBuilder::new(compiler_config);
+
+                            if let Some(target) = config.target {
+                                builder = builder.set_target(Some(target.inner));
+                            }
+
+                            if let Some(features) = config.features {
+                                builder = builder.set_features(Some(features.inner));
+                            }
+
+                            builder.engine()
+                        };
+            Some(Box::new(wasm_engine_t { inner }))
+        } else {
+            #[cfg(feature = "compiler-headless")]
+            let inner: Engine =
+                     {
+                            let mut builder = EngineBuilder::headless();
+
+                            if let Some(target) = config.target {
+                                builder = builder.set_target(Some(target.inner));
+                            }
+
+                            if let Some(features) = config.features {
+                                builder = builder.set_features(Some(features.inner));
+                            }
+
+                            builder.engine()
+                    };
+            #[cfg(not(any(feature = "compiler-headless", feature="compiler")))]
+            let inner: Engine = Engine::default();
+
+            Some(Box::new(wasm_engine_t { inner }))
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_engine_new() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                assert(engine);
+
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/function.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/function.rs
new file mode 100644
index 0000000..e72c277
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/function.rs
@@ -0,0 +1,256 @@
+use super::super::store::wasm_store_t;
+use super::super::trap::wasm_trap_t;
+use super::super::types::{wasm_functype_t, wasm_valkind_enum};
+use super::super::value::{wasm_val_inner, wasm_val_t, wasm_val_vec_t};
+use super::wasm_extern_t;
+use crate::wasm_c_api::function_env::FunctionCEnv;
+use libc::c_void;
+use std::convert::TryInto;
+use std::mem::MaybeUninit;
+use std::sync::{Arc, Mutex};
+use wasmer_api::{Extern, Function, FunctionEnv, FunctionEnvMut, RuntimeError, Value};
+
+#[derive(Clone)]
+#[allow(non_camel_case_types)]
+#[repr(C)]
+pub struct wasm_func_t {
+    pub(crate) extern_: wasm_extern_t,
+}
+
+impl wasm_func_t {
+    pub(crate) fn try_from(e: &wasm_extern_t) -> Option<&wasm_func_t> {
+        match &e.inner {
+            Extern::Function(_) => Some(unsafe { &*(e as *const _ as *const _) }),
+            _ => None,
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+pub type wasm_func_callback_t = unsafe extern "C" fn(
+    args: &wasm_val_vec_t,
+    results: &mut wasm_val_vec_t,
+) -> Option<Box<wasm_trap_t>>;
+
+#[allow(non_camel_case_types)]
+pub type wasm_func_callback_with_env_t = unsafe extern "C" fn(
+    env: *mut c_void,
+    args: &wasm_val_vec_t,
+    results: &mut wasm_val_vec_t,
+) -> Option<Box<wasm_trap_t>>;
+
+#[allow(non_camel_case_types)]
+pub type wasm_env_finalizer_t = unsafe extern "C" fn(*mut c_void);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_new(
+    store: Option<&mut wasm_store_t>,
+    function_type: Option<&wasm_functype_t>,
+    callback: Option<wasm_func_callback_t>,
+) -> Option<Box<wasm_func_t>> {
+    let function_type = function_type?;
+    let callback = callback?;
+    let store = store?;
+    let mut store_mut = store.inner.store_mut();
+
+    let func_sig = &function_type.inner().function_type;
+    let num_rets = func_sig.results().len();
+    let inner_callback = move |mut _env: FunctionEnvMut<'_, FunctionCEnv>,
+                               args: &[Value]|
+          -> Result<Vec<Value>, RuntimeError> {
+        let processed_args: wasm_val_vec_t = args
+            .iter()
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<wasm_val_t>, _>>()
+            .expect("Argument conversion failed")
+            .into();
+
+        let mut results: wasm_val_vec_t = vec![
+            wasm_val_t {
+                kind: wasm_valkind_enum::WASM_I64 as _,
+                of: wasm_val_inner { int64_t: 0 },
+            };
+            num_rets
+        ]
+        .into();
+
+        let trap = callback(&processed_args, &mut results);
+
+        if let Some(trap) = trap {
+            return Err(trap.inner);
+        }
+
+        let processed_results = results
+            .take()
+            .into_iter()
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<Value>, _>>()
+            .expect("Result conversion failed");
+
+        Ok(processed_results)
+    };
+    let env = FunctionEnv::new(&mut store_mut, FunctionCEnv::default());
+    let function = Function::new_with_env(&mut store_mut, &env, func_sig, inner_callback);
+    Some(Box::new(wasm_func_t {
+        extern_: wasm_extern_t::new(store.inner.clone(), function.into()),
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_new_with_env(
+    store: Option<&mut wasm_store_t>,
+    function_type: Option<&wasm_functype_t>,
+    callback: Option<wasm_func_callback_with_env_t>,
+    env: *mut c_void,
+    env_finalizer: Option<wasm_env_finalizer_t>,
+) -> Option<Box<wasm_func_t>> {
+    let function_type = function_type?;
+    let callback = callback?;
+    let store = store?;
+    let mut store_mut = store.inner.store_mut();
+
+    let func_sig = &function_type.inner().function_type;
+    let num_rets = func_sig.results().len();
+
+    #[derive(Clone)]
+    #[repr(C)]
+    struct WrapperEnv {
+        env: FunctionCEnv,
+        env_finalizer: Arc<Mutex<Option<wasm_env_finalizer_t>>>,
+    }
+
+    // Only relevant when using multiple threads in the C API;
+    // Synchronization will be done via the C API / on the C side.
+    unsafe impl Send for WrapperEnv {}
+    unsafe impl Sync for WrapperEnv {}
+
+    impl Drop for WrapperEnv {
+        fn drop(&mut self) {
+            if let Ok(mut guard) = self.env_finalizer.lock() {
+                if Arc::strong_count(&self.env_finalizer) == 1 {
+                    if let Some(env_finalizer) = guard.take() {
+                        unsafe { (env_finalizer)(self.env.as_ptr()) };
+                    }
+                }
+            }
+        }
+    }
+    let inner_callback = move |env: FunctionEnvMut<'_, WrapperEnv>,
+                               args: &[Value]|
+          -> Result<Vec<Value>, RuntimeError> {
+        let processed_args: wasm_val_vec_t = args
+            .iter()
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<wasm_val_t>, _>>()
+            .expect("Argument conversion failed")
+            .into();
+
+        let mut results: wasm_val_vec_t = vec![
+            wasm_val_t {
+                kind: wasm_valkind_enum::WASM_I64 as _,
+                of: wasm_val_inner { int64_t: 0 },
+            };
+            num_rets
+        ]
+        .into();
+
+        let trap = callback(env.data().env.as_ptr(), &processed_args, &mut results);
+
+        if let Some(trap) = trap {
+            return Err(trap.inner);
+        }
+
+        let processed_results = results
+            .take()
+            .into_iter()
+            .map(TryInto::try_into)
+            .collect::<Result<Vec<Value>, _>>()
+            .expect("Result conversion failed");
+
+        Ok(processed_results)
+    };
+    let env = FunctionEnv::new(
+        &mut store_mut,
+        WrapperEnv {
+            env: FunctionCEnv::new(c_try!(
+                std::ptr::NonNull::new(env),
+                "Function environment cannot be a null pointer."
+            )),
+            env_finalizer: Arc::new(Mutex::new(env_finalizer)),
+        },
+    );
+    let function = Function::new_with_env(&mut store_mut, &env, func_sig, inner_callback);
+    Some(Box::new(wasm_func_t {
+        extern_: wasm_extern_t::new(store.inner.clone(), function.into()),
+    }))
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_func_copy(func: &wasm_func_t) -> Box<wasm_func_t> {
+    Box::new(func.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_delete(_func: Option<Box<wasm_func_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_call(
+    func: Option<&mut wasm_func_t>,
+    args: Option<&wasm_val_vec_t>,
+    results: &mut wasm_val_vec_t,
+) -> Option<Box<wasm_trap_t>> {
+    let func = func?;
+    let args = args?;
+    let mut store = func.extern_.store.clone();
+    let mut store_mut = store.store_mut();
+    let params = args
+        .as_slice()
+        .iter()
+        .cloned()
+        .map(TryInto::try_into)
+        .collect::<Result<Vec<Value>, _>>()
+        .expect("Arguments conversion failed");
+
+    match func.extern_.function().call(&mut store_mut, &params) {
+        Ok(wasm_results) => {
+            for (slot, val) in results
+                .as_uninit_slice()
+                .iter_mut()
+                .zip(wasm_results.iter())
+            {
+                *slot = MaybeUninit::new(val.try_into().expect("Results conversion failed"));
+            }
+
+            None
+        }
+        Err(e) => Some(Box::new(e.into())),
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_param_arity(func: &wasm_func_t) -> usize {
+    func.extern_
+        .function()
+        .ty(&func.extern_.store.store())
+        .params()
+        .len()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_result_arity(func: &wasm_func_t) -> usize {
+    func.extern_
+        .function()
+        .ty(&func.extern_.store.store())
+        .results()
+        .len()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_func_type(
+    func: Option<&wasm_func_t>,
+) -> Option<Box<wasm_functype_t>> {
+    let func = func?;
+    Some(Box::new(wasm_functype_t::new(
+        func.extern_.function().ty(&func.extern_.store.store()),
+    )))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/global.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/global.rs
new file mode 100644
index 0000000..1c1519d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/global.rs
@@ -0,0 +1,178 @@
+use super::super::store::wasm_store_t;
+use super::super::types::wasm_globaltype_t;
+use super::super::value::wasm_val_t;
+use super::wasm_extern_t;
+use std::convert::TryInto;
+use wasmer_api::{Extern, Global, Value};
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_global_t {
+    pub(crate) extern_: wasm_extern_t,
+}
+
+impl wasm_global_t {
+    pub(crate) fn try_from(e: &wasm_extern_t) -> Option<&wasm_global_t> {
+        match &e.inner {
+            Extern::Global(_) => Some(unsafe { &*(e as *const _ as *const _) }),
+            _ => None,
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_new(
+    store: Option<&mut wasm_store_t>,
+    global_type: Option<&wasm_globaltype_t>,
+    val: Option<&wasm_val_t>,
+) -> Option<Box<wasm_global_t>> {
+    let global_type = global_type?;
+    let store = store?;
+    let mut store_mut = store.inner.store_mut();
+    let val = val?;
+
+    let global_type = &global_type.inner().global_type;
+    let wasm_val = val.try_into().ok()?;
+    let global = if global_type.mutability.is_mutable() {
+        Global::new_mut(&mut store_mut, wasm_val)
+    } else {
+        Global::new(&mut store_mut, wasm_val)
+    };
+    Some(Box::new(wasm_global_t {
+        extern_: wasm_extern_t::new(store.inner.clone(), global.into()),
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_delete(_global: Option<Box<wasm_global_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_copy(global: &wasm_global_t) -> Box<wasm_global_t> {
+    // do shallow copy
+    Box::new(global.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_get(
+    global: &mut wasm_global_t,
+    // own
+    out: &mut wasm_val_t,
+) {
+    let value = global
+        .extern_
+        .global()
+        .get(&mut global.extern_.store.store_mut());
+    *out = value.try_into().unwrap();
+}
+
+/// Note: This function returns nothing by design but it can raise an
+/// error if setting a new value fails.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_set(global: &mut wasm_global_t, val: &wasm_val_t) {
+    let value: Value = val.try_into().unwrap();
+    c_try!(global
+        .extern_
+        .global()
+        .set(&mut global.extern_.store.store_mut(), value); otherwise ());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_same(
+    wasm_global1: &wasm_global_t,
+    wasm_global2: &wasm_global_t,
+) -> bool {
+    wasm_global1.extern_.global() == wasm_global2.extern_.global()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_global_type(
+    global: Option<&wasm_global_t>,
+) -> Option<Box<wasm_globaltype_t>> {
+    let global = global?;
+    Some(Box::new(wasm_globaltype_t::new(
+        global.extern_.global().ty(&global.extern_.store.store()),
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_set_host_global_immutable() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_val_t forty_two = WASM_F32_VAL(42);
+                wasm_val_t forty_three = WASM_F32_VAL(43);
+
+                wasm_valtype_t* valtype = wasm_valtype_new_i32();
+                wasm_globaltype_t* global_type = wasm_globaltype_new(valtype, WASM_CONST);
+                wasm_global_t* global = wasm_global_new(store, global_type, &forty_two);
+
+                wasm_globaltype_delete(global_type);
+
+                wasm_global_set(global, &forty_three);
+
+                assert(wasmer_last_error_length() > 0);
+
+                wasm_global_delete(global);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_set_guest_global_immutable() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module (global $global (export \"global\") f32 (f32.const 1)))");
+                wasm_byte_vec_t wasm_bytes;
+                wat2wasm(&wat, &wasm_bytes);
+                wasm_module_t* module = wasm_module_new(store, &wasm_bytes);
+                wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+                wasm_instance_t* instance = wasm_instance_new(store, module, &import_object, NULL);
+
+                wasm_extern_vec_t exports;
+                wasm_instance_exports(instance, &exports);
+                wasm_global_t* global = wasm_extern_as_global(exports.data[0]);
+
+                wasm_val_t forty_two = WASM_F32_VAL(42);
+                wasm_global_set(global, &forty_two);
+
+                printf("%d", wasmer_last_error_length());
+                assert(wasmer_last_error_length() > 0);
+
+                wasm_instance_delete(instance);
+                wasm_byte_vec_delete(&wasm_bytes);
+                wasm_byte_vec_delete(&wat);
+                wasm_extern_vec_delete(&exports);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/memory.rs
new file mode 100644
index 0000000..a919ec9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/memory.rs
@@ -0,0 +1,104 @@
+use super::super::types::wasm_memorytype_t;
+use super::{super::store::wasm_store_t, wasm_extern_t};
+use wasmer_api::{Extern, Memory, Pages};
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_memory_t {
+    pub(crate) extern_: wasm_extern_t,
+}
+
+impl wasm_memory_t {
+    pub(crate) fn try_from(e: &wasm_extern_t) -> Option<&wasm_memory_t> {
+        match &e.inner {
+            Extern::Memory(_) => Some(unsafe { &*(e as *const _ as *const _) }),
+            _ => None,
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_new(
+    store: Option<&mut wasm_store_t>,
+    memory_type: Option<&wasm_memorytype_t>,
+) -> Option<Box<wasm_memory_t>> {
+    let memory_type = memory_type?;
+    let store = store?;
+    let mut store_mut = store.inner.store_mut();
+    let memory_type = memory_type.inner().memory_type;
+    let memory = c_try!(Memory::new(&mut store_mut, memory_type));
+    Some(Box::new(wasm_memory_t {
+        extern_: wasm_extern_t::new(store.inner.clone(), memory.into()),
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_delete(_memory: Option<Box<wasm_memory_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_copy(memory: &wasm_memory_t) -> Box<wasm_memory_t> {
+    // do shallow copy
+    Box::new(memory.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_same(
+    wasm_memory1: &wasm_memory_t,
+    wasm_memory2: &wasm_memory_t,
+) -> bool {
+    wasm_memory1.extern_.memory() == wasm_memory2.extern_.memory()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_type(
+    memory: Option<&wasm_memory_t>,
+) -> Option<Box<wasm_memorytype_t>> {
+    let memory = memory?;
+    Some(Box::new(wasm_memorytype_t::new(
+        memory.extern_.memory().ty(&memory.extern_.store.store()),
+    )))
+}
+
+// get a raw pointer into bytes
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_data(memory: &mut wasm_memory_t) -> *mut u8 {
+    memory
+        .extern_
+        .memory()
+        .view(&memory.extern_.store.store())
+        .data_ptr()
+}
+
+// size in bytes
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_data_size(memory: &wasm_memory_t) -> usize {
+    memory
+        .extern_
+        .memory()
+        .view(&memory.extern_.store.store())
+        .size()
+        .bytes()
+        .0
+}
+
+// size in pages
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_size(memory: &wasm_memory_t) -> u32 {
+    memory
+        .extern_
+        .memory()
+        .view(&memory.extern_.store.store())
+        .size()
+        .0 as _
+}
+
+// delta is in pages
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memory_grow(memory: &mut wasm_memory_t, delta: u32) -> bool {
+    memory
+        .extern_
+        .memory()
+        .grow(&mut memory.extern_.store.store_mut(), Pages(delta))
+        .is_ok()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/mod.rs
new file mode 100644
index 0000000..a6a2e4e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/mod.rs
@@ -0,0 +1,193 @@
+mod function;
+mod global;
+mod memory;
+mod table;
+
+use super::store::StoreRef;
+// use super::types::{wasm_externkind_enum, wasm_externkind_t};
+pub use function::*;
+pub use global::*;
+pub use memory::*;
+pub use table::*;
+use wasmer_api::{Extern, ExternType, Function, Global, Memory, Table};
+
+#[allow(non_camel_case_types)]
+#[derive(Clone)]
+pub struct wasm_extern_t {
+    pub(crate) inner: Extern,
+    pub(crate) store: StoreRef,
+}
+
+impl wasm_extern_t {
+    pub(crate) fn new(store: StoreRef, inner: Extern) -> Self {
+        Self { inner, store }
+    }
+
+    pub(crate) fn global(&self) -> Global {
+        match &self.inner {
+            Extern::Global(g) => g.clone(),
+            _ => unsafe { std::hint::unreachable_unchecked() },
+        }
+    }
+
+    pub(crate) fn function(&self) -> Function {
+        match &self.inner {
+            Extern::Function(f) => f.clone(),
+            _ => unsafe { std::hint::unreachable_unchecked() },
+        }
+    }
+
+    pub(crate) fn table(&self) -> Table {
+        match &self.inner {
+            Extern::Table(t) => t.clone(),
+            _ => unsafe { std::hint::unreachable_unchecked() },
+        }
+    }
+
+    pub(crate) fn memory(&self) -> Memory {
+        match &self.inner {
+            Extern::Memory(m) => m.clone(),
+            _ => unsafe { std::hint::unreachable_unchecked() },
+        }
+    }
+}
+
+// #[no_mangle]
+// pub extern "C" fn wasm_extern_kind(e: &wasm_extern_t) -> wasm_externkind_t {
+//     (match e.inner {
+//         Extern::Function(_) => wasm_externkind_enum::WASM_EXTERN_FUNC,
+//         Extern::Table(_) => wasm_externkind_enum::WASM_EXTERN_TABLE,
+//         Extern::Global(_) => wasm_externkind_enum::WASM_EXTERN_GLOBAL,
+//         Extern::Memory(_) => wasm_externkind_enum::WASM_EXTERN_MEMORY,
+//     }) as wasm_externkind_t
+// }
+
+impl wasm_extern_t {
+    pub(crate) unsafe fn ty(&self) -> ExternType {
+        self.inner.ty(&self.store.store())
+    }
+}
+
+impl From<wasm_extern_t> for Extern {
+    fn from(other: wasm_extern_t) -> Self {
+        other.inner
+    }
+}
+
+wasm_declare_boxed_vec!(extern);
+
+/// Copy a `wasm_extern_t`.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_extern_copy(r#extern: &wasm_extern_t) -> Box<wasm_extern_t> {
+    Box::new(r#extern.clone())
+}
+
+/// Delete an extern.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_extern_delete(_extern: Option<Box<wasm_extern_t>>) {}
+
+#[no_mangle]
+pub extern "C" fn wasm_func_as_extern(func: Option<&wasm_func_t>) -> Option<&wasm_extern_t> {
+    Some(&func?.extern_)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_global_as_extern(global: Option<&wasm_global_t>) -> Option<&wasm_extern_t> {
+    Some(&global?.extern_)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_memory_as_extern(memory: Option<&wasm_memory_t>) -> Option<&wasm_extern_t> {
+    Some(&memory?.extern_)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_table_as_extern(table: Option<&wasm_table_t>) -> Option<&wasm_extern_t> {
+    Some(&table?.extern_)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_extern_as_func(r#extern: Option<&wasm_extern_t>) -> Option<&wasm_func_t> {
+    wasm_func_t::try_from(r#extern?)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_extern_as_global(
+    r#extern: Option<&wasm_extern_t>,
+) -> Option<&wasm_global_t> {
+    wasm_global_t::try_from(r#extern?)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_extern_as_memory(
+    r#extern: Option<&wasm_extern_t>,
+) -> Option<&wasm_memory_t> {
+    wasm_memory_t::try_from(r#extern?)
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_extern_as_table(r#extern: Option<&wasm_extern_t>) -> Option<&wasm_table_t> {
+    wasm_table_t::try_from(r#extern?)
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_extern_copy() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (func (export \"function\")))"
+                );
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+                wasm_trap_t* trap = NULL;
+
+                wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+                assert(instance);
+
+                wasm_extern_vec_t exports;
+                wasm_instance_exports(instance, &exports);
+
+                assert(exports.size == 1);
+
+                wasm_extern_t* function = exports.data[0];
+                assert(wasm_extern_kind(function) == WASM_EXTERN_FUNC);
+
+                wasm_extern_t* function_copy = wasm_extern_copy(function);
+                assert(wasm_extern_kind(function_copy) == WASM_EXTERN_FUNC);
+
+                wasm_extern_delete(function_copy);
+                wasm_extern_vec_delete(&exports);
+                wasm_instance_delete(instance);
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/table.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/table.rs
new file mode 100644
index 0000000..839cb44
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/externals/table.rs
@@ -0,0 +1,62 @@
+use super::super::store::wasm_store_t;
+use super::super::types::{wasm_ref_t, wasm_table_size_t, wasm_tabletype_t};
+use super::wasm_extern_t;
+use wasmer_api::Extern;
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+#[derive(Clone)]
+pub struct wasm_table_t {
+    pub(crate) extern_: wasm_extern_t,
+}
+
+impl wasm_table_t {
+    pub(crate) fn try_from(e: &wasm_extern_t) -> Option<&wasm_table_t> {
+        match &e.inner {
+            Extern::Table(_) => Some(unsafe { &*(e as *const _ as *const _) }),
+            _ => None,
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_new(
+    _store: Option<&wasm_store_t>,
+    _table_type: Option<&wasm_tabletype_t>,
+    _init: *const wasm_ref_t,
+) -> Option<Box<wasm_table_t>> {
+    todo!("get val from init somehow");
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_delete(_table: Option<Box<wasm_table_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_copy(table: &wasm_table_t) -> Box<wasm_table_t> {
+    // do shallow copy
+    Box::new(table.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_size(table: &wasm_table_t) -> usize {
+    table.extern_.table().size(&table.extern_.store.store()) as _
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_same(
+    wasm_table1: &wasm_table_t,
+    wasm_table2: &wasm_table_t,
+) -> bool {
+    wasm_table1.extern_.table() == wasm_table2.extern_.table()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_table_grow(
+    _table: &mut wasm_table_t,
+    _delta: wasm_table_size_t,
+    _init: *mut wasm_ref_t,
+) -> bool {
+    // TODO: maybe need to look at result to return `true`; also maybe report error here
+    //wasm_table.inner.grow(delta, init).is_ok()
+    todo!("Blocked on transforming ExternRef into a val type")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/function_env.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/function_env.rs
new file mode 100644
index 0000000..a9e3910
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/function_env.rs
@@ -0,0 +1,63 @@
+use crate::wasm_c_api::store::wasm_store_t;
+use std::ffi::c_void;
+use wasmer_api::FunctionEnv;
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+pub struct FunctionCEnv {
+    #[allow(dead_code)]
+    inner: std::ptr::NonNull<c_void>,
+}
+
+impl FunctionCEnv {
+    #[allow(dead_code)]
+    pub(crate) fn as_ptr(&self) -> *mut c_void {
+        self.inner.as_ptr()
+    }
+}
+
+static NULL_ENV_PLACEHOLDER: u32 = 42;
+
+impl FunctionCEnv {
+    pub(crate) fn new(inner: std::ptr::NonNull<c_void>) -> Self {
+        Self { inner }
+    }
+}
+
+impl Default for FunctionCEnv {
+    fn default() -> Self {
+        Self {
+            inner: unsafe {
+                std::ptr::NonNull::new_unchecked(
+                    &NULL_ENV_PLACEHOLDER as *const u32 as *mut u32 as *mut c_void,
+                )
+            },
+        }
+    }
+}
+
+unsafe impl Send for FunctionCEnv {}
+
+#[derive(Clone)]
+#[allow(non_camel_case_types)]
+#[repr(C)]
+pub struct wasmer_funcenv_t {
+    inner: FunctionCEnv,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_funcenv_new(
+    store: Option<&mut wasm_store_t>,
+    mut data: *mut c_void,
+) -> Option<Box<wasmer_funcenv_t>> {
+    let store = store?;
+    if data.is_null() {
+        data = &NULL_ENV_PLACEHOLDER as *const u32 as *mut u32 as *mut c_void;
+    }
+    let inner = FunctionCEnv::new(std::ptr::NonNull::new_unchecked(data));
+    let _ = FunctionEnv::new(&mut store.inner.store_mut(), inner);
+    Some(Box::new(wasmer_funcenv_t { inner }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_funcenv_delete(_funcenv: Option<Box<wasmer_funcenv_t>>) {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/instance.rs
new file mode 100644
index 0000000..ab07dff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/instance.rs
@@ -0,0 +1,318 @@
+use super::externals::{wasm_extern_t, wasm_extern_vec_t};
+use super::module::wasm_module_t;
+use super::store::{wasm_store_t, StoreRef};
+use super::trap::wasm_trap_t;
+use wasmer_api::{Extern, Instance, InstantiationError};
+
+/// Opaque type representing a WebAssembly instance.
+#[allow(non_camel_case_types)]
+pub struct wasm_instance_t {
+    pub(crate) store: StoreRef,
+    pub(crate) inner: Instance,
+}
+
+/// Creates a new instance from a WebAssembly module and a
+/// set of imports.
+///
+/// ## Errors
+///
+/// The function can fail in 2 ways:
+///
+/// 1. Link errors that happen when plugging the imports into the
+///    instance,
+/// 2. Runtime errors that happen when running the module `start`
+///    function.
+///
+/// The failure is stored in the `trap` argument; the program doesn't
+/// panic.
+///
+/// # Notes
+///
+/// The `store` argument is ignored. The store from the given module
+/// will be used.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_instance_new(
+    store: Option<&mut wasm_store_t>,
+    module: Option<&wasm_module_t>,
+    imports: Option<&wasm_extern_vec_t>,
+    trap: Option<&mut *mut wasm_trap_t>,
+) -> Option<Box<wasm_instance_t>> {
+    let store = store?;
+    let mut store_mut = store.inner.store_mut();
+    let module = module?;
+    let imports = imports?;
+
+    let wasm_module = &module.inner;
+    let module_imports = wasm_module.imports();
+    let module_import_count = module_imports.len();
+    let externs = imports
+        .as_slice()
+        .iter()
+        .map(|imp| Extern::from(imp.as_ref().unwrap().as_ref().clone()))
+        .take(module_import_count)
+        .collect::<Vec<Extern>>();
+
+    let instance = match Instance::new_by_index(&mut store_mut, wasm_module, &externs) {
+        Ok(instance) => instance,
+
+        Err(InstantiationError::Link(link_error)) => {
+            crate::error::update_last_error(link_error);
+
+            return None;
+        }
+
+        Err(InstantiationError::Start(runtime_error)) => {
+            if let Some(trap) = trap {
+                let this_trap: Box<wasm_trap_t> = Box::new(runtime_error.into());
+                *trap = Box::into_raw(this_trap);
+            }
+
+            return None;
+        }
+
+        Err(e @ InstantiationError::CpuFeature(_)) => {
+            crate::error::update_last_error(e);
+
+            return None;
+        }
+
+        Err(e @ InstantiationError::DifferentStores) => {
+            crate::error::update_last_error(e);
+
+            return None;
+        }
+
+        Err(e @ InstantiationError::DifferentArchOS) => {
+            crate::error::update_last_error(e);
+
+            return None;
+        }
+    };
+
+    Some(Box::new(wasm_instance_t {
+        store: store.inner.clone(),
+        inner: instance,
+    }))
+}
+
+/// Deletes an instance.
+///
+/// # Example
+///
+/// See [`wasm_instance_new`].
+#[no_mangle]
+pub unsafe extern "C" fn wasm_instance_delete(_instance: Option<Box<wasm_instance_t>>) {}
+
+/// Gets the exports of the instance.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(
+///         &wat,
+///         "(module\n"
+///         "  (func (export \"function\") (param i32 i64))\n"
+///         "  (global (export \"global\") i32 (i32.const 7))\n"
+///         "  (table (export \"table\") 0 funcref)\n"
+///         "  (memory (export \"memory\") 1))"
+///     );
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///
+///     // Instantiate the module.
+///     wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+///     wasm_trap_t* trap = NULL;
+///
+///     wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+///     assert(instance);
+///
+///     // Read the exports.
+///     wasm_extern_vec_t exports;
+///     wasm_instance_exports(instance, &exports);
+///
+///     // We have 4 of them.
+///     assert(exports.size == 4);
+///
+///     // The first one is a function. Use `wasm_extern_as_func`
+///     // to go further.
+///     assert(wasm_extern_kind(exports.data[0]) == WASM_EXTERN_FUNC);
+///
+///     // The second one is a global. Use `wasm_extern_as_global` to
+///     // go further.
+///     assert(wasm_extern_kind(exports.data[1]) == WASM_EXTERN_GLOBAL);
+///
+///     // The third one is a table. Use `wasm_extern_as_table` to
+///     // go further.
+///     assert(wasm_extern_kind(exports.data[2]) == WASM_EXTERN_TABLE);
+///
+///     // The fourth one is a memory. Use `wasm_extern_as_memory` to
+///     // go further.
+///     assert(wasm_extern_kind(exports.data[3]) == WASM_EXTERN_MEMORY);
+///
+///     // Free everything.
+///     wasm_extern_vec_delete(&exports);
+///     wasm_instance_delete(instance);
+///     wasm_module_delete(module);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// To go further:
+///
+/// * [`wasm_extern_as_func`][super::externals::wasm_extern_as_func],
+/// * [`wasm_extern_as_global`][super::externals::wasm_extern_as_global],
+/// * [`wasm_extern_as_table`][super::externals::wasm_extern_as_table],
+/// * [`wasm_extern_as_memory`][super::externals::wasm_extern_as_memory].
+#[no_mangle]
+pub unsafe extern "C" fn wasm_instance_exports(
+    instance: &wasm_instance_t,
+    // own
+    out: &mut wasm_extern_vec_t,
+) {
+    let original_instance = instance;
+    let instance = &instance.inner;
+    let extern_vec: Vec<Option<Box<wasm_extern_t>>> = instance
+        .exports
+        .iter()
+        .map(|(_name, r#extern)| {
+            Some(Box::new(wasm_extern_t::new(
+                original_instance.store.clone(),
+                r#extern.clone(),
+            )))
+        })
+        .collect();
+    out.set_buffer(extern_vec);
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_instance_new() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            // The `sum` host function implementation.
+            wasm_trap_t* sum_callback(
+                const wasm_val_vec_t* arguments,
+                wasm_val_vec_t* results
+            ) {
+                wasm_val_t sum = {
+                    .kind = WASM_I32,
+                    .of = { arguments->data[0].of.i32 + arguments->data[1].of.i32 },
+                };
+                results->data[0] = sum;
+
+                return NULL;
+            }
+
+            int main() {
+                // Create the engine and the store.
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                // Create a WebAssembly module from a WAT definition.
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (import \"math\" \"sum\" (func $sum (param i32 i32) (result i32)))\n"
+                    "  (func (export \"add_one\") (param i32) (result i32)\n"
+                    "    local.get 0\n"
+                    "    i32.const 1\n"
+                    "    call $sum))"
+                );
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                // Create the module.
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+
+                assert(module);
+
+                // Prepare the imports.
+                wasm_functype_t* sum_type = wasm_functype_new_2_1(
+                    wasm_valtype_new_i32(),
+                    wasm_valtype_new_i32(),
+                    wasm_valtype_new_i32()
+                );
+                wasm_func_t* sum_function = wasm_func_new(store, sum_type, sum_callback);
+                wasm_extern_t* externs[] = { wasm_func_as_extern(sum_function) };
+                wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+
+                // Instantiate the module.
+                wasm_trap_t* trap = NULL;
+                wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+
+                assert(instance);
+
+                // Run the exported function.
+                wasm_extern_vec_t exports;
+                wasm_instance_exports(instance, &exports);
+
+                assert(exports.size == 1);
+
+                const wasm_func_t* run_function = wasm_extern_as_func(exports.data[0]);
+
+                assert(run_function);
+
+                wasm_val_t arguments[1] = { WASM_I32_VAL(1) };
+                wasm_val_t results[1] = { WASM_INIT_VAL };
+
+                wasm_val_vec_t arguments_as_array = WASM_ARRAY_VEC(arguments);
+                wasm_val_vec_t results_as_array = WASM_ARRAY_VEC(results);
+
+                trap = wasm_func_call(run_function, &arguments_as_array, &results_as_array);
+
+                assert(trap == NULL);
+                assert(results[0].of.i32 == 2);
+
+                // Free everything.
+                wasm_extern_vec_delete(&exports);
+                wasm_instance_delete(instance);
+                wasm_func_delete(sum_function);
+                wasm_functype_delete(sum_type);
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/macros.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/macros.rs
new file mode 100644
index 0000000..19a3090
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/macros.rs
@@ -0,0 +1,327 @@
+macro_rules! wasm_declare_vec_inner {
+    (
+        name: $name:ident,
+        ty: $elem_ty:ty,
+        c_ty: $c_ty:expr,
+        c_val: $c_val:expr,
+        new: $new:ident,
+        empty: $empty:ident,
+        uninit: $uninit:ident,
+        copy: $copy:ident,
+        delete: $delete:ident,
+    ) => {
+        #[doc = concat!("Represents a vector of `", $c_ty, "`.
+
+Read the documentation of [`", $c_ty, "`] to see more concrete examples.
+
+# Example
+
+```rust
+# use wasmer_inline_c::assert_c;
+# fn main() {
+#    (assert_c! {
+# #include \"tests/wasmer.h\"
+#
+void example(", $c_ty, " x, ", $c_ty, " y) {
+    // Create a vector of 2 `", $c_ty, "`.
+    ", $c_ty, " items[2] = {x, y};
+
+    ", stringify!($name), " vector;
+    ", stringify!($new), "(&vector, 2, items);
+
+    // Check that it contains 2 items.
+    assert(vector.size == 2);
+
+    // Free it.
+    ", stringify!($delete), "(&vector);
+}
+#
+# int main() { example(", $c_val, ", ", $c_val, "); return 0; }
+#    })
+#    .success();
+# }
+```")]
+        #[repr(C)]
+        pub struct $name {
+            pub size: usize,
+            pub data: *mut $elem_ty,
+        }
+
+        impl $name {
+            // Note that this does not free any existing buffer.
+            pub fn set_buffer(&mut self, buffer: Vec<$elem_ty>) {
+                let mut vec = buffer.into_boxed_slice();
+                self.size = vec.len();
+                self.data = vec.as_mut_ptr();
+                std::mem::forget(vec);
+            }
+
+            pub fn as_slice(&self) -> &[$elem_ty] {
+                // Note that we're careful to not create a slice with a null
+                // pointer as the data pointer, since that isn't defined
+                // behavior in Rust.
+                if self.size == 0 {
+                    &[]
+                } else {
+                    assert!(!self.data.is_null());
+                    unsafe { std::slice::from_raw_parts(self.data, self.size) }
+                }
+            }
+
+            pub fn as_uninit_slice(&mut self) -> &mut [std::mem::MaybeUninit<$elem_ty>] {
+                // Note that we're careful to not create a slice with a null
+                // pointer as the data pointer, since that isn't defined
+                // behavior in Rust.
+                if self.size == 0 {
+                    &mut []
+                } else {
+                    assert!(!self.data.is_null());
+                    unsafe { std::slice::from_raw_parts_mut(self.data as _, self.size) }
+                }
+            }
+
+            pub fn take(&mut self) -> Vec<$elem_ty> {
+                if self.data.is_null() {
+                    return Vec::new();
+                }
+                let vec = unsafe { Vec::from_raw_parts(self.data, self.size, self.size) };
+                self.data = std::ptr::null_mut();
+                self.size = 0;
+                return vec;
+            }
+        }
+
+        impl From<Vec<$elem_ty>> for $name {
+            fn from(vec: Vec<$elem_ty>) -> Self {
+                let mut vec = vec.into_boxed_slice();
+                let result = $name {
+                    size: vec.len(),
+                    data: vec.as_mut_ptr(),
+                };
+                std::mem::forget(vec);
+                result
+            }
+        }
+
+        impl Clone for $name {
+            fn clone(&self) -> Self {
+                self.as_slice().to_vec().into()
+            }
+        }
+
+        impl Drop for $name {
+            fn drop(&mut self) {
+                drop(self.take());
+            }
+        }
+
+        #[doc = concat!("Creates an empty vector of [`", $c_ty, "`].
+
+# Example
+
+```rust
+# use wasmer_inline_c::assert_c;
+# fn main() {
+#    (assert_c! {
+# #include \"tests/wasmer.h\"
+#
+int main() {
+    // Creates an empty vector of `", $c_ty, "`.
+    ", stringify!($name), " vector;
+    ", stringify!($empty), "(&vector);
+
+    // Check that it is empty.
+    assert(vector.size == 0);
+
+    // Free it.
+    ", stringify!($delete), "(&vector);
+
+    return 0;
+}
+#    })
+#    .success();
+# }
+```")]
+        #[no_mangle]
+        pub extern "C" fn $empty(out: &mut $name) {
+            out.size = 0;
+            out.data = std::ptr::null_mut();
+        }
+
+        #[doc = concat!("Creates a new uninitialized vector of [`", $c_ty, "`].
+
+# Example
+
+```rust
+# use wasmer_inline_c::assert_c;
+# fn main() {
+#    (assert_c! {
+# #include \"tests/wasmer.h\"
+#
+int main() {
+    // Creates an empty vector of `", $c_ty, "`.
+    ", stringify!($name), " vector;
+    ", stringify!($uninit), "(&vector, 3);
+
+    // Check that it contains 3 items.
+    assert(vector.size == 3);
+
+    // Free it.
+    ", stringify!($delete), "(&vector);
+
+    return 0;
+}
+#    })
+#    .success();
+# }
+```")]
+        #[no_mangle]
+        pub extern "C" fn $uninit(out: &mut $name, size: usize) {
+            out.set_buffer(vec![Default::default(); size]);
+        }
+
+        #[doc = concat!("Creates a new vector of [`", $c_ty, "`].
+
+# Example
+
+See the [`", stringify!($name), "`] type to get an example.")]
+        #[no_mangle]
+        pub unsafe extern "C" fn $new(out: &mut $name, size: usize, ptr: *const $elem_ty) {
+            let vec = (0..size).map(|i| ptr.add(i).read()).collect();
+            out.set_buffer(vec);
+        }
+
+        #[doc = concat!("Performs a deep copy of a vector of [`", $c_ty, "`].")]
+        #[no_mangle]
+        pub extern "C" fn $copy(out: &mut $name, src: &$name) {
+            out.set_buffer(src.as_slice().to_vec());
+        }
+
+        #[doc = concat!("Deletes a vector of [`", $c_ty, "`].
+
+# Example
+
+See the [`", stringify!($name), "`] type to get an example.")]
+        #[no_mangle]
+        pub extern "C" fn $delete(out: &mut $name) {
+            out.take();
+        }
+    };
+}
+
+macro_rules! wasm_declare_vec {
+    ($name:ident) => {
+        wasm_declare_vec!($name, wasm);
+    };
+
+    ($name:ident, $prefix:ident) => {
+        paste::paste! {
+            wasm_declare_vec_inner!(
+                name: [<$prefix _ $name _vec_t>],
+                ty: [<$prefix _ $name _t>],
+                c_ty: stringify!([<$prefix _ $name _t>]),
+                c_val: concat!("({ ",
+                    stringify!([<$prefix _ $name _t>]), " foo;\n",
+                    "memset(&foo, 0, sizeof(foo));\n",
+                    "foo;\n",
+                "})"),
+                new: [<$prefix _ $name _vec_new>],
+                empty: [<$prefix _ $name _vec_new_empty>],
+                uninit: [<$prefix _ $name _vec_new_uninitialized>],
+                copy: [<$prefix _ $name _vec_copy>],
+                delete: [<$prefix _ $name _vec_delete>],
+            );
+        }
+    };
+}
+
+macro_rules! wasm_declare_boxed_vec {
+    ($name:ident) => {
+        wasm_declare_boxed_vec!($name, wasm);
+    };
+
+    ($name:ident, $prefix:ident) => {
+        paste::paste! {
+            wasm_declare_vec_inner!(
+                name: [<$prefix _ $name _vec_t>],
+                ty: Option<Box<[<$prefix _ $name _t>]>>,
+                c_ty: stringify!([<$prefix _ $name _t>] *),
+                c_val: "NULL",
+                new: [<$prefix _ $name _vec_new>],
+                empty: [<$prefix _ $name _vec_new_empty>],
+                uninit: [<$prefix _ $name _vec_new_uninitialized>],
+                copy: [<$prefix _ $name _vec_copy>],
+                delete: [<$prefix _ $name _vec_delete>],
+            );
+        }
+    };
+}
+
+macro_rules! wasm_impl_copy {
+    ($name:ident) => {
+        wasm_impl_copy!($name, wasm);
+    };
+
+    ($name:ident, $prefix:ident) => {
+        paste::paste! {
+            #[no_mangle]
+            pub extern "C" fn [<$prefix _ $name _copy>](src: Option<&[<$prefix _ $name _t>]>) -> Option<Box<[<$prefix _ $name _t>]>> {
+                Some(Box::new(src?.clone()))
+            }
+        }
+    };
+}
+
+macro_rules! wasm_impl_delete {
+    ($name:ident) => {
+        wasm_impl_delete!($name, wasm);
+    };
+
+    ($name:ident, $prefix:ident) => {
+        paste::paste! {
+            #[no_mangle]
+            pub extern "C" fn [<$prefix _ $name _delete>](_: Option<Box<[<$prefix _ $name _t>]>>) {}
+        }
+    };
+}
+
+macro_rules! wasm_impl_copy_delete {
+    ($name:ident) => {
+        wasm_impl_copy_delete!($name, wasm);
+    };
+
+    ($name:ident, $prefix:ident) => {
+        wasm_impl_copy!($name, $prefix);
+        wasm_impl_delete!($name, $prefix);
+    };
+}
+
+macro_rules! c_try {
+    ($expr:expr; otherwise ()) => {{
+        let res: Result<_, _> = $expr;
+        match res {
+            Ok(val) => val,
+            Err(err) => {
+                crate::error::update_last_error(err);
+                return;
+            }
+        }
+    }};
+    ($expr:expr; otherwise $return:expr) => {{
+        let res: Result<_, _> = $expr;
+        match res {
+            Ok(val) => val,
+            Err(err) => {
+                crate::error::update_last_error(err);
+                return $return;
+            }
+        }
+    }};
+    ($expr:expr) => {{
+        c_try!($expr; otherwise None)
+    }};
+    ($expr:expr, $e:expr) => {{
+        let opt: Option<_> = $expr;
+        c_try!(opt.ok_or_else(|| $e))
+    }};
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/mod.rs
new file mode 100644
index 0000000..2b79d9f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/mod.rs
@@ -0,0 +1,368 @@
+//! Implementation of the [official WebAssembly C
+//! API](https://github.com/WebAssembly/wasm-c-api) for Wasmer.
+//!
+//! We would like to remind the reader that this official standard can
+//! be characterized as a _living standard_. As such, the API is not
+//! yet stable, even though it shows maturity over time. The API is
+//! described by the `wasm.h` C header, which is included by
+//! `wasmer.h` C header file (which contains extension of the
+//! standard API, for example to provide WASI or vendor-specific
+//! features).
+//!
+//! # Quick Guide
+//!
+//! Usually, the user first needs to create an [`engine`] and a
+//! [`store`]. Once it's done, the user needs to create a [`module`]
+//! and then [instantiate][instance] it. When instantiating the
+//! module, the user is able to pass a set of
+//! [imports][externals]. With an instance, the user is able to call
+//! the [exports][instance::wasm_instance_exports].
+//!
+//! Every module comes with examples and entry points to guide the
+//! discovery of this API.
+
+/// `Context`.
+mod function_env;
+
+/// Private Rust macros.
+#[macro_use]
+mod macros;
+
+/// An engine drives the compilation and the runtime.
+///
+/// Entry points: A default engine is created with
+/// [`wasm_engine_new`][engine::wasm_engine_new] and freed with
+/// [`wasm_engine_delete`][engine::wasm_engine_delete].
+///
+/// # Example
+///
+/// The simplest way to get a default engine is the following:
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new();
+///
+///     // Check we have a valid engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// To configure the engine, see the [`wasm_config_new`][engine::wasm_config_new].
+pub mod engine;
+
+/// cbindgen:ignore
+pub mod externals;
+
+/// A WebAssembly instance is a stateful, executable instance of a
+/// WebAssembly module.
+///
+/// Instance objects contain all the exported WebAssembly functions,
+/// memories, tables and globals that allow interacting with
+/// WebAssembly.
+///
+/// Entry points: A WebAssembly instance is created with
+/// [`wasm_instance_new`][instance::wasm_instance_new] and freed with
+/// [`wasm_instance_delete`][instance::wasm_instance_delete].
+///
+/// # Example
+///
+/// The simplest way to instantiate a Wasm module is the following:
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module)");
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///     assert(module);
+///
+///     // Instantiate the module.
+///     wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+///     wasm_trap_t* trap = NULL;
+///
+///     wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+///     assert(instance);
+///
+///     // Now do something with the instance, like calling the
+///     // exports with `wasm_instance_exports`.
+///
+///     // Free everything.
+///     wasm_instance_delete(instance);
+///     wasm_module_delete(module);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+pub mod instance;
+
+/// A WebAssembly module contains stateless WebAssembly code that has
+/// already been compiled and can be instantiated multiple times.
+///
+/// Entry points: A WebAssembly module is created with
+/// [`wasm_module_new`][module::wasm_module_new] and freed with
+/// [`wasm_module_delete`][module::wasm_module_delete].
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module)");
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///    
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///
+///     // It works!
+///     assert(module);
+///    
+///     // Free everything.
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_module_delete(module);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+pub mod module;
+
+/// A store represents all global state that can be manipulated by
+/// WebAssembly programs. It consists of the runtime representation of
+/// all instances of functions, tables, memories, and globals that
+/// have been allocated during the lifetime of the abstract machine.
+///
+/// The store holds the [engine] (that is —amonst many things— used to
+/// compile the Wasm bytes into a valid [module] artifact), in addition
+/// to extra private types.
+///
+/// Entry points: A store is created with
+/// [`wasm_store_new`][store::wasm_store_new] and freed with
+/// [`wasm_store_delete`][store::wasm_store_delete]. To customize the
+/// engine the store holds, see
+/// [`wasm_config_new`][engine::wasm_config_new].
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new();
+///
+///     // Create the store.
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // It works!
+///     assert(store);
+///    
+///     // Free everything.
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// cbindgen:ignore
+pub mod store;
+
+/// A trap represents an error which stores trace message with
+/// backtrace.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create an engine and a store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create the trap message.
+///     wasm_message_t message;
+///     wasm_name_new_from_string_nt(&message, "foobar");
+///
+///     // Create the trap with its message.
+///     // The backtrace will be generated automatically.
+///     wasm_trap_t* trap = wasm_trap_new(store, &message);
+///     assert(trap);
+///
+///     wasm_name_delete(&message);
+///
+///     // Do something with the trap.
+///
+///     // Free everything.
+///     wasm_trap_delete(trap);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// Usually, a trap is returned from a host function (an imported
+/// function).
+///
+/// cbindgen:ignore
+pub mod trap;
+
+/// cbindgen:ignore
+pub mod types;
+
+/// This module contains _unstable non-standard_ C API.
+///
+/// Use them at your own risks. The API is subject to change or to
+/// break without any plan to keep any compatibility :-).
+pub mod unstable;
+
+/// Possible runtime values that a WebAssembly module can either
+/// consume or produce.
+///
+/// cbindgen:ignore
+pub mod value;
+
+/// Wasmer-specific API to get or query the version of this Wasm C API.
+///
+/// The `wasmer.h` file provides the `WASMER_VERSION`,
+/// `WASMER_VERSION_MAJOR`, `WASMER_VERSION_MINOR`,
+/// `WASMER_VERSION_PATCH` and `WASMER_VERSION_PRE`
+/// constants. However, in absence of this header file, it is possible
+/// to retrieve the same information with their respective functions,
+/// namely [`wasmer_version`][version::wasmer_version],
+/// [`wasmer_version_major`][version::wasmer_version_major],
+/// [`wasmer_version_minor`][version::wasmer_version_minor],
+/// [`wasmer_version_patch`][version::wasmer_version_patch], and
+/// [`wasmer_version_pre`][version::wasmer_version_pre].
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Get and print the version.
+///     const char* version = wasmer_version();
+///     printf("%s", version);
+///
+///     // No need to free the string. It's statically allocated on
+///     // the Rust side.
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success()
+/// #    .stdout(env!("CARGO_PKG_VERSION"));
+/// # }
+/// ```
+pub mod version;
+
+#[cfg(feature = "wasi")]
+pub mod wasi;
+
+/// Wasmer-specific API to transform the WAT format into Wasm bytes.
+///
+/// It is used mostly for testing or for small program purposes.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Our WAT module.
+///     wasm_byte_vec_t wat;
+///     wasm_byte_vec_new(&wat, 8, "(module)");
+///
+///     // Our Wasm bytes.
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // It works!
+///     assert(wasm.size > 0);
+///
+///     // Free everything.
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[cfg(feature = "wat")]
+pub mod wat;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/module.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/module.rs
new file mode 100644
index 0000000..2bc7b1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/module.rs
@@ -0,0 +1,863 @@
+use super::store::wasm_store_t;
+use super::types::{wasm_byte_vec_t, wasm_exporttype_vec_t, wasm_importtype_vec_t};
+use std::ptr::NonNull;
+use wasmer_api::Module;
+
+/// Opaque type representing a WebAssembly module.
+#[derive(Clone)]
+#[allow(non_camel_case_types)]
+pub struct wasm_module_t {
+    pub(crate) inner: Module,
+}
+
+/// A WebAssembly module contains stateless WebAssembly code that has
+/// already been compiled and can be instantiated multiple times.
+///
+/// Creates a new WebAssembly Module given the configuration
+/// in the store.
+///
+/// ## Security
+///
+/// Before the code is compiled, it will be validated using the store
+/// features.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_new(
+    store: Option<&mut wasm_store_t>,
+    bytes: Option<&wasm_byte_vec_t>,
+) -> Option<Box<wasm_module_t>> {
+    let store = store?.inner.store_mut();
+    let bytes = bytes?;
+
+    let module = c_try!(Module::from_binary(&store, bytes.as_slice()));
+
+    Some(Box::new(wasm_module_t { inner: module }))
+}
+
+/// Deletes a WebAssembly module.
+///
+/// # Example
+///
+/// See [`wasm_module_new`].
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_delete(_module: Option<Box<wasm_module_t>>) {}
+
+/// Validates a new WebAssembly module given the configuration
+/// in the [store][super::store].
+///
+/// This validation is normally pretty fast and checks the enabled
+/// WebAssembly features in the [store engine][super::engine] to
+/// assure deterministic validation of the module.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module)");
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Validate that the WebAssembly module is correct.
+///     assert(wasm_module_validate(store, &wasm));
+///
+///     // Free everything.
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_validate(
+    store: Option<&mut wasm_store_t>,
+    bytes: Option<&wasm_byte_vec_t>,
+) -> bool {
+    let store = match store {
+        Some(store) => store.inner.store_mut(),
+        None => return false,
+    };
+    let bytes = match bytes {
+        Some(bytes) => bytes,
+        None => return false,
+    };
+
+    Module::validate(&store, bytes.as_slice())
+        .map(|_| true)
+        .unwrap_or(false)
+}
+
+/// Returns an array of the exported types in the module.
+///
+/// The order of the exports is guaranteed to be the same as in the
+/// WebAssembly bytecode.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(
+///         &wat,
+///         "(module\n"
+///         "  (func (export \"function\") (param i32 i64))\n"
+///         "  (global (export \"global\") i32 (i32.const 7))\n"
+///         "  (table (export \"table\") 0 funcref)\n"
+///         "  (memory (export \"memory\") 1))"
+///     );
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///     assert(module);
+///
+///     // Extract the types exported by this module.
+///     wasm_exporttype_vec_t export_types;
+///     wasm_module_exports(module, &export_types);
+///
+///     // We have 4 of them.
+///     assert(export_types.size == 4);
+///
+///     // The first one is a function. Use
+///     // `wasm_externtype_as_functype_const` to continue to inspect the
+///     // type.
+///     {
+///         wasm_exporttype_t* export_type = export_types.data[0];
+///
+///         const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+///         wasmer_assert_name(export_name, "function");
+///
+///         const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
+///     }
+///
+///     // The second one is a global. Use
+///     // `wasm_externtype_as_globaltype_const` to continue to inspect the
+///     // type.
+///     {
+///         wasm_exporttype_t* export_type = export_types.data[1];
+///
+///         const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+///         wasmer_assert_name(export_name, "global");
+///
+///         const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
+///     }
+///
+///     // The third one is a table. Use
+///     // `wasm_externtype_as_tabletype_const` to continue to inspect the
+///     // type.
+///     {
+///         wasm_exporttype_t* export_type = export_types.data[2];
+///
+///         const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+///         wasmer_assert_name(export_name, "table");
+///
+///         const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
+///     }
+///
+///     // The fourth one is a memory. Use
+///     // `wasm_externtype_as_memorytype_const` to continue to inspect the
+///     // type.
+///     {
+///         wasm_exporttype_t* export_type = export_types.data[3];
+///
+///         const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+///         wasmer_assert_name(export_name, "memory");
+///
+///         const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
+///     }
+///
+///     // Free everything.
+///     wasm_exporttype_vec_delete(&export_types);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_module_delete(module);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_exports(
+    module: &wasm_module_t,
+    // own
+    out: &mut wasm_exporttype_vec_t,
+) {
+    let exports = module
+        .inner
+        .exports()
+        .map(|export| Some(Box::new(export.into())))
+        .collect();
+
+    out.set_buffer(exports);
+}
+
+/// Returns an array of the imported types in the module.
+///
+/// The order of the imports is guaranteed to be the same as in the
+/// WebAssembly bytecode.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(
+///         &wat,
+///         "(module\n"
+///         "  (import \"ns\" \"function\" (func))\n"
+///         "  (import \"ns\" \"global\" (global f32))\n"
+///         "  (import \"ns\" \"table\" (table 1 2 anyfunc))\n"
+///         "  (import \"ns\" \"memory\" (memory 3 4)))"
+///     );
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///     assert(module);
+///
+///     // Extract the types imported by the module.
+///     wasm_importtype_vec_t import_types;
+///     wasm_module_imports(module, &import_types);
+///
+///     // We have 4 of them.
+///     assert(import_types.size == 4);
+///
+///     // The first one is a function. Use
+///     // `wasm_externtype_as_functype_const` to continue to inspect the
+///     // type.
+///     {
+///         const wasm_importtype_t* import_type = import_types.data[0];
+///
+///         const wasm_name_t* import_module = wasm_importtype_module(import_type);
+///         wasmer_assert_name(import_module, "ns");
+///
+///         const wasm_name_t* import_name = wasm_importtype_name(import_type);
+///         wasmer_assert_name(import_name, "function");
+///
+///         const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
+///     }
+///
+///     // The second one is a global. Use
+///     // `wasm_externtype_as_globaltype_const` to continue to inspect
+///     // the type.
+///     {
+///         const wasm_importtype_t* import_type = import_types.data[1];
+///
+///         const wasm_name_t* import_module = wasm_importtype_module(import_type);
+///         wasmer_assert_name(import_module, "ns");
+///
+///         const wasm_name_t* import_name = wasm_importtype_name(import_type);
+///         wasmer_assert_name(import_name, "global");
+///
+///         const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
+///     }
+///
+///     // The third one is a table. Use
+///     // `wasm_externtype_as_tabletype_const` to continue to inspect
+///     // the type.
+///     {
+///         const wasm_importtype_t* import_type = import_types.data[2];
+///
+///         const wasm_name_t* import_module = wasm_importtype_module(import_type);
+///         wasmer_assert_name(import_module, "ns");
+///
+///         const wasm_name_t* import_name = wasm_importtype_name(import_type);
+///         wasmer_assert_name(import_name, "table");
+///
+///         const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
+///     }
+///
+///     // The fourth one is a memory. Use
+///     // `wasm_externtype_as_memorytype_const` to continue to inspect
+///     // the type.
+///     {
+///         const wasm_importtype_t* import_type = import_types.data[3];
+///
+///         const wasm_name_t* import_module = wasm_importtype_module(import_type);
+///         wasmer_assert_name(import_module, "ns");
+///
+///         const wasm_name_t* import_name = wasm_importtype_name(import_type);
+///         wasmer_assert_name(import_name, "memory");
+///
+///         const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+///         assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
+///
+///         const wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype_const(extern_type);
+///         const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
+///         assert(memory_limits->min == 3);
+///         assert(memory_limits->max == 4);
+///     }
+///
+///     // Free everything.
+///     wasm_importtype_vec_delete(&import_types);
+///     wasm_module_delete(module);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_imports(
+    module: &wasm_module_t,
+    // own
+    out: &mut wasm_importtype_vec_t,
+) {
+    let imports = module
+        .inner
+        .imports()
+        .map(|import| Some(Box::new(import.into())))
+        .collect();
+
+    out.set_buffer(imports);
+}
+
+/// Deserializes a serialized module binary into a `wasm_module_t`.
+///
+/// Note: the module has to be serialized before with the
+/// `wasm_module_serialize` function.
+///
+/// # Safety
+///
+/// This function is inherently **unsafe** as the provided bytes:
+///
+/// 1. Are going to be deserialized directly into Rust and C objects,
+/// 2. Contains the function assembly bodies and, if intercepted,
+///    a malicious actor could inject code into executable
+///    memory.
+///
+/// And as such, the `wasm_module_deserialize` method is unsafe.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///    wasm_byte_vec_t wat;
+///    wasmer_byte_vec_new_from_string(
+///        &wat,
+///        "(module\n"
+///        "  (func (export \"function\") (param i32 i64))\n"
+///        "  (global (export \"global\") i32 (i32.const 7))\n"
+///        "  (table (export \"table\") 0 funcref)\n"
+///        "  (memory (export \"memory\") 1))"
+///    );
+///    wasm_byte_vec_t wasm;
+///    wat2wasm(&wat, &wasm);
+///
+///    // Create the module.
+///    wasm_module_t* module = wasm_module_new(store, &wasm);
+///    assert(module);
+///
+///    // Serialize the module into bytes.
+///    wasm_byte_vec_t serialized_module;
+///    wasm_module_serialize(module, &serialized_module);
+///    assert(serialized_module.size > 0);
+///
+///    // Free the module.
+///    wasm_module_delete(module);
+///
+///    // Deserialize the serialized module. Note that the store must
+///    // be the same as the one used to serialize.
+///    wasm_module_t* deserialized_module = wasm_module_deserialize(
+///        store,
+///        &serialized_module
+///    );
+///    wasm_byte_vec_delete(&serialized_module);
+///    assert(deserialized_module);
+///
+///    // Check we have our 4 export types.
+///    wasm_exporttype_vec_t export_types;
+///    wasm_module_exports(deserialized_module, &export_types);
+///
+///    assert(export_types.size == 4);
+///
+///    // Free everything.
+///    wasm_exporttype_vec_delete(&export_types);
+///    wasm_module_delete(deserialized_module);
+///    wasm_byte_vec_delete(&wasm);
+///    wasm_byte_vec_delete(&wat);
+///    wasm_store_delete(store);
+///    wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_deserialize(
+    store: &wasm_store_t,
+    bytes: Option<&wasm_byte_vec_t>,
+) -> Option<NonNull<wasm_module_t>> {
+    let bytes = bytes?;
+
+    let module = c_try!(Module::deserialize(&store.inner.store(), bytes.as_slice()));
+
+    Some(NonNull::new_unchecked(Box::into_raw(Box::new(
+        wasm_module_t { inner: module },
+    ))))
+}
+
+/// Serializes a module into a binary representation that the
+/// [engine][super::engine] can later process via
+/// [`wasm_module_deserialize`].
+///
+/// # Example
+///
+/// See [`wasm_module_deserialize`].
+#[no_mangle]
+pub unsafe extern "C" fn wasm_module_serialize(module: &wasm_module_t, out: &mut wasm_byte_vec_t) {
+    let byte_vec = c_try!(module.inner.serialize(); otherwise ());
+    out.set_buffer(byte_vec.to_vec());
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_validate() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                assert(wasm_module_validate(store, &wasm));
+
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_new() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_module_delete(module);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_exports() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (func (export \"function\") (param i32 i64))\n"
+                    "  (global (export \"global\") i32 (i32.const 7))\n"
+                    "  (table (export \"table\") 0 funcref)\n"
+                    "  (memory (export \"memory\") 1))"
+                );
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_exporttype_vec_t export_types;
+                wasm_module_exports(module, &export_types);
+
+                assert(export_types.size == 4);
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[0];
+
+                    const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+                    wasmer_assert_name(export_name, "function");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
+
+                    const wasm_functype_t* func_type = wasm_externtype_as_functype_const(extern_type);
+
+                    const wasm_valtype_vec_t* func_params = wasm_functype_params(func_type);
+                    assert(func_params && func_params->size == 2);
+                    assert(wasm_valtype_kind(func_params->data[0]) == WASM_I32);
+                    assert(wasm_valtype_kind(func_params->data[1]) == WASM_I64);
+
+                    const wasm_valtype_vec_t* func_results = wasm_functype_results(func_type);
+                    assert(func_results && func_results->size == 0);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[1];
+
+                    const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+                    wasmer_assert_name(export_name, "global");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
+
+                    const wasm_globaltype_t* global_type = wasm_externtype_as_globaltype_const(extern_type);
+                    assert(wasm_valtype_kind(wasm_globaltype_content(global_type)) == WASM_I32);
+                    assert(wasm_globaltype_mutability(global_type) == WASM_CONST);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[2];
+
+                    const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+                    wasmer_assert_name(export_name, "table");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
+
+                    const wasm_tabletype_t* table_type = wasm_externtype_as_tabletype_const(extern_type);
+                    assert(wasm_valtype_kind(wasm_tabletype_element(table_type)) == WASM_FUNCREF);
+
+                    const wasm_limits_t* table_limits = wasm_tabletype_limits(table_type);
+                    assert(table_limits->min == 0);
+                    assert(table_limits->max == wasm_limits_max_default);
+                }
+
+                {
+                    wasm_exporttype_t* export_type = export_types.data[3];
+
+                    const wasm_name_t* export_name = wasm_exporttype_name(export_type);
+                    wasmer_assert_name(export_name, "memory");
+
+                    const wasm_externtype_t* extern_type = wasm_exporttype_type(export_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
+
+                    const wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype_const(extern_type);
+                    const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
+                    assert(memory_limits->min == 1);
+                    assert(memory_limits->max == wasm_limits_max_default);
+                }
+
+                wasm_exporttype_vec_delete(&export_types);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_module_delete(module);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_imports() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (import \"ns\" \"function\" (func))\n"
+                    "  (import \"ns\" \"global\" (global f32))\n"
+                    "  (import \"ns\" \"table\" (table 1 2 anyfunc))\n"
+                    "  (import \"ns\" \"memory\" (memory 3 4)))"
+                );
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_importtype_vec_t import_types;
+                wasm_module_imports(module, &import_types);
+
+                assert(import_types.size == 4);
+
+                {
+                    const wasm_importtype_t* import_type = import_types.data[0];
+
+                    const wasm_name_t* import_module = wasm_importtype_module(import_type);
+                    wasmer_assert_name(import_module, "ns");
+
+                    const wasm_name_t* import_name = wasm_importtype_name(import_type);
+                    wasmer_assert_name(import_name, "function");
+
+                    const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_FUNC);
+
+                    const wasm_functype_t* func_type = wasm_externtype_as_functype_const(extern_type);
+
+                    const wasm_valtype_vec_t* func_params = wasm_functype_params(func_type);
+                    assert(func_params && func_params->size == 0);
+
+                    const wasm_valtype_vec_t* func_results = wasm_functype_results(func_type);
+                    assert(func_results && func_results->size == 0);
+                }
+
+                {
+                    const wasm_importtype_t* import_type = import_types.data[1];
+
+                    const wasm_name_t* import_module = wasm_importtype_module(import_type);
+                    wasmer_assert_name(import_module, "ns");
+
+                    const wasm_name_t* import_name = wasm_importtype_name(import_type);
+                    wasmer_assert_name(import_name, "global");
+
+                    const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_GLOBAL);
+
+                    const wasm_globaltype_t* global_type = wasm_externtype_as_globaltype_const(extern_type);
+                    assert(wasm_valtype_kind(wasm_globaltype_content(global_type)) == WASM_F32);
+                    assert(wasm_globaltype_mutability(global_type) == WASM_CONST);
+                }
+
+                {
+                    const wasm_importtype_t* import_type = import_types.data[2];
+
+                    const wasm_name_t* import_module = wasm_importtype_module(import_type);
+                    wasmer_assert_name(import_module, "ns");
+
+                    const wasm_name_t* import_name = wasm_importtype_name(import_type);
+                    wasmer_assert_name(import_name, "table");
+
+                    const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_TABLE);
+
+                    const wasm_tabletype_t* table_type = wasm_externtype_as_tabletype_const(extern_type);
+                    assert(wasm_valtype_kind(wasm_tabletype_element(table_type)) == WASM_FUNCREF);
+
+                    const wasm_limits_t* table_limits = wasm_tabletype_limits(table_type);
+                    assert(table_limits->min == 1);
+                    assert(table_limits->max == 2);
+                }
+
+                {
+                    const wasm_importtype_t* import_type = import_types.data[3];
+
+                    const wasm_name_t* import_module = wasm_importtype_module(import_type);
+                    wasmer_assert_name(import_module, "ns");
+
+                    const wasm_name_t* import_name = wasm_importtype_name(import_type);
+                    wasmer_assert_name(import_name, "memory");
+
+                    const wasm_externtype_t* extern_type = wasm_importtype_type(import_type);
+                    assert(wasm_externtype_kind(extern_type) == WASM_EXTERN_MEMORY);
+
+                    const wasm_memorytype_t* memory_type = wasm_externtype_as_memorytype_const(extern_type);
+                    const wasm_limits_t* memory_limits = wasm_memorytype_limits(memory_type);
+                    assert(memory_limits->min == 3);
+                    assert(memory_limits->max == 4);
+                }
+
+                wasm_importtype_vec_delete(&import_types);
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_serialize() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_byte_vec_t serialized_module;
+                wasm_module_serialize(module, &serialized_module);
+                assert(serialized_module.size > 0);
+
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&serialized_module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_module_serialize_and_deserialize() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(
+                    &wat,
+                    "(module\n"
+                    "  (func (export \"function\") (param i32 i64))\n"
+                    "  (global (export \"global\") i32 (i32.const 7))\n"
+                    "  (table (export \"table\") 0 funcref)\n"
+                    "  (memory (export \"memory\") 1))"
+                );
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                wasm_byte_vec_t serialized_module;
+                wasm_module_serialize(module, &serialized_module);
+                assert(serialized_module.size > 0);
+
+                wasm_module_delete(module);
+                wasm_module_t* deserialized_module = wasm_module_deserialize(
+                    store,
+                    &serialized_module
+                );
+                wasm_byte_vec_delete(&serialized_module);
+                assert(deserialized_module);
+
+                wasm_exporttype_vec_t export_types;
+                wasm_module_exports(deserialized_module, &export_types);
+
+                assert(export_types.size == 4);
+
+                wasm_exporttype_vec_delete(&export_types);
+                wasm_module_delete(deserialized_module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/store.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/store.rs
new file mode 100644
index 0000000..24c6b06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/store.rs
@@ -0,0 +1,52 @@
+use super::engine::wasm_engine_t;
+use std::cell::UnsafeCell;
+use std::rc::Rc;
+use wasmer_api::{AsStoreMut, AsStoreRef, Store, StoreMut, StoreRef as BaseStoreRef};
+
+#[derive(Clone)]
+pub struct StoreRef {
+    inner: Rc<UnsafeCell<Store>>,
+}
+
+impl StoreRef {
+    pub unsafe fn store(&self) -> BaseStoreRef<'_> {
+        (*self.inner.get()).as_store_ref()
+    }
+
+    pub unsafe fn store_mut(&mut self) -> StoreMut<'_> {
+        (*self.inner.get()).as_store_mut()
+    }
+}
+
+/// Opaque type representing a WebAssembly store.
+#[allow(non_camel_case_types)]
+pub struct wasm_store_t {
+    pub(crate) inner: StoreRef,
+}
+
+/// Creates a new WebAssembly store given a specific [engine][super::engine].
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_store_new(
+    engine: Option<&wasm_engine_t>,
+) -> Option<Box<wasm_store_t>> {
+    let engine = engine?;
+    let store = Store::new(&engine.inner);
+
+    Some(Box::new(wasm_store_t {
+        inner: StoreRef {
+            inner: Rc::new(UnsafeCell::new(store)),
+        },
+    }))
+}
+
+/// Deletes a WebAssembly store.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_store_delete(_store: Option<Box<wasm_store_t>>) {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/trap.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/trap.rs
new file mode 100644
index 0000000..390e8a9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/trap.rs
@@ -0,0 +1,218 @@
+use super::store::wasm_store_t;
+use super::types::{wasm_byte_vec_t, wasm_message_t};
+use super::types::{wasm_frame_t, wasm_frame_vec_t};
+use std::ffi::CString;
+use wasmer_api::RuntimeError;
+
+// opaque type which is a `RuntimeError`
+#[allow(non_camel_case_types)]
+pub struct wasm_trap_t {
+    pub(crate) inner: RuntimeError,
+}
+
+impl From<RuntimeError> for wasm_trap_t {
+    fn from(other: RuntimeError) -> Self {
+        Self { inner: other }
+    }
+}
+
+/// Create a new trap message.
+///
+/// Be careful, the message is typed with `wasm_message_t` which
+/// represents a null-terminated string.
+///
+/// # Example
+///
+/// See the module's documentation for a complete example.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_trap_new(
+    _store: &mut wasm_store_t,
+    message: &wasm_message_t,
+) -> Option<Box<wasm_trap_t>> {
+    let message_bytes = message.as_slice();
+
+    // The trap message is typed with `wasm_message_t` which is a
+    // typeref to `wasm_name_t` with the exception that it's a
+    // null-terminated string. `RuntimeError` must contain a valid
+    // Rust `String` that doesn't contain a null byte. We must ensure
+    // this behavior.
+    let runtime_error = match CString::new(message_bytes) {
+        // The string is well-formed and doesn't contain a nul byte.
+        Ok(cstring) => RuntimeError::new(cstring.into_string().ok()?),
+
+        // The string is well-formed but is nul-terminated. Let's
+        // create a `String` which is null-terminated too.
+        Err(nul_error) if nul_error.nul_position() + 1 == message_bytes.len() => {
+            let mut vec = nul_error.into_vec();
+            vec.pop();
+
+            RuntimeError::new(String::from_utf8(vec).ok()?)
+        }
+
+        // The string not well-formed.
+        Err(_) => return None,
+    };
+
+    let trap = runtime_error.into();
+
+    Some(Box::new(trap))
+}
+
+/// Deletes a trap.
+///
+/// # Example
+///
+/// See the module's documentation for a complete example.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_trap_delete(_trap: Option<Box<wasm_trap_t>>) {}
+
+/// Gets the message attached to the trap.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create an engine and a store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create the trap message.
+///     wasm_message_t message;
+///     wasm_name_new_from_string_nt(&message, "foobar");
+///
+///     // Create the trap with its message.
+///     // The backtrace will be generated automatically.
+///     wasm_trap_t* trap = wasm_trap_new(store, &message);
+///     assert(trap);
+///
+///     // Get the trap's message back.
+///     wasm_message_t retrieved_message;
+///     wasm_trap_message(trap, &retrieved_message);
+///     assert(retrieved_message.size == message.size);
+///
+///     // Free everything.
+///     wasm_name_delete(&message);
+///     wasm_name_delete(&retrieved_message);
+///     wasm_trap_delete(trap);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasm_trap_message(
+    trap: &wasm_trap_t,
+    // own
+    out: &mut wasm_byte_vec_t,
+) {
+    let message = trap.inner.message();
+    let mut byte_vec = message.into_bytes();
+    byte_vec.push(0);
+
+    out.set_buffer(byte_vec);
+}
+
+/// Gets the origin frame attached to the trap.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_trap_origin(trap: &wasm_trap_t) -> Option<Box<wasm_frame_t>> {
+    trap.inner.trace().first().map(Into::into).map(Box::new)
+}
+
+/// Gets the trace (as a list of frames) attached to the trap.
+#[no_mangle]
+pub unsafe extern "C" fn wasm_trap_trace(
+    trap: &wasm_trap_t,
+    // own
+    out: &mut wasm_frame_vec_t,
+) {
+    let frames = trap.inner.trace();
+    out.set_buffer(
+        frames
+            .iter()
+            .map(|frame| Some(Box::new(frame.into())))
+            .collect(),
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_trap_message_null_terminated() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_message_t original_message;
+                wasm_name_new_from_string_nt(&original_message, "foobar");
+                assert(original_message.size == 7); // 6 for `foobar` + 1 for nul byte.
+
+                wasm_trap_t* trap = wasm_trap_new(store, &original_message);
+                assert(trap);
+
+                wasm_message_t retrieved_message;
+                wasm_trap_message(trap, &retrieved_message);
+                assert(retrieved_message.size == 7);
+
+                wasm_name_delete(&original_message);
+                wasm_name_delete(&retrieved_message);
+                wasm_trap_delete(trap);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_trap_message_not_null_terminated() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+
+                wasm_message_t original_message;
+                wasm_name_new_from_string(&original_message, "foobar");
+                assert(original_message.size == 6); // 6 for `foobar` + 0 for nul byte.
+
+                wasm_trap_t* trap = wasm_trap_new(store, &original_message);
+                assert(trap);
+
+                wasm_message_t retrieved_message;
+                wasm_trap_message(trap, &retrieved_message);
+                assert(retrieved_message.size == 7);
+
+                wasm_name_delete(&original_message);
+                wasm_name_delete(&retrieved_message);
+                wasm_trap_delete(trap);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/export.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/export.rs
new file mode 100644
index 0000000..a60ccf4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/export.rs
@@ -0,0 +1,48 @@
+use super::{wasm_externtype_t, wasm_name_t};
+use wasmer_api::ExportType;
+
+#[allow(non_camel_case_types)]
+#[derive(Clone)]
+pub struct wasm_exporttype_t {
+    name: wasm_name_t,
+    extern_type: wasm_externtype_t,
+}
+
+wasm_declare_boxed_vec!(exporttype);
+wasm_impl_copy_delete!(exporttype);
+
+#[no_mangle]
+pub extern "C" fn wasm_exporttype_new(
+    name: &wasm_name_t,
+    extern_type: Box<wasm_externtype_t>,
+) -> Box<wasm_exporttype_t> {
+    Box::new(wasm_exporttype_t {
+        name: name.clone(),
+        extern_type: *extern_type,
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_exporttype_name(export_type: &wasm_exporttype_t) -> &wasm_name_t {
+    &export_type.name
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_exporttype_type(export_type: &wasm_exporttype_t) -> &wasm_externtype_t {
+    &export_type.extern_type
+}
+
+impl From<ExportType> for wasm_exporttype_t {
+    fn from(other: ExportType) -> Self {
+        (&other).into()
+    }
+}
+
+impl From<&ExportType> for wasm_exporttype_t {
+    fn from(other: &ExportType) -> Self {
+        let name: wasm_name_t = other.name().to_string().into();
+        let extern_type: wasm_externtype_t = other.ty().into();
+
+        wasm_exporttype_t { name, extern_type }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/extern_.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/extern_.rs
new file mode 100644
index 0000000..4218c2a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/extern_.rs
@@ -0,0 +1,284 @@
+use super::super::externals::wasm_extern_t;
+use super::{
+    wasm_functype_t, wasm_globaltype_t, wasm_memorytype_t, wasm_tabletype_t, WasmFunctionType,
+    WasmGlobalType, WasmMemoryType, WasmTableType,
+};
+use std::convert::{TryFrom, TryInto};
+use std::mem;
+use thiserror::Error;
+use wasmer_api::ExternType;
+
+#[allow(non_camel_case_types)]
+pub type wasm_externkind_t = u8;
+
+#[allow(non_camel_case_types)]
+#[repr(u8)]
+pub enum wasm_externkind_enum {
+    WASM_EXTERN_FUNC = 0,
+    WASM_EXTERN_GLOBAL = 1,
+    WASM_EXTERN_TABLE = 2,
+    WASM_EXTERN_MEMORY = 3,
+}
+
+impl From<ExternType> for wasm_externkind_enum {
+    fn from(other: ExternType) -> Self {
+        (&other).into()
+    }
+}
+impl From<&ExternType> for wasm_externkind_enum {
+    fn from(other: &ExternType) -> Self {
+        match other {
+            ExternType::Function(_) => Self::WASM_EXTERN_FUNC,
+            ExternType::Global(_) => Self::WASM_EXTERN_GLOBAL,
+            ExternType::Table(_) => Self::WASM_EXTERN_TABLE,
+            ExternType::Memory(_) => Self::WASM_EXTERN_MEMORY,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum WasmExternType {
+    Function(WasmFunctionType),
+    Global(WasmGlobalType),
+    Table(WasmTableType),
+    Memory(WasmMemoryType),
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+pub struct wasm_externtype_t {
+    pub(crate) inner: WasmExternType,
+}
+
+impl wasm_externtype_t {
+    pub(crate) fn new(extern_type: ExternType) -> Self {
+        Self {
+            inner: match extern_type {
+                ExternType::Function(function_type) => {
+                    WasmExternType::Function(WasmFunctionType::new(function_type))
+                }
+                ExternType::Global(global_type) => {
+                    WasmExternType::Global(WasmGlobalType::new(global_type))
+                }
+                ExternType::Table(table_type) => {
+                    WasmExternType::Table(WasmTableType::new(table_type))
+                }
+                ExternType::Memory(memory_type) => {
+                    WasmExternType::Memory(WasmMemoryType::new(memory_type))
+                }
+            },
+        }
+    }
+}
+
+impl From<ExternType> for wasm_externtype_t {
+    fn from(extern_type: ExternType) -> Self {
+        Self::new(extern_type)
+    }
+}
+
+impl From<&ExternType> for wasm_externtype_t {
+    fn from(other: &ExternType) -> Self {
+        other.clone().into()
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_extern_type(r#extern: &wasm_extern_t) -> Box<wasm_externtype_t> {
+    Box::new(wasm_externtype_t::new(r#extern.ty()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_extern_kind(r#extern: &wasm_extern_t) -> wasm_externkind_t {
+    wasm_externkind_enum::from(r#extern.ty()) as wasm_externkind_t
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_delete(_extern_type: Option<Box<wasm_externtype_t>>) {}
+
+#[no_mangle]
+pub extern "C" fn wasm_externtype_copy(extern_type: &wasm_externtype_t) -> Box<wasm_externtype_t> {
+    Box::new(extern_type.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_kind(
+    extern_type: &wasm_externtype_t,
+) -> wasm_externkind_t {
+    (match extern_type.inner {
+        WasmExternType::Function(_) => wasm_externkind_enum::WASM_EXTERN_FUNC,
+        WasmExternType::Global(_) => wasm_externkind_enum::WASM_EXTERN_GLOBAL,
+        WasmExternType::Table(_) => wasm_externkind_enum::WASM_EXTERN_TABLE,
+        WasmExternType::Memory(_) => wasm_externkind_enum::WASM_EXTERN_MEMORY,
+    }) as wasm_externkind_t
+}
+
+#[derive(Debug, Clone, Error)]
+#[error("failed to convert from `wasm_externtype_t`: {0}")]
+pub struct ExternTypeConversionError(&'static str);
+
+impl From<&'static str> for ExternTypeConversionError {
+    fn from(other: &'static str) -> Self {
+        Self(other)
+    }
+}
+
+impl TryFrom<&'static wasm_externtype_t> for &'static wasm_functype_t {
+    type Error = ExternTypeConversionError;
+
+    fn try_from(other: &'static wasm_externtype_t) -> Result<Self, Self::Error> {
+        if let WasmExternType::Function(_) = other.inner {
+            Ok(unsafe { mem::transmute::<&'static wasm_externtype_t, Self>(other) })
+        } else {
+            Err(ExternTypeConversionError("Wrong type: expected function"))
+        }
+    }
+}
+
+impl TryFrom<&'static wasm_externtype_t> for &'static wasm_globaltype_t {
+    type Error = ExternTypeConversionError;
+
+    fn try_from(other: &'static wasm_externtype_t) -> Result<Self, Self::Error> {
+        if let WasmExternType::Global(_) = other.inner {
+            Ok(unsafe { mem::transmute::<&'static wasm_externtype_t, Self>(other) })
+        } else {
+            Err(ExternTypeConversionError("Wrong type: expected global"))
+        }
+    }
+}
+
+impl TryFrom<&'static wasm_externtype_t> for &'static wasm_tabletype_t {
+    type Error = ExternTypeConversionError;
+
+    fn try_from(other: &'static wasm_externtype_t) -> Result<Self, Self::Error> {
+        if let WasmExternType::Table(_) = other.inner {
+            Ok(unsafe { mem::transmute::<&'static wasm_externtype_t, Self>(other) })
+        } else {
+            Err(ExternTypeConversionError("Wrong type: expected table"))
+        }
+    }
+}
+
+impl TryFrom<&'static wasm_externtype_t> for &'static wasm_memorytype_t {
+    type Error = ExternTypeConversionError;
+
+    fn try_from(other: &'static wasm_externtype_t) -> Result<Self, Self::Error> {
+        if let WasmExternType::Memory(_) = other.inner {
+            Ok(unsafe { mem::transmute::<&'static wasm_externtype_t, Self>(other) })
+        } else {
+            Err(ExternTypeConversionError("Wrong type: expected memory"))
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_functype_const(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_functype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_functype(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_functype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_functype_as_externtype_const(
+    function_type: &'static wasm_functype_t,
+) -> &'static wasm_externtype_t {
+    &function_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_functype_as_externtype(
+    function_type: &'static wasm_functype_t,
+) -> &'static wasm_externtype_t {
+    &function_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_globaltype_const(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_globaltype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_globaltype(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_globaltype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_as_externtype_const(
+    global_type: &'static wasm_globaltype_t,
+) -> &'static wasm_externtype_t {
+    &global_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_as_externtype(
+    global_type: &'static wasm_globaltype_t,
+) -> &'static wasm_externtype_t {
+    &global_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_tabletype_const(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_tabletype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_tabletype(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_tabletype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_as_externtype_const(
+    table_type: &'static wasm_tabletype_t,
+) -> &'static wasm_externtype_t {
+    &table_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_as_externtype(
+    table_type: &'static wasm_tabletype_t,
+) -> &'static wasm_externtype_t {
+    &table_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_memorytype_const(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_memorytype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_externtype_as_memorytype(
+    extern_type: &'static wasm_externtype_t,
+) -> Option<&'static wasm_memorytype_t> {
+    Some(c_try!(extern_type.try_into()))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memorytype_as_externtype_const(
+    memory_type: &'static wasm_memorytype_t,
+) -> &'static wasm_externtype_t {
+    &memory_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memorytype_as_externtype(
+    memory_type: &'static wasm_memorytype_t,
+) -> &'static wasm_externtype_t {
+    &memory_type.extern_type
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/frame.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/frame.rs
new file mode 100644
index 0000000..9cccd95
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/frame.rs
@@ -0,0 +1,127 @@
+use super::super::instance::wasm_instance_t;
+use libc::c_char;
+use std::ffi::CString;
+use wasmer_api::FrameInfo;
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+pub struct wasm_frame_t {
+    info: FrameInfo,
+}
+
+impl<'a> From<&'a FrameInfo> for wasm_frame_t {
+    fn from(other: &'a FrameInfo) -> Self {
+        other.clone().into()
+    }
+}
+
+impl From<FrameInfo> for wasm_frame_t {
+    fn from(other: FrameInfo) -> Self {
+        Self { info: other }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_copy(frame: &wasm_frame_t) -> Box<wasm_frame_t> {
+    Box::new(frame.clone())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_delete(_frame: Option<Box<wasm_frame_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_instance(_frame: &wasm_frame_t) -> *const wasm_instance_t {
+    std::ptr::null()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_func_index(frame: &wasm_frame_t) -> u32 {
+    frame.info.func_index()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_func_offset(frame: &wasm_frame_t) -> usize {
+    frame.info.func_offset()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_module_offset(frame: &wasm_frame_t) -> usize {
+    frame.info.module_offset()
+}
+
+#[repr(C)]
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+pub struct wasm_name_t {
+    pub name: *mut c_char,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_module_name(frame: &wasm_frame_t) -> wasm_name_t {
+    let module_name =
+        Some(frame.info.module_name()).and_then(|f| Some(CString::new(f).ok()?.into_raw()));
+
+    match module_name {
+        Some(s) => wasm_name_t { name: s },
+        None => wasm_name_t {
+            name: core::ptr::null_mut(),
+        },
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_frame_func_name(frame: &wasm_frame_t) -> wasm_name_t {
+    let func_name = frame
+        .info
+        .function_name()
+        .and_then(|f| Some(CString::new(f).ok()?.into_raw()));
+
+    match func_name {
+        Some(s) => wasm_name_t { name: s },
+        None => wasm_name_t {
+            name: core::ptr::null_mut(),
+        },
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_name_delete(name: Option<&mut wasm_name_t>) {
+    if let Some(s) = name {
+        if !s.name.is_null() {
+            let _ = CString::from_raw(s.name);
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(frame);
+
+#[cfg(test)]
+#[test]
+fn test_frame_name() {
+    use std::ffi::CStr;
+    use wasmer_types::SourceLoc;
+
+    let info = wasm_frame_t {
+        info: FrameInfo::new(
+            "module_name".to_string(),
+            5,
+            Some("function_name".to_string()),
+            SourceLoc::new(10),
+            SourceLoc::new(20),
+        ),
+    };
+
+    unsafe {
+        let mut wasm_frame_func_name = wasm_frame_func_name(&info);
+        let s = CStr::from_ptr(wasm_frame_func_name.name);
+        assert_eq!(s.to_str().unwrap(), "function_name");
+        wasm_name_delete(Some(&mut wasm_frame_func_name));
+
+        let mut wasm_frame_module_name = wasm_frame_module_name(&info);
+        let s = CStr::from_ptr(wasm_frame_module_name.name);
+        assert_eq!(s.to_str().unwrap(), "module_name");
+        wasm_name_delete(Some(&mut wasm_frame_module_name));
+    }
+
+    println!("{:#?}", info);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/function.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/function.rs
new file mode 100644
index 0000000..52d10d5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/function.rs
@@ -0,0 +1,113 @@
+use super::{wasm_externtype_t, wasm_valtype_vec_t, WasmExternType};
+use std::fmt;
+use wasmer_api::{ExternType, FunctionType};
+use wasmer_types::Type;
+
+pub(crate) struct WasmFunctionType {
+    pub(crate) function_type: FunctionType,
+    params: wasm_valtype_vec_t,
+    results: wasm_valtype_vec_t,
+}
+
+impl WasmFunctionType {
+    pub(crate) fn new(function_type: FunctionType) -> Self {
+        let params: Vec<_> = function_type
+            .params()
+            .iter()
+            .map(|&valtype| Some(Box::new(valtype.into())))
+            .collect();
+        let results: Vec<_> = function_type
+            .results()
+            .iter()
+            .map(|&valtype| Some(Box::new(valtype.into())))
+            .collect();
+
+        Self {
+            function_type,
+            params: params.into(),
+            results: results.into(),
+        }
+    }
+}
+
+impl Clone for WasmFunctionType {
+    fn clone(&self) -> Self {
+        Self::new(self.function_type.clone())
+    }
+}
+
+impl fmt::Debug for WasmFunctionType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.function_type.fmt(f)
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct wasm_functype_t {
+    pub(crate) extern_type: wasm_externtype_t,
+}
+
+impl wasm_functype_t {
+    pub(crate) fn new(function_type: FunctionType) -> Self {
+        Self {
+            extern_type: wasm_externtype_t::new(ExternType::Function(function_type)),
+        }
+    }
+
+    pub(crate) fn inner(&self) -> &WasmFunctionType {
+        match &self.extern_type.inner {
+            WasmExternType::Function(wasm_function_type) => wasm_function_type,
+            _ => {
+                unreachable!("Data corruption: `wasm_functype_t` does not contain a function type")
+            }
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(functype);
+wasm_impl_copy_delete!(functype);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_functype_new(
+    params: Option<&mut wasm_valtype_vec_t>,
+    results: Option<&mut wasm_valtype_vec_t>,
+) -> Option<Box<wasm_functype_t>> {
+    let params = params?;
+    let results = results?;
+
+    let params_as_valtype: Vec<Type> = params
+        .take()
+        .into_iter()
+        .map(|val| val.as_ref().unwrap().as_ref().into())
+        .collect::<Vec<_>>();
+    let results_as_valtype: Vec<Type> = results
+        .take()
+        .into_iter()
+        .map(|val| val.as_ref().unwrap().as_ref().into())
+        .collect::<Vec<_>>();
+
+    Some(Box::new(wasm_functype_t::new(FunctionType::new(
+        params_as_valtype,
+        results_as_valtype,
+    ))))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_functype_params(
+    function_type: Option<&wasm_functype_t>,
+) -> Option<&wasm_valtype_vec_t> {
+    let function_type = function_type?;
+
+    Some(&function_type.inner().params)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_functype_results(
+    function_type: Option<&wasm_functype_t>,
+) -> Option<&wasm_valtype_vec_t> {
+    let function_type = function_type?;
+
+    Some(&function_type.inner().results)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/global.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/global.rs
new file mode 100644
index 0000000..b15d3e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/global.rs
@@ -0,0 +1,83 @@
+use super::{
+    wasm_externtype_t, wasm_mutability_enum, wasm_mutability_t, wasm_valtype_delete,
+    wasm_valtype_t, WasmExternType,
+};
+use std::convert::TryInto;
+use wasmer_api::{ExternType, GlobalType};
+
+#[derive(Debug, Clone)]
+pub(crate) struct WasmGlobalType {
+    pub(crate) global_type: GlobalType,
+    content: wasm_valtype_t,
+}
+
+impl WasmGlobalType {
+    pub(crate) fn new(global_type: GlobalType) -> Self {
+        let content = global_type.ty.into();
+
+        Self {
+            global_type,
+            content,
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct wasm_globaltype_t {
+    pub(crate) extern_type: wasm_externtype_t,
+}
+
+impl wasm_globaltype_t {
+    pub(crate) fn new(global_type: GlobalType) -> Self {
+        Self {
+            extern_type: wasm_externtype_t::new(ExternType::Global(global_type)),
+        }
+    }
+
+    pub(crate) fn inner(&self) -> &WasmGlobalType {
+        match &self.extern_type.inner {
+            WasmExternType::Global(wasm_global_type) => wasm_global_type,
+            _ => {
+                unreachable!("Data corruption: `wasm_globaltype_t` does not contain a global type")
+            }
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(globaltype);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_new(
+    valtype: Option<Box<wasm_valtype_t>>,
+    mutability: wasm_mutability_t,
+) -> Option<Box<wasm_globaltype_t>> {
+    let valtype = valtype?;
+    let mutability: wasm_mutability_enum = mutability.try_into().ok()?;
+    let global_type = Box::new(wasm_globaltype_t::new(GlobalType::new(
+        (*valtype).into(),
+        mutability.into(),
+    )));
+
+    wasm_valtype_delete(Some(valtype));
+
+    Some(global_type)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_delete(_global_type: Option<Box<wasm_globaltype_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_mutability(
+    global_type: &wasm_globaltype_t,
+) -> wasm_mutability_t {
+    wasm_mutability_enum::from(global_type.inner().global_type.mutability).into()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_globaltype_content(
+    global_type: &wasm_globaltype_t,
+) -> &wasm_valtype_t {
+    &global_type.inner().content
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/import.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/import.rs
new file mode 100644
index 0000000..8be6b99
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/import.rs
@@ -0,0 +1,65 @@
+use super::{wasm_externtype_t, wasm_name_t};
+use wasmer_api::ImportType;
+
+#[allow(non_camel_case_types)]
+#[derive(Clone)]
+#[repr(C)]
+pub struct wasm_importtype_t {
+    module: wasm_name_t,
+    name: wasm_name_t,
+    extern_type: wasm_externtype_t,
+}
+
+wasm_declare_boxed_vec!(importtype);
+wasm_impl_copy!(importtype);
+
+#[no_mangle]
+pub extern "C" fn wasm_importtype_new(
+    module: Option<&mut wasm_name_t>,
+    name: Option<&mut wasm_name_t>,
+    extern_type: Option<Box<wasm_externtype_t>>,
+) -> Option<Box<wasm_importtype_t>> {
+    Some(Box::new(wasm_importtype_t {
+        name: name?.take().into(),
+        module: module?.take().into(),
+        extern_type: *extern_type?,
+    }))
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_importtype_module(import_type: &wasm_importtype_t) -> &wasm_name_t {
+    &import_type.module
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_importtype_name(import_type: &wasm_importtype_t) -> &wasm_name_t {
+    &import_type.name
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_importtype_type(import_type: &wasm_importtype_t) -> &wasm_externtype_t {
+    &import_type.extern_type
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_importtype_delete(_import_type: Option<Box<wasm_importtype_t>>) {}
+
+impl From<ImportType> for wasm_importtype_t {
+    fn from(other: ImportType) -> Self {
+        (&other).into()
+    }
+}
+
+impl From<&ImportType> for wasm_importtype_t {
+    fn from(other: &ImportType) -> Self {
+        let module: wasm_name_t = other.module().to_string().into();
+        let name: wasm_name_t = other.name().to_string().into();
+        let extern_type: wasm_externtype_t = other.ty().into();
+
+        wasm_importtype_t {
+            module,
+            name,
+            extern_type,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/memory.rs
new file mode 100644
index 0000000..0cbbba7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/memory.rs
@@ -0,0 +1,83 @@
+use super::{wasm_externtype_t, WasmExternType};
+use wasmer_api::{ExternType, MemoryType, Pages};
+
+#[derive(Debug, Clone)]
+pub(crate) struct WasmMemoryType {
+    pub(crate) memory_type: MemoryType,
+    limits: wasm_limits_t,
+}
+
+impl WasmMemoryType {
+    pub(crate) fn new(memory_type: MemoryType) -> Self {
+        let limits = wasm_limits_t {
+            min: memory_type.minimum.0 as _,
+            max: memory_type
+                .maximum
+                .map(|max| max.0 as _)
+                .unwrap_or(LIMITS_MAX_SENTINEL),
+        };
+
+        Self {
+            memory_type,
+            limits,
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct wasm_memorytype_t {
+    pub(crate) extern_type: wasm_externtype_t,
+}
+
+impl wasm_memorytype_t {
+    pub(crate) fn new(memory_type: MemoryType) -> Self {
+        Self {
+            extern_type: wasm_externtype_t::new(ExternType::Memory(memory_type)),
+        }
+    }
+
+    pub(crate) fn inner(&self) -> &WasmMemoryType {
+        match &self.extern_type.inner {
+            WasmExternType::Memory(wasm_memory_type) => wasm_memory_type,
+            _ => {
+                unreachable!("Data corruption: `wasm_memorytype_t` does not contain a memory type")
+            }
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(memorytype);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Box<wasm_memorytype_t> {
+    let min_pages = Pages(limits.min as _);
+    let max_pages = if limits.max == LIMITS_MAX_SENTINEL {
+        None
+    } else {
+        Some(Pages(limits.max as _))
+    };
+
+    Box::new(wasm_memorytype_t::new(MemoryType::new(
+        min_pages, max_pages, false,
+    )))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memorytype_delete(_memory_type: Option<Box<wasm_memorytype_t>>) {}
+
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug)]
+#[repr(C)]
+pub struct wasm_limits_t {
+    pub min: u32,
+    pub max: u32,
+}
+
+const LIMITS_MAX_SENTINEL: u32 = u32::max_value();
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_memorytype_limits(memory_type: &wasm_memorytype_t) -> &wasm_limits_t {
+    &memory_type.inner().limits
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mod.rs
new file mode 100644
index 0000000..c5b7ed0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mod.rs
@@ -0,0 +1,42 @@
+mod export;
+mod extern_;
+mod frame;
+mod function;
+mod global;
+mod import;
+mod memory;
+mod mutability;
+mod table;
+mod value;
+
+pub use export::*;
+pub use extern_::*;
+pub use frame::*;
+pub use function::*;
+pub use global::*;
+pub use import::*;
+pub use memory::*;
+pub use mutability::*;
+pub use table::*;
+pub use value::*;
+
+#[allow(non_camel_case_types)]
+pub type wasm_byte_t = u8;
+
+wasm_declare_vec!(byte);
+
+#[allow(non_camel_case_types)]
+pub type wasm_name_t = wasm_byte_vec_t;
+
+impl From<String> for wasm_name_t {
+    fn from(string: String) -> Self {
+        string.into_bytes().into()
+    }
+}
+
+// opaque type over `ExternRef`?
+#[allow(non_camel_case_types)]
+pub struct wasm_ref_t;
+
+#[allow(non_camel_case_types)]
+pub type wasm_message_t = wasm_byte_vec_t;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mutability.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mutability.rs
new file mode 100644
index 0000000..bef1ec1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/mutability.rs
@@ -0,0 +1,56 @@
+use std::convert::TryFrom;
+use wasmer_api::Mutability;
+
+#[allow(non_camel_case_types)]
+pub type wasm_mutability_t = u8;
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum wasm_mutability_enum {
+    WASM_CONST = 0,
+    WASM_VAR,
+}
+
+impl wasm_mutability_enum {
+    #[allow(dead_code)]
+    fn is_mutable(self) -> bool {
+        self == Self::WASM_VAR
+    }
+}
+
+impl TryFrom<wasm_mutability_t> for wasm_mutability_enum {
+    type Error = &'static str;
+
+    fn try_from(item: wasm_mutability_t) -> Result<Self, Self::Error> {
+        Ok(match item {
+            0 => wasm_mutability_enum::WASM_CONST,
+            1 => wasm_mutability_enum::WASM_VAR,
+            _ => return Err("wasm_mutability_t value out of bounds"),
+        })
+    }
+}
+
+impl From<wasm_mutability_enum> for wasm_mutability_t {
+    fn from(other: wasm_mutability_enum) -> Self {
+        other as wasm_mutability_t
+    }
+}
+
+impl From<wasm_mutability_enum> for Mutability {
+    fn from(other: wasm_mutability_enum) -> Self {
+        match other {
+            wasm_mutability_enum::WASM_CONST => Mutability::Const,
+            wasm_mutability_enum::WASM_VAR => Mutability::Var,
+        }
+    }
+}
+
+impl From<Mutability> for wasm_mutability_enum {
+    fn from(other: Mutability) -> Self {
+        match other {
+            Mutability::Const => wasm_mutability_enum::WASM_CONST,
+            Mutability::Var => wasm_mutability_enum::WASM_VAR,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/table.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/table.rs
new file mode 100644
index 0000000..3affb52
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/table.rs
@@ -0,0 +1,91 @@
+use super::{
+    wasm_externtype_t, wasm_limits_t, wasm_valtype_delete, wasm_valtype_t, WasmExternType,
+};
+use wasmer_api::{ExternType, TableType};
+
+#[allow(non_camel_case_types)]
+pub type wasm_table_size_t = u32;
+
+const LIMITS_MAX_SENTINEL: u32 = u32::max_value();
+
+#[derive(Debug, Clone)]
+pub(crate) struct WasmTableType {
+    pub(crate) _table_type: TableType,
+    limits: wasm_limits_t,
+    content: wasm_valtype_t,
+}
+
+impl WasmTableType {
+    pub(crate) fn new(table_type: TableType) -> Self {
+        let limits = wasm_limits_t {
+            min: table_type.minimum as _,
+            max: table_type.maximum.unwrap_or(LIMITS_MAX_SENTINEL),
+        };
+        let content = table_type.ty.into();
+
+        Self {
+            _table_type: table_type,
+            limits,
+            content,
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct wasm_tabletype_t {
+    pub(crate) extern_type: wasm_externtype_t,
+}
+
+impl wasm_tabletype_t {
+    pub(crate) fn new(table_type: TableType) -> Self {
+        Self {
+            extern_type: wasm_externtype_t::new(ExternType::Table(table_type)),
+        }
+    }
+
+    pub(crate) fn inner(&self) -> &WasmTableType {
+        match &self.extern_type.inner {
+            WasmExternType::Table(wasm_table_type) => wasm_table_type,
+            _ => unreachable!("Data corruption: `wasm_tabletype_t` does not contain a table type"),
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(tabletype);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_new(
+    valtype: Option<Box<wasm_valtype_t>>,
+    limits: &wasm_limits_t,
+) -> Option<Box<wasm_tabletype_t>> {
+    let valtype = valtype?;
+    let max_elements = if limits.max == LIMITS_MAX_SENTINEL {
+        None
+    } else {
+        Some(limits.max as _)
+    };
+    let table_type = Box::new(wasm_tabletype_t::new(TableType::new(
+        (*valtype).into(),
+        limits.min as _,
+        max_elements,
+    )));
+
+    wasm_valtype_delete(Some(valtype));
+
+    Some(table_type)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_limits(table_type: &wasm_tabletype_t) -> &wasm_limits_t {
+    &table_type.inner().limits
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_element(table_type: &wasm_tabletype_t) -> &wasm_valtype_t {
+    &table_type.inner().content
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_tabletype_delete(_table_type: Option<Box<wasm_tabletype_t>>) {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/value.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/value.rs
new file mode 100644
index 0000000..ae2189c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/types/value.rs
@@ -0,0 +1,97 @@
+use super::super::value::wasm_valkind_t;
+use std::convert::TryInto;
+use wasmer_api::Type;
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum wasm_valkind_enum {
+    WASM_I32 = 0,
+    WASM_I64 = 1,
+    WASM_F32 = 2,
+    WASM_F64 = 3,
+    WASM_ANYREF = 128,
+    WASM_FUNCREF = 129,
+}
+
+impl From<Type> for wasm_valkind_enum {
+    fn from(other: Type) -> Self {
+        match other {
+            Type::I32 => Self::WASM_I32,
+            Type::I64 => Self::WASM_I64,
+            Type::F32 => Self::WASM_F32,
+            Type::F64 => Self::WASM_F64,
+            Type::V128 => todo!("no v128 type in Wasm C API yet!"),
+            Type::ExternRef => Self::WASM_ANYREF,
+            Type::FuncRef => Self::WASM_FUNCREF,
+        }
+    }
+}
+
+impl From<wasm_valkind_enum> for Type {
+    fn from(other: wasm_valkind_enum) -> Self {
+        use wasm_valkind_enum::*;
+        match other {
+            WASM_I32 => Type::I32,
+            WASM_I64 => Type::I64,
+            WASM_F32 => Type::F32,
+            WASM_F64 => Type::F64,
+            WASM_ANYREF => Type::ExternRef,
+            WASM_FUNCREF => Type::FuncRef,
+        }
+    }
+}
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Copy)]
+pub struct wasm_valtype_t {
+    valkind: wasm_valkind_enum,
+}
+
+impl Default for wasm_valtype_t {
+    fn default() -> Self {
+        Self {
+            valkind: wasm_valkind_enum::WASM_I32,
+        }
+    }
+}
+
+wasm_declare_boxed_vec!(valtype);
+
+impl From<wasm_valtype_t> for Type {
+    fn from(other: wasm_valtype_t) -> Self {
+        (&other).into()
+    }
+}
+
+impl From<&wasm_valtype_t> for Type {
+    fn from(other: &wasm_valtype_t) -> Self {
+        other.valkind.into()
+    }
+}
+
+impl From<Type> for wasm_valtype_t {
+    fn from(other: Type) -> Self {
+        Self {
+            valkind: other.into(),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wasm_valtype_new(kind: wasm_valkind_t) -> Option<Box<wasm_valtype_t>> {
+    let kind_enum = kind.try_into().ok()?;
+    let valtype = wasm_valtype_t { valkind: kind_enum };
+
+    Some(Box::new(valtype))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_valtype_delete(_valtype: Option<Box<wasm_valtype_t>>) {}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_valtype_kind(valtype: Option<&wasm_valtype_t>) -> wasm_valkind_t {
+    valtype
+        .expect("`wasm_valtype_kind: argument is a null pointer")
+        .valkind as wasm_valkind_t
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/engine.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/engine.rs
new file mode 100644
index 0000000..fe3d53c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/engine.rs
@@ -0,0 +1,257 @@
+//! Unstable non-standard Wasmer-specific types for the
+//! `wasm_engine_t` and siblings.
+
+#[cfg(feature = "compiler")]
+use super::super::engine::wasmer_compiler_t;
+use super::super::engine::{wasm_config_t, wasmer_engine_t};
+
+use super::features::wasmer_features_t;
+use super::target_lexicon::wasmer_target_t;
+
+/// Unstable non-standard Wasmer-specific API to update the
+/// configuration to specify a particular target for the engine.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Set the target.
+///     {
+///         wasmer_triple_t* triple = wasmer_triple_new_from_host();
+///         wasmer_cpu_features_t* cpu_features = wasmer_cpu_features_new();
+///         wasmer_target_t* target = wasmer_target_new(triple, cpu_features);
+///
+///         wasm_config_set_target(config, target);
+///     }
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_set_target(config: &mut wasm_config_t, target: Box<wasmer_target_t>) {
+    config.target = Some(target);
+}
+
+/// Unstable non-standard Wasmer-specific API to update the
+/// configuration to specify particular features for the engine.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Set the target.
+///     {
+///         wasmer_features_t* features = wasmer_features_new();
+///         wasmer_features_simd(features, true);
+///
+///         wasm_config_set_features(config, features);
+///     }
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_set_features(
+    config: &mut wasm_config_t,
+    features: Box<wasmer_features_t>,
+) {
+    config.features = Some(features);
+}
+
+/// Updates the configuration to enable NaN canonicalization.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the configuration.
+///     wasm_config_t* config = wasm_config_new();
+///
+///     // Enable NaN canonicalization.
+///     wasm_config_canonicalize_nans(config, true);
+///
+///     // Create the engine.
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     // Check we have an engine!
+///     assert(engine);
+///
+///     // Free everything.
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub extern "C" fn wasm_config_canonicalize_nans(config: &mut wasm_config_t, enable: bool) {
+    config.nan_canonicalization = enable;
+}
+
+/// Check whether the given compiler is available, i.e. part of this
+/// compiled library.
+#[no_mangle]
+#[cfg(feature = "compiler")]
+pub extern "C" fn wasmer_is_compiler_available(compiler: wasmer_compiler_t) -> bool {
+    match compiler {
+        wasmer_compiler_t::CRANELIFT if cfg!(feature = "cranelift") => true,
+        wasmer_compiler_t::LLVM if cfg!(feature = "llvm") => true,
+        wasmer_compiler_t::SINGLEPASS if cfg!(feature = "singlepass") => true,
+        _ => false,
+    }
+}
+
+/// Check whether there is no compiler available in this compiled
+/// library.
+#[no_mangle]
+pub extern "C" fn wasmer_is_headless() -> bool {
+    !cfg!(feature = "compiler")
+}
+
+/// Check whether the given engine is available, i.e. part of this
+/// compiled library.
+#[no_mangle]
+pub extern "C" fn wasmer_is_engine_available(engine: wasmer_engine_t) -> bool {
+    matches!(engine, wasmer_engine_t::UNIVERSAL if cfg!(feature = "compiler"))
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    use std::env::{remove_var, set_var};
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[test]
+    fn test_wasmer_is_headless() {
+        set_var(
+            "COMPILER",
+            if cfg!(feature = "compiler") { "0" } else { "1" },
+        );
+
+        (assert_c! {
+            #include "tests/wasmer.h"
+            #include <stdlib.h>
+
+            int main() {
+                assert(wasmer_is_headless() == (getenv("COMPILER")[0] == '1'));
+
+                return 0;
+            }
+        })
+        .success();
+
+        remove_var("COMPILER");
+    }
+
+    #[test]
+    fn test_wasmer_is_compiler_available() {
+        set_var(
+            "CRANELIFT",
+            if cfg!(feature = "cranelift") {
+                "1"
+            } else {
+                "0"
+            },
+        );
+        set_var("LLVM", if cfg!(feature = "llvm") { "1" } else { "0" });
+        set_var(
+            "SINGLEPASS",
+            if cfg!(feature = "singlepass") {
+                "1"
+            } else {
+                "0"
+            },
+        );
+
+        (assert_c! {
+            #include "tests/wasmer.h"
+            #include <stdlib.h>
+
+            int main() {
+                assert(wasmer_is_compiler_available(CRANELIFT) == (getenv("CRANELIFT")[0] == '1'));
+                assert(wasmer_is_compiler_available(LLVM) == (getenv("LLVM")[0] == '1'));
+                assert(wasmer_is_compiler_available(SINGLEPASS) == (getenv("SINGLEPASS")[0] == '1'));
+
+                return 0;
+            }
+        })
+        .success();
+
+        remove_var("CRANELIFT");
+        remove_var("LLVM");
+        remove_var("SINGLEPASS");
+    }
+
+    #[test]
+    fn test_wasmer_is_engine_available() {
+        set_var(
+            "UNIVERSAL",
+            if cfg!(feature = "compiler") { "1" } else { "0" },
+        );
+
+        (assert_c! {
+            #include "tests/wasmer.h"
+            #include <stdlib.h>
+
+            int main() {
+                assert(wasmer_is_engine_available(UNIVERSAL) == (getenv("UNIVERSAL")[0] == '1'));
+
+                return 0;
+            }
+        })
+        .success();
+
+        remove_var("UNIVERSAL");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/features.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/features.rs
new file mode 100644
index 0000000..b00cffb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/features.rs
@@ -0,0 +1,364 @@
+//! Unstable non-standard Wasmer-specific API that contains a Features
+//! API for the engine and the compiler.
+//!
+//!
+//! # Example
+//!
+//! ```rust
+//! # use wasmer_inline_c::assert_c;
+//! # fn main() {
+//! #    (assert_c! {
+//! # #include "tests/wasmer.h"
+//! #
+//! int main() {
+//!     // Declare features.
+//!     wasmer_features_t* features = wasmer_features_new();
+//!
+//!     // Now, let's enable de SIMD feature.
+//!     wasmer_features_simd(features, true);
+//!
+//!     // And also the memory64 feature.     
+//!     wasmer_features_memory64(features, true);
+//!
+//!     wasmer_features_delete(features);
+//!
+//!     return 0;
+//! }
+//! #    })
+//! #    .success();
+//! # }
+//! ```
+//!
+//! To go further, see
+//! [`wasm_config_set_features`](super::engine::wasm_config_set_features).
+
+use wasmer_types::Features;
+
+/// Controls which experimental features will be enabled.
+/// Features usually have a corresponding [WebAssembly proposal].
+///
+/// [WebAssembly proposal]: https://github.com/WebAssembly/proposals
+///
+/// # Example
+///
+/// See the module's documentation.
+#[derive(Debug)]
+#[allow(non_camel_case_types)]
+pub struct wasmer_features_t {
+    pub(crate) inner: Features,
+}
+
+/// Creates a new [`wasmer_features_t`].
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_new() -> Box<wasmer_features_t> {
+    Box::new(wasmer_features_t {
+        inner: Features::new(),
+    })
+}
+
+/// Delete a [`wasmer_features_t`].
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_delete(_features: Option<Box<wasmer_features_t>>) {}
+
+/// Configures whether the WebAssembly threads proposal will be enabled.
+///
+/// The [WebAssembly threads proposal][threads] is not currently fully
+/// standardized and is undergoing development. Support for this feature can
+/// be disabled through this method for appropriate WebAssembly modules.
+///
+/// This feature gates items such as shared memories and atomic
+/// instructions.
+///
+/// This is `true` by default.
+///
+/// [threads]: https://github.com/webassembly/threads
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_threads(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.threads(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly reference types proposal will be
+/// enabled.
+///
+/// The [WebAssembly reference types proposal][proposal] is not currently
+/// fully standardized and is undergoing development. Support for this
+/// feature can be enabled through this method for appropriate WebAssembly
+/// modules.
+///
+/// This feature gates items such as the `externref` type and multiple tables
+/// being in a module. Note that enabling the reference types feature will
+/// also enable the bulk memory feature.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/reference-types
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_reference_types(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.reference_types(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly SIMD proposal will be
+/// enabled.
+///
+/// The [WebAssembly SIMD proposal][proposal] is not currently
+/// fully standardized and is undergoing development. Support for this
+/// feature can be enabled through this method for appropriate WebAssembly
+/// modules.
+///
+/// This feature gates items such as the `v128` type and all of its
+/// operators being in a module.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/simd
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_simd(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.simd(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly bulk memory operations proposal will
+/// be enabled.
+///
+/// The [WebAssembly bulk memory operations proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature gates items such as the `memory.copy` instruction, passive
+/// data/table segments, etc, being in a module.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/bulk-memory-operations
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_bulk_memory(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.bulk_memory(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly multi-value proposal will
+/// be enabled.
+///
+/// The [WebAssembly multi-value proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature gates functions and blocks returning multiple values in a
+/// module, for example.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/multi-value
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_multi_value(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.multi_value(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly tail-call proposal will
+/// be enabled.
+///
+/// The [WebAssembly tail-call proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature gates tail-call functions in WebAssembly.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/tail-call
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_tail_call(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.tail_call(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly tail-call proposal will
+/// be enabled.
+///
+/// The [WebAssembly tail-call proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature allows WebAssembly modules to define, import and
+/// export modules and instances.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/webassembly/module-linking
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_module_linking(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.module_linking(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly multi-memory proposal will
+/// be enabled.
+///
+/// The [WebAssembly multi-memory proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature adds the ability to use multiple memories within a
+/// single Wasm module.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/WebAssembly/multi-memory
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_multi_memory(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.multi_memory(enable);
+
+    true
+}
+
+/// Configures whether the WebAssembly 64-bit memory proposal will
+/// be enabled.
+///
+/// The [WebAssembly 64-bit memory proposal][proposal] is not
+/// currently fully standardized and is undergoing development.
+/// Support for this feature can be enabled through this method for
+/// appropriate WebAssembly modules.
+///
+/// This feature gates support for linear memory of sizes larger than
+/// 2^32 bits.
+///
+/// This is `false` by default.
+///
+/// [proposal]: https://github.com/WebAssembly/memory64
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_features_memory64(
+    features: Option<&mut wasmer_features_t>,
+    enable: bool,
+) -> bool {
+    let features = match features {
+        Some(features) => features,
+        _ => return false,
+    };
+
+    features.inner.memory64(enable);
+
+    true
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs
new file mode 100644
index 0000000..41958ea
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/metering.rs
@@ -0,0 +1,326 @@
+//! Unstable non-standard Wasmer-specific API that contains everything
+//! to create the middleware metering API.
+//!
+//! The metering middleware is used for tracking how many operators
+//! are executed in total and putting a limit on the total number of
+//! operators executed.
+//!
+//! # Example
+//!
+//! ```rust
+//! # use wasmer_inline_c::assert_c;
+//! # fn main() {
+//! #    (assert_c! {
+//! # #include "tests/wasmer.h"
+//! #
+//! // Define our “cost function”.
+//! uint64_t cost_function(wasmer_parser_operator_t wasm_operator) {
+//!     switch(wasm_operator) {
+//!         // `local.get` and `i32.const` cost 1 unit.
+//!         case LocalGet:
+//!         case I32Const:
+//!             return 1;
+//!
+//!         // `i32.add` costs 2 units.
+//!         case I32Add:
+//!             return 2;
+//!
+//!         // The other operations are free.
+//!         default:
+//!             return 0;
+//!     }
+//! }
+//!
+//! int main() {
+//!     // Create a new metering middleware, with our cost function.
+//!     wasmer_metering_t* metering = wasmer_metering_new(10, cost_function);
+//!
+//!     // Consume `metering` to produce a generic `wasmer_middleware_t` value.
+//!     wasmer_middleware_t* middleware = wasmer_metering_as_middleware(metering);
+//!     
+//!     // Create a new configuration, and push the middleware in it.
+//!     wasm_config_t* config = wasm_config_new();
+//!     wasm_config_push_middleware(config, middleware);
+//!     
+//!     // Create the engine and the store based on the configuration.
+//!     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+//!     wasm_store_t* store = wasm_store_new(engine);
+//!     
+//!     // Create the new WebAssembly module.
+//!     wasm_byte_vec_t wat;
+//!     wasmer_byte_vec_new_from_string(
+//!         &wat,
+//!         "(module\n"
+//!         "  (type $add_t (func (param i32) (result i32)))\n"
+//!         "  (func $add_two_f (type $add_t) (param $value i32) (result i32)\n"
+//!         "    local.get $value\n"
+//!         "    i32.const 1\n"
+//!         "    i32.add)\n"
+//!         "  (export \"add_two\" (func $add_two_f)))"
+//!     );
+//!     wasm_byte_vec_t wasm;
+//!     wat2wasm(&wat, &wasm);
+//!
+//!     wasm_module_t* module = wasm_module_new(store, &wasm);
+//!     assert(module);
+//!     
+//!     // Instantiate the module.
+//!     wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+//!     wasm_trap_t* trap = NULL;
+//!     wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+//!     assert(instance);
+//!     
+//!     // Here we go. At this step, we will get the `add_two` exported function, and
+//!     // call it.
+//!     wasm_extern_vec_t exports;
+//!     wasm_instance_exports(instance, &exports);
+//!     assert(exports.size >= 1);
+//!     assert(wasm_extern_kind(exports.data[0]) == WASM_EXTERN_FUNC);
+//!
+//!     const wasm_func_t* add_two = wasm_extern_as_func(exports.data[0]);
+//!     assert(add_two);
+//!
+//!     wasm_val_t arguments[1] = { WASM_I32_VAL(41) };
+//!     wasm_val_t results[1] = { WASM_INIT_VAL };
+//!
+//!     wasm_val_vec_t arguments_as_array = WASM_ARRAY_VEC(arguments);
+//!     wasm_val_vec_t results_as_array = WASM_ARRAY_VEC(results);
+//!
+//!     // Let's call `add_two` for the first time!
+//!     {
+//!         trap = wasm_func_call(add_two, &arguments_as_array, &results_as_array);
+//!         assert(trap == NULL);
+//!         assert(results[0].of.i32 == 42);
+//!
+//!         // There is 6 points left!
+//!         assert(wasmer_metering_get_remaining_points(instance) == 6);
+//!         assert(wasmer_metering_points_are_exhausted(instance) == false);
+//!     }
+//!
+//!     // Let's call `add_two` for the second time!
+//!     {
+//!         trap = wasm_func_call(add_two, &arguments_as_array, &results_as_array);
+//!         assert(trap == NULL);
+//!         assert(results[0].of.i32 == 42);
+//!
+//!         // There is 2 points left!
+//!         assert(wasmer_metering_get_remaining_points(instance) == 2);
+//!         assert(wasmer_metering_points_are_exhausted(instance) == false);
+//!     }
+//!
+//!     // Let's call `add_two` for the third time!
+//!     {
+//!         trap = wasm_func_call(add_two, &arguments_as_array, &results_as_array);
+//!         // Oh, it failed!
+//!         assert(trap != NULL);
+//!
+//!         // There is 0 point left… they are exhausted.
+//!         assert(wasmer_metering_points_are_exhausted(instance) == true);
+//!     }
+//!
+//!     wasm_extern_vec_delete(&exports);
+//!     wasm_instance_delete(instance);
+//!     wasm_module_delete(module);
+//!     wasm_store_delete(store);
+//!     wasm_engine_delete(engine);
+//!
+//!     return 0;
+//! }
+//! #    })
+//! #    .success();
+//! # }
+//! ```
+
+use super::super::super::instance::wasm_instance_t;
+use super::super::parser::operator::wasmer_parser_operator_t;
+use super::wasmer_middleware_t;
+use std::sync::Arc;
+use wasmer_api::wasmparser::Operator;
+use wasmer_middlewares::{
+    metering::{get_remaining_points, set_remaining_points, MeteringPoints},
+    Metering,
+};
+
+/// Opaque type representing a metering middleware.
+///
+/// To transform this specific middleware into a generic one, please
+/// see [`wasmer_metering_as_middleware`].
+///
+/// # Example
+///
+/// See module's documentation.
+#[allow(non_camel_case_types, clippy::type_complexity)]
+pub struct wasmer_metering_t {
+    pub(crate) inner: Arc<Metering<Box<dyn Fn(&Operator) -> u64 + Send + Sync>>>,
+}
+
+/// Function type to represent a user-defined cost function
+/// implemented in C.
+///
+/// # Example
+///
+/// See module's documentation.
+#[allow(non_camel_case_types)]
+pub type wasmer_metering_cost_function_t =
+    extern "C" fn(wasm_operator: wasmer_parser_operator_t) -> u64;
+
+/// Creates a new metering middleware with an initial limit, i.e. a
+/// total number of operators to execute (regarding their respective
+/// cost), in addition to a cost function. The cost function defines
+/// the cost of an operation, that will decrease the initial limit.
+///
+/// # Example
+///
+/// See module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_metering_new(
+    initial_limit: u64,
+    cost_function: wasmer_metering_cost_function_t,
+) -> Box<wasmer_metering_t> {
+    let cost_function = move |operator: &Operator| -> u64 { cost_function(operator.into()) };
+
+    Box::new(wasmer_metering_t {
+        inner: Arc::new(Metering::new(initial_limit, Box::new(cost_function))),
+    })
+}
+
+/// Deletes a [`wasmer_metering_t`].
+///
+/// # Example
+///
+/// See module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_metering_delete(_metering: Option<Box<wasmer_metering_t>>) {}
+
+/// Returns the remaining metering points. `u64::MAX` means
+/// points are exhausted, otherwise it returns the number of
+/// points. Notice that it could include zero! Zero doesn't mean
+/// points are exhausted _yet_.
+///
+/// # Example
+///
+/// See module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_metering_get_remaining_points(
+    instance: &mut wasm_instance_t,
+) -> u64 {
+    match get_remaining_points(&mut instance.store.store_mut(), &instance.inner) {
+        MeteringPoints::Remaining(value) => value,
+        MeteringPoints::Exhausted => std::u64::MAX,
+    }
+}
+
+/// Returns true if the remaning points are exhausted, false otherwise.
+///
+/// # Example
+///
+/// See module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_metering_points_are_exhausted(
+    instance: &mut wasm_instance_t,
+) -> bool {
+    matches!(
+        get_remaining_points(&mut instance.store.store_mut(), &instance.inner),
+        MeteringPoints::Exhausted,
+    )
+}
+
+/// Set a new amount of points for the given metering middleware.
+///
+/// # Example
+///
+/// This example only illustrates the
+/// `wasmer_metering_set_remaining_points` function, as the number of
+/// points aren't updated by the WebAssembly module execution
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// // Define a dummy “cost function”.
+/// uint64_t cost_function(wasmer_parser_operator_t wasm_operator) {
+///     switch(wasm_operator) {
+///         default:
+///             return 0;
+///     }
+/// }
+///
+/// int main() {
+///     // Set the initial amount of points to 7.
+///     wasmer_metering_t* metering = wasmer_metering_new(7, cost_function);
+///
+///     // Consume `metering` to produce `middleware`.
+///     wasmer_middleware_t* middleware = wasmer_metering_as_middleware(metering);
+///
+///     // Create the configuration (which consumes `middleware`),
+///     // the engine, and the store.
+///     wasm_config_t* config = wasm_config_new();
+///     wasm_config_push_middleware(config, middleware);
+///     
+///     wasm_engine_t* engine = wasm_engine_new_with_config(config);
+///
+///     wasm_store_t* store = wasm_store_new(engine);
+///     
+///     // Create the module and instantiate it.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module)");
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///     assert(module);
+///     
+///     wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+///     wasm_trap_t* trap = NULL;
+///     wasm_instance_t* instance = wasm_instance_new(store, module, &imports, &trap);
+///     assert(instance);
+///
+///     // Read the number of points.
+///     assert(wasmer_metering_get_remaining_points(instance) == 7);
+///
+///     // Set a new number of points.
+///     wasmer_metering_set_remaining_points(instance, 42);
+///
+///     // Read the number of points.
+///     assert(wasmer_metering_get_remaining_points(instance) == 42);
+///
+///     wasm_instance_delete(instance);
+///     wasm_module_delete(module);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_metering_set_remaining_points(
+    instance: &mut wasm_instance_t,
+    new_limit: u64,
+) {
+    set_remaining_points(&mut instance.store.store_mut(), &instance.inner, new_limit);
+}
+
+/// Transforms a [`wasmer_metering_t`] into a generic
+/// [`wasmer_middleware_t`], to then be pushed in the configuration with
+/// [`wasm_config_push_middleware`][super::wasm_config_push_middleware].
+///
+/// This function takes ownership of `metering`.
+///
+/// # Example
+///
+/// See module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_metering_as_middleware(
+    metering: Option<Box<wasmer_metering_t>>,
+) -> Option<Box<wasmer_middleware_t>> {
+    let metering = metering?;
+
+    Some(Box::new(wasmer_middleware_t {
+        inner: metering.inner,
+    }))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs
new file mode 100644
index 0000000..238154b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/middlewares/mod.rs
@@ -0,0 +1,40 @@
+//! Unstable non-standard Wasmer-specific types to manipulate module
+//! middlewares.
+
+pub mod metering;
+
+use super::super::engine::wasm_config_t;
+use std::sync::Arc;
+use wasmer_api::ModuleMiddleware;
+
+#[cfg(all(feature = "middlewares", not(feature = "compiler")))]
+compile_error!("The `middlewares` feature requires the `compiler` feature to be turned on");
+
+/// Opaque representing any kind of middleware.
+///
+/// Used by `wasm_config_push_middleware`. A specific middleware is
+/// transformed into this type to get a generic middleware. See for
+/// example
+/// [`wasmer_metering_as_middleware`][metering::wasmer_metering_as_middleware].
+#[derive(Debug)]
+#[allow(non_camel_case_types)]
+pub struct wasmer_middleware_t {
+    pub(in crate::wasm_c_api) inner: Arc<dyn ModuleMiddleware>,
+}
+
+/// Updates the configuration to add a module middleware.
+///
+/// This function takes ownership of `middleware`.
+///
+/// This is a Wasmer-specific function.
+///
+/// # Example
+///
+/// See the documentation of the [`metering`] module.
+#[no_mangle]
+pub extern "C" fn wasm_config_push_middleware(
+    config: &mut wasm_config_t,
+    middleware: Box<wasmer_middleware_t>,
+) {
+    config.middlewares.push(*middleware);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/mod.rs
new file mode 100644
index 0000000..be245f1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/mod.rs
@@ -0,0 +1,10 @@
+pub mod engine;
+pub mod features;
+#[cfg(feature = "middlewares")]
+pub mod middlewares;
+pub mod module;
+#[cfg(feature = "compiler")]
+pub mod parser;
+pub mod target_lexicon;
+#[cfg(feature = "wasi")]
+pub mod wasi;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/module.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/module.rs
new file mode 100644
index 0000000..7fdbf88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/module.rs
@@ -0,0 +1,181 @@
+//! Unstable non-standard Wasmer-specific extensions to the Wasm C API.
+
+use super::super::engine::wasm_engine_t;
+use super::super::module::wasm_module_t;
+use super::super::types::{wasm_byte_vec_t, wasm_name_t};
+use std::ptr;
+use std::str;
+use wasmer_api::Module;
+
+/// Unstable non-standard Wasmer-specific API to get the module's
+/// name, otherwise `out->size` is set to `0` and `out->data` to
+/// `NULL`.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module $moduleName)");
+///     //                                             ^~~~~~~~~~~ that's the name!
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///
+///     // Read the module's name.
+///     wasm_name_t name;
+///     wasmer_module_name(module, &name);
+///
+///     // It works!
+///     wasmer_assert_name(&name, "moduleName");
+///
+///     // Free everything.
+///     wasm_byte_vec_delete(&name);
+///     wasm_module_delete(module);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_module_name(
+    module: &wasm_module_t,
+    // own
+    out: &mut wasm_name_t,
+) {
+    let name = match module.inner.name() {
+        Some(name) => name,
+        None => {
+            out.data = ptr::null_mut();
+            out.size = 0;
+
+            return;
+        }
+    };
+
+    out.set_buffer(name.as_bytes().to_vec());
+}
+
+/// Unstable non-standard Wasmer-specific API to set the module's
+/// name. The function returns `true` if the name has been updated,
+/// `false` otherwise.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create the engine and the store.
+///     wasm_engine_t* engine = wasm_engine_new();
+///     wasm_store_t* store = wasm_store_new(engine);
+///
+///     // Create a WebAssembly module from a WAT definition.
+///     wasm_byte_vec_t wat;
+///     wasmer_byte_vec_new_from_string(&wat, "(module)");
+///     wasm_byte_vec_t wasm;
+///     wat2wasm(&wat, &wasm);
+///
+///     // Create the module.
+///     wasm_module_t* module = wasm_module_new(store, &wasm);
+///
+///     // Read the module's name. There is none for the moment.
+///     {
+///         wasm_name_t name;
+///         wasmer_module_name(module, &name);
+///
+///         assert(name.size == 0);
+///     }
+///
+///     // So, let's set a new name.
+///     {
+///         wasm_name_t name;
+///         wasmer_byte_vec_new_from_string(&name, "hello");
+///         wasmer_module_set_name(module, &name);
+///     }
+///
+///     // And now, let's see the new name.
+///     {
+///         wasm_name_t name;
+///         wasmer_module_name(module, &name);
+///
+///         // It works!
+///         wasmer_assert_name(&name, "hello");
+///
+///         wasm_byte_vec_delete(&name);
+///     }
+///
+///     // Free everything.
+///     wasm_module_delete(module);
+///     wasm_byte_vec_delete(&wasm);
+///     wasm_byte_vec_delete(&wat);
+///     wasm_store_delete(store);
+///     wasm_engine_delete(engine);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_module_set_name(
+    module: &mut wasm_module_t,
+    // own
+    name: &wasm_name_t,
+) -> bool {
+    let name = match str::from_utf8(name.as_slice()) {
+        Ok(name) => name,
+        Err(_) => return false, // not ideal!
+    };
+
+    module.inner.set_name(name)
+}
+
+/// A WebAssembly module contains stateless WebAssembly code that has
+/// already been compiled and can be instantiated multiple times.
+///
+/// Creates a new WebAssembly Module using the provided engine,
+/// respecting its configuration.
+///
+/// ## Security
+///
+/// Before the code is compiled, it will be validated using the engine
+/// features.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_module_new(
+    engine: Option<&mut wasm_engine_t>,
+    bytes: Option<&wasm_byte_vec_t>,
+) -> Option<Box<wasm_module_t>> {
+    let engine: wasmer_api::Engine = engine?.inner.clone().into();
+    let bytes = bytes?;
+
+    let module = c_try!(Module::from_binary(&engine, bytes.as_slice()));
+
+    Some(Box::new(wasm_module_t { inner: module }))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/mod.rs
new file mode 100644
index 0000000..f4086e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/mod.rs
@@ -0,0 +1,3 @@
+//! Unstable non-standard Wasmer-specific types about WebAssembly parser.
+
+pub mod operator;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/operator.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/operator.rs
new file mode 100644
index 0000000..8a50317
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/parser/operator.rs
@@ -0,0 +1,1080 @@
+use wasmer_api::wasmparser::Operator;
+
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum wasmer_parser_operator_t {
+    Unreachable,
+    Nop,
+    Block,
+    Loop,
+    If,
+    Else,
+    Try,
+    Catch,
+    CatchAll,
+    Delegate,
+    Throw,
+    Rethrow,
+    Unwind,
+    End,
+    Br,
+    BrIf,
+    BrTable,
+    Return,
+    Call,
+    CallIndirect,
+    ReturnCall,
+    ReturnCallIndirect,
+    Drop,
+    Select,
+    TypedSelect,
+    LocalGet,
+    LocalSet,
+    LocalTee,
+    GlobalGet,
+    GlobalSet,
+    I32Load,
+    I64Load,
+    F32Load,
+    F64Load,
+    I32Load8S,
+    I32Load8U,
+    I32Load16S,
+    I32Load16U,
+    I64Load8S,
+    I64Load8U,
+    I64Load16S,
+    I64Load16U,
+    I64Load32S,
+    I64Load32U,
+    I32Store,
+    I64Store,
+    F32Store,
+    F64Store,
+    I32Store8,
+    I32Store16,
+    I64Store8,
+    I64Store16,
+    I64Store32,
+    MemorySize,
+    MemoryGrow,
+    I32Const,
+    I64Const,
+    F32Const,
+    F64Const,
+    RefNull,
+    RefIsNull,
+    RefFunc,
+    I32Eqz,
+    I32Eq,
+    I32Ne,
+    I32LtS,
+    I32LtU,
+    I32GtS,
+    I32GtU,
+    I32LeS,
+    I32LeU,
+    I32GeS,
+    I32GeU,
+    I64Eqz,
+    I64Eq,
+    I64Ne,
+    I64LtS,
+    I64LtU,
+    I64GtS,
+    I64GtU,
+    I64LeS,
+    I64LeU,
+    I64GeS,
+    I64GeU,
+    F32Eq,
+    F32Ne,
+    F32Lt,
+    F32Gt,
+    F32Le,
+    F32Ge,
+    F64Eq,
+    F64Ne,
+    F64Lt,
+    F64Gt,
+    F64Le,
+    F64Ge,
+    I32Clz,
+    I32Ctz,
+    I32Popcnt,
+    I32Add,
+    I32Sub,
+    I32Mul,
+    I32DivS,
+    I32DivU,
+    I32RemS,
+    I32RemU,
+    I32And,
+    I32Or,
+    I32Xor,
+    I32Shl,
+    I32ShrS,
+    I32ShrU,
+    I32Rotl,
+    I32Rotr,
+    I64Clz,
+    I64Ctz,
+    I64Popcnt,
+    I64Add,
+    I64Sub,
+    I64Mul,
+    I64DivS,
+    I64DivU,
+    I64RemS,
+    I64RemU,
+    I64And,
+    I64Or,
+    I64Xor,
+    I64Shl,
+    I64ShrS,
+    I64ShrU,
+    I64Rotl,
+    I64Rotr,
+    F32Abs,
+    F32Neg,
+    F32Ceil,
+    F32Floor,
+    F32Trunc,
+    F32Nearest,
+    F32Sqrt,
+    F32Add,
+    F32Sub,
+    F32Mul,
+    F32Div,
+    F32Min,
+    F32Max,
+    F32Copysign,
+    F64Abs,
+    F64Neg,
+    F64Ceil,
+    F64Floor,
+    F64Trunc,
+    F64Nearest,
+    F64Sqrt,
+    F64Add,
+    F64Sub,
+    F64Mul,
+    F64Div,
+    F64Min,
+    F64Max,
+    F64Copysign,
+    I32WrapI64,
+    I32TruncF32S,
+    I32TruncF32U,
+    I32TruncF64S,
+    I32TruncF64U,
+    I64ExtendI32S,
+    I64ExtendI32U,
+    I64TruncF32S,
+    I64TruncF32U,
+    I64TruncF64S,
+    I64TruncF64U,
+    F32ConvertI32S,
+    F32ConvertI32U,
+    F32ConvertI64S,
+    F32ConvertI64U,
+    F32DemoteF64,
+    F64ConvertI32S,
+    F64ConvertI32U,
+    F64ConvertI64S,
+    F64ConvertI64U,
+    F64PromoteF32,
+    I32ReinterpretF32,
+    I64ReinterpretF64,
+    F32ReinterpretI32,
+    F64ReinterpretI64,
+    I32Extend8S,
+    I32Extend16S,
+    I64Extend8S,
+    I64Extend16S,
+    I64Extend32S,
+    I32TruncSatF32S,
+    I32TruncSatF32U,
+    I32TruncSatF64S,
+    I32TruncSatF64U,
+    I64TruncSatF32S,
+    I64TruncSatF32U,
+    I64TruncSatF64S,
+    I64TruncSatF64U,
+    MemoryInit,
+    DataDrop,
+    MemoryCopy,
+    MemoryFill,
+    TableInit,
+    ElemDrop,
+    TableCopy,
+    TableFill,
+    TableGet,
+    TableSet,
+    TableGrow,
+    TableSize,
+    MemoryAtomicNotify,
+    MemoryAtomicWait32,
+    MemoryAtomicWait64,
+    AtomicFence,
+    I32AtomicLoad,
+    I64AtomicLoad,
+    I32AtomicLoad8U,
+    I32AtomicLoad16U,
+    I64AtomicLoad8U,
+    I64AtomicLoad16U,
+    I64AtomicLoad32U,
+    I32AtomicStore,
+    I64AtomicStore,
+    I32AtomicStore8,
+    I32AtomicStore16,
+    I64AtomicStore8,
+    I64AtomicStore16,
+    I64AtomicStore32,
+    I32AtomicRmwAdd,
+    I64AtomicRmwAdd,
+    I32AtomicRmw8AddU,
+    I32AtomicRmw16AddU,
+    I64AtomicRmw8AddU,
+    I64AtomicRmw16AddU,
+    I64AtomicRmw32AddU,
+    I32AtomicRmwSub,
+    I64AtomicRmwSub,
+    I32AtomicRmw8SubU,
+    I32AtomicRmw16SubU,
+    I64AtomicRmw8SubU,
+    I64AtomicRmw16SubU,
+    I64AtomicRmw32SubU,
+    I32AtomicRmwAnd,
+    I64AtomicRmwAnd,
+    I32AtomicRmw8AndU,
+    I32AtomicRmw16AndU,
+    I64AtomicRmw8AndU,
+    I64AtomicRmw16AndU,
+    I64AtomicRmw32AndU,
+    I32AtomicRmwOr,
+    I64AtomicRmwOr,
+    I32AtomicRmw8OrU,
+    I32AtomicRmw16OrU,
+    I64AtomicRmw8OrU,
+    I64AtomicRmw16OrU,
+    I64AtomicRmw32OrU,
+    I32AtomicRmwXor,
+    I64AtomicRmwXor,
+    I32AtomicRmw8XorU,
+    I32AtomicRmw16XorU,
+    I64AtomicRmw8XorU,
+    I64AtomicRmw16XorU,
+    I64AtomicRmw32XorU,
+    I32AtomicRmwXchg,
+    I64AtomicRmwXchg,
+    I32AtomicRmw8XchgU,
+    I32AtomicRmw16XchgU,
+    I64AtomicRmw8XchgU,
+    I64AtomicRmw16XchgU,
+    I64AtomicRmw32XchgU,
+    I32AtomicRmwCmpxchg,
+    I64AtomicRmwCmpxchg,
+    I32AtomicRmw8CmpxchgU,
+    I32AtomicRmw16CmpxchgU,
+    I64AtomicRmw8CmpxchgU,
+    I64AtomicRmw16CmpxchgU,
+    I64AtomicRmw32CmpxchgU,
+    V128Load,
+    V128Store,
+    V128Const,
+    I8x16Splat,
+    I8x16ExtractLaneS,
+    I8x16ExtractLaneU,
+    I8x16ReplaceLane,
+    I16x8Splat,
+    I16x8ExtractLaneS,
+    I16x8ExtractLaneU,
+    I16x8ReplaceLane,
+    I32x4Splat,
+    I32x4ExtractLane,
+    I32x4ReplaceLane,
+    I64x2Splat,
+    I64x2ExtractLane,
+    I64x2ReplaceLane,
+    F32x4Splat,
+    F32x4ExtractLane,
+    F32x4ReplaceLane,
+    F64x2Splat,
+    F64x2ExtractLane,
+    F64x2ReplaceLane,
+    I8x16Eq,
+    I8x16Ne,
+    I8x16LtS,
+    I8x16LtU,
+    I8x16GtS,
+    I8x16GtU,
+    I8x16LeS,
+    I8x16LeU,
+    I8x16GeS,
+    I8x16GeU,
+    I16x8Eq,
+    I16x8Ne,
+    I16x8LtS,
+    I16x8LtU,
+    I16x8GtS,
+    I16x8GtU,
+    I16x8LeS,
+    I16x8LeU,
+    I16x8GeS,
+    I16x8GeU,
+    I32x4Eq,
+    I32x4Ne,
+    I32x4LtS,
+    I32x4LtU,
+    I32x4GtS,
+    I32x4GtU,
+    I32x4LeS,
+    I32x4LeU,
+    I32x4GeS,
+    I32x4GeU,
+    I64x2Eq,
+    I64x2Ne,
+    I64x2LtS,
+    I64x2GtS,
+    I64x2LeS,
+    I64x2GeS,
+    F32x4Eq,
+    F32x4Ne,
+    F32x4Lt,
+    F32x4Gt,
+    F32x4Le,
+    F32x4Ge,
+    F64x2Eq,
+    F64x2Ne,
+    F64x2Lt,
+    F64x2Gt,
+    F64x2Le,
+    F64x2Ge,
+    V128Not,
+    V128And,
+    V128AndNot,
+    V128Or,
+    V128Xor,
+    V128Bitselect,
+    V128AnyTrue,
+    I8x16Abs,
+    I8x16Neg,
+    I8x16AllTrue,
+    I8x16Bitmask,
+    I8x16Shl,
+    I8x16ShrS,
+    I8x16ShrU,
+    I8x16Add,
+    I8x16AddSatS,
+    I8x16AddSatU,
+    I8x16Sub,
+    I8x16SubSatS,
+    I8x16SubSatU,
+    I8x16MinS,
+    I8x16MinU,
+    I8x16MaxS,
+    I8x16MaxU,
+    I8x16Popcnt,
+    I16x8Abs,
+    I16x8Neg,
+    I16x8AllTrue,
+    I16x8Bitmask,
+    I16x8Shl,
+    I16x8ShrS,
+    I16x8ShrU,
+    I16x8Add,
+    I16x8AddSatS,
+    I16x8AddSatU,
+    I16x8Sub,
+    I16x8SubSatS,
+    I16x8SubSatU,
+    I16x8Mul,
+    I16x8MinS,
+    I16x8MinU,
+    I16x8MaxS,
+    I16x8MaxU,
+    I16x8ExtAddPairwiseI8x16S,
+    I16x8ExtAddPairwiseI8x16U,
+    I32x4Abs,
+    I32x4Neg,
+    I32x4AllTrue,
+    I32x4Bitmask,
+    I32x4Shl,
+    I32x4ShrS,
+    I32x4ShrU,
+    I32x4Add,
+    I32x4Sub,
+    I32x4Mul,
+    I32x4MinS,
+    I32x4MinU,
+    I32x4MaxS,
+    I32x4MaxU,
+    I32x4DotI16x8S,
+    I32x4ExtAddPairwiseI16x8S,
+    I32x4ExtAddPairwiseI16x8U,
+    I64x2Abs,
+    I64x2Neg,
+    I64x2AllTrue,
+    I64x2Bitmask,
+    I64x2Shl,
+    I64x2ShrS,
+    I64x2ShrU,
+    I64x2Add,
+    I64x2Sub,
+    I64x2Mul,
+    F32x4Ceil,
+    F32x4Floor,
+    F32x4Trunc,
+    F32x4Nearest,
+    F64x2Ceil,
+    F64x2Floor,
+    F64x2Trunc,
+    F64x2Nearest,
+    F32x4Abs,
+    F32x4Neg,
+    F32x4Sqrt,
+    F32x4Add,
+    F32x4Sub,
+    F32x4Mul,
+    F32x4Div,
+    F32x4Min,
+    F32x4Max,
+    F32x4PMin,
+    F32x4PMax,
+    F64x2Abs,
+    F64x2Neg,
+    F64x2Sqrt,
+    F64x2Add,
+    F64x2Sub,
+    F64x2Mul,
+    F64x2Div,
+    F64x2Min,
+    F64x2Max,
+    F64x2PMin,
+    F64x2PMax,
+    I32x4TruncSatF32x4S,
+    I32x4TruncSatF32x4U,
+    F32x4ConvertI32x4S,
+    F32x4ConvertI32x4U,
+    I8x16Swizzle,
+    I8x16Shuffle,
+    V128Load8Splat,
+    V128Load16Splat,
+    V128Load32Splat,
+    V128Load32Zero,
+    V128Load64Splat,
+    V128Load64Zero,
+    I8x16NarrowI16x8S,
+    I8x16NarrowI16x8U,
+    I16x8NarrowI32x4S,
+    I16x8NarrowI32x4U,
+    I16x8ExtendLowI8x16S,
+    I16x8ExtendHighI8x16S,
+    I16x8ExtendLowI8x16U,
+    I16x8ExtendHighI8x16U,
+    I32x4ExtendLowI16x8S,
+    I32x4ExtendHighI16x8S,
+    I32x4ExtendLowI16x8U,
+    I32x4ExtendHighI16x8U,
+    I64x2ExtendLowI32x4S,
+    I64x2ExtendHighI32x4S,
+    I64x2ExtendLowI32x4U,
+    I64x2ExtendHighI32x4U,
+    I16x8ExtMulLowI8x16S,
+    I16x8ExtMulHighI8x16S,
+    I16x8ExtMulLowI8x16U,
+    I16x8ExtMulHighI8x16U,
+    I32x4ExtMulLowI16x8S,
+    I32x4ExtMulHighI16x8S,
+    I32x4ExtMulLowI16x8U,
+    I32x4ExtMulHighI16x8U,
+    I64x2ExtMulLowI32x4S,
+    I64x2ExtMulHighI32x4S,
+    I64x2ExtMulLowI32x4U,
+    I64x2ExtMulHighI32x4U,
+    V128Load8x8S,
+    V128Load8x8U,
+    V128Load16x4S,
+    V128Load16x4U,
+    V128Load32x2S,
+    V128Load32x2U,
+    V128Load8Lane,
+    V128Load16Lane,
+    V128Load32Lane,
+    V128Load64Lane,
+    V128Store8Lane,
+    V128Store16Lane,
+    V128Store32Lane,
+    V128Store64Lane,
+    I8x16RoundingAverageU,
+    I16x8RoundingAverageU,
+    I16x8Q15MulrSatS,
+    F32x4DemoteF64x2Zero,
+    F64x2PromoteLowF32x4,
+    F64x2ConvertLowI32x4S,
+    F64x2ConvertLowI32x4U,
+    I32x4TruncSatF64x2SZero,
+    I32x4TruncSatF64x2UZero,
+    I8x16RelaxedSwizzle,
+    I32x4RelaxedTruncSatF32x4S,
+    I32x4RelaxedTruncSatF32x4U,
+    I32x4RelaxedTruncSatF64x2SZero,
+    I32x4RelaxedTruncSatF64x2UZero,
+    F32x4Fma,
+    F32x4Fms,
+    F64x2Fma,
+    F64x2Fms,
+    I8x16LaneSelect,
+    I16x8LaneSelect,
+    I32x4LaneSelect,
+    I64x2LaneSelect,
+    F32x4RelaxedMin,
+    F32x4RelaxedMax,
+    F64x2RelaxedMin,
+    F64x2RelaxedMax,
+    I16x8RelaxedQ15mulrS,
+    I16x8DotI8x16I7x16S,
+    I32x4DotI8x16I7x16AddS,
+    F32x4RelaxedDotBf16x8AddF32x4,
+}
+
+impl<'a> From<&Operator<'a>> for wasmer_parser_operator_t {
+    fn from(operator: &Operator<'a>) -> Self {
+        use Operator as O;
+
+        match operator {
+            O::Unreachable => Self::Unreachable,
+            O::Nop => Self::Nop,
+            O::Block { .. } => Self::Block,
+            O::Loop { .. } => Self::Loop,
+            O::If { .. } => Self::If,
+            O::Else => Self::Else,
+            O::Try { .. } => Self::Try,
+            O::Catch { .. } => Self::Catch,
+            O::CatchAll => Self::CatchAll,
+            O::Delegate { .. } => Self::Delegate,
+            O::Throw { .. } => Self::Throw,
+            O::Rethrow { .. } => Self::Rethrow,
+            // O::Unwind removed
+            O::End => Self::End,
+            O::Br { .. } => Self::Br,
+            O::BrIf { .. } => Self::BrIf,
+            O::BrTable { .. } => Self::BrTable,
+            O::Return => Self::Return,
+            O::Call { .. } => Self::Call,
+            O::CallIndirect { .. } => Self::CallIndirect,
+            O::ReturnCall { .. } => Self::ReturnCall,
+            O::ReturnCallIndirect { .. } => Self::ReturnCallIndirect,
+            O::Drop => Self::Drop,
+            O::Select => Self::Select,
+            O::TypedSelect { .. } => Self::TypedSelect,
+            O::LocalGet { .. } => Self::LocalGet,
+            O::LocalSet { .. } => Self::LocalSet,
+            O::LocalTee { .. } => Self::LocalTee,
+            O::GlobalGet { .. } => Self::GlobalGet,
+            O::GlobalSet { .. } => Self::GlobalSet,
+            O::I32Load { .. } => Self::I32Load,
+            O::I64Load { .. } => Self::I64Load,
+            O::F32Load { .. } => Self::F32Load,
+            O::F64Load { .. } => Self::F64Load,
+            O::I32Load8S { .. } => Self::I32Load8S,
+            O::I32Load8U { .. } => Self::I32Load8U,
+            O::I32Load16S { .. } => Self::I32Load16S,
+            O::I32Load16U { .. } => Self::I32Load16U,
+            O::I64Load8S { .. } => Self::I64Load8S,
+            O::I64Load8U { .. } => Self::I64Load8U,
+            O::I64Load16S { .. } => Self::I64Load16S,
+            O::I64Load16U { .. } => Self::I64Load16U,
+            O::I64Load32S { .. } => Self::I64Load32S,
+            O::I64Load32U { .. } => Self::I64Load32U,
+            O::I32Store { .. } => Self::I32Store,
+            O::I64Store { .. } => Self::I64Store,
+            O::F32Store { .. } => Self::F32Store,
+            O::F64Store { .. } => Self::F64Store,
+            O::I32Store8 { .. } => Self::I32Store8,
+            O::I32Store16 { .. } => Self::I32Store16,
+            O::I64Store8 { .. } => Self::I64Store8,
+            O::I64Store16 { .. } => Self::I64Store16,
+            O::I64Store32 { .. } => Self::I64Store32,
+            O::MemorySize { .. } => Self::MemorySize,
+            O::MemoryGrow { .. } => Self::MemoryGrow,
+            O::I32Const { .. } => Self::I32Const,
+            O::I64Const { .. } => Self::I64Const,
+            O::F32Const { .. } => Self::F32Const,
+            O::F64Const { .. } => Self::F64Const,
+            O::RefNull { .. } => Self::RefNull,
+            O::RefIsNull => Self::RefIsNull,
+            O::RefFunc { .. } => Self::RefFunc,
+            O::I32Eqz => Self::I32Eqz,
+            O::I32Eq => Self::I32Eq,
+            O::I32Ne => Self::I32Ne,
+            O::I32LtS => Self::I32LtS,
+            O::I32LtU => Self::I32LtU,
+            O::I32GtS => Self::I32GtS,
+            O::I32GtU => Self::I32GtU,
+            O::I32LeS => Self::I32LeS,
+            O::I32LeU => Self::I32LeU,
+            O::I32GeS => Self::I32GeS,
+            O::I32GeU => Self::I32GeU,
+            O::I64Eqz => Self::I64Eqz,
+            O::I64Eq => Self::I64Eq,
+            O::I64Ne => Self::I64Ne,
+            O::I64LtS => Self::I64LtS,
+            O::I64LtU => Self::I64LtU,
+            O::I64GtS => Self::I64GtS,
+            O::I64GtU => Self::I64GtU,
+            O::I64LeS => Self::I64LeS,
+            O::I64LeU => Self::I64LeU,
+            O::I64GeS => Self::I64GeS,
+            O::I64GeU => Self::I64GeU,
+            O::F32Eq => Self::F32Eq,
+            O::F32Ne => Self::F32Ne,
+            O::F32Lt => Self::F32Lt,
+            O::F32Gt => Self::F32Gt,
+            O::F32Le => Self::F32Le,
+            O::F32Ge => Self::F32Ge,
+            O::F64Eq => Self::F64Eq,
+            O::F64Ne => Self::F64Ne,
+            O::F64Lt => Self::F64Lt,
+            O::F64Gt => Self::F64Gt,
+            O::F64Le => Self::F64Le,
+            O::F64Ge => Self::F64Ge,
+            O::I32Clz => Self::I32Clz,
+            O::I32Ctz => Self::I32Ctz,
+            O::I32Popcnt => Self::I32Popcnt,
+            O::I32Add => Self::I32Add,
+            O::I32Sub => Self::I32Sub,
+            O::I32Mul => Self::I32Mul,
+            O::I32DivS => Self::I32DivS,
+            O::I32DivU => Self::I32DivU,
+            O::I32RemS => Self::I32RemS,
+            O::I32RemU => Self::I32RemU,
+            O::I32And => Self::I32And,
+            O::I32Or => Self::I32Or,
+            O::I32Xor => Self::I32Xor,
+            O::I32Shl => Self::I32Shl,
+            O::I32ShrS => Self::I32ShrS,
+            O::I32ShrU => Self::I32ShrU,
+            O::I32Rotl => Self::I32Rotl,
+            O::I32Rotr => Self::I32Rotr,
+            O::I64Clz => Self::I64Clz,
+            O::I64Ctz => Self::I64Ctz,
+            O::I64Popcnt => Self::I64Popcnt,
+            O::I64Add => Self::I64Add,
+            O::I64Sub => Self::I64Sub,
+            O::I64Mul => Self::I64Mul,
+            O::I64DivS => Self::I64DivS,
+            O::I64DivU => Self::I64DivU,
+            O::I64RemS => Self::I64RemS,
+            O::I64RemU => Self::I64RemU,
+            O::I64And => Self::I64And,
+            O::I64Or => Self::I64Or,
+            O::I64Xor => Self::I64Xor,
+            O::I64Shl => Self::I64Shl,
+            O::I64ShrS => Self::I64ShrS,
+            O::I64ShrU => Self::I64ShrU,
+            O::I64Rotl => Self::I64Rotl,
+            O::I64Rotr => Self::I64Rotr,
+            O::F32Abs => Self::F32Abs,
+            O::F32Neg => Self::F32Neg,
+            O::F32Ceil => Self::F32Ceil,
+            O::F32Floor => Self::F32Floor,
+            O::F32Trunc => Self::F32Trunc,
+            O::F32Nearest => Self::F32Nearest,
+            O::F32Sqrt => Self::F32Sqrt,
+            O::F32Add => Self::F32Add,
+            O::F32Sub => Self::F32Sub,
+            O::F32Mul => Self::F32Mul,
+            O::F32Div => Self::F32Div,
+            O::F32Min => Self::F32Min,
+            O::F32Max => Self::F32Max,
+            O::F32Copysign => Self::F32Copysign,
+            O::F64Abs => Self::F64Abs,
+            O::F64Neg => Self::F64Neg,
+            O::F64Ceil => Self::F64Ceil,
+            O::F64Floor => Self::F64Floor,
+            O::F64Trunc => Self::F64Trunc,
+            O::F64Nearest => Self::F64Nearest,
+            O::F64Sqrt => Self::F64Sqrt,
+            O::F64Add => Self::F64Add,
+            O::F64Sub => Self::F64Sub,
+            O::F64Mul => Self::F64Mul,
+            O::F64Div => Self::F64Div,
+            O::F64Min => Self::F64Min,
+            O::F64Max => Self::F64Max,
+            O::F64Copysign => Self::F64Copysign,
+            O::I32WrapI64 => Self::I32WrapI64,
+            O::I32TruncF32S => Self::I32TruncF32S,
+            O::I32TruncF32U => Self::I32TruncF32U,
+            O::I32TruncF64S => Self::I32TruncF64S,
+            O::I32TruncF64U => Self::I32TruncF64U,
+            O::I64ExtendI32S => Self::I64ExtendI32S,
+            O::I64ExtendI32U => Self::I64ExtendI32U,
+            O::I64TruncF32S => Self::I64TruncF32S,
+            O::I64TruncF32U => Self::I64TruncF32U,
+            O::I64TruncF64S => Self::I64TruncF64S,
+            O::I64TruncF64U => Self::I64TruncF64U,
+            O::F32ConvertI32S => Self::F32ConvertI32S,
+            O::F32ConvertI32U => Self::F32ConvertI32U,
+            O::F32ConvertI64S => Self::F32ConvertI64S,
+            O::F32ConvertI64U => Self::F32ConvertI64U,
+            O::F32DemoteF64 => Self::F32DemoteF64,
+            O::F64ConvertI32S => Self::F64ConvertI32S,
+            O::F64ConvertI32U => Self::F64ConvertI32U,
+            O::F64ConvertI64S => Self::F64ConvertI64S,
+            O::F64ConvertI64U => Self::F64ConvertI64U,
+            O::F64PromoteF32 => Self::F64PromoteF32,
+            O::I32ReinterpretF32 => Self::I32ReinterpretF32,
+            O::I64ReinterpretF64 => Self::I64ReinterpretF64,
+            O::F32ReinterpretI32 => Self::F32ReinterpretI32,
+            O::F64ReinterpretI64 => Self::F64ReinterpretI64,
+            O::I32Extend8S => Self::I32Extend8S,
+            O::I32Extend16S => Self::I32Extend16S,
+            O::I64Extend8S => Self::I64Extend8S,
+            O::I64Extend16S => Self::I64Extend16S,
+            O::I64Extend32S => Self::I64Extend32S,
+            O::I32TruncSatF32S => Self::I32TruncSatF32S,
+            O::I32TruncSatF32U => Self::I32TruncSatF32U,
+            O::I32TruncSatF64S => Self::I32TruncSatF64S,
+            O::I32TruncSatF64U => Self::I32TruncSatF64U,
+            O::I64TruncSatF32S => Self::I64TruncSatF32S,
+            O::I64TruncSatF32U => Self::I64TruncSatF32U,
+            O::I64TruncSatF64S => Self::I64TruncSatF64S,
+            O::I64TruncSatF64U => Self::I64TruncSatF64U,
+            O::MemoryInit { .. } => Self::MemoryInit,
+            O::DataDrop { .. } => Self::DataDrop,
+            O::MemoryCopy { .. } => Self::MemoryCopy,
+            O::MemoryFill { .. } => Self::MemoryFill,
+            O::TableInit { .. } => Self::TableInit,
+            O::ElemDrop { .. } => Self::ElemDrop,
+            O::TableCopy { .. } => Self::TableCopy,
+            O::TableFill { .. } => Self::TableFill,
+            O::TableGet { .. } => Self::TableGet,
+            O::TableSet { .. } => Self::TableSet,
+            O::TableGrow { .. } => Self::TableGrow,
+            O::TableSize { .. } => Self::TableSize,
+            O::MemoryAtomicNotify { .. } => Self::MemoryAtomicNotify,
+            O::MemoryAtomicWait32 { .. } => Self::MemoryAtomicWait32,
+            O::MemoryAtomicWait64 { .. } => Self::MemoryAtomicWait64,
+            O::AtomicFence { .. } => Self::AtomicFence,
+            O::I32AtomicLoad { .. } => Self::I32AtomicLoad,
+            O::I64AtomicLoad { .. } => Self::I64AtomicLoad,
+            O::I32AtomicLoad8U { .. } => Self::I32AtomicLoad8U,
+            O::I32AtomicLoad16U { .. } => Self::I32AtomicLoad16U,
+            O::I64AtomicLoad8U { .. } => Self::I64AtomicLoad8U,
+            O::I64AtomicLoad16U { .. } => Self::I64AtomicLoad16U,
+            O::I64AtomicLoad32U { .. } => Self::I64AtomicLoad32U,
+            O::I32AtomicStore { .. } => Self::I32AtomicStore,
+            O::I64AtomicStore { .. } => Self::I64AtomicStore,
+            O::I32AtomicStore8 { .. } => Self::I32AtomicStore8,
+            O::I32AtomicStore16 { .. } => Self::I32AtomicStore16,
+            O::I64AtomicStore8 { .. } => Self::I64AtomicStore8,
+            O::I64AtomicStore16 { .. } => Self::I64AtomicStore16,
+            O::I64AtomicStore32 { .. } => Self::I64AtomicStore32,
+            O::I32AtomicRmwAdd { .. } => Self::I32AtomicRmwAdd,
+            O::I64AtomicRmwAdd { .. } => Self::I64AtomicRmwAdd,
+            O::I32AtomicRmw8AddU { .. } => Self::I32AtomicRmw8AddU,
+            O::I32AtomicRmw16AddU { .. } => Self::I32AtomicRmw16AddU,
+            O::I64AtomicRmw8AddU { .. } => Self::I64AtomicRmw8AddU,
+            O::I64AtomicRmw16AddU { .. } => Self::I64AtomicRmw16AddU,
+            O::I64AtomicRmw32AddU { .. } => Self::I64AtomicRmw32AddU,
+            O::I32AtomicRmwSub { .. } => Self::I32AtomicRmwSub,
+            O::I64AtomicRmwSub { .. } => Self::I64AtomicRmwSub,
+            O::I32AtomicRmw8SubU { .. } => Self::I32AtomicRmw8SubU,
+            O::I32AtomicRmw16SubU { .. } => Self::I32AtomicRmw16SubU,
+            O::I64AtomicRmw8SubU { .. } => Self::I64AtomicRmw8SubU,
+            O::I64AtomicRmw16SubU { .. } => Self::I64AtomicRmw16SubU,
+            O::I64AtomicRmw32SubU { .. } => Self::I64AtomicRmw32SubU,
+            O::I32AtomicRmwAnd { .. } => Self::I32AtomicRmwAnd,
+            O::I64AtomicRmwAnd { .. } => Self::I64AtomicRmwAnd,
+            O::I32AtomicRmw8AndU { .. } => Self::I32AtomicRmw8AndU,
+            O::I32AtomicRmw16AndU { .. } => Self::I32AtomicRmw16AndU,
+            O::I64AtomicRmw8AndU { .. } => Self::I64AtomicRmw8AndU,
+            O::I64AtomicRmw16AndU { .. } => Self::I64AtomicRmw16AndU,
+            O::I64AtomicRmw32AndU { .. } => Self::I64AtomicRmw32AndU,
+            O::I32AtomicRmwOr { .. } => Self::I32AtomicRmwOr,
+            O::I64AtomicRmwOr { .. } => Self::I64AtomicRmwOr,
+            O::I32AtomicRmw8OrU { .. } => Self::I32AtomicRmw8OrU,
+            O::I32AtomicRmw16OrU { .. } => Self::I32AtomicRmw16OrU,
+            O::I64AtomicRmw8OrU { .. } => Self::I64AtomicRmw8OrU,
+            O::I64AtomicRmw16OrU { .. } => Self::I64AtomicRmw16OrU,
+            O::I64AtomicRmw32OrU { .. } => Self::I64AtomicRmw32OrU,
+            O::I32AtomicRmwXor { .. } => Self::I32AtomicRmwXor,
+            O::I64AtomicRmwXor { .. } => Self::I64AtomicRmwXor,
+            O::I32AtomicRmw8XorU { .. } => Self::I32AtomicRmw8XorU,
+            O::I32AtomicRmw16XorU { .. } => Self::I32AtomicRmw16XorU,
+            O::I64AtomicRmw8XorU { .. } => Self::I64AtomicRmw8XorU,
+            O::I64AtomicRmw16XorU { .. } => Self::I64AtomicRmw16XorU,
+            O::I64AtomicRmw32XorU { .. } => Self::I64AtomicRmw32XorU,
+            O::I32AtomicRmwXchg { .. } => Self::I32AtomicRmwXchg,
+            O::I64AtomicRmwXchg { .. } => Self::I64AtomicRmwXchg,
+            O::I32AtomicRmw8XchgU { .. } => Self::I32AtomicRmw8XchgU,
+            O::I32AtomicRmw16XchgU { .. } => Self::I32AtomicRmw16XchgU,
+            O::I64AtomicRmw8XchgU { .. } => Self::I64AtomicRmw8XchgU,
+            O::I64AtomicRmw16XchgU { .. } => Self::I64AtomicRmw16XchgU,
+            O::I64AtomicRmw32XchgU { .. } => Self::I64AtomicRmw32XchgU,
+            O::I32AtomicRmwCmpxchg { .. } => Self::I32AtomicRmwCmpxchg,
+            O::I64AtomicRmwCmpxchg { .. } => Self::I64AtomicRmwCmpxchg,
+            O::I32AtomicRmw8CmpxchgU { .. } => Self::I32AtomicRmw8CmpxchgU,
+            O::I32AtomicRmw16CmpxchgU { .. } => Self::I32AtomicRmw16CmpxchgU,
+            O::I64AtomicRmw8CmpxchgU { .. } => Self::I64AtomicRmw8CmpxchgU,
+            O::I64AtomicRmw16CmpxchgU { .. } => Self::I64AtomicRmw16CmpxchgU,
+            O::I64AtomicRmw32CmpxchgU { .. } => Self::I64AtomicRmw32CmpxchgU,
+            O::V128Load { .. } => Self::V128Load,
+            O::V128Store { .. } => Self::V128Store,
+            O::V128Const { .. } => Self::V128Const,
+            O::I8x16Splat => Self::I8x16Splat,
+            O::I8x16ExtractLaneS { .. } => Self::I8x16ExtractLaneS,
+            O::I8x16ExtractLaneU { .. } => Self::I8x16ExtractLaneU,
+            O::I8x16ReplaceLane { .. } => Self::I8x16ReplaceLane,
+            O::I16x8Splat => Self::I16x8Splat,
+            O::I16x8ExtractLaneS { .. } => Self::I16x8ExtractLaneS,
+            O::I16x8ExtractLaneU { .. } => Self::I16x8ExtractLaneU,
+            O::I16x8ReplaceLane { .. } => Self::I16x8ReplaceLane,
+            O::I32x4Splat => Self::I32x4Splat,
+            O::I32x4ExtractLane { .. } => Self::I32x4ExtractLane,
+            O::I32x4ReplaceLane { .. } => Self::I32x4ReplaceLane,
+            O::I64x2Splat => Self::I64x2Splat,
+            O::I64x2ExtractLane { .. } => Self::I64x2ExtractLane,
+            O::I64x2ReplaceLane { .. } => Self::I64x2ReplaceLane,
+            O::F32x4Splat => Self::F32x4Splat,
+            O::F32x4ExtractLane { .. } => Self::F32x4ExtractLane,
+            O::F32x4ReplaceLane { .. } => Self::F32x4ReplaceLane,
+            O::F64x2Splat => Self::F64x2Splat,
+            O::F64x2ExtractLane { .. } => Self::F64x2ExtractLane,
+            O::F64x2ReplaceLane { .. } => Self::F64x2ReplaceLane,
+            O::I8x16Eq => Self::I8x16Eq,
+            O::I8x16Ne => Self::I8x16Ne,
+            O::I8x16LtS => Self::I8x16LtS,
+            O::I8x16LtU => Self::I8x16LtU,
+            O::I8x16GtS => Self::I8x16GtS,
+            O::I8x16GtU => Self::I8x16GtU,
+            O::I8x16LeS => Self::I8x16LeS,
+            O::I8x16LeU => Self::I8x16LeU,
+            O::I8x16GeS => Self::I8x16GeS,
+            O::I8x16GeU => Self::I8x16GeU,
+            O::I16x8Eq => Self::I16x8Eq,
+            O::I16x8Ne => Self::I16x8Ne,
+            O::I16x8LtS => Self::I16x8LtS,
+            O::I16x8LtU => Self::I16x8LtU,
+            O::I16x8GtS => Self::I16x8GtS,
+            O::I16x8GtU => Self::I16x8GtU,
+            O::I16x8LeS => Self::I16x8LeS,
+            O::I16x8LeU => Self::I16x8LeU,
+            O::I16x8GeS => Self::I16x8GeS,
+            O::I16x8GeU => Self::I16x8GeU,
+            O::I32x4Eq => Self::I32x4Eq,
+            O::I32x4Ne => Self::I32x4Ne,
+            O::I32x4LtS => Self::I32x4LtS,
+            O::I32x4LtU => Self::I32x4LtU,
+            O::I32x4GtS => Self::I32x4GtS,
+            O::I32x4GtU => Self::I32x4GtU,
+            O::I32x4LeS => Self::I32x4LeS,
+            O::I32x4LeU => Self::I32x4LeU,
+            O::I32x4GeS => Self::I32x4GeS,
+            O::I32x4GeU => Self::I32x4GeU,
+            O::I64x2Eq => Self::I64x2Eq,
+            O::I64x2Ne => Self::I64x2Ne,
+            O::I64x2LtS => Self::I64x2LtS,
+            O::I64x2GtS => Self::I64x2GtS,
+            O::I64x2LeS => Self::I64x2LeS,
+            O::I64x2GeS => Self::I64x2GeS,
+            O::F32x4Eq => Self::F32x4Eq,
+            O::F32x4Ne => Self::F32x4Ne,
+            O::F32x4Lt => Self::F32x4Lt,
+            O::F32x4Gt => Self::F32x4Gt,
+            O::F32x4Le => Self::F32x4Le,
+            O::F32x4Ge => Self::F32x4Ge,
+            O::F64x2Eq => Self::F64x2Eq,
+            O::F64x2Ne => Self::F64x2Ne,
+            O::F64x2Lt => Self::F64x2Lt,
+            O::F64x2Gt => Self::F64x2Gt,
+            O::F64x2Le => Self::F64x2Le,
+            O::F64x2Ge => Self::F64x2Ge,
+            O::V128Not => Self::V128Not,
+            O::V128And => Self::V128And,
+            O::V128AndNot => Self::V128AndNot,
+            O::V128Or => Self::V128Or,
+            O::V128Xor => Self::V128Xor,
+            O::V128Bitselect => Self::V128Bitselect,
+            O::V128AnyTrue => Self::V128AnyTrue,
+            O::I8x16Popcnt => Self::I8x16Popcnt,
+            O::I8x16Abs => Self::I8x16Abs,
+            O::I8x16Neg => Self::I8x16Neg,
+            O::I8x16AllTrue => Self::I8x16AllTrue,
+            O::I8x16Bitmask => Self::I8x16Bitmask,
+            O::I8x16Shl => Self::I8x16Shl,
+            O::I8x16ShrS => Self::I8x16ShrS,
+            O::I8x16ShrU => Self::I8x16ShrU,
+            O::I8x16Add => Self::I8x16Add,
+            O::I8x16AddSatS => Self::I8x16AddSatS,
+            O::I8x16AddSatU => Self::I8x16AddSatU,
+            O::I8x16Sub => Self::I8x16Sub,
+            O::I8x16SubSatS => Self::I8x16SubSatS,
+            O::I8x16SubSatU => Self::I8x16SubSatU,
+            O::I8x16MinS => Self::I8x16MinS,
+            O::I8x16MinU => Self::I8x16MinU,
+            O::I8x16MaxS => Self::I8x16MaxS,
+            O::I8x16MaxU => Self::I8x16MaxU,
+            O::I16x8Abs => Self::I16x8Abs,
+            O::I16x8Neg => Self::I16x8Neg,
+            O::I16x8AllTrue => Self::I16x8AllTrue,
+            O::I16x8Bitmask => Self::I16x8Bitmask,
+            O::I16x8Shl => Self::I16x8Shl,
+            O::I16x8ShrS => Self::I16x8ShrS,
+            O::I16x8ShrU => Self::I16x8ShrU,
+            O::I16x8Add => Self::I16x8Add,
+            O::I16x8AddSatS => Self::I16x8AddSatS,
+            O::I16x8AddSatU => Self::I16x8AddSatU,
+            O::I16x8Sub => Self::I16x8Sub,
+            O::I16x8SubSatS => Self::I16x8SubSatS,
+            O::I16x8SubSatU => Self::I16x8SubSatU,
+            O::I16x8Mul => Self::I16x8Mul,
+            O::I16x8MinS => Self::I16x8MinS,
+            O::I16x8MinU => Self::I16x8MinU,
+            O::I16x8MaxS => Self::I16x8MaxS,
+            O::I16x8MaxU => Self::I16x8MaxU,
+            O::I16x8ExtAddPairwiseI8x16S => Self::I16x8ExtAddPairwiseI8x16S,
+            O::I16x8ExtAddPairwiseI8x16U => Self::I16x8ExtAddPairwiseI8x16U,
+            O::I32x4Abs => Self::I32x4Abs,
+            O::I32x4Neg => Self::I32x4Neg,
+            O::I32x4AllTrue => Self::I32x4AllTrue,
+            O::I32x4Bitmask => Self::I32x4Bitmask,
+            O::I32x4Shl => Self::I32x4Shl,
+            O::I32x4ShrS => Self::I32x4ShrS,
+            O::I32x4ShrU => Self::I32x4ShrU,
+            O::I32x4Add => Self::I32x4Add,
+            O::I32x4Sub => Self::I32x4Sub,
+            O::I32x4Mul => Self::I32x4Mul,
+            O::I32x4MinS => Self::I32x4MinS,
+            O::I32x4MinU => Self::I32x4MinU,
+            O::I32x4MaxS => Self::I32x4MaxS,
+            O::I32x4MaxU => Self::I32x4MaxU,
+            O::I32x4DotI16x8S => Self::I32x4DotI16x8S,
+            O::I32x4ExtAddPairwiseI16x8S => Self::I32x4ExtAddPairwiseI16x8S,
+            O::I32x4ExtAddPairwiseI16x8U => Self::I32x4ExtAddPairwiseI16x8U,
+            O::I64x2Abs => Self::I64x2Abs,
+            O::I64x2Neg => Self::I64x2Neg,
+            O::I64x2AllTrue => Self::I64x2AllTrue,
+            O::I64x2Bitmask => Self::I64x2Bitmask,
+            O::I64x2Shl => Self::I64x2Shl,
+            O::I64x2ShrS => Self::I64x2ShrS,
+            O::I64x2ShrU => Self::I64x2ShrU,
+            O::I64x2Add => Self::I64x2Add,
+            O::I64x2Sub => Self::I64x2Sub,
+            O::I64x2Mul => Self::I64x2Mul,
+            O::F32x4Ceil => Self::F32x4Ceil,
+            O::F32x4Floor => Self::F32x4Floor,
+            O::F32x4Trunc => Self::F32x4Trunc,
+            O::F32x4Nearest => Self::F32x4Nearest,
+            O::F64x2Ceil => Self::F64x2Ceil,
+            O::F64x2Floor => Self::F64x2Floor,
+            O::F64x2Trunc => Self::F64x2Trunc,
+            O::F64x2Nearest => Self::F64x2Nearest,
+            O::F32x4Abs => Self::F32x4Abs,
+            O::F32x4Neg => Self::F32x4Neg,
+            O::F32x4Sqrt => Self::F32x4Sqrt,
+            O::F32x4Add => Self::F32x4Add,
+            O::F32x4Sub => Self::F32x4Sub,
+            O::F32x4Mul => Self::F32x4Mul,
+            O::F32x4Div => Self::F32x4Div,
+            O::F32x4Min => Self::F32x4Min,
+            O::F32x4Max => Self::F32x4Max,
+            O::F32x4PMin => Self::F32x4PMin,
+            O::F32x4PMax => Self::F32x4PMax,
+            O::F64x2Abs => Self::F64x2Abs,
+            O::F64x2Neg => Self::F64x2Neg,
+            O::F64x2Sqrt => Self::F64x2Sqrt,
+            O::F64x2Add => Self::F64x2Add,
+            O::F64x2Sub => Self::F64x2Sub,
+            O::F64x2Mul => Self::F64x2Mul,
+            O::F64x2Div => Self::F64x2Div,
+            O::F64x2Min => Self::F64x2Min,
+            O::F64x2Max => Self::F64x2Max,
+            O::F64x2PMin => Self::F64x2PMin,
+            O::F64x2PMax => Self::F64x2PMax,
+            O::I32x4TruncSatF32x4S => Self::I32x4TruncSatF32x4S,
+            O::I32x4TruncSatF32x4U => Self::I32x4TruncSatF32x4U,
+            O::F32x4ConvertI32x4S => Self::F32x4ConvertI32x4S,
+            O::F32x4ConvertI32x4U => Self::F32x4ConvertI32x4U,
+            O::I8x16Swizzle => Self::I8x16Swizzle,
+            O::I8x16Shuffle { .. } => Self::I8x16Shuffle,
+            O::V128Load8Splat { .. } => Self::V128Load8Splat,
+            O::V128Load16Splat { .. } => Self::V128Load16Splat,
+            O::V128Load32Splat { .. } => Self::V128Load32Splat,
+            O::V128Load32Zero { .. } => Self::V128Load32Zero,
+            O::V128Load64Splat { .. } => Self::V128Load64Splat,
+            O::V128Load64Zero { .. } => Self::V128Load64Zero,
+            O::I8x16NarrowI16x8S => Self::I8x16NarrowI16x8S,
+            O::I8x16NarrowI16x8U => Self::I8x16NarrowI16x8U,
+            O::I16x8NarrowI32x4S => Self::I16x8NarrowI32x4S,
+            O::I16x8NarrowI32x4U => Self::I16x8NarrowI32x4U,
+            O::I16x8ExtendLowI8x16S => Self::I16x8ExtendLowI8x16S,
+            O::I16x8ExtendHighI8x16S => Self::I16x8ExtendHighI8x16S,
+            O::I16x8ExtendLowI8x16U => Self::I16x8ExtendLowI8x16U,
+            O::I16x8ExtendHighI8x16U => Self::I16x8ExtendHighI8x16U,
+            O::I32x4ExtendLowI16x8S => Self::I32x4ExtendLowI16x8S,
+            O::I32x4ExtendHighI16x8S => Self::I32x4ExtendHighI16x8S,
+            O::I32x4ExtendLowI16x8U => Self::I32x4ExtendLowI16x8U,
+            O::I32x4ExtendHighI16x8U => Self::I32x4ExtendHighI16x8U,
+            O::I64x2ExtendLowI32x4S => Self::I64x2ExtendLowI32x4S,
+            O::I64x2ExtendHighI32x4S => Self::I64x2ExtendHighI32x4S,
+            O::I64x2ExtendLowI32x4U => Self::I64x2ExtendLowI32x4U,
+            O::I64x2ExtendHighI32x4U => Self::I64x2ExtendHighI32x4U,
+            O::I16x8ExtMulLowI8x16S => Self::I16x8ExtMulLowI8x16S,
+            O::I16x8ExtMulHighI8x16S => Self::I16x8ExtMulHighI8x16S,
+            O::I16x8ExtMulLowI8x16U => Self::I16x8ExtMulLowI8x16U,
+            O::I16x8ExtMulHighI8x16U => Self::I16x8ExtMulHighI8x16U,
+            O::I32x4ExtMulLowI16x8S => Self::I32x4ExtMulLowI16x8S,
+            O::I32x4ExtMulHighI16x8S => Self::I32x4ExtMulHighI16x8S,
+            O::I32x4ExtMulLowI16x8U => Self::I32x4ExtMulLowI16x8U,
+            O::I32x4ExtMulHighI16x8U => Self::I32x4ExtMulHighI16x8U,
+            O::I64x2ExtMulLowI32x4S => Self::I64x2ExtMulLowI32x4S,
+            O::I64x2ExtMulHighI32x4S => Self::I64x2ExtMulHighI32x4S,
+            O::I64x2ExtMulLowI32x4U => Self::I64x2ExtMulLowI32x4U,
+            O::I64x2ExtMulHighI32x4U => Self::I64x2ExtMulHighI32x4U,
+            O::V128Load8x8S { .. } => Self::V128Load8x8S,
+            O::V128Load8x8U { .. } => Self::V128Load8x8U,
+            O::V128Load16x4S { .. } => Self::V128Load16x4S,
+            O::V128Load16x4U { .. } => Self::V128Load16x4U,
+            O::V128Load32x2S { .. } => Self::V128Load32x2S,
+            O::V128Load32x2U { .. } => Self::V128Load32x2U,
+            O::V128Load8Lane { .. } => Self::V128Load8Lane,
+            O::V128Load16Lane { .. } => Self::V128Load16Lane,
+            O::V128Load32Lane { .. } => Self::V128Load32Lane,
+            O::V128Load64Lane { .. } => Self::V128Load64Lane,
+            O::V128Store8Lane { .. } => Self::V128Store8Lane,
+            O::V128Store16Lane { .. } => Self::V128Store16Lane,
+            O::V128Store32Lane { .. } => Self::V128Store32Lane,
+            O::V128Store64Lane { .. } => Self::V128Store64Lane,
+            O::I8x16AvgrU => Self::I8x16RoundingAverageU,
+            O::I16x8AvgrU => Self::I16x8RoundingAverageU,
+            O::I16x8Q15MulrSatS => Self::I16x8Q15MulrSatS,
+            O::F32x4DemoteF64x2Zero => Self::F32x4DemoteF64x2Zero,
+            O::F64x2PromoteLowF32x4 => Self::F64x2PromoteLowF32x4,
+            O::F64x2ConvertLowI32x4S => Self::F64x2ConvertLowI32x4S,
+            O::F64x2ConvertLowI32x4U => Self::F64x2ConvertLowI32x4U,
+            O::I32x4TruncSatF64x2SZero => Self::I32x4TruncSatF64x2SZero,
+            O::I32x4TruncSatF64x2UZero => Self::I32x4TruncSatF64x2UZero,
+            O::I8x16RelaxedSwizzle => Self::I8x16RelaxedSwizzle,
+            O::I32x4RelaxedTruncF32x4S => Self::I32x4RelaxedTruncSatF32x4S,
+            O::I32x4RelaxedTruncF32x4U => Self::I32x4RelaxedTruncSatF32x4U,
+            O::I32x4RelaxedTruncF64x2SZero => Self::I32x4RelaxedTruncSatF64x2SZero,
+            O::I32x4RelaxedTruncF64x2UZero => Self::I32x4RelaxedTruncSatF64x2UZero,
+            O::F32x4RelaxedMadd => Self::F32x4Fma,
+            O::I8x16RelaxedLaneselect => Self::I8x16LaneSelect,
+            O::I16x8RelaxedLaneselect => Self::I16x8LaneSelect,
+            O::I32x4RelaxedLaneselect => Self::I32x4LaneSelect,
+            O::I64x2RelaxedLaneselect => Self::I64x2LaneSelect,
+            O::F32x4RelaxedMin => Self::F32x4RelaxedMin,
+            O::F32x4RelaxedMax => Self::F32x4RelaxedMax,
+            O::F64x2RelaxedMin => Self::F64x2RelaxedMin,
+            O::F64x2RelaxedMax => Self::F64x2RelaxedMax,
+            O::I16x8RelaxedQ15mulrS => Self::I16x8RelaxedQ15mulrS,
+            _ => {
+                panic!("unimplemented operator {operator:?}");
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs
new file mode 100644
index 0000000..b24c3da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/target_lexicon.rs
@@ -0,0 +1,314 @@
+//! Unstable non-standard Wasmer-specific API that contains everything
+//! to create a target with a triple and CPU features.
+//!
+//! This is useful for cross-compilation.
+//!
+//! # Example
+//!
+//! ```rust
+//! # use wasmer_inline_c::assert_c;
+//! # fn main() {
+//! #    (assert_c! {
+//! # #include "tests/wasmer.h"
+//! #
+//! int main() {
+//!     // Declare the target triple.
+//!     wasmer_triple_t* triple;
+//!
+//!     {
+//!         wasm_name_t triple_name;
+//!         wasm_name_new_from_string(&triple_name, "x86_64-apple-darwin");
+//!
+//!         triple = wasmer_triple_new(&triple_name);
+//!
+//!         wasm_name_delete(&triple_name);
+//!     }
+//!
+//!     assert(triple);
+//!
+//!     // Declare the target CPU features.
+//!     wasmer_cpu_features_t* cpu_features = wasmer_cpu_features_new();
+//!
+//!     {
+//!         wasm_name_t cpu_feature_name;
+//!         wasm_name_new_from_string(&cpu_feature_name, "sse2");
+//!
+//!         wasmer_cpu_features_add(cpu_features, &cpu_feature_name);
+//!
+//!         wasm_name_delete(&cpu_feature_name);
+//!     }
+//!
+//!     assert(cpu_features);
+//!
+//!     // Create the target!
+//!     wasmer_target_t* target = wasmer_target_new(triple, cpu_features);
+//!     assert(target);
+//!
+//!     wasmer_target_delete(target);
+//!
+//!     return 0;
+//! }
+//! #    })
+//! #    .success();
+//! # }
+//! ```
+
+use super::super::types::wasm_name_t;
+use enumset::EnumSet;
+use std::slice;
+use std::str::{self, FromStr};
+use wasmer_api::{CpuFeature, Target, Triple};
+
+/// Unstable non-standard Wasmer-specific API to represent a triple +
+/// CPU features pair.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[derive(Debug)]
+#[allow(non_camel_case_types)]
+pub struct wasmer_target_t {
+    #[allow(unused)]
+    pub(crate) inner: Target,
+}
+
+/// Creates a new [`wasmer_target_t`].
+///
+/// It takes ownership of `triple` and `cpu_features`.
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_target_new(
+    triple: Option<Box<wasmer_triple_t>>,
+    cpu_features: Option<Box<wasmer_cpu_features_t>>,
+) -> Option<Box<wasmer_target_t>> {
+    let triple = triple?;
+    let cpu_features = cpu_features?;
+
+    Some(Box::new(wasmer_target_t {
+        inner: Target::new(triple.inner.clone(), cpu_features.inner),
+    }))
+}
+
+/// Delete a [`wasmer_target_t`].
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub extern "C" fn wasmer_target_delete(_target: Option<Box<wasmer_target_t>>) {}
+
+/// Unstable non-standard Wasmer-specific API to represent a target
+/// “triple”.
+///
+/// Historically such things had three fields, though they have added
+/// additional fields over time.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     wasm_name_t triple_name;
+///     wasm_name_new_from_string(&triple_name, "x86_64-apple-darwin");
+///
+///     wasmer_triple_t* triple = wasmer_triple_new(&triple_name);
+///     assert(triple);
+///
+///     wasmer_triple_delete(triple);
+///     wasm_name_delete(&triple_name);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// See also [`wasmer_triple_new_from_host`].
+#[allow(non_camel_case_types)]
+pub struct wasmer_triple_t {
+    inner: Triple,
+}
+
+/// Create a new [`wasmer_triple_t`] based on a triple string.
+///
+/// # Example
+///
+/// See [`wasmer_triple_t`] or [`wasmer_triple_new_from_host`].
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_triple_new(
+    triple: Option<&wasm_name_t>,
+) -> Option<Box<wasmer_triple_t>> {
+    let triple = triple?;
+    let triple = c_try!(str::from_utf8(slice::from_raw_parts(
+        triple.data,
+        triple.size
+    )));
+
+    Some(Box::new(wasmer_triple_t {
+        inner: c_try!(Triple::from_str(triple)),
+    }))
+}
+
+/// Create the [`wasmer_triple_t`] for the current host.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     wasmer_triple_t* triple = wasmer_triple_new_from_host();
+///     assert(triple);
+///
+///     wasmer_triple_delete(triple);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+///
+/// See also [`wasmer_triple_new`].
+#[no_mangle]
+pub extern "C" fn wasmer_triple_new_from_host() -> Box<wasmer_triple_t> {
+    Box::new(wasmer_triple_t {
+        inner: Triple::host(),
+    })
+}
+
+/// Delete a [`wasmer_triple_t`].
+///
+/// # Example
+///
+/// See [`wasmer_triple_t`].
+#[no_mangle]
+pub extern "C" fn wasmer_triple_delete(_triple: Option<Box<wasmer_triple_t>>) {}
+
+/// Unstable non-standard Wasmer-specific API to represent a set of
+/// CPU features.
+///
+/// CPU features are identified by their stringified names. The
+/// reference is the GCC options:
+///
+/// * <https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html>,
+/// * <https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html>,
+/// * <https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html>.
+///
+/// At the time of writing this documentation (it might be outdated in
+/// the future), the supported features are the following:
+///
+/// * `sse2`,
+/// * `sse3`,
+/// * `ssse3`,
+/// * `sse4.1`,
+/// * `sse4.2`,
+/// * `popcnt`,
+/// * `avx`,
+/// * `bmi`,
+/// * `bmi2`,
+/// * `avx2`,
+/// * `avx512dq`,
+/// * `avx512vl`,
+/// * `lzcnt`.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create a new CPU feature set.
+///     wasmer_cpu_features_t* cpu_features = wasmer_cpu_features_new();
+///
+///     // Create a new feature name, here `sse2`, and add it to the set.
+///     {
+///         wasm_name_t cpu_feature_name;
+///         wasm_name_new_from_string(&cpu_feature_name, "sse2");
+///
+///         wasmer_cpu_features_add(cpu_features, &cpu_feature_name);
+///
+///         wasm_name_delete(&cpu_feature_name);
+///     }
+///
+///     wasmer_cpu_features_delete(cpu_features);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[allow(non_camel_case_types)]
+pub struct wasmer_cpu_features_t {
+    inner: EnumSet<CpuFeature>,
+}
+
+/// Create a new [`wasmer_cpu_features_t`].
+///
+/// # Example
+///
+/// See [`wasmer_cpu_features_t`].
+#[no_mangle]
+pub extern "C" fn wasmer_cpu_features_new() -> Box<wasmer_cpu_features_t> {
+    Box::new(wasmer_cpu_features_t {
+        inner: CpuFeature::set(),
+    })
+}
+
+/// Delete a [`wasmer_cpu_features_t`].
+///
+/// # Example
+///
+/// See [`wasmer_cpu_features_t`].
+#[no_mangle]
+pub extern "C" fn wasmer_cpu_features_delete(_cpu_features: Option<Box<wasmer_cpu_features_t>>) {}
+
+/// Add a new CPU feature into the set represented by
+/// [`wasmer_cpu_features_t`].
+///
+/// # Example
+///
+/// See [`wasmer_cpu_features_t`].
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_cpu_features_add(
+    cpu_features: Option<&mut wasmer_cpu_features_t>,
+    feature: Option<&wasm_name_t>,
+) -> bool {
+    let cpu_features = match cpu_features {
+        Some(cpu_features) => cpu_features,
+        _ => return false,
+    };
+    let feature = match feature {
+        Some(feature) => feature,
+        _ => return false,
+    };
+    let feature = c_try!(
+        str::from_utf8(slice::from_raw_parts(
+            feature.data,
+            feature.size,
+        ));
+        otherwise false
+    );
+
+    cpu_features.inner.insert(c_try!(
+        CpuFeature::from_str(feature);
+        otherwise false
+    ));
+
+    true
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/wasi.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/wasi.rs
new file mode 100644
index 0000000..f37a5e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/unstable/wasi.rs
@@ -0,0 +1,183 @@
+//! Unstable non-standard Wasmer-specific API that contains more WASI
+//! API.
+
+use super::super::{
+    externals::wasm_extern_t, module::wasm_module_t, types::wasm_name_t, wasi::wasi_env_t,
+};
+
+/// Unstable non-standard type wrapping `wasm_extern_t` with the
+/// addition of two `wasm_name_t` respectively for the module name and
+/// the name of the extern (very likely to be an import). This
+/// non-standard type is used by the unstable non-standard
+/// `wasi_get_unordered_imports` function.
+///
+/// The `module`, `name` and `extern` fields are all owned by this type.
+#[allow(non_camel_case_types)]
+#[derive(Clone)]
+pub struct wasmer_named_extern_t {
+    module: wasm_name_t,
+    name: wasm_name_t,
+    r#extern: Box<wasm_extern_t>,
+}
+
+wasm_declare_boxed_vec!(named_extern, wasmer);
+
+/// So. Let's explain a dirty hack. `cbindgen` reads the code and
+/// collects symbols. What symbols do we need? None of the one
+/// declared in `wasm.h`, but for non-standard API, we need to collect
+/// all of them. The problem is that `wasmer_named_extern_t` is the only
+/// non-standard type where extra symbols are generated by a macro
+/// (`wasm_declare_boxed_vec!`). If we want those macro-generated
+/// symbols to be collected by `cbindgen`, we need to _expand_ the
+/// crate (i.e. running something like `rustc -- -Zunstable-options
+/// --pretty=expanded`). Expanding code is unstable and available only
+/// on nightly compiler. We _don't want_ to use a nightly compiler
+/// only for that. So how can we help `cbindgen` to _see_ those
+/// symbols?
+///
+/// First solution: We write the C code directly in a file, which is
+/// then included in the generated header file with the `cbindgen`
+/// API. Problem, it's super easy to get it outdated, and it makes the
+/// build process more complex.
+///
+/// Second solution: We write those symbols in a custom module, that
+/// is just here for `cbindgen`, never used by our Rust code
+/// (otherwise it's duplicated code), with no particular
+/// implementation.
+///
+/// And that's why we have the following `cbindgen_hack`
+/// module.
+///
+/// But this module must not be compiled by `rustc`. How to force
+/// `rustc` to ignore a module? With conditional compilation. Because
+/// `cbindgen` does not support conditional compilation, it will
+/// always _ignore_ the `#[cfg]` attribute, and will always read the
+/// content of the module.
+///
+/// Sorry.
+#[doc(hidden)]
+#[cfg(__cbindgen_hack__ = "yes")]
+mod __cbindgen_hack__ {
+    use super::*;
+
+    #[repr(C)]
+    pub struct wasmer_named_extern_vec_t {
+        pub size: usize,
+        pub data: *mut *mut wasmer_named_extern_t,
+    }
+
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_named_extern_vec_new(
+        out: *mut wasmer_named_extern_vec_t,
+        length: usize,
+        init: *const *mut wasmer_named_extern_t,
+    ) {
+        unimplemented!()
+    }
+
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_named_extern_vec_new_uninitialized(
+        out: *mut wasmer_named_extern_vec_t,
+        length: usize,
+    ) {
+        unimplemented!()
+    }
+
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_named_extern_vec_copy(
+        out_ptr: &mut wasmer_named_extern_vec_t,
+        in_ptr: &wasmer_named_extern_vec_t,
+    ) {
+        unimplemented!()
+    }
+
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_named_extern_vec_delete(
+        ptr: Option<&mut wasmer_named_extern_vec_t>,
+    ) {
+        unimplemented!()
+    }
+
+    #[no_mangle]
+    pub unsafe extern "C" fn wasmer_named_extern_vec_new_empty(
+        out: *mut wasmer_named_extern_vec_t,
+    ) {
+        unimplemented!()
+    }
+}
+
+/// Non-standard function to get the module name of a
+/// `wasmer_named_extern_t`.
+///
+/// The returned value isn't owned by the caller.
+#[no_mangle]
+pub extern "C" fn wasmer_named_extern_module(
+    named_extern: Option<&wasmer_named_extern_t>,
+) -> Option<&wasm_name_t> {
+    Some(&named_extern?.module)
+}
+
+/// Non-standard function to get the name of a `wasmer_named_extern_t`.
+///
+/// The returned value isn't owned by the caller.
+#[no_mangle]
+pub extern "C" fn wasmer_named_extern_name(
+    named_extern: Option<&wasmer_named_extern_t>,
+) -> Option<&wasm_name_t> {
+    Some(&named_extern?.name)
+}
+
+/// Non-standard function to get the wrapped extern of a
+/// `wasmer_named_extern_t`.
+///
+/// The returned value isn't owned by the caller.
+#[no_mangle]
+pub extern "C" fn wasmer_named_extern_unwrap(
+    named_extern: Option<&wasmer_named_extern_t>,
+) -> Option<&wasm_extern_t> {
+    Some(named_extern?.r#extern.as_ref())
+}
+
+/// Non-standard function to get the imports needed for the WASI
+/// implementation with no particular order. Each import has its
+/// associated module name and name, so that it can be re-order later
+/// based on the `wasm_module_t` requirements.
+#[no_mangle]
+pub unsafe extern "C" fn wasi_get_unordered_imports(
+    wasi_env: Option<&mut wasi_env_t>,
+    module: Option<&wasm_module_t>,
+    imports: &mut wasmer_named_extern_vec_t,
+) -> bool {
+    wasi_get_unordered_imports_inner(wasi_env, module, imports).is_some()
+}
+
+unsafe fn wasi_get_unordered_imports_inner(
+    wasi_env: Option<&mut wasi_env_t>,
+    module: Option<&wasm_module_t>,
+    imports: &mut wasmer_named_extern_vec_t,
+) -> Option<()> {
+    let wasi_env = wasi_env?;
+    let store = &mut wasi_env.store;
+    let mut store_mut = store.store_mut();
+    let module = module?;
+
+    let import_object = c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner));
+
+    imports.set_buffer(
+        import_object
+            .into_iter()
+            .map(move |((module, name), extern_)| {
+                let module = module.into();
+                let name = name.into();
+
+                Some(Box::new(wasmer_named_extern_t {
+                    module,
+                    name,
+                    r#extern: Box::new(wasm_extern_t::new(store.clone(), extern_)),
+                }))
+            })
+            .collect::<Vec<_>>(),
+    );
+
+    Some(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/value.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/value.rs
new file mode 100644
index 0000000..737975f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/value.rs
@@ -0,0 +1,239 @@
+use super::types::{wasm_ref_t, wasm_valkind_enum};
+use std::convert::{TryFrom, TryInto};
+use wasmer_api::Value;
+
+/// Represents the kind of values. The variants of this C enum is
+/// defined in `wasm.h` to list the following:
+///
+/// * `WASM_I32`, a 32-bit integer,
+/// * `WASM_I64`, a 64-bit integer,
+/// * `WASM_F32`, a 32-bit float,
+/// * `WASM_F64`, a 64-bit float,
+/// * `WASM_ANYREF`, a WebAssembly reference,
+/// * `WASM_FUNCREF`, a WebAssembly reference.
+#[allow(non_camel_case_types)]
+pub type wasm_valkind_t = u8;
+
+/// A Rust union, compatible with C, that holds a value of kind
+/// [`wasm_valkind_t`] (see [`wasm_val_t`] to get the complete
+/// picture). Members of the union are:
+///
+/// * `int32_t` if the value is a 32-bit integer,
+/// * `int64_t` if the value is a 64-bit integer,
+/// * `float32_t` if the value is a 32-bit float,
+/// * `float64_t` if the value is a 64-bit float,
+/// * `wref` (`wasm_ref_t`) if the value is a WebAssembly reference.
+#[allow(non_camel_case_types)]
+#[derive(Clone, Copy)]
+pub union wasm_val_inner {
+    pub(crate) int32_t: i32,
+    pub(crate) int64_t: i64,
+    pub(crate) float32_t: f32,
+    pub(crate) float64_t: f64,
+    pub(crate) wref: *mut wasm_ref_t,
+}
+
+/// A WebAssembly value composed of its type and its value.
+///
+/// Note that `wasm.h` defines macros to create Wasm values more
+/// easily: `WASM_I32_VAL`, `WASM_I64_VAL`, `WASM_F32_VAL`,
+/// `WASM_F64_VAL`, and `WASM_REF_VAL`.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Create a 32-bit integer Wasm value.
+///     wasm_val_t value1 = {
+///         .kind = WASM_I32,
+///         .of = { .i32 = 7 },
+///     };
+///
+///     // Create the same value with the `wasm.h` macro.
+///     wasm_val_t value2 = WASM_I32_VAL(7);
+///
+///     assert(value2.kind == WASM_I32);
+///     assert(value1.of.i32 == value2.of.i32);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success();
+/// # }
+/// ```
+#[allow(non_camel_case_types)]
+#[repr(C)]
+pub struct wasm_val_t {
+    /// The kind of the value.
+    pub kind: wasm_valkind_t,
+
+    /// The real value.
+    pub of: wasm_val_inner,
+}
+
+impl std::fmt::Debug for wasm_val_t {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let mut ds = f.debug_struct("wasm_val_t");
+        ds.field("kind", &self.kind);
+
+        match self.kind.try_into() {
+            Ok(wasm_valkind_enum::WASM_I32) => {
+                ds.field("i32", &unsafe { self.of.int32_t });
+            }
+            Ok(wasm_valkind_enum::WASM_I64) => {
+                ds.field("i64", &unsafe { self.of.int64_t });
+            }
+            Ok(wasm_valkind_enum::WASM_F32) => {
+                ds.field("f32", &unsafe { self.of.float32_t });
+            }
+            Ok(wasm_valkind_enum::WASM_F64) => {
+                ds.field("f64", &unsafe { self.of.float64_t });
+            }
+            Ok(wasm_valkind_enum::WASM_ANYREF) => {
+                ds.field("anyref", &unsafe { self.of.wref });
+            }
+
+            Ok(wasm_valkind_enum::WASM_FUNCREF) => {
+                ds.field("funcref", &unsafe { self.of.wref });
+            }
+            Err(_) => {
+                ds.field("value", &"Invalid value type");
+            }
+        }
+        ds.finish()
+    }
+}
+
+wasm_declare_vec!(val);
+
+impl Clone for wasm_val_t {
+    fn clone(&self) -> Self {
+        wasm_val_t {
+            kind: self.kind,
+            of: self.of,
+        }
+    }
+}
+
+impl Default for wasm_val_t {
+    fn default() -> Self {
+        Self {
+            kind: wasm_valkind_enum::WASM_I64 as _,
+            of: wasm_val_inner { int64_t: 0 },
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_val_copy(
+    // own
+    out: &mut wasm_val_t,
+    val: &wasm_val_t,
+) {
+    out.kind = val.kind;
+    out.of = c_try!(val.kind.try_into().map(|kind| {
+        match kind {
+            wasm_valkind_enum::WASM_I32 => wasm_val_inner {
+                int32_t: val.of.int32_t,
+            },
+            wasm_valkind_enum::WASM_I64 => wasm_val_inner {
+                int64_t: val.of.int64_t,
+            },
+            wasm_valkind_enum::WASM_F32 => wasm_val_inner {
+                float32_t: val.of.float32_t,
+            },
+            wasm_valkind_enum::WASM_F64 => wasm_val_inner {
+                float64_t: val.of.float64_t,
+            },
+            wasm_valkind_enum::WASM_ANYREF => wasm_val_inner { wref: val.of.wref },
+            wasm_valkind_enum::WASM_FUNCREF => wasm_val_inner { wref: val.of.wref },
+        }
+    }); otherwise ());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasm_val_delete(val: Option<Box<wasm_val_t>>) {
+    if let Some(val) = val {
+        // TODO: figure out where wasm_val is allocated first...
+        let _ = val;
+    }
+}
+
+impl TryFrom<wasm_valkind_t> for wasm_valkind_enum {
+    type Error = &'static str;
+
+    fn try_from(item: wasm_valkind_t) -> Result<Self, Self::Error> {
+        Ok(match item {
+            0 => wasm_valkind_enum::WASM_I32,
+            1 => wasm_valkind_enum::WASM_I64,
+            2 => wasm_valkind_enum::WASM_F32,
+            3 => wasm_valkind_enum::WASM_F64,
+            128 => wasm_valkind_enum::WASM_ANYREF,
+            129 => wasm_valkind_enum::WASM_FUNCREF,
+            _ => return Err("valkind value out of bounds"),
+        })
+    }
+}
+
+impl TryFrom<wasm_val_t> for Value {
+    type Error = &'static str;
+
+    fn try_from(item: wasm_val_t) -> Result<Self, Self::Error> {
+        (&item).try_into()
+    }
+}
+
+impl TryFrom<&wasm_val_t> for Value {
+    type Error = &'static str;
+
+    fn try_from(item: &wasm_val_t) -> Result<Self, Self::Error> {
+        Ok(match item.kind.try_into()? {
+            wasm_valkind_enum::WASM_I32 => Value::I32(unsafe { item.of.int32_t }),
+            wasm_valkind_enum::WASM_I64 => Value::I64(unsafe { item.of.int64_t }),
+            wasm_valkind_enum::WASM_F32 => Value::F32(unsafe { item.of.float32_t }),
+            wasm_valkind_enum::WASM_F64 => Value::F64(unsafe { item.of.float64_t }),
+            wasm_valkind_enum::WASM_ANYREF => return Err("ANYREF not supported at this time"),
+            wasm_valkind_enum::WASM_FUNCREF => return Err("FUNCREF not supported at this time"),
+        })
+    }
+}
+
+impl TryFrom<Value> for wasm_val_t {
+    type Error = &'static str;
+
+    fn try_from(item: Value) -> Result<Self, Self::Error> {
+        wasm_val_t::try_from(&item)
+    }
+}
+
+impl TryFrom<&Value> for wasm_val_t {
+    type Error = &'static str;
+
+    fn try_from(item: &Value) -> Result<Self, Self::Error> {
+        Ok(match *item {
+            Value::I32(v) => wasm_val_t {
+                of: wasm_val_inner { int32_t: v },
+                kind: wasm_valkind_enum::WASM_I32 as _,
+            },
+            Value::I64(v) => wasm_val_t {
+                of: wasm_val_inner { int64_t: v },
+                kind: wasm_valkind_enum::WASM_I64 as _,
+            },
+            Value::F32(v) => wasm_val_t {
+                of: wasm_val_inner { float32_t: v },
+                kind: wasm_valkind_enum::WASM_F32 as _,
+            },
+            Value::F64(v) => wasm_val_t {
+                of: wasm_val_inner { float64_t: v },
+                kind: wasm_valkind_enum::WASM_F64 as _,
+            },
+            Value::V128(_) => return Err("128bit SIMD types not yet supported in Wasm C API"),
+            _ => todo!("Handle these values in TryFrom<Value> for wasm_val_t"),
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/version.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/version.rs
new file mode 100644
index 0000000..337ad73
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/version.rs
@@ -0,0 +1,124 @@
+use lazy_static::lazy_static;
+use std::os::raw::c_char;
+
+const VERSION: &str = concat!(env!("CARGO_PKG_VERSION"), "\0");
+const VERSION_PRE: &str = concat!(env!("CARGO_PKG_VERSION_PRE"), "\0");
+
+lazy_static! {
+    static ref VERSION_MAJOR: u8 = env!("CARGO_PKG_VERSION_MAJOR")
+        .parse()
+        .expect("Failed to parse value for `VERSION_MAJOR` from `CARGO_PKG_VERSION_MAJOR`");
+    static ref VERSION_MINOR: u8 = env!("CARGO_PKG_VERSION_MINOR")
+        .parse()
+        .expect("Failed to parse value for `VERSION_MINOR` from `CARGO_PKG_VERSION_MINOR`");
+    static ref VERSION_PATCH: u8 = env!("CARGO_PKG_VERSION_PATCH")
+        .parse()
+        .expect("Failed to parse value for `VERSION_PATCH` from `CARGO_PKG_VERSION_PATCH`");
+}
+
+/// Get the version of the Wasmer C API.
+///
+/// The `.h` files already define variables like `WASMER_VERSION*`,
+/// but if this file is unreachable, one can use this function to
+/// retrieve the full semver version of the Wasmer C API.
+///
+/// The returned string is statically allocated. It must _not_ be
+/// freed!
+///
+/// # Example
+///
+/// See the module's documentation.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_version() -> *const c_char {
+    VERSION.as_ptr() as *const _
+}
+
+/// Get the major version of the Wasmer C API.
+///
+/// See [`wasmer_version`] to learn more.
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Get and print the version components.
+///     uint8_t version_major = wasmer_version_major();
+///     uint8_t version_minor = wasmer_version_minor();
+///     uint8_t version_patch = wasmer_version_patch();
+///
+///     printf("%d.%d.%d", version_major, version_minor, version_patch);
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success()
+/// #    .stdout(
+/// #         format!(
+/// #             "{}.{}.{}",
+/// #             env!("CARGO_PKG_VERSION_MAJOR"),
+/// #             env!("CARGO_PKG_VERSION_MINOR"),
+/// #             env!("CARGO_PKG_VERSION_PATCH")
+/// #         )
+/// #     );
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_version_major() -> u8 {
+    *VERSION_MAJOR
+}
+
+/// Get the minor version of the Wasmer C API.
+///
+/// See [`wasmer_version_major`] to learn more and get an example.  
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_version_minor() -> u8 {
+    *VERSION_MINOR
+}
+
+/// Get the patch version of the Wasmer C API.
+///
+/// See [`wasmer_version_major`] to learn more and get an example.  
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_version_patch() -> u8 {
+    *VERSION_PATCH
+}
+
+/// Get the minor version of the Wasmer C API.
+///
+/// See [`wasmer_version_major`] to learn more.
+///
+/// The returned string is statically allocated. It must _not_ be
+/// freed!
+///
+/// # Example
+///
+/// ```rust
+/// # use wasmer_inline_c::assert_c;
+/// # fn main() {
+/// #    (assert_c! {
+/// # #include "tests/wasmer.h"
+/// #
+/// int main() {
+///     // Get and print the pre version.
+///     const char* version_pre = wasmer_version_pre();
+///     printf("%s", version_pre);
+///
+///     // No need to free the string. It's statically allocated on
+///     // the Rust side.
+///
+///     return 0;
+/// }
+/// #    })
+/// #    .success()
+/// #    .stdout(env!("CARGO_PKG_VERSION_PRE"));
+/// # }
+/// ```
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_version_pre() -> *const c_char {
+    VERSION_PRE.as_ptr() as *const _
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wasi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wasi/mod.rs
new file mode 100644
index 0000000..f8e52e9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wasi/mod.rs
@@ -0,0 +1,715 @@
+//! Unofficial API for WASI integrating with the standard Wasm C API.
+//!
+//! This API will be superseded by a standard WASI API when/if such a standard is created.
+
+pub use super::unstable::wasi::wasi_get_unordered_imports;
+use super::{
+    externals::{wasm_extern_t, wasm_extern_vec_t, wasm_func_t, wasm_memory_t},
+    instance::wasm_instance_t,
+    module::wasm_module_t,
+    store::{wasm_store_t, StoreRef},
+    types::wasm_byte_vec_t,
+};
+use crate::error::update_last_error;
+use std::convert::TryFrom;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+use std::slice;
+use std::sync::Arc;
+#[cfg(feature = "webc_runner")]
+use wasmer_api::{AsStoreMut, Imports, Module};
+use wasmer_wasix::{
+    default_fs_backing, get_wasi_version,
+    runtime::task_manager::{tokio::TokioTaskManager, InlineWaker},
+    virtual_fs::AsyncReadExt,
+    virtual_fs::VirtualFile,
+    Pipe, PluggableRuntime, WasiEnv, WasiEnvBuilder, WasiFunctionEnv, WasiVersion,
+};
+
+#[derive(Debug)]
+#[allow(non_camel_case_types)]
+pub struct wasi_config_t {
+    inherit_stdout: bool,
+    inherit_stderr: bool,
+    inherit_stdin: bool,
+    builder: WasiEnvBuilder,
+    runtime: Option<tokio::runtime::Runtime>,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_new(
+    program_name: *const c_char,
+) -> Option<Box<wasi_config_t>> {
+    debug_assert!(!program_name.is_null());
+
+    let name_c_str = CStr::from_ptr(program_name);
+    let prog_name = c_try!(name_c_str.to_str());
+
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .unwrap();
+    let _guard = runtime.enter();
+
+    Some(Box::new(wasi_config_t {
+        inherit_stdout: true,
+        inherit_stderr: true,
+        inherit_stdin: true,
+        builder: WasiEnv::builder(prog_name).fs(default_fs_backing()),
+        runtime: Some(runtime),
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_env(
+    config: &mut wasi_config_t,
+    key: *const c_char,
+    value: *const c_char,
+) {
+    debug_assert!(!key.is_null());
+    debug_assert!(!value.is_null());
+
+    let key_cstr = CStr::from_ptr(key);
+    let key_bytes = key_cstr.to_bytes();
+    let value_cstr = CStr::from_ptr(value);
+    let value_bytes = value_cstr.to_bytes();
+
+    config.builder.add_env(key_bytes, value_bytes);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_arg(config: &mut wasi_config_t, arg: *const c_char) {
+    debug_assert!(!arg.is_null());
+
+    let arg_cstr = CStr::from_ptr(arg);
+    let arg_bytes = arg_cstr.to_bytes();
+
+    config.builder.add_arg(arg_bytes);
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_preopen_dir(
+    config: &mut wasi_config_t,
+    dir: *const c_char,
+) -> bool {
+    let dir_cstr = CStr::from_ptr(dir);
+    let dir_bytes = dir_cstr.to_bytes();
+    let dir_str = match std::str::from_utf8(dir_bytes) {
+        Ok(dir_str) => dir_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    if let Err(e) = config.builder.add_preopen_dir(dir_str) {
+        update_last_error(e);
+        return false;
+    }
+
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_config_mapdir(
+    config: &mut wasi_config_t,
+    alias: *const c_char,
+    dir: *const c_char,
+) -> bool {
+    let alias_cstr = CStr::from_ptr(alias);
+    let alias_bytes = alias_cstr.to_bytes();
+    let alias_str = match std::str::from_utf8(alias_bytes) {
+        Ok(alias_str) => alias_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    let dir_cstr = CStr::from_ptr(dir);
+    let dir_bytes = dir_cstr.to_bytes();
+    let dir_str = match std::str::from_utf8(dir_bytes) {
+        Ok(dir_str) => dir_str,
+        Err(e) => {
+            update_last_error(e);
+            return false;
+        }
+    };
+
+    if let Err(e) = config.builder.add_map_dir(alias_str, dir_str) {
+        update_last_error(e);
+        return false;
+    }
+
+    true
+}
+
+#[no_mangle]
+pub extern "C" fn wasi_config_capture_stdout(config: &mut wasi_config_t) {
+    config.inherit_stdout = false;
+}
+
+#[no_mangle]
+pub extern "C" fn wasi_config_inherit_stdout(config: &mut wasi_config_t) {
+    config.inherit_stdout = true;
+}
+
+#[no_mangle]
+pub extern "C" fn wasi_config_capture_stderr(config: &mut wasi_config_t) {
+    config.inherit_stderr = false;
+}
+
+#[no_mangle]
+pub extern "C" fn wasi_config_inherit_stderr(config: &mut wasi_config_t) {
+    config.inherit_stderr = true;
+}
+
+//#[no_mangle]
+//pub extern "C" fn wasi_config_capture_stdin(config: &mut wasi_config_t) {
+//    config.inherit_stdin = false;
+//}
+
+#[no_mangle]
+pub extern "C" fn wasi_config_inherit_stdin(config: &mut wasi_config_t) {
+    config.inherit_stdin = true;
+}
+
+#[repr(C)]
+pub struct wasi_filesystem_t {
+    ptr: *const c_char,
+    size: usize,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_filesystem_init_static_memory(
+    volume_bytes: Option<&wasm_byte_vec_t>,
+) -> Option<Box<wasi_filesystem_t>> {
+    let volume_bytes = volume_bytes.as_ref()?;
+    Some(Box::new(wasi_filesystem_t {
+        ptr: {
+            let ptr = (volume_bytes.data.as_ref()?) as *const _ as *const c_char;
+            if ptr.is_null() {
+                return None;
+            }
+            ptr
+        },
+        size: volume_bytes.size,
+    }))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_filesystem_delete(ptr: *mut wasi_filesystem_t) {
+    let _ = Box::from_raw(ptr);
+}
+
+/// Initializes the `imports` with an import object that links to
+/// the custom file system
+#[cfg(feature = "webc_runner")]
+#[no_mangle]
+pub unsafe extern "C" fn wasi_env_with_filesystem(
+    config: Box<wasi_config_t>,
+    store: Option<&mut wasm_store_t>,
+    module: Option<&wasm_module_t>,
+    fs: Option<&wasi_filesystem_t>,
+    imports: Option<&mut wasm_extern_vec_t>,
+    package: *const c_char,
+) -> Option<Box<wasi_env_t>> {
+    wasi_env_with_filesystem_inner(config, store, module, fs, imports, package)
+}
+
+#[cfg(feature = "webc_runner")]
+unsafe fn wasi_env_with_filesystem_inner(
+    config: Box<wasi_config_t>,
+    store: Option<&mut wasm_store_t>,
+    module: Option<&wasm_module_t>,
+    fs: Option<&wasi_filesystem_t>,
+    imports: Option<&mut wasm_extern_vec_t>,
+    package: *const c_char,
+) -> Option<Box<wasi_env_t>> {
+    let store = &mut store?.inner;
+    let fs = fs.as_ref()?;
+    let package_str = CStr::from_ptr(package);
+    let package = package_str.to_str().unwrap_or("");
+    let module = &module.as_ref()?.inner;
+    let imports = imports?;
+
+    let (wasi_env, import_object) = prepare_webc_env(
+        config,
+        &mut store.store_mut(),
+        module,
+        &*(fs.ptr as *const u8), // cast wasi_filesystem_t.ptr as &'static [u8]
+        fs.size,
+        package,
+    )?;
+
+    imports_set_buffer(store, module, import_object, imports)?;
+
+    Some(Box::new(wasi_env_t {
+        inner: wasi_env,
+        store: store.clone(),
+    }))
+}
+
+#[cfg(feature = "webc_runner")]
+fn prepare_webc_env(
+    mut config: Box<wasi_config_t>,
+    store: &mut impl AsStoreMut,
+    module: &Module,
+    bytes: &'static u8,
+    len: usize,
+    package_name: &str,
+) -> Option<(WasiFunctionEnv, Imports)> {
+    use virtual_fs::static_fs::StaticFileSystem;
+    use webc::v1::{FsEntryType, WebC};
+
+    let store_mut = store.as_store_mut();
+    let runtime = config.runtime.take();
+
+    let runtime = runtime.unwrap_or_else(|| {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+    });
+
+    let handle = runtime.handle().clone();
+    let _guard = handle.enter();
+    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
+    rt.set_engine(Some(store_mut.engine().clone()));
+
+    let slice = unsafe { std::slice::from_raw_parts(bytes, len) };
+    let volumes = WebC::parse_volumes_from_fileblock(slice).ok()?;
+    let top_level_dirs = volumes
+        .into_iter()
+        .flat_map(|(_, volume)| {
+            volume
+                .header
+                .top_level
+                .iter()
+                .cloned()
+                .filter(|e| e.fs_type == FsEntryType::Dir)
+                .map(|e| e.text.to_string())
+                .collect::<Vec<_>>()
+                .into_iter()
+        })
+        .collect::<Vec<_>>();
+
+    let filesystem = Box::new(StaticFileSystem::init(slice, package_name)?);
+    let mut builder = config.builder.runtime(Arc::new(rt));
+
+    if !config.inherit_stdout {
+        builder.set_stdout(Box::new(Pipe::channel().0));
+    }
+
+    if !config.inherit_stderr {
+        builder.set_stderr(Box::new(Pipe::channel().0));
+    }
+
+    builder.set_fs(filesystem);
+
+    for f_name in top_level_dirs.iter() {
+        builder
+            .add_preopen_build(|p| p.directory(f_name).read(true).write(true).create(true))
+            .ok()?;
+    }
+    let env = builder.finalize(store).ok()?;
+
+    let import_object = env.import_object(store, module).ok()?;
+    Some((env, import_object))
+}
+
+#[allow(non_camel_case_types)]
+pub struct wasi_env_t {
+    /// cbindgen:ignore
+    pub(super) inner: WasiFunctionEnv,
+    pub(super) store: StoreRef,
+}
+
+/// Create a new WASI environment.
+///
+/// It take ownership over the `wasi_config_t`.
+#[no_mangle]
+pub unsafe extern "C" fn wasi_env_new(
+    store: Option<&mut wasm_store_t>,
+    mut config: Box<wasi_config_t>,
+) -> Option<Box<wasi_env_t>> {
+    let store = &mut store?.inner;
+    let mut store_mut = store.store_mut();
+
+    let runtime = config.runtime.take();
+
+    let runtime = runtime.unwrap_or_else(|| {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap()
+    });
+
+    let handle = runtime.handle().clone();
+    let _guard = handle.enter();
+    let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
+    rt.set_engine(Some(store_mut.engine().clone()));
+
+    if !config.inherit_stdout {
+        config.builder.set_stdout(Box::new(Pipe::channel().0));
+    }
+
+    if !config.inherit_stderr {
+        config.builder.set_stderr(Box::new(Pipe::channel().0));
+    }
+
+    // TODO: impl capturer for stdin
+
+    let env = c_try!(config
+        .builder
+        .runtime(Arc::new(rt))
+        .finalize(&mut store_mut));
+
+    Some(Box::new(wasi_env_t {
+        inner: env,
+        store: store.clone(),
+    }))
+}
+
+/// Delete a [`wasi_env_t`].
+#[no_mangle]
+pub extern "C" fn wasi_env_delete(state: Option<Box<wasi_env_t>>) {
+    if let Some(mut env) = state {
+        env.inner
+            .on_exit(unsafe { &mut env.store.store_mut() }, None);
+    }
+}
+
+/// Set the memory on a [`wasi_env_t`].
+// NOTE: Only here to not break the C API.
+// This was previosly supported, but is no longer possible due to WASIX changes.
+// Customizing memories should be done through the builder or the runtime.
+#[no_mangle]
+#[deprecated(since = "4.0.0")]
+pub unsafe extern "C" fn wasi_env_set_memory(_env: &mut wasi_env_t, _memory: &wasm_memory_t) {
+    panic!("wasmer_env_set_memory() is not supported");
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_env_read_stdout(
+    env: &mut wasi_env_t,
+    buffer: *mut c_char,
+    buffer_len: usize,
+) -> isize {
+    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
+    let store = env.store.store();
+
+    let stdout = {
+        let data = env.inner.data(&store);
+        data.stdout()
+    };
+
+    if let Ok(mut stdout) = stdout {
+        if let Some(stdout) = stdout.as_mut() {
+            read_inner(stdout, inner_buffer)
+        } else {
+            update_last_error("could not find a file handle for `stdout`");
+            -1
+        }
+    } else {
+        update_last_error("could not find a file handle for `stdout`");
+        -1
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_env_read_stderr(
+    env: &mut wasi_env_t,
+    buffer: *mut c_char,
+    buffer_len: usize,
+) -> isize {
+    let inner_buffer = slice::from_raw_parts_mut(buffer as *mut _, buffer_len);
+    let store = env.store.store();
+    let stderr = {
+        let data = env.inner.data(&store);
+        data.stderr()
+    };
+    if let Ok(mut stderr) = stderr {
+        if let Some(stderr) = stderr.as_mut() {
+            read_inner(stderr, inner_buffer)
+        } else {
+            update_last_error("could not find a file handle for `stderr`");
+            -1
+        }
+    } else {
+        update_last_error("could not find a file handle for `stderr`");
+        -1
+    }
+}
+
+fn read_inner(
+    wasi_file: &mut Box<dyn VirtualFile + Send + Sync + 'static>,
+    inner_buffer: &mut [u8],
+) -> isize {
+    InlineWaker::block_on(async {
+        match wasi_file.read(inner_buffer).await {
+            Ok(a) => a as isize,
+            Err(err) => {
+                update_last_error(format!("failed to read wasi_file: {}", err));
+                -1
+            }
+        }
+    })
+}
+
+/// The version of WASI. This is determined by the imports namespace
+/// string.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(C)]
+#[allow(non_camel_case_types)]
+pub enum wasi_version_t {
+    /// An invalid version.
+    INVALID_VERSION = -1,
+
+    /// Latest version.
+    ///
+    /// It's a “floating” version, i.e. it's an alias to the latest
+    /// version (for the moment, `Snapshot1`). Using this version is a
+    /// way to ensure that modules will run only if they come with the
+    /// latest WASI version (in case of security issues for instance),
+    /// by just updating the runtime.
+    ///
+    /// Note that this version is never returned by an API. It is
+    /// provided only by the user.
+    LATEST = 0,
+
+    /// `wasi_unstable`.
+    SNAPSHOT0 = 1,
+
+    /// `wasi_snapshot_preview1`.
+    SNAPSHOT1 = 2,
+
+    /// `wasix_32v1`.
+    WASIX32V1 = 3,
+
+    /// `wasix_64v1`.
+    WASIX64V1 = 4,
+}
+
+impl From<WasiVersion> for wasi_version_t {
+    fn from(other: WasiVersion) -> Self {
+        match other {
+            WasiVersion::Snapshot0 => wasi_version_t::SNAPSHOT0,
+            WasiVersion::Snapshot1 => wasi_version_t::SNAPSHOT1,
+            WasiVersion::Wasix32v1 => wasi_version_t::WASIX32V1,
+            WasiVersion::Wasix64v1 => wasi_version_t::WASIX64V1,
+            WasiVersion::Latest => wasi_version_t::LATEST,
+        }
+    }
+}
+
+impl TryFrom<wasi_version_t> for WasiVersion {
+    type Error = &'static str;
+
+    fn try_from(other: wasi_version_t) -> Result<Self, Self::Error> {
+        Ok(match other {
+            wasi_version_t::INVALID_VERSION => return Err("Invalid WASI version cannot be used"),
+            wasi_version_t::SNAPSHOT0 => WasiVersion::Snapshot0,
+            wasi_version_t::SNAPSHOT1 => WasiVersion::Snapshot1,
+            wasi_version_t::WASIX32V1 => WasiVersion::Wasix32v1,
+            wasi_version_t::WASIX64V1 => WasiVersion::Wasix64v1,
+            wasi_version_t::LATEST => WasiVersion::Latest,
+        })
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_get_wasi_version(module: &wasm_module_t) -> wasi_version_t {
+    get_wasi_version(&module.inner, false)
+        .map(Into::into)
+        .unwrap_or(wasi_version_t::INVALID_VERSION)
+}
+
+/// Non-standard function to get the imports needed for the WASI
+/// implementation ordered as expected by the `wasm_module_t`.
+#[no_mangle]
+pub unsafe extern "C" fn wasi_get_imports(
+    _store: Option<&wasm_store_t>,
+    wasi_env: Option<&mut wasi_env_t>,
+    module: Option<&wasm_module_t>,
+    imports: &mut wasm_extern_vec_t,
+) -> bool {
+    wasi_get_imports_inner(wasi_env, module, imports).is_some()
+}
+
+unsafe fn wasi_get_imports_inner(
+    wasi_env: Option<&mut wasi_env_t>,
+    module: Option<&wasm_module_t>,
+    imports: &mut wasm_extern_vec_t,
+) -> Option<()> {
+    let wasi_env = wasi_env?;
+    let store = &mut wasi_env.store;
+    let mut store_mut = store.store_mut();
+    let module = module?;
+
+    let import_object = c_try!(wasi_env.inner.import_object(&mut store_mut, &module.inner));
+
+    imports_set_buffer(store, &module.inner, import_object, imports)?;
+
+    Some(())
+}
+
+pub(crate) fn imports_set_buffer(
+    store: &StoreRef,
+    module: &wasmer_api::Module,
+    import_object: wasmer_api::Imports,
+    imports: &mut wasm_extern_vec_t,
+) -> Option<()> {
+    imports.set_buffer(c_try!(module
+        .imports()
+        .map(|import_type| {
+            let ext = import_object
+                .get_export(import_type.module(), import_type.name())
+                .ok_or_else(|| {
+                    format!(
+                        "Failed to resolve import \"{}\" \"{}\"",
+                        import_type.module(),
+                        import_type.name()
+                    )
+                })?;
+
+            Ok(Some(Box::new(wasm_extern_t::new(store.clone(), ext))))
+        })
+        .collect::<Result<Vec<_>, String>>()));
+
+    Some(())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_env_initialize_instance(
+    wasi_env: &mut wasi_env_t,
+    store: &mut wasm_store_t,
+    instance: &mut wasm_instance_t,
+) -> bool {
+    wasi_env
+        .inner
+        .initialize(&mut store.inner.store_mut(), instance.inner.clone())
+        .unwrap();
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasi_get_start_function(
+    instance: &mut wasm_instance_t,
+) -> Option<Box<wasm_func_t>> {
+    let start = c_try!(instance.inner.exports.get_function("_start"));
+
+    Some(Box::new(wasm_func_t {
+        extern_: wasm_extern_t::new(instance.store.clone(), start.clone().into()),
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_wasi_get_wasi_version_snapshot0() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_unstable\" \"args_get\" (func (param i32 i32) (result i32))))");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                assert(wasi_get_wasi_version(module) == SNAPSHOT0);
+
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasmer_funcenv_delete(env);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_wasi_get_wasi_version_snapshot1() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snapshot_preview1\" \"args_get\" (func (param i32 i32) (result i32))))");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                assert(wasi_get_wasi_version(module) == SNAPSHOT1);
+
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasmer_funcenv_delete(env);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[cfg_attr(coverage, ignore)]
+    #[test]
+    fn test_wasi_get_wasi_version_invalid() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_engine_t* engine = wasm_engine_new();
+                wasm_store_t* store = wasm_store_new(engine);
+                wasmer_funcenv_t* env = wasmer_funcenv_new(store, 0);
+
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module (import \"wasi_snpsht_prvw1\" \"args_get\" (func (param i32 i32) (result i32))))");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                wasm_module_t* module = wasm_module_new(store, &wasm);
+                assert(module);
+
+                assert(wasi_get_wasi_version(module) == INVALID_VERSION);
+
+                wasm_module_delete(module);
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+                wasmer_funcenv_delete(env);
+                wasm_store_delete(store);
+                wasm_engine_delete(engine);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wat.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wat.rs
new file mode 100644
index 0000000..4d0c392
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/src/wasm_c_api/wat.rs
@@ -0,0 +1,88 @@
+use super::types::wasm_byte_vec_t;
+
+/// Parses in-memory bytes as either the WAT format, or a binary Wasm
+/// module. This is wasmer-specific.
+///
+/// In case of failure, `wat2wasm` sets the `out->data = NULL` and `out->size = 0`.
+///
+/// # Example
+///
+/// See the module's documentation.
+///
+/// # Safety
+/// This function is unsafe in order to be callable from C.
+#[cfg(feature = "wat")]
+#[no_mangle]
+pub unsafe extern "C" fn wat2wasm(wat: &wasm_byte_vec_t, out: &mut wasm_byte_vec_t) {
+    match wasmer_api::wat2wasm(wat.as_slice()) {
+        Ok(val) => out.set_buffer(val.into_owned()),
+        Err(err) => {
+            crate::error::update_last_error(err);
+            out.data = std::ptr::null_mut();
+            out.size = 0;
+        }
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(target_os = "windows"))]
+    use inline_c::assert_c;
+    #[cfg(target_os = "windows")]
+    use wasmer_inline_c::assert_c;
+
+    #[test]
+    fn test_wat2wasm() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module)");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                assert(wasm.data);
+                assert(wasm.size == 8);
+                assert(
+                    wasm.data[0] == 0 &&
+                        wasm.data[1] == 'a' &&
+                        wasm.data[2] == 's' &&
+                        wasm.data[3] == 'm' &&
+                        wasm.data[4] == 1 &&
+                        wasm.data[5] == 0 &&
+                        wasm.data[6] == 0 &&
+                        wasm.data[7] == 0
+                );
+
+                wasm_byte_vec_delete(&wasm);
+                wasm_byte_vec_delete(&wat);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+
+    #[test]
+    fn test_wat2wasm_failed() {
+        (assert_c! {
+            #include "tests/wasmer.h"
+
+            int main() {
+                wasm_byte_vec_t wat;
+                wasmer_byte_vec_new_from_string(&wat, "(module");
+                wasm_byte_vec_t wasm;
+                wat2wasm(&wat, &wasm);
+
+                assert(!wasm.data);
+                assert(wasmer_last_error_length() > 0);
+
+                wasm_byte_vec_delete(&wat);
+
+                return 0;
+            }
+        })
+        .success();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/.gitignore
new file mode 100644
index 0000000..58fbd3c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/.gitignore
@@ -0,0 +1,11 @@
+# ignore wasm-c-api binaries
+wasm-c-api-*
+test-*
+wasm-c-api/example/*
+
+# Unignore files ending with `.c` (i.e. `wasm-c-api-wasi.c`)
+!*.c
+!wasm-c-api/example/*.c
+!wasm-c-api/example/*.cc
+!wasm-c-api/example/*.wasm
+!wasm-c-api/example/*.wat
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/Makefile b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/Makefile
new file mode 100644
index 0000000..596994e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/Makefile
@@ -0,0 +1,32 @@
+WASMER_DIR:=$(realpath $(WASMER_DIR))
+
+$(info Using provided WASMER_DIR=$(WASMER_DIR))
+
+ROOT_DIR:=$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
+ROOT_DIR_PARENT:=$(shell dirname $(ROOT_DIR))
+
+ifeq (,$(wildcard $(WASMER_DIR)/bin/wasmer))
+	CFLAGS = -g -I $(ROOT_DIR) -I $(WASMER_DIR)/include
+	LDFLAGS = -Wl,-rpath,$(WASMER_DIR)/lib
+	LDLIBS = -L $(WASMER_DIR)/lib -lwasmer
+else
+	CFLAGS = -g -I $(ROOT_DIR)/wasm-c-api/include/ -I $(shell $(WASMER_DIR)/bin/wasmer config --includedir)
+	LDFLAGS = -Wl,-rpath,$(shell $(WASMER_DIR)/bin/wasmer config --libdir)
+	LDLIBS = $(shell $(WASMER_DIR)/bin/wasmer config --libs)
+endif
+
+
+$(info * ROOT_DIR: $(ROOT_DIR))
+$(info * WASMER_DIR: $(WASMER_DIR))
+$(info * "")
+$(info * CFLAGS: $(CFLAGS))
+$(info * LDFLAGS: $(LDFLAGS))
+$(info * LDLIBS: $(LDLIBS))
+
+test: 
+	cargo test --manifest-path="./wasmer-c-api-test-runner/Cargo.toml" -- --nocapture 2>&1
+
+.SILENT: clean
+.PHONY: clean
+clean:
+	$(foreach file,$(ALL),rm -f $(file).o $(file))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/.gitignore
new file mode 100644
index 0000000..ad0095a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/.gitignore
@@ -0,0 +1,2 @@
+out
+v8
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/Dockerfile b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/Dockerfile
new file mode 100644
index 0000000..d9f8de7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/Dockerfile
@@ -0,0 +1,18 @@
+FROM ubuntu:bionic
+RUN apt-get update && apt-get install -y \
+    apt-utils \
+    clang \
+    cmake \
+    curl \
+    git \
+    libc++-dev \
+    libc++abi-dev \
+    libglib2.0-dev \
+    libgmp-dev \
+    ninja-build \
+    python
+ADD . /code/wasm-c-api
+WORKDIR /code/wasm-c-api
+RUN make v8-checkout
+RUN make -j v8
+RUN make
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/LICENSE b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/LICENSE
new file mode 100644
index 0000000..8f71f43
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/LICENSE
@@ -0,0 +1,202 @@
+                                 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/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/README.md b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/README.md
new file mode 100644
index 0000000..1dbcbda
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/README.md
@@ -0,0 +1,112 @@
+# WebAssembly C and C++ API 
+
+Work in progress! No docs yet.
+
+
+### Design Goals
+
+* Provide a "black box" API for embedding a Wasm engine in other C/C++ applications.
+
+  * Be completely agnostic to VM specifics.
+
+  * Non-goal: "white box" interoperability with embedder (such as combined GC instead of mere finalisation) -- *much* more difficult to achieve.
+
+* Allow creation of bindings for other languages through typical C foreign function interfaces.
+
+  * Support a plain C API.
+
+  * Stick to mostly manual memory management of interface objects.
+
+* Avoid language features that raise barrier to use.
+
+  * E.g., no exceptions or post-C++11 features in C++ API.
+
+  * E.g., no passing of structs by-value or post-C99 features in C API.
+
+* Achieve link-time compatibility between different implementations.
+
+  * All implementation-dependent API classes are abstract and can be instantiated through factory methods only.
+
+
+### Interfaces
+
+* C++ API:
+
+  * See `include/wasm.hh` for interface.
+
+  * See `example/*.cc` for example usages.
+
+* C API:
+
+  * See `include/wasm.h` for interface.
+
+  * See `example/*.c` for example usages.
+
+Some random explanations:
+
+* The VM must be initialised by creating an instance of an *engine* (`wasm::Engine`/`wasm_engine_t`) and is shut down by deleting it. Such an instance may only be created once per process.
+
+* All runtime objects are tied to a specific *store* (`wasm::Store`/`wasm_store_t`). Multiple stores can be created, but their objects cannot interact. Every store and its objects must only be accessed in a single thread.
+
+* To exchange module objects between threads, create a *shared* module (`wasm::Shared<Module>`/`wasm_shared_module_t`). Other objects cannot be shared in current Wasm.
+
+* *Vector* structures (`wasm::vec<X>`/`wasm_x_vec_t`) are lightweight abstractions of a pair of a plain array and its length. The C++ API does not use `std::vector` because that does not support adopting pre-existing arrays.
+
+* *References* point to runtime objects, but may involve internal indirections, which may or may not be cached. Thus, pointer equality on `Ref*` or subclasses cannot be used to compare identity of the underlying objects (`Ref::eq` may be added later). However, `nullptr`/`NULL` uniquely represents null references.
+
+* The API already encompasses current proposals like [multiple return values](https://github.com/WebAssembly/multi-value/blob/master/proposals/multi-value/Overview.md) and [reference types](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md), but not yet [threads](https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md).
+
+
+### Prototype Implementation
+
+* This repo contains a prototype implementation based on V8 is in `src`.
+
+  * Note that this requires adding a module to V8, so it patches V8's build file.
+
+* The C API is implemented on top of the C++ API.
+
+* See `Makefile` for build recipe. Canonical steps to run examples:
+
+  1. `make v8-checkout`
+  2. `make v8`
+  3. `make all`
+
+
+#### Limitations
+
+V8 implementation:
+
+* Currently requires patching V8 by adding a module.
+
+* Host functions (`Func::make`) create a JavaScript function internally, since V8 cannot handle raw C imports yet.
+
+* As a consequence, does not support multiple results in external calls or host functions.
+
+* Host functions and host globals are created through auxiliary modules constructed on the fly, to work around limitations in JS API.
+
+* `Shared<Module>` is currently implemented via serialisation, since V8 does not currently have direct support for cross-isolate sharing.
+
+
+### Other Implementations
+
+Currently, known implementations of this API are included in
+
+* V8 natively (both C and C++)
+* Wabt (only C?)
+* Wasmtime (only C?)
+* [Wasmer](https://github.com/wasmerio/wasmer/tree/master/lib/c-api) (only C, C++ coming soon)
+
+
+### TODO
+
+Possible API tweaks:
+
+  * Add `Ref::eq` (or better, a subclass `EqRef::eq`) for reference equality?
+
+  * Add a way to return error messages from `Module::make` and `Module::validate`.
+
+  * Use `restrict` in C API?
+
+  * Find a way to perform C callbacks through C++ without extra wrapper?
+
+  * Add iterators to `vec` class?
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.c
new file mode 100644
index 0000000..2fddb16
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.c
@@ -0,0 +1,167 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// Print a Wasm value
+void wasm_val_print(wasm_val_t val) {
+  switch (val.kind) {
+    case WASM_I32: {
+      printf("%" PRIu32, val.of.i32);
+    } break;
+    case WASM_I64: {
+      printf("%" PRIu64, val.of.i64);
+    } break;
+    case WASM_F32: {
+      printf("%f", val.of.f32);
+    } break;
+    case WASM_F64: {
+      printf("%g", val.of.f64);
+    } break;
+    case WASM_ANYREF:
+    case WASM_FUNCREF: {
+      if (val.of.ref == NULL) {
+        printf("null");
+      } else {
+        printf("ref(%p)", val.of.ref);
+      }
+    } break;
+  }
+}
+
+// A function to be called from Wasm code.
+own wasm_trap_t* print_callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n> ");
+  wasm_val_print(args->data[0]);
+  printf("\n");
+
+  wasm_val_copy(&results->data[0], &args->data[0]);
+  return NULL;
+}
+
+
+// A function closure.
+own wasm_trap_t* closure_callback(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  int i = *(int*)env;
+  printf("Calling back closure...\n");
+  printf("> %d\n", i);
+
+  results->data[0].kind = WASM_I32;
+  results->data[0].of.i32 = (int32_t)i;
+  return NULL;
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("callback.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external print functions.
+  printf("Creating callback...\n");
+  own wasm_functype_t* print_type = wasm_functype_new_1_1(wasm_valtype_new_i32(), wasm_valtype_new_i32());
+  own wasm_func_t* print_func = wasm_func_new(store, print_type, print_callback);
+
+  int i = 42;
+  own wasm_functype_t* closure_type = wasm_functype_new_0_1(wasm_valtype_new_i32());
+  own wasm_func_t* closure_func = wasm_func_new_with_env(store, closure_type, closure_callback, &i, NULL);
+
+  wasm_functype_delete(print_type);
+  wasm_functype_delete(closure_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = {
+    wasm_func_as_extern(print_func), wasm_func_as_extern(closure_func)
+  };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(print_func);
+  wasm_func_delete(closure_func);
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  const wasm_func_t* run_func = wasm_extern_as_func(exports.data[0]);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+
+  // Call.
+  printf("Calling export...\n");
+  wasm_val_t as[2] = { WASM_I32_VAL(3), WASM_I32_VAL(4) };
+  wasm_val_t rs[1] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(as);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(rs);
+  if (wasm_func_call(run_func, &args, &results)) {
+    printf("> Error calling function!\n");
+    return 1;
+  }
+
+  wasm_extern_vec_delete(&exports);
+
+  // Print result.
+  printf("Printing result...\n");
+  printf("> %u\n", rs[0].of.i32);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.cc
new file mode 100644
index 0000000..957629c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.cc
@@ -0,0 +1,146 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+// Print a Wasm value
+auto operator<<(std::ostream& out, const wasm::Val& val) -> std::ostream& {
+  switch (val.kind()) {
+    case wasm::ValKind::I32: {
+      out << val.i32();
+    } break;
+    case wasm::ValKind::I64: {
+      out << val.i64();
+    } break;
+    case wasm::ValKind::F32: {
+      out << val.f32();
+    } break;
+    case wasm::ValKind::F64: {
+      out << val.f64();
+    } break;
+    case wasm::ValKind::ANYREF:
+    case wasm::ValKind::FUNCREF: {
+      if (val.ref() == nullptr) {
+        out << "null";
+      } else {
+        out << "ref(" << val.ref() << ")";
+      }
+    } break;
+  }
+  return out;
+}
+
+// A function to be called from Wasm code.
+auto print_callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl << "> " << args[0] << std::endl;
+  results[0] = args[0].copy();
+  return nullptr;
+}
+
+
+// A function closure.
+auto closure_callback(
+  void* env, const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  auto i = *reinterpret_cast<int*>(env);
+  std::cout << "Calling back closure..." << std::endl;
+  std::cout << "> " << i << std::endl;
+  results[0] = wasm::Val::i32(static_cast<int32_t>(i));
+  return nullptr;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("callback.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external print functions.
+  std::cout << "Creating callback..." << std::endl;
+  auto print_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32)),
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32))
+  );
+  auto print_func = wasm::Func::make(store, print_type.get(), print_callback);
+
+  // Creating closure.
+  std::cout << "Creating closure..." << std::endl;
+  int i = 42;
+  auto closure_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(),
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32))
+  );
+  auto closure_func = wasm::Func::make(store, closure_type.get(), closure_callback, &i);
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(
+    print_func.get(), closure_func.get());
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting export..." << std::endl;
+  auto exports = instance->exports();
+  if (exports.size() == 0 || exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func()) {
+    std::cout << "> Error accessing export!" << std::endl;
+    exit(1);
+  }
+  auto run_func = exports[0]->func();
+
+  // Call.
+  std::cout << "Calling export..." << std::endl;
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::i32(3), wasm::Val::i32(4));
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (run_func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+
+  // Print result.
+  std::cout << "Printing result..." << std::endl;
+  std::cout << "> " << results[0].i32() << std::endl;
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wasm
new file mode 100644
index 0000000..7e00b58
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wat
new file mode 100644
index 0000000..d86195f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/callback.wat
@@ -0,0 +1,10 @@
+(module
+  (func $print (import "" "print") (param i32) (result i32))
+  (func $closure (import "" "closure") (result i32))
+  (func (export "run") (param $x i32) (param $y i32) (result i32)
+    (i32.add
+      (call $print (i32.add (local.get $x) (local.get $y)))
+      (call $closure)
+    )
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.c
new file mode 100644
index 0000000..4f2efc5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.c
@@ -0,0 +1,110 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+const int iterations = 100000;
+
+int live_count = 0;
+
+void finalize(void* data) {
+  intptr_t i = (intptr_t)data;
+  if (i % (iterations / 10) == 0) printf("Finalizing #%" PRIdPTR "...\n", i);
+  --live_count;
+}
+
+void run_in_store(wasm_store_t* store) {
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("finalize.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    exit(1);
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    exit(1);
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    exit(1);
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating modules...\n");
+  for (int i = 0; i <= iterations; ++i) {
+    if (i % (iterations / 10) == 0) printf("%d\n", i);
+    wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+    own wasm_instance_t* instance =
+      wasm_instance_new(store, module, &imports, NULL);
+    if (!instance) {
+      printf("> Error instantiating module %d!\n", i);
+      exit(1);
+    }
+    void* data = (void*)(intptr_t)i;
+    wasm_instance_set_host_info_with_finalizer(instance, data, &finalize);
+    wasm_instance_delete(instance);
+    ++live_count;
+  }
+
+  wasm_module_delete(module);
+}
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+
+  printf("Live count %d\n", live_count);
+  printf("Creating store 1...\n");
+  wasm_store_t* store1 = wasm_store_new(engine);
+
+  printf("Running in store 1...\n");
+  run_in_store(store1);
+  printf("Live count %d\n", live_count);
+
+  printf("Creating store 2...\n");
+  wasm_store_t* store2 = wasm_store_new(engine);
+
+  printf("Running in store 2...\n");
+  run_in_store(store2);
+  printf("Live count %d\n", live_count);
+
+  printf("Deleting store 2...\n");
+  wasm_store_delete(store2);
+  printf("Live count %d\n", live_count);
+
+  printf("Running in store 1...\n");
+  run_in_store(store1);
+  printf("Live count %d\n", live_count);
+
+  printf("Deleting store 1...\n");
+  wasm_store_delete(store1);
+  printf("Live count %d\n", live_count);
+
+  assert(live_count == 0);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.cc
new file mode 100644
index 0000000..ce7e972
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.cc
@@ -0,0 +1,104 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+const int iterations = 100000;
+
+int live_count = 0;
+
+void finalize(void* data) {
+  intptr_t i = reinterpret_cast<intptr_t>(data);
+  if (i % (iterations / 10) == 0) {
+    std::cout << "Finalizing #" << i << "..." << std::endl;
+  }
+  --live_count;
+}
+
+void run_in_store(wasm::Store* store) {
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("finalize.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Instantiate.
+  std::cout << "Instantiating modules..." << std::endl;
+  for (int i = 0; i <= iterations; ++i) {
+    if (i % (iterations / 10) == 0) std::cout << i << std::endl;
+    auto imports = wasm::vec<wasm::Extern*>::make();
+    auto instance = wasm::Instance::make(store, module.get(), imports);
+    if (!instance) {
+      std::cout << "> Error instantiating module " << i << "!" << std::endl;
+      exit(1);
+    }
+    instance->set_host_info(reinterpret_cast<void*>(i), &finalize);
+    ++live_count;
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+
+  std::cout << "Live count " << live_count << std::endl;
+  std::cout << "Creating store 1..." << std::endl;
+  auto store1 = wasm::Store::make(engine.get());
+
+  std::cout << "Running in store 1..." << std::endl;
+  run_in_store(store1.get());
+  std::cout << "Live count " << live_count << std::endl;
+
+  {
+    std::cout << "Creating store 2..." << std::endl;
+    auto store2 = wasm::Store::make(engine.get());
+
+    std::cout << "Running in store 2..." << std::endl;
+    run_in_store(store2.get());
+    std::cout << "Live count " << live_count << std::endl;
+
+    std::cout << "Deleting store 2..." << std::endl;
+    std::cout << "Live count " << live_count << std::endl;
+  }
+
+  std::cout << "Running in store 1..." << std::endl;
+  run_in_store(store1.get());
+  std::cout << "Live count " << live_count << std::endl;
+
+  std::cout << "Deleting store 1..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Live count " << live_count << std::endl;
+  assert(live_count == 0);
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wasm
new file mode 100644
index 0000000..74f9c56
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wat
new file mode 100644
index 0000000..6237e73
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/finalize.wat
@@ -0,0 +1,5 @@
+(module
+  (func (export "f"))
+  (func (export "g"))
+  (func (export "h"))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.c
new file mode 100644
index 0000000..5bd4033
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.c
@@ -0,0 +1,240 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+wasm_global_t* get_export_global(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_global(exports->data[i])) {
+    printf("> Error accessing global export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_global(exports->data[i]);
+}
+
+wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_func(exports->data[i])) {
+    printf("> Error accessing function export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_func(exports->data[i]);
+}
+
+
+#define check(val, type, expected) \
+  if (val.of.type != expected) { \
+    printf("> Error reading value\n"); \
+    exit(1); \
+  }
+
+#define check_global(global, type, expected) \
+  { \
+    wasm_val_t val; \
+    wasm_global_get(global, &val); \
+    check(val, type, expected); \
+  }
+
+#define check_call(func, type, expected) \
+  { \
+    wasm_val_t vs[1]; \
+    wasm_val_vec_t args = WASM_EMPTY_VEC; \
+    wasm_val_vec_t results = WASM_ARRAY_VEC(vs); \
+    wasm_func_call(func, &args, &results); \
+    check(vs[0], type, expected); \
+  }
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("global.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external globals.
+  printf("Creating globals...\n");
+  own wasm_globaltype_t* const_f32_type = wasm_globaltype_new(
+    wasm_valtype_new(WASM_F32), WASM_CONST);
+  own wasm_globaltype_t* const_i64_type = wasm_globaltype_new(
+    wasm_valtype_new(WASM_I64), WASM_CONST);
+  own wasm_globaltype_t* var_f32_type = wasm_globaltype_new(
+    wasm_valtype_new(WASM_F32), WASM_VAR);
+  own wasm_globaltype_t* var_i64_type = wasm_globaltype_new(
+    wasm_valtype_new(WASM_I64), WASM_VAR);
+
+  wasm_val_t val_f32_1 = WASM_F32_VAL(1);
+  own wasm_global_t* const_f32_import =
+    wasm_global_new(store, const_f32_type, &val_f32_1);
+  wasm_val_t val_i64_2 = WASM_I64_VAL(2);
+  own wasm_global_t* const_i64_import =
+    wasm_global_new(store, const_i64_type, &val_i64_2);
+  wasm_val_t val_f32_3 = WASM_F32_VAL(3);
+  own wasm_global_t* var_f32_import =
+    wasm_global_new(store, var_f32_type, &val_f32_3);
+  wasm_val_t val_i64_4 = WASM_I64_VAL(4);
+  own wasm_global_t* var_i64_import =
+    wasm_global_new(store, var_i64_type, &val_i64_4);
+
+  wasm_globaltype_delete(const_f32_type);
+  wasm_globaltype_delete(const_i64_type);
+  wasm_globaltype_delete(var_f32_type);
+  wasm_globaltype_delete(var_i64_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = {
+    wasm_global_as_extern(const_f32_import),
+    wasm_global_as_extern(const_i64_import),
+    wasm_global_as_extern(var_f32_import),
+    wasm_global_as_extern(var_i64_import)
+  };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+
+  // Extract export.
+  printf("Extracting exports...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  size_t i = 0;
+  wasm_global_t* const_f32_export = get_export_global(&exports, i++);
+  wasm_global_t* const_i64_export = get_export_global(&exports, i++);
+  wasm_global_t* var_f32_export = get_export_global(&exports, i++);
+  wasm_global_t* var_i64_export = get_export_global(&exports, i++);
+  wasm_func_t* get_const_f32_import = get_export_func(&exports, i++);
+  wasm_func_t* get_const_i64_import = get_export_func(&exports, i++);
+  wasm_func_t* get_var_f32_import = get_export_func(&exports, i++);
+  wasm_func_t* get_var_i64_import = get_export_func(&exports, i++);
+  wasm_func_t* get_const_f32_export = get_export_func(&exports, i++);
+  wasm_func_t* get_const_i64_export = get_export_func(&exports, i++);
+  wasm_func_t* get_var_f32_export = get_export_func(&exports, i++);
+  wasm_func_t* get_var_i64_export = get_export_func(&exports, i++);
+  wasm_func_t* set_var_f32_import = get_export_func(&exports, i++);
+  wasm_func_t* set_var_i64_import = get_export_func(&exports, i++);
+  wasm_func_t* set_var_f32_export = get_export_func(&exports, i++);
+  wasm_func_t* set_var_i64_export = get_export_func(&exports, i++);
+
+  // Try cloning.
+  own wasm_global_t* copy = wasm_global_copy(var_f32_import);
+  assert(wasm_global_same(var_f32_import, copy));
+  wasm_global_delete(copy);
+
+  // Interact.
+  printf("Accessing globals...\n");
+
+  // Check initial values.
+  check_global(const_f32_import, f32, 1);
+  check_global(const_i64_import, i64, 2);
+  check_global(var_f32_import, f32, 3);
+  check_global(var_i64_import, i64, 4);
+  check_global(const_f32_export, f32, 5);
+  check_global(const_i64_export, i64, 6);
+  check_global(var_f32_export, f32, 7);
+  check_global(var_i64_export, i64, 8);
+
+  check_call(get_const_f32_import, f32, 1);
+  check_call(get_const_i64_import, i64, 2);
+  check_call(get_var_f32_import, f32, 3);
+  check_call(get_var_i64_import, i64, 4);
+  check_call(get_const_f32_export, f32, 5);
+  check_call(get_const_i64_export, i64, 6);
+  check_call(get_var_f32_export, f32, 7);
+  check_call(get_var_i64_export, i64, 8);
+
+  // Modify variables through API and check again.
+  wasm_val_t val33 = WASM_F32_VAL(33);
+  wasm_global_set(var_f32_import, &val33);
+  wasm_val_t val34 = WASM_I64_VAL(34);
+  wasm_global_set(var_i64_import, &val34);
+  wasm_val_t val37 = WASM_F32_VAL(37);
+  wasm_global_set(var_f32_export, &val37);
+  wasm_val_t val38 = WASM_I64_VAL(38);
+  wasm_global_set(var_i64_export, &val38);
+
+  check_global(var_f32_import, f32, 33);
+  check_global(var_i64_import, i64, 34);
+  check_global(var_f32_export, f32, 37);
+  check_global(var_i64_export, i64, 38);
+
+  check_call(get_var_f32_import, f32, 33);
+  check_call(get_var_i64_import, i64, 34);
+  check_call(get_var_f32_export, f32, 37);
+  check_call(get_var_i64_export, i64, 38);
+
+  // Modify variables through calls and check again.
+  wasm_val_vec_t res = WASM_EMPTY_VEC;
+  wasm_val_t vs73[] = { WASM_F32_VAL(73) };
+  wasm_val_vec_t args73 = WASM_ARRAY_VEC(vs73);
+  wasm_func_call(set_var_f32_import, &args73, &res);
+  wasm_val_t vs74[] = { WASM_I64_VAL(74) };
+  wasm_val_vec_t args74 = WASM_ARRAY_VEC(vs74);
+  wasm_func_call(set_var_i64_import, &args74, &res);
+  wasm_val_t vs77[] = { WASM_F32_VAL(77) };
+  wasm_val_vec_t args77 = WASM_ARRAY_VEC(vs77);
+  wasm_func_call(set_var_f32_export, &args77, &res);
+  wasm_val_t vs78[] = { WASM_I64_VAL(78) };
+  wasm_val_vec_t args78 = WASM_ARRAY_VEC(vs78);
+  wasm_func_call(set_var_i64_export, &args78, &res);
+
+  check_global(var_f32_import, f32, 73);
+  check_global(var_i64_import, i64, 74);
+  check_global(var_f32_export, f32, 77);
+  check_global(var_i64_export, i64, 78);
+
+  check_call(get_var_f32_import, f32, 73);
+  check_call(get_var_i64_import, i64, 74);
+  check_call(get_var_f32_export, f32, 77);
+  check_call(get_var_i64_export, i64, 78);
+
+  wasm_global_delete(const_f32_import);
+  wasm_global_delete(const_i64_import);
+  wasm_global_delete(var_f32_import);
+  wasm_global_delete(var_i64_import);
+  wasm_extern_vec_delete(&exports);
+  wasm_instance_delete(instance);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.cc
new file mode 100644
index 0000000..178eb61
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.cc
@@ -0,0 +1,198 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+auto get_export_global(wasm::ownvec<wasm::Extern>& exports, size_t i) -> wasm::Global* {
+  if (exports.size() <= i || !exports[i]->global()) {
+    std::cout << "> Error accessing global export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->global();
+}
+
+auto get_export_func(const wasm::ownvec<wasm::Extern>& exports, size_t i) -> const wasm::Func* {
+  if (exports.size() <= i || !exports[i]->func()) {
+    std::cout << "> Error accessing function export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->func();
+}
+
+template<class T, class U>
+void check(T actual, U expected) {
+  if (actual != expected) {
+    std::cout << "> Error reading value, expected " << expected << ", got " << actual << std::endl;
+    exit(1);
+  }
+}
+
+auto call(const wasm::Func* func) -> wasm::Val {
+  auto args = wasm::vec<wasm::Val>::make();
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  return results[0].copy();
+}
+
+void call(const wasm::Func* func, wasm::Val&& arg) {
+  auto args = wasm::vec<wasm::Val>::make(std::move(arg));
+  auto results = wasm::vec<wasm::Val>::make();
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("global.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external globals.
+  std::cout << "Creating globals..." << std::endl;
+  auto const_f32_type = wasm::GlobalType::make(
+    wasm::ValType::make(wasm::ValKind::F32), wasm::Mutability::CONST);
+  auto const_i64_type = wasm::GlobalType::make(
+    wasm::ValType::make(wasm::ValKind::I64), wasm::Mutability::CONST);
+  auto var_f32_type = wasm::GlobalType::make(
+    wasm::ValType::make(wasm::ValKind::F32), wasm::Mutability::VAR);
+  auto var_i64_type = wasm::GlobalType::make(
+    wasm::ValType::make(wasm::ValKind::I64), wasm::Mutability::VAR);
+  auto const_f32_import = wasm::Global::make(store, const_f32_type.get(), wasm::Val::f32(1));
+  auto const_i64_import = wasm::Global::make(store, const_i64_type.get(), wasm::Val::i64(2));
+  auto var_f32_import = wasm::Global::make(store, var_f32_type.get(), wasm::Val::f32(3));
+  auto var_i64_import = wasm::Global::make(store, var_i64_type.get(), wasm::Val::i64(4));
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(
+    const_f32_import.get(), const_i64_import.get(),
+    var_f32_import.get(), var_i64_import.get()
+  );
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting exports..." << std::endl;
+  auto exports = instance->exports();
+  size_t i = 0;
+  auto const_f32_export = get_export_global(exports, i++);
+  auto const_i64_export = get_export_global(exports, i++);
+  auto var_f32_export = get_export_global(exports, i++);
+  auto var_i64_export = get_export_global(exports, i++);
+  auto get_const_f32_import = get_export_func(exports, i++);
+  auto get_const_i64_import = get_export_func(exports, i++);
+  auto get_var_f32_import = get_export_func(exports, i++);
+  auto get_var_i64_import = get_export_func(exports, i++);
+  auto get_const_f32_export = get_export_func(exports, i++);
+  auto get_const_i64_export = get_export_func(exports, i++);
+  auto get_var_f32_export = get_export_func(exports, i++);
+  auto get_var_i64_export = get_export_func(exports, i++);
+  auto set_var_f32_import = get_export_func(exports, i++);
+  auto set_var_i64_import = get_export_func(exports, i++);
+  auto set_var_f32_export = get_export_func(exports, i++);
+  auto set_var_i64_export = get_export_func(exports, i++);
+
+  // Try cloning.
+  assert(var_f32_import->copy()->same(var_f32_import.get()));
+
+  // Interact.
+  std::cout << "Accessing globals..." << std::endl;
+
+  // Check initial values.
+  check(const_f32_import->get().f32(), 1);
+  check(const_i64_import->get().i64(), 2);
+  check(var_f32_import->get().f32(), 3);
+  check(var_i64_import->get().i64(), 4);
+  check(const_f32_export->get().f32(), 5);
+  check(const_i64_export->get().i64(), 6);
+  check(var_f32_export->get().f32(), 7);
+  check(var_i64_export->get().i64(), 8);
+
+  check(call(get_const_f32_import).f32(), 1);
+  check(call(get_const_i64_import).i64(), 2);
+  check(call(get_var_f32_import).f32(), 3);
+  check(call(get_var_i64_import).i64(), 4);
+  check(call(get_const_f32_export).f32(), 5);
+  check(call(get_const_i64_export).i64(), 6);
+  check(call(get_var_f32_export).f32(), 7);
+  check(call(get_var_i64_export).i64(), 8);
+
+  // Modify variables through API and check again.
+  var_f32_import->set(wasm::Val::f32(33));
+  var_i64_import->set(wasm::Val::i64(34));
+  var_f32_export->set(wasm::Val::f32(37));
+  var_i64_export->set(wasm::Val::i64(38));
+
+  check(var_f32_import->get().f32(), 33);
+  check(var_i64_import->get().i64(), 34);
+  check(var_f32_export->get().f32(), 37);
+  check(var_i64_export->get().i64(), 38);
+
+  check(call(get_var_f32_import).f32(), 33);
+  check(call(get_var_i64_import).i64(), 34);
+  check(call(get_var_f32_export).f32(), 37);
+  check(call(get_var_i64_export).i64(), 38);
+
+  // Modify variables through calls and check again.
+  call(set_var_f32_import, wasm::Val::f32(73));
+  call(set_var_i64_import, wasm::Val::i64(74));
+  call(set_var_f32_export, wasm::Val::f32(77));
+  call(set_var_i64_export, wasm::Val::i64(78));
+
+  check(var_f32_import->get().f32(), 73);
+  check(var_i64_import->get().i64(), 74);
+  check(var_f32_export->get().f32(), 77);
+  check(var_i64_export->get().i64(), 78);
+
+  check(call(get_var_f32_import).f32(), 73);
+  check(call(get_var_i64_import).i64(), 74);
+  check(call(get_var_f32_export).f32(), 77);
+  check(call(get_var_i64_export).i64(), 78);
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wasm
new file mode 100644
index 0000000..0e76863
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wat
new file mode 100644
index 0000000..dea0857
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/global.wat
@@ -0,0 +1,27 @@
+(module
+  (global $f32_import (import "" "const f32") f32)
+  (global $i64_import (import "" "const i64") i64)
+  (global $mut_f32_import (import "" "var f32") (mut f32))
+  (global $mut_i64_import (import "" "var i64") (mut i64))
+
+  (global $f32_export (export "const f32") f32 (f32.const 5))
+  (global $i64_export (export "const i64") i64 (i64.const 6))
+  (global $mut_f32_export (export "var f32") (mut f32) (f32.const 7))
+  (global $mut_i64_export (export "var i64") (mut i64) (i64.const 8))
+
+  (func (export "get const f32 import") (result f32) (global.get $f32_import))
+  (func (export "get const i64 import") (result i64) (global.get $i64_import))
+  (func (export "get var f32 import") (result f32) (global.get $mut_f32_import))
+  (func (export "get var i64 import") (result i64) (global.get $mut_i64_import))
+
+  (func (export "get const f32 export") (result f32) (global.get $f32_export))
+  (func (export "get const i64 export") (result i64) (global.get $i64_export))
+  (func (export "get var f32 export") (result f32) (global.get $mut_f32_export))
+  (func (export "get var i64 export") (result i64) (global.get $mut_i64_export))
+
+  (func (export "set var f32 import") (param f32) (global.set $mut_f32_import (local.get 0)))
+  (func (export "set var i64 import") (param i64) (global.set $mut_i64_import (local.get 0)))
+
+  (func (export "set var f32 export") (param f32) (global.set $mut_f32_export (local.get 0)))
+  (func (export "set var f64 export") (param i64) (global.set $mut_i64_export (local.get 0)))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.c
new file mode 100644
index 0000000..712f459
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.c
@@ -0,0 +1,118 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// A function to be called from Wasm code.
+own wasm_trap_t* hello_callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n");
+  printf("> Hello World!\n");
+  return NULL;
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("hello.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Validate.
+  printf("Validating module...\n");
+  if (!wasm_module_validate(store, &binary)) {
+    printf("> Error validating module!\n");
+    return 1;
+  }
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external print functions.
+  printf("Creating callback...\n");
+  own wasm_functype_t* hello_type = wasm_functype_new_0_0();
+  own wasm_func_t* hello_func =
+    wasm_func_new(store, hello_type, hello_callback);
+
+  wasm_functype_delete(hello_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = { wasm_func_as_extern(hello_func) };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(hello_func);
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  const wasm_func_t* run_func = wasm_extern_as_func(exports.data[0]);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+
+  // Call.
+  printf("Calling export...\n");
+  wasm_val_vec_t args = WASM_EMPTY_VEC;
+  wasm_val_vec_t results = WASM_EMPTY_VEC;
+  if (wasm_func_call(run_func, &args, &results)) {
+    printf("> Error calling function!\n");
+    return 1;
+  }
+
+  wasm_extern_vec_delete(&exports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.cc
new file mode 100644
index 0000000..c2a73c8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.cc
@@ -0,0 +1,100 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+// A function to be called from Wasm code.
+auto hello_callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  std::cout << "> Hello world!" << std::endl;
+  return nullptr;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("hello.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Validate.
+  std::cout << "Validating module..." << std::endl;
+  if (!wasm::Module::validate(store, binary)) {
+    std::cout << "> Error validating module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external print functions.
+  std::cout << "Creating callback..." << std::endl;
+  auto hello_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(), wasm::ownvec<wasm::ValType>::make()
+  );
+  auto hello_func = wasm::Func::make(store, hello_type.get(), hello_callback);
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(hello_func.get());
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting export..." << std::endl;
+  auto exports = instance->exports();
+  if (exports.size() == 0 || exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func()) {
+    std::cout << "> Error accessing export!" << std::endl;
+    exit(1);
+  }
+  auto run_func = exports[0]->func();
+
+  // Call.
+  std::cout << "Calling export..." << std::endl;
+  auto args = wasm::vec<wasm::Val>::make();
+  auto results = wasm::vec<wasm::Val>::make();
+  if (run_func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wasm
new file mode 100644
index 0000000..2207c03
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wat
new file mode 100644
index 0000000..1c56c55
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hello.wat
@@ -0,0 +1,4 @@
+(module
+  (func $hello (import "" "hello"))
+  (func (export "run") (call $hello))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.c
new file mode 100644
index 0000000..1e787ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.c
@@ -0,0 +1,270 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+
+// A function to be called from Wasm code.
+own wasm_trap_t* callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n> ");
+  printf("> %p\n",
+    args->data[0].of.ref ? wasm_ref_get_host_info(args->data[0].of.ref) : NULL);
+  wasm_val_copy(&results->data[0], &args->data[0]);
+  return NULL;
+}
+
+
+wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_func(exports->data[i])) {
+    printf("> Error accessing function export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_func(exports->data[i]);
+}
+
+wasm_global_t* get_export_global(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_global(exports->data[i])) {
+    printf("> Error accessing global export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_global(exports->data[i]);
+}
+
+wasm_table_t* get_export_table(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_table(exports->data[i])) {
+    printf("> Error accessing table export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_table(exports->data[i]);
+}
+
+
+own wasm_ref_t* call_v_r(const wasm_func_t* func) {
+  printf("call_v_r... "); fflush(stdout);
+  wasm_val_t rs[] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_EMPTY_VEC;
+  wasm_val_vec_t results = WASM_ARRAY_VEC(rs);
+  if (wasm_func_call(func, &args, &results)) {
+    printf("> Error calling function!\n");
+    exit(1);
+  }
+  printf("okay\n");
+  return rs[0].of.ref;
+}
+
+void call_r_v(const wasm_func_t* func, wasm_ref_t* ref) {
+  printf("call_r_v... "); fflush(stdout);
+  wasm_val_t vs[1] = { WASM_REF_VAL(ref) };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_EMPTY_VEC;
+  if (wasm_func_call(func, &args, &results)) {
+    printf("> Error calling function!\n");
+    exit(1);
+  }
+  printf("okay\n");
+}
+
+own wasm_ref_t* call_r_r(const wasm_func_t* func, wasm_ref_t* ref) {
+  printf("call_r_r... "); fflush(stdout);
+  wasm_val_t vs[1] = { WASM_REF_VAL(ref) };
+  wasm_val_t rs[1] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(rs);
+  if (wasm_func_call(func, &args, &results)) {
+    printf("> Error calling function!\n");
+    exit(1);
+  }
+  printf("okay\n");
+  return rs[0].of.ref;
+}
+
+void call_ir_v(const wasm_func_t* func, int32_t i, wasm_ref_t* ref) {
+  printf("call_ir_v... "); fflush(stdout);
+  wasm_val_t vs[2] = { WASM_I32_VAL(i), WASM_REF_VAL(ref) };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_EMPTY_VEC;
+  if (wasm_func_call(func, &args, &results)) {
+    printf("> Error calling function!\n");
+    exit(1);
+  }
+  printf("okay\n");
+}
+
+own wasm_ref_t* call_i_r(const wasm_func_t* func, int32_t i) {
+  printf("call_i_r... "); fflush(stdout);
+  wasm_val_t vs[1] = { WASM_I32_VAL(i) };
+  wasm_val_t rs[1] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(rs);
+  if (wasm_func_call(func, &args, &results)) {
+    printf("> Error calling function!\n");
+    exit(1);
+  }
+  printf("okay\n");
+  return rs[0].of.ref;
+}
+
+void check(own wasm_ref_t* actual, const wasm_ref_t* expected) {
+  if (actual != expected &&
+      !(actual && expected && wasm_ref_same(actual, expected))) {
+    printf("> Error reading reference, expected %p, got %p\n",
+      expected ? wasm_ref_get_host_info(expected) : NULL,
+      actual ? wasm_ref_get_host_info(actual) : NULL);
+    exit(1);
+  }
+  if (actual) wasm_ref_delete(actual);
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("hostref.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external callback function.
+  printf("Creating callback...\n");
+  own wasm_functype_t* callback_type = wasm_functype_new_1_1(
+    wasm_valtype_new(WASM_ANYREF), wasm_valtype_new(WASM_ANYREF));
+  own wasm_func_t* callback_func =
+    wasm_func_new(store, callback_type, callback);
+
+  wasm_functype_delete(callback_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = { wasm_func_as_extern(callback_func) };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(callback_func);
+  wasm_module_delete(module);
+
+  // Extract export.
+  printf("Extracting exports...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  size_t i = 0;
+  wasm_global_t* global = get_export_global(&exports, i++);
+  wasm_table_t* table = get_export_table(&exports, i++);
+  wasm_func_t* global_set = get_export_func(&exports, i++);
+  wasm_func_t* global_get = get_export_func(&exports, i++);
+  wasm_func_t* table_set = get_export_func(&exports, i++);
+  wasm_func_t* table_get = get_export_func(&exports, i++);
+  wasm_func_t* func_call = get_export_func(&exports, i++);
+
+  wasm_instance_delete(instance);
+
+  // Create host references.
+  printf("Creating host references...\n");
+  own wasm_ref_t* host1 = wasm_foreign_as_ref(wasm_foreign_new(store));
+  own wasm_ref_t* host2 = wasm_foreign_as_ref(wasm_foreign_new(store));
+  wasm_ref_set_host_info(host1, (void*)1);
+  wasm_ref_set_host_info(host2, (void*)2);
+
+  // Some sanity checks.
+  check(NULL, NULL);
+  check(wasm_ref_copy(host1), host1);
+  check(wasm_ref_copy(host2), host2);
+
+  own wasm_val_t val;
+  val.kind = WASM_ANYREF;
+  val.of.ref = wasm_ref_copy(host1);
+  check(wasm_ref_copy(val.of.ref), host1);
+  own wasm_ref_t* ref = val.of.ref;
+  check(wasm_ref_copy(ref), host1);
+  wasm_val_delete(&val);
+
+  // Interact.
+  printf("Accessing global...\n");
+  check(call_v_r(global_get), NULL);
+  call_r_v(global_set, host1);
+  check(call_v_r(global_get), host1);
+  call_r_v(global_set, host2);
+  check(call_v_r(global_get), host2);
+  call_r_v(global_set, NULL);
+  check(call_v_r(global_get), NULL);
+
+  wasm_global_get(global, &val);
+  assert(val.kind == WASM_ANYREF);
+  check(val.of.ref, NULL);
+  val.of.ref = host2;
+  wasm_global_set(global, &val);
+  check(call_v_r(global_get), host2);
+  wasm_global_get(global, &val);
+  assert(val.kind == WASM_ANYREF);
+  check(val.of.ref, host2);
+
+  printf("Accessing table...\n");
+  check(call_i_r(table_get, 0), NULL);
+  check(call_i_r(table_get, 1), NULL);
+  call_ir_v(table_set, 0, host1);
+  call_ir_v(table_set, 1, host2);
+  check(call_i_r(table_get, 0), host1);
+  check(call_i_r(table_get, 1), host2);
+  call_ir_v(table_set, 0, NULL);
+  check(call_i_r(table_get, 0), NULL);
+
+  check(wasm_table_get(table, 2), NULL);
+  wasm_table_set(table, 2, host1);
+  check(call_i_r(table_get, 2), host1);
+  check(wasm_table_get(table, 2), host1);
+
+  printf("Accessing function...\n");
+  check(call_r_r(func_call, NULL), NULL);
+  check(call_r_r(func_call, host1), host1);
+  check(call_r_r(func_call, host2), host2);
+
+  wasm_ref_delete(host1);
+  wasm_ref_delete(host2);
+
+  wasm_extern_vec_delete(&exports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.cc
new file mode 100644
index 0000000..09c239e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.cc
@@ -0,0 +1,236 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+// A function to be called from Wasm code.
+auto callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  std::cout << "> " << (args[0].ref() ? args[0].ref()->get_host_info() : nullptr) << std::endl;
+  results[0] = args[0].copy();
+  return nullptr;
+}
+
+
+auto get_export_func(const wasm::ownvec<wasm::Extern>& exports, size_t i) -> const wasm::Func* {
+  if (exports.size() <= i || !exports[i]->func()) {
+    std::cout << "> Error accessing function export " << i << "/" << exports.size() << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->func();
+}
+
+auto get_export_global(wasm::ownvec<wasm::Extern>& exports, size_t i) -> wasm::Global* {
+  if (exports.size() <= i || !exports[i]->global()) {
+    std::cout << "> Error accessing global export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->global();
+}
+
+auto get_export_table(wasm::ownvec<wasm::Extern>& exports, size_t i) -> wasm::Table* {
+  if (exports.size() <= i || !exports[i]->table()) {
+    std::cout << "> Error accessing table export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->table();
+}
+
+
+void call_r_v(const wasm::Func* func, const wasm::Ref* ref) {
+  std::cout << "call_r_v... " << std::flush;
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::ref(ref ? ref->copy() : wasm::own<wasm::Ref>()));
+  auto results = wasm::vec<wasm::Val>::make();
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  std::cout << "okay" << std::endl;
+}
+
+auto call_v_r(const wasm::Func* func) -> wasm::own<wasm::Ref> {
+  std::cout << "call_v_r... " << std::flush;
+  auto args = wasm::vec<wasm::Val>::make();
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  std::cout << "okay" << std::endl;
+  return results[0].release_ref();
+}
+
+auto call_r_r(const wasm::Func* func, const wasm::Ref* ref) -> wasm::own<wasm::Ref> {
+  std::cout << "call_r_r... " << std::flush;
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::ref(ref ? ref->copy() : wasm::own<wasm::Ref>()));
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  std::cout << "okay" << std::endl;
+  return results[0].release_ref();
+}
+
+void call_ir_v(const wasm::Func* func, int32_t i, const wasm::Ref* ref) {
+  std::cout << "call_ir_v... " << std::flush;
+  auto args = wasm::vec<wasm::Val>::make(
+    wasm::Val::i32(i), wasm::Val::ref(ref ? ref->copy() : wasm::own<wasm::Ref>()));
+  auto results = wasm::vec<wasm::Val>::make();
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  std::cout << "okay" << std::endl;
+}
+
+auto call_i_r(const wasm::Func* func, int32_t i) -> wasm::own<wasm::Ref> {
+  std::cout << "call_i_r... " << std::flush;
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::i32(i));
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+  std::cout << "okay" << std::endl;
+  return results[0].release_ref();
+}
+
+void check(wasm::own<wasm::Ref> actual, const wasm::Ref* expected) {
+  if (actual.get() != expected &&
+      !(actual && expected && actual->same(expected))) {
+    std::cout << "> Error reading reference, expected "
+      << (expected ? expected->get_host_info() : nullptr) << ", got "
+      << (actual ? actual->get_host_info() : nullptr) << std::endl;
+    exit(1);
+  }
+}
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("hostref.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    return;
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    return;
+  }
+
+  // Create external callback function.
+  std::cout << "Creating callback..." << std::endl;
+  auto callback_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::ANYREF)),
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::ANYREF))
+  );
+  auto callback_func = wasm::Func::make(store, callback_type.get(), callback);
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(callback_func.get());
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    return;
+  }
+
+  // Extract export.
+  std::cout << "Extracting exports..." << std::endl;
+  auto exports = instance->exports();
+  size_t i = 0;
+  auto global = get_export_global(exports, i++);
+  auto table = get_export_table(exports, i++);
+  auto global_set = get_export_func(exports, i++);
+  auto global_get = get_export_func(exports, i++);
+  auto table_set = get_export_func(exports, i++);
+  auto table_get = get_export_func(exports, i++);
+  auto func_call = get_export_func(exports, i++);
+
+  // Create host references.
+  std::cout << "Creating host references..." << std::endl;
+  auto host1 = wasm::Foreign::make(store);
+  auto host2 = wasm::Foreign::make(store);
+  host1->set_host_info(reinterpret_cast<void*>(1));
+  host2->set_host_info(reinterpret_cast<void*>(2));
+
+  // Some sanity checks.
+  check(nullptr, nullptr);
+  check(host1->copy(), host1.get());
+  check(host2->copy(), host2.get());
+
+  wasm::Val val = wasm::Val::ref(host1->copy());
+  check(val.ref()->copy(), host1.get());
+  auto ref = val.release_ref();
+  assert(val.ref() == nullptr);
+  check(ref->copy(), host1.get());
+
+  // Interact.
+  std::cout << "Accessing global..." << std::endl;
+  check(call_v_r(global_get), nullptr);
+  call_r_v(global_set, host1.get());
+  check(call_v_r(global_get), host1.get());
+  call_r_v(global_set, host2.get());
+  check(call_v_r(global_get), host2.get());
+  call_r_v(global_set, nullptr);
+  check(call_v_r(global_get), nullptr);
+
+  check(global->get().release_ref(), nullptr);
+  global->set(wasm::Val(host2->copy()));
+  check(call_v_r(global_get), host2.get());
+  check(global->get().release_ref(), host2.get());
+
+  std::cout << "Accessing table..." << std::endl;
+  check(call_i_r(table_get, 0), nullptr);
+  check(call_i_r(table_get, 1), nullptr);
+  call_ir_v(table_set, 0, host1.get());
+  call_ir_v(table_set, 1, host2.get());
+  check(call_i_r(table_get, 0), host1.get());
+  check(call_i_r(table_get, 1), host2.get());
+  call_ir_v(table_set, 0, nullptr);
+  check(call_i_r(table_get, 0), nullptr);
+
+  check(table->get(2), nullptr);
+  table->set(2, host1.get());
+  check(call_i_r(table_get, 2), host1.get());
+  check(table->get(2), host1.get());
+
+  std::cout << "Accessing function..." << std::endl;
+  check(call_r_r(func_call, nullptr), nullptr);
+  check(call_r_r(func_call, host1.get()), host1.get());
+  check(call_r_r(func_call, host2.get()), host2.get());
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wasm
new file mode 100644
index 0000000..7bfc728
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wat
new file mode 100644
index 0000000..4d14ba6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/hostref.wat
@@ -0,0 +1,24 @@
+(module
+  (import "" "f" (func $fun (param anyref) (result anyref)))
+
+  (global $glob (export "global") (mut anyref) (ref.null))
+  (table $tab (export "table") 10 anyref)
+
+  (func (export "global.set") (param $r anyref)
+    (global.set $glob (local.get $r))
+  )
+  (func (export "global.get") (result anyref)
+    (global.get $glob)
+  )
+
+  (func (export "table.set") (param $i i32) (param $r anyref)
+    (table.set $tab (local.get $i) (local.get $r))
+  )
+  (func (export "table.get") (param $i i32) (result anyref)
+    (table.get $tab (local.get $i))
+  )
+
+  (func (export "func.call") (param $r anyref) (result anyref)
+    (call $fun (local.get $r))
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.c
new file mode 100644
index 0000000..edd4eba
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.c
@@ -0,0 +1,221 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+
+wasm_memory_t* get_export_memory(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_memory(exports->data[i])) {
+    printf("> Error accessing memory export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_memory(exports->data[i]);
+}
+
+wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_func(exports->data[i])) {
+    printf("> Error accessing function export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_func(exports->data[i]);
+}
+
+
+void check(bool success) {
+  if (!success) {
+    printf("> Error, expected success\n");
+    exit(1);
+  }
+}
+
+void check_call(wasm_func_t* func, int i, wasm_val_t args[], int32_t expected) {
+  wasm_val_t r = WASM_INIT_VAL;
+  wasm_val_vec_t args_ = {i, args};
+  wasm_val_vec_t results = {1, &r};
+  if (wasm_func_call(func, &args_, &results) || r.of.i32 != expected) {
+    printf("> Error on result\n");
+    exit(1);
+  }
+}
+
+void check_call0(wasm_func_t* func, int32_t expected) {
+  check_call(func, 0, NULL, expected);
+}
+
+void check_call1(wasm_func_t* func, int32_t arg, int32_t expected) {
+  wasm_val_t args[] = { WASM_I32_VAL(arg) };
+  check_call(func, 1, args, expected);
+}
+
+void check_call2(wasm_func_t* func, int32_t arg1, int32_t arg2, int32_t expected) {
+  wasm_val_t args[] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
+  check_call(func, 2, args, expected);
+}
+
+void check_ok(wasm_func_t* func, int i, wasm_val_t args[]) {
+  wasm_val_vec_t args_ = {i, args};
+  wasm_val_vec_t results = {0, NULL};
+  if (wasm_func_call(func, &args_, &results)) {
+    printf("> Error on result, expected empty\n");
+    exit(1);
+  }
+}
+
+void check_ok2(wasm_func_t* func, int32_t arg1, int32_t arg2) {
+  wasm_val_t args[] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
+  check_ok(func, 2, args);
+}
+
+void check_trap(wasm_func_t* func, int i, wasm_val_t args[]) {
+  wasm_val_t r = WASM_INIT_VAL;
+  wasm_val_vec_t args_ = {i, args};
+  wasm_val_vec_t results = {1, &r};
+  own wasm_trap_t* trap = wasm_func_call(func, &args_, &results);
+  if (! trap) {
+    printf("> Error on result, expected trap\n");
+    exit(1);
+  }
+  wasm_trap_delete(trap);
+}
+
+void check_trap1(wasm_func_t* func, int32_t arg) {
+  wasm_val_t args[] = { WASM_I32_VAL(arg) };
+  check_trap(func, 1, args);
+}
+
+void check_trap2(wasm_func_t* func, int32_t arg1, int32_t arg2) {
+  wasm_val_t args[] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
+  check_trap(func, 2, args);
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("memory.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  // Extract export.
+  printf("Extracting exports...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  size_t i = 0;
+  wasm_memory_t* memory = get_export_memory(&exports, i++);
+  wasm_func_t* size_func = get_export_func(&exports, i++);
+  wasm_func_t* load_func = get_export_func(&exports, i++);
+  wasm_func_t* store_func = get_export_func(&exports, i++);
+
+  wasm_module_delete(module);
+
+  // Try cloning.
+  own wasm_memory_t* copy = wasm_memory_copy(memory);
+  assert(wasm_memory_same(memory, copy));
+  wasm_memory_delete(copy);
+
+  // Check initial memory.
+  printf("Checking memory...\n");
+  check(wasm_memory_size(memory) == 2);
+  check(wasm_memory_data_size(memory) == 0x20000);
+  check(wasm_memory_data(memory)[0] == 0);
+  check(wasm_memory_data(memory)[0x1000] == 1);
+  check(wasm_memory_data(memory)[0x1003] == 4);
+
+  check_call0(size_func, 2);
+  check_call1(load_func, 0, 0);
+  check_call1(load_func, 0x1000, 1);
+  check_call1(load_func, 0x1003, 4);
+  check_call1(load_func, 0x1ffff, 0);
+  check_trap1(load_func, 0x20000);
+
+  // Mutate memory.
+  printf("Mutating memory...\n");
+  wasm_memory_data(memory)[0x1003] = 5;
+  check_ok2(store_func, 0x1002, 6);
+  check_trap2(store_func, 0x20000, 0);
+
+  check(wasm_memory_data(memory)[0x1002] == 6);
+  check(wasm_memory_data(memory)[0x1003] == 5);
+  check_call1(load_func, 0x1002, 6);
+  check_call1(load_func, 0x1003, 5);
+
+  // Grow memory.
+  printf("Growing memory...\n");
+  check(wasm_memory_grow(memory, 1));
+  check(wasm_memory_size(memory) == 3);
+  check(wasm_memory_data_size(memory) == 0x30000);
+
+  check_call1(load_func, 0x20000, 0);
+  check_ok2(store_func, 0x20000, 0);
+  check_trap1(load_func, 0x30000);
+  check_trap2(store_func, 0x30000, 0);
+
+  check(! wasm_memory_grow(memory, 1));
+  check(wasm_memory_grow(memory, 0));
+
+  wasm_extern_vec_delete(&exports);
+  wasm_instance_delete(instance);
+
+  // Create stand-alone memory.
+  // TODO(wasm+): Once Wasm allows multiple memories, turn this into import.
+  printf("Creating stand-alone memory...\n");
+  wasm_limits_t limits = {5, 5};
+  own wasm_memorytype_t* memorytype = wasm_memorytype_new(&limits);
+  own wasm_memory_t* memory2 = wasm_memory_new(store, memorytype);
+  check(wasm_memory_size(memory2) == 5);
+  check(! wasm_memory_grow(memory2, 1));
+  check(wasm_memory_grow(memory2, 0));
+
+  wasm_memorytype_delete(memorytype);
+  wasm_memory_delete(memory2);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.cc
new file mode 100644
index 0000000..6cc3619
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.cc
@@ -0,0 +1,175 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+auto get_export_memory(wasm::ownvec<wasm::Extern>& exports, size_t i) -> wasm::Memory* {
+  if (exports.size() <= i || !exports[i]->memory()) {
+    std::cout << "> Error accessing memory export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->memory();
+}
+
+auto get_export_func(const wasm::ownvec<wasm::Extern>& exports, size_t i) -> const wasm::Func* {
+  if (exports.size() <= i || !exports[i]->func()) {
+    std::cout << "> Error accessing function export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->func();
+}
+
+template<class T, class U>
+void check(T actual, U expected) {
+  if (actual != expected) {
+    std::cout << "> Error on result, expected " << expected << ", got " << actual << std::endl;
+    exit(1);
+  }
+}
+
+template<class... Args>
+void check_ok(const wasm::Func* func, Args... xs) {
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::i32(xs)...);
+  auto results = wasm::vec<wasm::Val>::make();
+  if (func->call(args, results)) {
+    std::cout << "> Error on result, expected return" << std::endl;
+    exit(1);
+  }
+}
+
+template<class... Args>
+void check_trap(const wasm::Func* func, Args... xs) {
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::i32(xs)...);
+  auto results = wasm::vec<wasm::Val>::make();
+  if (! func->call(args, results)) {
+    std::cout << "> Error on result, expected trap" << std::endl;
+    exit(1);
+  }
+}
+
+template<class... Args>
+auto call(const wasm::Func* func, Args... xs) -> int32_t {
+  auto args = wasm::vec<wasm::Val>::make(wasm::Val::i32(xs)...);
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error on result, expected return" << std::endl;
+    exit(1);
+  }
+  return results[0].i32();
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("memory.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make();
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting exports..." << std::endl;
+  auto exports = instance->exports();
+  size_t i = 0;
+  auto memory = get_export_memory(exports, i++);
+  auto size_func = get_export_func(exports, i++);
+  auto load_func = get_export_func(exports, i++);
+  auto store_func = get_export_func(exports, i++);
+
+  // Try cloning.
+  assert(memory->copy()->same(memory));
+
+  // Check initial memory.
+  std::cout << "Checking memory..." << std::endl;
+  check(memory->size(), 2u);
+  check(memory->data_size(), 0x20000u);
+  check(memory->data()[0], 0);
+  check(memory->data()[0x1000], 1);
+  check(memory->data()[0x1003], 4);
+
+  check(call(size_func), 2);
+  check(call(load_func, 0), 0);
+  check(call(load_func, 0x1000), 1);
+  check(call(load_func, 0x1003), 4);
+  check(call(load_func, 0x1ffff), 0);
+  check_trap(load_func, 0x20000);
+
+  // Mutate memory.
+  std::cout << "Mutating memory..." << std::endl;
+  memory->data()[0x1003] = 5;
+  check_ok(store_func, 0x1002, 6);
+  check_trap(store_func, 0x20000, 0);
+
+  check(memory->data()[0x1002], 6);
+  check(memory->data()[0x1003], 5);
+  check(call(load_func, 0x1002), 6);
+  check(call(load_func, 0x1003), 5);
+
+  // Grow memory.
+  std::cout << "Growing memory..." << std::endl;
+  check(memory->grow(1), true);
+  check(memory->size(), 3u);
+  check(memory->data_size(), 0x30000u);
+
+  check(call(load_func, 0x20000), 0);
+  check_ok(store_func, 0x20000, 0);
+  check_trap(load_func, 0x30000);
+  check_trap(store_func, 0x30000, 0);
+
+  check(memory->grow(1), false);
+  check(memory->grow(0), true);
+
+  // Create stand-alone memory.
+  // TODO(wasm+): Once Wasm allows multiple memories, turn this into import.
+  std::cout << "Creating stand-alone memory..." << std::endl;
+  auto memorytype = wasm::MemoryType::make(wasm::Limits(5, 5));
+  auto memory2 = wasm::Memory::make(store, memorytype.get());
+  check(memory2->size(), 5u);
+  check(memory2->grow(1), false);
+  check(memory2->grow(0), true);
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wasm
new file mode 100644
index 0000000..6f6518b
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wat
new file mode 100644
index 0000000..4cf43e2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/memory.wat
@@ -0,0 +1,11 @@
+(module
+  (memory (export "memory") 2 3)
+
+  (func (export "size") (result i32) (memory.size))
+  (func (export "load") (param i32) (result i32) (i32.load8_s (local.get 0)))
+  (func (export "store") (param i32 i32)
+    (i32.store8 (local.get 0) (local.get 1))
+  )
+
+  (data (i32.const 0x1000) "\01\02\03\04")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.c
new file mode 100644
index 0000000..4a31e7e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.c
@@ -0,0 +1,156 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// A function to be called from Wasm code.
+own wasm_trap_t* callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n> ");
+  printf("> %"PRIu32" %"PRIu64" %"PRIu64" %"PRIu32"\n",
+    args->data[0].of.i32, args->data[1].of.i64,
+    args->data[2].of.i64, args->data[3].of.i32);
+  printf("\n");
+
+  wasm_val_copy(&results->data[0], &args->data[3]);
+  wasm_val_copy(&results->data[1], &args->data[1]);
+  wasm_val_copy(&results->data[2], &args->data[2]);
+  wasm_val_copy(&results->data[3], &args->data[0]);
+  return NULL;
+}
+
+
+// A function closure.
+own wasm_trap_t* closure_callback(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  int i = *(int*)env;
+  printf("Calling back closure...\n");
+  printf("> %d\n", i);
+
+  results->data[0].kind = WASM_I32;
+  results->data[0].of.i32 = (int32_t)i;
+  return NULL;
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("multi.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external print functions.
+  printf("Creating callback...\n");
+  wasm_valtype_t* types[4] = {
+    wasm_valtype_new_i32(), wasm_valtype_new_i64(),
+    wasm_valtype_new_i64(), wasm_valtype_new_i32()
+  };
+  own wasm_valtype_vec_t tuple1, tuple2;
+  wasm_valtype_vec_new(&tuple1, 4, types);
+  wasm_valtype_vec_copy(&tuple2, &tuple1);
+  own wasm_functype_t* callback_type = wasm_functype_new(&tuple1, &tuple2);
+  own wasm_func_t* callback_func =
+    wasm_func_new(store, callback_type, callback);
+
+  wasm_functype_delete(callback_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = { wasm_func_as_extern(callback_func) };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(callback_func);
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  const wasm_func_t* run_func = wasm_extern_as_func(exports.data[0]);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+
+  // Call.
+  printf("Calling export...\n");
+  wasm_val_t vals[4] = {
+    WASM_I32_VAL(1), WASM_I64_VAL(2), WASM_I64_VAL(3), WASM_I32_VAL(4)
+  };
+  wasm_val_t res[4] = {
+    WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL, WASM_INIT_VAL
+  };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vals);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(res);
+  if (wasm_func_call(run_func, &args, &results)) {
+    printf("> Error calling function!\n");
+    return 1;
+  }
+
+  wasm_extern_vec_delete(&exports);
+
+  // Print result.
+  printf("Printing result...\n");
+  printf("> %"PRIu32" %"PRIu64" %"PRIu64" %"PRIu32"\n",
+    res[0].of.i32, res[1].of.i64, res[2].of.i64, res[3].of.i32);
+
+  assert(res[0].of.i32 == 4);
+  assert(res[1].of.i64 == 3);
+  assert(res[2].of.i64 == 2);
+  assert(res[3].of.i32 == 1);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.cc
new file mode 100644
index 0000000..6d08355
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.cc
@@ -0,0 +1,118 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+// A function to be called from Wasm code.
+auto callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  std::cout << "> " << args[0].i32();
+  std::cout << " " << args[1].i64();
+  std::cout << " " << args[2].i64();
+  std::cout << " " << args[3].i32() << std::endl;
+  results[0] = args[3].copy();
+  results[1] = args[1].copy();
+  results[2] = args[2].copy();
+  results[3] = args[0].copy();
+  return nullptr;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("multi.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external print functions.
+  std::cout << "Creating callback..." << std::endl;
+  auto tuple = wasm::ownvec<wasm::ValType>::make(
+    wasm::ValType::make(wasm::ValKind::I32),
+    wasm::ValType::make(wasm::ValKind::I64),
+    wasm::ValType::make(wasm::ValKind::I64),
+    wasm::ValType::make(wasm::ValKind::I32)
+  );
+  auto callback_type =
+    wasm::FuncType::make(tuple.deep_copy(), tuple.deep_copy());
+  auto callback_func = wasm::Func::make(store, callback_type.get(), callback);
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(callback_func.get());
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting export..." << std::endl;
+  auto exports = instance->exports();
+  if (exports.size() == 0 || exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func()) {
+    std::cout << "> Error accessing export!" << std::endl;
+    exit(1);
+  }
+  auto run_func = exports[0]->func();
+
+  // Call.
+  std::cout << "Calling export..." << std::endl;
+  auto args = wasm::vec<wasm::Val>::make(
+    wasm::Val::i32(1), wasm::Val::i64(2), wasm::Val::i64(3), wasm::Val::i32(4)
+  );
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(4);
+  if (wasm::own<wasm::Trap> trap = run_func->call(args, results)) {
+    std::cout << "> Error calling function! " << trap->message().get() << std::endl;
+    exit(1);
+  }
+
+  // Print result.
+  std::cout << "Printing result..." << std::endl;
+  std::cout << "> " << results[0].i32();
+  std::cout << " " << results[1].i64();
+  std::cout << " " << results[2].i64();
+  std::cout << " " << results[3].i32() << std::endl;
+
+  assert(results[0].i32() == 4);
+  assert(results[1].i64() == 3);
+  assert(results[2].i64() == 2);
+  assert(results[3].i32() == 1);
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wasm
new file mode 100644
index 0000000..bff0143
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wat
new file mode 100644
index 0000000..e7fb331
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/multi.wat
@@ -0,0 +1,7 @@
+(module
+  (func $f (import "" "f") (param i32 i64 i64 i32) (result i32 i64 i64 i32))
+
+  (func $g (export "g") (param i32 i64 i64 i32) (result i32 i64 i64 i32)
+    (call $f (local.get 0) (local.get 2) (local.get 1) (local.get 3))
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.c
new file mode 100644
index 0000000..d438318
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.c
@@ -0,0 +1,171 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+void print_mutability(wasm_mutability_t mut) {
+  switch (mut) {
+    case WASM_VAR: printf("var"); break;
+    case WASM_CONST: printf("const"); break;
+  }
+}
+
+void print_limits(const wasm_limits_t* limits) {
+  printf("%ud", limits->min);
+  if (limits->max < wasm_limits_max_default) printf(" %ud", limits->max);
+}
+
+void print_valtype(const wasm_valtype_t* type) {
+  switch (wasm_valtype_kind(type)) {
+    case WASM_I32: printf("i32"); break;
+    case WASM_I64: printf("i64"); break;
+    case WASM_F32: printf("f32"); break;
+    case WASM_F64: printf("f64"); break;
+    case WASM_ANYREF: printf("anyref"); break;
+    case WASM_FUNCREF: printf("funcref"); break;
+  }
+}
+
+void print_valtypes(const wasm_valtype_vec_t* types) {
+  bool first = true;
+  for (size_t i = 0; i < types->size; ++i) {
+    if (first) {
+      first = false;
+    } else {
+      printf(" ");
+    }
+    print_valtype(types->data[i]);
+  }
+}
+
+void print_externtype(const wasm_externtype_t* type) {
+  switch (wasm_externtype_kind(type)) {
+    case WASM_EXTERN_FUNC: {
+      const wasm_functype_t* functype =
+        wasm_externtype_as_functype_const(type);
+      printf("func ");
+      print_valtypes(wasm_functype_params(functype));
+      printf(" -> ");
+      print_valtypes(wasm_functype_results(functype));
+    } break;
+    case WASM_EXTERN_GLOBAL: {
+      const wasm_globaltype_t* globaltype =
+        wasm_externtype_as_globaltype_const(type);
+      printf("global ");
+      print_mutability(wasm_globaltype_mutability(globaltype));
+      printf(" ");
+      print_valtype(wasm_globaltype_content(globaltype));
+    } break;
+    case WASM_EXTERN_TABLE: {
+      const wasm_tabletype_t* tabletype =
+        wasm_externtype_as_tabletype_const(type);
+      printf("table ");
+      print_limits(wasm_tabletype_limits(tabletype));
+      printf(" ");
+      print_valtype(wasm_tabletype_element(tabletype));
+    } break;
+    case WASM_EXTERN_MEMORY: {
+      const wasm_memorytype_t* memorytype =
+        wasm_externtype_as_memorytype_const(type);
+      printf("memory ");
+      print_limits(wasm_memorytype_limits(memorytype));
+    } break;
+  }
+}
+
+void print_name(const wasm_name_t* name) {
+  printf("\"%.*s\"", (int)name->size, name->data);
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("reflect.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_exporttype_vec_t export_types;
+  own wasm_extern_vec_t exports;
+  wasm_module_exports(module, &export_types);
+  wasm_instance_exports(instance, &exports);
+  assert(exports.size == export_types.size);
+
+  for (size_t i = 0; i < exports.size; ++i) {
+    assert(wasm_extern_kind(exports.data[i]) ==
+      wasm_externtype_kind(wasm_exporttype_type(export_types.data[i])));
+    printf("> export %zu ", i);
+    print_name(wasm_exporttype_name(export_types.data[i]));
+    printf("\n");
+    printf(">> initial: ");
+    print_externtype(wasm_exporttype_type(export_types.data[i]));
+    printf("\n");
+    printf(">> current: ");
+    own wasm_externtype_t* current = wasm_extern_type(exports.data[i]);
+    print_externtype(current);
+    wasm_externtype_delete(current);
+    printf("\n");
+    if (wasm_extern_kind(exports.data[i]) == WASM_EXTERN_FUNC) {
+      wasm_func_t* func = wasm_extern_as_func(exports.data[i]);
+      printf(">> in-arity: %zu", wasm_func_param_arity(func));
+      printf(", out-arity: %zu\n", wasm_func_result_arity(func));
+    }
+  }
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+  wasm_extern_vec_delete(&exports);
+  wasm_exporttype_vec_delete(&export_types);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.cc
new file mode 100644
index 0000000..9820d81
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.cc
@@ -0,0 +1,139 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+auto operator<<(std::ostream& out, wasm::Mutability mut) -> std::ostream& {
+  switch (mut) {
+    case wasm::Mutability::VAR: return out << "var";
+    case wasm::Mutability::CONST: return out << "const";
+  }
+  return out;
+}
+
+auto operator<<(std::ostream& out, wasm::Limits limits) -> std::ostream& {
+  out << limits.min;
+  if (limits.max < wasm::Limits(0).max) out << " " << limits.max;
+  return out;
+}
+
+auto operator<<(std::ostream& out, const wasm::ValType& type) -> std::ostream& {
+  switch (type.kind()) {
+    case wasm::ValKind::I32: return out << "i32";
+    case wasm::ValKind::I64: return out << "i64";
+    case wasm::ValKind::F32: return out << "f32";
+    case wasm::ValKind::F64: return out << "f64";
+    case wasm::ValKind::ANYREF: return out << "anyref";
+    case wasm::ValKind::FUNCREF: return out << "funcref";
+  }
+  return out;
+}
+
+auto operator<<(std::ostream& out, const wasm::ownvec<wasm::ValType>& types) -> std::ostream& {
+  bool first = true;
+  for (size_t i = 0; i < types.size(); ++i) {
+    if (first) {
+      first = false;
+    } else {
+      out << " ";
+    }
+    out << *types[i].get();
+  }
+  return out;
+}
+
+auto operator<<(std::ostream& out, const wasm::ExternType& type) -> std::ostream& {
+  switch (type.kind()) {
+    case wasm::ExternKind::FUNC: {
+      out << "func " << type.func()->params() << " -> " << type.func()->results();
+    } break;
+    case wasm::ExternKind::GLOBAL: {
+      out << "global " << type.global()->mutability() << " " << *type.global()->content();
+    } break;
+    case wasm::ExternKind::TABLE: {
+      out << "table " << type.table()->limits() << " " << *type.table()->element();
+    } break;
+    case wasm::ExternKind::MEMORY: {
+      out << "memory " << type.memory()->limits();
+    } break;
+  }
+  return out;
+}
+
+auto operator<<(std::ostream& out, const wasm::Name& name) -> std::ostream& {
+  out << "\"" << std::string(name.get(), name.size()) << "\"";
+  return out;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("reflect.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make();
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract exports.
+  std::cout << "Extracting export..." << std::endl;
+  auto export_types = module->exports();
+  auto exports = instance->exports();
+  assert(exports.size() == export_types.size());
+
+  for (size_t i = 0; i < exports.size(); ++i) {
+    assert(exports[i]->kind() == export_types[i]->type()->kind());
+    std::cout << "> export " << i << " " << export_types[i]->name() << std::endl;
+    std::cout << ">> initial: " << *export_types[i]->type() << std::endl;
+    std::cout << ">> current: " << *exports[i]->type() << std::endl;
+    if (exports[i]->kind() == wasm::ExternKind::FUNC) {
+      auto func = exports[i]->func();
+      std::cout << ">> in-arity: " << func->param_arity();
+      std::cout << ", out-arity: " << func->result_arity() << std::endl;
+    }
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wasm
new file mode 100644
index 0000000..15a68fe
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wat
new file mode 100644
index 0000000..261dfd3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/reflect.wat
@@ -0,0 +1,6 @@
+(module
+  (func (export "func") (param i32 f64 f32) (result i32) (unreachable))
+  (global (export "global") f64 (f64.const 0))
+  (table (export "table") 0 50 anyfunc)
+  (memory (export "memory") 1)
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.c
new file mode 100644
index 0000000..8ea1a37
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.c
@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// A function to be called from Wasm code.
+own wasm_trap_t* hello_callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n");
+  printf("> Hello World!\n");
+  return NULL;
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("serialize.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Serialize module.
+  printf("Serializing module...\n");
+  own wasm_byte_vec_t serialized;
+  wasm_module_serialize(module, &serialized);
+
+  wasm_module_delete(module);
+
+  // Deserialize module.
+  printf("Deserializing module...\n");
+  own wasm_module_t* deserialized = wasm_module_deserialize(store, &serialized);
+  if (!deserialized) {
+    printf("> Error deserializing module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&serialized);
+
+  // Create external print functions.
+  printf("Creating callback...\n");
+  own wasm_functype_t* hello_type = wasm_functype_new_0_0();
+  own wasm_func_t* hello_func =
+    wasm_func_new(store, hello_type, hello_callback);
+
+  wasm_functype_delete(hello_type);
+
+  // Instantiate.
+  printf("Instantiating deserialized module...\n");
+  wasm_extern_t* externs[] = { wasm_func_as_extern(hello_func) };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, deserialized, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(hello_func);
+
+  // Extract export.
+  printf("Extracting export...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size == 0) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+  const wasm_func_t* run_func = wasm_extern_as_func(exports.data[0]);
+  if (run_func == NULL) {
+    printf("> Error accessing export!\n");
+    return 1;
+  }
+
+  wasm_module_delete(deserialized);
+  wasm_instance_delete(instance);
+
+  // Call.
+  printf("Calling export...\n");
+  wasm_val_vec_t empty = WASM_EMPTY_VEC;
+  if (wasm_func_call(run_func, &empty, &empty)) {
+    printf("> Error calling function!\n");
+    return 1;
+  }
+
+  wasm_extern_vec_delete(&exports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.cc
new file mode 100644
index 0000000..f63baeb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.cc
@@ -0,0 +1,105 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+// A function to be called from Wasm code.
+auto hello_callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  std::cout << "> Hello world!" << std::endl;
+  return nullptr;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("serialize.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Serialize module.
+  std::cout << "Serializing module..." << std::endl;
+  auto serialized = module->serialize();
+
+  // Deserialize module.
+  std::cout << "Deserializing module..." << std::endl;
+  auto deserialized = wasm::Module::deserialize(store, serialized);
+  if (!deserialized) {
+    std::cout << "> Error deserializing module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external print functions.
+  std::cout << "Creating callback..." << std::endl;
+  auto hello_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(), wasm::ownvec<wasm::ValType>::make()
+  );
+  auto hello_func = wasm::Func::make(store, hello_type.get(), hello_callback);
+
+  // Instantiate.
+  std::cout << "Instantiating deserialized module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(hello_func.get());
+  auto instance = wasm::Instance::make(store, deserialized.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting export..." << std::endl;
+  auto exports = instance->exports();
+  if (exports.size() == 0 || exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func()) {
+    std::cout << "> Error accessing export!" << std::endl;
+    exit(1);
+  }
+  auto run_func = exports[0]->func();
+
+  // Call.
+  std::cout << "Calling export..." << std::endl;
+  auto args = wasm::vec<wasm::Val>::make();
+  auto results = wasm::vec<wasm::Val>::make();
+  if (run_func->call(args, results)) {
+    std::cout << "> Error calling function!" << std::endl;
+    exit(1);
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wasm
new file mode 100644
index 0000000..2207c03
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wat
new file mode 100644
index 0000000..1c56c55
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/serialize.wat
@@ -0,0 +1,4 @@
+(module
+  (func $hello (import "" "hello"))
+  (func (export "run") (call $hello))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.c
new file mode 100644
index 0000000..f60c03c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.c
@@ -0,0 +1,106 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+
+void print_frame(wasm_frame_t* frame) {
+  printf("> %p @ 0x%zx = %"PRIu32".0x%zx\n",
+    wasm_frame_instance(frame),
+    wasm_frame_module_offset(frame),
+    wasm_frame_func_index(frame),
+    wasm_frame_func_offset(frame)
+  );
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("start.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+  own wasm_trap_t* trap = NULL;
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, &trap);
+  if (instance || !trap) {
+    printf("> Error instantiating module, expected trap!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+
+  // Print result.
+  printf("Printing message...\n");
+  own wasm_name_t message;
+  wasm_trap_message(trap, &message);
+  printf("> %s\n", message.data);
+
+  printf("Printing origin...\n");
+  own wasm_frame_t* frame = wasm_trap_origin(trap);
+  if (frame) {
+    print_frame(frame);
+    wasm_frame_delete(frame);
+  } else {
+    printf("> Empty origin.\n");
+  }
+
+  printf("Printing trace...\n");
+  own wasm_frame_vec_t trace;
+  wasm_trap_trace(trap, &trace);
+  if (trace.size > 0) {
+    for (size_t i = 0; i < trace.size; ++i) {
+      print_frame(trace.data[i]);
+    }
+  } else {
+    printf("> Empty trace.\n");
+  }
+
+  wasm_frame_vec_delete(&trace);
+  wasm_trap_delete(trap);
+  wasm_name_delete(&message);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.cc
new file mode 100644
index 0000000..1643b9f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.cc
@@ -0,0 +1,89 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+void print_frame(const wasm::Frame* frame) {
+  std::cout << "> " << frame->instance();
+  std::cout << " @ 0x" << std::hex << frame->module_offset();
+  std::cout << " = " << frame->func_index();
+  std::cout << ".0x" << std::hex << frame->func_offset() << std::endl;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("start.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  wasm::own<wasm::Trap> trap;
+  auto imports = wasm::vec<wasm::Extern*>::make();
+  auto instance = wasm::Instance::make(store, module.get(), imports, &trap);
+  if (instance || !trap) {
+    std::cout << "> Error instantiating module, expected trap!" << std::endl;
+    exit(1);
+  }
+
+  // Print result.
+  std::cout << "Printing message..." << std::endl;
+  std::cout << "> " << trap->message().get() << std::endl;
+
+  std::cout << "Printing origin..." << std::endl;
+  auto frame = trap->origin();
+  if (frame) {
+    print_frame(frame.get());
+  } else {
+    std::cout << "> Empty origin." << std::endl;
+  }
+
+  std::cout << "Printing trace..." << std::endl;
+  auto trace = trap->trace();
+  if (trace.size() > 0) {
+    for (size_t i = 0; i < trace.size(); ++i) {
+      print_frame(trace[i].get());
+    }
+  } else {
+    std::cout << "> Empty trace." << std::endl;
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wasm
new file mode 100644
index 0000000..90cba21
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wat
new file mode 100644
index 0000000..eb95116
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/start.wat
@@ -0,0 +1,4 @@
+(module
+  (func $start (unreachable))
+  (start $start)
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.c
new file mode 100644
index 0000000..5e91a34
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.c
@@ -0,0 +1,214 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// A function to be called from Wasm code.
+own wasm_trap_t* neg_callback(
+  const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n");
+  results->data[0].kind = WASM_I32;
+  results->data[0].of.i32 = -args->data[0].of.i32;
+  return NULL;
+}
+
+
+wasm_table_t* get_export_table(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_table(exports->data[i])) {
+    printf("> Error accessing table export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_table(exports->data[i]);
+}
+
+wasm_func_t* get_export_func(const wasm_extern_vec_t* exports, size_t i) {
+  if (exports->size <= i || !wasm_extern_as_func(exports->data[i])) {
+    printf("> Error accessing function export %zu!\n", i);
+    exit(1);
+  }
+  return wasm_extern_as_func(exports->data[i]);
+}
+
+
+void check(bool success) {
+  if (!success) {
+    printf("> Error, expected success\n");
+    exit(1);
+  }
+}
+
+void check_table(wasm_table_t* table, int32_t i, bool expect_set) {
+  own wasm_ref_t* ref = wasm_table_get(table, i);
+  check((ref != NULL) == expect_set);
+  if (ref) wasm_ref_delete(ref);
+}
+
+void check_call(wasm_func_t* func, int32_t arg1, int32_t arg2, int32_t expected) {
+  wasm_val_t vs[2] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
+  wasm_val_t r[1] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(r);
+  if (wasm_func_call(func, &args, &results) || r[0].of.i32 != expected) {
+    printf("> Error on result\n");
+    exit(1);
+  }
+}
+
+void check_trap(wasm_func_t* func, int32_t arg1, int32_t arg2) {
+  wasm_val_t vs[2] = { WASM_I32_VAL(arg1), WASM_I32_VAL(arg2) };
+  wasm_val_t r[1] = { WASM_INIT_VAL };
+  wasm_val_vec_t args = WASM_ARRAY_VEC(vs);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(r);
+  own wasm_trap_t* trap = wasm_func_call(func, &args, &results);
+  if (! trap) {
+    printf("> Error on result, expected trap\n");
+    exit(1);
+  }
+  wasm_trap_delete(trap);
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("table.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_vec_t imports = WASM_EMPTY_VEC;
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  // Extract export.
+  printf("Extracting exports...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  size_t i = 0;
+  wasm_table_t* table = get_export_table(&exports, i++);
+  wasm_func_t* call_indirect = get_export_func(&exports, i++);
+  wasm_func_t* f = get_export_func(&exports, i++);
+  wasm_func_t* g = get_export_func(&exports, i++);
+
+  wasm_module_delete(module);
+
+  // Create external function.
+  printf("Creating callback...\n");
+  own wasm_functype_t* neg_type = wasm_functype_new_1_1(wasm_valtype_new_i32(), wasm_valtype_new_i32());
+  own wasm_func_t* h = wasm_func_new(store, neg_type, neg_callback);
+
+  wasm_functype_delete(neg_type);
+
+  // Try cloning.
+  own wasm_table_t* copy = wasm_table_copy(table);
+  assert(wasm_table_same(table, copy));
+  wasm_table_delete(copy);
+
+  // Check initial table.
+  printf("Checking table...\n");
+  check(wasm_table_size(table) == 2);
+  check_table(table, 0, false);
+  check_table(table, 1, true);
+  check_trap(call_indirect, 0, 0);
+  check_call(call_indirect, 7, 1, 7);
+  check_trap(call_indirect, 0, 2);
+
+  // Mutate table.
+  printf("Mutating table...\n");
+  check(wasm_table_set(table, 0, wasm_func_as_ref(g)));
+  check(wasm_table_set(table, 1, NULL));
+  check(! wasm_table_set(table, 2, wasm_func_as_ref(f)));
+  check_table(table, 0, true);
+  check_table(table, 1, false);
+  check_call(call_indirect, 7, 0, 666);
+  check_trap(call_indirect, 0, 1);
+  check_trap(call_indirect, 0, 2);
+
+  // Grow table.
+  printf("Growing table...\n");
+  check(wasm_table_grow(table, 3, NULL));
+  check(wasm_table_size(table) == 5);
+  check(wasm_table_set(table, 2, wasm_func_as_ref(f)));
+  check(wasm_table_set(table, 3, wasm_func_as_ref(h)));
+  check(! wasm_table_set(table, 5, NULL));
+  check_table(table, 2, true);
+  check_table(table, 3, true);
+  check_table(table, 4, false);
+  check_call(call_indirect, 5, 2, 5);
+  check_call(call_indirect, 6, 3, -6);
+  check_trap(call_indirect, 0, 4);
+  check_trap(call_indirect, 0, 5);
+
+  check(wasm_table_grow(table, 2, wasm_func_as_ref(f)));
+  check(wasm_table_size(table) == 7);
+  check_table(table, 5, true);
+  check_table(table, 6, true);
+
+  check(! wasm_table_grow(table, 5, NULL));
+  check(wasm_table_grow(table, 3, NULL));
+  check(wasm_table_grow(table, 0, NULL));
+
+  wasm_func_delete(h);
+  wasm_extern_vec_delete(&exports);
+  wasm_instance_delete(instance);
+
+  // Create stand-alone table.
+  // TODO(wasm+): Once Wasm allows multiple tables, turn this into import.
+  printf("Creating stand-alone table...\n");
+  wasm_limits_t limits = {5, 5};
+  own wasm_tabletype_t* tabletype =
+    wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), &limits);
+  own wasm_table_t* table2 = wasm_table_new(store, tabletype, NULL);
+  check(wasm_table_size(table2) == 5);
+  check(! wasm_table_grow(table2, 1, NULL));
+  check(wasm_table_grow(table2, 0, NULL));
+
+  wasm_tabletype_delete(tabletype);
+  wasm_table_delete(table2);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.cc
new file mode 100644
index 0000000..9ddf1d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.cc
@@ -0,0 +1,193 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+
+// A function to be called from Wasm code.
+auto neg_callback(
+  const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  results[0] = wasm::Val(-args[0].i32());
+  return nullptr;
+}
+
+
+auto get_export_table(wasm::ownvec<wasm::Extern>& exports, size_t i) -> wasm::Table* {
+  if (exports.size() <= i || !exports[i]->table()) {
+    std::cout << "> Error accessing table export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->table();
+}
+
+auto get_export_func(const wasm::ownvec<wasm::Extern>& exports, size_t i) -> const wasm::Func* {
+  if (exports.size() <= i || !exports[i]->func()) {
+    std::cout << "> Error accessing function export " << i << "!" << std::endl;
+    exit(1);
+  }
+  return exports[i]->func();
+}
+
+template<class T, class U>
+void check(T actual, U expected) {
+  if (actual != expected) {
+    std::cout << "> Error on result, expected " << expected << ", got " << actual << std::endl;
+    exit(1);
+  }
+}
+
+void check(bool success) {
+  if (! success) {
+    std::cout << "> Error, expected success" << std::endl;
+    exit(1);
+  }
+}
+
+auto call(
+  const wasm::Func* func, wasm::Val&& arg1, wasm::Val&& arg2
+) -> wasm::Val {
+  auto args = wasm::vec<wasm::Val>::make(std::move(arg1), std::move(arg2));
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (func->call(args, results)) {
+    std::cout << "> Error on result, expected return" << std::endl;
+    exit(1);
+  }
+  return results[0].copy();
+}
+
+void check_trap(const wasm::Func* func, wasm::Val&& arg1, wasm::Val&& arg2) {
+  auto args = wasm::vec<wasm::Val>::make(std::move(arg1), std::move(arg2));
+  auto results = wasm::vec<wasm::Val>::make_uninitialized(1);
+  if (! func->call(args, results)) {
+    std::cout << "> Error on result, expected trap" << std::endl;
+    exit(1);
+  }
+}
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("table.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make();
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting exports..." << std::endl;
+  auto exports = instance->exports();
+  size_t i = 0;
+  auto table = get_export_table(exports, i++);
+  auto call_indirect = get_export_func(exports, i++);
+  auto f = get_export_func(exports, i++);
+  auto g = get_export_func(exports, i++);
+
+  // Create external function.
+  std::cout << "Creating callback..." << std::endl;
+  auto neg_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32)),
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32))
+  );
+  auto h = wasm::Func::make(store, neg_type.get(), neg_callback);
+
+  // Try cloning.
+  assert(table->copy()->same(table));
+
+  // Check initial table.
+  std::cout << "Checking table..." << std::endl;
+  check(table->size(), 2u);
+  check(table->get(0) == nullptr);
+  check(table->get(1) != nullptr);
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(0));
+  check(call(call_indirect, wasm::Val::i32(7), wasm::Val::i32(1)).i32(), 7);
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(2));
+
+  // Mutate table.
+  std::cout << "Mutating table..." << std::endl;
+  check(table->set(0, g));
+  check(table->set(1, nullptr));
+  check(! table->set(2, f));
+  check(table->get(0) != nullptr);
+  check(table->get(1) == nullptr);
+  check(call(call_indirect, wasm::Val::i32(7), wasm::Val::i32(0)).i32(), 666);
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(1));
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(2));
+
+  // Grow table.
+  std::cout << "Growing table..." << std::endl;
+  check(table->grow(3));
+  check(table->size(), 5u);
+  check(table->set(2, f));
+  check(table->set(3, h.get()));
+  check(! table->set(5, nullptr));
+  check(table->get(2) != nullptr);
+  check(table->get(3) != nullptr);
+  check(table->get(4) == nullptr);
+  check(call(call_indirect, wasm::Val::i32(5), wasm::Val::i32(2)).i32(), 5);
+  check(call(call_indirect, wasm::Val::i32(6), wasm::Val::i32(3)).i32(), -6);
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(4));
+  check_trap(call_indirect, wasm::Val::i32(0), wasm::Val::i32(5));
+
+  check(table->grow(2, f));
+  check(table->size(), 7u);
+  check(table->get(5) != nullptr);
+  check(table->get(6) != nullptr);
+
+  check(! table->grow(5));
+  check(table->grow(3));
+  check(table->grow(0));
+
+  // Create stand-alone table.
+  // TODO(wasm+): Once Wasm allows multiple tables, turn this into import.
+  std::cout << "Creating stand-alone table..." << std::endl;
+  auto tabletype = wasm::TableType::make(
+    wasm::ValType::make(wasm::ValKind::FUNCREF), wasm::Limits(5, 5));
+  auto table2 = wasm::Table::make(store, tabletype.get());
+  check(table2->size() == 5);
+  check(! table2->grow(1));
+  check(table2->grow(0));
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wasm
new file mode 100644
index 0000000..cdc0d8c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wat
new file mode 100644
index 0000000..d3e3a94
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/table.wat
@@ -0,0 +1,12 @@
+(module
+  (table (export "table") 2 10 funcref)
+
+  (func (export "call_indirect") (param i32 i32) (result i32)
+    (call_indirect (param i32) (result i32) (local.get 0) (local.get 1))
+  )
+
+  (func $f (export "f") (param i32) (result i32) (local.get 0))
+  (func (export "g") (param i32) (result i32) (i32.const 666))
+
+  (elem (i32.const 1) $f)
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.c
new file mode 100644
index 0000000..d70bd1a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.c
@@ -0,0 +1,155 @@
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <unistd.h>
+
+#include "wasm.h"
+
+#define own
+
+const int N_THREADS = 10;
+const int N_REPS = 3;
+
+// A function to be called from Wasm code.
+own wasm_trap_t* callback(const wasm_val_vec_t* args, wasm_val_vec_t* results) {
+  assert(args->data[0].kind == WASM_I32);
+  printf("> Thread %d running\n", args->data[0].of.i32);
+  return NULL;
+}
+
+
+typedef struct {
+  wasm_engine_t* engine;
+  wasm_shared_module_t* module;
+  int id;
+} thread_args;
+
+void* run(void* args_abs) {
+  thread_args* args = (thread_args*)args_abs;
+
+  // Rereate store and module.
+  own wasm_store_t* store = wasm_store_new(args->engine);
+  own wasm_module_t* module = wasm_module_obtain(store, args->module);
+
+  // Run the example N times.
+  for (int i = 0; i < N_REPS; ++i) {
+    usleep(100000);
+
+    // Create imports.
+    own wasm_functype_t* func_type = wasm_functype_new_1_0(wasm_valtype_new_i32());
+    own wasm_func_t* func = wasm_func_new(store, func_type, callback);
+    wasm_functype_delete(func_type);
+
+    wasm_val_t val = WASM_I32_VAL((int32_t)args->id);
+    own wasm_globaltype_t* global_type =
+      wasm_globaltype_new(wasm_valtype_new_i32(), WASM_CONST);
+    own wasm_global_t* global = wasm_global_new(store, global_type, &val);
+    wasm_globaltype_delete(global_type);
+
+    // Instantiate.
+    wasm_extern_t* externs[] = {
+      wasm_func_as_extern(func), wasm_global_as_extern(global),
+    };
+    wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+    own wasm_instance_t* instance =
+      wasm_instance_new(store, module, &imports, NULL);
+    if (!instance) {
+      printf("> Error instantiating module!\n");
+      return NULL;
+    }
+
+    wasm_func_delete(func);
+    wasm_global_delete(global);
+
+    // Extract export.
+    own wasm_extern_vec_t exports;
+    wasm_instance_exports(instance, &exports);
+    if (exports.size == 0) {
+      printf("> Error accessing exports!\n");
+      return NULL;
+    }
+    const wasm_func_t *run_func = wasm_extern_as_func(exports.data[0]);
+    if (run_func == NULL) {
+      printf("> Error accessing export!\n");
+      return NULL;
+    }
+
+    wasm_instance_delete(instance);
+
+    // Call.
+    wasm_val_vec_t empty = WASM_EMPTY_VEC;
+    if (wasm_func_call(run_func, &empty, &empty)) {
+      printf("> Error calling function!\n");
+      return NULL;
+    }
+
+    wasm_extern_vec_delete(&exports);
+  }
+
+  wasm_module_delete(module);
+  wasm_store_delete(store);
+
+  free(args_abs);
+
+  return NULL;
+}
+
+int main(int argc, const char *argv[]) {
+  // Initialize.
+  wasm_engine_t* engine = wasm_engine_new();
+
+  // Load binary.
+  FILE* file = fopen("threads.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile and share.
+  own wasm_store_t* store = wasm_store_new(engine);
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  own wasm_shared_module_t* shared = wasm_module_share(module);
+
+  wasm_module_delete(module);
+  wasm_store_delete(store);
+
+  // Spawn threads.
+  pthread_t threads[N_THREADS];
+  for (int i = 0; i < N_THREADS; i++) {
+    thread_args* args = malloc(sizeof(thread_args));
+    args->id = i;
+    args->engine = engine;
+    args->module = shared;
+    printf("Initializing thread %d...\n", i);
+    pthread_create(&threads[i], NULL, &run, args);
+  }
+
+  for (int i = 0; i < N_THREADS; i++) {
+    printf("Waiting for thread: %d\n", i);
+    pthread_join(threads[i], NULL);
+  }
+
+  wasm_shared_module_delete(shared);
+  wasm_engine_delete(engine);
+
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.cc
new file mode 100644
index 0000000..e130717
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.cc
@@ -0,0 +1,125 @@
+#include <iostream>
+#include <fstream>
+#include <thread>
+#include <mutex>
+
+#include "wasm.hh"
+
+const int N_THREADS = 10;
+const int N_REPS = 3;
+
+// A function to be called from Wasm code.
+auto callback(
+  void* env, const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  assert(args[0].kind() == wasm::ValKind::I32);
+  std::lock_guard<std::mutex> lock(*reinterpret_cast<std::mutex*>(env));
+  std::cout << "Thread " << args[0].i32() << " running..." << std::endl;
+  std::cout.flush();
+  return nullptr;
+}
+
+
+void run(
+  wasm::Engine* engine, const wasm::Shared<wasm::Module>* shared,
+  std::mutex* mutex, int id
+) {
+  // Create store.
+  auto store_ = wasm::Store::make(engine);
+  auto store = store_.get();
+
+  // Obtain.
+  auto module = wasm::Module::obtain(store, shared);
+  if (!module) {
+    std::lock_guard<std::mutex> lock(*mutex);
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Run the example N times.
+  for (int i = 0; i < N_REPS; ++i) {
+    std::this_thread::sleep_for(std::chrono::nanoseconds(100000));
+
+    // Create imports.
+    auto func_type = wasm::FuncType::make(
+      wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32)),
+      wasm::ownvec<wasm::ValType>::make()
+    );
+    auto func = wasm::Func::make(store, func_type.get(), callback, mutex);
+
+    auto global_type = wasm::GlobalType::make(
+      wasm::ValType::make(wasm::ValKind::I32), wasm::Mutability::CONST);
+    auto global = wasm::Global::make(
+      store, global_type.get(), wasm::Val::i32(i));
+
+    // Instantiate.
+    auto imports = wasm::vec<wasm::Extern*>::make(func.get(), global.get());
+    auto instance = wasm::Instance::make(store, module.get(), imports);
+    if (!instance) {
+      std::lock_guard<std::mutex> lock(*mutex);
+      std::cout << "> Error instantiating module!" << std::endl;
+      exit(1);
+    }
+
+    // Extract export.
+    auto exports = instance->exports();
+    if (exports.size() == 0 || exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func()) {
+      std::lock_guard<std::mutex> lock(*mutex);
+      std::cout << "> Error accessing export!" << std::endl;
+      exit(1);
+    }
+    auto run_func = exports[0]->func();
+
+    // Call.
+    auto empty = wasm::vec<wasm::Val>::make();
+    run_func->call(empty, empty);
+  }
+}
+
+int main(int argc, const char *argv[]) {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("threads.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    return 1;
+  }
+
+  // Compile and share.
+  std::cout << "Compiling and sharing module..." << std::endl;
+  auto store = wasm::Store::make(engine.get());
+  auto module = wasm::Module::make(store.get(), binary);
+  auto shared = module->share();
+
+  // Spawn threads.
+  std::cout << "Spawning threads..." << std::endl;
+  std::mutex mutex;
+  std::thread threads[N_THREADS];
+  for (int i = 0; i < N_THREADS; ++i) {
+    {
+      std::lock_guard<std::mutex> lock(mutex);
+      std::cout << "Initializing thread " << i << "..." << std::endl;
+    }
+    threads[i] = std::thread(run, engine.get(), shared.get(), &mutex, i);
+  }
+
+  for (int i = 0; i < N_THREADS; ++i) {
+    {
+      std::lock_guard<std::mutex> lock(mutex);
+      std::cout << "Waiting for thread " << i << "..." << std::endl;
+    }
+    threads[i].join();
+  }
+
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wasm
new file mode 100644
index 0000000..9a5c19d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wat
new file mode 100644
index 0000000..29a3bbc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/threads.wat
@@ -0,0 +1,5 @@
+(module
+  (func $message (import "" "hello") (param i32))
+  (global $id (import "" "id") i32)
+  (func (export "run") (call $message (global.get $id)))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.c b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.c
new file mode 100644
index 0000000..e53e29b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.c
@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "wasm.h"
+
+#define own
+
+// A function to be called from Wasm code.
+own wasm_trap_t* fail_callback(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  printf("Calling back...\n");
+  own wasm_name_t message;
+  wasm_name_new_from_string_nt(&message, "callback abort");
+  own wasm_trap_t* trap = wasm_trap_new((wasm_store_t*)env, &message);
+  wasm_name_delete(&message);
+  return trap;
+}
+
+
+void print_frame(wasm_frame_t* frame) {
+  printf("> %p @ 0x%zx = %"PRIu32".0x%zx\n",
+    wasm_frame_instance(frame),
+    wasm_frame_module_offset(frame),
+    wasm_frame_func_index(frame),
+    wasm_frame_func_offset(frame)
+  );
+}
+
+
+int main(int argc, const char* argv[]) {
+  // Initialize.
+  printf("Initializing...\n");
+  wasm_engine_t* engine = wasm_engine_new();
+  wasm_store_t* store = wasm_store_new(engine);
+
+  // Load binary.
+  printf("Loading binary...\n");
+  FILE* file = fopen("trap.wasm", "rb");
+  if (!file) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t binary;
+  wasm_byte_vec_new_uninitialized(&binary, file_size);
+  if (fread(binary.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Compile.
+  printf("Compiling module...\n");
+  own wasm_module_t* module = wasm_module_new(store, &binary);
+  if (!module) {
+    printf("> Error compiling module!\n");
+    return 1;
+  }
+
+  wasm_byte_vec_delete(&binary);
+
+  // Create external print functions.
+  printf("Creating callback...\n");
+  own wasm_functype_t* fail_type =
+    wasm_functype_new_0_1(wasm_valtype_new_i32());
+  own wasm_func_t* fail_func =
+    wasm_func_new_with_env(store, fail_type, fail_callback, store, NULL);
+
+  if (!fail_func) {
+    printf("> Error compiling fail_func!\n");
+    return 1;
+  }
+
+  wasm_functype_delete(fail_type);
+
+  // Instantiate.
+  printf("Instantiating module...\n");
+  wasm_extern_t* externs[] = { wasm_func_as_extern(fail_func) };
+  wasm_extern_vec_t imports = WASM_ARRAY_VEC(externs);
+  own wasm_instance_t* instance =
+    wasm_instance_new(store, module, &imports, NULL);
+  if (!instance) {
+    printf("> Error instantiating module!\n");
+    return 1;
+  }
+
+  wasm_func_delete(fail_func);
+
+  // Extract export.
+  printf("Extracting exports...\n");
+  own wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+  if (exports.size < 2) {
+    printf("> Error accessing exports!\n");
+    return 1;
+  }
+
+  wasm_module_delete(module);
+  wasm_instance_delete(instance);
+
+  // Call.
+  for (int i = 0; i < 2; ++i) {
+    const wasm_func_t* func = wasm_extern_as_func(exports.data[i]);
+    if (func == NULL) {
+      printf("> Error accessing export!\n");
+      return 1;
+    }
+
+    printf("Calling export %d...\n", i);
+    wasm_val_vec_t args = WASM_EMPTY_VEC;
+    wasm_val_vec_t results = WASM_EMPTY_VEC;
+    own wasm_trap_t* trap = wasm_func_call(func, &args, &results);
+    if (!trap) {
+      printf("> Error calling function, expected trap!\n");
+      return 1;
+    }
+
+    printf("Printing message...\n");
+    own wasm_name_t message;
+    wasm_trap_message(trap, &message);
+    printf("> %s\n", message.data);
+
+    printf("Printing origin...\n");
+    own wasm_frame_t* frame = wasm_trap_origin(trap);
+    if (frame) {
+      print_frame(frame);
+      wasm_frame_delete(frame);
+    } else {
+      printf("> Empty origin.\n");
+    }
+
+    printf("Printing trace...\n");
+    own wasm_frame_vec_t trace;
+    wasm_trap_trace(trap, &trace);
+    if (trace.size > 0) {
+      for (size_t i = 0; i < trace.size; ++i) {
+        print_frame(trace.data[i]);
+      }
+    } else {
+      printf("> Empty trace.\n");
+    }
+
+    wasm_frame_vec_delete(&trace);
+    wasm_trap_delete(trap);
+    wasm_name_delete(&message);
+  }
+
+  wasm_extern_vec_delete(&exports);
+
+  // Shut down.
+  printf("Shutting down...\n");
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+
+  // All done.
+  printf("Done.\n");
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.cc
new file mode 100644
index 0000000..2e70c76
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.cc
@@ -0,0 +1,128 @@
+#include <iostream>
+#include <fstream>
+#include <cstdlib>
+#include <string>
+#include <cinttypes>
+
+#include "wasm.hh"
+
+// A function to be called from Wasm code.
+auto fail_callback(
+  void* env, const wasm::vec<wasm::Val>& args, wasm::vec<wasm::Val>& results
+) -> wasm::own<wasm::Trap> {
+  std::cout << "Calling back..." << std::endl;
+  auto store = reinterpret_cast<wasm::Store*>(env);
+  auto message = wasm::Name::make_nt(std::string("callback abort"));
+  return wasm::Trap::make(store, message);
+}
+
+
+void print_frame(const wasm::Frame* frame) {
+  std::cout << "> " << frame->instance();
+  std::cout << " @ 0x" << std::hex << frame->module_offset();
+  std::cout << " = " << frame->func_index();
+  std::cout << ".0x" << std::hex << frame->func_offset() << std::endl;
+}
+
+
+void run() {
+  // Initialize.
+  std::cout << "Initializing..." << std::endl;
+  auto engine = wasm::Engine::make();
+  auto store_ = wasm::Store::make(engine.get());
+  auto store = store_.get();
+
+  // Load binary.
+  std::cout << "Loading binary..." << std::endl;
+  std::ifstream file("trap.wasm");
+  file.seekg(0, std::ios_base::end);
+  auto file_size = file.tellg();
+  file.seekg(0);
+  auto binary = wasm::vec<byte_t>::make_uninitialized(file_size);
+  file.read(binary.get(), file_size);
+  file.close();
+  if (file.fail()) {
+    std::cout << "> Error loading module!" << std::endl;
+    exit(1);
+  }
+
+  // Compile.
+  std::cout << "Compiling module..." << std::endl;
+  auto module = wasm::Module::make(store, binary);
+  if (!module) {
+    std::cout << "> Error compiling module!" << std::endl;
+    exit(1);
+  }
+
+  // Create external print functions.
+  std::cout << "Creating callback..." << std::endl;
+  auto fail_type = wasm::FuncType::make(
+    wasm::ownvec<wasm::ValType>::make(),
+    wasm::ownvec<wasm::ValType>::make(wasm::ValType::make(wasm::ValKind::I32))
+  );
+  auto fail_func =
+    wasm::Func::make(store, fail_type.get(), fail_callback, store);
+
+  // Instantiate.
+  std::cout << "Instantiating module..." << std::endl;
+  auto imports = wasm::vec<wasm::Extern*>::make(fail_func.get());
+  auto instance = wasm::Instance::make(store, module.get(), imports);
+  if (!instance) {
+    std::cout << "> Error instantiating module!" << std::endl;
+    exit(1);
+  }
+
+  // Extract export.
+  std::cout << "Extracting exports..." << std::endl;
+  auto exports = instance->exports();
+  if (exports.size() < 2 ||
+      exports[0]->kind() != wasm::ExternKind::FUNC || !exports[0]->func() ||
+      exports[1]->kind() != wasm::ExternKind::FUNC || !exports[1]->func()) {
+    std::cout << "> Error accessing exports!" << std::endl;
+    exit(1);
+  }
+
+  // Call.
+  for (size_t i = 0; i < 2; ++i) {
+    std::cout << "Calling export " << i << "..." << std::endl;
+    auto args = wasm::vec<wasm::Val>::make();
+    auto results = wasm::vec<wasm::Val>::make();
+    auto trap = exports[i]->func()->call(args, results);
+    if (!trap) {
+      std::cout << "> Error calling function, expected trap!" << std::endl;
+      exit(1);
+    }
+
+    std::cout << "Printing message..." << std::endl;
+    std::cout << "> " << trap->message().get() << std::endl;
+
+    std::cout << "Printing origin..." << std::endl;
+    auto frame = trap->origin();
+    if (frame) {
+      print_frame(frame.get());
+    } else {
+      std::cout << "> Empty origin." << std::endl;
+    }
+
+    std::cout << "Printing trace..." << std::endl;
+    auto trace = trap->trace();
+    if (trace.size() > 0) {
+      for (size_t i = 0; i < trace.size(); ++i) {
+        print_frame(trace[i].get());
+      }
+    } else {
+      std::cout << "> Empty trace." << std::endl;
+    }
+  }
+
+  // Shut down.
+  std::cout << "Shutting down..." << std::endl;
+}
+
+
+int main(int argc, const char* argv[]) {
+  run();
+  std::cout << "Done." << std::endl;
+  return 0;
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wasm b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wasm
new file mode 100644
index 0000000..eeed14c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wat b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wat
new file mode 100644
index 0000000..dfd20fb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/example/trap.wat
@@ -0,0 +1,5 @@
+(module
+  (func $callback (import "" "callback") (result i32))
+  (func (export "callback") (result i32) (call $callback))
+  (func (export "unreachable") (result i32) (unreachable) (i32.const 1))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.h b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.h
new file mode 100644
index 0000000..7b38fe3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.h
@@ -0,0 +1,727 @@
+// WebAssembly C API
+
+#ifndef WASM_H
+#define WASM_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#ifndef WASM_API_EXTERN
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#define WASM_API_EXTERN __declspec(dllimport)
+#else
+#define WASM_API_EXTERN
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Machine types
+
+inline void assertions() {
+  static_assert(sizeof(float) == sizeof(uint32_t), "incompatible float type");
+  static_assert(sizeof(double) == sizeof(uint64_t), "incompatible double type");
+  static_assert(sizeof(intptr_t) == sizeof(uint32_t) ||
+                sizeof(intptr_t) == sizeof(uint64_t),
+                "incompatible pointer type");
+}
+
+typedef char byte_t;
+typedef float float32_t;
+typedef double float64_t;
+
+
+// Ownership
+
+#define own
+
+// The qualifier `own` is used to indicate ownership of data in this API.
+// It is intended to be interpreted similar to a `const` qualifier:
+//
+// - `own wasm_xxx_t*` owns the pointed-to data
+// - `own wasm_xxx_t` distributes to all fields of a struct or union `xxx`
+// - `own wasm_xxx_vec_t` owns the vector as well as its elements(!)
+// - an `own` function parameter passes ownership from caller to callee
+// - an `own` function result passes ownership from callee to caller
+// - an exception are `own` pointer parameters named `out`, which are copy-back
+//   output parameters passing back ownership from callee to caller
+//
+// Own data is created by `wasm_xxx_new` functions and some others.
+// It must be released with the corresponding `wasm_xxx_delete` function.
+//
+// Deleting a reference does not necessarily delete the underlying object,
+// it merely indicates that this owner no longer uses it.
+//
+// For vectors, `const wasm_xxx_vec_t` is used informally to indicate that
+// neither the vector nor its elements should be modified.
+// TODO: introduce proper `wasm_xxx_const_vec_t`?
+
+
+#define WASM_DECLARE_OWN(name) \
+  typedef struct wasm_##name##_t wasm_##name##_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_delete(own wasm_##name##_t*);
+
+
+// Vectors
+
+#define WASM_DECLARE_VEC(name, ptr_or_none) \
+  typedef struct wasm_##name##_vec_t { \
+    size_t size; \
+    wasm_##name##_t ptr_or_none* data; \
+  } wasm_##name##_vec_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_vec_new_empty(own wasm_##name##_vec_t* out); \
+  WASM_API_EXTERN void wasm_##name##_vec_new_uninitialized( \
+    own wasm_##name##_vec_t* out, size_t); \
+  WASM_API_EXTERN void wasm_##name##_vec_new( \
+    own wasm_##name##_vec_t* out, \
+    size_t, own wasm_##name##_t ptr_or_none const[]); \
+  WASM_API_EXTERN void wasm_##name##_vec_copy( \
+    own wasm_##name##_vec_t* out, const wasm_##name##_vec_t*); \
+  WASM_API_EXTERN void wasm_##name##_vec_delete(own wasm_##name##_vec_t*);
+
+
+// Byte vectors
+
+typedef byte_t wasm_byte_t;
+WASM_DECLARE_VEC(byte, )
+
+typedef wasm_byte_vec_t wasm_name_t;
+
+#define wasm_name wasm_byte_vec
+#define wasm_name_new wasm_byte_vec_new
+#define wasm_name_new_empty wasm_byte_vec_new_empty
+#define wasm_name_new_new_uninitialized wasm_byte_vec_new_uninitialized
+#define wasm_name_copy wasm_byte_vec_copy
+#define wasm_name_delete wasm_byte_vec_delete
+
+static inline void wasm_name_new_from_string(
+  own wasm_name_t* out, own const char* s
+) {
+  wasm_name_new(out, strlen(s), s);
+}
+
+static inline void wasm_name_new_from_string_nt(
+  own wasm_name_t* out, own const char* s
+) {
+  wasm_name_new(out, strlen(s) + 1, s);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+WASM_DECLARE_OWN(config)
+
+WASM_API_EXTERN own wasm_config_t* wasm_config_new();
+
+// Embedders may provide custom functions for manipulating configs.
+
+
+// Engine
+
+WASM_DECLARE_OWN(engine)
+
+// During testing, we use a custom implementation of wasm_engine_new
+#if defined(TEST_WASM) || defined(TEST_WASMER)
+wasm_engine_t* wasm_engine_new();
+#else
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new();
+#endif
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new_with_config(own wasm_config_t*);
+
+
+// Store
+
+WASM_DECLARE_OWN(store)
+
+WASM_API_EXTERN own wasm_store_t* wasm_store_new(wasm_engine_t*);
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+typedef uint8_t wasm_mutability_t;
+enum wasm_mutability_enum {
+  WASM_CONST,
+  WASM_VAR,
+};
+
+typedef struct wasm_limits_t {
+  uint32_t min;
+  uint32_t max;
+} wasm_limits_t;
+
+static const uint32_t wasm_limits_max_default = 0xffffffff;
+
+
+// Generic
+
+#define WASM_DECLARE_TYPE(name) \
+  WASM_DECLARE_OWN(name) \
+  WASM_DECLARE_VEC(name, *) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(wasm_##name##_t*);
+
+
+// Value Types
+
+WASM_DECLARE_TYPE(valtype)
+
+typedef uint8_t wasm_valkind_t;
+enum wasm_valkind_enum {
+  WASM_I32,
+  WASM_I64,
+  WASM_F32,
+  WASM_F64,
+  WASM_ANYREF = 128,
+  WASM_FUNCREF,
+};
+
+WASM_API_EXTERN own wasm_valtype_t* wasm_valtype_new(wasm_valkind_t);
+
+WASM_API_EXTERN wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t*);
+
+static inline bool wasm_valkind_is_num(wasm_valkind_t k) {
+  return k < WASM_ANYREF;
+}
+static inline bool wasm_valkind_is_ref(wasm_valkind_t k) {
+  return k >= WASM_ANYREF;
+}
+
+static inline bool wasm_valtype_is_num(const wasm_valtype_t* t) {
+  return wasm_valkind_is_num(wasm_valtype_kind(t));
+}
+static inline bool wasm_valtype_is_ref(const wasm_valtype_t* t) {
+  return wasm_valkind_is_ref(wasm_valtype_kind(t));
+}
+
+
+// Function Types
+
+WASM_DECLARE_TYPE(functype)
+
+WASM_API_EXTERN own wasm_functype_t* wasm_functype_new(
+  own wasm_valtype_vec_t* params, own wasm_valtype_vec_t* results);
+
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t*);
+
+
+// Global Types
+
+WASM_DECLARE_TYPE(globaltype)
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_globaltype_new(
+  own wasm_valtype_t*, wasm_mutability_t);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t*);
+WASM_API_EXTERN wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t*);
+
+
+// Table Types
+
+WASM_DECLARE_TYPE(tabletype)
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_tabletype_new(
+  own wasm_valtype_t*, const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t*);
+
+
+// Memory Types
+
+WASM_DECLARE_TYPE(memorytype)
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t*);
+
+
+// Extern Types
+
+WASM_DECLARE_TYPE(externtype)
+
+typedef uint8_t wasm_externkind_t;
+enum wasm_externkind_enum {
+  WASM_EXTERN_FUNC,
+  WASM_EXTERN_GLOBAL,
+  WASM_EXTERN_TABLE,
+  WASM_EXTERN_MEMORY,
+};
+
+WASM_API_EXTERN wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t*);
+
+WASM_API_EXTERN wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t*);
+
+WASM_API_EXTERN wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_externtype_t* wasm_functype_as_externtype_const(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_globaltype_as_externtype_const(const wasm_globaltype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_tabletype_as_externtype_const(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_memorytype_as_externtype_const(const wasm_memorytype_t*);
+
+WASM_API_EXTERN const wasm_functype_t* wasm_externtype_as_functype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_globaltype_t* wasm_externtype_as_globaltype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_tabletype_t* wasm_externtype_as_tabletype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_memorytype_t* wasm_externtype_as_memorytype_const(const wasm_externtype_t*);
+
+
+// Import Types
+
+WASM_DECLARE_TYPE(importtype)
+
+WASM_API_EXTERN own wasm_importtype_t* wasm_importtype_new(
+  own wasm_name_t* module, own wasm_name_t* name, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_module(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_name(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_importtype_type(const wasm_importtype_t*);
+
+
+// Export Types
+
+WASM_DECLARE_TYPE(exporttype)
+
+WASM_API_EXTERN own wasm_exporttype_t* wasm_exporttype_new(
+  own wasm_name_t*, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t*);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// Values
+
+struct wasm_ref_t;
+
+typedef struct wasm_val_t {
+  wasm_valkind_t kind;
+  union {
+    int32_t i32;
+    int64_t i64;
+    float32_t f32;
+    float64_t f64;
+    struct wasm_ref_t* ref;
+  } of;
+} wasm_val_t;
+
+WASM_API_EXTERN void wasm_val_delete(own wasm_val_t* v);
+WASM_API_EXTERN void wasm_val_copy(own wasm_val_t* out, const wasm_val_t*);
+
+WASM_DECLARE_VEC(val, )
+
+
+// References
+
+#define WASM_DECLARE_REF_BASE(name) \
+  WASM_DECLARE_OWN(name) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t*); \
+  WASM_API_EXTERN bool wasm_##name##_same(const wasm_##name##_t*, const wasm_##name##_t*); \
+  \
+  WASM_API_EXTERN void* wasm_##name##_get_host_info(const wasm_##name##_t*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info(wasm_##name##_t*, void*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info_with_finalizer( \
+    wasm_##name##_t*, void*, void (*)(void*));
+
+#define WASM_DECLARE_REF(name) \
+  WASM_DECLARE_REF_BASE(name) \
+  \
+  WASM_API_EXTERN wasm_ref_t* wasm_##name##_as_ref(wasm_##name##_t*); \
+  WASM_API_EXTERN wasm_##name##_t* wasm_ref_as_##name(wasm_ref_t*); \
+  WASM_API_EXTERN const wasm_ref_t* wasm_##name##_as_ref_const(const wasm_##name##_t*); \
+  WASM_API_EXTERN const wasm_##name##_t* wasm_ref_as_##name##_const(const wasm_ref_t*);
+
+#define WASM_DECLARE_SHARABLE_REF(name) \
+  WASM_DECLARE_REF(name) \
+  WASM_DECLARE_OWN(shared_##name) \
+  \
+  WASM_API_EXTERN own wasm_shared_##name##_t* wasm_##name##_share(const wasm_##name##_t*); \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_obtain(wasm_store_t*, const wasm_shared_##name##_t*);
+
+
+WASM_DECLARE_REF_BASE(ref)
+
+
+// Frames
+
+WASM_DECLARE_OWN(frame)
+WASM_DECLARE_VEC(frame, *)
+WASM_API_EXTERN own wasm_frame_t* wasm_frame_copy(const wasm_frame_t*);
+
+WASM_API_EXTERN struct wasm_instance_t* wasm_frame_instance(const wasm_frame_t*);
+WASM_API_EXTERN uint32_t wasm_frame_func_index(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_func_offset(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_module_offset(const wasm_frame_t*);
+
+
+// Traps
+
+typedef wasm_name_t wasm_message_t;  // null terminated
+
+WASM_DECLARE_REF(trap)
+
+WASM_API_EXTERN own wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t*);
+
+WASM_API_EXTERN void wasm_trap_message(const wasm_trap_t*, own wasm_message_t* out);
+WASM_API_EXTERN own wasm_frame_t* wasm_trap_origin(const wasm_trap_t*);
+WASM_API_EXTERN void wasm_trap_trace(const wasm_trap_t*, own wasm_frame_vec_t* out);
+
+
+// Foreign Objects
+
+WASM_DECLARE_REF(foreign)
+
+WASM_API_EXTERN own wasm_foreign_t* wasm_foreign_new(wasm_store_t*);
+
+
+// Modules
+
+WASM_DECLARE_SHARABLE_REF(module)
+
+WASM_API_EXTERN own wasm_module_t* wasm_module_new(
+  wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN bool wasm_module_validate(wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN void wasm_module_imports(const wasm_module_t*, own wasm_importtype_vec_t* out);
+WASM_API_EXTERN void wasm_module_exports(const wasm_module_t*, own wasm_exporttype_vec_t* out);
+
+WASM_API_EXTERN void wasm_module_serialize(const wasm_module_t*, own wasm_byte_vec_t* out);
+WASM_API_EXTERN own wasm_module_t* wasm_module_deserialize(wasm_store_t*, const wasm_byte_vec_t*);
+
+
+// Function Instances
+
+WASM_DECLARE_REF(func)
+
+typedef own wasm_trap_t* (*wasm_func_callback_t)(
+  const wasm_val_vec_t* args, own wasm_val_vec_t* results);
+typedef own wasm_trap_t* (*wasm_func_callback_with_env_t)(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+WASM_API_EXTERN own wasm_func_t* wasm_func_new(
+  wasm_store_t*, const wasm_functype_t*, wasm_func_callback_t);
+WASM_API_EXTERN own wasm_func_t* wasm_func_new_with_env(
+  wasm_store_t*, const wasm_functype_t* type, wasm_func_callback_with_env_t,
+  void* env, void (*finalizer)(void*));
+
+WASM_API_EXTERN own wasm_functype_t* wasm_func_type(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_param_arity(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_result_arity(const wasm_func_t*);
+
+WASM_API_EXTERN own wasm_trap_t* wasm_func_call(
+  const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+
+// Global Instances
+
+WASM_DECLARE_REF(global)
+
+WASM_API_EXTERN own wasm_global_t* wasm_global_new(
+  wasm_store_t*, const wasm_globaltype_t*, const wasm_val_t*);
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_global_type(const wasm_global_t*);
+
+WASM_API_EXTERN void wasm_global_get(const wasm_global_t*, own wasm_val_t* out);
+WASM_API_EXTERN void wasm_global_set(wasm_global_t*, const wasm_val_t*);
+
+
+// Table Instances
+
+WASM_DECLARE_REF(table)
+
+typedef uint32_t wasm_table_size_t;
+
+WASM_API_EXTERN own wasm_table_t* wasm_table_new(
+  wasm_store_t*, const wasm_tabletype_t*, wasm_ref_t* init);
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_table_type(const wasm_table_t*);
+
+WASM_API_EXTERN own wasm_ref_t* wasm_table_get(const wasm_table_t*, wasm_table_size_t index);
+WASM_API_EXTERN bool wasm_table_set(wasm_table_t*, wasm_table_size_t index, wasm_ref_t*);
+
+WASM_API_EXTERN wasm_table_size_t wasm_table_size(const wasm_table_t*);
+WASM_API_EXTERN bool wasm_table_grow(wasm_table_t*, wasm_table_size_t delta, wasm_ref_t* init);
+
+
+// Memory Instances
+
+WASM_DECLARE_REF(memory)
+
+typedef uint32_t wasm_memory_pages_t;
+
+static const size_t MEMORY_PAGE_SIZE = 0x10000;
+
+WASM_API_EXTERN own wasm_memory_t* wasm_memory_new(wasm_store_t*, const wasm_memorytype_t*);
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memory_type(const wasm_memory_t*);
+
+WASM_API_EXTERN byte_t* wasm_memory_data(wasm_memory_t*);
+WASM_API_EXTERN size_t wasm_memory_data_size(const wasm_memory_t*);
+
+WASM_API_EXTERN wasm_memory_pages_t wasm_memory_size(const wasm_memory_t*);
+WASM_API_EXTERN bool wasm_memory_grow(wasm_memory_t*, wasm_memory_pages_t delta);
+
+
+// Externals
+
+WASM_DECLARE_REF(extern)
+WASM_DECLARE_VEC(extern, *)
+
+WASM_API_EXTERN wasm_externkind_t wasm_extern_kind(const wasm_extern_t*);
+WASM_API_EXTERN own wasm_externtype_t* wasm_extern_type(const wasm_extern_t*);
+
+WASM_API_EXTERN wasm_extern_t* wasm_func_as_extern(wasm_func_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_global_as_extern(wasm_global_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_table_as_extern(wasm_table_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_memory_as_extern(wasm_memory_t*);
+
+WASM_API_EXTERN wasm_func_t* wasm_extern_as_func(wasm_extern_t*);
+WASM_API_EXTERN wasm_global_t* wasm_extern_as_global(wasm_extern_t*);
+WASM_API_EXTERN wasm_table_t* wasm_extern_as_table(wasm_extern_t*);
+WASM_API_EXTERN wasm_memory_t* wasm_extern_as_memory(wasm_extern_t*);
+
+WASM_API_EXTERN const wasm_extern_t* wasm_func_as_extern_const(const wasm_func_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_global_as_extern_const(const wasm_global_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_table_as_extern_const(const wasm_table_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_memory_as_extern_const(const wasm_memory_t*);
+
+WASM_API_EXTERN const wasm_func_t* wasm_extern_as_func_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_global_t* wasm_extern_as_global_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_table_t* wasm_extern_as_table_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_memory_t* wasm_extern_as_memory_const(const wasm_extern_t*);
+
+
+// Module Instances
+
+WASM_DECLARE_REF(instance)
+
+WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(
+  wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t* imports,
+  own wasm_trap_t**
+);
+
+WASM_API_EXTERN void wasm_instance_exports(const wasm_instance_t*, own wasm_extern_vec_t* out);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Convenience
+
+// Vectors
+
+#define WASM_EMPTY_VEC {0, NULL}
+#define WASM_ARRAY_VEC(array) {sizeof(array)/sizeof(*(array)), array}
+
+
+// Value Type construction short-hands
+
+static inline own wasm_valtype_t* wasm_valtype_new_i32() {
+  return wasm_valtype_new(WASM_I32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_i64() {
+  return wasm_valtype_new(WASM_I64);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f32() {
+  return wasm_valtype_new(WASM_F32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f64() {
+  return wasm_valtype_new(WASM_F64);
+}
+
+static inline own wasm_valtype_t* wasm_valtype_new_anyref() {
+  return wasm_valtype_new(WASM_ANYREF);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_funcref() {
+  return wasm_valtype_new(WASM_FUNCREF);
+}
+
+
+// Function Types construction short-hands
+
+static inline own wasm_functype_t* wasm_functype_new_0_0() {
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_0(
+  own wasm_valtype_t* p
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_1(
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_1(
+  own wasm_valtype_t* p, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_2(
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_2(
+  own wasm_valtype_t* p, own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+
+// Value construction short-hands
+
+static inline void wasm_val_init_ptr(own wasm_val_t* out, void* p) {
+#if UINTPTR_MAX == UINT32_MAX
+  out->kind = WASM_I32;
+  out->of.i32 = (intptr_t)p;
+#elif UINTPTR_MAX == UINT64_MAX
+  out->kind = WASM_I64;
+  out->of.i64 = (intptr_t)p;
+#endif
+}
+
+static inline void* wasm_val_ptr(const wasm_val_t* val) {
+#if UINTPTR_MAX == UINT32_MAX
+  return (void*)(intptr_t)val->of.i32;
+#elif UINTPTR_MAX == UINT64_MAX
+  return (void*)(intptr_t)val->of.i64;
+#endif
+}
+
+#define WASM_I32_VAL(i) {.kind = WASM_I32, .of = {.i32 = i}}
+#define WASM_I64_VAL(i) {.kind = WASM_I64, .of = {.i64 = i}}
+#define WASM_F32_VAL(z) {.kind = WASM_F32, .of = {.f32 = z}}
+#define WASM_F64_VAL(z) {.kind = WASM_F64, .of = {.f64 = z}}
+#define WASM_REF_VAL(r) {.kind = WASM_ANYREF, .of = {.ref = r}}
+#define WASM_INIT_VAL {.kind = WASM_ANYREF, .of = {.ref = NULL}}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+#undef own
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // #ifdef WASM_H
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.hh b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.hh
new file mode 100644
index 0000000..8a45099
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/include/wasm.hh
@@ -0,0 +1,752 @@
+// WebAssembly C++ API
+
+#ifndef WASM_HH
+#define WASM_HH
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <limits>
+#include <string>
+
+#ifndef WASM_API_EXTERN
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#define WASM_API_EXTERN __declspec(dllimport)
+#else
+#define WASM_API_EXTERN
+#endif
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Machine types
+
+static_assert(sizeof(float) == sizeof(int32_t), "incompatible float type");
+static_assert(sizeof(double) == sizeof(int64_t), "incompatible double type");
+static_assert(sizeof(intptr_t) == sizeof(int32_t) ||
+              sizeof(intptr_t) == sizeof(int64_t), "incompatible pointer type");
+
+using byte_t = char;
+using float32_t = float;
+using float64_t = double;
+
+
+namespace wasm {
+
+// Vectors
+
+template<class T>
+class vec {
+  static const size_t invalid_size = SIZE_MAX;
+
+  size_t size_;
+  std::unique_ptr<T[]> data_;
+
+#ifdef WASM_API_DEBUG
+  WASM_API_EXTERN void make_data();
+  WASM_API_EXTERN void free_data();
+#else
+  void make_data() {}
+  void free_data() {}
+#endif
+
+  vec(size_t size) : vec(size, size ? new(std::nothrow) T[size] : nullptr) {
+    make_data();
+  }
+
+  vec(size_t size, T* data) : size_(size), data_(data) {
+    assert(!!size_ == !!data_ || size_ == invalid_size);
+  }
+
+public:
+  using elem_type = T;
+
+  vec(vec<T>&& that) : vec(that.size_, that.data_.release()) {
+    that.size_ = invalid_size;
+  }
+
+  ~vec() {
+    free_data();
+  }
+
+  operator bool() const {
+    return bool(size_ != invalid_size);
+  }
+
+  auto size() const -> size_t {
+    return size_;
+  }
+
+  auto get() const -> const T* {
+    return data_.get();
+  }
+
+  auto get() -> T* {
+    return data_.get();
+  }
+
+  auto release() -> T* {
+    size_ = invalid_size;
+    return data_.release();
+  }
+
+  void reset() {
+    free_data();
+    size_ = invalid_size;
+    data_.reset();
+  }
+
+  void reset(vec& that) {
+    free_data();
+    size_ = that.size_;
+    data_.reset(that.data_.release());
+    that.size_ = invalid_size;
+  }
+
+  auto operator=(vec&& that) -> vec& {
+    reset(that);
+    return *this;
+  }
+
+  auto operator[](size_t i) -> T& {
+    assert(i < size_);
+    return data_[i];
+  }
+
+  auto operator[](size_t i) const -> const T& {
+    assert(i < size_);
+    return data_[i];
+  }
+
+  auto copy() const -> vec {
+    auto v = vec(size_);
+    if (v) for (size_t i = 0; i < size_; ++i) v.data_[i] = data_[i];
+    return v;
+  }
+
+  // TODO: This can't be used for e.g. vec<Value>
+  auto deep_copy() const -> vec {
+    auto v = vec(size_);
+    if (v) for (size_t i = 0; i < size_; ++i) v.data_[i] = data_[i]->copy();
+    return v;
+  }
+
+  static auto make_uninitialized(size_t size = 0) -> vec {
+    return vec(size);
+  }
+
+  static auto make(size_t size, T init[]) -> vec {
+    auto v = vec(size);
+    if (v) for (size_t i = 0; i < size; ++i) v.data_[i] = std::move(init[i]);
+    return v;
+  }
+
+  static auto make(std::string s) -> vec<char> {
+    auto v = vec(s.length());
+    if (v) std::strncpy(v.get(), s.data(), s.length());
+    return v;
+  }
+
+  static auto make_nt(std::string s) -> vec<char> {
+    auto v = vec(s.length() + 1);
+    if (v) std::strcpy(v.get(), s.data());
+    return v;
+  }
+
+  // TODO(mvsc): MVSC requires this special case:
+  static auto make() -> vec {
+    return vec(0);
+  }
+
+  template<class... Ts>
+  static auto make(Ts&&... args) -> vec {
+    T data[] = { std::forward<Ts>(args)... };
+    return make(sizeof...(Ts), data);
+  }
+
+  static auto adopt(size_t size, T data[]) -> vec {
+    return vec(size, data);
+  }
+
+  static auto invalid() -> vec {
+    return vec(invalid_size, nullptr);
+  }
+};
+
+
+// Ownership
+
+template<class T> using own = std::unique_ptr<T>;
+template<class T> using ownvec = vec<own<T>>;
+
+template<class T>
+auto make_own(T* x) -> own<T> { return own<T>(x); }
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+class WASM_API_EXTERN Config {
+public:
+  Config() = delete;
+  ~Config();
+  void operator delete(void*);
+
+  static auto make() -> own<Config>;
+
+  // Implementations may provide custom methods for manipulating Configs.
+};
+
+
+// Engine
+
+class WASM_API_EXTERN Engine {
+public:
+  Engine() = delete;
+  ~Engine();
+  void operator delete(void*);
+
+  static auto make(own<Config>&& = Config::make()) -> own<Engine>;
+};
+
+
+// Store
+
+class WASM_API_EXTERN Store {
+public:
+  Store() = delete;
+  ~Store();
+  void operator delete(void*);
+
+  static auto make(Engine*) -> own<Store>;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+enum class Mutability : uint8_t { CONST, VAR };
+
+struct Limits {
+  uint32_t min;
+  uint32_t max;
+
+  Limits(uint32_t min, uint32_t max = std::numeric_limits<uint32_t>::max()) :
+    min(min), max(max) {}
+};
+
+
+// Value Types
+
+enum class ValueKind : uint8_t {
+  I32, I64, F32, F64,
+  ANYREF = 128, FUNCREF,
+};
+
+inline bool is_num(ValueKind k) { return k < ValueKind::ANYREF; }
+inline bool is_ref(ValueKind k) { return k >= ValueKind::ANYREF; }
+
+
+class WASM_API_EXTERN ValueType {
+public:
+  ValueType() = delete;
+  ~ValueType();
+  void operator delete(void*);
+
+  static auto make(ValueKind) -> own<ValueType>;
+  auto copy() const -> own<ValueType>;
+
+  auto kind() const -> ValueKind;
+  auto is_num() const -> bool { return wasm::is_num(kind()); }
+  auto is_ref() const -> bool { return wasm::is_ref(kind()); }
+};
+
+
+// External Types
+
+enum class ExternKind : uint8_t {
+  FUNC, GLOBAL, TABLE, MEMORY
+};
+
+class FuncType;
+class GlobalType;
+class TableType;
+class MemoryType;
+
+class WASM_API_EXTERN ExternType {
+public:
+  ExternType() = delete;
+  ~ExternType();
+  void operator delete(void*);
+
+  auto copy() const-> own<ExternType>;
+
+  auto kind() const -> ExternKind;
+
+  auto func() -> FuncType*;
+  auto global() -> GlobalType*;
+  auto table() -> TableType*;
+  auto memory() -> MemoryType*;
+
+  auto func() const -> const FuncType*;
+  auto global() const -> const GlobalType*;
+  auto table() const -> const TableType*;
+  auto memory() const -> const MemoryType*;
+};
+
+
+// Function Types
+
+class WASM_API_EXTERN FuncType : public ExternType {
+public:
+  FuncType() = delete;
+  ~FuncType();
+
+  static auto make(
+    ownvec<ValueType>&& params = ownvec<ValueType>::make(),
+    ownvec<ValueType>&& results = ownvec<ValueType>::make()
+  ) -> own<FuncType>;
+
+  auto copy() const -> own<FuncType>;
+
+  auto params() const -> const ownvec<ValueType>&;
+  auto results() const -> const ownvec<ValueType>&;
+};
+
+
+// Global Types
+
+class WASM_API_EXTERN GlobalType : public ExternType {
+public:
+  GlobalType() = delete;
+  ~GlobalType();
+
+  static auto make(own<ValueType>&&, Mutability) -> own<GlobalType>;
+  auto copy() const -> own<GlobalType>;
+
+  auto content() const -> const ValueType*;
+  auto mutability() const -> Mutability;
+};
+
+
+// Table Types
+
+class WASM_API_EXTERN TableType : public ExternType {
+public:
+  TableType() = delete;
+  ~TableType();
+
+  static auto make(own<ValueType>&&, Limits) -> own<TableType>;
+  auto copy() const -> own<TableType>;
+
+  auto element() const -> const ValueType*;
+  auto limits() const -> const Limits&;
+};
+
+
+// Memory Types
+
+class WASM_API_EXTERN MemoryType : public ExternType {
+public:
+  MemoryType() = delete;
+  ~MemoryType();
+
+  static auto make(Limits) -> own<MemoryType>;
+  auto copy() const -> own<MemoryType>;
+
+  auto limits() const -> const Limits&;
+};
+
+
+// Import Types
+
+using Name = vec<byte_t>;
+
+class WASM_API_EXTERN ImportType {
+public:
+  ImportType() = delete;
+  ~ImportType();
+  void operator delete(void*);
+
+  static auto make(Name&& module, Name&& name, own<ExternType>&&) ->
+    own<ImportType>;
+  auto copy() const -> own<ImportType>;
+
+  auto module() const -> const Name&;
+  auto name() const -> const Name&;
+  auto type() const -> const ExternType*;
+};
+
+
+// Export Types
+
+class WASM_API_EXTERN ExportType {
+public:
+  ExportType() = delete;
+  ~ExportType();
+  void operator delete(void*);
+
+  static auto make(Name&&, own<ExternType>&&) -> own<ExportType>;
+  auto copy() const -> own<ExportType>;
+
+  auto name() const -> const Name&;
+  auto type() const -> const ExternType*;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// References
+
+class WASM_API_EXTERN Ref {
+public:
+  Ref() = delete;
+  ~Ref();
+  void operator delete(void*);
+
+  auto copy() const -> own<Ref>;
+  auto same(const Ref*) const -> bool;
+
+  auto get_host_info() const -> void*;
+  void set_host_info(void* info, void (*finalizer)(void*) = nullptr);
+};
+
+
+// Values
+
+class Value {
+  ValueKind kind_;
+  union impl {
+    int32_t i32;
+    int64_t i64;
+    float32_t f32;
+    float64_t f64;
+    Ref* ref;
+  } impl_;
+
+  Value(ValueKind kind, impl impl) : kind_(kind), impl_(impl) {}
+
+public:
+  Value() : kind_(ValueKind::ANYREF) { impl_.ref = nullptr; }
+  explicit Value(int32_t i) : kind_(ValueKind::I32) { impl_.i32 = i; }
+  explicit Value(int64_t i) : kind_(ValueKind::I64) { impl_.i64 = i; }
+  explicit Value(float32_t z) : kind_(ValueKind::F32) { impl_.f32 = z; }
+  explicit Value(float64_t z) : kind_(ValueKind::F64) { impl_.f64 = z; }
+  explicit Value(own<Ref>&& r) : kind_(ValueKind::ANYREF) { impl_.ref = r.release(); }
+
+  Value(Value&& that) : kind_(that.kind_), impl_(that.impl_) {
+    if (is_ref()) that.impl_.ref = nullptr;
+  }
+
+  ~Value() {
+    reset();
+  }
+
+  auto is_num() const -> bool { return wasm::is_num(kind_); }
+  auto is_ref() const -> bool { return wasm::is_ref(kind_); }
+
+  static auto i32(int32_t x) -> Value { return Value(x); }
+  static auto i64(int64_t x) -> Value { return Value(x); }
+  static auto f32(float32_t x) -> Value { return Value(x); }
+  static auto f64(float64_t x) -> Value { return Value(x); }
+  static auto ref(own<Ref>&& x) -> Value { return Value(std::move(x)); }
+  template<class T> inline static auto make(T x) -> Value;
+  template<class T> inline static auto make(own<T>&& x) -> Value;
+
+  void reset() {
+    if (is_ref() && impl_.ref) {
+      delete impl_.ref;
+      impl_.ref = nullptr;
+    }
+  }
+
+  void reset(Value& that) {
+    reset();
+    kind_ = that.kind_;
+    impl_ = that.impl_;
+    if (is_ref()) that.impl_.ref = nullptr;
+  }
+
+  auto operator=(Value&& that) -> Value& {
+    reset(that);
+    return *this;
+  } 
+
+  auto kind() const -> ValueKind { return kind_; }
+  auto i32() const -> int32_t { assert(kind_ == ValueKind::I32); return impl_.i32; }
+  auto i64() const -> int64_t { assert(kind_ == ValueKind::I64); return impl_.i64; }
+  auto f32() const -> float32_t { assert(kind_ == ValueKind::F32); return impl_.f32; }
+  auto f64() const -> float64_t { assert(kind_ == ValueKind::F64); return impl_.f64; }
+  auto ref() const -> Ref* { assert(is_ref()); return impl_.ref; }
+  template<class T> inline auto get() const -> T;
+
+  auto release_ref() -> own<Ref> {
+    assert(is_ref());
+    auto ref = impl_.ref;
+    impl_.ref = nullptr;
+    return own<Ref>(ref);
+  }
+
+  auto copy() const -> Value {
+    if (is_ref() && impl_.ref != nullptr) {
+      // TODO(mvsc): MVSC cannot handle this:
+      // impl impl = {.ref = impl_.ref->copy().release()};
+      impl impl;
+      impl.ref = impl_.ref->copy().release();
+      return Value(kind_, impl);
+    } else {
+      return Value(kind_, impl_);
+    }
+  }
+};
+
+
+template<> inline auto Value::make<int32_t>(int32_t x) -> Value { return Value(x); }
+template<> inline auto Value::make<int64_t>(int64_t x) -> Value { return Value(x); }
+template<> inline auto Value::make<float32_t>(float32_t x) -> Value { return Value(x); }
+template<> inline auto Value::make<float64_t>(float64_t x) -> Value { return Value(x); }
+template<> inline auto Value::make<Ref>(own<Ref>&& x) -> Value {
+  return Value(std::move(x));
+}
+
+template<> inline auto Value::make<uint32_t>(uint32_t x) -> Value {
+  return Value(static_cast<int32_t>(x));
+}
+template<> inline auto Value::make<uint64_t>(uint64_t x) -> Value {
+  return Value(static_cast<int64_t>(x));
+}
+
+template<> inline auto Value::get<int32_t>() const -> int32_t { return i32(); }
+template<> inline auto Value::get<int64_t>() const -> int64_t { return i64(); }
+template<> inline auto Value::get<float32_t>() const -> float32_t { return f32(); }
+template<> inline auto Value::get<float64_t>() const -> float64_t { return f64(); }
+template<> inline auto Value::get<Ref*>() const -> Ref* { return ref(); }
+
+template<> inline auto Value::get<uint32_t>() const -> uint32_t {
+  return static_cast<uint32_t>(i32());
+}
+template<> inline auto Value::get<uint64_t>() const -> uint64_t {
+  return static_cast<uint64_t>(i64());
+}
+
+
+// Traps
+
+using Message = vec<byte_t>;  // null terminated
+
+class Instance;
+
+class WASM_API_EXTERN Frame {
+public:
+  Frame() = delete;
+  ~Frame();
+  void operator delete(void*);
+
+  auto copy() const -> own<Frame>;
+
+  auto instance() const -> Instance*;
+  auto func_index() const -> uint32_t;
+  auto func_offset() const -> size_t;
+  auto module_offset() const -> size_t;
+};
+
+class WASM_API_EXTERN Trap : public Ref {
+public:
+  Trap() = delete;
+  ~Trap();
+
+  static auto make(Store*, const Message& msg) -> own<Trap>;
+  auto copy() const -> own<Trap>;
+
+  auto message() const -> Message;
+  auto origin() const -> own<Frame>;  // may be null
+  auto trace() const -> ownvec<Frame>;  // may be empty, origin first
+};
+
+
+// Shared objects
+
+template<class T>
+class WASM_API_EXTERN Shared {
+public:
+  Shared() = delete;
+  ~Shared();
+  void operator delete(void*);
+};
+
+
+// Modules
+
+class WASM_API_EXTERN Module : public Ref {
+public:
+  Module() = delete;
+  ~Module();
+
+  static auto validate(Store*, const vec<byte_t>& binary) -> bool;
+  static auto make(Store*, const vec<byte_t>& binary) -> own<Module>;
+  auto copy() const -> own<Module>;
+
+  auto imports() const -> ownvec<ImportType>;
+  auto exports() const -> ownvec<ExportType>;
+
+  auto share() const -> own<Shared<Module>>;
+  static auto obtain(Store*, const Shared<Module>*) -> own<Module>;
+
+  auto serialize() const -> vec<byte_t>;
+  static auto deserialize(Store*, const vec<byte_t>&) -> own<Module>;
+};
+
+
+// Foreign Objects
+
+class WASM_API_EXTERN Foreign : public Ref {
+public:
+  Foreign() = delete;
+  ~Foreign();
+
+  static auto make(Store*) -> own<Foreign>;
+  auto copy() const -> own<Foreign>;
+};
+
+
+// Externals
+
+class Func;
+class Global;
+class Table;
+class Memory;
+
+class WASM_API_EXTERN Extern : public Ref {
+public:
+  Extern() = delete;
+  ~Extern();
+
+  auto copy() const -> own<Extern>;
+
+  auto kind() const -> ExternKind;
+  auto type() const -> own<ExternType>;
+
+  auto func() -> Func*;
+  auto global() -> Global*;
+  auto table() -> Table*;
+  auto memory() -> Memory*;
+
+  auto func() const -> const Func*;
+  auto global() const -> const Global*;
+  auto table() const -> const Table*;
+  auto memory() const -> const Memory*;
+};
+
+
+// Function Instances
+
+class WASM_API_EXTERN Func : public Extern {
+public:
+  Func() = delete;
+  ~Func();
+
+  using callback = auto (*)(const vec<Value>&, vec<Value>&) -> own<Trap>;
+  using callback_with_env = auto (*)(void*, const vec<Value>&, vec<Value>&) -> own<Trap>;
+
+  static auto make(Store*, const FuncType*, callback) -> own<Func>;
+  static auto make(Store*, const FuncType*, callback_with_env,
+    void*, void (*finalizer)(void*) = nullptr) -> own<Func>;
+  auto copy() const -> own<Func>;
+
+  auto type() const -> own<FuncType>;
+  auto param_arity() const -> size_t;
+  auto result_arity() const -> size_t;
+
+  auto call(const vec<Value>&, vec<Value>&) const -> own<Trap>;
+};
+
+
+// Global Instances
+
+class WASM_API_EXTERN Global : public Extern {
+public:
+  Global() = delete;
+  ~Global();
+
+  static auto make(Store*, const GlobalType*, const Value&) -> own<Global>;
+  auto copy() const -> own<Global>;
+
+  auto type() const -> own<GlobalType>;
+  auto get() const -> Value;
+  void set(const Value&);
+};
+
+
+// Table Instances
+
+class WASM_API_EXTERN Table : public Extern {
+public:
+  Table() = delete;
+  ~Table();
+
+  using size_t = uint32_t;
+
+  static auto make(
+    Store*, const TableType*, const Ref* init = nullptr) -> own<Table>;
+  auto copy() const -> own<Table>;
+
+  auto type() const -> own<TableType>;
+  auto get(size_t index) const -> own<Ref>;
+  auto set(size_t index, const Ref*) -> bool;
+  auto size() const -> size_t;
+  auto grow(size_t delta, const Ref* init = nullptr) -> bool;
+};
+
+
+// Memory Instances
+
+class WASM_API_EXTERN Memory : public Extern {
+public:
+  Memory() = delete;
+  ~Memory();
+
+  static auto make(Store*, const MemoryType*) -> own<Memory>;
+  auto copy() const -> own<Memory>;
+
+  using pages_t = uint32_t;
+
+  static const size_t page_size = 0x10000;
+
+  auto type() const -> own<MemoryType>;
+  auto data() const -> byte_t*;
+  auto data_size() const -> size_t;
+  auto size() const -> pages_t;
+  auto grow(pages_t delta) -> bool;
+};
+
+
+// Module Instances
+
+class WASM_API_EXTERN Instance : public Ref {
+public:
+  Instance() = delete;
+  ~Instance();
+
+  static auto make(
+    Store*, const Module*, const vec<Extern*>&, own<Trap>* = nullptr
+  ) -> own<Instance>;
+  auto copy() const -> own<Instance>;
+
+  auto exports() const -> ownvec<Extern>;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace wasm
+
+#endif  // #ifdef WASM_HH
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/patch/0001-BUILD.gn-add-wasm-v8-lowlevel.patch b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/patch/0001-BUILD.gn-add-wasm-v8-lowlevel.patch
new file mode 100644
index 0000000..fe7b35f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/patch/0001-BUILD.gn-add-wasm-v8-lowlevel.patch
@@ -0,0 +1,28 @@
+diff --git a/BUILD.gn b/BUILD.gn
+index deedf82..6dced15 100644
+--- a/BUILD.gn
++++ b/BUILD.gn
+@@ -1679,6 +1679,7 @@ v8_header_set("v8_headers") {
+
+   sources = [
+     "include/v8.h",
++    "include/wasm-v8-lowlevel.hh",
+     "include/v8config.h",
+   ]
+
+@@ -2007,6 +2008,7 @@ v8_source_set("v8_base") {
+     "include/v8-testing.h",
+     "include/v8-util.h",
+     "include/v8.h",
++    "include/wasm-v8-lowlevel.hh",
+     "include/v8config.h",
+     "src/accessors.cc",
+     "src/accessors.h",
+@@ -2020,6 +2022,7 @@ v8_source_set("v8_base") {
+     "src/api/api-natives.h",
+     "src/api/api.cc",
+     "src/api/api.h",
++    "src/wasm-v8-lowlevel.cc",
+     "src/asmjs/asm-js.cc",
+     "src/asmjs/asm-js.h",
+     "src/asmjs/asm-names.h",
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.cc
new file mode 100644
index 0000000..93f0b58
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.cc
@@ -0,0 +1,570 @@
+#include "wasm-bin.hh"
+
+#include <cstring>
+
+namespace wasm {
+namespace bin {
+
+////////////////////////////////////////////////////////////////////////////////
+// Encoding
+
+void encode_header(char*& ptr) {
+  std::memcpy(ptr, "\x00""asm\x01\x00\x00\x00", 8);
+  ptr += 8;
+}
+
+auto u64_size(uint64_t n) -> size_t {
+  bool done = false;
+  size_t size = 0;
+  do {
+    ++size;
+    done = n <= 0x7f;
+    n = n >> 7;
+  } while (!done);
+  return size;
+}
+
+auto u32_size(uint64_t n) -> size_t {
+  return u64_size(n);
+}
+
+void encode_u64(char*& ptr, uint64_t n) {
+  bool done = false;
+  do {
+    done = n <= 0x7f;
+    *ptr++ = (n & 0x7f) | (done ? 0x00 : 0x80);
+    n = n >> 7;
+  } while (!done);
+}
+
+void encode_u32(char*& ptr, uint32_t n) {
+  encode_u64(ptr, n);
+}
+
+void encode_size32(char*& ptr, size_t n) {
+  assert(n <= 0xffffffff);
+  for (int i = 0; i < 5; ++i) {
+    *ptr++ = (n & 0x7f) | (i == 4 ? 0x00 : 0x80);
+    n = n >> 7;
+  }
+}
+
+
+void encode_valtype(char*& ptr, const ValType* type) {
+  switch (type->kind()) {
+    case ValKind::I32: *ptr++ = 0x7f; break;
+    case ValKind::I64: *ptr++ = 0x7e; break;
+    case ValKind::F32: *ptr++ = 0x7d; break;
+    case ValKind::F64: *ptr++ = 0x7c; break;
+    case ValKind::FUNCREF: *ptr++ = 0x70; break;
+    case ValKind::ANYREF: *ptr++ = 0x6f; break;
+    default: assert(false);
+  }
+}
+
+auto zero_size(const ValType* type) -> size_t {
+  switch (type->kind()) {
+    case ValKind::I32: return 1;
+    case ValKind::I64: return 1;
+    case ValKind::F32: return 4;
+    case ValKind::F64: return 8;
+    case ValKind::FUNCREF: return 0;
+    case ValKind::ANYREF: return 0;
+    default: assert(false);
+  }
+}
+
+void encode_const_zero(char*& ptr, const ValType* type) {
+  switch (type->kind()) {
+    case ValKind::I32: *ptr++ = 0x41; break;
+    case ValKind::I64: *ptr++ = 0x42; break;
+    case ValKind::F32: *ptr++ = 0x43; break;
+    case ValKind::F64: *ptr++ = 0x44; break;
+    case ValKind::FUNCREF: *ptr++ = 0xd0; break;
+    case ValKind::ANYREF: *ptr++ = 0xd0; break;
+    default: assert(false);
+  }
+  for (int i = 0; i < zero_size(type); ++i) *ptr++ = 0;
+}
+
+
+auto wrapper(const FuncType* type) -> vec<byte_t> {
+  auto in_arity = type->params().size();
+  auto out_arity = type->results().size();
+  auto size = 39 + in_arity + out_arity;
+  auto binary = vec<byte_t>::make_uninitialized(size);
+  auto ptr = binary.get();
+
+  encode_header(ptr);
+
+  *ptr++ = 0x01;  // type section
+  encode_size32(ptr, 12 + in_arity + out_arity);  // size
+  *ptr++ = 1;  // length
+  *ptr++ = 0x60;  // function
+  encode_size32(ptr, in_arity);
+  for (size_t i = 0; i < in_arity; ++i) {
+    encode_valtype(ptr, type->params()[i].get());
+  }
+  encode_size32(ptr, out_arity);
+  for (size_t i = 0; i < out_arity; ++i) {
+    encode_valtype(ptr, type->results()[i].get());
+  }
+
+  *ptr++ = 0x02;  // import section
+  *ptr++ = 5;  // size
+  *ptr++ = 1;  // length
+  *ptr++ = 0;  // module length
+  *ptr++ = 0;  // name length
+  *ptr++ = 0x00;  // func
+  *ptr++ = 0;  // type index
+
+  *ptr++ = 0x07;  // export section
+  *ptr++ = 4;  // size
+  *ptr++ = 1;  // length
+  *ptr++ = 0;  // name length
+  *ptr++ = 0x00;  // func
+  *ptr++ = 0;  // func index
+
+  assert(ptr - binary.get() == size);
+  return binary;
+}
+
+auto wrapper(const GlobalType* type) -> vec<byte_t> {
+  auto size = 25 + zero_size(type->content());
+  auto binary = vec<byte_t>::make_uninitialized(size);
+  auto ptr = binary.get();
+
+  encode_header(ptr);
+
+  *ptr++ = 0x06;  // global section
+  encode_size32(ptr, 5 + zero_size(type->content()));  // size
+  *ptr++ = 1;  // length
+  encode_valtype(ptr, type->content());
+  *ptr++ = (type->mutability() == Mutability::VAR);
+  encode_const_zero(ptr, type->content());
+  *ptr++ = 0x0b;  // end
+
+  *ptr++ = 0x07;  // export section
+  *ptr++ = 4;  // size
+  *ptr++ = 1;  // length
+  *ptr++ = 0;  // name length
+  *ptr++ = 0x03;  // global
+  *ptr++ = 0;  // func index
+
+  assert(ptr - binary.get() == size);
+  return binary;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Decoding
+
+// Numbers
+
+auto u32(const byte_t*& pos) -> uint32_t {
+  uint32_t n = 0;
+  uint32_t shift = 0;
+  byte_t b;
+  do {
+    b = *pos++;
+    n += (b & 0x7f) << shift;
+    shift += 7;
+  } while ((b & 0x80) != 0);
+  return n;
+}
+
+auto u64(const byte_t*& pos) -> uint64_t {
+  uint64_t n = 0;
+  uint64_t shift = 0;
+  byte_t b;
+  do {
+    b = *pos++;
+    n += (b & 0x7f) << shift;
+    shift += 7;
+  } while ((b & 0x80) != 0);
+  return n;
+}
+
+void u32_skip(const byte_t*& pos) {
+  bin::u32(pos);
+}
+
+
+// Names
+
+auto name(const byte_t*& pos) -> Name {
+  auto size = bin::u32(pos);
+  auto start = pos;
+  auto name = Name::make_uninitialized(size);
+  std::memcpy(name.get(), start, size);
+  pos += size;
+  return name;
+}
+
+void name_skip(const byte_t*& pos) {
+  auto size = bin::u32(pos);
+  pos += size;
+}
+
+
+// Types
+
+auto valtype(const byte_t*& pos) -> own<wasm::ValType> {
+  switch (*pos++) {
+    case 0x7f: return ValType::make(ValKind::I32);
+    case 0x7e: return ValType::make(ValKind::I64);
+    case 0x7d: return ValType::make(ValKind::F32);
+    case 0x7c: return ValType::make(ValKind::F64);
+    case 0x70: return ValType::make(ValKind::FUNCREF);
+    case 0x6f: return ValType::make(ValKind::ANYREF);
+    default:
+      // TODO(wasm+): support new value types
+      assert(false);
+  }
+}
+
+auto mutability(const byte_t*& pos) -> Mutability {
+  return *pos++ ? Mutability::VAR : Mutability::CONST;
+}
+
+auto limits(const byte_t*& pos) -> Limits {
+  auto tag = *pos++;
+  auto min = bin::u32(pos);
+  if ((tag & 0x01) == 0) {
+    return Limits(min);
+  } else {
+    auto max = bin::u32(pos);
+    return Limits(min, max);
+  }
+}
+
+auto stacktype(const byte_t*& pos) -> ownvec<ValType> {
+  size_t size = bin::u32(pos);
+  auto v = ownvec<ValType>::make_uninitialized(size);
+  for (uint32_t i = 0; i < size; ++i) v[i] = bin::valtype(pos);
+  return v;
+}
+
+auto functype(const byte_t*& pos) -> own<FuncType> {
+  assert(*pos == 0x60);
+  ++pos;
+  auto params = bin::stacktype(pos);
+  auto results = bin::stacktype(pos);
+  return FuncType::make(std::move(params), std::move(results));
+}
+
+auto globaltype(const byte_t*& pos) -> own<GlobalType> {
+  auto content = bin::valtype(pos);
+  auto mutability = bin::mutability(pos);
+  return GlobalType::make(std::move(content), mutability);
+}
+
+auto tabletype(const byte_t*& pos) -> own<TableType> {
+  auto elem = bin::valtype(pos);
+  auto limits = bin::limits(pos);
+  return TableType::make(std::move(elem), limits);
+}
+
+auto memorytype(const byte_t*& pos) -> own<MemoryType> {
+  auto limits = bin::limits(pos);
+  return MemoryType::make(limits);
+}
+
+
+void mutability_skip(const byte_t*& pos) {
+  ++pos;
+}
+
+void limits_skip(const byte_t*& pos) {
+  auto tag = *pos++;
+  bin::u32_skip(pos);
+  if ((tag & 0x01) != 0) bin::u32_skip(pos);
+}
+
+void valtype_skip(const byte_t*& pos) {
+  // TODO(wasm+): support new value types
+  ++pos;
+}
+
+void globaltype_skip(const byte_t*& pos) {
+  bin::valtype_skip(pos);
+  bin::mutability_skip(pos);
+}
+
+void tabletype_skip(const byte_t*& pos) {
+  bin::valtype_skip(pos);
+  bin::limits_skip(pos);
+}
+
+void memorytype_skip(const byte_t*& pos) {
+  bin::limits_skip(pos);
+}
+
+
+// Expressions
+
+void expr_skip(const byte_t*& pos) {
+  switch (*pos++ & 0xff) {
+    case 0x41:  // i32.const
+    case 0x42:  // i64.const
+    case 0x23:  // get_global
+    case 0xd2: {  // ref.func
+      bin::u32_skip(pos);
+    } break;
+    case 0x43: {  // f32.const
+      pos += 4;
+    } break;
+    case 0x44: {  // f64.const
+      pos += 8;
+    } break;
+    case 0xd0: {  // ref.null
+    } break;
+    default: {
+      assert(false);
+    }
+  }
+  ++pos;  // end
+}
+
+
+// Sections
+
+enum sec_t : byte_t {
+  SEC_TYPE = 1,
+  SEC_IMPORT = 2,
+  SEC_FUNC = 3,
+  SEC_TABLE = 4,
+  SEC_MEMORY = 5,
+  SEC_GLOBAL = 6,
+  SEC_EXPORT = 7
+};
+
+auto section(const vec<byte_t>& binary, bin::sec_t sec) -> const byte_t* {
+  const byte_t* end = binary.get() + binary.size();
+  const byte_t* pos = binary.get() + 8;  // skip header
+  while (pos < end && *pos++ != sec) {
+    auto size = bin::u32(pos);
+    pos += size;
+  }
+  if (pos == end) return nullptr;
+  bin::u32_skip(pos);
+  return pos;
+}
+
+auto section_end(const vec<byte_t>& binary, bin::sec_t sec) -> const byte_t* {
+  const byte_t* end = binary.get() + binary.size();
+  const byte_t* pos = binary.get() + 8;  // skip header
+  while (pos < end && *pos != sec) {
+    ++pos;
+    auto size = bin::u32(pos);
+    pos += size;
+  }
+  if (pos == end) return nullptr;
+  ++pos;
+  auto size = bin::u32(pos);
+  return pos + size;
+}
+
+
+// Type section
+
+auto types(const vec<byte_t>& binary) -> ownvec<FuncType> {
+  auto pos = bin::section(binary, SEC_TYPE);
+  if (pos == nullptr) return ownvec<FuncType>::make();
+  size_t size = bin::u32(pos);
+  // TODO(wasm+): support new deftypes
+  auto v = ownvec<FuncType>::make_uninitialized(size);
+  for (uint32_t i = 0; i < size; ++i) {
+    v[i] = bin::functype(pos);
+  }
+  assert(pos = bin::section_end(binary, SEC_TYPE));
+  return v;
+}
+
+
+// Import section
+
+auto imports(
+  const vec<byte_t>& binary, const ownvec<FuncType>& types
+) -> ownvec<ImportType> {
+  auto pos = bin::section(binary, SEC_IMPORT);
+  if (pos == nullptr) return ownvec<ImportType>::make();
+  size_t size = bin::u32(pos);
+  auto v = ownvec<ImportType>::make_uninitialized(size);
+  for (uint32_t i = 0; i < size; ++i) {
+    auto module = bin::name(pos);
+    auto name = bin::name(pos);
+    own<ExternType> type;
+    switch (*pos++) {
+      case 0x00: type = types[bin::u32(pos)]->copy(); break;
+      case 0x01: type = bin::tabletype(pos); break;
+      case 0x02: type = bin::memorytype(pos); break;
+      case 0x03: type = bin::globaltype(pos); break;
+      default: assert(false);
+    }
+    v[i] = ImportType::make(
+      std::move(module), std::move(name), std::move(type));
+  }
+  assert(pos = bin::section_end(binary, SEC_IMPORT));
+  return v;
+}
+
+auto count(const ownvec<ImportType>& imports, ExternKind kind) -> uint32_t {
+  uint32_t n = 0;
+  for (uint32_t i = 0; i < imports.size(); ++i) {
+    if (imports[i]->type()->kind() == kind) ++n;
+  }
+  return n;
+}
+
+
+// Function section
+
+auto funcs(
+  const vec<byte_t>& binary,
+  const ownvec<ImportType>& imports, const ownvec<FuncType>& types
+) -> ownvec<FuncType> {
+  auto pos = bin::section(binary, SEC_FUNC);
+  size_t size = pos != nullptr ? bin::u32(pos) : 0;
+  auto v = ownvec<FuncType>::make_uninitialized(
+    size + count(imports, ExternKind::FUNC));
+  size_t j = 0;
+  for (uint32_t i = 0; i < imports.size(); ++i) {
+    auto et = imports[i]->type();
+    if (et->kind() == ExternKind::FUNC) {
+      v[j++] = et->func()->copy();
+    }
+  }
+  if (pos != nullptr) {
+    for (; j < v.size(); ++j) {
+      v[j] = types[bin::u32(pos)]->copy();
+    }
+    assert(pos = bin::section_end(binary, SEC_FUNC));
+  }
+  return v;
+}
+
+
+// Global section
+
+auto globals(
+  const vec<byte_t>& binary, const ownvec<ImportType>& imports
+) -> ownvec<GlobalType> {
+  auto pos = bin::section(binary, SEC_GLOBAL);
+  size_t size = pos != nullptr ? bin::u32(pos) : 0;
+  auto v = ownvec<GlobalType>::make_uninitialized(
+    size + count(imports, ExternKind::GLOBAL));
+  size_t j = 0;
+  for (uint32_t i = 0; i < imports.size(); ++i) {
+    auto et = imports[i]->type();
+    if (et->kind() == ExternKind::GLOBAL) {
+      v[j++] = et->global()->copy();
+    }
+  }
+  if (pos != nullptr) {
+    for (; j < v.size(); ++j) {
+      v[j] = bin::globaltype(pos);
+      expr_skip(pos);
+    }
+    assert(pos = bin::section_end(binary, SEC_GLOBAL));
+  }
+  return v;
+}
+
+
+// Table section
+
+auto tables(
+  const vec<byte_t>& binary, const ownvec<ImportType>& imports
+) -> ownvec<TableType> {
+  auto pos = bin::section(binary, SEC_TABLE);
+  size_t size = pos != nullptr ? bin::u32(pos) : 0;
+  auto v = ownvec<TableType>::make_uninitialized(
+    size + count(imports, ExternKind::TABLE));
+  size_t j = 0;
+  for (uint32_t i = 0; i < imports.size(); ++i) {
+    auto et = imports[i]->type();
+    if (et->kind() == ExternKind::TABLE) {
+      v[j++] = et->table()->copy();
+    }
+  }
+  if (pos != nullptr) {
+    for (; j < v.size(); ++j) {
+      v[j] = bin::tabletype(pos);
+    }
+    assert(pos = bin::section_end(binary, SEC_TABLE));
+  }
+  return v;
+}
+
+
+// Memory section
+
+auto memories(
+  const vec<byte_t>& binary, const ownvec<ImportType>& imports
+) -> ownvec<MemoryType> {
+  auto pos = bin::section(binary, SEC_MEMORY);
+  size_t size = pos != nullptr ? bin::u32(pos) : 0;
+  auto v = ownvec<MemoryType>::make_uninitialized(
+    size + count(imports, ExternKind::MEMORY));
+  size_t j = 0;
+  for (uint32_t i = 0; i < imports.size(); ++i) {
+    auto et = imports[i]->type();
+    if (et->kind() == ExternKind::MEMORY) {
+      v[j++] = et->memory()->copy();
+    }
+  }
+  if (pos != nullptr) {
+    for (; j < v.size(); ++j) {
+      v[j] = bin::memorytype(pos);
+    }
+    assert(pos = bin::section_end(binary, SEC_MEMORY));
+  }
+  return v;
+}
+
+
+// Export section
+
+auto exports(const vec<byte_t>& binary,
+  const ownvec<FuncType>& funcs, const ownvec<GlobalType>& globals,
+  const ownvec<TableType>& tables, const ownvec<MemoryType>& memories
+) -> ownvec<ExportType> {
+  auto pos = bin::section(binary, SEC_EXPORT);
+  if (pos == nullptr) return ownvec<ExportType>::make();
+  size_t size = bin::u32(pos);
+  auto exports = ownvec<ExportType>::make_uninitialized(size);
+  for (uint32_t i = 0; i < size; ++i) {
+    auto name = bin::name(pos);
+    auto tag = *pos++;
+    auto index = bin::u32(pos);
+    own<ExternType> type;
+    switch (tag) {
+      case 0x00: type = funcs[index]->copy(); break;
+      case 0x01: type = tables[index]->copy(); break;
+      case 0x02: type = memories[index]->copy(); break;
+      case 0x03: type = globals[index]->copy(); break;
+      default: assert(false);
+    }
+    exports[i] = ExportType::make(std::move(name), std::move(type));
+  }
+  assert(pos = bin::section_end(binary, SEC_EXPORT));
+  return exports;
+}
+
+auto imports(const vec<byte_t>& binary) -> ownvec<ImportType> {
+  return bin::imports(binary, bin::types(binary));
+}
+
+auto exports(const vec<byte_t>& binary) -> ownvec<ExportType> {
+  auto types = bin::types(binary);
+  auto imports = bin::imports(binary, types);
+  auto funcs = bin::funcs(binary, imports, types);
+  auto globals = bin::globals(binary, imports);
+  auto tables = bin::tables(binary, imports);
+  auto memories = bin::memories(binary, imports);
+  return bin::exports(binary, funcs, globals, tables, memories);
+}
+
+}  // namespace bin
+}  // namespace wasm
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.hh b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.hh
new file mode 100644
index 0000000..15b2529
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-bin.hh
@@ -0,0 +1,25 @@
+#ifndef __WASM_BIN_HH
+#define __WASM_BIN_HH
+
+#include "wasm.hh"
+
+namespace wasm {
+namespace bin {
+
+auto u32_size(uint32_t) -> size_t;
+auto u64_size(uint64_t) -> size_t;
+void encode_u32(char*& ptr, uint32_t n);
+void encode_u64(char*& ptr, uint64_t n);
+auto u32(const byte_t*& pos) -> uint32_t;
+auto u64(const byte_t*& pos) -> uint64_t;
+
+auto wrapper(const FuncType*) -> vec<byte_t>;
+auto wrapper(const GlobalType*) -> vec<byte_t>;
+
+auto imports(const vec<byte_t>& binary) -> ownvec<ImportType>;
+auto exports(const vec<byte_t>& binary) -> ownvec<ExportType>;
+
+}  // namespace bin
+}  // namespace wasm
+
+#endif  // #ifdef __WASM_BIN_HH
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-c.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-c.cc
new file mode 100644
index 0000000..23f8151
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-c.cc
@@ -0,0 +1,1024 @@
+#include "wasm.h"
+#include "wasm.hh"
+
+#include "wasm-v8.cc"
+
+using namespace wasm;
+
+extern "C" {
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Backing implementation
+
+extern "C++" {
+
+template<class T>
+struct borrowed_vec {
+  vec<T> it;
+  borrowed_vec(vec<T>&& v) : it(std::move(v)) {}
+  borrowed_vec(borrowed_vec<T>&& that) : it(std::move(that.it)) {}
+  ~borrowed_vec() { it.release(); }
+};
+
+}  // extern "C++"
+
+
+#define WASM_DEFINE_OWN(name, Name) \
+  struct wasm_##name##_t : Name {}; \
+  \
+  void wasm_##name##_delete(wasm_##name##_t* x) { \
+    delete x; \
+  } \
+  \
+  extern "C++" inline auto hide_##name(Name* x) -> wasm_##name##_t* { \
+    return static_cast<wasm_##name##_t*>(x); \
+  } \
+  extern "C++" inline auto hide_##name(const Name* x) -> const wasm_##name##_t* { \
+    return static_cast<const wasm_##name##_t*>(x); \
+  } \
+  extern "C++" inline auto reveal_##name(wasm_##name##_t* x) -> Name* { \
+    return x; \
+  } \
+  extern "C++" inline auto reveal_##name(const wasm_##name##_t* x) -> const Name* { \
+    return x; \
+  } \
+  extern "C++" inline auto get_##name(own<Name>& x) -> wasm_##name##_t* { \
+    return hide_##name(x.get()); \
+  } \
+  extern "C++" inline auto get_##name(const own<Name>& x) -> const wasm_##name##_t* { \
+    return hide_##name(x.get()); \
+  } \
+  extern "C++" inline auto release_##name(own<Name>&& x) -> wasm_##name##_t* { \
+    return hide_##name(x.release()); \
+  } \
+  extern "C++" inline auto adopt_##name(wasm_##name##_t* x) -> own<Name> { \
+    return make_own(x); \
+  }
+
+
+// Vectors
+
+#define WASM_DEFINE_VEC_BASE(name, Name, vec, plainvec, ptr_or_none) \
+  static_assert( \
+    sizeof(wasm_##name##_vec_t) == sizeof(vec<Name>), \
+    "C/C++ incompatibility" \
+  ); \
+  static_assert( \
+    sizeof(wasm_##name##_t ptr_or_none) == sizeof(vec<Name>::elem_type), \
+    "C/C++ incompatibility" \
+  ); \
+  \
+  extern "C++" inline auto hide_##name##_vec(vec<Name>& v) \
+  -> wasm_##name##_vec_t* { \
+    return reinterpret_cast<wasm_##name##_vec_t*>(&v); \
+  } \
+  extern "C++" inline auto hide_##name##_vec(const vec<Name>& v) \
+  -> const wasm_##name##_vec_t* { \
+    return reinterpret_cast<const wasm_##name##_vec_t*>(&v); \
+  } \
+  extern "C++" inline auto hide_##name##_vec(vec<Name>::elem_type* v) \
+  -> wasm_##name##_t ptr_or_none* { \
+    return reinterpret_cast<wasm_##name##_t ptr_or_none*>(v); \
+  } \
+  extern "C++" inline auto hide_##name##_vec(const vec<Name>::elem_type* v) \
+  -> wasm_##name##_t ptr_or_none const* { \
+    return reinterpret_cast<wasm_##name##_t ptr_or_none const*>(v); \
+  } \
+  extern "C++" inline auto reveal_##name##_vec(wasm_##name##_vec_t* v) \
+  -> plainvec<Name*>* { \
+    return reinterpret_cast<plainvec<Name*>*>(v); \
+  } \
+  extern "C++" inline auto reveal_##name##_vec(const wasm_##name##_vec_t* v) \
+  -> const plainvec<Name*>* { \
+    return reinterpret_cast<const plainvec<Name*>*>(v); \
+  } \
+  extern "C++" inline auto reveal_##name##_vec(wasm_##name##_t ptr_or_none* v) \
+  -> vec<Name>::elem_type* { \
+    return reinterpret_cast<vec<Name>::elem_type*>(v); \
+  } \
+  extern "C++" inline auto reveal_##name##_vec(wasm_##name##_t ptr_or_none const* v) \
+  -> const vec<Name>::elem_type* { \
+    return reinterpret_cast<const vec<Name>::elem_type*>(v); \
+  } \
+  extern "C++" inline auto get_##name##_vec(vec<Name>& v) \
+  -> wasm_##name##_vec_t { \
+    wasm_##name##_vec_t v2 = { v.size(), hide_##name##_vec(v.get()) }; \
+    return v2; \
+  } \
+  extern "C++" inline auto get_##name##_vec(const vec<Name>& v) \
+  -> const wasm_##name##_vec_t { \
+    wasm_##name##_vec_t v2 = { \
+      v.size(), const_cast<wasm_##name##_t ptr_or_none*>(hide_##name##_vec(v.get())) }; \
+    return v2; \
+  } \
+  extern "C++" inline auto release_##name##_vec(vec<Name>&& v) \
+  -> wasm_##name##_vec_t { \
+    wasm_##name##_vec_t v2 = { v.size(), hide_##name##_vec(v.release()) }; \
+    return v2; \
+  } \
+  extern "C++" inline auto adopt_##name##_vec(wasm_##name##_vec_t* v) \
+  -> vec<Name> { \
+    return vec<Name>::adopt(v->size, reveal_##name##_vec(v->data)); \
+  } \
+  extern "C++" inline auto borrow_##name##_vec(const wasm_##name##_vec_t* v) \
+  -> borrowed_vec<vec<Name>::elem_type> { \
+    return borrowed_vec<vec<Name>::elem_type>(vec<Name>::adopt(v->size, reveal_##name##_vec(v->data))); \
+  } \
+  \
+  void wasm_##name##_vec_new_uninitialized( \
+    wasm_##name##_vec_t* out, size_t size \
+  ) { \
+    *out = release_##name##_vec(vec<Name>::make_uninitialized(size)); \
+  } \
+  void wasm_##name##_vec_new_empty(wasm_##name##_vec_t* out) { \
+    wasm_##name##_vec_new_uninitialized(out, 0); \
+  } \
+  \
+  void wasm_##name##_vec_delete(wasm_##name##_vec_t* v) { \
+    adopt_##name##_vec(v); \
+  }
+
+// Vectors with no ownership management of elements
+#define WASM_DEFINE_VEC_PLAIN(name, Name) \
+  WASM_DEFINE_VEC_BASE(name, Name, vec, vec, ) \
+  \
+  void wasm_##name##_vec_new( \
+    wasm_##name##_vec_t* out, \
+    size_t size, \
+    const wasm_##name##_t data[] \
+  ) { \
+    auto v2 = vec<Name>::make_uninitialized(size); \
+    if (v2.size() != 0) { \
+      memcpy(v2.get(), data, size * sizeof(wasm_##name##_t)); \
+    } \
+    *out = release_##name##_vec(std::move(v2)); \
+  } \
+  \
+  void wasm_##name##_vec_copy( \
+    wasm_##name##_vec_t* out, const wasm_##name##_vec_t* v \
+  ) { \
+    wasm_##name##_vec_new(out, v->size, v->data); \
+  }
+
+// Vectors that own their elements
+#define WASM_DEFINE_VEC_OWN(name, Name) \
+  WASM_DEFINE_VEC_BASE(name, Name, ownvec, vec, *) \
+  \
+  void wasm_##name##_vec_new( \
+    wasm_##name##_vec_t* out, \
+    size_t size, \
+    wasm_##name##_t* const data[] \
+  ) { \
+    auto v2 = ownvec<Name>::make_uninitialized(size); \
+    for (size_t i = 0; i < v2.size(); ++i) { \
+      v2[i] = adopt_##name(data[i]); \
+    } \
+    *out = release_##name##_vec(std::move(v2)); \
+  } \
+  \
+  void wasm_##name##_vec_copy( \
+    wasm_##name##_vec_t* out, const wasm_##name##_vec_t* v \
+  ) { \
+    auto v2 = ownvec<Name>::make_uninitialized(v->size); \
+    for (size_t i = 0; i < v2.size(); ++i) { \
+      v2[i] = adopt_##name(wasm_##name##_copy(v->data[i])); \
+    } \
+    *out = release_##name##_vec(std::move(v2)); \
+  }
+
+extern "C++" {
+template<class T>
+inline auto is_empty(T* p) -> bool { return !p; }
+}
+
+
+// Byte vectors
+
+using byte = byte_t;
+WASM_DEFINE_VEC_PLAIN(byte, byte)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+WASM_DEFINE_OWN(config, Config)
+
+wasm_config_t* wasm_config_new() {
+  return release_config(Config::make());
+}
+
+
+// Engine
+
+WASM_DEFINE_OWN(engine, Engine)
+
+wasm_engine_t* wasm_engine_new() {
+  return release_engine(Engine::make());
+}
+
+wasm_engine_t* wasm_engine_new_with_config(wasm_config_t* config) {
+  return release_engine(Engine::make(adopt_config(config)));
+}
+
+
+// Stores
+
+WASM_DEFINE_OWN(store, Store)
+
+wasm_store_t* wasm_store_new(wasm_engine_t* engine) {
+  return release_store(Store::make(engine));
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+extern "C++" inline auto hide_mutability(Mutability mutability) -> wasm_mutability_t {
+  return static_cast<wasm_mutability_t>(mutability);
+}
+
+extern "C++" inline auto reveal_mutability(wasm_mutability_t mutability) -> Mutability {
+  return static_cast<Mutability>(mutability);
+}
+
+
+extern "C++" inline auto hide_limits(const Limits& limits) -> const wasm_limits_t* {
+  return reinterpret_cast<const wasm_limits_t*>(&limits);
+}
+
+extern "C++" inline auto reveal_limits(wasm_limits_t limits) -> Limits {
+  return Limits(limits.min, limits.max);
+}
+
+
+extern "C++" inline auto hide_valkind(ValKind kind) -> wasm_valkind_t {
+  return static_cast<wasm_valkind_t>(kind);
+}
+
+extern "C++" inline auto reveal_valkind(wasm_valkind_t kind) -> ValKind {
+  return static_cast<ValKind>(kind);
+}
+
+
+extern "C++" inline auto hide_externkind(ExternKind kind) -> wasm_externkind_t {
+  return static_cast<wasm_externkind_t>(kind);
+}
+
+extern "C++" inline auto reveal_externkind(wasm_externkind_t kind) -> ExternKind {
+  return static_cast<ExternKind>(kind);
+}
+
+
+
+// Generic
+
+#define WASM_DEFINE_TYPE(name, Name) \
+  WASM_DEFINE_OWN(name, Name) \
+  WASM_DEFINE_VEC_OWN(name, Name) \
+  \
+  wasm_##name##_t* wasm_##name##_copy(wasm_##name##_t* t) { \
+    return release_##name(t->copy()); \
+  }
+
+
+// Value Types
+
+WASM_DEFINE_TYPE(valtype, ValType)
+
+wasm_valtype_t* wasm_valtype_new(wasm_valkind_t k) {
+  return release_valtype(ValType::make(reveal_valkind(k)));
+}
+
+wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t* t) {
+  return hide_valkind(t->kind());
+}
+
+
+// Function Types
+
+WASM_DEFINE_TYPE(functype, FuncType)
+
+wasm_functype_t* wasm_functype_new(
+  wasm_valtype_vec_t* params, wasm_valtype_vec_t* results
+) {
+  return release_functype(
+    FuncType::make(adopt_valtype_vec(params), adopt_valtype_vec(results)));
+}
+
+const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t* ft) {
+  return hide_valtype_vec(ft->params());
+}
+
+const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t* ft) {
+  return hide_valtype_vec(ft->results());
+}
+
+
+// Global Types
+
+WASM_DEFINE_TYPE(globaltype, GlobalType)
+
+wasm_globaltype_t* wasm_globaltype_new(
+  wasm_valtype_t* content, wasm_mutability_t mutability
+) {
+  return release_globaltype(GlobalType::make(
+    adopt_valtype(content),
+    reveal_mutability(mutability)
+  ));
+}
+
+const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t* gt) {
+  return hide_valtype(gt->content());
+}
+
+wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t* gt) {
+  return hide_mutability(gt->mutability());
+}
+
+
+// Table Types
+
+WASM_DEFINE_TYPE(tabletype, TableType)
+
+wasm_tabletype_t* wasm_tabletype_new(
+  wasm_valtype_t* element, const wasm_limits_t* limits
+) {
+  return release_tabletype(TableType::make(adopt_valtype(element), reveal_limits(*limits)));
+}
+
+const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t* tt) {
+  return hide_valtype(tt->element());
+}
+
+const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t* tt) {
+  return hide_limits(tt->limits());
+}
+
+
+// Memory Types
+
+WASM_DEFINE_TYPE(memorytype, MemoryType)
+
+wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t* limits) {
+  return release_memorytype(MemoryType::make(reveal_limits(*limits)));
+}
+
+const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t* mt) {
+  return hide_limits(mt->limits());
+}
+
+
+// Extern Types
+
+WASM_DEFINE_TYPE(externtype, ExternType)
+
+wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t* et) {
+  return hide_externkind(et->kind());
+}
+
+wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t* ft) {
+  return hide_externtype(static_cast<ExternType*>(ft));
+}
+wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t* gt) {
+  return hide_externtype(static_cast<ExternType*>(gt));
+}
+wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t* tt) {
+  return hide_externtype(static_cast<ExternType*>(tt));
+}
+wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t* mt) {
+  return hide_externtype(static_cast<ExternType*>(mt));
+}
+
+const wasm_externtype_t* wasm_functype_as_externtype_const(
+  const wasm_functype_t* ft
+) {
+  return hide_externtype(static_cast<const ExternType*>(ft));
+}
+const wasm_externtype_t* wasm_globaltype_as_externtype_const(
+  const wasm_globaltype_t* gt
+) {
+  return hide_externtype(static_cast<const ExternType*>(gt));
+}
+const wasm_externtype_t* wasm_tabletype_as_externtype_const(
+  const wasm_tabletype_t* tt
+) {
+  return hide_externtype(static_cast<const ExternType*>(tt));
+}
+const wasm_externtype_t* wasm_memorytype_as_externtype_const(
+  const wasm_memorytype_t* mt
+) {
+  return hide_externtype(static_cast<const ExternType*>(mt));
+}
+
+wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t* et) {
+  return et->kind() == ExternKind::FUNC
+    ? hide_functype(static_cast<FuncType*>(reveal_externtype(et))) : nullptr;
+}
+wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t* et) {
+  return et->kind() == ExternKind::GLOBAL
+    ? hide_globaltype(static_cast<GlobalType*>(reveal_externtype(et))) : nullptr;
+}
+wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t* et) {
+  return et->kind() == ExternKind::TABLE
+    ? hide_tabletype(static_cast<TableType*>(reveal_externtype(et))) : nullptr;
+}
+wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t* et) {
+  return et->kind() == ExternKind::MEMORY
+    ? hide_memorytype(static_cast<MemoryType*>(reveal_externtype(et))) : nullptr;
+}
+
+const wasm_functype_t* wasm_externtype_as_functype_const(
+  const wasm_externtype_t* et
+) {
+  return et->kind() == ExternKind::FUNC
+    ? hide_functype(static_cast<const FuncType*>(reveal_externtype(et))) : nullptr;
+}
+const wasm_globaltype_t* wasm_externtype_as_globaltype_const(
+  const wasm_externtype_t* et
+) {
+  return et->kind() == ExternKind::GLOBAL
+    ? hide_globaltype(static_cast<const GlobalType*>(reveal_externtype(et))) : nullptr;
+}
+const wasm_tabletype_t* wasm_externtype_as_tabletype_const(
+  const wasm_externtype_t* et
+) {
+  return et->kind() == ExternKind::TABLE
+    ? hide_tabletype(static_cast<const TableType*>(reveal_externtype(et))) : nullptr;
+}
+const wasm_memorytype_t* wasm_externtype_as_memorytype_const(
+  const wasm_externtype_t* et
+) {
+  return et->kind() == ExternKind::MEMORY
+    ? hide_memorytype(static_cast<const MemoryType*>(reveal_externtype(et))) : nullptr;
+}
+
+
+// Import Types
+
+WASM_DEFINE_TYPE(importtype, ImportType)
+
+wasm_importtype_t* wasm_importtype_new(
+  wasm_name_t* module, wasm_name_t* name, wasm_externtype_t* type
+) {
+  return release_importtype(
+    ImportType::make(adopt_byte_vec(module), adopt_byte_vec(name), adopt_externtype(type)));
+}
+
+const wasm_name_t* wasm_importtype_module(const wasm_importtype_t* it) {
+  return hide_byte_vec(it->module());
+}
+
+const wasm_name_t* wasm_importtype_name(const wasm_importtype_t* it) {
+  return hide_byte_vec(it->name());
+}
+
+const wasm_externtype_t* wasm_importtype_type(const wasm_importtype_t* it) {
+  return hide_externtype(it->type());
+}
+
+
+// Export Types
+
+WASM_DEFINE_TYPE(exporttype, ExportType)
+
+wasm_exporttype_t* wasm_exporttype_new(
+  wasm_name_t* name, wasm_externtype_t* type
+) {
+  return release_exporttype(
+    ExportType::make(adopt_byte_vec(name), adopt_externtype(type)));
+}
+
+const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t* et) {
+  return hide_byte_vec(et->name());
+}
+
+const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t* et) {
+  return hide_externtype(et->type());
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Values
+
+// References
+
+#define WASM_DEFINE_REF_BASE(name, Name) \
+  WASM_DEFINE_OWN(name, Name) \
+  \
+  wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t* t) { \
+    return release_##name(t->copy()); \
+  } \
+  \
+  bool wasm_##name##_same(const wasm_##name##_t* t1, const wasm_##name##_t* t2) { \
+    return t1->same(t2); \
+  } \
+  \
+  void* wasm_##name##_get_host_info(const wasm_##name##_t* r) { \
+    return r->get_host_info(); \
+  } \
+  void wasm_##name##_set_host_info(wasm_##name##_t* r, void* info) { \
+    r->set_host_info(info); \
+  } \
+  void wasm_##name##_set_host_info_with_finalizer( \
+    wasm_##name##_t* r, void* info, void (*finalizer)(void*) \
+  ) { \
+    r->set_host_info(info, finalizer); \
+  }
+
+#define WASM_DEFINE_REF(name, Name) \
+  WASM_DEFINE_REF_BASE(name, Name) \
+  \
+  wasm_ref_t* wasm_##name##_as_ref(wasm_##name##_t* r) { \
+    return hide_ref(static_cast<Ref*>(reveal_##name(r))); \
+  } \
+  wasm_##name##_t* wasm_ref_as_##name(wasm_ref_t* r) { \
+    return hide_##name(static_cast<Name*>(reveal_ref(r))); \
+  } \
+  \
+  const wasm_ref_t* wasm_##name##_as_ref_const(const wasm_##name##_t* r) { \
+    return hide_ref(static_cast<const Ref*>(reveal_##name(r))); \
+  } \
+  const wasm_##name##_t* wasm_ref_as_##name##_const(const wasm_ref_t* r) { \
+    return hide_##name(static_cast<const Name*>(reveal_ref(r))); \
+  }
+
+#define WASM_DEFINE_SHARABLE_REF(name, Name) \
+  WASM_DEFINE_REF(name, Name) \
+  WASM_DEFINE_OWN(shared_##name, Shared<Name>)
+
+
+WASM_DEFINE_REF_BASE(ref, Ref)
+
+
+// Values
+
+extern "C++" {
+
+inline auto is_empty(wasm_val_t v) -> bool {
+ return !is_ref(reveal_valkind(v.kind)) || !v.of.ref;
+}
+
+inline auto hide_val(Val v) -> wasm_val_t {
+  wasm_val_t v2 = { hide_valkind(v.kind()) };
+  switch (v.kind()) {
+    case ValKind::I32: v2.of.i32 = v.i32(); break;
+    case ValKind::I64: v2.of.i64 = v.i64(); break;
+    case ValKind::F32: v2.of.f32 = v.f32(); break;
+    case ValKind::F64: v2.of.f64 = v.f64(); break;
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: v2.of.ref = hide_ref(v.ref()); break;
+    default: assert(false);
+  }
+  return v2;
+}
+
+inline auto release_val(Val v) -> wasm_val_t {
+  wasm_val_t v2 = { hide_valkind(v.kind()) };
+  switch (v.kind()) {
+    case ValKind::I32: v2.of.i32 = v.i32(); break;
+    case ValKind::I64: v2.of.i64 = v.i64(); break;
+    case ValKind::F32: v2.of.f32 = v.f32(); break;
+    case ValKind::F64: v2.of.f64 = v.f64(); break;
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: v2.of.ref = release_ref(v.release_ref()); break;
+    default: assert(false);
+  }
+  return v2;
+}
+
+inline auto adopt_val(wasm_val_t v) -> Val {
+  switch (reveal_valkind(v.kind)) {
+    case ValKind::I32: return Val(v.of.i32);
+    case ValKind::I64: return Val(v.of.i64);
+    case ValKind::F32: return Val(v.of.f32);
+    case ValKind::F64: return Val(v.of.f64);
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: return Val(adopt_ref(v.of.ref));
+    default: assert(false);
+  }
+}
+
+struct borrowed_val {
+  Val it;
+  borrowed_val(Val&& v) : it(std::move(v)) {}
+  borrowed_val(borrowed_val&& that) : it(std::move(that.it)) {}
+  ~borrowed_val() { if (it.is_ref()) it.release_ref().release(); }
+};
+
+inline auto borrow_val(const wasm_val_t* v) -> borrowed_val {
+  Val v2;
+  switch (reveal_valkind(v->kind)) {
+    case ValKind::I32: v2 = Val(v->of.i32); break;
+    case ValKind::I64: v2 = Val(v->of.i64); break;
+    case ValKind::F32: v2 = Val(v->of.f32); break;
+    case ValKind::F64: v2 = Val(v->of.f64); break;
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: v2 = Val(adopt_ref(v->of.ref)); break;
+    default: assert(false);
+  }
+  return borrowed_val(std::move(v2));
+}
+
+}  // extern "C++"
+
+
+WASM_DEFINE_VEC_BASE(val, Val, vec, vec, )
+
+void wasm_val_vec_new(
+  wasm_val_vec_t* out, size_t size, wasm_val_t const data[]
+) {
+  auto v2 = vec<Val>::make_uninitialized(size);
+  for (size_t i = 0; i < v2.size(); ++i) {
+    v2[i] = adopt_val(data[i]);
+  }
+  *out = release_val_vec(std::move(v2));
+}
+
+void wasm_val_vec_copy(wasm_val_vec_t* out, const wasm_val_vec_t* v) {
+  auto v2 = vec<Val>::make_uninitialized(v->size);
+  for (size_t i = 0; i < v2.size(); ++i) {
+    wasm_val_t val;
+    wasm_val_copy(&v->data[i], &val);
+    v2[i] = adopt_val(val);
+  }
+  *out = release_val_vec(std::move(v2));
+}
+
+
+void wasm_val_delete(wasm_val_t* v) {
+  if (is_ref(reveal_valkind(v->kind))) {
+    adopt_ref(v->of.ref);
+  }
+}
+
+void wasm_val_copy(wasm_val_t* out, const wasm_val_t* v) {
+  *out = *v;
+  if (is_ref(reveal_valkind(v->kind))) {
+    out->of.ref = v->of.ref ? release_ref(v->of.ref->copy()) : nullptr;
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// Frames
+
+WASM_DEFINE_OWN(frame, Frame)
+WASM_DEFINE_VEC_OWN(frame, Frame)
+
+wasm_frame_t* wasm_frame_copy(const wasm_frame_t* frame) {
+  return release_frame(frame->copy());
+}
+
+wasm_instance_t* wasm_frame_instance(const wasm_frame_t* frame);
+// Defined below along with wasm_instance_t.
+
+uint32_t wasm_frame_func_index(const wasm_frame_t* frame) {
+  return reveal_frame(frame)->func_index();
+}
+
+size_t wasm_frame_func_offset(const wasm_frame_t* frame) {
+  return reveal_frame(frame)->func_offset();
+}
+
+size_t wasm_frame_module_offset(const wasm_frame_t* frame) {
+  return reveal_frame(frame)->module_offset();
+}
+
+
+// Traps
+
+WASM_DEFINE_REF(trap, Trap)
+
+wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t* message) {
+  auto message_ = borrow_byte_vec(message);
+  return release_trap(Trap::make(store, message_.it));
+}
+
+void wasm_trap_message(const wasm_trap_t* trap, wasm_message_t* out) {
+  *out = release_byte_vec(reveal_trap(trap)->message());
+}
+
+wasm_frame_t* wasm_trap_origin(const wasm_trap_t* trap) {
+  return release_frame(reveal_trap(trap)->origin());
+}
+
+void wasm_trap_trace(const wasm_trap_t* trap, wasm_frame_vec_t* out) {
+  *out = release_frame_vec(reveal_trap(trap)->trace());
+}
+
+
+// Foreign Objects
+
+WASM_DEFINE_REF(foreign, Foreign)
+
+wasm_foreign_t* wasm_foreign_new(wasm_store_t* store) {
+  return release_foreign(Foreign::make(store));
+}
+
+
+// Modules
+
+WASM_DEFINE_SHARABLE_REF(module, Module)
+
+bool wasm_module_validate(wasm_store_t* store, const wasm_byte_vec_t* binary) {
+  auto binary_ = borrow_byte_vec(binary);
+  return Module::validate(store, binary_.it);
+}
+
+wasm_module_t* wasm_module_new(
+  wasm_store_t* store, const wasm_byte_vec_t* binary
+) {
+  auto binary_ = borrow_byte_vec(binary);
+  return release_module(Module::make(store, binary_.it));
+}
+
+
+void wasm_module_imports(
+  const wasm_module_t* module, wasm_importtype_vec_t* out
+) {
+  *out = release_importtype_vec(reveal_module(module)->imports());
+}
+
+void wasm_module_exports(
+  const wasm_module_t* module, wasm_exporttype_vec_t* out
+) {
+  *out = release_exporttype_vec(reveal_module(module)->exports());
+}
+
+void wasm_module_serialize(const wasm_module_t* module, wasm_byte_vec_t* out) {
+  *out = release_byte_vec(reveal_module(module)->serialize());
+}
+
+wasm_module_t* wasm_module_deserialize(
+  wasm_store_t* store, const wasm_byte_vec_t* binary
+) {
+  auto binary_ = borrow_byte_vec(binary);
+  return release_module(Module::deserialize(store, binary_.it));
+}
+
+wasm_shared_module_t* wasm_module_share(const wasm_module_t* module) {
+  return release_shared_module(reveal_module(module)->share());
+}
+
+wasm_module_t* wasm_module_obtain(wasm_store_t* store, const wasm_shared_module_t* shared) {
+  return release_module(Module::obtain(store, shared));
+}
+
+
+// Function Instances
+
+WASM_DEFINE_REF(func, Func)
+
+extern "C++" {
+
+auto wasm_callback(
+  void* env, const vec<Val>& args, vec<Val>& results
+) -> own<Trap> {
+  auto f = reinterpret_cast<wasm_func_callback_t>(env);
+  return adopt_trap(f(hide_val_vec(args), hide_val_vec(results)));
+}
+
+struct wasm_callback_env_t {
+  wasm_func_callback_with_env_t callback;
+  void* env;
+  void (*finalizer)(void*);
+};
+
+auto wasm_callback_with_env(
+  void* env, const vec<Val>& args, vec<Val>& results
+) -> own<Trap> {
+  auto t = static_cast<wasm_callback_env_t*>(env);
+  return adopt_trap(t->callback(t->env, hide_val_vec(args), hide_val_vec(results)));
+}
+
+void wasm_callback_env_finalizer(void* env) {
+  auto t = static_cast<wasm_callback_env_t*>(env);
+  if (t->finalizer) t->finalizer(t->env);
+  delete t;
+}
+
+}  // extern "C++"
+
+wasm_func_t* wasm_func_new(
+  wasm_store_t* store, const wasm_functype_t* type,
+  wasm_func_callback_t callback
+) {
+  return release_func(Func::make(
+    store, type, wasm_callback, reinterpret_cast<void*>(callback)));
+}
+
+wasm_functype_t* wasm_func_type(const wasm_func_t* func) {
+  return release_functype(func->type());
+}
+
+size_t wasm_func_param_arity(const wasm_func_t* func) {
+  return func->param_arity();
+}
+
+size_t wasm_func_result_arity(const wasm_func_t* func) {
+  return func->result_arity();
+}
+
+wasm_trap_t* wasm_func_call(
+  const wasm_func_t* func, const wasm_val_vec_t* args, wasm_val_vec_t* results
+) {
+  auto args_ = borrow_val_vec(args);
+  auto results_ = borrow_val_vec(results);
+  return release_trap(func->call(args_.it, results_.it));
+}
+
+
+// Global Instances
+
+WASM_DEFINE_REF(global, Global)
+
+wasm_global_t* wasm_global_new(
+  wasm_store_t* store, const wasm_globaltype_t* type, const wasm_val_t* val
+) {
+  auto val_ = borrow_val(val);
+  return release_global(Global::make(store, type, val_.it));
+}
+
+wasm_globaltype_t* wasm_global_type(const wasm_global_t* global) {
+  return release_globaltype(global->type());
+}
+
+void wasm_global_get(const wasm_global_t* global, wasm_val_t* out) {
+  *out = release_val(global->get());
+}
+
+void wasm_global_set(wasm_global_t* global, const wasm_val_t* val) {
+  auto val_ = borrow_val(val);
+  global->set(val_.it);
+}
+
+
+// Table Instances
+
+WASM_DEFINE_REF(table, Table)
+
+wasm_table_t* wasm_table_new(
+  wasm_store_t* store, const wasm_tabletype_t* type, wasm_ref_t* ref
+) {
+  return release_table(Table::make(store, type, ref));
+}
+
+wasm_tabletype_t* wasm_table_type(const wasm_table_t* table) {
+  return release_tabletype(table->type());
+}
+
+wasm_ref_t* wasm_table_get(const wasm_table_t* table, wasm_table_size_t index) {
+  return release_ref(table->get(index));
+}
+
+bool wasm_table_set(
+  wasm_table_t* table, wasm_table_size_t index, wasm_ref_t* ref
+) {
+  return table->set(index, ref);
+}
+
+wasm_table_size_t wasm_table_size(const wasm_table_t* table) {
+  return table->size();
+}
+
+bool wasm_table_grow(
+  wasm_table_t* table, wasm_table_size_t delta, wasm_ref_t* ref
+) {
+  return table->grow(delta, ref);
+}
+
+
+// Memory Instances
+
+WASM_DEFINE_REF(memory, Memory)
+
+wasm_memory_t* wasm_memory_new(
+  wasm_store_t* store, const wasm_memorytype_t* type
+) {
+  return release_memory(Memory::make(store, type));
+}
+
+wasm_memorytype_t* wasm_memory_type(const wasm_memory_t* memory) {
+  return release_memorytype(memory->type());
+}
+
+wasm_byte_t* wasm_memory_data(wasm_memory_t* memory) {
+  return memory->data();
+}
+
+size_t wasm_memory_data_size(const wasm_memory_t* memory) {
+  return memory->data_size();
+}
+
+wasm_memory_pages_t wasm_memory_size(const wasm_memory_t* memory) {
+  return memory->size();
+}
+
+bool wasm_memory_grow(wasm_memory_t* memory, wasm_memory_pages_t delta) {
+  return memory->grow(delta);
+}
+
+
+// Externals
+
+WASM_DEFINE_REF(extern, Extern)
+WASM_DEFINE_VEC_OWN(extern, Extern)
+
+wasm_externkind_t wasm_extern_kind(const wasm_extern_t* external) {
+  return hide_externkind(external->kind());
+}
+wasm_externtype_t* wasm_extern_type(const wasm_extern_t* external) {
+  return release_externtype(external->type());
+}
+
+wasm_extern_t* wasm_func_as_extern(wasm_func_t* func) {
+  return hide_extern(static_cast<Extern*>(reveal_func(func)));
+}
+wasm_extern_t* wasm_global_as_extern(wasm_global_t* global) {
+  return hide_extern(static_cast<Extern*>(reveal_global(global)));
+}
+wasm_extern_t* wasm_table_as_extern(wasm_table_t* table) {
+  return hide_extern(static_cast<Extern*>(reveal_table(table)));
+}
+wasm_extern_t* wasm_memory_as_extern(wasm_memory_t* memory) {
+  return hide_extern(static_cast<Extern*>(reveal_memory(memory)));
+}
+
+const wasm_extern_t* wasm_func_as_extern_const(const wasm_func_t* func) {
+  return hide_extern(static_cast<const Extern*>(reveal_func(func)));
+}
+const wasm_extern_t* wasm_global_as_extern_const(const wasm_global_t* global) {
+  return hide_extern(static_cast<const Extern*>(reveal_global(global)));
+}
+const wasm_extern_t* wasm_table_as_extern_const(const wasm_table_t* table) {
+  return hide_extern(static_cast<const Extern*>(reveal_table(table)));
+}
+const wasm_extern_t* wasm_memory_as_extern_const(const wasm_memory_t* memory) {
+  return hide_extern(static_cast<const Extern*>(reveal_memory(memory)));
+}
+
+wasm_func_t* wasm_extern_as_func(wasm_extern_t* external) {
+  return hide_func(external->func());
+}
+wasm_global_t* wasm_extern_as_global(wasm_extern_t* external) {
+  return hide_global(external->global());
+}
+wasm_table_t* wasm_extern_as_table(wasm_extern_t* external) {
+  return hide_table(external->table());
+}
+wasm_memory_t* wasm_extern_as_memory(wasm_extern_t* external) {
+  return hide_memory(external->memory());
+}
+
+const wasm_func_t* wasm_extern_as_func_const(const wasm_extern_t* external) {
+  return hide_func(external->func());
+}
+const wasm_global_t* wasm_extern_as_global_const(const wasm_extern_t* external) {
+  return hide_global(external->global());
+}
+const wasm_table_t* wasm_extern_as_table_const(const wasm_extern_t* external) {
+  return hide_table(external->table());
+}
+const wasm_memory_t* wasm_extern_as_memory_const(const wasm_extern_t* external) {
+  return hide_memory(external->memory());
+}
+
+
+// Module Instances
+
+WASM_DEFINE_REF(instance, Instance)
+
+wasm_instance_t* wasm_instance_new(
+  wasm_store_t* store,
+  const wasm_module_t* module,
+  const wasm_extern_vec_t* imports,
+  wasm_trap_t** trap
+) {
+  own<Trap> error;
+  auto imports_ = reveal_extern_vec(imports);
+  auto instance =
+    release_instance(Instance::make(store, module, *imports_, &error));
+  if (trap) *trap = hide_trap(error.release());
+  return instance;
+}
+
+void wasm_instance_exports(
+  const wasm_instance_t* instance, wasm_extern_vec_t* out
+) {
+  *out = release_extern_vec(instance->exports());
+}
+
+
+wasm_instance_t* wasm_frame_instance(const wasm_frame_t* frame) {
+  return hide_instance(reveal_frame(frame)->instance());
+}
+
+}  // extern "C"
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.cc
new file mode 100644
index 0000000..d00f48e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.cc
@@ -0,0 +1,443 @@
+#include "wasm-v8-lowlevel.hh"
+
+// TODO(v8): if we don't include these, api.h does not compile
+#include "objects/objects.h"
+#include "objects/bigint.h"
+#include "objects/managed.h"
+#include "objects/module.h"
+#include "objects/shared-function-info.h"
+#include "objects/templates.h"
+#include "objects/fixed-array.h"
+#include "objects/ordered-hash-table.h"
+#include "objects/js-promise.h"
+#include "objects/js-collection.h"
+
+#include "api/api.h"
+#include "api/api-inl.h"
+#include "wasm/wasm-objects.h"
+#include "wasm/wasm-objects-inl.h"
+#include "wasm/wasm-serialization.h"
+
+
+namespace v8 {
+namespace wasm {
+
+
+// Objects
+
+auto object_isolate(v8::Local<v8::Object> obj) -> v8::Isolate* {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return reinterpret_cast<v8::Isolate*>(v8_obj->GetIsolate());
+}
+
+auto object_isolate(const v8::Persistent<v8::Object>& obj) -> v8::Isolate* {
+  struct FakePersistent { v8::Object* val; };
+  auto v8_obj = reinterpret_cast<const FakePersistent*>(&obj)->val;
+  return v8_obj->GetIsolate();
+}
+
+template<class T>
+auto object_handle(T v8_obj) -> v8::internal::Handle<T> {
+  return handle(v8_obj, v8_obj.GetIsolate());
+}
+
+
+auto object_is_module(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsWasmModuleObject();
+}
+
+auto object_is_instance(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsWasmInstanceObject();
+}
+
+auto object_is_func(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8::internal::WasmExportedFunction::IsWasmExportedFunction(*v8_obj);
+}
+
+auto object_is_global(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsWasmGlobalObject();
+}
+
+auto object_is_table(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsWasmTableObject();
+}
+
+auto object_is_memory(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsWasmMemoryObject();
+}
+
+auto object_is_error(v8::Local<v8::Object> obj) -> bool {
+  auto v8_obj = v8::Utils::OpenHandle(*obj);
+  return v8_obj->IsJSError();
+}
+
+
+
+// Foreign pointers
+
+auto foreign_new(v8::Isolate* isolate, void* ptr) -> v8::Local<v8::Value> {
+  auto foreign = v8::FromCData(
+    reinterpret_cast<v8::internal::Isolate*>(isolate),
+    reinterpret_cast<v8::internal::Address>(ptr)
+  );
+  return v8::Utils::ToLocal(foreign);
+}
+
+auto foreign_get(v8::Local<v8::Value> val) -> void* {
+  auto foreign = v8::Utils::OpenHandle(*val);
+  if (!foreign->IsForeign()) return nullptr;
+  auto addr = v8::ToCData<v8::internal::Address>(*foreign);
+  return reinterpret_cast<void*>(addr);
+}
+
+
+struct ManagedData {
+  ManagedData(void* info, void (*finalizer)(void*)) :
+    info(info), finalizer(finalizer) {}
+
+  ~ManagedData() {
+    if (finalizer) (*finalizer)(info);
+  }
+
+  void* info;
+  void (*finalizer)(void*);
+};
+
+auto managed_new(v8::Isolate* isolate, void* ptr, void (*finalizer)(void*)) -> v8::Local<v8::Value> {
+  assert(ptr);
+  auto managed = v8::internal::Managed<ManagedData>::FromUniquePtr(
+    reinterpret_cast<v8::internal::Isolate*>(isolate), sizeof(ManagedData),
+    std::unique_ptr<ManagedData>(new ManagedData(ptr, finalizer))
+  );
+  return v8::Utils::ToLocal(managed);
+}
+
+auto managed_get(v8::Local<v8::Value> val) -> void* {
+  auto v8_val = v8::Utils::OpenHandle(*val);
+  if (!v8_val->IsForeign()) return nullptr;
+  auto managed =
+    v8::internal::Handle<v8::internal::Managed<ManagedData>>::cast(v8_val);
+  return managed->raw()->info;
+}
+
+
+// Types
+
+auto v8_valtype_to_wasm(v8::internal::wasm::ValueType v8_valtype) -> val_kind_t {
+  switch (v8_valtype) {
+    case v8::internal::wasm::kWasmI32: return I32;
+    case v8::internal::wasm::kWasmI64: return I64;
+    case v8::internal::wasm::kWasmF32: return F32;
+    case v8::internal::wasm::kWasmF64: return F64;
+    case v8::internal::wasm::kWasmAnyRef: return ANYREF;
+    case v8::internal::wasm::kWasmAnyFunc: return FUNCREF;
+    default:
+      UNREACHABLE();
+  }
+}
+
+auto func_type_param_arity(v8::Local<v8::Object> function) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(function);
+  auto v8_function = v8::internal::Handle<v8::internal::WasmExportedFunction>::cast(v8_object);
+  v8::internal::wasm::FunctionSig* sig =
+    v8_function->instance().module()->functions[v8_function->function_index()].sig;
+  return static_cast<uint32_t>(sig->parameter_count());
+}
+
+auto func_type_result_arity(v8::Local<v8::Object> function) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(function);
+  auto v8_function = v8::internal::Handle<v8::internal::WasmExportedFunction>::cast(v8_object);
+  v8::internal::wasm::FunctionSig* sig =
+    v8_function->instance().module()->functions[v8_function->function_index()].sig;
+  return static_cast<uint32_t>(sig->return_count());
+}
+
+auto func_type_param(v8::Local<v8::Object> function, size_t i) -> val_kind_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(function);
+  auto v8_function = v8::internal::Handle<v8::internal::WasmExportedFunction>::cast(v8_object);
+  v8::internal::wasm::FunctionSig* sig =
+    v8_function->instance().module()->functions[v8_function->function_index()].sig;
+  return v8_valtype_to_wasm(sig->GetParam(i));
+}
+
+auto func_type_result(v8::Local<v8::Object> function, size_t i) -> val_kind_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(function);
+  auto v8_function = v8::internal::Handle<v8::internal::WasmExportedFunction>::cast(v8_object);
+  v8::internal::wasm::FunctionSig* sig =
+    v8_function->instance().module()->functions[v8_function->function_index()].sig;
+  return v8_valtype_to_wasm(sig->GetReturn(i));
+}
+
+auto global_type_content(v8::Local<v8::Object> global) -> val_kind_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_valtype_to_wasm(v8_global->type());
+}
+
+auto global_type_mutable(v8::Local<v8::Object> global) -> bool {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_global->is_mutable();
+}
+
+auto table_type_min(v8::Local<v8::Object> table) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  return v8_table->current_length();
+}
+
+auto table_type_max(v8::Local<v8::Object> table) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  auto v8_max_obj = v8_table->maximum_length();
+  uint32_t max;
+  return v8_max_obj.ToUint32(&max) ? max : 0xffffffffu;
+}
+
+auto memory_type_min(v8::Local<v8::Object> memory) -> uint32_t {
+  return memory_size(memory);
+}
+
+auto memory_type_max(v8::Local<v8::Object> memory) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(memory);
+  auto v8_memory = v8::internal::Handle<v8::internal::WasmMemoryObject>::cast(v8_object);
+  return v8_memory->has_maximum_pages() ? v8_memory->maximum_pages() : 0xffffffffu;
+}
+
+
+// Modules
+
+auto module_binary_size(v8::Local<v8::Object> module) -> size_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(module);
+  auto v8_module = v8::internal::Handle<v8::internal::WasmModuleObject>::cast(v8_object);
+  return v8_module->native_module()->wire_bytes().size();
+}
+
+auto module_binary(v8::Local<v8::Object> module) -> const char* {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(module);
+  auto v8_module = v8::internal::Handle<v8::internal::WasmModuleObject>::cast(v8_object);
+  return reinterpret_cast<const char*>(v8_module->native_module()->wire_bytes().begin());
+}
+
+auto module_serialize_size(v8::Local<v8::Object> module) -> size_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(module);
+  auto v8_module = v8::internal::Handle<v8::internal::WasmModuleObject>::cast(v8_object);
+  v8::internal::wasm::WasmSerializer serializer(v8_module->native_module());
+  return serializer.GetSerializedNativeModuleSize();
+}
+
+auto module_serialize(v8::Local<v8::Object> module, char* buffer, size_t size) -> bool {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(module);
+  auto v8_module = v8::internal::Handle<v8::internal::WasmModuleObject>::cast(v8_object);
+  v8::internal::wasm::WasmSerializer serializer(v8_module->native_module());
+  return serializer.SerializeNativeModule({reinterpret_cast<uint8_t*>(buffer), size});
+}
+
+auto module_deserialize(
+  v8::Isolate* isolate,
+  const char* binary, size_t binary_size,
+  const char* buffer, size_t buffer_size
+) -> v8::MaybeLocal<v8::Object> {
+  auto v8_isolate = reinterpret_cast<v8::internal::Isolate*>(isolate);
+  auto maybe_v8_module =
+    v8::internal::wasm::DeserializeNativeModule(v8_isolate,
+      {reinterpret_cast<const uint8_t*>(buffer), buffer_size},
+      {reinterpret_cast<const uint8_t*>(binary), binary_size});
+  if (maybe_v8_module.is_null()) return v8::MaybeLocal<v8::Object>();
+  auto v8_module = v8::internal::Handle<v8::internal::JSObject>::cast(maybe_v8_module.ToHandleChecked());
+  return v8::MaybeLocal<v8::Object>(v8::Utils::ToLocal(v8_module));
+}
+
+
+// Instances
+
+auto instance_module(v8::Local<v8::Object> instance) -> v8::Local<v8::Object> {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(instance);
+  auto v8_instance = v8::internal::Handle<v8::internal::WasmInstanceObject>::cast(v8_object);
+  auto v8_module = object_handle(v8::internal::JSObject::cast(v8_instance->module_object()));
+  return v8::Utils::ToLocal(v8_module);
+}
+
+auto instance_exports(v8::Local<v8::Object> instance) -> v8::Local<v8::Object> {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(instance);
+  auto v8_instance = v8::internal::Handle<v8::internal::WasmInstanceObject>::cast(v8_object);
+  auto v8_exports = object_handle(v8_instance->exports_object());
+  return v8::Utils::ToLocal(v8_exports);
+}
+
+
+// Externals
+
+auto extern_kind(v8::Local<v8::Object> external) -> extern_kind_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(external);
+
+  if (v8::internal::WasmExportedFunction::IsWasmExportedFunction(*v8_object)) return EXTERN_FUNC;
+  if (v8_object->IsWasmGlobalObject()) return EXTERN_GLOBAL;
+  if (v8_object->IsWasmTableObject()) return EXTERN_TABLE;
+  if (v8_object->IsWasmMemoryObject()) return EXTERN_MEMORY;
+  UNREACHABLE();
+}
+
+
+// Functions
+
+auto func_instance(v8::Local<v8::Function> function) -> v8::Local<v8::Object> {
+  auto v8_function = v8::Utils::OpenHandle(*function);
+  auto v8_func = v8::internal::Handle<v8::internal::WasmExportedFunction>::cast(v8_function);
+  auto v8_instance = object_handle(v8::internal::JSObject::cast(v8_func->instance()));
+  return v8::Utils::ToLocal(v8_instance);
+}
+
+
+// Globals
+
+auto global_get_i32(v8::Local<v8::Object> global) -> int32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_global->GetI32();
+}
+auto global_get_i64(v8::Local<v8::Object> global) -> int64_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_global->GetI64();
+}
+auto global_get_f32(v8::Local<v8::Object> global) -> float {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_global->GetF32();
+}
+auto global_get_f64(v8::Local<v8::Object> global) -> double {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8_global->GetF64();
+}
+auto global_get_ref(v8::Local<v8::Object> global) -> v8::Local<v8::Value> {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  return v8::Utils::ToLocal(v8_global->GetRef());
+}
+
+void global_set_i32(v8::Local<v8::Object> global, int32_t val) {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  v8_global->SetI32(val);
+}
+void global_set_i64(v8::Local<v8::Object> global, int64_t val) {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  v8_global->SetI64(val);
+}
+void global_set_f32(v8::Local<v8::Object> global, float val) {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  v8_global->SetF32(val);
+}
+void global_set_f64(v8::Local<v8::Object> global, double val) {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  v8_global->SetF64(val);
+}
+void global_set_ref(v8::Local<v8::Object> global, v8::Local<v8::Value> val) {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(global);
+  auto v8_global = v8::internal::Handle<v8::internal::WasmGlobalObject>::cast(v8_object);
+  v8_global->SetAnyRef(v8::Utils::OpenHandle<v8::Value, v8::internal::Object>(val));
+}
+
+
+// Tables
+
+auto table_get(v8::Local<v8::Object> table, size_t index) -> v8::MaybeLocal<v8::Value> {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  // TODO(v8): This should happen in WasmTableObject::Get.
+  if (index > v8_table->current_length()) return v8::MaybeLocal<v8::Value>();
+
+  v8::internal::Handle<v8::internal::Object> v8_value =
+    v8::internal::WasmTableObject::Get(
+      v8_table->GetIsolate(), v8_table, static_cast<uint32_t>(index));
+  return v8::Utils::ToLocal(v8::internal::Handle<v8::internal::Object>::cast(v8_value));
+}
+
+auto table_set(
+  v8::Local<v8::Object> table, size_t index, v8::Local<v8::Value> value
+) -> bool {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  auto v8_value = v8::Utils::OpenHandle<v8::Value, v8::internal::Object>(value);
+  // TODO(v8): This should happen in WasmTableObject::Set.
+  if (index >= v8_table->current_length()) return false;
+
+  { v8::TryCatch handler(table->GetIsolate());
+    v8::internal::WasmTableObject::Set(v8_table->GetIsolate(), v8_table,
+      static_cast<uint32_t>(index), v8_value);
+    if (handler.HasCaught()) return false;
+  }
+
+  return true;
+}
+
+auto table_size(v8::Local<v8::Object> table) -> size_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  return v8_table->current_length();
+}
+
+auto table_grow(
+  v8::Local<v8::Object> table, size_t delta, v8::Local<v8::Value> init
+) -> bool {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(table);
+  auto v8_table = v8::internal::Handle<v8::internal::WasmTableObject>::cast(v8_object);
+  if (delta > 0xfffffffflu) return false;
+  auto old_size = v8_table->current_length();
+  auto new_size = old_size + static_cast<uint32_t>(delta);
+  // TODO(v8): This should happen in WasmTableObject::Grow.
+  if (new_size > table_type_max(table)) return false;
+
+  { v8::TryCatch handler(table->GetIsolate());
+    v8::internal::WasmTableObject::Grow(
+      v8_table->GetIsolate(), v8_table, static_cast<uint32_t>(delta),
+      v8::Utils::OpenHandle<v8::Value, v8::internal::Object>(init));
+    if (handler.HasCaught()) return false;
+  }
+
+  return true;
+}
+
+
+// Memory
+
+auto memory_data(v8::Local<v8::Object> memory) -> char* {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(memory);
+  auto v8_memory = v8::internal::Handle<v8::internal::WasmMemoryObject>::cast(v8_object);
+  return reinterpret_cast<char*>(v8_memory->array_buffer().backing_store());
+}
+
+auto memory_data_size(v8::Local<v8::Object> memory)-> size_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(memory);
+  auto v8_memory = v8::internal::Handle<v8::internal::WasmMemoryObject>::cast(v8_object);
+  return v8_memory->array_buffer().byte_length();
+}
+
+auto memory_size(v8::Local<v8::Object> memory) -> uint32_t {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(memory);
+  auto v8_memory = v8::internal::Handle<v8::internal::WasmMemoryObject>::cast(v8_object);
+  return static_cast<uint32_t>(
+    v8_memory->array_buffer().byte_length() / v8::internal::wasm::kWasmPageSize);
+}
+
+auto memory_grow(v8::Local<v8::Object> memory, uint32_t delta) -> bool {
+  auto v8_object = v8::Utils::OpenHandle<v8::Object, v8::internal::JSReceiver>(memory);
+  auto v8_memory = v8::internal::Handle<v8::internal::WasmMemoryObject>::cast(v8_object);
+  auto old = v8::internal::WasmMemoryObject::Grow(
+    v8_memory->GetIsolate(), v8_memory, delta);
+  return old != -1;
+}
+
+}  // namespace wasm
+}  // namespace v8
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.hh b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.hh
new file mode 100644
index 0000000..5b2969f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8-lowlevel.hh
@@ -0,0 +1,79 @@
+#ifndef __WASM_V8_LOWLEVEL_HH
+#define __WASM_V8_LOWLEVEL_HH
+
+#include "v8.h"
+
+namespace v8 {
+namespace wasm {
+
+auto object_isolate(v8::Local<v8::Object>) -> v8::Isolate*;
+auto object_isolate(const v8::Persistent<v8::Object>&) -> v8::Isolate*;
+
+auto object_is_module(v8::Local<v8::Object>) -> bool;
+auto object_is_instance(v8::Local<v8::Object>) -> bool;
+auto object_is_func(v8::Local<v8::Object>) -> bool;
+auto object_is_global(v8::Local<v8::Object>) -> bool;
+auto object_is_table(v8::Local<v8::Object>) -> bool;
+auto object_is_memory(v8::Local<v8::Object>) -> bool;
+auto object_is_error(v8::Local<v8::Object>) -> bool;
+
+auto foreign_new(v8::Isolate*, void*) -> v8::Local<v8::Value>;
+auto foreign_get(v8::Local<v8::Value>) -> void*;
+
+auto managed_new(v8::Isolate*, void*, void (*)(void*)) -> v8::Local<v8::Value>;
+auto managed_get(v8::Local<v8::Value>) -> void*;
+
+enum val_kind_t { I32, I64, F32, F64, ANYREF = 128, FUNCREF };
+auto func_type_param_arity(v8::Local<v8::Object> global) -> uint32_t;
+auto func_type_result_arity(v8::Local<v8::Object> global) -> uint32_t;
+auto func_type_param(v8::Local<v8::Object> global, size_t) -> val_kind_t;
+auto func_type_result(v8::Local<v8::Object> global, size_t) -> val_kind_t;
+
+auto global_type_content(v8::Local<v8::Object> global) -> val_kind_t;
+auto global_type_mutable(v8::Local<v8::Object> global) -> bool;
+
+auto table_type_min(v8::Local<v8::Object> table) -> uint32_t;
+auto table_type_max(v8::Local<v8::Object> table) -> uint32_t;
+
+auto memory_type_min(v8::Local<v8::Object> memory) -> uint32_t;
+auto memory_type_max(v8::Local<v8::Object> memory) -> uint32_t;
+
+auto module_binary_size(v8::Local<v8::Object> module) -> size_t;
+auto module_binary(v8::Local<v8::Object> module) -> const char*;
+auto module_serialize_size(v8::Local<v8::Object> module) -> size_t;
+auto module_serialize(v8::Local<v8::Object> module, char*, size_t) -> bool;
+auto module_deserialize(v8::Isolate*, const char*, size_t, const char*, size_t) -> v8::MaybeLocal<v8::Object>;
+
+auto instance_module(v8::Local<v8::Object> instance) -> v8::Local<v8::Object>;
+auto instance_exports(v8::Local<v8::Object> instance) -> v8::Local<v8::Object>;
+
+enum extern_kind_t { EXTERN_FUNC, EXTERN_GLOBAL, EXTERN_TABLE, EXTERN_MEMORY };
+auto extern_kind(v8::Local<v8::Object> external) -> extern_kind_t;
+
+auto func_instance(v8::Local<v8::Function>) -> v8::Local<v8::Object>;
+
+auto global_get_i32(v8::Local<v8::Object> global) -> int32_t;
+auto global_get_i64(v8::Local<v8::Object> global) -> int64_t;
+auto global_get_f32(v8::Local<v8::Object> global) -> float;
+auto global_get_f64(v8::Local<v8::Object> global) -> double;
+auto global_get_ref(v8::Local<v8::Object> global) -> v8::Local<v8::Value>;
+void global_set_i32(v8::Local<v8::Object> global, int32_t);
+void global_set_i64(v8::Local<v8::Object> global, int64_t);
+void global_set_f32(v8::Local<v8::Object> global, float);
+void global_set_f64(v8::Local<v8::Object> global, double);
+void global_set_ref(v8::Local<v8::Object> global, v8::Local<v8::Value>);
+
+auto table_get(v8::Local<v8::Object> table, size_t index) -> v8::MaybeLocal<v8::Value>;
+auto table_set(v8::Local<v8::Object> table, size_t index, v8::Local<v8::Value>) -> bool;
+auto table_size(v8::Local<v8::Object> table) -> size_t;
+auto table_grow(v8::Local<v8::Object> table, size_t delta, v8::Local<v8::Value>) -> bool;
+
+auto memory_data(v8::Local<v8::Object> memory) -> char*;
+auto memory_data_size(v8::Local<v8::Object> memory)-> size_t;
+auto memory_size(v8::Local<v8::Object> memory) -> uint32_t;
+auto memory_grow(v8::Local<v8::Object> memory, uint32_t delta) -> bool;
+
+}  // namespace wasm
+}  // namespace v8
+
+#endif  // #define __WASM_V8_LOWLEVEL_HH
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8.cc b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8.cc
new file mode 100644
index 0000000..b58aaf4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm-c-api/src/wasm-v8.cc
@@ -0,0 +1,2137 @@
+#include "wasm.hh"
+#include "wasm-bin.hh"
+#include "wasm-v8-lowlevel.hh"
+
+#include "v8.h"
+#include "libplatform/libplatform.h"
+
+#include <iostream>
+
+#ifdef WASM_API_DEBUG
+#include <atomic>
+#endif
+
+
+namespace wasm_v8 {
+  using namespace v8::wasm;
+}
+
+namespace v8 {
+  namespace internal {
+    extern bool FLAG_expose_gc;
+    extern bool FLAG_experimental_wasm_bigint;
+    extern bool FLAG_experimental_wasm_mv;
+    extern bool FLAG_experimental_wasm_anyref;
+    extern bool FLAG_experimental_wasm_bulk_memory;
+    extern bool FLAG_experimental_wasm_return_call;
+  }
+}
+
+namespace wasm {
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+[[noreturn]] void UNIMPLEMENTED(const char* s) {
+  std::cerr << "Wasm API: " << s << " not supported yet!\n";
+  exit(1);
+}
+
+template<class T>
+void ignore(T) {}
+
+
+template<class C> struct implement;
+
+template<class C>
+auto impl(C* x) -> typename implement <C>::type* {
+  return reinterpret_cast<typename implement<C>::type*>(x);
+}
+
+template<class C>
+auto impl(const C* x) -> const typename implement<C>::type* {
+  return reinterpret_cast<const typename implement<C>::type*>(x);
+}
+
+template<class C>
+auto seal(typename implement <C>::type* x) -> C* {
+  return reinterpret_cast<C*>(x);
+}
+
+template<class C>
+auto seal(const typename implement <C>::type* x) -> const C* {
+  return reinterpret_cast<const C*>(x);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Debug aids
+
+struct Stats {
+  enum category_t {
+    BYTE, CONFIG, ENGINE, STORE, FRAME,
+    VALTYPE, FUNCTYPE, GLOBALTYPE, TABLETYPE, MEMORYTYPE,
+    EXTERNTYPE, IMPORTTYPE, EXPORTTYPE,
+    VAL, REF, TRAP,
+    MODULE, INSTANCE, FUNC, GLOBAL, TABLE, MEMORY, EXTERN,
+    STRONG_COUNT,
+    FUNCDATA_FUNCTYPE, FUNCDATA_VALTYPE,
+    CATEGORY_COUNT
+  };
+  enum cardinality_t {
+    OWN, VEC, SHARED, CARDINALITY_COUNT
+  };
+
+#ifdef WASM_API_DEBUG
+  static const char* name[STRONG_COUNT];
+  static const char* left[CARDINALITY_COUNT];
+  static const char* right[CARDINALITY_COUNT];
+
+  std::atomic<size_t> made[CATEGORY_COUNT][CARDINALITY_COUNT];
+  std::atomic<size_t> freed[CATEGORY_COUNT][CARDINALITY_COUNT];
+
+  Stats() {
+    for (int i = 0; i < CATEGORY_COUNT; ++i) {
+      for (int j = 0; j < CARDINALITY_COUNT; ++j) {
+        made[i][j] = freed[i][j] = 0;
+      }
+    }
+  }
+
+  ~Stats() {
+    // Hack for func data weakly owned by V8 heap.
+    freed[FUNCTYPE][OWN] +=
+      made[FUNCDATA_FUNCTYPE][OWN] - freed[FUNCDATA_FUNCTYPE][OWN];
+    freed[VALTYPE][OWN] +=
+      made[FUNCDATA_VALTYPE][OWN] - freed[FUNCDATA_VALTYPE][OWN];
+    freed[VALTYPE][VEC] +=
+      made[FUNCDATA_VALTYPE][VEC] - freed[FUNCDATA_VALTYPE][VEC];
+    // Hack for shared modules.
+    freed[BYTE][VEC] += made[MODULE][SHARED] - freed[MODULE][SHARED];
+
+    bool leak = false;
+    for (int i = 0; i < STRONG_COUNT; ++i) {
+      for (int j = 0; j < CARDINALITY_COUNT; ++j) {
+        assert(made[i][j] >= freed[i][j]);
+        auto live = made[i][j] - freed[i][j];
+        if (live) {
+          std::cerr << "Leaked " << live << " instances of wasm::"
+            << left[j] << name[i] << right[j]
+            << ", made " << made[i][j] << ", freed " << freed[i][j] << "!"
+            << std::endl;
+          leak = true;
+        }
+      }
+    }
+    if (leak) exit(1);
+  }
+#endif
+
+  void make(category_t i, void* ptr, cardinality_t j = OWN, size_t n = 1) {
+#ifdef WASM_API_DEBUG
+#ifdef WASM_API_DEBUG_LOG
+    if (ptr) {
+      std::clog << "[make] " << ptr
+        << " wasm::" << left[j] << name[i] << right[j] << std::endl;
+    }
+#endif
+    made[i][j] += n;
+#endif
+  }
+
+  void free(category_t i, void* ptr, cardinality_t j = OWN, size_t n = 1) {
+#ifdef WASM_API_DEBUG
+#ifdef WASM_API_DEBUG_LOG
+    if (ptr) {
+      std::clog << "[free] " << ptr
+        << " wasm::" << left[j] << name[i] << right[j] << std::endl;
+    }
+#endif
+    freed[i][j] += n;
+    if (freed[i][j] > made[i][j]) {
+      std::cerr << "Deleting instance of wasm::"
+        << left[j] << name[i] << right[j] << " when none is alive"
+        << ", made " << made[i][j] << ", freed " << freed[i][j] << "!"
+        << std::endl;
+      exit(1);
+    }
+#endif
+  }
+
+  static category_t categorize(const v8::Persistent<v8::Object>& pobj) {
+#ifdef WASM_API_DEBUG
+    auto isolate = wasm_v8::object_isolate(pobj);
+    v8::HandleScope handle_scope(isolate);
+    auto obj = pobj.Get(isolate);
+    if (wasm_v8::object_is_func(obj)) return FUNC;
+    if (wasm_v8::object_is_global(obj)) return GLOBAL;
+    if (wasm_v8::object_is_table(obj)) return TABLE;
+    if (wasm_v8::object_is_memory(obj)) return MEMORY;
+    if (wasm_v8::object_is_module(obj)) return MODULE;
+    if (wasm_v8::object_is_instance(obj)) return INSTANCE;
+    if (wasm_v8::object_is_error(obj)) return TRAP;
+#endif
+    return REF;
+  }
+};
+
+#ifdef WASM_API_DEBUG
+const char* Stats::name[STRONG_COUNT] = {
+  "byte_t", "Config", "Engine", "Store", "Frame",
+  "ValType", "FuncType", "GlobalType", "TableType", "MemoryType",
+  "ExternType", "ImportType", "ExportType",
+  "Val", "Ref", "Trap",
+  "Module", "Instance", "Func", "Global", "Table", "Memory", "Extern"
+};
+
+const char* Stats::left[CARDINALITY_COUNT] = {
+  "", "vec<", "Shared<"
+};
+
+const char* Stats::right[CARDINALITY_COUNT] = {
+  "", ">", ">"
+};
+#endif
+
+
+Stats stats;
+
+
+// Vectors
+
+#ifdef WASM_API_DEBUG
+
+#define DEFINE_VEC(type, vec, STAT) \
+  template<> void vec<type>::make_data() { \
+    if (data_) stats.make(Stats::STAT, data_.get(), Stats::VEC); \
+  } \
+  \
+  template<> void vec<type>::free_data() { \
+    if (data_) stats.free(Stats::STAT, data_.get(), Stats::VEC); \
+  }
+
+DEFINE_VEC(byte_t, vec, BYTE)
+DEFINE_VEC(Frame, ownvec, FRAME)
+DEFINE_VEC(ValType, ownvec, VALTYPE)
+DEFINE_VEC(FuncType, ownvec, FUNCTYPE)
+DEFINE_VEC(GlobalType, ownvec, GLOBALTYPE)
+DEFINE_VEC(TableType, ownvec, TABLETYPE)
+DEFINE_VEC(MemoryType, ownvec, MEMORYTYPE)
+DEFINE_VEC(ExternType, ownvec, EXTERNTYPE)
+DEFINE_VEC(ImportType, ownvec, IMPORTTYPE)
+DEFINE_VEC(ExportType, ownvec, EXPORTTYPE)
+DEFINE_VEC(Ref, ownvec, REF)
+DEFINE_VEC(Trap, ownvec, TRAP)
+DEFINE_VEC(Module, ownvec, MODULE)
+DEFINE_VEC(Instance, ownvec, INSTANCE)
+DEFINE_VEC(Func, ownvec, FUNC)
+DEFINE_VEC(Global, ownvec, GLOBAL)
+DEFINE_VEC(Table, ownvec, TABLE)
+DEFINE_VEC(Memory, ownvec, MEMORY)
+DEFINE_VEC(Extern, ownvec, EXTERN)
+DEFINE_VEC(Extern*, vec, EXTERN)
+DEFINE_VEC(Val, vec, VAL)
+
+#endif  // #ifdef WASM_API_DEBUG
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+struct ConfigImpl {
+  ConfigImpl() { stats.make(Stats::CONFIG, this); }
+  ~ConfigImpl() { stats.free(Stats::CONFIG, this); }
+};
+
+template<> struct implement<Config> { using type = ConfigImpl; };
+
+
+Config::~Config() {
+  impl(this)->~ConfigImpl();
+}
+
+void Config::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto Config::make() -> own<Config> {
+  return own<Config>(seal<Config>(new(std::nothrow) ConfigImpl()));
+}
+
+
+// Engine
+
+struct EngineImpl {
+  static bool created;
+
+  std::unique_ptr<v8::Platform> platform;
+
+  EngineImpl() {
+    assert(!created);
+    created = true;
+    stats.make(Stats::ENGINE, this);
+  }
+
+  ~EngineImpl() {
+    v8::V8::Dispose();
+    v8::V8::ShutdownPlatform();
+    stats.free(Stats::ENGINE, this);
+  }
+};
+
+bool EngineImpl::created = false;
+
+template<> struct implement<Engine> { using type = EngineImpl; };
+
+
+Engine::~Engine() {
+  impl(this)->~EngineImpl();
+}
+
+void Engine::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto Engine::make(own<Config>&& config) -> own<Engine> {
+  v8::internal::FLAG_expose_gc = true;
+  v8::internal::FLAG_experimental_wasm_bigint = true;
+  v8::internal::FLAG_experimental_wasm_mv = true;
+  v8::internal::FLAG_experimental_wasm_anyref = true;
+  v8::internal::FLAG_experimental_wasm_bulk_memory = true;
+  v8::internal::FLAG_experimental_wasm_return_call = true;
+  // v8::V8::SetFlagsFromCommandLine(&argc, const_cast<char**>(argv), false);
+  auto engine = new(std::nothrow) EngineImpl;
+  if (!engine) return own<Engine>();
+  // v8::V8::InitializeICUDefaultLocation(argv[0]);
+  // v8::V8::InitializeExternalStartupData(argv[0]);
+  engine->platform = v8::platform::NewDefaultPlatform();
+  v8::V8::InitializePlatform(engine->platform.get());
+  v8::V8::Initialize();
+  return make_own(seal<Engine>(engine));
+}
+
+
+// Stores
+
+enum v8_string_t {
+  V8_S_EMPTY,
+  V8_S_I32, V8_S_I64, V8_S_F32, V8_S_F64, V8_S_ANYREF, V8_S_ANYFUNC,
+  V8_S_VALUE, V8_S_MUTABLE, V8_S_ELEMENT, V8_S_MINIMUM, V8_S_MAXIMUM,
+  V8_S_COUNT
+};
+
+enum v8_symbol_t {
+  V8_Y_CALLBACK, V8_Y_ENV,
+  V8_Y_COUNT
+};
+
+enum v8_function_t {
+  V8_F_WEAKMAP, V8_F_WEAKMAP_PROTO, V8_F_WEAKMAP_GET, V8_F_WEAKMAP_SET,
+  V8_F_MODULE, V8_F_GLOBAL, V8_F_TABLE, V8_F_MEMORY,
+  V8_F_INSTANCE, V8_F_VALIDATE,
+  V8_F_COUNT,
+};
+
+class StoreImpl {
+  friend own<Store> Store::make(Engine*);
+
+  v8::Isolate::CreateParams create_params_;
+  v8::Isolate *isolate_;
+  v8::Eternal<v8::Context> context_;
+  v8::Eternal<v8::String> strings_[V8_S_COUNT];
+  v8::Eternal<v8::Symbol> symbols_[V8_Y_COUNT];
+  v8::Eternal<v8::Function> functions_[V8_F_COUNT];
+  v8::Eternal<v8::Object> host_data_map_;
+  v8::Eternal<v8::Symbol> callback_symbol_;
+  v8::Persistent<v8::Object>* handle_pool_ = nullptr;  // TODO: use v8::Value
+
+public:
+  StoreImpl() {
+    stats.make(Stats::STORE, this);
+  }
+
+  ~StoreImpl() {
+#ifdef WASM_API_DEBUG
+    isolate_->RequestGarbageCollectionForTesting(
+      v8::Isolate::kFullGarbageCollection);
+#endif
+    {
+      v8::HandleScope scope(isolate_);
+      while (handle_pool_ != nullptr) {
+        auto handle = handle_pool_;
+        handle_pool_ = reinterpret_cast<v8::Persistent<v8::Object>*>(
+          wasm_v8::foreign_get(handle->Get(isolate_)));
+        delete handle;
+      }
+    }
+    context()->Exit();
+    isolate_->Exit();
+    isolate_->Dispose();
+    delete create_params_.array_buffer_allocator;
+    stats.free(Stats::STORE, this);
+  }
+
+  auto isolate() const -> v8::Isolate* {
+    return isolate_;
+  }
+
+  auto context() const -> v8::Local<v8::Context> {
+    return context_.Get(isolate_);
+  }
+
+  auto v8_string(v8_string_t i) const -> v8::Local<v8::String> {
+    return strings_[i].Get(isolate_);
+  }
+  auto v8_string(v8_symbol_t i) const -> v8::Local<v8::Symbol> {
+    return symbols_[i].Get(isolate_);
+  }
+  auto v8_function(v8_function_t i) const -> v8::Local<v8::Function> {
+    return functions_[i].Get(isolate_);
+  }
+
+  auto host_data_map() const -> v8::Local<v8::Object> {
+    return host_data_map_.Get(isolate_);
+  }
+
+  static auto get(v8::Isolate* isolate) -> StoreImpl* {
+    return static_cast<StoreImpl*>(isolate->GetData(0));
+  }
+
+  auto make_handle() -> v8::Persistent<v8::Object>* {
+    if (handle_pool_ == nullptr) {
+      static const size_t n = 100;
+      for (size_t i = 0; i < n; ++i) {
+        auto v8_next = wasm_v8::foreign_new(isolate_, handle_pool_);
+        handle_pool_ = new(std::nothrow) v8::Persistent<v8::Object>();
+        if (!handle_pool_) return nullptr;
+        handle_pool_->Reset(isolate_, v8::Local<v8::Object>::Cast(v8_next));
+      }
+    }
+    auto handle = handle_pool_;
+    handle_pool_ = reinterpret_cast<v8::Persistent<v8::Object>*>(
+      wasm_v8::foreign_get(handle->Get(isolate_)));
+    return handle;
+  }
+
+  void free_handle(v8::Persistent<v8::Object>* handle) {
+    // TODO: shrink pool?
+    auto next = wasm_v8::foreign_new(isolate_, handle_pool_);
+    handle->Reset(isolate_, v8::Local<v8::Object>::Cast(next));
+    handle_pool_ = handle;
+  }
+};
+
+template<> struct implement<Store> { using type = StoreImpl; };
+
+
+Store::~Store() {
+  impl(this)->~StoreImpl();
+}
+
+void Store::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto Store::make(Engine*) -> own<Store> {
+  auto store = make_own(new(std::nothrow) StoreImpl());
+  if (!store) return own<Store>();
+
+  // Create isolate.
+  store->create_params_.array_buffer_allocator =
+    v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+  auto isolate = v8::Isolate::New(store->create_params_);
+  if (!isolate) return own<Store>();
+
+  {
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    // Create context.
+    auto context = v8::Context::New(isolate);
+    if (context.IsEmpty()) return own<Store>();
+    v8::Context::Scope context_scope(context);
+
+    store->isolate_ = isolate;
+    store->context_ = v8::Eternal<v8::Context>(isolate, context);
+
+    // Create strings.
+    static const char* const raw_strings[V8_S_COUNT] = {
+      "",
+      "i32", "i64", "f32", "f64", "anyref", "anyfunc", 
+      "value", "mutable", "element", "initial", "maximum",
+    };
+    for (int i = 0; i < V8_S_COUNT; ++i) {
+      auto maybe = v8::String::NewFromUtf8(isolate, raw_strings[i],
+        v8::NewStringType::kNormal);
+      if (maybe.IsEmpty()) return own<Store>();
+      auto string = maybe.ToLocalChecked();
+      store->strings_[i] = v8::Eternal<v8::String>(isolate, string);
+    }
+
+    for (int i = 0; i < V8_Y_COUNT; ++i) {
+      auto symbol = v8::Symbol::New(isolate);
+      store->symbols_[i] = v8::Eternal<v8::Symbol>(isolate, symbol);
+    }
+
+    // Extract functions.
+    auto global = context->Global();
+    auto maybe_wasm_name = v8::String::NewFromUtf8(isolate, "WebAssembly",
+        v8::NewStringType::kNormal);
+    if (maybe_wasm_name.IsEmpty()) return own<Store>();
+    auto wasm_name = maybe_wasm_name.ToLocalChecked();
+    auto maybe_wasm = global->Get(context, wasm_name);
+    if (maybe_wasm.IsEmpty()) return own<Store>();
+    auto wasm = v8::Local<v8::Object>::Cast(maybe_wasm.ToLocalChecked());
+    v8::Local<v8::Object> weakmap;
+    v8::Local<v8::Object> weakmap_proto;
+
+    struct {
+      const char* name;
+      v8::Local<v8::Object>* carrier;
+    } raw_functions[V8_F_COUNT] = {
+      {"WeakMap", &global}, {"prototype", &weakmap},
+      {"get", &weakmap_proto}, {"set", &weakmap_proto},
+      {"Module", &wasm}, {"Global", &wasm}, {"Table", &wasm}, {"Memory", &wasm},
+      {"Instance", &wasm}, {"validate", &wasm},
+    };
+    for (int i = 0; i < V8_F_COUNT; ++i) {
+      auto maybe_name = v8::String::NewFromUtf8(isolate, raw_functions[i].name,
+        v8::NewStringType::kNormal);
+      if (maybe_name.IsEmpty()) return own<Store>();
+      auto name = maybe_name.ToLocalChecked();
+      assert(!raw_functions[i].carrier->IsEmpty());
+      // TODO(wasm+): remove
+      if ((*raw_functions[i].carrier)->IsUndefined()) continue;
+      auto maybe_obj = (*raw_functions[i].carrier)->Get(context, name);
+      if (maybe_obj.IsEmpty()) return own<Store>();
+      auto obj = v8::Local<v8::Object>::Cast(maybe_obj.ToLocalChecked());
+      if (i == V8_F_WEAKMAP_PROTO) {
+        assert(obj->IsObject());
+        weakmap_proto = obj;
+      } else {
+        assert(obj->IsFunction());
+        auto function = v8::Local<v8::Function>::Cast(obj);
+        store->functions_[i] = v8::Eternal<v8::Function>(isolate, function);
+        if (i == V8_F_WEAKMAP) weakmap = function;
+      }
+    }
+
+    // Create host data weak map.
+    v8::Local<v8::Value> empty_args[] = {};
+    auto maybe_weakmap =
+      store->v8_function(V8_F_WEAKMAP)->NewInstance(context, 0, empty_args);
+    if (maybe_weakmap.IsEmpty()) return own<Store>();
+    auto map = v8::Local<v8::Object>::Cast(maybe_weakmap.ToLocalChecked());
+    assert(map->IsWeakMap());
+    store->host_data_map_ = v8::Eternal<v8::Object>(isolate, map);
+  }
+
+  store->isolate()->Enter();
+  store->context()->Enter();
+  isolate->SetData(0, store.get());
+
+  return make_own(seal<Store>(store.release()));
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Value Types
+
+struct ValTypeImpl {
+  ValKind kind;
+
+  ValTypeImpl(ValKind kind) : kind(kind) {}
+};
+
+template<> struct implement<ValType> { using type = ValTypeImpl; };
+
+ValTypeImpl* valtype_i32 = new ValTypeImpl(ValKind::I32);
+ValTypeImpl* valtype_i64 = new ValTypeImpl(ValKind::I64);
+ValTypeImpl* valtype_f32 = new ValTypeImpl(ValKind::F32);
+ValTypeImpl* valtype_f64 = new ValTypeImpl(ValKind::F64);
+ValTypeImpl* valtype_anyref = new ValTypeImpl(ValKind::ANYREF);
+ValTypeImpl* valtype_funcref = new ValTypeImpl(ValKind::FUNCREF);
+
+
+ValType::~ValType() {
+  stats.free(Stats::VALTYPE, this);
+}
+
+void ValType::operator delete(void*) {}
+
+auto ValType::make(ValKind k) -> own<ValType> {
+  ValTypeImpl* valtype;
+  switch (k) {
+    case ValKind::I32: valtype = valtype_i32; break;
+    case ValKind::I64: valtype = valtype_i64; break;
+    case ValKind::F32: valtype = valtype_f32; break;
+    case ValKind::F64: valtype = valtype_f64; break;
+    case ValKind::ANYREF: valtype = valtype_anyref; break;
+    case ValKind::FUNCREF: valtype = valtype_funcref; break;
+    default:
+      // TODO(wasm+): support new value types
+      assert(false);
+  };
+  auto result = seal<ValType>(valtype);
+  stats.make(Stats::VALTYPE, result);
+  return own<ValType>(result);
+}
+
+auto ValType::copy() const -> own<ValType> {
+  return make(kind());
+}
+
+auto ValType::kind() const -> ValKind {
+  return impl(this)->kind;
+}
+
+
+// Extern Types
+
+struct ExternTypeImpl {
+  ExternKind kind;
+
+  explicit ExternTypeImpl(ExternKind kind) : kind(kind) {}
+  virtual ~ExternTypeImpl() {}
+};
+
+template<> struct implement<ExternType> { using type = ExternTypeImpl; };
+
+
+ExternType::~ExternType() {
+  impl(this)->~ExternTypeImpl();
+}
+
+void ExternType::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto ExternType::copy() const -> own<ExternType> {
+  switch (kind()) {
+    case ExternKind::FUNC: return func()->copy();
+    case ExternKind::GLOBAL: return global()->copy();
+    case ExternKind::TABLE: return table()->copy();
+    case ExternKind::MEMORY: return memory()->copy();
+  }
+}
+
+auto ExternType::kind() const -> ExternKind {
+  return impl(this)->kind;
+}
+
+
+// Function Types
+
+struct FuncTypeImpl : ExternTypeImpl {
+  ownvec<ValType> params;
+  ownvec<ValType> results;
+
+  FuncTypeImpl(ownvec<ValType>& params, ownvec<ValType>& results) :
+    ExternTypeImpl(ExternKind::FUNC),
+    params(std::move(params)), results(std::move(results))
+  {
+    stats.make(Stats::FUNCTYPE, this);
+  }
+
+  ~FuncTypeImpl() {
+    stats.free(Stats::FUNCTYPE, this);
+  }
+};
+
+template<> struct implement<FuncType> { using type = FuncTypeImpl; };
+
+
+FuncType::~FuncType() {}
+
+auto FuncType::make(ownvec<ValType>&& params, ownvec<ValType>&& results)
+  -> own<FuncType> {
+  return params && results
+    ? own<FuncType>(
+        seal<FuncType>(new(std::nothrow) FuncTypeImpl(params, results)))
+    : own<FuncType>();
+}
+
+auto FuncType::copy() const -> own<FuncType> {
+  return make(params().deep_copy(), results().deep_copy());
+}
+
+auto FuncType::params() const -> const ownvec<ValType>& {
+  return impl(this)->params;
+}
+
+auto FuncType::results() const -> const ownvec<ValType>& {
+  return impl(this)->results;
+}
+
+
+auto ExternType::func() -> FuncType* {
+  return kind() == ExternKind::FUNC
+    ? seal<FuncType>(static_cast<FuncTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+auto ExternType::func() const -> const FuncType* {
+  return kind() == ExternKind::FUNC
+    ? seal<FuncType>(static_cast<const FuncTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+
+// Global Types
+
+struct GlobalTypeImpl : ExternTypeImpl {
+  own<ValType> content;
+  Mutability mutability;
+
+  GlobalTypeImpl(own<ValType>& content, Mutability mutability) :
+    ExternTypeImpl(ExternKind::GLOBAL),
+    content(std::move(content)), mutability(mutability)
+  {
+    stats.make(Stats::GLOBALTYPE, this);
+  }
+
+  ~GlobalTypeImpl() {
+    stats.free(Stats::GLOBALTYPE, this);
+  }
+};
+
+template<> struct implement<GlobalType> { using type = GlobalTypeImpl; };
+
+
+GlobalType::~GlobalType() {}
+
+auto GlobalType::make(
+  own<ValType>&& content, Mutability mutability
+) -> own<GlobalType> {
+  return content
+    ? own<GlobalType>(
+        seal<GlobalType>(new(std::nothrow) GlobalTypeImpl(content, mutability)))
+    : own<GlobalType>();
+}
+
+auto GlobalType::copy() const -> own<GlobalType> {
+  return make(content()->copy(), mutability());
+}
+
+auto GlobalType::content() const -> const ValType* {
+  return impl(this)->content.get();
+}
+
+auto GlobalType::mutability() const -> Mutability {
+  return impl(this)->mutability;
+}
+
+
+auto ExternType::global() -> GlobalType* {
+  return kind() == ExternKind::GLOBAL
+    ? seal<GlobalType>(static_cast<GlobalTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+auto ExternType::global() const -> const GlobalType* {
+  return kind() == ExternKind::GLOBAL
+    ? seal<GlobalType>(static_cast<const GlobalTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+
+// Table Types
+
+struct TableTypeImpl : ExternTypeImpl {
+  own<ValType> element;
+  Limits limits;
+
+  TableTypeImpl(own<ValType>& element, Limits limits) :
+    ExternTypeImpl(ExternKind::TABLE), element(std::move(element)), limits(limits)
+  {
+    stats.make(Stats::TABLETYPE, this);
+  }
+
+  ~TableTypeImpl() {
+    stats.free(Stats::TABLETYPE, this);
+  }
+};
+
+template<> struct implement<TableType> { using type = TableTypeImpl; };
+
+
+TableType::~TableType() {}
+
+auto TableType::make(own<ValType>&& element, Limits limits) -> own<TableType> {
+  return element
+    ? own<TableType>(
+        seal<TableType>(new(std::nothrow) TableTypeImpl(element, limits)))
+    : own<TableType>();
+}
+
+auto TableType::copy() const -> own<TableType> {
+  return make(element()->copy(), limits());
+}
+
+auto TableType::element() const -> const ValType* {
+  return impl(this)->element.get();
+}
+
+auto TableType::limits() const -> const Limits& {
+  return impl(this)->limits;
+}
+
+
+auto ExternType::table() -> TableType* {
+  return kind() == ExternKind::TABLE
+    ? seal<TableType>(static_cast<TableTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+auto ExternType::table() const -> const TableType* {
+  return kind() == ExternKind::TABLE
+    ? seal<TableType>(static_cast<const TableTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+
+// Memory Types
+
+struct MemoryTypeImpl : ExternTypeImpl {
+  Limits limits;
+
+  MemoryTypeImpl(Limits limits) :
+    ExternTypeImpl(ExternKind::MEMORY), limits(limits)
+  {
+    stats.make(Stats::MEMORYTYPE, this);
+  }
+
+  ~MemoryTypeImpl() {
+    stats.free(Stats::MEMORYTYPE, this);
+  }
+};
+
+template<> struct implement<MemoryType> { using type = MemoryTypeImpl; };
+
+
+MemoryType::~MemoryType() {}
+
+auto MemoryType::make(Limits limits) -> own<MemoryType> {
+  return own<MemoryType>(
+    seal<MemoryType>(new(std::nothrow) MemoryTypeImpl(limits)));
+}
+
+auto MemoryType::copy() const -> own<MemoryType> {
+  return MemoryType::make(limits());
+}
+
+auto MemoryType::limits() const -> const Limits& {
+  return impl(this)->limits;
+}
+
+
+auto ExternType::memory() -> MemoryType* {
+  return kind() == ExternKind::MEMORY
+    ? seal<MemoryType>(static_cast<MemoryTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+auto ExternType::memory() const -> const MemoryType* {
+  return kind() == ExternKind::MEMORY
+    ? seal<MemoryType>(static_cast<const MemoryTypeImpl*>(impl(this)))
+    : nullptr;
+}
+
+
+// Import Types
+
+struct ImportTypeImpl {
+  Name module;
+  Name name;
+  own<ExternType> type;
+
+  ImportTypeImpl(Name& module, Name& name, own<ExternType>& type) :
+    module(std::move(module)), name(std::move(name)), type(std::move(type))
+  {
+    stats.make(Stats::IMPORTTYPE, this);
+  }
+
+  ~ImportTypeImpl() {
+    stats.free(Stats::IMPORTTYPE, this);
+  }
+};
+
+template<> struct implement<ImportType> { using type = ImportTypeImpl; };
+
+
+ImportType::~ImportType() {
+  impl(this)->~ImportTypeImpl();
+}
+
+void ImportType::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto ImportType::make(
+  Name&& module, Name&& name, own<ExternType>&& type
+) -> own<ImportType> {
+  return module && name && type
+    ? own<ImportType>(
+        seal<ImportType>(new(std::nothrow) ImportTypeImpl(module, name, type)))
+    : own<ImportType>();
+}
+
+auto ImportType::copy() const -> own<ImportType> {
+  return make(module().copy(), name().copy(), type()->copy());
+}
+
+auto ImportType::module() const -> const Name& {
+  return impl(this)->module;
+}
+
+auto ImportType::name() const -> const Name& {
+  return impl(this)->name;
+}
+
+auto ImportType::type() const -> const ExternType* {
+  return impl(this)->type.get();
+}
+
+
+// Export Types
+
+struct ExportTypeImpl {
+  Name name;
+  own<ExternType> type;
+
+  ExportTypeImpl(Name& name, own<ExternType>& type) :
+    name(std::move(name)), type(std::move(type))
+  {
+    stats.make(Stats::EXPORTTYPE, this);
+  }
+
+  ~ExportTypeImpl() {
+    stats.free(Stats::EXPORTTYPE, this);
+  }
+};
+
+template<> struct implement<ExportType> { using type = ExportTypeImpl; };
+
+
+ExportType::~ExportType() {
+  impl(this)->~ExportTypeImpl();
+}
+
+void ExportType::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto ExportType::make(
+  Name&& name, own<ExternType>&& type
+) -> own<ExportType> {
+  return name && type
+    ? own<ExportType>(
+        seal<ExportType>(new(std::nothrow) ExportTypeImpl(name, type)))
+    : own<ExportType>();
+}
+
+auto ExportType::copy() const -> own<ExportType> {
+  return make(name().copy(), type()->copy());
+}
+
+auto ExportType::name() const -> const Name& {
+  return impl(this)->name;
+}
+
+auto ExportType::type() const -> const ExternType* {
+  return impl(this)->type.get();
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Conversions of types from and to V8 objects
+
+// Types
+
+auto valtype_to_v8(
+  StoreImpl* store, const ValType* type
+) -> v8::Local<v8::Value> {
+  v8_string_t string;
+  switch (type->kind()) {
+    case ValKind::I32: string = V8_S_I32; break;
+    case ValKind::I64: string = V8_S_I64; break;
+    case ValKind::F32: string = V8_S_F32; break;
+    case ValKind::F64: string = V8_S_F64; break;
+    case ValKind::ANYREF: string = V8_S_ANYREF; break;
+    case ValKind::FUNCREF: string = V8_S_ANYFUNC; break;
+    default:
+      // TODO(wasm+): support new value types
+      assert(false);
+  }
+  return store->v8_string(string);
+}
+
+auto mutability_to_v8(
+  StoreImpl* store, Mutability mutability
+) -> v8::Local<v8::Boolean> {
+  return v8::Boolean::New(store->isolate(), mutability == Mutability::VAR);
+}
+
+void limits_to_v8(StoreImpl* store, Limits limits, v8::Local<v8::Object> desc) {
+  auto isolate = store->isolate();
+  auto context = store->context();
+  ignore(desc->DefineOwnProperty(context, store->v8_string(V8_S_MINIMUM),
+    v8::Integer::NewFromUnsigned(isolate, limits.min)));
+  if (limits.max != Limits(0).max) {
+    ignore(desc->DefineOwnProperty(context, store->v8_string(V8_S_MAXIMUM),
+      v8::Integer::NewFromUnsigned(isolate, limits.max)));
+  }
+}
+
+auto globaltype_to_v8(
+  StoreImpl* store, const GlobalType* type
+) -> v8::Local<v8::Object> {
+  auto isolate = store->isolate();
+  auto context = store->context();
+  auto desc = v8::Object::New(isolate);
+  ignore(desc->DefineOwnProperty(context, store->v8_string(V8_S_VALUE),
+    valtype_to_v8(store, type->content())));
+  ignore(desc->DefineOwnProperty(context, store->v8_string(V8_S_MUTABLE),
+    mutability_to_v8(store, type->mutability())));
+  return desc;
+}
+
+auto tabletype_to_v8(
+  StoreImpl* store, const TableType* type
+) -> v8::Local<v8::Object> {
+  auto isolate = store->isolate();
+  auto context = store->context();
+  auto desc = v8::Object::New(isolate);
+  ignore(desc->DefineOwnProperty(context, store->v8_string(V8_S_ELEMENT),
+    valtype_to_v8(store, type->element())));
+  limits_to_v8(store, type->limits(), desc);
+  return desc;
+}
+
+auto memorytype_to_v8(
+  StoreImpl* store, const MemoryType* type
+) -> v8::Local<v8::Object> {
+  auto isolate = store->isolate();
+  auto desc = v8::Object::New(isolate);
+  limits_to_v8(store, type->limits(), desc);
+  return desc;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Values
+
+// References
+
+template<class Ref>
+class RefImpl : public v8::Persistent<v8::Object> {
+public:
+  RefImpl() = delete;
+  ~RefImpl() = delete;
+
+  static auto make(StoreImpl* store, v8::Local<v8::Object> obj) -> own<Ref> {
+    static_assert(sizeof(RefImpl) == sizeof(v8::Persistent<v8::Object>),
+      "incompatible object layout");
+    auto self = static_cast<RefImpl*>(store->make_handle());
+    if (!self) return nullptr;
+    self->Reset(store->isolate(), obj);
+    stats.make(Stats::categorize(*self), self);
+    return make_own(seal<Ref>(self));
+  }
+
+  auto copy() const -> own<Ref> {
+    v8::HandleScope handle_scope(isolate());
+    return make(store(), v8_object());
+  }
+
+  auto store() const -> StoreImpl* {
+    return StoreImpl::get(isolate());
+  }
+
+  auto isolate() const -> v8::Isolate* {
+    return wasm_v8::object_isolate(*this);
+  }
+
+  auto v8_object() const -> v8::Local<v8::Object> {
+    return Get(isolate());
+  }
+
+  auto get_host_info() const -> void* {
+    v8::HandleScope handle_scope(isolate());
+    auto store = this->store();
+
+    v8::Local<v8::Value> args[] = { v8_object() };
+    auto maybe_result = store->v8_function(V8_F_WEAKMAP_GET)->Call(
+      store->context(), store->host_data_map(), 1, args);
+    if (maybe_result.IsEmpty()) return nullptr;
+    return wasm_v8::managed_get(maybe_result.ToLocalChecked());
+  }
+
+  void set_host_info(void* info, void (*finalizer)(void*)) {
+    v8::HandleScope handle_scope(isolate());
+    auto store = this->store();
+    auto managed = wasm_v8::managed_new(store->isolate(), info, finalizer);
+    v8::Local<v8::Value> args[] = { v8_object(), managed };
+    auto maybe_result = store->v8_function(V8_F_WEAKMAP_SET)->Call(
+      store->context(), store->host_data_map(), 2, args);
+    if (maybe_result.IsEmpty()) return;
+  }
+};
+
+template<> struct implement<Ref> { using type = RefImpl<Ref>; };
+
+
+Ref::~Ref() {
+  stats.free(Stats::categorize(*impl(this)), this);
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  impl(this)->store()->free_handle(impl(this));
+}
+
+void Ref::operator delete(void *p) {}
+
+auto Ref::copy() const -> own<Ref> {
+  return impl(this)->copy();
+}
+
+auto Ref::same(const Ref* that) const -> bool {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return impl(this)->v8_object()->SameValue(impl(that)->v8_object());
+}
+
+auto Ref::get_host_info() const -> void* {
+  return impl(this)->get_host_info();
+}
+
+void Ref::set_host_info(void* info, void (*finalizer)(void*)) {
+  impl(this)->set_host_info(info, finalizer);
+}
+
+
+// Value Conversion
+
+auto ref_to_v8(StoreImpl* store, const Ref* r) -> v8::Local<v8::Value> {
+  if (r == nullptr) {
+    return v8::Null(store->isolate());
+  } else {
+    return impl(r)->v8_object();
+  }
+}
+
+auto val_to_v8(StoreImpl* store, const Val& v) -> v8::Local<v8::Value> {
+  auto isolate = store->isolate();
+  switch (v.kind()) {
+    case ValKind::I32: return v8::Integer::NewFromUnsigned(isolate, v.i32());
+    case ValKind::I64: return v8::BigInt::New(isolate, v.i64());
+    case ValKind::F32: return v8::Number::New(isolate, v.f32());
+    case ValKind::F64: return v8::Number::New(isolate, v.f64());
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF:
+      return ref_to_v8(store, v.ref());
+    default: assert(false);
+  }
+}
+
+auto v8_to_ref(StoreImpl* store, v8::Local<v8::Value> value) -> own<Ref> {
+  if (value->IsNull()) {
+    return nullptr;
+  } else if (value->IsObject()) {
+    return RefImpl<Ref>::make(store, v8::Local<v8::Object>::Cast(value));
+  } else {
+    UNIMPLEMENTED("JS primitive ref value");
+  }
+}
+
+auto v8_to_val(
+  StoreImpl* store, v8::Local<v8::Value> value, const ValType* t
+) -> Val {
+  auto context = store->context();
+  switch (t->kind()) {
+    case ValKind::I32: return Val(value->Int32Value(context).ToChecked());
+    case ValKind::I64: {
+      auto bigint = value->ToBigInt(context).ToLocalChecked();
+      return Val(bigint->Int64Value());
+    }
+    case ValKind::F32: {
+      auto number = value->NumberValue(context).ToChecked();
+      return Val(static_cast<float32_t>(number));
+    }
+    case ValKind::F64: return Val(value->NumberValue(context).ToChecked());
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: {
+      return Val(v8_to_ref(store, value));
+    }
+  }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// Frames
+
+struct FrameImpl {
+  FrameImpl(
+    own<Instance>&& instance, uint32_t func_index,
+    size_t func_offset, size_t module_offset
+  ) :
+    instance(std::move(instance)),
+    func_index(func_index),
+    func_offset(func_offset),
+    module_offset(module_offset)
+  {
+    stats.make(Stats::FRAME, this);
+  }
+
+  ~FrameImpl() { stats.free(Stats::FRAME, this); }
+
+  own<Instance> instance;
+  uint32_t func_index;
+  size_t func_offset;
+  size_t module_offset;
+};
+
+template<> struct implement<Frame> { using type = FrameImpl; };
+
+
+Frame::~Frame() {
+  impl(this)->~FrameImpl();
+}
+
+void Frame::operator delete(void *p) {
+  ::operator delete(p);
+}
+
+auto Frame::copy() const -> own<Frame> {
+  auto self = impl(this);
+  return own<Frame>(seal<Frame>(new(std::nothrow) FrameImpl(
+    self->instance->copy(), self->func_index, self->func_offset,
+    self->module_offset)));
+}
+
+auto Frame::instance() const -> Instance* {
+  return impl(this)->instance.get();
+}
+
+auto Frame::func_index() const -> uint32_t {
+  return impl(this)->func_index;
+}
+
+auto Frame::func_offset() const -> size_t {
+  return impl(this)->func_offset;
+}
+
+auto Frame::module_offset() const -> size_t {
+  return impl(this)->module_offset;
+}
+
+
+// Traps
+
+template<> struct implement<Trap> { using type = RefImpl<Trap>; };
+
+
+Trap::~Trap() {}
+
+auto Trap::copy() const -> own<Trap> {
+  return impl(this)->copy();
+}
+
+auto Trap::make(Store* store_abs, const Message& message) -> own<Trap> {
+  auto store = impl(store_abs);
+  v8::Isolate* isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto maybe_string = v8::String::NewFromUtf8(isolate, message.get(),
+    v8::NewStringType::kNormal, message.size());
+  if (maybe_string.IsEmpty()) return own<Trap>();
+  auto exception = v8::Exception::Error(maybe_string.ToLocalChecked());
+  return RefImpl<Trap>::make(store, v8::Local<v8::Object>::Cast(exception));
+}
+
+auto Trap::message() const -> Message {
+  auto isolate = impl(this)->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto message = v8::Exception::CreateMessage(isolate, impl(this)->v8_object());
+  v8::String::Utf8Value string(isolate, message->Get());
+  return vec<byte_t>::make_nt(std::string(*string));
+}
+
+auto Trap::origin() const -> own<Frame> {
+  // TODO(v8): implement
+  return own<Frame>(nullptr);
+}
+
+auto Trap::trace() const -> ownvec<Frame> {
+  // TODO(v8): implement
+  return ownvec<Frame>::make();
+}
+
+
+// Foreign Objects
+
+template<> struct implement<Foreign> { using type = RefImpl<Foreign>; };
+
+
+Foreign::~Foreign() {}
+
+auto Foreign::copy() const -> own<Foreign> {
+  return impl(this)->copy();
+}
+
+auto Foreign::make(Store* store_abs) -> own<Foreign> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto obj = v8::Object::New(isolate);
+  return RefImpl<Foreign>::make(store, obj);
+}
+
+
+// Modules
+
+template<> struct implement<Module> { using type = RefImpl<Module>; };
+
+
+Module::~Module() {}
+
+auto Module::copy() const -> own<Module> {
+  return impl(this)->copy();
+}
+
+auto Module::validate(Store* store_abs, const vec<byte_t>& binary) -> bool {
+  auto store = impl(store_abs);
+  v8::Isolate* isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto array_buffer = v8::ArrayBuffer::New(
+    isolate, const_cast<byte_t*>(binary.get()), binary.size());
+
+  v8::Local<v8::Value> args[] = {array_buffer};
+  auto result = store->v8_function(V8_F_VALIDATE)->Call(
+    store->context(), v8::Undefined(isolate), 1, args);
+  if (result.IsEmpty()) return false;
+
+  return result.ToLocalChecked()->IsTrue();
+}
+
+auto Module::make(Store* store_abs, const vec<byte_t>& binary) -> own<Module> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  auto context = store->context();
+  v8::HandleScope handle_scope(isolate);
+
+  auto array_buffer = v8::ArrayBuffer::New(
+    isolate, const_cast<byte_t*>(binary.get()), binary.size());
+
+  v8::Local<v8::Value> args[] = {array_buffer};
+  auto maybe_obj =
+    store->v8_function(V8_F_MODULE)->NewInstance(context, 1, args);
+  if (maybe_obj.IsEmpty()) return nullptr;
+  return RefImpl<Module>::make(store, maybe_obj.ToLocalChecked());
+}
+
+auto Module::imports() const -> ownvec<ImportType> {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto module = impl(this)->v8_object();
+  auto binary = vec<byte_t>::adopt(
+    wasm_v8::module_binary_size(module),
+    const_cast<byte_t*>(wasm_v8::module_binary(module))
+  );
+  auto imports = wasm::bin::imports(binary);
+  binary.release();
+  return imports;
+  // return impl(this)->data->imports.copy();
+/* OBSOLETE?
+  auto store = module->store();
+  auto isolate = store->isolate();
+  auto context = store->context();
+  v8::HandleScope handle_scope(isolate);
+
+  v8::Local<v8::Value> args[] = { module->v8_object() };
+  auto result = store->v8_function(V8_F_IMPORTS)->Call(
+    context, v8::Undefined(isolate), 1, args);
+  if (result.IsEmpty()) return wasm_importtype_vec_empty();
+  auto array = v8::Local<v8::Array>::Cast(result.ToLocalChecked());
+  size_t size = array->Length();
+
+  wasm_importtype_vec_t imports = wasm_importtype_vec_new_uninitialized(size);
+  for (size_t i = 0; i < size; ++i) {
+    auto desc = v8::Local<v8::Object>::Cast(array->Get(i));
+    auto module_str = v8::Local<v8::String>::Cast(
+      desc->Get(context, store->v8_string(V8_S_MODULE)).ToLocalChecked());
+    auto name_str = v8::Local<v8::String>::Cast(
+      desc->Get(context, store->v8_string(V8_S_NAME)).ToLocalChecked());
+    auto kind_str = v8::Local<v8::String>::Cast(
+      desc->Get(context, store->v8_string(V8_S_KIND)).ToLocalChecked());
+
+    auto type = wasm_externtype_new_from_v8_kind(store, kind_str);
+    auto module = wasm_byte_vec_new_from_v8_string(module_str);
+    auto name = wasm_byte_vec_new_from_v8_string(name_str);
+    imports.data[i] = wasm_importtype_new(module, name, type);
+  }
+
+  return imports;
+*/
+}
+
+auto Module::exports() const -> ownvec<ExportType> {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto module = impl(this)->v8_object();
+  auto binary = vec<byte_t>::adopt(
+    wasm_v8::module_binary_size(module),
+    const_cast<byte_t*>(wasm_v8::module_binary(module))
+  );
+  auto exports = wasm::bin::exports(binary);
+  binary.release();
+  return exports;
+  // return impl(this)->data->exports.copy();
+/* OBSOLETE?
+  auto store = module->store();
+  auto isolate = store->isolate();
+  auto context = store->context();
+  v8::HandleScope handle_scope(isolate);
+
+  v8::Local<v8::Value> args[] = { module->v8_object() };
+  auto result = store->v8_function(V8_F_EXPORTS)->Call(
+    context, v8::Undefined(isolate), 1, args);
+  if (result.IsEmpty()) return wasm_exporttype_vec_empty();
+  auto array = v8::Local<v8::Array>::Cast(result.ToLocalChecked());
+  size_t size = array->Length();
+
+  wasm_exporttype_vec_t exports = wasm_exporttype_vec_new_uninitialized(size);
+  for (size_t i = 0; i < size; ++i) {
+    auto desc = v8::Local<v8::Object>::Cast(array->Get(i));
+    auto name_str = v8::Local<v8::String>::Cast(
+      desc->Get(context, store->v8_string(V8_S_NAME)).ToLocalChecked());
+    auto kind_str = v8::Local<v8::String>::Cast(
+      desc->Get(context, store->v8_string(V8_S_KIND)).ToLocalChecked());
+
+    auto type = wasm_externtype_new_from_v8_kind(store, kind_str);
+    auto name = wasm_byte_vec_new_from_v8_string(name_str);
+    exports.data[i] = wasm_exporttype_new(name, type);
+  }
+
+  return exports;
+*/
+}
+
+auto Module::serialize() const -> vec<byte_t> {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto module = impl(this)->v8_object();
+  auto binary_size = wasm_v8::module_binary_size(module);
+  auto serial_size = wasm_v8::module_serialize_size(module);
+  auto size_size = wasm::bin::u64_size(binary_size);
+  auto buffer = vec<byte_t>::make_uninitialized(
+    size_size + binary_size + serial_size);
+  auto ptr = buffer.get();
+  wasm::bin::encode_u64(ptr, binary_size);
+  std::memcpy(ptr, wasm_v8::module_binary(module), binary_size);
+  ptr += binary_size;
+  if (!wasm_v8::module_serialize(module, ptr, serial_size)) buffer.reset();
+  return buffer;
+}
+
+auto Module::deserialize(Store* store_abs, const vec<byte_t>& serialized) -> own<Module> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+  auto ptr = serialized.get();
+  auto binary_size = wasm::bin::u64(ptr);
+  auto size_size = ptr - serialized.get();
+  auto serial_size = serialized.size() - size_size - binary_size;
+  auto maybe_obj = wasm_v8::module_deserialize(
+    isolate, ptr, binary_size, ptr + binary_size, serial_size);
+  if (maybe_obj.IsEmpty()) return nullptr;
+  return RefImpl<Module>::make(store, maybe_obj.ToLocalChecked());
+}
+
+
+// TODO(v8): do better when V8 can do better.
+template<> struct implement<Shared<Module>> { using type = vec<byte_t>; };
+
+template<>
+Shared<Module>::~Shared() {
+  stats.free(Stats::MODULE, this, Stats::SHARED);
+  impl(this)->~vec();
+}
+
+template<>
+void Shared<Module>::operator delete(void* p) {
+  ::operator delete(p);
+}
+
+auto Module::share() const -> own<Shared<Module>> {
+  auto shared = seal<Shared<Module>>(new vec<byte_t>(serialize()));
+  stats.make(Stats::MODULE, shared, Stats::SHARED);
+  return make_own(shared);
+}
+
+auto Module::obtain(Store* store, const Shared<Module>* shared) -> own<Module> {
+  return Module::deserialize(store, *impl(shared));
+}
+
+
+
+
+// Externals
+
+template<> struct implement<Extern> { using type = RefImpl<Extern>; };
+
+
+Extern::~Extern() {}
+
+auto Extern::copy() const -> own<Extern> {
+  return impl(this)->copy();
+}
+
+auto Extern::kind() const -> ExternKind {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return static_cast<ExternKind>(wasm_v8::extern_kind(impl(this)->v8_object()));
+}
+
+auto Extern::type() const -> own<ExternType> {
+  switch (kind()) {
+    case ExternKind::FUNC: return func()->type();
+    case ExternKind::GLOBAL: return global()->type();
+    case ExternKind::TABLE: return table()->type();
+    case ExternKind::MEMORY: return memory()->type();
+  }
+}
+
+auto Extern::func() -> Func* {
+  return kind() == ExternKind::FUNC ? static_cast<Func*>(this) : nullptr;
+}
+
+auto Extern::global() -> Global* {
+  return kind() == ExternKind::GLOBAL ? static_cast<Global*>(this) : nullptr;
+}
+
+auto Extern::table() -> Table* {
+  return kind() == ExternKind::TABLE ? static_cast<Table*>(this) : nullptr;
+}
+
+auto Extern::memory() -> Memory* {
+  return kind() == ExternKind::MEMORY ? static_cast<Memory*>(this) : nullptr;
+}
+
+auto Extern::func() const -> const Func* {
+  return kind() == ExternKind::FUNC ? static_cast<const Func*>(this) : nullptr;
+}
+
+auto Extern::global() const -> const Global* {
+  return kind() == ExternKind::GLOBAL ? static_cast<const Global*>(this) : nullptr;
+}
+
+auto Extern::table() const -> const Table* {
+  return kind() == ExternKind::TABLE ? static_cast<const Table*>(this) : nullptr;
+}
+
+auto Extern::memory() const -> const Memory* {
+  return kind() == ExternKind::MEMORY ? static_cast<const Memory*>(this) : nullptr;
+}
+
+auto extern_to_v8(const Extern* ex) -> v8::Local<v8::Value> {
+  return impl(ex)->v8_object();
+}
+
+
+// Function Instances
+
+template<> struct implement<Func> { using type = RefImpl<Func>; };
+
+
+Func::~Func() {}
+
+auto Func::copy() const -> own<Func> {
+  return impl(this)->copy();
+}
+
+struct FuncData {
+  Store* store;
+  own<FuncType> type;
+  enum Kind { CALLBACK, CALLBACK_WITH_ENV } kind;
+  union {
+    Func::callback callback;
+    Func::callback_with_env callback_with_env;
+  };
+  void (*finalizer)(void*);
+  void* env;
+
+  FuncData(Store* store, const FuncType* type, Kind kind) :
+    store(store), type(type->copy()), kind(kind), finalizer(nullptr)
+  {
+    stats.make(Stats::FUNCDATA_FUNCTYPE, nullptr);
+    stats.make(Stats::FUNCDATA_VALTYPE, nullptr, Stats::OWN, type->params().size());
+    stats.make(Stats::FUNCDATA_VALTYPE, nullptr, Stats::OWN, type->results().size());
+    if (type->params().get()) stats.make(Stats::FUNCDATA_VALTYPE, nullptr, Stats::VEC);
+    if (type->results().get()) stats.make(Stats::FUNCDATA_VALTYPE, nullptr, Stats::VEC);
+  }
+
+  ~FuncData() {
+    stats.free(Stats::FUNCDATA_FUNCTYPE, nullptr);
+    stats.free(Stats::FUNCDATA_VALTYPE, nullptr, Stats::OWN, type->params().size());
+    stats.free(Stats::FUNCDATA_VALTYPE, nullptr, Stats::OWN, type->results().size());
+    if (type->params().get()) stats.free(Stats::FUNCDATA_VALTYPE, nullptr, Stats::VEC);
+    if (type->results().get()) stats.free(Stats::FUNCDATA_VALTYPE, nullptr, Stats::VEC);
+    if (finalizer) (*finalizer)(env);
+  }
+
+  static void v8_callback(const v8::FunctionCallbackInfo<v8::Value>&);
+  static void finalize_func_data(void* data);
+};
+
+namespace {
+
+auto make_func(Store* store_abs, FuncData* data) -> own<Func> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+  auto context = store->context();
+
+  // Create V8 function
+  auto v8_data = wasm_v8::foreign_new(isolate, data);
+  auto function_template = v8::FunctionTemplate::New(
+    isolate, &FuncData::v8_callback, v8_data);
+  auto maybe_func_obj = function_template->GetFunction(context);
+  if (maybe_func_obj.IsEmpty()) return own<Func>();
+  auto func_obj = maybe_func_obj.ToLocalChecked();
+
+  // Create wrapper instance
+  auto binary = wasm::bin::wrapper(data->type.get());
+  auto module = Module::make(store_abs, binary);
+
+  auto imports_obj = v8::Object::New(isolate);
+  auto module_obj = v8::Object::New(isolate);
+  auto str = store->v8_string(V8_S_EMPTY);
+  ignore(imports_obj->DefineOwnProperty(context, str, module_obj));
+  ignore(module_obj->DefineOwnProperty(context, str, func_obj));
+
+  v8::Local<v8::Value> instantiate_args[] = {
+    impl(module.get())->v8_object(), imports_obj
+  };
+  auto instance_obj = store->v8_function(V8_F_INSTANCE)->NewInstance(
+    context, 2, instantiate_args).ToLocalChecked();
+  assert(!instance_obj.IsEmpty());
+  assert(instance_obj->IsObject());
+  auto exports_obj = wasm_v8::instance_exports(instance_obj);
+  assert(!exports_obj.IsEmpty());
+  assert(exports_obj->IsObject());
+  auto wrapped_func_obj = v8::Local<v8::Function>::Cast(
+    exports_obj->Get(context, str).ToLocalChecked());
+  assert(!wrapped_func_obj.IsEmpty());
+  assert(wrapped_func_obj->IsFunction());
+
+  auto func = RefImpl<Func>::make(store, wrapped_func_obj);
+  func->set_host_info(data, &FuncData::finalize_func_data);
+  return func;
+}
+
+auto func_type(v8::Local<v8::Object> v8_func) -> own<FuncType> {
+  // return impl(this)->data->type->copy();
+  auto param_arity = wasm_v8::func_type_param_arity(v8_func);
+  auto result_arity = wasm_v8::func_type_result_arity(v8_func);
+  auto params = ownvec<ValType>::make_uninitialized(param_arity);
+  auto results = ownvec<ValType>::make_uninitialized(result_arity);
+
+  for (size_t i = 0; i < params.size(); ++i) {
+    auto kind = static_cast<ValKind>(wasm_v8::func_type_param(v8_func, i));
+    params[i] = ValType::make(kind);
+  }
+  for (size_t i = 0; i < results.size(); ++i) {
+    auto kind = static_cast<ValKind>(wasm_v8::func_type_result(v8_func, i));
+    results[i] = ValType::make(kind);
+  }
+
+  return FuncType::make(std::move(params), std::move(results));
+}
+
+}  // namespace
+
+auto Func::make(
+  Store* store, const FuncType* type, Func::callback callback
+) -> own<Func> {
+  auto data = new FuncData(store, type, FuncData::CALLBACK);
+  data->callback = callback;
+  return make_func(store, data);
+}
+
+auto Func::make(
+  Store* store, const FuncType* type,
+  callback_with_env callback, void* env, void (*finalizer)(void*)
+) -> own<Func> {
+  auto data = new FuncData(store, type, FuncData::CALLBACK_WITH_ENV);
+  data->callback_with_env = callback;
+  data->env = env;
+  data->finalizer = finalizer;
+  return make_func(store, data);
+}
+
+auto Func::type() const -> own<FuncType> {
+  // return impl(this)->data->type->copy();
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return func_type(impl(this)->v8_object());
+}
+
+auto Func::param_arity() const -> size_t {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::func_type_param_arity(impl(this)->v8_object());
+}
+
+auto Func::result_arity() const -> size_t {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::func_type_result_arity(impl(this)->v8_object());
+}
+
+auto Func::call(const vec<Val>& args, vec<Val>& results) const -> own<Trap> {
+  auto func = impl(this);
+  auto store = func->store();
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto context = store->context();
+  auto type = this->type();
+  auto& param_types = type->params();
+  auto& result_types = type->results();
+
+  // TODO: cache v8_args array per thread.
+  auto v8_args = std::unique_ptr<v8::Local<v8::Value>[]>(
+    new(std::nothrow) v8::Local<v8::Value>[param_types.size()]);
+  for (size_t i = 0; i < param_types.size(); ++i) {
+    assert(args[i].kind() == param_types[i]->kind());
+    v8_args[i] = val_to_v8(store, args[i]);
+  }
+
+  v8::TryCatch handler(isolate);
+  auto v8_function = v8::Local<v8::Function>::Cast(func->v8_object());
+  auto maybe_val = v8_function->Call(
+    context, v8::Undefined(isolate), param_types.size(), v8_args.get());
+
+  if (handler.HasCaught()) {
+    auto exception = handler.Exception();
+    if (!exception->IsObject()) {
+      auto maybe_string = exception->ToString(store->context());
+      auto string = maybe_string.IsEmpty()
+        ? store->v8_string(V8_S_EMPTY) : maybe_string.ToLocalChecked();
+      exception = v8::Exception::Error(string);
+    }
+    return RefImpl<Trap>::make(store, v8::Local<v8::Object>::Cast(exception));
+  }
+
+  auto val = maybe_val.ToLocalChecked();
+  if (result_types.size() == 0) {
+    assert(val->IsUndefined());
+  } else if (result_types.size() == 1) {
+    assert(!val->IsUndefined());
+    new (&results[0]) Val(v8_to_val(store, val, result_types[0].get()));
+  } else {
+    assert(val->IsArray());
+    auto array = v8::Handle<v8::Array>::Cast(val);
+    for (size_t i = 0; i < result_types.size(); ++i) {
+      auto maybe = array->Get(context, i);
+      assert(!maybe.IsEmpty());
+      new (&results[i]) Val(v8_to_val(
+        store, maybe.ToLocalChecked(), result_types[i].get()));
+    }
+  }
+  return nullptr;
+}
+
+void FuncData::v8_callback(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  auto v8_data = v8::Local<v8::Object>::Cast(info.Data());
+  auto self = reinterpret_cast<FuncData*>(wasm_v8::foreign_get(v8_data));
+  auto store = impl(self->store);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  auto& param_types = self->type->params();
+  auto& result_types = self->type->results();
+
+  assert(param_types.size() == info.Length());
+
+  // TODO: cache params and result arrays per thread.
+  auto args = vec<Val>::make_uninitialized(param_types.size());
+  auto results = vec<Val>::make_uninitialized(result_types.size());
+  for (size_t i = 0; i < param_types.size(); ++i) {
+    args[i] = v8_to_val(store, info[i], param_types[i].get());
+  }
+
+  own<Trap> trap;
+  if (self->kind == CALLBACK_WITH_ENV) {
+    trap = self->callback_with_env(self->env, args, results);
+  } else {
+    trap = self->callback(args, results);
+  }
+
+  if (trap) {
+    isolate->ThrowException(impl(trap.get())->v8_object());
+    return;
+  }
+
+  auto ret = info.GetReturnValue();
+  if (result_types.size() == 0) {
+    ret.SetUndefined();
+  } else if (result_types.size() == 1) {
+    assert(results[0].kind() == result_types[0]->kind());
+    ret.Set(val_to_v8(store, results[0]));
+  } else {
+    auto context = store->context();
+    auto array = v8::Array::New(isolate, result_types.size());
+    for (size_t i = 0; i < result_types.size(); ++i) {
+      auto success = array->Set(context, i, val_to_v8(store, results[i]));
+      assert(success.IsJust() && success.ToChecked());
+    }
+    ret.Set(array);
+  }
+}
+
+void FuncData::finalize_func_data(void* data) {
+  delete reinterpret_cast<FuncData*>(data);
+}
+
+
+// Global Instances
+
+template<> struct implement<Global> { using type = RefImpl<Global>; };
+
+
+Global::~Global() {}
+
+auto Global::copy() const -> own<Global> {
+  return impl(this)->copy();
+}
+
+auto Global::make(
+  Store* store_abs, const GlobalType* type, const Val& val
+) -> own<Global> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+  auto context = store->context();
+
+  assert(type->content()->kind() == val.kind());
+
+  // Create wrapper instance
+  auto binary = wasm::bin::wrapper(type);
+  auto module = Module::make(store_abs, binary);
+
+  v8::Local<v8::Value> instantiate_args[] = { impl(module.get())->v8_object() };
+  auto instance_obj = store->v8_function(V8_F_INSTANCE)->NewInstance(
+    context, 1, instantiate_args).ToLocalChecked();
+  auto exports_obj = wasm_v8::instance_exports(instance_obj);
+  auto obj = v8::Local<v8::Object>::Cast(
+    exports_obj->Get(context, store->v8_string(V8_S_EMPTY)).ToLocalChecked());
+  assert(!obj.IsEmpty() && obj->IsObject());
+
+  auto global = RefImpl<Global>::make(store, obj);
+  assert(global);
+  global->set(val);
+  return global;
+}
+
+auto Global::type() const -> own<GlobalType> {
+  // return impl(this)->data->type->copy();
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto v8_global = impl(this)->v8_object();
+  auto kind = static_cast<ValKind>(wasm_v8::global_type_content(v8_global));
+  auto mutability = wasm_v8::global_type_mutable(v8_global)
+    ? Mutability::VAR : Mutability::CONST;
+  return GlobalType::make(ValType::make(kind), mutability);
+}
+
+auto Global::get() const -> Val {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto v8_global = impl(this)->v8_object();
+  switch (type()->content()->kind()) {
+    case ValKind::I32: return Val(wasm_v8::global_get_i32(v8_global));
+    case ValKind::I64: return Val(wasm_v8::global_get_i64(v8_global));
+    case ValKind::F32: return Val(wasm_v8::global_get_f32(v8_global));
+    case ValKind::F64: return Val(wasm_v8::global_get_f64(v8_global));
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: {
+      auto store = impl(this)->store();
+      return Val(v8_to_ref(store, wasm_v8::global_get_ref(v8_global)));
+    }
+    default:
+      assert(false);
+  }
+}
+
+void Global::set(const Val& val) {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto v8_global = impl(this)->v8_object();
+  switch (val.kind()) {
+    case ValKind::I32: return wasm_v8::global_set_i32(v8_global, val.i32());
+    case ValKind::I64: return wasm_v8::global_set_i64(v8_global, val.i64());
+    case ValKind::F32: return wasm_v8::global_set_f32(v8_global, val.f32());
+    case ValKind::F64: return wasm_v8::global_set_f64(v8_global, val.f64());
+    case ValKind::ANYREF:
+    case ValKind::FUNCREF: {
+      auto store = impl(this)->store();
+      return wasm_v8::global_set_ref(v8_global, ref_to_v8(store, val.ref()));
+    }
+    default:
+      assert(false);
+  }
+}
+
+
+// Table Instances
+
+template<> struct implement<Table> { using type = RefImpl<Table>; };
+
+
+Table::~Table() {}
+
+auto Table::copy() const -> own<Table> {
+  return impl(this)->copy();
+}
+
+auto Table::make(
+  Store* store_abs, const TableType* type, const Ref* ref
+) -> own<Table> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+  auto context = store->context();
+
+  v8::Local<v8::Value> init = v8::Null(isolate);
+  if (ref) init = impl(ref)->v8_object();
+  v8::Local<v8::Value> args[] = {tabletype_to_v8(store, type), init};
+  auto maybe_obj =
+    store->v8_function(V8_F_TABLE)->NewInstance(context, 2, args);
+  if (maybe_obj.IsEmpty()) return own<Table>();
+  auto table = RefImpl<Table>::make(store, maybe_obj.ToLocalChecked());
+  // TODO(wasm+): pass reference initialiser as parameter
+  if (table && ref) {
+    auto size = type->limits().min;
+    auto obj = maybe_obj.ToLocalChecked();
+    for (size_t i = 0; i < size; ++i) {
+      wasm_v8::table_set(obj, i, v8::Local<v8::Value>::Cast(init));
+    }
+  }
+  return table;
+}
+
+auto Table::type() const -> own<TableType> {
+  // return impl(this)->data->type->copy();
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto v8_table = impl(this)->v8_object();
+  uint32_t min = wasm_v8::table_type_min(v8_table);
+  uint32_t max = wasm_v8::table_type_max(v8_table);
+  // TODO(wasm+): support new element types.
+  return TableType::make(ValType::make(ValKind::FUNCREF), Limits(min, max));
+}
+
+auto Table::get(size_t index) const -> own<Ref> {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto maybe = wasm_v8::table_get(impl(this)->v8_object(), index);
+  if (maybe.IsEmpty()) return own<Ref>();
+  auto obj = v8::Local<v8::Object>::Cast(maybe.ToLocalChecked());
+  return v8_to_ref(impl(this)->store(), obj);
+}
+
+auto Table::set(size_t index, const Ref* ref) -> bool {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto val = ref_to_v8(impl(this)->store(), ref);
+  return wasm_v8::table_set(impl(this)->v8_object(), index, val);
+}
+
+auto Table::size() const -> size_t {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::table_size(impl(this)->v8_object());
+}
+
+auto Table::grow(size_t delta, const Ref* ref) -> bool {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto val = ref_to_v8(impl(this)->store(), ref);
+  return wasm_v8::table_grow(impl(this)->v8_object(), delta, val);
+}
+
+
+// Memory Instances
+
+template<> struct implement<Memory> { using type = RefImpl<Memory>; };
+
+
+Memory::~Memory() {}
+
+auto Memory::copy() const -> own<Memory> {
+  return impl(this)->copy();
+}
+
+auto Memory::make(Store* store_abs, const MemoryType* type) -> own<Memory> {
+  auto store = impl(store_abs);
+  auto isolate = store->isolate();
+  v8::HandleScope handle_scope(isolate);
+  auto context = store->context();
+
+  v8::Local<v8::Value> args[] = { memorytype_to_v8(store, type) };
+  auto maybe_obj =
+    store->v8_function(V8_F_MEMORY)->NewInstance(context, 1, args);
+  if (maybe_obj.IsEmpty()) return own<Memory>();
+  return RefImpl<Memory>::make(store, maybe_obj.ToLocalChecked());
+}
+
+auto Memory::type() const -> own<MemoryType> {
+  // return impl(this)->data->type->copy();
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  auto v8_memory = impl(this)->v8_object();
+  uint32_t min = wasm_v8::memory_type_min(v8_memory);
+  uint32_t max = wasm_v8::memory_type_max(v8_memory);
+  return MemoryType::make(Limits(min, max));
+}
+
+auto Memory::data() const -> byte_t* {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::memory_data(impl(this)->v8_object());
+}
+
+auto Memory::data_size() const -> size_t {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::memory_data_size(impl(this)->v8_object());
+}
+
+auto Memory::size() const -> pages_t {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::memory_size(impl(this)->v8_object());
+}
+
+auto Memory::grow(pages_t delta) -> bool {
+  v8::HandleScope handle_scope(impl(this)->isolate());
+  return wasm_v8::memory_grow(impl(this)->v8_object(), delta);
+}
+
+
+// Module Instances
+
+template<> struct implement<Instance> { using type = RefImpl<Instance>; };
+
+
+Instance::~Instance() {}
+
+auto Instance::copy() const -> own<Instance> {
+  return impl(this)->copy();
+}
+
+auto Instance::make(
+  Store* store_abs, const Module* module_abs, const vec<Extern*>& imports,
+  own<Trap>* trap
+) -> own<Instance> {
+  auto store = impl(store_abs);
+  auto module = impl(module_abs);
+  auto isolate = store->isolate();
+  auto context = store->context();
+  v8::HandleScope handle_scope(isolate);
+
+  assert(wasm_v8::object_isolate(module->v8_object()) == isolate);
+
+  if (trap) *trap = nullptr;
+  auto import_types = module_abs->imports();
+  auto imports_obj = v8::Object::New(isolate);
+  for (size_t i = 0; i < import_types.size(); ++i) {
+    auto type = import_types[i].get();
+    auto maybe_module = v8::String::NewFromOneByte(
+      isolate, reinterpret_cast<const uint8_t*>(type->module().get()),
+      v8::NewStringType::kNormal, type->module().size()
+    );
+    if (maybe_module.IsEmpty()) return own<Instance>();
+    auto module_str = maybe_module.ToLocalChecked();
+    auto maybe_name = v8::String::NewFromOneByte(
+      isolate, reinterpret_cast<const uint8_t*>(type->name().get()),
+      v8::NewStringType::kNormal, type->name().size()
+    );
+    if (maybe_name.IsEmpty()) return own<Instance>();
+    auto name_str = maybe_name.ToLocalChecked();
+
+    v8::Local<v8::Object> module_obj;
+    if (imports_obj->HasOwnProperty(context, module_str).ToChecked()) {
+      module_obj = v8::Local<v8::Object>::Cast(
+        imports_obj->Get(context, module_str).ToLocalChecked());
+    } else {
+      module_obj = v8::Object::New(isolate);
+      ignore(imports_obj->DefineOwnProperty(context, module_str, module_obj));
+    }
+
+    ignore(module_obj->DefineOwnProperty(
+      context, name_str, extern_to_v8(imports[i])));
+  }
+
+  v8::TryCatch handler(isolate);
+  v8::Local<v8::Value> instantiate_args[] = {module->v8_object(), imports_obj};
+  auto obj = store->v8_function(V8_F_INSTANCE)->NewInstance(
+    context, 2, instantiate_args).ToLocalChecked();
+
+  if (handler.HasCaught() && trap) {
+    auto exception = handler.Exception();
+    if (!exception->IsObject()) {
+      auto maybe_string = exception->ToString(store->context());
+      auto string = maybe_string.IsEmpty()
+        ? store->v8_string(V8_S_EMPTY) : maybe_string.ToLocalChecked();
+      exception = v8::Exception::Error(string);
+    }
+    *trap = RefImpl<Trap>::make(store, v8::Local<v8::Object>::Cast(exception));
+    return nullptr;
+  }
+
+  return RefImpl<Instance>::make(store, obj);
+}
+
+auto Instance::exports() const -> ownvec<Extern> {
+  auto instance = impl(this);
+  auto store = instance->store();
+  auto isolate = store->isolate();
+  auto context = store->context();
+  v8::HandleScope handle_scope(isolate);
+
+  auto module_obj = wasm_v8::instance_module(instance->v8_object());
+  auto exports_obj = wasm_v8::instance_exports(instance->v8_object());
+  assert(!module_obj.IsEmpty() && module_obj->IsObject());
+  assert(!exports_obj.IsEmpty() && exports_obj->IsObject());
+
+  auto module = RefImpl<Module>::make(store, module_obj);
+  auto export_types = module->exports();
+  auto exports = ownvec<Extern>::make_uninitialized(export_types.size());
+  if (!exports) return ownvec<Extern>::invalid();
+
+  for (size_t i = 0; i < export_types.size(); ++i) {
+    auto& name = export_types[i]->name();
+    auto maybe_name_obj = v8::String::NewFromUtf8(isolate, name.get(),
+      v8::NewStringType::kNormal, name.size());
+    if (maybe_name_obj.IsEmpty()) return ownvec<Extern>::invalid();
+    auto name_obj = maybe_name_obj.ToLocalChecked();
+    auto obj = v8::Local<v8::Object>::Cast(
+      exports_obj->Get(context, name_obj).ToLocalChecked());
+
+    auto type = export_types[i]->type();
+    switch (type->kind()) {
+      case ExternKind::FUNC: {
+        assert(wasm_v8::extern_kind(obj) == wasm_v8::EXTERN_FUNC);
+        exports[i] = RefImpl<Func>::make(store, obj);
+      } break;
+      case ExternKind::GLOBAL: {
+        assert(wasm_v8::extern_kind(obj) == wasm_v8::EXTERN_GLOBAL);
+        exports[i] = RefImpl<Global>::make(store, obj);
+      } break;
+      case ExternKind::TABLE: {
+        assert(wasm_v8::extern_kind(obj) == wasm_v8::EXTERN_TABLE);
+        exports[i] = RefImpl<Table>::make(store, obj);
+      } break;
+      case ExternKind::MEMORY: {
+        assert(wasm_v8::extern_kind(obj) == wasm_v8::EXTERN_MEMORY);
+        exports[i] = RefImpl<Memory>::make(store, obj);
+      } break;
+    }
+  }
+
+  return exports;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace wasm
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm.h b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm.h
new file mode 100644
index 0000000..1582dd0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasm.h
@@ -0,0 +1,50 @@
+// This header file is used only for test purposes! It is used by unit
+// test inside the `src/` directory for the moment.
+
+#ifndef TEST_WASM
+#define TEST_WASM
+
+#include "../wasm.h"
+#include "../wasmer.h"
+#include <stdio.h>
+#include <string.h>
+
+#if defined(_WIN32) || defined(_WIN64)
+#define strtok_r strtok_s
+#endif
+
+wasm_engine_t *wasm_engine_new() {
+  wasm_config_t *config = wasm_config_new();
+
+  char *wasmer_test_compiler = getenv("WASMER_CAPI_CONFIG");
+  char *wasmer_test_engine;
+
+  strtok_r(wasmer_test_compiler, "-", &wasmer_test_engine);
+  printf("Using compiler: %s, engine: %s\n", wasmer_test_compiler,
+         wasmer_test_engine);
+  if (strcmp(wasmer_test_compiler, "cranelift") == 0) {
+    assert(wasmer_is_compiler_available(CRANELIFT));
+    wasm_config_set_compiler(config, CRANELIFT);
+  } else if (strcmp(wasmer_test_compiler, "llvm") == 0) {
+    assert(wasmer_is_compiler_available(LLVM));
+    wasm_config_set_compiler(config, LLVM);
+  } else if (strcmp(wasmer_test_compiler, "singlepass") == 0) {
+    assert(wasmer_is_compiler_available(SINGLEPASS));
+    wasm_config_set_compiler(config, SINGLEPASS);
+  } else if (wasmer_test_compiler) {
+    printf("Compiler %s not recognized\n", wasmer_test_compiler);
+    abort();
+  }
+  if (strcmp(wasmer_test_engine, "universal") == 0) {
+    assert(wasmer_is_engine_available(UNIVERSAL));
+    wasm_config_set_engine(config, UNIVERSAL);
+  } else if (wasmer_test_engine) {
+    printf("Engine %s not recognized\n", wasmer_test_engine);
+    abort();
+  }
+
+  wasm_engine_t *engine = wasm_engine_new_with_config(config);
+  return engine;
+}
+
+#endif
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
new file mode 100644
index 0000000..e359694
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "wasmer-c-api-test-runner"
+version = "4.2.8"
+edition = "2021"
+license = "MIT"
+description = "wasmer-c-api-test-runner"
+
+[dependencies]
+cc = "1.0"
+target-lexicon = "0.11"
+regex = "1.6"
+walkdir = "2.3.2"
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs
new file mode 100644
index 0000000..ffa6482
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer-c-api-test-runner/src/lib.rs
@@ -0,0 +1,451 @@
+#[cfg(test)]
+use std::error::Error;
+#[cfg(test)]
+use std::process::Stdio;
+
+#[cfg(test)]
+static INCLUDE_REGEX: &str = "#include \"(.*)\"";
+
+#[derive(Debug)]
+pub struct Config {
+    pub wasmer_dir: String,
+    pub root_dir: String,
+}
+
+impl Config {
+    pub fn get() -> Config {
+        let mut config = Config {
+            wasmer_dir: std::env::var("WASMER_DIR").unwrap_or_default(),
+            root_dir: std::env::var("ROOT_DIR").unwrap_or_default(),
+        };
+
+        let wasmer_base_dir = find_wasmer_base_dir();
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+
+        if config.wasmer_dir.is_empty() {
+            println!("manifest dir = {manifest_dir}, wasmer root dir = {wasmer_base_dir}");
+            config.wasmer_dir = wasmer_base_dir.clone() + "/package";
+            assert!(std::path::Path::new(&config.wasmer_dir).exists());
+        }
+        if config.root_dir.is_empty() {
+            config.root_dir = wasmer_base_dir + "/lib/c-api/tests";
+        }
+
+        config
+    }
+}
+
+fn find_wasmer_base_dir() -> String {
+    let wasmer_base_dir = env!("CARGO_MANIFEST_DIR");
+    let mut path2 = wasmer_base_dir.split("wasmer").collect::<Vec<_>>();
+    path2.pop();
+    let mut wasmer_base_dir = path2.join("wasmer");
+
+    if wasmer_base_dir.contains("wasmer/lib/c-api") {
+        wasmer_base_dir = wasmer_base_dir
+            .split("wasmer/lib/c-api")
+            .next()
+            .unwrap()
+            .to_string()
+            + "wasmer";
+    } else if wasmer_base_dir.contains("wasmer\\lib\\c-api") {
+        wasmer_base_dir = wasmer_base_dir
+            .split("wasmer\\lib\\c-api")
+            .next()
+            .unwrap()
+            .to_string()
+            + "wasmer";
+    }
+
+    wasmer_base_dir
+}
+
+#[derive(Default)]
+pub struct RemoveTestsOnDrop {}
+
+impl Drop for RemoveTestsOnDrop {
+    fn drop(&mut self) {
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        for entry in std::fs::read_dir(manifest_dir).unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            let extension = path.extension().and_then(|s| s.to_str());
+            if extension == Some("obj") || extension == Some("exe") || extension == Some("o") {
+                println!("removing {}", path.display());
+                let _ = std::fs::remove_file(&path);
+            }
+        }
+        if let Some(parent) = std::path::Path::new(&manifest_dir).parent() {
+            for entry in std::fs::read_dir(parent).unwrap() {
+                let entry = entry.unwrap();
+                let path = entry.path();
+                let extension = path.extension().and_then(|s| s.to_str());
+                if extension == Some("obj") || extension == Some("exe") || extension == Some("o") {
+                    println!("removing {}", path.display());
+                    let _ = std::fs::remove_file(&path);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+pub const CAPI_BASE_TESTS: &[&str] = &[
+    "wasm-c-api/example/callback",
+    "wasm-c-api/example/memory",
+    "wasm-c-api/example/start",
+    "wasm-c-api/example/global",
+    "wasm-c-api/example/reflect",
+    "wasm-c-api/example/trap",
+    "wasm-c-api/example/hello",
+    "wasm-c-api/example/serialize",
+    "wasm-c-api/example/multi",
+];
+
+#[allow(unused_variables, dead_code)]
+pub const CAPI_BASE_TESTS_NOT_WORKING: &[&str] = &[
+    "wasm-c-api/example/finalize",
+    "wasm-c-api/example/hostref",
+    "wasm-c-api/example/threads",
+    "wasm-c-api/example/table",
+];
+
+// Runs all the tests that are working in the /c directory
+#[test]
+fn test_ok() {
+    let _drop = RemoveTestsOnDrop::default();
+    let config = Config::get();
+    println!("config: {:#?}", config);
+
+    let manifest_dir = env!("CARGO_MANIFEST_DIR");
+    let host = target_lexicon::HOST.to_string();
+    let target = &host;
+
+    let wasmer_dll_dir = format!("{}/lib", config.wasmer_dir);
+    let libwasmer_so_path = format!("{}/lib/libwasmer.so", config.wasmer_dir);
+    let exe_dir = format!("{manifest_dir}/../wasm-c-api/example");
+    let path = std::env::var("PATH").unwrap_or_default();
+    let newpath = format!("{};{path}", wasmer_dll_dir.replace('/', "\\"));
+
+    if target.contains("msvc") {
+        for test in CAPI_BASE_TESTS.iter() {
+            let mut build = cc::Build::new();
+            let build = build
+                .cargo_metadata(false)
+                .warnings(true)
+                .static_crt(true)
+                .extra_warnings(true)
+                .warnings_into_errors(false)
+                .debug(true)
+                .host(&host)
+                .target(target)
+                .opt_level(1);
+
+            let compiler = build.try_get_compiler().unwrap();
+
+            println!("compiler {:#?}", compiler);
+
+            // run vcvars
+            let vcvars_bat_path = find_vcvars64(&compiler).expect("no vcvars64.bat");
+            let mut vcvars = std::process::Command::new("cmd");
+            vcvars.arg("/C");
+            vcvars.arg(vcvars_bat_path);
+            println!("running {vcvars:?}");
+
+            // cmd /C vcvars64.bat
+            let output = vcvars
+                .output()
+                .expect("could not invoke vcvars64.bat at {vcvars_bat_path}");
+
+            if !output.status.success() {
+                println!();
+                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                // print_wasmer_root_to_stdout(&config);
+                panic!("failed to invoke vcvars64.bat {test}");
+            }
+
+            let mut command = compiler.to_command();
+
+            command.arg(&format!("{manifest_dir}/../{test}.c"));
+            if !config.wasmer_dir.is_empty() {
+                command.arg("/I");
+                command.arg(&format!("{}/wasm-c-api/include/", config.root_dir));
+                command.arg("/I");
+                command.arg(&format!("{}/include/", config.wasmer_dir));
+                let mut log = String::new();
+                fixup_symlinks(
+                    &[
+                        format!("{}/include/", config.wasmer_dir),
+                        format!("{}/wasm-c-api/include/", config.root_dir),
+                        config.root_dir.to_string(),
+                    ],
+                    &mut log,
+                    &config.root_dir,
+                )
+                .unwrap_or_else(|_| panic!("failed to fix symlinks: {log}"));
+                println!("{log}");
+            }
+            command.arg("/link");
+            if !config.wasmer_dir.is_empty() {
+                command.arg(&format!("/LIBPATH:{}/lib", config.wasmer_dir));
+                command.arg(&format!("{}/lib/wasmer.dll.lib", config.wasmer_dir));
+            }
+            command.arg(&format!("/OUT:{manifest_dir}/../{test}.exe"));
+
+            println!("compiling {test}: {command:?}");
+
+            // compile
+            let output = command
+                .output()
+                .unwrap_or_else(|_| panic!("failed to compile {command:#?}"));
+            if !output.status.success() {
+                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                println!("output: {:#?}", output);
+                // print_wasmer_root_to_stdout(&config);
+                panic!("failed to compile {test}");
+            }
+
+            if std::path::Path::new(&format!("{manifest_dir}/../{test}.exe")).exists() {
+                println!("exe does not exist");
+            }
+
+            // execute
+            let mut command = std::process::Command::new(&format!("{manifest_dir}/../{test}.exe"));
+            println!("newpath: {}", newpath.clone());
+            command.env("PATH", newpath.clone());
+            command.current_dir(exe_dir.clone());
+            println!("executing {test}: {command:?}");
+            println!("setting current dir = {exe_dir}");
+            let output = command
+                .output()
+                .unwrap_or_else(|_| panic!("failed to run {command:#?}"));
+            if !output.status.success() {
+                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                println!("output: {:#?}", output);
+                // print_wasmer_root_to_stdout(&config);
+                panic!("failed to execute {test}");
+            }
+
+            // cc -g -IC:/Users/felix/Development/wasmer/lib/c-api/tests/
+            //          -IC:/Users/felix/Development/wasmer/package/include
+            //
+            //          -Wl,-rpath,C:/Users/felix/Development/wasmer/package/lib
+            //
+            //          wasm-c-api/example/callback.c
+            //
+            //          -LC:/Users/felix/Development/wasmer/package/lib -lwasmer
+            //
+            // -o wasm-c-api/example/callback
+        }
+    } else {
+        for test in CAPI_BASE_TESTS.iter() {
+            let compiler_cmd = match std::process::Command::new("cc").output() {
+                Ok(_) => "cc",
+                Err(_) => "gcc",
+            };
+            let mut command = std::process::Command::new(compiler_cmd);
+
+            if !config.wasmer_dir.is_empty() {
+                command.arg("-I");
+                command.arg(&format!("{}/wasm-c-api/include/", config.root_dir));
+                command.arg("-I");
+                command.arg(&format!("{}/include/", config.wasmer_dir));
+                let mut log = String::new();
+                fixup_symlinks(
+                    &[
+                        format!("{}/include/", config.wasmer_dir),
+                        format!("{}/wasm-c-api/include/", config.root_dir),
+                        config.root_dir.to_string(),
+                    ],
+                    &mut log,
+                    &config.root_dir,
+                )
+                .unwrap_or_else(|_| panic!("failed to fix symlinks: {log}"));
+            }
+            command.arg(&format!("{manifest_dir}/../{test}.c"));
+            if !config.wasmer_dir.is_empty() {
+                command.arg("-L");
+                command.arg(&format!("{}/lib/", config.wasmer_dir));
+                command.arg("-lwasmer");
+                command.arg(&format!("-Wl,-rpath,{}/lib/", config.wasmer_dir));
+            }
+            command.arg("-o");
+            command.arg(&format!("{manifest_dir}/../{test}"));
+
+            // print_wasmer_root_to_stdout(&config);
+
+            println!("compile: {command:#?}");
+            // compile
+            let output = command
+                .stdout(Stdio::inherit())
+                .stderr(Stdio::inherit())
+                .current_dir(find_wasmer_base_dir())
+                .output()
+                .unwrap_or_else(|_| panic!("failed to compile {command:#?}"));
+            if !output.status.success() {
+                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                // print_wasmer_root_to_stdout(&config);
+                panic!("failed to compile {test}: {command:#?}");
+            }
+
+            // execute
+            let mut command = std::process::Command::new(&format!("{manifest_dir}/../{test}"));
+            command.env("LD_PRELOAD", libwasmer_so_path.clone());
+            command.current_dir(exe_dir.clone());
+            println!("execute: {command:#?}");
+            let output = command
+                .output()
+                .unwrap_or_else(|_| panic!("failed to run {command:#?}"));
+            if !output.status.success() {
+                println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+                println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+                // print_wasmer_root_to_stdout(&config);
+                panic!("failed to execute {test}: {command:#?}");
+            }
+        }
+    }
+
+    for test in CAPI_BASE_TESTS.iter() {
+        let _ = std::fs::remove_file(&format!("{manifest_dir}/{test}.obj"));
+        let _ = std::fs::remove_file(&format!("{manifest_dir}/../{test}.exe"));
+        let _ = std::fs::remove_file(&format!("{manifest_dir}/../{test}"));
+    }
+}
+
+#[cfg(test)]
+fn print_wasmer_root_to_stdout(config: &Config) {
+    println!("print_wasmer_root_to_stdout");
+
+    use walkdir::WalkDir;
+
+    println!(
+        "wasmer dir: {}",
+        std::path::Path::new(&config.wasmer_dir)
+            .canonicalize()
+            .unwrap()
+            .display()
+    );
+
+    for entry in WalkDir::new(&config.wasmer_dir)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        let f_name = String::from(entry.path().canonicalize().unwrap().to_string_lossy());
+        println!("{f_name}");
+    }
+
+    println!(
+        "root dir: {}",
+        std::path::Path::new(&config.root_dir)
+            .canonicalize()
+            .unwrap()
+            .display()
+    );
+
+    for entry in WalkDir::new(&config.root_dir)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        let f_name = String::from(entry.path().canonicalize().unwrap().to_string_lossy());
+        println!("{f_name}");
+    }
+
+    println!("printed");
+}
+
+#[cfg(test)]
+fn fixup_symlinks(
+    include_paths: &[String],
+    log: &mut String,
+    root_dir: &str,
+) -> Result<(), Box<dyn Error>> {
+    let source = std::path::Path::new(root_dir)
+        .join("lib")
+        .join("c-api")
+        .join("tests")
+        .join("wasm-c-api")
+        .join("include")
+        .join("wasm.h");
+    let target = std::path::Path::new(root_dir)
+        .join("lib")
+        .join("c-api")
+        .join("tests")
+        .join("wasm.h");
+    println!("copying {} -> {}", source.display(), target.display());
+    let _ = std::fs::copy(source, target);
+
+    log.push_str(&format!("include paths: {include_paths:?}"));
+    for i in include_paths {
+        let i = i.replacen("-I", "", 1);
+        let i = i.replacen("/I", "", 1);
+        let mut paths_headers = Vec::new();
+        let readdir = match std::fs::read_dir(&i) {
+            Ok(o) => o,
+            Err(_) => continue,
+        };
+        for entry in readdir {
+            let entry = entry?;
+            let path = entry.path();
+            let path_display = format!("{}", path.display());
+            if path_display.ends_with('h') {
+                paths_headers.push(path_display);
+            }
+        }
+        fixup_symlinks_inner(&paths_headers, log)?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+fn fixup_symlinks_inner(include_paths: &[String], log: &mut String) -> Result<(), Box<dyn Error>> {
+    log.push_str(&format!("fixup symlinks: {include_paths:#?}"));
+    let regex = regex::Regex::new(INCLUDE_REGEX).unwrap();
+    for path in include_paths.iter() {
+        let file = match std::fs::read_to_string(path) {
+            Ok(o) => o,
+            _ => continue,
+        };
+        let lines_3 = file.lines().take(3).collect::<Vec<_>>();
+        log.push_str(&format!("first 3 lines of {path:?}: {:#?}\n", lines_3));
+
+        let parent = std::path::Path::new(&path).parent().unwrap();
+        if let Ok(symlink) = std::fs::read_to_string(parent.join(&file)) {
+            log.push_str(&format!("symlinking {path:?}\n"));
+            std::fs::write(path, symlink)?;
+        }
+
+        // follow #include directives and recurse
+        let filepaths = regex
+            .captures_iter(&file)
+            .map(|c| c[1].to_string())
+            .collect::<Vec<_>>();
+        log.push_str(&format!("regex captures: ({path:?}): {:#?}\n", filepaths));
+        let joined_filepaths = filepaths
+            .iter()
+            .map(|s| {
+                let path = parent.join(s);
+                format!("{}", path.display())
+            })
+            .collect::<Vec<_>>();
+        fixup_symlinks_inner(&joined_filepaths, log)?;
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+fn find_vcvars64(compiler: &cc::Tool) -> Option<String> {
+    if !compiler.is_like_msvc() {
+        return None;
+    }
+
+    let path = compiler.path();
+    let path = format!("{}", path.display());
+    let split = path.split("VC").next()?;
+
+    Some(format!("{split}VC\\Auxiliary\\Build\\vcvars64.bat"))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer.h b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer.h
new file mode 100644
index 0000000..3247ece
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/tests/wasmer.h
@@ -0,0 +1,25 @@
+// This header file is used only for test purposes! It is used by unit
+// test inside the `src/` directory for the moment.
+
+#ifndef TEST_WASMER
+#define TEST_WASMER
+
+#include "../wasmer.h"
+#include "wasm.h"
+#include <stdio.h>
+#include <string.h>
+
+// Assert that a `wasm_name_t` equals something.
+void wasmer_assert_name(const wasm_name_t *name, const char *expected) {
+  assert(name->size == strlen(expected) &&
+         strncmp(name->data, expected, name->size) == 0);
+}
+
+// Helper to quickly create a `wasm_byte_vec_t` from a string, à la
+// `wasm_name_new_from_string`.
+static inline void wasmer_byte_vec_new_from_string(wasm_byte_vec_t *out,
+                                                   const char *s) {
+  wasm_byte_vec_new(out, strlen(s), s);
+}
+
+#endif /* TEST_WASMER */
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/wasm.h b/arbitrator/tools/module_roots/wasmer/lib/c-api/wasm.h
new file mode 120000
index 0000000..14a5311
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/wasm.h
@@ -0,0 +1 @@
+tests/wasm-c-api/include/wasm.h
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/c-api/wasmer_wasm.h b/arbitrator/tools/module_roots/wasmer/lib/c-api/wasmer_wasm.h
new file mode 100644
index 0000000..d41ff3c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/c-api/wasmer_wasm.h
@@ -0,0 +1,3 @@
+#include "wasmer.h"
+
+#pragma message "The wasmer_wasm.h header file is being deprecated, please use wasmer.h instead."
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/Cargo.toml
new file mode 100644
index 0000000..3539f06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/Cargo.toml
@@ -0,0 +1,83 @@
+[package]
+name = "wasmer-compiler-cli"
+description = "Wasmer Compiler CLI"
+categories = ["wasm", "command-line-interface"]
+keywords = ["wasm", "webassembly", "cli"]
+readme = "README.md"
+default-run = "wasmer-compiler"
+build = "build.rs"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[[bin]]
+name = "wasmer-compiler"
+path = "src/bin/wasmer_compiler.rs"
+doc = false
+
+[dependencies]
+wasmer-compiler = { version = "=4.2.8", path = "../compiler", features = ["compiler"] }
+wasmer-types = { version = "=4.2.8", path = "../types" }
+is-terminal = "0.4.7"
+colored = "2.0"
+anyhow = "1.0"
+# For the function names autosuggestion
+distance = "0.4"
+# For the inspect subcommand
+bytesize = "1.0"
+cfg-if = "1.0"
+# For debug feature
+fern = { version = "0.6", features = ["colored"], optional = true }
+log = { version = "0.4", optional = true }
+target-lexicon = { version = "0.12", features = ["std"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+wasmer-compiler-singlepass = { version = "=4.2.8", path = "../compiler-singlepass", optional = true }
+wasmer-compiler-cranelift = { version = "=4.2.8", path = "../compiler-cranelift", optional = true }
+clap = { version = "4.2.8", features = ["derive", "env"] }
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+wasmer-compiler-singlepass = { version = "=4.2.8", path = "../compiler-singlepass", optional = true, default-features = false, features = ["wasm"] }
+wasmer-compiler-cranelift = { version = "=4.2.8", path = "../compiler-cranelift", optional = true, default-features = false, features = ["wasm"] }
+# NOTE: Must use different features for clap because the "color" feature does not
+# work on wasi, due to the anstream dependency not compiling.
+clap = { version = "4.2.8", default-features = false, features = [
+  "std",
+  "help",
+  "usage",
+  "error-context",
+  "suggestions",
+  "derive",
+  "env",
+]}
+
+[target.'cfg(target_os = "linux")'.dependencies]
+unix_mode = "0.1.3"
+
+[features]
+# Don't add the compiler features in default, please add them on the Makefile
+# since we might want to autoconfigure them depending on the availability on the host.
+default = []
+engine = []
+compiler = [
+    "wasmer-compiler/translator",
+    "wasmer-compiler/compiler",
+]
+singlepass = [
+    "wasmer-compiler-singlepass",
+    "compiler",
+]
+cranelift = [
+    "wasmer-compiler-cranelift",
+    "compiler",
+]
+debug = ["fern", "log"]
+disable-all-logging = []
+jit = []
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/README.md b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/README.md
new file mode 100644
index 0000000..0b53d49
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/README.md
@@ -0,0 +1,31 @@
+# `wasmer-cli-compiler` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate is the Wasmer Compiler only CLI.
+
+
+## Features
+
+The Compiler only Wasmer supports the following features:
+* `wasi` (default): support for [WASI].
+* `emscripten` (default): support for [Emscripten].
+* `singlepass`: support for the [Singlepass compiler].
+
+[WASI]: https://github.com/wasmerio/wasmer/tree/master/lib/wasi/
+[Emscripten]: https://github.com/wasmerio/wasmer/tree/master/lib/emscripten/
+[Singlepass compiler]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass/
+
+## CLI commands
+
+Once you have Wasmer installed, you can start executing WebAssembly files easily:
+
+Get the current Wasmer version:
+
+```bash
+wasmer-compiler -V
+```
+
+Compile a WebAssembly file:
+
+```bash
+wasmer-compiler compile myfile.wasm -o myfile.wasmu --singlepass
+```
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/build.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/build.rs
new file mode 100644
index 0000000..36fe647
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/build.rs
@@ -0,0 +1,4 @@
+pub fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-env-changed=WASMER_INSTALL_PREFIX");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/bin/wasmer_compiler.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/bin/wasmer_compiler.rs
new file mode 100644
index 0000000..ba0f2e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/bin/wasmer_compiler.rs
@@ -0,0 +1,8 @@
+use wasmer_compiler_cli::cli::wasmer_main;
+
+#[cfg(feature = "run")]
+compile_error!("Cannot enable run with the compile-only build");
+
+fn main() {
+    wasmer_main();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/cli.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/cli.rs
new file mode 100644
index 0000000..c67e2df
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/cli.rs
@@ -0,0 +1,75 @@
+//! The logic for the Wasmer CLI tool.
+
+use crate::commands::Compile;
+use crate::commands::{Config, Validate};
+use crate::error::PrettyError;
+use anyhow::Result;
+
+use clap::{error::ErrorKind, Parser};
+
+#[derive(Parser)]
+#[clap(
+    name = "wasmer-compiler",
+    about = "WebAssembly standalone Compiler.",
+    author
+)]
+/// The options for the wasmer Command Line Interface
+enum WasmerCLIOptions {
+    /// Validate a WebAssembly binary
+    #[clap(name = "validate")]
+    Validate(Validate),
+
+    /// Compile a WebAssembly binary
+    #[clap(name = "compile")]
+    Compile(Compile),
+
+    /// Get various configuration information needed
+    /// to compile programs which use Wasmer
+    #[clap(name = "config")]
+    Config(Config),
+}
+
+impl WasmerCLIOptions {
+    fn execute(&self) -> Result<()> {
+        match self {
+            Self::Validate(validate) => validate.execute(),
+            Self::Compile(compile) => compile.execute(),
+            Self::Config(config) => config.execute(),
+        }
+    }
+}
+
+/// The main function for the Wasmer CLI tool.
+pub fn wasmer_main() {
+    // We allow windows to print properly colors
+    #[cfg(windows)]
+    colored::control::set_virtual_terminal(true).unwrap();
+
+    // We try to run wasmer with the normal arguments.
+    // Eg. `wasmer <SUBCOMMAND>`
+    // In case that fails, we fallback trying the Run subcommand directly.
+    // Eg. `wasmer myfile.wasm --dir=.`
+    //
+    // In case we've been run as wasmer-binfmt-interpreter myfile.wasm args,
+    // we assume that we're registered via binfmt_misc
+    let args = std::env::args().collect::<Vec<_>>();
+    let command = args.get(1);
+    let options = {
+        match command.unwrap_or(&"".to_string()).as_ref() {
+            "compile" | "config" | "help" | "inspect" | "validate" => WasmerCLIOptions::parse(),
+            _ => {
+                WasmerCLIOptions::try_parse_from(args.iter()).unwrap_or_else(|e| {
+                    match e.kind() {
+                        // This fixes a issue that:
+                        // 1. Shows the version twice when doing `wasmer -V`
+                        // 2. Shows the run help (instead of normal help) when doing `wasmer --help`
+                        ErrorKind::DisplayVersion | ErrorKind::DisplayHelp => e.exit(),
+                        _ => WasmerCLIOptions::Compile(Compile::parse()),
+                    }
+                })
+            }
+        }
+    };
+
+    PrettyError::report(options.execute());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands.rs
new file mode 100644
index 0000000..7441883
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands.rs
@@ -0,0 +1,7 @@
+//! The commands available in the Wasmer binary.
+mod compile;
+mod config;
+mod validate;
+
+pub use compile::*;
+pub use {config::*, validate::*};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/compile.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/compile.rs
new file mode 100644
index 0000000..9ebccc9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/compile.rs
@@ -0,0 +1,118 @@
+use crate::store::StoreOptions;
+use crate::warning;
+use anyhow::{Context, Result};
+use clap::Parser;
+use std::fs;
+use std::path::{Path, PathBuf};
+use wasmer_compiler::{ArtifactBuild, ArtifactCreate, ModuleEnvironment};
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{
+    Architecture, CompileError, CpuFeature, MemoryIndex, MemoryStyle, TableIndex, TableStyle,
+    Target, Triple,
+};
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer compile` subcommand
+pub struct Compile {
+    /// Input file
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    /// Output file
+    #[clap(name = "OUTPUT PATH", short = 'o')]
+    output: PathBuf,
+
+    /// Compilation Target triple
+    #[clap(long = "target")]
+    target_triple: Option<Triple>,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+
+    #[clap(short = 'm')]
+    cpu_features: Vec<CpuFeature>,
+}
+
+impl Compile {
+    /// Runs logic for the `compile` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to compile `{}`", self.path.display()))
+    }
+
+    fn inner_execute(&self) -> Result<()> {
+        let target = self
+            .target_triple
+            .as_ref()
+            .map(|target_triple| {
+                let mut features = self
+                    .cpu_features
+                    .clone()
+                    .into_iter()
+                    .fold(CpuFeature::set(), |a, b| a | b);
+                // Cranelift requires SSE2, so we have this "hack" for now to facilitate
+                // usage
+                if target_triple.architecture == Architecture::X86_64 {
+                    features |= CpuFeature::SSE2;
+                }
+                Target::new(target_triple.clone(), features)
+            })
+            .unwrap_or_default();
+        let (engine_builder, compiler_type) = self.store.get_engine_for_target(target.clone())?;
+        let engine = engine_builder.engine();
+        let output_filename = self
+            .output
+            .file_stem()
+            .map(|osstr| osstr.to_string_lossy().to_string())
+            .unwrap_or_default();
+        // `.wasmu` is the default extension for all the triples. It
+        // stands for “Wasm Universal”.
+        let recommended_extension = "wasmu";
+        match self.output.extension() {
+            Some(ext) => {
+                if ext != recommended_extension {
+                    warning!("the output file has a wrong extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+                }
+            }
+            None => {
+                warning!("the output file has no extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+            }
+        }
+        let tunables = self.store.get_tunables_for_target(&target)?;
+
+        println!("Compiler: {}", compiler_type.to_string());
+        println!("Target: {}", target.triple());
+
+        // compile and save the artifact (without using module from api)
+        let path: &Path = self.path.as_ref();
+        let wasm_bytes = std::fs::read(path)?;
+        let environ = ModuleEnvironment::new();
+        let translation = environ.translate(&wasm_bytes).map_err(CompileError::Wasm)?;
+        let module = translation.module;
+        let memory_styles: PrimaryMap<MemoryIndex, MemoryStyle> = module
+            .memories
+            .values()
+            .map(|memory_type| tunables.memory_style(memory_type))
+            .collect();
+        let table_styles: PrimaryMap<TableIndex, TableStyle> = module
+            .tables
+            .values()
+            .map(|table_type| tunables.table_style(table_type))
+            .collect();
+        let artifact = ArtifactBuild::new(
+            &mut engine.inner_mut(),
+            &wasm_bytes,
+            &target,
+            memory_styles,
+            table_styles,
+        )?;
+        let serialized = artifact.serialize()?;
+        fs::write(output_filename, serialized)?;
+        eprintln!(
+            "✔ File compiled successfully to `{}`.",
+            self.output.display(),
+        );
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/config.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/config.rs
new file mode 100644
index 0000000..155fb0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/config.rs
@@ -0,0 +1,107 @@
+use crate::VERSION;
+use anyhow::{Context, Result};
+use clap::Parser;
+use std::env;
+use std::path::PathBuf;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer config` subcommand
+pub struct Config {
+    /// Print the installation prefix.
+    #[clap(long, conflicts_with = "pkg_config")]
+    prefix: bool,
+
+    /// Directory containing Wasmer executables.
+    #[clap(long, conflicts_with = "pkg_config")]
+    bindir: bool,
+
+    /// Directory containing Wasmer headers.
+    #[clap(long, conflicts_with = "pkg_config")]
+    includedir: bool,
+
+    /// Directory containing Wasmer libraries.
+    #[clap(long, conflicts_with = "pkg_config")]
+    libdir: bool,
+
+    /// Libraries needed to link against Wasmer components.
+    #[clap(long, conflicts_with = "pkg_config")]
+    libs: bool,
+
+    /// C compiler flags for files that include Wasmer headers.
+    #[clap(long, conflicts_with = "pkg_config")]
+    cflags: bool,
+
+    /// It outputs the necessary details for compiling
+    /// and linking a program to Wasmer, using the `pkg-config` format.
+    #[clap(long)]
+    pkg_config: bool,
+}
+
+impl Config {
+    /// Runs logic for the `config` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context("failed to retrieve the wasmer config".to_string())
+    }
+    fn inner_execute(&self) -> Result<()> {
+        let key = "WASMER_DIR";
+        let wasmer_dir = env::var(key)
+            .ok()
+            .or_else(|| option_env!("WASMER_INSTALL_PREFIX").map(str::to_string))
+            .or_else(|| {
+                // Allowing deprecated function home_dir since it works fine,
+                // and will never be removed from std.
+                #[allow(deprecated)]
+                let dir = std::env::home_dir()?.join(".wasmer").to_str()?.to_string();
+
+                Some(dir)
+            })
+            .context(format!(
+                "failed to retrieve the {} environment variables",
+                key
+            ))?;
+
+        let prefix = PathBuf::from(wasmer_dir);
+
+        let prefixdir = prefix.display().to_string();
+        let bindir = prefix.join("bin").display().to_string();
+        let includedir = prefix.join("include").display().to_string();
+        let libdir = prefix.join("lib").display().to_string();
+        let cflags = format!("-I{}", includedir);
+        let libs = format!("-L{} -lwasmer", libdir);
+
+        if self.pkg_config {
+            println!("prefix={}", prefixdir);
+            println!("exec_prefix={}", bindir);
+            println!("includedir={}", includedir);
+            println!("libdir={}", libdir);
+            println!();
+            println!("Name: wasmer");
+            println!("Description: The Wasmer library for running WebAssembly");
+            println!("Version: {}", VERSION);
+            println!("Cflags: {}", cflags);
+            println!("Libs: {}", libs);
+            return Ok(());
+        }
+
+        if self.prefix {
+            println!("{}", prefixdir);
+        }
+        if self.bindir {
+            println!("{}", bindir);
+        }
+        if self.includedir {
+            println!("{}", includedir);
+        }
+        if self.libdir {
+            println!("{}", libdir);
+        }
+        if self.libs {
+            println!("{}", libs);
+        }
+        if self.cflags {
+            println!("{}", cflags);
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/validate.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/validate.rs
new file mode 100644
index 0000000..c3c421f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/commands/validate.rs
@@ -0,0 +1,40 @@
+use crate::store::StoreOptions;
+use anyhow::{bail, Context, Result};
+use clap::Parser;
+use std::path::PathBuf;
+use std::str::FromStr;
+use wasmer_types::{is_wasm, CpuFeature, Target, Triple};
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer validate` subcommand
+pub struct Validate {
+    /// File to validate as WebAssembly
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+}
+
+impl Validate {
+    /// Runs logic for the `validate` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to validate `{}`", self.path.display()))
+    }
+    fn inner_execute(&self) -> Result<()> {
+        let target = Target::new(
+            Triple::from_str("x86_64-linux-gnu").unwrap(),
+            CpuFeature::SSE2 | CpuFeature::AVX,
+        );
+        let (engine_builder, _compiler_type) = self.store.get_engine_for_target(target)?;
+        let engine = engine_builder.engine();
+        let module_contents = std::fs::read(&self.path)?;
+        if !is_wasm(&module_contents) {
+            bail!("`wasmer validate` only validates WebAssembly files");
+        }
+        engine.validate(&module_contents)?;
+        eprintln!("Validation passed for `{}`.", self.path.display());
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/common.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/common.rs
new file mode 100644
index 0000000..81af031
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/common.rs
@@ -0,0 +1,53 @@
+//! Common module with common used structures across different
+//! commands.
+use crate::VERSION;
+use clap::Parser;
+use std::env;
+use std::path::PathBuf;
+
+#[derive(Debug, Parser, Clone, Default)]
+/// The WebAssembly features that can be passed through the
+/// Command Line args.
+pub struct WasmFeatures {
+    /// Enable support for the SIMD proposal.
+    #[clap(long = "enable-simd")]
+    pub simd: bool,
+
+    /// Enable support for the threads proposal.
+    #[clap(long = "enable-threads")]
+    pub threads: bool,
+
+    /// Enable support for the reference types proposal.
+    #[clap(long = "enable-reference-types")]
+    pub reference_types: bool,
+
+    /// Enable support for the multi value proposal.
+    #[clap(long = "enable-multi-value")]
+    pub multi_value: bool,
+
+    /// Enable support for the bulk memory proposal.
+    #[clap(long = "enable-bulk-memory")]
+    pub bulk_memory: bool,
+
+    /// Enable support for all pre-standard proposals.
+    #[clap(long = "enable-all")]
+    pub all: bool,
+}
+
+/// Get the cache dir
+pub fn get_cache_dir() -> PathBuf {
+    match env::var("WASMER_CACHE_DIR") {
+        Ok(dir) => {
+            let mut path = PathBuf::from(dir);
+            path.push(VERSION);
+            path
+        }
+        Err(_) => {
+            // We use a temporal directory for saving cache files
+            let mut temp_dir = env::temp_dir();
+            temp_dir.push("wasmer");
+            temp_dir.push(VERSION);
+            temp_dir
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/error.rs
new file mode 100644
index 0000000..f23b503
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/error.rs
@@ -0,0 +1,114 @@
+//! Implements `PretyError` to print pretty errors in the CLI (when they happen)
+
+use anyhow::{Chain, Error};
+use colored::*;
+use std::fmt::{self, Debug, Write};
+
+/// A `PrettyError` for printing `anyhow::Error` nicely.
+pub struct PrettyError {
+    error: Error,
+}
+
+/// A macro that prints a warning with nice colors
+#[macro_export]
+macro_rules! warning {
+    ($($arg:tt)*) => ({
+        use colored::*;
+        eprintln!("{}: {}", "warning".yellow().bold(), format!($($arg)*));
+    })
+}
+
+impl PrettyError {
+    /// Process a `Result` printing any errors and exiting
+    /// the process after
+    pub fn report<T>(result: Result<T, Error>) -> ! {
+        std::process::exit(match result {
+            Ok(_t) => 0,
+            Err(error) => {
+                eprintln!("{:?}", PrettyError { error });
+                1
+            }
+        });
+    }
+}
+
+impl Debug for PrettyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let error = &self.error;
+
+        if f.alternate() {
+            return Debug::fmt(&error, f);
+        }
+
+        write!(f, "{}", format!("{}: {}", "error".red(), error).bold())?;
+        // write!(f, "{}", error)?;
+
+        if let Some(cause) = error.source() {
+            // write!(f, "\n{}:", "caused by".bold().blue())?;
+            let chain = Chain::new(cause);
+            let (total_errors, _) = chain.size_hint();
+            for (n, error) in chain.enumerate() {
+                writeln!(f)?;
+                let mut indented = Indented {
+                    inner: f,
+                    number: Some(n + 1),
+                    is_last: n == total_errors - 1,
+                    started: false,
+                };
+                write!(indented, "{}", error)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+struct Indented<'a, D> {
+    inner: &'a mut D,
+    number: Option<usize>,
+    started: bool,
+    is_last: bool,
+}
+
+impl<T> Write for Indented<'_, T>
+where
+    T: Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for (i, line) in s.split('\n').enumerate() {
+            if !self.started {
+                self.started = true;
+                match self.number {
+                    Some(number) => {
+                        if !self.is_last {
+                            write!(
+                                self.inner,
+                                "{} {: >4} ",
+                                "│".bold().blue(),
+                                format!("{}:", number).dimmed()
+                            )?
+                        } else {
+                            write!(
+                                self.inner,
+                                "{}{: >2}: ",
+                                "╰─▶".bold().blue(),
+                                format!("{}", number).bold().blue()
+                            )?
+                        }
+                    }
+                    None => self.inner.write_str("    ")?,
+                }
+            } else if i > 0 {
+                self.inner.write_char('\n')?;
+                if self.number.is_some() {
+                    self.inner.write_str("       ")?;
+                } else {
+                    self.inner.write_str("    ")?;
+                }
+            }
+
+            self.inner.write_str(line)?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/lib.rs
new file mode 100644
index 0000000..7ee91da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/lib.rs
@@ -0,0 +1,30 @@
+//! The Wasmer binary lib
+
+#![deny(
+    missing_docs,
+    dead_code,
+    nonstandard_style,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[macro_use]
+extern crate anyhow;
+
+pub mod commands;
+pub mod common;
+#[macro_use]
+pub mod error;
+pub mod cli;
+#[cfg(feature = "debug")]
+pub mod logging;
+pub mod store;
+pub mod utils;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/logging.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/logging.rs
new file mode 100644
index 0000000..88ae282
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/logging.rs
@@ -0,0 +1,68 @@
+//! Logging functions for the debug feature.
+
+use anyhow::Result;
+use fern::colors::{Color, ColoredLevelConfig};
+use std::time;
+
+/// The debug level
+pub type DebugLevel = log::LevelFilter;
+
+/// Subroutine to instantiate the loggers
+pub fn set_up_logging(verbose: u8) -> Result<(), String> {
+    let colors_line = ColoredLevelConfig::new()
+        .error(Color::Red)
+        .warn(Color::Yellow)
+        .trace(Color::BrightBlack);
+    let should_color = crate::utils::wasmer_should_print_color();
+
+    let colors_level = colors_line.info(Color::Green);
+    let level = match verbose {
+        1 => DebugLevel::Debug,
+        _ => DebugLevel::Trace,
+    };
+    let dispatch = fern::Dispatch::new()
+        .level(level)
+        .chain({
+            let base = if should_color {
+                fern::Dispatch::new().format(move |out, message, record| {
+                    let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH).expect("Can't get time");
+                    out.finish(format_args!(
+                        "{color_line}[{seconds}.{millis} {level} {target}{color_line}]{ansi_close} {message}",
+                        color_line = format_args!(
+                            "\x1B[{}m",
+                            colors_line.get_color(&record.level()).to_fg_str()
+                        ),
+                        seconds = time.as_secs(),
+                        millis = time.subsec_millis(),
+                        level = colors_level.color(record.level()),
+                        target = record.target(),
+                        ansi_close = "\x1B[0m",
+                        message = message,
+                    ));
+                })
+            } else {
+                // default formatter without color
+                fern::Dispatch::new().format(move |out, message, record| {
+                    let time = time::SystemTime::now().duration_since(time::UNIX_EPOCH).expect("Can't get time");
+                    out.finish(format_args!(
+                        "[{seconds}.{millis} {level} {target}] {message}",
+                        seconds = time.as_secs(),
+                        millis = time.subsec_millis(),
+                        level = record.level(),
+                        target = record.target(),
+                        message = message,
+                    ));
+                })
+            };
+
+            base
+                .filter(|metadata| {
+                    metadata.target().starts_with("wasmer")
+                })
+                .chain(std::io::stdout())
+        });
+
+    dispatch.apply().map_err(|e| format!("{}", e))?;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/store.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/store.rs
new file mode 100644
index 0000000..370d59b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/store.rs
@@ -0,0 +1,383 @@
+//! Common module with common used structures across different
+//! commands.
+
+use crate::common::WasmFeatures;
+use anyhow::Result;
+use clap::Parser;
+use std::string::ToString;
+#[allow(unused_imports)]
+use std::sync::Arc;
+use wasmer_compiler::EngineBuilder;
+use wasmer_compiler::{CompilerConfig, Features};
+use wasmer_types::{MemoryStyle, MemoryType, Pages, PointerWidth, TableStyle, TableType, Target};
+
+/// Minimul Subset of Tunable parameters for WebAssembly compilation.
+#[derive(Clone)]
+pub struct SubsetTunables {
+    /// For static heaps, the size in wasm pages of the heap protected by bounds checking.
+    pub static_memory_bound: Pages,
+
+    /// The size in bytes of the offset guard for static heaps.
+    pub static_memory_offset_guard_size: u64,
+
+    /// The size in bytes of the offset guard for dynamic heaps.
+    pub dynamic_memory_offset_guard_size: u64,
+}
+
+impl SubsetTunables {
+    /// Get the `BaseTunables` for a specific Target
+    pub fn for_target(target: &Target) -> Self {
+        let triple = target.triple();
+        let pointer_width: PointerWidth = triple.pointer_width().unwrap();
+        let (static_memory_bound, static_memory_offset_guard_size): (Pages, u64) =
+            match pointer_width {
+                PointerWidth::U16 => (0x400.into(), 0x1000),
+                PointerWidth::U32 => (0x4000.into(), 0x1_0000),
+                // Static Memory Bound:
+                //   Allocating 4 GiB of address space let us avoid the
+                //   need for explicit bounds checks.
+                // Static Memory Guard size:
+                //   Allocating 2 GiB of address space lets us translate wasm
+                //   offsets into x86 offsets as aggressively as we can.
+                PointerWidth::U64 => (0x1_0000.into(), 0x8000_0000),
+            };
+
+        // Allocate a small guard to optimize common cases but without
+        // wasting too much memory.
+        // The Windows memory manager seems more laxed than the other ones
+        // And a guard of just 1 page may not be enough is some borderline cases
+        // So using 2 pages for guard on this platform
+        #[cfg(target_os = "windows")]
+        let dynamic_memory_offset_guard_size: u64 = 0x2_0000;
+        #[cfg(not(target_os = "windows"))]
+        let dynamic_memory_offset_guard_size: u64 = 0x1_0000;
+
+        Self {
+            static_memory_bound,
+            static_memory_offset_guard_size,
+            dynamic_memory_offset_guard_size,
+        }
+    }
+    /// Get a `MemoryStyle` for the provided `MemoryType`
+    pub fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+        // A heap with a maximum that doesn't exceed the static memory bound specified by the
+        // tunables make it static.
+        //
+        // If the module doesn't declare an explicit maximum treat it as 4GiB.
+        let maximum = memory.maximum.unwrap_or_else(Pages::max_value);
+        if maximum <= self.static_memory_bound {
+            MemoryStyle::Static {
+                // Bound can be larger than the maximum for performance reasons
+                bound: self.static_memory_bound,
+                offset_guard_size: self.static_memory_offset_guard_size,
+            }
+        } else {
+            MemoryStyle::Dynamic {
+                offset_guard_size: self.dynamic_memory_offset_guard_size,
+            }
+        }
+    }
+
+    /// Get a [`TableStyle`] for the provided [`TableType`].
+    pub fn table_style(&self, _table: &TableType) -> TableStyle {
+        TableStyle::CallerChecksSignature
+    }
+}
+
+#[derive(Debug, Clone, Parser, Default)]
+/// The compiler and engine options
+pub struct StoreOptions {
+    #[clap(flatten)]
+    compiler: CompilerOptions,
+}
+
+#[derive(Debug, Clone, Parser, Default)]
+/// The compiler options
+pub struct CompilerOptions {
+    /// Use Singlepass compiler.
+    #[clap(long, conflicts_with_all = &["cranelift", "llvm"])]
+    singlepass: bool,
+
+    /// Use Cranelift compiler.
+    #[clap(long, conflicts_with_all = &["singlepass", "llvm"])]
+    cranelift: bool,
+
+    /// Use LLVM compiler.
+    #[clap(long, conflicts_with_all = &["singlepass", "cranelift"])]
+    llvm: bool,
+
+    /// Enable compiler internal verification.
+    #[allow(unused)]
+    #[clap(long)]
+    #[allow(dead_code)]
+    enable_verifier: bool,
+
+    /// LLVM debug directory, where IR and object files will be written to.
+    #[allow(unused)]
+    #[cfg(feature = "llvm")]
+    #[cfg_attr(feature = "llvm", clap(long, parse(from_os_str)))]
+    llvm_debug_dir: Option<PathBuf>,
+
+    #[clap(flatten)]
+    features: WasmFeatures,
+}
+
+impl CompilerOptions {
+    fn get_compiler(&self) -> Result<CompilerType> {
+        if self.cranelift {
+            Ok(CompilerType::Cranelift)
+        } else if self.llvm {
+            Ok(CompilerType::LLVM)
+        } else if self.singlepass {
+            Ok(CompilerType::Singlepass)
+        } else {
+            // Auto mode, we choose the best compiler for that platform
+            cfg_if::cfg_if! {
+                if #[cfg(all(feature = "cranelift", any(target_arch = "x86_64", target_arch = "aarch64")))] {
+                    Ok(CompilerType::Cranelift)
+                }
+                else if #[cfg(all(feature = "singlepass", any(target_arch = "x86_64", target_arch = "aarch64")))] {
+                    Ok(CompilerType::Singlepass)
+                }
+                else if #[cfg(feature = "llvm")] {
+                    Ok(CompilerType::LLVM)
+                } else {
+                    bail!("There are no available compilers for your architecture");
+                }
+            }
+        }
+    }
+
+    /// Get the enaled Wasm features.
+    pub fn get_features(&self, mut features: Features) -> Result<Features> {
+        if self.features.threads || self.features.all {
+            features.threads(true);
+        }
+        if self.features.multi_value || self.features.all {
+            features.multi_value(true);
+        }
+        if self.features.simd || self.features.all {
+            features.simd(true);
+        }
+        if self.features.bulk_memory || self.features.all {
+            features.bulk_memory(true);
+        }
+        if self.features.reference_types || self.features.all {
+            features.reference_types(true);
+        }
+        Ok(features)
+    }
+
+    fn get_engine_by_type(
+        &self,
+        target: Target,
+        compiler_config: Box<dyn CompilerConfig>,
+    ) -> Result<EngineBuilder> {
+        let features = self.get_features(compiler_config.default_features_for_target(&target))?;
+        let engine: EngineBuilder = EngineBuilder::new(compiler_config)
+            .set_target(Some(target))
+            .set_features(Some(features));
+
+        Ok(engine)
+    }
+
+    /// Get the Compiler Config for the current options
+    #[allow(unused_variables)]
+    pub(crate) fn get_compiler_config(&self) -> Result<(Box<dyn CompilerConfig>, CompilerType)> {
+        let compiler = self.get_compiler()?;
+        let compiler_config: Box<dyn CompilerConfig> = match compiler {
+            CompilerType::Headless => bail!("The headless engine can't be chosen"),
+            #[cfg(feature = "singlepass")]
+            CompilerType::Singlepass => {
+                let mut config = wasmer_compiler_singlepass::Singlepass::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "cranelift")]
+            CompilerType::Cranelift => {
+                let mut config = wasmer_compiler_cranelift::Cranelift::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "llvm")]
+            CompilerType::LLVM => {
+                use std::fmt;
+                use std::fs::File;
+                use std::io::Write;
+                use wasmer_compiler_llvm::{
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                };
+                use wasmer_types::entity::EntityRef;
+                let mut config = LLVM::new();
+                struct Callbacks {
+                    debug_dir: PathBuf,
+                }
+                impl Callbacks {
+                    fn new(debug_dir: PathBuf) -> Result<Self> {
+                        // Create the debug dir in case it doesn't exist
+                        std::fs::create_dir_all(&debug_dir)?;
+                        Ok(Self { debug_dir })
+                    }
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn types_to_signature(types: &[Type]) -> String {
+                    types
+                        .iter()
+                        .map(|ty| match ty {
+                            Type::I32 => "i".to_string(),
+                            Type::I64 => "I".to_string(),
+                            Type::F32 => "f".to_string(),
+                            Type::F64 => "F".to_string(),
+                            Type::V128 => "v".to_string(),
+                            Type::ExternRef => "e".to_string(),
+                            Type::FuncRef => "r".to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .join("")
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn function_kind_to_filename(kind: &CompiledKind) -> String {
+                    match kind {
+                        CompiledKind::Local(local_index) => {
+                            format!("function_{}", local_index.index())
+                        }
+                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+                            "trampoline_call_{}_{}",
+                            types_to_signature(&func_type.params()),
+                            types_to_signature(&func_type.results())
+                        ),
+                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+                            "trampoline_dynamic_{}_{}",
+                            types_to_signature(&func_type.params()),
+                            types_to_signature(&func_type.results())
+                        ),
+                        CompiledKind::Module => "module".into(),
+                    }
+                }
+                impl LLVMCallbacks for Callbacks {
+                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping pre optimized LLVM IR");
+                    }
+                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping post optimized LLVM IR");
+                    }
+                    fn obj_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.o", function_kind_to_filename(kind)));
+                        let mem_buf_slice = memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                }
+
+                impl fmt::Debug for Callbacks {
+                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                        write!(f, "LLVMCallbacks")
+                    }
+                }
+
+                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
+                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                }
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm",)))]
+            compiler => {
+                bail!(
+                    "The `{}` compiler is not included in this binary.",
+                    compiler.to_string()
+                )
+            }
+        };
+
+        #[allow(unreachable_code)]
+        Ok((compiler_config, compiler))
+    }
+}
+
+/// The compiler used for the store
+#[derive(Debug, PartialEq, Eq)]
+pub enum CompilerType {
+    /// Singlepass compiler
+    Singlepass,
+    /// Cranelift compiler
+    Cranelift,
+    /// LLVM compiler
+    LLVM,
+    /// Headless compiler
+    #[allow(dead_code)]
+    Headless,
+}
+
+impl CompilerType {
+    /// Return all enabled compilers
+    pub fn enabled() -> Vec<CompilerType> {
+        vec![
+            #[cfg(feature = "singlepass")]
+            Self::Singlepass,
+            #[cfg(feature = "cranelift")]
+            Self::Cranelift,
+            #[cfg(feature = "llvm")]
+            Self::LLVM,
+        ]
+    }
+}
+
+impl ToString for CompilerType {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Singlepass => "singlepass".to_string(),
+            Self::Cranelift => "cranelift".to_string(),
+            Self::LLVM => "llvm".to_string(),
+            Self::Headless => "headless".to_string(),
+        }
+    }
+}
+
+impl StoreOptions {
+    /// Get a EngineBulder for the Target
+    pub fn get_engine_for_target(&self, target: Target) -> Result<(EngineBuilder, CompilerType)> {
+        let (compiler_config, compiler_type) = self.compiler.get_compiler_config()?;
+        let engine = self.get_engine_with_compiler(target, compiler_config)?;
+        Ok((engine, compiler_type))
+    }
+
+    fn get_engine_with_compiler(
+        &self,
+        target: Target,
+        compiler_config: Box<dyn CompilerConfig>,
+    ) -> Result<EngineBuilder> {
+        self.compiler.get_engine_by_type(target, compiler_config)
+    }
+
+    /// Get (Subset)Tunables for the Target
+    pub fn get_tunables_for_target(&self, target: &Target) -> Result<SubsetTunables> {
+        let tunables = SubsetTunables::for_target(target);
+        Ok(tunables)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/utils.rs b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/utils.rs
new file mode 100644
index 0000000..7a4a925
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli-compiler/src/utils.rs
@@ -0,0 +1,97 @@
+//! Utility functions for the WebAssembly module
+use anyhow::{bail, Context, Result};
+use is_terminal::IsTerminal;
+use std::path::PathBuf;
+use std::{env, path::Path};
+
+/// Whether or not Wasmer should print with color
+pub fn wasmer_should_print_color() -> bool {
+    env::var("WASMER_COLOR")
+        .ok()
+        .and_then(|inner| inner.parse::<bool>().ok())
+        .unwrap_or_else(|| std::io::stdout().is_terminal())
+}
+
+fn retrieve_alias_pathbuf(alias: &str, real_dir: &str) -> Result<(String, PathBuf)> {
+    let pb = Path::new(real_dir)
+        .canonicalize()
+        .with_context(|| format!("Unable to get the absolute path for \"{real_dir}\""))?;
+
+    if let Ok(pb_metadata) = pb.metadata() {
+        if !pb_metadata.is_dir() {
+            bail!("\"{real_dir}\" exists, but it is not a directory");
+        }
+    } else {
+        bail!("Directory \"{real_dir}\" does not exist");
+    }
+
+    Ok((alias.to_string(), pb))
+}
+
+/// Parses a mapdir from a string
+pub fn parse_mapdir(entry: &str) -> Result<(String, PathBuf)> {
+    // We try first splitting by `::`
+    if let [alias, real_dir] = entry.split("::").collect::<Vec<&str>>()[..] {
+        retrieve_alias_pathbuf(alias, real_dir)
+    }
+    // And then we try splitting by `:` (for compatibility with previous API)
+    else if let [alias, real_dir] = entry.split(':').collect::<Vec<&str>>()[..] {
+        retrieve_alias_pathbuf(alias, real_dir)
+    } else {
+        bail!(
+            "Directory mappings must consist of two paths separate by a `::` or `:`. Found {}",
+            &entry
+        )
+    }
+}
+
+/// Parses an environment variable.
+pub fn parse_envvar(entry: &str) -> Result<(String, String)> {
+    let entry = entry.trim();
+
+    match entry.find('=') {
+        None => bail!(
+            "Environment variable must be of the form `<name>=<value>`; found `{}`",
+            &entry
+        ),
+
+        Some(0) => bail!(
+            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `{}`",
+            &entry
+        ),
+
+        Some(position) if position == entry.len() - 1 => bail!(
+            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `{}`",
+            &entry
+        ),
+
+        Some(position) => Ok((entry[..position].into(), entry[position + 1..].into())),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_envvar;
+
+    #[test]
+    fn test_parse_envvar() {
+        assert_eq!(
+            parse_envvar("A").unwrap_err().to_string(),
+            "Environment variable must be of the form `<name>=<value>`; found `A`"
+        );
+        assert_eq!(
+            parse_envvar("=A").unwrap_err().to_string(),
+            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `=A`"
+        );
+        assert_eq!(
+            parse_envvar("A=").unwrap_err().to_string(),
+            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `A=`"
+        );
+        assert_eq!(parse_envvar("A=B").unwrap(), ("A".into(), "B".into()));
+        assert_eq!(parse_envvar("   A=B\t").unwrap(), ("A".into(), "B".into()));
+        assert_eq!(
+            parse_envvar("A=B=C=D").unwrap(),
+            ("A".into(), "B=C=D".into())
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/cli/Cargo.toml
new file mode 100644
index 0000000..4857c58
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/Cargo.toml
@@ -0,0 +1,262 @@
+[package]
+name = "wasmer-cli"
+description = "Wasmer CLI"
+categories = ["wasm", "command-line-interface"]
+keywords = ["wasm", "webassembly", "cli"]
+readme = "README.md"
+default-run = "wasmer"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[[bin]]
+name = "wasmer"
+path = "src/bin/wasmer.rs"
+doc = false
+required-features = ["backend"]
+
+[[bin]]
+name = "wasmer-headless"
+path = "src/bin/wasmer_headless.rs"
+doc = false
+required-features = ["headless"]
+
+[features]
+# Don't add the compiler features in default, please add them on the Makefile
+# since we might want to autoconfigure them depending on the availability on the host.
+default = [
+  "sys",
+  "wat",
+  "wast",
+  "compiler",
+  "journal",
+  "wasmer-artifact-create",
+  "static-artifact-create",
+]
+
+# Tun-tap client for connecting to Wasmer Edge VPNs
+tun-tap = ["dep:tun-tap", "virtual-net/tokio-tungstenite", "tokio-tungstenite", "mio", "futures-util",  "mac_address", "dep:interfaces"]
+journal = ["wasmer-wasix/journal"]
+fuse = ["dep:fuse", "dep:time01", "dep:shared-buffer", "dep:rkyv"]
+backend = []
+coredump = ["wasm-coredump-builder"]
+sys = ["compiler", "wasmer-vm"]
+jsc = ["backend", "wasmer/jsc", "wasmer/std"]
+wast = ["wasmer-wast"]
+host-net = ["virtual-net/host-net"]
+wat = ["wasmer/wat"]
+compiler = ["backend", "wasmer/compiler", "wasmer-compiler/translator", "wasmer-compiler/compiler"]
+wasmer-artifact-create = ["compiler", "wasmer/wasmer-artifact-load", "wasmer/wasmer-artifact-create", "wasmer-compiler/wasmer-artifact-load", "wasmer-compiler/wasmer-artifact-create", "wasmer-object"]
+static-artifact-create = ["compiler", "wasmer/static-artifact-load", "wasmer/static-artifact-create", "wasmer-compiler/static-artifact-load", "wasmer-compiler/static-artifact-create", "wasmer-object"]
+wasmer-artifact-load = ["compiler", "wasmer/wasmer-artifact-load", "wasmer-compiler/wasmer-artifact-load"]
+static-artifact-load = ["compiler", "wasmer/static-artifact-load", "wasmer-compiler/static-artifact-load"]
+singlepass = ["wasmer-compiler-singlepass", "compiler"]
+cranelift = ["wasmer-compiler-cranelift", "compiler"]
+llvm = ["wasmer-compiler-llvm", "compiler"]
+disable-all-logging = ["wasmer-wasix/disable-all-logging", "log/release_max_level_off"]
+headless = []
+headless-minimal = ["headless", "disable-all-logging"]
+
+# Optional
+enable-serde = ["wasmer/enable-serde", "wasmer-vm/enable-serde", "wasmer-compiler/enable-serde", "wasmer-wasix/enable-serde"]
+
+[dependencies]
+# Repo-local dependencies.
+
+wasmer = { version = "=4.2.8", path = "../api", default-features = false }
+wasmer-compiler = { version = "=4.2.8", path = "../compiler", features = [
+  "compiler",
+], optional = true }
+wasmer-compiler-cranelift = { version = "=4.2.8", path = "../compiler-cranelift", optional = true }
+wasmer-compiler-singlepass = { version = "=4.2.8", path = "../compiler-singlepass", optional = true }
+wasmer-compiler-llvm = { version = "=4.2.8", path = "../compiler-llvm", optional = true }
+wasmer-emscripten = { version = "=4.2.8", path = "../emscripten" }
+wasmer-vm = { version = "=4.2.8", path = "../vm", optional = true }
+wasmer-wasix = { version = "0.18.3", path = "../wasix", features = [
+  "logging",
+  "webc_runner_rt_wcgi",
+  "webc_runner_rt_dcgi",
+  "webc_runner_rt_dproxy",
+  "webc_runner_rt_emscripten",
+  "host-fs",
+] }
+wasmer-wast = { version = "=4.2.8", path = "../../tests/lib/wast", optional = true }
+wasmer-types = { version = "=4.2.8", path = "../types", features = [
+  "enable-serde",
+] }
+wasmer-registry = { version = "5.10.4", path = "../registry", features = [
+  "build-package",
+  "clap",
+] }
+wasmer-object = { version = "=4.2.8", path = "../object", optional = true }
+virtual-fs = { version = "0.11.2", path = "../virtual-fs", default-features = false, features = [
+  "host-fs",
+] }
+virtual-net = { version = "0.6.3", path = "../virtual-net" }
+virtual-mio = { version = "0.3.1", path = "../virtual-io" }
+
+# Wasmer-owned dependencies.
+
+webc = { workspace = true }
+wasmer-api = { version = "=0.0.25", path = "../backend-api" }
+edge-schema.workspace = true
+edge-util = { version = "=0.1.0" }
+
+# Used by the mount command
+
+shared-buffer = { workspace = true, optional = true }
+rkyv = { workspace = true, optional = true }
+fuse = { version = "0.3", optional = true }
+time01 = { package = "time", version = "0.1.45", optional = true }
+
+
+# Third-party dependencies.
+
+is-terminal = "0.4.7"
+colored = "2.0"
+anyhow = "1.0"
+
+# For the inspect subcommand
+bytesize = "1.0"
+cfg-if = "1.0"
+tempfile = "3.6.0"
+serde = { version = "1.0.147", features = ["derive"] }
+dirs = { version = "4.0" }
+serde_json = { version = "1.0" }
+target-lexicon = { version = "0.12", features = ["std"] }
+wasmer-toml = { workspace = true }
+indexmap = "1.9.2"
+walkdir = "2.3.2"
+regex = "1.6.0"
+toml = "0.5.9"
+url = "2.3.1"
+libc = { version = "^0.2", default-features = false }
+parking_lot = "0.12"
+dialoguer = "0.11.0"
+tldextract = "0.6.0"
+hex = "0.4.3"
+flate2 = "1.0.25"
+cargo_metadata = "0.15.2"
+tar = "0.4.38"
+bytes = "1"
+thiserror = "1.0.37"
+log = "0.4.17"
+semver = "1.0.14"
+pathdiff = "0.2.1"
+sha2 = "0.10.6"
+object = "0.32.0"
+wasm-coredump-builder = { version = "0.1.11", optional = true }
+tracing = { version = "0.1" }
+tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt", "json"] }
+async-trait = "0.1.68"
+tokio = { version = "1.28.1", features = ["macros", "rt-multi-thread"] }
+once_cell = "1.17.1"
+indicatif = "0.17.5"
+opener = "0.6.1"
+normpath = "=1.1.1"
+hyper = { version = "0.14.27", features = ["server"] }
+http = "0.2.9"
+futures = "0.3.29"
+humantime = "2.1.0"
+interfaces = { version = "0.0.9", optional = true }
+
+uuid = { version = "1.3.0", features = ["v4"] }
+time = { version = "0.3.17", features = ["macros"] }
+serde_yaml = "0.8.26"
+comfy-table = "7.0.1"
+
+
+# Used by tuntap and connect
+futures-util = { version = "0.3", optional = true }
+mio = { version = "0.8", optional = true }
+tokio-tungstenite = { version = "0.20.1", features = [
+    "rustls-tls-webpki-roots",
+], optional = true }
+mac_address = { version = "1.1.5", optional = true }
+tun-tap = { version = "0.1.3", features = ["tokio"], optional = true }
+
+# NOTE: Must use different features for clap because the "color" feature does not
+# work on wasi due to the anstream dependency not compiling.
+[target.'cfg(not(target_family = "wasm"))'.dependencies]
+clap = { version = "4.2.8", features = ["derive", "env"] }
+[target.'cfg(target_family = "wasm")'.dependencies]
+clap = { version = "4.2.8", default-features = false, features = [
+  "std",
+  "help",
+  "usage",
+  "error-context",
+  "suggestions",
+  "derive",
+  "env",
+] }
+
+[target.'cfg(not(target_arch = "riscv64"))'.dependencies]
+reqwest = { version = "^0.11", default-features = false, features = [
+  "rustls-tls",
+  "json",
+  "multipart",
+  "gzip",
+] }
+
+[target.'cfg(target_arch = "riscv64")'.dependencies]
+reqwest = { version = "^0.11", default-features = false, features = [
+  "native-tls",
+  "json",
+  "multipart",
+] }
+
+[build-dependencies]
+chrono = { version = "^0.4", default-features = false, features = [
+  "std",
+  "clock",
+] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+unix_mode = "0.1.3"
+
+
+[dev-dependencies]
+assert_cmd = "2.0.11"
+predicates = "3.0.3"
+pretty_assertions = "1.3.0"
+
+[target.'cfg(target_os = "windows")'.dependencies]
+colored = "2.0.0"
+
+[package.metadata.binstall]
+pkg-fmt = "tgz"
+
+[package.metadata.binstall.overrides.aarch64-apple-darwin]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-darwin-arm64.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.x86_64-apple-darwin]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-darwin-amd64.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.aarch64-unknown-linux-gnu]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-linux-aarch64.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.riscv64gc-unknown-linux-gnu]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-linux-riscv64gc.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.x86_64-unknown-linux-gnu]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-linux-amd64.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.x86_64-unknown-linux-musl]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-linux-musl-amd64.{ archive-format }"
+bin-dir = "bin/{ bin }"
+
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-url = "{ repo }/releases/download/v{ version }/wasmer-windows-amd64.{ archive-format }"
+bin-dir = "bin/{ bin }.exe"
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/README.md b/arbitrator/tools/module_roots/wasmer/lib/cli/README.md
new file mode 100644
index 0000000..b6c913e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/README.md
@@ -0,0 +1,63 @@
+# `wasmer-cli` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate is the Wasmer CLI.
+
+The recommended way to install `wasmer` is via the [wasmer-installer](https://github.com/wasmerio/wasmer-install).
+
+However, you can also install `wasmer` via Cargo (you will need to specify the compilers to use):
+
+```bash
+cargo install wasmer-cli --features "singlepass,cranelift"
+```
+
+Or by building it inside the codebase:
+
+```bash
+cargo build --release --features "singlepass,cranelift"
+```
+
+## Features
+
+The Wasmer supports the following features:
+* `wat` (default): support for executing WebAssembly text files.
+* `wast`(default): support for running wast test files.
+* `cache` (default): support or automatically caching compiled artifacts.
+* `wasi` (default): support for [WASI].
+* `emscripten` (default): support for [Emscripten].
+* `singlepass`: support for the [Singlepass compiler].
+* `cranelift`: support for the [Cranelift compiler].
+* `llvm`: support for the [LLVM compiler].
+
+[WASI]: https://github.com/wasmerio/wasmer/tree/master/lib/wasi/
+[Emscripten]: https://github.com/wasmerio/wasmer/tree/master/lib/emscripten/
+[Singlepass compiler]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass/
+[Cranelift compiler]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-cranelift/
+[LLVM compiler]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm/
+
+## CLI commands
+
+Once you have Wasmer installed, you can start executing WebAssembly files easily:
+
+Get the current Wasmer version:
+
+```bash
+wasmer -V
+```
+
+Execute a WebAssembly file:
+
+```bash
+wasmer run myfile.wasm
+```
+
+Compile a WebAssembly file:
+
+```bash
+wasmer compile myfile.wasm -o myfile.wasmu
+```
+
+Run a compiled WebAssembly file (fastest):
+
+```bash
+wasmer run myfile.wasmu
+```
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/build.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/build.rs
new file mode 100644
index 0000000..be9c016
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/build.rs
@@ -0,0 +1,27 @@
+use std::process::Command;
+
+use chrono::prelude::*;
+
+pub fn main() {
+    // Set WASMER_GIT_HASH
+    let git_hash = Command::new("git")
+        .args(["rev-parse", "HEAD"])
+        .output()
+        .ok()
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .unwrap_or_default();
+    println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH={}", git_hash);
+
+    if git_hash.len() > 5 {
+        println!(
+            "cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT={}",
+            &git_hash[..7]
+        );
+    } else {
+        println!("cargo:rustc-env=WASMER_BUILD_GIT_HASH_SHORT=???????");
+    }
+
+    let utc: DateTime<Utc> = Utc::now();
+    let date = utc.format("%Y-%m-%d").to_string();
+    println!("cargo:rustc-env=WASMER_BUILD_DATE={}", date);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer.rs
new file mode 100644
index 0000000..482342e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer.rs
@@ -0,0 +1,8 @@
+#[cfg(not(feature = "backend"))]
+compile_error!(
+    "Either enable at least one backend, or compile the wasmer-headless binary instead.\nWith cargo, you can provide a compiler option with the --features flag.\n\nExample values:\n\n\t\t--features cranelift,singlepass\n\t\t--features jsc\n\n\n"
+);
+
+fn main() {
+    wasmer_cli::run_cli();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer_headless.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer_headless.rs
new file mode 100644
index 0000000..ca6849f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/bin/wasmer_headless.rs
@@ -0,0 +1,3 @@
+fn main() {
+    wasmer_cli::run_cli();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/mod.rs
new file mode 100644
index 0000000..9ae88bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/mod.rs
@@ -0,0 +1,548 @@
+//! A convenient little abstraction for building up C expressions and generating
+//! simple C code.
+
+#![allow(dead_code)]
+
+pub mod staticlib_header;
+
+/// An identifier in C.
+pub type CIdent = String;
+
+/// A Type in the C language.
+#[derive(Debug, Clone, Default)]
+#[allow(dead_code)]
+pub enum CType {
+    /// C `void` type.
+    #[default]
+    Void,
+    /// A pointer to some other type.
+    PointerTo {
+        /// Whether the pointer is `const`.
+        is_const: bool,
+        /// The type that the pointer points to.
+        inner: Box<CType>,
+    },
+    /// C 8 bit unsigned integer type.
+    U8,
+    /// C 16 bit unsigned integer type.
+    U16,
+    /// C 32 bit unsigned integer type.
+    U32,
+    /// C 64 bit unsigned integer type.
+    U64,
+    /// C pointer sized unsigned integer type.
+    USize,
+    /// C 8 bit signed integer type.
+    I8,
+    /// C 16 bit signed integer type.
+    I16,
+    /// C 32 bit signed integer type.
+    I32,
+    /// C 64 bit signed integer type.
+    I64,
+    /// C pointer sized signed integer type.
+    ISize,
+    /// A function or function pointer.
+    Function {
+        /// The arguments the function takes.
+        arguments: Vec<CType>,
+        /// The return value if it has one
+        ///
+        /// None is equivalent to Some(Box(Ctype::Void)).
+        return_value: Option<Box<CType>>,
+    },
+    /// C constant array.
+    Array {
+        /// The type of the array.
+        inner: Box<CType>,
+    },
+    /// A user defined type.
+    TypeDef(String),
+}
+
+impl CType {
+    /// Convenience function to get a mutable void pointer type.
+    pub fn void_ptr() -> Self {
+        CType::PointerTo {
+            is_const: false,
+            inner: Box::new(CType::Void),
+        }
+    }
+
+    /// Convenience function to get a const void pointer type.
+    #[allow(dead_code)]
+    pub fn const_void_ptr() -> Self {
+        CType::PointerTo {
+            is_const: true,
+            inner: Box::new(CType::Void),
+        }
+    }
+
+    /// Generate the C source code for a type into the given `String`.
+    fn generate_c(&self, w: &mut String) {
+        match &self {
+            Self::Void => {
+                w.push_str("void");
+            }
+            Self::PointerTo { is_const, inner } => {
+                if *is_const {
+                    w.push_str("const ");
+                }
+                inner.generate_c(w);
+                w.push('*');
+            }
+            Self::U8 => {
+                w.push_str("unsigned char");
+            }
+            Self::U16 => {
+                w.push_str("unsigned short");
+            }
+            Self::U32 => {
+                w.push_str("unsigned int");
+            }
+            Self::U64 => {
+                w.push_str("unsigned long long");
+            }
+            Self::USize => {
+                w.push_str("unsigned size_t");
+            }
+            Self::I8 => {
+                w.push_str("char");
+            }
+            Self::I16 => {
+                w.push_str("short");
+            }
+            Self::I32 => {
+                w.push_str("int");
+            }
+            Self::I64 => {
+                w.push_str("long long");
+            }
+            Self::ISize => {
+                w.push_str("size_t");
+            }
+            Self::Function {
+                arguments,
+                return_value,
+            } => {
+                // function with no, name, assume it's a function pointer
+                #[allow(clippy::borrowed_box)]
+                let ret: CType = return_value
+                    .as_ref()
+                    .map(|i: &Box<CType>| (**i).clone())
+                    .unwrap_or_default();
+                ret.generate_c(w);
+                w.push(' ');
+                w.push_str("(*)");
+                w.push('(');
+                match arguments.len() {
+                    l if l > 1 => {
+                        for arg in &arguments[..arguments.len() - 1] {
+                            arg.generate_c(w);
+                            w.push_str(", ");
+                        }
+                        arguments.last().unwrap().generate_c(w);
+                    }
+                    1 => {
+                        arguments[0].generate_c(w);
+                    }
+                    _ => {}
+                }
+                w.push(')');
+            }
+            Self::Array { inner } => {
+                inner.generate_c(w);
+                w.push_str("[]");
+            }
+            Self::TypeDef(inner) => {
+                w.push_str(inner);
+            }
+        }
+    }
+
+    /// Generate the C source code for a type with a nameinto the given `String`.
+    fn generate_c_with_name(&self, name: &str, w: &mut String) {
+        match &self {
+            Self::PointerTo { .. }
+            | Self::TypeDef { .. }
+            | Self::Void
+            | Self::U8
+            | Self::U16
+            | Self::U32
+            | Self::U64
+            | Self::USize
+            | Self::I8
+            | Self::I16
+            | Self::I32
+            | Self::I64
+            | Self::ISize => {
+                self.generate_c(w);
+                w.push(' ');
+                w.push_str(name);
+            }
+            Self::Function {
+                arguments,
+                return_value,
+            } => {
+                #[allow(clippy::borrowed_box)]
+                let ret: CType = return_value
+                    .as_ref()
+                    .map(|i: &Box<CType>| (**i).clone())
+                    .unwrap_or_default();
+                ret.generate_c(w);
+                w.push(' ');
+                w.push_str(name);
+                w.push('(');
+                match arguments.len() {
+                    l if l > 1 => {
+                        for arg in &arguments[..arguments.len() - 1] {
+                            arg.generate_c(w);
+                            w.push_str(", ");
+                        }
+                        arguments.last().unwrap().generate_c(w);
+                    }
+                    1 => {
+                        arguments[0].generate_c(w);
+                    }
+                    _ => {}
+                }
+                w.push(')');
+            }
+            Self::Array { inner } => {
+                inner.generate_c(w);
+                w.push(' ');
+                w.push_str(name);
+                w.push_str("[]");
+            }
+        }
+    }
+}
+
+/// A statement in the C programming language. This may not be exact to what an
+/// AST would look like or what the C standard says about the C language, it's
+/// simply a structed way to organize data for generating C code.
+#[derive(Debug, Clone)]
+pub enum CStatement {
+    /// A declaration of some kind.
+    Declaration {
+        /// The name of the thing being declared.
+        name: CIdent,
+        /// Whether the thing being declared is `extern`.
+        is_extern: bool,
+        /// Whether the thing being declared is `const`.
+        is_const: bool,
+        /// The type of the thing being declared.
+        ctype: CType,
+        /// The definition of the thing being declared.
+        ///
+        /// This is useful for initializing constant arrays, for example.
+        definition: Option<Box<CStatement>>,
+    },
+
+    /// A literal array of CStatements.
+    LiteralArray {
+        /// The contents of the array.
+        items: Vec<CStatement>,
+    },
+
+    /// A literal constant value, passed through directly as a string.
+    LiteralConstant {
+        /// The raw value acting as a constant.
+        value: String,
+    },
+
+    /// A C-style cast
+    Cast {
+        /// The type to cast to.
+        target_type: CType,
+        /// The thing being cast.
+        expression: Box<CStatement>,
+    },
+
+    /// Typedef one type to another.
+    TypeDef {
+        /// The type of the thing being typedef'd.
+        source_type: CType,
+        /// The new name by which this type may be called.
+        new_name: CIdent,
+    },
+}
+
+impl CStatement {
+    /// Generate C source code for the given CStatement.
+    fn generate_c(&self, w: &mut String) {
+        match &self {
+            Self::Declaration {
+                name,
+                is_extern,
+                is_const,
+                ctype,
+                definition,
+            } => {
+                if *is_const {
+                    w.push_str("const ");
+                }
+                if *is_extern {
+                    w.push_str("extern ");
+                }
+                ctype.generate_c_with_name(name, w);
+                if let Some(def) = definition {
+                    w.push_str(" = ");
+                    def.generate_c(w);
+                }
+                w.push(';');
+                w.push('\n');
+            }
+            Self::LiteralArray { items } => {
+                w.push('{');
+                if !items.is_empty() {
+                    w.push('\n');
+                }
+                for item in items {
+                    w.push('\t');
+                    item.generate_c(w);
+                    w.push(',');
+                    w.push('\n');
+                }
+                w.push('}');
+            }
+            Self::LiteralConstant { value } => {
+                w.push_str(value);
+            }
+            Self::Cast {
+                target_type,
+                expression,
+            } => {
+                w.push('(');
+                target_type.generate_c(w);
+                w.push(')');
+                w.push(' ');
+                expression.generate_c(w);
+            }
+            Self::TypeDef {
+                source_type,
+                new_name,
+            } => {
+                w.push_str("typedef ");
+                // leaky abstraction / hack, doesn't fully solve the problem
+                if let CType::Function { .. } = source_type {
+                    source_type.generate_c_with_name(&format!("(*{})", new_name), w);
+                } else {
+                    source_type.generate_c(w);
+                    w.push(' ');
+                    w.push_str(new_name);
+                }
+                w.push(';');
+                w.push('\n');
+            }
+        }
+    }
+}
+
+/// Generate C source code from some `CStatements` into a String.
+// TODO: add config section
+pub fn generate_c(statements: &[CStatement]) -> String {
+    let mut out = String::new();
+    for statement in statements {
+        statement.generate_c(&mut out);
+    }
+    out
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn generate_types() {
+        macro_rules! assert_c_type {
+            ($ctype:expr, $expected:expr) => {
+                let mut w = String::new();
+                let ctype = $ctype;
+                ctype.generate_c(&mut w);
+                assert_eq!(w, $expected);
+            };
+        }
+
+        assert_c_type!(CType::Void, "void");
+        assert_c_type!(CType::void_ptr(), "void*");
+        assert_c_type!(CType::const_void_ptr(), "const void*");
+        assert_c_type!(CType::U8, "unsigned char");
+        assert_c_type!(CType::U16, "unsigned short");
+        assert_c_type!(CType::U32, "unsigned int");
+        assert_c_type!(CType::U64, "unsigned long long");
+        assert_c_type!(CType::USize, "unsigned size_t");
+        assert_c_type!(CType::I8, "char");
+        assert_c_type!(CType::I16, "short");
+        assert_c_type!(CType::I32, "int");
+        assert_c_type!(CType::I64, "long long");
+        assert_c_type!(CType::ISize, "size_t");
+        assert_c_type!(CType::TypeDef("my_type".to_string()), "my_type");
+        assert_c_type!(
+            CType::Function {
+                arguments: vec![CType::U8, CType::ISize],
+                return_value: None
+            },
+            "void (*)(unsigned char, size_t)"
+        );
+        assert_c_type!(
+            CType::Function {
+                arguments: vec![],
+                return_value: Some(Box::new(CType::ISize))
+            },
+            "size_t (*)()"
+        );
+        assert_c_type!(
+            CType::PointerTo {
+                is_const: true,
+                inner: Box::new(CType::PointerTo {
+                    is_const: false,
+                    inner: Box::new(CType::U32)
+                })
+            },
+            "const unsigned int**"
+        );
+        // TODO: test more complicated const correctness rules: there are bugs relating to it.
+    }
+
+    #[test]
+    fn generate_types_with_names() {
+        macro_rules! assert_c_type {
+            ($ctype:expr, $name:literal, $expected:expr) => {
+                let mut w = String::new();
+                let ctype = $ctype;
+                ctype.generate_c_with_name($name, &mut w);
+                assert_eq!(w, $expected);
+            };
+        }
+
+        assert_c_type!(CType::Void, "main", "void main");
+        assert_c_type!(CType::void_ptr(), "data", "void* data");
+        assert_c_type!(CType::const_void_ptr(), "data", "const void* data");
+        assert_c_type!(CType::U8, "data", "unsigned char data");
+        assert_c_type!(CType::U16, "data", "unsigned short data");
+        assert_c_type!(CType::U32, "data", "unsigned int data");
+        assert_c_type!(CType::U64, "data", "unsigned long long data");
+        assert_c_type!(CType::USize, "data", "unsigned size_t data");
+        assert_c_type!(CType::I8, "data", "char data");
+        assert_c_type!(CType::I16, "data", "short data");
+        assert_c_type!(CType::I32, "data", "int data");
+        assert_c_type!(CType::I64, "data", "long long data");
+        assert_c_type!(CType::ISize, "data", "size_t data");
+        assert_c_type!(
+            CType::TypeDef("my_type".to_string()),
+            "data",
+            "my_type data"
+        );
+        assert_c_type!(
+            CType::Function {
+                arguments: vec![CType::U8, CType::ISize],
+                return_value: None
+            },
+            "my_func",
+            "void my_func(unsigned char, size_t)"
+        );
+        assert_c_type!(
+            CType::Function {
+                arguments: vec![],
+                return_value: Some(Box::new(CType::ISize))
+            },
+            "my_func",
+            "size_t my_func()"
+        );
+        assert_c_type!(
+            CType::PointerTo {
+                is_const: true,
+                inner: Box::new(CType::PointerTo {
+                    is_const: false,
+                    inner: Box::new(CType::U32)
+                })
+            },
+            "data",
+            "const unsigned int** data"
+        );
+        // TODO: test more complicated const correctness rules: there are bugs relating to it.
+    }
+
+    #[test]
+    fn generate_expressions_works() {
+        macro_rules! assert_c_expr {
+            ($cexpr:expr, $expected:expr) => {
+                let mut w = String::new();
+                let cexpr = $cexpr;
+                cexpr.generate_c(&mut w);
+                assert_eq!(w, $expected);
+            };
+        }
+
+        assert_c_expr!(
+            CStatement::LiteralConstant {
+                value: "\"Hello, world!\"".to_string()
+            },
+            "\"Hello, world!\""
+        );
+        assert_c_expr!(
+            CStatement::TypeDef {
+                source_type: CType::Function {
+                    arguments: vec![CType::I32, CType::I32],
+                    return_value: None,
+                },
+                new_name: "my_func_ptr".to_string(),
+            },
+            "typedef void (*my_func_ptr)(int, int);\n"
+        );
+        assert_c_expr!(
+            CStatement::LiteralArray {
+                items: vec![
+                    CStatement::LiteralConstant {
+                        value: "1".to_string()
+                    },
+                    CStatement::LiteralConstant {
+                        value: "2".to_string()
+                    },
+                    CStatement::LiteralConstant {
+                        value: "3".to_string()
+                    },
+                ]
+            },
+            "{\n\t1,\n\t2,\n\t3,\n}"
+        );
+        assert_c_expr!(CStatement::LiteralArray { items: vec![] }, "{}");
+        assert_c_expr!(
+            CStatement::Declaration {
+                name: "my_array".to_string(),
+                is_extern: false,
+                is_const: true,
+                ctype: CType::Array {
+                    inner: Box::new(CType::I32)
+                },
+                definition: Some(Box::new(CStatement::LiteralArray {
+                    items: vec![
+                        CStatement::LiteralConstant {
+                            value: "1".to_string()
+                        },
+                        CStatement::LiteralConstant {
+                            value: "2".to_string()
+                        },
+                        CStatement::LiteralConstant {
+                            value: "3".to_string()
+                        },
+                    ]
+                }))
+            },
+            "const int my_array[] = {\n\t1,\n\t2,\n\t3,\n};\n"
+        );
+        assert_c_expr!(
+            CStatement::Declaration {
+                name: "my_array".to_string(),
+                is_extern: true,
+                is_const: true,
+                ctype: CType::Array {
+                    inner: Box::new(CType::I32)
+                },
+                definition: None,
+            },
+            "const extern int my_array[];\n"
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/staticlib_header.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/staticlib_header.rs
new file mode 100644
index 0000000..27c10c6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/c_gen/staticlib_header.rs
@@ -0,0 +1,301 @@
+//! Generate a header file for the static object file produced.
+
+use wasmer_types::{ModuleInfo, Symbol, SymbolRegistry};
+
+use super::{generate_c, CStatement, CType};
+
+/// Helper functions to simplify the usage of the static artifact.
+fn gen_helper_functions(atom_name: &str, module_name: &str) -> String {
+    format!("
+    wasm_byte_vec_t generate_serialized_data_{atom_name}() {{
+        // We need to pass all the bytes as one big buffer so we have to do all this logic to memcpy
+        // the various pieces together from the generated header file.
+        //
+        // We should provide a `deseralize_vectored` function to avoid requiring this extra work.
+
+        char* byte_ptr = (char*)&{module_name}[0];
+
+        size_t num_function_pointers
+                = sizeof(function_pointers_{atom_name}) / sizeof(void*);
+        size_t num_function_trampolines
+                = sizeof(function_trampolines_{atom_name}) / sizeof(void*);
+        size_t num_dynamic_function_trampoline_pointers
+                = sizeof(dynamic_function_trampoline_pointers_{atom_name}) / sizeof(void*);
+
+
+        size_t buffer_size = module_bytes_len_{atom_name}
+                + sizeof(size_t) + sizeof(function_pointers_{atom_name})
+                + sizeof(size_t) + sizeof(function_trampolines_{atom_name})
+                + sizeof(size_t) + sizeof(dynamic_function_trampoline_pointers_{atom_name});
+
+        char* memory_buffer = (char*) malloc(buffer_size);
+        size_t current_offset = 0;
+
+        memcpy(memory_buffer + current_offset, byte_ptr, module_bytes_len_{atom_name});
+        current_offset += module_bytes_len_{atom_name};
+
+        memcpy(memory_buffer + current_offset, (void*)&num_function_pointers, sizeof(size_t));
+        current_offset += sizeof(size_t);
+
+        memcpy(memory_buffer + current_offset, (void*)&function_pointers_{atom_name}[0], sizeof(function_pointers_{atom_name}));
+        current_offset += sizeof(function_pointers_{atom_name});
+
+        memcpy(memory_buffer + current_offset, (void*)&num_function_trampolines, sizeof(size_t));
+        current_offset += sizeof(size_t);
+
+        memcpy(memory_buffer + current_offset, (void*)&function_trampolines_{atom_name}[0], sizeof(function_trampolines_{atom_name}));
+        current_offset += sizeof(function_trampolines_{atom_name});
+
+        memcpy(memory_buffer + current_offset, (void*)&num_dynamic_function_trampoline_pointers, sizeof(size_t));
+        current_offset += sizeof(size_t);
+
+        memcpy(memory_buffer + current_offset, (void*)&dynamic_function_trampoline_pointers_{atom_name}[0], sizeof(dynamic_function_trampoline_pointers_{atom_name}));
+        current_offset += sizeof(dynamic_function_trampoline_pointers_{atom_name});
+
+        wasm_byte_vec_t module_byte_vec = {{
+                .size = buffer_size,
+                .data = memory_buffer,
+        }};
+        return module_byte_vec;
+    }}
+
+    wasm_module_t* wasmer_object_module_new_{atom_name}(wasm_store_t* store, const char* wasm_name) {{
+            // wasm_name intentionally unused for now: will be used in the future.
+            wasm_byte_vec_t module_byte_vec = generate_serialized_data_{atom_name}();
+            wasm_module_t* module = wasm_module_deserialize(store, &module_byte_vec);
+            free(module_byte_vec.data);
+
+            return module;
+    }}
+    ")
+}
+
+/// Generate the header file that goes with the generated object file.
+pub fn generate_header_file(
+    atom_name: &str,
+    module_info: &ModuleInfo,
+    symbol_registry: &dyn SymbolRegistry,
+    metadata_length: usize,
+) -> String {
+    let mut c_statements = vec![
+        CStatement::LiteralConstant {
+            value: "#include \"wasmer.h\"\n#include <stdlib.h>\n#include <string.h>\n\n"
+                .to_string(),
+        },
+        CStatement::LiteralConstant {
+            value: "#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n".to_string(),
+        },
+        CStatement::Declaration {
+            name: format!("module_bytes_len_{atom_name}"),
+            is_extern: false,
+            is_const: true,
+            ctype: CType::U32,
+            definition: Some(Box::new(CStatement::LiteralConstant {
+                value: metadata_length.to_string(),
+            })),
+        },
+        CStatement::Declaration {
+            name: symbol_registry.symbol_to_name(Symbol::Metadata),
+            is_extern: true,
+            is_const: true,
+            ctype: CType::Array {
+                inner: Box::new(CType::U8),
+            },
+            definition: None,
+        },
+    ];
+    let function_declarations = module_info
+        .functions
+        .iter()
+        .filter_map(|(f_index, sig_index)| {
+            Some((module_info.local_func_index(f_index)?, sig_index))
+        })
+        .map(|(function_local_index, _sig_index)| {
+            let function_name =
+                symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
+            // TODO: figure out the signature here too
+            CStatement::Declaration {
+                name: function_name,
+                is_extern: true,
+                is_const: false,
+                ctype: CType::Function {
+                    arguments: vec![CType::Void],
+                    return_value: None,
+                },
+                definition: None,
+            }
+        });
+    c_statements.push(CStatement::LiteralConstant {
+        value: r#"
+// Compiled Wasm function pointers ordered by function index: the order they
+// appeared in in the Wasm module.
+"#
+        .to_string(),
+    });
+    c_statements.extend(function_declarations);
+
+    // function pointer array
+    {
+        let function_pointer_array_statements = module_info
+            .functions
+            .iter()
+            .filter_map(|(f_index, sig_index)| {
+                Some((module_info.local_func_index(f_index)?, sig_index))
+            })
+            .map(|(function_local_index, _sig_index)| {
+                let function_name =
+                    symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
+                // TODO: figure out the signature here too
+
+                CStatement::Cast {
+                    target_type: CType::void_ptr(),
+                    expression: Box::new(CStatement::LiteralConstant {
+                        value: function_name,
+                    }),
+                }
+            })
+            .collect::<Vec<_>>();
+
+        c_statements.push(CStatement::Declaration {
+            name: format!("function_pointers_{atom_name}"),
+            is_extern: false,
+            is_const: true,
+            ctype: CType::Array {
+                inner: Box::new(CType::void_ptr()),
+            },
+            definition: Some(Box::new(CStatement::LiteralArray {
+                items: function_pointer_array_statements,
+            })),
+        });
+    }
+
+    let func_trampoline_declarations =
+        module_info
+            .signatures
+            .iter()
+            .map(|(sig_index, _func_type)| {
+                let function_name =
+                    symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(sig_index));
+
+                CStatement::Declaration {
+                    name: function_name,
+                    is_extern: true,
+                    is_const: false,
+                    ctype: CType::Function {
+                        arguments: vec![CType::void_ptr(), CType::void_ptr(), CType::void_ptr()],
+                        return_value: None,
+                    },
+                    definition: None,
+                }
+            });
+    c_statements.push(CStatement::LiteralConstant {
+        value: r#"
+// Trampolines (functions by which we can call into Wasm) ordered by signature.
+// There is 1 trampoline per function signature in the order they appear in
+// the Wasm module.
+"#
+        .to_string(),
+    });
+    c_statements.extend(func_trampoline_declarations);
+
+    // function trampolines
+    {
+        let function_trampoline_statements = module_info
+            .signatures
+            .iter()
+            .map(|(sig_index, _vm_shared_index)| {
+                let function_name =
+                    symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(sig_index));
+                CStatement::LiteralConstant {
+                    value: function_name,
+                }
+            })
+            .collect::<Vec<_>>();
+
+        c_statements.push(CStatement::Declaration {
+            name: format!("function_trampolines_{atom_name}"),
+            is_extern: false,
+            is_const: true,
+            ctype: CType::Array {
+                inner: Box::new(CType::void_ptr()),
+            },
+            definition: Some(Box::new(CStatement::LiteralArray {
+                items: function_trampoline_statements,
+            })),
+        });
+    }
+
+    let dyn_func_declarations = module_info
+        .functions
+        .keys()
+        .take(module_info.num_imported_functions)
+        .map(|func_index| {
+            let function_name =
+                symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
+            // TODO: figure out the signature here
+            CStatement::Declaration {
+                name: function_name,
+                is_extern: true,
+                is_const: false,
+                ctype: CType::Function {
+                    arguments: vec![CType::void_ptr(), CType::void_ptr(), CType::void_ptr()],
+                    return_value: None,
+                },
+                definition: None,
+            }
+        });
+    c_statements.push(CStatement::LiteralConstant {
+        value: r#"
+// Dynamic trampolines are per-function and are used for each function where
+// the type signature is not known statically. In this case, this corresponds to
+// the imported functions.
+"#
+        .to_string(),
+    });
+    c_statements.extend(dyn_func_declarations);
+
+    c_statements.push(CStatement::TypeDef {
+        source_type: CType::Function {
+            arguments: vec![CType::void_ptr(), CType::void_ptr(), CType::void_ptr()],
+            return_value: None,
+        },
+        new_name: "dyn_func_trampoline_t".to_string(),
+    });
+
+    // dynamic function trampoline pointer array
+    {
+        let dynamic_function_trampoline_statements = module_info
+            .functions
+            .keys()
+            .take(module_info.num_imported_functions)
+            .map(|func_index| {
+                let function_name =
+                    symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
+                CStatement::LiteralConstant {
+                    value: function_name,
+                }
+            })
+            .collect::<Vec<_>>();
+        c_statements.push(CStatement::Declaration {
+            name: format!("dynamic_function_trampoline_pointers_{atom_name}"),
+            is_extern: false,
+            is_const: true,
+            ctype: CType::Array {
+                inner: Box::new(CType::TypeDef("dyn_func_trampoline_t".to_string())),
+            },
+            definition: Some(Box::new(CStatement::LiteralArray {
+                items: dynamic_function_trampoline_statements,
+            })),
+        });
+    }
+
+    c_statements.push(CStatement::LiteralConstant {
+        value: gen_helper_functions(atom_name, &symbol_registry.symbol_to_name(Symbol::Metadata)),
+    });
+
+    c_statements.push(CStatement::LiteralConstant {
+        value: "\n#ifdef __cplusplus\n}\n#endif\n\n".to_string(),
+    });
+
+    generate_c(&c_statements)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/add.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/add.rs
new file mode 100644
index 0000000..44cba7a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/add.rs
@@ -0,0 +1,209 @@
+use std::process::{Command, Stdio};
+
+use anyhow::{Context, Error};
+use clap::Parser;
+use wasmer_registry::{wasmer_env::WasmerEnv, Bindings, ProgrammingLanguage};
+
+/// Add a Wasmer package's bindings to your application.
+#[derive(Debug, Parser)]
+pub struct Add {
+    #[clap(flatten)]
+    env: WasmerEnv,
+    /// Add the JavaScript bindings using "npm install".
+    #[clap(long, groups = &["bindings", "js"])]
+    npm: bool,
+    /// Add the JavaScript bindings using "yarn add".
+    #[clap(long, groups = &["bindings", "js"])]
+    yarn: bool,
+    /// Add the JavaScript bindings using "pnpm add".
+    #[clap(long, groups = &["bindings", "js"])]
+    pnpm: bool,
+    /// Add the package as a dev-dependency.
+    #[clap(long, requires = "js")]
+    dev: bool,
+    /// Add the Python bindings using "pip install".
+    #[clap(long, groups = &["bindings", "py"])]
+    pip: bool,
+    /// The packages to add (e.g. "wasmer/wasmer-pack@0.5.0" or "python/python")
+    packages: Vec<wasmer_registry::Package>,
+}
+
+impl Add {
+    /// Execute [`Add`].
+    pub fn execute(&self) -> Result<(), Error> {
+        anyhow::ensure!(!self.packages.is_empty(), "No packages specified");
+
+        let registry = self
+            .env
+            .registry_endpoint()
+            .context("Unable to determine which registry to use")?;
+
+        let bindings = self.lookup_bindings(registry.as_str())?;
+
+        let mut cmd = self.target()?.command(&bindings)?;
+        cmd.stdin(Stdio::null())
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit());
+
+        println!("Running: {cmd:?}");
+
+        let status = cmd.status().with_context(|| {
+            format!(
+                "Unable to start \"{:?}\". Is it installed?",
+                cmd.get_program()
+            )
+        })?;
+
+        anyhow::ensure!(status.success(), "Command failed: {:?}", cmd);
+
+        Ok(())
+    }
+
+    fn lookup_bindings(&self, registry: &str) -> Result<Vec<Bindings>, Error> {
+        println!("Querying Wasmer for package bindings");
+
+        let mut bindings_to_add = Vec::new();
+        let language = self.target()?.language();
+
+        for pkg in &self.packages {
+            let bindings = lookup_bindings_for_package(registry, pkg, &language)
+                .with_context(|| format!("Unable to find bindings for {pkg}"))?;
+            bindings_to_add.push(bindings);
+        }
+
+        Ok(bindings_to_add)
+    }
+
+    fn target(&self) -> Result<Target, Error> {
+        match (self.pip, self.npm, self.yarn, self.pnpm) {
+            (false, false, false, false) => Err(anyhow::anyhow!(
+                "at least one of --npm, --pip, --yarn or --pnpm has to be specified"
+            )),
+            (true, false, false, false) => Ok(Target::Pip),
+            (false, true, false, false) => Ok(Target::Npm { dev: self.dev }),
+            (false, false, true, false) => Ok(Target::Yarn { dev: self.dev }),
+            (false, false, false, true) => Ok(Target::Pnpm { dev: self.dev }),
+            _ => Err(anyhow::anyhow!(
+                "only one of --npm, --pip or --yarn has to be specified"
+            )),
+        }
+    }
+}
+
+fn lookup_bindings_for_package(
+    registry: &str,
+    pkg: &wasmer_registry::Package,
+    language: &ProgrammingLanguage,
+) -> Result<Bindings, Error> {
+    let all_bindings =
+        wasmer_registry::list_bindings(registry, &pkg.package(), pkg.version.as_deref())?;
+
+    match all_bindings.iter().find(|b| b.language == *language) {
+        Some(b) => {
+            let Bindings { url, generator, .. } = b;
+            log::debug!("Found {pkg} bindings generated by {generator} at {url}");
+
+            Ok(b.clone())
+        }
+        None => {
+            if all_bindings.is_empty() {
+                anyhow::bail!("The package doesn't contain any bindings");
+            } else {
+                todo!();
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum Target {
+    Pip,
+    Yarn { dev: bool },
+    Npm { dev: bool },
+    Pnpm { dev: bool },
+}
+
+impl Target {
+    fn language(self) -> ProgrammingLanguage {
+        match self {
+            Target::Pip => ProgrammingLanguage::PYTHON,
+            Target::Pnpm { .. } | Target::Yarn { .. } | Target::Npm { .. } => {
+                ProgrammingLanguage::JAVASCRIPT
+            }
+        }
+    }
+
+    /// Construct a command which we can run to add packages.
+    ///
+    /// This deliberately runs the command using the OS shell instead of
+    /// invoking the tool directly. That way we can handle when a version
+    /// manager (e.g. `nvm` or `asdf`) replaces the tool with a script (e.g.
+    /// `npm.cmd` or `yarn.ps1`).
+    ///
+    /// See <https://github.com/wasmerio/wapm-cli/issues/291> for more.
+    fn command(self, packages: &[Bindings]) -> Result<Command, Error> {
+        let command_line = match self {
+            Target::Pip => {
+                if Command::new("pip").arg("--version").output().is_ok() {
+                    "pip install"
+                } else if Command::new("pip3").arg("--version").output().is_ok() {
+                    "pip3 install"
+                } else if Command::new("python").arg("--version").output().is_ok() {
+                    "python -m pip install"
+                } else if Command::new("python3").arg("--version").output().is_ok() {
+                    "python3 -m pip install"
+                } else {
+                    return Err(anyhow::anyhow!(
+                        "neither pip, pip3, python or python3 installed"
+                    ));
+                }
+            }
+            Target::Yarn { dev } => {
+                if Command::new("yarn").arg("--version").output().is_err() {
+                    return Err(anyhow::anyhow!("yarn not installed"));
+                }
+                if dev {
+                    "yarn add --dev"
+                } else {
+                    "yarn add"
+                }
+            }
+            Target::Npm { dev } => {
+                if Command::new("npm").arg("--version").output().is_err() {
+                    return Err(anyhow::anyhow!("npm not installed"));
+                }
+                if dev {
+                    "npm install --dev"
+                } else {
+                    "npm install"
+                }
+            }
+            Target::Pnpm { dev } => {
+                if Command::new("pnpm").arg("--version").output().is_err() {
+                    return Err(anyhow::anyhow!("pnpm not installed"));
+                }
+                if dev {
+                    "pnpm add --dev"
+                } else {
+                    "pnpm add"
+                }
+            }
+        };
+        let mut command_line = command_line.to_string();
+
+        for pkg in packages {
+            command_line.push(' ');
+            command_line.push_str(&pkg.url);
+        }
+
+        if cfg!(windows) {
+            let mut cmd = Command::new("cmd");
+            cmd.arg("/C").arg(command_line);
+            Ok(cmd)
+        } else {
+            let mut cmd = Command::new("sh");
+            cmd.arg("-c").arg(command_line);
+            Ok(cmd)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/create.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/create.rs
new file mode 100644
index 0000000..b8ca499
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/create.rs
@@ -0,0 +1,717 @@
+//! Create a new Edge app.
+
+use std::path::PathBuf;
+
+use anyhow::{bail, Context};
+use colored::Colorize;
+use dialoguer::Confirm;
+use edge_schema::schema::StringWebcIdent;
+use is_terminal::IsTerminal;
+use wasmer_api::{
+    types::{DeployAppVersion, Package, UserWithNamespaces},
+    WasmerClient,
+};
+
+use crate::{
+    commands::{
+        app::{deploy_app_verbose, AppConfigV1, DeployAppOpts, WaitMode},
+        AsyncCliCommand,
+    },
+    opts::{ApiOpts, ItemFormatOpts},
+    utils::package_wizard::{CreateMode, PackageType, PackageWizard},
+};
+
+/// Create a new Edge app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppCreate {
+    #[clap(name = "type", short = 't', long)]
+    template: Option<AppType>,
+
+    #[clap(long)]
+    publish_package: bool,
+
+    /// Skip local schema validation.
+    #[clap(long)]
+    pub no_validate: bool,
+
+    /// Do not prompt for user input.
+    #[clap(long)]
+    pub non_interactive: bool,
+
+    /// Do not interact with any APIs.
+    #[clap(long)]
+    pub offline: bool,
+
+    /// The owner of the app.
+    #[clap(long)]
+    pub owner: Option<String>,
+
+    /// Name to use when creating a new package.
+    #[clap(long)]
+    pub new_package_name: Option<String>,
+
+    /// The name of the app (can be changed later)
+    #[clap(long)]
+    pub name: Option<String>,
+
+    /// The path to a YAML file the app config.
+    #[clap(long)]
+    pub path: Option<PathBuf>,
+
+    /// Do not wait for the app to become reachable.
+    #[clap(long)]
+    pub no_wait: bool,
+
+    // Common args.
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub api: ApiOpts,
+
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub fmt: ItemFormatOpts,
+
+    /// Name of the package to use.
+    #[clap(long, short = 'p')]
+    pub package: Option<String>,
+}
+
+/// App type.
+#[derive(clap::ValueEnum, Clone, Copy, Debug)]
+pub enum AppType {
+    /// A HTTP server.
+    #[clap(name = "http")]
+    HttpServer,
+    /// A static website.
+    #[clap(name = "static-website")]
+    StaticWebsite,
+    /// Wraps another package to run in the browser.
+    #[clap(name = "browser-shell")]
+    BrowserShell,
+    /// Winter-js based JS-Worker
+    #[clap(name = "js-worker")]
+    JsWorker,
+    /// Python worker
+    #[clap(name = "py-application")]
+    PyApplication,
+}
+
+struct AppCreator {
+    package: Option<String>,
+    new_package_name: Option<String>,
+    app_name: Option<String>,
+    type_: AppType,
+    interactive: bool,
+    dir: PathBuf,
+    owner: String,
+    api: Option<WasmerClient>,
+    user: Option<UserWithNamespaces>,
+    local_package: Option<(PathBuf, wasmer_toml::Manifest)>,
+}
+
+struct AppCreatorOutput {
+    app: AppConfigV1,
+    api_pkg: Option<Package>,
+    local_package: Option<(PathBuf, wasmer_toml::Manifest)>,
+}
+
+impl AppCreator {
+    async fn build_browser_shell_app(self) -> Result<AppCreatorOutput, anyhow::Error> {
+        const WASM_BROWSER_CONTAINER_PACKAGE: &str = "wasmer/wasmer-sh";
+        const WASM_BROWSER_CONTAINER_VERSION: &str = "0.2";
+
+        eprintln!("A browser web shell wraps another package and runs it in the browser");
+        eprintln!("Select the package to wrap.");
+
+        let (inner_pkg, _inner_pkg_api) = crate::utils::prompt_for_package(
+            "Package",
+            None,
+            Some(crate::utils::PackageCheckMode::MustExist),
+            self.api.as_ref(),
+        )
+        .await?;
+
+        eprintln!("What should be the name of the wrapper package?");
+
+        let default_name = format!("{}-webshell", inner_pkg.0.name);
+        let outer_pkg_name =
+            crate::utils::prompts::prompt_for_ident("Package name", Some(&default_name))?;
+        let outer_pkg_full_name = format!("{}/{}", self.owner, outer_pkg_name);
+
+        eprintln!("What should be the name of the app?");
+
+        let default_name = if outer_pkg_name.ends_with("webshell") {
+            format!("{}-{}", self.owner, outer_pkg_name)
+        } else {
+            format!("{}-{}-webshell", self.owner, outer_pkg_name)
+        };
+        let app_name = crate::utils::prompts::prompt_for_ident("App name", Some(&default_name))?;
+
+        // Build the package.
+
+        let public_dir = self.dir.join("public");
+        if !public_dir.exists() {
+            std::fs::create_dir_all(&public_dir)?;
+        }
+
+        let init = serde_json::json!({
+            "init": format!("{}/{}", inner_pkg.0.namespace, inner_pkg.0.name),
+            "prompt": inner_pkg.0.name,
+            "no_welcome": true,
+            "connect": format!("wss://{app_name}.wasmer.app/.well-known/edge-vpn"),
+        });
+        let init_path = public_dir.join("init.json");
+        std::fs::write(&init_path, init.to_string())
+            .with_context(|| format!("Failed to write to '{}'", init_path.display()))?;
+
+        let package = wasmer_toml::PackageBuilder::new(
+            outer_pkg_full_name,
+            "0.1.0".parse().unwrap(),
+            format!("{} web shell", inner_pkg.0.name),
+        )
+        .rename_commands_to_raw_command_name(false)
+        .build()?;
+
+        let manifest = wasmer_toml::ManifestBuilder::new(package)
+            .with_dependency(
+                WASM_BROWSER_CONTAINER_PACKAGE,
+                WASM_BROWSER_CONTAINER_VERSION.to_string().parse().unwrap(),
+            )
+            .map_fs("public", PathBuf::from("public"))
+            .build()?;
+
+        let manifest_path = self.dir.join("wasmer.toml");
+
+        let raw = manifest.to_string()?;
+        eprintln!(
+            "Writing wasmer.toml package to '{}'",
+            manifest_path.display()
+        );
+        std::fs::write(&manifest_path, raw)?;
+
+        let app_cfg = AppConfigV1 {
+            app_id: None,
+            name: app_name,
+            owner: Some(self.owner.clone()),
+            cli_args: None,
+            env: Default::default(),
+            volumes: None,
+            domains: None,
+            scaling: None,
+            package: edge_schema::schema::StringWebcIdent(edge_schema::schema::WebcIdent {
+                repository: None,
+                namespace: self.owner,
+                name: outer_pkg_name,
+                tag: None,
+            }),
+            capabilities: None,
+            scheduled_tasks: None,
+            debug: Some(false),
+            extra: Default::default(),
+        };
+
+        Ok(AppCreatorOutput {
+            app: app_cfg,
+            api_pkg: None,
+            local_package: Some((self.dir, manifest)),
+        })
+    }
+
+    async fn build_app(self) -> Result<AppCreatorOutput, anyhow::Error> {
+        let package_opt: Option<StringWebcIdent> = if let Some(package) = self.package {
+            Some(package.parse()?)
+        } else if let Some((_, local)) = self.local_package.as_ref() {
+            let full = format!("{}@{}", local.package.name, local.package.version);
+            let mut pkg_ident = StringWebcIdent::parse(&local.package.name)
+                .with_context(|| format!("local package manifest has invalid name: '{full}'"))?;
+
+            // Pin the version.
+            pkg_ident.0.tag = Some(local.package.version.to_string());
+
+            if self.interactive {
+                eprintln!("Found local package: '{}'", full.green());
+
+                let msg = format!("Use package '{pkg_ident}'");
+
+                let should_use = Confirm::new()
+                    .with_prompt(&msg)
+                    .interact_opt()?
+                    .unwrap_or_default();
+
+                if should_use {
+                    Some(pkg_ident)
+                } else {
+                    None
+                }
+            } else {
+                Some(pkg_ident)
+            }
+        } else {
+            None
+        };
+
+        let (pkg, api_pkg, local_package) = if let Some(pkg) = package_opt {
+            if let Some(api) = &self.api {
+                let p2 = wasmer_api::query::get_package(
+                    api,
+                    format!("{}/{}", pkg.0.namespace, pkg.0.name),
+                )
+                .await?;
+
+                (pkg, p2, self.local_package)
+            } else {
+                (pkg, None, self.local_package)
+            }
+        } else {
+            eprintln!("No package found or specified.");
+
+            let ty = match self.type_ {
+                AppType::HttpServer => None,
+                AppType::StaticWebsite => Some(PackageType::StaticWebsite),
+                AppType::BrowserShell => None,
+                AppType::JsWorker => Some(PackageType::JsWorker),
+                AppType::PyApplication => Some(PackageType::PyApplication),
+            };
+
+            let create_mode = match ty {
+                Some(PackageType::StaticWebsite)
+                | Some(PackageType::JsWorker)
+                | Some(PackageType::PyApplication) => CreateMode::Create,
+                // Only static website creation is currently supported.
+                _ => CreateMode::SelectExisting,
+            };
+
+            let w = PackageWizard {
+                path: self.dir.clone(),
+                name: self.new_package_name.clone(),
+                type_: ty,
+                create_mode,
+                namespace: Some(self.owner.clone()),
+                namespace_default: self.user.as_ref().map(|u| u.username.clone()),
+                user: self.user.clone(),
+            };
+
+            let output = w.run(self.api.as_ref()).await?;
+            (
+                output.ident,
+                output.api,
+                output
+                    .local_path
+                    .and_then(move |x| Some((x, output.local_manifest?))),
+            )
+        };
+
+        let name = if let Some(name) = self.app_name {
+            name
+        } else {
+            let default = match self.type_ {
+                AppType::HttpServer | AppType::StaticWebsite => {
+                    format!("{}-{}", pkg.0.namespace, pkg.0.name)
+                }
+                AppType::JsWorker | AppType::PyApplication => {
+                    format!("{}-{}-worker", pkg.0.namespace, pkg.0.name)
+                }
+                AppType::BrowserShell => {
+                    format!("{}-{}-webshell", pkg.0.namespace, pkg.0.name)
+                }
+            };
+
+            dialoguer::Input::new()
+                .with_prompt("What should be the name of the app? <NAME>.wasmer.app")
+                .with_initial_text(default)
+                .interact_text()
+                .unwrap()
+        };
+
+        let cli_args = match self.type_ {
+            AppType::PyApplication => Some(vec!["/src/main.py".to_string()]),
+            AppType::JsWorker => Some(vec!["/src/index.js".to_string()]),
+            _ => None,
+        };
+
+        // TODO: check if name already exists.
+        let cfg = AppConfigV1 {
+            app_id: None,
+            owner: Some(self.owner.clone()),
+            volumes: None,
+            name,
+            env: Default::default(),
+            scaling: None,
+            // CLI args are only set for JS and Py workers for now.
+            cli_args,
+            // TODO: allow setting the description.
+            // description: Some("".to_string()),
+            package: pkg.clone(),
+            capabilities: None,
+            scheduled_tasks: None,
+            debug: Some(false),
+            domains: None,
+            extra: Default::default(),
+        };
+
+        Ok(AppCreatorOutput {
+            app: cfg,
+            api_pkg,
+            local_package,
+        })
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppCreate {
+    type Output = (AppConfigV1, Option<DeployAppVersion>);
+
+    async fn run_async(self) -> Result<(AppConfigV1, Option<DeployAppVersion>), anyhow::Error> {
+        let interactive = self.non_interactive == false && std::io::stdin().is_terminal();
+
+        let base_path = if let Some(p) = self.path {
+            p
+        } else {
+            std::env::current_dir()?
+        };
+
+        let (base_dir, appcfg_path) = if base_path.is_file() {
+            let dir = base_path
+                .canonicalize()?
+                .parent()
+                .context("could not determine parent directory")?
+                .to_owned();
+
+            (dir, base_path)
+        } else if base_path.is_dir() {
+            let full = base_path.join(AppConfigV1::CANONICAL_FILE_NAME);
+            (base_path, full)
+        } else {
+            bail!("No such file or directory: '{}'", base_path.display());
+        };
+
+        if appcfg_path.is_file() {
+            bail!(
+                "App configuration file already exists at '{}'",
+                appcfg_path.display()
+            );
+        }
+
+        let api = if self.offline {
+            None
+        } else {
+            Some(self.api.client()?)
+        };
+
+        let user = if let Some(api) = &api {
+            let u = wasmer_api::query::current_user_with_namespaces(
+                api,
+                Some(wasmer_api::types::GrapheneRole::Admin),
+            )
+            .await?;
+            Some(u)
+        } else {
+            None
+        };
+
+        let type_ = match self.template {
+            Some(t) => t,
+            None => {
+                if interactive {
+                    let index = dialoguer::Select::new()
+                        .with_prompt("App type")
+                        .default(0)
+                        .items(&[
+                            "Static website",
+                            "HTTP server",
+                            "Browser shell",
+                            "JS Worker (WinterJS)",
+                            "Python Application",
+                        ])
+                        .interact()?;
+                    match index {
+                        0 => AppType::StaticWebsite,
+                        1 => AppType::HttpServer,
+                        2 => AppType::BrowserShell,
+                        3 => AppType::JsWorker,
+                        4 => AppType::PyApplication,
+                        x => panic!("unhandled app type index '{x}'"),
+                    }
+                } else {
+                    bail!("No app type specified: use --type XXX");
+                }
+            }
+        };
+
+        let owner = if let Some(owner) = self.owner {
+            owner
+        } else if interactive {
+            crate::utils::prompts::prompt_for_namespace(
+                "Who should own this package?",
+                None,
+                user.as_ref(),
+            )?
+        } else {
+            bail!("No owner specified: use --owner XXX");
+        };
+
+        let allow_local_package = match type_ {
+            AppType::HttpServer => true,
+            AppType::StaticWebsite => true,
+            AppType::BrowserShell => false,
+            AppType::JsWorker => true,
+            AppType::PyApplication => true,
+        };
+
+        let local_package = if allow_local_package {
+            match crate::utils::load_package_manifest(&base_dir) {
+                Ok(Some(p)) => Some(p),
+                Ok(None) => None,
+                Err(err) => {
+                    eprintln!(
+                        "{warning}: could not load package manifest: {err}",
+                        warning = "Warning".yellow(),
+                    );
+                    None
+                }
+            }
+        } else {
+            None
+        };
+
+        let creator = AppCreator {
+            app_name: self.name,
+            new_package_name: self.new_package_name,
+            package: self.package,
+            type_,
+            interactive,
+            dir: base_dir,
+            owner: owner.clone(),
+            api,
+            user,
+            local_package,
+        };
+
+        let output = match type_ {
+            AppType::HttpServer
+            | AppType::StaticWebsite
+            | AppType::JsWorker
+            | AppType::PyApplication => creator.build_app().await?,
+            AppType::BrowserShell => creator.build_browser_shell_app().await?,
+        };
+
+        let AppCreatorOutput {
+            app: cfg,
+            api_pkg,
+            local_package,
+            ..
+        } = output;
+
+        let deploy_now = if self.offline {
+            false
+        } else if self.non_interactive {
+            true
+        } else {
+            Confirm::new()
+                .with_prompt("Would you like to publish the app now?".to_string())
+                .interact()?
+        };
+
+        // Make sure to write out the app.yaml to avoid not creating it when the
+        // publish or deploy step fails.
+        // (the later flow only writes a new app.yaml after a success)
+        let raw_app_config = cfg.clone().to_yaml()?;
+        std::fs::write(&appcfg_path, raw_app_config).with_context(|| {
+            format!("could not write app config to '{}'", appcfg_path.display())
+        })?;
+
+        let (final_config, app_version) = if deploy_now {
+            eprintln!("Creating the app...");
+
+            let api = self.api.client()?;
+
+            if api_pkg.is_none() {
+                if let Some((path, manifest)) = &local_package {
+                    eprintln!("Publishing package...");
+                    let manifest = manifest.clone();
+                    crate::utils::republish_package_with_bumped_version(&api, path, manifest)
+                        .await?;
+                }
+            }
+
+            let raw_config = cfg.clone().to_yaml()?;
+            std::fs::write(&appcfg_path, raw_config).with_context(|| {
+                format!("could not write config to '{}'", appcfg_path.display())
+            })?;
+
+            let wait_mode = if self.no_wait {
+                WaitMode::Deployed
+            } else {
+                WaitMode::Reachable
+            };
+
+            let opts = DeployAppOpts {
+                app: &cfg,
+                original_config: None,
+                allow_create: true,
+                make_default: true,
+                owner: Some(owner.clone()),
+                wait: wait_mode,
+            };
+            let (_app, app_version) = deploy_app_verbose(&api, opts).await?;
+
+            let new_cfg = super::app_config_from_api(&app_version)?;
+            (new_cfg, Some(app_version))
+        } else {
+            (cfg, None)
+        };
+
+        eprintln!("Writing app config to '{}'", appcfg_path.display());
+        let raw_final_config = final_config.clone().to_yaml()?;
+        std::fs::write(&appcfg_path, raw_final_config)
+            .with_context(|| format!("could not write config to '{}'", appcfg_path.display()))?;
+
+        eprintln!("To (re)deploy your app, run 'wasmer deploy'");
+
+        Ok((final_config, app_version))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_app_create_static_site_offline() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let cmd = CmdAppCreate {
+            template: Some(AppType::StaticWebsite),
+            publish_package: false,
+            no_validate: false,
+            non_interactive: true,
+            offline: true,
+            owner: Some("testuser".to_string()),
+            new_package_name: Some("static-site-1".to_string()),
+            name: Some("static-site-1".to_string()),
+            path: Some(dir.path().to_owned()),
+            no_wait: true,
+            api: ApiOpts::default(),
+            fmt: ItemFormatOpts::default(),
+            package: None,
+        };
+        cmd.run_async().await.unwrap();
+
+        let app = std::fs::read_to_string(dir.path().join("app.yaml")).unwrap();
+        assert_eq!(
+            app,
+            r#"---
+kind: wasmer.io/App.v0
+name: static-site-1
+owner: testuser
+package: testuser/static-site-1@0.1.0
+debug: false
+"#,
+        );
+    }
+
+    #[tokio::test]
+    async fn test_app_create_offline_with_package() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let cmd = CmdAppCreate {
+            template: Some(AppType::HttpServer),
+            publish_package: false,
+            no_validate: false,
+            non_interactive: true,
+            offline: true,
+            owner: Some("wasmer".to_string()),
+            new_package_name: None,
+            name: Some("testapp".to_string()),
+            path: Some(dir.path().to_owned()),
+            no_wait: true,
+            api: ApiOpts::default(),
+            fmt: ItemFormatOpts::default(),
+            package: Some("wasmer/testpkg".to_string()),
+        };
+        cmd.run_async().await.unwrap();
+
+        let app = std::fs::read_to_string(dir.path().join("app.yaml")).unwrap();
+        assert_eq!(
+            app,
+            r#"---
+kind: wasmer.io/App.v0
+name: testapp
+owner: wasmer
+package: wasmer/testpkg
+debug: false
+"#,
+        );
+    }
+    #[tokio::test]
+    async fn test_app_create_js_worker() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let cmd = CmdAppCreate {
+            template: Some(AppType::JsWorker),
+            publish_package: false,
+            no_validate: false,
+            non_interactive: true,
+            offline: true,
+            owner: Some("wasmer".to_string()),
+            new_package_name: None,
+            name: Some("test-js-worker".to_string()),
+            path: Some(dir.path().to_owned()),
+            no_wait: true,
+            api: ApiOpts::default(),
+            fmt: ItemFormatOpts::default(),
+            package: Some("wasmer/test-js-worker".to_string()),
+        };
+        cmd.run_async().await.unwrap();
+
+        let app = std::fs::read_to_string(dir.path().join("app.yaml")).unwrap();
+        assert_eq!(
+            app,
+            r#"---
+kind: wasmer.io/App.v0
+name: test-js-worker
+owner: wasmer
+package: wasmer/test-js-worker
+cli_args:
+  - /src/index.js
+debug: false
+"#,
+        );
+    }
+
+    #[tokio::test]
+    async fn test_app_create_py_worker() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let cmd = CmdAppCreate {
+            template: Some(AppType::PyApplication),
+            publish_package: false,
+            no_validate: false,
+            non_interactive: true,
+            offline: true,
+            owner: Some("wasmer".to_string()),
+            new_package_name: None,
+            name: Some("test-py-worker".to_string()),
+            path: Some(dir.path().to_owned()),
+            no_wait: true,
+            api: ApiOpts::default(),
+            fmt: ItemFormatOpts::default(),
+            package: Some("wasmer/test-py-worker".to_string()),
+        };
+        cmd.run_async().await.unwrap();
+
+        let app = std::fs::read_to_string(dir.path().join("app.yaml")).unwrap();
+        assert_eq!(
+            app,
+            r#"---
+kind: wasmer.io/App.v0
+name: test-py-worker
+owner: wasmer
+package: wasmer/test-py-worker
+cli_args:
+  - /src/main.py
+debug: false
+"#,
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/delete.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/delete.rs
new file mode 100644
index 0000000..fa6d0b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/delete.rs
@@ -0,0 +1,61 @@
+//! Delete an Edge app.
+
+use dialoguer::Confirm;
+use is_terminal::IsTerminal;
+
+use super::util::AppIdentOpts;
+use crate::{commands::AsyncCliCommand, opts::ApiOpts};
+
+/// Show an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppDelete {
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    #[clap(long)]
+    non_interactive: bool,
+
+    #[clap(flatten)]
+    ident: AppIdentOpts,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppDelete {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let interactive = std::io::stdin().is_terminal() && !self.non_interactive;
+        let client = self.api.client()?;
+
+        eprintln!("Looking up the app...");
+        let (_ident, app) = self.ident.load_app(&client).await?;
+
+        if interactive {
+            let should_use = Confirm::new()
+                .with_prompt(&format!(
+                    "Really delete the app '{}/{}'? (id: {})",
+                    app.owner.global_name,
+                    app.name,
+                    app.id.inner()
+                ))
+                .interact()?;
+
+            if !should_use {
+                eprintln!("App will not be deleted.");
+                return Ok(());
+            }
+        }
+
+        eprintln!(
+            "Deleting app {}/{} (id: {})...",
+            app.owner.global_name,
+            app.name,
+            app.id.inner(),
+        );
+        wasmer_api::query::delete_app(&client, app.id.into_inner()).await?;
+
+        eprintln!("App '{}/{}' was deleted!", app.owner.global_name, app.name);
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/get.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/get.rs
new file mode 100644
index 0000000..5c16636
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/get.rs
@@ -0,0 +1,38 @@
+//! Get information about an edge app.
+
+use wasmer_api::types::DeployApp;
+
+use super::util::AppIdentOpts;
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Show an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppGet {
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub api: ApiOpts,
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub fmt: ItemFormatOpts,
+
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub ident: AppIdentOpts,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppGet {
+    type Output = DeployApp;
+
+    async fn run_async(self) -> Result<DeployApp, anyhow::Error> {
+        let client = self.api.client()?;
+        let (_ident, app) = self.ident.load_app(&client).await?;
+
+        println!("{}", self.fmt.format.render(&app));
+
+        Ok(app)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/info.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/info.rs
new file mode 100644
index 0000000..5455bfd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/info.rs
@@ -0,0 +1,38 @@
+//! Show short information about an Edge app.
+
+use super::util::AppIdentOpts;
+use crate::{commands::AsyncCliCommand, opts::ApiOpts};
+
+/// Show short information about an Edge app.
+///
+/// Use `app get` to get more detailed information.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppInfo {
+    #[clap(flatten)]
+    api: ApiOpts,
+    #[clap(flatten)]
+    ident: AppIdentOpts,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppInfo {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        let (_ident, app) = self.ident.load_app(&client).await?;
+
+        let app_url = app.url;
+        let versioned_url = app.active_version.url;
+        let dashboard_url = app.admin_url;
+
+        println!("  App Info  ");
+        println!("> App Name: {}", app.name);
+        println!("> Namespace: {}", app.owner.global_name);
+        println!("> App URL: {}", app_url);
+        println!("> Versioned URL: {}", versioned_url);
+        println!("> Admin dashboard: {}", dashboard_url);
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/list.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/list.rs
new file mode 100644
index 0000000..053879e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/list.rs
@@ -0,0 +1,104 @@
+//! List Edge apps.
+
+use std::pin::Pin;
+
+use futures::{Stream, StreamExt};
+use wasmer_api::types::DeployApp;
+
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ListFormatOpts},
+};
+
+/// List apps.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppList {
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Get apps in a specific namespace.
+    ///
+    /// Will fetch the apps owned by the current user otherwise.
+    #[clap(short = 'n', long)]
+    namespace: Option<String>,
+
+    /// Get all apps that are accessible by the current user, including apps
+    /// directly owned by the user and apps in namespaces the user can access.
+    #[clap(short = 'a', long)]
+    all: bool,
+
+    /// Maximum number of apps to display
+    #[clap(long, default_value = "1000")]
+    max: usize,
+
+    /// Asks whether to display the next page or not
+    #[clap(long, default_value = "false")]
+    paging_mode: bool,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let apps_stream: Pin<
+            Box<dyn Stream<Item = Result<Vec<DeployApp>, anyhow::Error>> + Send + Sync>,
+        > = if let Some(ns) = self.namespace.clone() {
+            Box::pin(wasmer_api::query::namespace_apps(&client, ns).await)
+        } else if self.all {
+            Box::pin(wasmer_api::query::user_accessible_apps(&client).await?)
+        } else {
+            Box::pin(wasmer_api::query::user_apps(&client).await)
+        };
+
+        let mut apps_stream = std::pin::pin!(apps_stream);
+
+        let mut rem = self.max;
+
+        let mut display_apps = vec![];
+
+        'list: while let Some(apps) = apps_stream.next().await {
+            let mut apps = apps?;
+
+            let limit = std::cmp::min(apps.len(), rem);
+
+            if limit == 0 {
+                break;
+            }
+
+            rem -= limit;
+
+            if self.paging_mode {
+                println!("{}", self.fmt.format.render(&apps));
+
+                loop {
+                    println!("next page? [y, n]");
+
+                    let mut rsp = String::new();
+                    std::io::stdin().read_line(&mut rsp)?;
+
+                    if rsp.trim() == "y" {
+                        continue 'list;
+                    }
+                    if rsp.trim() == "n" {
+                        break 'list;
+                    }
+
+                    println!("uknown response: {rsp}");
+                }
+            }
+
+            display_apps.extend(apps.drain(..limit));
+        }
+
+        if !display_apps.is_empty() {
+            println!("{}", self.fmt.format.render(&display_apps));
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/logs.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/logs.rs
new file mode 100644
index 0000000..d6792ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/logs.rs
@@ -0,0 +1,204 @@
+//! Show logs for an Edge app.
+
+use comfy_table::Table;
+use edge_schema::pretty_duration::parse_timestamp_or_relative_time;
+use futures::StreamExt;
+use time::{format_description::well_known::Rfc3339, OffsetDateTime};
+use wasmer_api::types::{Log, LogStream};
+
+use crate::{
+    opts::{ApiOpts, ListFormatOpts},
+    utils::{render::CliRender, Identifier},
+};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy, clap::ValueEnum)]
+pub enum LogStreamArg {
+    Stdout,
+    Stderr,
+}
+
+/// Show an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppLogs {
+    #[clap(flatten)]
+    api: ApiOpts,
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+
+    /// The date of the earliest log entry.
+    ///
+    /// Defaults to the last 10 minutes.
+    ///
+    /// Format:
+    /// * RFC 3339 (`2006-01-02T03:04:05-07:00`)
+    /// * RFC 2822 (`Mon, 02 Jan 2006 03:04:05 MST`)
+    /// * Simple date (`2022-11-11`)
+    /// * Unix timestamp (`1136196245`)
+    /// * Relative time (`10m` / `-1h`, `1d1h30s`)
+    // TODO: should default to trailing logs once trailing is implemented.
+    #[clap(long, value_parser = parse_timestamp_or_relative_time)]
+    from: Option<OffsetDateTime>,
+
+    /// The date of the latest log entry.
+    ///
+    /// Format:
+    /// * RFC 3339 (`2006-01-02T03:04:05-07:00`)
+    /// * RFC 2822 (`Mon, 02 Jan 2006 03:04:05 MST`)
+    /// * Simple date (`2022-11-11`)
+    /// * Unix timestamp (`1136196245`)
+    /// * Relative time (`10m` / `1h`, `1d1h30s`)
+    #[clap(long, value_parser = parse_timestamp_or_relative_time)]
+    until: Option<OffsetDateTime>,
+
+    /// Maximum log lines to fetch.
+    /// Defaults to 1000.
+    #[clap(long, default_value = "1000")]
+    max: usize,
+
+    #[clap(long, default_value = "false")]
+    watch: bool,
+
+    /// The name of the app.
+    ///
+    /// Eg:
+    /// - name (assumes current user)
+    /// - namespace/name
+    /// - namespace/name@version
+    ident: Identifier,
+
+    /// Streams of logs to display
+    #[clap(long, value_delimiter = ',', value_enum)]
+    streams: Option<Vec<LogStreamArg>>,
+}
+
+#[async_trait::async_trait]
+impl crate::commands::AsyncCliCommand for CmdAppLogs {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let Identifier {
+            name,
+            owner,
+            version,
+        } = &self.ident;
+
+        let owner = match owner {
+            Some(owner) => owner.to_string(),
+            None => {
+                let user = wasmer_api::query::current_user_with_namespaces(&client, None).await?;
+                user.username
+            }
+        };
+
+        let from = self
+            .from
+            .unwrap_or_else(|| OffsetDateTime::now_utc() - time::Duration::minutes(10));
+
+        tracing::info!(
+            package.name=%self.ident.name,
+            package.owner=%owner,
+            package.version=self.ident.version.as_deref(),
+            range.start=%from,
+            range.end=self.until.map(|ts| ts.to_string()),
+            "Fetching logs",
+        );
+
+        let (stdout, stderr) = self
+            .streams
+            .map(|s| {
+                let mut stdout = false;
+                let mut stderr = false;
+
+                for stream in s {
+                    if matches!(stream, LogStreamArg::Stdout) {
+                        stdout = true;
+                    } else if matches!(stream, LogStreamArg::Stderr) {
+                        stderr = true;
+                    }
+                }
+
+                (stdout, stderr)
+            })
+            .unwrap_or_default();
+
+        let streams = Vec::from(match (stdout, stderr) {
+            (true, true) | (false, false) => &[LogStream::Stdout, LogStream::Stderr][..],
+            (true, false) => &[LogStream::Stdout][..],
+            (false, true) => &[LogStream::Stderr][..],
+        });
+
+        let logs_stream = wasmer_api::query::get_app_logs_paginated(
+            &client,
+            name.clone(),
+            owner.to_string(),
+            version.clone(),
+            from,
+            self.until,
+            self.watch,
+            Some(streams),
+        )
+        .await;
+
+        let mut logs_stream = std::pin::pin!(logs_stream);
+
+        let mut rem = self.max;
+
+        while let Some(logs) = logs_stream.next().await {
+            let mut logs = logs?;
+
+            let limit = std::cmp::min(logs.len(), rem);
+
+            let logs: Vec<_> = logs.drain(..limit).collect();
+
+            if !logs.is_empty() {
+                let rendered = self.fmt.format.render(&logs);
+                println!("{rendered}");
+
+                rem -= limit;
+            }
+
+            if !self.watch || rem == 0 {
+                break;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl CliRender for Log {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+
+        let Log { message, timestamp } = self;
+
+        table.add_rows([
+            vec![
+                "Timestamp".to_string(),
+                datetime_from_unix(*timestamp).format(&Rfc3339).unwrap(),
+            ],
+            vec!["Message".to_string(), message.to_string()],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec!["Timestamp".to_string(), "Message".to_string()]);
+
+        for item in items {
+            table.add_row([
+                datetime_from_unix(item.timestamp).format(&Rfc3339).unwrap(),
+                item.message.clone(),
+            ]);
+        }
+        table.to_string()
+    }
+}
+
+fn datetime_from_unix(timestamp: f64) -> OffsetDateTime {
+    OffsetDateTime::from_unix_timestamp_nanos(timestamp as i128)
+        .expect("Timestamp should always be valid")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/mod.rs
new file mode 100644
index 0000000..3743f87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/mod.rs
@@ -0,0 +1,243 @@
+//! Edge app commands.
+
+pub mod create;
+pub mod delete;
+pub mod get;
+pub mod info;
+pub mod list;
+pub mod logs;
+pub mod version;
+
+mod util;
+
+use std::{io::Write, time::Duration};
+
+use anyhow::{bail, Context};
+use edge_schema::schema::AppConfigV1;
+use wasmer_api::{
+    types::{DeployApp, DeployAppVersion},
+    WasmerClient,
+};
+
+use crate::commands::AsyncCliCommand;
+
+/// Manage Wasmer Deploy apps.
+#[derive(clap::Subcommand, Debug)]
+pub enum CmdApp {
+    Get(get::CmdAppGet),
+    Info(info::CmdAppInfo),
+    List(list::CmdAppList),
+    Logs(logs::CmdAppLogs),
+    Create(create::CmdAppCreate),
+    Delete(delete::CmdAppDelete),
+    #[clap(subcommand)]
+    Version(version::CmdAppVersion),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdApp {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        match self {
+            Self::Get(cmd) => {
+                cmd.run_async().await?;
+                Ok(())
+            }
+            Self::Info(cmd) => {
+                cmd.run_async().await?;
+                Ok(())
+            }
+            Self::Create(cmd) => {
+                cmd.run_async().await?;
+                Ok(())
+            }
+            Self::List(cmd) => cmd.run_async().await,
+            Self::Logs(cmd) => cmd.run_async().await,
+            Self::Delete(cmd) => cmd.run_async().await,
+            Self::Version(cmd) => cmd.run_async().await,
+        }
+    }
+}
+
+pub struct DeployAppOpts<'a> {
+    pub app: &'a AppConfigV1,
+    // Original raw yaml config.
+    // Present here to enable forwarding unknown fields to the backend, which
+    // preserves forwards-compatibility for schema changes.
+    pub original_config: Option<serde_yaml::Value>,
+    pub allow_create: bool,
+    pub make_default: bool,
+    pub owner: Option<String>,
+    pub wait: WaitMode,
+}
+
+pub async fn deploy_app(
+    client: &WasmerClient,
+    opts: DeployAppOpts<'_>,
+) -> Result<DeployAppVersion, anyhow::Error> {
+    let app = opts.app;
+
+    let config_value = app.clone().to_yaml_value()?;
+    let final_config = if let Some(old) = &opts.original_config {
+        crate::utils::merge_yaml_values(old, &config_value)
+    } else {
+        config_value
+    };
+    let mut raw_config = serde_yaml::to_string(&final_config)?.trim().to_string();
+    raw_config.push('\n');
+
+    // TODO: respect allow_create flag
+
+    let version = wasmer_api::query::publish_deploy_app(
+        client,
+        wasmer_api::types::PublishDeployAppVars {
+            config: raw_config,
+            name: app.name.clone().into(),
+            owner: opts.owner.map(|o| o.into()),
+            make_default: Some(opts.make_default),
+        },
+    )
+    .await
+    .context("could not create app in the backend")?;
+
+    Ok(version)
+}
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum WaitMode {
+    /// Wait for the app to be deployed.
+    Deployed,
+    /// Wait for the app to be deployed and ready.
+    Reachable,
+}
+
+/// Same as [Self::deploy], but also prints verbose information.
+pub async fn deploy_app_verbose(
+    client: &WasmerClient,
+    opts: DeployAppOpts<'_>,
+) -> Result<(DeployApp, DeployAppVersion), anyhow::Error> {
+    let owner = &opts.owner.clone().or_else(|| opts.app.owner.clone());
+    let app = &opts.app;
+
+    let pretty_name = if let Some(owner) = &owner {
+        format!("{}/{}", owner, app.name)
+    } else {
+        app.name.clone()
+    };
+
+    let make_default = opts.make_default;
+
+    eprintln!("Deploying app {pretty_name}...\n");
+
+    let wait = opts.wait;
+    let version = deploy_app(client, opts).await?;
+
+    let app_id = version
+        .app
+        .as_ref()
+        .context("app field on app version is empty")?
+        .id
+        .inner()
+        .to_string();
+
+    let app = wasmer_api::query::get_app_by_id(client, app_id.clone())
+        .await
+        .context("could not fetch app from backend")?;
+
+    let full_name = format!("{}/{}", app.owner.global_name, app.name);
+
+    eprintln!(" ✅ App {full_name} was successfully deployed!");
+    eprintln!();
+    eprintln!("> App URL: {}", app.url);
+    eprintln!("> Versioned URL: {}", version.url);
+    eprintln!("> Admin dashboard: {}", app.admin_url);
+
+    match wait {
+        WaitMode::Deployed => {}
+        WaitMode::Reachable => {
+            eprintln!();
+            eprintln!("Waiting for new deployment to become available...");
+            eprintln!("(You can safely stop waiting now with CTRL-C)");
+
+            let stderr = std::io::stderr();
+
+            tokio::time::sleep(Duration::from_secs(2)).await;
+
+            let start = tokio::time::Instant::now();
+            let client = reqwest::Client::new();
+
+            let check_url = if make_default { &app.url } else { &version.url };
+
+            let mut sleep_millis: u64 = 1_000;
+            loop {
+                let total_elapsed = start.elapsed();
+                if total_elapsed > Duration::from_secs(60 * 5) {
+                    eprintln!();
+                    bail!("\nApp still not reachable after 5 minutes...");
+                }
+
+                {
+                    let mut lock = stderr.lock();
+                    write!(&mut lock, ".").unwrap();
+                    lock.flush().unwrap();
+                }
+
+                let request_start = tokio::time::Instant::now();
+
+                match client.get(check_url).send().await {
+                    Ok(res) => {
+                        let header = res
+                            .headers()
+                            .get(edge_util::headers::HEADER_APP_VERSION_ID)
+                            .and_then(|x| x.to_str().ok())
+                            .unwrap_or_default();
+
+                        if header == version.id.inner() {
+                            eprintln!("\nNew version is now reachable at {check_url}");
+                            eprintln!("Deployment complete");
+                            break;
+                        }
+
+                        tracing::debug!(
+                            current=%header,
+                            expected=%app.active_version.id.inner(),
+                            "app is not at the right version yet",
+                        );
+                    }
+                    Err(err) => {
+                        tracing::debug!(?err, "health check request failed");
+                    }
+                };
+
+                let elapsed: u64 = request_start
+                    .elapsed()
+                    .as_millis()
+                    .try_into()
+                    .unwrap_or_default();
+                let to_sleep = Duration::from_millis(sleep_millis.saturating_sub(elapsed));
+                tokio::time::sleep(to_sleep).await;
+                sleep_millis = (sleep_millis * 2).max(10_000);
+            }
+        }
+    }
+
+    Ok((app, version))
+}
+
+pub fn app_config_from_api(version: &DeployAppVersion) -> Result<AppConfigV1, anyhow::Error> {
+    let app_id = version
+        .app
+        .as_ref()
+        .context("app field on app version is empty")?
+        .id
+        .inner()
+        .to_string();
+
+    let cfg = &version.user_yaml_config;
+    let mut cfg = AppConfigV1::parse_yaml(cfg)
+        .context("could not parse app config from backend app version")?;
+
+    cfg.app_id = Some(app_id);
+    Ok(cfg)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/util.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/util.rs
new file mode 100644
index 0000000..53d5987
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/util.rs
@@ -0,0 +1,186 @@
+use anyhow::{bail, Context};
+use edge_schema::schema::AppConfigV1;
+use wasmer_api::{
+    global_id::{GlobalId, NodeKind},
+    types::DeployApp,
+    WasmerClient,
+};
+
+/// App identifier.
+///
+/// Can be either a namespace/name a plain name or an app id.
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum AppIdent {
+    AppId(String),
+    NamespacedName(String, String),
+    Alias(String),
+}
+
+impl AppIdent {
+    /// Resolve an app identifier through the API.
+    pub async fn resolve(&self, client: &WasmerClient) -> Result<DeployApp, anyhow::Error> {
+        match self {
+            AppIdent::AppId(app_id) => wasmer_api::query::get_app_by_id(client, app_id.clone())
+                .await
+                .with_context(|| format!("Could not find app with id '{}'", app_id)),
+            AppIdent::Alias(name) => wasmer_api::query::get_app_by_alias(client, name.clone())
+                .await?
+                .with_context(|| format!("Could not find app with name '{name}'")),
+            AppIdent::NamespacedName(owner, name) => {
+                wasmer_api::query::get_app(client, owner.clone(), name.clone())
+                    .await?
+                    .with_context(|| format!("Could not find app '{owner}/{name}'"))
+            }
+        }
+    }
+}
+
+impl std::str::FromStr for AppIdent {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some((namespace, name)) = s.split_once('/') {
+            if namespace.is_empty() {
+                bail!("invalid app identifier '{s}': namespace can not be empty");
+            }
+            if name.is_empty() {
+                bail!("invalid app identifier '{s}': name can not be empty");
+            }
+
+            Ok(Self::NamespacedName(
+                namespace.to_string(),
+                name.to_string(),
+            ))
+        } else if let Ok(id) = GlobalId::parse_prefixed(s) {
+            if id.kind() == NodeKind::DeployApp {
+                Ok(Self::AppId(s.to_string()))
+            } else {
+                bail!(
+                    "invalid app identifier '{s}': expected an app id, but id is of type {kind}",
+                    kind = id.kind(),
+                );
+            }
+        } else {
+            Ok(Self::Alias(s.to_string()))
+        }
+    }
+}
+
+pub fn get_app_config_from_current_dir() -> Result<(AppConfigV1, std::path::PathBuf), anyhow::Error>
+{
+    // read the information from local `app.yaml
+    let current_dir = std::env::current_dir()?;
+    let app_config_path = current_dir.join(AppConfigV1::CANONICAL_FILE_NAME);
+
+    if !app_config_path.exists() || !app_config_path.is_file() {
+        bail!(
+            "Could not find app.yaml at path: '{}'.\nPlease specify an app like 'wasmer app get <namespace>/<name>' or 'wasmer app get <name>`'",
+            app_config_path.display()
+        );
+    }
+    // read the app.yaml
+    let raw_app_config = std::fs::read_to_string(&app_config_path)
+        .with_context(|| format!("Could not read file '{}'", app_config_path.display()))?;
+
+    // parse the app.yaml
+    let config = AppConfigV1::parse_yaml(&raw_app_config)
+        .map_err(|err| anyhow::anyhow!("Could not parse app.yaml: {err:?}"))?;
+
+    Ok((config, app_config_path))
+}
+
+/// Options for identifying an app.
+///
+/// Provides convenience methods for resolving an app identifier or loading it
+/// from a local app.yaml.
+#[derive(clap::Parser, Debug)]
+pub struct AppIdentOpts {
+    /// Identifier of the application.
+    ///
+    /// NOTE: If not specified, the command will look for an app config file in
+    /// the current directory.
+    ///
+    /// Valid input:
+    /// - namespace/app-name
+    /// - app-alias
+    /// - App ID
+    pub app_ident: Option<AppIdent>,
+}
+
+// Allowing because this is not performance-critical at all.
+#[allow(clippy::large_enum_variant)]
+pub enum ResolvedAppIdent {
+    Ident(AppIdent),
+    Config {
+        ident: AppIdent,
+        config: AppConfigV1,
+        path: std::path::PathBuf,
+    },
+}
+
+impl ResolvedAppIdent {
+    pub fn ident(&self) -> &AppIdent {
+        match self {
+            Self::Ident(ident) => ident,
+            Self::Config { ident, .. } => ident,
+        }
+    }
+}
+
+impl AppIdentOpts {
+    pub fn resolve_static(&self) -> Result<ResolvedAppIdent, anyhow::Error> {
+        if let Some(id) = &self.app_ident {
+            return Ok(ResolvedAppIdent::Ident(id.clone()));
+        }
+
+        // Try to load from local.
+        let (config, path) = get_app_config_from_current_dir()?;
+
+        let ident = if let Some(id) = &config.app_id {
+            AppIdent::AppId(id.clone())
+        } else {
+            AppIdent::Alias(config.name.clone())
+        };
+
+        Ok(ResolvedAppIdent::Config {
+            ident,
+            config,
+            path,
+        })
+    }
+
+    /// Load the specified app from the API.
+    pub async fn load_app(
+        &self,
+        client: &WasmerClient,
+    ) -> Result<(ResolvedAppIdent, DeployApp), anyhow::Error> {
+        let id = self.resolve_static()?;
+        let app = id.ident().resolve(client).await?;
+
+        Ok((id, app))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use super::*;
+
+    #[test]
+    fn test_app_ident() {
+        assert_eq!(
+            AppIdent::from_str("da_MRrWI0t5U582").unwrap(),
+            AppIdent::AppId("da_MRrWI0t5U582".to_string()),
+        );
+        assert_eq!(
+            AppIdent::from_str("lala").unwrap(),
+            AppIdent::Alias("lala".to_string()),
+        );
+
+        assert_eq!(
+            AppIdent::from_str("alpha/beta").unwrap(),
+            AppIdent::NamespacedName("alpha".to_string(), "beta".to_string()),
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/activate.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/activate.rs
new file mode 100644
index 0000000..e54341e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/activate.rs
@@ -0,0 +1,43 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Switch the active version of an app. (rollback / rollforward)
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppVersionActivate {
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub api: ApiOpts,
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub fmt: ItemFormatOpts,
+
+    /// App version ID to activate.
+    ///
+    /// This must be the unique version ID, not the version name!
+    /// Eg: dav_xYzaB1aaaaax
+    pub version: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppVersionActivate {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let app = wasmer_api::query::app_version_activate(&client, self.version).await?;
+
+        eprintln!(
+            "Changed active version of app '{}/{}' from '{}' to '{}' (id: {})",
+            app.owner.global_name,
+            app.name,
+            app.active_version.version,
+            app.active_version.version,
+            app.active_version.id.inner()
+        );
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/get.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/get.rs
new file mode 100644
index 0000000..c13f569
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/get.rs
@@ -0,0 +1,48 @@
+use anyhow::Context;
+
+use crate::{
+    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Show information for a specific app version.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppVersionGet {
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub api: ApiOpts,
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub fmt: ItemFormatOpts,
+
+    /// *Name* of the version - NOT the unique version id!
+    #[clap(long)]
+    pub name: String,
+
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub ident: AppIdentOpts,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppVersionGet {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        let (_ident, app) = self.ident.load_app(&client).await?;
+
+        let version = wasmer_api::query::get_app_version(
+            &client,
+            app.owner.global_name,
+            app.name,
+            self.name.clone(),
+        )
+        .await?
+        .with_context(|| format!("Could not find app version '{}'", self.name))?;
+
+        println!("{}", self.fmt.format.render(&version));
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/list.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/list.rs
new file mode 100644
index 0000000..c184cd0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/list.rs
@@ -0,0 +1,107 @@
+use wasmer_api::types::{DeployAppVersionsSortBy, GetDeployAppVersionsVars};
+
+use crate::{
+    commands::{app::util::AppIdentOpts, AsyncCliCommand},
+    opts::{ApiOpts, ListFormatOpts},
+};
+
+/// List versions of an app.
+#[derive(clap::Parser, Debug)]
+pub struct CmdAppVersionList {
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub api: ApiOpts,
+    #[allow(missing_docs)]
+    #[clap(flatten)]
+    pub fmt: ListFormatOpts,
+
+    /// Get all versions of the app.
+    /// Overrides pagination flags (--max, --offset).
+    #[clap(short = 'a', long)]
+    all: bool,
+
+    /// Pagination offset - get versions after this offset.
+    ///
+    /// See also: --max, --before, --after
+    #[clap(long)]
+    offset: Option<u32>,
+
+    /// Maximum number of items to return.
+    ///
+    /// See also: --offset, --before, --after
+    #[clap(long)]
+    max: Option<u32>,
+
+    /// Pagination cursor - get versions before this version.
+    ///
+    /// See also: --max, --offset, --after
+    #[clap(long)]
+    before: Option<String>,
+
+    /// Pagination cursor - get versions after this version.
+    ///
+    /// See also: --max, --offset, --before
+    #[clap(long)]
+    after: Option<String>,
+
+    #[clap(long)]
+    sort: Option<Sort>,
+
+    #[clap(flatten)]
+    #[allow(missing_docs)]
+    pub ident: AppIdentOpts,
+}
+
+#[derive(Clone, Copy, clap::ValueEnum, Debug)]
+enum Sort {
+    Newest,
+    Oldest,
+}
+
+impl From<Sort> for DeployAppVersionsSortBy {
+    fn from(val: Sort) -> Self {
+        match val {
+            Sort::Newest => DeployAppVersionsSortBy::Newest,
+            Sort::Oldest => DeployAppVersionsSortBy::Oldest,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppVersionList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        let (_ident, app) = self.ident.load_app(&client).await?;
+
+        let versions = if self.all {
+            wasmer_api::query::all_app_versions(&client, app.owner.global_name, app.name).await?
+        } else {
+            let vars = GetDeployAppVersionsVars {
+                owner: app.owner.global_name,
+                name: app.name,
+                offset: self.offset.map(|x| x as i32),
+                before: self.before,
+                after: self.after,
+                first: self.max.map(|x| x as i32),
+                last: None,
+                sort_by: self.sort.map(|x| x.into()),
+            };
+
+            let versions =
+                wasmer_api::query::get_deploy_app_versions(&client, vars.clone()).await?;
+
+            versions
+                .edges
+                .into_iter()
+                .flatten()
+                .filter_map(|edge| edge.node)
+                .collect::<Vec<_>>()
+        };
+
+        println!("{}", self.fmt.format.render(&versions));
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/mod.rs
new file mode 100644
index 0000000..86315bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/app/version/mod.rs
@@ -0,0 +1,28 @@
+//! Edge app version management.
+
+use crate::commands::AsyncCliCommand;
+
+pub mod activate;
+pub mod get;
+pub mod list;
+
+/// Manage app versions.
+#[derive(clap::Subcommand, Debug)]
+pub enum CmdAppVersion {
+    Get(get::CmdAppVersionGet),
+    List(list::CmdAppVersionList),
+    Activate(activate::CmdAppVersionActivate),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdAppVersion {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        match self {
+            Self::Get(cmd) => cmd.run_async().await,
+            Self::List(cmd) => cmd.run_async().await,
+            Self::Activate(cmd) => cmd.run_async().await,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/binfmt.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/binfmt.rs
new file mode 100644
index 0000000..271386e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/binfmt.rs
@@ -0,0 +1,155 @@
+use std::{
+    env, fs,
+    io::Write,
+    os::unix::{ffi::OsStrExt, fs::MetadataExt},
+    path::{Path, PathBuf},
+};
+
+use anyhow::{bail, Context, Result};
+use clap::Parser;
+use Action::*;
+
+#[derive(Debug, Parser, Clone, Copy)]
+enum Action {
+    /// Register wasmer as binfmt interpreter
+    Register,
+    /// Unregister a binfmt interpreter for wasm32
+    Unregister,
+    /// Soft unregister, and register
+    Reregister,
+}
+
+/// Unregister and/or register wasmer as binfmt interpreter
+///
+/// Check the wasmer repository for a systemd service definition example
+/// to automate the process at start-up.
+#[derive(Debug, Parser)]
+pub struct Binfmt {
+    // Might be better to traverse the mount list
+    /// Mount point of binfmt_misc fs
+    #[clap(long, default_value = "/proc/sys/fs/binfmt_misc/")]
+    binfmt_misc: PathBuf,
+
+    #[clap(subcommand)]
+    action: Action,
+}
+
+// Quick safety check:
+// This folder isn't world writeable (or else its sticky bit is set), and neither are its parents.
+//
+// If somebody mounted /tmp wrong, this might result in a TOCTOU problem.
+fn seccheck(path: &Path) -> Result<()> {
+    if let Some(parent) = path.parent() {
+        seccheck(parent)?;
+    }
+    let m = std::fs::metadata(path)
+        .with_context(|| format!("Can't check permissions of {}", path.to_string_lossy()))?;
+    use unix_mode::*;
+    anyhow::ensure!(
+        !is_allowed(Accessor::Other, Access::Write, m.mode()) || is_sticky(m.mode()),
+        "{} is world writeable and not sticky",
+        path.to_string_lossy()
+    );
+    Ok(())
+}
+
+impl Binfmt {
+    /// The filename used to register the wasmer CLI as a binfmt interpreter.
+    pub const FILENAME: &str = "wasmer-binfmt-interpreter";
+
+    /// execute [Binfmt]
+    pub fn execute(&self) -> Result<()> {
+        if !self.binfmt_misc.exists() {
+            panic!("{} does not exist", self.binfmt_misc.to_string_lossy());
+        }
+        let temp_dir;
+        let specs = match self.action {
+            Register | Reregister => {
+                temp_dir = tempfile::tempdir().context("Make temporary directory")?;
+                seccheck(temp_dir.path())?;
+                let bin_path_orig: PathBuf = env::current_exe()
+                    .and_then(|p| p.canonicalize())
+                    .context("Cannot get path to wasmer executable")?;
+                let bin_path = temp_dir.path().join(Binfmt::FILENAME);
+                fs::copy(bin_path_orig, &bin_path).context("Copy wasmer binary to temp folder")?;
+                let bin_path = fs::canonicalize(&bin_path).with_context(|| {
+                    format!(
+                        "Couldn't get absolute path for {}",
+                        bin_path.to_string_lossy()
+                    )
+                })?;
+                Some([
+                    [
+                        b":wasm32:M::\\x00asm\\x01\\x00\\x00::".as_ref(),
+                        bin_path.as_os_str().as_bytes(),
+                        b":PFC",
+                    ]
+                    .concat(),
+                    [
+                        b":wasm32-wat:E::wat::".as_ref(),
+                        bin_path.as_os_str().as_bytes(),
+                        b":PFC",
+                    ]
+                    .concat(),
+                ])
+            }
+            _ => None,
+        };
+        let wasm_registration = self.binfmt_misc.join("wasm32");
+        let wat_registration = self.binfmt_misc.join("wasm32-wat");
+        match self.action {
+            Reregister | Unregister => {
+                let unregister = [wasm_registration, wat_registration]
+                    .iter()
+                    .map(|registration| {
+                        if registration.exists() {
+                            let mut registration = fs::OpenOptions::new()
+                                .write(true)
+                                .open(registration)
+                                .context("Open existing binfmt entry to remove")?;
+                            registration
+                                .write_all(b"-1")
+                                .context("Couldn't write binfmt unregister request")?;
+                            Ok(true)
+                        } else {
+                            eprintln!(
+                                "Warning: {} does not exist, not unregistered.",
+                                registration.to_string_lossy()
+                            );
+                            Ok(false)
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .collect::<Result<Vec<_>>>()?;
+                if let (Unregister, false) = (self.action, unregister.into_iter().any(|b| b)) {
+                    bail!("Nothing unregistered");
+                }
+            }
+            _ => (),
+        };
+        if let Some(specs) = specs {
+            if cfg!(target_env = "gnu") {
+                // Approximate. ELF parsing for a proper check feels like overkill here.
+                eprintln!("Warning: wasmer has been compiled for glibc, and is thus likely dynamically linked. Invoking wasm binaries in chroots or mount namespaces (lxc, docker, ...) may not work.");
+            }
+            specs
+                .iter()
+                .map(|spec| {
+                    let register = self.binfmt_misc.join("register");
+                    let mut register = fs::OpenOptions::new()
+                        .write(true)
+                        .open(register)
+                        .context("Open binfmt misc for registration")?;
+                    register
+                        .write_all(spec)
+                        .context("Couldn't register binfmt")?;
+                    Ok(())
+                })
+                .collect::<Vec<_>>()
+                .into_iter()
+                .collect::<Result<Vec<_>>>()?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/cache.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/cache.rs
new file mode 100644
index 0000000..bd6ff0f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/cache.rs
@@ -0,0 +1,51 @@
+use std::{fs, path::Path};
+
+use anyhow::Result;
+use clap::Parser;
+use wasmer_registry::wasmer_env::WasmerEnv;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer cache` subcommand
+pub struct Cache {
+    #[clap(flatten)]
+    env: WasmerEnv,
+    /// The operation to perform.
+    #[clap(subcommand)]
+    cmd: Cmd,
+}
+
+impl Cache {
+    /// Execute the cache command
+    pub fn execute(&self) -> Result<()> {
+        let cache_dir = self.env.cache_dir();
+
+        match self.cmd {
+            Cmd::Clean => {
+                clean(&cache_dir)?;
+            }
+            Cmd::Dir => {
+                println!("{}", self.env.cache_dir().display());
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Copy, Clone, Parser)]
+enum Cmd {
+    /// Clear the cache
+    Clean,
+    /// Display the location of the cache
+    Dir,
+}
+
+fn clean(cache_dir: &Path) -> Result<()> {
+    if cache_dir.exists() {
+        fs::remove_dir_all(cache_dir)?;
+    }
+    fs::create_dir_all(cache_dir)?;
+    eprintln!("Wasmer cache cleaned successfully.");
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/compile.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/compile.rs
new file mode 100644
index 0000000..9739b28
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/compile.rs
@@ -0,0 +1,86 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use wasmer::*;
+
+use crate::{store::StoreOptions, warning};
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer compile` subcommand
+pub struct Compile {
+    /// Input file
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    /// Output file
+    #[clap(name = "OUTPUT PATH", short = 'o')]
+    output: PathBuf,
+
+    /// Compilation Target triple
+    #[clap(long = "target")]
+    target_triple: Option<Triple>,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+
+    #[clap(short = 'm')]
+    cpu_features: Vec<CpuFeature>,
+}
+
+impl Compile {
+    /// Runs logic for the `compile` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to compile `{}`", self.path.display()))
+    }
+
+    fn inner_execute(&self) -> Result<()> {
+        let target = self
+            .target_triple
+            .as_ref()
+            .map(|target_triple| {
+                let mut features = self
+                    .cpu_features
+                    .clone()
+                    .into_iter()
+                    .fold(CpuFeature::set(), |a, b| a | b);
+                // Cranelift requires SSE2, so we have this "hack" for now to facilitate
+                // usage
+                if target_triple.architecture == Architecture::X86_64 {
+                    features |= CpuFeature::SSE2;
+                }
+                Target::new(target_triple.clone(), features)
+            })
+            .unwrap_or_default();
+        let (store, compiler_type) = self.store.get_store_for_target(target.clone())?;
+        let output_filename = self
+            .output
+            .file_stem()
+            .map(|osstr| osstr.to_string_lossy().to_string())
+            .unwrap_or_default();
+        // wasmu stands for "WASM Universal"
+        let recommended_extension = "wasmu";
+        match self.output.extension() {
+            Some(ext) => {
+                if ext != recommended_extension {
+                    warning!("the output file has a wrong extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+                }
+            }
+            None => {
+                warning!("the output file has no extension. We recommend using `{}.{}` for the chosen target", &output_filename, &recommended_extension)
+            }
+        }
+        println!("Compiler: {}", compiler_type.to_string());
+        println!("Target: {}", target.triple());
+
+        let module = Module::from_file(&store, &self.path)?;
+        module.serialize_to_file(&self.output)?;
+        eprintln!(
+            "✔ File compiled successfully to `{}`.",
+            self.output.display(),
+        );
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/config.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/config.rs
new file mode 100644
index 0000000..261a189
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/config.rs
@@ -0,0 +1,304 @@
+use std::str::ParseBoolError;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use wasmer_registry::{wasmer_env::WasmerEnv, WasmerConfig};
+
+use crate::VERSION;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer config` subcommand: `wasmer config get --OPTION` or `wasmer config set [FLAG]`
+pub struct Config {
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    #[clap(flatten)]
+    flags: Flags,
+    /// Subcommand for `wasmer config get | set`
+    #[clap(subcommand)]
+    set: Option<GetOrSet>,
+}
+
+/// Normal configuration
+#[derive(Debug, Parser)]
+pub struct Flags {
+    /// Print the installation prefix.
+    #[clap(long, conflicts_with = "pkg_config")]
+    prefix: bool,
+
+    /// Directory containing Wasmer executables.
+    #[clap(long, conflicts_with = "pkg_config")]
+    bindir: bool,
+
+    /// Directory containing Wasmer headers.
+    #[clap(long, conflicts_with = "pkg_config")]
+    includedir: bool,
+
+    /// Directory containing Wasmer libraries.
+    #[clap(long, conflicts_with = "pkg_config")]
+    libdir: bool,
+
+    /// Libraries needed to link against Wasmer components.
+    #[clap(long, conflicts_with = "pkg_config")]
+    libs: bool,
+
+    /// C compiler flags for files that include Wasmer headers.
+    #[clap(long, conflicts_with = "pkg_config")]
+    cflags: bool,
+
+    /// Print the path to the wasmer configuration file where all settings are stored
+    #[clap(long, conflicts_with = "pkg_config")]
+    config_path: bool,
+
+    /// Outputs the necessary details for compiling
+    /// and linking a program to Wasmer, using the `pkg-config` format.
+    #[clap(long)]
+    pkg_config: bool,
+}
+
+/// Subcommand for `wasmer config set`
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub enum GetOrSet {
+    /// `wasmer config get $KEY`
+    #[clap(subcommand)]
+    Get(RetrievableConfigField),
+    /// `wasmer config set $KEY $VALUE`
+    #[clap(subcommand)]
+    Set(StorableConfigField),
+}
+
+/// Subcommand for `wasmer config get`
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub enum RetrievableConfigField {
+    /// Print the registry URL of the currently active registry
+    #[clap(name = "registry.url")]
+    RegistryUrl,
+    /// Print the token for the currently active registry or nothing if not logged in
+    #[clap(name = "registry.token")]
+    RegistryToken,
+    /// Print whether telemetry is currently enabled
+    #[clap(name = "telemetry.enabled")]
+    TelemetryEnabled,
+    /// Print whether update notifications are enabled
+    #[clap(name = "update-notifications.enabled")]
+    UpdateNotificationsEnabled,
+    /// Print the proxy URL
+    #[clap(name = "proxy.url")]
+    ProxyUrl,
+}
+
+/// Setting that can be stored in the wasmer config
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub enum StorableConfigField {
+    /// Set the registry URL of the currently active registry
+    #[clap(name = "registry.url")]
+    RegistryUrl(SetRegistryUrl),
+    /// Set the token for the currently active registry or nothing if not logged in
+    #[clap(name = "registry.token")]
+    RegistryToken(SetRegistryToken),
+    /// Set whether telemetry is currently enabled
+    #[clap(name = "telemetry.enabled")]
+    TelemetryEnabled(SetTelemetryEnabled),
+    /// Set whether update notifications are enabled
+    #[clap(name = "update-notifications.enabled")]
+    UpdateNotificationsEnabled(SetUpdateNotificationsEnabled),
+    /// Set the active proxy URL
+    #[clap(name = "proxy.url")]
+    ProxyUrl(SetProxyUrl),
+}
+
+/// Set the current active registry URL
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub struct SetRegistryUrl {
+    /// Url of the registry
+    #[clap(name = "URL")]
+    pub url: String,
+}
+
+/// Set or change the token for the current active registry
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub struct SetRegistryToken {
+    /// Token to set
+    #[clap(name = "TOKEN")]
+    pub token: String,
+}
+
+/// Set if update notifications are enabled
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub struct SetUpdateNotificationsEnabled {
+    /// Whether to enable update notifications
+    ///
+    /// ("true" | "false")
+    #[clap(name = "ENABLED")]
+    pub enabled: BoolString,
+}
+
+/// "true" or "false" for handling input in the CLI
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct BoolString(pub bool);
+
+impl std::str::FromStr for BoolString {
+    type Err = ParseBoolError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(bool::from_str(s)?))
+    }
+}
+
+/// Set if telemetry is enabled
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub struct SetTelemetryEnabled {
+    /// Whether to enable telemetry
+    ///
+    /// ("true" | "false")
+    #[clap(name = "ENABLED")]
+    pub enabled: BoolString,
+}
+
+/// Set if a proxy URL should be used
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Parser)]
+pub struct SetProxyUrl {
+    /// Set if a proxy URL should be used (empty = unset proxy)
+    #[clap(name = "URL")]
+    pub url: String,
+}
+
+impl Config {
+    /// Runs logic for the `config` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context("failed to retrieve the wasmer config".to_string())
+    }
+
+    fn inner_execute(&self) -> Result<()> {
+        if let Some(s) = self.set.as_ref() {
+            return s.execute(&self.env);
+        }
+
+        let flags = &self.flags;
+
+        let prefix = self.env.dir();
+
+        let prefixdir = prefix.display().to_string();
+        let bindir = prefix.join("bin").display().to_string();
+        let includedir = prefix.join("include").display().to_string();
+        let libdir = prefix.join("lib").display().to_string();
+        let cflags = format!("-I{}", includedir);
+        let libs = format!("-L{} -lwasmer", libdir);
+
+        if flags.pkg_config {
+            println!("prefix={}", prefixdir);
+            println!("exec_prefix={}", bindir);
+            println!("includedir={}", includedir);
+            println!("libdir={}", libdir);
+            println!();
+            println!("Name: wasmer");
+            println!("Description: The Wasmer library for running WebAssembly");
+            println!("Version: {}", VERSION);
+            println!("Cflags: {}", cflags);
+            println!("Libs: {}", libs);
+            return Ok(());
+        }
+
+        if flags.prefix {
+            println!("{}", prefixdir);
+        }
+        if flags.bindir {
+            println!("{}", bindir);
+        }
+        if flags.includedir {
+            println!("{}", includedir);
+        }
+        if flags.libdir {
+            println!("{}", libdir);
+        }
+        if flags.libs {
+            println!("{}", libs);
+        }
+        if flags.cflags {
+            println!("{}", cflags);
+        }
+
+        if flags.config_path {
+            let path = WasmerConfig::get_file_location(self.env.dir());
+            println!("{}", path.display());
+        }
+
+        Ok(())
+    }
+}
+
+impl GetOrSet {
+    fn execute(&self, env: &WasmerEnv) -> Result<()> {
+        let config_file = WasmerConfig::get_file_location(env.dir());
+        let mut config = env.config()?;
+
+        match self {
+            GetOrSet::Get(g) => match g {
+                RetrievableConfigField::RegistryUrl => {
+                    println!("{}", config.registry.get_current_registry());
+                }
+                RetrievableConfigField::RegistryToken => {
+                    if let Some(s) = config
+                        .registry
+                        .get_login_token_for_registry(&config.registry.get_current_registry())
+                    {
+                        println!("{s}");
+                    }
+                }
+                RetrievableConfigField::TelemetryEnabled => {
+                    println!("{:?}", config.telemetry_enabled);
+                }
+                RetrievableConfigField::UpdateNotificationsEnabled => {
+                    println!("{:?}", config.update_notifications_enabled);
+                }
+                RetrievableConfigField::ProxyUrl => {
+                    if let Some(s) = config.proxy.url.as_ref() {
+                        println!("{s}");
+                    } else {
+                        println!("none");
+                    }
+                }
+            },
+            GetOrSet::Set(s) => {
+                match s {
+                    StorableConfigField::RegistryUrl(s) => {
+                        config.registry.set_current_registry(&s.url);
+                        let current_registry = config.registry.get_current_registry();
+                        if let Some(u) = wasmer_registry::utils::get_username(&current_registry)
+                            .ok()
+                            .and_then(|o| o)
+                        {
+                            println!(
+                                "Successfully logged into registry {current_registry:?} as user {u:?}"
+                            );
+                        }
+                    }
+                    StorableConfigField::RegistryToken(t) => {
+                        config.registry.set_login_token_for_registry(
+                            &config.registry.get_current_registry(),
+                            &t.token,
+                            wasmer_registry::config::UpdateRegistry::LeaveAsIs,
+                        );
+                    }
+                    StorableConfigField::TelemetryEnabled(t) => {
+                        config.telemetry_enabled = t.enabled.0;
+                    }
+                    StorableConfigField::ProxyUrl(p) => {
+                        if p.url == "none" || p.url.is_empty() {
+                            config.proxy.url = None;
+                        } else {
+                            config.proxy.url = Some(p.url.clone());
+                        }
+                    }
+                    StorableConfigField::UpdateNotificationsEnabled(u) => {
+                        config.update_notifications_enabled = u.enabled.0;
+                    }
+                }
+                config
+                    .save(config_file)
+                    .with_context(|| anyhow::anyhow!("could not save config file"))?;
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/connect.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/connect.rs
new file mode 100644
index 0000000..42211ac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/connect.rs
@@ -0,0 +1,100 @@
+use std::net::IpAddr;
+
+use super::AsyncCliCommand;
+use crate::opts::ApiOpts;
+
+/// Connects to the Wasmer Edge distributed network.
+#[derive(clap::Parser, Debug)]
+pub struct CmdConnect {
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Runs in promiscuous mode
+    #[clap(long)]
+    pub promiscuous: bool,
+    /// Prints the network token rather than connecting
+    #[clap(long)]
+    pub print: bool,
+    /// Skips bringing the interface up using the `ip` tool.
+    #[clap(long)]
+    pub leave_down: bool,
+    /// Do not modify the postfix of the URL before connecting
+    #[clap(long)]
+    pub leave_postfix: bool,
+    /// One or more static IP address to assign the interface
+    #[clap(long)]
+    pub ip: Vec<IpAddr>,
+    /// Thr URL we will be connecting to
+    #[clap(index = 1)]
+    pub url: url::Url,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdConnect {
+    type Output = ();
+
+    #[cfg(all(target_os = "linux", feature = "tun-tap"))]
+    async fn run_async(mut self) -> Result<(), anyhow::Error> {
+        use edge_schema::{AppId, NetworkIdEncodingMethod, WELL_KNOWN_VPN};
+        use virtual_mio::Selector;
+
+        use crate::net::TunTapSocket;
+
+        // If the URL does not include the well known postfix then add it
+        if !self.leave_postfix {
+            self.url.set_path(WELL_KNOWN_VPN);
+        }
+
+        if self.print {
+            println!("websocket-url: {}", self.url.as_str());
+            return Ok(());
+        }
+
+        print!("Connecting...");
+        let socket = TunTapSocket::create(
+            Selector::new(),
+            self.url.clone(),
+            self.leave_down == false,
+            self.ip,
+        )
+        .await
+        .map_err(|err| {
+            println!("failed");
+            err
+        })?;
+        println!("\rConnected to {}    ", self.url.as_str());
+
+        for cidr in socket.ips().iter() {
+            println!("Your IP:  {}/{}", cidr.ip, cidr.prefix);
+        }
+        for route in socket.routes().iter() {
+            println!(
+                "Gateway: {}/{} -> {}",
+                route.cidr.ip, route.cidr.prefix, route.via_router
+            );
+        }
+        for cidr in socket.ips().iter() {
+            if let Some((app_id, _)) =
+                AppId::from_ip(&cidr.ip, NetworkIdEncodingMethod::PrivateProjection)
+            {
+                let ip = app_id.into_ip(
+                    cidr.ip,
+                    0x00_1001,
+                    NetworkIdEncodingMethod::PrivateProjection,
+                );
+                println!("Instance: {}/{}", ip, cidr.prefix);
+            }
+        }
+        println!("Press ctrl-c to terminate");
+        socket.await?;
+
+        Ok(())
+    }
+
+    #[cfg(not(all(target_os = "linux", feature = "tun-tap")))]
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        Err(anyhow::anyhow!(
+            "This CLI does not support the 'connect' command: only available on Linux (feature: tun-tap)"
+        ))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/mod.rs
new file mode 100644
index 0000000..533d1ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/mod.rs
@@ -0,0 +1,12 @@
+mod unpack;
+
+pub use unpack::PackageUnpack;
+
+/// Container related commands. (inspecting, unpacking, ...)
+#[derive(clap::Subcommand, Debug)]
+// Allowing missing_docs because the comment would override the doc comment on
+// the command struct.
+#[allow(missing_docs)]
+pub enum Container {
+    Unpack(PackageUnpack),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/unpack.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/unpack.rs
new file mode 100644
index 0000000..0e851c6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/container/unpack.rs
@@ -0,0 +1,118 @@
+use std::path::PathBuf;
+
+use anyhow::Context;
+use dialoguer::console::{style, Emoji};
+use indicatif::ProgressBar;
+
+/// Extract contents of a container to a directory.
+#[derive(clap::Parser, Debug)]
+pub struct PackageUnpack {
+    /// The output directory.
+    #[clap(short = 'o', long)]
+    out_dir: PathBuf,
+
+    /// Overwrite existing directories/files.
+    #[clap(long)]
+    overwrite: bool,
+
+    /// Run the unpack command without any output
+    #[clap(long)]
+    pub quiet: bool,
+
+    /// Path to the package.
+    package_path: PathBuf,
+}
+
+static PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("📦 ", "");
+static EXTRACTED_TO_EMOJI: Emoji<'_, '_> = Emoji("📂 ", "");
+
+impl PackageUnpack {
+    pub(crate) fn execute(&self) -> Result<(), anyhow::Error> {
+        // Setup the progress bar
+        let pb = if self.quiet {
+            ProgressBar::hidden()
+        } else {
+            ProgressBar::new_spinner()
+        };
+
+        pb.println(format!(
+            "{} {}Unpacking...",
+            style("[1/2]").bold().dim(),
+            PACKAGE_EMOJI
+        ));
+
+        let pkg = webc::compat::Container::from_disk(&self.package_path).with_context(|| {
+            format!(
+                "could not open package at '{}'",
+                self.package_path.display()
+            )
+        })?;
+
+        let outdir = &self.out_dir;
+        std::fs::create_dir_all(outdir)
+            .with_context(|| format!("could not create output directory '{}'", outdir.display()))?;
+
+        pkg.unpack(outdir, self.overwrite)
+            .with_context(|| "could not extract package".to_string())?;
+
+        pb.println(format!(
+            "{} {}Extracted package contents to '{}'",
+            style("[2/2]").bold().dim(),
+            EXTRACTED_TO_EMOJI,
+            self.out_dir.display()
+        ));
+
+        pb.finish();
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Download a package from the dev registry.
+    #[test]
+    fn test_cmd_package_extract() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let package_path = std::env::var("CARGO_MANIFEST_DIR").map(PathBuf::from).unwrap()
+            .parent().unwrap()
+            .parent().unwrap()
+            .join("tests/integration/cli/tests/webc/hello-0.1.0-665d2ddc-80e6-4845-85d3-4587b1693bb7.webc");
+
+        assert!(package_path.is_file());
+
+        let cmd = PackageUnpack {
+            out_dir: dir.path().to_owned(),
+            overwrite: false,
+            package_path,
+            quiet: true,
+        };
+
+        cmd.execute().unwrap();
+
+        let mut items = std::fs::read_dir(dir.path())
+            .unwrap()
+            .map(|x| {
+                x.unwrap()
+                    .path()
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_string()
+            })
+            .collect::<Vec<_>>();
+        items.sort();
+        assert_eq!(
+            items,
+            vec![
+                "atom".to_string(),
+                "manifest.json".to_string(),
+                "metadata".to_string(),
+            ]
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_exe.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_exe.rs
new file mode 100644
index 0000000..24c1dc6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_exe.rs
@@ -0,0 +1,2304 @@
+//! Create a standalone native executable for a given Wasm file.
+
+use std::{
+    collections::BTreeMap,
+    env,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
+
+use anyhow::{anyhow, bail, Context, Result};
+use clap::Parser;
+use serde::{Deserialize, Serialize};
+use tar::Archive;
+use wasmer::sys::Artifact;
+use wasmer::*;
+use wasmer_object::{emit_serialized, get_object_for_target};
+use wasmer_types::{compilation::symbols::ModuleMetadataSymbolRegistry, ModuleInfo};
+use webc::{
+    compat::{Container, Volume as WebcVolume},
+    PathSegments,
+};
+
+use self::utils::normalize_atom_name;
+use crate::{common::normalize_path, store::CompilerOptions};
+
+const LINK_SYSTEM_LIBRARIES_WINDOWS: &[&str] = &["userenv", "Ws2_32", "advapi32", "bcrypt"];
+
+const LINK_SYSTEM_LIBRARIES_UNIX: &[&str] = &["dl", "m", "pthread"];
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer create-exe` subcommand
+pub struct CreateExe {
+    /// Input file
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    /// Output file
+    #[clap(name = "OUTPUT PATH", short = 'o')]
+    output: PathBuf,
+
+    /// Optional directorey used for debugging: if present, will output the zig command
+    /// for reproducing issues in a debug directory
+    #[clap(long, name = "DEBUG PATH")]
+    debug_dir: Option<PathBuf>,
+
+    /// Prefix for every input file, e.g. "wat2wasm:sha256abc123" would
+    /// prefix every function in the wat2wasm input object with the "sha256abc123" hash
+    ///
+    /// If only a single value is given without containing a ":", this value is used for
+    /// all input files. If no value is given, the prefix is always equal to
+    /// the sha256 of the input .wasm file
+    #[clap(
+        long,
+        use_value_delimiter = true,
+        value_delimiter = ',',
+        name = "FILE:PREFIX:PATH"
+    )]
+    precompiled_atom: Vec<String>,
+
+    /// Compilation Target triple
+    ///
+    /// Accepted target triple values must follow the
+    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    ///
+    /// The recommended targets we try to support are:
+    ///
+    /// - "x86_64-linux-gnu"
+    /// - "aarch64-linux-gnu"
+    /// - "x86_64-apple-darwin"
+    /// - "arm64-apple-darwin"
+    /// - "x86_64-windows-gnu"
+    #[clap(long = "target")]
+    target_triple: Option<Triple>,
+
+    /// Can specify either a release version (such as "3.0.1") or a URL to a tarball to use
+    /// for linking. By default, create-exe will always pull the latest release tarball from GitHub,
+    /// this flag can be used to override that behaviour.
+    #[clap(long, name = "URL_OR_RELEASE_VERSION")]
+    use_wasmer_release: Option<String>,
+
+    #[clap(long, short = 'm', number_of_values = 1)]
+    cpu_features: Vec<CpuFeature>,
+
+    /// Additional libraries to link against.
+    /// This is useful for fixing linker errors that may occur on some systems.
+    #[clap(long, short = 'l')]
+    libraries: Vec<String>,
+
+    #[clap(flatten)]
+    cross_compile: CrossCompile,
+
+    #[clap(flatten)]
+    compiler: CompilerOptions,
+}
+
+/// Url or version to download the release from
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UrlOrVersion {
+    /// URL to download
+    Url(url::Url),
+    /// Release version to download
+    Version(semver::Version),
+}
+
+impl UrlOrVersion {
+    fn from_str(s: &str) -> Result<Self, anyhow::Error> {
+        let mut err;
+        let s = s.strip_prefix('v').unwrap_or(s);
+        match url::Url::parse(s) {
+            Ok(o) => return Ok(Self::Url(o)),
+            Err(e) => {
+                err = anyhow::anyhow!("could not parse as URL: {e}");
+            }
+        }
+
+        match semver::Version::parse(s) {
+            Ok(o) => return Ok(Self::Version(o)),
+            Err(e) => {
+                err = anyhow::anyhow!("could not parse as URL or version: {e}").context(err);
+            }
+        }
+
+        Err(err)
+    }
+}
+
+// Cross-compilation options with `zig`
+#[derive(Debug, Clone, Default, Parser)]
+pub(crate) struct CrossCompile {
+    /// Use the system linker instead of zig for linking
+    #[clap(long)]
+    use_system_linker: bool,
+
+    /// Cross-compilation library path (path to libwasmer.a / wasmer.lib)
+    #[clap(long = "library-path")]
+    library_path: Option<PathBuf>,
+
+    /// Cross-compilation tarball library path
+    #[clap(long = "tarball")]
+    tarball: Option<PathBuf>,
+
+    /// Specify `zig` binary path (defaults to `zig` in $PATH if not present)
+    #[clap(long = "zig-binary-path", env)]
+    zig_binary_path: Option<PathBuf>,
+}
+
+#[derive(Debug)]
+pub(crate) struct CrossCompileSetup {
+    pub(crate) target: Triple,
+    pub(crate) zig_binary_path: Option<PathBuf>,
+    pub(crate) library: PathBuf,
+}
+
+/// Given a pirita file, determines whether the file has one
+/// default command as an entrypoint or multiple (need to be specified via --command)
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Entrypoint {
+    /// Compiled atom files to link into the final binary
+    pub atoms: Vec<CommandEntrypoint>,
+    /// Volume objects (if any) to link into the final binary
+    pub volumes: Vec<Volume>,
+}
+
+/// Command entrypoint for multiple commands
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CommandEntrypoint {
+    /// Command name
+    pub command: String,
+    /// Atom name
+    pub atom: String,
+    /// Path to the object file, relative to the entrypoint.json parent dir
+    pub path: PathBuf,
+    /// Optional path to the static_defs.h header file, relative to the entrypoint.json parent dir
+    pub header: Option<PathBuf>,
+    /// Module info, set when the wasm file is compiled
+    pub module_info: Option<ModuleInfo>,
+}
+
+/// Volume object file (name + path to object file)
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Volume {
+    /// Volume name
+    pub name: String,
+    /// Path to volume fileblock object file
+    pub obj_file: PathBuf,
+}
+
+impl CreateExe {
+    /// Runs logic for the `compile` subcommand
+    pub fn execute(&self) -> Result<()> {
+        let path = normalize_path(&format!("{}", self.path.display()));
+        let target_triple = self.target_triple.clone().unwrap_or_else(Triple::host);
+        let mut cc = self.cross_compile.clone();
+        let target = utils::target_triple_to_target(&target_triple, &self.cpu_features);
+
+        let starting_cd = env::current_dir()?;
+        let input_path = starting_cd.join(path);
+        let output_path = starting_cd.join(&self.output);
+
+        let url_or_version = match self
+            .use_wasmer_release
+            .as_deref()
+            .map(UrlOrVersion::from_str)
+        {
+            Some(Ok(o)) => Some(o),
+            Some(Err(e)) => return Err(e),
+            None => None,
+        };
+
+        let cross_compilation =
+            utils::get_cross_compile_setup(&mut cc, &target_triple, &starting_cd, url_or_version)?;
+
+        if input_path.is_dir() {
+            return Err(anyhow::anyhow!("input path cannot be a directory"));
+        }
+
+        let (store, compiler_type) = self.compiler.get_store_for_target(target.clone())?;
+
+        println!("Compiler: {}", compiler_type.to_string());
+        println!("Target: {}", target.triple());
+        println!(
+            "Using path `{}` as libwasmer path.",
+            cross_compilation.library.display()
+        );
+
+        if !cross_compilation.library.exists() {
+            return Err(anyhow::anyhow!("library path does not exist"));
+        }
+
+        let temp = tempfile::tempdir();
+        let tempdir = match self.debug_dir.as_ref() {
+            Some(s) => s.clone(),
+            None => temp?.path().to_path_buf(),
+        };
+        std::fs::create_dir_all(&tempdir)?;
+
+        let atoms = if let Ok(pirita) = Container::from_disk(&input_path) {
+            // pirita file
+            compile_pirita_into_directory(
+                &pirita,
+                &tempdir,
+                &self.compiler,
+                &self.cpu_features,
+                &cross_compilation.target,
+                &self.precompiled_atom,
+                AllowMultiWasm::Allow,
+                self.debug_dir.is_some(),
+            )
+        } else {
+            // wasm file
+            prepare_directory_from_single_wasm_file(
+                &input_path,
+                &tempdir,
+                &self.compiler,
+                &cross_compilation.target,
+                &self.cpu_features,
+                &self.precompiled_atom,
+                self.debug_dir.is_some(),
+            )
+        }?;
+
+        get_module_infos(&store, &tempdir, &atoms)?;
+        let mut entrypoint = get_entrypoint(&tempdir)?;
+        create_header_files_in_dir(&tempdir, &mut entrypoint, &atoms, &self.precompiled_atom)?;
+        link_exe_from_dir(
+            &tempdir,
+            output_path,
+            &cross_compilation,
+            &self.libraries,
+            self.debug_dir.is_some(),
+            &atoms,
+            &self.precompiled_atom,
+        )?;
+
+        if self.target_triple.is_some() {
+            eprintln!(
+                "✔ Cross-compiled executable for `{}` target compiled successfully to `{}`.",
+                target.triple(),
+                self.output.display(),
+            );
+        } else {
+            eprintln!(
+                "✔ Native executable compiled successfully to `{}`.",
+                self.output.display(),
+            );
+        }
+
+        Ok(())
+    }
+}
+
+fn write_entrypoint(directory: &Path, entrypoint: &Entrypoint) -> Result<(), anyhow::Error> {
+    std::fs::write(
+        directory.join("entrypoint.json"),
+        serde_json::to_string_pretty(&entrypoint).unwrap(),
+    )
+    .map_err(|e| {
+        anyhow::anyhow!(
+            "cannot create entrypoint.json dir in {}: {e}",
+            directory.display()
+        )
+    })
+}
+
+fn get_entrypoint(directory: &Path) -> Result<Entrypoint, anyhow::Error> {
+    let entrypoint_json =
+        std::fs::read_to_string(directory.join("entrypoint.json")).map_err(|e| {
+            anyhow::anyhow!(
+                "could not read entrypoint.json in {}: {e}",
+                directory.display()
+            )
+        })?;
+
+    let entrypoint: Entrypoint = serde_json::from_str(&entrypoint_json).map_err(|e| {
+        anyhow::anyhow!(
+            "could not parse entrypoint.json in {}: {e}",
+            directory.display()
+        )
+    })?;
+
+    if entrypoint.atoms.is_empty() {
+        return Err(anyhow::anyhow!("file has no atoms to compile"));
+    }
+
+    Ok(entrypoint)
+}
+
+/// In pirita mode, specifies whether multi-atom
+/// pirita files should be allowed or rejected
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum AllowMultiWasm {
+    /// allow
+    Allow,
+    /// reject
+    Reject(Option<String>),
+}
+
+/// Given a pirita file, compiles the .wasm files into the target directory
+#[allow(clippy::too_many_arguments)]
+pub(super) fn compile_pirita_into_directory(
+    pirita: &Container,
+    target_dir: &Path,
+    compiler: &CompilerOptions,
+    cpu_features: &[CpuFeature],
+    triple: &Triple,
+    prefixes: &[String],
+    allow_multi_wasm: AllowMultiWasm,
+    debug: bool,
+) -> anyhow::Result<Vec<(String, Vec<u8>)>> {
+    let all_atoms = match &allow_multi_wasm {
+        AllowMultiWasm::Allow | AllowMultiWasm::Reject(None) => {
+            pirita.atoms().into_iter().collect::<Vec<_>>()
+        }
+        AllowMultiWasm::Reject(Some(s)) => {
+            let atom = pirita
+                .get_atom(s)
+                .with_context(|| format!("could not find atom \"{s}\"",))?;
+            vec![(s.to_string(), atom)]
+        }
+    };
+
+    allow_multi_wasm.validate(&all_atoms)?;
+
+    std::fs::create_dir_all(target_dir)
+        .map_err(|e| anyhow::anyhow!("cannot create / dir in {}: {e}", target_dir.display()))?;
+
+    let target_dir = target_dir.canonicalize()?;
+    let target = &utils::target_triple_to_target(triple, cpu_features);
+
+    std::fs::create_dir_all(target_dir.join("volumes")).map_err(|e| {
+        anyhow::anyhow!(
+            "cannot create /volumes dir in {}: {e}",
+            target_dir.display()
+        )
+    })?;
+
+    let volumes = pirita.volumes();
+    let volume_bytes = volume_file_block(&volumes);
+    let volume_name = "VOLUMES";
+    let volume_path = target_dir.join("volumes").join("volume.o");
+    write_volume_obj(&volume_bytes, volume_name, &volume_path, target)?;
+    let volume_path = volume_path.canonicalize()?;
+    let volume_path = pathdiff::diff_paths(&volume_path, &target_dir).unwrap();
+
+    std::fs::create_dir_all(target_dir.join("atoms")).map_err(|e| {
+        anyhow::anyhow!("cannot create /atoms dir in {}: {e}", target_dir.display())
+    })?;
+
+    let mut atoms_from_file = Vec::new();
+    let mut target_paths = Vec::new();
+
+    for (atom_name, atom_bytes) in all_atoms {
+        atoms_from_file.push((utils::normalize_atom_name(&atom_name), atom_bytes.to_vec()));
+        let atom_path = target_dir
+            .join("atoms")
+            .join(format!("{}.o", utils::normalize_atom_name(&atom_name)));
+        let header_path = {
+            std::fs::create_dir_all(target_dir.join("include")).map_err(|e| {
+                anyhow::anyhow!(
+                    "cannot create /include dir in {}: {e}",
+                    target_dir.display()
+                )
+            })?;
+
+            let header_path = target_dir.join("include").join(format!(
+                "static_defs_{}.h",
+                utils::normalize_atom_name(&atom_name)
+            ));
+
+            Some(header_path)
+        };
+        target_paths.push((
+            atom_name.clone(),
+            utils::normalize_atom_name(&atom_name),
+            atom_path,
+            header_path,
+        ));
+    }
+
+    let prefix_map = PrefixMapCompilation::from_input(&atoms_from_file, prefixes, false)
+        .with_context(|| anyhow::anyhow!("compile_pirita_into_directory"))?;
+
+    let module_infos = compile_atoms(
+        &atoms_from_file,
+        &target_dir.join("atoms"),
+        compiler,
+        target,
+        &prefix_map,
+        debug,
+    )?;
+
+    // target_dir
+    let mut atoms = Vec::new();
+    for (command_name, atom_name, a, opt_header_path) in target_paths {
+        let mut atom_path = a;
+        let mut header_path = opt_header_path;
+        if let Ok(a) = atom_path.canonicalize() {
+            let opt_header_path = header_path.and_then(|p| p.canonicalize().ok());
+            atom_path = pathdiff::diff_paths(&a, &target_dir).unwrap_or_else(|| a.clone());
+            header_path = opt_header_path.and_then(|h| pathdiff::diff_paths(h, &target_dir));
+        }
+        atoms.push(CommandEntrypoint {
+            // TODO: improve, "--command pip" should be able to invoke atom "python" with args "-m pip"
+            command: command_name,
+            atom: atom_name.clone(),
+            path: atom_path,
+            header: header_path,
+            module_info: module_infos.get(&atom_name).cloned(),
+        });
+    }
+
+    let entrypoint = Entrypoint {
+        atoms,
+        volumes: vec![Volume {
+            name: volume_name.to_string(),
+            obj_file: volume_path,
+        }],
+    };
+
+    write_entrypoint(&target_dir, &entrypoint)?;
+
+    Ok(atoms_from_file)
+}
+
+/// Serialize a set of volumes so they can be read by the C API.
+///
+/// This is really backwards, but the only way to create a v1 volume "fileblock"
+/// is by first reading every file in a [`webc::compat::Volume`], serializing it
+/// to webc v1's binary form, parsing those bytes into a [`webc::v1::Volume`],
+/// then constructing a dummy [`webc::v1::WebC`] object just so we can make a
+/// copy of its file block.
+fn volume_file_block(volumes: &BTreeMap<String, WebcVolume>) -> Vec<u8> {
+    let serialized_volumes: Vec<(&String, Vec<u8>)> = volumes
+        .iter()
+        .map(|(name, volume)| (name, serialize_volume_to_webc_v1(volume)))
+        .collect();
+
+    let parsed_volumes: indexmap::IndexMap<String, webc::v1::Volume<'_>> = serialized_volumes
+        .iter()
+        .filter_map(|(name, serialized_volume)| {
+            let volume = webc::v1::Volume::parse(serialized_volume).ok()?;
+            Some((name.to_string(), volume))
+        })
+        .collect();
+
+    let webc = webc::v1::WebC {
+        version: 0,
+        checksum: None,
+        signature: None,
+        manifest: webc::metadata::Manifest::default(),
+        atoms: webc::v1::Volume::default(),
+        volumes: parsed_volumes,
+    };
+
+    webc.get_volumes_as_fileblock()
+}
+
+fn serialize_volume_to_webc_v1(volume: &WebcVolume) -> Vec<u8> {
+    fn read_dir(
+        volume: &WebcVolume,
+        path: &mut PathSegments,
+        files: &mut BTreeMap<webc::v1::DirOrFile, Vec<u8>>,
+    ) {
+        for (segment, meta) in volume.read_dir(&*path).unwrap_or_default() {
+            path.push(segment);
+
+            match meta {
+                webc::compat::Metadata::Dir => {
+                    files.insert(
+                        webc::v1::DirOrFile::Dir(path.to_string().into()),
+                        Vec::new(),
+                    );
+                    read_dir(volume, path, files);
+                }
+                webc::compat::Metadata::File { .. } => {
+                    if let Some(contents) = volume.read_file(&*path) {
+                        files.insert(
+                            webc::v1::DirOrFile::File(path.to_string().into()),
+                            contents.to_vec(),
+                        );
+                    }
+                }
+            }
+
+            path.pop();
+        }
+    }
+
+    let mut path = PathSegments::ROOT;
+    let mut files = BTreeMap::new();
+
+    read_dir(volume, &mut path, &mut files);
+
+    webc::v1::Volume::serialize_files(files)
+}
+
+impl AllowMultiWasm {
+    fn validate(
+        &self,
+        all_atoms: &Vec<(String, webc::compat::SharedBytes)>,
+    ) -> Result<(), anyhow::Error> {
+        if matches!(self, AllowMultiWasm::Reject(None)) && all_atoms.len() > 1 {
+            let keys = all_atoms
+                .iter()
+                .map(|(name, _)| name.clone())
+                .collect::<Vec<_>>();
+
+            return Err(anyhow::anyhow!(
+                "where <ATOM> is one of: {}",
+                keys.join(", ")
+            ))
+            .context(anyhow::anyhow!(
+                "note: use --atom <ATOM> to specify which atom to compile"
+            ))
+            .context(anyhow::anyhow!(
+                "cannot compile more than one atom at a time"
+            ));
+        }
+
+        Ok(())
+    }
+}
+
+/// Prefix map used during compilation of object files
+#[derive(Debug, Default, PartialEq)]
+pub(crate) struct PrefixMapCompilation {
+    /// Sha256 hashes for the input files
+    input_hashes: BTreeMap<String, String>,
+    /// Manual prefixes for input files (file:prefix)
+    manual_prefixes: BTreeMap<String, String>,
+    /// Cached compilation objects for files on disk
+    #[allow(dead_code)]
+    compilation_objects: BTreeMap<String, Vec<u8>>,
+}
+
+impl PrefixMapCompilation {
+    /// Sets up the prefix map from a collection like "sha123123" or "wasmfile:sha123123" or "wasmfile:/tmp/filepath/:sha123123"
+    fn from_input(
+        atoms: &[(String, Vec<u8>)],
+        prefixes: &[String],
+        only_validate_prefixes: bool,
+    ) -> Result<Self, anyhow::Error> {
+        // No atoms: no prefixes necessary
+        if atoms.is_empty() {
+            return Ok(Self::default());
+        }
+
+        // default case: no prefixes have been specified:
+        // for all atoms, calculate the sha256
+        if prefixes.is_empty() {
+            return Ok(Self {
+                input_hashes: atoms
+                    .iter()
+                    .map(|(name, bytes)| (normalize_atom_name(name), Self::hash_for_bytes(bytes)))
+                    .collect(),
+                manual_prefixes: BTreeMap::new(),
+                compilation_objects: BTreeMap::new(),
+            });
+        }
+
+        // if prefixes are specified, have to match the atom names exactly
+        if prefixes.len() != atoms.len() {
+            println!(
+                "WARNING: invalid mapping of prefix and atoms: expected prefixes for {} atoms, got {} prefixes",
+                atoms.len(), prefixes.len()
+            );
+        }
+
+        let available_atoms = atoms.iter().map(|(k, _)| k.clone()).collect::<Vec<_>>();
+        let mut manual_prefixes = BTreeMap::new();
+        let mut compilation_objects = BTreeMap::new();
+
+        for p in prefixes.iter() {
+            // On windows, we have to account for paths like "C://", which would
+            // prevent a simple .split(":") or a regex
+            let prefix_split = Self::split_prefix(p);
+
+            match prefix_split.as_slice() {
+                // ATOM:PREFIX:PATH
+                [atom, prefix, path] => {
+                    if only_validate_prefixes {
+                        // only insert the prefix in order to not error out of the fs::read(path)
+                        manual_prefixes.insert(normalize_atom_name(atom), prefix.to_string());
+                    } else {
+                        let atom_hash = atoms
+                        .iter()
+                        .find_map(|(name, _)| if normalize_atom_name(name) == normalize_atom_name(atom) { Some(prefix.to_string()) } else { None })
+                        .ok_or_else(|| anyhow::anyhow!("no atom {atom:?} found, for prefix {p:?}, available atoms are {available_atoms:?}"))?;
+
+                        let current_dir = std::env::current_dir().unwrap().canonicalize().unwrap();
+                        let path = current_dir.join(path.replace("./", ""));
+                        let bytes = std::fs::read(&path).map_err(|e| {
+                            anyhow::anyhow!("could not read file for atom {atom:?} (prefix {p}, path {} in dir {}): {e}", path.display(), current_dir.display())
+                        })?;
+
+                        compilation_objects.insert(normalize_atom_name(atom), bytes);
+                        manual_prefixes.insert(normalize_atom_name(atom), atom_hash.to_string());
+                    }
+                }
+                // atom + path, but default SHA256 prefix
+                [atom, path] => {
+                    let atom_hash = atoms
+                    .iter()
+                    .find_map(|(name, bytes)| if normalize_atom_name(name) == normalize_atom_name(atom) { Some(Self::hash_for_bytes(bytes)) } else { None })
+                    .ok_or_else(|| anyhow::anyhow!("no atom {atom:?} found, for prefix {p:?}, available atoms are {available_atoms:?}"))?;
+                    manual_prefixes.insert(normalize_atom_name(atom), atom_hash.to_string());
+
+                    if !only_validate_prefixes {
+                        let current_dir = std::env::current_dir().unwrap().canonicalize().unwrap();
+                        let path = current_dir.join(path.replace("./", ""));
+                        let bytes = std::fs::read(&path).map_err(|e| {
+                            anyhow::anyhow!("could not read file for atom {atom:?} (prefix {p}, path {} in dir {}): {e}", path.display(), current_dir.display())
+                        })?;
+                        compilation_objects.insert(normalize_atom_name(atom), bytes);
+                    }
+                }
+                // only prefix if atoms.len() == 1
+                [prefix] if atoms.len() == 1 => {
+                    manual_prefixes.insert(normalize_atom_name(&atoms[0].0), prefix.to_string());
+                }
+                _ => {
+                    return Err(anyhow::anyhow!("invalid --precompiled-atom {p:?} - correct format is ATOM:PREFIX:PATH or ATOM:PATH"));
+                }
+            }
+        }
+
+        Ok(Self {
+            input_hashes: BTreeMap::new(),
+            manual_prefixes,
+            compilation_objects,
+        })
+    }
+
+    fn split_prefix(s: &str) -> Vec<String> {
+        let regex =
+            regex::Regex::new(r"^([a-zA-Z0-9\-_]+)(:([a-zA-Z0-9\.\-_]+))?(:(.+*))?").unwrap();
+        let mut captures = regex
+            .captures(s.trim())
+            .map(|c| {
+                c.iter()
+                    .skip(1)
+                    .flatten()
+                    .map(|m| m.as_str().to_owned())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+        if captures.is_empty() {
+            vec![s.to_string()]
+        } else if captures.len() == 5 {
+            captures.remove(1);
+            captures.remove(2);
+            captures
+        } else if captures.len() == 3 {
+            s.splitn(2, ':').map(|s| s.to_string()).collect()
+        } else {
+            captures
+        }
+    }
+
+    pub(crate) fn hash_for_bytes(bytes: &[u8]) -> String {
+        use sha2::{Digest, Sha256};
+        let mut hasher = Sha256::new();
+        hasher.update(bytes);
+        let result = hasher.finalize();
+
+        hex::encode(&result[..])
+    }
+
+    fn get_prefix_for_atom(&self, atom_name: &str) -> Option<String> {
+        self.manual_prefixes
+            .get(atom_name)
+            .or_else(|| self.input_hashes.get(atom_name))
+            .cloned()
+    }
+
+    #[allow(dead_code)]
+    fn get_compilation_object_for_atom(&self, atom_name: &str) -> Option<&[u8]> {
+        self.compilation_objects
+            .get(atom_name)
+            .map(|s| s.as_slice())
+    }
+}
+
+#[test]
+fn test_prefix_parsing() {
+    let tempdir = tempfile::TempDir::new().unwrap();
+    let path = tempdir.path();
+    std::fs::write(path.join("test.obj"), b"").unwrap();
+    let str1 = format!("ATOM_NAME:PREFIX:{}", path.join("test.obj").display());
+    let prefix =
+        PrefixMapCompilation::from_input(&[("ATOM_NAME".to_string(), b"".to_vec())], &[str1], true);
+    assert_eq!(
+        prefix.unwrap(),
+        PrefixMapCompilation {
+            input_hashes: BTreeMap::new(),
+            manual_prefixes: vec![("ATOM_NAME".to_string(), "PREFIX".to_string())]
+                .into_iter()
+                .collect(),
+            compilation_objects: Vec::new().into_iter().collect(),
+        }
+    );
+}
+
+#[test]
+fn test_split_prefix() {
+    let split = PrefixMapCompilation::split_prefix(
+        "qjs:abc123:C:\\Users\\felix\\AppData\\Local\\Temp\\.tmpoccCjV\\wasm.obj",
+    );
+    assert_eq!(
+        split,
+        vec![
+            "qjs".to_string(),
+            "abc123".to_string(),
+            "C:\\Users\\felix\\AppData\\Local\\Temp\\.tmpoccCjV\\wasm.obj".to_string(),
+        ]
+    );
+    let split = PrefixMapCompilation::split_prefix("qjs:./tmp.obj");
+    assert_eq!(split, vec!["qjs".to_string(), "./tmp.obj".to_string(),]);
+    let split2 = PrefixMapCompilation::split_prefix(
+        "qjs:abc123:/var/folders/65/2zzy98b16xz254jccxjzqb8w0000gn/T/.tmpNdgVaq/wasm.o",
+    );
+    assert_eq!(
+        split2,
+        vec![
+            "qjs".to_string(),
+            "abc123".to_string(),
+            "/var/folders/65/2zzy98b16xz254jccxjzqb8w0000gn/T/.tmpNdgVaq/wasm.o".to_string(),
+        ]
+    );
+    let split3 = PrefixMapCompilation::split_prefix(
+        "qjs:/var/folders/65/2zzy98b16xz254jccxjzqb8w0000gn/T/.tmpNdgVaq/wasm.o",
+    );
+    assert_eq!(
+        split3,
+        vec![
+            "qjs".to_string(),
+            "/var/folders/65/2zzy98b16xz254jccxjzqb8w0000gn/T/.tmpNdgVaq/wasm.o".to_string(),
+        ]
+    );
+}
+
+fn compile_atoms(
+    atoms: &[(String, Vec<u8>)],
+    output_dir: &Path,
+    compiler: &CompilerOptions,
+    target: &Target,
+    prefixes: &PrefixMapCompilation,
+    debug: bool,
+) -> Result<BTreeMap<String, ModuleInfo>, anyhow::Error> {
+    use std::{
+        fs::File,
+        io::{BufWriter, Write},
+    };
+
+    let mut module_infos = BTreeMap::new();
+    for (a, data) in atoms {
+        let prefix = prefixes
+            .get_prefix_for_atom(&normalize_atom_name(a))
+            .ok_or_else(|| anyhow::anyhow!("no prefix given for atom {a}"))?;
+        let atom_name = utils::normalize_atom_name(a);
+        let output_object_path = output_dir.join(format!("{atom_name}.o"));
+        if let Some(atom) = prefixes.get_compilation_object_for_atom(a) {
+            std::fs::write(&output_object_path, atom)
+                .map_err(|e| anyhow::anyhow!("{}: {e}", output_object_path.display()))?;
+            if debug {
+                println!("Using cached object file for atom {a:?}.");
+            }
+            continue;
+        }
+        let (engine, _) = compiler.get_engine_for_target(target.clone())?;
+        let engine_inner = engine.inner();
+        let compiler = engine_inner.compiler()?;
+        let features = engine_inner.features();
+        let tunables = engine.tunables();
+        let (module_info, obj, _, _) = Artifact::generate_object(
+            compiler,
+            data,
+            Some(prefix.as_str()),
+            target,
+            tunables,
+            features,
+        )?;
+        module_infos.insert(atom_name, module_info);
+        // Write object file with functions
+        let mut writer = BufWriter::new(File::create(&output_object_path)?);
+        obj.write_stream(&mut writer)
+            .map_err(|err| anyhow::anyhow!(err.to_string()))?;
+        writer.flush()?;
+    }
+
+    Ok(module_infos)
+}
+
+/// Compile the C code.
+fn run_c_compile(
+    path_to_c_src: &Path,
+    output_name: &Path,
+    target: &Triple,
+    debug: bool,
+    include_dirs: &[PathBuf],
+) -> anyhow::Result<()> {
+    #[cfg(not(windows))]
+    let c_compiler = "cc";
+    // We must use a C++ compiler on Windows because wasm.h uses `static_assert`
+    // which isn't available in `clang` on Windows.
+    #[cfg(windows)]
+    let c_compiler = "clang++";
+
+    let mut command = Command::new(c_compiler);
+    let mut command = command
+        .arg("-Wall")
+        .arg("-O2")
+        .arg("-c")
+        .arg(path_to_c_src)
+        .arg("-I")
+        .arg(utils::get_wasmer_include_directory()?);
+
+    for i in include_dirs {
+        command = command.arg("-I");
+        command = command.arg(normalize_path(&i.display().to_string()));
+    }
+
+    // On some compiler -target isn't implemented
+    if *target != Triple::host() {
+        command = command.arg("-target").arg(format!("{}", target));
+    }
+
+    let command = command.arg("-o").arg(output_name);
+
+    if debug {
+        println!("{command:#?}");
+    }
+
+    let output = command.output()?;
+    if debug {
+        eprintln!(
+            "run_c_compile: stdout: {}\n\nstderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    if !output.status.success() {
+        bail!(
+            "C code compile failed with: stdout: {}\n\nstderr: {}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+
+    Ok(())
+}
+
+fn write_volume_obj(
+    volume_bytes: &[u8],
+    object_name: &str,
+    output_path: &Path,
+    target: &Target,
+) -> anyhow::Result<()> {
+    use std::{
+        fs::File,
+        io::{BufWriter, Write},
+    };
+
+    let mut volumes_object = get_object_for_target(target.triple())?;
+    emit_serialized(
+        &mut volumes_object,
+        volume_bytes,
+        target.triple(),
+        object_name,
+    )?;
+
+    let mut writer = BufWriter::new(File::create(output_path)?);
+    volumes_object
+        .write_stream(&mut writer)
+        .map_err(|err| anyhow::anyhow!(err.to_string()))?;
+    writer.flush()?;
+    drop(writer);
+
+    Ok(())
+}
+
+/// Given a .wasm file, compiles the .wasm file into the target directory and creates the entrypoint.json
+#[allow(clippy::too_many_arguments)]
+pub(super) fn prepare_directory_from_single_wasm_file(
+    wasm_file: &Path,
+    target_dir: &Path,
+    compiler: &CompilerOptions,
+    triple: &Triple,
+    cpu_features: &[CpuFeature],
+    prefix: &[String],
+    debug: bool,
+) -> anyhow::Result<Vec<(String, Vec<u8>)>, anyhow::Error> {
+    let bytes = std::fs::read(wasm_file)?;
+    let target = &utils::target_triple_to_target(triple, cpu_features);
+
+    std::fs::create_dir_all(target_dir)
+        .map_err(|e| anyhow::anyhow!("cannot create / dir in {}: {e}", target_dir.display()))?;
+
+    let target_dir = target_dir.canonicalize()?;
+
+    std::fs::create_dir_all(target_dir.join("atoms")).map_err(|e| {
+        anyhow::anyhow!("cannot create /atoms dir in {}: {e}", target_dir.display())
+    })?;
+
+    let mut atoms_from_file = Vec::new();
+    let mut target_paths = Vec::new();
+
+    let all_files = vec![(
+        wasm_file
+            .file_stem()
+            .and_then(|f| f.to_str())
+            .unwrap_or("main")
+            .to_string(),
+        bytes,
+    )];
+
+    for (atom_name, atom_bytes) in all_files.iter() {
+        atoms_from_file.push((atom_name.clone(), atom_bytes.to_vec()));
+        let atom_path = target_dir.join("atoms").join(format!("{atom_name}.o"));
+        target_paths.push((atom_name, atom_path));
+    }
+
+    let prefix_map = PrefixMapCompilation::from_input(&atoms_from_file, prefix, false)
+        .with_context(|| anyhow::anyhow!("prepare_directory_from_single_wasm_file"))?;
+
+    let module_infos = compile_atoms(
+        &atoms_from_file,
+        &target_dir.join("atoms"),
+        compiler,
+        target,
+        &prefix_map,
+        debug,
+    )?;
+
+    let mut atoms = Vec::new();
+    for (atom_name, atom_path) in target_paths {
+        atoms.push(CommandEntrypoint {
+            // TODO: improve, "--command pip" should be able to invoke atom "python" with args "-m pip"
+            command: atom_name.clone(),
+            atom: atom_name.clone(),
+            path: atom_path,
+            header: None,
+            module_info: module_infos.get(atom_name).cloned(),
+        });
+    }
+
+    let entrypoint = Entrypoint {
+        atoms,
+        volumes: Vec::new(),
+    };
+
+    write_entrypoint(&target_dir, &entrypoint)?;
+
+    Ok(all_files)
+}
+
+// Given the input file paths, correctly resolves the .wasm files,
+// reads the module info from the wasm module and writes the ModuleInfo for each file
+// into the entrypoint.json file
+fn get_module_infos(
+    store: &Store,
+    directory: &Path,
+    atoms: &[(String, Vec<u8>)],
+) -> Result<BTreeMap<String, ModuleInfo>, anyhow::Error> {
+    let mut entrypoint =
+        get_entrypoint(directory).with_context(|| anyhow::anyhow!("get module infos"))?;
+
+    let mut module_infos = BTreeMap::new();
+    for (atom_name, atom_bytes) in atoms {
+        let module = Module::new(&store, atom_bytes.as_slice())?;
+        let module_info = module.info();
+        if let Some(s) = entrypoint
+            .atoms
+            .iter_mut()
+            .find(|a| a.atom.as_str() == atom_name.as_str())
+        {
+            s.module_info = Some(module_info.clone());
+            module_infos.insert(atom_name.clone(), module_info.clone());
+        }
+    }
+
+    write_entrypoint(directory, &entrypoint)?;
+
+    Ok(module_infos)
+}
+
+/// Create the static_defs.h header files in the /include directory
+pub(crate) fn create_header_files_in_dir(
+    directory: &Path,
+    entrypoint: &mut Entrypoint,
+    atoms: &[(String, Vec<u8>)],
+    prefixes: &[String],
+) -> anyhow::Result<()> {
+    use object::{Object, ObjectSection};
+
+    std::fs::create_dir_all(directory.join("include")).map_err(|e| {
+        anyhow::anyhow!("cannot create /include dir in {}: {e}", directory.display())
+    })?;
+
+    let prefixes = PrefixMapCompilation::from_input(atoms, prefixes, false)
+        .with_context(|| anyhow::anyhow!("create_header_files_in_dir"))?;
+
+    for atom in entrypoint.atoms.iter_mut() {
+        let atom_name = &atom.atom;
+        let prefix = prefixes
+            .get_prefix_for_atom(atom_name)
+            .ok_or_else(|| anyhow::anyhow!("cannot get prefix for atom {atom_name}"))?;
+
+        let object_file_src = directory.join(&atom.path);
+        let object_file = std::fs::read(&object_file_src)
+            .map_err(|e| anyhow::anyhow!("could not read {}: {e}", object_file_src.display()))?;
+        let obj_file = object::File::parse(&*object_file)?;
+        let sections = obj_file
+            .sections()
+            .filter_map(|s| s.name().ok().map(|s| s.to_string()))
+            .collect::<Vec<_>>();
+        let section = obj_file
+            .section_by_name(".data")
+            .unwrap()
+            .data()
+            .map_err(|_| {
+                anyhow::anyhow!(
+                    "missing section .data in object file {} (sections = {:#?}",
+                    object_file_src.display(),
+                    sections
+                )
+            })?;
+        let metadata_length = section.len();
+
+        let module_info = atom
+            .module_info
+            .as_ref()
+            .ok_or_else(|| anyhow::anyhow!("no module info for atom {atom_name:?}"))?;
+
+        let base_path = Path::new("include").join(format!("static_defs_{prefix}.h"));
+        let header_file_path = directory.join(&base_path);
+
+        let header_file_src = crate::c_gen::staticlib_header::generate_header_file(
+            &prefix,
+            module_info,
+            &ModuleMetadataSymbolRegistry {
+                prefix: prefix.clone(),
+            },
+            metadata_length,
+        );
+
+        std::fs::write(&header_file_path, &header_file_src).map_err(|e| {
+            anyhow::anyhow!(
+                "could not write static_defs.h for atom {atom_name} in generate-header step: {e}"
+            )
+        })?;
+
+        atom.header = Some(base_path);
+    }
+
+    write_entrypoint(directory, entrypoint)?;
+
+    Ok(())
+}
+
+/// Given a directory, links all the objects from the directory appropriately
+fn link_exe_from_dir(
+    directory: &Path,
+    output_path: PathBuf,
+    cross_compilation: &CrossCompileSetup,
+    additional_libraries: &[String],
+    debug: bool,
+    atoms: &[(String, Vec<u8>)],
+    prefixes: &[String],
+) -> anyhow::Result<()> {
+    let entrypoint =
+        get_entrypoint(directory).with_context(|| anyhow::anyhow!("link exe from dir"))?;
+
+    let prefixes = PrefixMapCompilation::from_input(atoms, prefixes, false)
+        .with_context(|| anyhow::anyhow!("link_exe_from_dir"))?;
+
+    let wasmer_main_c = generate_wasmer_main_c(&entrypoint, &prefixes).map_err(|e| {
+        anyhow::anyhow!(
+            "could not generate wasmer_main.c in dir {}: {e}",
+            directory.display()
+        )
+    })?;
+
+    std::fs::write(directory.join("wasmer_main.c"), wasmer_main_c.as_bytes()).map_err(|e| {
+        anyhow::anyhow!(
+            "could not write wasmer_main.c in dir {}: {e}",
+            directory.display()
+        )
+    })?;
+
+    let library_path = &cross_compilation.library;
+
+    let mut object_paths = entrypoint
+        .atoms
+        .iter()
+        .filter_map(|a| directory.join(&a.path).canonicalize().ok())
+        .collect::<Vec<_>>();
+
+    object_paths.extend(
+        entrypoint
+            .volumes
+            .iter()
+            .filter_map(|v| directory.join(&v.obj_file).canonicalize().ok()),
+    );
+
+    let zig_triple = utils::triple_to_zig_triple(&cross_compilation.target);
+    let include_dirs = entrypoint
+        .atoms
+        .iter()
+        .filter_map(|a| {
+            Some(
+                directory
+                    .join(a.header.as_deref()?)
+                    .canonicalize()
+                    .ok()?
+                    .parent()?
+                    .to_path_buf(),
+            )
+        })
+        .collect::<Vec<_>>();
+
+    let mut include_dirs = include_dirs;
+    include_dirs.sort();
+    include_dirs.dedup();
+
+    // On Windows, cross-compilation to Windows itself with zig does not work due
+    // to libunwind and libstdc++ not compiling, so we fake this special case of cross-compilation
+    // by falling back to the system compilation + system linker
+    if cross_compilation.target == Triple::host()
+        && cross_compilation.target.operating_system == OperatingSystem::Windows
+    {
+        run_c_compile(
+            &directory.join("wasmer_main.c"),
+            &directory.join("wasmer_main.o"),
+            &cross_compilation.target,
+            debug,
+            &include_dirs,
+        )
+        .map_err(|e| {
+            anyhow::anyhow!(
+                "could not run c compile of wasmer_main.c in dir {}: {e}",
+                directory.display()
+            )
+        })?;
+    }
+
+    // compilation done, now link
+    if cross_compilation.zig_binary_path.is_none()
+        || (cross_compilation.target == Triple::host()
+            && cross_compilation.target.operating_system == OperatingSystem::Windows)
+    {
+        #[cfg(not(windows))]
+        let linker = "cc";
+        #[cfg(windows)]
+        let linker = "clang";
+        let optimization_flag = "-O2";
+
+        let object_path = match directory.join("wasmer_main.o").canonicalize() {
+            Ok(s) => s,
+            Err(_) => directory.join("wasmer_main.c"),
+        };
+
+        object_paths.push(object_path);
+
+        return link_objects_system_linker(
+            library_path,
+            linker,
+            optimization_flag,
+            &include_dirs,
+            &object_paths,
+            &cross_compilation.target,
+            additional_libraries,
+            &output_path,
+            debug,
+        );
+    }
+
+    let zig_binary_path = cross_compilation
+        .zig_binary_path
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("could not find zig in $PATH {}", directory.display()))?;
+
+    let mut cmd = Command::new(zig_binary_path);
+    cmd.arg("build-exe");
+    cmd.arg("--verbose-cc");
+    cmd.arg("--verbose-link");
+    cmd.arg("-target");
+    cmd.arg(&zig_triple);
+
+    // On Windows, libstdc++ does not compile with zig due to zig-internal problems,
+    // so we link with only -lc
+    #[cfg(not(target_os = "windows"))]
+    if zig_triple.contains("windows") {
+        cmd.arg("-lc++");
+    } else {
+        cmd.arg("-lc");
+    }
+
+    #[cfg(target_os = "windows")]
+    cmd.arg("-lc");
+
+    for include_dir in include_dirs {
+        cmd.arg("-I");
+        cmd.arg(normalize_path(&format!("{}", include_dir.display())));
+    }
+
+    let mut include_path = library_path.clone();
+    include_path.pop();
+    include_path.pop();
+    include_path.push("include");
+    if !include_path.exists() {
+        // Can happen when we got the wrong library_path
+        return Err(anyhow::anyhow!("Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?", include_path.display(), library_path.display()));
+    }
+    cmd.arg("-I");
+    cmd.arg(normalize_path(&format!("{}", include_path.display())));
+
+    // On Windows, libunwind does not compile, so we have
+    // to create binaries without libunwind.
+    #[cfg(not(target_os = "windows"))]
+    cmd.arg("-lunwind");
+
+    #[cfg(target_os = "windows")]
+    if !zig_triple.contains("windows") {
+        cmd.arg("-lunwind");
+    }
+
+    cmd.arg("-OReleaseSafe");
+    cmd.arg("-fno-compiler-rt");
+    cmd.arg("-fno-lto");
+    #[cfg(target_os = "windows")]
+    let out_path = directory.join("wasmer_main.exe");
+    #[cfg(not(target_os = "windows"))]
+    let out_path = directory.join("wasmer_main");
+    cmd.arg(&format!("-femit-bin={}", out_path.display()));
+    cmd.args(
+        &object_paths
+            .iter()
+            .map(|o| normalize_path(&format!("{}", o.display())))
+            .collect::<Vec<_>>(),
+    );
+    cmd.arg(&normalize_path(&format!("{}", library_path.display())));
+    cmd.arg(normalize_path(&format!(
+        "{}",
+        directory
+            .join("wasmer_main.c")
+            .canonicalize()
+            .expect("could not find wasmer_main.c / wasmer_main.o")
+            .display()
+    )));
+
+    if zig_triple.contains("windows") {
+        let mut winsdk_path = library_path.clone();
+        winsdk_path.pop();
+        winsdk_path.pop();
+        winsdk_path.push("winsdk");
+
+        let files_winsdk = std::fs::read_dir(winsdk_path)
+            .ok()
+            .map(|res| {
+                res.filter_map(|r| Some(normalize_path(&format!("{}", r.ok()?.path().display()))))
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        cmd.args(files_winsdk);
+    }
+
+    if zig_triple.contains("macos") {
+        // need to link with Security framework when using zig, but zig
+        // doesn't include it, so we need to bring a copy of the dtb file
+        // which is basicaly the collection of exported symbol for the libs
+        let framework = include_bytes!("security_framework.tgz").to_vec();
+        // extract files
+        let tar = flate2::read::GzDecoder::new(framework.as_slice());
+        let mut archive = Archive::new(tar);
+        // directory is a temp folder
+        archive.unpack(directory)?;
+        // add the framework to the link command
+        cmd.arg("-framework");
+        cmd.arg("Security");
+        cmd.arg(format!("-F{}", directory.display()));
+    }
+
+    if debug {
+        println!("running cmd: {cmd:?}");
+        cmd.stdout(Stdio::inherit());
+        cmd.stderr(Stdio::inherit());
+    }
+
+    let compilation = cmd
+        .output()
+        .context(anyhow!("Could not execute `zig`: {cmd:?}"))?;
+
+    if !compilation.status.success() {
+        return Err(anyhow::anyhow!(String::from_utf8_lossy(
+            &compilation.stderr
+        )
+        .to_string()));
+    }
+
+    // remove file if it exists - if not done, can lead to errors on copy
+    let output_path_normalized = normalize_path(&format!("{}", output_path.display()));
+    let _ = std::fs::remove_file(output_path_normalized);
+    std::fs::copy(
+        normalize_path(&format!("{}", out_path.display())),
+        normalize_path(&format!("{}", output_path.display())),
+    )
+    .map_err(|e| {
+        anyhow::anyhow!(
+            "could not copy from {} to {}: {e}",
+            normalize_path(&format!("{}", out_path.display())),
+            normalize_path(&format!("{}", output_path.display()))
+        )
+    })?;
+
+    Ok(())
+}
+
+/// Link compiled objects using the system linker
+#[allow(clippy::too_many_arguments)]
+fn link_objects_system_linker(
+    libwasmer_path: &Path,
+    linker_cmd: &str,
+    optimization_flag: &str,
+    include_dirs: &[PathBuf],
+    object_paths: &[PathBuf],
+    target: &Triple,
+    additional_libraries: &[String],
+    output_path: &Path,
+    debug: bool,
+) -> Result<(), anyhow::Error> {
+    let libwasmer_path = libwasmer_path
+        .canonicalize()
+        .context("Failed to find libwasmer")?;
+    let mut command = Command::new(linker_cmd);
+    let mut command = command
+        .arg("-Wall")
+        .arg(optimization_flag)
+        .args(object_paths.iter().map(|path| path.canonicalize().unwrap()))
+        .arg(&libwasmer_path);
+
+    if *target != Triple::host() {
+        command = command.arg("-target");
+        command = command.arg(format!("{}", target));
+    }
+
+    for include_dir in include_dirs {
+        command = command.arg("-I");
+        command = command.arg(normalize_path(&format!("{}", include_dir.display())));
+    }
+    let mut include_path = libwasmer_path.clone();
+    include_path.pop();
+    include_path.pop();
+    include_path.push("include");
+    if !include_path.exists() {
+        // Can happen when we got the wrong library_path
+        return Err(anyhow::anyhow!("Wasmer include path {} does not exist, maybe library path {} is wrong (expected /lib/libwasmer.a)?", include_path.display(), libwasmer_path.display()));
+    }
+    command = command.arg("-I");
+    command = command.arg(normalize_path(&format!("{}", include_path.display())));
+
+    // Add libraries required per platform.
+    // We need userenv, sockets (Ws2_32), advapi32 for some system calls and bcrypt for random numbers.
+    let mut additional_libraries = additional_libraries.to_vec();
+    if target.operating_system == OperatingSystem::Windows {
+        additional_libraries.extend(LINK_SYSTEM_LIBRARIES_WINDOWS.iter().map(|s| s.to_string()));
+    } else {
+        additional_libraries.extend(LINK_SYSTEM_LIBRARIES_UNIX.iter().map(|s| s.to_string()));
+    }
+    let link_against_extra_libs = additional_libraries.iter().map(|lib| format!("-l{}", lib));
+    let command = command.args(link_against_extra_libs);
+    let command = command.arg("-o").arg(output_path);
+    if debug {
+        println!("{:#?}", command);
+    }
+    let output = command.output()?;
+
+    if !output.status.success() {
+        bail!(
+            "linking failed with command line:{:#?} stdout: {}\n\nstderr: {}",
+            command,
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr),
+        );
+    }
+    Ok(())
+}
+
+/// Generate the wasmer_main.c that links all object files together
+/// (depending on the object format / atoms number)
+fn generate_wasmer_main_c(
+    entrypoint: &Entrypoint,
+    prefixes: &PrefixMapCompilation,
+) -> Result<String, anyhow::Error> {
+    use std::fmt::Write;
+
+    const WASMER_MAIN_C_SOURCE: &str = include_str!("wasmer_create_exe_main.c");
+
+    // always with compile zig + static_defs.h
+    let atom_names = entrypoint
+        .atoms
+        .iter()
+        .map(|a| &a.command)
+        .collect::<Vec<_>>();
+
+    let c_code_to_add = String::new();
+    let mut c_code_to_instantiate = String::new();
+    let mut deallocate_module = String::new();
+    let mut extra_headers = Vec::new();
+
+    for a in atom_names.iter() {
+        let prefix = prefixes
+            .get_prefix_for_atom(&utils::normalize_atom_name(a))
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "cannot find prefix for atom {a} when generating wasmer_main.c ({:#?})",
+                    prefixes
+                )
+            })?;
+        let atom_name = prefix.clone();
+
+        extra_headers.push(format!("#include \"static_defs_{atom_name}.h\""));
+
+        write!(c_code_to_instantiate, "
+        wasm_module_t *atom_{atom_name} = wasmer_object_module_new_{atom_name}(store, \"{atom_name}\");
+        if (!atom_{atom_name}) {{
+            fprintf(stderr, \"Failed to create module from atom \\\"{a}\\\"\\n\");
+            print_wasmer_error();
+            return -1;
+        }}
+        ")?;
+
+        write!(deallocate_module, "wasm_module_delete(atom_{atom_name});")?;
+    }
+
+    let volumes_str = entrypoint
+        .volumes
+        .iter()
+        .map(|v| utils::normalize_atom_name(&v.name).to_uppercase())
+        .map(|uppercase| {
+            format!(
+                "extern size_t {uppercase}_LENGTH asm(\"{uppercase}_LENGTH\");\r\nextern char {uppercase}_DATA asm(\"{uppercase}_DATA\");"
+            )
+        })
+        .collect::<Vec<_>>();
+
+    let base_str = WASMER_MAIN_C_SOURCE;
+    let volumes_str = volumes_str.join("\r\n");
+    let return_str = base_str
+        .replace(
+            "#define WASI",
+            if !volumes_str.trim().is_empty() {
+                "#define WASI\r\n#define WASI_PIRITA"
+            } else {
+                "#define WASI"
+            },
+        )
+        .replace("// DECLARE_MODULES", &c_code_to_add)
+        .replace("// DECLARE_VOLUMES", &volumes_str)
+        .replace(
+            "// SET_NUMBER_OF_COMMANDS",
+            &format!("number_of_commands = {};", atom_names.len()),
+        )
+        .replace("// EXTRA_HEADERS", &extra_headers.join("\r\n"))
+        .replace("wasm_module_delete(module);", &deallocate_module);
+
+    if atom_names.len() == 1 {
+        let prefix = prefixes
+            .get_prefix_for_atom(&utils::normalize_atom_name(atom_names[0]))
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "cannot find prefix for atom {} when generating wasmer_main.c ({:#?})",
+                    &atom_names[0],
+                    prefixes
+                )
+            })?;
+        write!(c_code_to_instantiate, "module = atom_{prefix};")?;
+    } else {
+        for a in atom_names.iter() {
+            let prefix = prefixes
+                .get_prefix_for_atom(&utils::normalize_atom_name(a))
+                .ok_or_else(|| {
+                    anyhow::anyhow!(
+                        "cannot find prefix for atom {a} when generating wasmer_main.c ({:#?})",
+                        prefixes
+                    )
+                })?;
+            writeln!(
+                c_code_to_instantiate,
+                "if (strcmp(selected_atom, \"{a}\") == 0) {{ module = atom_{}; }}",
+                prefix
+            )?;
+        }
+    }
+
+    write!(
+        c_code_to_instantiate,
+        "
+    if (!module) {{
+        fprintf(stderr, \"No --command given, available commands are:\\n\");
+        fprintf(stderr, \"\\n\");
+        {commands}
+        fprintf(stderr, \"\\n\");
+        return -1;
+    }}
+    ",
+        commands = atom_names
+            .iter()
+            .map(|a| format!("fprintf(stderr, \"    {a}\\n\");"))
+            .collect::<Vec<_>>()
+            .join("\n")
+    )?;
+
+    Ok(return_str.replace("// INSTANTIATE_MODULES", &c_code_to_instantiate))
+}
+
+#[allow(dead_code)]
+pub(super) mod utils {
+
+    use std::{
+        ffi::OsStr,
+        path::{Path, PathBuf},
+    };
+
+    use anyhow::{anyhow, Context};
+    use target_lexicon::{Architecture, Environment, OperatingSystem, Triple};
+    use wasmer_types::{CpuFeature, Target};
+
+    use super::{CrossCompile, CrossCompileSetup, UrlOrVersion};
+
+    pub(in crate::commands) fn target_triple_to_target(
+        target_triple: &Triple,
+        cpu_features: &[CpuFeature],
+    ) -> Target {
+        let mut features = cpu_features.iter().fold(CpuFeature::set(), |a, b| a | *b);
+        // Cranelift requires SSE2, so we have this "hack" for now to facilitate
+        // usage
+        if target_triple.architecture == Architecture::X86_64 {
+            features |= CpuFeature::SSE2;
+        }
+        Target::new(target_triple.clone(), features)
+    }
+
+    pub(in crate::commands) fn get_cross_compile_setup(
+        cross_subc: &mut CrossCompile,
+        target_triple: &Triple,
+        starting_cd: &Path,
+        specific_release: Option<UrlOrVersion>,
+    ) -> Result<CrossCompileSetup, anyhow::Error> {
+        let target = target_triple;
+
+        if let Some(tarball_path) = cross_subc.tarball.as_mut() {
+            if tarball_path.is_relative() {
+                *tarball_path = starting_cd.join(&tarball_path);
+                if !tarball_path.exists() {
+                    return Err(anyhow!(
+                        "Tarball path `{}` does not exist.",
+                        tarball_path.display()
+                    ));
+                } else if tarball_path.is_dir() {
+                    return Err(anyhow!(
+                        "Tarball path `{}` is a directory.",
+                        tarball_path.display()
+                    ));
+                }
+            }
+        }
+
+        let zig_binary_path = if !cross_subc.use_system_linker {
+            find_zig_binary(cross_subc.zig_binary_path.as_ref().and_then(|p| {
+                if p.is_absolute() {
+                    p.canonicalize().ok()
+                } else {
+                    starting_cd.join(p).canonicalize().ok()
+                }
+            }))
+            .ok()
+        } else {
+            None
+        };
+
+        let library = if let Some(v) = cross_subc.library_path.clone() {
+            Some(v.canonicalize().unwrap_or(v))
+        } else if let Some(local_tarball) = cross_subc.tarball.as_ref() {
+            let (filename, tarball_dir) = find_filename(local_tarball, target)?;
+            Some(tarball_dir.join(filename))
+        } else {
+            let wasmer_cache_dir =
+                if *target_triple == Triple::host() && std::env::var("WASMER_DIR").is_ok() {
+                    wasmer_registry::WasmerConfig::get_wasmer_dir()
+                        .map_err(|e| anyhow!("{e}"))
+                        .map(|o| o.join("cache"))
+                } else {
+                    get_libwasmer_cache_path()
+                }
+                .ok();
+
+            // check if the tarball for the target already exists locally
+            let local_tarball = wasmer_cache_dir.as_ref().and_then(|wc| {
+                let wasmer_cache = std::fs::read_dir(wc).ok()?;
+                wasmer_cache
+                    .filter_map(|e| e.ok())
+                    .filter_map(|e| {
+                        let path = format!("{}", e.path().display());
+                        if path.ends_with(".tar.gz") {
+                            Some(e.path())
+                        } else {
+                            None
+                        }
+                    })
+                    .find(|p| crate::commands::utils::filter_tarball(p, target))
+            });
+
+            if let Some(UrlOrVersion::Url(wasmer_release)) = specific_release.as_ref() {
+                let tarball = super::http_fetch::download_url(wasmer_release.as_ref())?;
+                let (filename, tarball_dir) = find_filename(&tarball, target)?;
+                Some(tarball_dir.join(filename))
+            } else if let Some(UrlOrVersion::Version(wasmer_release)) = specific_release.as_ref() {
+                let release = super::http_fetch::get_release(Some(wasmer_release.clone()))?;
+                let tarball = super::http_fetch::download_release(release, target.clone())?;
+                let (filename, tarball_dir) = find_filename(&tarball, target)?;
+                Some(tarball_dir.join(filename))
+            } else if let Some(local_tarball) = local_tarball.as_ref() {
+                let (filename, tarball_dir) = find_filename(local_tarball, target)?;
+                Some(tarball_dir.join(filename))
+            } else {
+                let release = super::http_fetch::get_release(None)?;
+                let tarball = super::http_fetch::download_release(release, target.clone())?;
+                let (filename, tarball_dir) = find_filename(&tarball, target)?;
+                Some(tarball_dir.join(filename))
+            }
+        };
+
+        let library = library.ok_or_else(|| anyhow!("libwasmer.a / wasmer.lib not found"))?;
+
+        let ccs = CrossCompileSetup {
+            target: target.clone(),
+            zig_binary_path,
+            library,
+        };
+        Ok(ccs)
+    }
+
+    pub(super) fn filter_tarball(p: &Path, target: &Triple) -> bool {
+        filter_tarball_internal(p, target).unwrap_or(false)
+    }
+
+    fn filter_tarball_internal(p: &Path, target: &Triple) -> Option<bool> {
+        if !p.file_name()?.to_str()?.ends_with(".tar.gz") {
+            return None;
+        }
+
+        if target.environment == Environment::Musl && !p.file_name()?.to_str()?.contains("musl")
+            || p.file_name()?.to_str()?.contains("musl") && target.environment != Environment::Musl
+        {
+            return None;
+        }
+
+        if let Architecture::Aarch64(_) = target.architecture {
+            if !(p.file_name()?.to_str()?.contains("aarch64")
+                || p.file_name()?.to_str()?.contains("arm64"))
+            {
+                return None;
+            }
+        }
+
+        if let Architecture::X86_64 = target.architecture {
+            if target.operating_system == OperatingSystem::Windows {
+                if !p.file_name()?.to_str()?.contains("gnu64") {
+                    return None;
+                }
+            } else if !(p.file_name()?.to_str()?.contains("x86_64")
+                || p.file_name()?.to_str()?.contains("amd64"))
+            {
+                return None;
+            }
+        }
+
+        if let OperatingSystem::Windows = target.operating_system {
+            if !p.file_name()?.to_str()?.contains("windows") {
+                return None;
+            }
+        }
+
+        if let OperatingSystem::Darwin = target.operating_system {
+            if !(p.file_name()?.to_str()?.contains("apple")
+                || p.file_name()?.to_str()?.contains("darwin"))
+            {
+                return None;
+            }
+        }
+
+        if let OperatingSystem::Linux = target.operating_system {
+            if !p.file_name()?.to_str()?.contains("linux") {
+                return None;
+            }
+        }
+
+        Some(true)
+    }
+
+    pub(super) fn find_filename(
+        local_tarball: &Path,
+        target: &Triple,
+    ) -> Result<(PathBuf, PathBuf), anyhow::Error> {
+        let target_file_path = local_tarball
+            .parent()
+            .and_then(|parent| Some(parent.join(local_tarball.file_stem()?)))
+            .unwrap_or_else(|| local_tarball.to_path_buf());
+
+        let target_file_path = target_file_path
+            .parent()
+            .and_then(|parent| Some(parent.join(target_file_path.file_stem()?)))
+            .unwrap_or_else(|| target_file_path.clone());
+
+        std::fs::create_dir_all(&target_file_path)
+            .map_err(|e| anyhow!("{e}"))
+            .with_context(|| anyhow!("{}", target_file_path.display()))?;
+        let files =
+            super::http_fetch::untar(local_tarball, &target_file_path).with_context(|| {
+                anyhow!(
+                    "{} -> {}",
+                    local_tarball.display(),
+                    target_file_path.display()
+                )
+            })?;
+        let tarball_dir = target_file_path.canonicalize().unwrap_or(target_file_path);
+        let file = find_libwasmer_in_files(target, &files)?;
+        Ok((file, tarball_dir))
+    }
+
+    fn find_libwasmer_in_files(
+        target: &Triple,
+        files: &[PathBuf],
+    ) -> Result<PathBuf, anyhow::Error> {
+        let target_files = &[
+            OsStr::new("libwasmer-headless.a"),
+            OsStr::new("wasmer-headless.lib"),
+            OsStr::new("libwasmer.a"),
+            OsStr::new("wasmer.lib"),
+        ];
+        target_files
+        .iter()
+        .find_map(|q| {
+            files.iter().find(|f| f.file_name() == Some(*q))
+        })
+        .cloned()
+        .ok_or_else(|| {
+            anyhow!("Could not find libwasmer.a for {} target in the provided tarball path (files = {files:#?})", target)
+        })
+    }
+
+    pub(super) fn normalize_atom_name(s: &str) -> String {
+        s.chars()
+            .filter_map(|c| {
+                if char::is_alphabetic(c) {
+                    Some(c)
+                } else if c == '-' || c == '_' {
+                    Some('_')
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+
+    pub(super) fn triple_to_zig_triple(target_triple: &Triple) -> String {
+        let arch = match target_triple.architecture {
+            wasmer_types::Architecture::X86_64 => "x86_64".into(),
+            wasmer_types::Architecture::Aarch64(wasmer_types::Aarch64Architecture::Aarch64) => {
+                "aarch64".into()
+            }
+            v => v.to_string(),
+        };
+        let os = match target_triple.operating_system {
+            wasmer_types::OperatingSystem::Linux => "linux".into(),
+            wasmer_types::OperatingSystem::Darwin => "macos".into(),
+            wasmer_types::OperatingSystem::Windows => "windows".into(),
+            v => v.to_string(),
+        };
+        let env = match target_triple.environment {
+            wasmer_types::Environment::Musl => "musl",
+            wasmer_types::Environment::Gnu => "gnu",
+            wasmer_types::Environment::Msvc => "msvc",
+            _ => "none",
+        };
+        format!("{}-{}-{}", arch, os, env)
+    }
+
+    pub(super) fn get_wasmer_dir() -> anyhow::Result<PathBuf> {
+        wasmer_registry::WasmerConfig::get_wasmer_dir().map_err(|e| anyhow!("{e}"))
+    }
+
+    pub(super) fn get_wasmer_include_directory() -> anyhow::Result<PathBuf> {
+        let mut path = get_wasmer_dir()?;
+        if path.clone().join("wasmer.h").exists() {
+            return Ok(path);
+        }
+        path.push("include");
+        if !path.clone().join("wasmer.h").exists() {
+            if !path.exists() {
+                return Err(anyhow!("WASMER_DIR path {} does not exist", path.display()));
+            }
+            println!(
+                "wasmer.h does not exist in {}, will probably default to the system path",
+                path.canonicalize().unwrap().display()
+            );
+        }
+        Ok(path)
+    }
+
+    /// path to the static libwasmer
+    pub(super) fn get_libwasmer_path() -> anyhow::Result<PathBuf> {
+        let path = get_wasmer_dir()?;
+
+        // TODO: prefer headless Wasmer if/when it's a separate library.
+        #[cfg(not(windows))]
+        let libwasmer_static_name = "libwasmer.a";
+        #[cfg(windows)]
+        let libwasmer_static_name = "libwasmer.lib";
+
+        if path.exists() && path.join(libwasmer_static_name).exists() {
+            Ok(path.join(libwasmer_static_name))
+        } else {
+            Ok(path.join("lib").join(libwasmer_static_name))
+        }
+    }
+
+    /// path to library tarball cache dir
+    pub(super) fn get_libwasmer_cache_path() -> anyhow::Result<PathBuf> {
+        let mut path = get_wasmer_dir()?;
+        path.push("cache");
+        std::fs::create_dir_all(&path)?;
+        Ok(path)
+    }
+
+    pub(super) fn get_zig_exe_str() -> &'static str {
+        #[cfg(target_os = "windows")]
+        {
+            "zig.exe"
+        }
+        #[cfg(not(target_os = "windows"))]
+        {
+            "zig"
+        }
+    }
+
+    pub(super) fn find_zig_binary(path: Option<PathBuf>) -> Result<PathBuf, anyhow::Error> {
+        use std::env::split_paths;
+        #[cfg(unix)]
+        use std::os::unix::ffi::OsStrExt;
+        let path_var = std::env::var("PATH").unwrap_or_default();
+        #[cfg(unix)]
+        let system_path_var = std::process::Command::new("getconf")
+            .args(["PATH"])
+            .output()
+            .map(|output| output.stdout)
+            .unwrap_or_default();
+        let retval = if let Some(p) = path {
+            if p.exists() {
+                p
+            } else {
+                return Err(anyhow!("Could not find `zig` binary in {}.", p.display()));
+            }
+        } else {
+            let mut retval = None;
+            for mut p in split_paths(&path_var).chain(split_paths(
+                #[cfg(unix)]
+                {
+                    &OsStr::from_bytes(&system_path_var[..])
+                },
+                #[cfg(not(unix))]
+                {
+                    OsStr::new("")
+                },
+            )) {
+                p.push(get_zig_exe_str());
+                if p.exists() {
+                    retval = Some(p);
+                    break;
+                }
+            }
+            retval.ok_or_else(|| anyhow!("Could not find `zig` binary in PATH."))?
+        };
+
+        let version = std::process::Command::new(&retval)
+            .arg("version")
+            .output()
+            .with_context(|| {
+                format!(
+                    "Could not execute `zig` binary at path `{}`",
+                    retval.display()
+                )
+            })?
+            .stdout;
+        let version_slice = if let Some(pos) = version
+            .iter()
+            .position(|c| !(c.is_ascii_digit() || (*c == b'.')))
+        {
+            &version[..pos]
+        } else {
+            &version[..]
+        };
+
+        let version_slice = String::from_utf8_lossy(version_slice);
+        let version_semver = semver::Version::parse(&version_slice)
+            .map_err(|e| anyhow!("could not parse zig version: {version_slice}: {e}"))?;
+
+        if version_semver < semver::Version::parse("0.10.0").unwrap() {
+            Err(anyhow!("`zig` binary in PATH (`{}`) is not a new enough version (`{version_slice}`): please use version `0.10.0` or newer.", retval.display()))
+        } else {
+            Ok(retval)
+        }
+    }
+
+    #[test]
+    fn test_filter_tarball() {
+        use std::str::FromStr;
+        let test_paths = [
+            "/test/wasmer-darwin-amd64.tar.gz",
+            "/test/wasmer-darwin-arm64.tar.gz",
+            "/test/wasmer-linux-aarch64.tar.gz",
+            "/test/wasmer-linux-amd64.tar.gz",
+            "/test/wasmer-linux-musl-amd64.tar.gz",
+            "/test/wasmer-windows-amd64.tar.gz",
+            "/test/wasmer-windows-gnu64.tar.gz",
+            "/test/wasmer-windows.exe",
+        ];
+
+        let paths = test_paths.iter().map(Path::new).collect::<Vec<_>>();
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-windows").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-windows-gnu64.tar.gz")],
+        );
+
+        let paths = test_paths.iter().map(Path::new).collect::<Vec<_>>();
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-windows-gnu").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-windows-gnu64.tar.gz")],
+        );
+
+        let paths = test_paths.iter().map(Path::new).collect::<Vec<_>>();
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-windows-msvc").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-windows-gnu64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-darwin").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-darwin-amd64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-unknown-linux-gnu").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-linux-amd64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-linux-gnu").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-linux-amd64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("aarch64-linux-gnu").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-linux-aarch64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("x86_64-windows-gnu").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-windows-gnu64.tar.gz")],
+        );
+
+        assert_eq!(
+            paths
+                .iter()
+                .filter(|p| crate::commands::utils::filter_tarball(
+                    p,
+                    &Triple::from_str("aarch64-darwin").unwrap()
+                ))
+                .collect::<Vec<_>>(),
+            vec![&Path::new("/test/wasmer-darwin-arm64.tar.gz")],
+        );
+    }
+
+    #[test]
+    fn test_normalize_atom_name() {
+        assert_eq!(
+            normalize_atom_name("atom-name-with-dash"),
+            "atom_name_with_dash".to_string()
+        );
+    }
+}
+
+mod http_fetch {
+    use std::path::Path;
+
+    use anyhow::{anyhow, Context, Result};
+
+    pub(super) fn get_release(
+        release_version: Option<semver::Version>,
+    ) -> Result<serde_json::Value> {
+        let uri = "https://api.github.com/repos/wasmerio/wasmer/releases";
+
+        // Increases rate-limiting in GitHub CI
+        let auth = std::env::var("GITHUB_TOKEN");
+
+        let client = reqwest::blocking::Client::new();
+        let mut req = client.get(uri);
+        if let Ok(token) = auth {
+            req = req.header("Authorization", &format!("Bearer {token}"));
+        }
+
+        let response = req
+            .header("User-Agent", "wasmerio")
+            .header("Accept", "application/vnd.github.v3+json")
+            .send()
+            .map_err(anyhow::Error::new)
+            .context("Could not lookup wasmer repository on Github.")?;
+
+        let status = response.status();
+
+        let body = response
+            .bytes()
+            .map_err(anyhow::Error::new)
+            .context("Could not retrieve wasmer release history body")?;
+
+        if status != reqwest::StatusCode::OK {
+            log::warn!(
+                "Warning: Github API replied with non-200 status code: {}. Response: {}",
+                status,
+                String::from_utf8_lossy(&body),
+            );
+        }
+
+        let mut response = serde_json::from_slice::<serde_json::Value>(&body)?;
+
+        if let Some(releases) = response.as_array_mut() {
+            releases.retain(|r| {
+                r["tag_name"].is_string() && !r["tag_name"].as_str().unwrap().is_empty()
+            });
+            releases.sort_by_cached_key(|r| r["tag_name"].as_str().unwrap_or_default().to_string());
+            match release_version {
+                Some(specific_version) => {
+                    let mut all_versions = Vec::new();
+                    for r in releases.iter() {
+                        if r["tag_name"].as_str().unwrap_or_default()
+                            == specific_version.to_string()
+                        {
+                            return Ok(r.clone());
+                        } else {
+                            all_versions
+                                .push(r["tag_name"].as_str().unwrap_or_default().to_string());
+                        }
+                    }
+                    return Err(anyhow::anyhow!(
+                        "could not find release version {}, available versions are: {}",
+                        specific_version,
+                        all_versions.join(", ")
+                    ));
+                }
+                None => {
+                    if let Some(latest) = releases.pop() {
+                        return Ok(latest);
+                    }
+                }
+            }
+        }
+
+        Err(anyhow!(
+            "Could not get expected Github API response.\n\nReason: response format is not recognized:\n{response:#?}",
+        ))
+    }
+
+    pub(super) fn download_release(
+        mut release: serde_json::Value,
+        target_triple: wasmer::Triple,
+    ) -> Result<std::path::PathBuf> {
+        // Test if file has been already downloaded
+        if let Ok(mut cache_path) = super::utils::get_libwasmer_cache_path() {
+            let paths = std::fs::read_dir(&cache_path).and_then(|r| {
+                r.map(|res| res.map(|e| e.path()))
+                    .collect::<Result<Vec<_>, std::io::Error>>()
+            });
+
+            if let Ok(mut entries) = paths {
+                entries.retain(|p| p.to_str().map(|p| p.ends_with(".tar.gz")).unwrap_or(false));
+                entries.retain(|p| super::utils::filter_tarball(p, &target_triple));
+                if !entries.is_empty() {
+                    cache_path.push(&entries[0]);
+                    if cache_path.exists() {
+                        eprintln!(
+                            "Using cached tarball to cache path `{}`.",
+                            cache_path.display()
+                        );
+                        return Ok(cache_path);
+                    }
+                }
+            }
+        }
+
+        let assets = match release["assets"].as_array_mut() {
+            Some(s) => s,
+            None => {
+                return Err(anyhow!(
+                    "GitHub API: no [assets] array in JSON response for latest releases"
+                ));
+            }
+        };
+
+        assets.retain(|a| {
+            let name = match a["name"].as_str() {
+                Some(s) => s,
+                None => return false,
+            };
+            super::utils::filter_tarball(Path::new(&name), &target_triple)
+        });
+
+        if assets.len() != 1 {
+            return Err(anyhow!(
+                "GitHub API: more that one release selected for target {target_triple}: {assets:?}"
+            ));
+        }
+
+        let browser_download_url = if let Some(url) = assets[0]["browser_download_url"].as_str() {
+            url.to_string()
+        } else {
+            return Err(anyhow!(
+                "Could not get download url from Github API response."
+            ));
+        };
+
+        download_url(&browser_download_url)
+    }
+
+    pub(crate) fn download_url(
+        browser_download_url: &str,
+    ) -> Result<std::path::PathBuf, anyhow::Error> {
+        let filename = browser_download_url
+            .split('/')
+            .last()
+            .unwrap_or("output")
+            .to_string();
+
+        let download_tempdir = tempfile::TempDir::new()?;
+        let download_path = download_tempdir.path().join(&filename);
+
+        let mut file = std::fs::File::create(&download_path)?;
+        log::debug!(
+            "Downloading {} to {}",
+            browser_download_url,
+            download_path.display()
+        );
+
+        let mut response = reqwest::blocking::Client::builder()
+            .redirect(reqwest::redirect::Policy::limited(10))
+            .timeout(std::time::Duration::from_secs(10))
+            .build()
+            .map_err(anyhow::Error::new)
+            .context("Could not lookup wasmer artifact on Github.")?
+            .get(browser_download_url)
+            .send()
+            .map_err(anyhow::Error::new)
+            .context("Could not lookup wasmer artifact on Github.")?;
+
+        response
+            .copy_to(&mut file)
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+
+        match super::utils::get_libwasmer_cache_path() {
+            Ok(mut cache_path) => {
+                cache_path.push(&filename);
+                if let Err(err) = std::fs::copy(&download_path, &cache_path) {
+                    eprintln!(
+                        "Could not store tarball to cache path `{}`: {}",
+                        cache_path.display(),
+                        err
+                    );
+                    Err(anyhow!(
+                        "Could not copy from {} to {}",
+                        download_path.display(),
+                        cache_path.display()
+                    ))
+                } else {
+                    eprintln!("Cached tarball to cache path `{}`.", cache_path.display());
+                    Ok(cache_path)
+                }
+            }
+            Err(err) => {
+                eprintln!(
+                    "Could not determine cache path for downloaded binaries.: {}",
+                    err
+                );
+                Err(anyhow!("Could not determine libwasmer cache path"))
+            }
+        }
+    }
+
+    use std::path::PathBuf;
+
+    pub(crate) fn list_dir(target: &Path) -> Vec<PathBuf> {
+        use walkdir::WalkDir;
+        WalkDir::new(target)
+            .into_iter()
+            .filter_map(|e| e.ok())
+            .map(|entry| entry.path().to_path_buf())
+            .collect()
+    }
+
+    pub(super) fn untar(tarball: &Path, target: &Path) -> Result<Vec<PathBuf>> {
+        let _ = std::fs::remove_dir(target);
+        wasmer_registry::try_unpack_targz(tarball, target, false)?;
+        Ok(list_dir(target))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_obj.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_obj.rs
new file mode 100644
index 0000000..22a2f11
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/create_obj.rs
@@ -0,0 +1,170 @@
+#![allow(dead_code)]
+//! Create a standalone native executable for a given Wasm file.
+
+use std::{env, path::PathBuf};
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use wasmer::*;
+
+use crate::store::CompilerOptions;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer create-exe` subcommand
+pub struct CreateObj {
+    /// Input file
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    /// Output file or directory if the input is a pirita file
+    #[clap(name = "OUTPUT_PATH", short = 'o')]
+    output: PathBuf,
+
+    /// Optional directorey used for debugging: if present, will
+    /// output the files to a debug instead of a temp directory
+    #[clap(long, name = "DEBUG PATH")]
+    debug_dir: Option<PathBuf>,
+
+    /// Prefix for the function names in the input file in the compiled object file.
+    ///
+    /// Default value = sha256 of the input file
+    #[clap(long, name = "PREFIX")]
+    prefix: Option<String>,
+
+    /// Atom name to compile when compiling multi-atom pirita files
+    #[clap(long, name = "ATOM")]
+    atom: Option<String>,
+
+    /// Compilation Target triple
+    ///
+    /// Accepted target triple values must follow the
+    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    ///
+    /// The recommended targets we try to support are:
+    ///
+    /// - "x86_64-linux-gnu"
+    /// - "aarch64-linux-gnu"
+    /// - "x86_64-apple-darwin"
+    /// - "arm64-apple-darwin"
+    /// - "x86_64-windows-gnu"
+    #[clap(long = "target")]
+    target_triple: Option<Triple>,
+
+    #[clap(long, short = 'm', number_of_values = 1)]
+    cpu_features: Vec<CpuFeature>,
+
+    #[clap(flatten)]
+    compiler: CompilerOptions,
+}
+
+impl CreateObj {
+    /// Runs logic for the `create-obj` subcommand
+    pub fn execute(&self) -> Result<()> {
+        let path = crate::common::normalize_path(&format!("{}", self.path.display()));
+        let target_triple = self.target_triple.clone().unwrap_or_else(Triple::host);
+        let starting_cd = env::current_dir()?;
+        let input_path = starting_cd.join(path);
+        let temp_dir = tempfile::tempdir();
+        let output_directory_path = match self.debug_dir.as_ref() {
+            Some(s) => s.clone(),
+            None => temp_dir?.path().to_path_buf(),
+        };
+        std::fs::create_dir_all(&output_directory_path)?;
+        let prefix = match self.prefix.as_ref() {
+            Some(s) => vec![s.clone()],
+            None => Vec::new(),
+        };
+
+        let target = crate::commands::create_exe::utils::target_triple_to_target(
+            &target_triple,
+            &self.cpu_features,
+        );
+        let (_, compiler_type) = self.compiler.get_store_for_target(target.clone())?;
+        println!("Compiler: {}", compiler_type.to_string());
+        println!("Target: {}", target.triple());
+
+        let atoms = if let Ok(webc) = webc::compat::Container::from_disk(&input_path) {
+            crate::commands::create_exe::compile_pirita_into_directory(
+                &webc,
+                &output_directory_path,
+                &self.compiler,
+                &self.cpu_features,
+                &target_triple,
+                &prefix,
+                crate::commands::AllowMultiWasm::Reject(self.atom.clone()),
+                self.debug_dir.is_some(),
+            )
+        } else {
+            crate::commands::create_exe::prepare_directory_from_single_wasm_file(
+                &input_path,
+                &output_directory_path,
+                &self.compiler,
+                &target_triple,
+                &self.cpu_features,
+                &prefix,
+                self.debug_dir.is_some(),
+            )
+        }?;
+
+        // Copy output files into target path, depending on whether
+        // there are one or many files being compiled
+        let file_paths = std::fs::read_dir(output_directory_path.join("atoms"))
+            .map_err(|e| {
+                anyhow::anyhow!(
+                    "could not read {}: {e}",
+                    output_directory_path.join("atoms").display()
+                )
+            })?
+            .filter_map(|path| path.ok()?.path().canonicalize().ok())
+            .collect::<Vec<_>>();
+
+        if file_paths.is_empty() {
+            return Err(anyhow::anyhow!(
+                "could not compile object file: no output objects in {}",
+                output_directory_path.join("atoms").display()
+            ));
+        }
+
+        if file_paths.len() == 1 {
+            if let Some(parent) = self.output.parent() {
+                std::fs::create_dir_all(parent)?;
+            }
+            std::fs::copy(
+                std::env::current_dir().unwrap().join(&file_paths[0]),
+                std::env::current_dir().unwrap().join(&self.output),
+            )
+            .map_err(|e| {
+                anyhow::anyhow!(
+                    "{} -> {}: {e}",
+                    &file_paths[0].display(),
+                    self.output.display()
+                )
+            })?;
+        } else {
+            let keys = atoms
+                .iter()
+                .map(|(name, _)| name.clone())
+                .collect::<Vec<_>>();
+            return Err(anyhow::anyhow!(
+                "where <ATOM> is one of: {}",
+                keys.join(", ")
+            ))
+            .context(anyhow::anyhow!(
+                "note: use --atom <ATOM> to specify which atom to compile"
+            ))
+            .context(anyhow::anyhow!(
+                "cannot compile more than one atom at a time"
+            ));
+        }
+
+        let output_file = self.output.canonicalize().unwrap().display().to_string();
+        let output_file = output_file
+            .strip_prefix(r"\\?\")
+            .unwrap_or(&output_file)
+            .to_string();
+
+        eprintln!("✔ Object compiled successfully to `{output_file}`");
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/deploy.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/deploy.rs
new file mode 100644
index 0000000..febfe7e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/deploy.rs
@@ -0,0 +1,236 @@
+use std::{io::Write, path::PathBuf};
+
+use anyhow::{bail, Context};
+use edge_schema::schema::AppConfigV1;
+use is_terminal::IsTerminal;
+use wasmer_api::types::DeployAppVersion;
+
+use crate::{
+    commands::{
+        app::{deploy_app_verbose, DeployAppOpts, WaitMode},
+        AsyncCliCommand,
+    },
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Start a remote SSH session.
+#[derive(clap::Parser, Debug)]
+pub struct CmdDeploy {
+    #[clap(flatten)]
+    pub api: ApiOpts,
+    #[clap(flatten)]
+    pub fmt: ItemFormatOpts,
+
+    /// Skip local schema validation.
+    #[clap(long)]
+    pub no_validate: bool,
+
+    /// Do not prompt for user input.
+    #[clap(long)]
+    pub non_interactive: bool,
+
+    /// Automatically publish the package referenced by this app.
+    ///
+    /// Only works if the corresponding wasmer.toml is in the same directory.
+    #[clap(long)]
+    pub publish_package: bool,
+
+    /// The path to the app.yaml file.
+    #[clap(long)]
+    pub path: Option<PathBuf>,
+
+    /// Do not wait for the app to become reachable.
+    #[clap(long)]
+    pub no_wait: bool,
+
+    /// Do not make the new app version the default (active) version.
+    /// This is useful for testing a deployment first, before moving it to "production".
+    #[clap(long)]
+    pub no_default: bool,
+
+    /// Do not persist the app version ID in the app.yaml.
+    #[clap(long)]
+    pub no_persist_id: bool,
+
+    /// Specify the owner (user or namespace) of the app.
+    /// Will default to the currently logged in user, or the existing one
+    /// if the app can be found.
+    #[clap(long)]
+    pub owner: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdDeploy {
+    type Output = DeployAppVersion;
+
+    async fn run_async(self) -> Result<DeployAppVersion, anyhow::Error> {
+        let client = self.api.client()?;
+
+        let base_path = if let Some(p) = self.path {
+            p
+        } else {
+            std::env::current_dir()?
+        };
+        let file_path = if base_path.is_file() {
+            base_path
+        } else if base_path.is_dir() {
+            let full = base_path.join(AppConfigV1::CANONICAL_FILE_NAME);
+            if !full.is_file() {
+                bail!("Could not find app.yaml at path: '{}'", full.display());
+            }
+            full
+        } else {
+            bail!("No such file or directory: '{}'", base_path.display());
+        };
+        let abs_dir_path = file_path.canonicalize()?.parent().unwrap().to_owned();
+
+        let interactive = std::io::stdin().is_terminal() && !self.non_interactive;
+
+        let raw_config = std::fs::read_to_string(&file_path)
+            .with_context(|| format!("Could not read file: '{}'", file_path.display()))?;
+
+        let orig_config = AppConfigV1::parse_yaml(&raw_config)?;
+        eprintln!("Loaded app from: {}", file_path.display());
+
+        // Parse a raw value - will be used later for patching.
+        let orig_config_value: serde_yaml::Value =
+            serde_yaml::from_str(&raw_config).context("Could not parse app.yaml")?;
+
+        let pkg_name = format!(
+            "{}/{}",
+            orig_config.package.0.namespace, orig_config.package.0.name
+        );
+
+        // Check for a wasmer.toml
+
+        let local_manifest_path = abs_dir_path.join(crate::utils::DEFAULT_PACKAGE_MANIFEST_FILE);
+        let local_manifest = crate::utils::load_package_manifest(&local_manifest_path)?
+            .map(|x| x.1)
+            // Ignore local package if it is not referenced by the app.
+            .filter(|m| m.package.name == pkg_name);
+
+        let new_package_manifest = if let Some(manifest) = local_manifest {
+            let should_publish = if self.publish_package {
+                true
+            } else if interactive {
+                eprintln!();
+                dialoguer::Confirm::new()
+                    .with_prompt(format!("Publish new version of package '{}'?", pkg_name))
+                    .interact_opt()?
+                    .unwrap_or_default()
+            } else {
+                false
+            };
+
+            if should_publish {
+                eprintln!("Publishing package...");
+                let new_manifest = crate::utils::republish_package_with_bumped_version(
+                    &client,
+                    &local_manifest_path,
+                    manifest,
+                )
+                .await?;
+
+                eprint!("Waiting for package to become available...");
+                std::io::stderr().flush().unwrap();
+
+                let start_wait = std::time::Instant::now();
+                loop {
+                    if start_wait.elapsed().as_secs() > 300 {
+                        bail!("Timed out waiting for package to become available");
+                    }
+
+                    eprint!(".");
+                    std::io::stderr().flush().unwrap();
+
+                    let new_version_opt = wasmer_api::query::get_package_version(
+                        &client,
+                        new_manifest.package.name.clone(),
+                        new_manifest.package.version.to_string(),
+                    )
+                    .await;
+
+                    match new_version_opt {
+                        Ok(Some(new_version)) => {
+                            if new_version.distribution.pirita_sha256_hash.is_some() {
+                                eprintln!();
+                                break;
+                            }
+                        }
+                        Ok(None) => {
+                            bail!("Error - could not query package info: package not found");
+                        }
+                        Err(e) => {
+                            bail!("Error - could not query package info: {e}");
+                        }
+                    }
+
+                    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+                }
+
+                eprintln!(
+                    "Package '{}@{}' published successfully!",
+                    new_manifest.package.name, new_manifest.package.version
+                );
+                eprintln!();
+                Some(new_manifest)
+            } else {
+                if interactive {
+                    eprintln!();
+                }
+                None
+            }
+        } else {
+            None
+        };
+
+        let config = if let Some(manifest) = new_package_manifest {
+            let pkg = format!("{}@{}", manifest.package.name, manifest.package.version);
+            AppConfigV1 {
+                package: pkg.parse()?,
+                ..orig_config
+            }
+        } else {
+            orig_config
+        };
+
+        let wait_mode = if self.no_wait {
+            WaitMode::Deployed
+        } else {
+            WaitMode::Reachable
+        };
+
+        let opts = DeployAppOpts {
+            app: &config,
+            original_config: Some(orig_config_value.clone()),
+            allow_create: true,
+            make_default: !self.no_default,
+            owner: self.owner,
+            wait: wait_mode,
+        };
+        let (_app, app_version) = deploy_app_verbose(&client, opts).await?;
+
+        let mut new_config = super::app::app_config_from_api(&app_version)?;
+        if self.no_persist_id {
+            new_config.app_id = None;
+        }
+        let new_config_value = new_config.to_yaml_value()?;
+
+        // If the config changed, write it back.
+        if new_config_value != orig_config_value {
+            // We want to preserve unknown fields to allow for newer app.yaml
+            // settings without requring new CLI versions, so instead of just
+            // serializing the new config, we merge it with the old one.
+            let new_merged = crate::utils::merge_yaml_values(&orig_config_value, &new_config_value);
+            let new_config_raw = serde_yaml::to_string(&new_merged)?;
+            std::fs::write(&file_path, new_config_raw)
+                .with_context(|| format!("Could not write file: '{}'", file_path.display()))?;
+        }
+
+        if self.fmt.format == crate::utils::render::ItemFormat::Json {
+            println!("{}", serde_json::to_string_pretty(&app_version)?);
+        }
+
+        Ok(app_version)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/get.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/get.rs
new file mode 100644
index 0000000..81e15a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/get.rs
@@ -0,0 +1,32 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemTableFormatOpts},
+};
+
+/// Show a domain
+#[derive(clap::Parser, Debug)]
+pub struct CmdDomainGet {
+    #[clap(flatten)]
+    fmt: ItemTableFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Name of the domain.
+    name: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdDomainGet {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        if let Some(domain) = wasmer_api::query::get_domain_with_records(&client, self.name).await?
+        {
+            println!("{}", self.fmt.format.render(&domain));
+        } else {
+            anyhow::bail!("Domain not found");
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/list.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/list.rs
new file mode 100644
index 0000000..14ba9f6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/list.rs
@@ -0,0 +1,38 @@
+use wasmer_api::types::GetAllDomainsVariables;
+
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ListFormatOpts},
+};
+
+/// List domains.
+#[derive(clap::Parser, Debug)]
+pub struct CmdDomainList {
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Name of the namespace.
+    namespace: Option<String>,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdDomainList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        let domains = wasmer_api::query::get_all_domains(
+            &client,
+            GetAllDomainsVariables {
+                first: None,
+                after: None,
+                namespace: self.namespace,
+            },
+        )
+        .await?;
+        println!("{}", self.fmt.format.render(&domains));
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/mod.rs
new file mode 100644
index 0000000..ec9de5d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/mod.rs
@@ -0,0 +1,39 @@
+pub mod get;
+pub mod list;
+pub mod register;
+pub mod zonefile;
+use crate::commands::AsyncCliCommand;
+
+/// Manage DNS records
+#[derive(clap::Subcommand, Debug)]
+pub enum CmdDomain {
+    /// List domains
+    List(self::list::CmdDomainList),
+
+    /// Get a domain
+    Get(self::get::CmdDomainGet),
+
+    /// Get zone file for a domain
+    GetZoneFile(self::zonefile::CmdZoneFileGet),
+
+    /// Sync local zone file with remotex
+    SyncZoneFile(self::zonefile::CmdZoneFileSync),
+
+    /// Register new domain
+    Register(self::register::CmdDomainRegister),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdDomain {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        match self {
+            CmdDomain::List(cmd) => cmd.run_async().await,
+            CmdDomain::Get(cmd) => cmd.run_async().await,
+            CmdDomain::GetZoneFile(cmd) => cmd.run_async().await,
+            CmdDomain::SyncZoneFile(cmd) => cmd.run_async().await,
+            CmdDomain::Register(cmd) => cmd.run_async().await,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/register.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/register.rs
new file mode 100644
index 0000000..ef2d5f3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/register.rs
@@ -0,0 +1,45 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemTableFormatOpts},
+};
+
+/// Show a domain
+#[derive(clap::Parser, Debug)]
+pub struct CmdDomainRegister {
+    #[clap(flatten)]
+    fmt: ItemTableFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Name of the domain.
+    name: String,
+
+    /// owner under which the domain will live.
+    #[clap(long, short)]
+    namespace: Option<String>,
+
+    /// auto update DNS records for this domain.
+    #[clap(long, short)]
+    import_records: bool,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdDomainRegister {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        let domain = wasmer_api::query::register_domain(
+            &client,
+            self.name,
+            self.namespace,
+            Some(self.import_records),
+        )
+        .await?;
+        println!(
+            "{}: domain registered under owner `{}`",
+            domain.name, domain.owner.global_name
+        );
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/zonefile.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/zonefile.rs
new file mode 100644
index 0000000..692e4cb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/domain/zonefile.rs
@@ -0,0 +1,77 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemFormatOpts},
+};
+use anyhow::Context;
+
+#[derive(clap::Parser, Debug)]
+/// Show a zone file
+pub struct CmdZoneFileGet {
+    #[clap(flatten)]
+    fmt: ItemFormatOpts,
+
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Name of the domain.
+    domain_name: String,
+
+    /// output file name to store zone file
+    #[clap(short = 'o', long = "output", required = false)]
+    zone_file_path: Option<String>,
+}
+
+#[derive(clap::Parser, Debug)]
+/// Show a zone file
+pub struct CmdZoneFileSync {
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// filename of  zone-file to sync
+    zone_file_path: String,
+
+    /// Do not delete records that are not present in the zone file
+    #[clap(short = 'n', long = "no-delete-missing-records")]
+    no_delete_missing_records: bool,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdZoneFileGet {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+        if let Some(domain) =
+            wasmer_api::query::get_domain_zone_file(&client, self.domain_name).await?
+        {
+            let zone_file_contents = domain.zone_file;
+            if let Some(zone_file_path) = self.zone_file_path {
+                std::fs::write(zone_file_path, zone_file_contents)
+                    .context("Unable to write file")?;
+            } else {
+                println!("{}", zone_file_contents);
+            }
+        } else {
+            anyhow::bail!("Domain not found");
+        }
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdZoneFileSync {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let data = std::fs::read(&self.zone_file_path).context("Unable to read file")?;
+        let zone_file_contents = String::from_utf8(data).context("Not a valid UTF-8 sequence")?;
+        let domain = wasmer_api::query::upsert_domain_from_zone_file(
+            &self.api.client()?,
+            zone_file_contents,
+            !self.no_delete_missing_records,
+        )
+        .await?;
+        println!("Successfully synced domain: {}", domain.name);
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/gen_c_header.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/gen_c_header.rs
new file mode 100644
index 0000000..142c41a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/gen_c_header.rs
@@ -0,0 +1,143 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Error};
+use bytes::Bytes;
+use clap::Parser;
+use wasmer_compiler::Artifact;
+use wasmer_types::{
+    compilation::symbols::ModuleMetadataSymbolRegistry, CpuFeature, MetadataHeader, Triple,
+};
+use webc::{compat::SharedBytes, Container, DetectError};
+
+use crate::store::CompilerOptions;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer gen-c-header` subcommand
+pub struct GenCHeader {
+    /// Input file
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    /// Prefix hash (default: SHA256 of input .wasm file)
+    #[clap(long)]
+    prefix: Option<String>,
+
+    /// For pirita files: optional atom name to compile
+    #[clap(long)]
+    atom: Option<String>,
+
+    /// Output file
+    #[clap(name = "OUTPUT PATH", short = 'o')]
+    output: PathBuf,
+
+    /// Compilation Target triple
+    ///
+    /// Accepted target triple values must follow the
+    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    ///
+    /// The recommended targets we try to support are:
+    ///
+    /// - "x86_64-linux-gnu"
+    /// - "aarch64-linux-gnu"
+    /// - "x86_64-apple-darwin"
+    /// - "arm64-apple-darwin"
+    /// - "x86_64-windows-gnu"
+    #[clap(long = "target")]
+    target_triple: Option<Triple>,
+
+    #[clap(long, short = 'm', number_of_values = 1)]
+    cpu_features: Vec<CpuFeature>,
+}
+
+impl GenCHeader {
+    /// Runs logic for the `gen-c-header` subcommand
+    pub fn execute(&self) -> Result<(), Error> {
+        let file: Bytes = std::fs::read(&self.path)
+            .with_context(|| format!("Unable to read \"{}\"", self.path.display()))?
+            .into();
+        let prefix = match self.prefix.as_deref() {
+            Some(s) => s.to_string(),
+            None => crate::commands::PrefixMapCompilation::hash_for_bytes(&file),
+        };
+
+        let atom = match Container::from_bytes(file.clone()) {
+            Ok(webc) => self.get_atom(&webc)?,
+            Err(webc::compat::ContainerError::Detect(DetectError::InvalidMagic { .. })) => {
+                // we've probably got a WebAssembly file
+                file.into()
+            }
+            Err(other) => {
+                return Err(Error::new(other).context("Unable to parse the webc file"));
+            }
+        };
+
+        let target_triple = self.target_triple.clone().unwrap_or_else(Triple::host);
+        let target = crate::commands::create_exe::utils::target_triple_to_target(
+            &target_triple,
+            &self.cpu_features,
+        );
+        let (engine, _) = CompilerOptions::default().get_engine_for_target(target.clone())?;
+        let engine_inner = engine.inner();
+        let compiler = engine_inner.compiler()?;
+        let features = engine_inner.features();
+        let tunables = engine.tunables();
+        let (metadata, _, _) = Artifact::metadata(
+            compiler,
+            &atom,
+            Some(prefix.as_str()),
+            &target,
+            tunables,
+            features,
+        )
+        .map_err(|e| anyhow::anyhow!("could not generate metadata: {e}"))?;
+
+        let serialized_data = metadata
+            .serialize()
+            .map_err(|e| anyhow::anyhow!("failed to serialize: {e}"))?;
+        let mut metadata_binary = vec![];
+        metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
+        metadata_binary.extend(serialized_data);
+        let metadata_length = metadata_binary.len();
+
+        let header_file_src = crate::c_gen::staticlib_header::generate_header_file(
+            &prefix,
+            &metadata.compile_info.module,
+            &ModuleMetadataSymbolRegistry {
+                prefix: prefix.clone(),
+            },
+            metadata_length,
+        );
+
+        let output = crate::common::normalize_path(&self.output.display().to_string());
+
+        std::fs::write(&output, header_file_src)
+            .map_err(|e| anyhow::anyhow!("{e}"))
+            .with_context(|| anyhow::anyhow!("{output}"))?;
+
+        Ok(())
+    }
+
+    fn get_atom(&self, pirita: &Container) -> Result<SharedBytes, Error> {
+        let atoms = pirita.atoms();
+        let atom_names: Vec<_> = atoms.keys().map(|s| s.as_str()).collect();
+
+        match *atom_names.as_slice() {
+            [] => Err(Error::msg("The file doesn't contain any atoms")),
+            [name] => Ok(atoms[name].clone()),
+            [..] => match &self.atom {
+                Some(name) => atoms
+                    .get(name)
+                    .cloned()
+                    .with_context(|| format!("The file doesn't contain a \"{name}\" atom"))
+                    .with_context(|| {
+                        format!("-> note: available atoms are: {}", atom_names.join(", "))
+                    }),
+                None => {
+                    let err = Error::msg("file has multiple atoms, please specify which atom to generate the header file for")
+                            .context(format!("-> note: available atoms are: {}", atom_names.join(", ")));
+                    Err(err)
+                }
+            },
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/init.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/init.rs
new file mode 100644
index 0000000..b81babc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/init.rs
@@ -0,0 +1,555 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use anyhow::Context;
+use cargo_metadata::{CargoOpt, MetadataCommand};
+use clap::Parser;
+use semver::VersionReq;
+use wasmer_registry::wasmer_env::WasmerEnv;
+
+static NOTE: &str = "# See more keys and definitions at https://docs.wasmer.io/registry/manifest";
+
+const NEWLINE: &str = if cfg!(windows) { "\r\n" } else { "\n" };
+
+/// CLI args for the `wasmer init` command
+#[derive(Debug, Parser)]
+pub struct Init {
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    /// Initialize wasmer.toml for a library package
+    #[clap(long, group = "crate-type")]
+    pub lib: bool,
+    /// Initialize wasmer.toml for a binary package
+    #[clap(long, group = "crate-type")]
+    pub bin: bool,
+    /// Initialize an empty wasmer.toml
+    #[clap(long, group = "crate-type")]
+    pub empty: bool,
+    /// Force overwriting the wasmer.toml, even if it already exists
+    #[clap(long)]
+    pub overwrite: bool,
+    /// Don't display debug output
+    #[clap(long)]
+    pub quiet: bool,
+    /// Namespace to init with, default = current logged in user or _
+    #[clap(long)]
+    pub namespace: Option<String>,
+    /// Package name to init with, default = Cargo.toml name or current directory name
+    #[clap(long)]
+    pub package_name: Option<String>,
+    /// Version of the initialized package
+    #[clap(long)]
+    pub version: Option<semver::Version>,
+    /// If the `manifest-path` is a Cargo.toml, use that file to initialize the wasmer.toml
+    #[clap(long)]
+    pub manifest_path: Option<PathBuf>,
+    /// Add default dependencies for common packages
+    #[clap(long, value_enum)]
+    pub template: Option<Template>,
+    /// Include file paths into the target container filesystem
+    #[clap(long)]
+    pub include: Vec<String>,
+    /// Directory of the output file name. wasmer init will error if the target dir
+    /// already contains a wasmer.toml. Also sets the package name.
+    #[clap(name = "PACKAGE_PATH")]
+    pub out: Option<PathBuf>,
+}
+
+/// What template to use for the initialized wasmer.toml
+#[derive(Debug, PartialEq, Eq, Copy, Clone, clap::ValueEnum)]
+pub enum Template {
+    /// Add dependency on Python
+    Python,
+    /// Add dependency on JS
+    Js,
+}
+
+#[derive(Debug, PartialEq, Copy, Clone)]
+enum BinOrLib {
+    Bin,
+    Lib,
+    Empty,
+}
+
+// minimal version of the Cargo.toml [package] section
+#[derive(Debug, Clone)]
+struct MiniCargoTomlPackage {
+    cargo_toml_path: PathBuf,
+    name: String,
+    version: semver::Version,
+    description: Option<String>,
+    homepage: Option<String>,
+    repository: Option<String>,
+    license: Option<String>,
+    readme: Option<PathBuf>,
+    license_file: Option<PathBuf>,
+    #[allow(dead_code)]
+    workspace_root: PathBuf,
+    #[allow(dead_code)]
+    build_dir: PathBuf,
+}
+
+static WASMER_TOML_NAME: &str = "wasmer.toml";
+
+impl Init {
+    /// `wasmer init` execution
+    pub fn execute(&self) -> Result<(), anyhow::Error> {
+        let bin_or_lib = self.get_bin_or_lib()?;
+
+        // See if the directory has a Cargo.toml file, if yes, copy the license / readme, etc.
+        let manifest_path = match self.manifest_path.as_ref() {
+            Some(s) => s.clone(),
+            None => {
+                let cargo_toml_path = self
+                    .out
+                    .clone()
+                    .unwrap_or_else(|| std::env::current_dir().unwrap())
+                    .join("Cargo.toml");
+                cargo_toml_path
+                    .canonicalize()
+                    .unwrap_or_else(|_| cargo_toml_path.clone())
+            }
+        };
+
+        let cargo_toml = if manifest_path.exists() {
+            parse_cargo_toml(&manifest_path).ok()
+        } else {
+            None
+        };
+
+        let (fallback_package_name, target_file) = self.target_file()?;
+
+        if target_file.exists() && !self.overwrite {
+            anyhow::bail!(
+                "wasmer project already initialized in {}",
+                target_file.display(),
+            );
+        }
+
+        let constructed_manifest = construct_manifest(
+            cargo_toml.as_ref(),
+            &fallback_package_name,
+            self.package_name.as_deref(),
+            &target_file,
+            &manifest_path,
+            bin_or_lib,
+            self.namespace.clone(),
+            self.version.clone(),
+            self.template.as_ref(),
+            self.include.as_slice(),
+            self.quiet,
+            self.env.dir(),
+        )?;
+
+        if let Some(parent) = target_file.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+
+        // generate the wasmer.toml and exit
+        Self::write_wasmer_toml(&target_file, &constructed_manifest)
+    }
+
+    /// Writes the metadata to a wasmer.toml file, making sure we include the
+    /// [`NOTE`] so people get a link to the registry docs.
+    fn write_wasmer_toml(
+        path: &PathBuf,
+        toml: &wasmer_toml::Manifest,
+    ) -> Result<(), anyhow::Error> {
+        let toml_string = toml::to_string_pretty(&toml)?;
+
+        let mut resulting_string = String::new();
+        let mut note_inserted = false;
+
+        for line in toml_string.lines() {
+            resulting_string.push_str(line);
+
+            if !note_inserted && line.is_empty() {
+                // We've found an empty line after the initial [package]
+                // section. Let's add our note here.
+                resulting_string.push_str(NEWLINE);
+                resulting_string.push_str(NOTE);
+                resulting_string.push_str(NEWLINE);
+                note_inserted = true;
+            }
+            resulting_string.push_str(NEWLINE);
+        }
+
+        if !note_inserted {
+            // Make sure the note still ends up at the end of the file.
+            resulting_string.push_str(NEWLINE);
+            resulting_string.push_str(NOTE);
+            resulting_string.push_str(NEWLINE);
+            resulting_string.push_str(NEWLINE);
+        }
+
+        std::fs::write(path, resulting_string)
+            .with_context(|| format!("Unable to write to \"{}\"", path.display()))?;
+
+        Ok(())
+    }
+
+    fn target_file(&self) -> Result<(String, PathBuf), anyhow::Error> {
+        match self.out.as_ref() {
+            None => {
+                let current_dir = std::env::current_dir()?;
+                let package_name = self
+                    .package_name
+                    .clone()
+                    .or_else(|| {
+                        current_dir
+                            .canonicalize()
+                            .ok()?
+                            .file_stem()
+                            .and_then(|s| s.to_str())
+                            .map(|s| s.to_string())
+                    })
+                    .ok_or_else(|| anyhow::anyhow!("no current dir name"))?;
+                Ok((package_name, current_dir.join(WASMER_TOML_NAME)))
+            }
+            Some(s) => {
+                std::fs::create_dir_all(s)
+                    .map_err(|e| anyhow::anyhow!("{e}"))
+                    .with_context(|| anyhow::anyhow!("{}", s.display()))?;
+                let package_name = self
+                    .package_name
+                    .clone()
+                    .or_else(|| {
+                        s.canonicalize()
+                            .ok()?
+                            .file_stem()
+                            .and_then(|s| s.to_str())
+                            .map(|s| s.to_string())
+                    })
+                    .ok_or_else(|| anyhow::anyhow!("no dir name"))?;
+                Ok((package_name, s.join(WASMER_TOML_NAME)))
+            }
+        }
+    }
+
+    fn get_filesystem_mapping(include: &[String]) -> impl Iterator<Item = (String, PathBuf)> + '_ {
+        include.iter().map(|path| {
+            if path == "." || path == "/" {
+                return ("/".to_string(), Path::new("/").to_path_buf());
+            }
+
+            let key = format!("./{path}");
+            let value = PathBuf::from(format!("/{path}"));
+
+            (key, value)
+        })
+    }
+
+    fn get_command(
+        modules: &[wasmer_toml::Module],
+        bin_or_lib: BinOrLib,
+    ) -> Vec<wasmer_toml::Command> {
+        match bin_or_lib {
+            BinOrLib::Bin => modules
+                .iter()
+                .map(|m| {
+                    wasmer_toml::Command::V2(wasmer_toml::CommandV2 {
+                        name: m.name.clone(),
+                        module: wasmer_toml::ModuleReference::CurrentPackage {
+                            module: m.name.clone(),
+                        },
+                        runner: "wasi".to_string(),
+                        annotations: None,
+                    })
+                })
+                .collect(),
+            BinOrLib::Lib | BinOrLib::Empty => Vec::new(),
+        }
+    }
+
+    /// Returns the dependencies based on the `--template` flag
+    fn get_dependencies(template: Option<&Template>) -> HashMap<String, VersionReq> {
+        let mut map = HashMap::default();
+
+        match template {
+            Some(Template::Js) => {
+                map.insert("quickjs/quickjs".to_string(), VersionReq::STAR);
+            }
+            Some(Template::Python) => {
+                map.insert("python/python".to_string(), VersionReq::STAR);
+            }
+            _ => {}
+        }
+
+        map
+    }
+
+    // Returns whether the template for the wasmer.toml should be a binary, a library or an empty file
+    fn get_bin_or_lib(&self) -> Result<BinOrLib, anyhow::Error> {
+        match (self.empty, self.bin, self.lib) {
+            (true, false, false) => Ok(BinOrLib::Empty),
+            (false, true, false) => Ok(BinOrLib::Bin),
+            (false, false, true) => Ok(BinOrLib::Lib),
+            (false, false, false) => Ok(BinOrLib::Bin),
+            _ => anyhow::bail!("Only one of --bin, --lib, or --empty can be provided"),
+        }
+    }
+
+    /// Get bindings returns the first .wai / .wit file found and
+    /// optionally takes a warning callback that is triggered when > 1 .wai files are found
+    fn get_bindings(target_file: &Path, bin_or_lib: BinOrLib) -> Option<GetBindingsResult> {
+        match bin_or_lib {
+            BinOrLib::Bin | BinOrLib::Empty => None,
+            BinOrLib::Lib => target_file.parent().and_then(|parent| {
+                let all_bindings = walkdir::WalkDir::new(parent)
+                    .min_depth(1)
+                    .max_depth(3)
+                    .follow_links(false)
+                    .into_iter()
+                    .filter_map(|e| e.ok())
+                    .filter_map(|e| {
+                        let is_wit = e.path().extension().and_then(|s| s.to_str()) == Some(".wit");
+                        let is_wai = e.path().extension().and_then(|s| s.to_str()) == Some(".wai");
+                        if is_wit {
+                            Some(wasmer_toml::Bindings::Wit(wasmer_toml::WitBindings {
+                                wit_exports: e.path().to_path_buf(),
+                                wit_bindgen: semver::Version::parse("0.1.0").unwrap(),
+                            }))
+                        } else if is_wai {
+                            Some(wasmer_toml::Bindings::Wai(wasmer_toml::WaiBindings {
+                                exports: None,
+                                imports: vec![e.path().to_path_buf()],
+                                wai_version: semver::Version::parse("0.2.0").unwrap(),
+                            }))
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<Vec<_>>();
+
+                if all_bindings.is_empty() {
+                    None
+                } else if all_bindings.len() == 1 {
+                    Some(GetBindingsResult::OneBinding(all_bindings[0].clone()))
+                } else {
+                    Some(GetBindingsResult::MultiBindings(all_bindings))
+                }
+            }),
+        }
+    }
+}
+
+enum GetBindingsResult {
+    OneBinding(wasmer_toml::Bindings),
+    MultiBindings(Vec<wasmer_toml::Bindings>),
+}
+
+impl GetBindingsResult {
+    fn first_binding(&self) -> Option<wasmer_toml::Bindings> {
+        match self {
+            Self::OneBinding(s) => Some(s.clone()),
+            Self::MultiBindings(s) => s.get(0).cloned(),
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn construct_manifest(
+    cargo_toml: Option<&MiniCargoTomlPackage>,
+    fallback_package_name: &String,
+    package_name: Option<&str>,
+    target_file: &Path,
+    manifest_path: &Path,
+    bin_or_lib: BinOrLib,
+    namespace: Option<String>,
+    version: Option<semver::Version>,
+    template: Option<&Template>,
+    include_fs: &[String],
+    quiet: bool,
+    wasmer_dir: &Path,
+) -> Result<wasmer_toml::Manifest, anyhow::Error> {
+    if let Some(ct) = cargo_toml.as_ref() {
+        let msg = format!(
+            "NOTE: Initializing wasmer.toml file with metadata from Cargo.toml{NEWLINE}  -> {}",
+            ct.cargo_toml_path.display()
+        );
+        if !quiet {
+            println!("{msg}");
+        }
+        log::warn!("{msg}");
+    }
+
+    let package_name = package_name.unwrap_or_else(|| {
+        cargo_toml
+            .as_ref()
+            .map(|p| &p.name)
+            .unwrap_or(fallback_package_name)
+    });
+    let namespace = namespace.or_else(|| {
+        wasmer_registry::whoami(wasmer_dir, None, None)
+            .ok()
+            .map(|o| o.1)
+    });
+    let version = version.unwrap_or_else(|| {
+        cargo_toml
+            .as_ref()
+            .map(|t| t.version.clone())
+            .unwrap_or_else(|| semver::Version::parse("0.1.0").unwrap())
+    });
+    let license = cargo_toml.as_ref().and_then(|t| t.license.clone());
+    let license_file = cargo_toml.as_ref().and_then(|t| t.license_file.clone());
+    let readme = cargo_toml.as_ref().and_then(|t| t.readme.clone());
+    let repository = cargo_toml.as_ref().and_then(|t| t.repository.clone());
+    let homepage = cargo_toml.as_ref().and_then(|t| t.homepage.clone());
+    let description = cargo_toml
+        .as_ref()
+        .and_then(|t| t.description.clone())
+        .unwrap_or_else(|| format!("Description for package {package_name}"));
+
+    let default_abi = wasmer_toml::Abi::Wasi;
+    let bindings = Init::get_bindings(target_file, bin_or_lib);
+
+    if let Some(GetBindingsResult::MultiBindings(m)) = bindings.as_ref() {
+        let found = m
+            .iter()
+            .map(|m| match m {
+                wasmer_toml::Bindings::Wit(wb) => {
+                    format!("found: {}", serde_json::to_string(wb).unwrap_or_default())
+                }
+                wasmer_toml::Bindings::Wai(wb) => {
+                    format!("found: {}", serde_json::to_string(wb).unwrap_or_default())
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("\r\n");
+
+        let msg = vec![
+            String::new(),
+            "    It looks like your project contains multiple *.wai files.".to_string(),
+            "    Make sure you update the [[module.bindings]] appropriately".to_string(),
+            String::new(),
+            found,
+        ];
+        let msg = msg.join("\r\n");
+        if !quiet {
+            println!("{msg}");
+        }
+        log::warn!("{msg}");
+    }
+
+    let module_source = cargo_toml
+        .as_ref()
+        .map(|p| {
+            // Normalize the path to /target/release to be relative to the parent of the Cargo.toml
+            let outpath = p
+                .build_dir
+                .join("release")
+                .join(format!("{package_name}.wasm"));
+            let canonicalized_outpath = outpath.canonicalize().unwrap_or(outpath);
+            let outpath_str =
+                crate::common::normalize_path(&canonicalized_outpath.display().to_string());
+            let manifest_canonicalized = crate::common::normalize_path(
+                &manifest_path
+                    .parent()
+                    .and_then(|p| p.canonicalize().ok())
+                    .unwrap_or_else(|| manifest_path.to_path_buf())
+                    .display()
+                    .to_string(),
+            );
+            let diff = outpath_str
+                .strip_prefix(&manifest_canonicalized)
+                .unwrap_or(&outpath_str)
+                .replace('\\', "/");
+            // Format in UNIX fashion (forward slashes)
+            let relative_str = diff.strip_prefix('/').unwrap_or(&diff);
+            Path::new(&relative_str).to_path_buf()
+        })
+        .unwrap_or_else(|| Path::new(&format!("{package_name}.wasm")).to_path_buf());
+
+    let modules = vec![wasmer_toml::Module {
+        name: package_name.to_string(),
+        source: module_source,
+        kind: None,
+        abi: default_abi,
+        bindings: bindings.as_ref().and_then(|b| b.first_binding()),
+        interfaces: Some({
+            let mut map = HashMap::new();
+            map.insert("wasi".to_string(), "0.1.0-unstable".to_string());
+            map
+        }),
+    }];
+
+    let mut pkg = wasmer_toml::Package::builder(
+        if let Some(s) = namespace {
+            format!("{s}/{package_name}")
+        } else {
+            package_name.to_string()
+        },
+        version,
+        description,
+    );
+
+    if let Some(license) = license {
+        pkg.license(license);
+    }
+    if let Some(license_file) = license_file {
+        pkg.license_file(license_file);
+    }
+    if let Some(readme) = readme {
+        pkg.readme(readme);
+    }
+    if let Some(repository) = repository {
+        pkg.repository(repository);
+    }
+    if let Some(homepage) = homepage {
+        pkg.homepage(homepage);
+    }
+    let pkg = pkg.build()?;
+
+    let mut manifest = wasmer_toml::Manifest::builder(pkg);
+    manifest
+        .dependencies(Init::get_dependencies(template))
+        .commands(Init::get_command(&modules, bin_or_lib))
+        .fs(Init::get_filesystem_mapping(include_fs).collect());
+    match bin_or_lib {
+        BinOrLib::Bin | BinOrLib::Lib => {
+            manifest.modules(modules);
+        }
+        BinOrLib::Empty => {}
+    }
+    let manifest = manifest.build()?;
+
+    Ok(manifest)
+}
+fn parse_cargo_toml(manifest_path: &PathBuf) -> Result<MiniCargoTomlPackage, anyhow::Error> {
+    let mut metadata = MetadataCommand::new();
+    metadata.manifest_path(manifest_path);
+    metadata.no_deps();
+    metadata.features(CargoOpt::AllFeatures);
+
+    let metadata = metadata.exec().with_context(|| {
+        format!(
+            "Unable to load metadata from \"{}\"",
+            manifest_path.display()
+        )
+    })?;
+
+    let package = metadata
+        .root_package()
+        .ok_or_else(|| anyhow::anyhow!("no root package found in cargo metadata"))
+        .context(anyhow::anyhow!("{}", manifest_path.display()))?;
+
+    Ok(MiniCargoTomlPackage {
+        cargo_toml_path: manifest_path.clone(),
+        name: package.name.clone(),
+        version: package.version.clone(),
+        description: package.description.clone(),
+        homepage: package.homepage.clone(),
+        repository: package.repository.clone(),
+        license: package.license.clone(),
+        readme: package.readme.clone().map(|s| s.into_std_path_buf()),
+        license_file: package.license_file.clone().map(|f| f.into_std_path_buf()),
+        workspace_root: metadata.workspace_root.into_std_path_buf(),
+        build_dir: metadata
+            .target_directory
+            .into_std_path_buf()
+            .join("wasm32-wasi"),
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/inspect.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/inspect.rs
new file mode 100644
index 0000000..1f5c404
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/inspect.rs
@@ -0,0 +1,72 @@
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use bytesize::ByteSize;
+use clap::Parser;
+use wasmer::*;
+
+use crate::store::StoreOptions;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer validate` subcommand
+pub struct Inspect {
+    /// File to validate as WebAssembly
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+}
+
+impl Inspect {
+    /// Runs logic for the `validate` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to inspect `{}`", self.path.display()))
+    }
+
+    fn inner_execute(&self) -> Result<()> {
+        let (store, _compiler_type) = self.store.get_store()?;
+        let module_contents = std::fs::read(&self.path)?;
+        let iswasm = is_wasm(&module_contents);
+        let module_len = module_contents.len();
+        let module = Module::new(&store, module_contents)?;
+        println!("Type: {}", if !iswasm { "wat" } else { "wasm" });
+        println!("Size: {}", ByteSize(module_len as _));
+        println!("Imports:");
+        println!("  Functions:");
+        for f in module.imports().functions() {
+            println!("    \"{}\".\"{}\": {}", f.module(), f.name(), f.ty());
+        }
+        println!("  Memories:");
+        for f in module.imports().memories() {
+            println!("    \"{}\".\"{}\": {}", f.module(), f.name(), f.ty());
+        }
+        println!("  Tables:");
+        for f in module.imports().tables() {
+            println!("    \"{}\".\"{}\": {}", f.module(), f.name(), f.ty());
+        }
+        println!("  Globals:");
+        for f in module.imports().globals() {
+            println!("    \"{}\".\"{}\": {}", f.module(), f.name(), f.ty());
+        }
+        println!("Exports:");
+        println!("  Functions:");
+        for f in module.exports().functions() {
+            println!("    \"{}\": {}", f.name(), f.ty());
+        }
+        println!("  Memories:");
+        for f in module.exports().memories() {
+            println!("    \"{}\": {}", f.name(), f.ty());
+        }
+        println!("  Tables:");
+        for f in module.exports().tables() {
+            println!("    \"{}\": {}", f.name(), f.ty());
+        }
+        println!("  Globals:");
+        for f in module.exports().globals() {
+            println!("    \"{}\": {}", f.name(), f.ty());
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/compact.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/compact.rs
new file mode 100644
index 0000000..981d971
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/compact.rs
@@ -0,0 +1,31 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use wasmer_wasix::journal::{
+    copy_journal, CompactingLogFileJournal, LogFileJournal, PrintingJournal,
+};
+
+use crate::commands::CliCommand;
+
+/// Compacts a journal by removing duplicate or redundant
+/// events and rewriting the log
+#[derive(Debug, Parser)]
+pub struct CmdJournalCompact {
+    /// Path to the journal that will be compacted
+    #[clap(index = 1)]
+    journal_path: PathBuf,
+}
+
+impl CliCommand for CmdJournalCompact {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        let compactor = CompactingLogFileJournal::new(&self.journal_path)?.with_compact_on_drop();
+        drop(compactor);
+
+        let journal = LogFileJournal::new(&self.journal_path)?;
+        let printer = PrintingJournal::default();
+        copy_journal(&journal, &printer)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/export.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/export.rs
new file mode 100644
index 0000000..7d94c7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/export.rs
@@ -0,0 +1,25 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use wasmer_wasix::journal::{copy_journal, JournalPrintingMode, LogFileJournal, PrintingJournal};
+
+use crate::commands::CliCommand;
+
+/// Exports all the events in a journal to STDOUT as JSON data
+#[derive(Debug, Parser)]
+pub struct CmdJournalExport {
+    /// Path to the journal that will be printed
+    #[clap(index = 1)]
+    journal_path: PathBuf,
+}
+
+impl CliCommand for CmdJournalExport {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        let journal = LogFileJournal::new(self.journal_path)?;
+        let printer = PrintingJournal::new(JournalPrintingMode::Json);
+        copy_journal(&journal, &printer)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/filter.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/filter.rs
new file mode 100644
index 0000000..4052067
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/filter.rs
@@ -0,0 +1,114 @@
+use std::{path::PathBuf, str::FromStr};
+
+use clap::Parser;
+use wasmer_wasix::journal::{
+    copy_journal, FilteredJournalBuilder, LogFileJournal, PrintingJournal,
+};
+
+use crate::commands::CliCommand;
+
+/// Flags that specify what should be filtered out
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum FilterOut {
+    /// Filters out all the memory events
+    Memory,
+    /// Filters out all the thread stacks
+    Threads,
+    /// Filters out all the file system operations
+    FileSystem,
+    /// Filters out all core syscalls
+    Core,
+    /// Filters out the snapshots
+    Snapshots,
+    /// Filters out the networking
+    Networking,
+}
+
+impl FromStr for FilterOut {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "mem" | "memory" => Self::Memory,
+            "thread" | "threads" => Self::Threads,
+            "fs" | "file" | "filesystem" | "file-system" => Self::FileSystem,
+            "core" => Self::Core,
+            "snap" | "snapshot" | "snapshots" => Self::Snapshots,
+            "net" | "network" | "networking" => Self::Networking,
+            t => return Err(format!("unknown filter type - {}", t)),
+        })
+    }
+}
+
+/// Rewrites a journal log removing events that match the
+/// filter parameters.
+#[derive(Debug, Parser)]
+pub struct CmdJournalFilter {
+    /// Path to the journal that will be read
+    #[clap(index = 1)]
+    source_path: PathBuf,
+    /// Path to the journal that will be the output of the filter
+    #[clap(index = 2)]
+    target_path: PathBuf,
+    /// Filters to be applied to the output journal, filter options are
+    /// - 'mem' | 'memory' -> removes all WASM memory related events
+    /// - 'thread' | 'threads' -> removes all events related to the state of the threads
+    /// - 'fs' | 'file' -> removes file system mutation events
+    /// - 'core' -> removes core operating system operations such as TTY
+    /// - 'snap' | 'snapshot' -> removes the snapshots from the journal
+    /// - 'net' | 'network' -> removes network socket and interface events
+    #[clap(short, long = "filter")]
+    filters: Vec<FilterOut>,
+}
+
+impl CliCommand for CmdJournalFilter {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        // Create a new file name that will be the temp new file
+        // while its written
+        let mut temp_filename = self
+            .target_path
+            .file_name()
+            .ok_or_else(|| {
+                anyhow::format_err!(
+                    "The path is not a valid filename - {}",
+                    self.target_path.to_string_lossy()
+                )
+            })?
+            .to_string_lossy()
+            .to_string();
+        temp_filename.insert_str(0, ".staging.");
+        let temp_path = self.target_path.with_file_name(&temp_filename);
+        std::fs::remove_file(&temp_path).ok();
+
+        // Load the source journal and the target journal (in the temp location)
+        let source = LogFileJournal::new(self.source_path)?;
+        let target = LogFileJournal::new(temp_path.clone())?;
+
+        // Put a filter on the farget
+        let mut builder = FilteredJournalBuilder::new();
+        for filter in self.filters {
+            builder = match filter {
+                FilterOut::Memory => builder.with_ignore_memory(true),
+                FilterOut::Threads => builder.with_ignore_threads(true),
+                FilterOut::FileSystem => builder.with_ignore_fs(true),
+                FilterOut::Core => builder.with_ignore_core(true),
+                FilterOut::Snapshots => builder.with_ignore_snapshots(true),
+                FilterOut::Networking => builder.with_ignore_networking(true),
+            }
+        }
+        let target = builder.build(target);
+
+        // Copy the journal over and rename the temp file to the target file
+        copy_journal(&source, &target)?;
+        drop(target);
+        std::fs::rename(temp_path, self.target_path.clone())?;
+
+        // Now print the outcome
+        let journal = LogFileJournal::new(&self.target_path)?;
+        let printer = PrintingJournal::default();
+        copy_journal(&journal, &printer)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/import.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/import.rs
new file mode 100644
index 0000000..00bf0e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/import.rs
@@ -0,0 +1,54 @@
+use std::{io::ErrorKind, path::PathBuf};
+
+use clap::Parser;
+use wasmer_wasix::journal::{JournalEntry, LogFileJournal, WritableJournal};
+
+use crate::commands::CliCommand;
+
+/// Imports events into a journal file. Events are streamed as JSON
+/// objects into `stdin`
+#[derive(Debug, Parser)]
+pub struct CmdJournalImport {
+    /// Path to the journal that will be printed
+    #[clap(index = 1)]
+    journal_path: PathBuf,
+}
+
+impl CliCommand for CmdJournalImport {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        // Erase the journal file at the path and reopen it
+        if self.journal_path.exists() {
+            std::fs::remove_file(&self.journal_path)?;
+        }
+        let journal = LogFileJournal::new(self.journal_path)?;
+
+        // Read all the events from `stdin`, deserialize them and save them to the journal
+        let stdin = std::io::stdin();
+        let mut lines = String::new();
+        let mut line = String::new();
+        loop {
+            // Read until the end marker
+            loop {
+                line.clear();
+                match stdin.read_line(&mut line) {
+                    Ok(0) => return Ok(()),
+                    Ok(_) => {
+                        lines.push_str(&line);
+                        if line.trim_end() == "}" {
+                            break;
+                        }
+                    }
+                    Err(err) if err.kind() == ErrorKind::UnexpectedEof => return Ok(()),
+                    Err(err) => return Err(err.into()),
+                }
+            }
+
+            let record = serde_json::from_str::<JournalEntry<'static>>(&lines)?;
+            println!("{}", record);
+            journal.write(record)?;
+            lines.clear();
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/inspect.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/inspect.rs
new file mode 100644
index 0000000..9779e1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/inspect.rs
@@ -0,0 +1,25 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use wasmer_wasix::journal::{copy_journal, LogFileJournal, PrintingJournal};
+
+use crate::commands::CliCommand;
+
+/// Prints a summarized version of contents of a journal to stdout
+#[derive(Debug, Parser)]
+pub struct CmdJournalInspect {
+    /// Path to the journal that will be printed
+    #[clap(index = 1)]
+    journal_path: PathBuf,
+}
+
+impl CliCommand for CmdJournalInspect {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        let journal = LogFileJournal::new(self.journal_path)?;
+        let printer = PrintingJournal::default();
+        copy_journal(&journal, &printer)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mod.rs
new file mode 100644
index 0000000..4e65071
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mod.rs
@@ -0,0 +1,51 @@
+use crate::commands::CliCommand;
+
+mod compact;
+mod export;
+mod filter;
+mod import;
+mod inspect;
+#[cfg(feature = "fuse")]
+mod mount;
+
+pub use compact::*;
+pub use export::*;
+pub use filter::*;
+pub use import::*;
+pub use inspect::*;
+#[cfg(feature = "fuse")]
+pub use mount::*;
+
+/// Manage Journal files.
+#[derive(clap::Subcommand, Debug)]
+pub enum CmdJournal {
+    /// Compacts a journal into a smaller size by removed redundant or duplicate events
+    Compact(CmdJournalCompact),
+    /// Exports the contents of a journal to stdout as JSON objects
+    Export(CmdJournalExport),
+    /// Imports the events into a journal as JSON objects
+    Import(CmdJournalImport),
+    /// Inspects the contents of a journal and summarizes it to `stdout`
+    Inspect(CmdJournalInspect),
+    /// Filters out certain events from a journal
+    Filter(CmdJournalFilter),
+    /// Mounts the journal at a particular directory
+    #[cfg(feature = "fuse")]
+    Mount(CmdJournalMount),
+}
+
+impl CliCommand for CmdJournal {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        match self {
+            Self::Compact(cmd) => cmd.run(),
+            Self::Import(cmd) => cmd.run(),
+            Self::Export(cmd) => cmd.run(),
+            Self::Inspect(cmd) => cmd.run(),
+            Self::Filter(cmd) => cmd.run(),
+            #[cfg(feature = "fuse")]
+            Self::Mount(cmd) => cmd.run(),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/cmd.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/cmd.rs
new file mode 100644
index 0000000..66d03f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/cmd.rs
@@ -0,0 +1,42 @@
+use std::{path::PathBuf, process::Stdio};
+
+use clap::Parser;
+use wasmer_wasix::fs::WasiFdSeed;
+
+use super::fs::JournalFileSystemBuilder;
+use crate::commands::CliCommand;
+
+/// Mounts a journal as a file system on the local machine
+#[derive(Debug, Parser)]
+pub struct CmdJournalMount {
+    /// Path to the journal that will be printed
+    #[clap(index = 1)]
+    journal_path: PathBuf,
+    /// Path to the directory where the file system will be mounted
+    #[clap(index = 2)]
+    mount_path: PathBuf,
+}
+
+impl CliCommand for CmdJournalMount {
+    type Output = ();
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        // First we unmount any existing file system on this path
+        std::process::Command::new("/bin/umount")
+            .arg(self.mount_path.to_string_lossy().as_ref())
+            .stderr(Stdio::null())
+            .stdout(Stdio::null())
+            .spawn()?
+            .wait()
+            .ok();
+
+        let fs = JournalFileSystemBuilder::new(&self.journal_path)
+            .with_fd_seed(WasiFdSeed::default())
+            .with_progress_bar(false)
+            .build()?;
+
+        // Mounts the journal file system at a path
+        fuse::mount(fs, &self.mount_path, &[])?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/fs.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/fs.rs
new file mode 100644
index 0000000..f5baaf8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/fs.rs
@@ -0,0 +1,1214 @@
+#![allow(unused)]
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    ffi::OsStr,
+    fs::File,
+    hash::{Hash, Hasher},
+    io,
+    path::{Path, PathBuf},
+    sync::{atomic::AtomicU32, Arc, Mutex},
+    time::Duration,
+};
+
+use fuse::{
+    FileAttr, Filesystem, ReplyAttr, ReplyBmap, ReplyCreate, ReplyData, ReplyDirectory, ReplyEmpty,
+    ReplyEntry, ReplyLock, ReplyOpen, ReplyStatfs, ReplyWrite, ReplyXattr, Request,
+};
+use indicatif::{ProgressBar, ProgressStyle};
+use shared_buffer::OwnedBuffer;
+use tokio::runtime::Handle;
+use virtual_fs::{
+    mem_fs::{self, OffloadBackingStore},
+    AsyncReadExt, AsyncSeekExt, AsyncWriteExt, FileOpener, FileSystem, FsError,
+};
+use wasmer_wasix::{
+    fs::WasiFdSeed,
+    journal::{
+        copy_journal, ArchivedJournalEntry, ArchivedJournalEntryFileDescriptorWriteV1, Journal,
+        JournalEntry, JournalEntryFileDescriptorWriteV1, LogFileJournal, LogWriteResult,
+        ReadableJournal, WritableJournal,
+    },
+    types::Oflags,
+    wasmer_wasix_types::wasi,
+    VIRTUAL_ROOT_FD,
+};
+
+#[derive(Debug)]
+struct State {
+    handle: tokio::runtime::Handle,
+    mem_fs: mem_fs::FileSystem,
+    inos: HashMap<u64, Cow<'static, str>>,
+    lookup: HashMap<
+        u32,
+        Arc<tokio::sync::Mutex<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>>>,
+    >,
+    seed: WasiFdSeed,
+    fake_offset: u64,
+}
+
+#[derive(Debug)]
+struct MutexState {
+    inner: Mutex<State>,
+}
+
+#[derive(Debug)]
+pub struct JournalFileSystemBuilder {
+    path: PathBuf,
+    fd_seed: WasiFdSeed,
+    progress_bar: bool,
+}
+
+impl JournalFileSystemBuilder {
+    pub fn new(path: &Path) -> Self {
+        Self {
+            path: path.to_path_buf(),
+            fd_seed: WasiFdSeed::default(),
+            progress_bar: false,
+        }
+    }
+
+    pub fn with_fd_seed(mut self, fd_seed: WasiFdSeed) -> Self {
+        self.fd_seed = fd_seed;
+        self
+    }
+
+    pub fn with_progress_bar(mut self, val: bool) -> Self {
+        self.progress_bar = val;
+        self
+    }
+
+    // Opens the journal and copies all its contents into
+    // and memory file system
+    pub fn build(self) -> anyhow::Result<JournalFileSystem> {
+        let journal = LogFileJournal::new(&self.path)?;
+        let backing_store = journal.backing_store();
+        let file_len = backing_store.owned_buffer().len();
+
+        let mem_fs = mem_fs::FileSystem::default().with_backing_offload(backing_store)?;
+        let state = MutexState {
+            inner: Mutex::new(State {
+                handle: tokio::runtime::Handle::current(),
+                mem_fs,
+                inos: Default::default(),
+                seed: self.fd_seed,
+                lookup: Default::default(),
+                fake_offset: 0,
+            }),
+        };
+
+        let progress = if self.progress_bar {
+            let mut pb = ProgressBar::new(file_len as u64);
+            pb.set_style(ProgressStyle::with_template("{msg}\n{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})")
+                .unwrap()
+                .progress_chars("#>-"));
+            pb.set_message("Loading journal...");
+
+            Some(pb)
+        } else {
+            None
+        };
+
+        tokio::task::block_in_place(|| {
+            if let Some(progress) = progress {
+                copy_journal_with_progress(&journal, &state, progress)
+            } else {
+                copy_journal(&journal, &state)
+            }
+        })?;
+
+        let ret = JournalFileSystem {
+            handle: tokio::runtime::Handle::current(),
+            journal,
+            state,
+        };
+
+        Ok(ret)
+    }
+}
+
+pub fn copy_journal_with_progress<R: ReadableJournal, W: WritableJournal>(
+    from: &R,
+    to: &W,
+    mut progress: ProgressBar,
+) -> anyhow::Result<()> {
+    while let Some(record) = from.read()? {
+        progress.set_position(record.record_end);
+        to.write(record.into_inner())?;
+    }
+    progress.finish_and_clear();
+    println!("Journal is mounted");
+    Ok(())
+}
+
+#[derive(Debug)]
+pub struct JournalFileSystem {
+    handle: tokio::runtime::Handle,
+    journal: LogFileJournal,
+    state: MutexState,
+}
+
+impl JournalFileSystem {
+    fn reverse_ino(&self, ino: u64) -> Result<Cow<'static, str>, libc::c_int> {
+        if ino == 1 {
+            return Ok("/".into());
+        }
+        let path = {
+            let mut state = self.state.inner.lock().unwrap();
+            match state.inos.get(&ino).cloned() {
+                Some(path) => path,
+                None => {
+                    return Err(libc::ENOENT);
+                }
+            }
+        };
+        Ok(path)
+    }
+
+    fn attr<'a>(&self, path: Cow<'a, str>) -> Result<FileAttr, libc::c_int> {
+        let mut state = self.state.inner.lock().unwrap();
+
+        let res = state.mem_fs.metadata(&Path::new(path.as_ref()));
+        match res {
+            Ok(meta) => {
+                // The ino is just the hash of the name
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                path.hash(&mut hasher);
+                let ino = hasher.finish();
+                state
+                    .inos
+                    .entry(ino)
+                    .or_insert_with(|| path.into_owned().into());
+
+                // Build a file attr and return it
+                Ok(FileAttr {
+                    ino,
+                    size: meta.len,
+                    blocks: (1u64.max(meta.len) - 1 / 512) + 1,
+                    atime: time01::Timespec::new(meta.accessed as i64, 0),
+                    mtime: time01::Timespec::new(meta.modified as i64, 0),
+                    ctime: time01::Timespec::new(meta.created as i64, 0),
+                    crtime: time01::Timespec::new(meta.created as i64, 0),
+                    kind: file_type_to_kind(meta.ft),
+                    perm: 0o644,
+                    nlink: 1,
+                    uid: 0,
+                    gid: 0,
+                    rdev: 0,
+                    flags: 0,
+                })
+            }
+            Err(FsError::EntryNotFound) => Err(libc::ENOENT),
+            Err(_) => Err(libc::EIO),
+        }
+    }
+}
+
+impl WritableJournal for MutexState {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let mut state = self.inner.lock().unwrap();
+        let ret = LogWriteResult {
+            record_start: state.fake_offset,
+            record_end: state.fake_offset + entry.estimate_size() as u64,
+        };
+        state.fake_offset += ret.record_size();
+        match entry {
+            JournalEntry::FileDescriptorWriteV1 {
+                fd,
+                offset,
+                data,
+                is_64bit,
+            } => {
+                let handle = state.handle.clone();
+                if let Some(file) = state.lookup.get_mut(&fd) {
+                    handle.block_on(async {
+                        let mut file = file.lock().await;
+                        file.seek(io::SeekFrom::Start(offset)).await;
+                        file.write_all(&data).await
+                    })?;
+                }
+            }
+            JournalEntry::CloseFileDescriptorV1 { fd } => {
+                state.lookup.remove(&fd);
+            }
+            JournalEntry::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            } => {
+                state.seed.clip_val(fd + 1);
+                let file = state
+                    .mem_fs
+                    .new_open_options()
+                    .create(o_flags.contains(Oflags::CREATE))
+                    .truncate(o_flags.contains(Oflags::TRUNC))
+                    .write(true)
+                    .read(true)
+                    .open(path.as_ref())?;
+                state
+                    .lookup
+                    .insert(fd, Arc::new(tokio::sync::Mutex::new(file)));
+            }
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                state.seed.clip_val(new_fd + 1);
+                if let Some(file) = state.lookup.remove(&old_fd) {
+                    state.lookup.insert(new_fd, file);
+                }
+            }
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => {
+                state.seed.clip_val(copied_fd + 1);
+                if let Some(file) = state.lookup.get(&original_fd).cloned() {
+                    state.lookup.insert(copied_fd, file);
+                }
+            }
+            JournalEntry::CreateDirectoryV1 { fd, path } => {
+                state.mem_fs.create_dir(&Path::new(path.as_ref())).ok();
+            }
+            JournalEntry::RemoveDirectoryV1 { fd, path } => {
+                state.mem_fs.remove_dir(&Path::new(path.as_ref()))?;
+            }
+            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
+                let handle = state.handle.clone();
+                if let Some(file) = state.lookup.get(&fd) {
+                    handle.block_on(async {
+                        let mut file = file.lock().await;
+                        file.set_len(st_size)
+                    })?;
+                }
+            }
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
+                let handle = state.handle.clone();
+                if let Some(file) = state.lookup.get(&fd) {
+                    handle.block_on(async {
+                        let mut file = file.lock().await;
+                        file.set_len(offset + len)
+                    })?;
+                }
+            }
+            JournalEntry::UnlinkFileV1 { fd, path } => {
+                state.mem_fs.remove_file(&Path::new(path.as_ref()))?;
+            }
+            JournalEntry::PathRenameV1 {
+                old_fd,
+                old_path,
+                new_fd,
+                new_path,
+            } => {
+                let handle = state.handle.clone();
+                handle.block_on(async {
+                    state
+                        .mem_fs
+                        .rename(&Path::new(old_path.as_ref()), &Path::new(new_path.as_ref()))
+                        .await
+                })?;
+            }
+            JournalEntry::SocketOpenV1 { fd, .. } => {
+                state.seed.clip_val(fd + 1);
+            }
+            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+                state.seed.clip_val(fd1 + 1);
+                state.seed.clip_val(fd2 + 1);
+            }
+            JournalEntry::CreateEventV1 { fd, .. } => {
+                state.seed.clip_val(fd + 1);
+            }
+            JournalEntry::EpollCreateV1 { fd } => {
+                state.seed.clip_val(fd + 1);
+            }
+            JournalEntry::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            } => {
+                state.seed.clip_val(fd + 1);
+            }
+            JournalEntry::SocketAcceptedV1 { fd, .. } => {
+                state.seed.clip_val(fd + 1);
+            }
+            _ => {}
+        }
+        Ok(ret)
+    }
+}
+
+impl JournalFileSystem {
+    fn compute_path<'a>(&'a self, parent: u64, name: &'a OsStr) -> Result<Cow<'_, str>, i32> {
+        // Get the path from the ino otherwise it is not a known
+        // path (this means the other methods have to be hit first)
+        let path = match self.reverse_ino(parent) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::compute_path reverse_ino({parent}) errno={err}");
+                return Err(err);
+            }
+        };
+
+        // Add the name as a postfix
+        let name = name.to_string_lossy();
+        let path = if path.ends_with("/") {
+            path + name
+        } else {
+            path + "/" + name
+        };
+        Ok(path)
+    }
+}
+
+impl Filesystem for JournalFileSystem {
+    fn init(&mut self, _req: &Request) -> Result<(), libc::c_int> {
+        Ok(())
+    }
+
+    fn destroy(&mut self, _req: &Request) {}
+
+    fn lookup(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEntry) {
+        let path = match self.compute_path(parent, name) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::lookup err={err}");
+                return reply.error(err);
+            }
+        };
+
+        match self.attr(path) {
+            Ok(meta) => reply.entry(&time01::Timespec::new(1, 0), &meta, 0),
+            Err(err) => {
+                tracing::trace!("fs::lookup err={err}");
+                reply.error(err)
+            }
+        }
+    }
+
+    fn getattr(&mut self, _req: &Request, ino: u64, reply: ReplyAttr) {
+        let path = match self.reverse_ino(ino) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::getattr reverse_ino({ino}) errno={err}");
+                reply.error(err);
+                return;
+            }
+        };
+
+        match self.attr(path) {
+            Ok(meta) => reply.attr(&time01::Timespec::new(1, 0), &meta),
+            Err(err) => reply.error(err),
+        }
+    }
+
+    fn setattr(
+        &mut self,
+        _req: &Request,
+        ino: u64,
+        _mode: Option<u32>,
+        _uid: Option<u32>,
+        _gid: Option<u32>,
+        size: Option<u64>,
+        _atime: Option<time01::Timespec>,
+        _mtime: Option<time01::Timespec>,
+        fh: Option<u64>,
+        _crtime: Option<time01::Timespec>,
+        _chgtime: Option<time01::Timespec>,
+        _bkuptime: Option<time01::Timespec>,
+        _flags: Option<u32>,
+        reply: ReplyAttr,
+    ) {
+        let mut entries = Vec::new();
+
+        let attr = match fh {
+            Some(fd) => {
+                let fd = fd as u32;
+                let mut state = self.state.inner.lock().unwrap();
+                let file = match state.lookup.get_mut(&fd) {
+                    Some(f) => f.clone(),
+                    None => {
+                        tracing::trace!("fs::getattr noent (fd={fd})");
+                        reply.error(libc::ENOENT);
+                        return;
+                    }
+                };
+
+                self.handle.block_on(async {
+                    let mut file = file.lock().await;
+
+                    if let Some(size) = size {
+                        entries.push(JournalEntry::FileDescriptorSetSizeV1 {
+                            fd: fd as u32,
+                            st_size: size,
+                        })
+                    }
+
+                    FileAttr {
+                        ino,
+                        size: file.size(),
+                        blocks: (1u64.max(file.size()) - 1 / 512) + 1,
+                        atime: time01::Timespec::new(file.last_accessed() as i64, 0),
+                        mtime: time01::Timespec::new(file.last_modified() as i64, 0),
+                        ctime: time01::Timespec::new(file.created_time() as i64, 0),
+                        crtime: time01::Timespec::new(file.created_time() as i64, 0),
+                        kind: fuse::FileType::RegularFile,
+                        perm: 0o644,
+                        nlink: 1,
+                        uid: 0,
+                        gid: 0,
+                        rdev: 0,
+                        flags: 0,
+                    }
+                })
+            }
+            None => {
+                let path = match self.reverse_ino(ino) {
+                    Ok(a) => a,
+                    Err(err) => {
+                        tracing::trace!("fs::setattr reverse_ino({ino}) errno={err}");
+                        reply.error(err);
+                        return;
+                    }
+                };
+
+                let fh;
+                let mut state = self.state.inner.lock().unwrap();
+                let file = state
+                    .mem_fs
+                    .new_open_options()
+                    .read(true)
+                    .write(true)
+                    .open(&Path::new(path.as_ref()));
+                match file {
+                    Ok(file) => {
+                        // Reserve a file descriptor and close the state
+                        fh = state.seed.next_val();
+                        drop(state);
+
+                        entries.push(JournalEntry::OpenFileDescriptorV1 {
+                            fd: fh,
+                            dirfd: VIRTUAL_ROOT_FD,
+                            dirflags: 0,
+                            path,
+                            o_flags: wasi::Oflags::empty(),
+                            fs_rights_base: wasi::Rights::all(),
+                            fs_rights_inheriting: wasi::Rights::all(),
+                            fs_flags: wasi::Fdflags::empty(),
+                        });
+                        if let Some(size) = size {
+                            entries.push(JournalEntry::FileDescriptorSetSizeV1 {
+                                fd: fh as u32,
+                                st_size: size,
+                            })
+                        }
+                        entries.push(JournalEntry::CloseFileDescriptorV1 { fd: fh });
+
+                        for entry in entries.iter() {
+                            if self.state.write(entry.clone()).is_err() {
+                                tracing::trace!("fs::open err=EIO");
+                                reply.error(libc::EIO);
+                                return;
+                            }
+                        }
+                        for entry in entries.iter() {
+                            if self.journal.write(entry.clone()).is_err() {
+                                tracing::trace!("fs::open err=EIO");
+                                reply.error(libc::EIO);
+                                return;
+                            }
+                        }
+                        FileAttr {
+                            ino,
+                            size: file.size(),
+                            blocks: (1u64.max(file.size()) - 1 / 512) + 1,
+                            atime: time01::Timespec::new(file.last_accessed() as i64, 0),
+                            mtime: time01::Timespec::new(file.last_modified() as i64, 0),
+                            ctime: time01::Timespec::new(file.created_time() as i64, 0),
+                            crtime: time01::Timespec::new(file.created_time() as i64, 0),
+                            kind: fuse::FileType::RegularFile,
+                            perm: 0o644,
+                            nlink: 1,
+                            uid: 0,
+                            gid: 0,
+                            rdev: 0,
+                            flags: 0,
+                        }
+                    }
+                    Err(FsError::EntryNotFound) => {
+                        // Maybe its a directory, in which case we are done
+                        if let Ok(meta) = state.mem_fs.metadata(&Path::new(path.as_ref())) {
+                            FileAttr {
+                                ino,
+                                size: meta.len,
+                                blocks: (1u64.max(meta.len) - 1 / 512) + 1,
+                                atime: time01::Timespec::new(meta.accessed as i64, 0),
+                                mtime: time01::Timespec::new(meta.modified as i64, 0),
+                                ctime: time01::Timespec::new(meta.created as i64, 0),
+                                crtime: time01::Timespec::new(meta.created as i64, 0),
+                                kind: file_type_to_kind(meta.ft),
+                                perm: 0o644,
+                                nlink: 1,
+                                uid: 0,
+                                gid: 0,
+                                rdev: 0,
+                                flags: 0,
+                            }
+                        } else {
+                            tracing::trace!("fs::setattr open_file({path}) err=ENOENT");
+                            reply.error(libc::ENOENT);
+                            return;
+                        }
+                    }
+                    Err(err) => {
+                        tracing::trace!("fs::setattr open_file({path}) err={err}");
+                        reply.error(libc::EIO);
+                        return;
+                    }
+                }
+            }
+        };
+
+        // Return the data
+        reply.attr(&time01::Timespec::new(1, 0), &attr)
+    }
+
+    fn setxattr(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _name: &OsStr,
+        _value: &[u8],
+        _flags: u32,
+        _position: u32,
+        reply: ReplyEmpty,
+    ) {
+        tracing::trace!("fs::setxattr err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn getxattr(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _name: &OsStr,
+        _size: u32,
+        reply: ReplyXattr,
+    ) {
+        tracing::trace!("fs::getxattr size(0)");
+        reply.size(0)
+    }
+
+    fn open(&mut self, _req: &Request, ino: u64, flags: u32, reply: ReplyOpen) {
+        let path = match self.reverse_ino(ino) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::open reverse_ino({ino}) errno={err}");
+                reply.error(err);
+                return;
+            }
+        };
+
+        // Reserve a file descriptor
+        let fh = {
+            let mut state = self.state.inner.lock().unwrap();
+            state.seed.next_val()
+        };
+
+        // Write the journals
+        let entry = JournalEntry::OpenFileDescriptorV1 {
+            fd: fh,
+            dirfd: VIRTUAL_ROOT_FD,
+            dirflags: 0,
+            path,
+            o_flags: wasi::Oflags::empty(),
+            fs_rights_base: wasi::Rights::all(),
+            fs_rights_inheriting: wasi::Rights::all(),
+            fs_flags: wasi::Fdflags::empty(),
+        };
+        if self.state.write(entry.clone()).is_err() {
+            tracing::trace!("fs::open err=EIO");
+            reply.error(libc::EIO);
+            return;
+        }
+        if self.journal.write(entry).is_err() {
+            tracing::trace!("fs::open err=EIO");
+            reply.error(libc::EIO);
+            return;
+        }
+
+        tracing::trace!("fs::open opened fh={fh}");
+        reply.opened(fh as u64, flags);
+    }
+
+    fn release(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        fh: u64,
+        _flags: u32,
+        _lock_owner: u64,
+        _flush: bool,
+        reply: ReplyEmpty,
+    ) {
+        let fh = fh as u32;
+
+        {
+            // Check that the file handle exists
+            let mut state = self.state.inner.lock().unwrap();
+            if !state.lookup.contains_key(&fh) {
+                tracing::trace!("fs::release err=ENOENT (fd={fh})");
+                reply.error(libc::ENOENT);
+                return;
+            }
+        }
+
+        // Write the journals
+        let entry = JournalEntry::CloseFileDescriptorV1 { fd: fh };
+        if self.state.write(entry.clone()).is_err() {
+            tracing::trace!("fs::release err=EIO");
+            reply.error(libc::EIO);
+            return;
+        }
+        if self.journal.write(entry).is_err() {
+            tracing::trace!("fs::release err=EIO");
+            reply.error(libc::EIO);
+            return;
+        }
+
+        tracing::trace!("fs::release ok");
+        reply.ok();
+    }
+
+    fn create(
+        &mut self,
+        _req: &Request,
+        parent: u64,
+        name: &OsStr,
+        mode: u32,
+        flags: u32,
+        reply: ReplyCreate,
+    ) {
+        let path = match self.compute_path(parent, name) {
+            Ok(a) => a,
+            Err(err) => return reply.error(err),
+        };
+
+        // The ino is just the hash of the name
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        path.hash(&mut hasher);
+        let ino = hasher.finish();
+
+        // Reserve a file descriptor
+        let fh = {
+            let mut state = self.state.inner.lock().unwrap();
+            state.seed.next_val()
+        };
+
+        // Write the journals
+        let entry = JournalEntry::OpenFileDescriptorV1 {
+            fd: fh,
+            dirfd: VIRTUAL_ROOT_FD,
+            dirflags: 0,
+            path,
+            o_flags: wasi::Oflags::CREATE,
+            fs_rights_base: wasi::Rights::all(),
+            fs_rights_inheriting: wasi::Rights::all(),
+            fs_flags: wasi::Fdflags::empty(),
+        };
+        if let Err(err) = self.state.write(entry.clone()) {
+            tracing::trace!("fs::create (j1) err=EIO - {err}");
+            reply.error(libc::EIO);
+            return;
+        }
+        if let Err(err) = self.journal.write(entry) {
+            tracing::trace!("fs::create (j2) err=EIO - {err}");
+            reply.error(libc::EIO);
+            return;
+        }
+
+        let now = time01::get_time();
+        reply.created(
+            &time01::Timespec::new(1, 0),
+            &FileAttr {
+                ino,
+                size: 0,
+                blocks: 0,
+                atime: now,
+                mtime: now,
+                ctime: now,
+                crtime: now,
+                kind: fuse::FileType::RegularFile,
+                perm: 0o644,
+                nlink: 1,
+                uid: 0,
+                gid: 0,
+                rdev: 0,
+                flags: 0,
+            },
+            0,
+            fh as u64,
+            flags,
+        );
+    }
+
+    fn read(
+        &mut self,
+        _req: &Request,
+        ino: u64,
+        fh: u64,
+        offset: i64,
+        size: u32,
+        reply: ReplyData,
+    ) {
+        let fh = fh as u32;
+
+        // Grab the file from the file handle
+        let mut state = self.state.inner.lock().unwrap();
+        let file = match state.lookup.get_mut(&fh) {
+            Some(a) => a,
+            None => {
+                tracing::trace!("fs::read lookup(fh={fh}) noent err=EIO");
+                reply.error(libc::ENOENT);
+                return;
+            }
+        };
+
+        // Read the data from the file and return it
+        let data: Result<_, io::Error> = self.handle.block_on(async {
+            let mut file = file.lock().await;
+
+            let mut buf = Vec::with_capacity(size as usize);
+            unsafe { buf.set_len(size as usize) };
+            file.seek(io::SeekFrom::Start(offset as u64)).await?;
+            let amt = file.read(&mut buf).await?;
+            unsafe { buf.set_len(amt) };
+            Ok(buf)
+        });
+        let data = match data {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::read data err=EIO");
+                reply.error(libc::EIO);
+                return;
+            }
+        };
+
+        // Return the data
+        reply.data(&data);
+    }
+
+    fn write(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        fh: u64,
+        offset: i64,
+        data: &[u8],
+        _flags: u32,
+        reply: ReplyWrite,
+    ) {
+        let fh = fh as u32;
+
+        {
+            // Check that the file handle exists
+            let mut state = self.state.inner.lock().unwrap();
+            if !state.lookup.contains_key(&fh) {
+                tracing::trace!("fs::write err=ENOENT");
+                reply.error(libc::ENOENT);
+                return;
+            }
+        }
+
+        // Write the entry to the log file
+        let fd = fh as u32;
+        let entry = JournalEntry::FileDescriptorWriteV1 {
+            fd,
+            offset: offset as u64,
+            data: data.into(),
+            is_64bit: false,
+        };
+
+        let res = match self.journal.write(entry) {
+            Ok(res) => res,
+            Err(err) => {
+                tracing::trace!("fs::write err=EIO - {err}");
+                reply.error(libc::EIO);
+                return;
+            }
+        };
+
+        // We load the record from the journal and use this to write to the memory file system
+        // because the memory file system has an optimization where it will automatically offload
+        // the data to the mmap of the journal rather than store it in memory. In effect it offloads
+        // to the disk
+        {
+            let mut state = self.state.inner.lock().unwrap();
+            let handle = state.handle.clone();
+            if let Some(file) = state.lookup.get_mut(&fd) {
+                let res: Result<_, io::Error> = handle.block_on(async {
+                    let mut file = file.lock().await;
+                    file.seek(io::SeekFrom::Start(offset as u64)).await;
+
+                    // Unsafe!!! This assumes the structure does not change
+                    // where the first bytes in the entry are an aligned
+                    // array that corresponds to the data itself
+                    let size = data.len() as u64;
+                    let mut mmap_offset = res.record_start;
+                    let align = mmap_offset % 16;
+                    if align != 0 {
+                        mmap_offset += 16 - align;
+                    }
+
+                    // Add the entry
+                    if file.write_from_mmap(mmap_offset, size).is_err() {
+                        // We fall back on just writing the data normally
+                        file.seek(io::SeekFrom::Start(offset as u64)).await;
+                        file.write_all(&data).await?;
+                    }
+                    Ok(())
+                });
+                if let Err(err) = res {
+                    tracing::trace!("fs::write err=EIO");
+                    reply.error(libc::EIO);
+                    return;
+                }
+            } else {
+                tracing::trace!("fs::write err=EIO");
+                reply.error(libc::EIO);
+                return;
+            }
+        }
+
+        reply.written(data.len() as u32);
+    }
+
+    fn readdir(
+        &mut self,
+        _req: &Request,
+        ino: u64,
+        _fh: u64,
+        offset: i64,
+        mut reply: ReplyDirectory,
+    ) {
+        // Get the path from the ino otherwise it is not a known
+        // path (this means the other methods have to be hit first)
+        let path = match self.reverse_ino(ino) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::readir reverse_ino({ino}) err={}", err);
+                reply.error(err);
+                return;
+            }
+        };
+
+        let mut state = self.state.inner.lock().unwrap();
+        let read_dir = state.mem_fs.read_dir(&Path::new(path.as_ref()));
+        let read_dir = match read_dir {
+            Ok(a) => a,
+            Err(FsError::EntryNotFound) => {
+                tracing::trace!("fs::readir read_dir({}) err=ENOENT", path);
+                return;
+            }
+            Err(err) => {
+                tracing::trace!("fs::readir read_dir({}) err={}", path, err);
+                reply.error(libc::EIO);
+                return;
+            }
+        };
+
+        for (i, entry) in read_dir.into_iter().enumerate().skip(offset as usize) {
+            let entry = match entry {
+                Ok(a) => a,
+                Err(err) => {
+                    tracing::trace!("fs::readir direntry(index={i}) err={}", err);
+                    reply.error(libc::EIO);
+                    return;
+                }
+            };
+            let path = entry.path.to_string_lossy();
+            let name = match entry.path.file_name() {
+                Some(n) => n,
+                None => {
+                    tracing::trace!("fs::readir file_name err=EIO");
+                    reply.error(libc::EIO);
+                    return;
+                }
+            };
+
+            // The ino is just the hash of the name
+            let mut hasher = std::collections::hash_map::DefaultHasher::new();
+            path.hash(&mut hasher);
+            let ino = hasher.finish();
+            state
+                .inos
+                .entry(ino)
+                .or_insert_with(|| path.into_owned().into());
+
+            // Compute the directory kind
+            let kind = match entry.file_type() {
+                Ok(ft) => file_type_to_kind(ft),
+                _ => fuse::FileType::RegularFile,
+            };
+
+            // i + 1 means the index of the next entry
+            reply.add(ino, (i + 1) as i64, kind, name);
+        }
+        reply.ok();
+    }
+
+    fn mkdir(&mut self, _req: &Request, parent: u64, name: &OsStr, _mode: u32, reply: ReplyEntry) {
+        let path = match self.compute_path(parent, name) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::mkdir compute_path err={err}");
+                return reply.error(err);
+            }
+        };
+
+        let entry = JournalEntry::CreateDirectoryV1 {
+            fd: VIRTUAL_ROOT_FD,
+            path: path.clone(),
+        };
+        self.state.write(entry.clone());
+        self.journal.write(entry);
+
+        match self.attr(path) {
+            Ok(meta) => {
+                tracing::trace!("fs::mkdir ok");
+                reply.entry(&time01::Timespec::new(1, 0), &meta, 0)
+            }
+            Err(err) => {
+                tracing::trace!("fs::mkdir attr err={err}");
+                reply.error(err)
+            }
+        }
+    }
+
+    fn rmdir(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEmpty) {
+        let path = match self.compute_path(parent, name) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::rmdir err={err}");
+                return reply.error(err);
+            }
+        };
+
+        let entry = JournalEntry::RemoveDirectoryV1 {
+            fd: VIRTUAL_ROOT_FD,
+            path: path.clone(),
+        };
+        self.state.write(entry.clone());
+        self.journal.write(entry);
+        tracing::trace!("fs::rmdir ok");
+        reply.ok();
+    }
+
+    fn unlink(&mut self, _req: &Request, parent: u64, name: &OsStr, reply: ReplyEmpty) {
+        let path = match self.compute_path(parent, name) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::trace!("fs::unlink err={err}");
+                return reply.error(err);
+            }
+        };
+
+        let entry = JournalEntry::UnlinkFileV1 {
+            fd: VIRTUAL_ROOT_FD,
+            path: path.clone(),
+        };
+        self.state.write(entry.clone());
+        self.journal.write(entry);
+        tracing::trace!("fs::unlink ok");
+        reply.ok();
+    }
+
+    fn forget(&mut self, _req: &Request, _ino: u64, _nlookup: u64) {
+        tracing::trace!("fs::forget ok");
+    }
+
+    fn readlink(&mut self, _req: &Request, _ino: u64, reply: ReplyData) {
+        tracing::trace!("fs::readlink err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn mknod(
+        &mut self,
+        _req: &Request,
+        _parent: u64,
+        _name: &OsStr,
+        _mode: u32,
+        _rdev: u32,
+        reply: ReplyEntry,
+    ) {
+        tracing::trace!("fs::mknod err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn symlink(
+        &mut self,
+        _req: &Request,
+        _parent: u64,
+        _name: &OsStr,
+        _link: &Path,
+        reply: ReplyEntry,
+    ) {
+        tracing::trace!("fs::symlink err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn rename(
+        &mut self,
+        _req: &Request,
+        _parent: u64,
+        _name: &OsStr,
+        _newparent: u64,
+        _newname: &OsStr,
+        reply: ReplyEmpty,
+    ) {
+        tracing::trace!("fs::rename err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn link(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _newparent: u64,
+        _newname: &OsStr,
+        reply: ReplyEntry,
+    ) {
+        tracing::trace!("fs::link err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn fsync(&mut self, _req: &Request, _ino: u64, _fh: u64, _datasync: bool, reply: ReplyEmpty) {
+        tracing::trace!("fs::fsync err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn opendir(&mut self, _req: &Request, _ino: u64, _flags: u32, reply: ReplyOpen) {
+        tracing::trace!("fs::opendir opened");
+        reply.opened(0, 0);
+    }
+
+    fn releasedir(&mut self, _req: &Request, _ino: u64, _fh: u64, _flags: u32, reply: ReplyEmpty) {
+        tracing::trace!("fs::releasedir ok");
+        reply.ok();
+    }
+
+    fn fsyncdir(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _fh: u64,
+        _datasync: bool,
+        reply: ReplyEmpty,
+    ) {
+        tracing::trace!("fs::fsyncdir err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn statfs(&mut self, _req: &Request, _ino: u64, reply: ReplyStatfs) {
+        tracing::trace!("fs::statfs ok");
+        reply.statfs(0, 0, 0, 0, 0, 512, 255, 0);
+    }
+
+    fn listxattr(&mut self, _req: &Request, _ino: u64, _size: u32, reply: ReplyXattr) {
+        tracing::trace!("fs::listxattr err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn removexattr(&mut self, _req: &Request, _ino: u64, _name: &OsStr, reply: ReplyEmpty) {
+        tracing::trace!("fs::removexattr err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn access(&mut self, _req: &Request, _ino: u64, _mask: u32, reply: ReplyEmpty) {
+        tracing::trace!("fs::access err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn getlk(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _fh: u64,
+        _lock_owner: u64,
+        _start: u64,
+        _end: u64,
+        _typ: u32,
+        _pid: u32,
+        reply: ReplyLock,
+    ) {
+        tracing::trace!("fs::getlk err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn setlk(
+        &mut self,
+        _req: &Request,
+        _ino: u64,
+        _fh: u64,
+        _lock_owner: u64,
+        _start: u64,
+        _end: u64,
+        _typ: u32,
+        _pid: u32,
+        _sleep: bool,
+        reply: ReplyEmpty,
+    ) {
+        tracing::trace!("fs::setlk err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    fn bmap(&mut self, _req: &Request, _ino: u64, _blocksize: u32, _idx: u64, reply: ReplyBmap) {
+        tracing::trace!("fs::bmp err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn setvolname(&mut self, _req: &Request, _name: &OsStr, reply: ReplyEmpty) {
+        tracing::trace!("fs::setvolname err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn exchange(
+        &mut self,
+        _req: &Request,
+        _parent: u64,
+        _name: &OsStr,
+        _newparent: u64,
+        _newname: &OsStr,
+        _options: u64,
+        reply: ReplyEmpty,
+    ) {
+        tracing::trace!("fs::exchange err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+
+    #[cfg(target_os = "macos")]
+    fn getxtimes(&mut self, _req: &Request, _ino: u64, reply: ReplyXTimes) {
+        tracing::trace!("fs::getxtimes err=ENOSYS");
+        reply.error(libc::ENOSYS);
+    }
+}
+
+fn file_type_to_kind(ft: virtual_fs::FileType) -> fuse::FileType {
+    if ft.dir {
+        fuse::FileType::Directory
+    } else if ft.symlink {
+        fuse::FileType::Symlink
+    } else if ft.block_device {
+        fuse::FileType::BlockDevice
+    } else if ft.char_device {
+        fuse::FileType::CharDevice
+    } else if ft.socket {
+        fuse::FileType::Socket
+    } else {
+        fuse::FileType::RegularFile
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/mod.rs
new file mode 100644
index 0000000..44c2885
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/journal/mount/mod.rs
@@ -0,0 +1,4 @@
+mod cmd;
+mod fs;
+
+pub use cmd::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/login.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/login.rs
new file mode 100644
index 0000000..7e5555c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/login.rs
@@ -0,0 +1,541 @@
+use std::{net::TcpListener, path::PathBuf, str::FromStr, time::Duration};
+
+use anyhow::Ok;
+use clap::Parser;
+#[cfg(not(test))]
+use dialoguer::{console::style, Input};
+use hyper::{
+    service::{make_service_fn, service_fn},
+    Body, Request, Response, Server, StatusCode,
+};
+use reqwest::Method;
+use serde::Deserialize;
+use wasmer_registry::{
+    types::NewNonceOutput,
+    wasmer_env::{Registry, WasmerEnv, WASMER_DIR},
+    RegistryClient,
+};
+
+const WASMER_CLI: &str = "wasmer-cli";
+
+/// Payload from the frontend after the user has authenticated.
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum TokenStatus {
+    /// Signifying that the token is cancelled
+    Cancelled,
+    /// Signifying that the token is authorized
+    Authorized,
+}
+
+/// Payload from the frontend after the user has authenticated.
+///
+/// This has the token that we need to set in the WASMER_TOML file.
+#[derive(Clone, Debug, Deserialize)]
+pub struct ValidatedNonceOutput {
+    /// Token Received from the frontend
+    pub token: Option<String>,
+    /// Status of the token , whether it is authorized or cancelled
+    pub status: TokenStatus,
+}
+
+/// Enum for the boolean like prompt options
+#[derive(Debug, Clone, PartialEq)]
+pub enum BoolPromptOptions {
+    /// Signifying a yes/true - using `y/Y`
+    Yes,
+    /// Signifying a No/false - using `n/N`
+    No,
+}
+
+impl FromStr for BoolPromptOptions {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "y" | "Y" => Ok(BoolPromptOptions::Yes),
+            "n" | "N" => Ok(BoolPromptOptions::No),
+            _ => Err(anyhow::anyhow!("Invalid option")),
+        }
+    }
+}
+
+impl ToString for BoolPromptOptions {
+    fn to_string(&self) -> String {
+        match self {
+            BoolPromptOptions::Yes => "y".to_string(),
+            BoolPromptOptions::No => "n".to_string(),
+        }
+    }
+}
+
+type Token = String;
+
+#[derive(Debug, Clone)]
+enum AuthorizationState {
+    TokenSuccess(Token),
+    Cancelled,
+    TimedOut,
+    UnknownMethod,
+}
+
+#[derive(Clone)]
+struct AppContext {
+    server_shutdown_tx: tokio::sync::mpsc::Sender<bool>,
+    token_tx: tokio::sync::mpsc::Sender<AuthorizationState>,
+}
+
+/// Subcommand for log in a user into Wasmer (using a browser or provided a token)
+#[derive(Debug, Clone, Parser)]
+pub struct Login {
+    /// Variable to login without opening a browser
+    #[clap(long, name = "no-browser", default_value = "false")]
+    pub no_browser: bool,
+    // Note: This is essentially a copy of WasmerEnv except the token is
+    // accepted as a main argument instead of via --token.
+    /// Set Wasmer's home directory
+    #[clap(long, env = "WASMER_DIR", default_value = WASMER_DIR.as_os_str())]
+    pub wasmer_dir: PathBuf,
+    /// The registry to fetch packages from (inferred from the environment by
+    /// default)
+    #[clap(long, env = "WASMER_REGISTRY")]
+    pub registry: Option<Registry>,
+    /// The API token to use when communicating with the registry (inferred from
+    /// the environment by default)
+    pub token: Option<String>,
+    /// The directory cached artefacts are saved to.
+    #[clap(long, env = "WASMER_CACHE_DIR")]
+    cache_dir: Option<PathBuf>,
+}
+
+impl Login {
+    fn get_token_or_ask_user(&self, env: &WasmerEnv) -> Result<AuthorizationState, anyhow::Error> {
+        if let Some(token) = &self.token {
+            return Ok(AuthorizationState::TokenSuccess(token.clone()));
+        }
+
+        let registry_host = env.registry_endpoint()?;
+        let registry_tld = tldextract::TldExtractor::new(tldextract::TldOption::default())
+            .extract(registry_host.as_str())
+            .map_err(|e| {
+                std::io::Error::new(
+                    std::io::ErrorKind::Other,
+                    format!("Invalid registry for login {}: {e}", registry_host),
+                )
+            })?;
+
+        let login_prompt = match (
+            registry_tld.domain.as_deref(),
+            registry_tld.suffix.as_deref(),
+        ) {
+            (Some(d), Some(s)) => {
+                format!("Please paste the login token from https://{d}.{s}/settings/access-tokens")
+            }
+            _ => "Please paste the login token".to_string(),
+        };
+        #[cfg(test)]
+        {
+            Ok(AuthorizationState::TokenSuccess(login_prompt))
+        }
+        #[cfg(not(test))]
+        {
+            let token = Input::new().with_prompt(&login_prompt).interact_text()?;
+            Ok(AuthorizationState::TokenSuccess(token))
+        }
+    }
+
+    async fn get_token_from_browser(
+        &self,
+        env: &WasmerEnv,
+    ) -> Result<AuthorizationState, anyhow::Error> {
+        let registry = env.registry_endpoint()?;
+
+        let client = RegistryClient::new(registry.clone(), None, None);
+
+        let (listener, server_url) = Self::setup_listener().await?;
+
+        let (server_shutdown_tx, mut server_shutdown_rx) = tokio::sync::mpsc::channel::<bool>(1);
+        let (token_tx, mut token_rx) = tokio::sync::mpsc::channel::<AuthorizationState>(1);
+
+        // Create a new AppContext
+        let app_context = AppContext {
+            server_shutdown_tx,
+            token_tx,
+        };
+
+        let NewNonceOutput { auth_url } =
+            wasmer_registry::api::create_nonce(&client, WASMER_CLI.to_string(), server_url).await?;
+
+        // if failed to open the browser, then don't error out just print the auth_url with a message
+        println!("Opening auth link in your default browser: {}", &auth_url);
+        opener::open_browser(&auth_url).unwrap_or_else(|_| {
+            println!(
+                "⚠️ Failed to open the browser.\n
+            Please open the url: {}",
+                &auth_url
+            );
+        });
+
+        // Create a new server
+        let make_svc = make_service_fn(move |_| {
+            let context = app_context.clone();
+
+            // Create a `Service` for responding to the request.
+            let service = service_fn(move |req| service_router(context.clone(), req));
+
+            // Return the service to hyper.
+            async move { Ok(service) }
+        });
+
+        print!("Waiting for session... ");
+
+        // start the server
+        Server::from_tcp(listener)?
+            .serve(make_svc)
+            .with_graceful_shutdown(async {
+                server_shutdown_rx.recv().await;
+            })
+            .await?;
+
+        // receive the token from the server
+        let token = token_rx
+            .recv()
+            .await
+            .ok_or_else(|| anyhow::anyhow!("❌ Failed to receive token from localhost"))?;
+
+        Ok(token)
+    }
+
+    fn wasmer_env(&self) -> WasmerEnv {
+        WasmerEnv::new(
+            self.wasmer_dir.clone(),
+            self.registry.clone(),
+            self.token.clone(),
+            self.cache_dir.clone(),
+        )
+    }
+
+    async fn setup_listener() -> Result<(TcpListener, String), anyhow::Error> {
+        let listener = TcpListener::bind("127.0.0.1:0")?;
+        let addr = listener.local_addr()?;
+        let port = addr.port();
+
+        let server_url = format!("http://localhost:{}", port);
+
+        Ok((listener, server_url))
+    }
+
+    /// execute [List]
+    #[tokio::main]
+    pub async fn execute(&self) -> Result<(), anyhow::Error> {
+        let env = self.wasmer_env();
+        let registry = env.registry_endpoint()?;
+
+        let auth_state = match self.token.clone() {
+            Some(token) => Ok(AuthorizationState::TokenSuccess(token)),
+            None => {
+                let person_wants_to_login =
+                    match wasmer_registry::whoami(env.dir(), Some(registry.as_str()), None) {
+                        std::result::Result::Ok((registry, user)) => {
+                            println!(
+                                "You are already logged in as {:?} on registry {:?}",
+                                user, registry
+                            );
+
+                            #[cfg(not(test))]
+                            {
+                                let login_again = Input::new()
+                                    .with_prompt(format!(
+                                        "{} {} - [y/{}]",
+                                        style("?").yellow().bold(),
+                                        style("Do you want to login again?").bright().bold(),
+                                        style("N").green().bold()
+                                    ))
+                                    .show_default(false)
+                                    .default(BoolPromptOptions::No)
+                                    .interact_text()?;
+
+                                login_again == BoolPromptOptions::Yes
+                            }
+                            #[cfg(test)]
+                            {
+                                false
+                            }
+                        }
+                        _ => true,
+                    };
+
+                if !person_wants_to_login {
+                    Ok(AuthorizationState::Cancelled)
+                } else if self.no_browser {
+                    self.get_token_or_ask_user(&env)
+                } else {
+                    // switch between two methods of getting the token.
+                    // start two async processes, 10 minute timeout and get token from browser. Whichever finishes first, use that.
+                    let timeout_future = tokio::time::sleep(Duration::from_secs(60 * 10));
+                    tokio::select! {
+                     _ = timeout_future => {
+                             Ok(AuthorizationState::TimedOut)
+                         },
+                         token = self.get_token_from_browser(&env) => {
+                            token
+                         }
+                    }
+                }
+            }
+        }?;
+
+        match auth_state {
+            AuthorizationState::TokenSuccess(token) => {
+                let res = std::thread::spawn({
+                    let dir = env.dir().to_owned();
+                    let registry = registry.clone();
+                    move || {
+                        wasmer_registry::login::login_and_save_token(
+                            &dir,
+                            registry.as_str(),
+                            &token,
+                        )
+                    }
+                })
+                .join()
+                .map_err(|err| anyhow::format_err!("handler thread died: {err:?}"))??;
+
+                match res {
+                    Some(s) => {
+                        print!("Done!");
+                        println!("\n✅ Login for Wasmer user {:?} saved", s)
+                    }
+                    None => print!(
+                        "Warning: no user found on {:?} with the provided token.\nToken saved regardless.",
+                        registry.domain().unwrap_or("registry.wasmer.io")
+                    ),
+                };
+            }
+            AuthorizationState::TimedOut => {
+                print!("Timed out (10 mins exceeded)");
+            }
+            AuthorizationState::Cancelled => {
+                println!("Cancelled by the user");
+            }
+            AuthorizationState::UnknownMethod => {
+                println!("Error: unknown method\n");
+            }
+        };
+        Ok(())
+    }
+}
+
+async fn preflight(req: Request<Body>) -> Result<Response<Body>, anyhow::Error> {
+    let _whole_body = hyper::body::aggregate(req).await?;
+    let response = Response::builder()
+        .status(StatusCode::OK)
+        .header("Access-Control-Allow-Origin", "*") // FIXME: this is not secure, Don't allow all origins. @syrusakbary
+        .header("Access-Control-Allow-Headers", "Content-Type")
+        .header("Access-Control-Allow-Methods", "POST, OPTIONS")
+        .body(Body::default())?;
+    Ok(response)
+}
+
+async fn handle_post_save_token(
+    context: AppContext,
+    req: Request<Body>,
+) -> Result<Response<Body>, anyhow::Error> {
+    let AppContext {
+        server_shutdown_tx,
+        token_tx,
+    } = context;
+    let (.., body) = req.into_parts();
+    let body = hyper::body::to_bytes(body).await?;
+
+    let ValidatedNonceOutput {
+        token,
+        status: token_status,
+    } = serde_json::from_slice::<ValidatedNonceOutput>(&body)?;
+
+    // send the AuthorizationState based on token_status to the main thread and get the response message
+    let (response_message, parse_failure) = match token_status {
+        TokenStatus::Cancelled => {
+            token_tx
+                .send(AuthorizationState::Cancelled)
+                .await
+                .expect("Failed to send token");
+
+            ("Token Cancelled by the user", false)
+        }
+        TokenStatus::Authorized => {
+            if let Some(token) = token {
+                token_tx
+                    .send(AuthorizationState::TokenSuccess(token.clone()))
+                    .await
+                    .expect("Failed to send token");
+                ("Token Authorized", false)
+            } else {
+                ("Token not found", true)
+            }
+        }
+    };
+
+    server_shutdown_tx
+        .send(true)
+        .await
+        .expect("Failed to send shutdown signal");
+
+    let status = if parse_failure {
+        StatusCode::BAD_REQUEST
+    } else {
+        StatusCode::OK
+    };
+
+    Ok(Response::builder()
+        .status(status)
+        .header("Access-Control-Allow-Origin", "*") // FIXME: this is not secure, Don't allow all origins. @syrusakbary
+        .header("Access-Control-Allow-Headers", "Content-Type")
+        .header("Access-Control-Allow-Methods", "POST, OPTIONS")
+        .body(Body::from(response_message))?)
+}
+
+async fn handle_unknown_method(context: AppContext) -> Result<Response<Body>, anyhow::Error> {
+    let AppContext {
+        server_shutdown_tx,
+        token_tx,
+    } = context;
+
+    token_tx
+        .send(AuthorizationState::UnknownMethod)
+        .await
+        .expect("Failed to send token");
+
+    server_shutdown_tx
+        .send(true)
+        .await
+        .expect("Failed to send shutdown signal");
+
+    Ok(Response::builder()
+        .status(StatusCode::METHOD_NOT_ALLOWED)
+        .body(Body::from("Method not allowed"))?)
+}
+
+/// Handle the preflight headers first - OPTIONS request
+/// Then proceed to handle the actual request - POST request
+async fn service_router(
+    context: AppContext,
+    req: Request<Body>,
+) -> Result<Response<Body>, anyhow::Error> {
+    match *req.method() {
+        Method::OPTIONS => preflight(req).await,
+        Method::POST => handle_post_save_token(context, req).await,
+        _ => handle_unknown_method(context).await,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use clap::CommandFactory;
+    use tempfile::TempDir;
+
+    use super::*;
+
+    #[test]
+    fn interactive_login() {
+        let temp = TempDir::new().unwrap();
+        let login = Login {
+            no_browser: true,
+            registry: Some("wasmer.wtf".into()),
+            wasmer_dir: temp.path().to_path_buf(),
+            token: None,
+            cache_dir: None,
+        };
+        let env = login.wasmer_env();
+
+        let token = login.get_token_or_ask_user(&env).unwrap();
+        match token {
+            AuthorizationState::TokenSuccess(token) => {
+                assert_eq!(
+                    token,
+                    "Please paste the login token from https://wasmer.wtf/settings/access-tokens"
+                );
+            }
+            AuthorizationState::Cancelled
+            | AuthorizationState::TimedOut
+            | AuthorizationState::UnknownMethod => {
+                panic!("Should not reach here")
+            }
+        }
+    }
+
+    #[test]
+    fn login_with_token() {
+        let temp = TempDir::new().unwrap();
+        let login = Login {
+            no_browser: true,
+            registry: Some("wasmer.wtf".into()),
+            wasmer_dir: temp.path().to_path_buf(),
+            token: Some("abc".to_string()),
+            cache_dir: None,
+        };
+        let env = login.wasmer_env();
+
+        let token = login.get_token_or_ask_user(&env).unwrap();
+
+        match token {
+            AuthorizationState::TokenSuccess(token) => {
+                assert_eq!(token, "abc");
+            }
+            AuthorizationState::Cancelled
+            | AuthorizationState::TimedOut
+            | AuthorizationState::UnknownMethod => {
+                panic!("Should not reach here")
+            }
+        }
+    }
+
+    #[test]
+    fn in_sync_with_wasmer_env() {
+        let wasmer_env = WasmerEnv::command();
+        let login = Login::command();
+
+        // All options except --token should be the same
+        let wasmer_env_opts: Vec<_> = wasmer_env
+            .get_opts()
+            .filter(|arg| arg.get_id() != "token")
+            .collect();
+        let login_opts: Vec<_> = login.get_opts().collect();
+
+        assert_eq!(wasmer_env_opts, login_opts);
+
+        // The token argument should have the same message, even if it is an
+        // argument rather than a --flag.
+        let wasmer_env_token_help = wasmer_env
+            .get_opts()
+            .find(|arg| arg.get_id() == "token")
+            .unwrap()
+            .get_help()
+            .unwrap()
+            .to_string();
+        let login_token_help = login
+            .get_positionals()
+            .find(|arg| arg.get_id() == "token")
+            .unwrap()
+            .get_help()
+            .unwrap()
+            .to_string();
+        assert_eq!(wasmer_env_token_help, login_token_help);
+    }
+
+    /// Regression test for panics on API errors.
+    /// See https://github.com/wasmerio/wasmer/issues/4147.
+    #[test]
+    fn login_with_invalid_token_does_not_panic() {
+        let cmd = Login {
+            no_browser: true,
+            wasmer_dir: WASMER_DIR.clone(),
+            registry: Some("http://localhost:11".to_string().into()),
+            token: Some("invalid".to_string()),
+            cache_dir: None,
+        };
+
+        let res = cmd.execute();
+        assert!(res.is_err());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/mod.rs
new file mode 100644
index 0000000..18706fa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/mod.rs
@@ -0,0 +1,412 @@
+//! The commands available in the Wasmer binary.
+mod add;
+mod app;
+#[cfg(target_os = "linux")]
+mod binfmt;
+mod cache;
+#[cfg(feature = "compiler")]
+mod compile;
+mod config;
+mod connect;
+mod container;
+#[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+mod create_exe;
+#[cfg(feature = "static-artifact-create")]
+mod create_obj;
+pub(crate) mod deploy;
+pub(crate) mod domain;
+#[cfg(feature = "static-artifact-create")]
+mod gen_c_header;
+mod init;
+mod inspect;
+#[cfg(feature = "journal")]
+mod journal;
+mod login;
+pub(crate) mod namespace;
+mod package;
+mod publish;
+mod run;
+mod self_update;
+pub mod ssh;
+mod validate;
+#[cfg(feature = "wast")]
+mod wast;
+mod whoami;
+
+#[cfg(target_os = "linux")]
+pub use binfmt::*;
+use clap::{CommandFactory, Parser};
+#[cfg(feature = "compiler")]
+pub use compile::*;
+#[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+pub use create_exe::*;
+#[cfg(feature = "wast")]
+pub use wast::*;
+#[cfg(feature = "static-artifact-create")]
+pub use {create_obj::*, gen_c_header::*};
+
+#[cfg(feature = "journal")]
+pub use self::journal::*;
+pub use self::{
+    add::*, cache::*, config::*, container::*, init::*, inspect::*, login::*, package::*,
+    publish::*, run::Run, self_update::*, validate::*, whoami::*,
+};
+use crate::error::PrettyError;
+
+/// An executable CLI command.
+pub(crate) trait CliCommand {
+    type Output;
+
+    fn run(self) -> Result<(), anyhow::Error>;
+}
+
+/// An executable CLI command that runs in an async context.
+///
+/// An [`AsyncCliCommand`] automatically implements [`CliCommand`] by creating
+/// a new tokio runtime and blocking.
+#[async_trait::async_trait]
+pub(crate) trait AsyncCliCommand: Send + Sync {
+    type Output: Send + Sync;
+
+    async fn run_async(self) -> Result<Self::Output, anyhow::Error>;
+}
+
+impl<O: Send + Sync, C: AsyncCliCommand<Output = O>> CliCommand for C {
+    type Output = O;
+
+    fn run(self) -> Result<(), anyhow::Error> {
+        tokio::runtime::Runtime::new()?.block_on(AsyncCliCommand::run_async(self))?;
+        Ok(())
+    }
+}
+
+/// Command-line arguments for the Wasmer CLI.
+#[derive(clap::Parser, Debug)]
+#[clap(author, version)]
+#[clap(disable_version_flag = true)] // handled manually
+#[cfg_attr(feature = "headless", clap(
+    name = "wasmer-headless",
+    about = concat!("wasmer-headless ", env!("CARGO_PKG_VERSION")),
+))]
+#[cfg_attr(not(feature = "headless"), clap(
+    name = "wasmer",
+    about = concat!("wasmer ", env!("CARGO_PKG_VERSION")),
+))]
+pub struct WasmerCmd {
+    /// Print version info and exit.
+    #[clap(short = 'V', long)]
+    version: bool,
+    #[clap(flatten)]
+    output: crate::logging::Output,
+    #[clap(subcommand)]
+    cmd: Option<Cmd>,
+}
+
+impl WasmerCmd {
+    fn execute(self) -> Result<(), anyhow::Error> {
+        let WasmerCmd {
+            cmd,
+            version,
+            output,
+        } = self;
+
+        output.initialize_logging();
+
+        if version {
+            return print_version(output.is_verbose());
+        }
+
+        match cmd {
+            Some(Cmd::Run(options)) => options.execute(output),
+            Some(Cmd::SelfUpdate(options)) => options.execute(),
+            Some(Cmd::Cache(cache)) => cache.execute(),
+            Some(Cmd::Validate(validate)) => validate.execute(),
+            #[cfg(feature = "compiler")]
+            Some(Cmd::Compile(compile)) => compile.execute(),
+            #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+            Some(Cmd::CreateExe(create_exe)) => create_exe.execute(),
+            #[cfg(feature = "static-artifact-create")]
+            Some(Cmd::CreateObj(create_obj)) => create_obj.execute(),
+            Some(Cmd::Config(config)) => config.execute(),
+            Some(Cmd::Inspect(inspect)) => inspect.execute(),
+            Some(Cmd::Init(init)) => init.execute(),
+            Some(Cmd::Login(login)) => login.execute(),
+            Some(Cmd::Publish(publish)) => publish.execute(),
+            Some(Cmd::Package(cmd)) => match cmd {
+                Package::Download(cmd) => cmd.execute(),
+                Package::Build(cmd) => cmd.execute(),
+            },
+            Some(Cmd::Container(cmd)) => match cmd {
+                crate::commands::Container::Unpack(cmd) => cmd.execute(),
+            },
+            /*
+            Some(Cmd::Connect(connect)) => connect.execute(),
+            */
+            #[cfg(feature = "static-artifact-create")]
+            Some(Cmd::GenCHeader(gen_heder)) => gen_heder.execute(),
+            #[cfg(feature = "wast")]
+            Some(Cmd::Wast(wast)) => wast.execute(),
+            #[cfg(target_os = "linux")]
+            Some(Cmd::Binfmt(binfmt)) => binfmt.execute(),
+            Some(Cmd::Whoami(whoami)) => whoami.execute(),
+            Some(Cmd::Add(install)) => install.execute(),
+
+            // Deploy commands.
+            Some(Cmd::Deploy(c)) => c.run(),
+            Some(Cmd::App(apps)) => apps.run(),
+            #[cfg(feature = "journal")]
+            Some(Cmd::Journal(journal)) => journal.run(),
+            Some(Cmd::Ssh(ssh)) => ssh.run(),
+            Some(Cmd::Namespace(namespace)) => namespace.run(),
+            Some(Cmd::Domain(namespace)) => namespace.run(),
+            None => {
+                WasmerCmd::command().print_long_help()?;
+                // Note: clap uses an exit code of 2 when CLI parsing fails
+                std::process::exit(2);
+            }
+        }
+    }
+
+    /// The main function for the Wasmer CLI tool.
+    pub fn run() {
+        // We allow windows to print properly colors
+        #[cfg(windows)]
+        colored::control::set_virtual_terminal(true).unwrap();
+
+        PrettyError::report(Self::run_inner())
+    }
+
+    fn run_inner() -> Result<(), anyhow::Error> {
+        if is_binfmt_interpreter() {
+            Run::from_binfmt_args().execute(crate::logging::Output::default());
+        }
+
+        match WasmerCmd::try_parse() {
+            Ok(args) => args.execute(),
+            Err(e) => {
+                let might_be_wasmer_run = matches!(
+                    e.kind(),
+                    clap::error::ErrorKind::InvalidSubcommand
+                        | clap::error::ErrorKind::UnknownArgument
+                );
+
+                if might_be_wasmer_run {
+                    if let Ok(run) = Run::try_parse() {
+                        // Try to parse the command using the `wasmer some/package`
+                        // shorthand. Note that this has discoverability issues
+                        // because it's not shown as part of the main argument
+                        // parser's help, but that's fine.
+                        let output = crate::logging::Output::default();
+                        output.initialize_logging();
+                        run.execute(output);
+                    }
+                }
+
+                e.exit();
+            }
+        }
+    }
+}
+
+#[derive(clap::Parser, Debug)]
+#[allow(clippy::large_enum_variant)]
+/// The options for the wasmer Command Line Interface
+enum Cmd {
+    /// Login into a wasmer.io-like registry
+    Login(Login),
+
+    /// Login into a wasmer.io-like registry
+    #[clap(name = "publish")]
+    Publish(Publish),
+
+    /// Wasmer cache
+    Cache(Cache),
+
+    /// Validate a WebAssembly binary
+    Validate(Validate),
+
+    /// Compile a WebAssembly binary
+    #[cfg(feature = "compiler")]
+    Compile(Compile),
+
+    /// Compile a WebAssembly binary into a native executable
+    ///
+    /// To use, you need to set the `WASMER_DIR` environment variable
+    /// to the location of your Wasmer installation. This will probably be `~/.wasmer`. It
+    /// should include a `lib`, `include` and `bin` subdirectories. To create an executable
+    /// you will need `libwasmer`, so by setting `WASMER_DIR` the CLI knows where to look for
+    /// header files and libraries.
+    ///
+    /// Example usage:
+    ///
+    /// ```text
+    /// $ # in two lines:
+    /// $ export WASMER_DIR=/home/user/.wasmer/
+    /// $ wasmer create-exe qjs.wasm -o qjs.exe # or in one line:
+    /// $ WASMER_DIR=/home/user/.wasmer/ wasmer create-exe qjs.wasm -o qjs.exe
+    /// $ file qjs.exe
+    /// qjs.exe: ELF 64-bit LSB pie executable, x86-64 ...
+    /// ```
+    ///
+    /// ## Cross-compilation
+    ///
+    /// Accepted target triple values must follow the
+    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    ///
+    /// The recommended targets we try to support are:
+    ///
+    /// - "x86_64-linux-gnu"
+    /// - "aarch64-linux-gnu"
+    /// - "x86_64-apple-darwin"
+    /// - "arm64-apple-darwin"
+    #[cfg(any(feature = "static-artifact-create", feature = "wasmer-artifact-create"))]
+    #[clap(name = "create-exe", verbatim_doc_comment)]
+    CreateExe(CreateExe),
+
+    /// Compile a WebAssembly binary into an object file
+    ///
+    /// To use, you need to set the `WASMER_DIR` environment variable to the location of your
+    /// Wasmer installation. This will probably be `~/.wasmer`. It should include a `lib`,
+    /// `include` and `bin` subdirectories. To create an object you will need `libwasmer`, so by
+    /// setting `WASMER_DIR` the CLI knows where to look for header files and libraries.
+    ///
+    /// Example usage:
+    ///
+    /// ```text
+    /// $ # in two lines:
+    /// $ export WASMER_DIR=/home/user/.wasmer/
+    /// $ wasmer create-obj qjs.wasm --object-format symbols -o qjs.obj # or in one line:
+    /// $ WASMER_DIR=/home/user/.wasmer/ wasmer create-exe qjs.wasm --object-format symbols -o qjs.obj
+    /// $ file qjs.obj
+    /// qjs.obj: ELF 64-bit LSB relocatable, x86-64 ...
+    /// ```
+    ///
+    /// ## Cross-compilation
+    ///
+    /// Accepted target triple values must follow the
+    /// ['target_lexicon'](https://crates.io/crates/target-lexicon) crate format.
+    ///
+    /// The recommended targets we try to support are:
+    ///
+    /// - "x86_64-linux-gnu"
+    /// - "aarch64-linux-gnu"
+    /// - "x86_64-apple-darwin"
+    /// - "arm64-apple-darwin"
+    #[cfg(feature = "static-artifact-create")]
+    #[structopt(name = "create-obj", verbatim_doc_comment)]
+    CreateObj(CreateObj),
+
+    /// Generate the C static_defs.h header file for the input .wasm module
+    #[cfg(feature = "static-artifact-create")]
+    GenCHeader(GenCHeader),
+
+    /// Get various configuration information needed
+    /// to compile programs which use Wasmer
+    Config(Config),
+
+    /// Update wasmer to the latest version
+    #[clap(name = "self-update")]
+    SelfUpdate(SelfUpdate),
+
+    /// Inspect a WebAssembly file
+    Inspect(Inspect),
+
+    /// Initializes a new wasmer.toml file
+    #[clap(name = "init")]
+    Init(Init),
+
+    /// Run spec testsuite
+    #[cfg(feature = "wast")]
+    Wast(Wast),
+
+    /// Unregister and/or register wasmer as binfmt interpreter
+    #[cfg(target_os = "linux")]
+    Binfmt(Binfmt),
+
+    /// Shows the current logged in user for the current active registry
+    Whoami(Whoami),
+
+    /// Add a Wasmer package's bindings to your application.
+    Add(Add),
+
+    /// Run a WebAssembly file or Wasmer container.
+    #[clap(alias = "run-unstable")]
+    Run(Run),
+
+    /// Manage journals (compacting, inspecting, filtering, ...)
+    #[cfg(feature = "journal")]
+    #[clap(subcommand)]
+    Journal(CmdJournal),
+
+    #[clap(subcommand)]
+    Package(crate::commands::Package),
+
+    #[clap(subcommand)]
+    Container(crate::commands::Container),
+
+    // Edge commands
+    /// Deploy apps to Wasmer Edge.
+    Deploy(crate::commands::deploy::CmdDeploy),
+
+    /// Manage deployed Edge apps.
+    #[clap(subcommand, alias = "apps")]
+    App(crate::commands::app::CmdApp),
+
+    /// Run commands/packages on Wasmer Edge in an interactive shell session.
+    Ssh(crate::commands::ssh::CmdSsh),
+
+    /// Manage Wasmer namespaces.
+    #[clap(subcommand, alias = "namespaces")]
+    Namespace(crate::commands::namespace::CmdNamespace),
+
+    /// Manage DNS records
+    #[clap(subcommand, alias = "domains")]
+    Domain(crate::commands::domain::CmdDomain),
+}
+
+fn is_binfmt_interpreter() -> bool {
+    cfg_if::cfg_if! {
+        if #[cfg(target_os = "linux")] {
+            // Note: we'll be invoked by the kernel as Binfmt::FILENAME
+            let binary_path = match std::env::args_os().next() {
+                Some(path) => std::path::PathBuf::from(path),
+                None => return false,
+            };
+            binary_path.file_name().and_then(|f| f.to_str()) == Some(Binfmt::FILENAME)
+        } else {
+            false
+        }
+    }
+}
+
+fn print_version(verbose: bool) -> Result<(), anyhow::Error> {
+    if !verbose {
+        println!("wasmer {}", env!("CARGO_PKG_VERSION"));
+        return Ok(());
+    }
+
+    println!(
+        "wasmer {} ({} {})",
+        env!("CARGO_PKG_VERSION"),
+        env!("WASMER_BUILD_GIT_HASH_SHORT"),
+        env!("WASMER_BUILD_DATE")
+    );
+    println!("binary: {}", env!("CARGO_PKG_NAME"));
+    println!("commit-hash: {}", env!("WASMER_BUILD_GIT_HASH"));
+    println!("commit-date: {}", env!("WASMER_BUILD_DATE"));
+    println!("host: {}", target_lexicon::HOST);
+
+    let mut compilers = Vec::<&'static str>::new();
+    if cfg!(feature = "singlepass") {
+        compilers.push("singlepass");
+    }
+    if cfg!(feature = "cranelift") {
+        compilers.push("cranelift");
+    }
+    if cfg!(feature = "llvm") {
+        compilers.push("llvm");
+    }
+    println!("compiler: {}", compilers.join(","));
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/create.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/create.rs
new file mode 100644
index 0000000..b7d2be5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/create.rs
@@ -0,0 +1,39 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Create a new namespace.
+#[derive(clap::Parser, Debug)]
+pub struct CmdNamespaceCreate {
+    #[clap(flatten)]
+    fmt: ItemFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Description of the namespace.
+    #[clap(long)]
+    description: Option<String>,
+
+    /// Name of the namespace.
+    name: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdNamespaceCreate {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let vars = wasmer_api::types::CreateNamespaceVars {
+            name: self.name.clone(),
+            description: self.description.clone(),
+        };
+        let namespace = wasmer_api::query::create_namespace(&client, vars).await?;
+
+        println!("{}", self.fmt.format.render(&namespace));
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/get.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/get.rs
new file mode 100644
index 0000000..1ae680f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/get.rs
@@ -0,0 +1,35 @@
+use anyhow::Context;
+
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ItemFormatOpts},
+};
+
+/// Show a namespace.
+#[derive(clap::Parser, Debug)]
+pub struct CmdNamespaceGet {
+    #[clap(flatten)]
+    fmt: ItemFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+
+    /// Name of the namespace.
+    name: String,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdNamespaceGet {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let namespace = wasmer_api::query::get_namespace(&client, self.name)
+            .await?
+            .context("namespace not found")?;
+
+        println!("{}", self.fmt.format.render(&namespace));
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/list.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/list.rs
new file mode 100644
index 0000000..7804cb8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/list.rs
@@ -0,0 +1,28 @@
+use crate::{
+    commands::AsyncCliCommand,
+    opts::{ApiOpts, ListFormatOpts},
+};
+
+/// List namespaces.
+#[derive(clap::Parser, Debug)]
+pub struct CmdNamespaceList {
+    #[clap(flatten)]
+    fmt: ListFormatOpts,
+    #[clap(flatten)]
+    api: ApiOpts,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdNamespaceList {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let client = self.api.client()?;
+
+        let namespaces = wasmer_api::query::user_namespaces(&client).await?;
+
+        println!("{}", self.fmt.format.render(&namespaces));
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/mod.rs
new file mode 100644
index 0000000..ce0ec34
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/namespace/mod.rs
@@ -0,0 +1,24 @@
+pub mod create;
+pub mod get;
+pub mod list;
+
+use crate::commands::AsyncCliCommand;
+
+/// Manage namespaces.
+#[derive(clap::Subcommand, Debug)]
+pub enum CmdNamespace {
+    Get(get::CmdNamespaceGet),
+    List(list::CmdNamespaceList),
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdNamespace {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        match self {
+            CmdNamespace::List(cmd) => cmd.run_async().await,
+            CmdNamespace::Get(cmd) => cmd.run_async().await,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/build.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/build.rs
new file mode 100644
index 0000000..6f4e564
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/build.rs
@@ -0,0 +1,198 @@
+use std::path::PathBuf;
+
+use anyhow::Context;
+use dialoguer::console::{style, Emoji};
+use indicatif::ProgressBar;
+
+/// Build a container from a package manifest.
+#[derive(clap::Parser, Debug)]
+pub struct PackageBuild {
+    /// Output path for the package file.
+    /// Defaults to current directory + [name]-[version].webc.
+    #[clap(short = 'o', long)]
+    out: Option<PathBuf>,
+
+    /// Run the publish command without any output
+    #[clap(long)]
+    pub quiet: bool,
+
+    /// Path of the package or wasmer.toml manifest.
+    ///
+    /// Defaults to current directory.
+    package: Option<PathBuf>,
+
+    /// Only checks whether the package could be built successfully
+    #[clap(long)]
+    check: bool,
+}
+
+static READING_MANIFEST_EMOJI: Emoji<'_, '_> = Emoji("📖 ", "");
+static CREATING_OUTPUT_DIRECTORY_EMOJI: Emoji<'_, '_> = Emoji("📁 ", "");
+static WRITING_PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("📦 ", "");
+static SPARKLE: Emoji<'_, '_> = Emoji("✨ ", ":-)");
+
+impl PackageBuild {
+    pub(crate) fn check(package_path: PathBuf) -> Self {
+        PackageBuild {
+            out: None,
+            quiet: true,
+            package: Some(package_path),
+            check: true,
+        }
+    }
+
+    pub(crate) fn execute(&self) -> Result<(), anyhow::Error> {
+        let manifest_path = self.manifest_path()?;
+        let pkg = webc::wasmer_package::Package::from_manifest(manifest_path)?;
+
+        // Setup the progress bar
+        let pb = if self.quiet {
+            ProgressBar::hidden()
+        } else {
+            ProgressBar::new_spinner()
+        };
+
+        pb.println(format!(
+            "{} {}Reading manifest...",
+            style("[1/3]").bold().dim(),
+            READING_MANIFEST_EMOJI
+        ));
+
+        let manifest = pkg
+            .manifest()
+            .wapm()
+            .context("could not load package manifest")?
+            .context("package does not contain a Wasmer manifest")?;
+
+        // rest of the code writes the package to disk and is irrelevant
+        // to checking.
+        if self.check {
+            return Ok(());
+        }
+
+        let pkgname = manifest.name.replace('/', "-");
+        let name = format!("{}-{}.webc", pkgname, manifest.version,);
+
+        pb.println(format!(
+            "{} {}Creating output directory...",
+            style("[2/3]").bold().dim(),
+            CREATING_OUTPUT_DIRECTORY_EMOJI
+        ));
+
+        let out_path = if let Some(p) = &self.out {
+            if p.is_dir() {
+                p.join(name)
+            } else {
+                if let Some(parent) = p.parent() {
+                    std::fs::create_dir_all(parent).context("could not create output directory")?;
+                }
+
+                p.to_owned()
+            }
+        } else {
+            std::env::current_dir()
+                .context("could not determine current directory")?
+                .join(name)
+        };
+
+        if out_path.exists() {
+            anyhow::bail!(
+                "Output path '{}' already exists - specify a different path with -o/--out",
+                out_path.display()
+            );
+        }
+
+        let data = pkg.serialize()?;
+
+        pb.println(format!(
+            "{} {}Writing package...",
+            style("[3/3]").bold().dim(),
+            WRITING_PACKAGE_EMOJI
+        ));
+
+        std::fs::write(&out_path, &data)
+            .with_context(|| format!("could not write contents to '{}'", out_path.display()))?;
+
+        pb.finish_with_message(format!(
+            "{} Package written to '{}'",
+            SPARKLE,
+            out_path.display()
+        ));
+
+        Ok(())
+    }
+
+    fn manifest_path(&self) -> Result<PathBuf, anyhow::Error> {
+        let path = if let Some(p) = &self.package {
+            if p.is_dir() {
+                let manifest_path = p.join("wasmer.toml");
+                if !manifest_path.is_file() {
+                    anyhow::bail!(
+                        "Specified directory '{}' does not contain a wasmer.toml manifest",
+                        p.display()
+                    );
+                }
+                manifest_path
+            } else if p.is_file() {
+                p.clone()
+            } else {
+                anyhow::bail!(
+                    "Specified path '{}' is not a file or directory",
+                    p.display()
+                );
+            }
+        } else {
+            let dir = std::env::current_dir().context("could not get current directory")?;
+            let manifest_path = dir.join("wasmer.toml");
+            if !manifest_path.is_file() {
+                anyhow::bail!(
+                    "Current directory '{}' does not contain a wasmer.toml manifest - specify a path with --package-dir",
+                    dir.display()
+                );
+            }
+            manifest_path
+        };
+
+        Ok(path)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Download a package from the dev registry.
+    #[test]
+    fn test_cmd_package_build() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path();
+
+        std::fs::write(
+            path.join("wasmer.toml"),
+            r#"
+[package]
+name = "wasmer/hello"
+version = "0.1.0"
+description = "hello"
+
+[fs]
+"data" = "data"
+"#,
+        )
+        .unwrap();
+
+        std::fs::create_dir(path.join("data")).unwrap();
+        std::fs::write(path.join("data").join("hello.txt"), "Hello, world!").unwrap();
+
+        let cmd = PackageBuild {
+            package: Some(path.to_owned()),
+            out: Some(path.to_owned()),
+            quiet: true,
+            check: false,
+        };
+
+        cmd.execute().unwrap();
+
+        webc::Container::from_disk(path.join("wasmer-hello-0.1.0.webc")).unwrap();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/download.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/download.rs
new file mode 100644
index 0000000..d0dd430
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/download.rs
@@ -0,0 +1,261 @@
+use std::path::PathBuf;
+
+use anyhow::{bail, Context};
+use dialoguer::console::{style, Emoji};
+use indicatif::{ProgressBar, ProgressStyle};
+use tempfile::NamedTempFile;
+use wasmer_registry::wasmer_env::WasmerEnv;
+use wasmer_wasix::runtime::resolver::PackageSpecifier;
+
+/// Download a package from the registry.
+#[derive(clap::Parser, Debug)]
+pub struct PackageDownload {
+    #[clap(flatten)]
+    env: WasmerEnv,
+
+    /// Verify that the downloaded file is a valid package.
+    #[clap(long)]
+    validate: bool,
+
+    /// Path where the package file should be written to.
+    /// If not specified, the data will be written to stdout.
+    #[clap(short = 'o', long)]
+    out_path: PathBuf,
+
+    /// Run the download command without any output
+    #[clap(long)]
+    pub quiet: bool,
+
+    /// The package to download.
+    /// Can be:
+    /// * a pakage specifier: `namespace/package[@vesion]`
+    /// * a URL
+    package: PackageSpecifier,
+}
+
+static CREATING_OUTPUT_DIRECTORY_EMOJI: Emoji<'_, '_> = Emoji("📁 ", "");
+static DOWNLOADING_PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("🌐 ", "");
+static RETRIEVING_PACKAGE_INFORMATION_EMOJI: Emoji<'_, '_> = Emoji("📜 ", "");
+static VALIDATING_PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("🔍 ", "");
+static WRITING_PACKAGE_EMOJI: Emoji<'_, '_> = Emoji("📦 ", "");
+
+impl PackageDownload {
+    pub(crate) fn execute(&self) -> Result<(), anyhow::Error> {
+        let total_steps = if self.validate { 5 } else { 4 };
+        let mut step_num = 1;
+
+        // Setup the progress bar
+        let pb = if self.quiet {
+            ProgressBar::hidden()
+        } else {
+            ProgressBar::new_spinner()
+        };
+
+        pb.set_style(ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({bytes_per_sec}, {eta})")
+                                .unwrap()
+                                .progress_chars("#>-"));
+
+        pb.println(format!(
+            "{} {}Creating output directory...",
+            style(format!("[{}/{}]", step_num, total_steps))
+                .bold()
+                .dim(),
+            CREATING_OUTPUT_DIRECTORY_EMOJI,
+        ));
+
+        step_num += 1;
+
+        if let Some(parent) = self.out_path.parent() {
+            match parent.metadata() {
+                Ok(m) => {
+                    if !m.is_dir() {
+                        bail!(
+                            "parent of output file is not a directory: '{}'",
+                            parent.display()
+                        );
+                    }
+                }
+                Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                    std::fs::create_dir_all(parent)
+                        .context("could not create parent directory of output file")?;
+                }
+                Err(err) => return Err(err.into()),
+            }
+        };
+
+        pb.println(format!(
+            "{} {}Retrieving package information...",
+            style(format!("[{}/{}]", step_num, total_steps))
+                .bold()
+                .dim(),
+            RETRIEVING_PACKAGE_INFORMATION_EMOJI
+        ));
+
+        step_num += 1;
+
+        let (full_name, version, api_endpoint, token) = match &self.package {
+            PackageSpecifier::Registry { full_name, version } => {
+                let endpoint = self.env.registry_endpoint()?;
+                let version = version.to_string();
+                let version = if version == "*" { None } else { Some(version) };
+
+                (
+                    full_name,
+                    version,
+                    endpoint,
+                    self.env.get_token_opt().map(|x| x.to_string()),
+                )
+            }
+            PackageSpecifier::Url(url) => {
+                bail!("cannot download a package from a URL: '{}'", url);
+            }
+            PackageSpecifier::Path(_) => {
+                bail!("cannot download a package from a local path");
+            }
+        };
+
+        let package = wasmer_registry::query_package_from_registry(
+            api_endpoint.as_str(),
+            full_name,
+            version.as_deref(),
+            token.as_deref(),
+        )
+        .with_context(|| {
+            format!(
+                "could not retrieve package information for package '{}' from registry '{}'",
+                full_name, api_endpoint,
+            )
+        })?;
+
+        let download_url = package
+            .pirita_url
+            .context("registry does provide a container download container download URL")?;
+
+        let client = reqwest::blocking::Client::new();
+        let mut b = client
+            .get(download_url)
+            .header(http::header::ACCEPT, "application/webc");
+        if let Some(token) = token {
+            b = b.header(http::header::AUTHORIZATION, format!("Bearer {token}"));
+        };
+
+        pb.println(format!(
+            "{} {}Downloading package...",
+            style(format!("[{}/{}]", step_num, total_steps))
+                .bold()
+                .dim(),
+            DOWNLOADING_PACKAGE_EMOJI
+        ));
+
+        step_num += 1;
+
+        let res = b
+            .send()
+            .context("http request failed")?
+            .error_for_status()
+            .context("http request failed with non-success status code")?;
+
+        let webc_total_size = res
+            .headers()
+            .get(http::header::CONTENT_LENGTH)
+            .and_then(|t| t.to_str().ok())
+            .and_then(|t| t.parse::<u64>().ok())
+            .unwrap_or_default();
+
+        if webc_total_size == 0 {
+            bail!("Package is empty");
+        }
+
+        // Set the length of the progress bar
+        pb.set_length(webc_total_size);
+
+        let mut tmpfile = NamedTempFile::new_in(self.out_path.parent().unwrap())?;
+        let accepted_contenttypes = vec![
+            "application/webc",
+            "application/octet-stream",
+            "application/wasm",
+        ];
+        let ty = res
+            .headers()
+            .get(http::header::CONTENT_TYPE)
+            .and_then(|t| t.to_str().ok())
+            .unwrap_or_default();
+        if !(accepted_contenttypes.contains(&ty)) {
+            eprintln!(
+                "Warning: response has invalid content type - expected \
+                 one of {:?}, got {ty}",
+                accepted_contenttypes
+            );
+        }
+
+        std::io::copy(&mut pb.wrap_read(res), &mut tmpfile)
+            .context("could not write downloaded data to temporary file")?;
+
+        tmpfile.as_file_mut().sync_all()?;
+
+        if self.validate {
+            if !self.quiet {
+                println!(
+                    "{} {}Validating package...",
+                    style(format!("[{}/{}]", step_num, total_steps))
+                        .bold()
+                        .dim(),
+                    VALIDATING_PACKAGE_EMOJI
+                );
+            }
+
+            step_num += 1;
+
+            webc::compat::Container::from_disk(tmpfile.path())
+                .context("could not parse downloaded file as a package - invalid download?")?;
+        }
+
+        tmpfile.persist(&self.out_path).with_context(|| {
+            format!(
+                "could not persist temporary file to '{}'",
+                self.out_path.display()
+            )
+        })?;
+
+        pb.println(format!(
+            "{} {}Package downloaded to '{}'",
+            style(format!("[{}/{}]", step_num, total_steps))
+                .bold()
+                .dim(),
+            WRITING_PACKAGE_EMOJI,
+            self.out_path.display()
+        ));
+
+        // We're done, so finish the progress bar
+        pb.finish();
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use wasmer_registry::wasmer_env::WASMER_DIR;
+
+    use super::*;
+
+    /// Download a package from the dev registry.
+    #[test]
+    fn test_cmd_package_download() {
+        let dir = tempfile::tempdir().unwrap();
+
+        let out_path = dir.path().join("hello.webc");
+
+        let cmd = PackageDownload {
+            env: WasmerEnv::new(WASMER_DIR.clone(), Some("wasmer.wtf".into()), None, None),
+            validate: true,
+            out_path: out_path.clone(),
+            package: "wasmer/hello@0.1.0".parse().unwrap(),
+            quiet: true,
+        };
+
+        cmd.execute().unwrap();
+
+        webc::compat::Container::from_disk(out_path).unwrap();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/mod.rs
new file mode 100644
index 0000000..0d616bc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/package/mod.rs
@@ -0,0 +1,15 @@
+mod build;
+mod download;
+
+pub use build::PackageBuild;
+pub use download::PackageDownload;
+
+/// Package related commands.
+#[derive(clap::Subcommand, Debug)]
+// Allowing missing_docs because the comment would override the doc comment on
+// the command struct.
+#[allow(missing_docs)]
+pub enum Package {
+    Download(PackageDownload),
+    Build(build::PackageBuild),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/publish.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/publish.rs
new file mode 100644
index 0000000..4c129d0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/publish.rs
@@ -0,0 +1,114 @@
+use anyhow::Context as _;
+use clap::Parser;
+use wasmer_registry::{publish::PublishWait, wasmer_env::WasmerEnv};
+
+use super::PackageBuild;
+
+/// Publish a package to the package registry.
+#[derive(Debug, Parser)]
+pub struct Publish {
+    #[clap(flatten)]
+    env: WasmerEnv,
+    /// Run the publish logic without sending anything to the registry server
+    #[clap(long, name = "dry-run")]
+    pub dry_run: bool,
+    /// Run the publish command without any output
+    #[clap(long)]
+    pub quiet: bool,
+    /// Override the package of the uploaded package in the wasmer.toml
+    #[clap(long)]
+    pub package_name: Option<String>,
+    /// Override the package version of the uploaded package in the wasmer.toml
+    #[clap(long)]
+    pub version: Option<semver::Version>,
+    /// Skip validation of the uploaded package
+    #[clap(long)]
+    pub no_validate: bool,
+    /// Directory containing the `wasmer.toml`, or a custom *.toml manifest file.
+    ///
+    /// Defaults to current working directory.
+    #[clap(name = "PACKAGE_PATH")]
+    pub package_path: Option<String>,
+    /// Wait for package to be available on the registry before exiting.
+    #[clap(long)]
+    pub wait: bool,
+    /// Wait for the package and all dependencies to be available on the registry
+    /// before exiting.
+    ///
+    /// This includes the container, native executables and bindings.
+    #[clap(long)]
+    pub wait_all: bool,
+    /// Timeout (in seconds) for the publish query to the registry.
+    ///
+    /// Note that this is not the timeout for the entire publish process, but
+    /// for each individual query to the registry during the publish flow.
+    #[clap(long, default_value = "2m")]
+    pub timeout: humantime::Duration,
+}
+
+impl Publish {
+    /// Executes `wasmer publish`
+    pub fn execute(&self) -> Result<(), anyhow::Error> {
+        // first check if the package could be built successfuly
+        let package_path = match self.package_path.as_ref() {
+            Some(s) => std::env::current_dir()?.join(s),
+            None => std::env::current_dir()?,
+        };
+        PackageBuild::check(package_path).execute()?;
+
+        let token = self
+            .env
+            .token()
+            .context("could not determine auth token for registry - run 'wasmer login'")?;
+
+        let wait = if self.wait_all {
+            PublishWait::new_all()
+        } else if self.wait {
+            PublishWait::new_container()
+        } else {
+            PublishWait::new_none()
+        };
+
+        let publish = wasmer_registry::package::builder::Publish {
+            registry: self.env.registry_endpoint().map(|u| u.to_string()).ok(),
+            dry_run: self.dry_run,
+            quiet: self.quiet,
+            package_name: self.package_name.clone(),
+            version: self.version.clone(),
+            token,
+            no_validate: self.no_validate,
+            package_path: self.package_path.clone(),
+            wait,
+            timeout: self.timeout.into(),
+        };
+        publish.execute().map_err(on_error)?;
+
+        if let Err(e) = invalidate_graphql_query_cache(&self.env) {
+            tracing::warn!(
+                error = &*e,
+                "Unable to invalidate the cache used for package version queries",
+            );
+        }
+
+        Ok(())
+    }
+}
+
+fn on_error(e: anyhow::Error) -> anyhow::Error {
+    #[cfg(feature = "telemetry")]
+    sentry::integrations::anyhow::capture_anyhow(&e);
+
+    e
+}
+
+// HACK: We want to invalidate the cache used for GraphQL queries so
+// the current user sees the results of publishing immediately. There
+// are cleaner ways to achieve this, but for now we're just going to
+// clear out the whole GraphQL query cache.
+// See https://github.com/wasmerio/wasmer/pull/3983 for more
+fn invalidate_graphql_query_cache(env: &WasmerEnv) -> Result<(), anyhow::Error> {
+    let cache_dir = env.cache_dir().join("queries");
+    std::fs::remove_dir_all(cache_dir)?;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/mod.rs
new file mode 100644
index 0000000..7fcd32a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/mod.rs
@@ -0,0 +1,971 @@
+#![allow(missing_docs, unused)]
+
+mod wasi;
+
+use std::{
+    collections::BTreeMap,
+    fmt::{Binary, Display},
+    fs::File,
+    io::{ErrorKind, LineWriter, Read, Write},
+    net::SocketAddr,
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::{Arc, Mutex},
+    time::{Duration, SystemTime},
+};
+
+use anyhow::{bail, Context, Error};
+use clap::Parser;
+use indicatif::{MultiProgress, ProgressBar};
+use once_cell::sync::Lazy;
+use sha2::{Digest, Sha256};
+use tempfile::NamedTempFile;
+use url::Url;
+use wasmer::{
+    DeserializeError, Engine, Function, Imports, Instance, Module, Store, Type, TypedFunction,
+    Value,
+};
+#[cfg(feature = "compiler")]
+use wasmer_compiler::ArtifactBuild;
+use wasmer_registry::{wasmer_env::WasmerEnv, Package};
+#[cfg(feature = "journal")]
+use wasmer_wasix::journal::{LogFileJournal, SnapshotTrigger};
+use wasmer_wasix::{
+    bin_factory::BinaryPackage,
+    journal::CompactingLogFileJournal,
+    runners::{
+        dcgi::{DcgiInstanceFactory, DcgiRunner},
+        dproxy::DProxyRunner,
+        emscripten::EmscriptenRunner,
+        wasi::WasiRunner,
+        wcgi::{self, AbortHandle, NoOpWcgiCallbacks, WcgiRunner},
+        MappedCommand, MappedDirectory, Runner,
+    },
+    runtime::{
+        module_cache::{CacheError, ModuleHash},
+        package_loader::PackageLoader,
+        resolver::{PackageSpecifier, QueryError},
+        task_manager::VirtualTaskManagerExt,
+    },
+    Runtime, WasiError,
+};
+use webc::{metadata::Manifest, Container};
+
+use crate::{commands::run::wasi::Wasi, error::PrettyError, logging::Output, store::StoreOptions};
+
+const TICK: Duration = Duration::from_millis(250);
+
+/// The unstable `wasmer run` subcommand.
+#[derive(Debug, Parser)]
+pub struct Run {
+    #[clap(flatten)]
+    env: WasmerEnv,
+    #[clap(flatten)]
+    store: StoreOptions,
+    #[clap(flatten)]
+    wasi: crate::commands::run::Wasi,
+    #[clap(flatten)]
+    wcgi: WcgiOptions,
+    /// Set the default stack size (default is 1048576)
+    #[clap(long = "stack-size")]
+    stack_size: Option<usize>,
+    /// The function or command to invoke.
+    #[clap(short, long, aliases = &["command", "invoke", "command-name"])]
+    entrypoint: Option<String>,
+    /// Generate a coredump at this path if a WebAssembly trap occurs
+    #[clap(name = "COREDUMP PATH", long)]
+    coredump_on_trap: Option<PathBuf>,
+    /// The file, URL, or package to run.
+    #[clap(value_parser = PackageSource::infer)]
+    input: PackageSource,
+    /// Command-line arguments passed to the package
+    args: Vec<String>,
+}
+
+impl Run {
+    pub fn execute(self, output: Output) -> ! {
+        let result = self.execute_inner(output);
+        exit_with_wasi_exit_code(result);
+    }
+
+    #[tracing::instrument(level = "debug", name = "wasmer_run", skip_all)]
+    fn execute_inner(self, output: Output) -> Result<(), Error> {
+        let pb = ProgressBar::new_spinner();
+        pb.set_draw_target(output.draw_target());
+        pb.enable_steady_tick(TICK);
+
+        pb.set_message("Initializing the WebAssembly VM");
+
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()?;
+        let handle = runtime.handle().clone();
+
+        #[cfg(feature = "sys")]
+        if self.stack_size.is_some() {
+            wasmer_vm::set_stack_size(self.stack_size.unwrap());
+        }
+
+        let _guard = handle.enter();
+        let (store, _) = self.store.get_store()?;
+        let runtime = self
+            .wasi
+            .prepare_runtime(store.engine().clone(), &self.env, runtime)?;
+
+        // This is a slow operation, so let's temporarily wrap the runtime with
+        // something that displays progress
+        let monitoring_runtime = Arc::new(MonitoringRuntime::new(runtime, pb.clone()));
+        let runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime.runtime.clone();
+        let monitoring_runtime: Arc<dyn Runtime + Send + Sync> = monitoring_runtime;
+
+        let target = self.input.resolve_target(&monitoring_runtime, &pb)?;
+
+        pb.finish_and_clear();
+
+        // push the TTY state so we can restore it after the program finishes
+        let tty = runtime.tty().map(|tty| tty.tty_get());
+
+        let result = {
+            match target {
+                ExecutableTarget::WebAssembly {
+                    module,
+                    module_hash,
+                    path,
+                } => self.execute_wasm(&path, &module, module_hash, store, runtime.clone()),
+                ExecutableTarget::Package(pkg) => self.execute_webc(&pkg, runtime.clone()),
+            }
+        };
+
+        // restore the TTY state as the execution may have changed it
+        if let Some(state) = tty {
+            if let Some(tty) = runtime.tty() {
+                tty.tty_set(state);
+            }
+        }
+
+        if let Err(e) = &result {
+            self.maybe_save_coredump(e);
+        }
+
+        result
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn execute_wasm(
+        &self,
+        path: &Path,
+        module: &Module,
+        module_hash: ModuleHash,
+        mut store: Store,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        if wasmer_emscripten::is_emscripten_module(module) {
+            self.execute_emscripten_module()
+        } else if wasmer_wasix::is_wasi_module(module) || wasmer_wasix::is_wasix_module(module) {
+            self.execute_wasi_module(path, module, module_hash, runtime, store)
+        } else {
+            self.execute_pure_wasm_module(module, &mut store)
+        }
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn execute_webc(
+        &self,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let id = match self.entrypoint.as_deref() {
+            Some(cmd) => cmd,
+            None => infer_webc_entrypoint(pkg)?,
+        };
+        let cmd = pkg
+            .get_command(id)
+            .with_context(|| format!("Unable to get metadata for the \"{id}\" command"))?;
+
+        let uses = self.load_injected_packages(&runtime)?;
+
+        if DcgiRunner::can_run_command(cmd.metadata())? {
+            self.run_dcgi(id, pkg, uses, runtime)
+        } else if DProxyRunner::can_run_command(cmd.metadata())? {
+            self.run_dproxy(id, pkg, runtime)
+        } else if WcgiRunner::can_run_command(cmd.metadata())? {
+            self.run_wcgi(id, pkg, uses, runtime)
+        } else if WasiRunner::can_run_command(cmd.metadata())? {
+            self.run_wasi(id, pkg, uses, runtime)
+        } else if EmscriptenRunner::can_run_command(cmd.metadata())? {
+            self.run_emscripten(id, pkg, runtime)
+        } else {
+            bail!(
+                "Unable to find a runner that supports \"{}\"",
+                cmd.metadata().runner
+            );
+        }
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    fn load_injected_packages(
+        &self,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<Vec<BinaryPackage>, Error> {
+        let mut dependencies = Vec::new();
+
+        for name in &self.wasi.uses {
+            let specifier = PackageSpecifier::parse(name)
+                .with_context(|| format!("Unable to parse \"{name}\" as a package specifier"))?;
+            let pkg = {
+                let specifier = specifier.clone();
+                let inner_runtime = runtime.clone();
+                runtime
+                    .task_manager()
+                    .spawn_and_block_on(async move {
+                        BinaryPackage::from_registry(&specifier, inner_runtime.as_ref()).await
+                    })
+                    .with_context(|| format!("Unable to load \"{name}\""))??
+            };
+            dependencies.push(pkg);
+        }
+
+        Ok(dependencies)
+    }
+
+    fn run_wasi(
+        &self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        uses: Vec<BinaryPackage>,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let mut runner = self.build_wasi_runner(&runtime)?;
+        runner.run_command(command_name, pkg, runtime)
+    }
+
+    fn run_wcgi(
+        &self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        uses: Vec<BinaryPackage>,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let mut runner = wasmer_wasix::runners::wcgi::WcgiRunner::new(NoOpWcgiCallbacks);
+        self.config_wcgi(runner.config(), uses)?;
+        runner.run_command(command_name, pkg, runtime)
+    }
+
+    fn config_wcgi(
+        &self,
+        config: &mut wcgi::Config,
+        uses: Vec<BinaryPackage>,
+    ) -> Result<(), Error> {
+        config
+            .args(self.args.clone())
+            .addr(self.wcgi.addr)
+            .envs(self.wasi.env_vars.clone())
+            .map_directories(self.wasi.mapped_dirs.clone())
+            .callbacks(Callbacks::new(self.wcgi.addr))
+            .inject_packages(uses);
+        *config.capabilities() = self.wasi.capabilities();
+        if self.wasi.forward_host_env {
+            config.forward_host_env();
+        }
+
+        #[cfg(feature = "journal")]
+        {
+            for trigger in self.wasi.snapshot_on.iter().cloned() {
+                config.add_snapshot_trigger(trigger);
+            }
+            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+                config.add_default_snapshot_triggers();
+            }
+            if let Some(period) = self.wasi.snapshot_interval {
+                if self.wasi.journals.is_empty() {
+                    return Err(anyhow::format_err!(
+                        "If you specify a snapshot interval then you must also specify a journal file"
+                    ));
+                }
+                config.with_snapshot_interval(Duration::from_millis(period));
+            }
+            for journal in self.wasi.build_journals()? {
+                config.add_journal(journal);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn run_dcgi(
+        &self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        uses: Vec<BinaryPackage>,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let factory = DcgiInstanceFactory::new();
+        let mut runner = wasmer_wasix::runners::dcgi::DcgiRunner::new(factory);
+        self.config_wcgi(runner.config().inner(), uses);
+        runner.run_command(command_name, pkg, runtime)
+    }
+
+    fn run_dproxy(
+        &self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let mut inner = self.build_wasi_runner(&runtime)?;
+        let mut runner = wasmer_wasix::runners::dproxy::DProxyRunner::new(inner, pkg);
+        runner.run_command(command_name, pkg, runtime)
+    }
+
+    fn run_emscripten(
+        &self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let mut runner = wasmer_wasix::runners::emscripten::EmscriptenRunner::new();
+        runner.set_args(self.args.clone());
+
+        runner.run_command(command_name, pkg, runtime)
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn execute_pure_wasm_module(&self, module: &Module, store: &mut Store) -> Result<(), Error> {
+        let imports = Imports::default();
+        let instance = Instance::new(store, module, &imports)
+            .context("Unable to instantiate the WebAssembly module")?;
+
+        let entrypoint  = match &self.entrypoint {
+            Some(entry) => {
+                instance.exports
+                    .get_function(entry)
+                    .with_context(|| format!("The module doesn't contain a \"{entry}\" function"))?
+            },
+            None => {
+                instance.exports.get_function("_start")
+                    .context("The module doesn't contain a \"_start\" function. Either implement it or specify an entrypoint function.")?
+            }
+        };
+
+        let return_values = invoke_function(&instance, store, entrypoint, &self.args)?;
+
+        println!(
+            "{}",
+            return_values
+                .iter()
+                .map(|val| val.to_string())
+                .collect::<Vec<String>>()
+                .join(" ")
+        );
+
+        Ok(())
+    }
+
+    fn build_wasi_runner(
+        &self,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<WasiRunner, anyhow::Error> {
+        let packages = self.load_injected_packages(runtime)?;
+
+        let mut runner = WasiRunner::new();
+
+        runner
+            .with_args(&self.args)
+            .with_injected_packages(packages)
+            .with_envs(self.wasi.env_vars.clone())
+            .with_mapped_host_commands(self.wasi.build_mapped_commands()?)
+            .with_mapped_directories(self.wasi.build_mapped_directories()?)
+            .with_forward_host_env(self.wasi.forward_host_env)
+            .with_capabilities(self.wasi.capabilities());
+
+        #[cfg(feature = "journal")]
+        {
+            for trigger in self.wasi.snapshot_on.iter().cloned() {
+                runner.with_snapshot_trigger(trigger);
+            }
+            if self.wasi.snapshot_on.is_empty() && !self.wasi.journals.is_empty() {
+                runner.with_default_snapshot_triggers();
+            }
+            if let Some(period) = self.wasi.snapshot_interval {
+                if self.wasi.journals.is_empty() {
+                    return Err(anyhow::format_err!(
+                        "If you specify a snapshot interval then you must also specify a journal file"
+                    ));
+                }
+                runner.with_snapshot_interval(Duration::from_millis(period));
+            }
+            for journal in self.wasi.build_journals()? {
+                runner.with_journal(journal);
+            }
+        }
+
+        Ok(runner)
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn execute_wasi_module(
+        &self,
+        wasm_path: &Path,
+        module: &Module,
+        module_hash: ModuleHash,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+        mut store: Store,
+    ) -> Result<(), Error> {
+        let program_name = wasm_path.display().to_string();
+
+        let runner = self.build_wasi_runner(&runtime)?;
+        runner.run_wasm(
+            runtime,
+            &program_name,
+            module,
+            module_hash,
+            self.wasi.enable_async_threads,
+        )
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn execute_emscripten_module(&self) -> Result<(), Error> {
+        bail!("Emscripten packages are not currently supported")
+    }
+
+    #[allow(unused_variables)]
+    fn maybe_save_coredump(&self, e: &Error) {
+        #[cfg(feature = "coredump")]
+        if let Some(coredump) = &self.coredump_on_trap {
+            if let Err(e) = generate_coredump(e, self.input.to_string(), coredump) {
+                tracing::warn!(
+                    error = &*e as &dyn std::error::Error,
+                    coredump_path=%coredump.display(),
+                    "Unable to generate a coredump",
+                );
+            }
+        }
+    }
+
+    /// Create Run instance for arguments/env, assuming we're being run from a
+    /// CFP binfmt interpreter.
+    pub fn from_binfmt_args() -> Self {
+        Run::from_binfmt_args_fallible().unwrap_or_else(|e| {
+            crate::error::PrettyError::report::<()>(
+                Err(e).context("Failed to set up wasmer binfmt invocation"),
+            )
+        })
+    }
+
+    fn from_binfmt_args_fallible() -> Result<Self, Error> {
+        if !cfg!(linux) {
+            bail!("binfmt_misc is only available on linux.");
+        }
+
+        let argv = std::env::args().collect::<Vec<_>>();
+        let (_interpreter, executable, original_executable, args) = match &argv[..] {
+            [a, b, c, rest @ ..] => (a, b, c, rest),
+            _ => {
+                bail!("Wasmer binfmt interpreter needs at least three arguments (including $0) - must be registered as binfmt interpreter with the CFP flags. (Got arguments: {:?})", argv);
+            }
+        };
+        let store = StoreOptions::default();
+        Ok(Run {
+            env: WasmerEnv::default(),
+            store,
+            wasi: Wasi::for_binfmt_interpreter()?,
+            wcgi: WcgiOptions::default(),
+            stack_size: None,
+            entrypoint: Some(original_executable.to_string()),
+            coredump_on_trap: None,
+            input: PackageSource::infer(executable)?,
+            args: args.to_vec(),
+        })
+    }
+}
+
+fn invoke_function(
+    instance: &Instance,
+    store: &mut Store,
+    func: &Function,
+    args: &[String],
+) -> Result<Box<[Value]>, Error> {
+    let func_ty = func.ty(store);
+    let required_arguments = func_ty.params().len();
+    let provided_arguments = args.len();
+
+    anyhow::ensure!(
+        required_arguments == provided_arguments,
+        "Function expected {} arguments, but received {}",
+        required_arguments,
+        provided_arguments,
+    );
+
+    let invoke_args = args
+        .iter()
+        .zip(func_ty.params().iter())
+        .map(|(arg, param_type)| {
+            parse_value(arg, *param_type)
+                .with_context(|| format!("Unable to convert {arg:?} to {param_type:?}"))
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let return_values = func.call(store, &invoke_args)?;
+
+    Ok(return_values)
+}
+
+fn parse_value(s: &str, ty: wasmer_types::Type) -> Result<Value, Error> {
+    let value = match ty {
+        Type::I32 => Value::I32(s.parse()?),
+        Type::I64 => Value::I64(s.parse()?),
+        Type::F32 => Value::F32(s.parse()?),
+        Type::F64 => Value::F64(s.parse()?),
+        Type::V128 => Value::V128(s.parse()?),
+        _ => bail!("There is no known conversion from {s:?} to {ty:?}"),
+    };
+    Ok(value)
+}
+
+fn infer_webc_entrypoint(pkg: &BinaryPackage) -> Result<&str, Error> {
+    if let Some(entrypoint) = pkg.entrypoint_cmd.as_deref() {
+        return Ok(entrypoint);
+    }
+
+    match pkg.commands.as_slice() {
+        [] => bail!("The WEBC file doesn't contain any executable commands"),
+        [one] => Ok(one.name()),
+        [..] => {
+            let mut commands: Vec<_> = pkg.commands.iter().map(|cmd| cmd.name()).collect();
+            commands.sort();
+            bail!(
+                "Unable to determine the WEBC file's entrypoint. Please choose one of {:?}",
+                commands,
+            );
+        }
+    }
+}
+
+/// The input that was passed in via the command-line.
+#[derive(Debug, Clone, PartialEq)]
+enum PackageSource {
+    /// A file on disk (`*.wasm`, `*.webc`, etc.).
+    File(PathBuf),
+    /// A directory containing a `wasmer.toml` file
+    Dir(PathBuf),
+    /// A package to be downloaded (a URL, package name, etc.)
+    Package(PackageSpecifier),
+}
+
+impl PackageSource {
+    fn infer(s: &str) -> Result<PackageSource, Error> {
+        let path = Path::new(s);
+        if path.is_file() {
+            return Ok(PackageSource::File(path.to_path_buf()));
+        } else if path.is_dir() {
+            return Ok(PackageSource::Dir(path.to_path_buf()));
+        }
+
+        if let Ok(pkg) = PackageSpecifier::parse(s) {
+            return Ok(PackageSource::Package(pkg));
+        }
+
+        Err(anyhow::anyhow!(
+            "Unable to resolve \"{s}\" as a URL, package name, or file on disk"
+        ))
+    }
+
+    /// Try to resolve the [`PackageSource`] to an executable artifact.
+    ///
+    /// This will try to automatically download and cache any resources from the
+    /// internet.
+    #[tracing::instrument(level = "debug", skip_all)]
+    fn resolve_target(
+        &self,
+        rt: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<ExecutableTarget, Error> {
+        match self {
+            PackageSource::File(path) => ExecutableTarget::from_file(path, rt, pb),
+            PackageSource::Dir(d) => ExecutableTarget::from_dir(d, rt, pb),
+            PackageSource::Package(pkg) => {
+                pb.set_message("Loading from the registry");
+                let inner_pck = pkg.clone();
+                let inner_rt = rt.clone();
+                let pkg = rt.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_registry(&inner_pck, inner_rt.as_ref()).await
+                })??;
+                Ok(ExecutableTarget::Package(pkg))
+            }
+        }
+    }
+}
+
+impl Display for PackageSource {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PackageSource::File(path) | PackageSource::Dir(path) => write!(f, "{}", path.display()),
+            PackageSource::Package(p) => write!(f, "{p}"),
+        }
+    }
+}
+
+/// We've been given the path for a file... What does it contain and how should
+/// that be run?
+#[derive(Debug, Clone)]
+enum TargetOnDisk {
+    WebAssemblyBinary,
+    Wat,
+    LocalWebc,
+    Artifact,
+}
+
+impl TargetOnDisk {
+    fn from_file(path: &Path) -> Result<TargetOnDisk, Error> {
+        // Normally the first couple hundred bytes is enough to figure
+        // out what type of file this is.
+        let mut buffer = [0_u8; 512];
+
+        let mut f = File::open(path)
+            .with_context(|| format!("Unable to open \"{}\" for reading", path.display(),))?;
+        let bytes_read = f.read(&mut buffer)?;
+
+        let leading_bytes = &buffer[..bytes_read];
+
+        if wasmer::is_wasm(leading_bytes) {
+            return Ok(TargetOnDisk::WebAssemblyBinary);
+        }
+
+        if webc::detect(leading_bytes).is_ok() {
+            return Ok(TargetOnDisk::LocalWebc);
+        }
+
+        #[cfg(feature = "compiler")]
+        if ArtifactBuild::is_deserializable(leading_bytes) {
+            return Ok(TargetOnDisk::Artifact);
+        }
+
+        // If we can't figure out the file type based on its content, fall back
+        // to checking the extension.
+
+        match path.extension().and_then(|s| s.to_str()) {
+            Some("wat") => Ok(TargetOnDisk::Wat),
+            Some("wasm") => Ok(TargetOnDisk::WebAssemblyBinary),
+            Some("webc") => Ok(TargetOnDisk::LocalWebc),
+            Some("wasmu") => Ok(TargetOnDisk::WebAssemblyBinary),
+            _ => bail!("Unable to determine how to execute \"{}\"", path.display()),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum ExecutableTarget {
+    WebAssembly {
+        module: Module,
+        module_hash: ModuleHash,
+        path: PathBuf,
+    },
+    Package(BinaryPackage),
+}
+
+impl ExecutableTarget {
+    /// Try to load a Wasmer package from a directory containing a `wasmer.toml`
+    /// file.
+    #[tracing::instrument(level = "debug", skip_all)]
+    fn from_dir(
+        dir: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
+        pb.set_message(format!("Loading \"{}\" into memory", dir.display()));
+
+        let manifest_path = dir.join("wasmer.toml");
+        let webc = webc::wasmer_package::Package::from_manifest(manifest_path)?;
+        let container = Container::from(webc);
+
+        pb.set_message("Resolving dependencies");
+        let inner_runtime = runtime.clone();
+        let pkg = runtime.task_manager().spawn_and_block_on(async move {
+            BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
+        })??;
+
+        Ok(ExecutableTarget::Package(pkg))
+    }
+
+    /// Try to load a file into something that can be used to run it.
+    #[tracing::instrument(level = "debug", skip_all)]
+    fn from_file(
+        path: &Path,
+        runtime: &Arc<dyn Runtime + Send + Sync>,
+        pb: &ProgressBar,
+    ) -> Result<Self, Error> {
+        pb.set_message(format!("Loading from \"{}\"", path.display()));
+
+        match TargetOnDisk::from_file(path)? {
+            TargetOnDisk::WebAssemblyBinary | TargetOnDisk::Wat => {
+                let wasm = std::fs::read(path)?;
+
+                pb.set_message("Compiling to WebAssembly");
+                let module = runtime
+                    .load_module_sync(&wasm)
+                    .with_context(|| format!("Unable to compile \"{}\"", path.display()))?;
+
+                Ok(ExecutableTarget::WebAssembly {
+                    module,
+                    module_hash: ModuleHash::hash(&wasm),
+                    path: path.to_path_buf(),
+                })
+            }
+            TargetOnDisk::Artifact => {
+                let engine = runtime.engine();
+                pb.set_message("Deserializing pre-compiled WebAssembly module");
+                let module = unsafe { Module::deserialize_from_file(&engine, path)? };
+                let module_hash = {
+                    let wasm = std::fs::read(path)?;
+                    ModuleHash::hash(wasm)
+                };
+
+                Ok(ExecutableTarget::WebAssembly {
+                    module,
+                    module_hash,
+                    path: path.to_path_buf(),
+                })
+            }
+            TargetOnDisk::LocalWebc => {
+                let container = Container::from_disk(path)?;
+                pb.set_message("Resolving dependencies");
+
+                let inner_runtime = runtime.clone();
+                let pkg = runtime.task_manager().spawn_and_block_on(async move {
+                    BinaryPackage::from_webc(&container, inner_runtime.as_ref()).await
+                })??;
+                Ok(ExecutableTarget::Package(pkg))
+            }
+        }
+    }
+}
+
+#[cfg(feature = "coredump")]
+fn generate_coredump(err: &Error, source_name: String, coredump_path: &Path) -> Result<(), Error> {
+    let err: &wasmer::RuntimeError = match err.downcast_ref() {
+        Some(e) => e,
+        None => {
+            log::warn!("no runtime error found to generate coredump with");
+            return Ok(());
+        }
+    };
+
+    let mut coredump_builder =
+        wasm_coredump_builder::CoredumpBuilder::new().executable_name(&source_name);
+
+    let mut thread_builder = wasm_coredump_builder::ThreadBuilder::new().thread_name("main");
+
+    for frame in err.trace() {
+        let coredump_frame = wasm_coredump_builder::FrameBuilder::new()
+            .codeoffset(frame.func_offset() as u32)
+            .funcidx(frame.func_index())
+            .build();
+        thread_builder.add_frame(coredump_frame);
+    }
+
+    coredump_builder.add_thread(thread_builder.build());
+
+    let coredump = coredump_builder
+        .serialize()
+        .map_err(Error::msg)
+        .context("Coredump serializing failed")?;
+
+    std::fs::write(coredump_path, &coredump).with_context(|| {
+        format!(
+            "Unable to save the coredump to \"{}\"",
+            coredump_path.display()
+        )
+    })?;
+
+    Ok(())
+}
+
+#[derive(Debug, Clone, Parser)]
+pub(crate) struct WcgiOptions {
+    /// The address to serve on.
+    #[clap(long, short, env, default_value_t = ([127, 0, 0, 1], 8000).into())]
+    pub(crate) addr: SocketAddr,
+}
+
+impl Default for WcgiOptions {
+    fn default() -> Self {
+        Self {
+            addr: ([127, 0, 0, 1], 8000).into(),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Callbacks {
+    stderr: Mutex<LineWriter<std::io::Stderr>>,
+    addr: SocketAddr,
+}
+
+impl Callbacks {
+    fn new(addr: SocketAddr) -> Self {
+        Callbacks {
+            stderr: Mutex::new(LineWriter::new(std::io::stderr())),
+            addr,
+        }
+    }
+}
+
+impl wasmer_wasix::runners::wcgi::Callbacks for Callbacks {
+    fn started(&self, _abort: AbortHandle) {
+        println!("WCGI Server running at http://{}/", self.addr);
+    }
+
+    fn on_stderr(&self, raw_message: &[u8]) {
+        if let Ok(mut stderr) = self.stderr.lock() {
+            // If the WCGI runner printed any log messages we want to make sure
+            // they get propagated to the user. Line buffering is important here
+            // because it helps prevent the output from becoming a complete
+            // mess.
+            let _ = stderr.write_all(raw_message);
+        }
+    }
+}
+
+/// Exit the current process, using the WASI exit code if the error contains
+/// one.
+fn exit_with_wasi_exit_code(result: Result<(), Error>) -> ! {
+    let exit_code = match result {
+        Ok(_) => 0,
+        Err(error) => {
+            match error.chain().find_map(get_exit_code) {
+                Some(exit_code) => exit_code.raw(),
+                None => {
+                    eprintln!("{:?}", PrettyError::new(error));
+                    // Something else happened
+                    1
+                }
+            }
+        }
+    };
+
+    std::io::stdout().flush().ok();
+    std::io::stderr().flush().ok();
+
+    std::process::exit(exit_code);
+}
+
+fn get_exit_code(
+    error: &(dyn std::error::Error + 'static),
+) -> Option<wasmer_wasix::types::wasi::ExitCode> {
+    if let Some(WasiError::Exit(exit_code)) = error.downcast_ref() {
+        return Some(*exit_code);
+    }
+    if let Some(error) = error.downcast_ref::<wasmer_wasix::WasiRuntimeError>() {
+        return error.as_exit_code();
+    }
+
+    None
+}
+
+#[derive(Debug)]
+struct MonitoringRuntime<R> {
+    runtime: Arc<R>,
+    progress: ProgressBar,
+}
+
+impl<R> MonitoringRuntime<R> {
+    fn new(runtime: R, progress: ProgressBar) -> Self {
+        MonitoringRuntime {
+            runtime: Arc::new(runtime),
+            progress,
+        }
+    }
+}
+
+impl<R: wasmer_wasix::Runtime + Send + Sync> wasmer_wasix::Runtime for MonitoringRuntime<R> {
+    fn networking(&self) -> &virtual_net::DynVirtualNetworking {
+        self.runtime.networking()
+    }
+
+    fn task_manager(&self) -> &Arc<dyn wasmer_wasix::VirtualTaskManager> {
+        self.runtime.task_manager()
+    }
+
+    fn package_loader(
+        &self,
+    ) -> Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync> {
+        let inner = self.runtime.package_loader();
+        Arc::new(MonitoringPackageLoader {
+            inner,
+            progress: self.progress.clone(),
+        })
+    }
+
+    fn module_cache(
+        &self,
+    ) -> Arc<dyn wasmer_wasix::runtime::module_cache::ModuleCache + Send + Sync> {
+        self.runtime.module_cache()
+    }
+
+    fn source(&self) -> Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync> {
+        let inner = self.runtime.source();
+        Arc::new(MonitoringSource {
+            inner,
+            progress: self.progress.clone(),
+        })
+    }
+
+    fn engine(&self) -> wasmer::Engine {
+        self.runtime.engine()
+    }
+
+    fn new_store(&self) -> wasmer::Store {
+        self.runtime.new_store()
+    }
+
+    fn http_client(&self) -> Option<&wasmer_wasix::http::DynHttpClient> {
+        self.runtime.http_client()
+    }
+
+    fn tty(&self) -> Option<&(dyn wasmer_wasix::os::TtyBridge + Send + Sync)> {
+        self.runtime.tty()
+    }
+}
+
+#[derive(Debug)]
+struct MonitoringSource {
+    inner: Arc<dyn wasmer_wasix::runtime::resolver::Source + Send + Sync>,
+    progress: ProgressBar,
+}
+
+#[async_trait::async_trait]
+impl wasmer_wasix::runtime::resolver::Source for MonitoringSource {
+    async fn query(
+        &self,
+        package: &PackageSpecifier,
+    ) -> Result<Vec<wasmer_wasix::runtime::resolver::PackageSummary>, QueryError> {
+        self.progress.set_message(format!("Looking up {package}"));
+        self.inner.query(package).await
+    }
+}
+
+#[derive(Debug)]
+struct MonitoringPackageLoader {
+    inner: Arc<dyn wasmer_wasix::runtime::package_loader::PackageLoader + Send + Sync>,
+    progress: ProgressBar,
+}
+
+#[async_trait::async_trait]
+impl wasmer_wasix::runtime::package_loader::PackageLoader for MonitoringPackageLoader {
+    async fn load(
+        &self,
+        summary: &wasmer_wasix::runtime::resolver::PackageSummary,
+    ) -> Result<Container, Error> {
+        let pkg_id = summary.package_id();
+        self.progress.set_message(format!("Downloading {pkg_id}"));
+
+        self.inner.load(summary).await
+    }
+
+    async fn load_package_tree(
+        &self,
+        root: &Container,
+        resolution: &wasmer_wasix::runtime::resolver::Resolution,
+    ) -> Result<BinaryPackage, Error> {
+        self.inner.load_package_tree(root, resolution).await
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/wasi.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/wasi.rs
new file mode 100644
index 0000000..17fa452
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/run/wasi.rs
@@ -0,0 +1,727 @@
+use std::{
+    collections::{BTreeSet, HashMap},
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::{mpsc::Sender, Arc},
+    time::Duration,
+};
+
+use anyhow::{bail, Context, Result};
+use bytes::Bytes;
+use clap::Parser;
+use tokio::runtime::Handle;
+use url::Url;
+use virtual_fs::{DeviceFile, FileSystem, PassthruFileSystem, RootFileSystemBuilder};
+use wasmer::{Engine, Function, Instance, Memory32, Memory64, Module, RuntimeError, Store, Value};
+use wasmer_registry::wasmer_env::WasmerEnv;
+#[cfg(feature = "journal")]
+use wasmer_wasix::journal::{LogFileJournal, SnapshotTrigger};
+use wasmer_wasix::{
+    bin_factory::BinaryPackage,
+    capabilities::Capabilities,
+    default_fs_backing, get_wasi_versions,
+    http::HttpClient,
+    journal::{CompactingLogFileJournal, DynJournal},
+    os::{tty_sys::SysTty, TtyBridge},
+    rewind_ext,
+    runners::{MappedCommand, MappedDirectory},
+    runtime::{
+        module_cache::{FileSystemCache, ModuleCache, ModuleHash},
+        package_loader::{BuiltinPackageLoader, PackageLoader},
+        resolver::{
+            FileSystemSource, InMemorySource, MultiSource, PackageSpecifier, Source, WapmSource,
+            WebSource,
+        },
+        task_manager::{
+            tokio::{RuntimeOrHandle, TokioTaskManager},
+            VirtualTaskManagerExt,
+        },
+    },
+    types::__WASI_STDIN_FILENO,
+    wasmer_wasix_types::wasi::Errno,
+    PluggableRuntime, RewindState, Runtime, WasiEnv, WasiEnvBuilder, WasiError, WasiFunctionEnv,
+    WasiVersion,
+};
+
+use crate::utils::{parse_envvar, parse_mapdir};
+
+const WAPM_SOURCE_CACHE_TIMEOUT: Duration = Duration::from_secs(10 * 60);
+
+#[derive(Debug, Parser, Clone, Default)]
+/// WASI Options
+pub struct Wasi {
+    /// WASI pre-opened directory
+    #[clap(long = "dir", name = "DIR", group = "wasi")]
+    pub(crate) pre_opened_directories: Vec<PathBuf>,
+
+    /// Map a host directory to a different location for the Wasm module
+    #[clap(
+        long = "mapdir",
+        name = "GUEST_DIR:HOST_DIR",
+        value_parser=parse_mapdir,
+    )]
+    pub(crate) mapped_dirs: Vec<MappedDirectory>,
+
+    /// Pass custom environment variables
+    #[clap(
+        long = "env",
+        name = "KEY=VALUE",
+        value_parser=parse_envvar,
+    )]
+    pub(crate) env_vars: Vec<(String, String)>,
+
+    /// Forward all host env variables to guest
+    #[clap(long, env)]
+    pub(crate) forward_host_env: bool,
+
+    /// List of other containers this module depends on
+    #[clap(long = "use", name = "USE")]
+    pub(crate) uses: Vec<String>,
+
+    /// List of webc packages that are explicitly included for execution
+    /// Note: these packages will be used instead of those in the registry
+    #[clap(long = "include-webc", name = "WEBC")]
+    pub(super) include_webcs: Vec<PathBuf>,
+
+    /// List of injected atoms
+    #[clap(long = "map-command", name = "MAPCMD")]
+    pub(super) map_commands: Vec<String>,
+
+    /// Enable networking with the host network.
+    ///
+    /// Allows WASI modules to open TCP and UDP connections, create sockets, ...
+    #[clap(long = "net")]
+    pub networking: bool,
+
+    /// Disables the TTY bridge
+    #[clap(long = "no-tty")]
+    pub no_tty: bool,
+
+    /// Enables asynchronous threading
+    #[clap(long = "enable-async-threads")]
+    pub enable_async_threads: bool,
+
+    /// Enables an exponential backoff (measured in milli-seconds) of
+    /// the process CPU usage when there are no active run tokens (when set
+    /// holds the maximum amount of time that it will pause the CPU)
+    /// (default = off)
+    #[clap(long = "enable-cpu-backoff")]
+    pub enable_cpu_backoff: Option<u64>,
+
+    /// Specifies one or more journal files that Wasmer will use to restore
+    /// and save the state of the WASM process as it executes.
+    ///
+    /// The state of the WASM process and its sandbox will be reapplied using
+    /// the journals in the order that you specify here.
+    ///
+    /// The last journal file specified will be created if it does not exist
+    /// and opened for read and write. New journal events will be written to this
+    /// file
+    #[cfg(feature = "journal")]
+    #[clap(long = "journal")]
+    pub journals: Vec<PathBuf>,
+
+    /// Flag that indicates if the journal will be automatically compacted
+    /// as it fills up and when the process exits
+    #[cfg(feature = "journal")]
+    #[clap(long = "enable-compaction")]
+    pub enable_compaction: bool,
+
+    /// Tells the compactor not to compact when the journal log file is closed
+    #[cfg(feature = "journal")]
+    #[clap(long = "without-compact-on-drop")]
+    pub without_compact_on_drop: bool,
+
+    /// Tells the compactor to compact when it grows by a certain factor of
+    /// its original size. (i.e. '0.2' would be it compacts after the journal
+    /// has grown by 20 percent)
+    ///
+    /// Default is to compact on growth that exceeds 15%
+    #[cfg(feature = "journal")]
+    #[clap(long = "with-compact-on-growth", default_value = "0.15")]
+    pub with_compact_on_growth: f32,
+
+    /// Indicates what events will cause a snapshot to be taken
+    /// and written to the journal file.
+    ///
+    /// If not specified, the default is to snapshot when the process idles, when
+    /// the process exits or periodically if an interval argument is also supplied.
+    ///
+    /// Additionally if the snapshot-on is not specified it will also take a snapshot
+    /// on the first stdin, environ or socket listen - this can be used to accelerate
+    /// the boot up time of WASM processes.
+    #[cfg(feature = "journal")]
+    #[clap(long = "snapshot-on")]
+    pub snapshot_on: Vec<SnapshotTrigger>,
+
+    /// Adds a periodic interval (measured in milli-seconds) that the runtime will automatically
+    /// take snapshots of the running process and write them to the journal. When specifying
+    /// this parameter it implies that `--snapshot-on interval` has also been specified.
+    #[cfg(feature = "journal")]
+    #[clap(long = "snapshot-period")]
+    pub snapshot_interval: Option<u64>,
+
+    /// Allow instances to send http requests.
+    ///
+    /// Access to domains is granted by default.
+    #[clap(long)]
+    pub http_client: bool,
+
+    /// Require WASI modules to only import 1 version of WASI.
+    #[clap(long = "deny-multiple-wasi-versions")]
+    pub deny_multiple_wasi_versions: bool,
+}
+
+pub struct RunProperties {
+    pub ctx: WasiFunctionEnv,
+    pub path: PathBuf,
+    pub invoke: Option<String>,
+    pub args: Vec<String>,
+}
+
+#[allow(dead_code)]
+impl Wasi {
+    const MAPPED_CURRENT_DIR_DEFAULT_PATH: &'static str = "/mnt/host";
+
+    pub fn map_dir(&mut self, alias: &str, target_on_disk: PathBuf) {
+        self.mapped_dirs.push(MappedDirectory {
+            guest: alias.to_string(),
+            host: target_on_disk,
+        });
+    }
+
+    pub fn set_env(&mut self, key: &str, value: &str) {
+        self.env_vars.push((key.to_string(), value.to_string()));
+    }
+
+    /// Gets the WASI version (if any) for the provided module
+    pub fn get_versions(module: &Module) -> Option<BTreeSet<WasiVersion>> {
+        // Get the wasi version in non-strict mode, so multiple wasi versions
+        // are potentially allowed.
+        //
+        // Checking for multiple wasi versions is handled outside this function.
+        get_wasi_versions(module, false)
+    }
+
+    /// Checks if a given module has any WASI imports at all.
+    pub fn has_wasi_imports(module: &Module) -> bool {
+        // Get the wasi version in non-strict mode, so no other imports
+        // are allowed
+        get_wasi_versions(module, false).is_some()
+    }
+
+    pub fn prepare(
+        &self,
+        module: &Module,
+        program_name: String,
+        args: Vec<String>,
+        rt: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<WasiEnvBuilder> {
+        let args = args.into_iter().map(|arg| arg.into_bytes());
+
+        let map_commands = self
+            .map_commands
+            .iter()
+            .map(|map| map.split_once('=').unwrap())
+            .map(|(a, b)| (a.to_string(), b.to_string()))
+            .collect::<HashMap<_, _>>();
+
+        let mut uses = Vec::new();
+        for name in &self.uses {
+            let specifier = PackageSpecifier::parse(name)
+                .with_context(|| format!("Unable to parse \"{name}\" as a package specifier"))?;
+            let pkg = {
+                let inner_rt = rt.clone();
+                rt.task_manager()
+                    .spawn_and_block_on(async move {
+                        BinaryPackage::from_registry(&specifier, &*inner_rt).await
+                    })
+                    .with_context(|| format!("Unable to load \"{name}\""))??
+            };
+            uses.push(pkg);
+        }
+
+        let builder = WasiEnv::builder(program_name)
+            .runtime(Arc::clone(&rt))
+            .args(args)
+            .envs(self.env_vars.clone())
+            .uses(uses)
+            .map_commands(map_commands);
+
+        let mut builder = {
+            // If we preopen anything from the host then shallow copy it over
+            let root_fs = RootFileSystemBuilder::new()
+                .with_tty(Box::new(DeviceFile::new(__WASI_STDIN_FILENO)))
+                .build();
+
+            let mut mapped_dirs = Vec::new();
+
+            // Process the --dirs flag and merge it with --mapdir.
+            let mut have_current_dir = false;
+            for dir in &self.pre_opened_directories {
+                let mapping = if dir == Path::new(".") {
+                    if have_current_dir {
+                        bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
+                    }
+                    have_current_dir = true;
+
+                    let current_dir =
+                        std::env::current_dir().context("could not determine current directory")?;
+
+                    MappedDirectory {
+                        host: current_dir,
+                        guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
+                    }
+                } else {
+                    let resolved = dir.canonicalize().with_context(|| {
+                        format!(
+                            "could not canonicalize path for argument '--dir {}'",
+                            dir.display()
+                        )
+                    })?;
+
+                    if &resolved != dir {
+                        bail!(
+                            "Invalid argument '--dir {}': path must either be absolute, or '.'",
+                            dir.display(),
+                        );
+                    }
+
+                    let guest = resolved
+                        .to_str()
+                        .with_context(|| {
+                            format!(
+                                "invalid argument '--dir {}': path must be valid utf-8",
+                                dir.display(),
+                            )
+                        })?
+                        .to_string();
+
+                    MappedDirectory {
+                        host: resolved,
+                        guest,
+                    }
+                };
+
+                mapped_dirs.push(mapping);
+            }
+
+            for MappedDirectory { host, guest } in &self.mapped_dirs {
+                let resolved_host = host.canonicalize().with_context(|| {
+                    format!(
+                        "could not canonicalize path for argument '--mapdir {}:{}'",
+                        host.display(),
+                        guest,
+                    )
+                })?;
+
+                let mapping = if guest == "." {
+                    if have_current_dir {
+                        bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
+                    }
+                    have_current_dir = true;
+
+                    MappedDirectory {
+                        host: resolved_host,
+                        guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
+                    }
+                } else {
+                    MappedDirectory {
+                        host: resolved_host,
+                        guest: guest.clone(),
+                    }
+                };
+                mapped_dirs.push(mapping);
+            }
+
+            if !mapped_dirs.is_empty() {
+                let fs_backing: Arc<dyn FileSystem + Send + Sync> =
+                    Arc::new(PassthruFileSystem::new(default_fs_backing()));
+                for MappedDirectory { host, guest } in self.mapped_dirs.clone() {
+                    let host = if !host.is_absolute() {
+                        Path::new("/").join(host)
+                    } else {
+                        host
+                    };
+                    root_fs.mount(guest.into(), &fs_backing, host)?;
+                }
+            }
+
+            // Open the root of the new filesystem
+            let b = builder
+                .sandbox_fs(root_fs)
+                .preopen_dir(Path::new("/"))
+                .unwrap();
+
+            if have_current_dir {
+                b.map_dir(".", Self::MAPPED_CURRENT_DIR_DEFAULT_PATH)?
+            } else {
+                b.map_dir(".", "/")?
+            }
+        };
+
+        *builder.capabilities_mut() = self.capabilities();
+
+        #[cfg(feature = "journal")]
+        {
+            for trigger in self.snapshot_on.iter().cloned() {
+                builder.add_snapshot_trigger(trigger);
+            }
+            if let Some(interval) = self.snapshot_interval {
+                builder.with_snapshot_interval(std::time::Duration::from_millis(interval));
+            }
+            for journal in self.build_journals()? {
+                builder.add_journal(journal);
+            }
+        }
+
+        Ok(builder)
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn build_journals(&self) -> anyhow::Result<Vec<Arc<DynJournal>>> {
+        let mut ret = Vec::new();
+        for journal in self.journals.clone() {
+            if self.enable_compaction {
+                let mut journal = CompactingLogFileJournal::new(journal)?;
+                if !self.without_compact_on_drop {
+                    journal = journal.with_compact_on_drop()
+                }
+                if self.with_compact_on_growth.is_normal() && self.with_compact_on_growth != 0f32 {
+                    journal = journal.with_compact_on_factor_size(self.with_compact_on_growth);
+                }
+                ret.push(Arc::new(journal) as Arc<DynJournal>);
+            } else {
+                ret.push(Arc::new(LogFileJournal::new(journal)?));
+            }
+        }
+        Ok(ret)
+    }
+
+    #[cfg(not(feature = "journal"))]
+    pub fn build_journals(&self) -> anyhow::Result<Vec<Arc<DynJournal>>> {
+        Ok(Vec::new())
+    }
+
+    pub fn build_mapped_directories(&self) -> Result<Vec<MappedDirectory>, anyhow::Error> {
+        let mut mapped_dirs = Vec::new();
+
+        // Process the --dirs flag and merge it with --mapdir.
+        let mut have_current_dir = false;
+        for dir in &self.pre_opened_directories {
+            let mapping = if dir == Path::new(".") {
+                if have_current_dir {
+                    bail!("Cannot pre-open the current directory twice: --dir=. must only be specified once");
+                }
+                have_current_dir = true;
+
+                let current_dir =
+                    std::env::current_dir().context("could not determine current directory")?;
+
+                MappedDirectory {
+                    host: current_dir,
+                    guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
+                }
+            } else {
+                let resolved = dir.canonicalize().with_context(|| {
+                    format!(
+                        "could not canonicalize path for argument '--dir {}'",
+                        dir.display()
+                    )
+                })?;
+
+                if &resolved != dir {
+                    bail!(
+                        "Invalid argument '--dir {}': path must either be absolute, or '.'",
+                        dir.display(),
+                    );
+                }
+
+                let guest = resolved
+                    .to_str()
+                    .with_context(|| {
+                        format!(
+                            "invalid argument '--dir {}': path must be valid utf-8",
+                            dir.display(),
+                        )
+                    })?
+                    .to_string();
+
+                MappedDirectory {
+                    host: resolved,
+                    guest,
+                }
+            };
+
+            mapped_dirs.push(mapping);
+        }
+
+        for MappedDirectory { host, guest } in &self.mapped_dirs {
+            let resolved_host = host.canonicalize().with_context(|| {
+                format!(
+                    "could not canonicalize path for argument '--mapdir {}:{}'",
+                    host.display(),
+                    guest,
+                )
+            })?;
+
+            let mapping = if guest == "." {
+                if have_current_dir {
+                    bail!("Cannot pre-open the current directory twice: '--mapdir=?:.' / '--dir=.' must only be specified once");
+                }
+                have_current_dir = true;
+
+                MappedDirectory {
+                    host: resolved_host,
+                    guest: Self::MAPPED_CURRENT_DIR_DEFAULT_PATH.to_string(),
+                }
+            } else {
+                MappedDirectory {
+                    host: resolved_host,
+                    guest: guest.clone(),
+                }
+            };
+            mapped_dirs.push(mapping);
+        }
+
+        Ok(mapped_dirs)
+    }
+
+    pub fn build_mapped_commands(&self) -> Result<Vec<MappedCommand>, anyhow::Error> {
+        self.map_commands
+            .iter()
+            .map(|item| {
+                let (a, b) = item.split_once('=').with_context(|| {
+                    format!(
+                        "Invalid --map-command flag: expected <ALIAS>=<HOST_PATH>, got '{item}'"
+                    )
+                })?;
+
+                let a = a.trim();
+                let b = b.trim();
+
+                if a.is_empty() {
+                    bail!("Invalid --map-command flag - alias cannot be empty: '{item}'");
+                }
+                // TODO(theduke): check if host command exists, and canonicalize PathBuf.
+                if b.is_empty() {
+                    bail!("Invalid --map-command flag - host path cannot be empty: '{item}'");
+                }
+
+                Ok(MappedCommand {
+                    alias: a.to_string(),
+                    target: b.to_string(),
+                })
+            })
+            .collect::<Result<Vec<_>, anyhow::Error>>()
+    }
+
+    pub fn capabilities(&self) -> Capabilities {
+        let mut caps = Capabilities::default();
+
+        if self.http_client {
+            caps.http_client = wasmer_wasix::http::HttpClientCapabilityV1::new_allow_all();
+        }
+
+        caps.threading.enable_asynchronous_threading = self.enable_async_threads;
+        caps.threading.enable_exponential_cpu_backoff =
+            self.enable_cpu_backoff.map(Duration::from_millis);
+
+        caps
+    }
+
+    pub fn prepare_runtime<I>(
+        &self,
+        engine: Engine,
+        env: &WasmerEnv,
+        rt_or_handle: I,
+    ) -> Result<impl Runtime + Send + Sync>
+    where
+        I: Into<RuntimeOrHandle>,
+    {
+        let tokio_task_manager = Arc::new(TokioTaskManager::new(rt_or_handle.into()));
+        let mut rt = PluggableRuntime::new(tokio_task_manager.clone());
+
+        if self.networking {
+            rt.set_networking_implementation(virtual_net::host::LocalNetworking::default());
+        } else {
+            rt.set_networking_implementation(virtual_net::UnsupportedVirtualNetworking::default());
+        }
+
+        #[cfg(feature = "journal")]
+        for journal in self.build_journals()? {
+            rt.add_journal(journal);
+        }
+
+        if !self.no_tty {
+            let tty = Arc::new(SysTty);
+            tty.reset();
+            rt.set_tty(tty);
+        }
+
+        let client =
+            wasmer_wasix::http::default_http_client().context("No HTTP client available")?;
+        let client = Arc::new(client);
+
+        let package_loader = self
+            .prepare_package_loader(env, client.clone())
+            .context("Unable to prepare the package loader")?;
+
+        let registry = self.prepare_source(env, client)?;
+
+        let cache_dir = env.cache_dir().join("compiled");
+        let module_cache = wasmer_wasix::runtime::module_cache::in_memory()
+            .with_fallback(FileSystemCache::new(cache_dir, tokio_task_manager));
+
+        rt.set_package_loader(package_loader)
+            .set_module_cache(module_cache)
+            .set_source(registry)
+            .set_engine(Some(engine));
+
+        Ok(rt)
+    }
+
+    /// Helper function for instantiating a module with Wasi imports for the `Run` command.
+    pub fn instantiate(
+        &self,
+        module: &Module,
+        module_hash: ModuleHash,
+        program_name: String,
+        args: Vec<String>,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+        store: &mut Store,
+    ) -> Result<(WasiFunctionEnv, Instance)> {
+        let builder = self.prepare(module, program_name, args, runtime)?;
+        let (instance, wasi_env) = builder.instantiate_ext(module.clone(), module_hash, store)?;
+
+        Ok((wasi_env, instance))
+    }
+
+    pub fn for_binfmt_interpreter() -> Result<Self> {
+        let dir = std::env::var_os("WASMER_BINFMT_MISC_PREOPEN")
+            .map(Into::into)
+            .unwrap_or_else(|| PathBuf::from("."));
+        Ok(Self {
+            deny_multiple_wasi_versions: true,
+            env_vars: std::env::vars().collect(),
+            pre_opened_directories: vec![dir],
+            ..Self::default()
+        })
+    }
+
+    fn prepare_package_loader(
+        &self,
+        env: &WasmerEnv,
+        client: Arc<dyn HttpClient + Send + Sync>,
+    ) -> Result<impl PackageLoader + Send + Sync> {
+        let checkout_dir = env.cache_dir().join("checkouts");
+        let tokens = tokens_by_authority(env)?;
+
+        let loader = BuiltinPackageLoader::new()
+            .with_cache_dir(checkout_dir)
+            .with_shared_http_client(client)
+            .with_tokens(tokens);
+
+        Ok(loader)
+    }
+
+    fn prepare_source(
+        &self,
+        env: &WasmerEnv,
+        client: Arc<dyn HttpClient + Send + Sync>,
+    ) -> Result<impl Source + Send + Sync> {
+        let mut source = MultiSource::new();
+
+        // Note: This should be first so our "preloaded" sources get a chance to
+        // override the main registry.
+        let mut preloaded = InMemorySource::new();
+        for path in &self.include_webcs {
+            preloaded
+                .add_webc(path)
+                .with_context(|| format!("Unable to load \"{}\"", path.display()))?;
+        }
+        source.add_source(preloaded);
+
+        let graphql_endpoint = self.graphql_endpoint(env)?;
+        let cache_dir = env.cache_dir().join("queries");
+        let mut wapm_source = WapmSource::new(graphql_endpoint, Arc::clone(&client))
+            .with_local_cache(cache_dir, WAPM_SOURCE_CACHE_TIMEOUT);
+        if let Some(token) = env
+            .config()?
+            .registry
+            .get_login_token_for_registry(wapm_source.registry_endpoint().as_str())
+        {
+            wapm_source = wapm_source.with_auth_token(token);
+        }
+        source.add_source(wapm_source);
+
+        let cache_dir = env.cache_dir().join("downloads");
+        source.add_source(WebSource::new(cache_dir, client));
+
+        source.add_source(FileSystemSource::default());
+
+        Ok(source)
+    }
+
+    fn graphql_endpoint(&self, env: &WasmerEnv) -> Result<Url> {
+        if let Ok(endpoint) = env.registry_endpoint() {
+            return Ok(endpoint);
+        }
+
+        let config = env.config()?;
+        let graphql_endpoint = config.registry.get_graphql_url();
+        let graphql_endpoint = graphql_endpoint
+            .parse()
+            .with_context(|| format!("Unable to parse \"{graphql_endpoint}\" as a URL"))?;
+
+        Ok(graphql_endpoint)
+    }
+}
+
+fn parse_registry(r: &str) -> Result<Url> {
+    let url = wasmer_registry::format_graphql(r).parse()?;
+    Ok(url)
+}
+
+fn tokens_by_authority(env: &WasmerEnv) -> Result<HashMap<String, String>> {
+    let mut tokens = HashMap::new();
+    let config = env.config()?;
+
+    for credentials in config.registry.tokens {
+        if let Ok(url) = Url::parse(&credentials.registry) {
+            if url.has_authority() {
+                tokens.insert(url.authority().to_string(), credentials.token);
+            }
+        }
+    }
+
+    if let (Ok(current_registry), Some(token)) = (env.registry_endpoint(), env.token()) {
+        if current_registry.has_authority() {
+            tokens.insert(current_registry.authority().to_string(), token);
+        }
+    }
+
+    // Note: The global wasmer.toml config file stores URLs for the GraphQL
+    // endpoint, however that's often on the backend (i.e.
+    // https://registry.wasmer.io/graphql) and we also want to use the same API
+    // token when sending requests to the frontend (e.g. downloading a package
+    // using the `Accept: application/webc` header).
+    //
+    // As a workaround to avoid needing to query *all* backends to find out
+    // their frontend URL every time the `wasmer` CLI runs, we'll assume that
+    // when a backend is called something like `registry.wasmer.io`, the
+    // frontend will be at `wasmer.io`. This works everywhere except for people
+    // developing the backend locally... Sorry, Ayush.
+
+    let mut frontend_tokens = HashMap::new();
+    for (hostname, token) in &tokens {
+        if let Some(frontend_url) = hostname.strip_prefix("registry.") {
+            if !tokens.contains_key(frontend_url) {
+                frontend_tokens.insert(frontend_url.to_string(), token.clone());
+            }
+        }
+    }
+    tokens.extend(frontend_tokens);
+
+    Ok(tokens)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/security_framework.tgz b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/security_framework.tgz
new file mode 100644
index 0000000..57611cd
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/security_framework.tgz differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/self_update.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/self_update.rs
new file mode 100644
index 0000000..dd74fa2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/self_update.rs
@@ -0,0 +1,37 @@
+use anyhow::Context as _;
+
+/// The options for the `wasmer self-update` subcommand
+#[derive(clap::Parser, Debug)]
+pub struct SelfUpdate {}
+
+impl SelfUpdate {
+    /// Runs logic for the `self-update` subcommand
+    pub fn execute(&self) -> Result<(), anyhow::Error> {
+        self.inner_execute().context("failed to self-update wasmer")
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn inner_execute(&self) -> Result<(), anyhow::Error> {
+        use std::process::{Command, Stdio};
+
+        println!("Fetching latest installer");
+        let cmd = Command::new("curl")
+            .arg("https://get.wasmer.io")
+            .arg("-sSfL")
+            .stdout(Stdio::piped())
+            .spawn()?;
+
+        let mut process = Command::new("sh")
+            .stdin(cmd.stdout.unwrap())
+            .stdout(Stdio::inherit())
+            .spawn()?;
+
+        process.wait().unwrap();
+        Ok(())
+    }
+
+    #[cfg(target_os = "windows")]
+    fn inner_execute(&self) -> Result<(), anyhow::Error> {
+        anyhow::bail!("Self update is not supported on Windows. Use install instructions on the Wasmer homepage: https://wasmer.io");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/ssh.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/ssh.rs
new file mode 100644
index 0000000..4ff84e9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/ssh.rs
@@ -0,0 +1,128 @@
+//! Edge SSH command.
+
+use anyhow::Context;
+use wasmer_api::WasmerClient;
+
+use super::AsyncCliCommand;
+use crate::{edge_config::EdgeConfig, opts::ApiOpts};
+
+/// Start a remote SSH session.
+#[derive(clap::Parser, Debug)]
+pub struct CmdSsh {
+    #[clap(flatten)]
+    api: ApiOpts,
+    /// SSH port to use.
+    #[clap(long, default_value = "22")]
+    pub ssh_port: u16,
+    /// SSH Host
+    #[clap(long, default_value = "root.wasmer.network")]
+    pub host: String,
+    /// Local port mapping to the package that's running, this allows
+    /// for instance a HTTP server to be tested remotely while giving
+    /// instant logs over stderr channelled via SSH.
+    #[clap(long)]
+    pub map_port: Vec<u16>,
+    /// Package to run on the Deploy servers
+    #[clap(index = 1, default_value = "sharrattj/bash")]
+    pub run: String,
+    /// Arguments to pass the package running on Deploy
+    #[clap(index = 2, trailing_var_arg = true)]
+    pub run_args: Vec<String>,
+    /// Prints the SSH command rather than executing it
+    #[clap(short, long)]
+    pub print: bool,
+}
+
+#[async_trait::async_trait]
+impl AsyncCliCommand for CmdSsh {
+    type Output = ();
+
+    async fn run_async(self) -> Result<(), anyhow::Error> {
+        let mut config = crate::edge_config::load_config(None)?;
+        let client = self.api.client()?;
+
+        let (token, is_new) = acquire_ssh_token(&client, &config.config).await?;
+
+        let host = self.host;
+        let port = self.ssh_port;
+
+        if is_new {
+            eprintln!("Acquired new SSH token");
+            config.set_ssh_token(token.clone())?;
+            if let Err(err) = config.save() {
+                eprintln!("Warning: failed to save config: {err}");
+            }
+        }
+
+        let mut cmd = std::process::Command::new("ssh");
+        let mut cmd = cmd
+            .args([
+                // No controlpath becaue we don't want to re-use connections
+                "-o",
+                "ControlPath=none",
+                // Disable host key checking, because we use a DNS-load-balanced
+                // host.
+                "-o",
+                "StrictHostKeyChecking=no",
+                // Don't persist known hosts - don't want to clutter users
+                // regular ssh data.
+                "-o",
+                "UserKnownHostsFile=/dev/null",
+                "-o",
+                "IdentitiesOnly=yes",
+                // Don't print ssh related output.
+                "-q",
+            ])
+            .args(["-p", format!("{port}").as_str()]);
+        for map_port in self.map_port {
+            cmd = cmd.args([
+                "-L",
+                format!("{}:localhost:{}", map_port, map_port).as_str(),
+            ]);
+        }
+
+        cmd = cmd.arg(format!("{token}@{host}")).arg(self.run.as_str());
+        for run_arg in self.run_args {
+            cmd = cmd.arg(&run_arg);
+        }
+
+        if self.print {
+            print!("ssh");
+            for arg in cmd.get_args() {
+                print!(" {}", arg.to_string_lossy().as_ref());
+            }
+            println!();
+            return Ok(());
+        }
+
+        let exit = cmd.spawn()?.wait()?;
+        if exit.success() {
+            Ok(())
+        } else {
+            Err(anyhow::anyhow!("ssh failed with status {}", exit))
+        }
+    }
+}
+
+type IsNew = bool;
+type RawToken = String;
+
+async fn acquire_ssh_token(
+    client: &WasmerClient,
+    config: &EdgeConfig,
+) -> Result<(RawToken, IsNew), anyhow::Error> {
+    if let Some(token) = &config.ssh_token {
+        // TODO: validate that token is still valid.
+        return Ok((token.clone(), false));
+    }
+
+    let token = create_ssh_token(client).await?;
+    Ok((token, true))
+}
+
+/// Create a new token for SSH access through the backend API.
+async fn create_ssh_token(client: &WasmerClient) -> Result<RawToken, anyhow::Error> {
+    wasmer_api::query::generate_deploy_config_token_raw(client, wasmer_api::query::TokenKind::SSH)
+        .await
+        .context("Could not create token for ssh access")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/validate.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/validate.rs
new file mode 100644
index 0000000..f544048
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/validate.rs
@@ -0,0 +1,36 @@
+use std::path::PathBuf;
+
+use anyhow::{bail, Context, Result};
+use clap::Parser;
+use wasmer::*;
+
+use crate::store::StoreOptions;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer validate` subcommand
+pub struct Validate {
+    /// File to validate as WebAssembly
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+}
+
+impl Validate {
+    /// Runs logic for the `validate` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to validate `{}`", self.path.display()))
+    }
+    fn inner_execute(&self) -> Result<()> {
+        let (store, _compiler_type) = self.store.get_store()?;
+        let module_contents = std::fs::read(&self.path)?;
+        if !is_wasm(&module_contents) {
+            bail!("`wasmer validate` only validates WebAssembly files");
+        }
+        Module::validate(&store, &module_contents)?;
+        eprintln!("Validation passed for `{}`.", self.path.display());
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wasmer_create_exe_main.c b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wasmer_create_exe_main.c
new file mode 100644
index 0000000..2840dbc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wasmer_create_exe_main.c
@@ -0,0 +1,257 @@
+
+#include "wasmer.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+// EXTRA_HEADERS
+
+#define own
+
+#define WASI
+ 
+// DECLARE_VOLUMES
+// DECLARE_MODULES
+
+static void print_wasmer_error() {
+  int error_len = wasmer_last_error_length();
+  printf("Error len: `%d`\n", error_len);
+  char *error_str = (char *)malloc(error_len);
+  wasmer_last_error_message(error_str, error_len);
+  printf("%s\n", error_str);
+  free(error_str);
+}
+
+#ifdef WASI
+static void pass_mapdir_arg(wasi_config_t *wasi_config, char *mapdir) {
+  int colon_location = strchr(mapdir, ':') - mapdir;
+  if (colon_location == 0) {
+    // error malformed argument
+    fprintf(stderr, "Expected mapdir argument of the form alias:directory\n");
+    exit(-1);
+  }
+
+  char *alias = (char *)malloc(colon_location + 1);
+  memcpy(alias, mapdir, colon_location);
+  alias[colon_location] = '\0';
+
+  int dir_len = strlen(mapdir) - colon_location;
+  char *dir = (char *)malloc(dir_len + 1);
+  memcpy(dir, &mapdir[colon_location + 1], dir_len);
+  dir[dir_len] = '\0';
+
+  wasi_config_mapdir(wasi_config, alias, dir);
+  free(alias);
+  free(dir);
+}
+
+// We try to parse out `--dir` and `--mapdir` ahead of time and process those
+// specially. All other arguments are passed to the guest program.
+static void handle_arguments(
+  wasi_config_t *wasi_config, 
+  int argc,
+  char *argv[], 
+  bool command_was_invoked, 
+  int dash_dash_position
+) {
+  for (int i = 1; i < argc; ++i) {
+    // We probably want special args like `--dir` and `--mapdir` to not be
+    // passed directly
+    if (strcmp(argv[i], "--dir") == 0) {
+      // next arg is a preopen directory
+      if ((i + 1) < argc) {
+        i++;
+        wasi_config_preopen_dir(wasi_config, argv[i]);
+      } else {
+        fprintf(stderr, "--dir expects a following argument specifying which "
+                        "directory to preopen\n");
+        exit(-1);
+      }
+    } else if (strcmp(argv[i], "--mapdir") == 0) {
+      // next arg is a mapdir
+      if ((i + 1) < argc) {
+        i++;
+        pass_mapdir_arg(wasi_config, argv[i]);
+      } else {
+        fprintf(stderr,
+                "--mapdir expects a following argument specifying which "
+                "directory to preopen in the form alias:directory\n");
+        exit(-1);
+      }
+    } else if (strncmp(argv[i], "--dir=", strlen("--dir=")) == 0) {
+      // this arg is a preopen dir
+      char *dir = argv[i] + strlen("--dir=");
+      wasi_config_preopen_dir(wasi_config, dir);
+    } else if (strncmp(argv[i], "--mapdir=", strlen("--mapdir=")) == 0) {
+      // this arg is a mapdir
+      char *mapdir = argv[i] + strlen("--mapdir=");
+      pass_mapdir_arg(wasi_config, mapdir);
+    } else if (command_was_invoked && i == dash_dash_position && strcmp(argv[i], "--") == 0) {
+      continue;
+    } else if (command_was_invoked && dash_dash_position > i && (strcmp(argv[i], "--command") == 0 || strcmp(argv[i], "-c") == 0)) {
+      // next arg is a command
+      if ((i + 1) < argc) {
+        i++;
+      } else {
+        fprintf(stderr, "--command expects a commmand name\n");
+        exit(-1);
+      } 
+    } else {
+      // guest argument
+      wasi_config_arg(wasi_config, argv[i]);
+    }
+  }
+}
+#endif
+
+int main(int argc, char *argv[]) {
+  wasm_config_t *config = wasm_config_new();
+  wasm_engine_t *engine = wasm_engine_new_with_config(config);
+  wasm_store_t *store = wasm_store_new(engine);
+  wasm_module_t *module = NULL;
+
+  const char* selected_atom = "main";
+  bool command_was_invoked = false;
+  int dash_dash_position = argc + 1;
+  int number_of_commands = 1;
+  // SET_NUMBER_OF_COMMANDS
+
+  if (number_of_commands > 1) {
+    // check if arguments contain "--" earlier than "--command" or "-c"
+    for (int i = 1; i < argc; i++) {
+      if (strcmp(argv[i], "--") == 0) {
+        dash_dash_position = i;
+        break;
+      }
+    }
+    
+    // select the --command only if if was given before a "--", such 
+    for (int i = 1; i < argc; i++) {
+      if ((strcmp(argv[i], "--command") == 0 || strcmp(argv[i], "-c") == 0) && dash_dash_position > i) {
+        // next arg is a command
+        if ((i + 1) < argc) {
+          selected_atom = argv[i + 1];
+          command_was_invoked = true;
+          break;
+        } else {
+          fprintf(stderr, "--command expects a commmand name\n");
+          exit(-1);
+        } 
+      }
+    }
+  }
+
+  // INSTANTIATE_MODULES
+
+  // We have now finished the memory buffer book keeping and we have a valid
+  // Module.
+
+#ifdef WASI_PIRITA
+  wasi_config_t *wasi_config = wasi_config_new(argv[0]);
+  handle_arguments(wasi_config, argc, argv, command_was_invoked,dash_dash_position);
+
+  wasm_byte_vec_t volume_bytes = {
+    .size = VOLUMES_LENGTH,
+    .data = &VOLUMES_DATA,
+  };
+
+  wasi_filesystem_t* filesystem = wasi_filesystem_init_static_memory(&volume_bytes);
+  if (!filesystem) {
+    printf("Error parsing filesystem from bytes\n");
+    return 1;
+  }
+
+  wasm_extern_vec_t imports;
+  wasi_env_t* wasi_env = wasi_env_with_filesystem(
+      wasi_config,
+      store,
+      module,
+      filesystem,
+      &imports,
+      selected_atom
+      );
+  if (!wasi_env) {
+    printf("Error setting filesystem\n");
+    return 1;
+  }
+#else
+  wasi_config_t *wasi_config = wasi_config_new(argv[0]);
+  handle_arguments(wasi_config, argc, argv, command_was_invoked, dash_dash_position);
+
+  wasi_env_t *wasi_env = wasi_env_new(store, wasi_config);
+  if (!wasi_env) {
+    fprintf(stderr, "Error building WASI env!\n");
+    print_wasmer_error();
+    return 1;
+  }
+
+  wasm_importtype_vec_t import_types;
+  wasm_module_imports(module, &import_types);
+
+  wasm_extern_vec_t imports;
+  wasm_extern_vec_new_uninitialized(&imports, import_types.size);
+  wasm_importtype_vec_delete(&import_types);
+
+#ifdef WASI
+  bool get_imports_result = wasi_get_imports(store, wasi_env, module, &imports);
+
+  if (!get_imports_result) {
+    fprintf(stderr, "Error getting WASI imports!\n");
+    print_wasmer_error();
+
+    return 1;
+  }
+#endif
+#endif
+
+  wasm_instance_t *instance = wasm_instance_new(store, module, &imports, NULL);
+
+  if (!instance) {
+    fprintf(stderr, "Failed to create instance\n");
+    print_wasmer_error();
+    return -1;
+  }
+
+#ifdef WASI
+  if (!wasi_env_initialize_instance(wasi_env, store, instance)) {
+    fprintf(stderr, "Failed to initialize env\n");
+    print_wasmer_error();
+    return -1;
+  }
+
+  own wasm_func_t *start_function = wasi_get_start_function(instance);
+  if (!start_function) {
+    fprintf(stderr, "`_start` function not found\n");
+    print_wasmer_error();
+    return -1;
+  }
+
+  wasm_val_vec_t args = WASM_EMPTY_VEC;
+  wasm_val_vec_t results = WASM_EMPTY_VEC;
+  own wasm_trap_t *trap = wasm_func_call(start_function, &args, &results);
+  if (trap) {
+    wasm_message_t retrieved_message;
+    // TODO: this is a shitty solution, but it's good enough for now
+    wasm_trap_message(trap, &retrieved_message);
+    if (strcmp(retrieved_message.data, "WASI exited with code: ExitCode::success (error 0)") == 0) {
+      wasm_trap_delete(trap);
+    } else {
+      fprintf(stderr, "%s", retrieved_message.data);
+      return -1;
+    }
+  }
+#endif
+
+  // TODO: handle non-WASI start (maybe with invoke?)
+
+#ifdef WASI_PIRITA
+  wasi_filesystem_delete(filesystem);
+#else
+  wasm_extern_vec_delete(&imports);
+#endif
+  wasi_env_delete(wasi_env);
+  wasm_instance_delete(instance);
+  wasm_module_delete(module);
+  wasm_store_delete(store);
+  wasm_engine_delete(engine);
+  return 0;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wast.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wast.rs
new file mode 100644
index 0000000..293e238
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/wast.rs
@@ -0,0 +1,39 @@
+//! Runs a .wast WebAssembly test suites
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+use wasmer_wast::Wast as WastSpectest;
+
+use crate::store::StoreOptions;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer wast` subcommand
+pub struct Wast {
+    /// Wast file to run
+    #[clap(name = "FILE")]
+    path: PathBuf,
+
+    #[clap(flatten)]
+    store: StoreOptions,
+
+    #[clap(short, long)]
+    /// A flag to indicate wast stop at the first error or continue.
+    fail_fast: bool,
+}
+
+impl Wast {
+    /// Runs logic for the `validate` subcommand
+    pub fn execute(&self) -> Result<()> {
+        self.inner_execute()
+            .context(format!("failed to test the wast `{}`", self.path.display()))
+    }
+    fn inner_execute(&self) -> Result<()> {
+        let (store, _compiler_name) = self.store.get_store()?;
+        let mut wast = WastSpectest::new_with_spectest(store);
+        wast.fail_fast = self.fail_fast;
+        wast.run_file(&self.path).with_context(|| "tests failed")?;
+        eprintln!("Wast tests succeeded for `{}`.", self.path.display());
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/whoami.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/whoami.rs
new file mode 100644
index 0000000..81bc962
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/commands/whoami.rs
@@ -0,0 +1,21 @@
+use clap::Parser;
+use wasmer_registry::wasmer_env::WasmerEnv;
+
+#[derive(Debug, Parser)]
+/// The options for the `wasmer whoami` subcommand
+pub struct Whoami {
+    #[clap(flatten)]
+    env: WasmerEnv,
+}
+
+impl Whoami {
+    /// Execute `wasmer whoami`
+    pub fn execute(&self) -> Result<(), anyhow::Error> {
+        let registry = self.env.registry_endpoint()?;
+        let token = self.env.token();
+        let (registry, username) =
+            wasmer_registry::whoami(self.env.dir(), Some(registry.as_str()), token.as_deref())?;
+        println!("logged into registry {registry:?} as user {username:?}");
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/common.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/common.rs
new file mode 100644
index 0000000..1e5e864
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/common.rs
@@ -0,0 +1,41 @@
+//! Common module with common used structures across different
+//! commands.
+
+use clap::Parser;
+
+#[derive(Debug, Parser, Clone, Default)]
+/// The WebAssembly features that can be passed through the
+/// Command Line args.
+pub struct WasmFeatures {
+    /// Enable support for the SIMD proposal.
+    #[clap(long = "enable-simd")]
+    pub simd: bool,
+
+    /// Disable support for the threads proposal.
+    #[clap(long = "disable-threads")]
+    pub disable_threads: bool,
+
+    /// Deprecated, threads are enabled by default.
+    #[clap(long = "enable-threads")]
+    pub _threads: bool,
+
+    /// Enable support for the reference types proposal.
+    #[clap(long = "enable-reference-types")]
+    pub reference_types: bool,
+
+    /// Enable support for the multi value proposal.
+    #[clap(long = "enable-multi-value")]
+    pub multi_value: bool,
+
+    /// Enable support for the bulk memory proposal.
+    #[clap(long = "enable-bulk-memory")]
+    pub bulk_memory: bool,
+
+    /// Enable support for all pre-standard proposals.
+    #[clap(long = "enable-all")]
+    pub all: bool,
+}
+
+pub(crate) fn normalize_path(s: &str) -> String {
+    wasmer_registry::utils::normalize_path(s)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/edge_config.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/edge_config.rs
new file mode 100644
index 0000000..b9176e3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/edge_config.rs
@@ -0,0 +1,133 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::{bail, Context};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
+pub struct EdgeConfig {
+    pub version: u32,
+    /// Token used for ssh access.
+    pub ssh_token: Option<String>,
+    /// Token used for network access.
+    pub network_token: Option<String>,
+}
+
+impl EdgeConfig {
+    pub const VERSION: u32 = 1;
+
+    pub fn from_slice(data: &[u8]) -> Result<Self, anyhow::Error> {
+        let data_str = std::str::from_utf8(data)?;
+        let value: toml::Value = toml::from_str(data_str).context("failed to parse config TOML")?;
+
+        let version = value
+            .get("version")
+            .and_then(|v| v.as_integer())
+            .context("invalid client config: no 'version' key found")?;
+
+        if version != Self::VERSION as i64 {
+            bail!(
+                "Invalid client config: unknown config version '{}'",
+                version
+            );
+        }
+
+        let config = toml::from_str(data_str)?;
+        Ok(config)
+    }
+}
+
+impl Default for EdgeConfig {
+    fn default() -> Self {
+        Self {
+            ssh_token: None,
+            network_token: None,
+            version: 1,
+        }
+    }
+}
+
+const CONFIG_FILE_NAME: &str = "deploy_client.toml";
+const CONFIG_PATH_ENV_VAR: &str = "DEPLOY_CLIENT_CONFIG_PATH";
+
+pub struct LoadedEdgeConfig {
+    pub config: EdgeConfig,
+    pub path: PathBuf,
+}
+
+impl LoadedEdgeConfig {
+    pub fn set_ssh_token(&mut self, token: String) -> Result<(), anyhow::Error> {
+        self.config.ssh_token = Some(token);
+        self.save()?;
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub fn set_network_token(&mut self, token: String) -> Result<(), anyhow::Error> {
+        self.config.network_token = Some(token);
+        self.save()?;
+        Ok(())
+    }
+
+    pub fn save(&self) -> Result<(), anyhow::Error> {
+        let data = toml::to_string(&self.config)?;
+        std::fs::write(&self.path, data)
+            .with_context(|| format!("failed to write config to '{}'", self.path.display()))?;
+        Ok(())
+    }
+}
+
+pub fn default_config_path() -> Result<PathBuf, anyhow::Error> {
+    if let Some(var) = std::env::var_os(CONFIG_PATH_ENV_VAR) {
+        Ok(var.into())
+    } else {
+        // TODO: use dirs crate to determine the correct path.
+        // (this also depends on general wasmer config moving there.)
+
+        #[allow(deprecated)]
+        let home = std::env::home_dir().context("failed to get home directory")?;
+        let path = home.join(".wasmer").join(CONFIG_FILE_NAME);
+        Ok(path)
+    }
+}
+
+pub fn load_config(custom_path: Option<PathBuf>) -> Result<LoadedEdgeConfig, anyhow::Error> {
+    let default_path = default_config_path()?;
+
+    let path = if let Some(p) = custom_path {
+        Some(p)
+    } else if default_path.is_file() {
+        Some(default_path.clone())
+    } else {
+        None
+    };
+
+    if let Some(path) = path {
+        if path.is_file() {
+            match try_load_config(&path) {
+                Ok(config) => {
+                    return Ok(LoadedEdgeConfig { config, path });
+                }
+                Err(err) => {
+                    eprintln!(
+                        "WARNING: failed to load config file at '{}': {}",
+                        path.display(),
+                        err
+                    );
+                }
+            }
+        }
+    }
+
+    Ok(LoadedEdgeConfig {
+        config: EdgeConfig::default(),
+        path: default_path,
+    })
+}
+
+fn try_load_config(path: &Path) -> Result<EdgeConfig, anyhow::Error> {
+    let data = std::fs::read(path)
+        .with_context(|| format!("failed to read config file at '{}'", path.display()))?;
+    let config = EdgeConfig::from_slice(&data)
+        .with_context(|| format!("failed to parse config file at '{}'", path.display()))?;
+    Ok(config)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/error.rs
new file mode 100644
index 0000000..57bc0f3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/error.rs
@@ -0,0 +1,153 @@
+//! Implements `PretyError` to print pretty errors in the CLI (when they happen)
+
+use std::fmt::{self, Debug, Write};
+
+use anyhow::{Chain, Error};
+use colored::*;
+use wasmer::RuntimeError;
+
+/// A `PrettyError` for printing `anyhow::Error` nicely.
+pub struct PrettyError {
+    error: Error,
+}
+
+impl PrettyError {
+    /// Create a new [`PrettyError`].
+    pub fn new(error: Error) -> Self {
+        PrettyError { error }
+    }
+}
+
+/// A macro that prints a warning with nice colors
+#[macro_export]
+macro_rules! warning {
+    ($($arg:tt)*) => ({
+        use colored::*;
+        eprintln!("{}: {}", "warning".yellow().bold(), format!($($arg)*));
+    })
+}
+
+#[cfg(not(feature = "jsc"))]
+impl PrettyError {
+    /// Process a `Result` printing any errors and exiting
+    /// the process after
+    pub fn report<T>(result: Result<T, Error>) -> ! {
+        std::process::exit(match result {
+            Ok(_t) => 0,
+            Err(error) => {
+                let runtime: Option<&RuntimeError> = error.downcast_ref();
+                let trapcode = runtime.map(|e| e.clone().to_trap());
+                eprintln!("{:?}", PrettyError { error });
+                // we don't use process:abort() here to avoid message from rust
+                // that could interfer with testing tools
+                // but still exit with the expected error code
+                match trapcode {
+                    #[cfg(target_os = "windows")]
+                    Some(_) => 3,
+                    #[cfg(not(target_os = "windows"))]
+                    Some(_) => 128 + libc::SIGABRT,
+                    _ => 1,
+                }
+            }
+        });
+    }
+}
+
+#[cfg(feature = "jsc")]
+impl PrettyError {
+    /// Process a `Result` printing any errors and exiting
+    /// the process after
+    pub fn report<T>(result: Result<T, Error>) -> ! {
+        std::process::exit(match result {
+            Ok(_t) => 0,
+            Err(error) => {
+                eprintln!("{:?}", PrettyError { error });
+                // we don't use process:abort() here to avoid message from rust
+                // that could interfer with testing tools
+                // but still exit with the expected error code
+                1
+            }
+        });
+    }
+}
+
+impl Debug for PrettyError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let error = &self.error;
+
+        if f.alternate() {
+            return Debug::fmt(&error, f);
+        }
+
+        write!(f, "{}", format!("{}: {}", "error".red(), error).bold())?;
+        // write!(f, "{}", error)?;
+
+        if let Some(cause) = error.source() {
+            // write!(f, "\n{}:", "caused by".bold().blue())?;
+            let chain = Chain::new(cause);
+            let (total_errors, _) = chain.size_hint();
+            for (n, error) in chain.enumerate() {
+                writeln!(f)?;
+                let mut indented = Indented {
+                    inner: f,
+                    number: Some(n + 1),
+                    is_last: n == total_errors - 1,
+                    started: false,
+                };
+                write!(indented, "{}", error)?;
+            }
+        }
+        Ok(())
+    }
+}
+
+struct Indented<'a, D> {
+    inner: &'a mut D,
+    number: Option<usize>,
+    started: bool,
+    is_last: bool,
+}
+
+impl<T> Write for Indented<'_, T>
+where
+    T: Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for (i, line) in s.split('\n').enumerate() {
+            if !self.started {
+                self.started = true;
+                match self.number {
+                    Some(number) => {
+                        if !self.is_last {
+                            write!(
+                                self.inner,
+                                "{} {: >4} ",
+                                "│".bold().blue(),
+                                format!("{}:", number).dimmed()
+                            )?
+                        } else {
+                            write!(
+                                self.inner,
+                                "{}{: >2}: ",
+                                "╰─▶".bold().blue(),
+                                format!("{}", number).bold().blue()
+                            )?
+                        }
+                    }
+                    None => self.inner.write_str("    ")?,
+                }
+            } else if i > 0 {
+                self.inner.write_char('\n')?;
+                if self.number.is_some() {
+                    self.inner.write_str("       ")?;
+                } else {
+                    self.inner.write_str("    ")?;
+                }
+            }
+
+            self.inner.write_str(line)?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/lib.rs
new file mode 100644
index 0000000..ae546bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/lib.rs
@@ -0,0 +1,41 @@
+//! The Wasmer binary lib
+
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![deny(
+    missing_docs,
+    dead_code,
+    nonstandard_style,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+// Allowed because it makes code more readable.
+#![allow(clippy::bool_comparison, clippy::match_like_matches_macro)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(all(target_os = "linux", feature = "tun-tap"))]
+mod net;
+
+mod commands;
+mod common;
+#[macro_use]
+mod error;
+mod c_gen;
+mod logging;
+mod opts;
+mod package_source;
+mod store;
+mod types;
+mod utils;
+
+mod edge_config;
+
+/// Version number of this crate.
+const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Run the Wasmer CLI.
+pub fn run_cli() {
+    self::commands::WasmerCmd::run();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/logging.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/logging.rs
new file mode 100644
index 0000000..64fb9c7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/logging.rs
@@ -0,0 +1,127 @@
+//! Logging functions for the debug feature.
+
+use is_terminal::IsTerminal;
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
+
+const WHITELISTED_LOG_TARGETS: &[&str] = &["wasmer", "wasmer_wasix", "virtual_fs"];
+
+/// Control the output generated by the CLI.
+#[derive(Debug, Default, Clone, PartialEq, clap::Parser)]
+pub struct Output {
+    /// Generate verbose output (repeat for more verbosity)
+    #[clap(short, long, action = clap::ArgAction::Count, global = true, conflicts_with = "quiet")]
+    pub verbose: u8,
+    /// Do not print progress messages.
+    #[clap(short, long, global = true, conflicts_with = "verbose")]
+    pub quiet: bool,
+    /// The format to use when generating logs.
+    #[clap(long, global = true, env, default_value = "text")]
+    pub log_format: LogFormat,
+    /// When to display colored output.
+    #[clap(long, default_value_t = clap::ColorChoice::Auto, global = true)]
+    pub color: clap::ColorChoice,
+}
+
+impl Output {
+    /// Has the `--verbose` flag been set?
+    pub fn is_verbose(&self) -> bool {
+        self.verbose > 0
+    }
+
+    /// Initialize logging based on the `$RUST_LOG` environment variable and
+    /// command-line flags.
+    pub fn initialize_logging(&self) {
+        let fmt_layer = fmt::layer()
+            .with_target(true)
+            .with_span_events(fmt::format::FmtSpan::CLOSE)
+            .with_ansi(self.should_emit_colors())
+            .with_thread_ids(true)
+            .with_writer(std::io::stderr);
+
+        let filter_layer = self.log_filter();
+
+        match self.log_format {
+            LogFormat::Text => tracing_subscriber::registry()
+                .with(filter_layer)
+                .with(fmt_layer.compact().with_target(true))
+                .init(),
+            LogFormat::Json => tracing_subscriber::registry()
+                .with(filter_layer)
+                .with(fmt_layer.json().with_target(true))
+                .init(),
+        }
+    }
+
+    fn log_filter(&self) -> EnvFilter {
+        let default_filters = [
+            LevelFilter::OFF,
+            LevelFilter::WARN,
+            LevelFilter::INFO,
+            LevelFilter::DEBUG,
+        ];
+
+        // First, we set up the default log level.
+        let default_level = default_filters
+            .get(self.verbose as usize)
+            .copied()
+            .unwrap_or(LevelFilter::TRACE);
+        let mut filter = EnvFilter::builder()
+            .with_default_directive(default_level.into())
+            .from_env_lossy();
+
+        // Next we add level-specific directives, where verbosity=0 means don't
+        // override anything. Note that these are shifted one level up so we'll
+        // get something like RUST_LOG="warn,wasmer_wasix=info"
+        let specific_filters = [LevelFilter::WARN, LevelFilter::INFO, LevelFilter::DEBUG];
+        if self.verbose > 0 {
+            let level = specific_filters
+                .get(self.verbose as usize)
+                .copied()
+                .unwrap_or(LevelFilter::TRACE);
+
+            for target in WHITELISTED_LOG_TARGETS {
+                let directive = format!("{target}={level}").parse().unwrap();
+                filter = filter.add_directive(directive);
+            }
+        }
+
+        filter
+    }
+
+    /// Check whether we should emit ANSI escape codes for log formatting.
+    ///
+    /// The `tracing-subscriber` crate doesn't have native support for
+    /// "--color=always|never|auto", so we implement a poor man's version.
+    ///
+    /// For more, see https://github.com/tokio-rs/tracing/issues/2388
+    fn should_emit_colors(&self) -> bool {
+        match self.color {
+            clap::ColorChoice::Auto => std::io::stderr().is_terminal(),
+            clap::ColorChoice::Always => true,
+            clap::ColorChoice::Never => false,
+        }
+    }
+
+    /// Get the draw target to be used with the `indicatif` crate.
+    ///
+    /// Progress indicators won't draw anything if the user passed the `--quiet`
+    /// flag.
+    pub fn draw_target(&self) -> indicatif::ProgressDrawTarget {
+        if self.quiet {
+            return indicatif::ProgressDrawTarget::hidden();
+        }
+
+        indicatif::ProgressDrawTarget::stderr()
+    }
+}
+
+/// The format used when generating logs.
+#[derive(Debug, Default, Copy, Clone, PartialEq, clap::ValueEnum)]
+pub enum LogFormat {
+    /// Human-readable logs.
+    #[default]
+    Text,
+    /// Machine-readable logs.
+    Json,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/mod.rs
new file mode 100644
index 0000000..c2a709b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/mod.rs
@@ -0,0 +1,2 @@
+mod tun;
+pub use tun::{TunTapDriver, TunTapSocket};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/tun.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/tun.rs
new file mode 100644
index 0000000..7b59b79
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/net/tun.rs
@@ -0,0 +1,405 @@
+use std::{
+    collections::{HashSet, VecDeque},
+    io::{self, ErrorKind},
+    mem::MaybeUninit,
+    os::fd::{AsRawFd, RawFd},
+    pin::Pin,
+    process::Command,
+    sync::Arc,
+    task::{Context, Poll, Waker},
+};
+
+use anyhow::Context as _;
+use bytes::Bytes;
+use futures_util::{Future, StreamExt};
+use mio::{event, unix::SourceFd, Interest, Registry, Token};
+use parking_lot::Mutex;
+use tun_tap::{Iface, Mode};
+use virtual_mio::{InterestGuard, InterestHandler, InterestType, InterestWakerMap, Selector};
+use virtual_net::{
+    io_err_into_net_error, meta::FrameSerializationFormat, IpAddr, IpCidr, IpRoute, Ipv4Addr,
+    Ipv6Addr, NetworkError, RemoteNetworkingClient, RemoteNetworkingClientDriver,
+    VirtualNetworking, VirtualRawSocket,
+};
+
+fn cmd(cmd: &str, args: &[&str]) -> anyhow::Result<()> {
+    let ecode = Command::new(cmd).args(args).spawn()?.wait()?;
+    if ecode.success() {
+        Ok(())
+    } else {
+        Err(anyhow::format_err!(
+            "failed to execute linux command (cmd={}, args={:?}, code={:?})",
+            cmd,
+            args,
+            ecode.code()
+        ))
+    }
+}
+
+pub struct TunTapSocket {}
+
+impl TunTapSocket {
+    pub async fn create(
+        selector: Arc<Selector>,
+        url: url::Url,
+        bring_up: bool,
+        static_ips: Vec<IpAddr>,
+    ) -> anyhow::Result<TunTapDriver> {
+        tracing::info!("creating tun/tap device");
+        let iface = match Iface::without_packet_info("edge%d", Mode::Tun) {
+            Ok(i) => i,
+            Err(err) => {
+                tracing::error!(
+                    "This process does not have permissions to open TUN/TAP sockets - {err}"
+                );
+                return Err(err).context("failed to open TUN/TAP socket");
+            }
+        };
+
+        // Create the remote client
+        tracing::info!("connecting to {url}");
+        let (stream, _res) = tokio_tungstenite::connect_async(url).await?;
+        let (tx, rx) = stream.split();
+
+        // Now pass it on to a remote networking adapter
+        tracing::info!("established web socket connection to the edge");
+        let (remote, mut remote_driver) =
+            RemoteNetworkingClient::new_from_tokio_ws_io(tx, rx, FrameSerializationFormat::Bincode);
+
+        tracing::info!("creating RAW socket");
+        let mut client = tokio::select! {
+            a = remote.bind_raw() => a,
+            _ = Pin::new(&mut remote_driver) => {
+                return Err(anyhow::format_err!("the driver closed before we could create the RAW socket"));
+            }
+        }?;
+
+        // If we are to set a static IP address then do so
+        for ip in static_ips {
+            tracing::info!("setting static IP ({ip})");
+            let res: anyhow::Result<()> = tokio::select! {
+                a = async {
+                    remote.ip_clear().await?;
+                    remote.ip_add(ip, match ip.is_ipv4() {
+                        true => 24,
+                        false => 120,
+                    }).await?;
+                    Ok(())
+                } => a,
+                _ = Pin::new(&mut remote_driver) => {
+                    return Err(anyhow::format_err!("the driver closed before it could set the static IP address"));
+                }
+            };
+            res?;
+        }
+
+        // We were likely assigned a mac address and IP address, get them
+        tracing::info!("getting remote socket addresses");
+        let ips = tokio::select! {
+            a = remote.ip_list() => a,
+            _ = Pin::new(&mut remote_driver) => {
+                return Err(anyhow::format_err!("the driver closed before we could the mac and IP addresses"));
+            }
+        }?;
+
+        // Get the routes as well
+        let routes = tokio::select! {
+            a = remote.route_list() => a,
+            _ = Pin::new(&mut remote_driver) => {
+                return Err(anyhow::format_err!("the driver closed before we could retrieve the routes"));
+            }
+        }?;
+
+        if bring_up {
+            tracing::info!("bringing up device ({})", iface.name());
+            interfaces::Interface::get_by_name(iface.name())?
+                .ok_or_else(|| anyhow::format_err!("The TUN/TAP interface could not be found"))?
+                .set_up(true)?;
+            //cmd("ip", &["link", "set", "up", "dev", iface.name()])?;
+
+            for ip in ips.iter() {
+                let ip_str = ip.ip.to_string();
+                let prefix = ip.prefix;
+                let ip_cidr = format!("{ip_str}/{prefix}");
+
+                println!("\rAssigning IP address ({ip_cidr})");
+                if cmd(
+                    "ip",
+                    &["address", "add", ip_cidr.as_str(), "dev", iface.name()],
+                )
+                .is_err()
+                {
+                    println!(
+                        "\rEscalating to elevated rights (sudo) due to limited user permissions"
+                    );
+                    cmd(
+                        "sudo",
+                        &[
+                            "ip",
+                            "address",
+                            "add",
+                            ip_cidr.as_str(),
+                            "dev",
+                            iface.name(),
+                        ],
+                    )?;
+                }
+            }
+
+            for mut route in routes.iter().cloned() {
+                // We change the addresses to some hard coded numbers that allow the routing to work properly
+                route.cidr.prefix = 8;
+                if route.cidr.ip.is_ipv6() {
+                    route.cidr.ip = IpAddr::V6(Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 0));
+                } else {
+                    route.cidr.ip = IpAddr::V4(Ipv4Addr::new(10, 0, 0, 0));
+                }
+
+                let ip_str = route.cidr.ip.to_string();
+                let prefix = route.cidr.prefix;
+                let ip_cidr = format!("{ip_str}/{prefix}");
+                let via_str = route.via_router.to_string();
+                let via = via_str.to_string();
+
+                println!("\rAssigning route ({ip_cidr})");
+                if cmd(
+                    "ip",
+                    &[
+                        "route",
+                        "add",
+                        ip_cidr.as_str(),
+                        "via",
+                        via.as_str(),
+                        "dev",
+                        iface.name(),
+                    ],
+                )
+                .is_err()
+                {
+                    println!(
+                        "\rEscalating to elevated rights (sudo) due to limited user permissions"
+                    );
+                    cmd(
+                        "sudo",
+                        &[
+                            "ip",
+                            "route",
+                            "add",
+                            ip_cidr.as_str(),
+                            "via",
+                            via.as_str(),
+                            "dev",
+                            iface.name(),
+                        ],
+                    )?;
+                }
+            }
+        }
+
+        // Set non-blocking and wrap the MIO
+        tracing::info!("switching to non-blocking IO");
+        set_non_blocking(&iface)?;
+        let handler = InterestWakerMap::default();
+        let mut source = MioWrapper {
+            fd: iface.as_raw_fd(),
+        };
+
+        // Register interest in the read and write events
+        let interest = InterestGuard::new(
+            &selector,
+            Box::new(handler.clone()),
+            &mut source,
+            mio::Interest::READABLE.add(mio::Interest::WRITABLE),
+        )
+        .map_err(io_err_into_net_error)?;
+
+        // Set the client handler
+        client.set_handler(Box::new(handler.clone()))?;
+
+        let driver = TunTapDriver {
+            iface,
+            handler,
+            send_queue: Default::default(),
+            _interest: interest,
+            client,
+            ips,
+            routes,
+            remote,
+            remote_driver,
+        };
+
+        Ok(driver)
+    }
+}
+
+fn set_non_blocking(iface: &Iface) -> anyhow::Result<()> {
+    let fd = iface.as_raw_fd();
+    let mut nonblock: libc::c_int = 1;
+    let result = unsafe { libc::ioctl(fd, libc::FIONBIO, &mut nonblock) };
+    if result == -1 {
+        Err(std::io::Error::last_os_error().into())
+    } else {
+        Ok(())
+    }
+}
+
+#[derive(Debug, Default)]
+struct TunTapHandlerInner {
+    wakers: Vec<Waker>,
+    set: HashSet<InterestType>,
+}
+
+#[derive(Debug, Clone, Default)]
+struct TunTapHandler {
+    inner: Arc<Mutex<TunTapHandlerInner>>,
+}
+impl InterestHandler for TunTapHandler {
+    fn push_interest(&mut self, interest: InterestType) {
+        let mut guard = self.inner.lock();
+        guard.set.insert(interest);
+        guard.wakers.drain(..).for_each(Waker::wake);
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        let mut guard = self.inner.lock();
+        guard.set.remove(&interest)
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        let guard = self.inner.lock();
+        guard.set.contains(&interest)
+    }
+}
+
+pub struct TunTapDriver {
+    iface: Iface,
+    handler: InterestWakerMap,
+    send_queue: VecDeque<Bytes>,
+    _interest: InterestGuard,
+    client: Box<dyn VirtualRawSocket + Sync + 'static>,
+    ips: Vec<IpCidr>,
+    routes: Vec<IpRoute>,
+    remote: RemoteNetworkingClient,
+    remote_driver: RemoteNetworkingClientDriver,
+}
+
+impl TunTapDriver {
+    pub fn client(&self) -> &RemoteNetworkingClient {
+        &self.remote
+    }
+
+    pub fn ips(&self) -> &Vec<IpCidr> {
+        &self.ips
+    }
+
+    pub fn routes(&self) -> &Vec<IpRoute> {
+        &self.routes
+    }
+}
+
+impl Future for TunTapDriver {
+    type Output = io::Result<()>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // Run the remote networking
+        match Pin::new(&mut self.remote_driver).poll(cx) {
+            Poll::Ready(()) => return Poll::Ready(Ok(())),
+            Poll::Pending => {}
+        }
+
+        // Add the waker before we drain all the the events
+        // we need to read and send
+        self.handler
+            .add(virtual_mio::InterestType::Readable, cx.waker());
+        self.handler
+            .add(virtual_mio::InterestType::Writable, cx.waker());
+
+        // First we drain the packet
+        while let Some(packet) = self.send_queue.pop_front() {
+            if self.client.try_send(&packet).is_ok() == false {
+                self.send_queue.push_front(packet);
+                break;
+            }
+        }
+
+        // Now we drain all the packets from the interface (but only if we have room)
+        if self.send_queue.is_empty() {
+            let mut chunk = [0u8; 65536];
+            loop {
+                match self.iface.recv(&mut chunk) {
+                    Ok(0) => return Poll::Ready(Err(ErrorKind::ConnectionReset.into())),
+                    Ok(data) => {
+                        // Send the packet down the client
+                        let packet = &chunk[..data];
+                        if self.client.try_send(packet).is_ok() == false {
+                            self.send_queue.push_back(Bytes::copy_from_slice(packet));
+                            break;
+                        }
+                        continue;
+                    }
+                    Err(err) if err.kind() == ErrorKind::WouldBlock => {
+                        break;
+                    }
+                    Err(err) => return Poll::Ready(Err(err)),
+                };
+            }
+        }
+
+        // The client interface expects
+        //
+        // UNSAFE: Drain the client interface method `try_recv` expects a MaybeUninit and
+        //         and guarantees it will fill in a portion of the memory
+        let mut chunk: [MaybeUninit<u8>; 65536] = unsafe { MaybeUninit::uninit().assume_init() };
+        loop {
+            let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..];
+            match self.client.try_recv(chunk_unsafe) {
+                Ok(0) => return Poll::Ready(Err(ErrorKind::ConnectionReset.into())),
+                Ok(data) => {
+                    let chunk_unsafe: &mut [u8] = unsafe { std::mem::transmute(chunk_unsafe) };
+                    let packet = &chunk_unsafe[..data];
+
+                    // Send the packet down the client
+                    self.iface.send(packet).ok();
+                    continue;
+                }
+                Err(NetworkError::WouldBlock) => {
+                    break;
+                }
+                Err(err) => {
+                    tracing::error!("packet recv error - {}", err);
+                    return Poll::Ready(Err(ErrorKind::Other.into()));
+                }
+            }
+        }
+
+        // Wait for some more interest or something to send
+        Poll::Pending
+    }
+}
+
+struct MioWrapper {
+    fd: RawFd,
+}
+
+impl event::Source for MioWrapper {
+    fn register(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+    ) -> io::Result<()> {
+        SourceFd(&self.fd).register(registry, token, interests)
+    }
+
+    fn reregister(
+        &mut self,
+        registry: &Registry,
+        token: Token,
+        interests: Interest,
+    ) -> io::Result<()> {
+        SourceFd(&self.fd).reregister(registry, token, interests)
+    }
+
+    fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
+        SourceFd(&self.fd).deregister(registry)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/opts.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/opts.rs
new file mode 100644
index 0000000..29b0689
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/opts.rs
@@ -0,0 +1,117 @@
+use anyhow::Context;
+use wasmer_api::WasmerClient;
+use wasmer_registry::WasmerConfig;
+
+#[derive(clap::Parser, Debug, Clone, Default)]
+pub struct ApiOpts {
+    #[clap(long, env = "WASMER_TOKEN")]
+    pub token: Option<String>,
+    #[clap(long)]
+    pub registry: Option<url::Url>,
+}
+
+struct Login {
+    url: url::Url,
+    token: Option<String>,
+}
+
+impl ApiOpts {
+    const PROD_REGISTRY: &'static str = "https://registry.wasmer.io/graphql";
+
+    fn load_config() -> Result<WasmerConfig, anyhow::Error> {
+        let wasmer_dir = WasmerConfig::get_wasmer_dir()
+            .map_err(|e| anyhow::anyhow!("no wasmer dir: '{e}' - did you run 'wasmer login'?"))?;
+
+        let config = WasmerConfig::from_file(&wasmer_dir).map_err(|e| {
+            anyhow::anyhow!("could not load config '{e}' - did you run wasmer login?")
+        })?;
+
+        Ok(config)
+    }
+
+    fn build_login(&self) -> Result<Login, anyhow::Error> {
+        let config = Self::load_config()?;
+
+        let login = if let Some(reg) = &self.registry {
+            let token = if let Some(token) = &self.token {
+                Some(token.clone())
+            } else {
+                config.registry.get_login_token_for_registry(reg.as_str())
+            };
+
+            Login {
+                url: reg.clone(),
+                token,
+            }
+        } else if let Some(login) = config.registry.current_login() {
+            let url = login.registry.parse::<url::Url>().with_context(|| {
+                format!(
+                    "config file specified invalid registry url: '{}'",
+                    login.registry
+                )
+            })?;
+
+            let token = self.token.clone().unwrap_or(login.token.clone());
+
+            Login {
+                url,
+                token: Some(token),
+            }
+        } else {
+            let url = Self::PROD_REGISTRY.parse::<url::Url>().unwrap();
+            Login {
+                url,
+                token: self.token.clone(),
+            }
+        };
+
+        Ok(login)
+    }
+
+    pub fn client_unauthennticated(&self) -> Result<WasmerClient, anyhow::Error> {
+        let login = self.build_login()?;
+
+        let client = wasmer_api::WasmerClient::new(login.url, "edge-cli")?;
+
+        let client = if let Some(token) = login.token {
+            client.with_auth_token(token)
+        } else {
+            client
+        };
+
+        Ok(client)
+    }
+
+    pub fn client(&self) -> Result<WasmerClient, anyhow::Error> {
+        let client = self.client_unauthennticated()?;
+        if client.auth_token().is_none() {
+            anyhow::bail!("no token provided - run 'wasmer login', specify --token=XXX, or set the WASMER_TOKEN env var");
+        }
+
+        Ok(client)
+    }
+}
+
+/// Formatting options for a single item.
+#[derive(clap::Parser, Debug, Default)]
+pub struct ItemFormatOpts {
+    /// Output format. (yaml, json, table)
+    #[clap(short = 'f', long, default_value = "yaml")]
+    pub format: crate::utils::render::ItemFormat,
+}
+
+/// Formatting options for a single item.
+#[derive(clap::Parser, Debug, Default)]
+pub struct ItemTableFormatOpts {
+    /// Output format. (yaml, json, table)
+    #[clap(short = 'f', long, default_value = "table")]
+    pub format: crate::utils::render::ItemFormat,
+}
+
+/// Formatting options for a list of items.
+#[derive(clap::Parser, Debug)]
+pub struct ListFormatOpts {
+    /// Output format. (yaml, json, table, item-table)
+    #[clap(short = 'f', long, default_value = "table")]
+    pub format: crate::utils::render::ListFormat,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/package_source.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/package_source.rs
new file mode 100644
index 0000000..4c54b1a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/package_source.rs
@@ -0,0 +1,121 @@
+//! Module for parsing and installing packages
+
+use std::str::FromStr;
+
+use url::Url;
+
+/// Source of a package
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub enum PackageSource {
+    /// Download from a URL
+    Url(Url),
+    /// Run a local file
+    File(String),
+    /// Download from a package
+    Package(wasmer_registry::Package),
+}
+
+impl Default for PackageSource {
+    fn default() -> Self {
+        PackageSource::File(String::new())
+    }
+}
+
+impl FromStr for PackageSource {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::parse(s)
+    }
+}
+
+impl PackageSource {
+    /// Parses a package source and transforms it to a URL or a File
+    pub fn parse(s: &str) -> Result<Self, String> {
+        // If the file is a http:// URL, run the URL
+        if let Ok(url) = url::Url::parse(s) {
+            if url.scheme() == "http" || url.scheme() == "https" {
+                return Ok(Self::Url(url));
+            }
+        }
+
+        Ok(match wasmer_registry::Package::from_str(s) {
+            Ok(o) => Self::Package(o),
+            Err(_) => Self::File(s.to_string()),
+        })
+    }
+}
+
+#[test]
+fn test_package_source() {
+    assert_eq!(
+        PackageSource::parse("registry.wasmer.io/graphql/python/python").unwrap(),
+        PackageSource::File("registry.wasmer.io/graphql/python/python".to_string()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("/absolute/path/test.wasm").unwrap(),
+        PackageSource::File("/absolute/path/test.wasm".to_string()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("C://absolute/path/test.wasm").unwrap(),
+        PackageSource::File("C://absolute/path/test.wasm".to_string()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("namespace/name@latest").unwrap(),
+        PackageSource::Package(wasmer_registry::Package {
+            namespace: "namespace".to_string(),
+            name: "name".to_string(),
+            version: Some("latest".to_string()),
+        })
+    );
+
+    assert_eq!(
+        PackageSource::parse("namespace/name@latest:command").unwrap(),
+        PackageSource::File("namespace/name@latest:command".to_string()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("namespace/name@1.0.2").unwrap(),
+        PackageSource::Package(wasmer_registry::Package {
+            namespace: "namespace".to_string(),
+            name: "name".to_string(),
+            version: Some("1.0.2".to_string()),
+        })
+    );
+
+    assert_eq!(
+        PackageSource::parse("namespace/name@1.0.2-rc.2").unwrap(),
+        PackageSource::Package(wasmer_registry::Package {
+            namespace: "namespace".to_string(),
+            name: "name".to_string(),
+            version: Some("1.0.2-rc.2".to_string()),
+        })
+    );
+
+    assert_eq!(
+        PackageSource::parse("namespace/name").unwrap(),
+        PackageSource::Package(wasmer_registry::Package {
+            namespace: "namespace".to_string(),
+            name: "name".to_string(),
+            version: None,
+        })
+    );
+
+    assert_eq!(
+        PackageSource::parse("https://wasmer.io/syrusakbary/python").unwrap(),
+        PackageSource::Url(url::Url::parse("https://wasmer.io/syrusakbary/python").unwrap()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("command").unwrap(),
+        PackageSource::File("command".to_string()),
+    );
+
+    assert_eq!(
+        PackageSource::parse("python@latest").unwrap(),
+        PackageSource::File("python@latest".to_string()),
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/store.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/store.rs
new file mode 100644
index 0000000..d758790
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/store.rs
@@ -0,0 +1,404 @@
+//! Common module with common used structures across different
+//! commands.
+
+// NOTE: A lot of this code depends on feature flags.
+// To not go crazy with annotations, some lints are disablefor the whole
+// module.
+#![allow(dead_code, unused_imports, unused_variables)]
+
+use std::path::PathBuf;
+use std::string::ToString;
+use std::sync::Arc;
+
+use anyhow::{bail, Result};
+#[cfg(feature = "sys")]
+use wasmer::sys::Features;
+use wasmer::*;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::CompilerConfig;
+#[cfg(feature = "compiler")]
+use wasmer_compiler::Engine;
+
+#[derive(Debug, Clone, clap::Parser, Default)]
+/// The compiler options
+pub struct StoreOptions {
+    #[cfg(feature = "compiler")]
+    #[clap(flatten)]
+    compiler: CompilerOptions,
+}
+
+#[derive(Debug, clap::Parser, Clone, Default)]
+/// The WebAssembly features that can be passed through the
+/// Command Line args.
+pub struct WasmFeatures {
+    /// Enable support for the SIMD proposal.
+    #[clap(long = "enable-simd")]
+    pub simd: bool,
+
+    /// Disable support for the threads proposal.
+    #[clap(long = "disable-threads")]
+    pub disable_threads: bool,
+
+    /// Deprecated, threads are enabled by default.
+    #[clap(long = "enable-threads")]
+    pub _threads: bool,
+
+    /// Enable support for the reference types proposal.
+    #[clap(long = "enable-reference-types")]
+    pub reference_types: bool,
+
+    /// Enable support for the multi value proposal.
+    #[clap(long = "enable-multi-value")]
+    pub multi_value: bool,
+
+    /// Enable support for the bulk memory proposal.
+    #[clap(long = "enable-bulk-memory")]
+    pub bulk_memory: bool,
+
+    /// Enable support for all pre-standard proposals.
+    #[clap(long = "enable-all")]
+    pub all: bool,
+}
+
+#[cfg(feature = "compiler")]
+#[derive(Debug, Clone, clap::Parser, Default)]
+/// The compiler options
+pub struct CompilerOptions {
+    /// Use Singlepass compiler.
+    #[clap(long, conflicts_with_all = &["cranelift", "llvm"])]
+    singlepass: bool,
+
+    /// Use Cranelift compiler.
+    #[clap(long, conflicts_with_all = &["singlepass", "llvm"])]
+    cranelift: bool,
+
+    /// Use LLVM compiler.
+    #[clap(long, conflicts_with_all = &["singlepass", "cranelift"])]
+    llvm: bool,
+
+    /// Enable compiler internal verification.
+    ///
+    /// Available for cranelift, LLVM and singlepass.
+    #[clap(long)]
+    enable_verifier: bool,
+
+    /// LLVM debug directory, where IR and object files will be written to.
+    ///
+    /// Only available for the LLVM compiler.
+    #[clap(long)]
+    llvm_debug_dir: Option<PathBuf>,
+
+    #[clap(flatten)]
+    features: WasmFeatures,
+}
+
+#[cfg(feature = "compiler")]
+impl CompilerOptions {
+    fn get_compiler(&self) -> Result<CompilerType> {
+        if self.cranelift {
+            Ok(CompilerType::Cranelift)
+        } else if self.llvm {
+            Ok(CompilerType::LLVM)
+        } else if self.singlepass {
+            Ok(CompilerType::Singlepass)
+        } else {
+            // Auto mode, we choose the best compiler for that platform
+            cfg_if::cfg_if! {
+                if #[cfg(all(feature = "cranelift", any(target_arch = "x86_64", target_arch = "aarch64")))] {
+                    Ok(CompilerType::Cranelift)
+                }
+                else if #[cfg(all(feature = "singlepass", any(target_arch = "x86_64", target_arch = "aarch64")))] {
+                    Ok(CompilerType::Singlepass)
+                }
+                else if #[cfg(feature = "llvm")] {
+                    Ok(CompilerType::LLVM)
+                } else {
+                    bail!("There are no available compilers for your architecture");
+                }
+            }
+        }
+    }
+
+    /// Get the enaled Wasm features.
+    pub fn get_features(&self, mut features: Features) -> Result<Features> {
+        if !self.features.disable_threads || self.features.all {
+            features.threads(true);
+        }
+        if self.features.disable_threads && !self.features.all {
+            features.threads(false);
+        }
+        if self.features.multi_value || self.features.all {
+            features.multi_value(true);
+        }
+        if self.features.simd || self.features.all {
+            features.simd(true);
+        }
+        if self.features.bulk_memory || self.features.all {
+            features.bulk_memory(true);
+        }
+        if self.features.reference_types || self.features.all {
+            features.reference_types(true);
+        }
+        Ok(features)
+    }
+
+    /// Gets the Store for a given target.
+    pub fn get_store_for_target(&self, target: Target) -> Result<(Store, CompilerType)> {
+        let (compiler_config, compiler_type) = self.get_compiler_config()?;
+        let engine = self.get_engine(target, compiler_config)?;
+        let store = Store::new(engine);
+        Ok((store, compiler_type))
+    }
+
+    /// Gets the Engine for a given target.
+    pub fn get_engine_for_target(&self, target: Target) -> Result<(Engine, CompilerType)> {
+        let (compiler_config, compiler_type) = self.get_compiler_config()?;
+        let engine = self.get_engine(target, compiler_config)?;
+        Ok((engine, compiler_type))
+    }
+
+    #[cfg(feature = "compiler")]
+    fn get_engine(
+        &self,
+        target: Target,
+        compiler_config: Box<dyn CompilerConfig>,
+    ) -> Result<Engine> {
+        let features = self.get_features(compiler_config.default_features_for_target(&target))?;
+        let engine: Engine = wasmer_compiler::EngineBuilder::new(compiler_config)
+            .set_features(Some(features))
+            .set_target(Some(target))
+            .engine();
+
+        Ok(engine)
+    }
+
+    /// Get the Compiler Config for the current options
+    #[allow(unused_variables)]
+    pub(crate) fn get_compiler_config(&self) -> Result<(Box<dyn CompilerConfig>, CompilerType)> {
+        let compiler = self.get_compiler()?;
+        let compiler_config: Box<dyn CompilerConfig> = match compiler {
+            CompilerType::Headless => bail!("The headless engine can't be chosen"),
+            #[cfg(feature = "singlepass")]
+            CompilerType::Singlepass => {
+                let mut config = wasmer_compiler_singlepass::Singlepass::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "cranelift")]
+            CompilerType::Cranelift => {
+                let mut config = wasmer_compiler_cranelift::Cranelift::new();
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(feature = "llvm")]
+            CompilerType::LLVM => {
+                use std::{fmt, fs::File, io::Write};
+
+                use wasmer_compiler_llvm::{
+                    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVM,
+                };
+                use wasmer_types::entity::EntityRef;
+                let mut config = LLVM::new();
+                struct Callbacks {
+                    debug_dir: PathBuf,
+                }
+                impl Callbacks {
+                    fn new(debug_dir: PathBuf) -> Result<Self> {
+                        // Create the debug dir in case it doesn't exist
+                        std::fs::create_dir_all(&debug_dir)?;
+                        Ok(Self { debug_dir })
+                    }
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn types_to_signature(types: &[Type]) -> String {
+                    types
+                        .iter()
+                        .map(|ty| match ty {
+                            Type::I32 => "i".to_string(),
+                            Type::I64 => "I".to_string(),
+                            Type::F32 => "f".to_string(),
+                            Type::F64 => "F".to_string(),
+                            Type::V128 => "v".to_string(),
+                            Type::ExternRef => "e".to_string(),
+                            Type::FuncRef => "r".to_string(),
+                        })
+                        .collect::<Vec<_>>()
+                        .join("")
+                }
+                // Converts a kind into a filename, that we will use to dump
+                // the contents of the IR object file to.
+                fn function_kind_to_filename(kind: &CompiledKind) -> String {
+                    match kind {
+                        CompiledKind::Local(local_index) => {
+                            format!("function_{}", local_index.index())
+                        }
+                        CompiledKind::FunctionCallTrampoline(func_type) => format!(
+                            "trampoline_call_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::DynamicFunctionTrampoline(func_type) => format!(
+                            "trampoline_dynamic_{}_{}",
+                            types_to_signature(func_type.params()),
+                            types_to_signature(func_type.results())
+                        ),
+                        CompiledKind::Module => "module".into(),
+                    }
+                }
+                impl LLVMCallbacks for Callbacks {
+                    fn preopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.preopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping pre optimized LLVM IR");
+                    }
+                    fn postopt_ir(&self, kind: &CompiledKind, module: &InkwellModule) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.postopt.ll", function_kind_to_filename(kind)));
+                        module
+                            .print_to_file(&path)
+                            .expect("Error while dumping post optimized LLVM IR");
+                    }
+                    fn obj_memory_buffer(
+                        &self,
+                        kind: &CompiledKind,
+                        memory_buffer: &InkwellMemoryBuffer,
+                    ) {
+                        let mut path = self.debug_dir.clone();
+                        path.push(format!("{}.o", function_kind_to_filename(kind)));
+                        let mem_buf_slice = memory_buffer.as_slice();
+                        let mut file = File::create(path)
+                            .expect("Error while creating debug object file from LLVM IR");
+                        let mut pos = 0;
+                        while pos < mem_buf_slice.len() {
+                            pos += file.write(&mem_buf_slice[pos..]).unwrap();
+                        }
+                    }
+                }
+
+                impl fmt::Debug for Callbacks {
+                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                        write!(f, "LLVMCallbacks")
+                    }
+                }
+
+                if let Some(ref llvm_debug_dir) = self.llvm_debug_dir {
+                    config.callbacks(Some(Arc::new(Callbacks::new(llvm_debug_dir.clone())?)));
+                }
+                if self.enable_verifier {
+                    config.enable_verifier();
+                }
+                Box::new(config)
+            }
+            #[cfg(not(all(feature = "singlepass", feature = "cranelift", feature = "llvm",)))]
+            compiler => {
+                bail!(
+                    "The `{}` compiler is not included in this binary.",
+                    compiler.to_string()
+                )
+            }
+        };
+
+        #[allow(unreachable_code)]
+        Ok((compiler_config, compiler))
+    }
+}
+
+/// The compiler used for the store
+#[derive(Debug, PartialEq, Eq)]
+#[allow(clippy::upper_case_acronyms, dead_code)]
+pub enum CompilerType {
+    /// Singlepass compiler
+    Singlepass,
+    /// Cranelift compiler
+    Cranelift,
+    /// LLVM compiler
+    LLVM,
+    /// Headless compiler
+    #[allow(dead_code)]
+    Headless,
+}
+
+impl CompilerType {
+    /// Return all enabled compilers
+    #[allow(dead_code)]
+    pub fn enabled() -> Vec<CompilerType> {
+        vec![
+            #[cfg(feature = "singlepass")]
+            Self::Singlepass,
+            #[cfg(feature = "cranelift")]
+            Self::Cranelift,
+            #[cfg(feature = "llvm")]
+            Self::LLVM,
+        ]
+    }
+}
+
+impl ToString for CompilerType {
+    fn to_string(&self) -> String {
+        match self {
+            Self::Singlepass => "singlepass".to_string(),
+            Self::Cranelift => "cranelift".to_string(),
+            Self::LLVM => "llvm".to_string(),
+            Self::Headless => "headless".to_string(),
+        }
+    }
+}
+
+#[cfg(feature = "compiler")]
+impl StoreOptions {
+    /// Gets the store for the host target, with the compiler name selected
+    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
+        let target = Target::default();
+        self.get_store_for_target(target)
+    }
+
+    /// Gets the store for a given target, with the compiler name selected.
+    pub fn get_store_for_target(&self, target: Target) -> Result<(Store, CompilerType)> {
+        let (compiler_config, compiler_type) = self.compiler.get_compiler_config()?;
+        let engine = self.get_engine_with_compiler(target, compiler_config)?;
+        let store = Store::new(engine);
+        Ok((store, compiler_type))
+    }
+
+    #[cfg(feature = "compiler")]
+    fn get_engine_with_compiler(
+        &self,
+        target: Target,
+        compiler_config: Box<dyn CompilerConfig>,
+    ) -> Result<Engine> {
+        let engine = self.compiler.get_engine(target, compiler_config)?;
+        Ok(engine)
+    }
+}
+
+// If we don't have a compiler, but we have an engine
+#[cfg(not(any(feature = "compiler", feature = "jsc")))]
+impl StoreOptions {
+    fn get_engine_headless(&self) -> Result<wasmer_compiler::Engine> {
+        let engine: wasmer_compiler::Engine = wasmer_compiler::EngineBuilder::headless().engine();
+        Ok(engine)
+    }
+
+    /// Get the store (headless engine)
+    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
+        let engine = self.get_engine_headless()?;
+        let store = Store::new(engine);
+        Ok((store, CompilerType::Headless))
+    }
+}
+
+#[cfg(all(not(feature = "compiler"), feature = "jsc"))]
+impl StoreOptions {
+    /// Get the store (headless engine)
+    pub fn get_store(&self) -> Result<(Store, CompilerType)> {
+        let store = Store::default();
+        Ok((store, CompilerType::Headless))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/types.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/types.rs
new file mode 100644
index 0000000..68897ca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/types.rs
@@ -0,0 +1,158 @@
+use comfy_table::Table;
+use wasmer_api::types::{DeployApp, DeployAppVersion, DnsDomain, DnsDomainWithRecords, Namespace};
+
+use crate::utils::render::CliRender;
+
+impl CliRender for DnsDomain {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([vec!["Domain".to_string(), self.name.clone()]]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        if items.is_empty() {
+            return String::new();
+        }
+        let mut table = Table::new();
+        table.set_header(vec!["Domain".to_string(), "Owner".to_string()]);
+        table.add_rows(
+            items
+                .iter()
+                .map(|ns| vec![ns.name.clone(), ns.owner.global_name.clone()]),
+        );
+        table.to_string()
+    }
+}
+
+impl CliRender for DnsDomainWithRecords {
+    fn render_item_table(&self) -> String {
+        let mut output = String::new();
+        let mut table = Table::new();
+        table
+            .load_preset(comfy_table::presets::UTF8_FULL_CONDENSED)
+            .set_header(vec![
+                "Type".to_string(),
+                "Name".to_string(),
+                "TTL".to_string(),
+                "Value".to_string(),
+            ]);
+        let mut rows: Vec<Vec<String>> = vec![];
+        if let Some(ref records) = self.records {
+            records.iter().flatten().for_each(|record| {
+                rows.push(vec![
+                    record.record_type().to_string(),
+                    record.name().unwrap_or("<no name>").to_string(),
+                    record
+                        .ttl()
+                        .expect("expected a TTL value for record")
+                        .to_string(),
+                    record.text().to_string(),
+                ]);
+            });
+        }
+
+        table.add_rows(rows);
+        output += &table.to_string();
+        output
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        if items.is_empty() {
+            return String::new();
+        }
+        let mut table = Table::new();
+        table.set_header(vec!["Domain".to_string()]);
+        table.add_rows(items.iter().map(|ns| vec![ns.name.clone()]));
+        table.to_string()
+    }
+}
+
+impl CliRender for Namespace {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec!["Namespace".to_string(), self.name.clone()],
+            vec!["Id".to_string(), self.id.inner().to_string()],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec!["Namespace".to_string(), "Id".to_string()]);
+        table.add_rows(
+            items
+                .iter()
+                .map(|ns| vec![ns.name.clone(), ns.id.inner().to_string()]),
+        );
+        table.to_string()
+    }
+}
+
+impl CliRender for DeployApp {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec![
+                "App".to_string(),
+                format!("{}/{}", self.owner.global_name, self.name),
+            ],
+            vec!["Version".to_string(), self.active_version.version.clone()],
+            vec![
+                "Created".to_string(),
+                self.active_version.created_at.0.clone(),
+            ],
+            vec!["Id".to_string(), self.id.inner().to_string()],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "App".to_string(),
+            "Version".to_string(),
+            "Created".to_string(),
+            "Id".to_string(),
+        ]);
+        table.add_rows(items.iter().map(|app| {
+            vec![
+                format!("{}/{}", app.owner.global_name, app.name),
+                app.active_version.version.clone(),
+                app.active_version.created_at.0.clone(),
+                app.id.inner().to_string(),
+            ]
+        }));
+        table.to_string()
+    }
+}
+
+impl CliRender for DeployAppVersion {
+    fn render_item_table(&self) -> String {
+        let mut table = Table::new();
+        table.add_rows([
+            vec!["Version name".to_string(), self.version.clone()],
+            vec!["Created".to_string(), self.created_at.0.clone()],
+            vec!["Id".to_string(), self.id.inner().to_string()],
+        ]);
+        table.to_string()
+    }
+
+    fn render_list_table(items: &[Self]) -> String {
+        let mut table = Table::new();
+        table.set_header(vec![
+            "Version name".to_string(),
+            "Created".to_string(),
+            "Id".to_string(),
+        ]);
+        table.add_rows(items.iter().map(|ver| {
+            vec![
+                ver.version.clone(),
+                ver.created_at.0.clone(),
+                ver.id.inner().to_string(),
+            ]
+        }));
+        table.to_string()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/mod.rs
new file mode 100644
index 0000000..5b687d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/mod.rs
@@ -0,0 +1,480 @@
+//! Utility functions for the WebAssembly module
+
+pub(crate) mod package_wizard;
+pub(crate) mod prompts;
+pub(crate) mod render;
+
+use std::{
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+
+use anyhow::{bail, Context as _, Result};
+use edge_schema::schema::StringWebcIdent;
+use once_cell::sync::Lazy;
+use regex::Regex;
+use wasmer_api::WasmerClient;
+use wasmer_wasix::runners::MappedDirectory;
+
+fn retrieve_alias_pathbuf(alias: &str, real_dir: &str) -> Result<MappedDirectory> {
+    let pb = PathBuf::from(&real_dir).canonicalize()?;
+    if let Ok(pb_metadata) = pb.metadata() {
+        if !pb_metadata.is_dir() {
+            bail!("\"{}\" exists, but it is not a directory", &real_dir);
+        }
+    } else {
+        bail!("Directory \"{}\" does not exist", &real_dir);
+    }
+    Ok(MappedDirectory {
+        guest: alias.to_string(),
+        host: pb,
+    })
+}
+
+/// Parses a mapdir from a string
+pub fn parse_mapdir(entry: &str) -> Result<MappedDirectory> {
+    // We try first splitting by `::`
+    if let [alias, real_dir] = entry.split("::").collect::<Vec<&str>>()[..] {
+        retrieve_alias_pathbuf(alias, real_dir)
+    }
+    // And then we try splitting by `:` (for compatibility with previous API)
+    else if let [alias, real_dir] = entry.splitn(2, ':').collect::<Vec<&str>>()[..] {
+        retrieve_alias_pathbuf(alias, real_dir)
+    } else {
+        bail!(
+            "Directory mappings must consist of two paths separate by a `::` or `:`. Found {}",
+            &entry
+        )
+    }
+}
+
+/// Parses an environment variable.
+pub fn parse_envvar(entry: &str) -> Result<(String, String)> {
+    let entry = entry.trim();
+
+    match entry.find('=') {
+        None => bail!(
+            "Environment variable must be of the form `<name>=<value>`; found `{}`",
+            &entry
+        ),
+
+        Some(0) => bail!(
+            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `{}`",
+            &entry
+        ),
+
+        Some(position) if position == entry.len() - 1 => bail!(
+            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `{}`",
+            &entry
+        ),
+
+        Some(position) => Ok((entry[..position].into(), entry[position + 1..].into())),
+    }
+}
+
+pub(crate) const DEFAULT_PACKAGE_MANIFEST_FILE: &str = "wasmer.toml";
+
+/// Load a package manifest from the manifest file.
+///
+/// Path can either be a directory, or a concrete file path.
+pub fn load_package_manifest(
+    path: &Path,
+) -> Result<Option<(PathBuf, wasmer_toml::Manifest)>, anyhow::Error> {
+    let file_path = if path.is_file() {
+        path.to_owned()
+    } else {
+        path.join(DEFAULT_PACKAGE_MANIFEST_FILE)
+    };
+
+    let contents = match std::fs::read_to_string(&file_path) {
+        Ok(c) => c,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(None),
+        Err(err) => {
+            return Err(err).with_context(|| {
+                format!(
+                    "Could not read package manifest at '{}'",
+                    file_path.display()
+                )
+            })
+        }
+    };
+    let manifest = wasmer_toml::Manifest::parse(&contents).with_context(|| {
+        format!(
+            "Could not parse package config at: '{}'",
+            file_path.display()
+        )
+    })?;
+    Ok(Some((file_path, manifest)))
+}
+
+/// Ask a user for a package name.
+///
+/// Will continue looping until the user provides a valid name.
+pub fn prompt_for_package_name(
+    message: &str,
+    default: Option<&str>,
+) -> Result<StringWebcIdent, anyhow::Error> {
+    loop {
+        let raw: String = dialoguer::Input::new()
+            .with_prompt(message)
+            .with_initial_text(default.unwrap_or_default())
+            .interact_text()
+            .context("could not read user input")?;
+
+        match raw.parse::<StringWebcIdent>() {
+            Ok(p) => break Ok(p),
+            Err(err) => {
+                eprintln!("invalid package name: {err}");
+            }
+        }
+    }
+}
+
+/// Defines how to check for a package.
+pub enum PackageCheckMode {
+    /// The package must exist in the registry.
+    MustExist,
+    /// The package must NOT exist in the registry.
+    #[allow(dead_code)]
+    MustNotExist,
+}
+
+/// Ask for a package name.
+///
+/// Will continue looping until the user provides a valid name.
+///
+/// If an API is provided, will check if the package exists.
+pub async fn prompt_for_package(
+    message: &str,
+    default: Option<&str>,
+    check: Option<PackageCheckMode>,
+    client: Option<&WasmerClient>,
+) -> Result<(StringWebcIdent, Option<wasmer_api::types::Package>), anyhow::Error> {
+    loop {
+        let name = prompt_for_package_name(message, default)?;
+
+        if let Some(check) = &check {
+            let api = client.expect("Check mode specified, but no API provided");
+
+            let pkg = wasmer_api::query::get_package(api, name.to_string())
+                .await
+                .context("could not query backend for package")?;
+
+            match check {
+                PackageCheckMode::MustExist => {
+                    if let Some(pkg) = pkg {
+                        break Ok((name, Some(pkg)));
+                    } else {
+                        eprintln!("Package '{name}' does not exist");
+                    }
+                }
+                PackageCheckMode::MustNotExist => {
+                    if pkg.is_none() {
+                        break Ok((name, None));
+                    } else {
+                        eprintln!("Package '{name}' already exists");
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Re-publish a package with an increased minor version.
+pub async fn republish_package_with_bumped_version(
+    client: &WasmerClient,
+    manifest_path: &Path,
+    mut manifest: wasmer_toml::Manifest,
+) -> Result<wasmer_toml::Manifest, anyhow::Error> {
+    // Try to load existing version.
+    // If it does not exist yet, we don't need to increment.
+
+    let current_opt = wasmer_api::query::get_package(client, manifest.package.name.clone())
+        .await
+        .context("could not load package info from backend")?
+        .and_then(|x| x.last_version);
+
+    let new_version = if let Some(current) = &current_opt {
+        let mut v = semver::Version::parse(&current.version)
+            .with_context(|| format!("Could not parse package version: '{}'", current.version))?;
+
+        v.patch += 1;
+
+        // The backend does not have a reliable way to return the latest version,
+        // so we have to check each version in a loop.
+        loop {
+            let version = format!("={}", v);
+            let version = wasmer_api::query::get_package_version(
+                client,
+                manifest.package.name.clone(),
+                version.clone(),
+            )
+            .await
+            .context("could not load package info from backend")?;
+
+            if version.is_some() {
+                v.patch += 1;
+            } else {
+                break;
+            }
+        }
+
+        v
+    } else {
+        manifest.package.version
+    };
+
+    manifest.package.version = new_version;
+    let contents = toml::to_string(&manifest).with_context(|| {
+        format!(
+            "could not persist manifest to '{}'",
+            manifest_path.display()
+        )
+    })?;
+
+    let manifest_path = if manifest_path.is_file() {
+        manifest_path.to_owned()
+    } else {
+        manifest_path.join(DEFAULT_PACKAGE_MANIFEST_FILE)
+    };
+
+    std::fs::write(manifest_path.clone(), contents)
+        .with_context(|| format!("could not write manifest to '{}'", manifest_path.display()))?;
+
+    let dir = manifest_path
+        .parent()
+        .context("could not determine wasmer.toml parent directory")?
+        .to_owned();
+
+    let registry = client.graphql_endpoint().to_string();
+    let token = client
+        .auth_token()
+        .context("no auth token configured - run 'wasmer login'")?
+        .to_string();
+
+    let publish = wasmer_registry::package::builder::Publish {
+        registry: Some(registry),
+        dry_run: false,
+        quiet: false,
+        package_name: None,
+        version: None,
+        wait: wasmer_registry::publish::PublishWait::new_none(),
+        token,
+        no_validate: true,
+        package_path: Some(dir.to_str().unwrap().to_string()),
+        // Use a high timeout to prevent interrupting uploads of
+        // large packages.
+        timeout: std::time::Duration::from_secs(60 * 60 * 12),
+    };
+
+    // Publish uses a blocking http client internally, which leads to a
+    // "can't drop a runtime within an async context" error, so this has
+    // to be run in a separate thread.
+    std::thread::spawn(move || publish.execute())
+        .join()
+        .map_err(|e| anyhow::format_err!("failed to publish package: {:?}", e))??;
+
+    Ok(manifest)
+}
+
+/// The identifier for an app or package in the form, `owner/package@version`,
+/// where the `owner` and `version` are optional.
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) struct Identifier {
+    /// The package's name.
+    pub name: String,
+    /// The package's owner, typically a username or namespace.
+    pub owner: Option<String>,
+    /// The package's version number.
+    pub version: Option<String>,
+}
+
+impl Identifier {
+    pub fn new(name: impl Into<String>) -> Self {
+        Identifier {
+            name: name.into(),
+            owner: None,
+            version: None,
+        }
+    }
+
+    pub fn with_owner(self, owner: impl Into<String>) -> Self {
+        Identifier {
+            owner: Some(owner.into()),
+            ..self
+        }
+    }
+
+    pub fn with_version(self, version: impl Into<String>) -> Self {
+        Identifier {
+            version: Some(version.into()),
+            ..self
+        }
+    }
+}
+
+impl FromStr for Identifier {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        const PATTERN: &str = r"^(?x)
+            (?:
+                (?P<owner>[a-zA-Z][\w\d_.-]*)
+                /
+            )?
+            (?P<name>[a-zA-Z][\w\d_.-]*)
+            (?:
+                @
+                (?P<version>[\w\d.]+)
+            )?
+            $
+        ";
+        static RE: Lazy<Regex> = Lazy::new(|| Regex::new(PATTERN).unwrap());
+
+        let caps = RE.captures(s).context(
+            "Invalid package identifier, expected something like namespace/package@version",
+        )?;
+
+        let mut identifier = Identifier::new(&caps["name"]);
+
+        if let Some(owner) = caps.name("owner") {
+            identifier = identifier.with_owner(owner.as_str());
+        }
+
+        if let Some(version) = caps.name("version") {
+            identifier = identifier.with_version(version.as_str());
+        }
+
+        Ok(identifier)
+    }
+}
+
+/// Merge two yaml values by recursively merging maps from b into a.
+///
+/// Preserves old values that were not in b.
+pub(crate) fn merge_yaml_values(a: &serde_yaml::Value, b: &serde_yaml::Value) -> serde_yaml::Value {
+    use serde_yaml::Value as V;
+    match (a, b) {
+        (V::Mapping(a), V::Mapping(b)) => {
+            let mut m = a.clone();
+            for (k, v) in b.iter() {
+                let newval = if let Some(old) = a.get(k) {
+                    merge_yaml_values(old, v)
+                } else {
+                    v.clone()
+                };
+                m.insert(k.clone(), newval);
+            }
+            V::Mapping(m)
+        }
+        _ => b.clone(),
+    }
+}
+
+// pub(crate) fn shell(cmd: &str, args: &[&str]) -> anyhow::Result<Option<i32>> {
+//     let ecode = Command::new(cmd).args(args).spawn()?.wait()?;
+//     if ecode.success() {
+//         Ok(ecode.code())
+//     } else {
+//         Err(anyhow::format_err!(
+//             "failed to execute linux command (code={:?})",
+//             ecode.code()
+//         ))
+//     }
+// }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_merge_yaml_values() {
+        use serde_yaml::Value;
+        let v1 = r#"
+a: a
+b:
+  b1: b1
+c: c
+        "#;
+        let v2 = r#"
+a: a1
+b:
+  b2: b2
+        "#;
+        let v3 = r#"
+a: a1
+b:
+  b1: b1
+  b2: b2
+c: c
+        "#;
+
+        let a: Value = serde_yaml::from_str(v1).unwrap();
+        let b: Value = serde_yaml::from_str(v2).unwrap();
+        let c: Value = serde_yaml::from_str(v3).unwrap();
+        let merged = merge_yaml_values(&a, &b);
+        assert_eq!(merged, c);
+    }
+
+    #[test]
+    fn parse_valid_identifiers() {
+        let inputs = [
+            ("python", Identifier::new("python")),
+            (
+                "syrusakbary/python",
+                Identifier::new("python").with_owner("syrusakbary"),
+            ),
+            (
+                "wasmer/wasmer.io",
+                Identifier::new("wasmer.io").with_owner("wasmer"),
+            ),
+            (
+                "syrusakbary/python@1.2.3",
+                Identifier::new("python")
+                    .with_owner("syrusakbary")
+                    .with_version("1.2.3"),
+            ),
+            (
+                "python@1.2.3",
+                Identifier::new("python").with_version("1.2.3"),
+            ),
+        ];
+
+        for (src, expected) in inputs {
+            let identifier = Identifier::from_str(src).expect(src);
+            assert_eq!(identifier, expected);
+        }
+    }
+
+    #[test]
+    fn invalid_package_identifiers() {
+        let inputs = ["", "$", "python/", "/python", "python@", "."];
+
+        for input in inputs {
+            let result = Identifier::from_str(input);
+            assert!(result.is_err(), "Got {result:?} from {input:?}");
+        }
+    }
+
+    #[test]
+    fn test_parse_envvar() {
+        assert_eq!(
+            parse_envvar("A").unwrap_err().to_string(),
+            "Environment variable must be of the form `<name>=<value>`; found `A`"
+        );
+        assert_eq!(
+            parse_envvar("=A").unwrap_err().to_string(),
+            "Environment variable is not well formed, the `name` is missing in `<name>=<value>`; got `=A`"
+        );
+        assert_eq!(
+            parse_envvar("A=").unwrap_err().to_string(),
+            "Environment variable is not well formed, the `value` is missing in `<name>=<value>`; got `A=`"
+        );
+        assert_eq!(parse_envvar("A=B").unwrap(), ("A".into(), "B".into()));
+        assert_eq!(parse_envvar("   A=B\t").unwrap(), ("A".into(), "B".into()));
+        assert_eq!(
+            parse_envvar("A=B=C=D").unwrap(),
+            ("A".into(), "B=C=D".into())
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/mod.rs
new file mode 100644
index 0000000..e036e30
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/mod.rs
@@ -0,0 +1,512 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::Context;
+use dialoguer::Select;
+use edge_schema::schema::{StringWebcIdent, WebcIdent};
+use wasmer_api::{types::UserWithNamespaces, WasmerClient};
+
+use super::prompts::PackageCheckMode;
+
+const WASM_STATIC_SERVER_PACKAGE: &str = "wasmer/static-web-server";
+const WASM_STATIC_SERVER_VERSION: &str = "1";
+
+const WASMER_WINTER_JS_PACKAGE: &str = "wasmer/winterjs";
+const WASMER_WINTER_JS_VERSION: &str = "*";
+
+const WASM_PYTHON_PACKAGE: &str = "wasmer/python";
+const WASM_PYTHON_VERSION: &str = "3.12.6";
+
+const SAMPLE_INDEX_HTML: &str = include_str!("./templates/static-site/index.html");
+const SAMPLE_JS_WORKER: &str = include_str!("./templates/js-worker/index.js");
+const SAMPLE_PY_APPLICATION: &str = include_str!("./templates/py-application/main.py");
+
+#[derive(clap::ValueEnum, Clone, Copy, Debug)]
+pub enum PackageType {
+    #[clap(name = "regular")]
+    Regular,
+    /// A static website.
+    #[clap(name = "static-website")]
+    StaticWebsite,
+    /// A js-worker
+    #[clap(name = "js-worker")]
+    JsWorker,
+    /// A py-worker
+    #[clap(name = "py-application")]
+    PyApplication,
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum CreateMode {
+    Create,
+    SelectExisting,
+    #[allow(dead_code)]
+    CreateOrSelect,
+}
+
+fn prompt_for_pacakge_type() -> Result<PackageType, anyhow::Error> {
+    Select::new()
+        .with_prompt("What type of package do you want to create?")
+        .items(&["Basic pacakge", "Static website"])
+        .interact()
+        .map(|idx| match idx {
+            0 => PackageType::Regular,
+            1 => PackageType::StaticWebsite,
+            _ => unreachable!(),
+        })
+        .map_err(anyhow::Error::from)
+}
+
+#[derive(Debug)]
+pub struct PackageWizard {
+    pub path: PathBuf,
+    pub type_: Option<PackageType>,
+
+    pub create_mode: CreateMode,
+
+    /// Namespace to use.
+    pub namespace: Option<String>,
+    /// Default namespace to use.
+    /// Will still show a prompt, with this as the default value.
+    /// Ignored if [`Self::namespace`] is set.
+    pub namespace_default: Option<String>,
+
+    /// Pre-configured package name.
+    pub name: Option<String>,
+
+    pub user: Option<UserWithNamespaces>,
+}
+
+pub struct PackageWizardOutput {
+    pub ident: StringWebcIdent,
+    pub api: Option<wasmer_api::types::Package>,
+    pub local_path: Option<PathBuf>,
+    pub local_manifest: Option<wasmer_toml::Manifest>,
+}
+
+impl PackageWizard {
+    fn build_new_package(&self) -> Result<PackageWizardOutput, anyhow::Error> {
+        // New package
+
+        let owner = if let Some(namespace) = &self.namespace {
+            namespace.clone()
+        } else {
+            super::prompts::prompt_for_namespace(
+                "Who should own this package?",
+                None,
+                self.user.as_ref(),
+            )?
+        };
+
+        let ty = match self.type_ {
+            Some(t) => t,
+            None => prompt_for_pacakge_type()?,
+        };
+
+        let name = if let Some(name) = &self.name {
+            name.clone()
+        } else {
+            super::prompts::prompt_for_ident(
+                format!(
+                    "What should the package be called? It will be published under {}",
+                    owner
+                )
+                .as_str(),
+                None,
+            )?
+        };
+
+        if !self.path.is_dir() {
+            std::fs::create_dir_all(&self.path).with_context(|| {
+                format!("Failed to create directory: '{}'", self.path.display())
+            })?;
+        }
+
+        let ident = WebcIdent {
+            repository: None,
+            namespace: owner,
+            name,
+            tag: Some("0.1.0".to_string()),
+        };
+        let manifest = match ty {
+            PackageType::Regular => todo!(),
+            PackageType::StaticWebsite => initialize_static_site(&self.path, &ident)?,
+            PackageType::JsWorker => initialize_js_worker(&self.path, &ident)?,
+            PackageType::PyApplication => initialize_py_worker(&self.path, &ident)?,
+        };
+
+        let manifest_path = self.path.join("wasmer.toml");
+        let manifest_raw = manifest
+            .to_string()
+            .context("could not serialize package manifest")?;
+        std::fs::write(manifest_path, manifest_raw)
+            .with_context(|| format!("Failed to write manifest to '{}'", self.path.display()))?;
+
+        Ok(PackageWizardOutput {
+            ident: ident.into(),
+            api: None,
+            local_path: Some(self.path.clone()),
+            local_manifest: Some(manifest),
+        })
+    }
+
+    async fn prompt_existing_package(
+        &self,
+        api: Option<&WasmerClient>,
+    ) -> Result<PackageWizardOutput, anyhow::Error> {
+        // Existing package
+        let check = if api.is_some() {
+            Some(PackageCheckMode::MustExist)
+        } else {
+            None
+        };
+
+        eprintln!("Enter the name of an existing package:");
+        let (ident, api) = super::prompts::prompt_for_package("Package", None, check, api).await?;
+        Ok(PackageWizardOutput {
+            ident,
+            api,
+            local_path: None,
+            local_manifest: None,
+        })
+    }
+
+    pub async fn run(
+        self,
+        api: Option<&WasmerClient>,
+    ) -> Result<PackageWizardOutput, anyhow::Error> {
+        match self.create_mode {
+            CreateMode::Create => self.build_new_package(),
+            CreateMode::SelectExisting => self.prompt_existing_package(api).await,
+            CreateMode::CreateOrSelect => {
+                let index = Select::new()
+                    .with_prompt("What package do you want to use?")
+                    .items(&["Create new package", "Use existing package"])
+                    .default(0)
+                    .interact()?;
+
+                match index {
+                    0 => self.build_new_package(),
+                    1 => self.prompt_existing_package(api).await,
+                    other => {
+                        unreachable!("Unexpected index: {other}");
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn initialize_static_site(
+    path: &Path,
+    ident: &WebcIdent,
+) -> Result<wasmer_toml::Manifest, anyhow::Error> {
+    let full_name = format!("{}/{}", ident.namespace, ident.name);
+
+    let pubdir_name = "public";
+    let pubdir = path.join(pubdir_name);
+    if !pubdir.is_dir() {
+        std::fs::create_dir_all(&pubdir)
+            .with_context(|| format!("Failed to create directory: '{}'", pubdir.display()))?;
+    }
+    let index = pubdir.join("index.html");
+
+    let static_html = SAMPLE_INDEX_HTML.replace("{{title}}", &full_name);
+
+    if !index.is_file() {
+        std::fs::write(&index, static_html.as_str())
+            .with_context(|| "Could not write index.html file".to_string())?;
+    } else {
+        // The index.js file already exists, so we can ask the user if they want to overwrite it
+        let should_overwrite = dialoguer::Confirm::new()
+            .with_prompt("index.html already exists. Do you want to overwrite it?")
+            .interact()
+            .unwrap();
+        if should_overwrite {
+            std::fs::write(&index, static_html.as_str())
+                .with_context(|| "Could not write index.html file".to_string())?;
+        }
+    }
+
+    let raw_static_site_toml = format!(
+        r#"
+[package]
+name = "{}"
+version = "0.1.0"
+description = "{} website"
+
+[dependencies]
+"{}" = "{}"
+
+[fs]
+public = "{}"
+"#,
+        full_name.clone(),
+        full_name,
+        WASM_STATIC_SERVER_PACKAGE,
+        WASM_STATIC_SERVER_VERSION,
+        pubdir_name
+    );
+
+    let manifest = wasmer_toml::Manifest::parse(raw_static_site_toml.as_str())
+        .map_err(|e| anyhow::anyhow!("Could not parse js worker manifest: {}", e))?;
+
+    Ok(manifest)
+}
+
+fn initialize_js_worker(
+    path: &Path,
+    ident: &WebcIdent,
+) -> Result<wasmer_toml::Manifest, anyhow::Error> {
+    let full_name = format!("{}/{}", ident.namespace, ident.name);
+
+    let srcdir_name = "src";
+    let srcdir = path.join(srcdir_name);
+    if !srcdir.is_dir() {
+        std::fs::create_dir_all(&srcdir)
+            .with_context(|| format!("Failed to create directory: '{}'", srcdir.display()))?;
+    }
+
+    let index_js = srcdir.join("index.js");
+
+    let sample_js = SAMPLE_JS_WORKER.replace("{{package}}", &full_name);
+
+    if !index_js.is_file() {
+        std::fs::write(&index_js, sample_js.as_str())
+            .with_context(|| "Could not write index.js file".to_string())?;
+    }
+
+    // get the remote repository if it exists
+    // Todo: add this to the manifest
+    // let remote_repo_url = Command::new("git")
+    //     .arg("remote")
+    //     .arg("get-url")
+    //     .arg("origin")
+    //     .output()
+    //     .map_or("".to_string(), |f| String::from_utf8(f.stdout).unwrap());
+
+    let raw_js_worker_toml = format!(
+        r#"
+[package]
+name = "{name}"
+version = "0.1.0"
+description = "{name} js worker"
+
+[dependencies]
+"{winterjs_pkg}" = "{winterjs_version}"
+
+[fs]
+"/src" = "./src"
+
+[[command]]
+name = "script"
+module = "{winterjs_pkg}:winterjs"
+runner = "https://webc.org/runner/wasi"
+
+[command.annotations.wasi]
+main-args = ["/src/index.js"]
+env = ["JS_PATH=/src/index.js"]
+"#,
+        name = full_name,
+        winterjs_pkg = WASMER_WINTER_JS_PACKAGE,
+        winterjs_version = WASMER_WINTER_JS_VERSION,
+    );
+
+    let manifest = wasmer_toml::Manifest::parse(raw_js_worker_toml.as_str())
+        .map_err(|e| anyhow::anyhow!("Could not parse js worker manifest: {}", e))?;
+
+    Ok(manifest)
+}
+
+fn initialize_py_worker(
+    path: &Path,
+    ident: &WebcIdent,
+) -> Result<wasmer_toml::Manifest, anyhow::Error> {
+    let full_name = format!("{}/{}", ident.namespace, ident.name);
+
+    let appdir_name = "src";
+    let appdir = path.join(appdir_name);
+    if !appdir.is_dir() {
+        std::fs::create_dir_all(&appdir)
+            .with_context(|| format!("Failed to create directory: '{}'", appdir.display()))?;
+    }
+    let main_py = appdir.join("main.py");
+
+    let sample_main = SAMPLE_PY_APPLICATION.replace("{{package}}", &full_name);
+
+    if !main_py.is_file() {
+        std::fs::write(&main_py, sample_main.as_str())
+            .with_context(|| "Could not write main.py file".to_string())?;
+    }
+
+    // Todo: add this to the manifest
+    // let remote_repo_url = Command::new("git")
+    //     .arg("remote")
+    //     .arg("get-url")
+    //     .arg("origin")
+    //     .output()
+    //     .map_or("".to_string(), |f| String::from_utf8(f.stdout).unwrap());
+
+    let raw_py_worker_toml = format!(
+        r#"
+[package]
+name = "{}"
+version = "0.1.0"
+description = "{} py worker"
+
+[dependencies]
+"{}" = "{}"
+
+[fs]
+"/src" = "./src"
+# "/.env" = "./.env/" # Bundle the virtualenv
+
+[[command]]
+name = "script"
+module = "{}:python" # The "python" atom from "wasmer/python"
+runner = "wasi"
+
+[command.annotations.wasi]
+main-args = ["/src/main.py"]
+# env = ["PYTHON_PATH=/app/.env:/etc/python3.12/site-packages"] # Make our virtualenv accessible    
+"#,
+        full_name.clone(),
+        full_name,
+        WASM_PYTHON_PACKAGE,
+        WASM_PYTHON_VERSION,
+        WASM_PYTHON_PACKAGE
+    );
+
+    let manifest = wasmer_toml::Manifest::parse(raw_py_worker_toml.as_str())
+        .map_err(|e| anyhow::anyhow!("Could not parse py worker manifest: {}", e))?;
+
+    Ok(manifest)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_package_wizard_create_static_site() {
+        let dir = tempfile::tempdir().unwrap();
+
+        PackageWizard {
+            path: dir.path().to_owned(),
+            type_: Some(PackageType::StaticWebsite),
+            create_mode: CreateMode::Create,
+            namespace: Some("christoph".to_string()),
+            namespace_default: None,
+            name: Some("test123".to_string()),
+            user: None,
+        }
+        .run(None)
+        .await
+        .unwrap();
+
+        let manifest = std::fs::read_to_string(dir.path().join("wasmer.toml")).unwrap();
+        pretty_assertions::assert_eq!(
+            manifest,
+            r#"[package]
+name = "christoph/test123"
+version = "0.1.0"
+description = "christoph/test123 website"
+
+[dependencies]
+"wasmer/static-web-server" = "^1"
+
+[fs]
+public = "public"
+"#,
+        );
+
+        assert!(dir.path().join("public").join("index.html").is_file());
+    }
+
+    #[tokio::test]
+    async fn test_package_wizard_create_js_worker() {
+        let dir = tempfile::tempdir().unwrap();
+
+        PackageWizard {
+            path: dir.path().to_owned(),
+            type_: Some(PackageType::JsWorker),
+            create_mode: CreateMode::Create,
+            namespace: Some("christoph".to_string()),
+            namespace_default: None,
+            name: Some("js-worker-test".to_string()),
+            user: None,
+        }
+        .run(None)
+        .await
+        .unwrap();
+        let manifest = std::fs::read_to_string(dir.path().join("wasmer.toml")).unwrap();
+
+        pretty_assertions::assert_eq!(
+            manifest,
+            r#"[package]
+name = "christoph/js-worker-test"
+version = "0.1.0"
+description = "christoph/js-worker-test js worker"
+
+[dependencies]
+"wasmer/winterjs" = "*"
+
+[fs]
+"/src" = "./src"
+
+[[command]]
+name = "script"
+module = "wasmer/winterjs:winterjs"
+runner = "https://webc.org/runner/wasi"
+
+[command.annotations.wasi]
+env = ["JS_PATH=/src/index.js"]
+main-args = ["/src/index.js"]
+"#,
+        );
+
+        assert!(dir.path().join("src").join("index.js").is_file());
+    }
+
+    #[tokio::test]
+    async fn test_package_wizard_create_py_worker() {
+        let dir = tempfile::tempdir().unwrap();
+
+        PackageWizard {
+            path: dir.path().to_owned(),
+            type_: Some(PackageType::PyApplication),
+            create_mode: CreateMode::Create,
+            namespace: Some("christoph".to_string()),
+            namespace_default: None,
+            name: Some("py-worker-test".to_string()),
+            user: None,
+        }
+        .run(None)
+        .await
+        .unwrap();
+        let manifest = std::fs::read_to_string(dir.path().join("wasmer.toml")).unwrap();
+
+        pretty_assertions::assert_eq!(
+            manifest,
+            r#"[package]
+name = "christoph/py-worker-test"
+version = "0.1.0"
+description = "christoph/py-worker-test py worker"
+
+[dependencies]
+"wasmer/python" = "^3.12.6"
+
+[fs]
+"/src" = "./src"
+
+[[command]]
+name = "script"
+module = "wasmer/python:python"
+runner = "wasi"
+
+[command.annotations.wasi]
+main-args = ["/src/main.py"]
+"#,
+        );
+
+        assert!(dir.path().join("src").join("main.py").is_file());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/js-worker/index.js b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/js-worker/index.js
new file mode 100644
index 0000000..75d7c19
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/js-worker/index.js
@@ -0,0 +1,20 @@
+
+// Handler function.
+// Receives a request and returns a response.
+async function handleRequest(ev) {
+  const request = ev.request;
+
+  const out = JSON.stringify({
+    success: true,
+    method: request.method,
+    package: "{{package}}",
+  });
+  return new Response(out, {
+    headers: { "content-type": "application/json" },
+  });
+}
+
+// Register the listener that handles incoming requests.
+addEventListener("fetch", (event) => {
+  event.respondWith(handleRequest(event));
+});
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/py-application/main.py b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/py-application/main.py
new file mode 100644
index 0000000..e9ba84c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/py-application/main.py
@@ -0,0 +1,26 @@
+import os
+import json
+from http.server import SimpleHTTPRequestHandler, HTTPServer
+
+
+class CustomHandler(SimpleHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header('Content-type', 'application/json')
+        self.end_headers()
+
+        data = {
+            "message": "{{package}} is running on Python!"
+        }
+        self.wfile.write(json.dumps(data).encode('utf-8'))
+
+
+if __name__ == "__main__":
+    host = os.environ.get('HOST', '127.0.0.1')
+
+    # Get the PORT environment variable if it's present; otherwise, default to 8000
+    port = int(os.environ.get('PORT', 80))
+
+    server = HTTPServer((host, port), CustomHandler)
+    print(f"Starting server on http://{host}:{port}")
+    server.serve_forever()
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/static-site/index.html b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/static-site/index.html
new file mode 100644
index 0000000..188a8e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/package_wizard/templates/static-site/index.html
@@ -0,0 +1,498 @@
+<html>
+  <head>
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"
+    />
+    <title>{{title}}</title>
+    <style>
+      @font-face {
+        font-family: "Gilroy";
+        src: url(data:font/truetype;charset=utf-8;base64,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)
+          format("truetype");
+        font-weight: normal;
+        font-style: normal;
+      }
+
+      body {
+        display: flex;
+        flex-direction: column;
+        background: linear-gradient(180deg, #fcfcfe 0%, #eff1f6 100%);
+      }
+
+      header {
+        display: flex;
+        width: 100%;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+      header > .hcontent {
+        display: flex;
+
+        justify-content: center;
+        align-items: center;
+        gap: 8px;
+        backdrop-filter: blur(20px);
+        align-self: stretch;
+      }
+      .hcontent .navmenu {
+        display: flex;
+        align-items: center;
+        gap: 24px;
+        flex: 1 0 0;
+      }
+      .navmenu .logoWrap {
+        display: flex;
+        align-items: center;
+        gap: 24px;
+        flex: 1 0 0;
+        background-repeat: no-repeat;
+        background-position: 0%;
+        background-size: contain;
+        height: 32px;
+        justify-content: space-between;
+      }
+      .navmenu .menuWrap {
+        display: flex;
+        align-items: center;
+        gap: 24px;
+      }
+      .menuWrap .edgedocsBtn {
+        display: flex;
+        padding: 3px 18px 3px 16px;
+        align-items: center;
+        gap: 12px;
+        height: 28px;
+        border-radius: 18px;
+
+        border: 1px solid var(--dark-grey-10, rgba(15, 5, 24, 0.1));
+        color: var(--dark-grey-100, #0f0518);
+        text-align: right;
+        font-family: "Gilroy";
+        font-size: 16px;
+        font-style: normal;
+        font-weight: 600;
+        line-height: 140%; /* 22.4px */
+      }
+      .menuWrap .edgedocsBtn:hover,
+      .githubBtn:hover {
+        cursor: pointer;
+        background-color: var(--dark-grey-10, rgba(15, 5, 24, 0.1));
+      }
+
+      main {
+        display: flex;
+        align-items: flex-start;
+        gap: 8px;
+        flex-shrink: 0;
+        position: relative;
+
+        align-self: stretch;
+        justify-content: center;
+      }
+      main .bg-graphics1 {
+        position: absolute;
+      }
+      main .bg-graphics2 {
+        position: absolute;
+      }
+      main .bcontent {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 16px;
+        z-index: 100;
+      }
+      .bcontent .bcontBody {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 16px;
+        align-self: stretch;
+      }
+      .bcontBody .title {
+        color: #0f0518;
+        text-align: center;
+
+        /* Mobile/H1 */
+        font-family: "Gilroy";
+
+        font-style: normal;
+        font-weight: 600;
+        line-height: 140%; /* 61.6px */
+      }
+      .bcontBody .msgWrap {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+
+        align-self: stretch;
+      }
+      .msgWrap .msg {
+        align-self: stretch;
+        color: #0f0518;
+        text-align: center;
+
+        /* Mobile/Subline */
+        font-family: "Gilroy";
+
+        font-style: normal;
+        font-weight: 400;
+        line-height: 140%; /* 28px */
+        opacity: 0.5;
+      }
+      .msgWrap .footer {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        gap: 16px;
+
+        color: #0f0518;
+        text-align: center;
+        font-family: "Gilroy";
+        font-style: normal;
+        font-weight: 600;
+        line-height: 140%; /* 28px */
+      }
+      .githubBtn {
+        text-decoration: none;
+        color: inherit;
+        display: flex;
+        height: 54px;
+        padding: 0px 24px;
+        align-items: center;
+        gap: 16px;
+        border-radius: 56px;
+        border: 1px solid var(--dark-grey-20, rgba(15, 5, 24, 0.2));
+      }
+      .githubBtn .githubstars {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+      .githubstars .starsvalue {
+        display: flex;
+        padding-top: 2px;
+        align-items: flex-start;
+        color: #0f0518;
+        font-family: "Gilroy";
+        font-size: 22px;
+        font-style: normal;
+        font-weight: 600;
+        line-height: 140%; /* 30.8px */
+      }
+      .githublink {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+      }
+      /*mobile*/
+      @media screen and (max-width: 767px) {
+        header > .hcontent {
+          padding: 16px 24px;
+        }
+        .navmenu .logoWrap {
+          background-image: url("data:image/svg+xml;base64,<svg width="110" height="32" viewBox="0 0 110 32" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M35.7207 9.37103C36.474 9.37103 37.1887 9.36536 37.9024 9.38047C37.9665 9.38141 38.0619 9.51074 38.0855 9.59571C38.3413 10.519 38.5858 11.446 38.8341 12.3721C39.4675 14.7322 40.1019 17.0922 40.7373 19.4523C40.7637 19.5495 40.7939 19.6458 40.843 19.8129C40.8921 19.6808 40.9214 19.6156 40.9412 19.5476C41.8909 16.2813 42.8387 13.0131 43.7893 9.74675C43.9215 9.29362 43.8412 9.37669 44.2906 9.37197C44.7078 9.36725 45.1242 9.3682 45.5414 9.37197C45.9927 9.37669 45.9068 9.30495 46.0304 9.7307C46.6242 11.7755 47.2124 13.8221 47.8033 15.8678C48.163 17.1139 48.5217 18.3591 48.8823 19.6052C48.8974 19.6581 48.9173 19.7091 48.956 19.8224C49.0268 19.5816 49.0853 19.3947 49.1363 19.2059C49.9963 16.0038 50.8563 12.8016 51.7125 9.59759C51.7541 9.44089 51.8088 9.36159 51.9939 9.36536C52.615 9.37858 53.2362 9.37008 53.8574 9.37103C53.9187 9.37103 53.981 9.37858 54.0726 9.38519C54.0556 9.47298 54.0462 9.54756 54.0254 9.61931C52.8095 13.9222 51.5917 18.2232 50.3824 22.5279C50.322 22.7422 50.2332 22.8093 50.0123 22.8036C49.3364 22.7876 48.6595 22.7913 47.9836 22.8017C47.8005 22.8045 47.7325 22.7441 47.6815 22.5666C46.7998 19.5004 45.9096 16.4371 45.0203 13.3737C44.9948 13.2869 44.9684 13.2 44.8853 13.1103C44.7862 13.4436 44.6852 13.7759 44.588 14.11C43.7638 16.9393 42.9397 19.7676 42.1212 22.5987C42.0759 22.7564 42.0032 22.8045 41.8408 22.8027C41.1328 22.7932 40.4248 22.7932 39.7177 22.8027C39.5497 22.8045 39.4883 22.7422 39.4449 22.5893C38.2233 18.2628 36.9989 13.9382 35.7764 9.61364C35.7575 9.54756 35.7452 9.47959 35.7207 9.37103Z" fill="#0F0518"/>
<path d="M75.4531 13.2247C76.1328 13.2247 76.7974 13.2247 77.4951 13.2247C77.4951 13.573 77.4951 13.9138 77.4951 14.2546C77.5111 14.2659 77.5272 14.2772 77.5441 14.2886C78.222 13.3417 79.1622 12.9565 80.2856 12.966C81.4326 12.9754 82.3313 13.4456 82.9459 14.4415C82.9855 14.4104 83.0138 14.3962 83.0308 14.3726C83.7153 13.3946 84.6819 12.9792 85.845 12.9698C87.1336 12.9594 88.1994 13.4106 88.914 14.5284C89.3653 15.2326 89.5154 16.0256 89.5182 16.8488C89.5239 18.7604 89.5182 20.6711 89.5248 22.5828C89.5258 22.7669 89.4568 22.8056 89.2897 22.8028C88.763 22.7933 88.2353 22.7895 87.7085 22.8046C87.5018 22.8103 87.4423 22.7537 87.4432 22.5432C87.4517 20.7344 87.4536 18.9247 87.4432 17.1159C87.4413 16.7969 87.413 16.4674 87.3271 16.1615C87.093 15.3242 86.4265 14.871 85.5344 14.8965C84.4979 14.9258 83.7804 15.5328 83.5897 16.576C83.5283 16.9139 83.5085 17.2632 83.5066 17.6078C83.4981 19.2362 83.5029 20.8637 83.5029 22.4922C83.5029 22.5847 83.5029 22.6763 83.5029 22.7829C83.4056 22.7895 83.3376 22.799 83.2687 22.799C82.742 22.7999 82.2143 22.7895 81.6875 22.8046C81.4751 22.8103 81.4232 22.7414 81.4241 22.5375C81.4317 20.7523 81.4326 18.9662 81.4241 17.1811C81.4222 16.8535 81.4081 16.5146 81.3297 16.1993C81.0597 15.1184 80.0024 14.618 78.8847 15.024C78.1096 15.3053 77.7207 15.9038 77.5791 16.6789C77.5234 16.9857 77.5102 17.3038 77.5083 17.6172C77.5017 19.2532 77.5017 20.8892 77.5092 22.5252C77.5102 22.7357 77.4601 22.8122 77.2355 22.8056C76.6473 22.7895 76.0592 22.7999 75.4541 22.7999C75.4531 19.6006 75.4531 16.4268 75.4531 13.2247Z" fill="#0F0518"/>
<path d="M62.1267 14.5035C62.1267 14.0608 62.1267 13.6501 62.1267 13.2262C62.8206 13.2262 63.4861 13.2262 64.1724 13.2262C64.1724 16.4057 64.1724 19.5833 64.1724 22.7798C63.5003 22.7798 62.83 22.7798 62.1286 22.7798C62.1286 22.3531 62.1286 21.9349 62.1286 21.4667C62.0493 21.5403 62.0078 21.5714 61.9747 21.6111C61.1119 22.6524 59.9781 23.0677 58.6555 23.0366C56.2907 22.9799 54.397 21.14 54.0704 18.8272C53.8108 16.992 54.3234 15.4041 55.7036 14.1325C57.2782 12.6834 59.8677 12.5626 61.4546 13.8625C61.683 14.0494 61.8822 14.2694 62.1267 14.5035ZM59.103 21.0673C60.8381 21.0645 62.1267 19.758 62.1277 18.0021C62.1286 16.2518 60.8306 14.9368 59.1011 14.9349C57.3594 14.933 56.0557 16.2556 56.0651 18.0153C56.0755 19.7731 57.3669 21.0702 59.103 21.0673Z" fill="#0F0518"/>
<path d="M93.388 18.8882C93.657 19.9606 94.2697 20.678 95.293 20.9678C96.6836 21.3615 97.9419 21.1567 98.9445 19.9691C99.4939 20.29 100.047 20.6129 100.665 20.9735C100.365 21.2926 100.11 21.6098 99.8092 21.8751C98.9681 22.6161 97.9618 22.9626 96.8544 23.0258C95.5649 23.0995 94.3461 22.8644 93.2671 22.112C92.1636 21.3426 91.5244 20.2702 91.3073 18.9542C91.0628 17.4778 91.3253 16.0986 92.2315 14.8845C93.0179 13.8319 94.0903 13.241 95.3836 13.0371C96.4117 12.8747 97.4105 12.9606 98.3526 13.4232C99.7951 14.1312 100.624 15.3178 100.97 16.8623C101.103 17.458 101.117 18.0602 101.048 18.6682C101.026 18.8608 100.95 18.891 100.782 18.891C98.4215 18.8863 96.0614 18.8882 93.7014 18.8882C93.6089 18.8882 93.5154 18.8882 93.388 18.8882ZM98.9568 17.1785C99.0229 16.0344 97.755 14.8855 96.373 14.8402C94.585 14.7816 93.5635 15.9787 93.4059 17.1785C95.2581 17.1785 97.1074 17.1785 98.9568 17.1785Z" fill="#0F0518"/>
<path d="M67.7137 19.7841C67.776 19.9068 67.8269 20.0201 67.8902 20.1258C68.348 20.8933 69.0702 21.1605 69.9132 21.1321C70.2588 21.1208 70.626 21.0557 70.9385 20.916C71.6295 20.6073 71.6824 19.7473 71.0234 19.3838C70.5826 19.1402 70.0794 19.0081 69.5989 18.8382C69.1099 18.6654 68.6058 18.5342 68.1262 18.3397C66.8961 17.8422 66.3033 17.0436 66.3212 15.8994C66.3401 14.6486 66.965 13.7631 68.1073 13.3109C69.6725 12.6916 71.1754 12.8332 72.5301 13.9018C72.8775 14.1765 73.1465 14.5249 73.3656 14.9563C72.7906 15.2792 72.2261 15.5964 71.6427 15.9239C71.5917 15.8446 71.5483 15.7823 71.5087 15.7172C71.0036 14.8912 69.7688 14.5721 68.923 15.0488C68.2848 15.4094 68.2367 16.1864 68.8692 16.5489C69.2647 16.7755 69.7226 16.8991 70.1587 17.0521C70.7298 17.2512 71.3208 17.3976 71.8778 17.6279C73.6129 18.3454 74.1472 20.358 72.9946 21.8015C72.4914 22.4321 71.7975 22.7568 71.0225 22.9154C69.901 23.1448 68.7993 23.0891 67.7429 22.6143C66.9943 22.2782 66.4288 21.7373 66.0352 21.0151C65.9502 20.8584 65.9606 20.7744 66.1277 20.6828C66.5959 20.426 67.0538 20.1494 67.5173 19.8813C67.5768 19.8483 67.641 19.8209 67.7137 19.7841Z" fill="#0F0518"/>
<path d="M102.918 22.798C102.918 19.5864 102.918 16.4145 102.918 13.2284C103.602 13.2284 104.273 13.2284 104.97 13.2284C104.97 13.7183 104.97 14.1941 104.97 14.6699C105.628 13.539 106.624 13.0604 107.905 13.0405C107.905 13.7806 107.905 14.5066 107.905 15.2732C107.787 15.2732 107.665 15.2675 107.543 15.2741C106.699 15.3213 105.954 15.5762 105.438 16.2965C105.131 16.7251 104.992 17.2169 104.987 17.7371C104.974 19.3174 104.977 20.8967 104.974 22.477C104.973 22.7989 104.973 22.7989 104.657 22.7989C104.086 22.798 103.514 22.798 102.918 22.798Z" fill="#0F0518"/>
<path d="M8.74515 12.5031C8.74515 12.5324 8.74515 12.5617 8.74515 12.5909C8.74515 13.6226 8.0757 14.0725 7.2526 13.5969C6.4295 13.1214 5.76005 11.8995 5.76005 10.8679C5.76005 10.8387 5.76005 10.8094 5.76005 10.7801L0.744629 7.88281V24.1619L13.7679 31.6795V15.4005L8.74515 12.5031Z" fill="#0F0518"/>
<path d="M15.2574 8.74607C15.2574 8.77533 15.2574 8.8046 15.2574 8.83386C15.2574 9.86548 14.5879 10.3154 13.7648 9.83987C12.9417 9.3643 12.2723 8.14246 12.2723 7.11084C12.2723 7.08158 12.2723 7.05231 12.2723 7.02305L7.25684 4.12939V9.95328L15.2318 14.559V25.0142L20.2801 27.9298V11.6507L15.2574 8.74607Z" fill="#0F0518"/>
<path d="M21.7676 4.99289C21.7676 5.02215 21.7676 5.05142 21.7676 5.08069C21.7676 6.1123 21.0982 6.56226 20.2751 6.0867C19.452 5.61113 18.7825 4.38928 18.7825 3.35766C18.7825 3.3284 18.7825 3.29913 18.7825 3.26987L13.7671 0.372559V6.19644L21.742 10.8021V21.2573L26.7903 24.1729V7.89385L21.7676 4.99289Z" fill="#0F0518"/>
</svg>
");
+        }
+        main .bcontent {
+          width: 311px;
+          margin: 63px 32px 95px 32px;
+        }
+        main .bg-graphics1 {
+          margin-top: 22px;
+          width: 576px;
+          height: 576px;
+        }
+        main .bg-graphics2 {
+          margin-top: 22px;
+          width: 576px;
+          height: 576px;
+        }
+        .bcontBody .title {
+          font-size: 44px;
+        }
+        .bcontBody .msgWrap {
+          gap: 40px;
+        }
+        .msgWrap .msg {
+          font-size: 20px;
+          width: 311px;
+        }
+        .msgWrap .footer {
+          font-size: 20px;
+        }
+      }
+      /* for all except mobile*/
+      @media screen and (min-width: 768px) {
+        .navmenu .logoWrap {
+          background-image: url("data:image/svg+xml;base64,<svg width="124" height="36" viewBox="0 0 124 36" fill="none" xmlns="http://www.w3.org/2000/svg">
<path d="M40.1855 10.5426C41.033 10.5426 41.837 10.5363 42.6399 10.5533C42.7121 10.5543 42.8194 10.6998 42.8459 10.7954C43.1337 11.8341 43.4088 12.877 43.6881 13.9188C44.4007 16.5739 45.1144 19.229 45.8292 21.8841C45.8589 21.9935 45.8929 22.1018 45.9481 22.2898C46.0034 22.1411 46.0363 22.0678 46.0586 21.9913C47.127 18.3167 48.1933 14.64 49.2627 10.9653C49.4114 10.4556 49.3211 10.549 49.8267 10.5437C50.2961 10.5384 50.7644 10.5395 51.2339 10.5437C51.7415 10.549 51.6449 10.4683 51.784 10.9473C52.452 13.2476 53.1137 15.5501 53.7785 17.8515C54.1831 19.2534 54.5867 20.6543 54.9924 22.0561C55.0094 22.1156 55.0317 22.173 55.0752 22.3004C55.1549 22.0296 55.2207 21.8193 55.2781 21.6069C56.2456 18.0045 57.2131 14.4021 58.1764 10.7975C58.2231 10.6212 58.2847 10.532 58.4928 10.5363C59.1917 10.5511 59.8905 10.5416 60.5893 10.5426C60.6583 10.5426 60.7284 10.5511 60.8314 10.5586C60.8123 10.6573 60.8017 10.7412 60.7783 10.822C59.4104 15.6627 58.0404 20.5013 56.68 25.3442C56.612 25.5853 56.5122 25.6607 56.2636 25.6543C55.5032 25.6362 54.7417 25.6405 53.9813 25.6522C53.7753 25.6554 53.6988 25.5874 53.6415 25.3877C52.6495 21.9382 51.6481 18.492 50.6476 15.0457C50.6189 14.948 50.5892 14.8502 50.4957 14.7494C50.3842 15.1243 50.2706 15.4981 50.1612 15.874C49.2341 19.057 48.3069 22.2388 47.3861 25.4238C47.3351 25.6012 47.2534 25.6554 47.0707 25.6532C46.2742 25.6426 45.4776 25.6426 44.6822 25.6532C44.4931 25.6554 44.4241 25.5853 44.3753 25.4132C43.001 20.5459 41.6235 15.6808 40.2482 10.8156C40.227 10.7412 40.2132 10.6648 40.1855 10.5426Z" fill="#0F0518"/>
<path d="M84.8848 14.8781C85.6494 14.8781 86.3971 14.8781 87.1819 14.8781C87.1819 15.27 87.1819 15.6534 87.1819 16.0368C87.2 16.0495 87.218 16.0623 87.2372 16.075C87.9997 15.0098 89.0575 14.5765 90.3213 14.5871C91.6117 14.5977 92.6227 15.1266 93.3141 16.2471C93.3587 16.212 93.3906 16.1961 93.4097 16.1695C94.1797 15.0693 95.2672 14.602 96.5756 14.5914C98.0253 14.5797 99.2243 15.0873 100.028 16.3448C100.536 17.137 100.705 18.0291 100.708 18.9552C100.714 21.1059 100.708 23.2554 100.715 25.406C100.716 25.6131 100.639 25.6567 100.451 25.6535C99.8583 25.6429 99.2647 25.6386 98.6721 25.6556C98.4395 25.662 98.3726 25.5982 98.3736 25.3614C98.3832 23.3266 98.3853 21.2906 98.3736 19.2558C98.3715 18.8968 98.3396 18.5262 98.243 18.1821C97.9796 17.2401 97.2298 16.7303 96.2262 16.759C95.0601 16.7919 94.2529 17.4748 94.0384 18.6483C93.9694 19.0285 93.9471 19.4215 93.945 19.8091C93.9354 21.6411 93.9407 23.4721 93.9407 25.3041C93.9407 25.4081 93.9407 25.5112 93.9407 25.6312C93.8313 25.6386 93.7549 25.6492 93.6773 25.6492C93.0847 25.6503 92.491 25.6386 91.8984 25.6556C91.6595 25.662 91.6011 25.5844 91.6021 25.355C91.6106 23.3467 91.6117 21.3374 91.6021 19.3291C91.6 18.9606 91.5841 18.5793 91.4959 18.2246C91.1922 17.0085 90.0027 16.4457 88.7453 16.9023C87.8733 17.2188 87.4358 17.8921 87.2765 18.7641C87.2138 19.1092 87.1989 19.4671 87.1968 19.8197C87.1894 21.6602 87.1894 23.5007 87.1979 25.3412C87.1989 25.5781 87.1426 25.6641 86.8899 25.6567C86.2282 25.6386 85.5666 25.6503 84.8858 25.6503C84.8848 22.0511 84.8848 18.4805 84.8848 14.8781Z" fill="#0F0518"/>
<path d="M69.8924 16.3169C69.8924 15.8188 69.8924 15.3568 69.8924 14.8799C70.673 14.8799 71.4217 14.8799 72.1938 14.8799C72.1938 18.4569 72.1938 22.0317 72.1938 25.6277C71.4376 25.6277 70.6836 25.6277 69.8945 25.6277C69.8945 25.1477 69.8945 24.6772 69.8945 24.1504C69.8053 24.2333 69.7586 24.2683 69.7214 24.3129C68.7507 25.4843 67.4752 25.9516 65.9873 25.9166C63.3269 25.8529 61.1965 23.783 60.829 21.181C60.5369 19.1164 61.1136 17.3301 62.6663 15.8995C64.4378 14.2693 67.3509 14.1333 69.1362 15.5958C69.3932 15.806 69.6173 16.0535 69.8924 16.3169ZM66.4907 23.7012C68.4427 23.698 69.8924 22.2281 69.8934 20.2528C69.8945 18.2838 68.4342 16.8043 66.4886 16.8022C64.5291 16.8001 63.0624 18.288 63.0731 20.2676C63.0848 22.2451 64.5376 23.7044 66.4907 23.7012Z" fill="#0F0518"/>
<path d="M105.061 21.2496C105.364 22.4561 106.053 23.2632 107.204 23.5893C108.769 24.0321 110.184 23.8017 111.312 22.4656C111.93 22.8267 112.553 23.1899 113.248 23.5956C112.911 23.9546 112.624 24.3114 112.285 24.6099C111.339 25.4436 110.207 25.8333 108.961 25.9045C107.51 25.9873 106.139 25.7229 104.925 24.8764C103.684 24.0109 102.965 22.8044 102.72 21.3239C102.445 19.6629 102.741 18.1113 103.76 16.7455C104.645 15.5614 105.851 14.8965 107.306 14.6671C108.463 14.4845 109.587 14.5811 110.646 15.1015C112.269 15.898 113.202 17.233 113.591 18.9705C113.741 19.6406 113.756 20.3182 113.679 21.0021C113.654 21.2188 113.568 21.2528 113.379 21.2528C110.724 21.2475 108.069 21.2496 105.414 21.2496C105.31 21.2496 105.205 21.2496 105.061 21.2496ZM111.326 19.3263C111.4 18.0391 109.974 16.7466 108.419 16.6956C106.408 16.6298 105.259 17.9764 105.081 19.3263C107.165 19.3263 109.246 19.3263 111.326 19.3263Z" fill="#0F0518"/>
<path d="M76.1776 22.2573C76.2477 22.3954 76.305 22.5228 76.3762 22.6418C76.8912 23.5052 77.7037 23.8058 78.6521 23.7739C79.0408 23.7612 79.4539 23.6879 79.8055 23.5307C80.5829 23.1834 80.6423 22.2159 79.901 21.807C79.4051 21.533 78.839 21.3843 78.2984 21.1932C77.7483 20.9988 77.1812 20.8512 76.6417 20.6324C75.2578 20.0727 74.5909 19.1742 74.6111 17.8871C74.6323 16.4799 75.3354 15.4837 76.6204 14.975C78.3813 14.2783 80.072 14.4376 81.596 15.6398C81.9869 15.9489 82.2896 16.3407 82.5359 16.8261C81.8892 17.1893 81.2541 17.5462 80.5977 17.9147C80.5404 17.8255 80.4915 17.7554 80.4469 17.6821C79.8787 16.7528 78.4896 16.3938 77.538 16.9302C76.8201 17.3359 76.7659 18.2099 77.4775 18.6177C77.9225 18.8726 78.4376 19.0118 78.9282 19.1838C79.5708 19.4079 80.2356 19.5725 80.8622 19.8316C82.8142 20.6388 83.4153 22.903 82.1186 24.5269C81.5525 25.2363 80.7719 25.6017 79.9 25.7801C78.6383 26.0382 77.3989 25.9755 76.2105 25.4413C75.3683 25.0632 74.7321 24.4547 74.2893 23.6422C74.1937 23.4659 74.2054 23.3714 74.3933 23.2684C74.9201 22.9795 75.4352 22.6683 75.9567 22.3667C76.0236 22.3295 76.0958 22.2987 76.1776 22.2573Z" fill="#0F0518"/>
<path d="M115.783 25.6481C115.783 22.035 115.783 18.4666 115.783 14.8822C116.552 14.8822 117.307 14.8822 118.091 14.8822C118.091 15.4334 118.091 15.9687 118.091 16.504C118.831 15.2317 119.952 14.6932 121.393 14.6709C121.393 15.5035 121.393 16.3202 121.393 17.1826C121.26 17.1826 121.123 17.1762 120.986 17.1837C120.037 17.2368 119.198 17.5235 118.618 18.3338C118.273 18.816 118.115 19.3693 118.11 19.9545C118.095 21.7323 118.099 23.5091 118.095 25.287C118.094 25.6491 118.094 25.6491 117.739 25.6491C117.097 25.6481 116.453 25.6481 115.783 25.6481Z" fill="#0F0518"/>
<path d="M9.83848 14.066C9.83848 14.099 9.83848 14.1319 9.83848 14.1648C9.83848 15.3254 9.08534 15.8316 8.15936 15.2966C7.23337 14.7616 6.48023 13.387 6.48023 12.2264C6.48023 12.1935 6.48023 12.1606 6.48023 12.1276L0.837891 8.86816V27.1821L15.4891 35.6395V17.3255L9.83848 14.066Z" fill="#0F0518"/>
<path d="M17.1647 9.83926C17.1647 9.87219 17.1647 9.90511 17.1647 9.93803C17.1647 11.0986 16.4115 11.6048 15.4855 11.0698C14.5595 10.5348 13.8064 9.16021 13.8064 7.99964C13.8064 7.96671 13.8064 7.93379 13.8064 7.90086L8.16406 4.64551V11.1974L17.1358 16.3788V28.1409L22.8152 31.4209V13.107L17.1647 9.83926Z" fill="#0F0518"/>
<path d="M24.4889 5.61682C24.4889 5.64974 24.4889 5.68266 24.4889 5.71559C24.4889 6.87616 23.7357 7.38236 22.8097 6.84735C21.8838 6.31233 21.1306 4.93776 21.1306 3.77719C21.1306 3.74427 21.1306 3.71134 21.1306 3.67842L15.4883 0.418945V6.97081L24.4601 12.1522V23.9143L30.1394 27.1944V8.8804L24.4889 5.61682Z" fill="#0F0518"/>
</svg>
");
+        }
+
+        main .bg-graphics1 {
+          width: 508px;
+          height: 508px;
+        }
+        main .bg-graphics2 {
+          width: 508px;
+          height: 508px;
+        }
+      }
+
+      /*tablet*/
+      @media screen and (min-width: 768px) and (max-width: 1151px) {
+        header > .hcontent {
+          padding: 16px 24px;
+        }
+
+        main .bg-graphics1 {
+          margin-top: 16px;
+        }
+        main .bg-graphics2 {
+          margin-top: 16px;
+        }
+        main .bcontent {
+          width: 640px;
+          margin: 80px 64px 112px 64px;
+        }
+        .bcontBody .title {
+          font-size: 48px;
+        }
+        .bcontBody .msgWrap {
+          gap: 40px;
+        }
+        .msgWrap .msg {
+          font-size: 20px;
+        }
+        .msgWrap .footer {
+          font-size: 20px;
+        }
+      }
+
+      /*desktop + xl-screen*/
+      @media screen and (min-width: 1152px) {
+        main .bg-graphics1 {
+          margin-top: 40px;
+        }
+        main .bg-graphics2 {
+          margin-top: 40px;
+        }
+        main .bcontent {
+          width: 678px;
+          margin: 88px 237px 144px 237px;
+        }
+        .bcontBody .title {
+          font-size: 52px;
+        }
+        .bcontBody .msgWrap {
+          gap: 48px;
+        }
+      }
+
+      /*desktop*/
+      @media screen and (min-width: 1152px) and (max-width: 1439px) {
+        header > .hcontent {
+          padding: 20px 32px;
+        }
+        .navmenu .menuWrap {
+          padding-top: 2px;
+        }
+        .msgWrap .msg {
+          font-size: 22px;
+        }
+        .msgWrap .footer {
+          font-size: 22px;
+        }
+      }
+
+      /*xl-screen*/
+      @media screen and (min-width: 1440px) {
+        header > .hcontent {
+          width: 1152px;
+          padding: 20px 32px;
+          align-self: unset;
+        }
+        .navmenu .menuWrap {
+          padding-top: 2px;
+        }
+        .msgWrap .msg {
+          font-size: 22px;
+        }
+        .msgWrap .footer {
+          font-size: 22px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <header class="">
+      <div class="hcontent">
+        <div class="navmenu">
+          <div class="logoWrap">
+            <a
+              href="https://wasmer.io"
+              target="_blank"
+              style="height: 32px; width: 108px"
+            ></a>
+          </div>
+          <div class="menuWrap">
+            <button class="edgedocsBtn">
+              <a
+                style="text-decoration: none; color: inherit"
+                href="https://docs.wasmer.io/edge"
+                target="_blank"
+                >Check Edge Docs</a
+              >
+            </button>
+          </div>
+        </div>
+      </div>
+    </header>
+    <main class="" style="position: relative">
+      <svg
+        class="bg-graphics1"
+        width="516"
+        height="516"
+        viewBox="0 0 516 516"
+        fill="none"
+        xmlns="http://www.w3.org/2000/svg"
+      >
+        <g style="mix-blend-mode: color-dodge">
+          <circle
+            cx="258"
+            cy="258"
+            r="256"
+            transform="rotate(90 258 258)"
+            stroke="url(#paint0_linear_3412_122558)"
+            stroke-width="4"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          />
+        </g>
+        <defs>
+          <linearGradient
+            id="paint0_linear_3412_122558"
+            x1="124.542"
+            y1="-11.8168"
+            x2="403.46"
+            y2="186.07"
+            gradientUnits="userSpaceOnUse"
+          >
+            <stop stop-color="#F4A329" />
+            <stop offset="1" stop-color="#F4A329" stop-opacity="0" />
+          </linearGradient>
+        </defs>
+      </svg>
+      <svg
+        class="bg-graphics2"
+        width="516"
+        height="516"
+        viewBox="0 0 516 516"
+        fill="none"
+        xmlns="http://www.w3.org/2000/svg"
+      >
+        <g style="mix-blend-mode: overlay">
+          <circle
+            cx="258"
+            cy="258"
+            r="256"
+            stroke="url(#paint0_linear_3412_122559)"
+            stroke-width="4"
+            stroke-linecap="round"
+            stroke-linejoin="round"
+          />
+        </g>
+        <defs>
+          <linearGradient
+            id="paint0_linear_3412_122559"
+            x1="-5.05436"
+            y1="404.279"
+            x2="336.87"
+            y2="399.8"
+            gradientUnits="userSpaceOnUse"
+          >
+            <stop stop-color="#0F0518" />
+            <stop offset="1" stop-color="#0F0518" stop-opacity="0" />
+          </linearGradient>
+        </defs>
+      </svg>
+
+      <div class="bcontent">
+        <div class="wavinghand">
+          <img
+            src="data:image/svg+xml;base64,<svg width="89" height="88" viewBox="0 0 89 88" fill="none" xmlns="http://www.w3.org/2000/svg">
<g clip-path="url(#clip0_3415_134299)">
<rect x="0.5" width="88" height="88" rx="44" fill="#0F0518"/>
<circle cx="44.5" cy="44" r="44" fill="url(#paint0_linear_3415_134299)"/>
<g filter="url(#filter0_di_3415_134299)">
<path fill-rule="evenodd" clip-rule="evenodd" d="M34.7653 33.0025C32.4892 33.3604 30.5628 34.8921 30.2664 37.3242C29.3854 36.6708 28.2907 36.3531 27.0608 36.5111C24.1848 36.8807 22.0954 39.0471 22.5671 42.6868L23.1348 47.067L23.1179 47.0691C23.1179 47.0691 24.0428 54.6905 25.8512 60.5704C29.2357 70.579 37.4377 74.1865 45.7254 73.0053C52.6105 72.024 58.3785 67.4465 60.7975 63.1456C62.3142 60.4491 62.8088 57.6427 62.8189 55.0174C62.9124 54.084 62.8756 53.1343 62.6626 52.2295C62.4887 50.6594 62.1969 49.2068 61.9279 47.9479C60.4634 41.0938 60.7453 39.7426 61.2486 37.3298L61.2999 37.0835C61.8337 34.5086 63.5293 26.4702 63.5293 26.4702C63.7491 24.335 63.2732 20.4069 59.3531 19.8133C55.1131 19.1713 53.276 22.4248 52.9788 24.0837L50.6866 37.3032C50.4292 37.943 49.9365 37.5071 49.588 36.2059C49.077 34.2985 48.1528 31.2991 47.2373 28.3282L47.2373 28.3282L47.2372 28.3279L47.2372 28.3278C46.4649 25.8214 45.6988 23.3353 45.1924 21.5423C44.1484 17.8455 40.8646 17.4204 38.7259 17.9612C35.3187 18.8179 34.1697 22.5132 34.8916 24.7129C35.1945 25.636 36.4158 29.3288 37.7313 33.304C36.8387 32.9245 35.8238 32.836 34.7653 33.0025Z" fill="#AC5CE0"/>
</g>
<path opacity="0.6" d="M30.2664 37.3242L29.9685 37.7258L30.6587 38.2377L30.7627 37.3847L30.2664 37.3242ZM34.7653 33.0025L34.843 33.4964L34.7653 33.0025ZM27.0608 36.5111L26.9971 36.0152L27.0608 36.5111ZM22.5671 42.6868L23.063 42.6225L22.5671 42.6868ZM23.1348 47.067L23.1949 47.5634L23.6955 47.5029L23.6307 47.0028L23.1348 47.067ZM23.1179 47.0691L23.0579 46.5727L22.5613 46.6328L22.6216 47.1293L23.1179 47.0691ZM25.8512 60.5704L25.3732 60.7175L25.3776 60.7306L25.8512 60.5704ZM45.7254 73.0053L45.6548 72.5103L45.7254 73.0053ZM60.7975 63.1456L61.2333 63.3908L60.7975 63.1456ZM62.8189 55.0174L62.3214 54.9676L62.319 54.9915L62.3189 55.0155L62.8189 55.0174ZM62.6626 52.2295L62.1656 52.2846L62.169 52.3147L62.1759 52.3441L62.6626 52.2295ZM61.9279 47.9479L62.4169 47.8435V47.8435L61.9279 47.9479ZM61.2486 37.3298L61.7381 37.432L61.7381 37.4317L61.2486 37.3298ZM61.2999 37.0835L61.7894 37.1854L61.7895 37.1849L61.2999 37.0835ZM63.5293 26.4702L64.0186 26.5734L64.024 26.5476L64.0267 26.5214L63.5293 26.4702ZM59.3531 19.8133L59.2782 20.3077L59.3531 19.8133ZM52.9788 24.0837L52.4867 23.9956L52.4862 23.9983L52.9788 24.0837ZM50.6866 37.3032L51.1505 37.4899L51.1702 37.4408L51.1793 37.3887L50.6866 37.3032ZM49.588 36.2059L50.0709 36.0766H50.0709L49.588 36.2059ZM47.2373 28.3282L47.7153 28.1809L47.7117 28.1701L47.2373 28.3282ZM47.2373 28.3282L46.7601 28.4776L46.763 28.4863L47.2373 28.3282ZM47.2372 28.3279L47.7144 28.1785L47.7131 28.1744L47.2372 28.3279ZM47.2372 28.3278L46.7593 28.4751L46.7613 28.4813L47.2372 28.3278ZM45.1924 21.5423L44.7112 21.6782V21.6782L45.1924 21.5423ZM38.7259 17.9612L38.8479 18.4461L38.8485 18.4459L38.7259 17.9612ZM34.8916 24.7129L34.4165 24.8688L34.8916 24.7129ZM37.7313 33.304L37.5357 33.7642L38.5534 34.1969L38.206 33.147L37.7313 33.304ZM30.7627 37.3847C31.0259 35.2251 32.7326 33.8282 34.843 33.4964L34.6876 32.5085C32.2457 32.8925 30.0996 34.5592 29.77 37.2637L30.7627 37.3847ZM27.1245 37.0071C28.2249 36.8657 29.1902 37.1486 29.9685 37.7258L30.5642 36.9226C29.5806 36.1931 28.3566 35.8405 26.9971 36.0152L27.1245 37.0071ZM23.063 42.6225C22.8413 40.9123 23.2254 39.602 23.9511 38.6824C24.6797 37.7592 25.7933 37.1781 27.1245 37.0071L26.9971 36.0152C25.4523 36.2137 24.0833 36.9007 23.1661 38.0629C22.246 39.2289 21.8212 40.8216 22.0713 42.7511L23.063 42.6225ZM23.6307 47.0028L23.063 42.6225L22.0713 42.7511L22.639 47.1313L23.6307 47.0028ZM23.178 47.5655L23.1949 47.5634L23.0748 46.5706L23.0579 46.5727L23.178 47.5655ZM26.3291 60.4234C25.434 57.5132 24.755 54.1618 24.2991 51.5295C24.0714 50.2151 23.9001 49.0837 23.7857 48.2812C23.7285 47.8801 23.6855 47.5612 23.657 47.3431C23.6427 47.234 23.6319 47.1501 23.6248 47.0936C23.6213 47.0654 23.6186 47.044 23.6169 47.0298C23.616 47.0227 23.6153 47.0173 23.6149 47.0138C23.6147 47.0121 23.6145 47.0108 23.6144 47.01C23.6144 47.0095 23.6143 47.0092 23.6143 47.0091C23.6143 47.009 23.6143 47.0089 23.6143 47.0089C23.6143 47.0088 23.6143 47.0088 23.1179 47.0691C22.6216 47.1293 22.6216 47.1294 22.6216 47.1295C22.6216 47.1295 22.6216 47.1296 22.6216 47.1298C22.6217 47.1301 22.6217 47.1305 22.6218 47.131C22.6219 47.132 22.6221 47.1335 22.6223 47.1354C22.6228 47.1393 22.6235 47.145 22.6244 47.1525C22.6263 47.1674 22.629 47.1896 22.6327 47.2186C22.64 47.2767 22.6509 47.3622 22.6654 47.473C22.6945 47.6946 22.7379 48.0172 22.7957 48.4224C22.9112 49.2327 23.0841 50.3741 23.3137 51.7001C23.7724 54.3485 24.46 57.7478 25.3733 60.7174L26.3291 60.4234ZM45.6548 72.5103C41.603 73.0878 37.596 72.4917 34.1977 70.5499C30.8044 68.6111 27.9818 65.3103 26.3249 60.4103L25.3776 60.7306C27.1051 65.8392 30.0757 69.3464 33.7015 71.4182C37.3223 73.487 41.5601 74.104 45.7959 73.5003L45.6548 72.5103ZM60.3617 62.9005C58.0168 67.0696 52.3817 71.5516 45.6548 72.5103L45.7959 73.5003C52.8393 72.4965 58.7402 67.8234 61.2333 63.3908L60.3617 62.9005ZM62.3189 55.0155C62.309 57.5789 61.8265 60.2962 60.3617 62.9005L61.2333 63.3908C62.8019 60.6019 63.3085 57.7065 63.3189 55.0194L62.3189 55.0155ZM63.3164 55.0673C63.4145 54.0886 63.3771 53.0824 63.1493 52.1149L62.1759 52.3441C62.3742 53.1861 62.4104 54.0793 62.3214 54.9676L63.3164 55.0673ZM61.4389 48.0524C61.7072 49.3077 61.9946 50.7403 62.1656 52.2846L63.1596 52.1745C62.9828 50.5785 62.6866 49.106 62.4169 47.8435L61.4389 48.0524ZM60.7591 37.2277C60.5062 38.4401 60.2988 39.4304 60.3506 40.99C60.4018 42.532 60.7052 44.6186 61.4389 48.0524L62.4169 47.8435C61.686 44.4231 61.3982 42.4071 61.35 40.9568C61.3024 39.5241 61.4876 38.6324 61.7381 37.432L60.7591 37.2277ZM60.8104 36.9816L60.7591 37.2279L61.7381 37.4317L61.7894 37.1854L60.8104 36.9816ZM63.5293 26.4702C63.0401 26.367 63.0401 26.367 63.0401 26.3671C63.0401 26.3671 63.04 26.3672 63.04 26.3673C63.04 26.3676 63.0399 26.3679 63.0398 26.3684C63.0396 26.3694 63.0393 26.3709 63.0388 26.3728C63.038 26.3767 63.0368 26.3825 63.0352 26.3901C63.032 26.4054 63.0272 26.4281 63.0209 26.4579C63.0084 26.5174 62.9899 26.605 62.9662 26.7174C62.9188 26.9423 62.8504 27.2664 62.7668 27.6633C62.5995 28.4572 62.3708 29.5425 62.1255 30.7083C61.6349 33.0395 61.0774 35.6937 60.8103 36.9819L61.7895 37.1849C62.0562 35.8984 62.6134 33.2459 63.1041 30.9142C63.3494 29.7485 63.578 28.6633 63.7453 27.8695C63.8289 27.4726 63.8973 27.1486 63.9447 26.9238C63.9684 26.8113 63.9868 26.7237 63.9994 26.6643C64.0057 26.6345 64.0104 26.6118 64.0137 26.5965C64.0153 26.5889 64.0165 26.5831 64.0173 26.5792C64.0177 26.5773 64.018 26.5758 64.0182 26.5748C64.0183 26.5743 64.0184 26.574 64.0185 26.5737C64.0185 26.5736 64.0185 26.5735 64.0185 26.5735C64.0185 26.5734 64.0186 26.5734 63.5293 26.4702ZM59.2782 20.3077C61.045 20.5752 62.0131 21.5752 62.5359 22.7648C63.071 23.9824 63.1365 25.4035 63.0319 26.419L64.0267 26.5214C64.142 25.4016 64.0793 23.7911 63.4514 22.3624C62.8112 20.9058 61.5812 19.645 59.4279 19.3189L59.2782 20.3077ZM53.471 24.1719C53.6022 23.4394 54.0874 22.3136 55.0252 21.4543C55.9435 20.6129 57.3121 20.01 59.2782 20.3077L59.4279 19.3189C57.1541 18.9746 55.4842 19.6774 54.3496 20.717C53.2346 21.7387 52.6526 23.0691 52.4867 23.9956L53.471 24.1719ZM51.1793 37.3887L53.4715 24.1692L52.4862 23.9983L50.194 37.2178L51.1793 37.3887ZM49.105 36.3353C49.1975 36.6806 49.3026 36.9803 49.4169 37.2267C49.5279 37.466 49.6615 37.6854 49.8245 37.8425C49.9826 37.9948 50.2668 38.1726 50.611 38.0598C50.9151 37.9602 51.0702 37.6894 51.1505 37.4899L50.2228 37.1166C50.1743 37.2369 50.1713 37.1516 50.2997 37.1095C50.4683 37.0543 50.5592 37.1617 50.5184 37.1224C50.4825 37.0878 50.4114 36.9942 50.324 36.8058C50.2399 36.6245 50.1527 36.3818 50.0709 36.0766L49.105 36.3353ZM46.7595 28.4754C47.6763 31.4506 48.5971 34.4391 49.105 36.3353L50.0709 36.0766C49.557 34.1578 48.6293 31.1475 47.7151 28.181L46.7595 28.4754ZM46.763 28.4863L46.763 28.4863L47.7117 28.1701L47.7116 28.17L46.763 28.4863ZM46.7601 28.4774L46.7602 28.4776L47.7144 28.1787L47.7144 28.1785L46.7601 28.4774ZM46.7613 28.4813L46.7614 28.4814L47.7131 28.1744L47.7131 28.1743L46.7613 28.4813ZM44.7112 21.6782C45.2196 23.4783 45.9877 25.971 46.7594 28.4751L47.715 28.1806C46.942 25.6719 46.178 23.1924 45.6736 21.4064L44.7112 21.6782ZM38.8485 18.4459C39.8402 18.1951 41.0824 18.1743 42.1796 18.6251C43.254 19.0666 44.2303 19.9752 44.7112 21.6782L45.6736 21.4064C45.1105 19.4127 43.9229 18.2603 42.5597 17.7002C41.2193 17.1494 39.7503 17.1864 38.6034 17.4764L38.8485 18.4459ZM35.3667 24.557C35.0512 23.5956 35.1363 22.2549 35.7117 21.0487C36.2804 19.8563 37.3098 18.8328 38.8479 18.4461L38.604 17.4763C36.7349 17.9462 35.4862 19.1987 34.8091 20.6181C34.1386 22.0236 34.0102 23.6305 34.4165 24.8688L35.3667 24.557ZM38.206 33.147C36.8904 29.1713 35.6694 25.4793 35.3667 24.557L34.4165 24.8688C34.7197 25.7926 35.9413 29.4863 37.2566 33.4611L38.206 33.147ZM34.843 33.4964C35.8271 33.3416 36.7446 33.4279 37.5357 33.7642L37.9269 32.8439C36.9327 32.4212 35.8205 32.3304 34.6876 32.5085L34.843 33.4964Z" fill="#FBFBFC"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint1_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint2_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint3_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint4_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint5_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint6_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint7_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint8_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint9_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint10_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint11_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint12_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint13_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint14_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint15_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint16_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint17_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint18_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint19_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint20_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint21_radial_3415_134299)"/>
<path d="M41.5489 44.781L23.117 47.0114C23.117 47.0114 24.0419 54.6328 25.8504 60.5127C29.2348 70.5213 37.4368 74.1288 45.7245 72.9476C52.6096 71.9663 58.3776 67.3888 60.7966 63.0879C63.8371 57.6822 62.77 51.8353 61.927 47.8902C60.4134 40.8064 60.7652 39.6006 61.299 37.0257C61.8328 34.4509 63.5284 26.4125 63.5284 26.4125C63.7482 24.2772 63.2723 20.3492 59.3522 19.7556C55.1122 19.1136 53.2751 22.367 52.978 24.026L50.6857 37.2455C50.4283 37.8853 49.9356 37.4494 49.5871 36.1482C48.6451 32.6314 46.2981 25.403 45.1915 21.4846C44.1475 17.7878 40.8637 17.3627 38.7251 17.9035C35.3179 18.7601 34.1689 22.4555 34.8907 24.6552C35.6126 26.8548 41.5489 44.781 41.5489 44.781Z" fill="url(#paint22_radial_3415_134299)"/>
<path d="M22.5648 42.6286C22.093 38.989 24.1825 36.8225 27.0585 36.4529C29.9344 36.0834 32.0707 38.3153 32.4648 41.3565L33.0382 45.7806C33.4324 48.8218 31.8455 50.8287 28.9695 51.1982C26.0936 51.5678 23.5323 50.0939 23.1381 47.0527L22.5648 42.6286Z" fill="url(#paint23_radial_3415_134299)"/>
<path d="M22.5648 42.6286C22.093 38.989 24.1825 36.8225 27.0585 36.4529C29.9344 36.0834 32.0707 38.3153 32.4648 41.3565L33.0382 45.7806C33.4324 48.8218 31.8455 50.8287 28.9695 51.1982C26.0936 51.5678 23.5323 50.0939 23.1381 47.0527L22.5648 42.6286Z" fill="url(#paint24_radial_3415_134299)"/>
<path d="M22.5648 42.6286C22.093 38.989 24.1825 36.8225 27.0585 36.4529C29.9344 36.0834 32.0707 38.3153 32.4648 41.3565L33.0382 45.7806C33.4324 48.8218 31.8455 50.8287 28.9695 51.1982C26.0936 51.5678 23.5323 50.0939 23.1381 47.0527L22.5648 42.6286Z" fill="url(#paint25_radial_3415_134299)"/>
<path d="M22.5648 42.6286C22.093 38.989 24.1825 36.8225 27.0585 36.4529C29.9344 36.0834 32.0707 38.3153 32.4648 41.3565L33.0382 45.7806C33.4324 48.8218 31.8455 50.8287 28.9695 51.1982C26.0936 51.5678 23.5323 50.0939 23.1381 47.0527L22.5648 42.6286Z" fill="url(#paint26_radial_3415_134299)"/>
<path d="M22.5648 42.6286C22.093 38.989 24.1825 36.8225 27.0585 36.4529C29.9344 36.0834 32.0707 38.3153 32.4648 41.3565L33.0382 45.7806C33.4324 48.8218 31.8455 50.8287 28.9695 51.1982C26.0936 51.5678 23.5323 50.0939 23.1381 47.0527L22.5648 42.6286Z" fill="url(#paint27_radial_3415_134299)"/>
<path d="M30.4032 39.4106C29.5547 35.7398 31.8785 33.3987 34.7646 32.9448C37.6507 32.491 40.2127 33.9327 40.857 38.0007L41.5478 43.3702C42.1032 46.8771 39.9646 49.6608 37.4802 50.0515C33.8076 50.629 31.9288 48.7284 31.3734 45.2214L30.4032 39.4106Z" fill="url(#paint28_radial_3415_134299)"/>
<path d="M30.4032 39.4106C29.5547 35.7398 31.8785 33.3987 34.7646 32.9448C37.6507 32.491 40.2127 33.9327 40.857 38.0007L41.5478 43.3702C42.1032 46.8771 39.9646 49.6608 37.4802 50.0515C33.8076 50.629 31.9288 48.7284 31.3734 45.2214L30.4032 39.4106Z" fill="url(#paint29_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="#EBC645"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint30_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint31_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint32_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint33_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint34_radial_3415_134299)"/>
<path d="M49.2253 54.0753C53.6881 53.8331 55.6651 56.0162 57.4904 60.3958C59.1984 64.4939 64.3828 56.7719 62.4329 51.4071C59.9726 44.6378 53.9678 42.2567 47.1358 43.7613C43.5121 44.5594 43.0179 47.8156 43.2902 49.3533C43.5625 50.8909 44.7626 54.3174 49.2253 54.0753Z" fill="url(#paint35_radial_3415_134299)"/>
</g>
<defs>
<filter id="filter0_di_3415_134299" x="2.19279" y="-2.53865" width="81.6886" height="96.067" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
<feFlood flood-opacity="0" result="BackgroundImageFix"/>
<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
<feOffset/>
<feGaussianBlur stdDeviation="10.1538"/>
<feComposite in2="hardAlpha" operator="out"/>
<feColorMatrix type="matrix" values="0 0 0 0 0.67451 0 0 0 0 0.360784 0 0 0 0 0.878431 0 0 0 0.5 0"/>
<feBlend mode="normal" in2="BackgroundImageFix" result="effect1_dropShadow_3415_134299"/>
<feBlend mode="normal" in="SourceGraphic" in2="effect1_dropShadow_3415_134299" result="shape"/>
<feColorMatrix in="SourceAlpha" type="matrix" values="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127 0" result="hardAlpha"/>
<feOffset dy="2.38904"/>
<feGaussianBlur stdDeviation="10.1538"/>
<feComposite in2="hardAlpha" operator="arithmetic" k2="-1" k3="1"/>
<feColorMatrix type="matrix" values="0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0"/>
<feBlend mode="soft-light" in2="shape" result="effect2_innerShadow_3415_134299"/>
</filter>
<linearGradient id="paint0_linear_3415_134299" x1="44.5" y1="0" x2="44.5" y2="88" gradientUnits="userSpaceOnUse">
<stop stop-color="#AC5CE0" stop-opacity="0"/>
<stop offset="1" stop-color="#AC5CE0" stop-opacity="0.2"/>
</linearGradient>
<radialGradient id="paint1_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(42.2387 62.5222) rotate(-76.7043) scale(44.7839 35.4008)">
<stop stop-color="#FA9E33"/>
<stop offset="0.925314" stop-color="#EBC645"/>
</radialGradient>
<radialGradient id="paint2_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(30.0554 48.8317) rotate(-9.90418) scale(8.03257 5.98136)">
<stop offset="0.33643" stop-color="#A24301"/>
<stop offset="1" stop-color="#D8801C" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint3_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(35.7075 47.3245) rotate(-7.12501) scale(7.08839 5.27829)">
<stop offset="0.393254" stop-color="#B7580B"/>
<stop offset="1" stop-color="#B7580B" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint4_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(48.5188 49.5853) rotate(-4.03772) scale(10.7026 6.13655)">
<stop offset="0.52166" stop-color="#C96D26"/>
<stop offset="1" stop-color="#C96D26" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint5_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(51.5332 51.9717) rotate(18.8119) scale(12.0747 6.92324)">
<stop offset="0.364657" stop-color="#E87A4C"/>
<stop offset="1" stop-color="#E87A4C" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint6_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(49.398 27.4795) rotate(100.197) scale(59.597 37.5022)">
<stop offset="0.715801" stop-color="#B23112" stop-opacity="0"/>
<stop offset="0.805739" stop-color="#B23112"/>
</radialGradient>
<radialGradient id="paint7_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(24.529 62.271) rotate(75.4008) scale(27.9052 10.5138)">
<stop offset="0.0570815" stop-color="#DA8A3D"/>
<stop offset="1" stop-color="#F19F2B" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint8_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(51.4076 58.8798) rotate(97.3057) scale(4.93853 8.86144)">
<stop stop-color="#FA9E33"/>
<stop offset="1" stop-color="#FA9E33" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint9_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(60.4509 26.3491) rotate(101.503) scale(36.53 6.59829)">
<stop stop-color="#EBC645"/>
<stop offset="0.724186" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint10_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(58.4412 45.9429) rotate(78.4654) scale(12.5626 7.88463)">
<stop offset="0.0744322" stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint11_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(42.8667 23.9627) rotate(72.2485) scale(39.9597 8.18238)">
<stop stop-color="#EBC645"/>
<stop offset="0.724186" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint12_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(38.7847 37.4648) rotate(74.3159) scale(13.2415 5.52259)">
<stop offset="0.293288" stop-color="#C77C3C"/>
<stop offset="0.633272" stop-color="#E29438" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint13_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(34.0747 30.2428) rotate(74.162) scale(18.4086 7.69388)">
<stop stop-color="#E29438"/>
<stop offset="1" stop-color="#E29438" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint14_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(51.8472 24.8419) rotate(96.6987) scale(18.8432 4.73649)">
<stop offset="0.291673" stop-color="#D9992F"/>
<stop offset="1" stop-color="#D9992F" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint15_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(46.1323 34.262) rotate(74.876) scale(9.62795 2.79399)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint16_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(59.0692 31.6244) rotate(101.712) scale(10.5183 3.05237)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint17_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(49.1468 42.9284) rotate(91.0051) scale(7.16036 9.40396)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint18_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(50.2772 33.1944) rotate(90) scale(5.21244 1.90397)">
<stop offset="0.553966" stop-color="#C18745"/>
<stop offset="0.963855" stop-color="#C18745" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint19_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(37.5915 14.5426) rotate(139.737) scale(16.1303 7.16903)">
<stop offset="0.101032" stop-color="#DDA447"/>
<stop offset="1" stop-color="#DDA447" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint20_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(56.1804 18.6875) rotate(148.815) scale(5.579 2.47956)">
<stop offset="0.101032" stop-color="#DDA447"/>
<stop offset="1" stop-color="#DDA447" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint21_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(61.2045 23.5859) rotate(104.421) scale(4.53904 3.58802)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint22_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(42.3643 21.4507) rotate(90) scale(4.39603 3.47497)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint23_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(28.8023 42.9272) rotate(171.455) scale(5.82654 13.9686)">
<stop stop-color="#FA9E33"/>
<stop offset="0.510508" stop-color="#EBC645"/>
<stop offset="1" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint24_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(28.6767 38.4056) rotate(92.7244) scale(19.3644 14.0813)">
<stop offset="0.478145" stop-color="#FA9E33" stop-opacity="0"/>
<stop offset="0.708865" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint25_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(31.2515 37.966) rotate(100.02) scale(20.0886 16.7963)">
<stop offset="0.621335" stop-color="#FA9E33" stop-opacity="0"/>
<stop offset="0.704085" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint26_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(31.8167 42.048) rotate(80.3083) scale(10.9581 2.78526)">
<stop offset="0.405928" stop-color="#DE9210"/>
<stop offset="1" stop-color="#DE9210" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint27_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(32.6959 42.048) rotate(80.8195) scale(12.5958 2.61889)">
<stop offset="0.66312" stop-color="#BD7019"/>
<stop offset="1" stop-color="#BD7019" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint28_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(38.7239 40.1678) rotate(170.077) scale(7.77803 20.5242)">
<stop stop-color="#EBC645"/>
<stop offset="0.510508" stop-color="#FFC12C"/>
<stop offset="1" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint29_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(36.7871 35.1538) rotate(94.0901) scale(23.0336 16.6554)">
<stop offset="0.44754" stop-color="#FA9E33" stop-opacity="0"/>
<stop offset="0.694434" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint30_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(52.6637 55.8651) rotate(78.6939) scale(13.5735 13.8602)">
<stop offset="0.432432" stop-color="#FA9E33"/>
<stop offset="0.63069" stop-color="#EBC645"/>
<stop offset="0.713514" stop-color="#EBC645"/>
<stop offset="0.885914" stop-color="#FA9E33"/>
</radialGradient>
<radialGradient id="paint31_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(60.0741 47.3242) rotate(-59.0978) scale(20.0541 22.343)">
<stop offset="0.475974" stop-color="#ECA120" stop-opacity="0"/>
<stop offset="0.749853" stop-color="#ECA120"/>
</radialGradient>
<radialGradient id="paint32_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(57.5287 59.3519) rotate(79.9567) scale(9.29257 9.33953)">
<stop offset="0.462765" stop-color="#FA9E33"/>
<stop offset="1" stop-color="#FA9E33" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint33_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(49.0212 58.1259) rotate(51.9272) scale(9.5729 11.5455)">
<stop offset="0.263326" stop-color="#FA9E33"/>
<stop offset="1" stop-color="#FA9E33" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint34_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(53.3054 56.8699) rotate(53.5085) scale(5.46808 5.06898)">
<stop stop-color="#FA9E33"/>
<stop offset="1" stop-color="#FA9E33" stop-opacity="0"/>
</radialGradient>
<radialGradient id="paint35_radial_3415_134299" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(57.1853 58.8795) rotate(90) scale(4.96909 10.3058)">
<stop stop-color="#EBC645"/>
<stop offset="1" stop-color="#EBC645" stop-opacity="0"/>
</radialGradient>
<clipPath id="clip0_3415_134299">
<rect x="0.5" width="88" height="88" rx="44" fill="white"/>
</clipPath>
</defs>
</svg>
"
+          />
+        </div>
+        <div class="bcontBody">
+          <div class="title">Hi from the Edge</div>
+          <div class="msgWrap">
+            <div class="msg">
+              You did it! This simple sample app deploys straight from the edge.
+              Now imagine what you can do with it.
+            </div>
+            <div class="footer">
+              Follow us on Github.
+              <a
+                href="https://github.com/wasmerio"
+                target="_blank"
+                class="githubBtn"
+              >
+                <span class="githubstars">
+                  <span class="starsvalue">16,000+</span>
+                  <img
+                    src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyMiIgaGVpZ2h0PSIyMiIgdmlld0JveD0iMCAwIDIyIDIyIiBmaWxsPSJub25lIj4KICA8cGF0aCBkPSJNOS44MjY5OSAxLjc1NzY3QzEwLjI3OTUgMC43NDc0NCAxMS43MjA1IDAuNzQ3NDQzIDEyLjE3MyAxLjc1NzY4TDE0LjI0NjMgNi4zODYyNEMxNC40MzMgNi44MDI5IDE0LjgyODYgNy4wODg5NyAxNS4yODQ1IDcuMTM2ODVMMjAuMzQ4OSA3LjY2ODc1QzIxLjQ1NDIgNy43ODQ4NCAyMS44OTk1IDkuMTQ4NTggMjEuMDczOCA5Ljg4OTAzTDE3LjI5MDkgMTMuMjgxNUMxNi45NTAzIDEzLjU4NjkgMTYuNzk5MiAxNC4wNDk4IDE2Ljg5NDMgMTQuNDk2MUwxNy45NTA5IDE5LjQ1MzRDMTguMTgxNiAyMC41MzUzIDE3LjAxNTggMjEuMzc4MiAxNi4wNTMgMjAuODI1NkwxMS42NDE2IDE4LjI5MzdDMTEuMjQ0NSAxOC4wNjU4IDEwLjc1NTUgMTguMDY1OCAxMC4zNTg0IDE4LjI5MzdMNS45NDcwMyAyMC44MjU2QzQuOTg0MjEgMjEuMzc4MiAzLjgxODQ0IDIwLjUzNTMgNC4wNDkwNiAxOS40NTM0TDUuMTA1NjggMTQuNDk2MUM1LjIwMDggMTQuMDQ5OCA1LjA0OTY2IDEzLjU4NjkgNC43MDkxMiAxMy4yODE1TDAuOTI2MTU0IDkuODg5MDNDMC4xMDA0ODIgOS4xNDg1OCAwLjU0NTc2OCA3Ljc4NDg0IDEuNjUxMTIgNy42Njg3NUw2LjcxNTQ2IDcuMTM2ODVDNy4xNzEzNSA3LjA4ODk3IDcuNTY3MDMgNi44MDI5IDcuNzUzNjcgNi4zODYyNEw5LjgyNjk5IDEuNzU3NjdaIiBmaWxsPSIjRUJDNjQ1Ii8+Cjwvc3ZnPg=="
+                  />
+                </span>
+                <svg
+                  xmlns="http://www.w3.org/2000/svg"
+                  width="2"
+                  height="32"
+                  viewBox="0 0 2 32"
+                  fill="none"
+                >
+                  <path d="M1 0L1 32" stroke="#0F0518" stroke-opacity="0.2" />
+                </svg>
+                <div class="githublink">
+                  <svg
+                    xmlns="http://www.w3.org/2000/svg"
+                    width="24"
+                    height="24"
+                    viewBox="0 0 24 24"
+                    fill="none"
+                  >
+                    <g clip-path="url(#clip0_3778_6768)">
+                      <path
+                        d="M12.0002 0.279786C9.14338 0.278937 6.37999 1.29731 4.20691 3.15177C2.03384 5.00624 0.593645 7.57514 0.145306 10.3965C-0.303032 13.2179 0.269897 16.1067 1.76107 18.5435C3.25225 20.9802 5.56383 22.805 8.28017 23.6898H8.57017C8.71166 23.6986 8.85339 23.6772 8.98598 23.627C9.11856 23.5768 9.23896 23.499 9.3392 23.3988C9.43944 23.2986 9.51722 23.1782 9.56738 23.0456C9.61755 22.913 9.63895 22.7713 9.63017 22.6298V22.4198C9.63017 22.2498 9.63017 22.0198 9.63017 21.3298C9.62036 21.2643 9.59763 21.2014 9.56329 21.1447C9.52896 21.0881 9.48371 21.0388 9.43017 20.9998C9.37209 20.9528 9.30421 20.9194 9.23152 20.9021C9.15884 20.8848 9.08321 20.884 9.01017 20.8998C6.33017 21.4798 5.76017 19.7998 5.72017 19.6898C5.38458 18.8009 4.78421 18.0365 4.00017 17.4998C3.9532 17.4592 3.90304 17.4224 3.85017 17.3898C3.96638 17.3272 4.0993 17.3027 4.23017 17.3198C4.48151 17.3547 4.71952 17.4542 4.92105 17.6084C5.12257 17.7626 5.28074 17.9663 5.38017 18.1998C5.76702 18.8734 6.40006 19.3706 7.14608 19.587C7.89211 19.8033 8.69298 19.7219 9.38017 19.3598C9.45392 19.3276 9.51879 19.278 9.56928 19.2153C9.61977 19.1526 9.65438 19.0787 9.67017 18.9998C9.70846 18.5372 9.90644 18.1024 10.2302 17.7698C10.302 17.706 10.354 17.6228 10.3798 17.5302C10.4056 17.4376 10.4042 17.3395 10.3757 17.2477C10.3472 17.1559 10.2929 17.0743 10.2192 17.0126C10.1455 16.9509 10.0556 16.9117 9.96017 16.8998C7.59017 16.6298 5.17017 15.7998 5.17017 11.7098C5.1502 10.6827 5.52617 9.68723 6.22017 8.92979C6.28409 8.85919 6.32652 8.7718 6.34246 8.67791C6.35841 8.58402 6.3472 8.48753 6.31017 8.39979C6.03225 7.62332 6.03579 6.77391 6.32017 5.99979C7.244 6.16355 8.11111 6.55925 8.84017 7.14979C8.90041 7.1923 8.96945 7.22067 9.04217 7.23279C9.11489 7.24491 9.18941 7.24047 9.26017 7.21979C10.1535 6.97747 11.0746 6.85308 12.0002 6.84979C12.9292 6.85057 13.854 6.97499 14.7502 7.21979C14.8195 7.2389 14.8921 7.24254 14.963 7.23045C15.0338 7.21835 15.1012 7.19081 15.1602 7.14979C15.8904 6.56111 16.757 6.16563 17.6802 5.99979C17.9524 6.76977 17.9524 7.60981 17.6802 8.37979C17.6431 8.46753 17.6319 8.56402 17.6479 8.65791C17.6638 8.7518 17.7063 8.83919 17.7702 8.90979C18.457 9.65966 18.8325 10.643 18.8202 11.6598C18.8202 15.7498 16.3902 16.5698 14.0102 16.8398C13.9126 16.85 13.8201 16.8886 13.7443 16.951C13.6685 17.0133 13.6127 17.0966 13.584 17.1904C13.5552 17.2843 13.5546 17.3845 13.5824 17.4786C13.6102 17.5728 13.6651 17.6566 13.7402 17.7198C13.9617 17.9484 14.1309 18.2224 14.2363 18.5228C14.3416 18.8232 14.3804 19.1429 14.3502 19.4598V22.6398C14.3452 22.7961 14.3749 22.9516 14.4372 23.0951C14.4994 23.2386 14.5926 23.3666 14.7102 23.4698C14.8598 23.5818 15.0336 23.6574 15.2177 23.6904C15.4017 23.7234 15.5909 23.7129 15.7702 23.6598C18.4683 22.7571 20.7579 20.9252 22.2305 18.4909C23.7031 16.0566 24.2629 13.1782 23.81 10.3694C23.3571 7.56061 21.9209 5.0041 19.7578 3.15603C17.5946 1.30797 14.8452 0.288591 12.0002 0.279786Z"
+                        fill="#0F0518"
+                      />
+                    </g>
+                    <defs>
+                      <clipPath id="clip0_3778_6768">
+                        <rect width="24" height="24" fill="white" />
+                      </clipPath>
+                    </defs>
+                  </svg>
+                  <svg
+                    width="12"
+                    height="34"
+                    viewBox="0 0 12 34"
+                    fill="none"
+                    xmlns="http://www.w3.org/2000/svg"
+                  >
+                    <path
+                      d="M2.25 10.5H10.5M10.5 10.5V18.75M10.5 10.5L1.5 19.5"
+                      stroke="#0F0518"
+                      stroke-width="1.5"
+                      stroke-linecap="round"
+                      stroke-linejoin="round"
+                    />
+                  </svg>
+                </div>
+              </a>
+            </div>
+          </div>
+        </div>
+      </div>
+    </main>
+  </body>
+</html>
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/prompts.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/prompts.rs
new file mode 100644
index 0000000..df9a191
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/prompts.rs
@@ -0,0 +1,207 @@
+use anyhow::Context;
+use colored::Colorize;
+use dialoguer::Select;
+use edge_schema::schema::StringWebcIdent;
+use wasmer_api::WasmerClient;
+
+pub fn prompt_for_ident(message: &str, default: Option<&str>) -> Result<String, anyhow::Error> {
+    loop {
+        let diag = dialoguer::Input::new()
+            .with_prompt(message)
+            .with_initial_text(default.unwrap_or_default());
+
+        // if let Some(val) = &validator {
+        //     diag.validate_with(val);
+        // }
+
+        let raw: String = diag.interact()?;
+        let val = raw.trim();
+        if !val.is_empty() {
+            break Ok(val.to_string());
+        }
+    }
+}
+
+/// Ask a user for a package name.
+///
+/// Will continue looping until the user provides a valid name.
+pub fn prompt_for_package_ident(
+    message: &str,
+    default: Option<&str>,
+) -> Result<StringWebcIdent, anyhow::Error> {
+    loop {
+        let raw: String = dialoguer::Input::new()
+            .with_prompt(message)
+            .with_initial_text(default.unwrap_or_default())
+            .interact_text()
+            .context("could not read user input")?;
+
+        match raw.parse::<StringWebcIdent>() {
+            Ok(p) => break Ok(p),
+            Err(err) => {
+                eprintln!("invalid package name: {err}");
+            }
+        }
+    }
+}
+
+/// Defines how to check for a package.
+pub enum PackageCheckMode {
+    /// The package must exist in the registry.
+    MustExist,
+    /// The package must NOT exist in the registry.
+    #[allow(dead_code)]
+    MustNotExist,
+}
+
+/// Ask for a package name.
+///
+/// Will continue looping until the user provides a valid name.
+///
+/// If an API is provided, will check if the package exists.
+pub async fn prompt_for_package(
+    message: &str,
+    default: Option<&str>,
+    check: Option<PackageCheckMode>,
+    client: Option<&WasmerClient>,
+) -> Result<(StringWebcIdent, Option<wasmer_api::types::Package>), anyhow::Error> {
+    loop {
+        let ident = prompt_for_package_ident(message, default)?;
+
+        if let Some(check) = &check {
+            let api = client.expect("Check mode specified, but no API provided");
+
+            let pkg = wasmer_api::query::get_package(api, ident.to_string())
+                .await
+                .context("could not query backend for package")?;
+
+            match check {
+                PackageCheckMode::MustExist => {
+                    if let Some(pkg) = pkg {
+                        let mut ident = ident;
+                        if let Some(v) = &pkg.last_version {
+                            ident.0.tag = Some(v.version.clone());
+                        }
+                        break Ok((ident, Some(pkg)));
+                    } else {
+                        eprintln!("Package '{ident}' does not exist");
+                    }
+                }
+                PackageCheckMode::MustNotExist => {
+                    if pkg.is_none() {
+                        break Ok((ident, None));
+                    } else {
+                        eprintln!("Package '{ident}' already exists");
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Prompt for a namespace.
+///
+/// Will either show a select with all available namespaces based on the `user`
+/// argument, or present a basic text input.
+///
+/// The username will be included as an option.
+pub fn prompt_for_namespace(
+    message: &str,
+    default: Option<&str>,
+    user: Option<&wasmer_api::types::UserWithNamespaces>,
+) -> Result<String, anyhow::Error> {
+    if let Some(user) = user {
+        let namespaces = user
+            .namespaces
+            .edges
+            .clone()
+            .into_iter()
+            .flatten()
+            .filter_map(|e| e.node)
+            .collect::<Vec<_>>();
+
+        let labels = [user.username.clone()]
+            .into_iter()
+            .chain(namespaces.iter().map(|ns| ns.global_name.clone()))
+            .collect::<Vec<_>>();
+
+        let selection_index = Select::new()
+            .with_prompt(message)
+            .default(0)
+            .items(&labels)
+            .interact()
+            .context("could not read user input")?;
+
+        Ok(labels[selection_index].clone())
+    } else {
+        loop {
+            let value = dialoguer::Input::<String>::new()
+                .with_prompt(message)
+                .with_initial_text(default.map(|x| x.trim().to_string()).unwrap_or_default())
+                .interact_text()
+                .context("could not read user input")?
+                .trim()
+                .to_string();
+
+            if !value.is_empty() {
+                break Ok(value);
+            }
+        }
+    }
+}
+
+/// Prompt for an app name.
+/// If an api provided, will check if an app with the givne alias already exists.
+#[allow(dead_code)]
+pub async fn prompt_new_app_name(
+    message: &str,
+    default: Option<&str>,
+    namespace: &str,
+    api: Option<&WasmerClient>,
+) -> Result<String, anyhow::Error> {
+    loop {
+        let ident = prompt_for_ident(message, default)?;
+
+        if let Some(api) = &api {
+            let app = wasmer_api::query::get_app(api, namespace.to_string(), ident.clone()).await?;
+            eprintln!("Checking name availability...");
+            if app.is_some() {
+                eprintln!(
+                    "{}: app '{}/{}' already exists - pick a different name",
+                    "WARN:".yellow(),
+                    namespace,
+                    ident
+                );
+            } else {
+                break Ok(ident);
+            }
+        }
+    }
+}
+
+/// Prompt for an app name.
+/// If an api provided, will check if an app with the givne alias already exists.
+#[allow(dead_code)]
+pub async fn prompt_new_app_alias(
+    message: &str,
+    default: Option<&str>,
+    api: Option<&WasmerClient>,
+) -> Result<String, anyhow::Error> {
+    loop {
+        let ident = prompt_for_ident(message, default)?;
+
+        if let Some(api) = &api {
+            let app = wasmer_api::query::get_app_by_alias(api, ident.clone()).await?;
+            eprintln!("Checking name availability...");
+            if app.is_some() {
+                eprintln!(
+                    "{}: alias '{}' already exists - pick a different name",
+                    "WARN:".yellow(),
+                    ident
+                );
+            } else {
+                break Ok(ident);
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/render.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/render.rs
new file mode 100644
index 0000000..313daf8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/src/utils/render.rs
@@ -0,0 +1,87 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ItemFormat {
+    Json,
+    Yaml,
+    #[default]
+    Table,
+}
+
+impl ItemFormat {
+    pub fn render<T: CliRender>(self, item: &T) -> String {
+        CliRender::render_item(item, self)
+    }
+}
+
+impl std::str::FromStr for ItemFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "json" => Ok(ItemFormat::Json),
+            "yaml" => Ok(ItemFormat::Yaml),
+            "table" => Ok(ItemFormat::Table),
+            other => Err(format!("Unknown output format: '{other}'")),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+pub enum ListFormat {
+    Json,
+    Yaml,
+    #[default]
+    Table,
+    ItemTable,
+}
+
+impl ListFormat {
+    pub fn render<T: CliRender>(self, items: &[T]) -> String {
+        CliRender::render_list(items, self)
+    }
+}
+
+impl std::str::FromStr for ListFormat {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "json" => Ok(ListFormat::Json),
+            "yaml" => Ok(ListFormat::Yaml),
+            "table" => Ok(ListFormat::Table),
+            "item-table" => Ok(ListFormat::ItemTable),
+            other => Err(format!("Unknown output format: '{other}'")),
+        }
+    }
+}
+
+pub trait CliRender: serde::Serialize + Sized {
+    fn render_item(&self, format: ItemFormat) -> String {
+        match format {
+            ItemFormat::Json => serde_json::to_string_pretty(self).unwrap(),
+            ItemFormat::Yaml => serde_yaml::to_string(self).unwrap(),
+            ItemFormat::Table => self.render_item_table(),
+        }
+    }
+
+    fn render_item_table(&self) -> String;
+
+    fn render_list(items: &[Self], format: ListFormat) -> String {
+        match format {
+            ListFormat::Json => serde_json::to_string_pretty(items).unwrap(),
+            ListFormat::Yaml => serde_yaml::to_string(items).unwrap(),
+            ListFormat::Table => Self::render_list_table(items),
+            ListFormat::ItemTable => {
+                let mut out = String::new();
+
+                for item in items {
+                    out.push_str(&item.render_item_table());
+                    out.push_str("\n\n");
+                }
+
+                out
+            }
+        }
+    }
+
+    fn render_list_table(items: &[Self]) -> String;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/cli/tests/version.rs b/arbitrator/tools/module_roots/wasmer/lib/cli/tests/version.rs
new file mode 100644
index 0000000..1dcb7e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/cli/tests/version.rs
@@ -0,0 +1,68 @@
+use assert_cmd::Command;
+
+const WASMER_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[test]
+fn short_version_string() {
+    let version_number = format!("wasmer {WASMER_VERSION}");
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("--version")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&version_number));
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("-V")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&version_number));
+}
+
+#[test]
+fn long_version_string() {
+    let long_version_number = format!(
+        "wasmer {} ({} {})",
+        env!("CARGO_PKG_VERSION"),
+        env!("WASMER_BUILD_GIT_HASH_SHORT"),
+        env!("WASMER_BUILD_DATE")
+    );
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("--version")
+        .arg("--verbose")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&long_version_number))
+        .stdout(predicates::str::contains("binary:"));
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("-Vv")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&long_version_number))
+        .stdout(predicates::str::contains("binary:"));
+}
+
+#[test]
+fn help_text_contains_version() {
+    let version_number = format!("wasmer {WASMER_VERSION}");
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("-h")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&version_number));
+
+    Command::cargo_bin("wasmer")
+        .unwrap()
+        .arg("--help")
+        .assert()
+        .success()
+        .stdout(predicates::str::contains(&version_number));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/.gitignore
new file mode 100644
index 0000000..4308d82
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/.gitignore
@@ -0,0 +1,3 @@
+target/
+**/*.rs.bk
+Cargo.lock
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/Cargo.toml
new file mode 100644
index 0000000..3369cc8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/Cargo.toml
@@ -0,0 +1,45 @@
+[package]
+name = "wasmer-compiler-cranelift"
+description = "Cranelift compiler for Wasmer WebAssembly runtime"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly", "compiler", "cranelift"]
+documentation = "https://docs.rs/wasmer-compiler-cranelift/"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer-compiler = { path = "../compiler", version = "=4.2.8", features = ["translator", "compiler"], default-features = false }
+wasmer-types = { path = "../types", version = "=4.2.8", default-features = false, features = ["std"] }
+cranelift-entity = { version = "0.91.1", default-features = false }
+cranelift-codegen = { version = "0.91.1", default-features = false, features = ["x86", "arm64", "riscv64"] }
+cranelift-frontend = { version = "0.91.1", default-features = false }
+tracing = "0.1"
+hashbrown = { version = "0.11", optional = true }
+rayon = { version = "1.5", optional = true }
+more-asserts = "0.2"
+gimli = { version = "0.26", optional = true }
+smallvec = "1.6"
+target-lexicon = { version = "0.12.2", default-features = false }
+
+[dev-dependencies]
+cranelift-codegen = { version = "0.91.1", features = ["all-arch"] }
+lazy_static = "1.4"
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[features]
+default = ["std", "unwind", "rayon"]
+wasm = ["std", "unwind"]
+unwind = ["cranelift-codegen/unwind", "gimli"]
+std = ["cranelift-codegen/std", "cranelift-frontend/std", "wasmer-compiler/std", "wasmer-types/std"]
+core = ["hashbrown", "cranelift-codegen/core", "cranelift-frontend/core"]
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/README.md b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/README.md
new file mode 100644
index 0000000..51e8b92
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/README.md
@@ -0,0 +1,36 @@
+# `wasmer-compiler-cranelift` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-cranelift.svg)](https://crates.io/crates/wasmer-compiler-cranelift)
+
+This crate contains a compiler implementation based on Cranelift.
+
+## Usage
+
+```rust
+use wasmer::{Store, EngineBuilder};
+use wasmer_compiler_cranelift::Cranelift;
+
+let compiler = Cranelift::new();
+let mut store = Store::new(compiler);
+```
+
+*Note: you can find a [full working example using Cranelift compiler
+here][example].*
+
+## When to use Cranelift
+
+We recommend using this compiler crate **only for development
+proposes**. For production we recommend using [`wasmer-compiler-llvm`]
+as it offers a much better runtime speed (50% faster on average).
+
+### Acknowledgments
+
+This project borrowed some of the function lowering from
+[`cranelift-wasm`].
+
+Please check [Wasmer `ATTRIBUTIONS`] to further see licenses and other
+attributions of the project.
+
+
+[example]: https://github.com/wasmerio/wasmer/blob/master/examples/compiler_cranelift.rs
+[`wasmer-compiler-llvm`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm
+[`cranelift-wasm`]: https://crates.io/crates/cranelift-wasm
+[Wasmer `ATTRIBUTIONS`]: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/build.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/build.rs
new file mode 100644
index 0000000..0be0760
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/build.rs
@@ -0,0 +1,15 @@
+//! Wasmer Cranelift compiler build script.
+//!
+//! Sets the git revsion? for $PURPOSE
+//! TODO(syrus): explain what's happening here
+
+use std::process::Command;
+use std::str;
+
+fn main() {
+    let git_rev = match Command::new("git").args(["rev-parse", "HEAD"]).output() {
+        Ok(output) => str::from_utf8(&output.stdout).unwrap().trim().to_string(),
+        Err(_) => env!("CARGO_PKG_VERSION").to_string(),
+    };
+    println!("cargo:rustc-env=GIT_REV={}", git_rev);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/address_map.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/address_map.rs
new file mode 100644
index 0000000..088067c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/address_map.rs
@@ -0,0 +1,40 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use cranelift_codegen::Context;
+use cranelift_codegen::MachSrcLoc;
+use std::ops::Range;
+use wasmer_types::{FunctionAddressMap, InstructionAddressMap, SourceLoc};
+
+pub fn get_function_address_map(
+    context: &Context,
+    range: Range<usize>,
+    body_len: usize,
+) -> FunctionAddressMap {
+    let mut instructions = Vec::new();
+
+    // New-style backend: we have a `MachCompileResult` that will give us `MachSrcLoc` mapping
+    // tuples.
+    let mcr = context.compiled_code().unwrap();
+    for &MachSrcLoc { start, end, loc } in mcr.buffer.get_srclocs_sorted() {
+        instructions.push(InstructionAddressMap {
+            srcloc: SourceLoc::new(loc.bits()),
+            code_offset: start as usize,
+            code_len: (end - start) as usize,
+        });
+    }
+
+    // Generate artificial srcloc for function start/end to identify boundary
+    // within module. Similar to FuncTranslator::cur_srcloc(): it will wrap around
+    // if byte code is larger than 4 GB.
+    let start_srcloc = SourceLoc::new(range.start as u32);
+    let end_srcloc = SourceLoc::new(range.end as u32);
+
+    FunctionAddressMap {
+        instructions,
+        start_srcloc,
+        end_srcloc,
+        body_offset: 0,
+        body_len,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/compiler.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/compiler.rs
new file mode 100644
index 0000000..b2a880f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/compiler.rs
@@ -0,0 +1,471 @@
+//! Support for compiling with Cranelift.
+
+use crate::address_map::get_function_address_map;
+use crate::config::Cranelift;
+#[cfg(feature = "unwind")]
+use crate::dwarf::WriterRelocate;
+use crate::func_environ::{get_function_name, FuncEnvironment};
+use crate::trampoline::{
+    make_trampoline_dynamic_function, make_trampoline_function_call, FunctionBuilderContext,
+};
+use crate::translator::{
+    compiled_function_unwind_info, irlibcall_to_libcall, irreloc_to_relocationkind,
+    signature_to_cranelift_ir, CraneliftUnwindInfo, FuncTranslator,
+};
+use cranelift_codegen::ir::{ExternalName, UserFuncName};
+use cranelift_codegen::{ir, MachReloc};
+use cranelift_codegen::{Context, MachTrap};
+#[cfg(feature = "unwind")]
+use gimli::write::{Address, EhFrame, FrameTable};
+#[cfg(feature = "rayon")]
+use rayon::prelude::{IntoParallelRefIterator, ParallelIterator};
+use std::sync::Arc;
+use wasmer_compiler::{
+    Compiler, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader, ModuleMiddleware,
+    ModuleMiddlewareChain, ModuleTranslationState,
+};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{
+    CallingConvention, Compilation, CompileError, CompileModuleInfo, CompiledFunction,
+    CompiledFunctionFrameInfo, CompiledFunctionUnwindInfo, Dwarf, FunctionBody, FunctionIndex,
+    LocalFunctionIndex, ModuleInfo, Relocation, RelocationTarget, SectionIndex, SignatureIndex,
+    Target, TrapCode, TrapInformation,
+};
+
+/// A compiler that compiles a WebAssembly module with Cranelift, translating the Wasm to Cranelift IR,
+/// optimizing it and then translating to assembly.
+pub struct CraneliftCompiler {
+    config: Cranelift,
+}
+
+impl CraneliftCompiler {
+    /// Creates a new Cranelift compiler
+    pub fn new(config: Cranelift) -> Self {
+        Self { config }
+    }
+
+    /// Gets the WebAssembly features for this Compiler
+    pub fn config(&self) -> &Cranelift {
+        &self.config
+    }
+}
+
+impl Compiler for CraneliftCompiler {
+    fn name(&self) -> &str {
+        "cranelift"
+    }
+
+    /// Get the middlewares for this compiler
+    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
+        &self.config.middlewares
+    }
+
+    /// Compile the module using Cranelift, producing a compilation result with
+    /// associated relocations.
+    fn compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        module_translation_state: &ModuleTranslationState,
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+    ) -> Result<Compilation, CompileError> {
+        let isa = self
+            .config()
+            .isa(target)
+            .map_err(|error| CompileError::Codegen(error.to_string()))?;
+        let frontend_config = isa.frontend_config();
+        let memory_styles = &compile_info.memory_styles;
+        let table_styles = &compile_info.table_styles;
+        let module = &compile_info.module;
+        let signatures = module
+            .signatures
+            .iter()
+            .map(|(_sig_index, func_type)| signature_to_cranelift_ir(func_type, frontend_config))
+            .collect::<PrimaryMap<SignatureIndex, ir::Signature>>();
+
+        // Generate the frametable
+        #[cfg(feature = "unwind")]
+        let dwarf_frametable = if function_body_inputs.is_empty() {
+            // If we have no function body inputs, we don't need to
+            // construct the `FrameTable`. Constructing it, with empty
+            // FDEs will cause some issues in Linux.
+            None
+        } else {
+            match target.triple().default_calling_convention() {
+                Ok(CallingConvention::SystemV) => {
+                    match isa.create_systemv_cie() {
+                        Some(cie) => {
+                            let mut dwarf_frametable = FrameTable::default();
+                            let cie_id = dwarf_frametable.add_cie(cie);
+                            Some((dwarf_frametable, cie_id))
+                        }
+                        // Even though we are in a SystemV system, Cranelift doesn't support it
+                        None => None,
+                    }
+                }
+                _ => None,
+            }
+        };
+
+        let mut custom_sections = PrimaryMap::new();
+
+        #[cfg(not(feature = "rayon"))]
+        let mut func_translator = FuncTranslator::new();
+        #[cfg(not(feature = "rayon"))]
+        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .into_iter()
+            .map(|(i, input)| {
+                let func_index = module.func_index(i);
+                let mut context = Context::new();
+                let mut func_env = FuncEnvironment::new(
+                    isa.frontend_config(),
+                    module,
+                    &signatures,
+                    &memory_styles,
+                    &table_styles,
+                );
+                context.func.name = match get_function_name(func_index) {
+                    ExternalName::User(nameref) => {
+                        if context.func.params.user_named_funcs().is_valid(nameref) {
+                            let name = &context.func.params.user_named_funcs()[nameref];
+                            UserFuncName::User(name.clone())
+                        } else {
+                            UserFuncName::default()
+                        }
+                    }
+                    ExternalName::TestCase(testcase) => UserFuncName::Testcase(testcase),
+                    _ => UserFuncName::default(),
+                };
+                context.func.signature = signatures[module.functions[func_index]].clone();
+                // if generate_debug_info {
+                //     context.func.collect_debug_info();
+                // }
+                let mut reader =
+                    MiddlewareBinaryReader::new_with_offset(input.data, input.module_offset);
+                reader.set_middleware_chain(
+                    self.config
+                        .middlewares
+                        .generate_function_middleware_chain(i),
+                );
+
+                func_translator.translate(
+                    module_translation_state,
+                    &mut reader,
+                    &mut context.func,
+                    &mut func_env,
+                    i,
+                )?;
+
+                let mut code_buf: Vec<u8> = Vec::new();
+                context
+                    .compile_and_emit(&*isa, &mut code_buf)
+                    .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+
+                let result = context.compiled_code().unwrap();
+                let func_relocs = result
+                    .buffer
+                    .relocs()
+                    .into_iter()
+                    .map(|r| mach_reloc_to_reloc(module, r))
+                    .collect::<Vec<_>>();
+
+                let traps = result
+                    .buffer
+                    .traps()
+                    .into_iter()
+                    .map(mach_trap_to_trap)
+                    .collect::<Vec<_>>();
+
+                let (unwind_info, fde) = match compiled_function_unwind_info(&*isa, &context)? {
+                    #[cfg(feature = "unwind")]
+                    CraneliftUnwindInfo::Fde(fde) => {
+                        if dwarf_frametable.is_some() {
+                            let fde = fde.to_fde(Address::Symbol {
+                                // The symbol is the kind of relocation.
+                                // "0" is used for functions
+                                symbol: WriterRelocate::FUNCTION_SYMBOL,
+                                // We use the addend as a way to specify the
+                                // function index
+                                addend: i.index() as _,
+                            });
+                            // The unwind information is inserted into the dwarf section
+                            (Some(CompiledFunctionUnwindInfo::Dwarf), Some(fde))
+                        } else {
+                            (None, None)
+                        }
+                    }
+                    #[cfg(feature = "unwind")]
+                    other => (other.maybe_into_to_windows_unwind(), None),
+
+                    // This is a bit hacky, but necessary since gimli is not
+                    // available when the "unwind" feature is disabled.
+                    #[cfg(not(feature = "unwind"))]
+                    other => (other.maybe_into_to_windows_unwind(), None::<()>),
+                };
+
+                let range = reader.range();
+                let address_map = get_function_address_map(&context, range, code_buf.len());
+
+                Ok((
+                    CompiledFunction {
+                        body: FunctionBody {
+                            body: code_buf,
+                            unwind_info,
+                        },
+                        relocations: func_relocs,
+                        frame_info: CompiledFunctionFrameInfo { address_map, traps },
+                    },
+                    fde,
+                ))
+            })
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .unzip();
+        #[cfg(feature = "rayon")]
+        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .par_iter()
+            .map_init(FuncTranslator::new, |func_translator, (i, input)| {
+                let func_index = module.func_index(*i);
+                let mut context = Context::new();
+                let mut func_env = FuncEnvironment::new(
+                    isa.frontend_config(),
+                    module,
+                    &signatures,
+                    memory_styles,
+                    table_styles,
+                );
+                context.func.name = match get_function_name(func_index) {
+                    ExternalName::User(nameref) => {
+                        if context.func.params.user_named_funcs().is_valid(nameref) {
+                            let name = &context.func.params.user_named_funcs()[nameref];
+                            UserFuncName::User(name.clone())
+                        } else {
+                            UserFuncName::default()
+                        }
+                    }
+                    ExternalName::TestCase(testcase) => UserFuncName::Testcase(testcase),
+                    _ => UserFuncName::default(),
+                };
+                context.func.signature = signatures[module.functions[func_index]].clone();
+                // if generate_debug_info {
+                //     context.func.collect_debug_info();
+                // }
+                let mut reader =
+                    MiddlewareBinaryReader::new_with_offset(input.data, input.module_offset);
+                reader.set_middleware_chain(
+                    self.config
+                        .middlewares
+                        .generate_function_middleware_chain(*i),
+                );
+
+                func_translator.translate(
+                    module_translation_state,
+                    &mut reader,
+                    &mut context.func,
+                    &mut func_env,
+                    *i,
+                )?;
+
+                let mut code_buf: Vec<u8> = Vec::new();
+                context
+                    .compile_and_emit(&*isa, &mut code_buf)
+                    .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+
+                let result = context.compiled_code().unwrap();
+                let func_relocs = result
+                    .buffer
+                    .relocs()
+                    .iter()
+                    .map(|r| mach_reloc_to_reloc(module, r))
+                    .collect::<Vec<_>>();
+
+                let traps = result
+                    .buffer
+                    .traps()
+                    .iter()
+                    .map(mach_trap_to_trap)
+                    .collect::<Vec<_>>();
+
+                let (unwind_info, fde) = match compiled_function_unwind_info(&*isa, &context)? {
+                    #[cfg(feature = "unwind")]
+                    CraneliftUnwindInfo::Fde(fde) => {
+                        if dwarf_frametable.is_some() {
+                            let fde = fde.to_fde(Address::Symbol {
+                                // The symbol is the kind of relocation.
+                                // "0" is used for functions
+                                symbol: WriterRelocate::FUNCTION_SYMBOL,
+                                // We use the addend as a way to specify the
+                                // function index
+                                addend: i.index() as _,
+                            });
+                            // The unwind information is inserted into the dwarf section
+                            (Some(CompiledFunctionUnwindInfo::Dwarf), Some(fde))
+                        } else {
+                            (None, None)
+                        }
+                    }
+                    #[cfg(feature = "unwind")]
+                    other => (other.maybe_into_to_windows_unwind(), None),
+
+                    // This is a bit hacky, but necessary since gimli is not
+                    // available when the "unwind" feature is disabled.
+                    #[cfg(not(feature = "unwind"))]
+                    other => (other.maybe_into_to_windows_unwind(), None::<()>),
+                };
+
+                let range = reader.range();
+                let address_map = get_function_address_map(&context, range, code_buf.len());
+
+                Ok((
+                    CompiledFunction {
+                        body: FunctionBody {
+                            body: code_buf,
+                            unwind_info,
+                        },
+                        relocations: func_relocs,
+                        frame_info: CompiledFunctionFrameInfo { address_map, traps },
+                    },
+                    fde,
+                ))
+            })
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .unzip();
+
+        #[cfg(feature = "unwind")]
+        let dwarf = if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
+            for fde in fdes.into_iter().flatten() {
+                dwarf_frametable.add_fde(cie_id, fde);
+            }
+            let mut eh_frame = EhFrame(WriterRelocate::new(target.triple().endianness().ok()));
+            dwarf_frametable.write_eh_frame(&mut eh_frame).unwrap();
+
+            let eh_frame_section = eh_frame.0.into_section();
+            custom_sections.push(eh_frame_section);
+            Some(Dwarf::new(SectionIndex::new(custom_sections.len() - 1)))
+        } else {
+            None
+        };
+        #[cfg(not(feature = "unwind"))]
+        let dwarf = None;
+
+        // function call trampolines (only for local functions, by signature)
+        #[cfg(not(feature = "rayon"))]
+        let mut cx = FunctionBuilderContext::new();
+        #[cfg(not(feature = "rayon"))]
+        let function_call_trampolines = module
+            .signatures
+            .values()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .map(|sig| make_trampoline_function_call(&*isa, &mut cx, sig))
+            .collect::<Result<Vec<FunctionBody>, CompileError>>()?
+            .into_iter()
+            .collect::<PrimaryMap<SignatureIndex, FunctionBody>>();
+        #[cfg(feature = "rayon")]
+        let function_call_trampolines = module
+            .signatures
+            .values()
+            .collect::<Vec<_>>()
+            .par_iter()
+            .map_init(FunctionBuilderContext::new, |cx, sig| {
+                make_trampoline_function_call(&*isa, cx, sig)
+            })
+            .collect::<Result<Vec<FunctionBody>, CompileError>>()?
+            .into_iter()
+            .collect::<PrimaryMap<SignatureIndex, FunctionBody>>();
+
+        use wasmer_types::VMOffsets;
+        let offsets = VMOffsets::new_for_trampolines(frontend_config.pointer_bytes());
+        // dynamic function trampolines (only for imported functions)
+        #[cfg(not(feature = "rayon"))]
+        let mut cx = FunctionBuilderContext::new();
+        #[cfg(not(feature = "rayon"))]
+        let dynamic_function_trampolines = module
+            .imported_function_types()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .map(|func_type| make_trampoline_dynamic_function(&*isa, &offsets, &mut cx, &func_type))
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+        #[cfg(feature = "rayon")]
+        let dynamic_function_trampolines = module
+            .imported_function_types()
+            .collect::<Vec<_>>()
+            .par_iter()
+            .map_init(FunctionBuilderContext::new, |cx, func_type| {
+                make_trampoline_dynamic_function(&*isa, &offsets, cx, func_type)
+            })
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+
+        Ok(Compilation {
+            functions: functions.into_iter().collect(),
+            custom_sections,
+            function_call_trampolines,
+            dynamic_function_trampolines,
+            debug: dwarf,
+        })
+    }
+}
+
+fn mach_reloc_to_reloc(module: &ModuleInfo, reloc: &MachReloc) -> Relocation {
+    let &MachReloc {
+        offset,
+        kind,
+        ref name,
+        addend,
+    } = reloc;
+    let reloc_target = if let ExternalName::User(extname_ref) = *name {
+        //debug_assert_eq!(namespace, 0);
+        RelocationTarget::LocalFunc(
+            module
+                .local_func_index(FunctionIndex::from_u32(extname_ref.as_u32()))
+                .expect("The provided function should be local"),
+        )
+    } else if let ExternalName::LibCall(libcall) = *name {
+        RelocationTarget::LibCall(irlibcall_to_libcall(libcall))
+    } else {
+        panic!("unrecognized external name")
+    };
+    Relocation {
+        kind: irreloc_to_relocationkind(kind),
+        reloc_target,
+        offset,
+        addend,
+    }
+}
+
+fn mach_trap_to_trap(trap: &MachTrap) -> TrapInformation {
+    let &MachTrap { offset, code } = trap;
+    TrapInformation {
+        code_offset: offset,
+        trap_code: translate_ir_trapcode(code),
+    }
+}
+
+/// Translates the Cranelift IR TrapCode into generic Trap Code
+fn translate_ir_trapcode(trap: ir::TrapCode) -> TrapCode {
+    match trap {
+        ir::TrapCode::StackOverflow => TrapCode::StackOverflow,
+        ir::TrapCode::HeapOutOfBounds => TrapCode::HeapAccessOutOfBounds,
+        ir::TrapCode::HeapMisaligned => TrapCode::UnalignedAtomic,
+        ir::TrapCode::TableOutOfBounds => TrapCode::TableAccessOutOfBounds,
+        ir::TrapCode::IndirectCallToNull => TrapCode::IndirectCallToNull,
+        ir::TrapCode::BadSignature => TrapCode::BadSignature,
+        ir::TrapCode::IntegerOverflow => TrapCode::IntegerOverflow,
+        ir::TrapCode::IntegerDivisionByZero => TrapCode::IntegerDivisionByZero,
+        ir::TrapCode::BadConversionToInteger => TrapCode::BadConversionToInteger,
+        ir::TrapCode::UnreachableCodeReached => TrapCode::UnreachableCodeReached,
+        ir::TrapCode::Interrupt => unimplemented!("Interrupts not supported"),
+        ir::TrapCode::User(_user_code) => unimplemented!("User trap code not supported"),
+        // ir::TrapCode::Interrupt => TrapCode::Interrupt,
+        // ir::TrapCode::User(user_code) => TrapCode::User(user_code),
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/config.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/config.rs
new file mode 100644
index 0000000..0ce14a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/config.rs
@@ -0,0 +1,237 @@
+use crate::compiler::CraneliftCompiler;
+use cranelift_codegen::isa::{lookup, TargetIsa};
+use cranelift_codegen::settings::{self, Configurable};
+use cranelift_codegen::CodegenResult;
+use std::sync::Arc;
+use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
+use wasmer_types::{Architecture, CpuFeature, Target};
+
+// Runtime Environment
+
+/// Possible optimization levels for the Cranelift codegen backend.
+#[non_exhaustive]
+#[derive(Clone, Debug)]
+pub enum CraneliftOptLevel {
+    /// No optimizations performed, minimizes compilation time by disabling most
+    /// optimizations.
+    None,
+    /// Generates the fastest possible code, but may take longer.
+    Speed,
+    /// Similar to `speed`, but also performs transformations aimed at reducing
+    /// code size.
+    SpeedAndSize,
+}
+
+/// Global configuration options used to create an
+/// `wasmer_engine::Engine` and customize its behavior.
+///
+/// This structure exposes a builder-like interface and is primarily
+/// consumed by `wasmer_engine::Engine::new`.
+#[derive(Debug, Clone)]
+pub struct Cranelift {
+    enable_nan_canonicalization: bool,
+    enable_verifier: bool,
+    enable_pic: bool,
+    opt_level: CraneliftOptLevel,
+    /// The middleware chain.
+    pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+}
+
+impl Cranelift {
+    /// Creates a new configuration object with the default configuration
+    /// specified.
+    pub fn new() -> Self {
+        Self {
+            enable_nan_canonicalization: false,
+            enable_verifier: false,
+            opt_level: CraneliftOptLevel::Speed,
+            enable_pic: false,
+            middlewares: vec![],
+        }
+    }
+
+    /// Enable NaN canonicalization.
+    ///
+    /// NaN canonicalization is useful when trying to run WebAssembly
+    /// deterministically across different architectures.
+    pub fn canonicalize_nans(&mut self, enable: bool) -> &mut Self {
+        self.enable_nan_canonicalization = enable;
+        self
+    }
+
+    /// The optimization levels when optimizing the IR.
+    pub fn opt_level(&mut self, opt_level: CraneliftOptLevel) -> &mut Self {
+        self.opt_level = opt_level;
+        self
+    }
+
+    /// Generates the ISA for the provided target
+    pub fn isa(&self, target: &Target) -> CodegenResult<Box<dyn TargetIsa>> {
+        let mut builder =
+            lookup(target.triple().clone()).expect("construct Cranelift ISA for triple");
+        // Cpu Features
+        let cpu_features = target.cpu_features();
+        if target.triple().architecture == Architecture::X86_64
+            && !cpu_features.contains(CpuFeature::SSE2)
+        {
+            panic!("x86 support requires SSE2");
+        }
+        if cpu_features.contains(CpuFeature::SSE3) {
+            builder.enable("has_sse3").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::SSSE3) {
+            builder.enable("has_ssse3").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::SSE41) {
+            builder.enable("has_sse41").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::SSE42) {
+            builder.enable("has_sse42").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::POPCNT) {
+            builder.enable("has_popcnt").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::AVX) {
+            builder.enable("has_avx").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::BMI1) {
+            builder.enable("has_bmi1").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::BMI2) {
+            builder.enable("has_bmi2").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::AVX2) {
+            builder.enable("has_avx2").expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::AVX512DQ) {
+            builder
+                .enable("has_avx512dq")
+                .expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::AVX512VL) {
+            builder
+                .enable("has_avx512vl")
+                .expect("should be valid flag");
+        }
+        if cpu_features.contains(CpuFeature::LZCNT) {
+            builder.enable("has_lzcnt").expect("should be valid flag");
+        }
+
+        builder.finish(self.flags(target))
+    }
+
+    /// Generates the flags for the compiler
+    pub fn flags(&self, target: &Target) -> settings::Flags {
+        let is_riscv = matches!(target.triple().architecture, Architecture::Riscv64(_));
+        let mut flags = settings::builder();
+
+        // Enable probestack
+        flags
+            .enable("enable_probestack")
+            .expect("should be valid flag");
+
+        // Only inline probestack is supported on AArch64
+        if matches!(target.triple().architecture, Architecture::Aarch64(_)) {
+            flags
+                .set("probestack_strategy", "inline")
+                .expect("should be valid flag");
+        }
+
+        // There are two possible traps for division, and this way
+        // we get the proper one if code traps.
+        flags
+            .enable("avoid_div_traps")
+            .expect("should be valid flag");
+
+        if self.enable_pic {
+            flags.enable("is_pic").expect("should be a valid flag");
+        }
+
+        // We set up libcall trampolines in engine-universal.
+        // These trampolines are always reachable through short jumps.
+        flags
+            .enable("use_colocated_libcalls")
+            .expect("should be a valid flag");
+
+        // Invert cranelift's default-on verification to instead default off.
+        let enable_verifier = if self.enable_verifier {
+            "true"
+        } else {
+            "false"
+        };
+        flags
+            .set("enable_verifier", enable_verifier)
+            .expect("should be valid flag");
+        flags
+            .set("enable_safepoints", "true")
+            .expect("should be valid flag");
+
+        flags
+            .set(
+                "opt_level",
+                match self.opt_level {
+                    CraneliftOptLevel::None => "none",
+                    CraneliftOptLevel::Speed => "speed",
+                    CraneliftOptLevel::SpeedAndSize => "speed_and_size",
+                },
+            )
+            .expect("should be valid flag");
+
+        if is_riscv {
+            flags
+                .set("enable_simd", "false")
+                .expect("should be valid flag");
+        } else {
+            flags
+                .set("enable_simd", "true")
+                .expect("should be valid flag");
+        }
+
+        let enable_nan_canonicalization = if self.enable_nan_canonicalization {
+            "true"
+        } else {
+            "false"
+        };
+        flags
+            .set("enable_nan_canonicalization", enable_nan_canonicalization)
+            .expect("should be valid flag");
+
+        settings::Flags::new(flags)
+    }
+}
+
+impl CompilerConfig for Cranelift {
+    fn enable_pic(&mut self) {
+        self.enable_pic = true;
+    }
+
+    fn enable_verifier(&mut self) {
+        self.enable_verifier = true;
+    }
+
+    fn canonicalize_nans(&mut self, enable: bool) {
+        self.enable_nan_canonicalization = enable;
+    }
+
+    /// Transform it into the compiler
+    fn compiler(self: Box<Self>) -> Box<dyn Compiler> {
+        Box::new(CraneliftCompiler::new(*self))
+    }
+
+    /// Pushes a middleware onto the back of the middleware chain.
+    fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>) {
+        self.middlewares.push(middleware);
+    }
+}
+
+impl Default for Cranelift {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl From<Cranelift> for Engine {
+    fn from(config: Cranelift) -> Self {
+        EngineBuilder::new(config).engine()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/address_map.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/address_map.rs
new file mode 100644
index 0000000..c8900a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/address_map.rs
@@ -0,0 +1,33 @@
+//! Data structures to provide transformation of the source
+// addresses of a WebAssembly module into the native code.
+
+use cranelift_codegen::ir;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::LocalFunctionIndex;
+
+/// Value ranges for functions.
+pub type ValueLabelsRanges = PrimaryMap<LocalFunctionIndex, cranelift_codegen::ValueLabelsRanges>;
+
+/// Stack slots for functions.
+pub type StackSlots = PrimaryMap<LocalFunctionIndex, ir::StackSlots>;
+
+/// Memory definition offset in the VMContext structure.
+#[derive(Debug, Clone)]
+pub enum ModuleInfoMemoryOffset {
+    /// Not available.
+    None,
+    /// Offset to the defined memory.
+    Defined(u32),
+    /// Offset to the imported memory.
+    Imported(u32),
+}
+
+/// ModuleInfo `vmctx` related info.
+#[derive(Debug, Clone)]
+pub struct ModuleInfoVmctxInfo {
+    /// The memory definition offset in the VMContext structure.
+    pub memory_offset: ModuleInfoMemoryOffset,
+
+    /// The functions stack slots.
+    pub stack_slots: StackSlots,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/mod.rs
new file mode 100644
index 0000000..f369fb7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/debug/mod.rs
@@ -0,0 +1,3 @@
+mod address_map;
+
+pub use self::address_map::{ModuleInfoMemoryOffset, ModuleInfoVmctxInfo, ValueLabelsRanges};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/dwarf.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/dwarf.rs
new file mode 100644
index 0000000..8ab9b0b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/dwarf.rs
@@ -0,0 +1,104 @@
+use gimli::write::{Address, EndianVec, Result, Writer};
+use gimli::{RunTimeEndian, SectionId};
+use wasmer_types::entity::EntityRef;
+use wasmer_types::LocalFunctionIndex;
+use wasmer_types::{
+    CustomSection, CustomSectionProtection, Endianness, Relocation, RelocationKind,
+    RelocationTarget, SectionBody,
+};
+
+#[derive(Clone, Debug)]
+pub struct WriterRelocate {
+    pub relocs: Vec<Relocation>,
+    writer: EndianVec<RunTimeEndian>,
+}
+
+impl WriterRelocate {
+    pub const FUNCTION_SYMBOL: usize = 0;
+    pub fn new(endianness: Option<Endianness>) -> Self {
+        let endianness = match endianness {
+            Some(Endianness::Little) => RunTimeEndian::Little,
+            Some(Endianness::Big) => RunTimeEndian::Big,
+            // We autodetect it, based on the host
+            None => RunTimeEndian::default(),
+        };
+        Self {
+            relocs: Vec::new(),
+            writer: EndianVec::new(endianness),
+        }
+    }
+
+    pub fn into_section(mut self) -> CustomSection {
+        // GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
+        self.writer.write_u32(0).unwrap();
+        let data = self.writer.into_vec();
+        CustomSection {
+            protection: CustomSectionProtection::Read,
+            bytes: SectionBody::new_with_vec(data),
+            relocations: self.relocs,
+        }
+    }
+}
+
+impl Writer for WriterRelocate {
+    type Endian = RunTimeEndian;
+
+    fn endian(&self) -> Self::Endian {
+        self.writer.endian()
+    }
+
+    fn len(&self) -> usize {
+        self.writer.len()
+    }
+
+    fn write(&mut self, bytes: &[u8]) -> Result<()> {
+        self.writer.write(bytes)
+    }
+
+    fn write_at(&mut self, offset: usize, bytes: &[u8]) -> Result<()> {
+        self.writer.write_at(offset, bytes)
+    }
+
+    fn write_address(&mut self, address: Address, size: u8) -> Result<()> {
+        match address {
+            Address::Constant(val) => self.write_udata(val, size),
+            Address::Symbol { symbol, addend } => {
+                // Is a function relocation
+                if symbol == Self::FUNCTION_SYMBOL {
+                    // We use the addend to detect the function index
+                    let function_index = LocalFunctionIndex::new(addend as _);
+                    let reloc_target = RelocationTarget::LocalFunc(function_index);
+                    let offset = self.len() as u32;
+                    let kind = match size {
+                        8 => RelocationKind::Abs8,
+                        _ => unimplemented!("dwarf relocation size not yet supported: {}", size),
+                    };
+                    let addend = 0;
+                    self.relocs.push(Relocation {
+                        kind,
+                        reloc_target,
+                        offset,
+                        addend,
+                    });
+                    self.write_udata(addend as _, size)
+                } else {
+                    unreachable!("Symbol {} in DWARF not recognized", symbol);
+                }
+            }
+        }
+    }
+
+    fn write_offset(&mut self, _val: usize, _section: SectionId, _size: u8) -> Result<()> {
+        unimplemented!("write_offset not yet implemented");
+    }
+
+    fn write_offset_at(
+        &mut self,
+        _offset: usize,
+        _val: usize,
+        _section: SectionId,
+        _size: u8,
+    ) -> Result<()> {
+        unimplemented!("write_offset_at not yet implemented");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/func_environ.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/func_environ.rs
new file mode 100644
index 0000000..4a664b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/func_environ.rs
@@ -0,0 +1,1609 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use crate::translator::{
+    type_to_irtype, FuncEnvironment as BaseFuncEnvironment, GlobalVariable, TargetEnvironment,
+};
+use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir;
+use cranelift_codegen::ir::condcodes::*;
+use cranelift_codegen::ir::immediates::{Offset32, Uimm64};
+use cranelift_codegen::ir::types::*;
+use cranelift_codegen::ir::{AbiParam, ArgumentPurpose, Function, InstBuilder, Signature};
+use cranelift_codegen::isa::TargetFrontendConfig;
+use cranelift_frontend::FunctionBuilder;
+use std::convert::TryFrom;
+use wasmer_compiler::wasmparser::HeapType;
+use wasmer_types::entity::EntityRef;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::VMBuiltinFunctionIndex;
+use wasmer_types::VMOffsets;
+use wasmer_types::{
+    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, ModuleInfo,
+    SignatureIndex, TableIndex, Type as WasmerType,
+};
+use wasmer_types::{MemoryStyle, TableStyle};
+use wasmer_types::{WasmError, WasmResult};
+
+/// Compute an `ir::ExternalName` for a given wasm function index.
+pub fn get_function_name(func_index: FunctionIndex) -> ir::ExternalName {
+    ir::ExternalName::user(ir::UserExternalNameRef::from_u32(func_index.as_u32()))
+}
+
+/// The type of the `current_elements` field.
+pub fn type_of_vmtable_definition_current_elements(vmoffsets: &VMOffsets) -> ir::Type {
+    ir::Type::int(u16::from(vmoffsets.size_of_vmtable_definition_current_elements()) * 8).unwrap()
+}
+
+/// The `FuncEnvironment` implementation for use by the `ModuleEnvironment`.
+pub struct FuncEnvironment<'module_environment> {
+    /// Target-specified configuration.
+    target_config: TargetFrontendConfig,
+
+    /// The module-level environment which this function-level environment belongs to.
+    module: &'module_environment ModuleInfo,
+
+    /// A stack tracking the type of local variables.
+    type_stack: Vec<WasmerType>,
+
+    /// The module function signatures
+    signatures: &'module_environment PrimaryMap<SignatureIndex, ir::Signature>,
+
+    /// The Cranelift global holding the vmctx address.
+    vmctx: Option<ir::GlobalValue>,
+
+    /// The external function signature for implementing wasm's `memory.size`
+    /// for locally-defined 32-bit memories.
+    memory32_size_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.size`
+    /// for locally-defined tables.
+    table_size_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory.grow`
+    /// for locally-defined memories.
+    memory_grow_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.grow`
+    /// for locally-defined tables.
+    table_grow_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.copy`
+    /// (it's the same for both local and imported tables).
+    table_copy_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.init`.
+    table_init_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `elem.drop`.
+    elem_drop_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory.copy`
+    /// (it's the same for both local and imported memories).
+    memory_copy_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory.fill`
+    /// (it's the same for both local and imported memories).
+    memory_fill_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory.init`.
+    memory_init_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `data.drop`.
+    data_drop_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.get`.
+    table_get_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.set`.
+    table_set_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `func.ref`.
+    func_ref_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `table.fill`.
+    table_fill_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory32.atomic.wait32`.
+    memory32_atomic_wait32_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory32.atomic.wait64`.
+    memory32_atomic_wait64_sig: Option<ir::SigRef>,
+
+    /// The external function signature for implementing wasm's `memory32.atomic.notify`.
+    memory32_atomic_notify_sig: Option<ir::SigRef>,
+
+    /// Offsets to struct fields accessed by JIT code.
+    offsets: VMOffsets,
+
+    /// The memory styles
+    memory_styles: &'module_environment PrimaryMap<MemoryIndex, MemoryStyle>,
+
+    /// The table styles
+    table_styles: &'module_environment PrimaryMap<TableIndex, TableStyle>,
+}
+
+impl<'module_environment> FuncEnvironment<'module_environment> {
+    pub fn new(
+        target_config: TargetFrontendConfig,
+        module: &'module_environment ModuleInfo,
+        signatures: &'module_environment PrimaryMap<SignatureIndex, ir::Signature>,
+        memory_styles: &'module_environment PrimaryMap<MemoryIndex, MemoryStyle>,
+        table_styles: &'module_environment PrimaryMap<TableIndex, TableStyle>,
+    ) -> Self {
+        Self {
+            target_config,
+            module,
+            signatures,
+            type_stack: vec![],
+            vmctx: None,
+            memory32_size_sig: None,
+            table_size_sig: None,
+            memory_grow_sig: None,
+            table_grow_sig: None,
+            table_copy_sig: None,
+            table_init_sig: None,
+            elem_drop_sig: None,
+            memory_copy_sig: None,
+            memory_fill_sig: None,
+            memory_init_sig: None,
+            table_get_sig: None,
+            table_set_sig: None,
+            data_drop_sig: None,
+            func_ref_sig: None,
+            table_fill_sig: None,
+            memory32_atomic_wait32_sig: None,
+            memory32_atomic_wait64_sig: None,
+            memory32_atomic_notify_sig: None,
+            offsets: VMOffsets::new(target_config.pointer_bytes(), module),
+            memory_styles,
+            table_styles,
+        }
+    }
+
+    fn pointer_type(&self) -> ir::Type {
+        self.target_config.pointer_type()
+    }
+
+    fn vmctx(&mut self, func: &mut Function) -> ir::GlobalValue {
+        self.vmctx.unwrap_or_else(|| {
+            let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
+            self.vmctx = Some(vmctx);
+            vmctx
+        })
+    }
+
+    fn get_table_fill_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_fill_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // table index
+                    AbiParam::new(I32),
+                    // dst
+                    AbiParam::new(I32),
+                    // value
+                    AbiParam::new(R64),
+                    // len
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_fill_sig = Some(sig);
+        sig
+    }
+
+    fn get_table_fill_func(
+        &mut self,
+        func: &mut Function,
+        table_index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        (
+            self.get_table_fill_sig(func),
+            table_index.index(),
+            VMBuiltinFunctionIndex::get_table_fill_index(),
+        )
+    }
+
+    fn get_func_ref_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.func_ref_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(R64)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.func_ref_sig = Some(sig);
+        sig
+    }
+
+    fn get_func_ref_func(
+        &mut self,
+        func: &mut Function,
+        function_index: FunctionIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        (
+            self.get_func_ref_sig(func),
+            function_index.index(),
+            VMBuiltinFunctionIndex::get_func_ref_index(),
+        )
+    }
+
+    fn get_table_get_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_get_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(R64)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_get_sig = Some(sig);
+        sig
+    }
+
+    fn get_table_get_func(
+        &mut self,
+        func: &mut Function,
+        table_index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_table(table_index) {
+            (
+                self.get_table_get_sig(func),
+                table_index.index(),
+                VMBuiltinFunctionIndex::get_imported_table_get_index(),
+            )
+        } else {
+            (
+                self.get_table_get_sig(func),
+                self.module.local_table_index(table_index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_table_get_index(),
+            )
+        }
+    }
+
+    fn get_table_set_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_set_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                    AbiParam::new(I32),
+                    AbiParam::new(R64),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_set_sig = Some(sig);
+        sig
+    }
+
+    fn get_table_set_func(
+        &mut self,
+        func: &mut Function,
+        table_index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_table(table_index) {
+            (
+                self.get_table_set_sig(func),
+                table_index.index(),
+                VMBuiltinFunctionIndex::get_imported_table_set_index(),
+            )
+        } else {
+            (
+                self.get_table_set_sig(func),
+                self.module.local_table_index(table_index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_table_set_index(),
+            )
+        }
+    }
+
+    fn get_table_grow_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_grow_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // TODO: figure out what the representation of a Wasm value is
+                    AbiParam::new(R64),
+                    AbiParam::new(I32),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_grow_sig = Some(sig);
+        sig
+    }
+
+    /// Return the table.grow function signature to call for the given index, along with the
+    /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`.
+    fn get_table_grow_func(
+        &mut self,
+        func: &mut Function,
+        index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_table(index) {
+            (
+                self.get_table_grow_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_table_grow_index(),
+            )
+        } else {
+            (
+                self.get_table_grow_sig(func),
+                self.module.local_table_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_table_grow_index(),
+            )
+        }
+    }
+
+    fn get_memory_grow_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory_grow_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory_grow_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.grow function signature to call for the given index, along with the
+    /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`.
+    fn get_memory_grow_func(
+        &mut self,
+        func: &mut Function,
+        index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_memory(index) {
+            (
+                self.get_memory_grow_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory32_grow_index(),
+            )
+        } else {
+            (
+                self.get_memory_grow_sig(func),
+                self.module.local_memory_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_memory32_grow_index(),
+            )
+        }
+    }
+
+    fn get_table_size_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_size_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_size_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.size function signature to call for the given index, along with the
+    /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`.
+    fn get_table_size_func(
+        &mut self,
+        func: &mut Function,
+        index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_table(index) {
+            (
+                self.get_table_size_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_table_size_index(),
+            )
+        } else {
+            (
+                self.get_table_size_sig(func),
+                self.module.local_table_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_table_size_index(),
+            )
+        }
+    }
+
+    fn get_memory32_size_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory32_size_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory32_size_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.size function signature to call for the given index, along with the
+    /// translated index value to pass to it and its index in `VMBuiltinFunctionsArray`.
+    fn get_memory_size_func(
+        &mut self,
+        func: &mut Function,
+        index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_memory(index) {
+            (
+                self.get_memory32_size_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory32_size_index(),
+            )
+        } else {
+            (
+                self.get_memory32_size_sig(func),
+                self.module.local_memory_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_memory32_size_index(),
+            )
+        }
+    }
+
+    fn get_table_copy_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_copy_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Destination table index.
+                    AbiParam::new(I32),
+                    // Source table index.
+                    AbiParam::new(I32),
+                    // Index within destination table.
+                    AbiParam::new(I32),
+                    // Index within source table.
+                    AbiParam::new(I32),
+                    // Number of elements to copy.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_copy_sig = Some(sig);
+        sig
+    }
+
+    fn get_table_copy_func(
+        &mut self,
+        func: &mut Function,
+        dst_table_index: TableIndex,
+        src_table_index: TableIndex,
+    ) -> (ir::SigRef, usize, usize, VMBuiltinFunctionIndex) {
+        let sig = self.get_table_copy_sig(func);
+        (
+            sig,
+            dst_table_index.as_u32() as usize,
+            src_table_index.as_u32() as usize,
+            VMBuiltinFunctionIndex::get_table_copy_index(),
+        )
+    }
+
+    fn get_table_init_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.table_init_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Table index.
+                    AbiParam::new(I32),
+                    // Segment index.
+                    AbiParam::new(I32),
+                    // Destination index within table.
+                    AbiParam::new(I32),
+                    // Source index within segment.
+                    AbiParam::new(I32),
+                    // Number of elements to initialize.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.table_init_sig = Some(sig);
+        sig
+    }
+
+    fn get_table_init_func(
+        &mut self,
+        func: &mut Function,
+        table_index: TableIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        let sig = self.get_table_init_sig(func);
+        let table_index = table_index.as_u32() as usize;
+        (
+            sig,
+            table_index,
+            VMBuiltinFunctionIndex::get_table_init_index(),
+        )
+    }
+
+    fn get_elem_drop_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.elem_drop_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Element index.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.elem_drop_sig = Some(sig);
+        sig
+    }
+
+    fn get_elem_drop_func(&mut self, func: &mut Function) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.get_elem_drop_sig(func);
+        (sig, VMBuiltinFunctionIndex::get_elem_drop_index())
+    }
+
+    fn get_memory_copy_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory_copy_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory index.
+                    AbiParam::new(I32),
+                    // Destination address.
+                    AbiParam::new(I32),
+                    // Source address.
+                    AbiParam::new(I32),
+                    // Length.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory_copy_sig = Some(sig);
+        sig
+    }
+
+    fn get_memory_copy_func(
+        &mut self,
+        func: &mut Function,
+        memory_index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        let sig = self.get_memory_copy_sig(func);
+        if let Some(local_memory_index) = self.module.local_memory_index(memory_index) {
+            (
+                sig,
+                local_memory_index.index(),
+                VMBuiltinFunctionIndex::get_memory_copy_index(),
+            )
+        } else {
+            (
+                sig,
+                memory_index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory_copy_index(),
+            )
+        }
+    }
+
+    fn get_memory_fill_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory_fill_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory index.
+                    AbiParam::new(I32),
+                    // Destination address.
+                    AbiParam::new(I32),
+                    // Value.
+                    AbiParam::new(I32),
+                    // Length.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory_fill_sig = Some(sig);
+        sig
+    }
+
+    fn get_memory_fill_func(
+        &mut self,
+        func: &mut Function,
+        memory_index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        let sig = self.get_memory_fill_sig(func);
+        if let Some(local_memory_index) = self.module.local_memory_index(memory_index) {
+            (
+                sig,
+                local_memory_index.index(),
+                VMBuiltinFunctionIndex::get_memory_fill_index(),
+            )
+        } else {
+            (
+                sig,
+                memory_index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory_fill_index(),
+            )
+        }
+    }
+
+    fn get_memory_init_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory_init_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory index.
+                    AbiParam::new(I32),
+                    // Data index.
+                    AbiParam::new(I32),
+                    // Destination address.
+                    AbiParam::new(I32),
+                    // Source index within the data segment.
+                    AbiParam::new(I32),
+                    // Length.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory_init_sig = Some(sig);
+        sig
+    }
+
+    fn get_memory_init_func(
+        &mut self,
+        func: &mut Function,
+    ) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.get_memory_init_sig(func);
+        (sig, VMBuiltinFunctionIndex::get_memory_init_index())
+    }
+
+    fn get_data_drop_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.data_drop_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Data index.
+                    AbiParam::new(I32),
+                ],
+                returns: vec![],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.data_drop_sig = Some(sig);
+        sig
+    }
+
+    fn get_data_drop_func(&mut self, func: &mut Function) -> (ir::SigRef, VMBuiltinFunctionIndex) {
+        let sig = self.get_data_drop_sig(func);
+        (sig, VMBuiltinFunctionIndex::get_data_drop_index())
+    }
+
+    fn get_memory32_atomic_wait32_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory32_atomic_wait32_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory Index
+                    AbiParam::new(I32),
+                    // Dst
+                    AbiParam::new(I32),
+                    // Val
+                    AbiParam::new(I32),
+                    // Timeout
+                    AbiParam::new(I64),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory32_atomic_wait32_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.atomic.wait32 function signature to call for the given index,
+    /// along with the translated index value to pass to it
+    /// and its index in `VMBuiltinFunctionsArray`.
+    fn get_memory_atomic_wait32_func(
+        &mut self,
+        func: &mut Function,
+        index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_memory(index) {
+            (
+                self.get_memory32_atomic_wait32_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index(),
+            )
+        } else {
+            (
+                self.get_memory32_atomic_wait32_sig(func),
+                self.module.local_memory_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_memory_atomic_wait32_index(),
+            )
+        }
+    }
+
+    fn get_memory32_atomic_wait64_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory32_atomic_wait64_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory Index
+                    AbiParam::new(I32),
+                    // Dst
+                    AbiParam::new(I32),
+                    // Val
+                    AbiParam::new(I64),
+                    // Timeout
+                    AbiParam::new(I64),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory32_atomic_wait64_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.atomic.wait64 function signature to call for the given index,
+    /// along with the translated index value to pass to it
+    /// and its index in `VMBuiltinFunctionsArray`.
+    fn get_memory_atomic_wait64_func(
+        &mut self,
+        func: &mut Function,
+        index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_memory(index) {
+            (
+                self.get_memory32_atomic_wait64_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index(),
+            )
+        } else {
+            (
+                self.get_memory32_atomic_wait64_sig(func),
+                self.module.local_memory_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_memory_atomic_wait64_index(),
+            )
+        }
+    }
+
+    fn get_memory32_atomic_notify_sig(&mut self, func: &mut Function) -> ir::SigRef {
+        let sig = self.memory32_atomic_notify_sig.unwrap_or_else(|| {
+            func.import_signature(Signature {
+                params: vec![
+                    AbiParam::special(self.pointer_type(), ArgumentPurpose::VMContext),
+                    // Memory Index
+                    AbiParam::new(I32),
+                    // Dst
+                    AbiParam::new(I32),
+                    // Count
+                    AbiParam::new(I32),
+                ],
+                returns: vec![AbiParam::new(I32)],
+                call_conv: self.target_config.default_call_conv,
+            })
+        });
+        self.memory32_atomic_notify_sig = Some(sig);
+        sig
+    }
+
+    /// Return the memory.atomic.notify function signature to call for the given index,
+    /// along with the translated index value to pass to it
+    /// and its index in `VMBuiltinFunctionsArray`.
+    fn get_memory_atomic_notify_func(
+        &mut self,
+        func: &mut Function,
+        index: MemoryIndex,
+    ) -> (ir::SigRef, usize, VMBuiltinFunctionIndex) {
+        if self.module.is_imported_memory(index) {
+            (
+                self.get_memory32_atomic_notify_sig(func),
+                index.index(),
+                VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index(),
+            )
+        } else {
+            (
+                self.get_memory32_atomic_notify_sig(func),
+                self.module.local_memory_index(index).unwrap().index(),
+                VMBuiltinFunctionIndex::get_memory_atomic_notify_index(),
+            )
+        }
+    }
+
+    /// Translates load of builtin function and returns a pair of values `vmctx`
+    /// and address of the loaded function.
+    fn translate_load_builtin_function_address(
+        &mut self,
+        pos: &mut FuncCursor<'_>,
+        callee_func_idx: VMBuiltinFunctionIndex,
+    ) -> (ir::Value, ir::Value) {
+        // We use an indirect call so that we don't have to patch the code at runtime.
+        let pointer_type = self.pointer_type();
+        let vmctx = self.vmctx(pos.func);
+        let base = pos.ins().global_value(pointer_type, vmctx);
+
+        let mut mem_flags = ir::MemFlags::trusted();
+        mem_flags.set_readonly();
+
+        // Load the callee address.
+        let body_offset =
+            i32::try_from(self.offsets.vmctx_builtin_function(callee_func_idx)).unwrap();
+        let func_addr = pos.ins().load(pointer_type, mem_flags, base, body_offset);
+
+        (base, func_addr)
+    }
+}
+
+impl<'module_environment> TargetEnvironment for FuncEnvironment<'module_environment> {
+    fn target_config(&self) -> TargetFrontendConfig {
+        self.target_config
+    }
+}
+
+impl<'module_environment> BaseFuncEnvironment for FuncEnvironment<'module_environment> {
+    fn is_wasm_parameter(&self, _signature: &ir::Signature, index: usize) -> bool {
+        // The first parameter is the vmctx. The rest are the wasm parameters.
+        index >= 1
+    }
+
+    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table> {
+        let pointer_type = self.pointer_type();
+
+        let (ptr, base_offset, current_elements_offset) = {
+            let vmctx = self.vmctx(func);
+            if let Some(def_index) = self.module.local_table_index(index) {
+                let base_offset =
+                    i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap();
+                let current_elements_offset = i32::try_from(
+                    self.offsets
+                        .vmctx_vmtable_definition_current_elements(def_index),
+                )
+                .unwrap();
+                (vmctx, base_offset, current_elements_offset)
+            } else {
+                let from_offset = self.offsets.vmctx_vmtable_import_definition(index);
+                let table = func.create_global_value(ir::GlobalValueData::Load {
+                    base: vmctx,
+                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
+                    global_type: pointer_type,
+                    readonly: true,
+                });
+                let base_offset = i32::from(self.offsets.vmtable_definition_base());
+                let current_elements_offset =
+                    i32::from(self.offsets.vmtable_definition_current_elements());
+                (table, base_offset, current_elements_offset)
+            }
+        };
+
+        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
+            base: ptr,
+            offset: Offset32::new(base_offset),
+            global_type: pointer_type,
+            readonly: false,
+        });
+        let bound_gv = func.create_global_value(ir::GlobalValueData::Load {
+            base: ptr,
+            offset: Offset32::new(current_elements_offset),
+            global_type: type_of_vmtable_definition_current_elements(&self.offsets),
+            readonly: false,
+        });
+
+        let element_size = match self.table_styles[index] {
+            TableStyle::CallerChecksSignature => u64::from(self.offsets.size_of_vm_funcref()),
+        };
+
+        Ok(func.create_table(ir::TableData {
+            base_gv,
+            min_size: Uimm64::new(0),
+            bound_gv,
+            element_size: Uimm64::new(element_size),
+            index_type: I32,
+        }))
+    }
+
+    fn translate_table_grow(
+        &mut self,
+        mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        table_index: TableIndex,
+        _table: ir::Table,
+        delta: ir::Value,
+        init_value: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = self.get_table_grow_func(pos.func, table_index);
+        let table_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, init_value, delta, table_index],
+        );
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_table_get(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        _table: ir::Table,
+        index: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let mut pos = builder.cursor();
+
+        let (func_sig, table_index_arg, func_idx) = self.get_table_get_func(pos.func, table_index);
+        let table_index = pos.ins().iconst(I32, table_index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos
+            .ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, table_index, index]);
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_table_set(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        _table: ir::Table,
+        value: ir::Value,
+        index: ir::Value,
+    ) -> WasmResult<()> {
+        let mut pos = builder.cursor();
+
+        let (func_sig, table_index_arg, func_idx) = self.get_table_set_func(pos.func, table_index);
+        let table_index = pos.ins().iconst(I32, table_index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        pos.ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, table_index, index, value]);
+        Ok(())
+    }
+
+    fn translate_table_fill(
+        &mut self,
+        mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        table_index: TableIndex,
+        dst: ir::Value,
+        val: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, table_index_arg, func_idx) = self.get_table_fill_func(pos.func, table_index);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        let table_index_arg = pos.ins().iconst(I32, table_index_arg as i64);
+        pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, table_index_arg, dst, val, len],
+        );
+
+        Ok(())
+    }
+
+    fn translate_ref_null(
+        &mut self,
+        mut pos: cranelift_codegen::cursor::FuncCursor,
+        ty: HeapType,
+    ) -> WasmResult<ir::Value> {
+        Ok(match ty {
+            HeapType::Func => pos.ins().null(self.reference_type()),
+            HeapType::Extern => pos.ins().null(self.reference_type()),
+            _ => {
+                return Err(WasmError::Unsupported(
+                    "`ref.null T` that is not a `funcref` or an `externref`".into(),
+                ));
+            }
+        })
+    }
+
+    fn translate_ref_is_null(
+        &mut self,
+        mut pos: cranelift_codegen::cursor::FuncCursor,
+        value: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let bool_is_null = match pos.func.dfg.value_type(value) {
+            // `externref`
+            ty if ty.is_ref() => pos.ins().is_null(value),
+            // `funcref`
+            ty if ty == self.pointer_type() => {
+                pos.ins()
+                    .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::Equal, value, 0)
+            }
+            _ => unreachable!(),
+        };
+
+        Ok(pos.ins().uextend(ir::types::I32, bool_is_null))
+    }
+
+    fn translate_ref_func(
+        &mut self,
+        mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        func_index: FunctionIndex,
+    ) -> WasmResult<ir::Value> {
+        // TODO: optimize this by storing a pointer to local func_index funcref metadata
+        // so that local funcref is just (*global + offset) instead of a function call
+        //
+        // Actually we can do the above for both local and imported functions because
+        // all of those are known statically.
+        //
+        // prototyping with a function call though
+
+        let (func_sig, func_index_arg, func_idx) = self.get_func_ref_func(pos.func, func_index);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        let func_index_arg = pos.ins().iconst(I32, func_index_arg as i64);
+        let call_inst = pos
+            .ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, func_index_arg]);
+
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_custom_global_get(
+        &mut self,
+        mut _pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        _index: GlobalIndex,
+    ) -> WasmResult<ir::Value> {
+        unreachable!("we don't make any custom globals")
+    }
+
+    fn translate_custom_global_set(
+        &mut self,
+        mut _pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        _index: GlobalIndex,
+        _value: ir::Value,
+    ) -> WasmResult<()> {
+        unreachable!("we don't make any custom globals")
+    }
+
+    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<ir::Heap> {
+        let pointer_type = self.pointer_type();
+
+        let (ptr, base_offset, current_length_offset) = {
+            let vmctx = self.vmctx(func);
+            if let Some(def_index) = self.module.local_memory_index(index) {
+                let base_offset =
+                    i32::try_from(self.offsets.vmctx_vmmemory_definition_base(def_index)).unwrap();
+                let current_length_offset = i32::try_from(
+                    self.offsets
+                        .vmctx_vmmemory_definition_current_length(def_index),
+                )
+                .unwrap();
+                (vmctx, base_offset, current_length_offset)
+            } else {
+                let from_offset = self.offsets.vmctx_vmmemory_import_definition(index);
+                let memory = func.create_global_value(ir::GlobalValueData::Load {
+                    base: vmctx,
+                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
+                    global_type: pointer_type,
+                    readonly: true,
+                });
+                let base_offset = i32::from(self.offsets.vmmemory_definition_base());
+                let current_length_offset =
+                    i32::from(self.offsets.vmmemory_definition_current_length());
+                (memory, base_offset, current_length_offset)
+            }
+        };
+
+        // If we have a declared maximum, we can make this a "static" heap, which is
+        // allocated up front and never moved.
+        let (offset_guard_size, heap_style, readonly_base) = match self.memory_styles[index] {
+            MemoryStyle::Dynamic { offset_guard_size } => {
+                let heap_bound = func.create_global_value(ir::GlobalValueData::Load {
+                    base: ptr,
+                    offset: Offset32::new(current_length_offset),
+                    global_type: pointer_type,
+                    readonly: false,
+                });
+                (
+                    Uimm64::new(offset_guard_size),
+                    ir::HeapStyle::Dynamic {
+                        bound_gv: heap_bound,
+                    },
+                    false,
+                )
+            }
+            MemoryStyle::Static {
+                bound,
+                offset_guard_size,
+            } => (
+                Uimm64::new(offset_guard_size),
+                ir::HeapStyle::Static {
+                    bound: Uimm64::new(bound.bytes().0 as u64),
+                },
+                true,
+            ),
+        };
+
+        let heap_base = func.create_global_value(ir::GlobalValueData::Load {
+            base: ptr,
+            offset: Offset32::new(base_offset),
+            global_type: pointer_type,
+            readonly: readonly_base,
+        });
+        Ok(func.create_heap(ir::HeapData {
+            base: heap_base,
+            min_size: 0.into(),
+            offset_guard_size,
+            style: heap_style,
+            index_type: I32,
+        }))
+    }
+
+    fn make_global(
+        &mut self,
+        func: &mut ir::Function,
+        index: GlobalIndex,
+    ) -> WasmResult<GlobalVariable> {
+        let pointer_type = self.pointer_type();
+
+        let (ptr, offset) = {
+            let vmctx = self.vmctx(func);
+            let from_offset = if let Some(def_index) = self.module.local_global_index(index) {
+                self.offsets.vmctx_vmglobal_definition(def_index)
+            } else {
+                self.offsets.vmctx_vmglobal_import_definition(index)
+            };
+            let global = func.create_global_value(ir::GlobalValueData::Load {
+                base: vmctx,
+                offset: Offset32::new(i32::try_from(from_offset).unwrap()),
+                global_type: pointer_type,
+                readonly: true,
+            });
+
+            (global, 0)
+        };
+
+        Ok(GlobalVariable::Memory {
+            gv: ptr,
+            offset: offset.into(),
+            ty: type_to_irtype(self.module.globals[index].ty, self.target_config())?,
+        })
+    }
+
+    fn make_indirect_sig(
+        &mut self,
+        func: &mut ir::Function,
+        index: SignatureIndex,
+    ) -> WasmResult<ir::SigRef> {
+        Ok(func.import_signature(self.signatures[index].clone()))
+    }
+
+    fn make_direct_func(
+        &mut self,
+        func: &mut ir::Function,
+        index: FunctionIndex,
+    ) -> WasmResult<ir::FuncRef> {
+        let sigidx = self.module.functions[index];
+        let signature = func.import_signature(self.signatures[sigidx].clone());
+        let name = get_function_name(index);
+        Ok(func.import_function(ir::ExtFuncData {
+            name,
+            signature,
+            colocated: true,
+        }))
+    }
+
+    fn translate_call_indirect(
+        &mut self,
+        mut pos: FuncCursor<'_>,
+        table_index: TableIndex,
+        table: ir::Table,
+        sig_index: SignatureIndex,
+        sig_ref: ir::SigRef,
+        callee: ir::Value,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst> {
+        let pointer_type = self.pointer_type();
+
+        let table_entry_addr = pos.ins().table_addr(pointer_type, table, callee, 0);
+
+        // Dereference table_entry_addr to get the function address.
+        let mem_flags = ir::MemFlags::trusted();
+        let table_entry_addr = pos.ins().load(
+            pointer_type,
+            mem_flags,
+            table_entry_addr,
+            i32::from(self.offsets.vm_funcref_anyfunc_ptr()),
+        );
+
+        // check if the funcref is null
+        pos.ins()
+            .trapz(table_entry_addr, ir::TrapCode::IndirectCallToNull);
+
+        let func_addr = pos.ins().load(
+            pointer_type,
+            mem_flags,
+            table_entry_addr,
+            i32::from(self.offsets.vmcaller_checked_anyfunc_func_ptr()),
+        );
+
+        // If necessary, check the signature.
+        match self.table_styles[table_index] {
+            TableStyle::CallerChecksSignature => {
+                let sig_id_size = self.offsets.size_of_vmshared_signature_index();
+                let sig_id_type = ir::Type::int(u16::from(sig_id_size) * 8).unwrap();
+                let vmctx = self.vmctx(pos.func);
+                let base = pos.ins().global_value(pointer_type, vmctx);
+                let offset =
+                    i32::try_from(self.offsets.vmctx_vmshared_signature_id(sig_index)).unwrap();
+
+                // Load the caller ID.
+                let mut mem_flags = ir::MemFlags::trusted();
+                mem_flags.set_readonly();
+                let caller_sig_id = pos.ins().load(sig_id_type, mem_flags, base, offset);
+
+                // Load the callee ID.
+                let mem_flags = ir::MemFlags::trusted();
+                let callee_sig_id = pos.ins().load(
+                    sig_id_type,
+                    mem_flags,
+                    table_entry_addr,
+                    i32::from(self.offsets.vmcaller_checked_anyfunc_type_index()),
+                );
+
+                // Check that they match.
+                let cmp = pos.ins().icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
+                pos.ins().trapz(cmp, ir::TrapCode::BadSignature);
+            }
+        }
+
+        let mut real_call_args = Vec::with_capacity(call_args.len() + 2);
+
+        // First append the callee vmctx address.
+        let vmctx = pos.ins().load(
+            pointer_type,
+            mem_flags,
+            table_entry_addr,
+            i32::from(self.offsets.vmcaller_checked_anyfunc_vmctx()),
+        );
+        real_call_args.push(vmctx);
+
+        // Then append the regular call arguments.
+        real_call_args.extend_from_slice(call_args);
+
+        Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args))
+    }
+
+    fn translate_call(
+        &mut self,
+        mut pos: FuncCursor<'_>,
+        callee_index: FunctionIndex,
+        callee: ir::FuncRef,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst> {
+        let mut real_call_args = Vec::with_capacity(call_args.len() + 2);
+
+        // Handle direct calls to locally-defined functions.
+        if !self.module.is_imported_function(callee_index) {
+            // Let's get the caller vmctx
+            let caller_vmctx = pos.func.special_param(ArgumentPurpose::VMContext).unwrap();
+            // First append the callee vmctx address, which is the same as the caller vmctx in
+            // this case.
+            real_call_args.push(caller_vmctx);
+
+            // Then append the regular call arguments.
+            real_call_args.extend_from_slice(call_args);
+
+            return Ok(pos.ins().call(callee, &real_call_args));
+        }
+
+        // Handle direct calls to imported functions. We use an indirect call
+        // so that we don't have to patch the code at runtime.
+        let pointer_type = self.pointer_type();
+        let sig_ref = pos.func.dfg.ext_funcs[callee].signature;
+        let vmctx = self.vmctx(pos.func);
+        let base = pos.ins().global_value(pointer_type, vmctx);
+
+        let mem_flags = ir::MemFlags::trusted();
+
+        // Load the callee address.
+        let body_offset =
+            i32::try_from(self.offsets.vmctx_vmfunction_import_body(callee_index)).unwrap();
+        let func_addr = pos.ins().load(pointer_type, mem_flags, base, body_offset);
+
+        // First append the callee vmctx address.
+        let vmctx_offset =
+            i32::try_from(self.offsets.vmctx_vmfunction_import_vmctx(callee_index)).unwrap();
+        let vmctx = pos.ins().load(pointer_type, mem_flags, base, vmctx_offset);
+        real_call_args.push(vmctx);
+
+        // Then append the regular call arguments.
+        real_call_args.extend_from_slice(call_args);
+
+        Ok(pos.ins().call_indirect(sig_ref, func_addr, &real_call_args))
+    }
+
+    fn translate_memory_grow(
+        &mut self,
+        mut pos: FuncCursor<'_>,
+        index: MemoryIndex,
+        _heap: ir::Heap,
+        val: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = self.get_memory_grow_func(pos.func, index);
+        let memory_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos
+            .ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, val, memory_index]);
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_memory_size(
+        &mut self,
+        mut pos: FuncCursor<'_>,
+        index: MemoryIndex,
+        _heap: ir::Heap,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = self.get_memory_size_func(pos.func, index);
+        let memory_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos
+            .ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, memory_index]);
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_memory_copy(
+        &mut self,
+        mut pos: FuncCursor,
+        src_index: MemoryIndex,
+        _src_heap: ir::Heap,
+        _dst_index: MemoryIndex,
+        _dst_heap: ir::Heap,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, src_index, func_idx) = self.get_memory_copy_func(pos.func, src_index);
+
+        let src_index_arg = pos.ins().iconst(I32, src_index as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, src_index_arg, dst, src, len]);
+
+        Ok(())
+    }
+
+    fn translate_memory_fill(
+        &mut self,
+        mut pos: FuncCursor,
+        memory_index: MemoryIndex,
+        _heap: ir::Heap,
+        dst: ir::Value,
+        val: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, memory_index, func_idx) = self.get_memory_fill_func(pos.func, memory_index);
+
+        let memory_index_arg = pos.ins().iconst(I32, memory_index as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, memory_index_arg, dst, val, len],
+        );
+
+        Ok(())
+    }
+
+    fn translate_memory_init(
+        &mut self,
+        mut pos: FuncCursor,
+        memory_index: MemoryIndex,
+        _heap: ir::Heap,
+        seg_index: u32,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, func_idx) = self.get_memory_init_func(pos.func);
+
+        let memory_index_arg = pos.ins().iconst(I32, memory_index.index() as i64);
+        let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, memory_index_arg, seg_index_arg, dst, src, len],
+        );
+
+        Ok(())
+    }
+
+    fn translate_data_drop(&mut self, mut pos: FuncCursor, seg_index: u32) -> WasmResult<()> {
+        let (func_sig, func_idx) = self.get_data_drop_func(pos.func);
+        let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        pos.ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, seg_index_arg]);
+        Ok(())
+    }
+
+    fn translate_table_size(
+        &mut self,
+        mut pos: FuncCursor,
+        table_index: TableIndex,
+        _table: ir::Table,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = self.get_table_size_func(pos.func, table_index);
+        let table_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos
+            .ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, table_index]);
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_table_copy(
+        &mut self,
+        mut pos: FuncCursor,
+        dst_table_index: TableIndex,
+        _dst_table: ir::Table,
+        src_table_index: TableIndex,
+        _src_table: ir::Table,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, dst_table_index_arg, src_table_index_arg, func_idx) =
+            self.get_table_copy_func(pos.func, dst_table_index, src_table_index);
+
+        let dst_table_index_arg = pos.ins().iconst(I32, dst_table_index_arg as i64);
+        let src_table_index_arg = pos.ins().iconst(I32, src_table_index_arg as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[
+                vmctx,
+                dst_table_index_arg,
+                src_table_index_arg,
+                dst,
+                src,
+                len,
+            ],
+        );
+
+        Ok(())
+    }
+
+    fn translate_table_init(
+        &mut self,
+        mut pos: FuncCursor,
+        seg_index: u32,
+        table_index: TableIndex,
+        _table: ir::Table,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()> {
+        let (func_sig, table_index_arg, func_idx) = self.get_table_init_func(pos.func, table_index);
+
+        let table_index_arg = pos.ins().iconst(I32, table_index_arg as i64);
+        let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, table_index_arg, seg_index_arg, dst, src, len],
+        );
+
+        Ok(())
+    }
+
+    fn translate_elem_drop(&mut self, mut pos: FuncCursor, elem_index: u32) -> WasmResult<()> {
+        let (func_sig, func_idx) = self.get_elem_drop_func(pos.func);
+
+        let elem_index_arg = pos.ins().iconst(I32, elem_index as i64);
+
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+
+        pos.ins()
+            .call_indirect(func_sig, func_addr, &[vmctx, elem_index_arg]);
+
+        Ok(())
+    }
+
+    fn translate_atomic_wait(
+        &mut self,
+        mut pos: FuncCursor,
+        index: MemoryIndex,
+        _heap: ir::Heap,
+        addr: ir::Value,
+        expected: ir::Value,
+        timeout: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = if pos.func.dfg.value_type(expected) == I64 {
+            self.get_memory_atomic_wait64_func(pos.func, index)
+        } else {
+            self.get_memory_atomic_wait32_func(pos.func, index)
+        };
+        let memory_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst = pos.ins().call_indirect(
+            func_sig,
+            func_addr,
+            &[vmctx, memory_index, addr, expected, timeout],
+        );
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn translate_atomic_notify(
+        &mut self,
+        mut pos: FuncCursor,
+        index: MemoryIndex,
+        _heap: ir::Heap,
+        addr: ir::Value,
+        count: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let (func_sig, index_arg, func_idx) = self.get_memory_atomic_notify_func(pos.func, index);
+        let memory_index = pos.ins().iconst(I32, index_arg as i64);
+        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let call_inst =
+            pos.ins()
+                .call_indirect(func_sig, func_addr, &[vmctx, memory_index, addr, count]);
+        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+    }
+
+    fn get_global_type(&self, global_index: GlobalIndex) -> Option<WasmerType> {
+        Some(self.module.globals.get(global_index)?.ty)
+    }
+
+    fn push_local_decl_on_stack(&mut self, ty: WasmerType) {
+        self.type_stack.push(ty);
+    }
+
+    fn push_params_on_stack(&mut self, function_index: LocalFunctionIndex) {
+        let func_index = self.module.func_index(function_index);
+        let sig_idx = self.module.functions[func_index];
+        let signature = &self.module.signatures[sig_idx];
+        for param in signature.params() {
+            self.type_stack.push(*param);
+        }
+    }
+
+    fn get_local_type(&self, local_index: u32) -> Option<WasmerType> {
+        self.type_stack.get(local_index as usize).cloned()
+    }
+
+    fn get_local_types(&self) -> &[WasmerType] {
+        &self.type_stack
+    }
+
+    fn get_function_type(&self, function_index: FunctionIndex) -> Option<&FunctionType> {
+        let sig_idx = self.module.functions.get(function_index)?;
+        Some(&self.module.signatures[*sig_idx])
+    }
+
+    fn get_function_sig(&self, sig_index: SignatureIndex) -> Option<&FunctionType> {
+        self.module.signatures.get(sig_index)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/lib.rs
new file mode 100644
index 0000000..042537e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/lib.rs
@@ -0,0 +1,57 @@
+//! A WebAssembly `Compiler` implementation using Cranelift.
+//!
+//! Cranelift is a fast IR generator created by Mozilla for usage in
+//! Firefox as a next JS compiler generator.
+//!
+//! Compared to LLVM, Cranelift is a bit faster and made entirely in Rust.
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![allow(clippy::new_without_default, clippy::new_without_default)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(not(feature = "std"))]
+#[macro_use]
+extern crate alloc as std;
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+#[cfg(not(feature = "std"))]
+use hashbrown::{
+    hash_map,
+    hash_map::Entry::{Occupied, Vacant},
+    HashMap,
+};
+#[cfg(feature = "std")]
+use std::collections::{
+    hash_map,
+    hash_map::Entry::{Occupied, Vacant},
+    HashMap,
+};
+
+mod address_map;
+mod compiler;
+mod config;
+mod debug;
+#[cfg(feature = "unwind")]
+mod dwarf;
+mod func_environ;
+mod trampoline;
+mod translator;
+
+pub use crate::compiler::CraneliftCompiler;
+pub use crate::config::{Cranelift, CraneliftOptLevel};
+pub use crate::debug::{ModuleInfoMemoryOffset, ModuleInfoVmctxInfo, ValueLabelsRanges};
+pub use crate::trampoline::make_trampoline_function_call;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/dynamic_function.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
new file mode 100644
index 0000000..f7f84ed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/dynamic_function.rs
@@ -0,0 +1,117 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! A trampoline generator for calling dynamic host functions from Wasm.
+
+use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
+use cranelift_codegen::ir;
+use cranelift_codegen::ir::{
+    Function, InstBuilder, MemFlags, StackSlotData, StackSlotKind, UserFuncName,
+};
+use cranelift_codegen::isa::TargetIsa;
+use cranelift_codegen::Context;
+use std::cmp;
+use std::mem;
+
+use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
+use wasmer_types::{CompileError, FunctionBody, FunctionType, VMOffsets};
+
+/// Create a trampoline for invoking a WebAssembly function.
+pub fn make_trampoline_dynamic_function(
+    isa: &dyn TargetIsa,
+    offsets: &VMOffsets,
+    fn_builder_ctx: &mut FunctionBuilderContext,
+    func_type: &FunctionType,
+) -> Result<FunctionBody, CompileError> {
+    let pointer_type = isa.pointer_type();
+    let frontend_config = isa.frontend_config();
+    let signature = signature_to_cranelift_ir(func_type, frontend_config);
+    let mut stub_sig = ir::Signature::new(frontend_config.default_call_conv);
+    // Add the caller `vmctx` parameter.
+    stub_sig.params.push(ir::AbiParam::special(
+        pointer_type,
+        ir::ArgumentPurpose::VMContext,
+    ));
+
+    // Add the `values_vec` parameter.
+    stub_sig.params.push(ir::AbiParam::new(pointer_type));
+
+    // Compute the size of the values vector. The vmctx and caller vmctx are passed separately.
+    let value_size = mem::size_of::<u128>();
+    let values_vec_len =
+        (value_size * cmp::max(signature.params.len() - 1, signature.returns.len())) as u32;
+
+    let mut context = Context::new();
+    context.func = Function::with_name_signature(UserFuncName::user(0, 0), signature.clone());
+
+    let ss = context.func.create_sized_stack_slot(StackSlotData::new(
+        StackSlotKind::ExplicitSlot,
+        values_vec_len,
+    ));
+
+    {
+        let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx);
+        let block0 = builder.create_block();
+
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+        builder.seal_block(block0);
+
+        let values_vec_ptr_val = builder.ins().stack_addr(pointer_type, ss, 0);
+        let mflags = MemFlags::trusted();
+        // We only get the non-vmctx arguments
+        for i in 1..signature.params.len() {
+            let val = builder.func.dfg.block_params(block0)[i];
+            builder.ins().store(
+                mflags,
+                val,
+                values_vec_ptr_val,
+                ((i - 1) * value_size) as i32,
+            );
+        }
+
+        let block_params = builder.func.dfg.block_params(block0);
+        let vmctx_ptr_val = block_params[0];
+        let callee_args = vec![vmctx_ptr_val, values_vec_ptr_val];
+
+        let new_sig = builder.import_signature(stub_sig);
+
+        let mem_flags = ir::MemFlags::trusted();
+        let callee_value = builder.ins().load(
+            pointer_type,
+            mem_flags,
+            vmctx_ptr_val,
+            offsets.vmdynamicfunction_import_context_address() as i32,
+        );
+
+        builder
+            .ins()
+            .call_indirect(new_sig, callee_value, &callee_args);
+
+        let mflags = MemFlags::trusted();
+        let mut results = Vec::new();
+        for (i, r) in signature.returns.iter().enumerate() {
+            let load = builder.ins().load(
+                r.value_type,
+                mflags,
+                values_vec_ptr_val,
+                (i * value_size) as i32,
+            );
+            results.push(load);
+        }
+        builder.ins().return_(&results);
+        builder.finalize()
+    }
+
+    let mut code_buf = Vec::new();
+    context
+        .compile_and_emit(isa, &mut code_buf)
+        .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+
+    let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
+
+    Ok(FunctionBody {
+        body: code_buf,
+        unwind_info,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/function_call.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/function_call.rs
new file mode 100644
index 0000000..8d6741d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/function_call.rs
@@ -0,0 +1,115 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! A trampoline generator for calling Wasm functions easily.
+//!
+//! That way, you can start calling Wasm functions doing things like:
+//! ```ignore
+//! let my_func = instance.exports.get("func");
+//! my_func.call([1, 2])
+//! ```
+use crate::translator::{compiled_function_unwind_info, signature_to_cranelift_ir};
+use cranelift_codegen::ir;
+use cranelift_codegen::ir::InstBuilder;
+use cranelift_codegen::isa::TargetIsa;
+use cranelift_codegen::Context;
+use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
+use std::mem;
+use wasmer_types::{CompileError, FunctionBody, FunctionType};
+
+/// Create a trampoline for invoking a WebAssembly function.
+pub fn make_trampoline_function_call(
+    isa: &dyn TargetIsa,
+    fn_builder_ctx: &mut FunctionBuilderContext,
+    func_type: &FunctionType,
+) -> Result<FunctionBody, CompileError> {
+    let pointer_type = isa.pointer_type();
+    let frontend_config = isa.frontend_config();
+    let signature = signature_to_cranelift_ir(func_type, frontend_config);
+    let mut wrapper_sig = ir::Signature::new(frontend_config.default_call_conv);
+
+    // Add the callee `vmctx` parameter.
+    wrapper_sig.params.push(ir::AbiParam::special(
+        pointer_type,
+        ir::ArgumentPurpose::VMContext,
+    ));
+
+    // Add the `callee_address` parameter.
+    wrapper_sig.params.push(ir::AbiParam::new(pointer_type));
+
+    // Add the `values_vec` parameter.
+    wrapper_sig.params.push(ir::AbiParam::new(pointer_type));
+
+    let mut context = Context::new();
+    context.func = ir::Function::with_name_signature(ir::UserFuncName::user(0, 0), wrapper_sig);
+
+    let value_size = mem::size_of::<u128>();
+    {
+        let mut builder = FunctionBuilder::new(&mut context.func, fn_builder_ctx);
+        let block0 = builder.create_block();
+
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+        builder.seal_block(block0);
+
+        let (vmctx_ptr_val, callee_value, values_vec_ptr_val) = {
+            let params = builder.func.dfg.block_params(block0);
+            (params[0], params[1], params[2])
+        };
+
+        // Load the argument values out of `values_vec`.
+        let mflags = ir::MemFlags::trusted();
+        let callee_args = signature
+            .params
+            .iter()
+            .enumerate()
+            .map(|(i, r)| {
+                match i {
+                    0 => vmctx_ptr_val,
+                    _ =>
+                    // i - 1 because vmctx is not passed through `values_vec`.
+                    {
+                        builder.ins().load(
+                            r.value_type,
+                            mflags,
+                            values_vec_ptr_val,
+                            ((i - 1) * value_size) as i32,
+                        )
+                    }
+                }
+            })
+            .collect::<Vec<_>>();
+
+        let new_sig = builder.import_signature(signature);
+
+        let call = builder
+            .ins()
+            .call_indirect(new_sig, callee_value, &callee_args);
+
+        let results = builder.func.dfg.inst_results(call).to_vec();
+
+        // Store the return values into `values_vec`.
+        let mflags = ir::MemFlags::trusted();
+        for (i, r) in results.iter().enumerate() {
+            builder
+                .ins()
+                .store(mflags, *r, values_vec_ptr_val, (i * value_size) as i32);
+        }
+
+        builder.ins().return_(&[]);
+        builder.finalize()
+    }
+
+    let mut code_buf = Vec::new();
+
+    context
+        .compile_and_emit(isa, &mut code_buf)
+        .map_err(|error| CompileError::Codegen(error.inner.to_string()))?;
+
+    let unwind_info = compiled_function_unwind_info(isa, &context)?.maybe_into_to_windows_unwind();
+
+    Ok(FunctionBody {
+        body: code_buf,
+        unwind_info,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/mod.rs
new file mode 100644
index 0000000..3c8c402
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/trampoline/mod.rs
@@ -0,0 +1,9 @@
+#![allow(missing_docs)]
+
+mod dynamic_function;
+mod function_call;
+
+pub use self::dynamic_function::make_trampoline_dynamic_function;
+pub use self::function_call::make_trampoline_function_call;
+
+pub use cranelift_frontend::FunctionBuilderContext;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/code_translator.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/code_translator.rs
new file mode 100644
index 0000000..1de3e35
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/code_translator.rs
@@ -0,0 +1,3108 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! This module contains the bulk of the interesting code performing the translation between
+//! WebAssembly bytecode and Cranelift IR.
+//!
+//! The translation is done in one pass, opcode by opcode. Two main data structures are used during
+//! code translations: the value stack and the control stack. The value stack mimics the execution
+//! of the WebAssembly stack machine: each instruction result is pushed onto the stack and
+//! instruction arguments are popped off the stack. Similarly, when encountering a control flow
+//! block, it is pushed onto the control stack and popped off when encountering the corresponding
+//! `End`.
+//!
+//! Another data structure, the translation state, records information concerning unreachable code
+//! status and about if inserting a return at the end of the function is necessary.
+//!
+//! Some of the WebAssembly instructions need information about the environment for which they
+//! are being translated:
+//!
+//! - the loads and stores need the memory base address;
+//! - the `get_global` and `set_global` instructions depend on how the globals are implemented;
+//! - `memory.size` and `memory.grow` are runtime functions;
+//! - `call_indirect` has to translate the function index into the address of where this
+//!    is;
+//!
+//! That is why `translate_function_body` takes an object having the `WasmRuntime` trait as
+//! argument.
+//!
+//! There is extra complexity associated with translation of 128-bit SIMD instructions.
+//! Wasm only considers there to be a single 128-bit vector type.  But CLIF's type system
+//! distinguishes different lane configurations, so considers 8X16, 16X8, 32X4 and 64X2 to be
+//! different types.  The result is that, in wasm, it's perfectly OK to take the output of (eg)
+//! an `add.16x8` and use that as an operand of a `sub.32x4`, without using any cast.  But when
+//! translated into CLIF, that will cause a verifier error due to the apparent type mismatch.
+//!
+//! This file works around that problem by liberally inserting `bitcast` instructions in many
+//! places -- mostly, before the use of vector values, either as arguments to CLIF instructions
+//! or as block actual parameters.  These are no-op casts which nevertheless have different
+//! input and output types, and are used (mostly) to "convert" 16X8, 32X4 and 64X2-typed vectors
+//! to the "canonical" type, 8X16.  Hence the functions `optionally_bitcast_vector`,
+//! `bitcast_arguments`, `pop*_with_bitcast`, `canonicalise_then_jump`,
+//! `canonicalise_then_br{z,nz}`, `is_non_canonical_v128` and `canonicalise_v128_values`.
+//! Note that the `bitcast*` functions are occasionally used to convert to some type other than
+//! 8X16, but the `canonicalise*` functions always convert to type 8X16.
+//!
+//! Be careful when adding support for new vector instructions.  And when adding new jumps, even
+//! if they are apparently don't have any connection to vectors.  Never generate any kind of
+//! (inter-block) jump directly.  Instead use `canonicalise_then_jump` and
+//! `canonicalise_then_br{z,nz}`.
+//!
+//! The use of bitcasts is ugly and inefficient, but currently unavoidable:
+//!
+//! * they make the logic in this file fragile: miss out a bitcast for any reason, and there is
+//!   the risk of the system failing in the verifier.  At least for debug builds.
+//!
+//! * in the new backends, they potentially interfere with pattern matching on CLIF -- the
+//!   patterns need to take into account the presence of bitcast nodes.
+//!
+//! * in the new backends, they get translated into machine-level vector-register-copy
+//!   instructions, none of which are actually necessary.  We then depend on the register
+//!   allocator to coalesce them all out.
+//!
+//! * they increase the total number of CLIF nodes that have to be processed, hence slowing down
+//!   the compilation pipeline.  Also, the extra coalescing work generates a slowdown.
+//!
+//! A better solution which would avoid all four problems would be to remove the 8X16, 16X8,
+//! 32X4 and 64X2 types from CLIF and instead have a single V128 type.
+//!
+//! For further background see also:
+//!   <https://github.com/bytecodealliance/wasmtime/issues/1147>
+//!     ("Too many raw_bitcasts in SIMD code")
+//!   <https://github.com/bytecodealliance/cranelift/pull/1251>
+//!     ("Add X128 type to represent WebAssembly's V128 type")
+//!   <https://github.com/bytecodealliance/cranelift/pull/1236>
+//!     ("Relax verification to allow I8X16 to act as a default vector type")
+
+use super::func_environ::{FuncEnvironment, GlobalVariable, ReturnMode};
+use super::func_state::{ControlStackFrame, ElseData, FuncTranslationState};
+use super::translation_utils::{block_with_params, f32_translation, f64_translation};
+use crate::{hash_map, HashMap};
+use core::cmp;
+use core::convert::TryFrom;
+use core::{i32, u32};
+use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
+use cranelift_codegen::ir::immediates::Offset32;
+use cranelift_codegen::ir::types::*;
+use cranelift_codegen::ir::{
+    self, AtomicRmwOp, ConstantData, InstBuilder, JumpTableData, MemFlags, Value, ValueLabel,
+};
+use cranelift_codegen::packed_option::ReservedValue;
+use cranelift_frontend::{FunctionBuilder, Variable};
+use smallvec::SmallVec;
+use std::vec::Vec;
+
+use wasmer_compiler::wasmparser::{MemArg, Operator};
+use wasmer_compiler::{from_binaryreadererror_wasmerror, wasm_unsupported, ModuleTranslationState};
+use wasmer_types::{
+    FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
+};
+
+// Clippy warns about "align: _" but its important to document that the align field is ignored
+#[allow(clippy::unneeded_field_pattern, clippy::cognitive_complexity)]
+/// Translates wasm operators into Cranelift IR instructions. Returns `true` if it inserted
+/// a return.
+pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
+    module_translation_state: &ModuleTranslationState,
+    op: &Operator,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    if !state.reachable {
+        translate_unreachable_operator(module_translation_state, op, builder, state, environ)?;
+        return Ok(());
+    }
+
+    // This big match treats all Wasm code operators.
+    match op {
+        /********************************** Locals ****************************************
+         *  `get_local` and `set_local` are treated as non-SSA variables and will completely
+         *  disappear in the Cranelift Code
+         ***********************************************************************************/
+        Operator::LocalGet { local_index } => {
+            let val = builder.use_var(Variable::from_u32(*local_index));
+            state.push1(val);
+            let label = ValueLabel::from_u32(*local_index);
+            builder.set_val_label(val, label);
+        }
+        Operator::LocalSet { local_index } => {
+            let mut val = state.pop1();
+
+            // Ensure SIMD values are cast to their default Cranelift type, I8x16.
+            let ty = builder.func.dfg.value_type(val);
+            if ty.is_vector() {
+                val = optionally_bitcast_vector(val, I8X16, builder);
+            }
+
+            builder.def_var(Variable::from_u32(*local_index), val);
+            let label = ValueLabel::from_u32(*local_index);
+            builder.set_val_label(val, label);
+        }
+        Operator::LocalTee { local_index } => {
+            let mut val = state.peek1();
+
+            // Ensure SIMD values are cast to their default Cranelift type, I8x16.
+            let ty = builder.func.dfg.value_type(val);
+            if ty.is_vector() {
+                val = optionally_bitcast_vector(val, I8X16, builder);
+            }
+
+            builder.def_var(Variable::from_u32(*local_index), val);
+            let label = ValueLabel::from_u32(*local_index);
+            builder.set_val_label(val, label);
+        }
+        /********************************** Globals ****************************************
+         *  `get_global` and `set_global` are handled by the environment.
+         ***********************************************************************************/
+        Operator::GlobalGet { global_index } => {
+            let global_index = GlobalIndex::from_u32(*global_index);
+            let stack_elem = match state.get_global(builder.func, global_index.as_u32(), environ)? {
+                GlobalVariable::Const(val) => val,
+                GlobalVariable::Memory { gv, offset, ty } => {
+                    let addr = builder.ins().global_value(environ.pointer_type(), gv);
+                    let flags = ir::MemFlags::trusted();
+                    builder.ins().load(ty, flags, addr, offset)
+                }
+                GlobalVariable::Custom => {
+                    environ.translate_custom_global_get(builder.cursor(), global_index)?
+                }
+            };
+            state.push1(stack_elem);
+        }
+        Operator::GlobalSet { global_index } => {
+            let global_index = GlobalIndex::from_u32(*global_index);
+            match state.get_global(builder.func, global_index.as_u32(), environ)? {
+                GlobalVariable::Const(_) => {
+                    panic!("global #{} is a constant", global_index.as_u32())
+                }
+                GlobalVariable::Memory { gv, offset, ty } => {
+                    let addr = builder.ins().global_value(environ.pointer_type(), gv);
+                    let flags = ir::MemFlags::trusted();
+                    let mut val = state.pop1();
+                    // Ensure SIMD values are cast to their default Cranelift type, I8x16.
+                    if ty.is_vector() {
+                        val = optionally_bitcast_vector(val, I8X16, builder);
+                    }
+                    debug_assert_eq!(ty, builder.func.dfg.value_type(val));
+                    builder.ins().store(flags, val, addr, offset);
+                }
+                GlobalVariable::Custom => {
+                    let val = state.pop1();
+                    environ.translate_custom_global_set(builder.cursor(), global_index, val)?;
+                }
+            }
+        }
+        /********************************* Stack misc ***************************************
+         *  `drop`, `nop`, `unreachable` and `select`.
+         ***********************************************************************************/
+        Operator::Drop => {
+            state.pop1();
+        }
+        Operator::Select => {
+            // we can ignore metadata because extern ref must use TypedSelect
+            let (mut arg1, mut arg2, cond) = state.pop3();
+            if builder.func.dfg.value_type(arg1).is_vector() {
+                arg1 = optionally_bitcast_vector(arg1, I8X16, builder);
+            }
+            if builder.func.dfg.value_type(arg2).is_vector() {
+                arg2 = optionally_bitcast_vector(arg2, I8X16, builder);
+            }
+            state.push1(builder.ins().select(cond, arg1, arg2));
+        }
+        Operator::TypedSelect { ty: _ } => {
+            let (arg1, arg2, cond) = state.pop3();
+            state.push1(builder.ins().select(cond, arg1, arg2));
+        }
+        Operator::Nop => {
+            // We do nothing
+        }
+        Operator::Unreachable => {
+            builder.ins().trap(ir::TrapCode::UnreachableCodeReached);
+            state.reachable = false;
+        }
+        /***************************** Control flow blocks **********************************
+         *  When starting a control flow block, we create a new `Block` that will hold the code
+         *  after the block, and we push a frame on the control stack. Depending on the type
+         *  of block, we create a new `Block` for the body of the block with an associated
+         *  jump instruction.
+         *
+         *  The `End` instruction pops the last control frame from the control stack, seals
+         *  the destination block (since `br` instructions targeting it only appear inside the
+         *  block and have already been translated) and modify the value stack to use the
+         *  possible `Block`'s arguments values.
+         ***********************************************************************************/
+        Operator::Block { blockty } => {
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let next = block_with_params(builder, results.iter(), environ)?;
+            state.push_block(next, params.len(), results.len());
+        }
+        Operator::Loop { blockty } => {
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let loop_body = block_with_params(builder, params.iter(), environ)?;
+            let next = block_with_params(builder, results.iter(), environ)?;
+            canonicalise_then_jump(builder, loop_body, state.peekn(params.len()));
+            state.push_loop(loop_body, next, params.len(), results.len());
+
+            // Pop the initial `Block` actuals and replace them with the `Block`'s
+            // params since control flow joins at the top of the loop.
+            state.popn(params.len());
+            state
+                .stack
+                .extend_from_slice(builder.block_params(loop_body));
+
+            builder.switch_to_block(loop_body);
+            environ.translate_loop_header(builder.cursor())?;
+        }
+        Operator::If { blockty } => {
+            let val = state.pop1();
+
+            let (params, results) = module_translation_state.blocktype_params_results(blockty)?;
+            let (destination, else_data) = if params == results {
+                // It is possible there is no `else` block, so we will only
+                // allocate a block for it if/when we find the `else`. For now,
+                // we if the condition isn't true, then we jump directly to the
+                // destination block following the whole `if...end`. If we do end
+                // up discovering an `else`, then we will allocate a block for it
+                // and go back and patch the jump.
+                let destination = block_with_params(builder, results.iter(), environ)?;
+                let branch_inst =
+                    canonicalise_then_brz(builder, val, destination, state.peekn(params.len()));
+                (destination, ElseData::NoElse { branch_inst })
+            } else {
+                // The `if` type signature is not valid without an `else` block,
+                // so we eagerly allocate the `else` block here.
+                let destination = block_with_params(builder, results.iter(), environ)?;
+                let else_block = block_with_params(builder, params.iter(), environ)?;
+                canonicalise_then_brz(builder, val, else_block, state.peekn(params.len()));
+                builder.seal_block(else_block);
+                (destination, ElseData::WithElse { else_block })
+            };
+
+            let next_block = builder.create_block();
+            canonicalise_then_jump(builder, next_block, &[]);
+            builder.seal_block(next_block); // Only predecessor is the current block.
+            builder.switch_to_block(next_block);
+
+            // Here we append an argument to a Block targeted by an argumentless jump instruction
+            // But in fact there are two cases:
+            // - either the If does not have a Else clause, in that case ty = EmptyBlock
+            //   and we add nothing;
+            // - either the If have an Else clause, in that case the destination of this jump
+            //   instruction will be changed later when we translate the Else operator.
+            state.push_if(
+                destination,
+                else_data,
+                params.len(),
+                results.len(),
+                *blockty,
+            );
+        }
+        Operator::Else => {
+            let i = state.control_stack.len() - 1;
+            match state.control_stack[i] {
+                ControlStackFrame::If {
+                    ref else_data,
+                    head_is_reachable,
+                    ref mut consequent_ends_reachable,
+                    num_return_values,
+                    blocktype,
+                    destination,
+                    ..
+                } => {
+                    // We finished the consequent, so record its final
+                    // reachability state.
+                    debug_assert!(consequent_ends_reachable.is_none());
+                    *consequent_ends_reachable = Some(state.reachable);
+
+                    if head_is_reachable {
+                        // We have a branch from the head of the `if` to the `else`.
+                        state.reachable = true;
+
+                        // Ensure we have a block for the `else` block (it may have
+                        // already been pre-allocated, see `ElseData` for details).
+                        let else_block = match *else_data {
+                            ElseData::NoElse { branch_inst } => {
+                                let (params, _results) = module_translation_state
+                                    .blocktype_params_results(&blocktype)?;
+                                debug_assert_eq!(params.len(), num_return_values);
+                                let else_block =
+                                    block_with_params(builder, params.iter(), environ)?;
+                                canonicalise_then_jump(
+                                    builder,
+                                    destination,
+                                    state.peekn(params.len()),
+                                );
+                                state.popn(params.len());
+
+                                builder.change_jump_destination(branch_inst, else_block);
+                                builder.seal_block(else_block);
+                                else_block
+                            }
+                            ElseData::WithElse { else_block } => {
+                                canonicalise_then_jump(
+                                    builder,
+                                    destination,
+                                    state.peekn(num_return_values),
+                                );
+                                state.popn(num_return_values);
+                                else_block
+                            }
+                        };
+
+                        // You might be expecting that we push the parameters for this
+                        // `else` block here, something like this:
+                        //
+                        //     state.pushn(&control_stack_frame.params);
+                        //
+                        // We don't do that because they are already on the top of the stack
+                        // for us: we pushed the parameters twice when we saw the initial
+                        // `if` so that we wouldn't have to save the parameters in the
+                        // `ControlStackFrame` as another `Vec` allocation.
+
+                        builder.switch_to_block(else_block);
+
+                        // We don't bother updating the control frame's `ElseData`
+                        // to `WithElse` because nothing else will read it.
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+        Operator::End => {
+            let frame = state.control_stack.pop().unwrap();
+            let next_block = frame.following_code();
+            if !builder.is_unreachable() || builder.func.layout.first_inst(next_block).is_some() {
+                let return_count = frame.num_return_values();
+                let return_args = state.peekn(return_count);
+                canonicalise_then_jump(builder, frame.following_code(), return_args);
+                // You might expect that if we just finished an `if` block that
+                // didn't have a corresponding `else` block, then we would clean
+                // up our duplicate set of parameters that we pushed earlier
+                // right here. However, we don't have to explicitly do that,
+                // since we truncate the stack back to the original height
+                // below.
+            }
+
+            builder.switch_to_block(next_block);
+            builder.seal_block(next_block);
+
+            // If it is a loop we also have to seal the body loop block
+            if let ControlStackFrame::Loop { header, .. } = frame {
+                builder.seal_block(header)
+            }
+
+            frame.truncate_value_stack_to_original_size(&mut state.stack);
+            state
+                .stack
+                .extend_from_slice(builder.block_params(next_block));
+        }
+        /**************************** Branch instructions *********************************
+         * The branch instructions all have as arguments a target nesting level, which
+         * corresponds to how many control stack frames do we have to pop to get the
+         * destination `Block`.
+         *
+         * Once the destination `Block` is found, we sometimes have to declare a certain depth
+         * of the stack unreachable, because some branch instructions are terminator.
+         *
+         * The `br_table` case is much more complicated because Cranelift's `br_table` instruction
+         * does not support jump arguments like all the other branch instructions. That is why, in
+         * the case where we would use jump arguments for every other branch instruction, we
+         * need to split the critical edges leaving the `br_tables` by creating one `Block` per
+         * table destination; the `br_table` will point to these newly created `Blocks` and these
+         * `Block`s contain only a jump instruction pointing to the final destination, this time with
+         * jump arguments.
+         *
+         * This system is also implemented in Cranelift's SSA construction algorithm, because
+         * `use_var` located in a destination `Block` of a `br_table` might trigger the addition
+         * of jump arguments in each predecessor branch instruction, one of which might be a
+         * `br_table`.
+         ***********************************************************************************/
+        Operator::Br { relative_depth } => {
+            let i = state.control_stack.len() - 1 - (*relative_depth as usize);
+            let (return_count, br_destination) = {
+                let frame = &mut state.control_stack[i];
+                // We signal that all the code that follows until the next End is unreachable
+                frame.set_branched_to_exit();
+                let return_count = if frame.is_loop() {
+                    frame.num_param_values()
+                } else {
+                    frame.num_return_values()
+                };
+                (return_count, frame.br_destination())
+            };
+            let destination_args = state.peekn(return_count);
+            canonicalise_then_jump(builder, br_destination, destination_args);
+            state.popn(return_count);
+            state.reachable = false;
+        }
+        Operator::BrIf { relative_depth } => translate_br_if(*relative_depth, builder, state),
+        Operator::BrTable { targets } => {
+            let default = targets.default();
+            let mut min_depth = default;
+            for depth in targets.targets() {
+                let depth = depth.map_err(from_binaryreadererror_wasmerror)?;
+                if depth < min_depth {
+                    min_depth = depth;
+                }
+            }
+            let jump_args_count = {
+                let i = state.control_stack.len() - 1 - (min_depth as usize);
+                let min_depth_frame = &state.control_stack[i];
+                if min_depth_frame.is_loop() {
+                    min_depth_frame.num_param_values()
+                } else {
+                    min_depth_frame.num_return_values()
+                }
+            };
+            let val = state.pop1();
+            let mut data = JumpTableData::with_capacity(targets.len() as usize);
+            if jump_args_count == 0 {
+                // No jump arguments
+                for depth in targets.targets() {
+                    let depth = depth.map_err(from_binaryreadererror_wasmerror)?;
+                    let block = {
+                        let i = state.control_stack.len() - 1 - (depth as usize);
+                        let frame = &mut state.control_stack[i];
+                        frame.set_branched_to_exit();
+                        frame.br_destination()
+                    };
+                    data.push_entry(block);
+                }
+                let jt = builder.create_jump_table(data);
+                let block = {
+                    let i = state.control_stack.len() - 1 - (default as usize);
+                    let frame = &mut state.control_stack[i];
+                    frame.set_branched_to_exit();
+                    frame.br_destination()
+                };
+                builder.ins().br_table(val, block, jt);
+            } else {
+                // Here we have jump arguments, but Cranelift's br_table doesn't support them
+                // We then proceed to split the edges going out of the br_table
+                let return_count = jump_args_count;
+                let mut dest_block_sequence = vec![];
+                let mut dest_block_map = HashMap::new();
+                for depth in targets.targets() {
+                    let depth = depth.map_err(from_binaryreadererror_wasmerror)?;
+                    let branch_block = match dest_block_map.entry(depth as usize) {
+                        hash_map::Entry::Occupied(entry) => *entry.get(),
+                        hash_map::Entry::Vacant(entry) => {
+                            let block = builder.create_block();
+                            dest_block_sequence.push((depth as usize, block));
+                            *entry.insert(block)
+                        }
+                    };
+                    data.push_entry(branch_block);
+                }
+                let default_branch_block = match dest_block_map.entry(default as usize) {
+                    hash_map::Entry::Occupied(entry) => *entry.get(),
+                    hash_map::Entry::Vacant(entry) => {
+                        let block = builder.create_block();
+                        dest_block_sequence.push((default as usize, block));
+                        *entry.insert(block)
+                    }
+                };
+                let jt = builder.create_jump_table(data);
+                builder.ins().br_table(val, default_branch_block, jt);
+                for (depth, dest_block) in dest_block_sequence {
+                    builder.switch_to_block(dest_block);
+                    builder.seal_block(dest_block);
+                    let real_dest_block = {
+                        let i = state.control_stack.len() - 1 - depth;
+                        let frame = &mut state.control_stack[i];
+                        frame.set_branched_to_exit();
+                        frame.br_destination()
+                    };
+                    let destination_args = state.peekn(return_count);
+                    canonicalise_then_jump(builder, real_dest_block, destination_args);
+                }
+                state.popn(return_count);
+            }
+            state.reachable = false;
+        }
+        Operator::Return => {
+            let (return_count, _br_destination) = {
+                let frame = &mut state.control_stack[0];
+                let return_count = frame.num_return_values();
+                (return_count, frame.br_destination())
+            };
+            {
+                let return_args = state.peekn_mut(return_count);
+                // TODO(reftypes): maybe ref count here?
+                let return_types = wasm_param_types(&builder.func.signature.returns, |i| {
+                    environ.is_wasm_return(&builder.func.signature, i)
+                });
+                bitcast_arguments(return_args, &return_types, builder);
+                match environ.return_mode() {
+                    ReturnMode::NormalReturns => builder.ins().return_(return_args),
+                };
+            }
+            state.popn(return_count);
+            state.reachable = false;
+        }
+        /********************************** Exception handing **********************************/
+        Operator::Try { .. }
+        | Operator::Catch { .. }
+        | Operator::Throw { .. }
+        | Operator::Rethrow { .. }
+        | Operator::Delegate { .. }
+        | Operator::CatchAll => {
+            return Err(wasm_unsupported!(
+                "proposed exception handling operator {:?}",
+                op
+            ));
+        }
+        /************************************ Calls ****************************************
+         * The call instructions pop off their arguments from the stack and append their
+         * return values to it. `call_indirect` needs environment support because there is an
+         * argument referring to an index in the external functions table of the module.
+         ************************************************************************************/
+        Operator::Call { function_index } => {
+            let (fref, num_args) = state.get_direct_func(builder.func, *function_index, environ)?;
+
+            let args = state.peekn_mut(num_args);
+
+            // Bitcast any vector arguments to their default type, I8X16, before calling.
+            let callee_signature =
+                &builder.func.dfg.signatures[builder.func.dfg.ext_funcs[fref].signature];
+            let types = wasm_param_types(&callee_signature.params, |i| {
+                environ.is_wasm_parameter(callee_signature, i)
+            });
+            bitcast_arguments(args, &types, builder);
+            let func_index = FunctionIndex::from_u32(*function_index);
+
+            let call = environ.translate_call(builder.cursor(), func_index, fref, args)?;
+            let inst_results = builder.inst_results(call);
+            debug_assert_eq!(
+                inst_results.len(),
+                builder.func.dfg.signatures[builder.func.dfg.ext_funcs[fref].signature]
+                    .returns
+                    .len(),
+                "translate_call results should match the call signature"
+            );
+            state.popn(num_args);
+            state.pushn(inst_results);
+        }
+        Operator::CallIndirect {
+            type_index,
+            table_index,
+            table_byte: _,
+        } => {
+            // `index` is the index of the function's signature and `table_index` is the index of
+            // the table to search the function in.
+            let (sigref, num_args) = state.get_indirect_sig(builder.func, *type_index, environ)?;
+            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
+            let callee = state.pop1();
+
+            // Bitcast any vector arguments to their default type, I8X16, before calling.
+            let callee_signature = &builder.func.dfg.signatures[sigref];
+            let args = state.peekn_mut(num_args);
+            let types = wasm_param_types(&callee_signature.params, |i| {
+                environ.is_wasm_parameter(callee_signature, i)
+            });
+            bitcast_arguments(args, &types, builder);
+
+            let args = state.peekn(num_args);
+            let sig_idx = SignatureIndex::from_u32(*type_index);
+
+            let call = environ.translate_call_indirect(
+                builder.cursor(),
+                TableIndex::from_u32(*table_index),
+                table,
+                sig_idx,
+                sigref,
+                callee,
+                args,
+            )?;
+            let inst_results = builder.inst_results(call);
+            debug_assert_eq!(
+                inst_results.len(),
+                builder.func.dfg.signatures[sigref].returns.len(),
+                "translate_call_indirect results should match the call signature"
+            );
+            state.popn(num_args);
+            state.pushn(inst_results);
+        }
+        /******************************* Memory management ***********************************
+         * Memory management is handled by environment. It is usually translated into calls to
+         * special functions.
+         ************************************************************************************/
+        Operator::MemoryGrow { mem, mem_byte: _ } => {
+            // The WebAssembly MVP only supports one linear memory, but we expect the reserved
+            // argument to be a memory index.
+            let heap_index = MemoryIndex::from_u32(*mem);
+            let heap = state.get_heap(builder.func, *mem, environ)?;
+            let val = state.pop1();
+            state.push1(environ.translate_memory_grow(builder.cursor(), heap_index, heap, val)?)
+        }
+        Operator::MemorySize { mem, mem_byte: _ } => {
+            let heap_index = MemoryIndex::from_u32(*mem);
+            let heap = state.get_heap(builder.func, *mem, environ)?;
+            state.push1(environ.translate_memory_size(builder.cursor(), heap_index, heap)?);
+        }
+        /******************************* Load instructions ***********************************
+         * Wasm specifies an integer alignment flag but we drop it in Cranelift.
+         * The memory base address is provided by the environment.
+         ************************************************************************************/
+        Operator::I32Load8U { memarg } => {
+            translate_load(memarg, ir::Opcode::Uload8, I32, builder, state, environ)?;
+        }
+        Operator::I32Load16U { memarg } => {
+            translate_load(memarg, ir::Opcode::Uload16, I32, builder, state, environ)?;
+        }
+        Operator::I32Load8S { memarg } => {
+            translate_load(memarg, ir::Opcode::Sload8, I32, builder, state, environ)?;
+        }
+        Operator::I32Load16S { memarg } => {
+            translate_load(memarg, ir::Opcode::Sload16, I32, builder, state, environ)?;
+        }
+        Operator::I64Load8U { memarg } => {
+            translate_load(memarg, ir::Opcode::Uload8, I64, builder, state, environ)?;
+        }
+        Operator::I64Load16U { memarg } => {
+            translate_load(memarg, ir::Opcode::Uload16, I64, builder, state, environ)?;
+        }
+        Operator::I64Load8S { memarg } => {
+            translate_load(memarg, ir::Opcode::Sload8, I64, builder, state, environ)?;
+        }
+        Operator::I64Load16S { memarg } => {
+            translate_load(memarg, ir::Opcode::Sload16, I64, builder, state, environ)?;
+        }
+        Operator::I64Load32S { memarg } => {
+            translate_load(memarg, ir::Opcode::Sload32, I64, builder, state, environ)?;
+        }
+        Operator::I64Load32U { memarg } => {
+            translate_load(memarg, ir::Opcode::Uload32, I64, builder, state, environ)?;
+        }
+        Operator::I32Load { memarg } => {
+            translate_load(memarg, ir::Opcode::Load, I32, builder, state, environ)?;
+        }
+        Operator::F32Load { memarg } => {
+            translate_load(memarg, ir::Opcode::Load, F32, builder, state, environ)?;
+        }
+        Operator::I64Load { memarg } => {
+            translate_load(memarg, ir::Opcode::Load, I64, builder, state, environ)?;
+        }
+        Operator::F64Load { memarg } => {
+            translate_load(memarg, ir::Opcode::Load, F64, builder, state, environ)?;
+        }
+        Operator::V128Load { memarg } => {
+            translate_load(memarg, ir::Opcode::Load, I8X16, builder, state, environ)?;
+        }
+        Operator::V128Load8x8S { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().sload8x8(flags, base, offset);
+            state.push1(loaded);
+        }
+        Operator::V128Load8x8U { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().uload8x8(flags, base, offset);
+            state.push1(loaded);
+        }
+        Operator::V128Load16x4S { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().sload16x4(flags, base, offset);
+            state.push1(loaded);
+        }
+        Operator::V128Load16x4U { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().uload16x4(flags, base, offset);
+            state.push1(loaded);
+        }
+        Operator::V128Load32x2S { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().sload32x2(flags, base, offset);
+            state.push1(loaded);
+        }
+        Operator::V128Load32x2U { memarg } => {
+            let (flags, base, offset) = prepare_load(memarg, 8, builder, state, environ)?;
+            let loaded = builder.ins().uload32x2(flags, base, offset);
+            state.push1(loaded);
+        }
+        /****************************** Store instructions ***********************************
+         * Wasm specifies an integer alignment flag but we drop it in Cranelift.
+         * The memory base address is provided by the environment.
+         ************************************************************************************/
+        Operator::I32Store { memarg }
+        | Operator::I64Store { memarg }
+        | Operator::F32Store { memarg }
+        | Operator::F64Store { memarg } => {
+            translate_store(memarg, ir::Opcode::Store, builder, state, environ)?;
+        }
+        Operator::I32Store8 { memarg } | Operator::I64Store8 { memarg } => {
+            translate_store(memarg, ir::Opcode::Istore8, builder, state, environ)?;
+        }
+        Operator::I32Store16 { memarg } | Operator::I64Store16 { memarg } => {
+            translate_store(memarg, ir::Opcode::Istore16, builder, state, environ)?;
+        }
+        Operator::I64Store32 { memarg } => {
+            translate_store(memarg, ir::Opcode::Istore32, builder, state, environ)?;
+        }
+        Operator::V128Store { memarg } => {
+            translate_store(memarg, ir::Opcode::Store, builder, state, environ)?;
+        }
+        /****************************** Nullary Operators ************************************/
+        Operator::I32Const { value } => state.push1(builder.ins().iconst(I32, i64::from(*value))),
+        Operator::I64Const { value } => state.push1(builder.ins().iconst(I64, *value)),
+        Operator::F32Const { value } => {
+            state.push1(builder.ins().f32const(f32_translation(*value)));
+        }
+        Operator::F64Const { value } => {
+            state.push1(builder.ins().f64const(f64_translation(*value)));
+        }
+        /******************************* Unary Operators *************************************/
+        Operator::I32Clz | Operator::I64Clz => {
+            let arg = state.pop1();
+            state.push1(builder.ins().clz(arg));
+        }
+        Operator::I32Ctz | Operator::I64Ctz => {
+            let arg = state.pop1();
+            state.push1(builder.ins().ctz(arg));
+        }
+        Operator::I32Popcnt | Operator::I64Popcnt => {
+            let arg = state.pop1();
+            state.push1(builder.ins().popcnt(arg));
+        }
+        Operator::I64ExtendI32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I64, val));
+        }
+        Operator::I64ExtendI32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().uextend(I64, val));
+        }
+        Operator::I32WrapI64 => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I32, val));
+        }
+        Operator::F32Sqrt | Operator::F64Sqrt => {
+            let arg = state.pop1();
+            state.push1(builder.ins().sqrt(arg));
+        }
+        Operator::F32Ceil | Operator::F64Ceil => {
+            let arg = state.pop1();
+            state.push1(builder.ins().ceil(arg));
+        }
+        Operator::F32Floor | Operator::F64Floor => {
+            let arg = state.pop1();
+            state.push1(builder.ins().floor(arg));
+        }
+        Operator::F32Trunc | Operator::F64Trunc => {
+            let arg = state.pop1();
+            state.push1(builder.ins().trunc(arg));
+        }
+        Operator::F32Nearest | Operator::F64Nearest => {
+            let arg = state.pop1();
+            state.push1(builder.ins().nearest(arg));
+        }
+        Operator::F32Abs | Operator::F64Abs => {
+            let val = state.pop1();
+            state.push1(builder.ins().fabs(val));
+        }
+        Operator::F32Neg | Operator::F64Neg => {
+            let arg = state.pop1();
+            state.push1(builder.ins().fneg(arg));
+        }
+        Operator::F64ConvertI64U | Operator::F64ConvertI32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_from_uint(F64, val));
+        }
+        Operator::F64ConvertI64S | Operator::F64ConvertI32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_from_sint(F64, val));
+        }
+        Operator::F32ConvertI64S | Operator::F32ConvertI32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_from_sint(F32, val));
+        }
+        Operator::F32ConvertI64U | Operator::F32ConvertI32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_from_uint(F32, val));
+        }
+        Operator::F64PromoteF32 => {
+            let val = state.pop1();
+            state.push1(builder.ins().fpromote(F64, val));
+        }
+        Operator::F32DemoteF64 => {
+            let val = state.pop1();
+            state.push1(builder.ins().fdemote(F32, val));
+        }
+        Operator::I64TruncF64S | Operator::I64TruncF32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_sint(I64, val));
+        }
+        Operator::I32TruncF64S | Operator::I32TruncF32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_sint(I32, val));
+        }
+        Operator::I64TruncF64U | Operator::I64TruncF32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_uint(I64, val));
+        }
+        Operator::I32TruncF64U | Operator::I32TruncF32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_uint(I32, val));
+        }
+        Operator::I64TruncSatF64S | Operator::I64TruncSatF32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_sint_sat(I64, val));
+        }
+        Operator::I32TruncSatF64S | Operator::I32TruncSatF32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_sint_sat(I32, val));
+        }
+        Operator::I64TruncSatF64U | Operator::I64TruncSatF32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_uint_sat(I64, val));
+        }
+        Operator::I32TruncSatF64U | Operator::I32TruncSatF32U => {
+            let val = state.pop1();
+            state.push1(builder.ins().fcvt_to_uint_sat(I32, val));
+        }
+        Operator::F32ReinterpretI32 => {
+            let val = state.pop1();
+            state.push1(builder.ins().bitcast(F32, MemFlags::new(), val));
+        }
+        Operator::F64ReinterpretI64 => {
+            let val = state.pop1();
+            state.push1(builder.ins().bitcast(F64, MemFlags::new(), val));
+        }
+        Operator::I32ReinterpretF32 => {
+            let val = state.pop1();
+            state.push1(builder.ins().bitcast(I32, MemFlags::new(), val));
+        }
+        Operator::I64ReinterpretF64 => {
+            let val = state.pop1();
+            state.push1(builder.ins().bitcast(I64, MemFlags::new(), val));
+        }
+        Operator::I32Extend8S => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I8, val));
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I32, val));
+        }
+        Operator::I32Extend16S => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I16, val));
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I32, val));
+        }
+        Operator::I64Extend8S => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I8, val));
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I64, val));
+        }
+        Operator::I64Extend16S => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I16, val));
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I64, val));
+        }
+        Operator::I64Extend32S => {
+            let val = state.pop1();
+            state.push1(builder.ins().ireduce(I32, val));
+            let val = state.pop1();
+            state.push1(builder.ins().sextend(I64, val));
+        }
+        /****************************** Binary Operators ************************************/
+        Operator::I32Add | Operator::I64Add => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().iadd(arg1, arg2));
+        }
+        Operator::I32And | Operator::I64And => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().band(arg1, arg2));
+        }
+        Operator::I32Or | Operator::I64Or => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().bor(arg1, arg2));
+        }
+        Operator::I32Xor | Operator::I64Xor => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().bxor(arg1, arg2));
+        }
+        Operator::I32Shl | Operator::I64Shl => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().ishl(arg1, arg2));
+        }
+        Operator::I32ShrS | Operator::I64ShrS => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().sshr(arg1, arg2));
+        }
+        Operator::I32ShrU | Operator::I64ShrU => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().ushr(arg1, arg2));
+        }
+        Operator::I32Rotl | Operator::I64Rotl => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().rotl(arg1, arg2));
+        }
+        Operator::I32Rotr | Operator::I64Rotr => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().rotr(arg1, arg2));
+        }
+        Operator::F32Add | Operator::F64Add => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fadd(arg1, arg2));
+        }
+        Operator::I32Sub | Operator::I64Sub => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().isub(arg1, arg2));
+        }
+        Operator::F32Sub | Operator::F64Sub => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fsub(arg1, arg2));
+        }
+        Operator::I32Mul | Operator::I64Mul => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().imul(arg1, arg2));
+        }
+        Operator::F32Mul | Operator::F64Mul => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fmul(arg1, arg2));
+        }
+        Operator::F32Div | Operator::F64Div => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fdiv(arg1, arg2));
+        }
+        Operator::I32DivS | Operator::I64DivS => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().sdiv(arg1, arg2));
+        }
+        Operator::I32DivU | Operator::I64DivU => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().udiv(arg1, arg2));
+        }
+        Operator::I32RemS | Operator::I64RemS => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().srem(arg1, arg2));
+        }
+        Operator::I32RemU | Operator::I64RemU => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().urem(arg1, arg2));
+        }
+        Operator::F32Min | Operator::F64Min => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fmin(arg1, arg2));
+        }
+        Operator::F32Max | Operator::F64Max => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fmax(arg1, arg2));
+        }
+        Operator::F32Copysign | Operator::F64Copysign => {
+            let (arg1, arg2) = state.pop2();
+            state.push1(builder.ins().fcopysign(arg1, arg2));
+        }
+        /**************************** Comparison Operators **********************************/
+        Operator::I32LtS | Operator::I64LtS => {
+            translate_icmp(IntCC::SignedLessThan, builder, state)
+        }
+        Operator::I32LtU | Operator::I64LtU => {
+            translate_icmp(IntCC::UnsignedLessThan, builder, state)
+        }
+        Operator::I32LeS | Operator::I64LeS => {
+            translate_icmp(IntCC::SignedLessThanOrEqual, builder, state)
+        }
+        Operator::I32LeU | Operator::I64LeU => {
+            translate_icmp(IntCC::UnsignedLessThanOrEqual, builder, state)
+        }
+        Operator::I32GtS | Operator::I64GtS => {
+            translate_icmp(IntCC::SignedGreaterThan, builder, state)
+        }
+        Operator::I32GtU | Operator::I64GtU => {
+            translate_icmp(IntCC::UnsignedGreaterThan, builder, state)
+        }
+        Operator::I32GeS | Operator::I64GeS => {
+            translate_icmp(IntCC::SignedGreaterThanOrEqual, builder, state)
+        }
+        Operator::I32GeU | Operator::I64GeU => {
+            translate_icmp(IntCC::UnsignedGreaterThanOrEqual, builder, state)
+        }
+        Operator::I32Eqz | Operator::I64Eqz => {
+            let arg = state.pop1();
+            let val = builder.ins().icmp_imm(IntCC::Equal, arg, 0);
+            state.push1(builder.ins().uextend(I32, val));
+        }
+        Operator::I32Eq | Operator::I64Eq => translate_icmp(IntCC::Equal, builder, state),
+        Operator::F32Eq | Operator::F64Eq => translate_fcmp(FloatCC::Equal, builder, state),
+        Operator::I32Ne | Operator::I64Ne => translate_icmp(IntCC::NotEqual, builder, state),
+        Operator::F32Ne | Operator::F64Ne => translate_fcmp(FloatCC::NotEqual, builder, state),
+        Operator::F32Gt | Operator::F64Gt => translate_fcmp(FloatCC::GreaterThan, builder, state),
+        Operator::F32Ge | Operator::F64Ge => {
+            translate_fcmp(FloatCC::GreaterThanOrEqual, builder, state)
+        }
+        Operator::F32Lt | Operator::F64Lt => translate_fcmp(FloatCC::LessThan, builder, state),
+        Operator::F32Le | Operator::F64Le => {
+            translate_fcmp(FloatCC::LessThanOrEqual, builder, state)
+        }
+        Operator::RefNull { hty } => {
+            state.push1(environ.translate_ref_null(builder.cursor(), *hty)?)
+        }
+        Operator::RefIsNull => {
+            let value = state.pop1();
+            state.push1(environ.translate_ref_is_null(builder.cursor(), value)?);
+        }
+        Operator::RefFunc { function_index } => {
+            let index = FunctionIndex::from_u32(*function_index);
+            state.push1(environ.translate_ref_func(builder.cursor(), index)?);
+        }
+        Operator::MemoryAtomicWait32 { memarg } | Operator::MemoryAtomicWait64 { memarg } => {
+            // The WebAssembly MVP only supports one linear memory and
+            // wasmparser will ensure that the memory indices specified are
+            // zero.
+            let implied_ty = match op {
+                Operator::MemoryAtomicWait64 { .. } => I64,
+                Operator::MemoryAtomicWait32 { .. } => I32,
+                _ => unreachable!(),
+            };
+            let heap_index = MemoryIndex::from_u32(memarg.memory);
+            let heap = state.get_heap(builder.func, memarg.memory, environ)?;
+            let timeout = state.pop1(); // 64 (fixed)
+            let expected = state.pop1(); // 32 or 64 (per the `Ixx` in `IxxAtomicWait`)
+            let addr = state.pop1(); // 32 (fixed)
+            let addr = fold_atomic_mem_addr(addr, memarg, implied_ty, builder);
+            assert!(builder.func.dfg.value_type(expected) == implied_ty);
+            // `fn translate_atomic_wait` can inspect the type of `expected` to figure out what
+            // code it needs to generate, if it wants.
+            match environ.translate_atomic_wait(
+                builder.cursor(),
+                heap_index,
+                heap,
+                addr,
+                expected,
+                timeout,
+            ) {
+                Ok(res) => {
+                    state.push1(res);
+                }
+                Err(wasmer_types::WasmError::Unsupported(_err)) => {
+                    // If multiple threads hit a mutex then the function will fail
+                    builder.ins().trap(ir::TrapCode::UnreachableCodeReached);
+                    state.reachable = false;
+                }
+                Err(err) => {
+                    return Err(err);
+                }
+            };
+        }
+        Operator::MemoryAtomicNotify { memarg } => {
+            let heap_index = MemoryIndex::from_u32(memarg.memory);
+            let heap = state.get_heap(builder.func, memarg.memory, environ)?;
+            let count = state.pop1(); // 32 (fixed)
+            let addr = state.pop1(); // 32 (fixed)
+            let addr = fold_atomic_mem_addr(addr, memarg, I32, builder);
+            match environ.translate_atomic_notify(builder.cursor(), heap_index, heap, addr, count) {
+                Ok(res) => {
+                    state.push1(res);
+                }
+                Err(wasmer_types::WasmError::Unsupported(_err)) => {
+                    // Simple return a zero as this function is needed for the __wasi_init_memory function
+                    // but the equivalent notify.wait will not be called (as only one thread calls __start)
+                    // hence these atomic operations are not needed
+                    state.push1(builder.ins().iconst(I32, i64::from(0)));
+                }
+                Err(err) => {
+                    return Err(err);
+                }
+            };
+        }
+        Operator::I32AtomicLoad { memarg } => {
+            translate_atomic_load(I32, I32, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicLoad { memarg } => {
+            translate_atomic_load(I64, I64, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicLoad8U { memarg } => {
+            translate_atomic_load(I32, I8, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicLoad16U { memarg } => {
+            translate_atomic_load(I32, I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicLoad8U { memarg } => {
+            translate_atomic_load(I64, I8, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicLoad16U { memarg } => {
+            translate_atomic_load(I64, I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicLoad32U { memarg } => {
+            translate_atomic_load(I64, I32, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicStore { memarg } => {
+            translate_atomic_store(I32, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicStore { memarg } => {
+            translate_atomic_store(I64, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicStore8 { memarg } => {
+            translate_atomic_store(I8, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicStore16 { memarg } => {
+            translate_atomic_store(I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicStore8 { memarg } => {
+            translate_atomic_store(I8, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicStore16 { memarg } => {
+            translate_atomic_store(I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicStore32 { memarg } => {
+            translate_atomic_store(I32, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwAdd { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwAdd { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8AddU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16AddU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8AddU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16AddU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32AddU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::Add, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwSub { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwSub { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8SubU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16SubU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8SubU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16SubU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32SubU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::Sub, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwAnd { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwAnd { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8AndU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16AndU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8AndU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16AndU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32AndU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::And, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwOr { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwOr { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8OrU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16OrU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8OrU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16OrU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32OrU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::Or, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwXor { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwXor { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8XorU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16XorU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8XorU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16XorU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32XorU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::Xor, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwXchg { memarg } => {
+            translate_atomic_rmw(I32, I32, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwXchg { memarg } => {
+            translate_atomic_rmw(I64, I64, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8XchgU { memarg } => {
+            translate_atomic_rmw(I32, I8, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16XchgU { memarg } => {
+            translate_atomic_rmw(I32, I16, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8XchgU { memarg } => {
+            translate_atomic_rmw(I64, I8, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16XchgU { memarg } => {
+            translate_atomic_rmw(I64, I16, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32XchgU { memarg } => {
+            translate_atomic_rmw(I64, I32, AtomicRmwOp::Xchg, memarg, builder, state, environ)?
+        }
+
+        Operator::I32AtomicRmwCmpxchg { memarg } => {
+            translate_atomic_cas(I32, I32, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmwCmpxchg { memarg } => {
+            translate_atomic_cas(I64, I64, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw8CmpxchgU { memarg } => {
+            translate_atomic_cas(I32, I8, memarg, builder, state, environ)?
+        }
+        Operator::I32AtomicRmw16CmpxchgU { memarg } => {
+            translate_atomic_cas(I32, I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw8CmpxchgU { memarg } => {
+            translate_atomic_cas(I64, I8, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw16CmpxchgU { memarg } => {
+            translate_atomic_cas(I64, I16, memarg, builder, state, environ)?
+        }
+        Operator::I64AtomicRmw32CmpxchgU { memarg } => {
+            translate_atomic_cas(I64, I32, memarg, builder, state, environ)?
+        }
+
+        Operator::AtomicFence { .. } => {
+            builder.ins().fence();
+        }
+        Operator::MemoryCopy { dst_mem, src_mem } => {
+            let src_index = MemoryIndex::from_u32(*src_mem);
+            let dst_index = MemoryIndex::from_u32(*dst_mem);
+            let src_heap = state.get_heap(builder.func, *src_mem, environ)?;
+            let dst_heap = state.get_heap(builder.func, *dst_mem, environ)?;
+            let len = state.pop1();
+            let src_pos = state.pop1();
+            let dst_pos = state.pop1();
+            environ.translate_memory_copy(
+                builder.cursor(),
+                src_index,
+                src_heap,
+                dst_index,
+                dst_heap,
+                dst_pos,
+                src_pos,
+                len,
+            )?;
+        }
+        Operator::MemoryFill { mem } => {
+            let heap_index = MemoryIndex::from_u32(*mem);
+            let heap = state.get_heap(builder.func, *mem, environ)?;
+            let len = state.pop1();
+            let val = state.pop1();
+            let dest = state.pop1();
+            environ.translate_memory_fill(builder.cursor(), heap_index, heap, dest, val, len)?;
+        }
+        Operator::MemoryInit { data_index, mem } => {
+            let heap_index = MemoryIndex::from_u32(*mem);
+            let heap = state.get_heap(builder.func, *mem, environ)?;
+            let len = state.pop1();
+            let src = state.pop1();
+            let dest = state.pop1();
+            environ.translate_memory_init(
+                builder.cursor(),
+                heap_index,
+                heap,
+                *data_index,
+                dest,
+                src,
+                len,
+            )?;
+        }
+        Operator::DataDrop { data_index } => {
+            environ.translate_data_drop(builder.cursor(), *data_index)?;
+        }
+        Operator::TableSize { table: index } => {
+            let table = state.get_or_create_table(builder.func, *index, environ)?;
+            state.push1(environ.translate_table_size(
+                builder.cursor(),
+                TableIndex::from_u32(*index),
+                table,
+            )?);
+        }
+        Operator::TableGrow { table: index } => {
+            let table_index = TableIndex::from_u32(*index);
+            let table = state.get_or_create_table(builder.func, *index, environ)?;
+            let delta = state.pop1();
+            let init_value = state.pop1();
+            state.push1(environ.translate_table_grow(
+                builder.cursor(),
+                table_index,
+                table,
+                delta,
+                init_value,
+            )?);
+        }
+        Operator::TableGet { table: index } => {
+            let table_index = TableIndex::from_u32(*index);
+            let table = state.get_or_create_table(builder.func, *index, environ)?;
+            let index = state.pop1();
+            state.push1(environ.translate_table_get(builder, table_index, table, index)?);
+        }
+        Operator::TableSet { table: index } => {
+            let table_index = TableIndex::from_u32(*index);
+            let table = state.get_or_create_table(builder.func, *index, environ)?;
+            // We don't touch the ref count here because we're passing it to the host
+            // then dropping it from the stack. Thus 1 + -1 = 0.
+            let value = state.pop1();
+            let index = state.pop1();
+            environ.translate_table_set(builder, table_index, table, value, index)?;
+        }
+        Operator::TableCopy {
+            dst_table: dst_table_index,
+            src_table: src_table_index,
+        } => {
+            let dst_table = state.get_or_create_table(builder.func, *dst_table_index, environ)?;
+            let src_table = state.get_or_create_table(builder.func, *src_table_index, environ)?;
+            let len = state.pop1();
+            let src = state.pop1();
+            let dest = state.pop1();
+            environ.translate_table_copy(
+                builder.cursor(),
+                TableIndex::from_u32(*dst_table_index),
+                dst_table,
+                TableIndex::from_u32(*src_table_index),
+                src_table,
+                dest,
+                src,
+                len,
+            )?;
+        }
+        Operator::TableFill { table } => {
+            let table_index = TableIndex::from_u32(*table);
+            let len = state.pop1();
+            let val = state.pop1();
+            let dest = state.pop1();
+            environ.translate_table_fill(builder.cursor(), table_index, dest, val, len)?;
+        }
+        Operator::TableInit {
+            elem_index,
+            table: table_index,
+        } => {
+            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
+            let len = state.pop1();
+            let src = state.pop1();
+            let dest = state.pop1();
+            environ.translate_table_init(
+                builder.cursor(),
+                *elem_index,
+                TableIndex::from_u32(*table_index),
+                table,
+                dest,
+                src,
+                len,
+            )?;
+        }
+        Operator::ElemDrop { elem_index } => {
+            environ.translate_elem_drop(builder.cursor(), *elem_index)?;
+        }
+        Operator::V128Const { value } => {
+            let data = value.bytes().to_vec().into();
+            let handle = builder.func.dfg.constants.insert(data);
+            let value = builder.ins().vconst(I8X16, handle);
+            // the v128.const is typed in CLIF as a I8x16 but raw_bitcast to a different type
+            // before use
+            state.push1(value)
+        }
+        Operator::I8x16Splat | Operator::I16x8Splat => {
+            let reduced = builder.ins().ireduce(type_of(op).lane_type(), state.pop1());
+            let splatted = builder.ins().splat(type_of(op), reduced);
+            state.push1(splatted)
+        }
+        Operator::I32x4Splat
+        | Operator::I64x2Splat
+        | Operator::F32x4Splat
+        | Operator::F64x2Splat => {
+            let splatted = builder.ins().splat(type_of(op), state.pop1());
+            state.push1(splatted)
+        }
+        Operator::V128Load8Splat { memarg }
+        | Operator::V128Load16Splat { memarg }
+        | Operator::V128Load32Splat { memarg }
+        | Operator::V128Load64Splat { memarg } => {
+            translate_load(
+                memarg,
+                ir::Opcode::Load,
+                type_of(op).lane_type(),
+                builder,
+                state,
+                environ,
+            )?;
+            let splatted = builder.ins().splat(type_of(op), state.pop1());
+            state.push1(splatted)
+        }
+        Operator::V128Load32Zero { memarg } | Operator::V128Load64Zero { memarg } => {
+            translate_load(
+                memarg,
+                ir::Opcode::Load,
+                type_of(op).lane_type(),
+                builder,
+                state,
+                environ,
+            )?;
+            let as_vector = builder.ins().scalar_to_vector(type_of(op), state.pop1());
+            state.push1(as_vector)
+        }
+        Operator::V128Load8Lane { memarg, lane }
+        | Operator::V128Load16Lane { memarg, lane }
+        | Operator::V128Load32Lane { memarg, lane }
+        | Operator::V128Load64Lane { memarg, lane } => {
+            let vector = pop1_with_bitcast(state, type_of(op), builder);
+            translate_load(
+                memarg,
+                ir::Opcode::Load,
+                type_of(op).lane_type(),
+                builder,
+                state,
+                environ,
+            )?;
+            let replacement = state.pop1();
+            state.push1(builder.ins().insertlane(vector, replacement, *lane))
+        }
+        Operator::V128Store8Lane { memarg, lane }
+        | Operator::V128Store16Lane { memarg, lane }
+        | Operator::V128Store32Lane { memarg, lane }
+        | Operator::V128Store64Lane { memarg, lane } => {
+            let vector = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().extractlane(vector, *lane));
+            translate_store(memarg, ir::Opcode::Store, builder, state, environ)?;
+        }
+        Operator::I8x16ExtractLaneS { lane } | Operator::I16x8ExtractLaneS { lane } => {
+            let vector = pop1_with_bitcast(state, type_of(op), builder);
+            let extracted = builder.ins().extractlane(vector, *lane);
+            state.push1(builder.ins().sextend(I32, extracted))
+        }
+        Operator::I8x16ExtractLaneU { lane } | Operator::I16x8ExtractLaneU { lane } => {
+            let vector = pop1_with_bitcast(state, type_of(op), builder);
+            let extracted = builder.ins().extractlane(vector, *lane);
+            state.push1(builder.ins().uextend(I32, extracted));
+            // On x86, PEXTRB zeroes the upper bits of the destination register of extractlane so
+            // uextend could be elided; for now, uextend is needed for Cranelift's type checks to
+            // work.
+        }
+        Operator::I32x4ExtractLane { lane }
+        | Operator::I64x2ExtractLane { lane }
+        | Operator::F32x4ExtractLane { lane }
+        | Operator::F64x2ExtractLane { lane } => {
+            let vector = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().extractlane(vector, *lane))
+        }
+        Operator::I8x16ReplaceLane { lane } | Operator::I16x8ReplaceLane { lane } => {
+            let (vector, replacement) = state.pop2();
+            let ty = type_of(op);
+            let reduced = builder.ins().ireduce(ty.lane_type(), replacement);
+            let vector = optionally_bitcast_vector(vector, ty, builder);
+            state.push1(builder.ins().insertlane(vector, reduced, *lane))
+        }
+        Operator::I32x4ReplaceLane { lane }
+        | Operator::I64x2ReplaceLane { lane }
+        | Operator::F32x4ReplaceLane { lane }
+        | Operator::F64x2ReplaceLane { lane } => {
+            let (vector, replacement) = state.pop2();
+            let vector = optionally_bitcast_vector(vector, type_of(op), builder);
+            state.push1(builder.ins().insertlane(vector, replacement, *lane))
+        }
+        Operator::I8x16Shuffle { lanes, .. } => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            let lanes = ConstantData::from(lanes.as_ref());
+            let mask = builder.func.dfg.immediates.push(lanes);
+            let shuffled = builder.ins().shuffle(a, b, mask);
+            state.push1(shuffled)
+            // At this point the original types of a and b are lost; users of this value (i.e. this
+            // WASM-to-CLIF translator) may need to raw_bitcast for type-correctness. This is due
+            // to WASM using the less specific v128 type for certain operations and more specific
+            // types (e.g. i8x16) for others.
+        }
+        Operator::I8x16Swizzle => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            state.push1(builder.ins().swizzle(I8X16, a, b))
+        }
+        Operator::I8x16Add | Operator::I16x8Add | Operator::I32x4Add | Operator::I64x2Add => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().iadd(a, b))
+        }
+        Operator::I8x16AddSatS | Operator::I16x8AddSatS => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().sadd_sat(a, b))
+        }
+        Operator::I8x16AddSatU | Operator::I16x8AddSatU => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().uadd_sat(a, b))
+        }
+        Operator::I8x16Sub | Operator::I16x8Sub | Operator::I32x4Sub | Operator::I64x2Sub => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().isub(a, b))
+        }
+        Operator::I8x16SubSatS | Operator::I16x8SubSatS => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().ssub_sat(a, b))
+        }
+        Operator::I8x16SubSatU | Operator::I16x8SubSatU => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().usub_sat(a, b))
+        }
+        Operator::I8x16MinS | Operator::I16x8MinS | Operator::I32x4MinS => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().smin(a, b))
+        }
+        Operator::I8x16MinU | Operator::I16x8MinU | Operator::I32x4MinU => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().umin(a, b))
+        }
+        Operator::I8x16MaxS | Operator::I16x8MaxS | Operator::I32x4MaxS => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().smax(a, b))
+        }
+        Operator::I8x16MaxU | Operator::I16x8MaxU | Operator::I32x4MaxU => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().umax(a, b))
+        }
+        Operator::I8x16AvgrU | Operator::I16x8AvgrU => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().avg_round(a, b))
+        }
+        Operator::I8x16Neg | Operator::I16x8Neg | Operator::I32x4Neg | Operator::I64x2Neg => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().ineg(a))
+        }
+        Operator::I8x16Abs | Operator::I16x8Abs | Operator::I32x4Abs | Operator::I64x2Abs => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().iabs(a))
+        }
+        Operator::I16x8Mul | Operator::I32x4Mul | Operator::I64x2Mul => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().imul(a, b))
+        }
+        Operator::V128Or => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().bor(a, b))
+        }
+        Operator::V128Xor => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().bxor(a, b))
+        }
+        Operator::V128And => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().band(a, b))
+        }
+        Operator::V128AndNot => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().band_not(a, b))
+        }
+        Operator::V128Not => {
+            let a = state.pop1();
+            state.push1(builder.ins().bnot(a));
+        }
+        Operator::I8x16Shl | Operator::I16x8Shl | Operator::I32x4Shl | Operator::I64x2Shl => {
+            let (a, b) = state.pop2();
+            let bitcast_a = optionally_bitcast_vector(a, type_of(op), builder);
+            let bitwidth = i64::from(type_of(op).lane_bits());
+            // The spec expects to shift with `b mod lanewidth`; so, e.g., for 16 bit lane-width
+            // we do `b AND 15`; this means fewer instructions than `iconst + urem`.
+            let b_mod_bitwidth = builder.ins().band_imm(b, bitwidth - 1);
+            state.push1(builder.ins().ishl(bitcast_a, b_mod_bitwidth))
+        }
+        Operator::I8x16ShrU | Operator::I16x8ShrU | Operator::I32x4ShrU | Operator::I64x2ShrU => {
+            let (a, b) = state.pop2();
+            let bitcast_a = optionally_bitcast_vector(a, type_of(op), builder);
+            let bitwidth = i64::from(type_of(op).lane_bits());
+            // The spec expects to shift with `b mod lanewidth`; so, e.g., for 16 bit lane-width
+            // we do `b AND 15`; this means fewer instructions than `iconst + urem`.
+            let b_mod_bitwidth = builder.ins().band_imm(b, bitwidth - 1);
+            state.push1(builder.ins().ushr(bitcast_a, b_mod_bitwidth))
+        }
+        Operator::I8x16ShrS | Operator::I16x8ShrS | Operator::I32x4ShrS | Operator::I64x2ShrS => {
+            let (a, b) = state.pop2();
+            let bitcast_a = optionally_bitcast_vector(a, type_of(op), builder);
+            let bitwidth = i64::from(type_of(op).lane_bits());
+            // The spec expects to shift with `b mod lanewidth`; so, e.g., for 16 bit lane-width
+            // we do `b AND 15`; this means fewer instructions than `iconst + urem`.
+            let b_mod_bitwidth = builder.ins().band_imm(b, bitwidth - 1);
+            state.push1(builder.ins().sshr(bitcast_a, b_mod_bitwidth))
+        }
+        Operator::V128Bitselect => {
+            let (a, b, c) = state.pop3();
+            let bitcast_a = optionally_bitcast_vector(a, I8X16, builder);
+            let bitcast_b = optionally_bitcast_vector(b, I8X16, builder);
+            let bitcast_c = optionally_bitcast_vector(c, I8X16, builder);
+            // The CLIF operand ordering is slightly different and the types of all three
+            // operands must match (hence the bitcast).
+            state.push1(builder.ins().bitselect(bitcast_c, bitcast_a, bitcast_b))
+        }
+        Operator::V128AnyTrue => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            let bool_result = builder.ins().vany_true(a);
+            state.push1(builder.ins().uextend(I32, bool_result))
+        }
+        Operator::I8x16AllTrue
+        | Operator::I16x8AllTrue
+        | Operator::I32x4AllTrue
+        | Operator::I64x2AllTrue => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            let bool_result = builder.ins().vall_true(a);
+            state.push1(builder.ins().uextend(I32, bool_result))
+        }
+        Operator::I8x16Bitmask
+        | Operator::I16x8Bitmask
+        | Operator::I32x4Bitmask
+        | Operator::I64x2Bitmask => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().vhigh_bits(I32, a));
+        }
+        Operator::I8x16Eq | Operator::I16x8Eq | Operator::I32x4Eq | Operator::I64x2Eq => {
+            translate_vector_icmp(IntCC::Equal, type_of(op), builder, state)
+        }
+        Operator::I8x16Ne | Operator::I16x8Ne | Operator::I32x4Ne | Operator::I64x2Ne => {
+            translate_vector_icmp(IntCC::NotEqual, type_of(op), builder, state)
+        }
+        Operator::I8x16GtS | Operator::I16x8GtS | Operator::I32x4GtS | Operator::I64x2GtS => {
+            translate_vector_icmp(IntCC::SignedGreaterThan, type_of(op), builder, state)
+        }
+        Operator::I8x16LtS | Operator::I16x8LtS | Operator::I32x4LtS | Operator::I64x2LtS => {
+            translate_vector_icmp(IntCC::SignedLessThan, type_of(op), builder, state)
+        }
+        Operator::I8x16GtU | Operator::I16x8GtU | Operator::I32x4GtU => {
+            translate_vector_icmp(IntCC::UnsignedGreaterThan, type_of(op), builder, state)
+        }
+        Operator::I8x16LtU | Operator::I16x8LtU | Operator::I32x4LtU => {
+            translate_vector_icmp(IntCC::UnsignedLessThan, type_of(op), builder, state)
+        }
+        Operator::I8x16GeS | Operator::I16x8GeS | Operator::I32x4GeS | Operator::I64x2GeS => {
+            translate_vector_icmp(IntCC::SignedGreaterThanOrEqual, type_of(op), builder, state)
+        }
+        Operator::I8x16LeS | Operator::I16x8LeS | Operator::I32x4LeS | Operator::I64x2LeS => {
+            translate_vector_icmp(IntCC::SignedLessThanOrEqual, type_of(op), builder, state)
+        }
+        Operator::I8x16GeU | Operator::I16x8GeU | Operator::I32x4GeU => translate_vector_icmp(
+            IntCC::UnsignedGreaterThanOrEqual,
+            type_of(op),
+            builder,
+            state,
+        ),
+        Operator::I8x16LeU | Operator::I16x8LeU | Operator::I32x4LeU => {
+            translate_vector_icmp(IntCC::UnsignedLessThanOrEqual, type_of(op), builder, state)
+        }
+        Operator::F32x4Eq | Operator::F64x2Eq => {
+            translate_vector_fcmp(FloatCC::Equal, type_of(op), builder, state)
+        }
+        Operator::F32x4Ne | Operator::F64x2Ne => {
+            translate_vector_fcmp(FloatCC::NotEqual, type_of(op), builder, state)
+        }
+        Operator::F32x4Lt | Operator::F64x2Lt => {
+            translate_vector_fcmp(FloatCC::LessThan, type_of(op), builder, state)
+        }
+        Operator::F32x4Gt | Operator::F64x2Gt => {
+            translate_vector_fcmp(FloatCC::GreaterThan, type_of(op), builder, state)
+        }
+        Operator::F32x4Le | Operator::F64x2Le => {
+            translate_vector_fcmp(FloatCC::LessThanOrEqual, type_of(op), builder, state)
+        }
+        Operator::F32x4Ge | Operator::F64x2Ge => {
+            translate_vector_fcmp(FloatCC::GreaterThanOrEqual, type_of(op), builder, state)
+        }
+        Operator::F32x4Add | Operator::F64x2Add => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fadd(a, b))
+        }
+        Operator::F32x4Sub | Operator::F64x2Sub => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fsub(a, b))
+        }
+        Operator::F32x4Mul | Operator::F64x2Mul => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fmul(a, b))
+        }
+        Operator::F32x4Div | Operator::F64x2Div => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fdiv(a, b))
+        }
+        Operator::F32x4Max | Operator::F64x2Max => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fmax(a, b))
+        }
+        Operator::F32x4Min | Operator::F64x2Min => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fmin(a, b))
+        }
+        Operator::F32x4PMax | Operator::F64x2PMax => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fmax_pseudo(a, b))
+        }
+        Operator::F32x4PMin | Operator::F64x2PMin => {
+            let (a, b) = pop2_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fmin_pseudo(a, b))
+        }
+        Operator::F32x4Sqrt | Operator::F64x2Sqrt => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().sqrt(a))
+        }
+        Operator::F32x4Neg | Operator::F64x2Neg => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fneg(a))
+        }
+        Operator::F32x4Abs | Operator::F64x2Abs => {
+            let a = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().fabs(a))
+        }
+        Operator::F32x4ConvertI32x4S => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().fcvt_from_sint(F32X4, a))
+        }
+        Operator::F32x4ConvertI32x4U => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().fcvt_from_uint(F32X4, a))
+        }
+        Operator::F64x2ConvertLowI32x4S => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().fcvt_low_from_sint(F64X2, a));
+        }
+        Operator::F64x2ConvertLowI32x4U => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            let widened_a = builder.ins().uwiden_low(a);
+            state.push1(builder.ins().fcvt_from_uint(F64X2, widened_a));
+        }
+        Operator::F64x2PromoteLowF32x4 => {
+            let a = pop1_with_bitcast(state, F32X4, builder);
+            state.push1(builder.ins().fvpromote_low(a));
+        }
+        Operator::F32x4DemoteF64x2Zero => {
+            let a = pop1_with_bitcast(state, F64X2, builder);
+            state.push1(builder.ins().fvdemote(a));
+        }
+        Operator::I32x4TruncSatF32x4S => {
+            let a = pop1_with_bitcast(state, F32X4, builder);
+            state.push1(builder.ins().fcvt_to_sint_sat(I32X4, a))
+        }
+        Operator::I32x4TruncSatF64x2SZero => {
+            let a = pop1_with_bitcast(state, F64X2, builder);
+            let converted_a = builder.ins().fcvt_to_sint_sat(I64X2, a);
+            let handle = builder.func.dfg.constants.insert(vec![0u8; 16].into());
+            let zero = builder.ins().vconst(I64X2, handle);
+
+            state.push1(builder.ins().snarrow(converted_a, zero));
+        }
+        Operator::I32x4TruncSatF32x4U => {
+            let a = pop1_with_bitcast(state, F32X4, builder);
+            state.push1(builder.ins().fcvt_to_uint_sat(I32X4, a))
+        }
+        Operator::I32x4TruncSatF64x2UZero => {
+            let a = pop1_with_bitcast(state, F64X2, builder);
+            let converted_a = builder.ins().fcvt_to_uint_sat(I64X2, a);
+            let handle = builder.func.dfg.constants.insert(vec![0u8; 16].into());
+            let zero = builder.ins().vconst(I64X2, handle);
+
+            state.push1(builder.ins().uunarrow(converted_a, zero));
+        }
+        Operator::I8x16NarrowI16x8S => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().snarrow(a, b))
+        }
+        Operator::I16x8NarrowI32x4S => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().snarrow(a, b))
+        }
+        Operator::I8x16NarrowI16x8U => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().unarrow(a, b))
+        }
+        Operator::I16x8NarrowI32x4U => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().unarrow(a, b))
+        }
+        Operator::I16x8ExtendLowI8x16S => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            state.push1(builder.ins().swiden_low(a))
+        }
+        Operator::I16x8ExtendHighI8x16S => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            state.push1(builder.ins().swiden_high(a))
+        }
+        Operator::I16x8ExtendLowI8x16U => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            state.push1(builder.ins().uwiden_low(a))
+        }
+        Operator::I16x8ExtendHighI8x16U => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            state.push1(builder.ins().uwiden_high(a))
+        }
+        Operator::I32x4ExtendLowI16x8S => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().swiden_low(a))
+        }
+        Operator::I32x4ExtendHighI16x8S => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().swiden_high(a))
+        }
+        Operator::I32x4ExtendLowI16x8U => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().uwiden_low(a))
+        }
+        Operator::I32x4ExtendHighI16x8U => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().uwiden_high(a))
+        }
+
+        Operator::I64x2ExtendLowI32x4S => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().swiden_low(a))
+        }
+        Operator::I64x2ExtendHighI32x4S => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().swiden_high(a))
+        }
+        Operator::I64x2ExtendLowI32x4U => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().uwiden_low(a))
+        }
+        Operator::I64x2ExtendHighI32x4U => {
+            let a = pop1_with_bitcast(state, I32X4, builder);
+            state.push1(builder.ins().uwiden_high(a))
+        }
+        Operator::I16x8ExtAddPairwiseI8x16S => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            let widen_low = builder.ins().swiden_low(a);
+            let widen_high = builder.ins().swiden_high(a);
+            state.push1(builder.ins().iadd_pairwise(widen_low, widen_high));
+        }
+        Operator::I32x4ExtAddPairwiseI16x8S => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            let widen_low = builder.ins().swiden_low(a);
+            let widen_high = builder.ins().swiden_high(a);
+            state.push1(builder.ins().iadd_pairwise(widen_low, widen_high));
+        }
+        Operator::I16x8ExtAddPairwiseI8x16U => {
+            let a = pop1_with_bitcast(state, I8X16, builder);
+            let widen_low = builder.ins().uwiden_low(a);
+            let widen_high = builder.ins().uwiden_high(a);
+            state.push1(builder.ins().iadd_pairwise(widen_low, widen_high));
+        }
+        Operator::I32x4ExtAddPairwiseI16x8U => {
+            let a = pop1_with_bitcast(state, I16X8, builder);
+            let widen_low = builder.ins().uwiden_low(a);
+            let widen_high = builder.ins().uwiden_high(a);
+            state.push1(builder.ins().iadd_pairwise(widen_low, widen_high));
+        }
+        Operator::F32x4Ceil | Operator::F64x2Ceil => {
+            // This is something of a misuse of `type_of`, because that produces the return type
+            // of `op`.  In this case we want the arg type, but we know it's the same as the
+            // return type.  Same for the 3 cases below.
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().ceil(arg));
+        }
+        Operator::F32x4Floor | Operator::F64x2Floor => {
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().floor(arg));
+        }
+        Operator::F32x4Trunc | Operator::F64x2Trunc => {
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().trunc(arg));
+        }
+        Operator::F32x4Nearest | Operator::F64x2Nearest => {
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().nearest(arg));
+        }
+        Operator::I32x4DotI16x8S => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().widening_pairwise_dot_product_s(a, b));
+        }
+        Operator::I8x16Popcnt => {
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().popcnt(arg));
+        }
+        Operator::I16x8Q15MulrSatS => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            state.push1(builder.ins().sqmul_round_sat(a, b))
+        }
+        Operator::I16x8ExtMulLowI8x16S => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            let a_low = builder.ins().swiden_low(a);
+            let b_low = builder.ins().swiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I16x8ExtMulHighI8x16S => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            let a_high = builder.ins().swiden_high(a);
+            let b_high = builder.ins().swiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::I16x8ExtMulLowI8x16U => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            let a_low = builder.ins().uwiden_low(a);
+            let b_low = builder.ins().uwiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I16x8ExtMulHighI8x16U => {
+            let (a, b) = pop2_with_bitcast(state, I8X16, builder);
+            let a_high = builder.ins().uwiden_high(a);
+            let b_high = builder.ins().uwiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::I32x4ExtMulLowI16x8S => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            let a_low = builder.ins().swiden_low(a);
+            let b_low = builder.ins().swiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I32x4ExtMulHighI16x8S => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            let a_high = builder.ins().swiden_high(a);
+            let b_high = builder.ins().swiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::I32x4ExtMulLowI16x8U => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            let a_low = builder.ins().uwiden_low(a);
+            let b_low = builder.ins().uwiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I32x4ExtMulHighI16x8U => {
+            let (a, b) = pop2_with_bitcast(state, I16X8, builder);
+            let a_high = builder.ins().uwiden_high(a);
+            let b_high = builder.ins().uwiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::I64x2ExtMulLowI32x4S => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            let a_low = builder.ins().swiden_low(a);
+            let b_low = builder.ins().swiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I64x2ExtMulHighI32x4S => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            let a_high = builder.ins().swiden_high(a);
+            let b_high = builder.ins().swiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::I64x2ExtMulLowI32x4U => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            let a_low = builder.ins().uwiden_low(a);
+            let b_low = builder.ins().uwiden_low(b);
+            state.push1(builder.ins().imul(a_low, b_low));
+        }
+        Operator::I64x2ExtMulHighI32x4U => {
+            let (a, b) = pop2_with_bitcast(state, I32X4, builder);
+            let a_high = builder.ins().uwiden_high(a);
+            let b_high = builder.ins().uwiden_high(b);
+            state.push1(builder.ins().imul(a_high, b_high));
+        }
+        Operator::ReturnCall { .. } | Operator::ReturnCallIndirect { .. } => {
+            return Err(wasm_unsupported!("proposed tail-call operator {:?}", op));
+        }
+        Operator::I8x16RelaxedSwizzle
+        | Operator::I32x4RelaxedTruncF32x4S
+        | Operator::I32x4RelaxedTruncF32x4U
+        | Operator::I32x4RelaxedTruncF64x2SZero
+        | Operator::I32x4RelaxedTruncF64x2UZero
+        | Operator::F32x4RelaxedNmadd
+        | Operator::F32x4RelaxedMadd
+        | Operator::I8x16RelaxedLaneselect
+        | Operator::I16x8RelaxedLaneselect
+        | Operator::I32x4RelaxedLaneselect
+        | Operator::I64x2RelaxedLaneselect
+        | Operator::F32x4RelaxedMin
+        | Operator::F32x4RelaxedMax
+        | Operator::F64x2RelaxedMin
+        | Operator::F64x2RelaxedMax
+        | Operator::F64x2RelaxedMadd
+        | Operator::F64x2RelaxedNmadd
+        | Operator::I16x8RelaxedDotI8x16I7x16S
+        | Operator::I32x4RelaxedDotI8x16I7x16AddS
+        | Operator::I16x8RelaxedQ15mulrS => {
+            return Err(wasm_unsupported!("proposed relaxed-simd operator {:?}", op));
+        }
+        Operator::TryTable { .. } | Operator::ThrowRef => {
+            return Err(wasm_unsupported!(
+                "exceptions are not supported (operator: {op:?})"
+            ));
+        }
+        Operator::RefEq
+        | Operator::StructNew { .. }
+        | Operator::StructNewDefault { .. }
+        | Operator::StructGet { .. }
+        | Operator::StructGetS { .. }
+        | Operator::StructGetU { .. }
+        | Operator::StructSet { .. }
+        | Operator::ArrayNew { .. }
+        | Operator::ArrayNewDefault { .. }
+        | Operator::ArrayNewFixed { .. }
+        | Operator::ArrayNewData { .. }
+        | Operator::ArrayNewElem { .. }
+        | Operator::ArrayGet { .. }
+        | Operator::ArrayGetS { .. }
+        | Operator::ArrayGetU { .. }
+        | Operator::ArraySet { .. }
+        | Operator::ArrayLen
+        | Operator::ArrayFill { .. }
+        | Operator::ArrayCopy { .. }
+        | Operator::ArrayInitData { .. }
+        | Operator::ArrayInitElem { .. }
+        | Operator::RefTestNonNull { .. } => {}
+        Operator::RefTestNullable { .. }
+        | Operator::RefCastNonNull { .. }
+        | Operator::RefCastNullable { .. }
+        | Operator::BrOnCast { .. }
+        | Operator::BrOnCastFail { .. }
+        | Operator::AnyConvertExtern
+        | Operator::ExternConvertAny
+        | Operator::RefI31
+        | Operator::I31GetS
+        | Operator::I31GetU
+        | Operator::MemoryDiscard { .. }
+        | Operator::CallRef { .. }
+        | Operator::ReturnCallRef { .. }
+        | Operator::RefAsNonNull
+        | Operator::BrOnNull { .. }
+        | Operator::BrOnNonNull { .. } => {
+            return Err(wasm_unsupported!("GC proposal not (operator: {:?})", op));
+        }
+    };
+    Ok(())
+}
+
+// Clippy warns us of some fields we are deliberately ignoring
+#[allow(clippy::unneeded_field_pattern)]
+/// Deals with a Wasm instruction located in an unreachable portion of the code. Most of them
+/// are dropped but special ones like `End` or `Else` signal the potential end of the unreachable
+/// portion so the translation state must be updated accordingly.
+fn translate_unreachable_operator<FE: FuncEnvironment + ?Sized>(
+    module_translation_state: &ModuleTranslationState,
+    op: &Operator,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    debug_assert!(!state.reachable);
+    match *op {
+        Operator::If { blockty } => {
+            // Push a placeholder control stack entry. The if isn't reachable,
+            // so we don't have any branches anywhere.
+            state.push_if(
+                ir::Block::reserved_value(),
+                ElseData::NoElse {
+                    branch_inst: ir::Inst::reserved_value(),
+                },
+                0,
+                0,
+                blockty,
+            );
+        }
+        Operator::Loop { blockty: _ } | Operator::Block { blockty: _ } => {
+            state.push_block(ir::Block::reserved_value(), 0, 0);
+        }
+        Operator::Else => {
+            let i = state.control_stack.len() - 1;
+            match state.control_stack[i] {
+                ControlStackFrame::If {
+                    ref else_data,
+                    head_is_reachable,
+                    ref mut consequent_ends_reachable,
+                    blocktype,
+                    ..
+                } => {
+                    debug_assert!(consequent_ends_reachable.is_none());
+                    *consequent_ends_reachable = Some(state.reachable);
+
+                    if head_is_reachable {
+                        // We have a branch from the head of the `if` to the `else`.
+                        state.reachable = true;
+
+                        let else_block = match *else_data {
+                            ElseData::NoElse { branch_inst } => {
+                                let (params, _results) = module_translation_state
+                                    .blocktype_params_results(&blocktype)?;
+                                let else_block =
+                                    block_with_params(builder, params.iter(), environ)?;
+                                let frame = state.control_stack.last().unwrap();
+                                frame.truncate_value_stack_to_else_params(&mut state.stack);
+
+                                // We change the target of the branch instruction.
+                                builder.change_jump_destination(branch_inst, else_block);
+                                builder.seal_block(else_block);
+                                else_block
+                            }
+                            ElseData::WithElse { else_block } => {
+                                let frame = state.control_stack.last().unwrap();
+                                frame.truncate_value_stack_to_else_params(&mut state.stack);
+                                else_block
+                            }
+                        };
+
+                        builder.switch_to_block(else_block);
+
+                        // Again, no need to push the parameters for the `else`,
+                        // since we already did when we saw the original `if`. See
+                        // the comment for translating `Operator::Else` in
+                        // `translate_operator` for details.
+                    }
+                }
+                _ => unreachable!(),
+            }
+        }
+        Operator::End => {
+            let stack = &mut state.stack;
+            let control_stack = &mut state.control_stack;
+            let frame = control_stack.pop().unwrap();
+
+            // Pop unused parameters from stack.
+            frame.truncate_value_stack_to_original_size(stack);
+
+            let reachable_anyway = match frame {
+                // If it is a loop we also have to seal the body loop block
+                ControlStackFrame::Loop { header, .. } => {
+                    builder.seal_block(header);
+                    // And loops can't have branches to the end.
+                    false
+                }
+                // If we never set `consequent_ends_reachable` then that means
+                // we are finishing the consequent now, and there was no
+                // `else`. Whether the following block is reachable depends only
+                // on if the head was reachable.
+                ControlStackFrame::If {
+                    head_is_reachable,
+                    consequent_ends_reachable: None,
+                    ..
+                } => head_is_reachable,
+                // Since we are only in this function when in unreachable code,
+                // we know that the alternative just ended unreachable. Whether
+                // the following block is reachable depends on if the consequent
+                // ended reachable or not.
+                ControlStackFrame::If {
+                    head_is_reachable,
+                    consequent_ends_reachable: Some(consequent_ends_reachable),
+                    ..
+                } => head_is_reachable && consequent_ends_reachable,
+                // All other control constructs are already handled.
+                _ => false,
+            };
+
+            if frame.exit_is_branched_to() || reachable_anyway {
+                builder.switch_to_block(frame.following_code());
+                builder.seal_block(frame.following_code());
+
+                // And add the return values of the block but only if the next block is reachable
+                // (which corresponds to testing if the stack depth is 1)
+                stack.extend_from_slice(builder.block_params(frame.following_code()));
+                state.reachable = true;
+            }
+        }
+        _ => {
+            // We don't translate because this is unreachable code
+        }
+    }
+
+    Ok(())
+}
+
+/// Get the address+offset to use for a heap access.
+fn get_heap_addr(
+    heap: ir::Heap,
+    addr32: ir::Value,
+    offset: u32,
+    width: u32,
+    addr_ty: Type,
+    builder: &mut FunctionBuilder,
+) -> (ir::Value, i32) {
+    let offset_guard_size: u64 = builder.func.heaps[heap].offset_guard_size.into();
+
+    // How exactly the bounds check is performed here and what it's performed
+    // on is a bit tricky. Generally we want to rely on access violations (e.g.
+    // segfaults) to generate traps since that means we don't have to bounds
+    // check anything explicitly.
+    //
+    // If we don't have a guard page of unmapped memory, though, then we can't
+    // rely on this trapping behavior through segfaults. Instead we need to
+    // bounds-check the entire memory access here which is everything from
+    // `addr32 + offset` to `addr32 + offset + width` (not inclusive). In this
+    // scenario our adjusted offset that we're checking is `offset + width`.
+    //
+    // If we have a guard page, however, then we can perform a further
+    // optimization of the generated code by only checking multiples of the
+    // offset-guard size to be more CSE-friendly. Knowing that we have at least
+    // 1 page of a guard page we're then able to disregard the `width` since we
+    // know it's always less than one page. Our bounds check will be for the
+    // first byte which will either succeed and be guaranteed to fault if it's
+    // actually out of bounds, or the bounds check itself will fail. In any case
+    // we assert that the width is reasonably small for now so this assumption
+    // can be adjusted in the future if we get larger widths.
+    //
+    // Put another way we can say, where `y < offset_guard_size`:
+    //
+    //      n * offset_guard_size + y = offset
+    //
+    // We'll then pass `n * offset_guard_size` as the bounds check value. If
+    // this traps then our `offset` would have trapped anyway. If this check
+    // passes we know
+    //
+    //      addr32 + n * offset_guard_size < bound
+    //
+    // which means
+    //
+    //      addr32 + n * offset_guard_size + y < bound + offset_guard_size
+    //
+    // because `y < offset_guard_size`, which then means:
+    //
+    //      addr32 + offset < bound + offset_guard_size
+    //
+    // Since we know that that guard size bytes are all unmapped we're
+    // guaranteed that `offset` and the `width` bytes after it are either
+    // in-bounds or will hit the guard page, meaning we'll get the desired
+    // semantics we want.
+    //
+    // As one final comment on the bits with the guard size here, another goal
+    // of this is to hit an optimization in `heap_addr` where if the heap size
+    // minus the offset is >= 4GB then bounds checks are 100% eliminated. This
+    // means that with huge guard regions (e.g. our 2GB default) most adjusted
+    // offsets we're checking here are zero. This means that we'll hit the fast
+    // path and emit zero conditional traps for bounds checks
+    let adjusted_offset = if offset_guard_size == 0 {
+        u64::from(offset) + u64::from(width)
+    } else {
+        assert!(width < 1024);
+        cmp::max(u64::from(offset) / offset_guard_size * offset_guard_size, 1)
+    };
+    debug_assert!(adjusted_offset > 0); // want to bounds check at least 1 byte
+    let check_size = u32::try_from(adjusted_offset).unwrap_or(u32::MAX);
+    let base = builder
+        .ins()
+        .heap_addr(addr_ty, heap, addr32, 0u32, check_size as u8);
+
+    // Native load/store instructions take a signed `Offset32` immediate, so adjust the base
+    // pointer if necessary.
+    if offset > i32::MAX as u32 {
+        // Offset doesn't fit in the load/store instruction.
+        let adj = builder.ins().iadd_imm(base, i64::from(i32::MAX) + 1);
+        (adj, (offset - (i32::MAX as u32 + 1)) as i32)
+    } else {
+        (base, offset as i32)
+    }
+}
+
+/// Prepare for a load; factors out common functionality between load and load_extend operations.
+fn prepare_load<FE: FuncEnvironment + ?Sized>(
+    memarg: &MemArg,
+    loaded_bytes: u32,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<(MemFlags, Value, Offset32)> {
+    let addr32 = state.pop1();
+
+    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
+    let (base, offset) = get_heap_addr(
+        heap,
+        addr32,
+        memarg.offset as u32,
+        loaded_bytes,
+        environ.pointer_type(),
+        builder,
+    );
+
+    // Note that we don't set `is_aligned` here, even if the load instruction's
+    // alignment immediate says it's aligned, because WebAssembly's immediate
+    // field is just a hint, while Cranelift's aligned flag needs a guarantee.
+    // WebAssembly memory accesses are always little-endian.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+
+    Ok((flags, base, offset.into()))
+}
+
+/// Translate a load instruction.
+fn translate_load<FE: FuncEnvironment + ?Sized>(
+    memarg: &MemArg,
+    opcode: ir::Opcode,
+    result_ty: Type,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let (flags, base, offset) = prepare_load(
+        memarg,
+        mem_op_size(opcode, result_ty),
+        builder,
+        state,
+        environ,
+    )?;
+    let (load, dfg) = builder.ins().Load(opcode, result_ty, flags, offset, base);
+    state.push1(dfg.first_result(load));
+    Ok(())
+}
+
+/// Translate a store instruction.
+fn translate_store<FE: FuncEnvironment + ?Sized>(
+    memarg: &MemArg,
+    opcode: ir::Opcode,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let (addr32, val) = state.pop2();
+    let val_ty = builder.func.dfg.value_type(val);
+
+    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
+    let (base, offset) = get_heap_addr(
+        heap,
+        addr32,
+        memarg.offset as u32,
+        mem_op_size(opcode, val_ty),
+        environ.pointer_type(),
+        builder,
+    );
+    // See the comments in `prepare_load` about the flags.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+    builder
+        .ins()
+        .Store(opcode, val_ty, flags, offset.into(), val, base);
+    Ok(())
+}
+
+fn mem_op_size(opcode: ir::Opcode, ty: Type) -> u32 {
+    match opcode {
+        ir::Opcode::Istore8 | ir::Opcode::Sload8 | ir::Opcode::Uload8 => 1,
+        ir::Opcode::Istore16 | ir::Opcode::Sload16 | ir::Opcode::Uload16 => 2,
+        ir::Opcode::Istore32 | ir::Opcode::Sload32 | ir::Opcode::Uload32 => 4,
+        ir::Opcode::Store | ir::Opcode::Load => ty.bytes(),
+        _ => panic!("unknown size of mem op for {:?}", opcode),
+    }
+}
+
+fn translate_icmp(cc: IntCC, builder: &mut FunctionBuilder, state: &mut FuncTranslationState) {
+    let (arg0, arg1) = state.pop2();
+    let val = builder.ins().icmp(cc, arg0, arg1);
+    state.push1(builder.ins().uextend(I32, val));
+}
+
+fn fold_atomic_mem_addr(
+    linear_mem_addr: Value,
+    memarg: &MemArg,
+    access_ty: Type,
+    builder: &mut FunctionBuilder,
+) -> Value {
+    let access_ty_bytes = access_ty.bytes();
+    let final_lma = if memarg.offset > 0 {
+        assert!(builder.func.dfg.value_type(linear_mem_addr) == I32);
+        let linear_mem_addr = builder.ins().uextend(I64, linear_mem_addr);
+        let a = builder
+            .ins()
+            .iadd_imm(linear_mem_addr, memarg.offset as i64);
+        let r = builder
+            .ins()
+            .icmp_imm(IntCC::UnsignedGreaterThanOrEqual, a, 0x1_0000_0000i64);
+        builder.ins().trapnz(r, ir::TrapCode::HeapOutOfBounds);
+        builder.ins().ireduce(I32, a)
+    } else {
+        linear_mem_addr
+    };
+    assert!(access_ty_bytes == 4 || access_ty_bytes == 8);
+    let final_lma_misalignment = builder
+        .ins()
+        .band_imm(final_lma, i64::from(access_ty_bytes - 1));
+    let f = builder
+        .ins()
+        .icmp_imm(IntCC::Equal, final_lma_misalignment, i64::from(0));
+    builder.ins().trapz(f, ir::TrapCode::HeapMisaligned);
+    final_lma
+}
+
+// For an atomic memory operation, emit an alignment check for the linear memory address,
+// and then compute the final effective address.
+fn finalise_atomic_mem_addr<FE: FuncEnvironment + ?Sized>(
+    linear_mem_addr: Value,
+    memarg: &MemArg,
+    access_ty: Type,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<Value> {
+    let access_ty_bytes = access_ty.bytes();
+    let final_lma = if memarg.offset > 0 {
+        assert!(builder.func.dfg.value_type(linear_mem_addr) == I32);
+        let linear_mem_addr = builder.ins().uextend(I64, linear_mem_addr);
+        let a = builder
+            .ins()
+            .iadd_imm(linear_mem_addr, memarg.offset as i64);
+        let r = builder
+            .ins()
+            .icmp_imm(IntCC::UnsignedGreaterThanOrEqual, a, 0x1_0000_0000i64);
+        builder.ins().trapnz(r, ir::TrapCode::HeapOutOfBounds);
+        builder.ins().ireduce(I32, a)
+    } else {
+        linear_mem_addr
+    };
+    // Check the alignment of `linear_mem_addr`.
+    if access_ty_bytes != 1 {
+        assert!(access_ty_bytes == 2 || access_ty_bytes == 4 || access_ty_bytes == 8);
+        let final_lma_misalignment = builder
+            .ins()
+            .band_imm(final_lma, i64::from(access_ty_bytes - 1));
+        let f = builder
+            .ins()
+            .icmp_imm(IntCC::Equal, final_lma_misalignment, i64::from(0));
+        builder.ins().trapz(f, ir::TrapCode::HeapMisaligned);
+    }
+
+    // Compute the final effective address.
+    let heap = state.get_heap(builder.func, memarg.memory, environ)?;
+    let (base, offset) = get_heap_addr(
+        heap,
+        final_lma,
+        /*offset=*/ 0,
+        access_ty.bytes(),
+        environ.pointer_type(),
+        builder,
+    );
+
+    let final_effective_address = builder.ins().iadd_imm(base, i64::from(offset));
+    Ok(final_effective_address)
+}
+
+fn translate_atomic_rmw<FE: FuncEnvironment + ?Sized>(
+    widened_ty: Type,
+    access_ty: Type,
+    op: AtomicRmwOp,
+    memarg: &MemArg,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let (linear_mem_addr, mut arg2) = state.pop2();
+    let arg2_ty = builder.func.dfg.value_type(arg2);
+
+    // The operation is performed at type `access_ty`, and the old value is zero-extended
+    // to type `widened_ty`.
+    match access_ty {
+        I8 | I16 | I32 | I64 => {}
+        _ => {
+            return Err(wasm_unsupported!(
+                "atomic_rmw: unsupported access type {:?}",
+                access_ty
+            ))
+        }
+    };
+    let w_ty_ok = matches!(widened_ty, I32 | I64);
+    assert!(w_ty_ok && widened_ty.bytes() >= access_ty.bytes());
+
+    assert!(arg2_ty.bytes() >= access_ty.bytes());
+    if arg2_ty.bytes() > access_ty.bytes() {
+        arg2 = builder.ins().ireduce(access_ty, arg2);
+    }
+
+    let final_effective_address =
+        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
+
+    // See the comments in `prepare_load` about the flags.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+    let mut res = builder
+        .ins()
+        .atomic_rmw(access_ty, flags, op, final_effective_address, arg2);
+    if access_ty != widened_ty {
+        res = builder.ins().uextend(widened_ty, res);
+    }
+    state.push1(res);
+    Ok(())
+}
+
+fn translate_atomic_cas<FE: FuncEnvironment + ?Sized>(
+    widened_ty: Type,
+    access_ty: Type,
+    memarg: &MemArg,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let (linear_mem_addr, mut expected, mut replacement) = state.pop3();
+    let expected_ty = builder.func.dfg.value_type(expected);
+    let replacement_ty = builder.func.dfg.value_type(replacement);
+
+    // The compare-and-swap is performed at type `access_ty`, and the old value is zero-extended
+    // to type `widened_ty`.
+    match access_ty {
+        I8 | I16 | I32 | I64 => {}
+        _ => {
+            return Err(wasm_unsupported!(
+                "atomic_cas: unsupported access type {:?}",
+                access_ty
+            ))
+        }
+    };
+    let w_ty_ok = matches!(widened_ty, I32 | I64);
+    assert!(w_ty_ok && widened_ty.bytes() >= access_ty.bytes());
+
+    assert!(expected_ty.bytes() >= access_ty.bytes());
+    if expected_ty.bytes() > access_ty.bytes() {
+        expected = builder.ins().ireduce(access_ty, expected);
+    }
+    assert!(replacement_ty.bytes() >= access_ty.bytes());
+    if replacement_ty.bytes() > access_ty.bytes() {
+        replacement = builder.ins().ireduce(access_ty, replacement);
+    }
+
+    let final_effective_address =
+        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
+
+    // See the comments in `prepare_load` about the flags.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+    let mut res = builder
+        .ins()
+        .atomic_cas(flags, final_effective_address, expected, replacement);
+    if access_ty != widened_ty {
+        res = builder.ins().uextend(widened_ty, res);
+    }
+    state.push1(res);
+    Ok(())
+}
+
+fn translate_atomic_load<FE: FuncEnvironment + ?Sized>(
+    widened_ty: Type,
+    access_ty: Type,
+    memarg: &MemArg,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let linear_mem_addr = state.pop1();
+
+    // The load is performed at type `access_ty`, and the loaded value is zero extended
+    // to `widened_ty`.
+    match access_ty {
+        I8 | I16 | I32 | I64 => {}
+        _ => {
+            return Err(wasm_unsupported!(
+                "atomic_load: unsupported access type {:?}",
+                access_ty
+            ))
+        }
+    };
+    let w_ty_ok = matches!(widened_ty, I32 | I64);
+    assert!(w_ty_ok && widened_ty.bytes() >= access_ty.bytes());
+
+    let final_effective_address =
+        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
+
+    // See the comments in `prepare_load` about the flags.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+    let mut res = builder
+        .ins()
+        .atomic_load(access_ty, flags, final_effective_address);
+    if access_ty != widened_ty {
+        res = builder.ins().uextend(widened_ty, res);
+    }
+    state.push1(res);
+    Ok(())
+}
+
+fn translate_atomic_store<FE: FuncEnvironment + ?Sized>(
+    access_ty: Type,
+    memarg: &MemArg,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let (linear_mem_addr, mut data) = state.pop2();
+    let data_ty = builder.func.dfg.value_type(data);
+
+    // The operation is performed at type `access_ty`, and the data to be stored may first
+    // need to be narrowed accordingly.
+    match access_ty {
+        I8 | I16 | I32 | I64 => {}
+        _ => {
+            return Err(wasm_unsupported!(
+                "atomic_store: unsupported access type {:?}",
+                access_ty
+            ))
+        }
+    };
+    let d_ty_ok = matches!(data_ty, I32 | I64);
+    assert!(d_ty_ok && data_ty.bytes() >= access_ty.bytes());
+
+    if data_ty.bytes() > access_ty.bytes() {
+        data = builder.ins().ireduce(access_ty, data);
+    }
+
+    let final_effective_address =
+        finalise_atomic_mem_addr(linear_mem_addr, memarg, access_ty, builder, state, environ)?;
+
+    // See the comments in `prepare_load` about the flags.
+    let mut flags = MemFlags::new();
+    flags.set_endianness(ir::Endianness::Little);
+    builder
+        .ins()
+        .atomic_store(flags, data, final_effective_address);
+    Ok(())
+}
+
+fn translate_vector_icmp(
+    cc: IntCC,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+) {
+    let (a, b) = state.pop2();
+    let bitcast_a = optionally_bitcast_vector(a, needed_type, builder);
+    let bitcast_b = optionally_bitcast_vector(b, needed_type, builder);
+    state.push1(builder.ins().icmp(cc, bitcast_a, bitcast_b))
+}
+
+fn translate_fcmp(cc: FloatCC, builder: &mut FunctionBuilder, state: &mut FuncTranslationState) {
+    let (arg0, arg1) = state.pop2();
+    let val = builder.ins().fcmp(cc, arg0, arg1);
+    state.push1(builder.ins().uextend(I32, val));
+}
+
+fn translate_vector_fcmp(
+    cc: FloatCC,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+) {
+    let (a, b) = state.pop2();
+    let bitcast_a = optionally_bitcast_vector(a, needed_type, builder);
+    let bitcast_b = optionally_bitcast_vector(b, needed_type, builder);
+    state.push1(builder.ins().fcmp(cc, bitcast_a, bitcast_b))
+}
+
+fn translate_br_if(
+    relative_depth: u32,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+) {
+    let val = state.pop1();
+    let (br_destination, inputs) = translate_br_if_args(relative_depth, state);
+    canonicalise_then_brnz(builder, val, br_destination, inputs);
+
+    let next_block = builder.create_block();
+    canonicalise_then_jump(builder, next_block, &[]);
+    builder.seal_block(next_block); // The only predecessor is the current block.
+    builder.switch_to_block(next_block);
+}
+
+fn translate_br_if_args(
+    relative_depth: u32,
+    state: &mut FuncTranslationState,
+) -> (ir::Block, &mut [ir::Value]) {
+    let i = state.control_stack.len() - 1 - (relative_depth as usize);
+    let (return_count, br_destination) = {
+        let frame = &mut state.control_stack[i];
+        // The values returned by the branch are still available for the reachable
+        // code that comes after it
+        frame.set_branched_to_exit();
+        let return_count = if frame.is_loop() {
+            frame.num_param_values()
+        } else {
+            frame.num_return_values()
+        };
+        (return_count, frame.br_destination())
+    };
+    let inputs = state.peekn_mut(return_count);
+    (br_destination, inputs)
+}
+
+/// Determine the returned value type of a WebAssembly operator
+fn type_of(operator: &Operator) -> Type {
+    match operator {
+        Operator::V128Load { .. }
+        | Operator::V128Store { .. }
+        | Operator::V128Const { .. }
+        | Operator::V128Not
+        | Operator::V128And
+        | Operator::V128AndNot
+        | Operator::V128Or
+        | Operator::V128Xor
+        | Operator::V128AnyTrue
+        | Operator::V128Bitselect => I8X16, // default type representing V128
+
+        Operator::I8x16Shuffle { .. }
+        | Operator::I8x16Splat
+        | Operator::V128Load8Splat { .. }
+        | Operator::V128Load8Lane { .. }
+        | Operator::V128Store8Lane { .. }
+        | Operator::I8x16ExtractLaneS { .. }
+        | Operator::I8x16ExtractLaneU { .. }
+        | Operator::I8x16ReplaceLane { .. }
+        | Operator::I8x16Eq
+        | Operator::I8x16Ne
+        | Operator::I8x16LtS
+        | Operator::I8x16LtU
+        | Operator::I8x16GtS
+        | Operator::I8x16GtU
+        | Operator::I8x16LeS
+        | Operator::I8x16LeU
+        | Operator::I8x16GeS
+        | Operator::I8x16GeU
+        | Operator::I8x16Neg
+        | Operator::I8x16Abs
+        | Operator::I8x16AllTrue
+        | Operator::I8x16Shl
+        | Operator::I8x16ShrS
+        | Operator::I8x16ShrU
+        | Operator::I8x16Add
+        | Operator::I8x16AddSatS
+        | Operator::I8x16AddSatU
+        | Operator::I8x16Sub
+        | Operator::I8x16SubSatS
+        | Operator::I8x16SubSatU
+        | Operator::I8x16MinS
+        | Operator::I8x16MinU
+        | Operator::I8x16MaxS
+        | Operator::I8x16MaxU
+        | Operator::I8x16AvgrU
+        | Operator::I8x16Bitmask
+        | Operator::I8x16Popcnt => I8X16,
+
+        Operator::I16x8Splat
+        | Operator::V128Load16Splat { .. }
+        | Operator::V128Load16Lane { .. }
+        | Operator::V128Store16Lane { .. }
+        | Operator::I16x8ExtractLaneS { .. }
+        | Operator::I16x8ExtractLaneU { .. }
+        | Operator::I16x8ReplaceLane { .. }
+        | Operator::I16x8Eq
+        | Operator::I16x8Ne
+        | Operator::I16x8LtS
+        | Operator::I16x8LtU
+        | Operator::I16x8GtS
+        | Operator::I16x8GtU
+        | Operator::I16x8LeS
+        | Operator::I16x8LeU
+        | Operator::I16x8GeS
+        | Operator::I16x8GeU
+        | Operator::I16x8Neg
+        | Operator::I16x8Abs
+        | Operator::I16x8AllTrue
+        | Operator::I16x8Shl
+        | Operator::I16x8ShrS
+        | Operator::I16x8ShrU
+        | Operator::I16x8Add
+        | Operator::I16x8AddSatS
+        | Operator::I16x8AddSatU
+        | Operator::I16x8Sub
+        | Operator::I16x8SubSatS
+        | Operator::I16x8SubSatU
+        | Operator::I16x8MinS
+        | Operator::I16x8MinU
+        | Operator::I16x8MaxS
+        | Operator::I16x8MaxU
+        | Operator::I16x8AvgrU
+        | Operator::I16x8Mul
+        | Operator::I16x8Bitmask => I16X8,
+
+        Operator::I32x4Splat
+        | Operator::V128Load32Splat { .. }
+        | Operator::V128Load32Lane { .. }
+        | Operator::V128Store32Lane { .. }
+        | Operator::I32x4ExtractLane { .. }
+        | Operator::I32x4ReplaceLane { .. }
+        | Operator::I32x4Eq
+        | Operator::I32x4Ne
+        | Operator::I32x4LtS
+        | Operator::I32x4LtU
+        | Operator::I32x4GtS
+        | Operator::I32x4GtU
+        | Operator::I32x4LeS
+        | Operator::I32x4LeU
+        | Operator::I32x4GeS
+        | Operator::I32x4GeU
+        | Operator::I32x4Neg
+        | Operator::I32x4Abs
+        | Operator::I32x4AllTrue
+        | Operator::I32x4Shl
+        | Operator::I32x4ShrS
+        | Operator::I32x4ShrU
+        | Operator::I32x4Add
+        | Operator::I32x4Sub
+        | Operator::I32x4Mul
+        | Operator::I32x4MinS
+        | Operator::I32x4MinU
+        | Operator::I32x4MaxS
+        | Operator::I32x4MaxU
+        | Operator::I32x4Bitmask
+        | Operator::I32x4TruncSatF32x4S
+        | Operator::I32x4TruncSatF32x4U
+        | Operator::V128Load32Zero { .. } => I32X4,
+
+        Operator::I64x2Splat
+        | Operator::V128Load64Splat { .. }
+        | Operator::V128Load64Lane { .. }
+        | Operator::V128Store64Lane { .. }
+        | Operator::I64x2ExtractLane { .. }
+        | Operator::I64x2ReplaceLane { .. }
+        | Operator::I64x2Eq
+        | Operator::I64x2Ne
+        | Operator::I64x2LtS
+        | Operator::I64x2GtS
+        | Operator::I64x2LeS
+        | Operator::I64x2GeS
+        | Operator::I64x2Neg
+        | Operator::I64x2Abs
+        | Operator::I64x2AllTrue
+        | Operator::I64x2Shl
+        | Operator::I64x2ShrS
+        | Operator::I64x2ShrU
+        | Operator::I64x2Add
+        | Operator::I64x2Sub
+        | Operator::I64x2Mul
+        | Operator::I64x2Bitmask
+        | Operator::V128Load64Zero { .. } => I64X2,
+
+        Operator::F32x4Splat
+        | Operator::F32x4ExtractLane { .. }
+        | Operator::F32x4ReplaceLane { .. }
+        | Operator::F32x4Eq
+        | Operator::F32x4Ne
+        | Operator::F32x4Lt
+        | Operator::F32x4Gt
+        | Operator::F32x4Le
+        | Operator::F32x4Ge
+        | Operator::F32x4Abs
+        | Operator::F32x4Neg
+        | Operator::F32x4Sqrt
+        | Operator::F32x4Add
+        | Operator::F32x4Sub
+        | Operator::F32x4Mul
+        | Operator::F32x4Div
+        | Operator::F32x4Min
+        | Operator::F32x4Max
+        | Operator::F32x4PMin
+        | Operator::F32x4PMax
+        | Operator::F32x4ConvertI32x4S
+        | Operator::F32x4ConvertI32x4U
+        | Operator::F32x4Ceil
+        | Operator::F32x4Floor
+        | Operator::F32x4Trunc
+        | Operator::F32x4Nearest => F32X4,
+
+        Operator::F64x2Splat
+        | Operator::F64x2ExtractLane { .. }
+        | Operator::F64x2ReplaceLane { .. }
+        | Operator::F64x2Eq
+        | Operator::F64x2Ne
+        | Operator::F64x2Lt
+        | Operator::F64x2Gt
+        | Operator::F64x2Le
+        | Operator::F64x2Ge
+        | Operator::F64x2Abs
+        | Operator::F64x2Neg
+        | Operator::F64x2Sqrt
+        | Operator::F64x2Add
+        | Operator::F64x2Sub
+        | Operator::F64x2Mul
+        | Operator::F64x2Div
+        | Operator::F64x2Min
+        | Operator::F64x2Max
+        | Operator::F64x2PMin
+        | Operator::F64x2PMax
+        | Operator::F64x2Ceil
+        | Operator::F64x2Floor
+        | Operator::F64x2Trunc
+        | Operator::F64x2Nearest => F64X2,
+
+        _ => unimplemented!(
+            "Currently only SIMD instructions are mapped to their return type; the \
+             following instruction is not mapped: {:?}",
+            operator
+        ),
+    }
+}
+
+/// Some SIMD operations only operate on I8X16 in CLIF; this will convert them to that type by
+/// adding a raw_bitcast if necessary.
+fn optionally_bitcast_vector(
+    value: Value,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+) -> Value {
+    if builder.func.dfg.value_type(value) != needed_type {
+        builder.ins().bitcast(
+            needed_type,
+            MemFlags::new().with_endianness(ir::Endianness::Little),
+            value,
+        )
+    } else {
+        value
+    }
+}
+
+#[inline(always)]
+fn is_non_canonical_v128(ty: ir::Type) -> bool {
+    matches!(ty, I64X2 | I32X4 | I16X8 | F32X4 | F64X2)
+}
+
+/// Cast to I8X16, any vector values in `values` that are of "non-canonical" type (meaning, not
+/// I8X16), and return them in a slice.  A pre-scan is made to determine whether any casts are
+/// actually necessary, and if not, the original slice is returned.  Otherwise the cast values
+/// are returned in a slice that belongs to the caller-supplied `SmallVec`.
+fn canonicalise_v128_values<'a>(
+    tmp_canonicalised: &'a mut SmallVec<[ir::Value; 16]>,
+    builder: &mut FunctionBuilder,
+    values: &'a [ir::Value],
+) -> &'a [ir::Value] {
+    debug_assert!(tmp_canonicalised.is_empty());
+    // First figure out if any of the parameters need to be cast.  Mostly they don't need to be.
+    let any_non_canonical = values
+        .iter()
+        .any(|v| is_non_canonical_v128(builder.func.dfg.value_type(*v)));
+    // Hopefully we take this exit most of the time, hence doing no heap allocation.
+    if !any_non_canonical {
+        return values;
+    }
+    // Otherwise we'll have to cast, and push the resulting `Value`s into `canonicalised`.
+    for v in values {
+        tmp_canonicalised.push(if is_non_canonical_v128(builder.func.dfg.value_type(*v)) {
+            builder.ins().bitcast(
+                I8X16,
+                MemFlags::new().with_endianness(ir::Endianness::Little),
+                *v,
+            )
+        } else {
+            *v
+        });
+    }
+    tmp_canonicalised.as_slice()
+}
+
+/// Generate a `jump` instruction, but first cast all 128-bit vector values to I8X16 if they
+/// don't have that type.  This is done in somewhat roundabout way so as to ensure that we
+/// almost never have to do any heap allocation.
+fn canonicalise_then_jump(
+    builder: &mut FunctionBuilder,
+    destination: ir::Block,
+    params: &[ir::Value],
+) -> ir::Inst {
+    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
+    let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
+    builder.ins().jump(destination, canonicalised)
+}
+
+/// The same but for a `brz` instruction.
+fn canonicalise_then_brz(
+    builder: &mut FunctionBuilder,
+    cond: ir::Value,
+    destination: ir::Block,
+    params: &[ir::Value],
+) -> ir::Inst {
+    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
+    let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
+    builder.ins().brz(cond, destination, canonicalised)
+}
+
+/// The same but for a `brnz` instruction.
+fn canonicalise_then_brnz(
+    builder: &mut FunctionBuilder,
+    cond: ir::Value,
+    destination: ir::Block,
+    params: &[ir::Value],
+) -> ir::Inst {
+    let mut tmp_canonicalised = SmallVec::<[ir::Value; 16]>::new();
+    let canonicalised = canonicalise_v128_values(&mut tmp_canonicalised, builder, params);
+    builder.ins().brnz(cond, destination, canonicalised)
+}
+
+/// A helper for popping and bitcasting a single value; since SIMD values can lose their type by
+/// using v128 (i.e. CLIF's I8x16) we must re-type the values using a bitcast to avoid CLIF
+/// typing issues.
+fn pop1_with_bitcast(
+    state: &mut FuncTranslationState,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+) -> Value {
+    optionally_bitcast_vector(state.pop1(), needed_type, builder)
+}
+
+/// A helper for popping and bitcasting two values; since SIMD values can lose their type by
+/// using v128 (i.e. CLIF's I8x16) we must re-type the values using a bitcast to avoid CLIF
+/// typing issues.
+fn pop2_with_bitcast(
+    state: &mut FuncTranslationState,
+    needed_type: Type,
+    builder: &mut FunctionBuilder,
+) -> (Value, Value) {
+    let (a, b) = state.pop2();
+    let bitcast_a = optionally_bitcast_vector(a, needed_type, builder);
+    let bitcast_b = optionally_bitcast_vector(b, needed_type, builder);
+    (bitcast_a, bitcast_b)
+}
+
+/// A helper for bitcasting a sequence of values (e.g. function arguments). If a value is a
+/// vector type that does not match its expected type, this will modify the value in place to point
+/// to the result of a `raw_bitcast`. This conversion is necessary to translate Wasm code that
+/// uses `V128` as function parameters (or implicitly in block parameters) and still use specific
+/// CLIF types (e.g. `I32X4`) in the function body.
+pub fn bitcast_arguments(
+    arguments: &mut [Value],
+    expected_types: &[Type],
+    builder: &mut FunctionBuilder,
+) {
+    assert_eq!(arguments.len(), expected_types.len());
+    for (i, t) in expected_types.iter().enumerate() {
+        if t.is_vector() {
+            assert!(
+                builder.func.dfg.value_type(arguments[i]).is_vector(),
+                "unexpected type mismatch: expected {}, argument {} was actually of type {}",
+                t,
+                arguments[i],
+                builder.func.dfg.value_type(arguments[i])
+            );
+            arguments[i] = optionally_bitcast_vector(arguments[i], *t, builder)
+        }
+    }
+}
+
+/// A helper to extract all the `Type` listings of each variable in `params`
+/// for only parameters the return true for `is_wasm`, typically paired with
+/// `is_wasm_return` or `is_wasm_parameter`.
+pub fn wasm_param_types(params: &[ir::AbiParam], is_wasm: impl Fn(usize) -> bool) -> Vec<Type> {
+    let mut ret = Vec::with_capacity(params.len());
+    for (i, param) in params.iter().enumerate() {
+        if is_wasm(i) {
+            ret.push(param.value_type);
+        }
+    }
+    ret
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_environ.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_environ.rs
new file mode 100644
index 0000000..0f6215f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_environ.rs
@@ -0,0 +1,492 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! All the runtime support necessary for the wasm to cranelift translation is formalized by the
+//! traits `FunctionEnvMutironment`.
+
+use super::func_state::FuncTranslationState;
+use super::translation_utils::reference_type;
+use core::convert::From;
+use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir::immediates::Offset32;
+use cranelift_codegen::ir::{self, InstBuilder};
+use cranelift_codegen::isa::TargetFrontendConfig;
+use cranelift_frontend::FunctionBuilder;
+use wasmer_compiler::wasmparser::{HeapType, Operator};
+use wasmer_types::{
+    FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex, SignatureIndex,
+    TableIndex, Type as WasmerType, WasmResult,
+};
+
+/// The value of a WebAssembly global variable.
+#[derive(Clone, Copy)]
+pub enum GlobalVariable {
+    #[allow(dead_code)]
+    /// This is a constant global with a value known at compile time.
+    Const(ir::Value),
+
+    /// This is a variable in memory that should be referenced through a `GlobalValue`.
+    Memory {
+        /// The address of the global variable storage.
+        gv: ir::GlobalValue,
+        /// An offset to add to the address.
+        offset: Offset32,
+        /// The global variable's type.
+        ty: ir::Type,
+    },
+
+    #[allow(dead_code)]
+    /// This is a global variable that needs to be handled by the environment.
+    Custom,
+}
+
+#[allow(dead_code)]
+/// How to return from functions.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum ReturnMode {
+    /// Use normal return instructions as needed.
+    NormalReturns,
+}
+
+/// Environment affecting the translation of a WebAssembly.
+pub trait TargetEnvironment {
+    /// Get the information needed to produce Cranelift IR for the given target.
+    fn target_config(&self) -> TargetFrontendConfig;
+
+    /// Get the Cranelift integer type to use for native pointers.
+    ///
+    /// This returns `I64` for 64-bit architectures and `I32` for 32-bit architectures.
+    fn pointer_type(&self) -> ir::Type {
+        ir::Type::int(u16::from(self.target_config().pointer_bits())).unwrap()
+    }
+
+    /// Get the size of a native pointer, in bytes.
+    fn pointer_bytes(&self) -> u8 {
+        self.target_config().pointer_bytes()
+    }
+
+    /// Get the Cranelift reference type to use for native references.
+    ///
+    /// This returns `R64` for 64-bit architectures and `R32` for 32-bit architectures.
+    fn reference_type(&self) -> ir::Type {
+        reference_type(self.target_config()).expect("expected reference type")
+    }
+}
+
+/// Environment affecting the translation of a single WebAssembly function.
+///
+/// A `FuncEnvironment` trait object is required to translate a WebAssembly function to Cranelift
+/// IR. The function environment provides information about the WebAssembly module as well as the
+/// runtime environment.
+pub trait FuncEnvironment: TargetEnvironment {
+    /// Is the given parameter of the given function a wasm-level parameter, as opposed to a hidden
+    /// parameter added for use by the implementation?
+    fn is_wasm_parameter(&self, signature: &ir::Signature, index: usize) -> bool {
+        signature.params[index].purpose == ir::ArgumentPurpose::Normal
+    }
+
+    /// Is the given return of the given function a wasm-level parameter, as
+    /// opposed to a hidden parameter added for use by the implementation?
+    fn is_wasm_return(&self, signature: &ir::Signature, index: usize) -> bool {
+        signature.returns[index].purpose == ir::ArgumentPurpose::Normal
+    }
+
+    /// Should the code be structured to use a single `fallthrough_return` instruction at the end
+    /// of the function body, rather than `return` instructions as needed? This is used by VMs
+    /// to append custom epilogues.
+    fn return_mode(&self) -> ReturnMode {
+        ReturnMode::NormalReturns
+    }
+
+    /// Set up the necessary preamble definitions in `func` to access the global variable
+    /// identified by `index`.
+    ///
+    /// The index space covers both imported globals and globals defined by the module.
+    ///
+    /// Return the global variable reference that should be used to access the global and the
+    /// WebAssembly type of the global.
+    fn make_global(
+        &mut self,
+        func: &mut ir::Function,
+        index: GlobalIndex,
+    ) -> WasmResult<GlobalVariable>;
+
+    /// Set up the necessary preamble definitions in `func` to access the linear memory identified
+    /// by `index`.
+    ///
+    /// The index space covers both imported and locally declared memories.
+    fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<ir::Heap>;
+
+    /// Set up the necessary preamble definitions in `func` to access the table identified
+    /// by `index`.
+    ///
+    /// The index space covers both imported and locally declared tables.
+    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table>;
+
+    /// Set up a signature definition in the preamble of `func` that can be used for an indirect
+    /// call with signature `index`.
+    ///
+    /// The signature may contain additional arguments needed for an indirect call, but the
+    /// arguments marked as `ArgumentPurpose::Normal` must correspond to the WebAssembly signature
+    /// arguments.
+    ///
+    /// The signature will only be used for indirect calls, even if the module has direct function
+    /// calls with the same WebAssembly type.
+    fn make_indirect_sig(
+        &mut self,
+        func: &mut ir::Function,
+        index: SignatureIndex,
+    ) -> WasmResult<ir::SigRef>;
+
+    /// Set up an external function definition in the preamble of `func` that can be used to
+    /// directly call the function `index`.
+    ///
+    /// The index space covers both imported functions and functions defined in the current module.
+    ///
+    /// The function's signature may contain additional arguments needed for a direct call, but the
+    /// arguments marked as `ArgumentPurpose::Normal` must correspond to the WebAssembly signature
+    /// arguments.
+    ///
+    /// The function's signature will only be used for direct calls, even if the module has
+    /// indirect calls with the same WebAssembly type.
+    fn make_direct_func(
+        &mut self,
+        func: &mut ir::Function,
+        index: FunctionIndex,
+    ) -> WasmResult<ir::FuncRef>;
+
+    /// Translate a `call_indirect` WebAssembly instruction at `pos`.
+    ///
+    /// Insert instructions at `pos` for an indirect call to the function `callee` in the table
+    /// `table_index` with WebAssembly signature `sig_index`. The `callee` value will have type
+    /// `i32`.
+    ///
+    /// The signature `sig_ref` was previously created by `make_indirect_sig()`.
+    ///
+    /// Return the call instruction whose results are the WebAssembly return values.
+    #[allow(clippy::too_many_arguments)]
+    fn translate_call_indirect(
+        &mut self,
+        pos: FuncCursor,
+        table_index: TableIndex,
+        table: ir::Table,
+        sig_index: SignatureIndex,
+        sig_ref: ir::SigRef,
+        callee: ir::Value,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst>;
+
+    /// Translate a `call` WebAssembly instruction at `pos`.
+    ///
+    /// Insert instructions at `pos` for a direct call to the function `callee_index`.
+    ///
+    /// The function reference `callee` was previously created by `make_direct_func()`.
+    ///
+    /// Return the call instruction whose results are the WebAssembly return values.
+    fn translate_call(
+        &mut self,
+        mut pos: FuncCursor,
+        _callee_index: FunctionIndex,
+        callee: ir::FuncRef,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst> {
+        Ok(pos.ins().call(callee, call_args))
+    }
+
+    /// Translate a `memory.grow` WebAssembly instruction.
+    ///
+    /// The `index` provided identifies the linear memory to grow, and `heap` is the heap reference
+    /// returned by `make_heap` for the same index.
+    ///
+    /// The `val` value is the requested memory size in pages.
+    ///
+    /// Returns the old size (in pages) of the memory.
+    fn translate_memory_grow(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+        val: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translates a `memory.size` WebAssembly instruction.
+    ///
+    /// The `index` provided identifies the linear memory to query, and `heap` is the heap reference
+    /// returned by `make_heap` for the same index.
+    ///
+    /// Returns the size in pages of the memory.
+    fn translate_memory_size(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `memory.copy` WebAssembly instruction.
+    ///
+    /// The `index` provided identifies the linear memory to query, and `heap` is the heap reference
+    /// returned by `make_heap` for the same index.
+    #[allow(clippy::too_many_arguments)]
+    fn translate_memory_copy(
+        &mut self,
+        pos: FuncCursor,
+        src_index: MemoryIndex,
+        src_heap: ir::Heap,
+        dst_index: MemoryIndex,
+        dst_heap: ir::Heap,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `memory.fill` WebAssembly instruction.
+    ///
+    /// The `index` provided identifies the linear memory to query, and `heap` is the heap reference
+    /// returned by `make_heap` for the same index.
+    fn translate_memory_fill(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+        dst: ir::Value,
+        val: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `memory.init` WebAssembly instruction.
+    ///
+    /// The `index` provided identifies the linear memory to query, and `heap` is the heap reference
+    /// returned by `make_heap` for the same index. `seg_index` is the index of the segment to copy
+    /// from.
+    #[allow(clippy::too_many_arguments)]
+    fn translate_memory_init(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+        seg_index: u32,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `data.drop` WebAssembly instruction.
+    fn translate_data_drop(&mut self, pos: FuncCursor, seg_index: u32) -> WasmResult<()>;
+
+    /// Translate a `table.size` WebAssembly instruction.
+    fn translate_table_size(
+        &mut self,
+        pos: FuncCursor,
+        index: TableIndex,
+        table: ir::Table,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `table.grow` WebAssembly instruction.
+    fn translate_table_grow(
+        &mut self,
+        pos: FuncCursor,
+        table_index: TableIndex,
+        table: ir::Table,
+        delta: ir::Value,
+        init_value: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `table.get` WebAssembly instruction.
+    fn translate_table_get(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        table: ir::Table,
+        index: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `table.set` WebAssembly instruction.
+    fn translate_table_set(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        table: ir::Table,
+        value: ir::Value,
+        index: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `table.copy` WebAssembly instruction.
+    #[allow(clippy::too_many_arguments)]
+    fn translate_table_copy(
+        &mut self,
+        pos: FuncCursor,
+        dst_table_index: TableIndex,
+        dst_table: ir::Table,
+        src_table_index: TableIndex,
+        src_table: ir::Table,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `table.fill` WebAssembly instruction.
+    fn translate_table_fill(
+        &mut self,
+        pos: FuncCursor,
+        table_index: TableIndex,
+        dst: ir::Value,
+        val: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `table.init` WebAssembly instruction.
+    #[allow(clippy::too_many_arguments)]
+    fn translate_table_init(
+        &mut self,
+        pos: FuncCursor,
+        seg_index: u32,
+        table_index: TableIndex,
+        table: ir::Table,
+        dst: ir::Value,
+        src: ir::Value,
+        len: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate a `elem.drop` WebAssembly instruction.
+    fn translate_elem_drop(&mut self, pos: FuncCursor, seg_index: u32) -> WasmResult<()>;
+
+    /// Translate a `ref.null T` WebAssembly instruction.
+    ///
+    /// By default, translates into a null reference type.
+    ///
+    /// Override this if you don't use Cranelift reference types for all Wasm
+    /// reference types (e.g. you use a raw pointer for `funcref`s) or if the
+    /// null sentinel is not a null reference type pointer for your type. If you
+    /// override this method, then you should also override
+    /// `translate_ref_is_null` as well.
+    fn translate_ref_null(&mut self, pos: FuncCursor, ty: HeapType) -> WasmResult<ir::Value>;
+    // {
+    //     let _ = ty;
+    //     Ok(pos.ins().null(self.reference_type(ty)))
+    // }
+
+    /// Translate a `ref.is_null` WebAssembly instruction.
+    ///
+    /// By default, assumes that `value` is a Cranelift reference type, and that
+    /// a null Cranelift reference type is the null value for all Wasm reference
+    /// types.
+    ///
+    /// If you override this method, you probably also want to override
+    /// `translate_ref_null` as well.
+    fn translate_ref_is_null(
+        &mut self,
+        mut pos: FuncCursor,
+        value: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        let is_null = pos.ins().is_null(value);
+        Ok(pos.ins().uextend(ir::types::I64, is_null))
+    }
+
+    /// Translate a `ref.func` WebAssembly instruction.
+    fn translate_ref_func(
+        &mut self,
+        pos: FuncCursor,
+        func_index: FunctionIndex,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `global.get` WebAssembly instruction at `pos` for a global
+    /// that is custom.
+    fn translate_custom_global_get(
+        &mut self,
+        pos: FuncCursor,
+        global_index: GlobalIndex,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate a `global.set` WebAssembly instruction at `pos` for a global
+    /// that is custom.
+    fn translate_custom_global_set(
+        &mut self,
+        pos: FuncCursor,
+        global_index: GlobalIndex,
+        val: ir::Value,
+    ) -> WasmResult<()>;
+
+    /// Translate an `i32.atomic.wait` or `i64.atomic.wait` WebAssembly instruction.
+    /// The `index` provided identifies the linear memory containing the value
+    /// to wait on, and `heap` is the heap reference returned by `make_heap`
+    /// for the same index.  Whether the waited-on value is 32- or 64-bit can be
+    /// determined by examining the type of `expected`, which must be only I32 or I64.
+    ///
+    /// Returns an i32, which is negative if the helper call failed.
+    fn translate_atomic_wait(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+        addr: ir::Value,
+        expected: ir::Value,
+        timeout: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Translate an `atomic.notify` WebAssembly instruction.
+    /// The `index` provided identifies the linear memory containing the value
+    /// to wait on, and `heap` is the heap reference returned by `make_heap`
+    /// for the same index.
+    ///
+    /// Returns an i64, which is negative if the helper call failed.
+    fn translate_atomic_notify(
+        &mut self,
+        pos: FuncCursor,
+        index: MemoryIndex,
+        heap: ir::Heap,
+        addr: ir::Value,
+        count: ir::Value,
+    ) -> WasmResult<ir::Value>;
+
+    /// Emit code at the beginning of every wasm loop.
+    ///
+    /// This can be used to insert explicit interrupt or safepoint checking at
+    /// the beginnings of loops.
+    fn translate_loop_header(&mut self, _pos: FuncCursor) -> WasmResult<()> {
+        // By default, don't emit anything.
+        Ok(())
+    }
+
+    /// Optional callback for the `FunctionEnvMutironment` performing this translation to maintain
+    /// internal state or prepare custom state for the operator to translate
+    fn before_translate_operator(
+        &mut self,
+        _op: &Operator,
+        _builder: &mut FunctionBuilder,
+        _state: &FuncTranslationState,
+    ) -> WasmResult<()> {
+        Ok(())
+    }
+
+    /// Optional callback for the `FunctionEnvMutironment` performing this translation to maintain
+    /// internal state or finalize custom state for the operator that was translated
+    fn after_translate_operator(
+        &mut self,
+        _op: &Operator,
+        _builder: &mut FunctionBuilder,
+        _state: &FuncTranslationState,
+    ) -> WasmResult<()> {
+        Ok(())
+    }
+
+    /// Get the type of the global at the given index.
+    fn get_global_type(&self, global_index: GlobalIndex) -> Option<WasmerType>;
+
+    /// Push a local declaration on to the stack to track the type of locals.
+    fn push_local_decl_on_stack(&mut self, ty: WasmerType);
+
+    /// Push locals for a the params of a function on to the stack.
+    fn push_params_on_stack(&mut self, function_index: LocalFunctionIndex);
+
+    /// Get the type of the local at the given index.
+    fn get_local_type(&self, local_index: u32) -> Option<WasmerType>;
+
+    /// Get the types of all the current locals.
+    fn get_local_types(&self) -> &[WasmerType];
+
+    /// Get the type of the local at the given index.
+    fn get_function_type(&self, function_index: FunctionIndex) -> Option<&FunctionType>;
+
+    /// Get the type of a function with the given signature index.
+    fn get_function_sig(&self, sig_index: SignatureIndex) -> Option<&FunctionType>;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_state.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_state.rs
new file mode 100644
index 0000000..4b42bb1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_state.rs
@@ -0,0 +1,551 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! WebAssembly module and function translation state.
+//!
+//! The `ModuleTranslationState` struct defined in this module is used to keep track of data about
+//! the whole WebAssembly module, such as the decoded type signatures.
+//!
+//! The `FuncTranslationState` struct defined in this module is used to keep track of the WebAssembly
+//! value and control stacks during the translation of a single function.
+
+use super::func_environ::{FuncEnvironment, GlobalVariable};
+use crate::{HashMap, Occupied, Vacant};
+use cranelift_codegen::ir::{self, Block, Inst, Value};
+use std::vec::Vec;
+use wasmer_types::{
+    FunctionIndex, GlobalIndex, MemoryIndex, SignatureIndex, TableIndex, WasmResult,
+};
+
+/// Information about the presence of an associated `else` for an `if`, or the
+/// lack thereof.
+#[derive(Debug)]
+pub enum ElseData {
+    /// The `if` does not already have an `else` block.
+    ///
+    /// This doesn't mean that it will never have an `else`, just that we
+    /// haven't seen it yet.
+    NoElse {
+        /// If we discover that we need an `else` block, this is the jump
+        /// instruction that needs to be fixed up to point to the new `else`
+        /// block rather than the destination block after the `if...end`.
+        branch_inst: Inst,
+    },
+
+    /// We have already allocated an `else` block.
+    ///
+    /// Usually we don't know whether we will hit an `if .. end` or an `if
+    /// .. else .. end`, but sometimes we can tell based on the block's type
+    /// signature that the signature is not valid if there isn't an `else`. In
+    /// these cases, we pre-allocate the `else` block.
+    WithElse {
+        /// This is the `else` block.
+        else_block: Block,
+    },
+}
+
+/// A control stack frame can be an `if`, a `block` or a `loop`, each one having the following
+/// fields:
+///
+/// - `destination`: reference to the `Block` that will hold the code after the control block;
+/// - `num_return_values`: number of values returned by the control block;
+/// - `original_stack_size`: size of the value stack at the beginning of the control block.
+///
+/// Moreover, the `if` frame has the `branch_inst` field that points to the `brz` instruction
+/// separating the `true` and `false` branch. The `loop` frame has a `header` field that references
+/// the `Block` that contains the beginning of the body of the loop.
+#[derive(Debug)]
+pub enum ControlStackFrame {
+    If {
+        destination: Block,
+        else_data: ElseData,
+        num_param_values: usize,
+        num_return_values: usize,
+        original_stack_size: usize,
+        exit_is_branched_to: bool,
+        blocktype: wasmer_compiler::wasmparser::BlockType,
+        /// Was the head of the `if` reachable?
+        head_is_reachable: bool,
+        /// What was the reachability at the end of the consequent?
+        ///
+        /// This is `None` until we're finished translating the consequent, and
+        /// is set to `Some` either by hitting an `else` when we will begin
+        /// translating the alternative, or by hitting an `end` in which case
+        /// there is no alternative.
+        consequent_ends_reachable: Option<bool>,
+        // Note: no need for `alternative_ends_reachable` because that is just
+        // `state.reachable` when we hit the `end` in the `if .. else .. end`.
+    },
+    Block {
+        destination: Block,
+        num_param_values: usize,
+        num_return_values: usize,
+        original_stack_size: usize,
+        exit_is_branched_to: bool,
+    },
+    Loop {
+        destination: Block,
+        header: Block,
+        num_param_values: usize,
+        num_return_values: usize,
+        original_stack_size: usize,
+    },
+}
+
+/// Helper methods for the control stack objects.
+impl ControlStackFrame {
+    pub fn num_return_values(&self) -> usize {
+        match *self {
+            Self::If {
+                num_return_values, ..
+            }
+            | Self::Block {
+                num_return_values, ..
+            }
+            | Self::Loop {
+                num_return_values, ..
+            } => num_return_values,
+        }
+    }
+    pub fn num_param_values(&self) -> usize {
+        match *self {
+            Self::If {
+                num_param_values, ..
+            }
+            | Self::Block {
+                num_param_values, ..
+            }
+            | Self::Loop {
+                num_param_values, ..
+            } => num_param_values,
+        }
+    }
+    pub fn following_code(&self) -> Block {
+        match *self {
+            Self::If { destination, .. }
+            | Self::Block { destination, .. }
+            | Self::Loop { destination, .. } => destination,
+        }
+    }
+    pub fn br_destination(&self) -> Block {
+        match *self {
+            Self::If { destination, .. } | Self::Block { destination, .. } => destination,
+            Self::Loop { header, .. } => header,
+        }
+    }
+    /// Private helper. Use `truncate_value_stack_to_else_params()` or
+    /// `truncate_value_stack_to_original_size()` to restore value-stack state.
+    fn original_stack_size(&self) -> usize {
+        match *self {
+            Self::If {
+                original_stack_size,
+                ..
+            }
+            | Self::Block {
+                original_stack_size,
+                ..
+            }
+            | Self::Loop {
+                original_stack_size,
+                ..
+            } => original_stack_size,
+        }
+    }
+    pub fn is_loop(&self) -> bool {
+        match *self {
+            Self::If { .. } | Self::Block { .. } => false,
+            Self::Loop { .. } => true,
+        }
+    }
+
+    pub fn exit_is_branched_to(&self) -> bool {
+        match *self {
+            Self::If {
+                exit_is_branched_to,
+                ..
+            }
+            | Self::Block {
+                exit_is_branched_to,
+                ..
+            } => exit_is_branched_to,
+            Self::Loop { .. } => false,
+        }
+    }
+
+    pub fn set_branched_to_exit(&mut self) {
+        match *self {
+            Self::If {
+                ref mut exit_is_branched_to,
+                ..
+            }
+            | Self::Block {
+                ref mut exit_is_branched_to,
+                ..
+            } => *exit_is_branched_to = true,
+            Self::Loop { .. } => {}
+        }
+    }
+
+    /// Pop values from the value stack so that it is left at the
+    /// input-parameters to an else-block.
+    pub fn truncate_value_stack_to_else_params(&self, stack: &mut Vec<Value>) {
+        debug_assert!(matches!(self, &Self::If { .. }));
+        stack.truncate(self.original_stack_size());
+    }
+
+    /// Pop values from the value stack so that it is left at the state it was
+    /// before this control-flow frame.
+    pub fn truncate_value_stack_to_original_size(&self, stack: &mut Vec<Value>) {
+        // The "If" frame pushes its parameters twice, so they're available to the else block
+        // (see also `FuncTranslationState::push_if`).
+        // Yet, the original_stack_size member accounts for them only once, so that the else
+        // block can see the same number of parameters as the consequent block. As a matter of
+        // fact, we need to substract an extra number of parameter values for if blocks.
+        let num_duplicated_params = match self {
+            &Self::If {
+                num_param_values, ..
+            } => {
+                debug_assert!(num_param_values <= self.original_stack_size());
+                num_param_values
+            }
+            _ => 0,
+        };
+        stack.truncate(self.original_stack_size() - num_duplicated_params);
+    }
+}
+
+/// Contains information passed along during a function's translation and that records:
+///
+/// - The current value and control stacks.
+/// - The depth of the two unreachable control blocks stacks, that are manipulated when translating
+///   unreachable code;
+pub struct FuncTranslationState {
+    /// A stack of values corresponding to the active values in the input wasm function at this
+    /// point.
+    pub(crate) stack: Vec<Value>,
+    /// A stack of active control flow operations at this point in the input wasm function.
+    pub(crate) control_stack: Vec<ControlStackFrame>,
+    /// Is the current translation state still reachable? This is false when translating operators
+    /// like End, Return, or Unreachable.
+    pub(crate) reachable: bool,
+
+    // Map of global variables that have already been created by `FuncEnvironment::make_global`.
+    globals: HashMap<GlobalIndex, GlobalVariable>,
+
+    // Map of heaps that have been created by `FuncEnvironment::make_heap`.
+    heaps: HashMap<MemoryIndex, ir::Heap>,
+
+    // Map of tables that have been created by `FuncEnvironment::make_table`.
+    tables: HashMap<TableIndex, ir::Table>,
+
+    // Map of indirect call signatures that have been created by
+    // `FuncEnvironment::make_indirect_sig()`.
+    // Stores both the signature reference and the number of WebAssembly arguments
+    signatures: HashMap<SignatureIndex, (ir::SigRef, usize)>,
+
+    // Imported and local functions that have been created by
+    // `FuncEnvironment::make_direct_func()`.
+    // Stores both the function reference and the number of WebAssembly arguments
+    functions: HashMap<FunctionIndex, (ir::FuncRef, usize)>,
+}
+
+// Public methods that are exposed to non-`cranelift_wasm` API consumers.
+impl FuncTranslationState {
+    /// True if the current translation state expresses reachable code, false if it is unreachable.
+    #[inline]
+    #[allow(dead_code)]
+    pub fn reachable(&self) -> bool {
+        self.reachable
+    }
+}
+
+impl FuncTranslationState {
+    /// Construct a new, empty, `FuncTranslationState`
+    pub(crate) fn new() -> Self {
+        Self {
+            stack: Vec::new(),
+            // TODO(reftypes):
+            //metadata_stack: Vec::new(),
+            control_stack: Vec::new(),
+            reachable: true,
+            globals: HashMap::new(),
+            heaps: HashMap::new(),
+            tables: HashMap::new(),
+            signatures: HashMap::new(),
+            functions: HashMap::new(),
+        }
+    }
+
+    fn clear(&mut self) {
+        debug_assert!(self.stack.is_empty());
+        debug_assert!(self.control_stack.is_empty());
+        self.reachable = true;
+        self.globals.clear();
+        self.heaps.clear();
+        self.tables.clear();
+        self.signatures.clear();
+        self.functions.clear();
+    }
+
+    /// Initialize the state for compiling a function with the given signature.
+    ///
+    /// This resets the state to containing only a single block representing the whole function.
+    /// The exit block is the last block in the function which will contain the return instruction.
+    pub(crate) fn initialize(&mut self, sig: &ir::Signature, exit_block: Block) {
+        self.clear();
+        self.push_block(
+            exit_block,
+            0,
+            sig.returns
+                .iter()
+                .filter(|arg| arg.purpose == ir::ArgumentPurpose::Normal)
+                .count(),
+        );
+    }
+
+    /// Push a value.
+    pub(crate) fn push1(&mut self, val: Value) {
+        self.stack.push(val);
+    }
+
+    /// Push multiple values.
+    pub(crate) fn pushn(&mut self, vals: &[Value]) {
+        self.stack.extend_from_slice(vals);
+    }
+
+    /// Pop one value.
+    pub(crate) fn pop1(&mut self) -> Value {
+        self.stack
+            .pop()
+            .expect("attempted to pop a value from an empty stack")
+    }
+
+    /// Peek at the top of the stack without popping it.
+    pub(crate) fn peek1(&self) -> Value {
+        *self
+            .stack
+            .last()
+            .expect("attempted to peek at a value on an empty stack")
+    }
+
+    /// Pop two values. Return them in the order they were pushed.
+    pub(crate) fn pop2(&mut self) -> (Value, Value) {
+        let v2 = self.pop1();
+        let v1 = self.pop1();
+        (v1, v2)
+    }
+
+    /// Pop three values. Return them in the order they were pushed.
+    pub(crate) fn pop3(&mut self) -> (Value, Value, Value) {
+        let v3 = self.pop1();
+        let v2 = self.pop1();
+        let v1 = self.pop1();
+        (v1, v2, v3)
+    }
+
+    /// Helper to ensure the the stack size is at least as big as `n`; note that due to
+    /// `debug_assert` this will not execute in non-optimized builds.
+    #[inline]
+    fn ensure_length_is_at_least(&self, n: usize) {
+        debug_assert!(
+            n <= self.stack.len(),
+            "attempted to access {} values but stack only has {} values",
+            n,
+            self.stack.len()
+        );
+    }
+
+    /// Pop the top `n` values on the stack.
+    ///
+    /// The popped values are not returned. Use `peekn` to look at them before popping.
+    pub(crate) fn popn(&mut self, n: usize) {
+        self.ensure_length_is_at_least(n);
+        let new_len = self.stack.len() - n;
+        self.stack.truncate(new_len);
+    }
+
+    /// Peek at the top `n` values on the stack in the order they were pushed.
+    pub(crate) fn peekn(&self, n: usize) -> &[Value] {
+        self.ensure_length_is_at_least(n);
+        &self.stack[self.stack.len() - n..]
+    }
+
+    /// Peek at the top `n` values on the stack in the order they were pushed.
+    pub(crate) fn peekn_mut(&mut self, n: usize) -> &mut [Value] {
+        self.ensure_length_is_at_least(n);
+        let len = self.stack.len();
+        &mut self.stack[len - n..]
+    }
+
+    /// Push a block on the control stack.
+    pub(crate) fn push_block(
+        &mut self,
+        following_code: Block,
+        num_param_types: usize,
+        num_result_types: usize,
+    ) {
+        debug_assert!(num_param_types <= self.stack.len());
+        self.control_stack.push(ControlStackFrame::Block {
+            destination: following_code,
+            original_stack_size: self.stack.len() - num_param_types,
+            num_param_values: num_param_types,
+            num_return_values: num_result_types,
+            exit_is_branched_to: false,
+        });
+    }
+
+    /// Push a loop on the control stack.
+    pub(crate) fn push_loop(
+        &mut self,
+        header: Block,
+        following_code: Block,
+        num_param_types: usize,
+        num_result_types: usize,
+    ) {
+        debug_assert!(num_param_types <= self.stack.len());
+        self.control_stack.push(ControlStackFrame::Loop {
+            header,
+            destination: following_code,
+            original_stack_size: self.stack.len() - num_param_types,
+            num_param_values: num_param_types,
+            num_return_values: num_result_types,
+        });
+    }
+
+    /// Push an if on the control stack.
+    pub(crate) fn push_if(
+        &mut self,
+        destination: Block,
+        else_data: ElseData,
+        num_param_types: usize,
+        num_result_types: usize,
+        blocktype: wasmer_compiler::wasmparser::BlockType,
+    ) {
+        debug_assert!(num_param_types <= self.stack.len());
+
+        // Push a second copy of our `if`'s parameters on the stack. This lets
+        // us avoid saving them on the side in the `ControlStackFrame` for our
+        // `else` block (if it exists), which would require a second heap
+        // allocation. See also the comment in `translate_operator` for
+        // `Operator::Else`.
+        self.stack.reserve(num_param_types);
+        for i in (self.stack.len() - num_param_types)..self.stack.len() {
+            let val = self.stack[i];
+            self.stack.push(val);
+        }
+
+        self.control_stack.push(ControlStackFrame::If {
+            destination,
+            else_data,
+            original_stack_size: self.stack.len() - num_param_types,
+            num_param_values: num_param_types,
+            num_return_values: num_result_types,
+            exit_is_branched_to: false,
+            head_is_reachable: self.reachable,
+            consequent_ends_reachable: None,
+            blocktype,
+        });
+    }
+}
+
+/// Methods for handling entity references.
+impl FuncTranslationState {
+    /// Get the `GlobalVariable` reference that should be used to access the global variable
+    /// `index`. Create the reference if necessary.
+    /// Also return the WebAssembly type of the global.
+    pub(crate) fn get_global<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        func: &mut ir::Function,
+        index: u32,
+        environ: &mut FE,
+    ) -> WasmResult<GlobalVariable> {
+        let index = GlobalIndex::from_u32(index);
+        match self.globals.entry(index) {
+            Occupied(entry) => Ok(*entry.get()),
+            Vacant(entry) => Ok(*entry.insert(environ.make_global(func, index)?)),
+        }
+    }
+
+    /// Get the `Heap` reference that should be used to access linear memory `index`.
+    /// Create the reference if necessary.
+    pub(crate) fn get_heap<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        func: &mut ir::Function,
+        index: u32,
+        environ: &mut FE,
+    ) -> WasmResult<ir::Heap> {
+        let index = MemoryIndex::from_u32(index);
+        match self.heaps.entry(index) {
+            Occupied(entry) => Ok(*entry.get()),
+            Vacant(entry) => Ok(*entry.insert(environ.make_heap(func, index)?)),
+        }
+    }
+
+    /// Get the `Table` reference that should be used to access table `index`.
+    /// Create the reference if necessary.
+    pub(crate) fn get_or_create_table<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        func: &mut ir::Function,
+        index: u32,
+        environ: &mut FE,
+    ) -> WasmResult<ir::Table> {
+        let index = TableIndex::from_u32(index);
+        match self.tables.entry(index) {
+            Occupied(entry) => Ok(*entry.get()),
+            Vacant(entry) => Ok(*entry.insert(environ.make_table(func, index)?)),
+        }
+    }
+
+    /// Get the `SigRef` reference that should be used to make an indirect call with signature
+    /// `index`. Also return the number of WebAssembly arguments in the signature.
+    ///
+    /// Create the signature if necessary.
+    pub(crate) fn get_indirect_sig<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        func: &mut ir::Function,
+        index: u32,
+        environ: &mut FE,
+    ) -> WasmResult<(ir::SigRef, usize)> {
+        let index = SignatureIndex::from_u32(index);
+        match self.signatures.entry(index) {
+            Occupied(entry) => Ok(*entry.get()),
+            Vacant(entry) => {
+                let sig = environ.make_indirect_sig(func, index)?;
+                Ok(*entry.insert((sig, num_wasm_parameters(environ, &func.dfg.signatures[sig]))))
+            }
+        }
+    }
+
+    /// Get the `FuncRef` reference that should be used to make a direct call to function
+    /// `index`. Also return the number of WebAssembly arguments in the signature.
+    ///
+    /// Create the function reference if necessary.
+    pub(crate) fn get_direct_func<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        func: &mut ir::Function,
+        index: u32,
+        environ: &mut FE,
+    ) -> WasmResult<(ir::FuncRef, usize)> {
+        let index = FunctionIndex::from_u32(index);
+        match self.functions.entry(index) {
+            Occupied(entry) => Ok(*entry.get()),
+            Vacant(entry) => {
+                let fref = environ.make_direct_func(func, index)?;
+                let sig = func.dfg.ext_funcs[fref].signature;
+                Ok(*entry.insert((
+                    fref,
+                    num_wasm_parameters(environ, &func.dfg.signatures[sig]),
+                )))
+            }
+        }
+    }
+}
+
+fn num_wasm_parameters<FE: FuncEnvironment + ?Sized>(
+    environ: &FE,
+    signature: &ir::Signature,
+) -> usize {
+    (0..signature.params.len())
+        .filter(|index| environ.is_wasm_parameter(signature, *index))
+        .count()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_translator.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_translator.rs
new file mode 100644
index 0000000..8c6fa89
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/func_translator.rs
@@ -0,0 +1,277 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Standalone WebAssembly to Cranelift IR translator.
+//!
+//! This module defines the `FuncTranslator` type which can translate a single WebAssembly
+//! function to Cranelift IR guided by a `FuncEnvironment` which provides information about the
+//! WebAssembly module and the runtime environment.
+
+use super::code_translator::{bitcast_arguments, translate_operator, wasm_param_types};
+use super::func_environ::{FuncEnvironment, ReturnMode};
+use super::func_state::FuncTranslationState;
+use super::translation_utils::get_vmctx_value_label;
+use cranelift_codegen::entity::EntityRef;
+use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
+use cranelift_codegen::timing;
+use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
+use wasmer_compiler::{wasm_unsupported, wasmparser};
+use wasmer_compiler::{wptype_to_type, FunctionBinaryReader, ModuleTranslationState};
+use wasmer_types::{LocalFunctionIndex, WasmResult};
+
+/// WebAssembly to Cranelift IR function translator.
+///
+/// A `FuncTranslator` is used to translate a binary WebAssembly function into Cranelift IR guided
+/// by a `FuncEnvironment` object. A single translator instance can be reused to translate multiple
+/// functions which will reduce heap allocation traffic.
+pub struct FuncTranslator {
+    func_ctx: FunctionBuilderContext,
+    state: FuncTranslationState,
+}
+
+impl FuncTranslator {
+    /// Create a new translator.
+    pub fn new() -> Self {
+        Self {
+            func_ctx: FunctionBuilderContext::new(),
+            state: FuncTranslationState::new(),
+        }
+    }
+
+    /// Translate a binary WebAssembly function.
+    ///
+    /// The `code` slice contains the binary WebAssembly *function code* as it appears in the code
+    /// section of a WebAssembly module, not including the initial size of the function code. The
+    /// slice is expected to contain two parts:
+    ///
+    /// - The declaration of *locals*, and
+    /// - The function *body* as an expression.
+    ///
+    /// See [the WebAssembly specification][wasm].
+    ///
+    /// [wasm]: https://webassembly.github.io/spec/core/binary/modules.html#code-section
+    ///
+    /// The Cranelift IR function `func` should be completely empty except for the `func.signature`
+    /// and `func.name` fields. The signature may contain special-purpose arguments which are not
+    /// regarded as WebAssembly local variables. Any signature arguments marked as
+    /// `ArgumentPurpose::Normal` are made accessible as WebAssembly local variables.
+    ///
+    pub fn translate<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        module_translation_state: &ModuleTranslationState,
+        reader: &mut dyn FunctionBinaryReader,
+        func: &mut ir::Function,
+        environ: &mut FE,
+        local_function_index: LocalFunctionIndex,
+    ) -> WasmResult<()> {
+        environ.push_params_on_stack(local_function_index);
+        self.translate_from_reader(module_translation_state, reader, func, environ)
+    }
+
+    /// Translate a binary WebAssembly function from a `FunctionBinaryReader`.
+    pub fn translate_from_reader<FE: FuncEnvironment + ?Sized>(
+        &mut self,
+        module_translation_state: &ModuleTranslationState,
+        reader: &mut dyn FunctionBinaryReader,
+        func: &mut ir::Function,
+        environ: &mut FE,
+    ) -> WasmResult<()> {
+        let _tt = timing::wasm_translate_function();
+        tracing::trace!(
+            "translate({} bytes, {}{})",
+            reader.bytes_remaining(),
+            func.name,
+            func.signature
+        );
+        debug_assert_eq!(func.dfg.num_blocks(), 0, "Function must be empty");
+        debug_assert_eq!(func.dfg.num_insts(), 0, "Function must be empty");
+
+        // This clears the `FunctionBuilderContext`.
+        let mut builder = FunctionBuilder::new(func, &mut self.func_ctx);
+        builder.set_srcloc(cur_srcloc(reader));
+        let entry_block = builder.create_block();
+        builder.append_block_params_for_function_params(entry_block);
+        builder.switch_to_block(entry_block); // This also creates values for the arguments.
+        builder.seal_block(entry_block); // Declare all predecessors known.
+
+        // Make sure the entry block is inserted in the layout before we make any callbacks to
+        // `environ`. The callback functions may need to insert things in the entry block.
+        builder.ensure_inserted_block();
+
+        let num_params = declare_wasm_parameters(&mut builder, entry_block, environ);
+
+        // Set up the translation state with a single pushed control block representing the whole
+        // function and its return values.
+        let exit_block = builder.create_block();
+        builder.append_block_params_for_function_returns(exit_block);
+        self.state.initialize(&builder.func.signature, exit_block);
+
+        parse_local_decls(reader, &mut builder, num_params, environ)?;
+        parse_function_body(
+            module_translation_state,
+            reader,
+            &mut builder,
+            &mut self.state,
+            environ,
+        )?;
+
+        builder.finalize();
+        Ok(())
+    }
+}
+
+/// Declare local variables for the signature parameters that correspond to WebAssembly locals.
+///
+/// Return the number of local variables declared.
+fn declare_wasm_parameters<FE: FuncEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    entry_block: Block,
+    environ: &FE,
+) -> usize {
+    let sig_len = builder.func.signature.params.len();
+    let mut next_local = 0;
+    for i in 0..sig_len {
+        let param_type = builder.func.signature.params[i];
+        // There may be additional special-purpose parameters in addition to the normal WebAssembly
+        // signature parameters. For example, a `vmctx` pointer.
+        if environ.is_wasm_parameter(&builder.func.signature, i) {
+            // This is a normal WebAssembly signature parameter, so create a local for it.
+            let local = Variable::new(next_local);
+            builder.declare_var(local, param_type.value_type);
+            next_local += 1;
+
+            let param_value = builder.block_params(entry_block)[i];
+            builder.def_var(local, param_value);
+        }
+        if param_type.purpose == ir::ArgumentPurpose::VMContext {
+            let param_value = builder.block_params(entry_block)[i];
+            builder.set_val_label(param_value, get_vmctx_value_label());
+        }
+    }
+
+    next_local
+}
+
+/// Parse the local variable declarations that precede the function body.
+///
+/// Declare local variables, starting from `num_params`.
+fn parse_local_decls<FE: FuncEnvironment + ?Sized>(
+    reader: &mut dyn FunctionBinaryReader,
+    builder: &mut FunctionBuilder,
+    num_params: usize,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    let mut next_local = num_params;
+    let local_count = reader.read_local_count()?;
+
+    for _ in 0..local_count {
+        builder.set_srcloc(cur_srcloc(reader));
+        let (count, ty) = reader.read_local_decl()?;
+        declare_locals(builder, count, ty, &mut next_local, environ)?;
+    }
+
+    Ok(())
+}
+
+/// Declare `count` local variables of the same type, starting from `next_local`.
+///
+/// Fail if the type is not valid for a local.
+fn declare_locals<FE: FuncEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    count: u32,
+    wasm_type: wasmparser::ValType,
+    next_local: &mut usize,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    // All locals are initialized to 0.
+    use wasmparser::ValType::*;
+    let zeroval = match wasm_type {
+        I32 => builder.ins().iconst(ir::types::I32, 0),
+        I64 => builder.ins().iconst(ir::types::I64, 0),
+        F32 => builder.ins().f32const(ir::immediates::Ieee32::with_bits(0)),
+        F64 => builder.ins().f64const(ir::immediates::Ieee64::with_bits(0)),
+        V128 => {
+            let constant_handle = builder.func.dfg.constants.insert([0; 16].to_vec().into());
+            builder.ins().vconst(ir::types::I8X16, constant_handle)
+        }
+        Ref(ty) => {
+            if ty.is_func_ref() || ty.is_extern_ref() {
+                builder.ins().null(environ.reference_type())
+            } else {
+                return Err(wasm_unsupported!("unsupported reference type: {:?}", ty));
+            }
+        }
+    };
+
+    let wasmer_ty = wptype_to_type(wasm_type).unwrap();
+    let ty = builder.func.dfg.value_type(zeroval);
+    for _ in 0..count {
+        let local = Variable::new(*next_local);
+        builder.declare_var(local, ty);
+        builder.def_var(local, zeroval);
+        builder.set_val_label(zeroval, ValueLabel::new(*next_local));
+        environ.push_local_decl_on_stack(wasmer_ty);
+        *next_local += 1;
+    }
+    Ok(())
+}
+
+/// Parse the function body in `reader`.
+///
+/// This assumes that the local variable declarations have already been parsed and function
+/// arguments and locals are declared in the builder.
+fn parse_function_body<FE: FuncEnvironment + ?Sized>(
+    module_translation_state: &ModuleTranslationState,
+    reader: &mut dyn FunctionBinaryReader,
+    builder: &mut FunctionBuilder,
+    state: &mut FuncTranslationState,
+    environ: &mut FE,
+) -> WasmResult<()> {
+    // The control stack is initialized with a single block representing the whole function.
+    debug_assert_eq!(state.control_stack.len(), 1, "State not initialized");
+
+    // Keep going until the final `End` operator which pops the outermost block.
+    while !state.control_stack.is_empty() {
+        builder.set_srcloc(cur_srcloc(reader));
+        let op = reader.read_operator()?;
+        environ.before_translate_operator(&op, builder, state)?;
+        translate_operator(module_translation_state, &op, builder, state, environ)?;
+        environ.after_translate_operator(&op, builder, state)?;
+    }
+
+    // The final `End` operator left us in the exit block where we need to manually add a return
+    // instruction.
+    //
+    // If the exit block is unreachable, it may not have the correct arguments, so we would
+    // generate a return instruction that doesn't match the signature.
+    if state.reachable {
+        //debug_assert!(builder.is_pristine());
+        if !builder.is_unreachable() {
+            match environ.return_mode() {
+                ReturnMode::NormalReturns => {
+                    let return_types = wasm_param_types(&builder.func.signature.returns, |i| {
+                        environ.is_wasm_return(&builder.func.signature, i)
+                    });
+                    bitcast_arguments(&mut state.stack, &return_types, builder);
+                    builder.ins().return_(&state.stack)
+                }
+            };
+        }
+    }
+
+    // Discard any remaining values on the stack. Either we just returned them,
+    // or the end of the function is unreachable.
+    state.stack.clear();
+    //state.metadata_stack.clear();
+
+    debug_assert!(reader.eof());
+
+    Ok(())
+}
+
+/// Get the current source location from a reader.
+fn cur_srcloc(reader: &dyn FunctionBinaryReader) -> ir::SourceLoc {
+    // We record source locations as byte code offsets relative to the beginning of the file.
+    // This will wrap around if byte code is larger than 4 GB.
+    ir::SourceLoc::new(reader.original_position() as u32)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/mod.rs
new file mode 100644
index 0000000..773ee44
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/mod.rs
@@ -0,0 +1,15 @@
+//! Tools for translating wasm function bytecode to Cranelift IR.
+
+mod code_translator;
+mod func_environ;
+mod func_state;
+mod func_translator;
+mod translation_utils;
+mod unwind;
+
+pub use self::func_environ::{FuncEnvironment, GlobalVariable, TargetEnvironment};
+pub use self::func_translator::FuncTranslator;
+pub use self::translation_utils::{
+    irlibcall_to_libcall, irreloc_to_relocationkind, signature_to_cranelift_ir, type_to_irtype,
+};
+pub(crate) use self::unwind::{compiled_function_unwind_info, CraneliftUnwindInfo};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/translation_utils.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/translation_utils.rs
new file mode 100644
index 0000000..eb33af5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/translation_utils.rs
@@ -0,0 +1,145 @@
+//! Helper functions and structures for the translation.
+
+use super::func_environ::TargetEnvironment;
+use crate::std::string::ToString;
+use core::u32;
+use cranelift_codegen::binemit::Reloc;
+use cranelift_codegen::ir::{self, AbiParam};
+use cranelift_codegen::isa::TargetFrontendConfig;
+use cranelift_frontend::FunctionBuilder;
+use wasmer_compiler::wasmparser;
+use wasmer_types::{FunctionType, LibCall, RelocationKind, Type, WasmError, WasmResult};
+
+/// Helper function translate a Function signature into Cranelift Ir
+pub fn signature_to_cranelift_ir(
+    signature: &FunctionType,
+    target_config: TargetFrontendConfig,
+) -> ir::Signature {
+    let mut sig = ir::Signature::new(target_config.default_call_conv);
+    sig.params.extend(signature.params().iter().map(|&ty| {
+        let cret_arg: ir::Type = type_to_irtype(ty, target_config)
+            .expect("only numeric types are supported in function signatures");
+        AbiParam::new(cret_arg)
+    }));
+    sig.returns.extend(signature.results().iter().map(|&ty| {
+        let cret_arg: ir::Type = type_to_irtype(ty, target_config)
+            .expect("only numeric types are supported in function signatures");
+        AbiParam::new(cret_arg)
+    }));
+    // The Vmctx signature
+    sig.params.insert(
+        0,
+        AbiParam::special(target_config.pointer_type(), ir::ArgumentPurpose::VMContext),
+    );
+    sig
+}
+
+/// Helper function translating wasmparser types to Cranelift types when possible.
+pub fn reference_type(target_config: TargetFrontendConfig) -> WasmResult<ir::Type> {
+    match target_config.pointer_type() {
+        ir::types::I32 => Ok(ir::types::R32),
+        ir::types::I64 => Ok(ir::types::R64),
+        _ => Err(WasmError::Unsupported(
+            "unsupported pointer type".to_string(),
+        )),
+    }
+}
+
+/// Helper function translating wasmparser types to Cranelift types when possible.
+pub fn type_to_irtype(ty: Type, target_config: TargetFrontendConfig) -> WasmResult<ir::Type> {
+    match ty {
+        Type::I32 => Ok(ir::types::I32),
+        Type::I64 => Ok(ir::types::I64),
+        Type::F32 => Ok(ir::types::F32),
+        Type::F64 => Ok(ir::types::F64),
+        Type::V128 => Ok(ir::types::I8X16),
+        Type::ExternRef | Type::FuncRef => reference_type(target_config),
+        // ty => Err(wasm_unsupported!("type_to_type: wasm type {:?}", ty)),
+    }
+}
+
+/// Transform Cranelift LibCall into runtime LibCall
+pub fn irlibcall_to_libcall(libcall: ir::LibCall) -> LibCall {
+    match libcall {
+        ir::LibCall::Probestack => LibCall::Probestack,
+        ir::LibCall::CeilF32 => LibCall::CeilF32,
+        ir::LibCall::CeilF64 => LibCall::CeilF64,
+        ir::LibCall::FloorF32 => LibCall::FloorF32,
+        ir::LibCall::FloorF64 => LibCall::FloorF64,
+        ir::LibCall::TruncF32 => LibCall::TruncF32,
+        ir::LibCall::TruncF64 => LibCall::TruncF64,
+        ir::LibCall::NearestF32 => LibCall::NearestF32,
+        ir::LibCall::NearestF64 => LibCall::NearestF64,
+        _ => panic!("Unsupported libcall"),
+    }
+}
+
+/// Transform Cranelift Reloc to compiler Relocation
+pub fn irreloc_to_relocationkind(reloc: Reloc) -> RelocationKind {
+    match reloc {
+        Reloc::Abs4 => RelocationKind::Abs4,
+        Reloc::Abs8 => RelocationKind::Abs8,
+        Reloc::X86PCRel4 => RelocationKind::X86PCRel4,
+        Reloc::X86CallPCRel4 => RelocationKind::X86CallPCRel4,
+        Reloc::X86CallPLTRel4 => RelocationKind::X86CallPLTRel4,
+        Reloc::X86GOTPCRel4 => RelocationKind::X86GOTPCRel4,
+        Reloc::Arm64Call => RelocationKind::Arm64Call,
+        Reloc::RiscvCall => RelocationKind::RiscvCall,
+        _ => panic!("The relocation {} is not yet supported.", reloc),
+    }
+}
+
+/// Create a `Block` with the given Wasm parameters.
+pub fn block_with_params<'a, PE: TargetEnvironment + ?Sized>(
+    builder: &mut FunctionBuilder,
+    params: impl Iterator<Item = &'a wasmparser::ValType>,
+    environ: &PE,
+) -> WasmResult<ir::Block> {
+    let block = builder.create_block();
+    for ty in params.into_iter() {
+        match ty {
+            wasmparser::ValType::I32 => {
+                builder.append_block_param(block, ir::types::I32);
+            }
+            wasmparser::ValType::I64 => {
+                builder.append_block_param(block, ir::types::I64);
+            }
+            wasmparser::ValType::F32 => {
+                builder.append_block_param(block, ir::types::F32);
+            }
+            wasmparser::ValType::F64 => {
+                builder.append_block_param(block, ir::types::F64);
+            }
+            wasmparser::ValType::Ref(ty) => {
+                if ty.is_extern_ref() || ty.is_func_ref() {
+                    builder.append_block_param(block, environ.reference_type());
+                } else {
+                    return Err(WasmError::Unsupported(format!(
+                        "unsupported reference type: {:?}",
+                        ty
+                    )));
+                }
+            }
+            wasmparser::ValType::V128 => {
+                builder.append_block_param(block, ir::types::I8X16);
+            }
+        }
+    }
+    Ok(block)
+}
+
+/// Turns a `wasmparser` `f32` into a `Cranelift` one.
+pub fn f32_translation(x: wasmparser::Ieee32) -> ir::immediates::Ieee32 {
+    ir::immediates::Ieee32::with_bits(x.bits())
+}
+
+/// Turns a `wasmparser` `f64` into a `Cranelift` one.
+pub fn f64_translation(x: wasmparser::Ieee64) -> ir::immediates::Ieee64 {
+    ir::immediates::Ieee64::with_bits(x.bits())
+}
+
+/// Special VMContext value label. It is tracked as 0xffff_fffe label.
+pub fn get_vmctx_value_label() -> ir::ValueLabel {
+    const VMCTX_LABEL: u32 = 0xffff_fffe;
+    ir::ValueLabel::from_u32(VMCTX_LABEL)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/unwind.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/unwind.rs
new file mode 100644
index 0000000..4de700b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-cranelift/src/translator/unwind.rs
@@ -0,0 +1,70 @@
+//! A `Compilation` contains the compiled function bodies for a WebAssembly
+//! module.
+
+#[cfg(feature = "unwind")]
+use cranelift_codegen::isa::unwind::{systemv::UnwindInfo as DwarfFDE, UnwindInfo};
+use cranelift_codegen::print_errors::pretty_error;
+use cranelift_codegen::{isa, Context};
+use wasmer_types::CompileError;
+use wasmer_types::CompiledFunctionUnwindInfo;
+
+/// Cranelift specific unwind info
+pub(crate) enum CraneliftUnwindInfo {
+    #[cfg(feature = "unwind")]
+    /// Windows Unwind info
+    WindowsX64(Vec<u8>),
+    /// Dwarf FDE
+    #[cfg(feature = "unwind")]
+    Fde(DwarfFDE),
+    /// No Unwind info attached
+    None,
+}
+
+impl CraneliftUnwindInfo {
+    /// Transform the `CraneliftUnwindInfo` to the Windows format.
+    ///
+    /// We skip the DWARF as it is not needed for trampolines (which are the
+    /// main users of this function)
+    pub fn maybe_into_to_windows_unwind(self) -> Option<CompiledFunctionUnwindInfo> {
+        match self {
+            #[cfg(feature = "unwind")]
+            Self::WindowsX64(unwind_info) => {
+                Some(CompiledFunctionUnwindInfo::WindowsX64(unwind_info))
+            }
+            _ => None,
+        }
+    }
+}
+
+#[cfg(feature = "unwind")]
+/// Constructs unwind info object from Cranelift IR
+pub(crate) fn compiled_function_unwind_info(
+    isa: &dyn isa::TargetIsa,
+    context: &Context,
+) -> Result<CraneliftUnwindInfo, CompileError> {
+    let unwind_info = context
+        .compiled_code()
+        .unwrap()
+        .create_unwind_info(isa)
+        .map_err(|error| CompileError::Codegen(pretty_error(&context.func, error)))?;
+
+    match unwind_info {
+        Some(UnwindInfo::WindowsX64(unwind)) => {
+            let size = unwind.emit_size();
+            let mut data: Vec<u8> = vec![0; size];
+            unwind.emit(&mut data[..]);
+            Ok(CraneliftUnwindInfo::WindowsX64(data))
+        }
+        Some(UnwindInfo::SystemV(unwind)) => Ok(CraneliftUnwindInfo::Fde(unwind)),
+        Some(_) | None => Ok(CraneliftUnwindInfo::None),
+    }
+}
+
+#[cfg(not(feature = "unwind"))]
+/// Constructs unwind info object from Cranelift IR
+pub(crate) fn compiled_function_unwind_info(
+    isa: &dyn isa::TargetIsa,
+    context: &Context,
+) -> Result<CraneliftUnwindInfo, CompileError> {
+    Ok(CraneliftUnwindInfo::None)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/Cargo.toml
new file mode 100644
index 0000000..ff111b4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/Cargo.toml
@@ -0,0 +1,47 @@
+[package]
+name = "wasmer-compiler-llvm"
+description = "LLVM compiler for Wasmer WebAssembly runtime"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly", "compiler", "llvm"]
+documentation = "https://docs.rs/wasmer-compiler-llvm/"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer-compiler = { path = "../compiler", version = "=4.2.8", features = [
+    "translator", "compiler"
+] }
+wasmer-vm = { path = "../vm", version = "=4.2.8" }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+target-lexicon = { version = "0.12.2", default-features = false }
+smallvec = "1.6"
+object = { version = "0.28.3", default-features = false, features = ["read"] }
+libc = { version = "^0.2", default-features = false }
+byteorder = "1"
+itertools = "0.10"
+rayon = "1.5"
+
+[dependencies.inkwell]
+package = "inkwell"
+version = "0.1.1"
+default-features = false
+features = ["llvm15-0", "target-x86", "target-aarch64", "target-riscv"]
+
+[build-dependencies]
+cc = "1.0"
+lazy_static = "1.4"
+regex = "1.5"
+semver = "1.0"
+rustc_version = "0.4"
+
+[features]
+test = []
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/README.md b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/README.md
new file mode 100644
index 0000000..a8778e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/README.md
@@ -0,0 +1,47 @@
+# `wasmer-compiler-llvm` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-llvm.svg)](https://crates.io/crates/wasmer-compiler-llvm)
+
+This crate contains a compiler implementation based on [the LLVM Compiler Infrastructure][LLVM].
+
+## Usage
+
+```rust
+use wasmer::{Store, EngineBuilder};
+use wasmer_compiler_llvm::LLVM;
+
+let compiler = LLVM::new();
+let mut store = Store::new(compiler);
+```
+
+*Note: you can find a [full working example using LLVM compiler here][example].*
+
+## When to use LLVM
+
+We recommend using LLVM as the default compiler when running WebAssembly
+files on any **production** system, as it offers maximum peformance near
+to native speeds.
+
+## Requirements
+
+The LLVM compiler requires a valid installation of LLVM in your system.
+It currently requires **LLVM 15**.
+
+
+You can install LLVM easily on your Debian-like system via this command:
+
+```bash
+wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh
+sudo bash /tmp/llvm.sh 14
+```
+
+Or in macOS:
+
+```bash
+brew install llvm@14
+```
+
+Or via any of the [pre-built binaries that LLVM offers][llvm-pre-built].
+
+
+[LLVM]: https://llvm.org/
+[example]: https://github.com/wasmerio/wasmer/blob/master/examples/compiler_llvm.rs
+[llvm-pre-built]: https://releases.llvm.org/download.html
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/aarch64_systemv.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/aarch64_systemv.rs
new file mode 100644
index 0000000..7ebf68b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/aarch64_systemv.rs
@@ -0,0 +1,638 @@
+use crate::abi::Abi;
+use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    builder::Builder,
+    context::Context,
+    types::{AnyType, BasicMetadataTypeEnum, BasicType, FunctionType, StructType},
+    values::{BasicValue, BasicValueEnum, CallSiteValue, FunctionValue, IntValue, PointerValue},
+    AddressSpace,
+};
+use wasmer_types::CompileError;
+use wasmer_types::{FunctionType as FuncSig, Type};
+use wasmer_vm::VMOffsets;
+
+use std::convert::TryInto;
+
+/// Implementation of the [`Abi`] trait for the Aarch64 ABI on Linux.
+pub struct Aarch64SystemV {}
+
+impl Abi for Aarch64SystemV {
+    // Given a function definition, retrieve the parameter that is the vmctx pointer.
+    fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
+        func_value
+            .get_nth_param(u32::from(
+                func_value
+                    .get_enum_attribute(
+                        AttributeLoc::Param(0),
+                        Attribute::get_named_enum_kind_id("sret"),
+                    )
+                    .is_some(),
+            ))
+            .unwrap()
+            .into_pointer_value()
+    }
+
+    // Given a wasm function type, produce an llvm function declaration.
+    fn func_type_to_llvm<'ctx>(
+        &self,
+        context: &'ctx Context,
+        intrinsics: &Intrinsics<'ctx>,
+        offsets: Option<&VMOffsets>,
+        sig: &FuncSig,
+    ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError> {
+        let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
+
+        let param_types =
+            std::iter::once(Ok(intrinsics.ctx_ptr_ty.as_basic_type_enum())).chain(user_param_types);
+
+        let vmctx_attributes = |i: u32| {
+            vec![
+                (
+                    context.create_enum_attribute(Attribute::get_named_enum_kind_id("nofree"), 0),
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    if let Some(offsets) = offsets {
+                        context.create_enum_attribute(
+                            Attribute::get_named_enum_kind_id("dereferenceable"),
+                            offsets.size_of_vmctx().into(),
+                        )
+                    } else {
+                        context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("nonnull"), 0)
+                    },
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    context.create_enum_attribute(
+                        Attribute::get_named_enum_kind_id("align"),
+                        std::mem::align_of::<wasmer_vm::VMContext>()
+                            .try_into()
+                            .unwrap(),
+                    ),
+                    AttributeLoc::Param(i),
+                ),
+            ]
+        };
+
+        Ok(match sig.results() {
+            [] => (
+                intrinsics.void_ty.fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [_] => {
+                let single_value = sig.results()[0];
+                (
+                    type_to_llvm(intrinsics, single_value)?.fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [Type::F32, Type::F32] => {
+                let f32_ty = intrinsics.f32_ty.as_basic_type_enum();
+                (
+                    context.struct_type(&[f32_ty, f32_ty], false).fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [Type::F64, Type::F64] => {
+                let f64_ty = intrinsics.f64_ty.as_basic_type_enum();
+                (
+                    context.struct_type(&[f64_ty, f64_ty], false).fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [Type::F32, Type::F32, Type::F32] => {
+                let f32_ty = intrinsics.f32_ty.as_basic_type_enum();
+                (
+                    context
+                        .struct_type(&[f32_ty, f32_ty, f32_ty], false)
+                        .fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                    vmctx_attributes(0),
+                )
+            }
+            [Type::F32, Type::F32, Type::F32, Type::F32] => {
+                let f32_ty = intrinsics.f32_ty.as_basic_type_enum();
+                (
+                    context
+                        .struct_type(&[f32_ty, f32_ty, f32_ty, f32_ty], false)
+                        .fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                    vmctx_attributes(0),
+                )
+            }
+            _ => {
+                let sig_returns_bitwidths = sig
+                    .results()
+                    .iter()
+                    .map(|ty| match ty {
+                        Type::I32 | Type::F32 => 32,
+                        Type::I64 | Type::F64 => 64,
+                        Type::V128 => 128,
+                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                    })
+                    .collect::<Vec<i32>>();
+                match sig_returns_bitwidths.as_slice() {
+                    [32, 32] => (
+                        intrinsics.i64_ty.fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                        vmctx_attributes(0),
+                    ),
+                    [32, 64]
+                    | [64, 32]
+                    | [64, 64]
+                    | [32, 32, 32]
+                    | [64, 32, 32]
+                    | [32, 32, 64]
+                    | [32, 32, 32, 32] => (
+                        intrinsics.i64_ty.array_type(2).fn_type(
+                            param_types
+                                .map(|v| v.map(Into::into))
+                                .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                .as_slice(),
+                            false,
+                        ),
+                        vmctx_attributes(0),
+                    ),
+                    _ => {
+                        let basic_types: Vec<_> = sig
+                            .results()
+                            .iter()
+                            .map(|&ty| type_to_llvm(intrinsics, ty))
+                            .collect::<Result<_, _>>()?;
+
+                        let sret = context.struct_type(&basic_types, false);
+                        let sret_ptr = sret.ptr_type(AddressSpace::default());
+
+                        let param_types =
+                            std::iter::once(Ok(sret_ptr.as_basic_type_enum())).chain(param_types);
+
+                        let mut attributes = vec![(
+                            context.create_type_attribute(
+                                Attribute::get_named_enum_kind_id("sret"),
+                                sret.as_any_type_enum(),
+                            ),
+                            AttributeLoc::Param(0),
+                        )];
+                        attributes.append(&mut vmctx_attributes(1));
+
+                        (
+                            intrinsics.void_ty.fn_type(
+                                param_types
+                                    .map(|v| v.map(Into::into))
+                                    .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                                    .as_slice(),
+                                false,
+                            ),
+                            attributes,
+                        )
+                    }
+                }
+            }
+        })
+    }
+
+    // Marshall wasm stack values into function parameters.
+    fn args_to_call<'ctx>(
+        &self,
+        alloca_builder: &Builder<'ctx>,
+        func_sig: &FuncSig,
+        llvm_fn_ty: &FunctionType<'ctx>,
+        ctx_ptr: PointerValue<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> Vec<BasicValueEnum<'ctx>> {
+        // If it's an sret, allocate the return space.
+        let sret = if llvm_fn_ty.get_return_type().is_none() && func_sig.results().len() > 1 {
+            let llvm_params: Vec<_> = func_sig
+                .results()
+                .iter()
+                .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                .collect();
+            let llvm_params = llvm_fn_ty
+                .get_context()
+                .struct_type(llvm_params.as_slice(), false);
+            Some(alloca_builder.build_alloca(llvm_params, "sret"))
+        } else {
+            None
+        };
+
+        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
+
+        if let Some(sret) = sret {
+            std::iter::once(sret.as_basic_value_enum())
+                .chain(values)
+                .collect()
+        } else {
+            values.collect()
+        }
+    }
+
+    // Given a CallSite, extract the returned values and return them in a Vec.
+    fn rets_from_call<'ctx>(
+        &self,
+        builder: &Builder<'ctx>,
+        intrinsics: &Intrinsics<'ctx>,
+        call_site: CallSiteValue<'ctx>,
+        func_sig: &FuncSig,
+    ) -> Vec<BasicValueEnum<'ctx>> {
+        let split_i64 = |value: IntValue<'ctx>| -> (IntValue<'ctx>, IntValue<'ctx>) {
+            assert!(value.get_type() == intrinsics.i64_ty);
+            let low = builder.build_int_truncate(value, intrinsics.i32_ty, "");
+            let lshr =
+                builder.build_right_shift(value, intrinsics.i64_ty.const_int(32, false), false, "");
+            let high = builder.build_int_truncate(lshr, intrinsics.i32_ty, "");
+            (low, high)
+        };
+
+        let casted = |value: BasicValueEnum<'ctx>, ty: Type| -> BasicValueEnum<'ctx> {
+            match ty {
+                Type::I32 => {
+                    assert!(
+                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.i32_ty, "")
+                }
+                Type::F32 => {
+                    assert!(
+                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.f32_ty, "")
+                }
+                Type::I64 => {
+                    assert!(
+                        value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.i64_ty, "")
+                }
+                Type::F64 => {
+                    assert!(
+                        value.get_type() == intrinsics.i64_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f64_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.f64_ty, "")
+                }
+                Type::V128 => {
+                    assert!(value.get_type() == intrinsics.i128_ty.as_basic_type_enum());
+                    value
+                }
+                Type::ExternRef | Type::FuncRef => {
+                    assert!(value.get_type() == intrinsics.funcref_ty.as_basic_type_enum());
+                    value
+                }
+            }
+        };
+
+        if let Some(basic_value) = call_site.try_as_basic_value().left() {
+            if func_sig.results().len() > 1 {
+                if basic_value.get_type() == intrinsics.i64_ty.as_basic_type_enum() {
+                    assert!(func_sig.results().len() == 2);
+                    let value = basic_value.into_int_value();
+                    let (low, high) = split_i64(value);
+                    let low = casted(low.into(), func_sig.results()[0]);
+                    let high = casted(high.into(), func_sig.results()[1]);
+                    return vec![low, high];
+                }
+                if basic_value.is_struct_value() {
+                    let struct_value = basic_value.into_struct_value();
+                    return (0..struct_value.get_type().count_fields())
+                        .map(|i| builder.build_extract_value(struct_value, i, "").unwrap())
+                        .collect::<Vec<_>>();
+                }
+                let array_value = basic_value.into_array_value();
+                let low = builder
+                    .build_extract_value(array_value, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let high = builder
+                    .build_extract_value(array_value, 1, "")
+                    .unwrap()
+                    .into_int_value();
+                let func_sig_returns_bitwidths = func_sig
+                    .results()
+                    .iter()
+                    .map(|ty| match ty {
+                        Type::I32 | Type::F32 => 32,
+                        Type::I64 | Type::F64 => 64,
+                        Type::V128 => 128,
+                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                    })
+                    .collect::<Vec<i32>>();
+
+                match func_sig_returns_bitwidths.as_slice() {
+                    [32, 64] => {
+                        let (low, _) = split_i64(low);
+                        let low = casted(low.into(), func_sig.results()[0]);
+                        let high = casted(high.into(), func_sig.results()[1]);
+                        vec![low, high]
+                    }
+                    [64, 32] => {
+                        let (high, _) = split_i64(high);
+                        let low = casted(low.into(), func_sig.results()[0]);
+                        let high = casted(high.into(), func_sig.results()[1]);
+                        vec![low, high]
+                    }
+                    [64, 64] => {
+                        let low = casted(low.into(), func_sig.results()[0]);
+                        let high = casted(high.into(), func_sig.results()[1]);
+                        vec![low, high]
+                    }
+                    [32, 32, 32] => {
+                        let (v1, v2) = split_i64(low);
+                        let (v3, _) = split_i64(high);
+                        let v1 = casted(v1.into(), func_sig.results()[0]);
+                        let v2 = casted(v2.into(), func_sig.results()[1]);
+                        let v3 = casted(v3.into(), func_sig.results()[2]);
+                        vec![v1, v2, v3]
+                    }
+                    [32, 32, 64] => {
+                        let (v1, v2) = split_i64(low);
+                        let v1 = casted(v1.into(), func_sig.results()[0]);
+                        let v2 = casted(v2.into(), func_sig.results()[1]);
+                        let v3 = casted(high.into(), func_sig.results()[2]);
+                        vec![v1, v2, v3]
+                    }
+                    [64, 32, 32] => {
+                        let v1 = casted(low.into(), func_sig.results()[0]);
+                        let (v2, v3) = split_i64(high);
+                        let v2 = casted(v2.into(), func_sig.results()[1]);
+                        let v3 = casted(v3.into(), func_sig.results()[2]);
+                        vec![v1, v2, v3]
+                    }
+                    [32, 32, 32, 32] => {
+                        let (v1, v2) = split_i64(low);
+                        let (v3, v4) = split_i64(high);
+                        let v1 = casted(v1.into(), func_sig.results()[0]);
+                        let v2 = casted(v2.into(), func_sig.results()[1]);
+                        let v3 = casted(v3.into(), func_sig.results()[2]);
+                        let v4 = casted(v4.into(), func_sig.results()[3]);
+                        vec![v1, v2, v3, v4]
+                    }
+                    _ => unreachable!("expected an sret for this type"),
+                }
+            } else {
+                assert!(func_sig.results().len() == 1);
+                vec![basic_value]
+            }
+        } else {
+            assert!(call_site.count_arguments() > 0); // Either sret or vmctx.
+            if call_site
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some()
+            {
+                let sret_ty = call_site
+                    .try_as_basic_value()
+                    .right()
+                    .unwrap()
+                    .get_operand(0)
+                    .unwrap()
+                    .left()
+                    .unwrap();
+                let sret = sret_ty.into_pointer_value();
+                // re-build the llvm-type struct holding the return values
+                let llvm_results: Vec<_> = func_sig
+                    .results()
+                    .iter()
+                    .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                    .collect();
+                let struct_type = intrinsics
+                    .i32_ty
+                    .get_context()
+                    .struct_type(llvm_results.as_slice(), false);
+
+                let struct_value = builder
+                    .build_load(struct_type, sret, "")
+                    .into_struct_value();
+                let mut rets: Vec<_> = Vec::new();
+                for i in 0..struct_value.get_type().count_fields() {
+                    let value = builder.build_extract_value(struct_value, i, "").unwrap();
+                    rets.push(value);
+                }
+                assert!(func_sig.results().len() == rets.len());
+                rets
+            } else {
+                assert!(func_sig.results().is_empty());
+                vec![]
+            }
+        }
+    }
+
+    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError> {
+        let func_sig_returns_bitwidths = func_sig
+            .results()
+            .iter()
+            .map(|ty| match ty {
+                Type::I32 | Type::F32 => 32,
+                Type::I64 | Type::F64 => 64,
+                Type::V128 => 128,
+                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+            })
+            .collect::<Vec<i32>>();
+
+        Ok(!matches!(
+            func_sig_returns_bitwidths.as_slice(),
+            [] | [_]
+                | [32, 32]
+                | [32, 64]
+                | [64, 32]
+                | [64, 64]
+                | [32, 32, 32]
+                | [32, 32, 64]
+                | [64, 32, 32]
+                | [32, 32, 32, 32]
+        ))
+    }
+
+    fn pack_values_for_register_return<'ctx>(
+        &self,
+        intrinsics: &Intrinsics<'ctx>,
+        builder: &Builder<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        func_type: &FunctionType<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
+        let is_32 = |value: BasicValueEnum| {
+            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i32_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f32_ty)
+        };
+        let is_64 = |value: BasicValueEnum| {
+            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f64_ty)
+        };
+
+        let pack_i32s = |low: BasicValueEnum<'ctx>, high: BasicValueEnum<'ctx>| {
+            assert!(low.get_type() == intrinsics.i32_ty.as_basic_type_enum());
+            assert!(high.get_type() == intrinsics.i32_ty.as_basic_type_enum());
+            let (low, high) = (low.into_int_value(), high.into_int_value());
+            let low = builder.build_int_z_extend(low, intrinsics.i64_ty, "");
+            let high = builder.build_int_z_extend(high, intrinsics.i64_ty, "");
+            let high = builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), "");
+            builder.build_or(low, high, "").as_basic_value_enum()
+        };
+
+        let to_i64 = |v: BasicValueEnum<'ctx>| {
+            if v.is_float_value() {
+                let v = v.into_float_value();
+                if v.get_type() == intrinsics.f32_ty {
+                    let v = builder
+                        .build_bitcast(v, intrinsics.i32_ty, "")
+                        .into_int_value();
+                    let v = builder.build_int_z_extend(v, intrinsics.i64_ty, "");
+                    v.as_basic_value_enum()
+                } else {
+                    debug_assert!(v.get_type() == intrinsics.f64_ty);
+                    let v = builder.build_bitcast(v, intrinsics.i64_ty, "");
+                    v.as_basic_value_enum()
+                }
+            } else {
+                let v = v.into_int_value();
+                if v.get_type() == intrinsics.i32_ty {
+                    let v = builder.build_int_z_extend(v, intrinsics.i64_ty, "");
+                    v.as_basic_value_enum()
+                } else {
+                    debug_assert!(v.get_type() == intrinsics.i64_ty);
+                    v.as_basic_value_enum()
+                }
+            }
+        };
+
+        let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
+            let mut struct_value = ty.get_undef();
+            for (i, v) in values.iter().enumerate() {
+                struct_value = builder
+                    .build_insert_value(struct_value, *v, i as u32, "")
+                    .unwrap()
+                    .into_struct_value();
+            }
+            struct_value.as_basic_value_enum()
+        };
+
+        let build_2xi64 = |low: BasicValueEnum<'ctx>, high: BasicValueEnum<'ctx>| {
+            let low = to_i64(low);
+            let high = to_i64(high);
+            let value = intrinsics.i64_ty.array_type(2).get_undef();
+            let value = builder.build_insert_value(value, low, 0, "").unwrap();
+            let value = builder.build_insert_value(value, high, 1, "").unwrap();
+            value.as_basic_value_enum()
+        };
+
+        Ok(match *values {
+            [one_value] => one_value,
+            [v1, v2]
+                if v1.is_float_value()
+                    && v2.is_float_value()
+                    && v1.into_float_value().get_type() == v2.into_float_value().get_type() =>
+            {
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, v2],
+                )
+            }
+            [v1, v2] if is_32(v1) && is_32(v2) => {
+                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                pack_i32s(v1, v2)
+            }
+            [v1, v2] => build_2xi64(v1, v2),
+            [v1, v2, v3]
+                if is_32(v1)
+                    && is_32(v2)
+                    && is_32(v3)
+                    && v1.is_float_value()
+                    && v2.is_float_value()
+                    && v3.is_float_value() =>
+            {
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, v2, v3],
+                )
+            }
+            [v1, v2, v3] if is_32(v1) && is_32(v2) => {
+                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                let v1v2_pack = pack_i32s(v1, v2);
+                build_2xi64(v1v2_pack, v3)
+            }
+            [v1, v2, v3] if is_64(v1) && is_32(v2) && is_32(v3) => {
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
+                let v2v3_pack = pack_i32s(v2, v3);
+                build_2xi64(v1, v2v3_pack)
+            }
+            [v1, v2, v3, v4]
+                if is_32(v1)
+                    && is_32(v2)
+                    && is_32(v3)
+                    && is_32(v4)
+                    && v1.is_float_value()
+                    && v2.is_float_value()
+                    && v3.is_float_value()
+                    && v4.is_float_value() =>
+            {
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, v2, v3, v4],
+                )
+            }
+            [v1, v2, v3, v4] if is_32(v1) && is_32(v2) && is_32(v3) && is_32(v4) => {
+                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                let v1v2_pack = pack_i32s(v1, v2);
+                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
+                let v4 = builder.build_bitcast(v4, intrinsics.i32_ty, "");
+                let v3v4_pack = pack_i32s(v3, v4);
+                build_2xi64(v1v2_pack, v3v4_pack)
+            }
+            _ => {
+                unreachable!("called to perform register return on struct return or void function")
+            }
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/mod.rs
new file mode 100644
index 0000000..06c3bbf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/mod.rs
@@ -0,0 +1,88 @@
+// LLVM implements part of the ABI lowering internally, but also requires that
+// the user pack and unpack values themselves sometimes. This can help the LLVM
+// optimizer by exposing operations to the optimizer, but it requires that the
+// frontend know exactly what IR to produce in order to get the right ABI.
+
+#![deny(dead_code, missing_docs)]
+
+use crate::translator::intrinsics::Intrinsics;
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    builder::Builder,
+    context::Context,
+    targets::TargetMachine,
+    types::FunctionType,
+    values::{BasicValueEnum, CallSiteValue, FunctionValue, PointerValue},
+};
+use wasmer_types::CompileError;
+use wasmer_types::FunctionType as FuncSig;
+use wasmer_vm::VMOffsets;
+
+mod aarch64_systemv;
+mod x86_64_systemv;
+
+use aarch64_systemv::Aarch64SystemV;
+use x86_64_systemv::X86_64SystemV;
+
+pub fn get_abi(target_machine: &TargetMachine) -> Box<dyn Abi> {
+    if target_machine
+        .get_triple()
+        .as_str()
+        .to_string_lossy()
+        .starts_with("aarch64")
+    {
+        Box::new(Aarch64SystemV {})
+    } else {
+        Box::new(X86_64SystemV {})
+    }
+}
+
+/// We need to produce different LLVM IR for different platforms. (Contrary to
+/// popular knowledge LLVM IR is not intended to be portable in that way.) This
+/// trait deals with differences between function signatures on different
+/// targets.
+pub trait Abi {
+    /// Given a function definition, retrieve the parameter that is the vmctx pointer.
+    fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx>;
+
+    /// Given a wasm function type, produce an llvm function declaration.
+    fn func_type_to_llvm<'ctx>(
+        &self,
+        context: &'ctx Context,
+        intrinsics: &Intrinsics<'ctx>,
+        offsets: Option<&VMOffsets>,
+        sig: &FuncSig,
+    ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError>;
+
+    /// Marshall wasm stack values into function parameters.
+    fn args_to_call<'ctx>(
+        &self,
+        alloca_builder: &Builder<'ctx>,
+        func_sig: &FuncSig,
+        llvm_fn_ty: &FunctionType<'ctx>,
+        ctx_ptr: PointerValue<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> Vec<BasicValueEnum<'ctx>>;
+
+    /// Given a CallSite, extract the returned values and return them in a Vec.
+    fn rets_from_call<'ctx>(
+        &self,
+        builder: &Builder<'ctx>,
+        intrinsics: &Intrinsics<'ctx>,
+        call_site: CallSiteValue<'ctx>,
+        func_sig: &FuncSig,
+    ) -> Vec<BasicValueEnum<'ctx>>;
+
+    /// Whether the llvm equivalent of this wasm function has an `sret` attribute.
+    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError>;
+
+    /// Pack LLVM IR values representing individual wasm values into the return type for the function.
+    fn pack_values_for_register_return<'ctx>(
+        &self,
+        intrinsics: &Intrinsics<'ctx>,
+        builder: &Builder<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        func_type: &FunctionType<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError>;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/x86_64_systemv.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/x86_64_systemv.rs
new file mode 100644
index 0000000..47f1f75
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/abi/x86_64_systemv.rs
@@ -0,0 +1,663 @@
+use crate::abi::Abi;
+use crate::translator::intrinsics::{type_to_llvm, Intrinsics};
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    builder::Builder,
+    context::Context,
+    types::{AnyType, BasicMetadataTypeEnum, BasicType, FunctionType, StructType},
+    values::{
+        BasicValue, BasicValueEnum, CallSiteValue, FloatValue, FunctionValue, IntValue,
+        PointerValue, VectorValue,
+    },
+    AddressSpace,
+};
+use wasmer_types::{CompileError, FunctionType as FuncSig, Type};
+use wasmer_vm::VMOffsets;
+
+use std::convert::TryInto;
+
+/// Implementation of the [`Abi`] trait for the AMD64 SystemV ABI.
+pub struct X86_64SystemV {}
+
+impl Abi for X86_64SystemV {
+    // Given a function definition, retrieve the parameter that is the vmctx pointer.
+    fn get_vmctx_ptr_param<'ctx>(&self, func_value: &FunctionValue<'ctx>) -> PointerValue<'ctx> {
+        func_value
+            .get_nth_param(u32::from(
+                func_value
+                    .get_enum_attribute(
+                        AttributeLoc::Param(0),
+                        Attribute::get_named_enum_kind_id("sret"),
+                    )
+                    .is_some(),
+            ))
+            .unwrap()
+            .into_pointer_value()
+    }
+
+    // Given a wasm function type, produce an llvm function declaration.
+    fn func_type_to_llvm<'ctx>(
+        &self,
+        context: &'ctx Context,
+        intrinsics: &Intrinsics<'ctx>,
+        offsets: Option<&VMOffsets>,
+        sig: &FuncSig,
+    ) -> Result<(FunctionType<'ctx>, Vec<(Attribute, AttributeLoc)>), CompileError> {
+        let user_param_types = sig.params().iter().map(|&ty| type_to_llvm(intrinsics, ty));
+
+        let param_types =
+            std::iter::once(Ok(intrinsics.ctx_ptr_ty.as_basic_type_enum())).chain(user_param_types);
+
+        // TODO: figure out how many bytes long vmctx is, and mark it dereferenceable. (no need to mark it nonnull once we do this.)
+        let vmctx_attributes = |i: u32| {
+            vec![
+                (
+                    context.create_enum_attribute(Attribute::get_named_enum_kind_id("nofree"), 0),
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    if let Some(offsets) = offsets {
+                        context.create_enum_attribute(
+                            Attribute::get_named_enum_kind_id("dereferenceable"),
+                            offsets.size_of_vmctx().into(),
+                        )
+                    } else {
+                        context
+                            .create_enum_attribute(Attribute::get_named_enum_kind_id("nonnull"), 0)
+                    },
+                    AttributeLoc::Param(i),
+                ),
+                (
+                    context.create_enum_attribute(
+                        Attribute::get_named_enum_kind_id("align"),
+                        std::mem::align_of::<wasmer_vm::VMContext>()
+                            .try_into()
+                            .unwrap(),
+                    ),
+                    AttributeLoc::Param(i),
+                ),
+            ]
+        };
+
+        let sig_returns_bitwidths = sig
+            .results()
+            .iter()
+            .map(|ty| match ty {
+                Type::I32 | Type::F32 => 32,
+                Type::I64 | Type::F64 => 64,
+                Type::V128 => 128,
+                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+            })
+            .collect::<Vec<i32>>();
+
+        Ok(match sig_returns_bitwidths.as_slice() {
+            [] => (
+                intrinsics.void_ty.fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [_] => {
+                let single_value = sig.results()[0];
+                (
+                    type_to_llvm(intrinsics, single_value)?.fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 64] | [64, 32] | [64, 64] => {
+                let basic_types: Vec<_> = sig
+                    .results()
+                    .iter()
+                    .map(|&ty| type_to_llvm(intrinsics, ty))
+                    .collect::<Result<_, _>>()?;
+
+                (
+                    context.struct_type(&basic_types, false).fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    vmctx_attributes(0),
+                )
+            }
+            [32, 32] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => (
+                intrinsics.f32_ty.vec_type(2).fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [32, 32] => (
+                intrinsics.i64_ty.fn_type(
+                    param_types
+                        .map(|v| v.map(Into::into))
+                        .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                        .as_slice(),
+                    false,
+                ),
+                vmctx_attributes(0),
+            ),
+            [32, 32, _] if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 => (
+                context
+                    .struct_type(
+                        &[
+                            intrinsics.f32_ty.vec_type(2).as_basic_type_enum(),
+                            type_to_llvm(intrinsics, sig.results()[2])?,
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            [32, 32, _] => (
+                context
+                    .struct_type(
+                        &[
+                            intrinsics.i64_ty.as_basic_type_enum(),
+                            type_to_llvm(intrinsics, sig.results()[2])?,
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            [64, 32, 32] if sig.results()[1] == Type::F32 && sig.results()[2] == Type::F32 => (
+                context
+                    .struct_type(
+                        &[
+                            type_to_llvm(intrinsics, sig.results()[0])?,
+                            intrinsics.f32_ty.vec_type(2).as_basic_type_enum(),
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            [64, 32, 32] => (
+                context
+                    .struct_type(
+                        &[
+                            type_to_llvm(intrinsics, sig.results()[0])?,
+                            intrinsics.i64_ty.as_basic_type_enum(),
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            [32, 32, 32, 32] => (
+                context
+                    .struct_type(
+                        &[
+                            if sig.results()[0] == Type::F32 && sig.results()[1] == Type::F32 {
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                            } else {
+                                intrinsics.i64_ty.as_basic_type_enum()
+                            },
+                            if sig.results()[2] == Type::F32 && sig.results()[3] == Type::F32 {
+                                intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                            } else {
+                                intrinsics.i64_ty.as_basic_type_enum()
+                            },
+                        ],
+                        false,
+                    )
+                    .fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                vmctx_attributes(0),
+            ),
+            _ => {
+                let basic_types: Vec<_> = sig
+                    .results()
+                    .iter()
+                    .map(|&ty| type_to_llvm(intrinsics, ty))
+                    .collect::<Result<_, _>>()?;
+
+                let sret = context.struct_type(&basic_types, false);
+                let sret_ptr = sret.ptr_type(AddressSpace::default());
+
+                let param_types =
+                    std::iter::once(Ok(sret_ptr.as_basic_type_enum())).chain(param_types);
+
+                let mut attributes = vec![(
+                    context.create_type_attribute(
+                        Attribute::get_named_enum_kind_id("sret"),
+                        sret.as_any_type_enum(),
+                    ),
+                    AttributeLoc::Param(0),
+                )];
+                attributes.append(&mut vmctx_attributes(1));
+
+                (
+                    intrinsics.void_ty.fn_type(
+                        param_types
+                            .map(|v| v.map(Into::into))
+                            .collect::<Result<Vec<BasicMetadataTypeEnum>, _>>()?
+                            .as_slice(),
+                        false,
+                    ),
+                    attributes,
+                )
+            }
+        })
+    }
+
+    // Marshall wasm stack values into function parameters.
+    fn args_to_call<'ctx>(
+        &self,
+        alloca_builder: &Builder<'ctx>,
+        func_sig: &FuncSig,
+        llvm_fn_ty: &FunctionType<'ctx>,
+        ctx_ptr: PointerValue<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> Vec<BasicValueEnum<'ctx>> {
+        // If it's an sret, allocate the return space.
+        let sret = if llvm_fn_ty.get_return_type().is_none() && func_sig.results().len() > 1 {
+            let llvm_params: Vec<_> = func_sig
+                .results()
+                .iter()
+                .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                .collect();
+            let llvm_params = llvm_fn_ty
+                .get_context()
+                .struct_type(llvm_params.as_slice(), false);
+            Some(alloca_builder.build_alloca(llvm_params, "sret"))
+        } else {
+            None
+        };
+
+        let values = std::iter::once(ctx_ptr.as_basic_value_enum()).chain(values.iter().copied());
+
+        if let Some(sret) = sret {
+            std::iter::once(sret.as_basic_value_enum())
+                .chain(values)
+                .collect()
+        } else {
+            values.collect()
+        }
+    }
+
+    // Given a CallSite, extract the returned values and return them in a Vec.
+    fn rets_from_call<'ctx>(
+        &self,
+        builder: &Builder<'ctx>,
+        intrinsics: &Intrinsics<'ctx>,
+        call_site: CallSiteValue<'ctx>,
+        func_sig: &FuncSig,
+    ) -> Vec<BasicValueEnum<'ctx>> {
+        let split_i64 = |value: IntValue<'ctx>| -> (IntValue<'ctx>, IntValue<'ctx>) {
+            assert!(value.get_type() == intrinsics.i64_ty);
+            let low = builder.build_int_truncate(value, intrinsics.i32_ty, "");
+            let lshr =
+                builder.build_right_shift(value, intrinsics.i64_ty.const_int(32, false), false, "");
+            let high = builder.build_int_truncate(lshr, intrinsics.i32_ty, "");
+            (low, high)
+        };
+
+        let f32x2_ty = intrinsics.f32_ty.vec_type(2).as_basic_type_enum();
+        let extract_f32x2 = |value: VectorValue<'ctx>| -> (FloatValue<'ctx>, FloatValue<'ctx>) {
+            assert!(value.get_type() == f32x2_ty.into_vector_type());
+            let ret0 = builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(0, false), "")
+                .into_float_value();
+            let ret1 = builder
+                .build_extract_element(value, intrinsics.i32_ty.const_int(1, false), "")
+                .into_float_value();
+            (ret0, ret1)
+        };
+
+        let casted = |value: BasicValueEnum<'ctx>, ty: Type| -> BasicValueEnum<'ctx> {
+            match ty {
+                Type::I32 => {
+                    assert!(
+                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.i32_ty, "")
+                }
+                Type::F32 => {
+                    assert!(
+                        value.get_type() == intrinsics.i32_ty.as_basic_type_enum()
+                            || value.get_type() == intrinsics.f32_ty.as_basic_type_enum()
+                    );
+                    builder.build_bitcast(value, intrinsics.f32_ty, "")
+                }
+                _ => panic!("should only be called to repack 32-bit values"),
+            }
+        };
+
+        if let Some(basic_value) = call_site.try_as_basic_value().left() {
+            if func_sig.results().len() > 1 {
+                if basic_value.get_type() == intrinsics.i64_ty.as_basic_type_enum() {
+                    assert!(func_sig.results().len() == 2);
+                    let value = basic_value.into_int_value();
+                    let (low, high) = split_i64(value);
+                    let low = casted(low.into(), func_sig.results()[0]);
+                    let high = casted(high.into(), func_sig.results()[1]);
+                    return vec![low, high];
+                }
+                if basic_value.get_type() == f32x2_ty {
+                    assert!(func_sig.results().len() == 2);
+                    let (ret0, ret1) = extract_f32x2(basic_value.into_vector_value());
+                    return vec![ret0.into(), ret1.into()];
+                }
+                let struct_value = basic_value.into_struct_value();
+                let rets = (0..struct_value.get_type().count_fields())
+                    .map(|i| builder.build_extract_value(struct_value, i, "").unwrap())
+                    .collect::<Vec<_>>();
+                let func_sig_returns_bitwidths = func_sig
+                    .results()
+                    .iter()
+                    .map(|ty| match ty {
+                        Type::I32 | Type::F32 => 32,
+                        Type::I64 | Type::F64 => 64,
+                        Type::V128 => 128,
+                        Type::ExternRef | Type::FuncRef => 64, /* pointer */
+                    })
+                    .collect::<Vec<i32>>();
+
+                match func_sig_returns_bitwidths.as_slice() {
+                    [32, 64] | [64, 32] | [64, 64] => {
+                        assert!(func_sig.results().len() == 2);
+                        vec![rets[0], rets[1]]
+                    }
+                    [32, 32, _]
+                        if rets[0].get_type()
+                            == intrinsics.f32_ty.vec_type(2).as_basic_type_enum() =>
+                    {
+                        assert!(func_sig.results().len() == 3);
+                        let (rets0, rets1) = extract_f32x2(rets[0].into_vector_value());
+                        vec![rets0.into(), rets1.into(), rets[1]]
+                    }
+                    [32, 32, _] => {
+                        assert!(func_sig.results().len() == 3);
+                        let (low, high) = split_i64(rets[0].into_int_value());
+                        let low = casted(low.into(), func_sig.results()[0]);
+                        let high = casted(high.into(), func_sig.results()[1]);
+                        vec![low, high, rets[1]]
+                    }
+                    [64, 32, 32]
+                        if rets[1].get_type()
+                            == intrinsics.f32_ty.vec_type(2).as_basic_type_enum() =>
+                    {
+                        assert!(func_sig.results().len() == 3);
+                        let (rets1, rets2) = extract_f32x2(rets[1].into_vector_value());
+                        vec![rets[0], rets1.into(), rets2.into()]
+                    }
+                    [64, 32, 32] => {
+                        assert!(func_sig.results().len() == 3);
+                        let (rets1, rets2) = split_i64(rets[1].into_int_value());
+                        let rets1 = casted(rets1.into(), func_sig.results()[1]);
+                        let rets2 = casted(rets2.into(), func_sig.results()[2]);
+                        vec![rets[0], rets1, rets2]
+                    }
+                    [32, 32, 32, 32] => {
+                        assert!(func_sig.results().len() == 4);
+                        let (low0, high0) = if rets[0].get_type()
+                            == intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                        {
+                            let (x, y) = extract_f32x2(rets[0].into_vector_value());
+                            (x.into(), y.into())
+                        } else {
+                            let (x, y) = split_i64(rets[0].into_int_value());
+                            (x.into(), y.into())
+                        };
+                        let (low1, high1) = if rets[1].get_type()
+                            == intrinsics.f32_ty.vec_type(2).as_basic_type_enum()
+                        {
+                            let (x, y) = extract_f32x2(rets[1].into_vector_value());
+                            (x.into(), y.into())
+                        } else {
+                            let (x, y) = split_i64(rets[1].into_int_value());
+                            (x.into(), y.into())
+                        };
+                        let low0 = casted(low0, func_sig.results()[0]);
+                        let high0 = casted(high0, func_sig.results()[1]);
+                        let low1 = casted(low1, func_sig.results()[2]);
+                        let high1 = casted(high1, func_sig.results()[3]);
+                        vec![low0, high0, low1, high1]
+                    }
+                    _ => unreachable!("expected an sret for this type"),
+                }
+            } else {
+                assert!(func_sig.results().len() == 1);
+                vec![basic_value]
+            }
+        } else {
+            assert!(call_site.count_arguments() > 0); // Either sret or vmctx.
+            if call_site
+                .get_enum_attribute(
+                    AttributeLoc::Param(0),
+                    Attribute::get_named_enum_kind_id("sret"),
+                )
+                .is_some()
+            {
+                let sret_ty = call_site
+                    .try_as_basic_value()
+                    .right()
+                    .unwrap()
+                    .get_operand(0)
+                    .unwrap()
+                    .left()
+                    .unwrap();
+                let sret = sret_ty.into_pointer_value();
+                // re-build the llvm-type struct holding the return values
+                let llvm_results: Vec<_> = func_sig
+                    .results()
+                    .iter()
+                    .map(|x| type_to_llvm(intrinsics, *x).unwrap())
+                    .collect();
+                let struct_type = intrinsics
+                    .i32_ty
+                    .get_context()
+                    .struct_type(llvm_results.as_slice(), false);
+
+                let struct_value = builder
+                    .build_load(struct_type, sret, "")
+                    .into_struct_value();
+                let mut rets: Vec<_> = Vec::new();
+                for i in 0..struct_value.get_type().count_fields() {
+                    let value = builder.build_extract_value(struct_value, i, "").unwrap();
+                    rets.push(value);
+                }
+                assert!(func_sig.results().len() == rets.len());
+                rets
+            } else {
+                assert!(func_sig.results().is_empty());
+                vec![]
+            }
+        }
+    }
+
+    fn is_sret(&self, func_sig: &FuncSig) -> Result<bool, CompileError> {
+        let func_sig_returns_bitwidths = func_sig
+            .results()
+            .iter()
+            .map(|ty| match ty {
+                Type::I32 | Type::F32 => 32,
+                Type::I64 | Type::F64 => 64,
+                Type::V128 => 128,
+                Type::ExternRef | Type::FuncRef => 64, /* pointer */
+            })
+            .collect::<Vec<i32>>();
+
+        Ok(!matches!(
+            func_sig_returns_bitwidths.as_slice(),
+            [] | [_]
+                | [32, 32]
+                | [32, 64]
+                | [64, 32]
+                | [64, 64]
+                | [32, 32, 32]
+                | [32, 32, 64]
+                | [64, 32, 32]
+                | [32, 32, 32, 32]
+        ))
+    }
+
+    fn pack_values_for_register_return<'ctx>(
+        &self,
+        intrinsics: &Intrinsics<'ctx>,
+        builder: &Builder<'ctx>,
+        values: &[BasicValueEnum<'ctx>],
+        func_type: &FunctionType<'ctx>,
+    ) -> Result<BasicValueEnum<'ctx>, CompileError> {
+        let is_32 = |value: BasicValueEnum| {
+            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i32_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f32_ty)
+        };
+        let is_64 = |value: BasicValueEnum| {
+            (value.is_int_value() && value.into_int_value().get_type() == intrinsics.i64_ty)
+                || (value.is_float_value()
+                    && value.into_float_value().get_type() == intrinsics.f64_ty)
+        };
+        let is_f32 = |value: BasicValueEnum| {
+            value.is_float_value() && value.into_float_value().get_type() == intrinsics.f32_ty
+        };
+
+        let pack_i32s = |low: BasicValueEnum<'ctx>, high: BasicValueEnum<'ctx>| {
+            assert!(low.get_type() == intrinsics.i32_ty.as_basic_type_enum());
+            assert!(high.get_type() == intrinsics.i32_ty.as_basic_type_enum());
+            let (low, high) = (low.into_int_value(), high.into_int_value());
+            let low = builder.build_int_z_extend(low, intrinsics.i64_ty, "");
+            let high = builder.build_int_z_extend(high, intrinsics.i64_ty, "");
+            let high = builder.build_left_shift(high, intrinsics.i64_ty.const_int(32, false), "");
+            builder.build_or(low, high, "").as_basic_value_enum()
+        };
+
+        let pack_f32s = |first: BasicValueEnum<'ctx>,
+                         second: BasicValueEnum<'ctx>|
+         -> BasicValueEnum<'ctx> {
+            assert!(first.get_type() == intrinsics.f32_ty.as_basic_type_enum());
+            assert!(second.get_type() == intrinsics.f32_ty.as_basic_type_enum());
+            let (first, second) = (first.into_float_value(), second.into_float_value());
+            let vec_ty = intrinsics.f32_ty.vec_type(2);
+            let vec =
+                builder.build_insert_element(vec_ty.get_undef(), first, intrinsics.i32_zero, "");
+            builder
+                .build_insert_element(vec, second, intrinsics.i32_ty.const_int(1, false), "")
+                .as_basic_value_enum()
+        };
+
+        let build_struct = |ty: StructType<'ctx>, values: &[BasicValueEnum<'ctx>]| {
+            let mut struct_value = ty.get_undef();
+            for (i, v) in values.iter().enumerate() {
+                struct_value = builder
+                    .build_insert_value(struct_value, *v, i as u32, "")
+                    .unwrap()
+                    .into_struct_value();
+            }
+            struct_value.as_basic_value_enum()
+        };
+
+        Ok(match *values {
+            [one_value] => one_value,
+            [v1, v2] if is_f32(v1) && is_f32(v2) => pack_f32s(v1, v2),
+            [v1, v2] if is_32(v1) && is_32(v2) => {
+                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                pack_i32s(v1, v2)
+            }
+            [v1, v2] => {
+                assert!(!(is_32(v1) && is_32(v2)));
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, v2],
+                )
+            }
+            [v1, v2, v3] if is_f32(v1) && is_f32(v2) => build_struct(
+                func_type.get_return_type().unwrap().into_struct_type(),
+                &[pack_f32s(v1, v2), v3],
+            ),
+            [v1, v2, v3] if is_32(v1) && is_32(v2) => {
+                let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[pack_i32s(v1, v2), v3],
+                )
+            }
+            [v1, v2, v3] if is_64(v1) && is_f32(v2) && is_f32(v3) => build_struct(
+                func_type.get_return_type().unwrap().into_struct_type(),
+                &[v1, pack_f32s(v2, v3)],
+            ),
+            [v1, v2, v3] if is_64(v1) && is_32(v2) && is_32(v3) => {
+                let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1, pack_i32s(v2, v3)],
+                )
+            }
+            [v1, v2, v3, v4] if is_32(v1) && is_32(v2) && is_32(v3) && is_32(v4) => {
+                let v1v2_pack = if is_f32(v1) && is_f32(v2) {
+                    pack_f32s(v1, v2)
+                } else {
+                    let v1 = builder.build_bitcast(v1, intrinsics.i32_ty, "");
+                    let v2 = builder.build_bitcast(v2, intrinsics.i32_ty, "");
+                    pack_i32s(v1, v2)
+                };
+                let v3v4_pack = if is_f32(v3) && is_f32(v4) {
+                    pack_f32s(v3, v4)
+                } else {
+                    let v3 = builder.build_bitcast(v3, intrinsics.i32_ty, "");
+                    let v4 = builder.build_bitcast(v4, intrinsics.i32_ty, "");
+                    pack_i32s(v3, v4)
+                };
+                build_struct(
+                    func_type.get_return_type().unwrap().into_struct_type(),
+                    &[v1v2_pack, v3v4_pack],
+                )
+            }
+            _ => {
+                unreachable!("called to perform register return on struct return or void function")
+            }
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/compiler.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/compiler.rs
new file mode 100644
index 0000000..176402c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/compiler.rs
@@ -0,0 +1,375 @@
+use crate::config::LLVM;
+use crate::trampoline::FuncTrampoline;
+use crate::translator::FuncTranslator;
+use crate::CompiledKind;
+use inkwell::context::Context;
+use inkwell::memory_buffer::MemoryBuffer;
+use inkwell::module::{Linkage, Module};
+use inkwell::targets::FileType;
+use inkwell::DLLStorageClass;
+use rayon::iter::ParallelBridge;
+use rayon::prelude::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
+use std::sync::Arc;
+use wasmer_compiler::{Compiler, FunctionBodyData, ModuleMiddleware, ModuleTranslationState};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{
+    Compilation, CompileError, CompileModuleInfo, CustomSection, CustomSectionProtection, Dwarf,
+    FunctionIndex, LocalFunctionIndex, RelocationTarget, SectionBody, SectionIndex, SignatureIndex,
+    Symbol, SymbolRegistry, Target,
+};
+
+//use std::sync::Mutex;
+
+/// A compiler that compiles a WebAssembly module with LLVM, translating the Wasm to LLVM IR,
+/// optimizing it and then translating to assembly.
+pub struct LLVMCompiler {
+    config: LLVM,
+}
+
+impl LLVMCompiler {
+    /// Creates a new LLVM compiler
+    pub fn new(config: LLVM) -> LLVMCompiler {
+        LLVMCompiler { config }
+    }
+
+    /// Gets the config for this Compiler
+    fn config(&self) -> &LLVM {
+        &self.config
+    }
+}
+
+struct ShortNames {}
+
+impl SymbolRegistry for ShortNames {
+    fn symbol_to_name(&self, symbol: Symbol) -> String {
+        match symbol {
+            Symbol::Metadata => "M".to_string(),
+            Symbol::LocalFunction(index) => format!("f{}", index.index()),
+            Symbol::Section(index) => format!("s{}", index.index()),
+            Symbol::FunctionCallTrampoline(index) => format!("t{}", index.index()),
+            Symbol::DynamicFunctionTrampoline(index) => format!("d{}", index.index()),
+        }
+    }
+
+    fn name_to_symbol(&self, name: &str) -> Option<Symbol> {
+        if name.len() < 2 {
+            return None;
+        }
+        let (ty, idx) = name.split_at(1);
+        if ty.starts_with('M') {
+            return Some(Symbol::Metadata);
+        }
+
+        let idx = idx.parse::<u32>().ok()?;
+        match ty.chars().next().unwrap() {
+            'f' => Some(Symbol::LocalFunction(LocalFunctionIndex::from_u32(idx))),
+            's' => Some(Symbol::Section(SectionIndex::from_u32(idx))),
+            't' => Some(Symbol::FunctionCallTrampoline(SignatureIndex::from_u32(
+                idx,
+            ))),
+            'd' => Some(Symbol::DynamicFunctionTrampoline(FunctionIndex::from_u32(
+                idx,
+            ))),
+            _ => None,
+        }
+    }
+}
+
+impl LLVMCompiler {
+    fn compile_native_object(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        module_translation: &ModuleTranslationState,
+        function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        symbol_registry: &dyn SymbolRegistry,
+        wasmer_metadata: &[u8],
+    ) -> Result<Vec<u8>, CompileError> {
+        let target_machine = self.config().target_machine(target);
+        let ctx = Context::create();
+
+        // TODO: https:/github.com/rayon-rs/rayon/issues/822
+
+        let merged_bitcode = function_body_inputs.into_iter().par_bridge().map_init(
+            || {
+                let target_machine = self.config().target_machine(target);
+                FuncTranslator::new(target_machine)
+            },
+            |func_translator, (i, input)| {
+                let module = func_translator.translate_to_module(
+                    &compile_info.module,
+                    module_translation,
+                    &i,
+                    input,
+                    self.config(),
+                    &compile_info.memory_styles,
+                    &compile_info.table_styles,
+                    symbol_registry,
+                )?;
+                Ok(module.write_bitcode_to_memory().as_slice().to_vec())
+            },
+        );
+
+        let trampolines_bitcode = compile_info.module.signatures.iter().par_bridge().map_init(
+            || {
+                let target_machine = self.config().target_machine(target);
+                FuncTrampoline::new(target_machine)
+            },
+            |func_trampoline, (i, sig)| {
+                let name = symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(i));
+                let module = func_trampoline.trampoline_to_module(sig, self.config(), &name)?;
+                Ok(module.write_bitcode_to_memory().as_slice().to_vec())
+            },
+        );
+
+        let dynamic_trampolines_bitcode =
+            compile_info.module.functions.iter().par_bridge().map_init(
+                || {
+                    let target_machine = self.config().target_machine(target);
+                    (
+                        FuncTrampoline::new(target_machine),
+                        &compile_info.module.signatures,
+                    )
+                },
+                |(func_trampoline, signatures), (i, sig)| {
+                    let sig = &signatures[*sig];
+                    let name = symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(i));
+                    let module =
+                        func_trampoline.dynamic_trampoline_to_module(sig, self.config(), &name)?;
+                    Ok(module.write_bitcode_to_memory().as_slice().to_vec())
+                },
+            );
+
+        let merged_bitcode = merged_bitcode
+            .chain(trampolines_bitcode)
+            .chain(dynamic_trampolines_bitcode)
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_par_iter()
+            .reduce_with(|bc1, bc2| {
+                let ctx = Context::create();
+                let membuf = MemoryBuffer::create_from_memory_range(&bc1, "");
+                let m1 = Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap();
+                let membuf = MemoryBuffer::create_from_memory_range(&bc2, "");
+                let m2 = Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap();
+                m1.link_in_module(m2).unwrap();
+                m1.write_bitcode_to_memory().as_slice().to_vec()
+            });
+        let merged_module = if let Some(bc) = merged_bitcode {
+            let membuf = MemoryBuffer::create_from_memory_range(&bc, "");
+            Module::parse_bitcode_from_buffer(&membuf, &ctx).unwrap()
+        } else {
+            ctx.create_module("")
+        };
+
+        let i8_ty = ctx.i8_type();
+        let metadata_init = i8_ty.const_array(
+            wasmer_metadata
+                .iter()
+                .map(|v| i8_ty.const_int(*v as u64, false))
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
+        let metadata_gv = merged_module.add_global(
+            metadata_init.get_type(),
+            None,
+            &symbol_registry.symbol_to_name(wasmer_types::Symbol::Metadata),
+        );
+        metadata_gv.set_initializer(&metadata_init);
+        metadata_gv.set_linkage(Linkage::DLLExport);
+        metadata_gv.set_dll_storage_class(DLLStorageClass::Export);
+        metadata_gv.set_alignment(16);
+
+        if self.config().enable_verifier {
+            merged_module.verify().unwrap();
+        }
+
+        let memory_buffer = target_machine
+            .write_to_memory_buffer(&merged_module, FileType::Object)
+            .unwrap();
+        if let Some(ref callbacks) = self.config.callbacks {
+            callbacks.obj_memory_buffer(&CompiledKind::Module, &memory_buffer);
+        }
+
+        Ok(memory_buffer.as_slice().to_vec())
+    }
+}
+
+impl Compiler for LLVMCompiler {
+    fn name(&self) -> &str {
+        "llvm"
+    }
+
+    /// Get the middlewares for this compiler
+    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
+        &self.config.middlewares
+    }
+
+    fn experimental_native_compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        module_translation: &ModuleTranslationState,
+        // The list of function bodies
+        function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        symbol_registry: &dyn SymbolRegistry,
+        // The metadata to inject into the wasmer_metadata section of the object file.
+        wasmer_metadata: &[u8],
+    ) -> Option<Result<Vec<u8>, CompileError>> {
+        Some(self.compile_native_object(
+            target,
+            compile_info,
+            module_translation,
+            function_body_inputs,
+            symbol_registry,
+            wasmer_metadata,
+        ))
+    }
+
+    /// Compile the module using LLVM, producing a compilation result with
+    /// associated relocations.
+    fn compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        module_translation: &ModuleTranslationState,
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+    ) -> Result<Compilation, CompileError> {
+        //let data = Arc::new(Mutex::new(0));
+        let memory_styles = &compile_info.memory_styles;
+        let table_styles = &compile_info.table_styles;
+
+        let module = &compile_info.module;
+
+        // TODO: merge constants in sections.
+
+        let mut module_custom_sections = PrimaryMap::new();
+        let mut frame_section_bytes = vec![];
+        let mut frame_section_relocations = vec![];
+        let functions = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .par_iter()
+            .map_init(
+                || {
+                    let target_machine = self.config().target_machine(target);
+                    FuncTranslator::new(target_machine)
+                },
+                |func_translator, (i, input)| {
+                    // TODO: remove (to serialize)
+                    //let _data = data.lock().unwrap();
+                    func_translator.translate(
+                        module,
+                        module_translation,
+                        i,
+                        input,
+                        self.config(),
+                        memory_styles,
+                        table_styles,
+                        &ShortNames {},
+                    )
+                },
+            )
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .map(|mut compiled_function| {
+                let first_section = module_custom_sections.len() as u32;
+                for (section_index, custom_section) in compiled_function.custom_sections.iter() {
+                    // TODO: remove this call to clone()
+                    let mut custom_section = custom_section.clone();
+                    for reloc in &mut custom_section.relocations {
+                        if let RelocationTarget::CustomSection(index) = reloc.reloc_target {
+                            reloc.reloc_target = RelocationTarget::CustomSection(
+                                SectionIndex::from_u32(first_section + index.as_u32()),
+                            )
+                        }
+                    }
+                    if compiled_function
+                        .eh_frame_section_indices
+                        .contains(&section_index)
+                    {
+                        let offset = frame_section_bytes.len() as u32;
+                        for reloc in &mut custom_section.relocations {
+                            reloc.offset += offset;
+                        }
+                        frame_section_bytes.extend_from_slice(custom_section.bytes.as_slice());
+                        frame_section_relocations.extend(custom_section.relocations);
+                        // TODO: we do this to keep the count right, remove it.
+                        module_custom_sections.push(CustomSection {
+                            protection: CustomSectionProtection::Read,
+                            bytes: SectionBody::new_with_vec(vec![]),
+                            relocations: vec![],
+                        });
+                    } else {
+                        module_custom_sections.push(custom_section);
+                    }
+                }
+                for reloc in &mut compiled_function.compiled_function.relocations {
+                    if let RelocationTarget::CustomSection(index) = reloc.reloc_target {
+                        reloc.reloc_target = RelocationTarget::CustomSection(
+                            SectionIndex::from_u32(first_section + index.as_u32()),
+                        )
+                    }
+                }
+                compiled_function.compiled_function
+            })
+            .collect::<PrimaryMap<LocalFunctionIndex, _>>();
+
+        let dwarf = if !frame_section_bytes.is_empty() {
+            let dwarf = Some(Dwarf::new(SectionIndex::from_u32(
+                module_custom_sections.len() as u32,
+            )));
+            // Do not terminate dwarf info with a zero-length CIE.
+            // Because more info will be added later
+            // in lib/object/src/module.rs emit_compilation
+            module_custom_sections.push(CustomSection {
+                protection: CustomSectionProtection::Read,
+                bytes: SectionBody::new_with_vec(frame_section_bytes),
+                relocations: frame_section_relocations,
+            });
+            dwarf
+        } else {
+            None
+        };
+
+        let function_call_trampolines = module
+            .signatures
+            .values()
+            .collect::<Vec<_>>()
+            .par_iter()
+            .map_init(
+                || {
+                    let target_machine = self.config().target_machine(target);
+                    FuncTrampoline::new(target_machine)
+                },
+                |func_trampoline, sig| func_trampoline.trampoline(sig, self.config(), ""),
+            )
+            .collect::<Vec<_>>()
+            .into_iter()
+            .collect::<Result<PrimaryMap<_, _>, CompileError>>()?;
+
+        let dynamic_function_trampolines = module
+            .imported_function_types()
+            .collect::<Vec<_>>()
+            .par_iter()
+            .map_init(
+                || {
+                    let target_machine = self.config().target_machine(target);
+                    FuncTrampoline::new(target_machine)
+                },
+                |func_trampoline, func_type| {
+                    func_trampoline.dynamic_trampoline(func_type, self.config(), "")
+                },
+            )
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .collect::<PrimaryMap<_, _>>();
+
+        Ok(Compilation {
+            functions,
+            custom_sections: module_custom_sections,
+            function_call_trampolines,
+            dynamic_function_trampolines,
+            debug: dwarf,
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/config.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/config.rs
new file mode 100644
index 0000000..a4c5ebf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/config.rs
@@ -0,0 +1,287 @@
+use crate::compiler::LLVMCompiler;
+use inkwell::targets::{
+    CodeModel, InitializationConfig, RelocMode, Target as InkwellTarget, TargetMachine,
+    TargetTriple,
+};
+pub use inkwell::OptimizationLevel as LLVMOptLevel;
+use itertools::Itertools;
+use std::fmt::Debug;
+use std::sync::Arc;
+use target_lexicon::Architecture;
+use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
+use wasmer_types::{FunctionType, LocalFunctionIndex, Target, Triple};
+
+/// The InkWell ModuleInfo type
+pub type InkwellModule<'ctx> = inkwell::module::Module<'ctx>;
+
+/// The InkWell MemoryBuffer type
+pub type InkwellMemoryBuffer = inkwell::memory_buffer::MemoryBuffer;
+
+/// The compiled function kind, used for debugging in the `LLVMCallbacks`.
+#[derive(Debug, Clone)]
+pub enum CompiledKind {
+    // A locally-defined function in the Wasm file.
+    Local(LocalFunctionIndex),
+    // A function call trampoline for a given signature.
+    FunctionCallTrampoline(FunctionType),
+    // A dynamic function trampoline for a given signature.
+    DynamicFunctionTrampoline(FunctionType),
+    // An entire Wasm module.
+    Module,
+}
+
+/// Callbacks to the different LLVM compilation phases.
+pub trait LLVMCallbacks: Debug + Send + Sync {
+    fn preopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
+    fn postopt_ir(&self, function: &CompiledKind, module: &InkwellModule);
+    fn obj_memory_buffer(&self, function: &CompiledKind, memory_buffer: &InkwellMemoryBuffer);
+}
+
+#[derive(Debug, Clone)]
+pub struct LLVM {
+    pub(crate) enable_nan_canonicalization: bool,
+    pub(crate) enable_verifier: bool,
+    pub(crate) opt_level: LLVMOptLevel,
+    is_pic: bool,
+    pub(crate) callbacks: Option<Arc<dyn LLVMCallbacks>>,
+    /// The middleware chain.
+    pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+}
+
+impl LLVM {
+    /// Creates a new configuration object with the default configuration
+    /// specified.
+    pub fn new() -> Self {
+        Self {
+            enable_nan_canonicalization: false,
+            enable_verifier: false,
+            opt_level: LLVMOptLevel::Aggressive,
+            is_pic: false,
+            callbacks: None,
+            middlewares: vec![],
+        }
+    }
+
+    /// The optimization levels when optimizing the IR.
+    pub fn opt_level(&mut self, opt_level: LLVMOptLevel) -> &mut Self {
+        self.opt_level = opt_level;
+        self
+    }
+
+    /// Callbacks that will triggered in the different compilation
+    /// phases in LLVM.
+    pub fn callbacks(&mut self, callbacks: Option<Arc<dyn LLVMCallbacks>>) -> &mut Self {
+        self.callbacks = callbacks;
+        self
+    }
+
+    fn reloc_mode(&self) -> RelocMode {
+        if self.is_pic {
+            RelocMode::PIC
+        } else {
+            RelocMode::Static
+        }
+    }
+
+    fn code_model(&self) -> CodeModel {
+        // We normally use the large code model, but when targeting shared
+        // objects, we are required to use PIC. If we use PIC anyways, we lose
+        // any benefit from large code model and there's some cost on all
+        // platforms, plus some platforms (MachO) don't support PIC + large
+        // at all.
+        if self.is_pic {
+            CodeModel::Small
+        } else {
+            CodeModel::Large
+        }
+    }
+
+    fn target_triple(&self, target: &Target) -> TargetTriple {
+        let architecture = if target.triple().architecture
+            == Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64gc)
+        {
+            target_lexicon::Architecture::Riscv64(target_lexicon::Riscv64Architecture::Riscv64)
+        } else {
+            target.triple().architecture
+        };
+        // Hack: we're using is_pic to determine whether this is a native
+        // build or not.
+        let operating_system = if target.triple().operating_system
+            == wasmer_types::OperatingSystem::Darwin
+            && !self.is_pic
+        {
+            // LLVM detects static relocation + darwin + 64-bit and
+            // force-enables PIC because MachO doesn't support that
+            // combination. They don't check whether they're targeting
+            // MachO, they check whether the OS is set to Darwin.
+            //
+            // Since both linux and darwin use SysV ABI, this should work.
+            //  but not in the case of Aarch64, there the ABI is slightly different
+            #[allow(clippy::match_single_binding)]
+            match target.triple().architecture {
+                _ => wasmer_types::OperatingSystem::Linux,
+            }
+        } else {
+            target.triple().operating_system
+        };
+        let binary_format = if self.is_pic {
+            target.triple().binary_format
+        } else {
+            target_lexicon::BinaryFormat::Elf
+        };
+        let triple = Triple {
+            architecture,
+            vendor: target.triple().vendor.clone(),
+            operating_system,
+            environment: target.triple().environment,
+            binary_format,
+        };
+        TargetTriple::create(&triple.to_string())
+    }
+
+    /// Generates the target machine for the current target
+    pub fn target_machine(&self, target: &Target) -> TargetMachine {
+        let triple = target.triple();
+        let cpu_features = &target.cpu_features();
+
+        match triple.architecture {
+            Architecture::X86_64 | Architecture::X86_32(_) => {
+                InkwellTarget::initialize_x86(&InitializationConfig {
+                    asm_parser: true,
+                    asm_printer: true,
+                    base: true,
+                    disassembler: true,
+                    info: true,
+                    machine_code: true,
+                })
+            }
+            Architecture::Aarch64(_) => InkwellTarget::initialize_aarch64(&InitializationConfig {
+                asm_parser: true,
+                asm_printer: true,
+                base: true,
+                disassembler: true,
+                info: true,
+                machine_code: true,
+            }),
+            Architecture::Riscv64(_) => InkwellTarget::initialize_riscv(&InitializationConfig {
+                asm_parser: true,
+                asm_printer: true,
+                base: true,
+                disassembler: true,
+                info: true,
+                machine_code: true,
+            }),
+            // Architecture::Arm(_) => InkwellTarget::initialize_arm(&InitializationConfig {
+            //     asm_parser: true,
+            //     asm_printer: true,
+            //     base: true,
+            //     disassembler: true,
+            //     info: true,
+            //     machine_code: true,
+            // }),
+            _ => unimplemented!("target {} not yet supported in Wasmer", triple),
+        }
+
+        // The CPU features formatted as LLVM strings
+        // We can safely map to gcc-like features as the CPUFeatures
+        // are compliant with the same string representations as gcc.
+        let llvm_cpu_features = cpu_features
+            .iter()
+            .map(|feature| format!("+{}", feature.to_string()))
+            .join(",");
+
+        let target_triple = self.target_triple(target);
+        let llvm_target = InkwellTarget::from_triple(&target_triple).unwrap();
+        let llvm_target_machine = llvm_target
+            .create_target_machine(
+                &target_triple,
+                match triple.architecture {
+                    Architecture::Riscv64(_) => "generic-rv64",
+                    _ => "generic",
+                },
+                match triple.architecture {
+                    Architecture::Riscv64(_) => "+m,+a,+c,+d,+f",
+                    _ => &llvm_cpu_features,
+                },
+                self.opt_level,
+                self.reloc_mode(),
+                match triple.architecture {
+                    Architecture::Riscv64(_) => CodeModel::Medium,
+                    _ => self.code_model(),
+                },
+            )
+            .unwrap();
+
+        if let Architecture::Riscv64(_) = triple.architecture {
+            // TODO: totally non-portable way to change ABI
+            unsafe {
+                // This structure mimic the internal structure from inkwell
+                // that is defined as
+                //  #[derive(Debug)]
+                //  pub struct TargetMachine {
+                //    pub(crate) target_machine: LLVMTargetMachineRef,
+                //  }
+                pub struct MyTargetMachine {
+                    pub target_machine: *const u8,
+                }
+                // It is use to live patch the create LLVMTargetMachine
+                // to hard change the ABI and force "-mabi=lp64d" ABI
+                // instead of the default that don't use float registers
+                // because there is no current way to do this change
+
+                let my_target_machine: MyTargetMachine = std::mem::transmute(llvm_target_machine);
+
+                *((my_target_machine.target_machine as *mut u8).offset(0x410) as *mut u64) = 5;
+                std::ptr::copy_nonoverlapping(
+                    "lp64d\0".as_ptr(),
+                    (my_target_machine.target_machine as *mut u8).offset(0x418),
+                    6,
+                );
+
+                std::mem::transmute(my_target_machine)
+            }
+        } else {
+            llvm_target_machine
+        }
+    }
+}
+
+impl CompilerConfig for LLVM {
+    /// Emit code suitable for dlopen.
+    fn enable_pic(&mut self) {
+        // TODO: although we can emit PIC, the object file parser does not yet
+        // support all the relocations.
+        self.is_pic = true;
+    }
+
+    /// Whether to verify compiler IR.
+    fn enable_verifier(&mut self) {
+        self.enable_verifier = true;
+    }
+
+    fn canonicalize_nans(&mut self, enable: bool) {
+        self.enable_nan_canonicalization = enable;
+    }
+
+    /// Transform it into the compiler.
+    fn compiler(self: Box<Self>) -> Box<dyn Compiler> {
+        Box::new(LLVMCompiler::new(*self))
+    }
+
+    /// Pushes a middleware onto the back of the middleware chain.
+    fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>) {
+        self.middlewares.push(middleware);
+    }
+}
+
+impl Default for LLVM {
+    fn default() -> LLVM {
+        Self::new()
+    }
+}
+
+impl From<LLVM> for Engine {
+    fn from(config: LLVM) -> Self {
+        EngineBuilder::new(config).engine()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/lib.rs
new file mode 100644
index 0000000..49231b7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/lib.rs
@@ -0,0 +1,27 @@
+#![deny(
+    nonstandard_style,
+    unused_imports,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+#![cfg_attr(
+    all(not(target_os = "windows"), not(target_arch = "aarch64")),
+    deny(dead_code)
+)]
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+mod abi;
+mod compiler;
+mod config;
+mod object_file;
+mod trampoline;
+mod translator;
+
+pub use crate::compiler::LLVMCompiler;
+pub use crate::config::{
+    CompiledKind, InkwellMemoryBuffer, InkwellModule, LLVMCallbacks, LLVMOptLevel, LLVM,
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/object_file.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/object_file.rs
new file mode 100644
index 0000000..de8702b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/object_file.rs
@@ -0,0 +1,417 @@
+use object::{Object, ObjectSection, ObjectSymbol};
+
+use std::collections::{HashMap, HashSet};
+use std::convert::TryInto;
+use std::num::TryFromIntError;
+
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{
+    CompileError, CompiledFunctionFrameInfo, CustomSection, CustomSectionProtection,
+    CustomSections, FunctionAddressMap, FunctionBody, InstructionAddressMap, Relocation,
+    RelocationKind, RelocationTarget, SectionBody, SectionIndex, SourceLoc,
+};
+use wasmer_vm::libcalls::LibCall;
+
+fn map_tryfromint_err(error: TryFromIntError) -> CompileError {
+    CompileError::Codegen(format!("int doesn't fit: {}", error))
+}
+
+fn map_object_err(error: object::read::Error) -> CompileError {
+    CompileError::Codegen(format!("error parsing object file: {}", error))
+}
+
+pub struct CompiledFunction {
+    pub compiled_function: wasmer_types::CompiledFunction,
+    pub custom_sections: CustomSections,
+    pub eh_frame_section_indices: Vec<SectionIndex>,
+}
+
+pub fn load_object_file<F>(
+    contents: &[u8],
+    root_section: &str,
+    root_section_reloc_target: RelocationTarget,
+    mut symbol_name_to_relocation_target: F,
+) -> Result<CompiledFunction, CompileError>
+where
+    F: FnMut(&str) -> Result<Option<RelocationTarget>, CompileError>,
+{
+    // TODO: use perfect hash function?
+    let mut libcalls = HashMap::new();
+    libcalls.insert("ceilf".to_string(), LibCall::CeilF32);
+    libcalls.insert("ceil".to_string(), LibCall::CeilF64);
+    libcalls.insert("floorf".to_string(), LibCall::FloorF32);
+    libcalls.insert("floor".to_string(), LibCall::FloorF64);
+    libcalls.insert("nearbyintf".to_string(), LibCall::NearestF32);
+    libcalls.insert("nearbyint".to_string(), LibCall::NearestF64);
+    libcalls.insert("truncf".to_string(), LibCall::TruncF32);
+    libcalls.insert("trunc".to_string(), LibCall::TruncF64);
+    libcalls.insert("wasmer_vm_f32_ceil".to_string(), LibCall::CeilF32);
+    libcalls.insert("wasmer_vm_f64_ceil".to_string(), LibCall::CeilF64);
+    libcalls.insert("wasmer_vm_f32_floor".to_string(), LibCall::FloorF32);
+    libcalls.insert("wasmer_vm_f64_floor".to_string(), LibCall::FloorF64);
+    libcalls.insert("wasmer_vm_f32_nearest".to_string(), LibCall::NearestF32);
+    libcalls.insert("wasmer_vm_f64_nearest".to_string(), LibCall::NearestF64);
+    libcalls.insert("wasmer_vm_f32_trunc".to_string(), LibCall::TruncF32);
+    libcalls.insert("wasmer_vm_f64_trunc".to_string(), LibCall::TruncF64);
+    libcalls.insert("wasmer_vm_memory32_size".to_string(), LibCall::Memory32Size);
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_size".to_string(),
+        LibCall::ImportedMemory32Size,
+    );
+    libcalls.insert("wasmer_vm_table_copy".to_string(), LibCall::TableCopy);
+    libcalls.insert("wasmer_vm_table_init".to_string(), LibCall::TableInit);
+    libcalls.insert("wasmer_vm_table_fill".to_string(), LibCall::TableFill);
+    libcalls.insert("wasmer_vm_table_size".to_string(), LibCall::TableSize);
+    libcalls.insert(
+        "wasmer_vm_imported_table_size".to_string(),
+        LibCall::ImportedTableSize,
+    );
+    libcalls.insert("wasmer_vm_table_get".to_string(), LibCall::TableGet);
+    libcalls.insert(
+        "wasmer_vm_imported_table_get".to_string(),
+        LibCall::ImportedTableGet,
+    );
+    libcalls.insert("wasmer_vm_table_set".to_string(), LibCall::TableSet);
+    libcalls.insert(
+        "wasmer_vm_imported_table_set".to_string(),
+        LibCall::ImportedTableSet,
+    );
+    libcalls.insert("wasmer_vm_table_grow".to_string(), LibCall::TableGrow);
+    libcalls.insert(
+        "wasmer_vm_imported_table_grow".to_string(),
+        LibCall::ImportedTableGrow,
+    );
+    libcalls.insert("wasmer_vm_func_ref".to_string(), LibCall::FuncRef);
+    libcalls.insert("wasmer_vm_elem_drop".to_string(), LibCall::ElemDrop);
+    libcalls.insert("wasmer_vm_memory32_copy".to_string(), LibCall::Memory32Copy);
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_copy".to_string(),
+        LibCall::ImportedMemory32Copy,
+    );
+    libcalls.insert("wasmer_vm_memory32_fill".to_string(), LibCall::Memory32Fill);
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_fill".to_string(),
+        LibCall::ImportedMemory32Fill,
+    );
+    libcalls.insert("wasmer_vm_memory32_init".to_string(), LibCall::Memory32Init);
+    libcalls.insert("wasmer_vm_data_drop".to_string(), LibCall::DataDrop);
+    libcalls.insert("wasmer_vm_raise_trap".to_string(), LibCall::RaiseTrap);
+    libcalls.insert(
+        "wasmer_vm_memory32_atomic_wait32".to_string(),
+        LibCall::Memory32AtomicWait32,
+    );
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_atomic_wait32".to_string(),
+        LibCall::ImportedMemory32AtomicWait32,
+    );
+    libcalls.insert(
+        "wasmer_vm_memory32_atomic_wait64".to_string(),
+        LibCall::Memory32AtomicWait64,
+    );
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_atomic_wait64".to_string(),
+        LibCall::ImportedMemory32AtomicWait64,
+    );
+    libcalls.insert(
+        "wasmer_vm_memory32_atomic_notify".to_string(),
+        LibCall::Memory32AtomicNotify,
+    );
+    libcalls.insert(
+        "wasmer_vm_imported_memory32_atomic_notify".to_string(),
+        LibCall::ImportedMemory32AtomicNotify,
+    );
+
+    let elf = object::File::parse(contents).map_err(map_object_err)?;
+
+    let mut visited: HashSet<object::read::SectionIndex> = HashSet::new();
+    let mut worklist: Vec<object::read::SectionIndex> = Vec::new();
+    let mut section_targets: HashMap<object::read::SectionIndex, RelocationTarget> = HashMap::new();
+
+    let root_section_index = elf
+        .section_by_name(root_section)
+        .ok_or_else(|| CompileError::Codegen(format!("no section named {}", root_section)))?
+        .index();
+
+    let mut section_to_custom_section = HashMap::new();
+
+    section_targets.insert(root_section_index, root_section_reloc_target);
+
+    let mut next_custom_section: u32 = 0;
+    let mut elf_section_to_target = |elf_section_index: object::read::SectionIndex| {
+        *section_targets.entry(elf_section_index).or_insert_with(|| {
+            let next = SectionIndex::from_u32(next_custom_section);
+            section_to_custom_section.insert(elf_section_index, next);
+            let target = RelocationTarget::CustomSection(next);
+            next_custom_section += 1;
+            target
+        })
+    };
+
+    // From elf section index to list of Relocations. Although we use a Vec,
+    // the order of relocations is not important.
+    let mut relocations: HashMap<object::read::SectionIndex, Vec<Relocation>> = HashMap::new();
+
+    // Each iteration of this loop pulls a section and the relocations
+    // relocations that apply to it. We begin with the ".root_section"
+    // section, and then parse all relocation sections that apply to that
+    // section. Those relocations may refer to additional sections which we
+    // then add to the worklist until we've visited the closure of
+    // everything needed to run the code in ".root_section".
+    //
+    // `worklist` is the list of sections we have yet to visit. It never
+    // contains any duplicates or sections we've already visited. `visited`
+    // contains all the sections we've ever added to the worklist in a set
+    // so that we can quickly check whether a section is new before adding
+    // it to worklist. `section_to_custom_section` is filled in with all
+    // the sections we want to include.
+    worklist.push(root_section_index);
+    visited.insert(root_section_index);
+
+    // Also add any .eh_frame sections.
+    let mut eh_frame_section_indices = vec![];
+    for section in elf.sections() {
+        if section.kind() == object::SectionKind::Elf(object::elf::SHT_X86_64_UNWIND) {
+            let index = section.index();
+            worklist.push(index);
+            visited.insert(index);
+            eh_frame_section_indices.push(index);
+            // This allocates a custom section index for the ELF section.
+            elf_section_to_target(index);
+        }
+    }
+
+    while let Some(section_index) = worklist.pop() {
+        for (offset, reloc) in elf
+            .section_by_index(section_index)
+            .map_err(map_object_err)?
+            .relocations()
+        {
+            let kind = match (elf.architecture(), reloc.kind(), reloc.size()) {
+                (_, object::RelocationKind::Absolute, 64) => RelocationKind::Abs8,
+                (
+                    object::Architecture::X86_64,
+                    object::RelocationKind::Elf(object::elf::R_X86_64_PC64),
+                    0,
+                ) => RelocationKind::X86PCRel8,
+                (object::Architecture::Aarch64, object::RelocationKind::PltRelative, 26) => {
+                    RelocationKind::Arm64Call
+                }
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G0_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw0,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G1_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw1,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G2_NC),
+                    0,
+                ) => RelocationKind::Arm64Movw2,
+                (
+                    object::Architecture::Aarch64,
+                    object::RelocationKind::Elf(object::elf::R_AARCH64_MOVW_UABS_G3),
+                    0,
+                ) => RelocationKind::Arm64Movw3,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_CALL_PLT),
+                    0,
+                ) => RelocationKind::RiscvCall,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_HI20),
+                    0,
+                ) => RelocationKind::RiscvPCRelHi20,
+                (
+                    object::Architecture::Riscv64,
+                    object::RelocationKind::Elf(object::elf::R_RISCV_PCREL_LO12_I),
+                    0,
+                ) => RelocationKind::RiscvPCRelLo12I,
+                _ => {
+                    return Err(CompileError::Codegen(format!(
+                        "unknown relocation {:?}",
+                        reloc
+                    )));
+                }
+            };
+            let mut addend = reloc.addend();
+            let target = match reloc.target() {
+                object::read::RelocationTarget::Symbol(index) => {
+                    let symbol = elf.symbol_by_index(index).map_err(map_object_err)?;
+                    let symbol_name = symbol.name().map_err(map_object_err)?;
+                    if symbol.kind() == object::SymbolKind::Section {
+                        match symbol.section() {
+                            object::SymbolSection::Section(section_index) => {
+                                if section_index == root_section_index {
+                                    root_section_reloc_target
+                                } else {
+                                    if visited.insert(section_index) {
+                                        worklist.push(section_index);
+                                    }
+                                    elf_section_to_target(section_index)
+                                }
+                            }
+                            _ => {
+                                return Err(CompileError::Codegen(format!(
+                                    "relocation targets unknown section {:?}",
+                                    reloc
+                                )));
+                            }
+                        }
+                        // Maybe a libcall then?
+                    } else if let Some(libcall) = libcalls.get(symbol_name) {
+                        RelocationTarget::LibCall(*libcall)
+                    } else if let Some(reloc_target) =
+                        symbol_name_to_relocation_target(symbol_name)?
+                    {
+                        reloc_target
+                    } else if let object::SymbolSection::Section(section_index) = symbol.section() {
+                        // TODO: Encode symbol address into addend, I think this is a bit hacky.
+                        addend = addend.wrapping_add(symbol.address() as i64);
+
+                        if section_index == root_section_index {
+                            root_section_reloc_target
+                        } else {
+                            if visited.insert(section_index) {
+                                worklist.push(section_index);
+                            }
+
+                            elf_section_to_target(section_index)
+                        }
+                    } else {
+                        return Err(CompileError::Codegen(format!(
+                            "relocation targets unknown symbol {:?}",
+                            reloc
+                        )));
+                    }
+                }
+
+                object::read::RelocationTarget::Section(index) => {
+                    if index == root_section_index {
+                        root_section_reloc_target
+                    } else {
+                        if visited.insert(index) {
+                            worklist.push(index);
+                        }
+                        elf_section_to_target(index)
+                    }
+                }
+
+                object::read::RelocationTarget::Absolute => {
+                    // Wasm-produced object files should never have absolute
+                    // addresses in them because none of the parts of the Wasm
+                    // VM, nor the generated code are loaded at fixed addresses.
+                    return Err(CompileError::Codegen(format!(
+                        "relocation targets absolute address {:?}",
+                        reloc
+                    )));
+                }
+
+                // `object::read::RelocationTarget` is a
+                // non-exhaustive enum (`#[non_exhaustive]`), so it
+                // could have additional variants added in the
+                // future. Therefore, when matching against variants
+                // of non-exhaustive enums, an extra wildcard arm must
+                // be added to account for any future variants.
+                t => {
+                    return Err(CompileError::Codegen(format!(
+                        "relocation target is unknown `{:?}`",
+                        t
+                    )));
+                }
+            };
+            relocations
+                .entry(section_index)
+                .or_default()
+                .push(Relocation {
+                    kind,
+                    reloc_target: target,
+                    offset: offset.try_into().map_err(map_tryfromint_err)?,
+                    addend,
+                });
+        }
+    }
+
+    let eh_frame_section_indices = eh_frame_section_indices
+        .iter()
+        .map(|index| {
+            section_to_custom_section.get(index).map_or_else(
+                || {
+                    Err(CompileError::Codegen(format!(
+                        ".eh_frame section with index={:?} was never loaded",
+                        index
+                    )))
+                },
+                |idx| Ok(*idx),
+            )
+        })
+        .collect::<Result<Vec<SectionIndex>, _>>()?;
+
+    let mut custom_sections = section_to_custom_section
+        .iter()
+        .map(|(elf_section_index, custom_section_index)| {
+            (
+                custom_section_index,
+                CustomSection {
+                    protection: CustomSectionProtection::Read,
+                    bytes: SectionBody::new_with_vec(
+                        elf.section_by_index(*elf_section_index)
+                            .unwrap()
+                            .data()
+                            .unwrap()
+                            .to_vec(),
+                    ),
+                    relocations: relocations
+                        .remove_entry(elf_section_index)
+                        .map_or(vec![], |(_, v)| v),
+                },
+            )
+        })
+        .collect::<Vec<_>>();
+    custom_sections.sort_unstable_by_key(|a| a.0);
+    let custom_sections = custom_sections
+        .into_iter()
+        .map(|(_, v)| v)
+        .collect::<PrimaryMap<SectionIndex, _>>();
+
+    let function_body = FunctionBody {
+        body: elf
+            .section_by_index(root_section_index)
+            .unwrap()
+            .data()
+            .unwrap()
+            .to_vec(),
+        unwind_info: None,
+    };
+
+    let address_map = FunctionAddressMap {
+        instructions: vec![InstructionAddressMap {
+            srcloc: SourceLoc::default(),
+            code_offset: 0,
+            code_len: function_body.body.len(),
+        }],
+        start_srcloc: SourceLoc::default(),
+        end_srcloc: SourceLoc::default(),
+        body_offset: 0,
+        body_len: function_body.body.len(),
+    };
+
+    Ok(CompiledFunction {
+        compiled_function: wasmer_types::CompiledFunction {
+            body: function_body,
+            relocations: relocations
+                .remove_entry(&root_section_index)
+                .map_or(vec![], |(_, v)| v),
+            frame_info: CompiledFunctionFrameInfo {
+                address_map,
+                traps: vec![],
+            },
+        },
+        custom_sections,
+        eh_frame_section_indices,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/mod.rs
new file mode 100644
index 0000000..9adc422
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/mod.rs
@@ -0,0 +1,3 @@
+mod wasm;
+
+pub use self::wasm::FuncTrampoline;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/wasm.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/wasm.rs
new file mode 100644
index 0000000..a3be231
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/trampoline/wasm.rs
@@ -0,0 +1,506 @@
+use crate::abi::{get_abi, Abi};
+use crate::config::{CompiledKind, LLVM};
+use crate::object_file::{load_object_file, CompiledFunction};
+use crate::translator::intrinsics::{type_to_llvm, type_to_llvm_ptr, Intrinsics};
+use inkwell::values::BasicMetadataValueEnum;
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    context::Context,
+    module::{Linkage, Module},
+    passes::PassManager,
+    targets::{FileType, TargetMachine},
+    types::{BasicType, FunctionType},
+    values::FunctionValue,
+    AddressSpace, DLLStorageClass,
+};
+use std::cmp;
+use std::convert::TryInto;
+use wasmer_types::{
+    CompileError, FunctionBody, FunctionType as FuncType, LocalFunctionIndex, RelocationTarget,
+};
+
+pub struct FuncTrampoline {
+    ctx: Context,
+    target_machine: TargetMachine,
+    abi: Box<dyn Abi>,
+}
+
+const FUNCTION_SECTION: &str = "__TEXT,wasmer_trmpl"; // Needs to be between 1 and 16 chars
+
+impl FuncTrampoline {
+    pub fn new(target_machine: TargetMachine) -> Self {
+        let abi = get_abi(&target_machine);
+        Self {
+            ctx: Context::create(),
+            target_machine,
+            abi,
+        }
+    }
+
+    pub fn trampoline_to_module(
+        &self,
+        ty: &FuncType,
+        config: &LLVM,
+        name: &str,
+    ) -> Result<Module, CompileError> {
+        // The function type, used for the callbacks.
+        let function = CompiledKind::FunctionCallTrampoline(ty.clone());
+        let module = self.ctx.create_module("");
+        let target_machine = &self.target_machine;
+        let target_triple = target_machine.get_triple();
+        let target_data = target_machine.get_target_data();
+        module.set_triple(&target_triple);
+        module.set_data_layout(&target_data.get_data_layout());
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
+
+        let (callee_ty, callee_attrs) =
+            self.abi
+                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty)?;
+        let trampoline_ty = intrinsics.void_ty.fn_type(
+            &[
+                intrinsics.ctx_ptr_ty.into(),                       // vmctx ptr
+                callee_ty.ptr_type(AddressSpace::default()).into(), // callee function address
+                intrinsics.i128_ptr_ty.into(),                      // in/out values ptr
+            ],
+            false,
+        );
+
+        let trampoline_func = module.add_function(name, trampoline_ty, Some(Linkage::External));
+        trampoline_func
+            .as_global_value()
+            .set_section(Some(FUNCTION_SECTION));
+        trampoline_func
+            .as_global_value()
+            .set_linkage(Linkage::DLLExport);
+        trampoline_func
+            .as_global_value()
+            .set_dll_storage_class(DLLStorageClass::Export);
+        self.generate_trampoline(
+            trampoline_func,
+            ty,
+            callee_ty,
+            &callee_attrs,
+            &self.ctx,
+            &intrinsics,
+        )?;
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.preopt_ir(&function, &module);
+        }
+
+        let pass_manager = PassManager::create(());
+
+        if config.enable_verifier {
+            pass_manager.add_verifier_pass();
+        }
+
+        pass_manager.add_early_cse_pass();
+
+        pass_manager.run_on(&module);
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.postopt_ir(&function, &module);
+        }
+
+        Ok(module)
+    }
+
+    pub fn trampoline(
+        &self,
+        ty: &FuncType,
+        config: &LLVM,
+        name: &str,
+    ) -> Result<FunctionBody, CompileError> {
+        let module = self.trampoline_to_module(ty, config, name)?;
+        let function = CompiledKind::FunctionCallTrampoline(ty.clone());
+        let target_machine = &self.target_machine;
+
+        let memory_buffer = target_machine
+            .write_to_memory_buffer(&module, FileType::Object)
+            .unwrap();
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.obj_memory_buffer(&function, &memory_buffer);
+        }
+
+        let mem_buf_slice = memory_buffer.as_slice();
+        let CompiledFunction {
+            compiled_function,
+            custom_sections,
+            eh_frame_section_indices,
+        } = load_object_file(
+            mem_buf_slice,
+            FUNCTION_SECTION,
+            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            |name: &str| {
+                Err(CompileError::Codegen(format!(
+                    "trampoline generation produced reference to unknown function {}",
+                    name
+                )))
+            },
+        )?;
+        let mut all_sections_are_eh_sections = true;
+        if eh_frame_section_indices.len() != custom_sections.len() {
+            all_sections_are_eh_sections = false;
+        } else {
+            let mut eh_frame_section_indices = eh_frame_section_indices;
+            eh_frame_section_indices.sort_unstable();
+            for (idx, section_idx) in eh_frame_section_indices.iter().enumerate() {
+                if idx as u32 != section_idx.as_u32() {
+                    all_sections_are_eh_sections = false;
+                    break;
+                }
+            }
+        }
+        if !all_sections_are_eh_sections {
+            return Err(CompileError::Codegen(
+                "trampoline generation produced non-eh custom sections".into(),
+            ));
+        }
+        if !compiled_function.relocations.is_empty() {
+            return Err(CompileError::Codegen(
+                "trampoline generation produced relocations".into(),
+            ));
+        }
+        // Ignore CompiledFunctionFrameInfo. Extra frame info isn't a problem.
+
+        Ok(FunctionBody {
+            body: compiled_function.body.body,
+            unwind_info: compiled_function.body.unwind_info,
+        })
+    }
+
+    pub fn dynamic_trampoline_to_module(
+        &self,
+        ty: &FuncType,
+        config: &LLVM,
+        name: &str,
+    ) -> Result<Module, CompileError> {
+        // The function type, used for the callbacks
+        let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
+        let module = self.ctx.create_module("");
+        let target_machine = &self.target_machine;
+        let target_data = target_machine.get_target_data();
+        let target_triple = target_machine.get_triple();
+        module.set_triple(&target_triple);
+        module.set_data_layout(&target_data.get_data_layout());
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
+
+        let (trampoline_ty, trampoline_attrs) =
+            self.abi
+                .func_type_to_llvm(&self.ctx, &intrinsics, None, ty)?;
+        let trampoline_func = module.add_function(name, trampoline_ty, Some(Linkage::External));
+        for (attr, attr_loc) in trampoline_attrs {
+            trampoline_func.add_attribute(attr_loc, attr);
+        }
+        trampoline_func
+            .as_global_value()
+            .set_section(Some(FUNCTION_SECTION));
+        trampoline_func
+            .as_global_value()
+            .set_linkage(Linkage::DLLExport);
+        trampoline_func
+            .as_global_value()
+            .set_dll_storage_class(DLLStorageClass::Export);
+        self.generate_dynamic_trampoline(trampoline_func, ty, &self.ctx, &intrinsics)?;
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.preopt_ir(&function, &module);
+        }
+
+        let pass_manager = PassManager::create(());
+
+        if config.enable_verifier {
+            pass_manager.add_verifier_pass();
+        }
+
+        pass_manager.add_early_cse_pass();
+
+        pass_manager.run_on(&module);
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.postopt_ir(&function, &module);
+        }
+
+        Ok(module)
+    }
+    pub fn dynamic_trampoline(
+        &self,
+        ty: &FuncType,
+        config: &LLVM,
+        name: &str,
+    ) -> Result<FunctionBody, CompileError> {
+        let function = CompiledKind::DynamicFunctionTrampoline(ty.clone());
+        let target_machine = &self.target_machine;
+
+        let module = self.dynamic_trampoline_to_module(ty, config, name)?;
+
+        let memory_buffer = target_machine
+            .write_to_memory_buffer(&module, FileType::Object)
+            .unwrap();
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.obj_memory_buffer(&function, &memory_buffer);
+        }
+
+        let mem_buf_slice = memory_buffer.as_slice();
+        let CompiledFunction {
+            compiled_function,
+            custom_sections,
+            eh_frame_section_indices,
+        } = load_object_file(
+            mem_buf_slice,
+            FUNCTION_SECTION,
+            RelocationTarget::LocalFunc(LocalFunctionIndex::from_u32(0)),
+            |name: &str| {
+                Err(CompileError::Codegen(format!(
+                    "trampoline generation produced reference to unknown function {}",
+                    name
+                )))
+            },
+        )?;
+        let mut all_sections_are_eh_sections = true;
+        if eh_frame_section_indices.len() != custom_sections.len() {
+            all_sections_are_eh_sections = false;
+        } else {
+            let mut eh_frame_section_indices = eh_frame_section_indices;
+            eh_frame_section_indices.sort_unstable();
+            for (idx, section_idx) in eh_frame_section_indices.iter().enumerate() {
+                if idx as u32 != section_idx.as_u32() {
+                    all_sections_are_eh_sections = false;
+                    break;
+                }
+            }
+        }
+        if !all_sections_are_eh_sections {
+            return Err(CompileError::Codegen(
+                "trampoline generation produced non-eh custom sections".into(),
+            ));
+        }
+        if !compiled_function.relocations.is_empty() {
+            return Err(CompileError::Codegen(
+                "trampoline generation produced relocations".into(),
+            ));
+        }
+        // Ignore CompiledFunctionFrameInfo. Extra frame info isn't a problem.
+
+        Ok(FunctionBody {
+            body: compiled_function.body.body,
+            unwind_info: compiled_function.body.unwind_info,
+        })
+    }
+
+    fn generate_trampoline<'ctx>(
+        &self,
+        trampoline_func: FunctionValue,
+        func_sig: &FuncType,
+        llvm_func_type: FunctionType,
+        func_attrs: &[(Attribute, AttributeLoc)],
+        context: &'ctx Context,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> Result<(), CompileError> {
+        let entry_block = context.append_basic_block(trampoline_func, "entry");
+        let builder = context.create_builder();
+        builder.position_at_end(entry_block);
+
+        let (callee_vmctx_ptr, func_ptr, args_rets_ptr) =
+            match *trampoline_func.get_params().as_slice() {
+                [callee_vmctx_ptr, func_ptr, args_rets_ptr] => (
+                    callee_vmctx_ptr,
+                    func_ptr.into_pointer_value(),
+                    args_rets_ptr.into_pointer_value(),
+                ),
+                _ => {
+                    return Err(CompileError::Codegen(
+                        "trampoline function unimplemented".to_string(),
+                    ))
+                }
+            };
+
+        let mut args_vec: Vec<BasicMetadataValueEnum> =
+            Vec::with_capacity(func_sig.params().len() + 1);
+
+        if self.abi.is_sret(func_sig)? {
+            let basic_types: Vec<_> = func_sig
+                .results()
+                .iter()
+                .map(|&ty| type_to_llvm(intrinsics, ty))
+                .collect::<Result<_, _>>()?;
+
+            let sret_ty = context.struct_type(&basic_types, false);
+            args_vec.push(builder.build_alloca(sret_ty, "sret").into());
+        }
+
+        args_vec.push(callee_vmctx_ptr.into());
+
+        for (i, param_ty) in func_sig.params().iter().enumerate() {
+            let index = intrinsics.i32_ty.const_int(i as _, false);
+            let item_pointer = unsafe {
+                builder.build_in_bounds_gep(intrinsics.i128_ty, args_rets_ptr, &[index], "arg_ptr")
+            };
+
+            let casted_type = type_to_llvm(intrinsics, *param_ty)?;
+            let casted_pointer_type = type_to_llvm_ptr(intrinsics, *param_ty)?;
+
+            let typed_item_pointer =
+                builder.build_pointer_cast(item_pointer, casted_pointer_type, "typed_arg_pointer");
+
+            let arg = builder.build_load(casted_type, typed_item_pointer, "arg");
+            args_vec.push(arg.into());
+        }
+
+        let call_site =
+            builder.build_indirect_call(llvm_func_type, func_ptr, args_vec.as_slice(), "call");
+        for (attr, attr_loc) in func_attrs {
+            call_site.add_attribute(*attr_loc, *attr);
+        }
+
+        let rets = self
+            .abi
+            .rets_from_call(&builder, intrinsics, call_site, func_sig);
+        let mut idx = 0;
+        rets.iter().for_each(|v| {
+            let ptr = unsafe {
+                builder.build_gep(
+                    intrinsics.i128_ty,
+                    args_rets_ptr,
+                    &[intrinsics.i32_ty.const_int(idx, false)],
+                    "",
+                )
+            };
+            let ptr =
+                builder.build_pointer_cast(ptr, v.get_type().ptr_type(AddressSpace::default()), "");
+            builder.build_store(ptr, *v);
+            idx += 1;
+        });
+
+        builder.build_return(None);
+        Ok(())
+    }
+
+    fn generate_dynamic_trampoline<'ctx>(
+        &self,
+        trampoline_func: FunctionValue,
+        func_sig: &FuncType,
+        context: &'ctx Context,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> Result<(), CompileError> {
+        let entry_block = context.append_basic_block(trampoline_func, "entry");
+        let builder = context.create_builder();
+        builder.position_at_end(entry_block);
+
+        // Allocate stack space for the params and results.
+        let values = builder.build_alloca(
+            intrinsics.i128_ty.array_type(cmp::max(
+                func_sig.params().len().try_into().unwrap(),
+                func_sig.results().len().try_into().unwrap(),
+            )),
+            "",
+        );
+
+        // Copy params to 'values'.
+        let first_user_param = if self.abi.is_sret(func_sig)? { 2 } else { 1 };
+        for i in 0..func_sig.params().len() {
+            let ptr = unsafe {
+                builder.build_in_bounds_gep(
+                    intrinsics.i128_ty,
+                    values,
+                    &[intrinsics.i32_ty.const_int(i.try_into().unwrap(), false)],
+                    "args",
+                )
+            };
+            let ptr = builder
+                .build_bitcast(ptr, type_to_llvm_ptr(intrinsics, func_sig.params()[i])?, "")
+                .into_pointer_value();
+            builder.build_store(
+                ptr,
+                trampoline_func
+                    .get_nth_param(i as u32 + first_user_param)
+                    .unwrap(),
+            );
+        }
+
+        let callee_ptr_ty = intrinsics.void_ty.fn_type(
+            &[
+                intrinsics.ctx_ptr_ty.into(),  // vmctx ptr
+                intrinsics.i128_ptr_ty.into(), // in/out values ptr
+            ],
+            false,
+        );
+        let callee_ty = callee_ptr_ty.ptr_type(AddressSpace::default());
+        let vmctx = self.abi.get_vmctx_ptr_param(&trampoline_func);
+        let callee_ty =
+            builder.build_bitcast(vmctx, callee_ty.ptr_type(AddressSpace::default()), "");
+        let callee = builder
+            .build_load(intrinsics.ctx_ptr_ty, callee_ty.into_pointer_value(), "")
+            .into_pointer_value();
+
+        let values_ptr = builder.build_pointer_cast(values, intrinsics.i128_ptr_ty, "");
+        builder.build_indirect_call(
+            callee_ptr_ty,
+            callee,
+            &[vmctx.into(), values_ptr.into()],
+            "",
+        );
+
+        if func_sig.results().is_empty() {
+            builder.build_return(None);
+        } else {
+            let results = func_sig
+                .results()
+                .iter()
+                .enumerate()
+                .map(|(idx, ty)| {
+                    let ptr = unsafe {
+                        builder.build_gep(
+                            intrinsics.i128_ty,
+                            values,
+                            &[intrinsics.i32_ty.const_int(idx.try_into().unwrap(), false)],
+                            "",
+                        )
+                    };
+                    let ptr =
+                        builder.build_pointer_cast(ptr, type_to_llvm_ptr(intrinsics, *ty)?, "");
+                    Ok(builder.build_load(type_to_llvm(intrinsics, *ty)?, ptr, ""))
+                })
+                .collect::<Result<Vec<_>, CompileError>>()?;
+
+            if self.abi.is_sret(func_sig)? {
+                let sret = trampoline_func
+                    .get_first_param()
+                    .unwrap()
+                    .into_pointer_value();
+
+                let basic_types: Vec<_> = func_sig
+                    .results()
+                    .iter()
+                    .map(|&ty| type_to_llvm(intrinsics, ty))
+                    .collect::<Result<_, _>>()?;
+                let mut struct_value = context.struct_type(&basic_types, false).get_undef();
+
+                for (idx, value) in results.iter().enumerate() {
+                    let value = builder.build_bitcast(
+                        *value,
+                        type_to_llvm(intrinsics, func_sig.results()[idx])?,
+                        "",
+                    );
+                    struct_value = builder
+                        .build_insert_value(struct_value, value, idx as u32, "")
+                        .unwrap()
+                        .into_struct_value();
+                }
+                builder.build_store(sret, struct_value);
+                builder.build_return(None);
+            } else {
+                builder.build_return(Some(&self.abi.pack_values_for_register_return(
+                    intrinsics,
+                    &builder,
+                    results.as_slice(),
+                    &trampoline_func.get_type(),
+                )?));
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/code.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/code.rs
new file mode 100644
index 0000000..e4d00ee
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/code.rs
@@ -0,0 +1,11480 @@
+use super::{
+    intrinsics::{
+        tbaa_label, type_to_llvm, CtxType, FunctionCache, GlobalCache, Intrinsics, MemoryCache,
+    },
+    // stackmap::{StackmapEntry, StackmapEntryKind, StackmapRegistry, ValueSemantic},
+    state::{ControlFrame, ExtraInfo, IfElseState, State},
+};
+use inkwell::{
+    attributes::AttributeLoc,
+    builder::Builder,
+    context::Context,
+    module::{Linkage, Module},
+    passes::PassManager,
+    targets::{FileType, TargetMachine},
+    types::{BasicType, BasicTypeEnum, FloatMathType, IntType, PointerType, VectorType},
+    values::{
+        BasicMetadataValueEnum, BasicValue, BasicValueEnum, FloatValue, FunctionValue,
+        InstructionOpcode, InstructionValue, IntValue, PhiValue, PointerValue, VectorValue,
+    },
+    AddressSpace, AtomicOrdering, AtomicRMWBinOp, DLLStorageClass, FloatPredicate, IntPredicate,
+};
+use smallvec::SmallVec;
+
+use crate::abi::{get_abi, Abi};
+use crate::config::{CompiledKind, LLVM};
+use crate::object_file::{load_object_file, CompiledFunction};
+use wasmer_compiler::wasmparser::{MemArg, Operator};
+use wasmer_compiler::{
+    from_binaryreadererror_wasmerror, wpheaptype_to_type, wptype_to_type, FunctionBinaryReader,
+    FunctionBodyData, MiddlewareBinaryReader, ModuleMiddlewareChain, ModuleTranslationState,
+};
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{
+    CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex, MemoryIndex,
+    ModuleInfo, RelocationTarget, SignatureIndex, Symbol, SymbolRegistry, TableIndex, Type,
+};
+use wasmer_vm::{MemoryStyle, TableStyle, VMOffsets};
+
+const FUNCTION_SECTION: &str = "__TEXT,wasmer_function";
+
+fn to_compile_error(err: impl std::error::Error) -> CompileError {
+    CompileError::Codegen(format!("{}", err))
+}
+
+pub struct FuncTranslator {
+    ctx: Context,
+    target_machine: TargetMachine,
+    abi: Box<dyn Abi>,
+}
+
+impl FuncTranslator {
+    pub fn new(target_machine: TargetMachine) -> Self {
+        let abi = get_abi(&target_machine);
+        Self {
+            ctx: Context::create(),
+            target_machine,
+            abi,
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn translate_to_module(
+        &self,
+        wasm_module: &ModuleInfo,
+        module_translation: &ModuleTranslationState,
+        local_func_index: &LocalFunctionIndex,
+        function_body: &FunctionBodyData,
+        config: &LLVM,
+        memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
+        _table_styles: &PrimaryMap<TableIndex, TableStyle>,
+        symbol_registry: &dyn SymbolRegistry,
+    ) -> Result<Module, CompileError> {
+        // The function type, used for the callbacks.
+        let function = CompiledKind::Local(*local_func_index);
+        let func_index = wasm_module.func_index(*local_func_index);
+        let function_name =
+            symbol_registry.symbol_to_name(Symbol::LocalFunction(*local_func_index));
+        let module_name = match wasm_module.name.as_ref() {
+            None => format!("<anonymous module> function {}", function_name),
+            Some(module_name) => format!("module {} function {}", module_name, function_name),
+        };
+        let module = self.ctx.create_module(module_name.as_str());
+
+        let target_machine = &self.target_machine;
+        let target_triple = target_machine.get_triple();
+        let target_data = target_machine.get_target_data();
+        module.set_triple(&target_triple);
+        module.set_data_layout(&target_data.get_data_layout());
+        let wasm_fn_type = wasm_module
+            .signatures
+            .get(wasm_module.functions[func_index])
+            .unwrap();
+
+        // TODO: pointer width
+        let offsets = VMOffsets::new(8, wasm_module);
+        let intrinsics = Intrinsics::declare(&module, &self.ctx, &target_data);
+        let (func_type, func_attrs) =
+            self.abi
+                .func_type_to_llvm(&self.ctx, &intrinsics, Some(&offsets), wasm_fn_type)?;
+
+        let func = module.add_function(&function_name, func_type, Some(Linkage::External));
+        for (attr, attr_loc) in &func_attrs {
+            func.add_attribute(*attr_loc, *attr);
+        }
+
+        func.add_attribute(AttributeLoc::Function, intrinsics.stack_probe);
+        func.set_personality_function(intrinsics.personality);
+        func.as_global_value().set_section(Some(FUNCTION_SECTION));
+        func.set_linkage(Linkage::DLLExport);
+        func.as_global_value()
+            .set_dll_storage_class(DLLStorageClass::Export);
+
+        let entry = self.ctx.append_basic_block(func, "entry");
+        let start_of_code = self.ctx.append_basic_block(func, "start_of_code");
+        let return_ = self.ctx.append_basic_block(func, "return");
+        let alloca_builder = self.ctx.create_builder();
+        let cache_builder = self.ctx.create_builder();
+        let builder = self.ctx.create_builder();
+        cache_builder.position_at_end(entry);
+        let br = cache_builder.build_unconditional_branch(start_of_code);
+        alloca_builder.position_before(&br);
+        cache_builder.position_before(&br);
+        builder.position_at_end(start_of_code);
+
+        let mut state = State::new();
+        builder.position_at_end(return_);
+        let phis: SmallVec<[PhiValue; 1]> = wasm_fn_type
+            .results()
+            .iter()
+            .map(|&wasm_ty| type_to_llvm(&intrinsics, wasm_ty).map(|ty| builder.build_phi(ty, "")))
+            .collect::<Result<_, _>>()?;
+        state.push_block(return_, phis);
+        builder.position_at_end(start_of_code);
+
+        let mut reader = MiddlewareBinaryReader::new_with_offset(
+            function_body.data,
+            function_body.module_offset,
+        );
+        reader.set_middleware_chain(
+            config
+                .middlewares
+                .generate_function_middleware_chain(*local_func_index),
+        );
+
+        let mut params = vec![];
+        let first_param =
+            if func_type.get_return_type().is_none() && wasm_fn_type.results().len() > 1 {
+                2
+            } else {
+                1
+            };
+        let mut is_first_alloca = true;
+        let mut insert_alloca = |ty, name| {
+            let alloca = alloca_builder.build_alloca(ty, name);
+            if is_first_alloca {
+                alloca_builder.position_at(entry, &alloca.as_instruction_value().unwrap());
+                is_first_alloca = false;
+            }
+            alloca
+        };
+
+        for idx in 0..wasm_fn_type.params().len() {
+            let ty = wasm_fn_type.params()[idx];
+            let ty = type_to_llvm(&intrinsics, ty)?;
+            let value = func
+                .get_nth_param((idx as u32).checked_add(first_param).unwrap())
+                .unwrap();
+            let alloca = insert_alloca(ty, "param");
+            cache_builder.build_store(alloca, value);
+            params.push((ty, alloca));
+        }
+
+        let mut locals = vec![];
+        let num_locals = reader.read_local_count()?;
+        for _ in 0..num_locals {
+            let (count, ty) = reader.read_local_decl()?;
+            let ty = wptype_to_type(ty).map_err(to_compile_error)?;
+            let ty = type_to_llvm(&intrinsics, ty)?;
+            for _ in 0..count {
+                let alloca = insert_alloca(ty, "local");
+                cache_builder.build_store(alloca, ty.const_zero());
+                locals.push((ty, alloca));
+            }
+        }
+
+        let mut params_locals = params.clone();
+        params_locals.extend(locals.iter().cloned());
+
+        let mut fcg = LLVMFunctionCodeGenerator {
+            context: &self.ctx,
+            builder,
+            alloca_builder,
+            intrinsics: &intrinsics,
+            state,
+            function: func,
+            locals: params_locals,
+            ctx: CtxType::new(wasm_module, &func, &cache_builder, &*self.abi),
+            unreachable_depth: 0,
+            memory_styles,
+            _table_styles,
+            module: &module,
+            module_translation,
+            wasm_module,
+            symbol_registry,
+            abi: &*self.abi,
+            config,
+        };
+        fcg.ctx.add_func(
+            func_index,
+            func.as_global_value().as_pointer_value(),
+            func_type,
+            fcg.ctx.basic(),
+            &func_attrs,
+        );
+
+        while fcg.state.has_control_frames() {
+            let pos = reader.current_position() as u32;
+            let op = reader.read_operator()?;
+            fcg.translate_operator(op, pos)?;
+        }
+
+        fcg.finalize(wasm_fn_type)?;
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.preopt_ir(&function, &module);
+        }
+
+        let pass_manager = PassManager::create(());
+
+        if config.enable_verifier {
+            pass_manager.add_verifier_pass();
+        }
+
+        pass_manager.add_type_based_alias_analysis_pass();
+        pass_manager.add_sccp_pass();
+        pass_manager.add_prune_eh_pass();
+        pass_manager.add_dead_arg_elimination_pass();
+        pass_manager.add_lower_expect_intrinsic_pass();
+        pass_manager.add_scalar_repl_aggregates_pass();
+        pass_manager.add_instruction_combining_pass();
+        pass_manager.add_jump_threading_pass();
+        pass_manager.add_correlated_value_propagation_pass();
+        pass_manager.add_cfg_simplification_pass();
+        pass_manager.add_reassociate_pass();
+        pass_manager.add_loop_rotate_pass();
+        pass_manager.add_ind_var_simplify_pass();
+        pass_manager.add_licm_pass();
+        pass_manager.add_loop_vectorize_pass();
+        pass_manager.add_instruction_combining_pass();
+        pass_manager.add_sccp_pass();
+        pass_manager.add_reassociate_pass();
+        pass_manager.add_cfg_simplification_pass();
+        pass_manager.add_gvn_pass();
+        pass_manager.add_memcpy_optimize_pass();
+        pass_manager.add_dead_store_elimination_pass();
+        pass_manager.add_bit_tracking_dce_pass();
+        pass_manager.add_instruction_combining_pass();
+        pass_manager.add_reassociate_pass();
+        pass_manager.add_cfg_simplification_pass();
+        pass_manager.add_slp_vectorize_pass();
+        pass_manager.add_early_cse_pass();
+
+        pass_manager.run_on(&module);
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.postopt_ir(&function, &module);
+        }
+
+        Ok(module)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn translate(
+        &self,
+        wasm_module: &ModuleInfo,
+        module_translation: &ModuleTranslationState,
+        local_func_index: &LocalFunctionIndex,
+        function_body: &FunctionBodyData,
+        config: &LLVM,
+        memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
+        table_styles: &PrimaryMap<TableIndex, TableStyle>,
+        symbol_registry: &dyn SymbolRegistry,
+    ) -> Result<CompiledFunction, CompileError> {
+        let module = self.translate_to_module(
+            wasm_module,
+            module_translation,
+            local_func_index,
+            function_body,
+            config,
+            memory_styles,
+            table_styles,
+            symbol_registry,
+        )?;
+        let function = CompiledKind::Local(*local_func_index);
+        let target_machine = &self.target_machine;
+        let memory_buffer = target_machine
+            .write_to_memory_buffer(&module, FileType::Object)
+            .unwrap();
+
+        if let Some(ref callbacks) = config.callbacks {
+            callbacks.obj_memory_buffer(&function, &memory_buffer);
+        }
+
+        let mem_buf_slice = memory_buffer.as_slice();
+        load_object_file(
+            mem_buf_slice,
+            FUNCTION_SECTION,
+            RelocationTarget::LocalFunc(*local_func_index),
+            |name: &str| {
+                Ok(
+                    if let Some(Symbol::LocalFunction(local_func_index)) =
+                        symbol_registry.name_to_symbol(name)
+                    {
+                        Some(RelocationTarget::LocalFunc(local_func_index))
+                    } else {
+                        None
+                    },
+                )
+            },
+        )
+    }
+}
+
+impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
+    // Create a vector where each lane contains the same value.
+    fn splat_vector(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        vec_ty: VectorType<'ctx>,
+    ) -> VectorValue<'ctx> {
+        // Use insert_element to insert the element into an undef vector, then use
+        // shuffle vector to copy that lane to all lanes.
+        self.builder.build_shuffle_vector(
+            self.builder.build_insert_element(
+                vec_ty.get_undef(),
+                value,
+                self.intrinsics.i32_zero,
+                "",
+            ),
+            vec_ty.get_undef(),
+            self.intrinsics
+                .i32_ty
+                .vec_type(vec_ty.get_size())
+                .const_zero(),
+            "",
+        )
+    }
+
+    // Convert floating point vector to integer and saturate when out of range.
+    // https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md
+    #[allow(clippy::too_many_arguments)]
+    fn trunc_sat<T: FloatMathType<'ctx>>(
+        &self,
+        fvec_ty: T,
+        ivec_ty: T::MathConvType,
+        lower_bound: u64, // Exclusive (least representable value)
+        upper_bound: u64, // Exclusive (greatest representable value)
+        int_min_value: u64,
+        int_max_value: u64,
+        value: IntValue<'ctx>,
+    ) -> VectorValue<'ctx> {
+        // a) Compare vector with itself to identify NaN lanes.
+        // b) Compare vector with splat of inttofp(upper_bound) to identify
+        //    lanes that need to saturate to max.
+        // c) Compare vector with splat of inttofp(lower_bound) to identify
+        //    lanes that need to saturate to min.
+        // d) Use vector select (not shuffle) to pick from either the
+        //    splat vector or the input vector depending on whether the
+        //    comparison indicates that we have an unrepresentable value. Replace
+        //    unrepresentable values with zero.
+        // e) Now that the value is safe, fpto[su]i it.
+        // f) Use our previous comparison results to replace certain zeros with
+        //    int_min or int_max.
+
+        let fvec_ty = fvec_ty.as_basic_type_enum().into_vector_type();
+        let ivec_ty = ivec_ty.as_basic_type_enum().into_vector_type();
+        let fvec_element_ty = fvec_ty.get_element_type().into_float_type();
+        let ivec_element_ty = ivec_ty.get_element_type().into_int_type();
+
+        let is_signed = int_min_value != 0;
+        let int_min_value = self.splat_vector(
+            ivec_element_ty
+                .const_int(int_min_value, is_signed)
+                .as_basic_value_enum(),
+            ivec_ty,
+        );
+        let int_max_value = self.splat_vector(
+            ivec_element_ty
+                .const_int(int_max_value, is_signed)
+                .as_basic_value_enum(),
+            ivec_ty,
+        );
+        let lower_bound = if is_signed {
+            self.builder.build_signed_int_to_float(
+                ivec_element_ty.const_int(lower_bound, is_signed),
+                fvec_element_ty,
+                "",
+            )
+        } else {
+            self.builder.build_unsigned_int_to_float(
+                ivec_element_ty.const_int(lower_bound, is_signed),
+                fvec_element_ty,
+                "",
+            )
+        };
+        let upper_bound = if is_signed {
+            self.builder.build_signed_int_to_float(
+                ivec_element_ty.const_int(upper_bound, is_signed),
+                fvec_element_ty,
+                "",
+            )
+        } else {
+            self.builder.build_unsigned_int_to_float(
+                ivec_element_ty.const_int(upper_bound, is_signed),
+                fvec_element_ty,
+                "",
+            )
+        };
+
+        let value = self
+            .builder
+            .build_bitcast(value, fvec_ty, "")
+            .into_vector_value();
+        let zero = fvec_ty.const_zero();
+        let lower_bound = self.splat_vector(lower_bound.as_basic_value_enum(), fvec_ty);
+        let upper_bound = self.splat_vector(upper_bound.as_basic_value_enum(), fvec_ty);
+        let nan_cmp = self
+            .builder
+            .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
+        let above_upper_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::OGT,
+            value,
+            upper_bound,
+            "above_upper_bound",
+        );
+        let below_lower_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::OLT,
+            value,
+            lower_bound,
+            "below_lower_bound",
+        );
+        let not_representable = self.builder.build_or(
+            self.builder.build_or(nan_cmp, above_upper_bound_cmp, ""),
+            below_lower_bound_cmp,
+            "not_representable_as_int",
+        );
+        let value = self
+            .builder
+            .build_select(not_representable, zero, value, "safe_to_convert")
+            .into_vector_value();
+        let value = if is_signed {
+            self.builder
+                .build_float_to_signed_int(value, ivec_ty, "as_int")
+        } else {
+            self.builder
+                .build_float_to_unsigned_int(value, ivec_ty, "as_int")
+        };
+        let value = self
+            .builder
+            .build_select(above_upper_bound_cmp, int_max_value, value, "")
+            .into_vector_value();
+        self.builder
+            .build_select(below_lower_bound_cmp, int_min_value, value, "")
+            .into_vector_value()
+    }
+
+    // Convert floating point vector to integer and saturate when out of range.
+    // https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md
+    #[allow(clippy::too_many_arguments)]
+    fn trunc_sat_into_int<T: FloatMathType<'ctx>>(
+        &self,
+        fvec_ty: T,
+        ivec_ty: T::MathConvType,
+        lower_bound: u64, // Exclusive (least representable value)
+        upper_bound: u64, // Exclusive (greatest representable value)
+        int_min_value: u64,
+        int_max_value: u64,
+        value: IntValue<'ctx>,
+    ) -> IntValue<'ctx> {
+        let res = self.trunc_sat(
+            fvec_ty,
+            ivec_ty,
+            lower_bound,
+            upper_bound,
+            int_min_value,
+            int_max_value,
+            value,
+        );
+        self.builder
+            .build_bitcast(res, self.intrinsics.i128_ty, "")
+            .into_int_value()
+    }
+
+    // Convert floating point vector to integer and saturate when out of range.
+    // https://github.com/WebAssembly/nontrapping-float-to-int-conversions/blob/master/proposals/nontrapping-float-to-int-conversion/Overview.md
+    fn trunc_sat_scalar(
+        &self,
+        int_ty: IntType<'ctx>,
+        lower_bound: u64, // Exclusive (least representable value)
+        upper_bound: u64, // Exclusive (greatest representable value)
+        int_min_value: u64,
+        int_max_value: u64,
+        value: FloatValue<'ctx>,
+    ) -> IntValue<'ctx> {
+        // TODO: this is a scalarized version of the process in trunc_sat. Either
+        // we should merge with trunc_sat, or we should simplify this function.
+
+        // a) Compare value with itself to identify NaN.
+        // b) Compare value inttofp(upper_bound) to identify values that need to
+        //    saturate to max.
+        // c) Compare value with inttofp(lower_bound) to identify values that need
+        //    to saturate to min.
+        // d) Use select to pick from either zero or the input vector depending on
+        //    whether the comparison indicates that we have an unrepresentable
+        //    value.
+        // e) Now that the value is safe, fpto[su]i it.
+        // f) Use our previous comparison results to replace certain zeros with
+        //    int_min or int_max.
+
+        let is_signed = int_min_value != 0;
+        let int_min_value = int_ty.const_int(int_min_value, is_signed);
+        let int_max_value = int_ty.const_int(int_max_value, is_signed);
+
+        let lower_bound = if is_signed {
+            self.builder.build_signed_int_to_float(
+                int_ty.const_int(lower_bound, is_signed),
+                value.get_type(),
+                "",
+            )
+        } else {
+            self.builder.build_unsigned_int_to_float(
+                int_ty.const_int(lower_bound, is_signed),
+                value.get_type(),
+                "",
+            )
+        };
+        let upper_bound = if is_signed {
+            self.builder.build_signed_int_to_float(
+                int_ty.const_int(upper_bound, is_signed),
+                value.get_type(),
+                "",
+            )
+        } else {
+            self.builder.build_unsigned_int_to_float(
+                int_ty.const_int(upper_bound, is_signed),
+                value.get_type(),
+                "",
+            )
+        };
+
+        let zero = value.get_type().const_zero();
+
+        let nan_cmp = self
+            .builder
+            .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
+        let above_upper_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::OGT,
+            value,
+            upper_bound,
+            "above_upper_bound",
+        );
+        let below_lower_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::OLT,
+            value,
+            lower_bound,
+            "below_lower_bound",
+        );
+        let not_representable = self.builder.build_or(
+            self.builder.build_or(nan_cmp, above_upper_bound_cmp, ""),
+            below_lower_bound_cmp,
+            "not_representable_as_int",
+        );
+        let value = self
+            .builder
+            .build_select(not_representable, zero, value, "safe_to_convert")
+            .into_float_value();
+        let value = if is_signed {
+            self.builder
+                .build_float_to_signed_int(value, int_ty, "as_int")
+        } else {
+            self.builder
+                .build_float_to_unsigned_int(value, int_ty, "as_int")
+        };
+        let value = self
+            .builder
+            .build_select(above_upper_bound_cmp, int_max_value, value, "")
+            .into_int_value();
+        let value = self
+            .builder
+            .build_select(below_lower_bound_cmp, int_min_value, value, "")
+            .into_int_value();
+        self.builder
+            .build_bitcast(value, int_ty, "")
+            .into_int_value()
+    }
+
+    fn trap_if_not_representable_as_int(
+        &self,
+        lower_bound: u64, // Inclusive (not a trapping value)
+        upper_bound: u64, // Inclusive (not a trapping value)
+        value: FloatValue,
+    ) {
+        let float_ty = value.get_type();
+        let int_ty = if float_ty == self.intrinsics.f32_ty {
+            self.intrinsics.i32_ty
+        } else {
+            self.intrinsics.i64_ty
+        };
+
+        let lower_bound = self
+            .builder
+            .build_bitcast(int_ty.const_int(lower_bound, false), float_ty, "")
+            .into_float_value();
+        let upper_bound = self
+            .builder
+            .build_bitcast(int_ty.const_int(upper_bound, false), float_ty, "")
+            .into_float_value();
+
+        // The 'U' in the float predicate is short for "unordered" which means that
+        // the comparison will compare true if either operand is a NaN. Thus, NaNs
+        // are out of bounds.
+        let above_upper_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::UGT,
+            value,
+            upper_bound,
+            "above_upper_bound",
+        );
+        let below_lower_bound_cmp = self.builder.build_float_compare(
+            FloatPredicate::ULT,
+            value,
+            lower_bound,
+            "below_lower_bound",
+        );
+        let out_of_bounds = self.builder.build_or(
+            above_upper_bound_cmp,
+            below_lower_bound_cmp,
+            "out_of_bounds",
+        );
+
+        let failure_block = self
+            .context
+            .append_basic_block(self.function, "conversion_failure_block");
+        let continue_block = self
+            .context
+            .append_basic_block(self.function, "conversion_success_block");
+
+        self.builder
+            .build_conditional_branch(out_of_bounds, failure_block, continue_block);
+        self.builder.position_at_end(failure_block);
+        let is_nan = self
+            .builder
+            .build_float_compare(FloatPredicate::UNO, value, value, "is_nan");
+        let trap_code = self.builder.build_select(
+            is_nan,
+            self.intrinsics.trap_bad_conversion_to_integer,
+            self.intrinsics.trap_illegal_arithmetic,
+            "",
+        );
+        self.builder
+            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
+        self.builder.build_unreachable();
+        self.builder.position_at_end(continue_block);
+    }
+
+    fn trap_if_zero_or_overflow(&self, left: IntValue, right: IntValue) {
+        let int_type = left.get_type();
+
+        let (min_value, neg_one_value) = if int_type == self.intrinsics.i32_ty {
+            let min_value = int_type.const_int(i32::min_value() as u64, false);
+            let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
+            (min_value, neg_one_value)
+        } else if int_type == self.intrinsics.i64_ty {
+            let min_value = int_type.const_int(i64::min_value() as u64, false);
+            let neg_one_value = int_type.const_int(-1i64 as u64, false);
+            (min_value, neg_one_value)
+        } else {
+            unreachable!()
+        };
+
+        let divisor_is_zero = self.builder.build_int_compare(
+            IntPredicate::EQ,
+            right,
+            int_type.const_zero(),
+            "divisor_is_zero",
+        );
+        let should_trap = self.builder.build_or(
+            divisor_is_zero,
+            self.builder.build_and(
+                self.builder
+                    .build_int_compare(IntPredicate::EQ, left, min_value, "left_is_min"),
+                self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    right,
+                    neg_one_value,
+                    "right_is_neg_one",
+                ),
+                "div_will_overflow",
+            ),
+            "div_should_trap",
+        );
+
+        let should_trap = self
+            .builder
+            .build_call(
+                self.intrinsics.expect_i1,
+                &[
+                    should_trap.into(),
+                    self.intrinsics.i1_ty.const_zero().into(),
+                ],
+                "should_trap_expect",
+            )
+            .try_as_basic_value()
+            .left()
+            .unwrap()
+            .into_int_value();
+
+        let shouldnt_trap_block = self
+            .context
+            .append_basic_block(self.function, "shouldnt_trap_block");
+        let should_trap_block = self
+            .context
+            .append_basic_block(self.function, "should_trap_block");
+        self.builder
+            .build_conditional_branch(should_trap, should_trap_block, shouldnt_trap_block);
+        self.builder.position_at_end(should_trap_block);
+        let trap_code = self.builder.build_select(
+            divisor_is_zero,
+            self.intrinsics.trap_integer_division_by_zero,
+            self.intrinsics.trap_illegal_arithmetic,
+            "",
+        );
+        self.builder
+            .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
+        self.builder.build_unreachable();
+        self.builder.position_at_end(shouldnt_trap_block);
+    }
+
+    fn trap_if_zero(&self, value: IntValue) {
+        let int_type = value.get_type();
+        let should_trap = self.builder.build_int_compare(
+            IntPredicate::EQ,
+            value,
+            int_type.const_zero(),
+            "divisor_is_zero",
+        );
+
+        let should_trap = self
+            .builder
+            .build_call(
+                self.intrinsics.expect_i1,
+                &[
+                    should_trap.into(),
+                    self.intrinsics.i1_ty.const_zero().into(),
+                ],
+                "should_trap_expect",
+            )
+            .try_as_basic_value()
+            .left()
+            .unwrap()
+            .into_int_value();
+
+        let shouldnt_trap_block = self
+            .context
+            .append_basic_block(self.function, "shouldnt_trap_block");
+        let should_trap_block = self
+            .context
+            .append_basic_block(self.function, "should_trap_block");
+        self.builder
+            .build_conditional_branch(should_trap, should_trap_block, shouldnt_trap_block);
+        self.builder.position_at_end(should_trap_block);
+        self.builder.build_call(
+            self.intrinsics.throw_trap,
+            &[self.intrinsics.trap_integer_division_by_zero.into()],
+            "throw",
+        );
+        self.builder.build_unreachable();
+        self.builder.position_at_end(shouldnt_trap_block);
+    }
+
+    fn v128_into_int_vec(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+        int_vec_ty: VectorType<'ctx>,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        let (value, info) = if info.has_pending_f32_nan() {
+            let value = self
+                .builder
+                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
+            (self.canonicalize_nans(value), info.strip_pending())
+        } else if info.has_pending_f64_nan() {
+            let value = self
+                .builder
+                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
+            (self.canonicalize_nans(value), info.strip_pending())
+        } else {
+            (value, info)
+        };
+        (
+            self.builder
+                .build_bitcast(value, int_vec_ty, "")
+                .into_vector_value(),
+            info,
+        )
+    }
+
+    fn v128_into_i8x16(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        self.v128_into_int_vec(value, info, self.intrinsics.i8x16_ty)
+    }
+
+    fn v128_into_i16x8(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        self.v128_into_int_vec(value, info, self.intrinsics.i16x8_ty)
+    }
+
+    fn v128_into_i32x4(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        self.v128_into_int_vec(value, info, self.intrinsics.i32x4_ty)
+    }
+
+    fn v128_into_i64x2(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        self.v128_into_int_vec(value, info, self.intrinsics.i64x2_ty)
+    }
+
+    // If the value is pending a 64-bit canonicalization, do it now.
+    // Return a f32x4 vector.
+    fn v128_into_f32x4(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        let (value, info) = if info.has_pending_f64_nan() {
+            let value = self
+                .builder
+                .build_bitcast(value, self.intrinsics.f64x2_ty, "");
+            (self.canonicalize_nans(value), info.strip_pending())
+        } else {
+            (value, info)
+        };
+        (
+            self.builder
+                .build_bitcast(value, self.intrinsics.f32x4_ty, "")
+                .into_vector_value(),
+            info,
+        )
+    }
+
+    // If the value is pending a 32-bit canonicalization, do it now.
+    // Return a f64x2 vector.
+    fn v128_into_f64x2(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> (VectorValue<'ctx>, ExtraInfo) {
+        let (value, info) = if info.has_pending_f32_nan() {
+            let value = self
+                .builder
+                .build_bitcast(value, self.intrinsics.f32x4_ty, "");
+            (self.canonicalize_nans(value), info.strip_pending())
+        } else {
+            (value, info)
+        };
+        (
+            self.builder
+                .build_bitcast(value, self.intrinsics.f64x2_ty, "")
+                .into_vector_value(),
+            info,
+        )
+    }
+
+    fn apply_pending_canonicalization(
+        &self,
+        value: BasicValueEnum<'ctx>,
+        info: ExtraInfo,
+    ) -> BasicValueEnum<'ctx> {
+        if !self.config.enable_nan_canonicalization {
+            return value;
+        }
+
+        if info.has_pending_f32_nan() {
+            if value.get_type().is_vector_type()
+                || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
+            {
+                let ty = value.get_type();
+                let value = self
+                    .builder
+                    .build_bitcast(value, self.intrinsics.f32x4_ty, "");
+                let value = self.canonicalize_nans(value);
+                self.builder.build_bitcast(value, ty, "")
+            } else {
+                self.canonicalize_nans(value)
+            }
+        } else if info.has_pending_f64_nan() {
+            if value.get_type().is_vector_type()
+                || value.get_type() == self.intrinsics.i128_ty.as_basic_type_enum()
+            {
+                let ty = value.get_type();
+                let value = self
+                    .builder
+                    .build_bitcast(value, self.intrinsics.f64x2_ty, "");
+                let value = self.canonicalize_nans(value);
+                self.builder.build_bitcast(value, ty, "")
+            } else {
+                self.canonicalize_nans(value)
+            }
+        } else {
+            value
+        }
+    }
+
+    // Replaces any NaN with the canonical QNaN, otherwise leaves the value alone.
+    fn canonicalize_nans(&self, value: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {
+        if !self.config.enable_nan_canonicalization {
+            return value;
+        }
+
+        let f_ty = value.get_type();
+        if f_ty.is_vector_type() {
+            let value = value.into_vector_value();
+            let f_ty = f_ty.into_vector_type();
+            let zero = f_ty.const_zero();
+            let nan_cmp = self
+                .builder
+                .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
+            let canonical_qnan = f_ty
+                .get_element_type()
+                .into_float_type()
+                .const_float(std::f64::NAN);
+            let canonical_qnan = self.splat_vector(canonical_qnan.as_basic_value_enum(), f_ty);
+            self.builder
+                .build_select(nan_cmp, canonical_qnan, value, "")
+                .as_basic_value_enum()
+        } else {
+            let value = value.into_float_value();
+            let f_ty = f_ty.into_float_type();
+            let zero = f_ty.const_zero();
+            let nan_cmp = self
+                .builder
+                .build_float_compare(FloatPredicate::UNO, value, zero, "nan");
+            let canonical_qnan = f_ty.const_float(std::f64::NAN);
+            self.builder
+                .build_select(nan_cmp, canonical_qnan, value, "")
+                .as_basic_value_enum()
+        }
+    }
+
+    fn quiet_nan(&self, value: BasicValueEnum<'ctx>) -> BasicValueEnum<'ctx> {
+        let intrinsic = if value
+            .get_type()
+            .eq(&self.intrinsics.f32_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f32)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f64_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f64)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f32x4_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f32x4)
+        } else if value
+            .get_type()
+            .eq(&self.intrinsics.f64x2_ty.as_basic_type_enum())
+        {
+            Some(self.intrinsics.add_f64x2)
+        } else {
+            None
+        };
+
+        match intrinsic {
+            Some(intrinsic) => self
+                .builder
+                .build_call(
+                    intrinsic,
+                    &[
+                        value.into(),
+                        value.get_type().const_zero().into(),
+                        self.intrinsics.fp_rounding_md,
+                        self.intrinsics.fp_exception_md,
+                    ],
+                    "",
+                )
+                .try_as_basic_value()
+                .left()
+                .unwrap(),
+            None => value,
+        }
+    }
+
+    // If this memory access must trap when out of bounds (i.e. it is a memory
+    // access written in the user program as opposed to one used by our VM)
+    // then mark that it can't be delete.
+    fn mark_memaccess_nodelete(
+        &mut self,
+        memory_index: MemoryIndex,
+        memaccess: InstructionValue<'ctx>,
+    ) -> Result<(), CompileError> {
+        if let MemoryCache::Static { base_ptr: _ } = self.ctx.memory(
+            memory_index,
+            self.intrinsics,
+            self.module,
+            self.memory_styles,
+        ) {
+            // The best we've got is `volatile`.
+            // TODO: convert unwrap fail to CompileError
+            memaccess.set_volatile(true).unwrap();
+        }
+        Ok(())
+    }
+
+    fn annotate_user_memaccess(
+        &mut self,
+        memory_index: MemoryIndex,
+        _memarg: &MemArg,
+        alignment: u32,
+        memaccess: InstructionValue<'ctx>,
+    ) -> Result<(), CompileError> {
+        match memaccess.get_opcode() {
+            InstructionOpcode::Load | InstructionOpcode::Store => {
+                memaccess.set_alignment(alignment).unwrap();
+            }
+            _ => {}
+        };
+        self.mark_memaccess_nodelete(memory_index, memaccess)?;
+        tbaa_label(
+            self.module,
+            self.intrinsics,
+            format!("memory {}", memory_index.as_u32()),
+            memaccess,
+        );
+        Ok(())
+    }
+
+    fn resolve_memory_ptr(
+        &mut self,
+        memory_index: MemoryIndex,
+        memarg: &MemArg,
+        ptr_ty: PointerType<'ctx>,
+        var_offset: IntValue<'ctx>,
+        value_size: usize,
+    ) -> Result<PointerValue<'ctx>, CompileError> {
+        let builder = &self.builder;
+        let intrinsics = &self.intrinsics;
+        let context = &self.context;
+        let function = &self.function;
+
+        // Compute the offset into the storage.
+        let imm_offset = intrinsics.i64_ty.const_int(memarg.offset, false);
+        let var_offset = builder.build_int_z_extend(var_offset, intrinsics.i64_ty, "");
+        let offset = builder.build_int_add(var_offset, imm_offset, "");
+
+        // Look up the memory base (as pointer) and bounds (as unsigned integer).
+        let base_ptr =
+            match self
+                .ctx
+                .memory(memory_index, intrinsics, self.module, self.memory_styles)
+            {
+                MemoryCache::Dynamic {
+                    ptr_to_base_ptr,
+                    ptr_to_current_length,
+                } => {
+                    // Bounds check it.
+                    let minimum = self.wasm_module.memories[memory_index].minimum;
+                    let value_size_v = intrinsics.i64_ty.const_int(value_size as u64, false);
+                    let ptr_in_bounds = if offset.is_const() {
+                        // When the offset is constant, if it's below the minimum
+                        // memory size, we've statically shown that it's safe.
+                        let load_offset_end = offset.const_add(value_size_v);
+                        let ptr_in_bounds = load_offset_end.const_int_compare(
+                            IntPredicate::ULE,
+                            intrinsics.i64_ty.const_int(minimum.bytes().0 as u64, false),
+                        );
+                        if ptr_in_bounds.get_zero_extended_constant() == Some(1) {
+                            Some(ptr_in_bounds)
+                        } else {
+                            None
+                        }
+                    } else {
+                        None
+                    }
+                    .unwrap_or_else(|| {
+                        let load_offset_end = builder.build_int_add(offset, value_size_v, "");
+
+                        let current_length = builder
+                            .build_load(self.intrinsics.i32_ty, ptr_to_current_length, "")
+                            .into_int_value();
+                        tbaa_label(
+                            self.module,
+                            self.intrinsics,
+                            format!("memory {} length", memory_index.as_u32()),
+                            current_length.as_instruction_value().unwrap(),
+                        );
+                        let current_length =
+                            builder.build_int_z_extend(current_length, intrinsics.i64_ty, "");
+
+                        builder.build_int_compare(
+                            IntPredicate::ULE,
+                            load_offset_end,
+                            current_length,
+                            "",
+                        )
+                    });
+                    if !ptr_in_bounds.is_constant_int()
+                        || ptr_in_bounds.get_zero_extended_constant().unwrap() != 1
+                    {
+                        // LLVM may have folded this into 'i1 true' in which case we know
+                        // the pointer is in bounds. LLVM may also have folded it into a
+                        // constant expression, not known to be either true or false yet.
+                        // If it's false, unknown-but-constant, or not-a-constant, emit a
+                        // runtime bounds check. LLVM may yet succeed at optimizing it away.
+                        let ptr_in_bounds = builder
+                            .build_call(
+                                intrinsics.expect_i1,
+                                &[
+                                    ptr_in_bounds.into(),
+                                    intrinsics.i1_ty.const_int(1, true).into(),
+                                ],
+                                "ptr_in_bounds_expect",
+                            )
+                            .try_as_basic_value()
+                            .left()
+                            .unwrap()
+                            .into_int_value();
+
+                        let in_bounds_continue_block =
+                            context.append_basic_block(*function, "in_bounds_continue_block");
+                        let not_in_bounds_block =
+                            context.append_basic_block(*function, "not_in_bounds_block");
+                        builder.build_conditional_branch(
+                            ptr_in_bounds,
+                            in_bounds_continue_block,
+                            not_in_bounds_block,
+                        );
+                        builder.position_at_end(not_in_bounds_block);
+                        builder.build_call(
+                            intrinsics.throw_trap,
+                            &[intrinsics.trap_memory_oob.into()],
+                            "throw",
+                        );
+                        builder.build_unreachable();
+                        builder.position_at_end(in_bounds_continue_block);
+                    }
+                    let ptr_to_base = builder
+                        .build_load(intrinsics.i8_ptr_ty, ptr_to_base_ptr, "")
+                        .into_pointer_value();
+                    tbaa_label(
+                        self.module,
+                        self.intrinsics,
+                        format!("memory base_ptr {}", memory_index.as_u32()),
+                        ptr_to_base.as_instruction_value().unwrap(),
+                    );
+                    ptr_to_base
+                }
+                MemoryCache::Static { base_ptr } => base_ptr,
+            };
+        let value_ptr =
+            unsafe { builder.build_gep(self.intrinsics.i8_ty, base_ptr, &[offset], "") };
+        Ok(builder
+            .build_bitcast(value_ptr, ptr_ty, "")
+            .into_pointer_value())
+    }
+
+    fn trap_if_misaligned(&self, _memarg: &MemArg, ptr: PointerValue<'ctx>, align: u8) {
+        if align <= 1 {
+            return;
+        }
+        let value = self
+            .builder
+            .build_ptr_to_int(ptr, self.intrinsics.i64_ty, "");
+        let and = self.builder.build_and(
+            value,
+            self.intrinsics.i64_ty.const_int((align - 1).into(), false),
+            "misaligncheck",
+        );
+        let aligned =
+            self.builder
+                .build_int_compare(IntPredicate::EQ, and, self.intrinsics.i64_zero, "");
+        let aligned = self
+            .builder
+            .build_call(
+                self.intrinsics.expect_i1,
+                &[
+                    aligned.into(),
+                    self.intrinsics.i1_ty.const_int(1, false).into(),
+                ],
+                "",
+            )
+            .try_as_basic_value()
+            .left()
+            .unwrap()
+            .into_int_value();
+
+        let continue_block = self
+            .context
+            .append_basic_block(self.function, "aligned_access_continue_block");
+        let not_aligned_block = self
+            .context
+            .append_basic_block(self.function, "misaligned_trap_block");
+        self.builder
+            .build_conditional_branch(aligned, continue_block, not_aligned_block);
+
+        self.builder.position_at_end(not_aligned_block);
+        self.builder.build_call(
+            self.intrinsics.throw_trap,
+            &[self.intrinsics.trap_unaligned_atomic.into()],
+            "throw",
+        );
+        self.builder.build_unreachable();
+
+        self.builder.position_at_end(continue_block);
+    }
+
+    fn finalize(&mut self, wasm_fn_type: &FunctionType) -> Result<(), CompileError> {
+        let func_type = self.function.get_type();
+
+        let results = self.state.popn_save_extra(wasm_fn_type.results().len())?;
+        let results = results
+            .into_iter()
+            .map(|(v, i)| self.apply_pending_canonicalization(v, i));
+        if wasm_fn_type.results().is_empty() {
+            self.builder.build_return(None);
+        } else if self.abi.is_sret(wasm_fn_type)? {
+            let sret = self
+                .function
+                .get_first_param()
+                .unwrap()
+                .into_pointer_value();
+            let llvm_params: Vec<_> = wasm_fn_type
+                .results()
+                .iter()
+                .map(|x| type_to_llvm(self.intrinsics, *x).unwrap())
+                .collect();
+            let mut struct_value = self
+                .context
+                .struct_type(llvm_params.as_slice(), false)
+                .get_undef();
+            for (idx, value) in results.enumerate() {
+                let value = self.builder.build_bitcast(
+                    value,
+                    type_to_llvm(self.intrinsics, wasm_fn_type.results()[idx])?,
+                    "",
+                );
+                struct_value = self
+                    .builder
+                    .build_insert_value(struct_value, value, idx as u32, "")
+                    .unwrap()
+                    .into_struct_value();
+            }
+            self.builder.build_store(sret, struct_value);
+            self.builder.build_return(None);
+        } else {
+            self.builder
+                .build_return(Some(&self.abi.pack_values_for_register_return(
+                    self.intrinsics,
+                    &self.builder,
+                    &results.collect::<Vec<_>>(),
+                    &func_type,
+                )?));
+        }
+        Ok(())
+    }
+}
+
+/*
+fn emit_stack_map<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    builder: &Builder<'ctx>,
+    local_function_id: usize,
+    target: &mut StackmapRegistry,
+    kind: StackmapEntryKind,
+    locals: &[PointerValue],
+    state: &State<'ctx>,
+    _ctx: &mut CtxType<'ctx>,
+    opcode_offset: usize,
+) {
+    let stackmap_id = target.entries.len();
+
+    let mut params = Vec::with_capacity(2 + locals.len() + state.stack.len());
+
+    params.push(
+        intrinsics
+            .i64_ty
+            .const_int(stackmap_id as u64, false)
+            .as_basic_value_enum(),
+    );
+    params.push(intrinsics.i32_ty.const_zero().as_basic_value_enum());
+
+    let locals: Vec<_> = locals.iter().map(|x| x.as_basic_value_enum()).collect();
+    let mut value_semantics: Vec<ValueSemantic> =
+        Vec::with_capacity(locals.len() + state.stack.len());
+
+    params.extend_from_slice(&locals);
+    value_semantics.extend((0..locals.len()).map(ValueSemantic::WasmLocal));
+
+    params.extend(state.stack.iter().map(|x| x.0));
+    value_semantics.extend((0..state.stack.len()).map(ValueSemantic::WasmStack));
+
+    // FIXME: Information needed for Abstract -> Runtime state transform is not fully preserved
+    // to accelerate compilation and reduce memory usage. Check this again when we try to support
+    // "full" LLVM OSR.
+
+    assert_eq!(params.len(), value_semantics.len() + 2);
+
+    builder.build_call(intrinsics.experimental_stackmap, &params, "");
+
+    target.entries.push(StackmapEntry {
+        kind,
+        local_function_id,
+        local_count: locals.len(),
+        stack_count: state.stack.len(),
+        opcode_offset,
+        value_semantics,
+        is_start: true,
+    });
+}
+
+fn finalize_opcode_stack_map<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    builder: &Builder<'ctx>,
+    local_function_id: usize,
+    target: &mut StackmapRegistry,
+    kind: StackmapEntryKind,
+    opcode_offset: usize,
+) {
+    let stackmap_id = target.entries.len();
+    builder.build_call(
+        intrinsics.experimental_stackmap,
+        &[
+            intrinsics
+                .i64_ty
+                .const_int(stackmap_id as u64, false)
+                .as_basic_value_enum(),
+            intrinsics.i32_ty.const_zero().as_basic_value_enum(),
+        ],
+        "opcode_stack_map_end",
+    );
+    target.entries.push(StackmapEntry {
+        kind,
+        local_function_id,
+        local_count: 0,
+        stack_count: 0,
+        opcode_offset,
+        value_semantics: vec![],
+        is_start: false,
+    });
+}
+ */
+
+pub struct LLVMFunctionCodeGenerator<'ctx, 'a> {
+    context: &'ctx Context,
+    builder: Builder<'ctx>,
+    alloca_builder: Builder<'ctx>,
+    intrinsics: &'a Intrinsics<'ctx>,
+    state: State<'ctx>,
+    function: FunctionValue<'ctx>,
+    locals: Vec<(BasicTypeEnum<'ctx>, PointerValue<'ctx>)>, // Contains params and locals
+    ctx: CtxType<'ctx, 'a>,
+    unreachable_depth: usize,
+    memory_styles: &'a PrimaryMap<MemoryIndex, MemoryStyle>,
+    _table_styles: &'a PrimaryMap<TableIndex, TableStyle>,
+
+    // This is support for stackmaps:
+    /*
+    stackmaps: Rc<RefCell<StackmapRegistry>>,
+    index: usize,
+    opcode_offset: usize,
+    track_state: bool,
+    */
+    module: &'a Module<'ctx>,
+    module_translation: &'a ModuleTranslationState,
+    wasm_module: &'a ModuleInfo,
+    symbol_registry: &'a dyn SymbolRegistry,
+    abi: &'a dyn Abi,
+    config: &'a LLVM,
+}
+
+impl<'ctx, 'a> LLVMFunctionCodeGenerator<'ctx, 'a> {
+    fn translate_operator(&mut self, op: Operator, _source_loc: u32) -> Result<(), CompileError> {
+        // TODO: remove this vmctx by moving everything into CtxType. Values
+        // computed off vmctx usually benefit from caching.
+        let vmctx = &self.ctx.basic().into_pointer_value();
+
+        //let opcode_offset: Option<usize> = None;
+
+        if !self.state.reachable {
+            match op {
+                Operator::Block { blockty: _ }
+                | Operator::Loop { blockty: _ }
+                | Operator::If { blockty: _ } => {
+                    self.unreachable_depth += 1;
+                    return Ok(());
+                }
+                Operator::Else => {
+                    if self.unreachable_depth != 0 {
+                        return Ok(());
+                    }
+                }
+                Operator::End => {
+                    if self.unreachable_depth != 0 {
+                        self.unreachable_depth -= 1;
+                        return Ok(());
+                    }
+                }
+                _ => {
+                    return Ok(());
+                }
+            }
+        }
+
+        match op {
+            /***************************
+             * Control Flow instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#control-flow-instructions
+             ***************************/
+            Operator::Block { blockty } => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let end_block = self.context.append_basic_block(self.function, "end");
+                self.builder.position_at_end(end_block);
+
+                let phis: SmallVec<[PhiValue<'ctx>; 1]> = self
+                    .module_translation
+                    .blocktype_params_results(&blockty)?
+                    .1
+                    .iter()
+                    .map(|&wp_ty| {
+                        wptype_to_type(wp_ty)
+                            .map_err(to_compile_error)
+                            .and_then(|wasm_ty| {
+                                type_to_llvm(self.intrinsics, wasm_ty)
+                                    .map(|ty| self.builder.build_phi(ty, ""))
+                            })
+                    })
+                    .collect::<Result<_, _>>()?;
+
+                self.state.push_block(end_block, phis);
+                self.builder.position_at_end(current_block);
+            }
+            Operator::Loop { blockty } => {
+                let loop_body = self.context.append_basic_block(self.function, "loop_body");
+                let loop_next = self.context.append_basic_block(self.function, "loop_outer");
+                let pre_loop_block = self.builder.get_insert_block().unwrap();
+
+                self.builder.build_unconditional_branch(loop_body);
+
+                self.builder.position_at_end(loop_next);
+                let blocktypes = self.module_translation.blocktype_params_results(&blockty)?;
+                let phis = blocktypes
+                    .1
+                    .iter()
+                    .map(|&wp_ty| {
+                        wptype_to_type(wp_ty)
+                            .map_err(to_compile_error)
+                            .and_then(|wasm_ty| {
+                                type_to_llvm(self.intrinsics, wasm_ty)
+                                    .map(|ty| self.builder.build_phi(ty, ""))
+                            })
+                    })
+                    .collect::<Result<_, _>>()?;
+                self.builder.position_at_end(loop_body);
+                let loop_phis: SmallVec<[PhiValue<'ctx>; 1]> = blocktypes
+                    .0
+                    .iter()
+                    .map(|&wp_ty| {
+                        wptype_to_type(wp_ty)
+                            .map_err(to_compile_error)
+                            .and_then(|wasm_ty| {
+                                type_to_llvm(self.intrinsics, wasm_ty)
+                                    .map(|ty| self.builder.build_phi(ty, ""))
+                            })
+                    })
+                    .collect::<Result<_, _>>()?;
+                for phi in loop_phis.iter().rev() {
+                    let (value, info) = self.state.pop1_extra()?;
+                    let value = self.apply_pending_canonicalization(value, info);
+                    phi.add_incoming(&[(&value, pre_loop_block)]);
+                }
+                for phi in &loop_phis {
+                    self.state.push1(phi.as_basic_value());
+                }
+
+                /*
+                if self.track_state {
+                    if let Some(offset) = opcode_offset {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        emit_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Loop,
+                            &self.self.locals,
+                            state,
+                            ctx,
+                            offset,
+                        );
+                        let signal_mem = ctx.signal_mem();
+                        let iv = self.builder
+                            .build_store(signal_mem, self.context.i8_type().const_zero());
+                        // Any 'store' can be made volatile.
+                        iv.set_volatile(true).unwrap();
+                        finalize_opcode_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Loop,
+                            offset,
+                        );
+                    }
+                }
+                */
+
+                self.state.push_loop(loop_body, loop_next, loop_phis, phis);
+            }
+            Operator::Br { relative_depth } => {
+                let frame = self.state.frame_at_depth(relative_depth)?;
+
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let phis = if frame.is_loop() {
+                    frame.loop_body_phis()
+                } else {
+                    frame.phis()
+                };
+
+                let len = phis.len();
+                let values = self.state.peekn_extra(len)?;
+                let values = values
+                    .iter()
+                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info));
+
+                // For each result of the block we're branching to,
+                // pop a value off the value stack and load it into
+                // the corresponding phi.
+                for (phi, value) in phis.iter().zip(values) {
+                    phi.add_incoming(&[(&value, current_block)]);
+                }
+
+                self.builder.build_unconditional_branch(*frame.br_dest());
+
+                self.state.popn(len)?;
+                self.state.reachable = false;
+            }
+            Operator::BrIf { relative_depth } => {
+                let cond = self.state.pop1()?;
+                let frame = self.state.frame_at_depth(relative_depth)?;
+
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let phis = if frame.is_loop() {
+                    frame.loop_body_phis()
+                } else {
+                    frame.phis()
+                };
+
+                let param_stack = self.state.peekn_extra(phis.len())?;
+                let param_stack = param_stack
+                    .iter()
+                    .map(|(v, info)| self.apply_pending_canonicalization(*v, *info));
+
+                for (phi, value) in phis.iter().zip(param_stack) {
+                    phi.add_incoming(&[(&value, current_block)]);
+                }
+
+                let else_block = self.context.append_basic_block(self.function, "else");
+
+                let cond_value = self.builder.build_int_compare(
+                    IntPredicate::NE,
+                    cond.into_int_value(),
+                    self.intrinsics.i32_zero,
+                    "",
+                );
+                self.builder
+                    .build_conditional_branch(cond_value, *frame.br_dest(), else_block);
+                self.builder.position_at_end(else_block);
+            }
+            Operator::BrTable { ref targets } => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let index = self.state.pop1()?;
+
+                let default_frame = self.state.frame_at_depth(targets.default())?;
+
+                let phis = if default_frame.is_loop() {
+                    default_frame.loop_body_phis()
+                } else {
+                    default_frame.phis()
+                };
+                let args = self.state.peekn(phis.len())?;
+
+                for (phi, value) in phis.iter().zip(args.iter()) {
+                    phi.add_incoming(&[(value, current_block)]);
+                }
+
+                let cases: Vec<_> = targets
+                    .targets()
+                    .enumerate()
+                    .map(|(case_index, depth)| {
+                        let depth = depth.map_err(from_binaryreadererror_wasmerror)?;
+                        let frame_result: Result<&ControlFrame, CompileError> =
+                            self.state.frame_at_depth(depth);
+                        let frame = match frame_result {
+                            Ok(v) => v,
+                            Err(e) => return Err(e),
+                        };
+                        let case_index_literal =
+                            self.context.i32_type().const_int(case_index as u64, false);
+                        let phis = if frame.is_loop() {
+                            frame.loop_body_phis()
+                        } else {
+                            frame.phis()
+                        };
+                        for (phi, value) in phis.iter().zip(args.iter()) {
+                            phi.add_incoming(&[(value, current_block)]);
+                        }
+
+                        Ok((case_index_literal, *frame.br_dest()))
+                    })
+                    .collect::<Result<_, _>>()?;
+
+                self.builder.build_switch(
+                    index.into_int_value(),
+                    *default_frame.br_dest(),
+                    &cases[..],
+                );
+
+                let args_len = args.len();
+                self.state.popn(args_len)?;
+                self.state.reachable = false;
+            }
+            Operator::If { blockty } => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+                let if_then_block = self.context.append_basic_block(self.function, "if_then");
+                let if_else_block = self.context.append_basic_block(self.function, "if_else");
+                let end_block = self.context.append_basic_block(self.function, "if_end");
+
+                let end_phis = {
+                    self.builder.position_at_end(end_block);
+
+                    let phis = self
+                        .module_translation
+                        .blocktype_params_results(&blockty)?
+                        .1
+                        .iter()
+                        .map(|&wp_ty| {
+                            wptype_to_type(wp_ty)
+                                .map_err(to_compile_error)
+                                .and_then(|wasm_ty| {
+                                    type_to_llvm(self.intrinsics, wasm_ty)
+                                        .map(|ty| self.builder.build_phi(ty, ""))
+                                })
+                        })
+                        .collect::<Result<_, _>>()?;
+
+                    self.builder.position_at_end(current_block);
+                    phis
+                };
+
+                let cond = self.state.pop1()?;
+
+                let cond_value = self.builder.build_int_compare(
+                    IntPredicate::NE,
+                    cond.into_int_value(),
+                    self.intrinsics.i32_zero,
+                    "",
+                );
+
+                self.builder
+                    .build_conditional_branch(cond_value, if_then_block, if_else_block);
+                self.builder.position_at_end(if_else_block);
+                let block_param_types = self
+                    .module_translation
+                    .blocktype_params_results(&blockty)?
+                    .0
+                    .iter()
+                    .map(|&wp_ty| {
+                        wptype_to_type(wp_ty)
+                            .map_err(to_compile_error)
+                            .and_then(|wasm_ty| type_to_llvm(self.intrinsics, wasm_ty))
+                    })
+                    .collect::<Result<Vec<_>, _>>()?;
+                let else_phis: SmallVec<[PhiValue<'ctx>; 1]> = block_param_types
+                    .iter()
+                    .map(|&ty| self.builder.build_phi(ty, ""))
+                    .collect();
+                self.builder.position_at_end(if_then_block);
+                let then_phis: SmallVec<[PhiValue<'ctx>; 1]> = block_param_types
+                    .iter()
+                    .map(|&ty| self.builder.build_phi(ty, ""))
+                    .collect();
+                for (else_phi, then_phi) in else_phis.iter().rev().zip(then_phis.iter().rev()) {
+                    let (value, info) = self.state.pop1_extra()?;
+                    let value = self.apply_pending_canonicalization(value, info);
+                    else_phi.add_incoming(&[(&value, current_block)]);
+                    then_phi.add_incoming(&[(&value, current_block)]);
+                }
+                for phi in then_phis.iter() {
+                    self.state.push1(phi.as_basic_value());
+                }
+
+                self.state.push_if(
+                    if_then_block,
+                    if_else_block,
+                    end_block,
+                    then_phis,
+                    else_phis,
+                    end_phis,
+                );
+            }
+            Operator::Else => {
+                if self.state.reachable {
+                    let frame = self.state.frame_at_depth(0)?;
+                    let current_block = self.builder.get_insert_block().ok_or_else(|| {
+                        CompileError::Codegen("not currently in a block".to_string())
+                    })?;
+
+                    for phi in frame.phis().to_vec().iter().rev() {
+                        let (value, info) = self.state.pop1_extra()?;
+                        let value = self.apply_pending_canonicalization(value, info);
+                        phi.add_incoming(&[(&value, current_block)])
+                    }
+
+                    let frame = self.state.frame_at_depth(0)?;
+                    self.builder.build_unconditional_branch(*frame.code_after());
+                }
+
+                let (if_else_block, if_else_state) = if let ControlFrame::IfElse {
+                    if_else,
+                    if_else_state,
+                    ..
+                } = self.state.frame_at_depth_mut(0)?
+                {
+                    (if_else, if_else_state)
+                } else {
+                    unreachable!()
+                };
+
+                *if_else_state = IfElseState::Else;
+
+                self.builder.position_at_end(*if_else_block);
+                self.state.reachable = true;
+
+                if let ControlFrame::IfElse { else_phis, .. } = self.state.frame_at_depth(0)? {
+                    // Push our own 'else' phi nodes to the stack.
+                    for phi in else_phis.clone().iter() {
+                        self.state.push1(phi.as_basic_value());
+                    }
+                };
+            }
+
+            Operator::End => {
+                let frame = self.state.pop_frame()?;
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                if self.state.reachable {
+                    for phi in frame.phis().iter().rev() {
+                        let (value, info) = self.state.pop1_extra()?;
+                        let value = self.apply_pending_canonicalization(value, info);
+                        phi.add_incoming(&[(&value, current_block)]);
+                    }
+
+                    self.builder.build_unconditional_branch(*frame.code_after());
+                }
+
+                if let ControlFrame::IfElse {
+                    if_else,
+                    next,
+                    if_else_state: IfElseState::If,
+                    else_phis,
+                    ..
+                } = &frame
+                {
+                    for (phi, else_phi) in frame.phis().iter().zip(else_phis.iter()) {
+                        phi.add_incoming(&[(&else_phi.as_basic_value(), *if_else)]);
+                    }
+                    self.builder.position_at_end(*if_else);
+                    self.builder.build_unconditional_branch(*next);
+                }
+
+                self.builder.position_at_end(*frame.code_after());
+                self.state.reset_stack(&frame);
+
+                self.state.reachable = true;
+
+                // Push each phi value to the value stack.
+                for phi in frame.phis() {
+                    if phi.count_incoming() != 0 {
+                        self.state.push1(phi.as_basic_value());
+                    } else {
+                        let basic_ty = phi.as_basic_value().get_type();
+                        let placeholder_value = basic_ty.const_zero();
+                        self.state.push1(placeholder_value);
+                        phi.as_instruction().erase_from_basic_block();
+                    }
+                }
+            }
+            Operator::Return => {
+                let current_block = self
+                    .builder
+                    .get_insert_block()
+                    .ok_or_else(|| CompileError::Codegen("not currently in a block".to_string()))?;
+
+                let frame = self.state.outermost_frame()?;
+                for phi in frame.phis().to_vec().iter().rev() {
+                    let (arg, info) = self.state.pop1_extra()?;
+                    let arg = self.apply_pending_canonicalization(arg, info);
+                    phi.add_incoming(&[(&arg, current_block)]);
+                }
+                let frame = self.state.outermost_frame()?;
+                self.builder.build_unconditional_branch(*frame.br_dest());
+
+                self.state.reachable = false;
+            }
+
+            Operator::Unreachable => {
+                // Emit an unreachable instruction.
+                // If llvm cannot prove that this is never reached,
+                // it will emit a `ud2` instruction on x86_64 arches.
+
+                // Comment out this `if` block to allow spectests to pass.
+                // TODO: fix this
+                /*
+                if let Some(offset) = opcode_offset {
+                    if self.track_state {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        emit_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Trappable,
+                            &self.self.locals,
+                            state,
+                            ctx,
+                            offset,
+                        );
+                        self.builder.build_call(self.intrinsics.trap, &[], "trap");
+                        finalize_opcode_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Trappable,
+                            offset,
+                        );
+                    }
+                }
+                */
+
+                self.builder.build_call(
+                    self.intrinsics.throw_trap,
+                    &[self.intrinsics.trap_unreachable.into()],
+                    "throw",
+                );
+                self.builder.build_unreachable();
+
+                self.state.reachable = false;
+            }
+
+            /***************************
+             * Basic instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#basic-instructions
+             ***************************/
+            Operator::Nop => {
+                // Do nothing.
+            }
+            Operator::Drop => {
+                self.state.pop1()?;
+            }
+
+            // Generate const values.
+            Operator::I32Const { value } => {
+                let i = self.intrinsics.i32_ty.const_int(value as u64, false);
+                let info = if is_f32_arithmetic(value as u32) {
+                    ExtraInfo::arithmetic_f32()
+                } else {
+                    Default::default()
+                };
+                self.state.push1_extra(i, info);
+            }
+            Operator::I64Const { value } => {
+                let i = self.intrinsics.i64_ty.const_int(value as u64, false);
+                let info = if is_f64_arithmetic(value as u64) {
+                    ExtraInfo::arithmetic_f64()
+                } else {
+                    Default::default()
+                };
+                self.state.push1_extra(i, info);
+            }
+            Operator::F32Const { value } => {
+                let bits = self.intrinsics.i32_ty.const_int(value.bits() as u64, false);
+                let info = if is_f32_arithmetic(value.bits()) {
+                    ExtraInfo::arithmetic_f32()
+                } else {
+                    Default::default()
+                };
+                let f = self
+                    .builder
+                    .build_bitcast(bits, self.intrinsics.f32_ty, "f");
+                self.state.push1_extra(f, info);
+            }
+            Operator::F64Const { value } => {
+                let bits = self.intrinsics.i64_ty.const_int(value.bits(), false);
+                let info = if is_f64_arithmetic(value.bits()) {
+                    ExtraInfo::arithmetic_f64()
+                } else {
+                    Default::default()
+                };
+                let f = self
+                    .builder
+                    .build_bitcast(bits, self.intrinsics.f64_ty, "f");
+                self.state.push1_extra(f, info);
+            }
+            Operator::V128Const { value } => {
+                let mut hi: [u8; 8] = Default::default();
+                let mut lo: [u8; 8] = Default::default();
+                hi.copy_from_slice(&value.bytes()[0..8]);
+                lo.copy_from_slice(&value.bytes()[8..16]);
+                let packed = [u64::from_le_bytes(hi), u64::from_le_bytes(lo)];
+                let i = self
+                    .intrinsics
+                    .i128_ty
+                    .const_int_arbitrary_precision(&packed);
+                let mut quad1: [u8; 4] = Default::default();
+                let mut quad2: [u8; 4] = Default::default();
+                let mut quad3: [u8; 4] = Default::default();
+                let mut quad4: [u8; 4] = Default::default();
+                quad1.copy_from_slice(&value.bytes()[0..4]);
+                quad2.copy_from_slice(&value.bytes()[4..8]);
+                quad3.copy_from_slice(&value.bytes()[8..12]);
+                quad4.copy_from_slice(&value.bytes()[12..16]);
+                let mut info: ExtraInfo = Default::default();
+                if is_f32_arithmetic(u32::from_le_bytes(quad1))
+                    && is_f32_arithmetic(u32::from_le_bytes(quad2))
+                    && is_f32_arithmetic(u32::from_le_bytes(quad3))
+                    && is_f32_arithmetic(u32::from_le_bytes(quad4))
+                {
+                    info |= ExtraInfo::arithmetic_f32();
+                }
+                if is_f64_arithmetic(packed[0]) && is_f64_arithmetic(packed[1]) {
+                    info |= ExtraInfo::arithmetic_f64();
+                }
+                self.state.push1_extra(i, info);
+            }
+
+            Operator::I8x16Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = v.into_int_value();
+                let v = self
+                    .builder
+                    .build_int_truncate(v, self.intrinsics.i8_ty, "");
+                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::I16x8Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = v.into_int_value();
+                let v = self
+                    .builder
+                    .build_int_truncate(v, self.intrinsics.i16_ty, "");
+                let res = self.splat_vector(v.as_basic_value_enum(), self.intrinsics.i16x8_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::I32x4Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self.splat_vector(v, self.intrinsics.i32x4_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::I64x2Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self.splat_vector(v, self.intrinsics.i64x2_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::F32x4Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self.splat_vector(v, self.intrinsics.f32x4_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The spec is unclear, we interpret splat as preserving NaN
+                // payload bits.
+                self.state.push1_extra(res, i);
+            }
+            Operator::F64x2Splat => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self.splat_vector(v, self.intrinsics.f64x2_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The spec is unclear, we interpret splat as preserving NaN
+                // payload bits.
+                self.state.push1_extra(res, i);
+            }
+
+            // Operate on self.locals.
+            Operator::LocalGet { local_index } => {
+                let (type_value, pointer_value) = self.locals[local_index as usize];
+                let v = self.builder.build_load(type_value, pointer_value, "");
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("local {}", local_index),
+                    v.as_instruction_value().unwrap(),
+                );
+                self.state.push1(v);
+            }
+            Operator::LocalSet { local_index } => {
+                let pointer_value = self.locals[local_index as usize].1;
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let store = self.builder.build_store(pointer_value, v);
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("local {}", local_index),
+                    store,
+                );
+            }
+            Operator::LocalTee { local_index } => {
+                let pointer_value = self.locals[local_index as usize].1;
+                let (v, i) = self.state.peek1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let store = self.builder.build_store(pointer_value, v);
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("local {}", local_index),
+                    store,
+                );
+            }
+
+            Operator::GlobalGet { global_index } => {
+                let global_index = GlobalIndex::from_u32(global_index);
+                match self
+                    .ctx
+                    .global(global_index, self.intrinsics, self.module)?
+                {
+                    GlobalCache::Const { value } => {
+                        self.state.push1(*value);
+                    }
+                    GlobalCache::Mut {
+                        ptr_to_value,
+                        value_type,
+                    } => {
+                        let value = self.builder.build_load(*value_type, *ptr_to_value, "");
+                        tbaa_label(
+                            self.module,
+                            self.intrinsics,
+                            format!("global {}", global_index.as_u32()),
+                            value.as_instruction_value().unwrap(),
+                        );
+                        self.state.push1(value);
+                    }
+                }
+            }
+            Operator::GlobalSet { global_index } => {
+                let global_index = GlobalIndex::from_u32(global_index);
+                match self
+                    .ctx
+                    .global(global_index, self.intrinsics, self.module)?
+                {
+                    GlobalCache::Const { value: _ } => {
+                        return Err(CompileError::Codegen(format!(
+                            "global.set on immutable global index {}",
+                            global_index.as_u32()
+                        )))
+                    }
+                    GlobalCache::Mut { ptr_to_value, .. } => {
+                        let ptr_to_value = *ptr_to_value;
+                        let (value, info) = self.state.pop1_extra()?;
+                        let value = self.apply_pending_canonicalization(value, info);
+                        let store = self.builder.build_store(ptr_to_value, value);
+                        tbaa_label(
+                            self.module,
+                            self.intrinsics,
+                            format!("global {}", global_index.as_u32()),
+                            store,
+                        );
+                    }
+                }
+            }
+
+            // `TypedSelect` must be used for extern refs so ref counting should
+            // be done with TypedSelect. But otherwise they're the same.
+            Operator::TypedSelect { .. } | Operator::Select => {
+                let ((v1, i1), (v2, i2), (cond, _)) = self.state.pop3_extra()?;
+                // We don't bother canonicalizing 'cond' here because we only
+                // compare it to zero, and that's invariant under
+                // canonicalization.
+
+                // If the pending bits of v1 and v2 are the same, we can pass
+                // them along to the result. Otherwise, apply pending
+                // canonicalizations now.
+                let (v1, i1, v2, i2) = if i1.has_pending_f32_nan() != i2.has_pending_f32_nan()
+                    || i1.has_pending_f64_nan() != i2.has_pending_f64_nan()
+                {
+                    (
+                        self.apply_pending_canonicalization(v1, i1),
+                        i1.strip_pending(),
+                        self.apply_pending_canonicalization(v2, i2),
+                        i2.strip_pending(),
+                    )
+                } else {
+                    (v1, i1, v2, i2)
+                };
+                let cond_value = self.builder.build_int_compare(
+                    IntPredicate::NE,
+                    cond.into_int_value(),
+                    self.intrinsics.i32_zero,
+                    "",
+                );
+                let res = self.builder.build_select(cond_value, v1, v2, "");
+                let info = {
+                    let mut info = i1.strip_pending() & i2.strip_pending();
+                    if i1.has_pending_f32_nan() {
+                        debug_assert!(i2.has_pending_f32_nan());
+                        info |= ExtraInfo::pending_f32_nan();
+                    }
+                    if i1.has_pending_f64_nan() {
+                        debug_assert!(i2.has_pending_f64_nan());
+                        info |= ExtraInfo::pending_f64_nan();
+                    }
+                    info
+                };
+                self.state.push1_extra(res, info);
+            }
+            Operator::Call { function_index } => {
+                let func_index = FunctionIndex::from_u32(function_index);
+                let sigindex = &self.wasm_module.functions[func_index];
+                let func_type = &self.wasm_module.signatures[*sigindex];
+
+                let FunctionCache {
+                    func,
+                    llvm_func_type,
+                    vmctx: callee_vmctx,
+                    attrs,
+                } = if let Some(local_func_index) = self.wasm_module.local_func_index(func_index) {
+                    let function_name = self
+                        .symbol_registry
+                        .symbol_to_name(Symbol::LocalFunction(local_func_index));
+                    self.ctx.local_func(
+                        local_func_index,
+                        func_index,
+                        self.intrinsics,
+                        self.module,
+                        self.context,
+                        func_type,
+                        &function_name,
+                    )?
+                } else {
+                    self.ctx
+                        .func(func_index, self.intrinsics, self.context, func_type)?
+                };
+                let llvm_func_type = *llvm_func_type;
+                let func = *func;
+                let callee_vmctx = *callee_vmctx;
+                let attrs = attrs.clone();
+
+                /*
+                let func_ptr = self.llvm.functions.borrow_mut()[&func_index];
+
+                (params, func_ptr.as_global_value().as_pointer_value())
+                */
+                let params = self.state.popn_save_extra(func_type.params().len())?;
+
+                // Apply pending canonicalizations.
+                let params = params
+                    .iter()
+                    .zip(func_type.params().iter())
+                    .map(|((v, info), wasm_ty)| match wasm_ty {
+                        Type::F32 => self.builder.build_bitcast(
+                            self.apply_pending_canonicalization(*v, *info),
+                            self.intrinsics.f32_ty,
+                            "",
+                        ),
+                        Type::F64 => self.builder.build_bitcast(
+                            self.apply_pending_canonicalization(*v, *info),
+                            self.intrinsics.f64_ty,
+                            "",
+                        ),
+                        Type::V128 => self.apply_pending_canonicalization(*v, *info),
+                        _ => *v,
+                    })
+                    .collect::<Vec<_>>();
+
+                let params = self.abi.args_to_call(
+                    &self.alloca_builder,
+                    func_type,
+                    &llvm_func_type,
+                    callee_vmctx.into_pointer_value(),
+                    params.as_slice(),
+                    self.intrinsics,
+                );
+
+                /*
+                if self.track_state {
+                    if let Some(offset) = opcode_offset {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        emit_stack_map(
+                            &info,
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Call,
+                            &self.locals,
+                            state,
+                            ctx,
+                            offset,
+                        )
+                    }
+                }
+                */
+                let call_site = self.builder.build_indirect_call(
+                    llvm_func_type,
+                    func,
+                    params
+                        .iter()
+                        .copied()
+                        .map(Into::into)
+                        .collect::<Vec<BasicMetadataValueEnum>>()
+                        .as_slice(),
+                    "",
+                );
+                for (attr, attr_loc) in attrs {
+                    call_site.add_attribute(attr_loc, attr);
+                }
+                /*
+                if self.track_state {
+                    if let Some(offset) = opcode_offset {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        finalize_opcode_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Call,
+                            offset,
+                        )
+                    }
+                }
+                */
+
+                self.abi
+                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)
+                    .iter()
+                    .for_each(|ret| self.state.push1(*ret));
+            }
+            Operator::CallIndirect {
+                type_index,
+                table_index,
+                table_byte: _,
+            } => {
+                let sigindex = SignatureIndex::from_u32(type_index);
+                let func_type = &self.wasm_module.signatures[sigindex];
+                let expected_dynamic_sigindex =
+                    self.ctx
+                        .dynamic_sigindex(sigindex, self.intrinsics, self.module);
+                let (table_base, table_bound) = self.ctx.table(
+                    TableIndex::from_u32(table_index),
+                    self.intrinsics,
+                    self.module,
+                );
+                let func_index = self.state.pop1()?.into_int_value();
+
+                let truncated_table_bounds = self.builder.build_int_truncate(
+                    table_bound,
+                    self.intrinsics.i32_ty,
+                    "truncated_table_bounds",
+                );
+
+                // First, check if the index is outside of the table bounds.
+                let index_in_bounds = self.builder.build_int_compare(
+                    IntPredicate::ULT,
+                    func_index,
+                    truncated_table_bounds,
+                    "index_in_bounds",
+                );
+
+                let index_in_bounds = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.expect_i1,
+                        &[
+                            index_in_bounds.into(),
+                            self.intrinsics.i1_ty.const_int(1, false).into(),
+                        ],
+                        "index_in_bounds_expect",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let in_bounds_continue_block = self
+                    .context
+                    .append_basic_block(self.function, "in_bounds_continue_block");
+                let not_in_bounds_block = self
+                    .context
+                    .append_basic_block(self.function, "not_in_bounds_block");
+                self.builder.build_conditional_branch(
+                    index_in_bounds,
+                    in_bounds_continue_block,
+                    not_in_bounds_block,
+                );
+                self.builder.position_at_end(not_in_bounds_block);
+                self.builder.build_call(
+                    self.intrinsics.throw_trap,
+                    &[self.intrinsics.trap_table_access_oob.into()],
+                    "throw",
+                );
+                self.builder.build_unreachable();
+                self.builder.position_at_end(in_bounds_continue_block);
+
+                // We assume the table has the `funcref` (pointer to `anyfunc`)
+                // element type.
+                let casted_table_base = self.builder.build_pointer_cast(
+                    table_base,
+                    self.intrinsics.funcref_ty.ptr_type(AddressSpace::default()),
+                    "casted_table_base",
+                );
+
+                let funcref_ptr = unsafe {
+                    self.builder.build_in_bounds_gep(
+                        self.intrinsics.funcref_ty,
+                        casted_table_base,
+                        &[func_index],
+                        "funcref_ptr",
+                    )
+                };
+
+                // a funcref (pointer to `anyfunc`)
+                let anyfunc_struct_ptr = self
+                    .builder
+                    .build_load(
+                        self.intrinsics.funcref_ty,
+                        funcref_ptr,
+                        "anyfunc_struct_ptr",
+                    )
+                    .into_pointer_value();
+
+                // trap if we're trying to call a null funcref
+                {
+                    let funcref_not_null = self
+                        .builder
+                        .build_is_not_null(anyfunc_struct_ptr, "null funcref check");
+
+                    let funcref_continue_deref_block = self
+                        .context
+                        .append_basic_block(self.function, "funcref_continue deref_block");
+
+                    let funcref_is_null_block = self
+                        .context
+                        .append_basic_block(self.function, "funcref_is_null_block");
+                    self.builder.build_conditional_branch(
+                        funcref_not_null,
+                        funcref_continue_deref_block,
+                        funcref_is_null_block,
+                    );
+                    self.builder.position_at_end(funcref_is_null_block);
+                    self.builder.build_call(
+                        self.intrinsics.throw_trap,
+                        &[self.intrinsics.trap_call_indirect_null.into()],
+                        "throw",
+                    );
+                    self.builder.build_unreachable();
+                    self.builder.position_at_end(funcref_continue_deref_block);
+                }
+
+                // Load things from the anyfunc data structure.
+                let func_ptr_ptr = self
+                    .builder
+                    .build_struct_gep(
+                        self.intrinsics.anyfunc_ty,
+                        anyfunc_struct_ptr,
+                        0,
+                        "func_ptr_ptr",
+                    )
+                    .unwrap();
+                let sigindex_ptr = self
+                    .builder
+                    .build_struct_gep(
+                        self.intrinsics.anyfunc_ty,
+                        anyfunc_struct_ptr,
+                        1,
+                        "sigindex_ptr",
+                    )
+                    .unwrap();
+                let ctx_ptr_ptr = self
+                    .builder
+                    .build_struct_gep(
+                        self.intrinsics.anyfunc_ty,
+                        anyfunc_struct_ptr,
+                        2,
+                        "ctx_ptr_ptr",
+                    )
+                    .unwrap();
+                let (func_ptr, found_dynamic_sigindex, ctx_ptr) = (
+                    self.builder
+                        .build_load(self.intrinsics.i8_ptr_ty, func_ptr_ptr, "func_ptr")
+                        .into_pointer_value(),
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, sigindex_ptr, "sigindex")
+                        .into_int_value(),
+                    self.builder
+                        .build_load(self.intrinsics.ctx_ptr_ty, ctx_ptr_ptr, "ctx_ptr"),
+                );
+
+                // Next, check if the table element is initialized.
+
+                // TODO: we may not need this check anymore
+                let elem_initialized = self.builder.build_is_not_null(func_ptr, "");
+
+                // Next, check if the signature id is correct.
+
+                let sigindices_equal = self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    expected_dynamic_sigindex,
+                    found_dynamic_sigindex,
+                    "sigindices_equal",
+                );
+
+                let initialized_and_sigindices_match =
+                    self.builder
+                        .build_and(elem_initialized, sigindices_equal, "");
+
+                // Tell llvm that `expected_dynamic_sigindex` should equal `found_dynamic_sigindex`.
+                let initialized_and_sigindices_match = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.expect_i1,
+                        &[
+                            initialized_and_sigindices_match.into(),
+                            self.intrinsics.i1_ty.const_int(1, false).into(),
+                        ],
+                        "initialized_and_sigindices_match_expect",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let continue_block = self
+                    .context
+                    .append_basic_block(self.function, "continue_block");
+                let sigindices_notequal_block = self
+                    .context
+                    .append_basic_block(self.function, "sigindices_notequal_block");
+                self.builder.build_conditional_branch(
+                    initialized_and_sigindices_match,
+                    continue_block,
+                    sigindices_notequal_block,
+                );
+
+                self.builder.position_at_end(sigindices_notequal_block);
+                let trap_code = self.builder.build_select(
+                    elem_initialized,
+                    self.intrinsics.trap_call_indirect_sig,
+                    self.intrinsics.trap_call_indirect_null,
+                    "",
+                );
+                self.builder
+                    .build_call(self.intrinsics.throw_trap, &[trap_code.into()], "throw");
+                self.builder.build_unreachable();
+                self.builder.position_at_end(continue_block);
+
+                let (llvm_func_type, llvm_func_attrs) = self.abi.func_type_to_llvm(
+                    self.context,
+                    self.intrinsics,
+                    Some(self.ctx.get_offsets()),
+                    func_type,
+                )?;
+
+                let params = self.state.popn_save_extra(func_type.params().len())?;
+
+                // Apply pending canonicalizations.
+                let params =
+                    params
+                        .iter()
+                        .zip(func_type.params().iter())
+                        .map(|((v, info), wasm_ty)| match wasm_ty {
+                            Type::F32 => self.builder.build_bitcast(
+                                self.apply_pending_canonicalization(*v, *info),
+                                self.intrinsics.f32_ty,
+                                "",
+                            ),
+                            Type::F64 => self.builder.build_bitcast(
+                                self.apply_pending_canonicalization(*v, *info),
+                                self.intrinsics.f64_ty,
+                                "",
+                            ),
+                            Type::V128 => self.apply_pending_canonicalization(*v, *info),
+                            _ => *v,
+                        });
+
+                let params = self.abi.args_to_call(
+                    &self.alloca_builder,
+                    func_type,
+                    &llvm_func_type,
+                    ctx_ptr.into_pointer_value(),
+                    params.collect::<Vec<_>>().as_slice(),
+                    self.intrinsics,
+                );
+
+                let typed_func_ptr = self.builder.build_pointer_cast(
+                    func_ptr,
+                    llvm_func_type.ptr_type(AddressSpace::default()),
+                    "typed_func_ptr",
+                );
+
+                /*
+                if self.track_state {
+                    if let Some(offset) = opcode_offset {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        emit_stack_map(
+                            &info,
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Call,
+                            &self.locals,
+                            state,
+                            ctx,
+                            offset,
+                        )
+                    }
+                }
+                */
+                let call_site = self.builder.build_indirect_call(
+                    llvm_func_type,
+                    typed_func_ptr,
+                    params
+                        .iter()
+                        .copied()
+                        .map(Into::into)
+                        .collect::<Vec<BasicMetadataValueEnum>>()
+                        .as_slice(),
+                    "indirect_call",
+                );
+                for (attr, attr_loc) in llvm_func_attrs {
+                    call_site.add_attribute(attr_loc, attr);
+                }
+                /*
+                if self.track_state {
+                    if let Some(offset) = opcode_offset {
+                        let mut stackmaps = self.stackmaps.borrow_mut();
+                        finalize_opcode_stack_map(
+                            self.intrinsics,
+                            self.builder,
+                            self.index,
+                            &mut *stackmaps,
+                            StackmapEntryKind::Call,
+                            offset,
+                        )
+                    }
+                }
+                */
+
+                self.abi
+                    .rets_from_call(&self.builder, self.intrinsics, call_site, func_type)
+                    .iter()
+                    .for_each(|ret| self.state.push1(*ret));
+            }
+
+            /***************************
+             * Integer Arithmetic instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#integer-arithmetic-instructions
+             ***************************/
+            Operator::I32Add | Operator::I64Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_int_add(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self.builder.build_int_add(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self.builder.build_int_add(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtAddPairwiseI8x16S | Operator::I16x8ExtAddPairwiseI8x16U => {
+                let extend_op = match op {
+                    Operator::I16x8ExtAddPairwiseI8x16S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i16x8_ty, "")
+                    }
+                    Operator::I16x8ExtAddPairwiseI8x16U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i16x8_ty, "")
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+
+                let left = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[14],
+                    ]),
+                    "",
+                );
+                let left = extend_op(self, left);
+                let right = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[7],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[15],
+                    ]),
+                    "",
+                );
+                let right = extend_op(self, right);
+
+                let res = self.builder.build_int_add(left, right, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self.builder.build_int_add(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtAddPairwiseI16x8S | Operator::I32x4ExtAddPairwiseI16x8U => {
+                let extend_op = match op {
+                    Operator::I32x4ExtAddPairwiseI16x8S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i32x4_ty, "")
+                    }
+                    Operator::I32x4ExtAddPairwiseI16x8U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i32x4_ty, "")
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+
+                let left = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[6],
+                    ]),
+                    "",
+                );
+                let left = extend_op(self, left);
+                let right = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let right = extend_op(self, right);
+
+                let res = self.builder.build_int_add(left, right, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self.builder.build_int_add(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16AddSatS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sadd_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8AddSatS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sadd_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16AddSatU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.uadd_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8AddSatU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.uadd_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Sub | Operator::I64Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_int_sub(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self.builder.build_int_sub(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self.builder.build_int_sub(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self.builder.build_int_sub(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self.builder.build_int_sub(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16SubSatS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ssub_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8SubSatS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ssub_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16SubSatU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.usub_sat_i8x16, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8SubSatU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.usub_sat_i16x8, &[v1.into(), v2.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Mul | Operator::I64Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_int_mul(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self.builder.build_int_mul(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self.builder.build_int_mul(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self.builder.build_int_mul(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Q15MulrSatS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+
+                let max_value = self
+                    .intrinsics
+                    .i16_ty
+                    .const_int(i16::max_value() as u64, false);
+                let max_values = VectorType::const_vector(&[max_value; 8]);
+
+                let v1 = self
+                    .builder
+                    .build_int_s_extend(v1, self.intrinsics.i32x8_ty, "");
+                let v2 = self
+                    .builder
+                    .build_int_s_extend(v2, self.intrinsics.i32x8_ty, "");
+                let res = self.builder.build_int_mul(v1, v2, "");
+
+                // magic number specified by the spec
+                let bit = self.intrinsics.i32_ty.const_int(0x4000, false);
+                let bits = VectorType::const_vector(&[bit; 8]);
+
+                let res = self.builder.build_int_add(res, bits, "");
+
+                let fifteen = self.intrinsics.i32_consts[15];
+                let fifteens = VectorType::const_vector(&[fifteen; 8]);
+
+                let res = self.builder.build_right_shift(res, fifteens, true, "");
+                let saturate_up = {
+                    let max_values =
+                        self.builder
+                            .build_int_s_extend(max_values, self.intrinsics.i32x8_ty, "");
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, res, max_values, "")
+                };
+
+                let res = self
+                    .builder
+                    .build_int_truncate(res, self.intrinsics.i16x8_ty, "");
+
+                let res = self
+                    .builder
+                    .build_select(saturate_up, max_values, res, "")
+                    .into_vector_value();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtMulLowI8x16S
+            | Operator::I16x8ExtMulLowI8x16U
+            | Operator::I16x8ExtMulHighI8x16S
+            | Operator::I16x8ExtMulHighI8x16U => {
+                let extend_op = match op {
+                    Operator::I16x8ExtMulLowI8x16S | Operator::I16x8ExtMulHighI8x16S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i16x8_ty, "")
+                    }
+                    Operator::I16x8ExtMulLowI8x16U | Operator::I16x8ExtMulHighI8x16U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i16x8_ty, "")
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let shuffle_array = match op {
+                    Operator::I16x8ExtMulLowI8x16S | Operator::I16x8ExtMulLowI8x16U => [
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[14],
+                    ],
+                    Operator::I16x8ExtMulHighI8x16S | Operator::I16x8ExtMulHighI8x16U => [
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[7],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[15],
+                    ],
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let val1 = self.builder.build_shuffle_vector(
+                    v1,
+                    v1.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val1 = extend_op(self, val1);
+                let val2 = self.builder.build_shuffle_vector(
+                    v2,
+                    v2.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val2 = extend_op(self, val2);
+                let res = self.builder.build_int_mul(val1, val2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtMulLowI16x8S
+            | Operator::I32x4ExtMulLowI16x8U
+            | Operator::I32x4ExtMulHighI16x8S
+            | Operator::I32x4ExtMulHighI16x8U => {
+                let extend_op = match op {
+                    Operator::I32x4ExtMulLowI16x8S | Operator::I32x4ExtMulHighI16x8S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i32x4_ty, "")
+                    }
+                    Operator::I32x4ExtMulLowI16x8U | Operator::I32x4ExtMulHighI16x8U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i32x4_ty, "")
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let shuffle_array = match op {
+                    Operator::I32x4ExtMulLowI16x8S | Operator::I32x4ExtMulLowI16x8U => [
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[6],
+                    ],
+                    Operator::I32x4ExtMulHighI16x8S | Operator::I32x4ExtMulHighI16x8U => [
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[7],
+                    ],
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let val1 = self.builder.build_shuffle_vector(
+                    v1,
+                    v1.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val1 = extend_op(self, val1);
+                let val2 = self.builder.build_shuffle_vector(
+                    v2,
+                    v2.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val2 = extend_op(self, val2);
+                let res = self.builder.build_int_mul(val1, val2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2ExtMulLowI32x4S
+            | Operator::I64x2ExtMulLowI32x4U
+            | Operator::I64x2ExtMulHighI32x4S
+            | Operator::I64x2ExtMulHighI32x4U => {
+                let extend_op = match op {
+                    Operator::I64x2ExtMulLowI32x4S | Operator::I64x2ExtMulHighI32x4S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    Operator::I64x2ExtMulLowI32x4U | Operator::I64x2ExtMulHighI32x4U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let shuffle_array = match op {
+                    Operator::I64x2ExtMulLowI32x4S | Operator::I64x2ExtMulLowI32x4U => {
+                        [self.intrinsics.i32_consts[0], self.intrinsics.i32_consts[2]]
+                    }
+                    Operator::I64x2ExtMulHighI32x4S | Operator::I64x2ExtMulHighI32x4U => {
+                        [self.intrinsics.i32_consts[1], self.intrinsics.i32_consts[3]]
+                    }
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let val1 = self.builder.build_shuffle_vector(
+                    v1,
+                    v1.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val1 = extend_op(self, val1);
+                let val2 = self.builder.build_shuffle_vector(
+                    v2,
+                    v2.get_type().get_undef(),
+                    VectorType::const_vector(&shuffle_array),
+                    "",
+                );
+                let val2 = extend_op(self, val2);
+                let res = self.builder.build_int_mul(val1, val2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4DotI16x8S => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let low_i16 = [
+                    self.intrinsics.i32_consts[0],
+                    self.intrinsics.i32_consts[2],
+                    self.intrinsics.i32_consts[4],
+                    self.intrinsics.i32_consts[6],
+                ];
+                let high_i16 = [
+                    self.intrinsics.i32_consts[1],
+                    self.intrinsics.i32_consts[3],
+                    self.intrinsics.i32_consts[5],
+                    self.intrinsics.i32_consts[7],
+                ];
+                let v1_low = self.builder.build_shuffle_vector(
+                    v1,
+                    v1.get_type().get_undef(),
+                    VectorType::const_vector(&low_i16),
+                    "",
+                );
+                let v1_low = self
+                    .builder
+                    .build_int_s_extend(v1_low, self.intrinsics.i32x4_ty, "");
+                let v1_high = self.builder.build_shuffle_vector(
+                    v1,
+                    v1.get_type().get_undef(),
+                    VectorType::const_vector(&high_i16),
+                    "",
+                );
+                let v1_high =
+                    self.builder
+                        .build_int_s_extend(v1_high, self.intrinsics.i32x4_ty, "");
+                let v2_low = self.builder.build_shuffle_vector(
+                    v2,
+                    v2.get_type().get_undef(),
+                    VectorType::const_vector(&low_i16),
+                    "",
+                );
+                let v2_low = self
+                    .builder
+                    .build_int_s_extend(v2_low, self.intrinsics.i32x4_ty, "");
+                let v2_high = self.builder.build_shuffle_vector(
+                    v2,
+                    v2.get_type().get_undef(),
+                    VectorType::const_vector(&high_i16),
+                    "",
+                );
+                let v2_high =
+                    self.builder
+                        .build_int_s_extend(v2_high, self.intrinsics.i32x4_ty, "");
+                let low_product = self.builder.build_int_mul(v1_low, v2_low, "");
+                let high_product = self.builder.build_int_mul(v1_high, v2_high, "");
+
+                let res = self.builder.build_int_add(low_product, high_product, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32DivS | Operator::I64DivS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+
+                self.trap_if_zero_or_overflow(v1, v2);
+
+                let res = self.builder.build_int_signed_div(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32DivU | Operator::I64DivU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+
+                self.trap_if_zero(v2);
+
+                let res = self.builder.build_int_unsigned_div(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32RemS | Operator::I64RemS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let int_type = v1.get_type();
+                let (min_value, neg_one_value) = if int_type == self.intrinsics.i32_ty {
+                    let min_value = int_type.const_int(i32::min_value() as u64, false);
+                    let neg_one_value = int_type.const_int(-1i32 as u32 as u64, false);
+                    (min_value, neg_one_value)
+                } else if int_type == self.intrinsics.i64_ty {
+                    let min_value = int_type.const_int(i64::min_value() as u64, false);
+                    let neg_one_value = int_type.const_int(-1i64 as u64, false);
+                    (min_value, neg_one_value)
+                } else {
+                    unreachable!()
+                };
+
+                self.trap_if_zero(v2);
+
+                // "Overflow also leads to undefined behavior; this is a rare
+                // case, but can occur, for example, by taking the remainder of
+                // a 32-bit division of -2147483648 by -1. (The remainder
+                // doesn’t actually overflow, but this rule lets srem be
+                // implemented using instructions that return both the result
+                // of the division and the remainder.)"
+                //   -- https://llvm.org/docs/LangRef.html#srem-instruction
+                //
+                // In Wasm, the i32.rem_s i32.const -2147483648 i32.const -1 is
+                // i32.const 0. We implement this by swapping out the left value
+                // for 0 in this case.
+                let will_overflow = self.builder.build_and(
+                    self.builder
+                        .build_int_compare(IntPredicate::EQ, v1, min_value, "left_is_min"),
+                    self.builder.build_int_compare(
+                        IntPredicate::EQ,
+                        v2,
+                        neg_one_value,
+                        "right_is_neg_one",
+                    ),
+                    "srem_will_overflow",
+                );
+                let v1 = self
+                    .builder
+                    .build_select(will_overflow, int_type.const_zero(), v1, "")
+                    .into_int_value();
+                let res = self.builder.build_int_signed_rem(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32RemU | Operator::I64RemU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+
+                self.trap_if_zero(v2);
+
+                let res = self.builder.build_int_unsigned_rem(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32And | Operator::I64And | Operator::V128And => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_and(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32Or | Operator::I64Or | Operator::V128Or => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_or(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I32Xor | Operator::I64Xor | Operator::V128Xor => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let res = self.builder.build_xor(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::V128AndNot => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let v2 = self.builder.build_not(v2, "");
+                let res = self.builder.build_and(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::V128Bitselect => {
+                let ((v1, i1), (v2, i2), (cond, cond_info)) = self.state.pop3_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let cond = self.apply_pending_canonicalization(cond, cond_info);
+                let v1 = self
+                    .builder
+                    .build_bitcast(v1, self.intrinsics.i1x128_ty, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_bitcast(v2, self.intrinsics.i1x128_ty, "")
+                    .into_vector_value();
+                let cond = self
+                    .builder
+                    .build_bitcast(cond, self.intrinsics.i1x128_ty, "")
+                    .into_vector_value();
+                let res = self.builder.build_select(cond, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16Bitmask => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+
+                let zeros = self.intrinsics.i8x16_ty.const_zero();
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
+                let res = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i16_ty, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Bitmask => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+
+                let zeros = self.intrinsics.i16x8_ty.const_zero();
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
+                let res = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i8_ty, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Bitmask => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i32x4(v, i);
+
+                let zeros = self.intrinsics.i32x4_ty.const_zero();
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
+                let res = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i4_ty, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Bitmask => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i64x2(v, i);
+
+                let zeros = self.intrinsics.i64x2_ty.const_zero();
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v, zeros, "");
+                let res = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i2_ty, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i32_ty.const_int(31u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_left_shift(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I64Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i64_ty.const_int(63u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_left_shift(v1, v2, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[7], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                let res = self.builder.build_left_shift(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
+                let res = self.builder.build_left_shift(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
+                let res = self.builder.build_left_shift(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Shl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
+                let v2 = self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
+                let res = self.builder.build_left_shift(v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i32_ty.const_int(31u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                self.state.push1(res);
+            }
+            Operator::I64ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i64_ty.const_int(63u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[7], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2ShrS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
+                let v2 = self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
+                let res = self.builder.build_right_shift(v1, v2, true, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i32_ty.const_int(31u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                self.state.push1(res);
+            }
+            Operator::I64ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i64_ty.const_int(63u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[7], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i8_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 = self
+                    .builder
+                    .build_and(v2, self.intrinsics.i32_consts[15], "");
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i16_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i16x8_ty);
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(31, false), "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i32x4_ty);
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2ShrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let v2 =
+                    self.builder
+                        .build_and(v2, self.intrinsics.i32_ty.const_int(63, false), "");
+                let v2 = self
+                    .builder
+                    .build_int_z_extend(v2, self.intrinsics.i64_ty, "");
+                let v2 = self.splat_vector(v2.as_basic_value_enum(), self.intrinsics.i64x2_ty);
+                let res = self.builder.build_right_shift(v1, v2, false, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Rotl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i32_ty.const_int(31u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let lhs = self.builder.build_left_shift(v1, v2, "");
+                let rhs = {
+                    let negv2 = self.builder.build_int_neg(v2, "");
+                    let rhs = self.builder.build_and(negv2, mask, "");
+                    self.builder.build_right_shift(v1, rhs, false, "")
+                };
+                let res = self.builder.build_or(lhs, rhs, "");
+                self.state.push1(res);
+            }
+            Operator::I64Rotl => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i64_ty.const_int(63u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let lhs = self.builder.build_left_shift(v1, v2, "");
+                let rhs = {
+                    let negv2 = self.builder.build_int_neg(v2, "");
+                    let rhs = self.builder.build_and(negv2, mask, "");
+                    self.builder.build_right_shift(v1, rhs, false, "")
+                };
+                let res = self.builder.build_or(lhs, rhs, "");
+                self.state.push1(res);
+            }
+            Operator::I32Rotr => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i32_ty.const_int(31u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let lhs = self.builder.build_right_shift(v1, v2, false, "");
+                let rhs = {
+                    let negv2 = self.builder.build_int_neg(v2, "");
+                    let rhs = self.builder.build_and(negv2, mask, "");
+                    self.builder.build_left_shift(v1, rhs, "")
+                };
+                let res = self.builder.build_or(lhs, rhs, "");
+                self.state.push1(res);
+            }
+            Operator::I64Rotr => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let mask = self.intrinsics.i64_ty.const_int(63u64, false);
+                let v2 = self.builder.build_and(v2, mask, "");
+                let lhs = self.builder.build_right_shift(v1, v2, false, "");
+                let rhs = {
+                    let negv2 = self.builder.build_int_neg(v2, "");
+                    let rhs = self.builder.build_and(negv2, mask, "");
+                    self.builder.build_left_shift(v1, rhs, "")
+                };
+                let res = self.builder.build_or(lhs, rhs, "");
+                self.state.push1(res);
+            }
+            Operator::I32Clz => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let is_zero_undef = self.intrinsics.i1_zero;
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.ctlz_i32,
+                        &[input.into(), is_zero_undef.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64Clz => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let is_zero_undef = self.intrinsics.i1_zero;
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.ctlz_i64,
+                        &[input.into(), is_zero_undef.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I32Ctz => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let is_zero_undef = self.intrinsics.i1_zero;
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cttz_i32,
+                        &[input.into(), is_zero_undef.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64Ctz => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let is_zero_undef = self.intrinsics.i1_zero;
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cttz_i64,
+                        &[input.into(), is_zero_undef.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I8x16Popcnt => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ctpop_i8x16, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Popcnt => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ctpop_i32, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64Popcnt => {
+                let (input, info) = self.state.pop1_extra()?;
+                let input = self.apply_pending_canonicalization(input, info);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ctpop_i64, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I32Eqz => {
+                let input = self.state.pop1()?.into_int_value();
+                let cond = self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    input,
+                    self.intrinsics.i32_zero,
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64Eqz => {
+                let input = self.state.pop1()?.into_int_value();
+                let cond = self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    input,
+                    self.intrinsics.i64_zero,
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I8x16Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+
+                let seven = self.intrinsics.i8_ty.const_int(7, false);
+                let seven = VectorType::const_vector(&[seven; 16]);
+                let all_sign_bits = self.builder.build_right_shift(v, seven, true, "");
+                let xor = self.builder.build_xor(v, all_sign_bits, "");
+                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+
+                let fifteen = self.intrinsics.i16_ty.const_int(15, false);
+                let fifteen = VectorType::const_vector(&[fifteen; 8]);
+                let all_sign_bits = self.builder.build_right_shift(v, fifteen, true, "");
+                let xor = self.builder.build_xor(v, all_sign_bits, "");
+                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i32x4(v, i);
+
+                let thirtyone = self.intrinsics.i32_ty.const_int(31, false);
+                let thirtyone = VectorType::const_vector(&[thirtyone; 4]);
+                let all_sign_bits = self.builder.build_right_shift(v, thirtyone, true, "");
+                let xor = self.builder.build_xor(v, all_sign_bits, "");
+                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i64x2(v, i);
+
+                let sixtythree = self.intrinsics.i64_ty.const_int(63, false);
+                let sixtythree = VectorType::const_vector(&[sixtythree; 2]);
+                let all_sign_bits = self.builder.build_right_shift(v, sixtythree, true, "");
+                let xor = self.builder.build_xor(v, all_sign_bits, "");
+                let res = self.builder.build_int_sub(xor, all_sign_bits, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16MinS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16MinU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16MaxS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16MaxU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8MinS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8MinU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8MaxS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8MaxU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4MinS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4MinU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4MaxS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4MaxU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v1, v2, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16AvgrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+
+                // This approach is faster on x86-64 when the PAVG[BW]
+                // instructions are available. On other platforms, an alternative
+                // implementation appears likely to outperform, described here:
+                //   %a = or %v1, %v2
+                //   %b = and %a, 1
+                //   %v1 = lshr %v1, 1
+                //   %v2 = lshr %v2, 1
+                //   %sum = add %v1, %v2
+                //   %res = add %sum, %b
+
+                let ext_ty = self.intrinsics.i16_ty.vec_type(16);
+                let one = self.intrinsics.i16_ty.const_int(1, false);
+                let one = VectorType::const_vector(&[one; 16]);
+
+                let v1 = self.builder.build_int_z_extend(v1, ext_ty, "");
+                let v2 = self.builder.build_int_z_extend(v2, ext_ty, "");
+                let res =
+                    self.builder
+                        .build_int_add(self.builder.build_int_add(one, v1, ""), v2, "");
+                let res = self.builder.build_right_shift(res, one, false, "");
+                let res = self
+                    .builder
+                    .build_int_truncate(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8AvgrU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+
+                // This approach is faster on x86-64 when the PAVG[BW]
+                // instructions are available. On other platforms, an alternative
+                // implementation appears likely to outperform, described here:
+                //   %a = or %v1, %v2
+                //   %b = and %a, 1
+                //   %v1 = lshr %v1, 1
+                //   %v2 = lshr %v2, 1
+                //   %sum = add %v1, %v2
+                //   %res = add %sum, %b
+
+                let ext_ty = self.intrinsics.i32_ty.vec_type(8);
+                let one = self.intrinsics.i32_consts[1];
+                let one = VectorType::const_vector(&[one; 8]);
+
+                let v1 = self.builder.build_int_z_extend(v1, ext_ty, "");
+                let v2 = self.builder.build_int_z_extend(v2, ext_ty, "");
+                let res =
+                    self.builder
+                        .build_int_add(self.builder.build_int_add(one, v1, ""), v2, "");
+                let res = self.builder.build_right_shift(res, one, false, "");
+                let res = self
+                    .builder
+                    .build_int_truncate(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+
+            /***************************
+             * Floating-Point Arithmetic instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#floating-point-arithmetic-instructions
+             ***************************/
+            Operator::F32Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.add_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.add_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32x4Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f32x4(v1, i1);
+                let (v2, i2) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.add_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64x2Add => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f64x2(v1, i1);
+                let (v2, i2) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.add_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.sub_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.sub_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32x4Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f32x4(v1, i1);
+                let (v2, i2) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.sub_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64x2Sub => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f64x2(v1, i1);
+                let (v2, i2) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.sub_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.mul_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.mul_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32x4Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f32x4(v1, i1);
+                let (v2, i2) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.mul_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f32_nan(),
+                );
+            }
+            Operator::F64x2Mul => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f64x2(v1, i1);
+                let (v2, i2) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.mul_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(
+                    res,
+                    (i1.strip_pending() & i2.strip_pending()) | ExtraInfo::pending_f64_nan(),
+                );
+            }
+            Operator::F32Div => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.div_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Div => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.div_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32x4Div => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.div_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64x2Div => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.div_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32Sqrt => {
+                let input = self.state.pop1()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sqrt_f32, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Sqrt => {
+                let input = self.state.pop1()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sqrt_f64, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32x4Sqrt => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sqrt_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let bits = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                self.state.push1_extra(bits, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64x2Sqrt => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.sqrt_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let bits = self
+                    .builder
+                    .build_bitcast(res, self.intrinsics.i128_ty, "bits");
+                self.state.push1(bits);
+            }
+            Operator::F32Min => {
+                // This implements the same logic as LLVM's @llvm.minimum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let (v1, v2) = self.state.pop2()?;
+                let v1 = self.canonicalize_nans(v1);
+                let v2 = self.canonicalize_nans(v2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f32_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f32_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1),
+                    self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2),
+                        self.builder.build_select(
+                            v1_lt_v2,
+                            v1,
+                            self.builder.build_select(
+                                v1_gt_v2,
+                                v2,
+                                self.builder.build_bitcast(
+                                    self.builder.build_or(
+                                        self.builder
+                                            .build_bitcast(v1, self.intrinsics.i32_ty, "")
+                                            .into_int_value(),
+                                        self.builder
+                                            .build_bitcast(v2, self.intrinsics.i32_ty, "")
+                                            .into_int_value(),
+                                        "",
+                                    ),
+                                    self.intrinsics.f32_ty,
+                                    "",
+                                ),
+                                "",
+                            ),
+                            "",
+                        ),
+                        "",
+                    ),
+                    "",
+                );
+
+                self.state.push1(res);
+            }
+            Operator::F64Min => {
+                // This implements the same logic as LLVM's @llvm.minimum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let (v1, v2) = self.state.pop2()?;
+                let v1 = self.canonicalize_nans(v1);
+                let v2 = self.canonicalize_nans(v2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f64_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f64_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1),
+                    self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2),
+                        self.builder.build_select(
+                            v1_lt_v2,
+                            v1,
+                            self.builder.build_select(
+                                v1_gt_v2,
+                                v2,
+                                self.builder.build_bitcast(
+                                    self.builder.build_or(
+                                        self.builder
+                                            .build_bitcast(v1, self.intrinsics.i64_ty, "")
+                                            .into_int_value(),
+                                        self.builder
+                                            .build_bitcast(v2, self.intrinsics.i64_ty, "")
+                                            .into_int_value(),
+                                        "",
+                                    ),
+                                    self.intrinsics.f64_ty,
+                                    "",
+                                ),
+                                "",
+                            ),
+                            "",
+                        ),
+                        "",
+                    ),
+                    "",
+                );
+
+                self.state.push1(res);
+            }
+            Operator::F32x4Min => {
+                // This implements the same logic as LLVM's @llvm.minimum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f32x4_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f32x4_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1.into()).into_vector_value(),
+                    self.builder
+                        .build_select(
+                            v2_is_nan,
+                            self.quiet_nan(v2.into()).into_vector_value(),
+                            self.builder
+                                .build_select(
+                                    v1_lt_v2,
+                                    v1.into(),
+                                    self.builder.build_select(
+                                        v1_gt_v2,
+                                        v2.into(),
+                                        self.builder.build_bitcast(
+                                            self.builder.build_or(
+                                                self.builder
+                                                    .build_bitcast(v1, self.intrinsics.i32x4_ty, "")
+                                                    .into_vector_value(),
+                                                self.builder
+                                                    .build_bitcast(v2, self.intrinsics.i32x4_ty, "")
+                                                    .into_vector_value(),
+                                                "",
+                                            ),
+                                            self.intrinsics.f32x4_ty,
+                                            "",
+                                        ),
+                                        "",
+                                    ),
+                                    "",
+                                )
+                                .into_vector_value(),
+                            "",
+                        )
+                        .into_vector_value(),
+                    "",
+                );
+
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32x4PMin => {
+                // Pseudo-min: b < a ? b : a
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _i1) = self.v128_into_f32x4(v1, i1);
+                let (v2, _i2) = self.v128_into_f32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v2, v1, "");
+                let res = self.builder.build_select(cmp, v2, v1, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Min => {
+                // This implements the same logic as LLVM's @llvm.minimum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f64x2_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f64x2_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1.into()).into_vector_value(),
+                    self.builder
+                        .build_select(
+                            v2_is_nan,
+                            self.quiet_nan(v2.into()).into_vector_value(),
+                            self.builder
+                                .build_select(
+                                    v1_lt_v2,
+                                    v1.into(),
+                                    self.builder.build_select(
+                                        v1_gt_v2,
+                                        v2.into(),
+                                        self.builder.build_bitcast(
+                                            self.builder.build_or(
+                                                self.builder
+                                                    .build_bitcast(v1, self.intrinsics.i64x2_ty, "")
+                                                    .into_vector_value(),
+                                                self.builder
+                                                    .build_bitcast(v2, self.intrinsics.i64x2_ty, "")
+                                                    .into_vector_value(),
+                                                "",
+                                            ),
+                                            self.intrinsics.f64x2_ty,
+                                            "",
+                                        ),
+                                        "",
+                                    ),
+                                    "",
+                                )
+                                .into_vector_value(),
+                            "",
+                        )
+                        .into_vector_value(),
+                    "",
+                );
+
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2PMin => {
+                // Pseudo-min: b < a ? b : a
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _i1) = self.v128_into_f64x2(v1, i1);
+                let (v2, _i2) = self.v128_into_f64x2(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v2, v1, "");
+                let res = self.builder.build_select(cmp, v2, v1, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Max => {
+                // This implements the same logic as LLVM's @llvm.maximum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let (v1, v2) = self.state.pop2()?;
+                let v1 = self.canonicalize_nans(v1);
+                let v2 = self.canonicalize_nans(v2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f32_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f32_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1),
+                    self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2),
+                        self.builder.build_select(
+                            v1_lt_v2,
+                            v2,
+                            self.builder.build_select(
+                                v1_gt_v2,
+                                v1,
+                                self.builder.build_bitcast(
+                                    self.builder.build_and(
+                                        self.builder
+                                            .build_bitcast(v1, self.intrinsics.i32_ty, "")
+                                            .into_int_value(),
+                                        self.builder
+                                            .build_bitcast(v2, self.intrinsics.i32_ty, "")
+                                            .into_int_value(),
+                                        "",
+                                    ),
+                                    self.intrinsics.f32_ty,
+                                    "",
+                                ),
+                                "",
+                            ),
+                            "",
+                        ),
+                        "",
+                    ),
+                    "",
+                );
+
+                self.state.push1(res);
+            }
+            Operator::F64Max => {
+                // This implements the same logic as LLVM's @llvm.maximum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let (v1, v2) = self.state.pop2()?;
+                let v1 = self.canonicalize_nans(v1);
+                let v2 = self.canonicalize_nans(v2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f64_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f64_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_int_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1),
+                    self.builder.build_select(
+                        v2_is_nan,
+                        self.quiet_nan(v2),
+                        self.builder.build_select(
+                            v1_lt_v2,
+                            v2,
+                            self.builder.build_select(
+                                v1_gt_v2,
+                                v1,
+                                self.builder.build_bitcast(
+                                    self.builder.build_and(
+                                        self.builder
+                                            .build_bitcast(v1, self.intrinsics.i64_ty, "")
+                                            .into_int_value(),
+                                        self.builder
+                                            .build_bitcast(v2, self.intrinsics.i64_ty, "")
+                                            .into_int_value(),
+                                        "",
+                                    ),
+                                    self.intrinsics.f64_ty,
+                                    "",
+                                ),
+                                "",
+                            ),
+                            "",
+                        ),
+                        "",
+                    ),
+                    "",
+                );
+
+                self.state.push1(res);
+            }
+            Operator::F32x4Max => {
+                // This implements the same logic as LLVM's @llvm.maximum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f32x4_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f32x4_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f32x4,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1.into()).into_vector_value(),
+                    self.builder
+                        .build_select(
+                            v2_is_nan,
+                            self.quiet_nan(v2.into()).into_vector_value(),
+                            self.builder
+                                .build_select(
+                                    v1_lt_v2,
+                                    v2.into(),
+                                    self.builder.build_select(
+                                        v1_gt_v2,
+                                        v1.into(),
+                                        self.builder.build_bitcast(
+                                            self.builder.build_and(
+                                                self.builder
+                                                    .build_bitcast(v1, self.intrinsics.i32x4_ty, "")
+                                                    .into_vector_value(),
+                                                self.builder
+                                                    .build_bitcast(v2, self.intrinsics.i32x4_ty, "")
+                                                    .into_vector_value(),
+                                                "",
+                                            ),
+                                            self.intrinsics.f32x4_ty,
+                                            "",
+                                        ),
+                                        "",
+                                    ),
+                                    "",
+                                )
+                                .into_vector_value(),
+                            "",
+                        )
+                        .into_vector_value(),
+                    "",
+                );
+
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32x4PMax => {
+                // Pseudo-max: a < b ? b : a
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _i1) = self.v128_into_f32x4(v1, i1);
+                let (v2, _i2) = self.v128_into_f32x4(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v2, v1, "");
+
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Max => {
+                // This implements the same logic as LLVM's @llvm.maximum
+                // intrinsic would, but x86 lowering of that intrinsic
+                // encounters a fatal error in LLVM 11.
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+
+                let v1_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            self.intrinsics.f64x2_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v2_is_nan = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v2.into(),
+                            self.intrinsics.f64x2_zero.into(),
+                            self.intrinsics.fp_uno_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_lt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_olt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+                let v1_gt_v2 = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.cmp_f64x2,
+                        &[
+                            v1.into(),
+                            v2.into(),
+                            self.intrinsics.fp_ogt_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap()
+                    .into_vector_value();
+
+                let res = self.builder.build_select(
+                    v1_is_nan,
+                    self.quiet_nan(v1.into()).into_vector_value(),
+                    self.builder
+                        .build_select(
+                            v2_is_nan,
+                            self.quiet_nan(v2.into()).into_vector_value(),
+                            self.builder
+                                .build_select(
+                                    v1_lt_v2,
+                                    v2.into(),
+                                    self.builder.build_select(
+                                        v1_gt_v2,
+                                        v1.into(),
+                                        self.builder.build_bitcast(
+                                            self.builder.build_and(
+                                                self.builder
+                                                    .build_bitcast(v1, self.intrinsics.i64x2_ty, "")
+                                                    .into_vector_value(),
+                                                self.builder
+                                                    .build_bitcast(v2, self.intrinsics.i64x2_ty, "")
+                                                    .into_vector_value(),
+                                                "",
+                                            ),
+                                            self.intrinsics.f64x2_ty,
+                                            "",
+                                        ),
+                                        "",
+                                    ),
+                                    "",
+                                )
+                                .into_vector_value(),
+                            "",
+                        )
+                        .into_vector_value(),
+                    "",
+                );
+
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2PMax => {
+                // Pseudo-max: a < b ? b : a
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _i1) = self.v128_into_f64x2(v1, i1);
+                let (v2, _i2) = self.v128_into_f64x2(v2, i2);
+                let cmp = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
+                let res = self.builder.build_select(cmp, v2, v1, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Ceil => {
+                let (input, info) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ceil_f32, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, info | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F32x4Ceil => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ceil_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Ceil => {
+                let (input, info) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ceil_f64, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, info | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F64x2Ceil => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.ceil_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32Floor => {
+                let (input, info) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.floor_f32, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, info | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F32x4Floor => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.floor_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Floor => {
+                let (input, info) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.floor_f64, &[input.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, info | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F64x2Floor => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.floor_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32Trunc => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.trunc_f32, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F32x4Trunc => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.trunc_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Trunc => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.trunc_f64, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F64x2Trunc => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.trunc_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32Nearest => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.nearbyint_f32, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F32x4Nearest => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.nearbyint_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64Nearest => {
+                let (v, i) = self.state.pop1_extra()?;
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.nearbyint_f64, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F64x2Nearest => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.nearbyint_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i | ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.fabs_f32, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                // The exact NaN returned by F32Abs is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F64Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.fabs_f64, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                // The exact NaN returned by F64Abs is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F32x4Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v =
+                    self.builder
+                        .build_bitcast(v.into_int_value(), self.intrinsics.f32x4_ty, "");
+                let v = self.apply_pending_canonicalization(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.fabs_f32x4, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The exact NaN returned by F32x4Abs is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F64x2Abs => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v =
+                    self.builder
+                        .build_bitcast(v.into_int_value(), self.intrinsics.f64x2_ty, "");
+                let v = self.apply_pending_canonicalization(v, i);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.fabs_f64x2, &[v.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The exact NaN returned by F32x4Abs is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F32x4Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v =
+                    self.builder
+                        .build_bitcast(v.into_int_value(), self.intrinsics.f32x4_ty, "");
+                let v = self
+                    .apply_pending_canonicalization(v, i)
+                    .into_vector_value();
+                let res = self.builder.build_float_neg(v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The exact NaN returned by F32x4Neg is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F64x2Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v =
+                    self.builder
+                        .build_bitcast(v.into_int_value(), self.intrinsics.f64x2_ty, "");
+                let v = self
+                    .apply_pending_canonicalization(v, i)
+                    .into_vector_value();
+                let res = self.builder.build_float_neg(v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                // The exact NaN returned by F64x2Neg is fully defined. Do not
+                // adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F32Neg | Operator::F64Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i).into_float_value();
+                let res = self.builder.build_float_neg(v, "");
+                // The exact NaN returned by F32Neg and F64Neg are fully defined.
+                // Do not adjust.
+                self.state.push1_extra(res, i.strip_pending());
+            }
+            Operator::F32Copysign => {
+                let ((mag, mag_info), (sgn, sgn_info)) = self.state.pop2_extra()?;
+                let mag = self.apply_pending_canonicalization(mag, mag_info);
+                let sgn = self.apply_pending_canonicalization(sgn, sgn_info);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.copysign_f32, &[mag.into(), sgn.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                // The exact NaN returned by F32Copysign is fully defined.
+                // Do not adjust.
+                self.state.push1_extra(res, mag_info.strip_pending());
+            }
+            Operator::F64Copysign => {
+                let ((mag, mag_info), (sgn, sgn_info)) = self.state.pop2_extra()?;
+                let mag = self.apply_pending_canonicalization(mag, mag_info);
+                let sgn = self.apply_pending_canonicalization(sgn, sgn_info);
+                let res = self
+                    .builder
+                    .build_call(self.intrinsics.copysign_f64, &[mag.into(), sgn.into()], "")
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                // The exact NaN returned by F32Copysign is fully defined.
+                // Do not adjust.
+                self.state.push1_extra(res, mag_info.strip_pending());
+            }
+
+            /***************************
+             * Integer Comparison instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#integer-comparison-instructions
+             ***************************/
+            Operator::I32Eq | Operator::I64Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::EQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32Ne | Operator::I64Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self.builder.build_int_compare(IntPredicate::NE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32LtS | Operator::I64LtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16LtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8LtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4LtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2LtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32LtU | Operator::I64LtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16LtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8LtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4LtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32LeS | Operator::I64LeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16LeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8LeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4LeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2LeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32LeU | Operator::I64LeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16LeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8LeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4LeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::ULE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32GtS | Operator::I64GtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16GtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8GtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4GtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2GtS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32GtU | Operator::I64GtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16GtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8GtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4GtU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32GeS | Operator::I64GeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16GeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8GeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4GeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2GeS => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i64x2(v1, i1);
+                let (v2, _) = self.v128_into_i64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::SGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32GeU | Operator::I64GeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
+                let cond = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16GeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let (v2, _) = self.v128_into_i8x16(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i8x16_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8GeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4GeU => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_int_compare(IntPredicate::UGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+
+            /***************************
+             * Floating-Point Comparison instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#floating-point-comparison-instructions
+             ***************************/
+            Operator::F32Eq | Operator::F64Eq => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Eq => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OEQ, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Ne | Operator::F64Ne => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Ne => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::UNE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Lt | Operator::F64Lt => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Lt => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Lt => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Le | Operator::F64Le => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Le => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Le => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OLE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Gt | Operator::F64Gt => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Gt => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Gt => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGT, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32Ge | Operator::F64Ge => {
+                let (v1, v2) = self.state.pop2()?;
+                let (v1, v2) = (v1.into_float_value(), v2.into_float_value());
+                let cond = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_z_extend(cond, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::F32x4Ge => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f32x4(v1, i1);
+                let (v2, _) = self.v128_into_f32x4(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2Ge => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_f64x2(v1, i1);
+                let (v2, _) = self.v128_into_f64x2(v2, i2);
+                let res = self
+                    .builder
+                    .build_float_compare(FloatPredicate::OGE, v1, v2, "");
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+
+            /***************************
+             * Conversion instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#conversion-instructions
+             ***************************/
+            Operator::I32WrapI64 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_int_truncate(v, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64ExtendI32S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(v, self.intrinsics.i64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64ExtendI32U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I16x8ExtendLowI8x16S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtendHighI8x16S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[14],
+                        self.intrinsics.i32_consts[15],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtendLowI8x16U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtendHighI8x16U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[14],
+                        self.intrinsics.i32_consts[15],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtendLowI16x8S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtendHighI16x8S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_s_extend(low, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtendLowI16x8U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ExtendHighI16x8U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(low, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2ExtendLowI32x4U
+            | Operator::I64x2ExtendLowI32x4S
+            | Operator::I64x2ExtendHighI32x4U
+            | Operator::I64x2ExtendHighI32x4S => {
+                let extend = match op {
+                    Operator::I64x2ExtendLowI32x4U | Operator::I64x2ExtendHighI32x4U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    Operator::I64x2ExtendLowI32x4S | Operator::I64x2ExtendHighI32x4S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    _ => unreachable!("Unhandled inner case"),
+                };
+                let indices = match op {
+                    Operator::I64x2ExtendLowI32x4S | Operator::I64x2ExtendLowI32x4U => {
+                        [self.intrinsics.i32_consts[0], self.intrinsics.i32_consts[1]]
+                    }
+                    Operator::I64x2ExtendHighI32x4S | Operator::I64x2ExtendHighI32x4U => {
+                        [self.intrinsics.i32_consts[2], self.intrinsics.i32_consts[3]]
+                    }
+                    _ => unreachable!("Unhandled inner case"),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i32x4(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&indices),
+                    "",
+                );
+                let res = extend(self, low);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16NarrowI16x8S => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let min = self.intrinsics.i16_ty.const_int(0xff80, false);
+                let max = self.intrinsics.i16_ty.const_int(0x007f, false);
+                let min = VectorType::const_vector(&[min; 8]);
+                let max = VectorType::const_vector(&[max; 8]);
+                let apply_min_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                let apply_max_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                let apply_min_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                let apply_max_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, "");
+                let v1 = self
+                    .builder
+                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_select(apply_max_clamp_v1, max, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_int_truncate(v1, self.intrinsics.i8_ty.vec_type(8), "");
+                let v2 = self
+                    .builder
+                    .build_select(apply_min_clamp_v2, min, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_select(apply_max_clamp_v2, max, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i8_ty.vec_type(8), "");
+                let res = self.builder.build_shuffle_vector(
+                    v1,
+                    v2,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[14],
+                        self.intrinsics.i32_consts[15],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16NarrowI16x8U => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let (v2, _) = self.v128_into_i16x8(v2, i2);
+                let min = self.intrinsics.i16x8_ty.const_zero();
+                let max = self.intrinsics.i16_ty.const_int(0x00ff, false);
+                let max = VectorType::const_vector(&[max; 8]);
+                let apply_min_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                let apply_max_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                let apply_min_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                let apply_max_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, "");
+                let v1 = self
+                    .builder
+                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_select(apply_max_clamp_v1, max, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_int_truncate(v1, self.intrinsics.i8_ty.vec_type(8), "");
+                let v2 = self
+                    .builder
+                    .build_select(apply_min_clamp_v2, min, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_select(apply_max_clamp_v2, max, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_int_truncate(v2, self.intrinsics.i8_ty.vec_type(8), "");
+                let res = self.builder.build_shuffle_vector(
+                    v1,
+                    v2,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                        self.intrinsics.i32_consts[8],
+                        self.intrinsics.i32_consts[9],
+                        self.intrinsics.i32_consts[10],
+                        self.intrinsics.i32_consts[11],
+                        self.intrinsics.i32_consts[12],
+                        self.intrinsics.i32_consts[13],
+                        self.intrinsics.i32_consts[14],
+                        self.intrinsics.i32_consts[15],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8NarrowI32x4S => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let min = self.intrinsics.i32_ty.const_int(0xffff8000, false);
+                let max = self.intrinsics.i32_ty.const_int(0x00007fff, false);
+                let min = VectorType::const_vector(&[min; 4]);
+                let max = VectorType::const_vector(&[max; 4]);
+                let apply_min_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                let apply_max_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                let apply_min_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                let apply_max_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, "");
+                let v1 = self
+                    .builder
+                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_select(apply_max_clamp_v1, max, v1, "")
+                    .into_vector_value();
+                let v1 =
+                    self.builder
+                        .build_int_truncate(v1, self.intrinsics.i16_ty.vec_type(4), "");
+                let v2 = self
+                    .builder
+                    .build_select(apply_min_clamp_v2, min, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_select(apply_max_clamp_v2, max, v2, "")
+                    .into_vector_value();
+                let v2 =
+                    self.builder
+                        .build_int_truncate(v2, self.intrinsics.i16_ty.vec_type(4), "");
+                let res = self.builder.build_shuffle_vector(
+                    v1,
+                    v2,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8NarrowI32x4U => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i32x4(v1, i1);
+                let (v2, _) = self.v128_into_i32x4(v2, i2);
+                let min = self.intrinsics.i32x4_ty.const_zero();
+                let max = self.intrinsics.i32_ty.const_int(0xffff, false);
+                let max = VectorType::const_vector(&[max; 4]);
+                let apply_min_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v1, min, "");
+                let apply_max_clamp_v1 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v1, max, "");
+                let apply_min_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SLT, v2, min, "");
+                let apply_max_clamp_v2 =
+                    self.builder
+                        .build_int_compare(IntPredicate::SGT, v2, max, "");
+                let v1 = self
+                    .builder
+                    .build_select(apply_min_clamp_v1, min, v1, "")
+                    .into_vector_value();
+                let v1 = self
+                    .builder
+                    .build_select(apply_max_clamp_v1, max, v1, "")
+                    .into_vector_value();
+                let v1 =
+                    self.builder
+                        .build_int_truncate(v1, self.intrinsics.i16_ty.vec_type(4), "");
+                let v2 = self
+                    .builder
+                    .build_select(apply_min_clamp_v2, min, v2, "")
+                    .into_vector_value();
+                let v2 = self
+                    .builder
+                    .build_select(apply_max_clamp_v2, max, v2, "")
+                    .into_vector_value();
+                let v2 =
+                    self.builder
+                        .build_int_truncate(v2, self.intrinsics.i16_ty.vec_type(4), "");
+                let res = self.builder.build_shuffle_vector(
+                    v1,
+                    v2,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                        self.intrinsics.i32_consts[4],
+                        self.intrinsics.i32_consts[5],
+                        self.intrinsics.i32_consts[6],
+                        self.intrinsics.i32_consts[7],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4TruncSatF32x4S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self.trunc_sat_into_int(
+                    self.intrinsics.f32x4_ty,
+                    self.intrinsics.i32x4_ty,
+                    LEF32_GEQ_I32_MIN,
+                    GEF32_LEQ_I32_MAX,
+                    std::i32::MIN as u64,
+                    std::i32::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I32x4TruncSatF32x4U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self.trunc_sat_into_int(
+                    self.intrinsics.f32x4_ty,
+                    self.intrinsics.i32x4_ty,
+                    LEF32_GEQ_U32_MIN,
+                    GEF32_LEQ_U32_MAX,
+                    std::u32::MIN as u64,
+                    std::u32::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I32x4TruncSatF64x2SZero | Operator::I32x4TruncSatF64x2UZero => {
+                let ((min, max), (cmp_min, cmp_max)) = match op {
+                    Operator::I32x4TruncSatF64x2SZero => (
+                        (std::i32::MIN as u64, std::i32::MAX as u64),
+                        (LEF64_GEQ_I32_MIN, GEF64_LEQ_I32_MAX),
+                    ),
+                    Operator::I32x4TruncSatF64x2UZero => (
+                        (std::u32::MIN as u64, std::u32::MAX as u64),
+                        (LEF64_GEQ_U32_MIN, GEF64_LEQ_U32_MAX),
+                    ),
+                    _ => unreachable!("Unhandled internal variant"),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self.trunc_sat(
+                    self.intrinsics.f64x2_ty,
+                    self.intrinsics.i32_ty.vec_type(2),
+                    cmp_min,
+                    cmp_max,
+                    min,
+                    max,
+                    v,
+                );
+
+                let zero = self.intrinsics.i32_consts[0];
+                let zeros = VectorType::const_vector(&[zero; 2]);
+                let res = self.builder.build_shuffle_vector(
+                    res,
+                    zeros,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            // Operator::I64x2TruncSatF64x2S => {
+            //     let (v, i) = self.state.pop1_extra()?;
+            //     let v = self.apply_pending_canonicalization(v, i);
+            //     let v = v.into_int_value();
+            //     let res = self.trunc_sat_into_int(
+            //         self.intrinsics.f64x2_ty,
+            //         self.intrinsics.i64x2_ty,
+            //         std::i64::MIN as u64,
+            //         std::i64::MAX as u64,
+            //         std::i64::MIN as u64,
+            //         std::i64::MAX as u64,
+            //         v,
+            //     );
+            //     self.state.push1(res);
+            // }
+            // Operator::I64x2TruncSatF64x2U => {
+            //     let (v, i) = self.state.pop1_extra()?;
+            //     let v = self.apply_pending_canonicalization(v, i);
+            //     let v = v.into_int_value();
+            //     let res = self.trunc_sat_into_int(
+            //         self.intrinsics.f64x2_ty,
+            //         self.intrinsics.i64x2_ty,
+            //         std::u64::MIN,
+            //         std::u64::MAX,
+            //         std::u64::MIN,
+            //         std::u64::MAX,
+            //         v,
+            //     );
+            //     self.state.push1(res);
+            // }
+            Operator::I32TruncF32S => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xcf000000, // -2147483600.0
+                    0x4effffff, // 2147483500.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_signed_int(v1, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32TruncF64S => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xc1e00000001fffff, // -2147483648.9999995
+                    0x41dfffffffffffff, // 2147483647.9999998
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_signed_int(v1, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32TruncSatF32S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i32_ty,
+                    LEF32_GEQ_I32_MIN,
+                    GEF32_LEQ_I32_MAX,
+                    std::i32::MIN as u32 as u64,
+                    std::i32::MAX as u32 as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I32TruncSatF64S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i32_ty,
+                    LEF64_GEQ_I32_MIN,
+                    GEF64_LEQ_I32_MAX,
+                    std::i32::MIN as u64,
+                    std::i32::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I64TruncF32S => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xdf000000, // -9223372000000000000.0
+                    0x5effffff, // 9223371500000000000.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_signed_int(v1, self.intrinsics.i64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64TruncF64S => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xc3e0000000000000, // -9223372036854776000.0
+                    0x43dfffffffffffff, // 9223372036854775000.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_signed_int(v1, self.intrinsics.i64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64TruncSatF32S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i64_ty,
+                    LEF32_GEQ_I64_MIN,
+                    GEF32_LEQ_I64_MAX,
+                    std::i64::MIN as u64,
+                    std::i64::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I64TruncSatF64S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i64_ty,
+                    LEF64_GEQ_I64_MIN,
+                    GEF64_LEQ_I64_MAX,
+                    std::i64::MIN as u64,
+                    std::i64::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I32TruncF32U => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xbf7fffff, // -0.99999994
+                    0x4f7fffff, // 4294967000.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32TruncF64U => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xbfefffffffffffff, // -0.9999999999999999
+                    0x41efffffffffffff, // 4294967295.9999995
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_unsigned_int(v1, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32TruncSatF32U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i32_ty,
+                    LEF32_GEQ_U32_MIN,
+                    GEF32_LEQ_U32_MAX,
+                    std::u32::MIN as u64,
+                    std::u32::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I32TruncSatF64U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i32_ty,
+                    LEF64_GEQ_U32_MIN,
+                    GEF64_LEQ_U32_MAX,
+                    std::u32::MIN as u64,
+                    std::u32::MAX as u64,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I64TruncF32U => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xbf7fffff, // -0.99999994
+                    0x5f7fffff, // 18446743000000000000.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64TruncF64U => {
+                let v1 = self.state.pop1()?.into_float_value();
+                self.trap_if_not_representable_as_int(
+                    0xbfefffffffffffff, // -0.9999999999999999
+                    0x43efffffffffffff, // 18446744073709550000.0
+                    v1,
+                );
+                let res = self
+                    .builder
+                    .build_float_to_unsigned_int(v1, self.intrinsics.i64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64TruncSatF32U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i64_ty,
+                    LEF32_GEQ_U64_MIN,
+                    GEF32_LEQ_U64_MAX,
+                    std::u64::MIN,
+                    std::u64::MAX,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::I64TruncSatF64U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_float_value();
+                let res = self.trunc_sat_scalar(
+                    self.intrinsics.i64_ty,
+                    LEF64_GEQ_U64_MIN,
+                    GEF64_LEQ_U64_MAX,
+                    std::u64::MIN,
+                    std::u64::MAX,
+                    v,
+                );
+                self.state.push1(res);
+            }
+            Operator::F32DemoteF64 => {
+                let v = self.state.pop1()?;
+                let v = v.into_float_value();
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.fptrunc_f64,
+                        &[
+                            v.into(),
+                            self.intrinsics.fp_rounding_md,
+                            self.intrinsics.fp_exception_md,
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            Operator::F64PromoteF32 => {
+                let v = self.state.pop1()?;
+                let v = v.into_float_value();
+                let res = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.fpext_f32,
+                        &[v.into(), self.intrinsics.fp_exception_md],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32ConvertI32S | Operator::F32ConvertI64S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_signed_int_to_float(v, self.intrinsics.f32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64ConvertI32S | Operator::F64ConvertI64S => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_signed_int_to_float(v, self.intrinsics.f64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32ConvertI32U | Operator::F32ConvertI64U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_unsigned_int_to_float(v, self.intrinsics.f32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64ConvertI32U | Operator::F64ConvertI64U => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let v = v.into_int_value();
+                let res = self
+                    .builder
+                    .build_unsigned_int_to_float(v, self.intrinsics.f64_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32x4ConvertI32x4S => {
+                let v = self.state.pop1()?;
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i32x4_ty, "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_signed_int_to_float(v, self.intrinsics.f32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F32x4ConvertI32x4U => {
+                let v = self.state.pop1()?;
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i32x4_ty, "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_unsigned_int_to_float(v, self.intrinsics.f32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2ConvertLowI32x4S | Operator::F64x2ConvertLowI32x4U => {
+                let extend = match op {
+                    Operator::F64x2ConvertLowI32x4U => {
+                        |s: &Self, v| s.builder.build_int_z_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    Operator::F64x2ConvertLowI32x4S => {
+                        |s: &Self, v| s.builder.build_int_s_extend(v, s.intrinsics.i64x2_ty, "")
+                    }
+                    _ => unreachable!("Unhandled inner case"),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i32x4(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                    ]),
+                    "",
+                );
+                let res = extend(self, low);
+                let res = self
+                    .builder
+                    .build_signed_int_to_float(res, self.intrinsics.f64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::F64x2PromoteLowF32x4 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f32x4(v, i);
+                let low = self.builder.build_shuffle_vector(
+                    v,
+                    v.get_type().get_undef(),
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                    ]),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_float_ext(low, self.intrinsics.f64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, ExtraInfo::pending_f64_nan());
+            }
+            Operator::F32x4DemoteF64x2Zero => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_f64x2(v, i);
+                let f32x2_ty = self.intrinsics.f32_ty.vec_type(2);
+                let res = self.builder.build_float_trunc(v, f32x2_ty, "");
+                let zeros = f32x2_ty.const_zero();
+                let res = self.builder.build_shuffle_vector(
+                    res,
+                    zeros,
+                    VectorType::const_vector(&[
+                        self.intrinsics.i32_consts[0],
+                        self.intrinsics.i32_consts[1],
+                        self.intrinsics.i32_consts[2],
+                        self.intrinsics.i32_consts[3],
+                    ]),
+                    "",
+                );
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, ExtraInfo::pending_f32_nan());
+            }
+            // Operator::F64x2ConvertI64x2S => {
+            //     let v = self.state.pop1()?;
+            //     let v = self
+            //         .builder
+            //         .build_bitcast(v, self.intrinsics.i64x2_ty, "")
+            //         .into_vector_value();
+            //     let res = self
+            //         .builder
+            //         .build_signed_int_to_float(v, self.intrinsics.f64x2_ty, "");
+            //     let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+            //     self.state.push1(res);
+            // }
+            // Operator::F64x2ConvertI64x2U => {
+            //     let v = self.state.pop1()?;
+            //     let v = self
+            //         .builder
+            //         .build_bitcast(v, self.intrinsics.i64x2_ty, "")
+            //         .into_vector_value();
+            //     let res = self
+            //         .builder
+            //         .build_unsigned_int_to_float(v, self.intrinsics.f64x2_ty, "");
+            //     let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+            //     self.state.push1(res);
+            // }
+            Operator::I32ReinterpretF32 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let ret = self.builder.build_bitcast(v, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(ret, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64ReinterpretF64 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let ret = self.builder.build_bitcast(v, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(ret, ExtraInfo::arithmetic_f64());
+            }
+            Operator::F32ReinterpretI32 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let ret = self.builder.build_bitcast(v, self.intrinsics.f32_ty, "");
+                self.state.push1_extra(ret, i);
+            }
+            Operator::F64ReinterpretI64 => {
+                let (v, i) = self.state.pop1_extra()?;
+                let ret = self.builder.build_bitcast(v, self.intrinsics.f64_ty, "");
+                self.state.push1_extra(ret, i);
+            }
+
+            /***************************
+             * Sign-extension operators.
+             * https://github.com/WebAssembly/sign-extension-ops/blob/master/proposals/sign-extension-ops/Overview.md
+             ***************************/
+            Operator::I32Extend8S => {
+                let value = self.state.pop1()?.into_int_value();
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let extended_value =
+                    self.builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                self.state.push1(extended_value);
+            }
+            Operator::I32Extend16S => {
+                let value = self.state.pop1()?.into_int_value();
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let extended_value =
+                    self.builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i32_ty, "");
+                self.state.push1(extended_value);
+            }
+            Operator::I64Extend8S => {
+                let value = self.state.pop1()?.into_int_value();
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let extended_value =
+                    self.builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                self.state.push1(extended_value);
+            }
+            Operator::I64Extend16S => {
+                let value = self.state.pop1()?.into_int_value();
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let extended_value =
+                    self.builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                self.state.push1(extended_value);
+            }
+            Operator::I64Extend32S => {
+                let value = self.state.pop1()?.into_int_value();
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let extended_value =
+                    self.builder
+                        .build_int_s_extend(narrow_value, self.intrinsics.i64_ty, "");
+                self.state.push1(extended_value);
+            }
+
+            /***************************
+             * Load and Store instructions.
+             * https://github.com/sunfishcode/wasm-reference-manual/blob/master/WebAssembly.md#load-and-store-instructions
+             ***************************/
+            Operator::I32Load { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    result.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(result);
+            }
+            Operator::I64Load { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    result.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(result);
+            }
+            Operator::F32Load { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.f32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.f32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    result.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(result);
+            }
+            Operator::F64Load { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.f64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.f64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    result.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(result);
+            }
+            Operator::V128Load { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i128_ptr_ty,
+                    offset,
+                    16,
+                )?;
+                let result =
+                    self.builder
+                        .build_load(self.intrinsics.i128_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    result.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(result);
+            }
+            Operator::V128Load8Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _i) = self.v128_into_i8x16(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let element = self
+                    .builder
+                    .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    element.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v, element, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load16Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_i16x8(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let element =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    element.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v, element, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::V128Load32Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_i32x4(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let element =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    element.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v, element, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::V128Load64Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_i64x2(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let element =
+                    self.builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    element.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v, element, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1_extra(res, i);
+            }
+
+            Operator::I32Store { ref memarg } => {
+                let value = self.state.pop1()?;
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let store = self.builder.build_store(effective_address, value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::I64Store { ref memarg } => {
+                let value = self.state.pop1()?;
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let store = self.builder.build_store(effective_address, value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::F32Store { ref memarg } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.f32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.f32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let store = self.builder.build_store(effective_address, v);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::F64Store { ref memarg } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.f64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.f64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let store = self.builder.build_store(effective_address, v);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::V128Store { ref memarg } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i128_ptr_ty,
+                    offset,
+                    16,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i128_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let store = self.builder.build_store(effective_address, v);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::V128Store8Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _i) = self.v128_into_i8x16(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let val = self.builder.build_extract_element(v, idx, "");
+                let store = self.builder.build_store(effective_address, val);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::V128Store16Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _i) = self.v128_into_i16x8(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let val = self.builder.build_extract_element(v, idx, "");
+                let store = self.builder.build_store(effective_address, val);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::V128Store32Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _i) = self.v128_into_i32x4(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let val = self.builder.build_extract_element(v, idx, "");
+                let store = self.builder.build_store(effective_address, val);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::V128Store64Lane { ref memarg, lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _i) = self.v128_into_i64x2(v, i);
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let val = self.builder.build_extract_element(v, idx, "");
+                let store = self.builder.build_store(effective_address, val);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::I32Load8S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_s_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i32_ty,
+                    "",
+                );
+                self.state.push1(result);
+            }
+            Operator::I32Load16S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_s_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i32_ty,
+                    "",
+                );
+                self.state.push1(result);
+            }
+            Operator::I64Load8S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                    .into_int_value();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result =
+                    self.builder
+                        .build_int_s_extend(narrow_result, self.intrinsics.i64_ty, "");
+                self.state.push1(result);
+            }
+            Operator::I64Load16S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                    .into_int_value();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result =
+                    self.builder
+                        .build_int_s_extend(narrow_result, self.intrinsics.i64_ty, "");
+                self.state.push1(result);
+            }
+            Operator::I64Load32S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_s_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i64_ty,
+                    "",
+                );
+                self.state.push1(result);
+            }
+
+            Operator::I32Load8U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_z_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i32_ty,
+                    "",
+                );
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32Load16U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_z_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i32_ty,
+                    "",
+                );
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64Load8U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_z_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i64_ty,
+                    "",
+                );
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64Load16U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_z_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i64_ty,
+                    "",
+                );
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64Load32U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let narrow_result =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    narrow_result.as_instruction_value().unwrap(),
+                )?;
+                let result = self.builder.build_int_z_extend(
+                    narrow_result.into_int_value(),
+                    self.intrinsics.i64_ty,
+                    "",
+                );
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+
+            Operator::I32Store8 { ref memarg } | Operator::I64Store8 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::I32Store16 { ref memarg } | Operator::I64Store16 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::I64Store32 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let dead_load =
+                    self.builder
+                        .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    dead_load.as_instruction_value().unwrap(),
+                )?;
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+            }
+            Operator::I8x16Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i32x4(v, i);
+                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I64x2Neg => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i64x2(v, i);
+                let res = self.builder.build_int_sub(v.get_type().const_zero(), v, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Not => {
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i).into_int_value();
+                let res = self.builder.build_not(v, "");
+                self.state.push1(res);
+            }
+            Operator::V128AnyTrue => {
+                // | Operator::I64x2AnyTrue
+                // Skip canonicalization, it never changes non-zero values to zero or vice versa.
+                let v = self.state.pop1()?.into_int_value();
+                let res = self.builder.build_int_compare(
+                    IntPredicate::NE,
+                    v,
+                    v.get_type().const_zero(),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16AllTrue
+            | Operator::I16x8AllTrue
+            | Operator::I32x4AllTrue
+            | Operator::I64x2AllTrue => {
+                let vec_ty = match op {
+                    Operator::I8x16AllTrue => self.intrinsics.i8x16_ty,
+                    Operator::I16x8AllTrue => self.intrinsics.i16x8_ty,
+                    Operator::I32x4AllTrue => self.intrinsics.i32x4_ty,
+                    Operator::I64x2AllTrue => self.intrinsics.i64x2_ty,
+                    _ => unreachable!(),
+                };
+                let (v, i) = self.state.pop1_extra()?;
+                let v = self.apply_pending_canonicalization(v, i).into_int_value();
+                let lane_int_ty = self.context.custom_width_int_type(vec_ty.get_size());
+                let vec = self
+                    .builder
+                    .build_bitcast(v, vec_ty, "vec")
+                    .into_vector_value();
+                let mask = self.builder.build_int_compare(
+                    IntPredicate::NE,
+                    vec,
+                    vec_ty.const_zero(),
+                    "mask",
+                );
+                let cmask = self
+                    .builder
+                    .build_bitcast(mask, lane_int_ty, "cmask")
+                    .into_int_value();
+                let res = self.builder.build_int_compare(
+                    IntPredicate::EQ,
+                    cmask,
+                    lane_int_ty.const_int(std::u64::MAX, true),
+                    "",
+                );
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(
+                    res,
+                    ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+                );
+            }
+            Operator::I8x16ExtractLaneS { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self
+                    .builder
+                    .build_extract_element(v, idx, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16ExtractLaneU { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i8x16(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self
+                    .builder
+                    .build_extract_element(v, idx, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I16x8ExtractLaneS { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self
+                    .builder
+                    .build_extract_element(v, idx, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ExtractLaneU { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, _) = self.v128_into_i16x8(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self
+                    .builder
+                    .build_extract_element(v, idx, "")
+                    .into_int_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(res, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(res, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32x4ExtractLane { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_i32x4(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_extract_element(v, idx, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::I64x2ExtractLane { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_i64x2(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_extract_element(v, idx, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::F32x4ExtractLane { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_f32x4(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_extract_element(v, idx, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::F64x2ExtractLane { lane } => {
+                let (v, i) = self.state.pop1_extra()?;
+                let (v, i) = self.v128_into_f64x2(v, i);
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_extract_element(v, idx, "");
+                self.state.push1_extra(res, i);
+            }
+            Operator::I8x16ReplaceLane { lane } => {
+                let ((v1, i1), (v2, _)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i8x16(v1, i1);
+                let v2 = v2.into_int_value();
+                let v2 = self.builder.build_int_cast(v2, self.intrinsics.i8_ty, "");
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I16x8ReplaceLane { lane } => {
+                let ((v1, i1), (v2, _)) = self.state.pop2_extra()?;
+                let (v1, _) = self.v128_into_i16x8(v1, i1);
+                let v2 = v2.into_int_value();
+                let v2 = self.builder.build_int_cast(v2, self.intrinsics.i16_ty, "");
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I32x4ReplaceLane { lane } => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_i32x4(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let i2 = i2.strip_pending();
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i1 & i2 & ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64x2ReplaceLane { lane } => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_i64x2(v1, i1);
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = v2.into_int_value();
+                let i2 = i2.strip_pending();
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state
+                    .push1_extra(res, i1 & i2 & ExtraInfo::arithmetic_f64());
+            }
+            Operator::F32x4ReplaceLane { lane } => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f32x4(v1, i1);
+                let push_pending_f32_nan_to_result =
+                    i1.has_pending_f32_nan() && i2.has_pending_f32_nan();
+                let (v1, v2) = if !push_pending_f32_nan_to_result {
+                    (
+                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)
+                            .into_vector_value(),
+                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)
+                            .into_float_value(),
+                    )
+                } else {
+                    (v1, v2.into_float_value())
+                };
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let info = if push_pending_f32_nan_to_result {
+                    ExtraInfo::pending_f32_nan()
+                } else {
+                    i1.strip_pending() & i2.strip_pending()
+                };
+                self.state.push1_extra(res, info);
+            }
+            Operator::F64x2ReplaceLane { lane } => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let (v1, i1) = self.v128_into_f64x2(v1, i1);
+                let push_pending_f64_nan_to_result =
+                    i1.has_pending_f64_nan() && i2.has_pending_f64_nan();
+                let (v1, v2) = if !push_pending_f64_nan_to_result {
+                    (
+                        self.apply_pending_canonicalization(v1.as_basic_value_enum(), i1)
+                            .into_vector_value(),
+                        self.apply_pending_canonicalization(v2.as_basic_value_enum(), i2)
+                            .into_float_value(),
+                    )
+                } else {
+                    (v1, v2.into_float_value())
+                };
+                let idx = self.intrinsics.i32_ty.const_int(lane.into(), false);
+                let res = self.builder.build_insert_element(v1, v2, idx, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                let info = if push_pending_f64_nan_to_result {
+                    ExtraInfo::pending_f64_nan()
+                } else {
+                    i1.strip_pending() & i2.strip_pending()
+                };
+                self.state.push1_extra(res, info);
+            }
+            Operator::I8x16Swizzle => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v1 = self
+                    .builder
+                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
+                    .into_vector_value();
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = self
+                    .builder
+                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
+                    .into_vector_value();
+                let lanes = self.intrinsics.i8_ty.const_int(16, false);
+                let lanes =
+                    self.splat_vector(lanes.as_basic_value_enum(), self.intrinsics.i8x16_ty);
+                let mut res = self.intrinsics.i8x16_ty.get_undef();
+                let idx_out_of_range = self.builder.build_int_compare(
+                    IntPredicate::UGE,
+                    v2,
+                    lanes,
+                    "idx_out_of_range",
+                );
+                let idx_clamped = self
+                    .builder
+                    .build_select(
+                        idx_out_of_range,
+                        self.intrinsics.i8x16_ty.const_zero(),
+                        v2,
+                        "idx_clamped",
+                    )
+                    .into_vector_value();
+                for i in 0..16 {
+                    let idx = self
+                        .builder
+                        .build_extract_element(
+                            idx_clamped,
+                            self.intrinsics.i32_ty.const_int(i, false),
+                            "idx",
+                        )
+                        .into_int_value();
+                    let replace_with_zero = self
+                        .builder
+                        .build_extract_element(
+                            idx_out_of_range,
+                            self.intrinsics.i32_ty.const_int(i, false),
+                            "replace_with_zero",
+                        )
+                        .into_int_value();
+                    let elem = self
+                        .builder
+                        .build_extract_element(v1, idx, "elem")
+                        .into_int_value();
+                    let elem_or_zero = self.builder.build_select(
+                        replace_with_zero,
+                        self.intrinsics.i8_zero,
+                        elem,
+                        "elem_or_zero",
+                    );
+                    res = self.builder.build_insert_element(
+                        res,
+                        elem_or_zero,
+                        self.intrinsics.i32_ty.const_int(i, false),
+                        "",
+                    );
+                }
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::I8x16Shuffle { lanes } => {
+                let ((v1, i1), (v2, i2)) = self.state.pop2_extra()?;
+                let v1 = self.apply_pending_canonicalization(v1, i1);
+                let v1 = self
+                    .builder
+                    .build_bitcast(v1, self.intrinsics.i8x16_ty, "")
+                    .into_vector_value();
+                let v2 = self.apply_pending_canonicalization(v2, i2);
+                let v2 = self
+                    .builder
+                    .build_bitcast(v2, self.intrinsics.i8x16_ty, "")
+                    .into_vector_value();
+                let mask = VectorType::const_vector(
+                    lanes
+                        .iter()
+                        .map(|l| self.intrinsics.i32_ty.const_int((*l).into(), false))
+                        .collect::<Vec<IntValue>>()
+                        .as_slice(),
+                );
+                let res = self.builder.build_shuffle_vector(v1, v2, mask, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load8x8S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i8_ty.vec_type(8), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(v, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load8x8U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i8_ty.vec_type(8), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i16x8_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load16x4S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i16_ty.vec_type(4), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(v, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load16x4U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i16_ty.vec_type(4), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i32x4_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load32x2S { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i32_ty.vec_type(2), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_s_extend(v, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load32x2U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let v = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let v = self
+                    .builder
+                    .build_bitcast(v, self.intrinsics.i32_ty.vec_type(2), "")
+                    .into_vector_value();
+                let res = self
+                    .builder
+                    .build_int_z_extend(v, self.intrinsics.i64x2_ty, "");
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load32Zero { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.builder.build_int_z_extend(
+                    elem.into_int_value(),
+                    self.intrinsics.i128_ty,
+                    "",
+                );
+                self.state.push1(res);
+            }
+            Operator::V128Load64Zero { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.builder.build_int_z_extend(
+                    elem.into_int_value(),
+                    self.intrinsics.i128_ty,
+                    "",
+                );
+                self.state.push1(res);
+            }
+            Operator::V128Load8Splat { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i8_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.splat_vector(elem, self.intrinsics.i8x16_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load16Splat { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i16_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.splat_vector(elem, self.intrinsics.i16x8_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load32Splat { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.splat_vector(elem, self.intrinsics.i32x4_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::V128Load64Splat { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                let elem = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    1,
+                    elem.as_instruction_value().unwrap(),
+                )?;
+                let res = self.splat_vector(elem, self.intrinsics.i64x2_ty);
+                let res = self.builder.build_bitcast(res, self.intrinsics.i128_ty, "");
+                self.state.push1(res);
+            }
+            Operator::AtomicFence => {
+                // Fence is a nop.
+                //
+                // Fence was added to preserve information about fences from
+                // source languages. If in the future Wasm extends the memory
+                // model, and if we hadn't recorded what fences used to be there,
+                // it would lead to data races that weren't present in the
+                // original source language.
+            }
+            Operator::I32AtomicLoad { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.i32_ty, effective_address, "");
+                let load = result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 4, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                self.state.push1(result);
+            }
+            Operator::I64AtomicLoad { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let result = self
+                    .builder
+                    .build_load(self.intrinsics.i64_ty, effective_address, "");
+                let load = result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 8, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                self.state.push1(result);
+            }
+            Operator::I32AtomicLoad8U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                    .into_int_value();
+                let load = narrow_result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 1, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                let result =
+                    self.builder
+                        .build_int_z_extend(narrow_result, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicLoad16U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                    .into_int_value();
+                let load = narrow_result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 2, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                let result =
+                    self.builder
+                        .build_int_z_extend(narrow_result, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64AtomicLoad8U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i8_ty, effective_address, "")
+                    .into_int_value();
+                let load = narrow_result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 1, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                let result =
+                    self.builder
+                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicLoad16U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i16_ty, effective_address, "")
+                    .into_int_value();
+                let load = narrow_result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 2, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                let result =
+                    self.builder
+                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicLoad32U { ref memarg } => {
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_result = self
+                    .builder
+                    .build_load(self.intrinsics.i32_ty, effective_address, "")
+                    .into_int_value();
+                let load = narrow_result.as_instruction_value().unwrap();
+                self.annotate_user_memaccess(memory_index, memarg, 4, load)?;
+                load.set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+                let result =
+                    self.builder
+                        .build_int_z_extend(narrow_result, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(result, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I32AtomicStore { ref memarg } => {
+                let value = self.state.pop1()?;
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let store = self.builder.build_store(effective_address, value);
+                self.annotate_user_memaccess(memory_index, memarg, 4, store)?;
+                store
+                    .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+            }
+            Operator::I64AtomicStore { ref memarg } => {
+                let value = self.state.pop1()?;
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let store = self.builder.build_store(effective_address, value);
+                self.annotate_user_memaccess(memory_index, memarg, 8, store)?;
+                store
+                    .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+            }
+            Operator::I32AtomicStore8 { ref memarg } | Operator::I64AtomicStore8 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 1, store)?;
+                store
+                    .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+            }
+            Operator::I32AtomicStore16 { ref memarg }
+            | Operator::I64AtomicStore16 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 2, store)?;
+                store
+                    .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+            }
+            Operator::I64AtomicStore32 { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let store = self.builder.build_store(effective_address, narrow_value);
+                self.annotate_user_memaccess(memory_index, memarg, 4, store)?;
+                store
+                    .set_atomic_ordering(AtomicOrdering::SequentiallyConsistent)
+                    .unwrap();
+            }
+            Operator::I32AtomicRmw8AddU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("memory {}", memory_index.as_u32()),
+                    old.as_instruction_value().unwrap(),
+                );
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16AddU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("memory {}", memory_index.as_u32()),
+                    old.as_instruction_value().unwrap(),
+                );
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwAdd { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                tbaa_label(
+                    self.module,
+                    self.intrinsics,
+                    format!("memory {}", memory_index.as_u32()),
+                    old.as_instruction_value().unwrap(),
+                );
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8AddU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16AddU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32AddU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwAdd { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Add,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8SubU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16SubU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwSub { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8SubU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64AtomicRmw16SubU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32SubU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwSub { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Sub,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8AndU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16AndU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwAnd { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8AndU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16AndU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32AndU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwAnd { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::And,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8OrU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16OrU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwOr { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I64AtomicRmw8OrU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16OrU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32OrU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwOr { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Or,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8XorU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16XorU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwXor { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8XorU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16XorU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32XorU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwXor { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xor,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8XchgU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16XchgU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwXchg { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8XchgU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16XchgU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32XchgU { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_value =
+                    self.builder
+                        .build_int_truncate(value, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        narrow_value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwXchg { ref memarg } => {
+                let value = self.state.pop1()?.into_int_value();
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_atomicrmw(
+                        AtomicRMWBinOp::Xchg,
+                        effective_address,
+                        value,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                self.state.push1(old);
+            }
+            Operator::I32AtomicRmw8CmpxchgU { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_cmp = self
+                    .builder
+                    .build_int_truncate(cmp, self.intrinsics.i8_ty, "");
+                let narrow_new = self
+                    .builder
+                    .build_int_truncate(new, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        narrow_cmp,
+                        narrow_new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_extract_value(old, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmw16CmpxchgU { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_cmp = self
+                    .builder
+                    .build_int_truncate(cmp, self.intrinsics.i16_ty, "");
+                let narrow_new = self
+                    .builder
+                    .build_int_truncate(new, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        narrow_cmp,
+                        narrow_new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_extract_value(old, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i32_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f32());
+            }
+            Operator::I32AtomicRmwCmpxchg { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        cmp,
+                        new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self.builder.build_extract_value(old, 0, "").unwrap();
+                self.state.push1(old);
+            }
+            Operator::I64AtomicRmw8CmpxchgU { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i8_ptr_ty,
+                    offset,
+                    1,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 1);
+                let narrow_cmp = self
+                    .builder
+                    .build_int_truncate(cmp, self.intrinsics.i8_ty, "");
+                let narrow_new = self
+                    .builder
+                    .build_int_truncate(new, self.intrinsics.i8_ty, "");
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        narrow_cmp,
+                        narrow_new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_extract_value(old, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw16CmpxchgU { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i16_ptr_ty,
+                    offset,
+                    2,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 2);
+                let narrow_cmp = self
+                    .builder
+                    .build_int_truncate(cmp, self.intrinsics.i16_ty, "");
+                let narrow_new = self
+                    .builder
+                    .build_int_truncate(new, self.intrinsics.i16_ty, "");
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        narrow_cmp,
+                        narrow_new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_extract_value(old, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmw32CmpxchgU { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i32_ptr_ty,
+                    offset,
+                    4,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 4);
+                let narrow_cmp = self
+                    .builder
+                    .build_int_truncate(cmp, self.intrinsics.i32_ty, "");
+                let narrow_new = self
+                    .builder
+                    .build_int_truncate(new, self.intrinsics.i32_ty, "");
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        narrow_cmp,
+                        narrow_new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self
+                    .builder
+                    .build_extract_value(old, 0, "")
+                    .unwrap()
+                    .into_int_value();
+                let old = self
+                    .builder
+                    .build_int_z_extend(old, self.intrinsics.i64_ty, "");
+                self.state.push1_extra(old, ExtraInfo::arithmetic_f64());
+            }
+            Operator::I64AtomicRmwCmpxchg { ref memarg } => {
+                let ((cmp, cmp_info), (new, new_info)) = self.state.pop2_extra()?;
+                let cmp = self.apply_pending_canonicalization(cmp, cmp_info);
+                let new = self.apply_pending_canonicalization(new, new_info);
+                let (cmp, new) = (cmp.into_int_value(), new.into_int_value());
+                let offset = self.state.pop1()?.into_int_value();
+                let memory_index = MemoryIndex::from_u32(0);
+                let effective_address = self.resolve_memory_ptr(
+                    memory_index,
+                    memarg,
+                    self.intrinsics.i64_ptr_ty,
+                    offset,
+                    8,
+                )?;
+                self.trap_if_misaligned(memarg, effective_address, 8);
+                let old = self
+                    .builder
+                    .build_cmpxchg(
+                        effective_address,
+                        cmp,
+                        new,
+                        AtomicOrdering::SequentiallyConsistent,
+                        AtomicOrdering::SequentiallyConsistent,
+                    )
+                    .unwrap();
+                self.annotate_user_memaccess(
+                    memory_index,
+                    memarg,
+                    0,
+                    old.as_instruction_value().unwrap(),
+                )?;
+                let old = self.builder.build_extract_value(old, 0, "").unwrap();
+                self.state.push1(old);
+            }
+
+            Operator::MemoryGrow { mem, mem_byte: _ } => {
+                let memory_index = MemoryIndex::from_u32(mem);
+                let delta = self.state.pop1()?;
+                let grow_fn_ptr = self.ctx.memory_grow(memory_index, self.intrinsics);
+                let grow = self.builder.build_indirect_call(
+                    self.intrinsics.memory_grow_ty,
+                    grow_fn_ptr,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        delta.into(),
+                        self.intrinsics.i32_ty.const_int(mem.into(), false).into(),
+                    ],
+                    "",
+                );
+                self.state.push1(grow.try_as_basic_value().left().unwrap());
+            }
+            Operator::MemorySize { mem, mem_byte: _ } => {
+                let memory_index = MemoryIndex::from_u32(mem);
+                let size_fn_ptr = self.ctx.memory_size(memory_index, self.intrinsics);
+                let size = self.builder.build_indirect_call(
+                    self.intrinsics.memory_size_ty,
+                    size_fn_ptr,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        self.intrinsics.i32_ty.const_int(mem.into(), false).into(),
+                    ],
+                    "",
+                );
+                size.add_attribute(AttributeLoc::Function, self.intrinsics.readonly);
+                self.state.push1(size.try_as_basic_value().left().unwrap());
+            }
+            Operator::MemoryInit { data_index, mem } => {
+                let (dest, src, len) = self.state.pop3()?;
+                let mem = self.intrinsics.i32_ty.const_int(mem.into(), false);
+                let segment = self.intrinsics.i32_ty.const_int(data_index.into(), false);
+                self.builder.build_call(
+                    self.intrinsics.memory_init,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        mem.into(),
+                        segment.into(),
+                        dest.into(),
+                        src.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::DataDrop { data_index } => {
+                let segment = self.intrinsics.i32_ty.const_int(data_index.into(), false);
+                self.builder.build_call(
+                    self.intrinsics.data_drop,
+                    &[vmctx.as_basic_value_enum().into(), segment.into()],
+                    "",
+                );
+            }
+            Operator::MemoryCopy { dst_mem, src_mem } => {
+                // ignored until we support multiple memories
+                let _dst = dst_mem;
+                let (memory_copy, src) = if let Some(local_memory_index) = self
+                    .wasm_module
+                    .local_memory_index(MemoryIndex::from_u32(src_mem))
+                {
+                    (self.intrinsics.memory_copy, local_memory_index.as_u32())
+                } else {
+                    (self.intrinsics.imported_memory_copy, src_mem)
+                };
+
+                let (dest_pos, src_pos, len) = self.state.pop3()?;
+                let src_index = self.intrinsics.i32_ty.const_int(src.into(), false);
+                self.builder.build_call(
+                    memory_copy,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        src_index.into(),
+                        dest_pos.into(),
+                        src_pos.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::MemoryFill { mem } => {
+                let (memory_fill, mem) = if let Some(local_memory_index) = self
+                    .wasm_module
+                    .local_memory_index(MemoryIndex::from_u32(mem))
+                {
+                    (self.intrinsics.memory_fill, local_memory_index.as_u32())
+                } else {
+                    (self.intrinsics.imported_memory_fill, mem)
+                };
+
+                let (dst, val, len) = self.state.pop3()?;
+                let mem_index = self.intrinsics.i32_ty.const_int(mem.into(), false);
+                self.builder.build_call(
+                    memory_fill,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        mem_index.into(),
+                        dst.into(),
+                        val.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            /***************************
+             * Reference types.
+             * https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md
+             ***************************/
+            Operator::RefNull { hty } => {
+                let ty = wpheaptype_to_type(hty).map_err(to_compile_error)?;
+                let ty = type_to_llvm(self.intrinsics, ty)?;
+                self.state.push1(ty.const_zero());
+            }
+            Operator::RefIsNull => {
+                let value = self.state.pop1()?.into_pointer_value();
+                let is_null = self.builder.build_is_null(value, "");
+                let is_null = self
+                    .builder
+                    .build_int_z_extend(is_null, self.intrinsics.i32_ty, "");
+                self.state.push1(is_null);
+            }
+            Operator::RefFunc { function_index } => {
+                let index = self
+                    .intrinsics
+                    .i32_ty
+                    .const_int(function_index.into(), false);
+                let value = self
+                    .builder
+                    .build_call(
+                        self.intrinsics.func_ref,
+                        &[self.ctx.basic().into(), index.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1(value);
+            }
+            Operator::TableGet { table } => {
+                let table_index = self.intrinsics.i32_ty.const_int(table.into(), false);
+                let elem = self.state.pop1()?;
+                let table_get = if self
+                    .wasm_module
+                    .local_table_index(TableIndex::from_u32(table))
+                    .is_some()
+                {
+                    self.intrinsics.table_get
+                } else {
+                    self.intrinsics.imported_table_get
+                };
+                let value = self
+                    .builder
+                    .build_call(
+                        table_get,
+                        &[self.ctx.basic().into(), table_index.into(), elem.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                let value = self.builder.build_bitcast(
+                    value,
+                    type_to_llvm(
+                        self.intrinsics,
+                        self.wasm_module
+                            .tables
+                            .get(TableIndex::from_u32(table))
+                            .unwrap()
+                            .ty,
+                    )?,
+                    "",
+                );
+                self.state.push1(value);
+            }
+            Operator::TableSet { table } => {
+                let table_index = self.intrinsics.i32_ty.const_int(table.into(), false);
+                let (elem, value) = self.state.pop2()?;
+                let value = self
+                    .builder
+                    .build_bitcast(value, self.intrinsics.anyref_ty, "");
+                let table_set = if self
+                    .wasm_module
+                    .local_table_index(TableIndex::from_u32(table))
+                    .is_some()
+                {
+                    self.intrinsics.table_set
+                } else {
+                    self.intrinsics.imported_table_set
+                };
+                self.builder.build_call(
+                    table_set,
+                    &[
+                        self.ctx.basic().into(),
+                        table_index.into(),
+                        elem.into(),
+                        value.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::TableCopy {
+                dst_table,
+                src_table,
+            } => {
+                let (dst, src, len) = self.state.pop3()?;
+                let dst_table = self.intrinsics.i32_ty.const_int(dst_table as u64, false);
+                let src_table = self.intrinsics.i32_ty.const_int(src_table as u64, false);
+                self.builder.build_call(
+                    self.intrinsics.table_copy,
+                    &[
+                        self.ctx.basic().into(),
+                        dst_table.into(),
+                        src_table.into(),
+                        dst.into(),
+                        src.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::TableInit { elem_index, table } => {
+                let (dst, src, len) = self.state.pop3()?;
+                let segment = self.intrinsics.i32_ty.const_int(elem_index as u64, false);
+                let table = self.intrinsics.i32_ty.const_int(table as u64, false);
+                self.builder.build_call(
+                    self.intrinsics.table_init,
+                    &[
+                        self.ctx.basic().into(),
+                        table.into(),
+                        segment.into(),
+                        dst.into(),
+                        src.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::ElemDrop { elem_index } => {
+                let segment = self.intrinsics.i32_ty.const_int(elem_index as u64, false);
+                self.builder.build_call(
+                    self.intrinsics.elem_drop,
+                    &[self.ctx.basic().into(), segment.into()],
+                    "",
+                );
+            }
+            Operator::TableFill { table } => {
+                let table = self.intrinsics.i32_ty.const_int(table as u64, false);
+                let (start, elem, len) = self.state.pop3()?;
+                let elem = self
+                    .builder
+                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
+                self.builder.build_call(
+                    self.intrinsics.table_fill,
+                    &[
+                        self.ctx.basic().into(),
+                        table.into(),
+                        start.into(),
+                        elem.into(),
+                        len.into(),
+                    ],
+                    "",
+                );
+            }
+            Operator::TableGrow { table } => {
+                let (elem, delta) = self.state.pop2()?;
+                let elem = self
+                    .builder
+                    .build_bitcast(elem, self.intrinsics.anyref_ty, "");
+                let (table_grow, table_index) = if let Some(local_table_index) = self
+                    .wasm_module
+                    .local_table_index(TableIndex::from_u32(table))
+                {
+                    (self.intrinsics.table_grow, local_table_index.as_u32())
+                } else {
+                    (self.intrinsics.imported_table_grow, table)
+                };
+                let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
+                let size = self
+                    .builder
+                    .build_call(
+                        table_grow,
+                        &[
+                            self.ctx.basic().into(),
+                            elem.into(),
+                            delta.into(),
+                            table_index.into(),
+                        ],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1(size);
+            }
+            Operator::TableSize { table } => {
+                let (table_size, table_index) = if let Some(local_table_index) = self
+                    .wasm_module
+                    .local_table_index(TableIndex::from_u32(table))
+                {
+                    (self.intrinsics.table_size, local_table_index.as_u32())
+                } else {
+                    (self.intrinsics.imported_table_size, table)
+                };
+                let table_index = self.intrinsics.i32_ty.const_int(table_index as u64, false);
+                let size = self
+                    .builder
+                    .build_call(
+                        table_size,
+                        &[self.ctx.basic().into(), table_index.into()],
+                        "",
+                    )
+                    .try_as_basic_value()
+                    .left()
+                    .unwrap();
+                self.state.push1(size);
+            }
+            Operator::MemoryAtomicWait32 { memarg } => {
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let (dst, val, timeout) = self.state.pop3()?;
+                let wait32_fn_ptr = self.ctx.memory_wait32(memory_index, self.intrinsics);
+                let ret = self.builder.build_indirect_call(
+                    self.intrinsics.memory_wait32_ty,
+                    wait32_fn_ptr,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        self.intrinsics
+                            .i32_ty
+                            .const_int(memarg.memory as u64, false)
+                            .into(),
+                        dst.into(),
+                        val.into(),
+                        timeout.into(),
+                    ],
+                    "",
+                );
+                self.state.push1(ret.try_as_basic_value().left().unwrap());
+            }
+            Operator::MemoryAtomicWait64 { memarg } => {
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let (dst, val, timeout) = self.state.pop3()?;
+                let wait64_fn_ptr = self.ctx.memory_wait64(memory_index, self.intrinsics);
+                let ret = self.builder.build_indirect_call(
+                    self.intrinsics.memory_wait64_ty,
+                    wait64_fn_ptr,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        self.intrinsics
+                            .i32_ty
+                            .const_int(memarg.memory as u64, false)
+                            .into(),
+                        dst.into(),
+                        val.into(),
+                        timeout.into(),
+                    ],
+                    "",
+                );
+                self.state.push1(ret.try_as_basic_value().left().unwrap());
+            }
+            Operator::MemoryAtomicNotify { memarg } => {
+                let memory_index = MemoryIndex::from_u32(memarg.memory);
+                let (dst, count) = self.state.pop2()?;
+                let notify_fn_ptr = self.ctx.memory_notify(memory_index, self.intrinsics);
+                let cnt = self.builder.build_indirect_call(
+                    self.intrinsics.memory_notify_ty,
+                    notify_fn_ptr,
+                    &[
+                        vmctx.as_basic_value_enum().into(),
+                        self.intrinsics
+                            .i32_ty
+                            .const_int(memarg.memory as u64, false)
+                            .into(),
+                        dst.into(),
+                        count.into(),
+                    ],
+                    "",
+                );
+                self.state.push1(cnt.try_as_basic_value().left().unwrap());
+            }
+            _ => {
+                return Err(CompileError::Codegen(format!(
+                    "Operator {:?} unimplemented",
+                    op
+                )));
+            }
+        }
+
+        Ok(())
+    }
+}
+
+fn is_f32_arithmetic(bits: u32) -> bool {
+    // Mask off sign bit.
+    let bits = bits & 0x7FFF_FFFF;
+    bits < 0x7FC0_0000
+}
+
+fn is_f64_arithmetic(bits: u64) -> bool {
+    // Mask off sign bit.
+    let bits = bits & 0x7FFF_FFFF_FFFF_FFFF;
+    bits < 0x7FF8_0000_0000_0000
+}
+
+// Constants for the bounds of truncation operations. These are the least or
+// greatest exact floats in either f32 or f64 representation
+// greater-than-or-equal-to (for least) or less-than-or-equal-to (for greatest)
+// the i32 or i64 or u32 or u64 min (for least) or max (for greatest), when
+// rounding towards zero.
+
+/// Least Exact Float (32 bits) greater-than-or-equal-to i32::MIN when rounding towards zero.
+const LEF32_GEQ_I32_MIN: u64 = std::i32::MIN as u64;
+/// Greatest Exact Float (32 bits) less-than-or-equal-to i32::MAX when rounding towards zero.
+const GEF32_LEQ_I32_MAX: u64 = 2147483520; // bits as f32: 0x4eff_ffff
+/// Least Exact Float (64 bits) greater-than-or-equal-to i32::MIN when rounding towards zero.
+const LEF64_GEQ_I32_MIN: u64 = std::i32::MIN as u64;
+/// Greatest Exact Float (64 bits) less-than-or-equal-to i32::MAX when rounding towards zero.
+const GEF64_LEQ_I32_MAX: u64 = std::i32::MAX as u64;
+/// Least Exact Float (32 bits) greater-than-or-equal-to u32::MIN when rounding towards zero.
+const LEF32_GEQ_U32_MIN: u64 = std::u32::MIN as u64;
+/// Greatest Exact Float (32 bits) less-than-or-equal-to u32::MAX when rounding towards zero.
+const GEF32_LEQ_U32_MAX: u64 = 4294967040; // bits as f32: 0x4f7f_ffff
+/// Least Exact Float (64 bits) greater-than-or-equal-to u32::MIN when rounding towards zero.
+const LEF64_GEQ_U32_MIN: u64 = std::u32::MIN as u64;
+/// Greatest Exact Float (64 bits) less-than-or-equal-to u32::MAX when rounding towards zero.
+const GEF64_LEQ_U32_MAX: u64 = 4294967295; // bits as f64: 0x41ef_ffff_ffff_ffff
+/// Least Exact Float (32 bits) greater-than-or-equal-to i64::MIN when rounding towards zero.
+const LEF32_GEQ_I64_MIN: u64 = std::i64::MIN as u64;
+/// Greatest Exact Float (32 bits) less-than-or-equal-to i64::MAX when rounding towards zero.
+const GEF32_LEQ_I64_MAX: u64 = 9223371487098961920; // bits as f32: 0x5eff_ffff
+/// Least Exact Float (64 bits) greater-than-or-equal-to i64::MIN when rounding towards zero.
+const LEF64_GEQ_I64_MIN: u64 = std::i64::MIN as u64;
+/// Greatest Exact Float (64 bits) less-than-or-equal-to i64::MAX when rounding towards zero.
+const GEF64_LEQ_I64_MAX: u64 = 9223372036854774784; // bits as f64: 0x43df_ffff_ffff_ffff
+/// Least Exact Float (32 bits) greater-than-or-equal-to u64::MIN when rounding towards zero.
+const LEF32_GEQ_U64_MIN: u64 = std::u64::MIN;
+/// Greatest Exact Float (32 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
+const GEF32_LEQ_U64_MAX: u64 = 18446742974197923840; // bits as f32: 0x5f7f_ffff
+/// Least Exact Float (64 bits) greater-than-or-equal-to u64::MIN when rounding towards zero.
+const LEF64_GEQ_U64_MIN: u64 = std::u64::MIN;
+/// Greatest Exact Float (64 bits) less-than-or-equal-to u64::MAX when rounding towards zero.
+const GEF64_LEQ_U64_MAX: u64 = 18446744073709549568; // bits as f64: 0x43ef_ffff_ffff_ffff
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/intrinsics.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/intrinsics.rs
new file mode 100644
index 0000000..f1f7346
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/intrinsics.rs
@@ -0,0 +1,2120 @@
+//! Code for dealing with [LLVM][llvm-intrinsics] and VM intrinsics.
+//!
+//! VM intrinsics are used to interact with the host VM.
+//!
+//! [llvm-intrinsics]: https://llvm.org/docs/LangRef.html#intrinsic-functions
+
+use crate::abi::Abi;
+use inkwell::values::BasicMetadataValueEnum;
+use inkwell::{
+    attributes::{Attribute, AttributeLoc},
+    builder::Builder,
+    context::Context,
+    module::{Linkage, Module},
+    targets::TargetData,
+    types::{
+        BasicMetadataTypeEnum, BasicType, BasicTypeEnum, FloatType, FunctionType, IntType,
+        PointerType, StructType, VectorType, VoidType,
+    },
+    values::{
+        BasicValue, BasicValueEnum, FloatValue, FunctionValue, InstructionValue, IntValue,
+        PointerValue, VectorValue,
+    },
+    AddressSpace,
+};
+use std::collections::{hash_map::Entry, HashMap};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{
+    CompileError, FunctionIndex, FunctionType as FuncType, GlobalIndex, LocalFunctionIndex,
+    MemoryIndex, ModuleInfo as WasmerCompilerModule, Mutability, SignatureIndex, TableIndex, Type,
+};
+use wasmer_vm::{MemoryStyle, TrapCode, VMBuiltinFunctionIndex, VMOffsets};
+
+pub fn type_to_llvm_ptr<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    ty: Type,
+) -> Result<PointerType<'ctx>, CompileError> {
+    match ty {
+        Type::I32 => Ok(intrinsics.i32_ptr_ty),
+        Type::I64 => Ok(intrinsics.i64_ptr_ty),
+        Type::F32 => Ok(intrinsics.f32_ptr_ty),
+        Type::F64 => Ok(intrinsics.f64_ptr_ty),
+        Type::V128 => Ok(intrinsics.i128_ptr_ty),
+        Type::FuncRef => Ok(intrinsics.funcref_ty.ptr_type(AddressSpace::default())),
+        Type::ExternRef => Ok(intrinsics.externref_ty.ptr_type(AddressSpace::default())),
+    }
+}
+
+pub fn type_to_llvm<'ctx>(
+    intrinsics: &Intrinsics<'ctx>,
+    ty: Type,
+) -> Result<BasicTypeEnum<'ctx>, CompileError> {
+    match ty {
+        Type::I32 => Ok(intrinsics.i32_ty.as_basic_type_enum()),
+        Type::I64 => Ok(intrinsics.i64_ty.as_basic_type_enum()),
+        Type::F32 => Ok(intrinsics.f32_ty.as_basic_type_enum()),
+        Type::F64 => Ok(intrinsics.f64_ty.as_basic_type_enum()),
+        Type::V128 => Ok(intrinsics.i128_ty.as_basic_type_enum()),
+        Type::FuncRef => Ok(intrinsics.funcref_ty.as_basic_type_enum()),
+        Type::ExternRef => Ok(intrinsics.externref_ty.as_basic_type_enum()),
+    }
+}
+
+/// Struct containing LLVM and VM intrinsics.
+pub struct Intrinsics<'ctx> {
+    pub ctlz_i32: FunctionValue<'ctx>,
+    pub ctlz_i64: FunctionValue<'ctx>,
+
+    pub cttz_i32: FunctionValue<'ctx>,
+    pub cttz_i64: FunctionValue<'ctx>,
+
+    pub ctpop_i32: FunctionValue<'ctx>,
+    pub ctpop_i64: FunctionValue<'ctx>,
+    pub ctpop_i8x16: FunctionValue<'ctx>,
+
+    pub fp_rounding_md: BasicMetadataValueEnum<'ctx>,
+    pub fp_exception_md: BasicMetadataValueEnum<'ctx>,
+    pub fp_ogt_md: BasicMetadataValueEnum<'ctx>,
+    pub fp_olt_md: BasicMetadataValueEnum<'ctx>,
+    pub fp_uno_md: BasicMetadataValueEnum<'ctx>,
+
+    pub add_f32: FunctionValue<'ctx>,
+    pub add_f64: FunctionValue<'ctx>,
+    pub add_f32x4: FunctionValue<'ctx>,
+    pub add_f64x2: FunctionValue<'ctx>,
+
+    pub sub_f32: FunctionValue<'ctx>,
+    pub sub_f64: FunctionValue<'ctx>,
+    pub sub_f32x4: FunctionValue<'ctx>,
+    pub sub_f64x2: FunctionValue<'ctx>,
+
+    pub mul_f32: FunctionValue<'ctx>,
+    pub mul_f64: FunctionValue<'ctx>,
+    pub mul_f32x4: FunctionValue<'ctx>,
+    pub mul_f64x2: FunctionValue<'ctx>,
+
+    pub div_f32: FunctionValue<'ctx>,
+    pub div_f64: FunctionValue<'ctx>,
+    pub div_f32x4: FunctionValue<'ctx>,
+    pub div_f64x2: FunctionValue<'ctx>,
+
+    pub sqrt_f32: FunctionValue<'ctx>,
+    pub sqrt_f64: FunctionValue<'ctx>,
+    pub sqrt_f32x4: FunctionValue<'ctx>,
+    pub sqrt_f64x2: FunctionValue<'ctx>,
+
+    pub cmp_f32: FunctionValue<'ctx>,
+    pub cmp_f64: FunctionValue<'ctx>,
+    pub cmp_f32x4: FunctionValue<'ctx>,
+    pub cmp_f64x2: FunctionValue<'ctx>,
+
+    pub ceil_f32: FunctionValue<'ctx>,
+    pub ceil_f64: FunctionValue<'ctx>,
+    pub ceil_f32x4: FunctionValue<'ctx>,
+    pub ceil_f64x2: FunctionValue<'ctx>,
+
+    pub floor_f32: FunctionValue<'ctx>,
+    pub floor_f64: FunctionValue<'ctx>,
+    pub floor_f32x4: FunctionValue<'ctx>,
+    pub floor_f64x2: FunctionValue<'ctx>,
+
+    pub trunc_f32: FunctionValue<'ctx>,
+    pub trunc_f64: FunctionValue<'ctx>,
+    pub trunc_f32x4: FunctionValue<'ctx>,
+    pub trunc_f64x2: FunctionValue<'ctx>,
+
+    pub fpext_f32: FunctionValue<'ctx>,
+    pub fptrunc_f64: FunctionValue<'ctx>,
+
+    pub nearbyint_f32: FunctionValue<'ctx>,
+    pub nearbyint_f64: FunctionValue<'ctx>,
+    pub nearbyint_f32x4: FunctionValue<'ctx>,
+    pub nearbyint_f64x2: FunctionValue<'ctx>,
+
+    pub fabs_f32: FunctionValue<'ctx>,
+    pub fabs_f64: FunctionValue<'ctx>,
+    pub fabs_f32x4: FunctionValue<'ctx>,
+    pub fabs_f64x2: FunctionValue<'ctx>,
+
+    pub copysign_f32: FunctionValue<'ctx>,
+    pub copysign_f64: FunctionValue<'ctx>,
+    pub copysign_f32x4: FunctionValue<'ctx>,
+    pub copysign_f64x2: FunctionValue<'ctx>,
+
+    pub sadd_sat_i8x16: FunctionValue<'ctx>,
+    pub sadd_sat_i16x8: FunctionValue<'ctx>,
+    pub uadd_sat_i8x16: FunctionValue<'ctx>,
+    pub uadd_sat_i16x8: FunctionValue<'ctx>,
+
+    pub ssub_sat_i8x16: FunctionValue<'ctx>,
+    pub ssub_sat_i16x8: FunctionValue<'ctx>,
+    pub usub_sat_i8x16: FunctionValue<'ctx>,
+    pub usub_sat_i16x8: FunctionValue<'ctx>,
+
+    pub expect_i1: FunctionValue<'ctx>,
+    pub trap: FunctionValue<'ctx>,
+    pub debug_trap: FunctionValue<'ctx>,
+
+    pub personality: FunctionValue<'ctx>,
+    pub readonly: Attribute,
+    pub stack_probe: Attribute,
+
+    pub void_ty: VoidType<'ctx>,
+    pub i1_ty: IntType<'ctx>,
+    pub i2_ty: IntType<'ctx>,
+    pub i4_ty: IntType<'ctx>,
+    pub i8_ty: IntType<'ctx>,
+    pub i16_ty: IntType<'ctx>,
+    pub i32_ty: IntType<'ctx>,
+    pub i64_ty: IntType<'ctx>,
+    pub i128_ty: IntType<'ctx>,
+    pub isize_ty: IntType<'ctx>,
+    pub f32_ty: FloatType<'ctx>,
+    pub f64_ty: FloatType<'ctx>,
+
+    pub i1x128_ty: VectorType<'ctx>,
+    pub i8x16_ty: VectorType<'ctx>,
+    pub i16x8_ty: VectorType<'ctx>,
+    pub i32x4_ty: VectorType<'ctx>,
+    pub i64x2_ty: VectorType<'ctx>,
+    pub f32x4_ty: VectorType<'ctx>,
+    pub f64x2_ty: VectorType<'ctx>,
+    pub i32x8_ty: VectorType<'ctx>,
+
+    pub i8_ptr_ty: PointerType<'ctx>,
+    pub i16_ptr_ty: PointerType<'ctx>,
+    pub i32_ptr_ty: PointerType<'ctx>,
+    pub i64_ptr_ty: PointerType<'ctx>,
+    pub i128_ptr_ty: PointerType<'ctx>,
+    pub isize_ptr_ty: PointerType<'ctx>,
+    pub f32_ptr_ty: PointerType<'ctx>,
+    pub f64_ptr_ty: PointerType<'ctx>,
+
+    pub anyfunc_ty: StructType<'ctx>,
+
+    pub funcref_ty: PointerType<'ctx>,
+    pub externref_ty: PointerType<'ctx>,
+    pub anyref_ty: PointerType<'ctx>,
+
+    pub i1_zero: IntValue<'ctx>,
+    pub i8_zero: IntValue<'ctx>,
+    pub i32_zero: IntValue<'ctx>,
+    pub i64_zero: IntValue<'ctx>,
+    pub i128_zero: IntValue<'ctx>,
+    pub isize_zero: IntValue<'ctx>,
+    pub f32_zero: FloatValue<'ctx>,
+    pub f64_zero: FloatValue<'ctx>,
+    pub f32x4_zero: VectorValue<'ctx>,
+    pub f64x2_zero: VectorValue<'ctx>,
+    pub i32_consts: [IntValue<'ctx>; 16],
+
+    pub trap_unreachable: BasicValueEnum<'ctx>,
+    pub trap_call_indirect_null: BasicValueEnum<'ctx>,
+    pub trap_call_indirect_sig: BasicValueEnum<'ctx>,
+    pub trap_memory_oob: BasicValueEnum<'ctx>,
+    pub trap_illegal_arithmetic: BasicValueEnum<'ctx>,
+    pub trap_integer_division_by_zero: BasicValueEnum<'ctx>,
+    pub trap_bad_conversion_to_integer: BasicValueEnum<'ctx>,
+    pub trap_unaligned_atomic: BasicValueEnum<'ctx>,
+    pub trap_table_access_oob: BasicValueEnum<'ctx>,
+
+    pub experimental_stackmap: FunctionValue<'ctx>,
+
+    // VM libcalls.
+    pub table_copy: FunctionValue<'ctx>,
+    pub table_init: FunctionValue<'ctx>,
+    pub table_fill: FunctionValue<'ctx>,
+    pub table_size: FunctionValue<'ctx>,
+    pub imported_table_size: FunctionValue<'ctx>,
+    pub table_get: FunctionValue<'ctx>,
+    pub imported_table_get: FunctionValue<'ctx>,
+    pub table_set: FunctionValue<'ctx>,
+    pub imported_table_set: FunctionValue<'ctx>,
+    pub table_grow: FunctionValue<'ctx>,
+    pub imported_table_grow: FunctionValue<'ctx>,
+    pub memory_init: FunctionValue<'ctx>,
+    pub data_drop: FunctionValue<'ctx>,
+    pub func_ref: FunctionValue<'ctx>,
+    pub elem_drop: FunctionValue<'ctx>,
+    pub memory_copy: FunctionValue<'ctx>,
+    pub imported_memory_copy: FunctionValue<'ctx>,
+    pub memory_fill: FunctionValue<'ctx>,
+    pub imported_memory_fill: FunctionValue<'ctx>,
+    pub memory_size_ty: FunctionType<'ctx>,
+    pub memory_grow_ty: FunctionType<'ctx>,
+    pub memory_wait32: FunctionValue<'ctx>,
+    pub memory_wait32_ty: FunctionType<'ctx>,
+    pub imported_memory_wait32: FunctionValue<'ctx>,
+    pub memory_wait64: FunctionValue<'ctx>,
+    pub memory_wait64_ty: FunctionType<'ctx>,
+    pub imported_memory_wait64: FunctionValue<'ctx>,
+    pub memory_notify: FunctionValue<'ctx>,
+    pub memory_notify_ty: FunctionType<'ctx>,
+    pub imported_memory_notify: FunctionValue<'ctx>,
+
+    pub throw_trap: FunctionValue<'ctx>,
+
+    // VM builtins.
+    pub vmfunction_import_ptr_ty: PointerType<'ctx>,
+    pub vmfunction_import_ty: StructType<'ctx>,
+    pub vmfunction_import_body_element: u32,
+    pub vmfunction_import_vmctx_element: u32,
+
+    pub vmmemory_definition_ptr_ty: PointerType<'ctx>,
+    pub vmmemory_definition_ty: StructType<'ctx>,
+    pub vmmemory_definition_base_element: u32,
+    pub vmmemory_definition_current_length_element: u32,
+
+    pub memory32_grow_ptr_ty: PointerType<'ctx>,
+    pub imported_memory32_grow_ptr_ty: PointerType<'ctx>,
+    pub memory32_size_ptr_ty: PointerType<'ctx>,
+    pub imported_memory32_size_ptr_ty: PointerType<'ctx>,
+    pub memory32_wait32_ptr_ty: PointerType<'ctx>,
+    pub imported_memory32_wait32_ptr_ty: PointerType<'ctx>,
+    pub memory32_wait64_ptr_ty: PointerType<'ctx>,
+    pub imported_memory32_wait64_ptr_ty: PointerType<'ctx>,
+    pub memory32_notify_ptr_ty: PointerType<'ctx>,
+    pub imported_memory32_notify_ptr_ty: PointerType<'ctx>,
+
+    // Pointer to the VM.
+    pub ctx_ptr_ty: PointerType<'ctx>,
+}
+
+impl<'ctx> Intrinsics<'ctx> {
+    /// Create an [`Intrinsics`] for the given [`Context`].
+    pub fn declare(
+        module: &Module<'ctx>,
+        context: &'ctx Context,
+        target_data: &TargetData,
+    ) -> Self {
+        let void_ty = context.void_type();
+        let i1_ty = context.bool_type();
+        let i2_ty = context.custom_width_int_type(2);
+        let i4_ty = context.custom_width_int_type(4);
+        let i8_ty = context.i8_type();
+        let i16_ty = context.i16_type();
+        let i32_ty = context.i32_type();
+        let i64_ty = context.i64_type();
+        let i128_ty = context.i128_type();
+        let isize_ty = context.ptr_sized_int_type(target_data, None);
+        let f32_ty = context.f32_type();
+        let f64_ty = context.f64_type();
+
+        let i1x4_ty = i1_ty.vec_type(4);
+        let i1x2_ty = i1_ty.vec_type(2);
+        let i1x128_ty = i1_ty.vec_type(128);
+        let i8x16_ty = i8_ty.vec_type(16);
+        let i16x8_ty = i16_ty.vec_type(8);
+        let i32x4_ty = i32_ty.vec_type(4);
+        let i64x2_ty = i64_ty.vec_type(2);
+        let f32x4_ty = f32_ty.vec_type(4);
+        let f64x2_ty = f64_ty.vec_type(2);
+        let i32x8_ty = i32_ty.vec_type(8);
+
+        let i8_ptr_ty = i8_ty.ptr_type(AddressSpace::default());
+        let i16_ptr_ty = i16_ty.ptr_type(AddressSpace::default());
+        let i32_ptr_ty = i32_ty.ptr_type(AddressSpace::default());
+        let i64_ptr_ty = i64_ty.ptr_type(AddressSpace::default());
+        let i128_ptr_ty = i128_ty.ptr_type(AddressSpace::default());
+        let isize_ptr_ty = isize_ty.ptr_type(AddressSpace::default());
+        let f32_ptr_ty = f32_ty.ptr_type(AddressSpace::default());
+        let f64_ptr_ty = f64_ty.ptr_type(AddressSpace::default());
+
+        let i1_zero = i1_ty.const_int(0, false);
+        let i8_zero = i8_ty.const_int(0, false);
+        let i32_zero = i32_ty.const_int(0, false);
+        let i64_zero = i64_ty.const_int(0, false);
+        let i128_zero = i128_ty.const_int(0, false);
+        let isize_zero = isize_ty.const_int(0, false);
+        let f32_zero = f32_ty.const_float(0.0);
+        let f64_zero = f64_ty.const_float(0.0);
+        let f32x4_zero = f32x4_ty.const_zero();
+        let f64x2_zero = f64x2_ty.const_zero();
+        let i32_consts = [
+            i32_ty.const_int(0, false),
+            i32_ty.const_int(1, false),
+            i32_ty.const_int(2, false),
+            i32_ty.const_int(3, false),
+            i32_ty.const_int(4, false),
+            i32_ty.const_int(5, false),
+            i32_ty.const_int(6, false),
+            i32_ty.const_int(7, false),
+            i32_ty.const_int(8, false),
+            i32_ty.const_int(9, false),
+            i32_ty.const_int(10, false),
+            i32_ty.const_int(11, false),
+            i32_ty.const_int(12, false),
+            i32_ty.const_int(13, false),
+            i32_ty.const_int(14, false),
+            i32_ty.const_int(15, false),
+        ];
+
+        let md_ty = context.metadata_type();
+
+        let i8_ptr_ty_basic = i8_ptr_ty.as_basic_type_enum();
+
+        let i1_ty_basic_md: BasicMetadataTypeEnum = i1_ty.into();
+        let i32_ty_basic_md: BasicMetadataTypeEnum = i32_ty.into();
+        let i64_ty_basic_md: BasicMetadataTypeEnum = i64_ty.into();
+        let f32_ty_basic_md: BasicMetadataTypeEnum = f32_ty.into();
+        let f64_ty_basic_md: BasicMetadataTypeEnum = f64_ty.into();
+        let i8x16_ty_basic_md: BasicMetadataTypeEnum = i8x16_ty.into();
+        let i16x8_ty_basic_md: BasicMetadataTypeEnum = i16x8_ty.into();
+        let f32x4_ty_basic_md: BasicMetadataTypeEnum = f32x4_ty.into();
+        let f64x2_ty_basic_md: BasicMetadataTypeEnum = f64x2_ty.into();
+        let md_ty_basic_md: BasicMetadataTypeEnum = md_ty.into();
+
+        let ctx_ty = i8_ty;
+        let ctx_ptr_ty = ctx_ty.ptr_type(AddressSpace::default());
+        let ctx_ptr_ty_basic = ctx_ptr_ty.as_basic_type_enum();
+        let ctx_ptr_ty_basic_md: BasicMetadataTypeEnum = ctx_ptr_ty.into();
+
+        let sigindex_ty = i32_ty;
+
+        let anyfunc_ty = context.struct_type(
+            &[i8_ptr_ty_basic, sigindex_ty.into(), ctx_ptr_ty_basic],
+            false,
+        );
+        let funcref_ty = anyfunc_ty.ptr_type(AddressSpace::default());
+        let externref_ty = funcref_ty;
+        let anyref_ty = i8_ptr_ty;
+        let anyref_ty_basic_md: BasicMetadataTypeEnum = anyref_ty.into();
+
+        let ret_i8x16_take_i8x16 = i8x16_ty.fn_type(&[i8x16_ty_basic_md], false);
+        let ret_i8x16_take_i8x16_i8x16 =
+            i8x16_ty.fn_type(&[i8x16_ty_basic_md, i8x16_ty_basic_md], false);
+        let ret_i16x8_take_i16x8_i16x8 =
+            i16x8_ty.fn_type(&[i16x8_ty_basic_md, i16x8_ty_basic_md], false);
+
+        let ret_i32_take_i32_i1 = i32_ty.fn_type(&[i32_ty_basic_md, i1_ty_basic_md], false);
+        let ret_i64_take_i64_i1 = i64_ty.fn_type(&[i64_ty_basic_md, i1_ty_basic_md], false);
+
+        let ret_i32_take_i32 = i32_ty.fn_type(&[i32_ty_basic_md], false);
+        let ret_i64_take_i64 = i64_ty.fn_type(&[i64_ty_basic_md], false);
+
+        let ret_f32_take_f32 = f32_ty.fn_type(&[f32_ty_basic_md], false);
+        let ret_f64_take_f64 = f64_ty.fn_type(&[f64_ty_basic_md], false);
+        let ret_f32x4_take_f32x4 = f32x4_ty.fn_type(&[f32x4_ty_basic_md], false);
+        let ret_f64x2_take_f64x2 = f64x2_ty.fn_type(&[f64x2_ty_basic_md], false);
+
+        let ret_f32_take_f32_f32 = f32_ty.fn_type(&[f32_ty_basic_md, f32_ty_basic_md], false);
+        let ret_f64_take_f64_f64 = f64_ty.fn_type(&[f64_ty_basic_md, f64_ty_basic_md], false);
+        let ret_f32x4_take_f32x4_f32x4 =
+            f32x4_ty.fn_type(&[f32x4_ty_basic_md, f32x4_ty_basic_md], false);
+        let ret_f64x2_take_f64x2_f64x2 =
+            f64x2_ty.fn_type(&[f64x2_ty_basic_md, f64x2_ty_basic_md], false);
+
+        let ret_f64_take_f32_md = f64_ty.fn_type(&[f32_ty_basic_md, md_ty_basic_md], false);
+        let ret_f32_take_f64_md_md =
+            f32_ty.fn_type(&[f64_ty_basic_md, md_ty_basic_md, md_ty_basic_md], false);
+
+        let ret_i1_take_i1_i1 = i1_ty.fn_type(&[i1_ty_basic_md, i1_ty_basic_md], false);
+
+        let ret_i1_take_f32_f32_md_md = i1_ty.fn_type(
+            &[
+                f32_ty_basic_md,
+                f32_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_i1_take_f64_f64_md_md = i1_ty.fn_type(
+            &[
+                f64_ty_basic_md,
+                f64_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_i1x4_take_f32x4_f32x4_md_md = i1x4_ty.fn_type(
+            &[
+                f32x4_ty_basic_md,
+                f32x4_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_i1x2_take_f64x2_f64x2_md_md = i1x2_ty.fn_type(
+            &[
+                f64x2_ty_basic_md,
+                f64x2_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+
+        let ret_f32_take_f32_f32_md_md = f32_ty.fn_type(
+            &[
+                f32_ty_basic_md,
+                f32_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_f64_take_f64_f64_md_md = f64_ty.fn_type(
+            &[
+                f64_ty_basic_md,
+                f64_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_f32x4_take_f32x4_f32x4_md_md = f32x4_ty.fn_type(
+            &[
+                f32x4_ty_basic_md,
+                f32x4_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+        let ret_f64x2_take_f64x2_f64x2_md_md = f64x2_ty.fn_type(
+            &[
+                f64x2_ty_basic_md,
+                f64x2_ty_basic_md,
+                md_ty_basic_md,
+                md_ty_basic_md,
+            ],
+            false,
+        );
+
+        let intrinsics = Self {
+            ctlz_i32: module.add_function("llvm.ctlz.i32", ret_i32_take_i32_i1, None),
+            ctlz_i64: module.add_function("llvm.ctlz.i64", ret_i64_take_i64_i1, None),
+
+            cttz_i32: module.add_function("llvm.cttz.i32", ret_i32_take_i32_i1, None),
+            cttz_i64: module.add_function("llvm.cttz.i64", ret_i64_take_i64_i1, None),
+
+            ctpop_i32: module.add_function("llvm.ctpop.i32", ret_i32_take_i32, None),
+            ctpop_i64: module.add_function("llvm.ctpop.i64", ret_i64_take_i64, None),
+            ctpop_i8x16: module.add_function("llvm.ctpop.v16i8", ret_i8x16_take_i8x16, None),
+
+            fp_rounding_md: context.metadata_string("round.tonearest").into(),
+            fp_exception_md: context.metadata_string("fpexcept.strict").into(),
+
+            fp_ogt_md: context.metadata_string("ogt").into(),
+            fp_olt_md: context.metadata_string("olt").into(),
+            fp_uno_md: context.metadata_string("uno").into(),
+
+            sqrt_f32: module.add_function("llvm.sqrt.f32", ret_f32_take_f32, None),
+            sqrt_f64: module.add_function("llvm.sqrt.f64", ret_f64_take_f64, None),
+            sqrt_f32x4: module.add_function("llvm.sqrt.v4f32", ret_f32x4_take_f32x4, None),
+            sqrt_f64x2: module.add_function("llvm.sqrt.v2f64", ret_f64x2_take_f64x2, None),
+
+            ceil_f32: module.add_function("llvm.ceil.f32", ret_f32_take_f32, None),
+            ceil_f64: module.add_function("llvm.ceil.f64", ret_f64_take_f64, None),
+            ceil_f32x4: module.add_function("llvm.ceil.v4f32", ret_f32x4_take_f32x4, None),
+            ceil_f64x2: module.add_function("llvm.ceil.v2f64", ret_f64x2_take_f64x2, None),
+
+            floor_f32: module.add_function("llvm.floor.f32", ret_f32_take_f32, None),
+            floor_f64: module.add_function("llvm.floor.f64", ret_f64_take_f64, None),
+            floor_f32x4: module.add_function("llvm.floor.v4f32", ret_f32x4_take_f32x4, None),
+            floor_f64x2: module.add_function("llvm.floor.v2f64", ret_f64x2_take_f64x2, None),
+
+            trunc_f32: module.add_function("llvm.trunc.f32", ret_f32_take_f32, None),
+            trunc_f64: module.add_function("llvm.trunc.f64", ret_f64_take_f64, None),
+            trunc_f32x4: module.add_function("llvm.trunc.v4f32", ret_f32x4_take_f32x4, None),
+            trunc_f64x2: module.add_function("llvm.trunc.v2f64", ret_f64x2_take_f64x2, None),
+
+            nearbyint_f32: module.add_function("llvm.nearbyint.f32", ret_f32_take_f32, None),
+            nearbyint_f64: module.add_function("llvm.nearbyint.f64", ret_f64_take_f64, None),
+            nearbyint_f32x4: module.add_function(
+                "llvm.nearbyint.v4f32",
+                ret_f32x4_take_f32x4,
+                None,
+            ),
+            nearbyint_f64x2: module.add_function(
+                "llvm.nearbyint.v2f64",
+                ret_f64x2_take_f64x2,
+                None,
+            ),
+
+            add_f32: module.add_function(
+                "llvm.experimental.constrained.fadd.f32",
+                ret_f32_take_f32_f32_md_md,
+                None,
+            ),
+            add_f64: module.add_function(
+                "llvm.experimental.constrained.fadd.f64",
+                ret_f64_take_f64_f64_md_md,
+                None,
+            ),
+            add_f32x4: module.add_function(
+                "llvm.experimental.constrained.fadd.v4f32",
+                ret_f32x4_take_f32x4_f32x4_md_md,
+                None,
+            ),
+            add_f64x2: module.add_function(
+                "llvm.experimental.constrained.fadd.v2f64",
+                ret_f64x2_take_f64x2_f64x2_md_md,
+                None,
+            ),
+
+            sub_f32: module.add_function(
+                "llvm.experimental.constrained.fsub.f32",
+                ret_f32_take_f32_f32_md_md,
+                None,
+            ),
+            sub_f64: module.add_function(
+                "llvm.experimental.constrained.fsub.f64",
+                ret_f64_take_f64_f64_md_md,
+                None,
+            ),
+            sub_f32x4: module.add_function(
+                "llvm.experimental.constrained.fsub.v4f32",
+                ret_f32x4_take_f32x4_f32x4_md_md,
+                None,
+            ),
+            sub_f64x2: module.add_function(
+                "llvm.experimental.constrained.fsub.v2f64",
+                ret_f64x2_take_f64x2_f64x2_md_md,
+                None,
+            ),
+
+            mul_f32: module.add_function(
+                "llvm.experimental.constrained.fmul.f32",
+                ret_f32_take_f32_f32_md_md,
+                None,
+            ),
+            mul_f64: module.add_function(
+                "llvm.experimental.constrained.fmul.f64",
+                ret_f64_take_f64_f64_md_md,
+                None,
+            ),
+            mul_f32x4: module.add_function(
+                "llvm.experimental.constrained.fmul.v4f32",
+                ret_f32x4_take_f32x4_f32x4_md_md,
+                None,
+            ),
+            mul_f64x2: module.add_function(
+                "llvm.experimental.constrained.fmul.v2f64",
+                ret_f64x2_take_f64x2_f64x2_md_md,
+                None,
+            ),
+
+            div_f32: module.add_function(
+                "llvm.experimental.constrained.fdiv.f32",
+                ret_f32_take_f32_f32_md_md,
+                None,
+            ),
+            div_f64: module.add_function(
+                "llvm.experimental.constrained.fdiv.f64",
+                ret_f64_take_f64_f64_md_md,
+                None,
+            ),
+            div_f32x4: module.add_function(
+                "llvm.experimental.constrained.fdiv.v4f32",
+                ret_f32x4_take_f32x4_f32x4_md_md,
+                None,
+            ),
+            div_f64x2: module.add_function(
+                "llvm.experimental.constrained.fdiv.v2f64",
+                ret_f64x2_take_f64x2_f64x2_md_md,
+                None,
+            ),
+
+            cmp_f32: module.add_function(
+                "llvm.experimental.constrained.fcmp.f32",
+                ret_i1_take_f32_f32_md_md,
+                None,
+            ),
+            cmp_f64: module.add_function(
+                "llvm.experimental.constrained.fcmp.f64",
+                ret_i1_take_f64_f64_md_md,
+                None,
+            ),
+            cmp_f32x4: module.add_function(
+                "llvm.experimental.constrained.fcmp.v4f32",
+                ret_i1x4_take_f32x4_f32x4_md_md,
+                None,
+            ),
+            cmp_f64x2: module.add_function(
+                "llvm.experimental.constrained.fcmp.v2f64",
+                ret_i1x2_take_f64x2_f64x2_md_md,
+                None,
+            ),
+
+            fpext_f32: module.add_function(
+                "llvm.experimental.constrained.fpext.f64.f32",
+                ret_f64_take_f32_md,
+                None,
+            ),
+            fptrunc_f64: module.add_function(
+                "llvm.experimental.constrained.fptrunc.f32.f64",
+                ret_f32_take_f64_md_md,
+                None,
+            ),
+
+            fabs_f32: module.add_function("llvm.fabs.f32", ret_f32_take_f32, None),
+            fabs_f64: module.add_function("llvm.fabs.f64", ret_f64_take_f64, None),
+            fabs_f32x4: module.add_function("llvm.fabs.v4f32", ret_f32x4_take_f32x4, None),
+            fabs_f64x2: module.add_function("llvm.fabs.v2f64", ret_f64x2_take_f64x2, None),
+
+            copysign_f32: module.add_function("llvm.copysign.f32", ret_f32_take_f32_f32, None),
+            copysign_f64: module.add_function("llvm.copysign.f64", ret_f64_take_f64_f64, None),
+            copysign_f32x4: module.add_function(
+                "llvm.copysign.v4f32",
+                ret_f32x4_take_f32x4_f32x4,
+                None,
+            ),
+            copysign_f64x2: module.add_function(
+                "llvm.copysign.v2f64",
+                ret_f64x2_take_f64x2_f64x2,
+                None,
+            ),
+
+            sadd_sat_i8x16: module.add_function(
+                "llvm.sadd.sat.v16i8",
+                ret_i8x16_take_i8x16_i8x16,
+                None,
+            ),
+            sadd_sat_i16x8: module.add_function(
+                "llvm.sadd.sat.v8i16",
+                ret_i16x8_take_i16x8_i16x8,
+                None,
+            ),
+            uadd_sat_i8x16: module.add_function(
+                "llvm.uadd.sat.v16i8",
+                ret_i8x16_take_i8x16_i8x16,
+                None,
+            ),
+            uadd_sat_i16x8: module.add_function(
+                "llvm.uadd.sat.v8i16",
+                ret_i16x8_take_i16x8_i16x8,
+                None,
+            ),
+
+            ssub_sat_i8x16: module.add_function(
+                "llvm.ssub.sat.v16i8",
+                ret_i8x16_take_i8x16_i8x16,
+                None,
+            ),
+            ssub_sat_i16x8: module.add_function(
+                "llvm.ssub.sat.v8i16",
+                ret_i16x8_take_i16x8_i16x8,
+                None,
+            ),
+            usub_sat_i8x16: module.add_function(
+                "llvm.usub.sat.v16i8",
+                ret_i8x16_take_i8x16_i8x16,
+                None,
+            ),
+            usub_sat_i16x8: module.add_function(
+                "llvm.usub.sat.v8i16",
+                ret_i16x8_take_i16x8_i16x8,
+                None,
+            ),
+
+            expect_i1: module.add_function("llvm.expect.i1", ret_i1_take_i1_i1, None),
+            trap: module.add_function("llvm.trap", void_ty.fn_type(&[], false), None),
+            debug_trap: module.add_function("llvm.debugtrap", void_ty.fn_type(&[], false), None),
+            personality: module.add_function(
+                "__gxx_personality_v0",
+                i32_ty.fn_type(&[], false),
+                Some(Linkage::External),
+            ),
+            readonly: context
+                .create_enum_attribute(Attribute::get_named_enum_kind_id("readonly"), 0),
+            stack_probe: context.create_string_attribute("probe-stack", "inline-asm"),
+
+            void_ty,
+            i1_ty,
+            i2_ty,
+            i4_ty,
+            i8_ty,
+            i16_ty,
+            i32_ty,
+            i64_ty,
+            i128_ty,
+            isize_ty,
+            f32_ty,
+            f64_ty,
+
+            i1x128_ty,
+            i8x16_ty,
+            i16x8_ty,
+            i32x4_ty,
+            i64x2_ty,
+            f32x4_ty,
+            f64x2_ty,
+            i32x8_ty,
+
+            i8_ptr_ty,
+            i16_ptr_ty,
+            i32_ptr_ty,
+            i64_ptr_ty,
+            i128_ptr_ty,
+            isize_ptr_ty,
+            f32_ptr_ty,
+            f64_ptr_ty,
+
+            anyfunc_ty,
+
+            funcref_ty,
+            externref_ty,
+            anyref_ty,
+
+            i1_zero,
+            i8_zero,
+            i32_zero,
+            i64_zero,
+            i128_zero,
+            isize_zero,
+            f32_zero,
+            f64_zero,
+            f32x4_zero,
+            f64x2_zero,
+            i32_consts,
+
+            trap_unreachable: i32_ty
+                .const_int(TrapCode::UnreachableCodeReached as _, false)
+                .as_basic_value_enum(),
+            trap_call_indirect_null: i32_ty
+                .const_int(TrapCode::IndirectCallToNull as _, false)
+                .as_basic_value_enum(),
+            trap_call_indirect_sig: i32_ty
+                .const_int(TrapCode::BadSignature as _, false)
+                .as_basic_value_enum(),
+            trap_memory_oob: i32_ty
+                .const_int(TrapCode::HeapAccessOutOfBounds as _, false)
+                .as_basic_value_enum(),
+            trap_illegal_arithmetic: i32_ty
+                .const_int(TrapCode::IntegerOverflow as _, false)
+                .as_basic_value_enum(),
+            trap_integer_division_by_zero: i32_ty
+                .const_int(TrapCode::IntegerDivisionByZero as _, false)
+                .as_basic_value_enum(),
+            trap_bad_conversion_to_integer: i32_ty
+                .const_int(TrapCode::BadConversionToInteger as _, false)
+                .as_basic_value_enum(),
+            trap_unaligned_atomic: i32_ty
+                .const_int(TrapCode::UnalignedAtomic as _, false)
+                .as_basic_value_enum(),
+            trap_table_access_oob: i32_ty
+                .const_int(TrapCode::TableAccessOutOfBounds as _, false)
+                .as_basic_value_enum(),
+
+            experimental_stackmap: module.add_function(
+                "llvm.experimental.stackmap",
+                void_ty.fn_type(
+                    &[
+                        i64_ty_basic_md, /* id */
+                        i32_ty_basic_md, /* numShadowBytes */
+                    ],
+                    true,
+                ),
+                None,
+            ),
+
+            // VM libcalls.
+            table_copy: module.add_function(
+                "wasmer_vm_table_copy",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            table_init: module.add_function(
+                "wasmer_vm_table_init",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            table_fill: module.add_function(
+                "wasmer_vm_table_fill",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        anyref_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            table_size: module.add_function(
+                "wasmer_vm_table_size",
+                i32_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+                None,
+            ),
+            imported_table_size: module.add_function(
+                "wasmer_vm_imported_table_size",
+                i32_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+                None,
+            ),
+            table_get: module.add_function(
+                "wasmer_vm_table_get",
+                anyref_ty.fn_type(
+                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
+                    false,
+                ),
+                None,
+            ),
+            imported_table_get: module.add_function(
+                "wasmer_vm_imported_table_get",
+                anyref_ty.fn_type(
+                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
+                    false,
+                ),
+                None,
+            ),
+            table_set: module.add_function(
+                "wasmer_vm_table_set",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        anyref_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            imported_table_set: module.add_function(
+                "wasmer_vm_imported_table_set",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        anyref_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            table_grow: module.add_function(
+                "wasmer_vm_table_grow",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        anyref_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            imported_table_grow: module.add_function(
+                "wasmer_vm_imported_table_grow",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        anyref_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_init: module.add_function(
+                "wasmer_vm_memory32_init",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_copy: module.add_function(
+                "wasmer_vm_memory32_copy",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            imported_memory_copy: module.add_function(
+                "wasmer_vm_imported_memory32_copy",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_fill: module.add_function(
+                "wasmer_vm_memory32_fill",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            imported_memory_fill: module.add_function(
+                "wasmer_vm_imported_memory32_fill",
+                void_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_size_ty: i32_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+            memory_grow_ty: i32_ty.fn_type(
+                &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
+                false,
+            ),
+            data_drop: module.add_function(
+                "wasmer_vm_data_drop",
+                void_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+                None,
+            ),
+            func_ref: module.add_function(
+                "wasmer_vm_func_ref",
+                funcref_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+                None,
+            ),
+            elem_drop: module.add_function(
+                "wasmer_vm_elem_drop",
+                void_ty.fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false),
+                None,
+            ),
+            throw_trap: module.add_function(
+                "wasmer_vm_raise_trap",
+                void_ty.fn_type(&[i32_ty_basic_md], false),
+                None,
+            ),
+            memory_wait32: module.add_function(
+                "wasmer_vm_memory32_atomic_wait32",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_wait32_ty: i32_ty.fn_type(
+                &[
+                    ctx_ptr_ty_basic_md,
+                    i32_ty_basic_md,
+                    i32_ty_basic_md,
+                    i32_ty_basic_md,
+                    i64_ty_basic_md,
+                ],
+                false,
+            ),
+            imported_memory_wait32: module.add_function(
+                "wasmer_vm_imported_memory32_atomic_wait32",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_wait64: module.add_function(
+                "wasmer_vm_memory32_atomic_wait64",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_wait64_ty: i32_ty.fn_type(
+                &[
+                    ctx_ptr_ty_basic_md,
+                    i32_ty_basic_md,
+                    i32_ty_basic_md,
+                    i64_ty_basic_md,
+                    i64_ty_basic_md,
+                ],
+                false,
+            ),
+            imported_memory_wait64: module.add_function(
+                "wasmer_vm_imported_memory32_atomic_wait64",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_notify: module.add_function(
+                "wasmer_vm_memory32_atomic_notify",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+            memory_notify_ty: i32_ty.fn_type(
+                &[
+                    ctx_ptr_ty_basic_md,
+                    i32_ty_basic_md,
+                    i32_ty_basic_md,
+                    i32_ty_basic_md,
+                ],
+                false,
+            ),
+            imported_memory_notify: module.add_function(
+                "wasmer_vm_imported_memory32_atomic_notify",
+                i32_ty.fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                ),
+                None,
+            ),
+
+            vmfunction_import_ptr_ty: context
+                .struct_type(&[i8_ptr_ty_basic, i8_ptr_ty_basic], false)
+                .ptr_type(AddressSpace::default()),
+            vmfunction_import_ty: context.struct_type(&[i8_ptr_ty_basic, i8_ptr_ty_basic], false),
+            vmfunction_import_body_element: 0,
+            vmfunction_import_vmctx_element: 1,
+
+            vmmemory_definition_ptr_ty: context
+                .struct_type(&[i8_ptr_ty_basic, isize_ty.into()], false)
+                .ptr_type(AddressSpace::default()),
+            vmmemory_definition_ty: context.struct_type(&[i8_ptr_ty_basic, isize_ty.into()], false),
+            vmmemory_definition_base_element: 0,
+            vmmemory_definition_current_length_element: 1,
+
+            memory32_grow_ptr_ty: i32_ty
+                .fn_type(
+                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            imported_memory32_grow_ptr_ty: i32_ty
+                .fn_type(
+                    &[ctx_ptr_ty_basic_md, i32_ty_basic_md, i32_ty_basic_md],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            memory32_size_ptr_ty: i32_ty
+                .fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false)
+                .ptr_type(AddressSpace::default()),
+            imported_memory32_size_ptr_ty: i32_ty
+                .fn_type(&[ctx_ptr_ty_basic_md, i32_ty_basic_md], false)
+                .ptr_type(AddressSpace::default()),
+            memory32_wait32_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            imported_memory32_wait32_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            memory32_wait64_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            imported_memory32_wait64_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i64_ty_basic_md,
+                        i64_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            memory32_notify_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+            imported_memory32_notify_ptr_ty: i32_ty
+                .fn_type(
+                    &[
+                        ctx_ptr_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                        i32_ty_basic_md,
+                    ],
+                    false,
+                )
+                .ptr_type(AddressSpace::default()),
+
+            ctx_ptr_ty,
+        };
+
+        let noreturn =
+            context.create_enum_attribute(Attribute::get_named_enum_kind_id("noreturn"), 0);
+        intrinsics
+            .throw_trap
+            .add_attribute(AttributeLoc::Function, noreturn);
+        intrinsics
+            .func_ref
+            .add_attribute(AttributeLoc::Function, intrinsics.readonly);
+
+        intrinsics
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum MemoryCache<'ctx> {
+    /// The memory moves around.
+    Dynamic {
+        ptr_to_base_ptr: PointerValue<'ctx>,
+        ptr_to_current_length: PointerValue<'ctx>,
+    },
+    /// The memory is always in the same place.
+    Static { base_ptr: PointerValue<'ctx> },
+}
+
+struct TableCache<'ctx> {
+    ptr_to_base_ptr: PointerValue<'ctx>,
+    ptr_to_bounds: PointerValue<'ctx>,
+}
+
+#[derive(Clone, Copy)]
+pub enum GlobalCache<'ctx> {
+    Mut {
+        ptr_to_value: PointerValue<'ctx>,
+        value_type: BasicTypeEnum<'ctx>,
+    },
+    Const {
+        value: BasicValueEnum<'ctx>,
+    },
+}
+
+#[derive(Clone)]
+pub struct FunctionCache<'ctx> {
+    pub func: PointerValue<'ctx>,
+    pub llvm_func_type: FunctionType<'ctx>,
+    pub vmctx: BasicValueEnum<'ctx>,
+    pub attrs: Vec<(Attribute, AttributeLoc)>,
+}
+
+pub struct CtxType<'ctx, 'a> {
+    ctx_ptr_value: PointerValue<'ctx>,
+
+    wasm_module: &'a WasmerCompilerModule,
+    cache_builder: &'a Builder<'ctx>,
+    abi: &'a dyn Abi,
+
+    cached_memories: HashMap<MemoryIndex, MemoryCache<'ctx>>,
+    cached_tables: HashMap<TableIndex, TableCache<'ctx>>,
+    cached_sigindices: HashMap<SignatureIndex, IntValue<'ctx>>,
+    cached_globals: HashMap<GlobalIndex, GlobalCache<'ctx>>,
+    cached_functions: HashMap<FunctionIndex, FunctionCache<'ctx>>,
+    cached_memory_grow: HashMap<MemoryIndex, PointerValue<'ctx>>,
+    cached_memory_size: HashMap<MemoryIndex, PointerValue<'ctx>>,
+
+    offsets: VMOffsets,
+}
+
+impl<'ctx, 'a> CtxType<'ctx, 'a> {
+    pub fn new(
+        wasm_module: &'a WasmerCompilerModule,
+        func_value: &FunctionValue<'ctx>,
+        cache_builder: &'a Builder<'ctx>,
+        abi: &'a dyn Abi,
+    ) -> CtxType<'ctx, 'a> {
+        CtxType {
+            ctx_ptr_value: abi.get_vmctx_ptr_param(func_value),
+
+            wasm_module,
+            cache_builder,
+            abi,
+
+            cached_memories: HashMap::new(),
+            cached_tables: HashMap::new(),
+            cached_sigindices: HashMap::new(),
+            cached_globals: HashMap::new(),
+            cached_functions: HashMap::new(),
+            cached_memory_grow: HashMap::new(),
+            cached_memory_size: HashMap::new(),
+
+            // TODO: pointer width
+            offsets: VMOffsets::new(8, wasm_module),
+        }
+    }
+
+    pub fn basic(&self) -> BasicValueEnum<'ctx> {
+        self.ctx_ptr_value.as_basic_value_enum()
+    }
+
+    pub fn memory(
+        &mut self,
+        index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+        memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
+    ) -> MemoryCache<'ctx> {
+        let (cached_memories, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
+            &mut self.cached_memories,
+            self.wasm_module,
+            self.ctx_ptr_value,
+            &self.cache_builder,
+            &self.offsets,
+        );
+        let memory_style = &memory_styles[index];
+        *cached_memories.entry(index).or_insert_with(|| {
+            let memory_definition_ptr = if let Some(local_memory_index) =
+                wasm_module.local_memory_index(index)
+            {
+                let offset = offsets.vmctx_vmmemory_definition(local_memory_index);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "") }
+            } else {
+                let offset = offsets.vmctx_vmmemory_import(index);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let memory_definition_ptr_ptr = unsafe {
+                    cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                };
+                let memory_definition_ptr_ptr = cache_builder
+                    .build_bitcast(
+                        memory_definition_ptr_ptr,
+                        intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
+                        "",
+                    )
+                    .into_pointer_value();
+                let memory_definition_ptr = cache_builder
+                    .build_load(intrinsics.i8_ptr_ty, memory_definition_ptr_ptr, "")
+                    .into_pointer_value();
+                tbaa_label(
+                    module,
+                    intrinsics,
+                    format!("memory {} definition", index.as_u32()),
+                    memory_definition_ptr.as_instruction_value().unwrap(),
+                );
+                memory_definition_ptr
+            };
+            let memory_definition_ptr = cache_builder
+                .build_bitcast(
+                    memory_definition_ptr,
+                    intrinsics.vmmemory_definition_ptr_ty,
+                    "",
+                )
+                .into_pointer_value();
+            let base_ptr = cache_builder
+                .build_struct_gep(
+                    intrinsics.vmmemory_definition_ty,
+                    memory_definition_ptr,
+                    intrinsics.vmmemory_definition_base_element,
+                    "",
+                )
+                .unwrap();
+            if let MemoryStyle::Dynamic { .. } = memory_style {
+                let current_length_ptr = cache_builder
+                    .build_struct_gep(
+                        intrinsics.vmmemory_definition_ty,
+                        memory_definition_ptr,
+                        intrinsics.vmmemory_definition_current_length_element,
+                        "",
+                    )
+                    .unwrap();
+                MemoryCache::Dynamic {
+                    ptr_to_base_ptr: base_ptr,
+                    ptr_to_current_length: current_length_ptr,
+                }
+            } else {
+                let base_ptr = cache_builder
+                    .build_load(intrinsics.i8_ptr_ty, base_ptr, "")
+                    .into_pointer_value();
+                tbaa_label(
+                    module,
+                    intrinsics,
+                    format!("memory base_ptr {}", index.as_u32()),
+                    base_ptr.as_instruction_value().unwrap(),
+                );
+                MemoryCache::Static { base_ptr }
+            }
+        })
+    }
+
+    fn table_prepare(
+        &mut self,
+        table_index: TableIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+    ) -> (PointerValue<'ctx>, PointerValue<'ctx>) {
+        let (cached_tables, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
+            &mut self.cached_tables,
+            self.wasm_module,
+            self.ctx_ptr_value,
+            &self.cache_builder,
+            &self.offsets,
+        );
+        let TableCache {
+            ptr_to_base_ptr,
+            ptr_to_bounds,
+        } = *cached_tables.entry(table_index).or_insert_with(|| {
+            let (ptr_to_base_ptr, ptr_to_bounds) =
+                if let Some(local_table_index) = wasm_module.local_table_index(table_index) {
+                    let offset = intrinsics.i64_ty.const_int(
+                        offsets
+                            .vmctx_vmtable_definition_base(local_table_index)
+                            .into(),
+                        false,
+                    );
+                    let ptr_to_base_ptr = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                    };
+                    let ptr_to_base_ptr = cache_builder
+                        .build_bitcast(
+                            ptr_to_base_ptr,
+                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
+                            "",
+                        )
+                        .into_pointer_value();
+                    let offset = intrinsics.i64_ty.const_int(
+                        offsets
+                            .vmctx_vmtable_definition_current_elements(local_table_index)
+                            .into(),
+                        false,
+                    );
+                    let ptr_to_bounds = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                    };
+                    let ptr_to_bounds = cache_builder
+                        .build_bitcast(ptr_to_bounds, intrinsics.i32_ptr_ty, "")
+                        .into_pointer_value();
+                    (ptr_to_base_ptr, ptr_to_bounds)
+                } else {
+                    let offset = intrinsics.i64_ty.const_int(
+                        offsets.vmctx_vmtable_import_definition(table_index).into(),
+                        false,
+                    );
+                    let definition_ptr_ptr = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                    };
+                    let definition_ptr_ptr = cache_builder
+                        .build_bitcast(
+                            definition_ptr_ptr,
+                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
+                            "",
+                        )
+                        .into_pointer_value();
+                    let definition_ptr = cache_builder
+                        .build_load(intrinsics.i8_ptr_ty, definition_ptr_ptr, "")
+                        .into_pointer_value();
+                    tbaa_label(
+                        module,
+                        intrinsics,
+                        format!("table {} definition", table_index.as_u32()),
+                        definition_ptr.as_instruction_value().unwrap(),
+                    );
+
+                    let offset = intrinsics
+                        .i64_ty
+                        .const_int(offsets.vmtable_definition_base().into(), false);
+                    let ptr_to_base_ptr = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")
+                    };
+                    let ptr_to_base_ptr = cache_builder
+                        .build_bitcast(
+                            ptr_to_base_ptr,
+                            intrinsics.i8_ptr_ty.ptr_type(AddressSpace::default()),
+                            "",
+                        )
+                        .into_pointer_value();
+                    let offset = intrinsics
+                        .i64_ty
+                        .const_int(offsets.vmtable_definition_current_elements().into(), false);
+                    let ptr_to_bounds = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, definition_ptr, &[offset], "")
+                    };
+                    let ptr_to_bounds = cache_builder
+                        .build_bitcast(ptr_to_bounds, intrinsics.i32_ptr_ty, "")
+                        .into_pointer_value();
+                    (ptr_to_base_ptr, ptr_to_bounds)
+                };
+            TableCache {
+                ptr_to_base_ptr,
+                ptr_to_bounds,
+            }
+        });
+
+        (ptr_to_base_ptr, ptr_to_bounds)
+    }
+
+    pub fn table(
+        &mut self,
+        index: TableIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+    ) -> (PointerValue<'ctx>, IntValue<'ctx>) {
+        let (ptr_to_base_ptr, ptr_to_bounds) = self.table_prepare(index, intrinsics, module);
+        let base_ptr = self
+            .cache_builder
+            .build_load(intrinsics.i8_ptr_ty, ptr_to_base_ptr, "base_ptr")
+            .into_pointer_value();
+        let bounds = self
+            .cache_builder
+            .build_load(intrinsics.isize_ty, ptr_to_bounds, "bounds")
+            .into_int_value();
+        tbaa_label(
+            module,
+            intrinsics,
+            format!("table_base_ptr {}", index.index()),
+            base_ptr.as_instruction_value().unwrap(),
+        );
+        tbaa_label(
+            module,
+            intrinsics,
+            format!("table_bounds {}", index.index()),
+            bounds.as_instruction_value().unwrap(),
+        );
+        (base_ptr, bounds)
+    }
+
+    pub fn dynamic_sigindex(
+        &mut self,
+        index: SignatureIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+    ) -> IntValue<'ctx> {
+        let (cached_sigindices, ctx_ptr_value, cache_builder, offsets) = (
+            &mut self.cached_sigindices,
+            self.ctx_ptr_value,
+            &self.cache_builder,
+            &self.offsets,
+        );
+        *cached_sigindices.entry(index).or_insert_with(|| {
+            let byte_offset = intrinsics
+                .i64_ty
+                .const_int(offsets.vmctx_vmshared_signature_id(index).into(), false);
+            let sigindex_ptr = unsafe {
+                cache_builder.build_gep(
+                    intrinsics.i8_ty,
+                    ctx_ptr_value,
+                    &[byte_offset],
+                    "dynamic_sigindex",
+                )
+            };
+            let sigindex_ptr = cache_builder
+                .build_bitcast(sigindex_ptr, intrinsics.i32_ptr_ty, "")
+                .into_pointer_value();
+
+            let sigindex = cache_builder
+                .build_load(intrinsics.i32_ty, sigindex_ptr, "sigindex")
+                .into_int_value();
+            tbaa_label(
+                module,
+                intrinsics,
+                format!("sigindex {}", index.as_u32()),
+                sigindex.as_instruction_value().unwrap(),
+            );
+            sigindex
+        })
+    }
+
+    pub fn global(
+        &mut self,
+        index: GlobalIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+    ) -> Result<&GlobalCache<'ctx>, CompileError> {
+        let (cached_globals, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
+            &mut self.cached_globals,
+            self.wasm_module,
+            self.ctx_ptr_value,
+            &self.cache_builder,
+            &self.offsets,
+        );
+        Ok(match cached_globals.entry(index) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => {
+                let global_type = wasm_module.globals[index];
+                let global_value_type = global_type.ty;
+
+                let global_mutability = global_type.mutability;
+                let offset = if let Some(local_global_index) = wasm_module.local_global_index(index)
+                {
+                    offsets.vmctx_vmglobal_definition(local_global_index)
+                } else {
+                    offsets.vmctx_vmglobal_import(index)
+                };
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let global_ptr = {
+                    let global_ptr_ptr = unsafe {
+                        cache_builder.build_gep(intrinsics.i8_ty, ctx_ptr_value, &[offset], "")
+                    };
+                    let global_ptr_ptr = cache_builder
+                        .build_bitcast(
+                            global_ptr_ptr,
+                            intrinsics.i32_ptr_ty.ptr_type(AddressSpace::default()),
+                            "",
+                        )
+                        .into_pointer_value();
+                    let global_ptr = cache_builder
+                        .build_load(intrinsics.i32_ptr_ty, global_ptr_ptr, "")
+                        .into_pointer_value();
+                    tbaa_label(
+                        module,
+                        intrinsics,
+                        format!("global_ptr {}", index.as_u32()),
+                        global_ptr.as_instruction_value().unwrap(),
+                    );
+                    global_ptr
+                };
+                let global_ptr = cache_builder
+                    .build_bitcast(
+                        global_ptr,
+                        type_to_llvm_ptr(intrinsics, global_value_type)?,
+                        "",
+                    )
+                    .into_pointer_value();
+
+                entry.insert(match global_mutability {
+                    Mutability::Const => {
+                        let value = cache_builder.build_load(
+                            type_to_llvm(intrinsics, global_value_type)?,
+                            global_ptr,
+                            "",
+                        );
+                        tbaa_label(
+                            module,
+                            intrinsics,
+                            format!("global {}", index.as_u32()),
+                            value.as_instruction_value().unwrap(),
+                        );
+                        GlobalCache::Const { value }
+                    }
+                    Mutability::Var => GlobalCache::Mut {
+                        ptr_to_value: global_ptr,
+                        value_type: type_to_llvm(intrinsics, global_value_type)?,
+                    },
+                })
+            }
+        })
+    }
+
+    pub fn add_func(
+        &mut self,
+        function_index: FunctionIndex,
+        func: PointerValue<'ctx>,
+        llvm_func_type: FunctionType<'ctx>,
+        vmctx: BasicValueEnum<'ctx>,
+        attrs: &[(Attribute, AttributeLoc)],
+    ) {
+        match self.cached_functions.entry(function_index) {
+            Entry::Occupied(_) => unreachable!("duplicate function"),
+            Entry::Vacant(entry) => {
+                entry.insert(FunctionCache {
+                    func,
+                    llvm_func_type,
+                    vmctx,
+                    attrs: attrs.to_vec(),
+                });
+            }
+        }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn local_func(
+        &mut self,
+        _local_function_index: LocalFunctionIndex,
+        function_index: FunctionIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        module: &Module<'ctx>,
+        context: &'ctx Context,
+        func_type: &FuncType,
+        function_name: &str,
+    ) -> Result<&FunctionCache<'ctx>, CompileError> {
+        let (cached_functions, ctx_ptr_value, offsets) = (
+            &mut self.cached_functions,
+            &self.ctx_ptr_value,
+            &self.offsets,
+        );
+        Ok(match cached_functions.entry(function_index) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => {
+                debug_assert!(module.get_function(function_name).is_none());
+                let (llvm_func_type, llvm_func_attrs) =
+                    self.abi
+                        .func_type_to_llvm(context, intrinsics, Some(offsets), func_type)?;
+                let func =
+                    module.add_function(function_name, llvm_func_type, Some(Linkage::External));
+                for (attr, attr_loc) in &llvm_func_attrs {
+                    func.add_attribute(*attr_loc, *attr);
+                }
+                entry.insert(FunctionCache {
+                    func: func.as_global_value().as_pointer_value(),
+                    llvm_func_type,
+                    vmctx: ctx_ptr_value.as_basic_value_enum(),
+                    attrs: llvm_func_attrs,
+                })
+            }
+        })
+    }
+
+    pub fn func(
+        &mut self,
+        function_index: FunctionIndex,
+        intrinsics: &Intrinsics<'ctx>,
+        context: &'ctx Context,
+        func_type: &FuncType,
+    ) -> Result<&FunctionCache<'ctx>, CompileError> {
+        let (cached_functions, wasm_module, ctx_ptr_value, cache_builder, offsets) = (
+            &mut self.cached_functions,
+            self.wasm_module,
+            &self.ctx_ptr_value,
+            &self.cache_builder,
+            &self.offsets,
+        );
+        Ok(match cached_functions.entry(function_index) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => {
+                let (llvm_func_type, llvm_func_attrs) =
+                    self.abi
+                        .func_type_to_llvm(context, intrinsics, Some(offsets), func_type)?;
+                debug_assert!(wasm_module.local_func_index(function_index).is_none());
+                let offset = offsets.vmctx_vmfunction_import(function_index);
+                let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+                let vmfunction_import_ptr = unsafe {
+                    cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "")
+                };
+                let vmfunction_import_ptr = cache_builder
+                    .build_bitcast(
+                        vmfunction_import_ptr,
+                        intrinsics.vmfunction_import_ptr_ty,
+                        "",
+                    )
+                    .into_pointer_value();
+
+                let body_ptr_ptr = cache_builder
+                    .build_struct_gep(
+                        intrinsics.vmfunction_import_ty,
+                        vmfunction_import_ptr,
+                        intrinsics.vmfunction_import_body_element,
+                        "",
+                    )
+                    .unwrap();
+                let body_ptr = cache_builder.build_load(intrinsics.i8_ptr_ty, body_ptr_ptr, "");
+                let body_ptr = cache_builder
+                    .build_bitcast(
+                        body_ptr,
+                        llvm_func_type.ptr_type(AddressSpace::default()),
+                        "",
+                    )
+                    .into_pointer_value();
+                let vmctx_ptr_ptr = cache_builder
+                    .build_struct_gep(
+                        intrinsics.vmfunction_import_ty,
+                        vmfunction_import_ptr,
+                        intrinsics.vmfunction_import_vmctx_element,
+                        "",
+                    )
+                    .unwrap();
+                let vmctx_ptr = cache_builder.build_load(intrinsics.ctx_ptr_ty, vmctx_ptr_ptr, "");
+                entry.insert(FunctionCache {
+                    func: body_ptr,
+                    llvm_func_type,
+                    vmctx: vmctx_ptr,
+                    attrs: llvm_func_attrs,
+                })
+            }
+        })
+    }
+
+    pub fn memory_grow(
+        &mut self,
+        memory_index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> PointerValue<'ctx> {
+        let (cached_memory_grow, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_grow,
+            &self.wasm_module,
+            &self.offsets,
+            &self.cache_builder,
+            &self.ctx_ptr_value,
+        );
+        *cached_memory_grow.entry(memory_index).or_insert_with(|| {
+            let (grow_fn, grow_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
+                (
+                    VMBuiltinFunctionIndex::get_memory32_grow_index(),
+                    intrinsics.memory32_grow_ptr_ty,
+                )
+            } else {
+                (
+                    VMBuiltinFunctionIndex::get_imported_memory32_grow_index(),
+                    intrinsics.imported_memory32_grow_ptr_ty,
+                )
+            };
+            let offset = offsets.vmctx_builtin_function(grow_fn);
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let grow_fn_ptr_ptr =
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
+
+            let grow_fn_ptr_ptr = cache_builder
+                .build_bitcast(
+                    grow_fn_ptr_ptr,
+                    grow_fn_ty.ptr_type(AddressSpace::default()),
+                    "",
+                )
+                .into_pointer_value();
+            cache_builder
+                .build_load(grow_fn_ty, grow_fn_ptr_ptr, "")
+                .into_pointer_value()
+        })
+    }
+
+    pub fn memory_size(
+        &mut self,
+        memory_index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> PointerValue<'ctx> {
+        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_size,
+            &self.wasm_module,
+            &self.offsets,
+            &self.cache_builder,
+            &self.ctx_ptr_value,
+        );
+        *cached_memory_size.entry(memory_index).or_insert_with(|| {
+            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
+                (
+                    VMBuiltinFunctionIndex::get_memory32_size_index(),
+                    intrinsics.memory32_size_ptr_ty,
+                )
+            } else {
+                (
+                    VMBuiltinFunctionIndex::get_imported_memory32_size_index(),
+                    intrinsics.imported_memory32_size_ptr_ty,
+                )
+            };
+            let offset = offsets.vmctx_builtin_function(size_fn);
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let size_fn_ptr_ptr =
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
+
+            let size_fn_ptr_ptr = cache_builder
+                .build_bitcast(
+                    size_fn_ptr_ptr,
+                    size_fn_ty.ptr_type(AddressSpace::default()),
+                    "",
+                )
+                .into_pointer_value();
+
+            cache_builder
+                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
+                .into_pointer_value()
+        })
+    }
+
+    pub fn memory_wait32(
+        &mut self,
+        memory_index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> PointerValue<'ctx> {
+        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_size,
+            &self.wasm_module,
+            &self.offsets,
+            &self.cache_builder,
+            &self.ctx_ptr_value,
+        );
+        *cached_memory_size.entry(memory_index).or_insert_with(|| {
+            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
+                (
+                    VMBuiltinFunctionIndex::get_memory_atomic_wait32_index(),
+                    intrinsics.memory32_wait32_ptr_ty,
+                )
+            } else {
+                (
+                    VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index(),
+                    intrinsics.imported_memory32_wait32_ptr_ty,
+                )
+            };
+            let offset = offsets.vmctx_builtin_function(size_fn);
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let size_fn_ptr_ptr =
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
+
+            let size_fn_ptr_ptr = cache_builder
+                .build_bitcast(
+                    size_fn_ptr_ptr,
+                    size_fn_ty.ptr_type(AddressSpace::default()),
+                    "",
+                )
+                .into_pointer_value();
+
+            cache_builder
+                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
+                .into_pointer_value()
+        })
+    }
+
+    pub fn memory_wait64(
+        &mut self,
+        memory_index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> PointerValue<'ctx> {
+        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_size,
+            &self.wasm_module,
+            &self.offsets,
+            &self.cache_builder,
+            &self.ctx_ptr_value,
+        );
+        *cached_memory_size.entry(memory_index).or_insert_with(|| {
+            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
+                (
+                    VMBuiltinFunctionIndex::get_memory_atomic_wait64_index(),
+                    intrinsics.memory32_wait64_ptr_ty,
+                )
+            } else {
+                (
+                    VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index(),
+                    intrinsics.imported_memory32_wait64_ptr_ty,
+                )
+            };
+            let offset = offsets.vmctx_builtin_function(size_fn);
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let size_fn_ptr_ptr =
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
+
+            let size_fn_ptr_ptr = cache_builder
+                .build_bitcast(
+                    size_fn_ptr_ptr,
+                    size_fn_ty.ptr_type(AddressSpace::default()),
+                    "",
+                )
+                .into_pointer_value();
+
+            cache_builder
+                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
+                .into_pointer_value()
+        })
+    }
+
+    pub fn memory_notify(
+        &mut self,
+        memory_index: MemoryIndex,
+        intrinsics: &Intrinsics<'ctx>,
+    ) -> PointerValue<'ctx> {
+        let (cached_memory_size, wasm_module, offsets, cache_builder, ctx_ptr_value) = (
+            &mut self.cached_memory_size,
+            &self.wasm_module,
+            &self.offsets,
+            &self.cache_builder,
+            &self.ctx_ptr_value,
+        );
+        *cached_memory_size.entry(memory_index).or_insert_with(|| {
+            let (size_fn, size_fn_ty) = if wasm_module.local_memory_index(memory_index).is_some() {
+                (
+                    VMBuiltinFunctionIndex::get_memory_atomic_notify_index(),
+                    intrinsics.memory32_notify_ptr_ty,
+                )
+            } else {
+                (
+                    VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index(),
+                    intrinsics.imported_memory32_notify_ptr_ty,
+                )
+            };
+            let offset = offsets.vmctx_builtin_function(size_fn);
+            let offset = intrinsics.i32_ty.const_int(offset.into(), false);
+            let size_fn_ptr_ptr =
+                unsafe { cache_builder.build_gep(intrinsics.i8_ty, *ctx_ptr_value, &[offset], "") };
+
+            let size_fn_ptr_ptr = cache_builder
+                .build_bitcast(
+                    size_fn_ptr_ptr,
+                    size_fn_ty.ptr_type(AddressSpace::default()),
+                    "",
+                )
+                .into_pointer_value();
+
+            cache_builder
+                .build_load(size_fn_ty, size_fn_ptr_ptr, "")
+                .into_pointer_value()
+        })
+    }
+
+    pub fn get_offsets(&self) -> &VMOffsets {
+        &self.offsets
+    }
+}
+
+// Given an instruction that operates on memory, mark the access as not aliasing
+// other memory accesses which have a different label.
+pub fn tbaa_label<'ctx>(
+    module: &Module<'ctx>,
+    intrinsics: &Intrinsics<'ctx>,
+    label: String,
+    instruction: InstructionValue<'ctx>,
+) {
+    // To convey to LLVM that two pointers must be pointing to distinct memory,
+    // we use LLVM's Type Based Aliasing Analysis, or TBAA, to mark the memory
+    // operations as having different types whose pointers may not alias.
+    //
+    // See the LLVM documentation at
+    //   https://llvm.org/docs/LangRef.html#tbaa-metadata
+    //
+    // LLVM TBAA supports many features, but we use it in a simple way, with
+    // only scalar types that are children of the root node. Every TBAA type we
+    // declare is NoAlias with the others. See NoAlias, PartialAlias,
+    // MayAlias and MustAlias in the LLVM documentation:
+    //   https://llvm.org/docs/AliasAnalysis.html#must-may-and-no-alias-responses
+
+    let context = module.get_context();
+
+    // `!wasmer_tbaa_root = {}`, the TBAA root node for wasmer.
+    let tbaa_root = module
+        .get_global_metadata("wasmer_tbaa_root")
+        .pop()
+        .unwrap_or_else(|| {
+            module
+                .add_global_metadata("wasmer_tbaa_root", &context.metadata_node(&[]))
+                .unwrap();
+            module.get_global_metadata("wasmer_tbaa_root")[0]
+        });
+
+    // Construct (or look up) the type descriptor, for example
+    //   `!"local 0" = !{!"local 0", !wasmer_tbaa_root}`.
+    let type_label = context.metadata_string(label.as_str());
+    let type_tbaa = module
+        .get_global_metadata(label.as_str())
+        .pop()
+        .unwrap_or_else(|| {
+            module
+                .add_global_metadata(
+                    label.as_str(),
+                    &context.metadata_node(&[type_label.into(), tbaa_root.into()]),
+                )
+                .unwrap();
+            module.get_global_metadata(label.as_str())[0]
+        });
+
+    // Construct (or look up) the access tag, which is a struct of the form
+    // (base type, access type, offset).
+    //
+    // "If BaseTy is a scalar type, Offset must be 0 and BaseTy and AccessTy
+    // must be the same".
+    //   -- https://llvm.org/docs/LangRef.html#tbaa-metadata
+    let label = label + "_memop";
+    let type_tbaa = module
+        .get_global_metadata(label.as_str())
+        .pop()
+        .unwrap_or_else(|| {
+            module
+                .add_global_metadata(
+                    label.as_str(),
+                    &context.metadata_node(&[
+                        type_tbaa.into(),
+                        type_tbaa.into(),
+                        intrinsics.i64_zero.into(),
+                    ]),
+                )
+                .unwrap();
+            module.get_global_metadata(label.as_str())[0]
+        });
+
+    // Attach the access tag to the instruction.
+    let tbaa_kind = context.get_kind_id("tbaa");
+    instruction.set_metadata(type_tbaa, tbaa_kind).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/mod.rs
new file mode 100644
index 0000000..ac54668
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/mod.rs
@@ -0,0 +1,6 @@
+mod code;
+pub mod intrinsics;
+//mod stackmap;
+mod state;
+
+pub use self::code::FuncTranslator;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/stackmap.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/stackmap.rs
new file mode 100644
index 0000000..cb6abc4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/stackmap.rs
@@ -0,0 +1,570 @@
+// https://llvm.org/docs/StackMaps.html#stackmap-section
+
+use byteorder::{LittleEndian, ReadBytesExt};
+use std::io::{self, Cursor};
+use wasmer_vm_core::vm::Ctx;
+use wasmer_vm_core::{
+    module::Module,
+    structures::TypedIndex,
+    types::{GlobalIndex, LocalOrImport, TableIndex},
+};
+
+#[derive(Default, Debug, Clone)]
+pub struct StackmapRegistry {
+    pub entries: Vec<StackmapEntry>,
+}
+
+#[derive(Debug, Clone)]
+pub struct StackmapEntry {
+    pub kind: StackmapEntryKind,
+    pub local_function_id: usize,
+    pub opcode_offset: usize,
+    pub value_semantics: Vec<ValueSemantic>,
+    pub local_count: usize,
+    pub stack_count: usize,
+    pub is_start: bool,
+}
+
+#[derive(Debug, Clone)]
+pub enum ValueSemantic {
+    WasmLocal(usize),
+    WasmStack(usize),
+    Ctx,
+    SignalMem,
+    PointerToMemoryBase,
+    PointerToMemoryBound, // 64-bit
+    MemoryBase,
+    MemoryBound, // 64-bit
+    PointerToGlobal(usize),
+    Global(usize),
+    PointerToTableBase,
+    PointerToTableBound,
+    ImportedFuncPointer(usize),
+    ImportedFuncCtx(usize),
+    DynamicSigindice(usize),
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum StackmapEntryKind {
+    FunctionHeader,
+    Loop,
+    Call,
+    Trappable,
+}
+
+impl StackmapEntry {
+    #[cfg(all(
+        any(target_os = "freebsd", target_os = "linux", target_vendor = "apple"),
+        target_arch = "x86_64"
+    ))]
+    pub fn populate_msm(
+        &self,
+        module_info: &ModuleInfo,
+        code_addr: usize,
+        llvm_map: &StackMap,
+        size_record: &StkSizeRecord,
+        map_record: &StkMapRecord,
+        end: Option<(&StackmapEntry, &StkMapRecord)>,
+        msm: &mut wasmer_vm_core::state::ModuleStateMap,
+    ) {
+        use std::collections::{BTreeMap, HashMap};
+        use wasmer_vm_core::state::{
+            x64::{new_machine_state, X64Register, GPR},
+            FunctionStateMap, MachineStateDiff, MachineValue, OffsetInfo, RegisterIndex,
+            SuspendOffset, WasmAbstractValue,
+        };
+        use wasmer_vm_core::vm;
+
+        let func_base_addr = (size_record.function_address as usize)
+            .checked_sub(code_addr)
+            .unwrap();
+        let target_offset = func_base_addr + map_record.instruction_offset as usize;
+        assert!(self.is_start);
+
+        if msm.local_functions.len() == self.local_function_id {
+            assert_eq!(self.kind, StackmapEntryKind::FunctionHeader);
+            msm.local_functions.insert(
+                target_offset,
+                FunctionStateMap::new(new_machine_state(), self.local_function_id, 0, vec![]),
+            );
+        } else if msm.local_functions.len() == self.local_function_id + 1 {
+        } else {
+            panic!("unordered local functions");
+        }
+
+        let (_, fsm) = msm.local_functions.iter_mut().last().unwrap();
+
+        assert_eq!(self.value_semantics.len(), map_record.locations.len());
+
+        // System V requires 16-byte alignment before each call instruction.
+        // Considering the saved rbp we need to ensure the stack size % 16 always equals to 8.
+        assert!(size_record.stack_size % 16 == 8);
+
+        // Layout begins just below saved rbp. (push rbp; mov rbp, rsp)
+        let mut machine_stack_half_layout: Vec<MachineValue> =
+            vec![MachineValue::Undefined; (size_record.stack_size - 8) as usize / 4];
+        let mut regs: Vec<(RegisterIndex, MachineValue)> = vec![];
+        let mut stack_constants: HashMap<usize, u64> = HashMap::new();
+
+        let mut prev_frame_diff: BTreeMap<usize, Option<MachineValue>> = BTreeMap::new();
+
+        let mut wasm_locals: Vec<WasmAbstractValue> = vec![];
+        let mut wasm_stack: Vec<WasmAbstractValue> = vec![];
+
+        for (i, loc) in map_record.locations.iter().enumerate() {
+            let mv = match self.value_semantics[i] {
+                ValueSemantic::WasmLocal(x) => {
+                    if x != wasm_locals.len() {
+                        panic!("unordered local values");
+                    }
+                    wasm_locals.push(WasmAbstractValue::Runtime);
+                    MachineValue::WasmLocal(x)
+                }
+                ValueSemantic::WasmStack(x) => {
+                    if x != wasm_stack.len() {
+                        panic!("unordered stack values");
+                    }
+                    wasm_stack.push(WasmAbstractValue::Runtime);
+                    MachineValue::WasmStack(x)
+                }
+                ValueSemantic::Ctx => MachineValue::Vmctx,
+                ValueSemantic::SignalMem => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_interrupt_signal_mem() as usize, 0])
+                }
+                ValueSemantic::PointerToMemoryBase => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_base() as usize])
+                }
+                ValueSemantic::PointerToMemoryBound => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_bound() as usize])
+                }
+                ValueSemantic::MemoryBase => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_base() as usize, 0])
+                }
+                ValueSemantic::MemoryBound => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_memory_bound() as usize, 0])
+                }
+                ValueSemantic::PointerToGlobal(idx) => {
+                    MachineValue::VmctxDeref(deref_global(module_info, idx, false))
+                }
+                ValueSemantic::Global(idx) => {
+                    MachineValue::VmctxDeref(deref_global(module_info, idx, true))
+                }
+                ValueSemantic::PointerToTableBase => {
+                    MachineValue::VmctxDeref(deref_table_base(module_info, 0, false))
+                }
+                ValueSemantic::PointerToTableBound => {
+                    MachineValue::VmctxDeref(deref_table_bound(module_info, 0, false))
+                }
+                ValueSemantic::ImportedFuncPointer(idx) => MachineValue::VmctxDeref(vec![
+                    Ctx::offset_imported_funcs() as usize,
+                    vm::ImportedFunc::size() as usize * idx
+                        + vm::ImportedFunc::offset_func() as usize,
+                    0,
+                ]),
+                ValueSemantic::ImportedFuncCtx(idx) => MachineValue::VmctxDeref(vec![
+                    Ctx::offset_imported_funcs() as usize,
+                    vm::ImportedFunc::size() as usize * idx
+                        + vm::ImportedFunc::offset_func_ctx() as usize,
+                    0,
+                ]),
+                ValueSemantic::DynamicSigindice(idx) => {
+                    MachineValue::VmctxDeref(vec![Ctx::offset_signatures() as usize, idx * 4, 0])
+                }
+            };
+            match loc.ty {
+                LocationType::Register => {
+                    let index = X64Register::from_dwarf_regnum(loc.dwarf_regnum)
+                        .expect("invalid regnum")
+                        .to_index();
+                    regs.push((index, mv));
+                }
+                LocationType::Constant => {
+                    let v = loc.offset_or_small_constant as u32 as u64;
+                    match mv {
+                        MachineValue::WasmStack(x) => {
+                            stack_constants.insert(x, v);
+                            *wasm_stack.last_mut().unwrap() = WasmAbstractValue::Const(v);
+                        }
+                        _ => {} // TODO
+                    }
+                }
+                LocationType::ConstantIndex => {
+                    let v =
+                        llvm_map.constants[loc.offset_or_small_constant as usize].large_constant;
+                    match mv {
+                        MachineValue::WasmStack(x) => {
+                            stack_constants.insert(x, v);
+                            *wasm_stack.last_mut().unwrap() = WasmAbstractValue::Const(v);
+                        }
+                        _ => {} // TODO
+                    }
+                }
+                LocationType::Direct => match mv {
+                    MachineValue::WasmLocal(_) => {
+                        assert_eq!(loc.location_size, 8); // the pointer itself
+                        assert!(
+                            X64Register::from_dwarf_regnum(loc.dwarf_regnum).unwrap()
+                                == X64Register::GPR(GPR::RBP)
+                        );
+                        if loc.offset_or_small_constant >= 0 {
+                            assert!(loc.offset_or_small_constant >= 16); // (saved_rbp, return_address)
+                            assert!(loc.offset_or_small_constant % 8 == 0);
+                            prev_frame_diff
+                                .insert((loc.offset_or_small_constant as usize - 16) / 8, Some(mv));
+                        } else {
+                            let stack_offset = ((-loc.offset_or_small_constant) / 4) as usize;
+                            assert!(
+                                stack_offset > 0 && stack_offset <= machine_stack_half_layout.len()
+                            );
+                            machine_stack_half_layout[stack_offset - 1] = mv;
+                        }
+                    }
+                    _ => unreachable!(
+                        "Direct location type is not expected for values other than local"
+                    ),
+                },
+                LocationType::Indirect => {
+                    assert!(loc.offset_or_small_constant < 0);
+                    assert!(
+                        X64Register::from_dwarf_regnum(loc.dwarf_regnum).unwrap()
+                            == X64Register::GPR(GPR::RBP)
+                    );
+                    let stack_offset = ((-loc.offset_or_small_constant) / 4) as usize;
+                    assert!(stack_offset > 0 && stack_offset <= machine_stack_half_layout.len());
+                    machine_stack_half_layout[stack_offset - 1] = mv;
+                }
+            }
+        }
+
+        assert_eq!(wasm_stack.len(), self.stack_count);
+        assert_eq!(wasm_locals.len(), self.local_count);
+
+        let mut machine_stack_layout: Vec<MachineValue> =
+            Vec::with_capacity(machine_stack_half_layout.len() / 2);
+
+        for i in 0..machine_stack_half_layout.len() / 2 {
+            let major = &machine_stack_half_layout[i * 2 + 1]; // mod 8 == 0
+            let minor = &machine_stack_half_layout[i * 2]; // mod 8 == 4
+            let only_major = match *minor {
+                MachineValue::Undefined => true,
+                _ => false,
+            };
+            if only_major {
+                machine_stack_layout.push(major.clone());
+            } else {
+                machine_stack_layout.push(MachineValue::TwoHalves(Box::new((
+                    major.clone(),
+                    minor.clone(),
+                ))));
+            }
+        }
+
+        let diff = MachineStateDiff {
+            last: None,
+            stack_push: machine_stack_layout,
+            stack_pop: 0,
+            prev_frame_diff,
+            reg_diff: regs,
+            wasm_stack_push: wasm_stack,
+            wasm_stack_pop: 0,
+            wasm_inst_offset: self.opcode_offset,
+        };
+        let diff_id = fsm.diffs.len();
+        fsm.diffs.push(diff);
+
+        match self.kind {
+            StackmapEntryKind::FunctionHeader => {
+                fsm.locals = wasm_locals;
+            }
+            _ => {
+                assert_eq!(fsm.locals, wasm_locals);
+            }
+        }
+
+        let end_offset = {
+            if let Some(end) = end {
+                let (end_entry, end_record) = end;
+                assert_eq!(end_entry.is_start, false);
+                assert_eq!(self.opcode_offset, end_entry.opcode_offset);
+                let end_offset = func_base_addr + end_record.instruction_offset as usize;
+                assert!(end_offset >= target_offset);
+                end_offset
+            } else {
+                target_offset + 1
+            }
+        };
+
+        match self.kind {
+            StackmapEntryKind::Loop => {
+                fsm.wasm_offset_to_target_offset
+                    .insert(self.opcode_offset, SuspendOffset::Loop(target_offset));
+                fsm.loop_offsets.insert(
+                    target_offset,
+                    OffsetInfo {
+                        end_offset,
+                        diff_id,
+                        activate_offset: target_offset,
+                    },
+                );
+            }
+            StackmapEntryKind::Call => {
+                fsm.wasm_offset_to_target_offset
+                    .insert(self.opcode_offset, SuspendOffset::Call(target_offset));
+                fsm.call_offsets.insert(
+                    target_offset,
+                    OffsetInfo {
+                        end_offset: end_offset + 1, // The return address is just after 'call' instruction. Offset by one here.
+                        diff_id,
+                        activate_offset: target_offset,
+                    },
+                );
+            }
+            StackmapEntryKind::Trappable => {
+                fsm.wasm_offset_to_target_offset
+                    .insert(self.opcode_offset, SuspendOffset::Trappable(target_offset));
+                fsm.trappable_offsets.insert(
+                    target_offset,
+                    OffsetInfo {
+                        end_offset,
+                        diff_id,
+                        activate_offset: target_offset,
+                    },
+                );
+            }
+            StackmapEntryKind::FunctionHeader => {
+                fsm.wasm_function_header_target_offset = Some(SuspendOffset::Loop(target_offset));
+                fsm.loop_offsets.insert(
+                    target_offset,
+                    OffsetInfo {
+                        end_offset,
+                        diff_id,
+                        activate_offset: target_offset,
+                    },
+                );
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct StackMap {
+    pub version: u8,
+    pub stk_size_records: Vec<StkSizeRecord>,
+    pub constants: Vec<Constant>,
+    pub stk_map_records: Vec<StkMapRecord>,
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct StkSizeRecord {
+    pub function_address: u64,
+    pub stack_size: u64,
+    pub record_count: u64,
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Constant {
+    pub large_constant: u64,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct StkMapRecord {
+    pub patchpoint_id: u64,
+    pub instruction_offset: u32,
+    pub locations: Vec<Location>,
+    pub live_outs: Vec<LiveOut>,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct Location {
+    pub ty: LocationType,
+    pub location_size: u16,
+    pub dwarf_regnum: u16,
+    pub offset_or_small_constant: i32,
+}
+
+#[derive(Copy, Clone, Debug, Default)]
+pub struct LiveOut {
+    pub dwarf_regnum: u16,
+    pub size_in_bytes: u8,
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum LocationType {
+    Register,
+    Direct,
+    Indirect,
+    Constant,
+    ConstantIndex,
+}
+
+impl StackMap {
+    pub fn parse(raw: &[u8]) -> io::Result<StackMap> {
+        let mut reader = Cursor::new(raw);
+        let mut map = StackMap::default();
+
+        let version = reader.read_u8()?;
+        if version != 3 {
+            return Err(io::Error::new(io::ErrorKind::Other, "version is not 3"));
+        }
+        map.version = version;
+        if reader.read_u8()? != 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "reserved field is not zero (1)",
+            ));
+        }
+        if reader.read_u16::<LittleEndian>()? != 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "reserved field is not zero (2)",
+            ));
+        }
+        let num_functions = reader.read_u32::<LittleEndian>()?;
+        let num_constants = reader.read_u32::<LittleEndian>()?;
+        let num_records = reader.read_u32::<LittleEndian>()?;
+        for _ in 0..num_functions {
+            let mut record = StkSizeRecord::default();
+            record.function_address = reader.read_u64::<LittleEndian>()?;
+            record.stack_size = reader.read_u64::<LittleEndian>()?;
+            record.record_count = reader.read_u64::<LittleEndian>()?;
+            map.stk_size_records.push(record);
+        }
+        for _ in 0..num_constants {
+            map.constants.push(Constant {
+                large_constant: reader.read_u64::<LittleEndian>()?,
+            });
+        }
+        for _ in 0..num_records {
+            let mut record = StkMapRecord::default();
+
+            record.patchpoint_id = reader.read_u64::<LittleEndian>()?;
+            record.instruction_offset = reader.read_u32::<LittleEndian>()?;
+            if reader.read_u16::<LittleEndian>()? != 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "reserved field is not zero (3)",
+                ));
+            }
+            let num_locations = reader.read_u16::<LittleEndian>()?;
+            for _ in 0..num_locations {
+                let ty = reader.read_u8()?;
+
+                let mut location = Location {
+                    ty: match ty {
+                        1 => LocationType::Register,
+                        2 => LocationType::Direct,
+                        3 => LocationType::Indirect,
+                        4 => LocationType::Constant,
+                        5 => LocationType::ConstantIndex,
+                        _ => {
+                            return Err(io::Error::new(
+                                io::ErrorKind::Other,
+                                "unknown location type",
+                            ))
+                        }
+                    },
+                    location_size: 0,
+                    dwarf_regnum: 0,
+                    offset_or_small_constant: 0,
+                };
+
+                if reader.read_u8()? != 0 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "reserved field is not zero (4)",
+                    ));
+                }
+                location.location_size = reader.read_u16::<LittleEndian>()?;
+                location.dwarf_regnum = reader.read_u16::<LittleEndian>()?;
+                if reader.read_u16::<LittleEndian>()? != 0 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "reserved field is not zero (5)",
+                    ));
+                }
+                location.offset_or_small_constant = reader.read_i32::<LittleEndian>()?;
+
+                record.locations.push(location);
+            }
+            if reader.position() % 8 != 0 {
+                if reader.read_u32::<LittleEndian>()? != 0 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "reserved field is not zero (6)",
+                    ));
+                }
+            }
+            if reader.read_u16::<LittleEndian>()? != 0 {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "reserved field is not zero (7)",
+                ));
+            }
+            let num_live_outs = reader.read_u16::<LittleEndian>()?;
+            for _ in 0..num_live_outs {
+                let mut liveout = LiveOut::default();
+
+                liveout.dwarf_regnum = reader.read_u16::<LittleEndian>()?;
+                if reader.read_u8()? != 0 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "reserved field is not zero (8)",
+                    ));
+                }
+                liveout.size_in_bytes = reader.read_u8()?;
+
+                record.live_outs.push(liveout);
+            }
+            if reader.position() % 8 != 0 {
+                if reader.read_u32::<LittleEndian>()? != 0 {
+                    return Err(io::Error::new(
+                        io::ErrorKind::Other,
+                        "reserved field is not zero (9)",
+                    ));
+                }
+            }
+
+            map.stk_map_records.push(record);
+        }
+        Ok(map)
+    }
+}
+
+fn deref_global(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
+    let mut x: Vec<usize> = match GlobalIndex::new(idx).local_or_import(info) {
+        LocalOrImport::Local(idx) => vec![Ctx::offset_globals() as usize, idx.index() * 8, 0],
+        LocalOrImport::Import(idx) => {
+            vec![Ctx::offset_imported_globals() as usize, idx.index() * 8, 0]
+        }
+    };
+    if deref_into_value {
+        x.push(0);
+    }
+    x
+}
+
+fn deref_table_base(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
+    let mut x: Vec<usize> = match TableIndex::new(idx).local_or_import(info) {
+        LocalOrImport::Local(idx) => vec![Ctx::offset_tables() as usize, idx.index() * 8, 0],
+        LocalOrImport::Import(idx) => {
+            vec![Ctx::offset_imported_tables() as usize, idx.index() * 8, 0]
+        }
+    };
+    if deref_into_value {
+        x.push(0);
+    }
+    x
+}
+
+fn deref_table_bound(info: &ModuleInfo, idx: usize, deref_into_value: bool) -> Vec<usize> {
+    let mut x: Vec<usize> = match TableIndex::new(idx).local_or_import(info) {
+        LocalOrImport::Local(idx) => vec![Ctx::offset_tables() as usize, idx.index() * 8, 8],
+        LocalOrImport::Import(idx) => {
+            vec![Ctx::offset_imported_tables() as usize, idx.index() * 8, 8]
+        }
+    };
+    if deref_into_value {
+        x.push(0);
+    }
+    x
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/state.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/state.rs
new file mode 100644
index 0000000..339d325
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-llvm/src/translator/state.rs
@@ -0,0 +1,439 @@
+use inkwell::{
+    basic_block::BasicBlock,
+    values::{BasicValue, BasicValueEnum, PhiValue},
+};
+use smallvec::SmallVec;
+use std::ops::{BitAnd, BitOr, BitOrAssign};
+use wasmer_types::CompileError;
+
+#[derive(Debug)]
+pub enum ControlFrame<'ctx> {
+    Block {
+        next: BasicBlock<'ctx>,
+        phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        stack_size_snapshot: usize,
+    },
+    Loop {
+        body: BasicBlock<'ctx>,
+        next: BasicBlock<'ctx>,
+        phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        loop_body_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        stack_size_snapshot: usize,
+    },
+    IfElse {
+        if_then: BasicBlock<'ctx>,
+        if_else: BasicBlock<'ctx>,
+        next: BasicBlock<'ctx>,
+        then_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        else_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        next_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        stack_size_snapshot: usize,
+        if_else_state: IfElseState,
+    },
+}
+
+#[derive(Debug)]
+pub enum IfElseState {
+    If,
+    Else,
+}
+
+impl<'ctx> ControlFrame<'ctx> {
+    pub fn code_after(&self) -> &BasicBlock<'ctx> {
+        match self {
+            ControlFrame::Block { ref next, .. }
+            | ControlFrame::Loop { ref next, .. }
+            | ControlFrame::IfElse { ref next, .. } => next,
+        }
+    }
+
+    pub fn br_dest(&self) -> &BasicBlock<'ctx> {
+        match self {
+            ControlFrame::Block { ref next, .. } | ControlFrame::IfElse { ref next, .. } => next,
+            ControlFrame::Loop { ref body, .. } => body,
+        }
+    }
+
+    pub fn phis(&self) -> &[PhiValue<'ctx>] {
+        match self {
+            ControlFrame::Block { ref phis, .. } | ControlFrame::Loop { ref phis, .. } => {
+                phis.as_slice()
+            }
+            ControlFrame::IfElse { ref next_phis, .. } => next_phis.as_slice(),
+        }
+    }
+
+    /// PHI nodes for stack values in the loop body.
+    pub fn loop_body_phis(&self) -> &[PhiValue<'ctx>] {
+        match self {
+            ControlFrame::Block { .. } | ControlFrame::IfElse { .. } => &[],
+            ControlFrame::Loop {
+                ref loop_body_phis, ..
+            } => loop_body_phis.as_slice(),
+        }
+    }
+
+    pub fn is_loop(&self) -> bool {
+        matches!(self, ControlFrame::Loop { .. })
+    }
+}
+
+#[derive(Debug, Default, Eq, PartialEq, Copy, Clone, Hash)]
+pub struct ExtraInfo {
+    state: u8,
+}
+impl ExtraInfo {
+    // This value is required to be arithmetic 32-bit NaN (or 32x4) by the WAsm
+    // machine, but which might not be in the LLVM value. The conversion to
+    // arithmetic NaN is pending. It is required for correctness.
+    //
+    // When applied to a 64-bit value, this flag has no meaning and must be
+    // ignored. It may be set in such cases to allow for common handling of
+    // 32 and 64-bit operations.
+    pub const fn pending_f32_nan() -> ExtraInfo {
+        ExtraInfo { state: 1 }
+    }
+
+    // This value is required to be arithmetic 64-bit NaN (or 64x2) by the WAsm
+    // machine, but which might not be in the LLVM value. The conversion to
+    // arithmetic NaN is pending. It is required for correctness.
+    //
+    // When applied to a 32-bit value, this flag has no meaning and must be
+    // ignored. It may be set in such cases to allow for common handling of
+    // 32 and 64-bit operations.
+    pub const fn pending_f64_nan() -> ExtraInfo {
+        ExtraInfo { state: 2 }
+    }
+
+    // This value either does not contain a 32-bit NaN, or it contains an
+    // arithmetic NaN. In SIMD, applies to all 4 lanes.
+    pub const fn arithmetic_f32() -> ExtraInfo {
+        ExtraInfo { state: 4 }
+    }
+
+    // This value either does not contain a 64-bit NaN, or it contains an
+    // arithmetic NaN. In SIMD, applies to both lanes.
+    pub const fn arithmetic_f64() -> ExtraInfo {
+        ExtraInfo { state: 8 }
+    }
+
+    pub const fn has_pending_f32_nan(&self) -> bool {
+        self.state & ExtraInfo::pending_f32_nan().state != 0
+    }
+    pub const fn has_pending_f64_nan(&self) -> bool {
+        self.state & ExtraInfo::pending_f64_nan().state != 0
+    }
+    pub const fn is_arithmetic_f32(&self) -> bool {
+        self.state & ExtraInfo::arithmetic_f32().state != 0
+    }
+    pub const fn is_arithmetic_f64(&self) -> bool {
+        self.state & ExtraInfo::arithmetic_f64().state != 0
+    }
+
+    pub const fn strip_pending(&self) -> ExtraInfo {
+        ExtraInfo {
+            state: self.state
+                & !(ExtraInfo::pending_f32_nan().state | ExtraInfo::pending_f64_nan().state),
+        }
+    }
+}
+
+// Union two ExtraInfos.
+impl BitOr for ExtraInfo {
+    type Output = Self;
+
+    fn bitor(self, other: Self) -> Self {
+        debug_assert!(!(self.has_pending_f32_nan() && other.has_pending_f64_nan()));
+        debug_assert!(!(self.has_pending_f64_nan() && other.has_pending_f32_nan()));
+        ExtraInfo {
+            state: if self.is_arithmetic_f32() || other.is_arithmetic_f32() {
+                ExtraInfo::arithmetic_f32().state
+            } else if self.has_pending_f32_nan() || other.has_pending_f32_nan() {
+                ExtraInfo::pending_f32_nan().state
+            } else {
+                0
+            } + if self.is_arithmetic_f64() || other.is_arithmetic_f64() {
+                ExtraInfo::arithmetic_f64().state
+            } else if self.has_pending_f64_nan() || other.has_pending_f64_nan() {
+                ExtraInfo::pending_f64_nan().state
+            } else {
+                0
+            },
+        }
+    }
+}
+impl BitOrAssign for ExtraInfo {
+    fn bitor_assign(&mut self, other: Self) {
+        *self = *self | other;
+    }
+}
+
+// Intersection for ExtraInfo.
+impl BitAnd for ExtraInfo {
+    type Output = Self;
+    fn bitand(self, other: Self) -> Self {
+        // Pending canonicalizations are not safe to discard, or even reorder.
+        debug_assert!(
+            self.has_pending_f32_nan() == other.has_pending_f32_nan()
+                || self.is_arithmetic_f32()
+                || other.is_arithmetic_f32()
+        );
+        debug_assert!(
+            self.has_pending_f64_nan() == other.has_pending_f64_nan()
+                || self.is_arithmetic_f64()
+                || other.is_arithmetic_f64()
+        );
+        let info = match (
+            self.is_arithmetic_f32() && other.is_arithmetic_f32(),
+            self.is_arithmetic_f64() && other.is_arithmetic_f64(),
+        ) {
+            (false, false) => Default::default(),
+            (true, false) => ExtraInfo::arithmetic_f32(),
+            (false, true) => ExtraInfo::arithmetic_f64(),
+            (true, true) => ExtraInfo::arithmetic_f32() | ExtraInfo::arithmetic_f64(),
+        };
+        match (self.has_pending_f32_nan(), self.has_pending_f64_nan()) {
+            (false, false) => info,
+            (true, false) => info | ExtraInfo::pending_f32_nan(),
+            (false, true) => info | ExtraInfo::pending_f64_nan(),
+            (true, true) => unreachable!("Can't form ExtraInfo with two pending canonicalizations"),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct State<'ctx> {
+    pub stack: Vec<(BasicValueEnum<'ctx>, ExtraInfo)>,
+    control_stack: Vec<ControlFrame<'ctx>>,
+
+    pub reachable: bool,
+}
+
+impl<'ctx> State<'ctx> {
+    pub fn new() -> Self {
+        Self {
+            stack: vec![],
+            control_stack: vec![],
+            reachable: true,
+        }
+    }
+
+    pub fn has_control_frames(&self) -> bool {
+        !self.control_stack.is_empty()
+    }
+
+    pub fn reset_stack(&mut self, frame: &ControlFrame<'ctx>) {
+        let stack_size_snapshot = match frame {
+            ControlFrame::Block {
+                stack_size_snapshot,
+                ..
+            }
+            | ControlFrame::Loop {
+                stack_size_snapshot,
+                ..
+            }
+            | ControlFrame::IfElse {
+                stack_size_snapshot,
+                ..
+            } => *stack_size_snapshot,
+        };
+        self.stack.truncate(stack_size_snapshot);
+    }
+
+    pub fn outermost_frame(&self) -> Result<&ControlFrame<'ctx>, CompileError> {
+        self.control_stack.get(0).ok_or_else(|| {
+            CompileError::Codegen("outermost_frame: invalid control stack depth".to_string())
+        })
+    }
+
+    pub fn frame_at_depth(&self, depth: u32) -> Result<&ControlFrame<'ctx>, CompileError> {
+        let index = self
+            .control_stack
+            .len()
+            .checked_sub(1 + (depth as usize))
+            .ok_or_else(|| {
+                CompileError::Codegen("frame_at_depth: invalid control stack depth".to_string())
+            })?;
+        Ok(&self.control_stack[index])
+    }
+
+    pub fn frame_at_depth_mut(
+        &mut self,
+        depth: u32,
+    ) -> Result<&mut ControlFrame<'ctx>, CompileError> {
+        let index = self
+            .control_stack
+            .len()
+            .checked_sub(1 + (depth as usize))
+            .ok_or_else(|| {
+                CompileError::Codegen("frame_at_depth_mut: invalid control stack depth".to_string())
+            })?;
+        Ok(&mut self.control_stack[index])
+    }
+
+    pub fn pop_frame(&mut self) -> Result<ControlFrame<'ctx>, CompileError> {
+        self.control_stack.pop().ok_or_else(|| {
+            CompileError::Codegen("pop_frame: cannot pop from control stack".to_string())
+        })
+    }
+
+    pub fn push1<T: BasicValue<'ctx>>(&mut self, value: T) {
+        self.push1_extra(value, Default::default());
+    }
+
+    pub fn push1_extra<T: BasicValue<'ctx>>(&mut self, value: T, info: ExtraInfo) {
+        self.stack.push((value.as_basic_value_enum(), info));
+    }
+
+    pub fn pop1(&mut self) -> Result<BasicValueEnum<'ctx>, CompileError> {
+        Ok(self.pop1_extra()?.0)
+    }
+
+    pub fn pop1_extra(&mut self) -> Result<(BasicValueEnum<'ctx>, ExtraInfo), CompileError> {
+        self.stack
+            .pop()
+            .ok_or_else(|| CompileError::Codegen("pop1_extra: invalid value stack".to_string()))
+    }
+
+    pub fn pop2(&mut self) -> Result<(BasicValueEnum<'ctx>, BasicValueEnum<'ctx>), CompileError> {
+        let v2 = self.pop1()?;
+        let v1 = self.pop1()?;
+        Ok((v1, v2))
+    }
+
+    #[allow(clippy::type_complexity)]
+    pub fn pop2_extra(
+        &mut self,
+    ) -> Result<
+        (
+            (BasicValueEnum<'ctx>, ExtraInfo),
+            (BasicValueEnum<'ctx>, ExtraInfo),
+        ),
+        CompileError,
+    > {
+        let v2 = self.pop1_extra()?;
+        let v1 = self.pop1_extra()?;
+        Ok((v1, v2))
+    }
+
+    pub fn pop3(
+        &mut self,
+    ) -> Result<
+        (
+            BasicValueEnum<'ctx>,
+            BasicValueEnum<'ctx>,
+            BasicValueEnum<'ctx>,
+        ),
+        CompileError,
+    > {
+        let v3 = self.pop1()?;
+        let v2 = self.pop1()?;
+        let v1 = self.pop1()?;
+        Ok((v1, v2, v3))
+    }
+
+    #[allow(clippy::type_complexity)]
+    pub fn pop3_extra(
+        &mut self,
+    ) -> Result<
+        (
+            (BasicValueEnum<'ctx>, ExtraInfo),
+            (BasicValueEnum<'ctx>, ExtraInfo),
+            (BasicValueEnum<'ctx>, ExtraInfo),
+        ),
+        CompileError,
+    > {
+        let v3 = self.pop1_extra()?;
+        let v2 = self.pop1_extra()?;
+        let v1 = self.pop1_extra()?;
+        Ok((v1, v2, v3))
+    }
+
+    pub fn peek1_extra(&self) -> Result<(BasicValueEnum<'ctx>, ExtraInfo), CompileError> {
+        let index =
+            self.stack.len().checked_sub(1).ok_or_else(|| {
+                CompileError::Codegen("peek1_extra: invalid value stack".to_string())
+            })?;
+        Ok(self.stack[index])
+    }
+
+    pub fn peekn(&self, n: usize) -> Result<Vec<BasicValueEnum<'ctx>>, CompileError> {
+        Ok(self.peekn_extra(n)?.iter().map(|x| x.0).collect())
+    }
+
+    pub fn peekn_extra(
+        &self,
+        n: usize,
+    ) -> Result<&[(BasicValueEnum<'ctx>, ExtraInfo)], CompileError> {
+        let index =
+            self.stack.len().checked_sub(n).ok_or_else(|| {
+                CompileError::Codegen("peekn_extra: invalid value stack".to_string())
+            })?;
+        Ok(&self.stack[index..])
+    }
+
+    pub fn popn_save_extra(
+        &mut self,
+        n: usize,
+    ) -> Result<Vec<(BasicValueEnum<'ctx>, ExtraInfo)>, CompileError> {
+        let v = self.peekn_extra(n)?.to_vec();
+        self.popn(n)?;
+        Ok(v)
+    }
+
+    pub fn popn(&mut self, n: usize) -> Result<(), CompileError> {
+        let index = self
+            .stack
+            .len()
+            .checked_sub(n)
+            .ok_or_else(|| CompileError::Codegen("popn: invalid value stack".to_string()))?;
+
+        self.stack.truncate(index);
+        Ok(())
+    }
+
+    pub fn push_block(&mut self, next: BasicBlock<'ctx>, phis: SmallVec<[PhiValue<'ctx>; 1]>) {
+        self.control_stack.push(ControlFrame::Block {
+            next,
+            phis,
+            stack_size_snapshot: self.stack.len(),
+        });
+    }
+
+    pub fn push_loop(
+        &mut self,
+        body: BasicBlock<'ctx>,
+        next: BasicBlock<'ctx>,
+        loop_body_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        phis: SmallVec<[PhiValue<'ctx>; 1]>,
+    ) {
+        self.control_stack.push(ControlFrame::Loop {
+            body,
+            next,
+            loop_body_phis,
+            phis,
+            stack_size_snapshot: self.stack.len(),
+        });
+    }
+
+    pub fn push_if(
+        &mut self,
+        if_then: BasicBlock<'ctx>,
+        if_else: BasicBlock<'ctx>,
+        next: BasicBlock<'ctx>,
+        then_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        else_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+        next_phis: SmallVec<[PhiValue<'ctx>; 1]>,
+    ) {
+        self.control_stack.push(ControlFrame::IfElse {
+            if_then,
+            if_else,
+            next,
+            then_phis,
+            else_phis,
+            next_phis,
+            stack_size_snapshot: self.stack.len(),
+            if_else_state: IfElseState::If,
+        });
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/Cargo.toml
new file mode 100644
index 0000000..cad3da6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/Cargo.toml
@@ -0,0 +1,48 @@
+[package]
+name = "wasmer-compiler-singlepass"
+description = "Singlepass compiler for Wasmer WebAssembly runtime"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly", "compiler", "singlepass"]
+documentation = "https://docs.rs/wasmer-compiler-singlepass/"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer-compiler = { path = "../compiler", version = "=4.2.8", features = ["translator", "compiler"], default-features = false }
+wasmer-types = { path = "../types", version = "=4.2.8", default-features = false, features = ["std"] }
+hashbrown = { version = "0.11", optional = true }
+gimli = { version = "0.26", optional = true }
+enumset.workspace = true
+more-asserts = "0.2"
+dynasm = "1.2.3"
+dynasmrt = "1.2.3"
+lazy_static = "1.4"
+byteorder = "1.3"
+smallvec = "1.6"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+rayon = { version = "1.5", optional = true }
+
+[dev-dependencies]
+target-lexicon = { version = "0.12.2", default-features = false }
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[features]
+default = ["std", "rayon", "unwind", "avx"]
+wasm = ["std", "unwind", "avx"]
+std = ["wasmer-compiler/std", "wasmer-types/std"]
+core = ["hashbrown", "wasmer-types/core"]
+unwind = ["gimli"]
+sse = []
+avx = []
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/README.md b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/README.md
new file mode 100644
index 0000000..6b78877
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/README.md
@@ -0,0 +1,33 @@
+# `wasmer-compiler-singlepass` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-compiler-singlepass.svg)](https://crates.io/crates/wasmer-compiler-singlepass)
+
+This crate contains a compiler implementation based on the Singlepass linear compiler.
+
+## Usage
+
+```rust
+use wasmer::{Store, EngineBuilder};
+use wasmer_compiler_singlepass::Singlepass;
+
+let compiler = Singlepass::new();
+let mut store = Store::new(compiler);
+```
+
+*Note: you can find a [full working example using Singlepass compiler
+here][example].*
+
+## When to use Singlepass
+
+Singlepass is designed to emit compiled code at linear time, as such
+is not prone to JIT bombs and also offers great compilation
+performance orders of magnitude faster than
+[`wasmer-compiler-cranelift`] and [`wasmer-compiler-llvm`], however
+with a bit slower runtime speed.
+
+The fact that singlepass is not prone to JIT bombs and offers a very
+predictable compilation speed makes it ideal for **blockchains** and other
+systems where fast and consistent compilation times are very critical.
+
+
+[example]: https://github.com/wasmerio/wasmer/blob/master/examples/compiler_singlepass.rs
+[`wasmer-compiler-cranelift`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-cranelift
+[`wasmer-compiler-llvm`]: https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/address_map.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/address_map.rs
new file mode 100644
index 0000000..cc4eb6c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/address_map.rs
@@ -0,0 +1,21 @@
+use wasmer_compiler::FunctionBodyData;
+use wasmer_types::{FunctionAddressMap, InstructionAddressMap, SourceLoc};
+
+pub fn get_function_address_map(
+    instructions: Vec<InstructionAddressMap>,
+    data: &FunctionBodyData,
+    body_len: usize,
+) -> FunctionAddressMap {
+    // Generate source loc for a function start/end to identify boundary within module.
+    // It will wrap around if byte code is larger than 4 GB.
+    let start_srcloc = SourceLoc::new(data.module_offset as u32);
+    let end_srcloc = SourceLoc::new((data.module_offset + data.data.len()) as u32);
+
+    FunctionAddressMap {
+        instructions,
+        start_srcloc,
+        end_srcloc,
+        body_offset: 0,
+        body_len,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/arm64_decl.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/arm64_decl.rs
new file mode 100644
index 0000000..b000bdd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/arm64_decl.rs
@@ -0,0 +1,317 @@
+//! ARM64 structures.
+
+use crate::common_decl::{MachineState, MachineValue, RegisterIndex};
+use crate::location::CombinedRegister;
+use crate::location::Reg as AbstractReg;
+use std::collections::BTreeMap;
+use std::slice::Iter;
+use wasmer_types::{CallingConvention, Type};
+
+/// General-purpose registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum GPR {
+    X0 = 0,
+    X1 = 1,
+    X2 = 2,
+    X3 = 3,
+    X4 = 4,
+    X5 = 5,
+    X6 = 6,
+    X7 = 7,
+    X8 = 8,
+    X9 = 9,
+    X10 = 10,
+    X11 = 11,
+    X12 = 12,
+    X13 = 13,
+    X14 = 14,
+    X15 = 15,
+    X16 = 16,
+    X17 = 17,
+    X18 = 18,
+    X19 = 19,
+    X20 = 20,
+    X21 = 21,
+    X22 = 22,
+    X23 = 23,
+    X24 = 24,
+    X25 = 25,
+    X26 = 26,
+    X27 = 27,
+    X28 = 28,
+    X29 = 29,
+    X30 = 30,
+    XzrSp = 31,
+}
+
+/// NEON registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[allow(dead_code)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum NEON {
+    V0 = 0,
+    V1 = 1,
+    V2 = 2,
+    V3 = 3,
+    V4 = 4,
+    V5 = 5,
+    V6 = 6,
+    V7 = 7,
+    V8 = 8,
+    V9 = 9,
+    V10 = 10,
+    V11 = 11,
+    V12 = 12,
+    V13 = 13,
+    V14 = 14,
+    V15 = 15,
+    V16 = 16,
+    V17 = 17,
+    V18 = 18,
+    V19 = 19,
+    V20 = 20,
+    V21 = 21,
+    V22 = 22,
+    V23 = 23,
+    V24 = 24,
+    V25 = 25,
+    V26 = 26,
+    V27 = 27,
+    V28 = 28,
+    V29 = 29,
+    V30 = 30,
+    V31 = 31,
+}
+
+impl AbstractReg for GPR {
+    fn is_callee_save(self) -> bool {
+        self as usize > 18
+    }
+    fn is_reserved(self) -> bool {
+        !matches!(self.into_index(), 0..=16 | 19..=27)
+    }
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<GPR, ()> {
+        match n {
+            0..=31 => Ok(*GPR::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, GPR> {
+        static GPRS: [GPR; 32] = [
+            GPR::X0,
+            GPR::X1,
+            GPR::X2,
+            GPR::X3,
+            GPR::X4,
+            GPR::X5,
+            GPR::X6,
+            GPR::X7,
+            GPR::X8,
+            GPR::X9,
+            GPR::X10,
+            GPR::X11,
+            GPR::X12,
+            GPR::X13,
+            GPR::X14,
+            GPR::X15,
+            GPR::X16,
+            GPR::X17,
+            GPR::X18,
+            GPR::X19,
+            GPR::X20,
+            GPR::X21,
+            GPR::X22,
+            GPR::X23,
+            GPR::X24,
+            GPR::X25,
+            GPR::X26,
+            GPR::X27,
+            GPR::X28,
+            GPR::X29,
+            GPR::X30,
+            GPR::XzrSp,
+        ];
+        GPRS.iter()
+    }
+    fn to_dwarf(self) -> u16 {
+        self.into_index() as u16
+    }
+}
+
+impl AbstractReg for NEON {
+    fn is_callee_save(self) -> bool {
+        self as usize > 16
+    }
+    fn is_reserved(self) -> bool {
+        false
+    }
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<NEON, ()> {
+        match n {
+            0..=31 => Ok(*NEON::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, NEON> {
+        const NEONS: [NEON; 32] = [
+            NEON::V0,
+            NEON::V1,
+            NEON::V2,
+            NEON::V3,
+            NEON::V4,
+            NEON::V5,
+            NEON::V6,
+            NEON::V7,
+            NEON::V8,
+            NEON::V9,
+            NEON::V10,
+            NEON::V11,
+            NEON::V12,
+            NEON::V13,
+            NEON::V14,
+            NEON::V15,
+            NEON::V16,
+            NEON::V17,
+            NEON::V18,
+            NEON::V19,
+            NEON::V20,
+            NEON::V21,
+            NEON::V22,
+            NEON::V23,
+            NEON::V24,
+            NEON::V25,
+            NEON::V26,
+            NEON::V27,
+            NEON::V28,
+            NEON::V29,
+            NEON::V30,
+            NEON::V31,
+        ];
+        NEONS.iter()
+    }
+    fn to_dwarf(self) -> u16 {
+        self.into_index() as u16 + 64
+    }
+}
+
+/// A machine register under the x86-64 architecture.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum ARM64Register {
+    /// General-purpose registers.
+    GPR(GPR),
+    /// NEON (floating point/SIMD) registers.
+    NEON(NEON),
+}
+
+impl CombinedRegister for ARM64Register {
+    /// Returns the index of the register.
+    fn to_index(&self) -> RegisterIndex {
+        match *self {
+            ARM64Register::GPR(x) => RegisterIndex(x as usize),
+            ARM64Register::NEON(x) => RegisterIndex(x as usize + 64),
+        }
+    }
+    /// Convert from a GPR register
+    fn from_gpr(x: u16) -> Self {
+        ARM64Register::GPR(GPR::from_index(x as usize).unwrap())
+    }
+    /// Convert from an SIMD register
+    fn from_simd(x: u16) -> Self {
+        ARM64Register::NEON(NEON::from_index(x as usize).unwrap())
+    }
+
+    /// Converts a DWARF regnum to ARM64Register.
+    fn _from_dwarf_regnum(x: u16) -> Option<ARM64Register> {
+        Some(match x {
+            0..=31 => ARM64Register::GPR(GPR::from_index(x as usize).unwrap()),
+            64..=95 => ARM64Register::NEON(NEON::from_index(x as usize - 64).unwrap()),
+            _ => return None,
+        })
+    }
+}
+
+/// An allocator that allocates registers for function arguments according to the System V ABI.
+#[derive(Default)]
+pub struct ArgumentRegisterAllocator {
+    n_gprs: usize,
+    n_neons: usize,
+}
+
+impl ArgumentRegisterAllocator {
+    /// Allocates a register for argument type `ty`. Returns `None` if no register is available for this type.
+    pub fn next(
+        &mut self,
+        ty: Type,
+        calling_convention: CallingConvention,
+    ) -> Option<ARM64Register> {
+        match calling_convention {
+            CallingConvention::SystemV | CallingConvention::AppleAarch64 => {
+                static GPR_SEQ: &[GPR] = &[
+                    GPR::X0,
+                    GPR::X1,
+                    GPR::X2,
+                    GPR::X3,
+                    GPR::X4,
+                    GPR::X5,
+                    GPR::X6,
+                    GPR::X7,
+                ];
+                static NEON_SEQ: &[NEON] = &[
+                    NEON::V0,
+                    NEON::V1,
+                    NEON::V2,
+                    NEON::V3,
+                    NEON::V4,
+                    NEON::V5,
+                    NEON::V6,
+                    NEON::V7,
+                ];
+                match ty {
+                    Type::I32 | Type::I64 => {
+                        if self.n_gprs < GPR_SEQ.len() {
+                            let gpr = GPR_SEQ[self.n_gprs];
+                            self.n_gprs += 1;
+                            Some(ARM64Register::GPR(gpr))
+                        } else {
+                            None
+                        }
+                    }
+                    Type::F32 | Type::F64 => {
+                        if self.n_neons < NEON_SEQ.len() {
+                            let neon = NEON_SEQ[self.n_neons];
+                            self.n_neons += 1;
+                            Some(ARM64Register::NEON(neon))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => todo!(
+                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
+                        ty
+                    ),
+                }
+            }
+            _ => unimplemented!(),
+        }
+    }
+}
+
+/// Create a new `MachineState` with default values.
+pub fn new_machine_state() -> MachineState {
+    MachineState {
+        stack_values: vec![],
+        register_values: vec![MachineValue::Undefined; 32 + 32],
+        prev_frame: BTreeMap::new(),
+        wasm_stack: vec![],
+        wasm_inst_offset: std::usize::MAX,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/codegen.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/codegen.rs
new file mode 100644
index 0000000..ab7a783
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/codegen.rs
@@ -0,0 +1,6745 @@
+use crate::address_map::get_function_address_map;
+use crate::codegen_error;
+#[cfg(feature = "unwind")]
+use crate::dwarf::WriterRelocate;
+use crate::location::{Location, Reg};
+use crate::machine::{Label, Machine, MachineStackOffset, NATIVE_PAGE_SIZE};
+use crate::unwind::UnwindFrame;
+use crate::{common_decl::*, config::Singlepass};
+#[cfg(feature = "unwind")]
+use gimli::write::Address;
+use smallvec::{smallvec, SmallVec};
+use std::cmp;
+use std::iter;
+use wasmer_compiler::wasmparser::{
+    BlockType as WpTypeOrFuncType, HeapType as WpHeapType, Operator, RefType as WpRefType,
+    ValType as WpType,
+};
+use wasmer_compiler::FunctionBodyData;
+#[cfg(feature = "unwind")]
+use wasmer_types::CompiledFunctionUnwindInfo;
+use wasmer_types::{
+    entity::{EntityRef, PrimaryMap},
+    CallingConvention, CompileError, FunctionIndex, FunctionType, GlobalIndex, LocalFunctionIndex,
+    LocalMemoryIndex, MemoryIndex, MemoryStyle, ModuleInfo, Relocation, RelocationTarget,
+    SectionIndex, SignatureIndex, TableIndex, TableStyle, TrapCode, Type, VMBuiltinFunctionIndex,
+    VMOffsets,
+};
+use wasmer_types::{CompiledFunction, CompiledFunctionFrameInfo, FunctionBody};
+
+/// The singlepass per-function code generator.
+pub struct FuncGen<'a, M: Machine> {
+    // Immutable properties assigned at creation time.
+    /// Static module information.
+    module: &'a ModuleInfo,
+
+    /// ModuleInfo compilation config.
+    config: &'a Singlepass,
+
+    /// Offsets of vmctx fields.
+    vmoffsets: &'a VMOffsets,
+
+    // // Memory plans.
+    memory_styles: &'a PrimaryMap<MemoryIndex, MemoryStyle>,
+
+    // // Table plans.
+    // table_styles: &'a PrimaryMap<TableIndex, TableStyle>,
+    /// Function signature.
+    signature: FunctionType,
+
+    // Working storage.
+    /// Memory locations of local variables.
+    locals: Vec<Location<M::GPR, M::SIMD>>,
+
+    /// Types of local variables, including arguments.
+    local_types: Vec<WpType>,
+
+    /// Value stack.
+    value_stack: Vec<Location<M::GPR, M::SIMD>>,
+
+    /// Metadata about floating point values on the stack.
+    fp_stack: Vec<FloatValue>,
+
+    /// A list of frames describing the current control stack.
+    control_stack: Vec<ControlFrame>,
+
+    stack_offset: MachineStackOffset,
+
+    save_area_offset: Option<MachineStackOffset>,
+
+    state: MachineState,
+
+    track_state: bool,
+
+    /// Low-level machine state.
+    machine: M,
+
+    /// Nesting level of unreachable code.
+    unreachable_depth: usize,
+
+    /// Function state map. Not yet used in the reborn version but let's keep it.
+    fsm: FunctionStateMap,
+
+    /// Relocation information.
+    relocations: Vec<Relocation>,
+
+    /// A set of special labels for trapping.
+    special_labels: SpecialLabelSet,
+
+    /// Calling convention to use.
+    calling_convention: CallingConvention,
+}
+
+struct SpecialLabelSet {
+    integer_division_by_zero: Label,
+    integer_overflow: Label,
+    heap_access_oob: Label,
+    table_access_oob: Label,
+    indirect_call_null: Label,
+    bad_signature: Label,
+    unaligned_atomic: Label,
+}
+
+/// Metadata about a floating-point value.
+#[derive(Copy, Clone, Debug)]
+struct FloatValue {
+    /// Do we need to canonicalize the value before its bit pattern is next observed? If so, how?
+    canonicalization: Option<CanonicalizeType>,
+
+    /// Corresponding depth in the main value stack.
+    depth: usize,
+}
+
+impl FloatValue {
+    fn new(depth: usize) -> Self {
+        FloatValue {
+            canonicalization: None,
+            depth,
+        }
+    }
+
+    fn cncl_f32(depth: usize) -> Self {
+        FloatValue {
+            canonicalization: Some(CanonicalizeType::F32),
+            depth,
+        }
+    }
+
+    fn cncl_f64(depth: usize) -> Self {
+        FloatValue {
+            canonicalization: Some(CanonicalizeType::F64),
+            depth,
+        }
+    }
+
+    fn promote(self, depth: usize) -> Result<FloatValue, CompileError> {
+        let ret = FloatValue {
+            canonicalization: match self.canonicalization {
+                Some(CanonicalizeType::F32) => Some(CanonicalizeType::F64),
+                Some(CanonicalizeType::F64) => codegen_error!("cannot promote F64"),
+                None => None,
+            },
+            depth,
+        };
+        Ok(ret)
+    }
+
+    fn demote(self, depth: usize) -> Result<FloatValue, CompileError> {
+        let ret = FloatValue {
+            canonicalization: match self.canonicalization {
+                Some(CanonicalizeType::F64) => Some(CanonicalizeType::F32),
+                Some(CanonicalizeType::F32) => codegen_error!("cannot demote F32"),
+                None => None,
+            },
+            depth,
+        };
+        Ok(ret)
+    }
+}
+
+/// Type of a pending canonicalization floating point value.
+/// Sometimes we don't have the type information elsewhere and therefore we need to track it here.
+#[derive(Copy, Clone, Debug)]
+enum CanonicalizeType {
+    F32,
+    F64,
+}
+
+impl CanonicalizeType {
+    fn to_size(self) -> Size {
+        match self {
+            CanonicalizeType::F32 => Size::S32,
+            CanonicalizeType::F64 => Size::S64,
+        }
+    }
+}
+
+trait PopMany<T> {
+    fn peek1(&self) -> Result<&T, CompileError>;
+    fn pop1(&mut self) -> Result<T, CompileError>;
+    fn pop2(&mut self) -> Result<(T, T), CompileError>;
+}
+
+impl<T> PopMany<T> for Vec<T> {
+    fn peek1(&self) -> Result<&T, CompileError> {
+        self.last()
+            .ok_or_else(|| CompileError::Codegen("peek1() expects at least 1 element".to_owned()))
+    }
+    fn pop1(&mut self) -> Result<T, CompileError> {
+        self.pop()
+            .ok_or_else(|| CompileError::Codegen("pop1() expects at least 1 element".to_owned()))
+    }
+    fn pop2(&mut self) -> Result<(T, T), CompileError> {
+        if self.len() < 2 {
+            return Err(CompileError::Codegen(
+                "pop2() expects at least 2 elements".to_owned(),
+            ));
+        }
+
+        let right = self.pop().unwrap();
+        let left = self.pop().unwrap();
+        Ok((left, right))
+    }
+}
+
+trait WpTypeExt {
+    fn is_float(&self) -> bool;
+}
+
+impl WpTypeExt for WpType {
+    fn is_float(&self) -> bool {
+        matches!(self, WpType::F32 | WpType::F64)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ControlFrame {
+    pub label: Label,
+    pub loop_like: bool,
+    pub if_else: IfElseState,
+    pub returns: SmallVec<[WpType; 1]>,
+    pub value_stack_depth: usize,
+    pub fp_stack_depth: usize,
+    pub state: MachineState,
+    pub state_diff_id: usize,
+}
+
+#[derive(Debug, Copy, Clone)]
+pub enum IfElseState {
+    None,
+    If(Label),
+    Else,
+}
+
+fn type_to_wp_type(ty: Type) -> WpType {
+    match ty {
+        Type::I32 => WpType::I32,
+        Type::I64 => WpType::I64,
+        Type::F32 => WpType::F32,
+        Type::F64 => WpType::F64,
+        Type::V128 => WpType::V128,
+        Type::ExternRef => WpType::Ref(WpRefType::new(true, WpHeapType::Extern).unwrap()),
+        Type::FuncRef => WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+    }
+}
+
+/// Abstraction for a 2-input, 1-output operator. Can be an integer/floating-point
+/// binop/cmpop.
+struct I2O1<R: Reg, S: Reg> {
+    loc_a: Location<R, S>,
+    loc_b: Location<R, S>,
+    ret: Location<R, S>,
+}
+
+impl<'a, M: Machine> FuncGen<'a, M> {
+    fn get_stack_offset(&self) -> usize {
+        self.stack_offset.0
+    }
+
+    /// Acquires locations from the machine state.
+    ///
+    /// If the returned locations are used for stack value, `release_location` needs to be called on them;
+    /// Otherwise, if the returned locations are used for locals, `release_location` does not need to be called on them.
+    #[allow(clippy::type_complexity)]
+    fn acquire_locations(
+        &mut self,
+        tys: &[(WpType, MachineValue)],
+        zeroed: bool,
+    ) -> Result<SmallVec<[Location<M::GPR, M::SIMD>; 1]>, CompileError> {
+        let mut ret = smallvec![];
+        let mut delta_stack_offset: usize = 0;
+
+        for (ty, mv) in tys {
+            let loc = match *ty {
+                WpType::F32 | WpType::F64 => self.machine.pick_simd().map(Location::SIMD),
+                WpType::I32 | WpType::I64 => self.machine.pick_gpr().map(Location::GPR),
+                WpType::Ref(ty) if ty.is_extern_ref() || ty.is_func_ref() => {
+                    self.machine.pick_gpr().map(Location::GPR)
+                }
+                _ => codegen_error!("can't acquire location for type {:?}", ty),
+            };
+
+            let loc = if let Some(x) = loc {
+                x
+            } else {
+                self.stack_offset.0 += 8;
+                delta_stack_offset += 8;
+                self.machine.local_on_stack(self.stack_offset.0 as i32)
+            };
+            if let Location::GPR(x) = loc {
+                self.machine.reserve_gpr(x);
+                self.state.register_values[self.machine.index_from_gpr(x).0] = mv.clone();
+            } else if let Location::SIMD(x) = loc {
+                self.machine.reserve_simd(x);
+                self.state.register_values[self.machine.index_from_simd(x).0] = mv.clone();
+            } else {
+                self.state.stack_values.push(mv.clone());
+            }
+            self.state.wasm_stack.push(WasmAbstractValue::Runtime);
+            ret.push(loc);
+        }
+
+        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
+        if delta_stack_offset != 0 {
+            self.machine.adjust_stack(delta_stack_offset as u32)?;
+        }
+        if zeroed {
+            for i in 0..tys.len() {
+                self.machine.zero_location(Size::S64, ret[i])?;
+            }
+        }
+        Ok(ret)
+    }
+
+    /// Releases locations used for stack value.
+    fn release_locations(
+        &mut self,
+        locs: &[Location<M::GPR, M::SIMD>],
+    ) -> Result<(), CompileError> {
+        let mut delta_stack_offset: usize = 0;
+
+        for loc in locs.iter().rev() {
+            match *loc {
+                Location::GPR(ref x) => {
+                    self.machine.release_gpr(*x);
+                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
+                        MachineValue::Undefined;
+                }
+                Location::SIMD(ref x) => {
+                    self.machine.release_simd(*x);
+                    self.state.register_values[self.machine.index_from_simd(*x).0] =
+                        MachineValue::Undefined;
+                }
+                Location::Memory(y, x) => {
+                    if y == self.machine.local_pointer() {
+                        if x >= 0 {
+                            codegen_error!("Invalid memory offset {}", x);
+                        }
+                        let offset = (-x) as usize;
+                        if offset != self.stack_offset.0 {
+                            codegen_error!(
+                                "Invalid memory offset {}!={}",
+                                offset,
+                                self.stack_offset.0
+                            );
+                        }
+                        self.stack_offset.0 -= 8;
+                        delta_stack_offset += 8;
+                        self.state
+                            .stack_values
+                            .pop()
+                            .ok_or_else(|| CompileError::Codegen("Empty stack_value".to_owned()))?;
+                    }
+                }
+                _ => {}
+            }
+            self.state
+                .wasm_stack
+                .pop()
+                .ok_or_else(|| CompileError::Codegen("Pop with wasm stack empty".to_owned()))?;
+        }
+        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
+        if delta_stack_offset != 0 {
+            self.machine.restore_stack(delta_stack_offset as u32)?;
+        }
+        Ok(())
+    }
+    /// Releases locations used for stack value.
+    fn release_locations_value(&mut self, stack_depth: usize) -> Result<(), CompileError> {
+        let mut delta_stack_offset: usize = 0;
+        let locs: &[Location<M::GPR, M::SIMD>] = &self.value_stack[stack_depth..];
+
+        for loc in locs.iter().rev() {
+            match *loc {
+                Location::GPR(ref x) => {
+                    self.machine.release_gpr(*x);
+                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
+                        MachineValue::Undefined;
+                }
+                Location::SIMD(ref x) => {
+                    self.machine.release_simd(*x);
+                    self.state.register_values[self.machine.index_from_simd(*x).0] =
+                        MachineValue::Undefined;
+                }
+                Location::Memory(y, x) => {
+                    if y == self.machine.local_pointer() {
+                        if x >= 0 {
+                            codegen_error!("Invalid memory offset {}", x);
+                        }
+                        let offset = (-x) as usize;
+                        if offset != self.stack_offset.0 {
+                            codegen_error!(
+                                "Invalid memory offset {}!={}",
+                                offset,
+                                self.stack_offset.0
+                            );
+                        }
+                        self.stack_offset.0 -= 8;
+                        delta_stack_offset += 8;
+                        self.state.stack_values.pop().ok_or_else(|| {
+                            CompileError::Codegen("Pop with values stack empty".to_owned())
+                        })?;
+                    }
+                }
+                _ => {}
+            }
+            self.state
+                .wasm_stack
+                .pop()
+                .ok_or_else(|| CompileError::Codegen("Pop with wasm stack empty".to_owned()))?;
+        }
+
+        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
+        if delta_stack_offset != 0 {
+            self.machine.adjust_stack(delta_stack_offset as u32)?;
+        }
+        Ok(())
+    }
+
+    fn release_locations_only_regs(
+        &mut self,
+        locs: &[Location<M::GPR, M::SIMD>],
+    ) -> Result<(), CompileError> {
+        for loc in locs.iter().rev() {
+            match *loc {
+                Location::GPR(ref x) => {
+                    self.machine.release_gpr(*x);
+                    self.state.register_values[self.machine.index_from_gpr(*x).0] =
+                        MachineValue::Undefined;
+                }
+                Location::SIMD(ref x) => {
+                    self.machine.release_simd(*x);
+                    self.state.register_values[self.machine.index_from_simd(*x).0] =
+                        MachineValue::Undefined;
+                }
+                _ => {}
+            }
+            // Wasm state popping is deferred to `release_locations_only_osr_state`.
+        }
+        Ok(())
+    }
+
+    fn release_locations_only_stack(
+        &mut self,
+        locs: &[Location<M::GPR, M::SIMD>],
+    ) -> Result<(), CompileError> {
+        let mut delta_stack_offset: usize = 0;
+
+        for loc in locs.iter().rev() {
+            if let Location::Memory(y, x) = *loc {
+                if y == self.machine.local_pointer() {
+                    if x >= 0 {
+                        codegen_error!("Invalid memory offset {}", x);
+                    }
+                    let offset = (-x) as usize;
+                    if offset != self.stack_offset.0 {
+                        codegen_error!("Invalid memory offset {}!={}", offset, self.stack_offset.0);
+                    }
+                    self.stack_offset.0 -= 8;
+                    delta_stack_offset += 8;
+                    self.state.stack_values.pop().ok_or_else(|| {
+                        CompileError::Codegen("Pop on empty value stack".to_owned())
+                    })?;
+                }
+            }
+            // Wasm state popping is deferred to `release_locations_only_osr_state`.
+        }
+
+        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
+        if delta_stack_offset != 0 {
+            self.machine.pop_stack_locals(delta_stack_offset as u32)?;
+        }
+        Ok(())
+    }
+
+    fn release_locations_only_osr_state(&mut self, n: usize) -> Result<(), CompileError> {
+        let new_length = self
+            .state
+            .wasm_stack
+            .len()
+            .checked_sub(n)
+            .expect("release_locations_only_osr_state: length underflow");
+        self.state.wasm_stack.truncate(new_length);
+        Ok(())
+    }
+
+    fn release_locations_keep_state(&mut self, stack_depth: usize) -> Result<(), CompileError> {
+        let mut delta_stack_offset: usize = 0;
+        let mut stack_offset = self.stack_offset.0;
+        let locs = &self.value_stack[stack_depth..];
+
+        for loc in locs.iter().rev() {
+            if let Location::Memory(y, x) = *loc {
+                if y == self.machine.local_pointer() {
+                    if x >= 0 {
+                        codegen_error!("Invalid memory offset {}", x);
+                    }
+                    let offset = (-x) as usize;
+                    if offset != stack_offset {
+                        codegen_error!("Invalid memory offset {}!={}", offset, self.stack_offset.0);
+                    }
+                    stack_offset -= 8;
+                    delta_stack_offset += 8;
+                }
+            }
+        }
+
+        let delta_stack_offset = self.machine.round_stack_adjust(delta_stack_offset);
+        if delta_stack_offset != 0 {
+            self.machine.pop_stack_locals(delta_stack_offset as u32)?;
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::type_complexity)]
+    fn init_locals(
+        &mut self,
+        n: usize,
+        sig: FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<Vec<Location<M::GPR, M::SIMD>>, CompileError> {
+        // How many machine stack slots will all the locals use?
+        let num_mem_slots = (0..n)
+            .filter(|&x| self.machine.is_local_on_stack(x))
+            .count();
+
+        // Total size (in bytes) of the pre-allocated "static area" for this function's
+        // locals and callee-saved registers.
+        let mut static_area_size: usize = 0;
+
+        // Callee-saved registers used for locals.
+        // Keep this consistent with the "Save callee-saved registers" code below.
+        for i in 0..n {
+            // If a local is not stored on stack, then it is allocated to a callee-saved register.
+            if !self.machine.is_local_on_stack(i) {
+                static_area_size += 8;
+            }
+        }
+
+        // Callee-saved vmctx.
+        static_area_size += 8;
+
+        // Some ABI (like Windows) needs extrat reg save
+        static_area_size += 8 * self.machine.list_to_save(calling_convention).len();
+
+        // Total size of callee saved registers.
+        let callee_saved_regs_size = static_area_size;
+
+        // Now we can determine concrete locations for locals.
+        let locations: Vec<Location<M::GPR, M::SIMD>> = (0..n)
+            .map(|i| self.machine.get_local_location(i, callee_saved_regs_size))
+            .collect();
+
+        // Add size of locals on stack.
+        static_area_size += num_mem_slots * 8;
+
+        // Allocate save area, without actually writing to it.
+        static_area_size = self.machine.round_stack_adjust(static_area_size);
+
+        // Stack probe.
+        //
+        // `rep stosq` writes data from low address to high address and may skip the stack guard page.
+        // so here we probe it explicitly when needed.
+        for i in (sig.params().len()..n)
+            .step_by(NATIVE_PAGE_SIZE / 8)
+            .skip(1)
+        {
+            self.machine.zero_location(Size::S64, locations[i])?;
+        }
+
+        self.machine.adjust_stack(static_area_size as _)?;
+
+        // Save callee-saved registers.
+        for loc in locations.iter() {
+            if let Location::GPR(x) = *loc {
+                self.stack_offset.0 += 8;
+                self.machine.move_local(self.stack_offset.0 as i32, *loc)?;
+                self.state.stack_values.push(MachineValue::PreserveRegister(
+                    self.machine.index_from_gpr(x),
+                ));
+            }
+        }
+
+        // Save the Reg use for vmctx.
+        self.stack_offset.0 += 8;
+        self.machine.move_local(
+            self.stack_offset.0 as i32,
+            Location::GPR(self.machine.get_vmctx_reg()),
+        )?;
+        self.state.stack_values.push(MachineValue::PreserveRegister(
+            self.machine.index_from_gpr(self.machine.get_vmctx_reg()),
+        ));
+
+        // Check if need to same some CallingConvention specific regs
+        let regs_to_save = self.machine.list_to_save(calling_convention);
+        for loc in regs_to_save.iter() {
+            self.stack_offset.0 += 8;
+            self.machine.move_local(self.stack_offset.0 as i32, *loc)?;
+        }
+
+        // Save the offset of register save area.
+        self.save_area_offset = Some(MachineStackOffset(self.stack_offset.0));
+
+        // Save location information for locals.
+        for (i, loc) in locations.iter().enumerate() {
+            match *loc {
+                Location::GPR(x) => {
+                    self.state.register_values[self.machine.index_from_gpr(x).0] =
+                        MachineValue::WasmLocal(i);
+                }
+                Location::Memory(_, _) => {
+                    self.state.stack_values.push(MachineValue::WasmLocal(i));
+                }
+                _ => codegen_error!("singlpass init_local unreachable"),
+            }
+        }
+
+        // Load in-register parameters into the allocated locations.
+        // Locals are allocated on the stack from higher address to lower address,
+        // so we won't skip the stack guard page here.
+        let mut stack_offset: usize = 0;
+        for (i, param) in sig.params().iter().enumerate() {
+            let sz = match *param {
+                Type::I32 | Type::F32 => Size::S32,
+                Type::I64 | Type::F64 => Size::S64,
+                Type::ExternRef | Type::FuncRef => Size::S64,
+                _ => codegen_error!("singlepass init_local unimplemented"),
+            };
+            let loc = self.machine.get_call_param_location(
+                i + 1,
+                sz,
+                &mut stack_offset,
+                calling_convention,
+            );
+            self.machine
+                .move_location_extend(sz, false, loc, Size::S64, locations[i])?;
+        }
+
+        // Load vmctx into it's GPR.
+        self.machine.move_location(
+            Size::S64,
+            self.machine
+                .get_simple_param_location(0, calling_convention),
+            Location::GPR(self.machine.get_vmctx_reg()),
+        )?;
+
+        // Initialize all normal locals to zero.
+        let mut init_stack_loc_cnt = 0;
+        let mut last_stack_loc = Location::Memory(self.machine.local_pointer(), i32::MAX);
+        for location in locations.iter().take(n).skip(sig.params().len()) {
+            match location {
+                Location::Memory(_, _) => {
+                    init_stack_loc_cnt += 1;
+                    last_stack_loc = cmp::min(last_stack_loc, *location);
+                }
+                Location::GPR(_) => {
+                    self.machine.zero_location(Size::S64, *location)?;
+                }
+                _ => codegen_error!("singlepass init_local unreachable"),
+            }
+        }
+        if init_stack_loc_cnt > 0 {
+            self.machine
+                .init_stack_loc(init_stack_loc_cnt, last_stack_loc)?;
+        }
+
+        // Add the size of all locals allocated to stack.
+        self.stack_offset.0 += static_area_size - callee_saved_regs_size;
+
+        Ok(locations)
+    }
+
+    fn finalize_locals(
+        &mut self,
+        calling_convention: CallingConvention,
+    ) -> Result<(), CompileError> {
+        // Unwind stack to the "save area".
+        self.machine
+            .restore_saved_area(self.save_area_offset.as_ref().unwrap().0 as i32)?;
+
+        let regs_to_save = self.machine.list_to_save(calling_convention);
+        for loc in regs_to_save.iter().rev() {
+            self.machine.pop_location(*loc)?;
+        }
+
+        // Restore register used by vmctx.
+        self.machine
+            .pop_location(Location::GPR(self.machine.get_vmctx_reg()))?;
+
+        // Restore callee-saved registers.
+        for loc in self.locals.iter().rev() {
+            if let Location::GPR(_) = *loc {
+                self.machine.pop_location(*loc)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Set the source location of the Wasm to the given offset.
+    pub fn set_srcloc(&mut self, offset: u32) {
+        self.machine.set_srcloc(offset);
+    }
+
+    fn get_location_released(
+        &mut self,
+        loc: Location<M::GPR, M::SIMD>,
+    ) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+        self.release_locations(&[loc])?;
+        Ok(loc)
+    }
+
+    fn pop_value_released(&mut self) -> Result<Location<M::GPR, M::SIMD>, CompileError> {
+        let loc = self.value_stack.pop().ok_or_else(|| {
+            CompileError::Codegen("pop_value_released: value stack is empty".to_owned())
+        })?;
+        self.get_location_released(loc)
+    }
+
+    /// Prepare data for binary operator with 2 inputs and 1 output.
+    fn i2o1_prepare(&mut self, ty: WpType) -> Result<I2O1<M::GPR, M::SIMD>, CompileError> {
+        let loc_b = self.pop_value_released()?;
+        let loc_a = self.pop_value_released()?;
+        let ret = self.acquire_locations(
+            &[(ty, MachineValue::WasmStack(self.value_stack.len()))],
+            false,
+        )?[0];
+        self.value_stack.push(ret);
+        Ok(I2O1 { loc_a, loc_b, ret })
+    }
+
+    fn mark_trappable(&mut self) {
+        let state_diff_id = self.get_state_diff();
+        let offset = self.machine.assembler_get_offset().0;
+        self.fsm.trappable_offsets.insert(
+            offset,
+            OffsetInfo {
+                end_offset: offset + 1,
+                activate_offset: offset,
+                diff_id: state_diff_id,
+            },
+        );
+        self.fsm.wasm_offset_to_target_offset.insert(
+            self.state.wasm_inst_offset,
+            SuspendOffset::Trappable(offset),
+        );
+    }
+    fn mark_offset_trappable(&mut self, offset: usize) {
+        let state_diff_id = self.get_state_diff();
+        self.fsm.trappable_offsets.insert(
+            offset,
+            OffsetInfo {
+                end_offset: offset + 1,
+                activate_offset: offset,
+                diff_id: state_diff_id,
+            },
+        );
+        self.fsm.wasm_offset_to_target_offset.insert(
+            self.state.wasm_inst_offset,
+            SuspendOffset::Trappable(offset),
+        );
+    }
+
+    /// Emits a Native ABI call sequence.
+    ///
+    /// The caller MUST NOT hold any temporary registers allocated by `acquire_temp_gpr` when calling
+    /// this function.
+    fn emit_call_native<
+        I: Iterator<Item = Location<M::GPR, M::SIMD>>,
+        J: Iterator<Item = WpType>,
+        F: FnOnce(&mut Self) -> Result<(), CompileError>,
+    >(
+        &mut self,
+        cb: F,
+        params: I,
+        params_type: J,
+    ) -> Result<(), CompileError> {
+        // Values pushed in this function are above the shadow region.
+        self.state.stack_values.push(MachineValue::ExplicitShadow);
+
+        let params: Vec<_> = params.collect();
+        let params_size: Vec<_> = params_type
+            .map(|x| match x {
+                WpType::F32 | WpType::I32 => Size::S32,
+                WpType::V128 => unimplemented!(),
+                _ => Size::S64,
+            })
+            .collect();
+
+        // Save used GPRs. Preserve correct stack alignment
+        let used_gprs = self.machine.get_used_gprs();
+        let mut used_stack = self.machine.push_used_gpr(&used_gprs)?;
+        for r in used_gprs.iter() {
+            let content = self.state.register_values[self.machine.index_from_gpr(*r).0].clone();
+            if content == MachineValue::Undefined {
+                return Err(CompileError::Codegen(
+                    "emit_call_native: Undefined used_gprs content".to_owned(),
+                ));
+            }
+            self.state.stack_values.push(content);
+        }
+
+        // Save used SIMD registers.
+        let used_simds = self.machine.get_used_simd();
+        if !used_simds.is_empty() {
+            used_stack += self.machine.push_used_simd(&used_simds)?;
+
+            for r in used_simds.iter().rev() {
+                let content =
+                    self.state.register_values[self.machine.index_from_simd(*r).0].clone();
+                if content == MachineValue::Undefined {
+                    return Err(CompileError::Codegen(
+                        "emit_call_native: Undefined used_simds content".to_owned(),
+                    ));
+                }
+                self.state.stack_values.push(content);
+            }
+        }
+        // mark the GPR used for Call as used
+        self.machine
+            .reserve_unused_temp_gpr(self.machine.get_grp_for_call());
+
+        let calling_convention = self.calling_convention;
+
+        let stack_padding: usize = match calling_convention {
+            CallingConvention::WindowsFastcall => 32,
+            _ => 0,
+        };
+
+        let mut stack_offset: usize = 0;
+        let mut args: Vec<Location<M::GPR, M::SIMD>> = vec![];
+        let mut pushed_args: usize = 0;
+        // Calculate stack offset.
+        for (i, _param) in params.iter().enumerate() {
+            args.push(self.machine.get_param_location(
+                1 + i,
+                params_size[i],
+                &mut stack_offset,
+                calling_convention,
+            ));
+        }
+
+        // Align stack to 16 bytes.
+        let stack_unaligned =
+            (self.machine.round_stack_adjust(self.get_stack_offset()) + used_stack + stack_offset)
+                % 16;
+        if stack_unaligned != 0 {
+            stack_offset += 16 - stack_unaligned;
+        }
+        self.machine.adjust_stack(stack_offset as u32)?;
+
+        #[allow(clippy::type_complexity)]
+        let mut call_movs: Vec<(Location<M::GPR, M::SIMD>, M::GPR)> = vec![];
+        // Prepare register & stack parameters.
+        for (i, param) in params.iter().enumerate().rev() {
+            let loc = args[i];
+            match loc {
+                Location::GPR(x) => {
+                    call_movs.push((*param, x));
+                }
+                Location::Memory(_, _) => {
+                    pushed_args += 1;
+                    match *param {
+                        Location::GPR(x) => {
+                            let content = self.state.register_values
+                                [self.machine.index_from_gpr(x).0]
+                                .clone();
+                            // FIXME: There might be some corner cases (release -> emit_call_native -> acquire?) that cause this assertion to fail.
+                            // Hopefully nothing would be incorrect at runtime.
+
+                            //assert!(content != MachineValue::Undefined);
+                            self.state.stack_values.push(content);
+                        }
+                        Location::SIMD(x) => {
+                            let content = self.state.register_values
+                                [self.machine.index_from_simd(x).0]
+                                .clone();
+                            //assert!(content != MachineValue::Undefined);
+                            self.state.stack_values.push(content);
+                        }
+                        Location::Memory(reg, offset) => {
+                            if reg != self.machine.local_pointer() {
+                                return Err(CompileError::Codegen(
+                                    "emit_call_native loc param: unreachable code".to_owned(),
+                                ));
+                            }
+                            self.state
+                                .stack_values
+                                .push(MachineValue::CopyStackBPRelative(offset));
+                            // TODO: Read value at this offset
+                        }
+                        _ => {
+                            self.state.stack_values.push(MachineValue::Undefined);
+                        }
+                    }
+                    self.machine
+                        .move_location_for_native(params_size[i], *param, loc)?;
+                }
+                _ => {
+                    return Err(CompileError::Codegen(
+                        "emit_call_native loc: unreachable code".to_owned(),
+                    ))
+                }
+            }
+        }
+
+        // Sort register moves so that register are not overwritten before read.
+        Self::sort_call_movs(&mut call_movs);
+
+        // Emit register moves.
+        for (loc, gpr) in call_movs {
+            if loc != Location::GPR(gpr) {
+                self.machine
+                    .move_location(Size::S64, loc, Location::GPR(gpr))?;
+            }
+        }
+
+        // Put vmctx as the first parameter.
+        self.machine.move_location(
+            Size::S64,
+            Location::GPR(self.machine.get_vmctx_reg()),
+            self.machine
+                .get_simple_param_location(0, calling_convention),
+        )?; // vmctx
+
+        if stack_padding > 0 {
+            self.machine.adjust_stack(stack_padding as u32)?;
+        }
+        // release the GPR used for call
+        self.machine.release_gpr(self.machine.get_grp_for_call());
+        cb(self)?;
+
+        // Offset needs to be after the 'call' instruction.
+        // TODO: Now the state information is also inserted for internal calls (e.g. MemoryGrow). Is this expected?
+        {
+            let state_diff_id = self.get_state_diff();
+            let offset = self.machine.assembler_get_offset().0;
+            self.fsm.call_offsets.insert(
+                offset,
+                OffsetInfo {
+                    end_offset: offset + 1,
+                    activate_offset: offset,
+                    diff_id: state_diff_id,
+                },
+            );
+            self.fsm
+                .wasm_offset_to_target_offset
+                .insert(self.state.wasm_inst_offset, SuspendOffset::Call(offset));
+        }
+
+        // Restore stack.
+        if stack_offset + stack_padding > 0 {
+            self.machine.restore_stack(
+                self.machine
+                    .round_stack_adjust(stack_offset + stack_padding) as u32,
+            )?;
+            if (stack_offset % 8) != 0 {
+                return Err(CompileError::Codegen(
+                    "emit_call_native: Bad restoring stack alignement".to_owned(),
+                ));
+            }
+            for _ in 0..pushed_args {
+                self.state
+                    .stack_values
+                    .pop()
+                    .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
+            }
+        }
+
+        // Restore SIMDs.
+        if !used_simds.is_empty() {
+            self.machine.pop_used_simd(&used_simds)?;
+            for _ in 0..used_simds.len() {
+                self.state
+                    .stack_values
+                    .pop()
+                    .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
+            }
+        }
+
+        // Restore GPRs.
+        self.machine.pop_used_gpr(&used_gprs)?;
+        for _ in used_gprs.iter().rev() {
+            self.state
+                .stack_values
+                .pop()
+                .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?;
+        }
+
+        if self
+            .state
+            .stack_values
+            .pop()
+            .ok_or_else(|| CompileError::Codegen("Pop an empty value stack".to_owned()))?
+            != MachineValue::ExplicitShadow
+        {
+            return Err(CompileError::Codegen(
+                "emit_call_native: Popped value is not ExplicitShadow".to_owned(),
+            ));
+        }
+        Ok(())
+    }
+
+    /// Emits a Native ABI call sequence, specialized for labels as the call target.
+    fn _emit_call_native_label<
+        I: Iterator<Item = Location<M::GPR, M::SIMD>>,
+        J: Iterator<Item = WpType>,
+    >(
+        &mut self,
+        label: Label,
+        params: I,
+        params_type: J,
+    ) -> Result<(), CompileError> {
+        self.emit_call_native(
+            |this| this.machine.emit_call_label(label),
+            params,
+            params_type,
+        )?;
+        Ok(())
+    }
+
+    /// Emits a memory operation.
+    fn op_memory<
+        F: FnOnce(&mut Self, bool, bool, i32, Label, Label) -> Result<(), CompileError>,
+    >(
+        &mut self,
+        cb: F,
+    ) -> Result<(), CompileError> {
+        let need_check = match self.memory_styles[MemoryIndex::new(0)] {
+            MemoryStyle::Static { .. } => false,
+            MemoryStyle::Dynamic { .. } => true,
+        };
+
+        let offset = if self.module.num_imported_memories != 0 {
+            self.vmoffsets
+                .vmctx_vmmemory_import_definition(MemoryIndex::new(0))
+        } else {
+            self.vmoffsets
+                .vmctx_vmmemory_definition(LocalMemoryIndex::new(0))
+        };
+        cb(
+            self,
+            need_check,
+            self.module.num_imported_memories != 0,
+            offset as i32,
+            self.special_labels.heap_access_oob,
+            self.special_labels.unaligned_atomic,
+        )
+    }
+
+    pub fn get_state_diff(&mut self) -> usize {
+        if !self.track_state {
+            return std::usize::MAX;
+        }
+        let last_frame = self.control_stack.last_mut().unwrap();
+        let mut diff = self.state.diff(&last_frame.state);
+        diff.last = Some(last_frame.state_diff_id);
+        let id = self.fsm.diffs.len();
+        last_frame.state = self.state.clone();
+        last_frame.state_diff_id = id;
+        self.fsm.diffs.push(diff);
+        id
+    }
+
+    fn emit_head(&mut self) -> Result<(), CompileError> {
+        self.machine.emit_function_prolog()?;
+
+        // Initialize locals.
+        self.locals = self.init_locals(
+            self.local_types.len(),
+            self.signature.clone(),
+            self.calling_convention,
+        )?;
+
+        // Mark vmctx register. The actual loading of the vmctx value is handled by init_local.
+        self.state.register_values[self.machine.index_from_gpr(self.machine.get_vmctx_reg()).0] =
+            MachineValue::Vmctx;
+
+        // TODO: Explicit stack check is not supported for now.
+        let diff = self.state.diff(&self.machine.new_machine_state());
+        let state_diff_id = self.fsm.diffs.len();
+        self.fsm.diffs.push(diff);
+
+        // simulate "red zone" if not supported by the platform
+        self.machine.adjust_stack(32)?;
+
+        self.control_stack.push(ControlFrame {
+            label: self.machine.get_label(),
+            loop_like: false,
+            if_else: IfElseState::None,
+            returns: self
+                .signature
+                .results()
+                .iter()
+                .map(|&x| type_to_wp_type(x))
+                .collect(),
+            value_stack_depth: 0,
+            fp_stack_depth: 0,
+            state: self.state.clone(),
+            state_diff_id,
+        });
+
+        // TODO: Full preemption by explicit signal checking
+
+        // We insert set StackOverflow as the default trap that can happen
+        // anywhere in the function prologue.
+        self.machine.insert_stackoverflow();
+
+        if self.state.wasm_inst_offset != std::usize::MAX {
+            return Err(CompileError::Codegen(
+                "emit_head: wasm_inst_offset not std::usize::MAX".to_owned(),
+            ));
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(
+        module: &'a ModuleInfo,
+        config: &'a Singlepass,
+        vmoffsets: &'a VMOffsets,
+        memory_styles: &'a PrimaryMap<MemoryIndex, MemoryStyle>,
+        _table_styles: &'a PrimaryMap<TableIndex, TableStyle>,
+        local_func_index: LocalFunctionIndex,
+        local_types_excluding_arguments: &[WpType],
+        machine: M,
+        calling_convention: CallingConvention,
+    ) -> Result<FuncGen<'a, M>, CompileError> {
+        let func_index = module.func_index(local_func_index);
+        let sig_index = module.functions[func_index];
+        let signature = module.signatures[sig_index].clone();
+
+        let mut local_types: Vec<_> = signature
+            .params()
+            .iter()
+            .map(|&x| type_to_wp_type(x))
+            .collect();
+        local_types.extend_from_slice(local_types_excluding_arguments);
+
+        let mut machine = machine;
+        let special_labels = SpecialLabelSet {
+            integer_division_by_zero: machine.get_label(),
+            integer_overflow: machine.get_label(),
+            heap_access_oob: machine.get_label(),
+            table_access_oob: machine.get_label(),
+            indirect_call_null: machine.get_label(),
+            bad_signature: machine.get_label(),
+            unaligned_atomic: machine.get_label(),
+        };
+
+        let fsm = FunctionStateMap::new(
+            machine.new_machine_state(),
+            local_func_index.index() as usize,
+            32,
+            (0..local_types.len())
+                .map(|_| WasmAbstractValue::Runtime)
+                .collect(),
+        );
+
+        let mut fg = FuncGen {
+            module,
+            config,
+            vmoffsets,
+            memory_styles,
+            // table_styles,
+            signature,
+            locals: vec![], // initialization deferred to emit_head
+            local_types,
+            value_stack: vec![],
+            fp_stack: vec![],
+            control_stack: vec![],
+            stack_offset: MachineStackOffset(0),
+            save_area_offset: None,
+            state: machine.new_machine_state(),
+            track_state: true,
+            machine,
+            unreachable_depth: 0,
+            fsm,
+            relocations: vec![],
+            special_labels,
+            calling_convention,
+        };
+        fg.emit_head()?;
+        Ok(fg)
+    }
+
+    pub fn has_control_frames(&self) -> bool {
+        !self.control_stack.is_empty()
+    }
+
+    pub fn feed_operator(&mut self, op: Operator) -> Result<(), CompileError> {
+        assert!(self.fp_stack.len() <= self.value_stack.len());
+
+        self.state.wasm_inst_offset = self.state.wasm_inst_offset.wrapping_add(1);
+
+        //println!("{:?} {}", op, self.value_stack.len());
+        let was_unreachable;
+
+        if self.unreachable_depth > 0 {
+            was_unreachable = true;
+
+            match op {
+                Operator::Block { .. } | Operator::Loop { .. } | Operator::If { .. } => {
+                    self.unreachable_depth += 1;
+                }
+                Operator::End => {
+                    self.unreachable_depth -= 1;
+                }
+                Operator::Else => {
+                    // We are in a reachable true branch
+                    if self.unreachable_depth == 1 {
+                        if let Some(IfElseState::If(_)) =
+                            self.control_stack.last().map(|x| x.if_else)
+                        {
+                            self.unreachable_depth -= 1;
+                        }
+                    }
+                }
+                _ => {}
+            }
+            if self.unreachable_depth > 0 {
+                return Ok(());
+            }
+        } else {
+            was_unreachable = false;
+        }
+
+        match op {
+            Operator::GlobalGet { global_index } => {
+                let global_index = GlobalIndex::from_u32(global_index);
+
+                let ty = type_to_wp_type(self.module.globals[global_index].ty);
+                if ty.is_float() {
+                    self.fp_stack.push(FloatValue::new(self.value_stack.len()));
+                }
+                let loc = self.acquire_locations(
+                    &[(ty, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(loc);
+
+                let tmp = self.machine.acquire_temp_gpr().unwrap();
+
+                let src = if let Some(local_global_index) =
+                    self.module.local_global_index(global_index)
+                {
+                    let offset = self.vmoffsets.vmctx_vmglobal_definition(local_global_index);
+                    self.machine.emit_relaxed_mov(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), offset as i32),
+                        Location::GPR(tmp),
+                    )?;
+                    Location::Memory(tmp, 0)
+                } else {
+                    // Imported globals require one level of indirection.
+                    let offset = self
+                        .vmoffsets
+                        .vmctx_vmglobal_import_definition(global_index);
+                    self.machine.emit_relaxed_mov(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), offset as i32),
+                        Location::GPR(tmp),
+                    )?;
+                    Location::Memory(tmp, 0)
+                };
+
+                self.machine.emit_relaxed_mov(Size::S64, src, loc)?;
+
+                self.machine.release_gpr(tmp);
+            }
+            Operator::GlobalSet { global_index } => {
+                let global_index = GlobalIndex::from_u32(global_index);
+                let tmp = self.machine.acquire_temp_gpr().unwrap();
+                let dst = if let Some(local_global_index) =
+                    self.module.local_global_index(global_index)
+                {
+                    let offset = self.vmoffsets.vmctx_vmglobal_definition(local_global_index);
+                    self.machine.emit_relaxed_mov(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), offset as i32),
+                        Location::GPR(tmp),
+                    )?;
+                    Location::Memory(tmp, 0)
+                } else {
+                    // Imported globals require one level of indirection.
+                    let offset = self
+                        .vmoffsets
+                        .vmctx_vmglobal_import_definition(global_index);
+                    self.machine.emit_relaxed_mov(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), offset as i32),
+                        Location::GPR(tmp),
+                    )?;
+                    Location::Memory(tmp, 0)
+                };
+                let ty = type_to_wp_type(self.module.globals[global_index].ty);
+                let loc = self.pop_value_released()?;
+                if ty.is_float() {
+                    let fp = self.fp_stack.pop1()?;
+                    if self.machine.arch_supports_canonicalize_nan()
+                        && self.config.enable_nan_canonicalization
+                        && fp.canonicalization.is_some()
+                    {
+                        self.machine.canonicalize_nan(
+                            match ty {
+                                WpType::F32 => Size::S32,
+                                WpType::F64 => Size::S64,
+                                _ => codegen_error!("singlepass Operator::GlobalSet unreachable"),
+                            },
+                            loc,
+                            dst,
+                        )?;
+                    } else {
+                        self.machine.emit_relaxed_mov(Size::S64, loc, dst)?;
+                    }
+                } else {
+                    self.machine.emit_relaxed_mov(Size::S64, loc, dst)?;
+                }
+                self.machine.release_gpr(tmp);
+            }
+            Operator::LocalGet { local_index } => {
+                let local_index = local_index as usize;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.machine
+                    .emit_relaxed_mov(Size::S64, self.locals[local_index], ret)?;
+                self.value_stack.push(ret);
+                if self.local_types[local_index].is_float() {
+                    self.fp_stack
+                        .push(FloatValue::new(self.value_stack.len() - 1));
+                }
+            }
+            Operator::LocalSet { local_index } => {
+                let local_index = local_index as usize;
+                let loc = self.pop_value_released()?;
+
+                if self.local_types[local_index].is_float() {
+                    let fp = self.fp_stack.pop1()?;
+                    if self.machine.arch_supports_canonicalize_nan()
+                        && self.config.enable_nan_canonicalization
+                        && fp.canonicalization.is_some()
+                    {
+                        self.machine.canonicalize_nan(
+                            match self.local_types[local_index] {
+                                WpType::F32 => Size::S32,
+                                WpType::F64 => Size::S64,
+                                _ => codegen_error!("singlepass Operator::LocalSet unreachable"),
+                            },
+                            loc,
+                            self.locals[local_index],
+                        )
+                    } else {
+                        self.machine
+                            .emit_relaxed_mov(Size::S64, loc, self.locals[local_index])
+                    }
+                } else {
+                    self.machine
+                        .emit_relaxed_mov(Size::S64, loc, self.locals[local_index])
+                }?;
+            }
+            Operator::LocalTee { local_index } => {
+                let local_index = local_index as usize;
+                let loc = *self.value_stack.last().unwrap();
+
+                if self.local_types[local_index].is_float() {
+                    let fp = self.fp_stack.peek1()?;
+                    if self.machine.arch_supports_canonicalize_nan()
+                        && self.config.enable_nan_canonicalization
+                        && fp.canonicalization.is_some()
+                    {
+                        self.machine.canonicalize_nan(
+                            match self.local_types[local_index] {
+                                WpType::F32 => Size::S32,
+                                WpType::F64 => Size::S64,
+                                _ => codegen_error!("singlepass Operator::LocalTee unreachable"),
+                            },
+                            loc,
+                            self.locals[local_index],
+                        )
+                    } else {
+                        self.machine
+                            .emit_relaxed_mov(Size::S64, loc, self.locals[local_index])
+                    }
+                } else {
+                    self.machine
+                        .emit_relaxed_mov(Size::S64, loc, self.locals[local_index])
+                }?;
+            }
+            Operator::I32Const { value } => {
+                self.value_stack.push(Location::Imm32(value as u32));
+                self.state
+                    .wasm_stack
+                    .push(WasmAbstractValue::Const(value as u32 as u64));
+            }
+            Operator::I32Add => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_add32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Sub => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_sub32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Mul => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_mul32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32DivU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let offset = self.machine.emit_binop_udiv32(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I32DivS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let offset = self.machine.emit_binop_sdiv32(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I32RemU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let offset = self.machine.emit_binop_urem32(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I32RemS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                let offset = self.machine.emit_binop_srem32(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I32And => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_and32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Or => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_or32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Xor => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.emit_binop_xor32(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Eq => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_eq(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Ne => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_ne(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Eqz => {
+                let loc_a = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.machine.i32_cmp_eq(loc_a, Location::Imm32(0), ret)?;
+                self.value_stack.push(ret);
+            }
+            Operator::I32Clz => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i32_clz(loc, ret)?;
+            }
+            Operator::I32Ctz => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i32_ctz(loc, ret)?;
+            }
+            Operator::I32Popcnt => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i32_popcnt(loc, ret)?;
+            }
+            Operator::I32Shl => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_shl(loc_a, loc_b, ret)?;
+            }
+            Operator::I32ShrU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_shr(loc_a, loc_b, ret)?;
+            }
+            Operator::I32ShrS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_sar(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Rotl => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_rol(loc_a, loc_b, ret)?;
+            }
+            Operator::I32Rotr => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_ror(loc_a, loc_b, ret)?;
+            }
+            Operator::I32LtU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_lt_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I32LeU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_le_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I32GtU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_gt_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I32GeU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_ge_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I32LtS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_lt_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I32LeS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_le_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I32GtS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_gt_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I32GeS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.i32_cmp_ge_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Const { value } => {
+                let value = value as u64;
+                self.value_stack.push(Location::Imm64(value));
+                self.state.wasm_stack.push(WasmAbstractValue::Const(value));
+            }
+            Operator::I64Add => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_add64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Sub => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_sub64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Mul => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_mul64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64DivU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let offset = self.machine.emit_binop_udiv64(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I64DivS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let offset = self.machine.emit_binop_sdiv64(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I64RemU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let offset = self.machine.emit_binop_urem64(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I64RemS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                let offset = self.machine.emit_binop_srem64(
+                    loc_a,
+                    loc_b,
+                    ret,
+                    self.special_labels.integer_division_by_zero,
+                    self.special_labels.integer_overflow,
+                )?;
+                self.mark_offset_trappable(offset);
+            }
+            Operator::I64And => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_and64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Or => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_or64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Xor => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.emit_binop_xor64(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Eq => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_eq(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Ne => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_ne(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Eqz => {
+                let loc_a = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.machine.i64_cmp_eq(loc_a, Location::Imm64(0), ret)?;
+                self.value_stack.push(ret);
+            }
+            Operator::I64Clz => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i64_clz(loc, ret)?;
+            }
+            Operator::I64Ctz => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i64_ctz(loc, ret)?;
+            }
+            Operator::I64Popcnt => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.i64_popcnt(loc, ret)?;
+            }
+            Operator::I64Shl => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_shl(loc_a, loc_b, ret)?;
+            }
+            Operator::I64ShrU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_shr(loc_a, loc_b, ret)?;
+            }
+            Operator::I64ShrS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_sar(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Rotl => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_rol(loc_a, loc_b, ret)?;
+            }
+            Operator::I64Rotr => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_ror(loc_a, loc_b, ret)?;
+            }
+            Operator::I64LtU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_lt_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I64LeU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_le_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I64GtU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_gt_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I64GeU => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_ge_u(loc_a, loc_b, ret)?;
+            }
+            Operator::I64LtS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_lt_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I64LeS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_le_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I64GtS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_gt_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I64GeS => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I64)?;
+                self.machine.i64_cmp_ge_s(loc_a, loc_b, ret)?;
+            }
+            Operator::I64ExtendI32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
+
+                // A 32-bit memory write does not automatically clear the upper 32 bits of a 64-bit word.
+                // So, we need to explicitly write zero to the upper half here.
+                if let Location::Memory(base, off) = ret {
+                    self.machine.emit_relaxed_mov(
+                        Size::S32,
+                        Location::Imm32(0),
+                        Location::Memory(base, off + 4),
+                    )?;
+                }
+            }
+            Operator::I64ExtendI32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S32, loc, Size::S64, ret)?;
+            }
+            Operator::I32Extend8S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S8, loc, Size::S32, ret)?;
+            }
+            Operator::I32Extend16S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S16, loc, Size::S32, ret)?;
+            }
+            Operator::I64Extend8S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S8, loc, Size::S64, ret)?;
+            }
+            Operator::I64Extend16S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S16, loc, Size::S64, ret)?;
+            }
+            Operator::I64Extend32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine
+                    .emit_relaxed_sign_extension(Size::S32, loc, Size::S64, ret)?;
+            }
+            Operator::I32WrapI64 => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
+            }
+
+            Operator::F32Const { value } => {
+                self.value_stack.push(Location::Imm32(value.bits()));
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+                self.state
+                    .wasm_stack
+                    .push(WasmAbstractValue::Const(value.bits() as u64));
+            }
+            Operator::F32Add => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f32_add(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Sub => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f32_sub(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Mul => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f32_mul(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Div => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f32_div(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Max => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                self.machine.f32_max(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Min => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                self.machine.f32_min(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Eq => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_eq(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Ne => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_ne(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Lt => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_lt(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Le => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_le(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Gt => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_gt(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Ge => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f32_cmp_ge(loc_a, loc_b, ret)?;
+            }
+            Operator::F32Nearest => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f32_nearest(loc, ret)?;
+            }
+            Operator::F32Floor => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f32_floor(loc, ret)?;
+            }
+            Operator::F32Ceil => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f32_ceil(loc, ret)?;
+            }
+            Operator::F32Trunc => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f32_trunc(loc, ret)?;
+            }
+            Operator::F32Sqrt => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f32(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f32_sqrt(loc, ret)?;
+            }
+
+            Operator::F32Copysign => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F32)?;
+
+                let (fp_src1, fp_src2) = self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+
+                let tmp1 = self.machine.acquire_temp_gpr().unwrap();
+                let tmp2 = self.machine.acquire_temp_gpr().unwrap();
+
+                if self.machine.arch_supports_canonicalize_nan()
+                    && self.config.enable_nan_canonicalization
+                {
+                    for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() {
+                        match fp.canonicalization {
+                            Some(_) => {
+                                self.machine
+                                    .canonicalize_nan(Size::S32, *loc, Location::GPR(*tmp))
+                            }
+                            None => {
+                                self.machine
+                                    .move_location(Size::S32, *loc, Location::GPR(*tmp))
+                            }
+                        }?;
+                    }
+                } else {
+                    self.machine
+                        .move_location(Size::S32, loc_a, Location::GPR(tmp1))?;
+                    self.machine
+                        .move_location(Size::S32, loc_b, Location::GPR(tmp2))?;
+                }
+                self.machine.emit_i32_copysign(tmp1, tmp2)?;
+                self.machine
+                    .move_location(Size::S32, Location::GPR(tmp1), ret)?;
+                self.machine.release_gpr(tmp2);
+                self.machine.release_gpr(tmp1);
+            }
+
+            Operator::F32Abs => {
+                // Preserve canonicalization state.
+
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine.f32_abs(loc, ret)?;
+            }
+
+            Operator::F32Neg => {
+                // Preserve canonicalization state.
+
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine.f32_neg(loc, ret)?;
+            }
+
+            Operator::F64Const { value } => {
+                self.value_stack.push(Location::Imm64(value.bits()));
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+                self.state
+                    .wasm_stack
+                    .push(WasmAbstractValue::Const(value.bits()));
+            }
+            Operator::F64Add => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f64_add(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Sub => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f64_sub(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Mul => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f64_mul(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Div => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                self.machine.f64_div(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Max => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                self.machine.f64_max(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Min => {
+                self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 2));
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+                self.machine.f64_min(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Eq => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_eq(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Ne => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_ne(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Lt => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_lt(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Le => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_le(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Gt => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_gt(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Ge => {
+                self.fp_stack.pop2()?;
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::I32)?;
+                self.machine.f64_cmp_ge(loc_a, loc_b, ret)?;
+            }
+            Operator::F64Nearest => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f64_nearest(loc, ret)?;
+            }
+            Operator::F64Floor => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f64_floor(loc, ret)?;
+            }
+            Operator::F64Ceil => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f64_ceil(loc, ret)?;
+            }
+            Operator::F64Trunc => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f64_trunc(loc, ret)?;
+            }
+            Operator::F64Sqrt => {
+                self.fp_stack.pop1()?;
+                self.fp_stack
+                    .push(FloatValue::cncl_f64(self.value_stack.len() - 1));
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.f64_sqrt(loc, ret)?;
+            }
+
+            Operator::F64Copysign => {
+                let I2O1 { loc_a, loc_b, ret } = self.i2o1_prepare(WpType::F64)?;
+
+                let (fp_src1, fp_src2) = self.fp_stack.pop2()?;
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+
+                let tmp1 = self.machine.acquire_temp_gpr().unwrap();
+                let tmp2 = self.machine.acquire_temp_gpr().unwrap();
+
+                if self.machine.arch_supports_canonicalize_nan()
+                    && self.config.enable_nan_canonicalization
+                {
+                    for (fp, loc, tmp) in [(fp_src1, loc_a, tmp1), (fp_src2, loc_b, tmp2)].iter() {
+                        match fp.canonicalization {
+                            Some(_) => {
+                                self.machine
+                                    .canonicalize_nan(Size::S64, *loc, Location::GPR(*tmp))
+                            }
+                            None => {
+                                self.machine
+                                    .move_location(Size::S64, *loc, Location::GPR(*tmp))
+                            }
+                        }?;
+                    }
+                } else {
+                    self.machine
+                        .move_location(Size::S64, loc_a, Location::GPR(tmp1))?;
+                    self.machine
+                        .move_location(Size::S64, loc_b, Location::GPR(tmp2))?;
+                }
+                self.machine.emit_i64_copysign(tmp1, tmp2)?;
+                self.machine
+                    .move_location(Size::S64, Location::GPR(tmp1), ret)?;
+
+                self.machine.release_gpr(tmp2);
+                self.machine.release_gpr(tmp1);
+            }
+
+            Operator::F64Abs => {
+                // Preserve canonicalization state.
+
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine.f64_abs(loc, ret)?;
+            }
+
+            Operator::F64Neg => {
+                // Preserve canonicalization state.
+
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                self.machine.f64_neg(loc, ret)?;
+            }
+
+            Operator::F64PromoteF32 => {
+                let fp = self.fp_stack.pop1()?;
+                self.fp_stack.push(fp.promote(self.value_stack.len() - 1)?);
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.convert_f64_f32(loc, ret)?;
+            }
+            Operator::F32DemoteF64 => {
+                let fp = self.fp_stack.pop1()?;
+                self.fp_stack.push(fp.demote(self.value_stack.len() - 1)?);
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.convert_f32_f64(loc, ret)?;
+            }
+
+            Operator::I32ReinterpretF32 => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                let fp = self.fp_stack.pop1()?;
+
+                if !self.machine.arch_supports_canonicalize_nan()
+                    || !self.config.enable_nan_canonicalization
+                    || fp.canonicalization.is_none()
+                {
+                    if loc != ret {
+                        self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
+                    }
+                } else {
+                    self.machine.canonicalize_nan(Size::S32, loc, ret)?;
+                }
+            }
+            Operator::F32ReinterpretI32 => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+
+                if loc != ret {
+                    self.machine.emit_relaxed_mov(Size::S32, loc, ret)?;
+                }
+            }
+
+            Operator::I64ReinterpretF64 => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                let fp = self.fp_stack.pop1()?;
+
+                if !self.machine.arch_supports_canonicalize_nan()
+                    || !self.config.enable_nan_canonicalization
+                    || fp.canonicalization.is_none()
+                {
+                    if loc != ret {
+                        self.machine.emit_relaxed_mov(Size::S64, loc, ret)?;
+                    }
+                } else {
+                    self.machine.canonicalize_nan(Size::S64, loc, ret)?;
+                }
+            }
+            Operator::F64ReinterpretI64 => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+
+                if loc != ret {
+                    self.machine.emit_relaxed_mov(Size::S64, loc, ret)?;
+                }
+            }
+
+            Operator::I32TruncF32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f32(loc, ret, false, false)?;
+            }
+
+            Operator::I32TruncSatF32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f32(loc, ret, false, true)?;
+            }
+
+            Operator::I32TruncF32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f32(loc, ret, true, false)?;
+            }
+            Operator::I32TruncSatF32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f32(loc, ret, true, true)?;
+            }
+
+            Operator::I64TruncF32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f32(loc, ret, true, false)?;
+            }
+
+            Operator::I64TruncSatF32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f32(loc, ret, true, true)?;
+            }
+
+            Operator::I64TruncF32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f32(loc, ret, false, false)?;
+            }
+            Operator::I64TruncSatF32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f32(loc, ret, false, true)?;
+            }
+
+            Operator::I32TruncF64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f64(loc, ret, false, false)?;
+            }
+
+            Operator::I32TruncSatF64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f64(loc, ret, false, true)?;
+            }
+
+            Operator::I32TruncF64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f64(loc, ret, true, false)?;
+            }
+
+            Operator::I32TruncSatF64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i32_f64(loc, ret, true, true)?;
+            }
+
+            Operator::I64TruncF64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f64(loc, ret, true, false)?;
+            }
+
+            Operator::I64TruncSatF64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f64(loc, ret, true, true)?;
+            }
+
+            Operator::I64TruncF64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f64(loc, ret, false, false)?;
+            }
+
+            Operator::I64TruncSatF64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack.pop1()?;
+
+                self.machine.convert_i64_f64(loc, ret, false, true)?;
+            }
+
+            Operator::F32ConvertI32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN.
+
+                self.machine.convert_f32_i32(loc, true, ret)?;
+            }
+            Operator::F32ConvertI32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f32 never results in NaN.
+
+                self.machine.convert_f32_i32(loc, false, ret)?;
+            }
+            Operator::F32ConvertI64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN.
+
+                self.machine.convert_f32_i64(loc, true, ret)?;
+            }
+            Operator::F32ConvertI64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f32 never results in NaN.
+
+                self.machine.convert_f32_i64(loc, false, ret)?;
+            }
+
+            Operator::F64ConvertI32S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN.
+
+                self.machine.convert_f64_i32(loc, true, ret)?;
+            }
+            Operator::F64ConvertI32U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i32 to f64 never results in NaN.
+
+                self.machine.convert_f64_i32(loc, false, ret)?;
+            }
+            Operator::F64ConvertI64S => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN.
+
+                self.machine.convert_f64_i64(loc, true, ret)?;
+            }
+            Operator::F64ConvertI64U => {
+                let loc = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1)); // Converting i64 to f64 never results in NaN.
+
+                self.machine.convert_f64_i64(loc, false, ret)?;
+            }
+
+            Operator::Call { function_index } => {
+                let function_index = function_index as usize;
+
+                let sig_index = *self
+                    .module
+                    .functions
+                    .get(FunctionIndex::new(function_index))
+                    .unwrap();
+                let sig = self.module.signatures.get(sig_index).unwrap();
+                let param_types: SmallVec<[WpType; 8]> =
+                    sig.params().iter().cloned().map(type_to_wp_type).collect();
+                let return_types: SmallVec<[WpType; 1]> =
+                    sig.results().iter().cloned().map(type_to_wp_type).collect();
+
+                let params: SmallVec<[_; 8]> = self
+                    .value_stack
+                    .drain(self.value_stack.len() - param_types.len()..)
+                    .collect();
+                self.release_locations_only_regs(&params)?;
+
+                self.release_locations_only_osr_state(params.len())?;
+
+                // Pop arguments off the FP stack and canonicalize them if needed.
+                //
+                // Canonicalization state will be lost across function calls, so early canonicalization
+                // is necessary here.
+                while let Some(fp) = self.fp_stack.last() {
+                    if fp.depth >= self.value_stack.len() {
+                        let index = fp.depth - self.value_stack.len();
+                        if self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                        {
+                            let size = fp.canonicalization.unwrap().to_size();
+                            self.machine
+                                .canonicalize_nan(size, params[index], params[index])?;
+                        }
+                        self.fp_stack.pop().unwrap();
+                    } else {
+                        break;
+                    }
+                }
+
+                // Imported functions are called through trampolines placed as custom sections.
+                let reloc_target = if function_index < self.module.num_imported_functions {
+                    RelocationTarget::CustomSection(SectionIndex::new(function_index))
+                } else {
+                    RelocationTarget::LocalFunc(LocalFunctionIndex::new(
+                        function_index - self.module.num_imported_functions,
+                    ))
+                };
+                let calling_convention = self.calling_convention;
+
+                self.emit_call_native(
+                    |this| {
+                        let offset = this
+                            .machine
+                            .mark_instruction_with_trap_code(TrapCode::StackOverflow);
+                        let mut relocations = this
+                            .machine
+                            .emit_call_with_reloc(calling_convention, reloc_target)?;
+                        this.machine.mark_instruction_address_end(offset);
+                        this.relocations.append(&mut relocations);
+                        Ok(())
+                    },
+                    params.iter().copied(),
+                    param_types.iter().copied(),
+                )?;
+
+                self.release_locations_only_stack(&params)?;
+
+                if !return_types.is_empty() {
+                    let ret = self.acquire_locations(
+                        &[(
+                            return_types[0],
+                            MachineValue::WasmStack(self.value_stack.len()),
+                        )],
+                        false,
+                    )?[0];
+                    self.value_stack.push(ret);
+                    if return_types[0].is_float() {
+                        self.machine.move_location(
+                            Size::S64,
+                            Location::SIMD(self.machine.get_simd_for_ret()),
+                            ret,
+                        )?;
+                        self.fp_stack
+                            .push(FloatValue::new(self.value_stack.len() - 1));
+                    } else {
+                        self.machine.move_location(
+                            Size::S64,
+                            Location::GPR(self.machine.get_gpr_for_ret()),
+                            ret,
+                        )?;
+                    }
+                }
+            }
+            Operator::CallIndirect {
+                type_index,
+                table_index,
+                table_byte: _,
+            } => {
+                // TODO: removed restriction on always being table idx 0;
+                // does any code depend on this?
+                let table_index = TableIndex::new(table_index as _);
+                let index = SignatureIndex::new(type_index as usize);
+                let sig = self.module.signatures.get(index).unwrap();
+                let param_types: SmallVec<[WpType; 8]> =
+                    sig.params().iter().cloned().map(type_to_wp_type).collect();
+                let return_types: SmallVec<[WpType; 1]> =
+                    sig.results().iter().cloned().map(type_to_wp_type).collect();
+
+                let func_index = self.pop_value_released()?;
+
+                let params: SmallVec<[_; 8]> = self
+                    .value_stack
+                    .drain(self.value_stack.len() - param_types.len()..)
+                    .collect();
+                self.release_locations_only_regs(&params)?;
+
+                // Pop arguments off the FP stack and canonicalize them if needed.
+                //
+                // Canonicalization state will be lost across function calls, so early canonicalization
+                // is necessary here.
+                while let Some(fp) = self.fp_stack.last() {
+                    if fp.depth >= self.value_stack.len() {
+                        let index = fp.depth - self.value_stack.len();
+                        if self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                        {
+                            let size = fp.canonicalization.unwrap().to_size();
+                            self.machine
+                                .canonicalize_nan(size, params[index], params[index])?;
+                        }
+                        self.fp_stack.pop().unwrap();
+                    } else {
+                        break;
+                    }
+                }
+
+                let table_base = self.machine.acquire_temp_gpr().unwrap();
+                let table_count = self.machine.acquire_temp_gpr().unwrap();
+                let sigidx = self.machine.acquire_temp_gpr().unwrap();
+
+                if let Some(local_table_index) = self.module.local_table_index(table_index) {
+                    let (vmctx_offset_base, vmctx_offset_len) = (
+                        self.vmoffsets.vmctx_vmtable_definition(local_table_index),
+                        self.vmoffsets
+                            .vmctx_vmtable_definition_current_elements(local_table_index),
+                    );
+                    self.machine.move_location(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), vmctx_offset_base as i32),
+                        Location::GPR(table_base),
+                    )?;
+                    self.machine.move_location(
+                        Size::S32,
+                        Location::Memory(self.machine.get_vmctx_reg(), vmctx_offset_len as i32),
+                        Location::GPR(table_count),
+                    )?;
+                } else {
+                    // Do an indirection.
+                    let import_offset = self.vmoffsets.vmctx_vmtable_import(table_index);
+                    self.machine.move_location(
+                        Size::S64,
+                        Location::Memory(self.machine.get_vmctx_reg(), import_offset as i32),
+                        Location::GPR(table_base),
+                    )?;
+
+                    // Load len.
+                    self.machine.move_location(
+                        Size::S32,
+                        Location::Memory(
+                            table_base,
+                            self.vmoffsets.vmtable_definition_current_elements() as _,
+                        ),
+                        Location::GPR(table_count),
+                    )?;
+
+                    // Load base.
+                    self.machine.move_location(
+                        Size::S64,
+                        Location::Memory(table_base, self.vmoffsets.vmtable_definition_base() as _),
+                        Location::GPR(table_base),
+                    )?;
+                }
+
+                self.machine
+                    .location_cmp(Size::S32, func_index, Location::GPR(table_count))?;
+                self.machine
+                    .jmp_on_belowequal(self.special_labels.table_access_oob)?;
+                self.machine
+                    .move_location(Size::S32, func_index, Location::GPR(table_count))?;
+                self.machine.emit_imul_imm32(
+                    Size::S64,
+                    self.vmoffsets.size_of_vm_funcref() as u32,
+                    table_count,
+                )?;
+                self.machine.location_add(
+                    Size::S64,
+                    Location::GPR(table_base),
+                    Location::GPR(table_count),
+                    false,
+                )?;
+
+                // deref the table to get a VMFuncRef
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(table_count, self.vmoffsets.vm_funcref_anyfunc_ptr() as i32),
+                    Location::GPR(table_count),
+                )?;
+                // Trap if the FuncRef is null
+                self.machine.location_cmp(
+                    Size::S64,
+                    Location::Imm32(0),
+                    Location::GPR(table_count),
+                )?;
+                self.machine
+                    .jmp_on_equal(self.special_labels.indirect_call_null)?;
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_vmshared_signature_id(index) as i32,
+                    ),
+                    Location::GPR(sigidx),
+                )?;
+
+                // Trap if signature mismatches.
+                self.machine.location_cmp(
+                    Size::S32,
+                    Location::GPR(sigidx),
+                    Location::Memory(
+                        table_count,
+                        (self.vmoffsets.vmcaller_checked_anyfunc_type_index() as usize) as i32,
+                    ),
+                )?;
+                self.machine
+                    .jmp_on_different(self.special_labels.bad_signature)?;
+
+                self.machine.release_gpr(sigidx);
+                self.machine.release_gpr(table_count);
+                self.machine.release_gpr(table_base);
+
+                let gpr_for_call = self.machine.get_grp_for_call();
+                if table_count != gpr_for_call {
+                    self.machine.move_location(
+                        Size::S64,
+                        Location::GPR(table_count),
+                        Location::GPR(gpr_for_call),
+                    )?;
+                }
+
+                self.release_locations_only_osr_state(params.len())?;
+
+                let vmcaller_checked_anyfunc_func_ptr =
+                    self.vmoffsets.vmcaller_checked_anyfunc_func_ptr() as usize;
+                let vmcaller_checked_anyfunc_vmctx =
+                    self.vmoffsets.vmcaller_checked_anyfunc_vmctx() as usize;
+                let calling_convention = self.calling_convention;
+
+                self.emit_call_native(
+                    |this| {
+                        if this.machine.arch_requires_indirect_call_trampoline() {
+                            this.machine
+                                .arch_emit_indirect_call_with_trampoline(Location::Memory(
+                                    gpr_for_call,
+                                    vmcaller_checked_anyfunc_func_ptr as i32,
+                                ))
+                        } else {
+                            let offset = this
+                                .machine
+                                .mark_instruction_with_trap_code(TrapCode::StackOverflow);
+
+                            // We set the context pointer
+                            this.machine.move_location(
+                                Size::S64,
+                                Location::Memory(
+                                    gpr_for_call,
+                                    vmcaller_checked_anyfunc_vmctx as i32,
+                                ),
+                                this.machine
+                                    .get_simple_param_location(0, calling_convention),
+                            )?;
+
+                            this.machine.emit_call_location(Location::Memory(
+                                gpr_for_call,
+                                vmcaller_checked_anyfunc_func_ptr as i32,
+                            ))?;
+                            this.machine.mark_instruction_address_end(offset);
+                            Ok(())
+                        }
+                    },
+                    params.iter().copied(),
+                    param_types.iter().copied(),
+                )?;
+
+                self.release_locations_only_stack(&params)?;
+
+                if !return_types.is_empty() {
+                    let ret = self.acquire_locations(
+                        &[(
+                            return_types[0],
+                            MachineValue::WasmStack(self.value_stack.len()),
+                        )],
+                        false,
+                    )?[0];
+                    self.value_stack.push(ret);
+                    if return_types[0].is_float() {
+                        self.machine.move_location(
+                            Size::S64,
+                            Location::SIMD(self.machine.get_simd_for_ret()),
+                            ret,
+                        )?;
+                        self.fp_stack
+                            .push(FloatValue::new(self.value_stack.len() - 1));
+                    } else {
+                        self.machine.move_location(
+                            Size::S64,
+                            Location::GPR(self.machine.get_gpr_for_ret()),
+                            ret,
+                        )?;
+                    }
+                }
+            }
+            Operator::If { blockty } => {
+                let label_end = self.machine.get_label();
+                let label_else = self.machine.get_label();
+
+                let cond = self.pop_value_released()?;
+
+                let frame = ControlFrame {
+                    label: label_end,
+                    loop_like: false,
+                    if_else: IfElseState::If(label_else),
+                    returns: match blockty {
+                        WpTypeOrFuncType::Empty => smallvec![],
+                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
+                        _ => {
+                            return Err(CompileError::Codegen(
+                                "If: multi-value returns not yet implemented".to_owned(),
+                            ))
+                        }
+                    },
+                    value_stack_depth: self.value_stack.len(),
+                    fp_stack_depth: self.fp_stack.len(),
+                    state: self.state.clone(),
+                    state_diff_id: self.get_state_diff(),
+                };
+                self.control_stack.push(frame);
+                self.machine
+                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
+                self.machine.jmp_on_equal(label_else)?;
+            }
+            Operator::Else => {
+                let frame = self.control_stack.last_mut().unwrap();
+
+                if !was_unreachable && !frame.returns.is_empty() {
+                    let first_return = frame.returns[0];
+                    let loc = *self.value_stack.last().unwrap();
+                    let canonicalize = if first_return.is_float() {
+                        let fp = self.fp_stack.peek1()?;
+                        self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                    } else {
+                        false
+                    };
+                    self.machine
+                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                }
+
+                let frame = &self.control_stack.last_mut().unwrap();
+                let stack_depth = frame.value_stack_depth;
+                let fp_depth = frame.fp_stack_depth;
+                self.release_locations_value(stack_depth)?;
+                self.value_stack.truncate(stack_depth);
+                self.fp_stack.truncate(fp_depth);
+                let frame = &mut self.control_stack.last_mut().unwrap();
+
+                match frame.if_else {
+                    IfElseState::If(label) => {
+                        self.machine.jmp_unconditionnal(frame.label)?;
+                        self.machine.emit_label(label)?;
+                        frame.if_else = IfElseState::Else;
+                    }
+                    _ => {
+                        return Err(CompileError::Codegen(
+                            "Else: frame.if_else unreachable code".to_owned(),
+                        ))
+                    }
+                }
+            }
+            // `TypedSelect` must be used for extern refs so ref counting should
+            // be done with TypedSelect. But otherwise they're the same.
+            Operator::TypedSelect { .. } | Operator::Select => {
+                let cond = self.pop_value_released()?;
+                let v_b = self.pop_value_released()?;
+                let v_a = self.pop_value_released()?;
+                let cncl: Option<(Option<CanonicalizeType>, Option<CanonicalizeType>)> =
+                    if self.fp_stack.len() >= 2
+                        && self.fp_stack[self.fp_stack.len() - 2].depth == self.value_stack.len()
+                        && self.fp_stack[self.fp_stack.len() - 1].depth
+                            == self.value_stack.len() + 1
+                    {
+                        let (left, right) = self.fp_stack.pop2()?;
+                        self.fp_stack.push(FloatValue::new(self.value_stack.len()));
+                        Some((left.canonicalization, right.canonicalization))
+                    } else {
+                        None
+                    };
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+
+                let end_label = self.machine.get_label();
+                let zero_label = self.machine.get_label();
+
+                self.machine
+                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
+                self.machine.jmp_on_equal(zero_label)?;
+                match cncl {
+                    Some((Some(fp), _))
+                        if self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization =>
+                    {
+                        self.machine.canonicalize_nan(fp.to_size(), v_a, ret)?;
+                    }
+                    _ => {
+                        if v_a != ret {
+                            self.machine.emit_relaxed_mov(Size::S64, v_a, ret)?;
+                        }
+                    }
+                }
+                self.machine.jmp_unconditionnal(end_label)?;
+                self.machine.emit_label(zero_label)?;
+                match cncl {
+                    Some((_, Some(fp)))
+                        if self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization =>
+                    {
+                        self.machine.canonicalize_nan(fp.to_size(), v_b, ret)?;
+                    }
+                    _ => {
+                        if v_b != ret {
+                            self.machine.emit_relaxed_mov(Size::S64, v_b, ret)?;
+                        }
+                    }
+                }
+                self.machine.emit_label(end_label)?;
+            }
+            Operator::Block { blockty } => {
+                let frame = ControlFrame {
+                    label: self.machine.get_label(),
+                    loop_like: false,
+                    if_else: IfElseState::None,
+                    returns: match blockty {
+                        WpTypeOrFuncType::Empty => smallvec![],
+                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
+                        _ => {
+                            return Err(CompileError::Codegen(
+                                "Block: multi-value returns not yet implemented".to_owned(),
+                            ))
+                        }
+                    },
+                    value_stack_depth: self.value_stack.len(),
+                    fp_stack_depth: self.fp_stack.len(),
+                    state: self.state.clone(),
+                    state_diff_id: self.get_state_diff(),
+                };
+                self.control_stack.push(frame);
+            }
+            Operator::Loop { blockty } => {
+                self.machine.align_for_loop()?;
+                let label = self.machine.get_label();
+                let state_diff_id = self.get_state_diff();
+                let _activate_offset = self.machine.assembler_get_offset().0;
+
+                self.control_stack.push(ControlFrame {
+                    label,
+                    loop_like: true,
+                    if_else: IfElseState::None,
+                    returns: match blockty {
+                        WpTypeOrFuncType::Empty => smallvec![],
+                        WpTypeOrFuncType::Type(inner_ty) => smallvec![inner_ty],
+                        _ => {
+                            return Err(CompileError::Codegen(
+                                "Loop: multi-value returns not yet implemented".to_owned(),
+                            ))
+                        }
+                    },
+                    value_stack_depth: self.value_stack.len(),
+                    fp_stack_depth: self.fp_stack.len(),
+                    state: self.state.clone(),
+                    state_diff_id,
+                });
+                self.machine.emit_label(label)?;
+
+                // TODO: Re-enable interrupt signal check without branching
+            }
+            Operator::Nop => {}
+            Operator::MemorySize { mem, mem_byte: _ } => {
+                let memory_index = MemoryIndex::new(mem as usize);
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_memory_index(memory_index).is_some() {
+                                VMBuiltinFunctionIndex::get_memory32_size_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_memory32_size_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index]
+                    iter::once(Location::Imm32(memory_index.index() as u32)),
+                    iter::once(WpType::I64),
+                )?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S64,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::MemoryInit { data_index, mem } => {
+                let len = self.value_stack.pop().unwrap();
+                let src = self.value_stack.pop().unwrap();
+                let dst = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, src, dst])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_memory_init_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, data_index, dst, src, len]
+                    [
+                        Location::Imm32(mem),
+                        Location::Imm32(data_index),
+                        dst,
+                        src,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [
+                        WpType::I64,
+                        WpType::I64,
+                        WpType::I64,
+                        WpType::I64,
+                        WpType::I64,
+                    ]
+                    .iter()
+                    .cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst, src, len])?;
+            }
+            Operator::DataDrop { data_index } => {
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_data_drop_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, data_index]
+                    iter::once(Location::Imm32(data_index)),
+                    iter::once(WpType::I64),
+                )?;
+            }
+            Operator::MemoryCopy { dst_mem, src_mem } => {
+                // ignore until we support multiple memories
+                let _dst = dst_mem;
+                let len = self.value_stack.pop().unwrap();
+                let src_pos = self.value_stack.pop().unwrap();
+                let dst_pos = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, src_pos, dst_pos])?;
+
+                let memory_index = MemoryIndex::new(src_mem as usize);
+                let (memory_copy_index, memory_index) =
+                    if self.module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_copy_index(),
+                            memory_index,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_copy_index(),
+                            memory_index,
+                        )
+                    };
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(memory_copy_index) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, dst, src, len]
+                    [
+                        Location::Imm32(memory_index.index() as u32),
+                        dst_pos,
+                        src_pos,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
+                        .iter()
+                        .cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst_pos, src_pos, len])?;
+            }
+            Operator::MemoryFill { mem } => {
+                let len = self.value_stack.pop().unwrap();
+                let val = self.value_stack.pop().unwrap();
+                let dst = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, val, dst])?;
+
+                let memory_index = MemoryIndex::new(mem as usize);
+                let (memory_fill_index, memory_index) =
+                    if self.module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_fill_index(),
+                            memory_index,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_fill_index(),
+                            memory_index,
+                        )
+                    };
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(memory_fill_index) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, dst, src, len]
+                    [Location::Imm32(memory_index.index() as u32), dst, val, len]
+                        .iter()
+                        .cloned(),
+                    [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
+                        .iter()
+                        .cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst, val, len])?;
+            }
+            Operator::MemoryGrow { mem, mem_byte: _ } => {
+                let memory_index = MemoryIndex::new(mem as usize);
+                let param_pages = self.value_stack.pop().unwrap();
+
+                self.release_locations_only_regs(&[param_pages])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_memory_index(memory_index).is_some() {
+                                VMBuiltinFunctionIndex::get_memory32_grow_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_memory32_grow_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, val, memory_index]
+                    iter::once(param_pages)
+                        .chain(iter::once(Location::Imm32(memory_index.index() as u32))),
+                    [WpType::I64, WpType::I64].iter().cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[param_pages])?;
+
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S64,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::I32Load { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::F32Load { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.f32_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Load8U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_load_8u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Load8S { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_load_8s(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Load16U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_load_16u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Load16S { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_load_16s(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Store { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::F32Store { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                let fp = self.fp_stack.pop1()?;
+                let config_nan_canonicalization = self.config.enable_nan_canonicalization;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.f32_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            config_nan_canonicalization && fp.canonicalization.is_some(),
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Store8 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_save_8(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32Store16 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_save_16(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::F64Load { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::F64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.fp_stack
+                    .push(FloatValue::new(self.value_stack.len() - 1));
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.f64_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load8U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_8u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load8S { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_8s(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load16U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_16u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load16S { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_16s(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load32U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_32u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Load32S { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_load_32s(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Store { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::F64Store { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                let fp = self.fp_stack.pop1()?;
+                let config_nan_canonicalization = self.config.enable_nan_canonicalization;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.f64_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            config_nan_canonicalization && fp.canonicalization.is_some(),
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Store8 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_save_8(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Store16 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_save_16(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64Store32 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_save_32(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::Unreachable => {
+                self.mark_trappable();
+                self.machine
+                    .emit_illegal_op(TrapCode::UnreachableCodeReached)?;
+                self.unreachable_depth = 1;
+            }
+            Operator::Return => {
+                let frame = &self.control_stack[0];
+                if !frame.returns.is_empty() {
+                    if frame.returns.len() != 1 {
+                        return Err(CompileError::Codegen(
+                            "Return: incorrect frame.returns".to_owned(),
+                        ));
+                    }
+                    let first_return = frame.returns[0];
+                    let loc = *self.value_stack.last().unwrap();
+                    let canonicalize = if first_return.is_float() {
+                        let fp = self.fp_stack.peek1()?;
+                        self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                    } else {
+                        false
+                    };
+                    self.machine
+                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                }
+                let frame = &self.control_stack[0];
+                let frame_depth = frame.value_stack_depth;
+                let label = frame.label;
+                self.release_locations_keep_state(frame_depth)?;
+                self.machine.jmp_unconditionnal(label)?;
+                self.unreachable_depth = 1;
+            }
+            Operator::Br { relative_depth } => {
+                let frame =
+                    &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)];
+                if !frame.loop_like && !frame.returns.is_empty() {
+                    if frame.returns.len() != 1 {
+                        return Err(CompileError::Codegen(
+                            "Br: incorrect frame.returns".to_owned(),
+                        ));
+                    }
+                    let first_return = frame.returns[0];
+                    let loc = *self.value_stack.last().unwrap();
+                    let canonicalize = if first_return.is_float() {
+                        let fp = self.fp_stack.peek1()?;
+                        self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                    } else {
+                        false
+                    };
+                    self.machine
+                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                }
+                let stack_len = self.control_stack.len();
+                let frame = &mut self.control_stack[stack_len - 1 - (relative_depth as usize)];
+                let frame_depth = frame.value_stack_depth;
+                let label = frame.label;
+
+                self.release_locations_keep_state(frame_depth)?;
+                self.machine.jmp_unconditionnal(label)?;
+                self.unreachable_depth = 1;
+            }
+            Operator::BrIf { relative_depth } => {
+                let after = self.machine.get_label();
+                let cond = self.pop_value_released()?;
+                self.machine
+                    .emit_relaxed_cmp(Size::S32, Location::Imm32(0), cond)?;
+                self.machine.jmp_on_equal(after)?;
+
+                let frame =
+                    &self.control_stack[self.control_stack.len() - 1 - (relative_depth as usize)];
+                if !frame.loop_like && !frame.returns.is_empty() {
+                    if frame.returns.len() != 1 {
+                        return Err(CompileError::Codegen(
+                            "BrIf: incorrect frame.returns".to_owned(),
+                        ));
+                    }
+
+                    let first_return = frame.returns[0];
+                    let loc = *self.value_stack.last().unwrap();
+                    let canonicalize = if first_return.is_float() {
+                        let fp = self.fp_stack.peek1()?;
+                        self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                    } else {
+                        false
+                    };
+                    self.machine
+                        .emit_function_return_value(first_return, canonicalize, loc)?;
+                }
+                let stack_len = self.control_stack.len();
+                let frame = &mut self.control_stack[stack_len - 1 - (relative_depth as usize)];
+                let stack_depth = frame.value_stack_depth;
+                let label = frame.label;
+                self.release_locations_keep_state(stack_depth)?;
+                self.machine.jmp_unconditionnal(label)?;
+
+                self.machine.emit_label(after)?;
+            }
+            Operator::BrTable { ref targets } => {
+                let default_target = targets.default();
+                let targets = targets
+                    .targets()
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| CompileError::Codegen(format!("BrTable read_table: {:?}", e)))?;
+                let cond = self.pop_value_released()?;
+                let table_label = self.machine.get_label();
+                let mut table: Vec<Label> = vec![];
+                let default_br = self.machine.get_label();
+                self.machine.emit_relaxed_cmp(
+                    Size::S32,
+                    Location::Imm32(targets.len() as u32),
+                    cond,
+                )?;
+                self.machine.jmp_on_aboveequal(default_br)?;
+
+                self.machine.emit_jmp_to_jumptable(table_label, cond)?;
+
+                for target in targets.iter() {
+                    let label = self.machine.get_label();
+                    self.machine.emit_label(label)?;
+                    table.push(label);
+                    let frame =
+                        &self.control_stack[self.control_stack.len() - 1 - (*target as usize)];
+                    if !frame.loop_like && !frame.returns.is_empty() {
+                        if frame.returns.len() != 1 {
+                            return Err(CompileError::Codegen(format!(
+                                "BrTable: incorrect frame.returns for {:?}",
+                                target
+                            )));
+                        }
+
+                        let first_return = frame.returns[0];
+                        let loc = *self.value_stack.last().unwrap();
+                        let canonicalize = if first_return.is_float() {
+                            let fp = self.fp_stack.peek1()?;
+                            self.machine.arch_supports_canonicalize_nan()
+                                && self.config.enable_nan_canonicalization
+                                && fp.canonicalization.is_some()
+                        } else {
+                            false
+                        };
+                        self.machine
+                            .emit_function_return_value(first_return, canonicalize, loc)?;
+                    }
+                    let frame =
+                        &self.control_stack[self.control_stack.len() - 1 - (*target as usize)];
+                    let stack_depth = frame.value_stack_depth;
+                    let label = frame.label;
+                    self.release_locations_keep_state(stack_depth)?;
+                    self.machine.jmp_unconditionnal(label)?;
+                }
+                self.machine.emit_label(default_br)?;
+
+                {
+                    let frame = &self.control_stack
+                        [self.control_stack.len() - 1 - (default_target as usize)];
+                    if !frame.loop_like && !frame.returns.is_empty() {
+                        if frame.returns.len() != 1 {
+                            return Err(CompileError::Codegen(
+                                "BrTable: incorrect frame.returns".to_owned(),
+                            ));
+                        }
+
+                        let first_return = frame.returns[0];
+                        let loc = *self.value_stack.last().unwrap();
+                        let canonicalize = if first_return.is_float() {
+                            let fp = self.fp_stack.peek1()?;
+                            self.machine.arch_supports_canonicalize_nan()
+                                && self.config.enable_nan_canonicalization
+                                && fp.canonicalization.is_some()
+                        } else {
+                            false
+                        };
+                        self.machine
+                            .emit_function_return_value(first_return, canonicalize, loc)?;
+                    }
+                    let frame = &self.control_stack
+                        [self.control_stack.len() - 1 - (default_target as usize)];
+                    let stack_depth = frame.value_stack_depth;
+                    let label = frame.label;
+                    self.release_locations_keep_state(stack_depth)?;
+                    self.machine.jmp_unconditionnal(label)?;
+                }
+
+                self.machine.emit_label(table_label)?;
+                for x in table {
+                    self.machine.jmp_unconditionnal(x)?;
+                }
+                self.unreachable_depth = 1;
+            }
+            Operator::Drop => {
+                self.pop_value_released()?;
+                if let Some(x) = self.fp_stack.last() {
+                    if x.depth == self.value_stack.len() {
+                        self.fp_stack.pop1()?;
+                    }
+                }
+            }
+            Operator::End => {
+                let frame = self.control_stack.pop().unwrap();
+
+                if !was_unreachable && !frame.returns.is_empty() {
+                    let loc = *self.value_stack.last().unwrap();
+                    let canonicalize = if frame.returns[0].is_float() {
+                        let fp = self.fp_stack.peek1()?;
+                        self.machine.arch_supports_canonicalize_nan()
+                            && self.config.enable_nan_canonicalization
+                            && fp.canonicalization.is_some()
+                    } else {
+                        false
+                    };
+                    self.machine
+                        .emit_function_return_value(frame.returns[0], canonicalize, loc)?;
+                }
+
+                if self.control_stack.is_empty() {
+                    self.machine.emit_label(frame.label)?;
+                    self.finalize_locals(self.calling_convention)?;
+                    self.machine.emit_function_epilog()?;
+
+                    // Make a copy of the return value in XMM0, as required by the SysV CC.
+                    match self.signature.results() {
+                        [x] if *x == Type::F32 || *x == Type::F64 => {
+                            self.machine.emit_function_return_float()?;
+                        }
+                        _ => {}
+                    }
+                    self.machine.emit_ret()?;
+                } else {
+                    let released = &self.value_stack.clone()[frame.value_stack_depth..];
+                    self.release_locations(released)?;
+                    self.value_stack.truncate(frame.value_stack_depth);
+                    self.fp_stack.truncate(frame.fp_stack_depth);
+
+                    if !frame.loop_like {
+                        self.machine.emit_label(frame.label)?;
+                    }
+
+                    if let IfElseState::If(label) = frame.if_else {
+                        self.machine.emit_label(label)?;
+                    }
+
+                    if !frame.returns.is_empty() {
+                        if frame.returns.len() != 1 {
+                            return Err(CompileError::Codegen(
+                                "End: incorrect frame.returns".to_owned(),
+                            ));
+                        }
+                        let loc = self.acquire_locations(
+                            &[(
+                                frame.returns[0],
+                                MachineValue::WasmStack(self.value_stack.len()),
+                            )],
+                            false,
+                        )?[0];
+                        self.machine.move_location(
+                            Size::S64,
+                            Location::GPR(self.machine.get_gpr_for_ret()),
+                            loc,
+                        )?;
+                        self.value_stack.push(loc);
+                        if frame.returns[0].is_float() {
+                            self.fp_stack
+                                .push(FloatValue::new(self.value_stack.len() - 1));
+                            // we already canonicalized at the `Br*` instruction or here previously.
+                        }
+                    }
+                }
+            }
+            Operator::AtomicFence => {
+                // Fence is a nop.
+                //
+                // Fence was added to preserve information about fences from
+                // source languages. If in the future Wasm extends the memory
+                // model, and if we hadn't recorded what fences used to be there,
+                // it would lead to data races that weren't present in the
+                // original source language.
+                self.machine.emit_memory_fence()?;
+            }
+            Operator::I32AtomicLoad { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicLoad8U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_load_8u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicLoad16U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_load_16u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicStore { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicStore8 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_save_8(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicStore16 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_save_16(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicLoad { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_load(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicLoad8U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_load_8u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicLoad16U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_load_16u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicLoad32U { ref memarg } => {
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_load_32u(
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicStore { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_save(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicStore8 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_save_8(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicStore16 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_save_16(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicStore32 { ref memarg } => {
+                let target_value = self.pop_value_released()?;
+                let target_addr = self.pop_value_released()?;
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_save_32(
+                            target_value,
+                            memarg,
+                            target_addr,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwAdd { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_add(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwAdd { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_add(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8AddU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_add_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16AddU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_add_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8AddU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_add_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16AddU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_add_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32AddU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_add_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwSub { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_sub(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwSub { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_sub(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8SubU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_sub_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16SubU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_sub_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8SubU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_sub_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16SubU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_sub_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32SubU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_sub_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwAnd { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_and(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwAnd { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_and(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8AndU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_and_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16AndU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_and_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8AndU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_and_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16AndU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_and_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32AndU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_and_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwOr { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_or(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwOr { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_or(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8OrU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_or_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16OrU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_or_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8OrU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_or_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16OrU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_or_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32OrU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_or_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwXor { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xor(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwXor { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xor(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8XorU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xor_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16XorU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xor_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8XorU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xor_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16XorU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xor_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32XorU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xor_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwXchg { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xchg(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwXchg { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xchg(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8XchgU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xchg_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16XchgU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_xchg_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8XchgU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xchg_8u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16XchgU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xchg_16u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32XchgU { ref memarg } => {
+                let loc = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_xchg_32u(
+                            loc,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmwCmpxchg { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_cmpxchg(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmwCmpxchg { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_cmpxchg(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw8CmpxchgU { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_cmpxchg_8u(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I32AtomicRmw16CmpxchgU { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i32_atomic_cmpxchg_16u(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw8CmpxchgU { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_cmpxchg_8u(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw16CmpxchgU { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_cmpxchg_16u(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+            Operator::I64AtomicRmw32CmpxchgU { ref memarg } => {
+                let new = self.pop_value_released()?;
+                let cmp = self.pop_value_released()?;
+                let target = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I64, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.op_memory(
+                    |this,
+                     need_check,
+                     imported_memories,
+                     offset,
+                     heap_access_oob,
+                     unaligned_atomic| {
+                        this.machine.i64_atomic_cmpxchg_32u(
+                            new,
+                            cmp,
+                            target,
+                            memarg,
+                            ret,
+                            need_check,
+                            imported_memories,
+                            offset,
+                            heap_access_oob,
+                            unaligned_atomic,
+                        )
+                    },
+                )?;
+            }
+
+            Operator::RefNull { .. } => {
+                self.value_stack.push(Location::Imm64(0));
+                self.state.wasm_stack.push(WasmAbstractValue::Const(0));
+            }
+            Operator::RefFunc { function_index } => {
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_func_ref_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: unclear if we need this? check other new insts with no stack ops
+                //.machine.release_locations_only_osr_state(1);
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, func_index] -> funcref
+                    iter::once(Location::Imm32(function_index as u32)),
+                    iter::once(WpType::I64),
+                )?;
+
+                let ret = self.acquire_locations(
+                    &[(
+                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+                        MachineValue::WasmStack(self.value_stack.len()),
+                    )],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S64,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::RefIsNull => {
+                let loc_a = self.pop_value_released()?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.machine.i64_cmp_eq(loc_a, Location::Imm64(0), ret)?;
+                self.value_stack.push(ret);
+            }
+            Operator::TableSet { table: index } => {
+                let table_index = TableIndex::new(index as _);
+                let value = self.value_stack.pop().unwrap();
+                let index = self.value_stack.pop().unwrap();
+                // double check this does what I think it does
+                self.release_locations_only_regs(&[value, index])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_table_index(table_index).is_some() {
+                                VMBuiltinFunctionIndex::get_table_set_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_table_set_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 2?
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, table_index, elem_index, reftype]
+                    [Location::Imm32(table_index.index() as u32), index, value]
+                        .iter()
+                        .cloned(),
+                    [WpType::I32, WpType::I64, WpType::I64].iter().cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[index, value])?;
+            }
+            Operator::TableGet { table: index } => {
+                let table_index = TableIndex::new(index as _);
+                let index = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[index])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_table_index(table_index).is_some() {
+                                VMBuiltinFunctionIndex::get_table_get_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_table_get_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, table_index, elem_index] -> reftype
+                    [Location::Imm32(table_index.index() as u32), index]
+                        .iter()
+                        .cloned(),
+                    [WpType::I32, WpType::I64].iter().cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[index])?;
+
+                let ret = self.acquire_locations(
+                    &[(
+                        WpType::Ref(WpRefType::new(true, WpHeapType::Func).unwrap()),
+                        MachineValue::WasmStack(self.value_stack.len()),
+                    )],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S64,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::TableSize { table: index } => {
+                let table_index = TableIndex::new(index as _);
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_table_index(table_index).is_some() {
+                                VMBuiltinFunctionIndex::get_table_size_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_table_size_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, table_index] -> i32
+                    iter::once(Location::Imm32(table_index.index() as u32)),
+                    iter::once(WpType::I32),
+                )?;
+
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S32,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::TableGrow { table: index } => {
+                let table_index = TableIndex::new(index as _);
+                let delta = self.value_stack.pop().unwrap();
+                let init_value = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[delta, init_value])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(
+                            if self.module.local_table_index(table_index).is_some() {
+                                VMBuiltinFunctionIndex::get_table_grow_index()
+                            } else {
+                                VMBuiltinFunctionIndex::get_imported_table_get_index()
+                            },
+                        ) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 2?
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, init_value, delta, table_index] -> u32
+                    [
+                        init_value,
+                        delta,
+                        Location::Imm32(table_index.index() as u32),
+                    ]
+                    .iter()
+                    .cloned(),
+                    [WpType::I64, WpType::I64, WpType::I64].iter().cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[init_value, delta])?;
+
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S32,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::TableCopy {
+                dst_table,
+                src_table,
+            } => {
+                let len = self.value_stack.pop().unwrap();
+                let src = self.value_stack.pop().unwrap();
+                let dest = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, src, dest])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_copy_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, dst_table_index, src_table_index, dst, src, len]
+                    [
+                        Location::Imm32(dst_table),
+                        Location::Imm32(src_table),
+                        dest,
+                        src,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [
+                        WpType::I32,
+                        WpType::I32,
+                        WpType::I64,
+                        WpType::I64,
+                        WpType::I64,
+                    ]
+                    .iter()
+                    .cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[dest, src, len])?;
+            }
+
+            Operator::TableFill { table } => {
+                let len = self.value_stack.pop().unwrap();
+                let val = self.value_stack.pop().unwrap();
+                let dest = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, val, dest])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_fill_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, table_index, start_idx, item, len]
+                    [Location::Imm32(table), dest, val, len].iter().cloned(),
+                    [WpType::I32, WpType::I64, WpType::I64, WpType::I64]
+                        .iter()
+                        .cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[dest, val, len])?;
+            }
+            Operator::TableInit { elem_index, table } => {
+                let len = self.value_stack.pop().unwrap();
+                let src = self.value_stack.pop().unwrap();
+                let dest = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[len, src, dest])?;
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_table_init_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, table_index, elem_index, dst, src, len]
+                    [
+                        Location::Imm32(table),
+                        Location::Imm32(elem_index),
+                        dest,
+                        src,
+                        len,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [
+                        WpType::I32,
+                        WpType::I32,
+                        WpType::I64,
+                        WpType::I64,
+                        WpType::I64,
+                    ]
+                    .iter()
+                    .cloned(),
+                )?;
+
+                self.release_locations_only_stack(&[dest, src, len])?;
+            }
+            Operator::ElemDrop { elem_index } => {
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets
+                            .vmctx_builtin_function(VMBuiltinFunctionIndex::get_elem_drop_index())
+                            as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: do we need this?
+                //.machine.release_locations_only_osr_state(1);
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, elem_index]
+                    [Location::Imm32(elem_index)].iter().cloned(),
+                    [WpType::I32].iter().cloned(),
+                )?;
+            }
+            Operator::MemoryAtomicWait32 { ref memarg } => {
+                let timeout = self.value_stack.pop().unwrap();
+                let val = self.value_stack.pop().unwrap();
+                let dst = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[timeout, val, dst])?;
+
+                let memory_index = MemoryIndex::new(memarg.memory as usize);
+                let (memory_atomic_wait32, memory_index) =
+                    if self.module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_wait32_index(),
+                            memory_index,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index(),
+                            memory_index,
+                        )
+                    };
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(memory_atomic_wait32) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, dst, src, timeout]
+                    [
+                        Location::Imm32(memory_index.index() as u32),
+                        dst,
+                        val,
+                        timeout,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [WpType::I32, WpType::I32, WpType::I32, WpType::I64]
+                        .iter()
+                        .cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst, val, timeout])?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S32,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::MemoryAtomicWait64 { ref memarg } => {
+                let timeout = self.value_stack.pop().unwrap();
+                let val = self.value_stack.pop().unwrap();
+                let dst = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[timeout, val, dst])?;
+
+                let memory_index = MemoryIndex::new(memarg.memory as usize);
+                let (memory_atomic_wait64, memory_index) =
+                    if self.module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_wait64_index(),
+                            memory_index,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index(),
+                            memory_index,
+                        )
+                    };
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(memory_atomic_wait64) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, dst, src, timeout]
+                    [
+                        Location::Imm32(memory_index.index() as u32),
+                        dst,
+                        val,
+                        timeout,
+                    ]
+                    .iter()
+                    .cloned(),
+                    [WpType::I32, WpType::I32, WpType::I64, WpType::I64]
+                        .iter()
+                        .cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst, val, timeout])?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S32,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            Operator::MemoryAtomicNotify { ref memarg } => {
+                let cnt = self.value_stack.pop().unwrap();
+                let dst = self.value_stack.pop().unwrap();
+                self.release_locations_only_regs(&[cnt, dst])?;
+
+                let memory_index = MemoryIndex::new(memarg.memory as usize);
+                let (memory_atomic_notify, memory_index) =
+                    if self.module.local_memory_index(memory_index).is_some() {
+                        (
+                            VMBuiltinFunctionIndex::get_memory_atomic_notify_index(),
+                            memory_index,
+                        )
+                    } else {
+                        (
+                            VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index(),
+                            memory_index,
+                        )
+                    };
+
+                self.machine.move_location(
+                    Size::S64,
+                    Location::Memory(
+                        self.machine.get_vmctx_reg(),
+                        self.vmoffsets.vmctx_builtin_function(memory_atomic_notify) as i32,
+                    ),
+                    Location::GPR(self.machine.get_grp_for_call()),
+                )?;
+
+                // TODO: should this be 3?
+                self.release_locations_only_osr_state(1)?;
+
+                self.emit_call_native(
+                    |this| {
+                        this.machine
+                            .emit_call_register(this.machine.get_grp_for_call())
+                    },
+                    // [vmctx, memory_index, dst, src, timeout]
+                    [Location::Imm32(memory_index.index() as u32), dst]
+                        .iter()
+                        .cloned(),
+                    [WpType::I32, WpType::I32].iter().cloned(),
+                )?;
+                self.release_locations_only_stack(&[dst, cnt])?;
+                let ret = self.acquire_locations(
+                    &[(WpType::I32, MachineValue::WasmStack(self.value_stack.len()))],
+                    false,
+                )?[0];
+                self.value_stack.push(ret);
+                self.machine.move_location(
+                    Size::S32,
+                    Location::GPR(self.machine.get_gpr_for_ret()),
+                    ret,
+                )?;
+            }
+            _ => {
+                return Err(CompileError::Codegen(format!(
+                    "not yet implemented: {:?}",
+                    op
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn finalize(
+        mut self,
+        data: &FunctionBodyData,
+    ) -> Result<(CompiledFunction, Option<UnwindFrame>), CompileError> {
+        // Generate actual code for special labels.
+        self.machine
+            .emit_label(self.special_labels.integer_division_by_zero)?;
+        self.machine
+            .emit_illegal_op(TrapCode::IntegerDivisionByZero)?;
+
+        self.machine
+            .emit_label(self.special_labels.integer_overflow)?;
+        self.machine.emit_illegal_op(TrapCode::IntegerOverflow)?;
+
+        self.machine
+            .emit_label(self.special_labels.heap_access_oob)?;
+        self.machine
+            .emit_illegal_op(TrapCode::HeapAccessOutOfBounds)?;
+
+        self.machine
+            .emit_label(self.special_labels.table_access_oob)?;
+        self.machine
+            .emit_illegal_op(TrapCode::TableAccessOutOfBounds)?;
+
+        self.machine
+            .emit_label(self.special_labels.indirect_call_null)?;
+        self.machine.emit_illegal_op(TrapCode::IndirectCallToNull)?;
+
+        self.machine.emit_label(self.special_labels.bad_signature)?;
+        self.machine.emit_illegal_op(TrapCode::BadSignature)?;
+
+        self.machine
+            .emit_label(self.special_labels.unaligned_atomic)?;
+        self.machine.emit_illegal_op(TrapCode::UnalignedAtomic)?;
+
+        // Notify the assembler backend to generate necessary code at end of function.
+        self.machine.finalize_function()?;
+
+        let body_len = self.machine.assembler_get_offset().0;
+
+        let mut unwind_info = None;
+        let mut fde = None;
+        #[cfg(feature = "unwind")]
+        match self.calling_convention {
+            CallingConvention::SystemV | CallingConvention::AppleAarch64 => {
+                let unwind = self.machine.gen_dwarf_unwind_info(body_len);
+                if let Some(unwind) = unwind {
+                    fde = Some(unwind.to_fde(Address::Symbol {
+                        symbol: WriterRelocate::FUNCTION_SYMBOL,
+                        addend: self.fsm.local_function_id as _,
+                    }));
+                    unwind_info = Some(CompiledFunctionUnwindInfo::Dwarf);
+                }
+            }
+            CallingConvention::WindowsFastcall => {
+                let unwind = self.machine.gen_windows_unwind_info(body_len);
+                if let Some(unwind) = unwind {
+                    unwind_info = Some(CompiledFunctionUnwindInfo::WindowsX64(unwind));
+                }
+            }
+            _ => (),
+        };
+
+        let address_map =
+            get_function_address_map(self.machine.instructions_address_map(), data, body_len);
+        let traps = self.machine.collect_trap_information();
+        let mut body = self.machine.assembler_finalize()?;
+        body.shrink_to_fit();
+
+        Ok((
+            CompiledFunction {
+                body: FunctionBody { body, unwind_info },
+                relocations: self.relocations.clone(),
+                frame_info: CompiledFunctionFrameInfo { traps, address_map },
+            },
+            fde,
+        ))
+    }
+    // FIXME: This implementation seems to be not enough to resolve all kinds of register dependencies
+    // at call place.
+    #[allow(clippy::type_complexity)]
+    fn sort_call_movs(movs: &mut [(Location<M::GPR, M::SIMD>, M::GPR)]) {
+        for i in 0..movs.len() {
+            for j in (i + 1)..movs.len() {
+                if let Location::GPR(src_gpr) = movs[j].0 {
+                    if src_gpr == movs[i].1 {
+                        movs.swap(i, j);
+                    }
+                }
+            }
+        }
+    }
+
+    // Cycle detector. Uncomment this to debug possibly incorrect call-mov sequences.
+    /*
+    {
+        use std::collections::{HashMap, HashSet, VecDeque};
+        let mut mov_map: HashMap<GPR, HashSet<GPR>> = HashMap::new();
+        for mov in movs.iter() {
+            if let Location::GPR(src_gpr) = mov.0 {
+                if src_gpr != mov.1 {
+                    mov_map.entry(src_gpr).or_insert_with(|| HashSet::new()).insert(mov.1);
+                }
+            }
+        }
+
+        for (start, _) in mov_map.iter() {
+            let mut q: VecDeque<GPR> = VecDeque::new();
+            let mut black: HashSet<GPR> = HashSet::new();
+
+            q.push_back(*start);
+            black.insert(*start);
+
+            while q.len() > 0 {
+                let reg = q.pop_front().unwrap();
+                let empty_set = HashSet::new();
+                for x in mov_map.get(&reg).unwrap_or(&empty_set).iter() {
+                    if black.contains(x) {
+                        panic!("cycle detected");
+                    }
+                    q.push_back(*x);
+                    black.insert(*x);
+                }
+            }
+        }
+    }
+    */
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/common_decl.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/common_decl.rs
new file mode 100644
index 0000000..9d48cf6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/common_decl.rs
@@ -0,0 +1,263 @@
+use std::collections::BTreeMap;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub struct RegisterIndex(pub usize);
+
+/// Whether a value is determined at compile-time or run-time.
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum WasmAbstractValue {
+    /// This value is only known at runtime.
+    Runtime,
+    /// A constant value.
+    Const(u64),
+}
+
+/// A container for the state of a running wasm instance.
+#[derive(Clone, Debug)]
+pub struct MachineState {
+    /// Stack values.
+    pub stack_values: Vec<MachineValue>,
+    /// Register values.
+    pub register_values: Vec<MachineValue>,
+    /// Previous frame.
+    pub prev_frame: BTreeMap<usize, MachineValue>,
+    /// Wasm stack.
+    pub wasm_stack: Vec<WasmAbstractValue>,
+    /// Wasm instruction offset.
+    pub wasm_inst_offset: usize,
+}
+
+/// A diff of two `MachineState`s.
+///
+/// A `MachineStateDiff` can only be applied after the `MachineStateDiff` its `last` field
+/// points to is already applied.
+#[derive(Clone, Debug, Default)]
+pub struct MachineStateDiff {
+    /// Link to the previous diff this diff is based on, or `None` if this is the first diff.
+    pub last: Option<usize>,
+
+    /// What values are pushed onto the stack?
+    pub stack_push: Vec<MachineValue>,
+
+    /// How many values are popped from the stack?
+    pub stack_pop: usize,
+
+    /// Register diff.
+    pub reg_diff: Vec<(RegisterIndex, MachineValue)>,
+
+    /// Changes in the previous frame's data.
+    pub prev_frame_diff: BTreeMap<usize, Option<MachineValue>>, // None for removal
+
+    /// Values pushed to the Wasm stack.
+    pub wasm_stack_push: Vec<WasmAbstractValue>,
+
+    /// # of values popped from the Wasm stack.
+    pub wasm_stack_pop: usize,
+
+    /// Wasm instruction offset.
+    pub wasm_inst_offset: usize, // absolute value; not a diff.
+}
+
+/// A kind of machine value.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MachineValue {
+    /// Undefined.
+    Undefined,
+    /// Vmctx.
+    Vmctx,
+    /// Vmctx Deref.
+    _VmctxDeref(Vec<usize>),
+    /// Preserve Register.
+    PreserveRegister(RegisterIndex),
+    /// Copy Stack BP Relative.
+    CopyStackBPRelative(i32), // relative to Base Pointer, in byte offset
+    /// Explicit Shadow.
+    ExplicitShadow, // indicates that all values above this are above the shadow region
+    /// Wasm Stack.
+    WasmStack(usize),
+    /// Wasm Local.
+    WasmLocal(usize),
+    /// Two Halves.
+    _TwoHalves(Box<(MachineValue, MachineValue)>), // 32-bit values. TODO: optimize: add another type for inner "half" value to avoid boxing?
+}
+
+/// A map of function states.
+#[derive(Clone, Debug)]
+pub struct FunctionStateMap {
+    /// Initial.
+    pub initial: MachineState,
+    /// Local Function Id.
+    pub local_function_id: usize,
+    /// Locals.
+    pub locals: Vec<WasmAbstractValue>,
+    /// Shadow size.
+    pub shadow_size: usize, // for single-pass backend, 32 bytes on x86-64
+    /// Diffs.
+    pub diffs: Vec<MachineStateDiff>,
+    /// Wasm Function Header target offset.
+    pub wasm_function_header_target_offset: Option<SuspendOffset>,
+    /// Wasm offset to target offset
+    pub wasm_offset_to_target_offset: BTreeMap<usize, SuspendOffset>,
+    /// Loop offsets.
+    pub loop_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
+    /// Call offsets.
+    pub call_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
+    /// Trappable offsets.
+    pub trappable_offsets: BTreeMap<usize, OffsetInfo>, /* suspend_offset -> info */
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub enum Size {
+    S8,
+    S16,
+    S32,
+    S64,
+}
+
+/// A kind of suspend offset.
+#[derive(Clone, Copy, Debug)]
+pub enum SuspendOffset {
+    /// A loop.
+    _Loop(usize),
+    /// A call.
+    Call(usize),
+    /// A trappable.
+    Trappable(usize),
+}
+
+/// Description of a machine code range following an offset.
+#[derive(Clone, Debug)]
+pub struct OffsetInfo {
+    /// Exclusive range-end offset.
+    pub end_offset: usize,
+    /// Index pointing to the `MachineStateDiff` entry.
+    pub diff_id: usize,
+    /// Offset at which execution can be continued.
+    pub activate_offset: usize,
+}
+
+impl FunctionStateMap {
+    /// Creates a new `FunctionStateMap` with the given parameters.
+    pub fn new(
+        initial: MachineState,
+        local_function_id: usize,
+        shadow_size: usize,
+        locals: Vec<WasmAbstractValue>,
+    ) -> FunctionStateMap {
+        FunctionStateMap {
+            initial,
+            local_function_id,
+            shadow_size,
+            locals,
+            diffs: vec![],
+            wasm_function_header_target_offset: None,
+            wasm_offset_to_target_offset: BTreeMap::new(),
+            loop_offsets: BTreeMap::new(),
+            call_offsets: BTreeMap::new(),
+            trappable_offsets: BTreeMap::new(),
+        }
+    }
+}
+
+impl MachineState {
+    /// Creates a `MachineStateDiff` from self and the given `&MachineState`.
+    pub fn diff(&self, old: &MachineState) -> MachineStateDiff {
+        let first_diff_stack_depth: usize = self
+            .stack_values
+            .iter()
+            .zip(old.stack_values.iter())
+            .enumerate()
+            .find(|&(_, (a, b))| a != b)
+            .map(|x| x.0)
+            .unwrap_or_else(|| old.stack_values.len().min(self.stack_values.len()));
+        assert_eq!(self.register_values.len(), old.register_values.len());
+        let reg_diff: Vec<_> = self
+            .register_values
+            .iter()
+            .zip(old.register_values.iter())
+            .enumerate()
+            .filter(|&(_, (a, b))| a != b)
+            .map(|(i, (a, _))| (RegisterIndex(i), a.clone()))
+            .collect();
+        let prev_frame_diff: BTreeMap<usize, Option<MachineValue>> = self
+            .prev_frame
+            .iter()
+            .filter(|(k, v)| {
+                if let Some(ref old_v) = old.prev_frame.get(k) {
+                    v != old_v
+                } else {
+                    true
+                }
+            })
+            .map(|(&k, v)| (k, Some(v.clone())))
+            .chain(
+                old.prev_frame
+                    .iter()
+                    .filter(|(k, _)| self.prev_frame.get(k).is_none())
+                    .map(|(&k, _)| (k, None)),
+            )
+            .collect();
+        let first_diff_wasm_stack_depth: usize = self
+            .wasm_stack
+            .iter()
+            .zip(old.wasm_stack.iter())
+            .enumerate()
+            .find(|&(_, (a, b))| a != b)
+            .map(|x| x.0)
+            .unwrap_or_else(|| old.wasm_stack.len().min(self.wasm_stack.len()));
+        MachineStateDiff {
+            last: None,
+            stack_push: self.stack_values[first_diff_stack_depth..].to_vec(),
+            stack_pop: old.stack_values.len() - first_diff_stack_depth,
+            reg_diff,
+
+            prev_frame_diff,
+
+            wasm_stack_push: self.wasm_stack[first_diff_wasm_stack_depth..].to_vec(),
+            wasm_stack_pop: old.wasm_stack.len() - first_diff_wasm_stack_depth,
+
+            wasm_inst_offset: self.wasm_inst_offset,
+        }
+    }
+}
+
+impl MachineStateDiff {
+    /// Creates a `MachineState` from the given `&FunctionStateMap`.
+    pub fn _build_state(&self, m: &FunctionStateMap) -> MachineState {
+        let mut chain: Vec<&MachineStateDiff> = vec![self];
+        let mut current = self.last;
+        while let Some(x) = current {
+            let that = &m.diffs[x];
+            current = that.last;
+            chain.push(that);
+        }
+        chain.reverse();
+        let mut state = m.initial.clone();
+        for x in chain {
+            for _ in 0..x.stack_pop {
+                state.stack_values.pop().unwrap();
+            }
+            for v in &x.stack_push {
+                state.stack_values.push(v.clone());
+            }
+            for &(index, ref v) in &x.reg_diff {
+                state.register_values[index.0] = v.clone();
+            }
+            for (index, ref v) in &x.prev_frame_diff {
+                if let Some(ref x) = v {
+                    state.prev_frame.insert(*index, x.clone());
+                } else {
+                    state.prev_frame.remove(index).unwrap();
+                }
+            }
+            for _ in 0..x.wasm_stack_pop {
+                state.wasm_stack.pop().unwrap();
+            }
+            for v in &x.wasm_stack_push {
+                state.wasm_stack.push(*v);
+            }
+        }
+        state.wasm_inst_offset = self.wasm_inst_offset;
+        state
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/compiler.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/compiler.rs
new file mode 100644
index 0000000..5e723a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/compiler.rs
@@ -0,0 +1,356 @@
+//! Support for compiling with Singlepass.
+// Allow unused imports while developing.
+#![allow(unused_imports, dead_code)]
+
+use crate::codegen::FuncGen;
+use crate::config::Singlepass;
+#[cfg(feature = "unwind")]
+use crate::dwarf::WriterRelocate;
+use crate::machine::Machine;
+use crate::machine::{
+    gen_import_call_trampoline, gen_std_dynamic_import_trampoline, gen_std_trampoline,
+};
+use crate::machine_arm64::MachineARM64;
+use crate::machine_x64::MachineX86_64;
+#[cfg(feature = "unwind")]
+use crate::unwind::{create_systemv_cie, UnwindFrame};
+use enumset::EnumSet;
+#[cfg(feature = "unwind")]
+use gimli::write::{EhFrame, FrameTable};
+#[cfg(feature = "rayon")]
+use rayon::prelude::{IntoParallelIterator, ParallelIterator};
+use std::sync::Arc;
+use wasmer_compiler::{
+    Compiler, CompilerConfig, FunctionBinaryReader, FunctionBodyData, MiddlewareBinaryReader,
+    ModuleMiddleware, ModuleMiddlewareChain, ModuleTranslationState,
+};
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{
+    Architecture, CallingConvention, Compilation, CompileError, CompileModuleInfo,
+    CompiledFunction, CpuFeature, Dwarf, FunctionBody, FunctionIndex, FunctionType,
+    LocalFunctionIndex, MemoryIndex, ModuleInfo, OperatingSystem, SectionIndex, TableIndex, Target,
+    TrapCode, TrapInformation, VMOffsets,
+};
+
+/// A compiler that compiles a WebAssembly module with Singlepass.
+/// It does the compilation in one pass
+pub struct SinglepassCompiler {
+    config: Singlepass,
+}
+
+impl SinglepassCompiler {
+    /// Creates a new Singlepass compiler
+    pub fn new(config: Singlepass) -> Self {
+        Self { config }
+    }
+
+    /// Gets the config for this Compiler
+    fn config(&self) -> &Singlepass {
+        &self.config
+    }
+}
+
+impl Compiler for SinglepassCompiler {
+    fn name(&self) -> &str {
+        "singlepass"
+    }
+
+    /// Get the middlewares for this compiler
+    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>] {
+        &self.config.middlewares
+    }
+
+    /// Compile the module using Singlepass, producing a compilation result with
+    /// associated relocations.
+    fn compile_module(
+        &self,
+        target: &Target,
+        compile_info: &CompileModuleInfo,
+        _module_translation: &ModuleTranslationState,
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+    ) -> Result<Compilation, CompileError> {
+        match target.triple().architecture {
+            Architecture::X86_64 => {}
+            Architecture::Aarch64(_) => {}
+            _ => {
+                return Err(CompileError::UnsupportedTarget(
+                    target.triple().architecture.to_string(),
+                ))
+            }
+        }
+
+        let calling_convention = match target.triple().default_calling_convention() {
+            Ok(CallingConvention::WindowsFastcall) => CallingConvention::WindowsFastcall,
+            Ok(CallingConvention::SystemV) => CallingConvention::SystemV,
+            Ok(CallingConvention::AppleAarch64) => CallingConvention::AppleAarch64,
+            _ => {
+                return Err(CompileError::UnsupportedTarget(
+                    "Unsupported Calling convention for Singlepass compiler".to_string(),
+                ))
+            }
+        };
+
+        // Generate the frametable
+        #[cfg(feature = "unwind")]
+        let dwarf_frametable = if function_body_inputs.is_empty() {
+            // If we have no function body inputs, we don't need to
+            // construct the `FrameTable`. Constructing it, with empty
+            // FDEs will cause some issues in Linux.
+            None
+        } else {
+            match target.triple().default_calling_convention() {
+                Ok(CallingConvention::SystemV) => {
+                    match create_systemv_cie(target.triple().architecture) {
+                        Some(cie) => {
+                            let mut dwarf_frametable = FrameTable::default();
+                            let cie_id = dwarf_frametable.add_cie(cie);
+                            Some((dwarf_frametable, cie_id))
+                        }
+                        None => None,
+                    }
+                }
+                _ => None,
+            }
+        };
+
+        let memory_styles = &compile_info.memory_styles;
+        let table_styles = &compile_info.table_styles;
+        let vmoffsets = VMOffsets::new(8, &compile_info.module);
+        let module = &compile_info.module;
+        let mut custom_sections: PrimaryMap<SectionIndex, _> = (0..module.num_imported_functions)
+            .map(FunctionIndex::new)
+            .collect::<Vec<_>>()
+            .into_par_iter_if_rayon()
+            .map(|i| {
+                gen_import_call_trampoline(
+                    &vmoffsets,
+                    i,
+                    &module.signatures[module.functions[i]],
+                    target,
+                    calling_convention,
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+            .collect();
+        let (functions, fdes): (Vec<CompiledFunction>, Vec<_>) = function_body_inputs
+            .iter()
+            .collect::<Vec<(LocalFunctionIndex, &FunctionBodyData<'_>)>>()
+            .into_par_iter_if_rayon()
+            .map(|(i, input)| {
+                let middleware_chain = self
+                    .config
+                    .middlewares
+                    .generate_function_middleware_chain(i);
+                let mut reader =
+                    MiddlewareBinaryReader::new_with_offset(input.data, input.module_offset);
+                reader.set_middleware_chain(middleware_chain);
+
+                // This local list excludes arguments.
+                let mut locals = vec![];
+                let num_locals = reader.read_local_count()?;
+                for _ in 0..num_locals {
+                    let (count, ty) = reader.read_local_decl()?;
+                    for _ in 0..count {
+                        locals.push(ty);
+                    }
+                }
+
+                match target.triple().architecture {
+                    Architecture::X86_64 => {
+                        let machine = MachineX86_64::new(Some(target.clone()))?;
+                        let mut generator = FuncGen::new(
+                            module,
+                            &self.config,
+                            &vmoffsets,
+                            memory_styles,
+                            table_styles,
+                            i,
+                            &locals,
+                            machine,
+                            calling_convention,
+                        )?;
+                        while generator.has_control_frames() {
+                            generator.set_srcloc(reader.original_position() as u32);
+                            let op = reader.read_operator()?;
+                            generator.feed_operator(op)?;
+                        }
+
+                        generator.finalize(input)
+                    }
+                    Architecture::Aarch64(_) => {
+                        let machine = MachineARM64::new(Some(target.clone()));
+                        let mut generator = FuncGen::new(
+                            module,
+                            &self.config,
+                            &vmoffsets,
+                            memory_styles,
+                            table_styles,
+                            i,
+                            &locals,
+                            machine,
+                            calling_convention,
+                        )?;
+                        while generator.has_control_frames() {
+                            generator.set_srcloc(reader.original_position() as u32);
+                            let op = reader.read_operator()?;
+                            generator.feed_operator(op)?;
+                        }
+
+                        generator.finalize(input)
+                    }
+                    _ => unimplemented!(),
+                }
+            })
+            .collect::<Result<Vec<_>, CompileError>>()?
+            .into_iter()
+            .unzip();
+
+        let function_call_trampolines = module
+            .signatures
+            .values()
+            .collect::<Vec<_>>()
+            .into_par_iter_if_rayon()
+            .map(|func_type| gen_std_trampoline(func_type, target, calling_convention).unwrap())
+            .collect::<Vec<_>>()
+            .into_iter()
+            .collect::<PrimaryMap<_, _>>();
+
+        let dynamic_function_trampolines = module
+            .imported_function_types()
+            .collect::<Vec<_>>()
+            .into_par_iter_if_rayon()
+            .map(|func_type| {
+                gen_std_dynamic_import_trampoline(
+                    &vmoffsets,
+                    &func_type,
+                    target,
+                    calling_convention,
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+            .collect::<PrimaryMap<FunctionIndex, FunctionBody>>();
+
+        #[cfg(feature = "unwind")]
+        let dwarf = if let Some((mut dwarf_frametable, cie_id)) = dwarf_frametable {
+            for fde in fdes.into_iter().flatten() {
+                match fde {
+                    UnwindFrame::SystemV(fde) => dwarf_frametable.add_fde(cie_id, fde),
+                }
+            }
+            let mut eh_frame = EhFrame(WriterRelocate::new(target.triple().endianness().ok()));
+            dwarf_frametable.write_eh_frame(&mut eh_frame).unwrap();
+
+            let eh_frame_section = eh_frame.0.into_section();
+            custom_sections.push(eh_frame_section);
+            Some(Dwarf::new(SectionIndex::new(custom_sections.len() - 1)))
+        } else {
+            None
+        };
+        #[cfg(not(feature = "unwind"))]
+        let dwarf = None;
+
+        Ok(Compilation {
+            functions: functions.into_iter().collect(),
+            custom_sections,
+            function_call_trampolines,
+            dynamic_function_trampolines,
+            debug: dwarf,
+        })
+    }
+
+    fn get_cpu_features_used(&self, cpu_features: &EnumSet<CpuFeature>) -> EnumSet<CpuFeature> {
+        let used = CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1;
+        cpu_features.intersection(used)
+    }
+}
+
+trait IntoParIterIfRayon {
+    type Output;
+    fn into_par_iter_if_rayon(self) -> Self::Output;
+}
+
+impl<T: Send> IntoParIterIfRayon for Vec<T> {
+    #[cfg(not(feature = "rayon"))]
+    type Output = std::vec::IntoIter<T>;
+    #[cfg(feature = "rayon")]
+    type Output = rayon::vec::IntoIter<T>;
+
+    fn into_par_iter_if_rayon(self) -> Self::Output {
+        #[cfg(not(feature = "rayon"))]
+        return self.into_iter();
+        #[cfg(feature = "rayon")]
+        return self.into_par_iter();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+    use target_lexicon::triple;
+    use wasmer_compiler::Features;
+    use wasmer_types::{CpuFeature, MemoryStyle, TableStyle, Triple};
+
+    fn dummy_compilation_ingredients<'a>() -> (
+        CompileModuleInfo,
+        ModuleTranslationState,
+        PrimaryMap<LocalFunctionIndex, FunctionBodyData<'a>>,
+    ) {
+        let compile_info = CompileModuleInfo {
+            features: Features::new(),
+            module: Arc::new(ModuleInfo::new()),
+            memory_styles: PrimaryMap::<MemoryIndex, MemoryStyle>::new(),
+            table_styles: PrimaryMap::<TableIndex, TableStyle>::new(),
+        };
+        let module_translation = ModuleTranslationState::new();
+        let function_body_inputs = PrimaryMap::<LocalFunctionIndex, FunctionBodyData<'_>>::new();
+        (compile_info, module_translation, function_body_inputs)
+    }
+
+    #[test]
+    fn errors_for_unsupported_targets() {
+        let compiler = SinglepassCompiler::new(Singlepass::default());
+
+        // Compile for 32bit Linux
+        let linux32 = Target::new(triple!("i686-unknown-linux-gnu"), CpuFeature::for_host());
+        let (mut info, translation, inputs) = dummy_compilation_ingredients();
+        let result = compiler.compile_module(&linux32, &mut info, &translation, inputs);
+        match result.unwrap_err() {
+            CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"),
+            error => panic!("Unexpected error: {:?}", error),
+        };
+
+        // Compile for win32
+        let win32 = Target::new(triple!("i686-pc-windows-gnu"), CpuFeature::for_host());
+        let (mut info, translation, inputs) = dummy_compilation_ingredients();
+        let result = compiler.compile_module(&win32, &mut info, &translation, inputs);
+        match result.unwrap_err() {
+            CompileError::UnsupportedTarget(name) => assert_eq!(name, "i686"), // Windows should be checked before architecture
+            error => panic!("Unexpected error: {:?}", error),
+        };
+    }
+
+    #[test]
+    fn errors_for_unsuported_cpufeatures() {
+        let compiler = SinglepassCompiler::new(Singlepass::default());
+        let mut features =
+            CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1;
+        // simple test
+        assert!(compiler
+            .get_cpu_features_used(&features)
+            .is_subset(CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+        // check that an AVX build don't work on SSE4.2 only host
+        assert!(!compiler
+            .get_cpu_features_used(&features)
+            .is_subset(CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+        // check that having a host with AVX512 doesn't change anything
+        features.insert_all(CpuFeature::AVX512DQ | CpuFeature::AVX512F);
+        assert!(compiler
+            .get_cpu_features_used(&features)
+            .is_subset(CpuFeature::AVX | CpuFeature::SSE42 | CpuFeature::LZCNT | CpuFeature::BMI1));
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/config.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/config.rs
new file mode 100644
index 0000000..ea01ebb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/config.rs
@@ -0,0 +1,66 @@
+// Allow unused imports while developing
+#![allow(unused_imports, dead_code)]
+
+use crate::compiler::SinglepassCompiler;
+use std::sync::Arc;
+use wasmer_compiler::{Compiler, CompilerConfig, Engine, EngineBuilder, ModuleMiddleware};
+use wasmer_types::{CpuFeature, Features, Target};
+
+#[derive(Debug, Clone)]
+pub struct Singlepass {
+    pub(crate) enable_nan_canonicalization: bool,
+    /// The middleware chain.
+    pub(crate) middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+}
+
+impl Singlepass {
+    /// Creates a new configuration object with the default configuration
+    /// specified.
+    pub fn new() -> Self {
+        Self {
+            enable_nan_canonicalization: true,
+            middlewares: vec![],
+        }
+    }
+
+    pub fn canonicalize_nans(&mut self, enable: bool) -> &mut Self {
+        self.enable_nan_canonicalization = enable;
+        self
+    }
+}
+
+impl CompilerConfig for Singlepass {
+    fn enable_pic(&mut self) {
+        // Do nothing, since singlepass already emits
+        // PIC code.
+    }
+
+    /// Transform it into the compiler
+    fn compiler(self: Box<Self>) -> Box<dyn Compiler> {
+        Box::new(SinglepassCompiler::new(*self))
+    }
+
+    /// Gets the default features for this compiler in the given target
+    fn default_features_for_target(&self, _target: &Target) -> Features {
+        let mut features = Features::default();
+        features.multi_value(false);
+        features
+    }
+
+    /// Pushes a middleware onto the back of the middleware chain.
+    fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>) {
+        self.middlewares.push(middleware);
+    }
+}
+
+impl Default for Singlepass {
+    fn default() -> Singlepass {
+        Self::new()
+    }
+}
+
+impl From<Singlepass> for Engine {
+    fn from(config: Singlepass) -> Self {
+        EngineBuilder::new(config).engine()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/dwarf.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/dwarf.rs
new file mode 100644
index 0000000..815787b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/dwarf.rs
@@ -0,0 +1,103 @@
+use gimli::write::{Address, EndianVec, Result, Writer};
+use gimli::{RunTimeEndian, SectionId};
+use wasmer_types::entity::EntityRef;
+use wasmer_types::{
+    CustomSection, CustomSectionProtection, Endianness, LocalFunctionIndex, Relocation,
+    RelocationKind, RelocationTarget, SectionBody,
+};
+
+#[derive(Clone, Debug)]
+pub struct WriterRelocate {
+    pub relocs: Vec<Relocation>,
+    writer: EndianVec<RunTimeEndian>,
+}
+
+impl WriterRelocate {
+    pub const FUNCTION_SYMBOL: usize = 0;
+    pub fn new(endianness: Option<Endianness>) -> Self {
+        let endianness = match endianness {
+            Some(Endianness::Little) => RunTimeEndian::Little,
+            Some(Endianness::Big) => RunTimeEndian::Big,
+            // We autodetect it, based on the host
+            None => RunTimeEndian::default(),
+        };
+        WriterRelocate {
+            relocs: Vec::new(),
+            writer: EndianVec::new(endianness),
+        }
+    }
+
+    pub fn into_section(mut self) -> CustomSection {
+        // GCC expects a terminating "empty" length, so write a 0 length at the end of the table.
+        self.writer.write_u32(0).unwrap();
+        let data = self.writer.into_vec();
+        CustomSection {
+            protection: CustomSectionProtection::Read,
+            bytes: SectionBody::new_with_vec(data),
+            relocations: self.relocs,
+        }
+    }
+}
+
+impl Writer for WriterRelocate {
+    type Endian = RunTimeEndian;
+
+    fn endian(&self) -> Self::Endian {
+        self.writer.endian()
+    }
+
+    fn len(&self) -> usize {
+        self.writer.len()
+    }
+
+    fn write(&mut self, bytes: &[u8]) -> Result<()> {
+        self.writer.write(bytes)
+    }
+
+    fn write_at(&mut self, offset: usize, bytes: &[u8]) -> Result<()> {
+        self.writer.write_at(offset, bytes)
+    }
+
+    fn write_address(&mut self, address: Address, size: u8) -> Result<()> {
+        match address {
+            Address::Constant(val) => self.write_udata(val, size),
+            Address::Symbol { symbol, addend } => {
+                // Is a function relocation
+                if symbol == Self::FUNCTION_SYMBOL {
+                    // We use the addend to detect the function index
+                    let function_index = LocalFunctionIndex::new(addend as _);
+                    let reloc_target = RelocationTarget::LocalFunc(function_index);
+                    let offset = self.len() as u32;
+                    let kind = match size {
+                        8 => RelocationKind::Abs8,
+                        _ => unimplemented!("dwarf relocation size not yet supported: {}", size),
+                    };
+                    let addend = 0;
+                    self.relocs.push(Relocation {
+                        kind,
+                        reloc_target,
+                        offset,
+                        addend,
+                    });
+                    self.write_udata(addend as u64, size)
+                } else {
+                    unreachable!("Symbol {} in DWARF not recognized", symbol);
+                }
+            }
+        }
+    }
+
+    fn write_offset(&mut self, _val: usize, _section: SectionId, _size: u8) -> Result<()> {
+        unimplemented!("write_offset not yet implemented");
+    }
+
+    fn write_offset_at(
+        &mut self,
+        _offset: usize,
+        _val: usize,
+        _section: SectionId,
+        _size: u8,
+    ) -> Result<()> {
+        unimplemented!("write_offset_at not yet implemented");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_arm64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_arm64.rs
new file mode 100644
index 0000000..aa7d7c9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_arm64.rs
@@ -0,0 +1,3740 @@
+pub use crate::arm64_decl::{ARM64Register, ArgumentRegisterAllocator, GPR, NEON};
+use crate::codegen_error;
+use crate::common_decl::Size;
+use crate::location::Location as AbstractLocation;
+pub use crate::location::{Multiplier, Reg};
+pub use crate::machine::{Label, Offset};
+use dynasm::dynasm;
+pub use dynasmrt::aarch64::{encode_logical_immediate_32bit, encode_logical_immediate_64bit};
+use dynasmrt::{
+    aarch64::Aarch64Relocation, AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi,
+    VecAssembler,
+};
+use wasmer_types::{
+    CallingConvention, CompileError, CustomSection, CustomSectionProtection, FunctionBody,
+    FunctionIndex, FunctionType, SectionBody, Type, VMOffsets,
+};
+
+type Assembler = VecAssembler<Aarch64Relocation>;
+
+/// Force `dynasm!` to use the correct arch (aarch64) when cross-compiling.
+/// `dynasm!` proc-macro tries to auto-detect it by default by looking at the
+/// `target_arch`, but it sees the `target_arch` of the proc-macro itself, which
+/// is always equal to host, even when cross-compiling.
+macro_rules! dynasm {
+    ($a:expr ; $($tt:tt)*) => {
+        dynasm::dynasm!(
+            $a
+            ; .arch aarch64
+            ; $($tt)*
+        )
+    };
+}
+
+pub type Location = AbstractLocation<GPR, NEON>;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[allow(dead_code)]
+#[repr(u8)]
+pub enum Condition {
+    // meaning for cmp or sub
+    /// Equal
+    Eq = 0,
+    /// Not equal
+    Ne = 1,
+    /// Unsigned higher or same (or carry set)
+    Cs = 2,
+    /// Unsigned lower (or carry clear)
+    Cc = 3,
+    /// Negative. The mnemonic stands for "minus"
+    Mi = 4,
+    /// Positive or zero. The mnemonic stands for "plus"
+    Pl = 5,
+    /// Signed overflow. The mnemonic stands for "V set"
+    Vs = 6,
+    /// No signed overflow. The mnemonic stands for "V clear"
+    Vc = 7,
+    /// Unsigned higher
+    Hi = 8,
+    /// Unsigned lower or same
+    Ls = 9,
+    /// Signed greater than or equal
+    Ge = 10,
+    /// Signed less than
+    Lt = 11,
+    /// Signed greater than
+    Gt = 12,
+    /// Signed less than or equal
+    Le = 13,
+    /// Always executed
+    Al = 14,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[allow(dead_code, clippy::upper_case_acronyms)]
+pub enum NeonOrMemory {
+    NEON(NEON),
+    Memory(GPR, i32),
+}
+
+#[derive(Copy, Clone, Debug)]
+#[allow(dead_code, clippy::upper_case_acronyms)]
+pub enum GPROrMemory {
+    GPR(GPR),
+    Memory(GPR, i32),
+}
+
+pub trait EmitterARM64 {
+    fn get_label(&mut self) -> Label;
+    fn get_offset(&self) -> Offset;
+    fn get_jmp_instr_size(&self) -> u8;
+
+    fn finalize_function(&mut self);
+
+    fn emit_str(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError>;
+    fn emit_ldr(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError>;
+    fn emit_stur(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: i32,
+    ) -> Result<(), CompileError>;
+    fn emit_ldur(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: i32,
+    ) -> Result<(), CompileError>;
+    fn emit_strdb(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError>;
+    fn emit_stria(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError>;
+    fn emit_ldria(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError>;
+    fn emit_stpdb(
+        &mut self,
+        sz: Size,
+        reg1: Location,
+        reg2: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError>;
+    fn emit_ldpia(
+        &mut self,
+        sz: Size,
+        reg1: Location,
+        reg2: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError>;
+
+    fn emit_ldrb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldrh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldrsb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldrsh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldrsw(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_strb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_strh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_ldaxr(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldaxrb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ldaxrh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_stlxr(
+        &mut self,
+        sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_stlxrb(
+        &mut self,
+        sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_stlxrh(
+        &mut self,
+        sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_movn(&mut self, sz: Size, reg: Location, val: u32) -> Result<(), CompileError>;
+    fn emit_movz(&mut self, reg: Location, val: u32) -> Result<(), CompileError>;
+    fn emit_movk(&mut self, reg: Location, val: u32, shift: u32) -> Result<(), CompileError>;
+
+    fn emit_mov_imm(&mut self, dst: Location, val: u64) -> Result<(), CompileError>;
+
+    fn emit_add(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_mul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_adds(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_subs(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_add_lsl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        lsl: u32,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_cmp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_tst(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_lsl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_lsr(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_asr(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_ror(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_or(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_and(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_eor(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_bfc(
+        &mut self,
+        se: Size,
+        lsb: u32,
+        width: u32,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_bfi(
+        &mut self,
+        se: Size,
+        src: Location,
+        lsb: u32,
+        width: u32,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_udiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_sdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    /// msub : c - a*b -> dst
+    fn emit_msub(
+        &mut self,
+        sz: Size,
+        a: Location,
+        b: Location,
+        c: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_sxtb(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_sxth(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_sxtw(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_uxtb(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_uxth(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_cset(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError>;
+    fn emit_csetm(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError>;
+    fn emit_cinc(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+        cond: Condition,
+    ) -> Result<(), CompileError>;
+    fn emit_clz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_rbit(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError>;
+    fn emit_b_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_cbz_label(&mut self, sz: Size, reg: Location, label: Label)
+        -> Result<(), CompileError>;
+    fn emit_cbnz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        label: Label,
+    ) -> Result<(), CompileError>;
+    fn emit_tbz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        n: u32,
+        label: Label,
+    ) -> Result<(), CompileError>;
+    fn emit_tbnz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        n: u32,
+        label: Label,
+    ) -> Result<(), CompileError>;
+    fn emit_bcond_label(&mut self, condition: Condition, label: Label) -> Result<(), CompileError>;
+    fn emit_bcond_label_far(
+        &mut self,
+        condition: Condition,
+        label: Label,
+    ) -> Result<(), CompileError>;
+    fn emit_b_register(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_ret(&mut self) -> Result<(), CompileError>;
+
+    fn emit_udf(&mut self, payload: u16) -> Result<(), CompileError>;
+    fn emit_dmb(&mut self) -> Result<(), CompileError>;
+    fn emit_brk(&mut self) -> Result<(), CompileError>;
+
+    fn emit_fcmp(&mut self, sz: Size, src1: Location, src2: Location) -> Result<(), CompileError>;
+    fn emit_fneg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_fsqrt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_fadd(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fsub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fmul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_fmin(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fmax(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_frintz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_frintn(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_frintm(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_frintp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+
+    fn emit_scvtf(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_ucvtf(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fcvt(&mut self, sz_in: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_fcvtzs(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_fcvtzu(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+
+    fn emit_fmov(
+        &mut self,
+        src_size: Size,
+        src: Location,
+        dst_size: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_cnt(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError>;
+    fn emit_addv(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError>;
+    fn emit_read_fpcr(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_write_fpcr(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_read_fpsr(&mut self, reg: GPR) -> Result<(), CompileError>;
+    fn emit_write_fpsr(&mut self, reg: GPR) -> Result<(), CompileError>;
+
+    fn arch_supports_canonicalize_nan(&self) -> bool {
+        true
+    }
+
+    fn arch_requires_indirect_call_trampoline(&self) -> bool {
+        false
+    }
+
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        _loc: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_indirect_call_with_trampoline unimplemented")
+    }
+}
+
+impl EmitterARM64 for Assembler {
+    fn get_label(&mut self) -> DynamicLabel {
+        self.new_dynamic_label()
+    }
+
+    fn get_offset(&self) -> AssemblyOffset {
+        self.offset()
+    }
+
+    fn get_jmp_instr_size(&self) -> u8 {
+        4 // relative jump, not full 32bits capable
+    }
+
+    fn finalize_function(&mut self) {
+        dynasm!(
+            self
+            ; const_neg_one_32:
+            ; .word -1
+            ; const_zero_32:
+            ; .word 0
+            ; const_pos_one_32:
+            ; .word 1
+        );
+    }
+
+    fn emit_str(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError> {
+        match (sz, reg, addr) {
+            (Size::S64, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x7) == 0 && (disp < 0x8000));
+                dynasm!(self ; str X(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x3) == 0 && (disp < 0x4000));
+                dynasm!(self ; str W(reg), [X(addr), disp]);
+            }
+            (Size::S16, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x1) == 0 && (disp < 0x2000));
+                dynasm!(self ; strh W(reg), [X(addr), disp]);
+            }
+            (Size::S8, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!(disp < 0x1000);
+                dynasm!(self ; strb W(reg), [X(addr), disp]);
+            }
+            (Size::S64, Location::SIMD(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x7) == 0 && (disp < 0x8000));
+                dynasm!(self ; str D(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::SIMD(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x3) == 0 && (disp < 0x4000));
+                dynasm!(self ; str S(reg), [X(addr), disp]);
+            }
+            (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; str X(reg), [X(addr)]),
+                    1 => dynasm!(self ; str X(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; str X(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; str W(reg), [X(addr)]),
+                    1 => dynasm!(self ; str W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; str W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit STR {:?}, {:?}, {:?}", sz, reg, addr),
+        }
+        Ok(())
+    }
+    fn emit_ldr(&mut self, sz: Size, reg: Location, addr: Location) -> Result<(), CompileError> {
+        match (sz, reg, addr) {
+            (Size::S64, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                assert!((disp & 0x7) == 0 && (disp < 0x8000));
+                let disp = disp as u32;
+                dynasm!(self ; ldr X(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                assert!((disp & 0x3) == 0 && (disp < 0x4000));
+                let disp = disp as u32;
+                dynasm!(self ; ldr W(reg), [X(addr), disp]);
+            }
+            (Size::S16, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                assert!((disp & 0x1 == 0) && (disp < 0x2000));
+                let disp = disp as u32;
+                dynasm!(self ; ldrh W(reg), [X(addr), disp]);
+            }
+            (Size::S8, Location::GPR(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                assert!(disp < 0x1000);
+                let disp = disp as u32;
+                dynasm!(self ; ldrb W(reg), [X(addr), disp]);
+            }
+            (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldr X(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldr X(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldr X(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldr W(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldr W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldr W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S64, Location::SIMD(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x7) == 0 && (disp < 0x8000));
+                dynasm!(self ; ldr D(reg), [X(addr), disp]);
+            }
+            (Size::S32, Location::SIMD(reg), Location::Memory(addr, disp)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let disp = disp as u32;
+                assert!((disp & 0x3) == 0 && (disp < 0x4000));
+                dynasm!(self ; ldr S(reg), [X(addr), disp]);
+            }
+            (Size::S64, Location::SIMD(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldr D(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldr D(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldr D(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S32, Location::SIMD(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldr S(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldr S(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldr S(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDR {:?}, {:?}, {:?}", sz, reg, addr),
+        }
+        Ok(())
+    }
+    fn emit_stur(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: i32,
+    ) -> Result<(), CompileError> {
+        assert!((-255..=255).contains(&offset));
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; stur X(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; stur W(reg), [X(addr), offset]);
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; stur D(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; stur S(reg), [X(addr), offset]);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit STUR {:?}, {:?}, {:?}, {:?}",
+                sz,
+                reg,
+                addr,
+                offset
+            ),
+        }
+        Ok(())
+    }
+    fn emit_ldur(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: i32,
+    ) -> Result<(), CompileError> {
+        assert!((-255..=255).contains(&offset));
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldur X(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldur W(reg), [X(addr), offset]);
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldur D(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldur S(reg), [X(addr), offset]);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LDUR {:?}, {:?}, {:?}, {:?}",
+                sz,
+                reg,
+                addr,
+                offset
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_strdb(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError> {
+        assert!(offset <= 255);
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; str X(reg), [X(addr), -(offset as i32)]!);
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; str D(reg), [X(addr), -(offset as i32)]!);
+            }
+            _ => codegen_error!("singlepass can't emit STRDB"),
+        }
+        Ok(())
+    }
+    fn emit_stria(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError> {
+        assert!(offset <= 255);
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; str X(reg), [X(addr)], (offset as i32));
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; str D(reg), [X(addr)], (offset as i32));
+            }
+            _ => codegen_error!("singlepass can't emit STRIA"),
+        }
+        Ok(())
+    }
+    fn emit_ldria(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError> {
+        assert!(offset <= 255);
+        match (sz, reg) {
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldr X(reg), [X(addr)], offset);
+            }
+            (Size::S64, Location::SIMD(reg)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldr D(reg), [X(addr)], offset);
+            }
+            _ => codegen_error!("singlepass can't emit LDRIA"),
+        }
+        Ok(())
+    }
+
+    fn emit_stpdb(
+        &mut self,
+        sz: Size,
+        reg1: Location,
+        reg2: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError> {
+        assert!(offset <= 255);
+        match (sz, reg1, reg2) {
+            (Size::S64, Location::GPR(reg1), Location::GPR(reg2)) => {
+                let reg1 = reg1.into_index() as u32;
+                let reg2 = reg2.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; stp X(reg1), X(reg2), [X(addr), -(offset as i32)]!);
+            }
+            _ => codegen_error!("singlepass can't emit STPDB"),
+        }
+        Ok(())
+    }
+    fn emit_ldpia(
+        &mut self,
+        sz: Size,
+        reg1: Location,
+        reg2: Location,
+        addr: GPR,
+        offset: u32,
+    ) -> Result<(), CompileError> {
+        assert!(offset <= 255);
+        match (sz, reg1, reg2) {
+            (Size::S64, Location::GPR(reg1), Location::GPR(reg2)) => {
+                let reg1 = reg1.into_index() as u32;
+                let reg2 = reg2.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                dynasm!(self ; ldp X(reg1), X(reg2), [X(addr)], offset);
+            }
+            _ => codegen_error!("singlepass can't emit LDPIA"),
+        }
+        Ok(())
+    }
+
+    fn emit_ldrb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!(offset < 0x1000);
+                dynasm!(self ; ldrb W(reg), [X(addr), offset]);
+            }
+            (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrb W(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrb W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrb W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDRB {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldrh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!((offset & 1 == 0) && (offset < 0x2000));
+                dynasm!(self ; ldrh W(reg), [X(addr), offset]);
+            }
+            (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrh W(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrh W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrh W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDRH {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldrsb(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, reg, dst) {
+            (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!(offset < 0x1000);
+                dynasm!(self ; ldrsb X(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!(offset < 0x1000);
+                dynasm!(self ; ldrsb W(reg), [X(addr), offset]);
+            }
+            (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrsb X(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrsb X(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrsb X(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrsb W(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrsb W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrsb W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDRSB {:?}, {:?}, {:?}", sz, reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldrsh(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, reg, dst) {
+            (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!((offset & 1 == 0) && (offset < 0x2000));
+                dynasm!(self ; ldrsh X(reg), [X(addr), offset]);
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!((offset & 1 == 0) && (offset < 0x2000));
+                dynasm!(self ; ldrsh W(reg), [X(addr), offset]);
+            }
+            (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrsh X(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrsh X(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrsh X(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            (Size::S32, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrsh W(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrsh W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrsh W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDRSH {:?}, {:?}, {:?}", sz, reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldrsw(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, reg, dst) {
+            (Size::S64, Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!((offset & 3 == 0) && (offset < 0x4000));
+                dynasm!(self ; ldrsw X(reg), [X(addr), offset]);
+            }
+            (Size::S64, Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; ldrsw X(reg), [X(addr)]),
+                    1 => dynasm!(self ; ldrsw X(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; ldrsw X(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LDRSW {:?}, {:?}, {:?}", sz, reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_strb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!(offset < 0x1000);
+                dynasm!(self ; strb W(reg), [X(addr), offset]);
+            }
+            (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; strb W(reg), [X(addr)]),
+                    1 => dynasm!(self ; strb W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; strb W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit STRB {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_strh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::Memory(addr, offset)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let offset = offset as u32;
+                assert!((offset & 1 == 0) && (offset < 0x2000));
+                dynasm!(self ; strh W(reg), [X(addr), offset]);
+            }
+            (Location::GPR(reg), Location::Memory2(addr, r2, mult, offs)) => {
+                let reg = reg.into_index() as u32;
+                let addr = addr.into_index() as u32;
+                let r2 = r2.into_index() as u32;
+                assert!(offs == 0);
+                let mult = mult as u32;
+                match mult {
+                    0 => dynasm!(self ; strh W(reg), [X(addr)]),
+                    1 => dynasm!(self ; strh W(reg), [X(addr), X(r2)]),
+                    _ => dynasm!(self ; strh W(reg), [X(addr), X(r2), LSL mult]),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit STRH {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_ldaxr(&mut self, sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, reg, dst) {
+            (Size::S32, Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ldaxr W(reg), [X(dst)]);
+            }
+            (Size::S64, Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ldaxr X(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit LDAXR {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldaxrb(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ldaxrb W(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit LDAXRB {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_ldaxrh(&mut self, _sz: Size, reg: Location, dst: Location) -> Result<(), CompileError> {
+        match (reg, dst) {
+            (Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ldaxrh W(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit LDAXRH {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_stlxr(
+        &mut self,
+        sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, status, reg, dst) {
+            (Size::S32, Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                let status = status.into_index() as u32;
+                dynasm!(self ; stlxr W(status), W(reg), [X(dst)]);
+            }
+            (Size::S64, Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                let status = status.into_index() as u32;
+                dynasm!(self ; stlxr W(status), X(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit STLXR {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_stlxrb(
+        &mut self,
+        _sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (status, reg, dst) {
+            (Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                let status = status.into_index() as u32;
+                dynasm!(self ; stlxrb W(status), W(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit STLXRB {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+    fn emit_stlxrh(
+        &mut self,
+        _sz: Size,
+        status: Location,
+        reg: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (status, reg, dst) {
+            (Location::GPR(status), Location::GPR(reg), Location::GPR(dst)) => {
+                let reg = reg.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                let status = status.into_index() as u32;
+                dynasm!(self ; stlxrh W(status), W(reg), [X(dst)]);
+            }
+            _ => codegen_error!("singlepass can't emit STLXRH {:?}, {:?}", reg, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov X(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov W(dst), W(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov V(dst).D[0], V(src).D[0]);
+            }
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov V(dst).S[0], V(src).S[0]);
+            }
+            (Size::S64, Location::GPR(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov V(dst).D[0], X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov V(dst).S[0], W(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov X(dst), V(src).D[0]);
+            }
+            (Size::S32, Location::SIMD(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mov W(dst), V(src).S[0]);
+            }
+            (Size::S32, Location::Imm32(val), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if val < 0x1000 {
+                    dynasm!(self ; mov W(dst), val as u64);
+                } else if encode_logical_immediate_32bit(val as _).is_some() {
+                    dynasm!(self ; orr W(dst), wzr, val);
+                } else {
+                    codegen_error!("singlepass can't emit MOV S32 {}, {:?}", val, dst);
+                }
+            }
+            (Size::S64, Location::Imm32(val), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if val < 0x1000 {
+                    dynasm!(self ; mov W(dst), val as u64);
+                } else if encode_logical_immediate_64bit(val as _).is_some() {
+                    dynasm!(self ; orr X(dst), xzr, val as u64);
+                } else {
+                    codegen_error!("singlepass can't emit MOV S64 {}, {:?}", val, dst);
+                }
+            }
+            (Size::S64, Location::Imm64(val), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if val < 0x1000 {
+                    dynasm!(self ; mov W(dst), val as u64);
+                } else if encode_logical_immediate_64bit(val as _).is_some() {
+                    dynasm!(self ; orr X(dst), xzr, val as u64);
+                } else {
+                    codegen_error!("singleplasse can't emit MOV S64 {}, {:?}", val, dst);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit MOV {:?}, {:?}, {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_movn(&mut self, sz: Size, reg: Location, val: u32) -> Result<(), CompileError> {
+        match (sz, reg) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; movn W(reg), val);
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; movn X(reg), val);
+            }
+            _ => codegen_error!("singlepass can't emit MOVN"),
+        }
+        Ok(())
+    }
+    fn emit_movz(&mut self, reg: Location, val: u32) -> Result<(), CompileError> {
+        match reg {
+            Location::GPR(reg) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; movz W(reg), val);
+            }
+            _ => codegen_error!("singlepass can't emit MOVZ"),
+        }
+        Ok(())
+    }
+    fn emit_movk(&mut self, reg: Location, val: u32, shift: u32) -> Result<(), CompileError> {
+        match reg {
+            Location::GPR(reg) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; movk X(reg), val, LSL shift);
+            }
+            _ => codegen_error!("singlepass can't emit MOVK"),
+        }
+        Ok(())
+    }
+
+    fn emit_mov_imm(&mut self, dst: Location, val: u64) -> Result<(), CompileError> {
+        match dst {
+            Location::GPR(dst) => {
+                let dst = dst.into_index() as u32;
+                let offset = val.trailing_zeros() & 48;
+                let masked = 0xffff & (val >> offset);
+                if (masked << offset) == val {
+                    dynasm!(self ; movz X(dst), masked as u32, LSL offset);
+                } else if val >> 16 == 0xffff_ffff_ffff {
+                    let val: u16 = !((val & 0xffff) as u16);
+                    dynasm!(self ; movn X(dst), val as u32);
+                } else if val >> 16 == 0xffff {
+                    let val: u16 = !((val & 0xffff) as u16);
+                    dynasm!(self ; movn W(dst), val as u32);
+                } else {
+                    dynasm!(self ; movz W(dst), (val&0xffff) as u32);
+                    let val = val >> 16;
+                    if val != 0 {
+                        dynasm!(self ; movk X(dst), (val&0xffff) as u32, LSL 16);
+                        let val = val >> 16;
+                        if val != 0 {
+                            dynasm!(self ; movk X(dst), (val&0xffff) as u32, LSL 32);
+                            let val = val >> 16;
+                            if val != 0 {
+                                dynasm!(self ; movk X(dst), (val&0xffff) as u32, LSL 48);
+                            }
+                        }
+                    }
+                }
+            }
+            _ => codegen_error!("singlepass can't emit MOVW {:?}", dst),
+        }
+        Ok(())
+    }
+
+    fn emit_add(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; add X(dst), X(src1), X(src2), UXTX);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; add W(dst), W(src1), W(src2), UXTX);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; add X(dst), X(src1), imm as u32);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                dynasm!(self ; add X(dst), X(src1), imm);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                let imm = imm as u32;
+                dynasm!(self ; add X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; add W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                dynasm!(self ; add W(dst), W(src1), imm);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit ADD {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_sub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sub X(dst), X(src1), X(src2), UXTX);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sub W(dst), W(src1), W(src2), UXTX);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sub X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sub W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                dynasm!(self ; sub W(dst), W(src1), imm);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                dynasm!(self ; sub X(dst), X(src1), imm);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    unreachable!();
+                }
+                dynasm!(self ; sub X(dst), X(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SUB {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_mul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mul X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; mul W(dst), W(src1), W(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit MUL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_adds(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; adds X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; adds W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; adds X(dst), X(src1), imm as u32);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    codegen_error!("singlepass ADD.S with imm too large {}", imm);
+                }
+                dynasm!(self ; adds X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; adds W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    codegen_error!("singlepass ADD.S with imm too large {}", imm);
+                }
+                dynasm!(self ; adds W(dst), W(src1), imm);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit ADD.S {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_subs(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; subs X(dst), X(src1), X(src2));
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; subs W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; subs X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; subs W(dst), W(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SUB.S {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_add_lsl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        lsl: u32,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; add X(dst), X(src1), X(src2), LSL lsl);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LSL {:?} {:?} {:?} {:?} LSL {:?}",
+                sz,
+                src1,
+                src2,
+                dst,
+                lsl
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_cmp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; cmp X(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; cmp W(dst), W(src));
+            }
+            (Size::S64, Location::Imm8(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; cmp X(dst), imm as u32);
+            }
+            (Size::S64, Location::Imm32(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    codegen_error!("singlepass CMP with imm too large {}", imm);
+                }
+                dynasm!(self ; cmp X(dst), imm as u32);
+            }
+            (Size::S64, Location::Imm64(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    codegen_error!("singlepass CMP with imm too large {}", imm);
+                }
+                dynasm!(self ; cmp X(dst), imm as u32);
+            }
+            (Size::S32, Location::Imm8(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; cmp W(dst), imm as u32);
+            }
+            (Size::S32, Location::Imm32(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if imm >= 0x1000 {
+                    codegen_error!("singlepass CMP with imm too large {}", imm);
+                }
+                dynasm!(self ; cmp W(dst), imm as u32);
+            }
+            _ => codegen_error!("singlepass can't emit CMP {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_tst(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; tst X(dst), X(src));
+            }
+            (Size::S64, Location::Imm32(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(imm as u64).is_none() {
+                    codegen_error!("singlepass TST with incompatible imm {}", imm);
+                }
+                dynasm!(self ; tst X(dst), imm as u64);
+            }
+            (Size::S64, Location::Imm64(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(imm as u64).is_none() {
+                    codegen_error!("singlepass TST with incompatible imm {}", imm);
+                }
+                dynasm!(self ; tst X(dst), imm as u64);
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; tst W(dst), W(src));
+            }
+            (Size::S32, Location::Imm32(imm), Location::GPR(dst)) => {
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(imm as u64).is_none() {
+                    codegen_error!("singlepass TST with incompatible imm {}", imm);
+                }
+                dynasm!(self ; tst W(dst), imm);
+            }
+            _ => codegen_error!("singlepass can't emit TST"),
+        }
+        Ok(())
+    }
+
+    fn emit_lsl(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; lsl X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                if imm > 63 {
+                    codegen_error!("singlepass LSL with incompatible imm {}", imm);
+                }
+                let imm = imm as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; lsl X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; lsl W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm > 63 {
+                    codegen_error!("singlepass LSL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsl X(dst), X(src1), imm as u32);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm > 63 {
+                    codegen_error!("singlepass LSL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsl X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm > 31 {
+                    codegen_error!("singlepass LSL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsl W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm > 31 {
+                    codegen_error!("singlepass LSL with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsl W(dst), W(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LSL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_asr(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; asr X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let imm = imm as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ASR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; asr X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; asr W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ASR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; asr X(dst), X(src1), imm as u32);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ASR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; asr X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass ASR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; asr W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass ASR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; asr W(dst), W(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit ASR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_lsr(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; lsr X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let imm = imm as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass LSR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsr X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; lsr W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass LSR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsr X(dst), X(src1), imm as u32);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass LSR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsr X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass LSR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsr W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass LSR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; lsr W(dst), W(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LSR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_ror(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ror X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let imm = imm as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ROR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; ror X(dst), X(src1), imm);
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm64(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let imm = imm as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ROR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; ror X(dst), X(src1), imm);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm32(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass ROR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; ror W(dst), W(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ror W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S64, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 63 {
+                    codegen_error!("singlepass ROR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; ror X(dst), X(src1), imm as u32);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm8(imm), Location::GPR(dst))
+            | (Size::S32, Location::Imm8(imm), Location::GPR(src1), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                if imm == 0 || imm > 31 {
+                    codegen_error!("singlepass ROR with incompatible imm {}", imm);
+                }
+                dynasm!(self ; ror W(dst), W(src1), imm as u32);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit ROR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_or(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; orr X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u64;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(src2 as u64).is_none() {
+                    codegen_error!("singlepass OR with incompatible imm {}", src2);
+                }
+                dynasm!(self ; orr X(dst), X(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u32;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_32bit(src2).is_none() {
+                    codegen_error!("singlepass OR with incompatible imm {}", src2);
+                }
+                dynasm!(self ; orr W(dst), W(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; orr W(dst), W(src1), W(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit OR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_and(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; and X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u64;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(src2 as u64).is_none() {
+                    codegen_error!("singlepass AND with incompatible imm {}", src2);
+                }
+                dynasm!(self ; and X(dst), X(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u32;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_32bit(src2).is_none() {
+                    codegen_error!("singlepass AND with incompatible imm {}", src2);
+                }
+                dynasm!(self ; and W(dst), W(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; and W(dst), W(src1), W(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit AND {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_eor(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; eor X(dst), X(src1), X(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::Imm64(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u64;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_64bit(src2 as u64).is_none() {
+                    codegen_error!("singlepass EOR with incompatible imm {}", src2);
+                }
+                dynasm!(self ; eor X(dst), X(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::Imm32(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2 as u32;
+                let dst = dst.into_index() as u32;
+                if encode_logical_immediate_32bit(src2).is_none() {
+                    codegen_error!("singlepass EOR with incompatible imm {}", src2);
+                }
+                dynasm!(self ; eor W(dst), W(src1), src2);
+            }
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; eor W(dst), W(src1), W(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit EOR {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_bfc(
+        &mut self,
+        sz: Size,
+        lsb: u32,
+        width: u32,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, dst) {
+            (Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; bfc W(dst as u32), lsb, width);
+            }
+            (Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; bfc X(dst as u32), lsb, width);
+            }
+            _ => codegen_error!("singlepass can't emit BFC"),
+        }
+        Ok(())
+    }
+    fn emit_bfi(
+        &mut self,
+        sz: Size,
+        src: Location,
+        lsb: u32,
+        width: u32,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; bfi W(dst as u32), W(src as u32), lsb, width);
+            }
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; bfi X(dst as u32), X(src as u32), lsb, width);
+            }
+            _ => codegen_error!("singlepass can't emit BFI"),
+        }
+        Ok(())
+    }
+
+    fn emit_udiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; udiv W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; udiv X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_sdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sdiv W(dst), W(src1), W(src2));
+            }
+            (Size::S64, Location::GPR(src1), Location::GPR(src2), Location::GPR(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sdiv X(dst), X(src1), X(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    /// msub : c - a*b -> dst
+    fn emit_msub(
+        &mut self,
+        sz: Size,
+        a: Location,
+        b: Location,
+        c: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, a, b, c, dst) {
+            (
+                Size::S32,
+                Location::GPR(a),
+                Location::GPR(b),
+                Location::GPR(c),
+                Location::GPR(dst),
+            ) => {
+                let a = a.into_index() as u32;
+                let b = b.into_index() as u32;
+                let c = c.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; msub W(dst), W(a), W(b), W(c));
+            }
+            (
+                Size::S64,
+                Location::GPR(a),
+                Location::GPR(b),
+                Location::GPR(c),
+                Location::GPR(dst),
+            ) => {
+                let a = a.into_index() as u32;
+                let b = b.into_index() as u32;
+                let c = c.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; msub X(dst), X(a), X(b), X(c));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit msub {:?} {:?} {:?} {:?} {:?}",
+                sz,
+                a,
+                b,
+                c,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_sxtb(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sxtb W(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sxtb X(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit SXTB {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_sxth(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sxth W(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sxth X(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit SXTH {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_sxtw(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (src, dst) {
+            (Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; sxtw X(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit SXTW {:?} {:?}", src, dst),
+        }
+        Ok(())
+    }
+    fn emit_uxtb(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (src, dst) {
+            (Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; uxtb W(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit UXTB {:?} {:?}", src, dst),
+        }
+        Ok(())
+    }
+    fn emit_uxth(&mut self, _sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (src, dst) {
+            (Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; uxth W(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit UXTH {:?} {:?}", src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_cset(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError> {
+        match (sz, dst) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; cset W(reg), eq),
+                    Condition::Ne => dynasm!(self ; cset W(reg), ne),
+                    Condition::Cs => dynasm!(self ; cset W(reg), cs),
+                    Condition::Cc => dynasm!(self ; cset W(reg), cc),
+                    Condition::Mi => dynasm!(self ; cset W(reg), mi),
+                    Condition::Pl => dynasm!(self ; cset W(reg), pl),
+                    Condition::Vs => dynasm!(self ; cset W(reg), vs),
+                    Condition::Vc => dynasm!(self ; cset W(reg), vc),
+                    Condition::Hi => dynasm!(self ; cset W(reg), hi),
+                    Condition::Ls => dynasm!(self ; cset W(reg), ls),
+                    Condition::Ge => dynasm!(self ; cset W(reg), ge),
+                    Condition::Lt => dynasm!(self ; cset W(reg), lt),
+                    Condition::Gt => dynasm!(self ; cset W(reg), gt),
+                    Condition::Le => dynasm!(self ; cset W(reg), le),
+                    Condition::Al => dynasm!(self ; cset W(reg), al),
+                }
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; cset X(reg), eq),
+                    Condition::Ne => dynasm!(self ; cset X(reg), ne),
+                    Condition::Cs => dynasm!(self ; cset X(reg), cs),
+                    Condition::Cc => dynasm!(self ; cset X(reg), cc),
+                    Condition::Mi => dynasm!(self ; cset X(reg), mi),
+                    Condition::Pl => dynasm!(self ; cset X(reg), pl),
+                    Condition::Vs => dynasm!(self ; cset X(reg), vs),
+                    Condition::Vc => dynasm!(self ; cset X(reg), vc),
+                    Condition::Hi => dynasm!(self ; cset X(reg), hi),
+                    Condition::Ls => dynasm!(self ; cset X(reg), ls),
+                    Condition::Ge => dynasm!(self ; cset X(reg), ge),
+                    Condition::Lt => dynasm!(self ; cset X(reg), lt),
+                    Condition::Gt => dynasm!(self ; cset X(reg), gt),
+                    Condition::Le => dynasm!(self ; cset X(reg), le),
+                    Condition::Al => dynasm!(self ; cset X(reg), al),
+                }
+            }
+            _ => codegen_error!("singlepass can't emit CSET {:?} {:?} {:?}", sz, dst, cond),
+        }
+        Ok(())
+    }
+    fn emit_csetm(&mut self, sz: Size, dst: Location, cond: Condition) -> Result<(), CompileError> {
+        match (sz, dst) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; csetm W(reg), eq),
+                    Condition::Ne => dynasm!(self ; csetm W(reg), ne),
+                    Condition::Cs => dynasm!(self ; csetm W(reg), cs),
+                    Condition::Cc => dynasm!(self ; csetm W(reg), cc),
+                    Condition::Mi => dynasm!(self ; csetm W(reg), mi),
+                    Condition::Pl => dynasm!(self ; csetm W(reg), pl),
+                    Condition::Vs => dynasm!(self ; csetm W(reg), vs),
+                    Condition::Vc => dynasm!(self ; csetm W(reg), vc),
+                    Condition::Hi => dynasm!(self ; csetm W(reg), hi),
+                    Condition::Ls => dynasm!(self ; csetm W(reg), ls),
+                    Condition::Ge => dynasm!(self ; csetm W(reg), ge),
+                    Condition::Lt => dynasm!(self ; csetm W(reg), lt),
+                    Condition::Gt => dynasm!(self ; csetm W(reg), gt),
+                    Condition::Le => dynasm!(self ; csetm W(reg), le),
+                    Condition::Al => dynasm!(self ; csetm W(reg), al),
+                }
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; csetm X(reg), eq),
+                    Condition::Ne => dynasm!(self ; csetm X(reg), ne),
+                    Condition::Cs => dynasm!(self ; csetm X(reg), cs),
+                    Condition::Cc => dynasm!(self ; csetm X(reg), cc),
+                    Condition::Mi => dynasm!(self ; csetm X(reg), mi),
+                    Condition::Pl => dynasm!(self ; csetm X(reg), pl),
+                    Condition::Vs => dynasm!(self ; csetm X(reg), vs),
+                    Condition::Vc => dynasm!(self ; csetm X(reg), vc),
+                    Condition::Hi => dynasm!(self ; csetm X(reg), hi),
+                    Condition::Ls => dynasm!(self ; csetm X(reg), ls),
+                    Condition::Ge => dynasm!(self ; csetm X(reg), ge),
+                    Condition::Lt => dynasm!(self ; csetm X(reg), lt),
+                    Condition::Gt => dynasm!(self ; csetm X(reg), gt),
+                    Condition::Le => dynasm!(self ; csetm X(reg), le),
+                    Condition::Al => dynasm!(self ; csetm X(reg), al),
+                }
+            }
+            _ => codegen_error!("singlepass can't emit CSETM {:?} {:?} {:?}", sz, dst, cond),
+        }
+        Ok(())
+    }
+    fn emit_cinc(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+        cond: Condition,
+    ) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; cinc W(dst), W(src), eq),
+                    Condition::Ne => dynasm!(self ; cinc W(dst), W(src), ne),
+                    Condition::Cs => dynasm!(self ; cinc W(dst), W(src), cs),
+                    Condition::Cc => dynasm!(self ; cinc W(dst), W(src), cc),
+                    Condition::Mi => dynasm!(self ; cinc W(dst), W(src), mi),
+                    Condition::Pl => dynasm!(self ; cinc W(dst), W(src), pl),
+                    Condition::Vs => dynasm!(self ; cinc W(dst), W(src), vs),
+                    Condition::Vc => dynasm!(self ; cinc W(dst), W(src), vc),
+                    Condition::Hi => dynasm!(self ; cinc W(dst), W(src), hi),
+                    Condition::Ls => dynasm!(self ; cinc W(dst), W(src), ls),
+                    Condition::Ge => dynasm!(self ; cinc W(dst), W(src), ge),
+                    Condition::Lt => dynasm!(self ; cinc W(dst), W(src), lt),
+                    Condition::Gt => dynasm!(self ; cinc W(dst), W(src), gt),
+                    Condition::Le => dynasm!(self ; cinc W(dst), W(src), le),
+                    Condition::Al => dynasm!(self ; cinc W(dst), W(src), al),
+                };
+            }
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                match cond {
+                    Condition::Eq => dynasm!(self ; cinc X(src), X(dst), eq),
+                    Condition::Ne => dynasm!(self ; cinc X(src), X(dst), ne),
+                    Condition::Cs => dynasm!(self ; cinc X(src), X(dst), cs),
+                    Condition::Cc => dynasm!(self ; cinc X(src), X(dst), cc),
+                    Condition::Mi => dynasm!(self ; cinc X(src), X(dst), mi),
+                    Condition::Pl => dynasm!(self ; cinc X(src), X(dst), pl),
+                    Condition::Vs => dynasm!(self ; cinc X(src), X(dst), vs),
+                    Condition::Vc => dynasm!(self ; cinc X(src), X(dst), vc),
+                    Condition::Hi => dynasm!(self ; cinc X(src), X(dst), hi),
+                    Condition::Ls => dynasm!(self ; cinc X(src), X(dst), ls),
+                    Condition::Ge => dynasm!(self ; cinc X(src), X(dst), ge),
+                    Condition::Lt => dynasm!(self ; cinc X(src), X(dst), lt),
+                    Condition::Gt => dynasm!(self ; cinc X(src), X(dst), gt),
+                    Condition::Le => dynasm!(self ; cinc X(src), X(dst), le),
+                    Condition::Al => dynasm!(self ; cinc X(src), X(dst), al),
+                };
+            }
+            _ => codegen_error!("singlepass can't emit CINC"),
+        }
+        Ok(())
+    }
+
+    fn emit_clz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; clz X(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; clz W(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit CLS {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_rbit(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; rbit X(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; rbit W(dst), W(src));
+            }
+            _ => codegen_error!("singlepass can't emit CLS {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; => label);
+        Ok(())
+    }
+    fn emit_load_label(&mut self, reg: GPR, label: Label) -> Result<(), CompileError> {
+        let reg = reg.into_index() as u32;
+        dynasm!(self ; adr X(reg), =>label);
+        Ok(())
+    }
+
+    fn emit_b_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; b =>label);
+        Ok(())
+    }
+    fn emit_cbz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        match (sz, reg) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; cbz W(reg), =>label);
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; cbz X(reg), =>label);
+            }
+            _ => codegen_error!("singlepass can't emit CBZ {:?} {:?} {:?}", sz, reg, label),
+        }
+        Ok(())
+    }
+    fn emit_cbnz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        match (sz, reg) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; cbnz W(reg), =>label);
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; cbnz X(reg), =>label);
+            }
+            _ => codegen_error!("singlepass can't emit CBNZ {:?} {:?} {:?}", sz, reg, label),
+        }
+        Ok(())
+    }
+    fn emit_tbz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        n: u32,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        match (sz, reg) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; tbz W(reg), n, =>label);
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; tbz X(reg), n, =>label);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit TBZ {:?} {:?} {:?} {:?}",
+                sz,
+                reg,
+                n,
+                label
+            ),
+        }
+        Ok(())
+    }
+    fn emit_tbnz_label(
+        &mut self,
+        sz: Size,
+        reg: Location,
+        n: u32,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        match (sz, reg) {
+            (Size::S32, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; tbnz W(reg), n, =>label);
+            }
+            (Size::S64, Location::GPR(reg)) => {
+                let reg = reg.into_index() as u32;
+                dynasm!(self ; tbnz X(reg), n, =>label);
+            }
+            _ => codegen_error!(
+                "singlepass can't emit TBNZ {:?} {:?} {:?} {:?}",
+                sz,
+                reg,
+                n,
+                label
+            ),
+        }
+        Ok(())
+    }
+    fn emit_bcond_label(&mut self, condition: Condition, label: Label) -> Result<(), CompileError> {
+        match condition {
+            Condition::Eq => dynasm!(self ; b.eq => label),
+            Condition::Ne => dynasm!(self ; b.ne => label),
+            Condition::Cs => dynasm!(self ; b.cs => label),
+            Condition::Cc => dynasm!(self ; b.cc => label),
+            Condition::Mi => dynasm!(self ; b.mi => label),
+            Condition::Pl => dynasm!(self ; b.pl => label),
+            Condition::Vs => dynasm!(self ; b.vs => label),
+            Condition::Vc => dynasm!(self ; b.vc => label),
+            Condition::Hi => dynasm!(self ; b.hi => label),
+            Condition::Ls => dynasm!(self ; b.ls => label),
+            Condition::Ge => dynasm!(self ; b.ge => label),
+            Condition::Lt => dynasm!(self ; b.lt => label),
+            Condition::Gt => dynasm!(self ; b.gt => label),
+            Condition::Le => dynasm!(self ; b.le => label),
+            Condition::Al => dynasm!(self ; b => label),
+        }
+        Ok(())
+    }
+    fn emit_bcond_label_far(
+        &mut self,
+        condition: Condition,
+        label: Label,
+    ) -> Result<(), CompileError> {
+        let cont: Label = self.get_label();
+        match condition {
+            // if not condition than continue
+            Condition::Eq => dynasm!(self ; b.ne => cont),
+            Condition::Ne => dynasm!(self ; b.eq => cont),
+            Condition::Cs => dynasm!(self ; b.cc => cont),
+            Condition::Cc => dynasm!(self ; b.cs => cont),
+            Condition::Mi => dynasm!(self ; b.pl => cont),
+            Condition::Pl => dynasm!(self ; b.mi => cont),
+            Condition::Vs => dynasm!(self ; b.vc => cont),
+            Condition::Vc => dynasm!(self ; b.vs => cont),
+            Condition::Hi => dynasm!(self ; b.ls => cont),
+            Condition::Ls => dynasm!(self ; b.hi => cont),
+            Condition::Ge => dynasm!(self ; b.lt => cont),
+            Condition::Lt => dynasm!(self ; b.ge => cont),
+            Condition::Gt => dynasm!(self ; b.le => cont),
+            Condition::Le => dynasm!(self ; b.gt => cont),
+            Condition::Al => { /*nothing*/ }
+        }
+        dynasm!(self ; b => label);
+        self.emit_label(cont)?;
+        Ok(())
+    }
+    fn emit_b_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; br X(reg.into_index() as u32));
+        Ok(())
+    }
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; bl =>label);
+        Ok(())
+    }
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; blr X(reg.into_index() as u32));
+        Ok(())
+    }
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; ret);
+        Ok(())
+    }
+
+    fn emit_udf(&mut self, payload: u16) -> Result<(), CompileError> {
+        dynasm!(self ; udf (payload as u32));
+        Ok(())
+    }
+    fn emit_dmb(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; dmb ish);
+        Ok(())
+    }
+    fn emit_brk(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; brk 0);
+        Ok(())
+    }
+
+    fn emit_fcmp(&mut self, sz: Size, src1: Location, src2: Location) -> Result<(), CompileError> {
+        match (sz, src1, src2) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                dynasm!(self ; fcmp S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                dynasm!(self ; fcmp D(src1), D(src2));
+            }
+            _ => codegen_error!("singlepass can't emit FCMP {:?} {:?} {:?}", sz, src1, src2),
+        }
+        Ok(())
+    }
+
+    fn emit_fneg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fneg S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fneg D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FNEG {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_fsqrt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fsqrt S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fsqrt D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FSQRT {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_fadd(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fadd S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fadd D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FADD {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fsub(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fsub S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fsub D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FSUB {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fmul(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmul S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmul D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FMUL {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fdiv(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fdiv S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fdiv D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FDIV {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_fmin(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmin S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmin D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FMIN {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fmax(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src1, src2, dst) {
+            (Size::S32, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmax S(dst), S(src1), S(src2));
+            }
+            (Size::S64, Location::SIMD(src1), Location::SIMD(src2), Location::SIMD(dst)) => {
+                let src1 = src1.into_index() as u32;
+                let src2 = src2.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fmax D(dst), D(src1), D(src2));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FMAX {:?} {:?} {:?} {:?}",
+                sz,
+                src1,
+                src2,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_frintz(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintz S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintz D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FRINTZ {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_frintn(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintn S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintn D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FRINTN {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_frintm(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintm S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintm D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FRINTM {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_frintp(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintp S(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; frintp D(dst), D(src));
+            }
+            _ => codegen_error!("singlepass can't emit FRINTP {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_scvtf(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_in, src, sz_out, dst) {
+            (Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; scvtf S(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; scvtf S(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; scvtf D(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; scvtf D(dst), X(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit SCVTF {:?} {:?} {:?} {:?}",
+                sz_in,
+                src,
+                sz_out,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_ucvtf(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_in, src, sz_out, dst) {
+            (Size::S32, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ucvtf S(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Size::S32, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ucvtf S(dst), X(src));
+            }
+            (Size::S32, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ucvtf D(dst), W(src));
+            }
+            (Size::S64, Location::GPR(src), Size::S64, Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; ucvtf D(dst), X(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UCVTF {:?} {:?} {:?} {:?}",
+                sz_in,
+                src,
+                sz_out,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fcvt(&mut self, sz_in: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz_in, src, dst) {
+            (Size::S32, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvt D(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Location::SIMD(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvt S(dst), D(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit UCVTF {:?} {:?} {:?}",
+                sz_in,
+                src,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fcvtzs(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_in, src, sz_out, dst) {
+            (Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzs W(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzs W(dst), D(src));
+            }
+            (Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzs X(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzs X(dst), D(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FCVTZS {:?} {:?} {:?} {:?}",
+                sz_in,
+                src,
+                sz_out,
+                dst
+            ),
+        }
+        Ok(())
+    }
+    fn emit_fcvtzu(
+        &mut self,
+        sz_in: Size,
+        src: Location,
+        sz_out: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_in, src, sz_out, dst) {
+            (Size::S32, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzu W(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Size::S32, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzu W(dst), D(src));
+            }
+            (Size::S32, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzu X(dst), S(src));
+            }
+            (Size::S64, Location::SIMD(src), Size::S64, Location::GPR(dst)) => {
+                let src = src.into_index() as u32;
+                let dst = dst.into_index() as u32;
+                dynasm!(self ; fcvtzu X(dst), D(src));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit FCVTZU {:?} {:?} {:?} {:?}",
+                sz_in,
+                src,
+                sz_out,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    // 1 011 0100 0100 000 => fpcr
+    fn emit_read_fpcr(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; mrs X(reg as u32), 0b1_011_0100_0100_000);
+        Ok(())
+    }
+    fn emit_write_fpcr(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; msr 0b1_011_0100_0100_000, X(reg as u32));
+        Ok(())
+    }
+    // 1 011 0100 0100 001 => fpsr
+    fn emit_read_fpsr(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; mrs X(reg as u32), 0b1_011_0100_0100_001);
+        Ok(())
+    }
+    fn emit_write_fpsr(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; msr 0b1_011_0100_0100_001, X(reg as u32));
+        Ok(())
+    }
+
+    fn emit_cnt(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError> {
+        dynasm!(self ; cnt V(dst.into_index() as u32).B8, V(src.into_index() as u32).B8);
+        Ok(())
+    }
+
+    fn emit_addv(&mut self, src: NEON, dst: NEON) -> Result<(), CompileError> {
+        dynasm!(self ; addv B(dst.into_index() as u32), V(src.into_index() as u32).B8);
+        Ok(())
+    }
+
+    fn emit_fmov(
+        &mut self,
+        src_size: Size,
+        src: Location,
+        dst_size: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        let res = match (src, dst) {
+            (AbstractLocation::GPR(src), AbstractLocation::SIMD(dst)) => {
+                match (src_size, dst_size) {
+                    (Size::S32, Size::S32) => Ok(dynasm!(self ; fmov S(dst as u32), W(src as u32))),
+                    (Size::S64, Size::S64) => Ok(dynasm!(self ; fmov D(dst as u32), X(src as u32))),
+                    _ => Err(()),
+                }
+            }
+            (AbstractLocation::SIMD(src), AbstractLocation::GPR(dst)) => {
+                match (src_size, dst_size) {
+                    (Size::S32, Size::S32) => Ok(dynasm!(self ; fmov W(dst as u32), S(src as u32))),
+                    (Size::S64, Size::S64) => Ok(dynasm!(self ; fmov X(dst as u32), D(src as u32))),
+                    _ => Err(()),
+                }
+            }
+            // (AbstractLocation::SIMD(src), AbstractLocation::SIMD(dst)) => todo!(),
+            // (AbstractLocation::SIMD(src), AbstractLocation::Imm32(dst)) => todo!(),
+            // (AbstractLocation::SIMD(src), AbstractLocation::Imm64(dst)) => todo!(),
+            _ => Err(()),
+        };
+
+        match res {
+            Ok(_) => Ok(()),
+            Err(_) => codegen_error!(
+                "singlepass can't generate fmov instruction for src_size: {:?}, src: {:?}, dst_size: {:?}, dst: {:?}",
+                src_size,
+                src,
+                dst_size,
+                dst,
+            ),
+        }
+    }
+}
+
+pub fn gen_std_trampoline_arm64(
+    sig: &FunctionType,
+    calling_convention: CallingConvention,
+) -> Result<FunctionBody, CompileError> {
+    let mut a = Assembler::new(0);
+
+    let fptr = GPR::X27;
+    let args = GPR::X28;
+
+    dynasm!(a
+        ; sub sp, sp, 32
+        ; stp x29, x30, [sp]
+        ; stp X(fptr as u32), X(args as u32), [sp, 16]
+        ; mov x29, sp
+        ; mov X(fptr as u32), x1
+        ; mov X(args as u32), x2
+    );
+
+    let stack_args = sig.params().len().saturating_sub(7); //1st arg is ctx, not an actual arg
+    let mut stack_offset = stack_args as u32 * 8;
+    if stack_args > 0 {
+        if stack_offset % 16 != 0 {
+            stack_offset += 8;
+            assert!(stack_offset % 16 == 0);
+        }
+        dynasm!(a ; sub sp, sp, stack_offset);
+    }
+
+    // Move arguments to their locations.
+    // `callee_vmctx` is already in the first argument register, so no need to move.
+    let mut caller_stack_offset: i32 = 0;
+    for (i, param) in sig.params().iter().enumerate() {
+        let sz = match *param {
+            Type::I32 | Type::F32 => Size::S32,
+            Type::I64 | Type::F64 => Size::S64,
+            Type::ExternRef => Size::S64,
+            Type::FuncRef => Size::S64,
+            _ => codegen_error!(
+                "singlepass unsupported param type for trampoline {:?}",
+                *param
+            ),
+        };
+        match i {
+            0..=6 => {
+                a.emit_ldr(
+                    sz,
+                    Location::GPR(GPR::from_index(i + 1).unwrap()),
+                    Location::Memory(args, (i * 16) as i32),
+                )?;
+            }
+            _ => {
+                #[allow(clippy::single_match)]
+                match calling_convention {
+                    CallingConvention::AppleAarch64 => {
+                        let sz = 1
+                            << match sz {
+                                Size::S8 => 0,
+                                Size::S16 => 1,
+                                Size::S32 => 2,
+                                Size::S64 => 3,
+                            };
+                        // align first
+                        if sz > 1 && caller_stack_offset & (sz - 1) != 0 {
+                            caller_stack_offset = (caller_stack_offset + (sz - 1)) & !(sz - 1);
+                        }
+                    }
+                    _ => (),
+                };
+                // using X16 as scratch reg
+                a.emit_ldr(
+                    sz,
+                    Location::GPR(GPR::X16),
+                    Location::Memory(args, (i * 16) as i32),
+                )?;
+                a.emit_str(
+                    sz,
+                    Location::GPR(GPR::X16),
+                    Location::Memory(GPR::XzrSp, caller_stack_offset),
+                )?;
+                match calling_convention {
+                    CallingConvention::AppleAarch64 => {
+                        caller_stack_offset += 1
+                            << match sz {
+                                Size::S8 => 0,
+                                Size::S16 => 1,
+                                Size::S32 => 2,
+                                Size::S64 => 3,
+                            };
+                    }
+                    _ => {
+                        caller_stack_offset += 8;
+                    }
+                }
+            }
+        }
+    }
+
+    dynasm!(a  ; blr X(fptr as u32));
+
+    // Write return value.
+    if !sig.results().is_empty() {
+        a.emit_str(Size::S64, Location::GPR(GPR::X0), Location::Memory(args, 0))?;
+    }
+
+    // Restore stack.
+    dynasm!(a
+        ; ldp X(fptr as u32), X(args as u32), [x29, 16]
+        ; ldp x29, x30, [x29]
+        ; add sp, sp, 32 + stack_offset as u32
+        ; ret
+    );
+
+    let mut body = a.finalize().unwrap();
+    body.shrink_to_fit();
+    Ok(FunctionBody {
+        body,
+        unwind_info: None,
+    })
+}
+// Generates dynamic import function call trampoline for a function type.
+pub fn gen_std_dynamic_import_trampoline_arm64(
+    vmoffsets: &VMOffsets,
+    sig: &FunctionType,
+    calling_convention: CallingConvention,
+) -> Result<FunctionBody, CompileError> {
+    let mut a = Assembler::new(0);
+    // Allocate argument array.
+    let stack_offset: usize = 16 * std::cmp::max(sig.params().len(), sig.results().len());
+    // Save LR and X26, as scratch register
+    a.emit_stpdb(
+        Size::S64,
+        Location::GPR(GPR::X30),
+        Location::GPR(GPR::X26),
+        GPR::XzrSp,
+        16,
+    )?;
+
+    if stack_offset != 0 {
+        if stack_offset < 0x1000 {
+            a.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),
+                Location::Imm32(stack_offset as _),
+                Location::GPR(GPR::XzrSp),
+            )?;
+        } else {
+            a.emit_mov_imm(Location::GPR(GPR::X26), stack_offset as u64)?;
+            a.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),
+                Location::GPR(GPR::X26),
+                Location::GPR(GPR::XzrSp),
+            )?;
+        }
+    }
+
+    // Copy arguments.
+    if !sig.params().is_empty() {
+        let mut argalloc = ArgumentRegisterAllocator::default();
+        argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
+
+        let mut stack_param_count: usize = 0;
+
+        for (i, ty) in sig.params().iter().enumerate() {
+            let source_loc = match argalloc.next(*ty, calling_convention) {
+                Some(ARM64Register::GPR(gpr)) => Location::GPR(gpr),
+                Some(ARM64Register::NEON(neon)) => Location::SIMD(neon),
+                None => {
+                    let sz = match calling_convention {
+                        CallingConvention::AppleAarch64 => match *ty {
+                            Type::I32 | Type::F32 => Size::S32,
+                            _ => {
+                                if stack_param_count & 7 != 0 {
+                                    stack_param_count = (stack_param_count + 7) & !7;
+                                };
+                                Size::S64
+                            }
+                        },
+                        _ => Size::S64,
+                    };
+                    a.emit_ldr(
+                        sz,
+                        Location::GPR(GPR::X26),
+                        Location::Memory(GPR::XzrSp, (stack_offset + 16 + stack_param_count) as _),
+                    )?;
+                    stack_param_count += match sz {
+                        Size::S32 => 4,
+                        Size::S64 => 8,
+                        _ => codegen_error!(
+                            "singlepass unreachable in gen_std_dynamic_import_trampoline_arm64"
+                        ),
+                    };
+                    Location::GPR(GPR::X26)
+                }
+            };
+            a.emit_str(
+                Size::S64,
+                source_loc,
+                Location::Memory(GPR::XzrSp, (i * 16) as _),
+            )?;
+
+            // Zero upper 64 bits.
+            a.emit_str(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),                       // XZR here
+                Location::Memory(GPR::XzrSp, (i * 16 + 8) as _), // XSP here
+            )?;
+        }
+    }
+
+    #[allow(clippy::match_single_binding)]
+    match calling_convention {
+        _ => {
+            // Load target address.
+            let offset = vmoffsets.vmdynamicfunction_import_context_address();
+            a.emit_ldur(Size::S64, Location::GPR(GPR::X26), GPR::X0, offset as i32)?;
+            // Load values array.
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),
+                Location::Imm8(0),
+                Location::GPR(GPR::X1),
+            )?;
+        }
+    };
+
+    // Call target.
+    a.emit_call_register(GPR::X26)?;
+
+    // Fetch return value.
+    if !sig.results().is_empty() {
+        assert_eq!(sig.results().len(), 1);
+        a.emit_ldr(
+            Size::S64,
+            Location::GPR(GPR::X0),
+            Location::Memory(GPR::XzrSp, 0),
+        )?;
+    }
+
+    // Release values array.
+    if stack_offset != 0 {
+        if stack_offset < 0x1000 {
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),
+                Location::Imm32(stack_offset as _),
+                Location::GPR(GPR::XzrSp),
+            )?;
+        } else {
+            a.emit_mov_imm(Location::GPR(GPR::X26), stack_offset as u64)?;
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::XzrSp),
+                Location::GPR(GPR::X26),
+                Location::GPR(GPR::XzrSp),
+            )?;
+        }
+    }
+    a.emit_ldpia(
+        Size::S64,
+        Location::GPR(GPR::X30),
+        Location::GPR(GPR::X26),
+        GPR::XzrSp,
+        16,
+    )?;
+
+    // Return.
+    a.emit_ret()?;
+
+    let mut body = a.finalize().unwrap();
+    body.shrink_to_fit();
+    Ok(FunctionBody {
+        body,
+        unwind_info: None,
+    })
+}
+// Singlepass calls import functions through a trampoline.
+pub fn gen_import_call_trampoline_arm64(
+    vmoffsets: &VMOffsets,
+    index: FunctionIndex,
+    sig: &FunctionType,
+    calling_convention: CallingConvention,
+) -> Result<CustomSection, CompileError> {
+    let mut a = Assembler::new(0);
+
+    // Singlepass internally treats all arguments as integers
+    // For the standard System V calling convention requires
+    //  floating point arguments to be passed in NEON registers.
+    //  Translation is expensive, so only do it if needed.
+    if sig
+        .params()
+        .iter()
+        .any(|&x| x == Type::F32 || x == Type::F64)
+    {
+        #[allow(clippy::match_single_binding)]
+        match calling_convention {
+            _ => {
+                // Allocate stack space for arguments.
+                let stack_offset: i32 = if sig.params().len() > 7 {
+                    7 * 8
+                } else {
+                    (sig.params().len() as i32) * 8
+                };
+                let stack_offset = if stack_offset & 15 != 0 {
+                    stack_offset + 8
+                } else {
+                    stack_offset
+                };
+                if stack_offset > 0 {
+                    if stack_offset < 0x1000 {
+                        a.emit_sub(
+                            Size::S64,
+                            Location::GPR(GPR::XzrSp),
+                            Location::Imm32(stack_offset as u32),
+                            Location::GPR(GPR::XzrSp),
+                        )?;
+                    } else {
+                        a.emit_mov_imm(Location::GPR(GPR::X16), stack_offset as u64)?;
+                        a.emit_sub(
+                            Size::S64,
+                            Location::GPR(GPR::XzrSp),
+                            Location::GPR(GPR::X16),
+                            Location::GPR(GPR::XzrSp),
+                        )?;
+                    }
+                }
+
+                // Store all arguments to the stack to prevent overwrite.
+                static PARAM_REGS: &[GPR] = &[
+                    GPR::X1,
+                    GPR::X2,
+                    GPR::X3,
+                    GPR::X4,
+                    GPR::X5,
+                    GPR::X6,
+                    GPR::X7,
+                ];
+                let mut param_locations = vec![];
+                /* Clippy is wrong about using `i` to index `PARAM_REGS` here. */
+                #[allow(clippy::needless_range_loop)]
+                for i in 0..sig.params().len() {
+                    let loc = match i {
+                        0..=6 => {
+                            let loc = Location::Memory(GPR::XzrSp, (i * 8) as i32);
+                            a.emit_str(Size::S64, Location::GPR(PARAM_REGS[i]), loc)?;
+                            loc
+                        }
+                        _ => Location::Memory(GPR::XzrSp, stack_offset + ((i - 7) * 8) as i32),
+                    };
+                    param_locations.push(loc);
+                }
+
+                // Copy arguments.
+                let mut caller_stack_offset: i32 = 0;
+                let mut argalloc = ArgumentRegisterAllocator::default();
+                argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
+                for (i, ty) in sig.params().iter().enumerate() {
+                    let prev_loc = param_locations[i];
+                    let targ = match argalloc.next(*ty, calling_convention) {
+                        Some(ARM64Register::GPR(gpr)) => Location::GPR(gpr),
+                        Some(ARM64Register::NEON(neon)) => Location::SIMD(neon),
+                        None => {
+                            // No register can be allocated. Put this argument on the stack.
+                            a.emit_ldr(Size::S64, Location::GPR(GPR::X16), prev_loc)?;
+                            a.emit_str(
+                                Size::S64,
+                                Location::GPR(GPR::X16),
+                                Location::Memory(GPR::XzrSp, stack_offset + caller_stack_offset),
+                            )?;
+                            caller_stack_offset += 8;
+                            continue;
+                        }
+                    };
+                    a.emit_ldr(Size::S64, targ, prev_loc)?;
+                }
+
+                // Restore stack pointer.
+                if stack_offset > 0 {
+                    if stack_offset < 0x1000 {
+                        a.emit_add(
+                            Size::S64,
+                            Location::GPR(GPR::XzrSp),
+                            Location::Imm32(stack_offset as u32),
+                            Location::GPR(GPR::XzrSp),
+                        )?;
+                    } else {
+                        a.emit_mov_imm(Location::GPR(GPR::X16), stack_offset as u64)?;
+                        a.emit_add(
+                            Size::S64,
+                            Location::GPR(GPR::XzrSp),
+                            Location::GPR(GPR::X16),
+                            Location::GPR(GPR::XzrSp),
+                        )?;
+                    }
+                }
+            }
+        }
+    }
+
+    // Emits a tail call trampoline that loads the address of the target import function
+    // from Ctx and jumps to it.
+
+    let offset = vmoffsets.vmctx_vmfunction_import(index);
+    // for ldr, offset needs to be a multiple of 8, wich often is not
+    // so use ldur, but then offset is limited to -255 .. +255. It will be positive here
+    let offset =
+        if (offset > 0 && offset < 0xF8) || (offset > 0 && offset < 0x7FF8 && (offset & 7) == 0) {
+            offset
+        } else {
+            a.emit_mov_imm(Location::GPR(GPR::X16), (offset as i64) as u64)?;
+            a.emit_add(
+                Size::S64,
+                Location::GPR(GPR::X0),
+                Location::GPR(GPR::X16),
+                Location::GPR(GPR::X0),
+            )?;
+            0
+        };
+    #[allow(clippy::match_single_binding)]
+    match calling_convention {
+        _ => {
+            if (offset & 7) == 0 {
+                a.emit_ldr(
+                    Size::S64,
+                    Location::GPR(GPR::X16),
+                    Location::Memory(GPR::X0, offset as i32), // function pointer
+                )?;
+                a.emit_ldr(
+                    Size::S64,
+                    Location::GPR(GPR::X0),
+                    Location::Memory(GPR::X0, offset as i32 + 8), // target vmctx
+                )?;
+            } else {
+                a.emit_ldur(
+                    Size::S64,
+                    Location::GPR(GPR::X16),
+                    GPR::X0,
+                    offset as i32, // function pointer
+                )?;
+                a.emit_ldur(
+                    Size::S64,
+                    Location::GPR(GPR::X0),
+                    GPR::X0,
+                    offset as i32 + 8, // target vmctx
+                )?;
+            }
+        }
+    }
+    a.emit_b_register(GPR::X16)?;
+
+    let mut contents = a.finalize().unwrap();
+    contents.shrink_to_fit();
+    let section_body = SectionBody::new_with_vec(contents);
+
+    Ok(CustomSection {
+        protection: CustomSectionProtection::ReadExecute,
+        bytes: section_body,
+        relocations: vec![],
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_x64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_x64.rs
new file mode 100644
index 0000000..13ac3b4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/emitter_x64.rs
@@ -0,0 +1,2420 @@
+use crate::codegen_error;
+use crate::common_decl::Size;
+use crate::location::Location as AbstractLocation;
+pub use crate::location::Multiplier;
+pub use crate::machine::{Label, Offset};
+use crate::machine_x64::AssemblerX64;
+pub use crate::x64_decl::{GPR, XMM};
+use dynasm::dynasm;
+use dynasmrt::{AssemblyOffset, DynamicLabel, DynasmApi, DynasmLabelApi};
+use wasmer_types::{CompileError, CpuFeature};
+
+/// Force `dynasm!` to use the correct arch (x64) when cross-compiling.
+/// `dynasm!` proc-macro tries to auto-detect it by default by looking at the
+/// `target_arch`, but it sees the `target_arch` of the proc-macro itself, which
+/// is always equal to host, even when cross-compiling.
+macro_rules! dynasm {
+    ($a:expr ; $($tt:tt)*) => {
+        dynasm::dynasm!(
+            $a.inner
+            ; .arch x64
+            ; $($tt)*
+        )
+    };
+}
+
+pub type Location = AbstractLocation<GPR, XMM>;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Condition {
+    None,
+    Above,
+    AboveEqual,
+    Below,
+    BelowEqual,
+    Greater,
+    GreaterEqual,
+    Less,
+    LessEqual,
+    Equal,
+    NotEqual,
+    Signed,
+    Carry,
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[allow(dead_code, clippy::upper_case_acronyms)]
+pub enum XMMOrMemory {
+    XMM(XMM),
+    Memory(GPR, i32),
+}
+
+#[derive(Copy, Clone, Debug)]
+#[allow(dead_code, clippy::upper_case_acronyms)]
+pub enum GPROrMemory {
+    GPR(GPR),
+    Memory(GPR, i32),
+}
+
+pub enum Precision {
+    Single,
+    Double,
+}
+
+pub trait EmitterX64 {
+    fn get_simd_arch(&self) -> Option<&CpuFeature>;
+    fn get_label(&mut self) -> Label;
+    fn get_offset(&self) -> Offset;
+    fn get_jmp_instr_size(&self) -> u8;
+
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        Ok(())
+    }
+
+    fn emit_u64(&mut self, x: u64) -> Result<(), CompileError>;
+    fn emit_bytes(&mut self, bytes: &[u8]) -> Result<(), CompileError>;
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError>;
+
+    fn emit_nop(&mut self) -> Result<(), CompileError>;
+
+    /// A high-level assembler method. Emits an instruction sequence of length `n` that is functionally
+    /// equivalent to a `nop` instruction, without guarantee about the underlying implementation.
+    fn emit_nop_n(&mut self, n: usize) -> Result<(), CompileError>;
+
+    fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_lea(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_lea_label(&mut self, label: Label, dst: Location) -> Result<(), CompileError>;
+    fn emit_cdq(&mut self) -> Result<(), CompileError>;
+    fn emit_cqo(&mut self) -> Result<(), CompileError>;
+    fn emit_xor(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_jmp(&mut self, condition: Condition, label: Label) -> Result<(), CompileError>;
+    fn emit_jmp_location(&mut self, loc: Location) -> Result<(), CompileError>;
+    fn emit_set(&mut self, condition: Condition, dst: GPR) -> Result<(), CompileError>;
+    fn emit_push(&mut self, sz: Size, src: Location) -> Result<(), CompileError>;
+    fn emit_pop(&mut self, sz: Size, dst: Location) -> Result<(), CompileError>;
+    fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) -> Result<(), CompileError>;
+    fn emit_add(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_sub(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_neg(&mut self, sz: Size, value: Location) -> Result<(), CompileError>;
+    fn emit_imul(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_imul_imm32_gpr64(&mut self, src: u32, dst: GPR) -> Result<(), CompileError>;
+    fn emit_div(&mut self, sz: Size, divisor: Location) -> Result<(), CompileError>;
+    fn emit_idiv(&mut self, sz: Size, divisor: Location) -> Result<(), CompileError>;
+    fn emit_shl(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_shr(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_sar(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_rol(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_ror(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_and(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_test(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_or(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_bsr(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_bsf(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_popcnt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_movzx(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_movsx(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_xchg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError>;
+    fn emit_lock_xadd(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_lock_cmpxchg(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError>;
+    fn emit_rep_stosq(&mut self) -> Result<(), CompileError>;
+
+    fn emit_btc_gpr_imm8_32(&mut self, src: u8, dst: GPR) -> Result<(), CompileError>;
+    fn emit_btc_gpr_imm8_64(&mut self, src: u8, dst: GPR) -> Result<(), CompileError>;
+
+    fn emit_cmovae_gpr_32(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError>;
+    fn emit_cmovae_gpr_64(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError>;
+
+    fn emit_vmovaps(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError>;
+    fn emit_vmovapd(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError>;
+    fn emit_vxorps(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vxorpd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+
+    fn emit_vaddss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vaddsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vsubss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vsubsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vmulss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vmulsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vdivss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vdivsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vmaxss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vmaxsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vminss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vminsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+
+    fn emit_vcmpeqss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+    fn emit_vcmpeqsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+
+    fn emit_vcmpneqss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcmpneqsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_vcmpltss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+    fn emit_vcmpltsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+
+    fn emit_vcmpless(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+    fn emit_vcmplesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+
+    fn emit_vcmpgtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+    fn emit_vcmpgtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+
+    fn emit_vcmpgess(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+    fn emit_vcmpgesd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM)
+        -> Result<(), CompileError>;
+
+    fn emit_vcmpunordss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcmpunordsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_vcmpordss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcmpordsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_vsqrtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_vsqrtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+
+    fn emit_vroundss_nearest(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundss_floor(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundss_ceil(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundss_trunc(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundsd_nearest(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundsd_floor(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundsd_ceil(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vroundsd_trunc(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_vcvtss2sd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcvtsd2ss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_ucomiss(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+    fn emit_ucomisd(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError>;
+
+    fn emit_cvttss2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError>;
+    fn emit_cvttss2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError>;
+    fn emit_cvttsd2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError>;
+    fn emit_cvttsd2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError>;
+
+    fn emit_vcvtsi2ss_32(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcvtsi2ss_64(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcvtsi2sd_32(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vcvtsi2sd_64(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_vblendvps(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        mask: XMM,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+    fn emit_vblendvpd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        mask: XMM,
+        dst: XMM,
+    ) -> Result<(), CompileError>;
+
+    fn emit_test_gpr_64(&mut self, reg: GPR) -> Result<(), CompileError>;
+
+    fn emit_ud2(&mut self) -> Result<(), CompileError>;
+    fn emit_ud1_payload(&mut self, payload: u8) -> Result<(), CompileError>;
+    fn emit_ret(&mut self) -> Result<(), CompileError>;
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError>;
+    fn emit_call_location(&mut self, loc: Location) -> Result<(), CompileError>;
+
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError>;
+
+    fn emit_bkpt(&mut self) -> Result<(), CompileError>;
+
+    fn emit_host_redirection(&mut self, target: GPR) -> Result<(), CompileError>;
+
+    fn arch_has_itruncf(&self) -> bool {
+        false
+    }
+    fn arch_emit_i32_trunc_sf32(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i32_trunc_sf32 unimplemented")
+    }
+    fn arch_emit_i32_trunc_sf64(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i32_trunc_sf64 unimplemented")
+    }
+    fn arch_emit_i32_trunc_uf32(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i32_trunc_uf32 unimplemented")
+    }
+    fn arch_emit_i32_trunc_uf64(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i32_trunc_uf64 unimplemented")
+    }
+    fn arch_emit_i64_trunc_sf32(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i64_trunc_sf32 unimplemented")
+    }
+    fn arch_emit_i64_trunc_sf64(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i64_trunc_sf64 unimplemented")
+    }
+    fn arch_emit_i64_trunc_uf32(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i64_trunc_uf32 unimplemented")
+    }
+    fn arch_emit_i64_trunc_uf64(&mut self, _src: XMM, _dst: GPR) -> Result<(), CompileError> {
+        codegen_error!("singplepass arch_emit_i64_trunc_uf64 unimplemented")
+    }
+
+    fn arch_has_fconverti(&self) -> bool {
+        false
+    }
+    fn arch_emit_f32_convert_si32(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f32_convert_si32 unimplemented")
+    }
+    fn arch_emit_f32_convert_si64(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f32_convert_si64 unimplemented")
+    }
+    fn arch_emit_f32_convert_ui32(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f32_convert_ui32 unimplemented")
+    }
+    fn arch_emit_f32_convert_ui64(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f32_convert_ui64 unimplemented")
+    }
+    fn arch_emit_f64_convert_si32(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f64_convert_si32 unimplemented")
+    }
+    fn arch_emit_f64_convert_si64(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f64_convert_si64 unimplemented")
+    }
+    fn arch_emit_f64_convert_ui32(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f64_convert_ui32 unimplemented")
+    }
+    fn arch_emit_f64_convert_ui64(&mut self, _src: GPR, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f64_convert_ui64 unimplemented")
+    }
+
+    fn arch_has_fneg(&self) -> bool {
+        false
+    }
+    fn arch_emit_f32_neg(&mut self, _src: XMM, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f32_neg unimplemented")
+    }
+    fn arch_emit_f64_neg(&mut self, _src: XMM, _dst: XMM) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_f64_neg unimplemented")
+    }
+
+    fn arch_has_xzcnt(&self) -> bool {
+        false
+    }
+    fn arch_emit_lzcnt(
+        &mut self,
+        _sz: Size,
+        _src: Location,
+        _dst: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_lzcnt unimplemented")
+    }
+    fn arch_emit_tzcnt(
+        &mut self,
+        _sz: Size,
+        _src: Location,
+        _dst: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_tzcnt unimplemented")
+    }
+
+    fn arch_supports_canonicalize_nan(&self) -> bool {
+        true
+    }
+
+    fn arch_requires_indirect_call_trampoline(&self) -> bool {
+        false
+    }
+
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        _loc: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass arch_emit_indirect_call_with_trampoline unimplemented")
+    }
+
+    // Emits entry trampoline just before the real function.
+    fn arch_emit_entry_trampoline(&mut self) -> Result<(), CompileError> {
+        Ok(())
+    }
+
+    // Byte offset from the beginning of a `mov Imm64, GPR` instruction to the imm64 value.
+    // Required to support emulation on Aarch64.
+    fn arch_mov64_imm_offset(&self) -> Result<usize, CompileError> {
+        codegen_error!("singlepass arch_mov64_imm_offset unimplemented")
+    }
+}
+
+macro_rules! unop_gpr {
+    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+        match ($sz, $loc) {
+            (Size::S32, Location::GPR(loc)) => {
+                dynasm!($assembler ; $ins Rd(loc as u8));
+            },
+            (Size::S64, Location::GPR(loc)) => {
+                dynasm!($assembler ; $ins Rq(loc as u8));
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! unop_mem {
+    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+        match ($sz, $loc) {
+            (Size::S32, Location::Memory(loc, disp)) => {
+                dynasm!($assembler ; $ins DWORD [Rq(loc as u8) + disp] );
+            },
+            (Size::S64, Location::Memory(loc, disp)) => {
+                dynasm!($assembler ; $ins QWORD [Rq(loc as u8) + disp] );
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! unop_gpr_or_mem {
+    ($ins:ident, $assembler:tt, $sz:expr, $loc:expr, $otherwise:block) => {
+        unop_gpr!($ins, $assembler, $sz, $loc, {
+            unop_mem!($ins, $assembler, $sz, $loc, $otherwise)
+        })
+    };
+}
+
+macro_rules! binop_imm32_gpr {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::Imm32(src), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rd(dst as u8), src as i32); // IMM32_2GPR
+            },
+            (Size::S64, Location::Imm32(src), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), src as i32); // IMM32_2GPR
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_imm32_mem {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::Imm32(src), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], src as i32);
+            },
+            (Size::S64, Location::Imm32(src), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], src as i32);
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_imm64_gpr {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S64, Location::Imm64(src), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), QWORD src as i64); // IMM32_2GPR
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_gpr_gpr {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rd(dst as u8), Rd(src as u8)); // GPR2GPR
+            },
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), Rq(src as u8)); // GPR2GPR
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_gpr_mem {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rd(src as u8)); // GPR2MEM
+            },
+            (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins [Rq(dst as u8) + disp], Rq(src as u8)); // GPR2MEM
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_mem_gpr {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rd(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR
+            },
+            (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), [Rq(src as u8) + disp]); // MEM2GPR
+            },
+            _ => $otherwise
+        }
+    };
+}
+
+macro_rules! binop_all_nofp {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        binop_imm32_gpr!($ins, $assembler, $sz, $src, $dst, {
+            binop_imm32_mem!($ins, $assembler, $sz, $src, $dst, {
+                binop_gpr_gpr!($ins, $assembler, $sz, $src, $dst, {
+                    binop_gpr_mem!($ins, $assembler, $sz, $src, $dst, {
+                        binop_mem_gpr!($ins, $assembler, $sz, $src, $dst, $otherwise)
+                    })
+                })
+            })
+        })
+    };
+}
+
+macro_rules! binop_shift {
+    ($ins:ident, $assembler:tt, $sz:expr, $src:expr, $dst:expr, $otherwise:block) => {
+        match ($sz, $src, $dst) {
+            (Size::S32, Location::GPR(GPR::RCX), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rd(dst as u8), cl);
+            },
+            (Size::S32, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], cl);
+            },
+            (Size::S32, Location::Imm8(imm), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rd(dst as u8), imm as i8);
+            },
+            (Size::S32, Location::Imm8(imm), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins DWORD [Rq(dst as u8) + disp], imm as i8);
+            },
+            (Size::S64, Location::GPR(GPR::RCX), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), cl);
+            },
+            (Size::S64, Location::GPR(GPR::RCX), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], cl);
+            },
+            (Size::S64, Location::Imm8(imm), Location::GPR(dst)) => {
+                dynasm!($assembler ; $ins Rq(dst as u8), imm as i8);
+            },
+            (Size::S64, Location::Imm8(imm), Location::Memory(dst, disp)) => {
+                dynasm!($assembler ; $ins QWORD [Rq(dst as u8) + disp], imm as i8);
+            },
+            _ => $otherwise
+        }
+    }
+}
+
+macro_rules! jmp_op {
+    ($ins:ident, $assembler:tt, $label:ident) => {
+        dynasm!($assembler ; $ins =>$label)
+    }
+}
+
+/// Move a single or double precision XMM value to another if src and destination
+/// are not the same.
+///
+/// TODO: Can we assume data is aligned and packed? If so, this function isn't necessary
+/// TODO: as we can use [`EmitterX64::emit_vmovaps`] and [`EmitterX64::emit_vmovadp`]
+/// TODO: instead
+fn move_src_to_dst(emitter: &mut AssemblerX64, precision: Precision, src: XMM, dst: XMM) {
+    if src == dst {
+        return;
+    }
+    match precision {
+        Precision::Single => match src {
+            XMM::XMM0 => dynasm!(emitter ; movss Rx((dst as u8)), xmm0),
+            XMM::XMM1 => dynasm!(emitter ; movss Rx((dst as u8)), xmm1),
+            XMM::XMM2 => dynasm!(emitter ; movss Rx((dst as u8)), xmm2),
+            XMM::XMM3 => dynasm!(emitter ; movss Rx((dst as u8)), xmm3),
+            XMM::XMM4 => dynasm!(emitter ; movss Rx((dst as u8)), xmm4),
+            XMM::XMM5 => dynasm!(emitter ; movss Rx((dst as u8)), xmm5),
+            XMM::XMM6 => dynasm!(emitter ; movss Rx((dst as u8)), xmm6),
+            XMM::XMM7 => dynasm!(emitter ; movss Rx((dst as u8)), xmm7),
+            XMM::XMM8 => dynasm!(emitter ; movss Rx((dst as u8)), xmm8),
+            XMM::XMM9 => dynasm!(emitter ; movss Rx((dst as u8)), xmm9),
+            XMM::XMM10 => dynasm!(emitter ; movss Rx((dst as u8)), xmm10),
+            XMM::XMM11 => dynasm!(emitter ; movss Rx((dst as u8)), xmm11),
+            XMM::XMM12 => dynasm!(emitter ; movss Rx((dst as u8)), xmm12),
+            XMM::XMM13 => dynasm!(emitter ; movss Rx((dst as u8)), xmm13),
+            XMM::XMM14 => dynasm!(emitter ; movss Rx((dst as u8)), xmm14),
+            XMM::XMM15 => dynasm!(emitter ; movss Rx((dst as u8)), xmm15),
+        },
+        Precision::Double => match src {
+            XMM::XMM0 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm0),
+            XMM::XMM1 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm1),
+            XMM::XMM2 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm2),
+            XMM::XMM3 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm3),
+            XMM::XMM4 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm4),
+            XMM::XMM5 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm5),
+            XMM::XMM6 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm6),
+            XMM::XMM7 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm7),
+            XMM::XMM8 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm8),
+            XMM::XMM9 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm9),
+            XMM::XMM10 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm10),
+            XMM::XMM11 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm11),
+            XMM::XMM12 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm12),
+            XMM::XMM13 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm13),
+            XMM::XMM14 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm14),
+            XMM::XMM15 => dynasm!(emitter ; movsd Rx((dst as u8)), xmm15),
+        },
+    }
+}
+
+macro_rules! avx_fn {
+    ($ins:ident, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
+        // Dynasm bug: AVX instructions are not encoded correctly.
+        match $src2 {
+            XMMOrMemory::XMM(x) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rx((x as u8))),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rx((x as u8))),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rx((x as u8))),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rx((x as u8))),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rx((x as u8))),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rx((x as u8))),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rx((x as u8))),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rx((x as u8))),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rx((x as u8))),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rx((x as u8))),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rx((x as u8))),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rx((x as u8))),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rx((x as u8))),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rx((x as u8))),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rx((x as u8))),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rx((x as u8))),
+            },
+            XMMOrMemory::Memory(base, disp) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, [Rq((base as u8)) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, [Rq((base as u8)) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, [Rq((base as u8)) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, [Rq((base as u8)) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, [Rq((base as u8)) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, [Rq((base as u8)) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, [Rq((base as u8)) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, [Rq((base as u8)) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, [Rq((base as u8)) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, [Rq((base as u8)) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, [Rq((base as u8)) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, [Rq((base as u8)) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, [Rq((base as u8)) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, [Rq((base as u8)) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, [Rq((base as u8)) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, [Rq((base as u8)) + disp]),
+            },
+        }
+    }
+}
+
+macro_rules! sse_fn {
+    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            XMMOrMemory::XMM(x) => {
+                if x == $dst {
+                    dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)))
+                } else {
+                    move_src_to_dst($emitter, $precision, $src1, $dst);
+                    dynasm!($emitter ; $ins Rx(($dst as u8)), Rx((x as u8)))
+                }
+            }
+            XMMOrMemory::Memory(base, disp) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp])
+            }
+        }
+    };
+    ($ins:ident, $mode:expr, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            XMMOrMemory::XMM(x) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter ; $ins Rx(($dst as u8)), Rx((x as u8)), $mode)
+            }
+            XMMOrMemory::Memory(base, disp) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp], $mode)
+            }
+        }
+    };
+}
+
+macro_rules! avx_i2f_64_fn {
+    ($ins:ident, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            GPROrMemory::GPR(x) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rq((x as u8))),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rq((x as u8))),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rq((x as u8))),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rq((x as u8))),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rq((x as u8))),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rq((x as u8))),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rq((x as u8))),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rq((x as u8))),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rq((x as u8))),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rq((x as u8))),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rq((x as u8))),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rq((x as u8))),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rq((x as u8))),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rq((x as u8))),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rq((x as u8))),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rq((x as u8))),
+            },
+            GPROrMemory::Memory(base, disp) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, QWORD [Rq((base as u8)) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, QWORD [Rq((base as u8)) + disp]),
+            },
+        }
+    }
+}
+
+macro_rules! sse_i2f_64_fn {
+    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            GPROrMemory::GPR(x) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter ; $ins Rx(($dst as u8)), Rq((x as u8)))
+            },
+            GPROrMemory::Memory(base, disp) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter ; $ins Rx(($dst as u8)), QWORD [Rq((base as u8)) + disp])
+            }
+        }
+    }
+}
+
+macro_rules! avx_i2f_32_fn {
+    ($ins:ident, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            GPROrMemory::GPR(x) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, Rd((x as u8))),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, Rd((x as u8))),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, Rd((x as u8))),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, Rd((x as u8))),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, Rd((x as u8))),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, Rd((x as u8))),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, Rd((x as u8))),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, Rd((x as u8))),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, Rd((x as u8))),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, Rd((x as u8))),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, Rd((x as u8))),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, Rd((x as u8))),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, Rd((x as u8))),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, Rd((x as u8))),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, Rd((x as u8))),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, Rd((x as u8))),
+            },
+            GPROrMemory::Memory(base, disp) => match $src1 {
+                XMM::XMM0 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm0, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM1 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm1, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM2 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm2, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM3 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm3, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM4 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm4, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM5 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm5, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM6 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm6, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM7 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm7, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM8 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm8, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM9 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm9, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM10 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm10, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM11 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm11, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM12 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm12, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM13 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm13, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM14 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm14, DWORD [Rq((base as u8)) + disp]),
+                XMM::XMM15 => dynasm!($emitter ; $ins Rx(($dst as u8)), xmm15, DWORD [Rq((base as u8)) + disp]),
+            },
+        }
+    }
+}
+
+macro_rules! sse_i2f_32_fn {
+    ($ins:ident, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            GPROrMemory::GPR(x) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter; $ins Rx(($src1 as u8)), Rd((x as u8)))
+            },
+            GPROrMemory::Memory(base, disp) => {
+                move_src_to_dst($emitter, $precision, $src1, $dst);
+                dynasm!($emitter; $ins Rx(($dst as u8)), DWORD [Rq((base as u8)) + disp])
+            }
+        }
+    }
+}
+
+macro_rules! avx_round_fn {
+    ($ins:ident, $mode:expr, $emitter:ident, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            XMMOrMemory::XMM(x) => dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)), Rx((x as u8)), $mode),
+            XMMOrMemory::Memory(base, disp) => dynasm!($emitter ; $ins Rx(($dst as u8)), Rx(($src1 as u8)), [Rq((base as u8)) + disp], $mode),
+        }
+    }
+}
+
+macro_rules! sse_round_fn {
+    ($ins:ident, $mode:expr, $emitter:ident, $precision:expr, $src1:ident, $src2:ident, $dst:ident) => {
+        match $src2 {
+            XMMOrMemory::XMM(x) => {
+                if x != $dst {
+                    move_src_to_dst($emitter, $precision, $src1, $dst);
+                }
+                dynasm!($emitter ; $ins Rx((x as u8)), Rx(($dst as u8)), $mode)
+            }
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!($emitter ; $ins Rx(($dst as u8)), [Rq((base as u8)) + disp], $mode)
+            },
+        }
+    }
+}
+
+impl EmitterX64 for AssemblerX64 {
+    fn get_simd_arch(&self) -> Option<&CpuFeature> {
+        self.simd_arch.as_ref()
+    }
+
+    fn get_label(&mut self) -> DynamicLabel {
+        self.new_dynamic_label()
+    }
+
+    fn get_offset(&self) -> AssemblyOffset {
+        self.offset()
+    }
+
+    fn get_jmp_instr_size(&self) -> u8 {
+        5
+    }
+
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        dynasm!(
+            self
+            ; const_neg_one_32:
+            ; .dword -1
+            ; const_zero_32:
+            ; .dword 0
+            ; const_pos_one_32:
+            ; .dword 1
+        );
+        Ok(())
+    }
+
+    fn arch_has_xzcnt(&self) -> bool {
+        match &self.target {
+            Some(target) => {
+                target.cpu_features().contains(CpuFeature::LZCNT)
+                    && target.cpu_features().contains(CpuFeature::BMI1)
+            }
+            None => false,
+        }
+    }
+
+    fn arch_emit_lzcnt(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        binop_gpr_gpr!(lzcnt, self, sz, src, dst, {
+            binop_mem_gpr!(lzcnt, self, sz, src, dst, {
+                codegen_error!("singlepass cannot emit lzcnt")
+            })
+        });
+        Ok(())
+    }
+
+    fn arch_emit_tzcnt(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        binop_gpr_gpr!(tzcnt, self, sz, src, dst, {
+            binop_mem_gpr!(tzcnt, self, sz, src, dst, {
+                codegen_error!("singlepass cannot emit tzcnt")
+            })
+        });
+        Ok(())
+    }
+
+    fn emit_u64(&mut self, x: u64) -> Result<(), CompileError> {
+        self.push_u64(x);
+        Ok(())
+    }
+
+    fn emit_bytes(&mut self, bytes: &[u8]) -> Result<(), CompileError> {
+        for &b in bytes {
+            self.push(b);
+        }
+        Ok(())
+    }
+
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; => label);
+        Ok(())
+    }
+
+    fn emit_nop(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; nop);
+        Ok(())
+    }
+
+    fn emit_nop_n(&mut self, mut n: usize) -> Result<(), CompileError> {
+        /*
+            1      90H                            NOP
+            2      66 90H                         66 NOP
+            3      0F 1F 00H                      NOP DWORD ptr [EAX]
+            4      0F 1F 40 00H                   NOP DWORD ptr [EAX + 00H]
+            5      0F 1F 44 00 00H                NOP DWORD ptr [EAX + EAX*1 + 00H]
+            6      66 0F 1F 44 00 00H             NOP DWORD ptr [AX + AX*1 + 00H]
+            7      0F 1F 80 00 00 00 00H          NOP DWORD ptr [EAX + 00000000H]
+            8      0F 1F 84 00 00 00 00 00H       NOP DWORD ptr [AX + AX*1 + 00000000H]
+            9      66 0F 1F 84 00 00 00 00 00H    NOP DWORD ptr [AX + AX*1 + 00000000H]
+        */
+        while n >= 9 {
+            n -= 9;
+            self.emit_bytes(&[0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00])?;
+            // 9-byte nop
+        }
+        let seq: &[u8] = match n {
+            0 => &[],
+            1 => &[0x90],
+            2 => &[0x66, 0x90],
+            3 => &[0x0f, 0x1f, 0x00],
+            4 => &[0x0f, 0x1f, 0x40, 0x00],
+            5 => &[0x0f, 0x1f, 0x44, 0x00, 0x00],
+            6 => &[0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00],
+            7 => &[0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00],
+            8 => &[0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00],
+            _ => codegen_error!("singlepass emit_nop_n unreachable"),
+        };
+        self.emit_bytes(seq)
+    }
+
+    fn emit_mov(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        // fast path
+        if let (Location::Imm32(0), Location::GPR(x)) = (src, dst) {
+            dynasm!(self ; xor Rd(x as u8), Rd(x as u8));
+            return Ok(());
+        }
+
+        binop_all_nofp!(mov, self, sz, src, dst, {
+            binop_imm64_gpr!(mov, self, sz, src, dst, {
+                match (sz, src, dst) {
+                    (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov [Rq(dst as u8) + disp], Rb(src as u8));
+                    }
+                    (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rb(dst as u8), [Rq(src as u8) + disp]);
+                    }
+                    (Size::S8, Location::Imm32(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rb(dst as u8), src as i8);
+                    }
+                    (Size::S8, Location::Imm64(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rb(dst as u8), src as i8);
+                    }
+                    (Size::S8, Location::Imm32(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8);
+                    }
+                    (Size::S8, Location::Imm64(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov BYTE [Rq(dst as u8) + disp], src as i8);
+                    }
+                    (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov [Rq(dst as u8) + disp], Rw(src as u8));
+                    }
+                    (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rw(dst as u8), [Rq(src as u8) + disp]);
+                    }
+                    (Size::S16, Location::Imm32(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rw(dst as u8), src as i16);
+                    }
+                    (Size::S16, Location::Imm64(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rw(dst as u8), src as i16);
+                    }
+                    (Size::S16, Location::Imm32(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16);
+                    }
+                    (Size::S16, Location::Imm64(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov WORD [Rq(dst as u8) + disp], src as i16);
+                    }
+                    (Size::S32, Location::Imm64(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                    }
+                    (Size::S32, Location::Imm64(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; mov DWORD [Rq(dst as u8) + disp], src as i32);
+                    }
+                    (Size::S32, Location::GPR(src), Location::SIMD(dst)) => {
+                        dynasm!(self ; movd Rx(dst as u8), Rd(src as u8));
+                    }
+                    (Size::S32, Location::SIMD(src), Location::GPR(dst)) => {
+                        dynasm!(self ; movd Rd(dst as u8), Rx(src as u8));
+                    }
+                    (Size::S32, Location::Memory(src, disp), Location::SIMD(dst)) => {
+                        dynasm!(self ; movd Rx(dst as u8), [Rq(src as u8) + disp]);
+                    }
+                    (Size::S32, Location::SIMD(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; movd [Rq(dst as u8) + disp], Rx(src as u8));
+                    }
+                    (Size::S64, Location::Imm64(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                    }
+                    (Size::S64, Location::Imm32(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                    }
+                    (Size::S64, Location::Imm8(src), Location::GPR(dst)) => {
+                        dynasm!(self ; mov Rd(dst as u8), src as i32);
+                    }
+
+                    (Size::S64, Location::GPR(src), Location::SIMD(dst)) => {
+                        dynasm!(self ; movq Rx(dst as u8), Rq(src as u8));
+                    }
+                    (Size::S64, Location::SIMD(src), Location::GPR(dst)) => {
+                        dynasm!(self ; movq Rq(dst as u8), Rx(src as u8));
+                    }
+                    (Size::S64, Location::Memory(src, disp), Location::SIMD(dst)) => {
+                        dynasm!(self ; movq Rx(dst as u8), [Rq(src as u8) + disp]);
+                    }
+                    (Size::S64, Location::SIMD(src), Location::Memory(dst, disp)) => {
+                        dynasm!(self ; movq [Rq(dst as u8) + disp], Rx(src as u8));
+                    }
+                    (_, Location::SIMD(src), Location::SIMD(dst)) => {
+                        dynasm!(self ; movq Rx(dst as u8), Rx(src as u8));
+                    }
+
+                    _ => codegen_error!("singlepass can't emit MOV {:?} {:?} {:?}", sz, src, dst),
+                }
+            })
+        });
+        Ok(())
+    }
+    fn emit_lea(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; lea Rd(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; lea Rq(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S32, Location::Memory2(src1, src2, mult, disp), Location::GPR(dst)) => {
+                match mult {
+                    Multiplier::Zero => dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + disp]),
+                    Multiplier::One => {
+                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp])
+                    }
+                    Multiplier::Two => {
+                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 2 + disp])
+                    }
+                    Multiplier::Four => {
+                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 4 + disp])
+                    }
+                    Multiplier::Height => {
+                        dynasm!(self ; lea Rd(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 8 + disp])
+                    }
+                };
+            }
+            (Size::S64, Location::Memory2(src1, src2, mult, disp), Location::GPR(dst)) => {
+                match mult {
+                    Multiplier::Zero => dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + disp]),
+                    Multiplier::One => {
+                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) + disp])
+                    }
+                    Multiplier::Two => {
+                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 2 + disp])
+                    }
+                    Multiplier::Four => {
+                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 4 + disp])
+                    }
+                    Multiplier::Height => {
+                        dynasm!(self ; lea Rq(dst as u8), [Rq(src1 as u8) + Rq(src2 as u8) * 8 + disp])
+                    }
+                };
+            }
+            _ => codegen_error!("singlepass can't emit LEA {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+    fn emit_lea_label(&mut self, label: Label, dst: Location) -> Result<(), CompileError> {
+        match dst {
+            Location::GPR(x) => {
+                dynasm!(self ; lea Rq(x as u8), [=>label]);
+            }
+            _ => codegen_error!("singlepass can't emit LEA label={:?} {:?}", label, dst),
+        }
+        Ok(())
+    }
+    fn emit_cdq(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; cdq);
+        Ok(())
+    }
+    fn emit_cqo(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; cqo);
+        Ok(())
+    }
+    fn emit_xor(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_all_nofp!(xor, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit XOR {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_jmp(&mut self, condition: Condition, label: Label) -> Result<(), CompileError> {
+        match condition {
+            Condition::None => jmp_op!(jmp, self, label),
+            Condition::Above => jmp_op!(ja, self, label),
+            Condition::AboveEqual => jmp_op!(jae, self, label),
+            Condition::Below => jmp_op!(jb, self, label),
+            Condition::BelowEqual => jmp_op!(jbe, self, label),
+            Condition::Greater => jmp_op!(jg, self, label),
+            Condition::GreaterEqual => jmp_op!(jge, self, label),
+            Condition::Less => jmp_op!(jl, self, label),
+            Condition::LessEqual => jmp_op!(jle, self, label),
+            Condition::Equal => jmp_op!(je, self, label),
+            Condition::NotEqual => jmp_op!(jne, self, label),
+            Condition::Signed => jmp_op!(js, self, label),
+            Condition::Carry => jmp_op!(jc, self, label),
+        }
+        Ok(())
+    }
+    fn emit_jmp_location(&mut self, loc: Location) -> Result<(), CompileError> {
+        match loc {
+            Location::GPR(x) => dynasm!(self ; jmp Rq(x as u8)),
+            Location::Memory(base, disp) => dynasm!(self ; jmp QWORD [Rq(base as u8) + disp]),
+            _ => codegen_error!("singlepass can't emit JMP {:?}", loc),
+        }
+        Ok(())
+    }
+    fn emit_set(&mut self, condition: Condition, dst: GPR) -> Result<(), CompileError> {
+        match condition {
+            Condition::Above => dynasm!(self ; seta Rb(dst as u8)),
+            Condition::AboveEqual => dynasm!(self ; setae Rb(dst as u8)),
+            Condition::Below => dynasm!(self ; setb Rb(dst as u8)),
+            Condition::BelowEqual => dynasm!(self ; setbe Rb(dst as u8)),
+            Condition::Greater => dynasm!(self ; setg Rb(dst as u8)),
+            Condition::GreaterEqual => dynasm!(self ; setge Rb(dst as u8)),
+            Condition::Less => dynasm!(self ; setl Rb(dst as u8)),
+            Condition::LessEqual => dynasm!(self ; setle Rb(dst as u8)),
+            Condition::Equal => dynasm!(self ; sete Rb(dst as u8)),
+            Condition::NotEqual => dynasm!(self ; setne Rb(dst as u8)),
+            Condition::Signed => dynasm!(self ; sets Rb(dst as u8)),
+            Condition::Carry => dynasm!(self ; setc Rb(dst as u8)),
+            _ => codegen_error!("singlepass can't emit SET {:?} {:?}", condition, dst),
+        }
+        Ok(())
+    }
+    fn emit_push(&mut self, sz: Size, src: Location) -> Result<(), CompileError> {
+        match (sz, src) {
+            (Size::S64, Location::Imm32(src)) => dynasm!(self ; push src as i32),
+            (Size::S64, Location::GPR(src)) => dynasm!(self ; push Rq(src as u8)),
+            (Size::S64, Location::Memory(src, disp)) => {
+                dynasm!(self ; push QWORD [Rq(src as u8) + disp])
+            }
+            _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", sz, src),
+        }
+        Ok(())
+    }
+    fn emit_pop(&mut self, sz: Size, dst: Location) -> Result<(), CompileError> {
+        match (sz, dst) {
+            (Size::S64, Location::GPR(dst)) => dynasm!(self ; pop Rq(dst as u8)),
+            (Size::S64, Location::Memory(dst, disp)) => {
+                dynasm!(self ; pop QWORD [Rq(dst as u8) + disp])
+            }
+            _ => codegen_error!("singlepass can't emit POP {:?} {:?}", sz, dst),
+        }
+        Ok(())
+    }
+    fn emit_cmp(&mut self, sz: Size, left: Location, right: Location) -> Result<(), CompileError> {
+        // Constant elimination for comparison between consts.
+        //
+        // Only needed for `emit_cmp`, since other binary operators actually write to `right` and `right` must
+        // be a writable location for them.
+        let consts = match (left, right) {
+            (Location::Imm32(x), Location::Imm32(y)) => Some((x as i32 as i64, y as i32 as i64)),
+            (Location::Imm32(x), Location::Imm64(y)) => Some((x as i32 as i64, y as i64)),
+            (Location::Imm64(x), Location::Imm32(y)) => Some((x as i64, y as i32 as i64)),
+            (Location::Imm64(x), Location::Imm64(y)) => Some((x as i64, y as i64)),
+            _ => None,
+        };
+        use std::cmp::Ordering;
+        match consts {
+            Some((x, y)) => match x.cmp(&y) {
+                Ordering::Less => dynasm!(self ; cmp DWORD [>const_neg_one_32], 0),
+                Ordering::Equal => dynasm!(self ; cmp DWORD [>const_zero_32], 0),
+                Ordering::Greater => dynasm!(self ; cmp DWORD [>const_pos_one_32], 0),
+            },
+            None => binop_all_nofp!(cmp, self, sz, left, right, {
+                codegen_error!("singlepass can't emit CMP {:?} {:?} {:?}", sz, left, right);
+            }),
+        }
+        Ok(())
+    }
+    fn emit_add(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        // Fast path
+        if let Location::Imm32(0) = src {
+            return Ok(());
+        }
+        binop_all_nofp!(add, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit ADD {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_sub(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        // Fast path
+        if let Location::Imm32(0) = src {
+            return Ok(());
+        }
+        binop_all_nofp!(sub, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit SUB {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_neg(&mut self, sz: Size, value: Location) -> Result<(), CompileError> {
+        match (sz, value) {
+            (Size::S8, Location::GPR(value)) => dynasm!(self ; neg Rb(value as u8)),
+            (Size::S8, Location::Memory(value, disp)) => {
+                dynasm!(self ; neg [Rq(value as u8) + disp])
+            }
+            (Size::S16, Location::GPR(value)) => dynasm!(self ; neg Rw(value as u8)),
+            (Size::S16, Location::Memory(value, disp)) => {
+                dynasm!(self ; neg [Rq(value as u8) + disp])
+            }
+            (Size::S32, Location::GPR(value)) => dynasm!(self ; neg Rd(value as u8)),
+            (Size::S32, Location::Memory(value, disp)) => {
+                dynasm!(self ; neg [Rq(value as u8) + disp])
+            }
+            (Size::S64, Location::GPR(value)) => dynasm!(self ; neg Rq(value as u8)),
+            (Size::S64, Location::Memory(value, disp)) => {
+                dynasm!(self ; neg [Rq(value as u8) + disp])
+            }
+            _ => codegen_error!("singlepass can't emit NEG {:?} {:?}", sz, value),
+        }
+        Ok(())
+    }
+    fn emit_imul(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_gpr_gpr!(imul, self, sz, src, dst, {
+            binop_mem_gpr!(imul, self, sz, src, dst, {
+                codegen_error!("singlepass can't emit IMUL {:?} {:?} {:?}", sz, src, dst)
+            })
+        });
+        Ok(())
+    }
+    fn emit_imul_imm32_gpr64(&mut self, src: u32, dst: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; imul Rq(dst as u8), Rq(dst as u8), src as i32);
+        Ok(())
+    }
+    fn emit_div(&mut self, sz: Size, divisor: Location) -> Result<(), CompileError> {
+        unop_gpr_or_mem!(div, self, sz, divisor, {
+            codegen_error!("singlepass can't emit DIV {:?} {:?}", sz, divisor)
+        });
+        Ok(())
+    }
+    fn emit_idiv(&mut self, sz: Size, divisor: Location) -> Result<(), CompileError> {
+        unop_gpr_or_mem!(idiv, self, sz, divisor, {
+            codegen_error!("singlepass can't emit IDIV {:?} {:?}", sz, divisor)
+        });
+        Ok(())
+    }
+    fn emit_shl(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_shift!(shl, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit SHL {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_shr(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_shift!(shr, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit SHR {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_sar(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_shift!(sar, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit SAR {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_rol(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_shift!(rol, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit ROL {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_ror(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_shift!(ror, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit ROR {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_and(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_all_nofp!(and, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit AND {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_test(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_all_nofp!(test, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit TEST {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_or(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_all_nofp!(or, self, sz, src, dst, {
+            codegen_error!("singlepass can't emit OR {:?} {:?} {:?}", sz, src, dst)
+        });
+        Ok(())
+    }
+    fn emit_bsr(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_gpr_gpr!(bsr, self, sz, src, dst, {
+            binop_mem_gpr!(bsr, self, sz, src, dst, {
+                codegen_error!("singlepass can't emit BSR {:?} {:?} {:?}", sz, src, dst)
+            })
+        });
+        Ok(())
+    }
+    fn emit_bsf(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_gpr_gpr!(bsf, self, sz, src, dst, {
+            binop_mem_gpr!(bsf, self, sz, src, dst, {
+                codegen_error!("singlepass can't emit BSF {:?} {:?} {:?}", sz, src, dst)
+            })
+        });
+        Ok(())
+    }
+    fn emit_popcnt(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        binop_gpr_gpr!(popcnt, self, sz, src, dst, {
+            binop_mem_gpr!(popcnt, self, sz, src, dst, {
+                codegen_error!("singlepass can't emit POPCNT {:?} {:?} {:?}", sz, src, dst)
+            })
+        });
+        Ok(())
+    }
+    fn emit_movzx(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_src, src, sz_dst, dst) {
+            (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rd(dst as u8), Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rd(dst as u8), Rw(src as u8));
+            }
+            (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rd(dst as u8), BYTE [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rd(dst as u8), WORD [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::Imm32(imm), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rd(dst as u8), imm as i32);
+            }
+            (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rq(dst as u8), Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rq(dst as u8), Rw(src as u8));
+            }
+            (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rq(dst as u8), BYTE [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movzx Rq(dst as u8), WORD [Rq(src as u8) + disp]);
+            }
+            (Size::S32, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                if src != dst {
+                    dynasm!(self ; mov Rd(dst as u8), Rd(src as u8));
+                }
+            }
+            (Size::S32, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rd(dst as u8), DWORD [Rq(src as u8) + disp]);
+            }
+            (Size::S8, Location::Imm32(imm), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            (Size::S16, Location::Imm32(imm), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            (Size::S32, Location::Imm32(imm), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            (Size::S8, Location::Imm64(imm), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            (Size::S16, Location::Imm64(imm), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            (Size::S32, Location::Imm64(imm), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; mov Rq(dst as u8), imm as i32);
+            }
+            _ => {
+                codegen_error!(
+                    "singlepass can't emit MOVZX {:?} {:?} {:?} {:?}",
+                    sz_src,
+                    src,
+                    sz_dst,
+                    dst
+                )
+            }
+        }
+        Ok(())
+    }
+    fn emit_movsx(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz_src, src, sz_dst, dst) {
+            (Size::S8, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rd(dst as u8), Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rd(dst as u8), Rw(src as u8));
+            }
+            (Size::S8, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rd(dst as u8), BYTE [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::Memory(src, disp), Size::S32, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rd(dst as u8), WORD [Rq(src as u8) + disp]);
+            }
+            (Size::S8, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), Rw(src as u8));
+            }
+            (Size::S32, Location::GPR(src), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), Rd(src as u8));
+            }
+            (Size::S8, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), BYTE [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), WORD [Rq(src as u8) + disp]);
+            }
+            (Size::S32, Location::Memory(src, disp), Size::S64, Location::GPR(dst)) => {
+                dynasm!(self ; movsx Rq(dst as u8), DWORD [Rq(src as u8) + disp]);
+            }
+            _ => {
+                codegen_error!(
+                    "singlepass can't emit MOVSX {:?} {:?} {:?} {:?}",
+                    sz_src,
+                    src,
+                    sz_dst,
+                    dst
+                )
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_xchg(&mut self, sz: Size, src: Location, dst: Location) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S8, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rb(dst as u8), Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rw(dst as u8), Rw(src as u8));
+            }
+            (Size::S32, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rd(dst as u8), Rd(src as u8));
+            }
+            (Size::S64, Location::GPR(src), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rq(dst as u8), Rq(src as u8));
+            }
+            (Size::S8, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rb(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rb(src as u8));
+            }
+            (Size::S16, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rw(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rw(src as u8));
+            }
+            (Size::S32, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rd(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rd(src as u8));
+            }
+            (Size::S64, Location::Memory(src, disp), Location::GPR(dst)) => {
+                dynasm!(self ; xchg Rq(dst as u8), [Rq(src as u8) + disp]);
+            }
+            (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; xchg [Rq(dst as u8) + disp], Rq(src as u8));
+            }
+            _ => codegen_error!("singlepass can't emit XCHG {:?} {:?} {:?}", sz, src, dst),
+        }
+        Ok(())
+    }
+
+    fn emit_lock_xadd(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rw(src as u8));
+            }
+            (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rd(src as u8));
+            }
+            (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock xadd [Rq(dst as u8) + disp], Rq(src as u8));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LOCK XADD {:?} {:?} {:?}",
+                sz,
+                src,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_lock_cmpxchg(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (sz, src, dst) {
+            (Size::S8, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rb(src as u8));
+            }
+            (Size::S16, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rw(src as u8));
+            }
+            (Size::S32, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rd(src as u8));
+            }
+            (Size::S64, Location::GPR(src), Location::Memory(dst, disp)) => {
+                dynasm!(self ; lock cmpxchg [Rq(dst as u8) + disp], Rq(src as u8));
+            }
+            _ => codegen_error!(
+                "singlepass can't emit LOCK CMPXCHG {:?} {:?} {:?}",
+                sz,
+                src,
+                dst
+            ),
+        }
+        Ok(())
+    }
+
+    fn emit_rep_stosq(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; rep stosq);
+        Ok(())
+    }
+    fn emit_btc_gpr_imm8_32(&mut self, src: u8, dst: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; btc Rd(dst as u8), BYTE src as i8);
+        Ok(())
+    }
+
+    fn emit_btc_gpr_imm8_64(&mut self, src: u8, dst: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; btc Rq(dst as u8), BYTE src as i8);
+        Ok(())
+    }
+
+    fn emit_cmovae_gpr_32(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; cmovae Rd(dst as u8), Rd(src as u8));
+        Ok(())
+    }
+
+    fn emit_cmovae_gpr_64(&mut self, src: GPR, dst: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; cmovae Rq(dst as u8), Rq(src as u8));
+        Ok(())
+    }
+
+    fn emit_vmovaps(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError> {
+        match (src, dst) {
+            (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => {
+                dynasm!(self ; movaps Rx(dst as u8), Rx(src as u8))
+            }
+            (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => {
+                dynasm!(self ; movaps Rx(dst as u8), [Rq(base as u8) + disp])
+            }
+            (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => {
+                dynasm!(self ; movaps [Rq(base as u8) + disp], Rx(src as u8))
+            }
+            _ => codegen_error!("singlepass can't emit VMOVAPS {:?} {:?}", src, dst),
+        };
+        Ok(())
+    }
+
+    fn emit_vmovapd(&mut self, src: XMMOrMemory, dst: XMMOrMemory) -> Result<(), CompileError> {
+        match (src, dst) {
+            (XMMOrMemory::XMM(src), XMMOrMemory::XMM(dst)) => {
+                dynasm!(self ; movapd Rx(dst as u8), Rx(src as u8))
+            }
+            (XMMOrMemory::Memory(base, disp), XMMOrMemory::XMM(dst)) => {
+                dynasm!(self ; movapd Rx(dst as u8), [Rq(base as u8) + disp])
+            }
+            (XMMOrMemory::XMM(src), XMMOrMemory::Memory(base, disp)) => {
+                dynasm!(self ; movapd [Rq(base as u8) + disp], Rx(src as u8))
+            }
+            _ => codegen_error!("singlepass can't emit VMOVAPD {:?} {:?}", src, dst),
+        };
+        Ok(())
+    }
+    fn emit_vxorps(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vxorps, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(xorps, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vxorpd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vxorpd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(xorpd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vaddss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vaddss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(addss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vaddsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vaddsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(addsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vsubss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vsubss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(subss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vsubsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vsubsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(subsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vmulss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vmulss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(mulss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vmulsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vmulsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(mulsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vdivss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vdivss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(divss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vdivsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vdivsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(divsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vmaxss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vmaxss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(maxss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vmaxsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vmaxsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(maxsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vminss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vminss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(minss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vminsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vminsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(minsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpeqss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpeqss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 0, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpeqsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpeqsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 0, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpneqss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpneqss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 4, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpneqsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpneqsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 4, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpltss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpltss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 1, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpltsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpltsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 1, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpless(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpless, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 2, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmplesd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmplesd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 2, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpgtss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpgtss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 6, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpgtsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpgtsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 6, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpgess(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpgess, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 5, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpgesd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpgesd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 5, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpunordss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpunordss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 3, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpunordsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpunordsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 3, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpordss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpordss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpss, 7, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcmpordsd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcmpordsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cmpsd, 7, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vsqrtss(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vsqrtss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(sqrtss, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vsqrtsd(&mut self, src1: XMM, src2: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vsqrtsd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(sqrtsd, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtss2sd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcvtss2sd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cvtss2sd, self, Precision::Single, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtsd2ss(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_fn!(vcvtsd2ss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => sse_fn!(cvtsd2ss, self, Precision::Double, src1, src2, dst),
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundss_nearest(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundss, 0, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundss, 0, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundsd_nearest(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundsd, 0, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundsd, 0, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundss_floor(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundss, 1, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundss, 1, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundsd_floor(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundsd, 1, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundsd, 1, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundss_ceil(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundss, 2, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundss, 2, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundsd_ceil(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundsd, 2, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundsd, 2, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundss_trunc(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundss, 3, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundss, 3, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vroundsd_trunc(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_round_fn!(vroundsd, 3, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_round_fn!(roundsd, 3, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtsi2ss_32(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_i2f_32_fn!(vcvtsi2ss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_i2f_32_fn!(cvtsi2ss, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtsi2sd_32(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_i2f_32_fn!(vcvtsi2sd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_i2f_32_fn!(cvtsi2sd, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtsi2ss_64(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_i2f_64_fn!(vcvtsi2ss, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_i2f_64_fn!(cvtsi2ss, self, Precision::Single, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+    fn emit_vcvtsi2sd_64(
+        &mut self,
+        src1: XMM,
+        src2: GPROrMemory,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => avx_i2f_64_fn!(vcvtsi2sd, self, src1, src2, dst),
+            Some(CpuFeature::SSE42) => {
+                sse_i2f_64_fn!(cvtsi2sd, self, Precision::Double, src1, src2, dst)
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn emit_vblendvps(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        mask: XMM,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        // this implementation works only for sse 4.1 and greater
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => match src2 {
+                XMMOrMemory::XMM(src2) => {
+                    // TODO: this argument order does not match the documentation??
+                    dynasm!( self; vblendvps Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8))
+                }
+                XMMOrMemory::Memory(base, disp) => {
+                    dynasm!( self; vblendvps Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8))
+                }
+            },
+            Some(CpuFeature::SSE42) => match src2 {
+                XMMOrMemory::XMM(src2) => {
+                    move_src_to_dst(self, Precision::Single, src1, dst);
+                    dynasm!( self; blendvps Rx(dst as u8), Rx(src2 as u8))
+                }
+                XMMOrMemory::Memory(base, disp) => {
+                    move_src_to_dst(self, Precision::Single, src1, dst);
+                    dynasm!( self; blendvps Rx(dst as u8), [Rq(base as u8) + disp])
+                }
+            },
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn emit_vblendvpd(
+        &mut self,
+        src1: XMM,
+        src2: XMMOrMemory,
+        mask: XMM,
+        dst: XMM,
+    ) -> Result<(), CompileError> {
+        // this implementation works only for sse 4.1 and greater
+        match self.get_simd_arch() {
+            Some(CpuFeature::AVX) => match src2 {
+                XMMOrMemory::XMM(src2) => {
+                    // TODO: this argument order does not match the documentation??
+                    dynasm!( self; vblendvpd Rx(dst as u8), Rx(mask as u8), Rx(src2 as u8), Rx(src1 as u8))
+                }
+                XMMOrMemory::Memory(base, disp) => {
+                    dynasm!( self; vblendvpd Rx(dst as u8), Rx(mask as u8), [Rq(base as u8) + disp], Rx(src1 as u8))
+                }
+            },
+            Some(CpuFeature::SSE42) => match src2 {
+                XMMOrMemory::XMM(src2) => {
+                    move_src_to_dst(self, Precision::Double, src1, dst);
+                    dynasm!( self; blendvpd Rx(dst as u8), Rx(src2 as u8))
+                }
+                XMMOrMemory::Memory(base, disp) => {
+                    move_src_to_dst(self, Precision::Double, src1, dst);
+                    dynasm!( self; blendvpd Rx(dst as u8), [Rq(base as u8) + disp])
+                }
+            },
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn emit_ucomiss(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; ucomiss Rx(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; ucomiss Rx(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_ucomisd(&mut self, src: XMMOrMemory, dst: XMM) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; ucomisd Rx(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; ucomisd Rx(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_cvttss2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rd(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; cvttss2si Rd(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_cvttss2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttss2si Rq(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; cvttss2si Rq(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_cvttsd2si_32(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rd(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; cvttsd2si Rd(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_cvttsd2si_64(&mut self, src: XMMOrMemory, dst: GPR) -> Result<(), CompileError> {
+        match src {
+            XMMOrMemory::XMM(x) => dynasm!(self ; cvttsd2si Rq(dst as u8), Rx(x as u8)),
+            XMMOrMemory::Memory(base, disp) => {
+                dynasm!(self ; cvttsd2si Rq(dst as u8), [Rq(base as u8) + disp])
+            }
+        }
+        Ok(())
+    }
+
+    fn emit_test_gpr_64(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; test Rq(reg as u8), Rq(reg as u8));
+        Ok(())
+    }
+
+    fn emit_ud2(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; ud2);
+        Ok(())
+    }
+    fn emit_ud1_payload(&mut self, payload: u8) -> Result<(), CompileError> {
+        assert!(payload & 0xf0 == 0);
+        dynasm!(self ; ud1 Rd((payload>>3)&1), Rd(payload&7));
+        Ok(())
+    }
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; ret);
+        Ok(())
+    }
+
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        dynasm!(self ; call =>label);
+        Ok(())
+    }
+    fn emit_call_location(&mut self, loc: Location) -> Result<(), CompileError> {
+        match loc {
+            Location::GPR(x) => dynasm!(self ; call Rq(x as u8)),
+            Location::Memory(base, disp) => dynasm!(self ; call QWORD [Rq(base as u8) + disp]),
+            _ => codegen_error!("singlepass can't emit CALL {:?}", loc),
+        }
+        Ok(())
+    }
+
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        dynasm!(self ; call Rq(reg as u8));
+        Ok(())
+    }
+
+    fn emit_bkpt(&mut self) -> Result<(), CompileError> {
+        dynasm!(self ; int3);
+        Ok(())
+    }
+
+    fn emit_host_redirection(&mut self, target: GPR) -> Result<(), CompileError> {
+        self.emit_jmp_location(Location::GPR(target))
+    }
+
+    fn arch_mov64_imm_offset(&self) -> Result<usize, CompileError> {
+        Ok(2)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/lib.rs
new file mode 100644
index 0000000..2ea4cf7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/lib.rs
@@ -0,0 +1,34 @@
+//! A WebAssembly `Compiler` implementation using Singlepass.
+//!
+//! Singlepass is a super-fast assembly generator that generates
+//! assembly code in just one pass. This is useful for different applications
+//! including Blockchains and Edge computing where quick compilation
+//! times are a must, and JIT bombs should never happen.
+//!
+//! Compared to Cranelift and LLVM, Singlepass compiles much faster but has worse
+//! runtime performance.
+
+#![allow(clippy::unnecessary_cast)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+mod address_map;
+mod arm64_decl;
+mod codegen;
+mod common_decl;
+mod compiler;
+mod config;
+#[cfg(feature = "unwind")]
+mod dwarf;
+mod emitter_arm64;
+mod emitter_x64;
+mod location;
+mod machine;
+mod machine_arm64;
+mod machine_x64;
+mod unwind;
+#[cfg(feature = "unwind")]
+mod unwind_winx64;
+mod x64_decl;
+
+pub use crate::compiler::SinglepassCompiler;
+pub use crate::config::Singlepass;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/location.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/location.rs
new file mode 100644
index 0000000..ba8addf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/location.rs
@@ -0,0 +1,77 @@
+use crate::common_decl::RegisterIndex;
+use crate::machine::*;
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::slice::Iter;
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum Multiplier {
+    Zero = 0,
+    One = 1,
+    Two = 2,
+    Four = 4,
+    Height = 8,
+}
+
+#[allow(dead_code, clippy::upper_case_acronyms)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum Location<R, S> {
+    GPR(R),
+    SIMD(S),
+    Memory(R, i32),
+    Memory2(R, R, Multiplier, i32), // R + R*Multiplier + i32
+    Imm8(u8),
+    Imm32(u32),
+    Imm64(u64),
+    None,
+}
+
+impl<R, S> MaybeImmediate for Location<R, S> {
+    fn imm_value(&self) -> Option<Value> {
+        match *self {
+            Location::Imm8(imm) => Some(Value::I8(imm as i8)),
+            Location::Imm32(imm) => Some(Value::I32(imm as i32)),
+            Location::Imm64(imm) => Some(Value::I64(imm as i64)),
+            _ => None,
+        }
+    }
+}
+
+pub trait Reg: Copy + Clone + Eq + PartialEq + Debug + Hash + Ord {
+    fn is_callee_save(self) -> bool;
+    fn is_reserved(self) -> bool;
+    fn into_index(self) -> usize;
+    fn from_index(i: usize) -> Result<Self, ()>;
+    fn iterator() -> Iter<'static, Self>;
+    fn to_dwarf(self) -> u16;
+}
+
+pub trait Descriptor<R: Reg, S: Reg> {
+    const FP: R;
+    const VMCTX: R;
+    const GPR_COUNT: usize;
+    const SIMD_COUNT: usize;
+    const WORD_SIZE: usize;
+    const STACK_GROWS_DOWN: bool;
+    const FP_STACK_ARG_OFFSET: i32;
+    const ARG_REG_COUNT: usize;
+    fn callee_save_gprs() -> Vec<R>;
+    fn caller_save_gprs() -> Vec<R>;
+    fn callee_save_simd() -> Vec<S>;
+    fn caller_save_simd() -> Vec<S>;
+    fn callee_param_location(n: usize) -> Location<R, S>;
+    fn caller_arg_location(n: usize) -> Location<R, S>;
+    fn return_location() -> Location<R, S>;
+}
+
+pub trait CombinedRegister: Copy + Clone + Eq + PartialEq + Debug {
+    /// Returns the index of the register.
+    fn to_index(&self) -> RegisterIndex;
+    /// Converts a DWARF regnum to CombinedRegister.
+    fn _from_dwarf_regnum(x: u16) -> Option<Self>;
+    /// Convert from a GPR register
+    fn from_gpr(x: u16) -> Self;
+    /// Convert from an SIMD register
+    fn from_simd(x: u16) -> Self;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine.rs
new file mode 100644
index 0000000..e3ca24b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine.rs
@@ -0,0 +1,2504 @@
+use crate::common_decl::*;
+use crate::location::{Location, Reg};
+use crate::machine_arm64::MachineARM64;
+use crate::machine_x64::MachineX86_64;
+use crate::unwind::UnwindInstructions;
+use dynasmrt::{AssemblyOffset, DynamicLabel};
+use std::collections::BTreeMap;
+use std::fmt::Debug;
+pub use wasmer_compiler::wasmparser::MemArg;
+use wasmer_compiler::wasmparser::ValType as WpType;
+use wasmer_types::{
+    Architecture, CallingConvention, CompileError, CustomSection, FunctionBody, FunctionIndex,
+    FunctionType, InstructionAddressMap, Relocation, RelocationTarget, Target, TrapCode,
+    TrapInformation, VMOffsets,
+};
+
+pub type Label = DynamicLabel;
+pub type Offset = AssemblyOffset;
+
+#[allow(dead_code)]
+#[derive(Clone, PartialEq)]
+pub enum Value {
+    I8(i8),
+    I32(i32),
+    I64(i64),
+    F32(f32),
+    F64(f64),
+}
+
+#[macro_export]
+macro_rules! codegen_error {
+    ($($arg:tt)*) => {return Err(CompileError::Codegen(format!($($arg)*)))}
+}
+
+pub trait MaybeImmediate {
+    fn imm_value(&self) -> Option<Value>;
+    fn is_imm(&self) -> bool {
+        self.imm_value().is_some()
+    }
+}
+
+/// A trap table for a `RunnableModuleInfo`.
+#[derive(Clone, Debug, Default)]
+pub struct TrapTable {
+    /// Mappings from offsets in generated machine code to the corresponding trap code.
+    pub offset_to_code: BTreeMap<usize, TrapCode>,
+}
+
+// all machine seems to have a page this size, so not per arch for now
+pub const NATIVE_PAGE_SIZE: usize = 4096;
+
+pub struct MachineStackOffset(pub usize);
+
+pub trait Machine {
+    type GPR: Copy + Eq + Debug + Reg;
+    type SIMD: Copy + Eq + Debug + Reg;
+    /// Get current assembler offset
+    fn assembler_get_offset(&self) -> Offset;
+    /// Convert from a GPR register to index register
+    fn index_from_gpr(&self, x: Self::GPR) -> RegisterIndex;
+    /// Convert from an SIMD register
+    fn index_from_simd(&self, x: Self::SIMD) -> RegisterIndex;
+    /// Get the GPR that hold vmctx
+    fn get_vmctx_reg(&self) -> Self::GPR;
+    /// Picks an unused general purpose register for local/stack/argument use.
+    ///
+    /// This method does not mark the register as used
+    fn pick_gpr(&self) -> Option<Self::GPR>;
+    /// Picks an unused general purpose register for internal temporary use.
+    ///
+    /// This method does not mark the register as used
+    fn pick_temp_gpr(&self) -> Option<Self::GPR>;
+    /// Get all used GPR
+    fn get_used_gprs(&self) -> Vec<Self::GPR>;
+    /// Get all used SIMD regs
+    fn get_used_simd(&self) -> Vec<Self::SIMD>;
+    /// Picks an unused general pupose register and mark it as used
+    fn acquire_temp_gpr(&mut self) -> Option<Self::GPR>;
+    /// Releases a temporary GPR.
+    fn release_gpr(&mut self, gpr: Self::GPR);
+    /// Specify that a given register is in use.
+    fn reserve_unused_temp_gpr(&mut self, gpr: Self::GPR) -> Self::GPR;
+    /// reserve a GPR
+    fn reserve_gpr(&mut self, gpr: Self::GPR);
+    /// Push used gpr to the stack. Return the bytes taken on the stack
+    fn push_used_gpr(&mut self, grps: &[Self::GPR]) -> Result<usize, CompileError>;
+    /// Pop used gpr to the stack
+    fn pop_used_gpr(&mut self, grps: &[Self::GPR]) -> Result<(), CompileError>;
+    /// Picks an unused SIMD register.
+    ///
+    /// This method does not mark the register as used
+    fn pick_simd(&self) -> Option<Self::SIMD>;
+    /// Picks an unused SIMD register for internal temporary use.
+    ///
+    /// This method does not mark the register as used
+    fn pick_temp_simd(&self) -> Option<Self::SIMD>;
+    /// Acquires a temporary XMM register.
+    fn acquire_temp_simd(&mut self) -> Option<Self::SIMD>;
+    /// reserve a SIMD register
+    fn reserve_simd(&mut self, simd: Self::SIMD);
+    /// Releases a temporary XMM register.
+    fn release_simd(&mut self, simd: Self::SIMD);
+    /// Push used simd regs to the stack. Return bytes taken on the stack
+    fn push_used_simd(&mut self, simds: &[Self::SIMD]) -> Result<usize, CompileError>;
+    /// Pop used simd regs to the stack
+    fn pop_used_simd(&mut self, simds: &[Self::SIMD]) -> Result<(), CompileError>;
+    /// Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)
+    fn round_stack_adjust(&self, value: usize) -> usize;
+    /// Set the source location of the Wasm to the given offset.
+    fn set_srcloc(&mut self, offset: u32);
+    /// Marks each address in the code range emitted by `f` with the trap code `code`.
+    fn mark_address_range_with_trap_code(&mut self, code: TrapCode, begin: usize, end: usize);
+    /// Marks one address as trappable with trap code `code`.
+    fn mark_address_with_trap_code(&mut self, code: TrapCode);
+    /// Marks the instruction as trappable with trap code `code`. return "begin" offset
+    fn mark_instruction_with_trap_code(&mut self, code: TrapCode) -> usize;
+    /// Pushes the instruction to the address map, calculating the offset from a
+    /// provided beginning address.
+    fn mark_instruction_address_end(&mut self, begin: usize);
+    /// Insert a StackOverflow (at offset 0)
+    fn insert_stackoverflow(&mut self);
+    /// Get all current TrapInformation
+    fn collect_trap_information(&self) -> Vec<TrapInformation>;
+    // Get all intructions address map
+    fn instructions_address_map(&self) -> Vec<InstructionAddressMap>;
+    /// Memory location for a local on the stack
+    /// Like Location::Memory(GPR::RBP, -(self.stack_offset.0 as i32)) for x86_64
+    fn local_on_stack(&mut self, stack_offset: i32) -> Location<Self::GPR, Self::SIMD>;
+    /// Adjust stack for locals
+    /// Like assembler.emit_sub(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
+    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
+    /// restore stack
+    /// Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
+    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
+    /// Pop stack of locals
+    /// Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))
+    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>;
+    /// Zero a location taht is 32bits
+    fn zero_location(
+        &mut self,
+        size: Size,
+        location: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// GPR Reg used for local pointer on the stack
+    fn local_pointer(&self) -> Self::GPR;
+    /// push a value on the stack for a native call
+    fn move_location_for_native(
+        &mut self,
+        size: Size,
+        loc: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Determine whether a local should be allocated on the stack.
+    fn is_local_on_stack(&self, idx: usize) -> bool;
+    /// Determine a local's location.
+    fn get_local_location(
+        &self,
+        idx: usize,
+        callee_saved_regs_size: usize,
+    ) -> Location<Self::GPR, Self::SIMD>;
+    /// Move a local to the stack
+    /// Like emit_mov(Size::S64, location, Location::Memory(GPR::RBP, -(self.stack_offset.0 as i32)));
+    fn move_local(
+        &mut self,
+        stack_offset: i32,
+        location: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// List of register to save, depending on the CallingConvention
+    fn list_to_save(
+        &self,
+        calling_convention: CallingConvention,
+    ) -> Vec<Location<Self::GPR, Self::SIMD>>;
+    /// Get param location (to build a call, using SP for stack args)
+    fn get_param_location(
+        &self,
+        idx: usize,
+        sz: Size,
+        stack_offset: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location<Self::GPR, Self::SIMD>;
+    /// Get call param location (from a call, using FP for stack args)
+    fn get_call_param_location(
+        &self,
+        idx: usize,
+        sz: Size,
+        stack_offset: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location<Self::GPR, Self::SIMD>;
+    /// Get simple param location
+    fn get_simple_param_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
+    ) -> Location<Self::GPR, Self::SIMD>;
+    /// move a location to another
+    fn move_location(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// move a location to another, with zero or sign extension
+    fn move_location_extend(
+        &mut self,
+        size_val: Size,
+        signed: bool,
+        source: Location<Self::GPR, Self::SIMD>,
+        size_op: Size,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Load a memory value to a register, zero extending to 64bits.
+    /// Panic if gpr is not a Location::GPR or if mem is not a Memory(2)
+    fn load_address(
+        &mut self,
+        size: Size,
+        gpr: Location<Self::GPR, Self::SIMD>,
+        mem: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Init the stack loc counter
+    fn init_stack_loc(
+        &mut self,
+        init_stack_loc_cnt: u64,
+        last_stack_loc: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Restore save_area
+    fn restore_saved_area(&mut self, saved_area_offset: i32) -> Result<(), CompileError>;
+    /// Pop a location
+    fn pop_location(
+        &mut self,
+        location: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Create a new `MachineState` with default values.
+    fn new_machine_state(&self) -> MachineState;
+
+    /// Finalize the assembler
+    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError>;
+
+    /// get_offset of Assembler
+    fn get_offset(&self) -> Offset;
+
+    /// finalize a function
+    fn finalize_function(&mut self) -> Result<(), CompileError>;
+
+    /// emit native function prolog (depending on the calling Convention, like "PUSH RBP / MOV RSP, RBP")
+    fn emit_function_prolog(&mut self) -> Result<(), CompileError>;
+    /// emit native function epilog (depending on the calling Convention, like "MOV RBP, RSP / POP RBP")
+    fn emit_function_epilog(&mut self) -> Result<(), CompileError>;
+    /// handle return value, with optionnal cannonicalization if wanted
+    fn emit_function_return_value(
+        &mut self,
+        ty: WpType,
+        cannonicalize: bool,
+        loc: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Handle copy to SIMD register from ret value (if needed by the arch/calling convention)
+    fn emit_function_return_float(&mut self) -> Result<(), CompileError>;
+    /// Is NaN canonicalization supported
+    fn arch_supports_canonicalize_nan(&self) -> bool;
+    /// Cannonicalize a NaN (or panic if not supported)
+    fn canonicalize_nan(
+        &mut self,
+        sz: Size,
+        input: Location<Self::GPR, Self::SIMD>,
+        output: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// emit an Illegal Opcode, associated with a trapcode
+    fn emit_illegal_op(&mut self, trp: TrapCode) -> Result<(), CompileError>;
+    /// create a new label
+    fn get_label(&mut self) -> Label;
+    /// emit a label
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError>;
+
+    /// get the gpr use for call. like RAX on x86_64
+    fn get_grp_for_call(&self) -> Self::GPR;
+    /// Emit a call using the value in register
+    fn emit_call_register(&mut self, register: Self::GPR) -> Result<(), CompileError>;
+    /// Emit a call to a label
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError>;
+    /// Does an trampoline is neededfor indirect call
+    fn arch_requires_indirect_call_trampoline(&self) -> bool;
+    /// indirect call with trampoline
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        location: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// emit a call to a location
+    fn emit_call_location(
+        &mut self,
+        location: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// get the gpr for the return of generic values
+    fn get_gpr_for_ret(&self) -> Self::GPR;
+    /// get the simd for the return of float/double values
+    fn get_simd_for_ret(&self) -> Self::SIMD;
+
+    /// Emit a debug breakpoint
+    fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError>;
+
+    /// load the address of a memory location (will panic if src is not a memory)
+    /// like LEA opcode on x86_64
+    fn location_address(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// And src & dst -> dst (with or without flags)
+    fn location_and(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+        flags: bool,
+    ) -> Result<(), CompileError>;
+    /// Xor src & dst -> dst (with or without flags)
+    fn location_xor(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+        flags: bool,
+    ) -> Result<(), CompileError>;
+    /// Or src & dst -> dst (with or without flags)
+    fn location_or(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+        flags: bool,
+    ) -> Result<(), CompileError>;
+
+    /// Add src+dst -> dst (with or without flags)
+    fn location_add(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+        flags: bool,
+    ) -> Result<(), CompileError>;
+    /// Sub dst-src -> dst (with or without flags)
+    fn location_sub(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+        flags: bool,
+    ) -> Result<(), CompileError>;
+    /// -src -> dst
+    fn location_neg(
+        &mut self,
+        size_val: Size, // size of src
+        signed: bool,
+        source: Location<Self::GPR, Self::SIMD>,
+        size_op: Size,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// Cmp src - dst and set flags
+    fn location_cmp(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Test src & dst and set flags
+    fn location_test(
+        &mut self,
+        size: Size,
+        source: Location<Self::GPR, Self::SIMD>,
+        dest: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// jmp without condidtion
+    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on equal (src==dst)
+    /// like Equal set on x86_64
+    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on different (src!=dst)
+    /// like NotEqual set on x86_64
+    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on above (src>dst)
+    /// like Above set on x86_64
+    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on above (src>=dst)
+    /// like Above or Equal set on x86_64
+    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on above (src<=dst)
+    /// like Below or Equal set on x86_64
+    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError>;
+    /// jmp on overflow
+    /// like Carry set on x86_64
+    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError>;
+
+    /// jmp using a jump table at lable with cond as the indice
+    fn emit_jmp_to_jumptable(
+        &mut self,
+        label: Label,
+        cond: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// Align for Loop (may do nothing, depending on the arch)
+    fn align_for_loop(&mut self) -> Result<(), CompileError>;
+
+    /// ret (from a Call)
+    fn emit_ret(&mut self) -> Result<(), CompileError>;
+
+    /// Stack push of a location
+    fn emit_push(
+        &mut self,
+        size: Size,
+        loc: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Stack pop of a location
+    fn emit_pop(
+        &mut self,
+        size: Size,
+        loc: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// relaxed mov: move from anywhere to anywhere
+    fn emit_relaxed_mov(
+        &mut self,
+        sz: Size,
+        src: Location<Self::GPR, Self::SIMD>,
+        dst: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// relaxed cmp: compare from anywhere and anywhere
+    fn emit_relaxed_cmp(
+        &mut self,
+        sz: Size,
+        src: Location<Self::GPR, Self::SIMD>,
+        dst: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Emit a memory fence. Can be nothing for x86_64 or a DMB on ARM64 for example
+    fn emit_memory_fence(&mut self) -> Result<(), CompileError>;
+    /// relaxed move with zero extension
+    fn emit_relaxed_zero_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location<Self::GPR, Self::SIMD>,
+        sz_dst: Size,
+        dst: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// relaxed move with sign extension
+    fn emit_relaxed_sign_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location<Self::GPR, Self::SIMD>,
+        sz_dst: Size,
+        dst: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Multiply location with immediate
+    fn emit_imul_imm32(
+        &mut self,
+        size: Size,
+        imm32: u32,
+        gpr: Self::GPR,
+    ) -> Result<(), CompileError>;
+    /// Add with location directly from the stack
+    fn emit_binop_add32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Sub with location directly from the stack
+    fn emit_binop_sub32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Multiply with location directly from the stack
+    fn emit_binop_mul32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_udiv32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_sdiv32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Unsigned Reminder (of a division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_urem32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_srem32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// And with location directly from the stack
+    fn emit_binop_and32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Or with location directly from the stack
+    fn emit_binop_or32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Xor with location directly from the stack
+    fn emit_binop_xor32(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Greater of Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_ge_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Greater Than Compare 2 i32, result in a GPR
+    fn i32_cmp_gt_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Less of Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_le_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Less Than Compare 2 i32, result in a GPR
+    fn i32_cmp_lt_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Greater of Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_ge_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Greater Than Compare 2 i32, result in a GPR
+    fn i32_cmp_gt_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Less of Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_le_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Less Than Compare 2 i32, result in a GPR
+    fn i32_cmp_lt_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Not Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_ne(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Equal Compare 2 i32, result in a GPR
+    fn i32_cmp_eq(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count Leading 0 bit of an i32
+    fn i32_clz(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count Trailling 0 bit of an i32
+    fn i32_ctz(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count the number of 1 bit of an i32
+    fn i32_popcnt(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 Logical Shift Left
+    fn i32_shl(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 Logical Shift Right
+    fn i32_shr(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 Arithmetic Shift Right
+    fn i32_sar(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 Roll Left
+    fn i32_rol(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 Roll Right
+    fn i32_ror(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i32 load
+    #[allow(clippy::too_many_arguments)]
+    fn i32_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 load of an unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_load_8u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 load of an signed 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_load_8s(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 load of an unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_load_16u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 load of an signed 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_load_16s(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic load
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic load of an unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_load_8u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic load of an unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_load_16u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 save
+    #[allow(clippy::too_many_arguments)]
+    fn i32_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 save of the lower 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_save_8(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 save of the lower 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_save_16(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic save
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic save of a the lower 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_save_8(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic save of a the lower 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_save_16(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Add with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_add(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Add with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_add_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Add with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_add_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Sub with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_sub(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Sub with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_sub_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Sub with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_sub_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic And with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_and(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic And with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_and_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic And with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_and_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Or with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_or(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Or with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_or_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Or with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_or_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Xor with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xor(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Xor with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xor_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Xor with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xor_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Exchange with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xchg(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Exchange with u8
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xchg_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Exchange with u16
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_xchg_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Compare and Exchange with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_cmpxchg(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Compare and Exchange with u8
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i32 atomic Compare and Exchange with u16
+    #[allow(clippy::too_many_arguments)]
+    fn i32_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+
+    /// emit a move function address to GPR ready for call, using appropriate relocation
+    fn emit_call_with_reloc(
+        &mut self,
+        calling_convention: CallingConvention,
+        reloc_target: RelocationTarget,
+    ) -> Result<Vec<Relocation>, CompileError>;
+    /// Add with location directly from the stack
+    fn emit_binop_add64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Sub with location directly from the stack
+    fn emit_binop_sub64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Multiply with location directly from the stack
+    fn emit_binop_mul64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_udiv64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_sdiv64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Unsigned Reminder (of a division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_urem64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.
+    fn emit_binop_srem64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError>;
+    /// And with location directly from the stack
+    fn emit_binop_and64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Or with location directly from the stack
+    fn emit_binop_or64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Xor with location directly from the stack
+    fn emit_binop_xor64(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Greater of Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_ge_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Greater Than Compare 2 i64, result in a GPR
+    fn i64_cmp_gt_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Less of Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_le_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Signed Less Than Compare 2 i64, result in a GPR
+    fn i64_cmp_lt_s(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Greater of Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_ge_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Greater Than Compare 2 i64, result in a GPR
+    fn i64_cmp_gt_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Less of Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_le_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Unsigned Less Than Compare 2 i64, result in a GPR
+    fn i64_cmp_lt_u(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Not Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_ne(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Equal Compare 2 i64, result in a GPR
+    fn i64_cmp_eq(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count Leading 0 bit of an i64
+    fn i64_clz(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count Trailling 0 bit of an i64
+    fn i64_ctz(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Count the number of 1 bit of an i64
+    fn i64_popcnt(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 Logical Shift Left
+    fn i64_shl(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 Logical Shift Right
+    fn i64_shr(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 Arithmetic Shift Right
+    fn i64_sar(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 Roll Left
+    fn i64_rol(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 Roll Right
+    fn i64_ror(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// i64 load
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_8u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an signed 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_8s(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_32u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an signed 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_32s(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an signed 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_16u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 load of an signed 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_load_16s(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic load
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic load from unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_load_8u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic load from unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_load_16u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic load from unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_load_32u(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 save
+    #[allow(clippy::too_many_arguments)]
+    fn i64_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 save of the lower 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_save_8(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 save of the lower 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_save_16(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 save of the lower 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_save_32(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic save
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic save of a the lower 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_save_8(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic save of a the lower 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_save_16(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic save of a the lower 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_save_32(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Add with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_add(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Add with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_add_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Add with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_add_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Add with unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_add_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Sub with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_sub(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Sub with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_sub_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Sub with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_sub_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Sub with unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_sub_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic And with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_and(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic And with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_and_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic And with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_and_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic And with unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_and_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Or with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_or(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Or with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_or_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Or with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_or_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Or with unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_or_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Xor with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xor(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Xor with unsigned 8bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xor_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Xor with unsigned 16bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xor_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Xor with unsigned 32bits
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xor_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Exchange with i64
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xchg(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Exchange with u8
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xchg_8u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Exchange with u16
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xchg_16u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Exchange with u32
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_xchg_32u(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Compare and Exchange with i32
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_cmpxchg(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Compare and Exchange with u8
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Compare and Exchange with u16
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// i64 atomic Compare and Exchange with u32
+    #[allow(clippy::too_many_arguments)]
+    fn i64_atomic_cmpxchg_32u(
+        &mut self,
+        new: Location<Self::GPR, Self::SIMD>,
+        cmp: Location<Self::GPR, Self::SIMD>,
+        target: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+
+    /// load an F32
+    #[allow(clippy::too_many_arguments)]
+    fn f32_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// f32 save
+    #[allow(clippy::too_many_arguments)]
+    fn f32_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// load an F64
+    #[allow(clippy::too_many_arguments)]
+    fn f64_load(
+        &mut self,
+        addr: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        ret: Location<Self::GPR, Self::SIMD>,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// f64 save
+    #[allow(clippy::too_many_arguments)]
+    fn f64_save(
+        &mut self,
+        value: Location<Self::GPR, Self::SIMD>,
+        memarg: &MemArg,
+        addr: Location<Self::GPR, Self::SIMD>,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError>;
+    /// Convert a F64 from I64, signed or unsigned
+    fn convert_f64_i64(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Convert a F64 from I32, signed or unsigned
+    fn convert_f64_i32(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Convert a F32 from I64, signed or unsigned
+    fn convert_f32_i64(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Convert a F32 from I32, signed or unsigned
+    fn convert_f32_i32(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Convert a F64 to I64, signed or unsigned, without or without saturation
+    fn convert_i64_f64(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError>;
+    /// Convert a F64 to I32, signed or unsigned, without or without saturation
+    fn convert_i32_f64(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError>;
+    /// Convert a F32 to I64, signed or unsigned, without or without saturation
+    fn convert_i64_f32(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError>;
+    /// Convert a F32 to I32, signed or unsigned, without or without saturation
+    fn convert_i32_f32(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError>;
+    /// Convert a F32 to F64
+    fn convert_f64_f32(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Convert a F64 to F32
+    fn convert_f32_f64(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Negate an F64
+    fn f64_neg(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Get the Absolute Value of an F64
+    fn f64_abs(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Copy sign from tmp1 Self::GPR to tmp2 Self::GPR
+    fn emit_i64_copysign(&mut self, tmp1: Self::GPR, tmp2: Self::GPR) -> Result<(), CompileError>;
+    /// Get the Square Root of an F64
+    fn f64_sqrt(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Trunc of an F64
+    fn f64_trunc(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Ceil of an F64
+    fn f64_ceil(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Floor of an F64
+    fn f64_floor(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Round at nearest int of an F64
+    fn f64_nearest(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Greater of Equal Compare 2 F64, result in a GPR
+    fn f64_cmp_ge(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Greater Than Compare 2 F64, result in a GPR
+    fn f64_cmp_gt(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Less of Equal Compare 2 F64, result in a GPR
+    fn f64_cmp_le(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Less Than Compare 2 F64, result in a GPR
+    fn f64_cmp_lt(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Not Equal Compare 2 F64, result in a GPR
+    fn f64_cmp_ne(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Equal Compare 2 F64, result in a GPR
+    fn f64_cmp_eq(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// get Min for 2 F64 values
+    fn f64_min(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// get Max for 2 F64 values
+    fn f64_max(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Add 2 F64 values
+    fn f64_add(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Sub 2 F64 values
+    fn f64_sub(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Multiply 2 F64 values
+    fn f64_mul(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Divide 2 F64 values
+    fn f64_div(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Negate an F32
+    fn f32_neg(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Get the Absolute Value of an F32
+    fn f32_abs(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Copy sign from tmp1 Self::GPR to tmp2 Self::GPR
+    fn emit_i32_copysign(&mut self, tmp1: Self::GPR, tmp2: Self::GPR) -> Result<(), CompileError>;
+    /// Get the Square Root of an F32
+    fn f32_sqrt(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Trunc of an F32
+    fn f32_trunc(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Ceil of an F32
+    fn f32_ceil(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Floor of an F32
+    fn f32_floor(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Round at nearest int of an F32
+    fn f32_nearest(
+        &mut self,
+        loc: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Greater of Equal Compare 2 F32, result in a GPR
+    fn f32_cmp_ge(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Greater Than Compare 2 F32, result in a GPR
+    fn f32_cmp_gt(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Less of Equal Compare 2 F32, result in a GPR
+    fn f32_cmp_le(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Less Than Compare 2 F32, result in a GPR
+    fn f32_cmp_lt(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Not Equal Compare 2 F32, result in a GPR
+    fn f32_cmp_ne(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Equal Compare 2 F32, result in a GPR
+    fn f32_cmp_eq(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// get Min for 2 F32 values
+    fn f32_min(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// get Max for 2 F32 values
+    fn f32_max(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Add 2 F32 values
+    fn f32_add(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Sub 2 F32 values
+    fn f32_sub(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Multiply 2 F32 values
+    fn f32_mul(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+    /// Divide 2 F32 values
+    fn f32_div(
+        &mut self,
+        loc_a: Location<Self::GPR, Self::SIMD>,
+        loc_b: Location<Self::GPR, Self::SIMD>,
+        ret: Location<Self::GPR, Self::SIMD>,
+    ) -> Result<(), CompileError>;
+
+    /// Standard function Trampoline generation
+    fn gen_std_trampoline(
+        &self,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError>;
+    /// Generates dynamic import function call trampoline for a function type.
+    fn gen_std_dynamic_import_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError>;
+    /// Singlepass calls import functions through a trampoline.
+    fn gen_import_call_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        index: FunctionIndex,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<CustomSection, CompileError>;
+    /// generate eh_frame instruction (or None if not possible / supported)
+    fn gen_dwarf_unwind_info(&mut self, code_len: usize) -> Option<UnwindInstructions>;
+    /// generate Windows unwind instructions (or None if not possible / supported)
+    fn gen_windows_unwind_info(&mut self, code_len: usize) -> Option<Vec<u8>>;
+}
+
+/// Standard entry trampoline generation
+pub fn gen_std_trampoline(
+    sig: &FunctionType,
+    target: &Target,
+    calling_convention: CallingConvention,
+) -> Result<FunctionBody, CompileError> {
+    match target.triple().architecture {
+        Architecture::X86_64 => {
+            let machine = MachineX86_64::new(Some(target.clone()))?;
+            machine.gen_std_trampoline(sig, calling_convention)
+        }
+        Architecture::Aarch64(_) => {
+            let machine = MachineARM64::new(Some(target.clone()));
+            machine.gen_std_trampoline(sig, calling_convention)
+        }
+        _ => Err(CompileError::UnsupportedTarget(
+            "singlepass unimplemented arch for gen_std_trampoline".to_owned(),
+        )),
+    }
+}
+
+/// Generates dynamic import function call trampoline for a function type.
+pub fn gen_std_dynamic_import_trampoline(
+    vmoffsets: &VMOffsets,
+    sig: &FunctionType,
+    target: &Target,
+    calling_convention: CallingConvention,
+) -> Result<FunctionBody, CompileError> {
+    match target.triple().architecture {
+        Architecture::X86_64 => {
+            let machine = MachineX86_64::new(Some(target.clone()))?;
+            machine.gen_std_dynamic_import_trampoline(vmoffsets, sig, calling_convention)
+        }
+        Architecture::Aarch64(_) => {
+            let machine = MachineARM64::new(Some(target.clone()));
+            machine.gen_std_dynamic_import_trampoline(vmoffsets, sig, calling_convention)
+        }
+        _ => Err(CompileError::UnsupportedTarget(
+            "singlepass unimplemented arch for gen_std_dynamic_import_trampoline".to_owned(),
+        )),
+    }
+}
+/// Singlepass calls import functions through a trampoline.
+pub fn gen_import_call_trampoline(
+    vmoffsets: &VMOffsets,
+    index: FunctionIndex,
+    sig: &FunctionType,
+    target: &Target,
+    calling_convention: CallingConvention,
+) -> Result<CustomSection, CompileError> {
+    match target.triple().architecture {
+        Architecture::X86_64 => {
+            let machine = MachineX86_64::new(Some(target.clone()))?;
+            machine.gen_import_call_trampoline(vmoffsets, index, sig, calling_convention)
+        }
+        Architecture::Aarch64(_) => {
+            let machine = MachineARM64::new(Some(target.clone()));
+            machine.gen_import_call_trampoline(vmoffsets, index, sig, calling_convention)
+        }
+        _ => Err(CompileError::UnsupportedTarget(
+            "singlepass unimplemented arch for gen_import_call_trampoline".to_owned(),
+        )),
+    }
+}
+
+// Constants for the bounds of truncation operations. These are the least or
+// greatest exact floats in either f32 or f64 representation less-than (for
+// least) or greater-than (for greatest) the i32 or i64 or u32 or u64
+// min (for least) or max (for greatest), when rounding towards zero.
+
+/// Greatest Exact Float (32 bits) less-than i32::MIN when rounding towards zero.
+pub const GEF32_LT_I32_MIN: f32 = -2147483904.0;
+/// Least Exact Float (32 bits) greater-than i32::MAX when rounding towards zero.
+pub const LEF32_GT_I32_MAX: f32 = 2147483648.0;
+/// Greatest Exact Float (32 bits) less-than i64::MIN when rounding towards zero.
+pub const GEF32_LT_I64_MIN: f32 = -9223373136366403584.0;
+/// Least Exact Float (32 bits) greater-than i64::MAX when rounding towards zero.
+pub const LEF32_GT_I64_MAX: f32 = 9223372036854775808.0;
+/// Greatest Exact Float (32 bits) less-than u32::MIN when rounding towards zero.
+pub const GEF32_LT_U32_MIN: f32 = -1.0;
+/// Least Exact Float (32 bits) greater-than u32::MAX when rounding towards zero.
+pub const LEF32_GT_U32_MAX: f32 = 4294967296.0;
+/// Greatest Exact Float (32 bits) less-than u64::MIN when rounding towards zero.
+pub const GEF32_LT_U64_MIN: f32 = -1.0;
+/// Least Exact Float (32 bits) greater-than u64::MAX when rounding towards zero.
+pub const LEF32_GT_U64_MAX: f32 = 18446744073709551616.0;
+
+/// Greatest Exact Float (64 bits) less-than i32::MIN when rounding towards zero.
+pub const GEF64_LT_I32_MIN: f64 = -2147483649.0;
+/// Least Exact Float (64 bits) greater-than i32::MAX when rounding towards zero.
+pub const LEF64_GT_I32_MAX: f64 = 2147483648.0;
+/// Greatest Exact Float (64 bits) less-than i64::MIN when rounding towards zero.
+pub const GEF64_LT_I64_MIN: f64 = -9223372036854777856.0;
+/// Least Exact Float (64 bits) greater-than i64::MAX when rounding towards zero.
+pub const LEF64_GT_I64_MAX: f64 = 9223372036854775808.0;
+/// Greatest Exact Float (64 bits) less-than u32::MIN when rounding towards zero.
+pub const GEF64_LT_U32_MIN: f64 = -1.0;
+/// Least Exact Float (64 bits) greater-than u32::MAX when rounding towards zero.
+pub const LEF64_GT_U32_MAX: f64 = 4294967296.0;
+/// Greatest Exact Float (64 bits) less-than u64::MIN when rounding towards zero.
+pub const GEF64_LT_U64_MIN: f64 = -1.0;
+/// Least Exact Float (64 bits) greater-than u64::MAX when rounding towards zero.
+pub const LEF64_GT_U64_MAX: f64 = 18446744073709551616.0;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_arm64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_arm64.rs
new file mode 100644
index 0000000..2518dec
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_arm64.rs
@@ -0,0 +1,8897 @@
+use dynasmrt::{aarch64::Aarch64Relocation, VecAssembler};
+#[cfg(feature = "unwind")]
+use gimli::{write::CallFrameInstruction, AArch64};
+
+use wasmer_compiler::wasmparser::ValType as WpType;
+use wasmer_types::{
+    CallingConvention, CompileError, CpuFeature, CustomSection, FunctionBody, FunctionIndex,
+    FunctionType, InstructionAddressMap, Relocation, RelocationKind, RelocationTarget, SourceLoc,
+    Target, TrapCode, TrapInformation, VMOffsets,
+};
+
+use crate::arm64_decl::new_machine_state;
+use crate::arm64_decl::{GPR, NEON};
+use crate::codegen_error;
+use crate::common_decl::*;
+use crate::emitter_arm64::*;
+use crate::location::Location as AbstractLocation;
+use crate::location::Reg;
+use crate::machine::*;
+use crate::unwind::{UnwindInstructions, UnwindOps};
+
+type Assembler = VecAssembler<Aarch64Relocation>;
+type Location = AbstractLocation<GPR, NEON>;
+
+#[cfg(feature = "unwind")]
+fn dwarf_index(reg: u16) -> gimli::Register {
+    static DWARF_GPR: [gimli::Register; 32] = [
+        AArch64::X0,
+        AArch64::X1,
+        AArch64::X2,
+        AArch64::X3,
+        AArch64::X4,
+        AArch64::X5,
+        AArch64::X6,
+        AArch64::X7,
+        AArch64::X8,
+        AArch64::X9,
+        AArch64::X10,
+        AArch64::X11,
+        AArch64::X12,
+        AArch64::X13,
+        AArch64::X14,
+        AArch64::X15,
+        AArch64::X16,
+        AArch64::X17,
+        AArch64::X18,
+        AArch64::X19,
+        AArch64::X20,
+        AArch64::X21,
+        AArch64::X22,
+        AArch64::X23,
+        AArch64::X24,
+        AArch64::X25,
+        AArch64::X26,
+        AArch64::X27,
+        AArch64::X28,
+        AArch64::X29,
+        AArch64::X30,
+        AArch64::SP,
+    ];
+    static DWARF_NEON: [gimli::Register; 32] = [
+        AArch64::V0,
+        AArch64::V1,
+        AArch64::V2,
+        AArch64::V3,
+        AArch64::V4,
+        AArch64::V5,
+        AArch64::V6,
+        AArch64::V7,
+        AArch64::V8,
+        AArch64::V9,
+        AArch64::V10,
+        AArch64::V11,
+        AArch64::V12,
+        AArch64::V13,
+        AArch64::V14,
+        AArch64::V15,
+        AArch64::V16,
+        AArch64::V17,
+        AArch64::V18,
+        AArch64::V19,
+        AArch64::V20,
+        AArch64::V21,
+        AArch64::V22,
+        AArch64::V23,
+        AArch64::V24,
+        AArch64::V25,
+        AArch64::V26,
+        AArch64::V27,
+        AArch64::V28,
+        AArch64::V29,
+        AArch64::V30,
+        AArch64::V31,
+    ];
+    match reg {
+        0..=31 => DWARF_GPR[reg as usize],
+        64..=95 => DWARF_NEON[reg as usize - 64],
+        _ => panic!("Unknown register index {}", reg),
+    }
+}
+
+pub struct MachineARM64 {
+    assembler: Assembler,
+    used_gprs: u32,
+    used_simd: u32,
+    trap_table: TrapTable,
+    /// Map from byte offset into wasm function to range of native instructions.
+    // Ordered by increasing InstructionAddressMap::srcloc.
+    instructions_address_map: Vec<InstructionAddressMap>,
+    /// The source location for the current operator.
+    src_loc: u32,
+    /// is last push on a 8byte multiple or 16bytes?
+    pushed: bool,
+    /// Vector of unwind operations with offset
+    unwind_ops: Vec<(usize, UnwindOps)>,
+    /// A boolean flag signaling if this machine supports NEON.
+    has_neon: bool,
+}
+
+#[allow(dead_code)]
+#[derive(PartialEq)]
+enum ImmType {
+    None,
+    NoneXzr,
+    Bits8,
+    Bits12,
+    Shift32,
+    Shift32No0,
+    Shift64,
+    Shift64No0,
+    Logical32,
+    Logical64,
+    UnscaledOffset,
+    OffsetByte,
+    OffsetHWord,
+    OffsetWord,
+    OffsetDWord,
+}
+
+#[allow(dead_code)]
+impl MachineARM64 {
+    pub fn new(target: Option<Target>) -> Self {
+        // If and when needed, checks for other supported features should be
+        // added as boolean fields in the struct to make checking if such
+        // features are available as cheap as possible.
+        let has_neon = match target {
+            Some(ref target) => target.cpu_features().contains(CpuFeature::NEON),
+            None => false,
+        };
+
+        MachineARM64 {
+            assembler: Assembler::new(0),
+            used_gprs: 0,
+            used_simd: 0,
+            trap_table: TrapTable::default(),
+            instructions_address_map: vec![],
+            src_loc: 0,
+            pushed: false,
+            unwind_ops: vec![],
+            has_neon,
+        }
+    }
+    fn compatible_imm(&self, imm: i64, ty: ImmType) -> bool {
+        match ty {
+            ImmType::None => false,
+            ImmType::NoneXzr => false,
+            ImmType::Bits8 => (0..256).contains(&imm),
+            ImmType::Bits12 => (0..0x1000).contains(&imm),
+            ImmType::Shift32 => (0..32).contains(&imm),
+            ImmType::Shift32No0 => (1..32).contains(&imm),
+            ImmType::Shift64 => (0..64).contains(&imm),
+            ImmType::Shift64No0 => (1..64).contains(&imm),
+            ImmType::Logical32 => encode_logical_immediate_32bit(imm as u32).is_some(),
+            ImmType::Logical64 => encode_logical_immediate_64bit(imm as u64).is_some(),
+            ImmType::UnscaledOffset => (imm > -256) && (imm < 256),
+            ImmType::OffsetByte => (0..0x1000).contains(&imm),
+            ImmType::OffsetHWord => (imm & 1 == 0) && (0..0x2000).contains(&imm),
+            ImmType::OffsetWord => (imm & 3 == 0) && (0..0x4000).contains(&imm),
+            ImmType::OffsetDWord => (imm & 7 == 0) && (0..0x8000).contains(&imm),
+        }
+    }
+
+    fn location_to_reg(
+        &mut self,
+        sz: Size,
+        src: Location,
+        temps: &mut Vec<GPR>,
+        allow_imm: ImmType,
+        read_val: bool,
+        wanted: Option<GPR>,
+    ) -> Result<Location, CompileError> {
+        match src {
+            Location::GPR(_) | Location::SIMD(_) => Ok(src),
+            Location::Imm8(val) => {
+                if allow_imm == ImmType::NoneXzr && val == 0 {
+                    Ok(Location::GPR(GPR::XzrSp))
+                } else if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let tmp = if let Some(wanted) = wanted {
+                        wanted
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp);
+                        tmp
+                    };
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), val as u64)?;
+                    Ok(Location::GPR(tmp))
+                }
+            }
+            Location::Imm32(val) => {
+                if allow_imm == ImmType::NoneXzr && val == 0 {
+                    Ok(Location::GPR(GPR::XzrSp))
+                } else if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let tmp = if let Some(wanted) = wanted {
+                        wanted
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp);
+                        tmp
+                    };
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (val as i64) as u64)?;
+                    Ok(Location::GPR(tmp))
+                }
+            }
+            Location::Imm64(val) => {
+                if allow_imm == ImmType::NoneXzr && val == 0 {
+                    Ok(Location::GPR(GPR::XzrSp))
+                } else if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let tmp = if let Some(wanted) = wanted {
+                        wanted
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        temps.push(tmp);
+                        tmp
+                    };
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), val as u64)?;
+                    Ok(Location::GPR(tmp))
+                }
+            }
+            Location::Memory(reg, val) => {
+                let tmp = if let Some(wanted) = wanted {
+                    wanted
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    temps.push(tmp);
+                    tmp
+                };
+                if read_val {
+                    let offsize = match sz {
+                        Size::S8 => ImmType::OffsetByte,
+                        Size::S16 => ImmType::OffsetHWord,
+                        Size::S32 => ImmType::OffsetWord,
+                        Size::S64 => ImmType::OffsetDWord,
+                    };
+                    if sz == Size::S8 {
+                        if self.compatible_imm(val as i64, offsize) {
+                            self.assembler.emit_ldrb(
+                                sz,
+                                Location::GPR(tmp),
+                                Location::Memory(reg, val as _),
+                            )?;
+                        } else {
+                            if reg == tmp {
+                                codegen_error!("singlepass reg==tmp unreachable");
+                            }
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), (val as i64) as u64)?;
+                            self.assembler.emit_ldrb(
+                                sz,
+                                Location::GPR(tmp),
+                                Location::Memory2(reg, tmp, Multiplier::One, 0),
+                            )?;
+                        }
+                    } else if sz == Size::S16 {
+                        if self.compatible_imm(val as i64, offsize) {
+                            self.assembler.emit_ldrh(
+                                sz,
+                                Location::GPR(tmp),
+                                Location::Memory(reg, val as _),
+                            )?;
+                        } else {
+                            if reg == tmp {
+                                codegen_error!("singlepass reg==tmp unreachable");
+                            }
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), (val as i64) as u64)?;
+                            self.assembler.emit_ldrh(
+                                sz,
+                                Location::GPR(tmp),
+                                Location::Memory2(reg, tmp, Multiplier::One, 0),
+                            )?;
+                        }
+                    } else if self.compatible_imm(val as i64, offsize) {
+                        self.assembler.emit_ldr(
+                            sz,
+                            Location::GPR(tmp),
+                            Location::Memory(reg, val as _),
+                        )?;
+                    } else if self.compatible_imm(val as i64, ImmType::UnscaledOffset) {
+                        self.assembler.emit_ldur(sz, Location::GPR(tmp), reg, val)?;
+                    } else {
+                        if reg == tmp {
+                            codegen_error!("singlepass reg == tmp unreachable");
+                        }
+                        self.assembler
+                            .emit_mov_imm(Location::GPR(tmp), (val as i64) as u64)?;
+                        self.assembler.emit_ldr(
+                            sz,
+                            Location::GPR(tmp),
+                            Location::Memory2(reg, tmp, Multiplier::One, 0),
+                        )?;
+                    }
+                }
+                Ok(Location::GPR(tmp))
+            }
+            _ => codegen_error!("singlepass can't emit location_to_reg {:?} {:?}", sz, src),
+        }
+    }
+    fn location_to_neon(
+        &mut self,
+        sz: Size,
+        src: Location,
+        temps: &mut Vec<NEON>,
+        allow_imm: ImmType,
+        read_val: bool,
+    ) -> Result<Location, CompileError> {
+        match src {
+            Location::SIMD(_) => Ok(src),
+            Location::GPR(_) => {
+                let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                })?;
+                temps.push(tmp);
+                if read_val {
+                    self.assembler.emit_mov(sz, src, Location::SIMD(tmp))?;
+                }
+                Ok(Location::SIMD(tmp))
+            }
+            Location::Imm8(val) => {
+                if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let gpr = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+                    temps.push(tmp);
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(gpr), val as u64)?;
+                    self.assembler
+                        .emit_mov(sz, Location::GPR(gpr), Location::SIMD(tmp))?;
+                    self.release_gpr(gpr);
+                    Ok(Location::SIMD(tmp))
+                }
+            }
+            Location::Imm32(val) => {
+                if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let gpr = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+                    temps.push(tmp);
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(gpr), (val as i64) as u64)?;
+                    self.assembler
+                        .emit_mov(sz, Location::GPR(gpr), Location::SIMD(tmp))?;
+                    self.release_gpr(gpr);
+                    Ok(Location::SIMD(tmp))
+                }
+            }
+            Location::Imm64(val) => {
+                if self.compatible_imm(val as i64, allow_imm) {
+                    Ok(src)
+                } else {
+                    let gpr = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+                    temps.push(tmp);
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(gpr), val as u64)?;
+                    self.assembler
+                        .emit_mov(sz, Location::GPR(gpr), Location::SIMD(tmp))?;
+                    self.release_gpr(gpr);
+                    Ok(Location::SIMD(tmp))
+                }
+            }
+            Location::Memory(reg, val) => {
+                let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                })?;
+                temps.push(tmp);
+                if read_val {
+                    let offsize = if sz == Size::S32 {
+                        ImmType::OffsetWord
+                    } else {
+                        ImmType::OffsetDWord
+                    };
+                    if self.compatible_imm(val as i64, offsize) {
+                        self.assembler.emit_ldr(
+                            sz,
+                            Location::SIMD(tmp),
+                            Location::Memory(reg, val as _),
+                        )?;
+                    } else if self.compatible_imm(val as i64, ImmType::UnscaledOffset) {
+                        self.assembler
+                            .emit_ldur(sz, Location::SIMD(tmp), reg, val)?;
+                    } else {
+                        let gpr = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        self.assembler
+                            .emit_mov_imm(Location::GPR(gpr), (val as i64) as u64)?;
+                        self.assembler.emit_ldr(
+                            sz,
+                            Location::SIMD(tmp),
+                            Location::Memory2(reg, gpr, Multiplier::One, 0),
+                        )?;
+                        self.release_gpr(gpr);
+                    }
+                }
+                Ok(Location::SIMD(tmp))
+            }
+            _ => codegen_error!("singlepass can't emit location_to_neon {:?} {:?}", sz, src),
+        }
+    }
+
+    fn emit_relaxed_binop(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src: Location,
+        dst: Location,
+        putback: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src_imm = if putback {
+            ImmType::None
+        } else {
+            ImmType::Bits12
+        };
+        let src = self.location_to_reg(sz, src, &mut temps, src_imm, true, None)?;
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, !putback, None)?;
+        op(&mut self.assembler, sz, src, dest)?;
+        if dst != dest && putback {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_binop_neon(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src: Location,
+        dst: Location,
+        putback: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_neon(sz, src, &mut temps, ImmType::None, true)?;
+        let dest = self.location_to_neon(sz, dst, &mut temps, ImmType::None, !putback)?;
+        op(&mut self.assembler, sz, src, dest)?;
+        if dst != dest && putback {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_binop3(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+        allow_imm: ImmType,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(sz, src1, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(sz, src2, &mut temps, allow_imm, true, None)?;
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        op(&mut self.assembler, sz, src1, src2, dest)?;
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_binop3_neon(
+        &mut self,
+        op: fn(&mut Assembler, Size, Location, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+        allow_imm: ImmType,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_neon(sz, src1, &mut temps, ImmType::None, true)?;
+        let src2 = self.location_to_neon(sz, src2, &mut temps, allow_imm, true)?;
+        let dest = self.location_to_neon(sz, dst, &mut temps, ImmType::None, false)?;
+        op(&mut self.assembler, sz, src1, src2, dest)?;
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr64(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetDWord) {
+                    self.assembler.emit_ldr(Size::S64, dest, src)?;
+                } else if self.compatible_imm(offset as i64, ImmType::UnscaledOffset) {
+                    self.assembler.emit_ldur(Size::S64, dest, addr, offset)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldr(
+                        Size::S64,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singplass emit_relaxed_ldr64 unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr32(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetWord) {
+                    self.assembler.emit_ldr(Size::S32, dest, src)?;
+                } else if self.compatible_imm(offset as i64, ImmType::UnscaledOffset) {
+                    self.assembler.emit_ldur(Size::S32, dest, addr, offset)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldr(
+                        Size::S32,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_ldr32 unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr32s(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetWord) {
+                    self.assembler.emit_ldrsw(Size::S64, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldrsw(
+                        Size::S64,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singplepass emit_relaxed_ldr32s unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr16(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetHWord) {
+                    self.assembler.emit_ldrh(Size::S32, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldrh(
+                        Size::S32,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlpass emit_relaxed_ldr16 unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr16s(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetHWord) {
+                    self.assembler.emit_ldrsh(sz, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldrsh(
+                        sz,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_ldr16s unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr8(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetByte) {
+                    self.assembler.emit_ldrb(Size::S32, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldrb(
+                        Size::S32,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singplepass emit_relaxed_ldr8 unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_ldr8s(
+        &mut self,
+        sz: Size,
+        dst: Location,
+        src: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(sz, dst, &mut temps, ImmType::None, false, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetByte) {
+                    self.assembler.emit_ldrsb(sz, dest, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_ldrsb(
+                        sz,
+                        dest,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_ldr8s unreachable"),
+        }
+        if dst != dest {
+            self.move_location(sz, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_str64(&mut self, dst: Location, src: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dst = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::NoneXzr, true, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetDWord) {
+                    self.assembler.emit_str(Size::S64, dst, src)?;
+                } else if self.compatible_imm(offset as i64, ImmType::UnscaledOffset) {
+                    self.assembler.emit_stur(Size::S64, dst, addr, offset)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_str(
+                        Size::S64,
+                        dst,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit str64 {:?} {:?}", dst, src),
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_str32(&mut self, dst: Location, src: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dst = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::NoneXzr, true, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetWord) {
+                    self.assembler.emit_str(Size::S32, dst, src)?;
+                } else if self.compatible_imm(offset as i64, ImmType::UnscaledOffset) {
+                    self.assembler.emit_stur(Size::S32, dst, addr, offset)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_str(
+                        Size::S32,
+                        dst,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singplepass emit_relaxed_str32 unreachable"),
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_str16(&mut self, dst: Location, src: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dst = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::NoneXzr, true, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetHWord) {
+                    self.assembler.emit_strh(Size::S32, dst, src)?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_strh(
+                        Size::S32,
+                        dst,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_str16 unreachable"),
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn emit_relaxed_str8(&mut self, dst: Location, src: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dst = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::NoneXzr, true, None)?;
+        match src {
+            Location::Memory(addr, offset) => {
+                if self.compatible_imm(offset as i64, ImmType::OffsetByte) {
+                    self.assembler
+                        .emit_strb(Size::S32, dst, Location::Memory(addr, offset))?;
+                } else {
+                    let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                    self.assembler.emit_strb(
+                        Size::S32,
+                        dst,
+                        Location::Memory2(addr, tmp, Multiplier::One, 0),
+                    )?;
+                    temps.push(tmp);
+                }
+            }
+            _ => codegen_error!("singlepass emit_relaxed_str8 unreachable"),
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    /// I64 comparison with.
+    fn emit_cmpop_i64_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        match ret {
+            Location::GPR(_) => {
+                self.emit_relaxed_cmp(Size::S64, loc_b, loc_a)?;
+                self.assembler.emit_cset(Size::S32, ret, c)?;
+            }
+            Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.emit_relaxed_cmp(Size::S64, loc_b, loc_a)?;
+                self.assembler.emit_cset(Size::S32, Location::GPR(tmp), c)?;
+                self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+                self.release_gpr(tmp);
+            }
+            _ => {
+                codegen_error!("singlepass emit_compop_i64_dynamic_b unreachable");
+            }
+        }
+        Ok(())
+    }
+    /// I32 comparison with.
+    fn emit_cmpop_i32_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        match ret {
+            Location::GPR(_) => {
+                self.emit_relaxed_cmp(Size::S32, loc_b, loc_a)?;
+                self.assembler.emit_cset(Size::S32, ret, c)?;
+            }
+            Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.emit_relaxed_cmp(Size::S32, loc_b, loc_a)?;
+                self.assembler.emit_cset(Size::S32, Location::GPR(tmp), c)?;
+                self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+                self.release_gpr(tmp);
+            }
+            _ => {
+                codegen_error!("singlepass emit_cmpop_i32_dynamic_b unreachable");
+            }
+        }
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn memory_op<F: FnOnce(&mut Self, GPR) -> Result<(), CompileError>>(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        check_alignment: bool,
+        value_size: usize,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+        cb: F,
+    ) -> Result<(), CompileError> {
+        let tmp_addr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Reusing `tmp_addr` for temporary indirection here, since it's not used before the last reference to `{base,bound}_loc`.
+        let (base_loc, bound_loc) = if imported_memories {
+            // Imported memories require one level of indirection.
+            self.emit_relaxed_binop(
+                Assembler::emit_mov,
+                Size::S64,
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::GPR(tmp_addr),
+                true,
+            )?;
+            (Location::Memory(tmp_addr, 0), Location::Memory(tmp_addr, 8))
+        } else {
+            (
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::Memory(self.get_vmctx_reg(), offset + 8),
+            )
+        };
+
+        let tmp_base = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_bound = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Load base into temporary register.
+        self.emit_relaxed_ldr64(Size::S64, Location::GPR(tmp_base), base_loc)?;
+
+        // Load bound into temporary register, if needed.
+        if need_check {
+            self.emit_relaxed_ldr64(Size::S64, Location::GPR(tmp_bound), bound_loc)?;
+
+            // Wasm -> Effective.
+            // Assuming we never underflow - should always be true on Linux/macOS and Windows >=8,
+            // since the first page from 0x0 to 0x1000 is not accepted by mmap.
+            self.assembler.emit_add(
+                Size::S64,
+                Location::GPR(tmp_bound),
+                Location::GPR(tmp_base),
+                Location::GPR(tmp_bound),
+            )?;
+            if self.compatible_imm(value_size as _, ImmType::Bits12) {
+                self.assembler.emit_sub(
+                    Size::S64,
+                    Location::GPR(tmp_bound),
+                    Location::Imm32(value_size as _),
+                    Location::GPR(tmp_bound),
+                )?;
+            } else {
+                let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.assembler
+                    .emit_mov_imm(Location::GPR(tmp2), value_size as u64)?;
+                self.assembler.emit_sub(
+                    Size::S64,
+                    Location::GPR(tmp_bound),
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp_bound),
+                )?;
+                self.release_gpr(tmp2);
+            }
+        }
+
+        // Load effective address.
+        // `base_loc` and `bound_loc` becomes INVALID after this line, because `tmp_addr`
+        // might be reused.
+        self.move_location(Size::S32, addr, Location::GPR(tmp_addr))?;
+
+        // Add offset to memory address.
+        if memarg.offset != 0 {
+            if self.compatible_imm(memarg.offset as _, ImmType::Bits12) {
+                self.assembler.emit_adds(
+                    Size::S32,
+                    Location::Imm32(memarg.offset as u32),
+                    Location::GPR(tmp_addr),
+                    Location::GPR(tmp_addr),
+                )?;
+            } else {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.assembler
+                    .emit_mov_imm(Location::GPR(tmp), memarg.offset as _)?;
+                self.assembler.emit_adds(
+                    Size::S32,
+                    Location::GPR(tmp_addr),
+                    Location::GPR(tmp),
+                    Location::GPR(tmp_addr),
+                )?;
+                self.release_gpr(tmp);
+            }
+
+            // Trap if offset calculation overflowed.
+            self.assembler
+                .emit_bcond_label_far(Condition::Cs, heap_access_oob)?;
+        }
+
+        // Wasm linear memory -> real memory
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(tmp_base),
+            Location::GPR(tmp_addr),
+            Location::GPR(tmp_addr),
+        )?;
+
+        if need_check {
+            // Trap if the end address of the requested area is above that of the linear memory.
+            self.assembler.emit_cmp(
+                Size::S64,
+                Location::GPR(tmp_bound),
+                Location::GPR(tmp_addr),
+            )?;
+
+            // `tmp_bound` is inclusive. So trap only if `tmp_addr > tmp_bound`.
+            self.assembler
+                .emit_bcond_label_far(Condition::Hi, heap_access_oob)?;
+        }
+
+        self.release_gpr(tmp_bound);
+        self.release_gpr(tmp_base);
+
+        let align = value_size as u32;
+        if check_alignment && align != 1 {
+            self.assembler.emit_tst(
+                Size::S64,
+                Location::Imm32(align - 1),
+                Location::GPR(tmp_addr),
+            )?;
+            self.assembler
+                .emit_bcond_label_far(Condition::Ne, unaligned_atomic)?;
+        }
+        let begin = self.assembler.get_offset().0;
+        cb(self, tmp_addr)?;
+        let end = self.assembler.get_offset().0;
+        self.mark_address_range_with_trap_code(TrapCode::HeapAccessOutOfBounds, begin, end);
+
+        self.release_gpr(tmp_addr);
+        Ok(())
+    }
+
+    /*fn emit_compare_and_swap<F: FnOnce(&mut Self, GPR, GPR)>(
+        &mut self,
+        _loc: Location,
+        _target: Location,
+        _ret: Location,
+        _memarg: &MemArg,
+        _value_size: usize,
+        _memory_sz: Size,
+        _stack_sz: Size,
+        _need_check: bool,
+        _imported_memories: bool,
+        _offset: i32,
+        _heap_access_oob: Label,
+        _unaligned_atomic: Label,
+        _cb: F,
+    ) {
+        unimplemented!();
+    }*/
+
+    fn offset_is_ok(&self, size: Size, offset: i32) -> bool {
+        if offset < 0 {
+            return false;
+        }
+        let shift = match size {
+            Size::S8 => 0,
+            Size::S16 => 1,
+            Size::S32 => 2,
+            Size::S64 => 3,
+        };
+        if offset >= 0x1000 << shift {
+            return false;
+        }
+        if (offset & ((1 << shift) - 1)) != 0 {
+            return false;
+        }
+        true
+    }
+
+    fn emit_push(&mut self, sz: Size, src: Location) -> Result<(), CompileError> {
+        match (sz, src) {
+            (Size::S64, Location::GPR(_)) | (Size::S64, Location::SIMD(_)) => {
+                let offset = if self.pushed {
+                    0
+                } else {
+                    self.assembler.emit_sub(
+                        Size::S64,
+                        Location::GPR(GPR::XzrSp),
+                        Location::Imm8(16),
+                        Location::GPR(GPR::XzrSp),
+                    )?;
+                    8
+                };
+                self.assembler
+                    .emit_stur(Size::S64, src, GPR::XzrSp, offset)?;
+                self.pushed = !self.pushed;
+            }
+            (Size::S64, _) => {
+                let mut temps = vec![];
+                let src = self.location_to_reg(sz, src, &mut temps, ImmType::None, true, None)?;
+                let offset = if self.pushed {
+                    0
+                } else {
+                    self.assembler.emit_sub(
+                        Size::S64,
+                        Location::GPR(GPR::XzrSp),
+                        Location::Imm8(16),
+                        Location::GPR(GPR::XzrSp),
+                    )?;
+                    8
+                };
+                self.assembler
+                    .emit_stur(Size::S64, src, GPR::XzrSp, offset)?;
+                self.pushed = !self.pushed;
+                for r in temps {
+                    self.release_gpr(r);
+                }
+            }
+            _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", sz, src),
+        }
+        Ok(())
+    }
+    fn emit_double_push(
+        &mut self,
+        sz: Size,
+        src1: Location,
+        src2: Location,
+    ) -> Result<(), CompileError> {
+        if !self.pushed {
+            match (sz, src1, src2) {
+                (Size::S64, Location::GPR(_), Location::GPR(_)) => {
+                    self.assembler
+                        .emit_stpdb(Size::S64, src1, src2, GPR::XzrSp, 16)?;
+                }
+                _ => {
+                    self.emit_push(sz, src1)?;
+                    self.emit_push(sz, src2)?;
+                }
+            }
+        } else {
+            self.emit_push(sz, src1)?;
+            self.emit_push(sz, src2)?;
+        }
+        Ok(())
+    }
+    fn emit_pop(&mut self, sz: Size, dst: Location) -> Result<(), CompileError> {
+        match (sz, dst) {
+            (Size::S64, Location::GPR(_)) | (Size::S64, Location::SIMD(_)) => {
+                let offset = if self.pushed { 8 } else { 0 };
+                self.assembler
+                    .emit_ldur(Size::S64, dst, GPR::XzrSp, offset)?;
+                if self.pushed {
+                    self.assembler.emit_add(
+                        Size::S64,
+                        Location::GPR(GPR::XzrSp),
+                        Location::Imm8(16),
+                        Location::GPR(GPR::XzrSp),
+                    )?;
+                }
+                self.pushed = !self.pushed;
+            }
+            _ => codegen_error!("singlepass can't emit PUSH {:?} {:?}", sz, dst),
+        }
+        Ok(())
+    }
+    fn emit_double_pop(
+        &mut self,
+        sz: Size,
+        dst1: Location,
+        dst2: Location,
+    ) -> Result<(), CompileError> {
+        if !self.pushed {
+            match (sz, dst1, dst2) {
+                (Size::S64, Location::GPR(_), Location::GPR(_)) => {
+                    self.assembler
+                        .emit_ldpia(Size::S64, dst1, dst2, GPR::XzrSp, 16)?;
+                }
+                _ => {
+                    self.emit_pop(sz, dst2)?;
+                    self.emit_pop(sz, dst1)?;
+                }
+            }
+        } else {
+            self.emit_pop(sz, dst2)?;
+            self.emit_pop(sz, dst1)?;
+        }
+        Ok(())
+    }
+
+    fn set_default_nan(&mut self, temps: &mut Vec<GPR>) -> Result<GPR, CompileError> {
+        // temporarly set FPCR to DefaultNan
+        let old_fpcr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(old_fpcr);
+        self.assembler.emit_read_fpcr(old_fpcr)?;
+        let new_fpcr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(new_fpcr);
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(tmp);
+        self.assembler
+            .emit_mov(Size::S32, Location::Imm32(1), Location::GPR(tmp))?;
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(old_fpcr), Location::GPR(new_fpcr))?;
+        // DN is bit 25 of FPCR
+        self.assembler.emit_bfi(
+            Size::S64,
+            Location::GPR(tmp),
+            25,
+            1,
+            Location::GPR(new_fpcr),
+        )?;
+        self.assembler.emit_write_fpcr(new_fpcr)?;
+        Ok(old_fpcr)
+    }
+    fn set_trap_enabled(&mut self, temps: &mut Vec<GPR>) -> Result<GPR, CompileError> {
+        // temporarly set FPCR to DefaultNan
+        let old_fpcr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(old_fpcr);
+        self.assembler.emit_read_fpcr(old_fpcr)?;
+        let new_fpcr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(new_fpcr);
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(old_fpcr), Location::GPR(new_fpcr))?;
+        // IOE is bit 8 of FPCR
+        self.assembler
+            .emit_bfc(Size::S64, 8, 1, Location::GPR(new_fpcr))?;
+        self.assembler.emit_write_fpcr(new_fpcr)?;
+        Ok(old_fpcr)
+    }
+    fn restore_fpcr(&mut self, old_fpcr: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_write_fpcr(old_fpcr)
+    }
+
+    fn reset_exception_fpsr(&mut self) -> Result<(), CompileError> {
+        // reset exception count in FPSR
+        let fpsr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler.emit_read_fpsr(fpsr)?;
+        // IOC is 0
+        self.assembler
+            .emit_bfc(Size::S64, 0, 1, Location::GPR(fpsr))?;
+        self.assembler.emit_write_fpsr(fpsr)?;
+        self.release_gpr(fpsr);
+        Ok(())
+    }
+    fn read_fpsr(&mut self) -> Result<GPR, CompileError> {
+        let fpsr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler.emit_read_fpsr(fpsr)?;
+        Ok(fpsr)
+    }
+
+    fn trap_float_convertion_errors(
+        &mut self,
+        old_fpcr: GPR,
+        sz: Size,
+        f: Location,
+        temps: &mut Vec<GPR>,
+    ) -> Result<(), CompileError> {
+        let trap_badconv = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        let fpsr = self.read_fpsr()?;
+        temps.push(fpsr);
+        // no trap, than all good
+        self.assembler
+            .emit_tbz_label(Size::S32, Location::GPR(fpsr), 0, end)?;
+        // now need to check if it's overflow or NaN
+        self.assembler
+            .emit_bfc(Size::S64, 0, 4, Location::GPR(fpsr))?;
+        self.restore_fpcr(old_fpcr)?;
+        self.assembler.emit_fcmp(sz, f, f)?;
+        self.assembler
+            .emit_bcond_label(Condition::Vs, trap_badconv)?;
+        // fallthru: trap_overflow
+        self.emit_illegal_op_internal(TrapCode::IntegerOverflow)?;
+
+        self.emit_label(trap_badconv)?;
+        self.emit_illegal_op_internal(TrapCode::BadConversionToInteger)?;
+
+        self.emit_label(end)?;
+        self.restore_fpcr(old_fpcr)
+    }
+
+    fn used_gprs_contains(&self, r: &GPR) -> bool {
+        self.used_gprs & (1 << r.into_index()) != 0
+    }
+    fn used_simd_contains(&self, r: &NEON) -> bool {
+        self.used_simd & (1 << r.into_index()) != 0
+    }
+    fn used_gprs_insert(&mut self, r: GPR) {
+        self.used_gprs |= 1 << r.into_index();
+    }
+    fn used_simd_insert(&mut self, r: NEON) {
+        self.used_simd |= 1 << r.into_index();
+    }
+    fn used_gprs_remove(&mut self, r: &GPR) -> bool {
+        let ret = self.used_gprs_contains(r);
+        self.used_gprs &= !(1 << r.into_index());
+        ret
+    }
+    fn used_simd_remove(&mut self, r: &NEON) -> bool {
+        let ret = self.used_simd_contains(r);
+        self.used_simd &= !(1 << r.into_index());
+        ret
+    }
+    fn emit_unwind_op(&mut self, op: UnwindOps) {
+        self.unwind_ops.push((self.get_offset().0, op));
+    }
+    fn emit_illegal_op_internal(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        self.assembler.emit_udf(0xc0 | (trap as u8) as u16)
+    }
+}
+
+impl Machine for MachineARM64 {
+    type GPR = GPR;
+    type SIMD = NEON;
+    fn assembler_get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+    fn index_from_gpr(&self, x: GPR) -> RegisterIndex {
+        RegisterIndex(x as usize)
+    }
+    fn index_from_simd(&self, x: NEON) -> RegisterIndex {
+        RegisterIndex(x as usize + 32)
+    }
+
+    fn get_vmctx_reg(&self) -> GPR {
+        GPR::X28
+    }
+
+    fn get_used_gprs(&self) -> Vec<GPR> {
+        GPR::iterator()
+            .filter(|x| self.used_gprs & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+
+    fn get_used_simd(&self) -> Vec<NEON> {
+        NEON::iterator()
+            .filter(|x| self.used_simd & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+
+    fn pick_gpr(&self) -> Option<GPR> {
+        use GPR::*;
+        static REGS: &[GPR] = &[X9, X10, X11, X12, X13, X14, X15];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused general purpose register for internal temporary use.
+    fn pick_temp_gpr(&self) -> Option<GPR> {
+        use GPR::*;
+        static REGS: &[GPR] = &[X8, X7, X6, X5, X4, X3, X2, X1];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    fn acquire_temp_gpr(&mut self) -> Option<GPR> {
+        let gpr = self.pick_temp_gpr();
+        if let Some(x) = gpr {
+            self.used_gprs_insert(x);
+        }
+        gpr
+    }
+
+    fn release_gpr(&mut self, gpr: GPR) {
+        assert!(self.used_gprs_remove(&gpr));
+    }
+
+    fn reserve_unused_temp_gpr(&mut self, gpr: GPR) -> GPR {
+        assert!(!self.used_gprs_contains(&gpr));
+        self.used_gprs_insert(gpr);
+        gpr
+    }
+
+    fn reserve_gpr(&mut self, gpr: GPR) {
+        self.used_gprs_insert(gpr);
+    }
+
+    fn push_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<usize, CompileError> {
+        if used_gprs.len() % 2 == 1 {
+            self.emit_push(Size::S64, Location::GPR(GPR::XzrSp))?;
+        }
+        for r in used_gprs.iter() {
+            self.emit_push(Size::S64, Location::GPR(*r))?;
+        }
+        Ok(((used_gprs.len() + 1) / 2) * 16)
+    }
+    fn pop_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<(), CompileError> {
+        for r in used_gprs.iter().rev() {
+            self.emit_pop(Size::S64, Location::GPR(*r))?;
+        }
+        if used_gprs.len() % 2 == 1 {
+            self.emit_pop(Size::S64, Location::GPR(GPR::XzrSp))?;
+        }
+        Ok(())
+    }
+
+    // Picks an unused NEON register.
+    fn pick_simd(&self) -> Option<NEON> {
+        use NEON::*;
+        static REGS: &[NEON] = &[V8, V9, V10, V11, V12];
+        for r in REGS {
+            if !self.used_simd_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused NEON register for internal temporary use.
+    fn pick_temp_simd(&self) -> Option<NEON> {
+        use NEON::*;
+        static REGS: &[NEON] = &[V0, V1, V2, V3, V4, V5, V6, V7];
+        for r in REGS {
+            if !self.used_simd_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Acquires a temporary NEON register.
+    fn acquire_temp_simd(&mut self) -> Option<NEON> {
+        let simd = self.pick_temp_simd();
+        if let Some(x) = simd {
+            self.used_simd_insert(x);
+        }
+        simd
+    }
+
+    fn reserve_simd(&mut self, simd: NEON) {
+        self.used_simd_insert(simd);
+    }
+
+    // Releases a temporary NEON register.
+    fn release_simd(&mut self, simd: NEON) {
+        assert!(self.used_simd_remove(&simd));
+    }
+
+    fn push_used_simd(&mut self, used_neons: &[NEON]) -> Result<usize, CompileError> {
+        let stack_adjust = if used_neons.len() & 1 == 1 {
+            (used_neons.len() * 8) as u32 + 8
+        } else {
+            (used_neons.len() * 8) as u32
+        };
+        self.adjust_stack(stack_adjust)?;
+
+        for (i, r) in used_neons.iter().enumerate() {
+            self.assembler.emit_str(
+                Size::S64,
+                Location::SIMD(*r),
+                Location::Memory(GPR::XzrSp, (i * 8) as i32),
+            )?;
+        }
+        Ok(stack_adjust as usize)
+    }
+    fn pop_used_simd(&mut self, used_neons: &[NEON]) -> Result<(), CompileError> {
+        for (i, r) in used_neons.iter().enumerate() {
+            self.assembler.emit_ldr(
+                Size::S64,
+                Location::SIMD(*r),
+                Location::Memory(GPR::XzrSp, (i * 8) as i32),
+            )?;
+        }
+        let stack_adjust = if used_neons.len() & 1 == 1 {
+            (used_neons.len() * 8) as u32 + 8
+        } else {
+            (used_neons.len() * 8) as u32
+        };
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::XzrSp),
+            Location::Imm32(stack_adjust as _),
+            Location::GPR(GPR::XzrSp),
+        )
+    }
+
+    /// Set the source location of the Wasm to the given offset.
+    fn set_srcloc(&mut self, offset: u32) {
+        self.src_loc = offset;
+    }
+    /// Marks each address in the code range emitted by `f` with the trap code `code`.
+    fn mark_address_range_with_trap_code(&mut self, code: TrapCode, begin: usize, end: usize) {
+        for i in begin..end {
+            self.trap_table.offset_to_code.insert(i, code);
+        }
+        self.mark_instruction_address_end(begin);
+    }
+
+    /// Marks one address as trappable with trap code `code`.
+    fn mark_address_with_trap_code(&mut self, code: TrapCode) {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        self.mark_instruction_address_end(offset);
+    }
+    /// Marks the instruction as trappable with trap code `code`. return "begin" offset
+    fn mark_instruction_with_trap_code(&mut self, code: TrapCode) -> usize {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        offset
+    }
+    /// Pushes the instruction to the address map, calculating the offset from a
+    /// provided beginning address.
+    fn mark_instruction_address_end(&mut self, begin: usize) {
+        self.instructions_address_map.push(InstructionAddressMap {
+            srcloc: SourceLoc::new(self.src_loc),
+            code_offset: begin,
+            code_len: self.assembler.get_offset().0 - begin,
+        });
+    }
+
+    /// Insert a StackOverflow (at offset 0)
+    fn insert_stackoverflow(&mut self) {
+        let offset = 0;
+        self.trap_table
+            .offset_to_code
+            .insert(offset, TrapCode::StackOverflow);
+        self.mark_instruction_address_end(offset);
+    }
+
+    /// Get all current TrapInformation
+    fn collect_trap_information(&self) -> Vec<TrapInformation> {
+        self.trap_table
+            .offset_to_code
+            .clone()
+            .into_iter()
+            .map(|(offset, code)| TrapInformation {
+                code_offset: offset as u32,
+                trap_code: code,
+            })
+            .collect()
+    }
+
+    fn instructions_address_map(&self) -> Vec<InstructionAddressMap> {
+        self.instructions_address_map.clone()
+    }
+
+    // Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)
+    fn round_stack_adjust(&self, value: usize) -> usize {
+        if value & 0xf != 0 {
+            ((value >> 4) + 1) << 4
+        } else {
+            value
+        }
+    }
+
+    // Memory location for a local on the stack
+    fn local_on_stack(&mut self, stack_offset: i32) -> Location {
+        Location::Memory(GPR::X29, -stack_offset)
+    }
+
+    // Adjust stack for locals
+    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        let delta = if self.compatible_imm(delta_stack_offset as _, ImmType::Bits12) {
+            Location::Imm32(delta_stack_offset as _)
+        } else {
+            let tmp = GPR::X17;
+            self.assembler
+                .emit_mov_imm(Location::GPR(tmp), delta_stack_offset as u64)?;
+            Location::GPR(tmp)
+        };
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::GPR(GPR::XzrSp),
+            delta,
+            Location::GPR(GPR::XzrSp),
+        )
+    }
+    // restore stack
+    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        let delta = if self.compatible_imm(delta_stack_offset as _, ImmType::Bits12) {
+            Location::Imm32(delta_stack_offset as _)
+        } else {
+            let tmp = GPR::X17;
+            self.assembler
+                .emit_mov_imm(Location::GPR(tmp), delta_stack_offset as u64)?;
+            Location::GPR(tmp)
+        };
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::XzrSp),
+            delta,
+            Location::GPR(GPR::XzrSp),
+        )
+    }
+    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        let real_delta = if delta_stack_offset & 15 != 0 {
+            delta_stack_offset + 8
+        } else {
+            delta_stack_offset
+        };
+        let delta = if self.compatible_imm(real_delta as i64, ImmType::Bits12) {
+            Location::Imm32(real_delta as _)
+        } else {
+            let tmp = GPR::X17;
+            self.assembler
+                .emit_mov_imm(Location::GPR(tmp), real_delta as u64)?;
+            Location::GPR(tmp)
+        };
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::XzrSp),
+            delta,
+            Location::GPR(GPR::XzrSp),
+        )
+    }
+    // push a value on the stack for a native call
+    fn move_location_for_native(
+        &mut self,
+        size: Size,
+        loc: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match loc {
+            Location::Imm64(_)
+            | Location::Imm32(_)
+            | Location::Imm8(_)
+            | Location::Memory(_, _)
+            | Location::Memory2(_, _, _, _) => {
+                self.move_location(size, loc, Location::GPR(GPR::X17))?;
+                self.move_location(size, Location::GPR(GPR::X17), dest)
+            }
+            _ => self.move_location(size, loc, dest),
+        }
+    }
+
+    // Zero a location that is 32bits
+    fn zero_location(&mut self, size: Size, location: Location) -> Result<(), CompileError> {
+        self.move_location(size, Location::GPR(GPR::XzrSp), location)
+    }
+
+    // GPR Reg used for local pointer on the stack
+    fn local_pointer(&self) -> GPR {
+        GPR::X29
+    }
+
+    // Determine whether a local should be allocated on the stack.
+    fn is_local_on_stack(&self, idx: usize) -> bool {
+        idx > 7
+    }
+
+    // Determine a local's location.
+    fn get_local_location(&self, idx: usize, callee_saved_regs_size: usize) -> Location {
+        // Use callee-saved registers for the first locals.
+        match idx {
+            0 => Location::GPR(GPR::X19),
+            1 => Location::GPR(GPR::X20),
+            2 => Location::GPR(GPR::X21),
+            3 => Location::GPR(GPR::X22),
+            4 => Location::GPR(GPR::X23),
+            5 => Location::GPR(GPR::X24),
+            6 => Location::GPR(GPR::X25),
+            7 => Location::GPR(GPR::X26),
+            _ => Location::Memory(GPR::X29, -(((idx - 7) * 8 + callee_saved_regs_size) as i32)),
+        }
+    }
+    // Move a local to the stack
+    fn move_local(&mut self, stack_offset: i32, location: Location) -> Result<(), CompileError> {
+        if stack_offset < 256 {
+            self.assembler
+                .emit_stur(Size::S64, location, GPR::X29, -stack_offset)?;
+        } else {
+            let tmp = GPR::X17;
+            if stack_offset < 0x1_0000 {
+                self.assembler
+                    .emit_mov_imm(Location::GPR(tmp), (-stack_offset as i64) as u64)?;
+                self.assembler.emit_str(
+                    Size::S64,
+                    location,
+                    Location::Memory2(GPR::X29, tmp, Multiplier::One, 0),
+                )?;
+            } else {
+                self.assembler
+                    .emit_mov_imm(Location::GPR(tmp), (stack_offset as i64) as u64)?;
+                self.assembler.emit_sub(
+                    Size::S64,
+                    Location::GPR(GPR::X29),
+                    Location::GPR(tmp),
+                    Location::GPR(tmp),
+                )?;
+                self.assembler
+                    .emit_str(Size::S64, location, Location::GPR(tmp))?;
+            }
+        }
+        match location {
+            Location::GPR(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: x.to_dwarf(),
+                bp_neg_offset: stack_offset,
+            }),
+            Location::SIMD(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: x.to_dwarf(),
+                bp_neg_offset: stack_offset,
+            }),
+            _ => (),
+        }
+        Ok(())
+    }
+
+    // List of register to save, depending on the CallingConvention
+    fn list_to_save(&self, _calling_convention: CallingConvention) -> Vec<Location> {
+        vec![]
+    }
+
+    // Get param location, MUST be called in order!
+    fn get_param_location(
+        &self,
+        idx: usize,
+        sz: Size,
+        stack_args: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        match calling_convention {
+            CallingConvention::AppleAarch64 => match idx {
+                0 => Location::GPR(GPR::X0),
+                1 => Location::GPR(GPR::X1),
+                2 => Location::GPR(GPR::X2),
+                3 => Location::GPR(GPR::X3),
+                4 => Location::GPR(GPR::X4),
+                5 => Location::GPR(GPR::X5),
+                6 => Location::GPR(GPR::X6),
+                7 => Location::GPR(GPR::X7),
+                _ => {
+                    let sz = 1
+                        << match sz {
+                            Size::S8 => 0,
+                            Size::S16 => 1,
+                            Size::S32 => 2,
+                            Size::S64 => 3,
+                        };
+                    // align first
+                    if sz > 1 && *stack_args & (sz - 1) != 0 {
+                        *stack_args = (*stack_args + (sz - 1)) & !(sz - 1);
+                    }
+                    let loc = Location::Memory(GPR::XzrSp, *stack_args as i32);
+                    *stack_args += sz;
+                    loc
+                }
+            },
+            _ => match idx {
+                0 => Location::GPR(GPR::X0),
+                1 => Location::GPR(GPR::X1),
+                2 => Location::GPR(GPR::X2),
+                3 => Location::GPR(GPR::X3),
+                4 => Location::GPR(GPR::X4),
+                5 => Location::GPR(GPR::X5),
+                6 => Location::GPR(GPR::X6),
+                7 => Location::GPR(GPR::X7),
+                _ => {
+                    let loc = Location::Memory(GPR::XzrSp, *stack_args as i32);
+                    *stack_args += 8;
+                    loc
+                }
+            },
+        }
+    }
+    // Get call param location, MUST be called in order!
+    fn get_call_param_location(
+        &self,
+        idx: usize,
+        sz: Size,
+        stack_args: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        match calling_convention {
+            CallingConvention::AppleAarch64 => match idx {
+                0 => Location::GPR(GPR::X0),
+                1 => Location::GPR(GPR::X1),
+                2 => Location::GPR(GPR::X2),
+                3 => Location::GPR(GPR::X3),
+                4 => Location::GPR(GPR::X4),
+                5 => Location::GPR(GPR::X5),
+                6 => Location::GPR(GPR::X6),
+                7 => Location::GPR(GPR::X7),
+                _ => {
+                    let sz = 1
+                        << match sz {
+                            Size::S8 => 0,
+                            Size::S16 => 1,
+                            Size::S32 => 2,
+                            Size::S64 => 3,
+                        };
+                    // align first
+                    if sz > 1 && *stack_args & (sz - 1) != 0 {
+                        *stack_args = (*stack_args + (sz - 1)) & !(sz - 1);
+                    }
+                    let loc = Location::Memory(GPR::X29, 16 * 2 + *stack_args as i32);
+                    *stack_args += sz;
+                    loc
+                }
+            },
+            _ => match idx {
+                0 => Location::GPR(GPR::X0),
+                1 => Location::GPR(GPR::X1),
+                2 => Location::GPR(GPR::X2),
+                3 => Location::GPR(GPR::X3),
+                4 => Location::GPR(GPR::X4),
+                5 => Location::GPR(GPR::X5),
+                6 => Location::GPR(GPR::X6),
+                7 => Location::GPR(GPR::X7),
+                _ => {
+                    let loc = Location::Memory(GPR::X29, 16 * 2 + *stack_args as i32);
+                    *stack_args += 8;
+                    loc
+                }
+            },
+        }
+    }
+    // Get simple param location, Will not be accurate for Apple calling convention on "stack" arguments
+    fn get_simple_param_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        #[allow(clippy::match_single_binding)]
+        match calling_convention {
+            _ => match idx {
+                0 => Location::GPR(GPR::X0),
+                1 => Location::GPR(GPR::X1),
+                2 => Location::GPR(GPR::X2),
+                3 => Location::GPR(GPR::X3),
+                4 => Location::GPR(GPR::X4),
+                5 => Location::GPR(GPR::X5),
+                6 => Location::GPR(GPR::X6),
+                7 => Location::GPR(GPR::X7),
+                _ => Location::Memory(GPR::X29, (16 * 2 + (idx - 8) * 8) as i32),
+            },
+        }
+    }
+    // move a location to another
+    fn move_location(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match source {
+            Location::GPR(_) | Location::SIMD(_) => match dest {
+                Location::GPR(_) | Location::SIMD(_) => self.assembler.emit_mov(size, source, dest),
+                Location::Memory(addr, offs) => {
+                    if self.offset_is_ok(size, offs) {
+                        self.assembler.emit_str(size, source, dest)
+                    } else if self.compatible_imm(offs as i64, ImmType::UnscaledOffset) {
+                        self.assembler.emit_stur(size, source, addr, offs)
+                    } else {
+                        let tmp = GPR::X17;
+                        if offs < 0 {
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), (-offs) as u64)?;
+                            self.assembler.emit_sub(
+                                Size::S64,
+                                Location::GPR(addr),
+                                Location::GPR(tmp),
+                                Location::GPR(tmp),
+                            )?;
+                        } else {
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), offs as u64)?;
+                            self.assembler.emit_add(
+                                Size::S64,
+                                Location::GPR(addr),
+                                Location::GPR(tmp),
+                                Location::GPR(tmp),
+                            )?;
+                        }
+                        self.assembler
+                            .emit_str(size, source, Location::Memory(tmp, 0))
+                    }
+                }
+                _ => codegen_error!(
+                    "singlepass can't emit move_location {:?} {:?} => {:?}",
+                    size,
+                    source,
+                    dest
+                ),
+            },
+            Location::Imm8(_) => match dest {
+                Location::GPR(_) => self.assembler.emit_mov(size, source, dest),
+                Location::Memory(_, _) => match size {
+                    Size::S64 => self.emit_relaxed_str64(source, dest),
+                    Size::S32 => self.emit_relaxed_str32(source, dest),
+                    Size::S16 => self.emit_relaxed_str16(source, dest),
+                    Size::S8 => self.emit_relaxed_str8(source, dest),
+                },
+                _ => codegen_error!(
+                    "singlepass can't emit move_location {:?} {:?} => {:?}",
+                    size,
+                    source,
+                    dest
+                ),
+            },
+            Location::Imm32(val) => match dest {
+                Location::GPR(_) => self.assembler.emit_mov_imm(dest, val as u64),
+                Location::Memory(_, _) => match size {
+                    Size::S64 => self.emit_relaxed_str64(source, dest),
+                    Size::S32 => self.emit_relaxed_str32(source, dest),
+                    Size::S16 => self.emit_relaxed_str16(source, dest),
+                    Size::S8 => self.emit_relaxed_str8(source, dest),
+                },
+                _ => codegen_error!(
+                    "singlepass can't emit move_location {:?} {:?} => {:?}",
+                    size,
+                    source,
+                    dest
+                ),
+            },
+            Location::Imm64(val) => match dest {
+                Location::GPR(_) => self.assembler.emit_mov_imm(dest, val),
+                Location::Memory(_, _) => match size {
+                    Size::S64 => self.emit_relaxed_str64(source, dest),
+                    Size::S32 => self.emit_relaxed_str32(source, dest),
+                    Size::S16 => self.emit_relaxed_str16(source, dest),
+                    Size::S8 => self.emit_relaxed_str8(source, dest),
+                },
+                _ => codegen_error!(
+                    "singlepass can't emit move_location {:?} {:?} => {:?}",
+                    size,
+                    source,
+                    dest
+                ),
+            },
+            Location::Memory(addr, offs) => match dest {
+                Location::GPR(_) | Location::SIMD(_) => {
+                    if self.offset_is_ok(size, offs) {
+                        self.assembler.emit_ldr(size, dest, source)
+                    } else if offs > -256 && offs < 256 {
+                        self.assembler.emit_ldur(size, dest, addr, offs)
+                    } else {
+                        let tmp = GPR::X17;
+                        if offs < 0 {
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), (-offs) as u64)?;
+                            self.assembler.emit_sub(
+                                Size::S64,
+                                Location::GPR(addr),
+                                Location::GPR(tmp),
+                                Location::GPR(tmp),
+                            )?;
+                        } else {
+                            self.assembler
+                                .emit_mov_imm(Location::GPR(tmp), offs as u64)?;
+                            self.assembler.emit_add(
+                                Size::S64,
+                                Location::GPR(addr),
+                                Location::GPR(tmp),
+                                Location::GPR(tmp),
+                            )?;
+                        }
+                        self.assembler
+                            .emit_ldr(size, dest, Location::Memory(tmp, 0))
+                    }
+                }
+                _ => {
+                    let mut temps = vec![];
+                    let src =
+                        self.location_to_reg(size, source, &mut temps, ImmType::None, true, None)?;
+                    self.move_location(size, src, dest)?;
+                    for r in temps {
+                        self.release_gpr(r);
+                    }
+                    Ok(())
+                }
+            },
+            _ => codegen_error!(
+                "singlepass can't emit move_location {:?} {:?} => {:?}",
+                size,
+                source,
+                dest
+            ),
+        }
+    }
+    // move a location to another
+    fn move_location_extend(
+        &mut self,
+        size_val: Size,
+        signed: bool,
+        source: Location,
+        size_op: Size,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        if size_op != Size::S64 {
+            codegen_error!("singlepass move_location_extend unreachable");
+        }
+        let mut temps = vec![];
+        let dst = self.location_to_reg(size_op, dest, &mut temps, ImmType::None, false, None)?;
+        let src = match (size_val, signed, source) {
+            (Size::S64, _, _) => source,
+            (Size::S32, false, Location::GPR(_)) => {
+                self.assembler.emit_mov(size_val, source, dst)?;
+                dst
+            }
+            (Size::S8, false, Location::GPR(_)) => {
+                self.assembler.emit_uxtb(size_op, source, dst)?;
+                dst
+            }
+            (Size::S16, false, Location::GPR(_)) => {
+                self.assembler.emit_uxth(size_op, source, dst)?;
+                dst
+            }
+            (Size::S8, true, Location::GPR(_)) => {
+                self.assembler.emit_sxtb(size_op, source, dst)?;
+                dst
+            }
+            (Size::S16, true, Location::GPR(_)) => {
+                self.assembler.emit_sxth(size_op, source, dst)?;
+                dst
+            }
+            (Size::S32, true, Location::GPR(_)) => {
+                self.assembler.emit_sxtw(size_op, source, dst)?;
+                dst
+            }
+            (Size::S32, false, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr32(size_op, dst, source)?;
+                dst
+            }
+            (Size::S32, true, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr32s(size_op, dst, source)?;
+                dst
+            }
+            (Size::S16, false, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr16(size_op, dst, source)?;
+                dst
+            }
+            (Size::S16, true, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr16s(size_op, dst, source)?;
+                dst
+            }
+            (Size::S8, false, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr8(size_op, dst, source)?;
+                dst
+            }
+            (Size::S8, true, Location::Memory(_, _)) => {
+                self.emit_relaxed_ldr8s(size_op, dst, source)?;
+                dst
+            }
+            _ => codegen_error!(
+                "singlepass can't emit move_location_extend {:?} {:?} {:?} => {:?} {:?}",
+                size_val,
+                signed,
+                source,
+                size_op,
+                dest
+            ),
+        };
+        if src != dst {
+            self.move_location(size_op, src, dst)?;
+        }
+        if dst != dest {
+            self.move_location(size_op, dst, dest)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn load_address(
+        &mut self,
+        _size: Size,
+        _reg: Location,
+        _mem: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass load_address unimplemented");
+    }
+    // Init the stack loc counter
+    fn init_stack_loc(
+        &mut self,
+        init_stack_loc_cnt: u64,
+        last_stack_loc: Location,
+    ) -> Result<(), CompileError> {
+        let label = self.assembler.get_label();
+        let mut temps = vec![];
+        let dest = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        temps.push(dest);
+        let cnt = self.location_to_reg(
+            Size::S64,
+            Location::Imm64(init_stack_loc_cnt),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+        let dest = match last_stack_loc {
+            Location::GPR(_) => codegen_error!("singlepass init_stack_loc unreachable"),
+            Location::SIMD(_) => codegen_error!("singlepass init_stack_loc unreachable"),
+            Location::Memory(reg, offset) => {
+                if offset < 0 {
+                    let offset = (-offset) as u32;
+                    if self.compatible_imm(offset as i64, ImmType::Bits12) {
+                        self.assembler.emit_sub(
+                            Size::S64,
+                            Location::GPR(reg),
+                            Location::Imm32(offset),
+                            Location::GPR(dest),
+                        )?;
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        self.assembler
+                            .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                        self.assembler.emit_sub(
+                            Size::S64,
+                            Location::GPR(reg),
+                            Location::GPR(tmp),
+                            Location::GPR(dest),
+                        )?;
+                        temps.push(tmp);
+                    }
+                    dest
+                } else {
+                    let offset = offset as u32;
+                    if self.compatible_imm(offset as i64, ImmType::Bits12) {
+                        self.assembler.emit_add(
+                            Size::S64,
+                            Location::GPR(reg),
+                            Location::Imm32(offset),
+                            Location::GPR(dest),
+                        )?;
+                    } else {
+                        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        self.assembler
+                            .emit_mov_imm(Location::GPR(tmp), (offset as i64) as u64)?;
+                        self.assembler.emit_add(
+                            Size::S64,
+                            Location::GPR(reg),
+                            Location::GPR(tmp),
+                            Location::GPR(dest),
+                        )?;
+                        temps.push(tmp);
+                    }
+                    dest
+                }
+            }
+            _ => codegen_error!("singlepass can't emit init_stack_loc {:?}", last_stack_loc),
+        };
+        self.assembler.emit_label(label)?;
+        self.assembler
+            .emit_stria(Size::S64, Location::GPR(GPR::XzrSp), dest, 8)?;
+        self.assembler
+            .emit_sub(Size::S64, cnt, Location::Imm8(1), cnt)?;
+        self.assembler.emit_cbnz_label(Size::S64, cnt, label)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    // Restore save_area
+    fn restore_saved_area(&mut self, saved_area_offset: i32) -> Result<(), CompileError> {
+        let real_delta = if saved_area_offset & 15 != 0 {
+            self.pushed = true;
+            saved_area_offset + 8
+        } else {
+            self.pushed = false;
+            saved_area_offset
+        };
+        if self.compatible_imm(real_delta as _, ImmType::Bits12) {
+            self.assembler.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::X29),
+                Location::Imm32(real_delta as _),
+                Location::GPR(GPR::XzrSp),
+            )?;
+        } else {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.assembler
+                .emit_mov_imm(Location::GPR(tmp), real_delta as u64)?;
+            self.assembler.emit_sub(
+                Size::S64,
+                Location::GPR(GPR::X29),
+                Location::GPR(tmp),
+                Location::GPR(GPR::XzrSp),
+            )?;
+            self.release_gpr(tmp);
+        }
+        Ok(())
+    }
+    // Pop a location
+    fn pop_location(&mut self, location: Location) -> Result<(), CompileError> {
+        self.emit_pop(Size::S64, location)
+    }
+    // Create a new `MachineState` with default values.
+    fn new_machine_state(&self) -> MachineState {
+        new_machine_state()
+    }
+
+    // assembler finalize
+    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
+        self.assembler.finalize().map_err(|e| {
+            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+        })
+    }
+
+    fn get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        self.assembler.finalize_function();
+        Ok(())
+    }
+
+    fn emit_function_prolog(&mut self) -> Result<(), CompileError> {
+        self.emit_double_push(Size::S64, Location::GPR(GPR::X29), Location::GPR(GPR::X30))?; // save LR too
+        self.emit_unwind_op(UnwindOps::Push2Regs {
+            reg1: GPR::X29.to_dwarf(),
+            reg2: GPR::X30.to_dwarf(),
+            up_to_sp: 16,
+        });
+        self.emit_double_push(Size::S64, Location::GPR(GPR::X27), Location::GPR(GPR::X28))?;
+        self.emit_unwind_op(UnwindOps::Push2Regs {
+            reg1: GPR::X27.to_dwarf(),
+            reg2: GPR::X28.to_dwarf(),
+            up_to_sp: 32,
+        });
+        // cannot use mov, because XSP is XZR there. Need to use ADD with #0
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::XzrSp),
+            Location::Imm8(0),
+            Location::GPR(GPR::X29),
+        )?;
+        self.emit_unwind_op(UnwindOps::DefineNewFrame);
+        Ok(())
+    }
+
+    fn emit_function_epilog(&mut self) -> Result<(), CompileError> {
+        // cannot use mov, because XSP is XZR there. Need to use ADD with #0
+        self.assembler.emit_add(
+            Size::S64,
+            Location::GPR(GPR::X29),
+            Location::Imm8(0),
+            Location::GPR(GPR::XzrSp),
+        )?;
+        self.pushed = false; // SP is restored, consider it aligned
+        self.emit_double_pop(Size::S64, Location::GPR(GPR::X27), Location::GPR(GPR::X28))?;
+        self.emit_double_pop(Size::S64, Location::GPR(GPR::X29), Location::GPR(GPR::X30))?;
+        Ok(())
+    }
+
+    fn emit_function_return_value(
+        &mut self,
+        ty: WpType,
+        canonicalize: bool,
+        loc: Location,
+    ) -> Result<(), CompileError> {
+        if canonicalize {
+            self.canonicalize_nan(
+                match ty {
+                    WpType::F32 => Size::S32,
+                    WpType::F64 => Size::S64,
+                    _ => unreachable!(),
+                },
+                loc,
+                Location::GPR(GPR::X0),
+            )?;
+        } else {
+            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(GPR::X0))?;
+        }
+        Ok(())
+    }
+
+    fn emit_function_return_float(&mut self) -> Result<(), CompileError> {
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::X0), Location::SIMD(NEON::V0))
+    }
+
+    fn arch_supports_canonicalize_nan(&self) -> bool {
+        self.assembler.arch_supports_canonicalize_nan()
+    }
+    fn canonicalize_nan(
+        &mut self,
+        sz: Size,
+        input: Location,
+        output: Location,
+    ) -> Result<(), CompileError> {
+        let mut tempn = vec![];
+        let mut temps = vec![];
+        let old_fpcr = self.set_default_nan(&mut temps)?;
+        // use FMAX (input, intput) => output to automaticaly normalize the NaN
+        match (sz, input, output) {
+            (Size::S32, Location::SIMD(_), Location::SIMD(_)) => {
+                self.assembler.emit_fmax(sz, input, input, output)?;
+            }
+            (Size::S64, Location::SIMD(_), Location::SIMD(_)) => {
+                self.assembler.emit_fmax(sz, input, input, output)?;
+            }
+            (Size::S32, Location::SIMD(_), _) | (Size::S64, Location::SIMD(_), _) => {
+                let tmp = self.location_to_neon(sz, output, &mut tempn, ImmType::None, false)?;
+                self.assembler.emit_fmax(sz, input, input, tmp)?;
+                self.move_location(sz, tmp, output)?;
+            }
+            (Size::S32, Location::Memory(_, _), _) | (Size::S64, Location::Memory(_, _), _) => {
+                let src = self.location_to_neon(sz, input, &mut tempn, ImmType::None, true)?;
+                let tmp = self.location_to_neon(sz, output, &mut tempn, ImmType::None, false)?;
+                self.assembler.emit_fmax(sz, src, src, tmp)?;
+                if tmp != output {
+                    self.move_location(sz, tmp, output)?;
+                }
+            }
+            _ => codegen_error!(
+                "singlepass can't emit canonicalize_nan {:?} {:?} {:?}",
+                sz,
+                input,
+                output
+            ),
+        }
+
+        self.restore_fpcr(old_fpcr)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        for r in tempn {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+
+    fn emit_illegal_op(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        let offset = self.assembler.get_offset().0;
+        self.assembler.emit_udf(0xc0 | (trap as u8) as u16)?;
+        self.mark_instruction_address_end(offset);
+        Ok(())
+    }
+    fn get_label(&mut self) -> Label {
+        self.assembler.new_dynamic_label()
+    }
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_label(label)
+    }
+    fn get_grp_for_call(&self) -> GPR {
+        GPR::X27
+    }
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_call_register(reg)
+    }
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_call_label(label)
+    }
+    fn get_gpr_for_ret(&self) -> GPR {
+        GPR::X0
+    }
+    fn get_simd_for_ret(&self) -> NEON {
+        NEON::V0
+    }
+
+    fn arch_requires_indirect_call_trampoline(&self) -> bool {
+        self.assembler.arch_requires_indirect_call_trampoline()
+    }
+
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        location: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler
+            .arch_emit_indirect_call_with_trampoline(location)
+    }
+
+    fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_brk()
+    }
+
+    fn emit_call_location(&mut self, location: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let loc = self.location_to_reg(
+            Size::S64,
+            location,
+            &mut temps,
+            ImmType::None,
+            true,
+            Some(GPR::X27),
+        )?;
+        match loc {
+            Location::GPR(reg) => self.assembler.emit_call_register(reg),
+            _ => codegen_error!("singlepass can't emit CALL Location"),
+        }?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+
+    fn location_address(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_address not implemented")
+    }
+    // logic
+    fn location_and(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_and not implemented")
+    }
+    fn location_xor(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_xor not implemented")
+    }
+    fn location_or(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_or not implemented")
+    }
+    fn location_test(
+        &mut self,
+        _size: Size,
+        _source: Location,
+        _dest: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_test not implemented")
+    }
+    // math
+    fn location_add(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        flags: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(size, source, &mut temps, ImmType::Bits12, true, None)?;
+        let dst = self.location_to_reg(size, dest, &mut temps, ImmType::None, true, None)?;
+        if flags {
+            self.assembler.emit_adds(size, dst, src, dst)?;
+        } else {
+            self.assembler.emit_add(size, dst, src, dst)?;
+        }
+        if dst != dest {
+            self.move_location(size, dst, dest)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn location_sub(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        flags: bool,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(size, source, &mut temps, ImmType::Bits12, true, None)?;
+        let dst = self.location_to_reg(size, dest, &mut temps, ImmType::None, true, None)?;
+        if flags {
+            self.assembler.emit_subs(size, dst, src, dst)?;
+        } else {
+            self.assembler.emit_sub(size, dst, src, dst)?;
+        }
+        if dst != dest {
+            self.move_location(size, dst, dest)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn location_cmp(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_cmp, size, source, dest, false)
+    }
+    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_b_label(label)
+    }
+    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Eq, label)
+    }
+    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Ne, label)
+    }
+    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Hi, label)
+    }
+    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Cs, label)
+    }
+    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Ls, label)
+    }
+    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_bcond_label_far(Condition::Cs, label)
+    }
+
+    // jmp table
+    fn emit_jmp_to_jumptable(&mut self, label: Label, cond: Location) -> Result<(), CompileError> {
+        let tmp1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.assembler.emit_load_label(tmp1, label)?;
+        self.move_location(Size::S32, cond, Location::GPR(tmp2))?;
+
+        self.assembler.emit_add_lsl(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            2,
+            Location::GPR(tmp2),
+        )?;
+        self.assembler.emit_b_register(tmp2)?;
+        self.release_gpr(tmp2);
+        self.release_gpr(tmp1);
+        Ok(())
+    }
+
+    fn align_for_loop(&mut self) -> Result<(), CompileError> {
+        // noting to do on ARM64
+        Ok(())
+    }
+
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_ret()
+    }
+
+    fn emit_push(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.emit_push(size, loc)
+    }
+    fn emit_pop(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.emit_pop(size, loc)
+    }
+
+    fn emit_memory_fence(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_dmb()
+    }
+
+    fn location_neg(
+        &mut self,
+        _size_val: Size, // size of src
+        _signed: bool,
+        _source: Location,
+        _size_op: Size,
+        _dest: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass location_neg unimplemented");
+    }
+
+    fn emit_imul_imm32(&mut self, size: Size, imm32: u32, gpr: GPR) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_mov_imm(Location::GPR(tmp), imm32 as u64)?;
+        self.assembler.emit_mul(
+            size,
+            Location::GPR(gpr),
+            Location::GPR(tmp),
+            Location::GPR(gpr),
+        )?;
+        self.release_gpr(tmp);
+        Ok(())
+    }
+
+    // relaxed binop based...
+    fn emit_relaxed_mov(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_mov, sz, src, dst, true)
+    }
+    fn emit_relaxed_cmp(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_cmp, sz, src, dst, false)
+    }
+    fn emit_relaxed_zero_extension(
+        &mut self,
+        _sz_src: Size,
+        _src: Location,
+        _sz_dst: Size,
+        _dst: Location,
+    ) -> Result<(), CompileError> {
+        codegen_error!("singlepass emit_relaxed_zero_extension unimplemented");
+    }
+    fn emit_relaxed_sign_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match (src, dst) {
+            (Location::Memory(_, _), Location::GPR(_)) => match sz_src {
+                Size::S8 => self.emit_relaxed_ldr8s(sz_dst, dst, src),
+                Size::S16 => self.emit_relaxed_ldr16s(sz_dst, dst, src),
+                Size::S32 => self.emit_relaxed_ldr32s(sz_dst, dst, src),
+                _ => codegen_error!("singlepass emit_relaxed_sign_extension unreachable"),
+            },
+            _ => {
+                let mut temps = vec![];
+                let src =
+                    self.location_to_reg(sz_src, src, &mut temps, ImmType::None, true, None)?;
+                let dest =
+                    self.location_to_reg(sz_dst, dst, &mut temps, ImmType::None, false, None)?;
+                match sz_src {
+                    Size::S8 => self.assembler.emit_sxtb(sz_dst, src, dest),
+                    Size::S16 => self.assembler.emit_sxth(sz_dst, src, dest),
+                    Size::S32 => self.assembler.emit_sxtw(sz_dst, src, dest),
+                    _ => codegen_error!("singlepass emit_relaxed_sign_extension unreachable"),
+                }?;
+                if dst != dest {
+                    self.move_location(sz_dst, dest, dst)?;
+                }
+                for r in temps {
+                    self.release_gpr(r);
+                }
+                Ok(())
+            }
+        }
+    }
+
+    fn emit_binop_add32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_add,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_sub32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sub,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_mul32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_mul,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn emit_binop_udiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        self.assembler
+            .emit_cbz_label(Size::S32, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_sdiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+        self.assembler
+            .emit_cbz_label(Size::S32, src2, integer_division_by_zero)?;
+        let label_nooverflow = self.assembler.get_label();
+        let tmp = self.location_to_reg(
+            Size::S32,
+            Location::Imm32(0x80000000),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+        self.assembler.emit_cmp(Size::S32, tmp, src1)?;
+        self.assembler
+            .emit_bcond_label(Condition::Ne, label_nooverflow)?;
+        self.assembler.emit_movn(Size::S32, tmp, 0)?;
+        self.assembler.emit_cmp(Size::S32, tmp, src2)?;
+        self.assembler
+            .emit_bcond_label_far(Condition::Eq, integer_overflow)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_label(label_nooverflow)?;
+        self.assembler.emit_sdiv(Size::S32, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_urem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        let dest = if dest == src1 || dest == src2 {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            temps.push(tmp);
+            self.assembler
+                .emit_mov(Size::S32, dest, Location::GPR(tmp))?;
+            Location::GPR(tmp)
+        } else {
+            dest
+        };
+        self.assembler
+            .emit_cbz_label(Size::S32, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S32, src1, src2, dest)?;
+        // unsigned remainder : src1 - (src1/src2)*src2
+        self.assembler
+            .emit_msub(Size::S32, dest, src2, src1, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_srem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S32, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        let dest = if dest == src1 || dest == src2 {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            temps.push(tmp);
+            self.assembler
+                .emit_mov(Size::S32, dest, Location::GPR(tmp))?;
+            Location::GPR(tmp)
+        } else {
+            dest
+        };
+        self.assembler
+            .emit_cbz_label(Size::S32, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_sdiv(Size::S32, src1, src2, dest)?;
+        // unsigned remainder : src1 - (src1/src2)*src2
+        self.assembler
+            .emit_msub(Size::S32, dest, src2, src1, dest)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_and32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_and,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical32,
+        )
+    }
+    fn emit_binop_or32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_or,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical32,
+        )
+    }
+    fn emit_binop_xor32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_eor,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical32,
+        )
+    }
+    fn i32_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ge, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Gt, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Le, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Lt, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Cs, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Hi, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ls, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Cc, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Ne, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Eq, loc_a, loc_b, ret)
+    }
+    fn i32_clz(&mut self, src: Location, dst: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_clz, Size::S32, src, dst, true)
+    }
+    fn i32_ctz(&mut self, src: Location, dst: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(Size::S32, src, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S32, dst, &mut temps, ImmType::None, false, None)?;
+        self.assembler.emit_rbit(Size::S32, src, dest)?;
+        self.assembler.emit_clz(Size::S32, dest, dest)?;
+        if dst != dest {
+            self.move_location(Size::S32, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn i32_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.has_neon {
+            let mut temps = vec![];
+
+            let src_gpr =
+                self.location_to_reg(Size::S32, loc, &mut temps, ImmType::None, true, None)?;
+            let dst_gpr =
+                self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+
+            let mut neon_temps = vec![];
+            let neon_temp = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            neon_temps.push(neon_temp);
+
+            self.assembler
+                .emit_fmov(Size::S32, src_gpr, Size::S32, Location::SIMD(neon_temp))?;
+            self.assembler.emit_cnt(neon_temp, neon_temp)?;
+            self.assembler.emit_addv(neon_temp, neon_temp)?;
+            self.assembler
+                .emit_fmov(Size::S32, Location::SIMD(neon_temp), Size::S32, dst_gpr)?;
+
+            if ret != dst_gpr {
+                self.move_location(Size::S32, dst_gpr, ret)?;
+            }
+
+            for r in temps {
+                self.release_gpr(r);
+            }
+
+            for r in neon_temps {
+                self.release_simd(r);
+            }
+        } else {
+            let mut temps = vec![];
+            let src =
+                self.location_to_reg(Size::S32, loc, &mut temps, ImmType::None, true, None)?;
+            let dest =
+                self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+            let src = if src == loc {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(tmp);
+                self.assembler
+                    .emit_mov(Size::S32, src, Location::GPR(tmp))?;
+                Location::GPR(tmp)
+            } else {
+                src
+            };
+            let tmp = {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(tmp);
+                Location::GPR(tmp)
+            };
+            let label_loop = self.assembler.get_label();
+            let label_exit = self.assembler.get_label();
+            self.assembler
+                .emit_mov(Size::S32, Location::GPR(GPR::XzrSp), dest)?; // 0 => dest
+            self.assembler.emit_cbz_label(Size::S32, src, label_exit)?; // src==0, exit
+            self.assembler.emit_label(label_loop)?; // loop:
+            self.assembler
+                .emit_add(Size::S32, dest, Location::Imm8(1), dest)?; // dest += 1
+            self.assembler.emit_clz(Size::S32, src, tmp)?; // clz src => tmp
+            self.assembler.emit_lsl(Size::S32, src, tmp, src)?; // src << tmp => src
+            self.assembler
+                .emit_lsl(Size::S32, src, Location::Imm8(1), src)?; // src << 1 => src
+            self.assembler.emit_cbnz_label(Size::S32, src, label_loop)?; // if src!=0 goto loop
+            self.assembler.emit_label(label_exit)?;
+            if ret != dest {
+                self.move_location(Size::S32, dest, ret)?;
+            }
+            for r in temps {
+                self.release_gpr(r);
+            }
+        }
+        Ok(())
+    }
+    fn i32_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_lsl,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32No0,
+        )
+    }
+    fn i32_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_lsr,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32No0,
+        )
+    }
+    fn i32_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_asr,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32No0,
+        )
+    }
+    fn i32_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src2 = match loc_b {
+            Location::Imm8(imm) => Location::Imm8(32 - (imm & 31)),
+            Location::Imm32(imm) => Location::Imm8(32 - (imm & 31) as u8),
+            Location::Imm64(imm) => Location::Imm8(32 - (imm & 31) as u8),
+            _ => {
+                let tmp1 = self.location_to_reg(
+                    Size::S32,
+                    Location::Imm32(32),
+                    &mut temps,
+                    ImmType::None,
+                    true,
+                    None,
+                )?;
+                let tmp2 =
+                    self.location_to_reg(Size::S32, loc_b, &mut temps, ImmType::None, true, None)?;
+                self.assembler.emit_sub(Size::S32, tmp1, tmp2, tmp1)?;
+                tmp1
+            }
+        };
+        self.emit_relaxed_binop3(
+            Assembler::emit_ror,
+            Size::S32,
+            loc_a,
+            src2,
+            ret,
+            ImmType::Shift32No0,
+        )?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn i32_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_ror,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift32No0,
+        )
+    }
+    fn i32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8s(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16s(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str32(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str8(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str16(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i32_atomic_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str32(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    fn i32_atomic_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str8(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    fn i32_atomic_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str16(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    // i32 atomic Add with i32
+    fn i32_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_add32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Add with u8
+    fn i32_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_add32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Add with u16
+    fn i32_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_add32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Sub with i32
+    fn i32_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_sub32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Sub with u8
+    fn i32_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_sub32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Sub with u16
+    fn i32_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_sub32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic And with i32
+    fn i32_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_and32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic And with u8
+    fn i32_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_and32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic And with u16
+    fn i32_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_and32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Or with i32
+    fn i32_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_or32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Or with u8
+    fn i32_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_or32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Or with u16
+    fn i32_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_or32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Xor with i32
+    fn i32_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_xor32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Xor with u8
+    fn i32_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_xor32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Xor with u16
+    fn i32_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_xor32(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with i32
+    fn i32_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with u8
+    fn i32_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with u16
+    fn i32_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with i32
+    fn i32_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S32, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with u8
+    fn i32_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S32, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxrb(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i32 atomic Exchange with u16
+    fn i32_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S32, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S32, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxrh(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S32, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+
+    fn emit_call_with_reloc(
+        &mut self,
+        _calling_convention: CallingConvention,
+        reloc_target: RelocationTarget,
+    ) -> Result<Vec<Relocation>, CompileError> {
+        let mut relocations = vec![];
+        let next = self.get_label();
+        let reloc_at = self.assembler.get_offset().0;
+        self.emit_label(next)?; // this is to be sure the current imm26 value is 0
+        self.assembler.emit_call_label(next)?;
+        relocations.push(Relocation {
+            kind: RelocationKind::Arm64Call,
+            reloc_target,
+            offset: reloc_at as u32,
+            addend: 0,
+        });
+        Ok(relocations)
+    }
+
+    fn emit_binop_add64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_add,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_sub64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_sub,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Bits12,
+        )
+    }
+    fn emit_binop_mul64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_mul,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn emit_binop_udiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        self.assembler
+            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_sdiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+        self.assembler
+            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+        let label_nooverflow = self.assembler.get_label();
+        let tmp = self.location_to_reg(
+            Size::S64,
+            Location::Imm64(0x8000000000000000),
+            &mut temps,
+            ImmType::None,
+            true,
+            None,
+        )?;
+        self.assembler.emit_cmp(Size::S64, tmp, src1)?;
+        self.assembler
+            .emit_bcond_label(Condition::Ne, label_nooverflow)?;
+        self.assembler.emit_movn(Size::S64, tmp, 0)?;
+        self.assembler.emit_cmp(Size::S64, tmp, src2)?;
+        self.assembler
+            .emit_bcond_label_far(Condition::Eq, integer_overflow)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_label(label_nooverflow)?;
+        self.assembler.emit_sdiv(Size::S64, src1, src2, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_urem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        let dest = if dest == src1 || dest == src2 {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            temps.push(tmp);
+            self.assembler
+                .emit_mov(Size::S32, dest, Location::GPR(tmp))?;
+            Location::GPR(tmp)
+        } else {
+            dest
+        };
+        self.assembler
+            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_udiv(Size::S64, src1, src2, dest)?;
+        // unsigned remainder : src1 - (src1/src2)*src2
+        self.assembler
+            .emit_msub(Size::S64, dest, src2, src1, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_srem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        let mut temps = vec![];
+        let src1 = self.location_to_reg(Size::S64, loc_a, &mut temps, ImmType::None, true, None)?;
+        let src2 = self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        let dest = if dest == src1 || dest == src2 {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            temps.push(tmp);
+            self.assembler
+                .emit_mov(Size::S64, dest, Location::GPR(tmp))?;
+            Location::GPR(tmp)
+        } else {
+            dest
+        };
+        self.assembler
+            .emit_cbz_label(Size::S64, src2, integer_division_by_zero)?;
+        let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+        self.assembler.emit_sdiv(Size::S64, src1, src2, dest)?;
+        // unsigned remainder : src1 - (src1/src2)*src2
+        self.assembler
+            .emit_msub(Size::S64, dest, src2, src1, dest)?;
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(offset)
+    }
+    fn emit_binop_and64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_and,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical64,
+        )
+    }
+    fn emit_binop_or64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_or,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical64,
+        )
+    }
+    fn emit_binop_xor64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_eor,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Logical64,
+        )
+    }
+    fn i64_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ge, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Gt, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Le, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Lt, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Cs, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Hi, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ls, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Cc, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Ne, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Eq, loc_a, loc_b, ret)
+    }
+    fn i64_clz(&mut self, src: Location, dst: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(Assembler::emit_clz, Size::S64, src, dst, true)
+    }
+    fn i64_ctz(&mut self, src: Location, dst: Location) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let src = self.location_to_reg(Size::S64, src, &mut temps, ImmType::None, true, None)?;
+        let dest = self.location_to_reg(Size::S64, dst, &mut temps, ImmType::None, false, None)?;
+        self.assembler.emit_rbit(Size::S64, src, dest)?;
+        self.assembler.emit_clz(Size::S64, dest, dest)?;
+        if dst != dest {
+            self.move_location(Size::S64, dest, dst)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn i64_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.has_neon {
+            let mut temps = vec![];
+
+            let src_gpr =
+                self.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, true, None)?;
+            let dst_gpr =
+                self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+
+            let mut neon_temps = vec![];
+            let neon_temp = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            neon_temps.push(neon_temp);
+
+            self.assembler
+                .emit_fmov(Size::S64, src_gpr, Size::S64, Location::SIMD(neon_temp))?;
+            self.assembler.emit_cnt(neon_temp, neon_temp)?;
+            self.assembler.emit_addv(neon_temp, neon_temp)?;
+            self.assembler
+                .emit_fmov(Size::S64, Location::SIMD(neon_temp), Size::S64, dst_gpr)?;
+
+            if ret != dst_gpr {
+                self.move_location(Size::S64, dst_gpr, ret)?;
+            }
+
+            for r in temps {
+                self.release_gpr(r);
+            }
+
+            for r in neon_temps {
+                self.release_simd(r);
+            }
+        } else {
+            let mut temps = vec![];
+            let src =
+                self.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, true, None)?;
+            let dest =
+                self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+            let src = if src == loc {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(tmp);
+                self.assembler
+                    .emit_mov(Size::S64, src, Location::GPR(tmp))?;
+                Location::GPR(tmp)
+            } else {
+                src
+            };
+            let tmp = {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                temps.push(tmp);
+                Location::GPR(tmp)
+            };
+            let label_loop = self.assembler.get_label();
+            let label_exit = self.assembler.get_label();
+            self.assembler
+                .emit_mov(Size::S32, Location::GPR(GPR::XzrSp), dest)?; // dest <= 0
+            self.assembler.emit_cbz_label(Size::S64, src, label_exit)?; // src == 0, then goto label_exit
+            self.assembler.emit_label(label_loop)?;
+            self.assembler
+                .emit_add(Size::S32, dest, Location::Imm8(1), dest)?; // dest += 1
+            self.assembler.emit_clz(Size::S64, src, tmp)?; // clz src => tmp
+            self.assembler.emit_lsl(Size::S64, src, tmp, src)?; // src << tmp => src
+            self.assembler
+                .emit_lsl(Size::S64, src, Location::Imm8(1), src)?; // src << 1 => src
+            self.assembler.emit_cbnz_label(Size::S64, src, label_loop)?; // src != 0, then goto label_loop
+            self.assembler.emit_label(label_exit)?;
+            if ret != dest {
+                self.move_location(Size::S64, dest, ret)?;
+            }
+            for r in temps {
+                self.release_gpr(r);
+            }
+        }
+
+        Ok(())
+    }
+    fn i64_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_lsl,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64No0,
+        )
+    }
+    fn i64_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_lsr,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64No0,
+        )
+    }
+    fn i64_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_asr,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64No0,
+        )
+    }
+    fn i64_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        // there is no ROL on ARM64. We use ROR with 64-value instead
+        let mut temps = vec![];
+        let src2 = match loc_b {
+            Location::Imm8(imm) => Location::Imm8(64 - (imm & 63)),
+            Location::Imm32(imm) => Location::Imm8(64 - (imm & 63) as u8),
+            Location::Imm64(imm) => Location::Imm8(64 - (imm & 63) as u8),
+            _ => {
+                let tmp1 = self.location_to_reg(
+                    Size::S64,
+                    Location::Imm32(64),
+                    &mut temps,
+                    ImmType::None,
+                    true,
+                    None,
+                )?;
+                let tmp2 =
+                    self.location_to_reg(Size::S64, loc_b, &mut temps, ImmType::None, true, None)?;
+                self.assembler.emit_sub(Size::S64, tmp1, tmp2, tmp1)?;
+                tmp1
+            }
+        };
+        self.emit_relaxed_binop3(
+            Assembler::emit_ror,
+            Size::S64,
+            loc_a,
+            src2,
+            ret,
+            ImmType::Shift64No0,
+        )?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn i64_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3(
+            Assembler::emit_ror,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::Shift64No0,
+        )
+    }
+    fn i64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr64(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8s(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16s(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_load_32s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32s(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr64(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr8(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr16(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str64(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str8(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str16(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_save_32(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str32(target_value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str64(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    fn i64_atomic_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str8(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    fn i64_atomic_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str16(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    fn i64_atomic_save_32(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_str32(target_value, Location::Memory(addr, 0)),
+        )?;
+        self.assembler.emit_dmb()
+    }
+    // i64 atomic Add with i64
+    fn i64_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_add64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Add with u8
+    fn i64_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_add64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Add with u16
+    fn i64_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_add64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Add with u32
+    fn i64_atomic_add_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_add64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Sub with i64
+    fn i64_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_sub64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Sub with u8
+    fn i64_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_sub64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Sub with u16
+    fn i64_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_sub64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Sub with u32
+    fn i64_atomic_sub_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_sub64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic And with i64
+    fn i64_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_and64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic And with u8
+    fn i64_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_and64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic And with u16
+    fn i64_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_and64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic And with u32
+    fn i64_atomic_and_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_and64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Or with i64
+    fn i64_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_or64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Or with u8
+    fn i64_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_or64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Or with u16
+    fn i64_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_or64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Or with u32
+    fn i64_atomic_or_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_or64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Xor with i64
+    fn i64_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_xor64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Xor with u8
+    fn i64_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_xor64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Xor with u16
+    fn i64_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_binop_xor64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Xor with u32
+    fn i64_atomic_xor_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp1 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let tmp2 = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_binop_xor64(dst, loc, Location::GPR(tmp1))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp2),
+                    Location::GPR(tmp1),
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp2), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp1);
+                this.release_gpr(tmp2);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with i64
+    fn i64_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u8
+    fn i64_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u16
+    fn i64_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u32
+    fn i64_atomic_xchg_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, loc, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with i64
+    fn i64_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S64, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxr(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u8
+    fn i64_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrb(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S64, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxrb(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u16
+    fn i64_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxrh(Size::S64, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S64, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxrh(
+                    Size::S64,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+    // i64 atomic Exchange with u32
+    fn i64_atomic_cmpxchg_32u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                let mut temps = vec![];
+                let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let dst =
+                    this.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+                let org =
+                    this.location_to_reg(Size::S64, new, &mut temps, ImmType::None, false, None)?;
+                let reread = this.get_label();
+                let nosame = this.get_label();
+
+                this.emit_label(reread)?;
+                this.assembler
+                    .emit_ldaxr(Size::S32, dst, Location::GPR(addr))?;
+                this.emit_relaxed_cmp(Size::S64, dst, cmp)?;
+                this.assembler.emit_bcond_label(Condition::Ne, nosame)?;
+                this.assembler.emit_stlxr(
+                    Size::S32,
+                    Location::GPR(tmp),
+                    org,
+                    Location::GPR(addr),
+                )?;
+                this.assembler
+                    .emit_cbnz_label(Size::S32, Location::GPR(tmp), reread)?;
+                this.assembler.emit_dmb()?;
+
+                this.emit_label(nosame)?;
+                if dst != ret {
+                    this.move_location(Size::S64, ret, dst)?;
+                }
+                for r in temps {
+                    this.release_gpr(r);
+                }
+                this.release_gpr(tmp);
+                Ok(())
+            },
+        )
+    }
+
+    fn f32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr32(Size::S32, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn f32_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_str32(target_value, Location::Memory(addr, 0))
+                } else {
+                    this.canonicalize_nan(Size::S32, target_value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+    fn f64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_ldr64(Size::S64, ret, Location::Memory(addr, 0)),
+        )
+    }
+    fn f64_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_str64(target_value, Location::Memory(addr, 0))
+                } else {
+                    this.canonicalize_nan(Size::S64, target_value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+
+    fn convert_f64_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_reg(Size::S64, loc, &mut gprs, ImmType::NoneXzr, true, None)?;
+        let dest = self.location_to_neon(Size::S64, ret, &mut neons, ImmType::None, false)?;
+        if signed {
+            self.assembler.emit_scvtf(Size::S64, src, Size::S64, dest)?;
+        } else {
+            self.assembler.emit_ucvtf(Size::S64, src, Size::S64, dest)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_f64_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_reg(Size::S32, loc, &mut gprs, ImmType::NoneXzr, true, None)?;
+        let dest = self.location_to_neon(Size::S64, ret, &mut neons, ImmType::None, false)?;
+        if signed {
+            self.assembler.emit_scvtf(Size::S32, src, Size::S64, dest)?;
+        } else {
+            self.assembler.emit_ucvtf(Size::S32, src, Size::S64, dest)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_f32_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_reg(Size::S64, loc, &mut gprs, ImmType::NoneXzr, true, None)?;
+        let dest = self.location_to_neon(Size::S32, ret, &mut neons, ImmType::None, false)?;
+        if signed {
+            self.assembler.emit_scvtf(Size::S64, src, Size::S32, dest)?;
+        } else {
+            self.assembler.emit_ucvtf(Size::S64, src, Size::S32, dest)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_f32_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_reg(Size::S32, loc, &mut gprs, ImmType::NoneXzr, true, None)?;
+        let dest = self.location_to_neon(Size::S32, ret, &mut neons, ImmType::None, false)?;
+        if signed {
+            self.assembler.emit_scvtf(Size::S32, src, Size::S32, dest)?;
+        } else {
+            self.assembler.emit_ucvtf(Size::S32, src, Size::S32, dest)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_i64_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_neon(Size::S64, loc, &mut neons, ImmType::None, true)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut gprs, ImmType::None, false, None)?;
+        let old_fpcr = if !sat {
+            self.reset_exception_fpsr()?;
+            self.set_trap_enabled(&mut gprs)?
+        } else {
+            GPR::XzrSp
+        };
+        if signed {
+            self.assembler
+                .emit_fcvtzs(Size::S64, src, Size::S64, dest)?;
+        } else {
+            self.assembler
+                .emit_fcvtzu(Size::S64, src, Size::S64, dest)?;
+        }
+        if !sat {
+            self.trap_float_convertion_errors(old_fpcr, Size::S64, src, &mut gprs)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_i32_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_neon(Size::S64, loc, &mut neons, ImmType::None, true)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut gprs, ImmType::None, false, None)?;
+        let old_fpcr = if !sat {
+            self.reset_exception_fpsr()?;
+            self.set_trap_enabled(&mut gprs)?
+        } else {
+            GPR::XzrSp
+        };
+        if signed {
+            self.assembler
+                .emit_fcvtzs(Size::S64, src, Size::S32, dest)?;
+        } else {
+            self.assembler
+                .emit_fcvtzu(Size::S64, src, Size::S32, dest)?;
+        }
+        if !sat {
+            self.trap_float_convertion_errors(old_fpcr, Size::S64, src, &mut gprs)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_i64_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_neon(Size::S32, loc, &mut neons, ImmType::None, true)?;
+        let dest = self.location_to_reg(Size::S64, ret, &mut gprs, ImmType::None, false, None)?;
+        let old_fpcr = if !sat {
+            self.reset_exception_fpsr()?;
+            self.set_trap_enabled(&mut gprs)?
+        } else {
+            GPR::XzrSp
+        };
+        if signed {
+            self.assembler
+                .emit_fcvtzs(Size::S32, src, Size::S64, dest)?;
+        } else {
+            self.assembler
+                .emit_fcvtzu(Size::S32, src, Size::S64, dest)?;
+        }
+        if !sat {
+            self.trap_float_convertion_errors(old_fpcr, Size::S32, src, &mut gprs)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S64, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_i32_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        let mut gprs = vec![];
+        let mut neons = vec![];
+        let src = self.location_to_neon(Size::S32, loc, &mut neons, ImmType::None, true)?;
+        let dest = self.location_to_reg(Size::S32, ret, &mut gprs, ImmType::None, false, None)?;
+        let old_fpcr = if !sat {
+            self.reset_exception_fpsr()?;
+            self.set_trap_enabled(&mut gprs)?
+        } else {
+            GPR::XzrSp
+        };
+        if signed {
+            self.assembler
+                .emit_fcvtzs(Size::S32, src, Size::S32, dest)?;
+        } else {
+            self.assembler
+                .emit_fcvtzu(Size::S32, src, Size::S32, dest)?;
+        }
+        if !sat {
+            self.trap_float_convertion_errors(old_fpcr, Size::S32, src, &mut gprs)?;
+        }
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in gprs {
+            self.release_gpr(r);
+        }
+        for r in neons {
+            self.release_simd(r);
+        }
+        Ok(())
+    }
+    fn convert_f64_f32(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fcvt, Size::S32, loc, ret, true)
+    }
+    fn convert_f32_f64(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fcvt, Size::S64, loc, ret, true)
+    }
+    fn f64_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fneg, Size::S64, loc, ret, true)
+    }
+    fn f64_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp),
+            Location::Imm64(0x7fffffffffffffffu64),
+            Location::GPR(tmp),
+        )?;
+        self.move_location(Size::S64, Location::GPR(tmp), ret)?;
+
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn emit_i64_copysign(&mut self, tmp1: GPR, tmp2: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::Imm64(0x7fffffffffffffffu64),
+            Location::GPR(tmp1),
+        )?;
+
+        self.assembler.emit_and(
+            Size::S64,
+            Location::GPR(tmp2),
+            Location::Imm64(0x8000000000000000u64),
+            Location::GPR(tmp2),
+        )?;
+
+        self.assembler.emit_or(
+            Size::S64,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp1),
+        )
+    }
+    fn f64_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fsqrt, Size::S64, loc, ret, true)
+    }
+    fn f64_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintz, Size::S64, loc, ret, true)
+    }
+    fn f64_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintp, Size::S64, loc, ret, true)
+    }
+    fn f64_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintm, Size::S64, loc, ret, true)
+    }
+    fn f64_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintn, Size::S64, loc, ret, true)
+    }
+    fn f64_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_b, loc_a, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ls)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_b, loc_a, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Cc)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ls)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Cc)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ne)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S64, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S64, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Eq)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let old_fpcr = self.set_default_nan(&mut temps)?;
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmin,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )?;
+        self.restore_fpcr(old_fpcr)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let old_fpcr = self.set_default_nan(&mut temps)?;
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmax,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )?;
+        self.restore_fpcr(old_fpcr)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f64_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fadd,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f64_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fsub,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f64_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmul,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f64_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fdiv,
+            Size::S64,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f32_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fneg, Size::S32, loc, ret, true)
+    }
+    fn f32_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp),
+            Location::Imm32(0x7fffffffu32),
+            Location::GPR(tmp),
+        )?;
+        self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn emit_i32_copysign(&mut self, tmp1: GPR, tmp2: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp1),
+            Location::Imm32(0x7fffffffu32),
+            Location::GPR(tmp1),
+        )?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::GPR(tmp2),
+            Location::Imm32(0x80000000u32),
+            Location::GPR(tmp2),
+        )?;
+        self.assembler.emit_or(
+            Size::S32,
+            Location::GPR(tmp1),
+            Location::GPR(tmp2),
+            Location::GPR(tmp1),
+        )
+    }
+    fn f32_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_fsqrt, Size::S32, loc, ret, true)
+    }
+    fn f32_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintz, Size::S32, loc, ret, true)
+    }
+    fn f32_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintp, Size::S32, loc, ret, true)
+    }
+    fn f32_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintm, Size::S32, loc, ret, true)
+    }
+    fn f32_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_binop_neon(Assembler::emit_frintn, Size::S32, loc, ret, true)
+    }
+    fn f32_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_b, loc_a, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ls)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_b, loc_a, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Cc)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ls)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Cc)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Ne)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let dest = self.location_to_reg(Size::S32, ret, &mut temps, ImmType::None, false, None)?;
+        self.emit_relaxed_binop_neon(Assembler::emit_fcmp, Size::S32, loc_a, loc_b, false)?;
+        self.assembler.emit_cset(Size::S32, dest, Condition::Eq)?;
+        if ret != dest {
+            self.move_location(Size::S32, dest, ret)?;
+        }
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let old_fpcr = self.set_default_nan(&mut temps)?;
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmin,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )?;
+        self.restore_fpcr(old_fpcr)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let mut temps = vec![];
+        let old_fpcr = self.set_default_nan(&mut temps)?;
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmax,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )?;
+        self.restore_fpcr(old_fpcr)?;
+        for r in temps {
+            self.release_gpr(r);
+        }
+        Ok(())
+    }
+    fn f32_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fadd,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f32_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fsub,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f32_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fmul,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+    fn f32_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop3_neon(
+            Assembler::emit_fdiv,
+            Size::S32,
+            loc_a,
+            loc_b,
+            ret,
+            ImmType::None,
+        )
+    }
+
+    fn gen_std_trampoline(
+        &self,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        gen_std_trampoline_arm64(sig, calling_convention)
+    }
+    // Generates dynamic import function call trampoline for a function type.
+    fn gen_std_dynamic_import_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        gen_std_dynamic_import_trampoline_arm64(vmoffsets, sig, calling_convention)
+    }
+    // Singlepass calls import functions through a trampoline.
+    fn gen_import_call_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        index: FunctionIndex,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<CustomSection, CompileError> {
+        gen_import_call_trampoline_arm64(vmoffsets, index, sig, calling_convention)
+    }
+    #[cfg(feature = "unwind")]
+    fn gen_dwarf_unwind_info(&mut self, code_len: usize) -> Option<UnwindInstructions> {
+        let mut instructions = vec![];
+        for &(instruction_offset, ref inst) in &self.unwind_ops {
+            let instruction_offset = instruction_offset as u32;
+            match *inst {
+                UnwindOps::PushFP { up_to_sp } => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaOffset(up_to_sp as i32),
+                    ));
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::Offset(AArch64::X29, -(up_to_sp as i32)),
+                    ));
+                }
+                UnwindOps::Push2Regs {
+                    reg1,
+                    reg2,
+                    up_to_sp,
+                } => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaOffset(up_to_sp as i32),
+                    ));
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::Offset(dwarf_index(reg2), -(up_to_sp as i32) + 8),
+                    ));
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::Offset(dwarf_index(reg1), -(up_to_sp as i32)),
+                    ));
+                }
+                UnwindOps::DefineNewFrame => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaRegister(AArch64::X29),
+                    ));
+                }
+                UnwindOps::SaveRegister { reg, bp_neg_offset } => instructions.push((
+                    instruction_offset,
+                    CallFrameInstruction::Offset(dwarf_index(reg), -bp_neg_offset),
+                )),
+            }
+        }
+        Some(UnwindInstructions {
+            instructions,
+            len: code_len as u32,
+        })
+    }
+    #[cfg(not(feature = "unwind"))]
+    fn gen_dwarf_unwind_info(&mut self, _code_len: usize) -> Option<UnwindInstructions> {
+        None
+    }
+
+    fn gen_windows_unwind_info(&mut self, _code_len: usize) -> Option<Vec<u8>> {
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    fn test_move_location(machine: &mut MachineARM64, size: Size) -> Result<(), CompileError> {
+        machine.move_location(size, Location::GPR(GPR::X1), Location::GPR(GPR::X2))?;
+        machine.move_location(size, Location::GPR(GPR::X1), Location::Memory(GPR::X2, 10))?;
+        machine.move_location(size, Location::GPR(GPR::X1), Location::Memory(GPR::X2, -10))?;
+        machine.move_location(
+            size,
+            Location::GPR(GPR::X1),
+            Location::Memory(GPR::X2, 1024),
+        )?;
+        machine.move_location(
+            size,
+            Location::GPR(GPR::X1),
+            Location::Memory(GPR::X2, -1024),
+        )?;
+        machine.move_location(size, Location::Memory(GPR::X2, 10), Location::GPR(GPR::X1))?;
+        machine.move_location(size, Location::Memory(GPR::X2, -10), Location::GPR(GPR::X1))?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, 1024),
+            Location::GPR(GPR::X1),
+        )?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, -1024),
+            Location::GPR(GPR::X1),
+        )?;
+        machine.move_location(size, Location::GPR(GPR::X1), Location::SIMD(NEON::V0))?;
+        machine.move_location(size, Location::SIMD(NEON::V0), Location::GPR(GPR::X1))?;
+        machine.move_location(
+            size,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X2, 10),
+        )?;
+        machine.move_location(
+            size,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X2, -10),
+        )?;
+        machine.move_location(
+            size,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X2, 1024),
+        )?;
+        machine.move_location(
+            size,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X2, -1024),
+        )?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, 10),
+            Location::SIMD(NEON::V0),
+        )?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, -10),
+            Location::SIMD(NEON::V0),
+        )?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, 1024),
+            Location::SIMD(NEON::V0),
+        )?;
+        machine.move_location(
+            size,
+            Location::Memory(GPR::X2, -1024),
+            Location::SIMD(NEON::V0),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_move_location_extended(
+        machine: &mut MachineARM64,
+        signed: bool,
+        sized: Size,
+    ) -> Result<(), CompileError> {
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::GPR(GPR::X1),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::Memory(GPR::X1, 10),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::Memory(GPR::X1, 16),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::Memory(GPR::X1, -16),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::Memory(GPR::X1, 1024),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::X0),
+            Size::S64,
+            Location::Memory(GPR::X1, -1024),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::Memory(GPR::X0, 10),
+            Size::S64,
+            Location::GPR(GPR::X1),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_binop_op(
+        machine: &mut MachineARM64,
+        op: fn(&mut MachineARM64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::GPR(GPR::X2),
+            Location::GPR(GPR::X2),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::X2),
+            Location::Imm32(10),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::X0),
+            Location::GPR(GPR::X0),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::Imm32(10),
+            Location::GPR(GPR::X2),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::X0),
+            Location::GPR(GPR::X2),
+            Location::Memory(GPR::X0, 10),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::X0),
+            Location::Memory(GPR::X2, 16),
+            Location::Memory(GPR::X0, 10),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X0, 0),
+            Location::Memory(GPR::X2, 16),
+            Location::Memory(GPR::X0, 10),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_float_binop_op(
+        machine: &mut MachineARM64,
+        op: fn(&mut MachineARM64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::SIMD(NEON::V3),
+            Location::SIMD(NEON::V2),
+            Location::SIMD(NEON::V0),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V2),
+            Location::SIMD(NEON::V0),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X0, 0),
+            Location::SIMD(NEON::V2),
+            Location::SIMD(NEON::V0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X0, 0),
+            Location::Memory(GPR::X1, 10),
+            Location::SIMD(NEON::V0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X0, 0),
+            Location::Memory(GPR::X1, 16),
+            Location::Memory(GPR::X2, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X1, 16),
+            Location::Memory(GPR::X2, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V1),
+            Location::Memory(GPR::X2, 32),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_float_cmp_op(
+        machine: &mut MachineARM64,
+        op: fn(&mut MachineARM64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::SIMD(NEON::V3),
+            Location::SIMD(NEON::V2),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V0),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X1, 0),
+            Location::SIMD(NEON::V2),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X1, 0),
+            Location::Memory(GPR::X2, 10),
+            Location::GPR(GPR::X0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::X1, 0),
+            Location::Memory(GPR::X2, 16),
+            Location::Memory(GPR::X0, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::Memory(GPR::X2, 16),
+            Location::Memory(GPR::X0, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(NEON::V0),
+            Location::SIMD(NEON::V1),
+            Location::Memory(GPR::X0, 32),
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn tests_arm64() -> Result<(), CompileError> {
+        let mut machine = MachineARM64::new(None);
+
+        test_move_location(&mut machine, Size::S32)?;
+        test_move_location(&mut machine, Size::S64)?;
+        test_move_location_extended(&mut machine, false, Size::S8)?;
+        test_move_location_extended(&mut machine, false, Size::S16)?;
+        test_move_location_extended(&mut machine, false, Size::S32)?;
+        test_move_location_extended(&mut machine, true, Size::S8)?;
+        test_move_location_extended(&mut machine, true, Size::S16)?;
+        test_move_location_extended(&mut machine, true, Size::S32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_add32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_add64)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_sub32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_sub64)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_and32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_and64)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_xor32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_xor64)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_or32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_or64)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_mul32)?;
+        test_binop_op(&mut machine, MachineARM64::emit_binop_mul64)?;
+        test_float_binop_op(&mut machine, MachineARM64::f32_add)?;
+        test_float_binop_op(&mut machine, MachineARM64::f32_sub)?;
+        test_float_binop_op(&mut machine, MachineARM64::f32_mul)?;
+        test_float_binop_op(&mut machine, MachineARM64::f32_div)?;
+        test_float_cmp_op(&mut machine, MachineARM64::f32_cmp_eq)?;
+        test_float_cmp_op(&mut machine, MachineARM64::f32_cmp_lt)?;
+        test_float_cmp_op(&mut machine, MachineARM64::f32_cmp_le)?;
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_x64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_x64.rs
new file mode 100644
index 0000000..5bb3655
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/machine_x64.rs
@@ -0,0 +1,8711 @@
+use crate::codegen_error;
+use crate::common_decl::*;
+use crate::emitter_x64::*;
+use crate::location::Location as AbstractLocation;
+use crate::location::Reg;
+use crate::machine::*;
+use crate::unwind::{UnwindInstructions, UnwindOps};
+#[cfg(feature = "unwind")]
+use crate::unwind_winx64::create_unwind_info_from_insts;
+use crate::x64_decl::new_machine_state;
+use crate::x64_decl::{ArgumentRegisterAllocator, X64Register, GPR, XMM};
+use dynasmrt::{x64::X64Relocation, DynasmError, VecAssembler};
+#[cfg(feature = "unwind")]
+use gimli::{write::CallFrameInstruction, X86_64};
+use std::ops::{Deref, DerefMut};
+use wasmer_compiler::wasmparser::ValType as WpType;
+use wasmer_types::{
+    CallingConvention, CompileError, CpuFeature, CustomSection, CustomSectionProtection,
+    Relocation, RelocationKind, RelocationTarget, SectionBody, Target,
+};
+use wasmer_types::{FunctionBody, InstructionAddressMap, SourceLoc, TrapInformation};
+use wasmer_types::{FunctionIndex, FunctionType, TrapCode, Type, VMOffsets};
+
+type Assembler = VecAssembler<X64Relocation>;
+
+pub struct AssemblerX64 {
+    /// the actual inner
+    pub inner: Assembler,
+    /// the simd instructions set on the target.
+    /// Currently only supports SSE 4.2 and AVX
+    pub simd_arch: Option<CpuFeature>,
+    /// Full Target cpu
+    pub target: Option<Target>,
+}
+
+impl AssemblerX64 {
+    fn new(baseaddr: usize, target: Option<Target>) -> Result<Self, CompileError> {
+        let simd_arch = if target.is_none() {
+            Some(CpuFeature::SSE42)
+        } else {
+            let target = target.as_ref().unwrap();
+            if target.cpu_features().contains(CpuFeature::AVX) {
+                Some(CpuFeature::AVX)
+            } else if target.cpu_features().contains(CpuFeature::SSE42) {
+                Some(CpuFeature::SSE42)
+            } else {
+                return Err(CompileError::UnsupportedTarget(
+                    "x86_64 without AVX or SSE 4.2, use -m avx to enable".to_string(),
+                ));
+            }
+        };
+
+        Ok(Self {
+            inner: Assembler::new(baseaddr),
+            simd_arch,
+            target,
+        })
+    }
+
+    fn finalize(self) -> Result<Vec<u8>, DynasmError> {
+        self.inner.finalize()
+    }
+}
+
+impl Deref for AssemblerX64 {
+    type Target = Assembler;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl DerefMut for AssemblerX64 {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+type Location = AbstractLocation<GPR, XMM>;
+
+#[cfg(feature = "unwind")]
+fn dwarf_index(reg: u16) -> gimli::Register {
+    static DWARF_GPR: [gimli::Register; 16] = [
+        X86_64::RAX,
+        X86_64::RDX,
+        X86_64::RCX,
+        X86_64::RBX,
+        X86_64::RSI,
+        X86_64::RDI,
+        X86_64::RBP,
+        X86_64::RSP,
+        X86_64::R8,
+        X86_64::R9,
+        X86_64::R10,
+        X86_64::R11,
+        X86_64::R12,
+        X86_64::R13,
+        X86_64::R14,
+        X86_64::R15,
+    ];
+    static DWARF_XMM: [gimli::Register; 16] = [
+        X86_64::XMM0,
+        X86_64::XMM1,
+        X86_64::XMM2,
+        X86_64::XMM3,
+        X86_64::XMM4,
+        X86_64::XMM5,
+        X86_64::XMM6,
+        X86_64::XMM7,
+        X86_64::XMM8,
+        X86_64::XMM9,
+        X86_64::XMM10,
+        X86_64::XMM11,
+        X86_64::XMM12,
+        X86_64::XMM13,
+        X86_64::XMM14,
+        X86_64::XMM15,
+    ];
+    match reg {
+        0..=15 => DWARF_GPR[reg as usize],
+        17..=24 => DWARF_XMM[reg as usize - 17],
+        _ => panic!("Unknown register index {}", reg),
+    }
+}
+
+pub struct MachineX86_64 {
+    assembler: AssemblerX64,
+    used_gprs: u32,
+    used_simd: u32,
+    trap_table: TrapTable,
+    /// Map from byte offset into wasm function to range of native instructions.
+    ///
+    // Ordered by increasing InstructionAddressMap::srcloc.
+    instructions_address_map: Vec<InstructionAddressMap>,
+    /// The source location for the current operator.
+    src_loc: u32,
+    /// Vector of unwind operations with offset
+    unwind_ops: Vec<(usize, UnwindOps)>,
+}
+
+impl MachineX86_64 {
+    pub fn new(target: Option<Target>) -> Result<Self, CompileError> {
+        let assembler = AssemblerX64::new(0, target)?;
+        Ok(MachineX86_64 {
+            assembler,
+            used_gprs: 0,
+            used_simd: 0,
+            trap_table: TrapTable::default(),
+            instructions_address_map: vec![],
+            src_loc: 0,
+            unwind_ops: vec![],
+        })
+    }
+    pub fn emit_relaxed_binop(
+        &mut self,
+        op: fn(&mut AssemblerX64, Size, Location, Location) -> Result<(), CompileError>,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        enum RelaxMode {
+            Direct,
+            SrcToGPR,
+            DstToGPR,
+            BothToGPR,
+        }
+        let mode = match (src, dst) {
+            (Location::GPR(_), Location::GPR(_))
+                if std::ptr::eq(op as *const u8, AssemblerX64::emit_imul as *const u8) =>
+            {
+                RelaxMode::Direct
+            }
+            _ if std::ptr::eq(op as *const u8, AssemblerX64::emit_imul as *const u8) => {
+                RelaxMode::BothToGPR
+            }
+
+            (Location::Memory(_, _), Location::Memory(_, _)) => RelaxMode::SrcToGPR,
+            (Location::Imm64(_), Location::Imm64(_)) | (Location::Imm64(_), Location::Imm32(_)) => {
+                RelaxMode::BothToGPR
+            }
+            (_, Location::Imm32(_)) | (_, Location::Imm64(_)) => RelaxMode::DstToGPR,
+            (Location::Imm64(_), Location::Memory(_, _)) => RelaxMode::SrcToGPR,
+            (Location::Imm64(_), Location::GPR(_))
+                if (op as *const u8 != AssemblerX64::emit_mov as *const u8) =>
+            {
+                RelaxMode::SrcToGPR
+            }
+            (_, Location::SIMD(_)) => RelaxMode::SrcToGPR,
+            _ => RelaxMode::Direct,
+        };
+
+        match mode {
+            RelaxMode::SrcToGPR => {
+                let temp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(sz, src, Location::GPR(temp))?;
+                op(&mut self.assembler, sz, Location::GPR(temp), dst)?;
+                self.release_gpr(temp);
+            }
+            RelaxMode::DstToGPR => {
+                let temp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(sz, dst, Location::GPR(temp))?;
+                op(&mut self.assembler, sz, src, Location::GPR(temp))?;
+                self.release_gpr(temp);
+            }
+            RelaxMode::BothToGPR => {
+                let temp_src = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                let temp_dst = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(sz, src, Location::GPR(temp_src))?;
+                self.move_location(sz, dst, Location::GPR(temp_dst))?;
+                op(
+                    &mut self.assembler,
+                    sz,
+                    Location::GPR(temp_src),
+                    Location::GPR(temp_dst),
+                )?;
+                match dst {
+                    Location::Memory(_, _) | Location::GPR(_) => {
+                        self.move_location(sz, Location::GPR(temp_dst), dst)?;
+                    }
+                    _ => {}
+                }
+                self.release_gpr(temp_dst);
+                self.release_gpr(temp_src);
+            }
+            RelaxMode::Direct => {
+                op(&mut self.assembler, sz, src, dst)?;
+            }
+        }
+        Ok(())
+    }
+    pub fn emit_relaxed_zx_sx(
+        &mut self,
+        op: fn(&mut AssemblerX64, Size, Location, Size, Location) -> Result<(), CompileError>,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        match src {
+            Location::Imm32(_) | Location::Imm64(_) => {
+                let tmp_src = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.assembler
+                    .emit_mov(Size::S64, src, Location::GPR(tmp_src))?;
+                let src = Location::GPR(tmp_src);
+
+                match dst {
+                    Location::Imm32(_) | Location::Imm64(_) => unreachable!(),
+                    Location::Memory(_, _) => {
+                        let tmp_dst = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        op(
+                            &mut self.assembler,
+                            sz_src,
+                            src,
+                            sz_dst,
+                            Location::GPR(tmp_dst),
+                        )?;
+                        self.move_location(Size::S64, Location::GPR(tmp_dst), dst)?;
+
+                        self.release_gpr(tmp_dst);
+                    }
+                    Location::GPR(_) => {
+                        op(&mut self.assembler, sz_src, src, sz_dst, dst)?;
+                    }
+                    _ => {
+                        codegen_error!("singlepass emit_relaxed_zx_sx unreachable");
+                    }
+                };
+
+                self.release_gpr(tmp_src);
+            }
+            Location::GPR(_) | Location::Memory(_, _) => {
+                match dst {
+                    Location::Imm32(_) | Location::Imm64(_) => unreachable!(),
+                    Location::Memory(_, _) => {
+                        let tmp_dst = self.acquire_temp_gpr().ok_or_else(|| {
+                            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                        })?;
+                        op(
+                            &mut self.assembler,
+                            sz_src,
+                            src,
+                            sz_dst,
+                            Location::GPR(tmp_dst),
+                        )?;
+                        self.move_location(Size::S64, Location::GPR(tmp_dst), dst)?;
+
+                        self.release_gpr(tmp_dst);
+                    }
+                    Location::GPR(_) => {
+                        op(&mut self.assembler, sz_src, src, sz_dst, dst)?;
+                    }
+                    _ => {
+                        codegen_error!("singlepass emit_relaxed_zx_sx unreachable");
+                    }
+                };
+            }
+            _ => {
+                codegen_error!("singlepass emit_relaxed_zx_sx unreachable");
+            }
+        }
+        Ok(())
+    }
+    /// I32 binary operation with both operands popped from the virtual stack.
+    fn emit_binop_i32(
+        &mut self,
+        f: fn(&mut AssemblerX64, Size, Location, Location) -> Result<(), CompileError>,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if loc_a != ret {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc_a, Location::GPR(tmp))?;
+            self.emit_relaxed_binop(f, Size::S32, loc_b, Location::GPR(tmp))?;
+            self.emit_relaxed_mov(Size::S32, Location::GPR(tmp), ret)?;
+            self.release_gpr(tmp);
+        } else {
+            self.emit_relaxed_binop(f, Size::S32, loc_b, ret)?;
+        }
+        Ok(())
+    }
+    /// I64 binary operation with both operands popped from the virtual stack.
+    fn emit_binop_i64(
+        &mut self,
+        f: fn(&mut AssemblerX64, Size, Location, Location) -> Result<(), CompileError>,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if loc_a != ret {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc_a, Location::GPR(tmp))?;
+            self.emit_relaxed_binop(f, Size::S64, loc_b, Location::GPR(tmp))?;
+            self.emit_relaxed_mov(Size::S64, Location::GPR(tmp), ret)?;
+            self.release_gpr(tmp);
+        } else {
+            self.emit_relaxed_binop(f, Size::S64, loc_b, ret)?;
+        }
+        Ok(())
+    }
+    /// I64 comparison with.
+    fn emit_cmpop_i64_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        match ret {
+            Location::GPR(x) => {
+                self.emit_relaxed_cmp(Size::S64, loc_b, loc_a)?;
+                self.assembler.emit_set(c, x)?;
+                self.assembler
+                    .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(x))?;
+            }
+            Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.emit_relaxed_cmp(Size::S64, loc_b, loc_a)?;
+                self.assembler.emit_set(c, tmp)?;
+                self.assembler
+                    .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(tmp))?;
+                self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+                self.release_gpr(tmp);
+            }
+            _ => {
+                codegen_error!("singlepass emit_cmpop_i64_dynamic_b unreachable");
+            }
+        }
+        Ok(())
+    }
+    /// I64 shift with both operands popped from the virtual stack.
+    fn emit_shift_i64(
+        &mut self,
+        f: fn(&mut AssemblerX64, Size, Location, Location) -> Result<(), CompileError>,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler
+            .emit_mov(Size::S64, loc_b, Location::GPR(GPR::RCX))?;
+
+        if loc_a != ret {
+            self.emit_relaxed_mov(Size::S64, loc_a, ret)?;
+        }
+
+        f(&mut self.assembler, Size::S64, Location::GPR(GPR::RCX), ret)
+    }
+    /// Moves `loc` to a valid location for `div`/`idiv`.
+    fn emit_relaxed_xdiv(
+        &mut self,
+        op: fn(&mut AssemblerX64, Size, Location) -> Result<(), CompileError>,
+        sz: Size,
+        loc: Location,
+        integer_division_by_zero: Label,
+    ) -> Result<usize, CompileError> {
+        self.assembler.emit_cmp(sz, Location::Imm32(0), loc)?;
+        self.assembler
+            .emit_jmp(Condition::Equal, integer_division_by_zero)?;
+
+        match loc {
+            Location::Imm64(_) | Location::Imm32(_) => {
+                self.move_location(sz, loc, Location::GPR(GPR::RCX))?; // must not be used during div (rax, rdx)
+                let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+                op(&mut self.assembler, sz, Location::GPR(GPR::RCX))?;
+                self.mark_instruction_address_end(offset);
+                Ok(offset)
+            }
+            _ => {
+                let offset = self.mark_instruction_with_trap_code(TrapCode::IntegerOverflow);
+                op(&mut self.assembler, sz, loc)?;
+                self.mark_instruction_address_end(offset);
+                Ok(offset)
+            }
+        }
+    }
+    /// I32 comparison with.
+    fn emit_cmpop_i32_dynamic_b(
+        &mut self,
+        c: Condition,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        match ret {
+            Location::GPR(x) => {
+                self.emit_relaxed_cmp(Size::S32, loc_b, loc_a)?;
+                self.assembler.emit_set(c, x)?;
+                self.assembler
+                    .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(x))?;
+            }
+            Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.emit_relaxed_cmp(Size::S32, loc_b, loc_a)?;
+                self.assembler.emit_set(c, tmp)?;
+                self.assembler
+                    .emit_and(Size::S32, Location::Imm32(0xff), Location::GPR(tmp))?;
+                self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+                self.release_gpr(tmp);
+            }
+            _ => {
+                codegen_error!("singlepass emit_cmpop_i32_dynamic_b unreachable");
+            }
+        }
+        Ok(())
+    }
+    /// I32 shift with both operands popped from the virtual stack.
+    fn emit_shift_i32(
+        &mut self,
+        f: fn(&mut AssemblerX64, Size, Location, Location) -> Result<(), CompileError>,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler
+            .emit_mov(Size::S32, loc_b, Location::GPR(GPR::RCX))?;
+
+        if loc_a != ret {
+            self.emit_relaxed_mov(Size::S32, loc_a, ret)?;
+        }
+
+        f(&mut self.assembler, Size::S32, Location::GPR(GPR::RCX), ret)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn memory_op<F: FnOnce(&mut Self, GPR) -> Result<(), CompileError>>(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        check_alignment: bool,
+        value_size: usize,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+        cb: F,
+    ) -> Result<(), CompileError> {
+        // This function as been re-writen to use only 2 temporary register instead of 3
+        // without compromisong on the perfomances.
+        // The number of memory move should be equivalent to previous 3-temp regs version
+        // Register pressure is high on x86_64, and this is needed to be able to use
+        // instruction that neead RAX, like cmpxchg for example
+        let tmp_addr = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        // Reusing `tmp_addr` for temporary indirection here, since it's not used before the last reference to `{base,bound}_loc`.
+        let base_loc = if imported_memories {
+            // Imported memories require one level of indirection.
+            self.emit_relaxed_binop(
+                AssemblerX64::emit_mov,
+                Size::S64,
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::GPR(tmp2),
+            )?;
+            Location::Memory(tmp2, 0)
+        } else {
+            Location::Memory(self.get_vmctx_reg(), offset)
+        };
+
+        // Load base into temporary register.
+        self.assembler
+            .emit_mov(Size::S64, base_loc, Location::GPR(tmp2))?;
+
+        // Load effective address.
+        // `base_loc` and `bound_loc` becomes INVALID after this line, because `tmp_addr`
+        // might be reused.
+        self.assembler
+            .emit_mov(Size::S32, addr, Location::GPR(tmp_addr))?;
+
+        // Add offset to memory address.
+        if memarg.offset != 0 {
+            self.assembler.emit_add(
+                Size::S32,
+                Location::Imm32(memarg.offset as u32),
+                Location::GPR(tmp_addr),
+            )?;
+
+            // Trap if offset calculation overflowed.
+            self.assembler.emit_jmp(Condition::Carry, heap_access_oob)?;
+        }
+
+        if need_check {
+            let bound_loc = if imported_memories {
+                // Imported memories require one level of indirection.
+                self.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S64,
+                    Location::Memory(self.get_vmctx_reg(), offset),
+                    Location::GPR(tmp2),
+                )?;
+                Location::Memory(tmp2, 8)
+            } else {
+                Location::Memory(self.get_vmctx_reg(), offset + 8)
+            };
+            self.assembler
+                .emit_mov(Size::S64, bound_loc, Location::GPR(tmp2))?;
+
+            // We will compare the upper bound limit without having add the "temp_base" value, as it's a constant
+            self.assembler.emit_lea(
+                Size::S64,
+                Location::Memory(tmp2, -(value_size as i32)),
+                Location::GPR(tmp2),
+            )?;
+            // Trap if the end address of the requested area is above that of the linear memory.
+            self.assembler
+                .emit_cmp(Size::S64, Location::GPR(tmp2), Location::GPR(tmp_addr))?;
+
+            // `tmp_bound` is inclusive. So trap only if `tmp_addr > tmp_bound`.
+            self.assembler.emit_jmp(Condition::Above, heap_access_oob)?;
+        }
+        // get back baseloc, as it might have been destroid with the upper memory test
+        let base_loc = if imported_memories {
+            // Imported memories require one level of indirection.
+            self.emit_relaxed_binop(
+                AssemblerX64::emit_mov,
+                Size::S64,
+                Location::Memory(self.get_vmctx_reg(), offset),
+                Location::GPR(tmp2),
+            )?;
+            Location::Memory(tmp2, 0)
+        } else {
+            Location::Memory(self.get_vmctx_reg(), offset)
+        };
+        // Wasm linear memory -> real memory
+        self.assembler
+            .emit_add(Size::S64, base_loc, Location::GPR(tmp_addr))?;
+
+        self.release_gpr(tmp2);
+
+        let align = value_size as u32;
+        if check_alignment && align != 1 {
+            let tmp_aligncheck = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.assembler.emit_mov(
+                Size::S32,
+                Location::GPR(tmp_addr),
+                Location::GPR(tmp_aligncheck),
+            )?;
+            self.assembler.emit_and(
+                Size::S64,
+                Location::Imm32(align - 1),
+                Location::GPR(tmp_aligncheck),
+            )?;
+            self.assembler
+                .emit_jmp(Condition::NotEqual, unaligned_atomic)?;
+            self.release_gpr(tmp_aligncheck);
+        }
+        let begin = self.assembler.get_offset().0;
+        cb(self, tmp_addr)?;
+        let end = self.assembler.get_offset().0;
+        self.mark_address_range_with_trap_code(TrapCode::HeapAccessOutOfBounds, begin, end);
+
+        self.release_gpr(tmp_addr);
+        Ok(())
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn emit_compare_and_swap<F: FnOnce(&mut Self, GPR, GPR) -> Result<(), CompileError>>(
+        &mut self,
+        loc: Location,
+        target: Location,
+        ret: Location,
+        memarg: &MemArg,
+        value_size: usize,
+        memory_sz: Size,
+        stack_sz: Size,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+        cb: F,
+    ) -> Result<(), CompileError> {
+        if memory_sz > stack_sz {
+            codegen_error!("singlepass emit_compare_and_swap unreachable");
+        }
+
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if loc == Location::GPR(GPR::R14) {
+            GPR::R13
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+
+        self.move_location(stack_sz, loc, Location::GPR(value))?;
+
+        let retry = self.assembler.get_label();
+        self.emit_label(retry)?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            value_size,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.load_address(memory_sz, Location::GPR(compare), Location::Memory(addr, 0))?;
+                this.move_location(stack_sz, Location::GPR(compare), ret)?;
+                cb(this, compare, value)?;
+                this.assembler.emit_lock_cmpxchg(
+                    memory_sz,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+
+        self.jmp_on_different(retry)?;
+
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+
+    // Checks for underflow/overflow/nan.
+    #[allow(clippy::too_many_arguments)]
+    fn emit_f32_int_conv_check(
+        &mut self,
+        reg: XMM,
+        lower_bound: f32,
+        upper_bound: f32,
+        underflow_label: Label,
+        overflow_label: Label,
+        nan_label: Label,
+        succeed_label: Label,
+    ) -> Result<(), CompileError> {
+        let lower_bound = f32::to_bits(lower_bound);
+        let upper_bound = f32::to_bits(upper_bound);
+
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_x = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        // Underflow.
+        self.move_location(Size::S32, Location::Imm32(lower_bound), Location::GPR(tmp))?;
+        self.move_location(Size::S32, Location::GPR(tmp), Location::SIMD(tmp_x))?;
+        self.assembler
+            .emit_vcmpless(reg, XMMOrMemory::XMM(tmp_x), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler
+            .emit_jmp(Condition::NotEqual, underflow_label)?;
+
+        // Overflow.
+        self.move_location(Size::S32, Location::Imm32(upper_bound), Location::GPR(tmp))?;
+        self.move_location(Size::S32, Location::GPR(tmp), Location::SIMD(tmp_x))?;
+        self.assembler
+            .emit_vcmpgess(reg, XMMOrMemory::XMM(tmp_x), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler
+            .emit_jmp(Condition::NotEqual, overflow_label)?;
+
+        // NaN.
+        self.assembler
+            .emit_vcmpeqss(reg, XMMOrMemory::XMM(reg), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler.emit_jmp(Condition::Equal, nan_label)?;
+
+        self.assembler.emit_jmp(Condition::None, succeed_label)?;
+
+        self.release_simd(tmp_x);
+        self.release_gpr(tmp);
+        Ok(())
+    }
+
+    // Checks for underflow/overflow/nan before IxxTrunc{U/S}F32.
+    fn emit_f32_int_conv_check_trap(
+        &mut self,
+        reg: XMM,
+        lower_bound: f32,
+        upper_bound: f32,
+    ) -> Result<(), CompileError> {
+        let trap_overflow = self.assembler.get_label();
+        let trap_badconv = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_f32_int_conv_check(
+            reg,
+            lower_bound,
+            upper_bound,
+            trap_overflow,
+            trap_overflow,
+            trap_badconv,
+            end,
+        )?;
+
+        self.emit_label(trap_overflow)?;
+
+        self.emit_illegal_op_internal(TrapCode::IntegerOverflow)?;
+
+        self.emit_label(trap_badconv)?;
+
+        self.emit_illegal_op_internal(TrapCode::BadConversionToInteger)?;
+
+        self.emit_label(end)?;
+        Ok(())
+    }
+    #[allow(clippy::too_many_arguments)]
+    fn emit_f32_int_conv_check_sat<
+        F1: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F2: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F3: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F4: FnOnce(&mut Self) -> Result<(), CompileError>,
+    >(
+        &mut self,
+        reg: XMM,
+        lower_bound: f32,
+        upper_bound: f32,
+        underflow_cb: F1,
+        overflow_cb: F2,
+        nan_cb: Option<F3>,
+        convert_cb: F4,
+    ) -> Result<(), CompileError> {
+        // As an optimization nan_cb is optional, and when set to None we turn
+        // use 'underflow' as the 'nan' label. This is useful for callers who
+        // set the return value to zero for both underflow and nan.
+
+        let underflow = self.assembler.get_label();
+        let overflow = self.assembler.get_label();
+        let nan = if nan_cb.is_some() {
+            self.assembler.get_label()
+        } else {
+            underflow
+        };
+        let convert = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_f32_int_conv_check(
+            reg,
+            lower_bound,
+            upper_bound,
+            underflow,
+            overflow,
+            nan,
+            convert,
+        )?;
+
+        self.emit_label(underflow)?;
+        underflow_cb(self)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        self.emit_label(overflow)?;
+        overflow_cb(self)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        if let Some(cb) = nan_cb {
+            self.emit_label(nan)?;
+            cb(self)?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+        }
+
+        self.emit_label(convert)?;
+        convert_cb(self)?;
+        self.emit_label(end)
+    }
+    // Checks for underflow/overflow/nan.
+    #[allow(clippy::too_many_arguments)]
+    fn emit_f64_int_conv_check(
+        &mut self,
+        reg: XMM,
+        lower_bound: f64,
+        upper_bound: f64,
+        underflow_label: Label,
+        overflow_label: Label,
+        nan_label: Label,
+        succeed_label: Label,
+    ) -> Result<(), CompileError> {
+        let lower_bound = f64::to_bits(lower_bound);
+        let upper_bound = f64::to_bits(upper_bound);
+
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_x = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        // Underflow.
+        self.move_location(Size::S64, Location::Imm64(lower_bound), Location::GPR(tmp))?;
+        self.move_location(Size::S64, Location::GPR(tmp), Location::SIMD(tmp_x))?;
+        self.assembler
+            .emit_vcmplesd(reg, XMMOrMemory::XMM(tmp_x), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler
+            .emit_jmp(Condition::NotEqual, underflow_label)?;
+
+        // Overflow.
+        self.move_location(Size::S64, Location::Imm64(upper_bound), Location::GPR(tmp))?;
+        self.move_location(Size::S64, Location::GPR(tmp), Location::SIMD(tmp_x))?;
+        self.assembler
+            .emit_vcmpgesd(reg, XMMOrMemory::XMM(tmp_x), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler
+            .emit_jmp(Condition::NotEqual, overflow_label)?;
+
+        // NaN.
+        self.assembler
+            .emit_vcmpeqsd(reg, XMMOrMemory::XMM(reg), tmp_x)?;
+        self.move_location(Size::S32, Location::SIMD(tmp_x), Location::GPR(tmp))?;
+        self.assembler
+            .emit_cmp(Size::S32, Location::Imm32(0), Location::GPR(tmp))?;
+        self.assembler.emit_jmp(Condition::Equal, nan_label)?;
+
+        self.assembler.emit_jmp(Condition::None, succeed_label)?;
+
+        self.release_simd(tmp_x);
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    // Checks for underflow/overflow/nan before IxxTrunc{U/S}F64.. return offset/len for trap_overflow and trap_badconv
+    fn emit_f64_int_conv_check_trap(
+        &mut self,
+        reg: XMM,
+        lower_bound: f64,
+        upper_bound: f64,
+    ) -> Result<(), CompileError> {
+        let trap_overflow = self.assembler.get_label();
+        let trap_badconv = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_f64_int_conv_check(
+            reg,
+            lower_bound,
+            upper_bound,
+            trap_overflow,
+            trap_overflow,
+            trap_badconv,
+            end,
+        )?;
+
+        self.emit_label(trap_overflow)?;
+        self.emit_illegal_op_internal(TrapCode::IntegerOverflow)?;
+
+        self.emit_label(trap_badconv)?;
+        self.emit_illegal_op_internal(TrapCode::BadConversionToInteger)?;
+
+        self.emit_label(end)
+    }
+    #[allow(clippy::too_many_arguments)]
+    fn emit_f64_int_conv_check_sat<
+        F1: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F2: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F3: FnOnce(&mut Self) -> Result<(), CompileError>,
+        F4: FnOnce(&mut Self) -> Result<(), CompileError>,
+    >(
+        &mut self,
+        reg: XMM,
+        lower_bound: f64,
+        upper_bound: f64,
+        underflow_cb: F1,
+        overflow_cb: F2,
+        nan_cb: Option<F3>,
+        convert_cb: F4,
+    ) -> Result<(), CompileError> {
+        // As an optimization nan_cb is optional, and when set to None we turn
+        // use 'underflow' as the 'nan' label. This is useful for callers who
+        // set the return value to zero for both underflow and nan.
+
+        let underflow = self.assembler.get_label();
+        let overflow = self.assembler.get_label();
+        let nan = if nan_cb.is_some() {
+            self.assembler.get_label()
+        } else {
+            underflow
+        };
+        let convert = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_f64_int_conv_check(
+            reg,
+            lower_bound,
+            upper_bound,
+            underflow,
+            overflow,
+            nan,
+            convert,
+        )?;
+
+        self.emit_label(underflow)?;
+        underflow_cb(self)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        self.emit_label(overflow)?;
+        overflow_cb(self)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        if let Some(cb) = nan_cb {
+            self.emit_label(nan)?;
+            cb(self)?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+        }
+
+        self.emit_label(convert)?;
+        convert_cb(self)?;
+        self.emit_label(end)
+    }
+    /// Moves `src1` and `src2` to valid locations and possibly adds a layer of indirection for `dst` for AVX instructions.
+    fn emit_relaxed_avx(
+        &mut self,
+        op: fn(&mut AssemblerX64, XMM, XMMOrMemory, XMM) -> Result<(), CompileError>,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx_base(
+            |this, src1, src2, dst| op(&mut this.assembler, src1, src2, dst),
+            src1,
+            src2,
+            dst,
+        )
+    }
+
+    /// Moves `src1` and `src2` to valid locations and possibly adds a layer of indirection for `dst` for AVX instructions.
+    fn emit_relaxed_avx_base<
+        F: FnOnce(&mut Self, XMM, XMMOrMemory, XMM) -> Result<(), CompileError>,
+    >(
+        &mut self,
+        op: F,
+        src1: Location,
+        src2: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp3 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmpg = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        let src1 = match src1 {
+            Location::SIMD(x) => x,
+            Location::GPR(_) | Location::Memory(_, _) => {
+                self.assembler
+                    .emit_mov(Size::S64, src1, Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm32(_) => {
+                self.assembler
+                    .emit_mov(Size::S32, src1, Location::GPR(tmpg))?;
+                self.move_location(Size::S32, Location::GPR(tmpg), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            Location::Imm64(_) => {
+                self.assembler
+                    .emit_mov(Size::S64, src1, Location::GPR(tmpg))?;
+                self.move_location(Size::S64, Location::GPR(tmpg), Location::SIMD(tmp1))?;
+                tmp1
+            }
+            _ => {
+                codegen_error!("singlepass emit_relaxed_avx_base unreachable")
+            }
+        };
+
+        let src2 = match src2 {
+            Location::SIMD(x) => XMMOrMemory::XMM(x),
+            Location::Memory(base, disp) => XMMOrMemory::Memory(base, disp),
+            Location::GPR(_) => {
+                self.assembler
+                    .emit_mov(Size::S64, src2, Location::SIMD(tmp2))?;
+                XMMOrMemory::XMM(tmp2)
+            }
+            Location::Imm32(_) => {
+                self.assembler
+                    .emit_mov(Size::S32, src2, Location::GPR(tmpg))?;
+                self.move_location(Size::S32, Location::GPR(tmpg), Location::SIMD(tmp2))?;
+                XMMOrMemory::XMM(tmp2)
+            }
+            Location::Imm64(_) => {
+                self.assembler
+                    .emit_mov(Size::S64, src2, Location::GPR(tmpg))?;
+                self.move_location(Size::S64, Location::GPR(tmpg), Location::SIMD(tmp2))?;
+                XMMOrMemory::XMM(tmp2)
+            }
+            _ => {
+                codegen_error!("singlepass emit_relaxed_avx_base unreachable")
+            }
+        };
+
+        match dst {
+            Location::SIMD(x) => {
+                op(self, src1, src2, x)?;
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                op(self, src1, src2, tmp3)?;
+                self.assembler
+                    .emit_mov(Size::S64, Location::SIMD(tmp3), dst)?;
+            }
+            _ => {
+                codegen_error!("singlepass emit_relaxed_avx_base unreachable")
+            }
+        }
+
+        self.release_gpr(tmpg);
+        self.release_simd(tmp3);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
+    }
+
+    fn convert_i64_f64_u_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+        self.emit_f64_int_conv_check_sat(
+            tmp_in,
+            GEF64_LT_U64_MIN,
+            LEF64_GT_U64_MAX,
+            |this| {
+                this.assembler
+                    .emit_mov(Size::S64, Location::Imm64(0), Location::GPR(tmp_out))
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::u64::MAX),
+                    Location::GPR(tmp_out),
+                )
+            },
+            None::<fn(this: &mut Self) -> Result<(), CompileError>>,
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i64_trunc_uf64(tmp_in, tmp_out)
+                } else {
+                    let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    let tmp_x1 = this.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+                    let tmp_x2 = this.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+
+                    this.assembler.emit_mov(
+                        Size::S64,
+                        Location::Imm64(4890909195324358656u64),
+                        Location::GPR(tmp),
+                    )?; //double 9.2233720368547758E+18
+                    this.assembler.emit_mov(
+                        Size::S64,
+                        Location::GPR(tmp),
+                        Location::SIMD(tmp_x1),
+                    )?;
+                    this.assembler.emit_mov(
+                        Size::S64,
+                        Location::SIMD(tmp_in),
+                        Location::SIMD(tmp_x2),
+                    )?;
+                    this.assembler
+                        .emit_vsubsd(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in)?;
+                    this.assembler
+                        .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+                    this.assembler.emit_mov(
+                        Size::S64,
+                        Location::Imm64(0x8000000000000000u64),
+                        Location::GPR(tmp),
+                    )?;
+                    this.assembler.emit_xor(
+                        Size::S64,
+                        Location::GPR(tmp_out),
+                        Location::GPR(tmp),
+                    )?;
+                    this.assembler
+                        .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out)?;
+                    this.assembler
+                        .emit_ucomisd(XMMOrMemory::XMM(tmp_x1), tmp_x2)?;
+                    this.assembler.emit_cmovae_gpr_64(tmp, tmp_out)?;
+
+                    this.release_simd(tmp_x2);
+                    this.release_simd(tmp_x1);
+                    this.release_gpr(tmp);
+                    Ok(())
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i64_f64_u_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i64_trunc_uf64(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm2
+
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_U64_MIN, LEF64_GT_U64_MAX)?;
+
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?; // r15
+            let tmp_x1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm1
+            let tmp_x2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm3
+
+            self.move_location(
+                Size::S64,
+                Location::Imm64(4890909195324358656u64),
+                Location::GPR(tmp),
+            )?; //double 9.2233720368547758E+18
+            self.move_location(Size::S64, Location::GPR(tmp), Location::SIMD(tmp_x1))?;
+            self.move_location(Size::S64, Location::SIMD(tmp_in), Location::SIMD(tmp_x2))?;
+            self.assembler
+                .emit_vsubsd(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in)?;
+            self.assembler
+                .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(
+                Size::S64,
+                Location::Imm64(0x8000000000000000u64),
+                Location::GPR(tmp),
+            )?;
+            self.assembler
+                .emit_xor(Size::S64, Location::GPR(tmp_out), Location::GPR(tmp))?;
+            self.assembler
+                .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out)?;
+            self.assembler
+                .emit_ucomisd(XMMOrMemory::XMM(tmp_x1), tmp_x2)?;
+            self.assembler.emit_cmovae_gpr_64(tmp, tmp_out)?;
+            self.move_location(Size::S64, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_x2);
+            self.release_simd(tmp_x1);
+            self.release_gpr(tmp);
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i64_f64_s_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+        self.emit_f64_int_conv_check_sat(
+            tmp_in,
+            GEF64_LT_I64_MIN,
+            LEF64_GT_I64_MAX,
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::i64::MIN as u64),
+                    Location::GPR(tmp_out),
+                )
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::i64::MAX as u64),
+                    Location::GPR(tmp_out),
+                )
+            },
+            Some(|this: &mut Self| {
+                this.assembler
+                    .emit_mov(Size::S64, Location::Imm64(0), Location::GPR(tmp_out))
+            }),
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i64_trunc_sf64(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i64_f64_s_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i64_trunc_sf64(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_I64_MIN, LEF64_GT_I64_MAX)?;
+
+            self.assembler
+                .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(Size::S64, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i32_f64_s_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        let real_in = match loc {
+            Location::Imm32(_) | Location::Imm64(_) => {
+                self.move_location(Size::S64, loc, Location::GPR(tmp_out))?;
+                self.move_location(Size::S64, Location::GPR(tmp_out), Location::SIMD(tmp_in))?;
+                tmp_in
+            }
+            Location::SIMD(x) => x,
+            _ => {
+                self.move_location(Size::S64, loc, Location::SIMD(tmp_in))?;
+                tmp_in
+            }
+        };
+
+        self.emit_f64_int_conv_check_sat(
+            real_in,
+            GEF64_LT_I32_MIN,
+            LEF64_GT_I32_MAX,
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::i32::MIN as u32),
+                    Location::GPR(tmp_out),
+                )
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::i32::MAX as u32),
+                    Location::GPR(tmp_out),
+                )
+            },
+            Some(|this: &mut Self| {
+                this.assembler
+                    .emit_mov(Size::S32, Location::Imm32(0), Location::GPR(tmp_out))
+            }),
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i32_trunc_sf64(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttsd2si_32(XMMOrMemory::XMM(real_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i32_f64_s_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i32_trunc_sf64(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+
+            let real_in = match loc {
+                Location::Imm32(_) | Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc, Location::GPR(tmp_out))?;
+                    self.move_location(Size::S64, Location::GPR(tmp_out), Location::SIMD(tmp_in))?;
+                    tmp_in
+                }
+                Location::SIMD(x) => x,
+                _ => {
+                    self.move_location(Size::S64, loc, Location::SIMD(tmp_in))?;
+                    tmp_in
+                }
+            };
+
+            self.emit_f64_int_conv_check_trap(real_in, GEF64_LT_I32_MIN, LEF64_GT_I32_MAX)?;
+
+            self.assembler
+                .emit_cvttsd2si_32(XMMOrMemory::XMM(real_in), tmp_out)?;
+            self.move_location(Size::S32, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i32_f64_u_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+        self.emit_f64_int_conv_check_sat(
+            tmp_in,
+            GEF64_LT_U32_MIN,
+            LEF64_GT_U32_MAX,
+            |this| {
+                this.assembler
+                    .emit_mov(Size::S32, Location::Imm32(0), Location::GPR(tmp_out))
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::u32::MAX),
+                    Location::GPR(tmp_out),
+                )
+            },
+            None::<fn(this: &mut Self) -> Result<(), CompileError>>,
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i32_trunc_uf64(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i32_f64_u_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i32_trunc_uf64(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp_in))?;
+            self.emit_f64_int_conv_check_trap(tmp_in, GEF64_LT_U32_MIN, LEF64_GT_U32_MAX)?;
+
+            self.assembler
+                .emit_cvttsd2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(Size::S32, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i64_f32_u_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+        self.emit_f32_int_conv_check_sat(
+            tmp_in,
+            GEF32_LT_U64_MIN,
+            LEF32_GT_U64_MAX,
+            |this| {
+                this.assembler
+                    .emit_mov(Size::S64, Location::Imm64(0), Location::GPR(tmp_out))
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::u64::MAX),
+                    Location::GPR(tmp_out),
+                )
+            },
+            None::<fn(this: &mut Self) -> Result<(), CompileError>>,
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i64_trunc_uf32(tmp_in, tmp_out)
+                } else {
+                    let tmp = this.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    let tmp_x1 = this.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+                    let tmp_x2 = this.acquire_temp_simd().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+                    })?;
+
+                    this.assembler.emit_mov(
+                        Size::S32,
+                        Location::Imm32(1593835520u32),
+                        Location::GPR(tmp),
+                    )?; //float 9.22337203E+18
+                    this.assembler.emit_mov(
+                        Size::S32,
+                        Location::GPR(tmp),
+                        Location::SIMD(tmp_x1),
+                    )?;
+                    this.assembler.emit_mov(
+                        Size::S32,
+                        Location::SIMD(tmp_in),
+                        Location::SIMD(tmp_x2),
+                    )?;
+                    this.assembler
+                        .emit_vsubss(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in)?;
+                    this.assembler
+                        .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+                    this.assembler.emit_mov(
+                        Size::S64,
+                        Location::Imm64(0x8000000000000000u64),
+                        Location::GPR(tmp),
+                    )?;
+                    this.assembler.emit_xor(
+                        Size::S64,
+                        Location::GPR(tmp_out),
+                        Location::GPR(tmp),
+                    )?;
+                    this.assembler
+                        .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out)?;
+                    this.assembler
+                        .emit_ucomiss(XMMOrMemory::XMM(tmp_x1), tmp_x2)?;
+                    this.assembler.emit_cmovae_gpr_64(tmp, tmp_out)?;
+
+                    this.release_simd(tmp_x2);
+                    this.release_simd(tmp_x1);
+                    this.release_gpr(tmp);
+                    Ok(())
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i64_f32_u_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i64_trunc_uf32(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm2
+
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_U64_MIN, LEF32_GT_U64_MAX)?;
+
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?; // r15
+            let tmp_x1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm1
+            let tmp_x2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?; // xmm3
+
+            self.move_location(
+                Size::S32,
+                Location::Imm32(1593835520u32),
+                Location::GPR(tmp),
+            )?; //float 9.22337203E+18
+            self.move_location(Size::S32, Location::GPR(tmp), Location::SIMD(tmp_x1))?;
+            self.move_location(Size::S32, Location::SIMD(tmp_in), Location::SIMD(tmp_x2))?;
+            self.assembler
+                .emit_vsubss(tmp_in, XMMOrMemory::XMM(tmp_x1), tmp_in)?;
+            self.assembler
+                .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(
+                Size::S64,
+                Location::Imm64(0x8000000000000000u64),
+                Location::GPR(tmp),
+            )?;
+            self.assembler
+                .emit_xor(Size::S64, Location::GPR(tmp_out), Location::GPR(tmp))?;
+            self.assembler
+                .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_x2), tmp_out)?;
+            self.assembler
+                .emit_ucomiss(XMMOrMemory::XMM(tmp_x1), tmp_x2)?;
+            self.assembler.emit_cmovae_gpr_64(tmp, tmp_out)?;
+            self.move_location(Size::S64, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_x2);
+            self.release_simd(tmp_x1);
+            self.release_gpr(tmp);
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i64_f32_s_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+        self.emit_f32_int_conv_check_sat(
+            tmp_in,
+            GEF32_LT_I64_MIN,
+            LEF32_GT_I64_MAX,
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::i64::MIN as u64),
+                    Location::GPR(tmp_out),
+                )
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S64,
+                    Location::Imm64(std::i64::MAX as u64),
+                    Location::GPR(tmp_out),
+                )
+            },
+            Some(|this: &mut Self| {
+                this.assembler
+                    .emit_mov(Size::S64, Location::Imm64(0), Location::GPR(tmp_out))
+            }),
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i64_trunc_sf32(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i64_f32_s_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i64_trunc_sf32(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S64, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_I64_MIN, LEF32_GT_I64_MAX)?;
+            self.assembler
+                .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(Size::S64, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i32_f32_s_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+        self.emit_f32_int_conv_check_sat(
+            tmp_in,
+            GEF32_LT_I32_MIN,
+            LEF32_GT_I32_MAX,
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::i32::MIN as u32),
+                    Location::GPR(tmp_out),
+                )
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::i32::MAX as u32),
+                    Location::GPR(tmp_out),
+                )
+            },
+            Some(|this: &mut Self| {
+                this.assembler
+                    .emit_mov(Size::S32, Location::Imm32(0), Location::GPR(tmp_out))
+            }),
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i32_trunc_sf32(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttss2si_32(XMMOrMemory::XMM(tmp_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i32_f32_s_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i32_trunc_sf32(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_I32_MIN, LEF32_GT_I32_MAX)?;
+
+            self.assembler
+                .emit_cvttss2si_32(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(Size::S32, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+    fn convert_i32_f32_u_s(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+        self.emit_f32_int_conv_check_sat(
+            tmp_in,
+            GEF32_LT_U32_MIN,
+            LEF32_GT_U32_MAX,
+            |this| {
+                this.assembler
+                    .emit_mov(Size::S32, Location::Imm32(0), Location::GPR(tmp_out))
+            },
+            |this| {
+                this.assembler.emit_mov(
+                    Size::S32,
+                    Location::Imm32(std::u32::MAX),
+                    Location::GPR(tmp_out),
+                )
+            },
+            None::<fn(this: &mut Self) -> Result<(), CompileError>>,
+            |this| {
+                if this.assembler.arch_has_itruncf() {
+                    this.assembler.arch_emit_i32_trunc_uf32(tmp_in, tmp_out)
+                } else {
+                    this.assembler
+                        .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)
+                }
+            },
+        )?;
+
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+        self.release_simd(tmp_in);
+        self.release_gpr(tmp_out);
+        Ok(())
+    }
+    fn convert_i32_f32_u_u(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_itruncf() {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.assembler.arch_emit_i32_trunc_uf32(tmp_in, tmp_out)?;
+            self.emit_relaxed_mov(Size::S32, Location::GPR(tmp_out), ret)?;
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        } else {
+            let tmp_out = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmp_in = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp_in))?;
+            self.emit_f32_int_conv_check_trap(tmp_in, GEF32_LT_U32_MIN, LEF32_GT_U32_MAX)?;
+
+            self.assembler
+                .emit_cvttss2si_64(XMMOrMemory::XMM(tmp_in), tmp_out)?;
+            self.move_location(Size::S32, Location::GPR(tmp_out), ret)?;
+
+            self.release_simd(tmp_in);
+            self.release_gpr(tmp_out);
+        }
+        Ok(())
+    }
+
+    fn emit_relaxed_atomic_xchg(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(AssemblerX64::emit_xchg, sz, src, dst)
+    }
+
+    fn used_gprs_contains(&self, r: &GPR) -> bool {
+        self.used_gprs & (1 << r.into_index()) != 0
+    }
+    fn used_simd_contains(&self, r: &XMM) -> bool {
+        self.used_simd & (1 << r.into_index()) != 0
+    }
+    fn used_gprs_insert(&mut self, r: GPR) {
+        self.used_gprs |= 1 << r.into_index();
+    }
+    fn used_simd_insert(&mut self, r: XMM) {
+        self.used_simd |= 1 << r.into_index();
+    }
+    fn used_gprs_remove(&mut self, r: &GPR) -> bool {
+        let ret = self.used_gprs_contains(r);
+        self.used_gprs &= !(1 << r.into_index());
+        ret
+    }
+    fn used_simd_remove(&mut self, r: &XMM) -> bool {
+        let ret = self.used_simd_contains(r);
+        self.used_simd &= !(1 << r.into_index());
+        ret
+    }
+    fn emit_unwind_op(&mut self, op: UnwindOps) -> Result<(), CompileError> {
+        self.unwind_ops.push((self.get_offset().0, op));
+        Ok(())
+    }
+    fn emit_illegal_op_internal(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        let v = trap as u8;
+        self.assembler.emit_ud1_payload(v)
+    }
+}
+
+impl Machine for MachineX86_64 {
+    type GPR = GPR;
+    type SIMD = XMM;
+    fn assembler_get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+    fn index_from_gpr(&self, x: GPR) -> RegisterIndex {
+        RegisterIndex(x as usize)
+    }
+    fn index_from_simd(&self, x: XMM) -> RegisterIndex {
+        RegisterIndex(x as usize + 16)
+    }
+
+    fn get_vmctx_reg(&self) -> GPR {
+        GPR::R15
+    }
+
+    fn get_used_gprs(&self) -> Vec<GPR> {
+        GPR::iterator()
+            .filter(|x| self.used_gprs & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+
+    fn get_used_simd(&self) -> Vec<XMM> {
+        XMM::iterator()
+            .filter(|x| self.used_simd & (1 << x.into_index()) != 0)
+            .cloned()
+            .collect()
+    }
+
+    fn pick_gpr(&self) -> Option<GPR> {
+        use GPR::*;
+        static REGS: &[GPR] = &[RSI, RDI, R8, R9, R10, R11];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused general purpose register for internal temporary use.
+    fn pick_temp_gpr(&self) -> Option<GPR> {
+        use GPR::*;
+        static REGS: &[GPR] = &[RAX, RCX, RDX];
+        for r in REGS {
+            if !self.used_gprs_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    fn acquire_temp_gpr(&mut self) -> Option<GPR> {
+        let gpr = self.pick_temp_gpr();
+        if let Some(x) = gpr {
+            self.used_gprs_insert(x);
+        }
+        gpr
+    }
+
+    fn release_gpr(&mut self, gpr: GPR) {
+        assert!(self.used_gprs_remove(&gpr));
+    }
+
+    fn reserve_unused_temp_gpr(&mut self, gpr: GPR) -> GPR {
+        assert!(!self.used_gprs_contains(&gpr));
+        self.used_gprs_insert(gpr);
+        gpr
+    }
+
+    fn reserve_gpr(&mut self, gpr: GPR) {
+        self.used_gprs_insert(gpr);
+    }
+
+    fn push_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<usize, CompileError> {
+        for r in used_gprs.iter() {
+            self.assembler.emit_push(Size::S64, Location::GPR(*r))?;
+        }
+        Ok(used_gprs.len() * 8)
+    }
+    fn pop_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<(), CompileError> {
+        for r in used_gprs.iter().rev() {
+            self.assembler.emit_pop(Size::S64, Location::GPR(*r))?;
+        }
+        Ok(())
+    }
+
+    // Picks an unused XMM register.
+    fn pick_simd(&self) -> Option<XMM> {
+        use XMM::*;
+        static REGS: &[XMM] = &[XMM3, XMM4, XMM5, XMM6, XMM7];
+        for r in REGS {
+            if !self.used_simd_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Picks an unused XMM register for internal temporary use.
+    fn pick_temp_simd(&self) -> Option<XMM> {
+        use XMM::*;
+        static REGS: &[XMM] = &[XMM0, XMM1, XMM2];
+        for r in REGS {
+            if !self.used_simd_contains(r) {
+                return Some(*r);
+            }
+        }
+        None
+    }
+
+    // Acquires a temporary XMM register.
+    fn acquire_temp_simd(&mut self) -> Option<XMM> {
+        let simd = self.pick_temp_simd();
+        if let Some(x) = simd {
+            self.used_simd_insert(x);
+        }
+        simd
+    }
+
+    fn reserve_simd(&mut self, simd: XMM) {
+        self.used_simd_insert(simd);
+    }
+
+    // Releases a temporary XMM register.
+    fn release_simd(&mut self, simd: XMM) {
+        assert!(self.used_simd_remove(&simd));
+    }
+
+    fn push_used_simd(&mut self, used_xmms: &[XMM]) -> Result<usize, CompileError> {
+        self.adjust_stack((used_xmms.len() * 8) as u32)?;
+
+        for (i, r) in used_xmms.iter().enumerate() {
+            self.move_location(
+                Size::S64,
+                Location::SIMD(*r),
+                Location::Memory(GPR::RSP, (i * 8) as i32),
+            )?;
+        }
+
+        Ok(used_xmms.len() * 8)
+    }
+    fn pop_used_simd(&mut self, used_xmms: &[XMM]) -> Result<(), CompileError> {
+        for (i, r) in used_xmms.iter().enumerate() {
+            self.move_location(
+                Size::S64,
+                Location::Memory(GPR::RSP, (i * 8) as i32),
+                Location::SIMD(*r),
+            )?;
+        }
+        self.assembler.emit_add(
+            Size::S64,
+            Location::Imm32((used_xmms.len() * 8) as u32),
+            Location::GPR(GPR::RSP),
+        )
+    }
+
+    /// Set the source location of the Wasm to the given offset.
+    fn set_srcloc(&mut self, offset: u32) {
+        self.src_loc = offset;
+    }
+    /// Marks each address in the code range emitted by `f` with the trap code `code`.
+    fn mark_address_range_with_trap_code(&mut self, code: TrapCode, begin: usize, end: usize) {
+        for i in begin..end {
+            self.trap_table.offset_to_code.insert(i, code);
+        }
+        self.mark_instruction_address_end(begin);
+    }
+
+    /// Marks one address as trappable with trap code `code`.
+    fn mark_address_with_trap_code(&mut self, code: TrapCode) {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        self.mark_instruction_address_end(offset);
+    }
+    /// Marks the instruction as trappable with trap code `code`. return "begin" offset
+    fn mark_instruction_with_trap_code(&mut self, code: TrapCode) -> usize {
+        let offset = self.assembler.get_offset().0;
+        self.trap_table.offset_to_code.insert(offset, code);
+        offset
+    }
+    /// Pushes the instruction to the address map, calculating the offset from a
+    /// provided beginning address.
+    fn mark_instruction_address_end(&mut self, begin: usize) {
+        self.instructions_address_map.push(InstructionAddressMap {
+            srcloc: SourceLoc::new(self.src_loc),
+            code_offset: begin,
+            code_len: self.assembler.get_offset().0 - begin,
+        });
+    }
+
+    /// Insert a StackOverflow (at offset 0)
+    fn insert_stackoverflow(&mut self) {
+        let offset = 0;
+        self.trap_table
+            .offset_to_code
+            .insert(offset, TrapCode::StackOverflow);
+        self.mark_instruction_address_end(offset);
+    }
+
+    /// Get all current TrapInformation
+    fn collect_trap_information(&self) -> Vec<TrapInformation> {
+        self.trap_table
+            .offset_to_code
+            .clone()
+            .into_iter()
+            .map(|(offset, code)| TrapInformation {
+                code_offset: offset as u32,
+                trap_code: code,
+            })
+            .collect()
+    }
+
+    fn instructions_address_map(&self) -> Vec<InstructionAddressMap> {
+        self.instructions_address_map.clone()
+    }
+
+    // Memory location for a local on the stack
+    fn local_on_stack(&mut self, stack_offset: i32) -> Location {
+        Location::Memory(GPR::RBP, -stack_offset)
+    }
+
+    // Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)
+    fn round_stack_adjust(&self, value: usize) -> usize {
+        value
+    }
+
+    // Adjust stack for locals
+    fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        self.assembler.emit_sub(
+            Size::S64,
+            Location::Imm32(delta_stack_offset),
+            Location::GPR(GPR::RSP),
+        )
+    }
+    // restore stack
+    fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        self.assembler.emit_add(
+            Size::S64,
+            Location::Imm32(delta_stack_offset),
+            Location::GPR(GPR::RSP),
+        )
+    }
+    fn pop_stack_locals(&mut self, delta_stack_offset: u32) -> Result<(), CompileError> {
+        self.assembler.emit_add(
+            Size::S64,
+            Location::Imm32(delta_stack_offset),
+            Location::GPR(GPR::RSP),
+        )
+    }
+    // push a value on the stack for a native call
+    fn move_location_for_native(
+        &mut self,
+        _size: Size,
+        loc: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match loc {
+            Location::Imm64(_) | Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                let tmp = self.pick_temp_gpr();
+                if let Some(x) = tmp {
+                    self.assembler.emit_mov(Size::S64, loc, Location::GPR(x))?;
+                    self.assembler.emit_mov(Size::S64, Location::GPR(x), dest)
+                } else {
+                    self.assembler
+                        .emit_mov(Size::S64, Location::GPR(GPR::RAX), dest)?;
+                    self.assembler
+                        .emit_mov(Size::S64, loc, Location::GPR(GPR::RAX))?;
+                    self.assembler
+                        .emit_xchg(Size::S64, Location::GPR(GPR::RAX), dest)
+                }
+            }
+            _ => self.assembler.emit_mov(Size::S64, loc, dest),
+        }
+    }
+
+    // Zero a location that is 32bits
+    fn zero_location(&mut self, size: Size, location: Location) -> Result<(), CompileError> {
+        self.assembler.emit_mov(size, Location::Imm32(0), location)
+    }
+
+    // GPR Reg used for local pointer on the stack
+    fn local_pointer(&self) -> GPR {
+        GPR::RBP
+    }
+
+    // Determine whether a local should be allocated on the stack.
+    fn is_local_on_stack(&self, idx: usize) -> bool {
+        idx > 3
+    }
+
+    // Determine a local's location.
+    fn get_local_location(&self, idx: usize, callee_saved_regs_size: usize) -> Location {
+        // Use callee-saved registers for the first locals.
+        match idx {
+            0 => Location::GPR(GPR::R12),
+            1 => Location::GPR(GPR::R13),
+            2 => Location::GPR(GPR::R14),
+            3 => Location::GPR(GPR::RBX),
+            _ => Location::Memory(GPR::RBP, -(((idx - 3) * 8 + callee_saved_regs_size) as i32)),
+        }
+    }
+    // Move a local to the stack
+    fn move_local(&mut self, stack_offset: i32, location: Location) -> Result<(), CompileError> {
+        self.assembler.emit_mov(
+            Size::S64,
+            location,
+            Location::Memory(GPR::RBP, -stack_offset),
+        )?;
+        match location {
+            Location::GPR(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: x.to_dwarf(),
+                bp_neg_offset: stack_offset,
+            }),
+            Location::SIMD(x) => self.emit_unwind_op(UnwindOps::SaveRegister {
+                reg: x.to_dwarf(),
+                bp_neg_offset: stack_offset,
+            }),
+            _ => Ok(()),
+        }
+    }
+
+    // List of register to save, depending on the CallingConvention
+    fn list_to_save(&self, calling_convention: CallingConvention) -> Vec<Location> {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => {
+                vec![Location::GPR(GPR::RDI), Location::GPR(GPR::RSI)]
+            }
+            _ => vec![],
+        }
+    }
+
+    // Get param location
+    fn get_param_location(
+        &self,
+        idx: usize,
+        _sz: Size,
+        stack_location: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => match idx {
+                0 => Location::GPR(GPR::RCX),
+                1 => Location::GPR(GPR::RDX),
+                2 => Location::GPR(GPR::R8),
+                3 => Location::GPR(GPR::R9),
+                _ => {
+                    let loc = Location::Memory(GPR::RSP, *stack_location as i32);
+                    *stack_location += 8;
+                    loc
+                }
+            },
+            _ => match idx {
+                0 => Location::GPR(GPR::RDI),
+                1 => Location::GPR(GPR::RSI),
+                2 => Location::GPR(GPR::RDX),
+                3 => Location::GPR(GPR::RCX),
+                4 => Location::GPR(GPR::R8),
+                5 => Location::GPR(GPR::R9),
+                _ => {
+                    let loc = Location::Memory(GPR::RSP, *stack_location as i32);
+                    *stack_location += 8;
+                    loc
+                }
+            },
+        }
+    }
+    // Get call param location
+    fn get_call_param_location(
+        &self,
+        idx: usize,
+        _sz: Size,
+        _stack_location: &mut usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => match idx {
+                0 => Location::GPR(GPR::RCX),
+                1 => Location::GPR(GPR::RDX),
+                2 => Location::GPR(GPR::R8),
+                3 => Location::GPR(GPR::R9),
+                _ => Location::Memory(GPR::RBP, (32 + 16 + (idx - 4) * 8) as i32),
+            },
+            _ => match idx {
+                0 => Location::GPR(GPR::RDI),
+                1 => Location::GPR(GPR::RSI),
+                2 => Location::GPR(GPR::RDX),
+                3 => Location::GPR(GPR::RCX),
+                4 => Location::GPR(GPR::R8),
+                5 => Location::GPR(GPR::R9),
+                _ => Location::Memory(GPR::RBP, (16 + (idx - 6) * 8) as i32),
+            },
+        }
+    }
+    // Get simple param location
+    fn get_simple_param_location(
+        &self,
+        idx: usize,
+        calling_convention: CallingConvention,
+    ) -> Location {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => match idx {
+                0 => Location::GPR(GPR::RCX),
+                1 => Location::GPR(GPR::RDX),
+                2 => Location::GPR(GPR::R8),
+                3 => Location::GPR(GPR::R9),
+                _ => Location::Memory(GPR::RBP, (32 + 16 + (idx - 4) * 8) as i32),
+            },
+            _ => match idx {
+                0 => Location::GPR(GPR::RDI),
+                1 => Location::GPR(GPR::RSI),
+                2 => Location::GPR(GPR::RDX),
+                3 => Location::GPR(GPR::RCX),
+                4 => Location::GPR(GPR::R8),
+                5 => Location::GPR(GPR::R9),
+                _ => Location::Memory(GPR::RBP, (16 + (idx - 6) * 8) as i32),
+            },
+        }
+    }
+    // move a location to another
+    fn move_location(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        match source {
+            Location::GPR(_) => self.assembler.emit_mov(size, source, dest),
+            Location::Memory(_, _) => match dest {
+                Location::GPR(_) | Location::SIMD(_) => self.assembler.emit_mov(size, source, dest),
+                Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                    let tmp = self.pick_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass can't pick a temp gpr".to_owned())
+                    })?;
+                    self.assembler.emit_mov(size, source, Location::GPR(tmp))?;
+                    self.assembler.emit_mov(size, Location::GPR(tmp), dest)
+                }
+                _ => codegen_error!("singlepass move_location unreachable"),
+            },
+            Location::Memory2(_, _, _, _) => match dest {
+                Location::GPR(_) | Location::SIMD(_) => self.assembler.emit_mov(size, source, dest),
+                Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                    let tmp = self.pick_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass can't pick a temp gpr".to_owned())
+                    })?;
+                    self.assembler.emit_mov(size, source, Location::GPR(tmp))?;
+                    self.assembler.emit_mov(size, Location::GPR(tmp), dest)
+                }
+                _ => codegen_error!("singlepass move_location unreachable"),
+            },
+            Location::Imm8(_) | Location::Imm32(_) | Location::Imm64(_) => match dest {
+                Location::GPR(_) | Location::SIMD(_) => self.assembler.emit_mov(size, source, dest),
+                Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                    let tmp = self.pick_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass can't pick a temp gpr".to_owned())
+                    })?;
+                    self.assembler.emit_mov(size, source, Location::GPR(tmp))?;
+                    self.assembler.emit_mov(size, Location::GPR(tmp), dest)
+                }
+                _ => codegen_error!("singlepass move_location unreachable"),
+            },
+            Location::SIMD(_) => self.assembler.emit_mov(size, source, dest),
+            _ => codegen_error!("singlepass move_location unreachable"),
+        }
+    }
+    // move a location to another
+    fn move_location_extend(
+        &mut self,
+        size_val: Size,
+        signed: bool,
+        source: Location,
+        size_op: Size,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        let dst = match dest {
+            Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                Location::GPR(self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?)
+            }
+            Location::GPR(_) | Location::SIMD(_) => dest,
+            _ => codegen_error!("singlepass move_location_extend unreachable"),
+        };
+        match source {
+            Location::GPR(_)
+            | Location::Memory(_, _)
+            | Location::Memory2(_, _, _, _)
+            | Location::Imm32(_)
+            | Location::Imm64(_) => match size_val {
+                Size::S32 | Size::S64 => self.assembler.emit_mov(size_val, source, dst),
+                Size::S16 | Size::S8 => {
+                    if signed {
+                        self.assembler.emit_movsx(size_val, source, size_op, dst)
+                    } else {
+                        self.assembler.emit_movzx(size_val, source, size_op, dst)
+                    }
+                }
+            },
+            _ => panic!(
+                "unimplemented move_location_extend({:?}, {}, {:?}, {:?}, {:?}",
+                size_val, signed, source, size_op, dest
+            ),
+        }?;
+        if dst != dest {
+            self.assembler.emit_mov(size_op, dst, dest)?;
+            match dst {
+                Location::GPR(x) => self.release_gpr(x),
+                _ => codegen_error!("singlepass move_location_extend unreachable"),
+            };
+        }
+        Ok(())
+    }
+    fn load_address(
+        &mut self,
+        size: Size,
+        reg: Location,
+        mem: Location,
+    ) -> Result<(), CompileError> {
+        match reg {
+            Location::GPR(_) => {
+                match mem {
+                    Location::Memory(_, _) | Location::Memory2(_, _, _, _) => {
+                        // Memory moves with size < 32b do not zero upper bits.
+                        if size < Size::S32 {
+                            self.assembler.emit_xor(Size::S32, reg, reg)?;
+                        }
+                        self.assembler.emit_mov(size, mem, reg)?;
+                    }
+                    _ => codegen_error!("singlepass load_address unreachable"),
+                }
+            }
+            _ => codegen_error!("singlepass load_address unreachable"),
+        }
+        Ok(())
+    }
+    // Init the stack loc counter
+    fn init_stack_loc(
+        &mut self,
+        init_stack_loc_cnt: u64,
+        last_stack_loc: Location,
+    ) -> Result<(), CompileError> {
+        // Since these assemblies take up to 24 bytes, if more than 2 slots are initialized, then they are smaller.
+        self.assembler.emit_mov(
+            Size::S64,
+            Location::Imm64(init_stack_loc_cnt),
+            Location::GPR(GPR::RCX),
+        )?;
+        self.assembler
+            .emit_xor(Size::S64, Location::GPR(GPR::RAX), Location::GPR(GPR::RAX))?;
+        self.assembler
+            .emit_lea(Size::S64, last_stack_loc, Location::GPR(GPR::RDI))?;
+        self.assembler.emit_rep_stosq()
+    }
+    // Restore save_area
+    fn restore_saved_area(&mut self, saved_area_offset: i32) -> Result<(), CompileError> {
+        self.assembler.emit_lea(
+            Size::S64,
+            Location::Memory(GPR::RBP, -saved_area_offset),
+            Location::GPR(GPR::RSP),
+        )
+    }
+    // Pop a location
+    fn pop_location(&mut self, location: Location) -> Result<(), CompileError> {
+        self.assembler.emit_pop(Size::S64, location)
+    }
+    // Create a new `MachineState` with default values.
+    fn new_machine_state(&self) -> MachineState {
+        new_machine_state()
+    }
+
+    // assembler finalize
+    fn assembler_finalize(self) -> Result<Vec<u8>, CompileError> {
+        self.assembler.finalize().map_err(|e| {
+            CompileError::Codegen(format!("Assembler failed finalization with: {:?}", e))
+        })
+    }
+
+    fn get_offset(&self) -> Offset {
+        self.assembler.get_offset()
+    }
+
+    fn finalize_function(&mut self) -> Result<(), CompileError> {
+        self.assembler.finalize_function()?;
+        Ok(())
+    }
+
+    fn emit_function_prolog(&mut self) -> Result<(), CompileError> {
+        self.emit_push(Size::S64, Location::GPR(GPR::RBP))?;
+        self.emit_unwind_op(UnwindOps::PushFP { up_to_sp: 16 })?;
+        self.move_location(Size::S64, Location::GPR(GPR::RSP), Location::GPR(GPR::RBP))?;
+        self.emit_unwind_op(UnwindOps::DefineNewFrame)
+    }
+
+    fn emit_function_epilog(&mut self) -> Result<(), CompileError> {
+        self.move_location(Size::S64, Location::GPR(GPR::RBP), Location::GPR(GPR::RSP))?;
+        self.emit_pop(Size::S64, Location::GPR(GPR::RBP))
+    }
+
+    fn emit_function_return_value(
+        &mut self,
+        ty: WpType,
+        canonicalize: bool,
+        loc: Location,
+    ) -> Result<(), CompileError> {
+        if canonicalize {
+            self.canonicalize_nan(
+                match ty {
+                    WpType::F32 => Size::S32,
+                    WpType::F64 => Size::S64,
+                    _ => codegen_error!("singlepass emit_function_return_value unreachable"),
+                },
+                loc,
+                Location::GPR(GPR::RAX),
+            )
+        } else {
+            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(GPR::RAX))
+        }
+    }
+
+    fn emit_function_return_float(&mut self) -> Result<(), CompileError> {
+        self.move_location(
+            Size::S64,
+            Location::GPR(GPR::RAX),
+            Location::SIMD(XMM::XMM0),
+        )
+    }
+
+    fn arch_supports_canonicalize_nan(&self) -> bool {
+        self.assembler.arch_supports_canonicalize_nan()
+    }
+    fn canonicalize_nan(
+        &mut self,
+        sz: Size,
+        input: Location,
+        output: Location,
+    ) -> Result<(), CompileError> {
+        let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp3 = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+
+        self.emit_relaxed_mov(sz, input, Location::SIMD(tmp1))?;
+        let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        match sz {
+            Size::S32 => {
+                self.assembler
+                    .emit_vcmpunordss(tmp1, XMMOrMemory::XMM(tmp1), tmp2)?;
+                self.move_location(
+                    Size::S32,
+                    Location::Imm32(0x7FC0_0000), // Canonical NaN
+                    Location::GPR(tmpg1),
+                )?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp3))?;
+                self.assembler
+                    .emit_vblendvps(tmp2, XMMOrMemory::XMM(tmp3), tmp1, tmp1)?;
+            }
+            Size::S64 => {
+                self.assembler
+                    .emit_vcmpunordsd(tmp1, XMMOrMemory::XMM(tmp1), tmp2)?;
+                self.move_location(
+                    Size::S64,
+                    Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
+                    Location::GPR(tmpg1),
+                )?;
+                self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp3))?;
+                self.assembler
+                    .emit_vblendvpd(tmp2, XMMOrMemory::XMM(tmp3), tmp1, tmp1)?;
+            }
+            _ => codegen_error!("singlepass canonicalize_nan unreachable"),
+        }
+
+        self.emit_relaxed_mov(sz, Location::SIMD(tmp1), output)?;
+
+        self.release_gpr(tmpg1);
+        self.release_simd(tmp3);
+        self.release_simd(tmp2);
+        self.release_simd(tmp1);
+        Ok(())
+    }
+
+    fn emit_illegal_op(&mut self, trap: TrapCode) -> Result<(), CompileError> {
+        // code below is kept as a reference on how to emit illegal op with trap info
+        // without an Undefined opcode with payload
+        /*
+        let offset = self.assembler.get_offset().0;
+        self.trap_table
+        .offset_to_code
+        .insert(offset, trap);
+        self.assembler.emit_ud2();
+        self.mark_instruction_address_end(offset);*/
+        let v = trap as u8;
+        // payload needs to be between 0-15
+        // this will emit an 40 0F B9 Cx opcode, with x the payload
+        let offset = self.assembler.get_offset().0;
+        self.assembler.emit_ud1_payload(v)?;
+        self.mark_instruction_address_end(offset);
+        Ok(())
+    }
+    fn get_label(&mut self) -> Label {
+        self.assembler.new_dynamic_label()
+    }
+    fn emit_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_label(label)
+    }
+    fn get_grp_for_call(&self) -> GPR {
+        GPR::RAX
+    }
+    fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_call_register(reg)
+    }
+    fn emit_call_label(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_call_label(label)
+    }
+    fn get_gpr_for_ret(&self) -> GPR {
+        GPR::RAX
+    }
+    fn get_simd_for_ret(&self) -> XMM {
+        XMM::XMM0
+    }
+
+    fn arch_requires_indirect_call_trampoline(&self) -> bool {
+        self.assembler.arch_requires_indirect_call_trampoline()
+    }
+
+    fn arch_emit_indirect_call_with_trampoline(
+        &mut self,
+        location: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler
+            .arch_emit_indirect_call_with_trampoline(location)
+    }
+
+    fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_bkpt()
+    }
+
+    fn emit_call_location(&mut self, location: Location) -> Result<(), CompileError> {
+        self.assembler.emit_call_location(location)
+    }
+
+    fn location_address(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_lea(size, source, dest)
+    }
+    // logic
+    fn location_and(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_and(size, source, dest)
+    }
+    fn location_xor(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_xor(size, source, dest)
+    }
+    fn location_or(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_or(size, source, dest)
+    }
+    fn location_test(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_test(size, source, dest)
+    }
+    // math
+    fn location_add(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_add(size, source, dest)
+    }
+    fn location_sub(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+        _flags: bool,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_sub(size, source, dest)
+    }
+    fn location_cmp(
+        &mut self,
+        size: Size,
+        source: Location,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.assembler.emit_cmp(size, source, dest)
+    }
+    // (un)conditionnal jmp
+    // (un)conditionnal jmp
+    fn jmp_unconditionnal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::None, label)
+    }
+    fn jmp_on_equal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::Equal, label)
+    }
+    fn jmp_on_different(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::NotEqual, label)
+    }
+    fn jmp_on_above(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::Above, label)
+    }
+    fn jmp_on_aboveequal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::AboveEqual, label)
+    }
+    fn jmp_on_belowequal(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::BelowEqual, label)
+    }
+    fn jmp_on_overflow(&mut self, label: Label) -> Result<(), CompileError> {
+        self.assembler.emit_jmp(Condition::Carry, label)
+    }
+
+    // jmp table
+    fn emit_jmp_to_jumptable(&mut self, label: Label, cond: Location) -> Result<(), CompileError> {
+        let tmp1 = self
+            .pick_temp_gpr()
+            .ok_or_else(|| CompileError::Codegen("singlepass can't pick a temp gpr".to_owned()))?;
+        self.reserve_gpr(tmp1);
+        let tmp2 = self
+            .pick_temp_gpr()
+            .ok_or_else(|| CompileError::Codegen("singlepass can't pick a temp gpr".to_owned()))?;
+        self.reserve_gpr(tmp2);
+
+        self.assembler.emit_lea_label(label, Location::GPR(tmp1))?;
+        self.move_location(Size::S32, cond, Location::GPR(tmp2))?;
+
+        let instr_size = self.assembler.get_jmp_instr_size();
+        self.assembler
+            .emit_imul_imm32_gpr64(instr_size as _, tmp2)?;
+        self.assembler
+            .emit_add(Size::S64, Location::GPR(tmp1), Location::GPR(tmp2))?;
+        self.assembler.emit_jmp_location(Location::GPR(tmp2))?;
+        self.release_gpr(tmp2);
+        self.release_gpr(tmp1);
+        Ok(())
+    }
+
+    fn align_for_loop(&mut self) -> Result<(), CompileError> {
+        // Pad with NOPs to the next 16-byte boundary.
+        // Here we don't use the dynasm `.align 16` attribute because it pads the alignment with single-byte nops
+        // which may lead to efficiency problems.
+        match self.assembler.get_offset().0 % 16 {
+            0 => {}
+            x => {
+                self.assembler.emit_nop_n(16 - x)?;
+            }
+        }
+        assert_eq!(self.assembler.get_offset().0 % 16, 0);
+        Ok(())
+    }
+
+    fn emit_ret(&mut self) -> Result<(), CompileError> {
+        self.assembler.emit_ret()
+    }
+
+    fn emit_push(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.assembler.emit_push(size, loc)
+    }
+    fn emit_pop(&mut self, size: Size, loc: Location) -> Result<(), CompileError> {
+        self.assembler.emit_pop(size, loc)
+    }
+
+    fn emit_memory_fence(&mut self) -> Result<(), CompileError> {
+        // nothing on x86_64
+        Ok(())
+    }
+
+    fn location_neg(
+        &mut self,
+        size_val: Size, // size of src
+        signed: bool,
+        source: Location,
+        size_op: Size,
+        dest: Location,
+    ) -> Result<(), CompileError> {
+        self.move_location_extend(size_val, signed, source, size_op, dest)?;
+        self.assembler.emit_neg(size_val, dest)
+    }
+
+    fn emit_imul_imm32(&mut self, size: Size, imm32: u32, gpr: GPR) -> Result<(), CompileError> {
+        match size {
+            Size::S64 => self.assembler.emit_imul_imm32_gpr64(imm32, gpr),
+            _ => {
+                codegen_error!("singlepass emit_imul_imm32 unreachable");
+            }
+        }
+    }
+
+    // relaxed binop based...
+    fn emit_relaxed_mov(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(AssemblerX64::emit_mov, sz, src, dst)
+    }
+    fn emit_relaxed_cmp(
+        &mut self,
+        sz: Size,
+        src: Location,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_binop(AssemblerX64::emit_cmp, sz, src, dst)
+    }
+    fn emit_relaxed_zero_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        if (sz_src == Size::S32 || sz_src == Size::S64) && sz_dst == Size::S64 {
+            self.emit_relaxed_binop(AssemblerX64::emit_mov, sz_src, src, dst)
+        } else {
+            self.emit_relaxed_zx_sx(AssemblerX64::emit_movzx, sz_src, src, sz_dst, dst)
+        }
+    }
+    fn emit_relaxed_sign_extension(
+        &mut self,
+        sz_src: Size,
+        src: Location,
+        sz_dst: Size,
+        dst: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_zx_sx(AssemblerX64::emit_movsx, sz_src, src, sz_dst, dst)
+    }
+
+    fn emit_binop_add32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_add, loc_a, loc_b, ret)
+    }
+    fn emit_binop_sub32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_sub, loc_a, loc_b, ret)
+    }
+    fn emit_binop_mul32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_imul, loc_a, loc_b, ret)
+    }
+    fn emit_binop_udiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler
+            .emit_xor(Size::S32, Location::GPR(GPR::RDX), Location::GPR(GPR::RDX))?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_div,
+            Size::S32,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_sdiv32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler.emit_cdq()?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_idiv,
+            Size::S32,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(GPR::RAX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_urem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler
+            .emit_xor(Size::S32, Location::GPR(GPR::RDX), Location::GPR(GPR::RDX))?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_div,
+            Size::S32,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(GPR::RDX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_srem32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        let normal_path = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_relaxed_cmp(Size::S32, Location::Imm32(0x80000000), loc_a)?;
+        self.assembler.emit_jmp(Condition::NotEqual, normal_path)?;
+        self.emit_relaxed_cmp(Size::S32, Location::Imm32(0xffffffff), loc_b)?;
+        self.assembler.emit_jmp(Condition::NotEqual, normal_path)?;
+        self.move_location(Size::S32, Location::Imm32(0), ret)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        self.emit_label(normal_path)?;
+        self.assembler
+            .emit_mov(Size::S32, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler.emit_cdq()?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_idiv,
+            Size::S32,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S32, Location::GPR(GPR::RDX), ret)?;
+
+        self.emit_label(end)?;
+        Ok(offset)
+    }
+    fn emit_binop_and32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_and, loc_a, loc_b, ret)
+    }
+    fn emit_binop_or32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_or, loc_a, loc_b, ret)
+    }
+    fn emit_binop_xor32(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i32(AssemblerX64::emit_xor, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::GreaterEqual, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Greater, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::LessEqual, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Less, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::AboveEqual, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Above, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::BelowEqual, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Below, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::NotEqual, loc_a, loc_b, ret)
+    }
+    fn i32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i32_dynamic_b(Condition::Equal, loc_a, loc_b, ret)
+    }
+    fn i32_clz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let src = match loc {
+            Location::Imm32(_) | Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+                tmp
+            }
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i32_clz unreachable");
+            }
+        };
+        let dst = match ret {
+            Location::Memory(_, _) => self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?,
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i32_clz unreachable");
+            }
+        };
+
+        if self.assembler.arch_has_xzcnt() {
+            self.assembler
+                .arch_emit_lzcnt(Size::S32, Location::GPR(src), Location::GPR(dst))?;
+        } else {
+            let zero_path = self.assembler.get_label();
+            let end = self.assembler.get_label();
+
+            self.assembler.emit_test_gpr_64(src)?;
+            self.assembler.emit_jmp(Condition::Equal, zero_path)?;
+            self.assembler
+                .emit_bsr(Size::S32, Location::GPR(src), Location::GPR(dst))?;
+            self.assembler
+                .emit_xor(Size::S32, Location::Imm32(31), Location::GPR(dst))?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+            self.emit_label(zero_path)?;
+            self.move_location(Size::S32, Location::Imm32(32), Location::GPR(dst))?;
+            self.emit_label(end)?;
+        }
+        match loc {
+            Location::Imm32(_) | Location::Memory(_, _) => {
+                self.release_gpr(src);
+            }
+            _ => {}
+        };
+        if let Location::Memory(_, _) = ret {
+            self.move_location(Size::S32, Location::GPR(dst), ret)?;
+            self.release_gpr(dst);
+        };
+        Ok(())
+    }
+    fn i32_ctz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let src = match loc {
+            Location::Imm32(_) | Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+                tmp
+            }
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i32_ctz unreachable");
+            }
+        };
+        let dst = match ret {
+            Location::Memory(_, _) => self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?,
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i32_ctz unreachable");
+            }
+        };
+
+        if self.assembler.arch_has_xzcnt() {
+            self.assembler
+                .arch_emit_tzcnt(Size::S32, Location::GPR(src), Location::GPR(dst))?;
+        } else {
+            let zero_path = self.assembler.get_label();
+            let end = self.assembler.get_label();
+
+            self.assembler.emit_test_gpr_64(src)?;
+            self.assembler.emit_jmp(Condition::Equal, zero_path)?;
+            self.assembler
+                .emit_bsf(Size::S32, Location::GPR(src), Location::GPR(dst))?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+            self.emit_label(zero_path)?;
+            self.move_location(Size::S32, Location::Imm32(32), Location::GPR(dst))?;
+            self.emit_label(end)?;
+        }
+
+        match loc {
+            Location::Imm32(_) | Location::Memory(_, _) => {
+                self.release_gpr(src);
+            }
+            _ => {}
+        };
+        if let Location::Memory(_, _) = ret {
+            self.move_location(Size::S32, Location::GPR(dst), ret)?;
+            self.release_gpr(dst);
+        };
+        Ok(())
+    }
+    fn i32_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        match loc {
+            Location::Imm32(_) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+                if let Location::Memory(_, _) = ret {
+                    let out_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler.emit_popcnt(
+                        Size::S32,
+                        Location::GPR(tmp),
+                        Location::GPR(out_tmp),
+                    )?;
+                    self.move_location(Size::S32, Location::GPR(out_tmp), ret)?;
+                    self.release_gpr(out_tmp);
+                } else {
+                    self.assembler
+                        .emit_popcnt(Size::S32, Location::GPR(tmp), ret)?;
+                }
+                self.release_gpr(tmp);
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                if let Location::Memory(_, _) = ret {
+                    let out_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_popcnt(Size::S32, loc, Location::GPR(out_tmp))?;
+                    self.move_location(Size::S32, Location::GPR(out_tmp), ret)?;
+                    self.release_gpr(out_tmp);
+                } else {
+                    self.assembler.emit_popcnt(Size::S32, loc, ret)?;
+                }
+            }
+            _ => {
+                codegen_error!("singlepass i32_popcnt unreachable");
+            }
+        }
+        Ok(())
+    }
+    fn i32_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i32(AssemblerX64::emit_shl, loc_a, loc_b, ret)
+    }
+    fn i32_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i32(AssemblerX64::emit_shr, loc_a, loc_b, ret)
+    }
+    fn i32_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i32(AssemblerX64::emit_sar, loc_a, loc_b, ret)
+    }
+    fn i32_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i32(AssemblerX64::emit_rol, loc_a, loc_b, ret)
+    }
+    fn i32_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i32(AssemblerX64::emit_ror, loc_a, loc_b, ret)
+    }
+    fn i32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    Location::Memory(addr, 0),
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movzx,
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movsx,
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movzx,
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movsx,
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_mov(Size::S32, Location::Memory(addr, 0), ret),
+        )
+    }
+    fn i32_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zero_extension(
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zero_extension(
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S32,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i32_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i32_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S8,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i32_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S16,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    // x86_64 have a strong memory model, so coherency between all threads (core) is garantied
+    // and aligned move is guarantied to be atomic, too or from memory
+    // so store/load an atomic is a simple mov on x86_64
+    fn i32_atomic_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i32_atomic_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S8,
+                    value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i32_atomic_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S16,
+                    value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    // i32 atomic Add with i32
+    fn i32_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S32, loc, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Add with u8
+    fn i32_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location_extend(Size::S8, false, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Add with u16
+    fn i32_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location_extend(Size::S16, false, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Sub with i32
+    fn i32_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S32, false, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Sub with u8
+    fn i32_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S8, false, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Sub with u16
+    fn i32_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S16, false, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic And with i32
+    fn i32_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic And with u8
+    fn i32_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic And with u16
+    fn i32_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Or with i32
+    fn i32_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Or with u8
+    fn i32_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Or with u16
+    fn i32_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_or(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Xor with i32
+    fn i32_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Xor with u8
+    fn i32_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Xor with u16
+    fn i32_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S32,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_xor(Size::S32, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i32 atomic Exchange with i32
+    fn i32_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S32, loc, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S32, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Exchange with u8
+    fn i32_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_movzx(Size::S8, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S8, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Exchange with u16
+    fn i32_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_movzx(Size::S16, loc, Size::S32, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S16, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S32, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i32 atomic Exchange with i32
+    fn i32_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S32, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S32, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_mov(Size::S32, Location::GPR(compare), ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+    // i32 atomic Exchange with u8
+    fn i32_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S32, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S32, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_movzx(Size::S8, Location::GPR(compare), Size::S32, ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+    // i32 atomic Exchange with u16
+    fn i32_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S32, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S32, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_movzx(Size::S16, Location::GPR(compare), Size::S32, ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+
+    fn emit_call_with_reloc(
+        &mut self,
+        _calling_convention: CallingConvention,
+        reloc_target: RelocationTarget,
+    ) -> Result<Vec<Relocation>, CompileError> {
+        let mut relocations = vec![];
+        let next = self.get_label();
+        let reloc_at = self.assembler.get_offset().0 + 1; // skip E8
+        self.assembler.emit_call_label(next)?;
+        self.emit_label(next)?;
+        relocations.push(Relocation {
+            kind: RelocationKind::X86CallPCRel4,
+            reloc_target,
+            offset: reloc_at as u32,
+            addend: -4,
+        });
+        Ok(relocations)
+    }
+
+    fn emit_binop_add64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_add, loc_a, loc_b, ret)
+    }
+    fn emit_binop_sub64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_sub, loc_a, loc_b, ret)
+    }
+    fn emit_binop_mul64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_imul, loc_a, loc_b, ret)
+    }
+    fn emit_binop_udiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler
+            .emit_xor(Size::S64, Location::GPR(GPR::RDX), Location::GPR(GPR::RDX))?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_div,
+            Size::S64,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_sdiv64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler.emit_cqo()?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_idiv,
+            Size::S64,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::RAX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_urem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        self.assembler
+            .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler
+            .emit_xor(Size::S64, Location::GPR(GPR::RDX), Location::GPR(GPR::RDX))?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_div,
+            Size::S64,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::RDX), ret)?;
+        Ok(offset)
+    }
+    fn emit_binop_srem64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+        integer_division_by_zero: Label,
+        _integer_overflow: Label,
+    ) -> Result<usize, CompileError> {
+        // We assume that RAX and RDX are temporary registers here.
+        let normal_path = self.assembler.get_label();
+        let end = self.assembler.get_label();
+
+        self.emit_relaxed_cmp(Size::S64, Location::Imm64(0x8000000000000000u64), loc_a)?;
+        self.assembler.emit_jmp(Condition::NotEqual, normal_path)?;
+        self.emit_relaxed_cmp(Size::S64, Location::Imm64(0xffffffffffffffffu64), loc_b)?;
+        self.assembler.emit_jmp(Condition::NotEqual, normal_path)?;
+        self.move_location(Size::S64, Location::Imm64(0), ret)?;
+        self.assembler.emit_jmp(Condition::None, end)?;
+
+        self.emit_label(normal_path)?;
+        self.assembler
+            .emit_mov(Size::S64, loc_a, Location::GPR(GPR::RAX))?;
+        self.assembler.emit_cqo()?;
+        let offset = self.emit_relaxed_xdiv(
+            AssemblerX64::emit_idiv,
+            Size::S64,
+            loc_b,
+            integer_division_by_zero,
+        )?;
+        self.assembler
+            .emit_mov(Size::S64, Location::GPR(GPR::RDX), ret)?;
+
+        self.emit_label(end)?;
+        Ok(offset)
+    }
+    fn emit_binop_and64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_and, loc_a, loc_b, ret)
+    }
+    fn emit_binop_or64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_or, loc_a, loc_b, ret)
+    }
+    fn emit_binop_xor64(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_binop_i64(AssemblerX64::emit_xor, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ge_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::GreaterEqual, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Greater, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::LessEqual, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_s(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Less, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ge_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::AboveEqual, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_gt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Above, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_le_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::BelowEqual, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_lt_u(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Below, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::NotEqual, loc_a, loc_b, ret)
+    }
+    fn i64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_cmpop_i64_dynamic_b(Condition::Equal, loc_a, loc_b, ret)
+    }
+    fn i64_clz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let src = match loc {
+            Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+                tmp
+            }
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i64_clz unreachable");
+            }
+        };
+        let dst = match ret {
+            Location::Memory(_, _) => self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?,
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i64_clz unreachable");
+            }
+        };
+
+        if self.assembler.arch_has_xzcnt() {
+            self.assembler
+                .arch_emit_lzcnt(Size::S64, Location::GPR(src), Location::GPR(dst))?;
+        } else {
+            let zero_path = self.assembler.get_label();
+            let end = self.assembler.get_label();
+
+            self.assembler.emit_test_gpr_64(src)?;
+            self.assembler.emit_jmp(Condition::Equal, zero_path)?;
+            self.assembler
+                .emit_bsr(Size::S64, Location::GPR(src), Location::GPR(dst))?;
+            self.assembler
+                .emit_xor(Size::S64, Location::Imm32(63), Location::GPR(dst))?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+            self.emit_label(zero_path)?;
+            self.move_location(Size::S64, Location::Imm32(64), Location::GPR(dst))?;
+            self.emit_label(end)?;
+        }
+        match loc {
+            Location::Imm64(_) | Location::Memory(_, _) => {
+                self.release_gpr(src);
+            }
+            _ => {}
+        };
+        if let Location::Memory(_, _) = ret {
+            self.move_location(Size::S64, Location::GPR(dst), ret)?;
+            self.release_gpr(dst);
+        };
+        Ok(())
+    }
+    fn i64_ctz(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let src = match loc {
+            Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+                tmp
+            }
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i64_ctz unreachable");
+            }
+        };
+        let dst = match ret {
+            Location::Memory(_, _) => self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?,
+            Location::GPR(reg) => reg,
+            _ => {
+                codegen_error!("singlepass i64_ctz unreachable");
+            }
+        };
+
+        if self.assembler.arch_has_xzcnt() {
+            self.assembler
+                .arch_emit_tzcnt(Size::S64, Location::GPR(src), Location::GPR(dst))?;
+        } else {
+            let zero_path = self.assembler.get_label();
+            let end = self.assembler.get_label();
+
+            self.assembler.emit_test_gpr_64(src)?;
+            self.assembler.emit_jmp(Condition::Equal, zero_path)?;
+            self.assembler
+                .emit_bsf(Size::S64, Location::GPR(src), Location::GPR(dst))?;
+            self.assembler.emit_jmp(Condition::None, end)?;
+            self.emit_label(zero_path)?;
+            self.move_location(Size::S64, Location::Imm64(64), Location::GPR(dst))?;
+            self.emit_label(end)?;
+        }
+
+        match loc {
+            Location::Imm64(_) | Location::Imm32(_) | Location::Memory(_, _) => {
+                self.release_gpr(src);
+            }
+            _ => {}
+        };
+        if let Location::Memory(_, _) = ret {
+            self.move_location(Size::S64, Location::GPR(dst), ret)?;
+            self.release_gpr(dst);
+        };
+        Ok(())
+    }
+    fn i64_popcnt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        match loc {
+            Location::Imm64(_) | Location::Imm32(_) => {
+                let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                    CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                })?;
+                self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+                if let Location::Memory(_, _) = ret {
+                    let out_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler.emit_popcnt(
+                        Size::S64,
+                        Location::GPR(tmp),
+                        Location::GPR(out_tmp),
+                    )?;
+                    self.move_location(Size::S64, Location::GPR(out_tmp), ret)?;
+                    self.release_gpr(out_tmp);
+                } else {
+                    self.assembler
+                        .emit_popcnt(Size::S64, Location::GPR(tmp), ret)?;
+                }
+                self.release_gpr(tmp);
+            }
+            Location::Memory(_, _) | Location::GPR(_) => {
+                if let Location::Memory(_, _) = ret {
+                    let out_tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                        CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+                    })?;
+                    self.assembler
+                        .emit_popcnt(Size::S64, loc, Location::GPR(out_tmp))?;
+                    self.move_location(Size::S64, Location::GPR(out_tmp), ret)?;
+                    self.release_gpr(out_tmp);
+                } else {
+                    self.assembler.emit_popcnt(Size::S64, loc, ret)?;
+                }
+            }
+            _ => {
+                codegen_error!("singlepass i64_popcnt unreachable");
+            }
+        }
+        Ok(())
+    }
+    fn i64_shl(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i64(AssemblerX64::emit_shl, loc_a, loc_b, ret)
+    }
+    fn i64_shr(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i64(AssemblerX64::emit_shr, loc_a, loc_b, ret)
+    }
+    fn i64_sar(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i64(AssemblerX64::emit_sar, loc_a, loc_b, ret)
+    }
+    fn i64_rol(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i64(AssemblerX64::emit_rol, loc_a, loc_b, ret)
+    }
+    fn i64_ror(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_shift_i64(AssemblerX64::emit_ror, loc_a, loc_b, ret)
+    }
+    fn i64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S64,
+                    Location::Memory(addr, 0),
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movzx,
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_8s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movsx,
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movzx,
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_16s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movsx,
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                match ret {
+                    Location::GPR(_) => {}
+                    Location::Memory(base, offset) => {
+                        this.assembler.emit_mov(
+                            Size::S32,
+                            Location::Imm32(0),
+                            Location::Memory(base, offset + 4),
+                        )?; // clear upper bits
+                    }
+                    _ => {
+                        codegen_error!("singlepass i64_load_32u unreacahble");
+                    }
+                }
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    Location::Memory(addr, 0),
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_load_32s(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zx_sx(
+                    AssemblerX64::emit_movsx,
+                    Size::S32,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_atomic_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_mov(Size::S64, Location::Memory(addr, 0), ret),
+        )
+    }
+    fn i64_atomic_load_8u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zero_extension(
+                    Size::S8,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_atomic_load_16u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_zero_extension(
+                    Size::S16,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_atomic_load_32u(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                match ret {
+                    Location::GPR(_) => {}
+                    Location::Memory(base, offset) => {
+                        this.move_location(
+                            Size::S32,
+                            Location::Imm32(0),
+                            Location::Memory(base, offset + 4),
+                        )?; // clear upper bits
+                    }
+                    _ => {
+                        codegen_error!("singlepass i64_atomic_load_32u unreachable");
+                    }
+                }
+                this.emit_relaxed_zero_extension(
+                    Size::S32,
+                    Location::Memory(addr, 0),
+                    Size::S64,
+                    ret,
+                )
+            },
+        )
+    }
+    fn i64_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S64,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i64_save_8(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S8,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i64_save_16(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S16,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i64_save_32(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    target_value,
+                    Location::Memory(addr, 0),
+                )
+            },
+        )
+    }
+    fn i64_atomic_save(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_xchg(Size::S64, value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_save_8(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_xchg(Size::S8, value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_save_16(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_xchg(Size::S16, value, Location::Memory(addr, 0)),
+        )
+    }
+    fn i64_atomic_save_32(
+        &mut self,
+        value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            target_addr,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| this.emit_relaxed_atomic_xchg(Size::S32, value, Location::Memory(addr, 0)),
+        )
+    }
+    // i64 atomic Add with i64
+    fn i64_atomic_add(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S64, loc, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S64,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Add with u8
+    fn i64_atomic_add_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location_extend(Size::S8, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Add with u16
+    fn i64_atomic_add_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location_extend(Size::S16, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Add with u32
+    fn i64_atomic_add_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location_extend(Size::S32, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Sub with i64
+    fn i64_atomic_sub(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S64, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S64,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Sub with u8
+    fn i64_atomic_sub_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S8, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Sub with u16
+    fn i64_atomic_sub_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S16, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Sub with u32
+    fn i64_atomic_sub_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.location_neg(Size::S32, false, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_xadd(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic And with i64
+    fn i64_atomic_and(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            8,
+            Size::S64,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i64 atomic And with u8
+    fn i64_atomic_and_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i64 atomic And with u16
+    fn i64_atomic_and_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i64 atomic And with u32
+    fn i64_atomic_and_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.assembler
+                    .emit_and(Size::S64, Location::GPR(src), Location::GPR(dst))
+            },
+        )
+    }
+    // i64 atomic Or with i64
+    fn i64_atomic_or(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            8,
+            Size::S64,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_or(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic Or with u8
+    fn i64_atomic_or_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_or(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic Or with u16
+    fn i64_atomic_or_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_or(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic Or with u32
+    fn i64_atomic_or_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_or(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic xor with i64
+    fn i64_atomic_xor(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            8,
+            Size::S64,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_xor(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic xor with u8
+    fn i64_atomic_xor_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            1,
+            Size::S8,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_xor(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic xor with u16
+    fn i64_atomic_xor_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            2,
+            Size::S16,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_xor(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic xor with u32
+    fn i64_atomic_xor_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.emit_compare_and_swap(
+            loc,
+            target,
+            ret,
+            memarg,
+            4,
+            Size::S32,
+            Size::S64,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, src, dst| {
+                this.location_xor(Size::S64, Location::GPR(src), Location::GPR(dst), false)
+            },
+        )
+    }
+    // i64 atomic Exchange with i64
+    fn i64_atomic_xchg(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S64, loc, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S64, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Exchange with u8
+    fn i64_atomic_xchg_8u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_movzx(Size::S8, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S8, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Exchange with u16
+    fn i64_atomic_xchg_16u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_movzx(Size::S16, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S16, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Exchange with u32
+    fn i64_atomic_xchg_32u(
+        &mut self,
+        loc: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let value = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.assembler
+            .emit_movzx(Size::S32, loc, Size::S64, Location::GPR(value))?;
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler
+                    .emit_xchg(Size::S32, Location::GPR(value), Location::Memory(addr, 0))
+            },
+        )?;
+        self.move_location(Size::S64, Location::GPR(value), ret)?;
+        self.release_gpr(value);
+        Ok(())
+    }
+    // i64 atomic Exchange with i64
+    fn i64_atomic_cmpxchg(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S64, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S64, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S64,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_mov(Size::S64, Location::GPR(compare), ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+    // i64 atomic Exchange with u8
+    fn i64_atomic_cmpxchg_8u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S64, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S64, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            1,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S8,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_movzx(Size::S8, Location::GPR(compare), Size::S64, ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+    // i64 atomic Exchange with u16
+    fn i64_atomic_cmpxchg_16u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S64, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S64, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            2,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S16,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_movzx(Size::S16, Location::GPR(compare), Size::S64, ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+    // i64 atomic Exchange with u32
+    fn i64_atomic_cmpxchg_32u(
+        &mut self,
+        new: Location,
+        cmp: Location,
+        target: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let compare = self.reserve_unused_temp_gpr(GPR::RAX);
+        let value = if cmp == Location::GPR(GPR::R14) {
+            if new == Location::GPR(GPR::R13) {
+                GPR::R12
+            } else {
+                GPR::R13
+            }
+        } else {
+            GPR::R14
+        };
+        self.assembler.emit_push(Size::S64, Location::GPR(value))?;
+        self.assembler
+            .emit_mov(Size::S64, cmp, Location::GPR(compare))?;
+        self.assembler
+            .emit_mov(Size::S64, new, Location::GPR(value))?;
+
+        self.memory_op(
+            target,
+            memarg,
+            true,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.assembler.emit_lock_cmpxchg(
+                    Size::S32,
+                    Location::GPR(value),
+                    Location::Memory(addr, 0),
+                )?;
+                this.assembler
+                    .emit_mov(Size::S32, Location::GPR(compare), ret)
+            },
+        )?;
+        self.assembler.emit_pop(Size::S64, Location::GPR(value))?;
+        self.release_gpr(compare);
+        Ok(())
+    }
+
+    fn f32_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S32,
+                    Location::Memory(addr, 0),
+                    ret,
+                )
+            },
+        )
+    }
+    fn f32_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            4,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_binop(
+                        AssemblerX64::emit_mov,
+                        Size::S32,
+                        target_value,
+                        Location::Memory(addr, 0),
+                    )
+                } else {
+                    this.canonicalize_nan(Size::S32, target_value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+    fn f64_load(
+        &mut self,
+        addr: Location,
+        memarg: &MemArg,
+        ret: Location,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        self.memory_op(
+            addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                this.emit_relaxed_binop(
+                    AssemblerX64::emit_mov,
+                    Size::S64,
+                    Location::Memory(addr, 0),
+                    ret,
+                )
+            },
+        )
+    }
+    fn f64_save(
+        &mut self,
+        target_value: Location,
+        memarg: &MemArg,
+        target_addr: Location,
+        canonicalize: bool,
+        need_check: bool,
+        imported_memories: bool,
+        offset: i32,
+        heap_access_oob: Label,
+        unaligned_atomic: Label,
+    ) -> Result<(), CompileError> {
+        let canonicalize = canonicalize && self.arch_supports_canonicalize_nan();
+        self.memory_op(
+            target_addr,
+            memarg,
+            false,
+            8,
+            need_check,
+            imported_memories,
+            offset,
+            heap_access_oob,
+            unaligned_atomic,
+            |this, addr| {
+                if !canonicalize {
+                    this.emit_relaxed_binop(
+                        AssemblerX64::emit_mov,
+                        Size::S64,
+                        target_value,
+                        Location::Memory(addr, 0),
+                    )
+                } else {
+                    this.canonicalize_nan(Size::S64, target_value, Location::Memory(addr, 0))
+                }
+            },
+        )
+    }
+
+    fn convert_f64_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        if self.assembler.arch_has_fconverti() {
+            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler.arch_emit_f64_convert_si64(tmp_in, tmp_out)?;
+            } else {
+                self.assembler.arch_emit_f64_convert_ui64(tmp_in, tmp_out)?;
+            }
+            self.emit_relaxed_mov(Size::S64, Location::SIMD(tmp_out), ret)?;
+        } else if signed {
+            self.assembler
+                .emit_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.move_location(Size::S64, Location::SIMD(tmp_out), ret)?;
+        } else {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let do_convert = self.assembler.get_label();
+            let end_convert = self.assembler.get_label();
+
+            self.assembler
+                .emit_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            self.assembler.emit_test_gpr_64(tmp_in)?;
+            self.assembler.emit_jmp(Condition::Signed, do_convert)?;
+            self.assembler
+                .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.assembler.emit_jmp(Condition::None, end_convert)?;
+            self.emit_label(do_convert)?;
+            self.move_location(Size::S64, Location::GPR(tmp_in), Location::GPR(tmp))?;
+            self.assembler
+                .emit_and(Size::S64, Location::Imm32(1), Location::GPR(tmp))?;
+            self.assembler
+                .emit_shr(Size::S64, Location::Imm8(1), Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_or(Size::S64, Location::GPR(tmp), Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.assembler
+                .emit_vaddsd(tmp_out, XMMOrMemory::XMM(tmp_out), tmp_out)?;
+            self.emit_label(end_convert)?;
+            self.move_location(Size::S64, Location::SIMD(tmp_out), ret)?;
+
+            self.release_gpr(tmp);
+        }
+        self.release_gpr(tmp_in);
+        self.release_simd(tmp_out);
+        Ok(())
+    }
+    fn convert_f64_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        if self.assembler.arch_has_fconverti() {
+            self.emit_relaxed_mov(Size::S32, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler.arch_emit_f64_convert_si32(tmp_in, tmp_out)?;
+            } else {
+                self.assembler.arch_emit_f64_convert_ui32(tmp_in, tmp_out)?;
+            }
+            self.emit_relaxed_mov(Size::S64, Location::SIMD(tmp_out), ret)?;
+        } else {
+            self.assembler
+                .emit_mov(Size::S32, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler
+                    .emit_vcvtsi2sd_32(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            } else {
+                self.assembler
+                    .emit_vcvtsi2sd_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            }
+            self.move_location(Size::S64, Location::SIMD(tmp_out), ret)?;
+        }
+        self.release_gpr(tmp_in);
+        self.release_simd(tmp_out);
+        Ok(())
+    }
+    fn convert_f32_i64(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        if self.assembler.arch_has_fconverti() {
+            self.emit_relaxed_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler.arch_emit_f32_convert_si64(tmp_in, tmp_out)?;
+            } else {
+                self.assembler.arch_emit_f32_convert_ui64(tmp_in, tmp_out)?;
+            }
+            self.emit_relaxed_mov(Size::S32, Location::SIMD(tmp_out), ret)?;
+        } else if signed {
+            self.assembler
+                .emit_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.move_location(Size::S32, Location::SIMD(tmp_out), ret)?;
+        } else {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let do_convert = self.assembler.get_label();
+            let end_convert = self.assembler.get_label();
+
+            self.assembler
+                .emit_mov(Size::S64, loc, Location::GPR(tmp_in))?;
+            self.assembler.emit_test_gpr_64(tmp_in)?;
+            self.assembler.emit_jmp(Condition::Signed, do_convert)?;
+            self.assembler
+                .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.assembler.emit_jmp(Condition::None, end_convert)?;
+            self.emit_label(do_convert)?;
+            self.move_location(Size::S64, Location::GPR(tmp_in), Location::GPR(tmp))?;
+            self.assembler
+                .emit_and(Size::S64, Location::Imm32(1), Location::GPR(tmp))?;
+            self.assembler
+                .emit_shr(Size::S64, Location::Imm8(1), Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_or(Size::S64, Location::GPR(tmp), Location::GPR(tmp_in))?;
+            self.assembler
+                .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            self.assembler
+                .emit_vaddss(tmp_out, XMMOrMemory::XMM(tmp_out), tmp_out)?;
+            self.emit_label(end_convert)?;
+            self.move_location(Size::S32, Location::SIMD(tmp_out), ret)?;
+
+            self.release_gpr(tmp);
+        }
+        self.release_gpr(tmp_in);
+        self.release_simd(tmp_out);
+        Ok(())
+    }
+    fn convert_f32_i32(
+        &mut self,
+        loc: Location,
+        signed: bool,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        let tmp_out = self.acquire_temp_simd().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+        })?;
+        let tmp_in = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        if self.assembler.arch_has_fconverti() {
+            self.emit_relaxed_mov(Size::S32, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler.arch_emit_f32_convert_si32(tmp_in, tmp_out)?;
+            } else {
+                self.assembler.arch_emit_f32_convert_ui32(tmp_in, tmp_out)?;
+            }
+            self.emit_relaxed_mov(Size::S32, Location::SIMD(tmp_out), ret)?;
+        } else {
+            self.assembler
+                .emit_mov(Size::S32, loc, Location::GPR(tmp_in))?;
+            if signed {
+                self.assembler
+                    .emit_vcvtsi2ss_32(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            } else {
+                self.assembler
+                    .emit_vcvtsi2ss_64(tmp_out, GPROrMemory::GPR(tmp_in), tmp_out)?;
+            }
+            self.move_location(Size::S32, Location::SIMD(tmp_out), ret)?;
+        }
+        self.release_gpr(tmp_in);
+        self.release_simd(tmp_out);
+        Ok(())
+    }
+    fn convert_i64_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        match (signed, sat) {
+            (false, true) => self.convert_i64_f64_u_s(loc, ret),
+            (false, false) => self.convert_i64_f64_u_u(loc, ret),
+            (true, true) => self.convert_i64_f64_s_s(loc, ret),
+            (true, false) => self.convert_i64_f64_s_u(loc, ret),
+        }
+    }
+    fn convert_i32_f64(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        match (signed, sat) {
+            (false, true) => self.convert_i32_f64_u_s(loc, ret),
+            (false, false) => self.convert_i32_f64_u_u(loc, ret),
+            (true, true) => self.convert_i32_f64_s_s(loc, ret),
+            (true, false) => self.convert_i32_f64_s_u(loc, ret),
+        }
+    }
+    fn convert_i64_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        match (signed, sat) {
+            (false, true) => self.convert_i64_f32_u_s(loc, ret),
+            (false, false) => self.convert_i64_f32_u_u(loc, ret),
+            (true, true) => self.convert_i64_f32_s_s(loc, ret),
+            (true, false) => self.convert_i64_f32_s_u(loc, ret),
+        }
+    }
+    fn convert_i32_f32(
+        &mut self,
+        loc: Location,
+        ret: Location,
+        signed: bool,
+        sat: bool,
+    ) -> Result<(), CompileError> {
+        match (signed, sat) {
+            (false, true) => self.convert_i32_f32_u_s(loc, ret),
+            (false, false) => self.convert_i32_f32_u_u(loc, ret),
+            (true, true) => self.convert_i32_f32_s_s(loc, ret),
+            (true, false) => self.convert_i32_f32_s_u(loc, ret),
+        }
+    }
+    fn convert_f64_f32(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcvtss2sd, loc, loc, ret)
+    }
+    fn convert_f32_f64(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcvtsd2ss, loc, loc, ret)
+    }
+    fn f64_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_fneg() {
+            let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S64, loc, Location::SIMD(tmp))?;
+            self.assembler.arch_emit_f64_neg(tmp, tmp)?;
+            self.emit_relaxed_mov(Size::S64, Location::SIMD(tmp), ret)?;
+            self.release_simd(tmp);
+        } else {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+            self.assembler.emit_btc_gpr_imm8_64(63, tmp)?;
+            self.move_location(Size::S64, Location::GPR(tmp), ret)?;
+            self.release_gpr(tmp);
+        }
+        Ok(())
+    }
+    fn f64_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        let c = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.move_location(Size::S64, loc, Location::GPR(tmp))?;
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x7fffffffffffffffu64),
+            Location::GPR(c),
+        )?;
+        self.assembler
+            .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp))?;
+        self.move_location(Size::S64, Location::GPR(tmp), ret)?;
+
+        self.release_gpr(c);
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn emit_i64_copysign(&mut self, tmp1: GPR, tmp2: GPR) -> Result<(), CompileError> {
+        let c = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x7fffffffffffffffu64),
+            Location::GPR(c),
+        )?;
+        self.assembler
+            .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp1))?;
+
+        self.move_location(
+            Size::S64,
+            Location::Imm64(0x8000000000000000u64),
+            Location::GPR(c),
+        )?;
+        self.assembler
+            .emit_and(Size::S64, Location::GPR(c), Location::GPR(tmp2))?;
+
+        self.assembler
+            .emit_or(Size::S64, Location::GPR(tmp2), Location::GPR(tmp1))?;
+
+        self.release_gpr(c);
+        Ok(())
+    }
+    fn f64_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vsqrtsd, loc, loc, ret)
+    }
+    fn f64_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundsd_trunc, loc, loc, ret)
+    }
+    fn f64_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundsd_ceil, loc, loc, ret)
+    }
+    fn f64_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundsd_floor, loc, loc, ret)
+    }
+    fn f64_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundsd_nearest, loc, loc, ret)
+    }
+    fn f64_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpgesd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpgtsd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmplesd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpltsd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpneqsd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpeqsd, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f64_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if !self.arch_supports_canonicalize_nan() {
+            self.emit_relaxed_avx(AssemblerX64::emit_vminsd, loc_a, loc_b, ret)
+        } else {
+            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let src1 = match loc_a {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                _ => {
+                    codegen_error!("singlepass f64_min unreachable");
+                }
+            };
+            let src2 = match loc_b {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                _ => {
+                    codegen_error!("singlepass f64_min unreachable");
+                }
+            };
+
+            let tmp_xmm1 = XMM::XMM8;
+            let tmp_xmm2 = XMM::XMM9;
+            let tmp_xmm3 = XMM::XMM10;
+
+            self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
+            self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
+            self.assembler
+                .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+            self.assembler
+                .emit_vminsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+            let label1 = self.assembler.get_label();
+            let label2 = self.assembler.get_label();
+            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+            self.assembler
+                .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+            self.assembler.emit_jmp(Condition::None, label2)?;
+            self.emit_label(label1)?;
+            // load float -0.0
+            self.move_location(
+                Size::S64,
+                Location::Imm64(0x8000_0000_0000_0000), // Negative zero
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
+            self.emit_label(label2)?;
+            self.assembler
+                .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+            self.assembler.emit_vblendvpd(
+                tmp_xmm3,
+                XMMOrMemory::XMM(tmp_xmm2),
+                tmp_xmm1,
+                tmp_xmm1,
+            )?;
+            self.assembler
+                .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
+            // load float canonical nan
+            self.move_location(
+                Size::S64,
+                Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+            self.assembler
+                .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+            match ret {
+                Location::SIMD(x) => {
+                    self.assembler
+                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+                }
+                Location::Memory(_, _) | Location::GPR(_) => {
+                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+                }
+                _ => {
+                    codegen_error!("singlepass f64_min unreachable");
+                }
+            }
+
+            self.release_gpr(tmpg2);
+            self.release_gpr(tmpg1);
+            self.release_simd(tmp2);
+            self.release_simd(tmp1);
+            Ok(())
+        }
+    }
+    fn f64_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if !self.arch_supports_canonicalize_nan() {
+            self.emit_relaxed_avx(AssemblerX64::emit_vmaxsd, loc_a, loc_b, ret)
+        } else {
+            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let src1 = match loc_a {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                _ => {
+                    codegen_error!("singlepass f64_max unreachable");
+                }
+            };
+            let src2 = match loc_b {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                _ => {
+                    codegen_error!("singlepass f64_max unreachable");
+                }
+            };
+
+            let tmp_xmm1 = XMM::XMM8;
+            let tmp_xmm2 = XMM::XMM9;
+            let tmp_xmm3 = XMM::XMM10;
+
+            self.move_location(Size::S64, Location::SIMD(src1), Location::GPR(tmpg1))?;
+            self.move_location(Size::S64, Location::SIMD(src2), Location::GPR(tmpg2))?;
+            self.assembler
+                .emit_cmp(Size::S64, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+            self.assembler
+                .emit_vmaxsd(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+            let label1 = self.assembler.get_label();
+            let label2 = self.assembler.get_label();
+            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+            self.assembler
+                .emit_vmovapd(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+            self.assembler.emit_jmp(Condition::None, label2)?;
+            self.emit_label(label1)?;
+            self.assembler
+                .emit_vxorpd(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
+            self.emit_label(label2)?;
+            self.assembler
+                .emit_vcmpeqsd(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+            self.assembler.emit_vblendvpd(
+                tmp_xmm3,
+                XMMOrMemory::XMM(tmp_xmm2),
+                tmp_xmm1,
+                tmp_xmm1,
+            )?;
+            self.assembler
+                .emit_vcmpunordsd(src1, XMMOrMemory::XMM(src2), src1)?;
+            // load float canonical nan
+            self.move_location(
+                Size::S64,
+                Location::Imm64(0x7FF8_0000_0000_0000), // Canonical NaN
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+            self.assembler
+                .emit_vblendvpd(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+            match ret {
+                Location::SIMD(x) => {
+                    self.assembler
+                        .emit_vmovapd(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+                }
+                Location::Memory(_, _) | Location::GPR(_) => {
+                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+                }
+                _ => {
+                    codegen_error!("singlepass f64_max unreachable");
+                }
+            }
+
+            self.release_gpr(tmpg2);
+            self.release_gpr(tmpg1);
+            self.release_simd(tmp2);
+            self.release_simd(tmp1);
+            Ok(())
+        }
+    }
+    fn f64_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vaddsd, loc_a, loc_b, ret)
+    }
+    fn f64_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vsubsd, loc_a, loc_b, ret)
+    }
+    fn f64_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vmulsd, loc_a, loc_b, ret)
+    }
+    fn f64_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vdivsd, loc_a, loc_b, ret)
+    }
+    fn f32_neg(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        if self.assembler.arch_has_fneg() {
+            let tmp = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            self.emit_relaxed_mov(Size::S32, loc, Location::SIMD(tmp))?;
+            self.assembler.arch_emit_f32_neg(tmp, tmp)?;
+            self.emit_relaxed_mov(Size::S32, Location::SIMD(tmp), ret)?;
+            self.release_simd(tmp);
+        } else {
+            let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+            self.assembler.emit_btc_gpr_imm8_32(31, tmp)?;
+            self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+            self.release_gpr(tmp);
+        }
+        Ok(())
+    }
+    fn f32_abs(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        let tmp = self.acquire_temp_gpr().ok_or_else(|| {
+            CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+        })?;
+        self.move_location(Size::S32, loc, Location::GPR(tmp))?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::Imm32(0x7fffffffu32),
+            Location::GPR(tmp),
+        )?;
+        self.move_location(Size::S32, Location::GPR(tmp), ret)?;
+        self.release_gpr(tmp);
+        Ok(())
+    }
+    fn emit_i32_copysign(&mut self, tmp1: GPR, tmp2: GPR) -> Result<(), CompileError> {
+        self.assembler.emit_and(
+            Size::S32,
+            Location::Imm32(0x7fffffffu32),
+            Location::GPR(tmp1),
+        )?;
+        self.assembler.emit_and(
+            Size::S32,
+            Location::Imm32(0x80000000u32),
+            Location::GPR(tmp2),
+        )?;
+        self.assembler
+            .emit_or(Size::S32, Location::GPR(tmp2), Location::GPR(tmp1))
+    }
+    fn f32_sqrt(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vsqrtss, loc, loc, ret)
+    }
+    fn f32_trunc(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundss_trunc, loc, loc, ret)
+    }
+    fn f32_ceil(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundss_ceil, loc, loc, ret)
+    }
+    fn f32_floor(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundss_floor, loc, loc, ret)
+    }
+    fn f32_nearest(&mut self, loc: Location, ret: Location) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vroundss_nearest, loc, loc, ret)
+    }
+    fn f32_cmp_ge(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpgess, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_cmp_gt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpgtss, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_cmp_le(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpless, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_cmp_lt(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpltss, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_cmp_ne(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpneqss, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_cmp_eq(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vcmpeqss, loc_a, loc_b, ret)?;
+        self.assembler.emit_and(Size::S32, Location::Imm32(1), ret)
+    }
+    fn f32_min(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if !self.arch_supports_canonicalize_nan() {
+            self.emit_relaxed_avx(AssemblerX64::emit_vminss, loc_a, loc_b, ret)
+        } else {
+            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let src1 = match loc_a {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                _ => {
+                    codegen_error!("singlepass f32_min unreachable");
+                }
+            };
+            let src2 = match loc_b {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                _ => {
+                    codegen_error!("singlepass f32_min unreachable");
+                }
+            };
+
+            let tmp_xmm1 = XMM::XMM8;
+            let tmp_xmm2 = XMM::XMM9;
+            let tmp_xmm3 = XMM::XMM10;
+
+            self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
+            self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
+            self.assembler
+                .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+            self.assembler
+                .emit_vminss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+            let label1 = self.assembler.get_label();
+            let label2 = self.assembler.get_label();
+            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+            self.assembler
+                .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+            self.assembler.emit_jmp(Condition::None, label2)?;
+            self.emit_label(label1)?;
+            // load float -0.0
+            self.move_location(
+                Size::S64,
+                Location::Imm32(0x8000_0000), // Negative zero
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp_xmm2))?;
+            self.emit_label(label2)?;
+            self.assembler
+                .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+            self.assembler.emit_vblendvps(
+                tmp_xmm3,
+                XMMOrMemory::XMM(tmp_xmm2),
+                tmp_xmm1,
+                tmp_xmm1,
+            )?;
+            self.assembler
+                .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
+            // load float canonical nan
+            self.move_location(
+                Size::S64,
+                Location::Imm32(0x7FC0_0000), // Canonical NaN
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+            self.assembler
+                .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+            match ret {
+                Location::SIMD(x) => {
+                    self.assembler
+                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+                }
+                Location::Memory(_, _) | Location::GPR(_) => {
+                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+                }
+                _ => {
+                    codegen_error!("singlepass f32_min unreachable");
+                }
+            }
+
+            self.release_gpr(tmpg2);
+            self.release_gpr(tmpg1);
+            self.release_simd(tmp2);
+            self.release_simd(tmp1);
+            Ok(())
+        }
+    }
+    fn f32_max(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        if !self.arch_supports_canonicalize_nan() {
+            self.emit_relaxed_avx(AssemblerX64::emit_vmaxss, loc_a, loc_b, ret)
+        } else {
+            let tmp1 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmp2 = self.acquire_temp_simd().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp simd".to_owned())
+            })?;
+            let tmpg1 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+            let tmpg2 = self.acquire_temp_gpr().ok_or_else(|| {
+                CompileError::Codegen("singlepass cannot acquire temp gpr".to_owned())
+            })?;
+
+            let src1 = match loc_a {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_a, Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_a, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp1))?;
+                    tmp1
+                }
+                _ => {
+                    codegen_error!("singlepass f32_max unreachable");
+                }
+            };
+            let src2 = match loc_b {
+                Location::SIMD(x) => x,
+                Location::GPR(_) | Location::Memory(_, _) => {
+                    self.move_location(Size::S64, loc_b, Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm32(_) => {
+                    self.move_location(Size::S32, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S32, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                Location::Imm64(_) => {
+                    self.move_location(Size::S64, loc_b, Location::GPR(tmpg1))?;
+                    self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(tmp2))?;
+                    tmp2
+                }
+                _ => {
+                    codegen_error!("singlepass f32_max unreachable");
+                }
+            };
+
+            let tmp_xmm1 = XMM::XMM8;
+            let tmp_xmm2 = XMM::XMM9;
+            let tmp_xmm3 = XMM::XMM10;
+
+            self.move_location(Size::S32, Location::SIMD(src1), Location::GPR(tmpg1))?;
+            self.move_location(Size::S32, Location::SIMD(src2), Location::GPR(tmpg2))?;
+            self.assembler
+                .emit_cmp(Size::S32, Location::GPR(tmpg2), Location::GPR(tmpg1))?;
+            self.assembler
+                .emit_vmaxss(src1, XMMOrMemory::XMM(src2), tmp_xmm1)?;
+            let label1 = self.assembler.get_label();
+            let label2 = self.assembler.get_label();
+            self.assembler.emit_jmp(Condition::NotEqual, label1)?;
+            self.assembler
+                .emit_vmovaps(XMMOrMemory::XMM(tmp_xmm1), XMMOrMemory::XMM(tmp_xmm2))?;
+            self.assembler.emit_jmp(Condition::None, label2)?;
+            self.emit_label(label1)?;
+            self.assembler
+                .emit_vxorps(tmp_xmm2, XMMOrMemory::XMM(tmp_xmm2), tmp_xmm2)?;
+            self.emit_label(label2)?;
+            self.assembler
+                .emit_vcmpeqss(src1, XMMOrMemory::XMM(src2), tmp_xmm3)?;
+            self.assembler.emit_vblendvps(
+                tmp_xmm3,
+                XMMOrMemory::XMM(tmp_xmm2),
+                tmp_xmm1,
+                tmp_xmm1,
+            )?;
+            self.assembler
+                .emit_vcmpunordss(src1, XMMOrMemory::XMM(src2), src1)?;
+            // load float canonical nan
+            self.move_location(
+                Size::S64,
+                Location::Imm32(0x7FC0_0000), // Canonical NaN
+                Location::GPR(tmpg1),
+            )?;
+            self.move_location(Size::S64, Location::GPR(tmpg1), Location::SIMD(src2))?;
+            self.assembler
+                .emit_vblendvps(src1, XMMOrMemory::XMM(src2), tmp_xmm1, src1)?;
+            match ret {
+                Location::SIMD(x) => {
+                    self.assembler
+                        .emit_vmovaps(XMMOrMemory::XMM(src1), XMMOrMemory::XMM(x))?;
+                }
+                Location::Memory(_, _) | Location::GPR(_) => {
+                    self.move_location(Size::S64, Location::SIMD(src1), ret)?;
+                }
+                _ => {
+                    codegen_error!("singlepass f32_max unreachable");
+                }
+            }
+
+            self.release_gpr(tmpg2);
+            self.release_gpr(tmpg1);
+            self.release_simd(tmp2);
+            self.release_simd(tmp1);
+            Ok(())
+        }
+    }
+    fn f32_add(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vaddss, loc_a, loc_b, ret)
+    }
+    fn f32_sub(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vsubss, loc_a, loc_b, ret)
+    }
+    fn f32_mul(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vmulss, loc_a, loc_b, ret)
+    }
+    fn f32_div(
+        &mut self,
+        loc_a: Location,
+        loc_b: Location,
+        ret: Location,
+    ) -> Result<(), CompileError> {
+        self.emit_relaxed_avx(AssemblerX64::emit_vdivss, loc_a, loc_b, ret)
+    }
+
+    fn gen_std_trampoline(
+        &self,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        // the cpu feature here is irrelevant
+        let mut a = AssemblerX64::new(0, None)?;
+
+        // Calculate stack offset.
+        let mut stack_offset: u32 = 0;
+        for (i, _param) in sig.params().iter().enumerate() {
+            if let Location::Memory(_, _) =
+                self.get_simple_param_location(1 + i, calling_convention)
+            {
+                stack_offset += 8;
+            }
+        }
+        let stack_padding: u32 = match calling_convention {
+            CallingConvention::WindowsFastcall => 32,
+            _ => 0,
+        };
+
+        // Align to 16 bytes. We push two 8-byte registers below, so here we need to ensure stack_offset % 16 == 8.
+        if stack_offset % 16 != 8 {
+            stack_offset += 8;
+        }
+
+        // Used callee-saved registers
+        a.emit_push(Size::S64, Location::GPR(GPR::R15))?;
+        a.emit_push(Size::S64, Location::GPR(GPR::R14))?;
+
+        // Prepare stack space.
+        a.emit_sub(
+            Size::S64,
+            Location::Imm32(stack_offset + stack_padding),
+            Location::GPR(GPR::RSP),
+        )?;
+
+        // Arguments
+        a.emit_mov(
+            Size::S64,
+            self.get_simple_param_location(1, calling_convention),
+            Location::GPR(GPR::R15),
+        )?; // func_ptr
+        a.emit_mov(
+            Size::S64,
+            self.get_simple_param_location(2, calling_convention),
+            Location::GPR(GPR::R14),
+        )?; // args_rets
+
+        // Move arguments to their locations.
+        // `callee_vmctx` is already in the first argument register, so no need to move.
+        {
+            let mut n_stack_args: usize = 0;
+            for (i, _param) in sig.params().iter().enumerate() {
+                let src_loc = Location::Memory(GPR::R14, (i * 16) as _); // args_rets[i]
+                let dst_loc = self.get_simple_param_location(1 + i, calling_convention);
+
+                match dst_loc {
+                    Location::GPR(_) => {
+                        a.emit_mov(Size::S64, src_loc, dst_loc)?;
+                    }
+                    Location::Memory(_, _) => {
+                        // This location is for reading arguments but we are writing arguments here.
+                        // So recalculate it.
+                        a.emit_mov(Size::S64, src_loc, Location::GPR(GPR::RAX))?;
+                        a.emit_mov(
+                            Size::S64,
+                            Location::GPR(GPR::RAX),
+                            Location::Memory(
+                                GPR::RSP,
+                                (stack_padding as usize + n_stack_args * 8) as _,
+                            ),
+                        )?;
+                        n_stack_args += 1;
+                    }
+                    _ => codegen_error!("singlepass gen_std_trampoline unreachable"),
+                }
+            }
+        }
+
+        // Call.
+        a.emit_call_location(Location::GPR(GPR::R15))?;
+
+        // Restore stack.
+        a.emit_add(
+            Size::S64,
+            Location::Imm32(stack_offset + stack_padding),
+            Location::GPR(GPR::RSP),
+        )?;
+
+        // Write return value.
+        if !sig.results().is_empty() {
+            a.emit_mov(
+                Size::S64,
+                Location::GPR(GPR::RAX),
+                Location::Memory(GPR::R14, 0),
+            )?;
+        }
+
+        // Restore callee-saved registers.
+        a.emit_pop(Size::S64, Location::GPR(GPR::R14))?;
+        a.emit_pop(Size::S64, Location::GPR(GPR::R15))?;
+
+        a.emit_ret()?;
+
+        let mut body = a.finalize().unwrap();
+        body.shrink_to_fit();
+        Ok(FunctionBody {
+            body,
+            unwind_info: None,
+        })
+    }
+    // Generates dynamic import function call trampoline for a function type.
+    fn gen_std_dynamic_import_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<FunctionBody, CompileError> {
+        // the cpu feature here is irrelevant
+        let mut a = AssemblerX64::new(0, None)?;
+
+        // Allocate argument array.
+        let stack_offset: usize = 16 * std::cmp::max(sig.params().len(), sig.results().len()) + 8; // 16 bytes each + 8 bytes sysv call padding
+        let stack_padding: usize = match calling_convention {
+            CallingConvention::WindowsFastcall => 32,
+            _ => 0,
+        };
+        a.emit_sub(
+            Size::S64,
+            Location::Imm32((stack_offset + stack_padding) as _),
+            Location::GPR(GPR::RSP),
+        )?;
+
+        // Copy arguments.
+        if !sig.params().is_empty() {
+            let mut argalloc = ArgumentRegisterAllocator::default();
+            argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
+
+            let mut stack_param_count: usize = 0;
+
+            for (i, ty) in sig.params().iter().enumerate() {
+                let source_loc = match argalloc.next(*ty, calling_convention) {
+                    Some(X64Register::GPR(gpr)) => Location::GPR(gpr),
+                    Some(X64Register::XMM(xmm)) => Location::SIMD(xmm),
+                    None => {
+                        a.emit_mov(
+                            Size::S64,
+                            Location::Memory(
+                                GPR::RSP,
+                                (stack_padding * 2 + stack_offset + 8 + stack_param_count * 8) as _,
+                            ),
+                            Location::GPR(GPR::RAX),
+                        )?;
+                        stack_param_count += 1;
+                        Location::GPR(GPR::RAX)
+                    }
+                };
+                a.emit_mov(
+                    Size::S64,
+                    source_loc,
+                    Location::Memory(GPR::RSP, (stack_padding + i * 16) as _),
+                )?;
+
+                // Zero upper 64 bits.
+                a.emit_mov(
+                    Size::S64,
+                    Location::Imm32(0),
+                    Location::Memory(GPR::RSP, (stack_padding + i * 16 + 8) as _),
+                )?;
+            }
+        }
+
+        match calling_convention {
+            CallingConvention::WindowsFastcall => {
+                // Load target address.
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(
+                        GPR::RCX,
+                        vmoffsets.vmdynamicfunction_import_context_address() as i32,
+                    ),
+                    Location::GPR(GPR::RAX),
+                )?;
+                // Load values array.
+                a.emit_lea(
+                    Size::S64,
+                    Location::Memory(GPR::RSP, stack_padding as i32),
+                    Location::GPR(GPR::RDX),
+                )?;
+            }
+            _ => {
+                // Load target address.
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(
+                        GPR::RDI,
+                        vmoffsets.vmdynamicfunction_import_context_address() as i32,
+                    ),
+                    Location::GPR(GPR::RAX),
+                )?;
+                // Load values array.
+                a.emit_mov(Size::S64, Location::GPR(GPR::RSP), Location::GPR(GPR::RSI))?;
+            }
+        };
+
+        // Call target.
+        a.emit_call_location(Location::GPR(GPR::RAX))?;
+
+        // Fetch return value.
+        if !sig.results().is_empty() {
+            assert_eq!(sig.results().len(), 1);
+            a.emit_mov(
+                Size::S64,
+                Location::Memory(GPR::RSP, stack_padding as i32),
+                Location::GPR(GPR::RAX),
+            )?;
+        }
+
+        // Release values array.
+        a.emit_add(
+            Size::S64,
+            Location::Imm32((stack_offset + stack_padding) as _),
+            Location::GPR(GPR::RSP),
+        )?;
+
+        // Return.
+        a.emit_ret()?;
+
+        let mut body = a.finalize().unwrap();
+        body.shrink_to_fit();
+        Ok(FunctionBody {
+            body,
+            unwind_info: None,
+        })
+    }
+    // Singlepass calls import functions through a trampoline.
+    fn gen_import_call_trampoline(
+        &self,
+        vmoffsets: &VMOffsets,
+        index: FunctionIndex,
+        sig: &FunctionType,
+        calling_convention: CallingConvention,
+    ) -> Result<CustomSection, CompileError> {
+        // the cpu feature here is irrelevant
+        let mut a = AssemblerX64::new(0, None)?;
+
+        // TODO: ARM entry trampoline is not emitted.
+
+        // Singlepass internally treats all arguments as integers
+        // For the standard Windows calling convention requires
+        //  floating point arguments to be passed in XMM registers for the 4 first arguments only
+        //  That's the only change to do, other arguments are not to be changed
+        // For the standard System V calling convention requires
+        //  floating point arguments to be passed in XMM registers.
+        //  Translation is expensive, so only do it if needed.
+        if sig
+            .params()
+            .iter()
+            .any(|&x| x == Type::F32 || x == Type::F64)
+        {
+            match calling_convention {
+                CallingConvention::WindowsFastcall => {
+                    let mut param_locations: Vec<Location> = vec![];
+                    static PARAM_REGS: &[GPR] = &[GPR::RDX, GPR::R8, GPR::R9];
+                    #[allow(clippy::needless_range_loop)]
+                    for i in 0..sig.params().len() {
+                        let loc = match i {
+                            0..=2 => Location::GPR(PARAM_REGS[i]),
+                            _ => Location::Memory(GPR::RSP, 32 + 8 + ((i - 3) * 8) as i32), // will not be used anyway
+                        };
+                        param_locations.push(loc);
+                    }
+
+                    // Copy Float arguments to XMM from GPR.
+                    let mut argalloc = ArgumentRegisterAllocator::default();
+                    for (i, ty) in sig.params().iter().enumerate() {
+                        let prev_loc = param_locations[i];
+                        match argalloc.next(*ty, calling_convention) {
+                            Some(X64Register::GPR(_gpr)) => continue,
+                            Some(X64Register::XMM(xmm)) => {
+                                a.emit_mov(Size::S64, prev_loc, Location::SIMD(xmm))?
+                            }
+                            None => continue,
+                        };
+                    }
+                }
+                _ => {
+                    let mut param_locations = vec![];
+
+                    // Allocate stack space for arguments.
+                    let stack_offset: i32 = if sig.params().len() > 5 {
+                        5 * 8
+                    } else {
+                        (sig.params().len() as i32) * 8
+                    };
+                    if stack_offset > 0 {
+                        a.emit_sub(
+                            Size::S64,
+                            Location::Imm32(stack_offset as u32),
+                            Location::GPR(GPR::RSP),
+                        )?;
+                    }
+
+                    // Store all arguments to the stack to prevent overwrite.
+                    static PARAM_REGS: &[GPR] = &[GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9];
+                    #[allow(clippy::needless_range_loop)]
+                    for i in 0..sig.params().len() {
+                        let loc = match i {
+                            0..=4 => {
+                                let loc = Location::Memory(GPR::RSP, (i * 8) as i32);
+                                a.emit_mov(Size::S64, Location::GPR(PARAM_REGS[i]), loc)?;
+                                loc
+                            }
+                            _ => {
+                                Location::Memory(GPR::RSP, stack_offset + 8 + ((i - 5) * 8) as i32)
+                            }
+                        };
+                        param_locations.push(loc);
+                    }
+
+                    // Copy arguments.
+                    let mut argalloc = ArgumentRegisterAllocator::default();
+                    argalloc.next(Type::I64, calling_convention).unwrap(); // skip VMContext
+                    let mut caller_stack_offset: i32 = 0;
+                    for (i, ty) in sig.params().iter().enumerate() {
+                        let prev_loc = param_locations[i];
+                        let targ = match argalloc.next(*ty, calling_convention) {
+                            Some(X64Register::GPR(gpr)) => Location::GPR(gpr),
+                            Some(X64Register::XMM(xmm)) => Location::SIMD(xmm),
+                            None => {
+                                // No register can be allocated. Put this argument on the stack.
+                                //
+                                // Since here we never use fewer registers than by the original call, on the caller's frame
+                                // we always have enough space to store the rearranged arguments, and the copy "backward" between different
+                                // slots in the caller argument region will always work.
+                                a.emit_mov(Size::S64, prev_loc, Location::GPR(GPR::RAX))?;
+                                a.emit_mov(
+                                    Size::S64,
+                                    Location::GPR(GPR::RAX),
+                                    Location::Memory(
+                                        GPR::RSP,
+                                        stack_offset + 8 + caller_stack_offset,
+                                    ),
+                                )?;
+                                caller_stack_offset += 8;
+                                continue;
+                            }
+                        };
+                        a.emit_mov(Size::S64, prev_loc, targ)?;
+                    }
+
+                    // Restore stack pointer.
+                    if stack_offset > 0 {
+                        a.emit_add(
+                            Size::S64,
+                            Location::Imm32(stack_offset as u32),
+                            Location::GPR(GPR::RSP),
+                        )?;
+                    }
+                }
+            }
+        }
+
+        // Emits a tail call trampoline that loads the address of the target import function
+        // from Ctx and jumps to it.
+
+        let offset = vmoffsets.vmctx_vmfunction_import(index);
+
+        match calling_convention {
+            CallingConvention::WindowsFastcall => {
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(GPR::RCX, offset as i32), // function pointer
+                    Location::GPR(GPR::RAX),
+                )?;
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(GPR::RCX, offset as i32 + 8), // target vmctx
+                    Location::GPR(GPR::RCX),
+                )?;
+            }
+            _ => {
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(GPR::RDI, offset as i32), // function pointer
+                    Location::GPR(GPR::RAX),
+                )?;
+                a.emit_mov(
+                    Size::S64,
+                    Location::Memory(GPR::RDI, offset as i32 + 8), // target vmctx
+                    Location::GPR(GPR::RDI),
+                )?;
+            }
+        }
+        a.emit_host_redirection(GPR::RAX)?;
+
+        let mut contents = a.finalize().unwrap();
+        contents.shrink_to_fit();
+        let section_body = SectionBody::new_with_vec(contents);
+
+        Ok(CustomSection {
+            protection: CustomSectionProtection::ReadExecute,
+            bytes: section_body,
+            relocations: vec![],
+        })
+    }
+    #[cfg(feature = "unwind")]
+    fn gen_dwarf_unwind_info(&mut self, code_len: usize) -> Option<UnwindInstructions> {
+        let mut instructions = vec![];
+        for &(instruction_offset, ref inst) in &self.unwind_ops {
+            let instruction_offset = instruction_offset as u32;
+            match *inst {
+                UnwindOps::PushFP { up_to_sp } => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaOffset(up_to_sp as i32),
+                    ));
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::Offset(X86_64::RBP, -(up_to_sp as i32)),
+                    ));
+                }
+                UnwindOps::DefineNewFrame => {
+                    instructions.push((
+                        instruction_offset,
+                        CallFrameInstruction::CfaRegister(X86_64::RBP),
+                    ));
+                }
+                UnwindOps::SaveRegister { reg, bp_neg_offset } => instructions.push((
+                    instruction_offset,
+                    CallFrameInstruction::Offset(dwarf_index(reg), -bp_neg_offset),
+                )),
+                UnwindOps::Push2Regs { .. } => unimplemented!(),
+            }
+        }
+        Some(UnwindInstructions {
+            instructions,
+            len: code_len as u32,
+        })
+    }
+    #[cfg(not(feature = "unwind"))]
+    fn gen_dwarf_unwind_info(&mut self, _code_len: usize) -> Option<UnwindInstructions> {
+        None
+    }
+
+    #[cfg(feature = "unwind")]
+    fn gen_windows_unwind_info(&mut self, _code_len: usize) -> Option<Vec<u8>> {
+        let unwind_info = create_unwind_info_from_insts(&self.unwind_ops);
+        if let Some(unwind) = unwind_info {
+            let sz = unwind.emit_size();
+            let mut tbl = vec![0; sz];
+            unwind.emit(&mut tbl);
+            Some(tbl)
+        } else {
+            None
+        }
+    }
+
+    #[cfg(not(feature = "unwind"))]
+    fn gen_windows_unwind_info(&mut self, _code_len: usize) -> Option<Vec<u8>> {
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use enumset::enum_set;
+    use std::str::FromStr;
+    use wasmer_types::{CpuFeature, Target, Triple};
+
+    fn test_move_location(machine: &mut MachineX86_64) -> Result<(), CompileError> {
+        machine.move_location_for_native(
+            Size::S64,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RCX),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, 10),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, -10),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::Memory(GPR::RDX, 10),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::Imm64(50),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::Imm32(50),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(Size::S64, Location::Imm8(50), Location::GPR(GPR::RAX))?;
+
+        machine.move_location_for_native(
+            Size::S32,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RCX),
+        )?;
+        machine.move_location_for_native(
+            Size::S32,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, 10),
+        )?;
+        machine.move_location_for_native(
+            Size::S32,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, -10),
+        )?;
+        machine.move_location_for_native(
+            Size::S32,
+            Location::Memory(GPR::RDX, 10),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(
+            Size::S32,
+            Location::Imm32(50),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(Size::S32, Location::Imm8(50), Location::GPR(GPR::RAX))?;
+
+        machine.move_location_for_native(
+            Size::S16,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RCX),
+        )?;
+        machine.move_location_for_native(
+            Size::S16,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, 10),
+        )?;
+        machine.move_location_for_native(
+            Size::S16,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, -10),
+        )?;
+        machine.move_location_for_native(
+            Size::S16,
+            Location::Memory(GPR::RDX, 10),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(Size::S16, Location::Imm8(50), Location::GPR(GPR::RAX))?;
+
+        machine.move_location_for_native(
+            Size::S8,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RCX),
+        )?;
+        machine.move_location_for_native(
+            Size::S8,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, 10),
+        )?;
+        machine.move_location_for_native(
+            Size::S8,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, -10),
+        )?;
+        machine.move_location_for_native(
+            Size::S8,
+            Location::Memory(GPR::RDX, 10),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(Size::S8, Location::Imm8(50), Location::GPR(GPR::RAX))?;
+
+        machine.move_location_for_native(
+            Size::S64,
+            Location::SIMD(XMM::XMM0),
+            Location::GPR(GPR::RAX),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::SIMD(XMM::XMM0),
+            Location::Memory(GPR::RDX, -10),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::GPR(GPR::RAX),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        machine.move_location_for_native(
+            Size::S64,
+            Location::Memory(GPR::RDX, -10),
+            Location::SIMD(XMM::XMM0),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_move_location_extended(
+        machine: &mut MachineX86_64,
+        signed: bool,
+        sized: Size,
+    ) -> Result<(), CompileError> {
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::RAX),
+            Size::S64,
+            Location::GPR(GPR::RCX),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::GPR(GPR::RAX),
+            Size::S64,
+            Location::Memory(GPR::RCX, 10),
+        )?;
+        machine.move_location_extend(
+            sized,
+            signed,
+            Location::Memory(GPR::RAX, 10),
+            Size::S64,
+            Location::GPR(GPR::RCX),
+        )?;
+        if sized != Size::S32 {
+            machine.move_location_extend(
+                sized,
+                signed,
+                Location::GPR(GPR::RAX),
+                Size::S32,
+                Location::GPR(GPR::RCX),
+            )?;
+            machine.move_location_extend(
+                sized,
+                signed,
+                Location::GPR(GPR::RAX),
+                Size::S32,
+                Location::Memory(GPR::RCX, 10),
+            )?;
+            machine.move_location_extend(
+                sized,
+                signed,
+                Location::Memory(GPR::RAX, 10),
+                Size::S32,
+                Location::GPR(GPR::RCX),
+            )?;
+        }
+
+        Ok(())
+    }
+
+    fn test_binop_op(
+        machine: &mut MachineX86_64,
+        op: fn(&mut MachineX86_64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::GPR(GPR::RDX),
+            Location::GPR(GPR::RDX),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::RDX),
+            Location::Imm32(10),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::Imm32(10),
+            Location::GPR(GPR::RDX),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::RAX),
+            Location::GPR(GPR::RDX),
+            Location::Memory(GPR::RAX, 10),
+        )?;
+        op(
+            machine,
+            Location::GPR(GPR::RAX),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 10),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RAX, 0),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 10),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_float_binop_op(
+        machine: &mut MachineX86_64,
+        op: fn(&mut MachineX86_64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::SIMD(XMM::XMM3),
+            Location::SIMD(XMM::XMM2),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM2),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::SIMD(XMM::XMM2),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::Memory(GPR::RDX, 10),
+            Location::SIMD(XMM::XMM0),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM1),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+
+        Ok(())
+    }
+
+    fn test_float_cmp_op(
+        machine: &mut MachineX86_64,
+        op: fn(&mut MachineX86_64, Location, Location, Location) -> Result<(), CompileError>,
+    ) -> Result<(), CompileError> {
+        op(
+            machine,
+            Location::SIMD(XMM::XMM3),
+            Location::SIMD(XMM::XMM2),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM0),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::SIMD(XMM::XMM2),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::Memory(GPR::RDX, 10),
+            Location::GPR(GPR::RAX),
+        )?;
+        op(
+            machine,
+            Location::Memory(GPR::RBP, 0),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::Memory(GPR::RDX, 16),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+        op(
+            machine,
+            Location::SIMD(XMM::XMM0),
+            Location::SIMD(XMM::XMM1),
+            Location::Memory(GPR::RAX, 32),
+        )?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn tests_avx() -> Result<(), CompileError> {
+        let set = enum_set!(CpuFeature::AVX);
+        let target = Target::new(Triple::from_str("x86_64-linux-gnu").unwrap(), set);
+        let mut machine = MachineX86_64::new(Some(target))?;
+
+        test_move_location(&mut machine)?;
+        test_move_location_extended(&mut machine, false, Size::S8)?;
+        test_move_location_extended(&mut machine, false, Size::S16)?;
+        test_move_location_extended(&mut machine, false, Size::S32)?;
+        test_move_location_extended(&mut machine, true, Size::S8)?;
+        test_move_location_extended(&mut machine, true, Size::S16)?;
+        test_move_location_extended(&mut machine, true, Size::S32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_add32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_add64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_sub32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_sub64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_and32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_and64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_xor32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_xor64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_or32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_or64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_mul32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_mul64)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_add)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_sub)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_mul)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_div)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_eq)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_lt)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_le)?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn tests_sse42() -> Result<(), CompileError> {
+        let set = enum_set!(CpuFeature::SSE42);
+        let target = Target::new(Triple::from_str("x86_64-linux-gnu").unwrap(), set);
+        let mut machine = MachineX86_64::new(Some(target))?;
+
+        test_move_location(&mut machine)?;
+        test_move_location_extended(&mut machine, false, Size::S8)?;
+        test_move_location_extended(&mut machine, false, Size::S16)?;
+        test_move_location_extended(&mut machine, false, Size::S32)?;
+        test_move_location_extended(&mut machine, true, Size::S8)?;
+        test_move_location_extended(&mut machine, true, Size::S16)?;
+        test_move_location_extended(&mut machine, true, Size::S32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_add32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_add64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_sub32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_sub64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_and32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_and64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_xor32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_xor64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_or32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_or64)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_mul32)?;
+        test_binop_op(&mut machine, MachineX86_64::emit_binop_mul64)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_add)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_sub)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_mul)?;
+        test_float_binop_op(&mut machine, MachineX86_64::f32_div)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_eq)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_lt)?;
+        test_float_cmp_op(&mut machine, MachineX86_64::f32_cmp_le)?;
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind.rs
new file mode 100644
index 0000000..ffda450
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind.rs
@@ -0,0 +1,81 @@
+#[cfg(feature = "unwind")]
+use gimli::write::{Address, CallFrameInstruction, CommonInformationEntry, FrameDescriptionEntry};
+#[cfg(feature = "unwind")]
+use gimli::{AArch64, Encoding, Format, X86_64};
+use std::fmt::Debug;
+#[cfg(feature = "unwind")]
+use wasmer_types::Architecture;
+
+#[derive(Clone, Debug)]
+pub enum UnwindOps {
+    PushFP { up_to_sp: u32 },
+    Push2Regs { reg1: u16, reg2: u16, up_to_sp: u32 },
+    DefineNewFrame,
+    SaveRegister { reg: u16, bp_neg_offset: i32 },
+}
+
+#[cfg(not(feature = "unwind"))]
+pub type CallFrameInstruction = u32;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct UnwindInstructions {
+    pub instructions: Vec<(u32, CallFrameInstruction)>,
+    pub len: u32,
+}
+
+#[cfg(feature = "unwind")]
+pub enum UnwindFrame {
+    SystemV(gimli::write::FrameDescriptionEntry),
+}
+
+#[cfg(not(feature = "unwind"))]
+pub type UnwindFrame = u32;
+
+#[cfg(feature = "unwind")]
+impl UnwindInstructions {
+    /// Converts the unwind information into a `FrameDescriptionEntry`.
+    pub fn to_fde(&self, address: Address) -> UnwindFrame {
+        let mut fde = FrameDescriptionEntry::new(address, self.len);
+        for (offset, inst) in &self.instructions {
+            fde.add_instruction(*offset, inst.clone());
+        }
+        UnwindFrame::SystemV(fde)
+    }
+}
+
+/// generate a default systemv  cie
+#[cfg(feature = "unwind")]
+pub fn create_systemv_cie(arch: Architecture) -> Option<gimli::write::CommonInformationEntry> {
+    match arch {
+        Architecture::X86_64 => {
+            let mut entry = CommonInformationEntry::new(
+                Encoding {
+                    address_size: 8,
+                    format: Format::Dwarf32,
+                    version: 1,
+                },
+                1,
+                -8,
+                X86_64::RA,
+            );
+            entry.add_instruction(CallFrameInstruction::Cfa(X86_64::RSP, 8));
+            entry.add_instruction(CallFrameInstruction::Offset(X86_64::RA, -8));
+            Some(entry)
+        }
+        Architecture::Aarch64(_) => {
+            let mut entry = CommonInformationEntry::new(
+                Encoding {
+                    address_size: 8,
+                    format: Format::Dwarf32,
+                    version: 1,
+                },
+                1,
+                -8,
+                AArch64::X30,
+            );
+            entry.add_instruction(CallFrameInstruction::Cfa(AArch64::SP, 0));
+            Some(entry)
+        }
+        _ => None,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind_winx64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind_winx64.rs
new file mode 100644
index 0000000..389cba3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/unwind_winx64.rs
@@ -0,0 +1,303 @@
+//! Windows x64 ABI unwind information.
+
+use crate::unwind::UnwindOps;
+
+/// Maximum (inclusive) size of a "small" stack allocation
+const SMALL_ALLOC_MAX_SIZE: u32 = 128;
+/// Maximum (inclusive) size of a "large" stack allocation that can represented in 16-bits
+const LARGE_ALLOC_16BIT_MAX_SIZE: u32 = 524280;
+
+struct Writer<'a> {
+    buf: &'a mut [u8],
+    offset: usize,
+}
+
+impl<'a> Writer<'a> {
+    pub fn new(buf: &'a mut [u8]) -> Self {
+        Self { buf, offset: 0 }
+    }
+
+    fn write_u8(&mut self, v: u8) {
+        self.buf[self.offset] = v;
+        self.offset += 1;
+    }
+
+    fn write_u16_le(&mut self, v: u16) {
+        self.buf[self.offset..(self.offset + 2)].copy_from_slice(&v.to_le_bytes());
+        self.offset += 2;
+    }
+
+    fn write_u32_le(&mut self, v: u32) {
+        self.buf[self.offset..(self.offset + 4)].copy_from_slice(&v.to_le_bytes());
+        self.offset += 4;
+    }
+}
+
+/// The supported unwind codes for the x64 Windows ABI.
+///
+/// See: <https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64>
+/// Only what is needed to describe the prologues generated by the Cranelift x86 ISA are represented here.
+/// Note: the Cranelift x86 ISA RU enum matches the Windows unwind GPR encoding values.
+#[allow(dead_code)]
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) enum UnwindCode {
+    PushRegister {
+        instruction_offset: u8,
+        reg: u8,
+    },
+    SaveReg {
+        instruction_offset: u8,
+        reg: u8,
+        stack_offset: u32,
+    },
+    SaveXmm {
+        instruction_offset: u8,
+        reg: u8,
+        stack_offset: u32,
+    },
+    StackAlloc {
+        instruction_offset: u8,
+        size: u32,
+    },
+    SetFPReg {
+        instruction_offset: u8,
+    },
+}
+
+impl UnwindCode {
+    fn emit(&self, writer: &mut Writer) {
+        enum UnwindOperation {
+            PushNonvolatileRegister = 0,
+            LargeStackAlloc = 1,
+            SmallStackAlloc = 2,
+            SetFPReg = 3,
+            SaveNonVolatileRegister = 4,
+            SaveNonVolatileRegisterFar = 5,
+            SaveXmm128 = 8,
+            SaveXmm128Far = 9,
+        }
+
+        match self {
+            Self::PushRegister {
+                instruction_offset,
+                reg,
+            } => {
+                writer.write_u8(*instruction_offset);
+                writer.write_u8((*reg << 4) | (UnwindOperation::PushNonvolatileRegister as u8));
+            }
+            Self::SaveReg {
+                instruction_offset,
+                reg,
+                stack_offset,
+            }
+            | Self::SaveXmm {
+                instruction_offset,
+                reg,
+                stack_offset,
+            } => {
+                let is_xmm = matches!(self, Self::SaveXmm { .. });
+                let (op_small, op_large) = if is_xmm {
+                    (UnwindOperation::SaveXmm128, UnwindOperation::SaveXmm128Far)
+                } else {
+                    (
+                        UnwindOperation::SaveNonVolatileRegister,
+                        UnwindOperation::SaveNonVolatileRegisterFar,
+                    )
+                };
+                writer.write_u8(*instruction_offset);
+                let scaled_stack_offset = stack_offset / 16;
+                if scaled_stack_offset <= core::u16::MAX as u32 {
+                    writer.write_u8((*reg << 4) | (op_small as u8));
+                    writer.write_u16_le(scaled_stack_offset as u16);
+                } else {
+                    writer.write_u8((*reg << 4) | (op_large as u8));
+                    writer.write_u16_le(*stack_offset as u16);
+                    writer.write_u16_le((stack_offset >> 16) as u16);
+                }
+            }
+            Self::StackAlloc {
+                instruction_offset,
+                size,
+            } => {
+                // Stack allocations on Windows must be a multiple of 8 and be at least 1 slot
+                assert!(*size >= 8);
+                assert!((*size % 8) == 0);
+
+                writer.write_u8(*instruction_offset);
+                if *size <= SMALL_ALLOC_MAX_SIZE {
+                    writer.write_u8(
+                        ((((*size - 8) / 8) as u8) << 4) | UnwindOperation::SmallStackAlloc as u8,
+                    );
+                } else if *size <= LARGE_ALLOC_16BIT_MAX_SIZE {
+                    writer.write_u8(UnwindOperation::LargeStackAlloc as u8);
+                    writer.write_u16_le((*size / 8) as u16);
+                } else {
+                    writer.write_u8((1 << 4) | (UnwindOperation::LargeStackAlloc as u8));
+                    writer.write_u32_le(*size);
+                }
+            }
+            Self::SetFPReg { instruction_offset } => {
+                writer.write_u8(*instruction_offset);
+                writer.write_u8(UnwindOperation::SetFPReg as u8);
+            }
+        }
+    }
+
+    fn node_count(&self) -> usize {
+        match self {
+            Self::StackAlloc { size, .. } => {
+                if *size <= SMALL_ALLOC_MAX_SIZE {
+                    1
+                } else if *size <= LARGE_ALLOC_16BIT_MAX_SIZE {
+                    2
+                } else {
+                    3
+                }
+            }
+            Self::SaveXmm { stack_offset, .. } | Self::SaveReg { stack_offset, .. } => {
+                if *stack_offset <= core::u16::MAX as u32 {
+                    2
+                } else {
+                    3
+                }
+            }
+            _ => 1,
+        }
+    }
+}
+
+/// Represents Windows x64 unwind information.
+///
+/// For information about Windows x64 unwind info, see:
+/// <https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64>
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct UnwindInfo {
+    pub(crate) flags: u8,
+    pub(crate) prologue_size: u8,
+    pub(crate) frame_register: Option<u8>,
+    pub(crate) frame_register_offset: u8,
+    pub(crate) unwind_codes: Vec<UnwindCode>,
+}
+
+impl UnwindInfo {
+    /// Gets the emit size of the unwind information, in bytes.
+    pub fn emit_size(&self) -> usize {
+        let node_count = self.node_count();
+
+        // Calculation of the size requires no SEH handler or chained info
+        assert!(self.flags == 0);
+
+        // Size of fixed part of UNWIND_INFO is 4 bytes
+        // Then comes the UNWIND_CODE nodes (2 bytes each)
+        // Then comes 2 bytes of padding for the unwind codes if necessary
+        // Next would come the SEH data, but we assert above that the function doesn't have SEH data
+
+        4 + (node_count * 2) + if (node_count & 1) == 1 { 2 } else { 0 }
+    }
+
+    /// Emits the unwind information into the given mutable byte slice.
+    ///
+    /// This function will panic if the slice is not at least `emit_size` in length.
+    pub fn emit(&self, buf: &mut [u8]) {
+        const UNWIND_INFO_VERSION: u8 = 1;
+
+        let node_count = self.node_count();
+        assert!(node_count <= 256);
+
+        let mut writer = Writer::new(buf);
+
+        writer.write_u8((self.flags << 3) | UNWIND_INFO_VERSION);
+        writer.write_u8(self.prologue_size);
+        writer.write_u8(node_count as u8);
+
+        if let Some(reg) = self.frame_register {
+            writer.write_u8((self.frame_register_offset << 4) | reg);
+        } else {
+            writer.write_u8(0);
+        }
+
+        // Unwind codes are written in reverse order (prologue offset descending)
+        for code in self.unwind_codes.iter().rev() {
+            code.emit(&mut writer);
+        }
+
+        // To keep a 32-bit alignment, emit 2 bytes of padding if there's an odd number of 16-bit nodes
+        if (node_count & 1) == 1 {
+            writer.write_u16_le(0);
+        }
+
+        // Ensure the correct number of bytes was emitted
+        assert_eq!(writer.offset, self.emit_size());
+    }
+
+    fn node_count(&self) -> usize {
+        self.unwind_codes
+            .iter()
+            .fold(0, |nodes, c| nodes + c.node_count())
+    }
+}
+
+const UNWIND_RBP_REG: u8 = 5;
+
+pub(crate) fn create_unwind_info_from_insts(insts: &[(usize, UnwindOps)]) -> Option<UnwindInfo> {
+    let mut unwind_codes = vec![];
+    let mut frame_register_offset = 0;
+    let mut max_unwind_offset = 0;
+    for &(instruction_offset, ref inst) in insts {
+        let instruction_offset = ensure_unwind_offset(instruction_offset as u32)?;
+        match *inst {
+            UnwindOps::PushFP { .. } => {
+                unwind_codes.push(UnwindCode::PushRegister {
+                    instruction_offset,
+                    reg: UNWIND_RBP_REG,
+                });
+            }
+            UnwindOps::DefineNewFrame => {
+                frame_register_offset = ensure_unwind_offset(32)?;
+                unwind_codes.push(UnwindCode::SetFPReg { instruction_offset });
+            }
+            UnwindOps::SaveRegister { reg, bp_neg_offset } => match reg {
+                0..=15 => {
+                    // GPR reg
+                    static FROM_DWARF: [u8; 16] =
+                        [0, 2, 1, 3, 6, 7, 5, 4, 8, 9, 10, 11, 12, 13, 14, 15];
+                    unwind_codes.push(UnwindCode::SaveReg {
+                        instruction_offset,
+                        reg: FROM_DWARF[reg as usize],
+                        stack_offset: bp_neg_offset as u32,
+                    });
+                }
+                17..=32 => {
+                    unwind_codes.push(UnwindCode::SaveXmm {
+                        instruction_offset,
+                        reg: reg as u8 - 17,
+                        stack_offset: bp_neg_offset as u32,
+                    });
+                }
+                _ => {
+                    unreachable!("unknown register index {}", reg);
+                }
+            },
+            UnwindOps::Push2Regs { .. } => {
+                unreachable!("no aarch64 on x64");
+            }
+        }
+        max_unwind_offset = instruction_offset;
+    }
+
+    Some(UnwindInfo {
+        flags: 0,
+        prologue_size: max_unwind_offset,
+        frame_register: Some(UNWIND_RBP_REG),
+        frame_register_offset,
+        unwind_codes,
+    })
+}
+
+fn ensure_unwind_offset(offset: u32) -> Option<u8> {
+    if offset > 255 {
+        panic!("function prologues cannot exceed 255 bytes in size for Windows x64");
+    }
+    Some(offset as u8)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/x64_decl.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/x64_decl.rs
new file mode 100644
index 0000000..6178a17
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler-singlepass/src/x64_decl.rs
@@ -0,0 +1,342 @@
+//! X64 structures.
+
+#![allow(clippy::upper_case_acronyms)]
+use crate::common_decl::{MachineState, MachineValue, RegisterIndex};
+use crate::location::CombinedRegister;
+use crate::location::Reg as AbstractReg;
+use std::collections::BTreeMap;
+use std::slice::Iter;
+use wasmer_types::{CallingConvention, Type};
+
+/// General-purpose registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+pub enum GPR {
+    RAX = 0,
+    RCX = 1,
+    RDX = 2,
+    RBX = 3,
+    RSP = 4,
+    RBP = 5,
+    RSI = 6,
+    RDI = 7,
+    R8 = 8,
+    R9 = 9,
+    R10 = 10,
+    R11 = 11,
+    R12 = 12,
+    R13 = 13,
+    R14 = 14,
+    R15 = 15,
+}
+
+/// XMM registers.
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[allow(dead_code)]
+pub enum XMM {
+    XMM0 = 0,
+    XMM1 = 1,
+    XMM2 = 2,
+    XMM3 = 3,
+    XMM4 = 4,
+    XMM5 = 5,
+    XMM6 = 6,
+    XMM7 = 7,
+    XMM8 = 8,
+    XMM9 = 9,
+    XMM10 = 10,
+    XMM11 = 11,
+    XMM12 = 12,
+    XMM13 = 13,
+    XMM14 = 14,
+    XMM15 = 15,
+}
+
+impl AbstractReg for GPR {
+    fn is_callee_save(self) -> bool {
+        const IS_CALLEE_SAVE: [bool; 16] = [
+            false, false, false, true, true, true, false, false, false, false, false, false, true,
+            true, true, true,
+        ];
+        IS_CALLEE_SAVE[self as usize]
+    }
+    fn is_reserved(self) -> bool {
+        self == GPR::RSP || self == GPR::RBP || self == GPR::R10 || self == GPR::R15
+    }
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<GPR, ()> {
+        match n {
+            0..=15 => Ok(*GPR::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, GPR> {
+        static GPRS: [GPR; 16] = [
+            GPR::RAX,
+            GPR::RCX,
+            GPR::RDX,
+            GPR::RBX,
+            GPR::RSP,
+            GPR::RBP,
+            GPR::RSI,
+            GPR::RDI,
+            GPR::R8,
+            GPR::R9,
+            GPR::R10,
+            GPR::R11,
+            GPR::R12,
+            GPR::R13,
+            GPR::R14,
+            GPR::R15,
+        ];
+        GPRS.iter()
+    }
+    fn to_dwarf(self) -> u16 {
+        match self {
+            GPR::RAX => 0,
+            GPR::RDX => 1,
+            GPR::RCX => 2,
+            GPR::RBX => 3,
+            GPR::RSI => 4,
+            GPR::RDI => 5,
+            GPR::RBP => 6,
+            GPR::RSP => 7,
+            GPR::R8 => 8,
+            GPR::R9 => 9,
+            GPR::R10 => 10,
+            GPR::R11 => 11,
+            GPR::R12 => 12,
+            GPR::R13 => 13,
+            GPR::R14 => 14,
+            GPR::R15 => 15,
+        }
+    }
+}
+
+impl AbstractReg for XMM {
+    fn is_callee_save(self) -> bool {
+        const IS_CALLEE_SAVE: [bool; 16] = [
+            false, false, false, false, false, false, false, false, true, true, true, true, true,
+            true, true, true,
+        ];
+        IS_CALLEE_SAVE[self as usize]
+    }
+    fn is_reserved(self) -> bool {
+        false
+    }
+    fn into_index(self) -> usize {
+        self as usize
+    }
+    fn from_index(n: usize) -> Result<XMM, ()> {
+        match n {
+            0..=15 => Ok(*XMM::iterator().nth(n).unwrap()),
+            _ => Err(()),
+        }
+    }
+    fn iterator() -> Iter<'static, XMM> {
+        static XMMS: [XMM; 16] = [
+            XMM::XMM0,
+            XMM::XMM1,
+            XMM::XMM2,
+            XMM::XMM3,
+            XMM::XMM4,
+            XMM::XMM5,
+            XMM::XMM6,
+            XMM::XMM7,
+            XMM::XMM8,
+            XMM::XMM9,
+            XMM::XMM10,
+            XMM::XMM11,
+            XMM::XMM12,
+            XMM::XMM13,
+            XMM::XMM14,
+            XMM::XMM15,
+        ];
+        XMMS.iter()
+    }
+    fn to_dwarf(self) -> u16 {
+        self.into_index() as u16 + 17
+    }
+}
+
+/// A machine register under the x86-64 architecture.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum X64Register {
+    /// General-purpose registers.
+    GPR(GPR),
+    /// XMM (floating point/SIMD) registers.
+    XMM(XMM),
+}
+
+impl CombinedRegister for X64Register {
+    /// Returns the index of the register.
+    fn to_index(&self) -> RegisterIndex {
+        match *self {
+            X64Register::GPR(x) => RegisterIndex(x as usize),
+            X64Register::XMM(x) => RegisterIndex(x as usize + 16),
+        }
+    }
+    /// Convert from a GPR register
+    fn from_gpr(x: u16) -> Self {
+        X64Register::GPR(GPR::from_index(x as usize).unwrap())
+    }
+    /// Convert from an SIMD register
+    fn from_simd(x: u16) -> Self {
+        X64Register::XMM(XMM::from_index(x as usize).unwrap())
+    }
+    /* x86_64-abi-0.99.pdf
+     * Register Name                    | Number | Abbreviation
+     * General Purpose Register RAX     | 0      | %rax
+     * General Purpose Register RDX     | 1      | %rdx
+     * General Purpose Register RCX     | 2      | %rcx
+     * General Purpose Register RBX     | 3      | %rbx
+     * General Purpose Register RSI     | 4      | %rsi
+     * General Purpose Register RDI     | 5      | %rdi
+     * Frame Pointer Register   RBP     | 6      | %rbp
+     * Stack Pointer Register   RSP     | 7      | %rsp
+     * Extended Integer Registers 8-15  | 8-15   | %r8-%r15
+     * Return Address RA                | 16     |
+     * Vector Registers 0-7             | 17-24  | %xmm0-%xmm7
+     * Extended Vector Registers 8-15   | 25-32  | %xmm8-%xmm15
+     * Floating Point Registers 0-7     | 33-40  | %st0-%st7
+     * MMX Registers 0-7                | 41-48  | %mm0-%mm7
+     * Flag Register                    | 49     | %rFLAGS
+     * Segment Register ES              | 50     | %es
+     * Segment Register CS              | 51     | %cs
+     * Segment Register SS              | 52     | %ss
+     * Segment Register DS              | 53     | %ds
+     * Segment Register FS              | 54     | %fs
+     * Segment Register GS              | 55     | %gs
+     * Reserved                         | 56-57  |
+     * FS Base address                  | 58     | %fs.base
+     * GS Base address                  | 59     | %gs.base
+     * Reserved                         | 60-61  |
+     * Task Register                    | 62     | %tr
+     * LDT Register                     | 63     | %ldtr
+     * 128-bit Media Control and Status | 64     | %mxcsr
+     * x87 Control Word                 | 65     | %fcw
+     * x87 Status Word                  | 66     | %fsw
+     */
+    /// Converts a DWARF regnum to X64Register.
+    fn _from_dwarf_regnum(x: u16) -> Option<X64Register> {
+        static DWARF_REGS: [GPR; 16] = [
+            GPR::RAX,
+            GPR::RDX,
+            GPR::RCX,
+            GPR::RBX,
+            GPR::RSI,
+            GPR::RDI,
+            GPR::RBP,
+            GPR::RSP,
+            GPR::R8,
+            GPR::R9,
+            GPR::R10,
+            GPR::R11,
+            GPR::R12,
+            GPR::R13,
+            GPR::R14,
+            GPR::R15,
+        ];
+        Some(match x {
+            0..=15 => X64Register::GPR(DWARF_REGS[x as usize]),
+            17..=24 => X64Register::XMM(XMM::from_index(x as usize - 17).unwrap()),
+            _ => return None,
+        })
+    }
+}
+
+/// An allocator that allocates registers for function arguments according to the System V ABI.
+#[derive(Default)]
+pub struct ArgumentRegisterAllocator {
+    n_gprs: usize,
+    n_xmms: usize,
+}
+
+impl ArgumentRegisterAllocator {
+    /// Allocates a register for argument type `ty`. Returns `None` if no register is available for this type.
+    pub fn next(&mut self, ty: Type, calling_convention: CallingConvention) -> Option<X64Register> {
+        match calling_convention {
+            CallingConvention::WindowsFastcall => {
+                static GPR_SEQ: &[GPR] = &[GPR::RCX, GPR::RDX, GPR::R8, GPR::R9];
+                static XMM_SEQ: &[XMM] = &[XMM::XMM0, XMM::XMM1, XMM::XMM2, XMM::XMM3];
+                let idx = self.n_gprs + self.n_xmms;
+                match ty {
+                    Type::I32 | Type::I64 => {
+                        if idx < 4 {
+                            let gpr = GPR_SEQ[idx];
+                            self.n_gprs += 1;
+                            Some(X64Register::GPR(gpr))
+                        } else {
+                            None
+                        }
+                    }
+                    Type::F32 | Type::F64 => {
+                        if idx < 4 {
+                            let xmm = XMM_SEQ[idx];
+                            self.n_xmms += 1;
+                            Some(X64Register::XMM(xmm))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => todo!(
+                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
+                        ty
+                    ),
+                }
+            }
+            _ => {
+                static GPR_SEQ: &[GPR] =
+                    &[GPR::RDI, GPR::RSI, GPR::RDX, GPR::RCX, GPR::R8, GPR::R9];
+                static XMM_SEQ: &[XMM] = &[
+                    XMM::XMM0,
+                    XMM::XMM1,
+                    XMM::XMM2,
+                    XMM::XMM3,
+                    XMM::XMM4,
+                    XMM::XMM5,
+                    XMM::XMM6,
+                    XMM::XMM7,
+                ];
+                match ty {
+                    Type::I32 | Type::I64 => {
+                        if self.n_gprs < GPR_SEQ.len() {
+                            let gpr = GPR_SEQ[self.n_gprs];
+                            self.n_gprs += 1;
+                            Some(X64Register::GPR(gpr))
+                        } else {
+                            None
+                        }
+                    }
+                    Type::F32 | Type::F64 => {
+                        if self.n_xmms < XMM_SEQ.len() {
+                            let xmm = XMM_SEQ[self.n_xmms];
+                            self.n_xmms += 1;
+                            Some(X64Register::XMM(xmm))
+                        } else {
+                            None
+                        }
+                    }
+                    _ => todo!(
+                        "ArgumentRegisterAllocator::next: Unsupported type: {:?}",
+                        ty
+                    ),
+                }
+            }
+        }
+    }
+}
+
+/// Create a new `MachineState` with default values.
+pub fn new_machine_state() -> MachineState {
+    MachineState {
+        stack_values: vec![],
+        register_values: vec![MachineValue::Undefined; 16 + 8],
+        prev_frame: BTreeMap::new(),
+        wasm_stack: vec![],
+        wasm_inst_offset: std::usize::MAX,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/compiler/Cargo.toml
new file mode 100644
index 0000000..8463851
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/Cargo.toml
@@ -0,0 +1,72 @@
+[package]
+name = "wasmer-compiler"
+description = "Base compiler abstraction for Wasmer WebAssembly runtime"
+categories = ["wasm", "no-std"]
+keywords = ["wasm", "webassembly", "compiler"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer-types = { path = "../types", version = "=4.2.8", default-features = false }
+wasmer-object = { path = "../object", version = "=4.2.8", optional = true }
+wasmparser = { workspace = true, optional = true, default-features = false }
+enumset.workspace = true
+hashbrown = { version = "0.11", optional = true }
+serde = { version = "1.0", features = ["derive"], optional = true }
+thiserror = "1.0"
+serde_bytes = { version = "0.11", optional = true }
+smallvec = "1.6"
+
+backtrace = "0.3"
+memmap2 = "0.5"
+more-asserts = "0.2"
+lazy_static = "1.4"
+
+cfg-if = "1.0"
+leb128 = "0.2"
+enum-iterator = "0.7.0"
+
+bytes = "1.0"
+self_cell = "1.0"
+rkyv = { workspace = true }
+shared-buffer = { workspace = true }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+wasmer-vm = { path = "../vm", version = "=4.2.8" }
+region = { version = "3.0" }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winnt", "impl-default"] }
+
+[features]
+default = ["std"]
+# This feature is for compiler implementors, it enables using `Compiler` and
+# `CompilerConfig`, as well as the included wasmparser.
+# Disable this feature if you just want a headless engine.
+translator = ["wasmparser"]
+compiler = ["translator"]
+wasmer-artifact-load = []
+wasmer-artifact-create = []
+static-artifact-load = []
+static-artifact-create = ["wasmer-object"]
+std = ["wasmer-types/std"]
+core = ["hashbrown", "wasmer-types/core"]
+enable-serde = ["serde", "serde_bytes", "wasmer-types/enable-serde"]
+
+[badges]
+maintenance = { status = "experimental" }
+
+[package.metadata.docs.rs]
+features = [
+    "static-artifact-create",
+    "static-artifact-load",
+    "wasmer-artifact-create",
+    "wasmer-artifact-load",
+]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/README.md b/arbitrator/tools/module_roots/wasmer/lib/compiler/README.md
new file mode 100644
index 0000000..ace37ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/README.md
@@ -0,0 +1,56 @@
+# `wasmer-compiler` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate is the base for Compiler implementations.
+
+It performs the translation from a Wasm module into a basic
+`ModuleInfo`, but leaves the Wasm function bytecode translation to the
+compiler implementor.
+
+Here are some of the Compilers provided by Wasmer:
+
+* [Singlepass](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-singlepass),
+* [Cranelift](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-cranelift),
+* [LLVM](https://github.com/wasmerio/wasmer/tree/master/lib/compiler-llvm).
+
+## How to create a compiler
+
+To create a compiler, one needs to implement two traits:
+
+1. `CompilerConfig`, that configures and creates a new compiler,
+2. `Compiler`, the compiler itself that will compile a module.
+
+```rust
+/// The compiler configuration options.
+pub trait CompilerConfig {
+    /// Gets the custom compiler config
+    fn compiler(&self) -> Box<dyn Compiler>;
+}
+
+/// An implementation of a compiler from parsed WebAssembly module to compiled native code.
+pub trait Compiler {
+    /// Compiles a parsed module.
+    ///
+    /// It returns the [`Compilation`] or a [`CompileError`].
+    fn compile_module<'data, 'module>(
+        &self,
+        target: &Target,
+        compile_info: &'module CompileModuleInfo,
+        module_translation: &ModuleTranslationState,
+        // The list of function bodies
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'data>>,
+    ) -> Result<Compilation, CompileError>;
+}
+```
+
+## Acknowledgments
+
+This project borrowed some of the code strucutre from the
+[`cranelift-wasm`] crate, however it's been adapted to not depend on
+any specific IR and be abstract of any compiler.
+
+Please check [Wasmer `ATTRIBUTIONS`] to further see licenses and other
+attributions of the project.
+
+
+[`cranelift-wasm`]: https://crates.io/crates/cranelift-wasm
+[Wasmer `ATTRIBUTIONS`]: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/artifact_builder.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/artifact_builder.rs
new file mode 100644
index 0000000..cd840f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/artifact_builder.rs
@@ -0,0 +1,475 @@
+//! Define `ArtifactBuild` to allow compiling and instantiating to be
+//! done as separate steps.
+
+#[cfg(feature = "compiler")]
+use super::trampoline::{libcall_trampoline_len, make_libcall_trampolines};
+use crate::ArtifactCreate;
+use crate::EngineInner;
+use crate::Features;
+use crate::{ModuleEnvironment, ModuleMiddlewareChain};
+use core::mem::MaybeUninit;
+use enumset::EnumSet;
+use rkyv::de::deserializers::SharedDeserializeMap;
+use rkyv::option::ArchivedOption;
+use self_cell::self_cell;
+use shared_buffer::OwnedBuffer;
+use std::sync::Arc;
+use wasmer_types::entity::{ArchivedPrimaryMap, PrimaryMap};
+use wasmer_types::ArchivedOwnedDataInitializer;
+use wasmer_types::ArchivedSerializableCompilation;
+use wasmer_types::ArchivedSerializableModule;
+#[cfg(feature = "compiler")]
+use wasmer_types::CompileModuleInfo;
+use wasmer_types::DeserializeError;
+use wasmer_types::{
+    CompileError, CpuFeature, CustomSection, Dwarf, FunctionIndex, LocalFunctionIndex, MemoryIndex,
+    MemoryStyle, ModuleInfo, OwnedDataInitializer, Relocation, SectionIndex, SignatureIndex,
+    TableIndex, TableStyle, Target,
+};
+use wasmer_types::{
+    CompiledFunctionFrameInfo, FunctionBody, SerializableCompilation, SerializableModule,
+};
+use wasmer_types::{MetadataHeader, SerializeError};
+
+/// A compiled wasm module, ready to be instantiated.
+pub struct ArtifactBuild {
+    serializable: SerializableModule,
+}
+
+impl ArtifactBuild {
+    /// Header signature for wasmu binary
+    pub const MAGIC_HEADER: &'static [u8; 16] = b"wasmer-universal";
+
+    /// Check if the provided bytes look like a serialized `ArtifactBuild`.
+    pub fn is_deserializable(bytes: &[u8]) -> bool {
+        bytes.starts_with(Self::MAGIC_HEADER)
+    }
+
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
+    #[cfg(feature = "compiler")]
+    pub fn new(
+        inner_engine: &mut EngineInner,
+        data: &[u8],
+        target: &Target,
+        memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
+        table_styles: PrimaryMap<TableIndex, TableStyle>,
+    ) -> Result<Self, CompileError> {
+        let environ = ModuleEnvironment::new();
+        let features = inner_engine.features().clone();
+
+        let translation = environ.translate(data).map_err(CompileError::Wasm)?;
+
+        let compiler = inner_engine.compiler()?;
+
+        // We try to apply the middleware first
+        let mut module = translation.module;
+        let middlewares = compiler.get_middlewares();
+        middlewares.apply_on_module_info(&mut module)?;
+
+        let compile_info = CompileModuleInfo {
+            module: Arc::new(module),
+            features,
+            memory_styles,
+            table_styles,
+        };
+
+        // Compile the Module
+        let compilation = compiler.compile_module(
+            target,
+            &compile_info,
+            // SAFETY: Calling `unwrap` is correct since
+            // `environ.translate()` above will write some data into
+            // `module_translation_state`.
+            translation.module_translation_state.as_ref().unwrap(),
+            translation.function_body_inputs,
+        )?;
+
+        let data_initializers = translation
+            .data_initializers
+            .iter()
+            .map(OwnedDataInitializer::new)
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        // Synthesize a custom section to hold the libcall trampolines.
+        let mut function_frame_info = PrimaryMap::with_capacity(compilation.functions.len());
+        let mut function_bodies = PrimaryMap::with_capacity(compilation.functions.len());
+        let mut function_relocations = PrimaryMap::with_capacity(compilation.functions.len());
+        for (_, func) in compilation.functions.into_iter() {
+            function_bodies.push(func.body);
+            function_relocations.push(func.relocations);
+            function_frame_info.push(func.frame_info);
+        }
+        let mut custom_sections = compilation.custom_sections.clone();
+        let mut custom_section_relocations = compilation
+            .custom_sections
+            .iter()
+            .map(|(_, section)| section.relocations.clone())
+            .collect::<PrimaryMap<SectionIndex, _>>();
+        let libcall_trampolines_section = make_libcall_trampolines(target);
+        custom_section_relocations.push(libcall_trampolines_section.relocations.clone());
+        let libcall_trampolines = custom_sections.push(libcall_trampolines_section);
+        let libcall_trampoline_len = libcall_trampoline_len(target) as u32;
+        let cpu_features = compiler.get_cpu_features_used(target.cpu_features());
+
+        let serializable_compilation = SerializableCompilation {
+            function_bodies,
+            function_relocations,
+            function_frame_info,
+            function_call_trampolines: compilation.function_call_trampolines,
+            dynamic_function_trampolines: compilation.dynamic_function_trampolines,
+            custom_sections,
+            custom_section_relocations,
+            debug: compilation.debug,
+            libcall_trampolines,
+            libcall_trampoline_len,
+        };
+        let serializable = SerializableModule {
+            compilation: serializable_compilation,
+            compile_info,
+            data_initializers,
+            cpu_features: cpu_features.as_u64(),
+        };
+        Ok(Self { serializable })
+    }
+
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
+    #[cfg(not(feature = "compiler"))]
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn new(
+        _inner_engine: &mut EngineInner,
+        _data: &[u8],
+        _target: &Target,
+        _memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
+        _table_styles: PrimaryMap<TableIndex, TableStyle>,
+    ) -> Result<Self, CompileError> {
+        Err(CompileError::Codegen(
+            "Compilation is not enabled in the engine".to_string(),
+        ))
+    }
+
+    /// Create a new ArtifactBuild from a SerializableModule
+    pub fn from_serializable(serializable: SerializableModule) -> Self {
+        Self { serializable }
+    }
+
+    /// Get Functions Bodies ref
+    pub fn get_function_bodies_ref(&self) -> &PrimaryMap<LocalFunctionIndex, FunctionBody> {
+        &self.serializable.compilation.function_bodies
+    }
+
+    /// Get Functions Call Trampolines ref
+    pub fn get_function_call_trampolines_ref(&self) -> &PrimaryMap<SignatureIndex, FunctionBody> {
+        &self.serializable.compilation.function_call_trampolines
+    }
+
+    /// Get Dynamic Functions Call Trampolines ref
+    pub fn get_dynamic_function_trampolines_ref(&self) -> &PrimaryMap<FunctionIndex, FunctionBody> {
+        &self.serializable.compilation.dynamic_function_trampolines
+    }
+
+    /// Get Custom Sections ref
+    pub fn get_custom_sections_ref(&self) -> &PrimaryMap<SectionIndex, CustomSection> {
+        &self.serializable.compilation.custom_sections
+    }
+
+    /// Get Function Relocations
+    pub fn get_function_relocations(&self) -> &PrimaryMap<LocalFunctionIndex, Vec<Relocation>> {
+        &self.serializable.compilation.function_relocations
+    }
+
+    /// Get Function Relocations ref
+    pub fn get_custom_section_relocations_ref(&self) -> &PrimaryMap<SectionIndex, Vec<Relocation>> {
+        &self.serializable.compilation.custom_section_relocations
+    }
+
+    /// Get LibCall Trampoline Section Index
+    pub fn get_libcall_trampolines(&self) -> SectionIndex {
+        self.serializable.compilation.libcall_trampolines
+    }
+
+    /// Get LibCall Trampoline Length
+    pub fn get_libcall_trampoline_len(&self) -> usize {
+        self.serializable.compilation.libcall_trampoline_len as usize
+    }
+
+    /// Get Debug optional Dwarf ref
+    pub fn get_debug_ref(&self) -> Option<&Dwarf> {
+        self.serializable.compilation.debug.as_ref()
+    }
+
+    /// Get Function Relocations ref
+    pub fn get_frame_info_ref(&self) -> &PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo> {
+        &self.serializable.compilation.function_frame_info
+    }
+}
+
+impl<'a> ArtifactCreate<'a> for ArtifactBuild {
+    type OwnedDataInitializer = &'a OwnedDataInitializer;
+    type OwnedDataInitializerIterator = core::slice::Iter<'a, OwnedDataInitializer>;
+
+    fn create_module_info(&self) -> Arc<ModuleInfo> {
+        self.serializable.compile_info.module.clone()
+    }
+
+    fn set_module_info_name(&mut self, name: String) -> bool {
+        Arc::get_mut(&mut self.serializable.compile_info.module).map_or(false, |module_info| {
+            module_info.name = Some(name.to_string());
+            true
+        })
+    }
+
+    fn module_info(&self) -> &ModuleInfo {
+        &self.serializable.compile_info.module
+    }
+
+    fn features(&self) -> &Features {
+        &self.serializable.compile_info.features
+    }
+
+    fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        EnumSet::from_u64(self.serializable.cpu_features)
+    }
+
+    fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator {
+        self.serializable.data_initializers.iter()
+    }
+
+    fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        &self.serializable.compile_info.memory_styles
+    }
+
+    fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        &self.serializable.compile_info.table_styles
+    }
+
+    fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        serialize_module(&self.serializable)
+    }
+}
+
+/// Module loaded from an archive. Since `CompileModuleInfo` is part of the public
+/// interface of this crate and has to be mutable, it has to be deserialized completely.
+pub struct ModuleFromArchive<'a> {
+    /// The main serializable compilation object
+    pub compilation: &'a ArchivedSerializableCompilation,
+    /// Datas initializers
+    pub data_initializers: &'a rkyv::Archived<Box<[OwnedDataInitializer]>>,
+    /// CPU Feature flags for this compilation
+    pub cpu_features: u64,
+
+    // Keep the original module around for re-serialization
+    original_module: &'a ArchivedSerializableModule,
+}
+
+impl<'a> ModuleFromArchive<'a> {
+    /// Create a new `ModuleFromArchive` from the archived version of a `SerializableModule`
+    pub fn from_serializable_module(
+        module: &'a ArchivedSerializableModule,
+    ) -> Result<Self, DeserializeError> {
+        Ok(Self {
+            compilation: &module.compilation,
+            data_initializers: &module.data_initializers,
+            cpu_features: module.cpu_features,
+            original_module: module,
+        })
+    }
+}
+
+self_cell!(
+    struct ArtifactBuildFromArchiveCell {
+        owner: OwnedBuffer,
+
+        #[covariant]
+        dependent: ModuleFromArchive,
+    }
+);
+
+/// A compiled wasm module that was loaded from a serialized archive.
+pub struct ArtifactBuildFromArchive {
+    cell: ArtifactBuildFromArchiveCell,
+
+    /// Compilation informations
+    compile_info: CompileModuleInfo,
+}
+
+impl ArtifactBuildFromArchive {
+    pub(crate) fn try_new(
+        buffer: OwnedBuffer,
+        module_builder: impl FnOnce(
+            &OwnedBuffer,
+        ) -> Result<&ArchivedSerializableModule, DeserializeError>,
+    ) -> Result<Self, DeserializeError> {
+        let mut compile_info = MaybeUninit::uninit();
+
+        let cell = ArtifactBuildFromArchiveCell::try_new(buffer, |buffer| {
+            let module = module_builder(buffer)?;
+            let mut deserializer = SharedDeserializeMap::new();
+            compile_info = MaybeUninit::new(
+                rkyv::Deserialize::deserialize(&module.compile_info, &mut deserializer)
+                    .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))?,
+            );
+            ModuleFromArchive::from_serializable_module(module)
+        })?;
+
+        // Safety: we know the lambda will execute before getting here and assign both values
+        let compile_info = unsafe { compile_info.assume_init() };
+        Ok(Self { cell, compile_info })
+    }
+
+    /// Get Functions Bodies ref
+    pub fn get_function_bodies_ref(&self) -> &ArchivedPrimaryMap<LocalFunctionIndex, FunctionBody> {
+        &self.cell.borrow_dependent().compilation.function_bodies
+    }
+
+    /// Get Functions Call Trampolines ref
+    pub fn get_function_call_trampolines_ref(
+        &self,
+    ) -> &ArchivedPrimaryMap<SignatureIndex, FunctionBody> {
+        &self
+            .cell
+            .borrow_dependent()
+            .compilation
+            .function_call_trampolines
+    }
+
+    /// Get Dynamic Functions Call Trampolines ref
+    pub fn get_dynamic_function_trampolines_ref(
+        &self,
+    ) -> &ArchivedPrimaryMap<FunctionIndex, FunctionBody> {
+        &self
+            .cell
+            .borrow_dependent()
+            .compilation
+            .dynamic_function_trampolines
+    }
+
+    /// Get Custom Sections ref
+    pub fn get_custom_sections_ref(&self) -> &ArchivedPrimaryMap<SectionIndex, CustomSection> {
+        &self.cell.borrow_dependent().compilation.custom_sections
+    }
+
+    /// Get Function Relocations
+    pub fn get_function_relocations(
+        &self,
+    ) -> &ArchivedPrimaryMap<LocalFunctionIndex, Vec<Relocation>> {
+        &self
+            .cell
+            .borrow_dependent()
+            .compilation
+            .function_relocations
+    }
+
+    /// Get Function Relocations ref
+    pub fn get_custom_section_relocations_ref(
+        &self,
+    ) -> &ArchivedPrimaryMap<SectionIndex, Vec<Relocation>> {
+        &self
+            .cell
+            .borrow_dependent()
+            .compilation
+            .custom_section_relocations
+    }
+
+    /// Get LibCall Trampoline Section Index
+    pub fn get_libcall_trampolines(&self) -> SectionIndex {
+        self.cell.borrow_dependent().compilation.libcall_trampolines
+    }
+
+    /// Get LibCall Trampoline Length
+    pub fn get_libcall_trampoline_len(&self) -> usize {
+        self.cell
+            .borrow_dependent()
+            .compilation
+            .libcall_trampoline_len as usize
+    }
+
+    /// Get Debug optional Dwarf ref
+    pub fn get_debug_ref(&self) -> Option<&Dwarf> {
+        match self.cell.borrow_dependent().compilation.debug {
+            ArchivedOption::Some(ref x) => Some(x),
+            ArchivedOption::None => None,
+        }
+    }
+
+    /// Get Function Relocations ref
+    pub fn deserialize_frame_info_ref(
+        &self,
+    ) -> Result<PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>, DeserializeError> {
+        let mut deserializer = SharedDeserializeMap::new();
+        rkyv::Deserialize::deserialize(
+            &self.cell.borrow_dependent().compilation.function_frame_info,
+            &mut deserializer,
+        )
+        .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
+    }
+}
+
+impl<'a> ArtifactCreate<'a> for ArtifactBuildFromArchive {
+    type OwnedDataInitializer = &'a ArchivedOwnedDataInitializer;
+    type OwnedDataInitializerIterator = core::slice::Iter<'a, ArchivedOwnedDataInitializer>;
+
+    fn create_module_info(&self) -> Arc<ModuleInfo> {
+        self.compile_info.module.clone()
+    }
+
+    fn set_module_info_name(&mut self, name: String) -> bool {
+        Arc::get_mut(&mut self.compile_info.module).map_or(false, |module_info| {
+            module_info.name = Some(name.to_string());
+            true
+        })
+    }
+
+    fn module_info(&self) -> &ModuleInfo {
+        &self.compile_info.module
+    }
+
+    fn features(&self) -> &Features {
+        &self.compile_info.features
+    }
+
+    fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        EnumSet::from_u64(self.cell.borrow_dependent().cpu_features)
+    }
+
+    fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator {
+        self.cell.borrow_dependent().data_initializers.iter()
+    }
+
+    fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        &self.compile_info.memory_styles
+    }
+
+    fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        &self.compile_info.table_styles
+    }
+
+    fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        // We could have stored the original bytes, but since the module info name
+        // is mutable, we have to assume the data may have changed and serialize
+        // everything all over again. Also, to be able to serialize, first we have
+        // to deserialize completely. Luckily, serializing a module that was already
+        // deserialized from a file makes little sense, so hopefully, this is not a
+        // common use-case.
+
+        let mut deserializer = SharedDeserializeMap::new();
+        let mut module: SerializableModule = rkyv::Deserialize::deserialize(
+            self.cell.borrow_dependent().original_module,
+            &mut deserializer,
+        )
+        .map_err(|e| SerializeError::Generic(e.to_string()))?;
+        module.compile_info = self.compile_info.clone();
+        serialize_module(&module)
+    }
+}
+
+fn serialize_module(module: &SerializableModule) -> Result<Vec<u8>, SerializeError> {
+    let serialized_data = module.serialize()?;
+    assert!(std::mem::align_of::<SerializableModule>() <= MetadataHeader::ALIGN);
+
+    let mut metadata_binary = vec![];
+    metadata_binary.extend(ArtifactBuild::MAGIC_HEADER);
+    metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
+    metadata_binary.extend(serialized_data);
+    Ok(metadata_binary)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/mod.rs
new file mode 100644
index 0000000..91809c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/mod.rs
@@ -0,0 +1,7 @@
+//! Generic Artifact abstraction for Wasmer Engines.
+
+mod artifact_builder;
+mod trampoline;
+
+pub use self::artifact_builder::{ArtifactBuild, ArtifactBuildFromArchive, ModuleFromArchive};
+pub use self::trampoline::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/trampoline.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/trampoline.rs
new file mode 100644
index 0000000..387b626
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/artifact_builders/trampoline.rs
@@ -0,0 +1,108 @@
+//! Trampolines for libcalls.
+//!
+//! This is needed because the target of libcall relocations are not reachable
+//! through normal branch instructions.
+
+use enum_iterator::IntoEnumIterator;
+use wasmer_types::{
+    Architecture, CustomSection, CustomSectionProtection, LibCall, Relocation, RelocationKind,
+    RelocationTarget, SectionBody, Target,
+};
+
+// SystemV says that both x16 and x17 are available as intra-procedural scratch
+// registers but Apple's ABI restricts us to use x17.
+// LDR x17, [PC, #8]  51 00 00 58
+// BR x17             20 02 1f d6
+// JMPADDR            00 00 00 00 00 00 00 00
+const AARCH64_TRAMPOLINE: [u8; 16] = [
+    0x51, 0x00, 0x00, 0x58, 0x20, 0x02, 0x1f, 0xd6, 0, 0, 0, 0, 0, 0, 0, 0,
+];
+
+// 2 padding bytes are used to preserve alignment.
+// JMP [RIP + 2]   FF 25 02 00 00 00 [00 00]
+// 64-bit ADDR     00 00 00 00 00 00 00 00
+const X86_64_TRAMPOLINE: [u8; 16] = [
+    0xff, 0x25, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+];
+
+// can it be shorter than this?
+// 4 padding bytes are used to preserve alignment.
+// AUIPC t1,0     17 03 00 00
+// LD t1, 16(t1)  03 33 03 01
+// JR t1          67 00 03 00 [00 00 00 00]
+// JMPADDR        00 00 00 00 00 00 00 00
+const RISCV64_TRAMPOLINE: [u8; 24] = [
+    0x17, 0x03, 0x00, 0x00, 0x03, 0x33, 0x03, 0x01, 0x67, 0x00, 0x03, 0x00, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0,
+];
+
+fn make_trampoline(
+    target: &Target,
+    libcall: LibCall,
+    code: &mut Vec<u8>,
+    relocations: &mut Vec<Relocation>,
+) {
+    match target.triple().architecture {
+        Architecture::Aarch64(_) => {
+            code.extend(AARCH64_TRAMPOLINE);
+            relocations.push(Relocation {
+                kind: RelocationKind::Abs8,
+                reloc_target: RelocationTarget::LibCall(libcall),
+                offset: code.len() as u32 - 8,
+                addend: 0,
+            });
+        }
+        Architecture::X86_64 => {
+            code.extend(X86_64_TRAMPOLINE);
+            relocations.push(Relocation {
+                kind: RelocationKind::Abs8,
+                reloc_target: RelocationTarget::LibCall(libcall),
+                offset: code.len() as u32 - 8,
+                addend: 0,
+            });
+        }
+        Architecture::Riscv64(_) => {
+            code.extend(RISCV64_TRAMPOLINE);
+            relocations.push(Relocation {
+                kind: RelocationKind::Abs8,
+                reloc_target: RelocationTarget::LibCall(libcall),
+                offset: code.len() as u32 - 8,
+                addend: 0,
+            });
+        }
+        arch => panic!("Unsupported architecture: {}", arch),
+    };
+}
+
+/// Returns the length of a libcall trampoline.
+pub fn libcall_trampoline_len(target: &Target) -> usize {
+    match target.triple().architecture {
+        Architecture::Aarch64(_) => AARCH64_TRAMPOLINE.len(),
+        Architecture::X86_64 => X86_64_TRAMPOLINE.len(),
+        Architecture::Riscv64(_) => RISCV64_TRAMPOLINE.len(),
+        arch => panic!("Unsupported architecture: {}", arch),
+    }
+}
+
+/// Creates a custom section containing the libcall trampolines.
+pub fn make_libcall_trampolines(target: &Target) -> CustomSection {
+    let mut code = vec![];
+    let mut relocations = vec![];
+    for libcall in LibCall::into_enum_iter() {
+        make_trampoline(target, libcall, &mut code, &mut relocations);
+    }
+    CustomSection {
+        protection: CustomSectionProtection::ReadExecute,
+        bytes: SectionBody::new_with_vec(code),
+        relocations,
+    }
+}
+
+/// Returns the address of a trampoline in the libcall trampolines section.
+pub fn get_libcall_trampoline(
+    libcall: LibCall,
+    libcall_trampolines: usize,
+    libcall_trampoline_len: usize,
+) -> usize {
+    libcall_trampolines + libcall as usize * libcall_trampoline_len
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/compiler.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/compiler.rs
new file mode 100644
index 0000000..e654948
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/compiler.rs
@@ -0,0 +1,149 @@
+//! This module mainly outputs the `Compiler` trait that custom
+//! compilers will need to implement.
+
+use crate::lib::std::boxed::Box;
+use crate::lib::std::sync::Arc;
+use crate::translator::ModuleMiddleware;
+use crate::FunctionBodyData;
+use crate::ModuleTranslationState;
+use enumset::EnumSet;
+use wasmer_types::compilation::function::Compilation;
+use wasmer_types::compilation::module::CompileModuleInfo;
+use wasmer_types::compilation::symbols::SymbolRegistry;
+use wasmer_types::compilation::target::Target;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::error::CompileError;
+use wasmer_types::{CpuFeature, Features, LocalFunctionIndex};
+use wasmparser::{Validator, WasmFeatures};
+
+/// The compiler configuration options.
+pub trait CompilerConfig {
+    /// Enable Position Independent Code (PIC).
+    ///
+    /// This is required for shared object generation (Native Engine),
+    /// but will make the JIT Engine to fail, since PIC is not yet
+    /// supported in the JIT linking phase.
+    fn enable_pic(&mut self) {
+        // By default we do nothing, each backend will need to customize this
+        // in case they do something special for emitting PIC code.
+    }
+
+    /// Enable compiler IR verification.
+    ///
+    /// For compilers capable of doing so, this enables internal consistency
+    /// checking.
+    fn enable_verifier(&mut self) {
+        // By default we do nothing, each backend will need to customize this
+        // in case they create an IR that they can verify.
+    }
+
+    /// Enable NaN canonicalization.
+    ///
+    /// NaN canonicalization is useful when trying to run WebAssembly
+    /// deterministically across different architectures.
+    fn canonicalize_nans(&mut self, _enable: bool) {
+        // By default we do nothing, each backend will need to customize this
+        // in case they create an IR that they can verify.
+    }
+
+    /// Gets the custom compiler config
+    fn compiler(self: Box<Self>) -> Box<dyn Compiler>;
+
+    /// Gets the default features for this compiler in the given target
+    fn default_features_for_target(&self, _target: &Target) -> Features {
+        Features::default()
+    }
+
+    /// Pushes a middleware onto the back of the middleware chain.
+    fn push_middleware(&mut self, middleware: Arc<dyn ModuleMiddleware>);
+}
+
+impl<T> From<T> for Box<dyn CompilerConfig + 'static>
+where
+    T: CompilerConfig + 'static,
+{
+    fn from(other: T) -> Self {
+        Box::new(other)
+    }
+}
+
+/// An implementation of a Compiler from parsed WebAssembly module to Compiled native code.
+pub trait Compiler: Send {
+    /// Returns a descriptive name for this compiler.
+    ///
+    /// Note that this is an API breaking change since 3.0
+    fn name(&self) -> &str;
+
+    /// Validates a module.
+    ///
+    /// It returns the a succesful Result in case is valid, `CompileError` in case is not.
+    fn validate_module(&self, features: &Features, data: &[u8]) -> Result<(), CompileError> {
+        let wasm_features = WasmFeatures {
+            bulk_memory: features.bulk_memory,
+            threads: features.threads,
+            reference_types: features.reference_types,
+            multi_value: features.multi_value,
+            simd: features.simd,
+            tail_call: features.tail_call,
+            multi_memory: features.multi_memory,
+            memory64: features.memory64,
+            exceptions: features.exceptions,
+            extended_const: features.extended_const,
+            relaxed_simd: features.relaxed_simd,
+            mutable_global: true,
+            saturating_float_to_int: true,
+            floats: true,
+            sign_extension: true,
+
+            // Not supported
+            component_model: false,
+            function_references: false,
+            memory_control: false,
+            gc: false,
+            component_model_values: false,
+            component_model_nested_names: false,
+        };
+        let mut validator = Validator::new_with_features(wasm_features);
+        validator
+            .validate_all(data)
+            .map_err(|e| CompileError::Validate(format!("{}", e)))?;
+        Ok(())
+    }
+
+    /// Compiles a parsed module.
+    ///
+    /// It returns the [`Compilation`] or a [`CompileError`].
+    fn compile_module(
+        &self,
+        target: &Target,
+        module: &CompileModuleInfo,
+        module_translation: &ModuleTranslationState,
+        // The list of function bodies
+        function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+    ) -> Result<Compilation, CompileError>;
+
+    /// Compiles a module into a native object file.
+    ///
+    /// It returns the bytes as a `&[u8]` or a [`CompileError`].
+    fn experimental_native_compile_module(
+        &self,
+        _target: &Target,
+        _module: &CompileModuleInfo,
+        _module_translation: &ModuleTranslationState,
+        // The list of function bodies
+        _function_body_inputs: &PrimaryMap<LocalFunctionIndex, FunctionBodyData<'_>>,
+        _symbol_registry: &dyn SymbolRegistry,
+        // The metadata to inject into the wasmer_metadata section of the object file.
+        _wasmer_metadata: &[u8],
+    ) -> Option<Result<Vec<u8>, CompileError>> {
+        None
+    }
+
+    /// Get the middlewares for this compiler
+    fn get_middlewares(&self) -> &[Arc<dyn ModuleMiddleware>];
+
+    /// Get the CpuFeatues used by the compiler
+    fn get_cpu_features_used(&self, cpu_features: &EnumSet<CpuFeature>) -> EnumSet<CpuFeature> {
+        *cpu_features
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/artifact.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/artifact.rs
new file mode 100644
index 0000000..a02183b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/artifact.rs
@@ -0,0 +1,1195 @@
+//! Define `Artifact`, based on `ArtifactBuild`
+//! to allow compiling and instantiating to be done as separate steps.
+
+use crate::engine::link::link_module;
+use crate::lib::std::vec::IntoIter;
+use crate::ArtifactBuild;
+use crate::ArtifactBuildFromArchive;
+use crate::ArtifactCreate;
+use crate::Features;
+use crate::ModuleEnvironment;
+use crate::{
+    register_frame_info, resolve_imports, FunctionExtent, GlobalFrameInfoRegistration,
+    InstantiationError, Tunables,
+};
+#[cfg(feature = "static-artifact-create")]
+use crate::{Compiler, FunctionBodyData, ModuleTranslationState};
+use crate::{Engine, EngineInner};
+use enumset::EnumSet;
+use shared_buffer::OwnedBuffer;
+#[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
+use std::mem;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::sync::Arc;
+#[cfg(feature = "static-artifact-create")]
+use wasmer_object::{emit_compilation, emit_data, get_object_for_target, Object};
+#[cfg(any(feature = "static-artifact-create", feature = "static-artifact-load"))]
+use wasmer_types::compilation::symbols::ModuleMetadata;
+use wasmer_types::entity::{BoxedSlice, PrimaryMap};
+use wasmer_types::ArchivedDataInitializerLocation;
+use wasmer_types::ArchivedOwnedDataInitializer;
+#[cfg(feature = "static-artifact-create")]
+use wasmer_types::CompileModuleInfo;
+use wasmer_types::DataInitializerLike;
+use wasmer_types::DataInitializerLocation;
+use wasmer_types::DataInitializerLocationLike;
+use wasmer_types::MetadataHeader;
+use wasmer_types::{
+    CompileError, CpuFeature, DataInitializer, DeserializeError, FunctionIndex, LocalFunctionIndex,
+    MemoryIndex, ModuleInfo, OwnedDataInitializer, SignatureIndex, TableIndex, Target,
+};
+use wasmer_types::{SerializableModule, SerializeError};
+use wasmer_vm::{FunctionBodyPtr, MemoryStyle, TableStyle, VMSharedSignatureIndex, VMTrampoline};
+use wasmer_vm::{InstanceAllocator, StoreObjects, TrapHandlerFn, VMConfig, VMExtern, VMInstance};
+
+pub struct AllocatedArtifact {
+    // This shows if the frame info has been regestered already or not.
+    // Because the 'GlobalFrameInfoRegistration' ownership can be transfered to EngineInner
+    // this bool is needed to track the status, as 'frame_info_registration' will be None
+    // after the ownership is transfered.
+    frame_info_registered: bool,
+    // frame_info_registered is not staying there but transfered to CodeMemory from EngineInner
+    // using 'Artifact::take_frame_info_registration' method
+    // so the GloabelFrameInfo and MMap stays in sync and get dropped at the same time
+    frame_info_registration: Option<GlobalFrameInfoRegistration>,
+    finished_functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
+    finished_function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
+    finished_dynamic_function_trampolines: BoxedSlice<FunctionIndex, FunctionBodyPtr>,
+    signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
+    finished_function_lengths: BoxedSlice<LocalFunctionIndex, usize>,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(transparent)]
+/// A unique identifier for an Artifact.
+pub struct ArtifactId {
+    id: usize,
+}
+
+impl ArtifactId {
+    /// Format this identifier as a string.
+    pub fn id(&self) -> String {
+        format!("{}", &self.id)
+    }
+}
+
+impl Clone for ArtifactId {
+    fn clone(&self) -> Self {
+        Self::default()
+    }
+}
+
+impl Default for ArtifactId {
+    fn default() -> Self {
+        static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+        Self {
+            id: NEXT_ID.fetch_add(1, SeqCst),
+        }
+    }
+}
+
+/// A compiled wasm module, ready to be instantiated.
+pub struct Artifact {
+    id: ArtifactId,
+    artifact: ArtifactBuildVariant,
+    // The artifact will only be allocated in memory in case we can execute it
+    // (that means, if the target != host then this will be None).
+    allocated: Option<AllocatedArtifact>,
+}
+
+/// Artifacts may be created as the result of the compilation of a wasm
+/// module, corresponding to `ArtifactBuildVariant::Plain`, or loaded
+/// from an archive, corresponding to `ArtifactBuildVariant::Archived`.
+pub enum ArtifactBuildVariant {
+    Plain(ArtifactBuild),
+    Archived(ArtifactBuildFromArchive),
+}
+
+impl Artifact {
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
+    #[cfg(feature = "compiler")]
+    pub fn new(
+        engine: &Engine,
+        data: &[u8],
+        tunables: &dyn Tunables,
+    ) -> Result<Self, CompileError> {
+        let mut inner_engine = engine.inner_mut();
+        let environ = ModuleEnvironment::new();
+        let translation = environ.translate(data).map_err(CompileError::Wasm)?;
+        let module = translation.module;
+        let memory_styles: PrimaryMap<MemoryIndex, MemoryStyle> = module
+            .memories
+            .values()
+            .map(|memory_type| tunables.memory_style(memory_type))
+            .collect();
+        let table_styles: PrimaryMap<TableIndex, TableStyle> = module
+            .tables
+            .values()
+            .map(|table_type| tunables.table_style(table_type))
+            .collect();
+
+        let artifact = ArtifactBuild::new(
+            &mut inner_engine,
+            data,
+            engine.target(),
+            memory_styles,
+            table_styles,
+        )?;
+
+        Self::from_parts(
+            &mut inner_engine,
+            ArtifactBuildVariant::Plain(artifact),
+            engine.target(),
+        )
+        .map_err(|e| match e {
+            DeserializeError::Compiler(c) => c,
+
+            // `from_parts` only ever returns `CompileError`s when an
+            // `ArtifactBuildVariant::Plain` is passed in. Other cases
+            // of `DeserializeError` can only happen when an
+            // `ArtifactBuildVariant::Archived` is passed in. We don't
+            // wish to change the return type of this method because
+            // a. it makes no sense and b. it would be a breaking change,
+            // hence this match block and the other cases being
+            // unreachable.
+            _ => unreachable!(),
+        })
+    }
+
+    /// This indicates if the Artifact is allocated and can be run by the current
+    /// host. In case it can't be run (for example, if the artifact is cross compiled to
+    /// other architecture), it will return false.
+    pub fn allocated(&self) -> bool {
+        self.allocated.is_some()
+    }
+
+    /// A unique identifier for this object.
+    ///
+    /// This exists to allow us to compare two Artifacts for equality. Otherwise,
+    /// comparing two trait objects unsafely relies on implementation details
+    /// of trait representation.
+    pub fn id(&self) -> &ArtifactId {
+        &self.id
+    }
+
+    /// Compile a data buffer into a `ArtifactBuild`, which may then be instantiated.
+    #[cfg(not(feature = "compiler"))]
+    pub fn new(_engine: &Engine, _data: &[u8]) -> Result<Self, CompileError> {
+        Err(CompileError::Codegen(
+            "Compilation is not enabled in the engine".to_string(),
+        ))
+    }
+
+    /// Deserialize a serialized artifact.
+    ///
+    /// # Safety
+    /// This function loads executable code into memory.
+    /// You must trust the loaded bytes to be valid for the chosen engine and
+    /// for the host CPU architecture.
+    /// In contrast to [`Self::deserialize_unchecked`] the artifact layout is
+    /// validated, which increases safety.
+    pub unsafe fn deserialize(
+        engine: &Engine,
+        bytes: OwnedBuffer,
+    ) -> Result<Self, DeserializeError> {
+        if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
+            let static_artifact = Self::deserialize_object(engine, bytes);
+            match static_artifact {
+                Ok(v) => {
+                    return Ok(v);
+                }
+                Err(_) => {
+                    return Err(DeserializeError::Incompatible(
+                        "The provided bytes are not wasmer-universal".to_string(),
+                    ));
+                }
+            }
+        }
+
+        let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
+            let bytes =
+                Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
+
+            let metadata_len = MetadataHeader::parse(bytes)?;
+            let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+            let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+
+            SerializableModule::archive_from_slice_checked(metadata_slice)
+        })?;
+
+        let mut inner_engine = engine.inner_mut();
+        Self::from_parts(
+            &mut inner_engine,
+            ArtifactBuildVariant::Archived(artifact),
+            engine.target(),
+        )
+    }
+
+    /// Deserialize a serialized artifact.
+    ///
+    /// NOTE: You should prefer [`Self::deserialize`].
+    ///
+    /// # Safety
+    /// See [`Self::deserialize`].
+    /// In contrast to the above, this function skips artifact layout validation,
+    /// which increases the risk of loading invalid artifacts.
+    pub unsafe fn deserialize_unchecked(
+        engine: &Engine,
+        bytes: OwnedBuffer,
+    ) -> Result<Self, DeserializeError> {
+        if !ArtifactBuild::is_deserializable(bytes.as_ref()) {
+            let static_artifact = Self::deserialize_object(engine, bytes);
+            match static_artifact {
+                Ok(v) => {
+                    return Ok(v);
+                }
+                Err(_) => {
+                    return Err(DeserializeError::Incompatible(
+                        "The provided bytes are not wasmer-universal".to_string(),
+                    ));
+                }
+            }
+        }
+
+        let artifact = ArtifactBuildFromArchive::try_new(bytes, |bytes| {
+            let bytes =
+                Self::get_byte_slice(bytes, ArtifactBuild::MAGIC_HEADER.len(), bytes.len())?;
+
+            let metadata_len = MetadataHeader::parse(bytes)?;
+            let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+            let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+
+            SerializableModule::archive_from_slice(metadata_slice)
+        })?;
+
+        let mut inner_engine = engine.inner_mut();
+        Self::from_parts(
+            &mut inner_engine,
+            ArtifactBuildVariant::Archived(artifact),
+            engine.target(),
+        )
+    }
+
+    /// Construct a `ArtifactBuild` from component parts.
+    pub fn from_parts(
+        engine_inner: &mut EngineInner,
+        artifact: ArtifactBuildVariant,
+        target: &Target,
+    ) -> Result<Self, DeserializeError> {
+        if !target.is_native() {
+            return Ok(Self {
+                id: Default::default(),
+                artifact,
+                allocated: None,
+            });
+        } else {
+            // check if cpu features are compatible before anything else
+            let cpu_features = artifact.cpu_features();
+            if !target.cpu_features().is_superset(cpu_features) {
+                return Err(DeserializeError::Incompatible(format!(
+                    "Some CPU Features needed for the artifact are missing: {:?}",
+                    cpu_features.difference(*target.cpu_features())
+                )));
+            }
+        }
+        let module_info = artifact.module_info();
+        let (
+            finished_functions,
+            finished_function_call_trampolines,
+            finished_dynamic_function_trampolines,
+            custom_sections,
+        ) = match &artifact {
+            ArtifactBuildVariant::Plain(p) => engine_inner.allocate(
+                module_info,
+                p.get_function_bodies_ref().values(),
+                p.get_function_call_trampolines_ref().values(),
+                p.get_dynamic_function_trampolines_ref().values(),
+                p.get_custom_sections_ref().values(),
+            )?,
+            ArtifactBuildVariant::Archived(a) => engine_inner.allocate(
+                module_info,
+                a.get_function_bodies_ref().values(),
+                a.get_function_call_trampolines_ref().values(),
+                a.get_dynamic_function_trampolines_ref().values(),
+                a.get_custom_sections_ref().values(),
+            )?,
+        };
+
+        match &artifact {
+            ArtifactBuildVariant::Plain(p) => link_module(
+                module_info,
+                &finished_functions,
+                p.get_function_relocations()
+                    .iter()
+                    .map(|(k, v)| (k, v.iter())),
+                &custom_sections,
+                p.get_custom_section_relocations_ref()
+                    .iter()
+                    .map(|(k, v)| (k, v.iter())),
+                p.get_libcall_trampolines(),
+                p.get_libcall_trampoline_len(),
+            ),
+            ArtifactBuildVariant::Archived(a) => link_module(
+                module_info,
+                &finished_functions,
+                a.get_function_relocations()
+                    .iter()
+                    .map(|(k, v)| (k, v.iter())),
+                &custom_sections,
+                a.get_custom_section_relocations_ref()
+                    .iter()
+                    .map(|(k, v)| (k, v.iter())),
+                a.get_libcall_trampolines(),
+                a.get_libcall_trampoline_len(),
+            ),
+        };
+
+        // Compute indices into the shared signature table.
+        let signatures = {
+            let signature_registry = engine_inner.signatures();
+            module_info
+                .signatures
+                .values()
+                .map(|sig| signature_registry.register(sig))
+                .collect::<PrimaryMap<_, _>>()
+        };
+
+        let debug_ref = match &artifact {
+            ArtifactBuildVariant::Plain(p) => p.get_debug_ref(),
+            ArtifactBuildVariant::Archived(a) => a.get_debug_ref(),
+        };
+        let eh_frame = match debug_ref {
+            Some(debug) => {
+                let eh_frame_section_size = match &artifact {
+                    ArtifactBuildVariant::Plain(p) => {
+                        p.get_custom_sections_ref()[debug.eh_frame].bytes.len()
+                    }
+                    ArtifactBuildVariant::Archived(a) => {
+                        a.get_custom_sections_ref()[debug.eh_frame].bytes.len()
+                    }
+                };
+                let eh_frame_section_pointer = custom_sections[debug.eh_frame];
+                Some(unsafe {
+                    std::slice::from_raw_parts(*eh_frame_section_pointer, eh_frame_section_size)
+                })
+            }
+            None => None,
+        };
+
+        // Make all code compiled thus far executable.
+        engine_inner.publish_compiled_code();
+
+        engine_inner.publish_eh_frame(eh_frame)?;
+
+        let finished_function_lengths = finished_functions
+            .values()
+            .map(|extent| extent.length)
+            .collect::<PrimaryMap<LocalFunctionIndex, usize>>()
+            .into_boxed_slice();
+        let finished_functions = finished_functions
+            .values()
+            .map(|extent| extent.ptr)
+            .collect::<PrimaryMap<LocalFunctionIndex, FunctionBodyPtr>>()
+            .into_boxed_slice();
+        let finished_function_call_trampolines =
+            finished_function_call_trampolines.into_boxed_slice();
+        let finished_dynamic_function_trampolines =
+            finished_dynamic_function_trampolines.into_boxed_slice();
+        let signatures = signatures.into_boxed_slice();
+
+        let mut artifact = Self {
+            id: Default::default(),
+            artifact,
+            allocated: Some(AllocatedArtifact {
+                frame_info_registered: false,
+                frame_info_registration: None,
+                finished_functions,
+                finished_function_call_trampolines,
+                finished_dynamic_function_trampolines,
+                signatures,
+                finished_function_lengths,
+            }),
+        };
+
+        artifact
+            .internal_register_frame_info()
+            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))?;
+        if let Some(frame_info) = artifact.internal_take_frame_info_registration() {
+            engine_inner.register_frame_info(frame_info);
+        }
+
+        Ok(artifact)
+    }
+
+    /// Check if the provided bytes look like a serialized `ArtifactBuild`.
+    pub fn is_deserializable(bytes: &[u8]) -> bool {
+        ArtifactBuild::is_deserializable(bytes)
+    }
+}
+
+impl PartialEq for Artifact {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+impl Eq for Artifact {}
+
+impl std::fmt::Debug for Artifact {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Artifact")
+            .field("artifact_id", &self.id)
+            .field("module_info", &self.module_info())
+            .finish()
+    }
+}
+
+impl<'a> ArtifactCreate<'a> for Artifact {
+    type OwnedDataInitializer = <ArtifactBuildVariant as ArtifactCreate<'a>>::OwnedDataInitializer;
+    type OwnedDataInitializerIterator =
+        <ArtifactBuildVariant as ArtifactCreate<'a>>::OwnedDataInitializerIterator;
+
+    fn set_module_info_name(&mut self, name: String) -> bool {
+        self.artifact.set_module_info_name(name)
+    }
+
+    fn create_module_info(&self) -> Arc<ModuleInfo> {
+        self.artifact.create_module_info()
+    }
+
+    fn module_info(&self) -> &ModuleInfo {
+        self.artifact.module_info()
+    }
+
+    fn features(&self) -> &Features {
+        self.artifact.features()
+    }
+
+    fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        self.artifact.cpu_features()
+    }
+
+    fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator {
+        self.artifact.data_initializers()
+    }
+
+    fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        self.artifact.memory_styles()
+    }
+
+    fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        self.artifact.table_styles()
+    }
+
+    fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        self.artifact.serialize()
+    }
+}
+
+impl<'a> ArtifactCreate<'a> for ArtifactBuildVariant {
+    type OwnedDataInitializer = OwnedDataInitializerVariant<'a>;
+    type OwnedDataInitializerIterator = IntoIter<Self::OwnedDataInitializer>;
+
+    fn create_module_info(&self) -> Arc<ModuleInfo> {
+        match self {
+            Self::Plain(artifact) => artifact.create_module_info(),
+            Self::Archived(artifact) => artifact.create_module_info(),
+        }
+    }
+
+    fn set_module_info_name(&mut self, name: String) -> bool {
+        match self {
+            Self::Plain(artifact) => artifact.set_module_info_name(name),
+            Self::Archived(artifact) => artifact.set_module_info_name(name),
+        }
+    }
+
+    fn module_info(&self) -> &ModuleInfo {
+        match self {
+            Self::Plain(artifact) => artifact.module_info(),
+            Self::Archived(artifact) => artifact.module_info(),
+        }
+    }
+
+    fn features(&self) -> &Features {
+        match self {
+            Self::Plain(artifact) => artifact.features(),
+            Self::Archived(artifact) => artifact.features(),
+        }
+    }
+
+    fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        match self {
+            Self::Plain(artifact) => artifact.cpu_features(),
+            Self::Archived(artifact) => artifact.cpu_features(),
+        }
+    }
+
+    fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        match self {
+            Self::Plain(artifact) => artifact.memory_styles(),
+            Self::Archived(artifact) => artifact.memory_styles(),
+        }
+    }
+
+    fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        match self {
+            Self::Plain(artifact) => artifact.table_styles(),
+            Self::Archived(artifact) => artifact.table_styles(),
+        }
+    }
+
+    fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator {
+        match self {
+            Self::Plain(artifact) => artifact
+                .data_initializers()
+                .map(OwnedDataInitializerVariant::Plain)
+                .collect::<Vec<_>>()
+                .into_iter(),
+            Self::Archived(artifact) => artifact
+                .data_initializers()
+                .map(OwnedDataInitializerVariant::Archived)
+                .collect::<Vec<_>>()
+                .into_iter(),
+        }
+    }
+
+    fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        match self {
+            Self::Plain(artifact) => artifact.serialize(),
+            Self::Archived(artifact) => artifact.serialize(),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum OwnedDataInitializerVariant<'a> {
+    Plain(&'a OwnedDataInitializer),
+    Archived(&'a ArchivedOwnedDataInitializer),
+}
+
+impl<'a> DataInitializerLike<'a> for OwnedDataInitializerVariant<'a> {
+    type Location = DataInitializerLocationVariant<'a>;
+
+    fn location(&self) -> Self::Location {
+        match self {
+            Self::Plain(plain) => DataInitializerLocationVariant::Plain(plain.location()),
+            Self::Archived(archived) => {
+                DataInitializerLocationVariant::Archived(archived.location())
+            }
+        }
+    }
+
+    fn data(&self) -> &'a [u8] {
+        match self {
+            Self::Plain(plain) => plain.data(),
+            Self::Archived(archived) => archived.data(),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum DataInitializerLocationVariant<'a> {
+    Plain(&'a DataInitializerLocation),
+    Archived(&'a ArchivedDataInitializerLocation),
+}
+
+impl<'a> DataInitializerLocationVariant<'a> {
+    pub fn clone_to_plain(&self) -> DataInitializerLocation {
+        match self {
+            Self::Plain(p) => (*p).clone(),
+            Self::Archived(a) => DataInitializerLocation {
+                memory_index: a.memory_index(),
+                base: a.base(),
+                offset: a.offset(),
+            },
+        }
+    }
+}
+
+impl<'a> DataInitializerLocationLike for DataInitializerLocationVariant<'a> {
+    fn memory_index(&self) -> MemoryIndex {
+        match self {
+            Self::Plain(plain) => plain.memory_index(),
+            Self::Archived(archived) => archived.memory_index(),
+        }
+    }
+
+    fn base(&self) -> Option<wasmer_types::GlobalIndex> {
+        match self {
+            Self::Plain(plain) => plain.base(),
+            Self::Archived(archived) => archived.base(),
+        }
+    }
+
+    fn offset(&self) -> usize {
+        match self {
+            Self::Plain(plain) => plain.offset(),
+            Self::Archived(archived) => archived.offset(),
+        }
+    }
+}
+
+impl Artifact {
+    /// Register thie `Artifact` stack frame information into the global scope.
+    ///
+    /// This is not required anymore as it's done automaticaly when creating by 'Artifact::from_parts'
+    #[deprecated(
+        since = "4.0.0",
+        note = "done automaticaly by Artifact::from_parts, use 'take_frame_info_registration' if you use this method"
+    )]
+    pub fn register_frame_info(&mut self) -> Result<(), DeserializeError> {
+        self.internal_register_frame_info()
+    }
+
+    fn internal_register_frame_info(&mut self) -> Result<(), DeserializeError> {
+        if self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .frame_info_registered
+        {
+            return Ok(()); // already done
+        }
+
+        let finished_function_extents = self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .finished_functions
+            .values()
+            .copied()
+            .zip(
+                self.allocated
+                    .as_ref()
+                    .expect("It must be allocated")
+                    .finished_function_lengths
+                    .values()
+                    .copied(),
+            )
+            .map(|(ptr, length)| FunctionExtent { ptr, length })
+            .collect::<PrimaryMap<LocalFunctionIndex, _>>()
+            .into_boxed_slice();
+
+        let frame_info_registration = &mut self
+            .allocated
+            .as_mut()
+            .expect("It must be allocated")
+            .frame_info_registration;
+
+        *frame_info_registration = register_frame_info(
+            self.artifact.create_module_info(),
+            &finished_function_extents,
+            match &self.artifact {
+                ArtifactBuildVariant::Plain(p) => p.get_frame_info_ref().clone(),
+                ArtifactBuildVariant::Archived(a) => a.deserialize_frame_info_ref()?,
+            },
+        );
+
+        self.allocated
+            .as_mut()
+            .expect("It must be allocated")
+            .frame_info_registered = true;
+
+        Ok(())
+    }
+
+    /// The GlobalFrameInfoRegistration needs to be transfered to EngineInner if
+    /// register_frame_info has been used.
+    #[deprecated(since = "4.0.0", note = "done automaticaly by Artifact::from_parts.")]
+    pub fn take_frame_info_registration(&mut self) -> Option<GlobalFrameInfoRegistration> {
+        self.internal_take_frame_info_registration()
+    }
+
+    fn internal_take_frame_info_registration(&mut self) -> Option<GlobalFrameInfoRegistration> {
+        let frame_info_registration = &mut self
+            .allocated
+            .as_mut()
+            .expect("It must be allocated")
+            .frame_info_registration;
+
+        frame_info_registration.take()
+    }
+
+    /// Returns the functions allocated in memory or this `Artifact`
+    /// ready to be run.
+    pub fn finished_functions(&self) -> &BoxedSlice<LocalFunctionIndex, FunctionBodyPtr> {
+        &self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .finished_functions
+    }
+
+    /// Returns the function call trampolines allocated in memory of this
+    /// `Artifact`, ready to be run.
+    pub fn finished_function_call_trampolines(&self) -> &BoxedSlice<SignatureIndex, VMTrampoline> {
+        &self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .finished_function_call_trampolines
+    }
+
+    /// Returns the dynamic function trampolines allocated in memory
+    /// of this `Artifact`, ready to be run.
+    pub fn finished_dynamic_function_trampolines(
+        &self,
+    ) -> &BoxedSlice<FunctionIndex, FunctionBodyPtr> {
+        &self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .finished_dynamic_function_trampolines
+    }
+
+    /// Returns the associated VM signatures for this `Artifact`.
+    pub fn signatures(&self) -> &BoxedSlice<SignatureIndex, VMSharedSignatureIndex> {
+        &self
+            .allocated
+            .as_ref()
+            .expect("It must be allocated")
+            .signatures
+    }
+
+    /// Do preinstantiation logic that is executed before instantiating
+    #[allow(clippy::result_large_err)]
+    pub fn preinstantiate(&self) -> Result<(), InstantiationError> {
+        Ok(())
+    }
+
+    /// Crate an `Instance` from this `Artifact`.
+    ///
+    /// # Safety
+    ///
+    /// See [`VMInstance::new`].
+    #[allow(clippy::result_large_err)]
+    pub unsafe fn instantiate(
+        &self,
+        tunables: &dyn Tunables,
+        imports: &[VMExtern],
+        context: &mut StoreObjects,
+    ) -> Result<VMInstance, InstantiationError> {
+        // Validate the CPU features this module was compiled with against the
+        // host CPU features.
+        let host_cpu_features = CpuFeature::for_host();
+        if !host_cpu_features.is_superset(self.cpu_features()) {
+            return Err(InstantiationError::CpuFeature(format!(
+                "{:?}",
+                self.cpu_features().difference(host_cpu_features)
+            )));
+        }
+
+        self.preinstantiate()?;
+
+        let module = self.create_module_info();
+        let imports = resolve_imports(
+            &module,
+            imports,
+            context,
+            self.finished_dynamic_function_trampolines(),
+            self.memory_styles(),
+            self.table_styles(),
+        )
+        .map_err(InstantiationError::Link)?;
+
+        // Get pointers to where metadata about local memories should live in VM memory.
+        // Get pointers to where metadata about local tables should live in VM memory.
+
+        let (allocator, memory_definition_locations, table_definition_locations) =
+            InstanceAllocator::new(&module);
+        let finished_memories = tunables
+            .create_memories(
+                context,
+                &module,
+                self.memory_styles(),
+                &memory_definition_locations,
+            )
+            .map_err(InstantiationError::Link)?
+            .into_boxed_slice();
+        let finished_tables = tunables
+            .create_tables(
+                context,
+                &module,
+                self.table_styles(),
+                &table_definition_locations,
+            )
+            .map_err(InstantiationError::Link)?
+            .into_boxed_slice();
+        let finished_globals = tunables
+            .create_globals(context, &module)
+            .map_err(InstantiationError::Link)?
+            .into_boxed_slice();
+
+        let handle = VMInstance::new(
+            allocator,
+            module,
+            context,
+            self.finished_functions().clone(),
+            self.finished_function_call_trampolines().clone(),
+            finished_memories,
+            finished_tables,
+            finished_globals,
+            imports,
+            self.signatures().clone(),
+        )
+        .map_err(InstantiationError::Start)?;
+        Ok(handle)
+    }
+
+    /// Finishes the instantiation of a just created `VMInstance`.
+    ///
+    /// # Safety
+    ///
+    /// See [`VMInstance::finish_instantiation`].
+    #[allow(clippy::result_large_err)]
+    pub unsafe fn finish_instantiation(
+        &self,
+        config: &VMConfig,
+        trap_handler: Option<*const TrapHandlerFn<'static>>,
+        handle: &mut VMInstance,
+    ) -> Result<(), InstantiationError> {
+        let data_initializers = self
+            .data_initializers()
+            .map(|init| DataInitializer {
+                location: init.location().clone_to_plain(),
+                data: init.data(),
+            })
+            .collect::<Vec<_>>();
+        handle
+            .finish_instantiation(config, trap_handler, &data_initializers)
+            .map_err(InstantiationError::Start)
+    }
+
+    #[allow(clippy::type_complexity)]
+    #[cfg(feature = "static-artifact-create")]
+    /// Generate a compilation
+    pub fn generate_metadata<'data>(
+        data: &'data [u8],
+        compiler: &dyn Compiler,
+        tunables: &dyn Tunables,
+        features: &Features,
+    ) -> Result<
+        (
+            CompileModuleInfo,
+            PrimaryMap<LocalFunctionIndex, FunctionBodyData<'data>>,
+            Vec<DataInitializer<'data>>,
+            Option<ModuleTranslationState>,
+        ),
+        CompileError,
+    > {
+        let environ = ModuleEnvironment::new();
+        let translation = environ.translate(data).map_err(CompileError::Wasm)?;
+
+        // We try to apply the middleware first
+        use crate::translator::ModuleMiddlewareChain;
+        let mut module = translation.module;
+        let middlewares = compiler.get_middlewares();
+        middlewares.apply_on_module_info(&mut module)?;
+
+        let memory_styles: PrimaryMap<MemoryIndex, MemoryStyle> = module
+            .memories
+            .values()
+            .map(|memory_type| tunables.memory_style(memory_type))
+            .collect();
+        let table_styles: PrimaryMap<TableIndex, TableStyle> = module
+            .tables
+            .values()
+            .map(|table_type| tunables.table_style(table_type))
+            .collect();
+
+        let compile_info = CompileModuleInfo {
+            module: Arc::new(module),
+            features: features.clone(),
+            memory_styles,
+            table_styles,
+        };
+        Ok((
+            compile_info,
+            translation.function_body_inputs,
+            translation.data_initializers,
+            translation.module_translation_state,
+        ))
+    }
+
+    /// Generate the metadata object for the module
+    #[cfg(feature = "static-artifact-create")]
+    #[allow(clippy::type_complexity)]
+    pub fn metadata<'a>(
+        compiler: &dyn Compiler,
+        data: &'a [u8],
+        metadata_prefix: Option<&str>,
+        target: &Target,
+        tunables: &dyn Tunables,
+        features: &Features,
+    ) -> Result<
+        (
+            ModuleMetadata,
+            Option<ModuleTranslationState>,
+            PrimaryMap<LocalFunctionIndex, FunctionBodyData<'a>>,
+        ),
+        CompileError,
+    > {
+        #[allow(dead_code)]
+        let (compile_info, function_body_inputs, data_initializers, module_translation) =
+            Self::generate_metadata(data, compiler, tunables, features)?;
+
+        let data_initializers = data_initializers
+            .iter()
+            .map(OwnedDataInitializer::new)
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+
+        // TODO: we currently supply all-zero function body lengths.
+        // We don't know the lengths until they're compiled, yet we have to
+        // supply the metadata as an input to the compile.
+        let function_body_lengths = function_body_inputs
+            .keys()
+            .map(|_function_body| 0u64)
+            .collect::<PrimaryMap<LocalFunctionIndex, u64>>();
+
+        let metadata = ModuleMetadata {
+            compile_info,
+            prefix: metadata_prefix.map(|s| s.to_string()).unwrap_or_default(),
+            data_initializers,
+            function_body_lengths,
+            cpu_features: target.cpu_features().as_u64(),
+        };
+
+        Ok((metadata, module_translation, function_body_inputs))
+    }
+
+    /// Compile a module into an object file, which can be statically linked against.
+    ///
+    /// The `metadata_prefix` is an optional prefix for the object name to make the
+    /// function names in the object file unique. When set, the function names will
+    /// be `wasmer_function_{prefix}_{id}` and the object metadata will be addressable
+    /// using `WASMER_METADATA_{prefix}_LENGTH` and `WASMER_METADATA_{prefix}_DATA`.
+    ///
+    #[cfg(feature = "static-artifact-create")]
+    pub fn generate_object<'data>(
+        compiler: &dyn Compiler,
+        data: &[u8],
+        metadata_prefix: Option<&str>,
+        target: &'data Target,
+        tunables: &dyn Tunables,
+        features: &Features,
+    ) -> Result<
+        (
+            ModuleInfo,
+            Object<'data>,
+            usize,
+            Box<dyn wasmer_types::SymbolRegistry>,
+        ),
+        CompileError,
+    > {
+        use wasmer_types::{compilation::symbols::ModuleMetadataSymbolRegistry, SymbolRegistry};
+
+        fn to_compile_error(err: impl std::error::Error) -> CompileError {
+            CompileError::Codegen(format!("{}", err))
+        }
+
+        let target_triple = target.triple();
+        let (mut metadata, module_translation, function_body_inputs) =
+            Self::metadata(compiler, data, metadata_prefix, target, tunables, features)
+                .map_err(to_compile_error)?;
+
+        /*
+        In the C file we need:
+        - imports
+        - exports
+
+        to construct an api::Module which is a Store (can be passed in via argument) and an
+        Arc<dyn Artifact> which means this struct which includes:
+        - CompileModuleInfo
+        - Features
+        - ModuleInfo
+        - MemoryIndex -> MemoryStyle
+        - TableIndex -> TableStyle
+        - LocalFunctionIndex -> FunctionBodyPtr // finished functions
+        - FunctionIndex -> FunctionBodyPtr // finished dynamic function trampolines
+        - SignatureIndex -> VMSharedSignatureindextureIndex // signatures
+         */
+
+        let serialized_data = metadata.serialize().map_err(to_compile_error)?;
+        let mut metadata_binary = vec![];
+        metadata_binary.extend(MetadataHeader::new(serialized_data.len()).into_bytes());
+        metadata_binary.extend(serialized_data);
+
+        let (_compile_info, symbol_registry) = metadata.split();
+
+        let compilation: wasmer_types::compilation::function::Compilation = compiler
+            .compile_module(
+                target,
+                &metadata.compile_info,
+                module_translation.as_ref().unwrap(),
+                function_body_inputs,
+            )?;
+        let mut obj = get_object_for_target(target_triple).map_err(to_compile_error)?;
+
+        let object_name = ModuleMetadataSymbolRegistry {
+            prefix: metadata_prefix.unwrap_or_default().to_string(),
+        }
+        .symbol_to_name(wasmer_types::Symbol::Metadata);
+
+        emit_data(&mut obj, object_name.as_bytes(), &metadata_binary, 1)
+            .map_err(to_compile_error)?;
+
+        emit_compilation(&mut obj, compilation, &symbol_registry, target_triple)
+            .map_err(to_compile_error)?;
+        Ok((
+            Arc::try_unwrap(metadata.compile_info.module).unwrap(),
+            obj,
+            metadata_binary.len(),
+            Box::new(symbol_registry),
+        ))
+    }
+
+    /// Deserialize a ArtifactBuild from an object file
+    ///
+    /// # Safety
+    /// The object must be a valid static object generated by wasmer.
+    #[cfg(not(feature = "static-artifact-load"))]
+    pub unsafe fn deserialize_object(
+        _engine: &Engine,
+        _bytes: OwnedBuffer,
+    ) -> Result<Self, DeserializeError> {
+        Err(DeserializeError::Compiler(
+            CompileError::UnsupportedFeature("static load is not compiled in".to_string()),
+        ))
+    }
+
+    fn get_byte_slice(input: &[u8], start: usize, end: usize) -> Result<&[u8], DeserializeError> {
+        if (start == end && input.len() > start)
+            || (start < end && input.len() > start && input.len() >= end)
+        {
+            Ok(&input[start..end])
+        } else {
+            Err(DeserializeError::InvalidByteLength {
+                expected: end - start,
+                got: input.len(),
+            })
+        }
+    }
+
+    /// Deserialize a ArtifactBuild from an object file
+    ///
+    /// # Safety
+    /// The object must be a valid static object generated by wasmer.
+    #[cfg(feature = "static-artifact-load")]
+    pub unsafe fn deserialize_object(
+        engine: &Engine,
+        bytes: OwnedBuffer,
+    ) -> Result<Self, DeserializeError> {
+        use wasmer_types::SerializableCompilation;
+
+        let bytes = bytes.as_slice();
+        let metadata_len = MetadataHeader::parse(bytes)?;
+        let metadata_slice = Self::get_byte_slice(bytes, MetadataHeader::LEN, bytes.len())?;
+        let metadata_slice = Self::get_byte_slice(metadata_slice, 0, metadata_len)?;
+        let metadata: ModuleMetadata = ModuleMetadata::deserialize(metadata_slice)?;
+
+        const WORD_SIZE: usize = mem::size_of::<usize>();
+        let mut byte_buffer = [0u8; WORD_SIZE];
+
+        let mut cur_offset = MetadataHeader::LEN + metadata_len;
+
+        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+        cur_offset += WORD_SIZE;
+
+        let num_finished_functions = usize::from_ne_bytes(byte_buffer);
+        let mut finished_functions: PrimaryMap<LocalFunctionIndex, FunctionBodyPtr> =
+            PrimaryMap::new();
+
+        let engine_inner = engine.inner();
+        let signature_registry = engine_inner.signatures();
+
+        // read finished functions in order now...
+        for _i in 0..num_finished_functions {
+            let byte_buffer_slice =
+                Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+            byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+            let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
+            cur_offset += WORD_SIZE;
+
+            // TODO: we can read back the length here if we serialize it. This will improve debug output.
+            finished_functions.push(fp);
+        }
+
+        // We register all the signatures
+        let signatures = {
+            metadata
+                .compile_info
+                .module
+                .signatures
+                .values()
+                .map(|sig| signature_registry.register(sig))
+                .collect::<PrimaryMap<_, _>>()
+        };
+
+        // read trampolines in order
+        let mut finished_function_call_trampolines = PrimaryMap::new();
+
+        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+        cur_offset += WORD_SIZE;
+        let num_function_trampolines = usize::from_ne_bytes(byte_buffer);
+        for _ in 0..num_function_trampolines {
+            let byte_buffer_slice =
+                Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+            byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+            cur_offset += WORD_SIZE;
+            let trampoline_ptr_bytes = usize::from_ne_bytes(byte_buffer);
+            let trampoline = mem::transmute::<usize, VMTrampoline>(trampoline_ptr_bytes);
+            finished_function_call_trampolines.push(trampoline);
+            // TODO: we can read back the length here if we serialize it. This will improve debug output.
+        }
+
+        // read dynamic function trampolines in order now...
+        let mut finished_dynamic_function_trampolines = PrimaryMap::new();
+        let byte_buffer_slice = Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+        byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+        cur_offset += WORD_SIZE;
+        let num_dynamic_trampoline_functions = usize::from_ne_bytes(byte_buffer);
+        for _i in 0..num_dynamic_trampoline_functions {
+            let byte_buffer_slice =
+                Self::get_byte_slice(bytes, cur_offset, cur_offset + WORD_SIZE)?;
+            byte_buffer[0..WORD_SIZE].clone_from_slice(byte_buffer_slice);
+            let fp = FunctionBodyPtr(usize::from_ne_bytes(byte_buffer) as _);
+            cur_offset += WORD_SIZE;
+
+            // TODO: we can read back the length here if we serialize it. This will improve debug output.
+
+            finished_dynamic_function_trampolines.push(fp);
+        }
+
+        let artifact = ArtifactBuild::from_serializable(SerializableModule {
+            compilation: SerializableCompilation::default(),
+            compile_info: metadata.compile_info,
+            data_initializers: metadata.data_initializers,
+            cpu_features: metadata.cpu_features,
+        });
+
+        let finished_function_lengths = finished_functions
+            .values()
+            .map(|_| 0)
+            .collect::<PrimaryMap<LocalFunctionIndex, usize>>()
+            .into_boxed_slice();
+
+        Ok(Self {
+            id: Default::default(),
+            artifact: ArtifactBuildVariant::Plain(artifact),
+            allocated: Some(AllocatedArtifact {
+                frame_info_registered: false,
+                frame_info_registration: None,
+                finished_functions: finished_functions.into_boxed_slice(),
+                finished_function_call_trampolines: finished_function_call_trampolines
+                    .into_boxed_slice(),
+                finished_dynamic_function_trampolines: finished_dynamic_function_trampolines
+                    .into_boxed_slice(),
+                signatures: signatures.into_boxed_slice(),
+                finished_function_lengths,
+            }),
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/builder.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/builder.rs
new file mode 100644
index 0000000..0f07396
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/builder.rs
@@ -0,0 +1,78 @@
+use super::Engine;
+use crate::CompilerConfig;
+use wasmer_types::{Features, Target};
+
+/// The Builder contents of `Engine`
+pub struct EngineBuilder {
+    /// The compiler
+    compiler_config: Option<Box<dyn CompilerConfig>>,
+    /// The machine target
+    target: Option<Target>,
+    /// The features to compile the Wasm module with
+    features: Option<Features>,
+}
+
+impl EngineBuilder {
+    /// Create a new builder with pre-made components
+    pub fn new<T>(compiler_config: T) -> Self
+    where
+        T: Into<Box<dyn CompilerConfig>>,
+    {
+        Self {
+            compiler_config: Some(compiler_config.into()),
+            target: None,
+            features: None,
+        }
+    }
+
+    /// Create a new headless Backend
+    pub fn headless() -> Self {
+        Self {
+            compiler_config: None,
+            target: None,
+            features: None,
+        }
+    }
+
+    /// Set the target
+    pub fn set_target(mut self, target: Option<Target>) -> Self {
+        self.target = target;
+        self
+    }
+
+    /// Set the features
+    pub fn set_features(mut self, features: Option<Features>) -> Self {
+        self.features = features;
+        self
+    }
+
+    /// Build the `Engine` for this configuration
+    #[cfg(feature = "compiler")]
+    pub fn engine(self) -> Engine {
+        let target = self.target.unwrap_or_default();
+        if let Some(compiler_config) = self.compiler_config {
+            let features = self
+                .features
+                .unwrap_or_else(|| compiler_config.default_features_for_target(&target));
+            Engine::new(compiler_config, target, features)
+        } else {
+            Engine::headless()
+        }
+    }
+
+    /// Build the `Engine` for this configuration
+    #[cfg(not(feature = "compiler"))]
+    pub fn engine(self) -> Engine {
+        Engine::headless()
+    }
+
+    /// The Wasm features
+    pub fn features(&self) -> Option<&Features> {
+        self.features.as_ref()
+    }
+
+    /// The target
+    pub fn target(&self) -> Option<&Target> {
+        self.target.as_ref()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/code_memory.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/code_memory.rs
new file mode 100644
index 0000000..bf243a7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/code_memory.rs
@@ -0,0 +1,248 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Memory management for executable code.
+use super::unwind::UnwindRegistry;
+use crate::GlobalFrameInfoRegistration;
+use wasmer_types::{
+    compilation::unwind::CompiledFunctionUnwindInfoLike, CompiledFunctionUnwindInfoReference,
+    CustomSectionLike, FunctionBodyLike,
+};
+use wasmer_vm::{Mmap, VMFunctionBody};
+
+/// The optimal alignment for functions.
+///
+/// On x86-64, this is 16 since it's what the optimizations assume.
+/// When we add support for other architectures, we should also figure out their
+/// optimal alignment values.
+const ARCH_FUNCTION_ALIGNMENT: usize = 16;
+
+/// The optimal alignment for data.
+///
+const DATA_SECTION_ALIGNMENT: usize = 64;
+
+/// Memory manager for executable code.
+pub struct CodeMemory {
+    // frame info is placed first, to ensure it's dropped before the mmap
+    frame_info_registration: Option<GlobalFrameInfoRegistration>,
+    unwind_registry: UnwindRegistry,
+    mmap: Mmap,
+    start_of_nonexecutable_pages: usize,
+}
+
+impl CodeMemory {
+    /// Create a new `CodeMemory` instance.
+    pub fn new() -> Self {
+        Self {
+            unwind_registry: UnwindRegistry::new(),
+            mmap: Mmap::new(),
+            start_of_nonexecutable_pages: 0,
+            frame_info_registration: None,
+        }
+    }
+
+    /// Mutably get the UnwindRegistry.
+    pub fn unwind_registry_mut(&mut self) -> &mut UnwindRegistry {
+        &mut self.unwind_registry
+    }
+
+    /// Allocate a single contiguous block of memory at a fixed virtual address for the functions and custom sections, and copy the data in place.
+    #[allow(clippy::type_complexity)]
+    pub fn allocate<'module, 'memory, FunctionBody, CustomSection>(
+        &'memory mut self,
+        functions: &'memory [&'module FunctionBody],
+        executable_sections: &'memory [&'module CustomSection],
+        data_sections: &'memory [&'module CustomSection],
+    ) -> Result<
+        (
+            Vec<&'memory mut [VMFunctionBody]>,
+            Vec<&'memory mut [u8]>,
+            Vec<&'memory mut [u8]>,
+        ),
+        String,
+    >
+    where
+        FunctionBody: FunctionBodyLike<'module> + 'module,
+        CustomSection: CustomSectionLike<'module> + 'module,
+    {
+        let mut function_result = vec![];
+        let mut data_section_result = vec![];
+        let mut executable_section_result = vec![];
+
+        let page_size = region::page::size();
+
+        // 1. Calculate the total size, that is:
+        // - function body size, including all trampolines
+        // -- windows unwind info
+        // -- padding between functions
+        // - executable section body
+        // -- padding between executable sections
+        // - padding until a new page to change page permissions
+        // - data section body size
+        // -- padding between data sections
+
+        let total_len = round_up(
+            functions.iter().fold(0, |acc, func| {
+                round_up(
+                    acc + Self::function_allocation_size(*func),
+                    ARCH_FUNCTION_ALIGNMENT,
+                )
+            }) + executable_sections.iter().fold(0, |acc, exec| {
+                round_up(acc + exec.bytes().len(), ARCH_FUNCTION_ALIGNMENT)
+            }),
+            page_size,
+        ) + data_sections.iter().fold(0, |acc, data| {
+            round_up(acc + data.bytes().len(), DATA_SECTION_ALIGNMENT)
+        });
+
+        // 2. Allocate the pages. Mark them all read-write.
+
+        self.mmap = Mmap::with_at_least(total_len)?;
+
+        // 3. Determine where the pointers to each function, executable section
+        // or data section are. Copy the functions. Collect the addresses of each and return them.
+
+        let mut bytes = 0;
+        let mut buf = self.mmap.as_mut_slice();
+        for func in functions {
+            let len = round_up(
+                Self::function_allocation_size(*func),
+                ARCH_FUNCTION_ALIGNMENT,
+            );
+            let (func_buf, next_buf) = buf.split_at_mut(len);
+            buf = next_buf;
+            bytes += len;
+
+            let vmfunc = Self::copy_function(&mut self.unwind_registry, *func, func_buf);
+            assert_eq!(vmfunc.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+            function_result.push(vmfunc);
+        }
+        for section in executable_sections {
+            let section = section.bytes();
+            assert_eq!(buf.as_mut_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+            let len = round_up(section.len(), ARCH_FUNCTION_ALIGNMENT);
+            let (s, next_buf) = buf.split_at_mut(len);
+            buf = next_buf;
+            bytes += len;
+            s[..section.len()].copy_from_slice(section);
+            executable_section_result.push(s);
+        }
+
+        self.start_of_nonexecutable_pages = bytes;
+
+        if !data_sections.is_empty() {
+            // Data sections have different page permissions from the executable
+            // code that came before it, so they need to be on different pages.
+            let padding = round_up(bytes, page_size) - bytes;
+            buf = buf.split_at_mut(padding).1;
+
+            for section in data_sections {
+                let section = section.bytes();
+                assert_eq!(buf.as_mut_ptr() as usize % DATA_SECTION_ALIGNMENT, 0);
+                let len = round_up(section.len(), DATA_SECTION_ALIGNMENT);
+                let (s, next_buf) = buf.split_at_mut(len);
+                buf = next_buf;
+                s[..section.len()].copy_from_slice(section);
+                data_section_result.push(s);
+            }
+        }
+
+        Ok((
+            function_result,
+            executable_section_result,
+            data_section_result,
+        ))
+    }
+
+    /// Apply the page permissions.
+    pub fn publish(&mut self) {
+        if self.mmap.is_empty() || self.start_of_nonexecutable_pages == 0 {
+            return;
+        }
+        assert!(self.mmap.len() >= self.start_of_nonexecutable_pages);
+        unsafe {
+            region::protect(
+                self.mmap.as_mut_ptr(),
+                self.start_of_nonexecutable_pages,
+                region::Protection::READ_EXECUTE,
+            )
+        }
+        .expect("unable to make memory readonly and executable");
+    }
+
+    /// Calculates the allocation size of the given compiled function.
+    fn function_allocation_size<'a>(func: &'a impl FunctionBodyLike<'a>) -> usize {
+        match &func.unwind_info().map(|o| o.get()) {
+            Some(CompiledFunctionUnwindInfoReference::WindowsX64(info)) => {
+                // Windows unwind information is required to be emitted into code memory
+                // This is because it must be a positive relative offset from the start of the memory
+                // Account for necessary unwind information alignment padding (32-bit alignment)
+                ((func.body().len() + 3) & !3) + info.len()
+            }
+            _ => func.body().len(),
+        }
+    }
+
+    /// Copies the data of the compiled function to the given buffer.
+    ///
+    /// This will also add the function to the current function table.
+    fn copy_function<'module, 'memory>(
+        registry: &mut UnwindRegistry,
+        func: &'module impl FunctionBodyLike<'module>,
+        buf: &'memory mut [u8],
+    ) -> &'memory mut [VMFunctionBody] {
+        assert_eq!(buf.as_ptr() as usize % ARCH_FUNCTION_ALIGNMENT, 0);
+
+        let func_len = func.body().len();
+
+        let (body, remainder) = buf.split_at_mut(func_len);
+        body.copy_from_slice(func.body());
+        let vmfunc = Self::view_as_mut_vmfunc_slice(body);
+
+        let unwind_info = func.unwind_info().map(|o| o.get());
+        if let Some(CompiledFunctionUnwindInfoReference::WindowsX64(info)) = unwind_info {
+            // Windows unwind information is written following the function body
+            // Keep unwind information 32-bit aligned (round up to the nearest 4 byte boundary)
+            let unwind_start = (func_len + 3) & !3;
+            let unwind_size = info.len();
+            let padding = unwind_start - func_len;
+            assert_eq!((func_len + padding) % 4, 0);
+            let slice = remainder.split_at_mut(padding + unwind_size).0;
+            slice[padding..].copy_from_slice(info);
+        }
+
+        if let Some(ref info) = unwind_info {
+            registry
+                .register(vmfunc.as_ptr() as usize, 0, func_len as u32, info)
+                .expect("failed to register unwind information");
+        }
+
+        vmfunc
+    }
+
+    /// Convert mut a slice from u8 to VMFunctionBody.
+    fn view_as_mut_vmfunc_slice(slice: &mut [u8]) -> &mut [VMFunctionBody] {
+        let byte_ptr: *mut [u8] = slice;
+        let body_ptr = byte_ptr as *mut [VMFunctionBody];
+        unsafe { &mut *body_ptr }
+    }
+
+    /// Register the frame info, so it's free when the mememory gets freed
+    pub fn register_frame_info(&mut self, frame_info: GlobalFrameInfoRegistration) {
+        self.frame_info_registration = Some(frame_info);
+    }
+}
+
+fn round_up(size: usize, multiple: usize) -> usize {
+    debug_assert!(multiple.is_power_of_two());
+    (size + (multiple - 1)) & !(multiple - 1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CodeMemory;
+    fn _assert() {
+        fn _assert_send_sync<T: Send + Sync>() {}
+        _assert_send_sync::<CodeMemory>();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/error.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/error.rs
new file mode 100644
index 0000000..b5f9c0f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/error.rs
@@ -0,0 +1,52 @@
+//! The WebAssembly possible errors
+use thiserror::Error;
+pub use wasmer_types::ImportError;
+#[cfg(not(target_arch = "wasm32"))]
+use wasmer_vm::Trap;
+
+/// The WebAssembly.LinkError object indicates an error during
+/// module instantiation (besides traps from the start function).
+///
+/// This is based on the [link error][link-error] API.
+///
+/// [link-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/LinkError
+#[derive(Error, Debug)]
+#[error("Link error: {0}")]
+pub enum LinkError {
+    /// An error occurred when checking the import types.
+    #[error("Error while importing {0:?}.{1:?}: {2}")]
+    Import(String, String, ImportError),
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// A trap ocurred during linking.
+    #[error("Trap occurred during linking: {0}")]
+    Trap(#[source] Trap),
+
+    /// Insufficient resources available for linking.
+    #[error("Insufficient resources: {0}")]
+    Resource(String),
+}
+
+/// An error while instantiating a module.
+///
+/// This is not a common WebAssembly error, however
+/// we need to differentiate from a `LinkError` (an error
+/// that happens while linking, on instantiation) and a
+/// Trap that occurs when calling the WebAssembly module
+/// start function.
+#[derive(Error, Debug)]
+pub enum InstantiationError {
+    /// A linking ocurred during instantiation.
+    #[error(transparent)]
+    Link(LinkError),
+
+    /// The module was compiled with a CPU feature that is not available on
+    /// the current host.
+    #[error("module compiled with CPU feature that is missing from host")]
+    CpuFeature(String),
+
+    /// A runtime error occured while invoking the start function
+    #[cfg(not(target_arch = "wasm32"))]
+    #[error(transparent)]
+    Start(Trap),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/inner.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/inner.rs
new file mode 100644
index 0000000..cadb5cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/inner.rs
@@ -0,0 +1,515 @@
+//! Universal compilation.
+
+use crate::engine::builder::EngineBuilder;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::Artifact;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::BaseTunables;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::CodeMemory;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::GlobalFrameInfoRegistration;
+#[cfg(feature = "compiler")]
+use crate::{Compiler, CompilerConfig};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::{FunctionExtent, Tunables};
+#[cfg(not(target_arch = "wasm32"))]
+use shared_buffer::OwnedBuffer;
+#[cfg(not(target_arch = "wasm32"))]
+use std::path::Path;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::sync::{Arc, Mutex};
+#[cfg(not(target_arch = "wasm32"))]
+use wasmer_types::{
+    entity::PrimaryMap, DeserializeError, FunctionBodyLike, FunctionIndex, FunctionType,
+    LocalFunctionIndex, SignatureIndex,
+};
+use wasmer_types::{CompileError, Features, ModuleInfo, Target};
+#[cfg(not(target_arch = "wasm32"))]
+use wasmer_types::{CustomSectionLike, CustomSectionProtection, SectionIndex};
+#[cfg(not(target_arch = "wasm32"))]
+use wasmer_vm::{
+    FunctionBodyPtr, SectionBodyPtr, SignatureRegistry, VMFunctionBody, VMSharedSignatureIndex,
+    VMTrampoline,
+};
+
+/// A WebAssembly `Universal` Engine.
+#[derive(Clone)]
+pub struct Engine {
+    inner: Arc<Mutex<EngineInner>>,
+    /// The target for the compiler
+    target: Arc<Target>,
+    engine_id: EngineId,
+    #[cfg(not(target_arch = "wasm32"))]
+    tunables: Arc<dyn Tunables + Send + Sync>,
+    name: String,
+}
+
+impl Engine {
+    /// Create a new `Engine` with the given config
+    #[cfg(feature = "compiler")]
+    pub fn new(
+        compiler_config: Box<dyn CompilerConfig>,
+        target: Target,
+        features: Features,
+    ) -> Self {
+        #[cfg(not(target_arch = "wasm32"))]
+        let tunables = BaseTunables::for_target(&target);
+        let compiler = compiler_config.compiler();
+        let name = format!("engine-{}", compiler.name());
+        Self {
+            inner: Arc::new(Mutex::new(EngineInner {
+                compiler: Some(compiler),
+                features,
+                #[cfg(not(target_arch = "wasm32"))]
+                code_memory: vec![],
+                #[cfg(not(target_arch = "wasm32"))]
+                signatures: SignatureRegistry::new(),
+            })),
+            target: Arc::new(target),
+            engine_id: EngineId::default(),
+            #[cfg(not(target_arch = "wasm32"))]
+            tunables: Arc::new(tunables),
+            name,
+        }
+    }
+
+    #[cfg(not(feature = "compiler"))]
+    pub fn new(
+        compiler_config: Box<dyn CompilerConfig>,
+        target: Target,
+        features: Features,
+    ) -> Self {
+        panic!("The engine is not compiled with any compiler support")
+    }
+
+    /// Returns the name of this engine
+    pub fn name(&self) -> &str {
+        self.name.as_str()
+    }
+
+    /// Returns the deterministic id of this engine
+    pub fn deterministic_id(&self) -> &str {
+        // TODO: add a `deterministic_id` to the Compiler, so two
+        // compilers can actually serialize into a different deterministic_id
+        // if their configuration is different (eg. LLVM with optimizations vs LLVM
+        // without optimizations)
+        self.name.as_str()
+    }
+
+    /// Create a headless `Engine`
+    ///
+    /// A headless engine is an engine without any compiler attached.
+    /// This is useful for assuring a minimal runtime for running
+    /// WebAssembly modules.
+    ///
+    /// For example, for running in IoT devices where compilers are very
+    /// expensive, or also to optimize startup speed.
+    ///
+    /// # Important
+    ///
+    /// Headless engines can't compile or validate any modules,
+    /// they just take already processed Modules (via `Module::serialize`).
+    pub fn headless() -> Self {
+        let target = Target::default();
+        #[cfg(not(target_arch = "wasm32"))]
+        let tunables = BaseTunables::for_target(&target);
+        Self {
+            inner: Arc::new(Mutex::new(EngineInner {
+                #[cfg(feature = "compiler")]
+                compiler: None,
+                #[cfg(feature = "compiler")]
+                features: Features::default(),
+                #[cfg(not(target_arch = "wasm32"))]
+                code_memory: vec![],
+                #[cfg(not(target_arch = "wasm32"))]
+                signatures: SignatureRegistry::new(),
+            })),
+            target: Arc::new(target),
+            engine_id: EngineId::default(),
+            #[cfg(not(target_arch = "wasm32"))]
+            tunables: Arc::new(tunables),
+            name: "engine-headless".to_string(),
+        }
+    }
+
+    /// Get reference to `EngineInner`.
+    pub fn inner(&self) -> std::sync::MutexGuard<'_, EngineInner> {
+        self.inner.lock().unwrap()
+    }
+
+    /// Get mutable reference to `EngineInner`.
+    pub fn inner_mut(&self) -> std::sync::MutexGuard<'_, EngineInner> {
+        self.inner.lock().unwrap()
+    }
+
+    /// Gets the target
+    pub fn target(&self) -> &Target {
+        &self.target
+    }
+
+    /// Register a signature
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn register_signature(&self, func_type: &FunctionType) -> VMSharedSignatureIndex {
+        let compiler = self.inner();
+        compiler.signatures().register(func_type)
+    }
+
+    /// Lookup a signature
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn lookup_signature(&self, sig: VMSharedSignatureIndex) -> Option<FunctionType> {
+        let compiler = self.inner();
+        compiler.signatures().lookup(sig)
+    }
+
+    /// Validates a WebAssembly module
+    #[cfg(feature = "compiler")]
+    pub fn validate(&self, binary: &[u8]) -> Result<(), CompileError> {
+        self.inner().validate(binary)
+    }
+
+    /// Compile a WebAssembly binary
+    #[cfg(feature = "compiler")]
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn compile(&self, binary: &[u8]) -> Result<Arc<Artifact>, CompileError> {
+        Ok(Arc::new(Artifact::new(
+            self,
+            binary,
+            self.tunables.as_ref(),
+        )?))
+    }
+
+    /// Compile a WebAssembly binary
+    #[cfg(not(feature = "compiler"))]
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn compile(
+        &self,
+        _binary: &[u8],
+        _tunables: &dyn Tunables,
+    ) -> Result<Arc<Artifact>, CompileError> {
+        Err(CompileError::Codegen(
+            "The Engine is operating in headless mode, so it can not compile Modules.".to_string(),
+        ))
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// [`Module::serialize`].
+    ///
+    /// # Safety
+    ///
+    /// See [`Artifact::deserialize_unchecked`].
+    pub unsafe fn deserialize_unchecked(
+        &self,
+        bytes: OwnedBuffer,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        Ok(Arc::new(Artifact::deserialize_unchecked(self, bytes)?))
+    }
+
+    /// Deserializes a WebAssembly module which was previously serialized with
+    /// [`Module::serialize`].
+    ///
+    /// # Safety
+    ///
+    /// See [`Artifact::deserialize`].
+    #[cfg(not(target_arch = "wasm32"))]
+    pub unsafe fn deserialize(
+        &self,
+        bytes: OwnedBuffer,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        Ok(Arc::new(Artifact::deserialize(self, bytes)?))
+    }
+
+    /// Deserializes a WebAssembly module from a path.
+    ///
+    /// # Safety
+    /// See [`Artifact::deserialize`].
+    #[cfg(not(target_arch = "wasm32"))]
+    pub unsafe fn deserialize_from_file(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        self.deserialize(
+            OwnedBuffer::from_file(&file).map_err(|e| DeserializeError::Generic(e.to_string()))?,
+        )
+    }
+
+    /// Deserialize from a file path.
+    ///
+    /// # Safety
+    ///
+    /// See [`Artifact::deserialize_unchecked`].
+    #[cfg(not(target_arch = "wasm32"))]
+    pub unsafe fn deserialize_from_file_unchecked(
+        &self,
+        file_ref: &Path,
+    ) -> Result<Arc<Artifact>, DeserializeError> {
+        let file = std::fs::File::open(file_ref)?;
+        self.deserialize_unchecked(
+            OwnedBuffer::from_file(&file).map_err(|e| DeserializeError::Generic(e.to_string()))?,
+        )
+    }
+
+    /// A unique identifier for this object.
+    ///
+    /// This exists to allow us to compare two Engines for equality. Otherwise,
+    /// comparing two trait objects unsafely relies on implementation details
+    /// of trait representation.
+    pub fn id(&self) -> &EngineId {
+        &self.engine_id
+    }
+
+    /// Clone the engine
+    pub fn cloned(&self) -> Self {
+        self.clone()
+    }
+
+    /// Attach a Tunable to this engine
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn set_tunables(&mut self, tunables: impl Tunables + Send + Sync + 'static) {
+        self.tunables = Arc::new(tunables);
+    }
+
+    /// Get a reference to attached Tunable of this engine
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn tunables(&self) -> &dyn Tunables {
+        self.tunables.as_ref()
+    }
+}
+
+impl std::fmt::Debug for Engine {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Engine")
+            .field("target", &self.target)
+            .field("engine_id", &self.engine_id)
+            .field("name", &self.name)
+            .finish()
+    }
+}
+
+/// The inner contents of `Engine`
+pub struct EngineInner {
+    #[cfg(feature = "compiler")]
+    /// The compiler and cpu features
+    compiler: Option<Box<dyn Compiler>>,
+    #[cfg(feature = "compiler")]
+    /// The compiler and cpu features
+    features: Features,
+    /// The code memory is responsible of publishing the compiled
+    /// functions to memory.
+    #[cfg(not(target_arch = "wasm32"))]
+    code_memory: Vec<CodeMemory>,
+    /// The signature registry is used mainly to operate with trampolines
+    /// performantly.
+    #[cfg(not(target_arch = "wasm32"))]
+    signatures: SignatureRegistry,
+}
+
+impl EngineInner {
+    /// Gets the compiler associated to this engine.
+    #[cfg(feature = "compiler")]
+    pub fn compiler(&self) -> Result<&dyn Compiler, CompileError> {
+        match self.compiler.as_ref() {
+            None => Err(CompileError::Codegen(
+                "No compiler compiled into executable".to_string(),
+            )),
+            Some(compiler) => Ok(&**compiler),
+        }
+    }
+
+    /// Validate the module
+    #[cfg(feature = "compiler")]
+    pub fn validate(&self, data: &[u8]) -> Result<(), CompileError> {
+        let compiler = self.compiler()?;
+        compiler.validate_module(&self.features, data)
+    }
+
+    /// The Wasm features
+    #[cfg(feature = "compiler")]
+    pub fn features(&self) -> &Features {
+        &self.features
+    }
+
+    /// Allocate compiled functions into memory
+    #[cfg(not(target_arch = "wasm32"))]
+    #[allow(clippy::type_complexity)]
+    pub(crate) fn allocate<'a, FunctionBody, CustomSection>(
+        &'a mut self,
+        _module: &ModuleInfo,
+        functions: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
+        function_call_trampolines: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
+        dynamic_function_trampolines: impl ExactSizeIterator<Item = &'a FunctionBody> + 'a,
+        custom_sections: impl ExactSizeIterator<Item = &'a CustomSection> + Clone + 'a,
+    ) -> Result<
+        (
+            PrimaryMap<LocalFunctionIndex, FunctionExtent>,
+            PrimaryMap<SignatureIndex, VMTrampoline>,
+            PrimaryMap<FunctionIndex, FunctionBodyPtr>,
+            PrimaryMap<SectionIndex, SectionBodyPtr>,
+        ),
+        CompileError,
+    >
+    where
+        FunctionBody: FunctionBodyLike<'a> + 'a,
+        CustomSection: CustomSectionLike<'a> + 'a,
+    {
+        let functions_len = functions.len();
+        let function_call_trampolines_len = function_call_trampolines.len();
+
+        let function_bodies = functions
+            .chain(function_call_trampolines)
+            .chain(dynamic_function_trampolines)
+            .collect::<Vec<_>>();
+        let (executable_sections, data_sections): (Vec<_>, _) = custom_sections
+            .clone()
+            .partition(|section| *section.protection() == CustomSectionProtection::ReadExecute);
+        self.code_memory.push(CodeMemory::new());
+
+        let (mut allocated_functions, allocated_executable_sections, allocated_data_sections) =
+            self.code_memory
+                .last_mut()
+                .unwrap()
+                .allocate(
+                    function_bodies.as_slice(),
+                    executable_sections.as_slice(),
+                    data_sections.as_slice(),
+                )
+                .map_err(|message| {
+                    CompileError::Resource(format!(
+                        "failed to allocate memory for functions: {}",
+                        message
+                    ))
+                })?;
+
+        let allocated_functions_result = allocated_functions
+            .drain(0..functions_len)
+            .map(|slice| FunctionExtent {
+                ptr: FunctionBodyPtr(slice.as_ptr()),
+                length: slice.len(),
+            })
+            .collect::<PrimaryMap<LocalFunctionIndex, _>>();
+
+        let mut allocated_function_call_trampolines: PrimaryMap<SignatureIndex, VMTrampoline> =
+            PrimaryMap::new();
+        for ptr in allocated_functions
+            .drain(0..function_call_trampolines_len)
+            .map(|slice| slice.as_ptr())
+        {
+            let trampoline =
+                unsafe { std::mem::transmute::<*const VMFunctionBody, VMTrampoline>(ptr) };
+            allocated_function_call_trampolines.push(trampoline);
+        }
+
+        let allocated_dynamic_function_trampolines = allocated_functions
+            .drain(..)
+            .map(|slice| FunctionBodyPtr(slice.as_ptr()))
+            .collect::<PrimaryMap<FunctionIndex, _>>();
+
+        let mut exec_iter = allocated_executable_sections.iter();
+        let mut data_iter = allocated_data_sections.iter();
+        let allocated_custom_sections = custom_sections
+            .map(|section| {
+                SectionBodyPtr(
+                    if *section.protection() == CustomSectionProtection::ReadExecute {
+                        exec_iter.next()
+                    } else {
+                        data_iter.next()
+                    }
+                    .unwrap()
+                    .as_ptr(),
+                )
+            })
+            .collect::<PrimaryMap<SectionIndex, _>>();
+
+        Ok((
+            allocated_functions_result,
+            allocated_function_call_trampolines,
+            allocated_dynamic_function_trampolines,
+            allocated_custom_sections,
+        ))
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Make memory containing compiled code executable.
+    pub(crate) fn publish_compiled_code(&mut self) {
+        self.code_memory.last_mut().unwrap().publish();
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Register DWARF-type exception handling information associated with the code.
+    pub(crate) fn publish_eh_frame(&mut self, eh_frame: Option<&[u8]>) -> Result<(), CompileError> {
+        self.code_memory
+            .last_mut()
+            .unwrap()
+            .unwind_registry_mut()
+            .publish(eh_frame)
+            .map_err(|e| {
+                CompileError::Resource(format!("Error while publishing the unwind code: {}", e))
+            })?;
+        Ok(())
+    }
+
+    /// Shared signature registry.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn signatures(&self) -> &SignatureRegistry {
+        &self.signatures
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    /// Register the frame info for the code memory
+    pub(crate) fn register_frame_info(&mut self, frame_info: GlobalFrameInfoRegistration) {
+        self.code_memory
+            .last_mut()
+            .unwrap()
+            .register_frame_info(frame_info);
+    }
+}
+
+#[cfg(feature = "compiler")]
+impl From<Box<dyn CompilerConfig>> for Engine {
+    fn from(config: Box<dyn CompilerConfig>) -> Self {
+        EngineBuilder::new(config).engine()
+    }
+}
+
+impl From<EngineBuilder> for Engine {
+    fn from(engine_builder: EngineBuilder) -> Self {
+        engine_builder.engine()
+    }
+}
+
+impl From<&Self> for Engine {
+    fn from(engine_ref: &Self) -> Self {
+        engine_ref.cloned()
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(transparent)]
+/// A unique identifier for an Engine.
+pub struct EngineId {
+    id: usize,
+}
+
+impl EngineId {
+    /// Format this identifier as a string.
+    pub fn id(&self) -> String {
+        format!("{}", &self.id)
+    }
+}
+
+impl Clone for EngineId {
+    fn clone(&self) -> Self {
+        Self::default()
+    }
+}
+
+impl Default for EngineId {
+    fn default() -> Self {
+        static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+        Self {
+            id: NEXT_ID.fetch_add(1, SeqCst),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/link.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/link.rs
new file mode 100644
index 0000000..92a0357
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/link.rs
@@ -0,0 +1,183 @@
+//! Linking for Universal-compiled code.
+
+use crate::get_libcall_trampoline;
+use crate::FunctionExtent;
+use std::collections::HashMap;
+use std::ptr::{read_unaligned, write_unaligned};
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::RelocationLike;
+use wasmer_types::{LocalFunctionIndex, ModuleInfo};
+use wasmer_types::{RelocationKind, RelocationTarget, SectionIndex};
+use wasmer_vm::libcalls::function_pointer;
+use wasmer_vm::SectionBodyPtr;
+
+fn apply_relocation(
+    body: usize,
+    r: &impl RelocationLike,
+    allocated_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
+    allocated_sections: &PrimaryMap<SectionIndex, SectionBodyPtr>,
+    libcall_trampolines: SectionIndex,
+    libcall_trampoline_len: usize,
+    riscv_pcrel_hi20s: &mut HashMap<usize, u32>,
+) {
+    let target_func_address: usize = match r.reloc_target() {
+        RelocationTarget::LocalFunc(index) => *allocated_functions[index].ptr as usize,
+        RelocationTarget::LibCall(libcall) => {
+            // Use the direct target of the libcall if the relocation supports
+            // a full 64-bit address. Otherwise use a trampoline.
+            if r.kind() == RelocationKind::Abs8 || r.kind() == RelocationKind::X86PCRel8 {
+                function_pointer(libcall)
+            } else {
+                get_libcall_trampoline(
+                    libcall,
+                    allocated_sections[libcall_trampolines].0 as usize,
+                    libcall_trampoline_len,
+                )
+            }
+        }
+        RelocationTarget::CustomSection(custom_section) => {
+            *allocated_sections[custom_section] as usize
+        }
+    };
+
+    match r.kind() {
+        RelocationKind::Abs8 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u64, reloc_delta);
+        },
+        RelocationKind::X86PCRel4 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u32, reloc_delta as _);
+        },
+        RelocationKind::X86PCRel8 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u64, reloc_delta);
+        },
+        RelocationKind::X86CallPCRel4 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            write_unaligned(reloc_address as *mut u32, reloc_delta as _);
+        },
+        RelocationKind::Arm64Call => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            if (reloc_delta as i64).abs() >= 0x1000_0000 {
+                panic!(
+                    "Relocation to big for {:?} for {:?} with {:x}, current val {:x}",
+                    r.kind(),
+                    r.reloc_target(),
+                    reloc_delta,
+                    read_unaligned(reloc_address as *mut u32)
+                )
+            }
+            let reloc_delta = (((reloc_delta / 4) as u32) & 0x3ff_ffff)
+                | (read_unaligned(reloc_address as *mut u32) & 0xfc00_0000);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::Arm64Movw0 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta =
+                (((reloc_delta & 0xffff) as u32) << 5) | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::Arm64Movw1 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((((reloc_delta >> 16) & 0xffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::Arm64Movw2 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((((reloc_delta >> 32) & 0xffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::Arm64Movw3 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((((reloc_delta >> 48) & 0xffff) as u32) << 5)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::RiscvPCRelHi20 => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+
+            // save for later reference with RiscvPCRelLo12I
+            riscv_pcrel_hi20s.insert(reloc_address, reloc_delta as u32);
+
+            let reloc_delta = ((reloc_delta.wrapping_add(0x800) & 0xfffff000) as u32)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::RiscvPCRelLo12I => unsafe {
+            let (reloc_address, reloc_abs) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((riscv_pcrel_hi20s.get(&(reloc_abs as usize)).expect(
+                "R_RISCV_PCREL_LO12_I relocation target must be a symbol with R_RISCV_PCREL_HI20",
+            ) & 0xfff)
+                << 20)
+                | read_unaligned(reloc_address as *mut u32);
+            write_unaligned(reloc_address as *mut u32, reloc_delta);
+        },
+        RelocationKind::RiscvCall => unsafe {
+            let (reloc_address, reloc_delta) = r.for_address(body, target_func_address as u64);
+            let reloc_delta = ((reloc_delta & 0xfff) << 52)
+                | (reloc_delta.wrapping_add(0x800) & 0xfffff000)
+                | read_unaligned(reloc_address as *mut u64);
+            write_unaligned(reloc_address as *mut u64, reloc_delta);
+        },
+        kind => panic!(
+            "Relocation kind unsupported in the current architecture {}",
+            kind
+        ),
+    }
+}
+
+/// Links a module, patching the allocated functions with the
+/// required relocations and jump tables.
+pub fn link_module<'a>(
+    _module: &ModuleInfo,
+    allocated_functions: &PrimaryMap<LocalFunctionIndex, FunctionExtent>,
+    function_relocations: impl Iterator<
+        Item = (
+            LocalFunctionIndex,
+            impl Iterator<Item = &'a (impl RelocationLike + 'a)>,
+        ),
+    >,
+    allocated_sections: &PrimaryMap<SectionIndex, SectionBodyPtr>,
+    section_relocations: impl Iterator<
+        Item = (
+            SectionIndex,
+            impl Iterator<Item = &'a (impl RelocationLike + 'a)>,
+        ),
+    >,
+    libcall_trampolines: SectionIndex,
+    trampoline_len: usize,
+) {
+    let mut riscv_pcrel_hi20s: HashMap<usize, u32> = HashMap::new();
+
+    for (i, section_relocs) in section_relocations {
+        let body = *allocated_sections[i] as usize;
+        for r in section_relocs {
+            apply_relocation(
+                body,
+                r,
+                allocated_functions,
+                allocated_sections,
+                libcall_trampolines,
+                trampoline_len,
+                &mut riscv_pcrel_hi20s,
+            );
+        }
+    }
+    for (i, function_relocs) in function_relocations {
+        let body = *allocated_functions[i].ptr as usize;
+        for r in function_relocs {
+            apply_relocation(
+                body,
+                r,
+                allocated_functions,
+                allocated_sections,
+                libcall_trampolines,
+                trampoline_len,
+                &mut riscv_pcrel_hi20s,
+            );
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/mod.rs
new file mode 100644
index 0000000..75b4db3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/mod.rs
@@ -0,0 +1,48 @@
+//! The Wasmer Engine.
+
+mod error;
+#[cfg(not(target_arch = "wasm32"))]
+mod resolver;
+#[cfg(not(target_arch = "wasm32"))]
+mod trap;
+#[cfg(not(target_arch = "wasm32"))]
+mod tunables;
+
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+mod artifact;
+#[cfg(feature = "translator")]
+mod builder;
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+mod code_memory;
+#[cfg(feature = "translator")]
+mod inner;
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+mod link;
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+mod unwind;
+
+pub use self::error::{InstantiationError, LinkError};
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::resolver::resolve_imports;
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::trap::*;
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::tunables::{BaseTunables, Tunables};
+
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::artifact::Artifact;
+#[cfg(feature = "translator")]
+pub use self::builder::EngineBuilder;
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::code_memory::CodeMemory;
+#[cfg(feature = "translator")]
+pub use self::inner::{Engine, EngineInner};
+#[cfg(feature = "translator")]
+#[cfg(not(target_arch = "wasm32"))]
+pub use self::link::link_module;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/resolver.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/resolver.rs
new file mode 100644
index 0000000..e469937
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/resolver.rs
@@ -0,0 +1,201 @@
+//! Custom resolution for external references.
+
+use crate::LinkError;
+use more_asserts::assert_ge;
+use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
+use wasmer_types::{
+    ExternType, FunctionIndex, ImportError, ImportIndex, MemoryIndex, ModuleInfo, TableIndex,
+};
+
+use wasmer_vm::{
+    FunctionBodyPtr, Imports, LinearMemory, MemoryStyle, StoreObjects, TableStyle, VMExtern,
+    VMFunctionBody, VMFunctionImport, VMFunctionKind, VMGlobalImport, VMMemoryImport,
+    VMTableImport,
+};
+
+/// Get an `ExternType` given a import index.
+fn get_extern_from_import(module: &ModuleInfo, import_index: &ImportIndex) -> ExternType {
+    match import_index {
+        ImportIndex::Function(index) => {
+            let func = module.signatures[module.functions[*index]].clone();
+            ExternType::Function(func)
+        }
+        ImportIndex::Table(index) => {
+            let table = module.tables[*index];
+            ExternType::Table(table)
+        }
+        ImportIndex::Memory(index) => {
+            let memory = module.memories[*index];
+            ExternType::Memory(memory)
+        }
+        ImportIndex::Global(index) => {
+            let global = module.globals[*index];
+            ExternType::Global(global)
+        }
+    }
+}
+
+/// Get an `ExternType` given an export (and Engine signatures in case is a function).
+fn get_extern_type(context: &StoreObjects, extern_: &VMExtern) -> ExternType {
+    match extern_ {
+        VMExtern::Function(f) => ExternType::Function(f.get(context).signature.clone()),
+        VMExtern::Table(t) => ExternType::Table(*t.get(context).ty()),
+        VMExtern::Memory(m) => ExternType::Memory(m.get(context).ty()),
+        VMExtern::Global(g) => {
+            let global = g.get(context).ty();
+            ExternType::Global(*global)
+        }
+    }
+}
+
+fn get_runtime_size(context: &StoreObjects, extern_: &VMExtern) -> Option<u32> {
+    match extern_ {
+        VMExtern::Table(t) => Some(t.get(context).get_runtime_size()),
+        VMExtern::Memory(m) => Some(m.get(context).get_runtime_size()),
+        _ => None,
+    }
+}
+
+/// This function allows to match all imports of a `ModuleInfo` with concrete definitions provided by
+/// a `Resolver`.
+///
+/// If all imports are satisfied returns an `Imports` instance required for a module instantiation.
+#[allow(clippy::result_large_err)]
+pub fn resolve_imports(
+    module: &ModuleInfo,
+    imports: &[VMExtern],
+    context: &StoreObjects,
+    finished_dynamic_function_trampolines: &BoxedSlice<FunctionIndex, FunctionBodyPtr>,
+    memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
+    _table_styles: &PrimaryMap<TableIndex, TableStyle>,
+) -> Result<Imports, LinkError> {
+    let mut function_imports = PrimaryMap::with_capacity(module.num_imported_functions);
+    let mut table_imports = PrimaryMap::with_capacity(module.num_imported_tables);
+    let mut memory_imports = PrimaryMap::with_capacity(module.num_imported_memories);
+    let mut global_imports = PrimaryMap::with_capacity(module.num_imported_globals);
+
+    for (
+        wasmer_types::ImportKey {
+            module: module_name,
+            field,
+            import_idx,
+        },
+        import_index,
+    ) in module.imports.iter()
+    {
+        let import_extern = get_extern_from_import(module, import_index);
+        let resolved = if let Some(r) = imports.get(*import_idx as usize) {
+            r
+        } else {
+            return Err(LinkError::Import(
+                module_name.to_string(),
+                field.to_string(),
+                ImportError::UnknownImport(import_extern),
+            ));
+        };
+        let extern_type = get_extern_type(context, resolved);
+        let runtime_size = get_runtime_size(context, resolved);
+        if !extern_type.is_compatible_with(&import_extern, runtime_size) {
+            return Err(LinkError::Import(
+                module_name.to_string(),
+                field.to_string(),
+                ImportError::IncompatibleType(import_extern, extern_type),
+            ));
+        }
+        match *resolved {
+            VMExtern::Function(handle) => {
+                let f = handle.get(context);
+                let address = match f.kind {
+                    VMFunctionKind::Dynamic => {
+                        // If this is a dynamic imported function,
+                        // the address of the function is the address of the
+                        // reverse trampoline.
+                        let index = FunctionIndex::new(function_imports.len());
+                        finished_dynamic_function_trampolines[index].0 as *mut VMFunctionBody as _
+                    }
+                    VMFunctionKind::Static => unsafe { f.anyfunc.as_ptr().as_ref().func_ptr },
+                };
+
+                function_imports.push(VMFunctionImport {
+                    body: address,
+                    environment: unsafe { f.anyfunc.as_ptr().as_ref().vmctx },
+                    handle,
+                });
+            }
+            VMExtern::Table(handle) => {
+                let t = handle.get(context);
+                match import_index {
+                    ImportIndex::Table(index) => {
+                        let import_table_ty = t.ty();
+                        let expected_table_ty = &module.tables[*index];
+                        if import_table_ty.ty != expected_table_ty.ty {
+                            return Err(LinkError::Import(
+                                module_name.to_string(),
+                                field.to_string(),
+                                ImportError::IncompatibleType(import_extern, extern_type),
+                            ));
+                        }
+
+                        table_imports.push(VMTableImport {
+                            definition: t.vmtable(),
+                            handle,
+                        });
+                    }
+                    _ => {
+                        unreachable!("Table resolution did not match");
+                    }
+                }
+            }
+            VMExtern::Memory(handle) => {
+                let m = handle.get(context);
+                match import_index {
+                    ImportIndex::Memory(index) => {
+                        // Sanity-check: Ensure that the imported memory has at least
+                        // guard-page protections the importing module expects it to have.
+                        let export_memory_style = m.style();
+                        let import_memory_style = &memory_styles[*index];
+                        if let (
+                            MemoryStyle::Static { bound, .. },
+                            MemoryStyle::Static {
+                                bound: import_bound,
+                                ..
+                            },
+                        ) = (export_memory_style, &import_memory_style)
+                        {
+                            assert_ge!(bound, *import_bound);
+                        }
+                        assert_ge!(
+                            export_memory_style.offset_guard_size(),
+                            import_memory_style.offset_guard_size()
+                        );
+                    }
+                    _ => {
+                        // This should never be reached, as we did compatibility
+                        // checks before
+                        panic!("Memory resolution didn't matched");
+                    }
+                }
+
+                memory_imports.push(VMMemoryImport {
+                    definition: m.vmmemory(),
+                    handle,
+                });
+            }
+
+            VMExtern::Global(handle) => {
+                let g = handle.get(context);
+                global_imports.push(VMGlobalImport {
+                    definition: g.vmglobal(),
+                    handle,
+                });
+            }
+        }
+    }
+
+    Ok(Imports::new(
+        function_imports,
+        table_imports,
+        memory_imports,
+        global_imports,
+    ))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/frame_info.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/frame_info.rs
new file mode 100644
index 0000000..4222acc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/frame_info.rs
@@ -0,0 +1,243 @@
+//! This module is used for having backtraces in the Wasm runtime.
+//! Once the Compiler has compiled the ModuleInfo, and we have a set of
+//! compiled functions (addresses and function index) and a module,
+//! then we can use this to set a backtrace for that module.
+//!
+//! # Example
+//! ```ignore
+//! use wasmer_vm::{FRAME_INFO};
+//! use wasmer_types::ModuleInfo;
+//!
+//! let module: ModuleInfo = ...;
+//! FRAME_INFO.register(module, compiled_functions);
+//! ```
+use std::cmp;
+use std::collections::BTreeMap;
+use std::sync::{Arc, RwLock};
+use wasmer_types::entity::{BoxedSlice, EntityRef, PrimaryMap};
+use wasmer_types::{
+    CompiledFunctionFrameInfo, FrameInfo, LocalFunctionIndex, ModuleInfo, TrapInformation,
+};
+use wasmer_vm::FunctionBodyPtr;
+
+lazy_static::lazy_static! {
+    /// This is a global cache of backtrace frame information for all active
+    ///
+    /// This global cache is used during `Trap` creation to symbolicate frames.
+    /// This is populated on module compilation, and it is cleared out whenever
+    /// all references to a module are dropped.
+    pub static ref FRAME_INFO: RwLock<GlobalFrameInfo> = Default::default();
+}
+
+#[derive(Default)]
+pub struct GlobalFrameInfo {
+    /// An internal map that keeps track of backtrace frame information for
+    /// each module.
+    ///
+    /// This map is morally a map of ranges to a map of information for that
+    /// module. Each module is expected to reside in a disjoint section of
+    /// contiguous memory. No modules can overlap.
+    ///
+    /// The key of this map is the highest address in the module and the value
+    /// is the module's information, which also contains the start address.
+    ranges: BTreeMap<usize, ModuleInfoFrameInfo>,
+}
+
+/// An RAII structure used to unregister a module's frame information when the
+/// module is destroyed.
+pub struct GlobalFrameInfoRegistration {
+    /// The key that will be removed from the global `ranges` map when this is
+    /// dropped.
+    key: usize,
+}
+
+#[derive(Debug)]
+struct ModuleInfoFrameInfo {
+    start: usize,
+    functions: BTreeMap<usize, FunctionInfo>,
+    module: Arc<ModuleInfo>,
+    frame_infos: PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>,
+}
+
+impl ModuleInfoFrameInfo {
+    fn function_debug_info(&self, local_index: LocalFunctionIndex) -> &CompiledFunctionFrameInfo {
+        self.frame_infos.get(local_index).unwrap()
+    }
+
+    /// Gets a function given a pc
+    fn function_info(&self, pc: usize) -> Option<&FunctionInfo> {
+        let (end, func) = self.functions.range(pc..).next()?;
+        if func.start <= pc && pc <= *end {
+            Some(func)
+        } else {
+            None
+        }
+    }
+}
+
+#[derive(Debug)]
+struct FunctionInfo {
+    start: usize,
+    local_index: LocalFunctionIndex,
+}
+
+impl GlobalFrameInfo {
+    /// Fetches frame information about a program counter in a backtrace.
+    ///
+    /// Returns an object if this `pc` is known to some previously registered
+    /// module, or returns `None` if no information can be found.
+    pub fn lookup_frame_info(&self, pc: usize) -> Option<FrameInfo> {
+        let module = self.module_info(pc)?;
+        let func = module.function_info(pc)?;
+
+        // Use our relative position from the start of the function to find the
+        // machine instruction that corresponds to `pc`, which then allows us to
+        // map that to a wasm original source location.
+        let rel_pos = pc - func.start;
+        let instr_map = &module.function_debug_info(func.local_index).address_map;
+        let pos = match instr_map
+            .instructions
+            .binary_search_by_key(&rel_pos, |map| map.code_offset)
+        {
+            // Exact hit!
+            Ok(pos) => Some(pos),
+
+            // This *would* be at the first slot in the array, so no
+            // instructions cover `pc`.
+            Err(0) => None,
+
+            // This would be at the `nth` slot, so check `n-1` to see if we're
+            // part of that instruction. This happens due to the minus one when
+            // this function is called form trap symbolication, where we don't
+            // always get called with a `pc` that's an exact instruction
+            // boundary.
+            Err(n) => {
+                let instr = &instr_map.instructions[n - 1];
+                if instr.code_offset <= rel_pos && rel_pos < instr.code_offset + instr.code_len {
+                    Some(n - 1)
+                } else {
+                    None
+                }
+            }
+        };
+
+        let instr = match pos {
+            Some(pos) => instr_map.instructions[pos].srcloc,
+            // Some compilers don't emit yet the full trap information for each of
+            // the instructions (such as LLVM).
+            // In case no specific instruction is found, we return by default the
+            // start offset of the function.
+            None => instr_map.start_srcloc,
+        };
+        let func_index = module.module.func_index(func.local_index);
+        Some(FrameInfo::new(
+            module.module.name(),
+            func_index.index() as u32,
+            module.module.function_names.get(&func_index).cloned(),
+            instr_map.start_srcloc,
+            instr,
+        ))
+    }
+
+    /// Fetches trap information about a program counter in a backtrace.
+    pub fn lookup_trap_info(&self, pc: usize) -> Option<&TrapInformation> {
+        let module = self.module_info(pc)?;
+        let func = module.function_info(pc)?;
+        let traps = &module.function_debug_info(func.local_index).traps;
+        let idx = traps
+            .binary_search_by_key(&((pc - func.start) as u32), |info| info.code_offset)
+            .ok()?;
+        Some(&traps[idx])
+    }
+
+    /// Gets a module given a pc
+    fn module_info(&self, pc: usize) -> Option<&ModuleInfoFrameInfo> {
+        let (end, module_info) = self.ranges.range(pc..).next()?;
+        if module_info.start <= pc && pc <= *end {
+            Some(module_info)
+        } else {
+            None
+        }
+    }
+}
+
+impl Drop for GlobalFrameInfoRegistration {
+    fn drop(&mut self) {
+        if let Ok(mut info) = FRAME_INFO.write() {
+            info.ranges.remove(&self.key);
+        }
+    }
+}
+
+/// Represents a continuous region of executable memory starting with a function
+/// entry point.
+#[derive(Debug)]
+#[repr(C)]
+pub struct FunctionExtent {
+    /// Entry point for normal entry of the function. All addresses in the
+    /// function lie after this address.
+    pub ptr: FunctionBodyPtr,
+    /// Length in bytes.
+    pub length: usize,
+}
+
+/// Registers a new compiled module's frame information.
+///
+/// This function will register the `names` information for all of the
+/// compiled functions within `module`. If the `module` has no functions
+/// then `None` will be returned. Otherwise the returned object, when
+/// dropped, will be used to unregister all name information from this map.
+pub fn register(
+    module: Arc<ModuleInfo>,
+    finished_functions: &BoxedSlice<LocalFunctionIndex, FunctionExtent>,
+    frame_infos: PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>,
+) -> Option<GlobalFrameInfoRegistration> {
+    let mut min = usize::max_value();
+    let mut max = 0;
+    let mut functions = BTreeMap::new();
+    for (
+        i,
+        FunctionExtent {
+            ptr: start,
+            length: len,
+        },
+    ) in finished_functions.iter()
+    {
+        let start = **start as usize;
+        // end is "last byte" of the function code
+        let end = start + len - 1;
+        min = cmp::min(min, start);
+        max = cmp::max(max, end);
+        let func = FunctionInfo {
+            start,
+            local_index: i,
+        };
+        assert!(functions.insert(end, func).is_none());
+    }
+    if functions.is_empty() {
+        return None;
+    }
+
+    let mut info = FRAME_INFO.write().unwrap();
+    // First up assert that our chunk of jit functions doesn't collide with
+    // any other known chunks of jit functions...
+    if let Some((_, prev)) = info.ranges.range(max..).next() {
+        assert!(prev.start > max);
+    }
+    if let Some((prev_end, _)) = info.ranges.range(..=min).next_back() {
+        assert!(*prev_end < min);
+    }
+
+    // ... then insert our range and assert nothing was there previously
+    let prev = info.ranges.insert(
+        max,
+        ModuleInfoFrameInfo {
+            start: min,
+            functions,
+            module,
+            frame_infos,
+        },
+    );
+    assert!(prev.is_none());
+    Some(GlobalFrameInfoRegistration { key: max })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/mod.rs
new file mode 100644
index 0000000..511a35e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/mod.rs
@@ -0,0 +1,6 @@
+mod frame_info;
+mod stack;
+pub use frame_info::{
+    register as register_frame_info, FunctionExtent, GlobalFrameInfoRegistration, FRAME_INFO,
+};
+pub use stack::get_trace_and_trapcode;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/stack.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/stack.rs
new file mode 100644
index 0000000..aa07f93
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/trap/stack.rs
@@ -0,0 +1,66 @@
+use super::frame_info::{GlobalFrameInfo, FRAME_INFO};
+use backtrace::Backtrace;
+use wasmer_types::{FrameInfo, TrapCode};
+use wasmer_vm::Trap;
+
+/// Given a `Trap`, this function returns the Wasm trace and the trap code.
+pub fn get_trace_and_trapcode(trap: &Trap) -> (Vec<FrameInfo>, Option<TrapCode>) {
+    let info = FRAME_INFO.read().unwrap();
+    match &trap {
+        // A user error
+        Trap::User(_err) => (wasm_trace(&info, None, &Backtrace::new_unresolved()), None),
+        // A trap caused by the VM being Out of Memory
+        Trap::OOM { backtrace } => (wasm_trace(&info, None, backtrace), None),
+        // A trap caused by an error on the generated machine code for a Wasm function
+        Trap::Wasm {
+            pc,
+            signal_trap,
+            backtrace,
+        } => {
+            let trap_code = info
+                .lookup_trap_info(*pc)
+                .map_or(signal_trap.unwrap_or(TrapCode::StackOverflow), |info| {
+                    info.trap_code
+                });
+
+            (wasm_trace(&info, Some(*pc), backtrace), Some(trap_code))
+        }
+        // A trap triggered manually from the Wasmer runtime
+        Trap::Lib {
+            trap_code,
+            backtrace,
+        } => (wasm_trace(&info, None, backtrace), Some(*trap_code)),
+    }
+}
+
+fn wasm_trace(
+    info: &GlobalFrameInfo,
+    trap_pc: Option<usize>,
+    backtrace: &Backtrace,
+) -> Vec<FrameInfo> {
+    // Let's construct the trace
+    backtrace
+        .frames()
+        .iter()
+        .filter_map(|frame| {
+            let pc = frame.ip() as usize;
+            if pc == 0 {
+                None
+            } else {
+                // Note that we need to be careful about the pc we pass in here to
+                // lookup frame information. This program counter is used to
+                // translate back to an original source location in the origin wasm
+                // module. If this pc is the exact pc that the trap happened at,
+                // then we look up that pc precisely. Otherwise backtrace
+                // information typically points at the pc *after* the call
+                // instruction (because otherwise it's likely a call instruction on
+                // the stack). In that case we want to lookup information for the
+                // previous instruction (the call instruction) so we subtract one as
+                // the lookup.
+                let pc_to_lookup = if Some(pc) == trap_pc { pc } else { pc - 1 };
+                Some(pc_to_lookup)
+            }
+        })
+        .filter_map(|pc| info.lookup_frame_info(pc))
+        .collect::<Vec<_>>()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/tunables.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/tunables.rs
new file mode 100644
index 0000000..266c3bd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/tunables.rs
@@ -0,0 +1,368 @@
+use crate::engine::error::LinkError;
+use std::ptr::NonNull;
+use wasmer_types::entity::{EntityRef, PrimaryMap};
+use wasmer_types::{
+    GlobalType, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType,
+    ModuleInfo, Pages, PointerWidth, TableIndex, TableType, Target,
+};
+use wasmer_vm::{InternalStoreHandle, MemoryError, StoreObjects};
+use wasmer_vm::{MemoryStyle, TableStyle};
+use wasmer_vm::{VMConfig, VMGlobal, VMMemory, VMTable};
+use wasmer_vm::{VMMemoryDefinition, VMTableDefinition};
+
+/// An engine delegates the creation of memories, tables, and globals
+/// to a foreign implementor of this trait.
+pub trait Tunables {
+    /// Construct a `MemoryStyle` for the provided `MemoryType`
+    fn memory_style(&self, memory: &MemoryType) -> MemoryStyle;
+
+    /// Construct a `TableStyle` for the provided `TableType`
+    fn table_style(&self, table: &TableType) -> TableStyle;
+
+    /// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`].
+    fn create_host_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+    ) -> Result<VMMemory, MemoryError>;
+
+    /// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`].
+    ///
+    /// # Safety
+    /// - `vm_definition_location` must point to a valid location in VM memory.
+    unsafe fn create_vm_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+        vm_definition_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<VMMemory, MemoryError>;
+
+    /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String>;
+
+    /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`].
+    ///
+    /// # Safety
+    /// - `vm_definition_location` must point to a valid location in VM memory.
+    unsafe fn create_vm_table(
+        &self,
+        ty: &TableType,
+        style: &TableStyle,
+        vm_definition_location: NonNull<VMTableDefinition>,
+    ) -> Result<VMTable, String>;
+
+    /// Create a global with an unset value.
+    fn create_global(&self, ty: GlobalType) -> Result<VMGlobal, String> {
+        Ok(VMGlobal::new(ty))
+    }
+
+    /// Allocate memory for just the memories of the current module.
+    ///
+    /// # Safety
+    /// - `memory_definition_locations` must point to a valid locations in VM memory.
+    #[allow(clippy::result_large_err)]
+    unsafe fn create_memories(
+        &self,
+        context: &mut StoreObjects,
+        module: &ModuleInfo,
+        memory_styles: &PrimaryMap<MemoryIndex, MemoryStyle>,
+        memory_definition_locations: &[NonNull<VMMemoryDefinition>],
+    ) -> Result<PrimaryMap<LocalMemoryIndex, InternalStoreHandle<VMMemory>>, LinkError> {
+        let num_imports = module.num_imported_memories;
+        let mut memories: PrimaryMap<LocalMemoryIndex, _> =
+            PrimaryMap::with_capacity(module.memories.len() - num_imports);
+        for (index, mdl) in memory_definition_locations
+            .iter()
+            .enumerate()
+            .take(module.memories.len())
+            .skip(num_imports)
+        {
+            let mi = MemoryIndex::new(index);
+            let ty = &module.memories[mi];
+            let style = &memory_styles[mi];
+            memories.push(InternalStoreHandle::new(
+                context,
+                self.create_vm_memory(ty, style, *mdl)
+                    .map_err(|e| LinkError::Resource(format!("Failed to create memory: {}", e)))?,
+            ));
+        }
+        Ok(memories)
+    }
+
+    /// Allocate memory for just the tables of the current module.
+    ///
+    /// # Safety
+    ///
+    /// To be done
+    #[allow(clippy::result_large_err)]
+    unsafe fn create_tables(
+        &self,
+        context: &mut StoreObjects,
+        module: &ModuleInfo,
+        table_styles: &PrimaryMap<TableIndex, TableStyle>,
+        table_definition_locations: &[NonNull<VMTableDefinition>],
+    ) -> Result<PrimaryMap<LocalTableIndex, InternalStoreHandle<VMTable>>, LinkError> {
+        let num_imports = module.num_imported_tables;
+        let mut tables: PrimaryMap<LocalTableIndex, _> =
+            PrimaryMap::with_capacity(module.tables.len() - num_imports);
+        for (index, tdl) in table_definition_locations
+            .iter()
+            .enumerate()
+            .take(module.tables.len())
+            .skip(num_imports)
+        {
+            let ti = TableIndex::new(index);
+            let ty = &module.tables[ti];
+            let style = &table_styles[ti];
+            tables.push(InternalStoreHandle::new(
+                context,
+                self.create_vm_table(ty, style, *tdl)
+                    .map_err(LinkError::Resource)?,
+            ));
+        }
+        Ok(tables)
+    }
+
+    /// Allocate memory for just the globals of the current module,
+    /// with initializers applied.
+    #[allow(clippy::result_large_err)]
+    fn create_globals(
+        &self,
+        context: &mut StoreObjects,
+        module: &ModuleInfo,
+    ) -> Result<PrimaryMap<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>, LinkError> {
+        let num_imports = module.num_imported_globals;
+        let mut vmctx_globals = PrimaryMap::with_capacity(module.globals.len() - num_imports);
+
+        for &global_type in module.globals.values().skip(num_imports) {
+            vmctx_globals.push(InternalStoreHandle::new(
+                context,
+                self.create_global(global_type)
+                    .map_err(LinkError::Resource)?,
+            ));
+        }
+
+        Ok(vmctx_globals)
+    }
+
+    /// Get the VMConfig for this tunables
+    /// Currently, VMConfig have optional Stack size
+    /// If wasm_stack_size is left to None (the default value)
+    /// then the global stack size will be use
+    /// Else the defined stack size will be used. Size is in byte
+    /// and the value might be rounded to sane value is needed.
+    fn vmconfig(&self) -> &VMConfig {
+        &VMConfig {
+            wasm_stack_size: None,
+        }
+    }
+}
+
+/// Tunable parameters for WebAssembly compilation.
+/// This is the reference implementation of the `Tunables` trait,
+/// used by default.
+///
+/// You can use this as a template for creating a custom Tunables
+/// implementation or use composition to wrap your Tunables around
+/// this one. The later approach is demonstrated in the
+/// tunables-limit-memory example.
+#[derive(Clone)]
+pub struct BaseTunables {
+    /// For static heaps, the size in wasm pages of the heap protected by bounds checking.
+    pub static_memory_bound: Pages,
+
+    /// The size in bytes of the offset guard for static heaps.
+    pub static_memory_offset_guard_size: u64,
+
+    /// The size in bytes of the offset guard for dynamic heaps.
+    pub dynamic_memory_offset_guard_size: u64,
+}
+
+impl BaseTunables {
+    /// Get the `BaseTunables` for a specific Target
+    pub fn for_target(target: &Target) -> Self {
+        let triple = target.triple();
+        let pointer_width: PointerWidth = triple.pointer_width().unwrap();
+        let (static_memory_bound, static_memory_offset_guard_size): (Pages, u64) =
+            match pointer_width {
+                PointerWidth::U16 => (0x400.into(), 0x1000),
+                PointerWidth::U32 => (0x4000.into(), 0x1_0000),
+                // Static Memory Bound:
+                //   Allocating 4 GiB of address space let us avoid the
+                //   need for explicit bounds checks.
+                // Static Memory Guard size:
+                //   Allocating 2 GiB of address space lets us translate wasm
+                //   offsets into x86 offsets as aggressively as we can.
+                PointerWidth::U64 => (0x1_0000.into(), 0x8000_0000),
+            };
+
+        // Allocate a small guard to optimize common cases but without
+        // wasting too much memory.
+        // The Windows memory manager seems more laxed than the other ones
+        // And a guard of just 1 page may not be enough is some borderline cases
+        // So using 2 pages for guard on this platform
+        #[cfg(target_os = "windows")]
+        let dynamic_memory_offset_guard_size: u64 = 0x2_0000;
+        #[cfg(not(target_os = "windows"))]
+        let dynamic_memory_offset_guard_size: u64 = 0x1_0000;
+
+        Self {
+            static_memory_bound,
+            static_memory_offset_guard_size,
+            dynamic_memory_offset_guard_size,
+        }
+    }
+}
+
+impl Tunables for BaseTunables {
+    /// Get a `MemoryStyle` for the provided `MemoryType`
+    fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+        // A heap with a maximum that doesn't exceed the static memory bound specified by the
+        // tunables make it static.
+        //
+        // If the module doesn't declare an explicit maximum treat it as 4GiB.
+        let maximum = memory.maximum.unwrap_or_else(Pages::max_value);
+        if maximum <= self.static_memory_bound {
+            MemoryStyle::Static {
+                // Bound can be larger than the maximum for performance reasons
+                bound: self.static_memory_bound,
+                offset_guard_size: self.static_memory_offset_guard_size,
+            }
+        } else {
+            MemoryStyle::Dynamic {
+                offset_guard_size: self.dynamic_memory_offset_guard_size,
+            }
+        }
+    }
+
+    /// Get a [`TableStyle`] for the provided [`TableType`].
+    fn table_style(&self, _table: &TableType) -> TableStyle {
+        TableStyle::CallerChecksSignature
+    }
+
+    /// Create a memory owned by the host given a [`MemoryType`] and a [`MemoryStyle`].
+    fn create_host_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+    ) -> Result<VMMemory, MemoryError> {
+        VMMemory::new(ty, style)
+    }
+
+    /// Create a memory owned by the VM given a [`MemoryType`] and a [`MemoryStyle`].
+    ///
+    /// # Safety
+    /// - `vm_definition_location` must point to a valid, owned `VMMemoryDefinition`,
+    ///   for example in `VMContext`.
+    unsafe fn create_vm_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+        vm_definition_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<VMMemory, MemoryError> {
+        VMMemory::from_definition(ty, style, vm_definition_location)
+    }
+
+    /// Create a table owned by the host given a [`TableType`] and a [`TableStyle`].
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
+        VMTable::new(ty, style)
+    }
+
+    /// Create a table owned by the VM given a [`TableType`] and a [`TableStyle`].
+    ///
+    /// # Safety
+    /// - `vm_definition_location` must point to a valid, owned `VMTableDefinition`,
+    ///   for example in `VMContext`.
+    unsafe fn create_vm_table(
+        &self,
+        ty: &TableType,
+        style: &TableStyle,
+        vm_definition_location: NonNull<VMTableDefinition>,
+    ) -> Result<VMTable, String> {
+        VMTable::from_definition(ty, style, vm_definition_location)
+    }
+}
+
+impl Tunables for Box<dyn Tunables + Send + Sync> {
+    fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+        self.as_ref().memory_style(memory)
+    }
+
+    fn table_style(&self, table: &TableType) -> TableStyle {
+        self.as_ref().table_style(table)
+    }
+
+    fn create_host_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+    ) -> Result<VMMemory, MemoryError> {
+        self.as_ref().create_host_memory(ty, style)
+    }
+
+    unsafe fn create_vm_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+        vm_definition_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<VMMemory, MemoryError> {
+        self.as_ref()
+            .create_vm_memory(ty, style, vm_definition_location)
+    }
+
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
+        self.as_ref().create_host_table(ty, style)
+    }
+
+    unsafe fn create_vm_table(
+        &self,
+        ty: &TableType,
+        style: &TableStyle,
+        vm_definition_location: NonNull<VMTableDefinition>,
+    ) -> Result<VMTable, String> {
+        self.as_ref()
+            .create_vm_table(ty, style, vm_definition_location)
+    }
+}
+
+impl Tunables for std::sync::Arc<dyn Tunables + Send + Sync> {
+    fn memory_style(&self, memory: &MemoryType) -> MemoryStyle {
+        self.as_ref().memory_style(memory)
+    }
+
+    fn table_style(&self, table: &TableType) -> TableStyle {
+        self.as_ref().table_style(table)
+    }
+
+    fn create_host_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+    ) -> Result<VMMemory, MemoryError> {
+        self.as_ref().create_host_memory(ty, style)
+    }
+
+    unsafe fn create_vm_memory(
+        &self,
+        ty: &MemoryType,
+        style: &MemoryStyle,
+        vm_definition_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<VMMemory, MemoryError> {
+        self.as_ref()
+            .create_vm_memory(ty, style, vm_definition_location)
+    }
+
+    fn create_host_table(&self, ty: &TableType, style: &TableStyle) -> Result<VMTable, String> {
+        self.as_ref().create_host_table(ty, style)
+    }
+
+    unsafe fn create_vm_table(
+        &self,
+        ty: &TableType,
+        style: &TableStyle,
+        vm_definition_location: NonNull<VMTableDefinition>,
+    ) -> Result<VMTable, String> {
+        self.as_ref()
+            .create_vm_table(ty, style, vm_definition_location)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/dummy.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/dummy.rs
new file mode 100644
index 0000000..0a34e29
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/dummy.rs
@@ -0,0 +1,32 @@
+//! Module for Dummy unwind registry.
+
+use wasmer_types::CompiledFunctionUnwindInfo;
+
+/// Represents a registry of function unwind information when the host system
+/// support any one in specific.
+pub struct DummyUnwindRegistry {}
+
+impl DummyUnwindRegistry {
+    /// Creates a new unwind registry with the given base address.
+    pub fn new() -> Self {
+        DummyUnwindRegistry {}
+    }
+
+    /// Registers a function given the start offset, length, and unwind information.
+    pub fn register(
+        &mut self,
+        _base_address: usize,
+        _func_start: u32,
+        _func_len: u32,
+        _info: &CompiledFunctionUnwindInfo,
+    ) -> Result<(), String> {
+        // Do nothing
+        Ok(())
+    }
+
+    /// Publishes all registered functions.
+    pub fn publish(&mut self, eh_frame: Option<&[u8]>) -> Result<(), String> {
+        // Do nothing
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/mod.rs
new file mode 100644
index 0000000..7d61694
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/mod.rs
@@ -0,0 +1,13 @@
+cfg_if::cfg_if! {
+    if #[cfg(all(windows, target_arch = "x86_64"))] {
+        mod windows_x64;
+        pub use self::windows_x64::*;
+    } else if #[cfg(unix)] {
+        mod systemv;
+        pub use self::systemv::*;
+    } else {
+        // Otherwise, we provide a dummy fallback without unwinding
+        mod dummy;
+        pub use self::dummy::DummyUnwindRegistry as UnwindRegistry;
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/systemv.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/systemv.rs
new file mode 100644
index 0000000..fc1c4df
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/systemv.rs
@@ -0,0 +1,124 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Module for System V ABI unwind registry.
+
+use wasmer_types::CompiledFunctionUnwindInfoReference;
+
+/// Represents a registry of function unwind information for System V ABI.
+pub struct UnwindRegistry {
+    registrations: Vec<usize>,
+    published: bool,
+}
+
+extern "C" {
+    // libunwind import
+    fn __register_frame(fde: *const u8);
+    fn __deregister_frame(fde: *const u8);
+}
+
+impl UnwindRegistry {
+    /// Creates a new unwind registry with the given base address.
+    pub fn new() -> Self {
+        Self {
+            registrations: Vec::new(),
+            published: false,
+        }
+    }
+
+    /// Registers a function given the start offset, length, and unwind information.
+    pub fn register(
+        &mut self,
+        _base_address: usize,
+        _func_start: u32,
+        _func_len: u32,
+        info: &CompiledFunctionUnwindInfoReference,
+    ) -> Result<(), String> {
+        match info {
+            CompiledFunctionUnwindInfoReference::Dwarf => {}
+            _ => return Err(format!("unsupported unwind information {info:?}")),
+        };
+        Ok(())
+    }
+
+    /// Publishes all registered functions.
+    pub fn publish(&mut self, eh_frame: Option<&[u8]>) -> Result<(), String> {
+        if self.published {
+            return Err("unwind registry has already been published".to_string());
+        }
+
+        if let Some(eh_frame) = eh_frame {
+            unsafe {
+                self.register_frames(eh_frame);
+            }
+        }
+
+        self.published = true;
+
+        Ok(())
+    }
+
+    #[allow(clippy::cast_ptr_alignment)]
+    unsafe fn register_frames(&mut self, eh_frame: &[u8]) {
+        if cfg!(any(
+            all(target_os = "linux", target_env = "gnu"),
+            target_os = "freebsd"
+        )) {
+            // Registering an empty `eh_frame` (i.e. which
+            // contains empty FDEs) cause problems on Linux when
+            // deregistering it. We must avoid this
+            // scenario. Usually, this is handled upstream by the
+            // compilers.
+            debug_assert_ne!(
+                eh_frame,
+                &[0, 0, 0, 0],
+                "`eh_frame` seems to contain empty FDEs"
+            );
+
+            // On gnu (libgcc), `__register_frame` will walk the FDEs until an entry of length 0
+            let ptr = eh_frame.as_ptr();
+            __register_frame(ptr);
+            self.registrations.push(ptr as usize);
+        } else {
+            // For libunwind, `__register_frame` takes a pointer to a single FDE
+            let start = eh_frame.as_ptr();
+            let end = start.add(eh_frame.len());
+            let mut current = start;
+
+            // Walk all of the entries in the frame table and register them
+            while current < end {
+                let len = std::ptr::read::<u32>(current as *const u32) as usize;
+
+                // Skip over the CIE and zero-length FDEs.
+                // LLVM's libunwind emits a warning on zero-length FDEs.
+                if current != start && len != 0 {
+                    __register_frame(current);
+                    self.registrations.push(current as usize);
+                }
+
+                // Move to the next table entry (+4 because the length itself is not inclusive)
+                current = current.add(len + 4);
+            }
+        }
+    }
+}
+
+impl Drop for UnwindRegistry {
+    fn drop(&mut self) {
+        if self.published {
+            unsafe {
+                // libgcc stores the frame entries as a linked list in decreasing sort order
+                // based on the PC value of the registered entry.
+                //
+                // As we store the registrations in increasing order, it would be O(N^2) to
+                // deregister in that order.
+                //
+                // To ensure that we just pop off the first element in the list upon every
+                // deregistration, walk our list of registrations backwards.
+                for fde in self.registrations.iter().rev() {
+                    __deregister_frame(*fde as *const _);
+                }
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/windows_x64.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/windows_x64.rs
new file mode 100644
index 0000000..88259db
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/engine/unwind/windows_x64.rs
@@ -0,0 +1,102 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Module for Windows x64 ABI unwind registry.
+use std::collections::HashMap;
+use wasmer_types::CompiledFunctionUnwindInfoReference;
+use winapi::um::winnt;
+
+/// Represents a registry of function unwind information for Windows x64 ABI.
+pub struct UnwindRegistry {
+    // A hashmap mapping the baseaddress with the registered runtime functions
+    functions: HashMap<usize, Vec<winnt::RUNTIME_FUNCTION>>,
+    published: bool,
+}
+
+impl UnwindRegistry {
+    /// Creates a new unwind registry with the given base address.
+    pub fn new() -> Self {
+        Self {
+            functions: HashMap::new(),
+            published: false,
+        }
+    }
+
+    /// Registers a function given the start offset, length, and unwind information.
+    pub fn register(
+        &mut self,
+        base_address: usize,
+        func_start: u32,
+        func_len: u32,
+        info: &CompiledFunctionUnwindInfoReference,
+    ) -> Result<(), String> {
+        if self.published {
+            return Err("unwind registry has already been published".to_string());
+        }
+
+        match info {
+            CompiledFunctionUnwindInfoReference::WindowsX64(_) => {}
+            _ => return Err("unsupported unwind information".to_string()),
+        };
+
+        let mut entry = winnt::RUNTIME_FUNCTION::default();
+
+        entry.BeginAddress = func_start;
+        entry.EndAddress = func_start + func_len;
+
+        // The unwind information should be immediately following the function
+        // with padding for 4 byte alignment
+        unsafe {
+            *entry.u.UnwindInfoAddress_mut() = (entry.EndAddress + 3) & !3;
+        }
+        let entries = self.functions.entry(base_address).or_insert_with(Vec::new);
+
+        entries.push(entry);
+
+        Ok(())
+    }
+
+    /// Publishes all registered functions.
+    pub fn publish(&mut self, _eh_frame: Option<&[u8]>) -> Result<(), String> {
+        if self.published {
+            return Err("unwind registry has already been published".to_string());
+        }
+
+        self.published = true;
+
+        if !self.functions.is_empty() {
+            for (base_address, functions) in self.functions.iter_mut() {
+                // Windows heap allocations are 32-bit aligned, but assert just in case
+                assert_eq!(
+                    (functions.as_mut_ptr() as u64) % 4,
+                    0,
+                    "function table allocation was not aligned"
+                );
+                unsafe {
+                    if winnt::RtlAddFunctionTable(
+                        functions.as_mut_ptr(),
+                        functions.len() as u32,
+                        *base_address as u64,
+                    ) == 0
+                    {
+                        return Err("failed to register function tables".to_string());
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl Drop for UnwindRegistry {
+    fn drop(&mut self) {
+        if self.published {
+            unsafe {
+                for functions in self.functions.values_mut() {
+                    winnt::RtlDeleteFunctionTable(functions.as_mut_ptr());
+                }
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/lib.rs
new file mode 100644
index 0000000..9ded8d7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/lib.rs
@@ -0,0 +1,84 @@
+//! The `wasmer-compiler` crate provides the necessary abstractions
+//! to create a compiler.
+//!
+//! It provides an universal way of parsing a module via `wasmparser`,
+//! while giving the responsibility of compiling specific function
+//! WebAssembly bodies to the `Compiler` implementation.
+
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::new_without_default, clippy::upper_case_acronyms)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(all(feature = "std", feature = "core"))]
+compile_error!(
+    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
+);
+
+#[cfg(all(not(feature = "std"), not(feature = "core")))]
+compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
+
+#[cfg(feature = "core")]
+extern crate alloc;
+
+#[allow(unused_imports)]
+mod lib {
+    #[cfg(feature = "core")]
+    pub mod std {
+        pub use alloc::{borrow, boxed, str, string, sync, vec};
+        pub use core::fmt;
+        pub use hashbrown as collections;
+    }
+
+    #[cfg(feature = "std")]
+    pub mod std {
+        pub use std::{borrow, boxed, collections, fmt, str, string, sync, vec};
+    }
+}
+
+mod engine;
+mod traits;
+
+pub use crate::engine::*;
+pub use crate::traits::*;
+
+#[cfg(feature = "translator")]
+mod artifact_builders;
+
+#[cfg(feature = "translator")]
+pub use self::artifact_builders::*;
+
+#[cfg(feature = "translator")]
+mod compiler;
+
+#[cfg(feature = "translator")]
+#[macro_use]
+mod translator;
+#[cfg(feature = "translator")]
+pub use crate::compiler::{Compiler, CompilerConfig};
+#[cfg(feature = "translator")]
+pub use crate::translator::{
+    from_binaryreadererror_wasmerror, translate_module, wpheaptype_to_type, wptype_to_type,
+    FunctionBinaryReader, FunctionBodyData, FunctionMiddleware, MiddlewareBinaryReader,
+    MiddlewareReaderState, ModuleEnvironment, ModuleMiddleware, ModuleMiddlewareChain,
+    ModuleTranslationState,
+};
+
+pub use wasmer_types::{Addend, CodeOffset, Features};
+
+#[cfg(feature = "translator")]
+/// wasmparser is exported as a module to slim compiler dependencies
+pub use wasmparser;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/traits.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/traits.rs
new file mode 100644
index 0000000..308a29f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/traits.rs
@@ -0,0 +1,93 @@
+//! Generic Artifact abstraction for Wasmer Engines.
+
+use crate::Features;
+use enumset::EnumSet;
+use std::any::Any;
+use std::sync::Arc;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::SerializeError;
+use wasmer_types::{
+    CpuFeature, DataInitializerLike, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle,
+};
+
+/// An `Artifact` is the product that the `Engine`
+/// implementation produce and use.
+///
+/// The `Artifact` contains the compiled data for a given
+/// module as well as extra information needed to run the
+/// module at runtime, such as [`ModuleInfo`] and [`Features`].
+pub trait ArtifactCreate<'a>: Send + Sync + Upcastable {
+    /// Type of `OwnedDataInitializer` returned by the `data_initializers` method
+    type OwnedDataInitializer: DataInitializerLike<'a> + 'a;
+    /// Type of iterator returned by the `data_initializers` method
+    type OwnedDataInitializerIterator: Iterator<Item = Self::OwnedDataInitializer>;
+
+    /// Create a `ModuleInfo` for instantiation
+    fn create_module_info(&'a self) -> Arc<ModuleInfo>;
+
+    /// Sets the `ModuleInfo` name
+    fn set_module_info_name(&'a mut self, name: String) -> bool;
+
+    /// Returns the `ModuleInfo` for instantiation
+    fn module_info(&'a self) -> &ModuleInfo;
+
+    /// Returns the features for this Artifact
+    fn features(&'a self) -> &Features;
+
+    /// Returns the CPU features for this Artifact
+    fn cpu_features(&'a self) -> EnumSet<CpuFeature>;
+
+    /// Returns the memory styles associated with this `Artifact`.
+    fn memory_styles(&'a self) -> &PrimaryMap<MemoryIndex, MemoryStyle>;
+
+    /// Returns the table plans associated with this `Artifact`.
+    fn table_styles(&'a self) -> &PrimaryMap<TableIndex, TableStyle>;
+
+    /// Returns data initializers to pass to `VMInstance::initialize`
+    fn data_initializers(&'a self) -> Self::OwnedDataInitializerIterator;
+
+    /// Serializes an artifact into bytes
+    fn serialize(&'a self) -> Result<Vec<u8>, SerializeError>;
+}
+
+// Implementation of `Upcastable` taken from https://users.rust-lang.org/t/why-does-downcasting-not-work-for-subtraits/33286/7 .
+/// Trait needed to get downcasting of `Engine`s to work.
+pub trait Upcastable {
+    /// upcast ref
+    fn upcast_any_ref(&'_ self) -> &'_ dyn Any;
+    /// upcast mut ref
+    fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any;
+    /// upcast boxed dyn
+    fn upcast_any_box(self: Box<Self>) -> Box<dyn Any>;
+}
+
+impl<T: Any + Send + Sync + 'static> Upcastable for T {
+    #[inline]
+    fn upcast_any_ref(&'_ self) -> &'_ dyn Any {
+        self
+    }
+    #[inline]
+    fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any {
+        self
+    }
+    #[inline]
+    fn upcast_any_box(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+impl<'a, O, I>
+    dyn ArtifactCreate<'a, OwnedDataInitializer = O, OwnedDataInitializerIterator = I> + 'static
+{
+    /// Try to downcast the artifact into a given type.
+    #[inline]
+    pub fn downcast_ref<T: 'static>(&'a self) -> Option<&'a T> {
+        self.upcast_any_ref().downcast_ref::<T>()
+    }
+
+    /// Try to downcast the artifact into a given type mutably.
+    #[inline]
+    pub fn downcast_mut<T: 'static>(&'a mut self) -> Option<&'a mut T> {
+        self.upcast_any_mut().downcast_mut::<T>()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/environ.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/environ.rs
new file mode 100644
index 0000000..e69f167
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/environ.rs
@@ -0,0 +1,452 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+use super::state::ModuleTranslationState;
+use crate::lib::std::string::ToString;
+use crate::lib::std::{boxed::Box, string::String, vec::Vec};
+use crate::translate_module;
+use crate::wasmparser::{Operator, ValType};
+use std::convert::{TryFrom, TryInto};
+use std::ops::Range;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::FunctionType;
+use wasmer_types::WasmResult;
+use wasmer_types::{
+    CustomSectionIndex, DataIndex, DataInitializer, DataInitializerLocation, ElemIndex,
+    ExportIndex, FunctionIndex, GlobalIndex, GlobalInit, GlobalType, ImportIndex,
+    LocalFunctionIndex, MemoryIndex, MemoryType, ModuleInfo, SignatureIndex, TableIndex,
+    TableInitializer, TableType,
+};
+
+/// Contains function data: bytecode and its offset in the module.
+#[derive(Hash)]
+pub struct FunctionBodyData<'a> {
+    /// Function body bytecode.
+    pub data: &'a [u8],
+
+    /// Body offset relative to the module file.
+    pub module_offset: usize,
+}
+
+/// Trait for iterating over the operators of a Wasm Function
+pub trait FunctionBinaryReader<'a> {
+    /// Read a `count` indicating the number of times to call `read_local_decl`.
+    fn read_local_count(&mut self) -> WasmResult<u32>;
+
+    /// Read a `(count, value_type)` declaration of local variables of the same type.
+    fn read_local_decl(&mut self) -> WasmResult<(u32, ValType)>;
+
+    /// Reads the next available `Operator`.
+    fn read_operator(&mut self) -> WasmResult<Operator<'a>>;
+
+    /// Returns the current position.
+    fn current_position(&self) -> usize;
+
+    /// Returns the original position (with the offset)
+    fn original_position(&self) -> usize;
+
+    /// Returns the number of bytes remaining.
+    fn bytes_remaining(&self) -> usize;
+
+    /// Returns whether the readers has reached the end of the file.
+    fn eof(&self) -> bool;
+
+    /// Return the range (original offset, original offset + data length)
+    fn range(&self) -> Range<usize>;
+}
+
+/// The result of translating via `ModuleEnvironment`. Function bodies are not
+/// yet translated, and data initializers have not yet been copied out of the
+/// original buffer.
+/// The function bodies will be translated by a specific compiler backend.
+pub struct ModuleEnvironment<'data> {
+    /// ModuleInfo information.
+    pub module: ModuleInfo,
+
+    /// References to the function bodies.
+    pub function_body_inputs: PrimaryMap<LocalFunctionIndex, FunctionBodyData<'data>>,
+
+    /// References to the data initializers.
+    pub data_initializers: Vec<DataInitializer<'data>>,
+
+    /// The decoded Wasm types for the module.
+    pub module_translation_state: Option<ModuleTranslationState>,
+}
+
+impl<'data> ModuleEnvironment<'data> {
+    /// Allocates the environment data structures.
+    pub fn new() -> Self {
+        Self {
+            module: ModuleInfo::new(),
+            function_body_inputs: PrimaryMap::new(),
+            data_initializers: Vec::new(),
+            module_translation_state: None,
+        }
+    }
+
+    /// Translate a wasm module using this environment. This consumes the
+    /// `ModuleEnvironment` and produces a `ModuleInfoTranslation`.
+    pub fn translate(mut self, data: &'data [u8]) -> WasmResult<ModuleEnvironment<'data>> {
+        assert!(self.module_translation_state.is_none());
+        let module_translation_state = translate_module(data, &mut self)?;
+        self.module_translation_state = Some(module_translation_state);
+        Ok(self)
+    }
+
+    pub(crate) fn declare_export(&mut self, export: ExportIndex, name: &str) -> WasmResult<()> {
+        self.module.exports.insert(String::from(name), export);
+        Ok(())
+    }
+
+    pub(crate) fn declare_import(
+        &mut self,
+        import: ImportIndex,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        self.module.imports.insert(
+            (
+                String::from(module),
+                String::from(field),
+                self.module.imports.len().try_into().unwrap(),
+            )
+                .into(),
+            import,
+        );
+        Ok(())
+    }
+
+    pub(crate) fn reserve_signatures(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .signatures
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_signature(&mut self, sig: FunctionType) -> WasmResult<()> {
+        // TODO: Deduplicate signatures.
+        self.module.signatures.push(sig);
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_import(
+        &mut self,
+        sig_index: SignatureIndex,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.module.functions.len(),
+            self.module.num_imported_functions,
+            "Imported functions must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Function(FunctionIndex::from_u32(
+                self.module.num_imported_functions as _,
+            )),
+            module,
+            field,
+        )?;
+        self.module.functions.push(sig_index);
+        self.module.num_imported_functions += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_table_import(
+        &mut self,
+        table: TableType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.module.tables.len(),
+            self.module.num_imported_tables,
+            "Imported tables must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Table(TableIndex::from_u32(self.module.num_imported_tables as _)),
+            module,
+            field,
+        )?;
+        self.module.tables.push(table);
+        self.module.num_imported_tables += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_memory_import(
+        &mut self,
+        memory: MemoryType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.module.memories.len(),
+            self.module.num_imported_memories,
+            "Imported memories must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Memory(MemoryIndex::from_u32(
+                self.module.num_imported_memories as _,
+            )),
+            module,
+            field,
+        )?;
+        self.module.memories.push(memory);
+        self.module.num_imported_memories += 1;
+        Ok(())
+    }
+
+    pub(crate) fn declare_global_import(
+        &mut self,
+        global: GlobalType,
+        module: &str,
+        field: &str,
+    ) -> WasmResult<()> {
+        debug_assert_eq!(
+            self.module.globals.len(),
+            self.module.num_imported_globals,
+            "Imported globals must be declared first"
+        );
+        self.declare_import(
+            ImportIndex::Global(GlobalIndex::from_u32(self.module.num_imported_globals as _)),
+            module,
+            field,
+        )?;
+        self.module.globals.push(global);
+        self.module.num_imported_globals += 1;
+        Ok(())
+    }
+
+    pub(crate) fn finish_imports(&mut self) -> WasmResult<()> {
+        Ok(())
+    }
+
+    pub(crate) fn reserve_func_types(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .functions
+            .reserve_exact(usize::try_from(num).unwrap());
+        self.function_body_inputs
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()> {
+        self.module.functions.push(sig_index);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_tables(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .tables
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_table(&mut self, table: TableType) -> WasmResult<()> {
+        self.module.tables.push(table);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_memories(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .memories
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_memory(&mut self, memory: MemoryType) -> WasmResult<()> {
+        self.module.memories.push(memory);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_globals(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .globals
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_global(
+        &mut self,
+        global: GlobalType,
+        initializer: GlobalInit,
+    ) -> WasmResult<()> {
+        self.module.globals.push(global);
+        self.module.global_initializers.push(initializer);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_exports(&mut self, num: u32) -> WasmResult<()> {
+        self.module.exports.reserve(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_func_export(
+        &mut self,
+        func_index: FunctionIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Function(func_index), name)
+    }
+
+    pub(crate) fn declare_table_export(
+        &mut self,
+        table_index: TableIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Table(table_index), name)
+    }
+
+    pub(crate) fn declare_memory_export(
+        &mut self,
+        memory_index: MemoryIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Memory(memory_index), name)
+    }
+
+    pub(crate) fn declare_global_export(
+        &mut self,
+        global_index: GlobalIndex,
+        name: &str,
+    ) -> WasmResult<()> {
+        self.declare_export(ExportIndex::Global(global_index), name)
+    }
+
+    pub(crate) fn declare_start_function(&mut self, func_index: FunctionIndex) -> WasmResult<()> {
+        debug_assert!(self.module.start_function.is_none());
+        self.module.start_function = Some(func_index);
+        Ok(())
+    }
+
+    pub(crate) fn reserve_table_initializers(&mut self, num: u32) -> WasmResult<()> {
+        self.module
+            .table_initializers
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_table_initializers(
+        &mut self,
+        table_index: TableIndex,
+        base: Option<GlobalIndex>,
+        offset: usize,
+        elements: Box<[FunctionIndex]>,
+    ) -> WasmResult<()> {
+        self.module.table_initializers.push(TableInitializer {
+            table_index,
+            base,
+            offset,
+            elements,
+        });
+        Ok(())
+    }
+
+    pub(crate) fn declare_passive_element(
+        &mut self,
+        elem_index: ElemIndex,
+        segments: Box<[FunctionIndex]>,
+    ) -> WasmResult<()> {
+        let old = self.module.passive_elements.insert(elem_index, segments);
+        debug_assert!(
+            old.is_none(),
+            "should never get duplicate element indices, that would be a bug in `wasmer_compiler`'s \
+             translation"
+        );
+        Ok(())
+    }
+
+    pub(crate) fn define_function_body(
+        &mut self,
+        _module_translation_state: &ModuleTranslationState,
+        body_bytes: &'data [u8],
+        body_offset: usize,
+    ) -> WasmResult<()> {
+        self.function_body_inputs.push(FunctionBodyData {
+            data: body_bytes,
+            module_offset: body_offset,
+        });
+        Ok(())
+    }
+
+    pub(crate) fn reserve_data_initializers(&mut self, num: u32) -> WasmResult<()> {
+        self.data_initializers
+            .reserve_exact(usize::try_from(num).unwrap());
+        Ok(())
+    }
+
+    pub(crate) fn declare_data_initialization(
+        &mut self,
+        memory_index: MemoryIndex,
+        base: Option<GlobalIndex>,
+        offset: usize,
+        data: &'data [u8],
+    ) -> WasmResult<()> {
+        self.data_initializers.push(DataInitializer {
+            location: DataInitializerLocation {
+                memory_index,
+                base,
+                offset,
+            },
+            data,
+        });
+        Ok(())
+    }
+
+    pub(crate) fn reserve_passive_data(&mut self, count: u32) -> WasmResult<()> {
+        let count = usize::try_from(count).unwrap();
+        self.module.passive_data.reserve(count);
+        Ok(())
+    }
+
+    pub(crate) fn declare_passive_data(
+        &mut self,
+        data_index: DataIndex,
+        data: &'data [u8],
+    ) -> WasmResult<()> {
+        let old = self.module.passive_data.insert(data_index, Box::from(data));
+        debug_assert!(
+            old.is_none(),
+            "a module can't have duplicate indices, this would be a wasmer-compiler bug"
+        );
+        Ok(())
+    }
+
+    pub(crate) fn declare_module_name(&mut self, name: &'data str) -> WasmResult<()> {
+        self.module.name = Some(name.to_string());
+        Ok(())
+    }
+
+    pub(crate) fn declare_function_name(
+        &mut self,
+        func_index: FunctionIndex,
+        name: &'data str,
+    ) -> WasmResult<()> {
+        self.module
+            .function_names
+            .insert(func_index, name.to_string());
+        Ok(())
+    }
+
+    /// Provides the number of imports up front. By default this does nothing, but
+    /// implementations can use this to preallocate memory if desired.
+    pub(crate) fn reserve_imports(&mut self, _num: u32) -> WasmResult<()> {
+        Ok(())
+    }
+
+    /// Notifies the implementation that all exports have been declared.
+    pub(crate) fn finish_exports(&mut self) -> WasmResult<()> {
+        Ok(())
+    }
+
+    /// Indicates that a custom section has been found in the wasm file
+    pub(crate) fn custom_section(&mut self, name: &'data str, data: &'data [u8]) -> WasmResult<()> {
+        let custom_section = CustomSectionIndex::from_u32(
+            self.module.custom_sections_data.len().try_into().unwrap(),
+        );
+        self.module
+            .custom_sections
+            .insert(String::from(name), custom_section);
+        self.module.custom_sections_data.push(Box::from(data));
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/error.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/error.rs
new file mode 100644
index 0000000..d562353
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/error.rs
@@ -0,0 +1,56 @@
+use wasmer_types::{CompileError, WasmError};
+use wasmparser::BinaryReaderError;
+
+/// Return an `Err(WasmError::Unsupported(msg))` where `msg` the string built by calling `format!`
+/// on the arguments to this macro.
+#[macro_export]
+macro_rules! wasm_unsupported {
+    ($($arg:tt)*) => { wasmer_types::WasmError::Unsupported(format!($($arg)*)) }
+}
+
+///
+pub fn from_binaryreadererror_wasmerror(original: BinaryReaderError) -> WasmError {
+    WasmError::InvalidWebAssembly {
+        message: original.message().into(),
+        offset: original.offset(),
+    }
+}
+
+///
+#[allow(dead_code)]
+pub fn from_binaryreadererror_compileerror(original: BinaryReaderError) -> CompileError {
+    // BinaryReaderError -> WasmError -> CompileError
+    CompileError::Wasm(from_binaryreadererror_wasmerror(original))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wasmparser::BinaryReader;
+
+    #[test]
+    fn can_convert_binary_reader_error_to_wasm_error() {
+        let mut reader = BinaryReader::new(b"\0\0\0\0");
+        let binary_reader_error = reader.read_bytes(10).unwrap_err();
+        match from_binaryreadererror_wasmerror(binary_reader_error) {
+            WasmError::InvalidWebAssembly { message, offset } => {
+                assert_eq!(message, "unexpected end-of-file");
+                assert_eq!(offset, 0);
+            }
+            err => panic!("Unexpected error: {:?}", err),
+        }
+    }
+
+    #[test]
+    fn can_convert_binary_reader_error_to_compile_error() {
+        let mut reader = BinaryReader::new(b"\0\0\0\0");
+        let binary_reader_error = reader.read_bytes(10).unwrap_err();
+        match from_binaryreadererror_compileerror(binary_reader_error) {
+            CompileError::Wasm(WasmError::InvalidWebAssembly { message, offset }) => {
+                assert_eq!(message, "unexpected end-of-file");
+                assert_eq!(offset, 0);
+            }
+            err => panic!("Unexpected error: {:?}", err),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/middleware.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/middleware.rs
new file mode 100644
index 0000000..5d60cf0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/middleware.rs
@@ -0,0 +1,241 @@
+//! The middleware parses the function binary bytecodes and transform them
+//! with the chosen functions.
+
+use smallvec::SmallVec;
+use std::collections::VecDeque;
+use std::fmt::Debug;
+use std::ops::{Deref, Range};
+use wasmer_types::{LocalFunctionIndex, MiddlewareError, ModuleInfo, WasmResult};
+use wasmparser::{BinaryReader, Operator, ValType};
+
+use super::error::from_binaryreadererror_wasmerror;
+use crate::translator::environ::FunctionBinaryReader;
+
+/// A shared builder for function middlewares.
+pub trait ModuleMiddleware: Debug + Send + Sync {
+    /// Generates a `FunctionMiddleware` for a given function.
+    ///
+    /// Here we generate a separate object for each function instead of executing directly on per-function operators,
+    /// in order to enable concurrent middleware application. Takes immutable `&self` because this function can be called
+    /// concurrently from multiple compilation threads.
+    fn generate_function_middleware<'a>(
+        &self,
+        local_function_index: LocalFunctionIndex,
+    ) -> Box<dyn FunctionMiddleware<'a> + 'a>;
+
+    /// Transforms a `ModuleInfo` struct in-place. This is called before application on functions begins.
+    fn transform_module_info(&self, _: &mut ModuleInfo) -> Result<(), MiddlewareError> {
+        Ok(())
+    }
+}
+
+/// A function middleware specialized for a single function.
+pub trait FunctionMiddleware<'a>: Debug {
+    /// Provide info on the function's locals. This is called before feed.
+    fn locals_info(&mut self, _locals: &[ValType]) {}
+
+    /// Processes the given operator.
+    fn feed(
+        &mut self,
+        operator: Operator<'a>,
+        state: &mut MiddlewareReaderState<'a>,
+    ) -> Result<(), MiddlewareError> {
+        state.push_operator(operator);
+        Ok(())
+    }
+}
+
+/// A Middleware binary reader of the WebAssembly structures and types.
+#[derive(Debug)]
+pub struct MiddlewareBinaryReader<'a> {
+    /// Parsing state.
+    state: MiddlewareReaderState<'a>,
+
+    /// The backing middleware chain for this reader.
+    chain: Vec<Box<dyn FunctionMiddleware<'a> + 'a>>,
+}
+
+/// The state of the binary reader. Exposed to middlewares to push their outputs.
+#[derive(Debug)]
+pub struct MiddlewareReaderState<'a> {
+    /// Raw binary reader.
+    inner: BinaryReader<'a>,
+
+    /// The pending operations added by the middleware.
+    pending_operations: VecDeque<Operator<'a>>,
+
+    /// Number of local declarations that will ever be read.
+    local_decls: u32,
+
+    /// Number of local declarations read so far.
+    local_decls_read: u32,
+
+    /// Locals read so far.
+    locals: Vec<ValType>,
+}
+
+/// Trait for generating middleware chains from "prototype" (generator) chains.
+pub trait ModuleMiddlewareChain {
+    /// Generates a function middleware chain.
+    fn generate_function_middleware_chain<'a>(
+        &self,
+        local_function_index: LocalFunctionIndex,
+    ) -> Vec<Box<dyn FunctionMiddleware<'a> + 'a>>;
+
+    /// Applies the chain on a `ModuleInfo` struct.
+    fn apply_on_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError>;
+}
+
+impl<T: Deref<Target = dyn ModuleMiddleware>> ModuleMiddlewareChain for [T] {
+    /// Generates a function middleware chain.
+    fn generate_function_middleware_chain<'a>(
+        &self,
+        local_function_index: LocalFunctionIndex,
+    ) -> Vec<Box<dyn FunctionMiddleware<'a> + 'a>> {
+        self.iter()
+            .map(|x| x.generate_function_middleware(local_function_index))
+            .collect()
+    }
+
+    /// Applies the chain on a `ModuleInfo` struct.
+    fn apply_on_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> {
+        for item in self {
+            item.transform_module_info(module_info)?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> MiddlewareReaderState<'a> {
+    /// Push an operator.
+    pub fn push_operator(&mut self, operator: Operator<'a>) {
+        self.pending_operations.push_back(operator);
+    }
+}
+
+impl<'a> Extend<Operator<'a>> for MiddlewareReaderState<'a> {
+    fn extend<I: IntoIterator<Item = Operator<'a>>>(&mut self, iter: I) {
+        self.pending_operations.extend(iter);
+    }
+}
+
+impl<'a: 'b, 'b> Extend<&'b Operator<'a>> for MiddlewareReaderState<'a> {
+    fn extend<I: IntoIterator<Item = &'b Operator<'a>>>(&mut self, iter: I) {
+        self.pending_operations.extend(iter.into_iter().cloned());
+    }
+}
+
+impl<'a> MiddlewareBinaryReader<'a> {
+    /// Constructs a `MiddlewareBinaryReader` with an explicit starting offset.
+    pub fn new_with_offset(data: &'a [u8], original_offset: usize) -> Self {
+        let inner = BinaryReader::new_with_offset(data, original_offset);
+        Self {
+            state: MiddlewareReaderState {
+                inner,
+                pending_operations: VecDeque::new(),
+                local_decls: 0,
+                local_decls_read: 0,
+                locals: vec![],
+            },
+            chain: vec![],
+        }
+    }
+
+    /// Replaces the middleware chain with a new one.
+    pub fn set_middleware_chain(&mut self, stages: Vec<Box<dyn FunctionMiddleware<'a> + 'a>>) {
+        self.chain = stages;
+    }
+
+    /// Pass info about the locals of a function to all middlewares
+    fn emit_locals_info(&mut self) {
+        for middleware in &mut self.chain {
+            middleware.locals_info(&self.state.locals)
+        }
+    }
+}
+
+impl<'a> FunctionBinaryReader<'a> for MiddlewareBinaryReader<'a> {
+    fn read_local_count(&mut self) -> WasmResult<u32> {
+        let total = self.state.inner.read_var_u32();
+        let total = total.map_err(from_binaryreadererror_wasmerror)?;
+        self.state.local_decls = total;
+        self.state.locals.reserve(total as usize);
+        if total == 0 {
+            self.emit_locals_info();
+        }
+        Ok(total)
+    }
+
+    fn read_local_decl(&mut self) -> WasmResult<(u32, ValType)> {
+        let count = self.state.inner.read_var_u32();
+        let count = count.map_err(from_binaryreadererror_wasmerror)?;
+        let ty = self.state.inner.read::<ValType>();
+        let ty = ty.map_err(from_binaryreadererror_wasmerror)?;
+        for _ in 0..count {
+            self.state.locals.push(ty);
+        }
+
+        self.state.local_decls_read += 1;
+        if self.state.local_decls_read == self.state.local_decls {
+            self.emit_locals_info();
+        }
+        Ok((count, ty))
+    }
+
+    fn read_operator(&mut self) -> WasmResult<Operator<'a>> {
+        if self.chain.is_empty() {
+            // We short-circuit in case no chain is used
+            return self
+                .state
+                .inner
+                .read_operator()
+                .map_err(from_binaryreadererror_wasmerror);
+        }
+
+        // Try to fill the `self.pending_operations` buffer, until it is non-empty.
+        while self.state.pending_operations.is_empty() {
+            let raw_op = self
+                .state
+                .inner
+                .read_operator()
+                .map_err(from_binaryreadererror_wasmerror)?;
+
+            // Fill the initial raw operator into pending buffer.
+            self.state.pending_operations.push_back(raw_op);
+
+            // Run the operator through each stage.
+            for stage in &mut self.chain {
+                // Take the outputs from the previous stage.
+                let pending: SmallVec<[Operator<'a>; 2]> =
+                    self.state.pending_operations.drain(0..).collect();
+
+                // ...and feed them into the current stage.
+                for pending_op in pending {
+                    stage.feed(pending_op, &mut self.state)?;
+                }
+            }
+        }
+
+        Ok(self.state.pending_operations.pop_front().unwrap())
+    }
+
+    fn current_position(&self) -> usize {
+        self.state.inner.current_position()
+    }
+
+    fn original_position(&self) -> usize {
+        self.state.inner.original_position()
+    }
+
+    fn bytes_remaining(&self) -> usize {
+        self.state.inner.bytes_remaining()
+    }
+
+    fn eof(&self) -> bool {
+        self.state.inner.eof()
+    }
+
+    fn range(&self) -> Range<usize> {
+        self.state.inner.range()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/mod.rs
new file mode 100644
index 0000000..bcad787
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/mod.rs
@@ -0,0 +1,24 @@
+//! This module defines the parser and translator from wasmparser
+//! to a common structure `ModuleInfo`.
+//!
+//! It's derived from [cranelift-wasm] but architected for multiple
+//! compilers rather than just Cranelift.
+//!
+//! [cranelift-wasm]: https://crates.io/crates/cranelift-wasm/
+mod environ;
+mod middleware;
+mod module;
+mod state;
+#[macro_use]
+mod error;
+mod sections;
+
+pub use self::environ::{FunctionBinaryReader, FunctionBodyData, ModuleEnvironment};
+pub use self::middleware::{
+    FunctionMiddleware, MiddlewareBinaryReader, MiddlewareReaderState, ModuleMiddleware,
+    ModuleMiddlewareChain,
+};
+pub use self::module::translate_module;
+pub use self::sections::{wpheaptype_to_type, wptype_to_type};
+pub use self::state::ModuleTranslationState;
+pub use error::from_binaryreadererror_wasmerror;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/module.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/module.rs
new file mode 100644
index 0000000..97034a9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/module.rs
@@ -0,0 +1,121 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Translation skeleton that traverses the whole WebAssembly module and call helper functions
+//! to deal with each part of it.
+use super::environ::ModuleEnvironment;
+use super::error::from_binaryreadererror_wasmerror;
+use super::sections::{
+    parse_data_section, parse_element_section, parse_export_section, parse_function_section,
+    parse_global_section, parse_import_section, parse_memory_section, parse_name_section,
+    parse_start_section, parse_table_section, parse_type_section,
+};
+use super::state::ModuleTranslationState;
+use wasmer_types::WasmResult;
+use wasmparser::{NameSectionReader, Parser, Payload};
+
+/// Translate a sequence of bytes forming a valid Wasm binary into a
+/// parsed ModuleInfo `ModuleTranslationState`.
+pub fn translate_module<'data>(
+    data: &'data [u8],
+    environ: &mut ModuleEnvironment<'data>,
+) -> WasmResult<ModuleTranslationState> {
+    let mut module_translation_state = ModuleTranslationState::new();
+
+    for payload in Parser::new(0).parse_all(data) {
+        match payload.map_err(from_binaryreadererror_wasmerror)? {
+            Payload::Version { .. } | Payload::End { .. } => {}
+
+            Payload::TypeSection(types) => {
+                parse_type_section(types, &mut module_translation_state, environ)?;
+            }
+
+            Payload::ImportSection(imports) => {
+                parse_import_section(imports, environ)?;
+            }
+
+            Payload::FunctionSection(functions) => {
+                parse_function_section(functions, environ)?;
+            }
+
+            Payload::TableSection(tables) => {
+                parse_table_section(tables, environ)?;
+            }
+
+            Payload::MemorySection(memories) => {
+                parse_memory_section(memories, environ)?;
+            }
+
+            Payload::GlobalSection(globals) => {
+                parse_global_section(globals, environ)?;
+            }
+
+            Payload::ExportSection(exports) => {
+                parse_export_section(exports, environ)?;
+            }
+
+            Payload::StartSection { func, .. } => {
+                parse_start_section(func, environ)?;
+            }
+
+            Payload::ElementSection(elements) => {
+                parse_element_section(elements, environ)?;
+            }
+
+            Payload::CodeSectionStart { .. } => {}
+            Payload::CodeSectionEntry(code) => {
+                let mut code = code.get_binary_reader();
+                let size = code.bytes_remaining();
+                let offset = code.original_position();
+                environ.define_function_body(
+                    &module_translation_state,
+                    code.read_bytes(size)
+                        .map_err(from_binaryreadererror_wasmerror)?,
+                    offset,
+                )?;
+            }
+
+            Payload::DataSection(data) => {
+                parse_data_section(data, environ)?;
+            }
+
+            Payload::DataCountSection { count, .. } => {
+                environ.reserve_passive_data(count)?;
+            }
+
+            Payload::InstanceSection(_)
+            | Payload::ComponentSection { .. }
+            | Payload::CoreTypeSection(_)
+            | Payload::ComponentTypeSection(_)
+            | Payload::ComponentInstanceSection(_)
+            | Payload::ComponentAliasSection(_)
+            | Payload::ComponentCanonicalSection(_)
+            | Payload::ComponentStartSection { .. }
+            | Payload::ComponentImportSection(_)
+            | Payload::ComponentExportSection(_)
+            | Payload::ModuleSection { .. } => {
+                unimplemented!("module linking not implemented. It will only be implemented if/when browsers support it")
+            }
+
+            Payload::TagSection(_) => {
+                unimplemented!("exception handling not implemented yet")
+            }
+
+            Payload::CustomSection(sectionreader) => {
+                // We still add the custom section data, but also read it as name section reader
+                let name = sectionreader.name();
+                environ.custom_section(name, sectionreader.data())?;
+                if name == "name" {
+                    parse_name_section(
+                        NameSectionReader::new(sectionreader.data(), sectionreader.data_offset()),
+                        environ,
+                    )?;
+                }
+            }
+
+            Payload::UnknownSection { .. } => unreachable!(),
+        }
+    }
+
+    Ok(module_translation_state)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/sections.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/sections.rs
new file mode 100644
index 0000000..55aea49
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/sections.rs
@@ -0,0 +1,525 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Helper functions to gather information for each of the non-function sections of a
+//! WebAssembly module.
+//!
+//! The code of these helper functions is straightforward since they only read metadata
+//! about linear memories, tables, globals, etc. and store them for later use.
+//!
+//! The special case of the initialize expressions for table elements offsets or global variables
+//! is handled, according to the semantics of WebAssembly, to only specific expressions that are
+//! interpreted on the fly.
+
+use super::environ::ModuleEnvironment;
+use super::error::from_binaryreadererror_wasmerror;
+use super::state::ModuleTranslationState;
+use crate::wasm_unsupported;
+use std::boxed::Box;
+use std::vec::Vec;
+use wasmer_types::entity::packed_option::ReservedValue;
+use wasmer_types::entity::EntityRef;
+use wasmer_types::{
+    DataIndex, ElemIndex, FunctionIndex, FunctionType, GlobalIndex, GlobalInit, GlobalType,
+    MemoryIndex, MemoryType, Pages, SignatureIndex, TableIndex, TableType, Type, V128,
+};
+use wasmer_types::{WasmError, WasmResult};
+use wasmparser::{
+    self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
+    ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
+    GlobalSectionReader, GlobalType as WPGlobalType, ImportSectionReader, MemorySectionReader,
+    MemoryType as WPMemoryType, NameSectionReader, Operator, TableSectionReader, TypeRef,
+    TypeSectionReader,
+};
+
+/// Helper function translating wasmparser types to Wasm Type.
+pub fn wptype_to_type(ty: wasmparser::ValType) -> WasmResult<Type> {
+    match ty {
+        wasmparser::ValType::I32 => Ok(Type::I32),
+        wasmparser::ValType::I64 => Ok(Type::I64),
+        wasmparser::ValType::F32 => Ok(Type::F32),
+        wasmparser::ValType::F64 => Ok(Type::F64),
+        wasmparser::ValType::V128 => Ok(Type::V128),
+        wasmparser::ValType::Ref(ty) => wpreftype_to_type(ty),
+    }
+}
+
+/// Converts a wasmparser ref type to a Wasm Type.
+pub fn wpreftype_to_type(ty: wasmparser::RefType) -> WasmResult<Type> {
+    if ty.is_extern_ref() {
+        Ok(Type::ExternRef)
+    } else if ty.is_func_ref() {
+        Ok(Type::FuncRef)
+    } else {
+        Err(wasm_unsupported!("unsupported reference type: {:?}", ty))
+    }
+}
+
+/// Converts a wasmparser heap type to a Wasm Type.
+pub fn wpheaptype_to_type(ty: wasmparser::HeapType) -> WasmResult<Type> {
+    match ty {
+        wasmparser::HeapType::Func => Ok(Type::FuncRef),
+        wasmparser::HeapType::Extern => Ok(Type::ExternRef),
+        other => Err(wasm_unsupported!("unsupported reference type: {other:?}")),
+    }
+}
+
+/// Parses the Type section of the wasm module.
+pub fn parse_type_section(
+    types: TypeSectionReader,
+    module_translation_state: &mut ModuleTranslationState,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    let count = types.count();
+    environ.reserve_signatures(count)?;
+
+    for res in types.into_iter_err_on_gc_types() {
+        let functype = res.map_err(from_binaryreadererror_wasmerror)?;
+
+        let params = functype.params();
+        let returns = functype.results();
+        let sig_params: Box<[Type]> = params
+            .iter()
+            .map(|ty| {
+                wptype_to_type(*ty)
+                    .expect("only numeric types are supported in function signatures")
+            })
+            .collect();
+        let sig_returns: Box<[Type]> = returns
+            .iter()
+            .map(|ty| {
+                wptype_to_type(*ty)
+                    .expect("only numeric types are supported in function signatures")
+            })
+            .collect();
+        let sig = FunctionType::new(sig_params, sig_returns);
+        environ.declare_signature(sig)?;
+        module_translation_state
+            .wasm_types
+            .push((params.to_vec().into(), returns.to_vec().into()));
+    }
+
+    Ok(())
+}
+
+/// Parses the Import section of the wasm module.
+pub fn parse_import_section<'data>(
+    imports: ImportSectionReader<'data>,
+    environ: &mut ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_imports(imports.count())?;
+
+    for entry in imports {
+        let import = entry.map_err(from_binaryreadererror_wasmerror)?;
+        let module_name = import.module;
+        let field_name = import.name;
+
+        match import.ty {
+            TypeRef::Func(sig) => {
+                environ.declare_func_import(
+                    SignatureIndex::from_u32(sig),
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Tag(_) => {
+                unimplemented!("exception handling not implemented yet")
+            }
+            TypeRef::Memory(WPMemoryType {
+                shared,
+                memory64,
+                initial,
+                maximum,
+            }) => {
+                if memory64 {
+                    unimplemented!("64bit memory not implemented yet");
+                }
+                environ.declare_memory_import(
+                    MemoryType {
+                        minimum: Pages(initial as u32),
+                        maximum: maximum.map(|p| Pages(p as u32)),
+                        shared,
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Global(ref ty) => {
+                environ.declare_global_import(
+                    GlobalType {
+                        ty: wptype_to_type(ty.content_type)?,
+                        mutability: ty.mutable.into(),
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+            TypeRef::Table(ref tab) => {
+                environ.declare_table_import(
+                    TableType {
+                        ty: wpreftype_to_type(tab.element_type)?,
+                        minimum: tab.initial,
+                        maximum: tab.maximum,
+                    },
+                    module_name,
+                    field_name,
+                )?;
+            }
+        }
+    }
+
+    environ.finish_imports()?;
+    Ok(())
+}
+
+/// Parses the Function section of the wasm module.
+pub fn parse_function_section(
+    functions: FunctionSectionReader,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    let num_functions = functions.count();
+    if num_functions == std::u32::MAX {
+        // We reserve `u32::MAX` for our own use.
+        return Err(WasmError::ImplLimitExceeded);
+    }
+
+    environ.reserve_func_types(num_functions)?;
+
+    for entry in functions {
+        let sigindex = entry.map_err(from_binaryreadererror_wasmerror)?;
+        environ.declare_func_type(SignatureIndex::from_u32(sigindex))?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Table section of the wasm module.
+pub fn parse_table_section(
+    tables: TableSectionReader,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_tables(tables.count())?;
+
+    for entry in tables {
+        let table = entry.map_err(from_binaryreadererror_wasmerror)?;
+        environ.declare_table(TableType {
+            ty: wpreftype_to_type(table.ty.element_type).unwrap(),
+            minimum: table.ty.initial,
+            maximum: table.ty.maximum,
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Memory section of the wasm module.
+pub fn parse_memory_section(
+    memories: MemorySectionReader,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_memories(memories.count())?;
+
+    for entry in memories {
+        let WPMemoryType {
+            shared,
+            memory64,
+            initial,
+            maximum,
+        } = entry.map_err(from_binaryreadererror_wasmerror)?;
+        if memory64 {
+            unimplemented!("64bit memory not implemented yet");
+        }
+        environ.declare_memory(MemoryType {
+            minimum: Pages(initial as u32),
+            maximum: maximum.map(|p| Pages(p as u32)),
+            shared,
+        })?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Global section of the wasm module.
+pub fn parse_global_section(
+    globals: GlobalSectionReader,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_globals(globals.count())?;
+
+    for entry in globals {
+        let wasmparser::Global {
+            ty: WPGlobalType {
+                content_type,
+                mutable,
+            },
+            init_expr,
+        } = entry.map_err(from_binaryreadererror_wasmerror)?;
+        let mut init_expr_reader = init_expr.get_binary_reader();
+        let initializer = match init_expr_reader
+            .read_operator()
+            .map_err(from_binaryreadererror_wasmerror)?
+        {
+            Operator::I32Const { value } => GlobalInit::I32Const(value),
+            Operator::I64Const { value } => GlobalInit::I64Const(value),
+            Operator::F32Const { value } => GlobalInit::F32Const(f32::from_bits(value.bits())),
+            Operator::F64Const { value } => GlobalInit::F64Const(f64::from_bits(value.bits())),
+            Operator::V128Const { value } => GlobalInit::V128Const(V128::from(*value.bytes())),
+            Operator::RefNull { hty: _ } => {
+                // TODO: Do we need to handle different heap types here?
+                GlobalInit::RefNullConst
+            }
+            Operator::RefFunc { function_index } => {
+                GlobalInit::RefFunc(FunctionIndex::from_u32(function_index))
+            }
+            Operator::GlobalGet { global_index } => {
+                GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
+            }
+            ref s => {
+                return Err(wasm_unsupported!(
+                    "unsupported init expr in global section: {:?}",
+                    s
+                ));
+            }
+        };
+        let global = GlobalType {
+            ty: wptype_to_type(content_type).unwrap(),
+            mutability: mutable.into(),
+        };
+        environ.declare_global(global, initializer)?;
+    }
+
+    Ok(())
+}
+
+/// Parses the Export section of the wasm module.
+pub fn parse_export_section<'data>(
+    exports: ExportSectionReader<'data>,
+    environ: &mut ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_exports(exports.count())?;
+
+    for entry in exports {
+        let Export {
+            name: field,
+            ref kind,
+            index,
+        } = entry.map_err(from_binaryreadererror_wasmerror)?;
+
+        // The input has already been validated, so we should be able to
+        // assume valid UTF-8 and use `from_utf8_unchecked` if performance
+        // becomes a concern here.
+        let index = index as usize;
+        match *kind {
+            ExternalKind::Func => environ.declare_func_export(FunctionIndex::new(index), field)?,
+            ExternalKind::Table => environ.declare_table_export(TableIndex::new(index), field)?,
+            ExternalKind::Memory => {
+                environ.declare_memory_export(MemoryIndex::new(index), field)?
+            }
+            ExternalKind::Global => {
+                environ.declare_global_export(GlobalIndex::new(index), field)?
+            }
+            ExternalKind::Tag => {
+                unimplemented!("exception handling not implemented yet")
+            }
+        }
+    }
+
+    environ.finish_exports()?;
+    Ok(())
+}
+
+/// Parses the Start section of the wasm module.
+pub fn parse_start_section(index: u32, environ: &mut ModuleEnvironment) -> WasmResult<()> {
+    environ.declare_start_function(FunctionIndex::from_u32(index))?;
+    Ok(())
+}
+
+fn read_elems(items: &ElementItems) -> WasmResult<Box<[FunctionIndex]>> {
+    let mut out = Vec::new();
+
+    match items {
+        ElementItems::Functions(funcs) => {
+            for res in funcs.clone().into_iter() {
+                let func_index = res.map_err(from_binaryreadererror_wasmerror)?;
+                out.push(FunctionIndex::from_u32(func_index));
+            }
+        }
+        ElementItems::Expressions(ty, section) => {
+            // TODO: check type is supported
+            if !(ty.is_extern_ref() || ty.is_func_ref()) {
+                return Err(wasm_unsupported!(
+                    "unsupported element type in element section: {:?}",
+                    ty
+                ));
+            }
+
+            for res in section.clone().into_iter() {
+                let expr = res.map_err(from_binaryreadererror_wasmerror)?;
+
+                let op = expr
+                    .get_binary_reader()
+                    .read_operator()
+                    .map_err(from_binaryreadererror_wasmerror)?;
+                match op {
+                    Operator::RefNull { .. } => out.push(FunctionIndex::reserved_value()),
+                    Operator::RefFunc { function_index } => {
+                        out.push(FunctionIndex::from_u32(function_index))
+                    }
+                    other => {
+                        return Err(WasmError::Unsupported(format!(
+                            "unsupported init expr in element section: {other:?}",
+                        )));
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(out.into_boxed_slice())
+}
+
+/// Parses the Element section of the wasm module.
+pub fn parse_element_section(
+    elements: ElementSectionReader<'_>,
+    environ: &mut ModuleEnvironment,
+) -> WasmResult<()> {
+    environ.reserve_table_initializers(elements.count())?;
+
+    for (index, elem) in elements.into_iter().enumerate() {
+        let Element {
+            kind,
+            items,
+            range: _,
+        } = elem.map_err(from_binaryreadererror_wasmerror)?;
+
+        let segments = read_elems(&items)?;
+        match kind {
+            ElementKind::Active {
+                table_index,
+                offset_expr,
+            } => {
+                let table_index = TableIndex::from_u32(table_index.unwrap_or(0));
+
+                let mut init_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match init_expr_reader
+                    .read_operator()
+                    .map_err(from_binaryreadererror_wasmerror)?
+                {
+                    Operator::I32Const { value } => (None, value as u32 as usize),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in element section: {:?}",
+                            s
+                        ));
+                    }
+                };
+                environ.declare_table_initializers(table_index, base, offset, segments)?
+            }
+            ElementKind::Passive => {
+                let index = ElemIndex::from_u32(index as u32);
+                environ.declare_passive_element(index, segments)?;
+            }
+            ElementKind::Declared => (),
+        }
+    }
+    Ok(())
+}
+
+/// Parses the Data section of the wasm module.
+pub fn parse_data_section<'data>(
+    data: DataSectionReader<'data>,
+    environ: &mut ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    environ.reserve_data_initializers(data.count())?;
+
+    for (index, entry) in data.into_iter().enumerate() {
+        let Data {
+            kind,
+            data,
+            range: _,
+        } = entry.map_err(from_binaryreadererror_wasmerror)?;
+        match kind {
+            DataKind::Active {
+                memory_index,
+                offset_expr,
+            } => {
+                let mut init_expr_reader = offset_expr.get_binary_reader();
+                let (base, offset) = match init_expr_reader
+                    .read_operator()
+                    .map_err(from_binaryreadererror_wasmerror)?
+                {
+                    Operator::I32Const { value } => (None, value as u32 as usize),
+                    Operator::GlobalGet { global_index } => {
+                        (Some(GlobalIndex::from_u32(global_index)), 0)
+                    }
+                    ref s => {
+                        return Err(wasm_unsupported!(
+                            "unsupported init expr in data section: {:?}",
+                            s
+                        ))
+                    }
+                };
+                environ.declare_data_initialization(
+                    MemoryIndex::from_u32(memory_index),
+                    base,
+                    offset,
+                    data,
+                )?;
+            }
+            DataKind::Passive => {
+                let index = DataIndex::from_u32(index as u32);
+                environ.declare_passive_data(index, data)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Parses the Name section of the wasm module.
+pub fn parse_name_section<'data>(
+    names: NameSectionReader<'data>,
+    environ: &mut ModuleEnvironment<'data>,
+) -> WasmResult<()> {
+    for res in names {
+        let subsection = if let Ok(subsection) = res {
+            subsection
+        } else {
+            // Should we log / warn here?
+            continue;
+        };
+        match subsection {
+            wasmparser::Name::Function(function_subsection) => {
+                for naming in function_subsection.into_iter().flatten() {
+                    if naming.index != std::u32::MAX {
+                        environ.declare_function_name(
+                            FunctionIndex::from_u32(naming.index),
+                            naming.name,
+                        )?;
+                    }
+                }
+            }
+            wasmparser::Name::Module {
+                name,
+                name_range: _,
+            } => {
+                environ.declare_module_name(name)?;
+            }
+            wasmparser::Name::Local(_) => {}
+            wasmparser::Name::Label(_)
+            | wasmparser::Name::Type(_)
+            | wasmparser::Name::Table(_)
+            | wasmparser::Name::Memory(_)
+            | wasmparser::Name::Global(_)
+            | wasmparser::Name::Element(_)
+            | wasmparser::Name::Data(_)
+            | wasmparser::Name::Unknown { .. }
+            | wasmparser::Name::Tag(..) => {}
+        }
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/state.rs b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/state.rs
new file mode 100644
index 0000000..4182b06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/compiler/src/translator/state.rs
@@ -0,0 +1,138 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use std::boxed::Box;
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::{SignatureIndex, WasmResult};
+
+/// Map of signatures to a function's parameter and return types.
+pub(crate) type WasmTypes =
+    PrimaryMap<SignatureIndex, (Box<[wasmparser::ValType]>, Box<[wasmparser::ValType]>)>;
+
+/// Contains information decoded from the Wasm module that must be referenced
+/// during each Wasm function's translation.
+///
+/// This is only for data that is maintained by `wasmer-compiler` itself, as
+/// opposed to being maintained by the embedder. Data that is maintained by the
+/// embedder is represented with `ModuleEnvironment`.
+#[derive(Debug)]
+pub struct ModuleTranslationState {
+    /// A map containing a Wasm module's original, raw signatures.
+    ///
+    /// This is used for translating multi-value Wasm blocks inside functions,
+    /// which are encoded to refer to their type signature via index.
+    pub(crate) wasm_types: WasmTypes,
+}
+
+impl ModuleTranslationState {
+    /// Creates a new empty ModuleTranslationState.
+    pub fn new() -> Self {
+        Self {
+            wasm_types: PrimaryMap::new(),
+        }
+    }
+
+    /// Get the parameter and result types for the given Wasm blocktype.
+    pub fn blocktype_params_results<'a>(
+        &'a self,
+        ty_or_ft: &'a wasmparser::BlockType,
+    ) -> WasmResult<(&'a [wasmparser::ValType], SingleOrMultiValue<'a>)> {
+        Ok(match ty_or_ft {
+            wasmparser::BlockType::Type(ty) => (&[], SingleOrMultiValue::Single(ty)),
+            wasmparser::BlockType::FuncType(ty_index) => {
+                let sig_idx = SignatureIndex::from_u32(*ty_index);
+                let (ref params, ref results) = self.wasm_types[sig_idx];
+                (params, SingleOrMultiValue::Multi(results.as_ref()))
+            }
+            wasmparser::BlockType::Empty => (&[], SingleOrMultiValue::Multi(&[])),
+        })
+    }
+}
+
+/// A helper enum for representing either a single or multiple values.
+pub enum SingleOrMultiValue<'a> {
+    /// A single value.
+    Single(&'a wasmparser::ValType),
+    /// Multiple values.
+    Multi(&'a [wasmparser::ValType]),
+}
+
+impl<'a> SingleOrMultiValue<'a> {
+    /// True if empty.
+    pub fn is_empty(&self) -> bool {
+        match self {
+            SingleOrMultiValue::Single(_) => false,
+            SingleOrMultiValue::Multi(values) => values.is_empty(),
+        }
+    }
+
+    /// Count of values.
+    pub fn len(&self) -> usize {
+        match self {
+            SingleOrMultiValue::Single(_) => 1,
+            SingleOrMultiValue::Multi(values) => values.len(),
+        }
+    }
+
+    /// Iterate ofer the value types.
+    pub fn iter(&self) -> SingleOrMultiValueIterator<'_> {
+        match self {
+            SingleOrMultiValue::Single(v) => SingleOrMultiValueIterator::Single(v),
+            SingleOrMultiValue::Multi(items) => SingleOrMultiValueIterator::Multi {
+                index: 0,
+                values: items,
+            },
+        }
+    }
+}
+
+pub enum SingleOrMultiValueIterator<'a> {
+    Done,
+    Single(&'a wasmparser::ValType),
+    Multi {
+        index: usize,
+        values: &'a [wasmparser::ValType],
+    },
+}
+
+impl<'a> Iterator for SingleOrMultiValueIterator<'a> {
+    type Item = &'a wasmparser::ValType;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            SingleOrMultiValueIterator::Done => None,
+            SingleOrMultiValueIterator::Single(v) => {
+                let v = *v;
+                *self = SingleOrMultiValueIterator::Done;
+                Some(v)
+            }
+            SingleOrMultiValueIterator::Multi { index, values } => {
+                if let Some(x) = values.get(*index) {
+                    *index += 1;
+                    Some(x)
+                } else {
+                    *self = SingleOrMultiValueIterator::Done;
+                    None
+                }
+            }
+        }
+    }
+}
+
+impl<'a> PartialEq<[wasmparser::ValType]> for SingleOrMultiValue<'a> {
+    fn eq(&self, other: &[wasmparser::ValType]) -> bool {
+        match self {
+            SingleOrMultiValue::Single(ty) => other.len() == 1 && &other[0] == *ty,
+            SingleOrMultiValue::Multi(tys) => *tys == other,
+        }
+    }
+}
+
+impl<'a> PartialEq<SingleOrMultiValue<'a>> for &'a [wasmparser::ValType] {
+    fn eq(&self, other: &SingleOrMultiValue<'a>) -> bool {
+        match other {
+            SingleOrMultiValue::Single(ty) => self.len() == 1 && &self[0] == *ty,
+            SingleOrMultiValue::Multi(tys) => tys == self,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/derive/Cargo.toml
new file mode 100644
index 0000000..7576910
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "wasmer-derive"
+description = "Wasmer derive macros"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = { version = "1.0.72", features = ["full", "extra-traits"] }
+quote = "1"
+proc-macro2 = "1"
+proc-macro-error = "1.0.0"
+
+[dev-dependencies]
+wasmer-types = { path = "../types", default-features=false, features = ["std"] }
+compiletest_rs = "0.6"
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/src/lib.rs
new file mode 100644
index 0000000..fe781ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/src/lib.rs
@@ -0,0 +1,14 @@
+extern crate proc_macro;
+
+use proc_macro_error::proc_macro_error;
+use syn::{parse_macro_input, DeriveInput};
+
+mod value_type;
+
+#[proc_macro_error]
+#[proc_macro_derive(ValueType)]
+pub fn derive_value_type(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let gen = value_type::impl_value_type(&input);
+    gen.into()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/src/value_type.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/src/value_type.rs
new file mode 100644
index 0000000..3ba535e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/src/value_type.rs
@@ -0,0 +1,111 @@
+use proc_macro2::TokenStream;
+use proc_macro_error::abort;
+use quote::quote;
+use syn::{Data, DeriveInput, Fields, Member, Meta, MetaList, NestedMeta};
+
+/// We can only validate types that have a well defined layout.
+fn check_repr(input: &DeriveInput) {
+    let reprs = input
+        .attrs
+        .iter()
+        .filter_map(|attr| {
+            if let Meta::List(MetaList { path, nested, .. }) = attr.parse_meta().unwrap() {
+                if path.is_ident("repr") {
+                    return Some(nested.into_iter().collect::<Vec<_>>());
+                }
+            }
+            None
+        })
+        .flatten();
+
+    // We require either repr(C) or repr(transparent) to ensure fields are in
+    // source code order.
+    for meta in reprs {
+        if let NestedMeta::Meta(Meta::Path(path)) = meta {
+            if path.is_ident("C") || path.is_ident("transparent") {
+                return;
+            }
+        }
+    }
+
+    abort!(
+        input,
+        "ValueType can only be derived for #[repr(C)] or #[repr(transparent)] structs"
+    )
+}
+
+/// Zero out any padding bytes between fields.
+fn zero_padding(fields: &Fields) -> TokenStream {
+    let names: Vec<_> = fields
+        .iter()
+        .enumerate()
+        .map(|(i, field)| match &field.ident {
+            Some(ident) => Member::Named(ident.clone()),
+            None => Member::Unnamed(i.into()),
+        })
+        .collect();
+
+    let mut out = TokenStream::new();
+    for i in 0..fields.len() {
+        let name = &names[i];
+        let start = quote! {
+            &self.#name as *const _ as usize - self as *const _ as usize
+        };
+        let len = quote! {
+            ::core::mem::size_of_val(&self.#name)
+        };
+        let end = quote! {
+            #start + #len
+        };
+
+        // Zero out padding bytes within the current field.
+        //
+        // This also ensures that all fields implement ValueType.
+        out.extend(quote! {
+            ::wasmer_types::ValueType::zero_padding_bytes(&self.#name, &mut _bytes[#start..(#start + #len)]);
+        });
+
+        let padding_end = if i == fields.len() - 1 {
+            // Zero out padding bytes between the last field and the end of the struct.
+            let total_size = quote! {
+                ::core::mem::size_of_val(self)
+            };
+            total_size
+        } else {
+            // Zero out padding bytes between the current field and the next one.
+            let next_name = &names[i + 1];
+            let next_start = quote! {
+                &self.#next_name as *const _ as usize - self as *const _ as usize
+            };
+            next_start
+        };
+        out.extend(quote! {
+            for i in #end..#padding_end {
+                _bytes[i] = ::core::mem::MaybeUninit::new(0);
+            }
+        });
+    }
+    out
+}
+
+pub fn impl_value_type(input: &DeriveInput) -> TokenStream {
+    check_repr(input);
+
+    let struct_name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let fields = match &input.data {
+        Data::Struct(ds) => &ds.fields,
+        _ => abort!(input, "ValueType can only be derived for structs"),
+    };
+
+    let zero_padding = zero_padding(fields);
+
+    quote! {
+        unsafe impl #impl_generics ::wasmer_types::ValueType for #struct_name #ty_generics #where_clause {
+            #[inline]
+            fn zero_padding_bytes(&self, _bytes: &mut [::core::mem::MaybeUninit<u8>]) {
+                #zero_padding
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-attribute.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-attribute.rs
new file mode 100644
index 0000000..9766dd1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-attribute.rs
@@ -0,0 +1,11 @@
+extern crate wasmer;
+
+use wasmer::{LazyInit, Memory, WasmerEnv};
+
+#[derive(WasmerEnv)]
+struct BadAttribute {
+    #[wasmer(extraport)] //~ Unexpected identifier `extraport`. Expected `export`.
+    memory: LazyInit<Memory>,
+}
+
+fn main() {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-export-arg.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-export-arg.rs
new file mode 100644
index 0000000..e2e5e94
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/bad-export-arg.rs
@@ -0,0 +1,18 @@
+extern crate wasmer;
+
+use wasmer::{LazyInit, Memory, WasmerEnv};
+
+#[derive(WasmerEnv)]
+struct BadExportArg {
+    #[wasmer(export(this_is_not_a_real_argument = "hello, world"))]
+    //~ Unrecognized argument in export options: expected `name` found `this_is_not_a_real_argument
+    memory: LazyInit<Memory>,
+}
+
+#[derive(WasmerEnv)]
+struct BadExportArgRawString {
+    #[wasmer(export("hello"))] //~ Failed to parse `wasmer` attribute: unexpected token
+    memory: LazyInit<Memory>,
+}
+
+fn main() {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/no-lazy-init.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/no-lazy-init.rs
new file mode 100644
index 0000000..baeeb1e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compile-fail/no-lazy-init.rs
@@ -0,0 +1,11 @@
+extern crate wasmer;
+
+use wasmer::{LazyInit, Memory, WasmerEnv};
+
+#[derive(WasmerEnv)]
+struct ExportNotWrappedInLazyInit {
+    #[wasmer(export)]
+    memory: Memory, //~ WasmerEnv derive expects all `export`s to be wrapped in `LazyInit`
+}
+
+fn main() {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compiletest.rs b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compiletest.rs
new file mode 100644
index 0000000..ae91da9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/derive/tests/compiletest.rs
@@ -0,0 +1,48 @@
+// file is a modified version of  https://github.com/AltSysrq/proptest/blob/proptest-derive/proptest-derive/tests/compiletest.rs
+
+// Original copyright and license:
+// Copyright 2018 The proptest developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Modifications copyright 2020 Wasmer
+// Licensed under the MIT license
+
+extern crate compiletest_rs as ct;
+
+use std::env;
+
+fn run_mode(src: &'static str, mode: &'static str) {
+    let mut config = ct::Config::default();
+
+    config.mode = mode.parse().expect("invalid mode");
+    config.target_rustcflags = Some("-L ../../target/debug/deps".to_owned());
+    if let Ok(name) = env::var("TESTNAME") {
+        config.filters.push(name);
+    }
+    config.src_base = format!("tests/{}", src).into();
+
+    // hack to make this work on OSX: we probably don't need it though
+    /*if std::env::var("DYLD_LIBRARY_PATH").is_err() {
+        let val =    std::env::var("DYLD_FALLBACK_LIBRARY_PATH").unwrap();
+        std::env::set_var("DYLD_LIBRARY_PATH", val);
+    }
+    config.link_deps();*/
+
+    // Uncomment this if you have the "multiple crates named `wasmer` issue". Massively slows
+    // down test iteration though...
+    config.clean_rmeta();
+
+    ct::run_tests(&config);
+}
+
+#[test]
+#[ignore] // ignored by default because it needs to essentially run `cargo clean` to work correctly
+          // and that's really, really slow
+fn compile_test() {
+    run_mode("compile-fail", "compile-fail");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/emscripten/Cargo.toml
new file mode 100644
index 0000000..3c9a39a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "wasmer-emscripten"
+description = "Emscripten implementation library for Wasmer WebAssembly runtime"
+categories = ["wasm", "os"]
+keywords = ["wasm", "webassembly", "abi", "emscripten", "posix"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+byteorder = "1.3"
+lazy_static = "1.4"
+libc = "^0.2"
+log = "0.4"
+time = { version = "0.3", features = ["std", "formatting"] }
+wasmer = { path = "../api", version = "=4.2.8", default-features = false }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+
+[target.'cfg(windows)'.dependencies]
+getrandom = "0.2"
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/README.md b/arbitrator/tools/module_roots/wasmer/lib/emscripten/README.md
new file mode 100644
index 0000000..41c11bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/README.md
@@ -0,0 +1,5 @@
+# `wasmer-emscripten` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate provides the necessary imports to use [Emscripten] WebAssembly generated files easily from Wasmer.
+
+[Emscripten]: https://emscripten.org/
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/README.md b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/README.md
new file mode 100644
index 0000000..801a0f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/README.md
@@ -0,0 +1,544 @@
+## HOST APIS
+
+#### EMSCRIPTEN APIS
+
+###### PROCESS
+
+- **\_abort** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _abort()
+  ```
+- **abort** ✅ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn abort(ctx: &mut Ctx, message: u32, )
+  ```
+- **abort_on_cannot_grow_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn abort_on_cannot_grow_memory()
+  ```
+
+###### TIMING
+
+- **\_clock_gettime** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+
+###### ENVIRONMENT
+
+- **\_getenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _getenv(ctx: &mut Ctx, name: c_int, )
+  ```
+- **\_putenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _putenv(ctx: &mut Ctx, name: c_int, )
+  ```
+- **\_setenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _setenv(name: c_int, value: c_int, overwrite: c_int, instance: &mut Instance
+  ```
+- **\_unsetenv** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _unsetenv(ctx: &mut Ctx, name: c_int, )
+  ```
+
+###### THREAD
+
+- **\_pthread_getspecific** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_pthread_key_create** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_pthread_rwlock_destroy** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_pthread_rwlock_init** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_pthread_rwlock_wrlock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_pthread_setspecific** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_\_\_lock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **\_\_\_unlock** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+
+###### MEMORY
+
+- **\_emscripten_memcpy_big** ✅ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn _emscripten_memcpy_big(ctx: &mut Ctx, dest: u32, src: u32, len: u32, ) -> u32
+  ```
+- **enlarge_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn enlarge_memory()
+  ```
+- **get_total_memory** ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn get_total_memory(ctx: &mut Ctx, ) -> u32
+  ```
+
+###### TIMING
+
+- **\_clock_gettime** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+
+###### STATUS
+
+- **\_\_\_set_err_no** &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+
+---
+
+#### EMSCRIPTEN SYSCALLS
+
+- **access** (\_\_\_syscall33) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **acct** (\_\_\_syscall51) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **chdir** (\_\_\_syscall12) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **chmod** (\_\_\_syscall15) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **chown** (\_\_\_syscall212) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **clock_nanosleep** (\_\_\_syscall265) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **close** (\_\_\_syscall6) ✅ ❗️ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn close(fd: c_int) -> c_int
+  ```
+- **dup** (\_\_\_syscall330) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **dup** (\_\_\_syscall41) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **dup2** (\_\_\_syscall63) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **exit** (\_\_\_syscall1) ✅ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn exit(status: c_int)
+  ```
+- **faccessat** (\_\_\_syscall307) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fadvise** (\_\_\_syscall272) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fallocate** (\_\_\_syscall324) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fchdir** (\_\_\_syscall133) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fchmod** (\_\_\_syscall94) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fchmodat** (\_\_\_syscall306) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fchown** (\_\_\_syscall207) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fchownat** (\_\_\_syscall298) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fcntl** (\_\_\_syscall221) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fdatasync** (\_\_\_syscall148) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fstat** (\_\_\_syscall197) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fstatat** (\_\_\_syscall300) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fstatfs** (\_\_\_syscall269) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **fsync** (\_\_\_syscall118) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **ftruncate** (\_\_\_syscall194) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **futimesat** (\_\_\_syscall299) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getcwd** (\_\_\_syscall183) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getdents** (\_\_\_syscall220) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getgid** (\_\_\_syscall202) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getgroups** (\_\_\_syscall205) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getpgid** (\_\_\_syscall132) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getpgrp** (\_\_\_syscall65) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getpid** (\_\_\_syscall20) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getppid** (\_\_\_syscall64) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getpriority** (\_\_\_syscall96) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getresgid** (\_\_\_syscall211) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getrusage** (\_\_\_syscall77) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **getsid** (\_\_\_syscall147) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **ioctl** (\_\_\_syscall54) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **lchown** (\_\_\_syscall198) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **link** (\_\_\_syscall9) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **linkat** (\_\_\_syscall303) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **llseek** (\_\_\_syscall140) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **lstat** (\_\_\_syscall196) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **madvise** (\_\_\_syscall219) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mincore** (\_\_\_syscall218) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mkdir** (\_\_\_syscall39) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mkdirat** (\_\_\_syscall296) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mknod** (\_\_\_syscall14) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mknodat** (\_\_\_syscall297) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mmap** (\_\_\_syscall192) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mprotect** (\_\_\_syscall125) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **mremap** (\_\_\_syscall163) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **msync** (\_\_\_syscall144) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **munlockall** (\_\_\_syscall153) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **munmap** (\_\_\_syscall91) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **newselect** (\_\_\_syscall142) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **nice** (\_\_\_syscall34) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **open** (\_\_\_syscall5) ✅ ❗️ 🔥 &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn open(ctx: &mut Ctx, path: u32, flags: c_int, mode: c_int, ) -> c_int
+  ```
+- **openat** (\_\_\_syscall295) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pause** (\_\_\_syscall29) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pipe** (\_\_\_syscall331) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pipe** (\_\_\_syscall42) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **poll** (\_\_\_syscall168) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pread** (\_\_\_syscall180) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **preadv** (\_\_\_syscall333) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **prlimit** (\_\_\_syscall340) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pselect** (\_\_\_syscall308) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pwrite** (\_\_\_syscall181) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **pwritev** (\_\_\_syscall334) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **read** (\_\_\_syscall3) ✅ ❗️ &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+  fn read(ctx: &mut Ctx, fd: c_int, buf: u32, count: size_t, ) -> ssize_t
+  ```
+- **readlink** (\_\_\_syscall85) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **readlinkat** (\_\_\_syscall305) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **readv** (\_\_\_syscall145) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **recvmmsg** (\_\_\_syscall337) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **rename** (\_\_\_syscall38) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **renameat** (\_\_\_syscall302) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **rmdir** (\_\_\_syscall40) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **rt_sigqueueinfo** (\_\_\_syscall178) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **sendmmsg** (\_\_\_syscall345) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setdomainname** (\_\_\_syscall121) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setgid** (\_\_\_syscall214) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setitimer** (\_\_\_syscall104) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setpgid** (\_\_\_syscall57) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setpriority** (\_\_\_syscall97) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setresgid** (\_\_\_syscall210) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setrlimit** (\_\_\_syscall75) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **setsid** (\_\_\_syscall66) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **socketcall** (\_\_\_syscall102) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **stat** (\_\_\_syscall195) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **statfs** (\_\_\_syscall268) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **symlink** (\_\_\_syscall83) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **symlinkat** (\_\_\_syscall304) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **sync** (\_\_\_syscall36) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **truncate** (\_\_\_syscall193) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **ugetrlimit** (\_\_\_syscall191) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **umask** (\_\_\_syscall60) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **uname** (\_\_\_syscall122) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **unlink** (\_\_\_syscall10) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **unlinkat** (\_\_\_syscall301) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **utimensat** (\_\_\_syscall320) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **wait** (\_\_\_syscall114) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **write** (\_\_\_syscall4) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+- **writev** (\_\_\_syscall146) &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+  ```rust
+
+  ```
+
+### LEGEND &nbsp;&nbsp;&nbsp;&nbsp;[:top:](#host-apis)
+✅ - Implemented
+
+❗️ - Elevated privilege
+
+🔥 - Possible memory access violation
+
+📥 - Access to external memory
+
+📝 - External write to internal memory
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/bitwise.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/bitwise.rs
new file mode 100644
index 0000000..d912fda
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/bitwise.rs
@@ -0,0 +1,10 @@
+use crate::emscripten_target;
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+///emscripten: _llvm_bswap_i64
+pub fn _llvm_bswap_i64(ctx: FunctionEnvMut<EmEnv>, _low: i32, high: i32) -> i32 {
+    debug!("emscripten::_llvm_bswap_i64");
+    emscripten_target::setTempRet0(ctx, _low.swap_bytes());
+    high.swap_bytes()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/emscripten_target.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/emscripten_target.rs
new file mode 100644
index 0000000..736313d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/emscripten_target.rs
@@ -0,0 +1,1015 @@
+#![allow(non_snake_case)]
+
+use crate::env::{get_emscripten_data, get_emscripten_funcs};
+use crate::EmEnv;
+#[cfg(target_os = "linux")]
+use libc::getdtablesize;
+use wasmer::FunctionEnvMut;
+
+pub fn asm_const_i(_ctx: FunctionEnvMut<EmEnv>, _val: i32) -> i32 {
+    debug!("emscripten::asm_const_i: {}", _val);
+    0
+}
+
+pub fn exit_with_live_runtime(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::exit_with_live_runtime");
+}
+
+pub fn setTempRet0(ctx: FunctionEnvMut<EmEnv>, val: i32) {
+    trace!("emscripten::setTempRet0: {}", val);
+    get_emscripten_data(&ctx).as_mut().unwrap().temp_ret_0 = val;
+}
+
+pub fn getTempRet0(ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    trace!("emscripten::getTempRet0");
+    get_emscripten_data(&ctx).as_ref().unwrap().temp_ret_0
+}
+
+pub fn _alarm(_ctx: FunctionEnvMut<EmEnv>, _seconds: u32) -> i32 {
+    debug!("emscripten::_alarm({})", _seconds);
+    0
+}
+
+pub fn _atexit(_ctx: FunctionEnvMut<EmEnv>, _func: i32) -> i32 {
+    debug!("emscripten::_atexit");
+    // TODO: implement atexit properly
+    // __ATEXIT__.unshift({
+    //     func: func,
+    //     arg: arg
+    // });
+    0
+}
+pub fn __Unwind_Backtrace(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::__Unwind_Backtrace");
+    0
+}
+pub fn __Unwind_FindEnclosingFunction(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    debug!("emscripten::__Unwind_FindEnclosingFunction");
+    0
+}
+pub fn __Unwind_GetIPInfo(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::__Unwind_GetIPInfo");
+    0
+}
+pub fn ___cxa_find_matching_catch_2(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::___cxa_find_matching_catch_2");
+    0
+}
+pub fn ___cxa_find_matching_catch_3(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    debug!("emscripten::___cxa_find_matching_catch_3");
+    0
+}
+pub fn ___cxa_free_exception(_ctx: FunctionEnvMut<EmEnv>, _a: i32) {
+    debug!("emscripten::___cxa_free_exception");
+}
+pub fn ___resumeException(_ctx: FunctionEnvMut<EmEnv>, _a: i32) {
+    debug!("emscripten::___resumeException");
+}
+pub fn _dladdr(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::_dladdr");
+    0
+}
+pub fn ___gxx_personality_v0(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _a: i32,
+    _b: i32,
+    _c: i32,
+    _d: i32,
+    _e: i32,
+    _f: i32,
+) -> i32 {
+    debug!("emscripten::___gxx_personality_v0");
+    0
+}
+
+#[cfg(target_os = "linux")]
+pub fn _getdtablesize(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::getdtablesize");
+    unsafe { getdtablesize() }
+}
+#[cfg(not(target_os = "linux"))]
+pub fn _getdtablesize(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::getdtablesize");
+    -1
+}
+pub fn _gethostbyaddr(_ctx: FunctionEnvMut<EmEnv>, _addr: i32, _addrlen: i32, _atype: i32) -> i32 {
+    debug!("emscripten::gethostbyaddr");
+    0
+}
+pub fn _gethostbyname(_ctx: FunctionEnvMut<EmEnv>, _name: i32) -> i32 {
+    debug!("emscripten::gethostbyname_r");
+    0
+}
+pub fn _gethostbyname_r(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _name: i32,
+    _ret: i32,
+    _buf: i32,
+    _buflen: i32,
+    _out: i32,
+    _err: i32,
+) -> i32 {
+    debug!("emscripten::gethostbyname_r");
+    0
+}
+// NOTE: php.js has proper impl; libc has proper impl for linux
+pub fn _getloadavg(_ctx: FunctionEnvMut<EmEnv>, _loadavg: i32, _nelem: i32) -> i32 {
+    debug!("emscripten::getloadavg");
+    0
+}
+#[allow(clippy::too_many_arguments)]
+pub fn _getnameinfo(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _addr: i32,
+    _addrlen: i32,
+    _host: i32,
+    _hostlen: i32,
+    _serv: i32,
+    _servlen: i32,
+    _flags: i32,
+) -> i32 {
+    debug!(
+        "emscripten::_getnameinfo({}, {}, {}, {}, {}, {}, {})",
+        _addr, _addrlen, _host, _hostlen, _serv, _servlen, _flags
+    );
+    0
+}
+
+// Invoke functions
+// They save the stack to allow unwinding
+
+// Macro definitions
+macro_rules! invoke {
+    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
+        let funcs = get_emscripten_funcs(&$ctx).clone();
+        let sp = funcs.stack_save_ref().expect("stack_save is None").call(&mut $ctx).expect("stack_save call failed");
+        let call = funcs.$name_ref().expect(concat!("Dynamic call is None: ", stringify!($name))).clone();
+        match call.call(&mut $ctx, $($arg),*) {
+            Ok(v) => v,
+            Err(_e) => {
+                let stack = funcs.stack_restore_ref().expect("stack_restore is None");
+                stack.call(&mut $ctx, sp).expect("stack_restore call failed");
+                // TODO: We should check if _e != "longjmp" and if that's the case, re-throw the error
+                // JS version is: if (e !== e+0 && e !== 'longjmp') throw e;
+                let threw = funcs.set_threw_ref().expect("set_threw is None");
+                threw.call(&mut $ctx, 1, 0).expect("set_threw call failed");
+                0 as _
+            }
+        }
+    }};
+}
+macro_rules! invoke_no_return {
+    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
+        let funcs = get_emscripten_funcs(&$ctx).clone();
+        let stack = funcs.stack_save_ref().expect("stack_save is None");
+        let sp = stack.call(&mut $ctx).expect("stack_save call failed");
+        let call = funcs.$name_ref().expect(concat!("Dynamic call is None: ", stringify!($name))).clone();
+        match call.call(&mut $ctx, $($arg),*) {
+            Ok(v) => v,
+            Err(_e) => {
+                let stack = funcs.stack_restore_ref().expect("stack_restore is None");
+                stack.call(&mut $ctx, sp).expect("stack_restore call failed");
+                // TODO: We should check if _e != "longjmp" and if that's the case, re-throw the error
+                // JS version is: if (e !== e+0 && e !== 'longjmp') throw e;
+                let threw = funcs.set_threw_ref().expect("set_threw is None");
+                threw.call(&mut $ctx, 1, 0).expect("set_threw call failed");
+            }
+        }
+    }};
+}
+// The invoke_j functions do not save the stack
+macro_rules! invoke_no_stack_save {
+    ($ctx: ident, $name:ident, $name_ref:ident, $( $arg:ident ),*) => {{
+        let funcs = get_emscripten_funcs(&$ctx).clone();
+        let call = funcs.$name_ref().expect(concat!(stringify!($name), " is set to None")).clone();
+
+        call.call(&mut $ctx, $($arg),*).unwrap()
+    }}
+}
+
+// Invoke functions
+pub fn invoke_i(mut ctx: FunctionEnvMut<EmEnv>, index: i32) -> i32 {
+    debug!("emscripten::invoke_i");
+    invoke!(ctx, dyn_call_i, dyn_call_i_ref, index)
+}
+pub fn invoke_ii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) -> i32 {
+    debug!("emscripten::invoke_ii");
+    invoke!(ctx, dyn_call_ii, dyn_call_ii_ref, index, a1)
+}
+pub fn invoke_iii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> i32 {
+    debug!("emscripten::invoke_iii");
+    invoke!(ctx, dyn_call_iii, dyn_call_iii_ref, index, a1, a2)
+}
+pub fn invoke_iiii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
+    debug!("emscripten::invoke_iiii");
+    invoke!(ctx, dyn_call_iiii, dyn_call_iiii_ref, index, a1, a2, a3)
+}
+pub fn invoke_iifi(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: f64, a3: i32) -> i32 {
+    debug!("emscripten::invoke_iifi");
+    invoke!(ctx, dyn_call_iifi, dyn_call_iifi_ref, index, a1, a2, a3)
+}
+pub fn invoke_v(mut ctx: FunctionEnvMut<EmEnv>, index: i32) {
+    debug!("emscripten::invoke_v");
+    invoke_no_return!(ctx, dyn_call_v, dyn_call_v_ref, index);
+}
+pub fn invoke_vi(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) {
+    debug!("emscripten::invoke_vi");
+    invoke_no_return!(ctx, dyn_call_vi, dyn_call_vi_ref, index, a1);
+}
+pub fn invoke_vii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) {
+    debug!("emscripten::invoke_vii");
+    invoke_no_return!(ctx, dyn_call_vii, dyn_call_vii_ref, index, a1, a2);
+}
+
+pub fn invoke_viii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) {
+    debug!("emscripten::invoke_viii");
+    invoke_no_return!(ctx, dyn_call_viii, dyn_call_viii_ref, index, a1, a2, a3);
+}
+pub fn invoke_viiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+) {
+    debug!("emscripten::invoke_viiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiii,
+        dyn_call_viiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4
+    );
+}
+pub fn invoke_dii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> f64 {
+    debug!("emscripten::invoke_dii");
+    invoke!(ctx, dyn_call_dii, dyn_call_dii_ref, index, a1, a2)
+}
+pub fn invoke_diiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+) -> f64 {
+    debug!("emscripten::invoke_diiii");
+    invoke!(
+        ctx,
+        dyn_call_diiii,
+        dyn_call_diiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4
+    )
+}
+pub fn invoke_iiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiii,
+        dyn_call_iiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4
+    )
+}
+pub fn invoke_iiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiii,
+        dyn_call_iiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiiii,
+        dyn_call_iiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiiiii,
+        dyn_call_iiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiiiiii,
+        dyn_call_iiiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiiiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiiiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiiiiiii,
+        dyn_call_iiiiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiiiiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+    a10: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiiiiiiiiii");
+    invoke!(
+        ctx,
+        dyn_call_iiiiiiiiiii,
+        dyn_call_iiiiiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9,
+        a10
+    )
+}
+pub fn invoke_vd(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: f64) {
+    debug!("emscripten::invoke_vd");
+    invoke_no_return!(ctx, dyn_call_vd, dyn_call_vd_ref, index, a1)
+}
+pub fn invoke_viiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_viiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiii,
+        dyn_call_viiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+) {
+    debug!("emscripten::invoke_viiiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiiii,
+        dyn_call_viiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+) {
+    debug!("emscripten::invoke_viiiiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiiiii,
+        dyn_call_viiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+) {
+    debug!("emscripten::invoke_viiiiiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiiiiii,
+        dyn_call_viiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+) {
+    debug!("emscripten::invoke_viiiiiiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiiiiiii,
+        dyn_call_viiiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiiiiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+    a10: i32,
+) {
+    debug!("emscripten::invoke_viiiiiiiiii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viiiiiiiiii,
+        dyn_call_viiiiiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9,
+        a10
+    )
+}
+
+pub fn invoke_iij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
+    debug!("emscripten::invoke_iij");
+    invoke!(ctx, dyn_call_iij, dyn_call_iij_ref, index, a1, a2, a3)
+}
+
+pub fn invoke_iji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
+    debug!("emscripten::invoke_iji");
+    invoke!(ctx, dyn_call_iji, dyn_call_iji_ref, index, a1, a2, a3)
+}
+
+pub fn invoke_iiji(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiji");
+    invoke!(ctx, dyn_call_iiji, dyn_call_iiji_ref, index, a1, a2, a3, a4)
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_iiijj(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+) -> i32 {
+    debug!("emscripten::invoke_iiijj");
+    invoke!(
+        ctx,
+        dyn_call_iiijj,
+        dyn_call_iiijj_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6
+    )
+}
+pub fn invoke_j(mut ctx: FunctionEnvMut<EmEnv>, index: i32) -> i32 {
+    debug!("emscripten::invoke_j");
+    invoke_no_stack_save!(ctx, dyn_call_j, dyn_call_j_ref, index)
+}
+pub fn invoke_ji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32) -> i32 {
+    debug!("emscripten::invoke_ji");
+    invoke_no_stack_save!(ctx, dyn_call_ji, dyn_call_ji_ref, index, a1)
+}
+pub fn invoke_jii(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) -> i32 {
+    debug!("emscripten::invoke_jii");
+    invoke_no_stack_save!(ctx, dyn_call_jii, dyn_call_jii_ref, index, a1, a2)
+}
+
+pub fn invoke_jij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) -> i32 {
+    debug!("emscripten::invoke_jij");
+    invoke_no_stack_save!(ctx, dyn_call_jij, dyn_call_jij_ref, index, a1, a2, a3)
+}
+pub fn invoke_jjj(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+) -> i32 {
+    debug!("emscripten::invoke_jjj");
+    invoke_no_stack_save!(ctx, dyn_call_jjj, dyn_call_jjj_ref, index, a1, a2, a3, a4)
+}
+pub fn invoke_viiij(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_viiij");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viiij,
+        dyn_call_viiij_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiijiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+) {
+    debug!("emscripten::invoke_viiijiiii");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viiijiiii,
+        dyn_call_viiijiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viiijiiiiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+    a8: i32,
+    a9: i32,
+    a10: i32,
+    a11: i32,
+) {
+    debug!("emscripten::invoke_viiijiiiiii");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viiijiiiiii,
+        dyn_call_viiijiiiiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9,
+        a10,
+        a11
+    )
+}
+pub fn invoke_viij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32, a4: i32) {
+    debug!("emscripten::invoke_viij");
+    invoke_no_stack_save!(ctx, dyn_call_viij, dyn_call_viij_ref, index, a1, a2, a3, a4)
+}
+pub fn invoke_viiji(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_viiji");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viiji,
+        dyn_call_viiji_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viijiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+    a7: i32,
+) {
+    debug!("emscripten::invoke_viijiii");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viijiii,
+        dyn_call_viijiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7
+    )
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viijj(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+) {
+    debug!("emscripten::invoke_viijj");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_viijj,
+        dyn_call_viijj_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6
+    )
+}
+pub fn invoke_vj(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32) {
+    debug!("emscripten::invoke_vj");
+    invoke_no_stack_save!(ctx, dyn_call_vj, dyn_call_vj_ref, index, a1, a2)
+}
+pub fn invoke_vjji(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_vjji");
+    invoke_no_return!(
+        ctx,
+        dyn_call_vjji,
+        dyn_call_vjji_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+pub fn invoke_vij(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32) {
+    debug!("emscripten::invoke_vij");
+    invoke_no_stack_save!(ctx, dyn_call_vij, dyn_call_vij_ref, index, a1, a2, a3)
+}
+pub fn invoke_viji(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: i32, a4: i32) {
+    debug!("emscripten::invoke_viji");
+    invoke_no_stack_save!(ctx, dyn_call_viji, dyn_call_viji_ref, index, a1, a2, a3, a4)
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_vijiii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+    a6: i32,
+) {
+    debug!("emscripten::invoke_vijiii");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_vijiii,
+        dyn_call_vijiii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6
+    )
+}
+pub fn invoke_vijj(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: i32,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_vijj");
+    invoke_no_stack_save!(
+        ctx,
+        dyn_call_vijj,
+        dyn_call_vijj_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    )
+}
+pub fn invoke_vidd(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: f64, a3: f64) {
+    debug!("emscripten::invoke_viid");
+    invoke_no_return!(ctx, dyn_call_vidd, dyn_call_vidd_ref, index, a1, a2, a3);
+}
+pub fn invoke_viid(mut ctx: FunctionEnvMut<EmEnv>, index: i32, a1: i32, a2: i32, a3: f64) {
+    debug!("emscripten::invoke_viid");
+    invoke_no_return!(ctx, dyn_call_viid, dyn_call_viid_ref, index, a1, a2, a3);
+}
+pub fn invoke_viidii(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: f64,
+    a4: i32,
+    a5: i32,
+) {
+    debug!("emscripten::invoke_viidii");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viidii,
+        dyn_call_viidii_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5
+    );
+}
+#[allow(clippy::too_many_arguments)]
+pub fn invoke_viidddddddd(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    index: i32,
+    a1: i32,
+    a2: i32,
+    a3: f64,
+    a4: f64,
+    a5: f64,
+    a6: f64,
+    a7: f64,
+    a8: f64,
+    a9: f64,
+    a10: f64,
+) {
+    debug!("emscripten::invoke_viidddddddd");
+    invoke_no_return!(
+        ctx,
+        dyn_call_viidddddddd,
+        dyn_call_viidddddddd_ref,
+        index,
+        a1,
+        a2,
+        a3,
+        a4,
+        a5,
+        a6,
+        a7,
+        a8,
+        a9,
+        a10
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/mod.rs
new file mode 100644
index 0000000..6482a80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/mod.rs
@@ -0,0 +1,200 @@
+#[cfg(unix)]
+mod unix;
+
+#[cfg(windows)]
+mod windows;
+
+#[cfg(unix)]
+pub use self::unix::*;
+
+#[cfg(windows)]
+pub use self::windows::*;
+
+use libc::c_char;
+
+use crate::{allocate_on_stack, EmscriptenData, EmscriptenFunctions};
+
+use std::os::raw::c_int;
+use std::sync::MutexGuard;
+
+use crate::EmEnv;
+use wasmer::ValueType;
+use wasmer::{FunctionEnvMut, WasmPtr};
+
+pub fn call_malloc(mut ctx: &mut FunctionEnvMut<EmEnv>, size: u32) -> u32 {
+    let malloc_ref = get_emscripten_funcs(ctx).malloc_ref().unwrap().clone();
+    malloc_ref.call(&mut ctx, size).unwrap()
+}
+
+#[allow(dead_code)]
+pub fn call_malloc_with_cast<T: Copy>(ctx: &mut FunctionEnvMut<EmEnv>, size: u32) -> WasmPtr<T> {
+    WasmPtr::new(call_malloc(ctx, size))
+}
+
+pub fn call_memalign(mut ctx: &mut FunctionEnvMut<EmEnv>, alignment: u32, size: u32) -> u32 {
+    let memalign_ref = get_emscripten_funcs(ctx).memalign_ref().unwrap().clone();
+    memalign_ref.call(&mut ctx, alignment, size).unwrap()
+}
+
+pub fn call_memset(
+    mut ctx: &mut FunctionEnvMut<EmEnv>,
+    pointer: u32,
+    value: u32,
+    size: u32,
+) -> u32 {
+    let memset_ref = get_emscripten_funcs(ctx).memset_ref().unwrap().clone();
+    memset_ref.call(&mut ctx, pointer, value, size).unwrap()
+}
+
+pub(crate) fn get_emscripten_data<'a>(
+    ctx: &'a FunctionEnvMut<EmEnv>,
+) -> MutexGuard<'a, Option<EmscriptenData>> {
+    ctx.data().data.lock().unwrap()
+}
+
+pub(crate) fn get_emscripten_funcs<'a>(
+    ctx: &'a FunctionEnvMut<EmEnv>,
+) -> MutexGuard<'a, EmscriptenFunctions> {
+    ctx.data().funcs.lock().unwrap()
+}
+
+pub fn _getpagesize(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    debug!("emscripten::_getpagesize");
+    16384
+}
+
+pub fn _times(mut ctx: FunctionEnvMut<EmEnv>, buffer: u32) -> u32 {
+    if buffer != 0 {
+        call_memset(&mut ctx, buffer, 0, 16);
+    }
+    0
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___build_environment(mut ctx: FunctionEnvMut<EmEnv>, environ: c_int) {
+    debug!("emscripten::___build_environment {}", environ);
+    const MAX_ENV_VALUES: u32 = 64;
+    const TOTAL_ENV_SIZE: u32 = 1024;
+    let memory = ctx.data().memory(0);
+    let environment = emscripten_memory_pointer!(memory.view(&ctx), environ) as *mut c_int;
+    let (mut pool_offset, env_ptr, mut pool_ptr) = unsafe {
+        let (pool_offset, _pool_slice): (u32, &mut [u8]) =
+            allocate_on_stack(&mut ctx, TOTAL_ENV_SIZE as u32);
+        let (env_offset, _env_slice): (u32, &mut [u8]) =
+            allocate_on_stack(&mut ctx, (MAX_ENV_VALUES * 4) as u32);
+        let env_ptr = emscripten_memory_pointer!(memory.view(&ctx), env_offset) as *mut c_int;
+        let pool_ptr = emscripten_memory_pointer!(memory.view(&ctx), pool_offset) as *mut u8;
+        *env_ptr = pool_offset as i32;
+        *environment = env_offset as i32;
+
+        (pool_offset, env_ptr, pool_ptr)
+    };
+
+    // *env_ptr = 0;
+    let default_vars = vec![
+        ["USER", "web_user"],
+        ["LOGNAME", "web_user"],
+        ["PATH", "/"],
+        ["PWD", "/"],
+        ["HOME", "/home/web_user"],
+        ["LANG", "C.UTF-8"],
+        ["_", "thisProgram"],
+    ];
+    let mut strings = vec![];
+    let mut total_size = 0;
+    for [key, val] in &default_vars {
+        let line = key.to_string() + "=" + val;
+        total_size += line.len();
+        strings.push(line);
+    }
+    if total_size as u32 > TOTAL_ENV_SIZE {
+        panic!("Environment size exceeded TOTAL_ENV_SIZE!");
+    }
+    unsafe {
+        for (i, s) in strings.iter().enumerate() {
+            for (j, c) in s.chars().enumerate() {
+                debug_assert!(c < u8::max_value() as char);
+                *pool_ptr.add(j) = c as u8;
+            }
+            *env_ptr.add(i * 4) = pool_offset as i32;
+            pool_offset += s.len() as u32 + 1;
+            pool_ptr = pool_ptr.add(s.len() + 1);
+        }
+        *env_ptr.add(strings.len() * 4) = 0;
+    }
+}
+
+pub fn ___assert_fail(_ctx: FunctionEnvMut<EmEnv>, _a: c_int, _b: c_int, _c: c_int, _d: c_int) {
+    debug!("emscripten::___assert_fail {} {} {} {}", _a, _b, _c, _d);
+    // TODO: Implement like emscripten expects regarding memory/page size
+    // TODO raise an error
+}
+
+pub fn _pathconf(ctx: FunctionEnvMut<EmEnv>, path_addr: c_int, name: c_int) -> c_int {
+    debug!(
+        "emscripten::_pathconf {} {} - UNIMPLEMENTED",
+        path_addr, name
+    );
+    let memory = ctx.data().memory(0);
+    let _path = emscripten_memory_pointer!(memory.view(&ctx), path_addr) as *const c_char;
+    match name {
+        0 => 32000,
+        1..=3 => 255,
+        4 | 5 | 16 | 17 | 18 => 4096,
+        6 | 7 | 20 => 1,
+        8 => 0,
+        9 | 10 | 11 | 12 | 14 | 15 | 19 => -1,
+        13 => 64,
+        _ => {
+            // ___setErrNo(22);
+            -1
+        }
+    }
+}
+
+pub fn _fpathconf(_ctx: FunctionEnvMut<EmEnv>, _fildes: c_int, name: c_int) -> c_int {
+    debug!("emscripten::_fpathconf {} {}", _fildes, name);
+    match name {
+        0 => 32000,
+        1..=3 => 255,
+        4 | 5 | 16 | 17 | 18 => 4096,
+        6 | 7 | 20 => 1,
+        8 => 0,
+        9 | 10 | 11 | 12 | 14 | 15 | 19 => -1,
+        13 => 64,
+        _ => {
+            // ___setErrNo(22);
+            -1
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, ValueType)]
+#[repr(C)]
+pub struct EmAddrInfo {
+    // int
+    pub ai_flags: i32,
+    // int
+    pub ai_family: i32,
+    // int
+    pub ai_socktype: i32,
+    // int
+    pub ai_protocol: i32,
+    // socklen_t
+    pub ai_addrlen: u32,
+    // struct sockaddr*
+    pub ai_addr: WasmPtr<EmSockAddr>,
+    // char*
+    pub ai_canonname: WasmPtr<c_char>,
+    // struct addrinfo*
+    pub ai_next: WasmPtr<EmAddrInfo>,
+}
+
+// NOTE: from looking at emscripten JS, this should be a union
+// TODO: review this, highly likely to have bugs
+#[derive(Debug, Clone, Copy, ValueType)]
+#[repr(C)]
+pub struct EmSockAddr {
+    pub sa_family: i16,
+    pub sa_data: [c_char; 14],
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/unix/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/unix/mod.rs
new file mode 100644
index 0000000..a638d31
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/unix/mod.rs
@@ -0,0 +1,364 @@
+/// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
+use libc::{c_int, getgrnam as libc_getgrnam, getpwnam as libc_getpwnam, sysconf};
+use std::ffi::{CStr, CString};
+use std::mem;
+use std::os::raw::c_char;
+
+use crate::env::{call_malloc, call_malloc_with_cast, EmAddrInfo, EmSockAddr};
+use crate::utils::{copy_cstr_into_wasm, copy_terminated_array_of_cstrs};
+use crate::EmEnv;
+use wasmer::{FunctionEnvMut, WasmPtr};
+
+// #[no_mangle]
+/// emscripten: _getenv // (name: *const char) -> *const c_char;
+pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: i32) -> u32 {
+    debug!("emscripten::_getenv");
+
+    let em_env = ctx.data();
+    let memory = em_env.memory(0);
+    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
+
+    debug!("=> name({:?})", unsafe { CStr::from_ptr(name_addr) });
+
+    let c_string = unsafe { CStr::from_ptr(name_addr) };
+    let c_string = c_string.to_string_lossy();
+    let env_var = em_env.get_env_var(c_string.as_ref());
+    let env_var = match env_var {
+        Some(s) => s,
+        None => return 0,
+    };
+    let new_env_var = match CString::new(env_var) {
+        Ok(s) => s,
+        Err(_) => return 0,
+    };
+    unsafe { copy_cstr_into_wasm(&mut ctx, new_env_var.as_ptr()) }
+}
+
+/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
+pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: c_int, value: c_int, overwrite: c_int) -> c_int {
+    debug!("emscripten::_setenv");
+
+    let em_env = ctx.data();
+    let memory = em_env.memory(0);
+    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
+    let value_addr = emscripten_memory_pointer!(memory.view(&ctx), value) as *const c_char;
+
+    let name = unsafe { CStr::from_ptr(name_addr) }.to_string_lossy();
+    let value = unsafe { CStr::from_ptr(value_addr) }.to_string_lossy();
+
+    debug!("=> name({:?})", name);
+    debug!("=> value({:?})", value);
+
+    let previous_entry = em_env.set_env_var(name.as_ref(), value.as_ref());
+
+    if let (0, Some(prev)) = (overwrite, previous_entry) {
+        let _ = em_env.set_env_var(name.as_ref(), prev.as_ref());
+    }
+
+    0
+}
+
+/// emscripten: _putenv // (name: *const char);
+pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
+    debug!("emscripten::_putenv");
+
+    let em_env = ctx.data();
+    let memory = em_env.memory(0);
+    let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
+
+    let name = unsafe { CStr::from_ptr(name_addr) }.to_string_lossy();
+    debug!("=> name({:?})", name);
+
+    em_env.set_env_var(name.as_ref(), "");
+
+    0
+}
+
+/// emscripten: _unsetenv // (name: *const char);
+pub fn _unsetenv(mut ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
+    debug!("emscripten::_unsetenv");
+
+    let name = {
+        let em_env = ctx.data();
+        let memory = em_env.memory(0);
+        let name_addr = emscripten_memory_pointer!(memory.view(&ctx), name) as *const c_char;
+        unsafe { CStr::from_ptr(name_addr) }
+            .to_string_lossy()
+            .to_string()
+    };
+
+    debug!("=> name({:?})", name);
+    let em_env = ctx.data_mut();
+    em_env.remove_env_var(name.as_ref());
+
+    0
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
+    debug!("emscripten::_getpwnam {}", name_ptr);
+    #[cfg(feature = "debug")]
+    let _ = name_ptr;
+
+    #[repr(C)]
+    struct GuestPasswd {
+        pw_name: u32,
+        pw_passwd: u32,
+        pw_uid: u32,
+        pw_gid: u32,
+        pw_gecos: u32,
+        pw_dir: u32,
+        pw_shell: u32,
+    }
+
+    let memory = ctx.data().memory(0);
+    let name = unsafe {
+        let memory = memory.view(&ctx);
+        let memory_name_ptr = emscripten_memory_pointer!(&memory, name_ptr) as *const c_char;
+        CStr::from_ptr(memory_name_ptr)
+    };
+
+    unsafe {
+        let passwd = &*libc_getpwnam(name.as_ptr());
+        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
+
+        let memory = memory.view(&ctx);
+        let passwd_struct_ptr =
+            emscripten_memory_pointer!(&memory, passwd_struct_offset) as *mut GuestPasswd;
+        (*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(&mut ctx, passwd.pw_name);
+        (*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(&mut ctx, passwd.pw_passwd);
+        (*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(&mut ctx, passwd.pw_gecos);
+        (*passwd_struct_ptr).pw_dir = copy_cstr_into_wasm(&mut ctx, passwd.pw_dir);
+        (*passwd_struct_ptr).pw_shell = copy_cstr_into_wasm(&mut ctx, passwd.pw_shell);
+        (*passwd_struct_ptr).pw_uid = passwd.pw_uid;
+        (*passwd_struct_ptr).pw_gid = passwd.pw_gid;
+
+        passwd_struct_offset as c_int
+    }
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
+    debug!("emscripten::_getgrnam {}", name_ptr);
+
+    #[repr(C)]
+    struct GuestGroup {
+        gr_name: u32,
+        gr_passwd: u32,
+        gr_gid: u32,
+        gr_mem: u32,
+    }
+
+    let memory = ctx.data().memory(0);
+    let name = unsafe {
+        let memory_name_ptr =
+            emscripten_memory_pointer!(memory.view(&ctx), name_ptr) as *const c_char;
+        CStr::from_ptr(memory_name_ptr)
+    };
+
+    unsafe {
+        let group = &*libc_getgrnam(name.as_ptr());
+        let group_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestGroup>() as _);
+
+        let group_struct_ptr =
+            emscripten_memory_pointer!(memory.view(&ctx), group_struct_offset) as *mut GuestGroup;
+        (*group_struct_ptr).gr_name = copy_cstr_into_wasm(&mut ctx, group.gr_name);
+        (*group_struct_ptr).gr_passwd = copy_cstr_into_wasm(&mut ctx, group.gr_passwd);
+        (*group_struct_ptr).gr_gid = group.gr_gid;
+        (*group_struct_ptr).gr_mem = copy_terminated_array_of_cstrs(ctx, group.gr_mem);
+
+        group_struct_offset as c_int
+    }
+}
+
+pub fn _sysconf(_ctx: FunctionEnvMut<EmEnv>, name: c_int) -> i32 {
+    debug!("emscripten::_sysconf {}", name);
+    // TODO: Implement like emscripten expects regarding memory/page size
+    unsafe { sysconf(name) as i32 } // TODO review i64
+}
+
+// this may be a memory leak, probably not though because emscripten does the same thing
+pub fn _gai_strerror(mut ctx: FunctionEnvMut<EmEnv>, ecode: i32) -> i32 {
+    debug!("emscripten::_gai_strerror({})", ecode);
+
+    let cstr = unsafe { std::ffi::CStr::from_ptr(libc::gai_strerror(ecode)) };
+    let bytes = cstr.to_bytes_with_nul();
+    let string_on_guest: WasmPtr<c_char> = call_malloc_with_cast(&mut ctx, bytes.len() as _);
+    let memory = ctx.data().memory(0);
+    let memory = memory.view(&ctx);
+
+    let writer = string_on_guest.slice(&memory, bytes.len() as _).unwrap();
+    for (i, byte) in bytes.iter().enumerate() {
+        writer.index(i as u64).write(*byte as _).unwrap();
+    }
+
+    string_on_guest.offset() as _
+}
+
+pub fn _getaddrinfo(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    node_ptr: WasmPtr<c_char>,
+    service_str_ptr: WasmPtr<c_char>,
+    hints_ptr: WasmPtr<EmAddrInfo>,
+    res_val_ptr: WasmPtr<WasmPtr<EmAddrInfo>>,
+) -> i32 {
+    use libc::{addrinfo, freeaddrinfo};
+    debug!("emscripten::_getaddrinfo");
+    debug!(" => node = {}", {
+        if node_ptr.is_null() {
+            std::borrow::Cow::Borrowed("null")
+        } else {
+            unimplemented!()
+        }
+    });
+    debug!(" => server_str = {}", {
+        if service_str_ptr.is_null() {
+            std::borrow::Cow::Borrowed("null")
+        } else {
+            unimplemented!()
+        }
+    });
+
+    let hints = if hints_ptr.is_null() {
+        None
+    } else {
+        let memory = ctx.data().memory(0);
+        let hints_guest = hints_ptr.deref(&memory.view(&ctx)).read().unwrap();
+        Some(addrinfo {
+            ai_flags: hints_guest.ai_flags,
+            ai_family: hints_guest.ai_family,
+            ai_socktype: hints_guest.ai_socktype,
+            ai_protocol: hints_guest.ai_protocol,
+            ai_addrlen: 0,
+            ai_addr: std::ptr::null_mut(),
+            ai_canonname: std::ptr::null_mut(),
+            ai_next: std::ptr::null_mut(),
+        })
+    };
+
+    let mut out_ptr: *mut addrinfo = std::ptr::null_mut();
+
+    // allocate equivalent memory for res_val_ptr
+    let result = unsafe {
+        libc::getaddrinfo(
+            if node_ptr.is_null() {
+                std::ptr::null()
+            } else {
+                unimplemented!()
+            },
+            if service_str_ptr.is_null() {
+                std::ptr::null()
+            } else {
+                unimplemented!()
+            },
+            hints
+                .as_ref()
+                .map(|h| h as *const addrinfo)
+                .unwrap_or(std::ptr::null()),
+            &mut out_ptr as *mut *mut addrinfo,
+        )
+    };
+    if result != 0 {
+        return result;
+    }
+
+    // walk linked list and copy over, freeing them from the kernel
+    let head_of_list = unsafe {
+        let mut current_host_node = out_ptr;
+        let mut head_of_list = None;
+        let mut previous_guest_node: Option<WasmPtr<EmAddrInfo>> = None;
+
+        while !current_host_node.is_null() {
+            let current_guest_node_ptr: WasmPtr<EmAddrInfo> =
+                call_malloc_with_cast(&mut ctx, std::mem::size_of::<EmAddrInfo>() as _);
+            if head_of_list.is_none() {
+                head_of_list = Some(current_guest_node_ptr);
+            }
+
+            // connect list
+            if let Some(prev_guest) = previous_guest_node {
+                let memory = ctx.data().memory(0);
+                let memory = memory.view(&ctx);
+                let derefed_prev_guest = prev_guest.deref(&memory);
+                let mut pg = derefed_prev_guest.read().unwrap();
+                pg.ai_next = current_guest_node_ptr;
+                derefed_prev_guest.write(pg).unwrap();
+            }
+
+            // update values
+
+            let host_addrlen = (*current_host_node).ai_addrlen;
+            // allocate addr and copy data
+            let guest_sockaddr_ptr = {
+                let host_sockaddr_ptr = (*current_host_node).ai_addr;
+                let guest_sockaddr_ptr: WasmPtr<EmSockAddr> =
+                    call_malloc_with_cast(&mut ctx, host_addrlen as _);
+
+                let memory = ctx.data().memory(0);
+                let memory = memory.view(&ctx);
+                let derefed_guest_sockaddr = guest_sockaddr_ptr.deref(&memory);
+                let mut gs = derefed_guest_sockaddr.read().unwrap();
+                gs.sa_family = (*host_sockaddr_ptr).sa_family as i16;
+                gs.sa_data = (*host_sockaddr_ptr).sa_data;
+                derefed_guest_sockaddr.write(gs).unwrap();
+
+                guest_sockaddr_ptr
+            };
+
+            // allocate canon name on guest and copy data over
+            let guest_canonname_ptr = {
+                let str_ptr = (*current_host_node).ai_canonname;
+                if !str_ptr.is_null() {
+                    let canonname_cstr = std::ffi::CStr::from_ptr(str_ptr);
+                    let canonname_bytes = canonname_cstr.to_bytes_with_nul();
+                    let str_size = canonname_bytes.len();
+                    let guest_canonname: WasmPtr<c_char> =
+                        call_malloc_with_cast(&mut ctx, str_size as _);
+
+                    let memory = ctx.data().memory(0);
+                    let memory = memory.view(&ctx);
+                    let guest_canonname_writer =
+                        guest_canonname.slice(&memory, str_size as _).unwrap();
+                    for (i, b) in canonname_bytes.iter().enumerate() {
+                        guest_canonname_writer
+                            .index(i as u64)
+                            .write(*b as _)
+                            .unwrap();
+                    }
+
+                    guest_canonname
+                } else {
+                    WasmPtr::new(0)
+                }
+            };
+
+            let memory = ctx.data().memory(0);
+            let memory = memory.view(&ctx);
+            let derefed_current_guest_node = current_guest_node_ptr.deref(&memory);
+            let mut cgn = derefed_current_guest_node.read().unwrap();
+            cgn.ai_flags = (*current_host_node).ai_flags;
+            cgn.ai_family = (*current_host_node).ai_family;
+            cgn.ai_socktype = (*current_host_node).ai_socktype;
+            cgn.ai_protocol = (*current_host_node).ai_protocol;
+            cgn.ai_addrlen = host_addrlen;
+            cgn.ai_addr = guest_sockaddr_ptr;
+            cgn.ai_canonname = guest_canonname_ptr;
+            cgn.ai_next = WasmPtr::new(0);
+            derefed_current_guest_node.write(cgn).unwrap();
+
+            previous_guest_node = Some(current_guest_node_ptr);
+            current_host_node = (*current_host_node).ai_next;
+        }
+        // this frees all connected nodes on the linked list
+        freeaddrinfo(out_ptr);
+        head_of_list.unwrap_or_else(|| WasmPtr::new(0))
+    };
+
+    let memory = ctx.data().memory(0);
+    res_val_ptr
+        .deref(&memory.view(&ctx))
+        .write(head_of_list)
+        .unwrap();
+
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/windows/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/windows/mod.rs
new file mode 100644
index 0000000..b342bd9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/env/windows/mod.rs
@@ -0,0 +1,162 @@
+/// NOTE: These syscalls only support wasm_32 for now because they take u32 offset
+use libc::{c_int, c_long, getenv};
+
+use std::ffi::CString;
+use std::mem;
+use std::os::raw::c_char;
+
+use crate::env::{call_malloc, EmAddrInfo};
+use crate::utils::{copy_cstr_into_wasm, read_string_from_wasm};
+use crate::EmEnv;
+use wasmer::{FunctionEnvMut, WasmPtr};
+
+extern "C" {
+    #[link_name = "_putenv"]
+    pub fn putenv(s: *const c_char) -> c_int;
+}
+
+// #[no_mangle]
+/// emscripten: _getenv // (name: *const char) -> *const c_char;
+pub fn _getenv(mut ctx: FunctionEnvMut<EmEnv>, name: u32) -> u32 {
+    debug!("emscripten::_getenv");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    let name_string = read_string_from_wasm(&view, name);
+    debug!("=> name({:?})", name_string);
+    let c_str = unsafe { getenv(name_string.as_ptr() as *const libc::c_char) };
+    if c_str.is_null() {
+        return 0;
+    }
+    unsafe { copy_cstr_into_wasm(&mut ctx, c_str as *const c_char) }
+}
+
+/// emscripten: _setenv // (name: *const char, name: *const value, overwrite: int);
+pub fn _setenv(ctx: FunctionEnvMut<EmEnv>, name: u32, value: u32, _overwrite: u32) -> c_int {
+    debug!("emscripten::_setenv");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    // setenv does not exist on windows, so we hack it with _putenv
+    let name = read_string_from_wasm(&view, name);
+    let value = read_string_from_wasm(&view, value);
+    let putenv_string = format!("{}={}", name, value);
+    let putenv_cstring = CString::new(putenv_string).unwrap();
+    let putenv_raw_ptr = putenv_cstring.as_ptr();
+    debug!("=> name({:?})", name);
+    debug!("=> value({:?})", value);
+    unsafe { putenv(putenv_raw_ptr) }
+}
+
+/// emscripten: _putenv // (name: *const char);
+pub fn _putenv(ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_int {
+    debug!("emscripten::_putenv");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    let name_addr = emscripten_memory_pointer!(&view, name) as *const c_char;
+    debug!("=> name({:?})", unsafe {
+        std::ffi::CStr::from_ptr(name_addr)
+    });
+    unsafe { putenv(name_addr) }
+}
+
+/// emscripten: _unsetenv // (name: *const char);
+pub fn _unsetenv(ctx: FunctionEnvMut<EmEnv>, name: u32) -> c_int {
+    debug!("emscripten::_unsetenv");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    let name = read_string_from_wasm(&view, name);
+    // no unsetenv on windows, so use putenv with an empty value
+    let unsetenv_string = format!("{}=", name);
+    let unsetenv_cstring = CString::new(unsetenv_string).unwrap();
+    let unsetenv_raw_ptr = unsetenv_cstring.as_ptr();
+    debug!("=> name({:?})", name);
+    unsafe { putenv(unsetenv_raw_ptr) }
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _getpwnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
+    debug!("emscripten::_getpwnam {}", name_ptr);
+    #[cfg(not(feature = "debug"))]
+    let _ = name_ptr;
+
+    #[repr(C)]
+    struct GuestPasswd {
+        pw_name: u32,
+        pw_passwd: u32,
+        pw_uid: u32,
+        pw_gid: u32,
+        pw_gecos: u32,
+        pw_dir: u32,
+        pw_shell: u32,
+    }
+
+    // stub this in windows as it is not valid
+    unsafe {
+        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
+        let memory = ctx.data().memory(0);
+        let view = memory.view(&ctx);
+        let passwd_struct_ptr =
+            emscripten_memory_pointer!(&view, passwd_struct_offset) as *mut GuestPasswd;
+        (*passwd_struct_ptr).pw_name = 0;
+        (*passwd_struct_ptr).pw_passwd = 0;
+        (*passwd_struct_ptr).pw_gecos = 0;
+        (*passwd_struct_ptr).pw_dir = 0;
+        (*passwd_struct_ptr).pw_shell = 0;
+        (*passwd_struct_ptr).pw_uid = 0;
+        (*passwd_struct_ptr).pw_gid = 0;
+
+        passwd_struct_offset as c_int
+    }
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _getgrnam(mut ctx: FunctionEnvMut<EmEnv>, name_ptr: c_int) -> c_int {
+    debug!("emscripten::_getgrnam {}", name_ptr);
+    #[cfg(not(feature = "debug"))]
+    let _ = name_ptr;
+
+    #[repr(C)]
+    struct GuestGroup {
+        gr_name: u32,
+        gr_passwd: u32,
+        gr_gid: u32,
+        gr_mem: u32,
+    }
+
+    // stub the group struct as it is not supported on windows
+    unsafe {
+        let group_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestGroup>() as _);
+        let memory = ctx.data().memory(0);
+        let view = memory.view(&ctx);
+        let group_struct_ptr =
+            emscripten_memory_pointer!(&view, group_struct_offset) as *mut GuestGroup;
+        (*group_struct_ptr).gr_name = 0;
+        (*group_struct_ptr).gr_passwd = 0;
+        (*group_struct_ptr).gr_gid = 0;
+        (*group_struct_ptr).gr_mem = 0;
+        group_struct_offset as c_int
+    }
+}
+
+pub fn _sysconf(_ctx: FunctionEnvMut<EmEnv>, name: c_int) -> c_long {
+    debug!("emscripten::_sysconf {}", name);
+    #[cfg(not(feature = "debug"))]
+    let _ = name;
+    // stub because sysconf is not valid on windows
+    0
+}
+
+pub fn _gai_strerror(_ctx: FunctionEnvMut<EmEnv>, _ecode: i32) -> i32 {
+    debug!("emscripten::_gai_strerror({}) - stub", _ecode);
+    -1
+}
+
+pub fn _getaddrinfo(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _node_ptr: WasmPtr<c_char>,
+    _service_str_ptr: WasmPtr<c_char>,
+    _hints_ptr: WasmPtr<EmAddrInfo>,
+    _res_val_ptr: WasmPtr<WasmPtr<EmAddrInfo>>,
+) -> i32 {
+    debug!("emscripten::_getaddrinfo -- stub");
+    -1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/errno.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/errno.rs
new file mode 100644
index 0000000..99c78bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/errno.rs
@@ -0,0 +1,267 @@
+// use std::collections::HashMap;
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn ___seterrno(mut _ctx: FunctionEnvMut<EmEnv>, _value: i32) {
+    debug!("emscripten::___seterrno {}", _value);
+    // TODO: Incomplete impl
+    eprintln!("failed to set errno!");
+    // value
+}
+
+// pub enum ErrnoCodes {
+//     EPERM = 1,
+//     ENOENT = 2,
+//     ESRCH = 3,
+//     EINTR = 4,
+//     EIO = 5,
+//     ENXIO = 6,
+//     E2BIG = 7,
+//     ENOEXEC = 8,
+//     EBADF = 9,
+//     ECHILD = 10,
+//     EAGAIN = 11,
+//     EWOULDBLOCK = 11,
+//     ENOMEM = 12,
+//     EACCES = 13,
+//     EFAULT = 14,
+//     ENOTBLK = 15,
+//     EBUSY = 16,
+//     EEXIST = 17,
+//     EXDEV = 18,
+//     ENODEV = 19,
+//     ENOTDIR = 20,
+//     EISDIR = 21,
+//     EINVAL = 22,
+//     ENFILE = 23,
+//     EMFILE = 24,
+//     ENOTTY = 25,
+//     ETXTBSY = 26,
+//     EFBIG = 27,
+//     ENOSPC = 28,
+//     ESPIPE = 29,
+//     EROFS = 30,
+//     EMLINK = 31,
+//     EPIPE = 32,
+//     EDOM = 33,
+//     ERANGE = 34,
+//     ENOMSG = 42,
+//     EIDRM = 43,
+//     ECHRNG = 44,
+//     EL2NSYNC = 45,
+//     EL3HLT = 46,
+//     EL3RST = 47,
+//     ELNRNG = 48,
+//     EUNATCH = 49,
+//     ENOCSI = 50,
+//     EL2HLT = 51,
+//     EDEADLK = 35,
+//     ENOLCK = 37,
+//     EBADE = 52,
+//     EBADR = 53,
+//     EXFULL = 54,
+//     ENOANO = 55,
+//     EBADRQC = 56,
+//     EBADSLT = 57,
+//     EDEADLOCK = 35,
+//     EBFONT = 59,
+//     ENOSTR = 60,
+//     ENODATA = 61,
+//     ETIME = 62,
+//     ENOSR = 63,
+//     ENONET = 64,
+//     ENOPKG = 65,
+//     EREMOTE = 66,
+//     ENOLINK = 67,
+//     EADV = 68,
+//     ESRMNT = 69,
+//     ECOMM = 70,
+//     EPROTO = 71,
+//     EMULTIHOP = 72,
+//     EDOTDOT = 73,
+//     EBADMSG = 74,
+//     ENOTUNIQ = 76,
+//     EBADFD = 77,
+//     EREMCHG = 78,
+//     ELIBACC = 79,
+//     ELIBBAD = 80,
+//     ELIBSCN = 81,
+//     ELIBMAX = 82,
+//     ELIBEXEC = 83,
+//     ENOSYS = 38,
+//     ENOTEMPTY = 39,
+//     ENAMETOOLONG = 36,
+//     ELOOP = 40,
+//     EOPNOTSUPP = 95,
+//     EPFNOSUPPORT = 96,
+//     ECONNRESET = 104,
+//     ENOBUFS = 105,
+//     EAFNOSUPPORT = 97,
+//     EPROTOTYPE = 91,
+//     ENOTSOCK = 88,
+//     ENOPROTOOPT = 92,
+//     ESHUTDOWN = 108,
+//     ECONNREFUSED = 111,
+//     EADDRINUSE = 98,
+//     ECONNABORTED = 103,
+//     ENETUNREACH = 101,
+//     ENETDOWN = 100,
+//     ETIMEDOUT = 110,
+//     EHOSTDOWN = 112,
+//     EHOSTUNREACH = 113,
+//     EINPROGRESS = 115,
+//     EALREADY = 114,
+//     EDESTADDRREQ = 89,
+//     EMSGSIZE = 90,
+//     EPROTONOSUPPORT = 93,
+//     ESOCKTNOSUPPORT = 94,
+//     EADDRNOTAVAIL = 99,
+//     ENETRESET = 102,
+//     EISCONN = 106,
+//     ENOTCONN = 107,
+//     ETOOMANYREFS = 109,
+//     EUSERS = 87,
+//     EDQUOT = 122,
+//     ESTALE = 116,
+//     ENOTSUP = 95,
+//     ENOMEDIUM = 123,
+//     EILSEQ = 84,
+//     EOVERFLOW = 75,
+//     ECANCELED = 125,
+//     ENOTRECOVERABLE = 131,
+//     EOWNERDEAD = 130,
+//     ESTRPIPE = 86,
+// }
+
+// pub struct ErrnoMessages<'a> {
+//     message_map: HashMap<u32, &'a str>
+// }
+
+// impl<'a> ErrnoMessages<'a> {
+//     fn new() -> Self {
+//         let mut message_map = HashMap::new();
+//         message_map.insert(0, "Success");
+//         message_map.insert(1, "Not super-user");
+//         message_map.insert(2, "No such file or directory");
+//         message_map.insert(3, "No such process");
+//         message_map.insert(4, "Interrupted system call");
+//         message_map.insert(5, "I/O error");
+//         message_map.insert(6, "No such device or address");
+//         message_map.insert(7, "Arg list too long");
+//         message_map.insert(8, "Exec format error");
+//         message_map.insert(9, "Bad file number");
+//         message_map.insert(10, "No children");
+//         message_map.insert(11, "No more processes");
+//         message_map.insert(12, "Not enough core");
+//         message_map.insert(13, "Permission denied");
+//         message_map.insert(14, "Bad address");
+//         message_map.insert(15, "Block device required");
+//         message_map.insert(16, "Mount device busy");
+//         message_map.insert(17, "File exists");
+//         message_map.insert(18, "Cross-device link");
+//         message_map.insert(19, "No such device");
+//         message_map.insert(20, "Not a directory");
+//         message_map.insert(21, "Is a directory");
+//         message_map.insert(22, "Invalid argument");
+//         message_map.insert(23, "Too many open files in system");
+//         message_map.insert(24, "Too many open files");
+//         message_map.insert(25, "Not a typewriter");
+//         message_map.insert(26, "Text file busy");
+//         message_map.insert(27, "File too large");
+//         message_map.insert(28, "No space left on device");
+//         message_map.insert(29, "Illegal seek");
+//         message_map.insert(30, "Read only file system");
+//         message_map.insert(31, "Too many links");
+//         message_map.insert(32, "Broken pipe");
+//         message_map.insert(33, "Math arg out of domain of func");
+//         message_map.insert(34, "Math result not representable");
+//         message_map.insert(35, "File locking deadlock error");
+//         message_map.insert(36, "File or path name too long");
+//         message_map.insert(37, "No record locks available");
+//         message_map.insert(38, "Function not implemented");
+//         message_map.insert(39, "Directory not empty");
+//         message_map.insert(40, "Too many symbolic links");
+//         message_map.insert(42, "No message of desired type");
+//         message_map.insert(43, "Identifier removed");
+//         message_map.insert(44, "Channel number out of range");
+//         message_map.insert(45, "Level 2 not synchronized");
+//         message_map.insert(46, "Level 3 halted");
+//         message_map.insert(47, "Level 3 reset");
+//         message_map.insert(48, "Link number out of range");
+//         message_map.insert(49, "Protocol driver not attached");
+//         message_map.insert(50, "No CSI structure available");
+//         message_map.insert(51, "Level 2 halted");
+//         message_map.insert(52, "Invalid exchange");
+//         message_map.insert(53, "Invalid request descriptor");
+//         message_map.insert(54, "Exchange full");
+//         message_map.insert(55, "No anode");
+//         message_map.insert(56, "Invalid request code");
+//         message_map.insert(57, "Invalid slot");
+//         message_map.insert(59, "Bad font file fmt");
+//         message_map.insert(60, "Device not a stream");
+//         message_map.insert(61, "No data (for no delay io)");
+//         message_map.insert(62, "Timer expired");
+//         message_map.insert(63, "Out of streams resources");
+//         message_map.insert(64, "Machine is not on the network");
+//         message_map.insert(65, "Package not installed");
+//         message_map.insert(66, "The object is remote");
+//         message_map.insert(67, "The link has been severed");
+//         message_map.insert(68, "Advertise error");
+//         message_map.insert(69, "Srmount error");
+//         message_map.insert(70, "Communication error on send");
+//         message_map.insert(71, "Protocol error");
+//         message_map.insert(72, "Multihop attempted");
+//         message_map.insert(73, "Cross mount point (not really error)");
+//         message_map.insert(74, "Trying to read unreadable message");
+//         message_map.insert(75, "Value too large for defined data type");
+//         message_map.insert(76, "Given log. name not unique");
+//         message_map.insert(77, "f.d. invalid for this operation");
+//         message_map.insert(78, "Remote address changed");
+//         message_map.insert(79, "Can   access a needed shared lib");
+//         message_map.insert(80, "Accessing a corrupted shared lib");
+//         message_map.insert(81, ".lib section in a.out corrupted");
+//         message_map.insert(82, "Attempting to link in too many libs");
+//         message_map.insert(83, "Attempting to exec a shared library");
+//         message_map.insert(84, "Illegal byte sequence");
+//         message_map.insert(86, "Streams pipe error");
+//         message_map.insert(87, "Too many users");
+//         message_map.insert(88, "Socket operation on non-socket");
+//         message_map.insert(89, "Destination address required");
+//         message_map.insert(90, "Message too long");
+//         message_map.insert(91, "Protocol wrong type for socket");
+//         message_map.insert(92, "Protocol not available");
+//         message_map.insert(93, "Unknown protocol");
+//         message_map.insert(94, "Socket type not supported");
+//         message_map.insert(95, "Not supported");
+//         message_map.insert(96, "Protocol family not supported");
+//         message_map.insert(97, "Address family not supported by protocol family");
+//         message_map.insert(98, "Address already in use");
+//         message_map.insert(99, "Address not available");
+//         message_map.insert(100, "Network interface is not configured");
+//         message_map.insert(101, "Network is unreachable");
+//         message_map.insert(102, "Connection reset by network");
+//         message_map.insert(103, "Connection aborted");
+//         message_map.insert(104, "Connection reset by peer");
+//         message_map.insert(105, "No buffer space available");
+//         message_map.insert(106, "Socket is already connected");
+//         message_map.insert(107, "Socket is not connected");
+//         message_map.insert(108, "Can't send after socket shutdown");
+//         message_map.insert(109, "Too many references");
+//         message_map.insert(110, "Connection timed out");
+//         message_map.insert(111, "Connection refused");
+//         message_map.insert(112, "Host is down");
+//         message_map.insert(113, "Host is unreachable");
+//         message_map.insert(114, "Socket already connected");
+//         message_map.insert(115, "Connection already in progress");
+//         message_map.insert(116, "Stale file handle");
+//         message_map.insert(122, "Quota exceeded");
+//         message_map.insert(123, "No medium (in tape drive)");
+//         message_map.insert(125, "Operation canceled");
+//         message_map.insert(130, "Previous owner died");
+//         message_map.insert(131, "State not recoverable");
+
+//         ErrnoMessages {
+//             message_map,
+//         }
+//     }
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exception.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exception.rs
new file mode 100644
index 0000000..c3c8353
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exception.rs
@@ -0,0 +1,58 @@
+use super::env;
+use super::process::_abort;
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+/// emscripten: ___cxa_allocate_exception
+pub fn ___cxa_allocate_exception(mut ctx: FunctionEnvMut<EmEnv>, size: u32) -> u32 {
+    debug!("emscripten::___cxa_allocate_exception");
+    env::call_malloc(&mut ctx.as_mut(), size as _)
+}
+
+pub fn ___cxa_current_primary_exception(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    debug!("emscripten::___cxa_current_primary_exception");
+    unimplemented!("emscripten::___cxa_current_primary_exception")
+}
+
+pub fn ___cxa_decrement_exception_refcount(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
+    debug!("emscripten::___cxa_decrement_exception_refcount({})", _a);
+    unimplemented!("emscripten::___cxa_decrement_exception_refcount({})", _a)
+}
+
+pub fn ___cxa_increment_exception_refcount(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
+    debug!("emscripten::___cxa_increment_exception_refcount({})", _a);
+    unimplemented!("emscripten::___cxa_increment_exception_refcount({})", _a)
+}
+
+pub fn ___cxa_rethrow_primary_exception(_ctx: FunctionEnvMut<EmEnv>, _a: u32) {
+    debug!("emscripten::___cxa_rethrow_primary_exception({})", _a);
+    unimplemented!("emscripten::___cxa_rethrow_primary_exception({})", _a)
+}
+
+/// emscripten: ___cxa_throw
+/// TODO: We don't have support for exceptions yet
+pub fn ___cxa_throw(ctx: FunctionEnvMut<EmEnv>, _ptr: u32, _ty: u32, _destructor: u32) {
+    debug!("emscripten::___cxa_throw");
+    eprintln!("Throwing exceptions not yet implemented: aborting!");
+    _abort(ctx);
+}
+
+pub fn ___cxa_begin_catch(_ctx: FunctionEnvMut<EmEnv>, _exception_object_ptr: u32) -> i32 {
+    debug!("emscripten::___cxa_begin_catch");
+    -1
+}
+
+pub fn ___cxa_end_catch(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::___cxa_end_catch");
+}
+
+pub fn ___cxa_uncaught_exception(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::___cxa_uncaught_exception");
+    -1
+}
+
+pub fn ___cxa_pure_virtual(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::___cxa_pure_virtual");
+    // ABORT = true
+    panic!("Pure virtual function called!");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exec.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exec.rs
new file mode 100644
index 0000000..8fe4486
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exec.rs
@@ -0,0 +1,63 @@
+use crate::varargs::VarArgs;
+use crate::EmEnv;
+use libc::c_char;
+use libc::execvp as libc_execvp;
+use std::ffi::CString;
+use wasmer::{FunctionEnvMut, WasmPtr};
+
+pub fn execvp(ctx: FunctionEnvMut<EmEnv>, command_name_offset: u32, argv_offset: u32) -> i32 {
+    // a single reference to re-use
+    let memory = ctx.data().memory(0);
+    let emscripten_memory = memory.view(&ctx);
+
+    // read command name as string
+    let command_name_string_vec = WasmPtr::<u8>::new(command_name_offset)
+        .read_until(&emscripten_memory, |&byte| byte == 0)
+        .unwrap();
+    let command_name_string = CString::new(command_name_string_vec).unwrap();
+
+    // get the array of args
+    let argv = WasmPtr::<WasmPtr<u8>>::new(argv_offset)
+        .read_until(&emscripten_memory, |&ptr| ptr.is_null())
+        .unwrap();
+    let arg_strings: Vec<CString> = argv
+        .into_iter()
+        .map(|ptr| {
+            let vec = ptr
+                .read_until(&emscripten_memory, |&byte| byte == 0)
+                .unwrap();
+            CString::new(vec).unwrap()
+        })
+        .collect();
+    let mut argv: Vec<*const c_char> = arg_strings.iter().map(|s| s.as_ptr()).collect();
+
+    // push a nullptr on to the end of the args array
+    argv.push(std::ptr::null());
+
+    // construct raw pointers and hand them to `execvp`
+    let command_pointer = command_name_string.as_ptr() as *const i8;
+    let args_pointer = argv.as_ptr();
+    unsafe { libc_execvp(command_pointer as *const _, args_pointer as *const *const _) }
+}
+
+/// execl
+pub fn execl(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _path_ptr: i32,
+    _arg0_ptr: i32,
+    _varargs: VarArgs,
+) -> i32 {
+    debug!("emscripten::execl");
+    -1
+}
+
+/// execle
+pub fn execle(
+    _ctx: FunctionEnvMut<EmEnv>,
+    _path_ptr: i32,
+    _arg0_ptr: i32,
+    _varargs: VarArgs,
+) -> i32 {
+    debug!("emscripten::execle");
+    -1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exit.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exit.rs
new file mode 100644
index 0000000..907bb66
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/exit.rs
@@ -0,0 +1,8 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+// __exit
+pub fn exit(mut _ctx: FunctionEnvMut<EmEnv>, value: i32) {
+    debug!("emscripten::exit {}", value);
+    ::std::process::exit(value);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/inet.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/inet.rs
new file mode 100644
index 0000000..863a6bc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/inet.rs
@@ -0,0 +1,7 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn addr(mut _ctx: FunctionEnvMut<EmEnv>, _cp: i32) -> i32 {
+    debug!("inet::addr({})", _cp);
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/mod.rs
new file mode 100644
index 0000000..3682842
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/mod.rs
@@ -0,0 +1,66 @@
+#[cfg(unix)]
+mod unix;
+
+#[cfg(windows)]
+mod windows;
+
+#[cfg(unix)]
+pub use self::unix::*;
+
+#[cfg(windows)]
+pub use self::windows::*;
+
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+/// getprotobyname
+pub fn getprotobyname(_ctx: FunctionEnvMut<EmEnv>, _name_ptr: i32) -> i32 {
+    debug!("emscripten::getprotobyname");
+    unimplemented!("emscripten::getprotobyname")
+}
+
+/// getprotobynumber
+pub fn getprotobynumber(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::getprotobynumber");
+    unimplemented!("emscripten::getprotobynumber")
+}
+
+/// sigdelset
+pub fn sigdelset(ctx: FunctionEnvMut<EmEnv>, set: i32, signum: i32) -> i32 {
+    debug!("emscripten::sigdelset");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    #[allow(clippy::cast_ptr_alignment)]
+    let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
+
+    unsafe { *ptr &= !(1 << (signum - 1)) }
+
+    0
+}
+
+/// sigfillset
+pub fn sigfillset(ctx: FunctionEnvMut<EmEnv>, set: i32) -> i32 {
+    debug!("emscripten::sigfillset");
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+    #[allow(clippy::cast_ptr_alignment)]
+    let ptr = emscripten_memory_pointer!(&view, set) as *mut i32;
+
+    unsafe {
+        *ptr = -1;
+    }
+
+    0
+}
+
+/// tzset
+pub fn tzset(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::tzset - stub");
+    //unimplemented!("emscripten::tzset - stub")
+}
+
+/// strptime
+pub fn strptime(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::strptime");
+    unimplemented!("emscripten::strptime")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/unix.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/unix.rs
new file mode 100644
index 0000000..52d13d2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/unix.rs
@@ -0,0 +1,68 @@
+use super::super::env::call_malloc;
+use super::super::utils::copy_cstr_into_wasm;
+use libc::{chroot as _chroot, getpwuid as _getpwuid, printf as _printf};
+use std::mem;
+
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+/// putchar
+pub fn putchar(_ctx: FunctionEnvMut<EmEnv>, chr: i32) {
+    unsafe { libc::putchar(chr) };
+}
+
+/// printf
+pub fn printf(ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32 {
+    debug!("emscripten::printf {}, {}", memory_offset, extra);
+    unsafe {
+        let addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), memory_offset) as _;
+        _printf(addr, extra)
+    }
+}
+
+/// chroot
+pub fn chroot(ctx: FunctionEnvMut<EmEnv>, name_ptr: i32) -> i32 {
+    debug!("emscripten::chroot");
+    let name = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), name_ptr) as *const i8;
+    unsafe { _chroot(name as *const _) }
+}
+
+/// getpwuid
+#[allow(clippy::cast_ptr_alignment)]
+pub fn getpwuid(mut ctx: FunctionEnvMut<EmEnv>, uid: i32) -> i32 {
+    debug!("emscripten::getpwuid {}", uid);
+
+    #[repr(C)]
+    struct GuestPasswd {
+        pw_name: u32,
+        pw_passwd: u32,
+        pw_uid: u32,
+        pw_gid: u32,
+        pw_gecos: u32,
+        pw_dir: u32,
+        pw_shell: u32,
+    }
+
+    unsafe {
+        let passwd = &*_getpwuid(uid as _);
+        let passwd_struct_offset = call_malloc(&mut ctx, mem::size_of::<GuestPasswd>() as _);
+        let passwd_struct_ptr =
+            emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), passwd_struct_offset)
+                as *mut GuestPasswd;
+        assert_eq!(
+            passwd_struct_ptr as usize % std::mem::align_of::<GuestPasswd>(),
+            0
+        );
+        (*passwd_struct_ptr).pw_name = copy_cstr_into_wasm(&mut ctx, passwd.pw_name);
+        (*passwd_struct_ptr).pw_passwd = copy_cstr_into_wasm(&mut ctx, passwd.pw_passwd);
+        (*passwd_struct_ptr).pw_gecos = copy_cstr_into_wasm(&mut ctx, passwd.pw_gecos);
+        (*passwd_struct_ptr).pw_dir = copy_cstr_into_wasm(&mut ctx, passwd.pw_dir);
+        (*passwd_struct_ptr).pw_shell = copy_cstr_into_wasm(&mut ctx, passwd.pw_shell);
+        (*passwd_struct_ptr).pw_uid = passwd.pw_uid;
+        (*passwd_struct_ptr).pw_gid = passwd.pw_gid;
+
+        passwd_struct_offset as _
+    }
+    // unsafe { _getpwuid(uid as _) as _}
+    // 0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/windows.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/windows.rs
new file mode 100644
index 0000000..c9b00e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/io/windows.rs
@@ -0,0 +1,47 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+// This may be problematic for msvc which uses inline functions for the printf family
+// this cfg_attr will try to link with the legacy lib that does not inline printf
+// this will allow for compiliation, but will produce a linker error if there is a problem
+// finding printf.
+//#[cfg_attr(
+//    all(windows, target_env = "msvc"),
+//    link(name = "legacy_stdio_definitions", kind = "static-nobundle")
+//)]
+//extern "C" {
+//    #[link_name = "printf"]
+//    pub fn _printf(s: *const c_char, ...) -> c_int;
+//}
+
+/// putchar
+pub fn putchar(_ctx: FunctionEnvMut<EmEnv>, chr: i32) {
+    unsafe { libc::putchar(chr) };
+}
+
+/// printf
+pub fn printf(_ctx: FunctionEnvMut<EmEnv>, memory_offset: i32, extra: i32) -> i32 {
+    debug!("emscripten::printf {}, {}", memory_offset, extra);
+    #[cfg(not(feature = "debug"))]
+    {
+        let _ = memory_offset;
+        let _ = extra;
+    }
+    //    unsafe {
+    //        let addr = emscripten_memory_pointer!(ctx.memory(0), memory_offset) as _;
+    //        _printf(addr, extra)
+    //    }
+    -1
+}
+
+/// chroot
+pub fn chroot(_ctx: FunctionEnvMut<EmEnv>, _name_ptr: i32) -> i32 {
+    debug!("emscripten::chroot");
+    unimplemented!("emscripten::chroot")
+}
+
+/// getpwuid
+pub fn getpwuid(_ctx: FunctionEnvMut<EmEnv>, _uid: i32) -> i32 {
+    debug!("emscripten::getpwuid");
+    unimplemented!("emscripten::getpwuid")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/jmp.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/jmp.rs
new file mode 100644
index 0000000..903a472
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/jmp.rs
@@ -0,0 +1,80 @@
+use super::env::get_emscripten_funcs;
+use super::process::abort_with_message;
+use libc::c_int;
+// use std::cell::UnsafeCell;
+use crate::EmEnv;
+use std::error::Error;
+use std::fmt;
+use wasmer::FunctionEnvMut;
+
+/// setjmp
+pub fn __setjmp(ctx: FunctionEnvMut<EmEnv>, _env_addr: u32) -> c_int {
+    debug!("emscripten::__setjmp (setjmp)");
+    abort_with_message(ctx, "missing function: _setjmp");
+    unreachable!()
+    // unsafe {
+    //     // Rather than using the env as the holder of the jump buffer pointer,
+    //     // we use the environment address to store the index relative to jumps
+    //     // so the address of the jump it's outside the wasm memory itself.
+    //     let jump_index = emscripten_memory_pointer!(ctx.memory(0), env_addr) as *mut i8;
+    //     // We create the jump buffer outside of the wasm memory
+    //     let jump_buf: UnsafeCell<[u32; 27]> = UnsafeCell::new([0; 27]);
+    //     let jumps = &mut get_emscripten_data(&ctx).jumps;
+    //     let result = setjmp(jump_buf.get() as _);
+    //     // We set the jump index to be the last 3value of jumps
+    //     *jump_index = jumps.len() as _;
+    //     // We hold the reference of the jump buffer
+    //     jumps.push(jump_buf);
+    //     result
+    // }
+}
+
+/// longjmp
+#[allow(unreachable_code)]
+pub fn __longjmp(ctx: FunctionEnvMut<EmEnv>, _env_addr: u32, _val: c_int) {
+    debug!("emscripten::__longjmp (longmp)");
+    abort_with_message(ctx, "missing function: _longjmp");
+    // unsafe {
+    //     // We retrieve the jump index from the env address
+    //     let jump_index = emscripten_memory_pointer!(ctx.memory(0), env_addr) as *mut i8;
+    //     let jumps = &mut get_emscripten_data(&ctx).jumps;
+    //     // We get the real jump buffer from the jumps vector, using the retrieved index
+    //     let jump_buf = &jumps[*jump_index as usize];
+    //     longjmp(jump_buf.get() as _, val)
+    // };
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct LongJumpRet;
+
+impl fmt::Display for LongJumpRet {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "LongJumpRet")
+    }
+}
+
+impl Error for LongJumpRet {}
+
+/// _longjmp
+// This function differs from the js implementation, it should return Result<(), &'static str>
+#[allow(unreachable_code)]
+pub fn _longjmp(
+    mut ctx: FunctionEnvMut<EmEnv>,
+    env_addr: i32,
+    val: c_int,
+) -> Result<(), LongJumpRet> {
+    let val = if val == 0 { 1 } else { val };
+    let threw = get_emscripten_funcs(&ctx)
+        .set_threw_ref()
+        .expect("set_threw is None")
+        .clone();
+    threw
+        .call(&mut ctx, env_addr, val)
+        .expect("set_threw failed to call");
+    Err(LongJumpRet)
+}
+
+// extern "C" {
+//     fn setjmp(env: *mut c_void) -> c_int;
+//     fn longjmp(env: *mut c_void, val: c_int) -> !;
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lib.rs
new file mode 100644
index 0000000..3a3e644
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lib.rs
@@ -0,0 +1,1570 @@
+#![deny(
+    dead_code,
+    nonstandard_style,
+    unused_imports,
+    unused_mut,
+    unused_variables,
+    unused_unsafe,
+    unreachable_patterns
+)]
+// This allow attribute is ignored when placed directly on fields that also
+// have a #[wasmer(...)] attribute. As a dirty workaround it is for now
+// allowed for the whole library.
+#![allow(clippy::type_complexity, clippy::unnecessary_cast)]
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[macro_use]
+extern crate log;
+
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+use std::f64;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex, RwLock};
+use wasmer::{
+    imports, namespace, AsStoreMut, AsStoreRef, ExportError, Exports, Function, FunctionEnv,
+    FunctionEnvMut, FunctionType, Global, Imports, Instance, Memory, MemoryType, Module, Pages,
+    RuntimeError, Table, TableType, TypedFunction, Value, WasmPtr,
+};
+use wasmer_types::Type as ValType;
+
+#[cfg(unix)]
+extern crate libc as libc_crate;
+#[cfg(unix)]
+use libc_crate::DIR as LibcDir;
+
+// We use a placeholder for windows
+#[cfg(not(unix))]
+type LibcDir = u8;
+
+#[macro_use]
+mod macros;
+
+// EMSCRIPTEN APIS
+mod bitwise;
+mod emscripten_target;
+mod env;
+mod errno;
+mod exception;
+mod exec;
+mod exit;
+mod inet;
+mod io;
+mod jmp;
+mod libc;
+mod linking;
+mod lock;
+mod math;
+mod memory;
+mod process;
+mod pthread;
+mod signal;
+mod storage;
+mod syscalls;
+mod time;
+mod ucontext;
+mod unistd;
+mod utils;
+mod varargs;
+
+pub use self::storage::{align_memory, static_alloc};
+pub use self::utils::{
+    allocate_cstr_on_stack, allocate_on_stack, get_emscripten_memory_size, get_emscripten_metadata,
+    get_emscripten_table_size, is_emscripten_module,
+};
+
+/// State of the emscripten environment (environment variables, CLI args)
+#[derive(Debug, Clone)]
+pub struct EmscriptenState {
+    /// Environment variables in a [key -> value] mapping
+    pub env_vars: HashMap<String, String>,
+    /// Command line arguments that this module received
+    pub cli_args: Vec<String>,
+}
+
+impl Default for EmscriptenState {
+    fn default() -> Self {
+        Self {
+            env_vars: std::env::vars_os()
+                .filter_map(|(k, v)| Some((k.to_str()?.to_string(), v.to_str()?.to_string())))
+                .collect(),
+            cli_args: Vec::new(),
+        }
+    }
+}
+
+#[derive(Clone)]
+/// The environment provided to the Emscripten imports.
+pub struct EmEnv {
+    memory: Arc<RwLock<Option<Memory>>>,
+    data: Arc<Mutex<Option<EmscriptenData>>>,
+    funcs: Arc<Mutex<EmscriptenFunctions>>,
+    // State that is passed to the wasm module (environment variables, CLI args, ...)
+    #[allow(dead_code)]
+    state: Arc<Mutex<EmscriptenState>>,
+}
+
+impl Default for EmEnv {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl EmEnv {
+    /// Create a new EmEnv, with default value to be set later (set_memory, set_functions and set_data)
+    pub fn new() -> Self {
+        Self {
+            memory: Arc::new(RwLock::new(None)),
+            data: Arc::new(Mutex::new(None)),
+            funcs: Arc::new(Mutex::new(EmscriptenFunctions::new())),
+            state: Arc::new(Mutex::new(EmscriptenState::default())),
+        }
+    }
+
+    pub fn new_with_state(emstate: EmscriptenState) -> Self {
+        Self {
+            memory: Arc::new(RwLock::new(None)),
+            data: Arc::new(Mutex::new(None)),
+            funcs: Arc::new(Mutex::new(EmscriptenFunctions::new())),
+            state: Arc::new(Mutex::new(emstate)),
+        }
+    }
+
+    pub fn set_memory(&self, memory: Memory) {
+        let mut w = self.memory.write().unwrap();
+        *w = Some(memory);
+    }
+
+    /// Get a reference to the memory
+    pub fn memory(&self, _mem_idx: u32) -> Memory {
+        (*self.memory.read().unwrap()).as_ref().cloned().unwrap()
+    }
+
+    pub fn set_functions(&self, funcs: EmscriptenFunctions) {
+        let mut w = self.funcs.lock().unwrap();
+        *w = funcs;
+    }
+
+    pub fn set_data(&self, data: &EmscriptenGlobalsData, mapped_dirs: HashMap<String, PathBuf>) {
+        let mut w = self.data.lock().unwrap();
+        *w = Some(EmscriptenData::new(data.clone(), mapped_dirs));
+    }
+
+    pub fn get_env_var(&self, key: &str) -> Option<String> {
+        let w = self.state.lock().ok()?;
+        let result = w.env_vars.get(key).cloned();
+        result
+    }
+
+    pub fn get_env_vars_len(&self) -> usize {
+        let w = self.state.lock().unwrap();
+        w.env_vars.len()
+    }
+
+    pub fn set_env_var(&self, key: &str, value: &str) -> Option<String> {
+        let mut w = self.state.lock().ok()?;
+        w.env_vars.insert(key.to_string(), value.to_string())
+    }
+
+    pub fn remove_env_var(&self, key: &str) -> Option<String> {
+        let mut w = self.state.lock().ok()?;
+        w.env_vars.remove(key)
+    }
+
+    pub fn get_args_size(&self) -> usize {
+        let w = self.state.lock().unwrap();
+        w.cli_args.len()
+    }
+
+    pub fn get_args(&self) -> Vec<String> {
+        let w = self.state.lock().unwrap();
+        w.cli_args.clone()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct LibcDirWrapper(pub *mut LibcDir);
+
+impl std::ops::Deref for LibcDirWrapper {
+    type Target = *mut LibcDir;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+unsafe impl Send for LibcDirWrapper {}
+unsafe impl Sync for LibcDirWrapper {}
+
+// TODO: Magic number - how is this calculated?
+const TOTAL_STACK: u32 = 5_242_880;
+// TODO: make this variable
+const STATIC_BUMP: u32 = 215_536;
+
+lazy_static! {
+    static ref OLD_ABORT_ON_CANNOT_GROW_MEMORY_SIG: FunctionType =
+        FunctionType::new(vec![], vec![ValType::I32]);
+}
+
+// The address globals begin at. Very low in memory, for code size and optimization opportunities.
+// Above 0 is static memory, starting with globals.
+// Then the stack.
+// Then 'dynamic' memory for sbrk.
+const GLOBAL_BASE: u32 = 1024;
+const STATIC_BASE: u32 = GLOBAL_BASE;
+
+#[derive(Clone, Default)]
+pub struct EmscriptenFunctions {
+    pub malloc: Option<TypedFunction<u32, u32>>,
+    pub free: Option<TypedFunction<u32, ()>>,
+    pub memalign: Option<TypedFunction<(u32, u32), u32>>,
+    pub memset: Option<TypedFunction<(u32, u32, u32), u32>>,
+    pub stack_alloc: Option<TypedFunction<u32, u32>>,
+
+    pub dyn_call_i: Option<TypedFunction<i32, i32>>,
+    pub dyn_call_ii: Option<TypedFunction<(i32, i32), i32>>,
+    pub dyn_call_iii: Option<TypedFunction<(i32, i32, i32), i32>>,
+    pub dyn_call_iiii: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
+    pub dyn_call_iifi: Option<TypedFunction<(i32, i32, f64, i32), i32>>,
+    pub dyn_call_v: Option<TypedFunction<i32, ()>>,
+    pub dyn_call_vi: Option<TypedFunction<(i32, i32), ()>>,
+    pub dyn_call_vii: Option<TypedFunction<(i32, i32, i32), ()>>,
+    pub dyn_call_viii: Option<TypedFunction<(i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiii: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
+
+    // round 2
+    pub dyn_call_dii: Option<TypedFunction<(i32, i32, i32), f64>>,
+    pub dyn_call_diiii: Option<TypedFunction<(i32, i32, i32, i32, i32), f64>>,
+    pub dyn_call_iiiii: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiiiiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_vd: Option<TypedFunction<(i32, f64), ()>>,
+    pub dyn_call_viiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiiiiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiiiiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_iij: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
+    pub dyn_call_iji: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiji: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_iiijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_j: Option<TypedFunction<i32, i32>>,
+    pub dyn_call_ji: Option<TypedFunction<(i32, i32), i32>>,
+    pub dyn_call_jii: Option<TypedFunction<(i32, i32, i32), i32>>,
+    pub dyn_call_jij: Option<TypedFunction<(i32, i32, i32, i32), i32>>,
+    pub dyn_call_jjj: Option<TypedFunction<(i32, i32, i32, i32, i32), i32>>,
+    pub dyn_call_viiij: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiijiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiijiiiiii:
+        Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viij: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viiji: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viijiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_vj: Option<TypedFunction<(i32, i32, i32), ()>>,
+    pub dyn_call_vjji: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_vij: Option<TypedFunction<(i32, i32, i32, i32), ()>>,
+    pub dyn_call_viji: Option<TypedFunction<(i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_vijiii: Option<TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_vijj: Option<TypedFunction<(i32, i32, i32, i32, i32, i32), ()>>,
+    pub dyn_call_viid: Option<TypedFunction<(i32, i32, i32, f64), ()>>,
+    pub dyn_call_vidd: Option<TypedFunction<(i32, i32, f64, f64), ()>>,
+    pub dyn_call_viidii: Option<TypedFunction<(i32, i32, i32, f64, i32, i32), ()>>,
+    pub dyn_call_viidddddddd:
+        Option<TypedFunction<(i32, i32, i32, f64, f64, f64, f64, f64, f64, f64, f64), ()>>,
+
+    pub stack_save: Option<TypedFunction<(), i32>>,
+    pub stack_restore: Option<TypedFunction<i32, ()>>,
+    pub set_threw: Option<TypedFunction<(i32, i32), ()>>,
+}
+
+#[derive(Clone, Default)]
+pub struct EmscriptenData {
+    pub globals: EmscriptenGlobalsData,
+
+    pub jumps: Arc<Mutex<Vec<[u32; 27]>>>,
+    pub opened_dirs: HashMap<i32, Box<LibcDirWrapper>>,
+
+    pub temp_ret_0: i32,
+
+    pub mapped_dirs: HashMap<String, PathBuf>,
+}
+
+impl EmscriptenData {
+    pub fn new(
+        globals: EmscriptenGlobalsData,
+        mapped_dirs: HashMap<String, PathBuf>,
+    ) -> EmscriptenData {
+        EmscriptenData {
+            globals,
+            temp_ret_0: 0,
+            mapped_dirs,
+            ..Default::default()
+        }
+    }
+}
+
+impl EmscriptenFunctions {
+    pub fn new() -> EmscriptenFunctions {
+        EmscriptenFunctions {
+            ..Default::default()
+        }
+    }
+    pub fn malloc_ref(&self) -> Option<&TypedFunction<u32, u32>> {
+        self.malloc.as_ref()
+    }
+    pub fn free_ref(&self) -> Option<&TypedFunction<u32, ()>> {
+        self.free.as_ref()
+    }
+    pub fn memalign_ref(&self) -> Option<&TypedFunction<(u32, u32), u32>> {
+        self.memalign.as_ref()
+    }
+    pub fn memset_ref(&self) -> Option<&TypedFunction<(u32, u32, u32), u32>> {
+        self.memset.as_ref()
+    }
+    pub fn stack_alloc_ref(&self) -> Option<&TypedFunction<u32, u32>> {
+        self.stack_alloc.as_ref()
+    }
+
+    pub fn dyn_call_i_ref(&self) -> Option<&TypedFunction<i32, i32>> {
+        self.dyn_call_i.as_ref()
+    }
+    pub fn dyn_call_ii_ref(&self) -> Option<&TypedFunction<(i32, i32), i32>> {
+        self.dyn_call_ii.as_ref()
+    }
+    pub fn dyn_call_iii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), i32>> {
+        self.dyn_call_iii.as_ref()
+    }
+    pub fn dyn_call_iiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiii.as_ref()
+    }
+    pub fn dyn_call_iifi_ref(&self) -> Option<&TypedFunction<(i32, i32, f64, i32), i32>> {
+        self.dyn_call_iifi.as_ref()
+    }
+    pub fn dyn_call_v_ref(&self) -> Option<&TypedFunction<i32, ()>> {
+        self.dyn_call_v.as_ref()
+    }
+    pub fn dyn_call_vi_ref(&self) -> Option<&TypedFunction<(i32, i32), ()>> {
+        self.dyn_call_vi.as_ref()
+    }
+    pub fn dyn_call_vii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), ()>> {
+        self.dyn_call_vii.as_ref()
+    }
+    pub fn dyn_call_viii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), ()>> {
+        self.dyn_call_viii.as_ref()
+    }
+    pub fn dyn_call_viiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiii.as_ref()
+    }
+    pub fn dyn_call_dii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), f64>> {
+        self.dyn_call_dii.as_ref()
+    }
+    pub fn dyn_call_diiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), f64>> {
+        self.dyn_call_diiii.as_ref()
+    }
+    pub fn dyn_call_iiiii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiiiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiiiiiii.as_ref()
+    }
+    pub fn dyn_call_iiiiiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiiiiiiiiii.as_ref()
+    }
+    pub fn dyn_call_vd_ref(&self) -> Option<&TypedFunction<(i32, f64), ()>> {
+        self.dyn_call_vd.as_ref()
+    }
+    pub fn dyn_call_viiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiii.as_ref()
+    }
+    pub fn dyn_call_viiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiiii.as_ref()
+    }
+    pub fn dyn_call_viiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiiiii.as_ref()
+    }
+    pub fn dyn_call_viiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiiiiii.as_ref()
+    }
+    pub fn dyn_call_viiiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiiiiiii.as_ref()
+    }
+    pub fn dyn_call_viiiiiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiiiiiiiii.as_ref()
+    }
+    pub fn dyn_call_iij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
+        self.dyn_call_iij.as_ref()
+    }
+    pub fn dyn_call_iji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
+        self.dyn_call_iji.as_ref()
+    }
+    pub fn dyn_call_iiji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiji.as_ref()
+    }
+    pub fn dyn_call_iiijj_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_iiijj.as_ref()
+    }
+    pub fn dyn_call_j_ref(&self) -> Option<&TypedFunction<i32, i32>> {
+        self.dyn_call_j.as_ref()
+    }
+    pub fn dyn_call_ji_ref(&self) -> Option<&TypedFunction<(i32, i32), i32>> {
+        self.dyn_call_ji.as_ref()
+    }
+    pub fn dyn_call_jii_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), i32>> {
+        self.dyn_call_jii.as_ref()
+    }
+    pub fn dyn_call_jij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), i32>> {
+        self.dyn_call_jij.as_ref()
+    }
+    pub fn dyn_call_jjj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), i32>> {
+        self.dyn_call_jjj.as_ref()
+    }
+    pub fn dyn_call_viiij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiij.as_ref()
+    }
+    pub fn dyn_call_viiijiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiijiiii.as_ref()
+    }
+    pub fn dyn_call_viiijiiiiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), ()>>
+    {
+        self.dyn_call_viiijiiiiii.as_ref()
+    }
+    pub fn dyn_call_viij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viij.as_ref()
+    }
+    pub fn dyn_call_viiji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viiji.as_ref()
+    }
+    pub fn dyn_call_viijiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viijiii.as_ref()
+    }
+    pub fn dyn_call_viijj_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viijj.as_ref()
+    }
+    pub fn dyn_call_vj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32), ()>> {
+        self.dyn_call_vj.as_ref()
+    }
+    pub fn dyn_call_vjji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_vjji.as_ref()
+    }
+    pub fn dyn_call_vij_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32), ()>> {
+        self.dyn_call_vij.as_ref()
+    }
+    pub fn dyn_call_viji_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_viji.as_ref()
+    }
+    pub fn dyn_call_vijiii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_vijiii.as_ref()
+    }
+    pub fn dyn_call_vijj_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, i32, i32, i32), ()>> {
+        self.dyn_call_vijj.as_ref()
+    }
+    pub fn dyn_call_viid_ref(&self) -> Option<&TypedFunction<(i32, i32, i32, f64), ()>> {
+        self.dyn_call_viid.as_ref()
+    }
+    pub fn dyn_call_vidd_ref(&self) -> Option<&TypedFunction<(i32, i32, f64, f64), ()>> {
+        self.dyn_call_vidd.as_ref()
+    }
+    pub fn dyn_call_viidii_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, f64, i32, i32), ()>> {
+        self.dyn_call_viidii.as_ref()
+    }
+    pub fn dyn_call_viidddddddd_ref(
+        &self,
+    ) -> Option<&TypedFunction<(i32, i32, i32, f64, f64, f64, f64, f64, f64, f64, f64), ()>> {
+        self.dyn_call_viidddddddd.as_ref()
+    }
+
+    pub fn stack_save_ref(&self) -> Option<&TypedFunction<(), i32>> {
+        self.stack_save.as_ref()
+    }
+    pub fn stack_restore_ref(&self) -> Option<&TypedFunction<i32, ()>> {
+        self.stack_restore.as_ref()
+    }
+    pub fn set_threw_ref(&self) -> Option<&TypedFunction<(i32, i32), ()>> {
+        self.set_threw.as_ref()
+    }
+}
+
+/// Call the global constructors for C++ and set up the emscripten environment.
+///
+/// Note that this function does not completely set up Emscripten to be called.
+/// before calling this function, please initialize `Ctx::data` with a pointer
+/// to [`EmscriptenData`].
+pub fn set_up_emscripten(
+    store: &mut impl AsStoreMut,
+    instance: &mut Instance,
+) -> Result<(), RuntimeError> {
+    // ATINIT
+    // (used by C++)
+    if let Ok(func) = instance.exports.get_function("globalCtors") {
+        func.call(store, &[])?;
+    }
+
+    if let Ok(func) = instance
+        .exports
+        .get_function("___emscripten_environ_constructor")
+    {
+        func.call(store, &[])?;
+    }
+    Ok(())
+}
+
+/// Looks for variations of the main function (usually
+/// `["_main", "main"])`, then returns a reference to
+/// the name of the first found function. Useful for
+/// determining whether a module is executable.
+///
+/// Returns `ExportError` if none of the `main_func_names`
+/// were found.
+pub fn emscripten_get_main_func_name<'a>(
+    instance: &Instance,
+    main_func_names: &[&'a str],
+) -> Result<&'a str, ExportError> {
+    let mut last_err = None;
+
+    for func_name in main_func_names.iter() {
+        match instance.exports.get::<Function>(func_name) {
+            Ok(_) => {
+                return Ok(func_name);
+            }
+            Err(e) => {
+                last_err = Some(e);
+            }
+        }
+    }
+
+    match last_err {
+        None => Err(ExportError::Missing(format!("{main_func_names:?}"))),
+        Some(e) => Err(e),
+    }
+}
+
+/// Call the main function in emscripten, assumes that the emscripten state is
+/// set up.
+///
+/// If you don't want to set it up yourself, consider using [`run_emscripten_instance`].
+pub fn emscripten_call_main(
+    instance: &mut Instance,
+    function_name: &str,
+    mut env: FunctionEnvMut<EmEnv>,
+    path: &str,
+    args: &[&str],
+) -> Result<(), RuntimeError> {
+    let main_func = instance
+        .exports
+        .get::<Function>(function_name)
+        .map_err(|e| RuntimeError::new(e.to_string()))?;
+    let num_params = main_func.ty(&env).params().len();
+    match num_params {
+        2 => {
+            let mut new_args = vec![path];
+            new_args.extend(args);
+            let (argc, argv) = store_module_arguments(&mut env, new_args);
+            let func: &Function = instance
+                .exports
+                .get(function_name)
+                .map_err(|e| RuntimeError::new(e.to_string()))?;
+            func.call(
+                &mut env,
+                &[Value::I32(argc as i32), Value::I32(argv as i32)],
+            )?;
+        }
+        0 => {
+            let func: &Function = instance
+                .exports
+                .get(function_name)
+                .map_err(|e| RuntimeError::new(e.to_string()))?;
+            func.call(&mut env, &[])?;
+        }
+        _ => {
+            todo!("Update error type to be able to express this");
+            /*return Err(RuntimeError:: CallError::Resolve(ResolveError::ExportWrongType {
+                name: "main".to_string(),
+            }))*/
+        }
+    };
+
+    Ok(())
+}
+
+/// Top level function to execute emscripten
+pub fn run_emscripten_instance(
+    instance: &mut Instance,
+    mut env: FunctionEnvMut<EmEnv>,
+    globals: &mut EmscriptenGlobals,
+    path: &str,
+    args: Vec<&str>,
+    entrypoint: Option<String>,
+) -> Result<(), RuntimeError> {
+    env.data_mut().set_memory(globals.memory.clone());
+
+    // get emscripten export
+    let mut emfuncs = EmscriptenFunctions::new();
+    if let Ok(func) = instance.exports.get_typed_function(&env, "malloc") {
+        emfuncs.malloc = Some(func);
+    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_malloc") {
+        emfuncs.malloc = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "free") {
+        emfuncs.free = Some(func);
+    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_free") {
+        emfuncs.free = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "memalign") {
+        emfuncs.memalign = Some(func);
+    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_memalign") {
+        emfuncs.memalign = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "memset") {
+        emfuncs.memset = Some(func);
+    } else if let Ok(func) = instance.exports.get_typed_function(&env, "_memset") {
+        emfuncs.memset = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "stackAlloc") {
+        emfuncs.stack_alloc = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_i") {
+        emfuncs.dyn_call_i = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_ii") {
+        emfuncs.dyn_call_ii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iii") {
+        emfuncs.dyn_call_iii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiii") {
+        emfuncs.dyn_call_iiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iifi") {
+        emfuncs.dyn_call_iifi = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_v") {
+        emfuncs.dyn_call_v = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vi") {
+        emfuncs.dyn_call_vi = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vii") {
+        emfuncs.dyn_call_vii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viii") {
+        emfuncs.dyn_call_viii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiii") {
+        emfuncs.dyn_call_viiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_dii") {
+        emfuncs.dyn_call_dii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_diiii") {
+        emfuncs.dyn_call_diiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiii") {
+        emfuncs.dyn_call_iiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiiii") {
+        emfuncs.dyn_call_iiiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiiiiii") {
+        emfuncs.dyn_call_iiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_iiiiiiii")
+    {
+        emfuncs.dyn_call_iiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_iiiiiiiii")
+    {
+        emfuncs.dyn_call_iiiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_iiiiiiiiii")
+    {
+        emfuncs.dyn_call_iiiiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_iiiiiiiiiii")
+    {
+        emfuncs.dyn_call_iiiiiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vd") {
+        emfuncs.dyn_call_vd = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiiii") {
+        emfuncs.dyn_call_viiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiiiii") {
+        emfuncs.dyn_call_viiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiiiiii")
+    {
+        emfuncs.dyn_call_viiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiiiiiii")
+    {
+        emfuncs.dyn_call_viiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiiiiiiii")
+    {
+        emfuncs.dyn_call_viiiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiiiiiiiii")
+    {
+        emfuncs.dyn_call_viiiiiiiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iij") {
+        emfuncs.dyn_call_iij = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iji") {
+        emfuncs.dyn_call_iji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiji") {
+        emfuncs.dyn_call_iiji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_iiijj") {
+        emfuncs.dyn_call_iiijj = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_j") {
+        emfuncs.dyn_call_j = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_ji") {
+        emfuncs.dyn_call_ji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jii") {
+        emfuncs.dyn_call_jii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jij") {
+        emfuncs.dyn_call_jij = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_jjj") {
+        emfuncs.dyn_call_jjj = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiij") {
+        emfuncs.dyn_call_viiij = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiijiiii")
+    {
+        emfuncs.dyn_call_viiijiiii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viiijiiiiii")
+    {
+        emfuncs.dyn_call_viiijiiiiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viij") {
+        emfuncs.dyn_call_viij = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viiji") {
+        emfuncs.dyn_call_viiji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viijiii") {
+        emfuncs.dyn_call_viijiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viijj") {
+        emfuncs.dyn_call_viijj = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vj") {
+        emfuncs.dyn_call_vj = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vjji") {
+        emfuncs.dyn_call_vjji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vij") {
+        emfuncs.dyn_call_vij = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viji") {
+        emfuncs.dyn_call_viji = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vijiii") {
+        emfuncs.dyn_call_vijiii = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vijj") {
+        emfuncs.dyn_call_vijj = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viid") {
+        emfuncs.dyn_call_viid = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_vidd") {
+        emfuncs.dyn_call_vidd = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "dynCall_viidii") {
+        emfuncs.dyn_call_viidii = Some(func);
+    }
+    if let Ok(func) = instance
+        .exports
+        .get_typed_function(&env, "dynCall_viidddddddd")
+    {
+        emfuncs.dyn_call_viidddddddd = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "stackSave") {
+        emfuncs.stack_save = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "stackRestore") {
+        emfuncs.stack_restore = Some(func);
+    }
+    if let Ok(func) = instance.exports.get_typed_function(&env, "setThrew") {
+        emfuncs.set_threw = Some(func);
+    }
+    env.data().set_functions(emfuncs);
+
+    set_up_emscripten(&mut env, instance)?;
+
+    let main_func_names = ["_main", "main"];
+    if let Some(ep) = entrypoint.as_ref() {
+        debug!("Running entry point: {}", ep);
+        emscripten_call_main(instance, ep, env, path, &args)?;
+    } else if let Ok(name) = emscripten_get_main_func_name(instance, &main_func_names) {
+        emscripten_call_main(instance, name, env, path, &args)?;
+    } else {
+        return Err(RuntimeError::new(format!(
+            "No main function found (searched: {main_func_names:?}) and no entrypoint specified"
+        )));
+    }
+
+    // TODO atexit for emscripten
+    // println!("{:?}", data);
+    Ok(())
+}
+
+fn store_module_arguments(env: &mut FunctionEnvMut<EmEnv>, args: Vec<&str>) -> (u32, u32) {
+    let argc = args.len() + 1;
+
+    let mut args_slice = vec![0; argc];
+    for (slot, arg) in args_slice[0..argc].iter_mut().zip(args.iter()) {
+        *slot = unsafe { allocate_cstr_on_stack(&mut env.as_mut(), arg).0 };
+    }
+
+    let (argv_offset, argv_slice): (_, &mut [u32]) =
+        unsafe { allocate_on_stack(&mut env.as_mut(), ((argc) * 4) as u32) };
+    assert!(!argv_slice.is_empty());
+    for (slot, arg) in argv_slice[0..argc].iter_mut().zip(args_slice.iter()) {
+        *slot = *arg
+    }
+    argv_slice[argc] = 0;
+
+    (argc as u32 - 1, argv_offset)
+}
+
+pub fn emscripten_set_up_memory(
+    store: &impl AsStoreRef,
+    env: &FunctionEnv<EmEnv>,
+    memory: &Memory,
+    globals: &EmscriptenGlobalsData,
+) -> Result<(), String> {
+    env.as_ref(store).set_memory(memory.clone());
+    let memory = memory.view(store);
+    let dynamictop_ptr = WasmPtr::<i32>::new(globals.dynamictop_ptr).deref(&memory);
+    let dynamic_base = globals.dynamic_base;
+
+    if dynamictop_ptr.offset() >= memory.data_size() {
+        return Err("dynamictop_ptr beyond memory len".to_string());
+    }
+    dynamictop_ptr.write(dynamic_base as i32).unwrap();
+    Ok(())
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EmscriptenGlobalsData {
+    abort: u64,
+    // Env namespace
+    stacktop: u32,
+    stack_max: u32,
+    dynamictop_ptr: u32,
+    dynamic_base: u32,
+    memory_base: u32,
+    table_base: u32,
+    temp_double_ptr: u32,
+    use_old_abort_on_cannot_grow_memory: bool,
+}
+
+pub struct EmscriptenGlobals {
+    // The emscripten data
+    pub data: EmscriptenGlobalsData,
+    // The emscripten memory
+    pub memory: Memory,
+    pub table: Table,
+    pub memory_min: Pages,
+    pub memory_max: Option<Pages>,
+    pub null_function_names: Vec<String>,
+}
+
+impl EmscriptenGlobals {
+    pub fn new(
+        mut store: &mut impl AsStoreMut,
+        env: &FunctionEnv<EmEnv>,
+        module: &Module, /*, static_bump: u32 */
+    ) -> Result<Self, String> {
+        let mut use_old_abort_on_cannot_grow_memory = false;
+        for import in module.imports().functions() {
+            if import.name() == "abortOnCannotGrowMemory" && import.module() == "env" {
+                if import.ty() == &*OLD_ABORT_ON_CANNOT_GROW_MEMORY_SIG {
+                    use_old_abort_on_cannot_grow_memory = true;
+                }
+                break;
+            }
+        }
+
+        let (table_min, table_max) = get_emscripten_table_size(module)?;
+        let (memory_min, memory_max, shared) = get_emscripten_memory_size(module)?;
+
+        // Memory initialization
+        let memory_type = MemoryType::new(memory_min, memory_max, shared);
+        let memory = Memory::new(&mut store, memory_type).unwrap();
+
+        let table_type = TableType {
+            ty: ValType::FuncRef,
+            minimum: table_min,
+            maximum: table_max,
+        };
+        let table = Table::new(&mut store, table_type, Value::FuncRef(None)).unwrap();
+
+        let data = {
+            let static_bump = STATIC_BUMP;
+
+            let mut static_top = STATIC_BASE + static_bump;
+
+            let memory_base = STATIC_BASE;
+            let table_base = 0;
+
+            let temp_double_ptr = static_top;
+            static_top += 16;
+
+            let (dynamic_base, dynamictop_ptr) =
+                get_emscripten_metadata(module)?.unwrap_or_else(|| {
+                    let dynamictop_ptr = static_alloc(&mut static_top, 4);
+                    (
+                        align_memory(align_memory(static_top) + TOTAL_STACK),
+                        dynamictop_ptr,
+                    )
+                });
+
+            let stacktop = align_memory(static_top);
+            let stack_max = stacktop + TOTAL_STACK;
+
+            EmscriptenGlobalsData {
+                abort: 0,
+                stacktop,
+                stack_max,
+                dynamictop_ptr,
+                dynamic_base,
+                memory_base,
+                table_base,
+                temp_double_ptr,
+                use_old_abort_on_cannot_grow_memory,
+            }
+        };
+
+        emscripten_set_up_memory(store, env, &memory, &data)?;
+
+        let mut null_function_names = vec![];
+        for import in module.imports().functions() {
+            if import.module() == "env"
+                && (import.name().starts_with("nullFunction_")
+                    || import.name().starts_with("nullFunc_"))
+            {
+                null_function_names.push(import.name().to_string())
+            }
+        }
+
+        Ok(Self {
+            data,
+            memory,
+            table,
+            memory_min,
+            memory_max,
+            null_function_names,
+        })
+    }
+}
+
+pub fn generate_emscripten_env(
+    mut store: &mut impl AsStoreMut,
+    env: &FunctionEnv<EmEnv>,
+    globals: &mut EmscriptenGlobals,
+) -> Imports {
+    let abort_on_cannot_grow_memory_export = if globals.data.use_old_abort_on_cannot_grow_memory {
+        Function::new_typed_with_env(
+            &mut store,
+            env,
+            crate::memory::abort_on_cannot_grow_memory_old,
+        )
+    } else {
+        Function::new_typed_with_env(&mut store, env, crate::memory::abort_on_cannot_grow_memory)
+    };
+
+    let mut env_ns: Exports = namespace! {
+        "memory" => globals.memory.clone(),
+        "table" => globals.table.clone(),
+
+        // Globals
+        "STACKTOP" => Global::new(&mut store, Value::I32(globals.data.stacktop as i32)),
+        "STACK_MAX" => Global::new(&mut store, Value::I32(globals.data.stack_max as i32)),
+        "DYNAMICTOP_PTR" => Global::new(&mut store, Value::I32(globals.data.dynamictop_ptr as i32)),
+        "fb" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
+        "tableBase" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
+        "__table_base" => Global::new(&mut store, Value::I32(globals.data.table_base as i32)),
+        "ABORT" => Global::new(&mut store, Value::I32(globals.data.abort as i32)),
+        "gb" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
+        "memoryBase" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
+        "__memory_base" => Global::new(&mut store, Value::I32(globals.data.memory_base as i32)),
+        "tempDoublePtr" => Global::new(&mut store, Value::I32(globals.data.temp_double_ptr as i32)),
+
+        // inet
+        "_inet_addr" => Function::new_typed_with_env(&mut store, env, crate::inet::addr),
+
+        // IO
+        "printf" => Function::new_typed_with_env(&mut store, env, crate::io::printf),
+        "putchar" => Function::new_typed_with_env(&mut store, env, crate::io::putchar),
+        "___lock" => Function::new_typed_with_env(&mut store, env, crate::lock::___lock),
+        "___unlock" => Function::new_typed_with_env(&mut store, env, crate::lock::___unlock),
+        "___wait" => Function::new_typed_with_env(&mut store, env, crate::lock::___wait),
+        "_flock" => Function::new_typed_with_env(&mut store, env, crate::lock::_flock),
+        "_chroot" => Function::new_typed_with_env(&mut store, env, crate::io::chroot),
+        "_getprotobyname" => Function::new_typed_with_env(&mut store, env, crate::io::getprotobyname),
+        "_getprotobynumber" => Function::new_typed_with_env(&mut store, env, crate::io::getprotobynumber),
+        "_getpwuid" => Function::new_typed_with_env(&mut store, env, crate::io::getpwuid),
+        "_sigdelset" => Function::new_typed_with_env(&mut store, env, crate::io::sigdelset),
+        "_sigfillset" => Function::new_typed_with_env(&mut store, env, crate::io::sigfillset),
+        "_tzset" => Function::new_typed_with_env(&mut store, env, crate::io::tzset),
+        "_strptime" => Function::new_typed_with_env(&mut store, env, crate::io::strptime),
+
+        // exec
+        "_execvp" => Function::new_typed_with_env(&mut store, env, crate::exec::execvp),
+        "_execl" => Function::new_typed_with_env(&mut store, env, crate::exec::execl),
+        "_execle" => Function::new_typed_with_env(&mut store, env, crate::exec::execle),
+
+        // exit
+        "__exit" => Function::new_typed_with_env(&mut store, env, crate::exit::exit),
+
+        // Env
+        "___assert_fail" => Function::new_typed_with_env(&mut store, env, crate::env::___assert_fail),
+        "_getenv" => Function::new_typed_with_env(&mut store, env, crate::env::_getenv),
+        "_setenv" => Function::new_typed_with_env(&mut store, env, crate::env::_setenv),
+        "_putenv" => Function::new_typed_with_env(&mut store, env, crate::env::_putenv),
+        "_unsetenv" => Function::new_typed_with_env(&mut store, env, crate::env::_unsetenv),
+        "_getpwnam" => Function::new_typed_with_env(&mut store, env, crate::env::_getpwnam),
+        "_getgrnam" => Function::new_typed_with_env(&mut store, env, crate::env::_getgrnam),
+        "___buildEnvironment" => Function::new_typed_with_env(&mut store, env, crate::env::___build_environment),
+        "___setErrNo" => Function::new_typed_with_env(&mut store, env, crate::errno::___seterrno),
+        "_getpagesize" => Function::new_typed_with_env(&mut store, env, crate::env::_getpagesize),
+        "_sysconf" => Function::new_typed_with_env(&mut store, env, crate::env::_sysconf),
+        "_getaddrinfo" => Function::new_typed_with_env(&mut store, env, crate::env::_getaddrinfo),
+        "_times" => Function::new_typed_with_env(&mut store, env, crate::env::_times),
+        "_pathconf" => Function::new_typed_with_env(&mut store, env, crate::env::_pathconf),
+        "_fpathconf" => Function::new_typed_with_env(&mut store, env, crate::env::_fpathconf),
+
+        // Syscalls
+        "___syscall1" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall1),
+        "___syscall3" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall3),
+        "___syscall4" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall4),
+        "___syscall5" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall5),
+        "___syscall6" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall6),
+        "___syscall9" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall9),
+        "___syscall10" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall10),
+        "___syscall12" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall12),
+        "___syscall14" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall14),
+        "___syscall15" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall15),
+        "___syscall20" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall20),
+        "___syscall21" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall21),
+        "___syscall25" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall25),
+        "___syscall29" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall29),
+        "___syscall32" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall32),
+        "___syscall33" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall33),
+        "___syscall34" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall34),
+        "___syscall36" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall36),
+        "___syscall39" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall39),
+        "___syscall38" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall38),
+        "___syscall40" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall40),
+        "___syscall41" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall41),
+        "___syscall42" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall42),
+        "___syscall51" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall51),
+        "___syscall52" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall52),
+        "___syscall53" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall53),
+        "___syscall54" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall54),
+        "___syscall57" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall57),
+        "___syscall60" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall60),
+        "___syscall63" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall63),
+        "___syscall64" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall64),
+        "___syscall66" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall66),
+        "___syscall75" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall75),
+        "___syscall77" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall77),
+        "___syscall83" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall83),
+        "___syscall85" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall85),
+        "___syscall91" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall91),
+        "___syscall94" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall94),
+        "___syscall96" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall96),
+        "___syscall97" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall97),
+        "___syscall102" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall102),
+        "___syscall110" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall110),
+        "___syscall114" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall114),
+        "___syscall118" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall118),
+        "___syscall121" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall121),
+        "___syscall122" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall122),
+        "___syscall125" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall125),
+        "___syscall132" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall132),
+        "___syscall133" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall133),
+        "___syscall140" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall140),
+        "___syscall142" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall142),
+        "___syscall144" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall144),
+        "___syscall145" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall145),
+        "___syscall146" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall146),
+        "___syscall147" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall147),
+        "___syscall148" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall148),
+        "___syscall150" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall150),
+        "___syscall151" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall151),
+        "___syscall152" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall152),
+        "___syscall153" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall153),
+        "___syscall163" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall163),
+        "___syscall168" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall168),
+        "___syscall180" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall180),
+        "___syscall181" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall181),
+        "___syscall183" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall183),
+        "___syscall191" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall191),
+        "___syscall192" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall192),
+        "___syscall193" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall193),
+        "___syscall194" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall194),
+        "___syscall195" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall195),
+        "___syscall196" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall196),
+        "___syscall197" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall197),
+        "___syscall198" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall198),
+        "___syscall199" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall199),
+        "___syscall200" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall200),
+        "___syscall201" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall201),
+        "___syscall202" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall202),
+        "___syscall205" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall205),
+        "___syscall207" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall207),
+        "___syscall209" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall209),
+        "___syscall211" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall211),
+        "___syscall212" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall212),
+        "___syscall218" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall218),
+        "___syscall219" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall219),
+        "___syscall220" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall220),
+        "___syscall221" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall221),
+        "___syscall268" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall268),
+        "___syscall269" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall269),
+        "___syscall272" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall272),
+        "___syscall295" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall295),
+        "___syscall296" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall296),
+        "___syscall297" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall297),
+        "___syscall298" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall298),
+        "___syscall300" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall300),
+        "___syscall301" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall301),
+        "___syscall302" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall302),
+        "___syscall303" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall303),
+        "___syscall304" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall304),
+        "___syscall305" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall305),
+        "___syscall306" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall306),
+        "___syscall307" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall307),
+        "___syscall308" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall308),
+        "___syscall320" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall320),
+        "___syscall324" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall324),
+        "___syscall330" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall330),
+        "___syscall331" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall331),
+        "___syscall333" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall333),
+        "___syscall334" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall334),
+        "___syscall337" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall337),
+        "___syscall340" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall340),
+        "___syscall345" => Function::new_typed_with_env(&mut store, env, crate::syscalls::___syscall345),
+
+        // Process
+        "abort" => Function::new_typed_with_env(&mut store, env, crate::process::em_abort),
+        "_abort" => Function::new_typed_with_env(&mut store, env, crate::process::_abort),
+        "_prctl" => Function::new_typed_with_env(&mut store, env, crate::process::_prctl),
+        "abortStackOverflow" => Function::new_typed_with_env(&mut store, env, crate::process::abort_stack_overflow),
+        "_llvm_trap" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_trap),
+        "_fork" => Function::new_typed_with_env(&mut store, env, crate::process::_fork),
+        "_exit" => Function::new_typed_with_env(&mut store, env, crate::process::_exit),
+        "_system" => Function::new_typed_with_env(&mut store, env, crate::process::_system),
+        "_popen" => Function::new_typed_with_env(&mut store, env, crate::process::_popen),
+        "_endgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_endgrent),
+        "_execve" => Function::new_typed_with_env(&mut store, env, crate::process::_execve),
+        "_kill" => Function::new_typed_with_env(&mut store, env, crate::process::_kill),
+        "_llvm_stackrestore" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_stackrestore),
+        "_llvm_stacksave" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_stacksave),
+        "_llvm_eh_typeid_for" => Function::new_typed_with_env(&mut store, env, crate::process::_llvm_eh_typeid_for),
+        "_raise" => Function::new_typed_with_env(&mut store, env, crate::process::_raise),
+        "_sem_init" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_init),
+        "_sem_destroy" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_destroy),
+        "_sem_post" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_post),
+        "_sem_wait" => Function::new_typed_with_env(&mut store, env, crate::process::_sem_wait),
+        "_getgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_getgrent),
+        "_sched_yield" => Function::new_typed_with_env(&mut store, env, crate::process::_sched_yield),
+        "_setgrent" => Function::new_typed_with_env(&mut store, env, crate::process::_setgrent),
+        "_setgroups" => Function::new_typed_with_env(&mut store, env, crate::process::_setgroups),
+        "_setitimer" => Function::new_typed_with_env(&mut store, env, crate::process::_setitimer),
+        "_usleep" => Function::new_typed_with_env(&mut store, env, crate::process::_usleep),
+        "_nanosleep" => Function::new_typed_with_env(&mut store, env, crate::process::_nanosleep),
+        "_utime" => Function::new_typed_with_env(&mut store, env, crate::process::_utime),
+        "_utimes" => Function::new_typed_with_env(&mut store, env, crate::process::_utimes),
+        "_wait" => Function::new_typed_with_env(&mut store, env, crate::process::_wait),
+        "_wait3" => Function::new_typed_with_env(&mut store, env, crate::process::_wait3),
+        "_wait4" => Function::new_typed_with_env(&mut store, env, crate::process::_wait4),
+        "_waitid" => Function::new_typed_with_env(&mut store, env, crate::process::_waitid),
+        "_waitpid" => Function::new_typed_with_env(&mut store, env, crate::process::_waitpid),
+
+        // Emscripten
+        "_emscripten_asm_const_i" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::asm_const_i),
+        "_emscripten_exit_with_live_runtime" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::exit_with_live_runtime),
+
+        // Signal
+        "_sigemptyset" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigemptyset),
+        "_sigaddset" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigaddset),
+        "_sigprocmask" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigprocmask),
+        "_sigaction" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigaction),
+        "_signal" => Function::new_typed_with_env(&mut store, env, crate::signal::_signal),
+        "_sigsuspend" => Function::new_typed_with_env(&mut store, env, crate::signal::_sigsuspend),
+
+        // Memory
+        "abortOnCannotGrowMemory" => abort_on_cannot_grow_memory_export,
+        "_emscripten_memcpy_big" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_memcpy_big),
+        "_emscripten_get_heap_size" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_get_heap_size),
+        "_emscripten_resize_heap" => Function::new_typed_with_env(&mut store, env, crate::memory::_emscripten_resize_heap),
+        "enlargeMemory" => Function::new_typed_with_env(&mut store, env, crate::memory::enlarge_memory),
+        "segfault" => Function::new_typed_with_env(&mut store, env, crate::memory::segfault),
+        "alignfault" => Function::new_typed_with_env(&mut store, env, crate::memory::alignfault),
+        "ftfault" => Function::new_typed_with_env(&mut store, env, crate::memory::ftfault),
+        "getTotalMemory" => Function::new_typed_with_env(&mut store, env, crate::memory::get_total_memory),
+        "_sbrk" => Function::new_typed_with_env(&mut store, env, crate::memory::sbrk),
+        "___map_file" => Function::new_typed_with_env(&mut store, env, crate::memory::___map_file),
+
+        // Exception
+        "___cxa_allocate_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_allocate_exception),
+        "___cxa_current_primary_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_current_primary_exception),
+        "___cxa_decrement_exception_refcount" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_decrement_exception_refcount),
+        "___cxa_increment_exception_refcount" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_increment_exception_refcount),
+        "___cxa_rethrow_primary_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_rethrow_primary_exception),
+        "___cxa_throw" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_throw),
+        "___cxa_begin_catch" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_begin_catch),
+        "___cxa_end_catch" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_end_catch),
+        "___cxa_uncaught_exception" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_uncaught_exception),
+        "___cxa_pure_virtual" => Function::new_typed_with_env(&mut store, env, crate::exception::___cxa_pure_virtual),
+
+        // Time
+        "_gettimeofday" => Function::new_typed_with_env(&mut store, env, crate::time::_gettimeofday),
+        "_clock_getres" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_getres),
+        "_clock_gettime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_gettime),
+        "_clock_settime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_settime),
+        "___clock_gettime" => Function::new_typed_with_env(&mut store, env, crate::time::_clock_gettime),
+        "_clock" => Function::new_typed_with_env(&mut store, env, crate::time::_clock),
+        "_difftime" => Function::new_typed_with_env(&mut store, env, crate::time::_difftime),
+        "_asctime" => Function::new_typed_with_env(&mut store, env, crate::time::_asctime),
+        "_asctime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_asctime_r),
+        "_localtime" => Function::new_typed_with_env(&mut store, env, crate::time::_localtime),
+        "_time" => Function::new_typed_with_env(&mut store, env, crate::time::_time),
+        "_timegm" => Function::new_typed_with_env(&mut store, env, crate::time::_timegm),
+        "_strftime" => Function::new_typed_with_env(&mut store, env, crate::time::_strftime),
+        "_strftime_l" => Function::new_typed_with_env(&mut store, env, crate::time::_strftime_l),
+        "_localtime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_localtime_r),
+        "_gmtime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_gmtime_r),
+        "_ctime" => Function::new_typed_with_env(&mut store, env, crate::time::_ctime),
+        "_ctime_r" => Function::new_typed_with_env(&mut store, env, crate::time::_ctime_r),
+        "_mktime" => Function::new_typed_with_env(&mut store, env, crate::time::_mktime),
+        "_gmtime" => Function::new_typed_with_env(&mut store, env, crate::time::_gmtime),
+
+        // Math
+        "sqrt" => Function::new_typed_with_env(&mut store, env, crate::math::sqrt),
+        "floor" => Function::new_typed_with_env(&mut store, env, crate::math::floor),
+        "fabs" => Function::new_typed_with_env(&mut store, env, crate::math::fabs),
+        "f64-rem" => Function::new_typed_with_env(&mut store, env, crate::math::f64_rem),
+        "_llvm_copysign_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_copysign_f32),
+        "_llvm_copysign_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_copysign_f64),
+        "_llvm_log10_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log10_f64),
+        "_llvm_log2_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log2_f64),
+        "_llvm_log10_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log10_f32),
+        "_llvm_log2_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_log2_f64),
+        "_llvm_sin_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_sin_f64),
+        "_llvm_cos_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_cos_f64),
+        "_llvm_exp2_f32" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_exp2_f32),
+        "_llvm_exp2_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_exp2_f64),
+        "_llvm_trunc_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_trunc_f64),
+        "_llvm_fma_f64" => Function::new_typed_with_env(&mut store, env, crate::math::_llvm_fma_f64),
+        "_emscripten_random" => Function::new_typed_with_env(&mut store, env, crate::math::_emscripten_random),
+
+        // Jump
+        "__setjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::__setjmp),
+        "__longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::__longjmp),
+        "_longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::_longjmp),
+        "_emscripten_longjmp" => Function::new_typed_with_env(&mut store, env, crate::jmp::_longjmp),
+
+        // Bitwise
+        "_llvm_bswap_i64" => Function::new_typed_with_env(&mut store, env, crate::bitwise::_llvm_bswap_i64),
+
+        // libc
+        "_execv" => Function::new_typed_with_env(&mut store, env, crate::libc::execv),
+        "_endpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::endpwent),
+        "_fexecve" => Function::new_typed_with_env(&mut store, env, crate::libc::fexecve),
+        "_fpathconf" => Function::new_typed_with_env(&mut store, env, crate::libc::fpathconf),
+        "_getitimer" => Function::new_typed_with_env(&mut store, env, crate::libc::getitimer),
+        "_getpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::getpwent),
+        "_killpg" => Function::new_typed_with_env(&mut store, env, crate::libc::killpg),
+        "_pathconf" => Function::new_typed_with_env(&mut store, env, crate::libc::pathconf),
+        "_siginterrupt" => Function::new_typed_with_env(&mut store, env, crate::signal::_siginterrupt),
+        "_setpwent" => Function::new_typed_with_env(&mut store, env, crate::libc::setpwent),
+        "_sigismember" => Function::new_typed_with_env(&mut store, env, crate::libc::sigismember),
+        "_sigpending" => Function::new_typed_with_env(&mut store, env, crate::libc::sigpending),
+        "___libc_current_sigrtmax" => Function::new_typed_with_env(&mut store, env, crate::libc::current_sigrtmax),
+        "___libc_current_sigrtmin" => Function::new_typed_with_env(&mut store, env, crate::libc::current_sigrtmin),
+
+        // Linking
+        "_dlclose" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlclose),
+        "_dlerror" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlerror),
+        "_dlopen" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlopen),
+        "_dlsym" => Function::new_typed_with_env(&mut store, env, crate::linking::_dlsym),
+
+        // wasm32-unknown-emscripten
+        "_alarm" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_alarm),
+        "_atexit" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_atexit),
+        "setTempRet0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::setTempRet0),
+        "getTempRet0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::getTempRet0),
+        "invoke_i" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_i),
+        "invoke_ii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_ii),
+        "invoke_iii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iii),
+        "invoke_iiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiii),
+        "invoke_iifi" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iifi),
+        "invoke_v" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_v),
+        "invoke_vi" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vi),
+        "invoke_vj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vj),
+        "invoke_vjji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vjji),
+        "invoke_vii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vii),
+        "invoke_viii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viii),
+        "invoke_viiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiii),
+        "__Unwind_Backtrace" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_Backtrace),
+        "__Unwind_FindEnclosingFunction" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_FindEnclosingFunction),
+        "__Unwind_GetIPInfo" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::__Unwind_GetIPInfo),
+        "___cxa_find_matching_catch_2" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_find_matching_catch_2),
+        "___cxa_find_matching_catch_3" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_find_matching_catch_3),
+        "___cxa_free_exception" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___cxa_free_exception),
+        "___resumeException" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___resumeException),
+        "_dladdr" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_dladdr),
+        "_pthread_attr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_destroy),
+        "_pthread_attr_getstack" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_getstack),
+        "_pthread_attr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_init),
+        "_pthread_attr_setstacksize" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_attr_setstacksize),
+        "_pthread_cleanup_pop" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cleanup_pop),
+        "_pthread_cleanup_push" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cleanup_push),
+        "_pthread_cond_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_destroy),
+        "_pthread_cond_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_init),
+        "_pthread_cond_signal" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_signal),
+        "_pthread_cond_timedwait" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_timedwait),
+        "_pthread_cond_wait" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_cond_wait),
+        "_pthread_condattr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_destroy),
+        "_pthread_condattr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_init),
+        "_pthread_condattr_setclock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_condattr_setclock),
+        "_pthread_create" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_create),
+        "_pthread_detach" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_detach),
+        "_pthread_equal" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_equal),
+        "_pthread_exit" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_exit),
+        "_pthread_self" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_self),
+        "_pthread_getattr_np" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_getattr_np),
+        "_pthread_getspecific" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_getspecific),
+        "_pthread_join" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_join),
+        "_pthread_key_create" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_key_create),
+        "_pthread_mutex_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutex_destroy),
+        "_pthread_mutex_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutex_init),
+        "_pthread_mutexattr_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_destroy),
+        "_pthread_mutexattr_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_init),
+        "_pthread_mutexattr_settype" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_mutexattr_settype),
+        "_pthread_once" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_once),
+        "_pthread_rwlock_destroy" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_destroy),
+        "_pthread_rwlock_init" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_init),
+        "_pthread_rwlock_rdlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_rdlock),
+        "_pthread_rwlock_unlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_unlock),
+        "_pthread_rwlock_wrlock" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_rwlock_wrlock),
+        "_pthread_setcancelstate" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_setcancelstate),
+        "_pthread_setspecific" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_setspecific),
+        "_pthread_sigmask" => Function::new_typed_with_env(&mut store, env, crate::pthread::_pthread_sigmask),
+        "___gxx_personality_v0" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::___gxx_personality_v0),
+        "_gai_strerror" => Function::new_typed_with_env(&mut store, env, crate::env::_gai_strerror),
+        "_getdtablesize" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getdtablesize),
+        "_gethostbyaddr" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyaddr),
+        "_gethostbyname" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyname),
+        "_gethostbyname_r" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_gethostbyname_r),
+        "_getloadavg" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getloadavg),
+        "_getnameinfo" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::_getnameinfo),
+        "invoke_dii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_dii),
+        "invoke_diiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_diiii),
+        "invoke_iiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiii),
+        "invoke_iiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiii),
+        "invoke_iiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiii),
+        "invoke_iiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiii),
+        "invoke_iiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiii),
+        "invoke_iiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiiii),
+        "invoke_iiiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiiiiiiiiii),
+        "invoke_vd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vd),
+        "invoke_viiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiii),
+        "invoke_viiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiii),
+        "invoke_viiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiii),
+        "invoke_viiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiii),
+        "invoke_viiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiii),
+        "invoke_viiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiii),
+        "invoke_viiiiiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiiiiiiiii),
+        "invoke_iij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iij),
+        "invoke_iji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iji),
+        "invoke_iiji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiji),
+        "invoke_iiijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_iiijj),
+        "invoke_j" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_j),
+        "invoke_ji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_ji),
+        "invoke_jii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jii),
+        "invoke_jij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jij),
+        "invoke_jjj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_jjj),
+        "invoke_viiij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiij),
+        "invoke_viiijiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiijiiii),
+        "invoke_viiijiiiiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiijiiiiii),
+        "invoke_viij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viij),
+        "invoke_viiji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viiji),
+        "invoke_viijiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viijiii),
+        "invoke_viijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viijj),
+        "invoke_vij" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vij),
+        "invoke_viji" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viji),
+        "invoke_vijiii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vijiii),
+        "invoke_vijj" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vijj),
+        "invoke_vidd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_vidd),
+        "invoke_viid" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viid),
+        "invoke_viidii" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viidii),
+        "invoke_viidddddddd" => Function::new_typed_with_env(&mut store, env, crate::emscripten_target::invoke_viidddddddd),
+
+        // ucontext
+        "_getcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_getcontext),
+        "_makecontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_makecontext),
+        "_setcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_setcontext),
+        "_swapcontext" => Function::new_typed_with_env(&mut store, env, crate::ucontext::_swapcontext),
+
+        // unistd
+        "_confstr" => Function::new_typed_with_env(&mut store, env, crate::unistd::confstr),
+    };
+
+    // Compatibility with newer versions of Emscripten
+    let mut to_insert: Vec<(String, _)> = vec![];
+    for (k, v) in env_ns.iter() {
+        if let Some(k) = k.strip_prefix('_') {
+            if !env_ns.contains(k) {
+                to_insert.push((k.to_string(), v.clone()));
+            }
+        }
+    }
+
+    for (k, v) in to_insert {
+        env_ns.insert(k, v);
+    }
+
+    for null_function_name in globals.null_function_names.iter() {
+        env_ns.insert(
+            null_function_name.as_str(),
+            Function::new_typed_with_env(&mut store, env, nullfunc),
+        );
+    }
+
+    let import_object: Imports = imports! {
+        "env" => env_ns,
+        "global" => {
+          "NaN" => Global::new(&mut store, Value::F64(f64::NAN)),
+          "Infinity" => Global::new(&mut store, Value::F64(f64::INFINITY)),
+        },
+        "global.Math" => {
+            "pow" => Function::new_typed_with_env(&mut store, env, crate::math::pow),
+            "exp" => Function::new_typed_with_env(&mut store, env, crate::math::exp),
+            "log" => Function::new_typed_with_env(&mut store, env, crate::math::log),
+        },
+        "asm2wasm" => {
+            "f64-rem" => Function::new_typed_with_env(&mut store, env, crate::math::f64_rem),
+            "f64-to-int" => Function::new_typed_with_env(&mut store, env, crate::math::f64_to_int),
+        },
+    };
+
+    import_object
+}
+
+pub fn nullfunc(env: FunctionEnvMut<EmEnv>, _x: u32) {
+    use crate::process::abort_with_message;
+    debug!("emscripten::nullfunc_i {}", _x);
+    abort_with_message(
+        env,
+        "Invalid function pointer. Perhaps this is an invalid value \
+    (e.g. caused by calling a virtual method on a NULL pointer)? Or calling a function with an \
+    incorrect type, which will fail? (it is worth building your source files with -Werror (\
+    warnings are errors), as warnings can indicate undefined behavior which can cause this)",
+    );
+}
+
+/// The current version of this crate
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/libc.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/libc.rs
new file mode 100644
index 0000000..99414c2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/libc.rs
@@ -0,0 +1,78 @@
+extern crate libc;
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+#[cfg(unix)]
+use std::convert::TryInto;
+
+pub fn current_sigrtmax(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::current_sigrtmax");
+    0
+}
+
+pub fn current_sigrtmin(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::current_sigrtmin");
+    0
+}
+
+pub fn endpwent(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::endpwent");
+}
+
+pub fn execv(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::execv");
+    0
+}
+
+pub fn fexecve(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
+    debug!("emscripten::fexecve");
+    0
+}
+
+pub fn fpathconf(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::fpathconf");
+    0
+}
+
+pub fn getitimer(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::getitimer");
+    0
+}
+
+pub fn getpwent(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::getpwent");
+    0
+}
+
+pub fn killpg(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::killpg");
+    0
+}
+
+#[cfg(unix)]
+pub fn pathconf(ctx: FunctionEnvMut<EmEnv>, path_ptr: i32, name: i32) -> i32 {
+    debug!("emscripten::pathconf");
+    let memory = ctx.data().memory(0);
+    let path = emscripten_memory_pointer!(memory.view(&ctx), path_ptr) as *const i8;
+    unsafe { libc::pathconf(path as *const _, name).try_into().unwrap() }
+}
+
+#[cfg(not(unix))]
+pub fn pathconf(_ctx: FunctionEnvMut<EmEnv>, _path_ptr: i32, _name: i32) -> i32 {
+    debug!("emscripten::pathconf");
+    0
+}
+
+pub fn setpwent(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::setpwent");
+}
+
+pub fn sigismember(_ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::sigismember");
+    0
+}
+
+pub fn sigpending(_ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    debug!("emscripten::sigpending");
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/linking.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/linking.rs
new file mode 100644
index 0000000..83e39c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/linking.rs
@@ -0,0 +1,28 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+// TODO: Need to implement.
+
+/// emscripten: dlopen(filename: *const c_char, flag: c_int) -> *mut c_void
+pub fn _dlopen(mut _ctx: FunctionEnvMut<EmEnv>, _filename: u32, _flag: u32) -> i32 {
+    debug!("emscripten::_dlopen");
+    -1
+}
+
+/// emscripten: dlclose(handle: *mut c_void) -> c_int
+pub fn _dlclose(mut _ctx: FunctionEnvMut<EmEnv>, _filename: u32) -> i32 {
+    debug!("emscripten::_dlclose");
+    -1
+}
+
+/// emscripten: dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void
+pub fn _dlsym(mut _ctx: FunctionEnvMut<EmEnv>, _filepath: u32, _symbol: u32) -> i32 {
+    debug!("emscripten::_dlsym");
+    -1
+}
+
+/// emscripten: dlerror() -> *mut c_char
+pub fn _dlerror(mut _ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::_dlerror");
+    -1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lock.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lock.rs
new file mode 100644
index 0000000..ce905d3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/lock.rs
@@ -0,0 +1,29 @@
+use crate::EmEnv;
+use libc::c_int;
+use wasmer::FunctionEnvMut;
+
+// NOTE: Not implemented by Emscripten
+pub fn ___lock(mut _ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
+    debug!("emscripten::___lock {}", _what);
+}
+
+// NOTE: Not implemented by Emscripten
+pub fn ___unlock(mut _ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
+    debug!("emscripten::___unlock {}", _what);
+}
+
+// NOTE: Not implemented by Emscripten
+pub fn ___wait(
+    mut _ctx: FunctionEnvMut<EmEnv>,
+    _which: u32,
+    _varargs: u32,
+    _three: u32,
+    _four: u32,
+) {
+    debug!("emscripten::___wait");
+}
+
+pub fn _flock(mut _ctx: FunctionEnvMut<EmEnv>, _fd: u32, _op: u32) -> u32 {
+    debug!("emscripten::_flock");
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/macros.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/macros.rs
new file mode 100644
index 0000000..4cd2550
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/macros.rs
@@ -0,0 +1,5 @@
+macro_rules! emscripten_memory_pointer {
+    ($memory:expr, $pointer:expr) => {
+        $memory.data_ptr().wrapping_add($pointer as usize)
+    };
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/math.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/math.rs
new file mode 100644
index 0000000..1940b7e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/math.rs
@@ -0,0 +1,111 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn _llvm_copysign_f32(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
+    x.copysign(y)
+}
+
+pub fn _llvm_copysign_f64(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
+    x.copysign(y)
+}
+
+/// emscripten: _llvm_log10_f64
+pub fn _llvm_log10_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_log10_f64");
+    value.log10()
+}
+
+/// emscripten: _llvm_log2_f64
+pub fn _llvm_log2_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_log2_f64");
+    value.log2()
+}
+
+/// emscripten: _llvm_sin_f64
+pub fn _llvm_sin_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_sin_f64");
+    value.sin()
+}
+
+/// emscripten: _llvm_cos_f64
+pub fn _llvm_cos_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_cos_f64");
+    value.cos()
+}
+
+pub fn _llvm_log10_f32(mut _ctx: FunctionEnvMut<EmEnv>, _value: f64) -> f64 {
+    debug!("emscripten::_llvm_log10_f32");
+    -1.0
+}
+
+pub fn _llvm_log2_f32(mut _ctx: FunctionEnvMut<EmEnv>, _value: f64) -> f64 {
+    debug!("emscripten::_llvm_log10_f32");
+    -1.0
+}
+
+pub fn _llvm_exp2_f32(mut _ctx: FunctionEnvMut<EmEnv>, value: f32) -> f32 {
+    debug!("emscripten::_llvm_exp2_f32");
+    2f32.powf(value)
+}
+
+pub fn _llvm_exp2_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_exp2_f64");
+    2f64.powf(value)
+}
+
+pub fn _llvm_trunc_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    debug!("emscripten::_llvm_trunc_f64");
+    value.trunc()
+}
+
+pub fn _llvm_fma_f64(mut _ctx: FunctionEnvMut<EmEnv>, value: f64, a: f64, b: f64) -> f64 {
+    debug!("emscripten::_llvm_fma_f64");
+    value.mul_add(a, b)
+}
+
+pub fn _emscripten_random(mut _ctx: FunctionEnvMut<EmEnv>) -> f64 {
+    debug!("emscripten::_emscripten_random");
+    -1.0
+}
+
+// emscripten: asm2wasm.f64-rem
+pub fn f64_rem(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
+    debug!("emscripten::f64-rem");
+    x % y
+}
+
+// emscripten: global.Math pow
+pub fn pow(mut _ctx: FunctionEnvMut<EmEnv>, x: f64, y: f64) -> f64 {
+    x.powf(y)
+}
+
+// emscripten: global.Math exp
+pub fn exp(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    value.exp()
+}
+
+// emscripten: global.Math log
+pub fn log(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    value.ln()
+}
+
+// emscripten: global.Math sqrt
+pub fn sqrt(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    value.sqrt()
+}
+
+// emscripten: global.Math floor
+pub fn floor(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    value.floor()
+}
+
+// emscripten: global.Math fabs
+pub fn fabs(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> f64 {
+    value.abs()
+}
+
+// emscripten: asm2wasm.f64-to-int
+pub fn f64_to_int(mut _ctx: FunctionEnvMut<EmEnv>, value: f64) -> i32 {
+    debug!("emscripten::f64_to_int {}", value);
+    value as i32
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/memory.rs
new file mode 100644
index 0000000..2c905e3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/memory.rs
@@ -0,0 +1,188 @@
+use super::env::get_emscripten_data;
+use super::process::abort_with_message;
+use crate::EmEnv;
+use libc::{c_int, c_void, memcpy, size_t};
+// TODO: investigate max pages etc. probably in Wasm Common, maybe reexport
+use wasmer::{FunctionEnvMut, Pages, WasmPtr, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE};
+
+/// emscripten: _emscripten_memcpy_big
+pub fn _emscripten_memcpy_big(ctx: FunctionEnvMut<EmEnv>, dest: u32, src: u32, len: u32) -> u32 {
+    debug!(
+        "emscripten::_emscripten_memcpy_big {}, {}, {}",
+        dest, src, len
+    );
+    let memory = ctx.data().memory(0);
+    let dest_addr = emscripten_memory_pointer!(memory.view(&ctx), dest) as *mut c_void;
+    let src_addr = emscripten_memory_pointer!(memory.view(&ctx), src) as *mut c_void;
+    unsafe {
+        memcpy(dest_addr, src_addr, len as size_t);
+    }
+    dest
+}
+
+fn get_heap_size(ctx: &FunctionEnvMut<EmEnv>) -> u32 {
+    let memory = ctx.data().memory(0);
+    memory.view(&ctx).size().bytes().0 as u32
+}
+
+/// emscripten: _emscripten_get_heap_size
+pub fn _emscripten_get_heap_size(ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    trace!("emscripten::_emscripten_get_heap_size");
+    let result = get_heap_size(&ctx);
+    trace!("=> {}", result);
+
+    result
+}
+
+// From emscripten implementation
+fn align_up(mut val: usize, multiple: usize) -> usize {
+    if val % multiple > 0 {
+        val += multiple - val % multiple;
+    }
+    val
+}
+
+fn resize_heap(ctx: &mut FunctionEnvMut<EmEnv>, requested_size: u32) -> u32 {
+    debug!("emscripten::_emscripten_resize_heap {}", requested_size);
+    let memory = ctx.data().memory(0);
+    let current_memory_pages = memory.view(&ctx).size();
+    let current_memory = current_memory_pages.bytes().0 as u32;
+
+    // implementation from emscripten
+    let mut new_size = usize::max(
+        current_memory as usize,
+        WASM_MIN_PAGES as usize * WASM_PAGE_SIZE,
+    );
+    while new_size < requested_size as usize {
+        if new_size <= 0x2000_0000 {
+            new_size = align_up(new_size * 2, WASM_PAGE_SIZE);
+        } else {
+            new_size = usize::min(
+                align_up((3 * new_size + 0x8000_0000) / 4, WASM_PAGE_SIZE),
+                WASM_PAGE_SIZE * WASM_MAX_PAGES as usize,
+            );
+        }
+    }
+
+    let amount_to_grow = (new_size - current_memory as usize) / WASM_PAGE_SIZE;
+    if let Ok(_pages_allocated) = ctx
+        .data()
+        .memory(0)
+        .grow(&mut ctx.as_mut(), Pages(amount_to_grow as u32))
+    {
+        debug!("{} pages allocated", _pages_allocated.0);
+        1
+    } else {
+        0
+    }
+}
+
+/// emscripten: _emscripten_resize_heap
+/// Note: this function only allows growing the size of heap
+pub fn _emscripten_resize_heap(mut ctx: FunctionEnvMut<EmEnv>, requested_size: u32) -> u32 {
+    resize_heap(&mut ctx, requested_size)
+}
+
+/// emscripten: sbrk
+pub fn sbrk(mut ctx: FunctionEnvMut<EmEnv>, increment: i32) -> i32 {
+    debug!("emscripten::sbrk");
+    // let old_dynamic_top = 0;
+    // let new_dynamic_top = 0;
+    let top_ptr = get_emscripten_data(&ctx)
+        .as_ref()
+        .unwrap()
+        .globals
+        .dynamictop_ptr;
+
+    let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr);
+    let old_dynamic_top = {
+        let memory = ctx.data().memory(0);
+        let memory = memory.view(&ctx);
+        dynamictop_ptr.deref(&memory).read().unwrap()
+    };
+    let new_dynamic_top: i32 = old_dynamic_top + increment;
+    let total_memory = get_heap_size(&ctx) as i32;
+    debug!(
+        " => PTR {}, old: {}, new: {}, increment: {}, total: {}",
+        dynamictop_ptr.offset(),
+        old_dynamic_top,
+        new_dynamic_top,
+        increment,
+        total_memory
+    );
+    if increment > 0 && new_dynamic_top < old_dynamic_top || new_dynamic_top < 0 {
+        abort_on_cannot_grow_memory_old(ctx);
+        return -1;
+    }
+    if new_dynamic_top > total_memory {
+        let resized = resize_heap(&mut ctx, new_dynamic_top as u32);
+        if resized == 0 {
+            return -1;
+        }
+    }
+    // re-borrow the top ptr
+    let memory = ctx.data().memory(0);
+    let memory = memory.view(&ctx);
+    let dynamictop_ptr = WasmPtr::<i32>::new(top_ptr).deref(&memory);
+    dynamictop_ptr.write(new_dynamic_top).unwrap();
+    old_dynamic_top as _
+}
+
+/// emscripten: getTotalMemory
+pub fn get_total_memory(ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    debug!("emscripten::get_total_memory");
+    // instance.memories[0].current_pages()
+    // TODO: Fix implementation
+    let memory = ctx.data().memory(0);
+    memory.view(&ctx).size().bytes().0 as u32
+}
+
+/// emscripten: enlargeMemory
+pub fn enlarge_memory(_ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    debug!("emscripten::enlarge_memory");
+    // instance.memories[0].grow(100);
+    // TODO: Fix implementation
+    0
+}
+
+/// emscripten: abortOnCannotGrowMemory
+pub fn abort_on_cannot_grow_memory(ctx: FunctionEnvMut<EmEnv>, _requested_size: u32) -> u32 {
+    debug!(
+        "emscripten::abort_on_cannot_grow_memory {}",
+        _requested_size
+    );
+    abort_with_message(ctx, "Cannot enlarge memory arrays!");
+    0
+}
+
+/// emscripten: abortOnCannotGrowMemory
+pub fn abort_on_cannot_grow_memory_old(ctx: FunctionEnvMut<EmEnv>) -> u32 {
+    debug!("emscripten::abort_on_cannot_grow_memory");
+    abort_with_message(ctx, "Cannot enlarge memory arrays!");
+    0
+}
+
+/// emscripten: segfault
+pub fn segfault(ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::segfault");
+    abort_with_message(ctx, "segmentation fault");
+}
+
+/// emscripten: alignfault
+pub fn alignfault(ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::alignfault");
+    abort_with_message(ctx, "alignment fault");
+}
+
+/// emscripten: ftfault
+pub fn ftfault(ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::ftfault");
+    abort_with_message(ctx, "Function table mask error");
+}
+
+/// emscripten: ___map_file
+pub fn ___map_file(_ctx: FunctionEnvMut<EmEnv>, _one: u32, _two: u32) -> c_int {
+    debug!("emscripten::___map_file");
+    // NOTE: TODO: Em returns -1 here as well. May need to implement properly
+    -1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/process.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/process.rs
new file mode 100644
index 0000000..9156f2f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/process.rs
@@ -0,0 +1,203 @@
+use libc::{abort, c_int, exit, EAGAIN};
+
+#[cfg(not(target_os = "windows"))]
+type PidT = libc::pid_t;
+#[cfg(target_os = "windows")]
+type PidT = c_int;
+
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn abort_with_message(ctx: FunctionEnvMut<EmEnv>, message: &str) {
+    debug!("emscripten::abort_with_message");
+    println!("{}", message);
+    _abort(ctx);
+}
+
+/// The name of this call is `abort` but we want to avoid conflicts with libc::abort
+pub fn em_abort(ctx: FunctionEnvMut<EmEnv>, arg: u32) {
+    debug!("emscripten::abort");
+    eprintln!("Program aborted with value {}", arg);
+    _abort(ctx);
+}
+
+pub fn _abort(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::_abort");
+    unsafe {
+        abort();
+    }
+}
+
+pub fn _prctl(ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    debug!("emscripten::_prctl");
+    abort_with_message(ctx, "missing function: prctl");
+    -1
+}
+
+pub fn _fork(_ctx: FunctionEnvMut<EmEnv>) -> PidT {
+    debug!("emscripten::_fork");
+    // unsafe {
+    //     fork()
+    // }
+    -1
+}
+
+pub fn _endgrent(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::_endgrent");
+}
+
+pub fn _execve(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_execve");
+    -1
+}
+
+#[allow(unreachable_code)]
+pub fn _exit(_ctx: FunctionEnvMut<EmEnv>, status: c_int) {
+    // -> !
+    debug!("emscripten::_exit {}", status);
+    unsafe { exit(status) }
+}
+
+pub fn _kill(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_kill");
+    -1
+}
+
+pub fn _sched_yield(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::_sched_yield");
+    -1
+}
+
+pub fn _llvm_stacksave(_ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    debug!("emscripten::_llvm_stacksave");
+    -1
+}
+
+pub fn _llvm_stackrestore(_ctx: FunctionEnvMut<EmEnv>, _one: i32) {
+    debug!("emscripten::_llvm_stackrestore");
+}
+
+pub fn _raise(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_raise");
+    -1
+}
+
+pub fn _sem_init(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_sem_init: {}, {}, {}", _one, _two, _three);
+    0
+}
+
+pub fn _sem_destroy(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_sem_destroy");
+    0
+}
+
+pub fn _sem_post(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_sem_post");
+    -1
+}
+
+pub fn _sem_wait(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_sem_post");
+    -1
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _getgrent(_ctx: FunctionEnvMut<EmEnv>) -> c_int {
+    debug!("emscripten::_getgrent");
+    -1
+}
+
+pub fn _setgrent(_ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::_setgrent");
+}
+
+pub fn _setgroups(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_setgroups");
+    -1
+}
+
+pub fn _setitimer(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_setitimer");
+    -1
+}
+
+pub fn _usleep(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_usleep");
+    -1
+}
+
+pub fn _nanosleep(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_nanosleep");
+    -1
+}
+
+pub fn _utime(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_utime");
+    -1
+}
+
+pub fn _utimes(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_utimes");
+    -1
+}
+
+pub fn _wait(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_wait");
+    -1
+}
+
+pub fn _wait3(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_wait3");
+    -1
+}
+
+pub fn _wait4(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32, _d: i32) -> i32 {
+    debug!("emscripten::_wait4");
+    -1
+}
+
+pub fn _waitid(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32, _d: i32) -> i32 {
+    debug!("emscripten::_waitid");
+    -1
+}
+
+pub fn _waitpid(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_waitpid");
+    -1
+}
+
+pub fn abort_stack_overflow(ctx: FunctionEnvMut<EmEnv>, _what: c_int) {
+    debug!("emscripten::abort_stack_overflow");
+    // TODO: Message incomplete. Need to finish em runtime data first
+    abort_with_message(
+        ctx,
+        "Stack overflow! Attempted to allocate some bytes on the stack",
+    );
+}
+
+pub fn _llvm_trap(ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::_llvm_trap");
+    abort_with_message(ctx, "abort!");
+}
+
+pub fn _llvm_eh_typeid_for(_ctx: FunctionEnvMut<EmEnv>, _type_info_addr: u32) -> i32 {
+    debug!("emscripten::_llvm_eh_typeid_for");
+    -1
+}
+
+pub fn _system(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> c_int {
+    debug!("emscripten::_system");
+    // TODO: May need to change this Em impl to a working version
+    eprintln!("Can't call external programs");
+    EAGAIN
+}
+
+pub fn _popen(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> c_int {
+    debug!("emscripten::_popen");
+    // TODO: May need to change this Em impl to a working version
+    eprintln!("Missing function: popen");
+    unsafe {
+        abort();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/pthread.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/pthread.rs
new file mode 100644
index 0000000..322a1b0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/pthread.rs
@@ -0,0 +1,198 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn _pthread_attr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_attr_destroy");
+    0
+}
+
+pub fn _pthread_attr_getstack(
+    mut _ctx: FunctionEnvMut<EmEnv>,
+    _stackaddr: i32,
+    _stacksize: i32,
+    _other: i32,
+) -> i32 {
+    trace!(
+        "emscripten::_pthread_attr_getstack({}, {}, {})",
+        _stackaddr,
+        _stacksize,
+        _other
+    );
+    // TODO: Translate from Emscripten
+    // HEAP32[stackaddr >> 2] = STACK_BASE;
+    // HEAP32[stacksize >> 2] = TOTAL_STACK;
+    0
+}
+
+pub fn _pthread_attr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_attr_init({})", _a);
+    0
+}
+
+pub fn _pthread_attr_setstacksize(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_attr_setstacksize");
+    0
+}
+
+pub fn _pthread_cleanup_pop(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) {
+    trace!("emscripten::_pthread_cleanup_pop");
+}
+
+pub fn _pthread_cleanup_push(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) {
+    trace!("emscripten::_pthread_cleanup_push");
+}
+
+pub fn _pthread_cond_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_cond_destroy");
+    0
+}
+
+pub fn _pthread_cond_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_cond_init");
+    0
+}
+
+pub fn _pthread_cond_signal(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_cond_signal");
+    0
+}
+
+pub fn _pthread_cond_timedwait(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
+    trace!("emscripten::_pthread_cond_timedwait");
+    0
+}
+
+pub fn _pthread_cond_wait(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_cond_wait");
+    0
+}
+
+pub fn _pthread_condattr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_condattr_destroy");
+    0
+}
+
+pub fn _pthread_condattr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_condattr_init");
+    0
+}
+
+pub fn _pthread_condattr_setclock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_condattr_setclock");
+    0
+}
+
+pub fn _pthread_create(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32, _d: i32) -> i32 {
+    trace!("emscripten::_pthread_create");
+    // 11 seems to mean "no"
+    11
+}
+
+pub fn _pthread_detach(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_detach");
+    0
+}
+
+pub fn _pthread_equal(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_equal");
+    0
+}
+
+pub fn _pthread_exit(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) {
+    trace!("emscripten::_pthread_exit");
+}
+
+pub fn _pthread_getattr_np(mut _ctx: FunctionEnvMut<EmEnv>, _thread: i32, _attr: i32) -> i32 {
+    trace!("emscripten::_pthread_getattr_np({}, {})", _thread, _attr);
+    0
+}
+
+pub fn _pthread_getspecific(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_getspecific");
+    0
+}
+
+pub fn _pthread_join(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_join");
+    0
+}
+
+pub fn _pthread_self(mut _ctx: FunctionEnvMut<EmEnv>) -> i32 {
+    trace!("emscripten::_pthread_self");
+    0
+}
+
+pub fn _pthread_key_create(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_key_create");
+    0
+}
+
+pub fn _pthread_mutex_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_mutex_destroy");
+    0
+}
+
+pub fn _pthread_mutex_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_mutex_init");
+    0
+}
+
+pub fn _pthread_mutexattr_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_mutexattr_destroy");
+    0
+}
+
+pub fn _pthread_mutexattr_init(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_mutexattr_init");
+    0
+}
+
+pub fn _pthread_mutexattr_settype(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_mutexattr_settype");
+    0
+}
+
+pub fn _pthread_once(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_once");
+    0
+}
+
+pub fn _pthread_rwlock_destroy(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32) -> i32 {
+    trace!("emscripten::_pthread_rwlock_destroy({})", _rwlock);
+    0
+}
+
+pub fn _pthread_rwlock_init(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32, _attr: i32) -> i32 {
+    trace!("emscripten::_pthread_rwlock_init({}, {})", _rwlock, _attr);
+    0
+}
+
+pub fn _pthread_rwlock_rdlock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_rwlock_rdlock");
+    0
+}
+
+pub fn _pthread_rwlock_unlock(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32) -> i32 {
+    trace!("emscripten::_pthread_rwlock_unlock");
+    0
+}
+
+pub fn _pthread_rwlock_wrlock(mut _ctx: FunctionEnvMut<EmEnv>, _rwlock: i32) -> i32 {
+    trace!("emscripten::_pthread_rwlock_wrlock({})", _rwlock);
+    0
+}
+
+pub fn _pthread_setcancelstate(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_setcancelstate");
+    0
+}
+
+pub fn _pthread_setspecific(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32) -> i32 {
+    trace!("emscripten::_pthread_setspecific");
+    0
+}
+
+pub fn _pthread_sigmask(mut _ctx: FunctionEnvMut<EmEnv>, _a: i32, _b: i32, _c: i32) -> i32 {
+    trace!("emscripten::_pthread_sigmask");
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/signal.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/signal.rs
new file mode 100644
index 0000000..52386cd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/signal.rs
@@ -0,0 +1,50 @@
+// use super::varargs::VarArgs;
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _sigemptyset(ctx: FunctionEnvMut<EmEnv>, set: u32) -> i32 {
+    debug!("emscripten::_sigemptyset");
+    let memory = ctx.data().memory(0);
+    let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
+    unsafe {
+        *set_addr = 0;
+    }
+    0
+}
+
+pub fn _sigaction(_ctx: FunctionEnvMut<EmEnv>, _signum: u32, _act: u32, _oldact: u32) -> i32 {
+    debug!("emscripten::_sigaction {}, {}, {}", _signum, _act, _oldact);
+    0
+}
+
+pub fn _siginterrupt(_ctx: FunctionEnvMut<EmEnv>, _a: u32, _b: u32) -> i32 {
+    debug!("emscripten::_siginterrupt {}, {}", _a, _b);
+    0
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _sigaddset(ctx: FunctionEnvMut<EmEnv>, set: u32, signum: u32) -> i32 {
+    debug!("emscripten::_sigaddset {}, {}", set, signum);
+    let memory = ctx.data().memory(0);
+    let set_addr = emscripten_memory_pointer!(memory.view(&ctx), set) as *mut u32;
+    unsafe {
+        *set_addr |= 1 << (signum - 1);
+    }
+    0
+}
+
+pub fn _sigsuspend(_ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_sigsuspend");
+    -1
+}
+
+pub fn _sigprocmask(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32, _three: i32) -> i32 {
+    debug!("emscripten::_sigprocmask");
+    0
+}
+
+pub fn _signal(_ctx: FunctionEnvMut<EmEnv>, _sig: u32, _two: i32) -> i32 {
+    debug!("emscripten::_signal ({})", _sig);
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/storage.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/storage.rs
new file mode 100644
index 0000000..394b15c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/storage.rs
@@ -0,0 +1,12 @@
+// use crate::webassembly::Memory;
+
+pub fn align_memory(ptr: u32) -> u32 {
+    (ptr + 15) & !15
+}
+
+pub fn static_alloc(static_top: &mut u32, size: u32) -> u32 {
+    let old_static_top = *static_top;
+    // NOTE: The `4294967280` is a u32 conversion of -16 as gotten from emscripten.
+    *static_top = (*static_top + size + 15) & 4294967280;
+    old_static_top
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/mod.rs
new file mode 100644
index 0000000..42ce7b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/mod.rs
@@ -0,0 +1,744 @@
+#[cfg(unix)]
+mod unix;
+
+#[cfg(windows)]
+mod windows;
+
+#[cfg(unix)]
+pub use self::unix::*;
+
+#[cfg(windows)]
+pub use self::windows::*;
+
+use crate::{
+    utils::{copy_stat_into_wasm, get_cstr_path, get_current_directory},
+    EmEnv,
+};
+
+use super::varargs::VarArgs;
+use byteorder::{ByteOrder, LittleEndian};
+/// NOTE: TODO: These syscalls only support wasm_32 for now because they assume offsets are u32
+/// Syscall list: https://www.cs.utexas.edu/~bismith/test/syscalls/syscalls32.html
+use libc::{
+    c_int,
+    c_void,
+    chdir,
+    // setsockopt, getppid
+    close,
+    dup2,
+    exit,
+    fstat,
+    getpid,
+    // readlink,
+    // iovec,
+    lseek,
+    //    open,
+    read,
+    rename,
+    // sockaddr_in,
+    // readv,
+    rmdir,
+    // writev,
+    stat,
+    write,
+    // ENOTTY,
+};
+
+use super::env;
+#[allow(unused_imports)]
+use std::io::Error;
+use std::slice;
+use wasmer::{FunctionEnvMut, WasmPtr};
+
+/// exit
+pub fn ___syscall1(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) {
+    debug!("emscripten::___syscall1 (exit) {}", _which);
+    let status: i32 = varargs.get(&ctx);
+    unsafe {
+        exit(status);
+    }
+}
+
+/// read
+pub fn ___syscall3(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    // -> ssize_t
+    debug!("emscripten::___syscall3 (read) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let buf: u32 = varargs.get(&ctx);
+    let count: i32 = varargs.get(&ctx);
+    debug!("=> fd: {}, buf_offset: {}, count: {}", fd, buf, count);
+    let memory = ctx.data().memory(0);
+    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_void;
+    let ret = unsafe { read(fd, buf_addr, count as _) };
+    debug!("=> ret: {}", ret);
+    ret as _
+}
+
+/// write
+pub fn ___syscall4(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall4 (write) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let buf: i32 = varargs.get(&ctx);
+    let count: i32 = varargs.get(&ctx);
+    debug!("=> fd: {}, buf: {}, count: {}", fd, buf, count);
+    let memory = ctx.data().memory(0);
+    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *const c_void;
+    unsafe { write(fd, buf_addr, count as _) as i32 }
+}
+
+/// close
+pub fn ___syscall6(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall6 (close) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    debug!("fd: {}", fd);
+    unsafe { close(fd) }
+}
+
+// chdir
+pub fn ___syscall12(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall12 (chdir) {}", _which);
+    let path_ptr = varargs.get_str(&ctx);
+    let real_path_owned = get_cstr_path(ctx, path_ptr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path_ptr
+    };
+    let ret = unsafe { chdir(real_path) };
+    debug!(
+        "=> path: {:?}, ret: {}",
+        unsafe { std::ffi::CStr::from_ptr(real_path) },
+        ret
+    );
+    ret
+}
+
+pub fn ___syscall10(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall10");
+    -1
+}
+
+pub fn ___syscall14(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall14");
+    -1
+}
+
+pub fn ___syscall15(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall15");
+    -1
+}
+
+// getpid
+pub fn ___syscall20(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall20 (getpid)");
+    unsafe { getpid() }
+}
+
+pub fn ___syscall21(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall21");
+    -1
+}
+
+pub fn ___syscall25(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall25");
+    -1
+}
+
+pub fn ___syscall29(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall29");
+    -1
+}
+
+pub fn ___syscall32(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall32");
+    -1
+}
+
+pub fn ___syscall33(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall33");
+    -1
+}
+
+pub fn ___syscall36(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall36");
+    -1
+}
+
+// rename
+pub fn ___syscall38(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall38 (rename)");
+    let old_path = varargs.get_str(&ctx);
+    let new_path = varargs.get_str(&ctx);
+    let real_old_path_owned = get_cstr_path(ctx.as_mut(), old_path as *const _);
+    let real_old_path = if let Some(ref rp) = real_old_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        old_path
+    };
+    let real_new_path_owned = get_cstr_path(ctx, new_path as *const _);
+    let real_new_path = if let Some(ref rp) = real_new_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        new_path
+    };
+    let result = unsafe { rename(real_old_path, real_new_path) };
+    debug!(
+        "=> old_path: {}, new_path: {}, result: {}",
+        unsafe { std::ffi::CStr::from_ptr(real_old_path).to_str().unwrap() },
+        unsafe { std::ffi::CStr::from_ptr(real_new_path).to_str().unwrap() },
+        result
+    );
+    result
+}
+
+// rmdir
+pub fn ___syscall40(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall40 (rmdir)");
+    let pathname_addr = varargs.get_str(&ctx);
+    let real_path_owned = get_cstr_path(ctx, pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    unsafe { rmdir(real_path) }
+}
+
+// pipe
+pub fn ___syscall42(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall42 (pipe)");
+    // offset to a file descriptor, which contains a read end and write end, 2 integers
+    let fd_offset: u32 = varargs.get(&ctx);
+
+    let memory = ctx.data().memory(0);
+    let emscripten_memory = memory.view(&ctx);
+
+    // convert the file descriptor into a vec with two slots
+    let mut fd_vec: [c_int; 2] = WasmPtr::<[c_int; 2]>::new(fd_offset)
+        .deref(&emscripten_memory)
+        .read()
+        .unwrap();
+
+    // get it as a mutable pointer
+    let fd_ptr = fd_vec.as_mut_ptr();
+
+    // call pipe and store the pointers in this array
+    #[cfg(target_os = "windows")]
+    let result: c_int = unsafe { libc::pipe(fd_ptr, 2048, 0) };
+    #[cfg(not(target_os = "windows"))]
+    let result: c_int = unsafe { libc::pipe(fd_ptr) };
+    if result == -1 {
+        debug!("=> os error: {}", Error::last_os_error());
+    }
+    result
+}
+
+pub fn ___syscall51(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall51");
+    -1
+}
+
+pub fn ___syscall52(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall52");
+    -1
+}
+
+pub fn ___syscall53(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall53");
+    -1
+}
+
+pub fn ___syscall60(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall60");
+    -1
+}
+
+// dup2
+pub fn ___syscall63(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall63 (dup2) {}", _which);
+
+    let src: i32 = varargs.get(&ctx);
+    let dst: i32 = varargs.get(&ctx);
+
+    unsafe { dup2(src, dst) }
+}
+
+// getppid
+pub fn ___syscall64(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall64 (getppid)");
+    unsafe { getpid() }
+}
+
+pub fn ___syscall66(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall66");
+    -1
+}
+
+pub fn ___syscall75(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall75");
+    -1
+}
+
+pub fn ___syscall91(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall91 - stub");
+    0
+}
+
+pub fn ___syscall96(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall96");
+    -1
+}
+
+pub fn ___syscall97(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall97");
+    -1
+}
+
+pub fn ___syscall110(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall110");
+    -1
+}
+
+pub fn ___syscall121(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall121");
+    -1
+}
+
+pub fn ___syscall125(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall125");
+    -1
+}
+
+pub fn ___syscall133(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall133");
+    -1
+}
+
+pub fn ___syscall144(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall144");
+    -1
+}
+
+pub fn ___syscall147(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall147");
+    -1
+}
+
+pub fn ___syscall150(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall150");
+    -1
+}
+
+pub fn ___syscall151(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall151");
+    -1
+}
+
+pub fn ___syscall152(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall152");
+    -1
+}
+
+pub fn ___syscall153(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall153");
+    -1
+}
+
+pub fn ___syscall163(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall163");
+    -1
+}
+
+// getcwd
+pub fn ___syscall183(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall183");
+    let buf_offset: WasmPtr<libc::c_char> = varargs.get(&ctx);
+    let _size: c_int = varargs.get(&ctx);
+    let path = get_current_directory(ctx.as_mut());
+    let path_string = path.unwrap().display().to_string();
+    let len = path_string.len();
+    let memory = ctx.data().memory(0);
+    let memory = memory.view(&ctx);
+
+    let buf_writer = buf_offset.slice(&memory, len as u32 + 1).unwrap();
+    for (i, byte) in path_string.bytes().enumerate() {
+        buf_writer.index(i as u64).write(byte as _).unwrap();
+    }
+    buf_writer.index(len as u64).write(0).unwrap();
+    buf_offset.offset() as i32
+}
+
+// mmap2
+pub fn ___syscall192(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall192 (mmap2) {}", _which);
+    let _addr: i32 = varargs.get(&ctx);
+    let len: u32 = varargs.get(&ctx);
+    let _prot: i32 = varargs.get(&ctx);
+    let _flags: i32 = varargs.get(&ctx);
+    let fd: i32 = varargs.get(&ctx);
+    let _off: i32 = varargs.get(&ctx);
+    debug!(
+        "=> addr: {}, len: {}, prot: {}, flags: {}, fd: {}, off: {}",
+        _addr, len, _prot, _flags, fd, _off
+    );
+
+    if fd == -1 {
+        let ptr = env::call_memalign(&mut ctx, 16384, len);
+        if ptr == 0 {
+            // ENOMEM
+            return -12;
+        }
+        let memory = ctx.data().memory(0);
+        let real_ptr = emscripten_memory_pointer!(memory.view(&ctx), ptr) as *const u8;
+        env::call_memset(&mut ctx, ptr, 0, len);
+        for i in 0..(len as usize) {
+            unsafe {
+                assert_eq!(*real_ptr.add(i), 0);
+            }
+        }
+        debug!("=> ptr: {}", ptr);
+        ptr as i32
+    } else {
+        // return ENODEV
+        -19
+    }
+}
+
+/// lseek
+pub fn ___syscall140(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    // -> c_int
+    debug!("emscripten::___syscall140 (lseek) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let _offset_high: u32 = varargs.get(&ctx); // We don't use the offset high as emscripten skips it
+    let offset_low: u32 = varargs.get(&ctx);
+    let result_ptr_value: WasmPtr<i64> = varargs.get(&ctx);
+    let whence: i32 = varargs.get(&ctx);
+    let offset = offset_low;
+    let ret = unsafe { lseek(fd, offset as _, whence) as i64 };
+    let memory = ctx.data().memory(0);
+    let memory = memory.view(&ctx);
+
+    let result_ptr = result_ptr_value.deref(&memory);
+    result_ptr.write(ret).unwrap();
+
+    debug!(
+        "=> fd: {}, offset: {}, result: {}, whence: {} = {}\nlast os error: {}",
+        fd,
+        offset,
+        ret,
+        whence,
+        0,
+        Error::last_os_error(),
+    );
+    0
+}
+
+/// readv
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall145(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
+    // -> ssize_t
+    debug!("emscripten::___syscall145 (readv) {}", _which);
+
+    let fd: i32 = varargs.get(&ctx);
+    let iov: i32 = varargs.get(&ctx);
+    let iovcnt: i32 = varargs.get(&ctx);
+
+    #[repr(C)]
+    struct GuestIovec {
+        iov_base: i32,
+        iov_len: i32,
+    }
+
+    debug!("=> fd: {}, iov: {}, iovcnt = {}", fd, iov, iovcnt);
+    let mut ret = 0;
+    unsafe {
+        for i in 0..iovcnt {
+            let memory = ctx.data().memory(0);
+            let guest_iov_addr =
+                emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
+            let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
+                as *mut c_void;
+            let iov_len = (*guest_iov_addr).iov_len as _;
+            // debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
+            let curr = read(fd, iov_base, iov_len);
+            if curr < 0 {
+                return -1;
+            }
+            ret += curr;
+        }
+        // debug!(" => ret: {}", ret);
+        ret as _
+    }
+}
+
+// writev
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall146(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    // -> ssize_t
+    debug!("emscripten::___syscall146 (writev) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let iov: i32 = varargs.get(&ctx);
+    let iovcnt: i32 = varargs.get(&ctx);
+
+    #[repr(C)]
+    struct GuestIovec {
+        iov_base: i32,
+        iov_len: i32,
+    }
+
+    debug!("=> fd: {}, iov: {}, iovcnt = {}", fd, iov, iovcnt);
+    let mut ret = 0;
+    for i in 0..iovcnt {
+        unsafe {
+            let memory = ctx.data().memory(0);
+            let guest_iov_addr =
+                emscripten_memory_pointer!(memory.view(&ctx), (iov + i * 8)) as *mut GuestIovec;
+            let iov_base = emscripten_memory_pointer!(memory.view(&ctx), (*guest_iov_addr).iov_base)
+                as *const c_void;
+            let iov_len = (*guest_iov_addr).iov_len as _;
+            // debug!("=> iov_addr: {:?}, {:?}", iov_base, iov_len);
+            let curr = write(fd, iov_base, iov_len);
+            debug!(
+                "=> iov_base: {}, iov_len: {}, curr = {}",
+                (*guest_iov_addr).iov_base,
+                iov_len,
+                curr
+            );
+            if curr < 0 {
+                debug!("=> os error: {}", Error::last_os_error());
+                return -1;
+            }
+            ret += curr;
+        }
+    }
+    debug!(" => ret: {}", ret);
+    ret as _
+}
+
+pub fn ___syscall191(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    let _resource: i32 = varargs.get(&ctx);
+    debug!(
+        "emscripten::___syscall191 - mostly stub, resource: {}",
+        _resource
+    );
+    let rlim_emptr: i32 = varargs.get(&ctx);
+    let memory = ctx.data().memory(0);
+    let rlim_ptr = emscripten_memory_pointer!(memory.view(&ctx), rlim_emptr) as *mut u8;
+    let rlim = unsafe { slice::from_raw_parts_mut(rlim_ptr, 16) };
+
+    // set all to RLIM_INIFINTY
+    LittleEndian::write_i64(&mut *rlim, -1);
+    LittleEndian::write_i64(&mut rlim[8..], -1);
+
+    0
+}
+
+pub fn ___syscall193(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall193");
+    -1
+}
+
+// stat64
+pub fn ___syscall195(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall195 (stat64) {}", _which);
+    let pathname_addr = varargs.get_str(&ctx);
+    let buf: u32 = varargs.get(&ctx);
+
+    let real_path_owned = get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+
+    unsafe {
+        let mut _stat: stat = std::mem::zeroed();
+        let ret = stat(real_path, &mut _stat);
+        debug!(
+            "=> pathname: {}, buf: {} = {}",
+            std::ffi::CStr::from_ptr(real_path).to_str().unwrap(),
+            buf,
+            ret
+        );
+        if ret != 0 {
+            debug!("=> os error: {}", Error::last_os_error());
+            return ret;
+        }
+        copy_stat_into_wasm(ctx, buf, &_stat);
+    }
+    0
+}
+
+// fstat64
+pub fn ___syscall197(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall197 (fstat64) {}", _which);
+
+    let fd: c_int = varargs.get(&ctx);
+    let buf: u32 = varargs.get(&ctx);
+
+    unsafe {
+        let mut stat = std::mem::zeroed();
+        let ret = fstat(fd, &mut stat);
+        debug!("=> fd: {}, buf: {} = {}", fd, buf, ret);
+        if ret != 0 {
+            debug!("=> os error: {}", Error::last_os_error());
+            return ret;
+        }
+        copy_stat_into_wasm(ctx, buf, &stat);
+    }
+    0
+}
+
+pub fn ___syscall209(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall209");
+    -1
+}
+
+pub fn ___syscall211(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall211");
+    -1
+}
+
+pub fn ___syscall218(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall218");
+    -1
+}
+
+pub fn ___syscall268(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall268");
+    -1
+}
+
+pub fn ___syscall269(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall269");
+    -1
+}
+
+pub fn ___syscall272(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall272");
+    -1
+}
+
+pub fn ___syscall295(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall295");
+    -1
+}
+
+pub fn ___syscall296(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall296");
+    -1
+}
+
+pub fn ___syscall297(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall297");
+    -1
+}
+
+pub fn ___syscall298(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall298");
+    -1
+}
+
+pub fn ___syscall300(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall300");
+    -1
+}
+
+pub fn ___syscall301(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall301");
+    -1
+}
+
+pub fn ___syscall302(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall302");
+    -1
+}
+
+pub fn ___syscall303(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall303");
+    -1
+}
+
+pub fn ___syscall304(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall304");
+    -1
+}
+
+pub fn ___syscall305(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall305");
+    -1
+}
+
+pub fn ___syscall306(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall306");
+    -1
+}
+
+pub fn ___syscall307(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall307");
+    -1
+}
+
+pub fn ___syscall308(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall308");
+    -1
+}
+
+// utimensat
+pub fn ___syscall320(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall320 (utimensat), {}", _which);
+    0
+}
+
+pub fn ___syscall331(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall331");
+    -1
+}
+
+pub fn ___syscall333(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall333");
+    -1
+}
+
+pub fn ___syscall334(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall334");
+    -1
+}
+
+pub fn ___syscall337(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall337");
+    -1
+}
+
+// prlimit64
+pub fn ___syscall340(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall340 (prlimit64), {}", _which);
+    // NOTE: Doesn't really matter. Wasm modules cannot exceed WASM_PAGE_SIZE anyway.
+    let _pid: i32 = varargs.get(&ctx);
+    let resource: i32 = varargs.get(&ctx);
+    let _new_limit: u32 = varargs.get(&ctx);
+    let old_limit: u32 = varargs.get(&ctx);
+
+    let val = match resource {
+        // RLIMIT_NOFILE
+        7 => 1024,
+        _ => -1, // RLIM_INFINITY
+    };
+
+    if old_limit != 0 {
+        // just report no limits
+        let memory = ctx.data().memory(0);
+        let buf_ptr = emscripten_memory_pointer!(memory.view(&ctx), old_limit) as *mut u8;
+        let buf = unsafe { slice::from_raw_parts_mut(buf_ptr, 16) };
+
+        LittleEndian::write_i64(&mut *buf, val);
+        LittleEndian::write_i64(&mut buf[8..], val);
+    }
+
+    0
+}
+
+pub fn ___syscall345(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall345");
+    -1
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/unix.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/unix.rs
new file mode 100644
index 0000000..74a9058
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/unix.rs
@@ -0,0 +1,1150 @@
+use crate::{varargs::VarArgs, LibcDirWrapper};
+#[cfg(target_vendor = "apple")]
+use libc::size_t;
+/// NOTE: TODO: These syscalls only support wasm_32 for now because they assume offsets are u32
+/// Syscall list: https://www.cs.utexas.edu/~bismith/test/syscalls/syscalls32.html
+use libc::{
+    accept,
+    access,
+    bind,
+    c_char,
+    c_int,
+    c_ulong,
+    c_void,
+    chown,
+    // fcntl, setsockopt, getppid
+    connect,
+    dup,
+    dup2,
+    fchmod,
+    fchown,
+    fcntl,
+    // ENOTTY,
+    fsync,
+    getegid,
+    geteuid,
+    getgid,
+    getgroups,
+    getpeername,
+    getpgid,
+    getrusage,
+    getsockname,
+    getsockopt,
+    getuid,
+    gid_t,
+    in_addr_t,
+    in_port_t,
+    ioctl,
+    lchown,
+    link,
+    // iovec,
+    listen,
+    mkdir,
+    mode_t,
+    msghdr,
+    nice,
+    off_t,
+    open,
+    pid_t,
+    pread,
+    pwrite,
+    readdir,
+    // readv,
+    recvfrom,
+    recvmsg,
+    // ENOTTY,
+    rusage,
+    sa_family_t,
+    // writev,
+    select,
+    sendmsg,
+    sendto,
+    setpgid,
+    setsockopt,
+    sockaddr,
+    socket,
+    socklen_t,
+    stat,
+    symlink,
+    uid_t,
+    uname,
+    utsname,
+    EINVAL,
+    // sockaddr_in,
+    FIOCLEX,
+    FIONBIO,
+    F_GETFD,
+    F_SETFD,
+    SOL_SOCKET,
+    TIOCGWINSZ,
+    TIOCSPGRP,
+    // TCGETS,
+    // TCSETSW,
+};
+use wasmer::{FunctionEnvMut, ValueType, WasmPtr};
+
+// They are not exposed in in Rust libc in macOS
+const TCGETS: u64 = 0x5401;
+const TCSETSW: u64 = 0x5403;
+
+// `libc` constants as provided by `emscripten`. Maybe move to own file?
+const WASM_FIONBIO: u32 = 0x5421;
+const WASM_FIOCLEX: u32 = 0x5451;
+const WASM_TIOCSPGRP: u32 = 0x5410;
+const WASM_TIOCGWINSZ: u32 = 0x5413;
+const WASM_TCGETS: u32 = 0x5401;
+const WASM_TCSETSW: u32 = 0x5403;
+
+// Based on @syrusakbary sugerence at
+// https://github.com/wasmerio/wasmer/pull/532#discussion_r300837800
+fn translate_ioctl(wasm_ioctl: u32) -> c_ulong {
+    match wasm_ioctl {
+        WASM_FIOCLEX => FIOCLEX as _,
+        WASM_TIOCGWINSZ => TIOCGWINSZ as _,
+        WASM_TIOCSPGRP => TIOCSPGRP as _,
+        WASM_FIONBIO => FIONBIO as _,
+        WASM_TCGETS => TCGETS as _,
+        WASM_TCSETSW => TCSETSW as _,
+        _otherwise => {
+            unimplemented!("The ioctl {} is not yet implemented", wasm_ioctl);
+        }
+    }
+}
+
+#[allow(unused_imports)]
+use std::ffi::CStr;
+
+use crate::env::EmSockAddr;
+use crate::utils::{self, get_cstr_path};
+use crate::EmEnv;
+#[allow(unused_imports)]
+use std::io::Error;
+use std::mem;
+
+// Linking to functions that are not provided by rust libc
+#[cfg(target_vendor = "apple")]
+#[link(name = "c")]
+extern "C" {
+    pub fn wait4(pid: pid_t, status: *mut c_int, options: c_int, rusage: *mut rusage) -> pid_t;
+    pub fn madvise(addr: *mut c_void, len: size_t, advice: c_int) -> c_int;
+    pub fn fdatasync(fd: c_int) -> c_int;
+    pub fn lstat64(path: *const libc::c_char, buf: *mut c_void) -> c_int;
+}
+
+// Linking to functions that are not provided by rust libc
+#[cfg(target_os = "freebsd")]
+#[link(name = "c")]
+extern "C" {
+    pub fn wait4(pid: pid_t, status: *mut c_int, options: c_int, rusage: *mut rusage) -> pid_t;
+    pub fn fdatasync(fd: c_int) -> c_int;
+    pub fn ftruncate(fd: c_int, length: i64) -> c_int;
+    pub fn lstat(path: *const libc::c_char, buf: *mut stat) -> c_int;
+}
+
+#[cfg(not(any(target_os = "freebsd", target_vendor = "apple", target_os = "android")))]
+use libc::fallocate;
+#[cfg(target_os = "freebsd")]
+use libc::madvise;
+#[cfg(not(any(target_os = "freebsd", target_vendor = "apple")))]
+use libc::{fdatasync, ftruncate64, lstat, madvise, wait4};
+
+// Another conditional constant for name resolution: Macos et iOS use
+// SO_NOSIGPIPE as a setsockopt flag to disable SIGPIPE emission on socket.
+// Other platforms do otherwise.
+#[cfg(target_vendor = "apple")]
+use libc::SO_NOSIGPIPE;
+#[cfg(not(target_vendor = "apple"))]
+const SO_NOSIGPIPE: c_int = 0;
+
+/// open
+pub fn ___syscall5(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall5 (open) {}", _which);
+    let pathname_addr = varargs.get_str(&ctx);
+    let flags: i32 = varargs.get(&ctx);
+    let mode: u32 = varargs.get(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx, pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    let _path_str = unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() };
+    let fd = unsafe { open(real_path, flags, mode) };
+    debug!(
+        "=> path: {}, flags: {}, mode: {} = fd: {}",
+        _path_str, flags, mode, fd,
+    );
+    if fd == -1 {
+        debug!("=> last os error: {}", Error::last_os_error(),);
+    }
+    fd
+}
+
+/// link
+pub fn ___syscall9(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall9 (link) {}", _which);
+
+    let oldname_ptr = varargs.get_str(&ctx);
+    let newname_ptr = varargs.get_str(&ctx);
+    let result = unsafe { link(oldname_ptr, newname_ptr) };
+    debug!(
+        "=> oldname: {}, newname: {}, result: {}",
+        unsafe { std::ffi::CStr::from_ptr(oldname_ptr).to_str().unwrap() },
+        unsafe { std::ffi::CStr::from_ptr(newname_ptr).to_str().unwrap() },
+        result,
+    );
+    result
+}
+
+/// getrusage
+pub fn ___syscall77(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall77 (getrusage) {}", _which);
+
+    let resource: c_int = varargs.get(&ctx);
+    let rusage_ptr: c_int = varargs.get(&ctx);
+    let memory = ctx.data().memory(0);
+    #[allow(clippy::cast_ptr_alignment)]
+    let rusage = emscripten_memory_pointer!(memory.view(&ctx), rusage_ptr) as *mut rusage;
+    assert_eq!(8, mem::align_of_val(&rusage));
+    unsafe { getrusage(resource, rusage) }
+}
+
+/// symlink
+pub fn ___syscall83(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall83 (symlink) {}", _which);
+
+    let path1 = varargs.get_str(&ctx);
+    let path2 = varargs.get_str(&ctx);
+    let real_path1_owned = utils::get_cstr_path(ctx.as_mut(), path1 as *const _);
+    let real_path1 = if let Some(ref rp) = real_path1_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path1
+    };
+    let real_path2_owned = utils::get_cstr_path(ctx, path2 as *const _);
+    let real_path2 = if let Some(ref rp) = real_path2_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path2
+    };
+    let result = unsafe { symlink(real_path1, real_path2) };
+    debug!(
+        "=> path1: {}, path2: {}, result: {}",
+        unsafe { std::ffi::CStr::from_ptr(real_path1).to_str().unwrap() },
+        unsafe { std::ffi::CStr::from_ptr(real_path2).to_str().unwrap() },
+        result,
+    );
+    result
+}
+
+/// readlink
+pub fn ___syscall85(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall85 (readlink)");
+    let pathname_addr = varargs.get_str(&ctx);
+    let buf = varargs.get_str(&ctx);
+    // let buf_addr: i32 = varargs.get(&ctx);
+    let buf_size: i32 = varargs.get(&ctx);
+    let real_path_owned = get_cstr_path(ctx, pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+
+    let ret = unsafe { libc::readlink(real_path, buf as _, buf_size as _) as i32 };
+    if ret == -1 {
+        debug!("readlink failed");
+        return ret;
+    }
+    debug!(
+        "=> path: {}, buf: {}, buf_size: {}, return: {} ",
+        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
+        unsafe { std::ffi::CStr::from_ptr(buf as _).to_str().unwrap() },
+        buf_size,
+        ret
+    );
+    ret
+}
+
+/// ftruncate64
+pub fn ___syscall194(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall194 (ftruncate64) {}", _which);
+    let _fd: c_int = varargs.get(&ctx);
+    let _length: i64 = varargs.get(&ctx);
+    #[cfg(not(any(target_os = "freebsd", target_vendor = "apple")))]
+    unsafe {
+        ftruncate64(_fd, _length)
+    }
+    #[cfg(target_os = "freebsd")]
+    unsafe {
+        ftruncate(_fd, _length)
+    }
+    #[cfg(target_vendor = "apple")]
+    unimplemented!("emscripten::___syscall194 (ftruncate64) {}", _which)
+}
+
+/// lchown
+pub fn ___syscall198(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall198 (lchown) {}", _which);
+    let path_ptr = varargs.get_str(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path_ptr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path_ptr
+    };
+    let uid: uid_t = varargs.get(&ctx);
+    let gid: gid_t = varargs.get(&ctx);
+    let result = unsafe { lchown(real_path, uid, gid) };
+    debug!(
+        "=> path: {}, uid: {}, gid: {}, result: {}",
+        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
+        uid,
+        gid,
+        result,
+    );
+    result
+}
+
+/// getgroups
+pub fn ___syscall205(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall205 (getgroups) {}", _which);
+    let ngroups_max: c_int = varargs.get(&ctx);
+    let groups: c_int = varargs.get(&ctx);
+
+    let memory = ctx.data().memory(0);
+    #[allow(clippy::cast_ptr_alignment)]
+    let gid_ptr = emscripten_memory_pointer!(memory.view(&ctx), groups) as *mut gid_t;
+    assert_eq!(4, mem::align_of_val(&gid_ptr));
+    let result = unsafe { getgroups(ngroups_max, gid_ptr) };
+    debug!(
+        "=> ngroups_max: {}, gid_ptr: {:?}, result: {}",
+        ngroups_max, gid_ptr, result,
+    );
+    result
+}
+
+// chown
+pub fn ___syscall212(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall212 (chown) {}", _which);
+
+    let pathname_addr = varargs.get_str(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    let owner: u32 = varargs.get(&ctx);
+    let group: u32 = varargs.get(&ctx);
+
+    unsafe { chown(real_path, owner, group) }
+}
+
+/// madvise
+pub fn ___syscall219(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall212 (chown) {}", _which);
+
+    let addr_ptr: c_int = varargs.get(&ctx);
+    let len: usize = varargs.get(&ctx);
+    let advice: c_int = varargs.get(&ctx);
+
+    let memory = ctx.data().memory(0);
+    let addr = emscripten_memory_pointer!(memory.view(&ctx), addr_ptr) as *mut c_void;
+
+    unsafe { madvise(addr, len, advice) }
+}
+
+/// access
+pub fn ___syscall33(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall33 (access) {}", _which);
+    let path = varargs.get_str(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path
+    };
+    let amode: c_int = varargs.get(&ctx);
+    let result = unsafe { access(real_path, amode) };
+    debug!(
+        "=> path: {}, amode: {}, result: {}",
+        unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() },
+        amode,
+        result
+    );
+    result
+}
+
+/// nice
+pub fn ___syscall34(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall34 (nice) {}", _which);
+    let inc_r: c_int = varargs.get(&ctx);
+    unsafe { nice(inc_r) }
+}
+
+// mkdir
+pub fn ___syscall39(mut ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall39 (mkdir) {}", _which);
+    let pathname_addr = varargs.get_str(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), pathname_addr as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    let mode: u32 = varargs.get(&ctx);
+    unsafe { mkdir(real_path, mode as _) }
+}
+
+/// dup
+pub fn ___syscall41(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall41 (dup) {}", _which);
+    let fd: c_int = varargs.get(&ctx);
+    unsafe { dup(fd) }
+}
+
+/// getgid32
+pub fn ___syscall200(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall200 (getgid32)");
+    unsafe { getgid() as i32 }
+}
+
+// geteuid32
+pub fn ___syscall201(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall201 (geteuid32)");
+    unsafe {
+        // Maybe fix: Emscripten returns 0 always
+        geteuid() as i32
+    }
+}
+
+// getegid32
+pub fn ___syscall202(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    // gid_t
+    debug!("emscripten::___syscall202 (getegid32)");
+    unsafe {
+        // Maybe fix: Emscripten returns 0 always
+        getegid() as _
+    }
+}
+
+/// fchown
+pub fn ___syscall207(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall207 (fchown) {}", _which);
+    let fd: c_int = varargs.get(&ctx);
+    let owner: uid_t = varargs.get(&ctx);
+    let group: gid_t = varargs.get(&ctx);
+    unsafe { fchown(fd, owner, group) }
+}
+
+/// dup3
+pub fn ___syscall330(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> pid_t {
+    // Implementation based on description at https://linux.die.net/man/2/dup3
+    debug!("emscripten::___syscall330 (dup3)");
+    let oldfd: c_int = varargs.get(&ctx);
+    let newfd: c_int = varargs.get(&ctx);
+    let flags: c_int = varargs.get(&ctx);
+
+    if oldfd == newfd {
+        return EINVAL;
+    }
+
+    let res = unsafe { dup2(oldfd, newfd) };
+
+    // Set flags on newfd (https://www.gnu.org/software/libc/manual/html_node/Descriptor-Flags.html)
+    let mut old_flags = unsafe { fcntl(newfd, F_GETFD, 0) };
+
+    match old_flags {
+        f if f > 0 => {
+            old_flags |= flags;
+        }
+        0 => {
+            old_flags &= !flags;
+        }
+        _ => {}
+    }
+
+    unsafe {
+        fcntl(newfd, F_SETFD, old_flags);
+    }
+
+    debug!(
+        "=> oldfd: {}, newfd: {}, flags: {} = pid: {}",
+        oldfd, newfd, flags, res
+    );
+    res
+}
+
+/// ioctl
+pub fn ___syscall54(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall54 (ioctl) {}", _which);
+
+    let fd: i32 = varargs.get(&ctx);
+    let request: u32 = varargs.get(&ctx);
+    debug!("=> fd: {}, op: {}", fd, request);
+
+    // Got the equivalents here: https://code.woboq.org/linux/linux/include/uapi/asm-generic/ioctls.h.html
+    match request {
+        WASM_FIOCLEX | WASM_FIONBIO | WASM_TIOCGWINSZ | WASM_TIOCSPGRP | WASM_TCGETS
+        | WASM_TCSETSW => {
+            let argp: u32 = varargs.get(&ctx);
+            let memory = ctx.data().memory(0);
+            let argp_ptr = emscripten_memory_pointer!(memory.view(&ctx), argp) as *mut c_void;
+            let translated_request = translate_ioctl(request);
+            let ret = unsafe { ioctl(fd, translated_request as _, argp_ptr) };
+            debug!(
+                " => request: {}, translated: {}, return: {}",
+                request, translated_request, ret
+            );
+
+            // TODO: We hardcode the value to have emscripten tests pass, as for some reason
+            // when the capturer is active, ioctl returns -1 instead of 0
+            if request == WASM_TIOCGWINSZ && ret == -1 {
+                return 0;
+            }
+            ret
+        }
+        _ => {
+            debug!(
+                " => not implemented case {} (noop, hardcoded to 0)",
+                request
+            );
+            0
+        }
+    }
+}
+
+const SOCK_NON_BLOCK: i32 = 2048;
+const SOCK_CLOEXC: i32 = 0x80000;
+
+// socketcall
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall102(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall102 (socketcall) {}", _which);
+    let call: u32 = varargs.get(&ctx);
+    let mut socket_varargs: VarArgs = varargs.get(&ctx);
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+
+    // migrating to EmSockAddr, port being separate here is nice, should update that too
+    #[repr(C)]
+    pub struct GuestSockaddrIn {
+        pub sin_family: sa_family_t, // u16
+        pub sin_port: in_port_t,     // u16
+        pub sin_addr: GuestInAddr,   // u32
+        pub sin_zero: [u8; 8],       // u8 * 8
+                                     // 2 + 2 + 4 + 8 = 16
+    }
+
+    #[repr(C)]
+    pub struct GuestInAddr {
+        pub s_addr: in_addr_t, // u32
+    }
+
+    match call {
+        1 => {
+            debug!("socket: socket");
+            // socket (domain: c_int, ty: c_int, protocol: c_int) -> c_int
+            let domain: i32 = socket_varargs.get(&ctx);
+            let ty_and_flags: i32 = socket_varargs.get(&ctx);
+            let protocol: i32 = socket_varargs.get(&ctx);
+            let ty = ty_and_flags & (!SOCK_NON_BLOCK) & (!SOCK_CLOEXC);
+            let fd = unsafe { socket(domain, ty, protocol) };
+
+            if ty_and_flags & SOCK_CLOEXC != 0 {
+                // set_cloexec
+                unsafe {
+                    ioctl(fd, translate_ioctl(WASM_FIOCLEX) as _);
+                };
+            }
+
+            if ty_and_flags & SOCK_NON_BLOCK != 0 {
+                // do something here
+                unimplemented!("non blocking sockets");
+            }
+
+            // why is this here?
+            type T = u32;
+            let payload = 1 as *const T as _;
+            unsafe {
+                setsockopt(
+                    fd,
+                    SOL_SOCKET,
+                    SO_NOSIGPIPE,
+                    payload,
+                    mem::size_of::<T>() as socklen_t,
+                );
+            };
+
+            debug!(
+                "=> domain: {}, type: {}, protocol: {} = fd: {}",
+                domain, ty, protocol, fd
+            );
+            fd as _
+        }
+        2 => {
+            debug!("socket: bind");
+            // bind (socket: c_int, address: *const sockaddr, address_len: socklen_t) -> c_int
+            // TODO: Emscripten has a different signature.
+            let socket = socket_varargs.get(&ctx);
+            let address: u32 = socket_varargs.get(&ctx);
+            let address_len = socket_varargs.get(&ctx);
+            let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
+
+            // Debug received address
+            let _proper_address = address as *const GuestSockaddrIn;
+            debug!(
+                    "=> address.sin_family: {:?}, address.sin_port: {:?}, address.sin_addr.s_addr: {:?}",
+                unsafe { (*_proper_address).sin_family }, unsafe { (*_proper_address).sin_port }, unsafe { (*_proper_address).sin_addr.s_addr }
+                );
+
+            let status = unsafe { bind(socket, address, address_len) };
+            // debug!("=> status: {}", status);
+            debug!(
+                "=> socketfd: {}, address: {:?}, address_len: {} = status: {}",
+                socket, address, address_len, status
+            );
+            status
+            // -1
+        }
+        3 => {
+            debug!("socket: connect");
+            // connect (socket: c_int, address: *const sockaddr, len: socklen_t) -> c_int
+            // TODO: Emscripten has a different signature.
+            let socket = socket_varargs.get(&ctx);
+            let address: u32 = socket_varargs.get(&ctx);
+            let address_len = socket_varargs.get(&ctx);
+            let address = emscripten_memory_pointer!(&view, address) as *mut sockaddr;
+            unsafe { connect(socket, address, address_len) }
+        }
+        4 => {
+            debug!("socket: listen");
+            // listen (socket: c_int, backlog: c_int) -> c_int
+            let socket = socket_varargs.get(&ctx);
+            let backlog: i32 = socket_varargs.get(&ctx);
+            let status = unsafe { listen(socket, backlog) };
+            debug!(
+                "=> socketfd: {}, backlog: {} = status: {}",
+                socket, backlog, status
+            );
+            status
+        }
+        5 => {
+            debug!("socket: accept");
+            // accept (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
+            let socket: i32 = socket_varargs.get(&ctx);
+            let address: WasmPtr<EmSockAddr> = socket_varargs.get(&ctx);
+            let address_len: WasmPtr<u32> = socket_varargs.get(&ctx);
+
+            debug!(
+                "=> socket: {}, address: {:?}, address_len: {}",
+                socket,
+                address.deref(&view).read().unwrap(),
+                address_len.deref(&view).read().unwrap()
+            );
+            let mut address_len_addr = address_len.deref(&view).read().unwrap();
+            // let mut address_len_addr: socklen_t = 0;
+
+            let mut host_address: sockaddr = sockaddr {
+                sa_family: Default::default(),
+                sa_data: Default::default(),
+                #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+                sa_len: Default::default(),
+            };
+            let fd = unsafe { accept(socket, &mut host_address, &mut address_len_addr) };
+            let mut address_addr = address.deref(&view).read().unwrap();
+
+            address_addr.sa_family = host_address.sa_family as _;
+            address_addr.sa_data = host_address.sa_data;
+
+            // why is this here?
+            // set_cloexec
+            unsafe {
+                ioctl(fd, translate_ioctl(WASM_FIOCLEX) as _);
+            };
+
+            debug!(
+                "address: {:?}, len: {}, result fd = {}",
+                address_addr, address_len_addr, fd
+            );
+
+            fd as _
+        }
+        6 => {
+            debug!("socket: getsockname");
+            // getsockname (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
+            let socket: i32 = socket_varargs.get(&ctx);
+            let address: WasmPtr<EmSockAddr> = socket_varargs.get(&ctx);
+            let address_len: WasmPtr<u32> = socket_varargs.get(&ctx);
+            let address_len_addr = address_len.deref(&view).read().unwrap();
+
+            let mut sock_addr_host: sockaddr = sockaddr {
+                sa_family: Default::default(),
+                sa_data: Default::default(),
+                #[cfg(any(target_os = "freebsd", target_vendor = "apple"))]
+                sa_len: Default::default(),
+            };
+            let ret = unsafe {
+                getsockname(
+                    socket,
+                    &mut sock_addr_host as *mut sockaddr,
+                    address_len_addr as *mut u32,
+                )
+            };
+            // translate from host data into emscripten data
+            let mut address_mut = address.deref(&view).read().unwrap();
+            address_mut.sa_family = sock_addr_host.sa_family as _;
+            address_mut.sa_data = sock_addr_host.sa_data;
+
+            debug!(
+                "=> socket: {}, address, {:?}, address_len: {}, result = {}",
+                socket, address_mut, address_len_addr, ret
+            );
+
+            ret
+        }
+        7 => {
+            debug!("socket: getpeername");
+            // getpeername (socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int
+            let socket = socket_varargs.get(&ctx);
+            let address: u32 = socket_varargs.get(&ctx);
+            let address_len: u32 = socket_varargs.get(&ctx);
+            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
+            let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
+            unsafe { getpeername(socket, address, address_len_addr) }
+        }
+        11 => {
+            debug!("socket: sendto");
+            // sendto (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
+            let socket = socket_varargs.get(&ctx);
+            let buf: u32 = socket_varargs.get(&ctx);
+            let flags = socket_varargs.get(&ctx);
+            let len: i32 = socket_varargs.get(&ctx);
+            let address: u32 = socket_varargs.get(&ctx);
+            let address_len = socket_varargs.get(&ctx);
+            let buf_addr = emscripten_memory_pointer!(view, buf) as _;
+            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
+            unsafe { sendto(socket, buf_addr, flags, len, address, address_len) as i32 }
+        }
+        12 => {
+            debug!("socket: recvfrom");
+            // recvfrom (socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t) -> ssize_t
+            let socket = socket_varargs.get(&ctx);
+            let buf: u32 = socket_varargs.get(&ctx);
+            let len: i32 = socket_varargs.get(&ctx);
+            let flags: i32 = socket_varargs.get(&ctx);
+            let address: u32 = socket_varargs.get(&ctx);
+            let address_len: u32 = socket_varargs.get(&ctx);
+            let buf_addr = emscripten_memory_pointer!(view, buf) as _;
+            let address = emscripten_memory_pointer!(view, address) as *mut sockaddr;
+            let address_len_addr = emscripten_memory_pointer!(view, address_len) as *mut socklen_t;
+            unsafe {
+                recvfrom(
+                    socket,
+                    buf_addr,
+                    len as usize,
+                    flags,
+                    address,
+                    address_len_addr,
+                ) as i32
+            }
+        }
+        14 => {
+            debug!("socket: setsockopt");
+            // OSX and BSD have completely different values, be very careful here
+            //      https://github.com/openbsd/src/blob/master/sys/sys/socket.h#L156
+            // setsockopt (socket: c_int, level: c_int, name: c_int, value: *const c_void, option_len: socklen_t) -> c_int
+
+            let socket = socket_varargs.get(&ctx);
+            let level: i32 = socket_varargs.get(&ctx);
+            let level = if level == 1 { SOL_SOCKET } else { level };
+            let untranslated_name: i32 = socket_varargs.get(&ctx);
+            let value: u32 = socket_varargs.get(&ctx);
+            let option_len: u32 = socket_varargs.get(&ctx);
+            let value_addr = emscripten_memory_pointer!(view, value) as *const libc::c_void;
+            let name: i32 = translate_socket_name_flag(untranslated_name);
+
+            let ret = unsafe { setsockopt(socket, level, name, value_addr, option_len) };
+
+            debug!("=> socketfd: {}, level: {}, name: {}, value_addr: {:?}, option_len: {} = status: {}", socket, level, untranslated_name, value_addr, option_len, ret);
+            ret
+        }
+        15 => {
+            debug!("socket: getsockopt");
+            // getsockopt (sockfd: c_int, level: c_int, optname: c_int, optval: *mut c_void, optlen: *mut socklen_t) -> c_int
+            let socket = socket_varargs.get(&ctx);
+            let level: i32 = socket_varargs.get(&ctx);
+            let level = if level == 1 { SOL_SOCKET } else { level };
+            let untranslated_name: i32 = socket_varargs.get(&ctx);
+            let name: i32 = translate_socket_name_flag(untranslated_name);
+            let value: u32 = socket_varargs.get(&ctx);
+            let option_len: u32 = socket_varargs.get(&ctx);
+            let value_addr = emscripten_memory_pointer!(view, value) as _;
+            let option_len_addr = emscripten_memory_pointer!(view, option_len) as *mut socklen_t;
+            unsafe { getsockopt(socket, level, name, value_addr, option_len_addr) }
+        }
+        16 => {
+            debug!("socket: sendmsg");
+            // sendmsg (fd: c_int, msg: *const msghdr, flags: c_int) -> ssize_t
+            let socket: i32 = socket_varargs.get(&ctx);
+            let msg: u32 = socket_varargs.get(&ctx);
+            let flags: i32 = socket_varargs.get(&ctx);
+            let msg_addr = emscripten_memory_pointer!(view, msg) as *const msghdr;
+            unsafe { sendmsg(socket, msg_addr, flags) as i32 }
+        }
+        17 => {
+            debug!("socket: recvmsg");
+            // recvmsg (fd: c_int, msg: *mut msghdr, flags: c_int) -> ssize_t
+            let socket: i32 = socket_varargs.get(&ctx);
+            let msg: u32 = socket_varargs.get(&ctx);
+            let flags: i32 = socket_varargs.get(&ctx);
+            let msg_addr = emscripten_memory_pointer!(view, msg) as *mut msghdr;
+            unsafe { recvmsg(socket, msg_addr, flags) as i32 }
+        }
+        _ => {
+            // others
+            -1
+        }
+    }
+}
+
+/// OSX and BSD have completely different values, we must translate from emscripten's Linuxy
+/// value into one that we can pass to native syscalls
+fn translate_socket_name_flag(name: i32) -> i32 {
+    match name {
+        2 => libc::SO_REUSEADDR,
+        3 => libc::SO_TYPE,
+        4 => libc::SO_ERROR,
+        5 => libc::SO_DONTROUTE,
+        6 => libc::SO_BROADCAST,
+        7 => libc::SO_SNDBUF,
+        8 => libc::SO_RCVBUF,
+        9 => libc::SO_KEEPALIVE,
+        10 => libc::SO_OOBINLINE,
+        13 => libc::SO_LINGER,
+        18 => libc::SO_RCVLOWAT,
+        19 => libc::SO_SNDLOWAT,
+        20 => libc::SO_RCVTIMEO,
+        21 => libc::SO_SNDTIMEO,
+        // SO_DEBUG missing
+        30 => libc::SO_ACCEPTCONN,
+        otherwise => otherwise,
+    }
+}
+
+/// getpgid
+pub fn ___syscall132(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall132 (getpgid)");
+
+    let pid: pid_t = varargs.get(&ctx);
+
+    let ret = unsafe { getpgid(pid) };
+    debug!("=> pid: {} = {}", pid, ret);
+    if ret == -1 {
+        debug!("=> last os error: {}", Error::last_os_error(),);
+    }
+    ret
+}
+
+#[derive(Debug, Copy, Clone, ValueType)]
+#[repr(C)]
+pub struct EmPollFd {
+    pub fd: i32,
+    pub events: i16,
+    pub revents: i16,
+}
+
+/// poll
+pub fn ___syscall168(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall168(poll)");
+    let fds: WasmPtr<EmPollFd> = varargs.get(&ctx);
+    let nfds: u32 = varargs.get(&ctx);
+    let timeout: i32 = varargs.get(&ctx);
+    let memory = ctx.data().memory(0);
+    let view = memory.view(&ctx);
+
+    let mut fds_mut = fds.deref(&view).read().unwrap();
+
+    unsafe {
+        libc::poll(
+            &mut fds_mut as *mut EmPollFd as *mut libc::pollfd,
+            nfds as _,
+            timeout,
+        )
+    }
+}
+
+// pread
+pub fn ___syscall180(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall180 (pread) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let buf: u32 = varargs.get(&ctx);
+    let count: u32 = varargs.get(&ctx);
+    {
+        let zero: u32 = varargs.get(&ctx);
+        assert_eq!(zero, 0);
+    }
+    let offset: i64 = varargs.get(&ctx);
+
+    let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
+
+    unsafe { pread(fd, buf_ptr, count as _, offset) as _ }
+}
+
+// pwrite
+pub fn ___syscall181(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall181 (pwrite) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let buf: u32 = varargs.get(&ctx);
+    let count: u32 = varargs.get(&ctx);
+    {
+        let zero: u32 = varargs.get(&ctx);
+        assert_eq!(zero, 0);
+    }
+    let offset: i64 = varargs.get(&ctx);
+
+    let buf_ptr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as _;
+    let status = unsafe { pwrite(fd, buf_ptr, count as _, offset) as _ };
+    debug!(
+        "=> fd: {}, buf: {}, count: {}, offset: {} = status:{}",
+        fd, buf, count, offset, status
+    );
+    status
+}
+
+/// fchmod
+pub fn ___syscall94(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall118 (fchmod) {}", _which);
+    let fd: c_int = varargs.get(&ctx);
+    let mode: mode_t = varargs.get(&ctx);
+    unsafe { fchmod(fd, mode) }
+}
+
+/// wait4
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall114(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> pid_t {
+    debug!("emscripten::___syscall114 (wait4)");
+    let pid: pid_t = varargs.get(&ctx);
+    let status: u32 = varargs.get(&ctx);
+    let options: c_int = varargs.get(&ctx);
+    let rusage: u32 = varargs.get(&ctx);
+    let memory = ctx.data().memory(0);
+    let status_addr = emscripten_memory_pointer!(memory.view(&ctx), status) as *mut c_int;
+
+    let rusage_addr = emscripten_memory_pointer!(memory.view(&ctx), rusage) as *mut rusage;
+    let res = unsafe { wait4(pid, status_addr, options, rusage_addr) };
+    debug!(
+        "=> pid: {}, status: {:?}, options: {}, rusage: {:?} = pid: {}",
+        pid, status_addr, options, rusage_addr, res
+    );
+    res
+}
+
+/// fsync
+pub fn ___syscall118(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall118 (fsync) {}", _which);
+    let fd: c_int = varargs.get(&ctx);
+    unsafe { fsync(fd) }
+}
+
+// select
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall142(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall142 (newselect) {}", _which);
+
+    let nfds: i32 = varargs.get(&ctx);
+    let readfds: u32 = varargs.get(&ctx);
+    let writefds: u32 = varargs.get(&ctx);
+    let exceptfds: u32 = varargs.get(&ctx);
+    let _timeout: i32 = varargs.get(&ctx);
+
+    if nfds > 1024 {
+        // EINVAL
+        return -22;
+    }
+    assert!(exceptfds == 0, "`exceptfds` is not supporrted");
+
+    let memory = ctx.data().memory(0);
+    let readfds_ptr = emscripten_memory_pointer!(memory.view(&ctx), readfds) as _;
+    let writefds_ptr = emscripten_memory_pointer!(memory.view(&ctx), writefds) as _;
+
+    unsafe { select(nfds, readfds_ptr, writefds_ptr, 0 as _, 0 as _) }
+}
+
+/// fdatasync
+pub fn ___syscall148(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall148 (fdatasync) {}", _which);
+
+    let fd: i32 = varargs.get(&ctx);
+
+    unsafe { fdatasync(fd) }
+}
+
+// setpgid
+pub fn ___syscall57(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall57 (setpgid) {}", _which);
+
+    let pid: i32 = varargs.get(&ctx);
+    let pgid: i32 = varargs.get(&ctx);
+
+    let ret = unsafe { setpgid(pid, pgid) };
+    debug!("=> pid: {}, pgid: {} = {}", pid, pgid, ret);
+    if ret == -1 {
+        debug!("=> last os error: {}", Error::last_os_error(),);
+    }
+    ret
+}
+
+/// uname
+// NOTE: Wondering if we should return custom utsname, like Emscripten.
+pub fn ___syscall122(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall122 (uname) {}", _which);
+    let buf: u32 = varargs.get(&ctx);
+    debug!("=> buf: {}", buf);
+    let buf_addr = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), buf) as *mut utsname;
+    unsafe { uname(buf_addr) }
+}
+
+/// lstat64
+pub fn ___syscall196(mut ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall196 (lstat64) {}", _which);
+    let path = varargs.get_str(&ctx);
+    let real_path_owned = utils::get_cstr_path(ctx.as_mut(), path as *const _);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        path
+    };
+    let buf_ptr: u32 = varargs.get(&ctx);
+    unsafe {
+        let mut stat: stat = std::mem::zeroed();
+
+        #[cfg(target_vendor = "apple")]
+        let stat_ptr = &mut stat as *mut stat as *mut c_void;
+        #[cfg(not(target_vendor = "apple"))]
+        let stat_ptr = &mut stat as *mut stat;
+
+        #[cfg(target_vendor = "apple")]
+        let ret = lstat64(real_path, stat_ptr);
+        #[cfg(not(target_vendor = "apple"))]
+        let ret = lstat(real_path, stat_ptr);
+
+        debug!("ret: {}", ret);
+        if ret != 0 {
+            return ret;
+        }
+        utils::copy_stat_into_wasm(ctx, buf_ptr, &stat);
+    }
+    0
+}
+
+// getuid
+pub fn ___syscall199(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall199 (getuid)");
+    let uid = unsafe { getuid() as _ };
+    debug!("  => {}", uid);
+    uid
+}
+
+// getdents
+// dirent structure is
+// i64, i64, u16 (280), i8, [i8; 256]
+pub fn ___syscall220(ctx: FunctionEnvMut<EmEnv>, _which: i32, mut varargs: VarArgs) -> i32 {
+    use super::super::env::get_emscripten_data;
+
+    let fd: i32 = varargs.get(&ctx);
+    let dirp_addr: i32 = varargs.get(&ctx);
+    let count: u32 = varargs.get(&ctx);
+    debug!(
+        "emscripten::___syscall220 (getdents) {} {} {}",
+        fd, dirp_addr, count
+    );
+
+    let dirp = emscripten_memory_pointer!(ctx.data().memory(0).view(&ctx), dirp_addr) as *mut u8;
+
+    let data = &mut get_emscripten_data(&ctx);
+    let opened_dirs = &mut data.as_mut().unwrap().opened_dirs;
+
+    // need to persist stream across calls?
+    // let dir: *mut libc::DIR = unsafe { libc::fdopendir(fd) };
+    let dir = &*opened_dirs
+        .entry(fd)
+        .or_insert_with(|| unsafe { Box::new(LibcDirWrapper(libc::fdopendir(fd))) });
+
+    let mut pos = 0;
+    let offset = 256 + 12;
+    while pos + offset <= count as usize {
+        let dirent = unsafe { readdir(***dir) };
+        if dirent.is_null() {
+            break;
+        }
+        #[allow(clippy::cast_ptr_alignment)]
+        #[cfg(not(target_os = "freebsd"))]
+        unsafe {
+            *(dirp.add(pos) as *mut u32) = (*dirent).d_ino as u32;
+        }
+        #[allow(clippy::cast_ptr_alignment)]
+        #[cfg(target_os = "freebsd")]
+        unsafe {
+            *(dirp.add(pos) as *mut u32) = (*dirent).d_fileno as u32;
+        }
+        #[allow(clippy::cast_ptr_alignment)]
+        unsafe {
+            *(dirp.add(pos + 4) as *mut u32) = pos as u32;
+            *(dirp.add(pos + 8) as *mut u16) = offset as u16;
+            *(dirp.add(pos + 10) as *mut u8) = (*dirent).d_type;
+            let upper_bound = std::cmp::min((*dirent).d_reclen, 255) as usize;
+            let mut i = 0;
+            while i < upper_bound {
+                *(dirp.add(pos + 11 + i) as *mut c_char) = (*dirent).d_name[i] as c_char;
+                i += 1;
+            }
+            // We set the termination string char
+            *(dirp.add(pos + 11 + i) as *mut c_char) = 0;
+            debug!(
+                "  => file {}",
+                CStr::from_ptr(dirp.add(pos + 11) as *const c_char)
+                    .to_str()
+                    .unwrap()
+            );
+        }
+        pos += offset;
+    }
+    pos as i32
+}
+
+// fcntl64
+pub fn ___syscall221(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall221 (fcntl64) {}", _which);
+    let fd: i32 = varargs.get(&ctx);
+    let cmd: i32 = varargs.get(&ctx);
+    let arg: i32 = varargs.get(&ctx);
+    // (FAPPEND   - 0x08
+    // |FASYNC    - 0x40
+    // |FFSYNC    - 0x80
+    // |FNONBLOCK - 0x04
+    let ret = unsafe { fcntl(fd, cmd, arg) };
+    debug!("=> fd: {}, cmd: {} = {}", fd, cmd, ret);
+    if ret == -1 {
+        debug!("=> last os error: {}", Error::last_os_error(),);
+    }
+    ret
+}
+
+/// fallocate
+pub fn ___syscall324(ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall324 (fallocate) {}", _which);
+    let _fd: c_int = varargs.get(&ctx);
+    let _mode: c_int = varargs.get(&ctx);
+    let _offset: off_t = varargs.get(&ctx);
+    let _len: off_t = varargs.get(&ctx);
+    #[cfg(not(any(target_os = "freebsd", target_vendor = "apple", target_os = "android")))]
+    unsafe {
+        fallocate(_fd, _mode, _offset, _len)
+    }
+    #[cfg(any(target_os = "freebsd", target_vendor = "apple", target_os = "android"))]
+    {
+        unimplemented!("emscripten::___syscall324 (fallocate) {}", _which)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/windows.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/windows.rs
new file mode 100644
index 0000000..8644a1a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/syscalls/windows.rs
@@ -0,0 +1,314 @@
+use crate::utils::{copy_cstr_into_wasm, get_cstr_path};
+use crate::varargs::VarArgs;
+use crate::EmEnv;
+use libc::mkdir;
+use libc::open;
+use std::env;
+use std::ffi::CString;
+use std::fs::File;
+use std::io::Write;
+use std::os::raw::c_int;
+use wasmer::FunctionEnvMut;
+
+#[allow(non_camel_case_types)]
+type pid_t = c_int;
+
+/// open
+pub fn ___syscall5(mut ctx: FunctionEnvMut<EmEnv>, which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall5 (open) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    let pathname_addr = varargs.get_str(&ctx);
+    let real_path_owned = get_cstr_path(ctx.as_mut(), pathname_addr);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    let flags: i32 = varargs.get(&ctx);
+    let mode: u32 = varargs.get(&ctx);
+    let path_str = unsafe { std::ffi::CStr::from_ptr(real_path).to_str().unwrap() };
+
+    match path_str {
+        "/dev/urandom" => {
+            // create a fake urandom file for windows, super hacky
+            // put it in the temp directory so we can just forget about it
+            let mut tmp_dir = env::temp_dir();
+            tmp_dir.push("urandom");
+            let tmp_dir_str = tmp_dir.to_str().unwrap();
+            let tmp_dir_c_str = CString::new(tmp_dir_str).unwrap();
+            let ptr = tmp_dir_c_str.as_ptr() as *const i8;
+            let mut urandom_file = File::create(tmp_dir).unwrap();
+            // create some random bytes and put them into the file
+            let mut random_bytes = [0u8; 32];
+            getrandom::getrandom(&mut random_bytes).unwrap();
+            let _ = urandom_file.write_all(&random_bytes).unwrap();
+            // put the file path string into wasm memory
+            let urandom_file_offset = unsafe { copy_cstr_into_wasm(&mut ctx, ptr) };
+            let mem = ctx.data().memory(0);
+            let memory = mem.view(&ctx);
+            let raw_pointer_to_urandom_file =
+                emscripten_memory_pointer!(&memory, urandom_file_offset) as *const i8;
+            let fd = unsafe { open(raw_pointer_to_urandom_file, flags, mode) };
+            debug!(
+                "=> pathname: {}, flags: {}, mode: {} = fd: {}",
+                path_str, flags, mode, fd
+            );
+            fd
+        }
+        _ => {
+            let fd = unsafe { open(real_path, flags, mode) };
+            debug!(
+                "=> pathname: {}, flags: {}, mode: {} = fd: {}\npath: {}",
+                path_str, flags, mode, fd, path_str
+            );
+            fd
+        }
+    }
+}
+
+/// link
+pub fn ___syscall9(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall9 (link) {}", _which);
+    unimplemented!("emscripten::___syscall9 (link) {}", _which);
+}
+
+/// ftruncate64
+pub fn ___syscall194(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall194 - stub");
+    unimplemented!("emscripten::___syscall194 - stub")
+}
+
+// chown
+pub fn ___syscall212(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall212 (chown) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// access
+pub fn ___syscall33(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall33 (access) {}", _which);
+    unimplemented!("emscripten::___syscall33 (access) {}", _which);
+}
+
+/// nice
+pub fn ___syscall34(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall34 (nice) {}", _which);
+    unimplemented!("emscripten::___syscall34 (nice) {}", _which);
+}
+
+// mkdir
+pub fn ___syscall39(ctx: FunctionEnvMut<EmEnv>, which: c_int, mut varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall39 (mkdir) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    let pathname_addr = varargs.get_str(&ctx);
+    let real_path_owned = get_cstr_path(ctx, pathname_addr);
+    let real_path = if let Some(ref rp) = real_path_owned {
+        rp.as_c_str().as_ptr()
+    } else {
+        pathname_addr
+    };
+    unsafe { mkdir(real_path) }
+}
+
+/// dup
+pub fn ___syscall41(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall41 (dup) {}", _which);
+    unimplemented!("emscripten::___syscall41 (dup) {}", _which);
+}
+
+/// getrusage
+pub fn ___syscall77(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall77 (getrusage) {}", _which);
+    unimplemented!("emscripten::___syscall77 (getrusage) {}", _which);
+}
+
+/// symlink
+pub fn ___syscall83(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall83 (symlink) {}", _which);
+    unimplemented!("emscripten::___syscall83 (symlink) {}", _which);
+}
+
+/// readlink
+pub fn ___syscall85(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall85 (readlink) {}", _which);
+    -1
+}
+
+/// getpgid
+pub fn ___syscall132(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall132 (getpgid)");
+    -1
+}
+
+/// lchown
+pub fn ___syscall198(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall198 (lchown) {}", _which);
+    unimplemented!("emscripten::___syscall198 (lchown) {}", _which);
+}
+
+/// getgid32
+pub fn ___syscall200(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall200 (getgid32)");
+    unimplemented!("emscripten::___syscall200 (getgid32)");
+}
+
+// geteuid32
+pub fn ___syscall201(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall201 (geteuid32)");
+    unimplemented!("emscripten::___syscall201 (geteuid32)");
+}
+
+// getegid32
+pub fn ___syscall202(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    // gid_t
+    debug!("emscripten::___syscall202 (getegid32)");
+    unimplemented!("emscripten::___syscall202 (getegid32)");
+}
+
+/// getgroups
+pub fn ___syscall205(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall205 (getgroups) {}", _which);
+    unimplemented!("emscripten::___syscall205 (getgroups) {}", _which);
+}
+
+/// madvise
+pub fn ___syscall219(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall212 (chown) {}", _which);
+    unimplemented!("emscripten::___syscall212 (chown) {}", _which);
+}
+
+/// dup3
+pub fn ___syscall330(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> pid_t {
+    debug!("emscripten::___syscall330 (dup3)");
+    -1
+}
+
+/// ioctl
+pub fn ___syscall54(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall54 (ioctl) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// fchmod
+pub fn ___syscall94(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall118 (fchmod) {}", _which);
+    unimplemented!("emscripten::___syscall118 (fchmod) {}", _which);
+}
+
+// socketcall
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall102(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall102 (socketcall) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// fsync
+pub fn ___syscall118(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall118 (fsync) {}", _which);
+    unimplemented!("emscripten::___syscall118 (fsync) {}", _which);
+}
+
+// pread
+pub fn ___syscall180(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall180 (pread) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+// pwrite
+pub fn ___syscall181(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall181 (pwrite) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// wait4
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall114(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> pid_t {
+    debug!("emscripten::___syscall114 (wait4)");
+    -1
+}
+
+// select
+#[allow(clippy::cast_ptr_alignment)]
+pub fn ___syscall142(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall142 (newselect) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// fdatasync
+pub fn ___syscall148(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall148 (fdatasync) {}", _which);
+    unimplemented!("emscripten::___syscall148 (fdatasync) {}", _which);
+}
+
+// setpgid
+pub fn ___syscall57(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall57 (setpgid) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// uname
+// NOTE: Wondering if we should return custom utsname, like Emscripten.
+pub fn ___syscall122(_ctx: FunctionEnvMut<EmEnv>, which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall122 (uname) {}", which);
+    #[cfg(not(feature = "debug"))]
+    let _ = which;
+    -1
+}
+
+/// poll
+pub fn ___syscall168(_ctx: FunctionEnvMut<EmEnv>, _which: i32, _varargs: VarArgs) -> i32 {
+    debug!("emscripten::___syscall168(poll) - stub");
+    -1
+}
+
+/// lstat64
+pub fn ___syscall196(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall196 (lstat64) - stub");
+    -1
+}
+
+// getuid
+pub fn ___syscall199(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall199 (getuid)");
+    -1
+}
+
+// getdents
+pub fn ___syscall220(_ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::___syscall220");
+    -1
+}
+
+// fcntl64
+pub fn ___syscall221(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, mut _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall221 (fcntl64) {}", _which);
+    -1
+}
+
+/// fchown
+pub fn ___syscall207(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall207 (fchown) {}", _which);
+    unimplemented!("emscripten::___syscall207 (fchown) {}", _which)
+}
+
+/// fallocate
+pub fn ___syscall324(_ctx: FunctionEnvMut<EmEnv>, _which: c_int, _varargs: VarArgs) -> c_int {
+    debug!("emscripten::___syscall324 (fallocate) {}", _which);
+    unimplemented!("emscripten::___syscall324 (fallocate) {}", _which)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/time.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/time.rs
new file mode 100644
index 0000000..e77c704
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/time.rs
@@ -0,0 +1,470 @@
+use super::utils::{copy_cstr_into_wasm, write_to_buf};
+use crate::{allocate_on_stack, lazy_static, EmEnv};
+use libc::{c_char, c_int};
+// use libc::{c_char, c_int, clock_getres, clock_settime};
+use std::mem;
+use std::time::SystemTime;
+
+#[cfg(not(target_os = "windows"))]
+use libc::{clockid_t, time as libc_time, timegm as libc_timegm, tm as libc_tm};
+#[cfg(not(target_os = "windows"))]
+use std::ffi::CString;
+
+#[cfg(target_os = "windows")]
+use libc::time_t;
+
+use wasmer::FunctionEnvMut;
+
+#[cfg(target_os = "windows")]
+#[allow(non_camel_case_types)]
+type clockid_t = c_int;
+
+#[cfg(target_os = "windows")]
+extern "C" {
+    #[link_name = "time"]
+    pub fn libc_time(s: *const time_t) -> time_t;
+}
+
+use super::env;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+use libc::{CLOCK_MONOTONIC, CLOCK_MONOTONIC_COARSE, CLOCK_REALTIME};
+
+#[cfg(target_os = "freebsd")]
+use libc::{CLOCK_MONOTONIC, CLOCK_REALTIME};
+#[cfg(target_os = "freebsd")]
+const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
+
+#[cfg(target_vendor = "apple")]
+use libc::CLOCK_REALTIME;
+#[cfg(target_vendor = "apple")]
+const CLOCK_MONOTONIC: clockid_t = 1;
+#[cfg(target_vendor = "apple")]
+const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
+
+// some assumptions about the constants when targeting windows
+#[cfg(target_os = "windows")]
+const CLOCK_REALTIME: clockid_t = 0;
+#[cfg(target_os = "windows")]
+const CLOCK_MONOTONIC: clockid_t = 1;
+#[cfg(target_os = "windows")]
+const CLOCK_MONOTONIC_COARSE: clockid_t = 6;
+
+/// emscripten: _gettimeofday
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _gettimeofday(ctx: FunctionEnvMut<EmEnv>, tp: c_int, tz: c_int) -> c_int {
+    debug!("emscripten::_gettimeofday {} {}", tp, tz);
+    #[repr(C)]
+    struct GuestTimeVal {
+        tv_sec: i32,
+        tv_usec: i32,
+    }
+
+    assert!(
+        tz == 0,
+        "the timezone argument of `_gettimeofday` must be null"
+    );
+    unsafe {
+        let now = SystemTime::now();
+        let since_epoch = now.duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let memory = ctx.data().memory(0);
+        let timeval_struct_ptr =
+            emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeVal;
+
+        (*timeval_struct_ptr).tv_sec = since_epoch.as_secs() as _;
+        (*timeval_struct_ptr).tv_usec = since_epoch.subsec_nanos() as _;
+    }
+    0
+}
+
+pub fn _clock_getres(mut _ctx: FunctionEnvMut<EmEnv>, _clk_id: i32, _tp: i32) -> i32 {
+    debug!("emscripten::_clock_getres");
+    // clock_getres(clk_id, tp)
+    0
+}
+
+/// emscripten: _clock_gettime
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _clock_gettime(ctx: FunctionEnvMut<EmEnv>, clk_id: clockid_t, tp: c_int) -> c_int {
+    debug!("emscripten::_clock_gettime {} {}", clk_id, tp);
+    // debug!("Memory {:?}", ctx.memory(0)[..]);
+    #[repr(C)]
+    struct GuestTimeSpec {
+        tv_sec: i32,
+        tv_nsec: i32,
+    }
+
+    #[allow(unreachable_patterns)]
+    let duration = match clk_id {
+        CLOCK_REALTIME => time::OffsetDateTime::now_utc().unix_timestamp_nanos(),
+
+        CLOCK_MONOTONIC | CLOCK_MONOTONIC_COARSE => {
+            lazy_static! {
+                static ref PRECISE0: time::Instant = time::Instant::now();
+            };
+            let precise_ns = *PRECISE0;
+            (time::Instant::now() - precise_ns).whole_nanoseconds()
+        }
+        _ => panic!("Clock with id \"{}\" is not supported.", clk_id),
+    };
+
+    unsafe {
+        let memory = ctx.data().memory(0);
+        let timespec_struct_ptr =
+            emscripten_memory_pointer!(memory.view(&ctx), tp) as *mut GuestTimeSpec;
+        (*timespec_struct_ptr).tv_sec = (duration / 1_000_000_000) as _;
+        (*timespec_struct_ptr).tv_nsec = (duration % 1_000_000_000) as _;
+    }
+    0
+}
+
+pub fn _clock_settime(mut _ctx: FunctionEnvMut<EmEnv>, _clk_id: i32, _tp: i32) -> i32 {
+    debug!("emscripten::_clock_settime");
+    // clock_settime(clk_id, tp)
+    0
+}
+
+/// emscripten: ___clock_gettime
+pub fn ___clock_gettime(ctx: FunctionEnvMut<EmEnv>, clk_id: clockid_t, tp: c_int) -> c_int {
+    debug!("emscripten::___clock_gettime {} {}", clk_id, tp);
+    _clock_gettime(ctx, clk_id, tp)
+}
+
+/// emscripten: _clock
+pub fn _clock(mut _ctx: FunctionEnvMut<EmEnv>) -> c_int {
+    debug!("emscripten::_clock");
+    0 // TODO: unimplemented
+}
+
+/// emscripten: _difftime
+pub fn _difftime(mut _ctx: FunctionEnvMut<EmEnv>, t0: u32, t1: u32) -> f64 {
+    debug!("emscripten::_difftime");
+    (t0 - t1) as _
+}
+
+pub fn _gmtime_r(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32, _two: i32) -> i32 {
+    debug!("emscripten::_gmtime_r");
+    -1
+}
+
+pub fn _mktime(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_mktime");
+    -1
+}
+
+pub fn _gmtime(mut _ctx: FunctionEnvMut<EmEnv>, _one: i32) -> i32 {
+    debug!("emscripten::_gmtime");
+    -1
+}
+
+#[repr(C)]
+struct guest_tm {
+    pub tm_sec: c_int,    // 0
+    pub tm_min: c_int,    // 4
+    pub tm_hour: c_int,   // 8
+    pub tm_mday: c_int,   // 12
+    pub tm_mon: c_int,    // 16
+    pub tm_year: c_int,   // 20
+    pub tm_wday: c_int,   // 24
+    pub tm_yday: c_int,   // 28
+    pub tm_isdst: c_int,  // 32
+    pub tm_gmtoff: c_int, // 36
+    pub tm_zone: c_int,   // 40
+}
+
+/// emscripten: _tvset
+pub fn _tvset(mut _ctx: FunctionEnvMut<EmEnv>) {
+    debug!("emscripten::_tvset UNIMPLEMENTED");
+}
+
+/// formats time as a C string
+#[allow(clippy::cast_ptr_alignment)]
+unsafe fn fmt_time(ctx: FunctionEnvMut<EmEnv>, time: u32) -> *const c_char {
+    let memory = ctx.data().memory(0);
+    let date = &*(emscripten_memory_pointer!(memory.view(&ctx), time) as *mut guest_tm);
+
+    let days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    let months = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    let year = 1900 + date.tm_year;
+
+    let time_str = format!(
+        // NOTE: TODO: Hack! The 14 accompanying chars are needed for some reason
+        "{} {} {:2} {:02}:{:02}:{:02} {:4}\n\0\0\0\0\0\0\0\0\0\0\0\0\0",
+        days[date.tm_wday as usize],
+        months[date.tm_mon as usize],
+        date.tm_mday,
+        date.tm_hour,
+        date.tm_min,
+        date.tm_sec,
+        year
+    );
+
+    time_str[0..26].as_ptr() as _
+}
+
+/// emscripten: _asctime
+pub fn _asctime(mut ctx: FunctionEnvMut<EmEnv>, time: u32) -> u32 {
+    debug!("emscripten::_asctime {}", time);
+
+    unsafe {
+        let time_str_ptr = fmt_time(ctx.as_mut(), time);
+        copy_cstr_into_wasm(&mut ctx, time_str_ptr)
+
+        // let c_str = emscripten_memory_pointer!(ctx, ctx.data().memory(0), res) as *mut i8;
+        // use std::ffi::CStr;
+        // debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
+    }
+}
+
+/// emscripten: _asctime_r
+pub fn _asctime_r(mut ctx: FunctionEnvMut<EmEnv>, time: u32, buf: u32) -> u32 {
+    debug!("emscripten::_asctime_r {}, {}", time, buf);
+
+    unsafe {
+        // NOTE: asctime_r is specced to behave in an undefined manner if the algorithm would attempt
+        //      to write out more than 26 bytes (including the null terminator).
+        //      See http://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html
+        //      Our undefined behavior is to truncate the write to at most 26 bytes, including null terminator.
+        let time_str_ptr = fmt_time(ctx.as_mut(), time);
+        write_to_buf(ctx, time_str_ptr, buf, 26)
+
+        // let c_str = emscripten_memory_pointer!(ctx, ctx.data().memory(0), res) as *mut i8;
+        // use std::ffi::CStr;
+        // debug!("#### cstr = {:?}", CStr::from_ptr(c_str));
+    }
+}
+
+/// emscripten: _localtime
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _localtime(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> c_int {
+    debug!("emscripten::_localtime {}", time_p);
+    // NOTE: emscripten seems to want tzset() called in this function
+    //      https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
+
+    let memory = ctx.data().memory(0);
+    let timespec = unsafe {
+        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
+        let seconds = *time_p_addr;
+        time::OffsetDateTime::from_unix_timestamp(seconds).unwrap()
+    };
+
+    unsafe {
+        let tm_struct_offset = env::call_malloc(&mut ctx, mem::size_of::<guest_tm>() as _);
+        let tm_struct_ptr =
+            emscripten_memory_pointer!(memory.view(&ctx), tm_struct_offset) as *mut guest_tm;
+        // debug!(
+        //     ">>>>>>> time = {}, {}, {}, {}, {}, {}, {}, {}",
+        //     result_tm.tm_sec, result_tm.tm_min, result_tm.tm_hour, result_tm.tm_mday,
+        //     result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
+        // );
+        (*tm_struct_ptr).tm_sec = timespec.second() as _;
+        (*tm_struct_ptr).tm_min = timespec.minute() as _;
+        (*tm_struct_ptr).tm_hour = timespec.hour() as _;
+        (*tm_struct_ptr).tm_mon = timespec.month() as _;
+        (*tm_struct_ptr).tm_mday = timespec.day() as _;
+        (*tm_struct_ptr).tm_year = timespec.year();
+        (*tm_struct_ptr).tm_wday = timespec.weekday() as _;
+        (*tm_struct_ptr).tm_yday = timespec.ordinal() as _;
+        (*tm_struct_ptr).tm_isdst = -1; // DST information unknown with time 0.2+
+        (*tm_struct_ptr).tm_gmtoff = 0;
+        (*tm_struct_ptr).tm_zone = 0;
+
+        tm_struct_offset as _
+    }
+}
+/// emscripten: _localtime_r
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _localtime_r(ctx: FunctionEnvMut<EmEnv>, time_p: u32, result: u32) -> c_int {
+    debug!("emscripten::_localtime_r {}", time_p);
+
+    // NOTE: emscripten seems to want tzset() called in this function
+    //      https://stackoverflow.com/questions/19170721/real-time-awareness-of-timezone-change-in-localtime-vs-localtime-r
+
+    let memory = ctx.data().memory(0);
+    unsafe {
+        let seconds = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *const i32;
+        let timespec = time::OffsetDateTime::from_unix_timestamp_nanos(*seconds as _).unwrap();
+
+        // debug!(
+        //     ">>>>>>> time = {}, {}, {}, {}, {}, {}, {}, {}",
+        //     result_tm.tm_sec, result_tm.tm_min, result_tm.tm_hour, result_tm.tm_mday,
+        //     result_tm.tm_mon, result_tm.tm_year, result_tm.tm_wday, result_tm.tm_yday,
+        // );
+
+        let result_addr = emscripten_memory_pointer!(memory.view(&ctx), result) as *mut guest_tm;
+
+        (*result_addr).tm_sec = timespec.second() as _;
+        (*result_addr).tm_min = timespec.minute() as _;
+        (*result_addr).tm_hour = timespec.hour() as _;
+        (*result_addr).tm_mon = timespec.month() as _;
+        (*result_addr).tm_mday = timespec.day() as _;
+        (*result_addr).tm_year = timespec.year();
+        (*result_addr).tm_wday = timespec.weekday() as _;
+        (*result_addr).tm_yday = timespec.ordinal() as _;
+        (*result_addr).tm_isdst = -1; // DST information unknown with time 0.2+
+        (*result_addr).tm_gmtoff = 0;
+        (*result_addr).tm_zone = 0;
+
+        result as _
+    }
+}
+
+/// emscripten: _time
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _time(ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> i32 {
+    debug!("emscripten::_time {}", time_p);
+
+    unsafe {
+        let memory = ctx.data().memory(0);
+        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_p) as *mut i64;
+        libc_time(time_p_addr) as i32 // TODO review i64
+    }
+}
+
+pub fn _ctime_r(mut ctx: FunctionEnvMut<EmEnv>, time_p: u32, buf: u32) -> u32 {
+    debug!("emscripten::_ctime_r {} {}", time_p, buf);
+
+    // var stack = stackSave();
+    let (result_offset, _result_slice): (u32, &mut [u8]) =
+        unsafe { allocate_on_stack(&mut ctx, 44) };
+    let time = _localtime_r(ctx.as_mut(), time_p, result_offset) as u32;
+    _asctime_r(ctx, time, buf)
+    // stackRestore(stack);
+}
+
+pub fn _ctime(ctx: FunctionEnvMut<EmEnv>, time_p: u32) -> u32 {
+    debug!("emscripten::_ctime {}", time_p);
+    let tm_current = 2414544;
+    _ctime_r(ctx, time_p, tm_current)
+}
+
+/// emscripten: _timegm
+#[cfg(not(target_os = "windows"))]
+#[allow(clippy::cast_ptr_alignment)]
+pub fn _timegm(ctx: FunctionEnvMut<EmEnv>, time_ptr: u32) -> i32 {
+    debug!("emscripten::_timegm {}", time_ptr);
+
+    unsafe {
+        let memory = ctx.data().memory(0);
+        let time_p_addr = emscripten_memory_pointer!(memory.view(&ctx), time_ptr) as *mut guest_tm;
+
+        let x: *mut c_char = CString::new("").expect("CString::new failed").into_raw();
+        let mut rust_tm = libc_tm {
+            tm_sec: 0,
+            tm_min: 0,
+            tm_hour: 0,
+            tm_mday: 0,
+            tm_mon: 0,
+            tm_year: 0,
+            tm_wday: 0,
+            tm_yday: 0,
+            tm_isdst: 0,
+            tm_gmtoff: 0,
+            tm_zone: x,
+        };
+
+        let result = libc_timegm(&mut rust_tm) as i32;
+        if result != 0 {
+            (*time_p_addr).tm_sec = rust_tm.tm_sec;
+            (*time_p_addr).tm_min = rust_tm.tm_min;
+            (*time_p_addr).tm_hour = rust_tm.tm_hour;
+            (*time_p_addr).tm_mday = rust_tm.tm_mday;
+            (*time_p_addr).tm_mon = rust_tm.tm_mon;
+            (*time_p_addr).tm_year = rust_tm.tm_year;
+            (*time_p_addr).tm_wday = rust_tm.tm_wday;
+            (*time_p_addr).tm_yday = rust_tm.tm_yday;
+            (*time_p_addr).tm_isdst = rust_tm.tm_isdst;
+            (*time_p_addr).tm_gmtoff = rust_tm.tm_gmtoff as _;
+            (*time_p_addr).tm_zone = 0;
+        }
+        result
+    }
+}
+
+#[cfg(target_os = "windows")]
+pub fn _timegm(mut _ctx: FunctionEnvMut<EmEnv>, _time_ptr: c_int) -> i32 {
+    debug!(
+        "emscripten::_timegm - UNIMPLEMENTED IN WINDOWS {}",
+        _time_ptr
+    );
+    -1
+}
+
+/// emscripten: _strftime
+pub fn _strftime(
+    ctx: FunctionEnvMut<EmEnv>,
+    s_ptr: c_int,
+    maxsize: u32,
+    format_ptr: c_int,
+    tm_ptr: c_int,
+) -> i32 {
+    debug!(
+        "emscripten::_strftime {} {} {} {}",
+        s_ptr, maxsize, format_ptr, tm_ptr
+    );
+
+    let memory = ctx.data().memory(0);
+    #[allow(clippy::cast_ptr_alignment)]
+    let s = emscripten_memory_pointer!(memory.view(&ctx), s_ptr) as *mut c_char;
+    #[allow(clippy::cast_ptr_alignment)]
+    let format = emscripten_memory_pointer!(memory.view(&ctx), format_ptr) as *const c_char;
+    #[allow(clippy::cast_ptr_alignment)]
+    let tm = emscripten_memory_pointer!(memory.view(&ctx), tm_ptr) as *const guest_tm;
+
+    let format_string = unsafe { std::ffi::CStr::from_ptr(format).to_str().unwrap() };
+
+    debug!("=> format_string: {:?}", format_string);
+
+    let tm = unsafe { &*tm };
+
+    let Ok(rust_date) = time::Date::from_calendar_date(
+        tm.tm_year,
+        time::Month::try_from(tm.tm_mon as u8).unwrap(),
+        tm.tm_mday as u8,
+    ) else {
+        return 0;
+    };
+    let Ok(rust_time) = time::Time::from_hms(tm.tm_hour as u8, tm.tm_min as u8, tm.tm_sec as u8)
+    else {
+        return 0;
+    };
+    let rust_datetime = time::PrimitiveDateTime::new(rust_date, rust_time);
+    let rust_odt =
+        rust_datetime.assume_offset(time::UtcOffset::from_whole_seconds(tm.tm_gmtoff).unwrap());
+
+    let result_str = rust_odt
+        .format(&time::format_description::parse(format_string).unwrap())
+        .unwrap();
+
+    // pad for null?
+    let bytes = result_str.chars().count();
+    if bytes as u32 > maxsize {
+        0
+    } else {
+        // write output string
+        for (i, c) in result_str.chars().enumerate() {
+            unsafe { *s.add(i) = c as c_char };
+        }
+        // null terminate?
+        bytes as i32
+    }
+}
+
+/// emscripten: _strftime_l
+pub fn _strftime_l(
+    ctx: FunctionEnvMut<EmEnv>,
+    s_ptr: c_int,
+    maxsize: u32,
+    format_ptr: c_int,
+    tm_ptr: c_int,
+    _last: c_int,
+) -> i32 {
+    debug!(
+        "emscripten::_strftime_l {} {} {} {}",
+        s_ptr, maxsize, format_ptr, tm_ptr
+    );
+
+    _strftime(ctx, s_ptr, maxsize, format_ptr, tm_ptr)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/ucontext.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/ucontext.rs
new file mode 100644
index 0000000..58c9f92
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/ucontext.rs
@@ -0,0 +1,27 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn _getcontext(mut _ctx: FunctionEnvMut<EmEnv>, _ucp: i32) -> i32 {
+    debug!("emscripten::_getcontext({})", _ucp);
+    0
+}
+pub fn _makecontext(
+    mut _ctx: FunctionEnvMut<EmEnv>,
+    _ucp: i32,
+    _func: i32,
+    _argc: i32,
+    _argv: i32,
+) {
+    debug!(
+        "emscripten::_makecontext({}, {}, {}, {})",
+        _ucp, _func, _argc, _argv
+    );
+}
+pub fn _setcontext(mut _ctx: FunctionEnvMut<EmEnv>, _ucp: i32) -> i32 {
+    debug!("emscripten::_setcontext({})", _ucp);
+    0
+}
+pub fn _swapcontext(mut _ctx: FunctionEnvMut<EmEnv>, _oucp: i32, _ucp: i32) -> i32 {
+    debug!("emscripten::_swapcontext({}, {})", _oucp, _ucp);
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/unistd.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/unistd.rs
new file mode 100644
index 0000000..b6875d0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/unistd.rs
@@ -0,0 +1,7 @@
+use crate::EmEnv;
+use wasmer::FunctionEnvMut;
+
+pub fn confstr(mut _ctx: FunctionEnvMut<EmEnv>, _name: i32, _buf_pointer: i32, _len: i32) -> i32 {
+    debug!("unistd::confstr({}, {}, {})", _name, _buf_pointer, _len);
+    0
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/utils.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/utils.rs
new file mode 100644
index 0000000..41c23fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/utils.rs
@@ -0,0 +1,310 @@
+use super::env;
+use super::env::{get_emscripten_data, get_emscripten_funcs};
+use crate::storage::align_memory;
+use crate::EmEnv;
+use libc::stat;
+use std::ffi::CStr;
+use std::mem::size_of;
+use std::os::raw::c_char;
+use std::path::PathBuf;
+use std::slice;
+use wasmer::{FunctionEnvMut, GlobalInit, MemoryView, Module, Pages, WasmPtr};
+
+/// We check if a provided module is an Emscripten generated one
+pub fn is_emscripten_module(module: &Module) -> bool {
+    for import in module.imports().functions() {
+        let name = import.name();
+        let module = import.module();
+        if (name == "_emscripten_memcpy_big"
+            || name == "emscripten_memcpy_big"
+            || name == "__map_file")
+            && module == "env"
+        {
+            return true;
+        }
+    }
+    false
+}
+
+pub fn get_emscripten_table_size(module: &Module) -> Result<(u32, Option<u32>), String> {
+    if let Some(import) = module.imports().tables().next() {
+        let ty = import.ty();
+        Ok((ty.minimum, ty.maximum))
+    } else {
+        Err("Emscripten requires at least one imported table".to_string())
+    }
+}
+
+pub fn get_emscripten_memory_size(module: &Module) -> Result<(Pages, Option<Pages>, bool), String> {
+    if let Some(import) = module.imports().memories().next() {
+        let ty = import.ty();
+        Ok((ty.minimum, ty.maximum, ty.shared))
+    } else {
+        Err("Emscripten requires at least one imported memory".to_string())
+    }
+}
+
+/// Reads values written by `-s EMIT_EMSCRIPTEN_METADATA=1`
+/// Assumes values start from the end in this order:
+/// Last export: Dynamic Base
+/// Second-to-Last export: Dynamic top pointer
+pub fn get_emscripten_metadata(module: &Module) -> Result<Option<(u32, u32)>, String> {
+    let max_idx = match module
+        .info()
+        .global_initializers
+        .iter()
+        .map(|(k, _)| k)
+        .max()
+    {
+        Some(x) => x,
+        None => return Ok(None),
+    };
+
+    let snd_max_idx = match module
+        .info()
+        .global_initializers
+        .iter()
+        .map(|(k, _)| k)
+        .filter(|k| *k != max_idx)
+        .max()
+    {
+        Some(x) => x,
+        None => return Ok(None),
+    };
+
+    if let (GlobalInit::I32Const(dynamic_base), GlobalInit::I32Const(dynamictop_ptr)) = (
+        &module.info().global_initializers[max_idx],
+        &module.info().global_initializers[snd_max_idx],
+    ) {
+        let dynamic_base = (*dynamic_base as u32).checked_sub(32).ok_or_else(|| {
+            format!(
+                "emscripten unexpected dynamic_base {}",
+                *dynamic_base as u32
+            )
+        })?;
+        let dynamictop_ptr = (*dynamictop_ptr as u32).checked_sub(32).ok_or_else(|| {
+            format!(
+                "emscripten unexpected dynamictop_ptr {}",
+                *dynamictop_ptr as u32
+            )
+        })?;
+        Ok(Some((
+            align_memory(dynamic_base),
+            align_memory(dynamictop_ptr),
+        )))
+    } else {
+        Ok(None)
+    }
+}
+
+pub unsafe fn write_to_buf(
+    ctx: FunctionEnvMut<EmEnv>,
+    string: *const c_char,
+    buf: u32,
+    max: u32,
+) -> u32 {
+    let memory = ctx.data().memory(0);
+    let buf_addr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut c_char;
+
+    for i in 0..max {
+        *buf_addr.add(i as _) = *string.add(i as _);
+    }
+
+    buf
+}
+
+/// This function expects nullbyte to be appended.
+pub unsafe fn copy_cstr_into_wasm(ctx: &mut FunctionEnvMut<EmEnv>, cstr: *const c_char) -> u32 {
+    let s = CStr::from_ptr(cstr).to_str().unwrap();
+    let cstr_len = s.len();
+    let space_offset = env::call_malloc(ctx, (cstr_len as u32) + 1);
+    let memory = ctx.data().memory(0);
+    let raw_memory = emscripten_memory_pointer!(memory.view(&ctx), space_offset) as *mut c_char;
+    let slice = slice::from_raw_parts_mut(raw_memory, cstr_len);
+
+    for (byte, loc) in s.bytes().zip(slice.iter_mut()) {
+        *loc = byte as _;
+    }
+
+    // TODO: Appending null byte won't work, because there is CStr::from_ptr(cstr)
+    //      at the top that crashes when there is no null byte
+    *raw_memory.add(cstr_len) = 0;
+
+    space_offset
+}
+
+/// # Safety
+/// This method is unsafe because it operates directly with the slice of memory represented by the address
+pub unsafe fn allocate_on_stack<'a, T: Copy>(
+    mut ctx: &mut FunctionEnvMut<'a, EmEnv>,
+    count: u32,
+) -> (u32, &'a mut [T]) {
+    let stack_alloc_ref = get_emscripten_funcs(ctx).stack_alloc_ref().unwrap().clone();
+    let offset = stack_alloc_ref
+        .call(&mut ctx, count * (size_of::<T>() as u32))
+        .unwrap();
+
+    let memory = ctx.data().memory(0);
+    let addr = emscripten_memory_pointer!(memory.view(&ctx), offset) as *mut T;
+    let slice = slice::from_raw_parts_mut(addr, count as usize);
+
+    (offset, slice)
+}
+
+/// # Safety
+/// This method is unsafe because it uses `allocate_on_stack` which is unsafe
+pub unsafe fn allocate_cstr_on_stack<'a>(
+    ctx: &'a mut FunctionEnvMut<'a, EmEnv>,
+    s: &str,
+) -> (u32, &'a [u8]) {
+    let (offset, slice) = allocate_on_stack(ctx, (s.len() + 1) as u32);
+
+    use std::iter;
+    for (byte, loc) in s.bytes().chain(iter::once(0)).zip(slice.iter_mut()) {
+        *loc = byte;
+    }
+
+    (offset, slice)
+}
+
+#[cfg(not(target_os = "windows"))]
+pub unsafe fn copy_terminated_array_of_cstrs(
+    mut _ctx: FunctionEnvMut<EmEnv>,
+    cstrs: *mut *mut c_char,
+) -> u32 {
+    let _total_num = {
+        let mut ptr = cstrs;
+        let mut counter = 0;
+        while !(*ptr).is_null() {
+            counter += 1;
+            ptr = ptr.add(1);
+        }
+        counter
+    };
+    debug!(
+        "emscripten::copy_terminated_array_of_cstrs::total_num: {}",
+        _total_num
+    );
+    0
+}
+
+#[repr(C)]
+pub struct GuestStat {
+    st_dev: u32,
+    __st_dev_padding: u32,
+    __st_ino_truncated: u32,
+    st_mode: u32,
+    st_nlink: u32,
+    st_uid: u32,
+    st_gid: u32,
+    st_rdev: u32,
+    __st_rdev_padding: u32,
+    st_size: u32,
+    st_blksize: u32,
+    st_blocks: u32,
+    st_atime: u64,
+    st_mtime: u64,
+    st_ctime: u64,
+    st_ino: u32,
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+pub unsafe fn copy_stat_into_wasm(ctx: FunctionEnvMut<EmEnv>, buf: u32, stat: &stat) {
+    let memory = ctx.data().memory(0);
+    let stat_ptr = emscripten_memory_pointer!(memory.view(&ctx), buf) as *mut GuestStat;
+    (*stat_ptr).st_dev = stat.st_dev as _;
+    (*stat_ptr).__st_dev_padding = 0;
+    (*stat_ptr).__st_ino_truncated = stat.st_ino as _;
+    (*stat_ptr).st_mode = stat.st_mode as _;
+    (*stat_ptr).st_nlink = stat.st_nlink as _;
+    (*stat_ptr).st_uid = stat.st_uid as _;
+    (*stat_ptr).st_gid = stat.st_gid as _;
+    (*stat_ptr).st_rdev = stat.st_rdev as _;
+    (*stat_ptr).__st_rdev_padding = 0;
+    (*stat_ptr).st_size = stat.st_size as _;
+    (*stat_ptr).st_blksize = 4096;
+    #[cfg(not(target_os = "windows"))]
+    {
+        (*stat_ptr).st_blocks = stat.st_blocks as _;
+    }
+    #[cfg(target_os = "windows")]
+    {
+        (*stat_ptr).st_blocks = 0;
+    }
+    (*stat_ptr).st_atime = stat.st_atime as _;
+    (*stat_ptr).st_mtime = stat.st_mtime as _;
+    (*stat_ptr).st_ctime = stat.st_ctime as _;
+    (*stat_ptr).st_ino = stat.st_ino as _;
+}
+
+#[allow(dead_code)] // it's used in `env/windows/mod.rs`.
+pub fn read_string_from_wasm(memory: &MemoryView, offset: u32) -> String {
+    WasmPtr::<u8>::new(offset)
+        .read_utf8_string_with_nul(memory)
+        .unwrap()
+}
+
+/// This function trys to find an entry in mapdir
+/// translating paths into their correct value
+pub fn get_cstr_path(ctx: FunctionEnvMut<EmEnv>, path: *const i8) -> Option<std::ffi::CString> {
+    use std::collections::VecDeque;
+
+    let path_str =
+        unsafe { std::ffi::CStr::from_ptr(path as *const _).to_str().unwrap() }.to_string();
+    let data = get_emscripten_data(&ctx);
+    let path = PathBuf::from(path_str);
+    let mut prefix_added = false;
+    let mut components = path.components().collect::<VecDeque<_>>();
+    // TODO(mark): handle absolute/non-canonical/non-relative paths too (this
+    // functionality should be shared among the abis)
+    if components.len() == 1 {
+        components.push_front(std::path::Component::CurDir);
+        prefix_added = true;
+    }
+    let mut cumulative_path = PathBuf::new();
+    for c in components.into_iter() {
+        cumulative_path.push(c);
+        if let Some(val) = data
+            .as_ref()
+            .unwrap()
+            .mapped_dirs
+            .get(&cumulative_path.to_string_lossy().to_string())
+        {
+            let rest_of_path = if !prefix_added {
+                path.strip_prefix(cumulative_path).ok()?
+            } else {
+                &path
+            };
+            let rebased_path = val.join(rest_of_path);
+            return std::ffi::CString::new(rebased_path.to_string_lossy().as_bytes()).ok();
+        }
+    }
+    None
+}
+
+/// gets the current directory
+/// handles mapdir logic
+pub fn get_current_directory(ctx: FunctionEnvMut<EmEnv>) -> Option<PathBuf> {
+    if let Some(val) = get_emscripten_data(&ctx)
+        .as_ref()
+        .unwrap()
+        .mapped_dirs
+        .get(".")
+    {
+        return Some(val.clone());
+    }
+    std::env::current_dir()
+        .map(|cwd| {
+            if let Some(val) = get_emscripten_data(&ctx)
+                .as_ref()
+                .unwrap()
+                .mapped_dirs
+                .get(&cwd.to_string_lossy().to_string())
+            {
+                val.clone()
+            } else {
+                cwd
+            }
+        })
+        .ok()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/varargs.rs b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/varargs.rs
new file mode 100644
index 0000000..126d1fa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/emscripten/src/varargs.rs
@@ -0,0 +1,39 @@
+use crate::EmEnv;
+use std::mem;
+use wasmer::FromToNativeWasmType;
+// use std::ffi::CStr;
+use std::os::raw::c_char;
+use wasmer::FunctionEnvMut;
+
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct VarArgs {
+    pub pointer: u32, // assuming 32bit wasm
+}
+
+impl VarArgs {
+    pub fn get<T: Sized>(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> T {
+        let memory = ctx.data().memory(0);
+        let ptr = emscripten_memory_pointer!(memory.view(&ctx), self.pointer);
+        self.pointer += mem::size_of::<T>() as u32;
+        unsafe { (ptr as *const T).read() }
+    }
+
+    // pub fn getStr<'a>(&mut self, ctx: &mut Ctx) -> &'a CStr {
+    pub fn get_str(&mut self, ctx: &FunctionEnvMut<EmEnv>) -> *const c_char {
+        let ptr_addr: u32 = self.get(ctx);
+        let memory = ctx.data().memory(0);
+        emscripten_memory_pointer!(memory.view(&ctx), ptr_addr) as *const c_char
+    }
+}
+
+unsafe impl FromToNativeWasmType for VarArgs {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.pointer as _
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self { pointer: n as u32 }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/journal/Cargo.toml
new file mode 100644
index 0000000..d412dea
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/Cargo.toml
@@ -0,0 +1,40 @@
+[package]
+name = "wasmer-journal"
+version = "0.1.0"
+description = "Journaling functionality used by Wasmer to save and restore WASM state"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[features]
+default = [ "log-file", "wasmer/sys" ]
+log-file = [ "shared-buffer" ]
+
+[dependencies]
+wasmer = { default-features = false, path = "../api", version = "=4.2.8" }
+wasmer-wasix-types = { path = "../wasi-types", version = "0.18.3", features = [ "enable-serde" ] }
+virtual-net = { path = "../virtual-net", version = "0.6.3", default-features = false, features = ["rkyv"] }
+virtual-fs = { path = "../virtual-fs", default-features = false }
+
+shared-buffer = { workspace = true, optional = true }
+thiserror = "1"
+bytes = "1.1"
+async-trait = { version = "^0.1" }
+tracing = "0.1"
+derivative = { version = "^2" }
+base64 = "0.21"
+bincode = { version = "1.3" }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+anyhow = "1.0"
+rkyv = { workspace = true }
+bytecheck = { version = "0.6.8" }
+lz4_flex = { version = "0.11" }
+num_enum = "0.5.7"
+serde_json = { version = "^1" }
+
+[dev-dependencies]
+tracing-test = "0.2.4"
+tempfile = "3.6.0"
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/base64.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/base64.rs
new file mode 100644
index 0000000..be558dd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/base64.rs
@@ -0,0 +1,21 @@
+use std::borrow::Cow;
+
+use lz4_flex::block::{compress_prepend_size, decompress_size_prepended};
+
+use serde::{Deserialize, Serialize};
+use serde::{Deserializer, Serializer};
+
+pub fn serialize<S: Serializer>(v: &[u8], s: S) -> Result<S::Ok, S::Error> {
+    #[allow(deprecated)]
+    let base64 = base64::encode(compress_prepend_size(v));
+    String::serialize(&base64, s)
+}
+
+pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Cow<'static, [u8]>, D::Error> {
+    let base64 = String::deserialize(d)?;
+    #[allow(deprecated)]
+    let bytes = base64::decode(base64).map_err(serde::de::Error::custom)?;
+    decompress_size_prepended(&bytes)
+        .map_err(serde::de::Error::custom)
+        .map(|d| d.into())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_str.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_str.rs
new file mode 100644
index 0000000..c9676cb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_str.rs
@@ -0,0 +1,114 @@
+use std::{borrow::Cow, fmt, ops::Deref};
+
+use rkyv::{
+    ser::{ScratchSpace, Serializer},
+    vec::{ArchivedVec, VecResolver},
+    Archive, Archived, Serialize,
+};
+
+#[derive(Clone)]
+pub struct AlignedCowStr<'a> {
+    inner: Cow<'a, str>,
+}
+
+impl<'a> AlignedCowStr<'a> {
+    pub const ALIGNMENT: usize = 16;
+
+    pub fn into_inner(self) -> Cow<'a, str> {
+        self.inner
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &str {
+        self.inner.as_ref()
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+}
+
+impl<'a> Default for AlignedCowStr<'a> {
+    fn default() -> Self {
+        Self {
+            inner: String::new().into(),
+        }
+    }
+}
+
+impl<'a> fmt::Debug for AlignedCowStr<'a> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.inner.fmt(f)
+    }
+}
+
+impl<'a> From<String> for AlignedCowStr<'a> {
+    fn from(value: String) -> Self {
+        Self {
+            inner: value.into(),
+        }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl<'a> Into<String> for AlignedCowStr<'a> {
+    fn into(self) -> String {
+        self.inner.into_owned()
+    }
+}
+
+impl<'a> From<Cow<'a, str>> for AlignedCowStr<'a> {
+    fn from(value: Cow<'a, str>) -> Self {
+        Self { inner: value }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl<'a> Into<Cow<'a, str>> for AlignedCowStr<'a> {
+    fn into(self) -> Cow<'a, str> {
+        self.inner
+    }
+}
+
+impl<'a> Deref for AlignedCowStr<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.deref()
+    }
+}
+
+impl<'a> AsRef<str> for AlignedCowStr<'a> {
+    #[inline]
+    fn as_ref(&self) -> &str {
+        self.inner.as_ref()
+    }
+}
+
+impl<'a> Archive for AlignedCowStr<'a> {
+    type Archived = ArchivedVec<u8>;
+    type Resolver = VecResolver;
+
+    #[inline]
+    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
+        ArchivedVec::resolve_from_len(self.inner.as_bytes().len(), pos, resolver, out);
+    }
+}
+
+impl<'a, S: ScratchSpace + Serializer + ?Sized> Serialize<S> for AlignedCowStr<'a> {
+    #[inline]
+    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+        serializer.align(Self::ALIGNMENT)?;
+        unsafe {
+            ArchivedVec::<Archived<u8>>::serialize_copy_from_slice(
+                self.inner.as_bytes(),
+                serializer,
+            )
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_vec.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_vec.rs
new file mode 100644
index 0000000..49ff1bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/aligned_cow_vec.rs
@@ -0,0 +1,213 @@
+use std::{
+    borrow::{Borrow, BorrowMut, Cow},
+    fmt::{self, Pointer},
+    ops::{Deref, DerefMut},
+};
+
+use rkyv::{
+    ser::{ScratchSpace, Serializer},
+    vec::{ArchivedVec, VecResolver},
+    Archive, Archived, Serialize,
+};
+
+/// An aligned COW vector of bytes which avoids copying data
+/// when its constructed. The vector is aligned on the 16-byte
+/// boundary
+#[derive(Clone)]
+pub struct AlignedCowVec<'a, T>
+where
+    [T]: ToOwned,
+{
+    inner: Cow<'a, [T]>,
+}
+
+impl<'a, T> AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    /// The alignment of the vector
+    pub const ALIGNMENT: usize = 16;
+
+    pub fn into_inner(self) -> Cow<'a, [T]> {
+        self.inner
+    }
+
+    #[inline]
+    pub fn as_slice(&self) -> &[T] {
+        self.inner.as_ref()
+    }
+
+    pub fn len(&self) -> usize {
+        self.inner.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.inner.is_empty()
+    }
+
+    pub fn len_with_padding(&self) -> usize {
+        let mut ret = self.inner.len() * std::mem::size_of::<T>();
+        let padding = ret % Self::ALIGNMENT;
+        if padding != 0 {
+            ret += Self::ALIGNMENT - padding;
+        }
+        ret
+    }
+}
+
+impl<'a, T> Default for AlignedCowVec<'a, T>
+where
+    T: 'a + Clone,
+    [T]: ToOwned,
+{
+    fn default() -> Self {
+        Self {
+            inner: Vec::new().into(),
+        }
+    }
+}
+
+impl<'a, T> fmt::Debug for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_slice().fmt(f)
+    }
+}
+
+impl<'a, T> From<Vec<T>> for AlignedCowVec<'a, T>
+where
+    T: 'a + Clone,
+    [T]: ToOwned,
+{
+    fn from(value: Vec<T>) -> Self {
+        Self {
+            inner: value.into(),
+        }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl<'a> Into<Vec<u8>> for AlignedCowVec<'a, u8> {
+    fn into(self) -> Vec<u8> {
+        self.inner.into_owned()
+    }
+}
+
+impl<'a, T> From<Cow<'a, [T]>> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    fn from(value: Cow<'a, [T]>) -> Self {
+        Self { inner: value }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl<'a, T> Into<Cow<'a, [T]>> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    fn into(self) -> Cow<'a, [T]> {
+        self.inner
+    }
+}
+
+impl<'a, T> Deref for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.deref()
+    }
+}
+
+impl<'a, T> DerefMut for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+    <[T] as ToOwned>::Owned: BorrowMut<[T]>,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.to_mut().borrow_mut()
+    }
+}
+
+impl<'a, T> AsMut<[T]> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+    <[T] as ToOwned>::Owned: BorrowMut<[T]>,
+{
+    #[inline]
+    fn as_mut(&mut self) -> &mut [T] {
+        self.inner.to_mut().borrow_mut()
+    }
+}
+
+impl<'a, T> AsRef<[T]> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    #[inline]
+    fn as_ref(&self) -> &[T] {
+        self.inner.as_ref()
+    }
+}
+
+impl<'a, T> Borrow<[T]> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    #[inline]
+    fn borrow(&self) -> &[T] {
+        self.inner.borrow()
+    }
+}
+
+impl<'a, T> BorrowMut<[T]> for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+    <[T] as ToOwned>::Owned: BorrowMut<[T]>,
+{
+    #[inline]
+    fn borrow_mut(&mut self) -> &mut [T] {
+        self.inner.to_mut().borrow_mut()
+    }
+}
+
+impl<'a, T> Archive for AlignedCowVec<'a, T>
+where
+    T: 'a,
+    [T]: ToOwned,
+{
+    type Archived = ArchivedVec<T>;
+    type Resolver = VecResolver;
+
+    #[inline]
+    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
+        ArchivedVec::resolve_from_len(self.len(), pos, resolver, out);
+    }
+}
+
+impl<'a, S: ScratchSpace + Serializer + ?Sized> Serialize<S> for AlignedCowVec<'a, u8> {
+    #[inline]
+    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+        serializer.align(Self::ALIGNMENT)?;
+        unsafe {
+            ArchivedVec::<Archived<u8>>::serialize_copy_from_slice(self.as_slice(), serializer)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/arc.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/arc.rs
new file mode 100644
index 0000000..1790777
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/arc.rs
@@ -0,0 +1,41 @@
+use super::*;
+use std::ops::Deref;
+use std::sync::Arc;
+
+impl ReadableJournal for Arc<DynReadableJournal> {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.deref().read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.deref().as_restarted()
+    }
+}
+
+impl WritableJournal for Arc<DynWritableJournal> {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.deref().write(entry)
+    }
+}
+
+impl ReadableJournal for Arc<DynJournal> {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.deref().read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.deref().as_restarted()
+    }
+}
+
+impl WritableJournal for Arc<DynJournal> {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.deref().write(entry)
+    }
+}
+
+impl Journal for Arc<DynJournal> {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.clone()), Box::new(self.clone()))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived.rs
new file mode 100644
index 0000000..6a80048
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived.rs
@@ -0,0 +1,1804 @@
+use lz4_flex::block::compress_prepend_size;
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+use rkyv::ser::{ScratchSpace, Serializer};
+use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
+use std::time::{Duration, SystemTime};
+
+use super::*;
+
+pub const JOURNAL_MAGIC_NUMBER: u64 = 0x310d6dd027362979;
+pub const JOURNAL_MAGIC_NUMBER_BYTES: [u8; 8] = JOURNAL_MAGIC_NUMBER.to_be_bytes();
+
+#[repr(u16)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    IntoPrimitive,
+    TryFromPrimitive,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalEntryRecordType {
+    InitModuleV1 = 1,
+    ProcessExitV1 = 2,
+    SetThreadV1 = 3,
+    CloseThreadV1 = 4,
+    FileDescriptorSeekV1 = 5,
+    FileDescriptorWriteV1 = 6,
+    UpdateMemoryRegionV1 = 7,
+    SetClockTimeV1 = 9,
+    OpenFileDescriptorV1 = 10,
+    CloseFileDescriptorV1 = 11,
+    RenumberFileDescriptorV1 = 12,
+    DuplicateFileDescriptorV1 = 13,
+    CreateDirectoryV1 = 14,
+    RemoveDirectoryV1 = 15,
+    PathSetTimesV1 = 16,
+    FileDescriptorSetTimesV1 = 17,
+    FileDescriptorSetSizeV1 = 18,
+    FileDescriptorSetFlagsV1 = 19,
+    FileDescriptorSetRightsV1 = 20,
+    FileDescriptorAdviseV1 = 21,
+    FileDescriptorAllocateV1 = 22,
+    CreateHardLinkV1 = 23,
+    CreateSymbolicLinkV1 = 24,
+    UnlinkFileV1 = 25,
+    PathRenameV1 = 26,
+    ChangeDirectoryV1 = 27,
+    EpollCreateV1 = 28,
+    EpollCtlV1 = 29,
+    TtySetV1 = 30,
+    CreatePipeV1 = 31,
+    CreateEventV1 = 32,
+    PortAddAddrV1 = 33,
+    PortDelAddrV1 = 34,
+    PortAddrClearV1 = 35,
+    PortBridgeV1 = 36,
+    PortUnbridgeV1 = 37,
+    PortDhcpAcquireV1 = 38,
+    PortGatewaySetV1 = 39,
+    PortRouteAddV1 = 40,
+    PortRouteClearV1 = 41,
+    PortRouteDelV1 = 42,
+    SocketOpenV1 = 43,
+    SocketListenV1 = 44,
+    SocketBindV1 = 45,
+    SocketConnectedV1 = 46,
+    SocketAcceptedV1 = 47,
+    SocketJoinIpv4MulticastV1 = 48,
+    SocketJoinIpv6MulticastV1 = 49,
+    SocketLeaveIpv4MulticastV1 = 50,
+    SocketLeaveIpv6MulticastV1 = 51,
+    SocketSendFileV1 = 52,
+    SocketSendToV1 = 53,
+    SocketSendV1 = 54,
+    SocketSetOptFlagV1 = 55,
+    SocketSetOptSizeV1 = 56,
+    SocketSetOptTimeV1 = 57,
+    SocketShutdownV1 = 58,
+    SnapshotV1 = 59,
+    ClearEtherealV1 = 60,
+}
+
+impl JournalEntryRecordType {
+    /// # Safety
+    ///
+    /// `rykv` makes direct memory references to achieve high performance
+    /// however this does mean care must be taken that the data itself
+    /// can not be manipulated or corrupted.
+    pub unsafe fn deserialize_archive(self, data: &[u8]) -> anyhow::Result<JournalEntry<'_>> {
+        match self {
+            JournalEntryRecordType::InitModuleV1 => ArchivedJournalEntry::InitModuleV1(
+                rkyv::archived_root::<JournalEntryInitModuleV1>(data),
+            ),
+            JournalEntryRecordType::ClearEtherealV1 => {
+                ArchivedJournalEntry::ClearEtherealV1(rkyv::archived_root::<
+                    JournalEntryClearEtherealV1,
+                >(data))
+            }
+            JournalEntryRecordType::ProcessExitV1 => ArchivedJournalEntry::ProcessExitV1(
+                rkyv::archived_root::<JournalEntryProcessExitV1>(data),
+            ),
+            JournalEntryRecordType::SetThreadV1 => ArchivedJournalEntry::SetThreadV1(
+                rkyv::archived_root::<JournalEntrySetThreadV1>(data),
+            ),
+            JournalEntryRecordType::CloseThreadV1 => ArchivedJournalEntry::CloseThreadV1(
+                rkyv::archived_root::<JournalEntryCloseThreadV1>(data),
+            ),
+            JournalEntryRecordType::FileDescriptorSeekV1 => {
+                ArchivedJournalEntry::FileDescriptorSeekV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorSeekV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorWriteV1 => {
+                ArchivedJournalEntry::FileDescriptorWriteV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorWriteV1,
+                >(data))
+            }
+            JournalEntryRecordType::UpdateMemoryRegionV1 => {
+                ArchivedJournalEntry::UpdateMemoryRegionV1(rkyv::archived_root::<
+                    JournalEntryUpdateMemoryRegionV1,
+                >(data))
+            }
+            JournalEntryRecordType::SetClockTimeV1 => {
+                ArchivedJournalEntry::SetClockTimeV1(rkyv::archived_root::<
+                    JournalEntrySetClockTimeV1,
+                >(data))
+            }
+            JournalEntryRecordType::OpenFileDescriptorV1 => {
+                ArchivedJournalEntry::OpenFileDescriptorV1(rkyv::archived_root::<
+                    JournalEntryOpenFileDescriptorV1,
+                >(data))
+            }
+            JournalEntryRecordType::CloseFileDescriptorV1 => {
+                ArchivedJournalEntry::CloseFileDescriptorV1(rkyv::archived_root::<
+                    JournalEntryCloseFileDescriptorV1,
+                >(data))
+            }
+            JournalEntryRecordType::RenumberFileDescriptorV1 => {
+                ArchivedJournalEntry::RenumberFileDescriptorV1(rkyv::archived_root::<
+                    JournalEntryRenumberFileDescriptorV1,
+                >(data))
+            }
+            JournalEntryRecordType::DuplicateFileDescriptorV1 => {
+                ArchivedJournalEntry::DuplicateFileDescriptorV1(rkyv::archived_root::<
+                    JournalEntryDuplicateFileDescriptorV1,
+                >(data))
+            }
+            JournalEntryRecordType::CreateDirectoryV1 => {
+                ArchivedJournalEntry::CreateDirectoryV1(rkyv::archived_root::<
+                    JournalEntryCreateDirectoryV1,
+                >(data))
+            }
+            JournalEntryRecordType::RemoveDirectoryV1 => {
+                ArchivedJournalEntry::RemoveDirectoryV1(rkyv::archived_root::<
+                    JournalEntryRemoveDirectoryV1,
+                >(data))
+            }
+            JournalEntryRecordType::PathSetTimesV1 => {
+                ArchivedJournalEntry::PathSetTimesV1(rkyv::archived_root::<
+                    JournalEntryPathSetTimesV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorSetTimesV1 => {
+                ArchivedJournalEntry::FileDescriptorSetTimesV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorSetTimesV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorSetSizeV1 => {
+                ArchivedJournalEntry::FileDescriptorSetSizeV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorSetSizeV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorSetFlagsV1 => {
+                ArchivedJournalEntry::FileDescriptorSetFlagsV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorSetFlagsV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorSetRightsV1 => {
+                ArchivedJournalEntry::FileDescriptorSetRightsV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorSetRightsV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorAdviseV1 => {
+                ArchivedJournalEntry::FileDescriptorAdviseV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorAdviseV1,
+                >(data))
+            }
+            JournalEntryRecordType::FileDescriptorAllocateV1 => {
+                ArchivedJournalEntry::FileDescriptorAllocateV1(rkyv::archived_root::<
+                    JournalEntryFileDescriptorAllocateV1,
+                >(data))
+            }
+            JournalEntryRecordType::CreateHardLinkV1 => {
+                ArchivedJournalEntry::CreateHardLinkV1(rkyv::archived_root::<
+                    JournalEntryCreateHardLinkV1,
+                >(data))
+            }
+            JournalEntryRecordType::CreateSymbolicLinkV1 => {
+                ArchivedJournalEntry::CreateSymbolicLinkV1(rkyv::archived_root::<
+                    JournalEntryCreateSymbolicLinkV1,
+                >(data))
+            }
+            JournalEntryRecordType::UnlinkFileV1 => ArchivedJournalEntry::UnlinkFileV1(
+                rkyv::archived_root::<JournalEntryUnlinkFileV1>(data),
+            ),
+            JournalEntryRecordType::PathRenameV1 => ArchivedJournalEntry::PathRenameV1(
+                rkyv::archived_root::<JournalEntryPathRenameV1>(data),
+            ),
+            JournalEntryRecordType::ChangeDirectoryV1 => {
+                ArchivedJournalEntry::ChangeDirectoryV1(rkyv::archived_root::<
+                    JournalEntryChangeDirectoryV1,
+                >(data))
+            }
+            JournalEntryRecordType::EpollCreateV1 => ArchivedJournalEntry::EpollCreateV1(
+                rkyv::archived_root::<JournalEntryEpollCreateV1>(data),
+            ),
+            JournalEntryRecordType::EpollCtlV1 => ArchivedJournalEntry::EpollCtlV1(
+                rkyv::archived_root::<JournalEntryEpollCtlV1>(data),
+            ),
+            JournalEntryRecordType::TtySetV1 => {
+                ArchivedJournalEntry::TtySetV1(rkyv::archived_root::<JournalEntryTtySetV1>(data))
+            }
+            JournalEntryRecordType::CreatePipeV1 => ArchivedJournalEntry::CreatePipeV1(
+                rkyv::archived_root::<JournalEntryCreatePipeV1>(data),
+            ),
+            JournalEntryRecordType::CreateEventV1 => ArchivedJournalEntry::CreateEventV1(
+                rkyv::archived_root::<JournalEntryCreateEventV1>(data),
+            ),
+            JournalEntryRecordType::PortAddAddrV1 => ArchivedJournalEntry::PortAddAddrV1(
+                rkyv::archived_root::<JournalEntryPortAddAddrV1>(data),
+            ),
+            JournalEntryRecordType::PortDelAddrV1 => ArchivedJournalEntry::PortDelAddrV1(
+                rkyv::archived_root::<JournalEntryPortDelAddrV1>(data),
+            ),
+            JournalEntryRecordType::PortAddrClearV1 => return Ok(JournalEntry::PortAddrClearV1),
+            JournalEntryRecordType::PortBridgeV1 => ArchivedJournalEntry::PortBridgeV1(
+                rkyv::archived_root::<JournalEntryPortBridgeV1>(data),
+            ),
+            JournalEntryRecordType::PortUnbridgeV1 => return Ok(JournalEntry::PortUnbridgeV1),
+            JournalEntryRecordType::PortDhcpAcquireV1 => {
+                return Ok(JournalEntry::PortDhcpAcquireV1)
+            }
+            JournalEntryRecordType::PortGatewaySetV1 => {
+                ArchivedJournalEntry::PortGatewaySetV1(rkyv::archived_root::<
+                    JournalEntryPortGatewaySetV1,
+                >(data))
+            }
+            JournalEntryRecordType::PortRouteAddV1 => {
+                ArchivedJournalEntry::PortRouteAddV1(rkyv::archived_root::<
+                    JournalEntryPortRouteAddV1,
+                >(data))
+            }
+            JournalEntryRecordType::PortRouteClearV1 => return Ok(JournalEntry::PortRouteClearV1),
+            JournalEntryRecordType::PortRouteDelV1 => {
+                ArchivedJournalEntry::PortRouteDelV1(rkyv::archived_root::<
+                    JournalEntryPortRouteDelV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketOpenV1 => ArchivedJournalEntry::SocketOpenV1(
+                rkyv::archived_root::<JournalEntrySocketOpenV1>(data),
+            ),
+            JournalEntryRecordType::SocketListenV1 => {
+                ArchivedJournalEntry::SocketListenV1(rkyv::archived_root::<
+                    JournalEntrySocketListenV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketBindV1 => ArchivedJournalEntry::SocketBindV1(
+                rkyv::archived_root::<JournalEntrySocketBindV1>(data),
+            ),
+            JournalEntryRecordType::SocketConnectedV1 => {
+                ArchivedJournalEntry::SocketConnectedV1(rkyv::archived_root::<
+                    JournalEntrySocketConnectedV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketAcceptedV1 => {
+                ArchivedJournalEntry::SocketAcceptedV1(rkyv::archived_root::<
+                    JournalEntrySocketAcceptedV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketJoinIpv4MulticastV1 => {
+                ArchivedJournalEntry::SocketJoinIpv4MulticastV1(rkyv::archived_root::<
+                    JournalEntrySocketJoinIpv4MulticastV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketJoinIpv6MulticastV1 => {
+                ArchivedJournalEntry::SocketJoinIpv6MulticastV1(rkyv::archived_root::<
+                    JournalEntrySocketJoinIpv6MulticastV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketLeaveIpv4MulticastV1 => {
+                ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(rkyv::archived_root::<
+                    JournalEntrySocketLeaveIpv4MulticastV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketLeaveIpv6MulticastV1 => {
+                ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(rkyv::archived_root::<
+                    JournalEntrySocketLeaveIpv6MulticastV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketSendFileV1 => {
+                ArchivedJournalEntry::SocketSendFileV1(rkyv::archived_root::<
+                    JournalEntrySocketSendFileV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketSendToV1 => {
+                ArchivedJournalEntry::SocketSendToV1(rkyv::archived_root::<
+                    JournalEntrySocketSendToV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketSendV1 => ArchivedJournalEntry::SocketSendV1(
+                rkyv::archived_root::<JournalEntrySocketSendV1>(data),
+            ),
+            JournalEntryRecordType::SocketSetOptFlagV1 => {
+                ArchivedJournalEntry::SocketSetOptFlagV1(rkyv::archived_root::<
+                    JournalEntrySocketSetOptFlagV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketSetOptSizeV1 => {
+                ArchivedJournalEntry::SocketSetOptSizeV1(rkyv::archived_root::<
+                    JournalEntrySocketSetOptSizeV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketSetOptTimeV1 => {
+                ArchivedJournalEntry::SocketSetOptTimeV1(rkyv::archived_root::<
+                    JournalEntrySocketSetOptTimeV1,
+                >(data))
+            }
+            JournalEntryRecordType::SocketShutdownV1 => {
+                ArchivedJournalEntry::SocketShutdownV1(rkyv::archived_root::<
+                    JournalEntrySocketShutdownV1,
+                >(data))
+            }
+            JournalEntryRecordType::SnapshotV1 => ArchivedJournalEntry::SnapshotV1(
+                rkyv::archived_root::<JournalEntrySnapshotV1>(data),
+            ),
+        }
+        .try_into()
+    }
+}
+
+impl<'a> JournalEntry<'a> {
+    pub fn archive_record_type(&self) -> JournalEntryRecordType {
+        match self {
+            Self::InitModuleV1 { .. } => JournalEntryRecordType::InitModuleV1,
+            Self::ClearEtherealV1 { .. } => JournalEntryRecordType::ClearEtherealV1,
+            Self::UpdateMemoryRegionV1 { .. } => JournalEntryRecordType::UpdateMemoryRegionV1,
+            Self::ProcessExitV1 { .. } => JournalEntryRecordType::ProcessExitV1,
+            Self::SetThreadV1 { .. } => JournalEntryRecordType::SetThreadV1,
+            Self::CloseThreadV1 { .. } => JournalEntryRecordType::CloseThreadV1,
+            Self::FileDescriptorSeekV1 { .. } => JournalEntryRecordType::FileDescriptorSeekV1,
+            Self::FileDescriptorWriteV1 { .. } => JournalEntryRecordType::FileDescriptorWriteV1,
+            Self::SetClockTimeV1 { .. } => JournalEntryRecordType::SetClockTimeV1,
+            Self::CloseFileDescriptorV1 { .. } => JournalEntryRecordType::CloseFileDescriptorV1,
+            Self::OpenFileDescriptorV1 { .. } => JournalEntryRecordType::OpenFileDescriptorV1,
+            Self::RenumberFileDescriptorV1 { .. } => {
+                JournalEntryRecordType::RenumberFileDescriptorV1
+            }
+            Self::DuplicateFileDescriptorV1 { .. } => {
+                JournalEntryRecordType::DuplicateFileDescriptorV1
+            }
+            Self::CreateDirectoryV1 { .. } => JournalEntryRecordType::CreateDirectoryV1,
+            Self::RemoveDirectoryV1 { .. } => JournalEntryRecordType::RemoveDirectoryV1,
+            Self::PathSetTimesV1 { .. } => JournalEntryRecordType::PathSetTimesV1,
+            Self::FileDescriptorSetTimesV1 { .. } => {
+                JournalEntryRecordType::FileDescriptorSetTimesV1
+            }
+            Self::FileDescriptorSetFlagsV1 { .. } => {
+                JournalEntryRecordType::FileDescriptorSetFlagsV1
+            }
+            Self::FileDescriptorSetRightsV1 { .. } => {
+                JournalEntryRecordType::FileDescriptorSetRightsV1
+            }
+            Self::FileDescriptorSetSizeV1 { .. } => JournalEntryRecordType::FileDescriptorSetSizeV1,
+            Self::FileDescriptorAdviseV1 { .. } => JournalEntryRecordType::FileDescriptorAdviseV1,
+            Self::FileDescriptorAllocateV1 { .. } => {
+                JournalEntryRecordType::FileDescriptorAllocateV1
+            }
+            Self::CreateHardLinkV1 { .. } => JournalEntryRecordType::CreateHardLinkV1,
+            Self::CreateSymbolicLinkV1 { .. } => JournalEntryRecordType::CreateSymbolicLinkV1,
+            Self::UnlinkFileV1 { .. } => JournalEntryRecordType::UnlinkFileV1,
+            Self::PathRenameV1 { .. } => JournalEntryRecordType::PathRenameV1,
+            Self::ChangeDirectoryV1 { .. } => JournalEntryRecordType::ChangeDirectoryV1,
+            Self::EpollCreateV1 { .. } => JournalEntryRecordType::EpollCreateV1,
+            Self::EpollCtlV1 { .. } => JournalEntryRecordType::EpollCtlV1,
+            Self::TtySetV1 { .. } => JournalEntryRecordType::TtySetV1,
+            Self::CreatePipeV1 { .. } => JournalEntryRecordType::CreatePipeV1,
+            Self::CreateEventV1 { .. } => JournalEntryRecordType::CreateEventV1,
+            Self::PortAddAddrV1 { .. } => JournalEntryRecordType::PortAddAddrV1,
+            Self::PortDelAddrV1 { .. } => JournalEntryRecordType::PortDelAddrV1,
+            Self::PortAddrClearV1 => JournalEntryRecordType::PortAddrClearV1,
+            Self::PortBridgeV1 { .. } => JournalEntryRecordType::PortBridgeV1,
+            Self::PortUnbridgeV1 => JournalEntryRecordType::PortUnbridgeV1,
+            Self::PortDhcpAcquireV1 => JournalEntryRecordType::PortDhcpAcquireV1,
+            Self::PortGatewaySetV1 { .. } => JournalEntryRecordType::PortGatewaySetV1,
+            Self::PortRouteAddV1 { .. } => JournalEntryRecordType::PortRouteAddV1,
+            Self::PortRouteClearV1 => JournalEntryRecordType::PortRouteClearV1,
+            Self::PortRouteDelV1 { .. } => JournalEntryRecordType::PortRouteDelV1,
+            Self::SocketOpenV1 { .. } => JournalEntryRecordType::SocketOpenV1,
+            Self::SocketListenV1 { .. } => JournalEntryRecordType::SocketListenV1,
+            Self::SocketBindV1 { .. } => JournalEntryRecordType::SocketBindV1,
+            Self::SocketConnectedV1 { .. } => JournalEntryRecordType::SocketConnectedV1,
+            Self::SocketAcceptedV1 { .. } => JournalEntryRecordType::SocketAcceptedV1,
+            Self::SocketJoinIpv4MulticastV1 { .. } => {
+                JournalEntryRecordType::SocketJoinIpv4MulticastV1
+            }
+            Self::SocketJoinIpv6MulticastV1 { .. } => {
+                JournalEntryRecordType::SocketJoinIpv6MulticastV1
+            }
+            Self::SocketLeaveIpv4MulticastV1 { .. } => {
+                JournalEntryRecordType::SocketLeaveIpv4MulticastV1
+            }
+            Self::SocketLeaveIpv6MulticastV1 { .. } => {
+                JournalEntryRecordType::SocketLeaveIpv6MulticastV1
+            }
+            Self::SocketSendFileV1 { .. } => JournalEntryRecordType::SocketSendFileV1,
+            Self::SocketSendToV1 { .. } => JournalEntryRecordType::SocketSendToV1,
+            Self::SocketSendV1 { .. } => JournalEntryRecordType::SocketSendV1,
+            Self::SocketSetOptFlagV1 { .. } => JournalEntryRecordType::SocketSetOptFlagV1,
+            Self::SocketSetOptSizeV1 { .. } => JournalEntryRecordType::SocketSetOptSizeV1,
+            Self::SocketSetOptTimeV1 { .. } => JournalEntryRecordType::SocketSetOptTimeV1,
+            Self::SocketShutdownV1 { .. } => JournalEntryRecordType::SocketShutdownV1,
+            Self::SnapshotV1 { .. } => JournalEntryRecordType::SnapshotV1,
+        }
+    }
+
+    pub fn serialize_archive<T: Serializer + ScratchSpace>(
+        self,
+        serializer: &mut T,
+    ) -> anyhow::Result<usize>
+    where
+        T::Error: std::fmt::Display,
+    {
+        let amt = match self {
+            JournalEntry::InitModuleV1 { wasm_hash } => {
+                serializer.serialize_value(&JournalEntryInitModuleV1 { wasm_hash })
+            }
+            JournalEntry::ClearEtherealV1 => {
+                serializer.serialize_value(&JournalEntryClearEtherealV1 {})
+            }
+            JournalEntry::UpdateMemoryRegionV1 { region, data } => {
+                serializer.serialize_value(&JournalEntryUpdateMemoryRegionV1 {
+                    start: region.start,
+                    end: region.end,
+                    compressed_data: compress_prepend_size(data.as_ref()).into(),
+                })
+            }
+            JournalEntry::ProcessExitV1 { exit_code } => {
+                serializer.serialize_value(&JournalEntryProcessExitV1 {
+                    exit_code: exit_code.map(|e| e.into()),
+                })
+            }
+            JournalEntry::SetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                is_64bit,
+                start,
+                layout,
+            } => serializer.serialize_value(&JournalEntrySetThreadV1 {
+                id,
+                call_stack: call_stack.into(),
+                memory_stack: memory_stack.into(),
+                store_data: store_data.into(),
+                start: start.into(),
+                layout: layout.into(),
+                is_64bit,
+            }),
+            JournalEntry::CloseThreadV1 { id, exit_code } => {
+                serializer.serialize_value(&JournalEntryCloseThreadV1 {
+                    id,
+                    exit_code: exit_code.map(|e| e.into()),
+                })
+            }
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => serializer
+                .serialize_value(&JournalEntryFileDescriptorSeekV1 {
+                    fd,
+                    offset,
+                    whence: whence.into(),
+                }),
+            JournalEntry::FileDescriptorWriteV1 {
+                fd,
+                offset,
+                data,
+                is_64bit,
+            } => serializer.serialize_value(&JournalEntryFileDescriptorWriteV1 {
+                fd,
+                offset,
+                data: data.into(),
+                is_64bit,
+            }),
+            JournalEntry::SetClockTimeV1 { clock_id, time } => {
+                serializer.serialize_value(&JournalEntrySetClockTimeV1 {
+                    clock_id: clock_id.into(),
+                    time,
+                })
+            }
+            JournalEntry::CloseFileDescriptorV1 { fd } => {
+                serializer.serialize_value(&JournalEntryCloseFileDescriptorV1 { fd })
+            }
+            JournalEntry::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            } => serializer.serialize_value(&JournalEntryOpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path: path.into(),
+                o_flags: o_flags.bits(),
+                fs_rights_base: fs_rights_base.bits(),
+                fs_rights_inheriting: fs_rights_inheriting.bits(),
+                fs_flags: fs_flags.bits(),
+            }),
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                serializer.serialize_value(&JournalEntryRenumberFileDescriptorV1 { old_fd, new_fd })
+            }
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => serializer.serialize_value(&JournalEntryDuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            }),
+            JournalEntry::CreateDirectoryV1 { fd, path } => {
+                serializer.serialize_value(&JournalEntryCreateDirectoryV1 {
+                    fd,
+                    path: path.into(),
+                })
+            }
+            JournalEntry::RemoveDirectoryV1 { fd, path } => {
+                serializer.serialize_value(&JournalEntryRemoveDirectoryV1 {
+                    fd,
+                    path: path.into(),
+                })
+            }
+            JournalEntry::PathSetTimesV1 {
+                fd,
+                flags,
+                path,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => serializer.serialize_value(&JournalEntryPathSetTimesV1 {
+                fd,
+                flags,
+                path: path.into(),
+                st_atim,
+                st_mtim,
+                fst_flags: fst_flags.bits(),
+            }),
+            JournalEntry::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => serializer.serialize_value(&JournalEntryFileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags: fst_flags.bits(),
+            }),
+            JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
+                serializer.serialize_value(&JournalEntryFileDescriptorSetFlagsV1 {
+                    fd,
+                    flags: flags.bits(),
+                })
+            }
+            JournalEntry::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            } => serializer.serialize_value(&JournalEntryFileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base: fs_rights_base.bits(),
+                fs_rights_inheriting: fs_rights_inheriting.bits(),
+            }),
+            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
+                serializer.serialize_value(&JournalEntryFileDescriptorSetSizeV1 { fd, st_size })
+            }
+            JournalEntry::FileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice,
+            } => serializer.serialize_value(&JournalEntryFileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice: advice.into(),
+            }),
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => serializer
+                .serialize_value(&JournalEntryFileDescriptorAllocateV1 { fd, offset, len }),
+            JournalEntry::CreateHardLinkV1 {
+                old_fd,
+                old_path,
+                old_flags,
+                new_fd,
+                new_path,
+            } => serializer.serialize_value(&JournalEntryCreateHardLinkV1 {
+                old_fd,
+                old_path: old_path.into(),
+                old_flags,
+                new_fd,
+                new_path: new_path.into(),
+            }),
+            JournalEntry::CreateSymbolicLinkV1 {
+                old_path,
+                fd,
+                new_path,
+            } => serializer.serialize_value(&JournalEntryCreateSymbolicLinkV1 {
+                old_path: old_path.into(),
+                fd,
+                new_path: new_path.into(),
+            }),
+            JournalEntry::UnlinkFileV1 { fd, path } => {
+                serializer.serialize_value(&JournalEntryUnlinkFileV1 {
+                    fd,
+                    path: path.into(),
+                })
+            }
+            JournalEntry::PathRenameV1 {
+                old_fd,
+                old_path,
+                new_fd,
+                new_path,
+            } => serializer.serialize_value(&JournalEntryPathRenameV1 {
+                old_fd,
+                old_path: old_path.into(),
+                new_fd,
+                new_path: new_path.into(),
+            }),
+            JournalEntry::ChangeDirectoryV1 { path } => {
+                serializer.serialize_value(&JournalEntryChangeDirectoryV1 { path: path.into() })
+            }
+            JournalEntry::EpollCreateV1 { fd } => {
+                serializer.serialize_value(&JournalEntryEpollCreateV1 { fd })
+            }
+            JournalEntry::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            } => serializer.serialize_value(&JournalEntryEpollCtlV1 {
+                epfd,
+                op: op.into(),
+                fd,
+                event: event.map(|e| e.into()),
+            }),
+            JournalEntry::TtySetV1 { tty, line_feeds } => {
+                serializer.serialize_value(&JournalEntryTtySetV1 {
+                    cols: tty.cols,
+                    rows: tty.rows,
+                    width: tty.width,
+                    height: tty.height,
+                    stdin_tty: tty.stdin_tty,
+                    stdout_tty: tty.stdout_tty,
+                    stderr_tty: tty.stderr_tty,
+                    echo: tty.echo,
+                    line_buffered: tty.line_buffered,
+                    line_feeds,
+                })
+            }
+            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+                serializer.serialize_value(&JournalEntryCreatePipeV1 { fd1, fd2 })
+            }
+            JournalEntry::CreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            } => serializer.serialize_value(&JournalEntryCreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            }),
+            JournalEntry::PortAddAddrV1 { cidr } => {
+                serializer.serialize_value(&JournalEntryPortAddAddrV1 { cidr: cidr.into() })
+            }
+            JournalEntry::PortDelAddrV1 { addr } => {
+                serializer.serialize_value(&JournalEntryPortDelAddrV1 { addr })
+            }
+            JournalEntry::PortAddrClearV1 => serializer.serialize_value(&()),
+            JournalEntry::PortBridgeV1 {
+                network,
+                token,
+                security,
+            } => serializer.serialize_value(&JournalEntryPortBridgeV1 {
+                network: network.into(),
+                token: token.into(),
+                security: security.into(),
+            }),
+            JournalEntry::PortUnbridgeV1 => serializer.serialize_value(&()),
+            JournalEntry::PortDhcpAcquireV1 => serializer.serialize_value(&()),
+            JournalEntry::PortGatewaySetV1 { ip } => {
+                serializer.serialize_value(&JournalEntryPortGatewaySetV1 { ip })
+            }
+            JournalEntry::PortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            } => serializer.serialize_value(&JournalEntryPortRouteAddV1 {
+                cidr: cidr.into(),
+                via_router,
+                preferred_until,
+                expires_at,
+            }),
+            JournalEntry::PortRouteClearV1 => serializer.serialize_value(&()),
+            JournalEntry::PortRouteDelV1 { ip } => {
+                serializer.serialize_value(&JournalEntryPortRouteDelV1 { ip })
+            }
+            JournalEntry::SocketOpenV1 { af, ty, pt, fd } => {
+                serializer.serialize_value(&JournalEntrySocketOpenV1 {
+                    af: af.into(),
+                    ty: ty.into(),
+                    pt: pt.into(),
+                    fd,
+                })
+            }
+            JournalEntry::SocketListenV1 { fd, backlog } => {
+                serializer.serialize_value(&JournalEntrySocketListenV1 { fd, backlog })
+            }
+            JournalEntry::SocketBindV1 { fd, addr } => {
+                serializer.serialize_value(&JournalEntrySocketBindV1 { fd, addr })
+            }
+            JournalEntry::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            } => serializer.serialize_value(&JournalEntrySocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            }),
+            JournalEntry::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr: addr,
+                peer_addr,
+                fd_flags,
+                non_blocking: nonblocking,
+            } => serializer.serialize_value(&JournalEntrySocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr: addr,
+                peer_addr,
+                fd_flags: fd_flags.bits(),
+                nonblocking,
+            }),
+            JournalEntry::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            } => serializer.serialize_value(&JournalEntrySocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            }),
+            JournalEntry::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => serializer.serialize_value(&JournalEntrySocketJoinIpv6MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            }),
+            JournalEntry::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => serializer.serialize_value(&JournalEntrySocketLeaveIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            }),
+            JournalEntry::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => serializer.serialize_value(&JournalEntrySocketLeaveIpv6MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            }),
+            JournalEntry::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            } => serializer.serialize_value(&JournalEntrySocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            }),
+            JournalEntry::SocketSendToV1 {
+                fd,
+                data,
+                flags,
+                addr,
+                is_64bit,
+            } => serializer.serialize_value(&JournalEntrySocketSendToV1 {
+                fd,
+                data: data.into(),
+                flags,
+                addr,
+                is_64bit,
+            }),
+            JournalEntry::SocketSendV1 {
+                fd,
+                data,
+                flags,
+                is_64bit,
+            } => serializer.serialize_value(&JournalEntrySocketSendV1 {
+                fd,
+                data: data.into(),
+                flags,
+                is_64bit,
+            }),
+            JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => {
+                serializer.serialize_value(&JournalEntrySocketSetOptFlagV1 {
+                    fd,
+                    opt: opt.into(),
+                    flag,
+                })
+            }
+            JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => {
+                serializer.serialize_value(&JournalEntrySocketSetOptSizeV1 {
+                    fd,
+                    opt: opt.into(),
+                    size,
+                })
+            }
+            JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => {
+                serializer.serialize_value(&JournalEntrySocketSetOptTimeV1 {
+                    fd,
+                    ty: ty.into(),
+                    time,
+                })
+            }
+            JournalEntry::SocketShutdownV1 { fd, how } => {
+                serializer.serialize_value(&JournalEntrySocketShutdownV1 {
+                    fd,
+                    how: how.into(),
+                })
+            }
+            JournalEntry::SnapshotV1 { when, trigger } => {
+                serializer.serialize_value(&JournalEntrySnapshotV1 {
+                    since_epoch: when
+                        .duration_since(SystemTime::UNIX_EPOCH)
+                        .unwrap_or(Duration::ZERO),
+                    trigger: trigger.into(),
+                })
+            }
+        }
+        .map_err(|err| anyhow::format_err!("failed to serialize journal record - {}", err))?;
+        Ok(amt)
+    }
+}
+
+/// The journal log entries are serializable which
+/// allows them to be written directly to a file
+///
+/// Note: This structure is versioned which allows for
+/// changes to the journal entry types without having to
+/// worry about backward and forward compatibility
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub(crate) struct JournalEntryHeader {
+    pub record_type: u16,
+    pub record_size: u64,
+}
+
+pub enum ArchivedJournalEntry<'a> {
+    InitModuleV1(&'a ArchivedJournalEntryInitModuleV1),
+    ClearEtherealV1(&'a ArchivedJournalEntryClearEtherealV1),
+    ProcessExitV1(&'a ArchivedJournalEntryProcessExitV1),
+    SetThreadV1(&'a ArchivedJournalEntrySetThreadV1<'a>),
+    CloseThreadV1(&'a ArchivedJournalEntryCloseThreadV1),
+    FileDescriptorSeekV1(&'a ArchivedJournalEntryFileDescriptorSeekV1),
+    FileDescriptorWriteV1(&'a ArchivedJournalEntryFileDescriptorWriteV1<'a>),
+    UpdateMemoryRegionV1(&'a ArchivedJournalEntryUpdateMemoryRegionV1<'a>),
+    SetClockTimeV1(&'a ArchivedJournalEntrySetClockTimeV1),
+    OpenFileDescriptorV1(&'a ArchivedJournalEntryOpenFileDescriptorV1<'a>),
+    CloseFileDescriptorV1(&'a ArchivedJournalEntryCloseFileDescriptorV1),
+    RenumberFileDescriptorV1(&'a ArchivedJournalEntryRenumberFileDescriptorV1),
+    DuplicateFileDescriptorV1(&'a ArchivedJournalEntryDuplicateFileDescriptorV1),
+    CreateDirectoryV1(&'a ArchivedJournalEntryCreateDirectoryV1<'a>),
+    RemoveDirectoryV1(&'a ArchivedJournalEntryRemoveDirectoryV1<'a>),
+    PathSetTimesV1(&'a ArchivedJournalEntryPathSetTimesV1<'a>),
+    FileDescriptorSetTimesV1(&'a ArchivedJournalEntryFileDescriptorSetTimesV1),
+    FileDescriptorSetSizeV1(&'a ArchivedJournalEntryFileDescriptorSetSizeV1),
+    FileDescriptorSetFlagsV1(&'a ArchivedJournalEntryFileDescriptorSetFlagsV1),
+    FileDescriptorSetRightsV1(&'a ArchivedJournalEntryFileDescriptorSetRightsV1),
+    FileDescriptorAdviseV1(&'a ArchivedJournalEntryFileDescriptorAdviseV1),
+    FileDescriptorAllocateV1(&'a ArchivedJournalEntryFileDescriptorAllocateV1),
+    CreateHardLinkV1(&'a ArchivedJournalEntryCreateHardLinkV1<'a>),
+    CreateSymbolicLinkV1(&'a ArchivedJournalEntryCreateSymbolicLinkV1<'a>),
+    UnlinkFileV1(&'a ArchivedJournalEntryUnlinkFileV1<'a>),
+    PathRenameV1(&'a ArchivedJournalEntryPathRenameV1<'a>),
+    ChangeDirectoryV1(&'a ArchivedJournalEntryChangeDirectoryV1<'a>),
+    EpollCreateV1(&'a ArchivedJournalEntryEpollCreateV1),
+    EpollCtlV1(&'a ArchivedJournalEntryEpollCtlV1),
+    TtySetV1(&'a ArchivedJournalEntryTtySetV1),
+    CreatePipeV1(&'a ArchivedJournalEntryCreatePipeV1),
+    CreateEventV1(&'a ArchivedJournalEntryCreateEventV1),
+    PortAddAddrV1(&'a ArchivedJournalEntryPortAddAddrV1),
+    PortDelAddrV1(&'a ArchivedJournalEntryPortDelAddrV1),
+    PortAddrClearV1,
+    PortBridgeV1(&'a ArchivedJournalEntryPortBridgeV1<'a>),
+    PortUnbridgeV1,
+    PortDhcpAcquireV1,
+    PortGatewaySetV1(&'a ArchivedJournalEntryPortGatewaySetV1),
+    PortRouteAddV1(&'a ArchivedJournalEntryPortRouteAddV1),
+    PortRouteClearV1,
+    PortRouteDelV1(&'a ArchivedJournalEntryPortRouteDelV1),
+    SocketOpenV1(&'a ArchivedJournalEntrySocketOpenV1),
+    SocketListenV1(&'a ArchivedJournalEntrySocketListenV1),
+    SocketBindV1(&'a ArchivedJournalEntrySocketBindV1),
+    SocketConnectedV1(&'a ArchivedJournalEntrySocketConnectedV1),
+    SocketAcceptedV1(&'a ArchivedJournalEntrySocketAcceptedV1),
+    SocketJoinIpv4MulticastV1(&'a ArchivedJournalEntrySocketJoinIpv4MulticastV1),
+    SocketJoinIpv6MulticastV1(&'a ArchivedJournalEntrySocketJoinIpv6MulticastV1),
+    SocketLeaveIpv4MulticastV1(&'a ArchivedJournalEntrySocketLeaveIpv4MulticastV1),
+    SocketLeaveIpv6MulticastV1(&'a ArchivedJournalEntrySocketLeaveIpv6MulticastV1),
+    SocketSendFileV1(&'a ArchivedJournalEntrySocketSendFileV1),
+    SocketSendToV1(&'a ArchivedJournalEntrySocketSendToV1<'a>),
+    SocketSendV1(&'a ArchivedJournalEntrySocketSendV1<'a>),
+    SocketSetOptFlagV1(&'a ArchivedJournalEntrySocketSetOptFlagV1),
+    SocketSetOptSizeV1(&'a ArchivedJournalEntrySocketSetOptSizeV1),
+    SocketSetOptTimeV1(&'a ArchivedJournalEntrySocketSetOptTimeV1),
+    SocketShutdownV1(&'a ArchivedJournalEntrySocketShutdownV1),
+    SnapshotV1(&'a ArchivedJournalEntrySnapshotV1),
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryInitModuleV1 {
+    pub wasm_hash: [u8; 8],
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryClearEtherealV1 {}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryProcessExitV1 {
+    pub exit_code: Option<JournalExitCodeV1>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySetThreadV1<'a> {
+    pub id: u32,
+    pub call_stack: AlignedCowVec<'a, u8>,
+    pub memory_stack: AlignedCowVec<'a, u8>,
+    pub store_data: AlignedCowVec<'a, u8>,
+    pub start: JournalThreadStartTypeV1,
+    pub layout: JournalWasiMemoryLayout,
+    pub is_64bit: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCloseThreadV1 {
+    pub id: u32,
+    pub exit_code: Option<JournalExitCodeV1>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorSeekV1 {
+    pub fd: u32,
+    pub whence: JournalWhenceV1,
+    pub offset: i64,
+}
+
+/// WARNING!!!! Do not change this structure without updating
+/// "/lib/cli/src/commands/journal/mount/fs.rs"
+///
+/// The code over there assumes that the aligned vector is the
+/// first item in the serialized entry
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorWriteV1<'a> {
+    /// DO NOT MOVE!
+    pub data: AlignedCowVec<'a, u8>,
+    pub offset: u64,
+    pub fd: u32,
+    pub is_64bit: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryUpdateMemoryRegionV1<'a> {
+    pub compressed_data: AlignedCowVec<'a, u8>,
+    pub start: u64,
+    pub end: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySetClockTimeV1 {
+    pub clock_id: JournalSnapshot0ClockidV1,
+    pub time: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryOpenFileDescriptorV1<'a> {
+    pub fd: u32,
+    pub dirfd: u32,
+    pub dirflags: u32,
+    pub fs_flags: u16,
+    pub o_flags: u16,
+    pub fs_rights_base: u64,
+    pub fs_rights_inheriting: u64,
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCloseFileDescriptorV1 {
+    pub fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryRenumberFileDescriptorV1 {
+    pub old_fd: u32,
+    pub new_fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryDuplicateFileDescriptorV1 {
+    pub original_fd: u32,
+    pub copied_fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCreateDirectoryV1<'a> {
+    pub fd: u32,
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryRemoveDirectoryV1<'a> {
+    pub fd: u32,
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPathSetTimesV1<'a> {
+    pub fd: u32,
+    pub flags: u32,
+    pub path: AlignedCowStr<'a>,
+    pub st_atim: u64,
+    pub st_mtim: u64,
+    pub fst_flags: u16,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorSetTimesV1 {
+    pub fd: u32,
+    pub fst_flags: u16,
+    pub st_atim: u64,
+    pub st_mtim: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorSetSizeV1 {
+    pub fd: u32,
+    pub st_size: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorSetFlagsV1 {
+    pub fd: u32,
+    pub flags: u16,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorSetRightsV1 {
+    pub fd: u32,
+    pub fs_rights_base: u64,
+    pub fs_rights_inheriting: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorAdviseV1 {
+    pub fd: u32,
+    pub offset: u64,
+    pub len: u64,
+    pub advice: JournalAdviceV1,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryFileDescriptorAllocateV1 {
+    pub fd: u32,
+    pub offset: u64,
+    pub len: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCreateHardLinkV1<'a> {
+    pub old_fd: u32,
+    pub old_path: AlignedCowStr<'a>,
+    pub old_flags: u32,
+    pub new_fd: u32,
+    pub new_path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCreateSymbolicLinkV1<'a> {
+    pub fd: u32,
+    pub old_path: AlignedCowStr<'a>,
+    pub new_path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryUnlinkFileV1<'a> {
+    pub fd: u32,
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPathRenameV1<'a> {
+    pub old_fd: u32,
+    pub old_path: AlignedCowStr<'a>,
+    pub new_fd: u32,
+    pub new_path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryChangeDirectoryV1<'a> {
+    pub path: AlignedCowStr<'a>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryEpollCreateV1 {
+    pub fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryEpollCtlV1 {
+    pub epfd: u32,
+    pub op: JournalEpollCtlV1,
+    pub fd: u32,
+    pub event: Option<JournalEpollEventCtlV1>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryTtySetV1 {
+    pub cols: u32,
+    pub rows: u32,
+    pub width: u32,
+    pub height: u32,
+    pub stdin_tty: bool,
+    pub stdout_tty: bool,
+    pub stderr_tty: bool,
+    pub echo: bool,
+    pub line_buffered: bool,
+    pub line_feeds: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCreatePipeV1 {
+    pub fd1: u32,
+    pub fd2: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryCreateEventV1 {
+    pub initial_val: u64,
+    pub flags: u16,
+    pub fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortAddAddrV1 {
+    pub cidr: JournalIpCidrV1,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortDelAddrV1 {
+    pub addr: IpAddr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortBridgeV1<'a> {
+    pub network: AlignedCowStr<'a>,
+    pub token: AlignedCowStr<'a>,
+    pub security: JournalStreamSecurityV1,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortGatewaySetV1 {
+    pub ip: IpAddr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortRouteAddV1 {
+    pub cidr: JournalIpCidrV1,
+    pub via_router: IpAddr,
+    pub preferred_until: Option<Duration>,
+    pub expires_at: Option<Duration>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntryPortRouteDelV1 {
+    pub ip: IpAddr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketOpenV1 {
+    pub af: JournalAddressfamilyV1,
+    pub ty: JournalSocktypeV1,
+    pub pt: u16,
+    pub fd: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketListenV1 {
+    pub fd: u32,
+    pub backlog: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketBindV1 {
+    pub fd: u32,
+    pub addr: SocketAddr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketConnectedV1 {
+    pub fd: u32,
+    pub local_addr: SocketAddr,
+    pub peer_addr: SocketAddr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketAcceptedV1 {
+    pub listen_fd: u32,
+    pub fd: u32,
+    pub local_addr: SocketAddr,
+    pub peer_addr: SocketAddr,
+    pub fd_flags: u16,
+    pub nonblocking: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketJoinIpv4MulticastV1 {
+    pub fd: u32,
+    pub multiaddr: Ipv4Addr,
+    pub iface: Ipv4Addr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketJoinIpv6MulticastV1 {
+    pub fd: u32,
+    pub multiaddr: Ipv6Addr,
+    pub iface: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketLeaveIpv4MulticastV1 {
+    pub fd: u32,
+    pub multiaddr: Ipv4Addr,
+    pub iface: Ipv4Addr,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketLeaveIpv6MulticastV1 {
+    pub fd: u32,
+    pub multiaddr: Ipv6Addr,
+    pub iface: u32,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSendFileV1 {
+    pub socket_fd: u32,
+    pub file_fd: u32,
+    pub offset: u64,
+    pub count: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSendToV1<'a> {
+    pub fd: u32,
+    pub data: AlignedCowVec<'a, u8>,
+    pub flags: u16,
+    pub addr: SocketAddr,
+    pub is_64bit: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSendV1<'a> {
+    pub fd: u32,
+    pub data: AlignedCowVec<'a, u8>,
+    pub flags: u16,
+    pub is_64bit: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSetOptFlagV1 {
+    pub fd: u32,
+    pub opt: JournalSockoptionV1,
+    pub flag: bool,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSetOptSizeV1 {
+    pub fd: u32,
+    pub opt: JournalSockoptionV1,
+    pub size: u64,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketSetOptTimeV1 {
+    pub fd: u32,
+    pub ty: JournalTimeTypeV1,
+    pub time: Option<Duration>,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySocketShutdownV1 {
+    pub fd: u32,
+    pub how: JournalSocketShutdownV1,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalEntrySnapshotV1 {
+    pub since_epoch: Duration,
+    pub trigger: JournalSnapshotTriggerV1,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalSnapshot0ClockidV1 {
+    Realtime,
+    Monotonic,
+    ProcessCputimeId,
+    ThreadCputimeId,
+    Unknown = 255,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalWhenceV1 {
+    Set,
+    Cur,
+    End,
+    Unknown = 255,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalAdviceV1 {
+    Normal,
+    Sequential,
+    Random,
+    Willneed,
+    Dontneed,
+    Noreuse,
+    Unknown = 255,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct JournalIpCidrV1 {
+    pub ip: IpAddr,
+    pub prefix: u8,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalExitCodeV1 {
+    Errno(u16),
+    Other(i32),
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalSnapshotTriggerV1 {
+    Idle,
+    Listen,
+    Environ,
+    Stdin,
+    Timer,
+    Sigint,
+    Sigalrm,
+    Sigtstp,
+    Sigstop,
+    NonDeterministicCall,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalEpollCtlV1 {
+    Add,
+    Mod,
+    Del,
+    Unknown,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct JournalEpollEventCtlV1 {
+    pub events: u32,
+    pub ptr: u64,
+    pub fd: u32,
+    pub data1: u32,
+    pub data2: u64,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalStreamSecurityV1 {
+    Unencrypted,
+    AnyEncryption,
+    ClassicEncryption,
+    DoubleEncryption,
+    Unknown,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalAddressfamilyV1 {
+    Unspec,
+    Inet4,
+    Inet6,
+    Unix,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalSocktypeV1 {
+    Unknown,
+    Stream,
+    Dgram,
+    Raw,
+    Seqpacket,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalSockoptionV1 {
+    Noop,
+    ReusePort,
+    ReuseAddr,
+    NoDelay,
+    DontRoute,
+    OnlyV6,
+    Broadcast,
+    MulticastLoopV4,
+    MulticastLoopV6,
+    Promiscuous,
+    Listening,
+    LastError,
+    KeepAlive,
+    Linger,
+    OobInline,
+    RecvBufSize,
+    SendBufSize,
+    RecvLowat,
+    SendLowat,
+    RecvTimeout,
+    SendTimeout,
+    ConnectTimeout,
+    AcceptTimeout,
+    Ttl,
+    MulticastTtlV4,
+    Type,
+    Proto,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalTimeTypeV1 {
+    ReadTimeout,
+    WriteTimeout,
+    AcceptTimeout,
+    ConnectTimeout,
+    BindTimeout,
+    Linger,
+}
+
+#[repr(C)]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+)]
+#[archive_attr(derive(CheckBytes))]
+pub enum JournalSocketShutdownV1 {
+    Read,
+    Write,
+    Both,
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    PartialOrd,
+    Ord,
+    PartialEq,
+    Eq,
+    Hash,
+)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub enum JournalThreadStartTypeV1 {
+    MainThread,
+    ThreadSpawn { start_ptr: u64 },
+}
+
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Clone, Copy, RkyvSerialize, RkyvDeserialize, Archive, PartialEq, Eq, Hash)]
+#[archive_attr(derive(CheckBytes), repr(align(8)))]
+pub struct JournalWasiMemoryLayout {
+    pub stack_upper: u64,
+    pub stack_lower: u64,
+    pub guard_size: u64,
+    pub stack_size: u64,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived_from.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived_from.rs
new file mode 100644
index 0000000..1e76643
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/archived_from.rs
@@ -0,0 +1,1171 @@
+use lz4_flex::block::decompress_size_prepended;
+use std::borrow::Cow;
+use std::time::SystemTime;
+use wasmer_wasix_types::wasi;
+use wasmer_wasix_types::wasix::{ThreadStartType, WasiMemoryLayout};
+
+use super::*;
+
+impl From<wasi::Snapshot0Clockid> for JournalSnapshot0ClockidV1 {
+    fn from(val: wasi::Snapshot0Clockid) -> Self {
+        match val {
+            wasi::Snapshot0Clockid::Realtime => JournalSnapshot0ClockidV1::Realtime,
+            wasi::Snapshot0Clockid::Monotonic => JournalSnapshot0ClockidV1::Monotonic,
+            wasi::Snapshot0Clockid::ProcessCputimeId => JournalSnapshot0ClockidV1::ProcessCputimeId,
+            wasi::Snapshot0Clockid::ThreadCputimeId => JournalSnapshot0ClockidV1::ThreadCputimeId,
+            wasi::Snapshot0Clockid::Unknown => JournalSnapshot0ClockidV1::Unknown,
+        }
+    }
+}
+
+impl From<JournalSnapshot0ClockidV1> for wasi::Snapshot0Clockid {
+    fn from(val: JournalSnapshot0ClockidV1) -> Self {
+        match val {
+            JournalSnapshot0ClockidV1::Realtime => wasi::Snapshot0Clockid::Realtime,
+            JournalSnapshot0ClockidV1::Monotonic => wasi::Snapshot0Clockid::Monotonic,
+            JournalSnapshot0ClockidV1::ProcessCputimeId => wasi::Snapshot0Clockid::ProcessCputimeId,
+            JournalSnapshot0ClockidV1::ThreadCputimeId => wasi::Snapshot0Clockid::ThreadCputimeId,
+            JournalSnapshot0ClockidV1::Unknown => wasi::Snapshot0Clockid::Unknown,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalSnapshot0ClockidV1> for wasi::Snapshot0Clockid {
+    fn from(val: &'_ ArchivedJournalSnapshot0ClockidV1) -> Self {
+        match val {
+            ArchivedJournalSnapshot0ClockidV1::Realtime => wasi::Snapshot0Clockid::Realtime,
+            ArchivedJournalSnapshot0ClockidV1::Monotonic => wasi::Snapshot0Clockid::Monotonic,
+            ArchivedJournalSnapshot0ClockidV1::ProcessCputimeId => {
+                wasi::Snapshot0Clockid::ProcessCputimeId
+            }
+            ArchivedJournalSnapshot0ClockidV1::ThreadCputimeId => {
+                wasi::Snapshot0Clockid::ThreadCputimeId
+            }
+            ArchivedJournalSnapshot0ClockidV1::Unknown => wasi::Snapshot0Clockid::Unknown,
+        }
+    }
+}
+
+impl From<wasi::Whence> for JournalWhenceV1 {
+    fn from(val: wasi::Whence) -> Self {
+        match val {
+            wasi::Whence::Set => JournalWhenceV1::Set,
+            wasi::Whence::Cur => JournalWhenceV1::Cur,
+            wasi::Whence::End => JournalWhenceV1::End,
+            wasi::Whence::Unknown => JournalWhenceV1::Unknown,
+        }
+    }
+}
+
+impl From<JournalWhenceV1> for wasi::Whence {
+    fn from(val: JournalWhenceV1) -> Self {
+        match val {
+            JournalWhenceV1::Set => wasi::Whence::Set,
+            JournalWhenceV1::Cur => wasi::Whence::Cur,
+            JournalWhenceV1::End => wasi::Whence::End,
+            JournalWhenceV1::Unknown => wasi::Whence::Unknown,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalWhenceV1> for wasi::Whence {
+    fn from(val: &'_ ArchivedJournalWhenceV1) -> Self {
+        match val {
+            ArchivedJournalWhenceV1::Set => wasi::Whence::Set,
+            ArchivedJournalWhenceV1::Cur => wasi::Whence::Cur,
+            ArchivedJournalWhenceV1::End => wasi::Whence::End,
+            ArchivedJournalWhenceV1::Unknown => wasi::Whence::Unknown,
+        }
+    }
+}
+
+impl From<wasi::Advice> for JournalAdviceV1 {
+    fn from(val: wasi::Advice) -> Self {
+        match val {
+            wasi::Advice::Normal => JournalAdviceV1::Normal,
+            wasi::Advice::Sequential => JournalAdviceV1::Sequential,
+            wasi::Advice::Random => JournalAdviceV1::Random,
+            wasi::Advice::Willneed => JournalAdviceV1::Willneed,
+            wasi::Advice::Dontneed => JournalAdviceV1::Dontneed,
+            wasi::Advice::Noreuse => JournalAdviceV1::Noreuse,
+            wasi::Advice::Unknown => JournalAdviceV1::Unknown,
+        }
+    }
+}
+
+impl From<JournalAdviceV1> for wasi::Advice {
+    fn from(val: JournalAdviceV1) -> Self {
+        match val {
+            JournalAdviceV1::Normal => wasi::Advice::Normal,
+            JournalAdviceV1::Sequential => wasi::Advice::Sequential,
+            JournalAdviceV1::Random => wasi::Advice::Random,
+            JournalAdviceV1::Willneed => wasi::Advice::Willneed,
+            JournalAdviceV1::Dontneed => wasi::Advice::Dontneed,
+            JournalAdviceV1::Noreuse => wasi::Advice::Noreuse,
+            JournalAdviceV1::Unknown => wasi::Advice::Unknown,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalAdviceV1> for wasi::Advice {
+    fn from(val: &'_ ArchivedJournalAdviceV1) -> Self {
+        match val {
+            ArchivedJournalAdviceV1::Normal => wasi::Advice::Normal,
+            ArchivedJournalAdviceV1::Sequential => wasi::Advice::Sequential,
+            ArchivedJournalAdviceV1::Random => wasi::Advice::Random,
+            ArchivedJournalAdviceV1::Willneed => wasi::Advice::Willneed,
+            ArchivedJournalAdviceV1::Dontneed => wasi::Advice::Dontneed,
+            ArchivedJournalAdviceV1::Noreuse => wasi::Advice::Noreuse,
+            ArchivedJournalAdviceV1::Unknown => wasi::Advice::Unknown,
+        }
+    }
+}
+
+impl From<virtual_net::IpCidr> for JournalIpCidrV1 {
+    fn from(value: virtual_net::IpCidr) -> Self {
+        Self {
+            ip: value.ip,
+            prefix: value.prefix,
+        }
+    }
+}
+
+impl From<JournalIpCidrV1> for virtual_net::IpCidr {
+    fn from(value: JournalIpCidrV1) -> Self {
+        Self {
+            ip: value.ip,
+            prefix: value.prefix,
+        }
+    }
+}
+
+impl From<wasi::ExitCode> for JournalExitCodeV1 {
+    fn from(val: wasi::ExitCode) -> Self {
+        match val {
+            wasi::ExitCode::Errno(errno) => JournalExitCodeV1::Errno(errno as u16),
+            wasi::ExitCode::Other(id) => JournalExitCodeV1::Other(id),
+        }
+    }
+}
+
+impl From<JournalExitCodeV1> for wasi::ExitCode {
+    fn from(val: JournalExitCodeV1) -> Self {
+        match val {
+            JournalExitCodeV1::Errno(errno) => {
+                wasi::ExitCode::Errno(errno.try_into().unwrap_or(wasi::Errno::Unknown))
+            }
+            JournalExitCodeV1::Other(id) => wasi::ExitCode::Other(id),
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalExitCodeV1> for wasi::ExitCode {
+    fn from(val: &'_ ArchivedJournalExitCodeV1) -> Self {
+        match val {
+            ArchivedJournalExitCodeV1::Errno(errno) => {
+                wasi::ExitCode::Errno((*errno).try_into().unwrap_or(wasi::Errno::Unknown))
+            }
+            ArchivedJournalExitCodeV1::Other(id) => wasi::ExitCode::Other(*id),
+        }
+    }
+}
+
+impl From<SnapshotTrigger> for JournalSnapshotTriggerV1 {
+    fn from(val: SnapshotTrigger) -> Self {
+        match val {
+            SnapshotTrigger::Idle => JournalSnapshotTriggerV1::Idle,
+            SnapshotTrigger::FirstListen => JournalSnapshotTriggerV1::Listen,
+            SnapshotTrigger::FirstEnviron => JournalSnapshotTriggerV1::Environ,
+            SnapshotTrigger::FirstStdin => JournalSnapshotTriggerV1::Stdin,
+            SnapshotTrigger::FirstSigint => JournalSnapshotTriggerV1::Sigint,
+            SnapshotTrigger::PeriodicInterval => JournalSnapshotTriggerV1::Timer,
+            SnapshotTrigger::Sigint => JournalSnapshotTriggerV1::Sigint,
+            SnapshotTrigger::Sigalrm => JournalSnapshotTriggerV1::Sigalrm,
+            SnapshotTrigger::Sigtstp => JournalSnapshotTriggerV1::Sigtstp,
+            SnapshotTrigger::Sigstop => JournalSnapshotTriggerV1::Sigstop,
+            SnapshotTrigger::NonDeterministicCall => JournalSnapshotTriggerV1::NonDeterministicCall,
+        }
+    }
+}
+
+impl From<JournalSnapshotTriggerV1> for SnapshotTrigger {
+    fn from(val: JournalSnapshotTriggerV1) -> Self {
+        match val {
+            JournalSnapshotTriggerV1::Idle => SnapshotTrigger::Idle,
+            JournalSnapshotTriggerV1::Listen => SnapshotTrigger::FirstListen,
+            JournalSnapshotTriggerV1::Environ => SnapshotTrigger::FirstEnviron,
+            JournalSnapshotTriggerV1::Stdin => SnapshotTrigger::FirstStdin,
+            JournalSnapshotTriggerV1::Timer => SnapshotTrigger::PeriodicInterval,
+            JournalSnapshotTriggerV1::Sigint => SnapshotTrigger::Sigint,
+            JournalSnapshotTriggerV1::Sigalrm => SnapshotTrigger::Sigalrm,
+            JournalSnapshotTriggerV1::Sigtstp => SnapshotTrigger::Sigtstp,
+            JournalSnapshotTriggerV1::Sigstop => SnapshotTrigger::Sigstop,
+            JournalSnapshotTriggerV1::NonDeterministicCall => SnapshotTrigger::NonDeterministicCall,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalSnapshotTriggerV1> for SnapshotTrigger {
+    fn from(val: &'_ ArchivedJournalSnapshotTriggerV1) -> Self {
+        match val {
+            ArchivedJournalSnapshotTriggerV1::Idle => SnapshotTrigger::Idle,
+            ArchivedJournalSnapshotTriggerV1::Listen => SnapshotTrigger::FirstListen,
+            ArchivedJournalSnapshotTriggerV1::Environ => SnapshotTrigger::FirstEnviron,
+            ArchivedJournalSnapshotTriggerV1::Stdin => SnapshotTrigger::FirstStdin,
+            ArchivedJournalSnapshotTriggerV1::Timer => SnapshotTrigger::PeriodicInterval,
+            ArchivedJournalSnapshotTriggerV1::Sigint => SnapshotTrigger::Sigint,
+            ArchivedJournalSnapshotTriggerV1::Sigalrm => SnapshotTrigger::Sigalrm,
+            ArchivedJournalSnapshotTriggerV1::Sigtstp => SnapshotTrigger::Sigtstp,
+            ArchivedJournalSnapshotTriggerV1::Sigstop => SnapshotTrigger::Sigstop,
+            ArchivedJournalSnapshotTriggerV1::NonDeterministicCall => {
+                SnapshotTrigger::NonDeterministicCall
+            }
+        }
+    }
+}
+
+impl From<wasi::EpollCtl> for JournalEpollCtlV1 {
+    fn from(val: wasi::EpollCtl) -> Self {
+        match val {
+            wasi::EpollCtl::Add => JournalEpollCtlV1::Add,
+            wasi::EpollCtl::Mod => JournalEpollCtlV1::Mod,
+            wasi::EpollCtl::Del => JournalEpollCtlV1::Del,
+            wasi::EpollCtl::Unknown => JournalEpollCtlV1::Unknown,
+        }
+    }
+}
+
+impl From<JournalEpollCtlV1> for wasi::EpollCtl {
+    fn from(val: JournalEpollCtlV1) -> Self {
+        match val {
+            JournalEpollCtlV1::Add => wasi::EpollCtl::Add,
+            JournalEpollCtlV1::Mod => wasi::EpollCtl::Mod,
+            JournalEpollCtlV1::Del => wasi::EpollCtl::Del,
+            JournalEpollCtlV1::Unknown => wasi::EpollCtl::Unknown,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalEpollCtlV1> for wasi::EpollCtl {
+    fn from(val: &'_ ArchivedJournalEpollCtlV1) -> Self {
+        match val {
+            ArchivedJournalEpollCtlV1::Add => wasi::EpollCtl::Add,
+            ArchivedJournalEpollCtlV1::Mod => wasi::EpollCtl::Mod,
+            ArchivedJournalEpollCtlV1::Del => wasi::EpollCtl::Del,
+            ArchivedJournalEpollCtlV1::Unknown => wasi::EpollCtl::Unknown,
+        }
+    }
+}
+
+impl From<wasi::EpollEventCtl> for JournalEpollEventCtlV1 {
+    fn from(val: wasi::EpollEventCtl) -> Self {
+        JournalEpollEventCtlV1 {
+            events: val.events.bits(),
+            ptr: val.ptr,
+            fd: val.fd,
+            data1: val.data1,
+            data2: val.data2,
+        }
+    }
+}
+
+impl From<JournalEpollEventCtlV1> for wasi::EpollEventCtl {
+    fn from(val: JournalEpollEventCtlV1) -> Self {
+        Self {
+            events: wasi::EpollType::from_bits_truncate(val.events),
+            ptr: val.ptr,
+            fd: val.fd,
+            data1: val.data1,
+            data2: val.data2,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalEpollEventCtlV1> for wasi::EpollEventCtl {
+    fn from(val: &'_ ArchivedJournalEpollEventCtlV1) -> Self {
+        Self {
+            events: wasi::EpollType::from_bits_truncate(val.events),
+            ptr: val.ptr,
+            fd: val.fd,
+            data1: val.data1,
+            data2: val.data2,
+        }
+    }
+}
+
+impl From<virtual_net::StreamSecurity> for JournalStreamSecurityV1 {
+    fn from(val: virtual_net::StreamSecurity) -> Self {
+        use virtual_net::StreamSecurity;
+        match val {
+            StreamSecurity::Unencrypted => JournalStreamSecurityV1::Unencrypted,
+            StreamSecurity::AnyEncyption => JournalStreamSecurityV1::AnyEncryption,
+            StreamSecurity::ClassicEncryption => JournalStreamSecurityV1::ClassicEncryption,
+            StreamSecurity::DoubleEncryption => JournalStreamSecurityV1::DoubleEncryption,
+        }
+    }
+}
+
+impl From<JournalStreamSecurityV1> for virtual_net::StreamSecurity {
+    fn from(val: JournalStreamSecurityV1) -> Self {
+        use virtual_net::StreamSecurity;
+        match val {
+            JournalStreamSecurityV1::Unencrypted => StreamSecurity::Unencrypted,
+            JournalStreamSecurityV1::AnyEncryption => StreamSecurity::AnyEncyption,
+            JournalStreamSecurityV1::ClassicEncryption => StreamSecurity::ClassicEncryption,
+            JournalStreamSecurityV1::DoubleEncryption => StreamSecurity::DoubleEncryption,
+            JournalStreamSecurityV1::Unknown => StreamSecurity::AnyEncyption,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalStreamSecurityV1> for virtual_net::StreamSecurity {
+    fn from(val: &'_ ArchivedJournalStreamSecurityV1) -> Self {
+        use virtual_net::StreamSecurity;
+        match val {
+            ArchivedJournalStreamSecurityV1::Unencrypted => StreamSecurity::Unencrypted,
+            ArchivedJournalStreamSecurityV1::AnyEncryption => StreamSecurity::AnyEncyption,
+            ArchivedJournalStreamSecurityV1::ClassicEncryption => StreamSecurity::ClassicEncryption,
+            ArchivedJournalStreamSecurityV1::DoubleEncryption => StreamSecurity::DoubleEncryption,
+            ArchivedJournalStreamSecurityV1::Unknown => StreamSecurity::AnyEncyption,
+        }
+    }
+}
+
+impl From<wasi::Addressfamily> for JournalAddressfamilyV1 {
+    fn from(val: wasi::Addressfamily) -> Self {
+        match val {
+            wasi::Addressfamily::Unspec => JournalAddressfamilyV1::Unspec,
+            wasi::Addressfamily::Inet4 => JournalAddressfamilyV1::Inet4,
+            wasi::Addressfamily::Inet6 => JournalAddressfamilyV1::Inet6,
+            wasi::Addressfamily::Unix => JournalAddressfamilyV1::Unix,
+        }
+    }
+}
+
+impl From<JournalAddressfamilyV1> for wasi::Addressfamily {
+    fn from(val: JournalAddressfamilyV1) -> Self {
+        match val {
+            JournalAddressfamilyV1::Unspec => wasi::Addressfamily::Unspec,
+            JournalAddressfamilyV1::Inet4 => wasi::Addressfamily::Inet4,
+            JournalAddressfamilyV1::Inet6 => wasi::Addressfamily::Inet6,
+            JournalAddressfamilyV1::Unix => wasi::Addressfamily::Unix,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalAddressfamilyV1> for wasi::Addressfamily {
+    fn from(val: &'_ ArchivedJournalAddressfamilyV1) -> Self {
+        match val {
+            ArchivedJournalAddressfamilyV1::Unspec => wasi::Addressfamily::Unspec,
+            ArchivedJournalAddressfamilyV1::Inet4 => wasi::Addressfamily::Inet4,
+            ArchivedJournalAddressfamilyV1::Inet6 => wasi::Addressfamily::Inet6,
+            ArchivedJournalAddressfamilyV1::Unix => wasi::Addressfamily::Unix,
+        }
+    }
+}
+
+impl From<wasi::Socktype> for JournalSocktypeV1 {
+    fn from(val: wasi::Socktype) -> Self {
+        match val {
+            wasi::Socktype::Stream => JournalSocktypeV1::Stream,
+            wasi::Socktype::Dgram => JournalSocktypeV1::Dgram,
+            wasi::Socktype::Raw => JournalSocktypeV1::Raw,
+            wasi::Socktype::Seqpacket => JournalSocktypeV1::Seqpacket,
+            wasi::Socktype::Unknown => JournalSocktypeV1::Unknown,
+        }
+    }
+}
+
+impl From<JournalSocktypeV1> for wasi::Socktype {
+    fn from(val: JournalSocktypeV1) -> Self {
+        match val {
+            JournalSocktypeV1::Stream => wasi::Socktype::Stream,
+            JournalSocktypeV1::Dgram => wasi::Socktype::Dgram,
+            JournalSocktypeV1::Raw => wasi::Socktype::Raw,
+            JournalSocktypeV1::Seqpacket => wasi::Socktype::Seqpacket,
+            JournalSocktypeV1::Unknown => wasi::Socktype::Unknown,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalSocktypeV1> for wasi::Socktype {
+    fn from(val: &'_ ArchivedJournalSocktypeV1) -> Self {
+        match val {
+            ArchivedJournalSocktypeV1::Stream => wasi::Socktype::Stream,
+            ArchivedJournalSocktypeV1::Dgram => wasi::Socktype::Dgram,
+            ArchivedJournalSocktypeV1::Raw => wasi::Socktype::Raw,
+            ArchivedJournalSocktypeV1::Seqpacket => wasi::Socktype::Seqpacket,
+            ArchivedJournalSocktypeV1::Unknown => wasi::Socktype::Unknown,
+        }
+    }
+}
+
+impl From<wasi::Sockoption> for JournalSockoptionV1 {
+    fn from(val: wasi::Sockoption) -> Self {
+        match val {
+            wasi::Sockoption::Noop => JournalSockoptionV1::Noop,
+            wasi::Sockoption::ReusePort => JournalSockoptionV1::ReusePort,
+            wasi::Sockoption::ReuseAddr => JournalSockoptionV1::ReuseAddr,
+            wasi::Sockoption::NoDelay => JournalSockoptionV1::NoDelay,
+            wasi::Sockoption::DontRoute => JournalSockoptionV1::DontRoute,
+            wasi::Sockoption::OnlyV6 => JournalSockoptionV1::OnlyV6,
+            wasi::Sockoption::Broadcast => JournalSockoptionV1::Broadcast,
+            wasi::Sockoption::MulticastLoopV4 => JournalSockoptionV1::MulticastLoopV4,
+            wasi::Sockoption::MulticastLoopV6 => JournalSockoptionV1::MulticastLoopV6,
+            wasi::Sockoption::Promiscuous => JournalSockoptionV1::Promiscuous,
+            wasi::Sockoption::Listening => JournalSockoptionV1::Listening,
+            wasi::Sockoption::LastError => JournalSockoptionV1::LastError,
+            wasi::Sockoption::KeepAlive => JournalSockoptionV1::KeepAlive,
+            wasi::Sockoption::Linger => JournalSockoptionV1::Linger,
+            wasi::Sockoption::OobInline => JournalSockoptionV1::OobInline,
+            wasi::Sockoption::RecvBufSize => JournalSockoptionV1::RecvBufSize,
+            wasi::Sockoption::SendBufSize => JournalSockoptionV1::SendBufSize,
+            wasi::Sockoption::RecvLowat => JournalSockoptionV1::RecvLowat,
+            wasi::Sockoption::SendLowat => JournalSockoptionV1::SendLowat,
+            wasi::Sockoption::RecvTimeout => JournalSockoptionV1::RecvTimeout,
+            wasi::Sockoption::SendTimeout => JournalSockoptionV1::SendTimeout,
+            wasi::Sockoption::ConnectTimeout => JournalSockoptionV1::ConnectTimeout,
+            wasi::Sockoption::AcceptTimeout => JournalSockoptionV1::AcceptTimeout,
+            wasi::Sockoption::Ttl => JournalSockoptionV1::Ttl,
+            wasi::Sockoption::MulticastTtlV4 => JournalSockoptionV1::MulticastTtlV4,
+            wasi::Sockoption::Type => JournalSockoptionV1::Type,
+            wasi::Sockoption::Proto => JournalSockoptionV1::Proto,
+        }
+    }
+}
+
+impl From<JournalSockoptionV1> for wasi::Sockoption {
+    fn from(val: JournalSockoptionV1) -> Self {
+        match val {
+            JournalSockoptionV1::Noop => wasi::Sockoption::Noop,
+            JournalSockoptionV1::ReusePort => wasi::Sockoption::ReusePort,
+            JournalSockoptionV1::ReuseAddr => wasi::Sockoption::ReuseAddr,
+            JournalSockoptionV1::NoDelay => wasi::Sockoption::NoDelay,
+            JournalSockoptionV1::DontRoute => wasi::Sockoption::DontRoute,
+            JournalSockoptionV1::OnlyV6 => wasi::Sockoption::OnlyV6,
+            JournalSockoptionV1::Broadcast => wasi::Sockoption::Broadcast,
+            JournalSockoptionV1::MulticastLoopV4 => wasi::Sockoption::MulticastLoopV4,
+            JournalSockoptionV1::MulticastLoopV6 => wasi::Sockoption::MulticastLoopV6,
+            JournalSockoptionV1::Promiscuous => wasi::Sockoption::Promiscuous,
+            JournalSockoptionV1::Listening => wasi::Sockoption::Listening,
+            JournalSockoptionV1::LastError => wasi::Sockoption::LastError,
+            JournalSockoptionV1::KeepAlive => wasi::Sockoption::KeepAlive,
+            JournalSockoptionV1::Linger => wasi::Sockoption::Linger,
+            JournalSockoptionV1::OobInline => wasi::Sockoption::OobInline,
+            JournalSockoptionV1::RecvBufSize => wasi::Sockoption::RecvBufSize,
+            JournalSockoptionV1::SendBufSize => wasi::Sockoption::SendBufSize,
+            JournalSockoptionV1::RecvLowat => wasi::Sockoption::RecvLowat,
+            JournalSockoptionV1::SendLowat => wasi::Sockoption::SendLowat,
+            JournalSockoptionV1::RecvTimeout => wasi::Sockoption::RecvTimeout,
+            JournalSockoptionV1::SendTimeout => wasi::Sockoption::SendTimeout,
+            JournalSockoptionV1::ConnectTimeout => wasi::Sockoption::ConnectTimeout,
+            JournalSockoptionV1::AcceptTimeout => wasi::Sockoption::AcceptTimeout,
+            JournalSockoptionV1::Ttl => wasi::Sockoption::Ttl,
+            JournalSockoptionV1::MulticastTtlV4 => wasi::Sockoption::MulticastTtlV4,
+            JournalSockoptionV1::Type => wasi::Sockoption::Type,
+            JournalSockoptionV1::Proto => wasi::Sockoption::Proto,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalSockoptionV1> for wasi::Sockoption {
+    fn from(val: &'_ ArchivedJournalSockoptionV1) -> Self {
+        match val {
+            ArchivedJournalSockoptionV1::Noop => wasi::Sockoption::Noop,
+            ArchivedJournalSockoptionV1::ReusePort => wasi::Sockoption::ReusePort,
+            ArchivedJournalSockoptionV1::ReuseAddr => wasi::Sockoption::ReuseAddr,
+            ArchivedJournalSockoptionV1::NoDelay => wasi::Sockoption::NoDelay,
+            ArchivedJournalSockoptionV1::DontRoute => wasi::Sockoption::DontRoute,
+            ArchivedJournalSockoptionV1::OnlyV6 => wasi::Sockoption::OnlyV6,
+            ArchivedJournalSockoptionV1::Broadcast => wasi::Sockoption::Broadcast,
+            ArchivedJournalSockoptionV1::MulticastLoopV4 => wasi::Sockoption::MulticastLoopV4,
+            ArchivedJournalSockoptionV1::MulticastLoopV6 => wasi::Sockoption::MulticastLoopV6,
+            ArchivedJournalSockoptionV1::Promiscuous => wasi::Sockoption::Promiscuous,
+            ArchivedJournalSockoptionV1::Listening => wasi::Sockoption::Listening,
+            ArchivedJournalSockoptionV1::LastError => wasi::Sockoption::LastError,
+            ArchivedJournalSockoptionV1::KeepAlive => wasi::Sockoption::KeepAlive,
+            ArchivedJournalSockoptionV1::Linger => wasi::Sockoption::Linger,
+            ArchivedJournalSockoptionV1::OobInline => wasi::Sockoption::OobInline,
+            ArchivedJournalSockoptionV1::RecvBufSize => wasi::Sockoption::RecvBufSize,
+            ArchivedJournalSockoptionV1::SendBufSize => wasi::Sockoption::SendBufSize,
+            ArchivedJournalSockoptionV1::RecvLowat => wasi::Sockoption::RecvLowat,
+            ArchivedJournalSockoptionV1::SendLowat => wasi::Sockoption::SendLowat,
+            ArchivedJournalSockoptionV1::RecvTimeout => wasi::Sockoption::RecvTimeout,
+            ArchivedJournalSockoptionV1::SendTimeout => wasi::Sockoption::SendTimeout,
+            ArchivedJournalSockoptionV1::ConnectTimeout => wasi::Sockoption::ConnectTimeout,
+            ArchivedJournalSockoptionV1::AcceptTimeout => wasi::Sockoption::AcceptTimeout,
+            ArchivedJournalSockoptionV1::Ttl => wasi::Sockoption::Ttl,
+            ArchivedJournalSockoptionV1::MulticastTtlV4 => wasi::Sockoption::MulticastTtlV4,
+            ArchivedJournalSockoptionV1::Type => wasi::Sockoption::Type,
+            ArchivedJournalSockoptionV1::Proto => wasi::Sockoption::Proto,
+        }
+    }
+}
+
+impl From<SocketOptTimeType> for JournalTimeTypeV1 {
+    fn from(val: SocketOptTimeType) -> Self {
+        match val {
+            SocketOptTimeType::ReadTimeout => JournalTimeTypeV1::ReadTimeout,
+            SocketOptTimeType::WriteTimeout => JournalTimeTypeV1::WriteTimeout,
+            SocketOptTimeType::AcceptTimeout => JournalTimeTypeV1::AcceptTimeout,
+            SocketOptTimeType::ConnectTimeout => JournalTimeTypeV1::ConnectTimeout,
+            SocketOptTimeType::BindTimeout => JournalTimeTypeV1::BindTimeout,
+            SocketOptTimeType::Linger => JournalTimeTypeV1::Linger,
+        }
+    }
+}
+
+impl From<JournalTimeTypeV1> for SocketOptTimeType {
+    fn from(val: JournalTimeTypeV1) -> Self {
+        match val {
+            JournalTimeTypeV1::ReadTimeout => SocketOptTimeType::ReadTimeout,
+            JournalTimeTypeV1::WriteTimeout => SocketOptTimeType::WriteTimeout,
+            JournalTimeTypeV1::AcceptTimeout => SocketOptTimeType::AcceptTimeout,
+            JournalTimeTypeV1::ConnectTimeout => SocketOptTimeType::ConnectTimeout,
+            JournalTimeTypeV1::BindTimeout => SocketOptTimeType::BindTimeout,
+            JournalTimeTypeV1::Linger => SocketOptTimeType::Linger,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalTimeTypeV1> for SocketOptTimeType {
+    fn from(val: &'_ ArchivedJournalTimeTypeV1) -> Self {
+        match val {
+            ArchivedJournalTimeTypeV1::ReadTimeout => SocketOptTimeType::ReadTimeout,
+            ArchivedJournalTimeTypeV1::WriteTimeout => SocketOptTimeType::WriteTimeout,
+            ArchivedJournalTimeTypeV1::AcceptTimeout => SocketOptTimeType::AcceptTimeout,
+            ArchivedJournalTimeTypeV1::ConnectTimeout => SocketOptTimeType::ConnectTimeout,
+            ArchivedJournalTimeTypeV1::BindTimeout => SocketOptTimeType::BindTimeout,
+            ArchivedJournalTimeTypeV1::Linger => SocketOptTimeType::Linger,
+        }
+    }
+}
+
+impl From<SocketShutdownHow> for JournalSocketShutdownV1 {
+    fn from(val: SocketShutdownHow) -> Self {
+        match val {
+            SocketShutdownHow::Read => JournalSocketShutdownV1::Read,
+            SocketShutdownHow::Write => JournalSocketShutdownV1::Write,
+            SocketShutdownHow::Both => JournalSocketShutdownV1::Both,
+        }
+    }
+}
+
+impl From<JournalSocketShutdownV1> for SocketShutdownHow {
+    fn from(val: JournalSocketShutdownV1) -> Self {
+        match val {
+            JournalSocketShutdownV1::Read => SocketShutdownHow::Read,
+            JournalSocketShutdownV1::Write => SocketShutdownHow::Write,
+            JournalSocketShutdownV1::Both => SocketShutdownHow::Both,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalSocketShutdownV1> for SocketShutdownHow {
+    fn from(val: &'_ ArchivedJournalSocketShutdownV1) -> Self {
+        match val {
+            ArchivedJournalSocketShutdownV1::Read => SocketShutdownHow::Read,
+            ArchivedJournalSocketShutdownV1::Write => SocketShutdownHow::Write,
+            ArchivedJournalSocketShutdownV1::Both => SocketShutdownHow::Both,
+        }
+    }
+}
+
+impl From<JournalThreadStartTypeV1> for ThreadStartType {
+    fn from(value: JournalThreadStartTypeV1) -> Self {
+        match value {
+            JournalThreadStartTypeV1::MainThread => ThreadStartType::MainThread,
+            JournalThreadStartTypeV1::ThreadSpawn { start_ptr } => {
+                ThreadStartType::ThreadSpawn { start_ptr }
+            }
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalThreadStartTypeV1> for ThreadStartType {
+    fn from(value: &'_ ArchivedJournalThreadStartTypeV1) -> Self {
+        match value {
+            ArchivedJournalThreadStartTypeV1::MainThread => ThreadStartType::MainThread,
+            ArchivedJournalThreadStartTypeV1::ThreadSpawn { start_ptr } => {
+                ThreadStartType::ThreadSpawn {
+                    start_ptr: *start_ptr,
+                }
+            }
+        }
+    }
+}
+
+impl From<ThreadStartType> for JournalThreadStartTypeV1 {
+    fn from(value: ThreadStartType) -> Self {
+        match value {
+            ThreadStartType::MainThread => JournalThreadStartTypeV1::MainThread,
+            ThreadStartType::ThreadSpawn { start_ptr } => {
+                JournalThreadStartTypeV1::ThreadSpawn { start_ptr }
+            }
+        }
+    }
+}
+
+impl From<JournalWasiMemoryLayout> for WasiMemoryLayout {
+    fn from(value: JournalWasiMemoryLayout) -> Self {
+        Self {
+            stack_upper: value.stack_upper,
+            stack_lower: value.stack_lower,
+            guard_size: value.guard_size,
+            stack_size: value.stack_size,
+        }
+    }
+}
+
+impl From<&'_ ArchivedJournalWasiMemoryLayout> for WasiMemoryLayout {
+    fn from(value: &'_ ArchivedJournalWasiMemoryLayout) -> Self {
+        Self {
+            stack_upper: value.stack_upper,
+            stack_lower: value.stack_lower,
+            guard_size: value.guard_size,
+            stack_size: value.stack_size,
+        }
+    }
+}
+
+impl From<WasiMemoryLayout> for JournalWasiMemoryLayout {
+    fn from(value: WasiMemoryLayout) -> Self {
+        Self {
+            stack_upper: value.stack_upper,
+            stack_lower: value.stack_lower,
+            guard_size: value.guard_size,
+            stack_size: value.stack_size,
+        }
+    }
+}
+
+impl<'a> TryFrom<ArchivedJournalEntry<'a>> for JournalEntry<'a> {
+    type Error = anyhow::Error;
+
+    fn try_from(value: ArchivedJournalEntry<'a>) -> anyhow::Result<Self> {
+        Ok(match value {
+            ArchivedJournalEntry::InitModuleV1(ArchivedJournalEntryInitModuleV1 { wasm_hash }) => {
+                Self::InitModuleV1 {
+                    wasm_hash: *wasm_hash,
+                }
+            }
+            ArchivedJournalEntry::ClearEtherealV1(ArchivedJournalEntryClearEtherealV1 {
+                ..
+            }) => Self::ClearEtherealV1,
+            ArchivedJournalEntry::UpdateMemoryRegionV1(
+                ArchivedJournalEntryUpdateMemoryRegionV1 {
+                    start,
+                    end,
+                    compressed_data,
+                },
+            ) => Self::UpdateMemoryRegionV1 {
+                region: (*start)..(*end),
+                data: Cow::Owned(decompress_size_prepended(compressed_data.as_ref())?),
+            },
+            ArchivedJournalEntry::ProcessExitV1(ArchivedJournalEntryProcessExitV1 {
+                exit_code,
+            }) => Self::ProcessExitV1 {
+                exit_code: exit_code.as_ref().map(|code| code.into()),
+            },
+            ArchivedJournalEntry::SetThreadV1(ArchivedJournalEntrySetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                is_64bit,
+                start,
+                layout,
+            }) => Self::SetThreadV1 {
+                id: *id,
+                call_stack: call_stack.as_ref().into(),
+                memory_stack: memory_stack.as_ref().into(),
+                store_data: store_data.as_ref().into(),
+                start: start.into(),
+                layout: layout.into(),
+                is_64bit: *is_64bit,
+            },
+            ArchivedJournalEntry::CloseThreadV1(ArchivedJournalEntryCloseThreadV1 {
+                id,
+                exit_code,
+            }) => Self::CloseThreadV1 {
+                id: *id,
+                exit_code: exit_code.as_ref().map(|code| code.into()),
+            },
+            ArchivedJournalEntry::FileDescriptorWriteV1(
+                ArchivedJournalEntryFileDescriptorWriteV1 {
+                    data,
+                    fd,
+                    offset,
+                    is_64bit,
+                },
+            ) => Self::FileDescriptorWriteV1 {
+                data: data.as_ref().into(),
+                fd: *fd,
+                offset: *offset,
+                is_64bit: *is_64bit,
+            },
+            ArchivedJournalEntry::FileDescriptorSeekV1(
+                ArchivedJournalEntryFileDescriptorSeekV1 {
+                    fd,
+                    offset,
+                    ref whence,
+                },
+            ) => Self::FileDescriptorSeekV1 {
+                fd: *fd,
+                offset: *offset,
+                whence: whence.into(),
+            },
+            ArchivedJournalEntry::OpenFileDescriptorV1(
+                ArchivedJournalEntryOpenFileDescriptorV1 {
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path,
+                    o_flags,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    fs_flags,
+                },
+            ) => Self::OpenFileDescriptorV1 {
+                fd: *fd,
+                dirfd: *dirfd,
+                dirflags: *dirflags,
+                path: String::from_utf8_lossy(path.as_ref()),
+                o_flags: wasi::Oflags::from_bits_truncate(*o_flags),
+                fs_rights_base: wasi::Rights::from_bits_truncate(*fs_rights_base),
+                fs_rights_inheriting: wasi::Rights::from_bits_truncate(*fs_rights_inheriting),
+                fs_flags: wasi::Fdflags::from_bits_truncate(*fs_flags),
+            },
+            ArchivedJournalEntry::CloseFileDescriptorV1(
+                ArchivedJournalEntryCloseFileDescriptorV1 { fd },
+            ) => Self::CloseFileDescriptorV1 { fd: *fd },
+            ArchivedJournalEntry::RemoveDirectoryV1(ArchivedJournalEntryRemoveDirectoryV1 {
+                fd,
+                path,
+            }) => Self::RemoveDirectoryV1 {
+                fd: *fd,
+                path: String::from_utf8_lossy(path.as_ref()),
+            },
+            ArchivedJournalEntry::UnlinkFileV1(ArchivedJournalEntryUnlinkFileV1 { fd, path }) => {
+                Self::UnlinkFileV1 {
+                    fd: *fd,
+                    path: String::from_utf8_lossy(path.as_ref()),
+                }
+            }
+            ArchivedJournalEntry::PathRenameV1(ArchivedJournalEntryPathRenameV1 {
+                old_fd,
+                old_path,
+                new_fd,
+                new_path,
+            }) => Self::PathRenameV1 {
+                old_fd: *old_fd,
+                old_path: String::from_utf8_lossy(old_path.as_ref()),
+                new_fd: *new_fd,
+                new_path: String::from_utf8_lossy(new_path.as_ref()),
+            },
+            ArchivedJournalEntry::SnapshotV1(ArchivedJournalEntrySnapshotV1 {
+                since_epoch,
+                ref trigger,
+            }) => Self::SnapshotV1 {
+                when: SystemTime::UNIX_EPOCH
+                    .checked_add((*since_epoch).try_into().unwrap())
+                    .unwrap_or(SystemTime::UNIX_EPOCH),
+                trigger: trigger.into(),
+            },
+            ArchivedJournalEntry::SetClockTimeV1(ArchivedJournalEntrySetClockTimeV1 {
+                ref clock_id,
+                time,
+            }) => Self::SetClockTimeV1 {
+                clock_id: clock_id.into(),
+                time: *time,
+            },
+            ArchivedJournalEntry::RenumberFileDescriptorV1(
+                ArchivedJournalEntryRenumberFileDescriptorV1 { old_fd, new_fd },
+            ) => Self::RenumberFileDescriptorV1 {
+                old_fd: *old_fd,
+                new_fd: *new_fd,
+            },
+            ArchivedJournalEntry::DuplicateFileDescriptorV1(
+                ArchivedJournalEntryDuplicateFileDescriptorV1 {
+                    original_fd: old_fd,
+                    copied_fd: new_fd,
+                },
+            ) => Self::DuplicateFileDescriptorV1 {
+                original_fd: *old_fd,
+                copied_fd: *new_fd,
+            },
+            ArchivedJournalEntry::CreateDirectoryV1(ArchivedJournalEntryCreateDirectoryV1 {
+                fd,
+                path,
+            }) => Self::CreateDirectoryV1 {
+                fd: *fd,
+                path: String::from_utf8_lossy(path.as_ref()),
+            },
+            ArchivedJournalEntry::PathSetTimesV1(ArchivedJournalEntryPathSetTimesV1 {
+                fd,
+                path,
+                flags,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            }) => Self::PathSetTimesV1 {
+                fd: *fd,
+                path: String::from_utf8_lossy(path.as_ref()),
+                flags: *flags,
+                st_atim: *st_atim,
+                st_mtim: *st_mtim,
+                fst_flags: wasi::Fstflags::from_bits_truncate(*fst_flags),
+            },
+            ArchivedJournalEntry::FileDescriptorSetTimesV1(
+                ArchivedJournalEntryFileDescriptorSetTimesV1 {
+                    fd,
+                    st_atim,
+                    st_mtim,
+                    fst_flags,
+                },
+            ) => Self::FileDescriptorSetTimesV1 {
+                fd: *fd,
+                st_atim: *st_atim,
+                st_mtim: *st_mtim,
+                fst_flags: wasi::Fstflags::from_bits_truncate(*fst_flags),
+            },
+            ArchivedJournalEntry::FileDescriptorSetSizeV1(
+                ArchivedJournalEntryFileDescriptorSetSizeV1 { fd, st_size },
+            ) => Self::FileDescriptorSetSizeV1 {
+                fd: *fd,
+                st_size: *st_size,
+            },
+            ArchivedJournalEntry::FileDescriptorSetFlagsV1(
+                ArchivedJournalEntryFileDescriptorSetFlagsV1 { fd, flags },
+            ) => Self::FileDescriptorSetFlagsV1 {
+                fd: *fd,
+                flags: wasi::Fdflags::from_bits_truncate(*flags),
+            },
+            ArchivedJournalEntry::FileDescriptorSetRightsV1(
+                ArchivedJournalEntryFileDescriptorSetRightsV1 {
+                    fd,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                },
+            ) => Self::FileDescriptorSetRightsV1 {
+                fd: *fd,
+                fs_rights_base: wasi::Rights::from_bits_truncate(*fs_rights_base),
+                fs_rights_inheriting: wasi::Rights::from_bits_truncate(*fs_rights_inheriting),
+            },
+            ArchivedJournalEntry::FileDescriptorAdviseV1(
+                ArchivedJournalEntryFileDescriptorAdviseV1 {
+                    fd,
+                    offset,
+                    len,
+                    ref advice,
+                },
+            ) => Self::FileDescriptorAdviseV1 {
+                fd: *fd,
+                offset: *offset,
+                len: *len,
+                advice: advice.into(),
+            },
+            ArchivedJournalEntry::FileDescriptorAllocateV1(
+                ArchivedJournalEntryFileDescriptorAllocateV1 { fd, offset, len },
+            ) => Self::FileDescriptorAllocateV1 {
+                fd: *fd,
+                offset: *offset,
+                len: *len,
+            },
+            ArchivedJournalEntry::CreateHardLinkV1(ArchivedJournalEntryCreateHardLinkV1 {
+                old_fd,
+                old_path,
+                old_flags,
+                new_fd,
+                new_path,
+            }) => Self::CreateHardLinkV1 {
+                old_fd: *old_fd,
+                old_path: String::from_utf8_lossy(old_path.as_ref()),
+                old_flags: *old_flags,
+                new_fd: *new_fd,
+                new_path: String::from_utf8_lossy(new_path.as_ref()),
+            },
+            ArchivedJournalEntry::CreateSymbolicLinkV1(
+                ArchivedJournalEntryCreateSymbolicLinkV1 {
+                    old_path,
+                    fd,
+                    new_path,
+                },
+            ) => Self::CreateSymbolicLinkV1 {
+                old_path: String::from_utf8_lossy(old_path.as_ref()),
+                fd: *fd,
+                new_path: String::from_utf8_lossy(new_path.as_ref()),
+            },
+            ArchivedJournalEntry::ChangeDirectoryV1(ArchivedJournalEntryChangeDirectoryV1 {
+                path,
+            }) => Self::ChangeDirectoryV1 {
+                path: String::from_utf8_lossy(path.as_ref()),
+            },
+            ArchivedJournalEntry::EpollCreateV1(ArchivedJournalEntryEpollCreateV1 { fd }) => {
+                Self::EpollCreateV1 { fd: *fd }
+            }
+            ArchivedJournalEntry::EpollCtlV1(ArchivedJournalEntryEpollCtlV1 {
+                epfd,
+                ref op,
+                fd,
+                ref event,
+            }) => Self::EpollCtlV1 {
+                epfd: *epfd,
+                op: op.into(),
+                fd: *fd,
+                event: event.as_ref().map(|e| e.into()),
+            },
+            ArchivedJournalEntry::TtySetV1(ArchivedJournalEntryTtySetV1 {
+                cols,
+                rows,
+                width,
+                height,
+                stdin_tty,
+                stdout_tty,
+                stderr_tty,
+                echo,
+                line_buffered,
+                line_feeds,
+            }) => Self::TtySetV1 {
+                tty: wasi::Tty {
+                    cols: *cols,
+                    rows: *rows,
+                    width: *width,
+                    height: *height,
+                    stdin_tty: *stdin_tty,
+                    stdout_tty: *stdout_tty,
+                    stderr_tty: *stderr_tty,
+                    echo: *echo,
+                    line_buffered: *line_buffered,
+                },
+                line_feeds: *line_feeds,
+            },
+            ArchivedJournalEntry::CreatePipeV1(ArchivedJournalEntryCreatePipeV1 { fd1, fd2 }) => {
+                Self::CreatePipeV1 {
+                    fd1: *fd1,
+                    fd2: *fd2,
+                }
+            }
+            ArchivedJournalEntry::PortAddAddrV1(ArchivedJournalEntryPortAddAddrV1 { cidr }) => {
+                Self::PortAddAddrV1 {
+                    cidr: JournalIpCidrV1 {
+                        ip: cidr.ip.as_ipaddr(),
+                        prefix: cidr.prefix,
+                    }
+                    .into(),
+                }
+            }
+            ArchivedJournalEntry::PortDelAddrV1(ArchivedJournalEntryPortDelAddrV1 { addr }) => {
+                Self::PortDelAddrV1 {
+                    addr: addr.as_ipaddr(),
+                }
+            }
+            ArchivedJournalEntry::PortAddrClearV1 => Self::PortAddrClearV1,
+            ArchivedJournalEntry::PortBridgeV1(ArchivedJournalEntryPortBridgeV1 {
+                network,
+                token,
+                ref security,
+            }) => Self::PortBridgeV1 {
+                network: String::from_utf8_lossy(network.as_ref()),
+                token: String::from_utf8_lossy(token.as_ref()),
+                security: security.into(),
+            },
+            ArchivedJournalEntry::PortUnbridgeV1 => Self::PortUnbridgeV1,
+            ArchivedJournalEntry::PortDhcpAcquireV1 => Self::PortDhcpAcquireV1,
+            ArchivedJournalEntry::PortGatewaySetV1(ArchivedJournalEntryPortGatewaySetV1 { ip }) => {
+                Self::PortGatewaySetV1 { ip: ip.as_ipaddr() }
+            }
+            ArchivedJournalEntry::PortRouteAddV1(ArchivedJournalEntryPortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            }) => Self::PortRouteAddV1 {
+                cidr: JournalIpCidrV1 {
+                    ip: cidr.ip.as_ipaddr(),
+                    prefix: cidr.prefix,
+                }
+                .into(),
+                via_router: via_router.as_ipaddr(),
+                preferred_until: preferred_until
+                    .as_ref()
+                    .map(|time| (*time).try_into().unwrap()),
+                expires_at: expires_at.as_ref().map(|time| (*time).try_into().unwrap()),
+            },
+            ArchivedJournalEntry::PortRouteClearV1 => Self::PortRouteClearV1,
+            ArchivedJournalEntry::PortRouteDelV1(ArchivedJournalEntryPortRouteDelV1 { ip }) => {
+                Self::PortRouteDelV1 { ip: ip.as_ipaddr() }
+            }
+            ArchivedJournalEntry::SocketOpenV1(ArchivedJournalEntrySocketOpenV1 {
+                ref af,
+                ref ty,
+                pt,
+                fd,
+            }) => Self::SocketOpenV1 {
+                af: af.into(),
+                ty: ty.into(),
+                pt: (*pt).try_into().unwrap_or(wasi::SockProto::Max),
+                fd: *fd,
+            },
+            ArchivedJournalEntry::SocketListenV1(ArchivedJournalEntrySocketListenV1 {
+                fd,
+                backlog,
+            }) => Self::SocketListenV1 {
+                fd: *fd,
+                backlog: *backlog,
+            },
+            ArchivedJournalEntry::SocketBindV1(ArchivedJournalEntrySocketBindV1 { fd, addr }) => {
+                Self::SocketBindV1 {
+                    fd: *fd,
+                    addr: addr.as_socket_addr(),
+                }
+            }
+            ArchivedJournalEntry::SocketConnectedV1(ArchivedJournalEntrySocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            }) => Self::SocketConnectedV1 {
+                fd: *fd,
+                local_addr: local_addr.as_socket_addr(),
+                peer_addr: peer_addr.as_socket_addr(),
+            },
+            ArchivedJournalEntry::SocketAcceptedV1(ArchivedJournalEntrySocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr,
+                peer_addr,
+                fd_flags,
+                nonblocking,
+            }) => Self::SocketAcceptedV1 {
+                listen_fd: *listen_fd,
+                fd: *fd,
+                local_addr: local_addr.as_socket_addr(),
+                peer_addr: peer_addr.as_socket_addr(),
+                fd_flags: wasi::Fdflags::from_bits_truncate(*fd_flags),
+                non_blocking: *nonblocking,
+            },
+            ArchivedJournalEntry::SocketJoinIpv4MulticastV1(
+                ArchivedJournalEntrySocketJoinIpv4MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+            ) => Self::SocketJoinIpv4MulticastV1 {
+                fd: *fd,
+                multiaddr: multiaddr.as_ipv4(),
+                iface: iface.as_ipv4(),
+            },
+            ArchivedJournalEntry::SocketJoinIpv6MulticastV1(
+                ArchivedJournalEntrySocketJoinIpv6MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+            ) => Self::SocketJoinIpv6MulticastV1 {
+                fd: *fd,
+                multi_addr: multiaddr.as_ipv6(),
+                iface: *iface,
+            },
+            ArchivedJournalEntry::SocketLeaveIpv4MulticastV1(
+                ArchivedJournalEntrySocketLeaveIpv4MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+            ) => Self::SocketLeaveIpv4MulticastV1 {
+                fd: *fd,
+                multi_addr: multiaddr.as_ipv4(),
+                iface: iface.as_ipv4(),
+            },
+            ArchivedJournalEntry::SocketLeaveIpv6MulticastV1(
+                ArchivedJournalEntrySocketLeaveIpv6MulticastV1 {
+                    fd,
+                    multiaddr,
+                    iface,
+                },
+            ) => Self::SocketLeaveIpv6MulticastV1 {
+                fd: *fd,
+                multi_addr: multiaddr.as_ipv6(),
+                iface: *iface,
+            },
+            ArchivedJournalEntry::SocketSendFileV1(ArchivedJournalEntrySocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            }) => Self::SocketSendFileV1 {
+                socket_fd: *socket_fd,
+                file_fd: *file_fd,
+                offset: *offset,
+                count: *count,
+            },
+            ArchivedJournalEntry::SocketSendToV1(ArchivedJournalEntrySocketSendToV1 {
+                fd,
+                data,
+                flags,
+                addr,
+                is_64bit,
+            }) => Self::SocketSendToV1 {
+                fd: *fd,
+                data: data.as_ref().into(),
+                flags: *flags,
+                addr: addr.as_socket_addr(),
+                is_64bit: *is_64bit,
+            },
+            ArchivedJournalEntry::SocketSendV1(ArchivedJournalEntrySocketSendV1 {
+                fd,
+                data,
+                flags,
+                is_64bit,
+            }) => Self::SocketSendV1 {
+                fd: *fd,
+                data: data.as_ref().into(),
+                flags: *flags,
+                is_64bit: *is_64bit,
+            },
+            ArchivedJournalEntry::SocketSetOptFlagV1(ArchivedJournalEntrySocketSetOptFlagV1 {
+                fd,
+                ref opt,
+                flag,
+            }) => Self::SocketSetOptFlagV1 {
+                fd: *fd,
+                opt: opt.into(),
+                flag: *flag,
+            },
+            ArchivedJournalEntry::SocketSetOptSizeV1(ArchivedJournalEntrySocketSetOptSizeV1 {
+                fd,
+                ref opt,
+                size,
+            }) => Self::SocketSetOptSizeV1 {
+                fd: *fd,
+                opt: opt.into(),
+                size: *size,
+            },
+            ArchivedJournalEntry::SocketSetOptTimeV1(ArchivedJournalEntrySocketSetOptTimeV1 {
+                fd,
+                ref ty,
+                time,
+            }) => Self::SocketSetOptTimeV1 {
+                fd: *fd,
+                ty: ty.into(),
+                time: time.as_ref().map(|time| (*time).try_into().unwrap()),
+            },
+            ArchivedJournalEntry::SocketShutdownV1(ArchivedJournalEntrySocketShutdownV1 {
+                fd,
+                ref how,
+            }) => Self::SocketShutdownV1 {
+                fd: *fd,
+                how: how.into(),
+            },
+            ArchivedJournalEntry::CreateEventV1(ArchivedJournalEntryCreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            }) => Self::CreateEventV1 {
+                initial_val: *initial_val,
+                flags: *flags,
+                fd: *fd,
+            },
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/boxed.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/boxed.rs
new file mode 100644
index 0000000..9db8cdb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/boxed.rs
@@ -0,0 +1,35 @@
+use std::ops::Deref;
+
+use super::*;
+
+impl ReadableJournal for Box<DynReadableJournal> {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.deref().read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.deref().as_restarted()
+    }
+}
+
+impl WritableJournal for Box<DynWritableJournal> {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.deref().write(entry)
+    }
+}
+
+impl ReadableJournal for Box<DynJournal> {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.deref().read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.deref().as_restarted()
+    }
+}
+
+impl WritableJournal for Box<DynJournal> {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.deref().write(entry)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/buffered.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/buffered.rs
new file mode 100644
index 0000000..c5011c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/buffered.rs
@@ -0,0 +1,100 @@
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use super::*;
+
+// The buffered journal will keep all the events in memory until it
+// is either reset or dropped.
+#[derive(Debug)]
+pub struct BufferedJournal {
+    tx: BufferedJournalTx,
+    rx: BufferedJournalRx,
+}
+
+#[derive(Debug, Default, Clone)]
+struct State {
+    records: Arc<Mutex<Vec<JournalEntry<'static>>>>,
+    offset: usize,
+}
+
+#[derive(Debug)]
+pub struct BufferedJournalRx {
+    state: Arc<Mutex<State>>,
+}
+
+#[derive(Debug)]
+pub struct BufferedJournalTx {
+    state: Arc<Mutex<State>>,
+}
+
+impl Default for BufferedJournal {
+    fn default() -> Self {
+        let state = Arc::new(Mutex::new(State::default()));
+        Self {
+            tx: BufferedJournalTx {
+                state: state.clone(),
+            },
+            rx: BufferedJournalRx { state },
+        }
+    }
+}
+
+impl WritableJournal for BufferedJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let entry = entry.into_owned();
+        let state = self.state.lock().unwrap();
+        let estimate_size = entry.estimate_size();
+        state.records.lock().unwrap().push(entry);
+        Ok(LogWriteResult {
+            record_start: state.offset as u64,
+            record_end: state.offset as u64 + estimate_size as u64,
+        })
+    }
+}
+
+impl ReadableJournal for BufferedJournalRx {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        let mut state = self.state.lock().unwrap();
+        let ret = state.records.lock().unwrap().get(state.offset).cloned();
+
+        let record_start = state.offset as u64;
+        if ret.is_some() {
+            state.offset += 1;
+        }
+        Ok(ret.map(|r| LogReadResult {
+            record_start,
+            record_end: state.offset as u64,
+            record: r,
+        }))
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        let mut state = self.state.lock().unwrap().clone();
+        state.offset = 0;
+        Ok(Box::new(BufferedJournalRx {
+            state: Arc::new(Mutex::new(state)),
+        }))
+    }
+}
+
+impl WritableJournal for BufferedJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for BufferedJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl Journal for BufferedJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting.rs
new file mode 100644
index 0000000..1a002e0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting.rs
@@ -0,0 +1,1169 @@
+use derivative::Derivative;
+use std::{
+    collections::{HashMap, HashSet},
+    ops::{DerefMut, Range},
+    sync::{Arc, Mutex},
+};
+use wasmer_wasix_types::wasi;
+
+use super::*;
+
+pub type Fd = u32;
+
+#[derive(Debug, Default)]
+struct StateDescriptor {
+    events: Vec<usize>,
+    write_map: HashMap<MemoryRange, usize>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct MemoryRange {
+    start: u64,
+    end: u64,
+}
+impl From<Range<u64>> for MemoryRange {
+    fn from(value: Range<u64>) -> Self {
+        Self {
+            start: value.start,
+            end: value.end,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+struct DescriptorLookup(u64);
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct State {
+    /// The descriptor seed is used generate descriptor lookups
+    descriptor_seed: u64,
+    // We maintain a memory map of the events that are significant
+    memory_map: HashMap<MemoryRange, usize>,
+    // List of all the snapshots
+    snapshots: Vec<usize>,
+    // Last tty event thats been set
+    tty: Option<usize>,
+    // Events that create a particular directory
+    create_directory: HashMap<String, usize>,
+    // Events that remove a particular directory
+    remove_directory: HashMap<String, usize>,
+    // When creating and truncating a file we have a special
+    // lookup so that duplicates can be erased
+    create_trunc_file: HashMap<String, Fd>,
+    // Thread events are only maintained while the thread and the
+    // process are still running
+    thread_map: HashMap<u32, usize>,
+    // Any descriptors are assumed to be read only operations until
+    // they actually do something that changes the system
+    suspect_descriptors: HashMap<Fd, DescriptorLookup>,
+    // Any descriptors are assumed to be read only operations until
+    // they actually do something that changes the system
+    keep_descriptors: HashMap<Fd, DescriptorLookup>,
+    // We put the IO related to stdio into a special list
+    // which can be purged when the program exits as its no longer
+    // important.
+    stdio_descriptors: HashMap<Fd, DescriptorLookup>,
+    // We abstract the descriptor state so that multiple file descriptors
+    // can refer to the same file descriptors
+    descriptors: HashMap<DescriptorLookup, StateDescriptor>,
+    // Everything that will be retained during the next compact
+    whitelist: HashSet<usize>,
+    // We use an event index to track what to keep
+    event_index: usize,
+    // The delta list is used for all the events that happened
+    // after a compact started
+    delta_list: Option<Vec<usize>>,
+    // The inner journal that we will write to
+    #[derivative(Debug = "ignore")]
+    inner_tx: Box<DynWritableJournal>,
+    // The inner journal that we read from
+    #[derivative(Debug = "ignore")]
+    inner_rx: Box<DynReadableJournal>,
+}
+
+impl State {
+    fn create_filter<J>(&self, inner: J) -> FilteredJournal
+    where
+        J: Journal,
+    {
+        let has_threads = !self.thread_map.is_empty();
+
+        let mut filter = FilteredJournalBuilder::new()
+            .with_filter_events(self.whitelist.clone().into_iter().collect());
+        if let Some(tty) = self.tty.as_ref() {
+            filter.add_event_to_whitelist(*tty);
+        }
+        for e in self.snapshots.iter() {
+            filter.add_event_to_whitelist(*e);
+        }
+        for (_, e) in self.memory_map.iter() {
+            filter.add_event_to_whitelist(*e);
+        }
+        for t in self.thread_map.iter() {
+            filter.add_event_to_whitelist(*t.1);
+        }
+        for (_, e) in self.create_directory.iter() {
+            filter.add_event_to_whitelist(*e);
+        }
+        for (_, e) in self.remove_directory.iter() {
+            filter.add_event_to_whitelist(*e);
+        }
+        for (_, l) in self
+            .suspect_descriptors
+            .iter()
+            .chain(self.keep_descriptors.iter())
+        {
+            if let Some(d) = self.descriptors.get(l) {
+                for e in d.events.iter() {
+                    filter.add_event_to_whitelist(*e);
+                }
+                for e in d.write_map.values() {
+                    filter.add_event_to_whitelist(*e);
+                }
+            }
+        }
+        if has_threads {
+            for (_, l) in self.stdio_descriptors.iter() {
+                if let Some(d) = self.descriptors.get(l) {
+                    for e in d.events.iter() {
+                        filter.add_event_to_whitelist(*e);
+                    }
+                    for e in d.write_map.values() {
+                        filter.add_event_to_whitelist(*e);
+                    }
+                }
+            }
+        }
+        filter.build(inner)
+    }
+}
+
+/// Deduplicates memory and stacks to reduce the number of volume of
+/// log events sent to its inner capturer. Compacting the events occurs
+/// in line as the events are generated
+#[derive(Debug, Clone)]
+pub struct CompactingJournalTx {
+    state: Arc<Mutex<State>>,
+    compacting: Arc<Mutex<()>>,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct CompactingJournalRx {
+    #[derivative(Debug = "ignore")]
+    inner: Box<DynReadableJournal>,
+}
+
+impl CompactingJournalRx {
+    pub fn swap_inner(&mut self, mut with: Box<DynReadableJournal>) -> Box<DynReadableJournal> {
+        std::mem::swap(&mut self.inner, &mut with);
+        with
+    }
+}
+
+#[derive(Debug)]
+pub struct CompactingJournal {
+    tx: CompactingJournalTx,
+    rx: CompactingJournalRx,
+}
+
+impl CompactingJournal {
+    pub fn new<J>(inner: J) -> anyhow::Result<Self>
+    where
+        J: Journal,
+    {
+        let (tx, rx) = inner.split();
+        let state = State {
+            inner_tx: tx,
+            inner_rx: rx.as_restarted()?,
+            tty: None,
+            snapshots: Default::default(),
+            memory_map: Default::default(),
+            thread_map: Default::default(),
+            create_directory: Default::default(),
+            remove_directory: Default::default(),
+            create_trunc_file: Default::default(),
+            suspect_descriptors: Default::default(),
+            keep_descriptors: Default::default(),
+            stdio_descriptors: Default::default(),
+            descriptor_seed: 0,
+            descriptors: Default::default(),
+            whitelist: Default::default(),
+            delta_list: None,
+            event_index: 0,
+        };
+        Ok(Self {
+            tx: CompactingJournalTx {
+                state: Arc::new(Mutex::new(state)),
+                compacting: Arc::new(Mutex::new(())),
+            },
+            rx: CompactingJournalRx { inner: rx },
+        })
+    }
+}
+
+/// Represents the results of a compaction operation
+#[derive(Debug, Default)]
+pub struct CompactResult {
+    pub total_size: u64,
+    pub total_events: usize,
+}
+
+impl CompactingJournalTx {
+    pub fn create_filter<J>(&self, inner: J) -> FilteredJournal
+    where
+        J: Journal,
+    {
+        let state = self.state.lock().unwrap();
+        state.create_filter(inner)
+    }
+
+    pub fn swap(&self, other: Self) -> Self {
+        let mut state1 = self.state.lock().unwrap();
+        let mut state2 = other.state.lock().unwrap();
+        std::mem::swap(state1.deref_mut(), state2.deref_mut());
+        drop(state1);
+        drop(state2);
+        other
+    }
+
+    /// Compacts the inner journal into a new journal
+    pub fn compact_to<J>(&self, new_journal: J) -> anyhow::Result<CompactResult>
+    where
+        J: Journal,
+    {
+        // Enter a compacting lock
+        let _guard = self.compacting.lock().unwrap();
+
+        // The first thing we do is create a filter that we
+        // place around the new journal so that it only receives new events
+        let (new_journal, replay_rx) = {
+            let mut state = self.state.lock().unwrap();
+            state.delta_list.replace(Default::default());
+            (
+                state.create_filter(new_journal),
+                state.inner_rx.as_restarted()?,
+            )
+        };
+
+        let mut result = CompactResult::default();
+
+        // Read all the events and feed them into the filtered journal and then
+        // strip off the filter so that its a normal journal again
+        while let Some(entry) = replay_rx.read()? {
+            let res = new_journal.write(entry.into_inner())?;
+            if res.record_size() > 0 {
+                result.total_size += res.record_size();
+                result.total_events += 1;
+            }
+        }
+        let new_journal = new_journal.into_inner();
+
+        // We now go into a blocking situation which will freeze the journals
+        let mut state = self.state.lock().unwrap();
+
+        // Now we build a filtered journal which will pick up any events that were
+        // added which we did the compacting.
+        let new_journal = FilteredJournalBuilder::new()
+            .with_filter_events(
+                state
+                    .delta_list
+                    .take()
+                    .unwrap_or_default()
+                    .into_iter()
+                    .collect(),
+            )
+            .build(new_journal);
+
+        // Now we feed all the events into the new journal using the delta filter. After the
+        // extra events are added we strip off the filter again
+        let replay_rx = state.inner_rx.as_restarted()?;
+        while let Some(entry) = replay_rx.read()? {
+            new_journal.write(entry.into_inner())?;
+        }
+        let new_journal = new_journal.into_inner();
+
+        // Now we install the new journal
+        let (mut tx, mut rx) = new_journal.split();
+        std::mem::swap(&mut state.inner_tx, &mut tx);
+        std::mem::swap(&mut state.inner_rx, &mut rx);
+
+        Ok(result)
+    }
+
+    pub fn replace_inner<J: Journal>(&self, inner: J) {
+        let mut state = self.state.lock().unwrap();
+        let (mut tx, mut rx) = inner.split();
+        std::mem::swap(&mut state.inner_tx, &mut tx);
+        std::mem::swap(&mut state.inner_rx, &mut rx);
+    }
+}
+
+impl WritableJournal for CompactingJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let mut state = self.state.lock().unwrap();
+        let event_index = state.event_index;
+        state.event_index += 1;
+
+        if let Some(delta) = state.delta_list.as_mut() {
+            delta.push(event_index);
+        }
+
+        match &entry {
+            JournalEntry::UpdateMemoryRegionV1 { region, .. } => {
+                state.memory_map.insert(region.clone().into(), event_index);
+            }
+            JournalEntry::SetThreadV1 { id, .. } => {
+                state.thread_map.insert(*id, event_index);
+            }
+            JournalEntry::CloseThreadV1 { id, .. } => {
+                state.thread_map.remove(id);
+            }
+            JournalEntry::SnapshotV1 { .. } => {
+                state.snapshots.push(event_index);
+            }
+            JournalEntry::ProcessExitV1 { .. } => {
+                state.thread_map.clear();
+                state.memory_map.clear();
+                for (_, lookup) in state.suspect_descriptors.clone() {
+                    state.descriptors.remove(&lookup);
+                }
+                state.suspect_descriptors.clear();
+                for (_, lookup) in state.stdio_descriptors.clone() {
+                    state.descriptors.remove(&lookup);
+                }
+                state.stdio_descriptors.clear();
+                state.whitelist.insert(event_index);
+                state.snapshots.clear();
+            }
+            JournalEntry::TtySetV1 { .. } => {
+                state.tty.replace(event_index);
+            }
+            JournalEntry::OpenFileDescriptorV1 {
+                fd, o_flags, path, ..
+            } => {
+                // All file descriptors are opened in a suspect state which
+                // means if they are closed without modifying the file system
+                // then the events will be ignored.
+                let lookup = DescriptorLookup(state.descriptor_seed);
+                state.descriptor_seed += 1;
+                state.suspect_descriptors.insert(*fd, lookup);
+
+                // There is an exception to the rule which is if the create
+                // flag is specified its always recorded as a mutating operation
+                // because it may create a file that does not exist on the file system
+                if o_flags.contains(wasi::Oflags::CREATE) {
+                    if let Some(lookup) = state.suspect_descriptors.remove(fd) {
+                        state.keep_descriptors.insert(*fd, lookup);
+                    }
+                }
+
+                // The event itself must be recorded in a staging area
+                state
+                    .descriptors
+                    .entry(lookup)
+                    .or_default()
+                    .events
+                    .push(event_index);
+
+                // Creating a file and erasing anything that was there before means
+                // the entire create branch that exists before this one can be ignored
+                if o_flags.contains(wasi::Oflags::CREATE) && o_flags.contains(wasi::Oflags::TRUNC) {
+                    let path = path.to_string();
+                    if let Some(existing) = state.create_trunc_file.remove(&path) {
+                        state.suspect_descriptors.remove(&existing);
+                        state.keep_descriptors.remove(&existing);
+                    }
+                    state.create_trunc_file.insert(path, *fd);
+                }
+            }
+            // We keep non-mutable events for file descriptors that are suspect
+            JournalEntry::FileDescriptorSeekV1 { fd, .. }
+            | JournalEntry::CloseFileDescriptorV1 { fd } => {
+                // Get the lookup
+                // (if its suspect then it will remove the entry and
+                //  thus the entire branch of events it represents is discarded)
+                let lookup = if matches!(&entry, JournalEntry::CloseFileDescriptorV1 { .. }) {
+                    state.suspect_descriptors.remove(fd)
+                } else {
+                    state.suspect_descriptors.get(fd).cloned()
+                };
+                let lookup = lookup
+                    .or_else(|| state.keep_descriptors.get(fd).cloned())
+                    .or_else(|| state.stdio_descriptors.get(fd).cloned());
+
+                if let Some(lookup) = lookup {
+                    let state = state.descriptors.entry(lookup).or_default();
+                    state.events.push(event_index);
+                } else {
+                    state.whitelist.insert(event_index);
+                }
+            }
+            // Things that modify a file descriptor mean that it is
+            // no longer suspect and thus it needs to be kept
+            JournalEntry::FileDescriptorAdviseV1 { fd, .. }
+            | JournalEntry::FileDescriptorAllocateV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetFlagsV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetTimesV1 { fd, .. }
+            | JournalEntry::FileDescriptorWriteV1 { fd, .. } => {
+                // Its no longer suspect
+                if let Some(lookup) = state.suspect_descriptors.remove(fd) {
+                    state.keep_descriptors.insert(*fd, lookup);
+                }
+
+                // Get the lookup
+                let lookup = state
+                    .suspect_descriptors
+                    .get(fd)
+                    .cloned()
+                    .or_else(|| state.keep_descriptors.get(fd).cloned())
+                    .or_else(|| state.stdio_descriptors.get(fd).cloned());
+
+                // Update the state
+                if let Some(lookup) = lookup {
+                    let state = state.descriptors.entry(lookup).or_default();
+                    if let JournalEntry::FileDescriptorWriteV1 { offset, data, .. } = &entry {
+                        state.write_map.insert(
+                            MemoryRange {
+                                start: *offset,
+                                end: *offset + data.len() as u64,
+                            },
+                            event_index,
+                        );
+                    } else {
+                        state.events.push(event_index);
+                    }
+                } else {
+                    state.whitelist.insert(event_index);
+                }
+            }
+            // Duplicating the file descriptor
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => {
+                if let Some(lookup) = state.suspect_descriptors.remove(original_fd) {
+                    state.suspect_descriptors.insert(*copied_fd, lookup);
+                } else if let Some(lookup) = state.keep_descriptors.remove(original_fd) {
+                    state.keep_descriptors.insert(*copied_fd, lookup);
+                } else if let Some(lookup) = state.stdio_descriptors.remove(original_fd) {
+                    state.stdio_descriptors.insert(*copied_fd, lookup);
+                } else {
+                    state.whitelist.insert(event_index);
+                }
+            }
+            // Renumbered file descriptors will retain their suspect status
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                if let Some(lookup) = state.suspect_descriptors.remove(old_fd) {
+                    state.suspect_descriptors.insert(*new_fd, lookup);
+                } else if let Some(lookup) = state.keep_descriptors.remove(old_fd) {
+                    state.keep_descriptors.insert(*new_fd, lookup);
+                } else if let Some(lookup) = state.stdio_descriptors.remove(old_fd) {
+                    state.stdio_descriptors.insert(*new_fd, lookup);
+                } else {
+                    state.whitelist.insert(event_index);
+                }
+            }
+            // Creating a new directory only needs to be done once
+            JournalEntry::CreateDirectoryV1 { path, .. } => {
+                let path = path.to_string();
+                state.remove_directory.remove(&path);
+                state.create_directory.entry(path).or_insert(event_index);
+            }
+            // Deleting a directory only needs to be done once
+            JournalEntry::RemoveDirectoryV1 { path, .. } => {
+                let path = path.to_string();
+                state.create_directory.remove(&path);
+                state.remove_directory.entry(path).or_insert(event_index);
+            }
+            _ => {
+                // The fallthrough is to whitelist the event so that it will
+                // be reflected in the next compaction event
+                state.whitelist.insert(event_index);
+            }
+        }
+        state.inner_tx.write(entry)
+    }
+}
+
+impl CompactingJournal {
+    /// Compacts the inner journal into a new journal
+    pub fn compact_to<J>(&mut self, new_journal: J) -> anyhow::Result<CompactResult>
+    where
+        J: Journal,
+    {
+        self.tx.compact_to(new_journal)
+    }
+
+    pub fn into_split(self) -> (CompactingJournalTx, CompactingJournalRx) {
+        (self.tx, self.rx)
+    }
+
+    pub fn replace_inner<J: Journal>(&mut self, inner: J) {
+        let (inner_tx, inner_rx) = inner.split();
+        let inner_rx_restarted = inner_rx.as_restarted().unwrap();
+
+        self.tx
+            .replace_inner(RecombinedJournal::new(inner_tx, inner_rx));
+        self.rx.inner = inner_rx_restarted;
+    }
+}
+
+impl ReadableJournal for CompactingJournalRx {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.inner.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.inner.as_restarted()
+    }
+}
+
+impl WritableJournal for CompactingJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for CompactingJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        let state = self.tx.state.lock().unwrap();
+        state.inner_rx.as_restarted()
+    }
+}
+
+impl Journal for CompactingJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
+
+#[cfg(feature = "journal")]
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use wasmer_wasix_types::wasi::Tty;
+
+    pub fn run_test<'a>(
+        in_records: Vec<JournalEntry<'a>>,
+        out_records: Vec<JournalEntry<'a>>,
+    ) -> anyhow::Result<()> {
+        // Build a journal that will store the records before compacting
+        let mut compacting_journal = CompactingJournal::new(BufferedJournal::default())?;
+        for record in in_records {
+            compacting_journal.write(record)?;
+        }
+
+        // Now we build a new one using the compactor
+        let new_journal = BufferedJournal::default();
+        compacting_journal.compact_to(new_journal)?;
+
+        // Read the records
+        let new_records = compacting_journal.as_restarted()?;
+        for record1 in out_records {
+            let record2 = new_records.read()?;
+            assert_eq!(Some(record1), record2);
+        }
+        assert!(new_records.read()?.is_none());
+
+        Ok(())
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_purge_duplicate_memory_writes() {
+        run_test(
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [22u8; 16].to_vec().into(),
+                },
+            ],
+            vec![JournalEntry::UpdateMemoryRegionV1 {
+                region: 0..16,
+                data: [22u8; 16].to_vec().into(),
+            }],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_keep_overlapping_memory() {
+        run_test(
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 20..36,
+                    data: [22u8; 16].to_vec().into(),
+                },
+            ],
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 20..36,
+                    data: [22u8; 16].to_vec().into(),
+                },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_keep_adjacent_memory_writes() {
+        run_test(
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 16..32,
+                    data: [22u8; 16].to_vec().into(),
+                },
+            ],
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 16..32,
+                    data: [22u8; 16].to_vec().into(),
+                },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_purge_identical_memory_writes() {
+        run_test(
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+            ],
+            vec![JournalEntry::UpdateMemoryRegionV1 {
+                region: 0..16,
+                data: [11u8; 16].to_vec().into(),
+            }],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_thread_stacks() {
+        run_test(
+            vec![
+                JournalEntry::SetThreadV1 {
+                    id: 4321.into(),
+                    call_stack: [44u8; 87].to_vec().into(),
+                    memory_stack: [55u8; 34].to_vec().into(),
+                    store_data: [66u8; 70].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::SetThreadV1 {
+                    id: 1234.into(),
+                    call_stack: [11u8; 124].to_vec().into(),
+                    memory_stack: [22u8; 51].to_vec().into(),
+                    store_data: [33u8; 87].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::SetThreadV1 {
+                    id: 65.into(),
+                    call_stack: [77u8; 34].to_vec().into(),
+                    memory_stack: [88u8; 51].to_vec().into(),
+                    store_data: [99u8; 12].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseThreadV1 {
+                    id: 1234.into(),
+                    exit_code: None,
+                },
+            ],
+            vec![
+                JournalEntry::SetThreadV1 {
+                    id: 4321.into(),
+                    call_stack: [44u8; 87].to_vec().into(),
+                    memory_stack: [55u8; 34].to_vec().into(),
+                    store_data: [66u8; 70].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::SetThreadV1 {
+                    id: 65.into(),
+                    call_stack: [77u8; 34].to_vec().into(),
+                    memory_stack: [88u8; 51].to_vec().into(),
+                    store_data: [99u8; 12].to_vec().into(),
+                    is_64bit: true,
+                },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_processed_exited() {
+        run_test(
+            vec![
+                JournalEntry::UpdateMemoryRegionV1 {
+                    region: 0..16,
+                    data: [11u8; 16].to_vec().into(),
+                },
+                JournalEntry::SetThreadV1 {
+                    id: 4321.into(),
+                    call_stack: [44u8; 87].to_vec().into(),
+                    memory_stack: [55u8; 34].to_vec().into(),
+                    store_data: [66u8; 70].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::SnapshotV1 {
+                    when: SystemTime::now(),
+                    trigger: SnapshotTrigger::FirstListen,
+                },
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::ProcessExitV1 { exit_code: None },
+            ],
+            vec![JournalEntry::ProcessExitV1 { exit_code: None }],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_partial_write_survives() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_write_survives_close() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_write_survives_exit() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::ProcessExitV1 { exit_code: None },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::ProcessExitV1 { exit_code: None },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_read_is_ignored() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorSeekV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    whence: wasi::Whence::End,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+            ],
+            Vec::new(),
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_touch() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::CREATE | wasi::Oflags::TRUNC,
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+                JournalEntry::ProcessExitV1 { exit_code: None },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::CREATE | wasi::Oflags::TRUNC,
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+                JournalEntry::ProcessExitV1 { exit_code: None },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_redundant_file() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::CREATE | wasi::Oflags::TRUNC,
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [5u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1235,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::CREATE | wasi::Oflags::TRUNC,
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1235,
+                    offset: 1234,
+                    data: [6u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1235 },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1235,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::CREATE | wasi::Oflags::TRUNC,
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1235,
+                    offset: 1234,
+                    data: [6u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1235 },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_ignore_double_writes() {
+        run_test(
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [1u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [5u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+            ],
+            vec![
+                JournalEntry::OpenFileDescriptorV1 {
+                    fd: 1234,
+                    dirfd: 3452345,
+                    dirflags: 0,
+                    path: "/blah".into(),
+                    o_flags: wasi::Oflags::empty(),
+                    fs_rights_base: wasi::Rights::all(),
+                    fs_rights_inheriting: wasi::Rights::all(),
+                    fs_flags: wasi::Fdflags::all(),
+                },
+                JournalEntry::FileDescriptorWriteV1 {
+                    fd: 1234,
+                    offset: 1234,
+                    data: [5u8; 16].to_vec().into(),
+                    is_64bit: true,
+                },
+                JournalEntry::CloseFileDescriptorV1 { fd: 1234 },
+            ],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_create_directory() {
+        run_test(
+            vec![JournalEntry::CreateDirectoryV1 {
+                fd: 1234,
+                path: "/blah".into(),
+            }],
+            vec![JournalEntry::CreateDirectoryV1 {
+                fd: 1234,
+                path: "/blah".into(),
+            }],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_file_system_redundant_create_directory() {
+        run_test(
+            vec![
+                JournalEntry::CreateDirectoryV1 {
+                    fd: 1234,
+                    path: "/blah".into(),
+                },
+                JournalEntry::CreateDirectoryV1 {
+                    fd: 1235,
+                    path: "/blah".into(),
+                },
+            ],
+            vec![JournalEntry::CreateDirectoryV1 {
+                fd: 1234,
+                path: "/blah".into(),
+            }],
+        )
+        .unwrap()
+    }
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_compact_duplicate_tty() {
+        run_test(
+            vec![
+                JournalEntry::TtySetV1 {
+                    tty: Tty {
+                        cols: 123,
+                        rows: 65,
+                        width: 2341,
+                        height: 573457,
+                        stdin_tty: true,
+                        stdout_tty: true,
+                        stderr_tty: true,
+                        echo: true,
+                        line_buffered: true,
+                    },
+                    line_feeds: true,
+                },
+                JournalEntry::TtySetV1 {
+                    tty: Tty {
+                        cols: 12,
+                        rows: 65,
+                        width: 2341,
+                        height: 573457,
+                        stdin_tty: true,
+                        stdout_tty: false,
+                        stderr_tty: true,
+                        echo: true,
+                        line_buffered: true,
+                    },
+                    line_feeds: true,
+                },
+            ],
+            vec![JournalEntry::TtySetV1 {
+                tty: Tty {
+                    cols: 12,
+                    rows: 65,
+                    width: 2341,
+                    height: 573457,
+                    stdin_tty: true,
+                    stdout_tty: false,
+                    stderr_tty: true,
+                    echo: true,
+                    line_buffered: true,
+                },
+                line_feeds: true,
+            }],
+        )
+        .unwrap()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting_log_file.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting_log_file.rs
new file mode 100644
index 0000000..7bc3302
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/compacting_log_file.rs
@@ -0,0 +1,262 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::{Arc, Mutex},
+};
+
+use super::*;
+
+#[derive(Debug)]
+struct State {
+    on_n_records: Option<u64>,
+    on_n_size: Option<u64>,
+    on_factor_size: Option<f32>,
+    on_drop: bool,
+    cnt_records: u64,
+    cnt_size: u64,
+    ref_size: u64,
+}
+
+#[derive(Debug)]
+pub struct CompactingLogFileJournal {
+    tx: CompactingLogFileJournalTx,
+    rx: CompactingLogFileJournalRx,
+}
+
+#[derive(Debug)]
+pub struct CompactingLogFileJournalTx {
+    state: Arc<Mutex<State>>,
+    inner: CompactingJournalTx,
+    main_path: PathBuf,
+    temp_path: PathBuf,
+}
+
+#[derive(Debug)]
+pub struct CompactingLogFileJournalRx {
+    #[allow(dead_code)]
+    state: Arc<Mutex<State>>,
+    inner: CompactingJournalRx,
+}
+
+impl CompactingLogFileJournalRx {
+    pub fn swap_inner(&mut self, with: Box<DynReadableJournal>) -> Box<DynReadableJournal> {
+        self.inner.swap_inner(with)
+    }
+}
+
+impl CompactingLogFileJournal {
+    pub fn new(path: impl AsRef<Path>) -> anyhow::Result<Self> {
+        // We prepare a compacting journal which does nothing
+        // with the events other than learn from them
+        let counting = CountingJournal::default();
+        let mut compacting = CompactingJournal::new(counting.clone())?;
+
+        // We first feed all the entries into the compactor so that
+        // it learns all the records
+        let log_file = LogFileJournal::new(path.as_ref())?;
+        copy_journal(&log_file, &compacting)?;
+
+        // Now everything is learned its time to attach the
+        // log file to the compacting journal
+        compacting.replace_inner(log_file);
+        let (tx, rx) = compacting.into_split();
+
+        let mut temp_filename = path
+            .as_ref()
+            .file_name()
+            .ok_or_else(|| {
+                anyhow::format_err!(
+                    "The path is not a valid filename - {}",
+                    path.as_ref().to_string_lossy()
+                )
+            })?
+            .to_string_lossy()
+            .to_string();
+        temp_filename.insert_str(0, ".compacting.");
+        let temp_path = path.as_ref().with_file_name(&temp_filename);
+
+        let state = Arc::new(Mutex::new(State {
+            on_drop: false,
+            on_n_records: None,
+            on_n_size: None,
+            on_factor_size: None,
+            cnt_records: 0,
+            cnt_size: 0,
+            ref_size: counting.size(),
+        }));
+        let tx = CompactingLogFileJournalTx {
+            state: state.clone(),
+            inner: tx,
+            main_path: path.as_ref().to_path_buf(),
+            temp_path,
+        };
+        let rx = CompactingLogFileJournalRx { state, inner: rx };
+
+        Ok(Self { tx, rx })
+    }
+
+    pub fn compact_now(&mut self) -> anyhow::Result<CompactResult> {
+        let (result, new_rx) = self.tx.compact_now()?;
+        self.rx.inner = new_rx;
+        Ok(result)
+    }
+
+    pub fn with_compact_on_drop(self) -> Self {
+        self.tx.state.lock().unwrap().on_drop = true;
+        self
+    }
+
+    pub fn with_compact_on_n_records(self, n_records: u64) -> Self {
+        self.tx
+            .state
+            .lock()
+            .unwrap()
+            .on_n_records
+            .replace(n_records);
+        self
+    }
+
+    pub fn with_compact_on_n_size(self, n_size: u64) -> Self {
+        self.tx.state.lock().unwrap().on_n_size.replace(n_size);
+        self
+    }
+
+    pub fn with_compact_on_factor_size(self, factor_size: f32) -> Self {
+        self.tx
+            .state
+            .lock()
+            .unwrap()
+            .on_factor_size
+            .replace(factor_size);
+        self
+    }
+}
+
+impl CompactingLogFileJournalTx {
+    pub fn compact_now(&self) -> anyhow::Result<(CompactResult, CompactingJournalRx)> {
+        // Reset the counters
+        self.reset_counters();
+
+        // Create the staging file and open it
+        std::fs::remove_file(&self.temp_path).ok();
+        let target = LogFileJournal::new(self.temp_path.clone())?;
+
+        // Compact the data into the new target and rename it over the last one
+        let result = self.inner.compact_to(target)?;
+        std::fs::rename(&self.temp_path, &self.main_path)?;
+
+        // Renaming the file has quite a detrimental effect on the file as
+        // it means any new mmap operations will fail, hence we need to
+        // reopen the log file, seek to the end and reattach it
+        let target = LogFileJournal::new(self.main_path.clone())?;
+
+        // We prepare a compacting journal which does nothing
+        // with the events other than learn from them
+        let counting = CountingJournal::default();
+        let mut compacting = CompactingJournal::new(counting)?;
+        copy_journal(&target, &compacting)?;
+
+        // Now everything is learned its time to attach the log file to the compacting journal
+        // and replace the current one
+        compacting.replace_inner(target);
+        let (tx, rx) = compacting.into_split();
+        self.inner.swap(tx);
+
+        // We take a new reference point for the size of the journal
+        {
+            let mut state = self.state.lock().unwrap();
+            state.ref_size = result.total_size;
+        }
+
+        Ok((result, rx))
+    }
+
+    pub fn reset_counters(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.cnt_records = 0;
+        state.cnt_size = 0;
+    }
+}
+
+impl Drop for CompactingLogFileJournalTx {
+    fn drop(&mut self) {
+        let triggered = self.state.lock().unwrap().on_drop;
+        if triggered {
+            if let Err(err) = self.compact_now() {
+                tracing::error!("failed to compact log - {}", err);
+            }
+        }
+    }
+}
+
+impl ReadableJournal for CompactingLogFileJournalRx {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.inner.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.inner.as_restarted()
+    }
+}
+
+impl WritableJournal for CompactingLogFileJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let res = self.inner.write(entry)?;
+
+        let triggered = {
+            let mut state = self.state.lock().unwrap();
+            if res.record_size() > 0 {
+                state.cnt_records += 1;
+                state.cnt_size += res.record_size();
+            }
+
+            let mut triggered = false;
+            if let Some(on) = state.on_n_records.as_ref() {
+                if state.cnt_records >= *on {
+                    triggered = true;
+                }
+            }
+            if let Some(on) = state.on_n_size.as_ref() {
+                if state.cnt_size >= *on {
+                    triggered = true;
+                }
+            }
+
+            if let Some(factor) = state.on_factor_size.as_ref() {
+                let next_ref = (*factor * state.ref_size as f32) as u64;
+                if state.cnt_size > next_ref {
+                    triggered = true;
+                }
+            }
+
+            triggered
+        };
+
+        if triggered {
+            self.compact_now()?;
+        }
+
+        Ok(res)
+    }
+}
+
+impl ReadableJournal for CompactingLogFileJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl WritableJournal for CompactingLogFileJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl Journal for CompactingLogFileJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/counting.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/counting.rs
new file mode 100644
index 0000000..e7c32c0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/counting.rs
@@ -0,0 +1,51 @@
+use std::sync::{
+    atomic::{AtomicU64, AtomicUsize, Ordering},
+    Arc,
+};
+
+use super::*;
+
+/// Journal that counts the size of the entries that are written to it
+#[derive(Debug, Clone, Default)]
+pub struct CountingJournal {
+    n_cnt: Arc<AtomicUsize>,
+    n_size: Arc<AtomicU64>,
+}
+
+impl CountingJournal {
+    pub fn cnt(&self) -> usize {
+        self.n_cnt.load(Ordering::SeqCst)
+    }
+
+    pub fn size(&self) -> u64 {
+        self.n_size.load(Ordering::SeqCst)
+    }
+}
+
+impl ReadableJournal for CountingJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        Ok(None)
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::<CountingJournal>::default())
+    }
+}
+
+impl WritableJournal for CountingJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let size = entry.estimate_size() as u64;
+        let offset = self.n_cnt.fetch_add(1, Ordering::SeqCst);
+        self.n_size.fetch_add(size, Ordering::SeqCst);
+        Ok(LogWriteResult {
+            record_start: offset as u64,
+            record_end: offset as u64 + size,
+        })
+    }
+}
+
+impl Journal for CountingJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.clone()), Box::new(self))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/filter.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/filter.rs
new file mode 100644
index 0000000..f0bef52
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/filter.rs
@@ -0,0 +1,381 @@
+use std::{
+    collections::HashSet,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+use derivative::Derivative;
+
+use super::*;
+
+/// Filters out a specific set of journal events and drops the rest, this
+/// journal can be useful for restoring to a previous call point but
+/// retaining the memory changes (e.g. WCGI runner).
+#[derive(Debug)]
+pub struct FilteredJournal {
+    tx: FilteredJournalTx,
+    rx: FilteredJournalRx,
+}
+
+/// Represents what will be filtered by the filtering process
+#[derive(Debug)]
+struct FilteredJournalConfig {
+    filter_memory: bool,
+    filter_threads: bool,
+    filter_fs: bool,
+    filter_stdio: bool,
+    filter_core: bool,
+    filter_snapshots: bool,
+    filter_net: bool,
+    filter_events: Option<HashSet<usize>>,
+    event_index: AtomicUsize,
+}
+
+impl Default for FilteredJournalConfig {
+    fn default() -> Self {
+        Self {
+            filter_memory: false,
+            filter_threads: false,
+            filter_fs: false,
+            filter_stdio: false,
+            filter_core: false,
+            filter_snapshots: false,
+            filter_net: false,
+            filter_events: None,
+            event_index: AtomicUsize::new(0),
+        }
+    }
+}
+
+impl Clone for FilteredJournalConfig {
+    fn clone(&self) -> Self {
+        Self {
+            filter_memory: self.filter_memory,
+            filter_threads: self.filter_threads,
+            filter_fs: self.filter_fs,
+            filter_stdio: self.filter_stdio,
+            filter_core: self.filter_core,
+            filter_snapshots: self.filter_snapshots,
+            filter_net: self.filter_net,
+            filter_events: self.filter_events.clone(),
+            event_index: AtomicUsize::new(self.event_index.load(Ordering::SeqCst)),
+        }
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct FilteredJournalTx {
+    #[derivative(Debug = "ignore")]
+    inner: Box<DynWritableJournal>,
+    config: FilteredJournalConfig,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct FilteredJournalRx {
+    #[derivative(Debug = "ignore")]
+    inner: Box<DynReadableJournal>,
+}
+
+/// Constructs a filter with a set of parameters that will be filtered on
+#[derive(Debug, Default)]
+pub struct FilteredJournalBuilder {
+    config: FilteredJournalConfig,
+}
+
+impl FilteredJournalBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn build<J>(self, inner: J) -> FilteredJournal
+    where
+        J: Journal,
+    {
+        FilteredJournal::new(inner, self.config)
+    }
+
+    pub fn with_ignore_memory(mut self, val: bool) -> Self {
+        self.config.filter_memory = val;
+        self
+    }
+
+    pub fn with_ignore_threads(mut self, val: bool) -> Self {
+        self.config.filter_threads = val;
+        self
+    }
+
+    pub fn with_ignore_fs(mut self, val: bool) -> Self {
+        self.config.filter_fs = val;
+        self
+    }
+
+    pub fn with_ignore_stdio(mut self, val: bool) -> Self {
+        self.config.filter_stdio = val;
+        self
+    }
+
+    pub fn with_ignore_core(mut self, val: bool) -> Self {
+        self.config.filter_core = val;
+        self
+    }
+
+    pub fn with_ignore_snapshots(mut self, val: bool) -> Self {
+        self.config.filter_snapshots = val;
+        self
+    }
+
+    pub fn with_ignore_networking(mut self, val: bool) -> Self {
+        self.config.filter_net = val;
+        self
+    }
+
+    pub fn with_filter_events(mut self, events: HashSet<usize>) -> Self {
+        self.config.filter_events = Some(events);
+        self
+    }
+
+    pub fn add_event_to_whitelist(&mut self, event_index: usize) {
+        if let Some(filter) = self.config.filter_events.as_mut() {
+            filter.insert(event_index);
+        }
+    }
+
+    pub fn set_ignore_memory(&mut self, val: bool) -> &mut Self {
+        self.config.filter_memory = val;
+        self
+    }
+
+    pub fn set_ignore_threads(&mut self, val: bool) -> &mut Self {
+        self.config.filter_threads = val;
+        self
+    }
+
+    pub fn set_ignore_fs(&mut self, val: bool) -> &mut Self {
+        self.config.filter_fs = val;
+        self
+    }
+
+    pub fn set_ignore_stdio(&mut self, val: bool) -> &mut Self {
+        self.config.filter_stdio = val;
+        self
+    }
+
+    pub fn set_ignore_core(&mut self, val: bool) -> &mut Self {
+        self.config.filter_core = val;
+        self
+    }
+
+    pub fn set_ignore_snapshots(&mut self, val: bool) -> &mut Self {
+        self.config.filter_snapshots = val;
+        self
+    }
+
+    pub fn set_ignore_networking(&mut self, val: bool) -> &mut Self {
+        self.config.filter_net = val;
+        self
+    }
+}
+
+impl FilteredJournal {
+    fn new<J>(inner: J, config: FilteredJournalConfig) -> Self
+    where
+        J: Journal,
+    {
+        let (tx, rx) = inner.split();
+        Self {
+            tx: FilteredJournalTx { inner: tx, config },
+            rx: FilteredJournalRx { inner: rx },
+        }
+    }
+
+    pub fn clone_with_inner<J>(&self, inner: J) -> Self
+    where
+        J: Journal,
+    {
+        let config = self.tx.config.clone();
+        let (tx, rx) = inner.split();
+        Self {
+            tx: FilteredJournalTx { config, inner: tx },
+            rx: FilteredJournalRx { inner: rx },
+        }
+    }
+
+    pub fn into_inner(self) -> RecombinedJournal {
+        RecombinedJournal::new(self.tx.inner, self.rx.inner)
+    }
+}
+
+impl WritableJournal for FilteredJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let event_index = self.config.event_index.fetch_add(1, Ordering::SeqCst);
+        if let Some(events) = self.config.filter_events.as_ref() {
+            if !events.contains(&event_index) {
+                return Ok(LogWriteResult {
+                    record_start: 0,
+                    record_end: 0,
+                });
+            }
+        }
+
+        let evt = match entry {
+            JournalEntry::SetClockTimeV1 { .. }
+            | JournalEntry::InitModuleV1 { .. }
+            | JournalEntry::ProcessExitV1 { .. }
+            | JournalEntry::EpollCreateV1 { .. }
+            | JournalEntry::EpollCtlV1 { .. }
+            | JournalEntry::TtySetV1 { .. } => {
+                if self.config.filter_core {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::ClearEtherealV1 => entry,
+            JournalEntry::SetThreadV1 { .. } | JournalEntry::CloseThreadV1 { .. } => {
+                if self.config.filter_threads {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::UpdateMemoryRegionV1 { .. } => {
+                if self.config.filter_memory {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::FileDescriptorSeekV1 { fd, .. }
+            | JournalEntry::FileDescriptorWriteV1 { fd, .. }
+            | JournalEntry::OpenFileDescriptorV1 { fd, .. }
+            | JournalEntry::CloseFileDescriptorV1 { fd, .. }
+            | JournalEntry::RenumberFileDescriptorV1 { old_fd: fd, .. }
+            | JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd: fd, ..
+            }
+            | JournalEntry::FileDescriptorSetFlagsV1 { fd, .. }
+            | JournalEntry::FileDescriptorAdviseV1 { fd, .. }
+            | JournalEntry::FileDescriptorAllocateV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetRightsV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetTimesV1 { fd, .. }
+            | JournalEntry::FileDescriptorSetSizeV1 { fd, .. } => {
+                if self.config.filter_stdio && fd <= 2 {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                if self.config.filter_fs {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::RemoveDirectoryV1 { .. }
+            | JournalEntry::UnlinkFileV1 { .. }
+            | JournalEntry::PathRenameV1 { .. }
+            | JournalEntry::CreateDirectoryV1 { .. }
+            | JournalEntry::PathSetTimesV1 { .. }
+            | JournalEntry::CreateHardLinkV1 { .. }
+            | JournalEntry::CreateSymbolicLinkV1 { .. }
+            | JournalEntry::ChangeDirectoryV1 { .. }
+            | JournalEntry::CreatePipeV1 { .. }
+            | JournalEntry::CreateEventV1 { .. } => {
+                if self.config.filter_fs {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::SnapshotV1 { .. } => {
+                if self.config.filter_snapshots {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+            JournalEntry::PortAddAddrV1 { .. }
+            | JournalEntry::PortDelAddrV1 { .. }
+            | JournalEntry::PortAddrClearV1
+            | JournalEntry::PortBridgeV1 { .. }
+            | JournalEntry::PortUnbridgeV1
+            | JournalEntry::PortDhcpAcquireV1
+            | JournalEntry::PortGatewaySetV1 { .. }
+            | JournalEntry::PortRouteAddV1 { .. }
+            | JournalEntry::PortRouteClearV1
+            | JournalEntry::PortRouteDelV1 { .. }
+            | JournalEntry::SocketOpenV1 { .. }
+            | JournalEntry::SocketListenV1 { .. }
+            | JournalEntry::SocketBindV1 { .. }
+            | JournalEntry::SocketConnectedV1 { .. }
+            | JournalEntry::SocketAcceptedV1 { .. }
+            | JournalEntry::SocketJoinIpv4MulticastV1 { .. }
+            | JournalEntry::SocketJoinIpv6MulticastV1 { .. }
+            | JournalEntry::SocketLeaveIpv4MulticastV1 { .. }
+            | JournalEntry::SocketLeaveIpv6MulticastV1 { .. }
+            | JournalEntry::SocketSendFileV1 { .. }
+            | JournalEntry::SocketSendToV1 { .. }
+            | JournalEntry::SocketSendV1 { .. }
+            | JournalEntry::SocketSetOptFlagV1 { .. }
+            | JournalEntry::SocketSetOptSizeV1 { .. }
+            | JournalEntry::SocketSetOptTimeV1 { .. }
+            | JournalEntry::SocketShutdownV1 { .. } => {
+                if self.config.filter_net {
+                    return Ok(LogWriteResult {
+                        record_start: 0,
+                        record_end: 0,
+                    });
+                }
+                entry
+            }
+        };
+        self.inner.write(evt)
+    }
+}
+
+impl ReadableJournal for FilteredJournalRx {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.inner.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::new(FilteredJournalRx {
+            inner: self.inner.as_restarted()?,
+        }))
+    }
+}
+
+impl WritableJournal for FilteredJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for FilteredJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl Journal for FilteredJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/log_file.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/log_file.rs
new file mode 100644
index 0000000..864bd0e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/log_file.rs
@@ -0,0 +1,487 @@
+use bytes::Buf;
+use rkyv::ser::{
+    serializers::{AllocScratch, CompositeSerializer, SharedSerializeMap, WriteSerializer},
+    Serializer,
+};
+use shared_buffer::OwnedBuffer;
+use std::{
+    fs::File,
+    io::{Seek, SeekFrom, Write},
+    path::Path,
+    sync::{Arc, Mutex},
+};
+use virtual_fs::mem_fs::OffloadBackingStore;
+
+use super::*;
+
+/// The LogFile snapshot capturer will write its snapshots to a linear journal
+/// and read them when restoring. It uses the `bincode` serializer which
+/// means that forwards and backwards compatibility must be dealt with
+/// carefully.
+///
+/// When opening an existing journal file that was previously saved
+/// then new entries will be added to the end regardless of if
+/// its been read.
+///
+/// The logfile snapshot capturer uses a 64bit number as a entry encoding
+/// delimiter.
+#[derive(Debug)]
+pub struct LogFileJournal {
+    tx: LogFileJournalTx,
+    rx: LogFileJournalRx,
+}
+
+#[derive(Debug)]
+struct TxState {
+    file: File,
+    serializer: CompositeSerializer<WriteSerializer<File>, AllocScratch, SharedSerializeMap>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LogFileJournalTx {
+    state: Arc<Mutex<TxState>>,
+}
+
+#[derive(Debug)]
+pub struct LogFileJournalRx {
+    tx: Option<LogFileJournalTx>,
+    buffer_pos: Mutex<usize>,
+    buffer: OwnedBuffer,
+    store: OffloadBackingStore,
+}
+
+impl LogFileJournalRx {
+    pub fn owned_buffer(&self) -> OwnedBuffer {
+        self.store.owned_buffer().clone()
+    }
+
+    pub fn backing_store(&self) -> OffloadBackingStore {
+        self.store.clone()
+    }
+}
+
+impl LogFileJournalTx {
+    pub fn as_rx(&self) -> anyhow::Result<LogFileJournalRx> {
+        let state = self.state.lock().unwrap();
+        let file = state.file.try_clone()?;
+
+        let store = OffloadBackingStore::from_file(&file);
+        let buffer = store.owned_buffer();
+
+        // If the buffer exists we valid the magic number
+        let mut buffer_pos = 0;
+        let mut buffer_ptr = buffer.as_ref();
+        if buffer_ptr.len() >= 8 {
+            let magic = u64::from_be_bytes(buffer_ptr[0..8].try_into().unwrap());
+            if magic != JOURNAL_MAGIC_NUMBER {
+                return Err(anyhow::format_err!(
+                    "invalid magic number of journal ({} vs {})",
+                    magic,
+                    JOURNAL_MAGIC_NUMBER
+                ));
+            }
+            buffer_ptr.advance(8);
+            buffer_pos += 8;
+        } else {
+            tracing::trace!("journal has no magic (could be empty?)");
+        }
+
+        Ok(LogFileJournalRx {
+            tx: Some(self.clone()),
+            buffer_pos: Mutex::new(buffer_pos),
+            buffer,
+            store,
+        })
+    }
+}
+
+impl LogFileJournal {
+    pub fn new(path: impl AsRef<Path>) -> anyhow::Result<Self> {
+        let file = std::fs::File::options()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open(path)?;
+        Self::from_file(file)
+    }
+
+    pub fn owned_buffer(&self) -> OwnedBuffer {
+        self.rx.owned_buffer()
+    }
+
+    pub fn backing_store(&self) -> OffloadBackingStore {
+        self.rx.backing_store()
+    }
+
+    /// Create a new journal from a file
+    pub fn from_file(mut file: std::fs::File) -> anyhow::Result<Self> {
+        // Move to the end of the file and write the
+        // magic if one is needed
+        let underlying_file = file.try_clone()?;
+        let end_pos = file.seek(SeekFrom::End(0))?;
+        let mut serializer = WriteSerializer::with_pos(file, end_pos as usize);
+        if serializer.pos() == 0 {
+            let magic = JOURNAL_MAGIC_NUMBER;
+            let magic = magic.to_be_bytes();
+            serializer.write(&magic)?;
+        }
+
+        // Create the tx
+        let tx = LogFileJournalTx {
+            state: Arc::new(Mutex::new(TxState {
+                file: underlying_file,
+                serializer: CompositeSerializer::new(
+                    serializer,
+                    AllocScratch::default(),
+                    SharedSerializeMap::default(),
+                ),
+            })),
+        };
+
+        // First we create the readable journal
+        let rx = tx.as_rx()?;
+
+        Ok(Self { rx, tx })
+    }
+
+    /// Create a new journal from a buffer
+    pub fn from_buffer(buffer: OwnedBuffer) -> RecombinedJournal {
+        // Create the rx
+        let rx = LogFileJournalRx {
+            tx: None,
+            buffer_pos: Mutex::new(0),
+            buffer: buffer.clone(),
+            store: OffloadBackingStore::from_buffer(buffer),
+        };
+
+        // Create an unsupported write journal
+        let tx = UnsupportedJournal::default();
+
+        // Now recombine
+        RecombinedJournal::new(Box::new(tx), Box::new(rx))
+    }
+}
+
+impl WritableJournal for LogFileJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        tracing::debug!("journal event: {:?}", entry);
+
+        let mut state = self.state.lock().unwrap();
+
+        // Write the header (with a record size of zero)
+        let record_type: JournalEntryRecordType = entry.archive_record_type();
+        let offset_header = state.serializer.pos() as u64;
+        state.serializer.write(&[0u8; 8])?;
+
+        // Now serialize the actual data to the log
+        let offset_start = state.serializer.pos() as u64;
+        entry.serialize_archive(&mut state.serializer)?;
+        let offset_end = state.serializer.pos() as u64;
+        let record_size = offset_end - offset_start;
+        tracing::trace!(
+            "delimiter header={offset_header},start={offset_start},record_size={record_size}"
+        );
+
+        // Write the record and then move back to the end again
+        state.file.seek(SeekFrom::Start(offset_header))?;
+        let header_bytes = {
+            let a = (record_type as u16).to_be_bytes();
+            let b = &record_size.to_be_bytes()[2..8];
+            [a[0], a[1], b[0], b[1], b[2], b[3], b[4], b[5]]
+        };
+        state.file.write_all(&header_bytes)?;
+        state.file.seek(SeekFrom::Start(offset_end))?;
+
+        // Now write the actual data and update the offsets
+        Ok(LogWriteResult {
+            record_start: offset_start,
+            record_end: offset_end,
+        })
+    }
+}
+
+impl ReadableJournal for LogFileJournalRx {
+    /// UNSAFE: This method uses unsafe operations to remove the need to zero
+    /// the buffer before its read the log entries into it
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        let mut buffer_pos = self.buffer_pos.lock().unwrap();
+
+        // Get a memory reference to the data on the disk at
+        // the current read location
+        let mut buffer_ptr = self.buffer.as_ref();
+        buffer_ptr.advance(*buffer_pos);
+        loop {
+            // Read the headers and advance
+            if buffer_ptr.len() < 8 {
+                return Ok(None);
+            }
+
+            let record_type: JournalEntryRecordType;
+            let header = {
+                let b = buffer_ptr;
+
+                // If the next header is the magic itself then skip it.
+                // You may be wondering how a magic could appear later
+                // in the journal itself. This can happen if someone
+                // concat's multiple journals together to make a combined
+                // journal
+                if b[0..8] == JOURNAL_MAGIC_NUMBER_BYTES[0..8] {
+                    buffer_ptr.advance(8);
+                    *buffer_pos += 8;
+                    continue;
+                }
+
+                // Otherwise we decode the header
+                let header = JournalEntryHeader {
+                    record_type: u16::from_be_bytes([b[0], b[1]]),
+                    record_size: u64::from_be_bytes([0u8, 0u8, b[2], b[3], b[4], b[5], b[6], b[7]]),
+                };
+
+                // Now we read the entry
+                record_type = match header.record_type.try_into() {
+                    Ok(t) => t,
+                    Err(_) => {
+                        tracing::debug!(
+                            "unknown journal entry type ({}) - the journal stops here",
+                            header.record_type
+                        );
+                        return Ok(None);
+                    }
+                };
+
+                buffer_ptr.advance(8);
+                *buffer_pos += 8;
+                header
+            };
+            let record_start = *buffer_pos as u64;
+
+            // Move the buffer position forward past the record
+            let entry = &buffer_ptr[..(header.record_size as usize)];
+            buffer_ptr.advance(header.record_size as usize);
+            *buffer_pos += header.record_size as usize;
+
+            let record = unsafe { record_type.deserialize_archive(entry)? };
+            return Ok(Some(LogReadResult {
+                record_start,
+                record_end: *buffer_pos as u64,
+                record,
+            }));
+        }
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        if let Some(tx) = &self.tx {
+            let ret = tx.as_rx()?;
+            Ok(Box::new(ret))
+        } else {
+            Ok(Box::new(LogFileJournalRx {
+                tx: None,
+                buffer_pos: Mutex::new(0),
+                buffer: self.buffer.clone(),
+                store: self.store.clone(),
+            }))
+        }
+    }
+}
+
+impl WritableJournal for LogFileJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for LogFileJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl Journal for LogFileJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use wasmer_wasix_types::wasix::WasiMemoryLayout;
+
+    use super::*;
+
+    #[tracing_test::traced_test]
+    #[test]
+    pub fn test_save_and_load_journal_events() {
+        // Get a random file path
+        let file = tempfile::NamedTempFile::new().unwrap();
+
+        // Write some events to it
+        let journal = LogFileJournal::from_file(file.as_file().try_clone().unwrap()).unwrap();
+        journal
+            .write(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 })
+            .unwrap();
+        journal
+            .write(JournalEntry::SetThreadV1 {
+                id: 1,
+                call_stack: vec![11; 116].into(),
+                memory_stack: vec![22; 16].into(),
+                store_data: vec![33; 136].into(),
+                is_64bit: false,
+                layout: WasiMemoryLayout {
+                    stack_upper: 0,
+                    stack_lower: 1024,
+                    guard_size: 16,
+                    stack_size: 1024,
+                },
+                start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
+            })
+            .unwrap();
+        journal.write(JournalEntry::PortAddrClearV1).unwrap();
+        drop(journal);
+
+        // Read the events and validate
+        let journal = LogFileJournal::new(file.path()).unwrap();
+        let event1 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event2 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event3 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event4 = journal.read().unwrap().map(LogReadResult::into_inner);
+
+        // Check the events
+        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event2,
+            Some(JournalEntry::SetThreadV1 {
+                id: 1,
+                call_stack: vec![11; 116].into(),
+                memory_stack: vec![22; 16].into(),
+                store_data: vec![33; 136].into(),
+                is_64bit: false,
+                layout: WasiMemoryLayout {
+                    stack_upper: 0,
+                    stack_lower: 1024,
+                    guard_size: 16,
+                    stack_size: 1024,
+                },
+                start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
+            })
+        );
+        assert_eq!(event3, Some(JournalEntry::PortAddrClearV1));
+        assert_eq!(event4, None);
+
+        // Now write another event
+        journal
+            .write(JournalEntry::SocketSendV1 {
+                fd: 1234,
+                data: [12; 1024].to_vec().into(),
+                flags: 123,
+                is_64bit: true,
+            })
+            .unwrap();
+
+        // The event should not be visible yet unless we reload the log file
+        assert_eq!(journal.read().unwrap().map(LogReadResult::into_inner), None);
+
+        // Reload the load file
+        let journal = LogFileJournal::new(file.path()).unwrap();
+
+        // Before we read it, we will throw in another event
+        journal
+            .write(JournalEntry::CreatePipeV1 {
+                fd1: 1234,
+                fd2: 5432,
+            })
+            .unwrap();
+
+        let event1 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event2 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event3 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event4 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event5 = journal.read().unwrap().map(LogReadResult::into_inner);
+        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event2,
+            Some(JournalEntry::SetThreadV1 {
+                id: 1,
+                call_stack: vec![11; 116].into(),
+                memory_stack: vec![22; 16].into(),
+                store_data: vec![33; 136].into(),
+                is_64bit: false,
+                layout: WasiMemoryLayout {
+                    stack_upper: 0,
+                    stack_lower: 1024,
+                    guard_size: 16,
+                    stack_size: 1024,
+                },
+                start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
+            })
+        );
+        assert_eq!(event3, Some(JournalEntry::PortAddrClearV1));
+        assert_eq!(
+            event4,
+            Some(JournalEntry::SocketSendV1 {
+                fd: 1234,
+                data: [12; 1024].to_vec().into(),
+                flags: 123,
+                is_64bit: true,
+            })
+        );
+        assert_eq!(event5, None);
+
+        // Load it again
+        let journal = LogFileJournal::new(file.path()).unwrap();
+
+        let event1 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event2 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event3 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event4 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event5 = journal.read().unwrap().map(LogReadResult::into_inner);
+        let event6 = journal.read().unwrap().map(LogReadResult::into_inner);
+
+        tracing::info!("event1 {:?}", event1);
+        tracing::info!("event2 {:?}", event2);
+        tracing::info!("event3 {:?}", event3);
+        tracing::info!("event4 {:?}", event4);
+        tracing::info!("event5 {:?}", event5);
+        tracing::info!("event6 {:?}", event6);
+
+        assert_eq!(event1, Some(JournalEntry::CreatePipeV1 { fd1: 1, fd2: 2 }));
+        assert_eq!(
+            event2,
+            Some(JournalEntry::SetThreadV1 {
+                id: 1,
+                call_stack: vec![11; 116].into(),
+                memory_stack: vec![22; 16].into(),
+                store_data: vec![33; 136].into(),
+                is_64bit: false,
+                layout: WasiMemoryLayout {
+                    stack_upper: 0,
+                    stack_lower: 1024,
+                    guard_size: 16,
+                    stack_size: 1024,
+                },
+                start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
+            })
+        );
+        assert_eq!(event3, Some(JournalEntry::PortAddrClearV1));
+        assert_eq!(
+            event4,
+            Some(JournalEntry::SocketSendV1 {
+                fd: 1234,
+                data: [12; 1024].to_vec().into(),
+                flags: 123,
+                is_64bit: true,
+            })
+        );
+        assert_eq!(
+            event5,
+            Some(JournalEntry::CreatePipeV1 {
+                fd1: 1234,
+                fd2: 5432,
+            })
+        );
+        assert_eq!(event6, None);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/mod.rs
new file mode 100644
index 0000000..c517635
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/mod.rs
@@ -0,0 +1,40 @@
+mod aligned_cow_str;
+mod aligned_cow_vec;
+mod arc;
+mod archived;
+mod archived_from;
+mod boxed;
+mod buffered;
+mod compacting;
+#[cfg(feature = "log-file")]
+mod compacting_log_file;
+mod counting;
+mod filter;
+#[cfg(feature = "log-file")]
+mod log_file;
+mod null;
+mod pipe;
+mod printing;
+mod recombined;
+#[cfg(test)]
+mod tests;
+mod unsupported;
+
+pub(super) use super::*;
+
+pub use aligned_cow_str::*;
+pub use aligned_cow_vec::*;
+pub use archived::*;
+pub use buffered::*;
+pub use compacting::*;
+#[cfg(feature = "log-file")]
+pub use compacting_log_file::*;
+pub use counting::*;
+pub use filter::*;
+#[cfg(feature = "log-file")]
+pub use log_file::*;
+pub use null::*;
+pub use pipe::*;
+pub use printing::*;
+pub use recombined::*;
+pub use unsupported::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/null.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/null.rs
new file mode 100644
index 0000000..f7b34e6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/null.rs
@@ -0,0 +1,37 @@
+use super::*;
+
+pub static NULL_JOURNAL: NullJournal = NullJournal { debug_print: false };
+
+/// The null journal sends all the records into the abyss
+#[derive(Debug, Default)]
+pub struct NullJournal {
+    debug_print: bool,
+}
+
+impl ReadableJournal for NullJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        Ok(None)
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::<NullJournal>::default())
+    }
+}
+
+impl WritableJournal for NullJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        if self.debug_print {
+            tracing::debug!("journal event: {:?}", entry);
+        }
+        Ok(LogWriteResult {
+            record_start: 0,
+            record_end: entry.estimate_size() as u64,
+        })
+    }
+}
+
+impl Journal for NullJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::<NullJournal>::default(), Box::<NullJournal>::default())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/pipe.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/pipe.rs
new file mode 100644
index 0000000..94a8c85
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/pipe.rs
@@ -0,0 +1,127 @@
+use std::sync::mpsc::TryRecvError;
+use std::sync::Mutex;
+use std::sync::{mpsc, Arc};
+
+use super::*;
+
+// The pipe journal will feed journal entries between two bi-directional ends
+// of a pipe.
+#[derive(Debug)]
+pub struct PipeJournal {
+    tx: PipeJournalTx,
+    rx: PipeJournalRx,
+}
+
+#[derive(Debug)]
+pub struct PipeJournalRx {
+    receiver: Arc<Mutex<mpsc::Receiver<LogReadResult<'static>>>>,
+}
+
+#[derive(Debug)]
+struct SenderState {
+    offset: u64,
+    sender: mpsc::Sender<LogReadResult<'static>>,
+}
+
+#[derive(Debug)]
+pub struct PipeJournalTx {
+    sender: Arc<Mutex<SenderState>>,
+}
+
+impl PipeJournal {
+    pub fn channel() -> (Self, Self) {
+        let (tx1, rx1) = mpsc::channel();
+        let (tx2, rx2) = mpsc::channel();
+
+        let end1 = PipeJournal {
+            tx: PipeJournalTx {
+                sender: Arc::new(Mutex::new(SenderState {
+                    offset: 0,
+                    sender: tx1,
+                })),
+            },
+            rx: PipeJournalRx {
+                receiver: Arc::new(Mutex::new(rx2)),
+            },
+        };
+
+        let end2 = PipeJournal {
+            tx: PipeJournalTx {
+                sender: Arc::new(Mutex::new(SenderState {
+                    offset: 0,
+                    sender: tx2,
+                })),
+            },
+            rx: PipeJournalRx {
+                receiver: Arc::new(Mutex::new(rx1)),
+            },
+        };
+
+        (end1, end2)
+    }
+}
+
+impl WritableJournal for PipeJournalTx {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        let entry = entry.into_owned();
+        let entry_size = entry.estimate_size() as u64;
+
+        let mut sender = self.sender.lock().unwrap();
+        sender
+            .sender
+            .send(LogReadResult {
+                record_start: sender.offset,
+                record_end: sender.offset + entry_size,
+                record: entry,
+            })
+            .map_err(|err| {
+                anyhow::format_err!("failed to send journal event through the pipe - {}", err)
+            })?;
+        sender.offset += entry_size;
+        Ok(LogWriteResult {
+            record_start: sender.offset,
+            record_end: sender.offset + entry_size,
+        })
+    }
+}
+
+impl ReadableJournal for PipeJournalRx {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        let rx = self.receiver.lock().unwrap();
+        match rx.try_recv() {
+            Ok(e) => Ok(Some(e)),
+            Err(TryRecvError::Empty) => Ok(None),
+            Err(TryRecvError::Disconnected) => Err(anyhow::format_err!(
+                "failed to receive journal event from the pipe as its disconnected"
+            )),
+        }
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::new(PipeJournalRx {
+            receiver: self.receiver.clone(),
+        }))
+    }
+}
+
+impl WritableJournal for PipeJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for PipeJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl Journal for PipeJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (Box::new(self.tx), Box::new(self.rx))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/printing.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/printing.rs
new file mode 100644
index 0000000..baa2959
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/printing.rs
@@ -0,0 +1,350 @@
+use std::fmt;
+
+use super::*;
+use wasmer_wasix_types::wasi;
+
+/// Type of printing mode to use
+#[derive(Debug)]
+pub enum JournalPrintingMode {
+    Text,
+    Json,
+}
+impl Default for JournalPrintingMode {
+    fn default() -> Self {
+        Self::Text
+    }
+}
+
+/// The default for runtime is to use the unsupported journal
+/// which will fail to write journal entries if one attempts to do so.
+#[derive(Debug, Default)]
+pub struct PrintingJournal {
+    mode: JournalPrintingMode,
+}
+
+impl PrintingJournal {
+    pub fn new(mode: JournalPrintingMode) -> Self {
+        Self { mode }
+    }
+}
+
+impl ReadableJournal for PrintingJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        Ok(None)
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::<PrintingJournal>::default())
+    }
+}
+
+impl WritableJournal for PrintingJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        match self.mode {
+            JournalPrintingMode::Text => println!("{}", entry),
+            JournalPrintingMode::Json => {
+                println!("{}", serde_json::to_string_pretty(&entry)?)
+            }
+        }
+        Ok(LogWriteResult {
+            record_start: 0,
+            record_end: entry.estimate_size() as u64,
+        })
+    }
+}
+
+impl Journal for PrintingJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (
+            Box::<PrintingJournal>::default(),
+            Box::<PrintingJournal>::default(),
+        )
+    }
+}
+
+impl<'a> fmt::Display for JournalEntry<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            JournalEntry::InitModuleV1 { wasm_hash } => {
+                write!(f, "init-module (hash={:x?})", wasm_hash)
+            }
+            JournalEntry::ClearEtherealV1 => {
+                write!(f, "clear-ethereal")
+            }
+            JournalEntry::UpdateMemoryRegionV1 { region, data } => write!(
+                f,
+                "memory-update (start={}, end={}, data.len={})",
+                region.start,
+                region.end,
+                data.len()
+            ),
+            JournalEntry::ProcessExitV1 { exit_code } => {
+                write!(f, "process-exit (code={:?})", exit_code)
+            }
+            JournalEntry::SetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                ..
+            } => write!(
+                f,
+                "thread-update (id={}, call-stack.len={}, mem-stack.len={}, store-size={}",
+                id,
+                call_stack.len(),
+                memory_stack.len(),
+                store_data.len(),
+            ),
+            JournalEntry::CloseThreadV1 { id, exit_code } => {
+                write!(f, "thread-close (id={}, code={:?})", id, exit_code)
+            }
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => write!(
+                f,
+                "fd-seek (fd={}, offset={}, whence={:?})",
+                fd, offset, whence
+            ),
+            JournalEntry::FileDescriptorWriteV1 {
+                fd, offset, data, ..
+            } => write!(
+                f,
+                "fd-write (fd={}, offset={}, data.len={})",
+                fd,
+                offset,
+                data.len()
+            ),
+            JournalEntry::SetClockTimeV1 { clock_id, time } => {
+                write!(f, "set-clock-time (id={:?}, time={})", clock_id, time)
+            }
+            JournalEntry::CloseFileDescriptorV1 { fd } => write!(f, "fd-close (fd={})", fd),
+            JournalEntry::OpenFileDescriptorV1 {
+                fd, path, o_flags, ..
+            } => {
+                if o_flags.contains(wasi::Oflags::CREATE) {
+                    if o_flags.contains(wasi::Oflags::TRUNC) {
+                        write!(f, "fd-create-new (fd={}, path={})", fd, path)
+                    } else {
+                        write!(f, "fd-create (fd={}, path={})", fd, path)
+                    }
+                } else if o_flags.contains(wasi::Oflags::TRUNC) {
+                    write!(f, "fd-open-new (fd={}, path={})", fd, path)
+                } else {
+                    write!(f, "fd-open (fd={}, path={})", fd, path)
+                }
+            }
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                write!(f, "fd-renumber (old={}, new={})", old_fd, new_fd)
+            }
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => write!(
+                f,
+                "fd-duplicate (original={}, copied={})",
+                original_fd, copied_fd
+            ),
+            JournalEntry::CreateDirectoryV1 { fd, path } => {
+                write!(f, "path-create-dir (fd={}, path={})", fd, path)
+            }
+            JournalEntry::RemoveDirectoryV1 { fd, path } => {
+                write!(f, "path-remove-dir (fd={}, path={})", fd, path)
+            }
+            JournalEntry::PathSetTimesV1 {
+                path,
+                st_atim,
+                st_mtim,
+                ..
+            } => write!(
+                f,
+                "path-set-times (path={}, atime={}, mtime={}))",
+                path, st_atim, st_mtim
+            ),
+            JournalEntry::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                ..
+            } => write!(
+                f,
+                "fd-set-times (fd={}, atime={}, mtime={})",
+                fd, st_atim, st_mtim
+            ),
+            JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
+                write!(f, "fd-set-flags (fd={}, flags={:?})", fd, flags)
+            }
+            JournalEntry::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            } => write!(
+                f,
+                "fd-set-rights (fd={}, base={:?}, inherited={:?})",
+                fd, fs_rights_base, fs_rights_inheriting
+            ),
+            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
+                write!(f, "fd-set-size (fd={}, size={})", fd, st_size)
+            }
+            JournalEntry::FileDescriptorAdviseV1 {
+                fd, offset, len, ..
+            } => write!(f, "fd-advise (fd={}, offset={}, len={})", fd, offset, len),
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
+                write!(f, "fd-allocate (fd={}, offset={}, len={})", fd, offset, len)
+            }
+            JournalEntry::CreateHardLinkV1 {
+                old_path, new_path, ..
+            } => write!(f, "path-link (from={}, to={})", old_path, new_path),
+            JournalEntry::CreateSymbolicLinkV1 {
+                old_path, new_path, ..
+            } => write!(f, "path-symlink (from={}, to={})", old_path, new_path),
+            JournalEntry::UnlinkFileV1 { path, .. } => write!(f, "path-unlink (path={})", path),
+            JournalEntry::PathRenameV1 {
+                old_path, new_path, ..
+            } => write!(
+                f,
+                "path-rename (old-path={}, new-path={})",
+                old_path, new_path
+            ),
+            JournalEntry::ChangeDirectoryV1 { path } => write!(f, "chdir (path={})", path),
+            JournalEntry::EpollCreateV1 { fd } => write!(f, "epoll-create (fd={})", fd),
+            JournalEntry::EpollCtlV1 { epfd, op, fd, .. } => {
+                write!(f, "epoll-ctl (epfd={}, op={:?}, fd={})", epfd, op, fd)
+            }
+            JournalEntry::TtySetV1 { tty, line_feeds } => write!(
+                f,
+                "tty-set (echo={}, buffering={}, feeds={})",
+                tty.echo, tty.line_buffered, line_feeds
+            ),
+            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+                write!(f, "fd-pipe (fd1={}, fd2={})", fd1, fd2)
+            }
+            JournalEntry::CreateEventV1 {
+                initial_val, fd, ..
+            } => write!(f, "fd-event (fd={}, initial={})", fd, initial_val),
+            JournalEntry::PortAddAddrV1 { cidr } => {
+                write!(f, "port-addr-add (ip={}, prefix={})", cidr.ip, cidr.prefix)
+            }
+            JournalEntry::PortDelAddrV1 { addr } => write!(f, "port-addr-del (addr={})", addr),
+            JournalEntry::PortAddrClearV1 => write!(f, "port-addr-clear"),
+            JournalEntry::PortBridgeV1 { network, .. } => {
+                write!(f, "port-bridge (network={})", network)
+            }
+            JournalEntry::PortUnbridgeV1 => write!(f, "port-unbridge"),
+            JournalEntry::PortDhcpAcquireV1 => write!(f, "port-dhcp-acquire"),
+            JournalEntry::PortGatewaySetV1 { ip } => write!(f, "port-gateway-set (ip={})", ip),
+            JournalEntry::PortRouteAddV1 {
+                cidr, via_router, ..
+            } => write!(
+                f,
+                "port-route-add (ip={}, prefix={}, via_router={})",
+                cidr.ip, cidr.prefix, via_router
+            ),
+            JournalEntry::PortRouteClearV1 => write!(f, "port-route-clear"),
+            JournalEntry::PortRouteDelV1 { ip } => write!(f, "port-route-del (ip={})", ip),
+            JournalEntry::SocketOpenV1 { af, ty, pt, fd } => {
+                write!(
+                    f,
+                    "sock-open (fd={}, af={:?}, ty={:?}, pt={:?})",
+                    fd, af, ty, pt
+                )
+            }
+            JournalEntry::SocketListenV1 { fd, backlog } => {
+                write!(f, "sock-listen (fd={}, backlog={})", fd, backlog)
+            }
+            JournalEntry::SocketBindV1 { fd, addr } => {
+                write!(f, "sock-bind (fd={}, addr={})", fd, addr)
+            }
+            JournalEntry::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            } => {
+                write!(
+                    f,
+                    "sock-connect (fd={}, addr={}, peer={})",
+                    fd, local_addr, peer_addr
+                )
+            }
+            JournalEntry::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr,
+                peer_addr,
+                ..
+            } => write!(
+                f,
+                "sock-accept (listen-fd={}, sock_fd={}, addr={}, peer={})",
+                listen_fd, fd, local_addr, peer_addr
+            ),
+            JournalEntry::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            } => write!(
+                f,
+                "sock-join-mcast-ipv4 (fd={}, addr={}, iface={})",
+                fd, multiaddr, iface
+            ),
+            JournalEntry::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => write!(
+                f,
+                "sock-join-mcast-ipv6 (fd={}, addr={}, iface={})",
+                fd, multiaddr, iface
+            ),
+            JournalEntry::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => write!(
+                f,
+                "sock-leave-mcast-ipv4 (fd={}, addr={}, iface={})",
+                fd, multiaddr, iface
+            ),
+            JournalEntry::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => write!(
+                f,
+                "sock-leave-mcast-ipv6 (fd={}, addr={}, iface={})",
+                fd, multiaddr, iface
+            ),
+            JournalEntry::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            } => write!(
+                f,
+                "sock-send-file (sock-fd={}, file-fd={}, offset={}, count={})",
+                socket_fd, file_fd, offset, count
+            ),
+            JournalEntry::SocketSendToV1 { fd, data, addr, .. } => write!(
+                f,
+                "sock-send-to (fd={}, data.len={}, addr={})",
+                fd,
+                data.len(),
+                addr
+            ),
+            JournalEntry::SocketSendV1 { fd, data, .. } => {
+                write!(f, "sock-send (fd={}, data.len={}", fd, data.len())
+            }
+            JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => {
+                write!(f, "sock-set-opt (fd={}, opt={:?}, flag={})", fd, opt, flag)
+            }
+            JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => {
+                write!(f, "sock-set-opt (fd={}, opt={:?}, size={})", fd, opt, size)
+            }
+            JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => {
+                write!(f, "sock-set-opt (fd={}, opt={:?}, time={:?})", fd, ty, time)
+            }
+            JournalEntry::SocketShutdownV1 { fd, how } => {
+                write!(f, "sock-shutdown (fd={}, how={:?})", fd, how)
+            }
+            JournalEntry::SnapshotV1 { when, trigger } => {
+                write!(f, "snapshot (when={:?}, trigger={:?})", when, trigger)
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/recombined.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/recombined.rs
new file mode 100644
index 0000000..6a97c9b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/recombined.rs
@@ -0,0 +1,34 @@
+use super::*;
+
+pub struct RecombinedJournal {
+    tx: Box<DynWritableJournal>,
+    rx: Box<DynReadableJournal>,
+}
+
+impl RecombinedJournal {
+    pub fn new(tx: Box<DynWritableJournal>, rx: Box<DynReadableJournal>) -> Self {
+        Self { tx, rx }
+    }
+}
+
+impl WritableJournal for RecombinedJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        self.tx.write(entry)
+    }
+}
+
+impl ReadableJournal for RecombinedJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        self.rx.read()
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        self.rx.as_restarted()
+    }
+}
+
+impl Journal for RecombinedJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (self.tx, self.rx)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/tests.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/tests.rs
new file mode 100644
index 0000000..faebfcc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/tests.rs
@@ -0,0 +1,724 @@
+use std::{
+    net::{Ipv4Addr, Ipv6Addr, SocketAddr},
+    time::{Duration, SystemTime},
+};
+
+use super::*;
+use rkyv::ser::serializers::{
+    AllocScratch, CompositeSerializer, SharedSerializeMap, WriteSerializer,
+};
+use wasmer_wasix_types::wasi;
+
+pub fn run_test<'a>(record: JournalEntry<'a>) {
+    tracing::info!("record: {:?}", record);
+
+    // Determine the record type
+    let record_type = record.archive_record_type();
+    tracing::info!("record_type: {:?}", record_type);
+
+    // Serialize it
+    let mut buffer = Vec::new();
+    let mut serializer = CompositeSerializer::new(
+        WriteSerializer::new(&mut buffer),
+        AllocScratch::default(),
+        SharedSerializeMap::default(),
+    );
+
+    record.clone().serialize_archive(&mut serializer).unwrap();
+    let buffer = &buffer[..];
+    if buffer.len() < 20 {
+        tracing::info!("buffer: {:x?}", buffer);
+    } else {
+        tracing::info!("buffer_len: {}", buffer.len());
+    }
+
+    // Deserialize it
+    let record2 = unsafe { record_type.deserialize_archive(buffer).unwrap() };
+    tracing::info!("record2: {:?}", record2);
+
+    // Check it
+    assert_eq!(record, record2);
+
+    // Now make it static and check it again
+    let record3 = record2.into_owned();
+    tracing::info!("record3: {:?}", record3);
+    assert_eq!(record, record3);
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_init_module() {
+    run_test(JournalEntry::InitModuleV1 {
+        wasm_hash: [13u8; 8],
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_process_exit() {
+    run_test(JournalEntry::ProcessExitV1 {
+        exit_code: Some(wasi::ExitCode::Errno(wasi::Errno::Fault)),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_set_thread() {
+    run_test(JournalEntry::SetThreadV1 {
+        id: 1234u32,
+        call_stack: vec![1, 2, 3].into(),
+        memory_stack: vec![4, 5, 6, 7].into(),
+        store_data: vec![10, 11].into(),
+        is_64bit: true,
+        layout: wasmer_wasix_types::wasix::WasiMemoryLayout {
+            stack_upper: 0,
+            stack_lower: 1024,
+            guard_size: 16,
+            stack_size: 1024,
+        },
+        start: wasmer_wasix_types::wasix::ThreadStartType::MainThread,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_close_thread() {
+    run_test(JournalEntry::CloseThreadV1 {
+        id: 987u32,
+        exit_code: Some(wasi::ExitCode::Errno(wasi::Errno::Fault)),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_descriptor_seek() {
+    run_test(JournalEntry::FileDescriptorSeekV1 {
+        fd: 765u32,
+        offset: 9183722450971234i64,
+        whence: wasi::Whence::End,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_descriptor_write() {
+    run_test(JournalEntry::FileDescriptorWriteV1 {
+        fd: 54321u32,
+        offset: 13897412934u64,
+        data: vec![74u8, 98u8, 36u8].into(),
+        is_64bit: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_update_memory() {
+    run_test(JournalEntry::UpdateMemoryRegionV1 {
+        region: 76u64..8237453u64,
+        data: [74u8; 40960].to_vec().into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_set_clock_time() {
+    run_test(JournalEntry::SetClockTimeV1 {
+        clock_id: wasi::Snapshot0Clockid::Realtime,
+        time: 7912837412934u64,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_open_file_descriptor() {
+    run_test(JournalEntry::OpenFileDescriptorV1 {
+        fd: 298745u32,
+        dirfd: 23458922u32,
+        dirflags: 134512345,
+        path: "/blah".into(),
+        o_flags: wasi::Oflags::all(),
+        fs_rights_base: wasi::Rights::all(),
+        fs_rights_inheriting: wasi::Rights::all(),
+        fs_flags: wasi::Fdflags::all(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_close_descriptor() {
+    run_test(JournalEntry::CloseFileDescriptorV1 { fd: 23845732u32 });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_renumber_file_descriptor() {
+    run_test(JournalEntry::RenumberFileDescriptorV1 {
+        old_fd: 27834u32,
+        new_fd: 398452345u32,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_duplicate_file_descriptor() {
+    run_test(JournalEntry::DuplicateFileDescriptorV1 {
+        original_fd: 23482934u32,
+        copied_fd: 9384529u32,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_create_directory() {
+    run_test(JournalEntry::CreateDirectoryV1 {
+        fd: 238472u32,
+        path: "/joasjdf/asdfn".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_remove_directory() {
+    run_test(JournalEntry::RemoveDirectoryV1 {
+        fd: 23894952u32,
+        path: "/blahblah".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_path_set_times() {
+    run_test(JournalEntry::PathSetTimesV1 {
+        fd: 1238934u32,
+        flags: 234523,
+        path: "/".into(),
+        st_atim: 923452345,
+        st_mtim: 350,
+        fst_flags: wasi::Fstflags::all(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_set_times() {
+    run_test(JournalEntry::FileDescriptorSetTimesV1 {
+        fd: 898785u32,
+        st_atim: 29834952345,
+        st_mtim: 239845892345,
+        fst_flags: wasi::Fstflags::all(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_set_size() {
+    run_test(JournalEntry::FileDescriptorSetSizeV1 {
+        fd: 34958234u32,
+        st_size: 234958293845u64,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_set_flags() {
+    run_test(JournalEntry::FileDescriptorSetFlagsV1 {
+        fd: 982348752u32,
+        flags: wasi::Fdflags::all(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_set_rights() {
+    run_test(JournalEntry::FileDescriptorSetRightsV1 {
+        fd: 872345u32,
+        fs_rights_base: wasi::Rights::all(),
+        fs_rights_inheriting: wasi::Rights::all(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_advise() {
+    run_test(JournalEntry::FileDescriptorAdviseV1 {
+        fd: 298434u32,
+        offset: 92834529092345,
+        len: 23485928345,
+        advice: wasi::Advice::Random,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_file_descriptor_allocate() {
+    run_test(JournalEntry::FileDescriptorAllocateV1 {
+        fd: 2934852,
+        offset: 23489582934523,
+        len: 9845982345,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_create_hard_link() {
+    run_test(JournalEntry::CreateHardLinkV1 {
+        old_fd: 324983845,
+        old_path: "/asjdfiasidfasdf".into(),
+        old_flags: 234857,
+        new_fd: 34958345,
+        new_path: "/ashdufnasd".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_create_symbolic_link() {
+    run_test(JournalEntry::CreateSymbolicLinkV1 {
+        old_path: "/asjbndfjasdf/asdafasdf".into(),
+        fd: 235422345,
+        new_path: "/asdf".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_unlink_file() {
+    run_test(JournalEntry::UnlinkFileV1 {
+        fd: 32452345,
+        path: "/asdfasd".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_path_rename() {
+    run_test(JournalEntry::PathRenameV1 {
+        old_fd: 32451345,
+        old_path: "/asdfasdfas/asdfasdf".into(),
+        new_fd: 23452345,
+        new_path: "/ahgfdfghdfghdfgh".into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_change_directory() {
+    run_test(JournalEntry::ChangeDirectoryV1 {
+        path: "/etc".to_string().into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_epoll_create() {
+    run_test(JournalEntry::EpollCreateV1 { fd: 45384752 });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_epoll_ctl() {
+    run_test(JournalEntry::EpollCtlV1 {
+        epfd: 34523455,
+        op: wasi::EpollCtl::Unknown,
+        fd: 23452345,
+        event: Some(wasi::EpollEventCtl {
+            events: wasi::EpollType::all(),
+            ptr: 32452345,
+            fd: 23452345,
+            data1: 1235245756,
+            data2: 23452345,
+        }),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_tty_set() {
+    run_test(JournalEntry::TtySetV1 {
+        tty: wasi::Tty {
+            cols: 1234,
+            rows: 6754,
+            width: 4563456,
+            height: 345,
+            stdin_tty: true,
+            stdout_tty: false,
+            stderr_tty: true,
+            echo: true,
+            line_buffered: true,
+        },
+        line_feeds: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_create_pipe() {
+    run_test(JournalEntry::CreatePipeV1 {
+        fd1: 3452345,
+        fd2: 2345163,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_create_event() {
+    run_test(JournalEntry::CreateEventV1 {
+        initial_val: 13451345,
+        flags: 2343,
+        fd: 5836544,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_port_add_addr() {
+    run_test(JournalEntry::PortAddAddrV1 {
+        cidr: JournalIpCidrV1 {
+            ip: Ipv4Addr::LOCALHOST.into(),
+            prefix: 24,
+        }
+        .into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_del_addr() {
+    run_test(JournalEntry::PortDelAddrV1 {
+        addr: Ipv6Addr::LOCALHOST.into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_addr_clear() {
+    run_test(JournalEntry::PortAddrClearV1);
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_port_bridge() {
+    run_test(JournalEntry::PortBridgeV1 {
+        network: "mynetwork".into(),
+        token: format!("blh blah").into(),
+        security: JournalStreamSecurityV1::ClassicEncryption.into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_unbridge() {
+    run_test(JournalEntry::PortUnbridgeV1);
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_dhcp_acquire() {
+    run_test(JournalEntry::PortDhcpAcquireV1);
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_gateway_set() {
+    run_test(JournalEntry::PortGatewaySetV1 {
+        ip: Ipv4Addr::new(12, 34, 136, 220).into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_route_add() {
+    run_test(JournalEntry::PortRouteAddV1 {
+        cidr: JournalIpCidrV1 {
+            ip: Ipv4Addr::LOCALHOST.into(),
+            prefix: 24,
+        }
+        .into(),
+        via_router: Ipv4Addr::LOCALHOST.into(),
+        preferred_until: Some(Duration::MAX),
+        expires_at: Some(Duration::ZERO),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_route_clear() {
+    run_test(JournalEntry::PortRouteClearV1);
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_route_del() {
+    run_test(JournalEntry::PortRouteDelV1 {
+        ip: Ipv4Addr::BROADCAST.into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_open() {
+    run_test(JournalEntry::SocketOpenV1 {
+        af: wasi::Addressfamily::Inet6,
+        ty: wasi::Socktype::Stream,
+        pt: wasi::SockProto::Tcp,
+        fd: 23452345,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_listen() {
+    run_test(JournalEntry::SocketListenV1 {
+        fd: 12341234,
+        backlog: 123,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_bind() {
+    run_test(JournalEntry::SocketBindV1 {
+        fd: 2341234,
+        addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 1234),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_connected() {
+    run_test(JournalEntry::SocketConnectedV1 {
+        fd: 12341,
+        local_addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 1234),
+        peer_addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 1234),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_accepted() {
+    run_test(JournalEntry::SocketAcceptedV1 {
+        listen_fd: 21234,
+        fd: 1,
+        local_addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 3452),
+        peer_addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 3452),
+        fd_flags: wasi::Fdflags::all(),
+        non_blocking: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_join_ipv4_multicast() {
+    run_test(JournalEntry::SocketJoinIpv4MulticastV1 {
+        fd: 12,
+        multiaddr: Ipv4Addr::new(123, 123, 123, 123).into(),
+        iface: Ipv4Addr::new(128, 0, 0, 1).into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_join_ipv6_multicast() {
+    run_test(JournalEntry::SocketJoinIpv6MulticastV1 {
+        fd: 12,
+        multi_addr: Ipv6Addr::new(123, 123, 123, 123, 1234, 12663, 31, 1324).into(),
+        iface: 23541,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_leave_ipv4_multicast() {
+    run_test(JournalEntry::SocketLeaveIpv4MulticastV1 {
+        fd: 12,
+        multi_addr: Ipv4Addr::new(123, 123, 123, 123).into(),
+        iface: Ipv4Addr::new(128, 0, 0, 1).into(),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_leave_ipv6_multicast() {
+    run_test(JournalEntry::SocketLeaveIpv6MulticastV1 {
+        fd: 12,
+        multi_addr: Ipv6Addr::new(123, 123, 123, 123, 1234, 12663, 31, 1324).into(),
+        iface: 23541,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_send_file() {
+    run_test(JournalEntry::SocketSendFileV1 {
+        socket_fd: 22234,
+        file_fd: 989,
+        offset: 124,
+        count: 345673456234651234,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_send_to() {
+    run_test(JournalEntry::SocketSendToV1 {
+        fd: 123,
+        data: [98u8; 102400].to_vec().into(),
+        flags: 1234,
+        addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 3452),
+        is_64bit: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_send() {
+    run_test(JournalEntry::SocketSendV1 {
+        fd: 123,
+        data: [98u8; 102400].to_vec().into(),
+        flags: 1234,
+        is_64bit: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_set_opt_flag() {
+    run_test(JournalEntry::SocketSetOptFlagV1 {
+        fd: 0,
+        opt: wasi::Sockoption::Linger,
+        flag: true,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_set_opt_size() {
+    run_test(JournalEntry::SocketSetOptSizeV1 {
+        fd: 15,
+        opt: wasi::Sockoption::Linger,
+        size: 234234,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_set_opt_time() {
+    run_test(JournalEntry::SocketSetOptTimeV1 {
+        fd: 0,
+        ty: SocketOptTimeType::AcceptTimeout,
+        time: Some(Duration::ZERO),
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_socket_shutdown() {
+    run_test(JournalEntry::SocketShutdownV1 {
+        fd: 123,
+        how: SocketShutdownHow::Both,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_snapshot() {
+    run_test(JournalEntry::SnapshotV1 {
+        when: SystemTime::now(),
+        trigger: SnapshotTrigger::Idle,
+    });
+}
+
+#[tracing_test::traced_test]
+#[test]
+pub fn test_record_alignment() {
+    assert_eq!(std::mem::align_of::<JournalEntryInitModuleV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryProcessExitV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySetThreadV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryCloseThreadV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryFileDescriptorSeekV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryFileDescriptorWriteV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryUpdateMemoryRegionV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySetClockTimeV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryOpenFileDescriptorV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryCloseFileDescriptorV1>(), 8);
+    assert_eq!(
+        std::mem::align_of::<JournalEntryRenumberFileDescriptorV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryDuplicateFileDescriptorV1>(),
+        8
+    );
+    assert_eq!(std::mem::align_of::<JournalEntryCreateDirectoryV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryRemoveDirectoryV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPathSetTimesV1>(), 8);
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorSetTimesV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorSetSizeV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorSetFlagsV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorSetRightsV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorAdviseV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntryFileDescriptorAllocateV1>(),
+        8
+    );
+    assert_eq!(std::mem::align_of::<JournalEntryCreateHardLinkV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryCreateSymbolicLinkV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryUnlinkFileV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPathRenameV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryChangeDirectoryV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryEpollCreateV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryEpollCtlV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryTtySetV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryCreatePipeV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryCreateEventV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortAddAddrV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortDelAddrV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortBridgeV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortGatewaySetV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortRouteAddV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntryPortRouteDelV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketOpenV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketListenV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketBindV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketConnectedV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketAcceptedV1>(), 8);
+    assert_eq!(
+        std::mem::align_of::<JournalEntrySocketJoinIpv4MulticastV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntrySocketJoinIpv6MulticastV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntrySocketLeaveIpv4MulticastV1>(),
+        8
+    );
+    assert_eq!(
+        std::mem::align_of::<JournalEntrySocketLeaveIpv6MulticastV1>(),
+        8
+    );
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSendFileV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSendToV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSendV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSetOptFlagV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSetOptSizeV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketSetOptTimeV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySocketShutdownV1>(), 8);
+    assert_eq!(std::mem::align_of::<JournalEntrySnapshotV1>(), 8);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/unsupported.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/unsupported.rs
new file mode 100644
index 0000000..3ac2abd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/concrete/unsupported.rs
@@ -0,0 +1,34 @@
+use super::*;
+
+pub static UNSUPPORTED_JOURNAL: UnsupportedJournal = UnsupportedJournal {};
+
+/// The default for runtime is to use the unsupported journal
+/// which will fail to write journal entries if one attempts to do so.
+#[derive(Debug, Default)]
+pub struct UnsupportedJournal {}
+
+impl ReadableJournal for UnsupportedJournal {
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>> {
+        Ok(None)
+    }
+
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>> {
+        Ok(Box::<UnsupportedJournal>::default())
+    }
+}
+
+impl WritableJournal for UnsupportedJournal {
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult> {
+        tracing::debug!("journal event: {:?}", entry);
+        Err(anyhow::format_err!("unsupported"))
+    }
+}
+
+impl Journal for UnsupportedJournal {
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>) {
+        (
+            Box::<UnsupportedJournal>::default(),
+            Box::<UnsupportedJournal>::default(),
+        )
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/entry.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/entry.rs
new file mode 100644
index 0000000..29190d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/entry.rs
@@ -0,0 +1,792 @@
+use derivative::Derivative;
+use serde::{Deserialize, Serialize};
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::net::{Shutdown, SocketAddr};
+use std::time::{Duration, SystemTime};
+use std::{borrow::Cow, ops::Range};
+use virtual_net::{IpCidr, StreamSecurity};
+use wasmer_wasix_types::wasi::{
+    Addressfamily, Advice, EpollCtl, EpollEventCtl, EventFdFlags, ExitCode, Fdflags, FileDelta,
+    Filesize, Fstflags, LookupFlags, Oflags, Rights, SiFlags, Snapshot0Clockid, SockProto,
+    Sockoption, Socktype, Timestamp, Tty, Whence,
+};
+use wasmer_wasix_types::wasix::{ThreadStartType, WasiMemoryLayout};
+
+use crate::{base64, SnapshotTrigger};
+
+type Fd = u32;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum SocketJournalEvent {
+    TcpListen {
+        listen_addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    },
+    TcpStream {
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+    },
+    UdpSocket {
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    },
+    Icmp {
+        addr: SocketAddr,
+    },
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum SocketShutdownHow {
+    Read,
+    Write,
+    Both,
+}
+impl From<Shutdown> for SocketShutdownHow {
+    fn from(value: Shutdown) -> Self {
+        match value {
+            Shutdown::Read => Self::Read,
+            Shutdown::Write => Self::Write,
+            Shutdown::Both => Self::Both,
+        }
+    }
+}
+impl From<SocketShutdownHow> for Shutdown {
+    fn from(value: SocketShutdownHow) -> Self {
+        match value {
+            SocketShutdownHow::Read => Self::Read,
+            SocketShutdownHow::Write => Self::Write,
+            SocketShutdownHow::Both => Self::Both,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[serde(rename_all = "snake_case")]
+pub enum SocketOptTimeType {
+    ReadTimeout,
+    WriteTimeout,
+    AcceptTimeout,
+    ConnectTimeout,
+    BindTimeout,
+    Linger,
+}
+
+/// Represents a log entry in a snapshot log stream that represents the total
+/// state of a WASM process at a point in time.
+#[allow(clippy::large_enum_variant)]
+#[derive(Derivative, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derivative(Debug)]
+#[serde(rename_all = "snake_case")]
+pub enum JournalEntry<'a> {
+    InitModuleV1 {
+        wasm_hash: [u8; 8],
+    },
+    ClearEtherealV1,
+    UpdateMemoryRegionV1 {
+        region: Range<u64>,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        data: Cow<'a, [u8]>,
+    },
+    ProcessExitV1 {
+        exit_code: Option<ExitCode>,
+    },
+    SetThreadV1 {
+        id: u32,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        call_stack: Cow<'a, [u8]>,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        memory_stack: Cow<'a, [u8]>,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        store_data: Cow<'a, [u8]>,
+        start: ThreadStartType,
+        layout: WasiMemoryLayout,
+        is_64bit: bool,
+    },
+    CloseThreadV1 {
+        id: u32,
+        exit_code: Option<ExitCode>,
+    },
+    FileDescriptorSeekV1 {
+        fd: Fd,
+        offset: FileDelta,
+        whence: Whence,
+    },
+    FileDescriptorWriteV1 {
+        fd: Fd,
+        offset: u64,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        data: Cow<'a, [u8]>,
+        is_64bit: bool,
+    },
+    SetClockTimeV1 {
+        clock_id: Snapshot0Clockid,
+        time: Timestamp,
+    },
+    CloseFileDescriptorV1 {
+        fd: Fd,
+    },
+    OpenFileDescriptorV1 {
+        fd: Fd,
+        dirfd: Fd,
+        dirflags: LookupFlags,
+        path: Cow<'a, str>,
+        o_flags: Oflags,
+        #[derivative(Debug = "ignore")]
+        fs_rights_base: Rights,
+        #[derivative(Debug = "ignore")]
+        fs_rights_inheriting: Rights,
+        fs_flags: Fdflags,
+    },
+    RenumberFileDescriptorV1 {
+        old_fd: Fd,
+        new_fd: Fd,
+    },
+    DuplicateFileDescriptorV1 {
+        original_fd: Fd,
+        copied_fd: Fd,
+    },
+    CreateDirectoryV1 {
+        fd: Fd,
+        path: Cow<'a, str>,
+    },
+    RemoveDirectoryV1 {
+        fd: Fd,
+        path: Cow<'a, str>,
+    },
+    PathSetTimesV1 {
+        fd: Fd,
+        flags: LookupFlags,
+        path: Cow<'a, str>,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    },
+    FileDescriptorSetTimesV1 {
+        fd: Fd,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    },
+    FileDescriptorSetFlagsV1 {
+        fd: Fd,
+        flags: Fdflags,
+    },
+    FileDescriptorSetRightsV1 {
+        fd: Fd,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+    },
+    FileDescriptorSetSizeV1 {
+        fd: Fd,
+        st_size: Filesize,
+    },
+    FileDescriptorAdviseV1 {
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+        advice: Advice,
+    },
+    FileDescriptorAllocateV1 {
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+    },
+    CreateHardLinkV1 {
+        old_fd: Fd,
+        old_path: Cow<'a, str>,
+        old_flags: LookupFlags,
+        new_fd: Fd,
+        new_path: Cow<'a, str>,
+    },
+    CreateSymbolicLinkV1 {
+        old_path: Cow<'a, str>,
+        fd: Fd,
+        new_path: Cow<'a, str>,
+    },
+    UnlinkFileV1 {
+        fd: Fd,
+        path: Cow<'a, str>,
+    },
+    PathRenameV1 {
+        old_fd: Fd,
+        old_path: Cow<'a, str>,
+        new_fd: Fd,
+        new_path: Cow<'a, str>,
+    },
+    ChangeDirectoryV1 {
+        path: Cow<'a, str>,
+    },
+    EpollCreateV1 {
+        fd: Fd,
+    },
+    EpollCtlV1 {
+        epfd: Fd,
+        op: EpollCtl,
+        fd: Fd,
+        event: Option<EpollEventCtl>,
+    },
+    TtySetV1 {
+        tty: Tty,
+        line_feeds: bool,
+    },
+    CreatePipeV1 {
+        fd1: Fd,
+        fd2: Fd,
+    },
+    CreateEventV1 {
+        initial_val: u64,
+        flags: EventFdFlags,
+        fd: Fd,
+    },
+    PortAddAddrV1 {
+        cidr: IpCidr,
+    },
+    PortDelAddrV1 {
+        addr: IpAddr,
+    },
+    PortAddrClearV1,
+    PortBridgeV1 {
+        network: Cow<'a, str>,
+        token: Cow<'a, str>,
+        security: StreamSecurity,
+    },
+    PortUnbridgeV1,
+    PortDhcpAcquireV1,
+    PortGatewaySetV1 {
+        ip: IpAddr,
+    },
+    PortRouteAddV1 {
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    },
+    PortRouteClearV1,
+    PortRouteDelV1 {
+        ip: IpAddr,
+    },
+    SocketOpenV1 {
+        af: Addressfamily,
+        ty: Socktype,
+        pt: SockProto,
+        fd: Fd,
+    },
+    SocketListenV1 {
+        fd: Fd,
+        backlog: u32,
+    },
+    SocketBindV1 {
+        fd: Fd,
+        addr: SocketAddr,
+    },
+    SocketConnectedV1 {
+        fd: Fd,
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+    },
+    SocketAcceptedV1 {
+        listen_fd: Fd,
+        fd: Fd,
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+        fd_flags: Fdflags,
+        non_blocking: bool,
+    },
+    SocketJoinIpv4MulticastV1 {
+        fd: Fd,
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    },
+    SocketJoinIpv6MulticastV1 {
+        fd: Fd,
+        multi_addr: Ipv6Addr,
+        iface: u32,
+    },
+    SocketLeaveIpv4MulticastV1 {
+        fd: Fd,
+        multi_addr: Ipv4Addr,
+        iface: Ipv4Addr,
+    },
+    SocketLeaveIpv6MulticastV1 {
+        fd: Fd,
+        multi_addr: Ipv6Addr,
+        iface: u32,
+    },
+    SocketSendFileV1 {
+        socket_fd: Fd,
+        file_fd: Fd,
+        offset: Filesize,
+        count: Filesize,
+    },
+    SocketSendToV1 {
+        fd: Fd,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        data: Cow<'a, [u8]>,
+        flags: SiFlags,
+        addr: SocketAddr,
+        is_64bit: bool,
+    },
+    SocketSendV1 {
+        fd: Fd,
+        #[derivative(Debug = "ignore")]
+        #[serde(with = "base64")]
+        data: Cow<'a, [u8]>,
+        flags: SiFlags,
+        is_64bit: bool,
+    },
+    SocketSetOptFlagV1 {
+        fd: Fd,
+        opt: Sockoption,
+        flag: bool,
+    },
+    SocketSetOptSizeV1 {
+        fd: Fd,
+        opt: Sockoption,
+        size: u64,
+    },
+    SocketSetOptTimeV1 {
+        fd: Fd,
+        ty: SocketOptTimeType,
+        time: Option<Duration>,
+    },
+    SocketShutdownV1 {
+        fd: Fd,
+        how: SocketShutdownHow,
+    },
+    /// Represents the marker for the end of a snapshot
+    SnapshotV1 {
+        when: SystemTime,
+        trigger: SnapshotTrigger,
+    },
+}
+
+impl<'a> JournalEntry<'a> {
+    pub fn into_owned(self) -> JournalEntry<'static> {
+        match self {
+            Self::InitModuleV1 { wasm_hash } => JournalEntry::InitModuleV1 { wasm_hash },
+            Self::ClearEtherealV1 => JournalEntry::ClearEtherealV1,
+            Self::UpdateMemoryRegionV1 { region, data } => JournalEntry::UpdateMemoryRegionV1 {
+                region,
+                data: data.into_owned().into(),
+            },
+            Self::ProcessExitV1 { exit_code } => JournalEntry::ProcessExitV1 { exit_code },
+            Self::SetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                is_64bit,
+                start,
+                layout,
+            } => JournalEntry::SetThreadV1 {
+                id,
+                call_stack: call_stack.into_owned().into(),
+                memory_stack: memory_stack.into_owned().into(),
+                store_data: store_data.into_owned().into(),
+                start,
+                layout,
+                is_64bit,
+            },
+            Self::CloseThreadV1 { id, exit_code } => JournalEntry::CloseThreadV1 { id, exit_code },
+            Self::FileDescriptorSeekV1 { fd, offset, whence } => {
+                JournalEntry::FileDescriptorSeekV1 { fd, offset, whence }
+            }
+            Self::FileDescriptorWriteV1 {
+                fd,
+                offset,
+                data,
+                is_64bit,
+            } => JournalEntry::FileDescriptorWriteV1 {
+                fd,
+                offset,
+                data: data.into_owned().into(),
+                is_64bit,
+            },
+            Self::SetClockTimeV1 { clock_id, time } => {
+                JournalEntry::SetClockTimeV1 { clock_id, time }
+            }
+            Self::CloseFileDescriptorV1 { fd } => JournalEntry::CloseFileDescriptorV1 { fd },
+            Self::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            } => JournalEntry::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path: path.into_owned().into(),
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            },
+            Self::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd }
+            }
+            Self::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            },
+            Self::CreateDirectoryV1 { fd, path } => JournalEntry::CreateDirectoryV1 {
+                fd,
+                path: path.into_owned().into(),
+            },
+            Self::RemoveDirectoryV1 { fd, path } => JournalEntry::RemoveDirectoryV1 {
+                fd,
+                path: path.into_owned().into(),
+            },
+            Self::PathSetTimesV1 {
+                fd,
+                flags,
+                path,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => JournalEntry::PathSetTimesV1 {
+                fd,
+                flags,
+                path: path.into_owned().into(),
+                st_atim,
+                st_mtim,
+                fst_flags,
+            },
+            Self::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => JournalEntry::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            },
+            Self::FileDescriptorSetFlagsV1 { fd, flags } => {
+                JournalEntry::FileDescriptorSetFlagsV1 { fd, flags }
+            }
+            Self::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            } => JournalEntry::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            },
+            Self::FileDescriptorSetSizeV1 { fd, st_size } => {
+                JournalEntry::FileDescriptorSetSizeV1 { fd, st_size }
+            }
+            Self::FileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice,
+            } => JournalEntry::FileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice,
+            },
+            Self::FileDescriptorAllocateV1 { fd, offset, len } => {
+                JournalEntry::FileDescriptorAllocateV1 { fd, offset, len }
+            }
+            Self::CreateHardLinkV1 {
+                old_fd,
+                old_path,
+                old_flags,
+                new_fd,
+                new_path,
+            } => JournalEntry::CreateHardLinkV1 {
+                old_fd,
+                old_path: old_path.into_owned().into(),
+                old_flags,
+                new_fd,
+                new_path: new_path.into_owned().into(),
+            },
+            Self::CreateSymbolicLinkV1 {
+                old_path,
+                fd,
+                new_path,
+            } => JournalEntry::CreateSymbolicLinkV1 {
+                old_path: old_path.into_owned().into(),
+                fd,
+                new_path: new_path.into_owned().into(),
+            },
+            Self::UnlinkFileV1 { fd, path } => JournalEntry::UnlinkFileV1 {
+                fd,
+                path: path.into_owned().into(),
+            },
+            Self::PathRenameV1 {
+                old_fd,
+                old_path,
+                new_fd,
+                new_path,
+            } => JournalEntry::PathRenameV1 {
+                old_fd,
+                old_path: old_path.into_owned().into(),
+                new_fd,
+                new_path: new_path.into_owned().into(),
+            },
+            Self::ChangeDirectoryV1 { path } => JournalEntry::ChangeDirectoryV1 {
+                path: path.into_owned().into(),
+            },
+            Self::EpollCreateV1 { fd } => JournalEntry::EpollCreateV1 { fd },
+            Self::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            } => JournalEntry::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            },
+            Self::TtySetV1 { tty, line_feeds } => JournalEntry::TtySetV1 { tty, line_feeds },
+            Self::CreatePipeV1 { fd1, fd2 } => JournalEntry::CreatePipeV1 { fd1, fd2 },
+            Self::CreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            } => JournalEntry::CreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            },
+            Self::PortAddAddrV1 { cidr } => JournalEntry::PortAddAddrV1 { cidr },
+            Self::PortDelAddrV1 { addr } => JournalEntry::PortDelAddrV1 { addr },
+            Self::PortAddrClearV1 => JournalEntry::PortAddrClearV1,
+            Self::PortBridgeV1 {
+                network,
+                token,
+                security,
+            } => JournalEntry::PortBridgeV1 {
+                network: network.into_owned().into(),
+                token: token.into_owned().into(),
+                security,
+            },
+            Self::PortUnbridgeV1 => JournalEntry::PortUnbridgeV1,
+            Self::PortDhcpAcquireV1 => JournalEntry::PortDhcpAcquireV1,
+            Self::PortGatewaySetV1 { ip } => JournalEntry::PortGatewaySetV1 { ip },
+            Self::PortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            } => JournalEntry::PortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            },
+            Self::PortRouteClearV1 => JournalEntry::PortRouteClearV1,
+            Self::PortRouteDelV1 { ip } => JournalEntry::PortRouteDelV1 { ip },
+            Self::SocketOpenV1 { af, ty, pt, fd } => JournalEntry::SocketOpenV1 { af, ty, pt, fd },
+            Self::SocketListenV1 { fd, backlog } => JournalEntry::SocketListenV1 { fd, backlog },
+            Self::SocketBindV1 { fd, addr } => JournalEntry::SocketBindV1 { fd, addr },
+            Self::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            } => JournalEntry::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            },
+            Self::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr,
+                peer_addr,
+                fd_flags,
+                non_blocking: nonblocking,
+            } => JournalEntry::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr,
+                peer_addr,
+                fd_flags,
+                non_blocking: nonblocking,
+            },
+            Self::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            } => JournalEntry::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            },
+            Self::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => JournalEntry::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+            Self::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => JournalEntry::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+            Self::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => JournalEntry::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+            Self::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            } => JournalEntry::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            },
+            Self::SocketSendToV1 {
+                fd,
+                data,
+                flags,
+                addr,
+                is_64bit,
+            } => JournalEntry::SocketSendToV1 {
+                fd,
+                data: data.into_owned().into(),
+                flags,
+                addr,
+                is_64bit,
+            },
+            Self::SocketSendV1 {
+                fd,
+                data,
+                flags,
+                is_64bit,
+            } => JournalEntry::SocketSendV1 {
+                fd,
+                data: data.into_owned().into(),
+                flags,
+                is_64bit,
+            },
+            Self::SocketSetOptFlagV1 { fd, opt, flag } => {
+                JournalEntry::SocketSetOptFlagV1 { fd, opt, flag }
+            }
+            Self::SocketSetOptSizeV1 { fd, opt, size } => {
+                JournalEntry::SocketSetOptSizeV1 { fd, opt, size }
+            }
+            Self::SocketSetOptTimeV1 { fd, ty, time } => {
+                JournalEntry::SocketSetOptTimeV1 { fd, ty, time }
+            }
+            Self::SocketShutdownV1 { fd, how } => JournalEntry::SocketShutdownV1 { fd, how },
+            Self::SnapshotV1 { when, trigger } => JournalEntry::SnapshotV1 { when, trigger },
+        }
+    }
+
+    pub fn estimate_size(&self) -> usize {
+        let base_size = std::mem::size_of_val(self);
+        match self {
+            JournalEntry::InitModuleV1 { .. } => base_size,
+            JournalEntry::ClearEtherealV1 => base_size,
+            JournalEntry::UpdateMemoryRegionV1 { data, .. } => base_size + data.len(),
+            JournalEntry::ProcessExitV1 { .. } => base_size,
+            JournalEntry::SetThreadV1 {
+                call_stack,
+                memory_stack,
+                store_data,
+                ..
+            } => base_size + call_stack.len() + memory_stack.len() + store_data.len(),
+            JournalEntry::CloseThreadV1 { .. } => base_size,
+            JournalEntry::FileDescriptorSeekV1 { .. } => base_size,
+            JournalEntry::FileDescriptorWriteV1 { data, .. } => base_size + data.len(),
+            JournalEntry::SetClockTimeV1 { .. } => base_size,
+            JournalEntry::CloseFileDescriptorV1 { .. } => base_size,
+            JournalEntry::OpenFileDescriptorV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::RenumberFileDescriptorV1 { .. } => base_size,
+            JournalEntry::DuplicateFileDescriptorV1 { .. } => base_size,
+            JournalEntry::CreateDirectoryV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::RemoveDirectoryV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::PathSetTimesV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::FileDescriptorSetTimesV1 { .. } => base_size,
+            JournalEntry::FileDescriptorSetFlagsV1 { .. } => base_size,
+            JournalEntry::FileDescriptorSetRightsV1 { .. } => base_size,
+            JournalEntry::FileDescriptorSetSizeV1 { .. } => base_size,
+            JournalEntry::FileDescriptorAdviseV1 { .. } => base_size,
+            JournalEntry::FileDescriptorAllocateV1 { .. } => base_size,
+            JournalEntry::CreateHardLinkV1 {
+                old_path, new_path, ..
+            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
+            JournalEntry::CreateSymbolicLinkV1 {
+                old_path, new_path, ..
+            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
+            JournalEntry::UnlinkFileV1 { path, .. } => base_size + path.as_bytes().len(),
+            JournalEntry::PathRenameV1 {
+                old_path, new_path, ..
+            } => base_size + old_path.as_bytes().len() + new_path.as_bytes().len(),
+            JournalEntry::ChangeDirectoryV1 { path } => base_size + path.as_bytes().len(),
+            JournalEntry::EpollCreateV1 { .. } => base_size,
+            JournalEntry::EpollCtlV1 { .. } => base_size,
+            JournalEntry::TtySetV1 { .. } => base_size,
+            JournalEntry::CreatePipeV1 { .. } => base_size,
+            JournalEntry::CreateEventV1 { .. } => base_size,
+            JournalEntry::PortAddAddrV1 { .. } => base_size,
+            JournalEntry::PortDelAddrV1 { .. } => base_size,
+            JournalEntry::PortAddrClearV1 => base_size,
+            JournalEntry::PortBridgeV1 { network, token, .. } => {
+                base_size + network.as_bytes().len() + token.as_bytes().len()
+            }
+            JournalEntry::PortUnbridgeV1 => base_size,
+            JournalEntry::PortDhcpAcquireV1 => base_size,
+            JournalEntry::PortGatewaySetV1 { .. } => base_size,
+            JournalEntry::PortRouteAddV1 { .. } => base_size,
+            JournalEntry::PortRouteClearV1 => base_size,
+            JournalEntry::PortRouteDelV1 { .. } => base_size,
+            JournalEntry::SocketOpenV1 { .. } => base_size,
+            JournalEntry::SocketListenV1 { .. } => base_size,
+            JournalEntry::SocketBindV1 { .. } => base_size,
+            JournalEntry::SocketConnectedV1 { .. } => base_size,
+            JournalEntry::SocketAcceptedV1 { .. } => base_size,
+            JournalEntry::SocketJoinIpv4MulticastV1 { .. } => base_size,
+            JournalEntry::SocketJoinIpv6MulticastV1 { .. } => base_size,
+            JournalEntry::SocketLeaveIpv4MulticastV1 { .. } => base_size,
+            JournalEntry::SocketLeaveIpv6MulticastV1 { .. } => base_size,
+            JournalEntry::SocketSendFileV1 { .. } => base_size,
+            JournalEntry::SocketSendToV1 { data, .. } => base_size + data.len(),
+            JournalEntry::SocketSendV1 { data, .. } => base_size + data.len(),
+            JournalEntry::SocketSetOptFlagV1 { .. } => base_size,
+            JournalEntry::SocketSetOptSizeV1 { .. } => base_size,
+            JournalEntry::SocketSetOptTimeV1 { .. } => base_size,
+            JournalEntry::SocketShutdownV1 { .. } => base_size,
+            JournalEntry::SnapshotV1 { .. } => base_size,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/lib.rs
new file mode 100644
index 0000000..c7e04c0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/lib.rs
@@ -0,0 +1,90 @@
+mod base64;
+mod concrete;
+mod entry;
+mod snapshot;
+mod util;
+
+pub use concrete::*;
+pub use entry::*;
+pub use snapshot::*;
+pub use util::*;
+
+use serde::{Deserialize, Serialize};
+use std::{ops::Deref, str::FromStr};
+
+/// The results of an operation to write a log entry to the log
+#[derive(Debug)]
+pub struct LogWriteResult {
+    // Start of the actual entry
+    pub record_start: u64,
+    // End of the actual entry
+    pub record_end: u64,
+}
+
+impl LogWriteResult {
+    pub fn record_size(&self) -> u64 {
+        self.record_end - self.record_start
+    }
+}
+
+/// The snapshot capturer will take a series of objects that represents the state of
+/// a WASM process at a point in time and saves it so that it can be restored.
+/// It also allows for the restoration of that state at a later moment
+#[allow(unused_variables)]
+pub trait WritableJournal {
+    /// Takes in a stream of snapshot log entries and saves them so that they
+    /// may be restored at a later moment
+    fn write<'a>(&'a self, entry: JournalEntry<'a>) -> anyhow::Result<LogWriteResult>;
+}
+
+/// The results of an operation to read a log entry from the log
+#[derive(Debug)]
+pub struct LogReadResult<'a> {
+    /// Offset into the journal where this entry exists
+    pub record_start: u64,
+    /// Offset of the end of the entry
+    pub record_end: u64,
+    /// Represents the journal entry
+    pub record: JournalEntry<'a>,
+}
+
+impl<'a> LogReadResult<'a> {
+    pub fn into_inner(self) -> JournalEntry<'a> {
+        self.record
+    }
+}
+
+impl<'a> Deref for LogReadResult<'a> {
+    type Target = JournalEntry<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.record
+    }
+}
+
+/// The snapshot capturer will take a series of objects that represents the state of
+/// a WASM process at a point in time and saves it so that it can be restored.
+/// It also allows for the restoration of that state at a later moment
+#[allow(unused_variables)]
+pub trait ReadableJournal {
+    /// Returns a stream of snapshot objects that the runtime will use
+    /// to restore the state of a WASM process to a previous moment in time
+    fn read(&self) -> anyhow::Result<Option<LogReadResult<'_>>>;
+
+    /// Resets the journal so that reads will start from the
+    /// beginning again
+    fn as_restarted(&self) -> anyhow::Result<Box<DynReadableJournal>>;
+}
+
+/// The snapshot capturer will take a series of objects that represents the state of
+/// a WASM process at a point in time and saves it so that it can be restored.
+/// It also allows for the restoration of that state at a later moment
+#[allow(unused_variables)]
+pub trait Journal: WritableJournal + ReadableJournal {
+    /// Splits the journal into a read and write side
+    fn split(self) -> (Box<DynWritableJournal>, Box<DynReadableJournal>);
+}
+
+pub type DynJournal = dyn Journal + Send + Sync;
+pub type DynWritableJournal = dyn WritableJournal + Send + Sync;
+pub type DynReadableJournal = dyn ReadableJournal + Send + Sync;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/snapshot.rs
new file mode 100644
index 0000000..ce5b702
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/snapshot.rs
@@ -0,0 +1,67 @@
+use super::*;
+
+/// Various triggers that will cause the runtime to take snapshot
+/// of the WASM state and store it in the snapshot file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum SnapshotTrigger {
+    /// Triggered when all the threads in the process goes idle
+    Idle,
+    /// Triggered when a listen syscall is invoked on a socket for the first time
+    FirstListen,
+    /// Triggered on reading the environment variables for the first time
+    FirstEnviron,
+    /// Triggered when the process reads stdin for the first time
+    FirstStdin,
+    /// Issued on the first interrupt signal (Ctrl + C) the process receives, after that normal CTRL-C will apply.
+    FirstSigint,
+    /// Triggered periodically based on a interval (default 10 seconds) which can be specified using the `snapshot-interval` option
+    PeriodicInterval,
+    /// Issued if the user sends an interrupt signal (Ctrl + C).
+    Sigint,
+    /// Alarm clock signal (used for timers)
+    Sigalrm,
+    /// The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop temporarily. It is commonly initiated by the user pressing Ctrl-Z.
+    Sigtstp,
+    /// The SIGSTOP signal instructs the operating system to stop a process for later resumption.
+    Sigstop,
+    /// When a non-determinstic call is made
+    NonDeterministicCall,
+}
+
+impl SnapshotTrigger {
+    pub fn only_once(&self) -> bool {
+        matches!(
+            self,
+            Self::FirstListen | Self::FirstEnviron | Self::FirstStdin | Self::FirstSigint
+        )
+    }
+}
+
+pub const DEFAULT_SNAPSHOT_TRIGGERS: [SnapshotTrigger; 4] = [
+    SnapshotTrigger::Idle,
+    SnapshotTrigger::FirstEnviron,
+    SnapshotTrigger::FirstListen,
+    SnapshotTrigger::FirstStdin,
+];
+
+impl FromStr for SnapshotTrigger {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let s = s.trim().to_lowercase();
+        Ok(match s.as_str() {
+            "idle" => Self::Idle,
+            "first-listen" => Self::FirstListen,
+            "first-stdin" => Self::FirstStdin,
+            "first-environ" => Self::FirstEnviron,
+            "first-intr" | "first-sigint" | "first-ctrlc" | "first-ctrl-c" => Self::FirstSigint,
+            "periodic-interval" => Self::PeriodicInterval,
+            "intr" | "sigint" | "ctrlc" | "ctrl-c" => Self::Sigint,
+            "alarm" | "timer" | "sigalrm" => Self::Sigalrm,
+            "sigtstp" | "ctrlz" | "ctrl-z" => Self::Sigtstp,
+            "stop" | "sigstop" => Self::Sigstop,
+            "non-deterministic-call" => Self::NonDeterministicCall,
+            a => return Err(anyhow::format_err!("invalid or unknown trigger ({a})")),
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/journal/src/util.rs b/arbitrator/tools/module_roots/wasmer/lib/journal/src/util.rs
new file mode 100644
index 0000000..6f550a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/journal/src/util.rs
@@ -0,0 +1,11 @@
+use super::*;
+
+pub fn copy_journal<R: ReadableJournal, W: WritableJournal>(
+    from: &R,
+    to: &W,
+) -> anyhow::Result<()> {
+    while let Some(record) = from.read()? {
+        to.write(record.into_inner())?;
+    }
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/middlewares/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/middlewares/Cargo.toml
new file mode 100644
index 0000000..dfddae6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/middlewares/Cargo.toml
@@ -0,0 +1,27 @@
+[package]
+name = "wasmer-middlewares"
+description = "A collection of various useful middlewares"
+categories = ["wasm"]
+keywords = ["webassembly", "wasm"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["compiler"] }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+wasmer-vm = { path = "../vm", version = "=4.2.8" }
+
+[dev-dependencies]
+wasmer = { path = "../api", version = "=4.2.8", features = ["compiler"] }
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/middlewares/README.md b/arbitrator/tools/module_roots/wasmer/lib/middlewares/README.md
new file mode 100644
index 0000000..04fea2e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/middlewares/README.md
@@ -0,0 +1,12 @@
+# Wasmer Middlewares
+
+The `wasmer-middlewares` crate is a collection of various useful
+middlewares:
+
+- `metering`: A middleware for tracking how many operators are
+  executed in total and putting a limit on the total number of
+  operators executed.
+
+  [See the `metering`
+  example](https://github.com/wasmerio/wasmer/blob/master/examples/metering.rs)
+  to get a concrete and complete example.
diff --git a/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/lib.rs
new file mode 100644
index 0000000..5d91464
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/lib.rs
@@ -0,0 +1,8 @@
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub mod metering;
+
+// The most commonly used symbol are exported at top level of the
+// module. Others are available via modules,
+// e.g. `wasmer_middlewares::metering::get_remaining_points`
+pub use metering::Metering;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/metering.rs b/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/metering.rs
new file mode 100644
index 0000000..e3c2684
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/middlewares/src/metering.rs
@@ -0,0 +1,491 @@
+//! `metering` is a middleware for tracking how many operators are
+//! executed in total and putting a limit on the total number of
+//! operators executed. The WebAssembly instance execution is stopped
+//! when the limit is reached.
+//!
+//! # Example
+//!
+//! [See the `metering` detailed and complete
+//! example](https://github.com/wasmerio/wasmer/blob/master/examples/metering.rs).
+
+use std::convert::TryInto;
+use std::fmt;
+use std::sync::{Arc, Mutex};
+use wasmer::wasmparser::{BlockType as WpTypeOrFuncType, Operator};
+use wasmer::{
+    AsStoreMut, ExportIndex, FunctionMiddleware, GlobalInit, GlobalType, Instance,
+    LocalFunctionIndex, MiddlewareError, MiddlewareReaderState, ModuleMiddleware, Mutability, Type,
+};
+use wasmer_types::{GlobalIndex, ModuleInfo};
+
+#[derive(Clone)]
+struct MeteringGlobalIndexes(GlobalIndex, GlobalIndex);
+
+impl MeteringGlobalIndexes {
+    /// The global index in the current module for remaining points.
+    fn remaining_points(&self) -> GlobalIndex {
+        self.0
+    }
+
+    /// The global index in the current module for a boolean indicating whether points are exhausted
+    /// or not.
+    /// This boolean is represented as a i32 global:
+    ///   * 0: there are remaining points
+    ///   * 1: points have been exhausted
+    fn points_exhausted(&self) -> GlobalIndex {
+        self.1
+    }
+}
+
+impl fmt::Debug for MeteringGlobalIndexes {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MeteringGlobalIndexes")
+            .field("remaining_points", &self.remaining_points())
+            .field("points_exhausted", &self.points_exhausted())
+            .finish()
+    }
+}
+
+/// The module-level metering middleware.
+///
+/// # Panic
+///
+/// An instance of `Metering` should _not_ be shared among different
+/// modules, since it tracks module-specific information like the
+/// global index to store metering state. Attempts to use a `Metering`
+/// instance from multiple modules will result in a panic.
+///
+/// # Example
+///
+/// ```rust
+/// use std::sync::Arc;
+/// use wasmer::{wasmparser::Operator, CompilerConfig};
+/// use wasmer_middlewares::Metering;
+///
+/// fn create_metering_middleware(compiler_config: &mut dyn CompilerConfig) {
+///     // Let's define a dummy cost function,
+///     // which counts 1 for all operators.
+///     let cost_function = |_operator: &Operator| -> u64 { 1 };
+///
+///     // Let's define the initial limit.
+///     let initial_limit = 10;
+///
+///     // Let's creating the metering middleware.
+///     let metering = Arc::new(Metering::new(
+///         initial_limit,
+///         cost_function
+///     ));
+///
+///     // Finally, let's push the middleware.
+///     compiler_config.push_middleware(metering);
+/// }
+/// ```
+pub struct Metering<F: Fn(&Operator) -> u64 + Send + Sync> {
+    /// Initial limit of points.
+    initial_limit: u64,
+
+    /// Function that maps each operator to a cost in "points".
+    cost_function: Arc<F>,
+
+    /// The global indexes for metering points.
+    global_indexes: Mutex<Option<MeteringGlobalIndexes>>,
+}
+
+/// The function-level metering middleware.
+pub struct FunctionMetering<F: Fn(&Operator) -> u64 + Send + Sync> {
+    /// Function that maps each operator to a cost in "points".
+    cost_function: Arc<F>,
+
+    /// The global indexes for metering points.
+    global_indexes: MeteringGlobalIndexes,
+
+    /// Accumulated cost of the current basic block.
+    accumulated_cost: u64,
+}
+
+/// Represents the type of the metering points, either `Remaining` or
+/// `Exhausted`.
+///
+/// # Example
+///
+/// See the [`get_remaining_points`] function to get an example.
+#[derive(Debug, Eq, PartialEq)]
+pub enum MeteringPoints {
+    /// The given number of metering points is left for the execution.
+    /// If the value is 0, all points are consumed but the execution
+    /// was not terminated.
+    Remaining(u64),
+
+    /// The execution was terminated because the metering points were
+    /// exhausted.  You can recover from this state by setting the
+    /// points via [`set_remaining_points`] and restart the execution.
+    Exhausted,
+}
+
+impl<F: Fn(&Operator) -> u64 + Send + Sync> Metering<F> {
+    /// Creates a `Metering` middleware.
+    pub fn new(initial_limit: u64, cost_function: F) -> Self {
+        Self {
+            initial_limit,
+            cost_function: Arc::new(cost_function),
+            global_indexes: Mutex::new(None),
+        }
+    }
+}
+
+impl<F: Fn(&Operator) -> u64 + Send + Sync> fmt::Debug for Metering<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Metering")
+            .field("initial_limit", &self.initial_limit)
+            .field("cost_function", &"<function>")
+            .field("global_indexes", &self.global_indexes)
+            .finish()
+    }
+}
+
+impl<F: Fn(&Operator) -> u64 + Send + Sync + 'static> ModuleMiddleware for Metering<F> {
+    /// Generates a `FunctionMiddleware` for a given function.
+    fn generate_function_middleware<'a>(
+        &self,
+        _: LocalFunctionIndex,
+    ) -> Box<dyn FunctionMiddleware<'a> + 'a> {
+        Box::new(FunctionMetering {
+            cost_function: self.cost_function.clone(),
+            global_indexes: self.global_indexes.lock().unwrap().clone().unwrap(),
+            accumulated_cost: 0,
+        })
+    }
+
+    /// Transforms a `ModuleInfo` struct in-place. This is called before application on functions begins.
+    fn transform_module_info(&self, module_info: &mut ModuleInfo) -> Result<(), MiddlewareError> {
+        let mut global_indexes = self.global_indexes.lock().unwrap();
+
+        if global_indexes.is_some() {
+            panic!("Metering::transform_module_info: Attempting to use a `Metering` middleware from multiple modules.");
+        }
+
+        // Append a global for remaining points and initialize it.
+        let remaining_points_global_index = module_info
+            .globals
+            .push(GlobalType::new(Type::I64, Mutability::Var));
+
+        module_info
+            .global_initializers
+            .push(GlobalInit::I64Const(self.initial_limit as i64));
+
+        module_info.exports.insert(
+            "wasmer_metering_remaining_points".to_string(),
+            ExportIndex::Global(remaining_points_global_index),
+        );
+
+        // Append a global for the exhausted points boolean and initialize it.
+        let points_exhausted_global_index = module_info
+            .globals
+            .push(GlobalType::new(Type::I32, Mutability::Var));
+
+        module_info
+            .global_initializers
+            .push(GlobalInit::I32Const(0));
+
+        module_info.exports.insert(
+            "wasmer_metering_points_exhausted".to_string(),
+            ExportIndex::Global(points_exhausted_global_index),
+        );
+
+        *global_indexes = Some(MeteringGlobalIndexes(
+            remaining_points_global_index,
+            points_exhausted_global_index,
+        ));
+        Ok(())
+    }
+}
+
+impl<F: Fn(&Operator) -> u64 + Send + Sync> fmt::Debug for FunctionMetering<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FunctionMetering")
+            .field("cost_function", &"<function>")
+            .field("global_indexes", &self.global_indexes)
+            .finish()
+    }
+}
+
+impl<'a, F: Fn(&Operator) -> u64 + Send + Sync> FunctionMiddleware<'a> for FunctionMetering<F> {
+    fn feed(
+        &mut self,
+        operator: Operator<'a>,
+        state: &mut MiddlewareReaderState<'a>,
+    ) -> Result<(), MiddlewareError> {
+        // Get the cost of the current operator, and add it to the accumulator.
+        // This needs to be done before the metering logic, to prevent operators like `Call` from escaping metering in some
+        // corner cases.
+        self.accumulated_cost += (self.cost_function)(&operator);
+
+        // Possible sources and targets of a branch. Finalize the cost of the previous basic block and perform necessary checks.
+        match operator {
+            Operator::Loop { .. } // loop headers are branch targets
+            | Operator::End // block ends are branch targets
+            | Operator::Else // "else" is the "end" of an if branch
+            | Operator::Br { .. } // branch source
+            | Operator::BrTable { .. } // branch source
+            | Operator::BrIf { .. } // branch source
+            | Operator::Call { .. } // function call - branch source
+            | Operator::CallIndirect { .. } // function call - branch source
+            | Operator::Return // end of function - branch source
+            => {
+                if self.accumulated_cost > 0 {
+                    state.extend(&[
+                        // if unsigned(globals[remaining_points_index]) < unsigned(self.accumulated_cost) { throw(); }
+                        Operator::GlobalGet { global_index: self.global_indexes.remaining_points().as_u32() },
+                        Operator::I64Const { value: self.accumulated_cost as i64 },
+                        Operator::I64LtU,
+                        Operator::If { blockty: WpTypeOrFuncType::Empty },
+                        Operator::I32Const { value: 1 },
+                        Operator::GlobalSet { global_index: self.global_indexes.points_exhausted().as_u32() },
+                        Operator::Unreachable,
+                        Operator::End,
+
+                        // globals[remaining_points_index] -= self.accumulated_cost;
+                        Operator::GlobalGet { global_index: self.global_indexes.remaining_points().as_u32() },
+                        Operator::I64Const { value: self.accumulated_cost as i64 },
+                        Operator::I64Sub,
+                        Operator::GlobalSet { global_index: self.global_indexes.remaining_points().as_u32() },
+                    ]);
+
+                    self.accumulated_cost = 0;
+                }
+            }
+            _ => {}
+        }
+        state.push_operator(operator);
+
+        Ok(())
+    }
+}
+
+/// Get the remaining points in an [`Instance`][wasmer::Instance].
+///
+/// Note: This can be used in a headless engine after an ahead-of-time
+/// compilation as all required state lives in the instance.
+///
+/// # Panic
+///
+/// The [`Instance`][wasmer::Instance) must have been processed with
+/// the [`Metering`] middleware at compile time, otherwise this will
+/// panic.
+///
+/// # Example
+///
+/// ```rust
+/// use wasmer::Instance;
+/// use wasmer::AsStoreMut;
+/// use wasmer_middlewares::metering::{get_remaining_points, MeteringPoints};
+///
+/// /// Check whether the instance can continue to run based on the
+/// /// number of remaining points.
+/// fn can_continue_to_run(store: &mut impl AsStoreMut, instance: &Instance) -> bool {
+///     matches!(get_remaining_points(store, instance), MeteringPoints::Remaining(points) if points > 0)
+/// }
+/// ```
+pub fn get_remaining_points(ctx: &mut impl AsStoreMut, instance: &Instance) -> MeteringPoints {
+    let exhausted: i32 = instance
+        .exports
+        .get_global("wasmer_metering_points_exhausted")
+        .expect("Can't get `wasmer_metering_points_exhausted` from Instance")
+        .get(ctx)
+        .try_into()
+        .expect("`wasmer_metering_points_exhausted` from Instance has wrong type");
+
+    if exhausted > 0 {
+        return MeteringPoints::Exhausted;
+    }
+
+    let points = instance
+        .exports
+        .get_global("wasmer_metering_remaining_points")
+        .expect("Can't get `wasmer_metering_remaining_points` from Instance")
+        .get(ctx)
+        .try_into()
+        .expect("`wasmer_metering_remaining_points` from Instance has wrong type");
+
+    MeteringPoints::Remaining(points)
+}
+
+/// Set the new provided remaining points in an
+/// [`Instance`][wasmer::Instance].
+///
+/// Note: This can be used in a headless engine after an ahead-of-time
+/// compilation as all required state lives in the instance.
+///
+/// # Panic
+///
+/// The given [`Instance`][wasmer::Instance] must have been processed
+/// with the [`Metering`] middleware at compile time, otherwise this
+/// will panic.
+///
+/// # Example
+///
+/// ```rust
+/// use wasmer::{AsStoreMut, Instance};
+/// use wasmer_middlewares::metering::set_remaining_points;
+///
+/// fn update_remaining_points(store: &mut impl AsStoreMut, instance: &Instance) {
+///     // The new limit.
+///     let new_limit = 10;
+///
+///     // Update the remaining points to the `new_limit`.
+///     set_remaining_points(store, instance, new_limit);
+/// }
+/// ```
+pub fn set_remaining_points(ctx: &mut impl AsStoreMut, instance: &Instance, points: u64) {
+    instance
+        .exports
+        .get_global("wasmer_metering_remaining_points")
+        .expect("Can't get `wasmer_metering_remaining_points` from Instance")
+        .set(ctx, points.into())
+        .expect("Can't set `wasmer_metering_remaining_points` in Instance");
+
+    instance
+        .exports
+        .get_global("wasmer_metering_points_exhausted")
+        .expect("Can't get `wasmer_metering_points_exhausted` from Instance")
+        .set(ctx, 0i32.into())
+        .expect("Can't set `wasmer_metering_points_exhausted` in Instance");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::sync::Arc;
+    use wasmer::sys::EngineBuilder;
+    use wasmer::{imports, wat2wasm, CompilerConfig, Cranelift, Module, Store, TypedFunction};
+
+    fn cost_function(operator: &Operator) -> u64 {
+        match operator {
+            Operator::LocalGet { .. } | Operator::I32Const { .. } => 1,
+            Operator::I32Add { .. } => 2,
+            _ => 0,
+        }
+    }
+
+    fn bytecode() -> Vec<u8> {
+        wat2wasm(
+            br#"
+            (module
+            (type $add_t (func (param i32) (result i32)))
+            (func $add_one_f (type $add_t) (param $value i32) (result i32)
+                local.get $value
+                i32.const 1
+                i32.add)
+            (export "add_one" (func $add_one_f)))
+            "#,
+        )
+        .unwrap()
+        .into()
+    }
+
+    #[test]
+    fn get_remaining_points_works() {
+        let metering = Arc::new(Metering::new(10, cost_function));
+        let mut compiler_config = Cranelift::default();
+        compiler_config.push_middleware(metering);
+        let mut store = Store::new(EngineBuilder::new(compiler_config));
+        let module = Module::new(&store, bytecode()).unwrap();
+
+        // Instantiate
+        let instance = Instance::new(&mut store, &module, &imports! {}).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(10)
+        );
+
+        // First call
+        //
+        // Calling add_one costs 4 points. Here are the details of how it has been computed:
+        // * `local.get $value` is a `Operator::LocalGet` which costs 1 point;
+        // * `i32.const` is a `Operator::I32Const` which costs 1 point;
+        // * `i32.add` is a `Operator::I32Add` which costs 2 points.
+        let add_one: TypedFunction<i32, i32> = instance
+            .exports
+            .get_function("add_one")
+            .unwrap()
+            .typed(&store)
+            .unwrap();
+        add_one.call(&mut store, 1).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(6)
+        );
+
+        // Second call
+        add_one.call(&mut store, 1).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(2)
+        );
+
+        // Third call fails due to limit
+        assert!(add_one.call(&mut store, 1).is_err());
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Exhausted
+        );
+    }
+
+    #[test]
+    fn set_remaining_points_works() {
+        let metering = Arc::new(Metering::new(10, cost_function));
+        let mut compiler_config = Cranelift::default();
+        compiler_config.push_middleware(metering);
+        let mut store = Store::new(EngineBuilder::new(compiler_config));
+        let module = Module::new(&store, bytecode()).unwrap();
+
+        // Instantiate
+        let instance = Instance::new(&mut store, &module, &imports! {}).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(10)
+        );
+        let add_one: TypedFunction<i32, i32> = instance
+            .exports
+            .get_function("add_one")
+            .unwrap()
+            .typed(&store)
+            .unwrap();
+
+        // Increase a bit to have enough for 3 calls
+        set_remaining_points(&mut store, &instance, 12);
+
+        // Ensure we can use the new points now
+        add_one.call(&mut store, 1).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(8)
+        );
+
+        add_one.call(&mut store, 1).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(4)
+        );
+
+        add_one.call(&mut store, 1).unwrap();
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(0)
+        );
+
+        assert!(add_one.call(&mut store, 1).is_err());
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Exhausted
+        );
+
+        // Add some points for another call
+        set_remaining_points(&mut store, &instance, 4);
+        assert_eq!(
+            get_remaining_points(&mut store, &instance),
+            MeteringPoints::Remaining(4)
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/object/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/object/Cargo.toml
new file mode 100644
index 0000000..8ac04a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/object/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "wasmer-object"
+description = "Wasmer Native Object generator"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+wasmer-types = { path = "../types", version = "=4.2.8" }
+object = { version = "0.29.0", default-features = false, features = ["write"] }
+thiserror = "1.0"
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/object/README.md b/arbitrator/tools/module_roots/wasmer/lib/object/README.md
new file mode 100644
index 0000000..aee56b3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/object/README.md
@@ -0,0 +1,10 @@
+# `wasmer-object` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+The Wasmer Native Object crate aims at cross-generating native objects
+for various platforms.
+
+Given a compilation result, i.e. the result
+of `wasmer_compiler::Compiler::compile_module`, this crate exposes
+functions to create an `Object` file for a given target. It is a
+useful thin layer on top of [the `object`
+crate](https://github.com/gimli-rs/object).
diff --git a/arbitrator/tools/module_roots/wasmer/lib/object/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/object/src/error.rs
new file mode 100644
index 0000000..910afbe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/object/src/error.rs
@@ -0,0 +1,23 @@
+use object::write::Error as ObjectWriteError;
+use thiserror::Error;
+
+/// The Object error can occur when creating an object file
+/// from a `Compilation`.
+#[derive(Error, Debug)]
+pub enum ObjectError {
+    /// The object was provided a not-supported binary format
+    #[error("Binary format {0} not supported")]
+    UnsupportedBinaryFormat(String),
+    /// The object was provided a not-supported architecture
+    #[error("Architecture {0} not supported")]
+    UnsupportedArchitecture(String),
+    /// The object was provided an unknown endianness
+    #[error("Unknown Endianness")]
+    UnknownEndianness,
+    /// The object was provided a not-supported architecture
+    #[error("Error when writing the object: {0}")]
+    Write(#[from] ObjectWriteError),
+    /// The module provided could not be serialized into bytes
+    #[error("Error when serializing the given module: {0}")]
+    Serialize(#[from] wasmer_types::SerializeError),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/object/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/object/src/lib.rs
new file mode 100644
index 0000000..946101e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/object/src/lib.rs
@@ -0,0 +1,25 @@
+//! Object creator for Wasm Compilations.
+//!
+//! Given a compilation result (this is, the result when calling `Compiler::compile_module`)
+//! this exposes functions to create an Object file for a given target.
+
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![allow(clippy::new_without_default)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+mod error;
+mod module;
+
+pub use crate::error::ObjectError;
+pub use crate::module::{emit_compilation, emit_data, emit_serialized, get_object_for_target};
+pub use object::{self, write::Object};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/object/src/module.rs b/arbitrator/tools/module_roots/wasmer/lib/object/src/module.rs
new file mode 100644
index 0000000..333980e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/object/src/module.rs
@@ -0,0 +1,469 @@
+use crate::error::ObjectError;
+use object::write::{
+    Object, Relocation, StandardSection, StandardSegment, Symbol as ObjSymbol, SymbolSection,
+};
+use object::{
+    elf, macho, FileFlags, RelocationEncoding, RelocationKind, SectionKind, SymbolFlags,
+    SymbolKind, SymbolScope,
+};
+use wasmer_types::entity::PrimaryMap;
+use wasmer_types::LocalFunctionIndex;
+use wasmer_types::{
+    Architecture, BinaryFormat, Compilation, CustomSectionProtection, Endianness,
+    RelocationKind as Reloc, RelocationTarget, SectionIndex, Triple,
+};
+use wasmer_types::{Symbol, SymbolRegistry};
+
+const DWARF_SECTION_NAME: &[u8] = b".eh_frame";
+
+/// Create an object for a given target `Triple`.
+///
+/// # Usage
+///
+/// ```rust
+/// # use wasmer_types::Triple;
+/// # use wasmer_object::ObjectError;
+/// use wasmer_object::get_object_for_target;
+///
+/// # fn generate_object_for_target(triple: &Triple) -> Result<(), ObjectError> {
+/// let mut object = get_object_for_target(&triple)?;
+///
+/// # Ok(())
+/// # }
+/// ```
+pub fn get_object_for_target(triple: &Triple) -> Result<Object, ObjectError> {
+    let obj_binary_format = match triple.binary_format {
+        BinaryFormat::Elf => object::BinaryFormat::Elf,
+        BinaryFormat::Macho => object::BinaryFormat::MachO,
+        BinaryFormat::Coff => object::BinaryFormat::Coff,
+        binary_format => {
+            return Err(ObjectError::UnsupportedBinaryFormat(format!(
+                "{}",
+                binary_format
+            )));
+        }
+    };
+    let obj_architecture = match triple.architecture {
+        Architecture::X86_64 => object::Architecture::X86_64,
+        Architecture::Aarch64(_) => object::Architecture::Aarch64,
+        Architecture::Riscv64(_) => object::Architecture::Riscv64,
+        architecture => {
+            return Err(ObjectError::UnsupportedArchitecture(format!(
+                "{}",
+                architecture
+            )));
+        }
+    };
+    let obj_endianness = match triple
+        .endianness()
+        .map_err(|_| ObjectError::UnknownEndianness)?
+    {
+        Endianness::Little => object::Endianness::Little,
+        Endianness::Big => object::Endianness::Big,
+    };
+
+    let mut object = Object::new(obj_binary_format, obj_architecture, obj_endianness);
+
+    if let Architecture::Riscv64(_) = triple.architecture {
+        object.flags = FileFlags::Elf {
+            e_flags: elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+            os_abi: 2,
+            abi_version: 0,
+        };
+    }
+
+    Ok(object)
+}
+
+/// Write data into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # use wasmer_types::Triple;
+/// # use wasmer_object::ObjectError;
+/// use wasmer_object::{get_object_for_target, emit_data};
+///
+/// # fn emit_data_into_object(triple: &Triple) -> Result<(), ObjectError> {
+/// let mut object = get_object_for_target(&triple)?;
+/// emit_data(&mut object, b"WASMER_METADATA", &b"Hello, World!"[..], 1)?;
+///
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_data(
+    obj: &mut Object,
+    name: &[u8],
+    data: &[u8],
+    align: u64,
+) -> Result<(), ObjectError> {
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: name.to_vec(),
+        value: 0,
+        size: 0,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Undefined,
+        flags: SymbolFlags::None,
+    });
+    let section_id = obj.section_id(StandardSection::Data);
+    obj.add_symbol_data(symbol_id, section_id, data, align);
+
+    Ok(())
+}
+
+/// Emit the compilation result into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # use wasmer_types::SymbolRegistry;
+/// # use wasmer_types::{Compilation, Triple};
+/// # use wasmer_object::ObjectError;
+/// use wasmer_object::{get_object_for_target, emit_compilation};
+///
+/// # fn emit_compilation_into_object(
+/// #     triple: &Triple,
+/// #     compilation: Compilation,
+/// #     symbol_registry: impl SymbolRegistry,
+/// # ) -> Result<(), ObjectError> {
+/// let mut object = get_object_for_target(&triple)?;
+/// emit_compilation(&mut object, compilation, &symbol_registry, &triple)?;
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_compilation(
+    obj: &mut Object,
+    compilation: Compilation,
+    symbol_registry: &impl SymbolRegistry,
+    triple: &Triple,
+) -> Result<(), ObjectError> {
+    let mut function_bodies = PrimaryMap::with_capacity(compilation.functions.len());
+    let mut function_relocations = PrimaryMap::with_capacity(compilation.functions.len());
+    for (_, func) in compilation.functions.into_iter() {
+        function_bodies.push(func.body);
+        function_relocations.push(func.relocations);
+    }
+    let custom_section_relocations = compilation
+        .custom_sections
+        .iter()
+        .map(|(_, section)| section.relocations.clone())
+        .collect::<PrimaryMap<SectionIndex, _>>();
+
+    let debug_index = compilation.debug.map(|d| d.eh_frame);
+
+    let align = match triple.architecture {
+        Architecture::X86_64 => 1,
+        // In Arm64 is recommended a 4-byte alignment
+        Architecture::Aarch64(_) => 4,
+        _ => 1,
+    };
+
+    // Add sections
+    let custom_section_ids = compilation
+        .custom_sections
+        .into_iter()
+        .map(|(section_index, custom_section)| {
+            if debug_index.map_or(false, |d| d == section_index) {
+                // If this is the debug section
+                let segment = obj.segment_name(StandardSegment::Debug).to_vec();
+                let section_id =
+                    obj.add_section(segment, DWARF_SECTION_NAME.to_vec(), SectionKind::Debug);
+                obj.append_section_data(section_id, custom_section.bytes.as_slice(), align);
+                let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
+                let symbol_id = obj.add_symbol(ObjSymbol {
+                    name: section_name.into_bytes(),
+                    value: 0,
+                    size: custom_section.bytes.len() as _,
+                    kind: SymbolKind::Data,
+                    scope: SymbolScope::Compilation,
+                    weak: false,
+                    section: SymbolSection::Section(section_id),
+                    flags: SymbolFlags::None,
+                });
+                (section_id, symbol_id)
+            } else {
+                let section_name = symbol_registry.symbol_to_name(Symbol::Section(section_index));
+                let (section_kind, standard_section) = match custom_section.protection {
+                    CustomSectionProtection::ReadExecute => {
+                        (SymbolKind::Text, StandardSection::Text)
+                    }
+                    CustomSectionProtection::Read => (SymbolKind::Data, StandardSection::Data),
+                };
+                let section_id = obj.section_id(standard_section);
+                let symbol_id = obj.add_symbol(ObjSymbol {
+                    name: section_name.into_bytes(),
+                    value: 0,
+                    size: custom_section.bytes.len() as _,
+                    kind: section_kind,
+                    scope: SymbolScope::Dynamic,
+                    weak: false,
+                    section: SymbolSection::Section(section_id),
+                    flags: SymbolFlags::None,
+                });
+                obj.add_symbol_data(
+                    symbol_id,
+                    section_id,
+                    custom_section.bytes.as_slice(),
+                    align,
+                );
+                (section_id, symbol_id)
+            }
+        })
+        .collect::<PrimaryMap<SectionIndex, _>>();
+
+    // Add functions
+    let function_symbol_ids = function_bodies
+        .into_iter()
+        .map(|(function_local_index, function)| {
+            let function_name =
+                symbol_registry.symbol_to_name(Symbol::LocalFunction(function_local_index));
+            let section_id = obj.section_id(StandardSection::Text);
+            let symbol_id = obj.add_symbol(ObjSymbol {
+                name: function_name.into_bytes(),
+                value: 0,
+                size: function.body.len() as _,
+                kind: SymbolKind::Text,
+                scope: SymbolScope::Dynamic,
+                weak: false,
+                section: SymbolSection::Section(section_id),
+                flags: SymbolFlags::None,
+            });
+            obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+            (section_id, symbol_id)
+        })
+        .collect::<PrimaryMap<LocalFunctionIndex, _>>();
+
+    // Add function call trampolines
+    for (signature_index, function) in compilation.function_call_trampolines.into_iter() {
+        let function_name =
+            symbol_registry.symbol_to_name(Symbol::FunctionCallTrampoline(signature_index));
+        let section_id = obj.section_id(StandardSection::Text);
+        let symbol_id = obj.add_symbol(ObjSymbol {
+            name: function_name.into_bytes(),
+            value: 0,
+            size: function.body.len() as _,
+            kind: SymbolKind::Text,
+            scope: SymbolScope::Dynamic,
+            weak: false,
+            section: SymbolSection::Section(section_id),
+            flags: SymbolFlags::None,
+        });
+        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+    }
+
+    // Add dynamic function trampolines
+    for (func_index, function) in compilation.dynamic_function_trampolines.into_iter() {
+        let function_name =
+            symbol_registry.symbol_to_name(Symbol::DynamicFunctionTrampoline(func_index));
+        let section_id = obj.section_id(StandardSection::Text);
+        let symbol_id = obj.add_symbol(ObjSymbol {
+            name: function_name.into_bytes(),
+            value: 0,
+            size: function.body.len() as _,
+            kind: SymbolKind::Text,
+            scope: SymbolScope::Dynamic,
+            weak: false,
+            section: SymbolSection::Section(section_id),
+            flags: SymbolFlags::None,
+        });
+        obj.add_symbol_data(symbol_id, section_id, &function.body, align);
+    }
+
+    let mut all_relocations = Vec::new();
+
+    for (function_local_index, relocations) in function_relocations.into_iter() {
+        let (section_id, symbol_id) = function_symbol_ids.get(function_local_index).unwrap();
+        all_relocations.push((*section_id, *symbol_id, relocations))
+    }
+
+    for (section_index, relocations) in custom_section_relocations.into_iter() {
+        if !debug_index.map_or(false, |d| d == section_index) {
+            // Skip DWARF relocations just yet
+            let (section_id, symbol_id) = custom_section_ids.get(section_index).unwrap();
+            all_relocations.push((*section_id, *symbol_id, relocations));
+        }
+    }
+
+    for (section_id, symbol_id, relocations) in all_relocations.into_iter() {
+        let (_symbol_id, section_offset) = obj.symbol_section_and_offset(symbol_id).unwrap();
+
+        for r in relocations {
+            let relocation_address = section_offset + r.offset as u64;
+
+            let (relocation_kind, relocation_encoding, relocation_size) = match r.kind {
+                Reloc::Abs4 => (RelocationKind::Absolute, RelocationEncoding::Generic, 32),
+                Reloc::Abs8 => (RelocationKind::Absolute, RelocationEncoding::Generic, 64),
+                Reloc::X86PCRel4 => (RelocationKind::Relative, RelocationEncoding::Generic, 32),
+                Reloc::X86CallPCRel4 => {
+                    (RelocationKind::Relative, RelocationEncoding::X86Branch, 32)
+                }
+                Reloc::X86CallPLTRel4 => (
+                    RelocationKind::PltRelative,
+                    RelocationEncoding::X86Branch,
+                    32,
+                ),
+                Reloc::X86GOTPCRel4 => {
+                    (RelocationKind::GotRelative, RelocationEncoding::Generic, 32)
+                }
+                Reloc::Arm64Call => (
+                    match obj.format() {
+                        object::BinaryFormat::Elf => RelocationKind::Elf(elf::R_AARCH64_CALL26),
+                        object::BinaryFormat::MachO => RelocationKind::MachO {
+                            value: macho::ARM64_RELOC_BRANCH26,
+                            relative: true,
+                        },
+                        fmt => panic!("unsupported binary format {:?}", fmt),
+                    },
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                Reloc::ElfX86_64TlsGd => (
+                    RelocationKind::Elf(elf::R_X86_64_TLSGD),
+                    RelocationEncoding::Generic,
+                    32,
+                ),
+                other => {
+                    return Err(ObjectError::UnsupportedArchitecture(format!(
+                        "{} (relocation: {}",
+                        triple.architecture, other
+                    )))
+                }
+            };
+
+            match r.reloc_target {
+                RelocationTarget::LocalFunc(index) => {
+                    let (_, target_symbol) = function_symbol_ids.get(index).unwrap();
+                    obj.add_relocation(
+                        section_id,
+                        Relocation {
+                            offset: relocation_address,
+                            size: relocation_size,
+                            kind: relocation_kind,
+                            encoding: relocation_encoding,
+                            symbol: *target_symbol,
+                            addend: r.addend,
+                        },
+                    )
+                    .map_err(ObjectError::Write)?;
+                }
+                RelocationTarget::LibCall(libcall) => {
+                    let libcall_fn_name = libcall.to_function_name().as_bytes();
+                    // We add the symols lazily as we see them
+                    let target_symbol = obj.symbol_id(libcall_fn_name).unwrap_or_else(|| {
+                        obj.add_symbol(ObjSymbol {
+                            name: libcall_fn_name.to_vec(),
+                            value: 0,
+                            size: 0,
+                            kind: SymbolKind::Unknown,
+                            scope: SymbolScope::Unknown,
+                            weak: false,
+                            section: SymbolSection::Undefined,
+                            flags: SymbolFlags::None,
+                        })
+                    });
+                    obj.add_relocation(
+                        section_id,
+                        Relocation {
+                            offset: relocation_address,
+                            size: relocation_size,
+                            kind: relocation_kind,
+                            encoding: relocation_encoding,
+                            symbol: target_symbol,
+                            addend: r.addend,
+                        },
+                    )
+                    .map_err(ObjectError::Write)?;
+                }
+                RelocationTarget::CustomSection(section_index) => {
+                    let (_, target_symbol) = custom_section_ids.get(section_index).unwrap();
+                    obj.add_relocation(
+                        section_id,
+                        Relocation {
+                            offset: relocation_address,
+                            size: relocation_size,
+                            kind: relocation_kind,
+                            encoding: relocation_encoding,
+                            symbol: *target_symbol,
+                            addend: r.addend,
+                        },
+                    )
+                    .map_err(ObjectError::Write)?;
+                }
+            };
+        }
+    }
+
+    Ok(())
+}
+
+/// Emit the compilation result into an existing object.
+///
+/// # Usage
+///
+/// ```rust
+/// # use wasmer_types::SymbolRegistry;
+/// # use wasmer_types::{Compilation, Triple};
+/// # use wasmer_object::{ObjectError, emit_serialized};
+/// use wasmer_object::{get_object_for_target, emit_compilation};
+///
+/// # fn emit_compilation_into_object(
+/// #     triple: &Triple,
+/// #     compilation: Compilation,
+/// #     symbol_registry: impl SymbolRegistry,
+/// # ) -> Result<(), ObjectError> {
+/// let bytes = &[ /* compilation bytes */];
+/// let mut object = get_object_for_target(&triple)?;
+/// emit_serialized(&mut object, bytes, &triple, "WASMER_MODULE")?;
+/// # Ok(())
+/// # }
+/// ```
+pub fn emit_serialized(
+    obj: &mut Object,
+    sercomp: &[u8],
+    triple: &Triple,
+    object_name: &str,
+) -> Result<(), ObjectError> {
+    obj.set_mangling(object::write::Mangling::None);
+    //let module_name = module.compile_info.module.name.clone();
+    let len_name = format!("{}_LENGTH", object_name);
+    let data_name = format!("{}_DATA", object_name);
+    //let metadata_name = "WASMER_MODULE_METADATA";
+
+    let align = match triple.architecture {
+        Architecture::X86_64 => 1,
+        // In Arm64 is recommended a 4-byte alignment
+        Architecture::Aarch64(_) => 4,
+        _ => 1,
+    };
+
+    let len = sercomp.len();
+    let section_id = obj.section_id(StandardSection::Data);
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: len_name.as_bytes().to_vec(),
+        value: 0,
+        size: len.to_le_bytes().len() as _,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Section(section_id),
+        flags: SymbolFlags::None,
+    });
+    obj.add_symbol_data(symbol_id, section_id, &len.to_le_bytes(), align);
+
+    let section_id = obj.section_id(StandardSection::Data);
+    let symbol_id = obj.add_symbol(ObjSymbol {
+        name: data_name.as_bytes().to_vec(),
+        value: 0,
+        size: sercomp.len() as _,
+        kind: SymbolKind::Data,
+        scope: SymbolScope::Dynamic,
+        weak: false,
+        section: SymbolSection::Section(section_id),
+        flags: SymbolFlags::None,
+    });
+    obj.add_symbol_data(symbol_id, section_id, sercomp, align);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/registry/Cargo.toml
new file mode 100644
index 0000000..6fd832d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/Cargo.toml
@@ -0,0 +1,61 @@
+[package]
+name = "wasmer-registry"
+version = "5.10.4"
+description = "Crate to interact with the wasmer registry, download packages, etc."
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[features]
+build-package  = ["rusqlite", "indexmap", "wasmer-wasm-interface", "wasmparser", "rpassword", "minisign", "time"]
+
+[dependencies]
+anyhow = "1.0.65"
+clap = { version = "4.3.5", default-features = false, features = ["derive", "env"], optional = true }
+console = "0.15.2"
+dialoguer = "0.11.0"
+dirs = "4.0.0"
+filetime = "0.2.19"
+flate2 = "1.0.24"
+futures = "0.3"
+futures-util = "0.3.25"
+graphql-ws-client = {version = "0.6.0", features = ["client-graphql-client"]}
+graphql_client = "0.13.0"
+hex = "0.4.3"
+indexmap = { version = "1.9.3", optional = true }
+indicatif = "0.17.2"
+lazy_static = "1.4.0"
+log = "0.4.17"
+lzma-rs = "0.2.0"
+minisign = { version = "0.7.2", optional = true }
+regex = "1.7.0"
+reqwest = { version = "0.11.12", default-features = false, features = ["blocking", "multipart", "json", "stream"] }
+rpassword = { version = "7.2.0", optional = true }
+rusqlite = { version = "0.28.0", optional = true, features = ["bundled"] }
+semver = "1.0.14"
+serde = { version = "1.0.145", features = ["derive"] }
+serde_json = "1.0.85"
+tar = "0.4.38"
+tempfile = "3.6.0"
+thiserror = "1.0.37"
+time = { version = "0.3.17", default-features = false, features = ["parsing", "std", "formatting"], optional = true }
+tldextract = "0.6.0"
+tokio = {version = "1", features = ["rt-multi-thread"]}
+tokio-tungstenite = {version = "0.20", features = ["rustls-tls-native-roots"]}
+toml = "0.5.9"
+tracing = "0.1.40"
+url = "2.3.1"
+wasmer-toml = { workspace = true }
+wasmer-wasm-interface = { version = "4.2.8", path = "../wasm-interface", optional = true }
+wasmparser = { workspace = true, optional = true }
+whoami = "1.2.3"
+
+[dev-dependencies]
+pretty_assertions = "1.3.0"
+
+[package.metadata.docs.rs]
+features = ["build-package"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/README.md b/arbitrator/tools/module_roots/wasmer/lib/registry/README.md
new file mode 100644
index 0000000..625820a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/README.md
@@ -0,0 +1,24 @@
+# wasmer-registry
+
+This crate provides integration with the Wasmer package registry GraphQL API.
+
+## Development
+
+### Updating the GraphQL Schema
+
+The GraphQL API schema used for generating queries and mutations is located at
+`./graphql/schema.graphql`.
+
+To update it to a deployed version of the backend, run:
+
+```bash
+npx get-graphql-schema https://registry.wasmer.wtf/graphql > graphql/schema.graphql
+```
+
+### Formatting GraphQL Files
+
+To format the GraphQL query and mutation files, run:
+
+```bash
+npx prettier --write ./graphql/**/*.graphql
+```
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/generate_deploy_token.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/generate_deploy_token.graphql
new file mode 100644
index 0000000..4c4244b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/generate_deploy_token.graphql
@@ -0,0 +1,5 @@
+mutation GenerateDeployToken($appVersionId: String!) {
+  generateDeployToken(input: { deployAppVersionId: $configId }) {
+    token
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/new_nonce.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/new_nonce.graphql
new file mode 100644
index 0000000..b5a6b18
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/new_nonce.graphql
@@ -0,0 +1,7 @@
+mutation NewNonce($name: String!, $callbackUrl: String!) {
+  newNonce(input: { name: $name, callbackUrl: $callbackUrl }) {
+    nonce {
+      authUrl
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_deploy_app.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_deploy_app.graphql
new file mode 100644
index 0000000..123843d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_deploy_app.graphql
@@ -0,0 +1,16 @@
+mutation PublishDeployApp($config: JSONString!, $name: ID, $owner: ID) {
+  publishDeployApp(input: { config: $config, name: $name, owner: $owner }) {
+    deployAppVersion {
+      id
+      version
+      app {
+        id
+        owner {
+          __typename
+          globalName
+        }
+        name
+      }
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_package_chunked.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_package_chunked.graphql
new file mode 100644
index 0000000..63b11ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/mutations/publish_package_chunked.graphql
@@ -0,0 +1,42 @@
+mutation PublishPackageMutationChunked(
+  $name: String!
+  $version: String!
+  $description: String!
+  $manifest: String!
+  $license: String
+  $licenseFile: String
+  $readme: String
+  $fileName: String
+  $repository: String
+  $homepage: String
+  $signature: InputSignature
+  $signedUrl: String
+  $private: Boolean
+  $wait: Boolean
+) {
+  publishPackage(
+    input: {
+      name: $name
+      version: $version
+      description: $description
+      manifest: $manifest
+      license: $license
+      licenseFile: $licenseFile
+      readme: $readme
+      file: $fileName
+      signedUrl: $signedUrl
+      repository: $repository
+      homepage: $homepage
+      signature: $signature
+      clientMutationId: ""
+      private: $private
+      wait: $wait
+    }
+  ) {
+    success
+    packageVersion {
+      id
+      version
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_bindings.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_bindings.graphql
new file mode 100644
index 0000000..9a8cbe7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_bindings.graphql
@@ -0,0 +1,22 @@
+query GetBindingsQuery($name: String!, $version: String = "latest") {
+  packageVersion: getPackageVersion(name: $name, version: $version) {
+    bindings {
+      id
+      language
+      url
+
+      generator {
+        packageVersion {
+          id
+          version
+          package {
+            name
+          }
+        }
+        commandName
+      }
+
+      __typename
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_interface_version.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_interface_version.graphql
new file mode 100644
index 0000000..48508aa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_interface_version.graphql
@@ -0,0 +1,9 @@
+query GetInterfaceVersionQuery($name: String!, $version: String!) {
+  interface: getInterfaceVersion(name: $name, version: $version) {
+    version
+    content
+    interface {
+      name
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_by_command.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_by_command.graphql
new file mode 100644
index 0000000..8511d47
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_by_command.graphql
@@ -0,0 +1,18 @@
+query GetPackageByCommandQuery($commandName: String!) {
+  getCommand(name: $commandName) {
+    command
+    packageVersion {
+      version
+      isLastVersion
+      manifest
+      distribution {
+        downloadUrl
+        piritaDownloadUrl
+      }
+      package {
+        displayName
+        private
+      }
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_version.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_version.graphql
new file mode 100644
index 0000000..751c3b4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_package_version.graphql
@@ -0,0 +1,15 @@
+query GetPackageVersionQuery($name: String!, $version: String) {
+  packageVersion: getPackageVersion(name: $name, version: $version) {
+    package {
+      name
+      private
+    }
+    version
+    isLastVersion
+    distribution {
+      downloadUrl
+      piritaDownloadUrl
+    }
+    manifest
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_signed_url.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_signed_url.graphql
new file mode 100644
index 0000000..185515e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/get_signed_url.graphql
@@ -0,0 +1,13 @@
+query GetSignedUrl(
+  $name: String!
+  $version: String!
+  $expiresAfterSeconds: Int
+) {
+  url: getSignedUrlForPackageUpload(
+    name: $name
+    version: $version
+    expiresAfterSeconds: $expiresAfterSeconds
+  ) {
+    url
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/test_if_registry_present.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/test_if_registry_present.graphql
new file mode 100644
index 0000000..61c2152
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/test_if_registry_present.graphql
@@ -0,0 +1,3 @@
+query TestIfRegistryPresent {
+  __typename
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/whoami.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/whoami.graphql
new file mode 100644
index 0000000..256c983
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/queries/whoami.graphql
@@ -0,0 +1,5 @@
+query WhoAmIQuery {
+  viewer {
+    username
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/schema.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/schema.graphql
new file mode 100644
index 0000000..7bed7db
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/schema.graphql
@@ -0,0 +1,3072 @@
+interface Node {
+  """The ID of the object"""
+  id: ID!
+}
+
+type PublicKey implements Node {
+  """The ID of the object"""
+  id: ID!
+  owner: User!
+  keyId: String!
+  key: String!
+  revokedAt: DateTime
+  uploadedAt: DateTime!
+  verifyingSignature: Signature
+  revoked: Boolean!
+}
+
+type User implements Node & PackageOwner & Owner {
+  firstName: String!
+  lastName: String!
+  email: String!
+  dateJoined: DateTime!
+
+  """Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only."""
+  username: String!
+  isEmailValidated: Boolean!
+  bio: String
+  location: String
+  websiteUrl: String
+
+  """The ID of the object"""
+  id: ID!
+  globalName: String!
+  globalId: ID!
+  avatar(size: Int = 80): String!
+  isViewer: Boolean!
+  hasUsablePassword: Boolean
+  fullName: String!
+  githubUrl: String
+  twitterUrl: String
+  companyRole: String
+  companyDescription: String
+  publicActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  billing: Billing
+  waitlist(name: String!): WaitlistMember
+  namespaces(role: GrapheneRole, offset: Int, before: String, after: String, first: Int, last: Int): NamespaceConnection!
+  packages(collaborating: Boolean = false, offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  apps(collaborating: Boolean = false, sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  isStaff: Boolean
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
+  packageInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
+  namespaceInvitesIncoming(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  apiTokens(before: String, after: String, first: Int, last: Int): APITokenConnection!
+  notifications(before: String, after: String, first: Int, last: Int): UserNotificationConnection!
+  dashboardActivity(offset: Int, before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  loginMethods: [LoginMethod!]!
+}
+
+"""Setup for backwards compatibility with existing frontends."""
+interface PackageOwner {
+  globalName: String!
+  globalId: ID!
+}
+
+"""An owner of a package."""
+interface Owner {
+  globalName: String!
+  globalId: ID!
+}
+
+"""
+The `DateTime` scalar type represents a DateTime
+value as specified by
+[iso8601](https://en.wikipedia.org/wiki/ISO_8601).
+"""
+scalar DateTime
+
+type ActivityEventConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [ActivityEventEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+The Relay compliant `PageInfo` type, containing data necessary to paginate this connection.
+"""
+type PageInfo {
+  """When paginating forwards, are there more items?"""
+  hasNextPage: Boolean!
+
+  """When paginating backwards, are there more items?"""
+  hasPreviousPage: Boolean!
+
+  """When paginating backwards, the cursor to continue."""
+  startCursor: String
+
+  """When paginating forwards, the cursor to continue."""
+  endCursor: String
+}
+
+"""A Relay edge containing a `ActivityEvent` and its cursor."""
+type ActivityEventEdge {
+  """The item at the end of the edge"""
+  node: ActivityEvent
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type ActivityEvent implements Node {
+  """The ID of the object"""
+  id: ID!
+  body: EventBody!
+  actorIcon: String!
+  createdAt: DateTime!
+}
+
+type EventBody {
+  text: String!
+  ranges: [NodeBodyRange!]!
+}
+
+type NodeBodyRange {
+  entity: Node!
+  offset: Int!
+  length: Int!
+}
+
+type WaitlistMember implements Node {
+  waitlist: Waitlist!
+  joinedAt: DateTime!
+  approvedAt: DateTime
+
+  """The ID of the object"""
+  id: ID!
+  member: Owner!
+  approved: Boolean!
+}
+
+type Waitlist implements Node {
+  name: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+
+  """The ID of the object"""
+  id: ID!
+}
+
+type NamespaceConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Namespace` and its cursor."""
+type NamespaceEdge {
+  """The item at the end of the edge"""
+  node: Namespace
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Namespace implements Node & PackageOwner & Owner {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  displayName: String
+  description: String!
+  avatar: String!
+  avatarUpdatedAt: DateTime
+  twitterHandle: String
+  githubHandle: String
+  websiteUrl: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  maintainerInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  userSet(offset: Int, before: String, after: String, first: Int, last: Int): UserConnection!
+  globalName: String!
+  globalId: ID!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  apps(sortBy: DeployAppsSortBy, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorConnection!
+  publicActivity(before: String, after: String, first: Int, last: Int): ActivityEventConnection!
+  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): NamespaceCollaboratorInviteConnection!
+  viewerHasRole(role: GrapheneRole!): Boolean!
+
+  """Whether the current user is invited to the namespace"""
+  viewerIsInvited: Boolean!
+
+  """The invitation for the current user to the namespace"""
+  viewerInvitation: NamespaceCollaboratorInvite
+  packageTransfersIncoming(offset: Int, before: String, after: String, first: Int, last: Int): PackageTransferRequestConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+}
+
+type NamespaceCollaboratorInviteConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceCollaboratorInviteEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+A Relay edge containing a `NamespaceCollaboratorInvite` and its cursor.
+"""
+type NamespaceCollaboratorInviteEdge {
+  """The item at the end of the edge"""
+  node: NamespaceCollaboratorInvite
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type NamespaceCollaboratorInvite implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  user: User
+  inviteEmail: String
+  namespace: Namespace!
+  role: RegistryNamespaceMaintainerInviteRoleChoices!
+  accepted: NamespaceCollaborator
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+}
+
+enum RegistryNamespaceMaintainerInviteRoleChoices {
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type NamespaceCollaborator implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  role: RegistryNamespaceMaintainerRoleChoices!
+  namespace: Namespace!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  invite: NamespaceCollaboratorInvite
+}
+
+enum RegistryNamespaceMaintainerRoleChoices {
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type UserConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [UserEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `User` and its cursor."""
+type UserEdge {
+  """The item at the end of the edge"""
+  node: User
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Package` and its cursor."""
+type PackageEdge {
+  """The item at the end of the edge"""
+  node: Package
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Package implements Likeable & Node & PackageOwner {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  private: Boolean!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  maintainers: [User]! @deprecated(reason: "Please use collaborators instead")
+  curated: Boolean!
+  ownerObjectId: Int!
+  lastVersion: PackageVersion
+
+  """The app icon. It should be formatted in the same way as Apple icons"""
+  icon: String!
+  totalDownloads: Int!
+  iconUpdatedAt: DateTime
+  watchersCount: Int!
+  webcs(offset: Int, before: String, after: String, first: Int, last: Int): WebcImageConnection!
+  versions: [PackageVersion]!
+  collectionSet: [Collection!]!
+  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
+  keywords(offset: Int, before: String, after: String, first: Int, last: Int): PackageKeywordConnection!
+  likersCount: Int!
+  viewerHasLiked: Boolean!
+  globalName: String!
+  globalId: ID!
+  alias: String
+  namespace: String!
+  displayName: String!
+
+  """The name of the package without the owner"""
+  packageName: String!
+
+  """The app icon. It should be formatted in the same way as Apple icons"""
+  appIcon: String! @deprecated(reason: "Please use icon instead")
+
+  """The total number of downloads of the package"""
+  downloadsCount: Int
+
+  """The public keys for all the published versions"""
+  publicKeys: [PublicKey!]!
+  collaborators(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorConnection!
+  pendingInvites(offset: Int, before: String, after: String, first: Int, last: Int): PackageCollaboratorInviteConnection!
+  viewerHasRole(role: GrapheneRole!): Boolean!
+  owner: PackageOwner!
+  isTransferring: Boolean!
+  activeTransferRequest: PackageTransferRequest
+  isArchived: Boolean!
+  viewerIsWatching: Boolean!
+  showDeployButton: Boolean!
+  similarPackageVersions(before: String, after: String, first: Int, last: Int): PackageSearchConnection!
+
+  """Whether the current user is invited to the package"""
+  viewerIsInvited: Boolean!
+
+  """The invitation for the current user to the package"""
+  viewerInvitation: PackageCollaboratorInvite
+}
+
+interface Likeable {
+  id: ID!
+  likersCount: Int!
+  viewerHasLiked: Boolean!
+}
+
+type PackageVersion implements Node {
+  """The ID of the object"""
+  id: ID!
+  package: Package!
+  version: String!
+  description: String!
+  manifest: String!
+  license: String
+  licenseFile: String
+  readme: String
+  witMd: String
+  repository: String
+  homepage: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  staticObjectsCompiled: Boolean!
+  nativeExecutablesCompiled: Boolean!
+  publishedBy: User!
+  clientName: String
+  signature: Signature
+  isArchived: Boolean!
+  file: String!
+
+  """"""
+  fileSize: BigInt!
+  webc: WebcImage
+  totalDownloads: Int!
+  bindingsState: RegistryPackageVersionBindingsStateChoices!
+  nativeExecutablesState: RegistryPackageVersionNativeExecutablesStateChoices!
+
+  """List of direct dependencies of this package version"""
+  dependencies(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  deployappversionSet(offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  lastversionPackage(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection!
+  commands: [Command!]!
+  nativeexecutableSet(offset: Int, before: String, after: String, first: Int, last: Int): NativeExecutableConnection!
+  bindingsgeneratorSet(offset: Int, before: String, after: String, first: Int, last: Int): BindingsGeneratorConnection!
+  javascriptlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
+  pythonlanguagebindingSet(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
+  piritaFile: String @deprecated(reason: "Please use distribution.piritaDownloadUrl instead.")
+  piritaFileSize: Int @deprecated(reason: "Please use distribution.piritaSize instead.")
+  piritaManifest: JSONString
+  piritaOffsets: JSONString
+  piritaVolumes: JSONString
+  pirita256hash: String @deprecated(reason: "Please use distribution.piritaSha256Hash instead.")
+  distribution: PackageDistribution!
+  filesystem: [PackageVersionFilesystem]!
+  isLastVersion: Boolean!
+  witFile: String
+  isSigned: Boolean!
+  moduleInterfaces: [InterfaceVersion!]!
+  modules: [PackageVersionModule!]!
+  getPiritaContents(volume: String! = "atom", base: String! = ""): [PiritaFilesystemItem!]!
+  getWebcContents(volume: String! = "atom", base: String! = "/"): [WEBCFilesystemItem!]!
+  nativeExecutables(triple: String, wasmerCompilerVersion: String): [NativeExecutable]
+  bindings: [PackageVersionLanguageBinding]!
+  npmBindings: PackageVersionNPMBinding
+  pythonBindings: PackageVersionPythonBinding
+  hasBindings: Boolean!
+  hasCommands: Boolean!
+  showDeployButton: Boolean!
+}
+
+"""
+The `BigInt` scalar type represents non-fractional whole numeric values.
+`BigInt` is not constrained to 32-bit like the `Int` type and thus is a less
+compatible type.
+"""
+scalar BigInt
+
+type WebcImage implements Node {
+  """The ID of the object"""
+  id: ID!
+
+  """"""
+  fileSize: BigInt!
+  manifest: JSONString!
+  volumes: JSONString!
+  offsets: JSONString!
+  webcSha256: String!
+  targzSha256: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  webcUrl: String!
+}
+
+"""
+Allows use of a JSON String for input / output from the GraphQL schema.
+
+Use of this type is *not recommended* as you lose the benefits of having a defined, static
+schema (one of the key benefits of GraphQL).
+"""
+scalar JSONString
+
+enum RegistryPackageVersionBindingsStateChoices {
+  """Bindings are not detected"""
+  NOT_PRESENT
+
+  """Bindings are being built"""
+  GENERATING
+
+  """Bindings generation has failed"""
+  ERROR
+
+  """Bindings are built and present"""
+  GENERATED_AND_PRESENT
+}
+
+enum RegistryPackageVersionNativeExecutablesStateChoices {
+  """Native Executables are not detected"""
+  NOT_PRESENT
+
+  """Native Executables are being built"""
+  GENERATING
+
+  """Native Executables generation has failed"""
+  ERROR
+
+  """Native Executables are built and present"""
+  GENERATED_AND_PRESENT
+}
+
+type PackageVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageVersion` and its cursor."""
+type PackageVersionEdge {
+  """The item at the end of the edge"""
+  node: PackageVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DeployAppVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DeployAppVersion` and its cursor."""
+type DeployAppVersionEdge {
+  """The item at the end of the edge"""
+  node: DeployAppVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppVersion implements Node {
+  """The ID of the object"""
+  id: ID!
+  app: DeployApp!
+  yamlConfig: String!
+  userYamlConfig: String!
+  clientName: String
+  signature: String
+  description: String
+  publishedBy: User!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  configWebc: String @deprecated(reason: "webc support has been deprecated for apps")
+  config: String! @deprecated(reason: "Please use jsonConfig instead")
+  jsonConfig: String!
+  url: String!
+  permalink: String!
+  urls: [String]!
+  version: String!
+  isActive: Boolean!
+  manifest: String!
+  logs(
+    """
+    Get logs starting from this timestamp. Takes EPOCH timestamp in seconds.
+    """
+    startingFrom: Float
+
+    """Get logs starting from this timestamp. Takes ISO timestamp."""
+    startingFromISO: DateTime
+
+    """Fetch logs until this timestamp. Takes EPOCH timestamp in seconds."""
+    until: Float
+    before: String
+    after: String
+    first: Int
+    last: Int
+  ): LogConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  sourcePackageVersion: PackageVersion!
+  aggregateMetrics: AggregateMetrics!
+}
+
+type DeployApp implements Node & Owner {
+  """The ID of the object"""
+  id: ID!
+  createdBy: User!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  activeVersion: DeployAppVersion!
+  globalName: String!
+  globalId: ID!
+  url: String!
+  adminUrl: String!
+  permalink: String!
+  urls: [String]!
+  description: String
+  name: String!
+  owner: Owner!
+  versions(sortBy: DeployAppVersionsSortBy, createdAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  aggregateMetrics: AggregateMetrics!
+  aliases(offset: Int, before: String, after: String, first: Int, last: Int): AppAliasConnection!
+  usageMetrics(forRange: MetricRange!, variant: MetricType!): [UsageMetric]!
+  deleted: Boolean!
+}
+
+enum DeployAppVersionsSortBy {
+  NEWEST
+  OLDEST
+}
+
+type AggregateMetrics {
+  cpuTime: String!
+  memoryTime: String!
+  ingress: String!
+  egress: String!
+  noRequests: String!
+  monthlyCost: String!
+}
+
+type AppAliasConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [AppAliasEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `AppAlias` and its cursor."""
+type AppAliasEdge {
+  """The item at the end of the edge"""
+  node: AppAlias
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type AppAlias implements Node {
+  name: String!
+  app: DeployApp!
+  isDefault: Boolean!
+
+  """The ID of the object"""
+  id: ID!
+  url: String!
+}
+
+type UsageMetric {
+  variant: MetricType!
+  value: Float!
+  unit: MetricUnit!
+  timestamp: DateTime!
+}
+
+enum MetricType {
+  cpu_time
+  memory_time
+  network_egress
+  network_ingress
+  no_of_requests
+  cost
+}
+
+"""Units for metrics"""
+enum MetricUnit {
+  """represents the unit of "seconds"."""
+  SEC
+
+  """represents the unit of "kilobytes"."""
+  KB
+
+  """represents the unit of "kilobytes per second"."""
+  KBS
+
+  """represents the unit of "number of requests"."""
+  NO_REQUESTS
+
+  """represents the unit of "cost" in USD."""
+  DOLLARS
+}
+
+enum MetricRange {
+  LAST_24_HOURS
+  LAST_30_DAYS
+}
+
+type LogConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [LogEdge]!
+}
+
+"""A Relay edge containing a `Log` and its cursor."""
+type LogEdge {
+  """The item at the end of the edge"""
+  node: Log
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Command {
+  command: String!
+  packageVersion: PackageVersion!
+  module: PackageVersionModule!
+}
+
+type PackageVersionModule {
+  name: String!
+  source: String!
+  abi: String
+  publicUrl: String!
+  atom: PiritaFilesystemFile!
+  rangeHeader: String!
+}
+
+type PiritaFilesystemFile {
+  name(display: PiritaFilesystemNameDisplay): String!
+  size: Int!
+  offset: Int!
+}
+
+enum PiritaFilesystemNameDisplay {
+  RELATIVE
+  ABSOLUTE
+}
+
+type NativeExecutableConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NativeExecutableEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `NativeExecutable` and its cursor."""
+type NativeExecutableEdge {
+  """The item at the end of the edge"""
+  node: NativeExecutable
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type NativeExecutable implements Node {
+  """The ID of the object"""
+  id: ID!
+  module: String! @deprecated(reason: "Use filename instead")
+  filename: String!
+  filesize: Int!
+  targetTriple: String!
+  downloadUrl: String!
+}
+
+type BindingsGeneratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BindingsGeneratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `BindingsGenerator` and its cursor."""
+type BindingsGeneratorEdge {
+  """The item at the end of the edge"""
+  node: BindingsGenerator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type BindingsGenerator implements Node {
+  """The ID of the object"""
+  id: ID!
+  packageVersion: PackageVersion!
+  active: Boolean!
+  commandName: String!
+  registryJavascriptlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionNPMBindingConnection!
+  registryPythonlanguagebindings(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionPythonBindingConnection!
+}
+
+type PackageVersionNPMBindingConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionNPMBindingEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageVersionNPMBinding` and its cursor."""
+type PackageVersionNPMBindingEdge {
+  """The item at the end of the edge"""
+  node: PackageVersionNPMBinding
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageVersionNPMBinding implements PackageVersionLanguageBinding & Node {
+  """The ID of the object"""
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  npmDefaultInstallPackageName(url: String): String! @deprecated(reason: "Please use packageName instead")
+}
+
+interface PackageVersionLanguageBinding {
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+}
+
+enum ProgrammingLanguage {
+  PYTHON
+  JAVASCRIPT
+}
+
+type PackageVersionPythonBindingConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageVersionPythonBindingEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""
+A Relay edge containing a `PackageVersionPythonBinding` and its cursor.
+"""
+type PackageVersionPythonBindingEdge {
+  """The item at the end of the edge"""
+  node: PackageVersionPythonBinding
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageVersionPythonBinding implements PackageVersionLanguageBinding & Node {
+  """The ID of the object"""
+  id: ID!
+  language: ProgrammingLanguage!
+
+  """The URL of the generated artifacts on Wasmer CDN."""
+  url: String!
+
+  """When the binding was generated"""
+  createdAt: DateTime!
+
+  """Package version used to generate this binding"""
+  generator: BindingsGenerator!
+  name: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  kind: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+
+  """Name of package source"""
+  packageName: String!
+
+  """Name of the package to import"""
+  importablePackageName: String!
+
+  """Code snippet example to use the package"""
+  codeSnippetExample: String!
+  module: String! @deprecated(reason: "Do not use this field, since bindings for all modules are generated at once now.")
+  pythonDefaultInstallPackageName(url: String): String!
+}
+
+type PackageDistribution {
+  downloadUrl: String!
+  size: Int
+  piritaDownloadUrl: String
+  piritaSize: Int
+  piritaSha256Hash: String
+}
+
+type PackageVersionFilesystem {
+  wasm: String!
+  host: String!
+}
+
+type InterfaceVersion implements Node {
+  """The ID of the object"""
+  id: ID!
+  interface: Interface!
+  version: String!
+  content: String!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  publishedBy: User!
+  packageVersions(offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+}
+
+type Interface implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  displayName: String!
+  description: String!
+  homepage: String
+  icon: String
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  versions(offset: Int, before: String, after: String, first: Int, last: Int): InterfaceVersionConnection!
+  lastVersion: InterfaceVersion
+}
+
+type InterfaceVersionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [InterfaceVersionEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `InterfaceVersion` and its cursor."""
+type InterfaceVersionEdge {
+  """The item at the end of the edge"""
+  node: InterfaceVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union PiritaFilesystemItem = PiritaFilesystemFile | PiritaFilesystemDir
+
+type PiritaFilesystemDir {
+  name(display: PiritaFilesystemNameDisplay): String!
+}
+
+type WEBCFilesystemItem {
+  name: String!
+  checksum: String!
+  size: Int!
+  offset: Int!
+}
+
+type WebcImageConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [WebcImageEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `WebcImage` and its cursor."""
+type WebcImageEdge {
+  """The item at the end of the edge"""
+  node: WebcImage
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Collection {
+  slug: String!
+  displayName: String!
+  description: String!
+  createdAt: DateTime!
+  banner: String!
+  packages(before: String, after: String, first: Int, last: Int): PackageConnection!
+}
+
+type CategoryConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [CategoryEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Category` and its cursor."""
+type CategoryEdge {
+  """The item at the end of the edge"""
+  node: Category
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Category implements Node {
+  """The ID of the object"""
+  id: ID!
+
+  """A category is a label that can be attached to a package."""
+  name: String!
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
+}
+
+type PackageKeywordConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageKeywordEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageKeyword` and its cursor."""
+type PackageKeywordEdge {
+  """The item at the end of the edge"""
+  node: PackageKeyword
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageKeyword implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+}
+
+type PackageCollaboratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageCollaboratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageCollaborator` and its cursor."""
+type PackageCollaboratorEdge {
+  """The item at the end of the edge"""
+  node: PackageCollaborator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageCollaborator implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  role: RegistryPackageMaintainerRoleChoices!
+  package: Package!
+  createdAt: DateTime!
+  updatedAt: DateTime!
+  invite: PackageCollaboratorInvite
+}
+
+enum RegistryPackageMaintainerRoleChoices {
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type PackageCollaboratorInvite implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  user: User
+  inviteEmail: String
+  package: Package!
+  role: RegistryPackageMaintainerInviteRoleChoices!
+  accepted: PackageCollaborator
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+}
+
+enum RegistryPackageMaintainerInviteRoleChoices {
+  """Admin"""
+  ADMIN
+
+  """Editor"""
+  EDITOR
+
+  """Viewer"""
+  VIEWER
+}
+
+type PackageCollaboratorInviteConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageCollaboratorInviteEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageCollaboratorInvite` and its cursor."""
+type PackageCollaboratorInviteEdge {
+  """The item at the end of the edge"""
+  node: PackageCollaboratorInvite
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum GrapheneRole {
+  ADMIN
+  EDITOR
+  VIEWER
+}
+
+type PackageTransferRequest implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  previousOwnerObjectId: Int!
+  newOwnerObjectId: Int!
+  package: Package!
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+  previousOwner: PackageOwner!
+  newOwner: PackageOwner!
+}
+
+type PackageSearchConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageSearchEdge]!
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageSearch` and its cursor."""
+type PackageSearchEdge {
+  """The item at the end of the edge"""
+  node: PackageVersion
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type DeployAppConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [DeployAppEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `DeployApp` and its cursor."""
+type DeployAppEdge {
+  """The item at the end of the edge"""
+  node: DeployApp
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+enum DeployAppsSortBy {
+  NEWEST
+  OLDEST
+  MOST_ACTIVE
+}
+
+type NamespaceCollaboratorConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NamespaceCollaboratorEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `NamespaceCollaborator` and its cursor."""
+type NamespaceCollaboratorEdge {
+  """The item at the end of the edge"""
+  node: NamespaceCollaborator
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type PackageTransferRequestConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [PackageTransferRequestEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `PackageTransferRequest` and its cursor."""
+type PackageTransferRequestEdge {
+  """The item at the end of the edge"""
+  node: PackageTransferRequest
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type APITokenConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [APITokenEdge]!
+}
+
+"""A Relay edge containing a `APIToken` and its cursor."""
+type APITokenEdge {
+  """The item at the end of the edge"""
+  node: APIToken
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type APIToken {
+  id: ID!
+  user: User!
+  identifier: String
+  createdAt: DateTime!
+  revokedAt: DateTime
+  lastUsedAt: DateTime
+  nonceSet(offset: Int, before: String, after: String, first: Int, last: Int): NonceConnection!
+}
+
+type NonceConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [NonceEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Nonce` and its cursor."""
+type NonceEdge {
+  """The item at the end of the edge"""
+  node: Nonce
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type Nonce implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  callbackUrl: String!
+  createdAt: DateTime!
+  isValidated: Boolean!
+  secret: String!
+  token: String!
+  expired: Boolean!
+  authUrl: String!
+}
+
+type UserNotificationConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [UserNotificationEdge]!
+  hasPendingNotifications: Boolean!
+  pendingNotificationsCount: Int!
+}
+
+"""A Relay edge containing a `UserNotification` and its cursor."""
+type UserNotificationEdge {
+  """The item at the end of the edge"""
+  node: UserNotification
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type UserNotification implements Node {
+  """The ID of the object"""
+  id: ID!
+  icon: String
+  body: EventBody!
+  seenState: UserNotificationSeenState!
+  kind: UserNotificationKind
+  createdAt: DateTime!
+}
+
+enum UserNotificationSeenState {
+  UNSEEN
+  SEEN
+  SEEN_AND_READ
+}
+
+union UserNotificationKind = UserNotificationKindPublishedPackageVersion | UserNotificationKindIncomingPackageTransfer | UserNotificationKindIncomingPackageInvite | UserNotificationKindIncomingNamespaceInvite | UserNotificationKindValidateEmail
+
+type UserNotificationKindPublishedPackageVersion {
+  packageVersion: PackageVersion!
+}
+
+type UserNotificationKindIncomingNamespaceInvite {
+  namespaceInvite: NamespaceCollaboratorInvite!
+}
+
+type UserNotificationKindValidateEmail {
+  user: User!
+}
+
+"""
+
+    Enum of ways a user can login. One user can have many login methods
+    associated with their account.
+
+"""
+enum LoginMethod {
+  GOOGLE
+  GITHUB
+  PASSWORD
+}
+
+type Signature {
+  id: ID!
+  publicKey: PublicKey!
+  data: String!
+  createdAt: DateTime!
+}
+
+type UserNotificationKindIncomingPackageTransfer {
+  packageTransferRequest: PackageTransferRequest!
+}
+
+type UserNotificationKindIncomingPackageInvite {
+  packageInvite: PackageCollaboratorInvite!
+}
+
+input DeploymentV1 {
+  name: String!
+  workload: WorkloadV1!
+}
+
+input WorkloadV1 {
+  capability: CapabilityMapV1
+  name: String = null
+  runner: WorkloadRunnerV1!
+}
+
+input AppV1Spec {
+  aliases: [String] = []
+  workload: WorkloadV2!
+}
+
+input WorkloadV2 {
+  source: String!
+}
+
+input CapabilityCpuV1 {
+  maximumThreads: Int
+  maximumUsage: Int
+}
+
+input FileSystemPermissionsV1 {
+  delete: Boolean
+  read: Boolean
+  write: Boolean
+}
+
+input FileSystemVolumeMountV1 {
+  path: String!
+  permissions: [FileSystemPermissionsV1]
+}
+
+input FileSystemVolumeSourceLocalV1 {
+  maximumSize: String!
+}
+
+input FileSystemVolumeSourceV1 {
+  local: FileSystemVolumeSourceLocalV1!
+}
+
+input FileSystemVolumeConfigV1 {
+  mounts: [FileSystemVolumeMountV1]!
+  name: String!
+  source: FileSystemVolumeSourceV1!
+}
+
+input CapabilityFileSystemV1 {
+  volumes: [FileSystemVolumeConfigV1]!
+}
+
+input CapabilityPersistentMemoryV1 {
+  volumes: [String]
+}
+
+input CapabilityMemorySwapV1 {
+  maximumSize: String
+  memoryId: String
+}
+
+input CapabilityNetworkV1 {
+  egress: NetworkEgressV1
+}
+
+input NetworkEgressV1 {
+  enabled: Boolean
+}
+
+input CapabilityNetworkDnsV1 {
+  enabled: Boolean
+  servers: [String]
+  allowedHosts: NetworkDnsAllowedHostsV1
+}
+
+input NetworkDnsAllowedHostsV1 {
+  allowAllHosts: Boolean
+  hosts: [String]
+  regexPatterns: [String]
+  wildcardPatterns: [String]
+}
+
+input CapabilityNetworkGatewayV1 {
+  domains: [String]
+  enforceHttps: Boolean
+}
+
+input CapabilityMapV1 {
+  memorySwap: CapabilityCpuV1
+}
+
+input WebcSourceV1 {
+  name: String!
+  namespace: String!
+  repository: String! = "https://registry.wasmer.wtf"
+  tag: String
+  authToken: String
+}
+
+input WorkloadRunnerV1 {
+  webProxy: RunnerWebProxyV1
+  wcgi: RunnerWCGIV1
+}
+
+"""Run a webassembly file."""
+input RunnerWCGIV1 {
+  source: WorkloadRunnerWasmSourceV1!
+  dialect: String
+}
+
+input RunnerWebProxyV1 {
+  source: WorkloadRunnerWasmSourceV1!
+}
+
+input WorkloadRunnerWasmSourceV1 {
+  webc: WebcSourceV1!
+}
+
+type StripeCustomer {
+  id: ID!
+}
+
+type Billing {
+  stripeCustomer: StripeCustomer!
+  payments: [PaymentIntent]!
+  paymentMethods: [PaymentMethod]!
+}
+
+type PaymentIntent implements Node {
+  """The datetime this object was created in stripe."""
+  created: DateTime
+
+  """Three-letter ISO currency code"""
+  currency: String!
+
+  """
+  Status of this PaymentIntent, one of requires_payment_method, requires_confirmation, requires_action, processing, requires_capture, canceled, or succeeded. You can read more about PaymentIntent statuses here.
+  """
+  status: DjstripePaymentIntentStatusChoices!
+
+  """The ID of the object"""
+  id: ID!
+  amount: String!
+}
+
+enum DjstripePaymentIntentStatusChoices {
+  """
+  Cancellation invalidates the intent for future confirmation and cannot be undone.
+  """
+  CANCELED
+
+  """Required actions have been handled."""
+  PROCESSING
+
+  """Payment Method require additional action, such as 3D secure."""
+  REQUIRES_ACTION
+
+  """Capture the funds on the cards which have been put on holds."""
+  REQUIRES_CAPTURE
+
+  """Intent is ready to be confirmed."""
+  REQUIRES_CONFIRMATION
+
+  """Intent created and requires a Payment Method to be attached."""
+  REQUIRES_PAYMENT_METHOD
+
+  """The funds are in your account."""
+  SUCCEEDED
+}
+
+union PaymentMethod = CardPaymentMethod
+
+type CardPaymentMethod implements Node {
+  """The ID of the object"""
+  id: ID!
+  brand: CardBrand!
+  country: String!
+  expMonth: Int!
+  expYear: Int!
+  funding: CardFunding!
+  last4: String!
+  isDefault: Boolean!
+}
+
+"""
+Card brand.
+
+Can be amex, diners, discover, jcb, mastercard, unionpay, visa, or unknown.
+"""
+enum CardBrand {
+  AMEX
+  DINERS
+  DISCOVER
+  JCB
+  MASTERCARD
+  UNIONPAY
+  VISA
+  UNKNOWN
+}
+
+"""
+Card funding type.
+
+Can be credit, debit, prepaid, or unknown.
+"""
+enum CardFunding {
+  CREDIT
+  DEBIT
+  PREPAID
+  UNKNOWN
+}
+
+type Payment {
+  id: ID
+  amount: String
+  paidOn: DateTime
+}
+
+"""Log entry for deploy app."""
+type Log {
+  """Timestamp in nanoseconds"""
+  timestamp: Float!
+
+  """ISO 8601 string in UTC"""
+  datetime: DateTime!
+
+  """Log message"""
+  message: String!
+}
+
+type Query {
+  latestTOS: TermsOfService!
+  getDeployAppVersion(name: String!, owner: String, version: String): DeployAppVersion
+  getDeployApp(name: String!, owner: String): DeployApp
+  getAppByGlobalAlias(alias: String!): DeployApp
+  getDeployApps(sortBy: DeployAppsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppConnection!
+  getAppVersions(sortBy: DeployAppVersionsSortBy, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): DeployAppVersionConnection!
+  viewer: User
+  getUser(username: String!): User
+  getPasswordResetToken(token: String!): GetPasswordResetToken
+  getAuthNonce(name: String!): Nonce
+  packages(offset: Int, before: String, after: String, first: Int, last: Int): PackageConnection
+  recentPackageVersions(curated: Boolean, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  allPackageVersions(sortBy: PackageVersionSortBy, createdAfter: DateTime, updatedAfter: DateTime, offset: Int, before: String, after: String, first: Int, last: Int): PackageVersionConnection!
+  getWebcImage(hash: String!): WebcImage
+  getNamespace(name: String!): Namespace
+  getPackage(name: String!): Package
+  getPackages(names: [String!]!): [Package]!
+  getPackageVersion(name: String!, version: String = "latest"): PackageVersion
+  getPackageVersions(names: [String!]!): [PackageVersion]
+  getPackageVersionByHash(name: String!, hash: String!): PackageVersion
+  getInterface(name: String!): Interface
+  getInterfaces(names: [String!]!): [Interface]!
+  getInterfaceVersion(name: String!, version: String = "latest"): InterfaceVersion
+  getContract(name: String!): Interface @deprecated(reason: "Please use getInterface instead")
+  getContracts(names: [String!]!): [Interface]! @deprecated(reason: "Please use getInterfaces instead")
+  getContractVersion(name: String!, version: String): InterfaceVersion @deprecated(reason: "Please use getInterfaceVersion instead")
+  getCommand(name: String!): Command
+  getCommands(names: [String!]!): [Command]
+  getCollections(before: String, after: String, first: Int, last: Int): CollectionConnection
+  getSignedUrlForPackageUpload(name: String!, version: String = "latest", expiresAfterSeconds: Int = 60): SignedUrl
+  categories(offset: Int, before: String, after: String, first: Int, last: Int): CategoryConnection!
+  blogposts(tags: [String!], before: String, after: String, first: Int, last: Int): BlogPostConnection!
+  getBlogpost(slug: String, featured: Boolean): BlogPost
+  allBlogpostTags(offset: Int, before: String, after: String, first: Int, last: Int): BlogPostTagConnection
+  search(query: String!, packages: PackagesFilter, namespaces: NamespacesFilter, users: UsersFilter, apps: AppFilter, blogposts: BlogPostsFilter, before: String, after: String, first: Int, last: Int): SearchConnection!
+  searchAutocomplete(kind: [SearchKind!], query: String!, before: String, after: String, first: Int, last: Int): SearchConnection!
+  getGlobalObject(slug: String!): GlobalObject
+  node(
+    """The ID of the object"""
+    id: ID!
+  ): Node
+  nodes(ids: [ID!]!): [Node]
+  info: RegistryInfo
+}
+
+type TermsOfService implements Node {
+  """The ID of the object"""
+  id: ID!
+  content: String!
+  createdAt: DateTime!
+  viewerHasAccepted: Boolean!
+}
+
+type GetPasswordResetToken {
+  valid: Boolean!
+  user: User
+}
+
+enum PackageVersionSortBy {
+  NEWEST
+  OLDEST
+}
+
+type CollectionConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [CollectionEdge]!
+}
+
+"""A Relay edge containing a `Collection` and its cursor."""
+type CollectionEdge {
+  """The item at the end of the edge"""
+  node: Collection
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type SignedUrl {
+  url: String!
+}
+
+type BlogPostConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BlogPostEdge]!
+}
+
+"""A Relay edge containing a `BlogPost` and its cursor."""
+type BlogPostEdge {
+  """The item at the end of the edge"""
+  node: BlogPost
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type BlogPost implements Node {
+  """The ID of the object"""
+  id: ID!
+  live: Boolean!
+
+  """The page title as you'd like it to be seen by the public"""
+  title: String!
+
+  """
+  The name of the page as it will appear in URLs e.g http://domain.com/blog/[my-slug]/
+  """
+  slug: String!
+  owner: User
+  body: String!
+  publishDate: DateTime
+  theme: BlogBlogPostThemeChoices!
+  url: String!
+  coverImageUrl: String
+  opengraphImageUrl: String
+  tagline: String!
+  relatedArticles: [BlogPost!]
+  updatedAt: DateTime!
+  tags: [BlogPostTag!]
+  editUrl: String
+}
+
+enum BlogBlogPostThemeChoices {
+  """Green"""
+  GREEN
+
+  """Purple"""
+  PURPLE
+
+  """Orange"""
+  ORANGE
+
+  """Blue"""
+  BLUE
+}
+
+type BlogPostTag implements Node {
+  """The ID of the object"""
+  id: ID!
+  name: String!
+  slug: String!
+}
+
+type BlogPostTagConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [BlogPostTagEdge]!
+
+  """Total number of items in the connection."""
+  totalCount: Int
+}
+
+"""A Relay edge containing a `BlogPostTag` and its cursor."""
+type BlogPostTagEdge {
+  """The item at the end of the edge"""
+  node: BlogPostTag
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+type SearchConnection {
+  """Pagination data for this connection."""
+  pageInfo: PageInfo!
+
+  """Contains the nodes in this connection."""
+  edges: [SearchEdge]!
+  totalCount: Int
+}
+
+"""A Relay edge containing a `Search` and its cursor."""
+type SearchEdge {
+  """The item at the end of the edge"""
+  node: SearchResult
+
+  """A cursor for use in pagination"""
+  cursor: String!
+}
+
+union SearchResult = PackageVersion | User | Namespace | DeployApp | BlogPost
+
+input PackagesFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter packages by being curated."""
+  curated: Boolean
+
+  """Filter packages by publish date."""
+  publishDate: SearchPublishDate
+
+  """Filter packages by having bindings."""
+  hasBindings: Boolean = false
+
+  """Filter packages by being standalone."""
+  isStandalone: Boolean = false
+
+  """Filter packages by having commands."""
+  hasCommands: Boolean = false
+
+  """Filter packages by interface."""
+  withInterfaces: [String]
+
+  """Filter packages by deployable status."""
+  deployable: Boolean
+
+  """Filter packages by license."""
+  license: String
+
+  """Filter packages created after this date."""
+  createdAfter: DateTime
+
+  """Filter packages created before this date."""
+  createdBefore: DateTime
+
+  """Filter packages with version published after this date."""
+  lastPublishedAfter: DateTime
+
+  """Filter packages with version published before this date."""
+  lastPublishedBefore: DateTime
+
+  """Filter packages by size."""
+  size: CountFilter
+
+  """Filter packages by download count."""
+  downloads: CountFilter
+
+  """Filter packages by like count."""
+  likes: CountFilter
+
+  """Filter packages by owner."""
+  owner: String
+
+  """Filter packages by published by."""
+  publishedBy: String
+
+  """Order packages by field."""
+  orderBy: PackageOrderBy = PUBLISHED_DATE
+}
+
+enum SearchOrderSort {
+  ASC
+  DESC
+}
+
+enum SearchPublishDate {
+  LAST_DAY
+  LAST_WEEK
+  LAST_MONTH
+  LAST_YEAR
+}
+
+input CountFilter {
+  count: Int = 0
+  comparison: CountComparison = GREATER_THAN_OR_EQUAL
+}
+
+enum CountComparison {
+  EQUAL
+  GREATER_THAN
+  LESS_THAN
+  GREATER_THAN_OR_EQUAL
+  LESS_THAN_OR_EQUAL
+}
+
+enum PackageOrderBy {
+  ALPHABETICALLY
+  SIZE
+  TOTAL_DOWNLOADS
+  PUBLISHED_DATE
+  CREATED_DATE
+  TOTAL_LIKES
+}
+
+input NamespacesFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter namespaces by package count."""
+  packageCount: CountFilter
+
+  """Filter namespaces created after this date."""
+  createdAfter: DateTime
+
+  """Filter namespaces created before this date."""
+  createdBefore: DateTime
+
+  """Filter namespaces by user count."""
+  userCount: CountFilter
+
+  """Filter namespaces by collaborator."""
+  collaborator: String
+
+  """Order namespaces by field."""
+  orderBy: NamespaceOrderBy = CREATED_DATE
+}
+
+enum NamespaceOrderBy {
+  PACKAGE_COUNT
+  COLLABORATOR_COUNT
+  APP_COUNT
+  CREATED_DATE
+}
+
+input UsersFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter users by package count."""
+  packageCount: CountFilter
+
+  """Filter users by namespace count."""
+  namespaceCount: CountFilter
+
+  """Filter users joined after this date."""
+  joinedAfter: DateTime
+
+  """Filter users joined before this date."""
+  joinedBefore: DateTime
+
+  """Order users by field."""
+  orderBy: UserOrderBy = CREATED_DATE
+}
+
+enum UserOrderBy {
+  PACKAGE_COUNT
+  APP_COUNT
+  CREATED_DATE
+}
+
+input AppFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter apps by deployed by."""
+  deployedBy: String
+
+  """Filter apps last deployed after this date."""
+  lastDeployedAfter: DateTime
+
+  """Filter apps last deployed before this date."""
+  lastDeployedBefore: DateTime
+
+  """Filter apps by owner."""
+  owner: String
+
+  """Order apps by field."""
+  orderBy: AppOrderBy = CREATED_DATE
+
+  """Filter apps by client name."""
+  clientName: String
+}
+
+enum AppOrderBy {
+  PUBLISHED_DATE
+  CREATED_DATE
+}
+
+input BlogPostsFilter {
+  count: Int = 1000
+  sortBy: SearchOrderSort = ASC
+
+  """Filter blog posts by tag."""
+  tags: [String]
+}
+
+enum SearchKind {
+  PACKAGE
+  NAMESPACE
+  USER
+}
+
+union GlobalObject = User | Namespace
+
+type RegistryInfo {
+  """Base URL for this registry"""
+  baseUrl: String!
+
+  """Base URL for the default frontend"""
+  defaultFrontend: String!
+
+  """URL to the graphql endpoint"""
+  graphqlUrl: String!
+
+  """URL to the graphql endpoint"""
+  createBlogpostUrl: String
+
+  """Public metadata about packages"""
+  packages: PackageInfo!
+
+  """Public metadata about the graphql schema"""
+  schema: SchemaInfo!
+}
+
+type PackageInfo {
+  """Number of package versions published this month"""
+  versionsPublishedThisMonth: Int!
+
+  """Number of new packages published this month"""
+  newPackagesThisMonth: Int!
+
+  """Number of package downloads this month"""
+  packageDownloadsThisMonth: Int!
+}
+
+type SchemaInfo {
+  """Download link for graphql schema"""
+  downloadUrl: String!
+
+  """SHA256 hash of the schema data"""
+  SHA256Hash: String!
+
+  """Timestamp when the schema was last updated"""
+  lastUpdated: DateTime!
+}
+
+type Mutation {
+  """Viewer accepts the latest ToS."""
+  acceptTOS(input: AcceptTOSInput!): AcceptTOSPayload
+  publishDeployApp(input: PublishDeployAppInput!): PublishDeployAppPayload
+  deleteApp(input: DeleteAppInput!): DeleteAppPayload
+
+  """Add current user to the waitlist."""
+  joinWaitlist(input: JoinWaitlistInput!): JoinWaitlistPayload
+
+  """Add stripe payment to the user"""
+  addPayment(input: AddPaymentInput!): AddPaymentPayload
+
+  """
+  Mutation to change the active version of a DeployApp to another DeployAppVersion.
+  """
+  markAppVersionAsActive(input: MarkAppVersionAsActiveInput!): MarkAppVersionAsActivePayload
+
+  """Set a payment method as default for the user."""
+  makePaymentDefault(input: SetDefaultPaymentMethodInput!): SetDefaultPaymentMethodPayload
+
+  """
+  Try to detach a payment method from customer.
+  Fails if trying to detach a default method,
+  or if it's the only payment method.
+  """
+  detachPaymentMethod(input: DetachPaymentMethodInput!): DetachPaymentMethodPayload
+  generateDeployConfigToken(input: GenerateDeployConfigTokenInput!): GenerateDeployConfigTokenPayload
+  renameApp(input: RenameAppInput!): RenameAppPayload
+  renameAppAlias(input: RenameAppAliasInput!): RenameAppAliasPayload
+  requestAppTransfer(input: RequestAppTransferInput!): RequestAppTransferPayload
+  acceptAppTransferRequest(input: AcceptAppTransferRequestInput!): AcceptAppTransferRequestPayload
+  removeAppTransferRequest(input: RemoveAppTransferRequestInput!): RemoveAppTransferRequestPayload
+  tokenAuth(input: ObtainJSONWebTokenInput!): ObtainJSONWebTokenPayload
+  generateDeployToken(input: GenerateDeployTokenInput!): GenerateDeployTokenPayload
+  verifyAccessToken(token: String): Verify
+  refreshAccessToken(refreshToken: String): Refresh
+  revokeAccessToken(refreshToken: String): Revoke
+  registerUser(input: RegisterUserInput!): RegisterUserPayload
+  socialAuth(input: SocialAuthJWTInput!): SocialAuthJWTPayload
+  validateUserEmail(input: ValidateUserEmailInput!): ValidateUserEmailPayload
+  requestPasswordReset(input: RequestPasswordResetInput!): RequestPasswordResetPayload
+  requestValidationEmail(input: RequestValidationEmailInput!): RequestValidationEmailPayload
+  changeUserPassword(input: ChangeUserPasswordInput!): ChangeUserPasswordPayload
+  changeUserUsername(input: ChangeUserUsernameInput!): ChangeUserUsernamePayload
+  changeUserEmail(input: ChangeUserEmailInput!): ChangeUserEmailPayload
+  updateUserInfo(input: UpdateUserInfoInput!): UpdateUserInfoPayload
+  validateUserPassword(input: ValidateUserPasswordInput!): ValidateUserPasswordPayload
+  generateApiToken(input: GenerateAPITokenInput!): GenerateAPITokenPayload
+  revokeApiToken(input: RevokeAPITokenInput!): RevokeAPITokenPayload
+  checkUserExists(input: CheckUserExistsInput!): CheckUserExistsPayload
+  readNotification(input: ReadNotificationInput!): ReadNotificationPayload
+  seePendingNotifications(input: SeePendingNotificationsInput!): SeePendingNotificationsPayload
+  newNonce(input: NewNonceInput!): NewNoncePayload
+  validateNonce(input: ValidateNonceInput!): ValidateNoncePayload
+  publishPublicKey(input: PublishPublicKeyInput!): PublishPublicKeyPayload
+  publishPackage(input: PublishPackageInput!): PublishPackagePayload
+  updatePackage(input: UpdatePackageInput!): UpdatePackagePayload
+  likePackage(input: LikePackageInput!): LikePackagePayload
+  unlikePackage(input: UnlikePackageInput!): UnlikePackagePayload
+  watchPackage(input: WatchPackageInput!): WatchPackagePayload
+  unwatchPackage(input: UnwatchPackageInput!): UnwatchPackagePayload
+  archivePackage(input: ArchivePackageInput!): ArchivePackagePayload
+  changePackageVersionArchivedStatus(input: ChangePackageVersionArchivedStatusInput!): ChangePackageVersionArchivedStatusPayload
+  createNamespace(input: CreateNamespaceInput!): CreateNamespacePayload
+  updateNamespace(input: UpdateNamespaceInput!): UpdateNamespacePayload
+  deleteNamespace(input: DeleteNamespaceInput!): DeleteNamespacePayload
+  inviteNamespaceCollaborator(input: InviteNamespaceCollaboratorInput!): InviteNamespaceCollaboratorPayload
+  acceptNamespaceCollaboratorInvite(input: AcceptNamespaceCollaboratorInviteInput!): AcceptNamespaceCollaboratorInvitePayload
+  removeNamespaceCollaboratorInvite(input: RemoveNamespaceCollaboratorInviteInput!): RemoveNamespaceCollaboratorInvitePayload
+  removeNamespaceCollaborator(input: RemoveNamespaceCollaboratorInput!): RemoveNamespaceCollaboratorPayload
+  updateNamespaceCollaboratorRole(input: UpdateNamespaceCollaboratorRoleInput!): UpdateNamespaceCollaboratorRolePayload
+  updateNamespaceCollaboratorInviteRole(input: UpdateNamespaceCollaboratorInviteRoleInput!): UpdateNamespaceCollaboratorInviteRolePayload
+  invitePackageCollaborator(input: InvitePackageCollaboratorInput!): InvitePackageCollaboratorPayload
+  acceptPackageCollaboratorInvite(input: AcceptPackageCollaboratorInviteInput!): AcceptPackageCollaboratorInvitePayload
+  removePackageCollaboratorInvite(input: RemovePackageCollaboratorInviteInput!): RemovePackageCollaboratorInvitePayload
+  updatePackageCollaboratorRole(input: UpdatePackageCollaboratorRoleInput!): UpdatePackageCollaboratorRolePayload
+  updatePackageCollaboratorInviteRole(input: UpdatePackageCollaboratorInviteRoleInput!): UpdatePackageCollaboratorInviteRolePayload
+  removePackageCollaborator(input: RemovePackageCollaboratorInput!): RemovePackageCollaboratorPayload
+  requestPackageTransfer(input: RequestPackageTransferInput!): RequestPackageTransferPayload
+  acceptPackageTransferRequest(input: AcceptPackageTransferRequestInput!): AcceptPackageTransferRequestPayload
+  removePackageTransferRequest(input: RemovePackageTransferRequestInput!): RemovePackageTransferRequestPayload
+  generateBindingsForAllPackages(input: GenerateBindingsForAllPackagesInput!): GenerateBindingsForAllPackagesPayload
+  makePackagePublic(input: MakePackagePublicInput!): MakePackagePublicPayload
+}
+
+"""Viewer accepts the latest ToS."""
+type AcceptTOSPayload {
+  TOS: TermsOfService!
+  clientMutationId: String
+}
+
+input AcceptTOSInput {
+  clientMutationId: String
+}
+
+type PublishDeployAppPayload {
+  deployAppVersion: DeployAppVersion!
+  clientMutationId: String
+}
+
+input PublishDeployAppInput {
+  """The configuration of the app."""
+  config: Configuration!
+
+  """The name of the app."""
+  name: ID
+
+  """The owner of the app."""
+  owner: ID
+
+  """The description of the app."""
+  description: String
+
+  """If true, the new version will be set as the default version."""
+  makeDefault: Boolean = true
+
+  """
+  If true, Publishing will fail if the source package does not have a valid webc.
+  """
+  strict: Boolean = false
+  clientMutationId: String
+}
+
+input Configuration {
+  deployment: AppV0
+  yamlConfig: String
+}
+
+input AppV0 {
+  kind: String = "wasmer.io/App.v0"
+  appId: ID
+  name: String!
+  description: String
+  package: String!
+}
+
+type DeleteAppPayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteAppInput {
+  """App ID to delete."""
+  id: ID!
+  clientMutationId: String
+}
+
+"""Add current user to the waitlist."""
+type JoinWaitlistPayload {
+  waitlistMember: WaitlistMember!
+  clientMutationId: String
+}
+
+input JoinWaitlistInput {
+  name: String!
+  clientMutationId: String
+}
+
+"""Add stripe payment to the user"""
+type AddPaymentPayload {
+  customerSecret: String!
+  clientMutationId: String
+}
+
+input AddPaymentInput {
+  clientMutationId: String
+}
+
+"""
+Mutation to change the active version of a DeployApp to another DeployAppVersion.
+"""
+type MarkAppVersionAsActivePayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input MarkAppVersionAsActiveInput {
+  """The ID of the DeployAppVersion to set as the new active version."""
+  appVersion: ID!
+  clientMutationId: String
+}
+
+"""Set a payment method as default for the user."""
+type SetDefaultPaymentMethodPayload {
+  success: Boolean!
+  billing: Billing!
+  clientMutationId: String
+}
+
+input SetDefaultPaymentMethodInput {
+  paymentMethod: ID!
+  clientMutationId: String
+}
+
+"""
+Try to detach a payment method from customer.
+Fails if trying to detach a default method,
+or if it's the only payment method.
+"""
+type DetachPaymentMethodPayload {
+  success: Boolean!
+  billing: Billing!
+  clientMutationId: String
+}
+
+input DetachPaymentMethodInput {
+  paymentMethod: ID!
+  clientMutationId: String
+}
+
+type GenerateDeployConfigTokenPayload {
+  token: String!
+  config: String!
+  clientMutationId: String
+}
+
+input GenerateDeployConfigTokenInput {
+  config: String!
+  clientMutationId: String
+}
+
+type RenameAppPayload {
+  success: Boolean!
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input RenameAppInput {
+  """App ID to delete."""
+  id: ID!
+
+  """New name for the app."""
+  name: String!
+  clientMutationId: String
+}
+
+type RenameAppAliasPayload {
+  success: Boolean!
+  alias: AppAlias!
+  clientMutationId: String
+}
+
+input RenameAppAliasInput {
+  """App alias ID to delete."""
+  id: ID!
+
+  """New name for the alias."""
+  name: String!
+  clientMutationId: String
+}
+
+type RequestAppTransferPayload {
+  appTransferRequest: AppTransferRequest!
+  clientMutationId: String
+}
+
+type AppTransferRequest implements Node {
+  """The ID of the object"""
+  id: ID!
+  requestedBy: User!
+  previousOwnerObjectId: Int!
+  newOwnerObjectId: Int!
+  app: DeployApp!
+  approvedBy: User
+  declinedBy: User
+  createdAt: DateTime!
+  expiresAt: DateTime!
+  closedAt: DateTime
+  previousOwner: Owner!
+  newOwner: Owner!
+}
+
+input RequestAppTransferInput {
+  appId: ID!
+  newOwnerId: ID!
+  clientMutationId: String
+}
+
+type AcceptAppTransferRequestPayload {
+  app: DeployApp!
+  appTransferRequest: AppTransferRequest!
+  clientMutationId: String
+}
+
+input AcceptAppTransferRequestInput {
+  appTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type RemoveAppTransferRequestPayload {
+  app: DeployApp!
+  clientMutationId: String
+}
+
+input RemoveAppTransferRequestInput {
+  appTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type ObtainJSONWebTokenPayload {
+  payload: GenericScalar!
+  refreshExpiresIn: Int!
+  username: CaseInsensitiveString!
+  clientMutationId: String
+  token: String!
+  refreshToken: String!
+}
+
+"""
+The `GenericScalar` scalar type represents a generic
+GraphQL scalar value that could be:
+String, Boolean, Int, Float, List or Object.
+"""
+scalar GenericScalar
+
+"""
+The `CaseInsensitiveString` scalar type represents textual data, represented as UTF-8
+character sequences. The String type is most often used by GraphQL to
+represent free-form human-readable text.
+"""
+scalar CaseInsensitiveString
+
+input ObtainJSONWebTokenInput {
+  clientMutationId: String
+  username: String!
+  password: String!
+}
+
+type GenerateDeployTokenPayload {
+  token: String!
+  deployConfigVersion: DeployAppVersion!
+  clientMutationId: String
+}
+
+input GenerateDeployTokenInput {
+  deployConfigVersionId: String!
+  clientMutationId: String
+}
+
+type Verify {
+  payload: GenericScalar!
+}
+
+type Refresh {
+  payload: GenericScalar!
+  refreshExpiresIn: Int!
+  token: String!
+  refreshToken: String!
+}
+
+type Revoke {
+  revoked: Int!
+}
+
+type RegisterUserPayload {
+  token: String
+  clientMutationId: String
+}
+
+input RegisterUserInput {
+  fullName: String!
+  email: String!
+  username: CaseInsensitiveString!
+  password: String!
+  clientMutationId: String
+}
+
+type SocialAuthJWTPayload {
+  social: SocialAuth
+  token: String
+  clientMutationId: String
+}
+
+type SocialAuth implements Node {
+  """The ID of the object"""
+  id: ID!
+  user: User!
+  provider: String!
+  uid: String!
+  extraData: String!
+  created: DateTime!
+  modified: DateTime!
+}
+
+input SocialAuthJWTInput {
+  provider: String!
+  accessToken: String!
+  register: Boolean = false
+  clientMutationId: String
+}
+
+type ValidateUserEmailPayload {
+  user: User
+  clientMutationId: String
+}
+
+input ValidateUserEmailInput {
+  """The user id"""
+  userId: ID
+  challenge: String!
+  clientMutationId: String
+}
+
+type RequestPasswordResetPayload {
+  email: String!
+  errors: [ErrorType]
+  clientMutationId: String
+}
+
+type ErrorType {
+  field: String!
+  messages: [String!]!
+}
+
+input RequestPasswordResetInput {
+  email: String!
+  clientMutationId: String
+}
+
+type RequestValidationEmailPayload {
+  user: User
+  success: Boolean!
+  clientMutationId: String
+}
+
+input RequestValidationEmailInput {
+  """The user id"""
+  userId: ID
+  clientMutationId: String
+}
+
+type ChangeUserPasswordPayload {
+  token: String
+  clientMutationId: String
+}
+
+input ChangeUserPasswordInput {
+  """
+  The token associated to change the password. If not existing it will use the request user by default
+  """
+  token: String
+  oldPassword: String
+  password: String!
+  clientMutationId: String
+}
+
+type ChangeUserUsernamePayload {
+  user: User
+  token: String
+  clientMutationId: String
+}
+
+input ChangeUserUsernameInput {
+  """The new user username"""
+  username: CaseInsensitiveString!
+  clientMutationId: String
+}
+
+type ChangeUserEmailPayload {
+  user: User!
+  clientMutationId: String
+}
+
+input ChangeUserEmailInput {
+  newEmail: String!
+  clientMutationId: String
+}
+
+type UpdateUserInfoPayload {
+  user: User
+  clientMutationId: String
+}
+
+input UpdateUserInfoInput {
+  """The user id"""
+  userId: ID
+
+  """The user full name"""
+  fullName: String
+
+  """The user bio"""
+  bio: String
+
+  """The user avatar"""
+  avatar: String
+
+  """
+  The user Twitter (it can be the url, or the handle with or without the @)
+  """
+  twitter: String
+
+  """
+  The user Github (it can be the url, or the handle with or without the @)
+  """
+  github: String
+
+  """The user website (it must be a valid url)"""
+  websiteUrl: String
+
+  """The user location"""
+  location: String
+  clientMutationId: String
+}
+
+type ValidateUserPasswordPayload {
+  success: Boolean
+  clientMutationId: String
+}
+
+input ValidateUserPasswordInput {
+  password: String!
+  clientMutationId: String
+}
+
+type GenerateAPITokenPayload {
+  token: APIToken
+  tokenRaw: String
+  user: User
+  clientMutationId: String
+}
+
+input GenerateAPITokenInput {
+  identifier: String
+  clientMutationId: String
+}
+
+type RevokeAPITokenPayload {
+  token: APIToken
+  success: Boolean
+  clientMutationId: String
+}
+
+input RevokeAPITokenInput {
+  """The API token ID"""
+  tokenId: ID!
+  clientMutationId: String
+}
+
+type CheckUserExistsPayload {
+  exists: Boolean!
+
+  """The user is only returned if the user input was the username"""
+  user: User
+  clientMutationId: String
+}
+
+input CheckUserExistsInput {
+  """The user"""
+  user: String!
+  clientMutationId: String
+}
+
+type ReadNotificationPayload {
+  notification: UserNotification
+  clientMutationId: String
+}
+
+input ReadNotificationInput {
+  notificationId: ID!
+  clientMutationId: String
+}
+
+type SeePendingNotificationsPayload {
+  success: Boolean
+  clientMutationId: String
+}
+
+input SeePendingNotificationsInput {
+  clientMutationId: String
+}
+
+type NewNoncePayload {
+  nonce: Nonce!
+  clientMutationId: String
+}
+
+input NewNonceInput {
+  name: String!
+  callbackUrl: String!
+  clientMutationId: String
+}
+
+type ValidateNoncePayload {
+  nonce: Nonce!
+  clientMutationId: String
+}
+
+input ValidateNonceInput {
+  id: ID!
+  secret: String!
+  clientMutationId: String
+}
+
+type PublishPublicKeyPayload {
+  success: Boolean!
+  publicKey: PublicKey!
+  clientMutationId: String
+}
+
+input PublishPublicKeyInput {
+  keyId: String!
+  key: String!
+  verifyingSignatureId: String
+  clientMutationId: String
+}
+
+type PublishPackagePayload {
+  success: Boolean!
+  packageVersion: PackageVersion!
+  clientMutationId: String
+}
+
+input PublishPackageInput {
+  name: String!
+  version: String!
+  description: String!
+  manifest: String!
+  license: String
+  licenseFile: String
+  readme: String
+  repository: String
+  homepage: String
+  file: String
+  signedUrl: String
+  signature: InputSignature
+
+  """The package icon"""
+  icon: String
+
+  """Whether the package is private"""
+  private: Boolean = false
+
+  """The upload format of the package"""
+  uploadFormat: UploadFormat = targz
+
+  """Whether to wait for webc generation to finish"""
+  wait: Boolean = false
+  clientMutationId: String
+}
+
+input InputSignature {
+  publicKeyKeyId: String!
+  data: String!
+}
+
+enum UploadFormat {
+  targz
+  webcv2
+}
+
+type UpdatePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UpdatePackageInput {
+  packageId: ID!
+
+  """The package icon"""
+  icon: String
+  clientMutationId: String
+}
+
+type LikePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input LikePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type UnlikePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UnlikePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type WatchPackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input WatchPackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type UnwatchPackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input UnwatchPackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type ArchivePackagePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input ArchivePackageInput {
+  packageId: ID!
+  clientMutationId: String
+}
+
+type ChangePackageVersionArchivedStatusPayload {
+  packageVersion: PackageVersion!
+  clientMutationId: String
+}
+
+input ChangePackageVersionArchivedStatusInput {
+  packageVersionId: ID!
+  isArchived: Boolean
+  clientMutationId: String
+}
+
+type CreateNamespacePayload {
+  namespace: Namespace!
+  user: User!
+  clientMutationId: String
+}
+
+input CreateNamespaceInput {
+  name: String!
+
+  """The namespace display name"""
+  displayName: String
+
+  """The namespace description"""
+  description: String
+
+  """The namespace avatar"""
+  avatar: String
+  clientMutationId: String
+}
+
+type UpdateNamespacePayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input UpdateNamespaceInput {
+  namespaceId: ID!
+
+  """The namespace slug name"""
+  name: String
+
+  """The namespace display name"""
+  displayName: String
+
+  """The namespace description"""
+  description: String
+
+  """The namespace avatar"""
+  avatar: String
+
+  """
+  The user Twitter (it can be the url, or the handle with or without the @)
+  """
+  twitter: String
+
+  """
+  The user Github (it can be the url, or the handle with or without the @)
+  """
+  github: String
+
+  """The user website (it must be a valid url)"""
+  websiteUrl: String
+  clientMutationId: String
+}
+
+type DeleteNamespacePayload {
+  success: Boolean!
+  clientMutationId: String
+}
+
+input DeleteNamespaceInput {
+  namespaceId: ID!
+  clientMutationId: String
+}
+
+type InviteNamespaceCollaboratorPayload {
+  invite: NamespaceCollaboratorInvite!
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input InviteNamespaceCollaboratorInput {
+  namespaceId: ID!
+  role: GrapheneRole!
+  username: String
+  email: String
+  clientMutationId: String
+}
+
+type AcceptNamespaceCollaboratorInvitePayload {
+  namespaceCollaboratorInvite: NamespaceCollaboratorInvite!
+  clientMutationId: String
+}
+
+input AcceptNamespaceCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemoveNamespaceCollaboratorInvitePayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input RemoveNamespaceCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemoveNamespaceCollaboratorPayload {
+  namespace: Namespace!
+  clientMutationId: String
+}
+
+input RemoveNamespaceCollaboratorInput {
+  namespaceCollaboratorId: ID!
+  clientMutationId: String
+}
+
+type UpdateNamespaceCollaboratorRolePayload {
+  collaborator: NamespaceCollaborator!
+  clientMutationId: String
+}
+
+input UpdateNamespaceCollaboratorRoleInput {
+  namespaceCollaboratorId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type UpdateNamespaceCollaboratorInviteRolePayload {
+  collaboratorInvite: NamespaceCollaboratorInvite!
+  clientMutationId: String
+}
+
+input UpdateNamespaceCollaboratorInviteRoleInput {
+  namespaceCollaboratorInviteId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type InvitePackageCollaboratorPayload {
+  invite: PackageCollaboratorInvite!
+  package: Package!
+  clientMutationId: String
+}
+
+input InvitePackageCollaboratorInput {
+  packageName: String!
+  role: GrapheneRole!
+  username: String
+  email: String
+  clientMutationId: String
+}
+
+type AcceptPackageCollaboratorInvitePayload {
+  packageCollaboratorInvite: PackageCollaboratorInvite!
+  clientMutationId: String
+}
+
+input AcceptPackageCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type RemovePackageCollaboratorInvitePayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageCollaboratorInviteInput {
+  inviteId: ID!
+  clientMutationId: String
+}
+
+type UpdatePackageCollaboratorRolePayload {
+  collaborator: PackageCollaborator!
+  clientMutationId: String
+}
+
+input UpdatePackageCollaboratorRoleInput {
+  packageCollaboratorId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type UpdatePackageCollaboratorInviteRolePayload {
+  collaboratorInvite: PackageCollaboratorInvite!
+  clientMutationId: String
+}
+
+input UpdatePackageCollaboratorInviteRoleInput {
+  packageCollaboratorInviteId: ID!
+  role: GrapheneRole!
+  clientMutationId: String
+}
+
+type RemovePackageCollaboratorPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageCollaboratorInput {
+  packageCollaboratorId: ID!
+  clientMutationId: String
+}
+
+type RequestPackageTransferPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RequestPackageTransferInput {
+  packageId: ID!
+  newOwnerId: ID!
+  clientMutationId: String
+}
+
+type AcceptPackageTransferRequestPayload {
+  package: Package!
+  packageTransferRequest: PackageTransferRequest!
+  clientMutationId: String
+}
+
+input AcceptPackageTransferRequestInput {
+  packageTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type RemovePackageTransferRequestPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input RemovePackageTransferRequestInput {
+  packageTransferRequestId: ID!
+  clientMutationId: String
+}
+
+type GenerateBindingsForAllPackagesPayload {
+  message: String!
+  clientMutationId: String
+}
+
+input GenerateBindingsForAllPackagesInput {
+  bindingsGeneratorId: ID
+  bindingsGeneratorCommand: String
+  clientMutationId: String
+}
+
+type MakePackagePublicPayload {
+  package: Package!
+  clientMutationId: String
+}
+
+input MakePackagePublicInput {
+  """The ID of the package to make public"""
+  id: ID!
+  clientMutationId: String
+}
+
+type Subscription {
+  packageVersionCreated(publishedBy: ID, ownerId: ID): PackageVersion!
+
+  """Subscribe to package version ready"""
+  packageVersionReady(packageVersionId: ID!): PackageVersionReadyResponse!
+
+  """Subscribe to new messages"""
+  newMessage: String!
+  userNotificationCreated(userId: ID!): UserNotificationCreated!
+}
+
+type PackageVersionReadyResponse {
+  state: PackageVersionState!
+  packageVersion: PackageVersion!
+  success: Boolean!
+}
+
+enum PackageVersionState {
+  WEBC_GENERATED
+  BINDINGS_GENERATED
+  NATIVE_EXES_GENERATED
+}
+
+type UserNotificationCreated {
+  notification: UserNotification
+  notificationDeletedId: ID
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/subscriptions/packageVersionReady.graphql b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/subscriptions/packageVersionReady.graphql
new file mode 100644
index 0000000..f7324e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/graphql/subscriptions/packageVersionReady.graphql
@@ -0,0 +1,6 @@
+subscription PackageVersionReady ($packageVersionId: ID!) {
+  packageVersionReady(packageVersionId: $packageVersionId) {
+    state
+    success
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/api.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/api.rs
new file mode 100644
index 0000000..5c107ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/api.rs
@@ -0,0 +1,77 @@
+use anyhow::Context;
+
+use crate::RegistryClient;
+
+use crate::graphql::mutations::{self};
+use crate::types::{NewNonceOutput, PublishDeployAppOutput, PublishDeployAppRawVars};
+
+/// Generate a Deploy token for for the given Deploy app version id.
+pub async fn generate_deploy_token(
+    client: &RegistryClient,
+    app_version_id: String,
+) -> Result<String, anyhow::Error> {
+    let vars = mutations::generate_deploy_token::Variables { app_version_id };
+    let res = client
+        .execute::<mutations::GenerateDeployToken>(vars)
+        .await?;
+    let token = res
+        .generate_deploy_token
+        .context("Query did not return a token")?
+        .token;
+
+    Ok(token)
+}
+
+/// Publish a Deploy app.
+///
+/// Takes a raw, unvalidated deployment config.
+// TODO: Add a variant of this query that takes a typed DeployV1 config.
+pub async fn publish_deploy_app_raw(
+    client: &RegistryClient,
+    data: PublishDeployAppRawVars,
+) -> Result<PublishDeployAppOutput, anyhow::Error> {
+    let vars2 = mutations::publish_deploy_app::Variables {
+        name: data.name,
+        owner: data.namespace,
+        config: serde_json::to_string(&data.config)?,
+    };
+
+    let version = client
+        .execute::<mutations::PublishDeployApp>(vars2)
+        .await?
+        .publish_deploy_app
+        .context("Query did not return data")?
+        .deploy_app_version;
+
+    let app = version.app;
+    // let app = version.app.context("Query did not return expected data")?;
+
+    Ok(PublishDeployAppOutput {
+        app_id: app.id,
+        app_name: app.name,
+        version_id: version.id,
+        version_name: version.version,
+        owner_name: app.owner.global_name,
+    })
+}
+
+/// Generate a new Nonce
+///
+/// Takes a name and a callbackUrl and returns a nonce
+pub async fn create_nonce(
+    client: &RegistryClient,
+    name: String,
+    callback_url: String,
+) -> Result<NewNonceOutput, anyhow::Error> {
+    let vars = mutations::new_nonce::Variables { name, callback_url };
+    let nonce = client
+        .execute::<mutations::NewNonce>(vars)
+        .await?
+        .new_nonce
+        .context("Query did not return a nonce")?
+        .nonce;
+
+    Ok(NewNonceOutput {
+        auth_url: nonce.auth_url,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/client.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/client.rs
new file mode 100644
index 0000000..3ae909b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/client.rs
@@ -0,0 +1,100 @@
+use anyhow::Context;
+use graphql_client::GraphQLQuery;
+use url::Url;
+
+/// API client for the Wasmer registry.
+#[derive(Clone)]
+pub struct RegistryClient {
+    client: reqwest::Client,
+    endpoint: Url,
+    token: Option<String>,
+}
+
+impl RegistryClient {
+    /// Construct a new registry.
+    pub fn new(endpoint: Url, token: Option<String>, user_agent: Option<String>) -> Self {
+        let user_agent = user_agent.unwrap_or_else(Self::default_user_agent);
+        let client = reqwest::Client::builder()
+            .user_agent(user_agent)
+            .build()
+            .unwrap();
+        Self {
+            client,
+            endpoint,
+            token,
+        }
+    }
+
+    /// Construct a client from a [`crate::config::RegistryLogin`].
+    pub fn from_registry(registry: crate::config::RegistryLogin) -> Result<Self, anyhow::Error> {
+        let endpoint = registry.registry.parse().context("Invalid registry URL")?;
+        let client = Self::new(endpoint, Some(registry.token), None);
+        Ok(client)
+    }
+
+    pub(crate) fn default_user_agent() -> String {
+        format!(
+            "wasmer/{} {} {}",
+            env!("CARGO_PKG_VERSION"),
+            whoami::platform(),
+            crate::graphql::whoami_distro(),
+        )
+    }
+
+    /// Set the GraphQL API endpoint.
+    pub fn with_endpoint(self, endpoint: Url) -> Self {
+        Self { endpoint, ..self }
+    }
+
+    /// Set the authentication token.
+    pub fn with_token(self, token: String) -> Self {
+        Self {
+            token: Some(token),
+            ..self
+        }
+    }
+
+    /// Execute a GraphQL query.
+    pub(crate) async fn execute_unchecked<Q: GraphQLQuery>(
+        &self,
+        vars: Q::Variables,
+    ) -> Result<graphql_client::Response<Q::ResponseData>, reqwest::Error> {
+        let body = Q::build_query(vars);
+
+        let req = self.client.post(self.endpoint.as_str());
+
+        let req = if let Some(token) = &self.token {
+            req.bearer_auth(token)
+        } else {
+            req
+        };
+        req.json(&body)
+            .send()
+            .await?
+            .error_for_status()?
+            .json::<graphql_client::Response<Q::ResponseData>>()
+            .await
+    }
+
+    /// Execute a GraphQL query, and convert a response with errors to a Rust error.
+    pub(crate) async fn execute<Q: GraphQLQuery>(
+        &self,
+        vars: Q::Variables,
+    ) -> Result<Q::ResponseData, anyhow::Error> {
+        let res = self.execute_unchecked::<Q>(vars).await?;
+
+        match (res.data, res.errors) {
+            (_, Some(errors)) => {
+                // TODO: Better error forwaring with a custom error type.
+                let errors = errors
+                    .iter()
+                    .map(|x| x.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                anyhow::bail!("GraphQL error: {errors}");
+            }
+            (Some(data), None) => Ok(data),
+            (None, None) => anyhow::bail!("GraphQL response contained no data"),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/config.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/config.rs
new file mode 100644
index 0000000..4eb49b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/config.rs
@@ -0,0 +1,323 @@
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use url::Url;
+
+pub static GLOBAL_CONFIG_DATABASE_FILE_NAME: &str = "wasmer.sqlite";
+
+#[derive(Deserialize, Default, Serialize, Debug, PartialEq, Eq)]
+pub struct WasmerConfig {
+    /// Whether or not telemetry is enabled.
+    #[serde(default)]
+    pub telemetry_enabled: bool,
+
+    /// Whether or not updated notifications are enabled.
+    #[serde(default)]
+    pub update_notifications_enabled: bool,
+
+    /// The registry that wasmer will connect to.
+    pub registry: MultiRegistry,
+
+    /// The proxy to use when connecting to the Internet.
+    #[serde(default)]
+    pub proxy: Proxy,
+}
+
+pub const fn wax_default_cooldown() -> i32 {
+    5 * 60
+}
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Default)]
+pub struct Proxy {
+    pub url: Option<String>,
+}
+
+/// Struct to store login tokens for multiple registry URLs
+/// inside of the wasmer.toml configuration file
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
+pub struct MultiRegistry {
+    /// Currently active registry
+    pub active_registry: String,
+    /// Map from "RegistryUrl" to "LoginToken", in order to
+    /// be able to be able to easily switch between registries
+    pub tokens: Vec<RegistryLogin>,
+}
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
+pub struct RegistryLogin {
+    /// Registry URL to login to
+    pub registry: String,
+    /// Login token for the registry
+    pub token: String,
+}
+
+impl Default for MultiRegistry {
+    fn default() -> Self {
+        MultiRegistry {
+            active_registry: format_graphql("wasmer.io"),
+            tokens: Vec::new(),
+        }
+    }
+}
+
+#[derive(Deserialize, Serialize, Debug, PartialEq, Eq, Clone)]
+pub struct Registry {
+    pub url: String,
+    pub token: Option<String>,
+}
+
+pub fn format_graphql(registry: &str) -> String {
+    if let Ok(mut url) = Url::parse(registry) {
+        // Looks like we've got a valid URL. Let's try to use it as-is.
+        if url.has_host() {
+            if url.path() == "/" {
+                // make sure we convert http://registry.wasmer.io/ to
+                // http://registry.wasmer.io/graphql
+                url.set_path("/graphql");
+            }
+
+            return url.to_string();
+        }
+    }
+
+    if !registry.contains("://") && !registry.contains('/') {
+        return endpoint_from_domain_name(registry);
+    }
+
+    // looks like we've received something we can't deal with. Just pass it
+    // through as-is and hopefully it'll either work or the end user can figure
+    // it out
+    registry.to_string()
+}
+
+/// By convention, something like `"wasmer.io"` should be converted to
+/// `"https://registry.wasmer.io/graphql"`.
+fn endpoint_from_domain_name(domain_name: &str) -> String {
+    if domain_name.contains("localhost") {
+        return format!("http://{domain_name}/graphql");
+    }
+
+    format!("https://registry.{domain_name}/graphql")
+}
+
+fn test_if_registry_present(registry: &str) -> Result<(), String> {
+    crate::utils::get_username_registry_token(registry, "")
+        .map(|_| ())
+        .map_err(|e| format!("{e}"))
+}
+
+#[derive(PartialEq, Eq, Copy, Clone)]
+pub enum UpdateRegistry {
+    Update,
+    LeaveAsIs,
+}
+
+impl MultiRegistry {
+    /// Gets the current (active) registry URL
+    pub fn clear_current_registry_token(&mut self) {
+        let MultiRegistry {
+            active_registry,
+            tokens,
+        } = self;
+        tokens.retain(|i| i.registry != *active_registry);
+        tokens.retain(|i| i.registry != format_graphql(active_registry));
+    }
+
+    pub fn get_graphql_url(&self) -> String {
+        let registry = self.get_current_registry();
+        format_graphql(&registry)
+    }
+
+    /// Gets the current (active) registry URL
+    pub fn get_current_registry(&self) -> String {
+        format_graphql(&self.active_registry)
+    }
+
+    pub fn current_login(&self) -> Option<&RegistryLogin> {
+        self.tokens
+            .iter()
+            .find(|login| login.registry == self.active_registry)
+    }
+
+    /// Sets the current (active) registry URL
+    pub fn set_current_registry(&mut self, registry: &str) {
+        let registry = format_graphql(registry);
+        if let Err(e) = test_if_registry_present(&registry) {
+            println!("Error when trying to ping registry {registry:?}: {e}");
+            println!("WARNING: Registry {registry:?} will be used, but commands may not succeed.");
+        }
+        self.active_registry = registry;
+    }
+
+    /// Returns the login token for the registry
+    pub fn get_login_token_for_registry(&self, registry: &str) -> Option<String> {
+        let registry_formatted = format_graphql(registry);
+        self.tokens
+            .iter()
+            .filter(|login| login.registry == registry || login.registry == registry_formatted)
+            .last()
+            .map(|login| login.token.clone())
+    }
+
+    /// Sets the login token for the registry URL
+    pub fn set_login_token_for_registry(
+        &mut self,
+        registry: &str,
+        token: &str,
+        update_current_registry: UpdateRegistry,
+    ) {
+        let registry_formatted = format_graphql(registry);
+        self.tokens
+            .retain(|login| !(login.registry == registry || login.registry == registry_formatted));
+        self.tokens.push(RegistryLogin {
+            registry: format_graphql(registry),
+            token: token.to_string(),
+        });
+        if update_current_registry == UpdateRegistry::Update {
+            self.active_registry = format_graphql(registry);
+        }
+    }
+}
+
+impl WasmerConfig {
+    pub(crate) const ENV_VAR_WASMER_REGISTRY_TOKEN: &'static str = "WASMER_TOKEN";
+    pub(crate) const ENV_VAR_WASMER_REGISTRY_TOKEN_LEGACY: &'static str = "WAPM_REGISTRY_TOKEN";
+
+    /// Save the config to a file
+    pub fn save<P: AsRef<Path>>(&self, to: P) -> anyhow::Result<()> {
+        use std::{fs::File, io::Write};
+        let config_serialized = toml::to_string(&self)?;
+        let mut file = File::create(to)?;
+        file.write_all(config_serialized.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn from_file(wasmer_dir: &Path) -> Result<Self, String> {
+        let path = Self::get_file_location(wasmer_dir);
+        match std::fs::read_to_string(path) {
+            Ok(config_toml) => Ok(toml::from_str(&config_toml).unwrap_or_else(|_| Self::default())),
+            Err(_e) => Ok(Self::default()),
+        }
+    }
+
+    /// Creates and returns the `WASMER_DIR` directory (or $HOME/.wasmer as a fallback)
+    pub fn get_wasmer_dir() -> Result<PathBuf, String> {
+        Ok(
+            if let Some(folder_str) = std::env::var("WASMER_DIR").ok().filter(|s| !s.is_empty()) {
+                let folder = PathBuf::from(folder_str);
+                std::fs::create_dir_all(folder.clone())
+                    .map_err(|e| format!("cannot create config directory: {e}"))?;
+                folder
+            } else {
+                #[allow(unused_variables)]
+                let default_dir = Self::get_current_dir()
+                    .ok()
+                    .unwrap_or_else(|| PathBuf::from("/".to_string()));
+                let home_dir =
+                    dirs::home_dir().ok_or_else(|| "cannot find home directory".to_string())?;
+                let mut folder = home_dir;
+                folder.push(".wasmer");
+                std::fs::create_dir_all(folder.clone())
+                    .map_err(|e| format!("cannot create config directory: {e}"))?;
+                folder
+            },
+        )
+    }
+
+    /// Load the config based on environment variables and default config file locations.
+    pub fn from_env() -> Result<Self, anyhow::Error> {
+        let dir = Self::get_wasmer_dir()
+            .map_err(|err| anyhow::anyhow!("Could not determine wasmer dir: {err}"))?;
+        let file_path = Self::get_file_location(&dir);
+        Self::from_file(&file_path).map_err(|err| {
+            anyhow::anyhow!(
+                "Could not load config file at '{}': {}",
+                file_path.display(),
+                err
+            )
+        })
+    }
+
+    pub fn get_current_dir() -> std::io::Result<PathBuf> {
+        std::env::current_dir()
+    }
+
+    pub fn get_file_location(wasmer_dir: &Path) -> PathBuf {
+        wasmer_dir.join(crate::GLOBAL_CONFIG_FILE_NAME)
+    }
+
+    pub fn get_database_file_path(wasmer_dir: &Path) -> PathBuf {
+        wasmer_dir.join(GLOBAL_CONFIG_DATABASE_FILE_NAME)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_registries_switch_token() {
+        let mut registries = MultiRegistry::default();
+
+        registries.set_current_registry("https://registry.wasmer.wtf");
+        assert_eq!(
+            registries.get_current_registry(),
+            "https://registry.wasmer.wtf/graphql".to_string()
+        );
+        registries.set_login_token_for_registry(
+            "https://registry.wasmer.io",
+            "token1",
+            UpdateRegistry::LeaveAsIs,
+        );
+        assert_eq!(
+            registries.get_current_registry(),
+            "https://registry.wasmer.wtf/graphql".to_string()
+        );
+        assert_eq!(
+            registries.get_login_token_for_registry(&registries.get_current_registry()),
+            None
+        );
+        registries.set_current_registry("https://registry.wasmer.io");
+        assert_eq!(
+            registries.get_login_token_for_registry(&registries.get_current_registry()),
+            Some("token1".to_string())
+        );
+        registries.clear_current_registry_token();
+        assert_eq!(
+            registries.get_login_token_for_registry(&registries.get_current_registry()),
+            None
+        );
+    }
+
+    #[test]
+    fn format_registry_urls() {
+        let inputs = [
+            // Domain names work
+            ("wasmer.io", "https://registry.wasmer.io/graphql"),
+            ("wasmer.wtf", "https://registry.wasmer.wtf/graphql"),
+            // Plain URLs
+            (
+                "https://registry.wasmer.wtf/graphql",
+                "https://registry.wasmer.wtf/graphql",
+            ),
+            (
+                "https://registry.wasmer.wtf/something/else",
+                "https://registry.wasmer.wtf/something/else",
+            ),
+            // We don't automatically prepend the domain name with
+            // "registry", but we will make sure "/" gets turned into "/graphql"
+            ("https://wasmer.wtf/", "https://wasmer.wtf/graphql"),
+            ("https://wasmer.wtf", "https://wasmer.wtf/graphql"),
+            // local development
+            (
+                "http://localhost:8000/graphql",
+                "http://localhost:8000/graphql",
+            ),
+            ("localhost:8000", "http://localhost:8000/graphql"),
+        ];
+
+        for (input, expected) in inputs {
+            let url = format_graphql(input);
+            assert_eq!(url, expected);
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mod.rs
new file mode 100644
index 0000000..467a1aa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mod.rs
@@ -0,0 +1,157 @@
+pub(crate) mod mutations;
+pub(crate) mod proxy;
+pub(crate) mod queries;
+pub(crate) mod subscriptions;
+
+use graphql_client::*;
+use reqwest::{
+    blocking::{multipart::Form, Client},
+    header::USER_AGENT,
+};
+use std::env;
+use std::time::Duration;
+
+use crate::config::WasmerConfig;
+
+pub fn whoami_distro() -> String {
+    #[cfg(target_os = "wasi")]
+    {
+        whoami::os().to_lowercase()
+    }
+    #[cfg(not(target_os = "wasi"))]
+    {
+        whoami::distro().to_lowercase()
+    }
+}
+
+fn setup_client() -> Result<Client, anyhow::Error> {
+    let builder = Client::builder();
+    let builder = proxy::maybe_set_up_proxy_blocking(builder)?;
+    builder.build().map_err(|e| e.into())
+}
+
+/// This function is being used to "ping" the registry
+/// (see test_if_registry_present and see whether the response
+/// is valid JSON, it doesn't check the response itself,
+/// since the response format might change
+pub fn execute_query_modifier_inner_check_json<V, F>(
+    registry_url: &str,
+    login_token: &str,
+    query: &QueryBody<V>,
+    timeout: Option<Duration>,
+    form_modifier: F,
+) -> anyhow::Result<()>
+where
+    V: serde::Serialize,
+    F: FnOnce(Form) -> Form,
+{
+    let client = setup_client()?;
+
+    let vars = serde_json::to_string(&query.variables).unwrap();
+
+    let form = Form::new()
+        .text("query", query.query.to_string())
+        .text("operationName", query.operation_name.to_string())
+        .text("variables", vars);
+
+    let form = form_modifier(form);
+
+    let user_agent = crate::client::RegistryClient::default_user_agent();
+
+    let mut res = client
+        .post(registry_url)
+        .multipart(form)
+        .bearer_auth(
+            env::var(WasmerConfig::ENV_VAR_WASMER_REGISTRY_TOKEN)
+                .ok()
+                .or_else(|| env::var(WasmerConfig::ENV_VAR_WASMER_REGISTRY_TOKEN_LEGACY).ok())
+                .unwrap_or_else(|| login_token.to_string()),
+        )
+        .header(USER_AGENT, user_agent);
+
+    if let Some(t) = timeout {
+        res = res.timeout(t);
+    }
+
+    let res = res.send()?;
+
+    let _: Response<serde_json::Value> = res.json()?;
+
+    Ok(())
+}
+
+pub fn execute_query_modifier_inner<R, V, F>(
+    registry_url: &str,
+    login_token: &str,
+    query: &QueryBody<V>,
+    timeout: Option<Duration>,
+    form_modifier: F,
+) -> anyhow::Result<R>
+where
+    for<'de> R: serde::Deserialize<'de>,
+    V: serde::Serialize,
+    F: FnOnce(Form) -> Form,
+{
+    let client = setup_client()?;
+
+    let vars = serde_json::to_string(&query.variables).unwrap();
+
+    let form = Form::new()
+        .text("query", query.query.to_string())
+        .text("operationName", query.operation_name.to_string())
+        .text("variables", vars);
+
+    let form = form_modifier(form);
+
+    let user_agent = crate::client::RegistryClient::default_user_agent();
+
+    let mut res = client
+        .post(registry_url)
+        .multipart(form)
+        .bearer_auth(
+            env::var("WASMER_TOKEN")
+                .ok()
+                .or_else(|| env::var("WAPM_REGISTRY_TOKEN").ok())
+                .unwrap_or_else(|| login_token.to_string()),
+        )
+        .header(USER_AGENT, user_agent);
+
+    if let Some(t) = timeout {
+        res = res.timeout(t);
+    }
+
+    let res = res.send()?;
+    let response_body: Response<R> = res.json()?;
+    if let Some(errors) = response_body.errors {
+        let error_messages: Vec<String> = errors.into_iter().map(|err| err.message).collect();
+        return Err(anyhow::anyhow!("{}", error_messages.join(", ")));
+    }
+    response_body
+        .data
+        .ok_or_else(|| anyhow::anyhow!("missing response data"))
+}
+
+pub fn execute_query<R, V>(
+    registry_url: &str,
+    login_token: &str,
+    query: &QueryBody<V>,
+) -> anyhow::Result<R>
+where
+    for<'de> R: serde::Deserialize<'de>,
+    V: serde::Serialize,
+{
+    execute_query_modifier_inner(registry_url, login_token, query, None, |f| f)
+}
+
+pub fn execute_query_with_timeout<R, V>(
+    registry_url: &str,
+    login_token: &str,
+    timeout: Duration,
+    query: &QueryBody<V>,
+) -> anyhow::Result<R>
+where
+    for<'de> R: serde::Deserialize<'de>,
+    V: serde::Serialize,
+{
+    execute_query_modifier_inner(registry_url, login_token, query, Some(timeout), |f| f)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mutations.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mutations.rs
new file mode 100644
index 0000000..6bed4af
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/mutations.rs
@@ -0,0 +1,35 @@
+use graphql_client::GraphQLQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/mutations/publish_package_chunked.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct PublishPackageMutationChunked;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/mutations/generate_deploy_token.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct GenerateDeployToken;
+
+pub type JSONString = String;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/mutations/publish_deploy_app.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct PublishDeployApp;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/mutations/new_nonce.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct NewNonce;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/proxy.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/proxy.rs
new file mode 100644
index 0000000..75ac81f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/proxy.rs
@@ -0,0 +1,73 @@
+//! Code for dealing with setting things up to proxy network requests
+
+use std::env;
+
+use anyhow::Context;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum ProxyError {
+    #[error("Failed to parse URL from {}: {}", url_location, error_message)]
+    UrlParseError {
+        url_location: String,
+        error_message: String,
+    },
+
+    #[error("Could not connect to proxy: {0}")]
+    ConnectionError(String),
+}
+
+pub fn maybe_set_up_proxy_blocking(
+    builder: reqwest::blocking::ClientBuilder,
+) -> anyhow::Result<reqwest::blocking::ClientBuilder> {
+    if let Some(proxy) =
+        maybe_set_up_proxy_inner().context("failed to setup proxy for reqwest Client")?
+    {
+        return Ok(builder.proxy(proxy));
+    }
+    Ok(builder)
+}
+
+/// Tries to set up a proxy
+///
+/// This function reads from wasmer config's `proxy.url` first, then checks
+/// `ALL_PROXY`, `HTTPS_PROXY`, and `HTTP_PROXY` environment variables, in both
+/// upper case and lower case, in that order.
+///
+/// If a proxy is specified in wasmer config's `proxy.url`, it is assumed
+/// to be a general proxy
+///
+/// A return value of `Ok(None)` means that there was no attempt to set up a proxy,
+/// `Ok(Some(proxy))` means that the proxy was set up successfully, and `Err(e)` that
+/// there was a failure while attempting to set up the proxy.
+fn maybe_set_up_proxy_inner() -> anyhow::Result<Option<reqwest::Proxy>> {
+    let proxy = if let Ok(proxy_url) = env::var("ALL_PROXY").or_else(|_| env::var("all_proxy")) {
+        reqwest::Proxy::all(&proxy_url).map(|proxy| (proxy_url, proxy, "ALL_PROXY"))
+    } else if let Ok(https_proxy_url) = env::var("HTTPS_PROXY").or_else(|_| env::var("https_proxy"))
+    {
+        reqwest::Proxy::https(&https_proxy_url).map(|proxy| (https_proxy_url, proxy, "HTTPS_PROXY"))
+    } else if let Ok(http_proxy_url) = env::var("HTTP_PROXY").or_else(|_| env::var("http_proxy")) {
+        reqwest::Proxy::http(&http_proxy_url).map(|proxy| (http_proxy_url, proxy, "http_proxy"))
+    } else {
+        return Ok(None);
+    }
+    .map_err(|e| ProxyError::ConnectionError(e.to_string()))
+    .and_then(
+        |(proxy_url_str, proxy, url_location): (String, _, &'static str)| {
+            url::Url::parse(&proxy_url_str)
+                .map_err(|e| ProxyError::UrlParseError {
+                    url_location: url_location.to_string(),
+                    error_message: e.to_string(),
+                })
+                .map(|url| {
+                    if !(url.username().is_empty()) && url.password().is_some() {
+                        proxy.basic_auth(url.username(), url.password().unwrap_or_default())
+                    } else {
+                        proxy
+                    }
+                })
+        },
+    )?;
+
+    Ok(Some(proxy))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/queries.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/queries.rs
new file mode 100644
index 0000000..a95234f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/queries.rs
@@ -0,0 +1,75 @@
+//! Low-level GraphQL queries used by this crate.
+//!
+//! If possible, users should prefer the high-level functions exposed under
+//! [`crate`].
+//!
+//! This module is primarily used in combination with
+//! [`crate::graphql::execute_query()`] as an "escape hatch" for accessing
+//! information that may not be exposed via the high-level functions.
+//!
+//! # Backwards Compatibility
+//!
+//! Queries won't be deleted or have breaking changes to their inputs during
+//! patch releases, however new fields may be added to the response types
+//! generated by `graphql_client` at any time.
+//!
+//! Users should treat all response types as if they had the `#[non_exhaustive]`
+//! attribute.
+
+use graphql_client::GraphQLQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/get_package_version.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct GetPackageVersionQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/get_package_by_command.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct GetPackageByCommandQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/test_if_registry_present.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct TestIfRegistryPresent;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/get_bindings.graphql",
+    response_derives = "Debug,Clone,PartialEq,Eq"
+)]
+pub(crate) struct GetBindingsQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/get_signed_url.graphql",
+    response_derives = "Debug, Clone"
+)]
+pub(crate) struct GetSignedUrl;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/get_interface_version.graphql",
+    response_derives = "Debug"
+)]
+pub(crate) struct GetInterfaceVersionQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/queries/whoami.graphql",
+    response_derives = "Debug"
+)]
+pub struct WhoAmIQuery;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/subscriptions.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/subscriptions.rs
new file mode 100644
index 0000000..6f0115f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/graphql/subscriptions.rs
@@ -0,0 +1,9 @@
+use graphql_client::GraphQLQuery;
+
+#[derive(GraphQLQuery)]
+#[graphql(
+    schema_path = "graphql/schema.graphql",
+    query_path = "graphql/subscriptions/packageVersionReady.graphql",
+    response_derives = "Debug"
+)]
+pub struct PackageVersionReady;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/interface.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/interface.rs
new file mode 100644
index 0000000..614ae38
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/interface.rs
@@ -0,0 +1,44 @@
+#![cfg_attr(
+    not(feature = "full"),
+    allow(dead_code, unused_imports, unused_variables)
+)]
+
+use graphql_client::GraphQLQuery;
+
+use crate::graphql::{
+    execute_query,
+    queries::{get_interface_version_query, GetInterfaceVersionQuery},
+};
+
+#[derive(Debug)]
+pub struct InterfaceFromServer {
+    pub name: String,
+    pub version: String,
+    pub content: String,
+}
+
+impl InterfaceFromServer {
+    fn get_response(
+        registry: &str,
+        name: String,
+        version: String,
+    ) -> anyhow::Result<get_interface_version_query::ResponseData> {
+        let q = GetInterfaceVersionQuery::build_query(get_interface_version_query::Variables {
+            name,
+            version,
+        });
+        execute_query(registry, "", &q)
+    }
+
+    pub fn get(registry: &str, name: String, version: String) -> anyhow::Result<Self> {
+        let response = Self::get_response(registry, name, version)?;
+        let response_val = response
+            .interface
+            .ok_or_else(|| anyhow::anyhow!("Error downloading Interface from the server"))?;
+        Ok(Self {
+            name: response_val.interface.name,
+            version: response_val.version,
+            content: response_val.content,
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/lib.rs
new file mode 100644
index 0000000..d2f1afc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/lib.rs
@@ -0,0 +1,524 @@
+//! High-level interactions with the Wasmer backend.
+//!
+//! The GraphQL schema can be updated by running `make` in the Wasmer repo's
+//! root directory.
+//!
+//! ```console
+//! $ make update-graphql-schema
+//! curl -sSfL https://registry.wasmer.io/graphql/schema.graphql > lib/registry/graphql/schema.graphql
+//! ```
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub mod api;
+mod client;
+pub mod config;
+pub mod graphql;
+pub mod interface;
+pub mod login;
+pub mod package;
+pub mod publish;
+pub mod subscriptions;
+pub(crate) mod tokio_spawner;
+pub mod types;
+pub mod utils;
+pub mod wasmer_env;
+
+pub use crate::client::RegistryClient;
+
+use std::{
+    fmt,
+    path::{Path, PathBuf},
+    time::Duration,
+};
+
+use anyhow::Context;
+use graphql_client::GraphQLQuery;
+use tar::EntryType;
+
+use crate::utils::normalize_path;
+pub use crate::{
+    config::{format_graphql, WasmerConfig},
+    graphql::queries::get_bindings_query::ProgrammingLanguage,
+    package::Package,
+};
+
+pub static PACKAGE_TOML_FILE_NAME: &str = "wasmer.toml";
+pub static PACKAGE_TOML_FALLBACK_NAME: &str = "wapm.toml";
+pub static GLOBAL_CONFIG_FILE_NAME: &str = "wasmer.toml";
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]
+#[non_exhaustive]
+pub struct PackageDownloadInfo {
+    pub registry: String,
+    pub package: String,
+    pub version: String,
+    pub is_latest_version: bool,
+    /// Is the package private?
+    pub is_private: bool,
+    pub commands: String,
+    pub manifest: String,
+    pub url: String,
+    pub pirita_url: Option<String>,
+}
+
+pub fn query_command_from_registry(
+    registry_url: &str,
+    command_name: &str,
+) -> Result<PackageDownloadInfo, String> {
+    use crate::graphql::{
+        execute_query,
+        queries::{get_package_by_command_query, GetPackageByCommandQuery},
+    };
+
+    let q = GetPackageByCommandQuery::build_query(get_package_by_command_query::Variables {
+        command_name: command_name.to_string(),
+    });
+
+    let response: get_package_by_command_query::ResponseData = execute_query(registry_url, "", &q)
+        .map_err(|e| format!("Error sending GetPackageByCommandQuery:  {e}"))?;
+
+    let command = response
+        .get_command
+        .ok_or_else(|| "GetPackageByCommandQuery: no get_command".to_string())?;
+
+    let package = command.package_version.package.display_name;
+    let version = command.package_version.version;
+    let url = command.package_version.distribution.download_url;
+    let pirita_url = command.package_version.distribution.pirita_download_url;
+
+    Ok(PackageDownloadInfo {
+        registry: registry_url.to_string(),
+        package,
+        version,
+        is_latest_version: command.package_version.is_last_version,
+        manifest: command.package_version.manifest,
+        commands: command_name.to_string(),
+        url,
+        pirita_url,
+        is_private: command.package_version.package.private,
+    })
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
+pub enum QueryPackageError {
+    ErrorSendingQuery(String),
+    NoPackageFound {
+        name: String,
+        version: Option<String>,
+    },
+}
+
+impl fmt::Display for QueryPackageError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            QueryPackageError::ErrorSendingQuery(q) => write!(f, "error sending query: {q}"),
+            QueryPackageError::NoPackageFound { name, version } => {
+                write!(f, "no package found for {name:?}")?;
+                if let Some(version) = version {
+                    write!(f, " (version = {version:?})")?;
+                }
+
+                Ok(())
+            }
+        }
+    }
+}
+
+impl std::error::Error for QueryPackageError {}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd)]
+pub enum GetIfPackageHasNewVersionResult {
+    // if version = Some(...) and the ~/.wasmer/checkouts/.../{version} exists, the package is already installed
+    UseLocalAlreadyInstalled {
+        registry_host: String,
+        namespace: String,
+        name: String,
+        version: String,
+        path: PathBuf,
+    },
+    // if version = None, check for the latest version
+    LocalVersionMayBeOutdated {
+        registry_host: String,
+        namespace: String,
+        name: String,
+        /// Versions that are already installed + whether they are
+        /// older (true) or younger (false) than the timeout
+        installed_versions: Vec<(String, bool)>,
+    },
+    // registry / namespace / name / version doesn't exist yet
+    PackageNotInstalledYet {
+        registry_url: String,
+        namespace: String,
+        name: String,
+        version: Option<String>,
+    },
+}
+
+/// Returns the download info of the packages, on error returns all the available packages
+/// i.e. (("foo/python", "wasmer.io"), ("bar/python" "wasmer.io")))
+pub fn query_package_from_registry(
+    registry_url: &str,
+    name: &str,
+    version: Option<&str>,
+    auth_token: Option<&str>,
+) -> Result<PackageDownloadInfo, QueryPackageError> {
+    use crate::graphql::{
+        execute_query,
+        queries::{get_package_version_query, GetPackageVersionQuery},
+    };
+
+    let q = GetPackageVersionQuery::build_query(get_package_version_query::Variables {
+        name: name.to_string(),
+        version: version.map(|s| s.to_string()),
+    });
+
+    let response: get_package_version_query::ResponseData =
+        execute_query(registry_url, auth_token.unwrap_or_default(), &q).map_err(|e| {
+            QueryPackageError::ErrorSendingQuery(format!("Error sending GetPackagesQuery: {e}"))
+        })?;
+
+    let v = response
+        .package_version
+        .as_ref()
+        .ok_or_else(|| QueryPackageError::NoPackageFound {
+            name: name.to_string(),
+            version: None,
+        })?;
+
+    let manifest = toml::from_str::<wasmer_toml::Manifest>(&v.manifest).map_err(|e| {
+        QueryPackageError::ErrorSendingQuery(format!("Invalid manifest for crate {name:?}: {e}"))
+    })?;
+
+    Ok(PackageDownloadInfo {
+        registry: registry_url.to_string(),
+        package: v.package.name.clone(),
+
+        version: v.version.clone(),
+        is_latest_version: v.is_last_version,
+        is_private: v.package.private,
+        manifest: v.manifest.clone(),
+
+        commands: manifest
+            .commands
+            .iter()
+            .map(|s| s.get_name())
+            .collect::<Vec<_>>()
+            .join(", "),
+
+        url: v.distribution.download_url.clone(),
+        pirita_url: v.distribution.pirita_download_url.clone(),
+    })
+}
+
+pub fn get_checkouts_dir(wasmer_dir: &Path) -> PathBuf {
+    wasmer_dir.join("checkouts")
+}
+
+pub fn get_webc_dir(wasmer_dir: &Path) -> PathBuf {
+    wasmer_dir.join("webc")
+}
+
+/// Convenience function that will unpack .tar.gz files and .tar.bz
+/// files to a target directory (does NOT remove the original .tar.gz)
+pub fn try_unpack_targz<P: AsRef<Path>>(
+    target_targz_path: P,
+    target_path: P,
+    strip_toplevel: bool,
+) -> Result<PathBuf, anyhow::Error> {
+    let target_targz_path = target_targz_path.as_ref().to_string_lossy().to_string();
+    let target_targz_path = crate::utils::normalize_path(&target_targz_path);
+    let target_targz_path = Path::new(&target_targz_path);
+
+    let target_path = target_path.as_ref().to_string_lossy().to_string();
+    let target_path = crate::utils::normalize_path(&target_path);
+    let target_path = Path::new(&target_path);
+
+    let open_file = || {
+        std::fs::File::open(target_targz_path)
+            .map_err(|e| anyhow::anyhow!("failed to open {}: {e}", target_targz_path.display()))
+    };
+
+    let try_decode_gz = || {
+        let file = open_file()?;
+        let gz_decoded = flate2::read::GzDecoder::new(&file);
+        let ar = tar::Archive::new(gz_decoded);
+        if strip_toplevel {
+            unpack_sans_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (gz_ar_unpack_sans_parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        } else {
+            unpack_with_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (gz_ar_unpack) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        }
+    };
+
+    let try_decode_xz = || {
+        let file = open_file()?;
+        let mut decomp: Vec<u8> = Vec::new();
+        let mut bufread = std::io::BufReader::new(&file);
+        lzma_rs::xz_decompress(&mut bufread, &mut decomp).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to unpack (try_decode_xz) {}: {e}",
+                target_targz_path.display()
+            )
+        })?;
+
+        let cursor = std::io::Cursor::new(decomp);
+        let mut ar = tar::Archive::new(cursor);
+        if strip_toplevel {
+            unpack_sans_parent(ar, target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (sans parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        } else {
+            ar.unpack(target_path).map_err(|e| {
+                anyhow::anyhow!(
+                    "failed to unpack (with parent) {}: {e}",
+                    target_targz_path.display()
+                )
+            })
+        }
+    };
+
+    try_decode_gz().or_else(|e1| {
+        try_decode_xz()
+            .map_err(|e2| anyhow::anyhow!("could not decode gz: {e1}, could not decode xz: {e2}"))
+    })?;
+
+    Ok(Path::new(&target_targz_path).to_path_buf())
+}
+
+/// Whether the top-level directory should be stripped
+pub fn download_and_unpack_targz(
+    url: &str,
+    target_path: &Path,
+    strip_toplevel: bool,
+) -> Result<PathBuf, anyhow::Error> {
+    let tempdir = tempfile::TempDir::new()?;
+
+    let target_targz_path = tempdir.path().join("package.tar.gz");
+
+    let mut resp = reqwest::blocking::get(url)
+        .map_err(|e| anyhow::anyhow!("failed to download {url}: {e}"))?;
+
+    {
+        let mut file = std::fs::File::create(&target_targz_path).map_err(|e| {
+            anyhow::anyhow!(
+                "failed to download {url} into {}: {e}",
+                target_targz_path.display()
+            )
+        })?;
+
+        resp.copy_to(&mut file)
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
+    }
+
+    try_unpack_targz(target_targz_path.as_path(), target_path, strip_toplevel)
+        .with_context(|| anyhow::anyhow!("Could not download {url}"))?;
+
+    Ok(target_path.to_path_buf())
+}
+
+pub fn unpack_with_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> Result<(), anyhow::Error>
+where
+    R: std::io::Read,
+{
+    use std::path::Component::Normal;
+
+    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
+
+    for entry in archive.entries()? {
+        let mut entry = entry?;
+        let path: PathBuf = entry
+            .path()?
+            .components()
+            .skip(1) // strip top-level directory
+            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
+            .collect();
+        if entry.header().entry_type().is_file() {
+            entry.unpack_in(&dst_normalized)?;
+        } else if entry.header().entry_type() == EntryType::Directory {
+            std::fs::create_dir_all(&Path::new(&dst_normalized).join(&path))?;
+        }
+    }
+    Ok(())
+}
+
+pub fn unpack_sans_parent<R>(mut archive: tar::Archive<R>, dst: &Path) -> std::io::Result<()>
+where
+    R: std::io::Read,
+{
+    use std::path::Component::Normal;
+
+    let dst_normalized = normalize_path(dst.to_string_lossy().as_ref());
+
+    for entry in archive.entries()? {
+        let mut entry = entry?;
+        let path: PathBuf = entry
+            .path()?
+            .components()
+            .skip(1) // strip top-level directory
+            .filter(|c| matches!(c, Normal(_))) // prevent traversal attacks
+            .collect();
+        entry.unpack(Path::new(&dst_normalized).join(path))?;
+    }
+    Ok(())
+}
+
+pub fn whoami(
+    wasmer_dir: &Path,
+    registry: Option<&str>,
+    token: Option<&str>,
+) -> Result<(String, String), anyhow::Error> {
+    use crate::graphql::queries::{who_am_i_query, WhoAmIQuery};
+
+    let config = WasmerConfig::from_file(wasmer_dir);
+
+    let config = config
+        .map_err(|e| anyhow::anyhow!("{e}"))
+        .with_context(|| format!("{registry:?}"))?;
+
+    let registry = match registry {
+        Some(s) => format_graphql(s),
+        None => config.registry.get_current_registry(),
+    };
+
+    let login_token = token
+        .map(|s| s.to_string())
+        .or_else(|| config.registry.get_login_token_for_registry(&registry))
+        .ok_or_else(|| anyhow::anyhow!("not logged into registry {:?}", registry))?;
+
+    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
+    let response: who_am_i_query::ResponseData =
+        crate::graphql::execute_query(&registry, &login_token, &q)
+            .with_context(|| format!("{registry:?}"))?;
+
+    let username = response
+        .viewer
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("not logged into registry {:?}", registry))?
+        .username
+        .to_string();
+
+    Ok((registry, username))
+}
+
+pub fn test_if_registry_present(registry: &str) -> Result<bool, String> {
+    use crate::graphql::queries::{test_if_registry_present, TestIfRegistryPresent};
+
+    let q = TestIfRegistryPresent::build_query(test_if_registry_present::Variables {});
+    crate::graphql::execute_query_modifier_inner_check_json(
+        registry,
+        "",
+        &q,
+        Some(Duration::from_secs(1)),
+        |f| f,
+    )
+    .map_err(|e| format!("{e}"))?;
+
+    Ok(true)
+}
+
+pub fn get_all_available_registries(wasmer_dir: &Path) -> Result<Vec<String>, String> {
+    let config = WasmerConfig::from_file(wasmer_dir)?;
+    let mut registries = Vec::new();
+    for login in config.registry.tokens {
+        registries.push(format_graphql(&login.registry));
+    }
+    Ok(registries)
+}
+
+/// A library that exposes bindings to a Wasmer package.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Bindings {
+    /// A unique ID specifying this set of bindings.
+    pub id: String,
+    /// The URL which can be used to download the files that were generated
+    /// (typically as a `*.tar.gz` file).
+    pub url: String,
+    /// The programming language these bindings are written in.
+    pub language: ProgrammingLanguage,
+    /// The generator used to generate these bindings.
+    pub generator: BindingsGenerator,
+}
+
+/// The generator used to create [`Bindings`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BindingsGenerator {
+    /// A unique ID specifying this generator.
+    pub id: String,
+    /// The generator package's name (e.g. `wasmer/wasmer-pack`).
+    pub package_name: String,
+    /// The exact package version.
+    pub version: String,
+    /// The name of the command that was used for generating bindings.
+    pub command: String,
+}
+
+impl fmt::Display for BindingsGenerator {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let BindingsGenerator {
+            package_name,
+            version,
+            command,
+            ..
+        } = self;
+
+        write!(f, "{package_name}@{version}:{command}")?;
+
+        Ok(())
+    }
+}
+
+/// List all bindings associated with a particular package.
+///
+/// If a version number isn't provided, this will default to the most recently
+/// published version.
+pub fn list_bindings(
+    registry: &str,
+    name: &str,
+    version: Option<&str>,
+) -> Result<Vec<Bindings>, anyhow::Error> {
+    use crate::graphql::queries::{
+        get_bindings_query::{ResponseData, Variables},
+        GetBindingsQuery,
+    };
+
+    let variables = Variables {
+        name: name.to_string(),
+        version: version.map(String::from),
+    };
+
+    let q = GetBindingsQuery::build_query(variables);
+    let response: ResponseData = crate::graphql::execute_query(registry, "", &q)?;
+
+    let package_version = response.package_version.context("Package not found")?;
+
+    let mut bindings_packages = Vec::new();
+
+    for b in package_version.bindings.into_iter().flatten() {
+        let pkg = Bindings {
+            id: b.id,
+            url: b.url,
+            language: b.language,
+            generator: BindingsGenerator {
+                id: b.generator.package_version.id,
+                package_name: b.generator.package_version.package.name,
+                version: b.generator.package_version.version,
+                command: b.generator.command_name,
+            },
+        };
+        bindings_packages.push(pkg);
+    }
+
+    Ok(bindings_packages)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/login.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/login.rs
new file mode 100644
index 0000000..9803f6f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/login.rs
@@ -0,0 +1,25 @@
+use crate::config::{format_graphql, UpdateRegistry};
+use crate::WasmerConfig;
+use std::path::Path;
+
+/// Login to a registry and save the token associated with it.
+///
+/// Also sets the registry as the currently active registry to provide a better UX.
+pub fn login_and_save_token(
+    wasmer_dir: &Path,
+    registry: &str,
+    token: &str,
+) -> Result<Option<String>, anyhow::Error> {
+    let registry = format_graphql(registry);
+    let mut config = WasmerConfig::from_file(wasmer_dir)
+        .map_err(|e| anyhow::anyhow!("config from file: {e}"))?;
+    config.registry.set_current_registry(&registry);
+    config.registry.set_login_token_for_registry(
+        &config.registry.get_current_registry(),
+        token,
+        UpdateRegistry::Update,
+    );
+    let path = WasmerConfig::get_file_location(wasmer_dir);
+    config.save(path)?;
+    crate::utils::get_username_registry_token(&registry, token)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/builder.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/builder.rs
new file mode 100644
index 0000000..ab804f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/builder.rs
@@ -0,0 +1,1064 @@
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+use std::{fs, io::IsTerminal};
+
+use anyhow::{anyhow, bail, Context};
+use flate2::{write::GzEncoder, Compression};
+use rusqlite::{params, Connection, OpenFlags, TransactionBehavior};
+use tar::Builder;
+use thiserror::Error;
+use time::{self, OffsetDateTime};
+
+use crate::publish::PublishWait;
+use crate::{package::builder::validate::ValidationPolicy, publish::SignArchiveResult};
+use crate::{WasmerConfig, PACKAGE_TOML_FALLBACK_NAME};
+
+const MIGRATIONS: &[(i32, &str)] = &[
+    (0, include_str!("./sql/migrations/0000.sql")),
+    (1, include_str!("./sql/migrations/0001.sql")),
+    (2, include_str!("./sql/migrations/0002.sql")),
+];
+
+const CURRENT_DATA_VERSION: usize = MIGRATIONS.len();
+
+/// CLI options for the `wasmer publish` command
+pub struct Publish {
+    /// Registry to publish to
+    pub registry: Option<String>,
+    /// Run the publish logic without sending anything to the registry server
+    pub dry_run: bool,
+    /// Run the publish command without any output
+    pub quiet: bool,
+    /// Override the package of the uploaded package in the wasmer.toml
+    pub package_name: Option<String>,
+    /// Override the package version of the uploaded package in the wasmer.toml
+    pub version: Option<semver::Version>,
+    /// The auth token to use.
+    pub token: String,
+    /// Skip validation of the uploaded package
+    pub no_validate: bool,
+    /// Directory containing the `wasmer.toml` (defaults to current root dir)
+    pub package_path: Option<String>,
+    /// Wait for package to be available on the registry before exiting
+    pub wait: PublishWait,
+    /// Timeout (in seconds) for the publish query to the registry
+    pub timeout: Duration,
+}
+
+#[derive(Debug, Error)]
+enum PackageBuildError {
+    #[error("Unable to publish the \"{module}\" module because \"{}\" is not a file", path.display())]
+    SourceMustBeFile { module: String, path: PathBuf },
+    #[error("Unable to load the bindings for \"{module}\" because \"{}\" doesn't exist", path.display())]
+    MissingBindings { module: String, path: PathBuf },
+    #[error("Error building package when parsing module \"{0}\": {1}.")]
+    ErrorBuildingPackage(String, io::Error),
+    #[error(
+        "Path \"{0}\", specified in the manifest as part of the package file system does not exist.",
+    )]
+    MissingManifestFsPath(String),
+    #[error("When processing the package filesystem, found path \"{0}\" which is not a directory")]
+    PackageFileSystemEntryMustBeDirectory(String),
+}
+
+impl Publish {
+    /// Executes `wasmer publish`
+    pub fn execute(&self) -> Result<(), anyhow::Error> {
+        let input_path = match self.package_path.as_ref() {
+            Some(s) => std::env::current_dir()?.join(s),
+            None => std::env::current_dir()?,
+        };
+
+        let manifest_path = match input_path.metadata() {
+            Ok(metadata) => {
+                if metadata.is_dir() {
+                    let p = input_path.join("wasmer.toml");
+                    if !p.is_file() {
+                        bail!(
+                            "directory does not contain a 'wasmer.toml' manifest - use 'wasmer init' to initialize a new packagae, or specify a valid package directory or manifest file instead. (path: {})",
+                            input_path.display()
+                        );
+                    }
+
+                    p
+                } else if metadata.is_file() {
+                    if input_path.extension().and_then(|x| x.to_str()) != Some("toml") {
+                        bail!(
+                            "The specified file path is not a .toml file: '{}'",
+                            input_path.display()
+                        );
+                    }
+                    input_path
+                } else {
+                    bail!("Invalid path specified: '{}'", input_path.display());
+                }
+            }
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+                bail!("Specified path does not exist: '{}'", input_path.display());
+            }
+            Err(err) => {
+                bail!("Could not read path '{}': {}", input_path.display(), err);
+            }
+        };
+
+        let manifest = std::fs::read_to_string(&manifest_path)
+            .map_err(|e| anyhow::anyhow!("could not find manifest: {e}"))
+            .with_context(|| anyhow::anyhow!("{}", manifest_path.display()))?;
+        let mut manifest = wasmer_toml::Manifest::parse(&manifest)?;
+
+        let manifest_path_canon = manifest_path.canonicalize()?;
+        let manifest_dir = manifest_path_canon
+            .parent()
+            .context("could not determine manifest parent directory")?
+            .to_owned();
+
+        if let Some(package_name) = self.package_name.as_ref() {
+            manifest.package.name = package_name.to_string();
+        }
+
+        if let Some(version) = self.version.as_ref() {
+            manifest.package.version = version.clone();
+        }
+
+        let archive_dir = tempfile::TempDir::new()?;
+        let archive_meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path)?;
+
+        let registry = match self.registry.as_deref() {
+            Some(s) => crate::format_graphql(s),
+            None => {
+                let wasmer_dir = WasmerConfig::get_wasmer_dir()
+                    .map_err(|e| anyhow::anyhow!("no wasmer dir: {e}"))?;
+                let config = WasmerConfig::from_file(&wasmer_dir)
+                    .map_err(|e| anyhow::anyhow!("could not load config {e}"))?;
+                config.registry.get_current_registry()
+            }
+        };
+
+        let mut policy = self.validation_policy();
+
+        if !policy.skip_validation() {
+            validate::validate_directory(
+                &manifest,
+                &registry,
+                manifest_dir,
+                &mut *policy,
+                &self.token,
+            )?;
+        }
+
+        let archive_path = &archive_meta.archive_path;
+        let mut compressed_archive_reader = fs::File::open(archive_path)?;
+
+        let maybe_signature_data = sign_compressed_archive(&mut compressed_archive_reader)?;
+        let archived_data_size = archive_path.metadata()?.len();
+
+        assert!(archive_path.exists());
+        assert!(archive_path.is_file());
+
+        if self.dry_run {
+            // dry run: publish is done here
+
+            println!(
+                "🚀 Successfully published package `{}@{}`",
+                manifest.package.name, manifest.package.version
+            );
+
+            let path = archive_dir.into_path();
+            eprintln!("Archive persisted at: {}", path.display());
+
+            log::info!(
+                "Publish succeeded, but package was not published because it was run in dry-run mode"
+            );
+
+            return Ok(());
+        }
+
+        crate::publish::try_chunked_uploading(
+            Some(registry),
+            Some(self.token.clone()),
+            &manifest.package,
+            &archive_meta.manifest_toml,
+            &archive_meta.license,
+            &archive_meta.readme,
+            &archive_meta
+                .archive_path
+                .file_name()
+                .unwrap()
+                .to_str()
+                .unwrap()
+                .to_string(),
+            archive_path,
+            &maybe_signature_data,
+            archived_data_size,
+            self.quiet,
+            self.wait,
+            self.timeout,
+        )
+    }
+
+    fn validation_policy(&self) -> Box<dyn ValidationPolicy> {
+        if self.no_validate {
+            Box::<validate::Skip>::default()
+        } else if std::io::stdin().is_terminal() {
+            Box::<validate::Interactive>::default()
+        } else {
+            Box::<validate::NonInteractive>::default()
+        }
+    }
+}
+
+struct ConstructedPackageArchive {
+    manifest_toml: String,
+    readme: Option<String>,
+    license: Option<String>,
+    archive_path: PathBuf,
+}
+
+fn construct_tar_gz(
+    archive_dir: &Path,
+    manifest: &wasmer_toml::Manifest,
+    manifest_path: &Path,
+) -> Result<ConstructedPackageArchive, anyhow::Error> {
+    // This is an assert instead of returned error because this is a programmer error.
+    debug_assert!(manifest_path.is_file(), "manifest path is not a file");
+
+    let manifest_dir = manifest_path
+        .parent()
+        .context("manifest path has no parent directory")?;
+
+    let mut builder = Builder::new(Vec::new());
+    builder.append_path_with_name(manifest_path, PACKAGE_TOML_FALLBACK_NAME)?;
+
+    let manifest_string = toml::to_string(&manifest)?;
+
+    let package = &manifest.package;
+    let modules = &manifest.modules;
+
+    let readme = match package.readme.as_ref() {
+        None => None,
+        Some(s) => {
+            let path = append_path_to_tar_gz(&mut builder, manifest_dir, s).map_err(|(p, e)| {
+                PackageBuildError::ErrorBuildingPackage(format!("{}", p.display()), e)
+            })?;
+            Some(std::fs::read_to_string(path)?)
+        }
+    };
+
+    let license = match package.license_file.as_ref() {
+        None => None,
+        Some(s) => {
+            let path = append_path_to_tar_gz(&mut builder, manifest_dir, s).map_err(|(p, e)| {
+                PackageBuildError::ErrorBuildingPackage(format!("{}", p.display()), e)
+            })?;
+            Some(std::fs::read_to_string(path)?)
+        }
+    };
+
+    for module in modules {
+        append_path_to_tar_gz(&mut builder, manifest_dir, &module.source).map_err(
+            |(normalized_path, _)| PackageBuildError::SourceMustBeFile {
+                module: module.name.clone(),
+                path: normalized_path,
+            },
+        )?;
+
+        if let Some(bindings) = &module.bindings {
+            for path in bindings.referenced_files(manifest_dir)? {
+                let relative_path = path.strip_prefix(manifest_dir).with_context(|| {
+                    format!(
+                        "\"{}\" should be inside \"{}\"",
+                        path.display(),
+                        manifest_dir.display(),
+                    )
+                })?;
+
+                append_path_to_tar_gz(&mut builder, manifest_dir, relative_path).map_err(
+                    |(normalized_path, _)| PackageBuildError::MissingBindings {
+                        module: module.name.clone(),
+                        path: normalized_path,
+                    },
+                )?;
+            }
+        }
+    }
+
+    // bundle the package filesystem
+    for (_alias, path) in &manifest.fs {
+        let normalized_path = normalize_path(manifest_dir, path);
+        let path_metadata = normalized_path.metadata().map_err(|_| {
+            PackageBuildError::MissingManifestFsPath(normalized_path.to_string_lossy().to_string())
+        })?;
+        if path_metadata.is_dir() {
+            builder.append_dir_all(path, &normalized_path)
+        } else {
+            return Err(PackageBuildError::PackageFileSystemEntryMustBeDirectory(
+                path.to_string_lossy().to_string(),
+            )
+            .into());
+        }
+        .map_err(|_| {
+            PackageBuildError::MissingManifestFsPath(normalized_path.to_string_lossy().to_string())
+        })?;
+    }
+
+    builder
+        .finish()
+        .map_err(|e| anyhow::anyhow!("failed to finish .tar.gz builder: {e}"))?;
+    let tar_archive_data = builder.into_inner().expect("tar archive was not finalized");
+    let archive_name = "package.tar.gz".to_string();
+    fs::create_dir(archive_dir.join("wapm_package"))?;
+    let archive_path = archive_dir.join("wapm_package").join(archive_name);
+    let mut compressed_archive = fs::File::create(&archive_path).unwrap();
+    let mut gz_enc = GzEncoder::new(&mut compressed_archive, Compression::best());
+
+    gz_enc.write_all(&tar_archive_data).unwrap();
+    let _compressed_archive = gz_enc.finish().unwrap();
+
+    Ok(ConstructedPackageArchive {
+        manifest_toml: manifest_string,
+        archive_path,
+        readme,
+        license,
+    })
+}
+
+fn append_path_to_tar_gz(
+    builder: &mut tar::Builder<Vec<u8>>,
+    base_path: &Path,
+    target_path: &Path,
+) -> Result<PathBuf, (PathBuf, io::Error)> {
+    let normalized_path = normalize_path(base_path, target_path);
+    normalized_path
+        .metadata()
+        .map_err(|e| (normalized_path.clone(), e))?;
+    builder
+        .append_path_with_name(&normalized_path, target_path)
+        .map_err(|e| (normalized_path.clone(), e))?;
+    Ok(normalized_path)
+}
+
+fn normalize_path(cwd: &Path, path: &Path) -> PathBuf {
+    let mut out = PathBuf::from(cwd);
+    let mut components = path.components();
+    if path.is_absolute() {
+        log::warn!(
+            "Interpreting absolute path {} as a relative path",
+            path.to_string_lossy()
+        );
+        components.next();
+    }
+    for comp in components {
+        out.push(comp);
+    }
+    out
+}
+
+/// Takes the package archive as a File and attempts to sign it using the active key
+/// returns the public key id used to sign it and the signature string itself
+pub fn sign_compressed_archive(
+    compressed_archive: &mut fs::File,
+) -> anyhow::Result<SignArchiveResult> {
+    let key_db = open_db()?;
+    let personal_key = if let Ok(v) = get_active_personal_key(&key_db) {
+        v
+    } else {
+        return Ok(SignArchiveResult::NoKeyRegistered);
+    };
+    let password = rpassword::prompt_password(format!(
+        "Please enter your password for the key pair {}:",
+        &personal_key.public_key_id
+    ))
+    .ok();
+    let private_key = if let Some(priv_key_location) = personal_key.private_key_location {
+        match minisign::SecretKey::from_file(&priv_key_location, password) {
+            Ok(priv_key_data) => priv_key_data,
+            Err(e) => {
+                log::error!(
+                    "Could not read private key from location {}: {}",
+                    priv_key_location,
+                    e
+                );
+                return Err(e.into());
+            }
+        }
+    } else {
+        // TODO: add more info about why this might have happened and what the user can do about it
+        log::warn!("Active key does not have a private key location registered with it!");
+        return Err(anyhow!("Cannot sign package, no private key"));
+    };
+    let public_key = minisign::PublicKey::from_base64(&personal_key.public_key_value)?;
+    let signature = minisign::sign(
+        Some(&public_key),
+        &private_key,
+        compressed_archive,
+        None,
+        None,
+    )?;
+    Ok(SignArchiveResult::Ok {
+        public_key_id: personal_key.public_key_id,
+        signature: signature.to_string(),
+    })
+}
+
+/// Opens an exclusive read/write connection to the database, creating it if it does not exist
+pub fn open_db() -> anyhow::Result<Connection> {
+    let wasmer_dir =
+        WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("no wasmer dir: {e}"))?;
+    let db_path = WasmerConfig::get_database_file_path(&wasmer_dir);
+    let mut conn = Connection::open_with_flags(
+        db_path,
+        OpenFlags::SQLITE_OPEN_CREATE
+            | OpenFlags::SQLITE_OPEN_READ_WRITE
+            | OpenFlags::SQLITE_OPEN_FULL_MUTEX,
+    )?;
+
+    apply_migrations(&mut conn)?;
+    Ok(conn)
+}
+
+/// Applies migrations to the database
+pub fn apply_migrations(conn: &mut Connection) -> anyhow::Result<()> {
+    let user_version = conn.pragma_query_value(None, "user_version", |val| val.get(0))?;
+    for data_version in user_version..CURRENT_DATA_VERSION {
+        log::debug!("Applying migration {}", data_version);
+        apply_migration(conn, data_version as i32)?;
+    }
+    Ok(())
+}
+
+#[derive(Debug, Error)]
+enum MigrationError {
+    #[error(
+        "Critical internal error: the data version {0} is not handleded; current data version: {1}"
+    )]
+    MigrationNumberDoesNotExist(i32, i32),
+    #[error("Critical internal error: failed to commit trasaction migrating to data version {0}")]
+    CommitFailed(i32),
+    #[error("Critical internal error: transaction failed on migration number {0}: {1}")]
+    TransactionFailed(i32, String),
+}
+
+/// Applies migrations to the database and updates the `user_version` pragma.
+/// Every migration must leave the database in a valid state.
+fn apply_migration(conn: &mut Connection, migration_number: i32) -> Result<(), MigrationError> {
+    let tx = conn
+        .transaction_with_behavior(TransactionBehavior::Immediate)
+        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
+
+    let migration_to_apply = MIGRATIONS
+        .iter()
+        .find_map(|(number, sql)| {
+            if *number == migration_number {
+                Some(sql)
+            } else {
+                None
+            }
+        })
+        .ok_or({
+            MigrationError::MigrationNumberDoesNotExist(
+                migration_number,
+                CURRENT_DATA_VERSION as i32,
+            )
+        })?;
+
+    tx.execute_batch(migration_to_apply)
+        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
+
+    tx.pragma_update(None, "user_version", migration_number + 1)
+        .map_err(|e| MigrationError::TransactionFailed(migration_number, format!("{}", e)))?;
+    tx.commit()
+        .map_err(|_| MigrationError::CommitFailed(migration_number))
+}
+
+/// Information about one of the user's keys
+#[derive(Debug)]
+pub struct PersonalKey {
+    /// Flag saying if the key will be used (there can only be one active key at a time)
+    pub active: bool,
+    /// The public key's tag. Used to identify the key pair
+    pub public_key_id: String,
+    /// The raw value of the public key in base64
+    pub public_key_value: String,
+    /// The location in the file system of the private key
+    pub private_key_location: Option<String>,
+    /// The type of private/public key this is
+    pub key_type_identifier: String,
+    /// The time at which the key was registered with wasmer
+    pub date_created: OffsetDateTime,
+}
+
+fn get_active_personal_key(conn: &Connection) -> anyhow::Result<PersonalKey> {
+    let mut stmt = conn.prepare(
+        "SELECT active, public_key_value, private_key_location, date_added, key_type_identifier, public_key_id FROM personal_keys
+         where active = 1",
+    )?;
+
+    let result = stmt
+        .query_map(params![], |row| {
+            Ok(PersonalKey {
+                active: row.get(0)?,
+                public_key_value: row.get(1)?,
+                private_key_location: row.get(2)?,
+                date_created: {
+                    use time::format_description::well_known::Rfc3339;
+                    let time_str: String = row.get(3)?;
+                    OffsetDateTime::parse(&time_str, &Rfc3339)
+                        .unwrap_or_else(|_| panic!("Failed to parse time string {}", &time_str))
+                },
+                key_type_identifier: row.get(4)?,
+                public_key_id: row.get(5)?,
+            })
+        })?
+        .next();
+
+    if let Some(res) = result {
+        Ok(res?)
+    } else {
+        Err(anyhow!("No active key found"))
+    }
+}
+
+mod interfaces {
+    use anyhow::anyhow;
+    use rusqlite::{params, Connection, TransactionBehavior};
+
+    pub const WASM_INTERFACE_EXISTENCE_CHECK: &str =
+        include_str!("./sql/queries/wasm_interface_existence_check.sql");
+    pub const INSERT_WASM_INTERFACE: &str = include_str!("./sql/queries/insert_interface.sql");
+    pub const GET_WASM_INTERFACE: &str = include_str!("./sql/queries/get_interface.sql");
+
+    pub fn interface_exists(
+        conn: &mut Connection,
+        interface_name: &str,
+        version: &str,
+    ) -> anyhow::Result<bool> {
+        let mut stmt = conn.prepare(WASM_INTERFACE_EXISTENCE_CHECK)?;
+        Ok(stmt.exists(params![interface_name, version])?)
+    }
+
+    pub fn load_interface_from_db(
+        conn: &mut Connection,
+        interface_name: &str,
+        version: &str,
+    ) -> anyhow::Result<wasmer_wasm_interface::Interface> {
+        let mut stmt = conn.prepare(GET_WASM_INTERFACE)?;
+        let interface_string: String =
+            stmt.query_row(params![interface_name, version], |row| row.get(0))?;
+
+        wasmer_wasm_interface::parser::parse_interface(&interface_string).map_err(|e| {
+            anyhow!(
+                "Failed to parse interface {} version {} in database: {}",
+                interface_name,
+                version,
+                e
+            )
+        })
+    }
+
+    pub fn import_interface(
+        conn: &mut Connection,
+        interface_name: &str,
+        version: &str,
+        content: &str,
+    ) -> anyhow::Result<()> {
+        // fail if we already have this interface
+        {
+            let mut key_check = conn.prepare(WASM_INTERFACE_EXISTENCE_CHECK)?;
+            let result = key_check.exists(params![interface_name, version])?;
+
+            if result {
+                return Err(anyhow!(
+                    "Interface {}, version {} already exists",
+                    interface_name,
+                    version
+                ));
+            }
+        }
+
+        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
+        let time_string = get_current_time_in_format().expect("Could not get current time");
+
+        log::debug!("Adding interface {:?} {:?}", interface_name, version);
+        tx.execute(
+            INSERT_WASM_INTERFACE,
+            params![interface_name, version, time_string, content],
+        )?;
+
+        tx.commit()?;
+        Ok(())
+    }
+
+    /// Gets the current time in our standard format
+    pub fn get_current_time_in_format() -> Option<String> {
+        use time::format_description::well_known::Rfc3339;
+        let cur_time = time::OffsetDateTime::now_utc();
+        cur_time.format(&Rfc3339).ok()
+    }
+}
+
+mod validate {
+    use anyhow::anyhow;
+    use thiserror::Error;
+    use wasmer_wasm_interface::{validate, Interface};
+
+    use super::interfaces;
+    use crate::{interface::InterfaceFromServer, QueryPackageError};
+    use std::{
+        fs,
+        io::Read,
+        ops::ControlFlow,
+        path::{Path, PathBuf},
+    };
+
+    pub(crate) fn validate_directory(
+        manifest: &wasmer_toml::Manifest,
+        registry: &str,
+        pkg_path: PathBuf,
+        callbacks: &mut dyn ValidationPolicy,
+        auth_token: &str,
+    ) -> anyhow::Result<()> {
+        // validate as dir
+        for module in manifest.modules.iter() {
+            if let Err(e) = validate_module(module, registry, &pkg_path) {
+                if callbacks.on_invalid_module(module, &e).is_break() {
+                    return Err(e.into());
+                }
+            }
+        }
+
+        if would_change_package_privacy(manifest, registry, auth_token)?
+            && callbacks.on_package_privacy_changed(manifest).is_break()
+        {
+            if manifest.package.private {
+                return Err(ValidationError::WouldBecomePrivate.into());
+            } else {
+                return Err(ValidationError::WouldBecomePublic.into());
+            }
+        }
+
+        log::debug!("package at path {:#?} validated", &pkg_path);
+
+        Ok(())
+    }
+
+    /// Check if publishing this manifest would change the package's privacy.
+    fn would_change_package_privacy(
+        manifest: &wasmer_toml::Manifest,
+        registry: &str,
+        auth_token: &str,
+    ) -> Result<bool, ValidationError> {
+        let result = crate::query_package_from_registry(
+            registry,
+            &manifest.package.name,
+            None,
+            Some(auth_token),
+        );
+
+        match result {
+            Ok(package_version) => Ok(package_version.is_private != manifest.package.private),
+            Err(QueryPackageError::NoPackageFound { .. }) => {
+                // The package hasn't been published yet
+                Ok(false)
+            }
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    fn validate_module(
+        module: &wasmer_toml::Module,
+        registry: &str,
+        pkg_path: &Path,
+    ) -> Result<(), ValidationError> {
+        let source_path = if module.source.is_relative() {
+            pkg_path.join(&module.source)
+        } else {
+            module.source.clone()
+        };
+        let source_path_string = source_path.to_string_lossy().to_string();
+        let mut wasm_file =
+            fs::File::open(&source_path).map_err(|_| ValidationError::MissingFile {
+                file: source_path_string.clone(),
+            })?;
+        let mut wasm_buffer = Vec::new();
+        wasm_file
+            .read_to_end(&mut wasm_buffer)
+            .map_err(|err| ValidationError::MiscCannotRead {
+                file: source_path_string.clone(),
+                error: format!("{}", err),
+            })?;
+
+        if let Some(bindings) = &module.bindings {
+            validate_bindings(bindings, pkg_path)?;
+        }
+
+        // hack, short circuit if no interface for now
+        if module.interfaces.is_none() {
+            return validate_wasm_and_report_errors_old(&wasm_buffer[..], source_path_string);
+        }
+
+        let mut conn = super::open_db().map_err(ValidationError::UpdatingInterfaces)?;
+        let mut interface: Interface = Default::default();
+        for (interface_name, interface_version) in
+            module.interfaces.clone().unwrap_or_default().into_iter()
+        {
+            add_module_interface(
+                &mut conn,
+                interface_name,
+                interface_version,
+                registry,
+                &mut interface,
+            )
+            .map_err(ValidationError::UpdatingInterfaces)?;
+        }
+        validate::validate_wasm_and_report_errors(&wasm_buffer, &interface).map_err(|e| {
+            ValidationError::InvalidWasm {
+                file: source_path_string,
+                error: format!("{:?}", e),
+            }
+        })?;
+
+        Ok(())
+    }
+
+    fn add_module_interface(
+        conn: &mut rusqlite::Connection,
+        interface_name: String,
+        interface_version: String,
+        registry: &str,
+        interface: &mut Interface,
+    ) -> anyhow::Result<()> {
+        if !interfaces::interface_exists(conn, &interface_name, &interface_version)? {
+            // download interface and store it if we don't have it locally
+            let interface_data_from_server = InterfaceFromServer::get(
+                registry,
+                interface_name.clone(),
+                interface_version.clone(),
+            )?;
+            interfaces::import_interface(
+                conn,
+                &interface_name,
+                &interface_version,
+                &interface_data_from_server.content,
+            )?;
+        }
+        let sub_interface =
+            interfaces::load_interface_from_db(conn, &interface_name, &interface_version)?;
+        *interface = interface
+            .merge(sub_interface)
+            .map_err(|e| anyhow!("Failed to merge interface {}: {}", &interface_name, e))?;
+        Ok(())
+    }
+
+    fn validate_bindings(
+        bindings: &wasmer_toml::Bindings,
+        base_directory_path: &Path,
+    ) -> Result<(), ValidationError> {
+        // Note: checking for referenced files will make sure they all exist.
+        let _ = bindings.referenced_files(base_directory_path)?;
+
+        Ok(())
+    }
+
+    #[derive(Debug, Error)]
+    #[non_exhaustive]
+    pub enum ValidationError {
+        #[error("WASM file \"{file}\" detected as invalid because {error}")]
+        InvalidWasm { file: String, error: String },
+        #[error("Could not find file {file}")]
+        MissingFile { file: String },
+        #[error("Failed to read file {file}; {error}")]
+        MiscCannotRead { file: String, error: String },
+        #[error(transparent)]
+        Imports(#[from] wasmer_toml::ImportsError),
+        #[error("Unable to update the interfaces database")]
+        UpdatingInterfaces(#[source] anyhow::Error),
+        #[error("Aborting because publishing the package would make it public")]
+        WouldBecomePublic,
+        #[error("Aborting because publishing the package would make it private")]
+        WouldBecomePrivate,
+        #[error("Unable to look up package information")]
+        Registry(#[from] QueryPackageError),
+    }
+
+    // legacy function, validates wasm.  TODO: clean up
+    pub fn validate_wasm_and_report_errors_old(
+        wasm: &[u8],
+        file_name: String,
+    ) -> Result<(), ValidationError> {
+        let mut val = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
+            threads: true,
+            reference_types: true,
+            simd: true,
+            bulk_memory: true,
+            multi_value: true,
+            ..Default::default()
+        });
+
+        val.validate_all(wasm)
+            .map_err(|e| ValidationError::InvalidWasm {
+                file: file_name.clone(),
+                error: format!("{}", e),
+            })?;
+
+        Ok(())
+    }
+
+    /// How should validation be treated by the publishing process?
+    pub(crate) trait ValidationPolicy: Send + Sync {
+        /// Should validation be skipped entirely?
+        fn skip_validation(&mut self) -> bool;
+
+        /// How should publishing proceed when a module is invalid?
+        fn on_invalid_module(
+            &mut self,
+            module: &wasmer_toml::Module,
+            error: &ValidationError,
+        ) -> ControlFlow<(), ()>;
+
+        /// How should publishing proceed when it might change a package's
+        /// privacy? (i.e. by making a private package publicly available).
+        fn on_package_privacy_changed(
+            &mut self,
+            manifest: &wasmer_toml::Manifest,
+        ) -> ControlFlow<(), ()>;
+    }
+
+    #[derive(Debug, Default, Copy, Clone, PartialEq)]
+    pub(crate) struct Skip;
+
+    impl ValidationPolicy for Skip {
+        fn skip_validation(&mut self) -> bool {
+            true
+        }
+
+        fn on_invalid_module(
+            &mut self,
+            _module: &wasmer_toml::Module,
+            _error: &ValidationError,
+        ) -> ControlFlow<(), ()> {
+            unreachable!()
+        }
+
+        fn on_package_privacy_changed(
+            &mut self,
+            _manifest: &wasmer_toml::Manifest,
+        ) -> ControlFlow<(), ()> {
+            unreachable!()
+        }
+    }
+
+    #[derive(Debug, Default, Copy, Clone, PartialEq)]
+    pub(crate) struct Interactive;
+
+    impl ValidationPolicy for Interactive {
+        fn skip_validation(&mut self) -> bool {
+            false
+        }
+
+        fn on_invalid_module(
+            &mut self,
+            module: &wasmer_toml::Module,
+            error: &ValidationError,
+        ) -> ControlFlow<(), ()> {
+            let module_name = &module.name;
+            let prompt =
+                format!("Validation error with the \"{module_name}\" module: {error}. Would you like to continue?");
+
+            match dialoguer::Confirm::new()
+                .with_prompt(prompt)
+                .default(false)
+                .interact()
+            {
+                Ok(true) => ControlFlow::Continue(()),
+                Ok(false) => ControlFlow::Break(()),
+                Err(e) => {
+                    tracing::error!(
+                        error = &e as &dyn std::error::Error,
+                        "Unable to check whether the user wants to change the package's privacy",
+                    );
+                    ControlFlow::Break(())
+                }
+            }
+        }
+
+        fn on_package_privacy_changed(
+            &mut self,
+            manifest: &wasmer_toml::Manifest,
+        ) -> ControlFlow<(), ()> {
+            let privacy = if manifest.package.private {
+                "private"
+            } else {
+                "public"
+            };
+            let prompt =
+                format!("This will make the package {privacy}. Would you like to continue?");
+
+            match dialoguer::Confirm::new()
+                .with_prompt(prompt)
+                .default(false)
+                .interact()
+            {
+                Ok(true) => ControlFlow::Continue(()),
+                Ok(false) => ControlFlow::Break(()),
+                Err(e) => {
+                    tracing::error!(
+                        error = &e as &dyn std::error::Error,
+                        "Unable to check whether the user wants to change the package's privacy",
+                    );
+                    ControlFlow::Break(())
+                }
+            }
+        }
+    }
+
+    #[derive(Debug, Default, Copy, Clone, PartialEq)]
+    pub(crate) struct NonInteractive;
+
+    impl ValidationPolicy for NonInteractive {
+        fn skip_validation(&mut self) -> bool {
+            false
+        }
+
+        fn on_invalid_module(
+            &mut self,
+            _module: &wasmer_toml::Module,
+            _error: &ValidationError,
+        ) -> ControlFlow<(), ()> {
+            ControlFlow::Break(())
+        }
+
+        fn on_package_privacy_changed(
+            &mut self,
+            _manifest: &wasmer_toml::Manifest,
+        ) -> ControlFlow<(), ()> {
+            ControlFlow::Break(())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Read;
+
+    use super::*;
+
+    #[test]
+    fn test_construct_package_tar_gz() {
+        let manifest_str = r#"[package]
+name = "wasmer-tests/wcgi-always-panic"
+version = "0.6.0"
+description = "wasmer-tests/wcgi-always-panic website"
+
+[[module]]
+name = "wcgi-always-panic"
+source = "module.wasm"
+abi = "wasi"
+
+[[command]]
+name = "wcgi"
+module = "wcgi-always-panic"
+runner = "https://webc.org/runner/wcgi"
+"#;
+
+        let archive_dir = tempfile::tempdir().unwrap();
+
+        let manifest_dir = tempfile::tempdir().unwrap();
+
+        let mp = manifest_dir.path();
+        let manifest_path = mp.join("wasmer.toml");
+
+        std::fs::write(&manifest_path, manifest_str).unwrap();
+        std::fs::write(mp.join("module.wasm"), "()").unwrap();
+
+        let manifest = wasmer_toml::Manifest::parse(manifest_str).unwrap();
+
+        let meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path).unwrap();
+
+        let mut data = std::io::Cursor::new(std::fs::read(meta.archive_path).unwrap());
+
+        let gz = flate2::read::GzDecoder::new(&mut data);
+        let mut archive = tar::Archive::new(gz);
+
+        let map = archive
+            .entries()
+            .unwrap()
+            .map(|res| {
+                let mut entry = res.unwrap();
+                let name = entry.path().unwrap().to_str().unwrap().to_string();
+                let mut contents = String::new();
+                entry.read_to_string(&mut contents).unwrap();
+                eprintln!("{name}:\n{contents}\n\n");
+                (name, contents)
+            })
+            .collect::<std::collections::HashMap<String, String>>();
+
+        let expected: std::collections::HashMap<String, String> = [
+            ("wapm.toml".to_string(), manifest_str.to_string()),
+            ("module.wasm".to_string(), "()".to_string()),
+        ]
+        .into_iter()
+        .collect();
+
+        pretty_assertions::assert_eq!(map, expected);
+    }
+
+    #[test]
+    fn test_construct_wai_package_tar_gz() {
+        let manifest_str = r#"[package]
+name = "wasmer/crumsort-wasm"
+version = "0.2.4"
+description = "Crumsort from Google made for WASM"
+
+[[module]]
+name = "crumsort-wasm"
+source = "crumsort_wasm.wasm"
+
+[module.bindings]
+wai-version = "0.2.0"
+exports = "crum-sort.wai"
+"#;
+
+        let archive_dir = tempfile::tempdir().unwrap();
+
+        let manifest_dir = tempfile::tempdir().unwrap();
+
+        let mp = manifest_dir.path();
+        let manifest_path = mp.join("wasmer.toml");
+
+        std::fs::write(&manifest_path, manifest_str).unwrap();
+        std::fs::write(mp.join("crumsort_wasm.wasm"), "()").unwrap();
+        std::fs::write(mp.join("crum-sort.wai"), "/// crum-sort.wai").unwrap();
+
+        let manifest = wasmer_toml::Manifest::parse(manifest_str).unwrap();
+        let meta = construct_tar_gz(archive_dir.path(), &manifest, &manifest_path).unwrap();
+
+        let mut data = std::io::Cursor::new(std::fs::read(meta.archive_path).unwrap());
+
+        let gz = flate2::read::GzDecoder::new(&mut data);
+        let mut archive = tar::Archive::new(gz);
+
+        let map = archive
+            .entries()
+            .unwrap()
+            .map(|res| {
+                let mut entry = res.unwrap();
+                let name = entry.path().unwrap().to_str().unwrap().to_string();
+                let mut contents = String::new();
+                entry.read_to_string(&mut contents).unwrap();
+                eprintln!("{name}:\n{contents}\n\n");
+                (name, contents)
+            })
+            .collect::<std::collections::HashMap<String, String>>();
+
+        let expected: std::collections::HashMap<String, String> = [
+            ("wapm.toml".to_string(), manifest_str.to_string()),
+            ("crum-sort.wai".to_string(), "/// crum-sort.wai".to_string()),
+            ("crumsort_wasm.wasm".to_string(), "()".to_string()),
+        ]
+        .into_iter()
+        .collect();
+
+        pretty_assertions::assert_eq!(map, expected);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/mod.rs
new file mode 100644
index 0000000..7296c0f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/mod.rs
@@ -0,0 +1,190 @@
+#[cfg(feature = "build-package")]
+pub mod builder;
+
+use crate::WasmerConfig;
+use regex::Regex;
+use std::path::{Path, PathBuf};
+use std::{fmt, str::FromStr};
+use url::Url;
+
+const REGEX_PACKAGE_WITH_VERSION: &str =
+    r"^([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)(@([a-zA-Z0-9\.\-_]+*))?$";
+
+lazy_static::lazy_static! {
+    static ref PACKAGE_WITH_VERSION: Regex = regex::Regex::new(REGEX_PACKAGE_WITH_VERSION).unwrap();
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Package {
+    pub namespace: String,
+    pub name: String,
+    pub version: Option<String>,
+}
+
+impl fmt::Display for Package {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.file())
+    }
+}
+
+impl Package {
+    /// Checks whether the package is already installed, if yes, returns the path to the root dir
+    pub fn already_installed(&self, wasmer_dir: &Path) -> Option<PathBuf> {
+        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
+        let config = WasmerConfig::from_file(wasmer_dir).ok()?;
+        let current_registry = config.registry.get_current_registry();
+        let hash = self.get_hash(&current_registry);
+
+        let found = std::fs::read_dir(&checkouts_dir)
+            .ok()?
+            .filter_map(|e| Some(e.ok()?.file_name().to_str()?.to_string()))
+            .find(|s| match self.version.as_ref() {
+                None => s.contains(&hash),
+                Some(v) => s.contains(&hash) && s.ends_with(v),
+            })?;
+        Some(checkouts_dir.join(found))
+    }
+
+    /// Checks if the URL is already installed, note that `{url}@{version}`
+    /// and `{url}` are treated the same
+    pub fn is_url_already_installed(url: &Url, wasmer_dir: &Path) -> Option<PathBuf> {
+        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
+
+        let url_string = url.to_string();
+        let (url, version) = match url_string.split('@').collect::<Vec<_>>()[..] {
+            [url, version] => (url.to_string(), Some(version)),
+            _ => (url_string, None),
+        };
+        let hash = Self::hash_url(&url);
+        let found = std::fs::read_dir(&checkouts_dir)
+            .ok()?
+            .filter_map(|e| Some(e.ok()?.file_name().to_str()?.to_string()))
+            .find(|s| match version.as_ref() {
+                None => s.contains(&hash),
+                Some(v) => s.contains(&hash) && s.ends_with(v),
+            })?;
+        Some(checkouts_dir.join(found))
+    }
+
+    /// Returns the hash of the URL with a maximum of 128 bytes length
+    /// (necessary for not erroring on filesystem limitations)
+    pub fn hash_url(url: &str) -> String {
+        hex::encode(url).chars().take(128).collect()
+    }
+
+    /// Returns the hash of the URL with a maximum of 64 bytes length
+    pub fn unhash_url(hashed: &str) -> String {
+        String::from_utf8_lossy(&hex::decode(hashed).unwrap_or_default()).to_string()
+    }
+
+    /// Returns the hash of the package URL without the version
+    /// (because the version is encoded as @version and isn't part of the hash itself)
+    pub fn get_hash(&self, registry: &str) -> String {
+        let url = self.get_url_without_version(registry);
+        Self::hash_url(&url.unwrap_or_default())
+    }
+
+    fn get_url_without_version(&self, registry: &str) -> Result<String, anyhow::Error> {
+        let url = self.url(registry);
+        Ok(format!(
+            "{}/{}/{}",
+            url?.origin().ascii_serialization(),
+            self.namespace,
+            self.name
+        ))
+    }
+
+    /// Returns the filename for this package
+    pub fn file(&self) -> String {
+        let version = self
+            .version
+            .as_ref()
+            .map(|f| format!("@{f}"))
+            .unwrap_or_default();
+        format!("{}/{}{version}", self.namespace, self.name)
+    }
+
+    /// Returns the {namespace}/{name} package name
+    pub fn package(&self) -> String {
+        format!("{}/{}", self.namespace, self.name)
+    }
+
+    /// Returns the full URL including the version for this package
+    pub fn url(&self, registry: &str) -> Result<Url, anyhow::Error> {
+        let registry_tld = tldextract::TldExtractor::new(tldextract::TldOption::default())
+            .extract(registry)
+            .map_err(|e| anyhow::anyhow!("Invalid registry: {}: {e}", registry))?;
+
+        let registry_tld = format!(
+            "{}.{}",
+            registry_tld.domain.as_deref().unwrap_or(""),
+            registry_tld.suffix.as_deref().unwrap_or(""),
+        );
+
+        let version = self
+            .version
+            .as_ref()
+            .map(|f| format!("@{f}"))
+            .unwrap_or_default();
+        let url = format!(
+            "https://{registry_tld}/{}/{}{version}",
+            self.namespace, self.name
+        );
+        url::Url::parse(&url).map_err(|e| anyhow::anyhow!("error parsing {url}: {e}"))
+    }
+
+    /// Returns the path to the installation directory.
+    /// Does not check whether the installation directory already exists.
+    pub fn get_path(&self, wasmer_dir: &Path) -> Result<PathBuf, anyhow::Error> {
+        let checkouts_dir = crate::get_checkouts_dir(wasmer_dir);
+        let config = WasmerConfig::from_file(wasmer_dir)
+            .map_err(|e| anyhow::anyhow!("could not load config {e}"))?;
+        let hash = self.get_hash(&config.registry.get_current_registry());
+
+        match self.version.as_ref() {
+            Some(v) => Ok(checkouts_dir.join(format!("{}@{}", hash, v))),
+            None => Ok(checkouts_dir.join(&hash)),
+        }
+    }
+}
+
+impl FromStr for Package {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let captures = PACKAGE_WITH_VERSION
+            .captures(s.trim())
+            .map(|c| {
+                c.iter()
+                    .flatten()
+                    .map(|m| m.as_str().to_owned())
+                    .collect::<Vec<_>>()
+            })
+            .unwrap_or_default();
+
+        match captures.len() {
+            // namespace/package
+            3 => {
+                let namespace = captures[1].to_string();
+                let name = captures[2].to_string();
+                Ok(Package {
+                    namespace,
+                    name,
+                    version: None,
+                })
+            }
+            // namespace/package@version
+            5 => {
+                let namespace = captures[1].to_string();
+                let name = captures[2].to_string();
+                let version = captures[4].to_string();
+                Ok(Package {
+                    namespace,
+                    name,
+                    version: Some(version),
+                })
+            }
+            other => Err(anyhow::anyhow!("invalid package {other}")),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0000.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0000.sql
new file mode 100644
index 0000000..a527dbc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0000.sql
@@ -0,0 +1,27 @@
+CREATE TABLE personal_keys
+(
+  id integer primary key,
+  active integer not null,
+  public_key_id text not null UNIQUE,
+  public_key_value text not null UNIQUE,
+  private_key_location text UNIQUE,
+  key_type_identifier text not null,
+  date_added text not null
+);
+
+CREATE TABLE wapm_users
+(
+  id integer primary key,
+  name text not null UNIQUE
+);
+
+CREATE TABLE wapm_public_keys
+(
+  id integer primary key,
+  public_key_id text not null UNIQUE,
+  user_key integer not null,
+  public_key_value text not null UNIQUE,
+  key_type_identifier text not null,
+  date_added text not null,
+  FOREIGN KEY(user_key) REFERENCES wapm_users(id)
+);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0001.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0001.sql
new file mode 100644
index 0000000..4258731
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0001.sql
@@ -0,0 +1,9 @@
+CREATE TABLE wasm_contracts
+(
+  id integer primary key,
+  contract_name text not null,
+  version text not null,
+  date_added text not null,
+  content text not null,
+  CONSTRAINT name_version_unique UNIQUE (contract_name, version)
+);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0002.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0002.sql
new file mode 100644
index 0000000..cc57ff9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/migrations/0002.sql
@@ -0,0 +1,26 @@
+PRAGMA foreign_keys=off;
+
+CREATE TABLE wasm_interfaces
+(
+  id integer primary key,
+  interface_name text not null,
+  version text not null,
+  date_added text not null,
+  content text not null,
+  CONSTRAINT name_version_unique UNIQUE (interface_name, version)
+);
+
+INSERT INTO wasm_interfaces
+(
+  id,
+  interface_name,
+  version,
+  date_added,
+  content
+)
+  SELECT id, contract_name, version, date_added, content
+  FROM wasm_contracts;
+
+DROP TABLE wasm_contracts;
+
+PRAGMA foreign_keys=on;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/get_interface.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/get_interface.sql
new file mode 100644
index 0000000..8dffff7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/get_interface.sql
@@ -0,0 +1,4 @@
+SELECT content
+FROM wasm_interfaces
+WHERE interface_name = (?1)
+  AND version = (?2)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/insert_interface.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/insert_interface.sql
new file mode 100644
index 0000000..b1f9967
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/insert_interface.sql
@@ -0,0 +1,3 @@
+INSERT INTO wasm_interfaces
+(interface_name, version, date_added, content)
+VALUES (?1, ?2, ?3, ?4)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql
new file mode 100644
index 0000000..d00f31e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/package/sql/queries/wasm_interface_existence_check.sql
@@ -0,0 +1,5 @@
+SELECT 1
+FROM wasm_interfaces
+WHERE interface_name = (?1) 
+   AND version = (?2)
+LIMIT 1
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/publish.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/publish.rs
new file mode 100644
index 0000000..433e855
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/publish.rs
@@ -0,0 +1,501 @@
+use crate::graphql::queries::get_signed_url::GetSignedUrlUrl;
+
+use crate::graphql::subscriptions::package_version_ready::PackageVersionState;
+use crate::graphql::{
+    mutations::{publish_package_mutation_chunked, PublishPackageMutationChunked},
+    queries::{get_signed_url, GetSignedUrl},
+};
+use crate::subscriptions::subscribe_package_version_ready;
+use crate::{format_graphql, WasmerConfig};
+use anyhow::{Context, Result};
+use console::{style, Emoji};
+use futures_util::StreamExt;
+use graphql_client::GraphQLQuery;
+use indicatif::{MultiProgress, ProgressBar, ProgressState, ProgressStyle};
+use std::collections::BTreeMap;
+use std::fmt::Write;
+use std::io::BufRead;
+use std::path::PathBuf;
+use std::sync::{Arc, Mutex};
+use std::thread;
+use std::time::Duration;
+
+static UPLOAD: Emoji<'_, '_> = Emoji("⬆️ ", "");
+static PACKAGE: Emoji<'_, '_> = Emoji("📦", "");
+
+/// Different conditions that can be "awaited" when publishing a package.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct PublishWait {
+    pub container: bool,
+    pub native_executables: bool,
+    pub bindings: bool,
+
+    pub timeout: Option<Duration>,
+}
+
+impl PublishWait {
+    pub fn is_any(self) -> bool {
+        self.container || self.native_executables || self.bindings
+    }
+
+    pub fn new_none() -> Self {
+        Self {
+            container: false,
+            native_executables: false,
+            bindings: false,
+            timeout: None,
+        }
+    }
+
+    pub fn new_all() -> Self {
+        Self {
+            container: true,
+            native_executables: true,
+            bindings: true,
+            timeout: None,
+        }
+    }
+
+    pub fn new_container() -> Self {
+        Self {
+            container: true,
+            native_executables: false,
+            bindings: false,
+            timeout: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum SignArchiveResult {
+    Ok {
+        public_key_id: String,
+        signature: String,
+    },
+    NoKeyRegistered,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn try_chunked_uploading(
+    registry: Option<String>,
+    token: Option<String>,
+    package: &wasmer_toml::Package,
+    manifest_string: &String,
+    license_file: &Option<String>,
+    readme: &Option<String>,
+    archive_name: &String,
+    archive_path: &PathBuf,
+    maybe_signature_data: &SignArchiveResult,
+    archived_data_size: u64,
+    quiet: bool,
+    wait: PublishWait,
+    timeout: Duration,
+) -> Result<(), anyhow::Error> {
+    let (registry, token) = initialize_registry_and_token(registry, token)?;
+
+    let maybe_signature_data = sign_package(maybe_signature_data);
+
+    // fetch this before showing the `Uploading...` message
+    // because there is a chance that the registry may not return a signed url.
+    // This usually happens if the package version already exists in the registry.
+    let signed_url = google_signed_url(&registry, &token, package, timeout)?;
+
+    if !quiet {
+        println!("{} {} Uploading...", style("[1/2]").bold().dim(), UPLOAD);
+    }
+    upload_package(&signed_url.url, archive_path, archived_data_size, timeout)?;
+
+    if !quiet {
+        println!("{} {} Publishing...", style("[2/2]").bold().dim(), PACKAGE);
+    }
+
+    let q =
+        PublishPackageMutationChunked::build_query(publish_package_mutation_chunked::Variables {
+            name: package.name.to_string(),
+            version: package.version.to_string(),
+            description: package.description.clone(),
+            manifest: manifest_string.to_string(),
+            license: package.license.clone(),
+            license_file: license_file.to_owned(),
+            readme: readme.to_owned(),
+            repository: package.repository.clone(),
+            homepage: package.homepage.clone(),
+            file_name: Some(archive_name.to_string()),
+            signature: maybe_signature_data,
+            signed_url: Some(signed_url.url),
+            private: Some(package.private),
+            wait: Some(wait.is_any()),
+        });
+
+    let response: publish_package_mutation_chunked::ResponseData =
+        crate::graphql::execute_query_with_timeout(&registry, &token, timeout, &q)?;
+
+    if let Some(pkg) = response.publish_package {
+        if !pkg.success {
+            return Err(anyhow::anyhow!("Could not publish package"));
+        }
+        if wait.is_any() {
+            let f = wait_for_package_version_to_become_ready(
+                &registry,
+                &token,
+                pkg.package_version.id,
+                quiet,
+                wait,
+            );
+
+            if let Ok(handle) = tokio::runtime::Handle::try_current() {
+                handle.block_on(f)?
+            } else {
+                tokio::runtime::Runtime::new().unwrap().block_on(f)?;
+            }
+        }
+    }
+
+    println!(
+        "🚀 Successfully published package `{}@{}`",
+        package.name, package.version,
+    );
+
+    Ok(())
+}
+
+fn initialize_registry_and_token(
+    registry: Option<String>,
+    token: Option<String>,
+) -> Result<(String, String), anyhow::Error> {
+    let registry = match registry.as_ref() {
+        Some(s) => format_graphql(s),
+        None => {
+            let wasmer_dir = WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("{e}"))?;
+
+            let config = WasmerConfig::from_file(&wasmer_dir);
+
+            config
+                .map_err(|e| anyhow::anyhow!("{e}"))?
+                .registry
+                .get_current_registry()
+        }
+    };
+
+    let token = match token.as_ref() {
+        Some(s) => s.to_string(),
+        None => {
+            let wasmer_dir = WasmerConfig::get_wasmer_dir().map_err(|e| anyhow::anyhow!("{e}"))?;
+
+            let config = WasmerConfig::from_file(&wasmer_dir);
+
+            config
+                .map_err(|e| anyhow::anyhow!("{e}"))?
+                .registry
+                .get_login_token_for_registry(&registry)
+                .ok_or_else(|| {
+                    anyhow::anyhow!("cannot publish package: not logged into registry {registry:?}")
+                })?
+        }
+    };
+
+    Ok((registry, token))
+}
+
+fn sign_package(
+    maybe_signature_data: &SignArchiveResult,
+) -> Option<publish_package_mutation_chunked::InputSignature> {
+    match maybe_signature_data {
+        SignArchiveResult::Ok {
+            public_key_id,
+            signature,
+        } => {
+            log::info!(
+                "Package successfully signed with public key: \"{}\"!",
+                &public_key_id
+            );
+            Some(publish_package_mutation_chunked::InputSignature {
+                public_key_key_id: public_key_id.to_string(),
+                data: signature.to_string(),
+            })
+        }
+        SignArchiveResult::NoKeyRegistered => {
+            // TODO: uncomment this when we actually want users to start using it
+            //warn!("Publishing package without a verifying signature. Consider registering a key pair with wasmer");
+            None
+        }
+    }
+}
+
+fn google_signed_url(
+    registry: &str,
+    token: &str,
+    package: &wasmer_toml::Package,
+    timeout: Duration,
+) -> Result<GetSignedUrlUrl, anyhow::Error> {
+    let get_google_signed_url = GetSignedUrl::build_query(get_signed_url::Variables {
+        name: package.name.to_string(),
+        version: package.version.to_string(),
+        expires_after_seconds: Some(60 * 30),
+    });
+
+    let _response: get_signed_url::ResponseData = crate::graphql::execute_query_with_timeout(
+        registry,
+        token,
+        timeout,
+        &get_google_signed_url,
+    )?;
+
+    let url = _response.url.ok_or_else(|| {
+        anyhow::anyhow!(
+            "could not get signed url for package {}@{}",
+            package.name,
+            package.version
+        )
+    })?;
+    Ok(url)
+}
+
+fn upload_package(
+    signed_url: &str,
+    archive_path: &PathBuf,
+    archived_data_size: u64,
+    timeout: Duration,
+) -> Result<(), anyhow::Error> {
+    let url = url::Url::parse(signed_url).context("cannot parse signed url")?;
+    let client = reqwest::blocking::Client::builder()
+        .default_headers(reqwest::header::HeaderMap::default())
+        .timeout(timeout)
+        .build()
+        .unwrap();
+
+    let res = client
+        .post(url)
+        .header(reqwest::header::CONTENT_LENGTH, "0")
+        .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+        .header("x-goog-resumable", "start");
+
+    let result = res.send().unwrap();
+
+    if result.status() != reqwest::StatusCode::from_u16(201).unwrap() {
+        return Err(anyhow::anyhow!(
+            "Uploading package failed: got HTTP {:?} when uploading",
+            result.status()
+        ));
+    }
+
+    let headers = result
+        .headers()
+        .into_iter()
+        .filter_map(|(k, v)| {
+            let k = k.to_string();
+            let v = v.to_str().ok()?.to_string();
+            Some((k.to_lowercase(), v))
+        })
+        .collect::<BTreeMap<_, _>>();
+
+    let session_uri = headers.get("location").unwrap().clone();
+
+    let total = archived_data_size;
+
+    // archive_path
+    let mut file = std::fs::OpenOptions::new()
+        .read(true)
+        .open(archive_path)
+        .map_err(|e| anyhow::anyhow!("cannot open archive {}: {e}", archive_path.display()))?;
+
+    let pb = ProgressBar::new(archived_data_size);
+    pb.set_style(ProgressStyle::with_template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {bytes}/{total_bytes} ({eta})")
+    .unwrap()
+    .with_key("eta", |state: &ProgressState, w: &mut dyn Write| {
+        write!(w, "{:.1}s", state.eta().as_secs_f64()).unwrap()
+    })
+    .progress_chars("#>-"));
+
+    let chunk_size = 1_048_576; // 1MB - 315s / 100MB
+    let mut file_pointer = 0;
+
+    let mut reader = std::io::BufReader::with_capacity(chunk_size, &mut file);
+
+    let client = reqwest::blocking::Client::builder()
+        .default_headers(reqwest::header::HeaderMap::default())
+        .build()
+        .unwrap();
+
+    while let Some(chunk) = reader.fill_buf().ok().map(|s| s.to_vec()) {
+        let n = chunk.len();
+
+        if chunk.is_empty() {
+            break;
+        }
+
+        let start = file_pointer;
+        let end = file_pointer + chunk.len().saturating_sub(1);
+        let content_range = format!("bytes {start}-{end}/{total}");
+
+        let res = client
+            .put(&session_uri)
+            .header(reqwest::header::CONTENT_TYPE, "application/octet-stream")
+            .header(reqwest::header::CONTENT_LENGTH, format!("{}", chunk.len()))
+            .header("Content-Range".to_string(), content_range)
+            .body(chunk.to_vec());
+
+        pb.set_position(file_pointer as u64);
+
+        res.send()
+            .map(|response| response.error_for_status())
+            .map_err(|e| {
+                anyhow::anyhow!(
+                    "cannot send request to {session_uri} (chunk {}..{}): {e}",
+                    file_pointer,
+                    file_pointer + chunk_size
+                )
+            })??;
+
+        if n < chunk_size {
+            break;
+        }
+
+        reader.consume(n);
+        file_pointer += n;
+    }
+
+    pb.finish_and_clear();
+    Ok(())
+}
+
+struct PackageVersionReadySharedState {
+    webc_generated: Arc<Mutex<Option<bool>>>,
+    bindings_generated: Arc<Mutex<Option<bool>>>,
+    native_exes_generated: Arc<Mutex<Option<bool>>>,
+}
+
+impl PackageVersionReadySharedState {
+    fn new() -> Self {
+        Self {
+            webc_generated: Arc::new(Mutex::new(Option::None)),
+            bindings_generated: Arc::new(Mutex::new(Option::None)),
+            native_exes_generated: Arc::new(Mutex::new(Option::None)),
+        }
+    }
+}
+
+fn create_spinner(m: &MultiProgress, message: String) -> ProgressBar {
+    let spinner = m.add(ProgressBar::new_spinner());
+    spinner.set_message(message);
+    spinner.set_style(ProgressStyle::default_spinner());
+    spinner.enable_steady_tick(Duration::from_millis(100));
+    spinner
+}
+
+fn show_spinners_while_waiting(state: &PackageVersionReadySharedState) {
+    // Clone shared state for threads
+    let (state_webc, state_bindings, state_native) = (
+        Arc::clone(&state.webc_generated),
+        Arc::clone(&state.bindings_generated),
+        Arc::clone(&state.native_exes_generated),
+    );
+    let m = MultiProgress::new();
+
+    let webc_spinner = create_spinner(&m, String::from("Generating WEBC..."));
+    let bindings_spinner = create_spinner(&m, String::from("Generating language bindings..."));
+    let exe_spinner = create_spinner(&m, String::from("Generating native executables..."));
+
+    let check_and_finish = |spinner: ProgressBar, state: Arc<Mutex<Option<bool>>>, name: String| {
+        thread::spawn(move || loop {
+            match state.lock() {
+                Ok(lock) => {
+                    if lock.is_some() {
+                        spinner.finish_with_message(format!("✅ {} generation complete", name));
+                        break;
+                    }
+                }
+                Err(_) => {
+                    break;
+                }
+            }
+            thread::sleep(Duration::from_millis(100));
+        });
+    };
+    check_and_finish(webc_spinner, state_webc, String::from("WEBC"));
+    check_and_finish(
+        bindings_spinner,
+        state_bindings,
+        String::from("Language bindings"),
+    );
+    check_and_finish(
+        exe_spinner,
+        state_native,
+        String::from("Native executables"),
+    );
+}
+
+async fn wait_for_package_version_to_become_ready(
+    registry: &str,
+    token: &str,
+    package_version_id: impl AsRef<str>,
+    quiet: bool,
+    mut conditions: PublishWait,
+) -> Result<()> {
+    let (mut stream, _client) =
+        subscribe_package_version_ready(registry, token, package_version_id.as_ref()).await?;
+
+    let state = PackageVersionReadySharedState::new();
+
+    if !quiet {
+        show_spinners_while_waiting(&state);
+    }
+
+    if !conditions.is_any() {
+        return Ok(());
+    }
+
+    let deadline = conditions
+        .timeout
+        .map(|x| std::time::Instant::now() + x)
+        .unwrap_or_else(|| std::time::Instant::now() + std::time::Duration::from_secs(60 * 10));
+
+    loop {
+        if !conditions.is_any() {
+            break;
+        }
+        if std::time::Instant::now() > deadline {
+            return Err(anyhow::anyhow!(
+                "Timed out waiting for package version to become ready"
+            ));
+        }
+
+        let data = match tokio::time::timeout_at(deadline.into(), stream.next()).await {
+            Err(_) => {
+                return Err(anyhow::anyhow!(
+                    "Timed out waiting for package version to become ready"
+                ))
+            }
+            Ok(None) => {
+                break;
+            }
+            Ok(Some(data)) => data,
+        };
+
+        if let Some(res_data) = data.unwrap().data {
+            match res_data.package_version_ready.state {
+                PackageVersionState::BINDINGS_GENERATED => {
+                    let mut st = state.bindings_generated.lock().unwrap();
+                    let is_ready = res_data.package_version_ready.success;
+                    *st = Some(is_ready);
+                    conditions.bindings = false;
+                }
+                PackageVersionState::NATIVE_EXES_GENERATED => {
+                    let mut st = state.native_exes_generated.lock().unwrap();
+                    *st = Some(res_data.package_version_ready.success);
+
+                    conditions.native_executables = false;
+                }
+                PackageVersionState::WEBC_GENERATED => {
+                    let mut st = state.webc_generated.lock().unwrap();
+                    *st = Some(res_data.package_version_ready.success);
+
+                    conditions.container = false;
+                }
+                PackageVersionState::Other(_) => {}
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/subscriptions.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/subscriptions.rs
new file mode 100644
index 0000000..f310dd4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/subscriptions.rs
@@ -0,0 +1,86 @@
+use std::env;
+
+use crate::{
+    graphql::subscriptions::{package_version_ready, PackageVersionReady},
+    tokio_spawner::TokioSpawner,
+};
+
+use futures_util::StreamExt;
+
+use graphql_client::GraphQLQuery;
+use graphql_ws_client::{
+    graphql::{GraphQLClient, StreamingOperation},
+    GraphQLClientClient, SubscriptionStream,
+};
+
+use tokio_tungstenite::{
+    connect_async,
+    tungstenite::{client::IntoClientRequest, http::HeaderValue, Message},
+};
+
+async fn subscribe_graphql<Q: GraphQLQuery + Send + Sync + Unpin + 'static>(
+    registry_url: &str,
+    login_token: &str,
+    variables: Q::Variables,
+) -> anyhow::Result<(
+    SubscriptionStream<GraphQLClient, StreamingOperation<Q>>,
+    GraphQLClientClient<Message>,
+)>
+where
+    <Q as GraphQLQuery>::Variables: Send + Sync + Unpin,
+{
+    let mut url = url::Url::parse(registry_url).unwrap();
+    if url.scheme() == "http" {
+        url.set_scheme("ws").unwrap();
+    } else if url.scheme() == "https" {
+        url.set_scheme("wss").unwrap();
+    }
+
+    let mut req = url.into_client_request()?;
+    req.headers_mut().insert(
+        "Sec-WebSocket-Protocol",
+        HeaderValue::from_str("graphql-transport-ws")?,
+    );
+    let token = env::var("WASMER_TOKEN")
+        .ok()
+        .or_else(|| env::var("WAPM_REGISTRY_TOKEN").ok())
+        .unwrap_or_else(|| login_token.to_string());
+    req.headers_mut().insert(
+        reqwest::header::AUTHORIZATION,
+        HeaderValue::from_str(&format!("Bearer {}", token))?,
+    );
+    let user_agent = crate::client::RegistryClient::default_user_agent();
+    req.headers_mut().insert(
+        reqwest::header::USER_AGENT,
+        HeaderValue::from_str(&user_agent)?,
+    );
+    let (ws_con, _resp) = connect_async(req).await?;
+    let (sink, stream) = ws_con.split();
+
+    let mut client = graphql_ws_client::GraphQLClientClientBuilder::new()
+        .build(stream, sink, TokioSpawner::current())
+        .await?;
+    let stream = client
+        .streaming_operation(StreamingOperation::<Q>::new(variables))
+        .await?;
+
+    Ok((stream, client))
+}
+
+pub async fn subscribe_package_version_ready(
+    registry_url: &str,
+    login_token: &str,
+    package_version_id: &str,
+) -> anyhow::Result<(
+    SubscriptionStream<GraphQLClient, StreamingOperation<PackageVersionReady>>,
+    GraphQLClientClient<Message>,
+)> {
+    subscribe_graphql(
+        registry_url,
+        login_token,
+        package_version_ready::Variables {
+            package_version_id: package_version_id.to_string(),
+        },
+    )
+    .await
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/tokio_spawner.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/tokio_spawner.rs
new file mode 100644
index 0000000..d4937e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/tokio_spawner.rs
@@ -0,0 +1,22 @@
+#[derive(Debug)]
+pub struct TokioSpawner(tokio::runtime::Handle);
+
+impl TokioSpawner {
+    pub fn new(handle: tokio::runtime::Handle) -> Self {
+        TokioSpawner(handle)
+    }
+
+    pub fn current() -> Self {
+        TokioSpawner::new(tokio::runtime::Handle::current())
+    }
+}
+
+impl futures::task::Spawn for TokioSpawner {
+    fn spawn_obj(
+        &self,
+        obj: futures::task::FutureObj<'static, ()>,
+    ) -> Result<(), futures::task::SpawnError> {
+        self.0.spawn(obj);
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/types.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/types.rs
new file mode 100644
index 0000000..3db9a2b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/types.rs
@@ -0,0 +1,31 @@
+/// Payload for publishing a new Deploy app.
+#[derive(Clone, Debug)]
+pub struct PublishDeployAppRawVars {
+    /// Name for the app.
+    /// If not specified a random name will be generated.
+    pub name: Option<String>,
+
+    /// The namespace to deploy the app to.
+    ///
+    /// If not specified the app will be deployed under the current users
+    /// namespace.
+    pub namespace: Option<String>,
+
+    /// The raw DeployV1 configuration.
+    pub config: serde_json::Value,
+}
+
+/// Data for a deployed app.
+#[derive(Clone, Debug)]
+pub struct PublishDeployAppOutput {
+    pub app_id: String,
+    pub app_name: String,
+    pub version_id: String,
+    pub version_name: String,
+    pub owner_name: String,
+}
+
+#[derive(Clone, Debug)]
+pub struct NewNonceOutput {
+    pub auth_url: String,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/utils.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/utils.rs
new file mode 100644
index 0000000..a45ed23
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/utils.rs
@@ -0,0 +1,21 @@
+use crate::graphql::{
+    execute_query,
+    queries::{who_am_i_query, WhoAmIQuery},
+};
+use graphql_client::GraphQLQuery;
+
+pub fn get_username(registry: &str) -> anyhow::Result<Option<String>> {
+    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
+    let response: who_am_i_query::ResponseData = execute_query(registry, "", &q)?;
+    Ok(response.viewer.map(|viewer| viewer.username))
+}
+
+pub fn get_username_registry_token(registry: &str, token: &str) -> anyhow::Result<Option<String>> {
+    let q = WhoAmIQuery::build_query(who_am_i_query::Variables {});
+    let response: who_am_i_query::ResponseData = execute_query(registry, token, &q)?;
+    Ok(response.viewer.map(|viewer| viewer.username))
+}
+
+pub fn normalize_path(s: &str) -> String {
+    s.strip_prefix(r"\\?\").unwrap_or(s).to_string()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/registry/src/wasmer_env.rs b/arbitrator/tools/module_roots/wasmer/lib/registry/src/wasmer_env.rs
new file mode 100644
index 0000000..5ba7183
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/registry/src/wasmer_env.rs
@@ -0,0 +1,297 @@
+use std::path::{Path, PathBuf};
+
+use crate::WasmerConfig;
+use anyhow::{Context, Error};
+use url::Url;
+
+/// Command-line flags for determining the local "Wasmer Environment".
+///
+/// This is where you access `$WASMER_DIR`, the `$WASMER_DIR/wasmer.toml` config
+/// file, and specify the current registry.
+#[derive(Debug, Clone, PartialEq)]
+#[cfg_attr(feature = "clap", derive(clap::Parser))]
+pub struct WasmerEnv {
+    /// Set Wasmer's home directory
+    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_DIR", default_value = WASMER_DIR.as_os_str()))]
+    wasmer_dir: PathBuf,
+    /// The registry to fetch packages from (inferred from the environment by
+    /// default)
+    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_REGISTRY"))]
+    registry: Option<Registry>,
+    /// The directory cached artefacts are saved to.
+    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_CACHE_DIR"))]
+    cache_dir: Option<PathBuf>,
+    /// The API token to use when communicating with the registry (inferred from
+    /// the environment by default)
+    #[cfg_attr(feature = "clap", clap(long, env = "WASMER_TOKEN"))]
+    token: Option<String>,
+}
+
+impl WasmerEnv {
+    pub fn new(
+        wasmer_dir: PathBuf,
+        registry: Option<Registry>,
+        token: Option<String>,
+        cache_dir: Option<PathBuf>,
+    ) -> Self {
+        WasmerEnv {
+            wasmer_dir,
+            registry,
+            token,
+            cache_dir,
+        }
+    }
+
+    pub fn registry_public_url(&self) -> Result<Url, Error> {
+        let mut url = self.registry_endpoint()?;
+        url.set_path("");
+
+        let domain = url
+            .host_str()
+            .context("url has no host")?
+            .strip_prefix("registry.")
+            .context("could not derive registry public url")?
+            .to_string();
+        url.set_host(Some(&domain))
+            .context("could not derive registry public url")?;
+
+        Ok(url)
+    }
+
+    /// Get the GraphQL endpoint used to query the registry.
+    pub fn registry_endpoint(&self) -> Result<Url, Error> {
+        if let Some(registry) = &self.registry {
+            return registry.graphql_endpoint();
+        }
+
+        let config = self.config()?;
+        let url = config.registry.get_current_registry().parse()?;
+
+        Ok(url)
+    }
+
+    /// Load the current Wasmer config.
+    pub fn config(&self) -> Result<WasmerConfig, Error> {
+        WasmerConfig::from_file(self.dir())
+            .map_err(Error::msg)
+            .with_context(|| {
+                format!(
+                    "Unable to load the config from the \"{}\" directory",
+                    self.dir().display()
+                )
+            })
+    }
+
+    /// The directory all Wasmer artifacts are stored in.
+    pub fn dir(&self) -> &Path {
+        &self.wasmer_dir
+    }
+
+    /// The directory all cached artifacts should be saved to.
+    pub fn cache_dir(&self) -> PathBuf {
+        match &self.cache_dir {
+            Some(cache_dir) => cache_dir.clone(),
+            None => self.dir().join("cache"),
+        }
+    }
+
+    /// Retrieve the specified token.
+    ///
+    /// NOTE: In contrast to [`Self::token`], this will not fall back to loading
+    /// the token from the confg file.
+    pub fn get_token_opt(&self) -> Option<&str> {
+        self.token.as_deref()
+    }
+
+    /// The API token for the active registry.
+    pub fn token(&self) -> Option<String> {
+        if let Some(token) = &self.token {
+            return Some(token.clone());
+        }
+
+        // Fall back to the config file
+
+        let config = self.config().ok()?;
+        let registry_endpoint = self.registry_endpoint().ok()?;
+        config
+            .registry
+            .get_login_token_for_registry(registry_endpoint.as_str())
+    }
+}
+
+impl Default for WasmerEnv {
+    fn default() -> Self {
+        Self {
+            wasmer_dir: WASMER_DIR.clone(),
+            registry: None,
+            token: None,
+            cache_dir: None,
+        }
+    }
+}
+
+lazy_static::lazy_static! {
+    /// The default value for `$WASMER_DIR`.
+    pub static ref WASMER_DIR: PathBuf = match crate::WasmerConfig::get_wasmer_dir() {
+        Ok(path) => path,
+        Err(e) => {
+            if let Some(install_prefix) = option_env!("WASMER_INSTALL_PREFIX") {
+                return PathBuf::from(install_prefix);
+            }
+
+            panic!("Unable to determine the wasmer dir: {e}");
+        }
+    };
+}
+
+/// A registry as specified by the user.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Registry(String);
+
+impl Registry {
+    /// Get the [`Registry`]'s string representation.
+    pub fn as_str(&self) -> &str {
+        self.0.as_str()
+    }
+
+    /// Get the GraphQL endpoint for this [`Registry`].
+    pub fn graphql_endpoint(&self) -> Result<Url, Error> {
+        let url = crate::format_graphql(self.as_str()).parse()?;
+        Ok(url)
+    }
+}
+
+impl From<String> for Registry {
+    fn from(value: String) -> Self {
+        Registry(value)
+    }
+}
+
+impl From<&str> for Registry {
+    fn from(value: &str) -> Self {
+        Registry(value.to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+
+    use super::*;
+
+    const WASMER_TOML: &str = r#"
+    telemetry_enabled = false
+    update_notifications_enabled = false
+
+    [registry]
+    active_registry = "https://registry.wasmer.io/graphql"
+
+    [[registry.tokens]]
+    registry = "https://registry.wasmer.wtf/graphql"
+    token = "dev-token"
+
+    [[registry.tokens]]
+    registry = "https://registry.wasmer.io/graphql"
+    token = "prod-token"
+    "#;
+
+    #[test]
+    fn load_defaults_from_config() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
+
+        let env = WasmerEnv {
+            wasmer_dir: temp.path().to_path_buf(),
+            registry: None,
+            cache_dir: None,
+            token: None,
+        };
+
+        assert_eq!(
+            env.registry_endpoint().unwrap().as_str(),
+            "https://registry.wasmer.io/graphql"
+        );
+        assert_eq!(env.token().unwrap(), "prod-token");
+        assert_eq!(env.cache_dir(), temp.path().join("cache"));
+    }
+
+    #[test]
+    fn override_token() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
+
+        let env = WasmerEnv {
+            wasmer_dir: temp.path().to_path_buf(),
+            registry: None,
+            cache_dir: None,
+            token: Some("asdf".to_string()),
+        };
+
+        assert_eq!(
+            env.registry_endpoint().unwrap().as_str(),
+            "https://registry.wasmer.io/graphql"
+        );
+        assert_eq!(env.token().unwrap(), "asdf");
+        assert_eq!(env.cache_dir(), temp.path().join("cache"));
+    }
+
+    #[test]
+    fn override_registry() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
+        let env = WasmerEnv {
+            wasmer_dir: temp.path().to_path_buf(),
+            registry: Some(Registry::from("wasmer.wtf")),
+            cache_dir: None,
+            token: None,
+        };
+
+        assert_eq!(
+            env.registry_endpoint().unwrap().as_str(),
+            "https://registry.wasmer.wtf/graphql"
+        );
+        assert_eq!(env.token().unwrap(), "dev-token");
+        assert_eq!(env.cache_dir(), temp.path().join("cache"));
+    }
+
+    #[test]
+    fn override_registry_and_token() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
+
+        let env = WasmerEnv {
+            wasmer_dir: temp.path().to_path_buf(),
+            registry: Some(Registry::from("wasmer.wtf")),
+            cache_dir: None,
+            token: Some("asdf".to_string()),
+        };
+
+        assert_eq!(
+            env.registry_endpoint().unwrap().as_str(),
+            "https://registry.wasmer.wtf/graphql"
+        );
+        assert_eq!(env.token().unwrap(), "asdf");
+        assert_eq!(env.cache_dir(), temp.path().join("cache"));
+    }
+
+    #[test]
+    fn override_cache_dir() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("wasmer.toml"), WASMER_TOML).unwrap();
+        let expected_cache_dir = temp.path().join("some-other-cache");
+
+        let env = WasmerEnv {
+            wasmer_dir: temp.path().to_path_buf(),
+            registry: None,
+            cache_dir: Some(expected_cache_dir.clone()),
+            token: None,
+        };
+
+        assert_eq!(
+            env.registry_endpoint().unwrap().as_str(),
+            "https://registry.wasmer.io/graphql"
+        );
+        assert_eq!(env.token().unwrap(), "prod-token");
+        assert_eq!(env.cache_dir(), expected_cache_dir);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/Cargo.toml
new file mode 100644
index 0000000..5e3786c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/Cargo.toml
@@ -0,0 +1,31 @@
+[package]
+name = "wasmer-sys-utils"
+version = "0.18.3"
+description = "Wasmer utilities for a sys environment."
+categories = ["wasm"]
+keywords = ["wasm", "webassembly"]
+license = "MIT OR Apache-2.0 WITH LLVM-exception"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["sys", "compiler"] }
+wasmer-vm = { path = "../vm", version = "=4.2.8" }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+region = { version = "3.0" }
+tracing = "0.1.37"
+
+[target.'cfg(unix)'.dependencies]
+libc = { version = "^0.2", default-features = false }
+
+[dev-dependencies]
+wasmer-wasix = { path = "../wasix", version = "0.18.3" }
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["sys", "compiler", "cranelift"] }
+tracing-subscriber = { version = "0.3.16", features = ["fmt"] }
+tracing = "0.1.37"
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/lib.rs
new file mode 100644
index 0000000..d0e931c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/lib.rs
@@ -0,0 +1,2 @@
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+pub mod memory;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs
new file mode 100644
index 0000000..4bda17c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/fd_mmap.rs
@@ -0,0 +1,414 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use std::{
+    io::{self, Read, Write},
+    ptr, slice,
+};
+
+// /// Round `size` up to the nearest multiple of `page_size`.
+// fn round_up_to_page_size(size: usize, page_size: usize) -> usize {
+//     (size + (page_size - 1)) & !(page_size - 1)
+// }
+
+/// A simple struct consisting of a page-aligned pointer to page-aligned
+/// and initially-zeroed memory and a length.
+#[derive(Debug)]
+pub struct FdMmap {
+    // Note that this is stored as a `usize` instead of a `*const` or `*mut`
+    // pointer to allow this structure to be natively `Send` and `Sync` without
+    // `unsafe impl`. This type is sendable across threads and shareable since
+    // the coordination all happens at the OS layer.
+    ptr: usize,
+    len: usize,
+    // Backing file that will be closed when the memory mapping goes out of scope
+    fd: FdGuard,
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct FdGuard(pub i32);
+
+impl Default for FdGuard {
+    fn default() -> Self {
+        Self(-1)
+    }
+}
+
+impl Clone for FdGuard {
+    fn clone(&self) -> Self {
+        unsafe { Self(libc::dup(self.0)) }
+    }
+}
+
+impl Drop for FdGuard {
+    fn drop(&mut self) {
+        if self.0 >= 0 {
+            unsafe {
+                libc::close(self.0);
+            }
+            self.0 = -1;
+        }
+    }
+}
+
+impl FdMmap {
+    /// Construct a new empty instance of `Mmap`.
+    pub fn new() -> Self {
+        // Rust's slices require non-null pointers, even when empty. `Vec`
+        // contains code to create a non-null dangling pointer value when
+        // constructed empty, so we reuse that here.
+        let empty = Vec::<u8>::new();
+        Self {
+            ptr: empty.as_ptr() as usize,
+            len: 0,
+            fd: FdGuard::default(),
+        }
+    }
+
+    // /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory.
+    // pub fn with_at_least(size: usize) -> Result<Self, String> {
+    //     let page_size = region::page::size();
+    //     let rounded_size = round_up_to_page_size(size, page_size);
+    //     Self::accessible_reserved(rounded_size, rounded_size)
+    // }
+
+    /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory,
+    /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size`
+    /// must be native page-size multiples.
+    pub fn accessible_reserved(
+        accessible_size: usize,
+        mapping_size: usize,
+    ) -> Result<Self, String> {
+        let page_size = region::page::size();
+        assert!(accessible_size <= mapping_size);
+        assert_eq!(mapping_size & (page_size - 1), 0);
+        assert_eq!(accessible_size & (page_size - 1), 0);
+
+        // Mmap may return EINVAL if the size is zero, so just
+        // special-case that.
+        if mapping_size == 0 {
+            return Ok(Self::new());
+        }
+
+        // Open a temporary file (which is used for swapping)
+        let fd = unsafe {
+            let file = libc::tmpfile();
+            if file.is_null() {
+                return Err(format!(
+                    "failed to create temporary file - {}",
+                    io::Error::last_os_error()
+                ));
+            }
+            FdGuard(libc::fileno(file))
+        };
+
+        // First we initialize it with zeros
+        unsafe {
+            if libc::ftruncate(fd.0, mapping_size as libc::off_t) < 0 {
+                return Err("could not truncate tmpfile".to_string());
+            }
+        }
+
+        // Compute the flags
+        let flags = libc::MAP_FILE | libc::MAP_SHARED;
+
+        Ok(if accessible_size == mapping_size {
+            // Allocate a single read-write region at once.
+            let ptr = unsafe {
+                libc::mmap(
+                    ptr::null_mut(),
+                    mapping_size,
+                    libc::PROT_READ | libc::PROT_WRITE,
+                    flags,
+                    fd.0,
+                    0,
+                )
+            };
+            if ptr as isize == -1_isize {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            Self {
+                ptr: ptr as usize,
+                len: mapping_size,
+                fd,
+            }
+        } else {
+            // Reserve the mapping size.
+            let ptr = unsafe {
+                libc::mmap(
+                    ptr::null_mut(),
+                    mapping_size,
+                    libc::PROT_NONE,
+                    flags,
+                    fd.0,
+                    0,
+                )
+            };
+            if ptr as isize == -1_isize {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            let mut result = Self {
+                ptr: ptr as usize,
+                len: mapping_size,
+                fd,
+            };
+
+            if accessible_size != 0 {
+                // Commit the accessible size.
+                result.make_accessible(0, accessible_size)?;
+            }
+
+            result
+        })
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes accessible.
+    /// `start` and `len` must be native page-size multiples and describe a range within
+    /// `self`'s reserved memory.
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> {
+        let page_size = region::page::size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert!(len < self.len);
+        assert!(start < self.len - len);
+
+        // Commit the accessible size.
+        let ptr = self.ptr as *const u8;
+        unsafe { region::protect(ptr.add(start), len, region::Protection::READ_WRITE) }
+            .map_err(|e| e.to_string())
+    }
+
+    /// Return the allocated memory as a slice of u8.
+    pub fn as_slice(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }
+    }
+
+    /// Return the allocated memory as a mutable slice of u8.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, self.len) }
+    }
+
+    // /// Return the allocated memory as a pointer to u8.
+    // pub fn as_ptr(&self) -> *const u8 {
+    //     self.ptr as *const u8
+    // }
+
+    /// Return the allocated memory as a mutable pointer to u8.
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.ptr as *mut u8
+    }
+
+    /// Return the length of the allocated memory.
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    // /// Return whether any memory has been allocated.
+    // pub fn is_empty(&self) -> bool {
+    //     self.len() == 0
+    // }
+
+    /// Copies the memory to a new swap file (using copy-on-write if available)
+    pub fn duplicate(&mut self, hint_used: Option<usize>) -> Result<Self, String> {
+        // Empty memory is an edge case
+
+        use std::os::unix::prelude::FromRawFd;
+        if self.len == 0 {
+            return Ok(Self::new());
+        }
+
+        // First we sync all the data to the backing file
+        unsafe {
+            libc::fsync(self.fd.0);
+        }
+
+        // Open a new temporary file (which is used for swapping for the forked memory)
+        let fd = unsafe {
+            let file = libc::tmpfile();
+            if file.is_null() {
+                return Err(format!(
+                    "failed to create temporary file - {}",
+                    io::Error::last_os_error()
+                ));
+            }
+            FdGuard(libc::fileno(file))
+        };
+
+        // Attempt to do a shallow copy (needs a backing file system that supports it)
+        unsafe {
+            if libc::ioctl(fd.0, 0x94, 9, self.fd.0) != 0
+            // FICLONE
+            {
+                #[cfg(feature = "tracing")]
+                trace!("memory copy started");
+
+                // Determine host much to copy
+                let len = match hint_used {
+                    Some(a) => a,
+                    None => self.len,
+                };
+
+                // The shallow copy failed so we have to do it the hard way
+
+                let mut source = std::fs::File::from_raw_fd(self.fd.0);
+                let mut out = std::fs::File::from_raw_fd(fd.0);
+                copy_file_range(&mut source, 0, &mut out, 0, len)
+                    .map_err(|err| format!("Could not copy memory: {err}"))?;
+
+                #[cfg(feature = "tracing")]
+                trace!("memory copy finished (size={})", len);
+            }
+        }
+
+        // Compute the flags
+        let flags = libc::MAP_FILE | libc::MAP_SHARED;
+
+        // Allocate a single read-write region at once.
+        let ptr = unsafe {
+            libc::mmap(
+                ptr::null_mut(),
+                self.len,
+                libc::PROT_READ | libc::PROT_WRITE,
+                flags,
+                fd.0,
+                0,
+            )
+        };
+        if ptr as isize == -1_isize {
+            return Err(io::Error::last_os_error().to_string());
+        }
+
+        Ok(Self {
+            ptr: ptr as usize,
+            len: self.len,
+            fd,
+        })
+    }
+}
+
+impl Drop for FdMmap {
+    fn drop(&mut self) {
+        if self.len != 0 {
+            let r = unsafe { libc::munmap(self.ptr as *mut libc::c_void, self.len) };
+            assert_eq!(r, 0, "munmap failed: {}", io::Error::last_os_error());
+        }
+    }
+}
+
+/// Copy a range of a file to another file.
+// We could also use libc::copy_file_range on some systems, but it's
+// hard to do this because it is not available on many libc implementations.
+// (not on Mac OS, musl, ...)
+#[cfg(target_family = "unix")]
+fn copy_file_range(
+    source: &mut std::fs::File,
+    source_offset: u64,
+    out: &mut std::fs::File,
+    out_offset: u64,
+    len: usize,
+) -> Result<(), std::io::Error> {
+    use std::io::{Seek, SeekFrom};
+
+    let source_original_pos = source.stream_position()?;
+    source.seek(SeekFrom::Start(source_offset))?;
+
+    // TODO: don't cast with as
+
+    let out_original_pos = out.stream_position()?;
+    out.seek(SeekFrom::Start(out_offset))?;
+
+    // TODO: don't do this horrible "triple buffering" below".
+    // let mut reader = std::io::BufReader::new(source);
+
+    // TODO: larger buffer?
+    let mut buffer = vec![0u8; 4096];
+
+    let mut to_read = len;
+    while to_read > 0 {
+        let chunk_size = std::cmp::min(to_read, buffer.len());
+        let read = source.read(&mut buffer[0..chunk_size])?;
+        out.write_all(&buffer[0..read])?;
+        to_read -= read;
+    }
+
+    // Need to read the last chunk.
+    out.flush()?;
+
+    // Restore files to original position.
+    source.seek(SeekFrom::Start(source_original_pos))?;
+    out.flush()?;
+    out.sync_data()?;
+    out.seek(SeekFrom::Start(out_original_pos))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // #[test]
+    // fn test_round_up_to_page_size() {
+    //     assert_eq!(round_up_to_page_size(0, 4096), 0);
+    //     assert_eq!(round_up_to_page_size(1, 4096), 4096);
+    //     assert_eq!(round_up_to_page_size(4096, 4096), 4096);
+    //     assert_eq!(round_up_to_page_size(4097, 4096), 8192);
+    // }
+
+    #[cfg(target_family = "unix")]
+    #[test]
+    fn test_copy_file_range() -> Result<(), std::io::Error> {
+        // I know tempfile:: exists, but this doesn't bring in an extra
+        // dependency.
+
+        use std::{fs::OpenOptions, io::Seek};
+
+        let dir = std::env::temp_dir().join("wasmer/copy_file_range");
+        if dir.is_dir() {
+            std::fs::remove_dir_all(&dir).unwrap()
+        }
+        std::fs::create_dir_all(&dir).unwrap();
+
+        let pa = dir.join("a");
+        let pb = dir.join("b");
+
+        let data: Vec<u8> = (0..100).collect();
+        let mut a = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(&pa)
+            .unwrap();
+        a.write_all(&data).unwrap();
+
+        let datb: Vec<u8> = (100..200).collect();
+        let mut b = OpenOptions::new()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(&pb)
+            .unwrap();
+        b.write_all(&datb).unwrap();
+
+        a.seek(io::SeekFrom::Start(30)).unwrap();
+        b.seek(io::SeekFrom::Start(99)).unwrap();
+        copy_file_range(&mut a, 10, &mut b, 40, 15).unwrap();
+
+        assert_eq!(a.stream_position().unwrap(), 30);
+        assert_eq!(b.stream_position().unwrap(), 99);
+
+        b.seek(io::SeekFrom::Start(0)).unwrap();
+        let mut out = Vec::new();
+        let len = b.read_to_end(&mut out).unwrap();
+        assert_eq!(len, 100);
+        assert_eq!(out[0..40], datb[0..40]);
+        assert_eq!(out[40..55], data[10..25]);
+        assert_eq!(out[55..100], datb[55..100]);
+
+        // TODO: needs more variant tests, but this is enough for now.
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/memories.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/memories.rs
new file mode 100644
index 0000000..8868476
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/memories.rs
@@ -0,0 +1,658 @@
+//! Memory management for linear memories.
+//!
+//! `Memory` is to WebAssembly linear memories what `Table` is to WebAssembly tables.
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use std::{cell::UnsafeCell, convert::TryInto, ptr::NonNull, rc::Rc, sync::RwLock};
+
+use wasmer::{Bytes, MemoryError, MemoryType, Pages};
+use wasmer_types::{MemoryStyle, WASM_PAGE_SIZE};
+use wasmer_vm::{
+    LinearMemory, MaybeInstanceOwned, ThreadConditions, Trap, VMMemoryDefinition, WaiterError,
+};
+
+use super::fd_mmap::FdMmap;
+
+// use crate::trap::Trap;
+// use crate::{mmap::Mmap, store::MaybeInstanceOwned, vmcontext::VMMemoryDefinition};
+// use more_asserts::assert_ge;
+// use std::cell::UnsafeCell;
+// use std::convert::TryInto;
+// use std::ptr::NonNull;
+// use std::slice;
+// use std::sync::{Arc, RwLock};
+// use wasmer_types::{Bytes, MemoryError, MemoryStyle, MemoryType, Pages};
+
+// The memory mapped area
+#[derive(Debug)]
+struct WasmMmap {
+    // Our OS allocation of mmap'd memory.
+    alloc: FdMmap,
+    // The current logical size in wasm pages of this linear memory.
+    size: Pages,
+    /// The owned memory definition used by the generated code
+    vm_memory_definition: MaybeInstanceOwned<VMMemoryDefinition>,
+}
+
+impl WasmMmap {
+    fn get_vm_memory_definition(&self) -> NonNull<VMMemoryDefinition> {
+        self.vm_memory_definition.as_ptr()
+    }
+
+    fn size(&self) -> Pages {
+        unsafe {
+            let md_ptr = self.get_vm_memory_definition();
+            let md = md_ptr.as_ref();
+            Bytes::from(md.current_length).try_into().unwrap()
+        }
+    }
+
+    fn grow(&mut self, delta: Pages, conf: VMMemoryConfig) -> Result<Pages, MemoryError> {
+        // Optimization of memory.grow 0 calls.
+        if delta.0 == 0 {
+            return Ok(self.size);
+        }
+
+        let new_pages = self
+            .size
+            .checked_add(delta)
+            .ok_or(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            })?;
+        let prev_pages = self.size;
+
+        if let Some(maximum) = conf.maximum {
+            if new_pages > maximum {
+                return Err(MemoryError::CouldNotGrow {
+                    current: self.size,
+                    attempted_delta: delta,
+                });
+            }
+        }
+
+        // Wasm linear memories are never allowed to grow beyond what is
+        // indexable. If the memory has no maximum, enforce the greatest
+        // limit here.
+        if new_pages >= Pages::max_value() {
+            // Linear memory size would exceed the index range.
+            return Err(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            });
+        }
+
+        let delta_bytes = delta.bytes().0;
+        let prev_bytes = prev_pages.bytes().0;
+        let new_bytes = new_pages.bytes().0;
+
+        if new_bytes > self.alloc.len() - conf.offset_guard_size {
+            // If the new size is within the declared maximum, but needs more memory than we
+            // have on hand, it's a dynamic heap and it can move.
+            let guard_bytes = conf.offset_guard_size;
+            let request_bytes =
+                new_bytes
+                    .checked_add(guard_bytes)
+                    .ok_or_else(|| MemoryError::CouldNotGrow {
+                        current: new_pages,
+                        attempted_delta: Bytes(guard_bytes).try_into().unwrap(),
+                    })?;
+
+            let mut new_mmap = FdMmap::accessible_reserved(new_bytes, request_bytes)
+                .map_err(MemoryError::Region)?;
+
+            let copy_len = self.alloc.len() - conf.offset_guard_size;
+            new_mmap.as_mut_slice()[..copy_len].copy_from_slice(&self.alloc.as_slice()[..copy_len]);
+
+            self.alloc = new_mmap;
+        } else if delta_bytes > 0 {
+            // Make the newly allocated pages accessible.
+            self.alloc
+                .make_accessible(prev_bytes, delta_bytes)
+                .map_err(MemoryError::Region)?;
+        }
+
+        self.size = new_pages;
+
+        // update memory definition
+        unsafe {
+            let mut md_ptr = self.vm_memory_definition.as_ptr();
+            let md = md_ptr.as_mut();
+            md.current_length = new_pages.bytes().0;
+            md.base = self.alloc.as_mut_ptr() as _;
+        }
+
+        Ok(prev_pages)
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64, conf: VMMemoryConfig) -> Result<(), MemoryError> {
+        let cur_size = self.size.bytes().0 as u64;
+        if cur_size < min_size {
+            let growth = min_size - cur_size;
+            let growth_pages = ((growth - 1) / WASM_PAGE_SIZE as u64) + 1;
+            self.grow(Pages(growth_pages as u32), conf)?;
+        }
+
+        Ok(())
+    }
+
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.size.0 = 0;
+        Ok(())
+    }
+
+    /// Copies the memory
+    /// (in this case it performs a copy-on-write to save memory)
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        let mem_length = self.size.bytes().0;
+        let mut alloc = self
+            .alloc
+            .duplicate(Some(mem_length))
+            .map_err(MemoryError::Generic)?;
+        let base_ptr = alloc.as_mut_ptr();
+        Ok(Self {
+            vm_memory_definition: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(
+                VMMemoryDefinition {
+                    base: base_ptr,
+                    current_length: mem_length,
+                },
+            ))),
+            alloc,
+            size: self.size,
+        })
+    }
+}
+
+/// A linear memory instance.
+#[derive(Debug, Clone)]
+struct VMMemoryConfig {
+    // The optional maximum size in wasm pages of this linear memory.
+    maximum: Option<Pages>,
+    /// The WebAssembly linear memory description.
+    memory: MemoryType,
+    /// Our chosen implementation style.
+    style: MemoryStyle,
+    // Size in bytes of extra guard pages after the end to optimize loads and stores with
+    // constant offsets.
+    offset_guard_size: usize,
+}
+
+impl VMMemoryConfig {
+    fn ty(&self, minimum: Pages) -> MemoryType {
+        let mut out = self.memory;
+        out.minimum = minimum;
+
+        out
+    }
+
+    fn style(&self) -> MemoryStyle {
+        self.style
+    }
+}
+
+/// A linear memory instance.
+#[derive(Debug)]
+pub struct VMOwnedMemory {
+    // The underlying allocation.
+    mmap: WasmMmap,
+    // Configuration of this memory
+    config: VMMemoryConfig,
+}
+
+unsafe impl Send for VMOwnedMemory {}
+unsafe impl Sync for VMOwnedMemory {}
+
+impl VMOwnedMemory {
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        unsafe { Self::new_internal(memory, style, None) }
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Self::new_internal(memory, style, Some(vm_memory_location))
+    }
+
+    /// Build a `Memory` with either self-owned or VM owned metadata.
+    unsafe fn new_internal(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: Option<NonNull<VMMemoryDefinition>>,
+    ) -> Result<Self, MemoryError> {
+        if memory.minimum > Pages::max_value() {
+            return Err(MemoryError::MinimumMemoryTooLarge {
+                min_requested: memory.minimum,
+                max_allowed: Pages::max_value(),
+            });
+        }
+        // `maximum` cannot be set to more than `65536` pages.
+        if let Some(max) = memory.maximum {
+            if max > Pages::max_value() {
+                return Err(MemoryError::MaximumMemoryTooLarge {
+                    max_requested: max,
+                    max_allowed: Pages::max_value(),
+                });
+            }
+            if max < memory.minimum {
+                return Err(MemoryError::InvalidMemory {
+                    reason: format!(
+                        "the maximum ({} pages) is less than the minimum ({} pages)",
+                        max.0, memory.minimum.0
+                    ),
+                });
+            }
+        }
+
+        let offset_guard_bytes = style.offset_guard_size() as usize;
+
+        let minimum_pages = match style {
+            MemoryStyle::Dynamic { .. } => memory.minimum,
+            MemoryStyle::Static { bound, .. } => {
+                assert!(*bound >= memory.minimum);
+                *bound
+            }
+        };
+        let minimum_bytes = minimum_pages.bytes().0;
+        let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap();
+        let mapped_pages = memory.minimum;
+        let mapped_bytes = mapped_pages.bytes();
+
+        let mut alloc = FdMmap::accessible_reserved(mapped_bytes.0, request_bytes)
+            .map_err(MemoryError::Region)?;
+        let base_ptr = alloc.as_mut_ptr();
+        let mem_length = memory.minimum.bytes().0;
+        let mmap = WasmMmap {
+            vm_memory_definition: if let Some(mem_loc) = vm_memory_location {
+                {
+                    let mut ptr = mem_loc;
+                    let md = ptr.as_mut();
+                    md.base = base_ptr;
+                    md.current_length = mem_length;
+                }
+                MaybeInstanceOwned::Instance(mem_loc)
+            } else {
+                MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMMemoryDefinition {
+                    base: base_ptr,
+                    current_length: mem_length,
+                })))
+            },
+            alloc,
+            size: memory.minimum,
+        };
+
+        Ok(Self {
+            mmap,
+            config: VMMemoryConfig {
+                maximum: memory.maximum,
+                offset_guard_size: offset_guard_bytes,
+                memory: *memory,
+                style: *style,
+            },
+        })
+    }
+
+    /// Converts this owned memory into shared memory
+    pub fn to_shared(self) -> VMSharedMemory {
+        VMSharedMemory {
+            mmap: Rc::new(RwLock::new(self.mmap)),
+            config: self.config,
+            conditions: ThreadConditions::new(),
+        }
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        Ok(Self {
+            mmap: self.mmap.copy()?,
+            config: self.config.clone(),
+        })
+    }
+}
+
+impl LinearMemory for VMOwnedMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        let minimum = self.mmap.size();
+        self.config.ty(minimum)
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        self.mmap.size()
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.config.style()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        self.mmap.grow(delta, self.config.clone())
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        self.mmap.grow_at_least(min_size, self.config.clone())
+    }
+
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.mmap.reset()?;
+        Ok(())
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        self.mmap.vm_memory_definition.as_ptr()
+    }
+
+    /// Owned memory can not be cloned (this will always return None)
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        Err(MemoryError::MemoryNotShared)
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        let forked = Self::copy(self)?;
+        Ok(Box::new(forked))
+    }
+}
+
+/// A shared linear memory instance.
+#[derive(Debug, Clone)]
+pub struct VMSharedMemory {
+    // The underlying allocation.
+    mmap: Rc<RwLock<WasmMmap>>,
+    // Configuration of this memory
+    config: VMMemoryConfig,
+    conditions: ThreadConditions,
+}
+
+unsafe impl Send for VMSharedMemory {}
+unsafe impl Sync for VMSharedMemory {}
+
+impl VMSharedMemory {
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        Ok(VMOwnedMemory::new(memory, style)?.to_shared())
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Ok(VMOwnedMemory::from_definition(memory, style, vm_memory_location)?.to_shared())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        Ok(Self {
+            mmap: Rc::new(RwLock::new(guard.copy()?)),
+            config: self.config.clone(),
+            conditions: ThreadConditions::new(),
+        })
+    }
+}
+
+impl LinearMemory for VMSharedMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        let minimum = {
+            let guard = self.mmap.read().unwrap();
+            guard.size()
+        };
+        self.config.ty(minimum)
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        let guard = self.mmap.read().unwrap();
+        guard.size()
+    }
+
+    /// Resets the memory back down to zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.reset()?;
+        Ok(())
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.config.style()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.grow(delta, self.config.clone())
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.grow_at_least(min_size, self.config.clone())
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        let guard = self.mmap.read().unwrap();
+        guard.vm_memory_definition.as_ptr()
+    }
+
+    /// Shared memory can always be cloned
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        Ok(Box::new(self.clone()))
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        let forked = Self::copy(self)?;
+        Ok(Box::new(forked))
+    }
+
+    fn do_wait(
+        &mut self,
+        dst: wasmer_vm::NotifyLocation,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<u32, WaiterError> {
+        self.conditions.do_wait(dst, timeout)
+    }
+
+    fn do_notify(&mut self, dst: wasmer_vm::NotifyLocation, count: u32) -> u32 {
+        self.conditions.do_notify(dst, count)
+    }
+}
+
+impl From<VMOwnedMemory> for VMMemory {
+    fn from(mem: VMOwnedMemory) -> Self {
+        Self(Box::new(mem))
+    }
+}
+
+impl From<VMSharedMemory> for VMMemory {
+    fn from(mem: VMSharedMemory) -> Self {
+        Self(Box::new(mem))
+    }
+}
+
+/// Represents linear memory that can be either owned or shared
+#[derive(Debug)]
+pub struct VMMemory(pub Box<dyn LinearMemory + 'static>);
+
+impl From<Box<dyn LinearMemory + 'static>> for VMMemory {
+    fn from(mem: Box<dyn LinearMemory + 'static>) -> Self {
+        Self(mem)
+    }
+}
+
+impl LinearMemory for VMMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        self.0.ty()
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        self.0.size()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        self.0.grow(delta)
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        self.0.grow_at_least(min_size)
+    }
+
+    /// Resets the memory down to a zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.0.reset()?;
+        Ok(())
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.0.style()
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        self.0.vmmemory()
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        self.0.try_clone()
+    }
+
+    /// Initialize memory with data
+    unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
+        self.0.initialize_with_data(start, data)
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        self.0.copy()
+    }
+}
+
+impl VMMemory {
+    /// Creates a new linear memory instance of the correct type with specified
+    /// minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        Ok(if memory.shared {
+            Self(Box::new(VMSharedMemory::new(memory, style)?))
+        } else {
+            Self(Box::new(VMOwnedMemory::new(memory, style)?))
+        })
+    }
+
+    /// Returns the number of pages in the allocated memory block
+    pub fn get_runtime_size(&self) -> u32 {
+        self.0.size().0
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Ok(if memory.shared {
+            Self(Box::new(VMSharedMemory::from_definition(
+                memory,
+                style,
+                vm_memory_location,
+            )?))
+        } else {
+            Self(Box::new(VMOwnedMemory::from_definition(
+                memory,
+                style,
+                vm_memory_location,
+            )?))
+        })
+    }
+
+    /// Creates VMMemory from a custom implementation - the following into implementations
+    /// are natively supported
+    /// - VMOwnedMemory -> VMMemory
+    /// - Box<dyn LinearMemory + 'static> -> VMMemory
+    pub fn from_custom<IntoVMMemory>(memory: IntoVMMemory) -> Self
+    where
+        IntoVMMemory: Into<Self>,
+    {
+        memory.into()
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        LinearMemory::copy(self)
+    }
+}
+
+#[doc(hidden)]
+/// Default implementation to initialize memory with data
+pub unsafe fn initialize_memory_with_data(
+    memory: &VMMemoryDefinition,
+    start: usize,
+    data: &[u8],
+) -> Result<(), Trap> {
+    let mem_slice = std::slice::from_raw_parts_mut(memory.base, memory.current_length);
+    let end = start + data.len();
+    let to_init = &mut mem_slice[start..end];
+    to_init.copy_from_slice(data);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/mod.rs
new file mode 100644
index 0000000..330c2c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/fd_memory/mod.rs
@@ -0,0 +1,4 @@
+mod fd_mmap;
+mod memories;
+
+pub use self::memories::{initialize_memory_with_data, VMMemory, VMOwnedMemory, VMSharedMemory};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/mod.rs
new file mode 100644
index 0000000..95385a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/src/memory/mod.rs
@@ -0,0 +1,2 @@
+#[cfg(target_os = "linux")]
+pub mod fd_memory;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/sys-utils/tests/fd_mmap_memory.rs b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/tests/fd_mmap_memory.rs
new file mode 100644
index 0000000..b502b0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/sys-utils/tests/fd_mmap_memory.rs
@@ -0,0 +1,124 @@
+// // TODO: make this a sensible test before merge NOTE: commented out since it's mostly here for demonstration purposes.
+// use std::sync::Arc;
+
+// use wasmer::{BaseTunables, Engine, Module, Store, Tunables};
+// use wasmer_vm::VMMemory;
+// use wasmer_wasix::{
+//     bin_factory::spawn_exec_module, virtual_fs::host_fs::File, BusSpawnedProcessJoin,
+//     PluggableRuntimeImplementation, WasiControlPlane, WasiEnv, WasiRuntime,
+//     WasiState,
+// };
+
+// use wasmer_sys_utils::memory::fd_memory::{VMOwnedMemory, VMSharedMemory};
+
+// struct FdTunables {
+//     base: BaseTunables,
+// }
+
+// impl Tunables for FdTunables {
+//     fn memory_style(&self, memory: &wasmer::MemoryType) -> wasmer::vm::MemoryStyle {
+//         self.base.memory_style(memory)
+//     }
+
+//     fn table_style(&self, table: &wasmer::TableType) -> wasmer::vm::TableStyle {
+//         self.base.table_style(table)
+//     }
+
+//     fn create_host_memory(
+//         &self,
+//         ty: &wasmer::MemoryType,
+//         style: &wasmer::vm::MemoryStyle,
+//     ) -> Result<wasmer::vm::VMMemory, wasmer::MemoryError> {
+//         Ok(VMMemory(Box::new(VMOwnedMemory::new(ty, style)?)))
+//     }
+
+//     unsafe fn create_vm_memory(
+//         &self,
+//         ty: &wasmer::MemoryType,
+//         style: &wasmer::vm::MemoryStyle,
+//         vm_definition_location: std::ptr::NonNull<wasmer::vm::VMMemoryDefinition>,
+//     ) -> Result<wasmer::vm::VMMemory, wasmer::MemoryError> {
+//         if ty.shared {
+//             let mem = VMSharedMemory::from_definition(ty, style, vm_definition_location)?;
+//             Ok(VMMemory(Box::new(mem)))
+//         } else {
+//             let mem = VMOwnedMemory::from_definition(ty, style, vm_definition_location)?;
+//             Ok(VMMemory(Box::new(mem)))
+//         }
+//     }
+
+//     fn create_host_table(
+//         &self,
+//         ty: &wasmer::TableType,
+//         style: &wasmer::vm::TableStyle,
+//     ) -> Result<wasmer::vm::VMTable, String> {
+//         self.base.create_host_table(ty, style)
+//     }
+
+//     unsafe fn create_vm_table(
+//         &self,
+//         ty: &wasmer::TableType,
+//         style: &wasmer::vm::TableStyle,
+//         vm_definition_location: std::ptr::NonNull<wasmer::vm::VMTableDefinition>,
+//     ) -> Result<wasmer::vm::VMTable, String> {
+//         self.base.create_vm_table(ty, style, vm_definition_location)
+//     }
+// }
+
+// #[test]
+// fn test_fd_mmap_memory() {
+//     tracing_subscriber::fmt()
+//         .with_level(true)
+//         .with_test_writer()
+//         .with_max_level(tracing::Level::TRACE)
+//         .try_init()
+//         .unwrap();
+
+//     let mut store = Store::default();
+//     // let engine = wasmer_compiler_cranelift::Cranelift::default();
+
+//     // let engine = Engine::default();
+
+//     let code = std::fs::read("/home/theduke/dev/github.com/wasmerio/wasix-integration-tests/rust/simple/target/wasm32-wasmer-wasi/debug/examples/spawn_threads_and_sleep.wasm").unwrap();
+//     let module = Module::new(&store, code).unwrap();
+
+//     let control_plane = WasiControlPlane::default();
+
+//     let rt = Arc::new(PluggableRuntimeImplementation::default());
+//     let wasi_env = WasiState::builder("fdmem")
+//         .args(["500", "100", "10"])
+//         .runtime(&rt)
+//         .finalize_with(&mut store, &control_plane)
+//         .unwrap();
+
+//     // let rt = wasi_env
+//     //     .data(&store)
+//     //     .runtime()
+//     //     .as_any()
+//     //     .unwrap()
+//     //     .downcast_ref::<PluggableRuntimeImplementation>()
+//     //     .unwrap()
+//     //     .clone();
+
+//     // Generate an `ImportObject`.
+//     // let instance = wasmer_wasix::build_wasi_instance(&module, &mut wasi_env, &mut store).unwrap();
+
+//     let config = wasmer_wasix::wasmer_vbus::SpawnOptionsConfig {
+//         reuse: false,
+//         env: wasi_env.data(&store).clone(),
+//         remote_instance: None,
+//         access_token: None,
+//     };
+
+//     let rt2: Arc<dyn WasiRuntime + Send + Sync> = rt.clone();
+//     let bus = spawn_exec_module(module, store, config, &rt2).unwrap();
+
+//     dbg!("spawned, sleeping!");
+//     let _joiner = BusSpawnedProcessJoin::new(bus);
+
+//     std::thread::sleep(std::time::Duration::from_secs(100000000000000));
+
+//     // Let's call the `_start` function, which is our `main` function in Rust.
+//     // let start = instance.exports.get_function("_start").unwrap();
+//     // start.call(&mut store, &[]).unwrap();
+// }
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/types/Cargo.toml
new file mode 100644
index 0000000..2775e02
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "wasmer-types"
+description = "Wasmer Common Types"
+categories = ["wasm", "no-std", "data-structures"]
+keywords = ["wasm", "webassembly", "types"]
+license = "MIT OR Apache-2.0 WITH LLVM-exception"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+serde = { version = "1.0", features = ["derive", "rc"], optional = true, default-features = false }
+serde_bytes = { version = "0.11", optional = true }
+thiserror = "1.0"
+more-asserts = "0.2"
+indexmap = { version = "1.6" }
+rkyv = { workspace = true }
+enum-iterator = "0.7.0"
+target-lexicon = { version = "0.12.2", default-features = false }
+enumset.workspace = true
+bytecheck = "0.6.8"
+
+[dev-dependencies]
+memoffset.workspace = true
+
+[features]
+default = ["std"]
+std = []
+core = []
+enable-serde = ["serde", "serde/std", "serde_bytes", "indexmap/serde-1"]
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/README.md b/arbitrator/tools/module_roots/wasmer/lib/types/README.md
new file mode 100644
index 0000000..53ef964
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/README.md
@@ -0,0 +1,28 @@
+# `wasmer-types` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This library provides all the types and traits necessary to use
+WebAssembly easily anywhere.
+
+Among other things, it defines the following _types_:
+
+* `units` like `Pages` or `Bytes`
+* `types` and `values` like `I32`, `I64`, `F32`, `F64`, `ExternRef`,
+  `FuncRef`, `V128`, value conversions, `ExternType`, `FunctionType`
+  etc.
+* `native` contains a set of trait and implementations to deal with
+  WebAssembly types that have a direct representation on the host,
+* `memory_view`, an API to read/write memories when bytes are
+  interpreted as particular types (`i8`, `i16`, `i32` etc.)
+* `indexes` contains all the possible WebAssembly module indexes for
+  various types
+* `initializers` for tables, data etc.
+* `features` to enable or disable some WebAssembly features inside the
+  Wasmer runtime
+
+
+### Acknowledgments
+
+This project borrowed some of the code for the entity structure from [cranelift-entity](https://crates.io/crates/cranelift-entity).
+We decided to move it here to help on serialization/deserialization.
+
+Please check [Wasmer ATTRIBUTIONS](https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md) to further see licenses and other attributions of the project. 
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/address_map.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/address_map.rs
new file mode 100644
index 0000000..2f46624
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/address_map.rs
@@ -0,0 +1,45 @@
+//! Data structures to provide transformation of the source
+// addresses of a WebAssembly module into the native code.
+
+use crate::lib::std::vec::Vec;
+use crate::SourceLoc;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Single source location to generated address mapping.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct InstructionAddressMap {
+    /// Original source location.
+    pub srcloc: SourceLoc,
+
+    /// Generated instructions offset.
+    pub code_offset: usize,
+
+    /// Generated instructions length.
+    pub code_len: usize,
+}
+
+/// Function and its instructions addresses mappings.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct FunctionAddressMap {
+    /// Instructions maps.
+    /// The array is sorted by the InstructionAddressMap::code_offset field.
+    pub instructions: Vec<InstructionAddressMap>,
+
+    /// Function start source location (normally declaration).
+    pub start_srcloc: SourceLoc,
+
+    /// Function end source location.
+    pub end_srcloc: SourceLoc,
+
+    /// Generated function body offset if applicable, otherwise 0.
+    pub body_offset: usize,
+
+    /// Generated function body length.
+    pub body_len: usize,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/function.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/function.rs
new file mode 100644
index 0000000..96dd723
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/function.rs
@@ -0,0 +1,183 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! A `Compilation` contains the compiled function bodies for a WebAssembly
+//! module (`CompiledFunction`).
+
+use crate::entity::PrimaryMap;
+use crate::lib::std::vec::Vec;
+use crate::{ArchivedCompiledFunctionUnwindInfo, TrapInformation};
+use crate::{CompiledFunctionUnwindInfo, FunctionAddressMap};
+use crate::{
+    CustomSection, FunctionIndex, LocalFunctionIndex, Relocation, SectionIndex, SignatureIndex,
+};
+use rkyv::option::ArchivedOption;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+use super::unwind::CompiledFunctionUnwindInfoLike;
+
+/// The frame info for a Compiled function.
+///
+/// This structure is only used for reconstructing
+/// the frame information after a `Trap`.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct CompiledFunctionFrameInfo {
+    /// The traps (in the function body).
+    ///
+    /// Code offsets of the traps MUST be in ascending order.
+    pub traps: Vec<TrapInformation>,
+
+    /// The address map.
+    pub address_map: FunctionAddressMap,
+}
+
+/// The function body.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct FunctionBody {
+    /// The function body bytes.
+    #[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))]
+    pub body: Vec<u8>,
+
+    /// The function unwind info
+    pub unwind_info: Option<CompiledFunctionUnwindInfo>,
+}
+
+/// Any struct that acts like a `FunctionBody`.
+#[allow(missing_docs)]
+pub trait FunctionBodyLike<'a> {
+    type UnwindInfo: CompiledFunctionUnwindInfoLike<'a>;
+
+    fn body(&'a self) -> &'a [u8];
+    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo>;
+}
+
+impl<'a> FunctionBodyLike<'a> for FunctionBody {
+    type UnwindInfo = CompiledFunctionUnwindInfo;
+
+    fn body(&'a self) -> &'a [u8] {
+        self.body.as_ref()
+    }
+
+    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo> {
+        self.unwind_info.as_ref()
+    }
+}
+
+impl<'a> FunctionBodyLike<'a> for ArchivedFunctionBody {
+    type UnwindInfo = ArchivedCompiledFunctionUnwindInfo;
+
+    fn body(&'a self) -> &'a [u8] {
+        self.body.as_ref()
+    }
+
+    fn unwind_info(&'a self) -> Option<&Self::UnwindInfo> {
+        match self.unwind_info {
+            ArchivedOption::Some(ref x) => Some(x),
+            ArchivedOption::None => None,
+        }
+    }
+}
+
+/// The result of compiling a WebAssembly function.
+///
+/// This structure only have the compiled information data
+/// (function bytecode body, relocations, traps, jump tables
+/// and unwind information).
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct CompiledFunction {
+    /// The function body.
+    pub body: FunctionBody,
+
+    /// The relocations (in the body)
+    pub relocations: Vec<Relocation>,
+
+    /// The frame information.
+    pub frame_info: CompiledFunctionFrameInfo,
+}
+
+/// The compiled functions map (index in the Wasm -> function)
+pub type Functions = PrimaryMap<LocalFunctionIndex, CompiledFunction>;
+
+/// The custom sections for a Compilation.
+pub type CustomSections = PrimaryMap<SectionIndex, CustomSection>;
+
+/// The DWARF information for this Compilation.
+///
+/// It is used for retrieving the unwind information once an exception
+/// happens.
+/// In the future this structure may also hold other information useful
+/// for debugging.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, PartialEq, Eq, Clone,
+)]
+#[archive(as = "Self")]
+pub struct Dwarf {
+    /// The section index in the [`Compilation`] that corresponds to the exception frames.
+    /// [Learn
+    /// more](https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/ehframechpt.html).
+    pub eh_frame: SectionIndex,
+}
+
+impl Dwarf {
+    /// Creates a `Dwarf` struct with the corresponding indices for its sections
+    pub fn new(eh_frame: SectionIndex) -> Self {
+        Self { eh_frame }
+    }
+}
+
+/// The result of compiling a WebAssembly module's functions.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(Debug, PartialEq, Eq)]
+pub struct Compilation {
+    /// Compiled code for the function bodies.
+    pub functions: Functions,
+
+    /// Custom sections for the module.
+    /// It will hold the data, for example, for constants used in a
+    /// function, global variables, rodata_64, hot/cold function partitioning, ...
+    pub custom_sections: CustomSections,
+
+    /// Trampolines to call a function defined locally in the wasm via a
+    /// provided `Vec` of values.
+    ///
+    /// This allows us to call easily Wasm functions, such as:
+    ///
+    /// ```ignore
+    /// let func = instance.exports.get_function("my_func");
+    /// func.call(&[Value::I32(1)]);
+    /// ```
+    pub function_call_trampolines: PrimaryMap<SignatureIndex, FunctionBody>,
+
+    /// Trampolines to call a dynamic function defined in
+    /// a host, from a Wasm module.
+    ///
+    /// This allows us to create dynamic Wasm functions, such as:
+    ///
+    /// ```ignore
+    /// fn my_func(values: &[Val]) -> Result<Vec<Val>, RuntimeError> {
+    ///     // do something
+    /// }
+    ///
+    /// let my_func_type = FunctionType::new(vec![Type::I32], vec![Type::I32]);
+    /// let imports = imports!{
+    ///     "namespace" => {
+    ///         "my_func" => Function::new(&store, my_func_type, my_func),
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// Note: Dynamic function trampolines are only compiled for imported function types.
+    pub dynamic_function_trampolines: PrimaryMap<FunctionIndex, FunctionBody>,
+
+    /// Section ids corresponding to the Dwarf debug info
+    pub debug: Option<Dwarf>,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/mod.rs
new file mode 100644
index 0000000..624cd2d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/mod.rs
@@ -0,0 +1,10 @@
+//! Types for compilation.
+
+pub mod address_map;
+pub mod function;
+pub mod module;
+pub mod relocation;
+pub mod section;
+pub mod symbols;
+pub mod target;
+pub mod unwind;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/module.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/module.rs
new file mode 100644
index 0000000..8c9c460
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/module.rs
@@ -0,0 +1,29 @@
+//! Types for modules.
+use crate::entity::PrimaryMap;
+use crate::{Features, MemoryIndex, MemoryStyle, ModuleInfo, TableIndex, TableStyle};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+/// The required info for compiling a module.
+///
+/// This differs from [`ModuleInfo`] because it have extra info only
+/// possible after translation (such as the features used for compiling,
+/// or the `MemoryStyle` and `TableStyle`).
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(Debug, Clone, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct CompileModuleInfo {
+    /// The features used for compiling the module
+    pub features: Features,
+    /// The module information
+    pub module: Arc<ModuleInfo>,
+    /// The memory styles used for compiling.
+    ///
+    /// The compiler will emit the most optimal code based
+    /// on the memory style (static or dynamic) chosen.
+    pub memory_styles: PrimaryMap<MemoryIndex, MemoryStyle>,
+    /// The table plans used for compiling.
+    pub table_styles: PrimaryMap<TableIndex, TableStyle>,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/relocation.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/relocation.rs
new file mode 100644
index 0000000..a1abd44
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/relocation.rs
@@ -0,0 +1,229 @@
+//! Relocation is the process of assigning load addresses for position-dependent
+//! code and data of a program and adjusting the code and data to reflect the
+//! assigned addresses.
+//!
+//! [Learn more](https://en.wikipedia.org/wiki/Relocation_(computing)).
+//!
+//! Each time a `Compiler` compiles a WebAssembly function (into machine code),
+//! it also attaches if there are any relocations that need to be patched into
+//! the generated machine code, so a given frontend (JIT or native) can
+//! do the corresponding work to run it.
+
+use super::section::SectionIndex;
+use crate::entity::PrimaryMap;
+use crate::lib::std::fmt;
+use crate::lib::std::vec::Vec;
+use crate::{Addend, CodeOffset};
+use crate::{LibCall, LocalFunctionIndex};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Relocation kinds for every ISA.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Copy, Clone, Debug, PartialEq, Eq,
+)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum RelocationKind {
+    /// absolute 4-byte
+    Abs4,
+    /// absolute 8-byte
+    Abs8,
+    /// x86 PC-relative 4-byte
+    X86PCRel4,
+    /// x86 PC-relative 8-byte
+    X86PCRel8,
+    /// x86 call to PC-relative 4-byte
+    X86CallPCRel4,
+    /// x86 call to PLT-relative 4-byte
+    X86CallPLTRel4,
+    /// x86 GOT PC-relative 4-byte
+    X86GOTPCRel4,
+    /// Arm32 call target
+    Arm32Call,
+    /// Arm64 call target
+    Arm64Call,
+    /// Arm64 movk/z part 0
+    Arm64Movw0,
+    /// Arm64 movk/z part 1
+    Arm64Movw1,
+    /// Arm64 movk/z part 2
+    Arm64Movw2,
+    /// Arm64 movk/z part 3
+    Arm64Movw3,
+    /// RISC-V PC-relative high 20bit
+    RiscvPCRelHi20,
+    /// RISC-V PC-relative low 12bit, I-type
+    RiscvPCRelLo12I,
+    /// RISC-V call target
+    RiscvCall,
+    /// Elf x86_64 32 bit signed PC relative offset to two GOT entries for GD symbol.
+    ElfX86_64TlsGd,
+    // /// Mach-O x86_64 32 bit signed PC relative offset to a `__thread_vars` entry.
+    // MachOX86_64Tlv,
+}
+
+impl fmt::Display for RelocationKind {
+    /// Display trait implementation drops the arch, since its used in contexts where the arch is
+    /// already unambiguous, e.g. clif syntax with isa specified. In other contexts, use Debug.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Self::Abs4 => write!(f, "Abs4"),
+            Self::Abs8 => write!(f, "Abs8"),
+            Self::X86PCRel4 => write!(f, "PCRel4"),
+            Self::X86PCRel8 => write!(f, "PCRel8"),
+            Self::X86CallPCRel4 => write!(f, "CallPCRel4"),
+            Self::X86CallPLTRel4 => write!(f, "CallPLTRel4"),
+            Self::X86GOTPCRel4 => write!(f, "GOTPCRel4"),
+            Self::Arm32Call | Self::Arm64Call | Self::RiscvCall => write!(f, "Call"),
+            Self::Arm64Movw0 => write!(f, "Arm64MovwG0"),
+            Self::Arm64Movw1 => write!(f, "Arm64MovwG1"),
+            Self::Arm64Movw2 => write!(f, "Arm64MovwG2"),
+            Self::Arm64Movw3 => write!(f, "Arm64MovwG3"),
+            Self::ElfX86_64TlsGd => write!(f, "ElfX86_64TlsGd"),
+            Self::RiscvPCRelHi20 => write!(f, "RiscvPCRelHi20"),
+            Self::RiscvPCRelLo12I => write!(f, "RiscvPCRelLo12I"),
+            // Self::MachOX86_64Tlv => write!(f, "MachOX86_64Tlv"),
+        }
+    }
+}
+
+/// A record of a relocation to perform.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct Relocation {
+    /// The relocation kind.
+    pub kind: RelocationKind,
+    /// Relocation target.
+    pub reloc_target: RelocationTarget,
+    /// The offset where to apply the relocation.
+    pub offset: CodeOffset,
+    /// The addend to add to the relocation value.
+    pub addend: Addend,
+}
+
+/// Any struct that acts like a `Relocation`.
+#[allow(missing_docs)]
+pub trait RelocationLike {
+    fn kind(&self) -> RelocationKind;
+    fn reloc_target(&self) -> RelocationTarget;
+    fn offset(&self) -> CodeOffset;
+    fn addend(&self) -> Addend;
+
+    /// Given a function start address, provide the relocation relative
+    /// to that address.
+    ///
+    /// The function returns the relocation address and the delta.
+    fn for_address(&self, start: usize, target_func_address: u64) -> (usize, u64) {
+        match self.kind() {
+            RelocationKind::Abs8
+            | RelocationKind::Arm64Movw0
+            | RelocationKind::Arm64Movw1
+            | RelocationKind::Arm64Movw2
+            | RelocationKind::Arm64Movw3
+            | RelocationKind::RiscvPCRelLo12I => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_abs = target_func_address
+                    .checked_add(reloc_addend as u64)
+                    .unwrap();
+                (reloc_address, reloc_abs)
+            }
+            RelocationKind::X86PCRel4 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = (target_func_address as u32)
+                    .wrapping_sub(reloc_address as u32)
+                    .checked_add(reloc_addend as u32)
+                    .unwrap();
+                (reloc_address, reloc_delta_u32 as u64)
+            }
+            RelocationKind::X86PCRel8 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta = target_func_address
+                    .wrapping_sub(reloc_address as u64)
+                    .checked_add(reloc_addend as u64)
+                    .unwrap();
+                (reloc_address, reloc_delta)
+            }
+            RelocationKind::X86CallPCRel4 | RelocationKind::X86CallPLTRel4 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = (target_func_address as u32)
+                    .wrapping_sub(reloc_address as u32)
+                    .wrapping_add(reloc_addend as u32);
+                (reloc_address, reloc_delta_u32 as u64)
+            }
+            RelocationKind::Arm64Call
+            | RelocationKind::RiscvCall
+            | RelocationKind::RiscvPCRelHi20 => {
+                let reloc_address = start + self.offset() as usize;
+                let reloc_addend = self.addend() as isize;
+                let reloc_delta_u32 = target_func_address
+                    .wrapping_sub(reloc_address as u64)
+                    .wrapping_add(reloc_addend as u64);
+                (reloc_address, reloc_delta_u32)
+            }
+            _ => panic!("Relocation kind unsupported"),
+        }
+    }
+}
+
+impl RelocationLike for Relocation {
+    fn kind(&self) -> RelocationKind {
+        self.kind
+    }
+
+    fn reloc_target(&self) -> RelocationTarget {
+        self.reloc_target
+    }
+
+    fn offset(&self) -> CodeOffset {
+        self.offset
+    }
+
+    fn addend(&self) -> Addend {
+        self.addend
+    }
+}
+
+impl RelocationLike for ArchivedRelocation {
+    fn kind(&self) -> RelocationKind {
+        self.kind
+    }
+
+    fn reloc_target(&self) -> RelocationTarget {
+        self.reloc_target
+    }
+
+    fn offset(&self) -> CodeOffset {
+        self.offset
+    }
+
+    fn addend(&self) -> Addend {
+        self.addend
+    }
+}
+
+/// Destination function. Can be either user function or some special one, like `memory.grow`.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, Copy, Clone, PartialEq, Eq,
+)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum RelocationTarget {
+    /// A relocation to a function defined locally in the wasm (not an imported one).
+    LocalFunc(LocalFunctionIndex),
+    /// A compiler-generated libcall.
+    LibCall(LibCall),
+    /// Custom sections generated by the compiler
+    CustomSection(SectionIndex),
+}
+
+/// Relocations to apply to function bodies.
+pub type Relocations = PrimaryMap<LocalFunctionIndex, Vec<Relocation>>;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/section.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/section.rs
new file mode 100644
index 0000000..f016910
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/section.rs
@@ -0,0 +1,162 @@
+//! This module define the required structures to emit custom
+//! Sections in a `Compilation`.
+//!
+//! The functions that access a custom [`CustomSection`] would need
+//! to emit a custom relocation: `RelocationTarget::CustomSection`, so
+//! it can be patched later by the engine (native or JIT).
+
+use super::relocation::{ArchivedRelocation, Relocation, RelocationLike};
+use crate::entity::entity_impl;
+use crate::lib::std::vec::Vec;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Index type of a Section defined inside a WebAssembly `Compilation`.
+#[derive(
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    Default,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct SectionIndex(u32);
+
+entity_impl!(SectionIndex);
+
+/// Custom section Protection.
+///
+/// Determines how a custom section may be used.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Debug, Clone, PartialEq, Eq,
+)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum CustomSectionProtection {
+    /// A custom section with read permission.
+    Read,
+
+    /// A custom section with read and execute permissions.
+    ReadExecute,
+}
+
+/// A Section for a `Compilation`.
+///
+/// This is used so compilers can store arbitrary information
+/// in the emitted module.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct CustomSection {
+    /// Memory protection that applies to this section.
+    pub protection: CustomSectionProtection,
+
+    /// The bytes corresponding to this section.
+    ///
+    /// > Note: These bytes have to be at-least 8-byte aligned
+    /// > (the start of the memory pointer).
+    /// > We might need to create another field for alignment in case it's
+    /// > needed in the future.
+    pub bytes: SectionBody,
+
+    /// Relocations that apply to this custom section.
+    pub relocations: Vec<Relocation>,
+}
+
+/// Any struct that acts like a `CustomSection`.
+#[allow(missing_docs)]
+pub trait CustomSectionLike<'a> {
+    type Relocations: RelocationLike;
+
+    fn protection(&self) -> &CustomSectionProtection;
+    fn bytes(&self) -> &[u8];
+    fn relocations(&'a self) -> &[Self::Relocations];
+}
+
+impl<'a> CustomSectionLike<'a> for CustomSection {
+    type Relocations = Relocation;
+
+    fn protection(&self) -> &CustomSectionProtection {
+        &self.protection
+    }
+
+    fn bytes(&self) -> &[u8] {
+        self.bytes.0.as_ref()
+    }
+
+    fn relocations(&'a self) -> &[Self::Relocations] {
+        self.relocations.as_slice()
+    }
+}
+
+impl<'a> CustomSectionLike<'a> for ArchivedCustomSection {
+    type Relocations = ArchivedRelocation;
+
+    fn protection(&self) -> &CustomSectionProtection {
+        &self.protection
+    }
+
+    fn bytes(&self) -> &[u8] {
+        self.bytes.0.as_ref()
+    }
+
+    fn relocations(&'a self) -> &[Self::Relocations] {
+        self.relocations.as_slice()
+    }
+}
+
+/// The bytes in the section.
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq, Default)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct SectionBody(#[cfg_attr(feature = "enable-serde", serde(with = "serde_bytes"))] Vec<u8>);
+
+impl SectionBody {
+    /// Create a new section body with the given contents.
+    pub fn new_with_vec(contents: Vec<u8>) -> Self {
+        Self(contents)
+    }
+
+    /// Returns a raw pointer to the section's buffer.
+    pub fn as_ptr(&self) -> *const u8 {
+        self.0.as_ptr()
+    }
+
+    /// Returns the length of this section in bytes.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Dereferences into the section's buffer.
+    pub fn as_slice(&self) -> &[u8] {
+        self.0.as_slice()
+    }
+
+    /// Returns whether or not the section body is empty.
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl ArchivedSectionBody {
+    /// Returns the length of this section in bytes.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns whether or not the section body is empty.
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/symbols.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/symbols.rs
new file mode 100644
index 0000000..4dc6311
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/symbols.rs
@@ -0,0 +1,236 @@
+//! This module define the required structures for compilation symbols.
+use crate::{
+    entity::{EntityRef, PrimaryMap},
+    CompileModuleInfo, DeserializeError, FunctionIndex, LocalFunctionIndex, OwnedDataInitializer,
+    SectionIndex, SerializeError, SignatureIndex,
+};
+use rkyv::{
+    archived_value, check_archived_value, de::deserializers::SharedDeserializeMap,
+    ser::serializers::AllocSerializer, ser::Serializer as RkyvSerializer, Archive,
+    Deserialize as RkyvDeserialize, Serialize as RkyvSerialize,
+};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// The kinds of wasmer_types objects that might be found in a native object file.
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub enum Symbol {
+    /// A metadata section, indexed by a unique prefix
+    /// (usually the wasm file SHA256 hash)
+    Metadata,
+
+    /// A function defined in the wasm.
+    LocalFunction(LocalFunctionIndex),
+
+    /// A wasm section.
+    Section(SectionIndex),
+
+    /// The function call trampoline for a given signature.
+    FunctionCallTrampoline(SignatureIndex),
+
+    /// The dynamic function trampoline for a given function.
+    DynamicFunctionTrampoline(FunctionIndex),
+}
+
+/// This trait facilitates symbol name lookups in a native object file.
+pub trait SymbolRegistry: Send + Sync {
+    /// Given a `Symbol` it returns the name for that symbol in the object file
+    fn symbol_to_name(&self, symbol: Symbol) -> String;
+
+    /// Given a name it returns the `Symbol` for that name in the object file
+    ///
+    /// This function is the inverse of [`SymbolRegistry::symbol_to_name`]
+    fn name_to_symbol(&self, name: &str) -> Option<Symbol>;
+}
+
+/// Serializable struct that represents the compiled metadata.
+#[derive(Debug, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct ModuleMetadata {
+    /// Compile info
+    pub compile_info: CompileModuleInfo,
+    /// Prefix for function etc symbols
+    pub prefix: String,
+    /// Data initializers
+    pub data_initializers: Box<[OwnedDataInitializer]>,
+    /// The function body lengths (used to find function by address)
+    pub function_body_lengths: PrimaryMap<LocalFunctionIndex, u64>,
+    /// CPU features used (See [`CpuFeature`](crate::CpuFeature))
+    pub cpu_features: u64,
+}
+
+/// A simple metadata registry
+pub struct ModuleMetadataSymbolRegistry {
+    /// Symbol prefix stirng
+    pub prefix: String,
+}
+
+impl ModuleMetadata {
+    /// Get mutable ref to compile info and a copy of the registry
+    pub fn split(&mut self) -> (&mut CompileModuleInfo, ModuleMetadataSymbolRegistry) {
+        let compile_info = &mut self.compile_info;
+        let symbol_registry = ModuleMetadataSymbolRegistry {
+            prefix: self.prefix.clone(),
+        };
+        (compile_info, symbol_registry)
+    }
+
+    /// Returns symbol registry.
+    pub fn get_symbol_registry(&self) -> ModuleMetadataSymbolRegistry {
+        ModuleMetadataSymbolRegistry {
+            prefix: self.prefix.clone(),
+        }
+    }
+    /// Serialize a Module into bytes
+    /// The bytes will have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        let mut serializer = AllocSerializer::<4096>::default();
+        let pos = serializer
+            .serialize_value(self)
+            .map_err(|err| SerializeError::Generic(format!("{}", err)))? as u64;
+        let mut serialized_data = serializer.into_serializer().into_inner();
+        serialized_data.extend_from_slice(&pos.to_le_bytes());
+        Ok(serialized_data.to_vec())
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    ///
+    /// # Safety
+    ///
+    /// This method is unsafe since it deserializes data directly
+    /// from memory.
+    /// Right now we are not doing any extra work for validation, but
+    /// `rkyv` has an option to do bytecheck on the serialized data before
+    /// serializing (via `rkyv::check_archived_value`).
+    pub unsafe fn deserialize_unchecked(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn deserialize(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice_checked(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// # Safety
+    ///
+    /// This method is unsafe.
+    /// Please check `ModuleMetadata::deserialize` for more details.
+    unsafe fn archive_from_slice(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedModuleMetadata, DeserializeError> {
+        if metadata_slice.len() < 8 {
+            return Err(DeserializeError::Incompatible(
+                "invalid serialized ModuleMetadata".into(),
+            ));
+        }
+        let mut pos: [u8; 8] = Default::default();
+        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
+        let pos: u64 = u64::from_le_bytes(pos);
+        Ok(archived_value::<Self>(
+            &metadata_slice[..metadata_slice.len() - 8],
+            pos as usize,
+        ))
+    }
+
+    /// # Safety
+    ///
+    /// This method is unsafe.
+    /// Please check `ModuleMetadata::deserialize` for more details.
+    fn archive_from_slice_checked(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedModuleMetadata, DeserializeError> {
+        if metadata_slice.len() < 8 {
+            return Err(DeserializeError::Incompatible(
+                "invalid serialized ModuleMetadata".into(),
+            ));
+        }
+        let mut pos: [u8; 8] = Default::default();
+        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
+        let pos: u64 = u64::from_le_bytes(pos);
+        check_archived_value::<Self>(&metadata_slice[..metadata_slice.len() - 8], pos as usize)
+            .map_err(|e| DeserializeError::CorruptedBinary(e.to_string()))
+    }
+
+    /// Deserialize a compilation module from an archive
+    pub fn deserialize_from_archive(
+        archived: &ArchivedModuleMetadata,
+    ) -> Result<Self, DeserializeError> {
+        let mut deserializer = SharedDeserializeMap::new();
+        RkyvDeserialize::deserialize(archived, &mut deserializer)
+            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
+    }
+}
+
+impl SymbolRegistry for ModuleMetadataSymbolRegistry {
+    fn symbol_to_name(&self, symbol: Symbol) -> String {
+        match symbol {
+            Symbol::Metadata => {
+                format!("WASMER_METADATA_{}", self.prefix.to_uppercase())
+            }
+            Symbol::LocalFunction(index) => {
+                format!("wasmer_function_{}_{}", self.prefix, index.index())
+            }
+            Symbol::Section(index) => format!("wasmer_section_{}_{}", self.prefix, index.index()),
+            Symbol::FunctionCallTrampoline(index) => {
+                format!(
+                    "wasmer_trampoline_function_call_{}_{}",
+                    self.prefix,
+                    index.index()
+                )
+            }
+            Symbol::DynamicFunctionTrampoline(index) => {
+                format!(
+                    "wasmer_trampoline_dynamic_function_{}_{}",
+                    self.prefix,
+                    index.index()
+                )
+            }
+        }
+    }
+
+    fn name_to_symbol(&self, name: &str) -> Option<Symbol> {
+        if name == self.symbol_to_name(Symbol::Metadata) {
+            Some(Symbol::Metadata)
+        } else if let Some(index) = name.strip_prefix(&format!("wasmer_function_{}_", self.prefix))
+        {
+            index
+                .parse::<u32>()
+                .ok()
+                .map(|index| Symbol::LocalFunction(LocalFunctionIndex::from_u32(index)))
+        } else if let Some(index) = name.strip_prefix(&format!("wasmer_section_{}_", self.prefix)) {
+            index
+                .parse::<u32>()
+                .ok()
+                .map(|index| Symbol::Section(SectionIndex::from_u32(index)))
+        } else if let Some(index) =
+            name.strip_prefix(&format!("wasmer_trampoline_function_call_{}_", self.prefix))
+        {
+            index
+                .parse::<u32>()
+                .ok()
+                .map(|index| Symbol::FunctionCallTrampoline(SignatureIndex::from_u32(index)))
+        } else if let Some(index) = name.strip_prefix(&format!(
+            "wasmer_trampoline_dynamic_function_{}_",
+            self.prefix
+        )) {
+            index
+                .parse::<u32>()
+                .ok()
+                .map(|index| Symbol::DynamicFunctionTrampoline(FunctionIndex::from_u32(index)))
+        } else {
+            None
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/target.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/target.rs
new file mode 100644
index 0000000..0d3d98f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/target.rs
@@ -0,0 +1,229 @@
+//! Target configuration
+
+// The clippy::use_self exception is due to a false positive indicating that
+// `CpuFeature` should be replaced by `Self`. Attaching the allowance to the
+// type itself has no effect, therefore it's disabled for the whole module.
+// Feel free to remove this allow attribute once the bug is fixed.
+// See https://github.com/rust-lang/rust-clippy/issues/6902
+// Same things is now happening with unused-unit for the EnumSetType derivative
+#![allow(clippy::unused_unit, clippy::use_self)]
+
+use crate::error::ParseCpuFeatureError;
+use enumset::{EnumSet, EnumSetType};
+use std::str::FromStr;
+use std::string::{String, ToString};
+pub use target_lexicon::{
+    Aarch64Architecture, Architecture, BinaryFormat, CallingConvention, Endianness, Environment,
+    OperatingSystem, PointerWidth, Triple, Vendor,
+};
+
+/// The nomenclature is inspired by the [`cpuid` crate].
+/// The list of supported features was initially retrieved from
+/// [`cranelift-native`].
+///
+/// The `CpuFeature` enum values are likely to grow closer to the
+/// original `cpuid`. However, we prefer to start small and grow from there.
+///
+/// If you would like to use a flag that doesn't exist yet here, please
+/// open a PR.
+///
+/// [`cpuid` crate]: https://docs.rs/cpuid/0.1.1/cpuid/enum.CpuFeature.html
+/// [`cranelift-native`]: https://github.com/bytecodealliance/cranelift/blob/6988545fd20249b084c53f4761b8c861266f5d31/cranelift-native/src/lib.rs#L51-L92
+#[allow(missing_docs, clippy::derived_hash_with_manual_eq)]
+#[derive(EnumSetType, Debug, Hash)]
+pub enum CpuFeature {
+    // X86 features
+    SSE2,
+    SSE3,
+    SSSE3,
+    SSE41,
+    SSE42,
+    POPCNT,
+    AVX,
+    BMI1,
+    BMI2,
+    AVX2,
+    AVX512DQ,
+    AVX512VL,
+    AVX512F,
+    LZCNT,
+    // ARM features
+    NEON,
+    // Risc-V features
+}
+
+impl CpuFeature {
+    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+    /// Retrieves the features for the current Host
+    pub fn for_host() -> EnumSet<Self> {
+        let mut features = EnumSet::new();
+
+        if std::is_x86_feature_detected!("sse2") {
+            features.insert(Self::SSE2);
+        }
+        if std::is_x86_feature_detected!("sse3") {
+            features.insert(Self::SSE3);
+        }
+        if std::is_x86_feature_detected!("ssse3") {
+            features.insert(Self::SSSE3);
+        }
+        if std::is_x86_feature_detected!("sse4.1") {
+            features.insert(Self::SSE41);
+        }
+        if std::is_x86_feature_detected!("sse4.2") {
+            features.insert(Self::SSE42);
+        }
+        if std::is_x86_feature_detected!("popcnt") {
+            features.insert(Self::POPCNT);
+        }
+        if std::is_x86_feature_detected!("avx") {
+            features.insert(Self::AVX);
+        }
+        if std::is_x86_feature_detected!("bmi1") {
+            features.insert(Self::BMI1);
+        }
+        if std::is_x86_feature_detected!("bmi2") {
+            features.insert(Self::BMI2);
+        }
+        if std::is_x86_feature_detected!("avx2") {
+            features.insert(Self::AVX2);
+        }
+        if std::is_x86_feature_detected!("avx512dq") {
+            features.insert(Self::AVX512DQ);
+        }
+        if std::is_x86_feature_detected!("avx512vl") {
+            features.insert(Self::AVX512VL);
+        }
+        if std::is_x86_feature_detected!("avx512f") {
+            features.insert(Self::AVX512F);
+        }
+        if std::is_x86_feature_detected!("lzcnt") {
+            features.insert(Self::LZCNT);
+        }
+        features
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    /// Retrieves the features for the current Host
+    pub fn for_host() -> EnumSet<Self> {
+        let mut features = EnumSet::new();
+
+        if std::arch::is_aarch64_feature_detected!("neon") {
+            features.insert(Self::NEON);
+        }
+
+        features
+    }
+
+    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))]
+    /// Retrieves the features for the current Host
+    pub fn for_host() -> EnumSet<Self> {
+        // We default to an empty hash set
+        EnumSet::new()
+    }
+
+    /// Retrieves an empty set of `CpuFeature`s.
+    pub fn set() -> EnumSet<Self> {
+        // We default to an empty hash set
+        EnumSet::new()
+    }
+}
+
+// This options should map exactly the GCC options indicated
+// here by architectures:
+//
+// X86: https://gcc.gnu.org/onlinedocs/gcc/x86-Options.html
+// ARM: https://gcc.gnu.org/onlinedocs/gcc/ARM-Options.html
+// Aarch64: https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html
+impl FromStr for CpuFeature {
+    type Err = ParseCpuFeatureError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "sse2" => Ok(Self::SSE2),
+            "sse3" => Ok(Self::SSE3),
+            "ssse3" => Ok(Self::SSSE3),
+            "sse4.1" => Ok(Self::SSE41),
+            "sse4.2" => Ok(Self::SSE42),
+            "popcnt" => Ok(Self::POPCNT),
+            "avx" => Ok(Self::AVX),
+            "bmi" => Ok(Self::BMI1),
+            "bmi2" => Ok(Self::BMI2),
+            "avx2" => Ok(Self::AVX2),
+            "avx512dq" => Ok(Self::AVX512DQ),
+            "avx512vl" => Ok(Self::AVX512VL),
+            "avx512f" => Ok(Self::AVX512F),
+            "lzcnt" => Ok(Self::LZCNT),
+            "neon" => Ok(Self::NEON),
+            _ => Err(ParseCpuFeatureError::Missing(s.to_string())),
+        }
+    }
+}
+
+impl ToString for CpuFeature {
+    fn to_string(&self) -> String {
+        match self {
+            Self::SSE2 => "sse2",
+            Self::SSE3 => "sse3",
+            Self::SSSE3 => "ssse3",
+            Self::SSE41 => "sse4.1",
+            Self::SSE42 => "sse4.2",
+            Self::POPCNT => "popcnt",
+            Self::AVX => "avx",
+            Self::BMI1 => "bmi",
+            Self::BMI2 => "bmi2",
+            Self::AVX2 => "avx2",
+            Self::AVX512DQ => "avx512dq",
+            Self::AVX512VL => "avx512vl",
+            Self::AVX512F => "avx512f",
+            Self::LZCNT => "lzcnt",
+            Self::NEON => "neon",
+        }
+        .to_string()
+    }
+}
+
+/// This is the target that we will use for compiling
+/// the WebAssembly ModuleInfo, and then run it.
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Target {
+    triple: Triple,
+    cpu_features: EnumSet<CpuFeature>,
+}
+
+impl Target {
+    /// Creates a new target given a triple
+    pub fn new(triple: Triple, cpu_features: EnumSet<CpuFeature>) -> Self {
+        Self {
+            triple,
+            cpu_features,
+        }
+    }
+
+    /// The triple associated for the target.
+    pub fn triple(&self) -> &Triple {
+        &self.triple
+    }
+
+    /// The triple associated for the target.
+    pub fn cpu_features(&self) -> &EnumSet<CpuFeature> {
+        &self.cpu_features
+    }
+
+    /// Check if target is a native (eq to host) or not
+    pub fn is_native(&self) -> bool {
+        let host = Triple::host();
+        host.operating_system == self.triple.operating_system
+            && host.architecture == self.triple.architecture
+    }
+}
+
+/// The default for the Target will use the HOST as the triple
+impl Default for Target {
+    fn default() -> Self {
+        Self {
+            triple: Triple::host(),
+            cpu_features: CpuFeature::for_host(),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/unwind.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/unwind.rs
new file mode 100644
index 0000000..4f553b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/compilation/unwind.rs
@@ -0,0 +1,61 @@
+//! A `CompiledFunctionUnwindInfo` contains the function unwind information.
+//!
+//! The unwind information is used to determine which function
+//! called the function that threw the exception, and which
+//! function called that one, and so forth.
+//!
+//! [Learn more](https://en.wikipedia.org/wiki/Call_stack).
+use crate::lib::std::vec::Vec;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Compiled function unwind information.
+///
+/// > Note: Windows OS have a different way of representing the [unwind info],
+/// > That's why we keep the Windows data and the Unix frame layout in different
+/// > fields.
+///
+/// [unwind info]: https://docs.microsoft.com/en-us/cpp/build/exception-handling-x64?view=vs-2019
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, Debug, Clone, PartialEq, Eq)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub enum CompiledFunctionUnwindInfo {
+    /// Windows UNWIND_INFO.
+    WindowsX64(Vec<u8>),
+
+    /// The unwind info is added to the Dwarf section in `Compilation`.
+    Dwarf,
+}
+
+/// Generic reference to data in a `CompiledFunctionUnwindInfo`
+#[allow(missing_docs)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CompiledFunctionUnwindInfoReference<'a> {
+    WindowsX64(&'a [u8]),
+    Dwarf,
+}
+
+/// Any struct that acts like a `CompiledFunctionUnwindInfo`.
+#[allow(missing_docs)]
+pub trait CompiledFunctionUnwindInfoLike<'a> {
+    fn get(&'a self) -> CompiledFunctionUnwindInfoReference<'a>;
+}
+
+impl<'a> CompiledFunctionUnwindInfoLike<'a> for CompiledFunctionUnwindInfo {
+    fn get(&'a self) -> CompiledFunctionUnwindInfoReference<'a> {
+        match self {
+            Self::WindowsX64(v) => CompiledFunctionUnwindInfoReference::WindowsX64(v.as_ref()),
+            Self::Dwarf => CompiledFunctionUnwindInfoReference::Dwarf,
+        }
+    }
+}
+
+impl<'a> CompiledFunctionUnwindInfoLike<'a> for ArchivedCompiledFunctionUnwindInfo {
+    fn get(&'a self) -> CompiledFunctionUnwindInfoReference<'a> {
+        match self {
+            Self::WindowsX64(v) => CompiledFunctionUnwindInfoReference::WindowsX64(v.as_ref()),
+            Self::Dwarf => CompiledFunctionUnwindInfoReference::Dwarf,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/boxed_slice.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/boxed_slice.rs
new file mode 100644
index 0000000..585c1a1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/boxed_slice.rs
@@ -0,0 +1,317 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Boxed slices for `PrimaryMap`.
+
+use crate::entity::iter::{Iter, IterMut};
+use crate::entity::keys::Keys;
+use crate::entity::EntityRef;
+use crate::lib::std::boxed::Box;
+use crate::lib::std::marker::PhantomData;
+use crate::lib::std::ops::{Index, IndexMut};
+use crate::lib::std::slice;
+
+/// A slice mapping `K -> V` allocating dense entity references.
+///
+/// The `BoxedSlice` data structure uses the dense index space to implement a map with a boxed
+/// slice.
+#[derive(Debug, Clone)]
+pub struct BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    elems: Box<[V]>,
+    unused: PhantomData<K>,
+}
+
+impl<K, V> BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    /// Create a new slice from a raw pointer. A safer way to create slices is
+    /// to use `PrimaryMap::into_boxed_slice()`.
+    ///
+    /// # Safety
+    ///
+    /// This relies on `raw` pointing to a valid slice of `V`s.
+    pub unsafe fn from_raw(raw: *mut [V]) -> Self {
+        Self {
+            elems: Box::from_raw(raw),
+            unused: PhantomData,
+        }
+    }
+
+    /// Check if `k` is a valid key in the map.
+    pub fn is_valid(&self, k: K) -> bool {
+        k.index() < self.elems.len()
+    }
+
+    /// Get the element at `k` if it exists.
+    pub fn get(&self, k: K) -> Option<&V> {
+        self.elems.get(k.index())
+    }
+
+    /// Get the element at `k` if it exists, mutable version.
+    pub fn get_mut(&mut self, k: K) -> Option<&mut V> {
+        self.elems.get_mut(k.index())
+    }
+
+    /// Is this map completely empty?
+    pub fn is_empty(&self) -> bool {
+        self.elems.is_empty()
+    }
+
+    /// Get the total number of entity references created.
+    pub fn len(&self) -> usize {
+        self.elems.len()
+    }
+
+    /// Iterate over all the keys in this map.
+    pub fn keys(&self) -> Keys<K> {
+        Keys::with_len(self.elems.len())
+    }
+
+    /// Iterate over all the values in this map.
+    pub fn values(&self) -> slice::Iter<V> {
+        self.elems.iter()
+    }
+
+    /// Iterate over all the values in this map, mutable edition.
+    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+        self.elems.iter_mut()
+    }
+
+    /// Iterate over all the keys and values in this map.
+    pub fn iter(&self) -> Iter<K, V> {
+        Iter::new(self.elems.iter())
+    }
+
+    /// Iterate over all the keys and values in this map, mutable edition.
+    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+        IterMut::new(self.elems.iter_mut())
+    }
+
+    /// Returns the last element that was inserted in the map.
+    pub fn last(&self) -> Option<&V> {
+        self.elems.last()
+    }
+}
+
+/// Immutable indexing into a `BoxedSlice`.
+/// The indexed value must be in the map.
+impl<K, V> Index<K> for BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    type Output = V;
+
+    fn index(&self, k: K) -> &V {
+        &self.elems[k.index()]
+    }
+}
+
+/// Mutable indexing into a `BoxedSlice`.
+impl<K, V> IndexMut<K> for BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    fn index_mut(&mut self, k: K) -> &mut V {
+        &mut self.elems[k.index()]
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter::new(self.elems.iter())
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut BoxedSlice<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a mut V);
+    type IntoIter = IterMut<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IterMut::new(self.elems.iter_mut())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::entity::PrimaryMap;
+    use crate::lib::std::vec::Vec;
+
+    // `EntityRef` impl for testing.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct E(u32);
+
+    impl EntityRef for E {
+        fn new(i: usize) -> Self {
+            Self(i as u32)
+        }
+        fn index(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    #[test]
+    fn basic() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let p = PrimaryMap::<E, isize>::new();
+        let m = p.into_boxed_slice();
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, []);
+
+        assert!(!m.is_valid(r0));
+        assert!(!m.is_valid(r1));
+    }
+
+    #[test]
+    fn iter() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let mut m = p.into_boxed_slice();
+
+        let mut i = 0;
+        for (key, value) in &m {
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for (key_mut, value_mut) in m.iter_mut() {
+            assert_eq!(key_mut.index(), i);
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn iter_rev() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let mut m = p.into_boxed_slice();
+
+        let mut i = 2;
+        for (key, value) in m.iter().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+
+        i = 2;
+        for (key, value) in m.iter_mut().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+    }
+    #[test]
+    fn keys() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let m = p.into_boxed_slice();
+
+        for (i, key) in m.keys().enumerate() {
+            assert_eq!(key.index(), i);
+        }
+    }
+
+    #[test]
+    fn keys_rev() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let m = p.into_boxed_slice();
+
+        let mut i = 2;
+        for key in m.keys().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+        }
+    }
+
+    #[test]
+    fn values() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let mut m = p.into_boxed_slice();
+
+        let mut i = 0;
+        for value in m.values() {
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for value_mut in m.values_mut() {
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn values_rev() {
+        let mut p: PrimaryMap<E, usize> = PrimaryMap::new();
+        p.push(12);
+        p.push(33);
+        let mut m = p.into_boxed_slice();
+
+        let mut i = 2;
+        for value in m.values().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+        i = 2;
+        for value_mut in m.values_mut().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/iter.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/iter.rs
new file mode 100644
index 0000000..a157abe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/iter.rs
@@ -0,0 +1,127 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! A double-ended iterator over entity references and entities.
+
+use crate::entity::EntityRef;
+use crate::lib::std::iter::Enumerate;
+use crate::lib::std::marker::PhantomData;
+use crate::lib::std::slice;
+use crate::lib::std::vec;
+
+/// Iterate over all keys in order.
+pub struct Iter<'a, K: EntityRef, V>
+where
+    V: 'a,
+{
+    enumerate: Enumerate<slice::Iter<'a, V>>,
+    unused: PhantomData<K>,
+}
+
+impl<'a, K: EntityRef, V> Iter<'a, K, V> {
+    /// Create an `Iter` iterator that visits the `PrimaryMap` keys and values
+    /// of `iter`.
+    pub fn new(iter: slice::Iter<'a, V>) -> Self {
+        Self {
+            enumerate: iter.enumerate(),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<'a, K: EntityRef, V> Iterator for Iter<'a, K, V> {
+    type Item = (K, &'a V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.enumerate.size_hint()
+    }
+}
+
+impl<'a, K: EntityRef, V> DoubleEndedIterator for Iter<'a, K, V> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
+    }
+}
+
+impl<'a, K: EntityRef, V> ExactSizeIterator for Iter<'a, K, V> {}
+
+/// Iterate over all keys in order.
+pub struct IterMut<'a, K: EntityRef, V>
+where
+    V: 'a,
+{
+    enumerate: Enumerate<slice::IterMut<'a, V>>,
+    unused: PhantomData<K>,
+}
+
+impl<'a, K: EntityRef, V> IterMut<'a, K, V> {
+    /// Create an `IterMut` iterator that visits the `PrimaryMap` keys and values
+    /// of `iter`.
+    pub fn new(iter: slice::IterMut<'a, V>) -> Self {
+        Self {
+            enumerate: iter.enumerate(),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<'a, K: EntityRef, V> Iterator for IterMut<'a, K, V> {
+    type Item = (K, &'a mut V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.enumerate.size_hint()
+    }
+}
+
+impl<'a, K: EntityRef, V> DoubleEndedIterator for IterMut<'a, K, V> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
+    }
+}
+
+impl<'a, K: EntityRef, V> ExactSizeIterator for IterMut<'a, K, V> {}
+
+/// Iterate over all keys in order.
+pub struct IntoIter<K: EntityRef, V> {
+    enumerate: Enumerate<vec::IntoIter<V>>,
+    unused: PhantomData<K>,
+}
+
+impl<K: EntityRef, V> IntoIter<K, V> {
+    /// Create an `IntoIter` iterator that visits the `PrimaryMap` keys and values
+    /// of `iter`.
+    pub fn new(iter: vec::IntoIter<V>) -> Self {
+        Self {
+            enumerate: iter.enumerate(),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<K: EntityRef, V> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.enumerate.next().map(|(i, v)| (K::new(i), v))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.enumerate.size_hint()
+    }
+}
+
+impl<K: EntityRef, V> DoubleEndedIterator for IntoIter<K, V> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.enumerate.next_back().map(|(i, v)| (K::new(i), v))
+    }
+}
+
+impl<K: EntityRef, V> ExactSizeIterator for IntoIter<K, V> {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/keys.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/keys.rs
new file mode 100644
index 0000000..08d5a22
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/keys.rs
@@ -0,0 +1,61 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! A double-ended iterator over entity references.
+//!
+//! When `core::iter::Step` is stabilized, `Keys` could be implemented as a wrapper around
+//! `core::ops::Range`, but for now, we implement it manually.
+
+use crate::entity::EntityRef;
+use crate::lib::std::marker::PhantomData;
+
+/// Iterate over all keys in order.
+pub struct Keys<K: EntityRef> {
+    pos: usize,
+    rev_pos: usize,
+    unused: PhantomData<K>,
+}
+
+impl<K: EntityRef> Keys<K> {
+    /// Create a `Keys` iterator that visits `len` entities starting from 0.
+    pub fn with_len(len: usize) -> Self {
+        Self {
+            pos: 0,
+            rev_pos: len,
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<K: EntityRef> Iterator for Keys<K> {
+    type Item = K;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pos < self.rev_pos {
+            let k = K::new(self.pos);
+            self.pos += 1;
+            Some(k)
+        } else {
+            None
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let size = self.rev_pos - self.pos;
+        (size, Some(size))
+    }
+}
+
+impl<K: EntityRef> DoubleEndedIterator for Keys<K> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.rev_pos > self.pos {
+            let k = K::new(self.rev_pos - 1);
+            self.rev_pos -= 1;
+            Some(k)
+        } else {
+            None
+        }
+    }
+}
+
+impl<K: EntityRef> ExactSizeIterator for Keys<K> {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/mod.rs
new file mode 100644
index 0000000..7adbd67
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/mod.rs
@@ -0,0 +1,95 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+/// A type wrapping a small integer index should implement `EntityRef` so it can be used as the key
+/// of an `SecondaryMap` or `SparseMap`.
+pub trait EntityRef: Copy + Eq {
+    /// Create a new entity reference from a small integer.
+    /// This should crash if the requested index is not representable.
+    fn new(_: usize) -> Self;
+
+    /// Get the index that was used to create this entity reference.
+    fn index(self) -> usize;
+}
+
+/// Macro which provides the common implementation of a 32-bit entity reference.
+#[macro_export]
+macro_rules! entity_impl {
+    // Basic traits.
+    ($entity:ident) => {
+        impl $crate::entity::EntityRef for $entity {
+            fn new(index: usize) -> Self {
+                debug_assert!(index < ($crate::lib::std::u32::MAX as usize));
+                $entity(index as u32)
+            }
+
+            fn index(self) -> usize {
+                self.0 as usize
+            }
+        }
+
+        impl $crate::entity::packed_option::ReservedValue for $entity {
+            fn reserved_value() -> $entity {
+                $entity($crate::lib::std::u32::MAX)
+            }
+
+            fn is_reserved_value(&self) -> bool {
+                self.0 == $crate::lib::std::u32::MAX
+            }
+        }
+
+        impl $entity {
+            /// Create a new instance from a `u32`.
+            #[allow(dead_code)]
+            pub fn from_u32(x: u32) -> Self {
+                debug_assert!(x < $crate::lib::std::u32::MAX);
+                $entity(x)
+            }
+
+            /// Return the underlying index value as a `u32`.
+            #[allow(dead_code)]
+            pub fn as_u32(self) -> u32 {
+                self.0
+            }
+        }
+    };
+
+    // Include basic `Display` impl using the given display prefix.
+    // Display a `Block` reference as "block12".
+    ($entity:ident, $display_prefix:expr) => {
+        entity_impl!($entity);
+
+        impl $crate::lib::std::fmt::Display for $entity {
+            fn fmt(
+                &self,
+                f: &mut $crate::lib::std::fmt::Formatter,
+            ) -> $crate::lib::std::fmt::Result {
+                write!(f, concat!($display_prefix, "{}"), self.0)
+            }
+        }
+
+        impl $crate::lib::std::fmt::Debug for $entity {
+            fn fmt(
+                &self,
+                f: &mut $crate::lib::std::fmt::Formatter,
+            ) -> $crate::lib::std::fmt::Result {
+                (self as &dyn $crate::lib::std::fmt::Display).fmt(f)
+            }
+        }
+    };
+}
+
+pub mod packed_option;
+
+mod boxed_slice;
+mod iter;
+mod keys;
+mod primary_map;
+mod secondary_map;
+
+pub use crate::entity_impl;
+pub use boxed_slice::BoxedSlice;
+pub use iter::{Iter, IterMut};
+pub use keys::Keys;
+pub use primary_map::{ArchivedPrimaryMap, PrimaryMap};
+pub use secondary_map::SecondaryMap;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/packed_option.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/packed_option.rs
new file mode 100644
index 0000000..5ba5d80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/packed_option.rs
@@ -0,0 +1,175 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Compact representation of `Option<T>` for types with a reserved value.
+//!
+//! Small types are often used in tables and linked lists where an
+//! `Option<T>` is needed. Unfortunately, that would double the size of the tables
+//! because `Option<T>` is twice as big as `T`.
+//!
+//! This module provides a `PackedOption<T>` for types that have a reserved value that can be used
+//! to represent `None`.
+
+use crate::lib::std::fmt;
+use crate::lib::std::mem;
+
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Types that have a reserved value which can't be created any other way.
+pub trait ReservedValue {
+    /// Create an instance of the reserved value.
+    fn reserved_value() -> Self;
+    /// Checks whether value is the reserved one.
+    fn is_reserved_value(&self) -> bool;
+}
+
+/// Packed representation of `Option<T>`.
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct PackedOption<T: ReservedValue>(T);
+
+impl<T: ReservedValue> PackedOption<T> {
+    /// Returns `true` if the packed option is a `None` value.
+    pub fn is_none(&self) -> bool {
+        self.0.is_reserved_value()
+    }
+
+    /// Returns `true` if the packed option is a `Some` value.
+    pub fn is_some(&self) -> bool {
+        !self.0.is_reserved_value()
+    }
+
+    /// Expand the packed option into a normal `Option`.
+    pub fn expand(self) -> Option<T> {
+        if self.is_none() {
+            None
+        } else {
+            Some(self.0)
+        }
+    }
+
+    /// Maps a `PackedOption<T>` to `Option<U>` by applying a function to a contained value.
+    pub fn map<U, F>(self, f: F) -> Option<U>
+    where
+        F: FnOnce(T) -> U,
+    {
+        self.expand().map(f)
+    }
+
+    /// Unwrap a packed `Some` value or panic.
+    pub fn unwrap(self) -> T {
+        self.expand().unwrap()
+    }
+
+    /// Unwrap a packed `Some` value or panic.
+    pub fn expect(self, msg: &str) -> T {
+        self.expand().expect(msg)
+    }
+
+    /// Takes the value out of the packed option, leaving a `None` in its place.
+    pub fn take(&mut self) -> Option<T> {
+        mem::replace(self, None.into()).expand()
+    }
+}
+
+impl<T: ReservedValue> Default for PackedOption<T> {
+    /// Create a default packed option representing `None`.
+    fn default() -> Self {
+        Self(T::reserved_value())
+    }
+}
+
+impl<T: ReservedValue> From<T> for PackedOption<T> {
+    /// Convert `t` into a packed `Some(x)`.
+    fn from(t: T) -> Self {
+        debug_assert!(
+            !t.is_reserved_value(),
+            "Can't make a PackedOption from the reserved value."
+        );
+        Self(t)
+    }
+}
+
+impl<T: ReservedValue> From<Option<T>> for PackedOption<T> {
+    /// Convert an option into its packed equivalent.
+    fn from(opt: Option<T>) -> Self {
+        match opt {
+            None => Self::default(),
+            Some(t) => t.into(),
+        }
+    }
+}
+
+impl<T: ReservedValue> From<PackedOption<T>> for Option<T> {
+    fn from(other: PackedOption<T>) -> Self {
+        other.expand()
+    }
+}
+
+impl<T> fmt::Debug for PackedOption<T>
+where
+    T: ReservedValue + fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.is_none() {
+            write!(f, "None")
+        } else {
+            write!(f, "Some({:?})", self.0)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Dummy entity class, with no Copy or Clone.
+    #[derive(Debug, PartialEq, Eq)]
+    struct NoC(u32);
+
+    impl ReservedValue for NoC {
+        fn reserved_value() -> Self {
+            Self(13)
+        }
+
+        fn is_reserved_value(&self) -> bool {
+            self.0 == 13
+        }
+    }
+
+    #[test]
+    fn moves() {
+        let x = NoC(3);
+        let somex: PackedOption<NoC> = x.into();
+        assert!(!somex.is_none());
+        assert_eq!(somex.expand(), Some(NoC(3)));
+
+        let none: PackedOption<NoC> = None.into();
+        assert!(none.is_none());
+        assert_eq!(none.expand(), None);
+    }
+
+    // Dummy entity class, with Copy.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct Ent(u32);
+
+    impl ReservedValue for Ent {
+        fn reserved_value() -> Self {
+            Self(13)
+        }
+
+        fn is_reserved_value(&self) -> bool {
+            self.0 == 13
+        }
+    }
+
+    #[test]
+    fn copies() {
+        let x = Ent(2);
+        let some: PackedOption<Ent> = x.into();
+        let some2: Option<Ent> = x.into();
+        assert_eq!(some.expand(), some2);
+        assert_eq!(some, x.into());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/primary_map.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/primary_map.rs
new file mode 100644
index 0000000..cadfbf5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/primary_map.rs
@@ -0,0 +1,459 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Densely numbered entity references as mapping keys.
+use crate::entity::boxed_slice::BoxedSlice;
+use crate::entity::iter::{IntoIter, Iter, IterMut};
+use crate::entity::keys::Keys;
+use crate::entity::EntityRef;
+use crate::lib::std::boxed::Box;
+use crate::lib::std::iter::FromIterator;
+use crate::lib::std::marker::PhantomData;
+use crate::lib::std::ops::{Index, IndexMut};
+use crate::lib::std::slice;
+use crate::lib::std::vec::Vec;
+use rkyv::{Archive, Archived, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// A primary mapping `K -> V` allocating dense entity references.
+///
+/// The `PrimaryMap` data structure uses the dense index space to implement a map with a vector.
+///
+/// A primary map contains the main definition of an entity, and it can be used to allocate new
+/// entity references with the `push` method.
+///
+/// There should only be a single `PrimaryMap` instance for a given `EntityRef` type, otherwise
+/// conflicting references will be created. Using unknown keys for indexing will cause a panic.
+///
+/// Note that `PrimaryMap` doesn't implement `Deref` or `DerefMut`, which would allow
+/// `&PrimaryMap<K, V>` to convert to `&[V]`. One of the main advantages of `PrimaryMap` is
+/// that it only allows indexing with the distinct `EntityRef` key type, so converting to a
+/// plain slice would make it easier to use incorrectly. To make a slice of a `PrimaryMap`, use
+/// `into_boxed_slice`.
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    pub(crate) elems: Vec<V>,
+    pub(crate) unused: PhantomData<K>,
+}
+
+impl<K, V> PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    /// Create a new empty map.
+    pub fn new() -> Self {
+        Self {
+            elems: Vec::new(),
+            unused: PhantomData,
+        }
+    }
+
+    /// Create a new empty map with the given capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            elems: Vec::with_capacity(capacity),
+            unused: PhantomData,
+        }
+    }
+
+    /// Check if `k` is a valid key in the map.
+    pub fn is_valid(&self, k: K) -> bool {
+        k.index() < self.elems.len()
+    }
+
+    /// Get the element at `k` if it exists.
+    pub fn get(&self, k: K) -> Option<&V> {
+        self.elems.get(k.index())
+    }
+
+    /// Get the element at `k` if it exists, mutable version.
+    pub fn get_mut(&mut self, k: K) -> Option<&mut V> {
+        self.elems.get_mut(k.index())
+    }
+
+    /// Is this map completely empty?
+    pub fn is_empty(&self) -> bool {
+        self.elems.is_empty()
+    }
+
+    /// Get the total number of entity references created.
+    pub fn len(&self) -> usize {
+        self.elems.len()
+    }
+
+    /// Iterate over all the keys in this map.
+    pub fn keys(&self) -> Keys<K> {
+        Keys::with_len(self.elems.len())
+    }
+
+    /// Iterate over all the values in this map.
+    pub fn values(&self) -> slice::Iter<V> {
+        self.elems.iter()
+    }
+
+    /// Iterate over all the values in this map, mutable edition.
+    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+        self.elems.iter_mut()
+    }
+
+    /// Iterate over all the keys and values in this map.
+    pub fn iter(&self) -> Iter<K, V> {
+        Iter::new(self.elems.iter())
+    }
+
+    /// Iterate over all the keys and values in this map, mutable edition.
+    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+        IterMut::new(self.elems.iter_mut())
+    }
+
+    /// Remove all entries from this map.
+    pub fn clear(&mut self) {
+        self.elems.clear()
+    }
+
+    /// Get the key that will be assigned to the next pushed value.
+    pub fn next_key(&self) -> K {
+        K::new(self.elems.len())
+    }
+
+    /// Append `v` to the mapping, assigning a new key which is returned.
+    pub fn push(&mut self, v: V) -> K {
+        let k = self.next_key();
+        self.elems.push(v);
+        k
+    }
+
+    /// Returns the last element that was inserted in the map.
+    pub fn last(&self) -> Option<&V> {
+        self.elems.last()
+    }
+
+    /// Reserves capacity for at least `additional` more elements to be inserted.
+    pub fn reserve(&mut self, additional: usize) {
+        self.elems.reserve(additional)
+    }
+
+    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted.
+    pub fn reserve_exact(&mut self, additional: usize) {
+        self.elems.reserve_exact(additional)
+    }
+
+    /// Shrinks the capacity of the `PrimaryMap` as much as possible.
+    pub fn shrink_to_fit(&mut self) {
+        self.elems.shrink_to_fit()
+    }
+
+    /// Consumes this `PrimaryMap` and produces a `BoxedSlice`.
+    pub fn into_boxed_slice(self) -> BoxedSlice<K, V> {
+        unsafe { BoxedSlice::<K, V>::from_raw(Box::<[V]>::into_raw(self.elems.into_boxed_slice())) }
+    }
+}
+
+impl<K, V> Default for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Immutable indexing into an `PrimaryMap`.
+/// The indexed value must be in the map.
+impl<K, V> Index<K> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Output = V;
+
+    fn index(&self, k: K) -> &V {
+        &self.elems[k.index()]
+    }
+}
+
+/// Mutable indexing into an `PrimaryMap`.
+impl<K, V> IndexMut<K> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn index_mut(&mut self, k: K) -> &mut V {
+        &mut self.elems[k.index()]
+    }
+}
+
+impl<K, V> IntoIterator for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter::new(self.elems.into_iter())
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a V);
+    type IntoIter = Iter<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        Iter::new(self.elems.iter())
+    }
+}
+
+impl<'a, K, V> IntoIterator for &'a mut PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    type Item = (K, &'a mut V);
+    type IntoIter = IterMut<'a, K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IterMut::new(self.elems.iter_mut())
+    }
+}
+
+impl<K, V> FromIterator<V> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn from_iter<T>(iter: T) -> Self
+    where
+        T: IntoIterator<Item = V>,
+    {
+        Self {
+            elems: Vec::from_iter(iter),
+            unused: PhantomData,
+        }
+    }
+}
+
+impl<K, V> ArchivedPrimaryMap<K, V>
+where
+    K: EntityRef,
+    V: Archive,
+{
+    /// Iterator over all values in the `ArchivedPrimaryMap`
+    pub fn values(&self) -> slice::Iter<Archived<V>> {
+        self.elems.iter()
+    }
+
+    /// Iterate over all the keys and values in this map.
+    pub fn iter(&self) -> Iter<K, Archived<V>> {
+        Iter::new(self.elems.iter())
+    }
+}
+
+/// Immutable indexing into an `ArchivedPrimaryMap`.
+/// The indexed value must be in the map.
+impl<K, V> Index<K> for ArchivedPrimaryMap<K, V>
+where
+    K: EntityRef,
+    V: Archive,
+{
+    type Output = Archived<V>;
+
+    fn index(&self, k: K) -> &Self::Output {
+        &self.elems[k.index()]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // `EntityRef` impl for testing.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct E(u32);
+
+    impl EntityRef for E {
+        fn new(i: usize) -> Self {
+            Self(i as u32)
+        }
+        fn index(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    #[test]
+    fn basic() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let m = PrimaryMap::<E, isize>::new();
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, []);
+
+        assert!(!m.is_valid(r0));
+        assert!(!m.is_valid(r1));
+    }
+
+    #[test]
+    fn push() {
+        let mut m = PrimaryMap::new();
+        let k0: E = m.push(12);
+        let k1 = m.push(33);
+
+        assert_eq!(m[k0], 12);
+        assert_eq!(m[k1], 33);
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, [k0, k1]);
+    }
+
+    #[test]
+    fn iter() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 0;
+        for (key, value) in &m {
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for (key_mut, value_mut) in m.iter_mut() {
+            assert_eq!(key_mut.index(), i);
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn iter_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for (key, value) in m.iter().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+
+        i = 2;
+        for (key, value) in m.iter_mut().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+    }
+    #[test]
+    fn keys() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        for (i, key) in m.keys().enumerate() {
+            assert_eq!(key.index(), i);
+        }
+    }
+
+    #[test]
+    fn keys_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for key in m.keys().rev() {
+            i -= 1;
+            assert_eq!(key.index(), i);
+        }
+    }
+
+    #[test]
+    fn values() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 0;
+        for value in m.values() {
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+        i = 0;
+        for value_mut in m.values_mut() {
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn values_rev() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let mut i = 2;
+        for value in m.values().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value, 12),
+                1 => assert_eq!(*value, 33),
+                _ => panic!(),
+            }
+        }
+        i = 2;
+        for value_mut in m.values_mut().rev() {
+            i -= 1;
+            match i {
+                0 => assert_eq!(*value_mut, 12),
+                1 => assert_eq!(*value_mut, 33),
+                _ => panic!(),
+            }
+        }
+    }
+
+    #[test]
+    fn from_iter() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let n = m.values().collect::<PrimaryMap<E, _>>();
+        assert!(m.len() == n.len());
+        for (me, ne) in m.values().zip(n.values()) {
+            assert!(*me == **ne);
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/secondary_map.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/secondary_map.rs
new file mode 100644
index 0000000..894dd81
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/entity/secondary_map.rs
@@ -0,0 +1,325 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Densely numbered entity references as mapping keys.
+
+use crate::entity::iter::{Iter, IterMut};
+use crate::entity::keys::Keys;
+use crate::entity::EntityRef;
+use crate::lib::std::cmp::min;
+use crate::lib::std::marker::PhantomData;
+use crate::lib::std::ops::{Index, IndexMut};
+use crate::lib::std::slice;
+use crate::lib::std::vec::Vec;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{
+    de::{Deserializer, SeqAccess, Visitor},
+    ser::{SerializeSeq, Serializer},
+    Deserialize, Serialize,
+};
+
+/// A mapping `K -> V` for densely indexed entity references.
+///
+/// The `SecondaryMap` data structure uses the dense index space to implement a map with a vector.
+/// Unlike `PrimaryMap`, an `SecondaryMap` can't be used to allocate entity references. It is used
+/// to associate secondary information with entities.
+///
+/// The map does not track if an entry for a key has been inserted or not. Instead it behaves as if
+/// all keys have a default entry from the beginning.
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(rkyv::CheckBytes))]
+pub struct SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone,
+{
+    pub(crate) elems: Vec<V>,
+    pub(crate) default: V,
+    pub(crate) unused: PhantomData<K>,
+}
+
+/// Shared `SecondaryMap` implementation for all value types.
+impl<K, V> SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone,
+{
+    /// Create a new empty map.
+    pub fn new() -> Self
+    where
+        V: Default,
+    {
+        Self {
+            elems: Vec::new(),
+            default: Default::default(),
+            unused: PhantomData,
+        }
+    }
+
+    /// Create a new, empty map with the specified capacity.
+    ///
+    /// The map will be able to hold exactly `capacity` elements without reallocating.
+    pub fn with_capacity(capacity: usize) -> Self
+    where
+        V: Default,
+    {
+        Self {
+            elems: Vec::with_capacity(capacity),
+            default: Default::default(),
+            unused: PhantomData,
+        }
+    }
+
+    /// Create a new empty map with a specified default value.
+    ///
+    /// This constructor does not require V to implement Default.
+    pub fn with_default(default: V) -> Self {
+        Self {
+            elems: Vec::new(),
+            default,
+            unused: PhantomData,
+        }
+    }
+
+    /// Returns the number of elements the map can hold without reallocating.
+    pub fn capacity(&self) -> usize {
+        self.elems.capacity()
+    }
+
+    /// Get the element at `k` if it exists.
+    #[inline(always)]
+    pub fn get(&self, k: K) -> Option<&V> {
+        self.elems.get(k.index())
+    }
+
+    /// Is this map completely empty?
+    #[inline(always)]
+    pub fn is_empty(&self) -> bool {
+        self.elems.is_empty()
+    }
+
+    /// Remove all entries from this map.
+    #[inline(always)]
+    pub fn clear(&mut self) {
+        self.elems.clear()
+    }
+
+    /// Iterate over all the keys and values in this map.
+    pub fn iter(&self) -> Iter<K, V> {
+        Iter::new(self.elems.iter())
+    }
+
+    /// Iterate over all the keys and values in this map, mutable edition.
+    pub fn iter_mut(&mut self) -> IterMut<K, V> {
+        IterMut::new(self.elems.iter_mut())
+    }
+
+    /// Iterate over all the keys in this map.
+    pub fn keys(&self) -> Keys<K> {
+        Keys::with_len(self.elems.len())
+    }
+
+    /// Iterate over all the values in this map.
+    pub fn values(&self) -> slice::Iter<V> {
+        self.elems.iter()
+    }
+
+    /// Iterate over all the values in this map, mutable edition.
+    pub fn values_mut(&mut self) -> slice::IterMut<V> {
+        self.elems.iter_mut()
+    }
+
+    /// Resize the map to have `n` entries by adding default entries as needed.
+    pub fn resize(&mut self, n: usize) {
+        self.elems.resize(n, self.default.clone());
+    }
+}
+
+impl<K, V> Default for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Default,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Immutable indexing into an `SecondaryMap`.
+///
+/// All keys are permitted. Untouched entries have the default value.
+impl<K, V> Index<K> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone,
+{
+    type Output = V;
+
+    #[inline(always)]
+    fn index(&self, k: K) -> &V {
+        self.elems.get(k.index()).unwrap_or(&self.default)
+    }
+}
+
+/// Mutable indexing into an `SecondaryMap`.
+///
+/// The map grows as needed to accommodate new keys.
+impl<K, V> IndexMut<K> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone,
+{
+    #[inline(always)]
+    fn index_mut(&mut self, k: K) -> &mut V {
+        let i = k.index();
+        if i >= self.elems.len() {
+            self.elems.resize(i + 1, self.default.clone());
+        }
+        &mut self.elems[i]
+    }
+}
+
+impl<K, V> PartialEq for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        let min_size = min(self.elems.len(), other.elems.len());
+        self.default == other.default
+            && self.elems[..min_size] == other.elems[..min_size]
+            && self.elems[min_size..].iter().all(|e| *e == self.default)
+            && other.elems[min_size..].iter().all(|e| *e == other.default)
+    }
+}
+
+impl<K, V> Eq for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + PartialEq + Eq,
+{
+}
+
+#[cfg(feature = "enable-serde")]
+impl<K, V> Serialize for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + PartialEq + Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        // TODO: bincode encodes option as "byte for Some/None" and then optionally the content
+        // TODO: we can actually optimize it by encoding manually bitmask, then elements
+        let mut elems_cnt = self.elems.len();
+        while elems_cnt > 0 && self.elems[elems_cnt - 1] == self.default {
+            elems_cnt -= 1;
+        }
+        let mut seq = serializer.serialize_seq(Some(1 + elems_cnt))?;
+        seq.serialize_element(&Some(self.default.clone()))?;
+        for e in self.elems.iter().take(elems_cnt) {
+            let some_e = Some(e);
+            seq.serialize_element(if *e == self.default { &None } else { &some_e })?;
+        }
+        seq.end()
+    }
+}
+
+#[cfg(feature = "enable-serde")]
+impl<'de, K, V> Deserialize<'de> for SecondaryMap<K, V>
+where
+    K: EntityRef,
+    V: Clone + Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        use crate::lib::std::fmt;
+
+        struct SecondaryMapVisitor<K, V> {
+            unused: PhantomData<fn(K) -> V>,
+        }
+
+        impl<'de, K, V> Visitor<'de> for SecondaryMapVisitor<K, V>
+        where
+            K: EntityRef,
+            V: Clone + Deserialize<'de>,
+        {
+            type Value = SecondaryMap<K, V>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("struct SecondaryMap")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                match seq.next_element()? {
+                    Some(Some(default_val)) => {
+                        let default_val: V = default_val; // compiler can't infer the type
+                        let mut m = SecondaryMap::with_default(default_val.clone());
+                        let mut idx = 0;
+                        while let Some(val) = seq.next_element()? {
+                            let val: Option<_> = val; // compiler can't infer the type
+                            m[K::new(idx)] = val.unwrap_or_else(|| default_val.clone());
+                            idx += 1;
+                        }
+                        Ok(m)
+                    }
+                    _ => Err(serde::de::Error::custom("Default value required")),
+                }
+            }
+        }
+
+        deserializer.deserialize_seq(SecondaryMapVisitor {
+            unused: PhantomData {},
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // `EntityRef` impl for testing.
+    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+    struct E(u32);
+
+    impl EntityRef for E {
+        fn new(i: usize) -> Self {
+            Self(i as u32)
+        }
+        fn index(self) -> usize {
+            self.0 as usize
+        }
+    }
+
+    #[test]
+    fn basic() {
+        let r0 = E(0);
+        let r1 = E(1);
+        let r2 = E(2);
+        let mut m = SecondaryMap::new();
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, []);
+
+        m[r2] = 3;
+        m[r1] = 5;
+
+        assert_eq!(m[r1], 5);
+        assert_eq!(m[r2], 3);
+
+        let v: Vec<E> = m.keys().collect();
+        assert_eq!(v, [r0, r1, r2]);
+
+        let shared = &m;
+        assert_eq!(shared[r0], 0);
+        assert_eq!(shared[r1], 5);
+        assert_eq!(shared[r2], 3);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/error.rs
new file mode 100644
index 0000000..c25f2d0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/error.rs
@@ -0,0 +1,296 @@
+//! The WebAssembly possible errors
+use crate::{ExternType, Pages};
+use std::io;
+use thiserror::Error;
+
+/// The Serialize error can occur when serializing a
+/// compiled Module into a binary.
+#[derive(Error, Debug)]
+pub enum SerializeError {
+    /// An IO error
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// A generic serialization error
+    #[error("{0}")]
+    Generic(String),
+}
+
+/// The Deserialize error can occur when loading a
+/// compiled Module from a binary.
+#[derive(Error, Debug)]
+pub enum DeserializeError {
+    /// An IO error
+    #[error(transparent)]
+    Io(#[from] io::Error),
+    /// A generic deserialization error
+    #[error("{0}")]
+    Generic(String),
+    /// Incompatible serialized binary
+    #[error("incompatible binary: {0}")]
+    Incompatible(String),
+    /// The provided binary is corrupted
+    #[error("corrupted binary: {0}")]
+    CorruptedBinary(String),
+    /// The binary was valid, but we got an error when
+    /// trying to allocate the required resources.
+    #[error(transparent)]
+    Compiler(#[from] CompileError),
+    /// Input artifact bytes have an invalid length
+    #[error("invalid input bytes: expected {expected} bytes, got {got}")]
+    InvalidByteLength {
+        /// How many bytes were expected
+        expected: usize,
+        /// How many bytes the artifact contained
+        got: usize,
+    },
+}
+
+/// Error type describing things that can go wrong when operating on Wasm Memories.
+#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum MemoryError {
+    /// Low level error with mmap.
+    #[error("Error when allocating memory: {0}")]
+    Region(String),
+    /// The operation would cause the size of the memory to exceed the maximum or would cause
+    /// an overflow leading to unindexable memory.
+    #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)]
+    CouldNotGrow {
+        /// The current size in pages.
+        current: Pages,
+        /// The attempted amount to grow by in pages.
+        attempted_delta: Pages,
+    },
+    /// Invalid memory was provided.
+    #[error("The memory is invalid because {}", reason)]
+    InvalidMemory {
+        /// The reason why the provided memory is invalid.
+        reason: String,
+    },
+    /// Caller asked for more minimum memory than we can give them.
+    #[error("The minimum requested ({} pages) memory is greater than the maximum allowed memory ({} pages)", min_requested.0, max_allowed.0)]
+    MinimumMemoryTooLarge {
+        /// The number of pages requested as the minimum amount of memory.
+        min_requested: Pages,
+        /// The maximum amount of memory we can allocate.
+        max_allowed: Pages,
+    },
+    /// Caller asked for a maximum memory greater than we can give them.
+    #[error("The maximum requested memory ({} pages) is greater than the maximum allowed memory ({} pages)", max_requested.0, max_allowed.0)]
+    MaximumMemoryTooLarge {
+        /// The number of pages requested as the maximum amount of memory.
+        max_requested: Pages,
+        /// The number of pages requested as the maximum amount of memory.
+        max_allowed: Pages,
+    },
+    /// Returned when a shared memory is required, but the given memory is not shared.
+    #[error("The memory is not shared")]
+    MemoryNotShared,
+    /// Returned when trying to call a memory operation that is not supported by
+    /// the particular memory implementation.
+    #[error("tried to call an unsupported memory operation: {message}")]
+    UnsupportedOperation {
+        /// Message describing the unsupported operation.
+        message: String,
+    },
+    /// The memory does not support atomic operations.
+    #[error("The memory does not support atomic operations")]
+    AtomicsNotSupported,
+    /// A user defined error value, used for error cases not listed above.
+    #[error("A user-defined error occurred: {0}")]
+    Generic(String),
+}
+
+/// An ImportError.
+///
+/// Note: this error is not standard to WebAssembly, but it's
+/// useful to determine the import issue on the API side.
+#[derive(Error, Debug, Clone)]
+pub enum ImportError {
+    /// Incompatible Import Type.
+    /// This error occurs when the import types mismatch.
+    #[error("incompatible import type. Expected {0:?} but received {1:?}")]
+    IncompatibleType(ExternType, ExternType),
+
+    /// Unknown Import.
+    /// This error occurs when an import was expected but not provided.
+    #[error("unknown import. Expected {0:?}")]
+    UnknownImport(ExternType),
+
+    /// Memory Error
+    #[error("memory error. {0}")]
+    MemoryError(String),
+}
+
+/// An error while preinstantiating a module.
+///
+#[derive(Error, Debug)]
+pub enum PreInstantiationError {
+    /// The module was compiled with a CPU feature that is not available on
+    /// the current host.
+    #[error("module compiled with CPU feature that is missing from host")]
+    CpuFeature(String),
+}
+
+use crate::lib::std::string::String;
+
+// Compilation Errors
+//
+// If `std` feature is enable, we can't use `thiserror` until
+// https://github.com/dtolnay/thiserror/pull/64 is merged.
+
+/// The WebAssembly.CompileError object indicates an error during
+/// WebAssembly decoding or validation.
+///
+/// This is based on the [Wasm Compile Error][compile-error] API.
+///
+/// [compiler-error]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(Error))]
+pub enum CompileError {
+    /// A Wasm translation error occured.
+    #[cfg_attr(feature = "std", error("WebAssembly translation error: {0}"))]
+    Wasm(WasmError),
+
+    /// A compilation error occured.
+    #[cfg_attr(feature = "std", error("Compilation error: {0}"))]
+    Codegen(String),
+
+    /// The module did not pass validation.
+    #[cfg_attr(feature = "std", error("Validation error: {0}"))]
+    Validate(String),
+
+    /// The compiler doesn't support a Wasm feature
+    #[cfg_attr(feature = "std", error("Feature {0} is not yet supported"))]
+    UnsupportedFeature(String),
+
+    /// The compiler cannot compile for the given target.
+    /// This can refer to the OS, the chipset or any other aspect of the target system.
+    #[cfg_attr(
+        feature = "std",
+        error("The target {0} is not yet supported (see https://docs.wasmer.io/runtime/features)")
+    )]
+    UnsupportedTarget(String),
+
+    /// Insufficient resources available for execution.
+    #[cfg_attr(feature = "std", error("Insufficient resources: {0}"))]
+    Resource(String),
+}
+
+impl From<WasmError> for CompileError {
+    fn from(original: WasmError) -> Self {
+        Self::Wasm(original)
+    }
+}
+
+/// A error in the middleware.
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(Error))]
+#[cfg_attr(feature = "std", error("Error in middleware {name}: {message}"))]
+pub struct MiddlewareError {
+    /// The name of the middleware where the error was created
+    pub name: String,
+    /// The error message
+    pub message: String,
+}
+
+impl MiddlewareError {
+    /// Create a new `MiddlewareError`
+    pub fn new<A: Into<String>, B: Into<String>>(name: A, message: B) -> Self {
+        Self {
+            name: name.into(),
+            message: message.into(),
+        }
+    }
+}
+
+impl From<MiddlewareError> for CompileError {
+    fn from(error: MiddlewareError) -> Self {
+        WasmError::Middleware(error).into()
+    }
+}
+
+/// A WebAssembly translation error.
+///
+/// When a WebAssembly function can't be translated, one of these error codes will be returned
+/// to describe the failure.
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(Error))]
+pub enum WasmError {
+    /// The input WebAssembly code is invalid.
+    ///
+    /// This error code is used by a WebAssembly translator when it encounters invalid WebAssembly
+    /// code. This should never happen for validated WebAssembly code.
+    #[cfg_attr(
+        feature = "std",
+        error("Invalid input WebAssembly code at offset {offset}: {message}")
+    )]
+    InvalidWebAssembly {
+        /// A string describing the validation error.
+        message: String,
+        /// The bytecode offset where the error occurred.
+        offset: usize,
+    },
+
+    /// A feature used by the WebAssembly code is not supported by the embedding environment.
+    ///
+    /// Embedding environments may have their own limitations and feature restrictions.
+    #[cfg_attr(feature = "std", error("Unsupported feature: {0}"))]
+    Unsupported(String),
+
+    /// An implementation limit was exceeded.
+    #[cfg_attr(feature = "std", error("Implementation limit exceeded"))]
+    ImplLimitExceeded,
+
+    /// An error from the middleware error.
+    #[cfg_attr(feature = "std", error("{0}"))]
+    Middleware(MiddlewareError),
+
+    /// A generic error.
+    #[cfg_attr(feature = "std", error("{0}"))]
+    Generic(String),
+}
+
+impl From<MiddlewareError> for WasmError {
+    fn from(original: MiddlewareError) -> Self {
+        Self::Middleware(original)
+    }
+}
+
+/// The error that can happen while parsing a `str`
+/// to retrieve a [`CpuFeature`](crate::CpuFeature).
+#[derive(Debug)]
+#[cfg_attr(feature = "std", derive(Error))]
+pub enum ParseCpuFeatureError {
+    /// The provided string feature doesn't exist
+    #[cfg_attr(feature = "std", error("CpuFeature {0} not recognized"))]
+    Missing(String),
+}
+
+/// A convenient alias for a `Result` that uses `WasmError` as the error type.
+pub type WasmResult<T> = Result<T, WasmError>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn middleware_error_can_be_created() {
+        let msg = String::from("Something went wrong");
+        let error = MiddlewareError::new("manipulator3000", msg);
+        assert_eq!(error.name, "manipulator3000");
+        assert_eq!(error.message, "Something went wrong");
+    }
+
+    #[test]
+    fn middleware_error_be_converted_to_wasm_error() {
+        let error = WasmError::from(MiddlewareError::new("manipulator3000", "foo"));
+        match error {
+            WasmError::Middleware(MiddlewareError { name, message }) => {
+                assert_eq!(name, "manipulator3000");
+                assert_eq!(message, "foo");
+            }
+            err => panic!("Unexpected error: {:?}", err),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/features.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/features.rs
new file mode 100644
index 0000000..5419776
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/features.rs
@@ -0,0 +1,343 @@
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Controls which experimental features will be enabled.
+/// Features usually have a corresponding [WebAssembly proposal].
+///
+/// [WebAssembly proposal]: https://github.com/WebAssembly/proposals
+#[derive(Clone, Debug, Eq, PartialEq, rkyv::CheckBytes)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive(as = "Self")]
+pub struct Features {
+    /// Threads proposal should be enabled
+    pub threads: bool,
+    /// Reference Types proposal should be enabled
+    pub reference_types: bool,
+    /// SIMD proposal should be enabled
+    pub simd: bool,
+    /// Bulk Memory proposal should be enabled
+    pub bulk_memory: bool,
+    /// Multi Value proposal should be enabled
+    pub multi_value: bool,
+    /// Tail call proposal should be enabled
+    pub tail_call: bool,
+    /// Module Linking proposal should be enabled
+    pub module_linking: bool,
+    /// Multi Memory proposal should be enabled
+    pub multi_memory: bool,
+    /// 64-bit Memory proposal should be enabled
+    pub memory64: bool,
+    /// Wasm exceptions proposal should be enabled
+    pub exceptions: bool,
+    /// Relaxed SIMD proposal should be enabled
+    pub relaxed_simd: bool,
+    /// Extended constant expressions proposal should be enabled
+    pub extended_const: bool,
+}
+
+impl Features {
+    /// Create a new feature
+    pub fn new() -> Self {
+        Self {
+            threads: true,
+            // Reference types should be on by default
+            reference_types: true,
+            // SIMD should be on by default
+            simd: true,
+            // Bulk Memory should be on by default
+            bulk_memory: true,
+            // Multivalue should be on by default
+            multi_value: true,
+            tail_call: false,
+            module_linking: false,
+            multi_memory: false,
+            memory64: false,
+            exceptions: false,
+            relaxed_simd: false,
+            extended_const: false,
+        }
+    }
+
+    /// Configures whether the WebAssembly threads proposal will be enabled.
+    ///
+    /// The [WebAssembly threads proposal][threads] is not currently fully
+    /// standardized and is undergoing development. Support for this feature can
+    /// be enabled through this method for appropriate WebAssembly modules.
+    ///
+    /// This feature gates items such as shared memories and atomic
+    /// instructions.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [threads]: https://github.com/webassembly/threads
+    pub fn threads(&mut self, enable: bool) -> &mut Self {
+        self.threads = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly reference types proposal will be
+    /// enabled.
+    ///
+    /// The [WebAssembly reference types proposal][proposal] is now
+    /// fully standardized and enabled by default.
+    ///
+    /// This feature gates items such as the `externref` type and multiple tables
+    /// being in a module. Note that enabling the reference types feature will
+    /// also enable the bulk memory feature.
+    ///
+    /// This is `true` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/reference-types
+    pub fn reference_types(&mut self, enable: bool) -> &mut Self {
+        self.reference_types = enable;
+        // The reference types proposal depends on the bulk memory proposal
+        if enable {
+            self.bulk_memory(true);
+        }
+        self
+    }
+
+    /// Configures whether the WebAssembly SIMD proposal will be
+    /// enabled.
+    ///
+    /// The [WebAssembly SIMD proposal][proposal] is not currently
+    /// fully standardized and is undergoing development. Support for this
+    /// feature can be enabled through this method for appropriate WebAssembly
+    /// modules.
+    ///
+    /// This feature gates items such as the `v128` type and all of its
+    /// operators being in a module.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/simd
+    pub fn simd(&mut self, enable: bool) -> &mut Self {
+        self.simd = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly bulk memory operations proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly bulk memory operations proposal][proposal] is now
+    /// fully standardized and enabled by default.
+    ///
+    /// This feature gates items such as the `memory.copy` instruction, passive
+    /// data/table segments, etc, being in a module.
+    ///
+    /// This is `true` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/bulk-memory-operations
+    pub fn bulk_memory(&mut self, enable: bool) -> &mut Self {
+        self.bulk_memory = enable;
+        // In case is false, we disable both threads and reference types
+        // since they both depend on bulk memory
+        if !enable {
+            self.reference_types(false);
+        }
+        self
+    }
+
+    /// Configures whether the WebAssembly multi-value proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly multi-value proposal][proposal] is now fully
+    /// standardized and enabled by default, except with the singlepass
+    /// compiler which does not support it.
+    ///
+    /// This feature gates functions and blocks returning multiple values in a
+    /// module, for example.
+    ///
+    /// This is `true` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/multi-value
+    pub fn multi_value(&mut self, enable: bool) -> &mut Self {
+        self.multi_value = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly tail-call proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly tail-call proposal][proposal] is not
+    /// currently fully standardized and is undergoing development.
+    /// Support for this feature can be enabled through this method for
+    /// appropriate WebAssembly modules.
+    ///
+    /// This feature gates tail-call functions in WebAssembly.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/tail-call
+    pub fn tail_call(&mut self, enable: bool) -> &mut Self {
+        self.tail_call = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly module linking proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly module linking proposal][proposal] is not
+    /// currently fully standardized and is undergoing development.
+    /// Support for this feature can be enabled through this method for
+    /// appropriate WebAssembly modules.
+    ///
+    /// This feature allows WebAssembly modules to define, import and
+    /// export modules and instances.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/module-linking
+    pub fn module_linking(&mut self, enable: bool) -> &mut Self {
+        self.module_linking = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly multi-memory proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly multi-memory proposal][proposal] is not
+    /// currently fully standardized and is undergoing development.
+    /// Support for this feature can be enabled through this method for
+    /// appropriate WebAssembly modules.
+    ///
+    /// This feature adds the ability to use multiple memories within a
+    /// single Wasm module.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [proposal]: https://github.com/WebAssembly/multi-memory
+    pub fn multi_memory(&mut self, enable: bool) -> &mut Self {
+        self.multi_memory = enable;
+        self
+    }
+
+    /// Configures whether the WebAssembly 64-bit memory proposal will
+    /// be enabled.
+    ///
+    /// The [WebAssembly 64-bit memory proposal][proposal] is not
+    /// currently fully standardized and is undergoing development.
+    /// Support for this feature can be enabled through this method for
+    /// appropriate WebAssembly modules.
+    ///
+    /// This feature gates support for linear memory of sizes larger than
+    /// 2^32 bits.
+    ///
+    /// This is `false` by default.
+    ///
+    /// [proposal]: https://github.com/WebAssembly/memory64
+    pub fn memory64(&mut self, enable: bool) -> &mut Self {
+        self.memory64 = enable;
+        self
+    }
+}
+
+impl Default for Features {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod test_features {
+    use super::*;
+    #[test]
+    fn default_features() {
+        let default = Features::default();
+        assert_eq!(
+            default,
+            Features {
+                threads: true,
+                reference_types: true,
+                simd: true,
+                bulk_memory: true,
+                multi_value: true,
+                tail_call: false,
+                module_linking: false,
+                multi_memory: false,
+                memory64: false,
+                exceptions: false,
+                relaxed_simd: false,
+                extended_const: false,
+            }
+        );
+    }
+
+    #[test]
+    fn enable_threads() {
+        let mut features = Features::new();
+        features.bulk_memory(false).threads(true);
+
+        assert!(features.threads);
+    }
+
+    #[test]
+    fn enable_reference_types() {
+        let mut features = Features::new();
+        features.bulk_memory(false).reference_types(true);
+        assert!(features.reference_types);
+        assert!(features.bulk_memory);
+    }
+
+    #[test]
+    fn enable_simd() {
+        let mut features = Features::new();
+        features.simd(true);
+        assert!(features.simd);
+    }
+
+    #[test]
+    fn enable_multi_value() {
+        let mut features = Features::new();
+        features.multi_value(true);
+        assert!(features.multi_value);
+    }
+
+    #[test]
+    fn enable_bulk_memory() {
+        let mut features = Features::new();
+        features.bulk_memory(true);
+        assert!(features.bulk_memory);
+    }
+
+    #[test]
+    fn disable_bulk_memory() {
+        let mut features = Features::new();
+        features
+            .threads(true)
+            .reference_types(true)
+            .bulk_memory(false);
+        assert!(!features.bulk_memory);
+        assert!(!features.reference_types);
+    }
+
+    #[test]
+    fn enable_tail_call() {
+        let mut features = Features::new();
+        features.tail_call(true);
+        assert!(features.tail_call);
+    }
+
+    #[test]
+    fn enable_module_linking() {
+        let mut features = Features::new();
+        features.module_linking(true);
+        assert!(features.module_linking);
+    }
+
+    #[test]
+    fn enable_multi_memory() {
+        let mut features = Features::new();
+        features.multi_memory(true);
+        assert!(features.multi_memory);
+    }
+
+    #[test]
+    fn enable_memory64() {
+        let mut features = Features::new();
+        features.memory64(true);
+        assert!(features.memory64);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/indexes.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/indexes.rs
new file mode 100644
index 0000000..3bf3883
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/indexes.rs
@@ -0,0 +1,275 @@
+//! Helper functions and structures for the translation.
+use crate::entity::entity_impl;
+use core::u32;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Index type of a function defined locally inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct LocalFunctionIndex(u32);
+entity_impl!(LocalFunctionIndex);
+
+/// Index type of a table defined locally inside the WebAssembly module.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct LocalTableIndex(u32);
+entity_impl!(LocalTableIndex);
+
+/// Index type of a memory defined locally inside the WebAssembly module.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct LocalMemoryIndex(u32);
+entity_impl!(LocalMemoryIndex);
+
+/// Index type of a global defined locally inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct LocalGlobalIndex(u32);
+entity_impl!(LocalGlobalIndex);
+
+/// Index type of a function (imported or local) inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct FunctionIndex(u32);
+entity_impl!(FunctionIndex);
+
+/// Index type of a table (imported or local) inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct TableIndex(u32);
+entity_impl!(TableIndex);
+
+/// Index type of a global variable (imported or local) inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct GlobalIndex(u32);
+entity_impl!(GlobalIndex);
+
+/// Index type of a linear memory (imported or local) inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct MemoryIndex(u32);
+entity_impl!(MemoryIndex);
+
+/// Index type of a signature (imported or local) inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct SignatureIndex(u32);
+entity_impl!(SignatureIndex);
+
+/// Index type of a passive data segment inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct DataIndex(u32);
+entity_impl!(DataIndex);
+
+/// Index type of a passive element segment inside the WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct ElemIndex(u32);
+entity_impl!(ElemIndex);
+
+/// Index type of a custom section inside a WebAssembly module.
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Debug,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct CustomSectionIndex(u32);
+entity_impl!(CustomSectionIndex);
+
+/// An entity to export.
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum ExportIndex {
+    /// Function export.
+    Function(FunctionIndex),
+    /// Table export.
+    Table(TableIndex),
+    /// Memory export.
+    Memory(MemoryIndex),
+    /// Global export.
+    Global(GlobalIndex),
+}
+
+/// An entity to import.
+#[derive(
+    Clone,
+    Debug,
+    Hash,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum ImportIndex {
+    /// Function import.
+    Function(FunctionIndex),
+    /// Table import.
+    Table(TableIndex),
+    /// Memory import.
+    Memory(MemoryIndex),
+    /// Global import.
+    Global(GlobalIndex),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/initializers.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/initializers.rs
new file mode 100644
index 0000000..26e7a3c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/initializers.rs
@@ -0,0 +1,144 @@
+use crate::indexes::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex};
+use crate::lib::std::boxed::Box;
+
+use enumset::__internal::EnumSetTypeRepr;
+use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// A WebAssembly table initializer.
+#[derive(Clone, Debug, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive_attr(derive(CheckBytes))]
+pub struct TableInitializer {
+    /// The index of a table to initialize.
+    pub table_index: TableIndex,
+    /// Optionally, a global variable giving a base index.
+    pub base: Option<GlobalIndex>,
+    /// The offset to add to the base.
+    pub offset: usize,
+    /// The values to write into the table elements.
+    pub elements: Box<[FunctionIndex]>,
+}
+
+/// A memory index and offset within that memory where a data initialization
+/// should be performed.
+#[derive(Clone, Debug, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive_attr(derive(CheckBytes))]
+pub struct DataInitializerLocation {
+    /// The index of the memory to initialize.
+    pub memory_index: MemoryIndex,
+
+    /// Optionally a Global variable base to initialize at.
+    pub base: Option<GlobalIndex>,
+
+    /// A constant offset to initialize at.
+    pub offset: usize,
+}
+
+/// Any struct that acts like a `DataInitializerLocation`.
+#[allow(missing_docs)]
+pub trait DataInitializerLocationLike {
+    fn memory_index(&self) -> MemoryIndex;
+    fn base(&self) -> Option<GlobalIndex>;
+    fn offset(&self) -> usize;
+}
+
+impl DataInitializerLocationLike for &DataInitializerLocation {
+    fn memory_index(&self) -> MemoryIndex {
+        self.memory_index
+    }
+
+    fn base(&self) -> Option<GlobalIndex> {
+        self.base
+    }
+
+    fn offset(&self) -> usize {
+        self.offset
+    }
+}
+
+impl DataInitializerLocationLike for &ArchivedDataInitializerLocation {
+    fn memory_index(&self) -> MemoryIndex {
+        MemoryIndex::from_u32(self.memory_index.as_u32())
+    }
+
+    fn base(&self) -> Option<GlobalIndex> {
+        match self.base {
+            rkyv::option::ArchivedOption::None => None,
+            rkyv::option::ArchivedOption::Some(base) => Some(GlobalIndex::from_u32(base.as_u32())),
+        }
+    }
+
+    fn offset(&self) -> usize {
+        self.offset.to_usize()
+    }
+}
+
+/// A data initializer for linear memory.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct DataInitializer<'data> {
+    /// The location where the initialization is to be performed.
+    pub location: DataInitializerLocation,
+
+    /// The initialization data.
+    pub data: &'data [u8],
+}
+
+/// As `DataInitializer` but owning the data rather than
+/// holding a reference to it
+#[derive(Debug, Clone, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive_attr(derive(CheckBytes))]
+pub struct OwnedDataInitializer {
+    /// The location where the initialization is to be performed.
+    pub location: DataInitializerLocation,
+
+    /// The initialization owned data.
+    pub data: Box<[u8]>,
+}
+
+/// Any struct that acts like a `DataInitializer`.
+#[allow(missing_docs)]
+pub trait DataInitializerLike<'a> {
+    type Location: DataInitializerLocationLike + Copy + 'a;
+
+    fn location(&self) -> Self::Location;
+    fn data(&self) -> &'a [u8];
+}
+
+impl OwnedDataInitializer {
+    /// Creates a new `OwnedDataInitializer` from a `DataInitializer`.
+    pub fn new(borrowed: &DataInitializer<'_>) -> Self {
+        Self {
+            location: borrowed.location.clone(),
+            data: borrowed.data.to_vec().into_boxed_slice(),
+        }
+    }
+}
+
+impl<'a> DataInitializerLike<'a> for &'a OwnedDataInitializer {
+    type Location = &'a DataInitializerLocation;
+
+    fn location(&self) -> Self::Location {
+        &self.location
+    }
+
+    fn data(&self) -> &'a [u8] {
+        self.data.as_ref()
+    }
+}
+
+impl<'a> DataInitializerLike<'a> for &'a ArchivedOwnedDataInitializer {
+    type Location = &'a ArchivedDataInitializerLocation;
+
+    fn location(&self) -> Self::Location {
+        &self.location
+    }
+
+    fn data(&self) -> &'a [u8] {
+        self.data.as_ref()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/lib.rs
new file mode 100644
index 0000000..db01db3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/lib.rs
@@ -0,0 +1,229 @@
+//! This are the common types and utility tools for using WebAssembly
+//! in a Rust environment.
+//!
+//! This crate provides common structures such as `Type` or `Value`, type indexes
+//! and native function wrappers with `Func`.
+
+#![deny(missing_docs, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::new_without_default)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(all(feature = "std", feature = "core"))]
+compile_error!(
+    "The `std` and `core` features are both enabled, which is an error. Please enable only once."
+);
+
+#[cfg(all(not(feature = "std"), not(feature = "core")))]
+compile_error!("Both the `std` and `core` features are disabled. Please enable one of them.");
+
+#[cfg(feature = "core")]
+extern crate alloc;
+
+/// The `lib` module defines a `std` module that is identical whether
+/// the `core` or the `std` feature is enabled.
+pub mod lib {
+    /// Custom `std` module.
+    #[cfg(feature = "core")]
+    pub mod std {
+        pub use alloc::{borrow, boxed, format, iter, rc, slice, string, vec};
+        pub use core::{any, cell, cmp, convert, fmt, hash, marker, mem, ops, ptr, sync, u32};
+    }
+
+    /// Custom `std` module.
+    #[cfg(feature = "std")]
+    pub mod std {
+        pub use std::{
+            any, borrow, boxed, cell, cmp, convert, fmt, format, hash, iter, marker, mem, ops, ptr,
+            rc, slice, string, sync, u32, vec,
+        };
+    }
+}
+
+pub mod compilation;
+pub mod error;
+mod features;
+mod indexes;
+mod initializers;
+mod libcalls;
+mod memory;
+mod module;
+mod serialize;
+mod stack;
+mod store_id;
+mod table;
+mod trapcode;
+mod types;
+mod units;
+mod utils;
+mod value;
+mod vmoffsets;
+
+pub use crate::compilation::target::{
+    Aarch64Architecture, Architecture, BinaryFormat, CallingConvention, CpuFeature, Endianness,
+    Environment, OperatingSystem, PointerWidth, Target, Triple, Vendor,
+};
+pub use crate::serialize::{
+    ArchivedSerializableCompilation, ArchivedSerializableModule, MetadataHeader,
+    SerializableCompilation, SerializableModule,
+};
+pub use error::{
+    CompileError, DeserializeError, ImportError, MemoryError, MiddlewareError,
+    ParseCpuFeatureError, PreInstantiationError, SerializeError, WasmError, WasmResult,
+};
+
+/// The entity module, with common helpers for Rust structures
+pub mod entity;
+pub use crate::features::Features;
+pub use crate::indexes::{
+    CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, FunctionIndex, GlobalIndex, ImportIndex,
+    LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
+    SignatureIndex, TableIndex,
+};
+pub use crate::initializers::{
+    ArchivedDataInitializerLocation, ArchivedOwnedDataInitializer, DataInitializer,
+    DataInitializerLike, DataInitializerLocation, DataInitializerLocationLike,
+    OwnedDataInitializer, TableInitializer,
+};
+pub use crate::memory::{Memory32, Memory64, MemorySize};
+pub use crate::module::{ExportsIterator, ImportKey, ImportsIterator, ModuleInfo};
+pub use crate::units::{
+    Bytes, PageCountOutOfRange, Pages, WASM_MAX_PAGES, WASM_MIN_PAGES, WASM_PAGE_SIZE,
+};
+pub use types::{
+    ExportType, ExternType, FunctionType, GlobalInit, GlobalType, ImportType, MemoryType,
+    Mutability, TableType, Type, V128,
+};
+pub use value::{RawValue, ValueType};
+
+pub use crate::libcalls::LibCall;
+pub use crate::memory::MemoryStyle;
+pub use crate::table::TableStyle;
+// TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+pub use crate::trapcode::{OnCalledAction, TrapCode};
+pub use crate::vmoffsets::{TargetSharedSignatureIndex, VMBuiltinFunctionIndex, VMOffsets};
+
+pub use crate::utils::is_wasm;
+
+pub use crate::compilation::relocation::{
+    ArchivedRelocation, Relocation, RelocationKind, RelocationLike, RelocationTarget, Relocations,
+};
+pub use crate::compilation::section::{
+    ArchivedCustomSection, CustomSection, CustomSectionLike, CustomSectionProtection, SectionBody,
+    SectionIndex,
+};
+
+pub use crate::compilation::address_map::{FunctionAddressMap, InstructionAddressMap};
+pub use crate::compilation::function::{
+    ArchivedFunctionBody, Compilation, CompiledFunction, CompiledFunctionFrameInfo, CustomSections,
+    Dwarf, FunctionBody, FunctionBodyLike, Functions,
+};
+pub use crate::compilation::module::CompileModuleInfo;
+pub use crate::compilation::symbols::{Symbol, SymbolRegistry};
+pub use crate::compilation::unwind::{
+    ArchivedCompiledFunctionUnwindInfo, CompiledFunctionUnwindInfo, CompiledFunctionUnwindInfoLike,
+    CompiledFunctionUnwindInfoReference,
+};
+
+pub use crate::stack::{FrameInfo, SourceLoc, TrapInformation};
+pub use crate::store_id::StoreId;
+
+/// Offset in bytes from the beginning of the function.
+pub type CodeOffset = u32;
+
+/// Addend to add to the symbol value.
+pub type Addend = i64;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+mod native {
+    use super::Type;
+    use crate::memory::{Memory32, Memory64, MemorySize};
+    use std::fmt;
+
+    /// `NativeWasmType` represents a Wasm type that has a direct
+    /// representation on the host (hence the “native” term).
+    ///
+    /// It uses the Rust Type system to automatically detect the
+    /// Wasm type associated with a native Rust type.
+    ///
+    /// ```
+    /// use wasmer_types::{NativeWasmType, Type};
+    ///
+    /// let wasm_type = i32::WASM_TYPE;
+    /// assert_eq!(wasm_type, Type::I32);
+    /// ```
+    ///
+    /// > Note: This strategy will be needed later to
+    /// > automatically detect the signature of a Rust function.
+    pub trait NativeWasmType: Sized {
+        /// The ABI for this type (i32, i64, f32, f64)
+        type Abi: Copy + fmt::Debug;
+
+        /// Type for this `NativeWasmType`.
+        const WASM_TYPE: Type;
+    }
+
+    impl NativeWasmType for u32 {
+        const WASM_TYPE: Type = Type::I32;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for i32 {
+        const WASM_TYPE: Type = Type::I32;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for i64 {
+        const WASM_TYPE: Type = Type::I64;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for u64 {
+        const WASM_TYPE: Type = Type::I64;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for f32 {
+        const WASM_TYPE: Type = Type::F32;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for f64 {
+        const WASM_TYPE: Type = Type::F64;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for u128 {
+        const WASM_TYPE: Type = Type::V128;
+        type Abi = Self;
+    }
+
+    impl NativeWasmType for Memory32 {
+        const WASM_TYPE: Type = <<Self as MemorySize>::Native as NativeWasmType>::WASM_TYPE;
+        type Abi = <<Self as MemorySize>::Native as NativeWasmType>::Abi;
+    }
+
+    impl NativeWasmType for Memory64 {
+        const WASM_TYPE: Type = <<Self as MemorySize>::Native as NativeWasmType>::WASM_TYPE;
+        type Abi = <<Self as MemorySize>::Native as NativeWasmType>::Abi;
+    }
+
+    impl<T: NativeWasmType> NativeWasmType for Option<T> {
+        const WASM_TYPE: Type = T::WASM_TYPE;
+        type Abi = T::Abi;
+    }
+}
+
+pub use crate::native::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/libcalls.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/libcalls.rs
new file mode 100644
index 0000000..21222c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/libcalls.rs
@@ -0,0 +1,194 @@
+use enum_iterator::IntoEnumIterator;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// The name of a runtime library routine.
+///
+/// This list is likely to grow over time.
+#[derive(
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    IntoEnumIterator,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+#[repr(u16)]
+pub enum LibCall {
+    /// ceil.f32
+    CeilF32,
+
+    /// ceil.f64
+    CeilF64,
+
+    /// floor.f32
+    FloorF32,
+
+    /// floor.f64
+    FloorF64,
+
+    /// nearest.f32
+    NearestF32,
+
+    /// nearest.f64
+    NearestF64,
+
+    /// trunc.f32
+    TruncF32,
+
+    /// trunc.f64
+    TruncF64,
+
+    /// memory.size for local functions
+    Memory32Size,
+
+    /// memory.size for imported functions
+    ImportedMemory32Size,
+
+    /// table.copy
+    TableCopy,
+
+    /// table.init
+    TableInit,
+
+    /// table.fill
+    TableFill,
+
+    /// table.size for local tables
+    TableSize,
+
+    /// table.size for imported tables
+    ImportedTableSize,
+
+    /// table.get for local tables
+    TableGet,
+
+    /// table.get for imported tables
+    ImportedTableGet,
+
+    /// table.set for local tables
+    TableSet,
+
+    /// table.set for imported tables
+    ImportedTableSet,
+
+    /// table.grow for local tables
+    TableGrow,
+
+    /// table.grow for imported tables
+    ImportedTableGrow,
+
+    /// ref.func
+    FuncRef,
+
+    /// elem.drop
+    ElemDrop,
+
+    /// memory.copy for local memories
+    Memory32Copy,
+
+    /// memory.copy for imported memories
+    ImportedMemory32Copy,
+
+    /// memory.fill for local memories
+    Memory32Fill,
+
+    /// memory.fill for imported memories
+    ImportedMemory32Fill,
+
+    /// memory.init
+    Memory32Init,
+
+    /// data.drop
+    DataDrop,
+
+    /// A custom trap
+    RaiseTrap,
+
+    /// probe for stack overflow. These are emitted for functions which need
+    /// when the `enable_probestack` setting is true.
+    Probestack,
+
+    /// memory.atomic.wait32 for local memories
+    Memory32AtomicWait32,
+
+    /// memory.atomic.wait32 for imported memories
+    ImportedMemory32AtomicWait32,
+
+    /// memory.atomic.wait64 for local memories
+    Memory32AtomicWait64,
+
+    /// memory.atomic.wait64 for imported memories
+    ImportedMemory32AtomicWait64,
+
+    /// memory.atomic.notify for local memories
+    Memory32AtomicNotify,
+
+    /// memory.atomic.botify for imported memories
+    ImportedMemory32AtomicNotify,
+}
+
+impl LibCall {
+    /// Return the function name associated to the libcall.
+    pub fn to_function_name(&self) -> &str {
+        match self {
+            Self::CeilF32 => "wasmer_vm_f32_ceil",
+            Self::CeilF64 => "wasmer_vm_f64_ceil",
+            Self::FloorF32 => "wasmer_vm_f32_floor",
+            Self::FloorF64 => "wasmer_vm_f64_floor",
+            Self::NearestF32 => "wasmer_vm_f32_nearest",
+            Self::NearestF64 => "wasmer_vm_f64_nearest",
+            Self::TruncF32 => "wasmer_vm_f32_trunc",
+            Self::TruncF64 => "wasmer_vm_f64_trunc",
+            Self::Memory32Size => "wasmer_vm_memory32_size",
+            Self::ImportedMemory32Size => "wasmer_vm_imported_memory32_size",
+            Self::TableCopy => "wasmer_vm_table_copy",
+            Self::TableInit => "wasmer_vm_table_init",
+            Self::TableFill => "wasmer_vm_table_fill",
+            Self::TableSize => "wasmer_vm_table_size",
+            Self::ImportedTableSize => "wasmer_vm_imported_table_size",
+            Self::TableGet => "wasmer_vm_table_get",
+            Self::ImportedTableGet => "wasmer_vm_imported_table_get",
+            Self::TableSet => "wasmer_vm_table_set",
+            Self::ImportedTableSet => "wasmer_vm_imported_table_set",
+            Self::TableGrow => "wasmer_vm_table_grow",
+            Self::ImportedTableGrow => "wasmer_vm_imported_table_grow",
+            Self::FuncRef => "wasmer_vm_func_ref",
+            Self::ElemDrop => "wasmer_vm_elem_drop",
+            Self::Memory32Copy => "wasmer_vm_memory32_copy",
+            Self::ImportedMemory32Copy => "wasmer_vm_imported_memory32_copy",
+            Self::Memory32Fill => "wasmer_vm_memory32_fill",
+            Self::ImportedMemory32Fill => "wasmer_vm_imported_memory32_fill",
+            Self::Memory32Init => "wasmer_vm_memory32_init",
+            Self::DataDrop => "wasmer_vm_data_drop",
+            Self::RaiseTrap => "wasmer_vm_raise_trap",
+            // We have to do this because macOS requires a leading `_` and it's not
+            // a normal function, it's a static variable, so we have to do it manually.
+            #[cfg(target_vendor = "apple")]
+            Self::Probestack => "_wasmer_vm_probestack",
+            #[cfg(not(target_vendor = "apple"))]
+            Self::Probestack => "wasmer_vm_probestack",
+            Self::Memory32AtomicWait32 => "wasmer_vm_memory32_atomic_wait32",
+            Self::ImportedMemory32AtomicWait32 => "wasmer_vm_imported_memory32_atomic_wait32",
+            Self::Memory32AtomicWait64 => "wasmer_vm_memory32_atomic_wait64",
+            Self::ImportedMemory32AtomicWait64 => "wasmer_vm_imported_memory32_atomic_wait64",
+            Self::Memory32AtomicNotify => "wasmer_vm_memory32_atomic_notify",
+            Self::ImportedMemory32AtomicNotify => "wasmer_vm_imported_memory32_atomic_notify",
+        }
+    }
+}
+
+impl fmt::Display for LibCall {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/memory.rs
new file mode 100644
index 0000000..5999f0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/memory.rs
@@ -0,0 +1,155 @@
+use crate::{Pages, ValueType};
+use core::ops::SubAssign;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::convert::{TryFrom, TryInto};
+use std::iter::Sum;
+use std::ops::{Add, AddAssign};
+
+/// Implementation styles for WebAssembly linear memory.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum MemoryStyle {
+    /// The actual memory can be resized and moved.
+    Dynamic {
+        /// Our chosen offset-guard size.
+        ///
+        /// It represents the size in bytes of extra guard pages after the end
+        /// to optimize loads and stores with constant offsets.
+        offset_guard_size: u64,
+    },
+    /// Address space is allocated up front.
+    Static {
+        /// The number of mapped and unmapped pages.
+        bound: Pages,
+        /// Our chosen offset-guard size.
+        ///
+        /// It represents the size in bytes of extra guard pages after the end
+        /// to optimize loads and stores with constant offsets.
+        offset_guard_size: u64,
+    },
+}
+
+impl MemoryStyle {
+    /// Returns the offset-guard size
+    pub fn offset_guard_size(&self) -> u64 {
+        match self {
+            Self::Dynamic { offset_guard_size } => *offset_guard_size,
+            Self::Static {
+                offset_guard_size, ..
+            } => *offset_guard_size,
+        }
+    }
+}
+
+/// Trait for the `Memory32` and `Memory64` marker types.
+///
+/// This allows code to be generic over 32-bit and 64-bit memories.
+/// # Safety
+/// Direct memory access is unsafe
+pub unsafe trait MemorySize: Copy {
+    /// Type used to represent an offset into a memory. This is `u32` or `u64`.
+    type Offset: Default
+        + std::fmt::Debug
+        + std::fmt::Display
+        + Eq
+        + Ord
+        + PartialEq<Self::Offset>
+        + PartialOrd<Self::Offset>
+        + Clone
+        + Copy
+        + Sync
+        + Send
+        + ValueType
+        + Into<u64>
+        + From<u32>
+        + From<u16>
+        + From<u8>
+        + TryFrom<u64>
+        + TryFrom<u32>
+        + TryFrom<u16>
+        + TryFrom<u8>
+        + TryFrom<i32>
+        + TryInto<usize>
+        + TryInto<u64>
+        + TryInto<u32>
+        + TryInto<u16>
+        + TryInto<u8>
+        + TryInto<i32>
+        + TryFrom<usize>
+        + Add<Self::Offset>
+        + Sum<Self::Offset>
+        + AddAssign<Self::Offset>
+        + SubAssign<Self::Offset>
+        + 'static;
+
+    /// Type used to pass this value as an argument or return value for a Wasm function.
+    type Native: super::NativeWasmType;
+
+    /// Zero value used for `WasmPtr::is_null`.
+    const ZERO: Self::Offset;
+
+    /// One value used for counting.
+    const ONE: Self::Offset;
+
+    /// Convert an `Offset` to a `Native`.
+    fn offset_to_native(offset: Self::Offset) -> Self::Native;
+
+    /// Convert a `Native` to an `Offset`.
+    fn native_to_offset(native: Self::Native) -> Self::Offset;
+
+    /// True if the memory is 64-bit
+    fn is_64bit() -> bool;
+}
+
+/// Marker trait for 32-bit memories.
+#[derive(Clone, Copy)]
+pub struct Memory32;
+unsafe impl MemorySize for Memory32 {
+    type Offset = u32;
+    type Native = i32;
+    const ZERO: Self::Offset = 0;
+    const ONE: Self::Offset = 1;
+    fn offset_to_native(offset: Self::Offset) -> Self::Native {
+        offset as Self::Native
+    }
+    fn native_to_offset(native: Self::Native) -> Self::Offset {
+        native as Self::Offset
+    }
+    fn is_64bit() -> bool {
+        false
+    }
+}
+
+/// Marker trait for 64-bit memories.
+#[derive(Clone, Copy)]
+pub struct Memory64;
+unsafe impl MemorySize for Memory64 {
+    type Offset = u64;
+    type Native = i64;
+    const ZERO: Self::Offset = 0;
+    const ONE: Self::Offset = 1;
+    fn offset_to_native(offset: Self::Offset) -> Self::Native {
+        offset as Self::Native
+    }
+    fn native_to_offset(native: Self::Native) -> Self::Offset {
+        native as Self::Offset
+    }
+    fn is_64bit() -> bool {
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/module.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/module.rs
new file mode 100644
index 0000000..38afacc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/module.rs
@@ -0,0 +1,638 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Data structure for representing WebAssembly modules in a
+//! `wasmer::Module`.
+
+use crate::entity::{EntityRef, PrimaryMap};
+use crate::{
+    CustomSectionIndex, DataIndex, ElemIndex, ExportIndex, ExportType, ExternType, FunctionIndex,
+    FunctionType, GlobalIndex, GlobalInit, GlobalType, ImportIndex, ImportType, LocalFunctionIndex,
+    LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex, MemoryType, SignatureIndex,
+    TableIndex, TableInitializer, TableType,
+};
+use indexmap::IndexMap;
+use rkyv::{
+    de::SharedDeserializeRegistry, ser::ScratchSpace, ser::Serializer,
+    ser::SharedSerializeRegistry, Archive, Archived, CheckBytes, Deserialize as RkyvDeserialize,
+    Fallible, Serialize as RkyvSerialize,
+};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::fmt;
+use std::iter::ExactSizeIterator;
+use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+
+#[derive(Debug, Clone, RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct ModuleId {
+    id: usize,
+}
+
+impl ModuleId {
+    pub fn id(&self) -> String {
+        format!("{}", &self.id)
+    }
+}
+
+impl Default for ModuleId {
+    fn default() -> Self {
+        static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+        Self {
+            id: NEXT_ID.fetch_add(1, SeqCst),
+        }
+    }
+}
+
+/// Hash key of an import
+#[derive(Debug, Hash, Eq, PartialEq, Clone, Default, RkyvSerialize, RkyvDeserialize, Archive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive_attr(derive(CheckBytes, PartialEq, Eq, Hash))]
+pub struct ImportKey {
+    /// Module name
+    pub module: String,
+    /// Field name
+    pub field: String,
+    /// Import index
+    pub import_idx: u32,
+}
+
+impl From<(String, String, u32)> for ImportKey {
+    fn from((module, field, import_idx): (String, String, u32)) -> Self {
+        Self {
+            module,
+            field,
+            import_idx,
+        }
+    }
+}
+
+#[cfg(feature = "enable-serde")]
+mod serde_imports {
+
+    use crate::ImportIndex;
+    use crate::ImportKey;
+    use indexmap::IndexMap;
+    use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+    type InitialType = IndexMap<ImportKey, ImportIndex>;
+    type SerializedType = Vec<(ImportKey, ImportIndex)>;
+    // IndexMap<ImportKey, ImportIndex>
+    // Vec<
+    pub fn serialize<S: Serializer>(s: &InitialType, serializer: S) -> Result<S::Ok, S::Error> {
+        let vec: SerializedType = s
+            .iter()
+            .map(|(a, b)| (a.clone(), b.clone()))
+            .collect::<Vec<_>>();
+        vec.serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<InitialType, D::Error> {
+        let serialized = <SerializedType as Deserialize>::deserialize(deserializer)?;
+        Ok(serialized.into_iter().collect())
+    }
+}
+
+/// A translated WebAssembly module, excluding the function bodies and
+/// memory initializers.
+#[derive(Debug, Clone, Default)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ModuleInfo {
+    /// A unique identifier (within this process) for this module.
+    ///
+    /// We skip serialization/deserialization of this field, as it
+    /// should be computed by the process.
+    /// It's not skipped in rkyv, but that is okay, because even though it's skipped in bincode/serde
+    /// it's still deserialized back as a garbage number, and later override from computed by the process
+    #[cfg_attr(feature = "enable-serde", serde(skip_serializing, skip_deserializing))]
+    pub id: ModuleId,
+
+    /// The name of this wasm module, often found in the wasm file.
+    pub name: Option<String>,
+
+    /// Imported entities with the (module, field, index_of_the_import)
+    ///
+    /// Keeping the `index_of_the_import` is important, as there can be
+    /// two same references to the same import, and we don't want to confuse
+    /// them.
+    #[cfg_attr(feature = "enable-serde", serde(with = "serde_imports"))]
+    pub imports: IndexMap<ImportKey, ImportIndex>,
+
+    /// Exported entities.
+    pub exports: IndexMap<String, ExportIndex>,
+
+    /// The module "start" function, if present.
+    pub start_function: Option<FunctionIndex>,
+
+    /// WebAssembly table initializers.
+    pub table_initializers: Vec<TableInitializer>,
+
+    /// WebAssembly passive elements.
+    pub passive_elements: HashMap<ElemIndex, Box<[FunctionIndex]>>,
+
+    /// WebAssembly passive data segments.
+    pub passive_data: HashMap<DataIndex, Box<[u8]>>,
+
+    /// WebAssembly global initializers.
+    pub global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>,
+
+    /// WebAssembly function names.
+    pub function_names: HashMap<FunctionIndex, String>,
+
+    /// WebAssembly function signatures.
+    pub signatures: PrimaryMap<SignatureIndex, FunctionType>,
+
+    /// WebAssembly functions (imported and local).
+    pub functions: PrimaryMap<FunctionIndex, SignatureIndex>,
+
+    /// WebAssembly tables (imported and local).
+    pub tables: PrimaryMap<TableIndex, TableType>,
+
+    /// WebAssembly linear memories (imported and local).
+    pub memories: PrimaryMap<MemoryIndex, MemoryType>,
+
+    /// WebAssembly global variables (imported and local).
+    pub globals: PrimaryMap<GlobalIndex, GlobalType>,
+
+    /// Custom sections in the module.
+    pub custom_sections: IndexMap<String, CustomSectionIndex>,
+
+    /// The data for each CustomSection in the module.
+    pub custom_sections_data: PrimaryMap<CustomSectionIndex, Box<[u8]>>,
+
+    /// Number of imported functions in the module.
+    pub num_imported_functions: usize,
+
+    /// Number of imported tables in the module.
+    pub num_imported_tables: usize,
+
+    /// Number of imported memories in the module.
+    pub num_imported_memories: usize,
+
+    /// Number of imported globals in the module.
+    pub num_imported_globals: usize,
+}
+
+/// Mirror version of ModuleInfo that can derive rkyv traits
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct ArchivableModuleInfo {
+    name: Option<String>,
+    imports: IndexMap<ImportKey, ImportIndex>,
+    exports: IndexMap<String, ExportIndex>,
+    start_function: Option<FunctionIndex>,
+    table_initializers: Vec<TableInitializer>,
+    passive_elements: BTreeMap<ElemIndex, Box<[FunctionIndex]>>,
+    passive_data: BTreeMap<DataIndex, Box<[u8]>>,
+    global_initializers: PrimaryMap<LocalGlobalIndex, GlobalInit>,
+    function_names: BTreeMap<FunctionIndex, String>,
+    signatures: PrimaryMap<SignatureIndex, FunctionType>,
+    functions: PrimaryMap<FunctionIndex, SignatureIndex>,
+    tables: PrimaryMap<TableIndex, TableType>,
+    memories: PrimaryMap<MemoryIndex, MemoryType>,
+    globals: PrimaryMap<GlobalIndex, GlobalType>,
+    custom_sections: IndexMap<String, CustomSectionIndex>,
+    custom_sections_data: PrimaryMap<CustomSectionIndex, Box<[u8]>>,
+    num_imported_functions: usize,
+    num_imported_tables: usize,
+    num_imported_memories: usize,
+    num_imported_globals: usize,
+}
+
+impl From<ModuleInfo> for ArchivableModuleInfo {
+    fn from(it: ModuleInfo) -> Self {
+        Self {
+            name: it.name,
+            imports: it.imports,
+            exports: it.exports,
+            start_function: it.start_function,
+            table_initializers: it.table_initializers,
+            passive_elements: it.passive_elements.into_iter().collect(),
+            passive_data: it.passive_data.into_iter().collect(),
+            global_initializers: it.global_initializers,
+            function_names: it.function_names.into_iter().collect(),
+            signatures: it.signatures,
+            functions: it.functions,
+            tables: it.tables,
+            memories: it.memories,
+            globals: it.globals,
+            custom_sections: it.custom_sections,
+            custom_sections_data: it.custom_sections_data,
+            num_imported_functions: it.num_imported_functions,
+            num_imported_tables: it.num_imported_tables,
+            num_imported_memories: it.num_imported_memories,
+            num_imported_globals: it.num_imported_globals,
+        }
+    }
+}
+
+impl From<ArchivableModuleInfo> for ModuleInfo {
+    fn from(it: ArchivableModuleInfo) -> Self {
+        Self {
+            id: Default::default(),
+            name: it.name,
+            imports: it.imports,
+            exports: it.exports,
+            start_function: it.start_function,
+            table_initializers: it.table_initializers,
+            passive_elements: it.passive_elements.into_iter().collect(),
+            passive_data: it.passive_data.into_iter().collect(),
+            global_initializers: it.global_initializers,
+            function_names: it.function_names.into_iter().collect(),
+            signatures: it.signatures,
+            functions: it.functions,
+            tables: it.tables,
+            memories: it.memories,
+            globals: it.globals,
+            custom_sections: it.custom_sections,
+            custom_sections_data: it.custom_sections_data,
+            num_imported_functions: it.num_imported_functions,
+            num_imported_tables: it.num_imported_tables,
+            num_imported_memories: it.num_imported_memories,
+            num_imported_globals: it.num_imported_globals,
+        }
+    }
+}
+
+impl From<&ModuleInfo> for ArchivableModuleInfo {
+    fn from(it: &ModuleInfo) -> Self {
+        Self::from(it.clone())
+    }
+}
+
+impl Archive for ModuleInfo {
+    type Archived = <ArchivableModuleInfo as Archive>::Archived;
+    type Resolver = <ArchivableModuleInfo as Archive>::Resolver;
+
+    unsafe fn resolve(&self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived) {
+        ArchivableModuleInfo::from(self).resolve(pos, resolver, out)
+    }
+}
+
+impl<S: Serializer + SharedSerializeRegistry + ScratchSpace + ?Sized> RkyvSerialize<S>
+    for ModuleInfo
+{
+    fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+        ArchivableModuleInfo::from(self).serialize(serializer)
+    }
+}
+
+impl<D: Fallible + ?Sized + SharedDeserializeRegistry> RkyvDeserialize<ModuleInfo, D>
+    for Archived<ModuleInfo>
+{
+    fn deserialize(&self, deserializer: &mut D) -> Result<ModuleInfo, D::Error> {
+        let r: ArchivableModuleInfo =
+            RkyvDeserialize::<ArchivableModuleInfo, D>::deserialize(self, deserializer)?;
+        Ok(ModuleInfo::from(r))
+    }
+}
+
+// For test serialization correctness, everything except module id should be same
+impl PartialEq for ModuleInfo {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+            && self.imports == other.imports
+            && self.exports == other.exports
+            && self.start_function == other.start_function
+            && self.table_initializers == other.table_initializers
+            && self.passive_elements == other.passive_elements
+            && self.passive_data == other.passive_data
+            && self.global_initializers == other.global_initializers
+            && self.function_names == other.function_names
+            && self.signatures == other.signatures
+            && self.functions == other.functions
+            && self.tables == other.tables
+            && self.memories == other.memories
+            && self.globals == other.globals
+            && self.custom_sections == other.custom_sections
+            && self.custom_sections_data == other.custom_sections_data
+            && self.num_imported_functions == other.num_imported_functions
+            && self.num_imported_tables == other.num_imported_tables
+            && self.num_imported_memories == other.num_imported_memories
+            && self.num_imported_globals == other.num_imported_globals
+    }
+}
+
+impl Eq for ModuleInfo {}
+
+impl ModuleInfo {
+    /// Allocates the module data structures.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Get the given passive element, if it exists.
+    pub fn get_passive_element(&self, index: ElemIndex) -> Option<&[FunctionIndex]> {
+        self.passive_elements.get(&index).map(|es| &**es)
+    }
+
+    /// Get the exported signatures of the module
+    pub fn exported_signatures(&self) -> Vec<FunctionType> {
+        self.exports
+            .iter()
+            .filter_map(|(_name, export_index)| match export_index {
+                ExportIndex::Function(i) => {
+                    let signature = self.functions.get(*i).unwrap();
+                    let func_type = self.signatures.get(*signature).unwrap();
+                    Some(func_type.clone())
+                }
+                _ => None,
+            })
+            .collect::<Vec<FunctionType>>()
+    }
+
+    /// Get the export types of the module
+    pub fn exports(&'_ self) -> ExportsIterator<impl Iterator<Item = ExportType> + '_> {
+        let iter = self.exports.iter().map(move |(name, export_index)| {
+            let extern_type = match export_index {
+                ExportIndex::Function(i) => {
+                    let signature = self.functions.get(*i).unwrap();
+                    let func_type = self.signatures.get(*signature).unwrap();
+                    ExternType::Function(func_type.clone())
+                }
+                ExportIndex::Table(i) => {
+                    let table_type = self.tables.get(*i).unwrap();
+                    ExternType::Table(*table_type)
+                }
+                ExportIndex::Memory(i) => {
+                    let memory_type = self.memories.get(*i).unwrap();
+                    ExternType::Memory(*memory_type)
+                }
+                ExportIndex::Global(i) => {
+                    let global_type = self.globals.get(*i).unwrap();
+                    ExternType::Global(*global_type)
+                }
+            };
+            ExportType::new(name, extern_type)
+        });
+        ExportsIterator::new(iter, self.exports.len())
+    }
+
+    /// Get the import types of the module
+    pub fn imports(&'_ self) -> ImportsIterator<impl Iterator<Item = ImportType> + '_> {
+        let iter =
+            self.imports
+                .iter()
+                .map(move |(ImportKey { module, field, .. }, import_index)| {
+                    let extern_type = match import_index {
+                        ImportIndex::Function(i) => {
+                            let signature = self.functions.get(*i).unwrap();
+                            let func_type = self.signatures.get(*signature).unwrap();
+                            ExternType::Function(func_type.clone())
+                        }
+                        ImportIndex::Table(i) => {
+                            let table_type = self.tables.get(*i).unwrap();
+                            ExternType::Table(*table_type)
+                        }
+                        ImportIndex::Memory(i) => {
+                            let memory_type = self.memories.get(*i).unwrap();
+                            ExternType::Memory(*memory_type)
+                        }
+                        ImportIndex::Global(i) => {
+                            let global_type = self.globals.get(*i).unwrap();
+                            ExternType::Global(*global_type)
+                        }
+                    };
+                    ImportType::new(module, field, extern_type)
+                });
+        ImportsIterator::new(iter, self.imports.len())
+    }
+
+    /// Get the custom sections of the module given a `name`.
+    pub fn custom_sections<'a>(&'a self, name: &'a str) -> impl Iterator<Item = Box<[u8]>> + 'a {
+        self.custom_sections
+            .iter()
+            .filter_map(move |(section_name, section_index)| {
+                if name != section_name {
+                    return None;
+                }
+                Some(self.custom_sections_data[*section_index].clone())
+            })
+    }
+
+    /// Convert a `LocalFunctionIndex` into a `FunctionIndex`.
+    pub fn func_index(&self, local_func: LocalFunctionIndex) -> FunctionIndex {
+        FunctionIndex::new(self.num_imported_functions + local_func.index())
+    }
+
+    /// Convert a `FunctionIndex` into a `LocalFunctionIndex`. Returns None if the
+    /// index is an imported function.
+    pub fn local_func_index(&self, func: FunctionIndex) -> Option<LocalFunctionIndex> {
+        func.index()
+            .checked_sub(self.num_imported_functions)
+            .map(LocalFunctionIndex::new)
+    }
+
+    /// Test whether the given function index is for an imported function.
+    pub fn is_imported_function(&self, index: FunctionIndex) -> bool {
+        index.index() < self.num_imported_functions
+    }
+
+    /// Convert a `LocalTableIndex` into a `TableIndex`.
+    pub fn table_index(&self, local_table: LocalTableIndex) -> TableIndex {
+        TableIndex::new(self.num_imported_tables + local_table.index())
+    }
+
+    /// Convert a `TableIndex` into a `LocalTableIndex`. Returns None if the
+    /// index is an imported table.
+    pub fn local_table_index(&self, table: TableIndex) -> Option<LocalTableIndex> {
+        table
+            .index()
+            .checked_sub(self.num_imported_tables)
+            .map(LocalTableIndex::new)
+    }
+
+    /// Test whether the given table index is for an imported table.
+    pub fn is_imported_table(&self, index: TableIndex) -> bool {
+        index.index() < self.num_imported_tables
+    }
+
+    /// Convert a `LocalMemoryIndex` into a `MemoryIndex`.
+    pub fn memory_index(&self, local_memory: LocalMemoryIndex) -> MemoryIndex {
+        MemoryIndex::new(self.num_imported_memories + local_memory.index())
+    }
+
+    /// Convert a `MemoryIndex` into a `LocalMemoryIndex`. Returns None if the
+    /// index is an imported memory.
+    pub fn local_memory_index(&self, memory: MemoryIndex) -> Option<LocalMemoryIndex> {
+        memory
+            .index()
+            .checked_sub(self.num_imported_memories)
+            .map(LocalMemoryIndex::new)
+    }
+
+    /// Test whether the given memory index is for an imported memory.
+    pub fn is_imported_memory(&self, index: MemoryIndex) -> bool {
+        index.index() < self.num_imported_memories
+    }
+
+    /// Convert a `LocalGlobalIndex` into a `GlobalIndex`.
+    pub fn global_index(&self, local_global: LocalGlobalIndex) -> GlobalIndex {
+        GlobalIndex::new(self.num_imported_globals + local_global.index())
+    }
+
+    /// Convert a `GlobalIndex` into a `LocalGlobalIndex`. Returns None if the
+    /// index is an imported global.
+    pub fn local_global_index(&self, global: GlobalIndex) -> Option<LocalGlobalIndex> {
+        global
+            .index()
+            .checked_sub(self.num_imported_globals)
+            .map(LocalGlobalIndex::new)
+    }
+
+    /// Test whether the given global index is for an imported global.
+    pub fn is_imported_global(&self, index: GlobalIndex) -> bool {
+        index.index() < self.num_imported_globals
+    }
+
+    /// Get the Module name
+    pub fn name(&self) -> String {
+        match self.name {
+            Some(ref name) => name.to_string(),
+            None => "<module>".to_string(),
+        }
+    }
+
+    /// Get the imported function types of the module.
+    pub fn imported_function_types(&'_ self) -> impl Iterator<Item = FunctionType> + '_ {
+        self.functions
+            .values()
+            .take(self.num_imported_functions)
+            .map(move |sig_index| self.signatures[*sig_index].clone())
+    }
+}
+
+impl fmt::Display for ModuleInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.name())
+    }
+}
+
+// Code inspired from
+// https://www.reddit.com/r/rust/comments/9vspv4/extending_iterators_ergonomically/
+
+/// This iterator allows us to iterate over the exports
+/// and offer nice API ergonomics over it.
+pub struct ExportsIterator<I: Iterator<Item = ExportType> + Sized> {
+    iter: I,
+    size: usize,
+}
+
+impl<I: Iterator<Item = ExportType> + Sized> ExportsIterator<I> {
+    /// Create a new `ExportsIterator` for a given iterator and size
+    pub fn new(iter: I, size: usize) -> Self {
+        Self { iter, size }
+    }
+}
+
+impl<I: Iterator<Item = ExportType> + Sized> ExactSizeIterator for ExportsIterator<I> {
+    // We can easily calculate the remaining number of iterations.
+    fn len(&self) -> usize {
+        self.size
+    }
+}
+
+impl<I: Iterator<Item = ExportType> + Sized> ExportsIterator<I> {
+    /// Get only the functions
+    pub fn functions(self) -> impl Iterator<Item = ExportType<FunctionType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Function(ty) => Some(ExportType::new(extern_.name(), ty.clone())),
+            _ => None,
+        })
+    }
+    /// Get only the memories
+    pub fn memories(self) -> impl Iterator<Item = ExportType<MemoryType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Memory(ty) => Some(ExportType::new(extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+    /// Get only the tables
+    pub fn tables(self) -> impl Iterator<Item = ExportType<TableType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Table(ty) => Some(ExportType::new(extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+    /// Get only the globals
+    pub fn globals(self) -> impl Iterator<Item = ExportType<GlobalType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Global(ty) => Some(ExportType::new(extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+}
+
+impl<I: Iterator<Item = ExportType> + Sized> Iterator for ExportsIterator<I> {
+    type Item = ExportType;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+/// This iterator allows us to iterate over the imports
+/// and offer nice API ergonomics over it.
+pub struct ImportsIterator<I: Iterator<Item = ImportType> + Sized> {
+    iter: I,
+    size: usize,
+}
+
+impl<I: Iterator<Item = ImportType> + Sized> ImportsIterator<I> {
+    /// Create a new `ImportsIterator` for a given iterator and size
+    pub fn new(iter: I, size: usize) -> Self {
+        Self { iter, size }
+    }
+}
+
+impl<I: Iterator<Item = ImportType> + Sized> ExactSizeIterator for ImportsIterator<I> {
+    // We can easily calculate the remaining number of iterations.
+    fn len(&self) -> usize {
+        self.size
+    }
+}
+
+impl<I: Iterator<Item = ImportType> + Sized> ImportsIterator<I> {
+    /// Get only the functions
+    pub fn functions(self) -> impl Iterator<Item = ImportType<FunctionType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Function(ty) => Some(ImportType::new(
+                extern_.module(),
+                extern_.name(),
+                ty.clone(),
+            )),
+            _ => None,
+        })
+    }
+    /// Get only the memories
+    pub fn memories(self) -> impl Iterator<Item = ImportType<MemoryType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Memory(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+    /// Get only the tables
+    pub fn tables(self) -> impl Iterator<Item = ImportType<TableType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Table(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+    /// Get only the globals
+    pub fn globals(self) -> impl Iterator<Item = ImportType<GlobalType>> + Sized {
+        self.iter.filter_map(|extern_| match extern_.ty() {
+            ExternType::Global(ty) => Some(ImportType::new(extern_.module(), extern_.name(), *ty)),
+            _ => None,
+        })
+    }
+}
+
+impl<I: Iterator<Item = ImportType> + Sized> Iterator for ImportsIterator<I> {
+    type Item = ImportType;
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/serialize.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/serialize.rs
new file mode 100644
index 0000000..0e6ef78
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/serialize.rs
@@ -0,0 +1,267 @@
+use crate::entity::PrimaryMap;
+use crate::{
+    compilation::target::CpuFeature, CompileModuleInfo, CompiledFunctionFrameInfo, CustomSection,
+    DeserializeError, Dwarf, Features, FunctionBody, FunctionIndex, LocalFunctionIndex,
+    MemoryIndex, MemoryStyle, ModuleInfo, OwnedDataInitializer, Relocation, SectionIndex,
+    SerializeError, SignatureIndex, TableIndex, TableStyle,
+};
+use enumset::EnumSet;
+use rkyv::check_archived_value;
+use rkyv::{
+    archived_value, de::deserializers::SharedDeserializeMap, ser::serializers::AllocSerializer,
+    ser::Serializer as RkyvSerializer, Archive, CheckBytes, Deserialize as RkyvDeserialize,
+    Serialize as RkyvSerialize,
+};
+use std::convert::TryInto;
+use std::mem;
+
+/// The compilation related data for a serialized modules
+#[derive(Archive, Default, RkyvDeserialize, RkyvSerialize)]
+#[allow(missing_docs)]
+#[archive_attr(derive(CheckBytes))]
+pub struct SerializableCompilation {
+    pub function_bodies: PrimaryMap<LocalFunctionIndex, FunctionBody>,
+    pub function_relocations: PrimaryMap<LocalFunctionIndex, Vec<Relocation>>,
+    pub function_frame_info: PrimaryMap<LocalFunctionIndex, CompiledFunctionFrameInfo>,
+    pub function_call_trampolines: PrimaryMap<SignatureIndex, FunctionBody>,
+    pub dynamic_function_trampolines: PrimaryMap<FunctionIndex, FunctionBody>,
+    pub custom_sections: PrimaryMap<SectionIndex, CustomSection>,
+    pub custom_section_relocations: PrimaryMap<SectionIndex, Vec<Relocation>>,
+    // The section indices corresponding to the Dwarf debug info
+    pub debug: Option<Dwarf>,
+    // Custom section containing libcall trampolines.
+    pub libcall_trampolines: SectionIndex,
+    // Length of each libcall trampoline.
+    pub libcall_trampoline_len: u32,
+}
+
+impl SerializableCompilation {
+    /// Serialize a Compilation into bytes
+    /// The bytes will have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        let mut serializer = AllocSerializer::<4096>::default();
+        let pos = serializer
+            .serialize_value(self)
+            .map_err(to_serialize_error)? as u64;
+        let mut serialized_data = serializer.into_serializer().into_inner();
+        serialized_data.extend_from_slice(&pos.to_le_bytes());
+        Ok(serialized_data.to_vec())
+    }
+}
+
+/// Serializable struct that is able to serialize from and to a `ArtifactInfo`.
+#[derive(Archive, RkyvDeserialize, RkyvSerialize)]
+#[allow(missing_docs)]
+#[archive_attr(derive(CheckBytes))]
+pub struct SerializableModule {
+    /// The main serializable compilation object
+    pub compilation: SerializableCompilation,
+    /// Compilation informations
+    pub compile_info: CompileModuleInfo,
+    /// Datas initializers
+    pub data_initializers: Box<[OwnedDataInitializer]>,
+    /// CPU Feature flags for this compilation
+    pub cpu_features: u64,
+}
+
+fn to_serialize_error(err: impl std::error::Error) -> SerializeError {
+    SerializeError::Generic(format!("{}", err))
+}
+
+impl SerializableModule {
+    /// Serialize a Module into bytes
+    /// The bytes will have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    pub fn serialize(&self) -> Result<Vec<u8>, SerializeError> {
+        let mut serializer = AllocSerializer::<4096>::default();
+        let pos = serializer
+            .serialize_value(self)
+            .map_err(to_serialize_error)? as u64;
+        let mut serialized_data = serializer.into_serializer().into_inner();
+        serialized_data.extend_from_slice(&pos.to_le_bytes());
+        Ok(serialized_data.to_vec())
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    ///
+    /// # Safety
+    ///
+    /// This method is unsafe since it deserializes data directly
+    /// from memory.
+    /// Right now we are not doing any extra work for validation, but
+    /// `rkyv` has an option to do bytecheck on the serialized data before
+    /// serializing (via `rkyv::check_archived_value`).
+    pub unsafe fn deserialize_unchecked(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// Deserialize a Module from a slice.
+    /// The slice must have the following format:
+    /// RKYV serialization (any length) + POS (8 bytes)
+    ///
+    /// Unlike [`Self::deserialize`], this function will validate the data.
+    ///
+    /// # Safety
+    /// Unsafe because it loads executable code into memory.
+    /// The loaded bytes must be trusted.
+    pub unsafe fn deserialize(metadata_slice: &[u8]) -> Result<Self, DeserializeError> {
+        let archived = Self::archive_from_slice_checked(metadata_slice)?;
+        Self::deserialize_from_archive(archived)
+    }
+
+    /// # Safety
+    ///
+    /// This method is unsafe.
+    /// Please check `SerializableModule::deserialize` for more details.
+    pub unsafe fn archive_from_slice(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
+        if metadata_slice.len() < 8 {
+            return Err(DeserializeError::Incompatible(
+                "invalid serialized data".into(),
+            ));
+        }
+        let mut pos: [u8; 8] = Default::default();
+        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
+        let pos: u64 = u64::from_le_bytes(pos);
+        Ok(archived_value::<Self>(
+            &metadata_slice[..metadata_slice.len() - 8],
+            pos as usize,
+        ))
+    }
+
+    /// Deserialize an archived module.
+    ///
+    /// In contrast to [`Self::deserialize`], this method performs validation
+    /// and is not unsafe.
+    pub fn archive_from_slice_checked(
+        metadata_slice: &[u8],
+    ) -> Result<&ArchivedSerializableModule, DeserializeError> {
+        if metadata_slice.len() < 8 {
+            return Err(DeserializeError::Incompatible(
+                "invalid serialized data".into(),
+            ));
+        }
+        let mut pos: [u8; 8] = Default::default();
+        pos.copy_from_slice(&metadata_slice[metadata_slice.len() - 8..metadata_slice.len()]);
+        let pos: u64 = u64::from_le_bytes(pos);
+        check_archived_value::<Self>(&metadata_slice[..metadata_slice.len() - 8], pos as usize)
+            .map_err(|err| DeserializeError::CorruptedBinary(err.to_string()))
+    }
+
+    /// Deserialize a compilation module from an archive
+    pub fn deserialize_from_archive(
+        archived: &ArchivedSerializableModule,
+    ) -> Result<Self, DeserializeError> {
+        let mut deserializer = SharedDeserializeMap::new();
+        RkyvDeserialize::deserialize(archived, &mut deserializer)
+            .map_err(|e| DeserializeError::CorruptedBinary(format!("{:?}", e)))
+    }
+
+    /// Create a `ModuleInfo` for instantiation
+    pub fn create_module_info(&self) -> ModuleInfo {
+        self.compile_info.module.as_ref().clone()
+    }
+
+    /// Returns the `ModuleInfo` for instantiation
+    pub fn module_info(&self) -> &ModuleInfo {
+        &self.compile_info.module
+    }
+
+    /// Returns the features for this Artifact
+    pub fn features(&self) -> &Features {
+        &self.compile_info.features
+    }
+
+    /// Returns the CPU features for this Artifact
+    pub fn cpu_features(&self) -> EnumSet<CpuFeature> {
+        EnumSet::from_u64(self.cpu_features)
+    }
+
+    /// Returns data initializers to pass to `VMInstance::initialize`
+    pub fn data_initializers(&self) -> &[OwnedDataInitializer] {
+        &self.data_initializers
+    }
+
+    /// Returns the memory styles associated with this `Artifact`.
+    pub fn memory_styles(&self) -> &PrimaryMap<MemoryIndex, MemoryStyle> {
+        &self.compile_info.memory_styles
+    }
+
+    /// Returns the table plans associated with this `Artifact`.
+    pub fn table_styles(&self) -> &PrimaryMap<TableIndex, TableStyle> {
+        &self.compile_info.table_styles
+    }
+}
+
+/// Metadata header which holds an ABI version and the length of the remaining
+/// metadata.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct MetadataHeader {
+    magic: [u8; 8],
+    version: u32,
+    len: u32,
+}
+
+impl MetadataHeader {
+    /// Current ABI version. Increment this any time breaking changes are made
+    /// to the format of the serialized data.
+    pub const CURRENT_VERSION: u32 = 6;
+
+    /// Magic number to identify wasmer metadata.
+    const MAGIC: [u8; 8] = *b"WASMER\0\0";
+
+    /// Length of the metadata header.
+    pub const LEN: usize = 16;
+
+    /// Alignment of the metadata.
+    pub const ALIGN: usize = 16;
+
+    /// Creates a new header for metadata of the given length.
+    pub fn new(len: usize) -> Self {
+        Self {
+            magic: Self::MAGIC,
+            version: Self::CURRENT_VERSION,
+            len: len.try_into().expect("metadata exceeds maximum length"),
+        }
+    }
+
+    /// Convert the header into its bytes representation.
+    pub fn into_bytes(self) -> [u8; 16] {
+        unsafe { mem::transmute(self) }
+    }
+
+    /// Parses the header and returns the length of the metadata following it.
+    pub fn parse(bytes: &[u8]) -> Result<usize, DeserializeError> {
+        if bytes.as_ptr() as usize % 8 != 0 {
+            return Err(DeserializeError::CorruptedBinary(
+                "misaligned metadata".to_string(),
+            ));
+        }
+        let bytes: [u8; 16] = bytes
+            .get(..16)
+            .ok_or_else(|| {
+                DeserializeError::CorruptedBinary("invalid metadata header".to_string())
+            })?
+            .try_into()
+            .unwrap();
+        let header: Self = unsafe { mem::transmute(bytes) };
+        if header.magic != Self::MAGIC {
+            return Err(DeserializeError::Incompatible(
+                "The provided bytes were not serialized by Wasmer".to_string(),
+            ));
+        }
+        if header.version != Self::CURRENT_VERSION {
+            return Err(DeserializeError::Incompatible(
+                "The provided bytes were serialized by an incompatible version of Wasmer"
+                    .to_string(),
+            ));
+        }
+        Ok(header.len as usize)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/frame.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/frame.rs
new file mode 100644
index 0000000..989b0fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/frame.rs
@@ -0,0 +1,96 @@
+use crate::SourceLoc;
+
+/// Description of a frame in a backtrace.
+///
+/// Each runtime error includes a backtrace of the WebAssembly frames that led
+/// to the trap, and each frame is described by this structure.
+#[derive(Debug, Clone)]
+pub struct FrameInfo {
+    /// The name of the module
+    module_name: String,
+    /// The index of the function in the module
+    func_index: u32,
+    /// The function name, if one is available.
+    function_name: Option<String>,
+    /// The source location of the function
+    func_start: SourceLoc,
+    /// The source location of the instruction
+    instr: SourceLoc,
+}
+
+impl FrameInfo {
+    /// Creates a new [FrameInfo], useful for testing.
+    pub fn new(
+        module_name: String,
+        func_index: u32,
+        function_name: Option<String>,
+        func_start: SourceLoc,
+        instr: SourceLoc,
+    ) -> Self {
+        Self {
+            module_name,
+            func_index,
+            function_name,
+            func_start,
+            instr,
+        }
+    }
+
+    /// Returns the WebAssembly function index for this frame.
+    ///
+    /// This function index is the index in the function index space of the
+    /// WebAssembly module that this frame comes from.
+    pub fn func_index(&self) -> u32 {
+        self.func_index
+    }
+
+    /// Returns the identifer of the module that this frame is for.
+    ///
+    /// ModuleInfo identifiers are present in the `name` section of a WebAssembly
+    /// binary, but this may not return the exact item in the `name` section.
+    /// ModuleInfo names can be overwritten at construction time or perhaps inferred
+    /// from file names. The primary purpose of this function is to assist in
+    /// debugging and therefore may be tweaked over time.
+    ///
+    /// This function returns `None` when no name can be found or inferred.
+    pub fn module_name(&self) -> &str {
+        &self.module_name
+    }
+
+    /// Returns a descriptive name of the function for this frame, if one is
+    /// available.
+    ///
+    /// The name of this function may come from the `name` section of the
+    /// WebAssembly binary, or wasmer may try to infer a better name for it if
+    /// not available, for example the name of the export if it's exported.
+    ///
+    /// This return value is primarily used for debugging and human-readable
+    /// purposes for things like traps. Note that the exact return value may be
+    /// tweaked over time here and isn't guaranteed to be something in
+    /// particular about a wasm module due to its primary purpose of assisting
+    /// in debugging.
+    ///
+    /// This function returns `None` when no name could be inferred.
+    pub fn function_name(&self) -> Option<&str> {
+        self.function_name.as_deref()
+    }
+
+    /// Returns the offset within the original wasm module this frame's program
+    /// counter was at.
+    ///
+    /// The offset here is the offset from the beginning of the original wasm
+    /// module to the instruction that this frame points to.
+    pub fn module_offset(&self) -> usize {
+        self.instr.bits() as usize
+    }
+
+    /// Returns the offset from the original wasm module's function to this
+    /// frame's program counter.
+    ///
+    /// The offset here is the offset from the beginning of the defining
+    /// function of this frame (within the wasm module) to the instruction this
+    /// frame points to.
+    pub fn func_offset(&self) -> usize {
+        (self.instr.bits() - self.func_start.bits()) as usize
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/mod.rs
new file mode 100644
index 0000000..0e36b9f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/mod.rs
@@ -0,0 +1,9 @@
+//! Types for the stack tracing / frames.
+
+mod frame;
+mod sourceloc;
+mod trap;
+
+pub use frame::FrameInfo;
+pub use sourceloc::SourceLoc;
+pub use trap::TrapInformation;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/sourceloc.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/sourceloc.rs
new file mode 100644
index 0000000..1ddb327
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/sourceloc.rs
@@ -0,0 +1,75 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Source locations.
+//!
+//! A [`SourceLoc`] determines the position of a certain instruction
+//! relative to the WebAssembly module. This is used mainly for debugging
+//! and tracing errors.
+
+use crate::lib::std::fmt;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// A source location.
+///
+/// The default source location uses the all-ones bit pattern `!0`. It is used for instructions
+/// that can't be given a real source location.
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(Serialize, Deserialize),
+    serde(transparent)
+)]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[repr(transparent)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, rkyv::CheckBytes)]
+#[archive(as = "Self")]
+pub struct SourceLoc(u32);
+
+impl SourceLoc {
+    /// Create a new source location with the given bits.
+    pub fn new(bits: u32) -> Self {
+        Self(bits)
+    }
+
+    /// Is this the default source location?
+    pub fn is_default(self) -> bool {
+        self == Default::default()
+    }
+
+    /// Read the bits of this source location.
+    pub fn bits(self) -> u32 {
+        self.0
+    }
+}
+
+impl Default for SourceLoc {
+    fn default() -> Self {
+        Self(!0)
+    }
+}
+
+impl fmt::Display for SourceLoc {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if self.is_default() {
+            write!(f, "0x-")
+        } else {
+            write!(f, "0x{:04x}", self.0)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::SourceLoc;
+    use crate::lib::std::string::ToString;
+
+    #[test]
+    fn display() {
+        assert_eq!(SourceLoc::default().to_string(), "0x-");
+        assert_eq!(SourceLoc::new(0).to_string(), "0x0000");
+        assert_eq!(SourceLoc::new(16).to_string(), "0x0010");
+        assert_eq!(SourceLoc::new(0xabcdef).to_string(), "0xabcdef");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/trap.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/trap.rs
new file mode 100644
index 0000000..37467d4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/stack/trap.rs
@@ -0,0 +1,19 @@
+//! Types for traps.
+use crate::CodeOffset;
+use crate::TrapCode;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Information about trap.
+#[cfg_attr(feature = "enable-serde", derive(Deserialize, Serialize))]
+#[derive(
+    RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes, Clone, Debug, PartialEq, Eq,
+)]
+#[archive(as = "Self")]
+pub struct TrapInformation {
+    /// The offset of the trapping instruction in native code. It is relative to the beginning of the function.
+    pub code_offset: CodeOffset,
+    /// Code of the trap.
+    pub trap_code: TrapCode,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/store_id.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/store_id.rs
new file mode 100644
index 0000000..414a4af
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/store_id.rs
@@ -0,0 +1,34 @@
+use core::fmt::Display;
+use std::{
+    num::NonZeroUsize,
+    sync::atomic::{AtomicUsize, Ordering},
+};
+
+/// Unique ID to identify a context.
+///
+/// Every handle to an object managed by a context also contains the ID of the
+/// context. This is used to check that a handle is always used with the
+/// correct context.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct StoreId(NonZeroUsize);
+
+impl Default for StoreId {
+    // Allocates a unique ID for a new context.
+    fn default() -> Self {
+        // No overflow checking is needed here: overflowing this would take
+        // thousands of years.
+        static NEXT_ID: AtomicUsize = AtomicUsize::new(1);
+        Self(NonZeroUsize::new(NEXT_ID.fetch_add(1, Ordering::Relaxed)).unwrap())
+    }
+}
+
+impl Display for StoreId {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let val: usize = self.0.into();
+        if val == usize::MAX {
+            write!(f, "unknown")
+        } else {
+            write!(f, "{}", self.0)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/table.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/table.rs
new file mode 100644
index 0000000..0b155d1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/table.rs
@@ -0,0 +1,16 @@
+use bytecheck::CheckBytes;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+/// Implementation styles for WebAssembly tables.
+#[derive(
+    Debug, Clone, Hash, PartialEq, Eq, RkyvSerialize, RkyvDeserialize, Archive, CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum TableStyle {
+    /// Signatures are stored in the table and checked in the caller.
+    CallerChecksSignature,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/trapcode.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/trapcode.rs
new file mode 100644
index 0000000..88a4bf5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/trapcode.rs
@@ -0,0 +1,179 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Trap codes describing the reason for a trap.
+
+use core::fmt::{self, Display, Formatter};
+use core::str::FromStr;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+/// A trap code describing the reason for a trap.
+///
+/// All trap instructions have an explicit trap code.
+#[derive(
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Debug,
+    Hash,
+    Error,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[repr(u32)]
+#[archive(as = "Self")]
+pub enum TrapCode {
+    /// The current stack space was exhausted.
+    ///
+    /// On some platforms, a stack overflow may also be indicated by a segmentation fault from the
+    /// stack guard page.
+    StackOverflow = 0,
+
+    /// A `heap_addr` instruction detected an out-of-bounds error.
+    ///
+    /// Note that not all out-of-bounds heap accesses are reported this way;
+    /// some are detected by a segmentation fault on the heap unmapped or
+    /// offset-guard pages.
+    HeapAccessOutOfBounds = 1,
+
+    /// A `heap_addr` instruction was misaligned.
+    HeapMisaligned = 2,
+
+    /// A `table_addr` instruction detected an out-of-bounds error.
+    TableAccessOutOfBounds = 3,
+
+    /// Indirect call to a null table entry.
+    IndirectCallToNull = 4,
+
+    /// Signature mismatch on indirect call.
+    BadSignature = 5,
+
+    /// An integer arithmetic operation caused an overflow.
+    IntegerOverflow = 6,
+
+    /// An integer division by zero.
+    IntegerDivisionByZero = 7,
+
+    /// Failed float-to-int conversion.
+    BadConversionToInteger = 8,
+
+    /// Code that was supposed to have been unreachable was reached.
+    UnreachableCodeReached = 9,
+
+    /// An atomic memory access was attempted with an unaligned pointer.
+    UnalignedAtomic = 10,
+}
+
+impl TrapCode {
+    /// Gets the message for this trap code
+    pub fn message(&self) -> &str {
+        match self {
+            Self::StackOverflow => "call stack exhausted",
+            Self::HeapAccessOutOfBounds => "out of bounds memory access",
+            Self::HeapMisaligned => "misaligned heap",
+            Self::TableAccessOutOfBounds => "undefined element: out of bounds table access",
+            Self::IndirectCallToNull => "uninitialized element",
+            Self::BadSignature => "indirect call type mismatch",
+            Self::IntegerOverflow => "integer overflow",
+            Self::IntegerDivisionByZero => "integer divide by zero",
+            Self::BadConversionToInteger => "invalid conversion to integer",
+            Self::UnreachableCodeReached => "unreachable",
+            Self::UnalignedAtomic => "unaligned atomic access",
+        }
+    }
+}
+
+impl Display for TrapCode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        let identifier = match *self {
+            Self::StackOverflow => "stk_ovf",
+            Self::HeapAccessOutOfBounds => "heap_get_oob",
+            Self::HeapMisaligned => "heap_misaligned",
+            Self::TableAccessOutOfBounds => "table_get_oob",
+            Self::IndirectCallToNull => "icall_null",
+            Self::BadSignature => "bad_sig",
+            Self::IntegerOverflow => "int_ovf",
+            Self::IntegerDivisionByZero => "int_divz",
+            Self::BadConversionToInteger => "bad_toint",
+            Self::UnreachableCodeReached => "unreachable",
+            Self::UnalignedAtomic => "unalign_atom",
+        };
+        f.write_str(identifier)
+    }
+}
+
+impl FromStr for TrapCode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "stk_ovf" => Ok(Self::StackOverflow),
+            "heap_get_oob" => Ok(Self::HeapAccessOutOfBounds),
+            "heap_misaligned" => Ok(Self::HeapMisaligned),
+            "table_get_oob" => Ok(Self::TableAccessOutOfBounds),
+            "icall_null" => Ok(Self::IndirectCallToNull),
+            "bad_sig" => Ok(Self::BadSignature),
+            "int_ovf" => Ok(Self::IntegerOverflow),
+            "int_divz" => Ok(Self::IntegerDivisionByZero),
+            "bad_toint" => Ok(Self::BadConversionToInteger),
+            "unreachable" => Ok(Self::UnreachableCodeReached),
+            "unalign_atom" => Ok(Self::UnalignedAtomic),
+            _ => Err(()),
+        }
+    }
+}
+
+// TODO: OnCalledAction is needed for asyncify. It will be refactored with https://github.com/wasmerio/wasmer/issues/3451
+/// After the stack is unwound via asyncify what
+/// should the call loop do next
+#[derive(Debug)]
+pub enum OnCalledAction {
+    /// Will call the function again
+    InvokeAgain,
+    /// Will return the result of the invocation
+    Finish,
+    /// Traps with an error
+    Trap(Box<dyn std::error::Error + Send + Sync>),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Everything but user-defined codes.
+    const CODES: [TrapCode; 11] = [
+        TrapCode::StackOverflow,
+        TrapCode::HeapAccessOutOfBounds,
+        TrapCode::HeapMisaligned,
+        TrapCode::TableAccessOutOfBounds,
+        TrapCode::IndirectCallToNull,
+        TrapCode::BadSignature,
+        TrapCode::IntegerOverflow,
+        TrapCode::IntegerDivisionByZero,
+        TrapCode::BadConversionToInteger,
+        TrapCode::UnreachableCodeReached,
+        TrapCode::UnalignedAtomic,
+    ];
+
+    #[test]
+    fn display() {
+        for r in &CODES {
+            let tc = *r;
+            assert_eq!(tc.to_string().parse(), Ok(tc));
+        }
+        assert_eq!("bogus".parse::<TrapCode>(), Err(()));
+
+        // assert_eq!(TrapCode::User(17).to_string(), "user17");
+        // assert_eq!("user22".parse(), Ok(TrapCode::User(22)));
+        assert_eq!("user".parse::<TrapCode>(), Err(()));
+        assert_eq!("user-1".parse::<TrapCode>(), Err(()));
+        assert_eq!("users".parse::<TrapCode>(), Err(()));
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/types.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/types.rs
new file mode 100644
index 0000000..588a4e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/types.rs
@@ -0,0 +1,642 @@
+use crate::indexes::{FunctionIndex, GlobalIndex};
+use crate::lib::std::borrow::ToOwned;
+use crate::lib::std::fmt;
+use crate::lib::std::format;
+use crate::lib::std::string::{String, ToString};
+use crate::lib::std::vec::Vec;
+use crate::units::Pages;
+
+use bytecheck::CheckBytes;
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+// Type Representations
+
+// Value Types
+
+/// A list of all possible value types in WebAssembly.
+#[derive(Copy, Debug, Clone, Eq, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum Type {
+    /// Signed 32 bit integer.
+    I32,
+    /// Signed 64 bit integer.
+    I64,
+    /// Floating point 32 bit integer.
+    F32,
+    /// Floating point 64 bit integer.
+    F64,
+    /// A 128 bit number.
+    V128,
+    /// A reference to opaque data in the Wasm instance.
+    ExternRef, /* = 128 */
+    /// A reference to a Wasm function.
+    FuncRef,
+}
+
+impl Type {
+    /// Returns true if `Type` matches any of the numeric types. (e.g. `I32`,
+    /// `I64`, `F32`, `F64`, `V128`).
+    pub fn is_num(self) -> bool {
+        matches!(
+            self,
+            Self::I32 | Self::I64 | Self::F32 | Self::F64 | Self::V128
+        )
+    }
+
+    /// Returns true if `Type` matches either of the reference types.
+    pub fn is_ref(self) -> bool {
+        matches!(self, Self::ExternRef | Self::FuncRef)
+    }
+}
+
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+/// The WebAssembly V128 type
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, CheckBytes)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive(as = "Self")]
+pub struct V128(pub(crate) [u8; 16]);
+
+impl V128 {
+    /// Get the bytes corresponding to the V128 value
+    pub fn bytes(&self) -> &[u8; 16] {
+        &self.0
+    }
+    /// Iterate over the bytes in the constant.
+    pub fn iter(&self) -> impl Iterator<Item = &u8> {
+        self.0.iter()
+    }
+
+    /// Convert the immediate into a vector.
+    pub fn to_vec(self) -> Vec<u8> {
+        self.0.to_vec()
+    }
+
+    /// Convert the immediate into a slice.
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0[..]
+    }
+}
+
+impl From<[u8; 16]> for V128 {
+    fn from(array: [u8; 16]) -> Self {
+        Self(array)
+    }
+}
+
+impl From<&[u8]> for V128 {
+    fn from(slice: &[u8]) -> Self {
+        assert_eq!(slice.len(), 16);
+        let mut buffer = [0; 16];
+        buffer.copy_from_slice(slice);
+        Self(buffer)
+    }
+}
+
+// External Types
+
+/// A list of all possible types which can be externally referenced from a
+/// WebAssembly module.
+///
+/// This list can be found in [`ImportType`] or [`ExportType`], so these types
+/// can either be imported or exported.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum ExternType {
+    /// This external type is the type of a WebAssembly function.
+    Function(FunctionType),
+    /// This external type is the type of a WebAssembly global.
+    Global(GlobalType),
+    /// This external type is the type of a WebAssembly table.
+    Table(TableType),
+    /// This external type is the type of a WebAssembly memory.
+    Memory(MemoryType),
+}
+
+fn is_global_compatible(exported: GlobalType, imported: GlobalType) -> bool {
+    let GlobalType {
+        ty: exported_ty,
+        mutability: exported_mutability,
+    } = exported;
+    let GlobalType {
+        ty: imported_ty,
+        mutability: imported_mutability,
+    } = imported;
+
+    exported_ty == imported_ty && imported_mutability == exported_mutability
+}
+
+fn is_table_element_type_compatible(exported_type: Type, imported_type: Type) -> bool {
+    match exported_type {
+        Type::FuncRef => true,
+        _ => imported_type == exported_type,
+    }
+}
+
+fn is_table_compatible(
+    exported: &TableType,
+    imported: &TableType,
+    imported_runtime_size: Option<u32>,
+) -> bool {
+    let TableType {
+        ty: exported_ty,
+        minimum: exported_minimum,
+        maximum: exported_maximum,
+    } = exported;
+    let TableType {
+        ty: imported_ty,
+        minimum: imported_minimum,
+        maximum: imported_maximum,
+    } = imported;
+
+    is_table_element_type_compatible(*exported_ty, *imported_ty)
+        && *imported_minimum <= imported_runtime_size.unwrap_or(*exported_minimum)
+        && (imported_maximum.is_none()
+            || (!exported_maximum.is_none()
+                && imported_maximum.unwrap() >= exported_maximum.unwrap()))
+}
+
+fn is_memory_compatible(
+    exported: &MemoryType,
+    imported: &MemoryType,
+    imported_runtime_size: Option<u32>,
+) -> bool {
+    let MemoryType {
+        minimum: exported_minimum,
+        maximum: exported_maximum,
+        shared: exported_shared,
+    } = exported;
+    let MemoryType {
+        minimum: imported_minimum,
+        maximum: imported_maximum,
+        shared: imported_shared,
+    } = imported;
+
+    imported_minimum.0 <= imported_runtime_size.unwrap_or(exported_minimum.0)
+        && (imported_maximum.is_none()
+            || (!exported_maximum.is_none()
+                && imported_maximum.unwrap() >= exported_maximum.unwrap()))
+        && exported_shared == imported_shared
+}
+
+macro_rules! accessors {
+    ($(($variant:ident($ty:ty) $get:ident $unwrap:ident))*) => ($(
+        /// Attempt to return the underlying type of this external type,
+        /// returning `None` if it is a different type.
+        pub fn $get(&self) -> Option<&$ty> {
+            if let Self::$variant(e) = self {
+                Some(e)
+            } else {
+                None
+            }
+        }
+
+        /// Returns the underlying descriptor of this [`ExternType`], panicking
+        /// if it is a different type.
+        ///
+        /// # Panics
+        ///
+        /// Panics if `self` is not of the right type.
+        pub fn $unwrap(&self) -> &$ty {
+            self.$get().expect(concat!("expected ", stringify!($ty)))
+        }
+    )*)
+}
+
+impl ExternType {
+    accessors! {
+        (Function(FunctionType) func unwrap_func)
+        (Global(GlobalType) global unwrap_global)
+        (Table(TableType) table unwrap_table)
+        (Memory(MemoryType) memory unwrap_memory)
+    }
+    /// Check if two externs are compatible
+    pub fn is_compatible_with(&self, other: &Self, runtime_size: Option<u32>) -> bool {
+        match (self, other) {
+            (Self::Function(a), Self::Function(b)) => a == b,
+            (Self::Global(a), Self::Global(b)) => is_global_compatible(*a, *b),
+            (Self::Table(a), Self::Table(b)) => is_table_compatible(a, b, runtime_size),
+            (Self::Memory(a), Self::Memory(b)) => is_memory_compatible(a, b, runtime_size),
+            // The rest of possibilities, are not compatible
+            _ => false,
+        }
+    }
+}
+
+// TODO: `shrink_to_fit` these or change it to `Box<[Type]>` if not using
+// Cow or something else
+/// The signature of a function that is either implemented
+/// in a Wasm module or exposed to Wasm by the host.
+///
+/// WebAssembly functions can have 0 or more parameters and results.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct FunctionType {
+    /// The parameters of the function
+    params: Box<[Type]>,
+    /// The return values of the function
+    results: Box<[Type]>,
+}
+
+impl FunctionType {
+    /// Creates a new Function Type with the given parameter and return types.
+    pub fn new<Params, Returns>(params: Params, returns: Returns) -> Self
+    where
+        Params: Into<Box<[Type]>>,
+        Returns: Into<Box<[Type]>>,
+    {
+        Self {
+            params: params.into(),
+            results: returns.into(),
+        }
+    }
+
+    /// Parameter types.
+    pub fn params(&self) -> &[Type] {
+        &self.params
+    }
+
+    /// Return types.
+    pub fn results(&self) -> &[Type] {
+        &self.results
+    }
+}
+
+impl fmt::Display for FunctionType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let params = self
+            .params
+            .iter()
+            .map(|p| format!("{:?}", p))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let results = self
+            .results
+            .iter()
+            .map(|p| format!("{:?}", p))
+            .collect::<Vec<_>>()
+            .join(", ");
+        write!(f, "[{}] -> [{}]", params, results)
+    }
+}
+
+// Macro needed until https://rust-lang.github.io/rfcs/2000-const-generics.html is stable.
+// See https://users.rust-lang.org/t/how-to-implement-trait-for-fixed-size-array-of-any-size/31494
+macro_rules! implement_from_pair_to_functiontype {
+    ($($N:literal,$M:literal)+) => {
+        $(
+            impl From<([Type; $N], [Type; $M])> for FunctionType {
+                fn from(pair: ([Type; $N], [Type; $M])) -> Self {
+                    Self::new(pair.0, pair.1)
+                }
+            }
+        )+
+    }
+}
+
+implement_from_pair_to_functiontype! {
+    0,0 0,1 0,2 0,3 0,4 0,5 0,6 0,7 0,8 0,9
+    1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8 1,9
+    2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 2,9
+    3,0 3,1 3,2 3,3 3,4 3,5 3,6 3,7 3,8 3,9
+    4,0 4,1 4,2 4,3 4,4 4,5 4,6 4,7 4,8 4,9
+    5,0 5,1 5,2 5,3 5,4 5,5 5,6 5,7 5,8 5,9
+    6,0 6,1 6,2 6,3 6,4 6,5 6,6 6,7 6,8 6,9
+    7,0 7,1 7,2 7,3 7,4 7,5 7,6 7,7 7,8 7,9
+    8,0 8,1 8,2 8,3 8,4 8,5 8,6 8,7 8,8 8,9
+    9,0 9,1 9,2 9,3 9,4 9,5 9,6 9,7 9,8 9,9
+}
+
+impl From<&Self> for FunctionType {
+    fn from(as_ref: &Self) -> Self {
+        as_ref.clone()
+    }
+}
+
+/// Indicator of whether a global is mutable or not
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, CheckBytes)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum Mutability {
+    /// The global is constant and its value does not change
+    Const,
+    /// The value of the global can change over time
+    Var,
+}
+
+impl Mutability {
+    /// Returns a boolean indicating if the enum is set to mutable.
+    pub fn is_mutable(self) -> bool {
+        self.into()
+    }
+}
+
+impl From<bool> for Mutability {
+    fn from(value: bool) -> Self {
+        if value {
+            Self::Var
+        } else {
+            Self::Const
+        }
+    }
+}
+
+impl From<Mutability> for bool {
+    fn from(value: Mutability) -> Self {
+        match value {
+            Mutability::Var => true,
+            Mutability::Const => false,
+        }
+    }
+}
+
+/// WebAssembly global.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, CheckBytes)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive(as = "Self")]
+pub struct GlobalType {
+    /// The type of the value stored in the global.
+    pub ty: Type,
+    /// A flag indicating whether the value may change at runtime.
+    pub mutability: Mutability,
+}
+
+// Global Types
+
+/// A WebAssembly global descriptor.
+///
+/// This type describes an instance of a global in a WebAssembly
+/// module. Globals are local to an `Instance` and are either
+/// immutable or mutable.
+impl GlobalType {
+    /// Create a new Global variable
+    /// # Usage:
+    /// ```
+    /// use wasmer_types::{GlobalType, Type, Mutability};
+    ///
+    /// // An I32 constant global
+    /// let global = GlobalType::new(Type::I32, Mutability::Const);
+    /// // An I64 mutable global
+    /// let global = GlobalType::new(Type::I64, Mutability::Var);
+    /// ```
+    pub fn new(ty: Type, mutability: Mutability) -> Self {
+        Self { ty, mutability }
+    }
+}
+
+impl fmt::Display for GlobalType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mutability = match self.mutability {
+            Mutability::Const => "constant",
+            Mutability::Var => "mutable",
+        };
+        write!(f, "{} ({})", self.ty, mutability)
+    }
+}
+
+/// Globals are initialized via the `const` operators or by referring to another import.
+#[derive(Debug, Clone, Copy, PartialEq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive, rkyv::CheckBytes)]
+#[archive(as = "Self")]
+#[repr(u8)]
+pub enum GlobalInit {
+    /// An `i32.const`.
+    I32Const(i32),
+    /// An `i64.const`.
+    I64Const(i64),
+    /// An `f32.const`.
+    F32Const(f32),
+    /// An `f64.const`.
+    F64Const(f64),
+    /// A `v128.const`.
+    V128Const(V128),
+    /// A `global.get` of another global.
+    GetGlobal(GlobalIndex),
+    // TODO(reftypes): `ref.null func` and `ref.null extern` seem to be 2 different
+    // things: we need to handle both. Perhaps this handled in context by the
+    // global knowing its own type?
+    /// A `ref.null`.
+    RefNullConst,
+    /// A `ref.func <index>`.
+    RefFunc(FunctionIndex),
+}
+
+// Table Types
+
+/// A descriptor for a table in a WebAssembly module.
+///
+/// Tables are contiguous chunks of a specific element, typically a `funcref` or
+/// an `externref`. The most common use for tables is a function table through
+/// which `call_indirect` can invoke other functions.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct TableType {
+    /// The type of data stored in elements of the table.
+    pub ty: Type,
+    /// The minimum number of elements in the table.
+    pub minimum: u32,
+    /// The maximum number of elements in the table.
+    pub maximum: Option<u32>,
+}
+
+impl TableType {
+    /// Creates a new table descriptor which will contain the specified
+    /// `element` and have the `limits` applied to its length.
+    pub fn new(ty: Type, minimum: u32, maximum: Option<u32>) -> Self {
+        Self {
+            ty,
+            minimum,
+            maximum,
+        }
+    }
+}
+
+impl fmt::Display for TableType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if let Some(maximum) = self.maximum {
+            write!(f, "{} ({}..{})", self.ty, self.minimum, maximum)
+        } else {
+            write!(f, "{} ({}..)", self.ty, self.minimum)
+        }
+    }
+}
+
+// Memory Types
+
+/// A descriptor for a WebAssembly memory type.
+///
+/// Memories are described in units of pages (64KB) and represent contiguous
+/// chunks of addressable memory.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[derive(RkyvSerialize, RkyvDeserialize, Archive)]
+#[archive_attr(derive(CheckBytes))]
+pub struct MemoryType {
+    /// The minimum number of pages in the memory.
+    pub minimum: Pages,
+    /// The maximum number of pages in the memory.
+    pub maximum: Option<Pages>,
+    /// Whether the memory may be shared between multiple threads.
+    pub shared: bool,
+}
+
+impl MemoryType {
+    /// Creates a new descriptor for a WebAssembly memory given the specified
+    /// limits of the memory.
+    pub fn new<IntoPages>(minimum: IntoPages, maximum: Option<IntoPages>, shared: bool) -> Self
+    where
+        IntoPages: Into<Pages>,
+    {
+        Self {
+            minimum: minimum.into(),
+            maximum: maximum.map(Into::into),
+            shared,
+        }
+    }
+}
+
+impl fmt::Display for MemoryType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let shared = if self.shared { "shared" } else { "not shared" };
+        if let Some(maximum) = self.maximum {
+            write!(f, "{} ({:?}..{:?})", shared, self.minimum, maximum)
+        } else {
+            write!(f, "{} ({:?}..)", shared, self.minimum)
+        }
+    }
+}
+
+// Import Types
+
+/// A descriptor for an imported value into a wasm module.
+///
+/// This type is primarily accessed from the `Module::imports`
+/// API. Each `ImportType` describes an import into the wasm module
+/// with the module/name that it's imported from as well as the type
+/// of item that's being imported.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ImportType<T = ExternType> {
+    module: String,
+    name: String,
+    ty: T,
+}
+
+impl<T> ImportType<T> {
+    /// Creates a new import descriptor which comes from `module` and `name` and
+    /// is of type `ty`.
+    pub fn new(module: &str, name: &str, ty: T) -> Self {
+        Self {
+            module: module.to_owned(),
+            name: name.to_owned(),
+            ty,
+        }
+    }
+
+    /// Returns the module name that this import is expected to come from.
+    pub fn module(&self) -> &str {
+        &self.module
+    }
+
+    /// Returns the field name of the module that this import is expected to
+    /// come from.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Returns the expected type of this import.
+    pub fn ty(&self) -> &T {
+        &self.ty
+    }
+}
+
+// Export Types
+
+/// A descriptor for an exported WebAssembly value.
+///
+/// This type is primarily accessed from the `Module::exports`
+/// accessor and describes what names are exported from a wasm module
+/// and the type of the item that is exported.
+///
+/// The `<T>` refefers to `ExternType`, however it can also refer to use
+/// `MemoryType`, `TableType`, `FunctionType` and `GlobalType` for ease of
+/// use.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct ExportType<T = ExternType> {
+    name: String,
+    ty: T,
+}
+
+impl<T> ExportType<T> {
+    /// Creates a new export which is exported with the given `name` and has the
+    /// given `ty`.
+    pub fn new(name: &str, ty: T) -> Self {
+        Self {
+            name: name.to_string(),
+            ty,
+        }
+    }
+
+    /// Returns the name by which this export is known by.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Returns the type of this export.
+    pub fn ty(&self) -> &T {
+        &self.ty
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const VOID_TO_VOID: ([Type; 0], [Type; 0]) = ([], []);
+    const I32_I32_TO_VOID: ([Type; 2], [Type; 0]) = ([Type::I32, Type::I32], []);
+    const V128_I64_TO_I32: ([Type; 2], [Type; 1]) = ([Type::V128, Type::I64], [Type::I32]);
+    const NINE_V128_TO_NINE_I32: ([Type; 9], [Type; 9]) = ([Type::V128; 9], [Type::I32; 9]);
+
+    #[test]
+    fn convert_tuple_to_functiontype() {
+        let ty: FunctionType = VOID_TO_VOID.into();
+        assert_eq!(ty.params().len(), 0);
+        assert_eq!(ty.results().len(), 0);
+
+        let ty: FunctionType = I32_I32_TO_VOID.into();
+        assert_eq!(ty.params().len(), 2);
+        assert_eq!(ty.params()[0], Type::I32);
+        assert_eq!(ty.params()[1], Type::I32);
+        assert_eq!(ty.results().len(), 0);
+
+        let ty: FunctionType = V128_I64_TO_I32.into();
+        assert_eq!(ty.params().len(), 2);
+        assert_eq!(ty.params()[0], Type::V128);
+        assert_eq!(ty.params()[1], Type::I64);
+        assert_eq!(ty.results().len(), 1);
+        assert_eq!(ty.results()[0], Type::I32);
+
+        let ty: FunctionType = NINE_V128_TO_NINE_I32.into();
+        assert_eq!(ty.params().len(), 9);
+        assert_eq!(ty.results().len(), 9);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/units.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/units.rs
new file mode 100644
index 0000000..60e488b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/units.rs
@@ -0,0 +1,193 @@
+use crate::lib::std::convert::TryFrom;
+use crate::lib::std::fmt;
+use crate::lib::std::ops::{Add, Sub};
+use rkyv::{Archive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use thiserror::Error;
+
+/// WebAssembly page sizes are fixed to be 64KiB.
+/// Note: large page support may be added in an opt-in manner in the [future].
+///
+/// [future]: https://webassembly.org/docs/future-features/#large-page-support
+pub const WASM_PAGE_SIZE: usize = 0x10000;
+
+/// The number of pages we can have before we run out of byte index space.
+pub const WASM_MAX_PAGES: u32 = 0x10000;
+
+/// The minimum number of pages allowed.
+pub const WASM_MIN_PAGES: u32 = 0x100;
+
+/// Units of WebAssembly pages (as specified to be 65,536 bytes).
+#[derive(
+    Copy,
+    Clone,
+    PartialEq,
+    Eq,
+    PartialOrd,
+    Ord,
+    Hash,
+    RkyvSerialize,
+    RkyvDeserialize,
+    Archive,
+    rkyv::CheckBytes,
+)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[archive(as = "Self")]
+pub struct Pages(pub u32);
+
+impl Pages {
+    /// Returns the largest value that can be represented by the Pages type.
+    ///
+    /// This is defined by the WebAssembly standard as 65,536 pages.
+    #[inline(always)]
+    pub const fn max_value() -> Self {
+        Self(WASM_MAX_PAGES)
+    }
+
+    /// Checked addition. Computes `self + rhs`,
+    /// returning `None` if overflow occurred.
+    pub fn checked_add(self, rhs: Self) -> Option<Self> {
+        let added = (self.0 as usize) + (rhs.0 as usize);
+        if added <= (WASM_MAX_PAGES as usize) {
+            Some(Self(added as u32))
+        } else {
+            None
+        }
+    }
+
+    /// Calculate number of bytes from pages.
+    pub fn bytes(self) -> Bytes {
+        self.into()
+    }
+}
+
+impl fmt::Debug for Pages {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} pages", self.0)
+    }
+}
+
+impl From<u32> for Pages {
+    fn from(other: u32) -> Self {
+        Self(other)
+    }
+}
+
+/// Units of WebAssembly memory in terms of 8-bit bytes.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Bytes(pub usize);
+
+impl fmt::Debug for Bytes {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{} bytes", self.0)
+    }
+}
+
+impl From<Pages> for Bytes {
+    fn from(pages: Pages) -> Self {
+        Self((pages.0 as usize) * WASM_PAGE_SIZE)
+    }
+}
+
+impl From<usize> for Bytes {
+    fn from(other: usize) -> Self {
+        Self(other)
+    }
+}
+
+impl From<u32> for Bytes {
+    fn from(other: u32) -> Self {
+        Self(other.try_into().unwrap())
+    }
+}
+
+impl<T> Sub<T> for Pages
+where
+    T: Into<Self>,
+{
+    type Output = Self;
+    fn sub(self, rhs: T) -> Self {
+        Self(self.0 - rhs.into().0)
+    }
+}
+
+impl<T> Add<T> for Pages
+where
+    T: Into<Self>,
+{
+    type Output = Self;
+    fn add(self, rhs: T) -> Self {
+        Self(self.0 + rhs.into().0)
+    }
+}
+
+/// The only error that can happen when converting `Bytes` to `Pages`
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
+#[error("Number of pages exceeds uint32 range")]
+pub struct PageCountOutOfRange;
+
+impl TryFrom<Bytes> for Pages {
+    type Error = PageCountOutOfRange;
+
+    fn try_from(bytes: Bytes) -> Result<Self, Self::Error> {
+        let pages: u32 = (bytes.0 / WASM_PAGE_SIZE)
+            .try_into()
+            .or(Err(PageCountOutOfRange))?;
+        Ok(Self(pages))
+    }
+}
+
+impl<T> Sub<T> for Bytes
+where
+    T: Into<Self>,
+{
+    type Output = Self;
+    fn sub(self, rhs: T) -> Self {
+        Self(self.0 - rhs.into().0)
+    }
+}
+
+impl<T> Add<T> for Bytes
+where
+    T: Into<Self>,
+{
+    type Output = Self;
+    fn add(self, rhs: T) -> Self {
+        Self(self.0 + rhs.into().0)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn convert_bytes_to_pages() {
+        // rounds down
+        let pages = Pages::try_from(Bytes(0)).unwrap();
+        assert_eq!(pages, Pages(0));
+        let pages = Pages::try_from(Bytes(1)).unwrap();
+        assert_eq!(pages, Pages(0));
+        let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE - 1)).unwrap();
+        assert_eq!(pages, Pages(0));
+        let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE)).unwrap();
+        assert_eq!(pages, Pages(1));
+        let pages = Pages::try_from(Bytes(WASM_PAGE_SIZE + 1)).unwrap();
+        assert_eq!(pages, Pages(1));
+        let pages = Pages::try_from(Bytes(28 * WASM_PAGE_SIZE + 42)).unwrap();
+        assert_eq!(pages, Pages(28));
+        let pages = Pages::try_from(Bytes((u32::MAX as usize) * WASM_PAGE_SIZE)).unwrap();
+        assert_eq!(pages, Pages(u32::MAX));
+        let pages = Pages::try_from(Bytes((u32::MAX as usize) * WASM_PAGE_SIZE + 1)).unwrap();
+        assert_eq!(pages, Pages(u32::MAX));
+
+        // Errors when page count cannot be represented as u32
+        let result = Pages::try_from(Bytes((u32::MAX as usize + 1) * WASM_PAGE_SIZE));
+        assert_eq!(result.unwrap_err(), PageCountOutOfRange);
+        let result = Pages::try_from(Bytes(usize::MAX));
+        assert_eq!(result.unwrap_err(), PageCountOutOfRange);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/utils.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/utils.rs
new file mode 100644
index 0000000..b3f067f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/utils.rs
@@ -0,0 +1,4 @@
+/// Check if the provided bytes are wasm-like
+pub fn is_wasm(bytes: impl AsRef<[u8]>) -> bool {
+    bytes.as_ref().starts_with(b"\0asm")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/value.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/value.rs
new file mode 100644
index 0000000..0455946
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/value.rs
@@ -0,0 +1,141 @@
+use core::{fmt, marker::PhantomData, mem::MaybeUninit};
+
+/// Raw representation of a WebAssembly value.
+///
+/// In most cases you will want to use the type-safe `Value` wrapper instead.
+#[allow(missing_docs)]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union RawValue {
+    pub i32: i32,
+    pub i64: i64,
+    pub u32: u32,
+    pub u64: u64,
+    pub f32: f32,
+    pub f64: f64,
+    pub i128: i128,
+    pub u128: u128,
+    pub funcref: usize,
+    pub externref: usize,
+    pub bytes: [u8; 16],
+}
+
+impl From<i32> for RawValue {
+    fn from(value: i32) -> Self {
+        Self { i32: value }
+    }
+}
+
+impl From<i64> for RawValue {
+    fn from(value: i64) -> Self {
+        Self { i64: value }
+    }
+}
+
+impl From<f32> for RawValue {
+    fn from(value: f32) -> Self {
+        Self { f32: value }
+    }
+}
+
+impl From<f64> for RawValue {
+    fn from(value: f64) -> Self {
+        Self { f64: value }
+    }
+}
+
+impl Default for RawValue {
+    fn default() -> Self {
+        Self { bytes: [0; 16] }
+    }
+}
+
+impl fmt::Debug for RawValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RawValue")
+            .field("bytes", unsafe { &self.bytes })
+            .finish()
+    }
+}
+
+macro_rules! partial_eq {
+    ($($t:ty => $f:tt),*) => ($(
+        impl PartialEq<$t> for RawValue {
+            fn eq(&self, o: &$t) -> bool {
+                unsafe { self.$f == *o }
+            }
+        }
+    )*)
+}
+
+partial_eq! {
+    i32 => i32,
+    u32 => u32,
+    i64 => i64,
+    u64 => u64,
+    f32 => f32,
+    f64 => f64,
+    i128 => i128,
+    u128 => u128
+}
+
+impl PartialEq for RawValue {
+    fn eq(&self, o: &Self) -> bool {
+        unsafe { self.u128 == o.u128 }
+    }
+}
+
+/// Trait for a Value type. A Value type is a type that is always valid and may
+/// be safely copied.
+///
+/// # Safety
+///
+/// To maintain safety, types which implement this trait must be valid for all
+/// bit patterns. This means that it cannot contain enums, `bool`, references,
+/// etc.
+///
+/// Concretely a `u32` is a Value type because every combination of 32 bits is
+/// a valid `u32`. However a `bool` is _not_ a Value type because any bit patterns
+/// other than `0` and `1` are invalid in Rust and may cause undefined behavior if
+/// a `bool` is constructed from those bytes.
+///
+/// Additionally this trait has a method which zeros out any uninitializes bytes
+/// prior to writing them to Wasm memory, which prevents information leaks into
+/// the sandbox.
+pub unsafe trait ValueType: Copy {
+    /// This method is passed a byte slice which contains the byte
+    /// representation of `self`. It must zero out any bytes which are
+    /// uninitialized (e.g. padding bytes).
+    fn zero_padding_bytes(&self, bytes: &mut [MaybeUninit<u8>]);
+}
+
+// Trivial implementations for primitive types and arrays of them.
+macro_rules! primitives {
+    ($($t:ident)*) => ($(
+        unsafe impl ValueType for $t {
+            #[inline]
+            fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+        }
+        unsafe impl<const N: usize> ValueType for [$t; N] {
+            #[inline]
+            fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+        }
+    )*)
+}
+primitives! {
+    bool
+    i8 u8
+    i16 u16
+    i32 u32
+    i64 u64
+    i128 u128
+    isize usize
+    f32 f64
+}
+
+// This impl for PhantomData allows #[derive(ValueType)] to work with types
+// that contain a PhantomData.
+unsafe impl<T: ?Sized> ValueType for PhantomData<T> {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/types/src/vmoffsets.rs b/arbitrator/tools/module_roots/wasmer/lib/types/src/vmoffsets.rs
new file mode 100644
index 0000000..47e457f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/types/src/vmoffsets.rs
@@ -0,0 +1,795 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Offsets and sizes of various structs in wasmer-vm's vmcontext
+//! module.
+
+#![deny(rustdoc::broken_intra_doc_links)]
+
+use crate::{
+    FunctionIndex, GlobalIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
+    ModuleInfo, SignatureIndex, TableIndex,
+};
+use more_asserts::assert_lt;
+use std::convert::TryFrom;
+use std::mem::size_of;
+
+/// An index type for builtin functions.
+#[derive(Copy, Clone, Debug)]
+pub struct VMBuiltinFunctionIndex(u32);
+
+impl VMBuiltinFunctionIndex {
+    /// Returns an index for wasm's `memory.grow` builtin function.
+    pub const fn get_memory32_grow_index() -> Self {
+        Self(0)
+    }
+    /// Returns an index for wasm's imported `memory.grow` builtin function.
+    pub const fn get_imported_memory32_grow_index() -> Self {
+        Self(1)
+    }
+    /// Returns an index for wasm's `memory.size` builtin function.
+    pub const fn get_memory32_size_index() -> Self {
+        Self(2)
+    }
+    /// Returns an index for wasm's imported `memory.size` builtin function.
+    pub const fn get_imported_memory32_size_index() -> Self {
+        Self(3)
+    }
+    /// Returns an index for wasm's `table.copy` when both tables are locally
+    /// defined.
+    pub const fn get_table_copy_index() -> Self {
+        Self(4)
+    }
+    /// Returns an index for wasm's `table.init`.
+    pub const fn get_table_init_index() -> Self {
+        Self(5)
+    }
+    /// Returns an index for wasm's `elem.drop`.
+    pub const fn get_elem_drop_index() -> Self {
+        Self(6)
+    }
+    /// Returns an index for wasm's `memory.copy` for locally defined memories.
+    pub const fn get_memory_copy_index() -> Self {
+        Self(7)
+    }
+    /// Returns an index for wasm's `memory.copy` for imported memories.
+    pub const fn get_imported_memory_copy_index() -> Self {
+        Self(8)
+    }
+    /// Returns an index for wasm's `memory.fill` for locally defined memories.
+    pub const fn get_memory_fill_index() -> Self {
+        Self(9)
+    }
+    /// Returns an index for wasm's `memory.fill` for imported memories.
+    pub const fn get_imported_memory_fill_index() -> Self {
+        Self(10)
+    }
+    /// Returns an index for wasm's `memory.init` instruction.
+    pub const fn get_memory_init_index() -> Self {
+        Self(11)
+    }
+    /// Returns an index for wasm's `data.drop` instruction.
+    pub const fn get_data_drop_index() -> Self {
+        Self(12)
+    }
+    /// Returns an index for wasm's `raise_trap` instruction.
+    pub const fn get_raise_trap_index() -> Self {
+        Self(13)
+    }
+    /// Returns an index for wasm's `table.size` instruction for local tables.
+    pub const fn get_table_size_index() -> Self {
+        Self(14)
+    }
+    /// Returns an index for wasm's `table.size` instruction for imported tables.
+    pub const fn get_imported_table_size_index() -> Self {
+        Self(15)
+    }
+    /// Returns an index for wasm's `table.grow` instruction for local tables.
+    pub const fn get_table_grow_index() -> Self {
+        Self(16)
+    }
+    /// Returns an index for wasm's `table.grow` instruction for imported tables.
+    pub const fn get_imported_table_grow_index() -> Self {
+        Self(17)
+    }
+    /// Returns an index for wasm's `table.get` instruction for local tables.
+    pub const fn get_table_get_index() -> Self {
+        Self(18)
+    }
+    /// Returns an index for wasm's `table.get` instruction for imported tables.
+    pub const fn get_imported_table_get_index() -> Self {
+        Self(19)
+    }
+    /// Returns an index for wasm's `table.set` instruction for local tables.
+    pub const fn get_table_set_index() -> Self {
+        Self(20)
+    }
+    /// Returns an index for wasm's `table.set` instruction for imported tables.
+    pub const fn get_imported_table_set_index() -> Self {
+        Self(21)
+    }
+    /// Returns an index for wasm's `func.ref` instruction.
+    pub const fn get_func_ref_index() -> Self {
+        Self(22)
+    }
+    /// Returns an index for wasm's `table.fill` instruction for local tables.
+    pub const fn get_table_fill_index() -> Self {
+        Self(23)
+    }
+    /// Returns an index for wasm's local `memory.atomic.wait32` builtin function.
+    pub const fn get_memory_atomic_wait32_index() -> Self {
+        Self(24)
+    }
+    /// Returns an index for wasm's imported `memory.atomic.wait32` builtin function.
+    pub const fn get_imported_memory_atomic_wait32_index() -> Self {
+        Self(25)
+    }
+    /// Returns an index for wasm's local `memory.atomic.wait64` builtin function.
+    pub const fn get_memory_atomic_wait64_index() -> Self {
+        Self(26)
+    }
+    /// Returns an index for wasm's imported `memory.atomic.wait64` builtin function.
+    pub const fn get_imported_memory_atomic_wait64_index() -> Self {
+        Self(27)
+    }
+    /// Returns an index for wasm's local `memory.atomic.notify` builtin function.
+    pub const fn get_memory_atomic_notify_index() -> Self {
+        Self(28)
+    }
+    /// Returns an index for wasm's imported `memory.atomic.notify` builtin function.
+    pub const fn get_imported_memory_atomic_notify_index() -> Self {
+        Self(29)
+    }
+    /// Returns the total number of builtin functions.
+    pub const fn builtin_functions_total_number() -> u32 {
+        30
+    }
+
+    /// Return the index as an u32 number.
+    pub const fn index(self) -> u32 {
+        self.0
+    }
+}
+
+#[cfg(target_pointer_width = "32")]
+fn cast_to_u32(sz: usize) -> u32 {
+    u32::try_from(sz).unwrap()
+}
+#[cfg(target_pointer_width = "64")]
+fn cast_to_u32(sz: usize) -> u32 {
+    u32::try_from(sz).expect("overflow in cast from usize to u32")
+}
+
+/// Align an offset used in this module to a specific byte-width by rounding up
+#[inline]
+const fn align(offset: u32, width: u32) -> u32 {
+    (offset + (width - 1)) / width * width
+}
+
+/// This class computes offsets to fields within VMContext and other
+/// related structs that JIT code accesses directly.
+#[derive(Clone, Debug)]
+pub struct VMOffsets {
+    /// The size in bytes of a pointer on the target.
+    pointer_size: u8,
+    /// The number of signature declarations in the module.
+    num_signature_ids: u32,
+    /// The number of imported functions in the module.
+    num_imported_functions: u32,
+    /// The number of imported tables in the module.
+    num_imported_tables: u32,
+    /// The number of imported memories in the module.
+    num_imported_memories: u32,
+    /// The number of imported globals in the module.
+    num_imported_globals: u32,
+    /// The number of defined tables in the module.
+    num_local_tables: u32,
+    /// The number of defined memories in the module.
+    num_local_memories: u32,
+    /// The number of defined globals in the module.
+    num_local_globals: u32,
+
+    vmctx_signature_ids_begin: u32,
+    vmctx_imported_functions_begin: u32,
+    vmctx_imported_tables_begin: u32,
+    vmctx_imported_memories_begin: u32,
+    vmctx_imported_globals_begin: u32,
+    vmctx_tables_begin: u32,
+    vmctx_memories_begin: u32,
+    vmctx_globals_begin: u32,
+    vmctx_builtin_functions_begin: u32,
+    vmctx_trap_handler_begin: u32,
+    vmctx_gas_limiter_pointer: u32,
+    vmctx_stack_limit_begin: u32,
+    vmctx_stack_limit_initial_begin: u32,
+    size_of_vmctx: u32,
+}
+
+impl VMOffsets {
+    /// Return a new `VMOffsets` instance, for a given pointer size.
+    pub fn new(pointer_size: u8, module: &ModuleInfo) -> Self {
+        let mut ret = Self {
+            pointer_size,
+            num_signature_ids: cast_to_u32(module.signatures.len()),
+            num_imported_functions: cast_to_u32(module.num_imported_functions),
+            num_imported_tables: cast_to_u32(module.num_imported_tables),
+            num_imported_memories: cast_to_u32(module.num_imported_memories),
+            num_imported_globals: cast_to_u32(module.num_imported_globals),
+            num_local_tables: cast_to_u32(module.tables.len()),
+            num_local_memories: cast_to_u32(module.memories.len()),
+            num_local_globals: cast_to_u32(module.globals.len()),
+            vmctx_signature_ids_begin: 0,
+            vmctx_imported_functions_begin: 0,
+            vmctx_imported_tables_begin: 0,
+            vmctx_imported_memories_begin: 0,
+            vmctx_imported_globals_begin: 0,
+            vmctx_tables_begin: 0,
+            vmctx_memories_begin: 0,
+            vmctx_globals_begin: 0,
+            vmctx_builtin_functions_begin: 0,
+            vmctx_trap_handler_begin: 0,
+            vmctx_gas_limiter_pointer: 0,
+            vmctx_stack_limit_begin: 0,
+            vmctx_stack_limit_initial_begin: 0,
+            size_of_vmctx: 0,
+        };
+        ret.precompute();
+        ret
+    }
+
+    /// Return a new `VMOffsets` instance, for a given pointer size
+    /// skipping the `ModuleInfo`.
+    ///
+    /// Note: This should only when generating code for trampolines.
+    pub fn new_for_trampolines(pointer_size: u8) -> Self {
+        Self {
+            pointer_size,
+            num_signature_ids: 0,
+            num_imported_functions: 0,
+            num_imported_tables: 0,
+            num_imported_memories: 0,
+            num_imported_globals: 0,
+            num_local_tables: 0,
+            num_local_memories: 0,
+            num_local_globals: 0,
+            vmctx_signature_ids_begin: 0,
+            vmctx_imported_functions_begin: 0,
+            vmctx_imported_tables_begin: 0,
+            vmctx_imported_memories_begin: 0,
+            vmctx_imported_globals_begin: 0,
+            vmctx_tables_begin: 0,
+            vmctx_memories_begin: 0,
+            vmctx_globals_begin: 0,
+            vmctx_builtin_functions_begin: 0,
+            vmctx_trap_handler_begin: 0,
+            vmctx_gas_limiter_pointer: 0,
+            vmctx_stack_limit_begin: 0,
+            vmctx_stack_limit_initial_begin: 0,
+            size_of_vmctx: 0,
+        }
+    }
+
+    /// Number of local tables defined in the module
+    pub fn num_local_tables(&self) -> u32 {
+        self.num_local_tables
+    }
+
+    /// Number of local memories defined in the module
+    pub fn num_local_memories(&self) -> u32 {
+        self.num_local_memories
+    }
+
+    fn precompute(&mut self) {
+        /// Offset base by num_items items of size item_size, panicking on overflow
+        fn offset_by(base: u32, num_items: u32, item_size: u32) -> u32 {
+            base.checked_add(num_items.checked_mul(item_size).unwrap())
+                .unwrap()
+        }
+        /// Offset base by num_items items of size item_size, panicking on overflow
+        /// Also, will align the value on pointer size boundary,
+        /// to avoid misalignement issue
+        fn offset_by_aligned(base: u32, num_items: u32, item_size: u32) -> u32 {
+            align(
+                base.checked_add(num_items.checked_mul(item_size).unwrap())
+                    .unwrap(),
+                size_of::<&u32>() as u32,
+            )
+        }
+
+        self.vmctx_signature_ids_begin = 0;
+        self.vmctx_imported_functions_begin = offset_by_aligned(
+            self.vmctx_signature_ids_begin,
+            self.num_signature_ids,
+            u32::from(self.size_of_vmshared_signature_index()),
+        );
+        self.vmctx_imported_tables_begin = offset_by_aligned(
+            self.vmctx_imported_functions_begin,
+            self.num_imported_functions,
+            u32::from(self.size_of_vmfunction_import()),
+        );
+        self.vmctx_imported_memories_begin = offset_by_aligned(
+            self.vmctx_imported_tables_begin,
+            self.num_imported_tables,
+            u32::from(self.size_of_vmtable_import()),
+        );
+        self.vmctx_imported_globals_begin = offset_by_aligned(
+            self.vmctx_imported_memories_begin,
+            self.num_imported_memories,
+            u32::from(self.size_of_vmmemory_import()),
+        );
+        self.vmctx_tables_begin = offset_by_aligned(
+            self.vmctx_imported_globals_begin,
+            self.num_imported_globals,
+            u32::from(self.size_of_vmglobal_import()),
+        );
+        self.vmctx_memories_begin = offset_by_aligned(
+            self.vmctx_tables_begin,
+            self.num_local_tables,
+            u32::from(self.size_of_vmtable_definition()),
+        );
+        self.vmctx_globals_begin = align(
+            offset_by(
+                self.vmctx_memories_begin,
+                self.num_local_memories,
+                u32::from(self.size_of_vmmemory_definition()),
+            ),
+            16,
+        );
+        self.vmctx_builtin_functions_begin = offset_by(
+            self.vmctx_globals_begin,
+            self.num_local_globals,
+            u32::from(self.size_of_vmglobal_local()),
+        );
+        self.vmctx_trap_handler_begin = offset_by(
+            self.vmctx_builtin_functions_begin,
+            VMBuiltinFunctionIndex::builtin_functions_total_number(),
+            u32::from(self.pointer_size),
+        );
+        self.vmctx_gas_limiter_pointer = offset_by(
+            self.vmctx_trap_handler_begin,
+            1,
+            u32::from(self.pointer_size),
+        );
+        self.vmctx_stack_limit_begin = offset_by(
+            self.vmctx_gas_limiter_pointer,
+            1,
+            u32::from(self.pointer_size),
+        );
+        self.vmctx_stack_limit_initial_begin = self.vmctx_stack_limit_begin.checked_add(4).unwrap();
+        self.size_of_vmctx = self.vmctx_stack_limit_begin.checked_add(4).unwrap();
+    }
+}
+
+/// Offsets for `VMFunctionImport`.
+impl VMOffsets {
+    /// The offset of the `body` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmfunction_import_body(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `vmctx` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmfunction_import_vmctx(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// The offset of the `handle` field.
+    pub const fn vmfunction_import_handle(&self) -> u8 {
+        2 * self.pointer_size
+    }
+
+    /// Return the size of `VMFunctionImport`.
+    pub const fn size_of_vmfunction_import(&self) -> u8 {
+        3 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMDynamicFunctionContext`.
+impl VMOffsets {
+    /// The offset of the `address` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmdynamicfunction_import_context_address(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `ctx` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmdynamicfunction_import_context_ctx(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// Return the size of `VMDynamicFunctionContext`.
+    pub const fn size_of_vmdynamicfunction_import_context(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for `*const VMFunctionBody`.
+impl VMOffsets {
+    /// The size of the `current_elements` field.
+    #[allow(clippy::identity_op)]
+    pub const fn size_of_vmfunction_body_ptr(&self) -> u8 {
+        1 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMTableImport`.
+impl VMOffsets {
+    /// The offset of the `definition` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmtable_import_definition(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `handle` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmtable_import_handle(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// Return the size of `VMTableImport`.
+    pub const fn size_of_vmtable_import(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMTableDefinition`.
+impl VMOffsets {
+    /// The offset of the `base` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmtable_definition_base(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `current_elements` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmtable_definition_current_elements(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// The size of the `current_elements` field.
+    pub const fn size_of_vmtable_definition_current_elements(&self) -> u8 {
+        4
+    }
+
+    /// Return the size of `VMTableDefinition`.
+    pub const fn size_of_vmtable_definition(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMMemoryImport`.
+impl VMOffsets {
+    /// The offset of the `from` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmmemory_import_definition(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `handle` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmmemory_import_handle(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// Return the size of `VMMemoryImport`.
+    pub const fn size_of_vmmemory_import(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMMemoryDefinition`.
+impl VMOffsets {
+    /// The offset of the `base` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmmemory_definition_base(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `current_length` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmmemory_definition_current_length(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// The size of the `current_length` field.
+    pub const fn size_of_vmmemory_definition_current_length(&self) -> u8 {
+        4
+    }
+
+    /// Return the size of `VMMemoryDefinition`.
+    pub const fn size_of_vmmemory_definition(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMGlobalImport`.
+impl VMOffsets {
+    /// The offset of the `definition` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmglobal_import_definition(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `handle` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmglobal_import_handle(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// Return the size of `VMGlobalImport`.
+    #[allow(clippy::identity_op)]
+    pub const fn size_of_vmglobal_import(&self) -> u8 {
+        2 * self.pointer_size
+    }
+}
+
+/// Offsets for a non-null pointer to a `VMGlobalDefinition` used as a local global.
+impl VMOffsets {
+    /// Return the size of a pointer to a `VMGlobalDefinition`;
+    ///
+    /// The underlying global itself is the size of the largest value type (i.e. a V128),
+    /// however the size of this type is just the size of a pointer.
+    pub const fn size_of_vmglobal_local(&self) -> u8 {
+        self.pointer_size
+    }
+}
+
+/// Offsets for `VMSharedSignatureIndex`.
+impl VMOffsets {
+    /// Return the size of `VMSharedSignatureIndex`.
+    pub const fn size_of_vmshared_signature_index(&self) -> u8 {
+        4
+    }
+}
+
+/// Offsets for `VMCallerCheckedAnyfunc`.
+impl VMOffsets {
+    /// The offset of the `func_ptr` field.
+    #[allow(clippy::erasing_op)]
+    pub const fn vmcaller_checked_anyfunc_func_ptr(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// The offset of the `type_index` field.
+    #[allow(clippy::identity_op)]
+    pub const fn vmcaller_checked_anyfunc_type_index(&self) -> u8 {
+        1 * self.pointer_size
+    }
+
+    /// The offset of the `vmctx` field.
+    pub const fn vmcaller_checked_anyfunc_vmctx(&self) -> u8 {
+        2 * self.pointer_size
+    }
+
+    /// The offset of the `call_trampoline` field.
+    pub const fn vmcaller_checked_anyfunc_call_trampoline(&self) -> u8 {
+        3 * self.pointer_size
+    }
+
+    /// Return the size of `VMCallerCheckedAnyfunc`.
+    pub const fn size_of_vmcaller_checked_anyfunc(&self) -> u8 {
+        4 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMFuncRef`.
+impl VMOffsets {
+    /// The offset to the pointer to the anyfunc inside the ref.
+    #[allow(clippy::erasing_op)]
+    pub const fn vm_funcref_anyfunc_ptr(&self) -> u8 {
+        0 * self.pointer_size
+    }
+
+    /// Return the size of `VMFuncRef`.
+    #[allow(clippy::identity_op)]
+    pub const fn size_of_vm_funcref(&self) -> u8 {
+        1 * self.pointer_size
+    }
+}
+
+/// Offsets for `VMContext`.
+impl VMOffsets {
+    /// The offset of the `signature_ids` array.
+    pub fn vmctx_signature_ids_begin(&self) -> u32 {
+        self.vmctx_signature_ids_begin
+    }
+
+    /// The offset of the `tables` array.
+    #[allow(clippy::erasing_op)]
+    pub fn vmctx_imported_functions_begin(&self) -> u32 {
+        self.vmctx_imported_functions_begin
+    }
+
+    /// The offset of the `tables` array.
+    #[allow(clippy::identity_op)]
+    pub fn vmctx_imported_tables_begin(&self) -> u32 {
+        self.vmctx_imported_tables_begin
+    }
+
+    /// The offset of the `memories` array.
+    pub fn vmctx_imported_memories_begin(&self) -> u32 {
+        self.vmctx_imported_memories_begin
+    }
+
+    /// The offset of the `globals` array.
+    pub fn vmctx_imported_globals_begin(&self) -> u32 {
+        self.vmctx_imported_globals_begin
+    }
+
+    /// The offset of the `tables` array.
+    pub fn vmctx_tables_begin(&self) -> u32 {
+        self.vmctx_tables_begin
+    }
+
+    /// The offset of the `memories` array.
+    pub fn vmctx_memories_begin(&self) -> u32 {
+        self.vmctx_memories_begin
+    }
+
+    /// The offset of the `globals` array.
+    pub fn vmctx_globals_begin(&self) -> u32 {
+        self.vmctx_globals_begin
+    }
+
+    /// The offset of the builtin functions array.
+    pub fn vmctx_builtin_functions_begin(&self) -> u32 {
+        self.vmctx_builtin_functions_begin
+    }
+
+    /// Return the size of the `VMContext` allocation.
+    pub fn size_of_vmctx(&self) -> u32 {
+        self.size_of_vmctx
+    }
+
+    /// Return the offset to `VMSharedSignatureIndex` index `index`.
+    pub fn vmctx_vmshared_signature_id(&self, index: SignatureIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_signature_ids);
+        self.vmctx_signature_ids_begin
+            + index.as_u32() * u32::from(self.size_of_vmshared_signature_index())
+    }
+
+    /// Return the offset to `VMFunctionImport` index `index`.
+    pub fn vmctx_vmfunction_import(&self, index: FunctionIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_imported_functions);
+        self.vmctx_imported_functions_begin
+            + index.as_u32() * u32::from(self.size_of_vmfunction_import())
+    }
+
+    /// Return the offset to `VMTableImport` index `index`.
+    pub fn vmctx_vmtable_import(&self, index: TableIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_imported_tables);
+        self.vmctx_imported_tables_begin + index.as_u32() * u32::from(self.size_of_vmtable_import())
+    }
+
+    /// Return the offset to `VMMemoryImport` index `index`.
+    pub fn vmctx_vmmemory_import(&self, index: MemoryIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_imported_memories);
+        self.vmctx_imported_memories_begin
+            + index.as_u32() * u32::from(self.size_of_vmmemory_import())
+    }
+
+    /// Return the offset to `VMGlobalImport` index `index`.
+    pub fn vmctx_vmglobal_import(&self, index: GlobalIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_imported_globals);
+        self.vmctx_imported_globals_begin
+            + index.as_u32() * u32::from(self.size_of_vmglobal_import())
+    }
+
+    /// Return the offset to `VMTableDefinition` index `index`.
+    pub fn vmctx_vmtable_definition(&self, index: LocalTableIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_local_tables);
+        self.vmctx_tables_begin + index.as_u32() * u32::from(self.size_of_vmtable_definition())
+    }
+
+    /// Return the offset to `VMMemoryDefinition` index `index`.
+    pub fn vmctx_vmmemory_definition(&self, index: LocalMemoryIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_local_memories);
+        self.vmctx_memories_begin + index.as_u32() * u32::from(self.size_of_vmmemory_definition())
+    }
+
+    /// Return the offset to the `VMGlobalDefinition` index `index`.
+    pub fn vmctx_vmglobal_definition(&self, index: LocalGlobalIndex) -> u32 {
+        assert_lt!(index.as_u32(), self.num_local_globals);
+        self.vmctx_globals_begin + index.as_u32() * u32::from(self.size_of_vmglobal_local())
+    }
+
+    /// Return the offset to the `body` field in `*const VMFunctionBody` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmfunction_import_body(&self, index: FunctionIndex) -> u32 {
+        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_body())
+    }
+
+    /// Return the offset to the `vmctx` field in `*const VMFunctionBody` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmfunction_import_vmctx(&self, index: FunctionIndex) -> u32 {
+        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_vmctx())
+    }
+
+    /// Return the offset to the `definition` field in `VMTableImport` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmtable_import_definition(&self, index: TableIndex) -> u32 {
+        self.vmctx_vmtable_import(index) + u32::from(self.vmtable_import_definition())
+    }
+
+    /// Return the offset to the `base` field in `VMTableDefinition` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmtable_definition_base(&self, index: LocalTableIndex) -> u32 {
+        self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_base())
+    }
+
+    /// Return the offset to the `current_elements` field in `VMTableDefinition` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmtable_definition_current_elements(&self, index: LocalTableIndex) -> u32 {
+        self.vmctx_vmtable_definition(index) + u32::from(self.vmtable_definition_current_elements())
+    }
+
+    /// Return the offset to the `from` field in `VMMemoryImport` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmmemory_import_definition(&self, index: MemoryIndex) -> u32 {
+        self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_definition())
+    }
+
+    /// Return the offset to the `vmctx` field in `VMMemoryImport` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmmemory_import_handle(&self, index: MemoryIndex) -> u32 {
+        self.vmctx_vmmemory_import(index) + u32::from(self.vmmemory_import_handle())
+    }
+
+    /// Return the offset to the `base` field in `VMMemoryDefinition` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmmemory_definition_base(&self, index: LocalMemoryIndex) -> u32 {
+        self.vmctx_vmmemory_definition(index) + u32::from(self.vmmemory_definition_base())
+    }
+
+    /// Return the offset to the `current_length` field in `VMMemoryDefinition` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmmemory_definition_current_length(&self, index: LocalMemoryIndex) -> u32 {
+        self.vmctx_vmmemory_definition(index) + u32::from(self.vmmemory_definition_current_length())
+    }
+
+    /// Return the offset to the `from` field in `VMGlobalImport` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_vmglobal_import_definition(&self, index: GlobalIndex) -> u32 {
+        self.vmctx_vmglobal_import(index) + u32::from(self.vmglobal_import_definition())
+    }
+
+    /// Return the offset to builtin function in `VMBuiltinFunctionsArray` index `index`.
+    /// Remember updating precompute upon changes
+    pub fn vmctx_builtin_function(&self, index: VMBuiltinFunctionIndex) -> u32 {
+        self.vmctx_builtin_functions_begin + index.index() * u32::from(self.pointer_size)
+    }
+}
+
+/// Target specific type for shared signature index.
+#[derive(Debug, Copy, Clone)]
+pub struct TargetSharedSignatureIndex(u32);
+
+impl TargetSharedSignatureIndex {
+    /// Constructs `TargetSharedSignatureIndex`.
+    pub const fn new(value: u32) -> Self {
+        Self(value)
+    }
+
+    /// Returns index value.
+    pub const fn index(self) -> u32 {
+        self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::vmoffsets::align;
+
+    #[test]
+    fn alignment() {
+        fn is_aligned(x: u32) -> bool {
+            x % 16 == 0
+        }
+        assert!(is_aligned(align(0, 16)));
+        assert!(is_aligned(align(32, 16)));
+        assert!(is_aligned(align(33, 16)));
+        assert!(is_aligned(align(31, 16)));
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/Cargo.toml
new file mode 100644
index 0000000..c9279a1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/Cargo.toml
@@ -0,0 +1,57 @@
+[package]
+name = "virtual-fs"
+version = "0.11.2"
+description = "Wasmer Virtual FileSystem"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow = { version = "1.0.66", optional = true }
+async-trait = { version = "^0.1" }
+bytes = "1"
+derivative = "2.2.0"
+filetime = { version = "0.2.18", optional = true }
+fs_extra = { version = "1.2.0", optional = true }
+futures = { version = "0.3" }
+indexmap = "1.9.2"
+lazy_static = "1.4"
+libc = { version = "^0.2", default-features = false, optional = true }
+pin-project-lite = "0.2.9"
+replace_with = "0.1.7"
+shared-buffer = { workspace = true }
+slab = { version = "0.4" }
+thiserror = "1"
+tokio = { version = "1", features = ["io-util", "sync", "macros"], default_features = false }
+tracing = { version = "0.1" }
+typetag = { version = "0.1", optional = true }
+webc = { version = "5.0", optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
+
+[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
+getrandom = { version = "0.2" }
+
+[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
+getrandom = { version = "0.2", features = [ "js" ] }
+
+[dev-dependencies]
+pretty_assertions = "1.3.0"
+tempfile = "3.6.0"
+tracing-test = "0.2.4"
+tokio = { version = "1", features = ["io-util", "rt"], default_features = false }
+
+[features]
+default = ["host-fs", "webc-fs", "static-fs"]
+host-fs = ["libc", "fs_extra", "filetime", "tokio/fs", "tokio/io-std", "tokio/rt"]
+webc-fs = ["webc", "anyhow"]
+static-fs = ["webc", "anyhow"]
+enable-serde = ["typetag", "serde"]
+no-time = []
+# Enables memory tracking/limiting functionality for the in-memory filesystem.
+tracking = []
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_box_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_box_file.rs
new file mode 100644
index 0000000..d518c70
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_box_file.rs
@@ -0,0 +1,141 @@
+//! Used for sharing references to the same file across multiple file systems,
+//! effectively this is a symbolic link without all the complex path redirection
+
+use std::{
+    io::{self, *},
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+
+use derivative::Derivative;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct ArcBoxFile {
+    #[derivative(Debug = "ignore")]
+    inner: Arc<Mutex<Box<dyn VirtualFile + Send + Sync + 'static>>>,
+}
+
+impl ArcBoxFile {
+    pub fn new(inner: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(inner)),
+        }
+    }
+}
+
+impl AsyncSeek for ArcBoxFile {
+    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.start_seek(position)
+    }
+    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_complete(cx)
+    }
+}
+
+impl AsyncWrite for ArcBoxFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write(cx, buf)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_flush(cx)
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_shutdown(cx)
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write_vectored(cx, bufs)
+    }
+    fn is_write_vectored(&self) -> bool {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.is_write_vectored()
+    }
+}
+
+impl AsyncRead for ArcBoxFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_read(cx, buf)
+    }
+}
+
+impl VirtualFile for ArcBoxFile {
+    fn last_accessed(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_accessed()
+    }
+    fn last_modified(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_modified()
+    }
+    fn created_time(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.created_time()
+    }
+    fn size(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.size()
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_len(new_size)
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.unlink()
+    }
+    fn is_open(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.is_open()
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        let inner = self.inner.lock().unwrap();
+        inner.get_special_fd()
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_read_ready(cx)
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_write_ready(cx)
+    }
+}
+
+impl From<Box<dyn VirtualFile + Send + Sync + 'static>> for ArcBoxFile {
+    fn from(val: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        ArcBoxFile::new(val)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_file.rs
new file mode 100644
index 0000000..4e980e0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_file.rs
@@ -0,0 +1,181 @@
+//! Used for sharing references to the same file across multiple file systems,
+//! effectively this is a symbolic link without all the complex path redirection
+
+use crate::{ClonableVirtualFile, VirtualFile};
+use derivative::Derivative;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::{
+    io::{self, *},
+    sync::{Arc, Mutex},
+};
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    #[derivative(Debug = "ignore")]
+    inner: Arc<Mutex<Box<T>>>,
+}
+
+impl<T> ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    pub fn new(inner: Box<T>) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(inner)),
+        }
+    }
+}
+
+impl<T> AsyncSeek for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.start_seek(position)
+    }
+    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_complete(cx)
+    }
+}
+
+impl<T> AsyncWrite for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write(cx, buf)
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_flush(cx)
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_shutdown(cx)
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_write_vectored(cx, bufs)
+    }
+    fn is_write_vectored(&self) -> bool {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.is_write_vectored()
+    }
+}
+
+impl<T> AsyncRead for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut guard = self.inner.lock().unwrap();
+        let file = Pin::new(guard.as_mut());
+        file.poll_read(cx, buf)
+    }
+}
+
+impl<T> VirtualFile for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn last_accessed(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_accessed()
+    }
+    fn last_modified(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.last_modified()
+    }
+    fn created_time(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.created_time()
+    }
+    fn size(&self) -> u64 {
+        let inner = self.inner.lock().unwrap();
+        inner.size()
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.set_len(new_size)
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.unlink()
+    }
+    fn is_open(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.is_open()
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        let inner = self.inner.lock().unwrap();
+        inner.get_special_fd()
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_read_ready(cx)
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.lock().unwrap();
+        let inner = Pin::new(inner.as_mut());
+        inner.poll_write_ready(cx)
+    }
+}
+
+impl<T> Clone for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+{
+    fn clone(&self) -> Self {
+        ArcFile {
+            inner: self.inner.clone(),
+        }
+    }
+}
+
+impl<T> ClonableVirtualFile for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+    T: Clone,
+{
+}
+
+impl<T> Default for ArcFile<T>
+where
+    T: VirtualFile + Send + Sync + 'static,
+    T: Default,
+{
+    fn default() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(Box::default())),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_fs.rs
new file mode 100644
index 0000000..734774f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/arc_fs.rs
@@ -0,0 +1,52 @@
+//! Wraps a clonable Arc of a file system - in practice this is useful so you
+//! can pass clonable file systems with a `Box<dyn FileSystem>` to other
+//! interfaces
+
+use std::{path::Path, sync::Arc};
+
+use crate::*;
+
+#[derive(Debug)]
+pub struct ArcFileSystem {
+    fs: Arc<dyn FileSystem + Send + Sync + 'static>,
+}
+
+impl ArcFileSystem {
+    pub fn new(inner: Arc<dyn FileSystem + Send + Sync + 'static>) -> Self {
+        Self { fs: inner }
+    }
+}
+
+impl FileSystem for ArcFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        self.fs.read_dir(path)
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        self.fs.create_dir(path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        self.fs.remove_dir(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { self.fs.rename(from, to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.metadata(path)
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.symlink_metadata(path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        self.fs.remove_file(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        self.fs.new_open_options()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/buffer_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/buffer_file.rs
new file mode 100644
index 0000000..9af6681
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/buffer_file.rs
@@ -0,0 +1,103 @@
+//! Used for /dev/zero - infinitely returns zero
+//! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
+
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Debug, Default)]
+pub struct BufferFile {
+    pub(crate) data: Cursor<Vec<u8>>,
+}
+
+impl AsyncSeek for BufferFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        let data = Pin::new(&mut self.data);
+        data.start_seek(position)
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_complete(cx)
+    }
+}
+
+impl AsyncWrite for BufferFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_write(cx, buf)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_write_vectored(cx, bufs)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for BufferFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let data = Pin::new(&mut self.data);
+        data.poll_read(cx, buf)
+    }
+}
+
+impl VirtualFile for BufferFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        self.data.get_ref().len() as u64
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.data.get_mut().resize(new_size as usize, 0);
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn poll_read_ready(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let cur = self.data.stream_position().unwrap_or_default();
+        let len = self.data.seek(SeekFrom::End(0)).unwrap_or_default();
+        if cur < len {
+            Poll::Ready(Ok((len - cur) as usize))
+        } else {
+            Poll::Ready(Ok(0))
+        }
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/builder.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/builder.rs
new file mode 100644
index 0000000..f583834
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/builder.rs
@@ -0,0 +1,184 @@
+use crate::random_file::RandomFile;
+use crate::{FileSystem, VirtualFile};
+use std::path::{Path, PathBuf};
+use tracing::*;
+
+use super::ZeroFile;
+use super::{DeviceFile, NullFile};
+use crate::tmp_fs::TmpFileSystem;
+
+pub struct RootFileSystemBuilder {
+    default_root_dirs: bool,
+    default_dev_files: bool,
+    add_wasmer_command: bool,
+    stdin: Option<Box<dyn VirtualFile + Send + Sync>>,
+    stdout: Option<Box<dyn VirtualFile + Send + Sync>>,
+    stderr: Option<Box<dyn VirtualFile + Send + Sync>>,
+    tty: Option<Box<dyn VirtualFile + Send + Sync>>,
+}
+
+impl Default for RootFileSystemBuilder {
+    fn default() -> Self {
+        Self {
+            default_root_dirs: true,
+            default_dev_files: true,
+            add_wasmer_command: true,
+            stdin: None,
+            stdout: None,
+            stderr: None,
+            tty: None,
+        }
+    }
+}
+
+impl RootFileSystemBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn with_stdin(mut self, file: Box<dyn VirtualFile + Send + Sync>) -> Self {
+        self.stdin.replace(file);
+        self
+    }
+
+    pub fn with_stdout(mut self, file: Box<dyn VirtualFile + Send + Sync>) -> Self {
+        self.stdout.replace(file);
+        self
+    }
+
+    pub fn with_stderr(mut self, file: Box<dyn VirtualFile + Send + Sync>) -> Self {
+        self.stderr.replace(file);
+        self
+    }
+
+    pub fn with_tty(mut self, file: Box<dyn VirtualFile + Send + Sync>) -> Self {
+        self.tty.replace(file);
+        self
+    }
+
+    pub fn default_root_dirs(mut self, val: bool) -> Self {
+        self.default_root_dirs = val;
+        self
+    }
+
+    pub fn build(self) -> TmpFileSystem {
+        let tmp = TmpFileSystem::new();
+        if self.default_root_dirs {
+            for root_dir in &["/.app", "/.private", "/bin", "/dev", "/etc", "/tmp"] {
+                if let Err(err) = tmp.create_dir(Path::new(root_dir)) {
+                    debug!("failed to create dir [{}] - {}", root_dir, err);
+                }
+            }
+        }
+        if self.add_wasmer_command {
+            let _ = tmp
+                .new_open_options_ext()
+                .insert_device_file(PathBuf::from("/bin/wasmer"), Box::<NullFile>::default());
+        }
+        if self.default_dev_files {
+            let _ = tmp
+                .new_open_options_ext()
+                .insert_device_file(PathBuf::from("/dev/null"), Box::<NullFile>::default());
+            let _ = tmp
+                .new_open_options_ext()
+                .insert_device_file(PathBuf::from("/dev/zero"), Box::<ZeroFile>::default());
+            let _ = tmp
+                .new_open_options_ext()
+                .insert_device_file(PathBuf::from("/dev/urandom"), Box::<RandomFile>::default());
+            let _ = tmp.new_open_options_ext().insert_device_file(
+                PathBuf::from("/dev/stdin"),
+                self.stdin
+                    .unwrap_or_else(|| Box::new(DeviceFile::new(DeviceFile::STDIN))),
+            );
+            let _ = tmp.new_open_options_ext().insert_device_file(
+                PathBuf::from("/dev/stdout"),
+                self.stdout
+                    .unwrap_or_else(|| Box::new(DeviceFile::new(DeviceFile::STDOUT))),
+            );
+            let _ = tmp.new_open_options_ext().insert_device_file(
+                PathBuf::from("/dev/stderr"),
+                self.stderr
+                    .unwrap_or_else(|| Box::new(DeviceFile::new(DeviceFile::STDERR))),
+            );
+            let _ = tmp.new_open_options_ext().insert_device_file(
+                PathBuf::from("/dev/tty"),
+                self.tty.unwrap_or_else(|| Box::<NullFile>::default()),
+            );
+        }
+        tmp
+    }
+}
+
+#[cfg(test)]
+mod test_builder {
+    use crate::{FileSystem, RootFileSystemBuilder};
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[tokio::test]
+    async fn test_root_file_system() {
+        let root_fs = RootFileSystemBuilder::new().build();
+        let mut dev_null = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/null")
+            .unwrap();
+        assert_eq!(dev_null.write(b"hello").await.unwrap(), 5);
+        let mut buf = Vec::new();
+        dev_null.read_to_end(&mut buf).await.unwrap();
+        assert!(buf.is_empty());
+        assert!(dev_null.get_special_fd().is_none());
+
+        let mut dev_zero = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/zero")
+            .unwrap();
+        assert_eq!(dev_zero.write(b"hello").await.unwrap(), 5);
+        let mut buf = vec![1; 10];
+        dev_zero.read_exact(&mut buf[..]).await.unwrap();
+        assert_eq!(buf, vec![0; 10]);
+        assert!(dev_zero.get_special_fd().is_none());
+
+        let mut dev_tty = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/tty")
+            .unwrap();
+        assert_eq!(dev_tty.write(b"hello").await.unwrap(), 5);
+        let mut buf = Vec::new();
+        dev_tty.read_to_end(&mut buf).await.unwrap();
+        assert!(buf.is_empty());
+        assert!(dev_tty.get_special_fd().is_none());
+
+        root_fs
+            .new_open_options()
+            .read(true)
+            .open("/bin/wasmer")
+            .unwrap();
+
+        let dev_stdin = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/stdin")
+            .unwrap();
+        assert_eq!(dev_stdin.get_special_fd().unwrap(), 0);
+        let dev_stdout = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/stdout")
+            .unwrap();
+        assert_eq!(dev_stdout.get_special_fd().unwrap(), 1);
+        let dev_stderr = root_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .open("/dev/stderr")
+            .unwrap();
+        assert_eq!(dev_stderr.get_special_fd().unwrap(), 2);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/combine_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/combine_file.rs
new file mode 100644
index 0000000..f3db42c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/combine_file.rs
@@ -0,0 +1,100 @@
+use derivative::Derivative;
+
+use super::*;
+
+use crate::VirtualFile;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct CombineFile {
+    tx: Box<dyn VirtualFile + Send + Sync + 'static>,
+    rx: Box<dyn VirtualFile + Send + Sync + 'static>,
+}
+
+impl CombineFile {
+    pub fn new(
+        tx: Box<dyn VirtualFile + Send + Sync + 'static>,
+        rx: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> Self {
+        Self { tx, rx }
+    }
+}
+
+impl VirtualFile for CombineFile {
+    fn last_accessed(&self) -> u64 {
+        self.rx.last_accessed()
+    }
+
+    fn last_modified(&self) -> u64 {
+        self.tx.last_modified()
+    }
+
+    fn created_time(&self) -> u64 {
+        self.tx.created_time()
+    }
+
+    fn size(&self) -> u64 {
+        self.rx.size()
+    }
+
+    fn set_len(&mut self, new_size: u64) -> Result<()> {
+        self.tx.set_len(new_size)
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        self.tx.unlink()
+    }
+
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.rx.as_mut()).poll_read_ready(cx)
+    }
+
+    fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.tx.as_mut()).poll_write_ready(cx)
+    }
+}
+
+impl AsyncWrite for CombineFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        Pin::new(&mut self.tx).poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.tx).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.tx).poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for CombineFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.rx).poll_read(cx, buf)
+    }
+}
+
+impl AsyncSeek for CombineFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        Pin::new(&mut self.tx).start_seek(position)?;
+        Pin::new(&mut self.rx).start_seek(position)
+    }
+
+    fn poll_complete(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<u64>> {
+        if Pin::new(&mut self.tx).poll_complete(cx).is_pending() {
+            return Poll::Pending;
+        }
+        Pin::new(&mut self.rx).poll_complete(cx)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/cow_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/cow_file.rs
new file mode 100644
index 0000000..4030981
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/cow_file.rs
@@ -0,0 +1,228 @@
+//! Used for /dev/zero - infinitely returns zero
+//! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
+
+use replace_with::replace_with_or_abort;
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+
+use crate::{BufferFile, VirtualFile};
+
+#[derive(Debug)]
+enum CowState {
+    ReadOnly(Box<dyn VirtualFile + Send + Sync>),
+    Copying {
+        pos: u64,
+        inner: Box<dyn VirtualFile + Send + Sync>,
+    },
+    Copied,
+}
+impl CowState {
+    fn as_ref(&self) -> Option<&(dyn VirtualFile + Send + Sync)> {
+        match self {
+            Self::ReadOnly(inner) => Some(inner.as_ref()),
+            Self::Copying { inner, .. } => Some(inner.as_ref()),
+            _ => None,
+        }
+    }
+    fn as_mut(&mut self) -> Option<&mut Box<dyn VirtualFile + Send + Sync>> {
+        match self {
+            Self::ReadOnly(inner) => Some(inner),
+            Self::Copying { inner, .. } => Some(inner),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CopyOnWriteFile {
+    last_accessed: u64,
+    last_modified: u64,
+    created_time: u64,
+    state: CowState,
+    buf: BufferFile,
+}
+
+impl CopyOnWriteFile {
+    pub fn new(inner: Box<dyn VirtualFile + Send + Sync>) -> Self {
+        Self {
+            last_accessed: inner.last_accessed(),
+            last_modified: inner.last_modified(),
+            created_time: inner.created_time(),
+            state: CowState::ReadOnly(inner),
+            buf: BufferFile::default(),
+        }
+    }
+    fn poll_copy_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+        if let CowState::Copying { ref mut inner, pos } = &mut self.state {
+            let mut temp = [0u8; 8192];
+
+            while *pos < inner.size() {
+                let mut read_temp = ReadBuf::new(&mut temp);
+
+                if let Err(err) = Pin::new(inner.as_mut()).start_seek(SeekFrom::Start(*pos)) {
+                    return Poll::Ready(Err(err));
+                }
+                match Pin::new(inner.as_mut()).poll_complete(cx).map_ok(|_| ()) {
+                    Poll::Ready(Ok(())) => {}
+                    p => return p,
+                }
+                match Pin::new(inner.as_mut()).poll_read(cx, &mut read_temp) {
+                    Poll::Pending => return Poll::Pending,
+                    Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                    Poll::Ready(Ok(())) => {}
+                }
+                if read_temp.remaining() == 0 {
+                    return Poll::Pending;
+                }
+                *pos += read_temp.remaining() as u64;
+
+                self.buf.data.write_all(read_temp.filled()).unwrap();
+            }
+            self.state = CowState::Copied;
+        }
+        Poll::Ready(Ok(()))
+    }
+    fn poll_copy_start_and_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+        replace_with_or_abort(&mut self.state, |state| match state {
+            CowState::ReadOnly(inner) => CowState::Copying { pos: 0, inner },
+            state => state,
+        });
+        self.poll_copy_progress(cx)
+    }
+}
+
+impl AsyncSeek for CopyOnWriteFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        let data = Pin::new(&mut self.buf);
+        data.start_seek(position)?;
+
+        if let Some(inner) = self.state.as_mut() {
+            Pin::new(inner.as_mut()).start_seek(position)?;
+        }
+
+        Ok(())
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        match self.state.as_mut() {
+            Some(inner) => Pin::new(inner.as_mut()).poll_complete(cx),
+            None => {
+                let data = Pin::new(&mut self.buf);
+                data.poll_complete(cx)
+            }
+        }
+    }
+}
+
+impl AsyncWrite for CopyOnWriteFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        match self.poll_copy_start_and_progress(cx) {
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+            Poll::Ready(Ok(())) => {}
+        }
+        let data = Pin::new(&mut self.buf);
+        data.poll_write(cx, buf)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        match self.poll_copy_start_and_progress(cx) {
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+            Poll::Ready(Ok(())) => {}
+        }
+        let data = Pin::new(&mut self.buf);
+        data.poll_write_vectored(cx, bufs)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        match self.poll_copy_start_and_progress(cx) {
+            Poll::Ready(Ok(())) => {}
+            p => return p,
+        }
+        let data = Pin::new(&mut self.buf);
+        data.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        match self.poll_copy_start_and_progress(cx) {
+            Poll::Ready(Ok(())) => {}
+            p => return p,
+        }
+        let data = Pin::new(&mut self.buf);
+        data.poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for CopyOnWriteFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        match self.poll_copy_progress(cx) {
+            Poll::Ready(Ok(())) => {}
+            p => return p,
+        }
+        match self.state.as_mut() {
+            Some(inner) => Pin::new(inner.as_mut()).poll_read(cx, buf),
+            None => {
+                let data = Pin::new(&mut self.buf);
+                data.poll_read(cx, buf)
+            }
+        }
+    }
+}
+
+impl VirtualFile for CopyOnWriteFile {
+    fn last_accessed(&self) -> u64 {
+        self.last_accessed
+    }
+    fn last_modified(&self) -> u64 {
+        self.last_modified
+    }
+    fn created_time(&self) -> u64 {
+        self.created_time
+    }
+    fn size(&self) -> u64 {
+        match self.state.as_ref() {
+            Some(inner) => inner.size(),
+            None => self.buf.size(),
+        }
+    }
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.buf.set_len(new_size)
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        self.buf.set_len(0)
+    }
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        match self.poll_copy_progress(cx) {
+            Poll::Pending => return Poll::Pending,
+            Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+            Poll::Ready(Ok(())) => {}
+        }
+        match self.state.as_mut() {
+            Some(inner) => Pin::new(inner.as_mut()).poll_read_ready(cx),
+            None => {
+                let data: Pin<&mut BufferFile> = Pin::new(&mut self.buf);
+                data.poll_read_ready(cx)
+            }
+        }
+    }
+
+    fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        self.poll_copy_progress(cx).map_ok(|_| 8192)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/dual_write_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/dual_write_file.rs
new file mode 100644
index 0000000..ef27a3f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/dual_write_file.rs
@@ -0,0 +1,112 @@
+use derivative::Derivative;
+
+use super::*;
+
+use crate::VirtualFile;
+
+/// Wraps a [`VirtualFile`], and also invokes a provided function for each write.
+///
+/// Useful for debugging.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct DualWriteFile {
+    inner: Box<dyn VirtualFile + Send + Sync + 'static>,
+    #[derivative(Debug = "ignore")]
+    #[allow(clippy::type_complexity)]
+    extra_write: Box<dyn FnMut(&[u8]) + Send + Sync + 'static>,
+}
+
+impl DualWriteFile {
+    pub fn new(
+        inner: Box<dyn VirtualFile + Send + Sync + 'static>,
+        funct: impl FnMut(&[u8]) + Send + Sync + 'static,
+    ) -> Self {
+        Self {
+            inner,
+            extra_write: Box::new(funct),
+        }
+    }
+}
+
+impl VirtualFile for DualWriteFile {
+    fn last_accessed(&self) -> u64 {
+        self.inner.last_accessed()
+    }
+
+    fn last_modified(&self) -> u64 {
+        self.inner.last_modified()
+    }
+
+    fn created_time(&self) -> u64 {
+        self.inner.created_time()
+    }
+
+    fn size(&self) -> u64 {
+        self.inner.size()
+    }
+
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.inner.set_len(new_size)
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        self.inner.unlink()
+    }
+
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.inner.as_mut()).poll_read_ready(cx)
+    }
+
+    fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Pin::new(self.inner.as_mut()).poll_write_ready(cx)
+    }
+}
+
+impl AsyncWrite for DualWriteFile {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        match Pin::new(&mut self.inner).poll_write(cx, buf) {
+            Poll::Ready(Ok(amt)) => {
+                if amt > 0 {
+                    (self.extra_write)(&buf[..amt]);
+                }
+                Poll::Ready(Ok(amt))
+            }
+            res => res,
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
+
+impl AsyncRead for DualWriteFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.inner).poll_read(cx, buf)
+    }
+}
+
+impl AsyncSeek for DualWriteFile {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        Pin::new(&mut self.inner).start_seek(position)
+    }
+
+    fn poll_complete(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<u64>> {
+        Pin::new(&mut self.inner).poll_complete(cx)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/empty_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/empty_fs.rs
new file mode 100644
index 0000000..ce5be69
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/empty_fs.rs
@@ -0,0 +1,77 @@
+//! When no file system is used by a WebC then this is used as a placeholder -
+//! as the name suggests it always returns file not found.
+
+use std::path::Path;
+#[allow(unused_imports, dead_code)]
+use tracing::{debug, error, info, trace, warn};
+
+use crate::*;
+
+#[derive(Debug, Default)]
+pub struct EmptyFileSystem {}
+
+#[allow(unused_variables)]
+impl FileSystem for EmptyFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        // Special-case the root path by returning an empty iterator.
+        // An empty file system should still be readable, just not contain
+        // any entries.
+        if path == Path::new("/") {
+            Ok(ReadDir::new(Vec::new()))
+        } else {
+            Err(FsError::EntryNotFound)
+        }
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { Err(FsError::EntryNotFound) })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        // Special-case the root path by returning an stub value.
+        // An empty file system should still be readable, just not contain
+        // any entries.
+        if path == Path::new("/") {
+            Ok(Metadata {
+                ft: FileType::new_dir(),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            Err(FsError::EntryNotFound)
+        }
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        Err(FsError::EntryNotFound)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+}
+
+impl FileOpener for EmptyFileSystem {
+    #[allow(unused_variables)]
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        Err(FsError::EntryNotFound)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/filesystems.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/filesystems.rs
new file mode 100644
index 0000000..46682a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/filesystems.rs
@@ -0,0 +1,106 @@
+use crate::FileSystem;
+
+/// A chain of one or more [`FileSystem`]s.
+pub trait FileSystems<'a>: 'a {
+    // FIXME(Michael-F-Bryan): Rewrite this to use GATs when we bump the MSRV to
+    // 1.65 or higher. That'll get rid of all the lifetimes and HRTBs.
+    type Iter: IntoIterator<Item = &'a (dyn FileSystem + Send)> + Send + 'a;
+
+    /// Get something that can be used to iterate over the underlying
+    /// filesystems.
+    fn filesystems(&'a self) -> Self::Iter;
+}
+
+impl<'a, 'b, S> FileSystems<'a> for &'b S
+where
+    S: FileSystems<'a> + 'b,
+    'b: 'a,
+{
+    type Iter = S::Iter;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        (**self).filesystems()
+    }
+}
+
+impl<'a, T> FileSystems<'a> for Vec<T>
+where
+    T: FileSystem + Send,
+{
+    type Iter = <[T] as FileSystems<'a>>::Iter;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        self[..].filesystems()
+    }
+}
+
+impl<'a, T, const N: usize> FileSystems<'a> for [T; N]
+where
+    T: FileSystem + Send,
+{
+    type Iter = [&'a (dyn FileSystem + Send); N];
+
+    fn filesystems(&'a self) -> Self::Iter {
+        // TODO: rewrite this when array::each_ref() is stable
+        let mut i = 0;
+        [(); N].map(|_| {
+            let f = &self[i] as &(dyn FileSystem + Send);
+            i += 1;
+            f
+        })
+    }
+}
+
+impl<'a, T> FileSystems<'a> for [T]
+where
+    T: FileSystem + Send,
+{
+    type Iter = std::iter::Map<std::slice::Iter<'a, T>, fn(&T) -> &(dyn FileSystem + Send)>;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        self.iter().map(|fs| fs as &(dyn FileSystem + Send))
+    }
+}
+
+impl<'a> FileSystems<'a> for () {
+    type Iter = std::iter::Empty<&'a (dyn FileSystem + Send)>;
+
+    fn filesystems(&'a self) -> Self::Iter {
+        std::iter::empty()
+    }
+}
+
+macro_rules! count {
+    ($first:tt $($rest:tt)*) => {
+        1 + count!($($rest)*)
+    };
+    () => { 0 };
+}
+
+macro_rules! tuple_filesystems {
+    ($first:ident $(, $rest:ident)* $(,)?) => {
+        impl<'a, $first, $( $rest ),*> FileSystems<'a> for ($first, $($rest),*)
+        where
+            $first: FileSystem,
+            $($rest: FileSystem),*
+        {
+            type Iter = [&'a (dyn FileSystem + Send); count!($first $($rest)*)];
+
+            fn filesystems(&'a self) -> Self::Iter {
+                #[allow(non_snake_case)]
+                let ($first, $($rest),*) = self;
+
+                [
+                    $first as &(dyn FileSystem + Send),
+                    $($rest),*
+                ]
+            }
+
+        }
+
+        tuple_filesystems!($($rest),*);
+    };
+    () => {};
+}
+
+tuple_filesystems!(F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16,);
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/host_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/host_fs.rs
new file mode 100644
index 0000000..bac84f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/host_fs.rs
@@ -0,0 +1,1461 @@
+use crate::{
+    DirEntry, FileType, FsError, Metadata, OpenOptions, OpenOptionsConfig, ReadDir, Result,
+    VirtualFile,
+};
+use bytes::{Buf, Bytes};
+use futures::future::BoxFuture;
+#[cfg(feature = "enable-serde")]
+use serde::{de, Deserialize, Serialize};
+use std::convert::TryInto;
+use std::fs;
+use std::io::{self, Seek};
+use std::path::{Path, PathBuf};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use std::time::{SystemTime, UNIX_EPOCH};
+use tokio::fs as tfs;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+use tokio::runtime::Handle;
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct FileSystem {
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
+    handle: Handle,
+}
+#[allow(dead_code)]
+fn default_handle() -> Handle {
+    Handle::current()
+}
+
+impl Default for FileSystem {
+    fn default() -> Self {
+        Self {
+            handle: Handle::current(),
+        }
+    }
+}
+impl FileSystem {
+    pub fn new(handle: Handle) -> Self {
+        FileSystem { handle }
+    }
+}
+
+impl FileSystem {
+    pub fn canonicalize(&self, path: &Path) -> Result<PathBuf> {
+        if !path.exists() {
+            return Err(FsError::InvalidInput);
+        }
+        fs::canonicalize(path).map_err(Into::into)
+    }
+}
+
+impl crate::FileSystem for FileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        let read_dir = fs::read_dir(path)?;
+        let mut data = read_dir
+            .map(|entry| {
+                let entry = entry?;
+                let metadata = entry.metadata()?;
+                Ok(DirEntry {
+                    path: entry.path(),
+                    metadata: Ok(metadata.try_into()?),
+                })
+            })
+            .collect::<std::result::Result<Vec<DirEntry>, io::Error>>()
+            .map_err::<FsError, _>(Into::into)?;
+        data.sort_by(|a, b| a.path.file_name().cmp(&b.path.file_name()));
+        Ok(ReadDir::new(data))
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        if path.parent().is_none() {
+            return Err(FsError::BaseNotDirectory);
+        }
+        fs::create_dir(path).map_err(Into::into)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        if path.parent().is_none() {
+            return Err(FsError::BaseNotDirectory);
+        }
+        // https://github.com/rust-lang/rust/issues/86442
+        // DirectoryNotEmpty is not implemented consistently
+        if path.is_dir() && self.read_dir(path).map(|s| !s.is_empty()).unwrap_or(false) {
+            return Err(FsError::DirectoryNotEmpty);
+        }
+        fs::remove_dir(path).map_err(Into::into)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        Box::pin(async move {
+            use filetime::{set_file_mtime, FileTime};
+            if from.parent().is_none() {
+                return Err(FsError::BaseNotDirectory);
+            }
+            if to.parent().is_none() {
+                return Err(FsError::BaseNotDirectory);
+            }
+            if !from.exists() {
+                return Err(FsError::EntryNotFound);
+            }
+            let from_parent = from.parent().unwrap();
+            let to_parent = to.parent().unwrap();
+            if !from_parent.exists() {
+                return Err(FsError::EntryNotFound);
+            }
+            if !to_parent.exists() {
+                return Err(FsError::EntryNotFound);
+            }
+            let result = if from_parent != to_parent {
+                let _ = std::fs::create_dir_all(to_parent);
+                if from.is_dir() {
+                    fs_extra::move_items(
+                        &[&from],
+                        &to,
+                        &fs_extra::dir::CopyOptions {
+                            copy_inside: true,
+                            ..Default::default()
+                        },
+                    )
+                    .map(|_| ())
+                    .map_err(|_| FsError::UnknownError)?;
+                    let _ = fs_extra::remove_items(&[&from]);
+                    Ok(())
+                } else {
+                    fs::copy(&from, &to).map(|_| ()).map_err(FsError::from)?;
+                    fs::remove_file(&from).map(|_| ()).map_err(Into::into)
+                }
+            } else {
+                fs::rename(&from, &to).map_err(Into::into)
+            };
+            let _ = set_file_mtime(&to, FileTime::now()).map(|_| ());
+            result
+        })
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        if path.parent().is_none() {
+            return Err(FsError::BaseNotDirectory);
+        }
+        fs::remove_file(path).map_err(Into::into)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        fs::metadata(path)
+            .and_then(TryInto::try_into)
+            .map_err(Into::into)
+    }
+}
+
+impl TryInto<Metadata> for std::fs::Metadata {
+    type Error = io::Error;
+
+    fn try_into(self) -> std::result::Result<Metadata, Self::Error> {
+        let filetype = self.file_type();
+        let (char_device, block_device, socket, fifo) = {
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::FileTypeExt;
+                (
+                    filetype.is_char_device(),
+                    filetype.is_block_device(),
+                    filetype.is_socket(),
+                    filetype.is_fifo(),
+                )
+            }
+            #[cfg(not(unix))]
+            {
+                (false, false, false, false)
+            }
+        };
+
+        Ok(Metadata {
+            ft: FileType {
+                dir: filetype.is_dir(),
+                file: filetype.is_file(),
+                symlink: filetype.is_symlink(),
+                char_device,
+                block_device,
+                socket,
+                fifo,
+            },
+            accessed: self
+                .accessed()
+                .and_then(|time| {
+                    time.duration_since(UNIX_EPOCH)
+                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+                })
+                .map_or(0, |time| time.as_nanos() as u64),
+            created: self
+                .created()
+                .and_then(|time| {
+                    time.duration_since(UNIX_EPOCH)
+                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+                })
+                .map_or(0, |time| time.as_nanos() as u64),
+            modified: self
+                .modified()
+                .and_then(|time| {
+                    time.duration_since(UNIX_EPOCH)
+                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+                })
+                .map_or(0, |time| time.as_nanos() as u64),
+            len: self.len(),
+        })
+    }
+}
+
+impl crate::FileOpener for FileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        // TODO: handle create implying write, etc.
+        let read = conf.read();
+        let write = conf.write();
+
+        // according to Rust's stdlib, specifying both truncate and append is nonsensical,
+        // and it will return an error if we try to open a file with both flags set.
+        // in order to prevent this, and stay compatible with native binaries, we just ignore
+        // the append flag if truncate is set. the rationale behind this decision is that
+        // truncate is going to be applied first and append is going to be ignored anyway.
+        let append = if conf.truncate { false } else { conf.append() };
+
+        let mut oo = fs::OpenOptions::new();
+        oo.read(conf.read())
+            .write(conf.write())
+            .create_new(conf.create_new())
+            .create(conf.create())
+            .append(append)
+            .truncate(conf.truncate())
+            .open(path)
+            .map_err(Into::into)
+            .map(|file| {
+                Box::new(File::new(
+                    self.handle.clone(),
+                    file,
+                    path.to_owned(),
+                    read,
+                    write,
+                    append,
+                )) as Box<dyn VirtualFile + Send + Sync + 'static>
+            })
+    }
+}
+
+/// A thin wrapper around `std::fs::File`
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize))]
+pub struct File {
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
+    handle: Handle,
+    #[cfg_attr(feature = "enable-serde", serde(skip_serializing))]
+    inner_std: fs::File,
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    inner: tfs::File,
+    pub host_path: PathBuf,
+    #[cfg(feature = "enable-serde")]
+    flags: u16,
+}
+
+#[cfg(feature = "enable-serde")]
+impl<'de> Deserialize<'de> for File {
+    fn deserialize<D>(deserializer: D) -> std::result::Result<File, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(field_identifier, rename_all = "snake_case")]
+        enum Field {
+            HostPath,
+            Flags,
+        }
+
+        struct FileVisitor;
+
+        impl<'de> de::Visitor<'de> for FileVisitor {
+            type Value = File;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("struct File")
+            }
+
+            fn visit_seq<V>(self, mut seq: V) -> std::result::Result<Self::Value, V::Error>
+            where
+                V: de::SeqAccess<'de>,
+            {
+                let host_path = seq
+                    .next_element()?
+                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
+                let flags = seq
+                    .next_element()?
+                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
+                let inner = fs::OpenOptions::new()
+                    .read(flags & File::READ != 0)
+                    .write(flags & File::WRITE != 0)
+                    .append(flags & File::APPEND != 0)
+                    .open(&host_path)
+                    .map_err(|_| de::Error::custom("Could not open file on this system"))?;
+                Ok(File {
+                    handle: Handle::current(),
+                    inner: tokio::fs::File::from_std(inner.try_clone().unwrap()),
+                    inner_std: inner,
+                    host_path,
+                    flags,
+                })
+            }
+
+            fn visit_map<V>(self, mut map: V) -> std::result::Result<Self::Value, V::Error>
+            where
+                V: de::MapAccess<'de>,
+            {
+                let mut host_path = None;
+                let mut flags = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::HostPath => {
+                            if host_path.is_some() {
+                                return Err(de::Error::duplicate_field("host_path"));
+                            }
+                            host_path = Some(map.next_value()?);
+                        }
+                        Field::Flags => {
+                            if flags.is_some() {
+                                return Err(de::Error::duplicate_field("flags"));
+                            }
+                            flags = Some(map.next_value()?);
+                        }
+                    }
+                }
+                let host_path = host_path.ok_or_else(|| de::Error::missing_field("host_path"))?;
+                let flags = flags.ok_or_else(|| de::Error::missing_field("flags"))?;
+                let inner = fs::OpenOptions::new()
+                    .read(flags & File::READ != 0)
+                    .write(flags & File::WRITE != 0)
+                    .append(flags & File::APPEND != 0)
+                    .open(&host_path)
+                    .map_err(|_| de::Error::custom("Could not open file on this system"))?;
+                Ok(File {
+                    handle: Handle::current(),
+                    inner: tokio::fs::File::from_std(inner.try_clone().unwrap()),
+                    inner_std: inner,
+                    host_path,
+                    flags,
+                })
+            }
+        }
+
+        const FIELDS: &[&str] = &["host_path", "flags"];
+        deserializer.deserialize_struct("File", FIELDS, FileVisitor)
+    }
+}
+
+impl File {
+    const READ: u16 = 1;
+    const WRITE: u16 = 2;
+    const APPEND: u16 = 4;
+
+    /// creates a new host file from a `std::fs::File` and a path
+    pub fn new(
+        handle: Handle,
+        file: fs::File,
+        host_path: PathBuf,
+        read: bool,
+        write: bool,
+        append: bool,
+    ) -> Self {
+        let mut _flags = 0;
+
+        if read {
+            _flags |= Self::READ;
+        }
+
+        if write {
+            _flags |= Self::WRITE;
+        }
+
+        if append {
+            _flags |= Self::APPEND;
+        }
+
+        let async_file = tfs::File::from_std(file.try_clone().unwrap());
+        Self {
+            handle,
+            inner_std: file,
+            inner: async_file,
+            host_path,
+            #[cfg(feature = "enable-serde")]
+            flags: _flags,
+        }
+    }
+
+    fn metadata(&self) -> std::fs::Metadata {
+        // FIXME: no unwrap!
+        self.inner_std.metadata().unwrap()
+    }
+}
+
+//#[cfg_attr(feature = "enable-serde", typetag::serde)]
+#[async_trait::async_trait]
+impl VirtualFile for File {
+    fn last_accessed(&self) -> u64 {
+        self.metadata()
+            .accessed()
+            .ok()
+            .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok())
+            .map(|ct| ct.as_nanos() as u64)
+            .unwrap_or(0)
+    }
+
+    fn last_modified(&self) -> u64 {
+        self.metadata()
+            .modified()
+            .ok()
+            .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok())
+            .map(|ct| ct.as_nanos() as u64)
+            .unwrap_or(0)
+    }
+
+    fn created_time(&self) -> u64 {
+        self.metadata()
+            .created()
+            .ok()
+            .and_then(|ct| ct.duration_since(SystemTime::UNIX_EPOCH).ok())
+            .map(|ct| ct.as_nanos() as u64)
+            .unwrap_or(0)
+    }
+
+    fn size(&self) -> u64 {
+        self.metadata().len()
+    }
+
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        fs::File::set_len(&self.inner_std, new_size).map_err(Into::into)
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        fs::remove_file(&self.host_path).map_err(Into::into)
+    }
+
+    fn get_special_fd(&self) -> Option<u32> {
+        None
+    }
+
+    fn poll_read_ready(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let cursor = match self.inner_std.stream_position() {
+            Ok(a) => a,
+            Err(err) => return Poll::Ready(Err(err)),
+        };
+        let end = match self.inner_std.seek(io::SeekFrom::End(0)) {
+            Ok(a) => a,
+            Err(err) => return Poll::Ready(Err(err)),
+        };
+        let _ = self.inner_std.seek(io::SeekFrom::Start(cursor));
+
+        let remaining = end - cursor;
+        Poll::Ready(Ok(remaining as usize))
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}
+
+impl AsyncRead for File {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for File {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+}
+
+impl AsyncSeek for File {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.start_seek(position)
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_complete(cx)
+    }
+}
+
+/// A wrapper type around Stdout that implements `VirtualFile`.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Stdout {
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
+    handle: Handle,
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_stdout"))]
+    inner: tokio::io::Stdout,
+}
+#[allow(dead_code)]
+fn default_stdout() -> tokio::io::Stdout {
+    tokio::io::stdout()
+}
+impl Default for Stdout {
+    fn default() -> Self {
+        Self {
+            handle: Handle::current(),
+            inner: tokio::io::stdout(),
+        }
+    }
+}
+
+/// Default size for write buffers.
+///
+/// Chosen to be both sufficiently large, and a multiple of the default page
+/// size on most systems.
+///
+/// This value has limited meaning, since it is only used for buffer size hints,
+/// and those hints are often ignored.
+const DEFAULT_BUF_SIZE_HINT: usize = 8 * 1024;
+
+//#[cfg_attr(feature = "enable-serde", typetag::serde)]
+#[async_trait::async_trait]
+impl VirtualFile for Stdout {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+
+    fn last_modified(&self) -> u64 {
+        0
+    }
+
+    fn created_time(&self) -> u64 {
+        0
+    }
+
+    fn size(&self) -> u64 {
+        0
+    }
+
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        Ok(())
+    }
+
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(1)
+    }
+
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(DEFAULT_BUF_SIZE_HINT))
+    }
+}
+
+impl AsyncRead for Stdout {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not read from stdout",
+        )))
+    }
+}
+
+impl AsyncWrite for Stdout {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+}
+
+impl AsyncSeek for Stdout {
+    fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+        Err(io::Error::new(io::ErrorKind::Other, "can not seek stdout"))
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not seek stdout",
+        )))
+    }
+}
+
+/// A wrapper type around Stderr that implements `VirtualFile`.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Stderr {
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
+    handle: Handle,
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_stderr"))]
+    inner: tokio::io::Stderr,
+}
+#[allow(dead_code)]
+fn default_stderr() -> tokio::io::Stderr {
+    tokio::io::stderr()
+}
+impl Default for Stderr {
+    fn default() -> Self {
+        Self {
+            handle: Handle::current(),
+            inner: tokio::io::stderr(),
+        }
+    }
+}
+
+impl AsyncRead for Stderr {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not read from stderr",
+        )))
+    }
+}
+
+impl AsyncWrite for Stderr {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_write_vectored(cx, bufs)
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        self.inner.is_write_vectored()
+    }
+}
+
+impl AsyncSeek for Stderr {
+    fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+        Err(io::Error::new(io::ErrorKind::Other, "can not seek stderr"))
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not seek stderr",
+        )))
+    }
+}
+
+//#[cfg_attr(feature = "enable-serde", typetag::serde)]
+#[async_trait::async_trait]
+impl VirtualFile for Stderr {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+
+    fn last_modified(&self) -> u64 {
+        0
+    }
+
+    fn created_time(&self) -> u64 {
+        0
+    }
+
+    fn size(&self) -> u64 {
+        0
+    }
+
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        Ok(())
+    }
+
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(2)
+    }
+
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}
+
+/// A wrapper type around Stdin that implements `VirtualFile`.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Stdin {
+    read_buffer: Arc<std::sync::Mutex<Option<Bytes>>>,
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_handle"))]
+    handle: Handle,
+    #[cfg_attr(feature = "enable-serde", serde(skip, default = "default_stdin"))]
+    inner: tokio::io::Stdin,
+}
+#[allow(dead_code)]
+fn default_stdin() -> tokio::io::Stdin {
+    tokio::io::stdin()
+}
+impl Default for Stdin {
+    fn default() -> Self {
+        Self {
+            handle: Handle::current(),
+            read_buffer: Arc::new(std::sync::Mutex::new(None)),
+            inner: tokio::io::stdin(),
+        }
+    }
+}
+
+impl AsyncRead for Stdin {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let max_size = buf.remaining();
+        {
+            let mut read_buffer = self.read_buffer.lock().unwrap();
+            if let Some(read_buffer) = read_buffer.as_mut() {
+                let buf_len = read_buffer.len();
+                if buf_len > 0 {
+                    let read = buf_len.min(max_size);
+                    buf.put_slice(&read_buffer[..read]);
+                    read_buffer.advance(read);
+                    return Poll::Ready(Ok(()));
+                }
+            }
+        }
+
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+        inner.poll_read(cx, buf)
+    }
+}
+
+impl AsyncWrite for Stdin {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not wrote to stdin",
+        )))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not flush stdin",
+        )))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not wrote to stdin",
+        )))
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not wrote to stdin",
+        )))
+    }
+}
+
+impl AsyncSeek for Stdin {
+    fn start_seek(self: Pin<&mut Self>, _position: io::SeekFrom) -> io::Result<()> {
+        Err(io::Error::new(io::ErrorKind::Other, "can not seek stdin"))
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not seek stdin",
+        )))
+    }
+}
+
+//#[cfg_attr(feature = "enable-serde", typetag::serde)]
+#[async_trait::async_trait]
+impl VirtualFile for Stdin {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<()> {
+        Ok(())
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(0)
+    }
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        {
+            let read_buffer = self.read_buffer.lock().unwrap();
+            if let Some(read_buffer) = read_buffer.as_ref() {
+                let buf_len = read_buffer.len();
+                if buf_len > 0 {
+                    return Poll::Ready(Ok(buf_len));
+                }
+            }
+        }
+
+        let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+        let inner = Pin::new(&mut self.inner);
+
+        let mut buf = [0u8; 8192];
+        let mut read_buf = ReadBuf::new(&mut buf[..]);
+        match inner.poll_read(cx, &mut read_buf) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(Err(err)) => Poll::Ready(Err(err)),
+            Poll::Ready(Ok(())) => {
+                let buf = read_buf.filled();
+                let buf_len = buf.len();
+
+                let mut read_buffer = self.read_buffer.lock().unwrap();
+                read_buffer.replace(Bytes::from(buf.to_vec()));
+                Poll::Ready(Ok(buf_len))
+            }
+        }
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+
+    use crate::host_fs::FileSystem;
+    use crate::FileSystem as FileSystemTrait;
+    use crate::FsError;
+    use std::path::Path;
+
+    #[tokio::test]
+    async fn test_new_filesystem() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("foo2.txt"), b"").unwrap();
+
+        let fs = FileSystem::default();
+        assert!(fs.read_dir(Path::new("/")).is_ok(), "hostfs can read root");
+        assert!(
+            fs.new_open_options()
+                .read(true)
+                .open(temp.path().join("foo2.txt"))
+                .is_ok(),
+            "created foo2.txt"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_create_dir() {
+        let temp = TempDir::new().unwrap();
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.create_dir(Path::new("/")),
+            Err(FsError::BaseNotDirectory),
+            "creating a directory that has no parent",
+        );
+
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        assert!(
+            temp.path().join("foo").exists(),
+            "foo dir exists in host_fs"
+        );
+
+        let cur_dir = read_dir_names(&fs, temp.path());
+
+        if !cur_dir.contains(&"foo".to_string()) {
+            panic!("cur_dir does not contain foo: {:#?}", cur_dir);
+        }
+
+        assert!(
+            cur_dir.contains(&"foo".to_string()),
+            "the root is updated and well-defined"
+        );
+
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        assert!(
+            temp.path().join("foo").join("bar").exists(),
+            "foo dir exists in host_fs"
+        );
+
+        let foo_dir = read_dir_names(&fs, temp.path().join("foo"));
+
+        assert!(
+            foo_dir.contains(&"bar".to_string()),
+            "the foo directory is updated and well-defined"
+        );
+
+        let bar_dir = read_dir_names(&fs, temp.path().join("foo/bar"));
+
+        assert!(
+            bar_dir.is_empty(),
+            "the foo directory is updated and well-defined"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_remove_dir() {
+        let temp = TempDir::new().unwrap();
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/foo")),
+            Err(FsError::EntryNotFound),
+            "cannot remove a directory that doesn't exist",
+        );
+
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        assert!(temp.path().join("foo/bar").exists(), "./foo/bar exists");
+
+        assert_eq!(
+            fs.remove_dir(&temp.path().join("foo")),
+            Err(FsError::DirectoryNotEmpty),
+            "removing a directory that has children",
+        );
+
+        assert_eq!(
+            fs.remove_dir(&temp.path().join("foo/bar")),
+            Ok(()),
+            "removing a sub-directory",
+        );
+
+        assert_eq!(
+            fs.remove_dir(&temp.path().join("foo")),
+            Ok(()),
+            "removing a directory",
+        );
+
+        let cur_dir = read_dir_names(&fs, temp.path());
+
+        assert!(
+            !cur_dir.contains(&"foo".to_string()),
+            "the foo directory still exists"
+        );
+    }
+
+    fn read_dir_names(fs: &dyn crate::FileSystem, path: impl AsRef<Path>) -> Vec<String> {
+        fs.read_dir(path.as_ref())
+            .unwrap()
+            .filter_map(|entry| Some(entry.ok()?.file_name().to_str()?.to_string()))
+            .collect::<Vec<_>>()
+    }
+
+    #[tokio::test]
+    async fn test_rename() {
+        let temp = TempDir::new().unwrap();
+        let fs = FileSystem::default();
+        std::fs::create_dir_all(temp.path().join("foo").join("qux")).unwrap();
+        let foo = temp.path().join("foo");
+        let bar = temp.path().join("bar");
+
+        assert_eq!(
+            fs.rename(Path::new("/"), Path::new("/bar")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming a directory that has no parent",
+        );
+        assert_eq!(
+            fs.rename(Path::new("/foo"), Path::new("/")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming to a directory that has no parent",
+        );
+
+        assert_eq!(
+            fs.rename(&foo, &foo.join("bar").join("baz"),).await,
+            Err(FsError::EntryNotFound),
+            "renaming to a directory that has parent that doesn't exist",
+        );
+
+        // On Windows, rename "to" must not be an existing directory
+        #[cfg(not(target_os = "windows"))]
+        assert_eq!(fs.create_dir(&bar), Ok(()));
+
+        assert_eq!(
+            fs.rename(&foo, &bar).await,
+            Ok(()),
+            "renaming to a directory that has parent that exists",
+        );
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(bar.join("hello1.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello1.txt`)",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(bar.join("hello2.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello2.txt`)",
+        );
+
+        let cur_dir = read_dir_names(&fs, temp.path());
+
+        assert!(
+            !cur_dir.contains(&"foo".to_string()),
+            "the foo directory still exists"
+        );
+
+        assert!(
+            cur_dir.contains(&"bar".to_string()),
+            "the bar directory still exists"
+        );
+
+        let bar_dir = read_dir_names(&fs, &bar);
+
+        if !bar_dir.contains(&"qux".to_string()) {
+            println!("qux does not exist: {:?}", bar_dir)
+        }
+
+        let qux_dir = read_dir_names(&fs, bar.join("qux"));
+
+        assert!(qux_dir.is_empty(), "the qux directory is empty");
+
+        assert!(
+            bar.join("hello1.txt").exists(),
+            "the /bar/hello1.txt file exists"
+        );
+
+        assert!(
+            bar.join("hello2.txt").exists(),
+            "the /bar/hello2.txt file exists"
+        );
+
+        assert_eq!(fs.create_dir(&foo), Ok(()), "create ./foo again",);
+
+        assert_eq!(
+            fs.rename(&bar.join("hello2.txt"), &foo.join("world2.txt"))
+                .await,
+            Ok(()),
+            "renaming (and moving) a file",
+        );
+
+        assert_eq!(
+            fs.rename(&foo, &bar.join("baz")).await,
+            Ok(()),
+            "renaming a directory",
+        );
+
+        assert_eq!(
+            fs.rename(&bar.join("hello1.txt"), &bar.join("world1.txt"))
+                .await,
+            Ok(()),
+            "renaming a file (in the same directory)",
+        );
+
+        assert!(bar.exists(), "./bar exists");
+        assert!(bar.join("baz").exists(), "./bar/baz exists");
+        assert!(!foo.exists(), "foo does not exist anymore");
+        assert!(
+            bar.join("baz/world2.txt").exists(),
+            "/bar/baz/world2.txt exists"
+        );
+        assert!(
+            bar.join("world1.txt").exists(),
+            "/bar/world1.txt (ex hello1.txt) exists"
+        );
+        assert!(!bar.join("hello1.txt").exists(), "hello1.txt was moved");
+        assert!(!bar.join("hello2.txt").exists(), "hello2.txt was moved");
+        assert!(
+            bar.join("baz/world2.txt").exists(),
+            "world2.txt was moved to the correct place"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_metadata() {
+        use std::thread::sleep;
+        use std::time::Duration;
+
+        let temp = TempDir::new().unwrap();
+
+        let fs = FileSystem::default();
+
+        let root_metadata = fs.metadata(temp.path()).unwrap();
+
+        assert!(root_metadata.ft.dir);
+        // it seems created is not evailable on musl, at least on CI testing.
+        #[cfg(not(target_env = "musl"))]
+        assert_eq!(root_metadata.accessed, root_metadata.created);
+        #[cfg(not(target_env = "musl"))]
+        assert_eq!(root_metadata.modified, root_metadata.created);
+        assert!(root_metadata.modified > 0);
+
+        let foo = temp.path().join("foo");
+
+        assert_eq!(fs.create_dir(&foo), Ok(()));
+
+        let foo_metadata = fs.metadata(&foo);
+        assert!(foo_metadata.is_ok());
+        let foo_metadata = foo_metadata.unwrap();
+
+        assert!(foo_metadata.ft.dir);
+        #[cfg(not(target_env = "musl"))]
+        assert_eq!(foo_metadata.accessed, foo_metadata.created);
+        #[cfg(not(target_env = "musl"))]
+        assert_eq!(foo_metadata.modified, foo_metadata.created);
+        assert!(foo_metadata.modified > 0);
+
+        sleep(Duration::from_secs(3));
+
+        let bar = temp.path().join("bar");
+
+        assert_eq!(fs.rename(&foo, &bar).await, Ok(()));
+
+        let bar_metadata = fs.metadata(&bar).unwrap();
+        assert!(bar_metadata.ft.dir);
+        assert!(bar_metadata.accessed >= foo_metadata.accessed);
+        assert_eq!(bar_metadata.created, foo_metadata.created);
+        assert!(bar_metadata.modified > foo_metadata.modified);
+
+        let root_metadata = fs.metadata(&bar).unwrap();
+        assert!(
+            root_metadata.modified > foo_metadata.modified,
+            "the parent modified time was updated"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_remove_file() {
+        let fs = FileSystem::default();
+        let temp = TempDir::new().unwrap();
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(temp.path().join("foo.txt")),
+                Ok(_)
+            ),
+            "creating a new file",
+        );
+
+        assert!(read_dir_names(&fs, temp.path()).contains(&"foo.txt".to_string()));
+
+        assert!(temp.path().join("foo.txt").is_file());
+
+        assert_eq!(
+            fs.remove_file(&temp.path().join("foo.txt")),
+            Ok(()),
+            "removing a file that exists",
+        );
+
+        assert!(!temp.path().join("foo.txt").exists());
+
+        assert_eq!(
+            fs.remove_file(&temp.path().join("foo.txt")),
+            Err(FsError::EntryNotFound),
+            "removing a file that doesn't exists",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_readdir() {
+        let temp = TempDir::new().unwrap();
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo")),
+            Ok(()),
+            "creating `foo`"
+        );
+        assert_eq!(
+            fs.create_dir(&temp.path().join("foo/sub")),
+            Ok(()),
+            "creating `sub`"
+        );
+        assert_eq!(
+            fs.create_dir(&temp.path().join("bar")),
+            Ok(()),
+            "creating `bar`"
+        );
+        assert_eq!(
+            fs.create_dir(&temp.path().join("baz")),
+            Ok(()),
+            "creating `bar`"
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(temp.path().join("a.txt")),
+                Ok(_)
+            ),
+            "creating `a.txt`",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(&temp.path().join("b.txt")),
+                Ok(_)
+            ),
+            "creating `b.txt`",
+        );
+
+        let readdir = fs.read_dir(temp.path());
+
+        assert!(
+            readdir.is_ok(),
+            "reading the directory `{}`",
+            temp.path().display()
+        );
+
+        let mut readdir = readdir.unwrap();
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("a.txt"), "checking entry #1");
+        assert!(next.path.is_file(), "checking entry #1");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("b.txt"), "checking entry #2");
+        assert!(next.path.is_file(), "checking entry #2");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("bar"), "checking entry #3");
+        assert!(next.path.is_dir(), "checking entry #3");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("baz"), "checking entry #4");
+        assert!(next.path.is_dir(), "checking entry #4");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("foo"), "checking entry #5");
+        assert!(next.path.is_dir(), "checking entry #5");
+
+        if let Some(s) = readdir.next() {
+            panic!("next: {:?}", s);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_canonicalize() {
+        let temp = TempDir::new().unwrap();
+        std::fs::create_dir_all(temp.path().join("foo/bar/baz/qux")).unwrap();
+        std::fs::write(temp.path().join("foo/bar/baz/qux/hello.txt"), b"").unwrap();
+
+        let fs = FileSystem::default();
+        let root_dir = temp.path().canonicalize().unwrap();
+
+        assert_eq!(
+            fs.canonicalize(temp.path()),
+            Ok(root_dir.clone()),
+            "canonicalizing `/`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("foo")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `foo`",
+        );
+        assert_eq!(
+            fs.canonicalize(&temp.path().join("././././foo/")),
+            Ok(root_dir.join("foo")),
+            "canonicalizing `/././././foo/`",
+        );
+        assert_eq!(
+            fs.canonicalize(&temp.path().join("foo/bar//")),
+            Ok(root_dir.join("foo").join("bar")),
+            "canonicalizing `/foo/bar//`",
+        );
+        assert_eq!(
+            fs.canonicalize(&temp.path().join("foo/bar/../bar")),
+            Ok(root_dir.join("foo").join("bar")),
+            "canonicalizing `/foo/bar/../bar`",
+        );
+        assert_eq!(
+            fs.canonicalize(&temp.path().join("foo/bar/../..")),
+            Ok(root_dir.clone()),
+            "canonicalizing `/foo/bar/../..`",
+        );
+        // temp.path().join("/foo/bar/../../..").exists() gives true on windows
+        #[cfg(not(target_os = "windows"))]
+        assert_eq!(
+            fs.canonicalize(&root_dir.join("/foo/bar/../../..")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `/foo/bar/../../..`",
+        );
+        assert_eq!(
+            fs.canonicalize(&root_dir.join("C:/foo/")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `C:/foo/`",
+        );
+        assert_eq!(
+            fs.canonicalize(&root_dir.join(
+                "foo/./../foo/bar/../../foo/bar/./baz/./../baz/qux/../../baz/./qux/hello.txt"
+            )),
+            Ok(root_dir
+                .join("foo")
+                .join("bar")
+                .join("baz")
+                .join("qux")
+                .join("hello.txt")),
+            "canonicalizing a crazily stupid path name",
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/lib.rs
new file mode 100644
index 0000000..7fb2343
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/lib.rs
@@ -0,0 +1,725 @@
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(test)]
+#[macro_use]
+extern crate pretty_assertions;
+
+use futures::future::BoxFuture;
+use std::any::Any;
+use std::ffi::OsString;
+use std::fmt;
+use std::io;
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+use std::pin::Pin;
+use std::task::Context;
+use std::task::Poll;
+use thiserror::Error;
+
+pub mod arc_box_file;
+pub mod arc_file;
+pub mod arc_fs;
+pub mod buffer_file;
+pub mod builder;
+pub mod combine_file;
+pub mod cow_file;
+pub mod dual_write_file;
+pub mod empty_fs;
+#[cfg(feature = "host-fs")]
+pub mod host_fs;
+pub mod mem_fs;
+pub mod null_file;
+pub mod passthru_fs;
+pub mod random_file;
+pub mod special_file;
+pub mod tmp_fs;
+pub mod union_fs;
+pub mod zero_file;
+// tty_file -> see wasmer_wasi::tty_file
+mod filesystems;
+pub(crate) mod ops;
+mod overlay_fs;
+pub mod pipe;
+#[cfg(feature = "host-fs")]
+mod scoped_directory_fs;
+mod static_file;
+#[cfg(feature = "static-fs")]
+pub mod static_fs;
+mod trace_fs;
+#[cfg(feature = "webc-fs")]
+pub mod webc_fs;
+#[cfg(feature = "webc-fs")]
+mod webc_volume_fs;
+
+pub mod limiter;
+
+pub use arc_box_file::*;
+pub use arc_file::*;
+pub use arc_fs::*;
+pub use buffer_file::*;
+pub use builder::*;
+pub use combine_file::*;
+pub use cow_file::*;
+pub use dual_write_file::*;
+pub use empty_fs::*;
+pub use filesystems::FileSystems;
+pub use null_file::*;
+pub use overlay_fs::OverlayFileSystem;
+pub use passthru_fs::*;
+pub use pipe::*;
+#[cfg(feature = "host-fs")]
+pub use scoped_directory_fs::ScopedDirectoryFileSystem;
+pub use special_file::*;
+pub use static_file::StaticFile;
+pub use tmp_fs::*;
+pub use trace_fs::TraceFileSystem;
+pub use union_fs::*;
+#[cfg(feature = "webc-fs")]
+pub use webc_volume_fs::WebcVolumeFileSystem;
+pub use zero_file::*;
+
+pub type Result<T> = std::result::Result<T, FsError>;
+
+// re-exports
+pub use tokio::io::ReadBuf;
+pub use tokio::io::{AsyncRead, AsyncReadExt};
+pub use tokio::io::{AsyncSeek, AsyncSeekExt};
+pub use tokio::io::{AsyncWrite, AsyncWriteExt};
+
+pub trait ClonableVirtualFile: VirtualFile + Clone {}
+
+pub use ops::{copy_reference, copy_reference_ext};
+
+pub trait FileSystem: fmt::Debug + Send + Sync + 'static + Upcastable {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir>;
+    fn create_dir(&self, path: &Path) -> Result<()>;
+    fn remove_dir(&self, path: &Path) -> Result<()>;
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>>;
+    fn metadata(&self, path: &Path) -> Result<Metadata>;
+    /// This method gets metadata without following symlinks in the path.
+    /// Currently identical to `metadata` because symlinks aren't implemented
+    /// yet.
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        self.metadata(path)
+    }
+    fn remove_file(&self, path: &Path) -> Result<()>;
+
+    fn new_open_options(&self) -> OpenOptions;
+}
+
+impl dyn FileSystem + 'static {
+    #[inline]
+    pub fn downcast_ref<T: 'static>(&'_ self) -> Option<&'_ T> {
+        self.upcast_any_ref().downcast_ref::<T>()
+    }
+    #[inline]
+    pub fn downcast_mut<T: 'static>(&'_ mut self) -> Option<&'_ mut T> {
+        self.upcast_any_mut().downcast_mut::<T>()
+    }
+}
+
+#[async_trait::async_trait]
+impl<D, F> FileSystem for D
+where
+    D: Deref<Target = F> + std::fmt::Debug + Send + Sync + 'static,
+    F: FileSystem + ?Sized,
+{
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        (**self).read_dir(path)
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        (**self).create_dir(path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        (**self).remove_dir(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { (**self).rename(from, to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        (**self).metadata(path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        (**self).remove_file(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        (**self).new_open_options()
+    }
+}
+
+pub trait FileOpener {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>>;
+}
+
+#[derive(Debug, Clone)]
+pub struct OpenOptionsConfig {
+    pub read: bool,
+    pub write: bool,
+    pub create_new: bool,
+    pub create: bool,
+    pub append: bool,
+    pub truncate: bool,
+}
+
+impl OpenOptionsConfig {
+    /// Returns the minimum allowed rights, given the rights of the parent directory
+    pub fn minimum_rights(&self, parent_rights: &Self) -> Self {
+        Self {
+            read: parent_rights.read && self.read,
+            write: parent_rights.write && self.write,
+            create_new: parent_rights.create_new && self.create_new,
+            create: parent_rights.create && self.create,
+            append: parent_rights.append && self.append,
+            truncate: parent_rights.truncate && self.truncate,
+        }
+    }
+
+    pub const fn read(&self) -> bool {
+        self.read
+    }
+
+    pub const fn write(&self) -> bool {
+        self.write
+    }
+
+    pub const fn create_new(&self) -> bool {
+        self.create_new
+    }
+
+    pub const fn create(&self) -> bool {
+        self.create
+    }
+
+    pub const fn append(&self) -> bool {
+        self.append
+    }
+
+    pub const fn truncate(&self) -> bool {
+        self.truncate
+    }
+
+    /// Would a file opened with this [`OpenOptionsConfig`] change files on the
+    /// filesystem.
+    pub const fn would_mutate(&self) -> bool {
+        let OpenOptionsConfig {
+            read: _,
+            write,
+            create_new,
+            create,
+            append,
+            truncate,
+        } = *self;
+        append || write || create || create_new || truncate
+    }
+}
+
+impl<'a> fmt::Debug for OpenOptions<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.conf.fmt(f)
+    }
+}
+
+pub struct OpenOptions<'a> {
+    opener: &'a dyn FileOpener,
+    conf: OpenOptionsConfig,
+}
+
+impl<'a> OpenOptions<'a> {
+    pub fn new(opener: &'a dyn FileOpener) -> Self {
+        Self {
+            opener,
+            conf: OpenOptionsConfig {
+                read: false,
+                write: false,
+                create_new: false,
+                create: false,
+                append: false,
+                truncate: false,
+            },
+        }
+    }
+
+    pub fn get_config(&self) -> OpenOptionsConfig {
+        self.conf.clone()
+    }
+
+    /// Use an existing [`OpenOptionsConfig`] to configure this [`OpenOptions`].
+    pub fn options(&mut self, options: OpenOptionsConfig) -> &mut Self {
+        self.conf = options;
+        self
+    }
+
+    /// Sets the option for read access.
+    ///
+    /// This option, when true, will indicate that the file should be
+    /// `read`-able if opened.
+    pub fn read(&mut self, read: bool) -> &mut Self {
+        self.conf.read = read;
+        self
+    }
+
+    /// Sets the option for write access.
+    ///
+    /// This option, when true, will indicate that the file should be
+    /// `write`-able if opened.
+    ///
+    /// If the file already exists, any write calls on it will overwrite its
+    /// contents, without truncating it.
+    pub fn write(&mut self, write: bool) -> &mut Self {
+        self.conf.write = write;
+        self
+    }
+
+    /// Sets the option for the append mode.
+    ///
+    /// This option, when true, means that writes will append to a file instead
+    /// of overwriting previous contents.
+    /// Note that setting `.write(true).append(true)` has the same effect as
+    /// setting only `.append(true)`.
+    pub fn append(&mut self, append: bool) -> &mut Self {
+        self.conf.append = append;
+        self
+    }
+
+    /// Sets the option for truncating a previous file.
+    ///
+    /// If a file is successfully opened with this option set it will truncate
+    /// the file to 0 length if it already exists.
+    ///
+    /// The file must be opened with write access for truncate to work.
+    pub fn truncate(&mut self, truncate: bool) -> &mut Self {
+        self.conf.truncate = truncate;
+        self
+    }
+
+    /// Sets the option to create a new file, or open it if it already exists.
+    pub fn create(&mut self, create: bool) -> &mut Self {
+        self.conf.create = create;
+        self
+    }
+
+    /// Sets the option to create a new file, failing if it already exists.
+    pub fn create_new(&mut self, create_new: bool) -> &mut Self {
+        self.conf.create_new = create_new;
+        self
+    }
+
+    pub fn open<P: AsRef<Path>>(
+        &mut self,
+        path: P,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        self.opener.open(path.as_ref(), &self.conf)
+    }
+}
+
+/// This trait relies on your file closing when it goes out of scope via `Drop`
+//#[cfg_attr(feature = "enable-serde", typetag::serde)]
+pub trait VirtualFile:
+    fmt::Debug + AsyncRead + AsyncWrite + AsyncSeek + Unpin + Upcastable + Send
+{
+    /// the last time the file was accessed in nanoseconds as a UNIX timestamp
+    fn last_accessed(&self) -> u64;
+
+    /// the last time the file was modified in nanoseconds as a UNIX timestamp
+    fn last_modified(&self) -> u64;
+
+    /// the time at which the file was created in nanoseconds as a UNIX timestamp
+    fn created_time(&self) -> u64;
+
+    /// the size of the file in bytes
+    fn size(&self) -> u64;
+
+    /// Change the size of the file, if the `new_size` is greater than the current size
+    /// the extra bytes will be allocated and zeroed
+    fn set_len(&mut self, new_size: u64) -> Result<()>;
+
+    /// Request deletion of the file
+    fn unlink(&mut self) -> Result<()>;
+
+    /// Indicates if the file is opened or closed. This function must not block
+    /// Defaults to a status of being constantly open
+    fn is_open(&self) -> bool {
+        true
+    }
+
+    /// Used for "special" files such as `stdin`, `stdout` and `stderr`.
+    /// Always returns the same file descriptor (0, 1 or 2). Returns `None`
+    /// on normal files
+    fn get_special_fd(&self) -> Option<u32> {
+        None
+    }
+
+    /// Writes to this file using an mmap offset and reference
+    /// (this method only works for mmap optimized file systems)
+    fn write_from_mmap(&mut self, _offset: u64, _len: u64) -> std::io::Result<()> {
+        Err(std::io::ErrorKind::Unsupported.into())
+    }
+
+    /// This method will copy a file from a source to this destination where
+    /// the default is to do a straight byte copy however file system implementors
+    /// may optimize this to do a zero copy
+    fn copy_reference(
+        &mut self,
+        mut src: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> BoxFuture<'_, std::io::Result<()>> {
+        Box::pin(async move {
+            let bytes_written = tokio::io::copy(&mut src, self).await?;
+            tracing::trace!(bytes_written, "Copying file into host filesystem",);
+            Ok(())
+        })
+    }
+
+    /// Polls the file for when there is data to be read
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>>;
+
+    /// Polls the file for when it is available for writing
+    fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>>;
+}
+
+// Implementation of `Upcastable` taken from https://users.rust-lang.org/t/why-does-downcasting-not-work-for-subtraits/33286/7 .
+/// Trait needed to get downcasting from `VirtualFile` to work.
+pub trait Upcastable {
+    fn upcast_any_ref(&'_ self) -> &'_ dyn Any;
+    fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any;
+    fn upcast_any_box(self: Box<Self>) -> Box<dyn Any>;
+}
+
+impl<T: Any + fmt::Debug + 'static> Upcastable for T {
+    #[inline]
+    fn upcast_any_ref(&'_ self) -> &'_ dyn Any {
+        self
+    }
+    #[inline]
+    fn upcast_any_mut(&'_ mut self) -> &'_ mut dyn Any {
+        self
+    }
+    #[inline]
+    fn upcast_any_box(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+/// Determines the mode that stdio handlers will operate in
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum StdioMode {
+    /// Stdio will be piped to a file descriptor
+    Piped,
+    /// Stdio will inherit the file handlers of its parent
+    Inherit,
+    /// Stdio will be dropped
+    Null,
+    /// Stdio will be sent to the log handler
+    Log,
+}
+
+/// Error type for external users
+#[derive(Error, Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FsError {
+    /// The fd given as a base was not a directory so the operation was not possible
+    #[error("fd not a directory")]
+    BaseNotDirectory,
+    /// Expected a file but found not a file
+    #[error("fd not a file")]
+    NotAFile,
+    /// The fd given was not usable
+    #[error("invalid fd")]
+    InvalidFd,
+    /// File exists
+    #[error("file exists")]
+    AlreadyExists,
+    /// The filesystem has failed to lock a resource.
+    #[error("lock error")]
+    Lock,
+    /// Something failed when doing IO. These errors can generally not be handled.
+    /// It may work if tried again.
+    #[error("io error")]
+    IOError,
+    /// The address was in use
+    #[error("address is in use")]
+    AddressInUse,
+    /// The address could not be found
+    #[error("address could not be found")]
+    AddressNotAvailable,
+    /// A pipe was closed
+    #[error("broken pipe (was closed)")]
+    BrokenPipe,
+    /// The connection was aborted
+    #[error("connection aborted")]
+    ConnectionAborted,
+    /// The connection request was refused
+    #[error("connection refused")]
+    ConnectionRefused,
+    /// The connection was reset
+    #[error("connection reset")]
+    ConnectionReset,
+    /// The operation was interrupted before it could finish
+    #[error("operation interrupted")]
+    Interrupted,
+    /// Invalid internal data, if the argument data is invalid, use `InvalidInput`
+    #[error("invalid internal data")]
+    InvalidData,
+    /// The provided data is invalid
+    #[error("invalid input")]
+    InvalidInput,
+    /// Could not perform the operation because there was not an open connection
+    #[error("connection is not open")]
+    NotConnected,
+    /// The requested file or directory could not be found
+    #[error("entry not found")]
+    EntryNotFound,
+    /// The requested device couldn't be accessed
+    #[error("can't access device")]
+    NoDevice,
+    /// Caller was not allowed to perform this operation
+    #[error("permission denied")]
+    PermissionDenied,
+    /// The operation did not complete within the given amount of time
+    #[error("time out")]
+    TimedOut,
+    /// Found EOF when EOF was not expected
+    #[error("unexpected eof")]
+    UnexpectedEof,
+    /// Operation would block, this error lets the caller know that they can try again
+    #[error("blocking operation. try again")]
+    WouldBlock,
+    /// A call to write returned 0
+    #[error("write returned 0")]
+    WriteZero,
+    /// Directory not Empty
+    #[error("directory not empty")]
+    DirectoryNotEmpty,
+    #[error("storage full")]
+    StorageFull,
+    /// Some other unhandled error. If you see this, it's probably a bug.
+    #[error("unknown error found")]
+    UnknownError,
+}
+
+impl From<io::Error> for FsError {
+    fn from(io_error: io::Error) -> Self {
+        match io_error.kind() {
+            io::ErrorKind::AddrInUse => FsError::AddressInUse,
+            io::ErrorKind::AddrNotAvailable => FsError::AddressNotAvailable,
+            io::ErrorKind::AlreadyExists => FsError::AlreadyExists,
+            io::ErrorKind::BrokenPipe => FsError::BrokenPipe,
+            io::ErrorKind::ConnectionAborted => FsError::ConnectionAborted,
+            io::ErrorKind::ConnectionRefused => FsError::ConnectionRefused,
+            io::ErrorKind::ConnectionReset => FsError::ConnectionReset,
+            io::ErrorKind::Interrupted => FsError::Interrupted,
+            io::ErrorKind::InvalidData => FsError::InvalidData,
+            io::ErrorKind::InvalidInput => FsError::InvalidInput,
+            io::ErrorKind::NotConnected => FsError::NotConnected,
+            io::ErrorKind::NotFound => FsError::EntryNotFound,
+            io::ErrorKind::PermissionDenied => FsError::PermissionDenied,
+            io::ErrorKind::TimedOut => FsError::TimedOut,
+            io::ErrorKind::UnexpectedEof => FsError::UnexpectedEof,
+            io::ErrorKind::WouldBlock => FsError::WouldBlock,
+            io::ErrorKind::WriteZero => FsError::WriteZero,
+            // NOTE: Add this once the "io_error_more" Rust feature is stabilized
+            // io::ErrorKind::StorageFull => FsError::StorageFull,
+            io::ErrorKind::Other => FsError::IOError,
+            // if the following triggers, a new error type was added to this non-exhaustive enum
+            _ => FsError::UnknownError,
+        }
+    }
+}
+
+impl From<FsError> for io::Error {
+    fn from(val: FsError) -> Self {
+        let kind = match val {
+            FsError::AddressInUse => io::ErrorKind::AddrInUse,
+            FsError::AddressNotAvailable => io::ErrorKind::AddrNotAvailable,
+            FsError::AlreadyExists => io::ErrorKind::AlreadyExists,
+            FsError::BrokenPipe => io::ErrorKind::BrokenPipe,
+            FsError::ConnectionAborted => io::ErrorKind::ConnectionAborted,
+            FsError::ConnectionRefused => io::ErrorKind::ConnectionRefused,
+            FsError::ConnectionReset => io::ErrorKind::ConnectionReset,
+            FsError::Interrupted => io::ErrorKind::Interrupted,
+            FsError::InvalidData => io::ErrorKind::InvalidData,
+            FsError::InvalidInput => io::ErrorKind::InvalidInput,
+            FsError::NotConnected => io::ErrorKind::NotConnected,
+            FsError::EntryNotFound => io::ErrorKind::NotFound,
+            FsError::PermissionDenied => io::ErrorKind::PermissionDenied,
+            FsError::TimedOut => io::ErrorKind::TimedOut,
+            FsError::UnexpectedEof => io::ErrorKind::UnexpectedEof,
+            FsError::WouldBlock => io::ErrorKind::WouldBlock,
+            FsError::WriteZero => io::ErrorKind::WriteZero,
+            FsError::IOError => io::ErrorKind::Other,
+            FsError::BaseNotDirectory => io::ErrorKind::Other,
+            FsError::NotAFile => io::ErrorKind::Other,
+            FsError::InvalidFd => io::ErrorKind::Other,
+            FsError::Lock => io::ErrorKind::Other,
+            FsError::NoDevice => io::ErrorKind::Other,
+            FsError::DirectoryNotEmpty => io::ErrorKind::Other,
+            FsError::UnknownError => io::ErrorKind::Other,
+            FsError::StorageFull => io::ErrorKind::Other,
+            // NOTE: Add this once the "io_error_more" Rust feature is stabilized
+            // FsError::StorageFull => io::ErrorKind::StorageFull,
+        };
+        kind.into()
+    }
+}
+
+#[derive(Debug)]
+pub struct ReadDir {
+    // TODO: to do this properly we need some kind of callback to the core FS abstraction
+    data: Vec<DirEntry>,
+    index: usize,
+}
+
+impl ReadDir {
+    pub fn new(data: Vec<DirEntry>) -> Self {
+        Self { data, index: 0 }
+    }
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DirEntry {
+    pub path: PathBuf,
+    // weird hack, to fix this we probably need an internal trait object or callbacks or something
+    pub metadata: Result<Metadata>,
+}
+
+impl DirEntry {
+    pub fn path(&self) -> PathBuf {
+        self.path.clone()
+    }
+
+    pub fn metadata(&self) -> Result<Metadata> {
+        self.metadata.clone()
+    }
+
+    pub fn file_type(&self) -> Result<FileType> {
+        let metadata = self.metadata.clone()?;
+        Ok(metadata.file_type())
+    }
+
+    pub fn file_name(&self) -> OsString {
+        self.path
+            .file_name()
+            .unwrap_or(self.path.as_os_str())
+            .to_owned()
+    }
+
+    pub fn is_white_out(&self) -> Option<PathBuf> {
+        ops::is_white_out(&self.path)
+    }
+}
+
+#[allow(clippy::len_without_is_empty)] // Clippy thinks it's an iterator.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+// TODO: review this, proper solution would probably use a trait object internally
+pub struct Metadata {
+    pub ft: FileType,
+    pub accessed: u64,
+    pub created: u64,
+    pub modified: u64,
+    pub len: u64,
+}
+
+impl Metadata {
+    pub fn is_file(&self) -> bool {
+        self.ft.is_file()
+    }
+
+    pub fn is_dir(&self) -> bool {
+        self.ft.is_dir()
+    }
+
+    pub fn accessed(&self) -> u64 {
+        self.accessed
+    }
+
+    pub fn created(&self) -> u64 {
+        self.created
+    }
+
+    pub fn modified(&self) -> u64 {
+        self.modified
+    }
+
+    pub fn file_type(&self) -> FileType {
+        self.ft.clone()
+    }
+
+    pub fn len(&self) -> u64 {
+        self.len
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+// TODO: review this, proper solution would probably use a trait object internally
+pub struct FileType {
+    pub dir: bool,
+    pub file: bool,
+    pub symlink: bool,
+    // TODO: the following 3 only exist on unix in the standard FS API.
+    // We should mirror that API and extend with that trait too.
+    pub char_device: bool,
+    pub block_device: bool,
+    pub socket: bool,
+    pub fifo: bool,
+}
+
+impl FileType {
+    pub fn new_dir() -> Self {
+        Self {
+            dir: true,
+            ..Default::default()
+        }
+    }
+
+    pub fn new_file() -> Self {
+        Self {
+            file: true,
+            ..Default::default()
+        }
+    }
+
+    pub fn is_dir(&self) -> bool {
+        self.dir
+    }
+    pub fn is_file(&self) -> bool {
+        self.file
+    }
+    pub fn is_symlink(&self) -> bool {
+        self.symlink
+    }
+    pub fn is_char_device(&self) -> bool {
+        self.char_device
+    }
+    pub fn is_block_device(&self) -> bool {
+        self.block_device
+    }
+    pub fn is_socket(&self) -> bool {
+        self.socket
+    }
+    pub fn is_fifo(&self) -> bool {
+        self.fifo
+    }
+}
+
+impl Iterator for ReadDir {
+    type Item = Result<DirEntry>;
+
+    fn next(&mut self) -> Option<Result<DirEntry>> {
+        if let Some(v) = self.data.get(self.index).cloned() {
+            self.index += 1;
+            return Some(Ok(v));
+        }
+        None
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/limiter.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/limiter.rs
new file mode 100644
index 0000000..bcd44ee
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/limiter.rs
@@ -0,0 +1,210 @@
+use std::sync::Arc;
+
+use crate::FsError;
+
+pub use self::tracked_vec::TrackedVec;
+
+/// Allows tracking and limiting the memory usage of a memfs [`FileSystem`].
+pub trait FsMemoryLimiter: Send + Sync + std::fmt::Debug {
+    fn on_grow(&self, grown_bytes: usize) -> std::result::Result<(), FsError>;
+    fn on_shrink(&self, shrunk_bytes: usize);
+}
+
+pub type DynFsMemoryLimiter = Arc<dyn FsMemoryLimiter + Send + Sync>;
+
+#[cfg(feature = "tracking")]
+mod tracked_vec {
+    use crate::FsError;
+
+    use super::DynFsMemoryLimiter;
+
+    #[derive(Debug, Clone)]
+    pub struct TrackedVec {
+        data: Vec<u8>,
+        pub(super) limiter: Option<DynFsMemoryLimiter>,
+    }
+
+    impl TrackedVec {
+        pub fn new(limiter: Option<DynFsMemoryLimiter>) -> Self {
+            Self {
+                data: Vec::new(),
+                limiter,
+            }
+        }
+
+        pub fn limiter(&self) -> Option<&DynFsMemoryLimiter> {
+            self.limiter.as_ref()
+        }
+
+        pub fn with_capacity(
+            capacity: usize,
+            limiter: Option<DynFsMemoryLimiter>,
+        ) -> Result<Self, FsError> {
+            if let Some(limiter) = &limiter {
+                limiter.on_grow(capacity)?;
+            }
+            Ok(Self {
+                data: Vec::with_capacity(capacity),
+                limiter,
+            })
+        }
+
+        pub fn clear(&mut self) {
+            self.data.clear();
+        }
+
+        pub fn append(&mut self, other: &mut Self) -> Result<(), FsError> {
+            let old_capacity = self.data.capacity();
+            self.data.append(&mut other.data);
+
+            if let Some(limiter) = &self.limiter {
+                let new = self.data.capacity() - old_capacity;
+                limiter.on_grow(new)?;
+            }
+
+            Ok(())
+        }
+
+        pub fn split_off(&mut self, at: usize) -> Result<Self, FsError> {
+            let other = self.data.split_off(at);
+
+            if let Some(limiter) = &self.limiter {
+                // NOTE: split_off leaves the original vector capacity intact, so
+                // we can just add the new length.
+                let new_len = other.capacity();
+                limiter.on_grow(new_len)?;
+            }
+
+            Ok(Self {
+                data: other,
+                limiter: self.limiter.clone(),
+            })
+        }
+
+        pub fn resize(&mut self, new_len: usize, value: u8) -> Result<(), FsError> {
+            let old_capacity = self.data.capacity();
+            self.data.resize(new_len, value);
+            if let Some(limiter) = &self.limiter {
+                let new = self.data.capacity() - old_capacity;
+                limiter.on_grow(new)?;
+            }
+            Ok(())
+        }
+
+        pub fn extend_from_slice(&mut self, other: &[u8]) -> Result<(), FsError> {
+            let old_capacity = self.data.capacity();
+            self.data.extend_from_slice(other);
+            if let Some(limiter) = &self.limiter {
+                let new = self.data.capacity() - old_capacity;
+                limiter.on_grow(new)?;
+            }
+            Ok(())
+        }
+
+        pub fn reserve_exact(&mut self, additional: usize) -> Result<(), FsError> {
+            let old_capacity = self.data.capacity();
+            self.data.reserve_exact(additional);
+            if let Some(limiter) = &self.limiter {
+                let new = self.data.capacity() - old_capacity;
+                limiter.on_grow(new)?;
+            }
+            Ok(())
+        }
+    }
+
+    impl Drop for TrackedVec {
+        fn drop(&mut self) {
+            if let Some(limiter) = &self.limiter {
+                limiter.on_shrink(self.data.capacity());
+            }
+        }
+    }
+
+    impl std::ops::Deref for TrackedVec {
+        type Target = [u8];
+
+        fn deref(&self) -> &Self::Target {
+            &self.data
+        }
+    }
+
+    impl std::ops::DerefMut for TrackedVec {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.data
+        }
+    }
+}
+
+#[cfg(not(feature = "tracking"))]
+mod tracked_vec {
+    use crate::FsError;
+
+    use super::DynFsMemoryLimiter;
+
+    #[derive(Debug)]
+    pub struct TrackedVec {
+        data: Vec<u8>,
+    }
+
+    impl TrackedVec {
+        pub fn new(_limiter: Option<DynFsMemoryLimiter>) -> Self {
+            Self { data: Vec::new() }
+        }
+
+        pub fn limiter(&self) -> Option<&DynFsMemoryLimiter> {
+            None
+        }
+
+        pub fn with_capacity(
+            capacity: usize,
+            _limiter: Option<DynFsMemoryLimiter>,
+        ) -> Result<Self, FsError> {
+            Ok(Self {
+                data: Vec::with_capacity(capacity),
+            })
+        }
+
+        pub fn clear(&mut self) {
+            self.data.clear();
+        }
+
+        pub fn append(&mut self, other: &mut Self) -> Result<(), FsError> {
+            self.data.append(&mut other.data);
+            Ok(())
+        }
+
+        pub fn split_off(&mut self, at: usize) -> Result<Self, FsError> {
+            let other = self.data.split_off(at);
+            Ok(Self { data: other })
+        }
+
+        pub fn resize(&mut self, new_len: usize, value: u8) -> Result<(), FsError> {
+            self.data.resize(new_len, value);
+            Ok(())
+        }
+
+        pub fn extend_from_slice(&mut self, other: &[u8]) -> Result<(), FsError> {
+            self.data.extend_from_slice(other);
+            Ok(())
+        }
+
+        pub fn reserve_exact(&mut self, additional: usize) -> Result<(), FsError> {
+            self.data.reserve_exact(additional);
+            Ok(())
+        }
+    }
+
+    impl std::ops::Deref for TrackedVec {
+        type Target = Vec<u8>;
+
+        fn deref(&self) -> &Self::Target {
+            &self.data
+        }
+    }
+
+    impl std::ops::DerefMut for TrackedVec {
+        fn deref_mut(&mut self) -> &mut Self::Target {
+            &mut self.data
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file.rs
new file mode 100644
index 0000000..1a43365
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file.rs
@@ -0,0 +1,1542 @@
+//! This module contains the `FileHandle` and `File`
+//! implementations. They aren't exposed to the public API. Only
+//! `FileHandle` can be used through the `VirtualFile` trait object.
+
+use futures::future::BoxFuture;
+use tokio::io::AsyncRead;
+use tokio::io::{AsyncSeek, AsyncWrite};
+
+use self::offloaded_file::OffloadWrite;
+
+use super::*;
+use crate::limiter::TrackedVec;
+use crate::{CopyOnWriteFile, FsError, Result, VirtualFile};
+use std::borrow::Cow;
+use std::cmp;
+use std::convert::TryInto;
+use std::fmt;
+use std::io;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+/// A file handle. The file system doesn't return the [`File`] type
+/// directly, but rather this `FileHandle` type, which contains the
+/// inode, the flags, and (a light copy of) the filesystem. For each
+/// operations, it is checked that the permissions allow the
+/// operations to be executed, and then it is checked that the file
+/// still exists in the file system. After that, the operation is
+/// delegated to the file itself.
+pub(super) struct FileHandle {
+    inode: Inode,
+    filesystem: FileSystem,
+    readable: bool,
+    writable: bool,
+    append_mode: bool,
+    cursor: u64,
+    arc_file: Option<Result<Box<dyn VirtualFile + Send + Sync + 'static>>>,
+}
+
+impl Clone for FileHandle {
+    fn clone(&self) -> Self {
+        Self {
+            inode: self.inode,
+            filesystem: self.filesystem.clone(),
+            readable: self.readable,
+            writable: self.writable,
+            append_mode: self.append_mode,
+            cursor: self.cursor,
+            arc_file: None,
+        }
+    }
+}
+
+impl FileHandle {
+    pub(super) fn new(
+        inode: Inode,
+        filesystem: FileSystem,
+        readable: bool,
+        writable: bool,
+        append_mode: bool,
+        cursor: u64,
+    ) -> Self {
+        Self {
+            inode,
+            filesystem,
+            readable,
+            writable,
+            append_mode,
+            cursor,
+            arc_file: None,
+        }
+    }
+
+    fn lazy_load_arc_file_mut(&mut self) -> Result<&mut dyn VirtualFile> {
+        if self.arc_file.is_none() {
+            let fs = match self.filesystem.inner.read() {
+                Ok(fs) => fs,
+                _ => return Err(FsError::EntryNotFound),
+            };
+
+            let inode = fs.storage.get(self.inode);
+            match inode {
+                Some(Node::ArcFile(node)) => {
+                    self.arc_file.replace(
+                        node.fs
+                            .new_open_options()
+                            .read(self.readable)
+                            .write(self.writable)
+                            .append(self.append_mode)
+                            .open(node.path.as_path()),
+                    );
+                }
+                _ => return Err(FsError::EntryNotFound),
+            }
+        }
+        Ok(self
+            .arc_file
+            .as_mut()
+            .unwrap()
+            .as_mut()
+            .map_err(|err| *err)?
+            .as_mut())
+    }
+}
+
+impl VirtualFile for FileHandle {
+    fn last_accessed(&self) -> u64 {
+        let fs = match self.filesystem.inner.read() {
+            Ok(fs) => fs,
+            _ => return 0,
+        };
+
+        let inode = fs.storage.get(self.inode);
+        match inode {
+            Some(node) => node.metadata().accessed,
+            _ => 0,
+        }
+    }
+
+    fn last_modified(&self) -> u64 {
+        let fs = match self.filesystem.inner.read() {
+            Ok(fs) => fs,
+            _ => return 0,
+        };
+
+        let inode = fs.storage.get(self.inode);
+        match inode {
+            Some(node) => node.metadata().modified,
+            _ => 0,
+        }
+    }
+
+    fn created_time(&self) -> u64 {
+        let fs = match self.filesystem.inner.read() {
+            Ok(fs) => fs,
+            _ => return 0,
+        };
+
+        let inode = fs.storage.get(self.inode);
+        let node = match inode {
+            Some(node) => node,
+            _ => return 0,
+        };
+
+        node.metadata().created
+    }
+
+    fn size(&self) -> u64 {
+        let fs = match self.filesystem.inner.read() {
+            Ok(fs) => fs,
+            _ => return 0,
+        };
+
+        let inode = fs.storage.get(self.inode);
+        match inode {
+            Some(Node::File(node)) => node.file.len().try_into().unwrap_or(0),
+            Some(Node::OffloadedFile(node)) => node.file.len(),
+            Some(Node::ReadOnlyFile(node)) => node.file.len().try_into().unwrap_or(0),
+            Some(Node::CustomFile(node)) => {
+                let file = node.file.lock().unwrap();
+                file.size()
+            }
+            Some(Node::ArcFile(node)) => match self.arc_file.as_ref() {
+                Some(file) => file.as_ref().map(|file| file.size()).unwrap_or(0),
+                None => node
+                    .fs
+                    .new_open_options()
+                    .read(self.readable)
+                    .write(self.writable)
+                    .append(self.append_mode)
+                    .open(node.path.as_path())
+                    .map(|file| file.size())
+                    .unwrap_or(0),
+            },
+            _ => 0,
+        }
+    }
+
+    fn set_len(&mut self, new_size: u64) -> Result<()> {
+        let mut fs = self.filesystem.inner.write().map_err(|_| FsError::Lock)?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File(FileNode { file, metadata, .. })) => {
+                file.buffer
+                    .resize(new_size.try_into().map_err(|_| FsError::UnknownError)?, 0)?;
+                metadata.len = new_size;
+            }
+            Some(Node::OffloadedFile(OffloadedFileNode { file, metadata, .. })) => {
+                file.resize(new_size, 0);
+                metadata.len = new_size;
+            }
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                file.set_len(new_size)?;
+                node.metadata.len = new_size;
+            }
+            Some(Node::ReadOnlyFile { .. }) => return Err(FsError::PermissionDenied),
+            Some(Node::ArcFile { .. }) => {
+                drop(fs);
+                let file = self.lazy_load_arc_file_mut()?;
+                file.set_len(new_size)?;
+            }
+            _ => return Err(FsError::NotAFile),
+        }
+
+        Ok(())
+    }
+
+    fn unlink(&mut self) -> Result<()> {
+        let filesystem = self.filesystem.clone();
+        let inode = self.inode;
+
+        let (inode_of_parent, position, inode_of_file) = {
+            // Read lock.
+            let fs = filesystem.inner.read().map_err(|_| FsError::Lock)?;
+
+            // The inode of the file.
+            let inode_of_file = inode;
+
+            // Find the position of the file in the parent, and the
+            // inode of the parent.
+            let (position, inode_of_parent) = fs
+                .storage
+                .iter()
+                .find_map(|(inode_of_parent, node)| match node {
+                    Node::Directory(DirectoryNode { children, .. }) => {
+                        children.iter().enumerate().find_map(|(nth, inode)| {
+                            if inode == &inode_of_file {
+                                Some((nth, inode_of_parent))
+                            } else {
+                                None
+                            }
+                        })
+                    }
+
+                    _ => None,
+                })
+                .ok_or(FsError::BaseNotDirectory)?;
+
+            (inode_of_parent, position, inode_of_file)
+        };
+
+        {
+            // Write lock.
+            let mut fs = filesystem.inner.write().map_err(|_| FsError::Lock)?;
+
+            // Remove the file from the storage.
+            fs.storage.remove(inode_of_file);
+
+            // Remove the child from the parent directory.
+            fs.remove_child_from_node(inode_of_parent, position)?;
+        }
+
+        Ok(())
+    }
+
+    fn get_special_fd(&self) -> Option<u32> {
+        let fs = match self.filesystem.inner.read() {
+            Ok(a) => a,
+            Err(_) => {
+                return None;
+            }
+        };
+
+        let inode = fs.storage.get(self.inode);
+        match inode {
+            Some(Node::CustomFile(node)) => {
+                let file = node.file.lock().unwrap();
+                file.get_special_fd()
+            }
+            Some(Node::ArcFile(node)) => match self.arc_file.as_ref() {
+                Some(file) => file
+                    .as_ref()
+                    .map(|file| file.get_special_fd())
+                    .unwrap_or(None),
+                None => node
+                    .fs
+                    .new_open_options()
+                    .read(self.readable)
+                    .write(self.writable)
+                    .append(self.append_mode)
+                    .open(node.path.as_path())
+                    .map(|file| file.get_special_fd())
+                    .unwrap_or(None),
+            },
+            _ => None,
+        }
+    }
+
+    fn copy_reference(
+        &mut self,
+        src: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> BoxFuture<'_, std::io::Result<()>> {
+        let inner = self.filesystem.inner.clone();
+        Box::pin(async move {
+            let mut fs = inner.write().unwrap();
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(inode) => {
+                    let metadata = Metadata {
+                        ft: crate::FileType {
+                            file: true,
+                            ..Default::default()
+                        },
+                        accessed: src.last_accessed(),
+                        created: src.created_time(),
+                        modified: src.last_modified(),
+                        len: src.size(),
+                    };
+
+                    *inode = Node::CustomFile(CustomFileNode {
+                        inode: inode.inode(),
+                        name: inode.name().to_string_lossy().to_string().into(),
+                        file: Mutex::new(Box::new(CopyOnWriteFile::new(src))),
+                        metadata,
+                    });
+                    Ok(())
+                }
+                None => Err(std::io::ErrorKind::InvalidInput.into()),
+            }
+        })
+    }
+
+    fn poll_read_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        if !self.readable {
+            return Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                format!(
+                    "the file (inode `{}) doesn't have the `read` permission",
+                    self.inode
+                ),
+            )));
+        }
+
+        let mut fs =
+            self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File(node)) => {
+                let remaining = node.file.buffer.len() - (self.cursor as usize);
+                Poll::Ready(Ok(remaining))
+            }
+            Some(Node::OffloadedFile(node)) => {
+                let remaining = node.file.len() as usize - (self.cursor as usize);
+                Poll::Ready(Ok(remaining))
+            }
+            Some(Node::ReadOnlyFile(node)) => {
+                let remaining = node.file.buffer.len() - (self.cursor as usize);
+                Poll::Ready(Ok(remaining))
+            }
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                let file = Pin::new(file.as_mut());
+                file.poll_read_ready(cx)
+            }
+            Some(Node::ArcFile(_)) => {
+                drop(fs);
+                match self.lazy_load_arc_file_mut() {
+                    Ok(file) => {
+                        let file = Pin::new(file);
+                        file.poll_read_ready(cx)
+                    }
+                    Err(_) => Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ))),
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("inode `{}` doesn't match a file", self.inode),
+            ))),
+        }
+    }
+
+    fn poll_write_ready(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        if !self.readable {
+            return Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                format!(
+                    "the file (inode `{}) doesn't have the `read` permission",
+                    self.inode
+                ),
+            )));
+        }
+
+        let mut fs =
+            self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File(_)) => Poll::Ready(Ok(8192)),
+            Some(Node::OffloadedFile(_)) => Poll::Ready(Ok(8192)),
+            Some(Node::ReadOnlyFile(_)) => Poll::Ready(Ok(0)),
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                let file = Pin::new(file.as_mut());
+                file.poll_read_ready(cx)
+            }
+            Some(Node::ArcFile(_)) => {
+                drop(fs);
+                match self.lazy_load_arc_file_mut() {
+                    Ok(file) => {
+                        let file = Pin::new(file);
+                        file.poll_read_ready(cx)
+                    }
+                    Err(_) => Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ))),
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("inode `{}` doesn't match a file", self.inode),
+            ))),
+        }
+    }
+
+    fn write_from_mmap(&mut self, offset: u64, size: u64) -> std::io::Result<()> {
+        if !self.writable {
+            return Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                format!(
+                    "the file (inode `{}) doesn't have the `write` permission",
+                    self.inode
+                ),
+            ));
+        }
+
+        let mut cursor = self.cursor;
+        {
+            let mut fs = self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(Node::OffloadedFile(node)) => {
+                    node.file
+                        .write(OffloadWrite::MmapOffset { offset, size }, &mut cursor)?;
+                    node.metadata.len = node.file.len();
+                }
+                _ => {
+                    return Err(io::ErrorKind::Unsupported.into());
+                }
+            }
+        }
+        self.cursor = cursor;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test_virtual_file {
+    use crate::{mem_fs::*, FileSystem as FS};
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    macro_rules! path {
+        ($path:expr) => {
+            std::path::Path::new($path)
+        };
+    }
+
+    #[tokio::test]
+    async fn test_last_accessed() {
+        let fs = FileSystem::default();
+
+        let file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+        let last_accessed_time = file.last_accessed();
+
+        assert!(last_accessed_time > 0, "last accessed time is not zero");
+
+        sleep(Duration::from_secs(3));
+
+        let file = fs
+            .new_open_options()
+            .read(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to open a file");
+        let next_last_accessed_time = file.last_accessed();
+
+        assert!(
+            next_last_accessed_time > last_accessed_time,
+            "the last accessed time is updated"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_last_modified() {
+        let fs = FileSystem::default();
+
+        let file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(file.last_modified() > 0, "last modified time is not zero");
+    }
+
+    #[tokio::test]
+    async fn test_created_time() {
+        let fs = FileSystem::default();
+
+        let file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+        let created_time = file.created_time();
+
+        assert!(created_time > 0, "created time is not zero");
+
+        let file = fs
+            .new_open_options()
+            .read(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+        let next_created_time = file.created_time();
+
+        assert_eq!(
+            next_created_time, created_time,
+            "created time stays constant"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_size() {
+        let fs = FileSystem::default();
+
+        let file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert_eq!(file.size(), 0, "new file is empty");
+    }
+
+    #[tokio::test]
+    async fn test_set_len() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(matches!(file.set_len(7), Ok(())), "setting a new length");
+        assert_eq!(file.size(), 7, "file has a new length");
+    }
+
+    #[tokio::test]
+    async fn test_unlink() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(fs_inner.storage.len(), 2, "storage has the new file");
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1]
+                ),
+                "`/` contains `foo.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::File(FileNode {
+                        inode: 1,
+                        name,
+                        ..
+                    })) if name == "foo.txt"
+                ),
+                "`foo.txt` exists and is a file",
+            );
+        }
+
+        assert_eq!(file.unlink(), Ok(()), "unlinking the file");
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(
+                fs_inner.storage.len(),
+                1,
+                "storage no longer has the new file"
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children.is_empty()
+                ),
+                "`/` is empty",
+            );
+        }
+    }
+}
+
+impl AsyncRead for FileHandle {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        if !self.readable {
+            return Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                format!(
+                    "the file (inode `{}) doesn't have the `read` permission",
+                    self.inode
+                ),
+            )));
+        }
+
+        let mut cursor = self.cursor;
+        let ret = {
+            let mut fs = self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(Node::File(node)) => {
+                    let read = unsafe {
+                        node.file
+                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                    };
+                    if let Ok(read) = &read {
+                        unsafe { buf.assume_init(*read) };
+                        buf.advance(*read);
+                    }
+                    Poll::Ready(read.map(|_| ()))
+                }
+                Some(Node::OffloadedFile(node)) => {
+                    let read = unsafe {
+                        node.file
+                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                    };
+                    if let Ok(read) = &read {
+                        unsafe { buf.assume_init(*read) };
+                        buf.advance(*read);
+                    }
+                    Poll::Ready(read.map(|_| ()))
+                }
+                Some(Node::ReadOnlyFile(node)) => {
+                    let read = unsafe {
+                        node.file
+                            .read(std::mem::transmute(buf.unfilled_mut()), &mut cursor)
+                    };
+                    if let Ok(read) = &read {
+                        unsafe { buf.assume_init(*read) };
+                        buf.advance(*read);
+                    }
+                    Poll::Ready(read.map(|_| ()))
+                }
+                Some(Node::CustomFile(node)) => {
+                    let mut file = node.file.lock().unwrap();
+                    let file = Pin::new(file.as_mut());
+                    file.poll_read(cx, buf)
+                }
+                Some(Node::ArcFile(_)) => {
+                    drop(fs);
+                    match self.lazy_load_arc_file_mut() {
+                        Ok(file) => {
+                            let file = Pin::new(file);
+                            file.poll_read(cx, buf)
+                        }
+                        Err(_) => {
+                            return Poll::Ready(Err(io::Error::new(
+                                io::ErrorKind::NotFound,
+                                format!("inode `{}` doesn't match a file", self.inode),
+                            )))
+                        }
+                    }
+                }
+                _ => {
+                    return Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    )));
+                }
+            }
+        };
+        self.cursor = cursor;
+        ret
+    }
+}
+
+impl AsyncSeek for FileHandle {
+    fn start_seek(mut self: Pin<&mut Self>, position: io::SeekFrom) -> io::Result<()> {
+        if self.append_mode {
+            return Ok(());
+        }
+
+        let mut cursor = self.cursor;
+        let ret = {
+            let mut fs = self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(Node::File(node)) => {
+                    node.file.seek(position, &mut cursor)?;
+                    Ok(())
+                }
+                Some(Node::OffloadedFile(node)) => {
+                    node.file.seek(position, &mut cursor)?;
+                    Ok(())
+                }
+                Some(Node::ReadOnlyFile(node)) => {
+                    node.file.seek(position, &mut cursor)?;
+                    Ok(())
+                }
+                Some(Node::CustomFile(node)) => {
+                    let mut file = node.file.lock().unwrap();
+                    let file = Pin::new(file.as_mut());
+                    file.start_seek(position)
+                }
+                Some(Node::ArcFile(_)) => {
+                    drop(fs);
+                    match self.lazy_load_arc_file_mut() {
+                        Ok(file) => {
+                            let file = Pin::new(file);
+                            file.start_seek(position)
+                        }
+                        Err(_) => {
+                            return Err(io::Error::new(
+                                io::ErrorKind::NotFound,
+                                format!("inode `{}` doesn't match a file", self.inode),
+                            ));
+                        }
+                    }
+                }
+                _ => {
+                    return Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ));
+                }
+            }
+        };
+        self.cursor = cursor;
+        ret
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        // In `append` mode, it's not possible to seek in the file. In
+        // [`open(2)`](https://man7.org/linux/man-pages/man2/open.2.html),
+        // the `O_APPEND` option describes this behavior well:
+        //
+        // > Before each write(2), the file offset is positioned at
+        // > the end of the file, as if with lseek(2).  The
+        // > modification of the file offset and the write operation
+        // > are performed as a single atomic step.
+        // >
+        // > O_APPEND may lead to corrupted files on NFS filesystems
+        // > if more than one process appends data to a file at once.
+        // > This is because NFS does not support appending to a file,
+        // > so the client kernel has to simulate it, which can't be
+        // > done without a race condition.
+        if self.append_mode {
+            return Poll::Ready(Ok(0));
+        }
+
+        let mut fs =
+            self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File { .. }) => Poll::Ready(Ok(self.cursor)),
+            Some(Node::OffloadedFile { .. }) => Poll::Ready(Ok(self.cursor)),
+            Some(Node::ReadOnlyFile { .. }) => Poll::Ready(Ok(self.cursor)),
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                let file = Pin::new(file.as_mut());
+                file.poll_complete(cx)
+            }
+            Some(Node::ArcFile { .. }) => {
+                drop(fs);
+                match self.lazy_load_arc_file_mut() {
+                    Ok(file) => {
+                        let file = Pin::new(file);
+                        file.poll_complete(cx)
+                    }
+                    Err(_) => Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ))),
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("inode `{}` doesn't match a file", self.inode),
+            ))),
+        }
+    }
+}
+
+impl AsyncWrite for FileHandle {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        if !self.writable {
+            return Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::PermissionDenied,
+                format!(
+                    "the file (inode `{}) doesn't have the `write` permission",
+                    self.inode
+                ),
+            )));
+        }
+
+        let mut cursor = self.cursor;
+        let bytes_written = {
+            let mut fs = self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(Node::File(node)) => {
+                    let bytes_written = node.file.write(buf, &mut cursor)?;
+                    node.metadata.len = node.file.len().try_into().unwrap();
+                    bytes_written
+                }
+                Some(Node::OffloadedFile(node)) => {
+                    let bytes_written = node.file.write(OffloadWrite::Buffer(buf), &mut cursor)?;
+                    node.metadata.len = node.file.len();
+                    bytes_written
+                }
+                Some(Node::ReadOnlyFile(node)) => {
+                    let bytes_written = node.file.write(buf, &mut cursor)?;
+                    node.metadata.len = node.file.len().try_into().unwrap();
+                    bytes_written
+                }
+                Some(Node::CustomFile(node)) => {
+                    let mut guard = node.file.lock().unwrap();
+
+                    let file = Pin::new(guard.as_mut());
+                    if let Err(err) = file.start_seek(io::SeekFrom::Start(self.cursor)) {
+                        return Poll::Ready(Err(err));
+                    }
+
+                    let file = Pin::new(guard.as_mut());
+                    let _ = file.poll_complete(cx);
+
+                    let file = Pin::new(guard.as_mut());
+                    let bytes_written = match file.poll_write(cx, buf) {
+                        Poll::Ready(Ok(a)) => a,
+                        Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                        Poll::Pending => return Poll::Pending,
+                    };
+                    cursor += bytes_written as u64;
+                    node.metadata.len = guard.size();
+                    bytes_written
+                }
+                Some(Node::ArcFile(_)) => {
+                    drop(fs);
+                    match self.lazy_load_arc_file_mut() {
+                        Ok(file) => {
+                            let file = Pin::new(file);
+                            return file.poll_write(cx, buf);
+                        }
+                        Err(_) => {
+                            return Poll::Ready(Err(io::Error::new(
+                                io::ErrorKind::NotFound,
+                                format!("inode `{}` doesn't match a file", self.inode),
+                            )))
+                        }
+                    }
+                }
+                _ => {
+                    return Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    )))
+                }
+            }
+        };
+        self.cursor = cursor;
+        Poll::Ready(Ok(bytes_written))
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[io::IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        let mut cursor = self.cursor;
+        let ret = {
+            let mut fs = self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+            let inode = fs.storage.get_mut(self.inode);
+            match inode {
+                Some(Node::File(node)) => {
+                    let buf = bufs
+                        .iter()
+                        .find(|b| !b.is_empty())
+                        .map_or(&[][..], |b| &**b);
+                    let bytes_written = node.file.write(buf, &mut cursor)?;
+                    node.metadata.len = node.file.buffer.len() as u64;
+                    Poll::Ready(Ok(bytes_written))
+                }
+                Some(Node::OffloadedFile(node)) => {
+                    let buf = bufs
+                        .iter()
+                        .find(|b| !b.is_empty())
+                        .map_or(&[][..], |b| &**b);
+                    let bytes_written = node.file.write(OffloadWrite::Buffer(buf), &mut cursor)?;
+                    node.metadata.len = node.file.len();
+                    Poll::Ready(Ok(bytes_written))
+                }
+                Some(Node::ReadOnlyFile(node)) => {
+                    let buf = bufs
+                        .iter()
+                        .find(|b| !b.is_empty())
+                        .map_or(&[][..], |b| &**b);
+                    let bytes_written = node.file.write(buf, &mut cursor)?;
+                    node.metadata.len = node.file.buffer.len() as u64;
+                    Poll::Ready(Ok(bytes_written))
+                }
+                Some(Node::CustomFile(node)) => {
+                    let mut file = node.file.lock().unwrap();
+                    let file = Pin::new(file.as_mut());
+                    file.poll_write_vectored(cx, bufs)
+                }
+                Some(Node::ArcFile(_)) => {
+                    drop(fs);
+                    match self.lazy_load_arc_file_mut() {
+                        Ok(file) => {
+                            let file = Pin::new(file);
+                            file.poll_write_vectored(cx, bufs)
+                        }
+                        Err(_) => Poll::Ready(Err(io::Error::new(
+                            io::ErrorKind::NotFound,
+                            format!("inode `{}` doesn't match a file", self.inode),
+                        ))),
+                    }
+                }
+                _ => Poll::Ready(Err(io::Error::new(
+                    io::ErrorKind::NotFound,
+                    format!("inode `{}` doesn't match a file", self.inode),
+                ))),
+            }
+        };
+        self.cursor = cursor;
+        ret
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut fs =
+            self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File(node)) => Poll::Ready(node.file.flush()),
+            Some(Node::OffloadedFile(node)) => Poll::Ready(node.file.flush()),
+            Some(Node::ReadOnlyFile(node)) => Poll::Ready(node.file.flush()),
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                let file = Pin::new(file.as_mut());
+                file.poll_flush(cx)
+            }
+            Some(Node::ArcFile { .. }) => {
+                drop(fs);
+                match self.lazy_load_arc_file_mut() {
+                    Ok(file) => {
+                        let file = Pin::new(file);
+                        file.poll_flush(cx)
+                    }
+                    Err(_) => Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ))),
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("inode `{}` doesn't match a file", self.inode),
+            ))),
+        }
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        let mut fs =
+            self.filesystem.inner.write().map_err(|_| {
+                io::Error::new(io::ErrorKind::Other, "failed to acquire a write lock")
+            })?;
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File { .. }) => Poll::Ready(Ok(())),
+            Some(Node::OffloadedFile { .. }) => Poll::Ready(Ok(())),
+            Some(Node::ReadOnlyFile { .. }) => Poll::Ready(Ok(())),
+            Some(Node::CustomFile(node)) => {
+                let mut file = node.file.lock().unwrap();
+                let file = Pin::new(file.as_mut());
+                file.poll_shutdown(cx)
+            }
+            Some(Node::ArcFile { .. }) => {
+                drop(fs);
+                match self.lazy_load_arc_file_mut() {
+                    Ok(file) => {
+                        let file = Pin::new(file);
+                        file.poll_shutdown(cx)
+                    }
+                    Err(_) => Poll::Ready(Err(io::Error::new(
+                        io::ErrorKind::NotFound,
+                        format!("inode `{}` doesn't match a file", self.inode),
+                    ))),
+                }
+            }
+            _ => Poll::Ready(Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("inode `{}` doesn't match a file", self.inode),
+            ))),
+        }
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        let mut fs = match self.filesystem.inner.write() {
+            Ok(a) => a,
+            Err(_) => return false,
+        };
+
+        let inode = fs.storage.get_mut(self.inode);
+        match inode {
+            Some(Node::File { .. }) => false,
+            Some(Node::OffloadedFile { .. }) => false,
+            Some(Node::ReadOnlyFile { .. }) => false,
+            Some(Node::CustomFile(node)) => {
+                let file = node.file.lock().unwrap();
+                file.is_write_vectored()
+            }
+            Some(Node::ArcFile { .. }) => {
+                drop(fs);
+                match self.arc_file.as_ref() {
+                    Some(Ok(file)) => file.is_write_vectored(),
+                    _ => false,
+                }
+            }
+            _ => false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test_read_write_seek {
+    use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+
+    use crate::{mem_fs::*, FileSystem as FS};
+    use std::io;
+
+    macro_rules! path {
+        ($path:expr) => {
+            std::path::Path::new($path)
+        };
+    }
+
+    #[tokio::test]
+    async fn test_writing_at_various_positions() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foo").await, Ok(3)),
+            "writing `foo` at the end of the file",
+        );
+        assert_eq!(file.size(), 3, "checking the size of the file");
+
+        assert!(
+            matches!(file.write(b"bar").await, Ok(3)),
+            "writing `bar` at the end of the file",
+        );
+        assert_eq!(file.size(), 6, "checking the size of the file");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "seeking to 0",
+        );
+
+        assert!(
+            matches!(file.write(b"baz").await, Ok(3)),
+            "writing `baz` at the beginning of the file",
+        );
+        assert_eq!(file.size(), 6, "checking the size of the file");
+
+        assert!(
+            matches!(file.write(b"qux").await, Ok(3)),
+            "writing `qux` in the middle of the file",
+        );
+        assert_eq!(file.size(), 6, "checking the size of the file");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "seeking to 0",
+        );
+
+        let mut string = String::new();
+        assert!(
+            matches!(file.read_to_string(&mut string).await, Ok(6)),
+            "reading `bazqux`",
+        );
+        assert_eq!(string, "bazqux");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(-3)).await, Ok(3)),
+            "seeking to 3",
+        );
+
+        let mut string = String::new();
+        assert!(
+            matches!(file.read_to_string(&mut string).await, Ok(3)),
+            "reading `qux`",
+        );
+        assert_eq!(string, "qux");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::End(0)).await, Ok(6)),
+            "seeking to 6",
+        );
+
+        let mut string = String::new();
+        assert!(
+            matches!(file.read_to_string(&mut string).await, Ok(0)),
+            "reading ``",
+        );
+        assert_eq!(string, "");
+    }
+
+    #[test]
+    pub fn writing_to_middle() {
+        fn assert_contents(file: &File, expected: &[u8]) {
+            let mut buf = vec![0; expected.len() + 1];
+            let mut cursor = 0;
+            let read = file.read(buf.as_mut(), &mut cursor).unwrap();
+            assert_eq!(read, expected.len(), "Must have the same amount of data");
+            assert_eq!(buf[0..expected.len()], *expected);
+        }
+
+        let mut file = File::new(None);
+
+        let mut cursor = 0;
+
+        // Write to empty file
+        file.write(b"hello, world.", &mut cursor).unwrap();
+        assert_eq!(cursor, 13);
+        assert_contents(&file, b"hello, world.");
+
+        // Write to end of file
+        file.write(b"goodbye!", &mut cursor).unwrap();
+        assert_eq!(cursor, 21);
+        assert_contents(&file, b"hello, world.goodbye!");
+
+        // Write to middle of file
+        cursor = 5;
+        file.write(b"BOOM", &mut cursor).unwrap();
+        assert_eq!(cursor, 9);
+        assert_contents(&file, b"helloBOOMrld.goodbye!");
+
+        // Write to middle of file until last byte
+        cursor = 17;
+        file.write(b"BANG", &mut cursor).unwrap();
+        assert_eq!(cursor, 21);
+        assert_contents(&file, b"helloBOOMrld.goodBANG");
+
+        // Write to middle past end of file
+        cursor = 17;
+        file.write(b"OUCH!", &mut cursor).unwrap();
+        assert_eq!(cursor, 22);
+        assert_contents(&file, b"helloBOOMrld.goodOUCH!");
+    }
+
+    #[tokio::test]
+    async fn test_reading() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(fs.metadata(path!("/foo.txt")), Ok(Metadata { len: 0, .. })),
+            "checking the `metadata.len` is 0",
+        );
+        assert!(
+            matches!(file.write(b"foobarbazqux").await, Ok(12)),
+            "writing `foobarbazqux`",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "seeking to 0",
+        );
+
+        let mut buffer = [0; 6];
+        assert!(
+            matches!(file.read(&mut buffer[..]).await, Ok(6)),
+            "reading 6 bytes",
+        );
+        assert_eq!(buffer, b"foobar"[..], "checking the 6 bytes");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "seeking to 0",
+        );
+
+        let mut buffer = [0; 16];
+        assert!(
+            matches!(file.read(&mut buffer[..]).await, Ok(12)),
+            "reading more bytes than available",
+        );
+        assert_eq!(buffer[..12], b"foobarbazqux"[..], "checking the 12 bytes");
+        assert!(
+            matches!(fs.metadata(path!("/foo.txt")), Ok(Metadata { len: 12, .. })),
+            "checking the `metadata.len` is 0",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_reading_to_the_end() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foobarbazqux").await, Ok(12)),
+            "writing `foobarbazqux`",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "seeking to 0",
+        );
+
+        let mut buffer = Vec::new();
+        assert!(
+            matches!(file.read_to_end(&mut buffer).await, Ok(12)),
+            "reading all bytes",
+        );
+        assert_eq!(buffer, b"foobarbazqux"[..], "checking all the bytes");
+    }
+
+    #[tokio::test]
+    async fn test_reading_to_string() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foobarbazqux").await, Ok(12)),
+            "writing `foobarbazqux`",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(6)).await, Ok(6)),
+            "seeking to 0",
+        );
+
+        let mut string = String::new();
+        assert!(
+            matches!(file.read_to_string(&mut string).await, Ok(6)),
+            "reading a string",
+        );
+        assert_eq!(string, "bazqux", "checking the string");
+    }
+
+    #[tokio::test]
+    async fn test_reading_exact_buffer() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foobarbazqux").await, Ok(12)),
+            "writing `foobarbazqux`",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(6)).await, Ok(6)),
+            "seeking to 0",
+        );
+
+        let mut buffer = [0; 16];
+        assert!(
+            matches!(file.read_exact(&mut buffer).await, Err(_)),
+            "failing to read an exact buffer",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::End(-5)).await, Ok(7)),
+            "seeking to 7",
+        );
+
+        let mut buffer = [0; 3];
+        assert!(
+            matches!(file.read_exact(&mut buffer).await, Ok(_)),
+            "failing to read an exact buffer",
+        );
+    }
+}
+
+impl fmt::Debug for FileHandle {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("FileHandle")
+            .field("inode", &self.inode)
+            .field("readable", &self.readable)
+            .field("writable", &self.writable)
+            .finish()
+    }
+}
+
+/// The real file! It is simply a buffer of bytes with a cursor that
+/// represents a read/write position in the buffer.
+#[derive(Debug)]
+pub(super) struct File {
+    buffer: TrackedVec,
+}
+
+impl File {
+    pub(super) fn new(limiter: Option<crate::limiter::DynFsMemoryLimiter>) -> Self {
+        Self {
+            buffer: TrackedVec::new(limiter),
+        }
+    }
+
+    pub(super) fn truncate(&mut self) {
+        self.buffer.clear();
+    }
+
+    pub(super) fn len(&self) -> usize {
+        self.buffer.len()
+    }
+}
+
+impl File {
+    pub fn read(&self, buf: &mut [u8], cursor: &mut u64) -> io::Result<usize> {
+        let cur_pos = *cursor as usize;
+        let max_to_read = cmp::min(self.buffer.len() - cur_pos, buf.len());
+        let data_to_copy = &self.buffer[cur_pos..][..max_to_read];
+
+        // SAFETY: `buf[..max_to_read]` and `data_to_copy` have the same size, due to
+        // how `max_to_read` is computed.
+        buf[..max_to_read].copy_from_slice(data_to_copy);
+
+        *cursor += max_to_read as u64;
+
+        Ok(max_to_read)
+    }
+}
+
+impl File {
+    pub fn seek(&self, position: io::SeekFrom, cursor: &mut u64) -> io::Result<u64> {
+        let to_err = |_| io::ErrorKind::InvalidInput;
+
+        // Calculate the next cursor.
+        let next_cursor: i64 = match position {
+            // Calculate from the beginning, so `0 + offset`.
+            io::SeekFrom::Start(offset) => offset.try_into().map_err(to_err)?,
+
+            // Calculate from the end, so `buffer.len() + offset`.
+            io::SeekFrom::End(offset) => {
+                TryInto::<i64>::try_into(self.buffer.len()).map_err(to_err)? + offset
+            }
+
+            // Calculate from the current cursor, so `cursor + offset`.
+            io::SeekFrom::Current(offset) => {
+                TryInto::<i64>::try_into(*cursor).map_err(to_err)? + offset
+            }
+        };
+
+        // It's an error to seek before byte 0.
+        if next_cursor < 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "seeking before the byte 0",
+            ));
+        }
+
+        // In this implementation, it's an error to seek beyond the
+        // end of the buffer.
+        let next_cursor = next_cursor.try_into().map_err(to_err)?;
+        *cursor = cmp::min(self.buffer.len() as u64, next_cursor);
+
+        let cursor = *cursor;
+        Ok(cursor)
+    }
+}
+
+impl File {
+    pub fn write(&mut self, buf: &[u8], cursor: &mut u64) -> io::Result<usize> {
+        let position = *cursor as usize;
+
+        if position + buf.len() > self.buffer.len() {
+            // Writing past the end of the current buffer, must reallocate
+            let len_after_end = (position + buf.len()) - self.buffer.len();
+            let let_to_end = buf.len() - len_after_end;
+            self.buffer[position..position + let_to_end].copy_from_slice(&buf[0..let_to_end]);
+            self.buffer.extend_from_slice(&buf[let_to_end..buf.len()])?;
+        } else {
+            self.buffer[position..position + buf.len()].copy_from_slice(buf);
+        }
+
+        *cursor += buf.len() as u64;
+
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+/// Read only file that uses copy-on-write
+#[derive(Debug)]
+pub(super) struct ReadOnlyFile {
+    buffer: Cow<'static, [u8]>,
+}
+
+impl ReadOnlyFile {
+    pub(super) fn new(buffer: Cow<'static, [u8]>) -> Self {
+        Self { buffer }
+    }
+
+    pub(super) fn len(&self) -> usize {
+        self.buffer.len()
+    }
+}
+
+impl ReadOnlyFile {
+    pub fn read(&self, buf: &mut [u8], cursor: &mut u64) -> io::Result<usize> {
+        let cur_pos = *cursor as usize;
+        let max_to_read = cmp::min(self.buffer.len() - cur_pos, buf.len());
+        let data_to_copy = &self.buffer[cur_pos..][..max_to_read];
+
+        // SAFETY: `buf[..max_to_read]` and `data_to_copy` have the same size, due to
+        // how `max_to_read` is computed.
+        buf[..max_to_read].copy_from_slice(data_to_copy);
+
+        *cursor += max_to_read as u64;
+
+        Ok(max_to_read)
+    }
+}
+
+impl ReadOnlyFile {
+    pub fn seek(&self, _position: io::SeekFrom, _cursor: &mut u64) -> io::Result<u64> {
+        Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            "file is read-only",
+        ))
+    }
+}
+
+impl ReadOnlyFile {
+    pub fn write(&mut self, _buf: &[u8], _cursor: &mut u64) -> io::Result<usize> {
+        Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            "file is read-only",
+        ))
+    }
+
+    pub fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file_opener.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file_opener.rs
new file mode 100644
index 0000000..f2a7da5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/file_opener.rs
@@ -0,0 +1,799 @@
+use super::filesystem::InodeResolution;
+use super::*;
+use crate::{FileType, FsError, Metadata, OpenOptionsConfig, Result, VirtualFile};
+use std::borrow::Cow;
+use std::path::Path;
+use tracing::*;
+
+impl FileSystem {
+    /// Inserts a readonly file into the file system that uses copy-on-write
+    /// (this is required for zero-copy creation of the same file)
+    pub fn insert_ro_file(&self, path: &Path, contents: Cow<'static, [u8]>) -> Result<()> {
+        let _ = crate::FileSystem::remove_file(self, path);
+        let (inode_of_parent, maybe_inode_of_file, name_of_file) = self.insert_inode(path)?;
+
+        let inode_of_parent = match inode_of_parent {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(..) => {
+                return Err(FsError::InvalidInput);
+            }
+        };
+
+        match maybe_inode_of_file {
+            // The file already exists, then it can not be inserted.
+            Some(_inode_of_file) => return Err(FsError::AlreadyExists),
+
+            // The file doesn't already exist; it's OK to create it if
+            None => {
+                // Write lock.
+                let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                let file = ReadOnlyFile::new(contents);
+                let file_len = file.len() as u64;
+
+                // Creating the file in the storage.
+                let inode_of_file = fs.storage.vacant_entry().key();
+                let real_inode_of_file = fs.storage.insert(Node::ReadOnlyFile(ReadOnlyFileNode {
+                    inode: inode_of_file,
+                    name: name_of_file,
+                    file,
+                    metadata: {
+                        let time = time();
+
+                        Metadata {
+                            ft: FileType {
+                                file: true,
+                                ..Default::default()
+                            },
+                            accessed: time,
+                            created: time,
+                            modified: time,
+                            len: file_len,
+                        }
+                    },
+                }));
+
+                assert_eq!(
+                    inode_of_file, real_inode_of_file,
+                    "new file inode should have been correctly calculated",
+                );
+
+                // Adding the new directory to its parent.
+                fs.add_child_to_node(inode_of_parent, inode_of_file)?;
+
+                inode_of_file
+            }
+        };
+        Ok(())
+    }
+
+    /// Inserts a arc file into the file system that references another file
+    /// in another file system (does not copy the real data)
+    pub fn insert_arc_file_at(
+        &self,
+        target_path: PathBuf,
+        fs: Arc<dyn crate::FileSystem + Send + Sync>,
+        source_path: PathBuf,
+    ) -> Result<()> {
+        let _ = crate::FileSystem::remove_file(self, target_path.as_path());
+        let (inode_of_parent, maybe_inode_of_file, name_of_file) =
+            self.insert_inode(target_path.as_path())?;
+
+        let inode_of_parent = match inode_of_parent {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(..) => {
+                return Err(FsError::InvalidInput);
+            }
+        };
+
+        match maybe_inode_of_file {
+            // The file already exists, then it can not be inserted.
+            Some(_inode_of_file) => return Err(FsError::AlreadyExists),
+
+            // The file doesn't already exist; it's OK to create it if
+            None => {
+                // Write lock.
+                let mut fs_lock = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                // Read the metadata or generate a dummy one
+                let meta = match fs.metadata(&target_path) {
+                    Ok(meta) => meta,
+                    _ => {
+                        let time = time();
+                        Metadata {
+                            ft: FileType {
+                                file: true,
+                                ..Default::default()
+                            },
+                            accessed: time,
+                            created: time,
+                            modified: time,
+                            len: 0,
+                        }
+                    }
+                };
+
+                // Creating the file in the storage.
+                let inode_of_file = fs_lock.storage.vacant_entry().key();
+                let real_inode_of_file = fs_lock.storage.insert(Node::ArcFile(ArcFileNode {
+                    inode: inode_of_file,
+                    name: name_of_file,
+                    fs,
+                    path: source_path,
+                    metadata: meta,
+                }));
+
+                assert_eq!(
+                    inode_of_file, real_inode_of_file,
+                    "new file inode should have been correctly calculated",
+                );
+
+                // Adding the new directory to its parent.
+                fs_lock.add_child_to_node(inode_of_parent, inode_of_file)?;
+
+                inode_of_file
+            }
+        };
+        Ok(())
+    }
+
+    /// Inserts a arc file into the file system that references another file
+    /// in another file system (does not copy the real data)
+    pub fn insert_arc_file(
+        &self,
+        target_path: PathBuf,
+        fs: Arc<dyn crate::FileSystem + Send + Sync>,
+    ) -> Result<()> {
+        self.insert_arc_file_at(target_path.clone(), fs, target_path)
+    }
+
+    /// Inserts a arc directory into the file system that references another file
+    /// in another file system (does not copy the real data)
+    pub fn insert_arc_directory_at(
+        &self,
+        target_path: PathBuf,
+        other: Arc<dyn crate::FileSystem + Send + Sync>,
+        source_path: PathBuf,
+    ) -> Result<()> {
+        let _ = crate::FileSystem::remove_dir(self, target_path.as_path());
+        let (inode_of_parent, maybe_inode_of_file, name_of_file) =
+            self.insert_inode(target_path.as_path())?;
+
+        let inode_of_parent = match inode_of_parent {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(..) => {
+                return Err(FsError::InvalidInput);
+            }
+        };
+
+        match maybe_inode_of_file {
+            // The file already exists, then it can not be inserted.
+            Some(_inode_of_file) => return Err(FsError::AlreadyExists),
+
+            // The file doesn't already exist; it's OK to create it if
+            None => {
+                // Write lock.
+                let mut fs_lock = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                // Creating the file in the storage.
+                let inode_of_file = fs_lock.storage.vacant_entry().key();
+                let real_inode_of_file =
+                    fs_lock.storage.insert(Node::ArcDirectory(ArcDirectoryNode {
+                        inode: inode_of_file,
+                        name: name_of_file,
+                        fs: other,
+                        path: source_path,
+                        metadata: {
+                            let time = time();
+                            Metadata {
+                                ft: FileType {
+                                    file: true,
+                                    ..Default::default()
+                                },
+                                accessed: time,
+                                created: time,
+                                modified: time,
+                                len: 0,
+                            }
+                        },
+                    }));
+
+                assert_eq!(
+                    inode_of_file, real_inode_of_file,
+                    "new file inode should have been correctly calculated",
+                );
+
+                // Adding the new directory to its parent.
+                fs_lock.add_child_to_node(inode_of_parent, inode_of_file)?;
+
+                inode_of_file
+            }
+        };
+        Ok(())
+    }
+
+    /// Inserts a arc directory into the file system that references another file
+    /// in another file system (does not copy the real data)
+    pub fn insert_arc_directory(
+        &self,
+        target_path: PathBuf,
+        other: Arc<dyn crate::FileSystem + Send + Sync>,
+    ) -> Result<()> {
+        self.insert_arc_directory_at(target_path.clone(), other, target_path)
+    }
+
+    /// Inserts a arc file into the file system that references another file
+    /// in another file system (does not copy the real data)
+    pub fn insert_device_file(
+        &self,
+        path: PathBuf,
+        file: Box<dyn crate::VirtualFile + Send + Sync>,
+    ) -> Result<()> {
+        let _ = crate::FileSystem::remove_file(self, path.as_path());
+        let (inode_of_parent, maybe_inode_of_file, name_of_file) =
+            self.insert_inode(path.as_path())?;
+
+        let inode_of_parent = match inode_of_parent {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(..) => {
+                // TODO: should remove the inode again!
+                return Err(FsError::InvalidInput);
+            }
+        };
+
+        if let Some(_inode_of_file) = maybe_inode_of_file {
+            // TODO: restore previous inode?
+            return Err(FsError::AlreadyExists);
+        }
+        // Write lock.
+        let mut fs_lock = self.inner.write().map_err(|_| FsError::Lock)?;
+
+        // Creating the file in the storage.
+        let inode_of_file = fs_lock.storage.vacant_entry().key();
+        let real_inode_of_file = fs_lock.storage.insert(Node::CustomFile(CustomFileNode {
+            inode: inode_of_file,
+            name: name_of_file,
+            file: Mutex::new(file),
+            metadata: {
+                let time = time();
+                Metadata {
+                    ft: FileType {
+                        file: true,
+                        ..Default::default()
+                    },
+                    accessed: time,
+                    created: time,
+                    modified: time,
+                    len: 0,
+                }
+            },
+        }));
+
+        assert_eq!(
+            inode_of_file, real_inode_of_file,
+            "new file inode should have been correctly calculated",
+        );
+
+        // Adding the new directory to its parent.
+        fs_lock.add_child_to_node(inode_of_parent, inode_of_file)?;
+
+        Ok(())
+    }
+
+    fn insert_inode(
+        &self,
+        path: &Path,
+    ) -> Result<(InodeResolution, Option<InodeResolution>, OsString)> {
+        // Read lock.
+        let fs = self.inner.read().map_err(|_| FsError::Lock)?;
+
+        // Check the path has a parent.
+        let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+
+        // Check the file name.
+        let name_of_file = path
+            .file_name()
+            .ok_or(FsError::InvalidInput)?
+            .to_os_string();
+
+        // Find the parent inode.
+        let inode_of_parent = match fs.inode_of_parent(parent_of_path)? {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(fs, parent_path) => {
+                return Ok((
+                    InodeResolution::Redirect(fs, parent_path),
+                    None,
+                    name_of_file,
+                ));
+            }
+        };
+
+        // Find the inode of the file if it exists.
+        let maybe_inode_of_file = fs
+            .as_parent_get_position_and_inode_of_file(inode_of_parent, &name_of_file)?
+            .map(|(_nth, inode)| inode);
+
+        Ok((
+            InodeResolution::Found(inode_of_parent),
+            maybe_inode_of_file,
+            name_of_file,
+        ))
+    }
+}
+
+impl crate::FileOpener for FileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        debug!(path=%path.display(), "open");
+
+        let read = conf.read();
+        let mut write = conf.write();
+        let append = conf.append();
+        let mut truncate = conf.truncate();
+        let mut create = conf.create();
+        let create_new = conf.create_new();
+
+        // If `create_new` is used, `create` and `truncate ` are ignored.
+        if create_new {
+            create = false;
+            truncate = false;
+        }
+
+        // To truncate a file, `write` must be used.
+        if truncate && !write {
+            return Err(FsError::PermissionDenied);
+        }
+
+        // `append` is semantically equivalent to `write` + `append`
+        // but let's keep them exclusive.
+        if append {
+            write = false;
+        }
+
+        let (inode_of_parent, maybe_inode_of_file, name_of_file) = self.insert_inode(path)?;
+
+        let inode_of_parent = match inode_of_parent {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(fs, mut parent_path) => {
+                parent_path.push(name_of_file);
+                return fs
+                    .new_open_options()
+                    .options(conf.clone())
+                    .open(parent_path);
+            }
+        };
+
+        let mut cursor = 0u64;
+        let inode_of_file = match maybe_inode_of_file {
+            // The file already exists, and a _new_ one _must_ be
+            // created; it's not OK.
+            Some(_inode_of_file) if create_new => return Err(FsError::AlreadyExists),
+
+            // The file already exists; it's OK.
+            Some(inode_of_file) => {
+                let inode_of_file = match inode_of_file {
+                    InodeResolution::Found(a) => a,
+                    InodeResolution::Redirect(fs, path) => {
+                        return fs.new_open_options().options(conf.clone()).open(path);
+                    }
+                };
+
+                // Write lock.
+                let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                let inode = fs.storage.get_mut(inode_of_file);
+                match inode {
+                    Some(Node::File(FileNode { metadata, file, .. })) => {
+                        // Update the accessed time.
+                        metadata.accessed = time();
+
+                        // Truncate if needed.
+                        if truncate {
+                            file.truncate();
+                            metadata.len = 0;
+                        }
+
+                        // Move the cursor to the end if needed.
+                        if append {
+                            cursor = file.len() as u64;
+                        }
+                    }
+
+                    Some(Node::OffloadedFile(OffloadedFileNode { metadata, file, .. })) => {
+                        // Update the accessed time.
+                        metadata.accessed = time();
+
+                        // Truncate if needed.
+                        if truncate {
+                            file.truncate();
+                            metadata.len = 0;
+                        }
+
+                        // Move the cursor to the end if needed.
+                        if append {
+                            cursor = file.len();
+                        }
+                    }
+
+                    Some(Node::ReadOnlyFile(node)) => {
+                        // Update the accessed time.
+                        node.metadata.accessed = time();
+
+                        // Truncate if needed.
+                        if truncate || append {
+                            return Err(FsError::PermissionDenied);
+                        }
+                    }
+
+                    Some(Node::CustomFile(node)) => {
+                        // Update the accessed time.
+                        node.metadata.accessed = time();
+
+                        // Truncate if needed.
+                        let mut file = node.file.lock().unwrap();
+                        if truncate {
+                            file.set_len(0)?;
+                            node.metadata.len = 0;
+                        }
+
+                        // Move the cursor to the end if needed.
+                        if append {
+                            cursor = file.size();
+                        }
+                    }
+
+                    Some(Node::ArcFile(node)) => {
+                        // Update the accessed time.
+                        node.metadata.accessed = time();
+
+                        let mut file = node
+                            .fs
+                            .new_open_options()
+                            .read(read)
+                            .write(write)
+                            .append(append)
+                            .truncate(truncate)
+                            .create(create)
+                            .create_new(create_new)
+                            .open(node.path.as_path())?;
+
+                        // Truncate if needed.
+                        if truncate {
+                            file.set_len(0)?;
+                            node.metadata.len = 0;
+                        }
+
+                        // Move the cursor to the end if needed.
+                        if append {
+                            cursor = file.size();
+                        }
+                    }
+
+                    None => return Err(FsError::EntryNotFound),
+                    _ => return Err(FsError::NotAFile),
+                }
+
+                inode_of_file
+            }
+
+            // The file doesn't already exist; it's OK to create it if:
+            // 1. `create_new` is used with `write` or `append`,
+            // 2. `create` is used with `write` or `append`.
+            None if (create_new || create) && (create_new || write || append) => {
+                // Write lock.
+                let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                let metadata = {
+                    let time = time();
+                    Metadata {
+                        ft: FileType {
+                            file: true,
+                            ..Default::default()
+                        },
+                        accessed: time,
+                        created: time,
+                        modified: time,
+                        len: 0,
+                    }
+                };
+                let inode_of_file = fs.storage.vacant_entry().key();
+
+                // We might be in optimized mode
+                let file = if let Some(offload) = fs.backing_offload.clone() {
+                    let file = OffloadedFile::new(fs.limiter.clone(), offload);
+                    Node::OffloadedFile(OffloadedFileNode {
+                        inode: inode_of_file,
+                        name: name_of_file,
+                        file,
+                        metadata,
+                    })
+                } else {
+                    let file = File::new(fs.limiter.clone());
+                    Node::File(FileNode {
+                        inode: inode_of_file,
+                        name: name_of_file,
+                        file,
+                        metadata,
+                    })
+                };
+
+                // Creating the file in the storage.
+                let real_inode_of_file = fs.storage.insert(file);
+
+                assert_eq!(
+                    inode_of_file, real_inode_of_file,
+                    "new file inode should have been correctly calculated",
+                );
+
+                // Adding the new directory to its parent.
+                fs.add_child_to_node(inode_of_parent, inode_of_file)?;
+
+                inode_of_file
+            }
+
+            None if (create_new || create) => return Err(FsError::PermissionDenied),
+
+            None => return Err(FsError::EntryNotFound),
+        };
+
+        Ok(Box::new(FileHandle::new(
+            inode_of_file,
+            self.clone(),
+            read,
+            write || append || truncate,
+            append,
+            cursor,
+        )))
+    }
+}
+
+#[cfg(test)]
+mod test_file_opener {
+    use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+
+    use crate::{mem_fs::*, FileSystem as FS, FsError};
+    use std::io;
+
+    macro_rules! path {
+        ($path:expr) => {
+            std::path::Path::new($path)
+        };
+    }
+
+    #[tokio::test]
+    async fn test_create_new_file() {
+        let fs = FileSystem::default();
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Ok(_),
+            ),
+            "creating a new file",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(fs_inner.storage.len(), 2, "storage has the new file");
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1]
+                ),
+                "`/` contains `foo.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::File(FileNode {
+                        inode: 1,
+                        name,
+                        ..
+                    })) if name == "foo.txt"
+                ),
+                "`foo.txt` exists and is a file",
+            );
+        }
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Err(FsError::AlreadyExists)
+            ),
+            "creating a new file that already exist",
+        );
+
+        assert_eq!(
+            fs.new_open_options()
+                .write(true)
+                .create_new(true)
+                .open(path!("/foo/bar.txt"))
+                .map(|_| ()),
+            Err(FsError::EntryNotFound),
+            "creating a file in a directory that doesn't exist",
+        );
+
+        assert_eq!(fs.remove_file(path!("/foo.txt")), Ok(()), "removing a file");
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(false)
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Ok(_),
+            ),
+            "creating a file without the `write` option",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_truncate_a_read_only_file() {
+        let fs = FileSystem::default();
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(false)
+                    .truncate(true)
+                    .open(path!("/foo.txt")),
+                Err(FsError::PermissionDenied),
+            ),
+            "truncating a read-only file",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_truncate() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foobar").await, Ok(6)),
+            "writing `foobar` at the end of the file",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(0)).await, Ok(6)),
+            "checking the current position is 6",
+        );
+        assert!(
+            matches!(file.seek(io::SeekFrom::End(0)).await, Ok(6)),
+            "checking the size is 6",
+        );
+
+        let mut file = fs
+            .new_open_options()
+            .write(true)
+            .truncate(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to open + truncate `foo.txt`");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(0)).await, Ok(0)),
+            "checking the current position is 0",
+        );
+        assert!(
+            matches!(file.seek(io::SeekFrom::End(0)).await, Ok(0)),
+            "checking the size is 0",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_append() {
+        let fs = FileSystem::default();
+
+        let mut file = fs
+            .new_open_options()
+            .write(true)
+            .create_new(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to create a new file");
+
+        assert!(
+            matches!(file.write(b"foobar").await, Ok(6)),
+            "writing `foobar` at the end of the file",
+        );
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(0)).await, Ok(6)),
+            "checking the current position is 6",
+        );
+        assert!(
+            matches!(file.seek(io::SeekFrom::End(0)).await, Ok(6)),
+            "checking the size is 6",
+        );
+
+        let mut file = fs
+            .new_open_options()
+            .append(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to open `foo.txt`");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(0)).await, Ok(0)),
+            "checking the current position in append-mode is 0",
+        );
+        assert!(
+            matches!(file.seek(io::SeekFrom::Start(0)).await, Ok(0)),
+            "trying to rewind in append-mode",
+        );
+        assert!(matches!(file.write(b"baz").await, Ok(3)), "writing `baz`");
+
+        let mut file = fs
+            .new_open_options()
+            .read(true)
+            .open(path!("/foo.txt"))
+            .expect("failed to open `foo.txt");
+
+        assert!(
+            matches!(file.seek(io::SeekFrom::Current(0)).await, Ok(0)),
+            "checking the current position is read-mode is 0",
+        );
+
+        let mut string = String::new();
+        assert!(
+            matches!(file.read_to_string(&mut string).await, Ok(9)),
+            "reading the entire `foo.txt` file",
+        );
+        assert_eq!(
+            string, "foobarbaz",
+            "checking append-mode is ignoring seek operations",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_opening_a_file_that_already_exists() {
+        let fs = FileSystem::default();
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Ok(_),
+            ),
+            "creating a _new_ file",
+        );
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Err(FsError::AlreadyExists),
+            ),
+            "creating a _new_ file that already exists",
+        );
+
+        assert!(
+            matches!(
+                fs.new_open_options().read(true).open(path!("/foo.txt")),
+                Ok(_),
+            ),
+            "opening a file that already exists",
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/filesystem.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/filesystem.rs
new file mode 100644
index 0000000..c1d72bc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/filesystem.rs
@@ -0,0 +1,1875 @@
+//! This module contains the [`FileSystem`] type itself.
+
+use self::offloaded_file::OffloadBackingStore;
+
+use super::*;
+use crate::{DirEntry, FileSystem as _, FileType, FsError, Metadata, OpenOptions, ReadDir, Result};
+use futures::future::BoxFuture;
+use slab::Slab;
+use std::collections::VecDeque;
+use std::convert::identity;
+use std::ffi::OsString;
+use std::fmt;
+use std::path::{Component, Path, PathBuf};
+use std::sync::{Arc, RwLock};
+
+/// The in-memory file system!
+///
+/// This `FileSystem` type can be cloned, it's a light copy of the
+/// `FileSystemInner` (which is behind a `Arc` + `RwLock`).
+#[derive(Clone, Default)]
+pub struct FileSystem {
+    pub(super) inner: Arc<RwLock<FileSystemInner>>,
+}
+
+impl FileSystem {
+    pub fn set_memory_limiter(&self, limiter: crate::limiter::DynFsMemoryLimiter) {
+        self.inner.write().unwrap().limiter = Some(limiter);
+    }
+
+    pub fn new_open_options_ext(&self) -> &FileSystem {
+        self
+    }
+
+    /// Uses a mmap'ed file as a cache for file data thus removing the
+    /// need to copy the data into memory.
+    ///
+    /// This is especially important for journals as it means that the
+    /// data stored within the journals does not need to be copied
+    /// into memory, for very large journals this would otherwise be
+    /// a problem.
+    pub fn with_backing_offload(self, buffer: OffloadBackingStore) -> Result<Self> {
+        let mut lock = self.inner.write().map_err(|_| FsError::Lock)?;
+        lock.backing_offload.replace(buffer);
+        drop(lock);
+        Ok(self)
+    }
+
+    /// Canonicalize a path without validating that it actually exists.
+    pub fn canonicalize_unchecked(&self, path: &Path) -> Result<PathBuf> {
+        let lock = self.inner.read().map_err(|_| FsError::Lock)?;
+        lock.canonicalize_without_inode(path)
+    }
+
+    /// Merge all items from a given source path (directory) of a different file
+    /// system into this file system.
+    ///
+    /// Individual files and directories of the given path are mounted.
+    ///
+    /// This function is not recursive, only the items in the source_path are
+    /// mounted.
+    ///
+    /// See [`Self::union`] for mounting all inodes recursively.
+    pub fn mount_directory_entries(
+        &self,
+        target_path: &Path,
+        other: &Arc<dyn crate::FileSystem + Send + Sync>,
+        mut source_path: &Path,
+    ) -> Result<()> {
+        let fs_lock = self.inner.read().map_err(|_| FsError::Lock)?;
+
+        if cfg!(windows) {
+            // We need to take some care here because
+            // canonicalize_without_inode() doesn't accept Windows paths that
+            // start with a prefix (drive letters, UNC paths, etc.). If we
+            // somehow get one of those paths, we'll automatically trim it away.
+            let mut components = source_path.components();
+
+            if let Some(Component::Prefix(_)) = components.next() {
+                source_path = components.as_path();
+            }
+        }
+
+        let (_target_path, root_inode) = match fs_lock.canonicalize(target_path) {
+            Ok((p, InodeResolution::Found(inode))) => (p, inode),
+            Ok((_p, InodeResolution::Redirect(..))) => {
+                return Err(FsError::AlreadyExists);
+            }
+            Err(_) => {
+                // Root directory does not exist, so we can just mount.
+                return self.mount(target_path.to_path_buf(), other, source_path.to_path_buf());
+            }
+        };
+
+        let _root_node = match fs_lock.storage.get(root_inode).unwrap() {
+            Node::Directory(dir) => dir,
+            _ => {
+                return Err(FsError::AlreadyExists);
+            }
+        };
+
+        let source_path = fs_lock.canonicalize_without_inode(source_path)?;
+
+        std::mem::drop(fs_lock);
+
+        let source = other.read_dir(&source_path)?;
+        for entry in source.data {
+            let meta = entry.metadata?;
+
+            let entry_target_path = target_path.join(entry.path.file_name().unwrap());
+
+            if meta.is_file() {
+                self.insert_arc_file_at(entry_target_path, other.clone(), entry.path)?;
+            } else if meta.is_dir() {
+                self.insert_arc_directory_at(entry_target_path, other.clone(), entry.path)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn union(&self, other: &Arc<dyn crate::FileSystem + Send + Sync>) {
+        // Iterate all the directories and files in the other filesystem
+        // and create references back to them in this filesystem
+        let mut remaining = VecDeque::new();
+        remaining.push_back(PathBuf::from("/"));
+        while let Some(next) = remaining.pop_back() {
+            if next
+                .file_name()
+                .map(|n| n.to_string_lossy().starts_with(".wh."))
+                .unwrap_or(false)
+            {
+                let rm = next.to_string_lossy();
+                let rm = &rm[".wh.".len()..];
+                let rm = PathBuf::from(rm);
+                let _ = crate::FileSystem::remove_dir(self, rm.as_path());
+                let _ = crate::FileSystem::remove_file(self, rm.as_path());
+                continue;
+            }
+            let _ = crate::FileSystem::create_dir(self, next.as_path());
+
+            let dir = match other.read_dir(next.as_path()) {
+                Ok(dir) => dir,
+                Err(_) => {
+                    // TODO: propagate errors (except NotFound)
+                    continue;
+                }
+            };
+
+            for sub_dir_res in dir {
+                let sub_dir = match sub_dir_res {
+                    Ok(sub_dir) => sub_dir,
+                    Err(_) => {
+                        // TODO: propagate errors (except NotFound)
+                        continue;
+                    }
+                };
+
+                match sub_dir.file_type() {
+                    Ok(t) if t.is_dir() => {
+                        remaining.push_back(sub_dir.path());
+                    }
+                    Ok(t) if t.is_file() => {
+                        if sub_dir.file_name().to_string_lossy().starts_with(".wh.") {
+                            let rm = next.to_string_lossy();
+                            let rm = &rm[".wh.".len()..];
+                            let rm = PathBuf::from(rm);
+                            let _ = crate::FileSystem::remove_dir(self, rm.as_path());
+                            let _ = crate::FileSystem::remove_file(self, rm.as_path());
+                            continue;
+                        }
+                        let _ = self
+                            .new_open_options_ext()
+                            .insert_arc_file(sub_dir.path(), other.clone());
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    pub fn mount(
+        &self,
+        target_path: PathBuf,
+        other: &Arc<dyn crate::FileSystem + Send + Sync>,
+        source_path: PathBuf,
+    ) -> Result<()> {
+        if crate::FileSystem::read_dir(self, target_path.as_path()).is_ok() {
+            return Err(FsError::AlreadyExists);
+        }
+
+        let (inode_of_parent, name_of_directory) = {
+            // Read lock.
+            let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+
+            // Canonicalize the path without checking the path exists,
+            // because it's about to be created.
+            let path = guard.canonicalize_without_inode(target_path.as_path())?;
+
+            // Check the path has a parent.
+            let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+
+            // Check the directory name.
+            let name_of_directory = path
+                .file_name()
+                .ok_or(FsError::InvalidInput)?
+                .to_os_string();
+
+            // Find the parent inode.
+            let inode_of_parent = match guard.inode_of_parent(parent_of_path)? {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(..) => {
+                    return Err(FsError::AlreadyExists);
+                }
+            };
+
+            (inode_of_parent, name_of_directory)
+        };
+
+        {
+            // Write lock.
+            let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+            // Creating the directory in the storage.
+            let inode_of_directory = fs.storage.vacant_entry().key();
+            let real_inode_of_directory = fs.storage.insert(Node::ArcDirectory(ArcDirectoryNode {
+                inode: inode_of_directory,
+                name: name_of_directory,
+                fs: other.clone(),
+                path: source_path,
+                metadata: {
+                    let time = time();
+
+                    Metadata {
+                        ft: FileType {
+                            dir: true,
+                            ..Default::default()
+                        },
+                        accessed: time,
+                        created: time,
+                        modified: time,
+                        len: 0,
+                    }
+                },
+            }));
+
+            assert_eq!(
+                inode_of_directory, real_inode_of_directory,
+                "new directory inode should have been correctly calculated",
+            );
+
+            // Adding the new directory to its parent.
+            fs.add_child_to_node(inode_of_parent, inode_of_directory)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl crate::FileSystem for FileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        // Read lock.
+        let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+
+        // Canonicalize the path.
+        let (path, inode_of_directory) = guard.canonicalize(path)?;
+        let inode_of_directory = match inode_of_directory {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(fs, path) => {
+                return fs.read_dir(path.as_path());
+            }
+        };
+
+        // Check it's a directory and fetch the immediate children as `DirEntry`.
+        let inode = guard.storage.get(inode_of_directory);
+        let children = match inode {
+            Some(Node::Directory(DirectoryNode { children, .. })) => children
+                .iter()
+                .filter_map(|inode| guard.storage.get(*inode))
+                .map(|node| DirEntry {
+                    path: {
+                        let mut entry_path = path.to_path_buf();
+                        entry_path.push(node.name());
+
+                        entry_path
+                    },
+                    metadata: Ok(node.metadata().clone()),
+                })
+                .collect(),
+
+            Some(Node::ArcDirectory(ArcDirectoryNode { fs, path, .. })) => {
+                return fs.read_dir(path.as_path());
+            }
+
+            _ => return Err(FsError::InvalidInput),
+        };
+
+        Ok(ReadDir::new(children))
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        if self.read_dir(path).is_ok() {
+            return Err(FsError::AlreadyExists);
+        }
+
+        let (inode_of_parent, name_of_directory) = {
+            // Read lock.
+            let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+
+            // Canonicalize the path without checking the path exists,
+            // because it's about to be created.
+            let path = guard.canonicalize_without_inode(path)?;
+
+            // Check the path has a parent.
+            let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+
+            // Check the directory name.
+            let name_of_directory = path
+                .file_name()
+                .ok_or(FsError::InvalidInput)?
+                .to_os_string();
+
+            // Find the parent inode.
+            let inode_of_parent = match guard.inode_of_parent(parent_of_path)? {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(fs, mut path) => {
+                    drop(guard);
+                    path.push(name_of_directory);
+                    return fs.create_dir(path.as_path());
+                }
+            };
+
+            (inode_of_parent, name_of_directory)
+        };
+
+        if self.read_dir(path).is_ok() {
+            return Err(FsError::AlreadyExists);
+        }
+
+        {
+            // Write lock.
+            let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+            // Creating the directory in the storage.
+            let inode_of_directory = fs.storage.vacant_entry().key();
+            let real_inode_of_directory = fs.storage.insert(Node::Directory(DirectoryNode {
+                inode: inode_of_directory,
+                name: name_of_directory,
+                children: Vec::new(),
+                metadata: {
+                    let time = time();
+
+                    Metadata {
+                        ft: FileType {
+                            dir: true,
+                            ..Default::default()
+                        },
+                        accessed: time,
+                        created: time,
+                        modified: time,
+                        len: 0,
+                    }
+                },
+            }));
+
+            assert_eq!(
+                inode_of_directory, real_inode_of_directory,
+                "new directory inode should have been correctly calculated",
+            );
+
+            // Adding the new directory to its parent.
+            fs.add_child_to_node(inode_of_parent, inode_of_directory)?;
+        }
+
+        Ok(())
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        let (inode_of_parent, position, inode_of_directory) = {
+            // Read lock.
+            let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+
+            // Canonicalize the path.
+            let (path, _) = guard.canonicalize(path)?;
+
+            // Check the path has a parent.
+            let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+
+            // Check the directory name.
+            let name_of_directory = path
+                .file_name()
+                .ok_or(FsError::InvalidInput)?
+                .to_os_string();
+
+            // Find the parent inode.
+            let inode_of_parent = match guard.inode_of_parent(parent_of_path)? {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(fs, mut parent_path) => {
+                    drop(guard);
+                    parent_path.push(name_of_directory);
+                    return fs.remove_dir(parent_path.as_path());
+                }
+            };
+
+            // Get the child index to remove in the parent node, in
+            // addition to the inode of the directory to remove.
+            let (position, inode_of_directory) = guard
+                .as_parent_get_position_and_inode_of_directory(
+                    inode_of_parent,
+                    &name_of_directory,
+                    DirectoryMustBeEmpty::Yes,
+                )?;
+
+            (inode_of_parent, position, inode_of_directory)
+        };
+
+        let inode_of_directory = match inode_of_directory {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(fs, path) => {
+                return fs.remove_dir(path.as_path());
+            }
+        };
+
+        {
+            // Write lock.
+            let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+            // Remove the directory from the storage.
+            fs.storage.remove(inode_of_directory);
+
+            // Remove the child from the parent directory.
+            fs.remove_child_from_node(inode_of_parent, position)?;
+        }
+
+        Ok(())
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async {
+            let name_of_to;
+
+            let (
+                (position_of_from, inode, inode_of_from_parent),
+                (inode_of_to_parent, name_of_to),
+                inode_dest,
+            ) = {
+                // Read lock.
+                let fs = self.inner.read().map_err(|_| FsError::Lock)?;
+
+                let from = fs.canonicalize_without_inode(from)?;
+                let to = fs.canonicalize_without_inode(to)?;
+
+                // Check the paths have parents.
+                let parent_of_from = from.parent().ok_or(FsError::BaseNotDirectory)?;
+                let parent_of_to = to.parent().ok_or(FsError::BaseNotDirectory)?;
+
+                // Check the names.
+                let name_of_from = from
+                    .file_name()
+                    .ok_or(FsError::InvalidInput)?
+                    .to_os_string();
+                name_of_to = to.file_name().ok_or(FsError::InvalidInput)?.to_os_string();
+
+                // Find the parent inodes.
+                let inode_of_from_parent = match fs.inode_of_parent(parent_of_from)? {
+                    InodeResolution::Found(a) => a,
+                    InodeResolution::Redirect(..) => {
+                        return Err(FsError::InvalidInput);
+                    }
+                };
+                let inode_of_to_parent = match fs.inode_of_parent(parent_of_to)? {
+                    InodeResolution::Found(a) => a,
+                    InodeResolution::Redirect(..) => {
+                        return Err(FsError::InvalidInput);
+                    }
+                };
+
+                // Find the inode of the dest file if it exists
+                let maybe_position_and_inode_of_file =
+                    fs.as_parent_get_position_and_inode_of_file(inode_of_to_parent, &name_of_to)?;
+
+                // Get the child indexes to update in the parent nodes, in
+                // addition to the inode of the directory to update.
+                let (position_of_from, inode) = fs
+                    .as_parent_get_position_and_inode(inode_of_from_parent, &name_of_from)?
+                    .ok_or(FsError::EntryNotFound)?;
+
+                (
+                    (position_of_from, inode, inode_of_from_parent),
+                    (inode_of_to_parent, name_of_to),
+                    maybe_position_and_inode_of_file,
+                )
+            };
+
+            let inode = match inode {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(..) => {
+                    return Err(FsError::InvalidInput);
+                }
+            };
+
+            {
+                // Write lock.
+                let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+                if let Some((position, inode_of_file)) = inode_dest {
+                    // Remove the file from the storage.
+                    match inode_of_file {
+                        InodeResolution::Found(inode_of_file) => {
+                            fs.storage.remove(inode_of_file);
+                        }
+                        InodeResolution::Redirect(..) => {
+                            return Err(FsError::InvalidInput);
+                        }
+                    }
+
+                    fs.remove_child_from_node(inode_of_to_parent, position)?;
+                }
+
+                // Update the file name, and update the modified time.
+                fs.update_node_name(inode, name_of_to)?;
+
+                // The parents are different. Let's update them.
+                if inode_of_from_parent != inode_of_to_parent {
+                    // Remove the file from its parent, and update the
+                    // modified time.
+                    fs.remove_child_from_node(inode_of_from_parent, position_of_from)?;
+
+                    // Add the file to its new parent, and update the modified
+                    // time.
+                    fs.add_child_to_node(inode_of_to_parent, inode)?;
+                }
+                // Otherwise, we need to at least update the modified time of the parent.
+                else {
+                    let mut inode = fs.storage.get_mut(inode_of_from_parent);
+                    match inode.as_mut() {
+                        Some(Node::Directory(node)) => node.metadata.modified = time(),
+                        Some(Node::ArcDirectory(node)) => node.metadata.modified = time(),
+                        _ => return Err(FsError::UnknownError),
+                    }
+                }
+            }
+
+            Ok(())
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        // Read lock.
+        let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+        match guard.inode_of(path)? {
+            InodeResolution::Found(inode) => Ok(guard
+                .storage
+                .get(inode)
+                .ok_or(FsError::UnknownError)?
+                .metadata()
+                .clone()),
+            InodeResolution::Redirect(fs, path) => {
+                drop(guard);
+                fs.metadata(path.as_path())
+            }
+        }
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        let (inode_of_parent, position, inode_of_file) = {
+            // Read lock.
+            let guard = self.inner.read().map_err(|_| FsError::Lock)?;
+
+            // Canonicalize the path.
+            let path = guard.canonicalize_without_inode(path)?;
+
+            // Check the path has a parent.
+            let parent_of_path = path.parent().ok_or(FsError::BaseNotDirectory)?;
+
+            // Check the file name.
+            let name_of_file = path
+                .file_name()
+                .ok_or(FsError::InvalidInput)?
+                .to_os_string();
+
+            // Find the parent inode.
+            let inode_of_parent = match guard.inode_of_parent(parent_of_path)? {
+                InodeResolution::Found(a) => a,
+                InodeResolution::Redirect(fs, mut parent_path) => {
+                    parent_path.push(name_of_file);
+                    return fs.remove_file(parent_path.as_path());
+                }
+            };
+
+            // Find the inode of the file if it exists, along with its position.
+            let maybe_position_and_inode_of_file =
+                guard.as_parent_get_position_and_inode_of_file(inode_of_parent, &name_of_file)?;
+
+            match maybe_position_and_inode_of_file {
+                Some((position, inode_of_file)) => (inode_of_parent, position, inode_of_file),
+                None => return Err(FsError::EntryNotFound),
+            }
+        };
+
+        let inode_of_file = match inode_of_file {
+            InodeResolution::Found(a) => a,
+            InodeResolution::Redirect(fs, path) => {
+                return fs.remove_file(path.as_path());
+            }
+        };
+
+        {
+            // Write lock.
+            let mut fs = self.inner.write().map_err(|_| FsError::Lock)?;
+
+            // Remove the file from the storage.
+            fs.storage.remove(inode_of_file);
+
+            // Remove the child from the parent directory.
+            fs.remove_child_from_node(inode_of_parent, position)?;
+        }
+
+        Ok(())
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+}
+
+impl fmt::Debug for FileSystem {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let fs: &FileSystemInner = &self.inner.read().unwrap();
+
+        fs.fmt(formatter)
+    }
+}
+
+/// The core of the file system. It contains a collection of `Node`s,
+/// indexed by their respective `Inode` in a slab.
+pub(super) struct FileSystemInner {
+    pub(super) storage: Slab<Node>,
+    pub(super) backing_offload: Option<OffloadBackingStore>,
+    pub(super) limiter: Option<crate::limiter::DynFsMemoryLimiter>,
+}
+
+#[derive(Debug)]
+pub(super) enum InodeResolution {
+    Found(Inode),
+    Redirect(Arc<dyn crate::FileSystem + Send + Sync + 'static>, PathBuf),
+}
+
+impl InodeResolution {
+    #[allow(dead_code)]
+    pub fn unwrap(&self) -> Inode {
+        match self {
+            Self::Found(a) => *a,
+            Self::Redirect(..) => {
+                panic!("failed to unwrap the inode as the resolution is a redirect");
+            }
+        }
+    }
+}
+
+impl FileSystemInner {
+    /// Get the inode associated to a path if it exists.
+    pub(super) fn inode_of(&self, path: &Path) -> Result<InodeResolution> {
+        // SAFETY: The root node always exists, so it's safe to unwrap here.
+        let mut node = self.storage.get(ROOT_INODE).unwrap();
+        let mut components = path.components();
+
+        match components.next() {
+            Some(Component::RootDir) => {}
+            _ => return Err(FsError::BaseNotDirectory),
+        }
+
+        while let Some(component) = components.next() {
+            node = match node {
+                Node::Directory(DirectoryNode { children, .. }) => children
+                    .iter()
+                    .filter_map(|inode| self.storage.get(*inode))
+                    .find(|node| node.name() == component.as_os_str())
+                    .ok_or(FsError::EntryNotFound)?,
+                Node::ArcDirectory(ArcDirectoryNode {
+                    fs, path: fs_path, ..
+                }) => {
+                    let mut path = fs_path.clone();
+                    path.push(PathBuf::from(component.as_os_str()));
+                    for component in components.by_ref() {
+                        path.push(PathBuf::from(component.as_os_str()));
+                    }
+                    return Ok(InodeResolution::Redirect(fs.clone(), path));
+                }
+                _ => return Err(FsError::BaseNotDirectory),
+            };
+        }
+
+        Ok(InodeResolution::Found(node.inode()))
+    }
+
+    /// Get the inode associated to a “parent path”. The returned
+    /// inode necessarily represents a directory.
+    pub(super) fn inode_of_parent(&self, parent_path: &Path) -> Result<InodeResolution> {
+        match self.inode_of(parent_path)? {
+            InodeResolution::Found(inode_of_parent) => {
+                // Ensure it is a directory.
+                match self.storage.get(inode_of_parent) {
+                    Some(Node::Directory(DirectoryNode { .. })) => {
+                        Ok(InodeResolution::Found(inode_of_parent))
+                    }
+                    Some(Node::ArcDirectory(ArcDirectoryNode { fs, path, .. })) => {
+                        Ok(InodeResolution::Redirect(fs.clone(), path.clone()))
+                    }
+                    _ => Err(FsError::BaseNotDirectory),
+                }
+            }
+            InodeResolution::Redirect(fs, path) => Ok(InodeResolution::Redirect(fs, path)),
+        }
+    }
+
+    /// From the inode of a parent node (so, a directory), returns the
+    /// child index of `name_of_directory` along with its inode.
+    pub(super) fn as_parent_get_position_and_inode_of_directory(
+        &self,
+        inode_of_parent: Inode,
+        name_of_directory: &OsString,
+        directory_must_be_empty: DirectoryMustBeEmpty,
+    ) -> Result<(usize, InodeResolution)> {
+        match self.storage.get(inode_of_parent) {
+            Some(Node::Directory(DirectoryNode { children, .. })) => children
+                .iter()
+                .enumerate()
+                .filter_map(|(nth, inode)| self.storage.get(*inode).map(|node| (nth, node)))
+                .find_map(|(nth, node)| match node {
+                    Node::Directory(DirectoryNode {
+                        inode,
+                        name,
+                        children,
+                        ..
+                    }) if name.as_os_str() == name_of_directory => {
+                        if directory_must_be_empty.no() || children.is_empty() {
+                            Some(Ok((nth, InodeResolution::Found(*inode))))
+                        } else {
+                            Some(Err(FsError::DirectoryNotEmpty))
+                        }
+                    }
+
+                    _ => None,
+                })
+                .ok_or(FsError::InvalidInput)
+                .and_then(identity), // flatten
+
+            Some(Node::ArcDirectory(ArcDirectoryNode {
+                fs, path: fs_path, ..
+            })) => {
+                let mut path = fs_path.clone();
+                path.push(name_of_directory);
+                Ok((0, InodeResolution::Redirect(fs.clone(), path)))
+            }
+
+            _ => Err(FsError::BaseNotDirectory),
+        }
+    }
+
+    /// From the inode of a parent node (so, a directory), returns the
+    /// child index of `name_of_file` along with its inode.
+    pub(super) fn as_parent_get_position_and_inode_of_file(
+        &self,
+        inode_of_parent: Inode,
+        name_of_file: &OsString,
+    ) -> Result<Option<(usize, InodeResolution)>> {
+        match self.storage.get(inode_of_parent) {
+            Some(Node::Directory(DirectoryNode { children, .. })) => children
+                .iter()
+                .enumerate()
+                .filter_map(|(nth, inode)| self.storage.get(*inode).map(|node| (nth, node)))
+                .find_map(|(nth, node)| match node {
+                    Node::File(FileNode { inode, name, .. })
+                    | Node::OffloadedFile(OffloadedFileNode { inode, name, .. })
+                    | Node::ReadOnlyFile(ReadOnlyFileNode { inode, name, .. })
+                    | Node::CustomFile(CustomFileNode { inode, name, .. })
+                    | Node::ArcFile(ArcFileNode { inode, name, .. })
+                        if name.as_os_str() == name_of_file =>
+                    {
+                        Some(Some((nth, InodeResolution::Found(*inode))))
+                    }
+                    _ => None,
+                })
+                .or(Some(None))
+                .ok_or(FsError::InvalidInput),
+
+            Some(Node::ArcDirectory(ArcDirectoryNode {
+                fs, path: fs_path, ..
+            })) => {
+                let mut path = fs_path.clone();
+                path.push(name_of_file);
+                Ok(Some((0, InodeResolution::Redirect(fs.clone(), path))))
+            }
+
+            _ => Err(FsError::BaseNotDirectory),
+        }
+    }
+
+    /// From the inode of a parent node (so, a directory), returns the
+    /// child index of `name_of` along with its inode, whatever the
+    /// type of inode is (directory or file).
+    fn as_parent_get_position_and_inode(
+        &self,
+        inode_of_parent: Inode,
+        name_of: &OsString,
+    ) -> Result<Option<(usize, InodeResolution)>> {
+        match self.storage.get(inode_of_parent) {
+            Some(Node::Directory(DirectoryNode { children, .. })) => children
+                .iter()
+                .enumerate()
+                .filter_map(|(nth, inode)| self.storage.get(*inode).map(|node| (nth, node)))
+                .find_map(|(nth, node)| match node {
+                    Node::File(FileNode { inode, name, .. })
+                    | Node::OffloadedFile(OffloadedFileNode { inode, name, .. })
+                    | Node::Directory(DirectoryNode { inode, name, .. })
+                    | Node::ReadOnlyFile(ReadOnlyFileNode { inode, name, .. })
+                    | Node::CustomFile(CustomFileNode { inode, name, .. })
+                    | Node::ArcFile(ArcFileNode { inode, name, .. })
+                        if name.as_os_str() == name_of =>
+                    {
+                        Some(Some((nth, InodeResolution::Found(*inode))))
+                    }
+                    _ => None,
+                })
+                .or(Some(None))
+                .ok_or(FsError::InvalidInput),
+
+            Some(Node::ArcDirectory(ArcDirectoryNode {
+                fs, path: fs_path, ..
+            })) => {
+                let mut path = fs_path.clone();
+                path.push(name_of);
+                Ok(Some((0, InodeResolution::Redirect(fs.clone(), path))))
+            }
+
+            _ => Err(FsError::BaseNotDirectory),
+        }
+    }
+
+    /// Set a new name for the node represented by `inode`.
+    pub(super) fn update_node_name(&mut self, inode: Inode, new_name: OsString) -> Result<()> {
+        let node = self.storage.get_mut(inode).ok_or(FsError::UnknownError)?;
+
+        node.set_name(new_name);
+        node.metadata_mut().modified = time();
+
+        Ok(())
+    }
+
+    /// Add a child to a directory node represented by `inode`.
+    ///
+    /// This function also updates the modified time of the directory.
+    ///
+    /// # Safety
+    ///
+    /// `inode` must represents an existing directory.
+    pub(super) fn add_child_to_node(&mut self, inode: Inode, new_child: Inode) -> Result<()> {
+        match self.storage.get_mut(inode) {
+            Some(Node::Directory(DirectoryNode {
+                children,
+                metadata: Metadata { modified, .. },
+                ..
+            })) => {
+                children.push(new_child);
+                *modified = time();
+
+                Ok(())
+            }
+            _ => Err(FsError::UnknownError),
+        }
+    }
+
+    /// Remove the child at position `position` of a directory node
+    /// represented by `inode`.
+    ///
+    /// This function also updates the modified time of the directory.
+    ///
+    /// # Safety
+    ///
+    /// `inode` must represents an existing directory.
+    pub(super) fn remove_child_from_node(&mut self, inode: Inode, position: usize) -> Result<()> {
+        match self.storage.get_mut(inode) {
+            Some(Node::Directory(DirectoryNode {
+                children,
+                metadata: Metadata { modified, .. },
+                ..
+            })) => {
+                children.remove(position);
+                *modified = time();
+
+                Ok(())
+            }
+            _ => Err(FsError::UnknownError),
+        }
+    }
+
+    /// Canonicalize a path, i.e. try to resolve to a canonical,
+    /// absolute form of the path with all intermediate components
+    /// normalized:
+    ///
+    /// * A path must starts with a root (`/`),
+    /// * A path can contain `..` or `.` components,
+    /// * A path must not contain a Windows prefix (`C:` or `\\server`),
+    /// * A normalized path exists in the file system.
+    pub(super) fn canonicalize(&self, path: &Path) -> Result<(PathBuf, InodeResolution)> {
+        let new_path = self.canonicalize_without_inode(path)?;
+        let inode = self.inode_of(&new_path)?;
+
+        Ok((new_path, inode))
+    }
+
+    /// Like `Self::canonicalize` but without returning the inode of
+    /// the path, which means that there is no guarantee that the path
+    /// exists in the file system.
+    pub(super) fn canonicalize_without_inode(&self, path: &Path) -> Result<PathBuf> {
+        let mut components = path.components();
+
+        match components.next() {
+            Some(Component::RootDir) => {}
+            _ => return Err(FsError::InvalidInput),
+        }
+
+        let mut new_path = PathBuf::with_capacity(path.as_os_str().len());
+        new_path.push("/");
+
+        for component in components {
+            match component {
+                // That's an error to get a `RootDir` a second time.
+                Component::RootDir => return Err(FsError::UnknownError),
+
+                // Nothing to do on `new_path`.
+                Component::CurDir => (),
+
+                // Pop the lastly inserted component on `new_path` if
+                // any, otherwise it's an error.
+                Component::ParentDir => {
+                    if !new_path.pop() {
+                        return Err(FsError::InvalidInput);
+                    }
+                }
+
+                // A normal
+                Component::Normal(name) => {
+                    new_path.push(name);
+                }
+
+                // We don't support Windows path prefix.
+                Component::Prefix(_) => return Err(FsError::InvalidInput),
+            }
+        }
+
+        Ok(new_path)
+    }
+}
+
+impl fmt::Debug for FileSystemInner {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            formatter,
+            "\n{inode:<8}    {ty:<4}    name",
+            inode = "inode",
+            ty = "type",
+        )?;
+
+        fn debug(
+            nodes: Vec<&Node>,
+            slf: &FileSystemInner,
+            formatter: &mut fmt::Formatter<'_>,
+            indentation: usize,
+        ) -> fmt::Result {
+            for node in nodes {
+                writeln!(
+                    formatter,
+                    "{inode:<8}    {ty:<4}   {indentation_symbol:indentation_width$}{name}",
+                    inode = node.inode(),
+                    ty = match node {
+                        Node::File { .. } => "file",
+                        Node::OffloadedFile { .. } => "offloaded-file",
+                        Node::ReadOnlyFile { .. } => "ro-file",
+                        Node::ArcFile { .. } => "arc-file",
+                        Node::CustomFile { .. } => "custom-file",
+                        Node::Directory { .. } => "dir",
+                        Node::ArcDirectory { .. } => "arc-dir",
+                    },
+                    name = node.name().to_string_lossy(),
+                    indentation_symbol = " ",
+                    indentation_width = indentation * 2 + 1,
+                )?;
+
+                if let Node::Directory(DirectoryNode { children, .. }) = node {
+                    debug(
+                        children
+                            .iter()
+                            .filter_map(|inode| slf.storage.get(*inode))
+                            .collect(),
+                        slf,
+                        formatter,
+                        indentation + 1,
+                    )?;
+                }
+            }
+
+            Ok(())
+        }
+
+        debug(
+            vec![self.storage.get(ROOT_INODE).unwrap()],
+            self,
+            formatter,
+            0,
+        )
+    }
+}
+
+impl Default for FileSystemInner {
+    fn default() -> Self {
+        let time = time();
+
+        let mut slab = Slab::new();
+        slab.insert(Node::Directory(DirectoryNode {
+            inode: ROOT_INODE,
+            name: OsString::from("/"),
+            children: Vec::new(),
+            metadata: Metadata {
+                ft: FileType {
+                    dir: true,
+                    ..Default::default()
+                },
+                accessed: time,
+                created: time,
+                modified: time,
+                len: 0,
+            },
+        }));
+
+        Self {
+            storage: slab,
+            backing_offload: None,
+            limiter: None,
+        }
+    }
+}
+
+#[allow(dead_code)] // The `No` variant.
+pub(super) enum DirectoryMustBeEmpty {
+    Yes,
+    No,
+}
+
+impl DirectoryMustBeEmpty {
+    pub(super) fn yes(&self) -> bool {
+        matches!(self, Self::Yes)
+    }
+
+    pub(super) fn no(&self) -> bool {
+        !self.yes()
+    }
+}
+
+#[cfg(test)]
+mod test_filesystem {
+    use std::{borrow::Cow, path::Path};
+
+    use tokio::io::AsyncReadExt;
+
+    use crate::{mem_fs::*, ops, DirEntry, FileSystem as FS, FileType, FsError};
+
+    macro_rules! path {
+        ($path:expr) => {
+            std::path::Path::new($path)
+        };
+
+        (buf $path:expr) => {
+            std::path::PathBuf::from($path)
+        };
+    }
+
+    #[tokio::test]
+    async fn test_new_filesystem() {
+        let fs = FileSystem::default();
+        let fs_inner = fs.inner.read().unwrap();
+
+        assert_eq!(fs_inner.storage.len(), 1, "storage has a root");
+        assert!(
+            matches!(
+                fs_inner.storage.get(ROOT_INODE),
+                Some(Node::Directory(DirectoryNode {
+                    inode: ROOT_INODE,
+                    name,
+                    children,
+                    ..
+                })) if name == "/" && children.is_empty(),
+            ),
+            "storage has a well-defined root",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_create_dir() {
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.create_dir(path!("/")),
+            Err(FsError::AlreadyExists),
+            "creating the root which already exists",
+        );
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory",);
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+            assert_eq!(
+                fs_inner.storage.len(),
+                2,
+                "storage contains the new directory"
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1]
+                ),
+                "the root is updated and well-defined",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 1,
+                        name,
+                        children,
+                        ..
+                    })) if name == "foo" && children.is_empty(),
+                ),
+                "the new directory is well-defined",
+            );
+        }
+
+        assert_eq!(
+            fs.create_dir(path!("/foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+            assert_eq!(
+                fs_inner.storage.len(),
+                3,
+                "storage contains the new sub-directory",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1]
+                ),
+                "the root is updated again and well-defined",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 1,
+                        name,
+                        children,
+                        ..
+                    })) if name == "foo" && children == &[2]
+                ),
+                "the new directory is updated and well-defined",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(2),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 2,
+                        name,
+                        children,
+                        ..
+                    })) if name == "bar" && children.is_empty()
+                ),
+                "the new directory is well-defined",
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_remove_dir() {
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.remove_dir(path!("/")),
+            Err(FsError::BaseNotDirectory),
+            "removing a directory that has no parent",
+        );
+
+        assert_eq!(
+            fs.remove_dir(path!("/foo")),
+            Err(FsError::EntryNotFound),
+            "cannot remove a directory that doesn't exist",
+        );
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating a directory",);
+
+        assert_eq!(
+            fs.create_dir(path!("/foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+            assert_eq!(
+                fs_inner.storage.len(),
+                3,
+                "storage contains all the directories",
+            );
+        }
+
+        assert_eq!(
+            fs.remove_dir(path!("/foo")),
+            Err(FsError::DirectoryNotEmpty),
+            "removing a directory that has children",
+        );
+
+        assert_eq!(
+            fs.remove_dir(path!("/foo/bar")),
+            Ok(()),
+            "removing a sub-directory",
+        );
+
+        assert_eq!(fs.remove_dir(path!("/foo")), Ok(()), "removing a directory",);
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+            assert_eq!(
+                fs_inner.storage.len(),
+                1,
+                "storage contains all the directories",
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_rename() {
+        let fs = FileSystem::default();
+
+        assert_eq!(
+            fs.rename(path!("/"), path!("/bar")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming a directory that has no parent",
+        );
+        assert_eq!(
+            fs.rename(path!("/foo"), path!("/")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming to a directory that has no parent",
+        );
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()));
+        assert_eq!(fs.create_dir(path!("/foo/qux")), Ok(()));
+
+        assert_eq!(
+            fs.rename(path!("/foo"), path!("/bar/baz")).await,
+            Err(FsError::EntryNotFound),
+            "renaming to a directory that has parent that doesn't exist",
+        );
+
+        assert_eq!(fs.create_dir(path!("/bar")), Ok(()));
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/bar/hello1.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello1.txt`)",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/bar/hello2.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello2.txt`)",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(fs_inner.storage.len(), 6, "storage has all files");
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1, 3]
+                ),
+                "`/` contains `foo` and `bar`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 1,
+                        name,
+                        children,
+                        ..
+                    })) if name == "foo" && children == &[2]
+                ),
+                "`foo` contains `qux`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(2),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 2,
+                        name,
+                        children,
+                        ..
+                    })) if name == "qux" && children.is_empty()
+                ),
+                "`qux` is empty",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(3),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 3,
+                        name,
+                        children,
+                        ..
+                    })) if name == "bar" && children == &[4, 5]
+                ),
+                "`bar` is contains `hello.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(4),
+                    Some(Node::File(FileNode {
+                        inode: 4,
+                        name,
+                        ..
+                    })) if name == "hello1.txt"
+                ),
+                "`hello1.txt` exists",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(5),
+                    Some(Node::File(FileNode {
+                        inode: 5,
+                        name,
+                        ..
+                    })) if name == "hello2.txt"
+                ),
+                "`hello2.txt` exists",
+            );
+        }
+
+        assert_eq!(
+            fs.rename(path!("/bar/hello2.txt"), path!("/foo/world2.txt"))
+                .await,
+            Ok(()),
+            "renaming (and moving) a file",
+        );
+
+        assert_eq!(
+            fs.rename(path!("/foo"), path!("/bar/baz")).await,
+            Ok(()),
+            "renaming a directory",
+        );
+
+        assert_eq!(
+            fs.rename(path!("/bar/hello1.txt"), path!("/bar/world1.txt"))
+                .await,
+            Ok(()),
+            "renaming a file (in the same directory)",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            dbg!(&fs_inner);
+
+            assert_eq!(
+                fs_inner.storage.len(),
+                6,
+                "storage has still all directories"
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[3]
+                ),
+                "`/` contains `bar`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 1,
+                        name,
+                        children,
+                        ..
+                    })) if name == "baz" && children == &[2, 5]
+                ),
+                "`foo` has been renamed to `baz` and contains `qux` and `world2.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(2),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 2,
+                        name,
+                        children,
+                        ..
+                    })) if name == "qux" && children.is_empty()
+                ),
+                "`qux` is empty",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(3),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: 3,
+                        name,
+                        children,
+                        ..
+                    })) if name == "bar" && children == &[4, 1]
+                ),
+                "`bar` contains `bar` (ex `foo`)  and `world1.txt` (ex `hello1`)",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(4),
+                    Some(Node::File(FileNode {
+                        inode: 4,
+                        name,
+                        ..
+                    })) if name == "world1.txt"
+                ),
+                "`hello1.txt` has been renamed to `world1.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(5),
+                    Some(Node::File(FileNode {
+                        inode: 5,
+                        name,
+                        ..
+                    })) if name == "world2.txt"
+                ),
+                "`hello2.txt` has been renamed to `world2.txt`",
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_metadata() {
+        use std::thread::sleep;
+        use std::time::Duration;
+
+        let fs = FileSystem::default();
+        let root_metadata = fs.metadata(path!("/"));
+
+        assert!(matches!(
+            root_metadata,
+            Ok(Metadata {
+                ft: FileType { dir: true, .. },
+                accessed,
+                created,
+                modified,
+                len: 0
+            }) if accessed == created && created == modified && modified > 0
+        ));
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()));
+
+        let foo_metadata = fs.metadata(path!("/foo"));
+        assert!(foo_metadata.is_ok());
+        let foo_metadata = foo_metadata.unwrap();
+
+        assert!(matches!(
+            foo_metadata,
+            Metadata {
+                ft: FileType { dir: true, .. },
+                accessed,
+                created,
+                modified,
+                len: 0
+            } if accessed == created && created == modified && modified > 0
+        ));
+
+        sleep(Duration::from_secs(3));
+
+        assert_eq!(fs.rename(path!("/foo"), path!("/bar")).await, Ok(()));
+
+        assert!(
+            matches!(
+                fs.metadata(path!("/bar")),
+                Ok(Metadata {
+                    ft: FileType { dir: true, .. },
+                    accessed,
+                    created,
+                    modified,
+                    len: 0
+                }) if
+                    accessed == foo_metadata.accessed &&
+                    created == foo_metadata.created &&
+                    modified > foo_metadata.modified
+            ),
+            "the modified time is updated when file is renamed",
+        );
+        assert!(
+            matches!(
+                fs.metadata(path!("/")),
+                Ok(Metadata {
+                    ft: FileType { dir: true, .. },
+                    accessed,
+                    created,
+                    modified,
+                    len: 0
+                }) if
+                    accessed <= foo_metadata.accessed &&
+                    created <= foo_metadata.created &&
+                    modified > foo_metadata.modified
+            ),
+            "the modified time of the parent is updated when file is renamed \n{:?}\n{:?}",
+            fs.metadata(path!("/")),
+            foo_metadata,
+        );
+    }
+
+    #[tokio::test]
+    async fn test_remove_file() {
+        let fs = FileSystem::default();
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/foo.txt")),
+                Ok(_)
+            ),
+            "creating a new file",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(fs_inner.storage.len(), 2, "storage has all files");
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children == &[1]
+                ),
+                "`/` contains `foo.txt`",
+            );
+            assert!(
+                matches!(
+                    fs_inner.storage.get(1),
+                    Some(Node::File(FileNode {
+                        inode: 1,
+                        name,
+                        ..
+                    })) if name == "foo.txt"
+                ),
+                "`foo.txt` exists and is a file",
+            );
+        }
+
+        assert_eq!(
+            fs.remove_file(path!("/foo.txt")),
+            Ok(()),
+            "removing a file that exists",
+        );
+
+        {
+            let fs_inner = fs.inner.read().unwrap();
+
+            assert_eq!(fs_inner.storage.len(), 1, "storage no longer has the file");
+            assert!(
+                matches!(
+                    fs_inner.storage.get(ROOT_INODE),
+                    Some(Node::Directory(DirectoryNode {
+                        inode: ROOT_INODE,
+                        name,
+                        children,
+                        ..
+                    })) if name == "/" && children.is_empty()
+                ),
+                "`/` is empty",
+            );
+        }
+
+        assert_eq!(
+            fs.remove_file(path!("/foo.txt")),
+            Err(FsError::EntryNotFound),
+            "removing a file that exists",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_readdir() {
+        let fs = FileSystem::default();
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating `foo`");
+        assert_eq!(fs.create_dir(path!("/foo/sub")), Ok(()), "creating `sub`");
+        assert_eq!(fs.create_dir(path!("/bar")), Ok(()), "creating `bar`");
+        assert_eq!(fs.create_dir(path!("/baz")), Ok(()), "creating `bar`");
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/a.txt")),
+                Ok(_)
+            ),
+            "creating `a.txt`",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/b.txt")),
+                Ok(_)
+            ),
+            "creating `b.txt`",
+        );
+
+        let readdir = fs.read_dir(path!("/"));
+
+        assert!(readdir.is_ok(), "reading the directory `/`");
+
+        let mut readdir = readdir.unwrap();
+
+        assert!(
+            matches!(
+                readdir.next(),
+                Some(Ok(DirEntry {
+                    path,
+                    metadata: Ok(Metadata { ft, .. }),
+                }))
+                    if path == path!(buf "/foo") && ft.is_dir()
+            ),
+            "checking entry #1",
+        );
+        assert!(
+            matches!(
+                readdir.next(),
+                Some(Ok(DirEntry {
+                    path,
+                    metadata: Ok(Metadata { ft, .. }),
+                }))
+                    if path == path!(buf "/bar") && ft.is_dir()
+            ),
+            "checking entry #2",
+        );
+        assert!(
+            matches!(
+                readdir.next(),
+                Some(Ok(DirEntry {
+                    path,
+                    metadata: Ok(Metadata { ft, .. }),
+                }))
+                    if path == path!(buf "/baz") && ft.is_dir()
+            ),
+            "checking entry #3",
+        );
+        assert!(
+            matches!(
+                readdir.next(),
+                Some(Ok(DirEntry {
+                    path,
+                    metadata: Ok(Metadata { ft, .. }),
+                }))
+                    if path == path!(buf "/a.txt") && ft.is_file()
+            ),
+            "checking entry #4",
+        );
+        assert!(
+            matches!(
+                readdir.next(),
+                Some(Ok(DirEntry {
+                    path,
+                    metadata: Ok(Metadata { ft, .. }),
+                }))
+                    if path == path!(buf "/b.txt") && ft.is_file()
+            ),
+            "checking entry #5",
+        );
+        assert!(matches!(readdir.next(), None), "no more entries");
+    }
+
+    #[tokio::test]
+    async fn test_canonicalize() {
+        let fs = FileSystem::default();
+
+        assert_eq!(fs.create_dir(path!("/foo")), Ok(()), "creating `foo`");
+        assert_eq!(fs.create_dir(path!("/foo/bar")), Ok(()), "creating `bar`");
+        assert_eq!(
+            fs.create_dir(path!("/foo/bar/baz")),
+            Ok(()),
+            "creating `baz`",
+        );
+        assert_eq!(
+            fs.create_dir(path!("/foo/bar/baz/qux")),
+            Ok(()),
+            "creating `qux`",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(path!("/foo/bar/baz/qux/hello.txt")),
+                Ok(_)
+            ),
+            "creating `hello.txt`",
+        );
+
+        let fs_inner = fs.inner.read().unwrap();
+
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/"), ROOT_INODE)),
+            "canonicalizing `/`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("foo"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Err(FsError::InvalidInput),
+            "canonicalizing `foo`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/././././foo/"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/foo"), 1)),
+            "canonicalizing `/././././foo/`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/foo/bar//"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/foo/bar"), 2)),
+            "canonicalizing `/foo/bar//`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/foo/bar/../bar"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/foo/bar"), 2)),
+            "canonicalizing `/foo/bar/../bar`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/foo/bar/../.."))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/"), ROOT_INODE)),
+            "canonicalizing `/foo/bar/../..`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("/foo/bar/../../.."))
+                .map(|(a, b)| (a, b.unwrap())),
+            Err(FsError::InvalidInput),
+            "canonicalizing `/foo/bar/../../..`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!("C:/foo/"))
+                .map(|(a, b)| (a, b.unwrap())),
+            Err(FsError::InvalidInput),
+            "canonicalizing `C:/foo/`",
+        );
+        assert_eq!(
+            fs_inner
+                .canonicalize(path!(
+                    "/foo/./../foo/bar/../../foo/bar/./baz/./../baz/qux/../../baz/./qux/hello.txt"
+                ))
+                .map(|(a, b)| (a, b.unwrap())),
+            Ok((path!(buf "/foo/bar/baz/qux/hello.txt"), 5)),
+            "canonicalizing a crazily stupid path name",
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "Not yet supported. See https://github.com/wasmerio/wasmer/issues/3678"]
+    async fn mount_to_overlapping_directories() {
+        let top_level = FileSystem::default();
+        ops::touch(&top_level, "/file.txt").unwrap();
+        let nested = FileSystem::default();
+        ops::touch(&nested, "/another-file.txt").unwrap();
+        let top_level: Arc<dyn crate::FileSystem + Send + Sync> = Arc::new(top_level);
+        let nested: Arc<dyn crate::FileSystem + Send + Sync> = Arc::new(nested);
+
+        let fs = FileSystem::default();
+        fs.mount("/top-level".into(), &top_level, "/".into())
+            .unwrap();
+        fs.mount("/top-level/nested".into(), &nested, "/".into())
+            .unwrap();
+
+        assert!(ops::is_dir(&fs, "/top-level"));
+        assert!(ops::is_file(&fs, "/top-level/file.txt"));
+        assert!(ops::is_dir(&fs, "/top-level/nested"));
+        assert!(ops::is_file(&fs, "/top-level/nested/another-file.txt"));
+    }
+
+    #[tokio::test]
+    async fn test_merge_flat() {
+        let main = FileSystem::default();
+
+        let other = FileSystem::default();
+        crate::ops::create_dir_all(&other, "/a/x").unwrap();
+        other
+            .insert_ro_file(&Path::new("/a/x/a.txt"), Cow::Borrowed(b"a"))
+            .unwrap();
+        other
+            .insert_ro_file(&Path::new("/a/x/b.txt"), Cow::Borrowed(b"b"))
+            .unwrap();
+        other
+            .insert_ro_file(&Path::new("/a/x/c.txt"), Cow::Borrowed(b"c"))
+            .unwrap();
+
+        let out = other.read_dir(&Path::new("/")).unwrap();
+        dbg!(&out);
+
+        let other: Arc<dyn crate::FileSystem + Send + Sync> = Arc::new(other);
+
+        main.mount_directory_entries(&Path::new("/"), &other, &Path::new("/a"))
+            .unwrap();
+
+        let mut buf = Vec::new();
+
+        let mut f = main
+            .new_open_options()
+            .read(true)
+            .open(&Path::new("/x/a.txt"))
+            .unwrap();
+        f.read_to_end(&mut buf).await.unwrap();
+
+        assert_eq!(buf, b"a");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/mod.rs
new file mode 100644
index 0000000..33ea3ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/mod.rs
@@ -0,0 +1,170 @@
+mod file;
+mod file_opener;
+mod filesystem;
+mod offloaded_file;
+mod stdio;
+
+use file::{File, FileHandle, ReadOnlyFile};
+pub use filesystem::FileSystem;
+pub use offloaded_file::OffloadBackingStore;
+pub use stdio::{Stderr, Stdin, Stdout};
+
+use crate::Metadata;
+use std::{
+    ffi::{OsStr, OsString},
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};
+
+use self::offloaded_file::OffloadedFile;
+
+type Inode = usize;
+const ROOT_INODE: Inode = 0;
+
+#[derive(Debug)]
+struct FileNode {
+    inode: Inode,
+    name: OsString,
+    file: File,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct ReadOnlyFileNode {
+    inode: Inode,
+    name: OsString,
+    file: ReadOnlyFile,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct OffloadedFileNode {
+    inode: Inode,
+    name: OsString,
+    file: OffloadedFile,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct ArcFileNode {
+    inode: Inode,
+    name: OsString,
+    fs: Arc<dyn crate::FileSystem + Send + Sync>,
+    path: PathBuf,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct CustomFileNode {
+    inode: Inode,
+    name: OsString,
+    file: Mutex<Box<dyn crate::VirtualFile + Send + Sync>>,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct DirectoryNode {
+    inode: Inode,
+    name: OsString,
+    children: Vec<Inode>,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+struct ArcDirectoryNode {
+    inode: Inode,
+    name: OsString,
+    fs: Arc<dyn crate::FileSystem + Send + Sync>,
+    path: PathBuf,
+    metadata: Metadata,
+}
+
+#[derive(Debug)]
+enum Node {
+    File(FileNode),
+    OffloadedFile(OffloadedFileNode),
+    ReadOnlyFile(ReadOnlyFileNode),
+    ArcFile(ArcFileNode),
+    CustomFile(CustomFileNode),
+    Directory(DirectoryNode),
+    ArcDirectory(ArcDirectoryNode),
+}
+
+impl Node {
+    fn inode(&self) -> Inode {
+        *match self {
+            Self::File(FileNode { inode, .. }) => inode,
+            Self::OffloadedFile(OffloadedFileNode { inode, .. }) => inode,
+            Self::ReadOnlyFile(ReadOnlyFileNode { inode, .. }) => inode,
+            Self::ArcFile(ArcFileNode { inode, .. }) => inode,
+            Self::CustomFile(CustomFileNode { inode, .. }) => inode,
+            Self::Directory(DirectoryNode { inode, .. }) => inode,
+            Self::ArcDirectory(ArcDirectoryNode { inode, .. }) => inode,
+        }
+    }
+
+    fn name(&self) -> &OsStr {
+        match self {
+            Self::File(FileNode { name, .. }) => name.as_os_str(),
+            Self::OffloadedFile(OffloadedFileNode { name, .. }) => name.as_os_str(),
+            Self::ReadOnlyFile(ReadOnlyFileNode { name, .. }) => name.as_os_str(),
+            Self::ArcFile(ArcFileNode { name, .. }) => name.as_os_str(),
+            Self::CustomFile(CustomFileNode { name, .. }) => name.as_os_str(),
+            Self::Directory(DirectoryNode { name, .. }) => name.as_os_str(),
+            Self::ArcDirectory(ArcDirectoryNode { name, .. }) => name.as_os_str(),
+        }
+    }
+
+    fn metadata(&self) -> &Metadata {
+        match self {
+            Self::File(FileNode { metadata, .. }) => metadata,
+            Self::OffloadedFile(OffloadedFileNode { metadata, .. }) => metadata,
+            Self::ReadOnlyFile(ReadOnlyFileNode { metadata, .. }) => metadata,
+            Self::ArcFile(ArcFileNode { metadata, .. }) => metadata,
+            Self::CustomFile(CustomFileNode { metadata, .. }) => metadata,
+            Self::Directory(DirectoryNode { metadata, .. }) => metadata,
+            Self::ArcDirectory(ArcDirectoryNode { metadata, .. }) => metadata,
+        }
+    }
+
+    fn metadata_mut(&mut self) -> &mut Metadata {
+        match self {
+            Self::File(FileNode { metadata, .. }) => metadata,
+            Self::OffloadedFile(OffloadedFileNode { metadata, .. }) => metadata,
+            Self::ReadOnlyFile(ReadOnlyFileNode { metadata, .. }) => metadata,
+            Self::ArcFile(ArcFileNode { metadata, .. }) => metadata,
+            Self::CustomFile(CustomFileNode { metadata, .. }) => metadata,
+            Self::Directory(DirectoryNode { metadata, .. }) => metadata,
+            Self::ArcDirectory(ArcDirectoryNode { metadata, .. }) => metadata,
+        }
+    }
+
+    fn set_name(&mut self, new_name: OsString) {
+        match self {
+            Self::File(FileNode { name, .. }) => *name = new_name,
+            Self::OffloadedFile(OffloadedFileNode { name, .. }) => *name = new_name,
+            Self::ReadOnlyFile(ReadOnlyFileNode { name, .. }) => *name = new_name,
+            Self::ArcFile(ArcFileNode { name, .. }) => *name = new_name,
+            Self::CustomFile(CustomFileNode { name, .. }) => *name = new_name,
+            Self::Directory(DirectoryNode { name, .. }) => *name = new_name,
+            Self::ArcDirectory(ArcDirectoryNode { name, .. }) => *name = new_name,
+        }
+    }
+}
+
+fn time() -> u64 {
+    #[cfg(not(feature = "no-time"))]
+    {
+        // SAFETY: It's very unlikely that the system returns a time that
+        // is before `UNIX_EPOCH` :-).
+        std::time::SystemTime::now()
+            .duration_since(std::time::SystemTime::UNIX_EPOCH)
+            .unwrap()
+            .as_nanos() as u64
+    }
+
+    #[cfg(feature = "no-time")]
+    {
+        0
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/offloaded_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/offloaded_file.rs
new file mode 100644
index 0000000..356a7e7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/offloaded_file.rs
@@ -0,0 +1,485 @@
+use bytes::Bytes;
+use shared_buffer::OwnedBuffer;
+use std::{
+    cmp,
+    fs::File,
+    io,
+    ops::Range,
+    sync::{Arc, Mutex, MutexGuard},
+};
+
+use crate::limiter::DynFsMemoryLimiter;
+
+#[derive(Debug)]
+pub enum FileExtent {
+    MmapOffload { offset: u64, size: u64 },
+    RepeatingBytes { value: u8, cnt: u64 },
+    InMemory { data: Bytes },
+}
+
+impl FileExtent {
+    pub fn size(&self) -> u64 {
+        match self {
+            FileExtent::MmapOffload { size, .. } => *size,
+            FileExtent::RepeatingBytes { cnt, .. } => *cnt,
+            FileExtent::InMemory { data } => data.len() as u64,
+        }
+    }
+
+    pub fn resize(&mut self, new_size: u64) {
+        match self {
+            FileExtent::MmapOffload { size, .. } => *size = new_size.min(*size),
+            FileExtent::RepeatingBytes { cnt, .. } => *cnt = new_size,
+            FileExtent::InMemory { data } => {
+                *data = data.slice(..(new_size as usize));
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct OffloadBackingStoreState {
+    mmap_file: Option<File>,
+    mmap_offload: OwnedBuffer,
+}
+
+impl OffloadBackingStoreState {
+    fn get_slice(&mut self, range: Range<u64>) -> io::Result<&[u8]> {
+        let offset = range.start;
+        let size = match range.end {
+            u64::MAX => {
+                let len = self.mmap_offload.len() as u64;
+                if len < offset {
+                    tracing::trace!("range out of bounds {} vs {}", len, offset);
+                    return Err(io::ErrorKind::UnexpectedEof.into());
+                }
+                len - offset
+            }
+            end => end - offset,
+        };
+
+        let end = offset + size;
+        if end > self.mmap_offload.len() as u64 {
+            let mmap_file = match self.mmap_file.as_ref() {
+                Some(a) => a,
+                None => {
+                    tracing::trace!(
+                        "mmap buffer out of bounds and no mmap file to reload {} vs {}",
+                        end,
+                        self.mmap_offload.len()
+                    );
+                    return Err(io::ErrorKind::UnexpectedEof.into());
+                }
+            };
+            self.mmap_offload = OwnedBuffer::from_file(mmap_file)
+                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+            if end > self.mmap_offload.len() as u64 {
+                tracing::trace!(
+                    "mmap buffer out of bounds {} vs {} for {:?}",
+                    end,
+                    self.mmap_offload.len(),
+                    range
+                );
+                return Err(io::ErrorKind::UnexpectedEof.into());
+            }
+        }
+        Ok(&self.mmap_offload[offset as usize..end as usize])
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct OffloadBackingStore {
+    state: Arc<Mutex<OffloadBackingStoreState>>,
+}
+
+impl OffloadBackingStore {
+    pub fn new(mmap_offload: OwnedBuffer, mmap_file: Option<File>) -> Self {
+        Self {
+            state: Arc::new(Mutex::new(OffloadBackingStoreState {
+                mmap_file,
+                mmap_offload,
+            })),
+        }
+    }
+
+    pub fn from_file(file: &File) -> Self {
+        let file = file.try_clone().unwrap();
+        let buffer = OwnedBuffer::from_file(&file).unwrap();
+        Self::new(buffer, Some(file))
+    }
+
+    pub fn from_buffer(buffer: OwnedBuffer) -> Self {
+        Self::new(buffer, None)
+    }
+
+    pub fn owned_buffer(&self) -> OwnedBuffer {
+        let guard = self.state.lock().unwrap();
+        guard.mmap_offload.clone()
+    }
+
+    fn lock(&self) -> MutexGuard<'_, OffloadBackingStoreState> {
+        self.state.lock().unwrap()
+    }
+}
+
+#[derive(Debug)]
+pub struct OffloadedFile {
+    backing: OffloadBackingStore,
+    #[allow(dead_code)]
+    limiter: Option<DynFsMemoryLimiter>,
+    extents: Vec<FileExtent>,
+    size: u64,
+}
+
+pub enum OffloadWrite<'a> {
+    MmapOffset { offset: u64, size: u64 },
+    Buffer(&'a [u8]),
+}
+
+impl<'a> OffloadWrite<'a> {
+    fn len(&self) -> usize {
+        match self {
+            OffloadWrite::MmapOffset { size, .. } => *size as usize,
+            OffloadWrite::Buffer(data) => data.len(),
+        }
+    }
+}
+
+impl OffloadedFile {
+    pub fn new(limiter: Option<DynFsMemoryLimiter>, backing: OffloadBackingStore) -> Self {
+        Self {
+            backing,
+            limiter,
+            extents: Vec::new(),
+            size: 0,
+        }
+    }
+
+    pub fn seek(&self, position: io::SeekFrom, cursor: &mut u64) -> io::Result<u64> {
+        let to_err = |_| io::ErrorKind::InvalidInput;
+
+        // Calculate the next cursor.
+        let next_cursor: i64 = match position {
+            io::SeekFrom::Start(offset) => offset.try_into().map_err(to_err)?,
+            io::SeekFrom::End(offset) => self.len() as i64 + offset,
+            io::SeekFrom::Current(offset) => {
+                TryInto::<i64>::try_into(*cursor).map_err(to_err)? + offset
+            }
+        };
+
+        // It's an error to seek before byte 0.
+        if next_cursor < 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "seeking before the byte 0",
+            ));
+        }
+
+        // In this implementation, it's an error to seek beyond the
+        // end of the buffer.
+        let next_cursor = next_cursor.try_into().map_err(to_err)?;
+        *cursor = cmp::min(self.len(), next_cursor);
+        Ok(*cursor)
+    }
+
+    pub fn read(&self, mut buf: &mut [u8], cursor: &mut u64) -> io::Result<usize> {
+        let cursor_start = *cursor;
+
+        let mut extent_offset = cursor_start;
+        let mut extent_index = 0usize;
+        while !buf.is_empty() && extent_index < self.extents.len() {
+            let extent = &self.extents[extent_index];
+
+            if extent_offset >= extent.size() {
+                extent_offset -= extent.size();
+                extent_index += 1;
+                continue;
+            }
+
+            let read = match extent {
+                FileExtent::MmapOffload {
+                    offset: mmap_offset,
+                    size: extent_size,
+                } => {
+                    let mut backing = self.backing.lock();
+                    let mmap_offset_plus_extent = mmap_offset + extent_offset;
+                    let data = backing.get_slice(
+                        mmap_offset_plus_extent
+                            ..(mmap_offset_plus_extent + *extent_size - extent_offset),
+                    )?;
+                    let data_len = cmp::min(buf.len(), data.len());
+                    buf[..data_len].copy_from_slice(&data[..data_len]);
+                    data_len
+                }
+                FileExtent::RepeatingBytes { value, cnt } => {
+                    let cnt = cmp::min(buf.len() as u64, cnt - extent_offset) as usize;
+                    buf[..cnt].iter_mut().for_each(|d| {
+                        *d = *value;
+                    });
+                    cnt
+                }
+                FileExtent::InMemory { data } => {
+                    let data = &data.as_ref()[extent_offset as usize..];
+                    let data_len = cmp::min(buf.len(), data.len());
+                    buf[..data_len].copy_from_slice(&data[..data_len]);
+                    data_len
+                }
+            };
+
+            *cursor += read as u64;
+            extent_offset = 0;
+            extent_index += 1;
+            buf = &mut buf[read..];
+        }
+        Ok((*cursor - cursor_start) as usize)
+    }
+
+    pub fn write(&mut self, data: OffloadWrite<'_>, cursor: &mut u64) -> io::Result<usize> {
+        let original_extent_offset = *cursor;
+        let mut extent_offset = original_extent_offset;
+        let mut data_len = data.len() as u64;
+
+        // We need to split any extents that are intersecting with the
+        // start or end of the new block of data we are about to write
+        let mut split_extents = |mut split_at: u64| {
+            let mut index = 0usize;
+            while split_at > 0 && index < self.extents.len() {
+                let extent = &mut self.extents[index];
+                if split_at >= extent.size() {
+                    split_at -= extent.size();
+                    index += 1;
+                    continue;
+                } else if split_at == 0 {
+                    break;
+                } else {
+                    let new_extent = match extent {
+                        FileExtent::MmapOffload {
+                            offset: other_offset,
+                            size: other_size,
+                        } => FileExtent::MmapOffload {
+                            offset: *other_offset + split_at,
+                            size: *other_size - split_at,
+                        },
+                        FileExtent::RepeatingBytes {
+                            value: other_value,
+                            cnt: other_cnt,
+                        } => FileExtent::RepeatingBytes {
+                            value: *other_value,
+                            cnt: *other_cnt - split_at,
+                        },
+                        FileExtent::InMemory { data: other_data } => FileExtent::InMemory {
+                            data: other_data.slice((split_at as usize)..),
+                        },
+                    };
+                    extent.resize(split_at);
+                    self.extents.insert(index + 1, new_extent);
+                    break;
+                }
+            }
+        };
+
+        // If the extent is below the actual size of the file then we need to split it
+        let mut index = if extent_offset < self.size {
+            split_extents(extent_offset);
+            split_extents(extent_offset + data_len);
+
+            // Now we delete all the extents that exist between the
+            // range that we are about to insert
+            let mut index = 0usize;
+            while index < self.extents.len() {
+                let extent = &self.extents[index];
+                if extent_offset >= extent.size() {
+                    extent_offset -= extent.size();
+                    index += 1;
+                    continue;
+                } else {
+                    break;
+                }
+            }
+            while index < self.extents.len() {
+                let extent = &self.extents[index];
+                if data_len < extent.size() {
+                    break;
+                }
+                data_len -= extent.size();
+                self.extents.remove(index);
+            }
+            index
+        } else {
+            self.extents.len()
+        };
+
+        // If we have a gap that needs to be filled then do so
+        if extent_offset > self.size {
+            self.extents.insert(
+                index,
+                FileExtent::RepeatingBytes {
+                    value: 0,
+                    cnt: extent_offset - self.size,
+                },
+            );
+            self.size = extent_offset;
+            index += 1;
+        }
+
+        // Insert the extent into the buffer
+        match data {
+            OffloadWrite::MmapOffset { offset, size } => {
+                self.extents
+                    .insert(index, FileExtent::MmapOffload { offset, size });
+            }
+            OffloadWrite::Buffer(data) => {
+                // Finally we add the new extent
+                let data_start = data.as_ptr() as u64;
+                let data_end = data_start + data.len() as u64;
+                let mut backing = self.backing.lock();
+                let backing_data = backing.get_slice(0u64..u64::MAX)?;
+
+                let mmap_start = backing_data.as_ptr() as u64;
+                let mmap_end = mmap_start + backing_data.len() as u64;
+
+                // If the data is within the mmap buffer then we use a extent range
+                // to represent the data, otherwise we fall back on copying the data
+                let new_extent = if data_start >= mmap_start && data_end <= mmap_end {
+                    FileExtent::MmapOffload {
+                        offset: data_start - mmap_start,
+                        size: data_end - data_start,
+                    }
+                } else {
+                    FileExtent::InMemory {
+                        data: data.to_vec().into(),
+                    }
+                };
+                self.extents.insert(index, new_extent);
+            }
+        }
+        self.size = self.size.max(original_extent_offset + data.len() as u64);
+
+        // Update the cursor
+        *cursor += data.len() as u64;
+        Ok(data.len())
+    }
+
+    pub fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+
+    pub fn resize(&mut self, new_len: u64, value: u8) {
+        let mut cur_len = self.len();
+        if new_len > cur_len {
+            self.extents.push(FileExtent::RepeatingBytes {
+                value,
+                cnt: new_len - cur_len,
+            });
+        }
+        while cur_len > new_len && !self.extents.is_empty() {
+            let extent: &mut FileExtent = self.extents.last_mut().unwrap();
+            let diff = extent.size().min(cur_len - new_len);
+            extent.resize(extent.size() - diff);
+            cur_len -= diff;
+            if extent.size() == 0 {
+                self.extents.pop();
+            }
+        }
+        self.size = new_len;
+    }
+
+    pub fn len(&self) -> u64 {
+        self.size
+    }
+
+    pub fn truncate(&mut self) {
+        self.extents.clear();
+        self.size = 0;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[tracing_test::traced_test]
+    pub fn test_offload_file() -> anyhow::Result<()> {
+        let buffer = OwnedBuffer::from_bytes(std::iter::repeat(12u8).take(100).collect::<Vec<_>>());
+        let test_data2 = buffer.clone();
+
+        let backing = OffloadBackingStore::new(buffer, None);
+        let mut file = OffloadedFile::new(None, backing);
+
+        let mut cursor = 0u64;
+        let test_data = std::iter::repeat(56u8).take(100).collect::<Vec<_>>();
+        file.write(OffloadWrite::Buffer(&test_data), &mut cursor)?;
+
+        assert_eq!(file.len(), 100);
+
+        cursor = 0;
+        let mut result = std::iter::repeat(0u8).take(100).collect::<Vec<_>>();
+        file.read(&mut result, &mut cursor)?;
+        assert_eq!(
+            &result,
+            &std::iter::repeat(56u8).take(100).collect::<Vec<_>>()
+        );
+
+        cursor = 50;
+        file.write(OffloadWrite::Buffer(&test_data2), &mut cursor)?;
+
+        assert_eq!(file.len(), 150);
+
+        cursor = 0;
+        let mut result = std::iter::repeat(0u8).take(150).collect::<Vec<_>>();
+        file.read(&mut result, &mut cursor)?;
+        assert_eq!(
+            &result,
+            &std::iter::repeat(56u8)
+                .take(50)
+                .chain(std::iter::repeat(12u8).take(100))
+                .collect::<Vec<_>>()
+        );
+
+        file.resize(200, 99u8);
+        assert_eq!(file.len(), 200);
+
+        cursor = 0;
+        let mut result = std::iter::repeat(0u8).take(200).collect::<Vec<_>>();
+        file.read(&mut result, &mut cursor)?;
+        assert_eq!(
+            &result,
+            &std::iter::repeat(56u8)
+                .take(50)
+                .chain(std::iter::repeat(12u8).take(100))
+                .chain(std::iter::repeat(99u8).take(50))
+                .collect::<Vec<_>>()
+        );
+
+        file.resize(33, 01u8);
+
+        cursor = 0;
+        let mut result = std::iter::repeat(0u8).take(33).collect::<Vec<_>>();
+        file.read(&mut result, &mut cursor)?;
+        assert_eq!(
+            &result,
+            &std::iter::repeat(56u8).take(33).collect::<Vec<_>>()
+        );
+
+        let mut cursor = 10u64;
+        let test_data = std::iter::repeat(74u8).take(10).collect::<Vec<_>>();
+        file.write(OffloadWrite::Buffer(&test_data), &mut cursor)?;
+
+        assert_eq!(file.len(), 33);
+
+        cursor = 0;
+        let mut result = std::iter::repeat(0u8).take(33).collect::<Vec<_>>();
+        file.read(&mut result, &mut cursor)?;
+        assert_eq!(
+            &result,
+            &std::iter::repeat(56u8)
+                .take(10)
+                .chain(std::iter::repeat(74u8).take(10))
+                .chain(std::iter::repeat(56u8).take(13))
+                .collect::<Vec<_>>()
+        );
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/stdio.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/stdio.rs
new file mode 100644
index 0000000..6153994
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/mem_fs/stdio.rs
@@ -0,0 +1,330 @@
+//! This module contains the standard I/O streams, i.e. “emulated”
+//! `stdin`, `stdout` and `stderr`.
+
+use crate::{FsError, Result, VirtualFile};
+use std::io::{self, Write};
+
+macro_rules! impl_virtualfile_on_std_streams {
+    ($name:ident { readable: $readable:expr, writable: $writable:expr $(,)* }) => {
+        /// A wrapper type around the standard I/O stream of the same
+        /// name that implements `VirtualFile`.
+        #[derive(Debug, Default)]
+        pub struct $name {
+            pub buf: Vec<u8>,
+        }
+
+        impl $name {
+            const fn is_readable(&self) -> bool {
+                $readable
+            }
+
+            const fn is_writable(&self) -> bool {
+                $writable
+            }
+        }
+
+        #[async_trait::async_trait]
+        impl VirtualFile for $name {
+            fn last_accessed(&self) -> u64 {
+                0
+            }
+
+            fn last_modified(&self) -> u64 {
+                0
+            }
+
+            fn created_time(&self) -> u64 {
+                0
+            }
+
+            fn size(&self) -> u64 {
+                0
+            }
+
+            fn set_len(& mut self, _new_size: u64) -> Result<()> {
+                Err(FsError::PermissionDenied)
+            }
+
+            fn unlink(&mut self) -> Result<()> {
+                Ok(())
+            }
+
+            fn poll_read_ready(self: std::pin::Pin<&mut Self>, _cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<usize>> {
+                std::task::Poll::Ready(Ok(self.buf.len()))
+            }
+
+            fn poll_write_ready(self: std::pin::Pin<&mut Self>, _cx: &mut std::task::Context<'_>) -> std::task::Poll<std::io::Result<usize>> {
+                std::task::Poll::Ready(Ok(8192))
+            }
+        }
+
+        impl_virtualfile_on_std_streams!(impl AsyncSeek for $name);
+        impl_virtualfile_on_std_streams!(impl AsyncRead for $name);
+        impl_virtualfile_on_std_streams!(impl AsyncWrite for $name);
+    };
+
+    (impl AsyncSeek for $name:ident) => {
+        impl tokio::io::AsyncSeek for $name {
+            fn start_seek(
+                self: std::pin::Pin<&mut Self>,
+                _position: io::SeekFrom
+            ) -> io::Result<()> {
+                Err(io::Error::new(
+                    io::ErrorKind::PermissionDenied,
+                    concat!("cannot seek `", stringify!($name), "`"),
+                ))
+            }
+            fn poll_complete(
+                self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>
+            ) -> std::task::Poll<io::Result<u64>>
+            {
+                std::task::Poll::Ready(
+                    Err(io::Error::new(
+                        io::ErrorKind::PermissionDenied,
+                        concat!("cannot seek `", stringify!($name), "`"),
+                    ))
+                )
+            }
+        }
+    };
+
+    (impl AsyncRead for $name:ident) => {
+        impl tokio::io::AsyncRead for $name {
+            fn poll_read(
+                mut self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>,
+                buf: &mut tokio::io::ReadBuf<'_>,
+            ) -> std::task::Poll<io::Result<()>> {
+                std::task::Poll::Ready(
+                    if self.is_readable() {
+                        let length = buf.remaining().min(self.buf.len());
+                        buf.put_slice(&self.buf[..length]);
+
+                        // Remove what has been consumed.
+                        self.buf.drain(..length);
+
+                        Ok(())
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::PermissionDenied,
+                            concat!("cannot read from `", stringify!($name), "`"),
+                        ))
+                    }
+                )
+            }
+        }
+    };
+
+    (impl AsyncWrite for $name:ident) => {
+        impl tokio::io::AsyncWrite for $name {
+            fn poll_write(
+                mut self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>,
+                buf: &[u8],
+            ) -> std::task::Poll<io::Result<usize>> {
+                std::task::Poll::Ready(
+                    if self.is_writable() {
+                        self.buf.write(buf)
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::PermissionDenied,
+                            concat!("cannot write to `", stringify!($name), "`"),
+                        ))
+                    }
+                )
+            }
+
+            fn poll_flush(
+                mut self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>
+            ) -> std::task::Poll<io::Result<()>> {
+                std::task::Poll::Ready(
+                    if self.is_writable() {
+                        self.buf.flush()
+                    } else {
+                        Err(io::Error::new(
+                            io::ErrorKind::PermissionDenied,
+                            concat!("cannot flush `", stringify!($name), "`"),
+                        ))
+                    }
+                )
+            }
+
+            fn poll_shutdown(
+                self: std::pin::Pin<&mut Self>,
+                _cx: &mut std::task::Context<'_>
+            ) -> std::task::Poll<io::Result<()>> {
+                std::task::Poll::Ready(Ok(()))
+            }
+        }
+    };
+}
+
+impl_virtualfile_on_std_streams!(Stdin {
+    readable: true,
+    writable: false,
+});
+impl_virtualfile_on_std_streams!(Stdout {
+    readable: false,
+    writable: true,
+});
+impl_virtualfile_on_std_streams!(Stderr {
+    readable: false,
+    writable: true,
+});
+
+#[cfg(test)]
+mod test_read_write_seek {
+    use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+
+    use crate::mem_fs::*;
+    use std::io::{self};
+
+    #[tokio::test]
+    async fn test_read_stdin() {
+        let mut stdin = Stdin {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+        let mut buffer = [0; 3];
+
+        assert!(
+            matches!(stdin.read(&mut buffer).await, Ok(3)),
+            "reading bytes from `stdin`",
+        );
+        assert_eq!(
+            buffer,
+            [b'f', b'o', b'o'],
+            "checking the bytes read from `stdin`"
+        );
+
+        let mut buffer = Vec::new();
+
+        assert!(
+            matches!(stdin.read_to_end(&mut buffer).await, Ok(3)),
+            "reading bytes again from `stdin`",
+        );
+        assert_eq!(
+            buffer,
+            &[b'b', b'a', b'r'],
+            "checking the bytes read from `stdin`"
+        );
+
+        let mut buffer = [0; 1];
+
+        assert!(
+            stdin.read_exact(&mut buffer).await.is_err(),
+            "cannot read bytes again because `stdin` has fully consumed",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_write_stdin() {
+        let mut stdin = Stdin { buf: vec![] };
+
+        assert!(
+            stdin.write(b"bazqux").await.is_err(),
+            "cannot write into `stdin`"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_seek_stdin() {
+        let mut stdin = Stdin {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+
+        assert!(
+            stdin.seek(io::SeekFrom::End(0)).await.is_err(),
+            "cannot seek `stdin`",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_read_stdout() {
+        let mut stdout = Stdout {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+        let mut buffer = String::new();
+
+        assert!(
+            stdout.read_to_string(&mut buffer).await.is_err(),
+            "cannot read from `stdout`"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_write_stdout() {
+        let mut stdout = Stdout { buf: vec![] };
+
+        assert!(
+            matches!(stdout.write(b"baz").await, Ok(3)),
+            "writing into `stdout`",
+        );
+        assert!(
+            matches!(stdout.write(b"qux").await, Ok(3)),
+            "writing again into `stdout`",
+        );
+        assert_eq!(
+            stdout.buf,
+            &[b'b', b'a', b'z', b'q', b'u', b'x'],
+            "checking the content of `stdout`",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_seek_stdout() {
+        let mut stdout = Stdout {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+
+        assert!(
+            stdout.seek(io::SeekFrom::End(0)).await.is_err(),
+            "cannot seek `stdout`",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_read_stderr() {
+        let mut stderr = Stderr {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+        let mut buffer = String::new();
+
+        assert!(
+            stderr.read_to_string(&mut buffer).await.is_err(),
+            "cannot read from `stderr`"
+        );
+    }
+
+    #[tokio::test]
+    async fn test_write_stderr() {
+        let mut stderr = Stderr { buf: vec![] };
+
+        assert!(
+            matches!(stderr.write(b"baz").await, Ok(3)),
+            "writing into `stderr`",
+        );
+        assert!(
+            matches!(stderr.write(b"qux").await, Ok(3)),
+            "writing again into `stderr`",
+        );
+        assert_eq!(
+            stderr.buf,
+            &[b'b', b'a', b'z', b'q', b'u', b'x'],
+            "checking the content of `stderr`",
+        );
+    }
+
+    #[tokio::test]
+    async fn test_seek_stderr() {
+        let mut stderr = Stderr {
+            buf: vec![b'f', b'o', b'o', b'b', b'a', b'r'],
+        };
+
+        assert!(
+            stderr.seek(io::SeekFrom::End(0)).await.is_err(),
+            "cannot seek `stderr`",
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/null_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/null_file.rs
new file mode 100644
index 0000000..b211314
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/null_file.rs
@@ -0,0 +1,87 @@
+//! NullFile is a special file for `/dev/null`, which returns 0 for all
+//! operations except writing.
+
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::{ClonableVirtualFile, VirtualFile};
+
+#[derive(Debug, Clone, Default)]
+pub struct NullFile {}
+
+impl AsyncSeek for NullFile {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncWrite for NullFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(bufs.len()))
+    }
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+}
+
+impl AsyncRead for NullFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl VirtualFile for NullFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}
+
+impl ClonableVirtualFile for NullFile {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/ops.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/ops.rs
new file mode 100644
index 0000000..88c9c06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/ops.rs
@@ -0,0 +1,331 @@
+//! Common [`FileSystem`] operations.
+#![allow(dead_code)] // Most of these helpers are used during testing
+
+use std::{
+    collections::VecDeque,
+    path::{Path, PathBuf},
+};
+
+use futures::future::BoxFuture;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+use crate::{DirEntry, FileSystem, FsError};
+
+/// Does this item exists?
+pub fn exists<F>(fs: &F, path: impl AsRef<Path>) -> bool
+where
+    F: FileSystem + ?Sized,
+{
+    fs.metadata(path.as_ref()).is_ok()
+}
+
+/// Does this path refer to a directory?
+pub fn is_dir<F>(fs: &F, path: impl AsRef<Path>) -> bool
+where
+    F: FileSystem + ?Sized,
+{
+    match fs.metadata(path.as_ref()) {
+        Ok(meta) => meta.is_dir(),
+        Err(_) => false,
+    }
+}
+
+/// Does this path refer to a file?
+pub fn is_file<F>(fs: &F, path: impl AsRef<Path>) -> bool
+where
+    F: FileSystem + ?Sized,
+{
+    match fs.metadata(path.as_ref()) {
+        Ok(meta) => meta.is_file(),
+        Err(_) => false,
+    }
+}
+
+/// Make sure a directory (and all its parents) exist.
+///
+/// This is analogous to [`std::fs::create_dir_all()`].
+pub fn create_dir_all<F>(fs: &F, path: impl AsRef<Path>) -> Result<(), FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    let path = path.as_ref();
+    if let Some(parent) = path.parent() {
+        create_dir_all(fs, parent)?;
+    }
+
+    if let Ok(metadata) = fs.metadata(path) {
+        if metadata.is_dir() {
+            return Ok(());
+        }
+        if metadata.is_file() {
+            return Err(FsError::BaseNotDirectory);
+        }
+    }
+
+    fs.create_dir(path)
+}
+
+static WHITEOUT_PREFIX: &str = ".wh.";
+
+/// Creates a white out file which hides it from secondary file systems
+pub fn create_white_out<F>(fs: &F, path: impl AsRef<Path>) -> Result<(), FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    if let Some(filename) = path.as_ref().file_name() {
+        let mut path = path.as_ref().to_owned();
+        path.set_file_name(format!("{}{}", WHITEOUT_PREFIX, filename.to_string_lossy()));
+
+        if let Some(parent) = path.parent() {
+            create_dir_all(fs, parent).ok();
+        }
+
+        fs.new_open_options()
+            .create_new(true)
+            .truncate(true)
+            .write(true)
+            .open(path)?;
+        Ok(())
+    } else {
+        Err(FsError::EntryNotFound)
+    }
+}
+
+/// Removes a white out file from the primary
+pub fn remove_white_out<F>(fs: &F, path: impl AsRef<Path>)
+where
+    F: FileSystem + ?Sized,
+{
+    if let Some(filename) = path.as_ref().file_name() {
+        let mut path = path.as_ref().to_owned();
+        path.set_file_name(format!("{}{}", WHITEOUT_PREFIX, filename.to_string_lossy()));
+        fs.remove_file(&path).ok();
+    }
+}
+
+/// Returns true if the path has been hidden by a whiteout file
+pub fn has_white_out<F>(fs: &F, path: impl AsRef<Path>) -> bool
+where
+    F: FileSystem + ?Sized,
+{
+    if let Some(filename) = path.as_ref().file_name() {
+        let mut path = path.as_ref().to_owned();
+        path.set_file_name(format!("{}{}", WHITEOUT_PREFIX, filename.to_string_lossy()));
+        fs.metadata(&path).is_ok()
+    } else {
+        false
+    }
+}
+
+/// Returns true if the path is a whiteout file
+pub fn is_white_out(path: impl AsRef<Path>) -> Option<PathBuf> {
+    if let Some(filename) = path.as_ref().file_name() {
+        if let Some(filename) = filename.to_string_lossy().strip_prefix(WHITEOUT_PREFIX) {
+            let mut path = path.as_ref().to_owned();
+            path.set_file_name(filename);
+            return Some(path);
+        }
+    }
+    None
+}
+
+/// Copies the reference of a file from one file system to another
+pub fn copy_reference<'a>(
+    source: &'a (impl FileSystem + ?Sized),
+    destination: &'a (impl FileSystem + ?Sized),
+    path: &'a Path,
+) -> BoxFuture<'a, Result<(), std::io::Error>> {
+    Box::pin(async { copy_reference_ext(source, destination, path, path).await })
+}
+
+/// Copies the reference of a file from one file system to another
+pub fn copy_reference_ext<'a>(
+    source: &'a (impl FileSystem + ?Sized),
+    destination: &'a (impl FileSystem + ?Sized),
+    from: &Path,
+    to: &Path,
+) -> BoxFuture<'a, Result<(), std::io::Error>> {
+    let from = from.to_owned();
+    let to = to.to_owned();
+    Box::pin(async move {
+        let src = source.new_open_options().read(true).open(from)?;
+        let mut dst = destination
+            .new_open_options()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(to)?;
+
+        dst.copy_reference(src).await?;
+        Ok(())
+    })
+}
+
+/// Asynchronously write some bytes to a file.
+///
+/// This is analogous to [`std::fs::write()`].
+pub async fn write<F>(
+    fs: &F,
+    path: impl AsRef<Path> + Send,
+    data: impl AsRef<[u8]> + Send,
+) -> Result<(), FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    let path = path.as_ref();
+    let data = data.as_ref();
+
+    let mut f = fs
+        .new_open_options()
+        .create(true)
+        .truncate(true)
+        .write(true)
+        .open(path)?;
+
+    f.write_all(data).await?;
+    f.flush().await?;
+
+    Ok(())
+}
+
+/// Asynchronously read a file's contents into memory.
+///
+/// This is analogous to [`std::fs::read()`].
+pub async fn read<F>(fs: &F, path: impl AsRef<Path> + Send) -> Result<Vec<u8>, FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    let mut f = fs.new_open_options().read(true).open(path.as_ref())?;
+    let mut buffer = Vec::new();
+    f.read_to_end(&mut buffer).await?;
+
+    Ok(buffer)
+}
+
+/// Asynchronously read a file's contents into memory as a string.
+///
+/// This is analogous to [`std::fs::read_to_string()`].
+pub async fn read_to_string<F>(fs: &F, path: impl AsRef<Path> + Send) -> Result<String, FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    let mut f = fs.new_open_options().read(true).open(path.as_ref())?;
+    let mut buffer = String::new();
+    f.read_to_string(&mut buffer).await?;
+
+    Ok(buffer)
+}
+
+/// Update a file's modification and access times, creating the file if it
+/// doesn't already exist.
+pub fn touch<F>(fs: &F, path: impl AsRef<Path> + Send) -> Result<(), FsError>
+where
+    F: FileSystem + ?Sized,
+{
+    let _ = fs.new_open_options().create(true).write(true).open(path)?;
+
+    Ok(())
+}
+
+/// Recursively iterate over all paths inside a directory, ignoring any
+/// errors that may occur along the way.
+pub fn walk<F>(fs: &F, path: impl AsRef<Path>) -> Box<dyn Iterator<Item = DirEntry> + '_>
+where
+    F: FileSystem + ?Sized,
+{
+    let path = path.as_ref();
+    let mut dirs_to_visit: VecDeque<_> = fs
+        .read_dir(path)
+        .ok()
+        .into_iter()
+        .flatten()
+        .filter_map(|result| result.ok())
+        .collect();
+
+    Box::new(std::iter::from_fn(move || {
+        let next = dirs_to_visit.pop_back()?;
+
+        if let Ok(children) = fs.read_dir(&next.path) {
+            dirs_to_visit.extend(children.flatten());
+        }
+
+        Some(next)
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mem_fs::FileSystem as MemFS;
+    use tokio::io::AsyncReadExt;
+
+    #[tokio::test]
+    async fn write() {
+        let fs = MemFS::default();
+
+        super::write(&fs, "/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let mut contents = String::new();
+        fs.new_open_options()
+            .read(true)
+            .open("/file.txt")
+            .unwrap()
+            .read_to_string(&mut contents)
+            .await
+            .unwrap();
+        assert_eq!(contents, "Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn read() {
+        let fs = MemFS::default();
+        fs.new_open_options()
+            .create(true)
+            .write(true)
+            .open("/file.txt")
+            .unwrap()
+            .write_all(b"Hello, World!")
+            .await
+            .unwrap();
+
+        let contents = super::read_to_string(&fs, "/file.txt").await.unwrap();
+        assert_eq!(contents, "Hello, World!");
+
+        let contents = super::read(&fs, "/file.txt").await.unwrap();
+        assert_eq!(contents, b"Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn create_dir_all() {
+        let fs = MemFS::default();
+        super::write(&fs, "/file.txt", b"").await.unwrap();
+
+        assert!(!super::exists(&fs, "/really/nested/directory"));
+        super::create_dir_all(&fs, "/really/nested/directory").unwrap();
+        assert!(super::exists(&fs, "/really/nested/directory"));
+
+        // It's okay to create the same directory multiple times
+        super::create_dir_all(&fs, "/really/nested/directory").unwrap();
+
+        // You can't create a directory on top of a file
+        assert_eq!(
+            super::create_dir_all(&fs, "/file.txt").unwrap_err(),
+            FsError::BaseNotDirectory
+        );
+        assert_eq!(
+            super::create_dir_all(&fs, "/file.txt/invalid/path").unwrap_err(),
+            FsError::BaseNotDirectory
+        );
+    }
+
+    #[tokio::test]
+    async fn touch() {
+        let fs = MemFS::default();
+
+        super::touch(&fs, "/file.txt").unwrap();
+
+        assert_eq!(super::read(&fs, "/file.txt").await.unwrap(), b"");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/overlay_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/overlay_fs.rs
new file mode 100644
index 0000000..8c16f2c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/overlay_fs.rs
@@ -0,0 +1,1630 @@
+use std::{
+    collections::HashSet,
+    fmt::Debug,
+    io::{self, SeekFrom},
+    path::{Path, PathBuf},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use futures::future::BoxFuture;
+use replace_with::replace_with_or_abort;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+
+use crate::{
+    ops, FileOpener, FileSystem, FileSystems, FsError, Metadata, OpenOptions, OpenOptionsConfig,
+    ReadDir, VirtualFile,
+};
+
+/// A primary filesystem and chain of secondary filesystems that are overlayed
+/// on top of each other.
+///
+/// # Precedence
+///
+/// The [`OverlayFileSystem`] will execute operations based on precedence.
+///
+///
+/// Most importantly, this means earlier filesystems can shadow files and
+/// directories that have a lower precedence.
+///
+///# Examples
+///
+/// Something useful to know is that the [`FileSystems`] trait is implemented
+/// for both arrays and tuples.
+///
+/// For example, if you want to create a [`crate::FileSystem`] which will
+/// create files in-memory while still being able to read from the host, you
+/// might do something like this:
+///
+/// ```rust
+/// use virtual_fs::{
+///     mem_fs::FileSystem as MemFS,
+///     host_fs::FileSystem as HostFS,
+///     OverlayFileSystem,
+/// };
+///
+/// let runtime = tokio::runtime::Builder::new_current_thread()
+///     .enable_all()
+///     .build()
+///     .unwrap();
+///     let _guard = runtime.enter();
+///
+/// let fs = OverlayFileSystem::new(MemFS::default(), [HostFS::default()]);
+///
+/// // This also has the benefit of storing the two values in-line with no extra
+/// // overhead or indirection.
+/// assert_eq!(
+///     std::mem::size_of_val(&fs),
+///     std::mem::size_of::<(MemFS, HostFS)>(),
+/// );
+/// ```
+///
+/// A more complex example is
+#[derive(Clone, PartialEq, Eq)]
+pub struct OverlayFileSystem<P, S> {
+    primary: Arc<P>,
+    secondaries: S,
+}
+
+impl<P, S> OverlayFileSystem<P, S>
+where
+    P: FileSystem + Send + Sync + 'static,
+    S: for<'a> FileSystems<'a> + Send + Sync + 'static,
+{
+    /// Create a new [`FileSystem`] using a primary [`crate::FileSystem`] and a
+    /// chain of secondary [`FileSystems`].
+    pub fn new(primary: P, secondaries: S) -> Self {
+        OverlayFileSystem {
+            primary: Arc::new(primary),
+            secondaries,
+        }
+    }
+
+    /// Get a reference to the primary filesystem.
+    pub fn primary(&self) -> &P {
+        &self.primary
+    }
+
+    /// Get a reference to the secondary filesystems.
+    pub fn secondaries(&self) -> &S {
+        &self.secondaries
+    }
+
+    /// Get a mutable reference to the secondary filesystems.
+    pub fn secondaries_mut(&mut self) -> &mut S {
+        &mut self.secondaries
+    }
+
+    fn permission_error_or_not_found(&self, path: &Path) -> Result<(), FsError> {
+        for fs in self.secondaries.filesystems() {
+            if ops::exists(fs, path) {
+                return Err(FsError::PermissionDenied);
+            }
+        }
+
+        Err(FsError::EntryNotFound)
+    }
+}
+
+impl<P, S> FileSystem for OverlayFileSystem<P, S>
+where
+    P: FileSystem + Send + 'static,
+    S: for<'a> FileSystems<'a> + Send + Sync + 'static,
+    for<'a> <<S as FileSystems<'a>>::Iter as IntoIterator>::IntoIter: Send,
+{
+    fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError> {
+        let mut entries = Vec::new();
+        let mut had_at_least_one_success = false;
+        let mut white_outs = HashSet::new();
+
+        let filesystems = std::iter::once(&self.primary as &(dyn FileSystem + Send))
+            .chain(self.secondaries().filesystems());
+
+        for fs in filesystems {
+            match fs.read_dir(path) {
+                Ok(r) => {
+                    for entry in r {
+                        let entry = entry?;
+
+                        // White out entries block any later entries in the secondaries
+                        // unless the entry has comes before the white out, thus the order
+                        // that the file systems are parsed is important to this logic.
+                        if let Some(path) = entry.is_white_out() {
+                            tracing::trace!(
+                                path=%path.display(),
+                                "Found whiteout file",
+                            );
+                            white_outs.insert(path);
+                            continue;
+                        } else if white_outs.contains(&entry.path) {
+                            tracing::trace!(
+                                path=%path.display(),
+                                "Skipping path because a whiteout exists",
+                            );
+                            continue;
+                        }
+
+                        entries.push(entry);
+                    }
+                    had_at_least_one_success = true;
+                }
+                Err(e) if should_continue(e) => continue,
+                Err(e) => return Err(e),
+            }
+        }
+
+        if had_at_least_one_success {
+            // Make sure later entries are removed in favour of earlier ones.
+            // Note: this sort is guaranteed to be stable, meaning filesystems
+            // "higher up" the chain will be further towards the start and kept
+            // when deduplicating.
+            entries.sort_by(|a, b| a.path.cmp(&b.path));
+            entries.dedup_by(|a, b| a.path == b.path);
+
+            Ok(ReadDir::new(entries))
+        } else {
+            Err(FsError::BaseNotDirectory)
+        }
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        // You can not create directories that use the whiteout prefix
+        if ops::is_white_out(path).is_some() {
+            return Err(FsError::InvalidInput);
+        }
+
+        // It could be the case that the directory was earlier hidden in the secondaries
+        // by a whiteout file, hence we need to make sure those are cleared out.
+        ops::remove_white_out(self.primary.as_ref(), path);
+
+        // Make sure the parent tree is in place on the primary, this is to cover the
+        // scenario where the secondaries has a parent structure that is not yet in the
+        // primary and the primary needs it to create a sub-directory
+        if let Some(parent) = path.parent() {
+            if self.read_dir(parent).is_ok() {
+                ops::create_dir_all(&self.primary, parent).ok();
+            }
+        }
+
+        // Create the directory in the primary
+        match self.primary.create_dir(path) {
+            Err(e) if should_continue(e) => {}
+            other => return other,
+        }
+
+        self.permission_error_or_not_found(path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        // Whiteout files can not be removed, instead the original directory
+        // must be removed or recreated.
+        if ops::is_white_out(path).is_some() {
+            tracing::trace!(
+                path=%path.display(),
+                "Unable to remove a whited out directory",
+            );
+            return Err(FsError::EntryNotFound);
+        }
+
+        // If the directory is contained in a secondary file system then we need to create a
+        // whiteout file so that it is suppressed and is no longer returned in `readdir` calls.
+
+        let had_at_least_one_success = self.secondaries.filesystems().into_iter().any(|fs| {
+            fs.read_dir(path).is_ok() && ops::create_white_out(&self.primary, path).is_ok()
+        });
+
+        // Attempt to remove it from the primary, if this succeeds then we may have also
+        // added the whiteout file in the earlier step, but are required in this case to
+        // properly delete the directory.
+        match self.primary.remove_dir(path) {
+            Err(e) if should_continue(e) => {}
+            other => return other,
+        }
+
+        if had_at_least_one_success {
+            return Ok(());
+        }
+        self.permission_error_or_not_found(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        Box::pin(async move {
+            // Whiteout files can not be renamed
+            if ops::is_white_out(&from).is_some() {
+                tracing::trace!(
+                    from=%from.display(),
+                    to=%to.display(),
+                    "Attempting to rename a file that was whited out"
+                );
+                return Err(FsError::EntryNotFound);
+            }
+            // You can not rename a file into a whiteout file
+            if ops::is_white_out(&to).is_some() {
+                tracing::trace!(
+                    from=%from.display(),
+                    to=%to.display(),
+                    "Attempting to rename a file into a whiteout file"
+                );
+                return Err(FsError::InvalidInput);
+            }
+
+            // We attempt to rename the file or directory in the primary
+            // if this succeeds then we also need to ensure the white out
+            // files are created where we need them, so we do not immediately
+            // return until that is done
+            let mut had_at_least_one_success = false;
+            match self.primary.rename(&from, &to).await {
+                Err(e) if should_continue(e) => {}
+                Ok(()) => {
+                    had_at_least_one_success = true;
+                }
+                other => return other,
+            }
+
+            // If we have not yet renamed the file it may still reside in
+            // the secondaries, in which case we need to copy it to the
+            // primary rather than rename it
+            if !had_at_least_one_success {
+                for fs in self.secondaries.filesystems() {
+                    if fs.metadata(&from).is_ok() {
+                        ops::copy_reference_ext(fs, &self.primary, &from, &to).await?;
+                        had_at_least_one_success = true;
+                        break;
+                    }
+                }
+            }
+
+            // If the rename operation was a success then we need to update any
+            // whiteout files on the primary before we return success.
+            if had_at_least_one_success {
+                for fs in self.secondaries.filesystems() {
+                    if fs.metadata(&from).is_ok() {
+                        tracing::trace!(
+                            path=%from.display(),
+                            "Creating a whiteout for the file that was renamed",
+                        );
+                        ops::create_white_out(&self.primary, &from).ok();
+                        break;
+                    }
+                }
+                ops::remove_white_out(&self.primary, &to);
+                return Ok(());
+            }
+
+            // Otherwise we are in a failure scenario
+            self.permission_error_or_not_found(&from)
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        // Whiteout files can not be read, they are just markers
+        if ops::is_white_out(path).is_some() {
+            return Err(FsError::EntryNotFound);
+        }
+
+        // Check if the file is in the primary
+        match self.primary.metadata(path) {
+            Ok(meta) => return Ok(meta),
+            Err(e) if should_continue(e) => {}
+            Err(e) => return Err(e),
+        }
+
+        // There might be a whiteout, search for this
+        if ops::has_white_out(&self.primary, path) {
+            return Err(FsError::EntryNotFound);
+        }
+
+        // Otherwise scan the secondaries
+        for fs in self.secondaries.filesystems() {
+            match fs.metadata(path) {
+                Err(e) if should_continue(e) => continue,
+                other => return other,
+            }
+        }
+
+        Err(FsError::EntryNotFound)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        // It is not possible to delete whiteout files directly, instead
+        // one must delete the original file
+        if ops::is_white_out(path).is_some() {
+            return Err(FsError::InvalidInput);
+        }
+
+        // If the file is contained in a secondary then then we need to create a
+        // whiteout file so that it is suppressed.
+        let had_at_least_one_success = self.secondaries.filesystems().into_iter().any(|fs| {
+            fs.metadata(path).is_ok() && ops::create_white_out(&self.primary, path).is_ok()
+        });
+
+        // Attempt to remove it from the primary
+        match self.primary.remove_file(path) {
+            Err(e) if should_continue(e) => {}
+            other => return other,
+        }
+
+        if had_at_least_one_success {
+            return Ok(());
+        }
+        self.permission_error_or_not_found(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions<'_> {
+        OpenOptions::new(self)
+    }
+}
+
+impl<P, S> FileOpener for OverlayFileSystem<P, S>
+where
+    P: FileSystem + Send + 'static,
+    S: for<'a> FileSystems<'a> + Send + Sync + 'static,
+    for<'a> <<S as FileSystems<'a>>::Iter as IntoIterator>::IntoIter: Send,
+{
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>, FsError> {
+        // Whiteout files can not be read, they are just markers
+        if ops::is_white_out(path).is_some() {
+            tracing::trace!(
+                path=%path.display(),
+                options=?conf,
+                "Whiteout files can't be opened",
+            );
+            return Err(FsError::InvalidInput);
+        }
+
+        // Check if the file is in the primary (without actually creating it) as
+        // when the file is in the primary it takes preference over any of file
+        {
+            let mut conf = conf.clone();
+            conf.create = false;
+            conf.create_new = false;
+            match self.primary.new_open_options().options(conf).open(path) {
+                Err(e) if should_continue(e) => {}
+                other => return other,
+            }
+        }
+
+        // In the scenario that we are creating the file then there is
+        // special handling that will ensure its setup correctly
+        if conf.create_new {
+            // When the secondary has the directory structure but the primary
+            // does not then we need to make sure we create all the structure
+            // in the primary
+            if let Some(parent) = path.parent() {
+                if ops::exists(self, parent) {
+                    // We create the directory structure on the primary so that
+                    // the new file can be created, this will make it override
+                    // whatever is in the primary
+                    ops::create_dir_all(&self.primary, parent)?;
+                } else {
+                    return Err(FsError::EntryNotFound);
+                }
+            }
+
+            // Remove any whiteout
+            ops::remove_white_out(&self.primary, path);
+
+            // Create the file in the primary
+            return self
+                .primary
+                .new_open_options()
+                .options(conf.clone())
+                .open(path);
+        }
+
+        // There might be a whiteout, search for this and if its found then
+        // we are done as the secondary file or directory has been earlier
+        // deleted via a white out (when the create flag is set then
+        // the white out marker is ignored)
+        if !conf.create && ops::has_white_out(&self.primary, path) {
+            tracing::trace!(
+                path=%path.display(),
+                "The file has been whited out",
+            );
+            return Err(FsError::EntryNotFound);
+        }
+
+        // Determine if a mutation will be possible with the opened file
+        let require_mutations = conf.append || conf.write || conf.create_new | conf.truncate;
+
+        // If the file is on a secondary then we should open it
+        if !ops::has_white_out(&self.primary, path) {
+            for fs in self.secondaries.filesystems() {
+                let mut sub_conf = conf.clone();
+                sub_conf.create = false;
+                sub_conf.create_new = false;
+                sub_conf.append = false;
+                sub_conf.truncate = false;
+                match fs.new_open_options().options(sub_conf.clone()).open(path) {
+                    Err(e) if should_continue(e) => continue,
+                    Ok(file) if require_mutations => {
+                        // If the file was opened with the ability to mutate then we need
+                        // to return a copy on write emulation so that the file can be
+                        // copied from the secondary to the primary in the scenario that
+                        // it is edited
+                        return open_copy_on_write(path, conf, &self.primary, file);
+                    }
+                    other => return other,
+                }
+            }
+        }
+
+        // If we are creating the file then do so
+        if conf.create {
+            // Create the parent structure and remove any whiteouts
+            if let Some(parent) = path.parent() {
+                if ops::exists(self, parent) {
+                    ops::create_dir_all(&self.primary, parent)?;
+                }
+            }
+            ops::remove_white_out(&self.primary, path);
+
+            // Create the file in the primary
+            return self
+                .primary
+                .new_open_options()
+                .options(conf.clone())
+                .open(path);
+        }
+
+        // The file does not exist anywhere
+        Err(FsError::EntryNotFound)
+    }
+}
+
+fn open_copy_on_write<P>(
+    path: &Path,
+    conf: &OpenOptionsConfig,
+    primary: &Arc<P>,
+    file: Box<dyn VirtualFile + Send + Sync>,
+) -> Result<Box<dyn VirtualFile + Send + Sync>, FsError>
+where
+    P: FileSystem,
+{
+    struct CopyOnWriteFile<P> {
+        path: PathBuf,
+        primary: Arc<P>,
+        state: CowState,
+        readable: bool,
+        append: bool,
+        new_size: Option<u64>,
+    }
+    enum CowState {
+        // The original file is still open and can be accessed for all
+        // read operations
+        ReadOnly(Box<dyn VirtualFile + Send + Sync>),
+        // The copy has started but first we need to get the cursor
+        // position within the source file so that it can be restored
+        SeekingGet(Box<dyn VirtualFile + Send + Sync>),
+        // Now we have the original starting cursor location we need
+        // to move the position of the read to the start of the source
+        // file
+        SeekingSet {
+            original_offset: u64,
+            src: Box<dyn VirtualFile + Send + Sync>,
+        },
+        // We are now copying the data in parts held in the buffer piece
+        // by piece until the original file is completely copied
+        Copying {
+            original_offset: u64,
+            buf: Vec<u8>,
+            buf_pos: usize,
+            dst: Box<dyn VirtualFile + Send + Sync>,
+            src: Box<dyn VirtualFile + Send + Sync>,
+        },
+        // After copying the file we need to seek the position back
+        // to its original location on the newly copied file
+        SeekingRestore {
+            dst: Box<dyn VirtualFile + Send + Sync>,
+        },
+        // We have copied the file and can use all the normal operations
+        Copied(Box<dyn VirtualFile + Send + Sync>),
+        // An error occurred during the copy operation and we are now in a
+        // failed state, after the error is consumed it will reset back
+        // to the original file
+        Error {
+            err: io::Error,
+            src: Box<dyn VirtualFile + Send + Sync>,
+        },
+    }
+    impl CowState {
+        fn as_ref(&self) -> &(dyn VirtualFile + Send + Sync) {
+            match self {
+                Self::ReadOnly(inner) => inner.as_ref(),
+                Self::SeekingGet(inner) => inner.as_ref(),
+                Self::SeekingSet { src, .. } => src.as_ref(),
+                Self::Copying { src, .. } => src.as_ref(),
+                Self::SeekingRestore { dst, .. } => dst.as_ref(),
+                Self::Copied(inner) => inner.as_ref(),
+                Self::Error { src, .. } => src.as_ref(),
+            }
+        }
+        fn as_mut(&mut self) -> &mut (dyn VirtualFile + Send + Sync) {
+            match self {
+                Self::ReadOnly(inner) => inner.as_mut(),
+                Self::SeekingGet(inner) => inner.as_mut(),
+                Self::SeekingSet { src, .. } => src.as_mut(),
+                Self::Copying { src, .. } => src.as_mut(),
+                Self::SeekingRestore { dst, .. } => dst.as_mut(),
+                Self::Copied(inner) => inner.as_mut(),
+                Self::Error { src, .. } => src.as_mut(),
+            }
+        }
+    }
+
+    impl<P> CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn poll_copy_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+            // Enter a loop until we go pending
+            let mut again = true;
+            while again {
+                again = false;
+
+                // The state machine is updated during the poll operation
+                replace_with_or_abort(&mut self.state, |state| match state {
+                    // We record the current position of the file so that it can be
+                    // restored after the copy-on-write is finished
+                    CowState::SeekingGet(mut src) => {
+                        match Pin::new(src.as_mut()).poll_complete(cx) {
+                            Poll::Ready(Ok(offset)) => {
+                                if let Err(err) =
+                                    Pin::new(src.as_mut()).start_seek(SeekFrom::Start(0))
+                                {
+                                    return CowState::Error { err, src };
+                                }
+                                again = true;
+                                CowState::SeekingSet {
+                                    original_offset: offset,
+                                    src,
+                                }
+                            }
+                            Poll::Ready(Err(err)) => CowState::Error { err, src },
+                            Poll::Pending => CowState::SeekingGet(src),
+                        }
+                    }
+
+                    // We complete the seek operation to the start of the source file
+                    CowState::SeekingSet {
+                        original_offset,
+                        mut src,
+                    } => {
+                        match Pin::new(src.as_mut()).poll_complete(cx).map_ok(|_| ()) {
+                            Poll::Ready(Ok(())) => {
+                                // Remove the whiteout, create the parent structure and open
+                                // the new file on the primary
+                                if let Some(parent) = self.path.parent() {
+                                    ops::create_dir_all(&self.primary, parent).ok();
+                                }
+                                let mut had_white_out = false;
+                                if ops::has_white_out(&self.primary, &self.path) {
+                                    ops::remove_white_out(&self.primary, &self.path);
+                                    had_white_out = true;
+                                }
+                                let dst = self
+                                    .primary
+                                    .new_open_options()
+                                    .create(true)
+                                    .read(self.readable)
+                                    .write(true)
+                                    .truncate(true)
+                                    .open(&self.path);
+                                match dst {
+                                    Ok(dst) if had_white_out => {
+                                        again = true;
+                                        CowState::Copied(dst)
+                                    }
+                                    Ok(dst) => {
+                                        again = true;
+                                        CowState::Copying {
+                                            original_offset,
+                                            buf: Vec::new(),
+                                            buf_pos: 0,
+                                            src,
+                                            dst,
+                                        }
+                                    }
+                                    Err(err) => CowState::Error {
+                                        err: err.into(),
+                                        src,
+                                    },
+                                }
+                            }
+                            Poll::Ready(Err(err)) => CowState::Error { err, src },
+                            Poll::Pending => CowState::SeekingSet {
+                                original_offset,
+                                src,
+                            },
+                        }
+                    }
+                    // We are now copying all the data on blocks
+                    CowState::Copying {
+                        mut src,
+                        mut dst,
+                        mut buf,
+                        mut buf_pos,
+                        original_offset,
+                    } => {
+                        loop {
+                            // We are either copying more data from the source
+                            // or we are copying the data to the destination
+                            if buf_pos < buf.len() {
+                                let dst_pinned = Pin::new(dst.as_mut());
+                                match dst_pinned.poll_write(cx, &buf[buf_pos..]) {
+                                    Poll::Ready(Ok(0)) => {}
+                                    Poll::Ready(Ok(amt)) => {
+                                        buf_pos += amt;
+                                        continue;
+                                    }
+                                    Poll::Ready(Err(err)) => {
+                                        return CowState::Error { err, src };
+                                    }
+                                    Poll::Pending => {}
+                                }
+                            } else {
+                                buf.resize_with(8192, || 0);
+                                buf_pos = 8192;
+                                let mut read_buf = ReadBuf::new(&mut buf);
+                                match Pin::new(src.as_mut()).poll_read(cx, &mut read_buf) {
+                                    Poll::Ready(Ok(())) if read_buf.filled().is_empty() => {
+                                        again = true;
+
+                                        if self.append {
+                                            // When we append then we leave the cursor at the
+                                            // end of the file
+                                            return CowState::Copied(dst);
+                                        } else {
+                                            // No more data exists to be read so we now move on to
+                                            // restoring the cursor back to the original position
+                                            if let Err(err) = Pin::new(dst.as_mut())
+                                                .start_seek(SeekFrom::Start(original_offset))
+                                            {
+                                                return CowState::Error { err, src };
+                                            }
+                                            return CowState::SeekingRestore { dst };
+                                        }
+                                    }
+                                    Poll::Ready(Ok(())) => {
+                                        // There is more data to be processed
+                                        let new_len = read_buf.filled().len();
+                                        unsafe { buf.set_len(new_len) };
+                                        buf_pos = 0;
+                                        continue;
+                                    }
+                                    Poll::Ready(Err(err)) => return CowState::Error { err, src },
+                                    Poll::Pending => {}
+                                }
+                            }
+                            return CowState::Copying {
+                                original_offset,
+                                buf,
+                                buf_pos,
+                                src,
+                                dst,
+                            };
+                        }
+                    }
+                    // Now once the the restoration of the seek position completes we set the copied state
+                    CowState::SeekingRestore { mut dst } => {
+                        match Pin::new(dst.as_mut()).poll_complete(cx) {
+                            Poll::Ready(_) => {
+                                // If we have changed the length then set it
+                                if let Some(new_size) = self.new_size.take() {
+                                    dst.set_len(new_size).ok();
+                                }
+                                CowState::Copied(dst)
+                            }
+                            Poll::Pending => CowState::SeekingRestore { dst },
+                        }
+                    }
+                    s => s,
+                });
+            }
+
+            // Determine what response to give based off the state, when an error occurs
+            // this will be returned and the copy-on-write will be reset
+            let mut ret = Poll::Pending;
+            replace_with_or_abort(&mut self.state, |state| match state {
+                CowState::ReadOnly(src) => {
+                    ret = Poll::Ready(Ok(()));
+                    CowState::ReadOnly(src)
+                }
+                CowState::Copied(src) => {
+                    ret = Poll::Ready(Ok(()));
+                    CowState::Copied(src)
+                }
+                CowState::Error { err, src } => {
+                    ret = Poll::Ready(Err(err));
+                    CowState::ReadOnly(src)
+                }
+                state => {
+                    ret = Poll::Pending;
+                    state
+                }
+            });
+            ret
+        }
+
+        fn poll_copy_start_and_progress(&mut self, cx: &mut Context) -> Poll<io::Result<()>> {
+            replace_with_or_abort(&mut self.state, |state| match state {
+                CowState::ReadOnly(inner) => CowState::SeekingGet(inner),
+                state => state,
+            });
+            self.poll_copy_progress(cx)
+        }
+    }
+
+    impl<P> Debug for CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("CopyOnWriteFile").finish()
+        }
+    }
+
+    impl<P> VirtualFile for CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn last_accessed(&self) -> u64 {
+            self.state.as_ref().last_accessed()
+        }
+
+        fn last_modified(&self) -> u64 {
+            self.state.as_ref().last_modified()
+        }
+
+        fn created_time(&self) -> u64 {
+            self.state.as_ref().created_time()
+        }
+
+        fn size(&self) -> u64 {
+            self.state.as_ref().size()
+        }
+
+        fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+            self.new_size = Some(new_size);
+            replace_with_or_abort(&mut self.state, |state| match state {
+                CowState::Copied(mut file) => {
+                    file.set_len(new_size).ok();
+                    CowState::Copied(file)
+                }
+                state => {
+                    // in the scenario where the length is set but the file is not
+                    // polled then we need to make sure we create a file properly
+                    if let Some(parent) = self.path.parent() {
+                        ops::create_dir_all(&self.primary, parent).ok();
+                    }
+                    let dst = self
+                        .primary
+                        .new_open_options()
+                        .create(true)
+                        .write(true)
+                        .open(&self.path);
+                    if let Ok(mut file) = dst {
+                        file.set_len(new_size).ok();
+                    }
+                    state
+                }
+            });
+            Ok(())
+        }
+
+        fn unlink(&mut self) -> crate::Result<()> {
+            let primary = self.primary.clone();
+            let path = self.path.clone();
+
+            // Create the whiteout file in the primary
+            let mut had_at_least_one_success = false;
+            if ops::create_white_out(&primary, &path).is_ok() {
+                had_at_least_one_success = true;
+            }
+
+            // Attempt to remove it from the primary first
+            match primary.remove_file(&path) {
+                Err(e) if should_continue(e) => {}
+                other => return other,
+            }
+
+            if had_at_least_one_success {
+                return Ok(());
+            }
+            Err(FsError::PermissionDenied)
+        }
+
+        fn poll_read_ready(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> Poll<std::io::Result<usize>> {
+            match self.poll_copy_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Pending => return Poll::Pending,
+            }
+            Pin::new(self.state.as_mut()).poll_read_ready(cx)
+        }
+
+        fn poll_write_ready(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> Poll<std::io::Result<usize>> {
+            match self.poll_copy_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Pending => return Poll::Pending,
+            }
+            Pin::new(self.state.as_mut()).poll_write_ready(cx)
+        }
+    }
+
+    impl<P> AsyncWrite for CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn poll_write(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buf: &[u8],
+        ) -> Poll<Result<usize, std::io::Error>> {
+            match self.poll_copy_start_and_progress(cx) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Ready(Ok(())) => {}
+            }
+            Pin::new(self.state.as_mut()).poll_write(cx, buf)
+        }
+
+        fn poll_write_vectored(
+            mut self: Pin<&mut Self>,
+            cx: &mut Context<'_>,
+            bufs: &[io::IoSlice<'_>],
+        ) -> Poll<Result<usize, io::Error>> {
+            match self.poll_copy_start_and_progress(cx) {
+                Poll::Pending => return Poll::Pending,
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Ready(Ok(())) => {}
+            }
+            Pin::new(self.state.as_mut()).poll_write_vectored(cx, bufs)
+        }
+
+        fn poll_flush(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> Poll<Result<(), std::io::Error>> {
+            match self.poll_copy_start_and_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                p => return p,
+            }
+            Pin::new(self.state.as_mut()).poll_flush(cx)
+        }
+
+        fn poll_shutdown(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> Poll<Result<(), std::io::Error>> {
+            match self.poll_copy_start_and_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                p => return p,
+            }
+            Pin::new(self.state.as_mut()).poll_shutdown(cx)
+        }
+    }
+
+    impl<P> AsyncRead for CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn poll_read(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buf: &mut tokio::io::ReadBuf<'_>,
+        ) -> Poll<std::io::Result<()>> {
+            match self.poll_copy_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                p => return p,
+            }
+            Pin::new(self.state.as_mut()).poll_read(cx, buf)
+        }
+    }
+
+    impl<P> AsyncSeek for CopyOnWriteFile<P>
+    where
+        P: FileSystem + 'static,
+    {
+        fn start_seek(
+            mut self: Pin<&mut Self>,
+            position: std::io::SeekFrom,
+        ) -> std::io::Result<()> {
+            match &mut self.state {
+                CowState::ReadOnly(file)
+                | CowState::SeekingGet(file)
+                | CowState::Error { src: file, .. }
+                | CowState::Copied(file)
+                | CowState::SeekingRestore { dst: file, .. } => {
+                    Pin::new(file.as_mut()).start_seek(position)
+                }
+                CowState::SeekingSet {
+                    original_offset,
+                    src,
+                    ..
+                }
+                | CowState::Copying {
+                    original_offset,
+                    src,
+                    ..
+                } => {
+                    *original_offset = match position {
+                        SeekFrom::Current(delta) => original_offset
+                            .checked_add_signed(delta)
+                            .unwrap_or(*original_offset),
+                        SeekFrom::Start(pos) => pos,
+                        SeekFrom::End(pos) => src
+                            .size()
+                            .checked_add_signed(pos)
+                            .unwrap_or(*original_offset),
+                    };
+                    Ok(())
+                }
+            }
+        }
+
+        fn poll_complete(
+            mut self: Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> Poll<std::io::Result<u64>> {
+            match self.poll_copy_progress(cx) {
+                Poll::Ready(Ok(())) => {}
+                Poll::Ready(Err(err)) => return Poll::Ready(Err(err)),
+                Poll::Pending => return Poll::Pending,
+            }
+            Pin::new(self.state.as_mut()).poll_complete(cx)
+        }
+    }
+
+    tracing::trace!(
+        path=%path.display(),
+        options=?conf,
+        "Opening the file in copy-on-write mode",
+    );
+    Ok(Box::new(CopyOnWriteFile::<P> {
+        path: path.to_path_buf(),
+        primary: primary.clone(),
+        state: CowState::ReadOnly(file),
+        readable: conf.read,
+        append: conf.append,
+        new_size: None,
+    }))
+}
+
+impl<P, S> Debug for OverlayFileSystem<P, S>
+where
+    P: FileSystem,
+    S: for<'a> FileSystems<'a>,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        struct IterFilesystems<'a, S>(&'a S);
+        impl<'a, S> Debug for IterFilesystems<'a, S>
+        where
+            S: for<'b> FileSystems<'b>,
+        {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let mut f = f.debug_list();
+
+                for fs in self.0.filesystems() {
+                    f.entry(&fs);
+                }
+
+                f.finish()
+            }
+        }
+
+        f.debug_struct("OverlayFileSystem")
+            .field("primary", &self.primary)
+            .field("secondaries", &IterFilesystems(&self.secondaries))
+            .finish()
+    }
+}
+
+fn should_continue(e: FsError) -> bool {
+    // HACK: We shouldn't really be ignoring FsError::BaseNotDirectory, but
+    // it's needed because the mem_fs::FileSystem doesn't return
+    // FsError::EntryNotFound when an intermediate directory doesn't exist
+    // (i.e. the "/path/to" in "/path/to/file.txt").
+    matches!(
+        e,
+        FsError::EntryNotFound | FsError::InvalidInput | FsError::BaseNotDirectory
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::PathBuf, sync::Arc};
+
+    use bytes::Bytes;
+    use tempfile::TempDir;
+    use tokio::io::{AsyncReadExt, AsyncSeekExt, AsyncWriteExt};
+    use webc::v1::{ParseOptions, WebCOwned};
+
+    use super::*;
+    use crate::{mem_fs::FileSystem as MemFS, webc_fs::WebcFileSystem, RootFileSystemBuilder};
+
+    const PYTHON: &[u8] = include_bytes!("../../c-api/examples/assets/python-0.1.0.wasmer");
+
+    #[tokio::test]
+    async fn remove_directory() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        let first = Path::new("/first");
+        let second = Path::new("/second");
+        let file_txt = second.join("file.txt");
+        let third = Path::new("/third");
+        primary.create_dir(first).unwrap();
+        primary.create_dir(second).unwrap();
+        primary
+            .new_open_options()
+            .create(true)
+            .write(true)
+            .open(&file_txt)
+            .unwrap()
+            .write_all(b"Hello, World!")
+            .await
+            .unwrap();
+        secondary.create_dir(third).unwrap();
+
+        let overlay = OverlayFileSystem::new(primary, [secondary]);
+
+        // Delete a folder on the primary filesystem
+        overlay.remove_dir(first).unwrap();
+        assert_eq!(
+            overlay.primary().metadata(first).unwrap_err(),
+            FsError::EntryNotFound,
+            "Deleted from primary"
+        );
+        assert!(!ops::exists(&overlay.secondaries[0], second));
+
+        // Directory on the primary fs isn't empty
+        assert_eq!(
+            overlay.remove_dir(second).unwrap_err(),
+            FsError::DirectoryNotEmpty,
+        );
+
+        // Try to remove something on one of the overlay filesystems
+        assert_eq!(overlay.remove_dir(third), Ok(()));
+
+        // It should no longer exist
+        assert_eq!(overlay.metadata(third).unwrap_err(), FsError::EntryNotFound);
+
+        assert!(ops::exists(&overlay.secondaries[0], third));
+    }
+
+    #[tokio::test]
+    async fn open_files() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&primary, "/primary").unwrap();
+        ops::touch(&primary, "/primary/read.txt").unwrap();
+        ops::touch(&primary, "/primary/write.txt").unwrap();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::touch(&secondary, "/secondary/read.txt").unwrap();
+        ops::touch(&secondary, "/secondary/write.txt").unwrap();
+        ops::create_dir_all(&secondary, "/primary").unwrap();
+        ops::write(&secondary, "/primary/read.txt", "This is shadowed")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        // Any new files will be created on the primary fs
+        let _ = fs
+            .new_open_options()
+            .create(true)
+            .write(true)
+            .open("/new.txt")
+            .unwrap();
+        assert!(ops::exists(&fs.primary, "/new.txt"));
+        assert!(!ops::exists(&fs.secondaries[0], "/new.txt"));
+
+        // You can open a file for reading and writing on the primary fs
+        let _ = fs
+            .new_open_options()
+            .create(false)
+            .write(true)
+            .read(true)
+            .open("/primary/write.txt")
+            .unwrap();
+
+        // Files on the primary should always shadow the secondary
+        let content = ops::read_to_string(&fs, "/primary/read.txt").await.unwrap();
+        assert_ne!(content, "This is shadowed");
+    }
+
+    #[tokio::test]
+    async fn create_file_that_looks_like_it_is_in_a_secondary_filesystem_folder() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/path/to/").unwrap();
+        assert!(!ops::is_dir(&primary, "/path/to/"));
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        ops::touch(&fs, "/path/to/file.txt").unwrap();
+
+        assert!(ops::is_dir(&fs.primary, "/path/to/"));
+        assert!(ops::is_file(&fs.primary, "/path/to/file.txt"));
+        assert!(!ops::is_file(&fs.secondaries[0], "/path/to/file.txt"));
+    }
+
+    #[tokio::test]
+    async fn listed_files_appear_overlayed() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        let secondary_overlayed = MemFS::default();
+        ops::create_dir_all(&primary, "/primary").unwrap();
+        ops::touch(&primary, "/primary/read.txt").unwrap();
+        ops::touch(&primary, "/primary/write.txt").unwrap();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::touch(&secondary, "/secondary/read.txt").unwrap();
+        ops::touch(&secondary, "/secondary/write.txt").unwrap();
+        // This second "secondary" filesystem should share the same folders as
+        // the first one.
+        ops::create_dir_all(&secondary_overlayed, "/secondary").unwrap();
+        ops::touch(&secondary_overlayed, "/secondary/overlayed.txt").unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary, secondary_overlayed]);
+
+        let paths: Vec<_> = ops::walk(&fs, "/").map(|entry| entry.path()).collect();
+        assert_eq!(
+            paths,
+            vec![
+                PathBuf::from("/secondary"),
+                PathBuf::from("/secondary/write.txt"),
+                PathBuf::from("/secondary/read.txt"),
+                PathBuf::from("/secondary/overlayed.txt"),
+                PathBuf::from("/primary"),
+                PathBuf::from("/primary/write.txt"),
+                PathBuf::from("/primary/read.txt"),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn wasi_runner_use_case() {
+        // Set up some dummy files on the host
+        let temp = TempDir::new().unwrap();
+        let first = temp.path().join("first");
+        let file_txt = first.join("file.txt");
+        let second = temp.path().join("second");
+        std::fs::create_dir_all(&first).unwrap();
+        std::fs::write(&file_txt, b"First!").unwrap();
+        std::fs::create_dir_all(&second).unwrap();
+        // configure the union FS so things are saved in memory by default
+        // (initialized with a set of unix-like folders), but certain folders
+        // are first to the host.
+        let primary = RootFileSystemBuilder::new().build();
+        let host_fs: Arc<dyn FileSystem + Send + Sync> =
+            Arc::new(crate::host_fs::FileSystem::default());
+        let first_dirs = [(&first, "/first"), (&second, "/second")];
+        for (host, guest) in first_dirs {
+            primary
+                .mount(PathBuf::from(guest), &host_fs, host.clone())
+                .unwrap();
+        }
+        // Set up the secondary file systems
+        let webc = WebCOwned::parse(Bytes::from_static(PYTHON), &ParseOptions::default()).unwrap();
+        let webc = WebcFileSystem::init_all(Arc::new(webc));
+
+        let fs = OverlayFileSystem::new(primary, [webc]);
+
+        // We should get all the normal directories from rootfs (primary)
+        assert!(ops::is_dir(&fs, "/lib"));
+        assert!(ops::is_dir(&fs, "/bin"));
+        assert!(ops::is_file(&fs, "/dev/stdin"));
+        assert!(ops::is_file(&fs, "/dev/stdout"));
+        // We also want to see files from the WEBC volumes (secondary)
+        assert!(ops::is_dir(&fs, "/lib/python3.6"));
+        assert!(ops::is_file(&fs, "/lib/python3.6/collections/__init__.py"));
+        #[cfg(never)]
+        {
+            // files on a secondary fs aren't writable
+            // TODO(Michael-F-Bryan): re-enable this if/when we fix
+            // open_readonly_file_hack()
+            assert_eq!(
+                fs.new_open_options()
+                    .append(true)
+                    .open("/lib/python3.6/collections/__init__.py")
+                    .unwrap_err(),
+                FsError::PermissionDenied,
+            );
+        }
+        // you are allowed to create files that look like they are in a secondary
+        // folder, though
+        ops::touch(&fs, "/lib/python3.6/collections/something-else.py").unwrap();
+        // But it'll be on the primary filesystem, not the secondary one
+        assert!(ops::is_file(
+            &fs.primary,
+            "/lib/python3.6/collections/something-else.py"
+        ));
+        assert!(!ops::is_file(
+            &fs.secondaries[0],
+            "/lib/python3.6/collections/something-else.py"
+        ));
+        // You can do the same thing with folders
+        fs.create_dir("/lib/python3.6/something-else".as_ref())
+            .unwrap();
+        assert!(ops::is_dir(&fs.primary, "/lib/python3.6/something-else"));
+        assert!(!ops::is_dir(
+            &fs.secondaries[0],
+            "/lib/python3.6/something-else"
+        ));
+        // It only works when you are directly inside an existing directory
+        // on the secondary filesystem, though
+        assert_eq!(
+            ops::touch(&fs, "/lib/python3.6/collections/this/doesnt/exist.txt").unwrap_err(),
+            FsError::EntryNotFound
+        );
+        // you should also be able to read files mounted from the host
+        assert!(ops::is_dir(&fs, "/first"));
+        assert!(ops::is_file(&fs, "/first/file.txt"));
+        assert_eq!(
+            ops::read_to_string(&fs, "/first/file.txt").await.unwrap(),
+            "First!"
+        );
+        // Overwriting them is fine and we'll see the changes on the host
+        ops::write(&fs, "/first/file.txt", "Updated").await.unwrap();
+        assert_eq!(std::fs::read_to_string(&file_txt).unwrap(), "Updated");
+        // The filesystem will see changes on the host that happened after it was
+        // set up
+        let another = second.join("another.txt");
+        std::fs::write(&another, "asdf").unwrap();
+        assert_eq!(
+            ops::read_to_string(&fs, "/second/another.txt")
+                .await
+                .unwrap(),
+            "asdf"
+        );
+    }
+
+    fn load_webc(bytes: &'static [u8]) -> WebcFileSystem<WebCOwned> {
+        let options = ParseOptions::default();
+        let webc = WebCOwned::parse(bytes, &options).unwrap();
+        WebcFileSystem::init_all(Arc::new(webc))
+    }
+
+    #[track_caller]
+    fn assert_same_directory_contents(
+        original: &dyn FileSystem,
+        path: impl AsRef<Path>,
+        candidate: &dyn FileSystem,
+    ) {
+        let path = path.as_ref();
+
+        let original_entries: Vec<_> = original
+            .read_dir(path)
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect();
+        let candidate_entries: Vec<_> = candidate
+            .read_dir(path)
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect();
+
+        assert_eq!(original_entries, candidate_entries);
+    }
+
+    #[tokio::test]
+    async fn absolute_and_relative_paths_are_passed_through() {
+        let python = Arc::new(load_webc(PYTHON));
+
+        // The underlying filesystem doesn't care about absolute/relative paths
+        assert_eq!(python.read_dir("/lib".as_ref()).unwrap().count(), 4);
+        assert_eq!(python.read_dir("lib".as_ref()).unwrap().count(), 4);
+
+        // read_dir() should be passed through to the primary
+        let webc_primary =
+            OverlayFileSystem::new(Arc::clone(&python), [crate::EmptyFileSystem::default()]);
+        assert_same_directory_contents(&python, "/lib", &webc_primary);
+        assert_same_directory_contents(&python, "lib", &webc_primary);
+
+        // read_dir() should also be passed through to the secondary
+        let webc_secondary =
+            OverlayFileSystem::new(crate::EmptyFileSystem::default(), [Arc::clone(&python)]);
+        assert_same_directory_contents(&python, "/lib", &webc_secondary);
+        assert_same_directory_contents(&python, "lib", &webc_secondary);
+
+        // It should be fine to overlay the root fs on top of our webc file
+        let overlay_rootfs = OverlayFileSystem::new(
+            RootFileSystemBuilder::default().build(),
+            [Arc::clone(&python)],
+        );
+        assert_same_directory_contents(&python, "/lib", &overlay_rootfs);
+        assert_same_directory_contents(&python, "lib", &overlay_rootfs);
+    }
+
+    #[tokio::test]
+    async fn open_secondary_fs_files_in_write_mode() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        let mut f = fs
+            .new_open_options()
+            .write(true)
+            .read(true)
+            .open("/secondary/file.txt")
+            .unwrap();
+        // reading is fine
+        let mut buf = String::new();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "Hello, World!");
+        f.seek(SeekFrom::Start(0)).await.unwrap();
+        // next we will write a new set of bytes
+        f.set_len(0).unwrap();
+        assert_eq!(f.write(b"Hi").await.unwrap(), 2);
+        // Same with flushing
+        assert_eq!(f.flush().await.unwrap(), (),);
+
+        // if we now read it then the data should be different
+        buf = String::new();
+        f.seek(SeekFrom::Start(0)).await.unwrap();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "Hi");
+        drop(f);
+
+        // including if we open it again
+        let mut f = fs
+            .new_open_options()
+            .read(true)
+            .open("/secondary/file.txt")
+            .unwrap();
+        buf = String::new();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "Hi");
+    }
+
+    #[tokio::test]
+    async fn open_secondary_fs_files_unlink() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        fs.metadata(Path::new("/secondary/file.txt")).unwrap();
+
+        // Now delete the file and make sure its not found
+        fs.remove_file(Path::new("/secondary/file.txt")).unwrap();
+        assert_eq!(
+            fs.metadata(Path::new("/secondary/file.txt")).unwrap_err(),
+            FsError::EntryNotFound
+        )
+    }
+
+    #[tokio::test]
+    async fn open_secondary_fs_without_cow() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        let mut f = fs
+            .new_open_options()
+            .create(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 13);
+
+        let mut buf = String::new();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "Hello, World!");
+
+        // it should not be in the primary and nor should the secondary folder
+        assert!(!ops::is_dir(&fs.primary, "/secondary"));
+        assert!(!ops::is_file(&fs.primary, "/secondary/file.txt"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/secondary"));
+        assert!(ops::is_file(&fs.secondaries[0], "/secondary/file.txt"));
+    }
+
+    #[tokio::test]
+    async fn create_and_append_secondary_fs_with_cow() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        let mut f = fs
+            .new_open_options()
+            .create(true)
+            .append(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 13);
+
+        f.write_all(b"asdf").await.unwrap();
+        assert_eq!(f.size() as usize, 17);
+
+        f.seek(SeekFrom::Start(0)).await.unwrap();
+
+        let mut buf = String::new();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "Hello, World!asdf");
+
+        // Now lets check the file systems under
+        let f = fs
+            .primary
+            .new_open_options()
+            .create(true)
+            .append(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 17);
+        let f = fs.secondaries[0]
+            .new_open_options()
+            .create(true)
+            .append(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 13);
+
+        // it should now exist in both the primary and secondary
+        assert!(ops::is_dir(&fs.primary, "/secondary"));
+        assert!(ops::is_file(&fs.primary, "/secondary/file.txt"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/secondary"));
+        assert!(ops::is_file(&fs.secondaries[0], "/secondary/file.txt"));
+    }
+
+    #[tokio::test]
+    async fn unlink_file_from_secondary_fs() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        fs.remove_file(Path::new("/secondary/file.txt")).unwrap();
+        assert_eq!(ops::exists(&fs, Path::new("/secondary/file.txt")), false);
+
+        assert!(ops::is_file(&fs.primary, "/secondary/.wh.file.txt"));
+        assert!(ops::is_file(&fs.secondaries[0], "/secondary/file.txt"));
+
+        // Now create the file again after the unlink
+        let mut f = fs
+            .new_open_options()
+            .create(true)
+            .write(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 0);
+        f.write_all(b"asdf").await.unwrap();
+        assert_eq!(f.size() as usize, 4);
+
+        // The whiteout should be gone and new file exist
+        assert!(!ops::is_file(&fs.primary, "/secondary/.wh.file.txt"));
+        assert!(ops::is_file(&fs.primary, "/secondary/file.txt"));
+        assert!(ops::is_file(&fs.secondaries[0], "/secondary/file.txt"));
+    }
+
+    #[tokio::test]
+    async fn rmdir_from_secondary_fs() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        assert!(ops::is_dir(&fs, "/secondary"));
+        fs.remove_dir(Path::new("/secondary")).unwrap();
+
+        assert!(!ops::is_dir(&fs, "/secondary"));
+        assert!(ops::is_file(&fs.primary, "/.wh.secondary"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/secondary"));
+
+        fs.create_dir(Path::new("/secondary")).unwrap();
+        assert!(ops::is_dir(&fs, "/secondary"));
+        assert!(ops::is_dir(&fs.primary, "/secondary"));
+        assert!(!ops::is_file(&fs.primary, "/.wh.secondary"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/secondary"));
+    }
+
+    #[tokio::test]
+    async fn rmdir_sub_from_secondary_fs() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/first/secondary").unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        assert!(ops::is_dir(&fs, "/first/secondary"));
+        fs.remove_dir(Path::new("/first/secondary")).unwrap();
+
+        assert!(!ops::is_dir(&fs, "/first/secondary"));
+        assert!(ops::is_file(&fs.primary, "/first/.wh.secondary"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/first/secondary"));
+
+        fs.create_dir(Path::new("/first/secondary")).unwrap();
+        assert!(ops::is_dir(&fs, "/first/secondary"));
+        assert!(ops::is_dir(&fs.primary, "/first/secondary"));
+        assert!(!ops::is_file(&fs.primary, "/first/.wh.secondary"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/first/secondary"));
+    }
+
+    #[tokio::test]
+    async fn create_new_secondary_fs_without_cow() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+        ops::write(&secondary, "/secondary/file.txt", b"Hello, World!")
+            .await
+            .unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        let mut f = fs
+            .new_open_options()
+            .create_new(true)
+            .read(true)
+            .open(Path::new("/secondary/file.txt"))
+            .unwrap();
+        assert_eq!(f.size() as usize, 0);
+
+        let mut buf = String::new();
+        f.read_to_string(&mut buf).await.unwrap();
+        assert_eq!(buf, "");
+
+        // it should now exist in both the primary and secondary
+        assert!(ops::is_dir(&fs.primary, "/secondary"));
+        assert!(ops::is_file(&fs.primary, "/secondary/file.txt"));
+        assert!(ops::is_dir(&fs.secondaries[0], "/secondary"));
+        assert!(ops::is_file(&fs.secondaries[0], "/secondary/file.txt"));
+    }
+
+    #[tokio::test]
+    async fn open_secondary_fs_files_remove_dir() {
+        let primary = MemFS::default();
+        let secondary = MemFS::default();
+        ops::create_dir_all(&secondary, "/secondary").unwrap();
+
+        let fs = OverlayFileSystem::new(primary, [secondary]);
+
+        fs.metadata(Path::new("/secondary")).unwrap();
+
+        // Now delete the file and make sure its not found
+        fs.remove_dir(Path::new("/secondary")).unwrap();
+        assert_eq!(
+            fs.metadata(Path::new("/secondary")).unwrap_err(),
+            FsError::EntryNotFound
+        )
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/passthru_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/passthru_fs.rs
new file mode 100644
index 0000000..08a940e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/passthru_fs.rs
@@ -0,0 +1,98 @@
+//! Wraps a boxed file system with an implemented trait VirtualSystem - this is
+//! needed so that a `Box<dyn VirtualFileSystem>` can be wrapped in an Arc and
+//! shared - some of the interfaces pass around a `Box<dyn VirtualFileSystem>`
+
+use std::path::Path;
+
+use crate::*;
+
+#[derive(Debug)]
+pub struct PassthruFileSystem {
+    fs: Box<dyn FileSystem + Send + Sync + 'static>,
+}
+
+impl PassthruFileSystem {
+    pub fn new(inner: Box<dyn FileSystem + Send + Sync + 'static>) -> Self {
+        Self { fs: inner }
+    }
+}
+
+impl FileSystem for PassthruFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        self.fs.read_dir(path)
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        self.fs.create_dir(path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        self.fs.remove_dir(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { self.fs.rename(from, to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.metadata(path)
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.symlink_metadata(path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        self.fs.remove_file(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        self.fs.new_open_options()
+    }
+}
+
+#[cfg(test)]
+mod test_builder {
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    use crate::{FileSystem, PassthruFileSystem};
+
+    #[tokio::test]
+    async fn test_passthru_fs_2() {
+        let mem_fs = crate::mem_fs::FileSystem::default();
+
+        mem_fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create(true)
+            .open("/foo.txt")
+            .unwrap()
+            .write_all(b"hello")
+            .await
+            .unwrap();
+
+        let mut buf = Vec::new();
+        mem_fs
+            .new_open_options()
+            .read(true)
+            .open("/foo.txt")
+            .unwrap()
+            .read_to_end(&mut buf)
+            .await
+            .unwrap();
+        assert_eq!(buf, b"hello");
+
+        let passthru_fs = PassthruFileSystem::new(Box::new(mem_fs.clone()));
+        let mut buf = Vec::new();
+        passthru_fs
+            .new_open_options()
+            .read(true)
+            .open("/foo.txt")
+            .unwrap()
+            .read_to_end(&mut buf)
+            .await
+            .unwrap();
+        assert_eq!(buf, b"hello");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/pipe.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/pipe.rs
new file mode 100644
index 0000000..f88d148
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/pipe.rs
@@ -0,0 +1,508 @@
+use bytes::{Buf, Bytes};
+#[cfg(feature = "futures")]
+use futures::Future;
+use std::io::IoSlice;
+use std::io::{self, Read, Seek, SeekFrom};
+use std::ops::DerefMut;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::task::Context;
+use std::task::Poll;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+use tokio::sync::{mpsc, mpsc::error::TryRecvError};
+
+use crate::{ArcFile, FsError, VirtualFile};
+
+#[derive(Debug, Clone)]
+pub struct Pipe {
+    /// Transmit side of the pipe
+    send: PipeTx,
+    /// Receive side of the pipe
+    recv: PipeRx,
+}
+
+#[derive(Debug, Clone)]
+pub struct PipeTx {
+    /// Sends bytes down the pipe
+    tx: Arc<Mutex<mpsc::UnboundedSender<Vec<u8>>>>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PipeRx {
+    /// Receives bytes from the pipe
+    /// Also, buffers the last read message from the pipe while its being consumed
+    rx: Arc<Mutex<PipeReceiver>>,
+}
+
+impl PipeRx {
+    fn try_read(&mut self, buf: &mut [u8]) -> Option<usize> {
+        let max_size = buf.len();
+
+        let mut rx = self.rx.lock().unwrap();
+        loop {
+            {
+                if let Some(read_buffer) = rx.buffer.as_mut() {
+                    let buf_len = read_buffer.len();
+                    if buf_len > 0 {
+                        let mut read = buf_len.min(max_size);
+                        let mut inner_buf = &read_buffer[..read];
+                        read = match Read::read(&mut inner_buf, buf) {
+                            Ok(a) => a,
+                            Err(_) => return None,
+                        };
+                        read_buffer.advance(read);
+                        return Some(read);
+                    }
+                }
+            }
+            let data = {
+                match rx.chan.try_recv() {
+                    Ok(a) => a,
+                    Err(TryRecvError::Empty) => {
+                        return None;
+                    }
+                    Err(TryRecvError::Disconnected) => {
+                        return Some(0);
+                    }
+                }
+            };
+            rx.buffer.replace(Bytes::from(data));
+        }
+    }
+}
+
+#[derive(Debug)]
+struct PipeReceiver {
+    chan: mpsc::UnboundedReceiver<Vec<u8>>,
+    buffer: Option<Bytes>,
+}
+
+impl Pipe {
+    fn new() -> Self {
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        Pipe {
+            send: PipeTx {
+                tx: Arc::new(Mutex::new(tx)),
+            },
+            recv: PipeRx {
+                rx: Arc::new(Mutex::new(PipeReceiver {
+                    chan: rx,
+                    buffer: None,
+                })),
+            },
+        }
+    }
+
+    pub fn channel() -> (Pipe, Pipe) {
+        let (tx1, rx1) = Pipe::new().split();
+        let (tx2, rx2) = Pipe::new().split();
+
+        let end1 = Pipe::combine(tx1, rx2);
+        let end2 = Pipe::combine(tx2, rx1);
+        (end1, end2)
+    }
+
+    pub fn split(self) -> (PipeTx, PipeRx) {
+        (self.send, self.recv)
+    }
+
+    pub fn combine(tx: PipeTx, rx: PipeRx) -> Self {
+        Self { send: tx, recv: rx }
+    }
+
+    pub fn try_read(&mut self, buf: &mut [u8]) -> Option<usize> {
+        self.recv.try_read(buf)
+    }
+}
+
+impl From<Pipe> for PipeTx {
+    fn from(val: Pipe) -> Self {
+        val.send
+    }
+}
+
+impl From<Pipe> for PipeRx {
+    fn from(val: Pipe) -> Self {
+        val.recv
+    }
+}
+
+impl Pipe {
+    pub fn close(&self) {
+        self.send.close();
+    }
+}
+
+impl PipeTx {
+    pub fn close(&self) {
+        // TODO: proper close() implementation - Propably want to store the writer in an Option<>
+        let (mut null_tx, _) = mpsc::unbounded_channel();
+        {
+            let mut guard = self.tx.lock().unwrap();
+            std::mem::swap(guard.deref_mut(), &mut null_tx);
+        }
+    }
+}
+
+impl Seek for Pipe {
+    fn seek(&mut self, from: SeekFrom) -> io::Result<u64> {
+        self.recv.seek(from)
+    }
+}
+
+impl Seek for PipeRx {
+    fn seek(&mut self, _: SeekFrom) -> io::Result<u64> {
+        Ok(0)
+    }
+}
+
+impl Seek for PipeTx {
+    fn seek(&mut self, _: SeekFrom) -> io::Result<u64> {
+        Ok(0)
+    }
+}
+
+impl Read for Pipe {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        self.recv.read(buf)
+    }
+}
+
+impl Read for PipeRx {
+    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+        let max_size = buf.len();
+
+        let mut rx = self.rx.lock().unwrap();
+        loop {
+            {
+                if let Some(read_buffer) = rx.buffer.as_mut() {
+                    let buf_len = read_buffer.len();
+                    if buf_len > 0 {
+                        let mut read = buf_len.min(max_size);
+                        let mut inner_buf = &read_buffer[..read];
+                        read = Read::read(&mut inner_buf, buf)?;
+                        read_buffer.advance(read);
+                        return Ok(read);
+                    }
+                }
+            }
+            let data = {
+                match rx.chan.blocking_recv() {
+                    Some(a) => a,
+                    None => {
+                        return Ok(0);
+                    }
+                }
+            };
+            rx.buffer.replace(Bytes::from(data));
+        }
+    }
+}
+
+impl std::io::Write for Pipe {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.send.write(buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.send.flush()
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
+        self.send.write_all(buf)
+    }
+
+    fn write_fmt(&mut self, fmt: std::fmt::Arguments<'_>) -> io::Result<()> {
+        self.send.write_fmt(fmt)
+    }
+
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
+        self.send.write_vectored(bufs)
+    }
+}
+
+impl std::io::Write for PipeTx {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let tx = self.tx.lock().unwrap();
+        tx.send(buf.to_vec())
+            .map_err(|_| Into::<std::io::Error>::into(std::io::ErrorKind::BrokenPipe))?;
+        Ok(buf.len())
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
+    }
+}
+
+impl AsyncSeek for Pipe {
+    fn start_seek(mut self: Pin<&mut Self>, position: SeekFrom) -> io::Result<()> {
+        let this = Pin::new(&mut self.recv);
+        this.start_seek(position)
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        let this = Pin::new(&mut self.recv);
+        this.poll_complete(cx)
+    }
+}
+
+impl AsyncSeek for PipeRx {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncSeek for PipeTx {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncWrite for Pipe {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let this = Pin::new(&mut self.send);
+        this.poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        let this = Pin::new(&mut self.send);
+        this.poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        let this = Pin::new(&mut self.send);
+        this.poll_shutdown(cx)
+    }
+
+    fn poll_write_vectored(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<Result<usize, io::Error>> {
+        let this = Pin::new(&mut self.send);
+        this.poll_write_vectored(cx, bufs)
+    }
+}
+
+impl AsyncWrite for PipeTx {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        let guard = self.tx.lock().unwrap();
+        match guard.send(buf.to_vec()) {
+            Ok(()) => Poll::Ready(Ok(buf.len())),
+            Err(_) => Poll::Ready(Err(Into::<std::io::Error>::into(
+                std::io::ErrorKind::BrokenPipe,
+            ))),
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        self.close();
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncRead for Pipe {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = Pin::new(&mut self.recv);
+        this.poll_read(cx, buf)
+    }
+}
+
+impl AsyncRead for PipeRx {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut rx = self.rx.lock().unwrap();
+        loop {
+            {
+                if let Some(inner_buf) = rx.buffer.as_mut() {
+                    let buf_len = inner_buf.len();
+                    if buf_len > 0 {
+                        let read = buf_len.min(buf.remaining());
+                        buf.put_slice(&inner_buf[..read]);
+                        inner_buf.advance(read);
+                        return Poll::Ready(Ok(()));
+                    }
+                }
+            }
+            let mut rx = Pin::new(rx.deref_mut());
+            let data = match rx.chan.poll_recv(cx) {
+                Poll::Ready(Some(a)) => a,
+                Poll::Ready(None) => return Poll::Ready(Ok(())),
+                Poll::Pending => return Poll::Pending,
+            };
+
+            rx.buffer.replace(Bytes::from(data));
+        }
+    }
+}
+
+impl VirtualFile for Pipe {
+    /// the last time the file was accessed in nanoseconds as a UNIX timestamp
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+
+    /// the last time the file was modified in nanoseconds as a UNIX timestamp
+    fn last_modified(&self) -> u64 {
+        0
+    }
+
+    /// the time at which the file was created in nanoseconds as a UNIX timestamp
+    fn created_time(&self) -> u64 {
+        0
+    }
+
+    /// the size of the file in bytes
+    fn size(&self) -> u64 {
+        0
+    }
+
+    /// Change the size of the file, if the `new_size` is greater than the current size
+    /// the extra bytes will be allocated and zeroed
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+
+    /// Request deletion of the file
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+
+    /// Indicates if the file is opened or closed. This function must not block
+    /// Defaults to a status of being constantly open
+    fn is_open(&self) -> bool {
+        self.send
+            .tx
+            .try_lock()
+            .map(|a| !a.is_closed())
+            .unwrap_or_else(|_| true)
+    }
+
+    /// Polls the file for when there is data to be read
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut rx = self.recv.rx.lock().unwrap();
+        loop {
+            {
+                if let Some(inner_buf) = rx.buffer.as_mut() {
+                    let buf_len = inner_buf.len();
+                    if buf_len > 0 {
+                        return Poll::Ready(Ok(buf_len));
+                    }
+                }
+            }
+
+            let mut pinned_rx = Pin::new(&mut rx.chan);
+            let data = match pinned_rx.poll_recv(cx) {
+                Poll::Ready(Some(a)) => a,
+                Poll::Ready(None) => return Poll::Ready(Ok(0)),
+                Poll::Pending => return Poll::Pending,
+            };
+
+            rx.buffer.replace(Bytes::from(data));
+        }
+    }
+
+    /// Polls the file for when it is available for writing
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let tx = self.send.tx.lock().unwrap();
+        if tx.is_closed() {
+            Poll::Ready(Ok(0))
+        } else {
+            Poll::Ready(Ok(8192))
+        }
+    }
+}
+
+/// A pair of pipes that are connected together.
+#[derive(Clone, Debug)]
+pub struct DuplexPipe {
+    front: Pipe,
+    back: Pipe,
+}
+
+impl DuplexPipe {
+    /// Get the sender pipe.
+    pub fn front(&self) -> &Pipe {
+        &self.front
+    }
+
+    /// Get the receiver pipe.
+    pub fn back(&self) -> &Pipe {
+        &self.back
+    }
+
+    /// Get the mutable sender pipe.
+    pub fn front_mut(&mut self) -> &mut Pipe {
+        &mut self.front
+    }
+
+    /// Get the receiver pipe.
+    pub fn back_mut(&mut self) -> &mut Pipe {
+        &mut self.back
+    }
+
+    /// Split into two pipes that are connected to each other
+    pub fn split(self) -> (Pipe, Pipe) {
+        (self.front, self.back)
+    }
+
+    /// Combines two ends of a duplex pipe back together again
+    pub fn combine(front: Pipe, back: Pipe) -> Self {
+        Self { front, back }
+    }
+
+    pub fn reverse(self) -> Self {
+        let (front, back) = self.split();
+        Self::combine(back, front)
+    }
+}
+
+impl Default for DuplexPipe {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl DuplexPipe {
+    pub fn new() -> DuplexPipe {
+        let (end1, end2) = Pipe::channel();
+        Self {
+            front: end1,
+            back: end2,
+        }
+    }
+}
+
+/// Shared version of BidiPipe for situations where you need
+/// to emulate the old behaviour of `Pipe` (both send and recv on one channel).
+pub type WasiBidirectionalSharedPipePair = ArcFile<DuplexPipe>;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/random_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/random_file.rs
new file mode 100644
index 0000000..5722859
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/random_file.rs
@@ -0,0 +1,88 @@
+//! Used for /dev/zero - infinitely returns zero
+//! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
+
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Debug, Default)]
+pub struct RandomFile {}
+
+impl AsyncSeek for RandomFile {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncWrite for RandomFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(bufs.len()))
+    }
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+}
+
+impl AsyncRead for RandomFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let mut data = vec![0u8; buf.remaining()];
+        getrandom::getrandom(&mut data).ok();
+        buf.put_slice(&data[..]);
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl VirtualFile for RandomFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/scoped_directory_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/scoped_directory_fs.rs
new file mode 100644
index 0000000..43b3b02
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/scoped_directory_fs.rs
@@ -0,0 +1,198 @@
+use std::path::{Component, Path, PathBuf};
+
+use futures::future::BoxFuture;
+
+use crate::{
+    DirEntry, FileOpener, FileSystem, FsError, Metadata, OpenOptions, OpenOptionsConfig, ReadDir,
+    VirtualFile,
+};
+
+/// A [`FileSystem`] implementation that is scoped to a specific directory on
+/// the host.
+#[derive(Debug, Clone)]
+pub struct ScopedDirectoryFileSystem {
+    root: PathBuf,
+    inner: crate::host_fs::FileSystem,
+}
+
+impl ScopedDirectoryFileSystem {
+    pub fn new(root: impl Into<PathBuf>, inner: crate::host_fs::FileSystem) -> Self {
+        ScopedDirectoryFileSystem {
+            root: root.into(),
+            inner,
+        }
+    }
+
+    /// Create a new [`ScopedDirectoryFileSystem`] using the current
+    /// [`tokio::runtime::Handle`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if called outside of a `tokio` context.
+    pub fn new_with_default_runtime(root: impl Into<PathBuf>) -> Self {
+        let handle = tokio::runtime::Handle::current();
+        let fs = crate::host_fs::FileSystem::new(handle);
+        ScopedDirectoryFileSystem::new(root, fs)
+    }
+
+    fn prepare_path(&self, path: &Path) -> PathBuf {
+        let path = normalize_path(path);
+        let path = path.strip_prefix("/").unwrap_or(&path);
+
+        let path = if !path.starts_with(&self.root) {
+            self.root.join(path)
+        } else {
+            path.to_owned()
+        };
+
+        debug_assert!(path.starts_with(&self.root));
+        path
+    }
+}
+
+impl FileSystem for ScopedDirectoryFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError> {
+        let path = self.prepare_path(path);
+
+        let mut entries = Vec::new();
+
+        for entry in self.inner.read_dir(&path)? {
+            let entry = entry?;
+            let path = entry
+                .path
+                .strip_prefix(&self.root)
+                .map_err(|_| FsError::InvalidData)?;
+            entries.push(DirEntry {
+                path: Path::new("/").join(path),
+                ..entry
+            });
+        }
+
+        Ok(ReadDir::new(entries))
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = self.prepare_path(path);
+        self.inner.create_dir(&path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = self.prepare_path(path);
+        self.inner.remove_dir(&path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Box::pin(async move {
+            let from = self.prepare_path(from);
+            let to = self.prepare_path(to);
+            self.inner.rename(&from, &to).await
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = self.prepare_path(path);
+        self.inner.metadata(&path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        let path = self.prepare_path(path);
+        self.inner.remove_file(&path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+}
+
+impl FileOpener for ScopedDirectoryFileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync + 'static>, FsError> {
+        let path = self.prepare_path(path);
+        self.inner
+            .new_open_options()
+            .options(conf.clone())
+            .open(&path)
+    }
+}
+
+// Copied from cargo
+// https://github.com/rust-lang/cargo/blob/fede83ccf973457de319ba6fa0e36ead454d2e20/src/cargo/util/paths.rs#L61
+fn normalize_path(path: &Path) -> PathBuf {
+    let mut components = path.components().peekable();
+
+    if matches!(components.peek(), Some(Component::Prefix(..))) {
+        // This bit diverges from the original cargo implementation, but we want
+        // to ignore the drive letter or UNC prefix on Windows. This shouldn't
+        // make a difference in practice because WASI is meant to give us
+        // Unix-style paths, not Windows-style ones.
+        let _ = components.next();
+    }
+
+    let mut ret = PathBuf::new();
+
+    for component in components {
+        match component {
+            Component::Prefix(..) => unreachable!(),
+            Component::RootDir => {}
+            Component::CurDir => {}
+            Component::ParentDir => {
+                ret.pop();
+            }
+            Component::Normal(c) => {
+                ret.push(c);
+            }
+        }
+    }
+    ret
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+    use tokio::io::AsyncReadExt;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn open_files() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("file.txt"), "Hello, World!").unwrap();
+        let fs = ScopedDirectoryFileSystem::new_with_default_runtime(temp.path());
+
+        let mut f = fs.new_open_options().read(true).open("/file.txt").unwrap();
+        let mut contents = String::new();
+        f.read_to_string(&mut contents).await.unwrap();
+
+        assert_eq!(contents, "Hello, World!");
+    }
+
+    #[tokio::test]
+    async fn cant_access_outside_the_scoped_directory() {
+        let scoped_directory = TempDir::new().unwrap();
+        std::fs::write(scoped_directory.path().join("file.txt"), "").unwrap();
+        std::fs::create_dir_all(scoped_directory.path().join("nested").join("dir")).unwrap();
+        let fs = ScopedDirectoryFileSystem::new_with_default_runtime(scoped_directory.path());
+
+        // Using ".." shouldn't let you escape the scoped directory
+        let mut directory_entries: Vec<_> = fs
+            .read_dir("/../../../".as_ref())
+            .unwrap()
+            .map(|e| e.unwrap().path())
+            .collect();
+        directory_entries.sort();
+        assert_eq!(
+            directory_entries,
+            vec![PathBuf::from("/file.txt"), PathBuf::from("/nested")],
+        );
+
+        // Using a directory's absolute path also shouldn't work
+        let other_dir = TempDir::new().unwrap();
+        assert_eq!(
+            fs.read_dir(other_dir.path()).unwrap_err(),
+            FsError::EntryNotFound
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/special_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/special_file.rs
new file mode 100644
index 0000000..a726e46
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/special_file.rs
@@ -0,0 +1,108 @@
+//! Used for /dev/stdin, /dev/stdout, dev/stderr - returns a
+//! static file descriptor (0, 1, 2)
+
+use std::io::{self, *};
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use crate::VirtualFile;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+pub type Fd = u32;
+
+/// A "special" file is a file that is locked
+/// to one file descriptor (i.e. stdout => 0, stdin => 1), etc.
+#[derive(Debug)]
+pub struct DeviceFile {
+    fd: Fd,
+}
+
+impl DeviceFile {
+    pub const STDIN: Fd = 0;
+    pub const STDOUT: Fd = 1;
+    pub const STDERR: Fd = 2;
+
+    pub fn new(fd: Fd) -> Self {
+        Self { fd }
+    }
+}
+
+impl AsyncSeek for DeviceFile {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncWrite for DeviceFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(bufs.len()))
+    }
+
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+}
+
+impl AsyncRead for DeviceFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl VirtualFile for DeviceFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn get_special_fd(&self) -> Option<u32> {
+        Some(self.fd)
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_file.rs
new file mode 100644
index 0000000..b37ef2c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_file.rs
@@ -0,0 +1,133 @@
+use std::{
+    convert::TryInto,
+    io::{self, Cursor},
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use shared_buffer::OwnedBuffer;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::{FsError, VirtualFile};
+
+/// An immutable file backed by an [`OwnedBuffer`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct StaticFile(Cursor<OwnedBuffer>);
+
+impl StaticFile {
+    pub fn new(bytes: impl Into<OwnedBuffer>) -> Self {
+        StaticFile(Cursor::new(bytes.into()))
+    }
+
+    /// Access the underlying buffer.
+    pub fn contents(&self) -> &OwnedBuffer {
+        self.0.get_ref()
+    }
+}
+
+#[async_trait::async_trait]
+impl VirtualFile for StaticFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+
+    fn last_modified(&self) -> u64 {
+        0
+    }
+
+    fn created_time(&self) -> u64 {
+        0
+    }
+
+    fn size(&self) -> u64 {
+        self.0.get_ref().len().try_into().unwrap()
+    }
+
+    fn set_len(&mut self, _new_size: u64) -> Result<(), FsError> {
+        Err(FsError::PermissionDenied)
+    }
+
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Err(FsError::PermissionDenied)
+    }
+
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let remaining = self.size() - self.0.position();
+        Poll::Ready(Ok(remaining.try_into().unwrap()))
+    }
+
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+}
+
+impl AsyncRead for StaticFile {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.0).poll_read(cx, buf)
+    }
+}
+
+// WebC file is not writable, the FileOpener will return a MemoryFile for writing instead
+// This code should never be executed (since writes are redirected to memory instead).
+impl AsyncWrite for StaticFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncSeek for StaticFile {
+    fn start_seek(mut self: Pin<&mut Self>, pos: io::SeekFrom) -> io::Result<()> {
+        Pin::new(&mut self.0).start_seek(pos)
+    }
+
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Pin::new(&mut self.0).poll_complete(cx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tokio::io::AsyncReadExt;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn read_a_static_file_to_end() {
+        let mut file = StaticFile::new(OwnedBuffer::from_static(b"Hello, World!"));
+        let mut buffer = [0; 5];
+
+        let bytes_read = file.read(&mut buffer).await.unwrap();
+        assert_eq!(bytes_read, 5);
+        assert_eq!(&buffer[..bytes_read], b"Hello");
+        assert_eq!(file.0.position(), 5);
+
+        let bytes_read = file.read(&mut buffer).await.unwrap();
+        assert_eq!(bytes_read, 5);
+        assert_eq!(&buffer[..bytes_read], b", Wor");
+        assert_eq!(file.0.position(), 10);
+
+        let bytes_read = file.read(&mut buffer).await.unwrap();
+        assert_eq!(bytes_read, 3);
+        assert_eq!(&buffer[..bytes_read], b"ld!");
+        assert_eq!(file.0.position(), 13);
+
+        let bytes_read = file.read(&mut buffer).await.unwrap();
+        assert_eq!(bytes_read, 0);
+        assert_eq!(&buffer[..bytes_read], b"");
+        assert_eq!(file.0.position(), 13);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_fs.rs
new file mode 100644
index 0000000..767741e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/static_fs.rs
@@ -0,0 +1,392 @@
+use anyhow::anyhow;
+use futures::future::BoxFuture;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use std::convert::TryInto;
+use std::io::{self, Error as IoError, ErrorKind as IoErrorKind, SeekFrom};
+use std::path::Path;
+use std::path::PathBuf;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use crate::mem_fs::FileSystem as MemFileSystem;
+use crate::{
+    FileOpener, FileSystem, FsError, Metadata, OpenOptions, OpenOptionsConfig, ReadDir, VirtualFile,
+};
+use indexmap::IndexMap;
+use webc::v1::{FsEntry, FsEntryType, OwnedFsEntryFile};
+
+/// Custom file system wrapper to map requested file paths
+#[derive(Debug)]
+pub struct StaticFileSystem {
+    pub package: String,
+    pub volumes: Arc<IndexMap<String, webc::v1::Volume<'static>>>,
+    pub memory: Arc<MemFileSystem>,
+}
+
+impl StaticFileSystem {
+    pub fn init(bytes: &'static [u8], package: &str) -> Option<Self> {
+        let volumes = Arc::new(webc::v1::WebC::parse_volumes_from_fileblock(bytes).ok()?);
+        let fs = Self {
+            package: package.to_string(),
+            volumes: volumes.clone(),
+            memory: Arc::new(MemFileSystem::default()),
+        };
+        let volume_names = fs.volumes.keys().cloned().collect::<Vec<_>>();
+        for volume_name in volume_names {
+            let directories = volumes.get(&volume_name).unwrap().list_directories();
+            for directory in directories {
+                let _ = fs.create_dir(Path::new(&directory));
+            }
+        }
+        Some(fs)
+    }
+}
+
+/// Custom file opener, returns a WebCFile
+impl FileOpener for StaticFileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        _conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync>, FsError> {
+        match get_volume_name_opt(path) {
+            Some(volume) => {
+                let file = (*self.volumes)
+                    .get(&volume)
+                    .ok_or(FsError::EntryNotFound)?
+                    .get_file_entry(path.to_string_lossy().as_ref())
+                    .map_err(|_e| FsError::EntryNotFound)?;
+
+                Ok(Box::new(WebCFile {
+                    package: self.package.clone(),
+                    volume,
+                    volumes: self.volumes.clone(),
+                    path: path.to_path_buf(),
+                    entry: file,
+                    cursor: 0,
+                }))
+            }
+            None => {
+                for (volume, v) in self.volumes.iter() {
+                    let entry = match v.get_file_entry(path.to_string_lossy().as_ref()) {
+                        Ok(s) => s,
+                        Err(_) => continue, // error
+                    };
+
+                    return Ok(Box::new(WebCFile {
+                        package: self.package.clone(),
+                        volume: volume.clone(),
+                        volumes: self.volumes.clone(),
+                        path: path.to_path_buf(),
+                        entry,
+                        cursor: 0,
+                    }));
+                }
+                self.memory.new_open_options().open(path)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WebCFile {
+    pub volumes: Arc<IndexMap<String, webc::v1::Volume<'static>>>,
+    pub package: String,
+    pub volume: String,
+    pub path: PathBuf,
+    pub entry: OwnedFsEntryFile,
+    pub cursor: u64,
+}
+
+#[async_trait::async_trait]
+impl VirtualFile for WebCFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        self.entry.get_len()
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let remaining = self.entry.get_len() - self.cursor;
+        Poll::Ready(Ok(remaining as usize))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncRead for WebCFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let bytes = self
+            .volumes
+            .get(&self.volume)
+            .ok_or_else(|| {
+                IoError::new(
+                    IoErrorKind::NotFound,
+                    anyhow!("Unknown volume {:?}", self.volume),
+                )
+            })?
+            .get_file_bytes(&self.entry)
+            .map_err(|e| IoError::new(IoErrorKind::NotFound, e))?;
+
+        let cursor: usize = self.cursor.try_into().unwrap_or(u32::MAX as usize);
+        let _start = cursor.min(bytes.len());
+        let bytes = &bytes[cursor..];
+
+        if bytes.len() > buf.remaining() {
+            let remaining = buf.remaining();
+            buf.put_slice(&bytes[..remaining]);
+        } else {
+            buf.put_slice(bytes);
+        }
+        Poll::Ready(Ok(()))
+    }
+}
+
+// WebC file is not writable, the FileOpener will return a MemoryFile for writing instead
+// This code should never be executed (since writes are redirected to memory instead).
+impl AsyncWrite for WebCFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncSeek for WebCFile {
+    fn start_seek(mut self: Pin<&mut Self>, pos: io::SeekFrom) -> io::Result<()> {
+        let self_size = self.size();
+        match pos {
+            SeekFrom::Start(s) => {
+                self.cursor = s.min(self_size);
+            }
+            SeekFrom::End(e) => {
+                let self_size_i64 = self_size.try_into().unwrap_or(i64::MAX);
+                self.cursor = ((self_size_i64).saturating_add(e))
+                    .min(self_size_i64)
+                    .try_into()
+                    .unwrap_or(i64::MAX as u64);
+            }
+            SeekFrom::Current(c) => {
+                self.cursor = (self
+                    .cursor
+                    .saturating_add(c.try_into().unwrap_or(i64::MAX as u64)))
+                .min(self_size);
+            }
+        }
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(self.cursor))
+    }
+}
+
+fn get_volume_name_opt<P: AsRef<Path>>(path: P) -> Option<String> {
+    use std::path::Component::Normal;
+    if let Some(Normal(n)) = path.as_ref().components().next() {
+        if let Some(s) = n.to_str() {
+            if s.ends_with(':') {
+                return Some(s.replace(':', ""));
+            }
+        }
+    }
+    None
+}
+
+fn transform_into_read_dir(path: &Path, fs_entries: &[FsEntry<'_>]) -> crate::ReadDir {
+    let entries = fs_entries
+        .iter()
+        .map(|e| crate::DirEntry {
+            path: path.join(&*e.text),
+            metadata: Ok(crate::Metadata {
+                ft: translate_file_type(e.fs_type),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: e.get_len(),
+            }),
+        })
+        .collect();
+
+    crate::ReadDir::new(entries)
+}
+
+impl FileSystem for StaticFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError> {
+        let path = normalizes_path(path);
+        for volume in self.volumes.values() {
+            let read_dir_result = volume
+                .read_dir(&path)
+                .map(|o| transform_into_read_dir(Path::new(&path), o.as_ref()))
+                .map_err(|_| FsError::EntryNotFound);
+
+            match read_dir_result {
+                Ok(o) => {
+                    return Ok(o);
+                }
+                Err(_) => {
+                    continue;
+                }
+            }
+        }
+
+        self.memory.read_dir(Path::new(&path))
+    }
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.create_dir(Path::new(&path));
+        result
+    }
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_dir(Path::new(&path));
+        if self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+            .is_some()
+        {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Box::pin(async {
+            let from = normalizes_path(from);
+            let to = normalizes_path(to);
+            let result = self.memory.rename(Path::new(&from), Path::new(&to)).await;
+            if self
+                .volumes
+                .values()
+                .find_map(|v| v.get_file_entry(&from).ok())
+                .is_some()
+            {
+                Ok(())
+            } else {
+                result
+            }
+        })
+    }
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if let Some(_fs) = self.volumes.values().find_map(|v| v.read_dir(&path).ok()) {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.metadata(Path::new(&path))
+        }
+    }
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_file(Path::new(&path));
+        if self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+            .is_some()
+        {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .values()
+            .find_map(|v| v.get_file_entry(&path).ok())
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if self
+            .volumes
+            .values()
+            .find_map(|v| v.read_dir(&path).ok())
+            .is_some()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.symlink_metadata(Path::new(&path))
+        }
+    }
+}
+
+fn normalizes_path(path: &Path) -> String {
+    let path = format!("{}", path.display());
+    if !path.starts_with('/') {
+        format!("/{path}")
+    } else {
+        path
+    }
+}
+
+fn translate_file_type(f: FsEntryType) -> crate::FileType {
+    crate::FileType {
+        dir: f == FsEntryType::Dir,
+        file: f == FsEntryType::File,
+        symlink: false,
+        char_device: false,
+        block_device: false,
+        socket: false,
+        fifo: false,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/tmp_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/tmp_fs.rs
new file mode 100644
index 0000000..46e47f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/tmp_fs.rs
@@ -0,0 +1,95 @@
+//! Wraps the memory file system implementation - this has been
+//! enhanced to support mounting file systems, shared static files,
+//! readonly files, etc...
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use crate::{
+    limiter::DynFsMemoryLimiter, mem_fs, BoxFuture, FileSystem, Metadata, OpenOptions, ReadDir,
+    Result,
+};
+
+#[derive(Debug, Default, Clone)]
+pub struct TmpFileSystem {
+    fs: mem_fs::FileSystem,
+}
+
+impl TmpFileSystem {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn set_memory_limiter(&self, limiter: DynFsMemoryLimiter) {
+        self.fs.set_memory_limiter(limiter);
+    }
+
+    pub fn new_open_options_ext(&self) -> &mem_fs::FileSystem {
+        self.fs.new_open_options_ext()
+    }
+
+    pub fn union(&self, other: &Arc<dyn FileSystem + Send + Sync>) {
+        self.fs.union(other)
+    }
+
+    /// See [`mem_fs::FileSystem::mount_directory_entries`].
+    pub fn mount_directory_entries(
+        &self,
+        target_path: &Path,
+        other: &Arc<dyn crate::FileSystem + Send + Sync>,
+        source_path: &Path,
+    ) -> Result<()> {
+        self.fs
+            .mount_directory_entries(target_path, other, source_path)
+    }
+
+    pub fn mount(
+        &self,
+        src_path: PathBuf,
+        other: &Arc<dyn FileSystem + Send + Sync>,
+        dst_path: PathBuf,
+    ) -> Result<()> {
+        self.fs.mount(src_path, other, dst_path)
+    }
+
+    /// Canonicalize a path without validating that it actually exists.
+    pub fn canonicalize_unchecked(&self, path: &Path) -> Result<PathBuf> {
+        self.fs.canonicalize_unchecked(path)
+    }
+}
+
+impl FileSystem for TmpFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        self.fs.read_dir(path)
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        self.fs.create_dir(path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        self.fs.remove_dir(path)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async { self.fs.rename(from, to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.metadata(path)
+    }
+
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        self.fs.symlink_metadata(path)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        self.fs.remove_file(path)
+    }
+
+    fn new_open_options(&self) -> OpenOptions {
+        self.fs.new_open_options()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/trace_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/trace_fs.rs
new file mode 100644
index 0000000..461b1cb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/trace_fs.rs
@@ -0,0 +1,243 @@
+use std::{
+    path::PathBuf,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use futures::future::BoxFuture;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite, ReadBuf};
+
+use crate::{FileOpener, FileSystem, OpenOptionsConfig, VirtualFile};
+
+/// A [`FileSystem`] wrapper that will automatically log all operations at the
+/// `trace` level.
+///
+/// To see these logs, you will typically need to set the `$RUST_LOG`
+/// environment variable to `virtual_fs::trace_fs=trace`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TraceFileSystem<F>(pub F);
+
+impl<F> TraceFileSystem<F> {
+    pub fn new(filesystem: F) -> Self {
+        TraceFileSystem(filesystem)
+    }
+
+    pub fn inner(&self) -> &F {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut F {
+        &mut self.0
+    }
+
+    pub fn into_inner(self) -> F {
+        self.0
+    }
+}
+
+impl<F> FileSystem for TraceFileSystem<F>
+where
+    F: FileSystem,
+{
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn read_dir(&self, path: &std::path::Path) -> crate::Result<crate::ReadDir> {
+        self.0.read_dir(path)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn create_dir(&self, path: &std::path::Path) -> crate::Result<()> {
+        self.0.create_dir(path)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn remove_dir(&self, path: &std::path::Path) -> crate::Result<()> {
+        self.0.remove_dir(path)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn rename<'a>(
+        &'a self,
+        from: &'a std::path::Path,
+        to: &'a std::path::Path,
+    ) -> BoxFuture<'a, crate::Result<()>> {
+        Box::pin(async { self.0.rename(from, to).await })
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn metadata(&self, path: &std::path::Path) -> crate::Result<crate::Metadata> {
+        self.0.metadata(path)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), err)]
+    fn remove_file(&self, path: &std::path::Path) -> crate::Result<()> {
+        self.0.remove_file(path)
+    }
+
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn new_open_options(&self) -> crate::OpenOptions {
+        crate::OpenOptions::new(self)
+    }
+}
+
+impl<F> FileOpener for TraceFileSystem<F>
+where
+    F: FileSystem,
+{
+    #[tracing::instrument(level = "trace", skip(self))]
+    fn open(
+        &self,
+        path: &std::path::Path,
+        conf: &OpenOptionsConfig,
+    ) -> crate::Result<Box<dyn crate::VirtualFile + Send + Sync + 'static>> {
+        let file = self.0.new_open_options().options(conf.clone()).open(path)?;
+        Ok(Box::new(TraceFile {
+            file,
+            path: path.to_owned(),
+        }))
+    }
+}
+
+#[derive(Debug)]
+struct TraceFile {
+    path: PathBuf,
+    file: Box<dyn crate::VirtualFile + Send + Sync + 'static>,
+}
+
+impl VirtualFile for TraceFile {
+    #[tracing::instrument(level = "trace", skip(self), fields(path=%self.path.display()))]
+    fn last_accessed(&self) -> u64 {
+        self.file.last_accessed()
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), fields(path=%self.path.display()))]
+    fn last_modified(&self) -> u64 {
+        self.file.last_modified()
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), fields(path=%self.path.display()))]
+    fn created_time(&self) -> u64 {
+        self.file.created_time()
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), fields(path=%self.path.display()))]
+    fn size(&self) -> u64 {
+        self.file.size()
+    }
+
+    #[tracing::instrument(level = "trace", skip(self), fields(path=%self.path.display()), err)]
+    fn set_len(&mut self, new_size: u64) -> crate::Result<()> {
+        self.file.set_len(new_size)
+    }
+
+    fn unlink(&mut self) -> crate::Result<()> {
+        self.file.unlink()
+    }
+
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_read_ready(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<std::io::Result<usize>> {
+        let result = Pin::new(&mut *self.file).poll_read_ready(cx);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_write_ready(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<std::io::Result<usize>> {
+        let result = Pin::new(&mut *self.file).poll_write_ready(cx);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+}
+
+impl AsyncRead for TraceFile {
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let result = Pin::new(&mut *self.file).poll_read(cx, buf);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+}
+
+impl AsyncWrite for TraceFile {
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, std::io::Error>> {
+        let result = Pin::new(&mut *self.file).poll_write(cx, buf);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        let result = Pin::new(&mut *self.file).poll_flush(cx);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        let result = Pin::new(&mut *self.file).poll_shutdown(cx);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+}
+
+impl AsyncSeek for TraceFile {
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()), err)]
+    fn start_seek(mut self: Pin<&mut Self>, position: std::io::SeekFrom) -> std::io::Result<()> {
+        Pin::new(&mut *self.file).start_seek(position)
+    }
+
+    #[tracing::instrument(level = "trace", skip_all, fields(path=%self.path.display()))]
+    fn poll_complete(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<u64>> {
+        let result = Pin::new(&mut *self.file).poll_complete(cx);
+
+        if let Poll::Ready(Err(e)) = &result {
+            tracing::trace!(error = e as &dyn std::error::Error);
+        }
+
+        result
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/union_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/union_fs.rs
new file mode 100644
index 0000000..635a92c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/union_fs.rs
@@ -0,0 +1,1111 @@
+//! Another implementation of the union that uses paths,
+//! its not as simple as TmpFs. not currently used but was used by
+//! the previoulsy implementation of Deploy - now using TmpFs
+
+use crate::*;
+
+use std::{
+    path::Path,
+    sync::{Arc, Mutex, Weak},
+};
+
+use tracing::{debug, trace};
+
+pub type TempHolding = Arc<Mutex<Option<Arc<Box<dyn FileSystem>>>>>;
+
+#[derive(Debug)]
+pub struct MountPoint {
+    pub path: String,
+    pub name: String,
+    pub fs: Option<Arc<Box<dyn FileSystem>>>,
+    pub weak_fs: Weak<Box<dyn FileSystem>>,
+    pub temp_holding: TempHolding,
+    pub should_sanitize: bool,
+    pub new_path: Option<String>,
+}
+
+impl Clone for MountPoint {
+    fn clone(&self) -> Self {
+        Self {
+            path: self.path.clone(),
+            name: self.name.clone(),
+            fs: None,
+            weak_fs: self.weak_fs.clone(),
+            temp_holding: self.temp_holding.clone(),
+            should_sanitize: self.should_sanitize,
+            new_path: self.new_path.clone(),
+        }
+    }
+}
+
+impl MountPoint {
+    pub fn fs(&self) -> Option<Arc<Box<dyn FileSystem>>> {
+        match &self.fs {
+            Some(a) => Some(a.clone()),
+            None => self.weak_fs.upgrade(),
+        }
+    }
+
+    /// Tries to recover the internal `Weak<dyn FileSystem>` to a `Arc<dyn FileSystem>`
+    fn solidify(&mut self) {
+        if self.fs.is_none() {
+            self.fs = self.weak_fs.upgrade();
+        }
+        {
+            let mut guard = self.temp_holding.lock().unwrap();
+            let fs = guard.take();
+            if self.fs.is_none() {
+                self.fs = fs;
+            }
+        }
+    }
+
+    /// Returns a strong-referenced copy of the internal `Arc<dyn FileSystem>`
+    fn strong(&self) -> Option<StrongMountPoint> {
+        self.fs().map(|fs| StrongMountPoint {
+            path: self.path.clone(),
+            name: self.name.clone(),
+            fs,
+            should_sanitize: self.should_sanitize,
+            new_path: self.new_path.clone(),
+        })
+    }
+}
+
+/// A `strong` mount point holds a strong `Arc` reference to the filesystem
+/// mounted at path `path`.
+#[derive(Debug)]
+pub struct StrongMountPoint {
+    pub path: String,
+    pub name: String,
+    pub fs: Arc<Box<dyn FileSystem>>,
+    pub should_sanitize: bool,
+    pub new_path: Option<String>,
+}
+
+/// Allows different filesystems of different types
+/// to be mounted at various mount points
+#[derive(Debug, Default, Clone)]
+pub struct UnionFileSystem {
+    pub mounts: Vec<MountPoint>,
+}
+
+impl UnionFileSystem {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn clear(&mut self) {
+        self.mounts.clear();
+    }
+}
+
+impl UnionFileSystem {
+    pub fn mount(
+        &mut self,
+        name: &str,
+        path: &str,
+        should_sanitize: bool,
+        fs: Box<dyn FileSystem>,
+        new_path: Option<&str>,
+    ) {
+        self.unmount(path);
+        let mut path = path.to_string();
+        if !path.starts_with('/') {
+            path.insert(0, '/');
+        }
+        if !path.ends_with('/') {
+            path += "/";
+        }
+        let new_path = new_path.map(|new_path| {
+            let mut new_path = new_path.to_string();
+            if !new_path.ends_with('/') {
+                new_path += "/";
+            }
+            new_path
+        });
+        let fs = Arc::new(fs);
+
+        let mount = MountPoint {
+            path,
+            name: name.to_string(),
+            fs: None,
+            weak_fs: Arc::downgrade(&fs),
+            temp_holding: Arc::new(Mutex::new(Some(fs.clone()))),
+            should_sanitize,
+            new_path,
+        };
+
+        self.mounts.push(mount);
+    }
+
+    pub fn unmount(&mut self, path: &str) {
+        let path1 = path.to_string();
+        let mut path2 = path1;
+        if !path2.starts_with('/') {
+            path2.insert(0, '/');
+        }
+        let mut path3 = path2.clone();
+        if !path3.ends_with('/') {
+            path3.push('/')
+        }
+        if path2.ends_with('/') {
+            path2 = (path2[..(path2.len() - 1)]).to_string();
+        }
+
+        self.mounts
+            .retain(|mount| mount.path != path2 && mount.path != path3);
+    }
+
+    fn read_dir_internal(&self, path: &Path) -> Result<ReadDir> {
+        let path = path.to_string_lossy();
+
+        let mut ret = None;
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.read_dir(Path::new(path.as_str())) {
+                Ok(dir) => {
+                    if ret.is_none() {
+                        ret = Some(Vec::new());
+                    }
+                    let ret = ret.as_mut().unwrap();
+                    for sub in dir.flatten() {
+                        ret.push(sub);
+                    }
+                }
+                Err(err) => {
+                    debug!("failed to read dir - {}", err);
+                }
+            }
+        }
+
+        match ret {
+            Some(mut ret) => {
+                ret.sort_by(|a, b| match (a.metadata.as_ref(), b.metadata.as_ref()) {
+                    (Ok(a), Ok(b)) => a.modified.cmp(&b.modified),
+                    _ => std::cmp::Ordering::Equal,
+                });
+                Ok(ReadDir::new(ret))
+            }
+            None => Err(FsError::EntryNotFound),
+        }
+    }
+
+    /// Deletes all mount points that do not have `sanitize` set in the options
+    pub fn sanitize(mut self) -> Self {
+        self.solidify();
+        self.mounts.retain(|mount| !mount.should_sanitize);
+        self
+    }
+
+    /// Tries to recover the internal `Weak<dyn FileSystem>` to a `Arc<dyn FileSystem>`
+    pub fn solidify(&mut self) {
+        for mount in self.mounts.iter_mut() {
+            mount.solidify();
+        }
+    }
+}
+
+impl FileSystem for UnionFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<ReadDir> {
+        debug!("read_dir: path={}", path.display());
+        self.read_dir_internal(path)
+    }
+    fn create_dir(&self, path: &Path) -> Result<()> {
+        debug!("create_dir: path={}", path.display());
+        if path.parent().is_none() {
+            return Err(FsError::BaseNotDirectory);
+        }
+        if self.read_dir_internal(path).is_ok() {
+            //return Err(FsError::AlreadyExists);
+            return Ok(());
+        }
+
+        let path = path.to_string_lossy();
+        let mut ret_error = FsError::EntryNotFound;
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.create_dir(Path::new(path.as_str())) {
+                Ok(ret) => {
+                    return Ok(ret);
+                }
+                Err(err) => {
+                    ret_error = err;
+                }
+            }
+        }
+        Err(ret_error)
+    }
+    fn remove_dir(&self, path: &Path) -> Result<()> {
+        debug!("remove_dir: path={}", path.display());
+        if path.parent().is_none() {
+            return Err(FsError::BaseNotDirectory);
+        }
+        // https://github.com/rust-lang/rust/issues/86442
+        // DirectoryNotEmpty is not implemented consistently
+        if path.is_dir() && self.read_dir(path).map(|s| !s.is_empty()).unwrap_or(false) {
+            return Err(FsError::DirectoryNotEmpty);
+        }
+        let mut ret_error = FsError::EntryNotFound;
+        let path = path.to_string_lossy();
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.remove_dir(Path::new(path.as_str())) {
+                Ok(ret) => {
+                    return Ok(ret);
+                }
+                Err(err) => {
+                    ret_error = err;
+                }
+            }
+        }
+        Err(ret_error)
+    }
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async {
+            println!("rename: from={} to={}", from.display(), to.display());
+            if from.parent().is_none() {
+                return Err(FsError::BaseNotDirectory);
+            }
+            if to.parent().is_none() {
+                return Err(FsError::BaseNotDirectory);
+            }
+            let mut ret_error = FsError::EntryNotFound;
+            let from = from.to_string_lossy();
+            let to = to.to_string_lossy();
+            #[cfg(target_os = "windows")]
+            let to = to.replace('\\', "/");
+            for (path, mount) in filter_mounts(&self.mounts, from.as_ref()) {
+                let mut to = if to.starts_with(mount.path.as_str()) {
+                    (to[mount.path.len()..]).to_string()
+                } else {
+                    ret_error = FsError::UnknownError;
+                    continue;
+                };
+                if !to.starts_with('/') {
+                    to = format!("/{}", to);
+                }
+                match mount
+                    .fs
+                    .rename(Path::new(&path), Path::new(to.as_str()))
+                    .await
+                {
+                    Ok(ret) => {
+                        trace!("rename ok");
+                        return Ok(ret);
+                    }
+                    Err(err) => {
+                        trace!("rename error (from={}, to={}) - {}", from, to, err);
+                        ret_error = err;
+                    }
+                }
+            }
+            trace!("rename failed - {}", ret_error);
+            Err(ret_error)
+        })
+    }
+    fn metadata(&self, path: &Path) -> Result<Metadata> {
+        debug!("metadata: path={}", path.display());
+        let mut ret_error = FsError::EntryNotFound;
+        let path = path.to_string_lossy();
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.metadata(Path::new(path.as_str())) {
+                Ok(ret) => {
+                    return Ok(ret);
+                }
+                Err(err) => {
+                    // This fixes a bug when attempting to create the directory /usr when it does not exist
+                    // on the x86 version of memfs
+                    // TODO: patch virtual-fs and remove
+                    if let FsError::NotAFile = &err {
+                        ret_error = FsError::EntryNotFound;
+                    } else {
+                        debug!("metadata failed: (path={}) - {}", path, err);
+                        ret_error = err;
+                    }
+                }
+            }
+        }
+        Err(ret_error)
+    }
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata> {
+        debug!("symlink_metadata: path={}", path.display());
+        let mut ret_error = FsError::EntryNotFound;
+        let path = path.to_string_lossy();
+        for (path_inner, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.symlink_metadata(Path::new(path_inner.as_str())) {
+                Ok(ret) => {
+                    return Ok(ret);
+                }
+                Err(err) => {
+                    // This fixes a bug when attempting to create the directory /usr when it does not exist
+                    // on the x86 version of memfs
+                    // TODO: patch virtual-fs and remove
+                    if let FsError::NotAFile = &err {
+                        ret_error = FsError::EntryNotFound;
+                    } else {
+                        debug!("metadata failed: (path={}) - {}", path, err);
+                        ret_error = err;
+                    }
+                }
+            }
+        }
+        debug!("symlink_metadata: failed={}", ret_error);
+        Err(ret_error)
+    }
+    fn remove_file(&self, path: &Path) -> Result<()> {
+        println!("remove_file: path={}", path.display());
+        let mut ret_error = FsError::EntryNotFound;
+        let path = path.to_string_lossy();
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.remove_file(Path::new(path.as_str())) {
+                Ok(ret) => {
+                    return Ok(ret);
+                }
+                Err(err) => {
+                    println!("returning error {err:?}");
+                    ret_error = err;
+                }
+            }
+        }
+        Err(ret_error)
+    }
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+}
+
+fn filter_mounts(
+    mounts: &[MountPoint],
+    target: &str,
+) -> impl Iterator<Item = (String, StrongMountPoint)> {
+    // On Windows, Path might use \ instead of /, wich mill messup the matching of mount points
+    #[cfg(target_os = "windows")]
+    let target = target.replace('\\', "/");
+
+    let mut biggest_path = 0usize;
+    let mut ret = Vec::new();
+    for mount in mounts.iter().rev() {
+        let mut test_mount_path1 = mount.path.clone();
+        if !test_mount_path1.ends_with('/') {
+            test_mount_path1.push('/');
+        }
+
+        let mut test_mount_path2 = mount.path.clone();
+        if test_mount_path2.ends_with('/') {
+            test_mount_path2 = test_mount_path2[..(test_mount_path2.len() - 1)].to_string();
+        }
+
+        if target == test_mount_path1 || target == test_mount_path2 {
+            if let Some(mount) = mount.strong() {
+                biggest_path = biggest_path.max(mount.path.len());
+                let mut path = "/".to_string();
+                if let Some(ref np) = mount.new_path {
+                    path = np.to_string();
+                }
+                ret.push((path, mount));
+            }
+        } else if target.starts_with(test_mount_path1.as_str()) {
+            if let Some(mount) = mount.strong() {
+                biggest_path = biggest_path.max(mount.path.len());
+                let path = &target[test_mount_path2.len()..];
+                let mut path = path.to_string();
+                if let Some(ref np) = mount.new_path {
+                    path = format!("{}{}", np, &path[1..]);
+                }
+                ret.push((path, mount));
+            }
+        }
+    }
+    ret.retain(|(_, b)| b.path.len() >= biggest_path);
+    ret.into_iter()
+}
+
+impl FileOpener for UnionFileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync>> {
+        debug!("open: path={}", path.display());
+        let mut ret_err = FsError::EntryNotFound;
+        let path = path.to_string_lossy();
+
+        if conf.create() || conf.create_new() {
+            for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+                if let Ok(mut ret) = mount
+                    .fs
+                    .new_open_options()
+                    .truncate(conf.truncate())
+                    .append(conf.append())
+                    .read(conf.read())
+                    .write(conf.write())
+                    .open(path)
+                {
+                    if conf.create_new() {
+                        ret.unlink().ok();
+                        continue;
+                    }
+                    return Ok(ret);
+                }
+            }
+        }
+        for (path, mount) in filter_mounts(&self.mounts, path.as_ref()) {
+            match mount.fs.new_open_options().options(conf.clone()).open(path) {
+                Ok(ret) => return Ok(ret),
+                Err(err) if ret_err == FsError::EntryNotFound => {
+                    ret_err = err;
+                }
+                _ => {}
+            }
+        }
+        Err(ret_err)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use tokio::io::AsyncWriteExt;
+
+    use crate::{mem_fs, ops, FileSystem as FileSystemTrait, FsError, UnionFileSystem};
+
+    fn gen_filesystem() -> UnionFileSystem {
+        let mut union = UnionFileSystem::new();
+        // fs.mount("/", Box::new(mem_fs::FileSystem::default()));
+        let a = mem_fs::FileSystem::default();
+        let b = mem_fs::FileSystem::default();
+        let c = mem_fs::FileSystem::default();
+        let d = mem_fs::FileSystem::default();
+        let e = mem_fs::FileSystem::default();
+        let f = mem_fs::FileSystem::default();
+        let g = mem_fs::FileSystem::default();
+        let h = mem_fs::FileSystem::default();
+
+        union.mount("mem_fs_1", "/test_new_filesystem", false, Box::new(a), None);
+        union.mount("mem_fs_2", "/test_create_dir", false, Box::new(b), None);
+        union.mount("mem_fs_3", "/test_remove_dir", false, Box::new(c), None);
+        union.mount("mem_fs_4", "/test_rename", false, Box::new(d), None);
+        union.mount("mem_fs_5", "/test_metadata", false, Box::new(e), None);
+        union.mount("mem_fs_6", "/test_remove_file", false, Box::new(f), None);
+        union.mount("mem_fs_6", "/test_readdir", false, Box::new(g), None);
+        union.mount("mem_fs_6", "/test_canonicalize", false, Box::new(h), None);
+
+        union
+    }
+
+    #[tokio::test]
+    async fn test_new_filesystem() {
+        let fs = gen_filesystem();
+        assert!(
+            fs.read_dir(Path::new("/test_new_filesystem")).is_ok(),
+            "hostfs can read root"
+        );
+        let mut file_write = fs
+            .new_open_options()
+            .read(true)
+            .write(true)
+            .create_new(true)
+            .open(Path::new("/test_new_filesystem/foo2.txt"))
+            .unwrap();
+        file_write.write_all(b"hello").await.unwrap();
+        let _ = std::fs::remove_file("/test_new_filesystem/foo2.txt");
+    }
+
+    #[tokio::test]
+    async fn test_create_dir() {
+        let fs = gen_filesystem();
+
+        assert_eq!(
+            fs.create_dir(Path::new("/")),
+            Err(FsError::BaseNotDirectory),
+            "creating a directory that has no parent",
+        );
+
+        let _ = fs_extra::remove_items(&["/test_create_dir"]);
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_create_dir")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_create_dir/foo")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        let cur_dir = read_dir_names(&fs, "/test_create_dir");
+
+        if !cur_dir.contains(&"foo".to_string()) {
+            panic!("cur_dir does not contain foo: {:#?}", cur_dir);
+        }
+
+        assert!(
+            cur_dir.contains(&"foo".to_string()),
+            "the root is updated and well-defined"
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_create_dir/foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        let foo_dir = read_dir_names(&fs, "/test_create_dir/foo");
+
+        assert!(
+            foo_dir.contains(&"bar".to_string()),
+            "the foo directory is updated and well-defined"
+        );
+
+        let bar_dir = read_dir_names(&fs, "/test_create_dir/foo/bar");
+
+        assert!(
+            bar_dir.is_empty(),
+            "the foo directory is updated and well-defined"
+        );
+        let _ = fs_extra::remove_items(&["/test_create_dir"]);
+    }
+
+    #[tokio::test]
+    async fn test_remove_dir() {
+        let fs = gen_filesystem();
+
+        let _ = fs_extra::remove_items(&["/test_remove_dir"]);
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/")),
+            Err(FsError::BaseNotDirectory),
+            "removing a directory that has no parent",
+        );
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/foo")),
+            Err(FsError::EntryNotFound),
+            "cannot remove a directory that doesn't exist",
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_remove_dir")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_remove_dir/foo")),
+            Ok(()),
+            "creating a directory",
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_remove_dir/foo/bar")),
+            Ok(()),
+            "creating a sub-directory",
+        );
+
+        assert!(
+            read_dir_names(&fs, "/test_remove_dir/foo").contains(&"bar".to_string()),
+            "./foo/bar exists"
+        );
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/test_remove_dir/foo")),
+            Err(FsError::DirectoryNotEmpty),
+            "removing a directory that has children",
+        );
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/test_remove_dir/foo/bar")),
+            Ok(()),
+            "removing a sub-directory",
+        );
+
+        assert_eq!(
+            fs.remove_dir(Path::new("/test_remove_dir/foo")),
+            Ok(()),
+            "removing a directory",
+        );
+
+        assert!(
+            !read_dir_names(&fs, "/test_remove_dir").contains(&"foo".to_string()),
+            "the foo directory still exists"
+        );
+
+        let _ = fs_extra::remove_items(&["/test_remove_dir"]);
+    }
+
+    fn read_dir_names(fs: &dyn crate::FileSystem, path: &str) -> Vec<String> {
+        fs.read_dir(Path::new(path))
+            .unwrap()
+            .filter_map(|entry| Some(entry.ok()?.file_name().to_str()?.to_string()))
+            .collect::<Vec<_>>()
+    }
+
+    #[tokio::test]
+    async fn test_rename() {
+        let fs = gen_filesystem();
+
+        let _ = fs_extra::remove_items(&["./test_rename"]);
+
+        assert_eq!(
+            fs.rename(Path::new("/"), Path::new("/bar")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming a directory that has no parent",
+        );
+        assert_eq!(
+            fs.rename(Path::new("/foo"), Path::new("/")).await,
+            Err(FsError::BaseNotDirectory),
+            "renaming to a directory that has no parent",
+        );
+
+        assert_eq!(fs.create_dir(Path::new("/test_rename")), Ok(()));
+        assert_eq!(fs.create_dir(Path::new("/test_rename/foo")), Ok(()));
+        assert_eq!(fs.create_dir(Path::new("/test_rename/foo/qux")), Ok(()));
+
+        assert_eq!(
+            fs.rename(
+                Path::new("/test_rename/foo"),
+                Path::new("/test_rename/bar/baz")
+            )
+            .await,
+            Err(FsError::EntryNotFound),
+            "renaming to a directory that has parent that doesn't exist",
+        );
+
+        assert_eq!(fs.create_dir(Path::new("/test_rename/bar")), Ok(()));
+
+        assert_eq!(
+            fs.rename(Path::new("/test_rename/foo"), Path::new("/test_rename/bar"))
+                .await,
+            Ok(()),
+            "renaming to a directory that has parent that exists",
+        );
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("/test_rename/bar/hello1.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello1.txt`)",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("/test_rename/bar/hello2.txt")),
+                Ok(_),
+            ),
+            "creating a new file (`hello2.txt`)",
+        );
+
+        let cur_dir = read_dir_names(&fs, "/test_rename");
+
+        assert!(
+            !cur_dir.contains(&"foo".to_string()),
+            "the foo directory still exists"
+        );
+
+        assert!(
+            cur_dir.contains(&"bar".to_string()),
+            "the bar directory still exists"
+        );
+
+        let bar_dir = read_dir_names(&fs, "/test_rename/bar");
+
+        if !bar_dir.contains(&"qux".to_string()) {
+            println!("qux does not exist: {:?}", bar_dir)
+        }
+
+        let qux_dir = read_dir_names(&fs, "/test_rename/bar/qux");
+
+        assert!(qux_dir.is_empty(), "the qux directory is empty");
+
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar").contains(&"hello1.txt".to_string()),
+            "the /bar/hello1.txt file exists"
+        );
+
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar").contains(&"hello2.txt".to_string()),
+            "the /bar/hello2.txt file exists"
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_rename/foo")),
+            Ok(()),
+            "create ./foo again",
+        );
+
+        assert_eq!(
+            fs.rename(
+                Path::new("/test_rename/bar/hello2.txt"),
+                Path::new("/test_rename/foo/world2.txt")
+            )
+            .await,
+            Ok(()),
+            "renaming (and moving) a file",
+        );
+
+        assert_eq!(
+            fs.rename(
+                Path::new("/test_rename/foo"),
+                Path::new("/test_rename/bar/baz")
+            )
+            .await,
+            Ok(()),
+            "renaming a directory",
+        );
+
+        assert_eq!(
+            fs.rename(
+                Path::new("/test_rename/bar/hello1.txt"),
+                Path::new("/test_rename/bar/world1.txt")
+            )
+            .await,
+            Ok(()),
+            "renaming a file (in the same directory)",
+        );
+
+        assert!(
+            read_dir_names(&fs, "/test_rename").contains(&"bar".to_string()),
+            "./bar exists"
+        );
+
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar").contains(&"baz".to_string()),
+            "/bar/baz exists"
+        );
+        assert!(
+            !read_dir_names(&fs, "/test_rename").contains(&"foo".to_string()),
+            "foo does not exist anymore"
+        );
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar/baz").contains(&"world2.txt".to_string()),
+            "/bar/baz/world2.txt exists"
+        );
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar").contains(&"world1.txt".to_string()),
+            "/bar/world1.txt (ex hello1.txt) exists"
+        );
+        assert!(
+            !read_dir_names(&fs, "/test_rename/bar").contains(&"hello1.txt".to_string()),
+            "hello1.txt was moved"
+        );
+        assert!(
+            !read_dir_names(&fs, "/test_rename/bar").contains(&"hello2.txt".to_string()),
+            "hello2.txt was moved"
+        );
+        assert!(
+            read_dir_names(&fs, "/test_rename/bar/baz").contains(&"world2.txt".to_string()),
+            "world2.txt was moved to the correct place"
+        );
+
+        let _ = fs_extra::remove_items(&["/test_rename"]);
+    }
+
+    #[tokio::test]
+    async fn test_metadata() {
+        use std::thread::sleep;
+        use std::time::Duration;
+
+        let fs = gen_filesystem();
+
+        let _ = fs_extra::remove_items(&["/test_metadata"]);
+
+        assert_eq!(fs.create_dir(Path::new("/test_metadata")), Ok(()));
+
+        let root_metadata = fs.metadata(Path::new("/test_metadata")).unwrap();
+
+        assert!(root_metadata.ft.dir);
+        assert!(root_metadata.accessed == root_metadata.created);
+        assert!(root_metadata.modified == root_metadata.created);
+        assert!(root_metadata.modified > 0);
+
+        assert_eq!(fs.create_dir(Path::new("/test_metadata/foo")), Ok(()));
+
+        let foo_metadata = fs.metadata(Path::new("/test_metadata/foo"));
+        assert!(foo_metadata.is_ok());
+        let foo_metadata = foo_metadata.unwrap();
+
+        assert!(foo_metadata.ft.dir);
+        assert!(foo_metadata.accessed == foo_metadata.created);
+        assert!(foo_metadata.modified == foo_metadata.created);
+        assert!(foo_metadata.modified > 0);
+
+        sleep(Duration::from_secs(3));
+
+        assert_eq!(
+            fs.rename(
+                Path::new("/test_metadata/foo"),
+                Path::new("/test_metadata/bar")
+            )
+            .await,
+            Ok(())
+        );
+
+        let bar_metadata = fs.metadata(Path::new("/test_metadata/bar")).unwrap();
+        assert!(bar_metadata.ft.dir);
+        assert!(bar_metadata.accessed == foo_metadata.accessed);
+        assert!(bar_metadata.created == foo_metadata.created);
+        assert!(bar_metadata.modified > foo_metadata.modified);
+
+        let root_metadata = fs.metadata(Path::new("/test_metadata/bar")).unwrap();
+        assert!(
+            root_metadata.modified > foo_metadata.modified,
+            "the parent modified time was updated"
+        );
+
+        let _ = fs_extra::remove_items(&["/test_metadata"]);
+    }
+
+    #[tokio::test]
+    async fn test_remove_file() {
+        let fs = gen_filesystem();
+
+        let _ = fs_extra::remove_items(&["./test_remove_file"]);
+
+        assert!(fs.create_dir(Path::new("/test_remove_file")).is_ok());
+
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("/test_remove_file/foo.txt")),
+                Ok(_)
+            ),
+            "creating a new file",
+        );
+
+        assert!(read_dir_names(&fs, "/test_remove_file").contains(&"foo.txt".to_string()));
+
+        assert_eq!(
+            fs.remove_file(Path::new("/test_remove_file/foo.txt")),
+            Ok(()),
+            "removing a file that exists",
+        );
+
+        assert!(!read_dir_names(&fs, "/test_remove_file").contains(&"foo.txt".to_string()));
+
+        assert_eq!(
+            fs.remove_file(Path::new("/test_remove_file/foo.txt")),
+            Err(FsError::EntryNotFound),
+            "removing a file that doesn't exists",
+        );
+
+        let _ = fs_extra::remove_items(&["./test_remove_file"]);
+    }
+
+    #[tokio::test]
+    async fn test_readdir() {
+        let fs = gen_filesystem();
+
+        assert_eq!(
+            fs.create_dir(Path::new("/test_readdir/foo")),
+            Ok(()),
+            "creating `foo`"
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("/test_readdir/foo/sub")),
+            Ok(()),
+            "creating `sub`"
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("/test_readdir/bar")),
+            Ok(()),
+            "creating `bar`"
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("/test_readdir/baz")),
+            Ok(()),
+            "creating `bar`"
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("/test_readdir/a.txt")),
+                Ok(_)
+            ),
+            "creating `a.txt`",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("/test_readdir/b.txt")),
+                Ok(_)
+            ),
+            "creating `b.txt`",
+        );
+
+        println!("fs: {:?}", fs);
+
+        let readdir = fs.read_dir(Path::new("/test_readdir"));
+
+        assert!(readdir.is_ok(), "reading the directory `/test_readdir/`");
+
+        let mut readdir = readdir.unwrap();
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("foo"), "checking entry #1");
+        println!("entry 1: {:#?}", next);
+        assert!(next.file_type().unwrap().is_dir(), "checking entry #1");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("bar"), "checking entry #2");
+        assert!(next.file_type().unwrap().is_dir(), "checking entry #2");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("baz"), "checking entry #3");
+        assert!(next.file_type().unwrap().is_dir(), "checking entry #3");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("a.txt"), "checking entry #2");
+        assert!(next.file_type().unwrap().is_file(), "checking entry #4");
+
+        let next = readdir.next().unwrap().unwrap();
+        assert!(next.path.ends_with("b.txt"), "checking entry #2");
+        assert!(next.file_type().unwrap().is_file(), "checking entry #5");
+
+        if let Some(s) = readdir.next() {
+            panic!("next: {:?}", s);
+        }
+
+        let _ = fs_extra::remove_items(&["./test_readdir"]);
+    }
+
+    /*
+    #[tokio::test]
+    async fn test_canonicalize() {
+        let fs = gen_filesystem();
+
+        let root_dir = env!("CARGO_MANIFEST_DIR");
+
+        let _ = fs_extra::remove_items(&["./test_canonicalize"]);
+
+        assert_eq!(
+            fs.create_dir(Path::new("./test_canonicalize")),
+            Ok(()),
+            "creating `test_canonicalize`"
+        );
+
+        assert_eq!(
+            fs.create_dir(Path::new("./test_canonicalize/foo")),
+            Ok(()),
+            "creating `foo`"
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("./test_canonicalize/foo/bar")),
+            Ok(()),
+            "creating `bar`"
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("./test_canonicalize/foo/bar/baz")),
+            Ok(()),
+            "creating `baz`",
+        );
+        assert_eq!(
+            fs.create_dir(Path::new("./test_canonicalize/foo/bar/baz/qux")),
+            Ok(()),
+            "creating `qux`",
+        );
+        assert!(
+            matches!(
+                fs.new_open_options()
+                    .write(true)
+                    .create_new(true)
+                    .open(Path::new("./test_canonicalize/foo/bar/baz/qux/hello.txt")),
+                Ok(_)
+            ),
+            "creating `hello.txt`",
+        );
+
+        assert_eq!(
+            fs.canonicalize(Path::new("./test_canonicalize")),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize")).to_path_buf()),
+            "canonicalizing `/`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("foo")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `foo`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("./test_canonicalize/././././foo/")),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize/foo")).to_path_buf()),
+            "canonicalizing `/././././foo/`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("./test_canonicalize/foo/bar//")),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize/foo/bar")).to_path_buf()),
+            "canonicalizing `/foo/bar//`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("./test_canonicalize/foo/bar/../bar")),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize/foo/bar")).to_path_buf()),
+            "canonicalizing `/foo/bar/../bar`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("./test_canonicalize/foo/bar/../..")),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize")).to_path_buf()),
+            "canonicalizing `/foo/bar/../..`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("/foo/bar/../../..")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `/foo/bar/../../..`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new("C:/foo/")),
+            Err(FsError::InvalidInput),
+            "canonicalizing `C:/foo/`",
+        );
+        assert_eq!(
+            fs.canonicalize(Path::new(
+                "./test_canonicalize/foo/./../foo/bar/../../foo/bar/./baz/./../baz/qux/../../baz/./qux/hello.txt"
+            )),
+            Ok(Path::new(&format!("{root_dir}/test_canonicalize/foo/bar/baz/qux/hello.txt")).to_path_buf()),
+            "canonicalizing a crazily stupid path name",
+        );
+
+        let _ = fs_extra::remove_items(&["./test_canonicalize"]);
+    }
+    */
+
+    #[tokio::test]
+    #[ignore = "Not yet supported. See https://github.com/wasmerio/wasmer/issues/3678"]
+    async fn mount_to_overlapping_directories() {
+        let top_level = mem_fs::FileSystem::default();
+        ops::touch(&top_level, "/file.txt").unwrap();
+        let nested = mem_fs::FileSystem::default();
+        ops::touch(&nested, "/another-file.txt").unwrap();
+
+        let mut fs = UnionFileSystem::default();
+        fs.mount(
+            "top-level",
+            "/",
+            false,
+            Box::new(top_level),
+            Some("/top-level"),
+        );
+        fs.mount(
+            "nested",
+            "/",
+            false,
+            Box::new(nested),
+            Some("/top-level/nested"),
+        );
+
+        assert!(ops::is_dir(&fs, "/top-level"));
+        assert!(ops::is_file(&fs, "/top-level/file.txt"));
+        assert!(ops::is_dir(&fs, "/top-level/nested"));
+        assert!(ops::is_file(&fs, "/top-level/nested/another-file.txt"));
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_fs.rs
new file mode 100644
index 0000000..ba52156
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_fs.rs
@@ -0,0 +1,484 @@
+use std::{
+    convert::{TryFrom, TryInto},
+    io::{self, Error as IoError, ErrorKind as IoErrorKind, SeekFrom},
+    ops::Deref,
+    path::{Path, PathBuf},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use anyhow::anyhow;
+use futures::future::BoxFuture;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+use webc::v1::{FsEntry, FsEntryType, OwnedFsEntryFile, WebC};
+
+use crate::{
+    mem_fs::FileSystem as MemFileSystem, FileOpener, FileSystem, FsError, Metadata, OpenOptions,
+    OpenOptionsConfig, ReadDir, VirtualFile,
+};
+
+/// Custom file system wrapper to map requested file paths
+#[derive(Debug)]
+pub struct WebcFileSystem<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+{
+    pub webc: Arc<T>,
+    pub memory: Arc<MemFileSystem>,
+    top_level_dirs: Vec<String>,
+    volumes: Vec<webc::v1::Volume<'static>>,
+}
+
+impl<T> WebcFileSystem<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    pub fn init(webc: Arc<T>, package: &str) -> Self {
+        let mut fs = Self {
+            webc: webc.clone(),
+            memory: Arc::new(MemFileSystem::default()),
+            top_level_dirs: Vec::new(),
+            volumes: Vec::new(),
+        };
+
+        for volume in webc.get_volumes_for_package(package) {
+            if let Some(vol_ref) = webc.volumes.get(&volume) {
+                fs.volumes.push(vol_ref.clone());
+            }
+            for directory in webc.list_directories(&volume) {
+                fs.top_level_dirs.push(directory.clone());
+                let _ = fs.create_dir(Path::new(&directory));
+            }
+        }
+        fs
+    }
+
+    pub fn init_all(webc: Arc<T>) -> Self {
+        let mut fs = Self {
+            webc: webc.clone(),
+            memory: Arc::new(MemFileSystem::default()),
+            top_level_dirs: Vec::new(),
+            volumes: webc.volumes.clone().into_values().collect(),
+        };
+        for (header, _) in webc.volumes.iter() {
+            for directory in webc.list_directories(header) {
+                fs.top_level_dirs.push(directory.clone());
+                let _ = fs.create_dir(Path::new(&directory));
+            }
+        }
+        fs
+    }
+
+    pub fn top_level_dirs(&self) -> &Vec<String> {
+        &self.top_level_dirs
+    }
+}
+
+/// Custom file opener, returns a WebCFile
+impl<T> FileOpener for WebcFileSystem<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    fn open(
+        &self,
+        path: &Path,
+        _conf: &OpenOptionsConfig,
+    ) -> Result<Box<dyn VirtualFile + Send + Sync>, FsError> {
+        match get_volume_name_opt(path) {
+            Some(volume) => {
+                let file = self
+                    .webc
+                    .volumes
+                    .get(&volume)
+                    .ok_or(FsError::EntryNotFound)?
+                    .get_file_entry(path.to_string_lossy().as_ref())
+                    .map_err(|_e| FsError::EntryNotFound)?;
+
+                Ok(Box::new(WebCFile {
+                    volume,
+                    webc: self.webc.clone(),
+                    path: path.to_path_buf(),
+                    entry: file,
+                    cursor: 0,
+                }))
+            }
+            None => {
+                for (volume, _) in self.webc.volumes.iter() {
+                    let v = match self.webc.volumes.get(volume) {
+                        Some(s) => s,
+                        None => continue, // error
+                    };
+
+                    let entry = match v.get_file_entry(path.to_string_lossy().as_ref()) {
+                        Ok(s) => s,
+                        Err(_) => continue, // error
+                    };
+
+                    return Ok(Box::new(WebCFile {
+                        volume: volume.clone(),
+                        webc: self.webc.clone(),
+                        path: path.to_path_buf(),
+                        entry,
+                        cursor: 0,
+                    }));
+                }
+                self.memory.new_open_options().open(path)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct WebCFile<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+{
+    pub webc: Arc<T>,
+    pub volume: String,
+    #[allow(dead_code)]
+    pub path: PathBuf,
+    pub entry: OwnedFsEntryFile,
+    pub cursor: u64,
+}
+
+impl<T> VirtualFile for WebCFile<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        self.entry.get_len()
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let remaining = self.entry.get_len() - self.cursor;
+        Poll::Ready(Ok(remaining as usize))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl<T> AsyncRead for WebCFile<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let bytes = self
+            .webc
+            .volumes
+            .get(&self.volume)
+            .ok_or_else(|| {
+                IoError::new(
+                    IoErrorKind::NotFound,
+                    anyhow!("Unknown volume {:?}", self.volume),
+                )
+            })?
+            .get_file_bytes(&self.entry)
+            .map_err(|e| IoError::new(IoErrorKind::NotFound, e))?;
+
+        let start: usize = self.cursor.try_into().unwrap();
+        let remaining = &bytes[start..];
+        let bytes_read = remaining.len().min(buf.remaining());
+        let bytes = &remaining[..bytes_read];
+
+        buf.put_slice(bytes);
+        self.cursor += u64::try_from(bytes_read).unwrap();
+
+        Poll::Ready(Ok(()))
+    }
+}
+
+// WebC file is not writable, the FileOpener will return a MemoryFile for writing instead
+// This code should never be executed (since writes are redirected to memory instead).
+impl<T> AsyncWrite for WebCFile<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+{
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl<T> AsyncSeek for WebCFile<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    fn start_seek(mut self: Pin<&mut Self>, pos: io::SeekFrom) -> io::Result<()> {
+        let self_size = self.size();
+        match pos {
+            SeekFrom::Start(s) => {
+                self.cursor = s.min(self_size);
+            }
+            SeekFrom::End(e) => {
+                let self_size_i64 = self_size.try_into().unwrap_or(i64::MAX);
+                self.cursor = ((self_size_i64).saturating_add(e))
+                    .min(self_size_i64)
+                    .try_into()
+                    .unwrap_or(i64::MAX as u64);
+            }
+            SeekFrom::Current(c) => {
+                self.cursor = (self
+                    .cursor
+                    .saturating_add(c.try_into().unwrap_or(i64::MAX as u64)))
+                .min(self_size);
+            }
+        }
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(self.cursor))
+    }
+}
+
+fn get_volume_name_opt<P: AsRef<Path>>(path: P) -> Option<String> {
+    use std::path::Component::Normal;
+    if let Some(Normal(n)) = path.as_ref().components().next() {
+        if let Some(s) = n.to_str() {
+            if s.ends_with(':') {
+                return Some(s.replace(':', ""));
+            }
+        }
+    }
+    None
+}
+
+#[allow(dead_code)]
+fn get_volume_name<P: AsRef<Path>>(path: P) -> String {
+    get_volume_name_opt(path).unwrap_or_else(|| "atom".to_string())
+}
+
+fn transform_into_read_dir(path: &Path, fs_entries: &[FsEntry<'_>]) -> crate::ReadDir {
+    let entries = fs_entries
+        .iter()
+        .map(|e| crate::DirEntry {
+            path: path.join(&*e.text),
+            metadata: Ok(crate::Metadata {
+                ft: translate_file_type(e.fs_type),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: e.get_len(),
+            }),
+        })
+        .collect();
+
+    crate::ReadDir::new(entries)
+}
+
+impl<T> FileSystem for WebcFileSystem<T>
+where
+    T: std::fmt::Debug + Send + Sync + 'static,
+    T: Deref<Target = WebC<'static>>,
+{
+    fn read_dir(&self, path: &Path) -> Result<ReadDir, FsError> {
+        let path = normalizes_path(path);
+        let read_dir_result = self
+            .volumes
+            .iter()
+            .filter_map(|v| v.read_dir(&path).ok())
+            .next()
+            .map(|o| transform_into_read_dir(Path::new(&path), o.as_ref()))
+            .ok_or(FsError::EntryNotFound);
+
+        match read_dir_result {
+            Ok(o) => Ok(o),
+            Err(_) => self.memory.read_dir(Path::new(&path)),
+        }
+    }
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.create_dir(Path::new(&path));
+        result
+    }
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_dir(Path::new(&path));
+        if self.volumes.iter().any(|v| v.get_file_entry(&path).is_ok()) {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Box::pin(async {
+            let from = normalizes_path(from);
+            let to = normalizes_path(to);
+            let result = self.memory.rename(Path::new(&from), Path::new(&to)).await;
+            if self.volumes.iter().any(|v| v.get_file_entry(&from).is_ok()) {
+                Ok(())
+            } else {
+                result
+            }
+        })
+    }
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .iter()
+            .filter_map(|v| v.get_file_entry(&path).ok())
+            .next()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if self
+            .volumes
+            .iter()
+            .filter_map(|v| v.read_dir(&path).ok())
+            .next()
+            .is_some()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.metadata(Path::new(&path))
+        }
+    }
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        let path = normalizes_path(path);
+        let result = self.memory.remove_file(Path::new(&path));
+        if self
+            .volumes
+            .iter()
+            .filter_map(|v| v.get_file_entry(&path).ok())
+            .next()
+            .is_some()
+        {
+            Ok(())
+        } else {
+            result
+        }
+    }
+    fn new_open_options(&self) -> OpenOptions {
+        OpenOptions::new(self)
+    }
+    fn symlink_metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalizes_path(path);
+        if let Some(fs_entry) = self
+            .volumes
+            .iter()
+            .filter_map(|v| v.get_file_entry(&path).ok())
+            .next()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::File),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: fs_entry.get_len(),
+            })
+        } else if self
+            .volumes
+            .iter()
+            .filter_map(|v| v.read_dir(&path).ok())
+            .next()
+            .is_some()
+        {
+            Ok(Metadata {
+                ft: translate_file_type(FsEntryType::Dir),
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            })
+        } else {
+            self.memory.symlink_metadata(Path::new(&path))
+        }
+    }
+}
+
+fn normalizes_path(path: &Path) -> String {
+    let path = format!("{}", path.display());
+    if !path.starts_with('/') {
+        format!("/{path}")
+    } else {
+        path
+    }
+}
+
+fn translate_file_type(f: FsEntryType) -> crate::FileType {
+    crate::FileType {
+        dir: f == FsEntryType::Dir,
+        file: f == FsEntryType::File,
+        symlink: false,
+        char_device: false,
+        block_device: false,
+        socket: false,
+        fifo: false,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::Bytes;
+    use tokio::io::AsyncReadExt;
+    use webc::v1::{ParseOptions, WebCOwned};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn read_a_file_from_the_webc_fs() {
+        let webc: &[u8] = include_bytes!("../../c-api/examples/assets/python-0.1.0.wasmer");
+        let options = ParseOptions::default();
+        let webc = WebCOwned::parse(Bytes::from_static(webc), &options).unwrap();
+
+        let fs = WebcFileSystem::init_all(Arc::new(webc));
+
+        let mut f = fs
+            .new_open_options()
+            .read(true)
+            .open(Path::new("/lib/python3.6/collections/abc.py"))
+            .unwrap();
+
+        let mut abc_py = String::new();
+        f.read_to_string(&mut abc_py).await.unwrap();
+        assert_eq!(
+            abc_py,
+            "from _collections_abc import *\nfrom _collections_abc import __all__\n"
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_volume_fs.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_volume_fs.rs
new file mode 100644
index 0000000..e185ec0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/webc_volume_fs.rs
@@ -0,0 +1,649 @@
+use std::{
+    convert::{TryFrom, TryInto},
+    io::Cursor,
+    path::{Path, PathBuf},
+    pin::Pin,
+    result::Result,
+    task::Poll,
+};
+
+use futures::future::BoxFuture;
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+use webc::{
+    compat::{Container, SharedBytes, Volume},
+    PathSegmentError, PathSegments, ToPathSegments,
+};
+
+use crate::{
+    DirEntry, EmptyFileSystem, FileOpener, FileSystem, FileType, FsError, Metadata,
+    OpenOptionsConfig, OverlayFileSystem, ReadDir, VirtualFile,
+};
+
+#[derive(Debug, Clone)]
+pub struct WebcVolumeFileSystem {
+    volume: Volume,
+}
+
+impl WebcVolumeFileSystem {
+    pub fn new(volume: Volume) -> Self {
+        WebcVolumeFileSystem { volume }
+    }
+
+    pub fn volume(&self) -> &Volume {
+        &self.volume
+    }
+
+    /// Get a filesystem where all [`Volume`]s in a [`Container`] are mounted to
+    /// the root directory.
+    pub fn mount_all(
+        container: &Container,
+    ) -> OverlayFileSystem<EmptyFileSystem, Vec<WebcVolumeFileSystem>> {
+        let mut filesystems = Vec::new();
+
+        for volume in container.volumes().into_values() {
+            filesystems.push(WebcVolumeFileSystem::new(volume));
+        }
+
+        OverlayFileSystem::new(EmptyFileSystem::default(), filesystems)
+    }
+}
+
+impl FileSystem for WebcVolumeFileSystem {
+    fn read_dir(&self, path: &Path) -> Result<crate::ReadDir, FsError> {
+        let meta = self.metadata(path)?;
+
+        if !meta.is_dir() {
+            return Err(FsError::BaseNotDirectory);
+        }
+
+        let path = normalize(path).map_err(|_| FsError::InvalidInput)?;
+
+        let mut entries = Vec::new();
+
+        for (name, meta) in self
+            .volume()
+            .read_dir(&path)
+            .ok_or(FsError::EntryNotFound)?
+        {
+            let path = PathBuf::from(path.join(name).to_string());
+            entries.push(DirEntry {
+                path,
+                metadata: Ok(compat_meta(meta)),
+            });
+        }
+
+        Ok(ReadDir::new(entries))
+    }
+
+    fn create_dir(&self, path: &Path) -> Result<(), FsError> {
+        // the directory shouldn't exist yet
+        if self.metadata(path).is_ok() {
+            return Err(FsError::AlreadyExists);
+        }
+
+        // it's parent should exist
+        let parent = path.parent().unwrap_or_else(|| Path::new("/"));
+
+        match self.metadata(parent) {
+            Ok(parent_meta) if parent_meta.is_dir() => {
+                // The operation would normally be doable... but we're a readonly
+                // filesystem
+                Err(FsError::PermissionDenied)
+            }
+            Ok(_) | Err(FsError::EntryNotFound) => Err(FsError::BaseNotDirectory),
+            Err(other) => Err(other),
+        }
+    }
+
+    fn remove_dir(&self, path: &Path) -> Result<(), FsError> {
+        // The original directory should exist
+        let meta = self.metadata(path)?;
+
+        // and it should be a directory
+        if !meta.is_dir() {
+            return Err(FsError::BaseNotDirectory);
+        }
+
+        // but we are a readonly filesystem, so you can't modify anything
+        Err(FsError::PermissionDenied)
+    }
+
+    fn rename<'a>(&'a self, from: &'a Path, to: &'a Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Box::pin(async {
+            // The original file should exist
+            let _ = self.metadata(from)?;
+
+            // we also want to make sure the destination's folder exists, too
+            let dest_parent = to.parent().unwrap_or_else(|| Path::new("/"));
+            let parent_meta = self.metadata(dest_parent)?;
+            if !parent_meta.is_dir() {
+                return Err(FsError::BaseNotDirectory);
+            }
+
+            // but we are a readonly filesystem, so you can't modify anything
+            Err(FsError::PermissionDenied)
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> Result<Metadata, FsError> {
+        let path = normalize(path).map_err(|_| FsError::InvalidInput)?;
+
+        self.volume()
+            .metadata(path)
+            .map(compat_meta)
+            .ok_or(FsError::EntryNotFound)
+    }
+
+    fn remove_file(&self, path: &Path) -> Result<(), FsError> {
+        let meta = self.metadata(path)?;
+
+        if !meta.is_file() {
+            return Err(FsError::NotAFile);
+        }
+
+        Err(FsError::PermissionDenied)
+    }
+
+    fn new_open_options(&self) -> crate::OpenOptions {
+        crate::OpenOptions::new(self)
+    }
+}
+
+impl FileOpener for WebcVolumeFileSystem {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &OpenOptionsConfig,
+    ) -> crate::Result<Box<dyn crate::VirtualFile + Send + Sync + 'static>> {
+        if let Some(parent) = path.parent() {
+            let parent_meta = self.metadata(parent)?;
+            if !parent_meta.is_dir() {
+                return Err(FsError::BaseNotDirectory);
+            }
+        }
+
+        match self.volume().metadata(path) {
+            Some(m) if m.is_file() => {}
+            Some(_) => return Err(FsError::NotAFile),
+            None if conf.create() || conf.create_new() => {
+                // The file would normally be created, but we are a readonly fs.
+                return Err(FsError::PermissionDenied);
+            }
+            None => return Err(FsError::EntryNotFound),
+        }
+
+        match self.volume().read_file(path) {
+            Some(bytes) => Ok(Box::new(File(Cursor::new(bytes)))),
+            None => {
+                // The metadata() call should guarantee this, so something
+                // probably went wrong internally
+                Err(FsError::UnknownError)
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+struct File(Cursor<SharedBytes>);
+
+impl VirtualFile for File {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+
+    fn last_modified(&self) -> u64 {
+        0
+    }
+
+    fn created_time(&self) -> u64 {
+        0
+    }
+
+    fn size(&self) -> u64 {
+        self.0.get_ref().len().try_into().unwrap()
+    }
+
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Err(FsError::PermissionDenied)
+    }
+
+    fn unlink(&mut self) -> crate::Result<()> {
+        Err(FsError::PermissionDenied)
+    }
+
+    fn poll_read_ready(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<std::io::Result<usize>> {
+        let bytes_remaining = self.0.get_ref().len() - usize::try_from(self.0.position()).unwrap();
+        Poll::Ready(Ok(bytes_remaining))
+    }
+
+    fn poll_write_ready(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<std::io::Result<usize>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+}
+
+impl AsyncRead for File {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        AsyncRead::poll_read(Pin::new(&mut self.0), cx, buf)
+    }
+}
+
+impl AsyncSeek for File {
+    fn start_seek(mut self: Pin<&mut Self>, position: std::io::SeekFrom) -> std::io::Result<()> {
+        AsyncSeek::start_seek(Pin::new(&mut self.0), position)
+    }
+
+    fn poll_complete(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<std::io::Result<u64>> {
+        AsyncSeek::poll_complete(Pin::new(&mut self.0), cx)
+    }
+}
+
+impl AsyncWrite for File {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<Result<usize, std::io::Error>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+
+    fn poll_flush(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+
+    fn poll_shutdown(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), std::io::Error>> {
+        Poll::Ready(Err(std::io::ErrorKind::PermissionDenied.into()))
+    }
+}
+
+fn compat_meta(meta: webc::compat::Metadata) -> Metadata {
+    match meta {
+        webc::compat::Metadata::Dir => Metadata {
+            ft: FileType {
+                dir: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        },
+        webc::compat::Metadata::File { length } => Metadata {
+            ft: FileType {
+                file: true,
+                ..Default::default()
+            },
+            len: length.try_into().unwrap(),
+            ..Default::default()
+        },
+    }
+}
+
+/// Normalize a [`Path`] into a [`PathSegments`], dealing with things like `..`
+/// and skipping `.`'s.
+fn normalize(path: &Path) -> Result<PathSegments, PathSegmentError> {
+    // normalization is handled by the ToPathSegments impl for Path
+    let result = path.to_path_segments();
+
+    if let Err(e) = &result {
+        tracing::debug!(
+            error = e as &dyn std::error::Error,
+            path=%path.display(),
+            "Unable to normalize a path",
+        );
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::DirEntry;
+    use std::convert::TryFrom;
+    use tokio::io::AsyncReadExt;
+
+    const PYTHON_WEBC: &[u8] = include_bytes!("../../c-api/examples/assets/python-0.1.0.wasmer");
+
+    #[test]
+    fn normalize_paths() {
+        let inputs: Vec<(&str, &[&str])> = vec![
+            ("/", &[]),
+            ("/path/to/", &["path", "to"]),
+            ("/path/to/file.txt", &["path", "to", "file.txt"]),
+            ("/folder/..", &[]),
+            ("/.hidden", &[".hidden"]),
+            ("/folder/../../../../../../../file.txt", &["file.txt"]),
+            #[cfg(windows)]
+            (r"C:\path\to\file.txt", &["path", "to", "file.txt"]),
+        ];
+
+        for (path, expected) in inputs {
+            let normalized = normalize(path.as_ref()).unwrap();
+            assert_eq!(normalized, expected.to_path_segments().unwrap());
+        }
+    }
+
+    #[test]
+    #[cfg_attr(not(windows), ignore = "Only works with PathBuf's Windows logic")]
+    fn normalize_windows_paths() {
+        let inputs: Vec<(&str, &[&str])> = vec![
+            (r"C:\path\to\file.txt", &["path", "to", "file.txt"]),
+            (r"C:/path/to/file.txt", &["path", "to", "file.txt"]),
+            (r"\\system07\C$\", &[]),
+            (r"c:\temp\test-file.txt", &["temp", "test-file.txt"]),
+            (
+                r"\\127.0.0.1\c$\temp\test-file.txt",
+                &["temp", "test-file.txt"],
+            ),
+            (r"\\.\c:\temp\test-file.txt", &["temp", "test-file.txt"]),
+            (r"\\?\c:\temp\test-file.txt", &["temp", "test-file.txt"]),
+            (
+                r"\\127.0.0.1\c$\temp\test-file.txt",
+                &["temp", "test-file.txt"],
+            ),
+            (
+                r"\\.\Volume{b75e2c83-0000-0000-0000-602f00000000}\temp\test-file.txt",
+                &["temp", "test-file.txt"],
+            ),
+        ];
+
+        for (path, expected) in inputs {
+            let normalized = normalize(path.as_ref()).unwrap();
+            assert_eq!(normalized, expected.to_path_segments().unwrap(), "{}", path);
+        }
+    }
+
+    #[test]
+    fn invalid_paths() {
+        let paths = [".", "..", "./file.txt", ""];
+
+        for path in paths {
+            assert!(normalize(path.as_ref()).is_err(), "{}", path);
+        }
+    }
+
+    #[test]
+    fn mount_all_volumes_in_python() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+
+        let fs = WebcVolumeFileSystem::mount_all(&container);
+
+        // We should now have access to the python directory
+        let lib_meta = fs.metadata("/lib/python3.6/".as_ref()).unwrap();
+        assert!(lib_meta.is_dir());
+    }
+
+    #[test]
+    fn read_dir() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        let entries: Vec<_> = fs
+            .read_dir("/lib".as_ref())
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect();
+        let expected = vec![
+            DirEntry {
+                path: "/lib/.DS_Store".into(),
+                metadata: Ok(Metadata {
+                    ft: FileType {
+                        file: true,
+                        ..Default::default()
+                    },
+                    accessed: 0,
+                    created: 0,
+                    modified: 0,
+                    len: 6148,
+                }),
+            },
+            DirEntry {
+                path: "/lib/Parser".into(),
+                metadata: Ok(Metadata {
+                    ft: FileType {
+                        dir: true,
+                        ..Default::default()
+                    },
+                    accessed: 0,
+                    created: 0,
+                    modified: 0,
+                    len: 0,
+                }),
+            },
+            DirEntry {
+                path: "/lib/python.wasm".into(),
+                metadata: Ok(crate::Metadata {
+                    ft: crate::FileType {
+                        file: true,
+                        ..Default::default()
+                    },
+                    accessed: 0,
+                    created: 0,
+                    modified: 0,
+                    len: 4694941,
+                }),
+            },
+            DirEntry {
+                path: "/lib/python3.6".into(),
+                metadata: Ok(crate::Metadata {
+                    ft: crate::FileType {
+                        dir: true,
+                        ..Default::default()
+                    },
+                    accessed: 0,
+                    created: 0,
+                    modified: 0,
+                    len: 0,
+                }),
+            },
+        ];
+        assert_eq!(entries, expected);
+    }
+
+    #[test]
+    fn metadata() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        let python_wasm = crate::Metadata {
+            ft: crate::FileType {
+                file: true,
+                ..Default::default()
+            },
+            accessed: 0,
+            created: 0,
+            modified: 0,
+            len: 4694941,
+        };
+        assert_eq!(
+            fs.metadata("/lib/python.wasm".as_ref()).unwrap(),
+            python_wasm,
+        );
+        assert_eq!(
+            fs.metadata("/../../../../lib/python.wasm".as_ref())
+                .unwrap(),
+            python_wasm,
+        );
+        assert_eq!(
+            fs.metadata("/lib/python3.6/../python3.6/../python.wasm".as_ref())
+                .unwrap(),
+            python_wasm,
+        );
+        assert_eq!(
+            fs.metadata("/lib/python3.6".as_ref()).unwrap(),
+            crate::Metadata {
+                ft: crate::FileType {
+                    dir: true,
+                    ..Default::default()
+                },
+                accessed: 0,
+                created: 0,
+                modified: 0,
+                len: 0,
+            },
+        );
+        assert_eq!(
+            fs.metadata("/this/does/not/exist".as_ref()).unwrap_err(),
+            FsError::EntryNotFound
+        );
+    }
+
+    #[tokio::test]
+    async fn file_opener() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        assert_eq!(
+            fs.new_open_options()
+                .create(true)
+                .write(true)
+                .open("/file.txt")
+                .unwrap_err(),
+            FsError::PermissionDenied,
+        );
+        assert_eq!(
+            fs.new_open_options().read(true).open("/lib").unwrap_err(),
+            FsError::NotAFile,
+        );
+        assert_eq!(
+            fs.new_open_options()
+                .read(true)
+                .open("/this/does/not/exist.txt")
+                .unwrap_err(),
+            FsError::EntryNotFound,
+        );
+
+        // We should be able to actually read the file
+        let mut f = fs
+            .new_open_options()
+            .read(true)
+            .open("/lib/python.wasm")
+            .unwrap();
+        let mut buffer = Vec::new();
+        f.read_to_end(&mut buffer).await.unwrap();
+        assert!(buffer.starts_with(b"\0asm"));
+        assert_eq!(
+            fs.metadata("/lib/python.wasm".as_ref()).unwrap().len(),
+            u64::try_from(buffer.len()).unwrap(),
+        );
+    }
+
+    #[test]
+    fn remove_dir_is_not_allowed() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        assert_eq!(
+            fs.remove_dir("/lib".as_ref()).unwrap_err(),
+            FsError::PermissionDenied,
+        );
+        assert_eq!(
+            fs.remove_dir("/this/does/not/exist".as_ref()).unwrap_err(),
+            FsError::EntryNotFound,
+        );
+        assert_eq!(
+            fs.remove_dir("/lib/python.wasm".as_ref()).unwrap_err(),
+            FsError::BaseNotDirectory,
+        );
+    }
+
+    #[test]
+    fn remove_file_is_not_allowed() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        assert_eq!(
+            fs.remove_file("/lib".as_ref()).unwrap_err(),
+            FsError::NotAFile,
+        );
+        assert_eq!(
+            fs.remove_file("/this/does/not/exist".as_ref()).unwrap_err(),
+            FsError::EntryNotFound,
+        );
+        assert_eq!(
+            fs.remove_file("/lib/python.wasm".as_ref()).unwrap_err(),
+            FsError::PermissionDenied,
+        );
+    }
+
+    #[test]
+    fn create_dir_is_not_allowed() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        assert_eq!(
+            fs.create_dir("/lib".as_ref()).unwrap_err(),
+            FsError::AlreadyExists,
+        );
+        assert_eq!(
+            fs.create_dir("/this/does/not/exist".as_ref()).unwrap_err(),
+            FsError::BaseNotDirectory,
+        );
+        assert_eq!(
+            fs.create_dir("/lib/nested/".as_ref()).unwrap_err(),
+            FsError::PermissionDenied,
+        );
+    }
+
+    #[tokio::test]
+    async fn rename_is_not_allowed() {
+        let container = Container::from_bytes(PYTHON_WEBC).unwrap();
+        let volumes = container.volumes();
+        let volume = volumes["atom"].clone();
+
+        let fs = WebcVolumeFileSystem::new(volume);
+
+        assert_eq!(
+            fs.rename("/lib".as_ref(), "/other".as_ref())
+                .await
+                .unwrap_err(),
+            FsError::PermissionDenied,
+        );
+        assert_eq!(
+            fs.rename("/this/does/not/exist".as_ref(), "/another".as_ref())
+                .await
+                .unwrap_err(),
+            FsError::EntryNotFound,
+        );
+        assert_eq!(
+            fs.rename("/lib/python.wasm".as_ref(), "/lib/another.wasm".as_ref())
+                .await
+                .unwrap_err(),
+            FsError::PermissionDenied,
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/zero_file.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/zero_file.rs
new file mode 100644
index 0000000..297a5fa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-fs/src/zero_file.rs
@@ -0,0 +1,90 @@
+//! Used for /dev/zero - infinitely returns zero
+//! which is useful for commands like `dd if=/dev/zero of=bigfile.img size=1G`
+
+use std::{
+    io::{self, IoSlice, SeekFrom},
+    iter,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+
+use crate::VirtualFile;
+
+#[derive(Debug, Default)]
+pub struct ZeroFile {}
+
+impl AsyncSeek for ZeroFile {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Ok(())
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Ok(0))
+    }
+}
+
+impl AsyncWrite for ZeroFile {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(bufs.len()))
+    }
+    fn is_write_vectored(&self) -> bool {
+        false
+    }
+}
+
+impl AsyncRead for ZeroFile {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        let zeros: Vec<u8> = iter::repeat(0).take(buf.remaining()).collect();
+        buf.put_slice(&zeros[..]);
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl VirtualFile for ZeroFile {
+    fn last_accessed(&self) -> u64 {
+        0
+    }
+    fn last_modified(&self) -> u64 {
+        0
+    }
+    fn created_time(&self) -> u64 {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: u64) -> crate::Result<()> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/Cargo.toml
new file mode 100644
index 0000000..4d25ba0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/Cargo.toml
@@ -0,0 +1,24 @@
+[package]
+name = "virtual-mio"
+version = "0.3.1"
+description = "Wasmer Virtual IO Engine powered by mio"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+thiserror = "1"
+bytes = "1.1"
+async-trait = { version = "^0.1" }
+tracing = "0.1"
+mio = { version = "0.8", features = [ "os-poll" ], optional = true }
+socket2 = { version = "0.4", optional = true }
+derivative = { version = "^2" }
+futures = { version = "0.3" }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+
+[features]
+sys = [ "mio", "socket2" ]
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/arc.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/arc.rs
new file mode 100644
index 0000000..7abc45f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/arc.rs
@@ -0,0 +1,43 @@
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use derivative::Derivative;
+
+use crate::{InterestHandler, InterestType};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct ArcInterestHandlerState {
+    #[derivative(Debug = "ignore")]
+    handler: Box<dyn InterestHandler + Send + Sync>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ArcInterestHandler {
+    state: Arc<Mutex<ArcInterestHandlerState>>,
+}
+
+impl ArcInterestHandler {
+    pub fn new(handler: Box<dyn InterestHandler + Send + Sync>) -> Self {
+        Self {
+            state: Arc::new(Mutex::new(ArcInterestHandlerState { handler })),
+        }
+    }
+}
+
+impl InterestHandler for ArcInterestHandler {
+    fn push_interest(&mut self, interest: InterestType) {
+        let mut state = self.state.lock().unwrap();
+        state.handler.push_interest(interest)
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        let mut state = self.state.lock().unwrap();
+        state.handler.pop_interest(interest)
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        let state = self.state.lock().unwrap();
+        state.handler.has_interest(interest)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/guard.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/guard.rs
new file mode 100644
index 0000000..c74a2f1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/guard.rs
@@ -0,0 +1,95 @@
+use std::{
+    io,
+    sync::{Arc, Weak},
+};
+
+use mio::Token;
+
+use crate::{InterestHandler, InterestType, InterestWakerMap, Selector};
+
+#[derive(Debug)]
+#[must_use = "Leaking token guards will break the IO subsystem"]
+pub struct InterestGuard {
+    selector: Weak<Selector>,
+    pub(crate) token: Token,
+}
+impl Drop for InterestGuard {
+    fn drop(&mut self) {
+        self.drop_internal();
+    }
+}
+impl InterestGuard {
+    pub fn new(
+        selector: &Arc<Selector>,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+        source: &mut dyn mio::event::Source,
+        interest: mio::Interest,
+    ) -> io::Result<InterestGuard> {
+        let token = selector.add(handler, source, interest)?;
+        Ok(Self {
+            selector: Arc::downgrade(selector),
+            token,
+        })
+    }
+
+    pub fn unregister(&mut self, source: &mut dyn mio::event::Source) -> io::Result<()> {
+        if let Some(selector) = self.selector.upgrade() {
+            selector.remove(self.token, Some(source))?;
+        }
+        Ok(())
+    }
+
+    pub fn replace_handler(
+        &mut self,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+    ) -> Result<(), Box<dyn InterestHandler + Send + Sync>> {
+        if let Some(selector) = self.selector.upgrade() {
+            selector.replace(self.token, handler);
+            Ok(())
+        } else {
+            Err(handler)
+        }
+    }
+
+    pub fn interest(&mut self, interest: InterestType) {
+        if let Some(selector) = self.selector.upgrade() {
+            selector.handle(self.token, |h| h.push_interest(interest));
+        }
+    }
+
+    fn drop_internal(&mut self) {
+        if let Some(selector) = self.selector.upgrade() {
+            selector.remove(self.token, None).ok();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum HandlerGuardState {
+    None,
+    ExternalHandler(InterestGuard),
+    WakerMap(InterestGuard, InterestWakerMap),
+}
+
+pub fn state_as_waker_map<'a>(
+    state: &'a mut HandlerGuardState,
+    selector: &'_ Arc<Selector>,
+    source: &'_ mut dyn mio::event::Source,
+) -> io::Result<&'a mut InterestWakerMap> {
+    if !matches!(state, HandlerGuardState::WakerMap(_, _)) {
+        let waker_map = InterestWakerMap::default();
+        *state = HandlerGuardState::WakerMap(
+            InterestGuard::new(
+                selector,
+                Box::new(waker_map.clone()),
+                source,
+                mio::Interest::READABLE | mio::Interest::WRITABLE,
+            )?,
+            waker_map,
+        );
+    }
+    Ok(match state {
+        HandlerGuardState::WakerMap(_, map) => map,
+        _ => unreachable!(),
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/interest.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/interest.rs
new file mode 100644
index 0000000..61763e9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/interest.rs
@@ -0,0 +1,200 @@
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::{Arc, Mutex},
+    task::{Context, RawWaker, RawWakerVTable, Waker},
+};
+
+use derivative::Derivative;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum InterestType {
+    Readable,
+    Writable,
+    Closed,
+    Error,
+}
+
+#[derive(Debug)]
+pub struct WakerInterestHandler {
+    set: HashSet<InterestType>,
+    waker: Waker,
+}
+impl WakerInterestHandler {
+    pub fn new(waker: &Waker) -> Box<Self> {
+        Box::new(WakerInterestHandler {
+            set: Default::default(),
+            waker: waker.clone(),
+        })
+    }
+}
+impl InterestHandler for WakerInterestHandler {
+    fn push_interest(&mut self, interest: InterestType) {
+        self.set.insert(interest);
+        self.waker.wake_by_ref();
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        self.set.remove(&interest)
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        self.set.contains(&interest)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SharedWakerInterestHandler {
+    inner: Arc<Mutex<Box<WakerInterestHandler>>>,
+}
+impl SharedWakerInterestHandler {
+    pub fn new(waker: &Waker) -> Box<Self> {
+        Box::new(Self {
+            inner: Arc::new(Mutex::new(WakerInterestHandler::new(waker))),
+        })
+    }
+}
+impl InterestHandler for SharedWakerInterestHandler {
+    fn push_interest(&mut self, interest: InterestType) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.push_interest(interest);
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        let mut inner = self.inner.lock().unwrap();
+        inner.pop_interest(interest)
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.has_interest(interest)
+    }
+}
+
+pub trait InterestHandler: Send + Sync {
+    fn push_interest(&mut self, interest: InterestType);
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool;
+
+    fn has_interest(&self, interest: InterestType) -> bool;
+}
+
+impl From<&Waker> for Box<dyn InterestHandler + Send + Sync> {
+    fn from(waker: &Waker) -> Self {
+        WakerInterestHandler::new(waker)
+    }
+}
+
+impl From<&Context<'_>> for Box<dyn InterestHandler + Send + Sync> {
+    fn from(cx: &Context) -> Self {
+        cx.waker().into()
+    }
+}
+
+pub fn handler_into_waker(
+    handler: Box<dyn InterestHandler + Send + Sync>,
+    interest: InterestType,
+) -> Arc<InterestHandlerWaker> {
+    Arc::new(InterestHandlerWaker {
+        handler: Arc::new(Mutex::new(handler)),
+        interest,
+    })
+}
+
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct InterestHandlerWaker {
+    #[derivative(Debug = "ignore")]
+    handler: Arc<Mutex<Box<dyn InterestHandler + Send + Sync>>>,
+    interest: InterestType,
+}
+impl InterestHandlerWaker {
+    pub fn wake_now(&self) {
+        let mut handler = self.handler.lock().unwrap();
+        handler.push_interest(self.interest);
+    }
+    pub fn set_interest(self: &Arc<Self>, interest: InterestType) -> Arc<Self> {
+        let mut next = self.as_ref().clone();
+        next.interest = interest;
+        Arc::new(next)
+    }
+    pub fn as_waker(self: &Arc<Self>) -> Waker {
+        let s: *const Self = Arc::into_raw(Arc::clone(self));
+        let raw_waker = RawWaker::new(s as *const (), &VTABLE);
+        unsafe { Waker::from_raw(raw_waker) }
+    }
+}
+
+fn handler_waker_wake(s: &InterestHandlerWaker) {
+    let waker_arc = unsafe { Arc::from_raw(s) };
+    waker_arc.wake_now();
+}
+
+fn handler_waker_clone(s: &InterestHandlerWaker) -> RawWaker {
+    let arc = unsafe { Arc::from_raw(s) };
+    std::mem::forget(arc.clone());
+    RawWaker::new(Arc::into_raw(arc) as *const (), &VTABLE)
+}
+
+const VTABLE: RawWakerVTable = unsafe {
+    RawWakerVTable::new(
+        |s| handler_waker_clone(&*(s as *const InterestHandlerWaker)), // clone
+        |s| handler_waker_wake(&*(s as *const InterestHandlerWaker)),  // wake
+        |s| (*(s as *const InterestHandlerWaker)).wake_now(), // wake by ref (don't decrease refcount)
+        |s| drop(Arc::from_raw(s as *const InterestHandlerWaker)), // decrease refcount
+    )
+};
+
+#[derive(Debug, Clone, Default)]
+struct InterestWakerMapState {
+    wakers: HashMap<InterestType, Vec<Waker>>,
+    triggered: HashSet<InterestType>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct InterestWakerMap {
+    state: Arc<Mutex<InterestWakerMapState>>,
+}
+
+impl InterestWakerMap {
+    pub fn add(&self, interest: InterestType, waker: &Waker) {
+        let mut state = self.state.lock().unwrap();
+        let entries = state.wakers.entry(interest).or_default();
+        if !entries.iter().any(|w| w.will_wake(waker)) {
+            entries.push(waker.clone());
+        }
+    }
+
+    pub fn pop(&self, interest: InterestType) -> bool {
+        let mut state = self.state.lock().unwrap();
+        state.triggered.remove(&interest)
+    }
+
+    pub fn push(&self, interest: InterestType) -> bool {
+        let mut state = self.state.lock().unwrap();
+        state.triggered.insert(interest)
+    }
+}
+
+impl InterestHandler for InterestWakerMap {
+    fn push_interest(&mut self, interest: InterestType) {
+        let mut state = self.state.lock().unwrap();
+        if let Some(wakers) = state.wakers.remove(&interest) {
+            for waker in wakers {
+                waker.wake();
+            }
+        } else {
+            state.triggered.insert(interest);
+        }
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        let mut state = self.state.lock().unwrap();
+        state.triggered.remove(&interest)
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        let state = self.state.lock().unwrap();
+        state.triggered.contains(&interest)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/lib.rs
new file mode 100644
index 0000000..e2e52b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/lib.rs
@@ -0,0 +1,15 @@
+mod arc;
+#[cfg(feature = "sys")]
+mod guard;
+mod interest;
+#[cfg(feature = "sys")]
+mod selector;
+pub mod waker;
+
+pub use arc::*;
+#[cfg(feature = "sys")]
+pub use guard::*;
+pub use interest::*;
+#[cfg(feature = "sys")]
+pub use selector::*;
+pub use waker::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/selector.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/selector.rs
new file mode 100644
index 0000000..3ea1b2f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/selector.rs
@@ -0,0 +1,183 @@
+use std::{
+    collections::HashMap,
+    io,
+    sync::{Arc, Mutex},
+};
+
+use derivative::Derivative;
+use mio::{Registry, Token};
+
+use crate::{InterestHandler, InterestType};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub(crate) struct EngineInner {
+    seed: usize,
+    registry: Registry,
+    #[derivative(Debug = "ignore")]
+    lookup: HashMap<Token, Box<dyn InterestHandler + Send + Sync>>,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct Selector {
+    token_close: Token,
+    inner: Mutex<EngineInner>,
+    closer: mio::Waker,
+}
+
+impl Selector {
+    pub fn new() -> Arc<Self> {
+        let poll = mio::Poll::new().unwrap();
+        let registry = poll
+            .registry()
+            .try_clone()
+            .expect("the selector registry failed to clone");
+
+        let engine = Arc::new(Selector {
+            closer: mio::Waker::new(poll.registry(), Token(0)).unwrap(),
+            token_close: Token(1),
+            inner: Mutex::new(EngineInner {
+                seed: 10,
+                lookup: Default::default(),
+                registry,
+            }),
+        });
+
+        {
+            let engine = engine.clone();
+            std::thread::spawn(move || {
+                Self::run(engine, poll);
+            });
+        }
+
+        engine
+    }
+
+    pub fn shutdown(&self) {
+        self.closer.wake().ok();
+    }
+
+    #[must_use = "the token must be consumed"]
+    pub fn add(
+        &self,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+        source: &mut dyn mio::event::Source,
+        interests: mio::Interest,
+    ) -> io::Result<Token> {
+        let mut guard = self.inner.lock().unwrap();
+
+        guard.seed = guard
+            .seed
+            .checked_add(1)
+            .expect("selector has ran out of token seeds");
+        let token = guard.seed;
+        let token = Token(token);
+        guard.lookup.insert(token, handler);
+
+        match source.register(&guard.registry, token, interests) {
+            Ok(()) => {}
+            Err(err) if err.kind() == io::ErrorKind::AlreadyExists => {
+                source.deregister(&guard.registry).ok();
+                source.register(&guard.registry, token, interests)?;
+            }
+            Err(err) => return Err(err),
+        };
+
+        Ok(token)
+    }
+
+    pub fn remove(
+        &self,
+        token: Token,
+        source: Option<&mut dyn mio::event::Source>,
+    ) -> io::Result<()> {
+        let mut guard = self.inner.lock().unwrap();
+        guard.lookup.remove(&token);
+
+        if let Some(source) = source {
+            guard.registry.deregister(source)?;
+        }
+        Ok(())
+    }
+
+    pub fn handle<F>(&self, token: Token, f: F)
+    where
+        F: Fn(&mut Box<dyn InterestHandler + Send + Sync>),
+    {
+        let mut guard = self.inner.lock().unwrap();
+        if let Some(handler) = guard.lookup.get_mut(&token) {
+            f(handler)
+        }
+    }
+
+    pub fn replace(&self, token: Token, mut handler: Box<dyn InterestHandler + Send + Sync>) {
+        let mut guard = self.inner.lock().unwrap();
+
+        let last = guard.lookup.remove(&token);
+        if let Some(last) = last {
+            let interests = vec![
+                InterestType::Readable,
+                InterestType::Writable,
+                InterestType::Closed,
+                InterestType::Error,
+            ];
+            for interest in interests {
+                if last.has_interest(interest) && !handler.has_interest(interest) {
+                    handler.push_interest(interest);
+                }
+            }
+        }
+
+        guard.lookup.insert(token, handler);
+    }
+
+    fn run(engine: Arc<Selector>, mut poll: mio::Poll) {
+        // The outer loop is used to release the scope of the
+        // read lock whenever it needs to do so
+        let mut events = mio::Events::with_capacity(128);
+        loop {
+            // Wait for an event to trigger
+            poll.poll(&mut events, None).unwrap();
+
+            // Loop through all the events while under a guard lock
+            let mut guard = engine.inner.lock().unwrap();
+            for event in events.iter() {
+                // If the event is already dropped then ignore it
+                let token = event.token();
+
+                // If its the close event then exit
+                if token == engine.token_close {
+                    return;
+                }
+
+                // Get the handler
+                let handler = match guard.lookup.get_mut(&token) {
+                    Some(h) => h,
+                    None => {
+                        tracing::debug!(token = token.0, "orphaned event");
+                        continue;
+                    }
+                };
+
+                // Otherwise this is a waker we need to wake
+                if event.is_readable() {
+                    tracing::trace!(token = ?token, interest = ?InterestType::Readable, "host epoll");
+                    handler.push_interest(InterestType::Readable);
+                }
+                if event.is_writable() {
+                    tracing::trace!(token = ?token, interest = ?InterestType::Writable, "host epoll");
+                    handler.push_interest(InterestType::Writable);
+                }
+                if event.is_read_closed() || event.is_write_closed() {
+                    tracing::trace!(token = ?token, interest = ?InterestType::Closed, "host epoll");
+                    handler.push_interest(InterestType::Closed);
+                }
+                if event.is_error() {
+                    tracing::trace!(token = ?token, interest = ?InterestType::Error, "host epoll");
+                    handler.push_interest(InterestType::Error);
+                }
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/waker.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/waker.rs
new file mode 100644
index 0000000..f9fe822
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-io/src/waker.rs
@@ -0,0 +1,83 @@
+#![allow(dead_code, unused)]
+use std::{
+    sync::{Arc, Condvar, Mutex},
+    task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
+};
+
+use futures::Future;
+
+pub struct InlineWaker {
+    lock: Mutex<()>,
+    condvar: Condvar,
+}
+impl InlineWaker {
+    pub fn new() -> Arc<Self> {
+        Arc::new(Self {
+            lock: Mutex::new(()),
+            condvar: Condvar::new(),
+        })
+    }
+
+    fn wake_now(&self) {
+        // Note: This guard should be there to prevent race conditions however in the
+        // browser it causes a lock up - some strange browser issue. What I suspect
+        // is that the Condvar::wait call is not releasing the mutex lock
+        #[cfg(not(feature = "js"))]
+        let _guard = self.lock.lock().unwrap();
+
+        self.condvar.notify_all();
+    }
+
+    pub fn as_waker(self: &Arc<Self>) -> Waker {
+        let s: *const Self = Arc::into_raw(Arc::clone(self));
+        let raw_waker = RawWaker::new(s as *const (), &VTABLE);
+        unsafe { Waker::from_raw(raw_waker) }
+    }
+
+    #[cfg(not(feature = "js"))]
+    pub fn block_on<'a, A>(task: impl Future<Output = A> + 'a) -> A {
+        futures::executor::block_on(task)
+    }
+
+    #[cfg(feature = "js")]
+    pub fn block_on<'a, A>(task: impl Future<Output = A> + 'a) -> A {
+        // Create the waker
+        let inline_waker = Self::new();
+        let waker = inline_waker.as_waker();
+        let mut cx = Context::from_waker(&waker);
+
+        // We loop waiting for the waker to be woken, then we poll again
+        let mut task = Box::pin(task);
+        loop {
+            let lock = inline_waker.lock.lock().unwrap();
+            match task.as_mut().poll(&mut cx) {
+                Poll::Pending => {
+                    inline_waker.condvar.wait(lock).ok();
+                }
+                Poll::Ready(ret) => {
+                    return ret;
+                }
+            }
+        }
+    }
+}
+
+fn inline_waker_wake(s: &InlineWaker) {
+    let waker_arc = unsafe { Arc::from_raw(s) };
+    waker_arc.wake_now();
+}
+
+fn inline_waker_clone(s: &InlineWaker) -> RawWaker {
+    let arc = unsafe { Arc::from_raw(s) };
+    std::mem::forget(arc.clone());
+    RawWaker::new(Arc::into_raw(arc) as *const (), &VTABLE)
+}
+
+const VTABLE: RawWakerVTable = unsafe {
+    RawWakerVTable::new(
+        |s| inline_waker_clone(&*(s as *const InlineWaker)), // clone
+        |s| inline_waker_wake(&*(s as *const InlineWaker)),  // wake
+        |s| (*(s as *const InlineWaker)).wake_now(), // wake by ref (don't decrease refcount)
+        |s| drop(Arc::from_raw(s as *const InlineWaker)), // decrease refcount
+    )
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/Cargo.toml
new file mode 100644
index 0000000..6bbd2a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/Cargo.toml
@@ -0,0 +1,60 @@
+[package]
+name = "virtual-net"
+version = "0.6.3"
+description = "Wasmer Virtual Networking"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+thiserror = "1"
+bytes = "1.1"
+async-trait = { version = "^0.1" }
+tracing = "0.1"
+tokio = { version = "1", default_features = false, features = ["io-util"] }
+libc = { version = "0.2.139", optional = true }
+mio = { version = "0.8", optional = true }
+socket2 = { version = "0.4", optional = true }
+derivative = { version = "^2" }
+virtual-mio  = { path = "../virtual-io", version = "0.3.0", default-features = false }
+base64 = "0.21"
+bincode = { version = "1.3" }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+pin-project-lite = "0.2.9"
+futures-util = { version = "0.3" }
+anyhow = "1.0"
+tokio-serde = { version = "0.8", features = [ "bincode" ], optional = true }
+tokio-util = { version = "0.7.8", features = ["codec"], optional = true }
+hyper-tungstenite = { version = "0.11", optional = true }
+hyper = { version = "0.14", optional = true }
+tokio-tungstenite = { version = "0.20", optional = true }
+rkyv = { workspace = true, optional = true }
+bytecheck = { version = "0.6.8", optional = true }
+
+[dependencies.smoltcp]
+version = "0.8"
+default-features = false
+features = ["proto-ipv4", "std", "alloc"]
+
+[dev-dependencies]
+tokio = { version = "1", default_features = false, features = [ "macros", "rt-multi-thread" ] }
+tracing-test = { version = "0.2" }
+serial_test = "2.0.0"
+
+[features]
+default = [ "host-net", "remote", "json", "messagepack", "cbor", "hyper", "tokio-tungstenite" ]
+host-net = [ "libc", "tokio/io-util", "virtual-mio/sys", "tokio/net", "tokio/rt", "socket2", "mio" ]
+remote = [ "libc", "tokio/io-util", "tokio/sync", "tokio-serde", "tokio-util" ]
+json = [ "tokio-serde/json" ]
+messagepack = [ "tokio-serde/messagepack" ]
+cbor = [ "tokio-serde/cbor" ]
+hyper = [ "hyper-tungstenite", "dep:hyper" ]
+tokio-tungstenite = [ "dep:tokio-tungstenite" ]
+rkyv = [ "dep:rkyv", "dep:bytecheck" ]
+
+[package.metadata.docs.rs]
+features = ["host-net", "remote"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/client.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/client.rs
new file mode 100644
index 0000000..879b992
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/client.rs
@@ -0,0 +1,1544 @@
+use std::collections::HashMap;
+use std::collections::VecDeque;
+use std::future::Future;
+use std::net::IpAddr;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::task::Context;
+use std::task::Poll;
+use std::task::RawWaker;
+use std::task::RawWakerVTable;
+use std::task::Waker;
+use std::time::Duration;
+
+use bytes::Buf;
+use bytes::BytesMut;
+use derivative::Derivative;
+use futures_util::future::BoxFuture;
+use futures_util::stream::FuturesOrdered;
+use futures_util::Sink;
+use futures_util::Stream;
+use futures_util::StreamExt;
+use tokio::io::AsyncRead;
+use tokio::io::AsyncWrite;
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::error::TryRecvError;
+use tokio::sync::mpsc::error::TrySendError;
+use tokio_serde::formats::SymmetricalBincode;
+#[cfg(feature = "cbor")]
+use tokio_serde::formats::SymmetricalCbor;
+#[cfg(feature = "json")]
+use tokio_serde::formats::SymmetricalJson;
+#[cfg(feature = "messagepack")]
+use tokio_serde::formats::SymmetricalMessagePack;
+use tokio_serde::SymmetricallyFramed;
+use tokio_util::codec::FramedRead;
+use tokio_util::codec::FramedWrite;
+use tokio_util::codec::LengthDelimitedCodec;
+use virtual_mio::InlineWaker;
+use virtual_mio::InterestType;
+
+use crate::meta;
+use crate::meta::FrameSerializationFormat;
+use crate::meta::RequestType;
+use crate::meta::ResponseType;
+use crate::meta::SocketId;
+use crate::meta::{MessageRequest, MessageResponse};
+use crate::IpCidr;
+use crate::IpRoute;
+use crate::NetworkError;
+use crate::StreamSecurity;
+use crate::VirtualConnectedSocket;
+use crate::VirtualConnectionlessSocket;
+use crate::VirtualIcmpSocket;
+use crate::VirtualIoSource;
+use crate::VirtualNetworking;
+use crate::VirtualRawSocket;
+use crate::VirtualSocket;
+use crate::VirtualTcpListener;
+use crate::VirtualTcpSocket;
+use crate::VirtualUdpSocket;
+
+use crate::rx_tx::RemoteRx;
+use crate::rx_tx::RemoteTx;
+use crate::rx_tx::RemoteTxWakers;
+use crate::Result;
+
+#[derive(Debug, Clone)]
+pub struct RemoteNetworkingClient {
+    common: Arc<RemoteCommon>,
+}
+
+impl RemoteNetworkingClient {
+    fn new(
+        tx: RemoteTx<MessageRequest>,
+        rx: RemoteRx<MessageResponse>,
+        rx_work: mpsc::UnboundedReceiver<BoxFuture<'static, ()>>,
+    ) -> (Self, RemoteNetworkingClientDriver) {
+        let common = RemoteCommon {
+            tx,
+            rx: Mutex::new(rx),
+            request_seed: AtomicU64::new(1),
+            requests: Default::default(),
+            socket_seed: AtomicU64::new(1),
+            recv_tx: Default::default(),
+            recv_with_addr_tx: Default::default(),
+            accept_tx: Default::default(),
+            sent_tx: Default::default(),
+            handlers: Default::default(),
+            stall: Default::default(),
+        };
+        let common = Arc::new(common);
+
+        let driver = RemoteNetworkingClientDriver {
+            more_work: rx_work,
+            tasks: Default::default(),
+            common: common.clone(),
+        };
+        let networking = Self { common };
+
+        (networking, driver)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    pub fn new_from_mpsc(
+        tx: mpsc::Sender<MessageRequest>,
+        rx: mpsc::Receiver<MessageResponse>,
+    ) -> (Self, RemoteNetworkingClientDriver) {
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+        let tx_wakers = RemoteTxWakers::default();
+
+        let tx = RemoteTx::Mpsc {
+            tx,
+            work: tx_work,
+            wakers: tx_wakers.clone(),
+        };
+        let rx = RemoteRx::Mpsc {
+            rx,
+            wakers: tx_wakers,
+        };
+
+        Self::new(tx, rx, rx_work)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    ///
+    /// This version will run the async read and write operations
+    /// only the driver (this is needed for mixed runtimes)
+    pub fn new_from_async_io<TX, RX>(
+        tx: TX,
+        rx: RX,
+        format: FrameSerializationFormat,
+    ) -> (Self, RemoteNetworkingClientDriver)
+    where
+        TX: AsyncWrite + Send + 'static,
+        RX: AsyncRead + Send + 'static,
+    {
+        let tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+        let tx: Pin<Box<dyn Sink<MessageRequest, Error = std::io::Error> + Send + 'static>> =
+            match format {
+                FrameSerializationFormat::Bincode => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalBincode::default()))
+                }
+                #[cfg(feature = "json")]
+                FrameSerializationFormat::Json => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalJson::default()))
+                }
+                #[cfg(feature = "messagepack")]
+                FrameSerializationFormat::MessagePack => Box::pin(SymmetricallyFramed::new(
+                    tx,
+                    SymmetricalMessagePack::default(),
+                )),
+                #[cfg(feature = "cbor")]
+                FrameSerializationFormat::Cbor => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalCbor::default()))
+                }
+            };
+
+        let rx = FramedRead::new(rx, LengthDelimitedCodec::new());
+        let rx: Pin<Box<dyn Stream<Item = std::io::Result<MessageResponse>> + Send + 'static>> =
+            match format {
+                FrameSerializationFormat::Bincode => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalBincode::default()))
+                }
+                #[cfg(feature = "json")]
+                FrameSerializationFormat::Json => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalJson::default()))
+                }
+                #[cfg(feature = "messagepack")]
+                FrameSerializationFormat::MessagePack => Box::pin(SymmetricallyFramed::new(
+                    rx,
+                    SymmetricalMessagePack::default(),
+                )),
+                #[cfg(feature = "cbor")]
+                FrameSerializationFormat::Cbor => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalCbor::default()))
+                }
+            };
+
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+        let tx_wakers = RemoteTxWakers::default();
+
+        let tx = RemoteTx::Stream {
+            tx: Arc::new(tokio::sync::Mutex::new(tx)),
+            work: tx_work,
+            wakers: tx_wakers,
+        };
+        let rx = RemoteRx::Stream { rx };
+
+        Self::new(tx, rx, rx_work)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    #[cfg(feature = "hyper")]
+    pub fn new_from_hyper_ws_io(
+        tx: futures_util::stream::SplitSink<
+            hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>,
+            hyper_tungstenite::tungstenite::Message,
+        >,
+        rx: futures_util::stream::SplitStream<
+            hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>,
+        >,
+        format: FrameSerializationFormat,
+    ) -> (Self, RemoteNetworkingClientDriver) {
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+
+        let tx = RemoteTx::HyperWebSocket {
+            tx: Arc::new(tokio::sync::Mutex::new(tx)),
+            work: tx_work,
+            wakers: RemoteTxWakers::default(),
+            format,
+        };
+        let rx = RemoteRx::HyperWebSocket { rx, format };
+        Self::new(tx, rx, rx_work)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    #[cfg(feature = "tokio-tungstenite")]
+    pub fn new_from_tokio_ws_io(
+        tx: futures_util::stream::SplitSink<
+            tokio_tungstenite::WebSocketStream<
+                tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
+            >,
+            tokio_tungstenite::tungstenite::Message,
+        >,
+        rx: futures_util::stream::SplitStream<
+            tokio_tungstenite::WebSocketStream<
+                tokio_tungstenite::MaybeTlsStream<tokio::net::TcpStream>,
+            >,
+        >,
+        format: FrameSerializationFormat,
+    ) -> (Self, RemoteNetworkingClientDriver) {
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+
+        let tx = RemoteTx::TokioWebSocket {
+            tx: Arc::new(tokio::sync::Mutex::new(tx)),
+            work: tx_work,
+            wakers: RemoteTxWakers::default(),
+            format,
+        };
+        let rx = RemoteRx::TokioWebSocket { rx, format };
+        Self::new(tx, rx, rx_work)
+    }
+
+    fn new_socket(&self, id: SocketId) -> RemoteSocket {
+        let (tx, rx_recv) = tokio::sync::mpsc::channel(100);
+        self.common.recv_tx.lock().unwrap().insert(id, tx);
+
+        let (tx, rx_recv_with_addr) = tokio::sync::mpsc::channel(100);
+        self.common.recv_with_addr_tx.lock().unwrap().insert(id, tx);
+
+        let (tx, rx_accept) = tokio::sync::mpsc::channel(100);
+        self.common.accept_tx.lock().unwrap().insert(id, tx);
+
+        let (tx, rx_sent) = tokio::sync::mpsc::channel(100);
+        self.common.sent_tx.lock().unwrap().insert(id, tx);
+
+        RemoteSocket {
+            socket_id: id,
+            common: self.common.clone(),
+            rx_buffer: BytesMut::new(),
+            rx_recv,
+            rx_recv_with_addr,
+            rx_accept,
+            rx_sent,
+            tx_waker: TxWaker::new(&self.common).as_waker(),
+            pending_accept: None,
+            buffer_accept: Default::default(),
+            buffer_recv_with_addr: Default::default(),
+            send_available: 0,
+        }
+    }
+}
+
+pin_project_lite::pin_project! {
+    pub struct RemoteNetworkingClientDriver {
+        common: Arc<RemoteCommon>,
+        more_work: mpsc::UnboundedReceiver<BoxFuture<'static, ()>>,
+        #[pin]
+        tasks: FuturesOrdered<BoxFuture<'static, ()>>,
+    }
+}
+
+impl Future for RemoteNetworkingClientDriver {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // This guard will be held while the pipeline is not currently
+        // stalled by some back pressure. It is only acquired when there
+        // is background tasks being processed
+        let mut not_stalled_guard = None;
+
+        // We loop until the waker is registered with the receiving stream
+        // and all the background tasks
+        loop {
+            // Background tasks are sent to this driver in certain circumstances
+            while let Poll::Ready(Some(work)) = Pin::new(&mut self.more_work).poll_recv(cx) {
+                self.tasks.push_back(work);
+            }
+
+            // Background work basically stalls the stream until its all processed
+            // which makes the back pressure system work properly
+            match self.tasks.poll_next_unpin(cx) {
+                Poll::Ready(Some(_)) => continue,
+                Poll::Ready(None) => {
+                    not_stalled_guard.take();
+                }
+                Poll::Pending if not_stalled_guard.is_none() => {
+                    if let Ok(guard) = self.common.stall.clone().try_lock_owned() {
+                        not_stalled_guard.replace(guard);
+                    } else {
+                        return Poll::Pending;
+                    }
+                }
+                Poll::Pending => {}
+            };
+
+            // We grab the next message sent by the server to us
+            let msg = {
+                let mut rx_guard = self.common.rx.lock().unwrap();
+                rx_guard.poll(cx)
+            };
+            return match msg {
+                Poll::Ready(Some(msg)) => {
+                    match msg {
+                        MessageResponse::Recv { socket_id, data } => {
+                            let tx = {
+                                let guard = self.common.recv_tx.lock().unwrap();
+                                match guard.get(&socket_id) {
+                                    Some(tx) => tx.clone(),
+                                    None => {
+                                        continue;
+                                    }
+                                }
+                            };
+                            let common = self.common.clone();
+                            self.tasks.push_back(Box::pin(async move {
+                                tx.send(data).await.ok();
+
+                                if let Some(h) = common.handlers.lock().unwrap().get_mut(&socket_id)
+                                {
+                                    h.push_interest(InterestType::Readable)
+                                }
+                            }));
+                        }
+                        MessageResponse::RecvWithAddr {
+                            socket_id,
+                            data,
+                            addr,
+                        } => {
+                            let tx = {
+                                let guard = self.common.recv_with_addr_tx.lock().unwrap();
+                                match guard.get(&socket_id) {
+                                    Some(tx) => tx.clone(),
+                                    None => continue,
+                                }
+                            };
+                            let common = self.common.clone();
+                            self.tasks.push_back(Box::pin(async move {
+                                tx.send(DataWithAddr { data, addr }).await.ok();
+
+                                if let Some(h) = common.handlers.lock().unwrap().get_mut(&socket_id)
+                                {
+                                    h.push_interest(InterestType::Readable)
+                                }
+                            }));
+                        }
+                        MessageResponse::Sent {
+                            socket_id, amount, ..
+                        } => {
+                            let tx = {
+                                let guard = self.common.sent_tx.lock().unwrap();
+                                match guard.get(&socket_id) {
+                                    Some(tx) => tx.clone(),
+                                    None => continue,
+                                }
+                            };
+                            self.tasks.push_back(Box::pin(async move {
+                                tx.send(amount).await.ok();
+                            }));
+                            if let Some(h) =
+                                self.common.handlers.lock().unwrap().get_mut(&socket_id)
+                            {
+                                h.push_interest(InterestType::Writable)
+                            }
+                        }
+                        MessageResponse::SendError {
+                            socket_id, error, ..
+                        } => match &error {
+                            NetworkError::ConnectionAborted
+                            | NetworkError::ConnectionReset
+                            | NetworkError::BrokenPipe => {
+                                if let Some(h) =
+                                    self.common.handlers.lock().unwrap().get_mut(&socket_id)
+                                {
+                                    h.push_interest(InterestType::Closed)
+                                }
+                            }
+                            _ => {
+                                if let Some(h) =
+                                    self.common.handlers.lock().unwrap().get_mut(&socket_id)
+                                {
+                                    h.push_interest(InterestType::Writable)
+                                }
+                            }
+                        },
+                        MessageResponse::FinishAccept {
+                            socket_id,
+                            child_id,
+                            addr,
+                        } => {
+                            let common = self.common.clone();
+                            self.tasks.push_back(Box::pin(async move {
+                                let tx = common.accept_tx.lock().unwrap().get(&socket_id).cloned();
+                                if let Some(tx) = tx {
+                                    tx.send(SocketWithAddr {
+                                        socket: child_id,
+                                        addr,
+                                    })
+                                    .await
+                                    .ok();
+                                }
+
+                                if let Some(h) = common.handlers.lock().unwrap().get_mut(&socket_id)
+                                {
+                                    h.push_interest(InterestType::Readable)
+                                }
+                            }));
+                        }
+                        MessageResponse::Closed { socket_id } => {
+                            if let Some(h) =
+                                self.common.handlers.lock().unwrap().get_mut(&socket_id)
+                            {
+                                h.push_interest(InterestType::Closed)
+                            }
+                        }
+                        MessageResponse::ResponseToRequest { req_id, res } => {
+                            let mut requests = self.common.requests.lock().unwrap();
+                            if let Some(request) = requests.remove(&req_id) {
+                                request.try_send(res).ok();
+                            }
+                        }
+                    }
+                    continue;
+                }
+                Poll::Ready(None) => Poll::Ready(()),
+                Poll::Pending => Poll::Pending,
+            };
+        }
+    }
+}
+
+#[derive(Debug)]
+struct TxWaker {
+    common: Arc<RemoteCommon>,
+}
+impl TxWaker {
+    pub fn new(common: &Arc<RemoteCommon>) -> Arc<Self> {
+        Arc::new(Self {
+            common: common.clone(),
+        })
+    }
+
+    fn wake_now(&self) {
+        let mut guard = self.common.handlers.lock().unwrap();
+        for (_, handler) in guard.iter_mut() {
+            handler.push_interest(InterestType::Writable);
+        }
+    }
+
+    pub fn as_waker(self: &Arc<Self>) -> Waker {
+        let s: *const Self = Arc::into_raw(Arc::clone(self));
+        let raw_waker = RawWaker::new(s as *const (), &VTABLE);
+        unsafe { Waker::from_raw(raw_waker) }
+    }
+}
+
+fn tx_waker_wake(s: &TxWaker) {
+    let waker_arc = unsafe { Arc::from_raw(s) };
+    waker_arc.wake_now();
+}
+
+fn tx_waker_clone(s: &TxWaker) -> RawWaker {
+    let arc = unsafe { Arc::from_raw(s) };
+    std::mem::forget(arc.clone());
+    RawWaker::new(Arc::into_raw(arc) as *const (), &VTABLE)
+}
+
+const VTABLE: RawWakerVTable = unsafe {
+    RawWakerVTable::new(
+        |s| tx_waker_clone(&*(s as *const TxWaker)),  // clone
+        |s| tx_waker_wake(&*(s as *const TxWaker)),   // wake
+        |s| (*(s as *const TxWaker)).wake_now(),      // wake by ref (don't decrease refcount)
+        |s| drop(Arc::from_raw(s as *const TxWaker)), // decrease refcount
+    )
+};
+
+#[derive(Debug)]
+struct RequestTx {
+    tx: mpsc::Sender<ResponseType>,
+}
+impl RequestTx {
+    pub fn try_send(self, msg: ResponseType) -> Result<()> {
+        match self.tx.try_send(msg) {
+            Ok(()) => Ok(()),
+            Err(TrySendError::Closed(_)) => Err(NetworkError::ConnectionAborted),
+            Err(TrySendError::Full(_)) => Err(NetworkError::WouldBlock),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct DataWithAddr {
+    pub data: Vec<u8>,
+    pub addr: SocketAddr,
+}
+#[derive(Debug)]
+struct SocketWithAddr {
+    pub socket: SocketId,
+    pub addr: SocketAddr,
+}
+type SocketMap<T> = HashMap<SocketId, T>;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct RemoteCommon {
+    #[derivative(Debug = "ignore")]
+    tx: RemoteTx<MessageRequest>,
+    #[derivative(Debug = "ignore")]
+    rx: Mutex<RemoteRx<MessageResponse>>,
+    request_seed: AtomicU64,
+    requests: Mutex<HashMap<u64, RequestTx>>,
+    socket_seed: AtomicU64,
+    recv_tx: Mutex<SocketMap<mpsc::Sender<Vec<u8>>>>,
+    recv_with_addr_tx: Mutex<SocketMap<mpsc::Sender<DataWithAddr>>>,
+    accept_tx: Mutex<SocketMap<mpsc::Sender<SocketWithAddr>>>,
+    sent_tx: Mutex<SocketMap<mpsc::Sender<u64>>>,
+    #[derivative(Debug = "ignore")]
+    handlers: Mutex<SocketMap<Box<dyn virtual_mio::InterestHandler + Send + Sync>>>,
+
+    // The stall guard will prevent reads while its held and there are background tasks running
+    // (the idea behind this is to create back pressure so that the task list infinitely grow)
+    stall: Arc<tokio::sync::Mutex<()>>,
+}
+
+impl RemoteCommon {
+    async fn io_iface(&self, req: RequestType) -> ResponseType {
+        let req_id = self.request_seed.fetch_add(1, Ordering::SeqCst);
+        let mut req_rx = {
+            let (tx, rx) = mpsc::channel(1);
+            let mut guard = self.requests.lock().unwrap();
+            guard.insert(req_id, RequestTx { tx });
+            rx
+        };
+        if let Err(err) = self
+            .tx
+            .send(MessageRequest::Interface {
+                req_id: Some(req_id),
+                req,
+            })
+            .await
+        {
+            return ResponseType::Err(err);
+        };
+        req_rx.recv().await.unwrap()
+    }
+
+    fn io_iface_fire_and_forget(&self, req: RequestType) -> Result<()> {
+        self.tx
+            .send_with_driver(MessageRequest::Interface { req_id: None, req })
+    }
+}
+
+#[async_trait::async_trait]
+impl VirtualNetworking for RemoteNetworkingClient {
+    async fn bridge(
+        &self,
+        network: &str,
+        access_token: &str,
+        security: StreamSecurity,
+    ) -> Result<()> {
+        match self
+            .common
+            .io_iface(RequestType::Bridge {
+                network: network.to_string(),
+                access_token: access_token.to_string(),
+                security,
+            })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(()),
+            res => {
+                tracing::debug!("invalid response to bridge request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn unbridge(&self) -> Result<()> {
+        match self.common.io_iface(RequestType::Unbridge).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(()),
+            res => {
+                tracing::debug!("invalid response to unbridge request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn dhcp_acquire(&self) -> Result<Vec<IpAddr>> {
+        match self.common.io_iface(RequestType::DhcpAcquire).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::IpAddressList(ips) => Ok(ips),
+            res => {
+                tracing::debug!("invalid response to DHCP acquire request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn ip_add(&self, ip: IpAddr, prefix: u8) -> Result<()> {
+        self.common
+            .io_iface_fire_and_forget(RequestType::IpAdd { ip, prefix })
+    }
+
+    async fn ip_remove(&self, ip: IpAddr) -> Result<()> {
+        self.common
+            .io_iface_fire_and_forget(RequestType::IpRemove(ip))
+    }
+
+    async fn ip_clear(&self) -> Result<()> {
+        self.common.io_iface_fire_and_forget(RequestType::IpClear)
+    }
+
+    async fn ip_list(&self) -> Result<Vec<IpCidr>> {
+        match self.common.io_iface(RequestType::GetIpList).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::CidrList(routes) => Ok(routes),
+            res => {
+                tracing::debug!("invalid response to IP list request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn mac(&self) -> Result<[u8; 6]> {
+        match self.common.io_iface(RequestType::GetMac).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Mac(mac) => Ok(mac),
+            res => {
+                tracing::debug!("invalid response to MAC request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn gateway_set(&self, ip: IpAddr) -> Result<()> {
+        self.common
+            .io_iface_fire_and_forget(RequestType::GatewaySet(ip))
+    }
+
+    async fn route_add(
+        &self,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> Result<()> {
+        self.common.io_iface_fire_and_forget(RequestType::RouteAdd {
+            cidr,
+            via_router,
+            preferred_until,
+            expires_at,
+        })
+    }
+
+    async fn route_remove(&self, cidr: IpAddr) -> Result<()> {
+        self.common
+            .io_iface_fire_and_forget(RequestType::RouteRemove(cidr))
+    }
+
+    async fn route_clear(&self) -> Result<()> {
+        self.common
+            .io_iface_fire_and_forget(RequestType::RouteClear)
+    }
+
+    async fn route_list(&self) -> Result<Vec<IpRoute>> {
+        match self.common.io_iface(RequestType::GetRouteList).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::RouteList(routes) => Ok(routes),
+            res => {
+                tracing::debug!("invalid response to route list request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn bind_raw(&self) -> Result<Box<dyn VirtualRawSocket + Sync>> {
+        let socket_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        match self.common.io_iface(RequestType::BindRaw(socket_id)).await {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(Box::new(self.new_socket(socket_id))),
+            ResponseType::Socket(socket_id) => Ok(Box::new(self.new_socket(socket_id))),
+            res => {
+                tracing::debug!("invalid response to bind RAw request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn listen_tcp(
+        &self,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualTcpListener + Sync>> {
+        let socket_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        match self
+            .common
+            .io_iface(RequestType::ListenTcp {
+                socket_id,
+                addr,
+                only_v6,
+                reuse_port,
+                reuse_addr,
+            })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(Box::new(self.new_socket(socket_id))),
+            ResponseType::Socket(socket_id) => {
+                let mut socket = self.new_socket(socket_id);
+                socket.touch_begin_accept().ok();
+                Ok(Box::new(socket))
+            }
+            res => {
+                tracing::debug!("invalid response to listen TCP request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn bind_udp(
+        &self,
+        addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualUdpSocket + Sync>> {
+        let socket_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        match self
+            .common
+            .io_iface(RequestType::BindUdp {
+                socket_id,
+                addr,
+                reuse_port,
+                reuse_addr,
+            })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(Box::new(self.new_socket(socket_id))),
+            ResponseType::Socket(socket_id) => Ok(Box::new(self.new_socket(socket_id))),
+            res => {
+                tracing::debug!("invalid response to bind UDP request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn bind_icmp(&self, addr: IpAddr) -> Result<Box<dyn VirtualIcmpSocket + Sync>> {
+        let socket_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        match self
+            .common
+            .io_iface(RequestType::BindIcmp { socket_id, addr })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(Box::new(self.new_socket(socket_id))),
+            ResponseType::Socket(socket_id) => Ok(Box::new(self.new_socket(socket_id))),
+            res => {
+                tracing::debug!("invalid response to bind ICMP request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn connect_tcp(
+        &self,
+        addr: SocketAddr,
+        peer: SocketAddr,
+    ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
+        let socket_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        match self
+            .common
+            .io_iface(RequestType::ConnectTcp {
+                socket_id,
+                addr,
+                peer,
+            })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(Box::new(self.new_socket(socket_id))),
+            ResponseType::Socket(socket_id) => Ok(Box::new(self.new_socket(socket_id))),
+            res => {
+                tracing::debug!("invalid response to connect TCP request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    async fn resolve(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    ) -> Result<Vec<IpAddr>> {
+        match self
+            .common
+            .io_iface(RequestType::Resolve {
+                host: host.to_string(),
+                port,
+                dns_server,
+            })
+            .await
+        {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::IpAddressList(ips) => Ok(ips),
+            res => {
+                tracing::debug!("invalid response to resolve request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct RemoteSocket {
+    socket_id: SocketId,
+    common: Arc<RemoteCommon>,
+    rx_buffer: BytesMut,
+    rx_recv: mpsc::Receiver<Vec<u8>>,
+    rx_recv_with_addr: mpsc::Receiver<DataWithAddr>,
+    tx_waker: Waker,
+    rx_accept: mpsc::Receiver<SocketWithAddr>,
+    rx_sent: mpsc::Receiver<u64>,
+    pending_accept: Option<(SocketId, mpsc::Receiver<Vec<u8>>)>,
+    buffer_recv_with_addr: VecDeque<DataWithAddr>,
+    buffer_accept: VecDeque<SocketWithAddr>,
+    send_available: u64,
+}
+impl Drop for RemoteSocket {
+    fn drop(&mut self) {
+        self.common.recv_tx.lock().unwrap().remove(&self.socket_id);
+        self.common
+            .recv_with_addr_tx
+            .lock()
+            .unwrap()
+            .remove(&self.socket_id);
+    }
+}
+
+impl RemoteSocket {
+    async fn io_socket(&self, req: RequestType) -> ResponseType {
+        let req_id = self.common.request_seed.fetch_add(1, Ordering::SeqCst);
+        let mut req_rx = {
+            let (tx, rx) = mpsc::channel(1);
+            let mut guard = self.common.requests.lock().unwrap();
+            guard.insert(req_id, RequestTx { tx });
+            rx
+        };
+        if let Err(err) = self
+            .common
+            .tx
+            .send(MessageRequest::Socket {
+                socket: self.socket_id,
+                req_id: Some(req_id),
+                req,
+            })
+            .await
+        {
+            return ResponseType::Err(err);
+        };
+        req_rx.recv().await.unwrap()
+    }
+
+    fn io_socket_fire_and_forget(&self, req: RequestType) -> Result<()> {
+        self.common.tx.send_with_driver(MessageRequest::Socket {
+            socket: self.socket_id,
+            req_id: None,
+            req,
+        })
+    }
+
+    fn touch_begin_accept(&mut self) -> Result<()> {
+        if self.pending_accept.is_some() {
+            return Ok(());
+        }
+        let child_id: SocketId = self
+            .common
+            .socket_seed
+            .fetch_add(1, Ordering::SeqCst)
+            .into();
+        self.io_socket_fire_and_forget(RequestType::BeginAccept(child_id))?;
+
+        let (tx, rx_recv) = tokio::sync::mpsc::channel(100);
+        self.common.recv_tx.lock().unwrap().insert(child_id, tx);
+
+        self.pending_accept.replace((child_id, rx_recv));
+        Ok(())
+    }
+}
+
+impl VirtualIoSource for RemoteSocket {
+    fn remove_handler(&mut self) {
+        self.common.handlers.lock().unwrap().remove(&self.socket_id);
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>> {
+        if !self.rx_buffer.is_empty() {
+            return Poll::Ready(Ok(self.rx_buffer.len()));
+        }
+        match self.rx_recv.poll_recv(cx) {
+            Poll::Ready(Some(data)) => {
+                self.rx_buffer.extend_from_slice(&data);
+                return Poll::Ready(Ok(self.rx_buffer.len()));
+            }
+            Poll::Ready(None) => return Poll::Ready(Ok(0)),
+            Poll::Pending => {}
+        }
+        if !self.buffer_recv_with_addr.is_empty() {
+            let total = self
+                .buffer_recv_with_addr
+                .iter()
+                .map(|a| a.data.len())
+                .sum();
+            return Poll::Ready(Ok(total));
+        }
+        match self.rx_recv_with_addr.poll_recv(cx) {
+            Poll::Ready(Some(data)) => self.buffer_recv_with_addr.push_back(data),
+            Poll::Ready(None) => return Poll::Ready(Ok(0)),
+            Poll::Pending => {}
+        }
+        if !self.buffer_accept.is_empty() {
+            return Poll::Ready(Ok(self.buffer_accept.len()));
+        }
+        match self.rx_accept.poll_recv(cx) {
+            Poll::Ready(Some(data)) => self.buffer_accept.push_back(data),
+            Poll::Ready(None) => {}
+            Poll::Pending => {}
+        }
+        Poll::Pending
+    }
+
+    fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>> {
+        if self.send_available > 0 {
+            return Poll::Ready(Ok(self.send_available as usize));
+        }
+        match self.rx_sent.poll_recv(cx) {
+            Poll::Ready(Some(amt)) => {
+                self.send_available += amt;
+                return Poll::Ready(Ok(self.send_available as usize));
+            }
+            Poll::Ready(None) => return Poll::Ready(Ok(0)),
+            Poll::Pending => {}
+        }
+        Poll::Pending
+    }
+}
+
+impl VirtualSocket for RemoteSocket {
+    fn set_ttl(&mut self, ttl: u32) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetTtl(ttl))
+    }
+
+    fn ttl(&self) -> Result<u32> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetTtl)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Ttl(ttl) => Ok(ttl),
+            res => {
+                tracing::debug!("invalid response to get TTL request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn addr_local(&self) -> Result<SocketAddr> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrLocal)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::SocketAddr(addr) => Ok(addr),
+            res => {
+                tracing::debug!("invalid response to address local request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn status(&self) -> Result<crate::SocketStatus> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetStatus)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Status(status) => Ok(status),
+            res => {
+                tracing::debug!("invalid response to status request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_handler(
+        &mut self,
+        handler: Box<dyn virtual_mio::InterestHandler + Send + Sync>,
+    ) -> Result<()> {
+        self.common
+            .handlers
+            .lock()
+            .unwrap()
+            .insert(self.socket_id, handler);
+        Ok(())
+    }
+}
+
+impl VirtualTcpListener for RemoteSocket {
+    fn try_accept(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)> {
+        // We may already have accepted a connection in the `poll_read_ready` method
+        self.touch_begin_accept()?;
+        let accepted = if let Some(child) = self.buffer_accept.pop_front() {
+            child
+        } else {
+            self.rx_accept.try_recv().map_err(|err| match err {
+                TryRecvError::Empty => NetworkError::WouldBlock,
+                TryRecvError::Disconnected => NetworkError::ConnectionAborted,
+            })?
+        };
+
+        // This placed here will mean there is always an accept request pending at the
+        // server as the constructor invokes this method and we invoke it here after
+        // receiving a child connection.
+        let mut rx_recv = None;
+        if let Some((rx_socket, existing_rx_recv)) = self.pending_accept.take() {
+            if accepted.socket == rx_socket {
+                rx_recv.replace(existing_rx_recv);
+            }
+        }
+        let rx_recv = match rx_recv {
+            Some(rx_recv) => rx_recv,
+            None => {
+                let (tx, rx_recv) = tokio::sync::mpsc::channel(100);
+                self.common
+                    .recv_tx
+                    .lock()
+                    .unwrap()
+                    .insert(accepted.socket, tx);
+                rx_recv
+            }
+        };
+        self.touch_begin_accept().ok();
+
+        let (tx, rx_recv_with_addr) = tokio::sync::mpsc::channel(100);
+        self.common
+            .recv_with_addr_tx
+            .lock()
+            .unwrap()
+            .insert(accepted.socket, tx);
+
+        let (tx, rx_accept) = tokio::sync::mpsc::channel(100);
+        self.common
+            .accept_tx
+            .lock()
+            .unwrap()
+            .insert(accepted.socket, tx);
+
+        let (tx, rx_sent) = tokio::sync::mpsc::channel(100);
+        self.common
+            .sent_tx
+            .lock()
+            .unwrap()
+            .insert(accepted.socket, tx);
+
+        let socket = RemoteSocket {
+            socket_id: accepted.socket,
+            common: self.common.clone(),
+            rx_buffer: BytesMut::new(),
+            rx_recv,
+            rx_recv_with_addr,
+            rx_accept,
+            rx_sent,
+            pending_accept: None,
+            tx_waker: TxWaker::new(&self.common).as_waker(),
+            buffer_accept: Default::default(),
+            buffer_recv_with_addr: Default::default(),
+            send_available: 0,
+        };
+        Ok((Box::new(socket), accepted.addr))
+    }
+
+    fn set_handler(
+        &mut self,
+        handler: Box<dyn virtual_mio::InterestHandler + Send + Sync>,
+    ) -> Result<()> {
+        VirtualSocket::set_handler(self, handler)
+    }
+
+    fn addr_local(&self) -> Result<SocketAddr> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrLocal)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::SocketAddr(addr) => Ok(addr),
+            res => {
+                tracing::debug!("invalid response to addr local request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_ttl(&mut self, ttl: u8) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetTtl(ttl as u32))
+    }
+
+    fn ttl(&self) -> Result<u8> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetTtl)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Ttl(val) => Ok(val.try_into().map_err(|_| NetworkError::InvalidData)?),
+            res => {
+                tracing::debug!("invalid response to get TTL request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+}
+
+impl VirtualRawSocket for RemoteSocket {
+    fn try_send(&mut self, data: &[u8]) -> Result<usize> {
+        let mut cx = Context::from_waker(&self.tx_waker);
+        match self.common.tx.poll_send(
+            &mut cx,
+            MessageRequest::Send {
+                socket: self.socket_id,
+                data: data.to_vec(),
+                req_id: None,
+            },
+        ) {
+            Poll::Ready(Ok(())) => Ok(data.len()),
+            Poll::Ready(Err(NetworkError::WouldBlock)) | Poll::Pending => {
+                self.send_available = 0;
+                Err(NetworkError::WouldBlock)
+            }
+            Poll::Ready(Err(err)) => Err(err),
+        }
+    }
+
+    fn try_flush(&mut self) -> Result<()> {
+        let mut cx = Context::from_waker(&self.tx_waker);
+        match self.common.tx.poll_send(
+            &mut cx,
+            MessageRequest::Socket {
+                socket: self.socket_id,
+                req: RequestType::Flush,
+                req_id: None,
+            },
+        ) {
+            Poll::Ready(Ok(())) => Ok(()),
+            Poll::Ready(Err(NetworkError::WouldBlock)) | Poll::Pending => {
+                self.send_available = 0;
+                Err(NetworkError::WouldBlock)
+            }
+            Poll::Ready(Err(err)) => Err(err),
+        }
+    }
+
+    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> Result<usize> {
+        loop {
+            if !self.rx_buffer.is_empty() {
+                let amt = self.rx_buffer.len().min(buf.len());
+                let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+                buf[..amt].copy_from_slice(&self.rx_buffer[..amt]);
+                self.rx_buffer.advance(amt);
+                return Ok(amt);
+            }
+            match self.rx_recv.try_recv() {
+                Ok(data) => self.rx_buffer.extend_from_slice(&data),
+                Err(TryRecvError::Disconnected) => return Err(NetworkError::ConnectionAborted),
+                Err(TryRecvError::Empty) => return Err(NetworkError::WouldBlock),
+            }
+        }
+    }
+
+    fn set_promiscuous(&mut self, promiscuous: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetPromiscuous(promiscuous))
+    }
+
+    fn promiscuous(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetPromiscuous)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get promiscuous request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+}
+
+impl VirtualConnectionlessSocket for RemoteSocket {
+    fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize> {
+        let req_id = self.common.request_seed.fetch_add(1, Ordering::SeqCst);
+        let mut cx = Context::from_waker(&self.tx_waker);
+        match self.common.tx.poll_send(
+            &mut cx,
+            MessageRequest::SendTo {
+                socket: self.socket_id,
+                data: data.to_vec(),
+                addr,
+                req_id: Some(req_id),
+            },
+        ) {
+            Poll::Ready(Ok(())) => Ok(data.len()),
+            Poll::Ready(Err(NetworkError::WouldBlock)) | Poll::Pending => {
+                self.send_available = 0;
+                Err(NetworkError::WouldBlock)
+            }
+            Poll::Ready(Err(err)) => Err(err),
+        }
+    }
+
+    fn try_recv_from(
+        &mut self,
+        buf: &mut [std::mem::MaybeUninit<u8>],
+    ) -> Result<(usize, SocketAddr)> {
+        match self.rx_recv_with_addr.try_recv() {
+            Ok(received) => {
+                let amt = buf.len().min(received.data.len());
+                let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+                buf[..amt].copy_from_slice(&received.data[..amt]);
+                Ok((amt, received.addr))
+            }
+            Err(TryRecvError::Disconnected) => Err(NetworkError::ConnectionAborted),
+            Err(TryRecvError::Empty) => Err(NetworkError::WouldBlock),
+        }
+    }
+}
+
+impl VirtualUdpSocket for RemoteSocket {
+    fn set_broadcast(&mut self, broadcast: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetBroadcast(broadcast))
+    }
+
+    fn broadcast(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetBroadcast)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get broadcast request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_multicast_loop_v4(&mut self, val: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetMulticastLoopV4(val))
+    }
+
+    fn multicast_loop_v4(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastLoopV4)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get multicast loop v4 request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_multicast_loop_v6(&mut self, val: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetMulticastLoopV6(val))
+    }
+
+    fn multicast_loop_v6(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastLoopV6)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get multicast loop v6 request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_multicast_ttl_v4(&mut self, ttl: u32) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetMulticastTtlV4(ttl))
+    }
+
+    fn multicast_ttl_v4(&self) -> Result<u32> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetMulticastTtlV4)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Ttl(ttl) => Ok(ttl),
+            res => {
+                tracing::debug!("invalid response to get multicast TTL v4 request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn join_multicast_v4(
+        &mut self,
+        multiaddr: std::net::Ipv4Addr,
+        iface: std::net::Ipv4Addr,
+    ) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::JoinMulticastV4 { multiaddr, iface })
+    }
+
+    fn leave_multicast_v4(
+        &mut self,
+        multiaddr: std::net::Ipv4Addr,
+        iface: std::net::Ipv4Addr,
+    ) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::LeaveMulticastV4 { multiaddr, iface })
+    }
+
+    fn join_multicast_v6(&mut self, multiaddr: std::net::Ipv6Addr, iface: u32) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::JoinMulticastV6 { multiaddr, iface })
+    }
+
+    fn leave_multicast_v6(&mut self, multiaddr: std::net::Ipv6Addr, iface: u32) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::LeaveMulticastV6 { multiaddr, iface })
+    }
+
+    fn addr_peer(&self) -> Result<Option<SocketAddr>> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrPeer)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(None),
+            ResponseType::SocketAddr(addr) => Ok(Some(addr)),
+            res => {
+                tracing::debug!("invalid response to addr peer request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+}
+
+impl VirtualIcmpSocket for RemoteSocket {}
+
+impl VirtualConnectedSocket for RemoteSocket {
+    fn set_linger(&mut self, linger: Option<Duration>) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetLinger(linger))
+    }
+
+    fn linger(&self) -> Result<Option<Duration>> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetLinger)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::None => Ok(None),
+            ResponseType::Duration(val) => Ok(Some(val)),
+            res => {
+                tracing::debug!("invalid response to get linger request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn try_send(&mut self, data: &[u8]) -> Result<usize> {
+        let req_id = self.common.request_seed.fetch_add(1, Ordering::SeqCst);
+        let mut cx = Context::from_waker(&self.tx_waker);
+        match self.common.tx.poll_send(
+            &mut cx,
+            MessageRequest::Send {
+                socket: self.socket_id,
+                data: data.to_vec(),
+                req_id: Some(req_id),
+            },
+        ) {
+            Poll::Ready(Ok(())) => Ok(data.len()),
+            Poll::Ready(Err(err)) => Err(err),
+            Poll::Pending => Err(NetworkError::WouldBlock),
+        }
+    }
+
+    fn try_flush(&mut self) -> Result<()> {
+        let mut cx = Context::from_waker(&self.tx_waker);
+        match self.common.tx.poll_send(
+            &mut cx,
+            MessageRequest::Socket {
+                socket: self.socket_id,
+                req: RequestType::Flush,
+                req_id: None,
+            },
+        ) {
+            Poll::Ready(Ok(())) => Ok(()),
+            Poll::Ready(Err(err)) => Err(err),
+            Poll::Pending => Err(NetworkError::WouldBlock),
+        }
+    }
+
+    fn close(&mut self) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::Close)
+    }
+
+    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> Result<usize> {
+        loop {
+            if !self.rx_buffer.is_empty() {
+                let amt = self.rx_buffer.len().min(buf.len());
+                let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+                buf[..amt].copy_from_slice(&self.rx_buffer[..amt]);
+                self.rx_buffer.advance(amt);
+                return Ok(amt);
+            }
+            match self.rx_recv.try_recv() {
+                Ok(data) => self.rx_buffer.extend_from_slice(&data),
+                Err(TryRecvError::Disconnected) => return Err(NetworkError::ConnectionAborted),
+                Err(TryRecvError::Empty) => return Err(NetworkError::WouldBlock),
+            }
+        }
+    }
+}
+
+impl VirtualTcpSocket for RemoteSocket {
+    fn set_recv_buf_size(&mut self, size: usize) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetRecvBufSize(size as u64))
+    }
+
+    fn recv_buf_size(&self) -> Result<usize> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetRecvBufSize)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Amount(amt) => Ok(amt.try_into().map_err(|_| NetworkError::IOError)?),
+            res => {
+                tracing::debug!("invalid response to get recv buf size request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_send_buf_size(&mut self, size: usize) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetSendBufSize(size as u64))
+    }
+
+    fn send_buf_size(&self) -> Result<usize> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetSendBufSize)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Amount(val) => Ok(val.try_into().map_err(|_| NetworkError::IOError)?),
+            res => {
+                tracing::debug!("invalid response to get send buf size request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_nodelay(&mut self, reuse: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetNoDelay(reuse))
+    }
+
+    fn nodelay(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetNoDelay)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get nodelay request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_keepalive(&mut self, keep_alive: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetKeepAlive(keep_alive))
+    }
+
+    fn keepalive(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetKeepAlive)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get nodelay request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn set_dontroute(&mut self, dont_route: bool) -> Result<()> {
+        self.io_socket_fire_and_forget(RequestType::SetDontRoute(dont_route))
+    }
+
+    fn dontroute(&self) -> Result<bool> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetDontRoute)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::Flag(val) => Ok(val),
+            res => {
+                tracing::debug!("invalid response to get nodelay request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn addr_peer(&self) -> Result<SocketAddr> {
+        match InlineWaker::block_on(self.io_socket(RequestType::GetAddrPeer)) {
+            ResponseType::Err(err) => Err(err),
+            ResponseType::SocketAddr(addr) => Ok(addr),
+            res => {
+                tracing::debug!("invalid response to addr peer request - {res:?}");
+                Err(NetworkError::IOError)
+            }
+        }
+    }
+
+    fn shutdown(&mut self, how: std::net::Shutdown) -> Result<()> {
+        let shutdown = match how {
+            std::net::Shutdown::Read => meta::Shutdown::Read,
+            std::net::Shutdown::Write => meta::Shutdown::Write,
+            std::net::Shutdown::Both => meta::Shutdown::Both,
+        };
+        self.io_socket_fire_and_forget(RequestType::Shutdown(shutdown))
+    }
+
+    fn is_closed(&self) -> bool {
+        match InlineWaker::block_on(self.io_socket(RequestType::IsClosed)) {
+            ResponseType::Flag(val) => val,
+            _ => false,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/composite.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/composite.rs
new file mode 100644
index 0000000..6901bca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/composite.rs
@@ -0,0 +1,121 @@
+use std::net::SocketAddr;
+use std::task::{Context, Poll};
+
+use crate::{Ipv4Addr, Ipv6Addr, NetworkError, VirtualIoSource, VirtualTcpListener};
+use derivative::Derivative;
+use virtual_mio::ArcInterestHandler;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct CompositeTcpListener {
+    #[derivative(Debug = "ignore")]
+    ports: Vec<Box<dyn VirtualTcpListener + Sync>>,
+}
+
+impl CompositeTcpListener {
+    pub fn new() -> Self {
+        Self { ports: Vec::new() }
+    }
+
+    pub fn add_port(&mut self, port: Box<dyn VirtualTcpListener + Sync>) {
+        self.ports.push(port);
+    }
+}
+
+impl Default for CompositeTcpListener {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl VirtualIoSource for CompositeTcpListener {
+    fn remove_handler(&mut self) {
+        for port in self.ports.iter_mut() {
+            port.remove_handler();
+        }
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        for port in self.ports.iter_mut() {
+            if let Poll::Ready(ready) = port.poll_read_ready(cx) {
+                return Poll::Ready(ready);
+            }
+        }
+        Poll::Pending
+    }
+
+    fn poll_write_ready(
+        &mut self,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<crate::Result<usize>> {
+        for port in self.ports.iter_mut() {
+            if let Poll::Ready(ready) = port.poll_write_ready(cx) {
+                return Poll::Ready(ready);
+            }
+        }
+        Poll::Pending
+    }
+}
+
+impl VirtualTcpListener for CompositeTcpListener {
+    fn try_accept(
+        &mut self,
+    ) -> crate::Result<(Box<dyn crate::VirtualTcpSocket + Sync>, SocketAddr)> {
+        let mut ret = NetworkError::Unsupported;
+        for port in self.ports.iter_mut() {
+            match port.try_accept() {
+                Ok(ret) => return Ok(ret),
+                Err(err) => {
+                    ret = err;
+                }
+            }
+        }
+        Err(ret)
+    }
+
+    fn set_handler(
+        &mut self,
+        handler: Box<dyn crate::InterestHandler + Send + Sync>,
+    ) -> crate::Result<()> {
+        let handler = ArcInterestHandler::new(handler);
+        for port in self.ports.iter_mut() {
+            port.set_handler(Box::new(handler.clone()))?;
+        }
+        Ok(())
+    }
+
+    fn addr_local(&self) -> crate::Result<SocketAddr> {
+        if self.ports.len() > 1 {
+            let addr = self.ports.first().unwrap().addr_local()?;
+            if addr.is_ipv4() {
+                Ok(SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), addr.port()))
+            } else {
+                Ok(SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), addr.port()))
+            }
+        } else if let Some(addr) = self.ports.first() {
+            addr.addr_local()
+        } else {
+            Err(NetworkError::Unsupported)
+        }
+    }
+
+    fn set_ttl(&mut self, ttl: u8) -> crate::Result<()> {
+        for port in self.ports.iter_mut() {
+            match port.set_ttl(ttl) {
+                Ok(()) | Err(NetworkError::Unsupported) => {}
+                Err(err) => return Err(err),
+            }
+        }
+        Ok(())
+    }
+
+    fn ttl(&self) -> crate::Result<u8> {
+        let mut ret = u8::MAX;
+        for port in self.ports.iter() {
+            if let Ok(ttl) = port.ttl() {
+                ret = ret.min(ttl)
+            }
+        }
+        Ok(ret)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/host.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/host.rs
new file mode 100644
index 0000000..0d14a1e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/host.rs
@@ -0,0 +1,891 @@
+#![allow(unused_variables)]
+use crate::{io_err_into_net_error, VirtualIoSource};
+#[allow(unused_imports)]
+use crate::{
+    IpCidr, IpRoute, NetworkError, Result, SocketStatus, StreamSecurity, VirtualConnectedSocket,
+    VirtualConnectionlessSocket, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket,
+    VirtualSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+};
+use bytes::{Buf, BytesMut};
+use derivative::Derivative;
+use std::collections::VecDeque;
+use std::io::{self, Read, Write};
+use std::mem::MaybeUninit;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr};
+#[cfg(not(target_os = "windows"))]
+use std::os::fd::AsRawFd;
+#[cfg(not(target_os = "windows"))]
+use std::os::fd::RawFd;
+use std::sync::Arc;
+use std::task::Poll;
+use std::time::Duration;
+use tokio::runtime::Handle;
+#[allow(unused_imports, dead_code)]
+use tracing::{debug, error, info, trace, warn};
+use virtual_mio::{
+    state_as_waker_map, HandlerGuardState, InterestGuard, InterestHandler, InterestType, Selector,
+};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct LocalNetworking {
+    selector: Arc<Selector>,
+    handle: Handle,
+}
+
+impl LocalNetworking {
+    pub fn new() -> Self {
+        Self {
+            selector: Selector::new(),
+            handle: Handle::current(),
+        }
+    }
+}
+
+impl Drop for LocalNetworking {
+    fn drop(&mut self) {
+        self.selector.shutdown();
+    }
+}
+
+impl Default for LocalNetworking {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait::async_trait]
+#[allow(unused_variables)]
+impl VirtualNetworking for LocalNetworking {
+    async fn listen_tcp(
+        &self,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualTcpListener + Sync>> {
+        let listener = std::net::TcpListener::bind(addr)
+            .map(|sock| {
+                sock.set_nonblocking(true).ok();
+                Box::new(LocalTcpListener {
+                    stream: mio::net::TcpListener::from_std(sock),
+                    selector: self.selector.clone(),
+                    handler_guard: HandlerGuardState::None,
+                    no_delay: None,
+                    keep_alive: None,
+                    backlog: Default::default(),
+                })
+            })
+            .map_err(io_err_into_net_error)?;
+        Ok(listener)
+    }
+
+    async fn bind_udp(
+        &self,
+        addr: SocketAddr,
+        _reuse_port: bool,
+        _reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualUdpSocket + Sync>> {
+        let socket = mio::net::UdpSocket::bind(addr).map_err(io_err_into_net_error)?;
+        socket2::SockRef::from(&socket).set_nonblocking(true).ok();
+
+        #[allow(unused_mut)]
+        let mut ret = LocalUdpSocket {
+            selector: self.selector.clone(),
+            socket,
+            addr,
+            handler_guard: HandlerGuardState::None,
+            backlog: Default::default(),
+        };
+
+        // In windows we can not poll the socket as it is not supported and hence
+        // what we do is immediately set the writable flag and relay on `mio` to
+        // refresh that flag when the state changes. In Linux what we do is actually
+        // make a non-blocking `poll` call to determine this state
+        #[cfg(target_os = "windows")]
+        {
+            let (state, selector, socket) = ret.split_borrow();
+            let map = state_as_waker_map(state, selector, socket).map_err(io_err_into_net_error)?;
+            map.push(InterestType::Writable);
+        }
+
+        Ok(Box::new(ret))
+    }
+
+    async fn connect_tcp(
+        &self,
+        _addr: SocketAddr,
+        mut peer: SocketAddr,
+    ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
+        let stream = mio::net::TcpStream::connect(peer).map_err(io_err_into_net_error)?;
+        socket2::SockRef::from(&stream).set_nonblocking(true).ok();
+        if let Ok(p) = stream.peer_addr() {
+            peer = p;
+        }
+        let socket = Box::new(LocalTcpStream::new(self.selector.clone(), stream, peer));
+        Ok(socket)
+    }
+
+    async fn resolve(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    ) -> Result<Vec<IpAddr>> {
+        let host_to_lookup = if host.contains(':') {
+            host.to_string()
+        } else {
+            format!("{}:{}", host, port.unwrap_or(0))
+        };
+        self.handle
+            .spawn(tokio::net::lookup_host(host_to_lookup))
+            .await
+            .map_err(|_| NetworkError::IOError)?
+            .map(|a| a.map(|a| a.ip()).collect::<Vec<_>>())
+            .map_err(io_err_into_net_error)
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct LocalTcpListener {
+    stream: mio::net::TcpListener,
+    selector: Arc<Selector>,
+    handler_guard: HandlerGuardState,
+    no_delay: Option<bool>,
+    keep_alive: Option<bool>,
+    backlog: VecDeque<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)>,
+}
+
+impl LocalTcpListener {
+    fn try_accept_internal(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)> {
+        match self.stream.accept().map_err(io_err_into_net_error) {
+            Ok((stream, addr)) => {
+                socket2::SockRef::from(&self.stream)
+                    .set_nonblocking(true)
+                    .ok();
+                let mut socket = LocalTcpStream::new(self.selector.clone(), stream, addr);
+                if let Some(no_delay) = self.no_delay {
+                    socket.set_nodelay(no_delay).ok();
+                }
+                if let Some(keep_alive) = self.keep_alive {
+                    socket.set_keepalive(keep_alive).ok();
+                }
+                Ok((Box::new(socket), addr))
+            }
+            Err(NetworkError::WouldBlock) => {
+                if let HandlerGuardState::WakerMap(_, map) = &mut self.handler_guard {
+                    map.pop(InterestType::Readable);
+                    map.pop(InterestType::Writable);
+                }
+                Err(NetworkError::WouldBlock)
+            }
+            Err(err) => Err(err),
+        }
+    }
+}
+
+impl VirtualTcpListener for LocalTcpListener {
+    fn try_accept(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)> {
+        if let Some(child) = self.backlog.pop_front() {
+            return Ok(child);
+        }
+        self.try_accept_internal()
+    }
+
+    fn set_handler(&mut self, mut handler: Box<dyn InterestHandler + Send + Sync>) -> Result<()> {
+        if let HandlerGuardState::ExternalHandler(guard) = &mut self.handler_guard {
+            match guard.replace_handler(handler) {
+                Ok(()) => return Ok(()),
+                Err(h) => handler = h,
+            }
+
+            // the handler could not be replaced so we need to build a new handler instead
+            if let Err(err) = guard.unregister(&mut self.stream) {
+                tracing::debug!("failed to unregister previous token - {}", err);
+            }
+        }
+
+        let guard = InterestGuard::new(
+            &self.selector,
+            handler,
+            &mut self.stream,
+            mio::Interest::READABLE.add(mio::Interest::WRITABLE),
+        )
+        .map_err(io_err_into_net_error)?;
+
+        self.handler_guard = HandlerGuardState::ExternalHandler(guard);
+
+        Ok(())
+    }
+
+    fn addr_local(&self) -> Result<SocketAddr> {
+        self.stream.local_addr().map_err(io_err_into_net_error)
+    }
+
+    fn set_ttl(&mut self, ttl: u8) -> Result<()> {
+        self.stream
+            .set_ttl(ttl as u32)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn ttl(&self) -> Result<u8> {
+        self.stream
+            .ttl()
+            .map(|ttl| ttl as u8)
+            .map_err(io_err_into_net_error)
+    }
+}
+
+impl LocalTcpListener {
+    fn split_borrow(
+        &mut self,
+    ) -> (
+        &mut HandlerGuardState,
+        &Arc<Selector>,
+        &mut mio::net::TcpListener,
+    ) {
+        (&mut self.handler_guard, &self.selector, &mut self.stream)
+    }
+}
+
+impl VirtualIoSource for LocalTcpListener {
+    fn remove_handler(&mut self) {
+        let mut guard = HandlerGuardState::None;
+        std::mem::swap(&mut guard, &mut self.handler_guard);
+        match guard {
+            HandlerGuardState::ExternalHandler(mut guard) => {
+                guard.unregister(&mut self.stream).ok();
+            }
+            HandlerGuardState::WakerMap(mut guard, _) => {
+                guard.unregister(&mut self.stream).ok();
+            }
+            HandlerGuardState::None => {}
+        }
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        if !self.backlog.is_empty() {
+            return Poll::Ready(Ok(self.backlog.len()));
+        }
+
+        let (state, selector, source) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, source).map_err(io_err_into_net_error)?;
+        map.add(InterestType::Readable, cx.waker());
+
+        if let Ok(child) = self.try_accept_internal() {
+            self.backlog.push_back(child);
+            return Poll::Ready(Ok(1));
+        }
+        Poll::Pending
+    }
+
+    fn poll_write_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        if !self.backlog.is_empty() {
+            return Poll::Ready(Ok(self.backlog.len()));
+        }
+
+        let (state, selector, source) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, source).map_err(io_err_into_net_error)?;
+        map.add(InterestType::Writable, cx.waker());
+
+        if let Ok(child) = self.try_accept_internal() {
+            self.backlog.push_back(child);
+            return Poll::Ready(Ok(1));
+        }
+        Poll::Pending
+    }
+}
+
+#[derive(Debug)]
+pub struct LocalTcpStream {
+    stream: mio::net::TcpStream,
+    addr: SocketAddr,
+    shutdown: Option<Shutdown>,
+    selector: Arc<Selector>,
+    handler_guard: HandlerGuardState,
+    buffer: BytesMut,
+}
+
+impl LocalTcpStream {
+    fn new(selector: Arc<Selector>, stream: mio::net::TcpStream, addr: SocketAddr) -> Self {
+        #[allow(unused_mut)]
+        let mut ret = Self {
+            stream,
+            addr,
+            shutdown: None,
+            selector,
+            handler_guard: HandlerGuardState::None,
+            buffer: BytesMut::new(),
+        };
+
+        // In windows we can not poll the socket as it is not supported and hence
+        // what we do is immediately set the writable flag and relay on `mio` to
+        // refresh that flag when the state changes. In Linux what we do is actually
+        // make a non-blocking `poll` call to determine this state
+        #[cfg(target_os = "windows")]
+        {
+            let (state, selector, socket, _) = ret.split_borrow();
+            if let Ok(map) = state_as_waker_map(state, selector, socket) {
+                map.push(InterestType::Writable);
+            }
+        }
+
+        ret
+    }
+}
+
+impl VirtualTcpSocket for LocalTcpStream {
+    fn set_recv_buf_size(&mut self, size: usize) -> Result<()> {
+        Ok(())
+    }
+
+    fn recv_buf_size(&self) -> Result<usize> {
+        Err(NetworkError::Unsupported)
+    }
+
+    fn set_send_buf_size(&mut self, size: usize) -> Result<()> {
+        Ok(())
+    }
+
+    fn send_buf_size(&self) -> Result<usize> {
+        Err(NetworkError::Unsupported)
+    }
+
+    fn set_nodelay(&mut self, nodelay: bool) -> Result<()> {
+        self.stream
+            .set_nodelay(nodelay)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn nodelay(&self) -> Result<bool> {
+        self.stream.nodelay().map_err(io_err_into_net_error)
+    }
+
+    fn set_keepalive(&mut self, keepalive: bool) -> Result<()> {
+        socket2::SockRef::from(&self.stream)
+            .set_keepalive(true)
+            .map_err(io_err_into_net_error)?;
+        Ok(())
+    }
+
+    fn keepalive(&self) -> Result<bool> {
+        let ret = socket2::SockRef::from(&self.stream)
+            .keepalive()
+            .map_err(io_err_into_net_error)?;
+        Ok(ret)
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn set_dontroute(&mut self, val: bool) -> Result<()> {
+        // TODO:
+        // Don't route is being set by WASIX which breaks networking
+        // Why this is being set is unknown but we need to disable
+        // the functionality for now as it breaks everything
+
+        let val = val as libc::c_int;
+        let payload = &val as *const libc::c_int as *const libc::c_void;
+        let err = unsafe {
+            libc::setsockopt(
+                self.stream.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_DONTROUTE,
+                payload,
+                std::mem::size_of::<libc::c_int>() as libc::socklen_t,
+            )
+        };
+        if err == -1 {
+            return Err(io_err_into_net_error(std::io::Error::last_os_error()));
+        }
+        Ok(())
+    }
+    #[cfg(target_os = "windows")]
+    fn set_dontroute(&mut self, val: bool) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    #[cfg(not(target_os = "windows"))]
+    fn dontroute(&self) -> Result<bool> {
+        let mut payload: MaybeUninit<libc::c_int> = MaybeUninit::uninit();
+        let mut len = std::mem::size_of::<libc::c_int>() as libc::socklen_t;
+        let err = unsafe {
+            libc::getsockopt(
+                self.stream.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_DONTROUTE,
+                payload.as_mut_ptr().cast(),
+                &mut len,
+            )
+        };
+        if err == -1 {
+            return Err(io_err_into_net_error(std::io::Error::last_os_error()));
+        }
+        Ok(unsafe { payload.assume_init() != 0 })
+    }
+    #[cfg(target_os = "windows")]
+    fn dontroute(&self) -> Result<bool> {
+        Err(NetworkError::Unsupported)
+    }
+
+    fn addr_peer(&self) -> Result<SocketAddr> {
+        Ok(self.addr)
+    }
+
+    fn shutdown(&mut self, how: Shutdown) -> Result<()> {
+        self.stream.shutdown(how).map_err(io_err_into_net_error)?;
+        self.shutdown = Some(how);
+        Ok(())
+    }
+
+    fn is_closed(&self) -> bool {
+        false
+    }
+}
+
+impl VirtualConnectedSocket for LocalTcpStream {
+    fn set_linger(&mut self, linger: Option<Duration>) -> Result<()> {
+        socket2::SockRef::from(&self.stream)
+            .set_linger(linger)
+            .map_err(io_err_into_net_error)?;
+        Ok(())
+    }
+
+    fn linger(&self) -> Result<Option<Duration>> {
+        socket2::SockRef::from(&self.stream)
+            .linger()
+            .map_err(io_err_into_net_error)
+    }
+
+    fn try_send(&mut self, data: &[u8]) -> Result<usize> {
+        let ret = self.stream.write(data).map_err(io_err_into_net_error);
+        match &ret {
+            Ok(0) | Err(NetworkError::WouldBlock) => {
+                if let HandlerGuardState::WakerMap(_, map) = &mut self.handler_guard {
+                    map.pop(InterestType::Writable);
+                }
+            }
+            _ => {}
+        }
+        ret
+    }
+
+    fn try_flush(&mut self) -> Result<()> {
+        self.stream.flush().map_err(io_err_into_net_error)
+    }
+
+    fn close(&mut self) -> Result<()> {
+        Ok(())
+    }
+
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize> {
+        let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+        if !self.buffer.is_empty() {
+            let amt = buf.len().min(self.buffer.len());
+            buf[..amt].copy_from_slice(&self.buffer[..amt]);
+            self.buffer.advance(amt);
+            return Ok(amt);
+        }
+
+        self.stream.read(buf).map_err(io_err_into_net_error)
+    }
+}
+
+impl VirtualSocket for LocalTcpStream {
+    fn set_ttl(&mut self, ttl: u32) -> Result<()> {
+        self.stream.set_ttl(ttl).map_err(io_err_into_net_error)
+    }
+
+    fn ttl(&self) -> Result<u32> {
+        self.stream.ttl().map_err(io_err_into_net_error)
+    }
+
+    fn addr_local(&self) -> Result<SocketAddr> {
+        self.stream.local_addr().map_err(io_err_into_net_error)
+    }
+
+    fn status(&self) -> Result<SocketStatus> {
+        Ok(SocketStatus::Opened)
+    }
+
+    fn set_handler(&mut self, mut handler: Box<dyn InterestHandler + Send + Sync>) -> Result<()> {
+        if let HandlerGuardState::ExternalHandler(guard) = &mut self.handler_guard {
+            match guard.replace_handler(handler) {
+                Ok(()) => return Ok(()),
+                Err(h) => handler = h,
+            }
+
+            // the handler could not be replaced so we need to build a new handler instead
+            if let Err(err) = guard.unregister(&mut self.stream) {
+                tracing::debug!("failed to unregister previous token - {}", err);
+            }
+        }
+
+        let guard = InterestGuard::new(
+            &self.selector,
+            handler,
+            &mut self.stream,
+            mio::Interest::READABLE.add(mio::Interest::WRITABLE),
+        )
+        .map_err(io_err_into_net_error)?;
+
+        self.handler_guard = HandlerGuardState::ExternalHandler(guard);
+
+        Ok(())
+    }
+}
+
+impl LocalTcpStream {
+    fn split_borrow(
+        &mut self,
+    ) -> (
+        &mut HandlerGuardState,
+        &Arc<Selector>,
+        &mut mio::net::TcpStream,
+        &mut BytesMut,
+    ) {
+        (
+            &mut self.handler_guard,
+            &self.selector,
+            &mut self.stream,
+            &mut self.buffer,
+        )
+    }
+}
+
+impl VirtualIoSource for LocalTcpStream {
+    fn remove_handler(&mut self) {
+        let mut guard = HandlerGuardState::None;
+        std::mem::swap(&mut guard, &mut self.handler_guard);
+        match guard {
+            HandlerGuardState::ExternalHandler(mut guard) => {
+                guard.unregister(&mut self.stream).ok();
+            }
+            HandlerGuardState::WakerMap(mut guard, _) => {
+                guard.unregister(&mut self.stream).ok();
+            }
+            HandlerGuardState::None => {}
+        }
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        if !self.buffer.is_empty() {
+            return Poll::Ready(Ok(self.buffer.len()));
+        }
+
+        let (state, selector, stream, buffer) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, stream).map_err(io_err_into_net_error)?;
+        map.pop(InterestType::Readable);
+        map.add(InterestType::Readable, cx.waker());
+
+        buffer.reserve(buffer.len() + 10240);
+        let uninit: &mut [MaybeUninit<u8>] = buffer.spare_capacity_mut();
+        let uninit_unsafe: &mut [u8] = unsafe { std::mem::transmute(uninit) };
+
+        match stream.read(uninit_unsafe) {
+            Ok(0) => Poll::Ready(Ok(0)),
+            Ok(amt) => {
+                unsafe {
+                    buffer.set_len(buffer.len() + amt);
+                }
+                Poll::Ready(Ok(amt))
+            }
+            Err(err) if err.kind() == io::ErrorKind::ConnectionAborted => Poll::Ready(Ok(0)),
+            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => Poll::Ready(Ok(0)),
+            Err(err) if err.kind() == io::ErrorKind::WouldBlock => Poll::Pending,
+            Err(err) => Poll::Ready(Err(io_err_into_net_error(err))),
+        }
+    }
+
+    fn poll_write_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        let (state, selector, stream, _) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, stream).map_err(io_err_into_net_error)?;
+        #[cfg(not(target_os = "windows"))]
+        map.pop(InterestType::Writable);
+        map.add(InterestType::Writable, cx.waker());
+        map.add(InterestType::Closed, cx.waker());
+        if map.has_interest(InterestType::Closed) {
+            return Poll::Ready(Ok(0));
+        }
+
+        #[cfg(not(target_os = "windows"))]
+        match libc_poll(stream.as_raw_fd(), libc::POLLOUT | libc::POLLHUP) {
+            Some(val) if (val & libc::POLLHUP) != 0 => {
+                return Poll::Ready(Ok(0));
+            }
+            Some(val) if (val & libc::POLLOUT) != 0 => return Poll::Ready(Ok(10240)),
+            _ => {}
+        }
+
+        // In windows we can not poll the socket as it is not supported and hence
+        // what we do is immediately set the writable flag and relay on `mio` to
+        // refresh that flag when the state changes. In Linux what we do is actually
+        // make a non-blocking `poll` call to determine this state
+        #[cfg(target_os = "windows")]
+        if map.has_interest(InterestType::Writable) {
+            return Poll::Ready(Ok(10240));
+        }
+
+        Poll::Pending
+    }
+}
+
+#[cfg(not(target_os = "windows"))]
+fn libc_poll(fd: RawFd, events: libc::c_short) -> Option<libc::c_short> {
+    let mut fds: [libc::pollfd; 1] = [libc::pollfd {
+        fd,
+        events,
+        revents: 0,
+    }];
+    let fds_mut = &mut fds[..];
+    let ret = unsafe { libc::poll(fds_mut.as_mut_ptr(), 1, 0) };
+    match ret == 1 {
+        true => Some(fds[0].revents),
+        false => None,
+    }
+}
+
+#[derive(Debug)]
+pub struct LocalUdpSocket {
+    socket: mio::net::UdpSocket,
+    #[allow(dead_code)]
+    addr: SocketAddr,
+    selector: Arc<Selector>,
+    handler_guard: HandlerGuardState,
+    backlog: VecDeque<(BytesMut, SocketAddr)>,
+}
+
+impl VirtualUdpSocket for LocalUdpSocket {
+    fn set_broadcast(&mut self, broadcast: bool) -> Result<()> {
+        self.socket
+            .set_broadcast(broadcast)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn broadcast(&self) -> Result<bool> {
+        self.socket.broadcast().map_err(io_err_into_net_error)
+    }
+
+    fn set_multicast_loop_v4(&mut self, val: bool) -> Result<()> {
+        self.socket
+            .set_multicast_loop_v4(val)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn multicast_loop_v4(&self) -> Result<bool> {
+        self.socket
+            .multicast_loop_v4()
+            .map_err(io_err_into_net_error)
+    }
+
+    fn set_multicast_loop_v6(&mut self, val: bool) -> Result<()> {
+        self.socket
+            .set_multicast_loop_v6(val)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn multicast_loop_v6(&self) -> Result<bool> {
+        self.socket
+            .multicast_loop_v6()
+            .map_err(io_err_into_net_error)
+    }
+
+    fn set_multicast_ttl_v4(&mut self, ttl: u32) -> Result<()> {
+        self.socket
+            .set_multicast_ttl_v4(ttl)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn multicast_ttl_v4(&self) -> Result<u32> {
+        self.socket
+            .multicast_ttl_v4()
+            .map_err(io_err_into_net_error)
+    }
+
+    fn join_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()> {
+        socket2::SockRef::from(&self.socket)
+            .join_multicast_v4(&multiaddr, &iface)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn leave_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()> {
+        socket2::SockRef::from(&self.socket)
+            .leave_multicast_v4(&multiaddr, &iface)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn join_multicast_v6(&mut self, multiaddr: Ipv6Addr, iface: u32) -> Result<()> {
+        self.socket
+            .join_multicast_v6(&multiaddr, iface)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn leave_multicast_v6(&mut self, multiaddr: Ipv6Addr, iface: u32) -> Result<()> {
+        self.socket
+            .leave_multicast_v6(&multiaddr, iface)
+            .map_err(io_err_into_net_error)
+    }
+
+    fn addr_peer(&self) -> Result<Option<SocketAddr>> {
+        self.socket
+            .peer_addr()
+            .map(Some)
+            .map_err(io_err_into_net_error)
+    }
+}
+
+impl VirtualConnectionlessSocket for LocalUdpSocket {
+    fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize> {
+        let ret = self
+            .socket
+            .send_to(data, addr)
+            .map_err(io_err_into_net_error);
+        match &ret {
+            Ok(0) | Err(NetworkError::WouldBlock) => {
+                if let HandlerGuardState::WakerMap(_, map) = &mut self.handler_guard {
+                    map.pop(InterestType::Writable);
+                }
+            }
+            _ => {}
+        }
+        ret
+    }
+
+    fn try_recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)> {
+        let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+        self.socket.recv_from(buf).map_err(io_err_into_net_error)
+    }
+}
+
+impl VirtualSocket for LocalUdpSocket {
+    fn set_ttl(&mut self, ttl: u32) -> Result<()> {
+        self.socket.set_ttl(ttl).map_err(io_err_into_net_error)
+    }
+
+    fn ttl(&self) -> Result<u32> {
+        self.socket.ttl().map_err(io_err_into_net_error)
+    }
+
+    fn addr_local(&self) -> Result<SocketAddr> {
+        self.socket.local_addr().map_err(io_err_into_net_error)
+    }
+
+    fn status(&self) -> Result<SocketStatus> {
+        Ok(SocketStatus::Opened)
+    }
+
+    fn set_handler(&mut self, mut handler: Box<dyn InterestHandler + Send + Sync>) -> Result<()> {
+        if let HandlerGuardState::ExternalHandler(guard) = &mut self.handler_guard {
+            match guard.replace_handler(handler) {
+                Ok(()) => {
+                    return Ok(());
+                }
+                Err(h) => handler = h,
+            }
+
+            // the handler could not be replaced so we need to build a new handler instead
+            if let Err(err) = guard.unregister(&mut self.socket) {
+                tracing::debug!("failed to unregister previous token - {}", err);
+            }
+        }
+
+        let guard = InterestGuard::new(
+            &self.selector,
+            handler,
+            &mut self.socket,
+            mio::Interest::READABLE.add(mio::Interest::WRITABLE),
+        )
+        .map_err(io_err_into_net_error)?;
+
+        self.handler_guard = HandlerGuardState::ExternalHandler(guard);
+
+        Ok(())
+    }
+}
+
+impl LocalUdpSocket {
+    fn split_borrow(
+        &mut self,
+    ) -> (
+        &mut HandlerGuardState,
+        &Arc<Selector>,
+        &mut mio::net::UdpSocket,
+    ) {
+        (&mut self.handler_guard, &self.selector, &mut self.socket)
+    }
+}
+
+impl VirtualIoSource for LocalUdpSocket {
+    fn remove_handler(&mut self) {
+        let mut guard = HandlerGuardState::None;
+        std::mem::swap(&mut guard, &mut self.handler_guard);
+        match guard {
+            HandlerGuardState::ExternalHandler(mut guard) => {
+                guard.unregister(&mut self.socket).ok();
+            }
+            HandlerGuardState::WakerMap(mut guard, _) => {
+                guard.unregister(&mut self.socket).ok();
+            }
+            HandlerGuardState::None => {}
+        }
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        if !self.backlog.is_empty() {
+            let total = self.backlog.iter().map(|a| a.0.len()).sum();
+            return Poll::Ready(Ok(total));
+        }
+
+        let (state, selector, socket) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, socket).map_err(io_err_into_net_error)?;
+        map.pop(InterestType::Readable);
+        map.add(InterestType::Readable, cx.waker());
+
+        let mut buffer = BytesMut::default();
+        buffer.reserve(10240);
+        let uninit: &mut [MaybeUninit<u8>] = buffer.spare_capacity_mut();
+        let uninit_unsafe: &mut [u8] = unsafe { std::mem::transmute(uninit) };
+
+        match self.socket.recv_from(uninit_unsafe) {
+            Ok((0, _)) => Poll::Ready(Ok(0)),
+            Ok((amt, peer)) => {
+                unsafe {
+                    buffer.set_len(amt);
+                }
+                self.backlog.push_back((buffer, peer));
+                Poll::Ready(Ok(amt))
+            }
+            Err(err) if err.kind() == io::ErrorKind::ConnectionAborted => Poll::Ready(Ok(0)),
+            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => Poll::Ready(Ok(0)),
+            Err(err) if err.kind() == io::ErrorKind::WouldBlock => Poll::Pending,
+            Err(err) => Poll::Ready(Err(io_err_into_net_error(err))),
+        }
+    }
+
+    fn poll_write_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<usize>> {
+        let (state, selector, socket) = self.split_borrow();
+        let map = state_as_waker_map(state, selector, socket).map_err(io_err_into_net_error)?;
+        #[cfg(not(target_os = "windows"))]
+        map.pop(InterestType::Writable);
+        map.add(InterestType::Writable, cx.waker());
+
+        #[cfg(not(target_os = "windows"))]
+        match libc_poll(socket.as_raw_fd(), libc::POLLOUT | libc::POLLHUP) {
+            Some(val) if (val & libc::POLLHUP) != 0 => {
+                return Poll::Ready(Ok(0));
+            }
+            Some(val) if (val & libc::POLLOUT) != 0 => return Poll::Ready(Ok(10240)),
+            _ => {}
+        }
+
+        // In windows we can not poll the socket as it is not supported and hence
+        // what we do is immediately set the writable flag and relay on `mio` to
+        // refresh that flag when the state changes. In Linux what we do is actually
+        // make a non-blocking `poll` call to determine this state
+        #[cfg(target_os = "windows")]
+        if map.has_interest(InterestType::Writable) {
+            return Poll::Ready(Ok(10240));
+        }
+
+        Poll::Pending
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/lib.rs
new file mode 100644
index 0000000..782d841
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/lib.rs
@@ -0,0 +1,921 @@
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+#[cfg(feature = "remote")]
+pub mod client;
+pub mod composite;
+#[cfg(feature = "host-net")]
+pub mod host;
+pub mod loopback;
+pub mod meta;
+#[cfg(feature = "remote")]
+pub mod rx_tx;
+#[cfg(feature = "remote")]
+pub mod server;
+pub mod tcp_pair;
+#[cfg(feature = "tokio")]
+#[cfg(test)]
+mod tests;
+
+#[cfg(feature = "remote")]
+pub use client::{RemoteNetworkingClient, RemoteNetworkingClientDriver};
+pub use composite::CompositeTcpListener;
+pub use loopback::LoopbackNetworking;
+use pin_project_lite::pin_project;
+#[cfg(feature = "rkyv")]
+use rkyv::{Archive, CheckBytes, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
+#[cfg(feature = "remote")]
+pub use server::{RemoteNetworkingServer, RemoteNetworkingServerDriver};
+use std::fmt;
+use std::mem::MaybeUninit;
+use std::net::IpAddr;
+use std::net::Ipv4Addr;
+use std::net::Ipv6Addr;
+use std::net::Shutdown;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Context;
+use std::task::Poll;
+use std::time::Duration;
+use thiserror::Error;
+#[cfg(feature = "tokio")]
+use tokio::io::AsyncRead;
+#[cfg(feature = "tokio")]
+use tokio::io::AsyncWrite;
+
+pub use bytes::Bytes;
+pub use bytes::BytesMut;
+use serde::{Deserialize, Serialize};
+pub use virtual_mio::{handler_into_waker, InterestHandler};
+#[cfg(feature = "host-net")]
+pub use virtual_mio::{InterestGuard, InterestHandlerWaker, InterestType};
+
+pub type Result<T> = std::result::Result<T, NetworkError>;
+
+/// Represents an IP address and its netmask
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv", derive(RkyvSerialize, RkyvDeserialize, Archive))]
+#[cfg_attr(feature = "rkyv", archive_attr(derive(CheckBytes)))]
+pub struct IpCidr {
+    pub ip: IpAddr,
+    pub prefix: u8,
+}
+
+/// Represents a routing entry in the routing table of the interface
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[cfg_attr(feature = "rkyv", derive(RkyvSerialize, RkyvDeserialize, Archive))]
+#[cfg_attr(feature = "rkyv", archive_attr(derive(CheckBytes)))]
+pub struct IpRoute {
+    pub cidr: IpCidr,
+    pub via_router: IpAddr,
+    pub preferred_until: Option<Duration>,
+    pub expires_at: Option<Duration>,
+}
+
+/// Represents an IO source
+pub trait VirtualIoSource: fmt::Debug + Send + Sync + 'static {
+    /// Removes a previously registered waker using a token
+    fn remove_handler(&mut self);
+
+    /// Polls the source to see if there is data waiting
+    fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>>;
+
+    /// Polls the source to see if data can be sent
+    fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<usize>>;
+}
+
+/// An implementation of virtual networking
+#[async_trait::async_trait]
+#[allow(unused_variables)]
+pub trait VirtualNetworking: fmt::Debug + Send + Sync + 'static {
+    /// Bridges this local network with a remote network, which is required in
+    /// order to make lower level networking calls (such as UDP/TCP)
+    async fn bridge(
+        &self,
+        network: &str,
+        access_token: &str,
+        security: StreamSecurity,
+    ) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Disconnects from the remote network essentially unbridging it
+    async fn unbridge(&self) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Acquires an IP address on the network and configures the routing tables
+    async fn dhcp_acquire(&self) -> Result<Vec<IpAddr>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Adds a static IP address to the interface with a netmask prefix
+    async fn ip_add(&self, ip: IpAddr, prefix: u8) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Removes a static (or dynamic) IP address from the interface
+    async fn ip_remove(&self, ip: IpAddr) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Clears all the assigned IP addresses for this interface
+    async fn ip_clear(&self) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Lists all the IP addresses currently assigned to this interface
+    async fn ip_list(&self) -> Result<Vec<IpCidr>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Returns the hardware MAC address for this interface
+    async fn mac(&self) -> Result<[u8; 6]> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Adds a default gateway to the routing table
+    async fn gateway_set(&self, ip: IpAddr) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Adds a specific route to the routing table
+    async fn route_add(
+        &self,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Removes a routing rule from the routing table
+    async fn route_remove(&self, cidr: IpAddr) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Clears the routing table for this interface
+    async fn route_clear(&self) -> Result<()> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Lists all the routes defined in the routing table for this interface
+    async fn route_list(&self) -> Result<Vec<IpRoute>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Creates a low level socket that can read and write Ethernet packets
+    /// directly to the interface
+    async fn bind_raw(&self) -> Result<Box<dyn VirtualRawSocket + Sync>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Lists for TCP connections on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    async fn listen_tcp(
+        &self,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualTcpListener + Sync>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Opens a UDP socket that listens on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    async fn bind_udp(
+        &self,
+        addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualUdpSocket + Sync>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Creates a socket that can be used to send and receive ICMP packets
+    /// from a paritcular IP address
+    async fn bind_icmp(&self, addr: IpAddr) -> Result<Box<dyn VirtualIcmpSocket + Sync>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Opens a TCP connection to a particular destination IP address and port
+    async fn connect_tcp(
+        &self,
+        addr: SocketAddr,
+        peer: SocketAddr,
+    ) -> Result<Box<dyn VirtualTcpSocket + Sync>> {
+        Err(NetworkError::Unsupported)
+    }
+
+    /// Performs DNS resolution for a specific hostname
+    async fn resolve(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    ) -> Result<Vec<IpAddr>> {
+        Err(NetworkError::Unsupported)
+    }
+}
+
+pub type DynVirtualNetworking = Arc<dyn VirtualNetworking>;
+
+pub trait VirtualTcpListener: VirtualIoSource + fmt::Debug + Send + Sync + 'static {
+    /// Tries to accept a new connection
+    fn try_accept(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)>;
+
+    /// Registers a waker for when a new connection has arrived. This uses
+    /// a stack machine which means more than one waker can be registered
+    fn set_handler(&mut self, handler: Box<dyn InterestHandler + Send + Sync>) -> Result<()>;
+
+    /// Returns the local address of this TCP listener
+    fn addr_local(&self) -> Result<SocketAddr>;
+
+    /// Sets how many network hops the packets are permitted for new connections
+    fn set_ttl(&mut self, ttl: u8) -> Result<()>;
+
+    /// Returns the maximum number of network hops before packets are dropped
+    fn ttl(&self) -> Result<u8>;
+}
+
+#[async_trait::async_trait]
+pub trait VirtualTcpListenerExt: VirtualTcpListener {
+    /// Accepts a new connection from the TCP listener
+    async fn accept(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)>;
+}
+
+#[async_trait::async_trait]
+impl<R: VirtualTcpListener + ?Sized> VirtualTcpListenerExt for R {
+    async fn accept(&mut self) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)> {
+        struct Poller<'a, R>
+        where
+            R: VirtualTcpListener + ?Sized,
+        {
+            listener: &'a mut R,
+        }
+        impl<'a, R> std::future::Future for Poller<'a, R>
+        where
+            R: VirtualTcpListener + ?Sized,
+        {
+            type Output = Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr)>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = self.listener.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match self.listener.try_accept() {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller { listener: self }.await
+    }
+}
+
+pub trait VirtualSocket: VirtualIoSource + fmt::Debug + Send + Sync + 'static {
+    /// Sets how many network hops the packets are permitted for new connections
+    fn set_ttl(&mut self, ttl: u32) -> Result<()>;
+
+    /// Returns the maximum number of network hops before packets are dropped
+    fn ttl(&self) -> Result<u32>;
+
+    /// Returns the local address for this socket
+    fn addr_local(&self) -> Result<SocketAddr>;
+
+    /// Returns the status/state of the socket
+    fn status(&self) -> Result<SocketStatus>;
+
+    /// Registers a waker for when this connection is ready to receive
+    /// more data. Uses a stack machine which means more than one waker
+    /// can be registered
+    fn set_handler(&mut self, handler: Box<dyn InterestHandler + Send + Sync>) -> Result<()>;
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SocketStatus {
+    Opening,
+    Opened,
+    Closed,
+    Failed,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum StreamSecurity {
+    Unencrypted,
+    AnyEncyption,
+    ClassicEncryption,
+    DoubleEncryption,
+}
+
+/// Connected sockets have a persistent connection to a remote peer
+pub trait VirtualConnectedSocket: VirtualSocket + fmt::Debug + Send + Sync + 'static {
+    /// Determines how long the socket will remain in a TIME_WAIT
+    /// after it disconnects (only the one that initiates the close will
+    /// be in a TIME_WAIT state thus the clients should always do this rather
+    /// than the server)
+    fn set_linger(&mut self, linger: Option<Duration>) -> Result<()>;
+
+    /// Returns how long the socket will remain in a TIME_WAIT
+    /// after it disconnects
+    fn linger(&self) -> Result<Option<Duration>>;
+
+    /// Tries to send out a datagram or stream of bytes on this socket
+    fn try_send(&mut self, data: &[u8]) -> Result<usize>;
+
+    // Tries to flush any data in the local buffers
+    fn try_flush(&mut self) -> Result<()>;
+
+    /// Closes the socket
+    fn close(&mut self) -> Result<()>;
+
+    /// Tries to read a packet from the socket
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+}
+
+#[async_trait::async_trait]
+pub trait VirtualConnectedSocketExt: VirtualConnectedSocket {
+    async fn send(&mut self, data: &[u8]) -> Result<usize>;
+
+    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+
+    async fn flush(&mut self) -> Result<()>;
+}
+
+#[async_trait::async_trait]
+impl<R: VirtualConnectedSocket + ?Sized> VirtualConnectedSocketExt for R {
+    async fn send(&mut self, data: &[u8]) -> Result<usize> {
+        pin_project! {
+            struct Poller<'a, 'b, R: ?Sized>
+            where
+                R: VirtualConnectedSocket,
+            {
+                socket: &'a mut R,
+                data: &'b [u8],
+            }
+        }
+        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        where
+            R: VirtualConnectedSocket + ?Sized,
+        {
+            type Output = Result<usize>;
+            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let this = self.project();
+
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = this.socket.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match this.socket.try_send(this.data) {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller { socket: self, data }.await
+    }
+
+    async fn recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize> {
+        pin_project! {
+            struct Poller<'a, 'b, R: ?Sized>
+            where
+                R: VirtualConnectedSocket,
+            {
+                socket: &'a mut R,
+                buf: &'b mut [MaybeUninit<u8>],
+            }
+        }
+        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        where
+            R: VirtualConnectedSocket + ?Sized,
+        {
+            type Output = Result<usize>;
+            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let this = self.project();
+
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = this.socket.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match this.socket.try_recv(this.buf) {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller { socket: self, buf }.await
+    }
+
+    async fn flush(&mut self) -> Result<()> {
+        struct Poller<'a, R>
+        where
+            R: VirtualConnectedSocket + ?Sized,
+        {
+            socket: &'a mut R,
+        }
+        impl<'a, R> std::future::Future for Poller<'a, R>
+        where
+            R: VirtualConnectedSocket + ?Sized,
+        {
+            type Output = Result<()>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = self.socket.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match self.socket.try_flush() {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller { socket: self }.await
+    }
+}
+
+/// Connectionless sockets are able to send and receive datagrams and stream
+/// bytes to multiple addresses at the same time (peer-to-peer)
+pub trait VirtualConnectionlessSocket: VirtualSocket + fmt::Debug + Send + Sync + 'static {
+    /// Sends out a datagram or stream of bytes on this socket
+    /// to a specific address
+    fn try_send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize>;
+
+    /// Recv a packet from the socket
+    fn try_recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)>;
+}
+
+#[async_trait::async_trait]
+pub trait VirtualConnectionlessSocketExt: VirtualConnectionlessSocket {
+    async fn send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize>;
+
+    async fn recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)>;
+}
+
+#[async_trait::async_trait]
+impl<R: VirtualConnectionlessSocket + ?Sized> VirtualConnectionlessSocketExt for R {
+    async fn send_to(&mut self, data: &[u8], addr: SocketAddr) -> Result<usize> {
+        pin_project! {
+            struct Poller<'a, 'b, R: ?Sized>
+            where
+                R: VirtualConnectionlessSocket,
+            {
+                socket: &'a mut R,
+                data: &'b [u8],
+                addr: SocketAddr,
+            }
+        }
+        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        where
+            R: VirtualConnectionlessSocket + ?Sized,
+        {
+            type Output = Result<usize>;
+            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let this = self.project();
+
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = this.socket.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match this.socket.try_send_to(this.data, *this.addr) {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller {
+            socket: self,
+            data,
+            addr,
+        }
+        .await
+    }
+
+    async fn recv_from(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<(usize, SocketAddr)> {
+        pin_project! {
+            struct Poller<'a, 'b, R: ?Sized>
+            where
+                R: VirtualConnectionlessSocket,
+            {
+                socket: &'a mut R,
+                buf: &'b mut [MaybeUninit<u8>],
+            }
+        }
+        impl<'a, 'b, R> std::future::Future for Poller<'a, 'b, R>
+        where
+            R: VirtualConnectionlessSocket + ?Sized,
+        {
+            type Output = Result<(usize, SocketAddr)>;
+            fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let this = self.project();
+
+                let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+                if let Err(err) = this.socket.set_handler(handler) {
+                    return Poll::Ready(Err(err));
+                }
+                match this.socket.try_recv_from(this.buf) {
+                    Ok(ret) => Poll::Ready(Ok(ret)),
+                    Err(NetworkError::WouldBlock) => Poll::Pending,
+                    Err(err) => Poll::Ready(Err(err)),
+                }
+            }
+        }
+        Poller { socket: self, buf }.await
+    }
+}
+
+/// ICMP sockets are low level devices bound to a specific address
+/// that can send and receive ICMP packets
+pub trait VirtualIcmpSocket:
+    VirtualConnectionlessSocket + fmt::Debug + Send + Sync + 'static
+{
+}
+
+#[async_trait::async_trait]
+pub trait VirtualRawSocket: VirtualSocket + fmt::Debug + Send + Sync + 'static {
+    /// Sends out a datagram or stream of bytes on this socket
+    fn try_send(&mut self, data: &[u8]) -> Result<usize>;
+
+    /// Attempts to flush the object, ensuring that any buffered data reach
+    /// their destination.
+    fn try_flush(&mut self) -> Result<()>;
+
+    /// Recv a packet from the socket
+    fn try_recv(&mut self, buf: &mut [MaybeUninit<u8>]) -> Result<usize>;
+
+    /// Tells the raw socket and its backing switch that all packets
+    /// should be received by this socket even if they are not
+    /// destined for this device
+    fn set_promiscuous(&mut self, promiscuous: bool) -> Result<()>;
+
+    /// Returns if the socket is running in promiscuous mode whereby it
+    /// will receive all packets even if they are not destined for the
+    /// local interface
+    fn promiscuous(&self) -> Result<bool>;
+}
+
+pub trait VirtualTcpSocket: VirtualConnectedSocket + fmt::Debug + Send + Sync + 'static {
+    /// Sets the receive buffer size which acts as a trottle for how
+    /// much data is buffered on this side of the pipe
+    fn set_recv_buf_size(&mut self, size: usize) -> Result<()>;
+
+    /// Size of the receive buffer that holds all data that has not
+    /// yet been read
+    fn recv_buf_size(&self) -> Result<usize>;
+
+    /// Sets the size of the send buffer which will hold the bytes of
+    /// data while they are being sent over to the peer
+    fn set_send_buf_size(&mut self, size: usize) -> Result<()>;
+
+    /// Size of the send buffer that holds all data that is currently
+    /// being transmitted.
+    fn send_buf_size(&self) -> Result<usize>;
+
+    /// When NO_DELAY is set the data that needs to be transmitted to
+    /// the peer is sent immediately rather than waiting for a bigger
+    /// batch of data, this reduces latency but increases encapsulation
+    /// overhead.
+    fn set_nodelay(&mut self, reuse: bool) -> Result<()>;
+
+    /// Indicates if the NO_DELAY flag is set which means that data
+    /// is immediately sent to the peer without waiting. This reduces
+    /// latency but increases encapsulation overhead.
+    fn nodelay(&self) -> Result<bool>;
+
+    /// When KEEP_ALIVE is set the connection will periodically send
+    /// an empty data packet to the server to make sure the connection
+    /// stays alive.
+    fn set_keepalive(&mut self, keepalive: bool) -> Result<()>;
+
+    /// Indicates if the KEEP_ALIVE flag is set which means that the
+    /// socket will periodically send an empty data packet to keep
+    /// the connection alive.
+    fn keepalive(&self) -> Result<bool>;
+
+    /// When DONT_ROUTE is set the packet will be sent directly
+    /// to the interface without passing through the routing logic.
+    fn set_dontroute(&mut self, keepalive: bool) -> Result<()>;
+
+    /// Indicates if the packet will pass straight through to
+    /// the interface bypassing the routing logic.
+    fn dontroute(&self) -> Result<bool>;
+
+    /// Returns the address (IP and Port) of the peer socket that this
+    /// is conencted to
+    fn addr_peer(&self) -> Result<SocketAddr>;
+
+    /// Shuts down either the READER or WRITER sides of the socket
+    /// connection.
+    fn shutdown(&mut self, how: Shutdown) -> Result<()>;
+
+    /// Return true if the socket is closed
+    fn is_closed(&self) -> bool;
+}
+
+#[cfg(feature = "tokio")]
+impl<'a> AsyncRead for Box<dyn VirtualTcpSocket + Sync + 'a> {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let this = self.get_mut();
+        let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+        if let Err(err) = this.set_handler(handler) {
+            return Poll::Ready(Err(net_error_into_io_err(err)));
+        }
+        let buf_unsafe = unsafe { buf.unfilled_mut() };
+        match this.try_recv(buf_unsafe) {
+            Ok(ret) => {
+                unsafe { buf.assume_init(ret) };
+                buf.set_filled(ret);
+                Poll::Ready(Ok(()))
+            }
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+}
+
+#[cfg(feature = "tokio")]
+impl<'a> AsyncWrite for Box<dyn VirtualTcpSocket + Sync + 'a> {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        let this = self.get_mut();
+        let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+        if let Err(err) = this.set_handler(handler) {
+            return Poll::Ready(Err(net_error_into_io_err(err)));
+        }
+        match this.try_send(buf) {
+            Ok(ret) => Poll::Ready(Ok(ret)),
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        let this = self.get_mut();
+        let handler: Box<dyn InterestHandler + Send + Sync> = cx.waker().into();
+        if let Err(err) = this.set_handler(handler) {
+            return Poll::Ready(Err(net_error_into_io_err(err)));
+        }
+        match this.try_flush() {
+            Ok(()) => Poll::Ready(Ok(())),
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        Poll::Ready(
+            self.shutdown(Shutdown::Write)
+                .map_err(net_error_into_io_err),
+        )
+    }
+}
+
+pub trait VirtualUdpSocket:
+    VirtualConnectionlessSocket + fmt::Debug + Send + Sync + 'static
+{
+    /// Sets a flag that means that the UDP socket is able
+    /// to receive and process broadcast packets.
+    fn set_broadcast(&mut self, broadcast: bool) -> Result<()>;
+
+    /// Indicates if the SO_BROADCAST flag is set which means
+    /// that the UDP socket will receive and process broadcast
+    /// packets
+    fn broadcast(&self) -> Result<bool>;
+
+    /// Sets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv4 addresses
+    fn set_multicast_loop_v4(&mut self, val: bool) -> Result<()>;
+
+    /// Gets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv4 addresses
+    fn multicast_loop_v4(&self) -> Result<bool>;
+
+    /// Sets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv6 addresses
+    fn set_multicast_loop_v6(&mut self, val: bool) -> Result<()>;
+
+    /// Gets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv6 addresses
+    fn multicast_loop_v6(&self) -> Result<bool>;
+
+    /// Sets the TTL for IPv4 multicast packets which is the
+    /// number of network hops before the packet is dropped
+    fn set_multicast_ttl_v4(&mut self, ttl: u32) -> Result<()>;
+
+    /// Gets the TTL for IPv4 multicast packets which is the
+    /// number of network hops before the packet is dropped
+    fn multicast_ttl_v4(&self) -> Result<u32>;
+
+    /// Tells this interface that it will subscribe to a
+    /// particular multicast address. This applies to IPv4 addresses
+    fn join_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()>;
+
+    /// Tells this interface that it will unsubscribe to a
+    /// particular multicast address. This applies to IPv4 addresses
+    fn leave_multicast_v4(&mut self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<()>;
+
+    /// Tells this interface that it will subscribe to a
+    /// particular multicast address. This applies to IPv6 addresses
+    fn join_multicast_v6(&mut self, multiaddr: Ipv6Addr, iface: u32) -> Result<()>;
+
+    /// Tells this interface that it will unsubscribe to a
+    /// particular multicast address. This applies to IPv6 addresses
+    fn leave_multicast_v6(&mut self, multiaddr: Ipv6Addr, iface: u32) -> Result<()>;
+
+    /// Returns the remote address of this UDP socket if it has been
+    /// connected to a specific target destination address
+    fn addr_peer(&self) -> Result<Option<SocketAddr>>;
+}
+
+#[derive(Debug, Default)]
+pub struct UnsupportedVirtualNetworking {}
+
+#[async_trait::async_trait]
+impl VirtualNetworking for UnsupportedVirtualNetworking {}
+
+#[derive(Error, Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NetworkError {
+    /// The handle given was not usable
+    #[error("invalid fd")]
+    InvalidFd,
+    /// File exists
+    #[error("file exists")]
+    AlreadyExists,
+    /// The filesystem has failed to lock a resource.
+    #[error("lock error")]
+    Lock,
+    /// Something failed when doing IO. These errors can generally not be handled.
+    /// It may work if tried again.
+    #[error("io error")]
+    IOError,
+    /// The address was in use
+    #[error("address is in use")]
+    AddressInUse,
+    /// The address could not be found
+    #[error("address could not be found")]
+    AddressNotAvailable,
+    /// A pipe was closed
+    #[error("broken pipe (was closed)")]
+    BrokenPipe,
+    /// Insufficient memory
+    #[error("Insufficient memory")]
+    InsufficientMemory,
+    /// The connection was aborted
+    #[error("connection aborted")]
+    ConnectionAborted,
+    /// The connection request was refused
+    #[error("connection refused")]
+    ConnectionRefused,
+    /// The connection was reset
+    #[error("connection reset")]
+    ConnectionReset,
+    /// The operation was interrupted before it could finish
+    #[error("operation interrupted")]
+    Interrupted,
+    /// Invalid internal data, if the argument data is invalid, use `InvalidInput`
+    #[error("invalid internal data")]
+    InvalidData,
+    /// The provided data is invalid
+    #[error("invalid input")]
+    InvalidInput,
+    /// Could not perform the operation because there was not an open connection
+    #[error("connection is not open")]
+    NotConnected,
+    /// The requested device couldn't be accessed
+    #[error("can't access device")]
+    NoDevice,
+    /// Caller was not allowed to perform this operation
+    #[error("permission denied")]
+    PermissionDenied,
+    /// The operation did not complete within the given amount of time
+    #[error("time out")]
+    TimedOut,
+    /// Found EOF when EOF was not expected
+    #[error("unexpected eof")]
+    UnexpectedEof,
+    /// Operation would block, this error lets the caller know that they can try again
+    #[error("blocking operation. try again")]
+    WouldBlock,
+    /// A call to write returned 0
+    #[error("write returned 0")]
+    WriteZero,
+    /// Too many open files
+    #[error("too many open files")]
+    TooManyOpenFiles,
+    /// The operation is not supported.
+    #[error("unsupported")]
+    Unsupported,
+    /// Some other unhandled error. If you see this, it's probably a bug.
+    #[error("unknown error found")]
+    UnknownError,
+}
+
+pub fn io_err_into_net_error(net_error: std::io::Error) -> NetworkError {
+    use std::io::ErrorKind;
+    match net_error.kind() {
+        ErrorKind::BrokenPipe => NetworkError::BrokenPipe,
+        ErrorKind::AlreadyExists => NetworkError::AlreadyExists,
+        ErrorKind::AddrInUse => NetworkError::AddressInUse,
+        ErrorKind::AddrNotAvailable => NetworkError::AddressNotAvailable,
+        ErrorKind::ConnectionAborted => NetworkError::ConnectionAborted,
+        ErrorKind::ConnectionRefused => NetworkError::ConnectionRefused,
+        ErrorKind::ConnectionReset => NetworkError::ConnectionReset,
+        ErrorKind::Interrupted => NetworkError::Interrupted,
+        ErrorKind::InvalidData => NetworkError::InvalidData,
+        ErrorKind::InvalidInput => NetworkError::InvalidInput,
+        ErrorKind::NotConnected => NetworkError::NotConnected,
+        ErrorKind::PermissionDenied => NetworkError::PermissionDenied,
+        ErrorKind::TimedOut => NetworkError::TimedOut,
+        ErrorKind::UnexpectedEof => NetworkError::UnexpectedEof,
+        ErrorKind::WouldBlock => NetworkError::WouldBlock,
+        ErrorKind::WriteZero => NetworkError::WriteZero,
+        ErrorKind::Unsupported => NetworkError::Unsupported,
+
+        #[cfg(all(target_family = "unix", feature = "libc"))]
+        _ => {
+            if let Some(code) = net_error.raw_os_error() {
+                match code {
+                    libc::EPERM => NetworkError::PermissionDenied,
+                    libc::EBADF => NetworkError::InvalidFd,
+                    libc::ECHILD => NetworkError::InvalidFd,
+                    libc::EMFILE => NetworkError::TooManyOpenFiles,
+                    libc::EINTR => NetworkError::Interrupted,
+                    libc::EIO => NetworkError::IOError,
+                    libc::ENXIO => NetworkError::IOError,
+                    libc::EAGAIN => NetworkError::WouldBlock,
+                    libc::ENOMEM => NetworkError::InsufficientMemory,
+                    libc::EACCES => NetworkError::PermissionDenied,
+                    libc::ENODEV => NetworkError::NoDevice,
+                    libc::EINVAL => NetworkError::InvalidInput,
+                    libc::EPIPE => NetworkError::BrokenPipe,
+                    err => {
+                        tracing::trace!("unknown os error {}", err);
+                        NetworkError::UnknownError
+                    }
+                }
+            } else {
+                NetworkError::UnknownError
+            }
+        }
+        #[cfg(not(all(target_family = "unix", feature = "libc")))]
+        _ => NetworkError::UnknownError,
+    }
+}
+
+pub fn net_error_into_io_err(net_error: NetworkError) -> std::io::Error {
+    use std::io::ErrorKind;
+    match net_error {
+        NetworkError::InvalidFd => ErrorKind::BrokenPipe.into(),
+        NetworkError::AlreadyExists => ErrorKind::AlreadyExists.into(),
+        NetworkError::Lock => ErrorKind::BrokenPipe.into(),
+        NetworkError::IOError => ErrorKind::BrokenPipe.into(),
+        NetworkError::AddressInUse => ErrorKind::AddrInUse.into(),
+        NetworkError::AddressNotAvailable => ErrorKind::AddrNotAvailable.into(),
+        NetworkError::BrokenPipe => ErrorKind::BrokenPipe.into(),
+        NetworkError::ConnectionAborted => ErrorKind::ConnectionAborted.into(),
+        NetworkError::ConnectionRefused => ErrorKind::ConnectionRefused.into(),
+        NetworkError::ConnectionReset => ErrorKind::ConnectionReset.into(),
+        NetworkError::Interrupted => ErrorKind::Interrupted.into(),
+        NetworkError::InvalidData => ErrorKind::InvalidData.into(),
+        NetworkError::InvalidInput => ErrorKind::InvalidInput.into(),
+        NetworkError::NotConnected => ErrorKind::NotConnected.into(),
+        NetworkError::NoDevice => ErrorKind::BrokenPipe.into(),
+        NetworkError::PermissionDenied => ErrorKind::PermissionDenied.into(),
+        NetworkError::TimedOut => ErrorKind::TimedOut.into(),
+        NetworkError::UnexpectedEof => ErrorKind::UnexpectedEof.into(),
+        NetworkError::WouldBlock => ErrorKind::WouldBlock.into(),
+        NetworkError::WriteZero => ErrorKind::WriteZero.into(),
+        NetworkError::Unsupported => ErrorKind::Unsupported.into(),
+        NetworkError::UnknownError => ErrorKind::BrokenPipe.into(),
+        NetworkError::InsufficientMemory => ErrorKind::OutOfMemory.into(),
+        NetworkError::TooManyOpenFiles => {
+            #[cfg(all(target_family = "unix", feature = "libc"))]
+            {
+                std::io::Error::from_raw_os_error(libc::EMFILE)
+            }
+            #[cfg(not(all(target_family = "unix", feature = "libc")))]
+            {
+                ErrorKind::Other.into()
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/loopback.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/loopback.rs
new file mode 100644
index 0000000..93a68b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/loopback.rs
@@ -0,0 +1,240 @@
+use std::collections::VecDeque;
+use std::net::SocketAddr;
+use std::sync::Mutex;
+use std::task::{Context, Poll, Waker};
+use std::{collections::HashMap, sync::Arc};
+
+use crate::tcp_pair::TcpSocketHalf;
+use crate::{
+    InterestHandler, IpAddr, IpCidr, Ipv4Addr, Ipv6Addr, NetworkError, VirtualIoSource,
+    VirtualNetworking, VirtualTcpListener, VirtualTcpSocket,
+};
+use derivative::Derivative;
+use virtual_mio::InterestType;
+
+const DEFAULT_MAX_BUFFER_SIZE: usize = 1_048_576;
+
+#[derive(Debug, Default)]
+struct LoopbackNetworkingState {
+    tcp_listeners: HashMap<SocketAddr, LoopbackTcpListener>,
+    ip_addresses: Vec<IpCidr>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LoopbackNetworking {
+    state: Arc<Mutex<LoopbackNetworkingState>>,
+}
+
+impl LoopbackNetworking {
+    pub fn new() -> Self {
+        LoopbackNetworking {
+            state: Arc::new(Mutex::new(Default::default())),
+        }
+    }
+
+    pub fn loopback_connect_to(
+        &self,
+        mut local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+    ) -> Option<TcpSocketHalf> {
+        let mut port = local_addr.port();
+        if port == 0 {
+            port = peer_addr.port();
+        }
+
+        local_addr = match local_addr.ip() {
+            IpAddr::V4(Ipv4Addr::UNSPECIFIED) => {
+                SocketAddr::new(Ipv4Addr::new(127, 0, 0, 100).into(), port)
+            }
+            IpAddr::V6(Ipv6Addr::UNSPECIFIED) => {
+                SocketAddr::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 100).into(), port)
+            }
+            ip => SocketAddr::new(ip, port),
+        };
+
+        let state = self.state.lock().unwrap();
+        if let Some(listener) = state.tcp_listeners.get(&peer_addr) {
+            Some(listener.connect_to(local_addr))
+        } else {
+            state
+                .tcp_listeners
+                .iter()
+                .next()
+                .map(|listener| listener.1.connect_to(local_addr))
+        }
+    }
+}
+
+impl Default for LoopbackNetworking {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait::async_trait]
+impl VirtualNetworking for LoopbackNetworking {
+    async fn dhcp_acquire(&self) -> crate::Result<Vec<IpAddr>> {
+        let mut state: std::sync::MutexGuard<'_, LoopbackNetworkingState> =
+            self.state.lock().unwrap();
+        state.ip_addresses.clear();
+        state.ip_addresses.push(IpCidr {
+            ip: IpAddr::V4(Ipv4Addr::LOCALHOST),
+            prefix: 32,
+        });
+        state.ip_addresses.push(IpCidr {
+            ip: IpAddr::V6(Ipv6Addr::LOCALHOST),
+            prefix: 128,
+        });
+        Ok(state.ip_addresses.iter().map(|cidr| cidr.ip).collect())
+    }
+
+    async fn ip_add(&self, ip: IpAddr, prefix: u8) -> crate::Result<()> {
+        let mut state = self.state.lock().unwrap();
+        state.ip_addresses.push(IpCidr { ip, prefix });
+        Ok(())
+    }
+
+    async fn ip_remove(&self, ip: IpAddr) -> crate::Result<()> {
+        let mut state: std::sync::MutexGuard<'_, LoopbackNetworkingState> =
+            self.state.lock().unwrap();
+        state.ip_addresses.retain(|cidr| cidr.ip != ip);
+        Ok(())
+    }
+
+    async fn ip_clear(&self) -> crate::Result<()> {
+        let mut state: std::sync::MutexGuard<'_, LoopbackNetworkingState> =
+            self.state.lock().unwrap();
+        state.ip_addresses.clear();
+        Ok(())
+    }
+
+    async fn ip_list(&self) -> crate::Result<Vec<IpCidr>> {
+        let state: std::sync::MutexGuard<'_, LoopbackNetworkingState> = self.state.lock().unwrap();
+        Ok(state.ip_addresses.clone())
+    }
+
+    async fn listen_tcp(
+        &self,
+        mut addr: SocketAddr,
+        _only_v6: bool,
+        _reuse_port: bool,
+        _reuse_addr: bool,
+    ) -> crate::Result<Box<dyn VirtualTcpListener + Sync>> {
+        let listener = LoopbackTcpListener::new(addr);
+
+        if addr.ip() == IpAddr::V4(Ipv4Addr::UNSPECIFIED) {
+            addr = SocketAddr::new(Ipv4Addr::LOCALHOST.into(), addr.port());
+        } else if addr.ip() == IpAddr::V6(Ipv6Addr::UNSPECIFIED) {
+            addr = SocketAddr::new(Ipv6Addr::LOCALHOST.into(), addr.port());
+        }
+
+        let mut state = self.state.lock().unwrap();
+        state.tcp_listeners.insert(addr, listener.clone());
+
+        Ok(Box::new(listener))
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct LoopbackTcpListenerState {
+    #[derivative(Debug = "ignore")]
+    handler: Option<Box<dyn InterestHandler + Send + Sync>>,
+    addr_local: SocketAddr,
+    backlog: VecDeque<TcpSocketHalf>,
+    wakers: Vec<Waker>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LoopbackTcpListener {
+    state: Arc<Mutex<LoopbackTcpListenerState>>,
+}
+
+impl LoopbackTcpListener {
+    pub fn new(addr_local: SocketAddr) -> Self {
+        Self {
+            state: Arc::new(Mutex::new(LoopbackTcpListenerState {
+                handler: None,
+                addr_local,
+                backlog: Default::default(),
+                wakers: Default::default(),
+            })),
+        }
+    }
+
+    pub fn connect_to(&self, addr_local: SocketAddr) -> TcpSocketHalf {
+        let mut state = self.state.lock().unwrap();
+        let (half1, half2) =
+            TcpSocketHalf::channel(DEFAULT_MAX_BUFFER_SIZE, state.addr_local, addr_local);
+
+        state.backlog.push_back(half1);
+        if let Some(handler) = state.handler.as_mut() {
+            handler.push_interest(InterestType::Readable);
+        }
+        state.wakers.drain(..).for_each(|w| w.wake());
+
+        half2
+    }
+}
+
+impl VirtualIoSource for LoopbackTcpListener {
+    fn remove_handler(&mut self) {
+        let mut state = self.state.lock().unwrap();
+        state.handler.take();
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        let mut state = self.state.lock().unwrap();
+        if !state.backlog.is_empty() {
+            return Poll::Ready(Ok(state.backlog.len()));
+        }
+        if !state.wakers.iter().any(|w| w.will_wake(cx.waker())) {
+            state.wakers.push(cx.waker().clone());
+        }
+        Poll::Pending
+    }
+
+    fn poll_write_ready(&mut self, _cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        Poll::Pending
+    }
+}
+
+impl VirtualTcpListener for LoopbackTcpListener {
+    fn try_accept(
+        &mut self,
+    ) -> crate::Result<(Box<dyn crate::VirtualTcpSocket + Sync>, SocketAddr)> {
+        let mut state = self.state.lock().unwrap();
+        let next = state.backlog.pop_front();
+        if let Some(next) = next {
+            let peer = next.addr_peer()?;
+            return Ok((Box::new(next), peer));
+        }
+        Err(NetworkError::WouldBlock)
+    }
+
+    fn set_handler(
+        &mut self,
+        mut handler: Box<dyn InterestHandler + Send + Sync>,
+    ) -> crate::Result<()> {
+        let mut state = self.state.lock().unwrap();
+        if !state.backlog.is_empty() {
+            handler.push_interest(InterestType::Readable);
+        }
+        state.handler.replace(handler);
+        Ok(())
+    }
+
+    fn addr_local(&self) -> crate::Result<SocketAddr> {
+        let state = self.state.lock().unwrap();
+        Ok(state.addr_local)
+    }
+
+    fn set_ttl(&mut self, _ttl: u8) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn ttl(&self) -> crate::Result<u8> {
+        Ok(64)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/meta.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/meta.rs
new file mode 100644
index 0000000..c8875c9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/meta.rs
@@ -0,0 +1,338 @@
+use std::net::IpAddr;
+use std::net::Ipv4Addr;
+use std::net::Ipv6Addr;
+use std::net::SocketAddr;
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+
+pub use super::IpCidr;
+pub use super::IpRoute;
+pub use super::NetworkError;
+pub use super::SocketStatus;
+pub use super::StreamSecurity;
+
+/// Represents a socket ID
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SocketId(u64);
+
+impl From<u64> for SocketId {
+    fn from(value: u64) -> Self {
+        Self(value)
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub enum FrameSerializationFormat {
+    Bincode,
+    #[cfg(feature = "json")]
+    Json,
+    #[cfg(feature = "messagepack")]
+    MessagePack,
+    #[cfg(feature = "cbor")]
+    Cbor,
+}
+
+/// Possible values which can be passed to the [`TcpStream::shutdown`] method.
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+pub enum Shutdown {
+    /// The reading portion of the [`TcpStream`] should be shut down.
+    Read,
+    /// The writing portion of the [`TcpStream`] should be shut down.
+    Write,
+    /// Both the reading and the writing portions of the [`TcpStream`] should be shut down.
+    Both,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum RequestType {
+    /// Bridges this local network with a remote network, which is required in
+    /// order to make lower level networking calls (such as UDP/TCP)
+    Bridge {
+        network: String,
+        access_token: String,
+        security: StreamSecurity,
+    },
+    /// Flushes all the data by ensuring a full round trip is completed
+    Flush,
+    /// Disconnects from the remote network essentially unbridging it
+    Unbridge,
+    /// Acquires an IP address on the network and configures the routing tables
+    DhcpAcquire,
+    /// Adds a static IP address to the interface with a netmask prefix
+    IpAdd { ip: IpAddr, prefix: u8 },
+    /// Removes a static (or dynamic) IP address from the interface
+    IpRemove(IpAddr),
+    /// Clears all the assigned IP addresses for this interface
+    IpClear,
+    /// Lists all the IP addresses currently assigned to this interface
+    GetIpList,
+    /// Returns the hardware MAC address for this interface
+    GetMac,
+    /// Adds a default gateway to the routing table
+    GatewaySet(IpAddr),
+    /// Adds a specific route to the routing table
+    RouteAdd {
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    },
+    /// Removes a routing rule from the routing table
+    RouteRemove(IpAddr),
+    /// Clears the routing table for this interface
+    RouteClear,
+    /// Lists all the routes defined in the routing table for this interface
+    GetRouteList,
+    /// Creates a low level socket that can read and write Ethernet packets
+    /// directly to the interface
+    BindRaw(SocketId),
+    /// Lists for TCP connections on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    ListenTcp {
+        socket_id: SocketId,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    },
+    /// Opens a UDP socket that listens on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    BindUdp {
+        socket_id: SocketId,
+        addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    },
+    /// Creates a socket that can be used to send and receive ICMP packets
+    /// from a paritcular IP address
+    BindIcmp { socket_id: SocketId, addr: IpAddr },
+    /// Opens a TCP connection to a particular destination IP address and port
+    ConnectTcp {
+        socket_id: SocketId,
+        addr: SocketAddr,
+        peer: SocketAddr,
+    },
+    /// Performs DNS resolution for a specific hostname
+    Resolve {
+        host: String,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    },
+    /// Closes the socket
+    Close,
+    /// Begins the process of accepting a socket and returns it later
+    BeginAccept(SocketId),
+    /// Returns the local address of this TCP listener
+    GetAddrLocal,
+    /// Returns the address (IP and Port) of the peer socket that this
+    /// is conencted to
+    GetAddrPeer,
+    /// Sets how many network hops the packets are permitted for new connections
+    SetTtl(u32),
+    /// Returns the maximum number of network hops before packets are dropped
+    GetTtl,
+    /// Returns the status/state of the socket
+    GetStatus,
+    /// Determines how long the socket will remain in a TIME_WAIT
+    /// after it disconnects (only the one that initiates the close will
+    /// be in a TIME_WAIT state thus the clients should always do this rather
+    /// than the server)
+    SetLinger(Option<Duration>),
+    /// Returns how long the socket will remain in a TIME_WAIT
+    /// after it disconnects
+    GetLinger,
+    /// Tells the raw socket and its backing switch that all packets
+    /// should be received by this socket even if they are not
+    /// destined for this device
+    SetPromiscuous(bool),
+    /// Returns if the socket is running in promiscuous mode whereby it
+    /// will receive all packets even if they are not destined for the
+    /// local interface
+    GetPromiscuous,
+    /// Sets the receive buffer size which acts as a trottle for how
+    /// much data is buffered on this side of the pipe
+    SetRecvBufSize(u64),
+    /// Size of the receive buffer that holds all data that has not
+    /// yet been read
+    GetRecvBufSize,
+    /// Sets the size of the send buffer which will hold the bytes of
+    /// data while they are being sent over to the peer
+    SetSendBufSize(u64),
+    /// Size of the send buffer that holds all data that is currently
+    /// being transmitted.
+    GetSendBufSize,
+    /// When NO_DELAY is set the data that needs to be transmitted to
+    /// the peer is sent immediately rather than waiting for a bigger
+    /// batch of data, this reduces latency but increases encapsulation
+    /// overhead.
+    SetNoDelay(bool),
+    /// Indicates if the NO_DELAY flag is set which means that data
+    /// is immediately sent to the peer without waiting. This reduces
+    /// latency but increases encapsulation overhead.
+    GetNoDelay,
+    /// When KEEP_ALIVE is set the connection will periodically send
+    /// an empty data packet to the server to make sure the connection
+    /// stays alive.
+    SetKeepAlive(bool),
+    /// Indicates if the KEEP_ALIVE flag is set which means that the
+    /// socket will periodically send an empty data packet to keep
+    /// the connection alive.
+    GetKeepAlive,
+    /// When DONT_ROUTE is set the packet will be sent directly
+    /// to the interface without passing through the routing logic.
+    SetDontRoute(bool),
+    /// Indicates if the packet will pass straight through to
+    /// the interface bypassing the routing logic.
+    GetDontRoute,
+    /// Shuts down either the READER or WRITER sides of the socket
+    /// connection.
+    Shutdown(Shutdown),
+    /// Return true if the socket is closed
+    IsClosed,
+    /// Sets a flag that means that the UDP socket is able
+    /// to receive and process broadcast packets.
+    SetBroadcast(bool),
+    /// Indicates if the SO_BROADCAST flag is set which means
+    /// that the UDP socket will receive and process broadcast
+    /// packets
+    GetBroadcast,
+    /// Sets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv4 addresses
+    SetMulticastLoopV4(bool),
+    /// Gets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv4 addresses
+    GetMulticastLoopV4,
+    /// Sets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv6 addresses
+    SetMulticastLoopV6(bool),
+    /// Gets a flag that indicates if multicast packets that
+    /// this socket is a member of will be looped back to
+    /// the sending socket. This applies to IPv6 addresses
+    GetMulticastLoopV6,
+    /// Sets the TTL for IPv4 multicast packets which is the
+    /// number of network hops before the packet is dropped
+    SetMulticastTtlV4(u32),
+    /// Gets the TTL for IPv4 multicast packets which is the
+    /// number of network hops before the packet is dropped
+    GetMulticastTtlV4,
+    /// Tells this interface that it will subscribe to a
+    /// particular multicast address. This applies to IPv4 addresses
+    JoinMulticastV4 {
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    },
+    /// Tells this interface that it will unsubscribe to a
+    /// particular multicast address. This applies to IPv4 addresses
+    LeaveMulticastV4 {
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    },
+    /// Tells this interface that it will subscribe to a
+    /// particular multicast address. This applies to IPv6 addresses
+    JoinMulticastV6 { multiaddr: Ipv6Addr, iface: u32 },
+    /// Tells this interface that it will unsubscribe to a
+    /// particular multicast address. This applies to IPv6 addresses
+    LeaveMulticastV6 { multiaddr: Ipv6Addr, iface: u32 },
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum ResponseType {
+    /// Nothing is returned (or noop)
+    None,
+    /// An error has occurred
+    Err(NetworkError),
+    /// Represents a duration of time
+    Duration(Duration),
+    /// Represents an amount (e.g. amount of bytes)
+    Amount(u64),
+    /// Returns a flag of true or false
+    Flag(bool),
+    /// List of IP addresses
+    IpAddressList(Vec<IpAddr>),
+    /// A single IP address
+    IpAddress(IpAddr),
+    /// List of socket addresses
+    SocketAddrList(Vec<SocketAddr>),
+    /// A single IP address
+    SocketAddr(SocketAddr),
+    /// Represents a MAC address
+    Mac([u8; 6]),
+    /// List of CIDR routes from a routing table
+    CidrList(Vec<IpCidr>),
+    /// List of IP routes from a routing table
+    RouteList(Vec<IpRoute>),
+    /// Reference to a socket
+    Socket(SocketId),
+    /// The TTL of a packet
+    Ttl(u32),
+    /// The status of the socket
+    Status(SocketStatus),
+}
+
+/// Message sent by the client to the server
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum MessageRequest {
+    Interface {
+        req: RequestType,
+        req_id: Option<u64>,
+    },
+    Socket {
+        socket: SocketId,
+        req: RequestType,
+        req_id: Option<u64>,
+    },
+    Send {
+        socket: SocketId,
+        data: Vec<u8>,
+        req_id: Option<u64>,
+    },
+    SendTo {
+        socket: SocketId,
+        data: Vec<u8>,
+        addr: SocketAddr,
+        req_id: Option<u64>,
+    },
+    Reconnect,
+}
+
+/// Message sent by the server back to a client
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum MessageResponse {
+    ResponseToRequest {
+        req_id: u64,
+        res: ResponseType,
+    },
+    Recv {
+        socket_id: SocketId,
+        data: Vec<u8>,
+    },
+    RecvWithAddr {
+        socket_id: SocketId,
+        data: Vec<u8>,
+        addr: SocketAddr,
+    },
+    Sent {
+        socket_id: SocketId,
+        req_id: u64,
+        amount: u64,
+    },
+    SendError {
+        socket_id: SocketId,
+        req_id: u64,
+        error: NetworkError,
+    },
+    FinishAccept {
+        socket_id: SocketId,
+        child_id: SocketId,
+        addr: SocketAddr,
+    },
+    Closed {
+        socket_id: SocketId,
+    },
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/rx_tx.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/rx_tx.rs
new file mode 100644
index 0000000..bb052f6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/rx_tx.rs
@@ -0,0 +1,617 @@
+use std::{
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll, Waker},
+};
+
+use crate::Result;
+use futures_util::{future::BoxFuture, Future, Sink, SinkExt, Stream};
+use serde::Serialize;
+#[cfg(feature = "tokio-tungstenite")]
+use tokio::net::TcpStream;
+use tokio::{
+    io::AsyncWrite,
+    sync::{
+        mpsc::{self, error::TrySendError},
+        oneshot,
+    },
+};
+use virtual_mio::InlineWaker;
+
+use crate::{io_err_into_net_error, NetworkError};
+
+#[derive(Debug, Clone, Default)]
+pub(crate) struct RemoteTxWakers {
+    wakers: Arc<Mutex<Vec<Waker>>>,
+}
+impl RemoteTxWakers {
+    pub fn add(&self, waker: &Waker) {
+        let mut guard = self.wakers.lock().unwrap();
+        if !guard.iter().any(|w| w.will_wake(waker)) {
+            guard.push(waker.clone());
+        }
+    }
+    pub fn wake(&self) {
+        let mut guard = self.wakers.lock().unwrap();
+        guard.drain(..).for_each(|w| w.wake());
+    }
+}
+
+#[derive(Debug, Default)]
+struct FailOnWrite {}
+impl AsyncWrite for FailOnWrite {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::ErrorKind::ConnectionAborted.into()))
+    }
+}
+
+pub(crate) type StreamSink<T> = Pin<Box<dyn Sink<T, Error = std::io::Error> + Send + 'static>>;
+
+pub(crate) enum RemoteTx<T>
+where
+    T: Serialize,
+{
+    Mpsc {
+        tx: mpsc::Sender<T>,
+        work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
+        wakers: RemoteTxWakers,
+    },
+    Stream {
+        tx: Arc<tokio::sync::Mutex<StreamSink<T>>>,
+        work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
+        wakers: RemoteTxWakers,
+    },
+    #[cfg(feature = "hyper")]
+    HyperWebSocket {
+        tx: Arc<
+            tokio::sync::Mutex<
+                futures_util::stream::SplitSink<
+                    hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>,
+                    hyper_tungstenite::tungstenite::Message,
+                >,
+            >,
+        >,
+        work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
+        wakers: RemoteTxWakers,
+        format: crate::meta::FrameSerializationFormat,
+    },
+    #[cfg(feature = "tokio-tungstenite")]
+    TokioWebSocket {
+        tx: Arc<
+            tokio::sync::Mutex<
+                futures_util::stream::SplitSink<
+                    tokio_tungstenite::WebSocketStream<
+                        tokio_tungstenite::MaybeTlsStream<TcpStream>,
+                    >,
+                    tokio_tungstenite::tungstenite::Message,
+                >,
+            >,
+        >,
+        work: mpsc::UnboundedSender<BoxFuture<'static, ()>>,
+        wakers: RemoteTxWakers,
+        format: crate::meta::FrameSerializationFormat,
+    },
+}
+impl<T> RemoteTx<T>
+where
+    T: Serialize + Send + Sync + 'static,
+{
+    pub(crate) async fn send(&self, req: T) -> Result<()> {
+        match self {
+            RemoteTx::Mpsc { tx, .. } => tx
+                .send(req)
+                .await
+                .map_err(|_| NetworkError::ConnectionAborted),
+            RemoteTx::Stream { tx, work, .. } => {
+                let (tx_done, rx_done) = oneshot::channel();
+                let tx = tx.clone();
+                work.send(Box::pin(async move {
+                    let job = async {
+                        let mut tx_guard = tx.lock_owned().await;
+                        tx_guard.send(req).await.map_err(io_err_into_net_error)
+                    };
+                    tx_done.send(job.await).ok();
+                }))
+                .map_err(|_| NetworkError::ConnectionAborted)?;
+
+                rx_done
+                    .await
+                    .unwrap_or(Err(NetworkError::ConnectionAborted))
+            }
+            #[cfg(feature = "hyper")]
+            RemoteTx::HyperWebSocket { tx, format, .. } => {
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Err(NetworkError::IOError);
+                    }
+                };
+                let mut tx = tx.lock().await;
+                tx.send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                    .await
+                    .map_err(|_| NetworkError::ConnectionAborted)
+            }
+            #[cfg(feature = "tokio-tungstenite")]
+            RemoteTx::TokioWebSocket { tx, format, .. } => {
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Err(NetworkError::IOError);
+                    }
+                };
+                let mut tx = tx.lock().await;
+                tx.send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                    .await
+                    .map_err(|_| NetworkError::ConnectionAborted)
+            }
+        }
+    }
+
+    pub(crate) fn poll_send(&self, cx: &mut Context<'_>, req: T) -> Poll<Result<()>> {
+        match self {
+            RemoteTx::Mpsc { tx, wakers, .. } => match tx.try_send(req) {
+                Ok(()) => Poll::Ready(Ok(())),
+                Err(TrySendError::Closed(_)) => Poll::Ready(Err(NetworkError::ConnectionAborted)),
+                Err(TrySendError::Full(_)) => {
+                    wakers.add(cx.waker());
+                    Poll::Pending
+                }
+            },
+            RemoteTx::Stream { tx, work, wakers } => {
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        wakers.add(cx.waker());
+                        return Poll::Pending;
+                    }
+                };
+                match tx_guard.poll_ready_unpin(cx) {
+                    Poll::Ready(Ok(())) => {}
+                    Poll::Ready(Err(err)) => return Poll::Ready(Err(io_err_into_net_error(err))),
+                    Poll::Pending => return Poll::Pending,
+                }
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard.send(req).await.map_err(io_err_into_net_error) {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(cx).is_ready() {
+                    return Poll::Ready(Ok(()));
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Poll::Ready(Ok(()))
+            }
+            #[cfg(feature = "hyper")]
+            RemoteTx::HyperWebSocket {
+                tx,
+                format,
+                work,
+                wakers,
+                ..
+            } => {
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        wakers.add(cx.waker());
+                        return Poll::Pending;
+                    }
+                };
+                match tx_guard.poll_ready_unpin(cx) {
+                    Poll::Ready(Ok(())) => {}
+                    Poll::Ready(Err(err)) => {
+                        tracing::warn!("failed to poll web socket for readiness - {err}");
+                        return Poll::Ready(Err(NetworkError::IOError));
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Poll::Ready(Err(NetworkError::IOError));
+                    }
+                };
+
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard
+                        .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                        .await
+                    {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(cx).is_ready() {
+                    return Poll::Ready(Ok(()));
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Poll::Ready(Ok(()))
+            }
+            #[cfg(feature = "tokio-tungstenite")]
+            RemoteTx::TokioWebSocket {
+                tx,
+                format,
+                work,
+                wakers,
+                ..
+            } => {
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        wakers.add(cx.waker());
+                        return Poll::Pending;
+                    }
+                };
+                match tx_guard.poll_ready_unpin(cx) {
+                    Poll::Ready(Ok(())) => {}
+                    Poll::Ready(Err(err)) => {
+                        tracing::warn!("failed to poll web socket for readiness - {err}");
+                        return Poll::Ready(Err(NetworkError::IOError));
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Poll::Ready(Err(NetworkError::IOError));
+                    }
+                };
+
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard
+                        .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                        .await
+                    {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(cx).is_ready() {
+                    return Poll::Ready(Ok(()));
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Poll::Ready(Ok(()))
+            }
+        }
+    }
+
+    pub(crate) fn send_with_driver(&self, req: T) -> Result<()> {
+        match self {
+            RemoteTx::Mpsc { tx, work, .. } => match tx.try_send(req) {
+                Ok(()) => Ok(()),
+                Err(TrySendError::Closed(_)) => Err(NetworkError::ConnectionAborted),
+                Err(TrySendError::Full(req)) => {
+                    let tx = tx.clone();
+                    work.send(Box::pin(async move {
+                        tx.send(req).await.ok();
+                    }))
+                    .ok();
+                    Ok(())
+                }
+            },
+            RemoteTx::Stream { tx, work, .. } => {
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        let tx = tx.clone();
+                        work.send(Box::pin(async move {
+                            let mut tx_guard = tx.lock().await;
+                            tx_guard.send(req).await.ok();
+                        }))
+                        .ok();
+                        return Ok(());
+                    }
+                };
+
+                let inline_waker = InlineWaker::new();
+                let waker = inline_waker.as_waker();
+                let mut cx = Context::from_waker(&waker);
+
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard.send(req).await.map_err(io_err_into_net_error) {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(&mut cx).is_ready() {
+                    return Ok(());
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Ok(())
+            }
+            #[cfg(feature = "hyper")]
+            RemoteTx::HyperWebSocket {
+                tx, format, work, ..
+            } => {
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Err(NetworkError::IOError);
+                    }
+                };
+
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        let tx = tx.clone();
+                        work.send(Box::pin(async move {
+                            let mut tx_guard = tx.lock().await;
+                            tx_guard
+                                .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                                .await
+                                .ok();
+                        }))
+                        .ok();
+                        return Ok(());
+                    }
+                };
+
+                let inline_waker = InlineWaker::new();
+                let waker = inline_waker.as_waker();
+                let mut cx = Context::from_waker(&waker);
+
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard
+                        .send(hyper_tungstenite::tungstenite::Message::Binary(data))
+                        .await
+                    {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(&mut cx).is_ready() {
+                    return Ok(());
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Ok(())
+            }
+            #[cfg(feature = "tokio-tungstenite")]
+            RemoteTx::TokioWebSocket {
+                tx, format, work, ..
+            } => {
+                let data = match format {
+                    crate::meta::FrameSerializationFormat::Bincode => bincode::serialize(&req)
+                        .map_err(|err| {
+                            tracing::warn!("failed to serialize message - {err}");
+                            NetworkError::IOError
+                        })?,
+                    format => {
+                        tracing::warn!("format not currently supported - {format:?}");
+                        return Err(NetworkError::IOError);
+                    }
+                };
+
+                let mut tx_guard = match tx.clone().try_lock_owned() {
+                    Ok(lock) => lock,
+                    Err(_) => {
+                        let tx = tx.clone();
+                        work.send(Box::pin(async move {
+                            let mut tx_guard = tx.lock().await;
+                            tx_guard
+                                .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                                .await
+                                .ok();
+                        }))
+                        .ok();
+                        return Ok(());
+                    }
+                };
+
+                let inline_waker = InlineWaker::new();
+                let waker = inline_waker.as_waker();
+                let mut cx = Context::from_waker(&waker);
+
+                let mut job = Box::pin(async move {
+                    if let Err(err) = tx_guard
+                        .send(tokio_tungstenite::tungstenite::Message::Binary(data))
+                        .await
+                    {
+                        tracing::error!("failed to send remaining bytes for request - {}", err);
+                    }
+                });
+
+                // First we try to finish it synchronously
+                if job.as_mut().poll(&mut cx).is_ready() {
+                    return Ok(());
+                }
+
+                // Otherwise we push it to the driver which will block all future send
+                // operations until it finishes
+                work.send(job).map_err(|err| {
+                    tracing::error!("failed to send remaining bytes for request - {}", err);
+                    NetworkError::ConnectionAborted
+                })?;
+                Ok(())
+            }
+        }
+    }
+}
+
+pub(crate) enum RemoteRx<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    Mpsc {
+        rx: mpsc::Receiver<T>,
+        wakers: RemoteTxWakers,
+    },
+    Stream {
+        rx: Pin<Box<dyn Stream<Item = std::io::Result<T>> + Send + 'static>>,
+    },
+    #[cfg(feature = "hyper")]
+    HyperWebSocket {
+        rx: futures_util::stream::SplitStream<
+            hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>,
+        >,
+        format: crate::meta::FrameSerializationFormat,
+    },
+    #[cfg(feature = "tokio-tungstenite")]
+    TokioWebSocket {
+        rx: futures_util::stream::SplitStream<
+            tokio_tungstenite::WebSocketStream<tokio_tungstenite::MaybeTlsStream<TcpStream>>,
+        >,
+        format: crate::meta::FrameSerializationFormat,
+    },
+}
+impl<T> RemoteRx<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    pub(crate) fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Option<T>> {
+        loop {
+            return match self {
+                RemoteRx::Mpsc { rx, wakers } => {
+                    let ret = Pin::new(rx).poll_recv(cx);
+                    if ret.is_ready() {
+                        wakers.wake();
+                    }
+                    ret
+                }
+                RemoteRx::Stream { rx } => match rx.as_mut().poll_next(cx) {
+                    Poll::Ready(Some(Ok(msg))) => Poll::Ready(Some(msg)),
+                    Poll::Ready(Some(Err(err))) => {
+                        tracing::debug!("failed to read from channel - {}", err);
+                        Poll::Ready(None)
+                    }
+                    Poll::Ready(None) => Poll::Ready(None),
+                    Poll::Pending => Poll::Pending,
+                },
+                #[cfg(feature = "hyper")]
+                RemoteRx::HyperWebSocket { rx, format } => match Pin::new(rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(hyper_tungstenite::tungstenite::Message::Binary(msg)))) => {
+                        match format {
+                            crate::meta::FrameSerializationFormat::Bincode => {
+                                return match bincode::deserialize(&msg) {
+                                    Ok(msg) => Poll::Ready(Some(msg)),
+                                    Err(err) => {
+                                        tracing::warn!("failed to deserialize message - {}", err);
+                                        continue;
+                                    }
+                                }
+                            }
+                            format => {
+                                tracing::warn!("format not currently supported - {format:?}");
+                                continue;
+                            }
+                        }
+                    }
+                    Poll::Ready(Some(Ok(msg))) => {
+                        tracing::warn!("unsupported message from channel - {}", msg);
+                        continue;
+                    }
+                    Poll::Ready(Some(Err(err))) => {
+                        tracing::debug!("failed to read from channel - {}", err);
+                        Poll::Ready(None)
+                    }
+                    Poll::Ready(None) => Poll::Ready(None),
+                    Poll::Pending => Poll::Pending,
+                },
+                #[cfg(feature = "tokio-tungstenite")]
+                RemoteRx::TokioWebSocket { rx, format } => match Pin::new(rx).poll_next(cx) {
+                    Poll::Ready(Some(Ok(tokio_tungstenite::tungstenite::Message::Binary(msg)))) => {
+                        match format {
+                            crate::meta::FrameSerializationFormat::Bincode => {
+                                return match bincode::deserialize(&msg) {
+                                    Ok(msg) => Poll::Ready(Some(msg)),
+                                    Err(err) => {
+                                        tracing::warn!("failed to deserialize message - {}", err);
+                                        continue;
+                                    }
+                                }
+                            }
+                            format => {
+                                tracing::warn!("format not currently supported - {format:?}");
+                                continue;
+                            }
+                        }
+                    }
+                    Poll::Ready(Some(Ok(msg))) => {
+                        tracing::warn!("unsupported message from channel - {}", msg);
+                        continue;
+                    }
+                    Poll::Ready(Some(Err(err))) => {
+                        tracing::debug!("failed to read from channel - {}", err);
+                        Poll::Ready(None)
+                    }
+                    Poll::Ready(None) => Poll::Ready(None),
+                    Poll::Pending => Poll::Pending,
+                },
+            };
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/server.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/server.rs
new file mode 100644
index 0000000..bc33c5a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/server.rs
@@ -0,0 +1,1641 @@
+use crate::meta::{FrameSerializationFormat, ResponseType};
+use crate::rx_tx::{RemoteRx, RemoteTx, RemoteTxWakers};
+use crate::{
+    meta::{MessageRequest, MessageResponse, RequestType, SocketId},
+    VirtualNetworking, VirtualRawSocket, VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+};
+use crate::{IpCidr, IpRoute, NetworkError, StreamSecurity, VirtualIcmpSocket};
+use derivative::Derivative;
+use futures_util::stream::FuturesOrdered;
+#[cfg(any(feature = "hyper", feature = "tokio-tungstenite"))]
+use futures_util::stream::{SplitSink, SplitStream};
+use futures_util::{future::BoxFuture, StreamExt};
+use futures_util::{Sink, Stream};
+use std::collections::HashSet;
+use std::mem::MaybeUninit;
+use std::net::IpAddr;
+use std::task::Waker;
+use std::time::Duration;
+use std::{
+    collections::HashMap,
+    future::Future,
+    net::SocketAddr,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+use tokio::{
+    io::{AsyncRead, AsyncWrite},
+    sync::mpsc,
+};
+use tokio_serde::formats::SymmetricalBincode;
+#[cfg(feature = "cbor")]
+use tokio_serde::formats::SymmetricalCbor;
+#[cfg(feature = "json")]
+use tokio_serde::formats::SymmetricalJson;
+#[cfg(feature = "messagepack")]
+use tokio_serde::formats::SymmetricalMessagePack;
+use tokio_serde::SymmetricallyFramed;
+use tokio_util::codec::{FramedRead, FramedWrite, LengthDelimitedCodec};
+use virtual_mio::InterestHandler;
+
+type BackgroundTask = Option<BoxFuture<'static, ()>>;
+
+#[derive(Debug, Clone)]
+pub struct RemoteNetworkingServer {
+    #[allow(dead_code)]
+    common: Arc<RemoteAdapterCommon>,
+    inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+}
+
+impl RemoteNetworkingServer {
+    fn new(
+        tx: RemoteTx<MessageResponse>,
+        rx: RemoteRx<MessageRequest>,
+        work: mpsc::UnboundedReceiver<BoxFuture<'static, ()>>,
+        inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    ) -> (Self, RemoteNetworkingServerDriver) {
+        let common = RemoteAdapterCommon {
+            tx,
+            rx: Mutex::new(rx),
+            sockets: Default::default(),
+            socket_accept: Default::default(),
+            handler: Default::default(),
+            stall_rx: Default::default(),
+        };
+        let common = Arc::new(common);
+
+        let driver = RemoteNetworkingServerDriver {
+            more_work: work,
+            tasks: Default::default(),
+            common: common.clone(),
+            inner: inner.clone(),
+        };
+        let networking = Self { common, inner };
+
+        (networking, driver)
+    }
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    pub fn new_from_mpsc(
+        tx: mpsc::Sender<MessageResponse>,
+        rx: mpsc::Receiver<MessageRequest>,
+        inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    ) -> (Self, RemoteNetworkingServerDriver) {
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+        let tx_wakers = RemoteTxWakers::default();
+
+        let tx = RemoteTx::Mpsc {
+            tx,
+            work: tx_work,
+            wakers: tx_wakers.clone(),
+        };
+        let rx = RemoteRx::Mpsc {
+            rx,
+            wakers: tx_wakers,
+        };
+        Self::new(tx, rx, rx_work, inner)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    pub fn new_from_async_io<TX, RX>(
+        tx: TX,
+        rx: RX,
+        format: FrameSerializationFormat,
+        inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    ) -> (Self, RemoteNetworkingServerDriver)
+    where
+        TX: AsyncWrite + Send + 'static,
+        RX: AsyncRead + Send + 'static,
+    {
+        let tx = FramedWrite::new(tx, LengthDelimitedCodec::new());
+        let tx: Pin<Box<dyn Sink<MessageResponse, Error = std::io::Error> + Send + 'static>> =
+            match format {
+                FrameSerializationFormat::Bincode => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalBincode::default()))
+                }
+                #[cfg(feature = "json")]
+                FrameSerializationFormat::Json => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalJson::default()))
+                }
+                #[cfg(feature = "messagepack")]
+                FrameSerializationFormat::MessagePack => Box::pin(SymmetricallyFramed::new(
+                    tx,
+                    SymmetricalMessagePack::default(),
+                )),
+                #[cfg(feature = "cbor")]
+                FrameSerializationFormat::Cbor => {
+                    Box::pin(SymmetricallyFramed::new(tx, SymmetricalCbor::default()))
+                }
+            };
+
+        let rx = FramedRead::new(rx, LengthDelimitedCodec::new());
+        let rx: Pin<Box<dyn Stream<Item = std::io::Result<MessageRequest>> + Send + 'static>> =
+            match format {
+                FrameSerializationFormat::Bincode => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalBincode::default()))
+                }
+                #[cfg(feature = "json")]
+                FrameSerializationFormat::Json => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalJson::default()))
+                }
+                #[cfg(feature = "messagepack")]
+                FrameSerializationFormat::MessagePack => Box::pin(SymmetricallyFramed::new(
+                    rx,
+                    SymmetricalMessagePack::default(),
+                )),
+                #[cfg(feature = "cbor")]
+                FrameSerializationFormat::Cbor => {
+                    Box::pin(SymmetricallyFramed::new(rx, SymmetricalCbor::default()))
+                }
+            };
+
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+
+        let tx = RemoteTx::Stream {
+            tx: Arc::new(tokio::sync::Mutex::new(tx)),
+            work: tx_work,
+            wakers: RemoteTxWakers::default(),
+        };
+        let rx = RemoteRx::Stream { rx };
+        Self::new(tx, rx, rx_work, inner)
+    }
+
+    /// Creates a new interface on the remote location using
+    /// a unique interface ID and a pair of channels
+    #[cfg(feature = "hyper")]
+    pub fn new_from_hyper_ws_io(
+        tx: SplitSink<
+            hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>,
+            hyper_tungstenite::tungstenite::Message,
+        >,
+        rx: SplitStream<hyper_tungstenite::WebSocketStream<hyper::upgrade::Upgraded>>,
+        format: FrameSerializationFormat,
+        inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    ) -> (Self, RemoteNetworkingServerDriver) {
+        let (tx_work, rx_work) = mpsc::unbounded_channel();
+
+        let tx = RemoteTx::HyperWebSocket {
+            tx: Arc::new(tokio::sync::Mutex::new(tx)),
+            work: tx_work,
+            wakers: RemoteTxWakers::default(),
+            format,
+        };
+        let rx = RemoteRx::HyperWebSocket { rx, format };
+        Self::new(tx, rx, rx_work, inner)
+    }
+}
+
+#[async_trait::async_trait]
+impl VirtualNetworking for RemoteNetworkingServer {
+    async fn bridge(
+        &self,
+        network: &str,
+        access_token: &str,
+        security: StreamSecurity,
+    ) -> Result<(), NetworkError> {
+        self.inner.bridge(network, access_token, security).await
+    }
+
+    async fn unbridge(&self) -> Result<(), NetworkError> {
+        self.inner.unbridge().await
+    }
+
+    async fn dhcp_acquire(&self) -> Result<Vec<IpAddr>, NetworkError> {
+        self.inner.dhcp_acquire().await
+    }
+
+    async fn ip_add(&self, ip: IpAddr, prefix: u8) -> Result<(), NetworkError> {
+        self.inner.ip_add(ip, prefix).await
+    }
+
+    async fn ip_remove(&self, ip: IpAddr) -> Result<(), NetworkError> {
+        self.inner.ip_remove(ip).await
+    }
+
+    async fn ip_clear(&self) -> Result<(), NetworkError> {
+        self.inner.ip_clear().await
+    }
+
+    async fn ip_list(&self) -> Result<Vec<IpCidr>, NetworkError> {
+        self.inner.ip_list().await
+    }
+
+    async fn mac(&self) -> Result<[u8; 6], NetworkError> {
+        self.inner.mac().await
+    }
+
+    async fn gateway_set(&self, ip: IpAddr) -> Result<(), NetworkError> {
+        self.inner.gateway_set(ip).await
+    }
+
+    async fn route_add(
+        &self,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> Result<(), NetworkError> {
+        self.inner
+            .route_add(cidr, via_router, preferred_until, expires_at)
+            .await
+    }
+
+    async fn route_remove(&self, cidr: IpAddr) -> Result<(), NetworkError> {
+        self.inner.route_remove(cidr).await
+    }
+
+    async fn route_clear(&self) -> Result<(), NetworkError> {
+        self.inner.route_clear().await
+    }
+
+    async fn route_list(&self) -> Result<Vec<IpRoute>, NetworkError> {
+        self.inner.route_list().await
+    }
+
+    async fn bind_raw(&self) -> Result<Box<dyn VirtualRawSocket + Sync>, NetworkError> {
+        self.inner.bind_raw().await
+    }
+
+    async fn listen_tcp(
+        &self,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualTcpListener + Sync>, NetworkError> {
+        self.inner
+            .listen_tcp(addr, only_v6, reuse_port, reuse_addr)
+            .await
+    }
+
+    async fn bind_udp(
+        &self,
+        addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualUdpSocket + Sync>, NetworkError> {
+        self.inner.bind_udp(addr, reuse_port, reuse_addr).await
+    }
+
+    async fn bind_icmp(
+        &self,
+        addr: IpAddr,
+    ) -> Result<Box<dyn VirtualIcmpSocket + Sync>, NetworkError> {
+        self.inner.bind_icmp(addr).await
+    }
+
+    async fn connect_tcp(
+        &self,
+        addr: SocketAddr,
+        peer: SocketAddr,
+    ) -> Result<Box<dyn VirtualTcpSocket + Sync>, NetworkError> {
+        self.inner.connect_tcp(addr, peer).await
+    }
+
+    async fn resolve(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    ) -> Result<Vec<IpAddr>, NetworkError> {
+        self.inner.resolve(host, port, dns_server).await
+    }
+}
+
+pin_project_lite::pin_project! {
+    pub struct RemoteNetworkingServerDriver {
+        common: Arc<RemoteAdapterCommon>,
+        more_work: mpsc::UnboundedReceiver<BoxFuture<'static, ()>>,
+        #[pin]
+        tasks: FuturesOrdered<BoxFuture<'static, ()>>,
+        inner: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    }
+}
+
+impl Future for RemoteNetworkingServerDriver {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        // We register the waker into the interest of the sockets so
+        // that it is woken when something is ready to read or write
+        let readable = {
+            let mut guard = self.common.handler.state.lock().unwrap();
+            if !guard.driver_wakers.iter().any(|w| w.will_wake(cx.waker())) {
+                guard.driver_wakers.push(cx.waker().clone());
+            }
+            guard.readable.drain().collect()
+        };
+        let readable: Vec<_> = readable;
+
+        {
+            // When a socket is marked as readable then we should drain all the data
+            // from it and start sending it to the client
+            let common = self.common.clone();
+            let mut guard = common.sockets.lock().unwrap();
+            for socket_id in readable {
+                if let Some(task) = guard
+                    .get_mut(&socket_id)
+                    .map(|s| s.drain_reads_and_accepts(&common, socket_id))
+                    .unwrap_or(None)
+                {
+                    self.tasks.push_back(task);
+                }
+            }
+        }
+
+        // This guard will be held while the pipeline is not currently
+        // stalled by some back pressure. It is only acquired when there
+        // is background tasks being processed
+        let mut not_stalled_guard = None;
+
+        // We loop until the waker is registered with the receiving stream
+        // and all the background tasks
+        loop {
+            // Background tasks are sent to this driver in certain circumstances
+            while let Poll::Ready(Some(work)) = Pin::new(&mut self.more_work).poll_recv(cx) {
+                self.tasks.push_back(work);
+            }
+
+            // Background work basically stalls the stream until its all processed
+            // which creates back pressure on the client so that they don't overload
+            // the system
+            match self.tasks.poll_next_unpin(cx) {
+                Poll::Ready(Some(_)) => continue,
+                Poll::Ready(None) => {
+                    not_stalled_guard.take();
+                }
+                Poll::Pending if not_stalled_guard.is_none() => {
+                    if let Ok(guard) = self.common.stall_rx.clone().try_lock_owned() {
+                        not_stalled_guard.replace(guard);
+                    } else {
+                        return Poll::Pending;
+                    }
+                }
+                Poll::Pending => {}
+            };
+
+            // We grab the next message sent by the client to us
+            let msg = {
+                let mut rx_guard = self.common.rx.lock().unwrap();
+                rx_guard.poll(cx)
+            };
+            return match msg {
+                Poll::Ready(Some(msg)) => {
+                    if let Some(task) = self.process(msg) {
+                        // With some messages we process there are background tasks that need to
+                        // be further driver to completion by the driver
+                        self.tasks.push_back(task)
+                    };
+                    continue;
+                }
+                Poll::Ready(None) => Poll::Ready(()),
+                Poll::Pending => Poll::Pending,
+            };
+        }
+    }
+}
+
+impl RemoteNetworkingServerDriver {
+    fn process(&mut self, msg: MessageRequest) -> BackgroundTask {
+        match msg {
+            MessageRequest::Send {
+                socket,
+                data,
+                req_id,
+            } => self.process_send(socket, data, req_id),
+            MessageRequest::SendTo {
+                socket,
+                data,
+                addr,
+                req_id,
+            } => self.process_send_to(socket, data, addr, req_id),
+            MessageRequest::Interface { req, req_id } => self.process_interface(req, req_id),
+            MessageRequest::Socket {
+                socket,
+                req,
+                req_id,
+            } => self.process_socket(socket, req, req_id),
+            MessageRequest::Reconnect => None,
+        }
+    }
+
+    fn process_send(
+        &mut self,
+        socket_id: SocketId,
+        data: Vec<u8>,
+        req_id: Option<u64>,
+    ) -> BackgroundTask {
+        let mut guard = self.common.sockets.lock().unwrap();
+        guard
+            .get_mut(&socket_id)
+            .map(|s| s.send(&self.common, socket_id, data, req_id))
+            .unwrap_or_else(|| {
+                tracing::debug!("orphaned socket {:?}", socket_id);
+                None
+            })
+    }
+
+    fn process_send_to(
+        &mut self,
+        socket_id: SocketId,
+        data: Vec<u8>,
+        addr: SocketAddr,
+        req_id: Option<u64>,
+    ) -> BackgroundTask {
+        let mut guard = self.common.sockets.lock().unwrap();
+        guard
+            .get_mut(&socket_id)
+            .map(|s| {
+                req_id.and_then(|req_id| s.send_to(&self.common, socket_id, data, addr, req_id))
+            })
+            .unwrap_or(None)
+    }
+
+    fn process_async<F>(future: F) -> BackgroundTask
+    where
+        F: Future<Output = BackgroundTask> + Send + 'static,
+    {
+        Some(Box::pin(async move {
+            let background_task = future.await;
+            if let Some(background_task) = background_task {
+                background_task.await;
+            }
+        }))
+    }
+
+    fn process_async_inner<F, Fut, T>(
+        &self,
+        work: F,
+        transmute: T,
+        req_id: Option<u64>,
+    ) -> BackgroundTask
+    where
+        F: FnOnce(Arc<dyn VirtualNetworking + Send + Sync>) -> Fut + Send + 'static,
+        Fut: Future + Send + 'static,
+        T: FnOnce(Fut::Output) -> ResponseType + Send + 'static,
+    {
+        let inner = self.inner.clone();
+        let common = self.common.clone();
+        Self::process_async(async move {
+            let future = work(inner);
+            let ret = future.await;
+            req_id.and_then(|req_id| {
+                common.send(MessageResponse::ResponseToRequest {
+                    req_id,
+                    res: transmute(ret),
+                })
+            })
+        })
+    }
+
+    fn process_async_noop<F, Fut>(&self, work: F, req_id: Option<u64>) -> BackgroundTask
+    where
+        F: FnOnce(Arc<dyn VirtualNetworking + Send + Sync>) -> Fut + Send + 'static,
+        Fut: Future<Output = Result<(), NetworkError>> + Send + 'static,
+    {
+        self.process_async_inner(
+            work,
+            move |ret| match ret {
+                Ok(()) => ResponseType::None,
+                Err(err) => ResponseType::Err(err),
+            },
+            req_id,
+        )
+    }
+
+    fn process_async_new_socket<F, Fut>(
+        &self,
+        work: F,
+        socket_id: SocketId,
+        req_id: Option<u64>,
+    ) -> BackgroundTask
+    where
+        F: FnOnce(Arc<dyn VirtualNetworking + Send + Sync>) -> Fut + Send + 'static,
+        Fut: Future<Output = Result<RemoteAdapterSocket, NetworkError>> + Send + 'static,
+    {
+        let common = self.common.clone();
+        self.process_async_inner(
+            work,
+            move |ret| match ret {
+                Ok(mut socket) => {
+                    let handler = Box::new(common.handler.clone().for_socket(socket_id));
+
+                    let err = match &mut socket {
+                        RemoteAdapterSocket::TcpListener { .. } => {
+                            // we do not attach the handler immediately with new TPC listeners as we
+                            // only want it to trigger when the BeginAccept message is received with
+                            // a child ID we can actually use
+                            Ok(())
+                        }
+                        RemoteAdapterSocket::TcpSocket(s) => s.set_handler(handler),
+                        RemoteAdapterSocket::UdpSocket(s) => s.set_handler(handler),
+                        RemoteAdapterSocket::IcmpSocket(s) => s.set_handler(handler),
+                        RemoteAdapterSocket::RawSocket(s) => s.set_handler(handler),
+                    };
+                    if let Err(err) = err {
+                        return ResponseType::Err(err);
+                    }
+
+                    let mut guard = common.sockets.lock().unwrap();
+                    guard.insert(socket_id, socket);
+
+                    ResponseType::Socket(socket_id)
+                }
+                Err(err) => ResponseType::Err(err),
+            },
+            req_id,
+        )
+    }
+
+    fn process_inner<F, R, T>(
+        &self,
+        work: F,
+        transmute: T,
+        socket_id: SocketId,
+        req_id: Option<u64>,
+    ) -> BackgroundTask
+    where
+        F: FnOnce(&mut RemoteAdapterSocket) -> R + Send + 'static,
+        T: FnOnce(R) -> ResponseType + Send + 'static,
+    {
+        let ret = {
+            let mut guard = self.common.sockets.lock().unwrap();
+            let socket = match guard.get_mut(&socket_id) {
+                Some(s) => s,
+                None => {
+                    return req_id.and_then(|req_id| {
+                        self.common.send(MessageResponse::ResponseToRequest {
+                            req_id,
+                            res: ResponseType::Err(NetworkError::InvalidFd),
+                        })
+                    })
+                }
+            };
+            work(socket)
+        };
+        req_id.and_then(|req_id| {
+            self.common.send(MessageResponse::ResponseToRequest {
+                req_id,
+                res: transmute(ret),
+            })
+        })
+    }
+
+    fn process_inner_noop<F>(
+        &self,
+        work: F,
+        socket_id: SocketId,
+        req_id: Option<u64>,
+    ) -> BackgroundTask
+    where
+        F: FnOnce(&mut RemoteAdapterSocket) -> Result<(), NetworkError> + Send + 'static,
+    {
+        self.process_inner(
+            work,
+            move |ret| match ret {
+                Ok(()) => ResponseType::None,
+                Err(err) => ResponseType::Err(err),
+            },
+            socket_id,
+            req_id,
+        )
+    }
+
+    fn process_inner_begin_accept(
+        &self,
+        socket_id: SocketId,
+        child_id: SocketId,
+        req_id: Option<u64>,
+    ) -> BackgroundTask {
+        // We record the child socket so it can be used on the next accepted socket
+        {
+            let mut guard = self.common.socket_accept.lock().unwrap();
+            guard.insert(socket_id, child_id);
+        }
+
+        // Now we attach the handler to the main listening socket
+        let mut handler = Box::new(self.common.handler.clone().for_socket(socket_id));
+        handler.push_interest(virtual_mio::InterestType::Readable);
+        self.process_inner_noop(
+            move |socket| match socket {
+                RemoteAdapterSocket::TcpListener {
+                    socket: s,
+                    next_accept,
+                    ..
+                } => {
+                    next_accept.replace(child_id);
+                    s.set_handler(handler)
+                }
+                _ => {
+                    // only the TCP listener needs its socket set as the other sockets
+                    // set their handlers when the socket is created instead. we need to
+                    // delay setting the handler so we have a child ID to use and return
+                    // to the client when a socket is accepted, thus we can not accept them
+                    // immediately
+                    Err(NetworkError::Unsupported)
+                }
+            },
+            socket_id,
+            req_id,
+        )
+    }
+
+    fn process_interface(&mut self, req: RequestType, req_id: Option<u64>) -> BackgroundTask {
+        match req {
+            RequestType::Bridge {
+                network,
+                access_token,
+                security,
+            } => self.process_async_noop(
+                move |inner| async move { inner.bridge(&network, &access_token, security).await },
+                req_id,
+            ),
+            RequestType::Unbridge => {
+                self.process_async_noop(move |inner| async move { inner.unbridge().await }, req_id)
+            }
+            RequestType::DhcpAcquire => self.process_async_inner(
+                move |inner| async move { inner.dhcp_acquire().await },
+                |ret| match ret {
+                    Ok(ips) => ResponseType::IpAddressList(ips),
+                    Err(err) => ResponseType::Err(err),
+                },
+                req_id,
+            ),
+            RequestType::IpAdd { ip, prefix } => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.ip_add(ip, prefix).await
+                },
+                req_id,
+            ),
+            RequestType::IpRemove(ip) => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.ip_remove(ip).await
+                },
+                req_id,
+            ),
+            RequestType::IpClear => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.ip_clear().await
+                },
+                req_id,
+            ),
+            RequestType::GetIpList => self.process_async_inner(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.ip_list().await
+                },
+                |ret| match ret {
+                    Ok(cidr) => ResponseType::CidrList(cidr),
+                    Err(err) => ResponseType::Err(err),
+                },
+                req_id,
+            ),
+            RequestType::GetMac => {
+                self.process_async_inner(
+                    move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                        inner.mac().await
+                    },
+                    |ret| match ret {
+                        Ok(mac) => ResponseType::Mac(mac),
+                        Err(err) => ResponseType::Err(err),
+                    },
+                    req_id,
+                )
+            }
+            RequestType::GatewaySet(ip) => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.gateway_set(ip).await
+                },
+                req_id,
+            ),
+            RequestType::RouteAdd {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            } => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner
+                        .route_add(cidr, via_router, preferred_until, expires_at)
+                        .await
+                },
+                req_id,
+            ),
+            RequestType::RouteRemove(ip) => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.route_remove(ip).await
+                },
+                req_id,
+            ),
+            RequestType::RouteClear => self.process_async_noop(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.route_clear().await
+                },
+                req_id,
+            ),
+            RequestType::GetRouteList => self.process_async_inner(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.route_list().await
+                },
+                |ret| match ret {
+                    Ok(routes) => ResponseType::RouteList(routes),
+                    Err(err) => ResponseType::Err(err),
+                },
+                req_id,
+            ),
+            RequestType::BindRaw(socket_id) => self.process_async_new_socket(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    Ok(RemoteAdapterSocket::RawSocket(inner.bind_raw().await?))
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::ListenTcp {
+                socket_id,
+                addr,
+                only_v6,
+                reuse_port,
+                reuse_addr,
+            } => self.process_async_new_socket(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    Ok(RemoteAdapterSocket::TcpListener {
+                        socket: inner
+                            .listen_tcp(addr, only_v6, reuse_port, reuse_addr)
+                            .await?,
+                        next_accept: None,
+                    })
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::BindUdp {
+                socket_id,
+                addr,
+                reuse_port,
+                reuse_addr,
+            } => self.process_async_new_socket(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    Ok(RemoteAdapterSocket::UdpSocket(
+                        inner.bind_udp(addr, reuse_port, reuse_addr).await?,
+                    ))
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::BindIcmp { socket_id, addr } => self.process_async_new_socket(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    Ok(RemoteAdapterSocket::IcmpSocket(
+                        inner.bind_icmp(addr).await?,
+                    ))
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::ConnectTcp {
+                socket_id,
+                addr,
+                peer,
+            } => self.process_async_new_socket(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    Ok(RemoteAdapterSocket::TcpSocket(
+                        inner.connect_tcp(addr, peer).await?,
+                    ))
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::Resolve {
+                host,
+                port,
+                dns_server,
+            } => self.process_async_inner(
+                move |inner: Arc<dyn VirtualNetworking + Send + Sync>| async move {
+                    inner.resolve(&host, port, dns_server).await
+                },
+                |ret| match ret {
+                    Ok(ips) => ResponseType::IpAddressList(ips),
+                    Err(err) => ResponseType::Err(err),
+                },
+                req_id,
+            ),
+            _ => req_id.and_then(|req_id| {
+                self.common.send(MessageResponse::ResponseToRequest {
+                    req_id,
+                    res: ResponseType::Err(NetworkError::Unsupported),
+                })
+            }),
+        }
+    }
+
+    fn process_socket(
+        &mut self,
+        socket_id: SocketId,
+        req: RequestType,
+        req_id: Option<u64>,
+    ) -> BackgroundTask {
+        match req {
+            RequestType::Flush => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.try_flush(),
+                    RemoteAdapterSocket::RawSocket(s) => s.try_flush(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::Close => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.close(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::BeginAccept(child_id) => {
+                self.process_inner_begin_accept(socket_id, child_id, req_id)
+            }
+            RequestType::GetAddrLocal => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.addr_local(),
+                    RemoteAdapterSocket::TcpListener { socket: s, .. } => s.addr_local(),
+                    RemoteAdapterSocket::UdpSocket(s) => s.addr_local(),
+                    RemoteAdapterSocket::IcmpSocket(s) => s.addr_local(),
+                    RemoteAdapterSocket::RawSocket(s) => s.addr_local(),
+                },
+                |ret| match ret {
+                    Ok(addr) => ResponseType::SocketAddr(addr),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetAddrPeer => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.addr_peer().map(Some),
+                    RemoteAdapterSocket::TcpListener { .. } => Err(NetworkError::Unsupported),
+                    RemoteAdapterSocket::UdpSocket(s) => s.addr_peer(),
+                    RemoteAdapterSocket::IcmpSocket(_) => Err(NetworkError::Unsupported),
+                    RemoteAdapterSocket::RawSocket(_) => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(Some(addr)) => ResponseType::SocketAddr(addr),
+                    Ok(None) => ResponseType::None,
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetTtl(ttl) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.set_ttl(ttl),
+                    RemoteAdapterSocket::TcpListener { socket: s, .. } => {
+                        s.set_ttl(ttl.try_into().unwrap_or_default())
+                    }
+                    RemoteAdapterSocket::UdpSocket(s) => s.set_ttl(ttl),
+                    RemoteAdapterSocket::IcmpSocket(s) => s.set_ttl(ttl),
+                    RemoteAdapterSocket::RawSocket(s) => s.set_ttl(ttl),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetTtl => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.ttl(),
+                    RemoteAdapterSocket::TcpListener { socket: s, .. } => s.ttl().map(|t| t as u32),
+                    RemoteAdapterSocket::UdpSocket(s) => s.ttl(),
+                    RemoteAdapterSocket::IcmpSocket(s) => s.ttl(),
+                    RemoteAdapterSocket::RawSocket(s) => s.ttl(),
+                },
+                |ret| match ret {
+                    Ok(ttl) => ResponseType::Ttl(ttl),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetStatus => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.status(),
+                    RemoteAdapterSocket::TcpListener { .. } => Err(NetworkError::Unsupported),
+                    RemoteAdapterSocket::UdpSocket(s) => s.status(),
+                    RemoteAdapterSocket::IcmpSocket(s) => s.status(),
+                    RemoteAdapterSocket::RawSocket(s) => s.status(),
+                },
+                |ret| match ret {
+                    Ok(status) => ResponseType::Status(status),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetLinger(linger) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.set_linger(linger),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetLinger => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.linger(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(Some(time)) => ResponseType::Duration(time),
+                    Ok(None) => ResponseType::None,
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetPromiscuous(promiscuous) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::RawSocket(s) => s.set_promiscuous(promiscuous),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetPromiscuous => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::RawSocket(s) => s.promiscuous(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetRecvBufSize(size) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => {
+                        s.set_recv_buf_size(size.try_into().unwrap_or_default())
+                    }
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetRecvBufSize => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.recv_buf_size(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(amt) => ResponseType::Amount(amt as u64),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetSendBufSize(size) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => {
+                        s.set_send_buf_size(size.try_into().unwrap_or_default())
+                    }
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetSendBufSize => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.send_buf_size(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(amt) => ResponseType::Amount(amt as u64),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetNoDelay(reuse) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.set_nodelay(reuse),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetNoDelay => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.nodelay(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetKeepAlive(val) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.set_keepalive(val),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetKeepAlive => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.keepalive(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetDontRoute(val) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.set_dontroute(val),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetDontRoute => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.dontroute(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::Shutdown(shutdown) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => s.shutdown(match shutdown {
+                        crate::meta::Shutdown::Read => std::net::Shutdown::Read,
+                        crate::meta::Shutdown::Write => std::net::Shutdown::Write,
+                        crate::meta::Shutdown::Both => std::net::Shutdown::Both,
+                    }),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::IsClosed => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::TcpSocket(s) => Ok(s.is_closed()),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetBroadcast(broadcast) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.set_broadcast(broadcast),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetBroadcast => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.broadcast(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetMulticastLoopV4(val) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.set_multicast_loop_v4(val),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetMulticastLoopV4 => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.multicast_loop_v4(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetMulticastLoopV6(val) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.set_multicast_loop_v6(val),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetMulticastLoopV6 => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.multicast_loop_v6(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(flag) => ResponseType::Flag(flag),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::SetMulticastTtlV4(ttl) => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.set_multicast_ttl_v4(ttl),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::GetMulticastTtlV4 => self.process_inner(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.multicast_ttl_v4(),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                |ret| match ret {
+                    Ok(ttl) => ResponseType::Ttl(ttl),
+                    Err(err) => ResponseType::Err(err),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::JoinMulticastV4 { multiaddr, iface } => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.join_multicast_v4(multiaddr, iface),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::LeaveMulticastV4 { multiaddr, iface } => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.leave_multicast_v4(multiaddr, iface),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::JoinMulticastV6 { multiaddr, iface } => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.join_multicast_v6(multiaddr, iface),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            RequestType::LeaveMulticastV6 { multiaddr, iface } => self.process_inner_noop(
+                move |socket| match socket {
+                    RemoteAdapterSocket::UdpSocket(s) => s.leave_multicast_v6(multiaddr, iface),
+                    _ => Err(NetworkError::Unsupported),
+                },
+                socket_id,
+                req_id,
+            ),
+            _ => req_id.and_then(|req_id| {
+                self.common.send(MessageResponse::ResponseToRequest {
+                    req_id,
+                    res: ResponseType::Err(NetworkError::Unsupported),
+                })
+            }),
+        }
+    }
+}
+
+enum RemoteAdapterSocket {
+    TcpListener {
+        socket: Box<dyn VirtualTcpListener + Sync + 'static>,
+        next_accept: Option<SocketId>,
+    },
+    TcpSocket(Box<dyn VirtualTcpSocket + Sync + 'static>),
+    UdpSocket(Box<dyn VirtualUdpSocket + Sync + 'static>),
+    RawSocket(Box<dyn VirtualRawSocket + Sync + 'static>),
+    IcmpSocket(Box<dyn VirtualIcmpSocket + Sync + 'static>),
+}
+
+impl RemoteAdapterSocket {
+    pub fn send(
+        &mut self,
+        common: &Arc<RemoteAdapterCommon>,
+        socket_id: SocketId,
+        data: Vec<u8>,
+        req_id: Option<u64>,
+    ) -> BackgroundTask {
+        match self {
+            Self::TcpSocket(this) => match this.try_send(&data) {
+                Ok(amount) => {
+                    if let Some(req_id) = req_id {
+                        common.send(MessageResponse::Sent {
+                            socket_id,
+                            req_id,
+                            amount: amount as u64,
+                        })
+                    } else {
+                        None
+                    }
+                }
+                Err(NetworkError::WouldBlock) => {
+                    let common = common.clone();
+                    Some(Box::pin(async move {
+                        // We will stall the receiver so that back pressure is sent back to the
+                        // sender and they don't overwhelm us with transmitting data.
+                        let _stall_rx = common.stall_rx.clone().lock_owned().await;
+
+                        // We use a poller here that uses the handler to wake itself up
+                        struct Poller {
+                            common: Arc<RemoteAdapterCommon>,
+                            socket_id: SocketId,
+                            data: Vec<u8>,
+                            req_id: Option<u64>,
+                        }
+                        impl Future for Poller {
+                            type Output = BackgroundTask;
+                            fn poll(
+                                self: Pin<&mut Self>,
+                                cx: &mut Context<'_>,
+                            ) -> Poll<Self::Output> {
+                                // We make sure the waker is registered with the interest driver which will
+                                // wake up this poller when there is writeability
+                                let mut guard = self.common.handler.state.lock().unwrap();
+                                if !guard.driver_wakers.iter().any(|w| w.will_wake(cx.waker())) {
+                                    guard.driver_wakers.push(cx.waker().clone());
+                                }
+                                drop(guard);
+
+                                let mut guard = self.common.sockets.lock().unwrap();
+                                if let Some(RemoteAdapterSocket::TcpSocket(socket)) =
+                                    guard.get_mut(&self.socket_id)
+                                {
+                                    match socket.try_send(&self.data) {
+                                        Ok(amount) => {
+                                            if let Some(req_id) = self.req_id {
+                                                return Poll::Ready(self.common.send(
+                                                    MessageResponse::Sent {
+                                                        socket_id: self.socket_id,
+                                                        req_id,
+                                                        amount: amount as u64,
+                                                    },
+                                                ));
+                                            } else {
+                                                return Poll::Ready(None);
+                                            }
+                                        }
+                                        Err(NetworkError::WouldBlock) => return Poll::Pending,
+                                        Err(error) => {
+                                            if let Some(req_id) = self.req_id {
+                                                return Poll::Ready(self.common.send(
+                                                    MessageResponse::SendError {
+                                                        socket_id: self.socket_id,
+                                                        req_id,
+                                                        error,
+                                                    },
+                                                ));
+                                            } else {
+                                                return Poll::Ready(None);
+                                            }
+                                        }
+                                    }
+                                }
+                                Poll::Ready(None)
+                            }
+                        }
+
+                        // Run the poller until this message is sent, or the socket fails
+                        let background_task = Poller {
+                            common,
+                            socket_id,
+                            data,
+                            req_id,
+                        }
+                        .await;
+
+                        // There might be more work left to finish off the send operation
+                        if let Some(background_task) = background_task {
+                            background_task.await;
+                        }
+                    }))
+                }
+                Err(error) => {
+                    if let Some(req_id) = req_id {
+                        common.send(MessageResponse::SendError {
+                            socket_id,
+                            req_id,
+                            error,
+                        })
+                    } else {
+                        None
+                    }
+                }
+            },
+            Self::RawSocket(this) => {
+                // when the RAW socket is overloaded we just silently drop the packet
+                // rather than buffering it and retrying later - Ethernet packets are
+                // not lossless. In reality most socket drivers under this remote socket
+                // will always succeed on `try_send` with RawSockets as they are always
+                // processed.
+                if let Err(err) = this.try_send(&data) {
+                    tracing::debug!("failed to send raw packet - {}", err);
+                }
+                None
+            }
+            _ => {
+                if let Some(req_id) = req_id {
+                    common.send(MessageResponse::SendError {
+                        socket_id,
+                        req_id,
+                        error: NetworkError::Unsupported,
+                    })
+                } else {
+                    None
+                }
+            }
+        }
+    }
+    pub fn send_to(
+        &mut self,
+        common: &Arc<RemoteAdapterCommon>,
+        socket_id: SocketId,
+        data: Vec<u8>,
+        addr: SocketAddr,
+        req_id: u64,
+    ) -> BackgroundTask {
+        match self {
+            Self::UdpSocket(this) => {
+                // when the UDP socket is overloaded we just silently drop the packet
+                // rather than buffering it and retrying later
+                this.try_send_to(&data, addr).ok();
+                None
+            }
+
+            Self::IcmpSocket(this) => {
+                // when the ICMP socket is overloaded we just silently drop the packet
+                // rather than buffering it and retrying later
+                this.try_send_to(&data, addr).ok();
+                None
+            }
+            _ => common.send(MessageResponse::SendError {
+                socket_id,
+                req_id,
+                error: NetworkError::Unsupported,
+            }),
+        }
+    }
+    pub fn drain_reads_and_accepts(
+        &mut self,
+        common: &Arc<RemoteAdapterCommon>,
+        socket_id: SocketId,
+    ) -> BackgroundTask {
+        // We loop reading the socket until all the pending reads are either
+        // being processed in a background task or they are empty
+        let mut ret: FuturesOrdered<BoxFuture<'static, ()>> = Default::default();
+        loop {
+            break match self {
+                Self::TcpListener {
+                    socket,
+                    next_accept,
+                } => {
+                    if next_accept.is_some() {
+                        match socket.try_accept() {
+                            Ok((mut child_socket, addr)) => {
+                                let child_id = next_accept.take().unwrap();
+
+                                // We set the handler on the socket so that it can
+                                let handler = Box::new(common.handler.clone().for_socket(child_id));
+                                child_socket.set_handler(handler).ok();
+
+                                // We will fix up the socket in the background then notify
+                                // the client of the new socket
+                                let common = common.clone();
+                                ret.push_back(Box::pin(async move {
+                                    // Next we record the socket so that it is active
+                                    {
+                                        let child_socket =
+                                            RemoteAdapterSocket::TcpSocket(child_socket);
+                                        let mut guard = common.sockets.lock().unwrap();
+                                        guard.insert(child_id, child_socket);
+                                    }
+
+                                    // Lastly we tell the client about the new socket
+                                    if let Some(task) = common.send(MessageResponse::FinishAccept {
+                                        socket_id,
+                                        child_id,
+                                        addr,
+                                    }) {
+                                        task.await;
+                                    }
+                                }));
+                            }
+                            Err(NetworkError::WouldBlock) => {}
+                            Err(err) => {
+                                tracing::error!("failed to accept socket - {}", err);
+                            }
+                        }
+                    }
+                }
+                Self::TcpSocket(this) => {
+                    let mut chunk: [MaybeUninit<u8>; 10240] =
+                        unsafe { MaybeUninit::uninit().assume_init() };
+                    match this.try_recv(&mut chunk) {
+                        Ok(0) => {}
+                        Ok(amt) => {
+                            let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
+                            let chunk_unsafe: &mut [u8] =
+                                unsafe { std::mem::transmute(chunk_unsafe) };
+                            if let Some(task) = common.send(MessageResponse::Recv {
+                                socket_id,
+                                data: chunk_unsafe.to_vec(),
+                            }) {
+                                ret.push_back(task);
+                            }
+                            continue;
+                        }
+                        Err(_) => {}
+                    }
+                }
+                Self::UdpSocket(this) => {
+                    let mut chunk: [MaybeUninit<u8>; 10240] =
+                        unsafe { MaybeUninit::uninit().assume_init() };
+                    match this.try_recv_from(&mut chunk) {
+                        Ok((0, _)) => {}
+                        Ok((amt, addr)) => {
+                            let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
+                            let chunk_unsafe: &mut [u8] =
+                                unsafe { std::mem::transmute(chunk_unsafe) };
+                            if let Some(task) = common.send(MessageResponse::RecvWithAddr {
+                                socket_id,
+                                data: chunk_unsafe.to_vec(),
+                                addr,
+                            }) {
+                                ret.push_back(task);
+                            }
+                            continue;
+                        }
+                        Err(_) => {}
+                    }
+                }
+                Self::IcmpSocket(this) => {
+                    let mut chunk: [MaybeUninit<u8>; 10240] =
+                        unsafe { MaybeUninit::uninit().assume_init() };
+                    match this.try_recv_from(&mut chunk) {
+                        Ok((0, _)) => {}
+                        Ok((amt, addr)) => {
+                            let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
+                            let chunk_unsafe: &mut [u8] =
+                                unsafe { std::mem::transmute(chunk_unsafe) };
+                            if let Some(task) = common.send(MessageResponse::RecvWithAddr {
+                                socket_id,
+                                data: chunk_unsafe.to_vec(),
+                                addr,
+                            }) {
+                                ret.push_back(task);
+                            }
+                            continue;
+                        }
+                        Err(_) => {}
+                    }
+                }
+                Self::RawSocket(this) => {
+                    let mut chunk: [MaybeUninit<u8>; 10240] =
+                        unsafe { MaybeUninit::uninit().assume_init() };
+                    match this.try_recv(&mut chunk) {
+                        Ok(0) => {}
+                        Ok(amt) => {
+                            let chunk_unsafe: &mut [MaybeUninit<u8>] = &mut chunk[..amt];
+                            let chunk_unsafe: &mut [u8] =
+                                unsafe { std::mem::transmute(chunk_unsafe) };
+                            if let Some(task) = common.send(MessageResponse::Recv {
+                                socket_id,
+                                data: chunk_unsafe.to_vec(),
+                            }) {
+                                ret.push_back(task);
+                            }
+                            continue;
+                        }
+                        Err(_) => {}
+                    }
+                }
+            };
+        }
+
+        if ret.is_empty() {
+            // There is nothing to process so we are done
+            None
+        } else {
+            Some(Box::pin(async move {
+                // Processes all the background tasks until completion
+                let mut stream = ret;
+                loop {
+                    let (next, s) = stream.into_future().await;
+                    if next.is_none() {
+                        break;
+                    }
+                    stream = s;
+                }
+            }))
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct RemoteAdapterHandlerState {
+    readable: HashSet<SocketId>,
+    driver_wakers: Vec<Waker>,
+}
+
+#[derive(Debug, Default, Clone)]
+struct RemoteAdapterHandler {
+    socket_id: Option<SocketId>,
+    state: Arc<Mutex<RemoteAdapterHandlerState>>,
+}
+impl RemoteAdapterHandler {
+    pub fn for_socket(self, id: SocketId) -> Self {
+        Self {
+            socket_id: Some(id),
+            state: self.state,
+        }
+    }
+}
+impl InterestHandler for RemoteAdapterHandler {
+    fn push_interest(&mut self, interest: virtual_mio::InterestType) {
+        let mut guard = self.state.lock().unwrap();
+        guard.driver_wakers.drain(..).for_each(|w| w.wake());
+        let socket_id = match self.socket_id {
+            Some(s) => s,
+            None => return,
+        };
+        if interest == virtual_mio::InterestType::Readable {
+            guard.readable.insert(socket_id);
+        }
+    }
+
+    fn pop_interest(&mut self, interest: virtual_mio::InterestType) -> bool {
+        let mut guard = self.state.lock().unwrap();
+        let socket_id = match self.socket_id {
+            Some(s) => s,
+            None => return false,
+        };
+        if interest == virtual_mio::InterestType::Readable {
+            return guard.readable.remove(&socket_id);
+        }
+        false
+    }
+
+    fn has_interest(&self, interest: virtual_mio::InterestType) -> bool {
+        let guard = self.state.lock().unwrap();
+        let socket_id = match self.socket_id {
+            Some(s) => s,
+            None => return false,
+        };
+        if interest == virtual_mio::InterestType::Readable {
+            return guard.readable.contains(&socket_id);
+        }
+        false
+    }
+}
+
+type SocketMap<T> = HashMap<SocketId, T>;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+struct RemoteAdapterCommon {
+    #[derivative(Debug = "ignore")]
+    tx: RemoteTx<MessageResponse>,
+    #[derivative(Debug = "ignore")]
+    rx: Mutex<RemoteRx<MessageRequest>>,
+    #[derivative(Debug = "ignore")]
+    sockets: Mutex<SocketMap<RemoteAdapterSocket>>,
+    socket_accept: Mutex<SocketMap<SocketId>>,
+    handler: RemoteAdapterHandler,
+
+    // The stall guard will prevent reads while its held and there are background tasks running
+    // (the idea behind this is to create back pressure so that the task list infinitely grow)
+    stall_rx: Arc<tokio::sync::Mutex<()>>,
+}
+impl RemoteAdapterCommon {
+    fn send(self: &Arc<Self>, req: MessageResponse) -> BackgroundTask {
+        let this = self.clone();
+        Some(Box::pin(async move {
+            if let Err(err) = this.tx.send(req).await {
+                tracing::debug!("failed to send message - {}", err);
+            }
+        }))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tcp_pair.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tcp_pair.rs
new file mode 100644
index 0000000..567d4c1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tcp_pair.rs
@@ -0,0 +1,633 @@
+use crate::{
+    net_error_into_io_err, InterestHandler, NetworkError, SocketStatus, VirtualConnectedSocket,
+    VirtualIoSource, VirtualSocket, VirtualTcpSocket,
+};
+use bytes::{Buf, Bytes};
+use futures_util::Future;
+use smoltcp::storage::RingBuffer;
+use std::io::{self};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::task::{Context, Waker};
+use std::time::Duration;
+use std::{net::SocketAddr, task::Poll};
+use tokio::io::{AsyncBufRead, AsyncRead, AsyncWrite, BufReader};
+use virtual_mio::{ArcInterestHandler, InterestType};
+
+#[derive(Debug)]
+struct SocketBufferState {
+    buffer: RingBuffer<'static, u8>,
+    push_handler: Option<ArcInterestHandler>,
+    pull_handler: Option<ArcInterestHandler>,
+    wakers: Vec<Waker>,
+    dead: bool,
+    // This flag prevents a poll write ready storm
+    halt_immediate_poll_write: bool,
+}
+
+impl SocketBufferState {
+    fn add_waker(&mut self, waker: &Waker) {
+        if !self.wakers.iter().any(|w| w.will_wake(waker)) {
+            self.wakers.push(waker.clone());
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct SocketBuffer {
+    state: Arc<Mutex<SocketBufferState>>,
+    dead_on_drop: bool,
+}
+
+impl Drop for SocketBuffer {
+    fn drop(&mut self) {
+        if self.dead_on_drop {
+            self.set_dead();
+        }
+    }
+}
+
+impl SocketBuffer {
+    fn new(max_size: usize) -> Self {
+        Self {
+            state: Arc::new(Mutex::new(SocketBufferState {
+                buffer: RingBuffer::new(vec![0; max_size]),
+                push_handler: None,
+                pull_handler: None,
+                wakers: Vec::new(),
+                dead: false,
+                halt_immediate_poll_write: false,
+            })),
+            dead_on_drop: false,
+        }
+    }
+
+    pub fn set_push_handler(&self, mut handler: ArcInterestHandler) {
+        let mut state = self.state.lock().unwrap();
+        if state.dead {
+            handler.push_interest(InterestType::Closed);
+        }
+        if !state.buffer.is_empty() {
+            handler.push_interest(InterestType::Readable);
+        }
+        state.push_handler.replace(handler);
+    }
+
+    pub fn set_pull_handler(&self, mut handler: ArcInterestHandler) {
+        let mut state = self.state.lock().unwrap();
+        if state.dead {
+            handler.push_interest(InterestType::Closed);
+        }
+        if !state.buffer.is_full() && state.pull_handler.is_none() {
+            handler.push_interest(InterestType::Writable);
+        }
+        state.pull_handler.replace(handler);
+    }
+
+    pub fn clear_push_handler(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.push_handler.take();
+    }
+
+    pub fn clear_pull_handler(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.pull_handler.take();
+    }
+
+    pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        let mut state = self.state.lock().unwrap();
+        if !state.buffer.is_empty() {
+            return Poll::Ready(Ok(state.buffer.len()));
+        }
+        if state.dead {
+            return Poll::Ready(Ok(0));
+        }
+        if !state.wakers.iter().any(|w| w.will_wake(cx.waker())) {
+            state.wakers.push(cx.waker().clone());
+        }
+        Poll::Pending
+    }
+
+    pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        let mut state = self.state.lock().unwrap();
+        if state.dead {
+            return Poll::Ready(Ok(0));
+        }
+        if !state.buffer.is_full() && !state.halt_immediate_poll_write {
+            state.halt_immediate_poll_write = true;
+            return Poll::Ready(Ok(state.buffer.window()));
+        }
+        if !state.wakers.iter().any(|w| w.will_wake(cx.waker())) {
+            state.wakers.push(cx.waker().clone());
+        }
+        Poll::Pending
+    }
+
+    pub fn set_dead(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.dead = true;
+        if let Some(handler) = state.pull_handler.as_mut() {
+            handler.push_interest(InterestType::Closed);
+        }
+        if let Some(handler) = state.push_handler.as_mut() {
+            handler.push_interest(InterestType::Closed);
+        }
+        state.wakers.drain(..).for_each(|w| w.wake());
+    }
+
+    pub fn is_dead(&self) -> bool {
+        let state = self.state.lock().unwrap();
+        state.dead
+    }
+
+    pub fn try_send(
+        &self,
+        data: &[u8],
+        all_or_nothing: bool,
+        waker: Option<&Waker>,
+    ) -> crate::Result<usize> {
+        let mut state = self.state.lock().unwrap();
+        if state.dead {
+            return Err(NetworkError::ConnectionReset);
+        }
+        state.halt_immediate_poll_write = false;
+        let available = state.buffer.window();
+        if available == 0 {
+            if let Some(waker) = waker {
+                state.add_waker(waker)
+            }
+            return Err(NetworkError::WouldBlock);
+        }
+        if data.len() > available {
+            if all_or_nothing {
+                if let Some(waker) = waker {
+                    state.add_waker(waker)
+                }
+                return Err(NetworkError::WouldBlock);
+            }
+            let amt = state.buffer.enqueue_slice(&data[..available]);
+            return Ok(amt);
+        }
+        let amt = state.buffer.enqueue_slice(data);
+
+        if let Some(handler) = state.push_handler.as_mut() {
+            handler.push_interest(InterestType::Readable);
+        }
+        state.wakers.drain(..).for_each(|w| w.wake());
+        Ok(amt)
+    }
+
+    pub async fn send(&self, data: Bytes) -> crate::Result<()> {
+        struct Poller<'a> {
+            this: &'a SocketBuffer,
+            data: Bytes,
+        }
+        impl<'a> Future for Poller<'a> {
+            type Output = crate::Result<()>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                loop {
+                    if self.data.is_empty() {
+                        return Poll::Ready(Ok(()));
+                    }
+                    return match self.this.try_send(&self.data, false, Some(cx.waker())) {
+                        Ok(amt) => {
+                            self.data.advance(amt);
+                            continue;
+                        }
+                        Err(NetworkError::WouldBlock) => Poll::Pending,
+                        Err(err) => Poll::Ready(Err(err)),
+                    };
+                }
+            }
+        }
+        Poller { this: self, data }.await
+    }
+
+    pub fn try_read(
+        &self,
+        buf: &mut [std::mem::MaybeUninit<u8>],
+        waker: Option<&Waker>,
+    ) -> crate::Result<usize> {
+        let mut state = self.state.lock().unwrap();
+        if state.buffer.is_empty() {
+            if state.dead {
+                return Err(NetworkError::ConnectionReset);
+            }
+
+            if let Some(waker) = waker {
+                state.add_waker(waker)
+            }
+            return Err(NetworkError::WouldBlock);
+        }
+
+        let buf: &mut [u8] = unsafe { std::mem::transmute(buf) };
+        let amt = buf.len().min(state.buffer.len());
+        let amt = state.buffer.dequeue_slice(&mut buf[..amt]);
+
+        if let Some(handler) = state.pull_handler.as_mut() {
+            handler.push_interest(InterestType::Writable);
+        }
+        state.wakers.drain(..).for_each(|w| w.wake());
+        Ok(amt)
+    }
+
+    pub fn set_max_size(&self, new_size: usize) {
+        let mut state = self.state.lock().unwrap();
+        state.halt_immediate_poll_write = false;
+
+        let mut existing: Vec<u8> = vec![0; state.buffer.len()];
+        if !state.buffer.is_empty() {
+            let amt = state.buffer.dequeue_slice(&mut existing[..]);
+            existing.resize(amt, 0);
+        }
+
+        state.buffer = RingBuffer::new(vec![0; new_size]);
+        if !existing.is_empty() {
+            let _ = state.buffer.enqueue_slice(&existing[..]);
+        }
+    }
+
+    pub fn max_size(&self) -> usize {
+        let state = self.state.lock().unwrap();
+        state.buffer.capacity()
+    }
+}
+
+impl AsyncWrite for SocketBuffer {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        match self.try_send(buf, false, Some(cx.waker())) {
+            Ok(amt) => Poll::Ready(Ok(amt)),
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        self.set_dead();
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncRead for SocketBuffer {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        match self.try_read(unsafe { buf.unfilled_mut() }, Some(cx.waker())) {
+            Ok(amt) => {
+                unsafe { buf.assume_init(amt) };
+                buf.advance(amt);
+                Poll::Ready(Ok(()))
+            }
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct TcpSocketHalf {
+    addr_local: SocketAddr,
+    addr_peer: SocketAddr,
+    tx: SocketBuffer,
+    rx: SocketBuffer,
+    ttl: u32,
+}
+
+impl TcpSocketHalf {
+    pub fn channel(
+        max_buffer_size: usize,
+        addr1: SocketAddr,
+        addr2: SocketAddr,
+    ) -> (TcpSocketHalf, TcpSocketHalf) {
+        let mut buffer1 = SocketBuffer::new(max_buffer_size);
+        buffer1.dead_on_drop = true;
+
+        let mut buffer2 = SocketBuffer::new(max_buffer_size);
+        buffer2.dead_on_drop = true;
+
+        let half1 = Self {
+            tx: buffer1.clone(),
+            rx: buffer2.clone(),
+            addr_local: addr1,
+            addr_peer: addr2,
+            ttl: 64,
+        };
+        let half2 = Self {
+            tx: buffer2,
+            rx: buffer1,
+            addr_local: addr2,
+            addr_peer: addr1,
+            ttl: 64,
+        };
+        (half1, half2)
+    }
+
+    pub fn is_active(&self) -> bool {
+        !self.tx.is_dead()
+    }
+
+    pub fn close(&self) -> crate::Result<()> {
+        self.tx.set_dead();
+        self.rx.set_dead();
+        Ok(())
+    }
+}
+
+impl VirtualIoSource for TcpSocketHalf {
+    fn remove_handler(&mut self) {
+        self.tx.clear_pull_handler();
+        self.rx.clear_push_handler();
+    }
+
+    fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        self.rx.poll_read_ready(cx)
+    }
+
+    fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<crate::Result<usize>> {
+        self.tx.poll_write_ready(cx)
+    }
+}
+
+impl VirtualSocket for TcpSocketHalf {
+    fn set_ttl(&mut self, ttl: u32) -> crate::Result<()> {
+        self.ttl = ttl;
+        Ok(())
+    }
+
+    fn ttl(&self) -> crate::Result<u32> {
+        Ok(self.ttl)
+    }
+
+    fn addr_local(&self) -> crate::Result<SocketAddr> {
+        Ok(self.addr_local)
+    }
+
+    fn status(&self) -> crate::Result<SocketStatus> {
+        Ok(if self.tx.is_dead() {
+            SocketStatus::Closed
+        } else {
+            SocketStatus::Opened
+        })
+    }
+
+    fn set_handler(
+        &mut self,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+    ) -> crate::Result<()> {
+        let handler = ArcInterestHandler::new(handler);
+        self.tx.set_pull_handler(handler.clone());
+        self.rx.set_push_handler(handler);
+        Ok(())
+    }
+}
+
+impl VirtualConnectedSocket for TcpSocketHalf {
+    fn set_linger(&mut self, _linger: Option<Duration>) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn linger(&self) -> crate::Result<Option<Duration>> {
+        Ok(None)
+    }
+
+    fn try_send(&mut self, data: &[u8]) -> crate::Result<usize> {
+        self.tx.try_send(data, false, None)
+    }
+
+    fn try_flush(&mut self) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn close(&mut self) -> crate::Result<()> {
+        self.tx.set_dead();
+        self.rx.set_dead();
+        Ok(())
+    }
+
+    fn try_recv(&mut self, buf: &mut [std::mem::MaybeUninit<u8>]) -> crate::Result<usize> {
+        self.rx.try_read(buf, None)
+    }
+}
+
+impl VirtualTcpSocket for TcpSocketHalf {
+    fn set_recv_buf_size(&mut self, size: usize) -> crate::Result<()> {
+        self.rx.set_max_size(size);
+        Ok(())
+    }
+
+    fn recv_buf_size(&self) -> crate::Result<usize> {
+        Ok(self.rx.max_size())
+    }
+
+    fn set_send_buf_size(&mut self, size: usize) -> crate::Result<()> {
+        self.tx.set_max_size(size);
+        Ok(())
+    }
+
+    fn send_buf_size(&self) -> crate::Result<usize> {
+        Ok(self.tx.max_size())
+    }
+
+    fn set_nodelay(&mut self, _reuse: bool) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn nodelay(&self) -> crate::Result<bool> {
+        Ok(true)
+    }
+
+    fn set_keepalive(&mut self, _keepalive: bool) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn keepalive(&self) -> crate::Result<bool> {
+        Ok(false)
+    }
+
+    fn set_dontroute(&mut self, _keepalive: bool) -> crate::Result<()> {
+        Ok(())
+    }
+
+    fn dontroute(&self) -> crate::Result<bool> {
+        Ok(false)
+    }
+
+    fn addr_peer(&self) -> crate::Result<SocketAddr> {
+        Ok(self.addr_peer)
+    }
+
+    fn shutdown(&mut self, how: std::net::Shutdown) -> crate::Result<()> {
+        match how {
+            std::net::Shutdown::Both => {
+                self.tx.set_dead();
+                self.rx.set_dead();
+            }
+            std::net::Shutdown::Read => {
+                self.rx.set_dead();
+            }
+            std::net::Shutdown::Write => {
+                self.tx.set_dead();
+            }
+        }
+        Ok(())
+    }
+
+    fn is_closed(&self) -> bool {
+        self.tx.is_dead()
+    }
+}
+
+#[allow(unused)]
+#[derive(Debug)]
+pub struct TcpSocketHalfTx {
+    addr_local: SocketAddr,
+    addr_peer: SocketAddr,
+    tx: SocketBuffer,
+    ttl: u32,
+}
+
+impl TcpSocketHalfTx {
+    pub fn poll_send(&self, cx: &mut Context<'_>, data: &[u8]) -> Poll<io::Result<usize>> {
+        match self.tx.try_send(data, false, Some(cx.waker())) {
+            Ok(amt) => Poll::Ready(Ok(amt)),
+            Err(NetworkError::WouldBlock) => Poll::Pending,
+            Err(err) => Poll::Ready(Err(net_error_into_io_err(err))),
+        }
+    }
+
+    pub fn try_send(&self, data: &[u8]) -> io::Result<usize> {
+        self.tx
+            .try_send(data, false, None)
+            .map_err(net_error_into_io_err)
+    }
+
+    pub async fn send_ext(&self, data: Bytes, non_blocking: bool) -> io::Result<()> {
+        if non_blocking {
+            self.tx
+                .try_send(&data, true, None)
+                .map_err(net_error_into_io_err)
+                .map(|_| ())
+        } else {
+            self.tx.send(data).await.map_err(net_error_into_io_err)
+        }
+    }
+
+    pub async fn send(&self, data: Bytes) -> io::Result<()> {
+        self.send_ext(data, false).await
+    }
+
+    pub fn close(&self) -> crate::Result<()> {
+        self.tx.set_dead();
+        Ok(())
+    }
+}
+
+impl AsyncWrite for TcpSocketHalfTx {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        Pin::new(&mut self.tx).poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        Pin::new(&mut self.tx).poll_flush(cx)
+    }
+
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        Pin::new(&mut self.tx).poll_shutdown(cx)
+    }
+}
+
+#[allow(unused)]
+#[derive(Debug)]
+pub struct TcpSocketHalfRx {
+    addr_local: SocketAddr,
+    addr_peer: SocketAddr,
+    rx: BufReader<SocketBuffer>,
+    ttl: u32,
+}
+
+impl TcpSocketHalfRx {
+    pub fn buffer(&self) -> &[u8] {
+        self.rx.buffer()
+    }
+
+    pub fn close(&mut self) -> crate::Result<()> {
+        self.rx.get_mut().set_dead();
+        Ok(())
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn inner(&mut self) -> &BufReader<SocketBuffer> {
+        &self.rx
+    }
+
+    #[allow(dead_code)]
+    pub(crate) fn inner_mut(&mut self) -> &mut BufReader<SocketBuffer> {
+        &mut self.rx
+    }
+}
+
+impl AsyncRead for TcpSocketHalfRx {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Pin::new(&mut self.rx).poll_read(cx, buf)
+    }
+}
+
+impl TcpSocketHalfRx {
+    pub fn poll_fill_buf(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
+        Pin::new(&mut self.rx).poll_fill_buf(cx)
+    }
+
+    pub fn consume(&mut self, amt: usize) {
+        Pin::new(&mut self.rx).consume(amt)
+    }
+}
+
+impl TcpSocketHalf {
+    pub fn split(self) -> (TcpSocketHalfTx, TcpSocketHalfRx) {
+        let tx = TcpSocketHalfTx {
+            tx: self.tx,
+            addr_local: self.addr_local,
+            addr_peer: self.addr_peer,
+            ttl: self.ttl,
+        };
+        let rx = TcpSocketHalfRx {
+            rx: BufReader::new(self.rx),
+            addr_local: self.addr_local,
+            addr_peer: self.addr_peer,
+            ttl: self.ttl,
+        };
+        (tx, rx)
+    }
+
+    pub fn combine(tx: TcpSocketHalfTx, rx: TcpSocketHalfRx) -> Self {
+        Self {
+            tx: tx.tx,
+            rx: rx.rx.into_inner(),
+            addr_local: tx.addr_local,
+            addr_peer: tx.addr_peer,
+            ttl: tx.ttl,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tests.rs b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tests.rs
new file mode 100644
index 0000000..2449982
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/virtual-net/src/tests.rs
@@ -0,0 +1,474 @@
+#![allow(unused)]
+use std::{
+    net::{Ipv4Addr, SocketAddrV4},
+    sync::atomic::{AtomicU16, Ordering},
+};
+
+use tracing_test::traced_test;
+
+#[cfg(feature = "remote")]
+use crate::RemoteNetworkingServer;
+use crate::{
+    host::LocalNetworking, meta::FrameSerializationFormat, VirtualConnectedSocketExt,
+    VirtualTcpListenerExt,
+};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+use super::*;
+
+#[cfg(feature = "remote")]
+async fn setup_mpsc() -> (RemoteNetworkingClient, RemoteNetworkingServer) {
+    tracing::info!("building MPSC channels");
+    let (tx1, rx1) = tokio::sync::mpsc::channel(100);
+    let (tx2, rx2) = tokio::sync::mpsc::channel(100);
+
+    tracing::info!("constructing remote client (mpsc)");
+    let (client, client_driver) = RemoteNetworkingClient::new_from_mpsc(tx1, rx2);
+
+    tracing::info!("spawning driver for remote client");
+    tokio::task::spawn(client_driver);
+
+    tracing::info!("create local networking provider");
+    let local_networking = LocalNetworking::new();
+
+    tracing::info!("constructing remote server (mpsc)");
+    let (server, server_driver) =
+        RemoteNetworkingServer::new_from_mpsc(tx2, rx1, Arc::new(local_networking));
+
+    tracing::info!("spawning driver for remote server");
+    tokio::task::spawn(server_driver);
+
+    (client, server)
+}
+
+#[cfg(feature = "remote")]
+async fn setup_pipe(
+    buf_size: usize,
+    format: FrameSerializationFormat,
+) -> (RemoteNetworkingClient, RemoteNetworkingServer) {
+    tracing::info!("building duplex streams");
+    let (tx1, rx1) = tokio::io::duplex(buf_size);
+    let (tx2, rx2) = tokio::io::duplex(buf_size);
+
+    tracing::info!("constructing remote client (mpsc)");
+    let (client, client_driver) = RemoteNetworkingClient::new_from_async_io(tx1, rx2, format);
+
+    tracing::info!("spawning driver for remote client");
+    tokio::task::spawn(client_driver);
+
+    tracing::info!("create local networking provider");
+    let local_networking = LocalNetworking::new();
+
+    tracing::info!("constructing remote server (mpsc)");
+    let (server, server_driver) =
+        RemoteNetworkingServer::new_from_async_io(tx2, rx1, format, Arc::new(local_networking));
+
+    tracing::info!("spawning driver for remote server");
+    tokio::task::spawn(server_driver);
+
+    (client, server)
+}
+
+#[cfg(feature = "remote")]
+async fn test_tcp(client: RemoteNetworkingClient, _server: RemoteNetworkingServer) {
+    let mut listener = client
+        .listen_tcp(
+            SocketAddr::from((Ipv4Addr::LOCALHOST, 0)),
+            false,
+            false,
+            false,
+        )
+        .await
+        .unwrap();
+    let addr: SocketAddr = listener.addr_local().unwrap();
+    tracing::info!("listening on {addr}");
+
+    const TEST1: &str = "the cat ran up the wall!";
+    const TEST2: &str = "...and fell off the roof! raise the roof! oop oop";
+
+    tracing::info!("spawning acceptor worker thread");
+    tokio::task::spawn(async move {
+        tracing::info!("waiting for connection");
+        let (mut socket, addr) = listener.accept().await.unwrap();
+        tracing::info!("accepted connection from {addr}");
+
+        tracing::info!("receiving data from client");
+        let mut buf = [0u8; TEST1.len()];
+        socket.read_exact(&mut buf).await.unwrap();
+
+        let msg = String::from_utf8_lossy(&buf);
+        assert_eq!(msg.as_ref(), TEST1);
+
+        tracing::info!("sending back test string - {TEST2}");
+        socket.send(TEST2.as_bytes()).await.unwrap();
+    });
+
+    tracing::info!("connecting to listening socket");
+    let mut socket = client
+        .connect_tcp(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)), addr)
+        .await
+        .unwrap();
+
+    tracing::info!("sending test string - {TEST1}");
+    socket.write_all(TEST1.as_bytes()).await.unwrap();
+
+    tracing::info!("receiving data from server");
+    let mut buf = [0u8; TEST2.len()];
+    socket.read_exact(&mut buf).await.unwrap();
+
+    let msg = String::from_utf8_lossy(&buf);
+    assert_eq!(msg.as_ref(), TEST2);
+
+    tracing::info!("all good");
+}
+
+#[cfg(feature = "remote")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_mpsc() {
+    let (client, server) = setup_mpsc().await;
+    test_tcp(client, server).await
+}
+
+// Disabled on musl due to flakiness.
+// See https://github.com/wasmerio/wasmer/issues/4425
+#[cfg(not(target_env = "musl"))]
+#[cfg(feature = "remote")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_small_pipe_using_bincode() {
+    let (client, server) = setup_pipe(10, FrameSerializationFormat::Bincode).await;
+    test_tcp(client, server).await
+}
+
+#[cfg(feature = "remote")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_large_pipe_using_bincode() {
+    let (client, server) = setup_pipe(1024000, FrameSerializationFormat::Bincode).await;
+    test_tcp(client, server).await
+}
+
+// Disabled on musl due to flakiness.
+// See https://github.com/wasmerio/wasmer/issues/4425
+#[cfg(not(target_env = "musl"))]
+#[cfg(feature = "remote")]
+#[cfg(feature = "json")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_small_pipe_using_json() {
+    let (client, server) = setup_pipe(10, FrameSerializationFormat::Json).await;
+    test_tcp(client, server).await
+}
+
+#[cfg(feature = "remote")]
+#[cfg(feature = "json")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_large_pipe_json_using_json() {
+    let (client, server) = setup_pipe(1024000, FrameSerializationFormat::Json).await;
+    test_tcp(client, server).await
+}
+
+// Disabled on musl due to flakiness.
+// See https://github.com/wasmerio/wasmer/issues/4425
+#[cfg(not(target_env = "musl"))]
+#[cfg(feature = "remote")]
+#[cfg(feature = "messagepack")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_small_pipe_using_messagepack() {
+    let (client, server) = setup_pipe(10, FrameSerializationFormat::MessagePack).await;
+    test_tcp(client, server).await
+}
+
+// Disabled on musl due to flakiness.
+// See https://github.com/wasmerio/wasmer/issues/4425
+#[cfg(not(target_env = "musl"))]
+#[cfg(feature = "remote")]
+#[cfg(feature = "messagepack")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_large_pipe_json_using_messagepack() {
+    let (client, server) = setup_pipe(1024000, FrameSerializationFormat::MessagePack).await;
+    test_tcp(client, server).await
+}
+
+// Disabled on musl due to flakiness.
+// See https://github.com/wasmerio/wasmer/issues/4425
+#[cfg(not(target_env = "musl"))]
+#[cfg(feature = "remote")]
+#[cfg(feature = "cbor")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_small_pipe_using_cbor() {
+    let (client, server) = setup_pipe(10, FrameSerializationFormat::Cbor).await;
+    test_tcp(client, server).await
+}
+
+#[cfg(feature = "remote")]
+#[cfg(feature = "cbor")]
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test(flavor = "multi_thread")]
+#[serial_test::serial]
+async fn test_tcp_with_large_pipe_json_using_cbor() {
+    let (client, server) = setup_pipe(1024000, FrameSerializationFormat::Cbor).await;
+    test_tcp(client, server).await
+}
+
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test]
+#[serial_test::serial]
+async fn test_google_poll() {
+    use futures_util::Future;
+
+    // Resolve the address
+    tracing::info!("resolving www.google.com");
+    let networking = LocalNetworking::new();
+    let peer_addr = networking
+        .resolve("www.google.com", None, None)
+        .await
+        .unwrap()
+        .into_iter()
+        .next()
+        .expect("IP address should be returned");
+    tracing::info!("www.google.com = {}", peer_addr);
+
+    // Start the connection
+    tracing::info!("connecting to {}:80", peer_addr);
+    let mut socket = networking
+        .connect_tcp(
+            SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
+            SocketAddr::new(peer_addr, 80),
+        )
+        .await
+        .unwrap();
+    tracing::info!("setting nodelay");
+    socket.set_nodelay(true).unwrap();
+    tracing::info!("setting keepalive");
+    socket.set_keepalive(true).unwrap();
+
+    // Wait for it to be ready to send packets
+    tracing::info!("waiting for write_ready");
+    struct Poller<'a> {
+        socket: &'a mut Box<dyn VirtualTcpSocket + Sync>,
+    }
+    impl<'a> Future for Poller<'a> {
+        type Output = Result<usize>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            self.socket.poll_write_ready(cx)
+        }
+    }
+    Poller {
+        socket: &mut socket,
+    }
+    .await;
+
+    // Send the data (GET http request)
+    let data =
+        b"GET / HTTP/1.1\r\nHost: www.google.com\r\nUser-Agent: curl/7.81.0\r\nAccept: */*\r\nConnection: Close\r\n\r\n";
+    tracing::info!("sending {} bytes", data.len());
+    let sent = socket.send(data).await.unwrap();
+    assert_eq!(sent, data.len());
+
+    // Enter a loop that will return all the data
+    loop {
+        // Wait for the next bit of data
+        tracing::info!("waiting for read ready");
+        struct Poller<'a> {
+            socket: &'a mut Box<dyn VirtualTcpSocket + Sync>,
+        }
+        impl<'a> Future for Poller<'a> {
+            type Output = Result<usize>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                self.socket.poll_read_ready(cx)
+            }
+        }
+        Poller {
+            socket: &mut socket,
+        }
+        .await;
+
+        // Now read the data
+        let mut buf = [0u8; 4096];
+        match socket.read(&mut buf).await {
+            Ok(0) => break,
+            Ok(amt) => {
+                tracing::info!("received {amt} bytes");
+                continue;
+            }
+            Err(err) => {
+                tracing::info!("failed - {}", err);
+                panic!("failed to receive data");
+            }
+        }
+    }
+
+    tracing::info!("done");
+}
+
+#[cfg_attr(windows, ignore)]
+#[traced_test]
+#[tokio::test]
+#[serial_test::serial]
+async fn test_google_epoll() {
+    use futures_util::Future;
+    use virtual_mio::SharedWakerInterestHandler;
+
+    // Resolve the address
+    tracing::info!("resolving www.google.com");
+    let networking = LocalNetworking::new();
+    let peer_addr = networking
+        .resolve("www.google.com", None, None)
+        .await
+        .unwrap()
+        .into_iter()
+        .next()
+        .expect("IP address should be returned");
+    tracing::info!("www.google.com = {}", peer_addr);
+
+    // Start the connection
+    tracing::info!("connecting to {}:80", peer_addr);
+    let mut socket = networking
+        .connect_tcp(
+            SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
+            SocketAddr::new(peer_addr, 80),
+        )
+        .await
+        .unwrap();
+    tracing::info!("setting nodelay");
+    socket.set_nodelay(true).unwrap();
+    tracing::info!("setting keepalive");
+    socket.set_keepalive(true).unwrap();
+
+    // Wait for it to be ready to send packets
+    tracing::info!("waiting for writability");
+    struct Poller<'a> {
+        handler: Option<Box<SharedWakerInterestHandler>>,
+        socket: &'a mut Box<dyn VirtualTcpSocket + Sync>,
+    }
+    impl<'a> Future for Poller<'a> {
+        type Output = Result<()>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            if self.handler.is_none() {
+                self.handler
+                    .replace(SharedWakerInterestHandler::new(cx.waker()));
+                let handler = self.handler.as_ref().unwrap().clone();
+                self.socket.set_handler(handler);
+            }
+            if self
+                .handler
+                .as_mut()
+                .unwrap()
+                .pop_interest(InterestType::Writable)
+            {
+                return Poll::Ready(Ok(()));
+            }
+            Poll::Pending
+        }
+    }
+    Poller {
+        handler: None,
+        socket: &mut socket,
+    }
+    .await;
+
+    // Send the data (GET http request)
+    let data =
+        b"GET / HTTP/1.1\r\nHost: www.google.com\r\nUser-Agent: curl/7.81.0\r\nAccept: */*\r\nConnection: Close\r\n\r\n";
+    tracing::info!("sending {} bytes", data.len());
+    let sent = socket.try_send(data).unwrap();
+    assert_eq!(sent, data.len());
+
+    // We detect if there are lots of false positives, that means something has gone
+    // wrong with the epoll implementation
+    let mut false_interest = 0usize;
+
+    // Enter a loop that will return all the data
+    loop {
+        // Wait for the next bit of data
+        tracing::info!("waiting for readability");
+        struct Poller<'a> {
+            handler: Option<Box<SharedWakerInterestHandler>>,
+            socket: &'a mut Box<dyn VirtualTcpSocket + Sync>,
+        }
+        impl<'a> Future for Poller<'a> {
+            type Output = Result<()>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                if self.handler.is_none() {
+                    self.handler
+                        .replace(SharedWakerInterestHandler::new(cx.waker()));
+                    let handler = self.handler.as_ref().unwrap().clone();
+                    self.socket.set_handler(handler);
+                }
+                if self
+                    .handler
+                    .as_mut()
+                    .unwrap()
+                    .pop_interest(InterestType::Readable)
+                {
+                    return Poll::Ready(Ok(()));
+                }
+                Poll::Pending
+            }
+        }
+        Poller {
+            handler: None,
+            socket: &mut socket,
+        }
+        .await;
+
+        // Now read the data until we block
+        let mut done = false;
+        for n in 0.. {
+            let mut buf: [MaybeUninit<u8>; 4096] = [MaybeUninit::uninit(); 4096];
+            match socket.try_recv(&mut buf) {
+                Ok(0) => {
+                    done = true;
+                    break;
+                }
+                Ok(amt) => {
+                    tracing::info!("received {amt} bytes");
+                    continue;
+                }
+                Err(NetworkError::WouldBlock) => {
+                    if n == 0 {
+                        false_interest += 1;
+                    }
+                    break;
+                }
+                Err(err) => {
+                    tracing::info!("failed - {}", err);
+                    panic!("failed to receive data");
+                }
+            }
+        }
+        if done {
+            break;
+        }
+    }
+
+    if false_interest > 20 {
+        panic!("too many false positives on the epoll ({false_interest}), something has likely gone wrong")
+    }
+
+    tracing::info!("done");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/vm/Cargo.toml
new file mode 100644
index 0000000..0622352
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/Cargo.toml
@@ -0,0 +1,54 @@
+[package]
+name = "wasmer-vm"
+description = "Runtime library support for Wasmer"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly"]
+license = "MIT OR Apache-2.0 WITH LLVM-exception"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+memoffset.workspace = true
+wasmer-types = { path = "../types", version = "=4.2.8" }
+libc = { version = "^0.2", default-features = false }
+indexmap = { version = "1.6" }
+thiserror = "1.0"
+more-asserts = "0.2"
+cfg-if = "1.0"
+backtrace = "0.3"
+serde = { version = "1.0", features = ["derive", "rc"], optional = true }
+enum-iterator = "0.7.0"
+scopeguard = "1.1.0"
+lazy_static = "1.4.0"
+region = { version = "3.0" }
+corosensei = { version = "0.1.2" }
+derivative = { version = "^2" }
+dashmap = { version = "5.4" }
+fnv = "1.0.3"
+# - Optional shared dependencies.
+tracing = { version = "0.1", optional = true }
+crossbeam-queue = "0.3.8"
+
+[target.'cfg(target_vendor = "apple")'.dependencies]
+mach = "0.3.2"
+
+[target.'cfg(target_os = "windows")'.dependencies]
+winapi = { version = "0.3", features = ["winbase", "memoryapi", "errhandlingapi"] }
+
+[build-dependencies]
+cc = "1.0"
+
+[badges]
+maintenance = { status = "actively-developed" }
+
+[features]
+default = []
+enable-serde = ["serde", "indexmap/serde-1", "wasmer-types/enable-serde" ]
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/README.md b/arbitrator/tools/module_roots/wasmer/lib/vm/README.md
new file mode 100644
index 0000000..e15c595
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/README.md
@@ -0,0 +1,25 @@
+# `wasmer-vm` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE)
+
+This crate contains the Wasmer VM runtime library, supporting the Wasm ABI used by wasmer.
+
+The Wasmer runtime is modular by design, and provides several
+libraries where each of them provides a specific set of features. This
+`wasmer-vm` library contains the low-level foundation for the runtime
+itself.
+
+It provides all the APIs wasmer needs to operate,
+from the `instance`, to `memory`, `probestack`, signature registry, `trap`,
+`table`, `VMContext`, `libcalls` etc.
+
+It is very unlikely that a user will need to deal with `wasmer-vm`
+directly. The `wasmer` crate provides types that embed types from
+`wasmer-vm` with a higher-level API.
+
+
+[`wasmer`]: https://crates.io/crates/wasmer
+
+### Acknowledgments
+
+This project borrowed some of the code for the VM structure and trapping from the [wasmtime-runtime](https://crates.io/crates/wasmtime-runtime).
+
+Please check [Wasmer ATTRIBUTIONS](https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md) to further see licenses and other attributions of the project. 
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/export.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/export.rs
new file mode 100644
index 0000000..d9df605
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/export.rs
@@ -0,0 +1,48 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use crate::global::VMGlobal;
+use crate::memory::VMMemory;
+use crate::store::InternalStoreHandle;
+use crate::table::VMTable;
+use crate::vmcontext::VMFunctionKind;
+use crate::{MaybeInstanceOwned, VMCallerCheckedAnyfunc};
+use derivative::Derivative;
+use std::any::Any;
+use wasmer_types::FunctionType;
+
+/// The value of an export passed from one instance to another.
+pub enum VMExtern {
+    /// A function export value.
+    Function(InternalStoreHandle<VMFunction>),
+
+    /// A table export value.
+    Table(InternalStoreHandle<VMTable>),
+
+    /// A memory export value.
+    Memory(InternalStoreHandle<VMMemory>),
+
+    /// A global export value.
+    Global(InternalStoreHandle<VMGlobal>),
+}
+
+/// A function export value.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct VMFunction {
+    /// Pointer to the `VMCallerCheckedAnyfunc` which contains data needed to
+    /// call the function and check its signature.
+    #[derivative(Debug = "ignore")]
+    pub anyfunc: MaybeInstanceOwned<VMCallerCheckedAnyfunc>,
+
+    /// The function type, used for compatibility checking.
+    pub signature: FunctionType,
+
+    /// The function kind (specifies the calling convention for the
+    /// function).
+    pub kind: VMFunctionKind,
+
+    /// Associated data owned by a host function.
+    #[derivative(Debug = "ignore")]
+    pub host_data: Box<dyn Any>,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/extern_ref.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/extern_ref.rs
new file mode 100644
index 0000000..79f71b8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/extern_ref.rs
@@ -0,0 +1,50 @@
+use derivative::Derivative;
+use std::any::Any;
+use wasmer_types::RawValue;
+
+use crate::store::InternalStoreHandle;
+
+/// Underlying object referenced by a `VMExternRef`.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct VMExternObj {
+    #[derivative(Debug = "ignore")]
+    contents: Box<dyn Any + Send + Sync + 'static>,
+}
+
+impl VMExternObj {
+    /// Wraps the given value to expose it to Wasm code as an externref.
+    pub fn new(val: impl Any + Send + Sync + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + Sync + 'static) {
+        &*self.contents
+    }
+}
+
+/// Represents an opaque reference to any data within WebAssembly.
+#[repr(transparent)]
+#[derive(Debug, Clone, Copy)]
+pub struct VMExternRef(pub InternalStoreHandle<VMExternObj>);
+
+impl VMExternRef {
+    /// Converts the `VMExternRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        RawValue {
+            funcref: self.0.index(),
+        }
+    }
+
+    /// Extracts a `VMExternRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw` must be a valid `VMExternRef` instance.
+    pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
+        InternalStoreHandle::from_index(raw.externref).map(Self)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/function_env.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/function_env.rs
new file mode 100644
index 0000000..f2f8b72
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/function_env.rs
@@ -0,0 +1,31 @@
+use derivative::Derivative;
+use std::any::Any;
+
+/// Underlying FunctionEnvironment used by a `VMFunction`.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct VMFunctionEnvironment {
+    #[derivative(Debug = "ignore")]
+    contents: Box<dyn Any + Send + 'static>,
+}
+
+impl VMFunctionEnvironment {
+    /// Wraps the given value to expose it to Wasm code as a function context.
+    pub fn new(val: impl Any + Send + 'static) -> Self {
+        Self {
+            contents: Box::new(val),
+        }
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a reference to the underlying value.
+    pub fn as_ref(&self) -> &(dyn Any + Send + 'static) {
+        &*self.contents
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    /// Returns a mutable reference to the underlying value.
+    pub fn as_mut(&mut self) -> &mut (dyn Any + Send + 'static) {
+        &mut *self.contents
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/global.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/global.rs
new file mode 100644
index 0000000..bddb555
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/global.rs
@@ -0,0 +1,49 @@
+use crate::{store::MaybeInstanceOwned, vmcontext::VMGlobalDefinition};
+use derivative::Derivative;
+use std::{cell::UnsafeCell, ptr::NonNull};
+use wasmer_types::GlobalType;
+
+/// A Global instance
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct VMGlobal {
+    ty: GlobalType,
+    #[derivative(Debug = "ignore")]
+    vm_global_definition: MaybeInstanceOwned<VMGlobalDefinition>,
+}
+
+impl VMGlobal {
+    /// Create a new, zero bit-pattern initialized global from a [`GlobalType`].
+    pub fn new(global_type: GlobalType) -> Self {
+        Self {
+            ty: global_type,
+            // TODO: Currently all globals are host-owned, we should inline the
+            // VMGlobalDefinition in VMContext for instance-defined globals.
+            vm_global_definition: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(
+                VMGlobalDefinition::new(),
+            ))),
+        }
+    }
+
+    /// Get the type of the global.
+    pub fn ty(&self) -> &GlobalType {
+        &self.ty
+    }
+
+    /// Get a pointer to the underlying definition used by the generated code.
+    pub fn vmglobal(&self) -> NonNull<VMGlobalDefinition> {
+        self.vm_global_definition.as_ptr()
+    }
+
+    /// Copies this global
+    pub fn copy_on_write(&self) -> Self {
+        unsafe {
+            Self {
+                ty: self.ty,
+                vm_global_definition: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(
+                    self.vm_global_definition.as_ptr().as_ref().clone(),
+                ))),
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/imports.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/imports.rs
new file mode 100644
index 0000000..fb5da50
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/imports.rs
@@ -0,0 +1,49 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+use crate::vmcontext::{VMFunctionImport, VMGlobalImport, VMMemoryImport, VMTableImport};
+use wasmer_types::entity::{BoxedSlice, PrimaryMap};
+use wasmer_types::{FunctionIndex, GlobalIndex, MemoryIndex, TableIndex};
+
+/// Resolved import pointers.
+#[derive(Clone)]
+pub struct Imports {
+    /// Resolved addresses for imported functions.
+    pub functions: BoxedSlice<FunctionIndex, VMFunctionImport>,
+
+    /// Resolved addresses for imported tables.
+    pub tables: BoxedSlice<TableIndex, VMTableImport>,
+
+    /// Resolved addresses for imported memories.
+    pub memories: BoxedSlice<MemoryIndex, VMMemoryImport>,
+
+    /// Resolved addresses for imported globals.
+    pub globals: BoxedSlice<GlobalIndex, VMGlobalImport>,
+}
+
+impl Imports {
+    /// Construct a new `Imports` instance.
+    pub fn new(
+        function_imports: PrimaryMap<FunctionIndex, VMFunctionImport>,
+        table_imports: PrimaryMap<TableIndex, VMTableImport>,
+        memory_imports: PrimaryMap<MemoryIndex, VMMemoryImport>,
+        global_imports: PrimaryMap<GlobalIndex, VMGlobalImport>,
+    ) -> Self {
+        Self {
+            functions: function_imports.into_boxed_slice(),
+            tables: table_imports.into_boxed_slice(),
+            memories: memory_imports.into_boxed_slice(),
+            globals: global_imports.into_boxed_slice(),
+        }
+    }
+
+    /// Construct a new `Imports` instance with no imports.
+    pub fn none() -> Self {
+        Self {
+            functions: PrimaryMap::new().into_boxed_slice(),
+            tables: PrimaryMap::new().into_boxed_slice(),
+            memories: PrimaryMap::new().into_boxed_slice(),
+            globals: PrimaryMap::new().into_boxed_slice(),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/allocator.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/allocator.rs
new file mode 100644
index 0000000..78f41fb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/allocator.rs
@@ -0,0 +1,218 @@
+use super::{Instance, VMInstance};
+use crate::vmcontext::VMTableDefinition;
+use crate::VMMemoryDefinition;
+use std::alloc::{self, Layout};
+use std::convert::TryFrom;
+use std::mem;
+use std::ptr::{self, NonNull};
+use wasmer_types::entity::EntityRef;
+use wasmer_types::VMOffsets;
+use wasmer_types::{LocalMemoryIndex, LocalTableIndex, ModuleInfo};
+
+/// This is an intermediate type that manages the raw allocation and
+/// metadata when creating an [`Instance`].
+///
+/// This type will free the allocated memory if it's dropped before
+/// being used.
+///
+/// It is important to remind that [`Instance`] is dynamically-sized
+/// based on `VMOffsets`: The `Instance.vmctx` field represents a
+/// dynamically-sized array that extends beyond the nominal end of the
+/// type. So in order to create an instance of it, we must:
+///
+/// 1. Define the correct layout for `Instance` (size and alignment),
+/// 2. Allocate it properly.
+///
+/// The [`InstanceAllocator::instance_layout`] computes the correct
+/// layout to represent the wanted [`Instance`].
+///
+/// Then we use this layout to allocate an empty `Instance` properly.
+pub struct InstanceAllocator {
+    /// The buffer that will contain the [`Instance`] and dynamic fields.
+    instance_ptr: NonNull<Instance>,
+
+    /// The layout of the `instance_ptr` buffer.
+    instance_layout: Layout,
+
+    /// Information about the offsets into the `instance_ptr` buffer for
+    /// the dynamic fields.
+    offsets: VMOffsets,
+
+    /// Whether or not this type has transferred ownership of the
+    /// `instance_ptr` buffer. If it has not when being dropped,
+    /// the buffer should be freed.
+    consumed: bool,
+}
+
+impl Drop for InstanceAllocator {
+    fn drop(&mut self) {
+        if !self.consumed {
+            // If `consumed` has not been set, then we still have ownership
+            // over the buffer and must free it.
+            let instance_ptr = self.instance_ptr.as_ptr();
+
+            unsafe {
+                std::alloc::dealloc(instance_ptr as *mut u8, self.instance_layout);
+            }
+        }
+    }
+}
+
+impl InstanceAllocator {
+    /// Allocates instance data for use with [`VMInstance::new`].
+    ///
+    /// Returns a wrapper type around the allocation and 2 vectors of
+    /// pointers into the allocated buffer. These lists of pointers
+    /// correspond to the location in memory for the local memories and
+    /// tables respectively. These pointers should be written to before
+    /// calling [`VMInstance::new`].
+    ///
+    /// [`VMInstance::new`]: super::VMInstance::new
+    pub fn new(
+        module: &ModuleInfo,
+    ) -> (
+        Self,
+        Vec<NonNull<VMMemoryDefinition>>,
+        Vec<NonNull<VMTableDefinition>>,
+    ) {
+        let offsets = VMOffsets::new(mem::size_of::<usize>() as u8, module);
+        let instance_layout = Self::instance_layout(&offsets);
+
+        #[allow(clippy::cast_ptr_alignment)]
+        let instance_ptr = unsafe { alloc::alloc(instance_layout) as *mut Instance };
+
+        let instance_ptr = if let Some(ptr) = NonNull::new(instance_ptr) {
+            ptr
+        } else {
+            alloc::handle_alloc_error(instance_layout);
+        };
+
+        let allocator = Self {
+            instance_ptr,
+            instance_layout,
+            offsets,
+            consumed: false,
+        };
+
+        // # Safety
+        // Both of these calls are safe because we allocate the pointer
+        // above with the same `offsets` that these functions use.
+        // Thus there will be enough valid memory for both of them.
+        let memories = unsafe { allocator.memory_definition_locations() };
+        let tables = unsafe { allocator.table_definition_locations() };
+
+        (allocator, memories, tables)
+    }
+
+    /// Calculate the appropriate layout for the [`Instance`].
+    fn instance_layout(offsets: &VMOffsets) -> Layout {
+        let vmctx_size = usize::try_from(offsets.size_of_vmctx())
+            .expect("Failed to convert the size of `vmctx` to a `usize`");
+
+        let instance_vmctx_layout =
+            Layout::array::<u8>(vmctx_size).expect("Failed to create a layout for `VMContext`");
+
+        let (instance_layout, _offset) = Layout::new::<Instance>()
+            .extend(instance_vmctx_layout)
+            .expect("Failed to extend to `Instance` layout to include `VMContext`");
+
+        instance_layout.pad_to_align()
+    }
+
+    /// Get the locations of where the local [`VMMemoryDefinition`]s should be stored.
+    ///
+    /// This function lets us create `Memory` objects on the host with backing
+    /// memory in the VM.
+    ///
+    /// # Safety
+    ///
+    /// - `Self.instance_ptr` must point to enough memory that all of
+    ///   the offsets in `Self.offsets` point to valid locations in
+    ///   memory, i.e. `Self.instance_ptr` must have been allocated by
+    ///   `Self::new`.
+    unsafe fn memory_definition_locations(&self) -> Vec<NonNull<VMMemoryDefinition>> {
+        let num_memories = self.offsets.num_local_memories();
+        let num_memories = usize::try_from(num_memories).unwrap();
+        let mut out = Vec::with_capacity(num_memories);
+
+        // We need to do some pointer arithmetic now. The unit is `u8`.
+        let ptr = self.instance_ptr.cast::<u8>().as_ptr();
+        let base_ptr = ptr.add(mem::size_of::<Instance>());
+
+        for i in 0..num_memories {
+            let mem_offset = self
+                .offsets
+                .vmctx_vmmemory_definition(LocalMemoryIndex::new(i));
+            let mem_offset = usize::try_from(mem_offset).unwrap();
+
+            let new_ptr = NonNull::new_unchecked(base_ptr.add(mem_offset));
+
+            out.push(new_ptr.cast());
+        }
+
+        out
+    }
+
+    /// Get the locations of where the [`VMTableDefinition`]s should be stored.
+    ///
+    /// This function lets us create [`Table`] objects on the host with backing
+    /// memory in the VM.
+    ///
+    /// # Safety
+    ///
+    /// - `Self.instance_ptr` must point to enough memory that all of
+    ///   the offsets in `Self.offsets` point to valid locations in
+    ///   memory, i.e. `Self.instance_ptr` must have been allocated by
+    ///   `Self::new`.
+    unsafe fn table_definition_locations(&self) -> Vec<NonNull<VMTableDefinition>> {
+        let num_tables = self.offsets.num_local_tables();
+        let num_tables = usize::try_from(num_tables).unwrap();
+        let mut out = Vec::with_capacity(num_tables);
+
+        // We need to do some pointer arithmetic now. The unit is `u8`.
+        let ptr = self.instance_ptr.cast::<u8>().as_ptr();
+        let base_ptr = ptr.add(std::mem::size_of::<Instance>());
+
+        for i in 0..num_tables {
+            let table_offset = self
+                .offsets
+                .vmctx_vmtable_definition(LocalTableIndex::new(i));
+            let table_offset = usize::try_from(table_offset).unwrap();
+
+            let new_ptr = NonNull::new_unchecked(base_ptr.add(table_offset));
+
+            out.push(new_ptr.cast());
+        }
+        out
+    }
+
+    /// Finish preparing by writing the [`Instance`] into memory, and
+    /// consume this `InstanceAllocator`.
+    pub(crate) fn into_vminstance(mut self, instance: Instance) -> VMInstance {
+        // Prevent the old state's drop logic from being called as we
+        // transition into the new state.
+        self.consumed = true;
+
+        unsafe {
+            // `instance` is moved at `Self.instance_ptr`. This
+            // pointer has been allocated by `Self::allocate_instance`
+            // (so by `VMInstance::allocate_instance`).
+            ptr::write(self.instance_ptr.as_ptr(), instance);
+            // Now `instance_ptr` is correctly initialized!
+        }
+        let instance = self.instance_ptr;
+        let instance_layout = self.instance_layout;
+
+        // This is correct because of the invariants of `Self` and
+        // because we write `Instance` to the pointer in this function.
+        VMInstance {
+            instance,
+            instance_layout,
+        }
+    }
+
+    /// Get the [`VMOffsets`] for the allocated buffer.
+    pub(crate) fn offsets(&self) -> &VMOffsets {
+        &self.offsets
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/mod.rs
new file mode 100644
index 0000000..4e8e80c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/mod.rs
@@ -0,0 +1,1536 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! An `Instance` contains all the runtime state used by execution of
+//! a WebAssembly module (except its callstack and register state). An
+//! `VMInstance` is a wrapper around `Instance` that manages
+//! how it is allocated and deallocated.
+
+mod allocator;
+
+use crate::export::VMExtern;
+use crate::imports::Imports;
+use crate::store::{InternalStoreHandle, StoreObjects};
+use crate::table::TableElement;
+use crate::trap::{catch_traps, Trap, TrapCode};
+use crate::vmcontext::{
+    memory32_atomic_check32, memory32_atomic_check64, memory_copy, memory_fill,
+    VMBuiltinFunctionsArray, VMCallerCheckedAnyfunc, VMContext, VMFunctionContext,
+    VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition,
+    VMMemoryImport, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMTrampoline,
+};
+use crate::{FunctionBodyPtr, MaybeInstanceOwned, TrapHandlerFn, VMFunctionBody};
+use crate::{LinearMemory, NotifyLocation};
+use crate::{VMConfig, VMFuncRef, VMFunction, VMGlobal, VMMemory, VMTable};
+pub use allocator::InstanceAllocator;
+use memoffset::offset_of;
+use more_asserts::assert_lt;
+use std::alloc::Layout;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::fmt;
+use std::mem;
+use std::ptr::{self, NonNull};
+use std::slice;
+use std::sync::Arc;
+use wasmer_types::entity::{packed_option::ReservedValue, BoxedSlice, EntityRef, PrimaryMap};
+use wasmer_types::{
+    DataIndex, DataInitializer, ElemIndex, ExportIndex, FunctionIndex, GlobalIndex, GlobalInit,
+    LocalFunctionIndex, LocalGlobalIndex, LocalMemoryIndex, LocalTableIndex, MemoryError,
+    MemoryIndex, ModuleInfo, Pages, SignatureIndex, TableIndex, TableInitializer, VMOffsets,
+};
+
+/// A WebAssembly instance.
+///
+/// The type is dynamically-sized. Indeed, the `vmctx` field can
+/// contain various data. That's why the type has a C representation
+/// to ensure that the `vmctx` field is last. See the documentation of
+/// the `vmctx` field to learn more.
+#[repr(C)]
+#[allow(clippy::type_complexity)]
+pub(crate) struct Instance {
+    /// The `ModuleInfo` this `Instance` was instantiated from.
+    module: Arc<ModuleInfo>,
+
+    /// Pointer to the object store of the context owning this instance.
+    context: *mut StoreObjects,
+
+    /// Offsets in the `vmctx` region.
+    offsets: VMOffsets,
+
+    /// WebAssembly linear memory data.
+    memories: BoxedSlice<LocalMemoryIndex, InternalStoreHandle<VMMemory>>,
+
+    /// WebAssembly table data.
+    tables: BoxedSlice<LocalTableIndex, InternalStoreHandle<VMTable>>,
+
+    /// WebAssembly global data.
+    globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>,
+
+    /// Pointers to functions in executable memory.
+    functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
+
+    /// Pointers to function call trampolines in executable memory.
+    function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
+
+    /// Passive elements in this instantiation. As `elem.drop`s happen, these
+    /// entries get removed.
+    passive_elements: RefCell<HashMap<ElemIndex, Box<[Option<VMFuncRef>]>>>,
+
+    /// Passive data segments from our module. As `data.drop`s happen, entries
+    /// get removed. A missing entry is considered equivalent to an empty slice.
+    passive_data: RefCell<HashMap<DataIndex, Arc<[u8]>>>,
+
+    /// Mapping of function indices to their func ref backing data. `VMFuncRef`s
+    /// will point to elements here for functions defined by this instance.
+    funcrefs: BoxedSlice<LocalFunctionIndex, VMCallerCheckedAnyfunc>,
+
+    /// Mapping of function indices to their func ref backing data. `VMFuncRef`s
+    /// will point to elements here for functions imported by this instance.
+    imported_funcrefs: BoxedSlice<FunctionIndex, NonNull<VMCallerCheckedAnyfunc>>,
+
+    /// Additional context used by compiled WebAssembly code. This
+    /// field is last, and represents a dynamically-sized array that
+    /// extends beyond the nominal end of the struct (similar to a
+    /// flexible array member).
+    vmctx: VMContext,
+}
+
+impl fmt::Debug for Instance {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.debug_struct("Instance").finish()
+    }
+}
+
+#[allow(clippy::cast_ptr_alignment)]
+impl Instance {
+    /// Helper function to access various locations offset from our `*mut
+    /// VMContext` object.
+    unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *mut T {
+        (self.vmctx_ptr() as *mut u8)
+            .add(usize::try_from(offset).unwrap())
+            .cast()
+    }
+
+    fn module(&self) -> &Arc<ModuleInfo> {
+        &self.module
+    }
+
+    pub(crate) fn module_ref(&self) -> &ModuleInfo {
+        &self.module
+    }
+
+    fn context(&self) -> &StoreObjects {
+        unsafe { &*self.context }
+    }
+
+    fn context_mut(&mut self) -> &mut StoreObjects {
+        unsafe { &mut *self.context }
+    }
+
+    /// Offsets in the `vmctx` region.
+    fn offsets(&self) -> &VMOffsets {
+        &self.offsets
+    }
+
+    /// Return a pointer to the `VMSharedSignatureIndex`s.
+    fn signature_ids_ptr(&self) -> *mut VMSharedSignatureIndex {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_signature_ids_begin()) }
+    }
+
+    /// Return the indexed `VMFunctionImport`.
+    fn imported_function(&self, index: FunctionIndex) -> &VMFunctionImport {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        unsafe { &*self.imported_functions_ptr().add(index) }
+    }
+
+    /// Return a pointer to the `VMFunctionImport`s.
+    fn imported_functions_ptr(&self) -> *mut VMFunctionImport {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_functions_begin()) }
+    }
+
+    /// Return the index `VMTableImport`.
+    fn imported_table(&self, index: TableIndex) -> &VMTableImport {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        unsafe { &*self.imported_tables_ptr().add(index) }
+    }
+
+    /// Return a pointer to the `VMTableImports`s.
+    fn imported_tables_ptr(&self) -> *mut VMTableImport {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_tables_begin()) }
+    }
+
+    /// Return the indexed `VMMemoryImport`.
+    fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        unsafe { &*self.imported_memories_ptr().add(index) }
+    }
+
+    /// Return a pointer to the `VMMemoryImport`s.
+    fn imported_memories_ptr(&self) -> *mut VMMemoryImport {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_memories_begin()) }
+    }
+
+    /// Return the indexed `VMGlobalImport`.
+    fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        unsafe { &*self.imported_globals_ptr().add(index) }
+    }
+
+    /// Return a pointer to the `VMGlobalImport`s.
+    fn imported_globals_ptr(&self) -> *mut VMGlobalImport {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_imported_globals_begin()) }
+    }
+
+    /// Return the indexed `VMTableDefinition`.
+    #[allow(dead_code)]
+    fn table(&self, index: LocalTableIndex) -> VMTableDefinition {
+        unsafe { *self.table_ptr(index).as_ref() }
+    }
+
+    #[allow(dead_code)]
+    /// Updates the value for a defined table to `VMTableDefinition`.
+    fn set_table(&self, index: LocalTableIndex, table: &VMTableDefinition) {
+        unsafe {
+            *self.table_ptr(index).as_ptr() = *table;
+        }
+    }
+
+    /// Return the indexed `VMTableDefinition`.
+    fn table_ptr(&self, index: LocalTableIndex) -> NonNull<VMTableDefinition> {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        NonNull::new(unsafe { self.tables_ptr().add(index) }).unwrap()
+    }
+
+    /// Return a pointer to the `VMTableDefinition`s.
+    fn tables_ptr(&self) -> *mut VMTableDefinition {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_tables_begin()) }
+    }
+
+    #[allow(dead_code)]
+    /// Get a locally defined or imported memory.
+    fn get_memory(&self, index: MemoryIndex) -> VMMemoryDefinition {
+        if let Some(local_index) = self.module.local_memory_index(index) {
+            self.memory(local_index)
+        } else {
+            let import = self.imported_memory(index);
+            unsafe { *import.definition.as_ref() }
+        }
+    }
+
+    /// Return the indexed `VMMemoryDefinition`.
+    fn memory(&self, index: LocalMemoryIndex) -> VMMemoryDefinition {
+        unsafe { *self.memory_ptr(index).as_ref() }
+    }
+
+    #[allow(dead_code)]
+    /// Set the indexed memory to `VMMemoryDefinition`.
+    fn set_memory(&self, index: LocalMemoryIndex, mem: &VMMemoryDefinition) {
+        unsafe {
+            *self.memory_ptr(index).as_ptr() = *mem;
+        }
+    }
+
+    /// Return the indexed `VMMemoryDefinition`.
+    fn memory_ptr(&self, index: LocalMemoryIndex) -> NonNull<VMMemoryDefinition> {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        NonNull::new(unsafe { self.memories_ptr().add(index) }).unwrap()
+    }
+
+    /// Return a pointer to the `VMMemoryDefinition`s.
+    fn memories_ptr(&self) -> *mut VMMemoryDefinition {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_memories_begin()) }
+    }
+
+    /// Get a locally defined or imported memory.
+    fn get_vmmemory(&self, index: MemoryIndex) -> &VMMemory {
+        if let Some(local_index) = self.module.local_memory_index(index) {
+            unsafe {
+                self.memories
+                    .get(local_index)
+                    .unwrap()
+                    .get(self.context.as_ref().unwrap())
+            }
+        } else {
+            let import = self.imported_memory(index);
+            unsafe { import.handle.get(self.context.as_ref().unwrap()) }
+        }
+    }
+
+    /// Get a locally defined or imported memory.
+    fn get_vmmemory_mut(&mut self, index: MemoryIndex) -> &mut VMMemory {
+        if let Some(local_index) = self.module.local_memory_index(index) {
+            unsafe {
+                self.memories
+                    .get_mut(local_index)
+                    .unwrap()
+                    .get_mut(self.context.as_mut().unwrap())
+            }
+        } else {
+            let import = self.imported_memory(index);
+            unsafe { import.handle.get_mut(self.context.as_mut().unwrap()) }
+        }
+    }
+
+    /// Get a locally defined memory as mutable.
+    fn get_local_vmmemory_mut(&mut self, local_index: LocalMemoryIndex) -> &mut VMMemory {
+        unsafe {
+            self.memories
+                .get_mut(local_index)
+                .unwrap()
+                .get_mut(self.context.as_mut().unwrap())
+        }
+    }
+
+    /// Return the indexed `VMGlobalDefinition`.
+    fn global(&self, index: LocalGlobalIndex) -> VMGlobalDefinition {
+        unsafe { self.global_ptr(index).as_ref().clone() }
+    }
+
+    /// Set the indexed global to `VMGlobalDefinition`.
+    #[allow(dead_code)]
+    fn set_global(&self, index: LocalGlobalIndex, global: &VMGlobalDefinition) {
+        unsafe {
+            *self.global_ptr(index).as_ptr() = global.clone();
+        }
+    }
+
+    /// Return the indexed `VMGlobalDefinition`.
+    fn global_ptr(&self, index: LocalGlobalIndex) -> NonNull<VMGlobalDefinition> {
+        let index = usize::try_from(index.as_u32()).unwrap();
+        // TODO:
+        NonNull::new(unsafe { *self.globals_ptr().add(index) }).unwrap()
+    }
+
+    /// Return a pointer to the `VMGlobalDefinition`s.
+    fn globals_ptr(&self) -> *mut *mut VMGlobalDefinition {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_globals_begin()) }
+    }
+
+    /// Return a pointer to the `VMBuiltinFunctionsArray`.
+    fn builtin_functions_ptr(&self) -> *mut VMBuiltinFunctionsArray {
+        unsafe { self.vmctx_plus_offset(self.offsets.vmctx_builtin_functions_begin()) }
+    }
+
+    /// Return a reference to the vmctx used by compiled wasm code.
+    fn vmctx(&self) -> &VMContext {
+        &self.vmctx
+    }
+
+    /// Return a raw pointer to the vmctx used by compiled wasm code.
+    fn vmctx_ptr(&self) -> *mut VMContext {
+        self.vmctx() as *const VMContext as *mut VMContext
+    }
+
+    /// Invoke the WebAssembly start function of the instance, if one is present.
+    fn invoke_start_function(
+        &self,
+        config: &VMConfig,
+        trap_handler: Option<*const TrapHandlerFn<'static>>,
+    ) -> Result<(), Trap> {
+        let start_index = match self.module.start_function {
+            Some(idx) => idx,
+            None => return Ok(()),
+        };
+
+        let (callee_address, callee_vmctx) = match self.module.local_func_index(start_index) {
+            Some(local_index) => {
+                let body = self
+                    .functions
+                    .get(local_index)
+                    .expect("function index is out of bounds")
+                    .0;
+                (
+                    body as *const _,
+                    VMFunctionContext {
+                        vmctx: self.vmctx_ptr(),
+                    },
+                )
+            }
+            None => {
+                assert_lt!(start_index.index(), self.module.num_imported_functions);
+                let import = self.imported_function(start_index);
+                (import.body, import.environment)
+            }
+        };
+
+        // Make the call.
+        unsafe {
+            catch_traps(trap_handler, config, || {
+                mem::transmute::<*const VMFunctionBody, unsafe extern "C" fn(VMFunctionContext)>(
+                    callee_address,
+                )(callee_vmctx)
+            })
+        }
+    }
+
+    /// Return the offset from the vmctx pointer to its containing `Instance`.
+    #[inline]
+    pub(crate) fn vmctx_offset() -> isize {
+        offset_of!(Self, vmctx) as isize
+    }
+
+    /// Return the table index for the given `VMTableDefinition`.
+    pub(crate) fn table_index(&self, table: &VMTableDefinition) -> LocalTableIndex {
+        let begin: *const VMTableDefinition = self.tables_ptr() as *const _;
+        let end: *const VMTableDefinition = table;
+        // TODO: Use `offset_from` once it stablizes.
+        let index = LocalTableIndex::new(
+            (end as usize - begin as usize) / mem::size_of::<VMTableDefinition>(),
+        );
+        assert_lt!(index.index(), self.tables.len());
+        index
+    }
+
+    /// Return the memory index for the given `VMMemoryDefinition`.
+    pub(crate) fn memory_index(&self, memory: &VMMemoryDefinition) -> LocalMemoryIndex {
+        let begin: *const VMMemoryDefinition = self.memories_ptr() as *const _;
+        let end: *const VMMemoryDefinition = memory;
+        // TODO: Use `offset_from` once it stablizes.
+        let index = LocalMemoryIndex::new(
+            (end as usize - begin as usize) / mem::size_of::<VMMemoryDefinition>(),
+        );
+        assert_lt!(index.index(), self.memories.len());
+        index
+    }
+
+    /// Grow memory by the specified amount of pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of pages.
+    pub(crate) fn memory_grow<IntoPages>(
+        &mut self,
+        memory_index: LocalMemoryIndex,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        let mem = *self
+            .memories
+            .get(memory_index)
+            .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index()));
+        mem.get_mut(self.context_mut()).grow(delta.into())
+    }
+
+    /// Grow imported memory by the specified amount of pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of pages.
+    ///
+    /// # Safety
+    /// This and `imported_memory_size` are currently unsafe because they
+    /// dereference the memory import's pointers.
+    pub(crate) unsafe fn imported_memory_grow<IntoPages>(
+        &mut self,
+        memory_index: MemoryIndex,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        let import = self.imported_memory(memory_index);
+        let mem = import.handle;
+        mem.get_mut(self.context_mut()).grow(delta.into())
+    }
+
+    /// Returns the number of allocated wasm pages.
+    pub(crate) fn memory_size(&self, memory_index: LocalMemoryIndex) -> Pages {
+        let mem = *self
+            .memories
+            .get(memory_index)
+            .unwrap_or_else(|| panic!("no memory for index {}", memory_index.index()));
+        mem.get(self.context()).size()
+    }
+
+    /// Returns the number of allocated wasm pages in an imported memory.
+    ///
+    /// # Safety
+    /// This and `imported_memory_grow` are currently unsafe because they
+    /// dereference the memory import's pointers.
+    pub(crate) unsafe fn imported_memory_size(&self, memory_index: MemoryIndex) -> Pages {
+        let import = self.imported_memory(memory_index);
+        let mem = import.handle;
+        mem.get(self.context()).size()
+    }
+
+    /// Returns the number of elements in a given table.
+    pub(crate) fn table_size(&self, table_index: LocalTableIndex) -> u32 {
+        let table = self
+            .tables
+            .get(table_index)
+            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()));
+        table.get(self.context()).size()
+    }
+
+    /// Returns the number of elements in a given imported table.
+    ///
+    /// # Safety
+    /// `table_index` must be a valid, imported table index.
+    pub(crate) unsafe fn imported_table_size(&self, table_index: TableIndex) -> u32 {
+        let import = self.imported_table(table_index);
+        let table = import.handle;
+        table.get(self.context()).size()
+    }
+
+    /// Grow table by the specified amount of elements.
+    ///
+    /// Returns `None` if table can't be grown by the specified amount
+    /// of elements.
+    pub(crate) fn table_grow(
+        &mut self,
+        table_index: LocalTableIndex,
+        delta: u32,
+        init_value: TableElement,
+    ) -> Option<u32> {
+        let table = *self
+            .tables
+            .get(table_index)
+            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()));
+        table.get_mut(self.context_mut()).grow(delta, init_value)
+    }
+
+    /// Grow table by the specified amount of elements.
+    ///
+    /// # Safety
+    /// `table_index` must be a valid, imported table index.
+    pub(crate) unsafe fn imported_table_grow(
+        &mut self,
+        table_index: TableIndex,
+        delta: u32,
+        init_value: TableElement,
+    ) -> Option<u32> {
+        let import = self.imported_table(table_index);
+        let table = import.handle;
+        table.get_mut(self.context_mut()).grow(delta, init_value)
+    }
+
+    /// Get table element by index.
+    pub(crate) fn table_get(
+        &self,
+        table_index: LocalTableIndex,
+        index: u32,
+    ) -> Option<TableElement> {
+        let table = self
+            .tables
+            .get(table_index)
+            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()));
+        table.get(self.context()).get(index)
+    }
+
+    /// Returns the element at the given index.
+    ///
+    /// # Safety
+    /// `table_index` must be a valid, imported table index.
+    pub(crate) unsafe fn imported_table_get(
+        &self,
+        table_index: TableIndex,
+        index: u32,
+    ) -> Option<TableElement> {
+        let import = self.imported_table(table_index);
+        let table = import.handle;
+        table.get(self.context()).get(index)
+    }
+
+    /// Set table element by index.
+    pub(crate) fn table_set(
+        &mut self,
+        table_index: LocalTableIndex,
+        index: u32,
+        val: TableElement,
+    ) -> Result<(), Trap> {
+        let table = *self
+            .tables
+            .get(table_index)
+            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()));
+        table.get_mut(self.context_mut()).set(index, val)
+    }
+
+    /// Set table element by index for an imported table.
+    ///
+    /// # Safety
+    /// `table_index` must be a valid, imported table index.
+    pub(crate) unsafe fn imported_table_set(
+        &mut self,
+        table_index: TableIndex,
+        index: u32,
+        val: TableElement,
+    ) -> Result<(), Trap> {
+        let import = self.imported_table(table_index);
+        let table = import.handle;
+        table.get_mut(self.context_mut()).set(index, val)
+    }
+
+    /// Get a `VMFuncRef` for the given `FunctionIndex`.
+    pub(crate) fn func_ref(&self, function_index: FunctionIndex) -> Option<VMFuncRef> {
+        if function_index == FunctionIndex::reserved_value() {
+            None
+        } else if let Some(local_function_index) = self.module.local_func_index(function_index) {
+            Some(VMFuncRef(NonNull::from(
+                &self.funcrefs[local_function_index],
+            )))
+        } else {
+            Some(VMFuncRef(self.imported_funcrefs[function_index]))
+        }
+    }
+
+    /// The `table.init` operation: initializes a portion of a table with a
+    /// passive element.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error when the range within the table is out of bounds
+    /// or the range within the passive element is out of bounds.
+    pub(crate) fn table_init(
+        &mut self,
+        table_index: TableIndex,
+        elem_index: ElemIndex,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init
+
+        let table = self.get_table_handle(table_index);
+        let table = unsafe { table.get_mut(&mut *self.context) };
+        let passive_elements = self.passive_elements.borrow();
+        let elem = passive_elements
+            .get(&elem_index)
+            .map_or::<&[Option<VMFuncRef>], _>(&[], |e| &**e);
+
+        if src
+            .checked_add(len)
+            .map_or(true, |n| n as usize > elem.len())
+            || dst.checked_add(len).map_or(true, |m| m > table.size())
+        {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        for (dst, src) in (dst..dst + len).zip(src..src + len) {
+            table
+                .set(dst, TableElement::FuncRef(elem[src as usize]))
+                .expect("should never panic because we already did the bounds check above");
+        }
+
+        Ok(())
+    }
+
+    /// The `table.fill` operation: fills a portion of a table with a given value.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error when the range within the table is out of bounds
+    pub(crate) fn table_fill(
+        &mut self,
+        table_index: TableIndex,
+        start_index: u32,
+        item: TableElement,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init
+
+        let table = self.get_table(table_index);
+        let table_size = table.size() as usize;
+
+        if start_index
+            .checked_add(len)
+            .map_or(true, |n| n as usize > table_size)
+        {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        for i in start_index..(start_index + len) {
+            table
+                .set(i, item.clone())
+                .expect("should never panic because we already did the bounds check above");
+        }
+
+        Ok(())
+    }
+
+    /// Drop an element.
+    pub(crate) fn elem_drop(&self, elem_index: ElemIndex) {
+        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-elem-drop
+
+        let mut passive_elements = self.passive_elements.borrow_mut();
+        passive_elements.remove(&elem_index);
+        // Note that we don't check that we actually removed an element because
+        // dropping a non-passive element is a no-op (not a trap).
+    }
+
+    /// Do a `memory.copy` for a locally defined memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error when the source or destination ranges are out of
+    /// bounds.
+    pub(crate) fn local_memory_copy(
+        &self,
+        memory_index: LocalMemoryIndex,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
+
+        let memory = self.memory(memory_index);
+        // The following memory copy is not synchronized and is not atomic:
+        unsafe { memory_copy(&memory, dst, src, len) }
+    }
+
+    /// Perform a `memory.copy` on an imported memory.
+    pub(crate) fn imported_memory_copy(
+        &self,
+        memory_index: MemoryIndex,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        let import = self.imported_memory(memory_index);
+        let memory = unsafe { import.definition.as_ref() };
+        // The following memory copy is not synchronized and is not atomic:
+        unsafe { memory_copy(memory, dst, src, len) }
+    }
+
+    /// Perform the `memory.fill` operation on a locally defined memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error if the memory range is out of bounds.
+    pub(crate) fn local_memory_fill(
+        &self,
+        memory_index: LocalMemoryIndex,
+        dst: u32,
+        val: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        let memory = self.memory(memory_index);
+        // The following memory fill is not synchronized and is not atomic:
+        unsafe { memory_fill(&memory, dst, val, len) }
+    }
+
+    /// Perform the `memory.fill` operation on an imported memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error if the memory range is out of bounds.
+    pub(crate) fn imported_memory_fill(
+        &self,
+        memory_index: MemoryIndex,
+        dst: u32,
+        val: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        let import = self.imported_memory(memory_index);
+        let memory = unsafe { import.definition.as_ref() };
+        // The following memory fill is not synchronized and is not atomic:
+        unsafe { memory_fill(memory, dst, val, len) }
+    }
+
+    /// Performs the `memory.init` operation.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error if the destination range is out of this module's
+    /// memory's bounds or if the source range is outside the data segment's
+    /// bounds.
+    pub(crate) fn memory_init(
+        &self,
+        memory_index: MemoryIndex,
+        data_index: DataIndex,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-memory-init
+
+        let memory = self.get_vmmemory(memory_index);
+        let passive_data = self.passive_data.borrow();
+        let data = passive_data.get(&data_index).map_or(&[][..], |d| &**d);
+
+        let current_length = unsafe { memory.vmmemory().as_ref().current_length };
+        if src
+            .checked_add(len)
+            .map_or(true, |n| n as usize > data.len())
+            || dst
+                .checked_add(len)
+                .map_or(true, |m| usize::try_from(m).unwrap() > current_length)
+        {
+            return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+        }
+        let src_slice = &data[src as usize..(src + len) as usize];
+        unsafe { memory.initialize_with_data(dst as usize, src_slice) }
+    }
+
+    /// Drop the given data segment, truncating its length to zero.
+    pub(crate) fn data_drop(&self, data_index: DataIndex) {
+        let mut passive_data = self.passive_data.borrow_mut();
+        passive_data.remove(&data_index);
+    }
+
+    /// Get a table by index regardless of whether it is locally-defined or an
+    /// imported, foreign table.
+    pub(crate) fn get_table(&mut self, table_index: TableIndex) -> &mut VMTable {
+        if let Some(local_table_index) = self.module.local_table_index(table_index) {
+            self.get_local_table(local_table_index)
+        } else {
+            self.get_foreign_table(table_index)
+        }
+    }
+
+    /// Get a locally-defined table.
+    pub(crate) fn get_local_table(&mut self, index: LocalTableIndex) -> &mut VMTable {
+        let table = self.tables[index];
+        table.get_mut(self.context_mut())
+    }
+
+    /// Get an imported, foreign table.
+    pub(crate) fn get_foreign_table(&mut self, index: TableIndex) -> &mut VMTable {
+        let import = self.imported_table(index);
+        let table = import.handle;
+        table.get_mut(self.context_mut())
+    }
+
+    /// Get a table handle by index regardless of whether it is locally-defined
+    /// or an imported, foreign table.
+    pub(crate) fn get_table_handle(
+        &mut self,
+        table_index: TableIndex,
+    ) -> InternalStoreHandle<VMTable> {
+        if let Some(local_table_index) = self.module.local_table_index(table_index) {
+            self.tables[local_table_index]
+        } else {
+            self.imported_table(table_index).handle
+        }
+    }
+
+    fn memory_wait(memory: &mut VMMemory, dst: u32, timeout: i64) -> Result<u32, Trap> {
+        let location = NotifyLocation { address: dst };
+        let timeout = if timeout < 0 {
+            None
+        } else {
+            Some(std::time::Duration::from_nanos(timeout as u64))
+        };
+        match memory.do_wait(location, timeout) {
+            Ok(count) => Ok(count),
+            Err(_err) => {
+                // ret is None if there is more than 2^32 waiter in queue or some other error
+                Err(Trap::lib(TrapCode::TableAccessOutOfBounds))
+            }
+        }
+    }
+
+    /// Perform an Atomic.Wait32
+    pub(crate) fn local_memory_wait32(
+        &mut self,
+        memory_index: LocalMemoryIndex,
+        dst: u32,
+        val: u32,
+        timeout: i64,
+    ) -> Result<u32, Trap> {
+        let memory = self.memory(memory_index);
+        //if ! memory.shared {
+        // We should trap according to spec, but official test rely on not trapping...
+        //}
+
+        let ret = unsafe { memory32_atomic_check32(&memory, dst, val) };
+
+        if let Ok(mut ret) = ret {
+            if ret == 0 {
+                let memory = self.get_local_vmmemory_mut(memory_index);
+                ret = Self::memory_wait(memory, dst, timeout)?;
+            }
+            Ok(ret)
+        } else {
+            ret
+        }
+    }
+
+    /// Perform an Atomic.Wait32
+    pub(crate) fn imported_memory_wait32(
+        &mut self,
+        memory_index: MemoryIndex,
+        dst: u32,
+        val: u32,
+        timeout: i64,
+    ) -> Result<u32, Trap> {
+        let import = self.imported_memory(memory_index);
+        let memory = unsafe { import.definition.as_ref() };
+        //if ! memory.shared {
+        // We should trap according to spec, but official test rely on not trapping...
+        //}
+
+        let ret = unsafe { memory32_atomic_check32(memory, dst, val) };
+        if let Ok(mut ret) = ret {
+            if ret == 0 {
+                let memory = self.get_vmmemory_mut(memory_index);
+                ret = Self::memory_wait(memory, dst, timeout)?;
+            }
+            Ok(ret)
+        } else {
+            ret
+        }
+    }
+
+    /// Perform an Atomic.Wait64
+    pub(crate) fn local_memory_wait64(
+        &mut self,
+        memory_index: LocalMemoryIndex,
+        dst: u32,
+        val: u64,
+        timeout: i64,
+    ) -> Result<u32, Trap> {
+        let memory = self.memory(memory_index);
+        //if ! memory.shared {
+        // We should trap according to spec, but official test rely on not trapping...
+        //}
+
+        let ret = unsafe { memory32_atomic_check64(&memory, dst, val) };
+
+        if let Ok(mut ret) = ret {
+            if ret == 0 {
+                let memory = self.get_local_vmmemory_mut(memory_index);
+                ret = Self::memory_wait(memory, dst, timeout)?;
+            }
+            Ok(ret)
+        } else {
+            ret
+        }
+    }
+
+    /// Perform an Atomic.Wait64
+    pub(crate) fn imported_memory_wait64(
+        &mut self,
+        memory_index: MemoryIndex,
+        dst: u32,
+        val: u64,
+        timeout: i64,
+    ) -> Result<u32, Trap> {
+        let import = self.imported_memory(memory_index);
+        let memory = unsafe { import.definition.as_ref() };
+        //if ! memory.shared {
+        // We should trap according to spec, but official test rely on not trapping...
+        //}
+
+        let ret = unsafe { memory32_atomic_check64(memory, dst, val) };
+
+        if let Ok(mut ret) = ret {
+            if ret == 0 {
+                let memory = self.get_vmmemory_mut(memory_index);
+                ret = Self::memory_wait(memory, dst, timeout)?;
+            }
+            Ok(ret)
+        } else {
+            ret
+        }
+    }
+
+    /// Perform an Atomic.Notify
+    pub(crate) fn local_memory_notify(
+        &mut self,
+        memory_index: LocalMemoryIndex,
+        dst: u32,
+        count: u32,
+    ) -> Result<u32, Trap> {
+        let memory = self.get_local_vmmemory_mut(memory_index);
+        // fetch the notifier
+        let location = NotifyLocation { address: dst };
+        Ok(memory.do_notify(location, count))
+    }
+
+    /// Perform an Atomic.Notify
+    pub(crate) fn imported_memory_notify(
+        &mut self,
+        memory_index: MemoryIndex,
+        dst: u32,
+        count: u32,
+    ) -> Result<u32, Trap> {
+        let memory = self.get_vmmemory_mut(memory_index);
+        // fetch the notifier
+        let location = NotifyLocation { address: dst };
+        Ok(memory.do_notify(location, count))
+    }
+}
+
+/// A handle holding an `Instance` of a WebAssembly module.
+///
+/// This is more or less a public facade of the private `Instance`,
+/// providing useful higher-level API.
+#[derive(Debug, Eq, PartialEq)]
+pub struct VMInstance {
+    /// The layout of `Instance` (which can vary).
+    instance_layout: Layout,
+
+    /// The `Instance` itself.
+    ///
+    /// `Instance` must not be dropped manually by Rust, because it's
+    /// allocated manually with `alloc` and a specific layout (Rust
+    /// would be able to drop `Instance` itself but it will imply a
+    /// memory leak because of `alloc`).
+    ///
+    /// No one in the code has a copy of the `Instance`'s
+    /// pointer. `Self` is the only one.
+    instance: NonNull<Instance>,
+}
+
+/// VMInstance are created with an InstanceAllocator
+/// and it will "consume" the memory
+/// So the Drop here actualy free it (else it would be leaked)
+impl Drop for VMInstance {
+    fn drop(&mut self) {
+        let instance_ptr = self.instance.as_ptr();
+
+        unsafe {
+            // Need to drop all the actual Instance members
+            instance_ptr.drop_in_place();
+            // And then free the memory allocated for the Instance itself
+            std::alloc::dealloc(instance_ptr as *mut u8, self.instance_layout);
+        }
+    }
+}
+
+impl VMInstance {
+    /// Create a new `VMInstance` pointing at a new [`Instance`].
+    ///
+    /// # Safety
+    ///
+    /// This method is not necessarily inherently unsafe to call, but in general
+    /// the APIs of an `Instance` are quite unsafe and have not been really
+    /// audited for safety that much. As a result the unsafety here on this
+    /// method is a low-overhead way of saying “this is an extremely unsafe type
+    /// to work with”.
+    ///
+    /// Extreme care must be taken when working with `VMInstance` and it's
+    /// recommended to have relatively intimate knowledge of how it works
+    /// internally if you'd like to do so. If possible it's recommended to use
+    /// the `wasmer` crate API rather than this type since that is vetted for
+    /// safety.
+    ///
+    /// However the following must be taken care of before calling this function:
+    /// - The memory at `instance.tables_ptr()` must be initialized with data for
+    ///   all the local tables.
+    /// - The memory at `instance.memories_ptr()` must be initialized with data for
+    ///   all the local memories.
+    #[allow(clippy::too_many_arguments)]
+    pub unsafe fn new(
+        allocator: InstanceAllocator,
+        module: Arc<ModuleInfo>,
+        context: &mut StoreObjects,
+        finished_functions: BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
+        finished_function_call_trampolines: BoxedSlice<SignatureIndex, VMTrampoline>,
+        finished_memories: BoxedSlice<LocalMemoryIndex, InternalStoreHandle<VMMemory>>,
+        finished_tables: BoxedSlice<LocalTableIndex, InternalStoreHandle<VMTable>>,
+        finished_globals: BoxedSlice<LocalGlobalIndex, InternalStoreHandle<VMGlobal>>,
+        imports: Imports,
+        vmshared_signatures: BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
+    ) -> Result<Self, Trap> {
+        let vmctx_globals = finished_globals
+            .values()
+            .map(|m| m.get(context).vmglobal())
+            .collect::<PrimaryMap<LocalGlobalIndex, _>>()
+            .into_boxed_slice();
+        let passive_data = RefCell::new(
+            module
+                .passive_data
+                .clone()
+                .into_iter()
+                .map(|(idx, bytes)| (idx, Arc::from(bytes)))
+                .collect::<HashMap<_, _>>(),
+        );
+
+        let handle = {
+            let offsets = allocator.offsets().clone();
+            // use dummy value to create an instance so we can get the vmctx pointer
+            let funcrefs = PrimaryMap::new().into_boxed_slice();
+            let imported_funcrefs = PrimaryMap::new().into_boxed_slice();
+            // Create the `Instance`. The unique, the One.
+            let instance = Instance {
+                module,
+                context,
+                offsets,
+                memories: finished_memories,
+                tables: finished_tables,
+                globals: finished_globals,
+                functions: finished_functions,
+                function_call_trampolines: finished_function_call_trampolines,
+                passive_elements: Default::default(),
+                passive_data,
+                funcrefs,
+                imported_funcrefs,
+                vmctx: VMContext {},
+            };
+
+            let mut instance_handle = allocator.into_vminstance(instance);
+
+            // Set the funcrefs after we've built the instance
+            {
+                let instance = instance_handle.instance_mut();
+                let vmctx_ptr = instance.vmctx_ptr();
+                (instance.funcrefs, instance.imported_funcrefs) = build_funcrefs(
+                    &instance.module,
+                    context,
+                    &imports,
+                    &instance.functions,
+                    &vmshared_signatures,
+                    &instance.function_call_trampolines,
+                    vmctx_ptr,
+                );
+            }
+
+            instance_handle
+        };
+        let instance = handle.instance();
+
+        ptr::copy(
+            vmshared_signatures.values().as_slice().as_ptr(),
+            instance.signature_ids_ptr(),
+            vmshared_signatures.len(),
+        );
+        ptr::copy(
+            imports.functions.values().as_slice().as_ptr(),
+            instance.imported_functions_ptr(),
+            imports.functions.len(),
+        );
+        ptr::copy(
+            imports.tables.values().as_slice().as_ptr(),
+            instance.imported_tables_ptr(),
+            imports.tables.len(),
+        );
+        ptr::copy(
+            imports.memories.values().as_slice().as_ptr(),
+            instance.imported_memories_ptr(),
+            imports.memories.len(),
+        );
+        ptr::copy(
+            imports.globals.values().as_slice().as_ptr(),
+            instance.imported_globals_ptr(),
+            imports.globals.len(),
+        );
+        // these should already be set, add asserts here? for:
+        // - instance.tables_ptr() as *mut VMTableDefinition
+        // - instance.memories_ptr() as *mut VMMemoryDefinition
+        ptr::copy(
+            vmctx_globals.values().as_slice().as_ptr(),
+            instance.globals_ptr() as *mut NonNull<VMGlobalDefinition>,
+            vmctx_globals.len(),
+        );
+        ptr::write(
+            instance.builtin_functions_ptr(),
+            VMBuiltinFunctionsArray::initialized(),
+        );
+
+        // Perform infallible initialization in this constructor, while fallible
+        // initialization is deferred to the `initialize` method.
+        initialize_passive_elements(instance);
+        initialize_globals(instance);
+
+        Ok(handle)
+    }
+
+    /// Return a reference to the contained `Instance`.
+    pub(crate) fn instance(&self) -> &Instance {
+        unsafe { self.instance.as_ref() }
+    }
+
+    /// Return a mutable reference to the contained `Instance`.
+    pub(crate) fn instance_mut(&mut self) -> &mut Instance {
+        unsafe { self.instance.as_mut() }
+    }
+
+    /// Finishes the instantiation process started by `Instance::new`.
+    ///
+    /// # Safety
+    ///
+    /// Only safe to call immediately after instantiation.
+    pub unsafe fn finish_instantiation(
+        &mut self,
+        config: &VMConfig,
+        trap_handler: Option<*const TrapHandlerFn<'static>>,
+        data_initializers: &[DataInitializer<'_>],
+    ) -> Result<(), Trap> {
+        let instance = self.instance_mut();
+
+        // Apply the initializers.
+        initialize_tables(instance)?;
+        initialize_memories(instance, data_initializers)?;
+
+        // The WebAssembly spec specifies that the start function is
+        // invoked automatically at instantiation time.
+        instance.invoke_start_function(config, trap_handler)?;
+        Ok(())
+    }
+
+    /// Return a reference to the vmctx used by compiled wasm code.
+    pub fn vmctx(&self) -> &VMContext {
+        self.instance().vmctx()
+    }
+
+    /// Return a raw pointer to the vmctx used by compiled wasm code.
+    pub fn vmctx_ptr(&self) -> *mut VMContext {
+        self.instance().vmctx_ptr()
+    }
+
+    /// Return a reference to the `VMOffsets` to get offsets in the
+    /// `Self::vmctx_ptr` region. Be careful when doing pointer
+    /// arithmetic!
+    pub fn vmoffsets(&self) -> &VMOffsets {
+        self.instance().offsets()
+    }
+
+    /// Return a reference-counting pointer to a module.
+    pub fn module(&self) -> &Arc<ModuleInfo> {
+        self.instance().module()
+    }
+
+    /// Return a reference to a module.
+    pub fn module_ref(&self) -> &ModuleInfo {
+        self.instance().module_ref()
+    }
+
+    /// Lookup an export with the given name.
+    pub fn lookup(&mut self, field: &str) -> Option<VMExtern> {
+        let export = *self.module_ref().exports.get(field)?;
+
+        Some(self.lookup_by_declaration(export))
+    }
+
+    /// Lookup an export with the given export declaration.
+    pub fn lookup_by_declaration(&mut self, export: ExportIndex) -> VMExtern {
+        let instance = self.instance();
+
+        match export {
+            ExportIndex::Function(index) => {
+                let sig_index = &instance.module.functions[index];
+                let handle = if let Some(def_index) = instance.module.local_func_index(index) {
+                    // A VMFunction is lazily created only for functions that are
+                    // exported.
+                    let signature = instance.module.signatures[*sig_index].clone();
+                    let vm_function = VMFunction {
+                        anyfunc: MaybeInstanceOwned::Instance(NonNull::from(
+                            &instance.funcrefs[def_index],
+                        )),
+                        signature,
+                        // Any function received is already static at this point as:
+                        // 1. All locally defined functions in the Wasm have a static signature.
+                        // 2. All the imported functions are already static (because
+                        //    they point to the trampolines rather than the dynamic addresses).
+                        kind: VMFunctionKind::Static,
+                        host_data: Box::new(()),
+                    };
+                    InternalStoreHandle::new(self.instance_mut().context_mut(), vm_function)
+                } else {
+                    let import = instance.imported_function(index);
+                    import.handle
+                };
+
+                VMExtern::Function(handle)
+            }
+            ExportIndex::Table(index) => {
+                let handle = if let Some(def_index) = instance.module.local_table_index(index) {
+                    instance.tables[def_index]
+                } else {
+                    let import = instance.imported_table(index);
+                    import.handle
+                };
+                VMExtern::Table(handle)
+            }
+            ExportIndex::Memory(index) => {
+                let handle = if let Some(def_index) = instance.module.local_memory_index(index) {
+                    instance.memories[def_index]
+                } else {
+                    let import = instance.imported_memory(index);
+                    import.handle
+                };
+                VMExtern::Memory(handle)
+            }
+            ExportIndex::Global(index) => {
+                let handle = if let Some(def_index) = instance.module.local_global_index(index) {
+                    instance.globals[def_index]
+                } else {
+                    let import = instance.imported_global(index);
+                    import.handle
+                };
+                VMExtern::Global(handle)
+            }
+        }
+    }
+
+    /// Return an iterator over the exports of this instance.
+    ///
+    /// Specifically, it provides access to the key-value pairs, where the keys
+    /// are export names, and the values are export declarations which can be
+    /// resolved `lookup_by_declaration`.
+    pub fn exports(&self) -> indexmap::map::Iter<String, ExportIndex> {
+        self.module().exports.iter()
+    }
+
+    /// Return the memory index for the given `VMMemoryDefinition` in this instance.
+    pub fn memory_index(&self, memory: &VMMemoryDefinition) -> LocalMemoryIndex {
+        self.instance().memory_index(memory)
+    }
+
+    /// Grow memory in this instance by the specified amount of pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of pages.
+    pub fn memory_grow<IntoPages>(
+        &mut self,
+        memory_index: LocalMemoryIndex,
+        delta: IntoPages,
+    ) -> Result<Pages, MemoryError>
+    where
+        IntoPages: Into<Pages>,
+    {
+        self.instance_mut().memory_grow(memory_index, delta)
+    }
+
+    /// Return the table index for the given `VMTableDefinition` in this instance.
+    pub fn table_index(&self, table: &VMTableDefinition) -> LocalTableIndex {
+        self.instance().table_index(table)
+    }
+
+    /// Grow table in this instance by the specified amount of pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of pages.
+    pub fn table_grow(
+        &mut self,
+        table_index: LocalTableIndex,
+        delta: u32,
+        init_value: TableElement,
+    ) -> Option<u32> {
+        self.instance_mut()
+            .table_grow(table_index, delta, init_value)
+    }
+
+    /// Get table element reference.
+    ///
+    /// Returns `None` if index is out of bounds.
+    pub fn table_get(&self, table_index: LocalTableIndex, index: u32) -> Option<TableElement> {
+        self.instance().table_get(table_index, index)
+    }
+
+    /// Set table element reference.
+    ///
+    /// Returns an error if the index is out of bounds
+    pub fn table_set(
+        &mut self,
+        table_index: LocalTableIndex,
+        index: u32,
+        val: TableElement,
+    ) -> Result<(), Trap> {
+        self.instance_mut().table_set(table_index, index, val)
+    }
+
+    /// Get a table defined locally within this module.
+    pub fn get_local_table(&mut self, index: LocalTableIndex) -> &mut VMTable {
+        self.instance_mut().get_local_table(index)
+    }
+}
+
+/// Compute the offset for a memory data initializer.
+fn get_memory_init_start(init: &DataInitializer<'_>, instance: &Instance) -> usize {
+    let mut start = init.location.offset;
+
+    if let Some(base) = init.location.base {
+        let val = unsafe {
+            if let Some(def_index) = instance.module.local_global_index(base) {
+                instance.global(def_index).val.u32
+            } else {
+                instance.imported_global(base).definition.as_ref().val.u32
+            }
+        };
+        start += usize::try_from(val).unwrap();
+    }
+
+    start
+}
+
+#[allow(clippy::mut_from_ref)]
+#[allow(dead_code)]
+/// Return a byte-slice view of a memory's data.
+unsafe fn get_memory_slice<'instance>(
+    init: &DataInitializer<'_>,
+    instance: &'instance Instance,
+) -> &'instance mut [u8] {
+    let memory = if let Some(local_memory_index) = instance
+        .module
+        .local_memory_index(init.location.memory_index)
+    {
+        instance.memory(local_memory_index)
+    } else {
+        let import = instance.imported_memory(init.location.memory_index);
+        *import.definition.as_ref()
+    };
+    slice::from_raw_parts_mut(memory.base, memory.current_length)
+}
+
+/// Compute the offset for a table element initializer.
+fn get_table_init_start(init: &TableInitializer, instance: &Instance) -> usize {
+    let mut start = init.offset;
+
+    if let Some(base) = init.base {
+        let val = unsafe {
+            if let Some(def_index) = instance.module.local_global_index(base) {
+                instance.global(def_index).val.u32
+            } else {
+                instance.imported_global(base).definition.as_ref().val.u32
+            }
+        };
+        start += usize::try_from(val).unwrap();
+    }
+
+    start
+}
+
+/// Initialize the table memory from the provided initializers.
+fn initialize_tables(instance: &mut Instance) -> Result<(), Trap> {
+    let module = Arc::clone(&instance.module);
+    for init in &module.table_initializers {
+        let start = get_table_init_start(init, instance);
+        let table = instance.get_table_handle(init.table_index);
+        let table = unsafe { table.get_mut(&mut *instance.context) };
+
+        if start
+            .checked_add(init.elements.len())
+            .map_or(true, |end| end > table.size() as usize)
+        {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        for (i, func_idx) in init.elements.iter().enumerate() {
+            let anyfunc = instance.func_ref(*func_idx);
+            table
+                .set(
+                    u32::try_from(start + i).unwrap(),
+                    TableElement::FuncRef(anyfunc),
+                )
+                .unwrap();
+        }
+    }
+
+    Ok(())
+}
+
+/// Initialize the `Instance::passive_elements` map by resolving the
+/// `ModuleInfo::passive_elements`'s `FunctionIndex`s into `VMCallerCheckedAnyfunc`s for
+/// this instance.
+fn initialize_passive_elements(instance: &Instance) {
+    let mut passive_elements = instance.passive_elements.borrow_mut();
+    debug_assert!(
+        passive_elements.is_empty(),
+        "should only be called once, at initialization time"
+    );
+
+    passive_elements.extend(
+        instance
+            .module
+            .passive_elements
+            .iter()
+            .filter(|(_, segments)| !segments.is_empty())
+            .map(|(idx, segments)| {
+                (
+                    *idx,
+                    segments.iter().map(|s| instance.func_ref(*s)).collect(),
+                )
+            }),
+    );
+}
+
+/// Initialize the table memory from the provided initializers.
+fn initialize_memories(
+    instance: &mut Instance,
+    data_initializers: &[DataInitializer<'_>],
+) -> Result<(), Trap> {
+    for init in data_initializers {
+        let memory = instance.get_vmmemory(init.location.memory_index);
+
+        let start = get_memory_init_start(init, instance);
+        unsafe {
+            let current_length = memory.vmmemory().as_ref().current_length;
+            if start
+                .checked_add(init.data.len())
+                .map_or(true, |end| end > current_length)
+            {
+                return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+            }
+            memory.initialize_with_data(start, init.data)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn initialize_globals(instance: &Instance) {
+    let module = Arc::clone(&instance.module);
+    for (index, initializer) in module.global_initializers.iter() {
+        unsafe {
+            let to = instance.global_ptr(index).as_ptr();
+            match initializer {
+                GlobalInit::I32Const(x) => (*to).val.i32 = *x,
+                GlobalInit::I64Const(x) => (*to).val.i64 = *x,
+                GlobalInit::F32Const(x) => (*to).val.f32 = *x,
+                GlobalInit::F64Const(x) => (*to).val.f64 = *x,
+                GlobalInit::V128Const(x) => (*to).val.bytes = *x.bytes(),
+                GlobalInit::GetGlobal(x) => {
+                    let from: VMGlobalDefinition =
+                        if let Some(def_x) = module.local_global_index(*x) {
+                            instance.global(def_x)
+                        } else {
+                            instance.imported_global(*x).definition.as_ref().clone()
+                        };
+                    *to = from;
+                }
+                GlobalInit::RefNullConst => (*to).val.funcref = 0,
+                GlobalInit::RefFunc(func_idx) => {
+                    let funcref = instance.func_ref(*func_idx).unwrap();
+                    (*to).val = funcref.into_raw();
+                }
+            }
+        }
+    }
+}
+
+/// Eagerly builds all the `VMFuncRef`s for imported and local functions so that all
+/// future funcref operations are just looking up this data.
+fn build_funcrefs(
+    module_info: &ModuleInfo,
+    ctx: &StoreObjects,
+    imports: &Imports,
+    finished_functions: &BoxedSlice<LocalFunctionIndex, FunctionBodyPtr>,
+    vmshared_signatures: &BoxedSlice<SignatureIndex, VMSharedSignatureIndex>,
+    function_call_trampolines: &BoxedSlice<SignatureIndex, VMTrampoline>,
+    vmctx_ptr: *mut VMContext,
+) -> (
+    BoxedSlice<LocalFunctionIndex, VMCallerCheckedAnyfunc>,
+    BoxedSlice<FunctionIndex, NonNull<VMCallerCheckedAnyfunc>>,
+) {
+    let mut func_refs =
+        PrimaryMap::with_capacity(module_info.functions.len() - module_info.num_imported_functions);
+    let mut imported_func_refs = PrimaryMap::with_capacity(module_info.num_imported_functions);
+
+    // do imported functions
+    for import in imports.functions.values() {
+        imported_func_refs.push(import.handle.get(ctx).anyfunc.as_ptr());
+    }
+
+    // do local functions
+    for (local_index, func_ptr) in finished_functions.iter() {
+        let index = module_info.func_index(local_index);
+        let sig_index = module_info.functions[index];
+        let type_index = vmshared_signatures[sig_index];
+        let call_trampoline = function_call_trampolines[sig_index];
+        let anyfunc = VMCallerCheckedAnyfunc {
+            func_ptr: func_ptr.0,
+            type_index,
+            vmctx: VMFunctionContext { vmctx: vmctx_ptr },
+            call_trampoline,
+        };
+        func_refs.push(anyfunc);
+    }
+    (
+        func_refs.into_boxed_slice(),
+        imported_func_refs.into_boxed_slice(),
+    )
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/ref.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/ref.rs
new file mode 100644
index 0000000..5eafc33
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/instance/ref.rs
@@ -0,0 +1,134 @@
+use super::Instance;
+use std::alloc::Layout;
+use std::convert::TryFrom;
+use std::ptr::{self, NonNull};
+use std::sync::{Arc, Weak};
+
+/// Dynamic instance allocation.
+///
+/// This structure has a C representation because `Instance` is
+/// dynamically-sized, and the `instance` field must be last.
+///
+/// This `InstanceRef` must be freed with [`InstanceInner::deallocate_instance`]
+/// if and only if it has been set correctly. The `Drop` implementation of
+/// [`InstanceInner`] calls its `deallocate_instance` method without
+/// checking if this property holds, only when `Self.strong` is equal to 1.
+#[derive(Debug)]
+#[repr(C)]
+struct InstanceInner {
+    /// The layout of `Instance` (which can vary).
+    instance_layout: Layout,
+
+    /// The `Instance` itself. It must be the last field of
+    /// `InstanceRef` since `Instance` is dyamically-sized.
+    ///
+    /// `Instance` must not be dropped manually by Rust, because it's
+    /// allocated manually with `alloc` and a specific layout (Rust
+    /// would be able to drop `Instance` itself but it will imply a
+    /// memory leak because of `alloc`).
+    ///
+    /// No one in the code has a copy of the `Instance`'s
+    /// pointer. `Self` is the only one.
+    instance: NonNull<Instance>,
+}
+
+impl InstanceInner {
+    /// Deallocate `Instance`.
+    ///
+    /// # Safety
+    ///
+    /// `Self.instance` must be correctly set and filled before being
+    /// dropped and deallocated.
+    unsafe fn deallocate_instance(&mut self) {
+        let instance_ptr = self.instance.as_ptr();
+
+        ptr::drop_in_place(instance_ptr);
+        std::alloc::dealloc(instance_ptr as *mut u8, self.instance_layout);
+    }
+
+    /// Get a reference to the `Instance`.
+    #[inline]
+    pub(crate) fn as_ref(&self) -> &Instance {
+        // SAFETY: The pointer is properly aligned, it is
+        // “dereferencable”, it points to an initialized memory of
+        // `Instance`, and the reference has the lifetime `'a`.
+        unsafe { self.instance.as_ref() }
+    }
+
+    #[inline]
+    pub(super) fn as_mut(&mut self) -> &mut Instance {
+        unsafe { self.instance.as_mut() }
+    }
+}
+
+impl PartialEq for InstanceInner {
+    /// Two `InstanceInner` are equal if and only if
+    /// `Self.instance` points to the same location.
+    fn eq(&self, other: &Self) -> bool {
+        self.instance == other.instance
+    }
+}
+
+impl Drop for InstanceInner {
+    /// Drop the `InstanceInner`.
+    fn drop(&mut self) {
+        unsafe { Self::deallocate_instance(self) };
+    }
+}
+
+/// TODO: Review this super carefully.
+unsafe impl Send for InstanceInner {}
+unsafe impl Sync for InstanceInner {}
+
+/// An `InstanceRef` is responsible to properly deallocate,
+/// and to give access to an `Instance`, in such a way that `Instance`
+/// is unique, can be shared, safely, across threads, without
+/// duplicating the pointer in multiple locations. `InstanceRef`
+/// must be the only “owner” of an `Instance`.
+///
+/// Consequently, one must not share `Instance` but
+/// `InstanceRef`. It acts like an Atomically Reference Counter
+/// to `Instance`. In short, `InstanceRef` is roughly a
+/// simplified version of `std::sync::Arc`.
+///
+/// Note for the curious reader: [`InstanceAllocator::new`]
+/// and [`VMInstance::new`] will respectively allocate a proper
+/// `Instance` and will fill it correctly.
+///
+/// A little bit of background: The initial goal was to be able to
+/// share an [`Instance`] between an [`VMInstance`] and the module
+/// exports, so that one can drop a [`VMInstance`] but still being
+/// able to use the exports properly.
+#[derive(Debug, PartialEq, Clone)]
+pub struct InstanceRef(Arc<InstanceInner>);
+
+impl InstanceRef {
+    /// Create a new `InstanceRef`. It allocates nothing. It fills
+    /// nothing. The `Instance` must be already valid and
+    /// filled.
+    ///
+    /// # Safety
+    ///
+    /// `instance` must a non-null, non-dangling, properly aligned,
+    /// and correctly initialized pointer to `Instance`. See
+    /// [`InstanceAllocator`] for an example of how to correctly use
+    /// this API.
+    pub(super) unsafe fn new(instance: NonNull<Instance>, instance_layout: Layout) -> Self {
+        Self(Arc::new(InstanceInner {
+            instance_layout,
+            instance,
+        }))
+    }
+
+    /// Get a reference to the `Instance`.
+    #[inline]
+    pub(crate) fn as_ref(&self) -> &Instance {
+        (&*self.0).as_ref()
+    }
+
+    /// Only succeeds if ref count is 1.
+    #[inline]
+    pub(super) fn as_mut(&mut self) -> Option<&mut Instance> {
+        Some(Arc::get_mut(&mut self.0)?.as_mut())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/lib.rs
new file mode 100644
index 0000000..3ae29ea
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/lib.rs
@@ -0,0 +1,144 @@
+//! Runtime library support for Wasmer.
+
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![deny(trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![allow(clippy::new_without_default, clippy::vtable_address_comparisons)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+mod export;
+mod extern_ref;
+mod function_env;
+mod global;
+mod imports;
+mod instance;
+mod memory;
+mod mmap;
+mod probestack;
+mod sig_registry;
+mod store;
+mod table;
+mod threadconditions;
+mod trap;
+mod vmcontext;
+
+pub mod libcalls;
+
+use std::ptr::NonNull;
+
+pub use crate::export::*;
+pub use crate::extern_ref::{VMExternObj, VMExternRef};
+pub use crate::function_env::VMFunctionEnvironment;
+pub use crate::global::*;
+pub use crate::imports::Imports;
+pub use crate::instance::{InstanceAllocator, VMInstance};
+pub use crate::memory::{
+    initialize_memory_with_data, LinearMemory, NotifyLocation, VMMemory, VMOwnedMemory,
+    VMSharedMemory,
+};
+pub use crate::mmap::Mmap;
+pub use crate::probestack::PROBESTACK;
+pub use crate::sig_registry::SignatureRegistry;
+pub use crate::store::{InternalStoreHandle, MaybeInstanceOwned, StoreHandle, StoreObjects};
+pub use crate::table::{TableElement, VMTable};
+#[doc(hidden)]
+pub use crate::threadconditions::{ThreadConditions, ThreadConditionsHandle, WaiterError};
+pub use crate::trap::*;
+pub use crate::vmcontext::{
+    VMCallerCheckedAnyfunc, VMContext, VMDynamicFunctionContext, VMFunctionContext,
+    VMFunctionImport, VMFunctionKind, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition,
+    VMMemoryImport, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMTrampoline,
+};
+pub use wasmer_types::LibCall;
+pub use wasmer_types::MemoryError;
+pub use wasmer_types::MemoryStyle;
+use wasmer_types::RawValue;
+pub use wasmer_types::TableStyle;
+pub use wasmer_types::{StoreId, TargetSharedSignatureIndex, VMBuiltinFunctionIndex, VMOffsets};
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Pointers to section data.
+#[derive(Clone, Copy, Debug)]
+#[repr(transparent)]
+pub struct SectionBodyPtr(pub *const u8);
+
+impl std::ops::Deref for SectionBodyPtr {
+    type Target = *const u8;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// A placeholder byte-sized type which is just used to provide some amount of type
+/// safety when dealing with pointers to JIT-compiled function bodies. Note that it's
+/// deliberately not Copy, as we shouldn't be carelessly copying function body bytes
+/// around.
+#[repr(C)]
+pub struct VMFunctionBody(u8);
+
+#[cfg(test)]
+mod test_vmfunction_body {
+    use super::VMFunctionBody;
+    use std::mem::size_of;
+
+    #[test]
+    fn check_vmfunction_body_offsets() {
+        assert_eq!(size_of::<VMFunctionBody>(), 1);
+    }
+}
+
+/// A safe wrapper around `VMFunctionBody`.
+#[derive(Clone, Copy, Debug)]
+#[repr(transparent)]
+pub struct FunctionBodyPtr(pub *const VMFunctionBody);
+
+impl std::ops::Deref for FunctionBodyPtr {
+    type Target = *const VMFunctionBody;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// # Safety
+/// The VMFunctionBody that this points to is opaque, so there's no data to
+/// read or write through this pointer. This is essentially a usize.
+unsafe impl Send for FunctionBodyPtr {}
+/// # Safety
+/// The VMFunctionBody that this points to is opaque, so there's no data to
+/// read or write through this pointer. This is essentially a usize.
+unsafe impl Sync for FunctionBodyPtr {}
+
+/// A function reference. A single word that points to metadata about a function.
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct VMFuncRef(pub NonNull<VMCallerCheckedAnyfunc>);
+
+impl VMFuncRef {
+    /// Converts the `VMFuncRef` into a `RawValue`.
+    pub fn into_raw(self) -> RawValue {
+        RawValue {
+            funcref: self.0.as_ptr() as usize,
+        }
+    }
+
+    /// Extracts a `VMFuncRef` from a `RawValue`.
+    ///
+    /// # Safety
+    /// `raw.funcref` must be a valid pointer.
+    pub unsafe fn from_raw(raw: RawValue) -> Option<Self> {
+        NonNull::new(raw.funcref as *mut VMCallerCheckedAnyfunc).map(Self)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/libcalls.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/libcalls.rs
new file mode 100644
index 0000000..f4043ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/libcalls.rs
@@ -0,0 +1,859 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Runtime library calls.
+//!
+//! Note that Wasm compilers may sometimes perform these inline rather than
+//! calling them, particularly when CPUs have special instructions which compute
+//! them directly.
+//!
+//! These functions are called by compiled Wasm code, and therefore must take
+//! certain care about some things:
+//!
+//! * They must always be `pub extern "C"` and should only contain basic, raw
+//!   i32/i64/f32/f64/pointer parameters that are safe to pass across the system
+//!   ABI!
+//!
+//! * If any nested function propagates an `Err(trap)` out to the library
+//!   function frame, we need to raise it. This involves some nasty and quite
+//!   unsafe code under the covers! Notable, after raising the trap, drops
+//!   **will not** be run for local variables! This can lead to things like
+//!   leaking `VMInstance`s which leads to never deallocating JIT code,
+//!   instances, and modules! Therefore, always use nested blocks to ensure
+//!   drops run before raising a trap:
+//!
+//!   ```ignore
+//!   pub extern "C" fn my_lib_function(...) {
+//!       let result = {
+//!           // Do everything in here so drops run at the end of the block.
+//!           ...
+//!       };
+//!       if let Err(trap) = result {
+//!           // Now we can safely raise the trap without leaking!
+//!           raise_lib_trap(trap);
+//!       }
+//!   }
+//!   ```
+
+#![allow(missing_docs)] // For some reason lint fails saying that `LibCall` is not documented, when it actually is
+
+use crate::probestack::PROBESTACK;
+use crate::table::{RawTableElement, TableElement};
+use crate::trap::{raise_lib_trap, Trap, TrapCode};
+use crate::vmcontext::VMContext;
+use crate::{on_host_stack, VMFuncRef};
+pub use wasmer_types::LibCall;
+use wasmer_types::{
+    DataIndex, ElemIndex, FunctionIndex, LocalMemoryIndex, LocalTableIndex, MemoryIndex,
+    TableIndex, Type,
+};
+
+/// Implementation of f32.ceil
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f32_ceil(x: f32) -> f32 {
+    x.ceil()
+}
+
+/// Implementation of f32.floor
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f32_floor(x: f32) -> f32 {
+    x.floor()
+}
+
+/// Implementation of f32.trunc
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f32_trunc(x: f32) -> f32 {
+    x.trunc()
+}
+
+/// Implementation of f32.nearest
+#[allow(clippy::float_arithmetic, clippy::float_cmp)]
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f32_nearest(x: f32) -> f32 {
+    // Rust doesn't have a nearest function, so do it manually.
+    if x == 0.0 {
+        // Preserve the sign of zero.
+        x
+    } else {
+        // Nearest is either ceil or floor depending on which is nearest or even.
+        let u = x.ceil();
+        let d = x.floor();
+        let um = (x - u).abs();
+        let dm = (x - d).abs();
+        if um < dm
+            || (um == dm && {
+                let h = u / 2.;
+                h.floor() == h
+            })
+        {
+            u
+        } else {
+            d
+        }
+    }
+}
+
+/// Implementation of f64.ceil
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f64_ceil(x: f64) -> f64 {
+    x.ceil()
+}
+
+/// Implementation of f64.floor
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f64_floor(x: f64) -> f64 {
+    x.floor()
+}
+
+/// Implementation of f64.trunc
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f64_trunc(x: f64) -> f64 {
+    x.trunc()
+}
+
+/// Implementation of f64.nearest
+#[allow(clippy::float_arithmetic, clippy::float_cmp)]
+#[no_mangle]
+pub extern "C" fn wasmer_vm_f64_nearest(x: f64) -> f64 {
+    // Rust doesn't have a nearest function, so do it manually.
+    if x == 0.0 {
+        // Preserve the sign of zero.
+        x
+    } else {
+        // Nearest is either ceil or floor depending on which is nearest or even.
+        let u = x.ceil();
+        let d = x.floor();
+        let um = (x - u).abs();
+        let dm = (x - d).abs();
+        if um < dm
+            || (um == dm && {
+                let h = u / 2.;
+                h.floor() == h
+            })
+        {
+            u
+        } else {
+            d
+        }
+    }
+}
+
+/// Implementation of memory.grow for locally-defined 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_grow(
+    vmctx: *mut VMContext,
+    delta: u32,
+    memory_index: u32,
+) -> u32 {
+    on_host_stack(|| {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+        instance
+            .memory_grow(memory_index, delta)
+            .map(|pages| pages.0)
+            .unwrap_or(u32::max_value())
+    })
+}
+
+/// Implementation of memory.grow for imported 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_grow(
+    vmctx: *mut VMContext,
+    delta: u32,
+    memory_index: u32,
+) -> u32 {
+    on_host_stack(|| {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = MemoryIndex::from_u32(memory_index);
+
+        instance
+            .imported_memory_grow(memory_index, delta)
+            .map(|pages| pages.0)
+            .unwrap_or(u32::max_value())
+    })
+}
+
+/// Implementation of memory.size for locally-defined 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_size(vmctx: *mut VMContext, memory_index: u32) -> u32 {
+    let instance = (*vmctx).instance();
+    let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+    instance.memory_size(memory_index).0
+}
+
+/// Implementation of memory.size for imported 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_size(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+) -> u32 {
+    let instance = (*vmctx).instance();
+    let memory_index = MemoryIndex::from_u32(memory_index);
+
+    instance.imported_memory_size(memory_index).0
+}
+
+/// Implementation of `table.copy`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_copy(
+    vmctx: *mut VMContext,
+    dst_table_index: u32,
+    src_table_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) {
+    let result = {
+        let dst_table_index = TableIndex::from_u32(dst_table_index);
+        let src_table_index = TableIndex::from_u32(src_table_index);
+        if dst_table_index == src_table_index {
+            let table = (*vmctx).instance_mut().get_table(dst_table_index);
+            table.copy_within(dst, src, len)
+        } else {
+            let dst_table = (*vmctx).instance_mut().get_table(dst_table_index);
+            let src_table = (*vmctx).instance_mut().get_table(src_table_index);
+            dst_table.copy(src_table, dst, src, len)
+        }
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `table.init`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_init(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    elem_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) {
+    let result = {
+        let table_index = TableIndex::from_u32(table_index);
+        let elem_index = ElemIndex::from_u32(elem_index);
+        let instance = (*vmctx).instance_mut();
+        instance.table_init(table_index, elem_index, dst, src, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `table.fill`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_fill(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    start_idx: u32,
+    item: RawTableElement,
+    len: u32,
+) {
+    let result = {
+        let table_index = TableIndex::from_u32(table_index);
+        let instance = (*vmctx).instance_mut();
+        let elem = match instance.get_table(table_index).ty().ty {
+            Type::ExternRef => TableElement::ExternRef(item.extern_ref),
+            Type::FuncRef => TableElement::FuncRef(item.func_ref),
+            _ => panic!("Unrecognized table type: does not contain references"),
+        };
+
+        instance.table_fill(table_index, start_idx, elem, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `table.size`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_size(vmctx: *mut VMContext, table_index: u32) -> u32 {
+    let instance = (*vmctx).instance();
+    let table_index = LocalTableIndex::from_u32(table_index);
+
+    instance.table_size(table_index)
+}
+
+/// Implementation of `table.size` for imported tables.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_table_size(
+    vmctx: *mut VMContext,
+    table_index: u32,
+) -> u32 {
+    let instance = (*vmctx).instance();
+    let table_index = TableIndex::from_u32(table_index);
+
+    instance.imported_table_size(table_index)
+}
+
+/// Implementation of `table.get`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_get(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    elem_index: u32,
+) -> RawTableElement {
+    let instance = (*vmctx).instance();
+    let table_index = LocalTableIndex::from_u32(table_index);
+
+    // TODO: type checking, maybe have specialized accessors
+    match instance.table_get(table_index, elem_index) {
+        Some(table_ref) => table_ref.into(),
+        None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+    }
+}
+
+/// Implementation of `table.get` for imported tables.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_table_get(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    elem_index: u32,
+) -> RawTableElement {
+    let instance = (*vmctx).instance_mut();
+    let table_index = TableIndex::from_u32(table_index);
+
+    // TODO: type checking, maybe have specialized accessors
+    match instance.imported_table_get(table_index, elem_index) {
+        Some(table_ref) => table_ref.into(),
+        None => raise_lib_trap(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+    }
+}
+
+/// Implementation of `table.set`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+///
+/// It is the caller's responsibility to increment the ref count of any ref counted
+/// type before passing it to this function.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_set(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    elem_index: u32,
+    value: RawTableElement,
+) {
+    let instance = (*vmctx).instance_mut();
+    let table_index = TableIndex::from_u32(table_index);
+    let table_index = instance
+        .module_ref()
+        .local_table_index(table_index)
+        .unwrap();
+
+    let elem = match instance.get_local_table(table_index).ty().ty {
+        Type::ExternRef => TableElement::ExternRef(value.extern_ref),
+        Type::FuncRef => TableElement::FuncRef(value.func_ref),
+        _ => panic!("Unrecognized table type: does not contain references"),
+    };
+
+    // TODO: type checking, maybe have specialized accessors
+    let result = instance.table_set(table_index, elem_index, elem);
+
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `table.set` for imported tables.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_table_set(
+    vmctx: *mut VMContext,
+    table_index: u32,
+    elem_index: u32,
+    value: RawTableElement,
+) {
+    let instance = (*vmctx).instance_mut();
+    let table_index = TableIndex::from_u32(table_index);
+    let elem = match instance.get_table(table_index).ty().ty {
+        Type::ExternRef => TableElement::ExternRef(value.extern_ref),
+        Type::FuncRef => TableElement::FuncRef(value.func_ref),
+        _ => panic!("Unrecognized table type: does not contain references"),
+    };
+
+    let result = instance.imported_table_set(table_index, elem_index, elem);
+
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `table.grow` for locally-defined tables.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_table_grow(
+    vmctx: *mut VMContext,
+    init_value: RawTableElement,
+    delta: u32,
+    table_index: u32,
+) -> u32 {
+    on_host_stack(|| {
+        let instance = (*vmctx).instance_mut();
+        let table_index = LocalTableIndex::from_u32(table_index);
+
+        let init_value = match instance.get_local_table(table_index).ty().ty {
+            Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
+            Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
+            _ => panic!("Unrecognized table type: does not contain references"),
+        };
+
+        instance
+            .table_grow(table_index, delta, init_value)
+            .unwrap_or(u32::max_value())
+    })
+}
+
+/// Implementation of `table.grow` for imported tables.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_table_grow(
+    vmctx: *mut VMContext,
+    init_value: RawTableElement,
+    delta: u32,
+    table_index: u32,
+) -> u32 {
+    on_host_stack(|| {
+        let instance = (*vmctx).instance_mut();
+        let table_index = TableIndex::from_u32(table_index);
+        let init_value = match instance.get_table(table_index).ty().ty {
+            Type::ExternRef => TableElement::ExternRef(init_value.extern_ref),
+            Type::FuncRef => TableElement::FuncRef(init_value.func_ref),
+            _ => panic!("Unrecognized table type: does not contain references"),
+        };
+
+        instance
+            .imported_table_grow(table_index, delta, init_value)
+            .unwrap_or(u32::max_value())
+    })
+}
+
+/// Implementation of `func.ref`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_func_ref(
+    vmctx: *mut VMContext,
+    function_index: u32,
+) -> VMFuncRef {
+    let instance = (*vmctx).instance();
+    let function_index = FunctionIndex::from_u32(function_index);
+
+    instance.func_ref(function_index).unwrap()
+}
+
+/// Implementation of `elem.drop`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_elem_drop(vmctx: *mut VMContext, elem_index: u32) {
+    on_host_stack(|| {
+        let elem_index = ElemIndex::from_u32(elem_index);
+        let instance = (*vmctx).instance();
+        instance.elem_drop(elem_index);
+    })
+}
+
+/// Implementation of `memory.copy` for locally defined memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_copy(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) {
+    let result = {
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+        let instance = (*vmctx).instance();
+        instance.local_memory_copy(memory_index, dst, src, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `memory.copy` for imported memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_copy(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) {
+    let result = {
+        let memory_index = MemoryIndex::from_u32(memory_index);
+        let instance = (*vmctx).instance();
+        instance.imported_memory_copy(memory_index, dst, src, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `memory.fill` for locally defined memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_fill(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u32,
+    len: u32,
+) {
+    let result = {
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+        let instance = (*vmctx).instance();
+        instance.local_memory_fill(memory_index, dst, val, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `memory.fill` for imported memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_fill(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u32,
+    len: u32,
+) {
+    let result = {
+        let memory_index = MemoryIndex::from_u32(memory_index);
+        let instance = (*vmctx).instance();
+        instance.imported_memory_fill(memory_index, dst, val, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `memory.init`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_init(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    data_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) {
+    let result = {
+        let memory_index = MemoryIndex::from_u32(memory_index);
+        let data_index = DataIndex::from_u32(data_index);
+        let instance = (*vmctx).instance();
+        instance.memory_init(memory_index, data_index, dst, src, len)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+}
+
+/// Implementation of `data.drop`.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_data_drop(vmctx: *mut VMContext, data_index: u32) {
+    on_host_stack(|| {
+        let data_index = DataIndex::from_u32(data_index);
+        let instance = (*vmctx).instance();
+        instance.data_drop(data_index)
+    })
+}
+
+/// Implementation for raising a trap
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `wasmer_call` or
+/// `wasmer_call_trampoline` must have been previously called.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_raise_trap(trap_code: TrapCode) -> ! {
+    let trap = Trap::lib(trap_code);
+    raise_lib_trap(trap)
+}
+
+/// Probestack check
+///
+/// # Safety
+///
+/// This function does not follow the standard function ABI, and is called as
+/// part of the function prologue.
+#[no_mangle]
+pub static wasmer_vm_probestack: unsafe extern "C" fn() = PROBESTACK;
+
+/// Implementation of memory.wait32 for locally-defined 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait32(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u32,
+    timeout: i64,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+        instance.local_memory_wait32(memory_index, dst, val, timeout)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// Implementation of memory.wait32 for imported 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait32(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u32,
+    timeout: i64,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = MemoryIndex::from_u32(memory_index);
+
+        instance.imported_memory_wait32(memory_index, dst, val, timeout)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// Implementation of memory.wait64 for locally-defined 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_atomic_wait64(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u64,
+    timeout: i64,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+        instance.local_memory_wait64(memory_index, dst, val, timeout)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// Implementation of memory.wait64 for imported 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_wait64(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    val: u64,
+    timeout: i64,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = MemoryIndex::from_u32(memory_index);
+
+        instance.imported_memory_wait64(memory_index, dst, val, timeout)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// Implementation of memory.notfy for locally-defined 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_memory32_atomic_notify(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    cnt: u32,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = LocalMemoryIndex::from_u32(memory_index);
+
+        instance.local_memory_notify(memory_index, dst, cnt)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// Implementation of memory.notfy for imported 32-bit memories.
+///
+/// # Safety
+///
+/// `vmctx` must be dereferenceable.
+#[no_mangle]
+pub unsafe extern "C" fn wasmer_vm_imported_memory32_atomic_notify(
+    vmctx: *mut VMContext,
+    memory_index: u32,
+    dst: u32,
+    cnt: u32,
+) -> u32 {
+    let result = {
+        let instance = (*vmctx).instance_mut();
+        let memory_index = MemoryIndex::from_u32(memory_index);
+
+        instance.imported_memory_notify(memory_index, dst, cnt)
+    };
+    if let Err(trap) = result {
+        raise_lib_trap(trap);
+    }
+    result.unwrap()
+}
+
+/// The function pointer to a libcall
+pub fn function_pointer(libcall: LibCall) -> usize {
+    match libcall {
+        LibCall::CeilF32 => wasmer_vm_f32_ceil as usize,
+        LibCall::CeilF64 => wasmer_vm_f64_ceil as usize,
+        LibCall::FloorF32 => wasmer_vm_f32_floor as usize,
+        LibCall::FloorF64 => wasmer_vm_f64_floor as usize,
+        LibCall::NearestF32 => wasmer_vm_f32_nearest as usize,
+        LibCall::NearestF64 => wasmer_vm_f64_nearest as usize,
+        LibCall::TruncF32 => wasmer_vm_f32_trunc as usize,
+        LibCall::TruncF64 => wasmer_vm_f64_trunc as usize,
+        LibCall::Memory32Size => wasmer_vm_memory32_size as usize,
+        LibCall::ImportedMemory32Size => wasmer_vm_imported_memory32_size as usize,
+        LibCall::TableCopy => wasmer_vm_table_copy as usize,
+        LibCall::TableInit => wasmer_vm_table_init as usize,
+        LibCall::TableFill => wasmer_vm_table_fill as usize,
+        LibCall::TableSize => wasmer_vm_table_size as usize,
+        LibCall::ImportedTableSize => wasmer_vm_imported_table_size as usize,
+        LibCall::TableGet => wasmer_vm_table_get as usize,
+        LibCall::ImportedTableGet => wasmer_vm_imported_table_get as usize,
+        LibCall::TableSet => wasmer_vm_table_set as usize,
+        LibCall::ImportedTableSet => wasmer_vm_imported_table_set as usize,
+        LibCall::TableGrow => wasmer_vm_table_grow as usize,
+        LibCall::ImportedTableGrow => wasmer_vm_imported_table_grow as usize,
+        LibCall::FuncRef => wasmer_vm_func_ref as usize,
+        LibCall::ElemDrop => wasmer_vm_elem_drop as usize,
+        LibCall::Memory32Copy => wasmer_vm_memory32_copy as usize,
+        LibCall::ImportedMemory32Copy => wasmer_vm_imported_memory32_copy as usize,
+        LibCall::Memory32Fill => wasmer_vm_memory32_fill as usize,
+        LibCall::ImportedMemory32Fill => wasmer_vm_imported_memory32_fill as usize,
+        LibCall::Memory32Init => wasmer_vm_memory32_init as usize,
+        LibCall::DataDrop => wasmer_vm_data_drop as usize,
+        LibCall::Probestack => wasmer_vm_probestack as usize,
+        LibCall::RaiseTrap => wasmer_vm_raise_trap as usize,
+        LibCall::Memory32AtomicWait32 => wasmer_vm_memory32_atomic_wait32 as usize,
+        LibCall::ImportedMemory32AtomicWait32 => wasmer_vm_imported_memory32_atomic_wait32 as usize,
+        LibCall::Memory32AtomicWait64 => wasmer_vm_memory32_atomic_wait64 as usize,
+        LibCall::ImportedMemory32AtomicWait64 => wasmer_vm_imported_memory32_atomic_wait64 as usize,
+        LibCall::Memory32AtomicNotify => wasmer_vm_memory32_atomic_notify as usize,
+        LibCall::ImportedMemory32AtomicNotify => wasmer_vm_imported_memory32_atomic_notify as usize,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/memory.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/memory.rs
new file mode 100644
index 0000000..61f956d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/memory.rs
@@ -0,0 +1,757 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Memory management for linear memories.
+//!
+//! `Memory` is to WebAssembly linear memories what `Table` is to WebAssembly tables.
+
+use crate::threadconditions::ThreadConditions;
+pub use crate::threadconditions::{NotifyLocation, WaiterError};
+use crate::trap::Trap;
+use crate::{mmap::Mmap, store::MaybeInstanceOwned, vmcontext::VMMemoryDefinition};
+use more_asserts::assert_ge;
+use std::cell::UnsafeCell;
+use std::convert::TryInto;
+use std::ptr::NonNull;
+use std::rc::Rc;
+use std::slice;
+use std::sync::RwLock;
+use std::time::Duration;
+use wasmer_types::{Bytes, MemoryError, MemoryStyle, MemoryType, Pages, WASM_PAGE_SIZE};
+
+// The memory mapped area
+#[derive(Debug)]
+struct WasmMmap {
+    // Our OS allocation of mmap'd memory.
+    alloc: Mmap,
+    // The current logical size in wasm pages of this linear memory.
+    size: Pages,
+    /// The owned memory definition used by the generated code
+    vm_memory_definition: MaybeInstanceOwned<VMMemoryDefinition>,
+}
+
+impl WasmMmap {
+    fn get_vm_memory_definition(&self) -> NonNull<VMMemoryDefinition> {
+        self.vm_memory_definition.as_ptr()
+    }
+
+    fn size(&self) -> Pages {
+        unsafe {
+            let md_ptr = self.get_vm_memory_definition();
+            let md = md_ptr.as_ref();
+            Bytes::from(md.current_length).try_into().unwrap()
+        }
+    }
+
+    fn grow(&mut self, delta: Pages, conf: VMMemoryConfig) -> Result<Pages, MemoryError> {
+        // Optimization of memory.grow 0 calls.
+        if delta.0 == 0 {
+            return Ok(self.size);
+        }
+
+        let new_pages = self
+            .size
+            .checked_add(delta)
+            .ok_or(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            })?;
+        let prev_pages = self.size;
+
+        if let Some(maximum) = conf.maximum {
+            if new_pages > maximum {
+                return Err(MemoryError::CouldNotGrow {
+                    current: self.size,
+                    attempted_delta: delta,
+                });
+            }
+        }
+
+        // Wasm linear memories are never allowed to grow beyond what is
+        // indexable. If the memory has no maximum, enforce the greatest
+        // limit here.
+        if new_pages >= Pages::max_value() {
+            // Linear memory size would exceed the index range.
+            return Err(MemoryError::CouldNotGrow {
+                current: self.size,
+                attempted_delta: delta,
+            });
+        }
+
+        let delta_bytes = delta.bytes().0;
+        let prev_bytes = prev_pages.bytes().0;
+        let new_bytes = new_pages.bytes().0;
+
+        if new_bytes > self.alloc.len() - conf.offset_guard_size {
+            // If the new size is within the declared maximum, but needs more memory than we
+            // have on hand, it's a dynamic heap and it can move.
+            let guard_bytes = conf.offset_guard_size;
+            let request_bytes =
+                new_bytes
+                    .checked_add(guard_bytes)
+                    .ok_or_else(|| MemoryError::CouldNotGrow {
+                        current: new_pages,
+                        attempted_delta: Bytes(guard_bytes).try_into().unwrap(),
+                    })?;
+
+            let mut new_mmap =
+                Mmap::accessible_reserved(new_bytes, request_bytes).map_err(MemoryError::Region)?;
+
+            let copy_len = self.alloc.len() - conf.offset_guard_size;
+            new_mmap.as_mut_slice()[..copy_len].copy_from_slice(&self.alloc.as_slice()[..copy_len]);
+
+            self.alloc = new_mmap;
+        } else if delta_bytes > 0 {
+            // Make the newly allocated pages accessible.
+            self.alloc
+                .make_accessible(prev_bytes, delta_bytes)
+                .map_err(MemoryError::Region)?;
+        }
+
+        self.size = new_pages;
+
+        // update memory definition
+        unsafe {
+            let mut md_ptr = self.vm_memory_definition.as_ptr();
+            let md = md_ptr.as_mut();
+            md.current_length = new_pages.bytes().0;
+            md.base = self.alloc.as_mut_ptr() as _;
+        }
+
+        Ok(prev_pages)
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64, conf: VMMemoryConfig) -> Result<(), MemoryError> {
+        let cur_size = self.size.bytes().0 as u64;
+        if cur_size < min_size {
+            let growth = min_size - cur_size;
+            let growth_pages = ((growth - 1) / WASM_PAGE_SIZE as u64) + 1;
+            self.grow(Pages(growth_pages as u32), conf)?;
+        }
+
+        Ok(())
+    }
+
+    /// Resets the memory down to a zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.size.0 = 0;
+        Ok(())
+    }
+
+    /// Copies the memory
+    /// (in this case it performs a copy-on-write to save memory)
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        let mem_length = self.size.bytes().0;
+        let mut alloc = self
+            .alloc
+            .copy(Some(mem_length))
+            .map_err(MemoryError::Generic)?;
+        let base_ptr = alloc.as_mut_ptr();
+        Ok(Self {
+            vm_memory_definition: MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(
+                VMMemoryDefinition {
+                    base: base_ptr,
+                    current_length: mem_length,
+                },
+            ))),
+            alloc,
+            size: self.size,
+        })
+    }
+}
+
+/// A linear memory instance.
+#[derive(Debug, Clone)]
+struct VMMemoryConfig {
+    // The optional maximum size in wasm pages of this linear memory.
+    maximum: Option<Pages>,
+    /// The WebAssembly linear memory description.
+    memory: MemoryType,
+    /// Our chosen implementation style.
+    style: MemoryStyle,
+    // Size in bytes of extra guard pages after the end to optimize loads and stores with
+    // constant offsets.
+    offset_guard_size: usize,
+}
+
+impl VMMemoryConfig {
+    fn ty(&self, minimum: Pages) -> MemoryType {
+        let mut out = self.memory;
+        out.minimum = minimum;
+
+        out
+    }
+
+    fn style(&self) -> MemoryStyle {
+        self.style
+    }
+}
+
+/// A linear memory instance.
+#[derive(Debug)]
+pub struct VMOwnedMemory {
+    // The underlying allocation.
+    mmap: WasmMmap,
+    // Configuration of this memory
+    config: VMMemoryConfig,
+}
+
+unsafe impl Send for VMOwnedMemory {}
+unsafe impl Sync for VMOwnedMemory {}
+
+impl VMOwnedMemory {
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        unsafe { Self::new_internal(memory, style, None) }
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Self::new_internal(memory, style, Some(vm_memory_location))
+    }
+
+    /// Build a `Memory` with either self-owned or VM owned metadata.
+    unsafe fn new_internal(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: Option<NonNull<VMMemoryDefinition>>,
+    ) -> Result<Self, MemoryError> {
+        if memory.minimum > Pages::max_value() {
+            return Err(MemoryError::MinimumMemoryTooLarge {
+                min_requested: memory.minimum,
+                max_allowed: Pages::max_value(),
+            });
+        }
+        // `maximum` cannot be set to more than `65536` pages.
+        if let Some(max) = memory.maximum {
+            if max > Pages::max_value() {
+                return Err(MemoryError::MaximumMemoryTooLarge {
+                    max_requested: max,
+                    max_allowed: Pages::max_value(),
+                });
+            }
+            if max < memory.minimum {
+                return Err(MemoryError::InvalidMemory {
+                    reason: format!(
+                        "the maximum ({} pages) is less than the minimum ({} pages)",
+                        max.0, memory.minimum.0
+                    ),
+                });
+            }
+        }
+
+        let offset_guard_bytes = style.offset_guard_size() as usize;
+
+        let minimum_pages = match style {
+            MemoryStyle::Dynamic { .. } => memory.minimum,
+            MemoryStyle::Static { bound, .. } => {
+                assert_ge!(*bound, memory.minimum);
+                *bound
+            }
+        };
+        let minimum_bytes = minimum_pages.bytes().0;
+        let request_bytes = minimum_bytes.checked_add(offset_guard_bytes).unwrap();
+        let mapped_pages = memory.minimum;
+        let mapped_bytes = mapped_pages.bytes();
+
+        let mut alloc = Mmap::accessible_reserved(mapped_bytes.0, request_bytes)
+            .map_err(MemoryError::Region)?;
+        let base_ptr = alloc.as_mut_ptr();
+        let mem_length = memory.minimum.bytes().0;
+        let mmap = WasmMmap {
+            vm_memory_definition: if let Some(mem_loc) = vm_memory_location {
+                {
+                    let mut ptr = mem_loc;
+                    let md = ptr.as_mut();
+                    md.base = base_ptr;
+                    md.current_length = mem_length;
+                }
+                MaybeInstanceOwned::Instance(mem_loc)
+            } else {
+                MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMMemoryDefinition {
+                    base: base_ptr,
+                    current_length: mem_length,
+                })))
+            },
+            alloc,
+            size: memory.minimum,
+        };
+
+        Ok(Self {
+            mmap,
+            config: VMMemoryConfig {
+                maximum: memory.maximum,
+                offset_guard_size: offset_guard_bytes,
+                memory: *memory,
+                style: *style,
+            },
+        })
+    }
+
+    /// Converts this owned memory into shared memory
+    pub fn to_shared(self) -> VMSharedMemory {
+        VMSharedMemory {
+            mmap: Rc::new(RwLock::new(self.mmap)),
+            config: self.config,
+            conditions: ThreadConditions::new(),
+        }
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        Ok(Self {
+            mmap: self.mmap.copy()?,
+            config: self.config.clone(),
+        })
+    }
+}
+
+impl LinearMemory for VMOwnedMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        let minimum = self.mmap.size();
+        self.config.ty(minimum)
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        self.mmap.size()
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.config.style()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        self.mmap.grow(delta, self.config.clone())
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        self.mmap.grow_at_least(min_size, self.config.clone())
+    }
+
+    /// Resets the memory down to a zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.mmap.reset()?;
+        Ok(())
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        self.mmap.vm_memory_definition.as_ptr()
+    }
+
+    /// Owned memory can not be cloned (this will always return None)
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        Err(MemoryError::MemoryNotShared)
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        let forked = Self::copy(self)?;
+        Ok(Box::new(forked))
+    }
+}
+
+/// A shared linear memory instance.
+#[derive(Debug, Clone)]
+pub struct VMSharedMemory {
+    // The underlying allocation.
+    mmap: Rc<RwLock<WasmMmap>>,
+    // Configuration of this memory
+    config: VMMemoryConfig,
+    // waiters list for this memory
+    conditions: ThreadConditions,
+}
+
+unsafe impl Send for VMSharedMemory {}
+unsafe impl Sync for VMSharedMemory {}
+
+impl VMSharedMemory {
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        Ok(VMOwnedMemory::new(memory, style)?.to_shared())
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Ok(VMOwnedMemory::from_definition(memory, style, vm_memory_location)?.to_shared())
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Self, MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        Ok(Self {
+            mmap: Rc::new(RwLock::new(guard.copy()?)),
+            config: self.config.clone(),
+            conditions: ThreadConditions::new(),
+        })
+    }
+}
+
+impl LinearMemory for VMSharedMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        let minimum = {
+            let guard = self.mmap.read().unwrap();
+            guard.size()
+        };
+        self.config.ty(minimum)
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        let guard = self.mmap.read().unwrap();
+        guard.size()
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.config.style()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.grow(delta, self.config.clone())
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.grow_at_least(min_size, self.config.clone())
+    }
+
+    /// Resets the memory down to a zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        let mut guard = self.mmap.write().unwrap();
+        guard.reset()?;
+        Ok(())
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        let guard = self.mmap.read().unwrap();
+        guard.vm_memory_definition.as_ptr()
+    }
+
+    /// Shared memory can always be cloned
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        Ok(Box::new(self.clone()))
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        let forked = Self::copy(self)?;
+        Ok(Box::new(forked))
+    }
+
+    // Add current thread to waiter list
+    fn do_wait(
+        &mut self,
+        dst: NotifyLocation,
+        timeout: Option<Duration>,
+    ) -> Result<u32, WaiterError> {
+        self.conditions.do_wait(dst, timeout)
+    }
+
+    /// Notify waiters from the wait list. Return the number of waiters notified
+    fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+        self.conditions.do_notify(dst, count)
+    }
+
+    fn thread_conditions(&self) -> Option<&ThreadConditions> {
+        Some(&self.conditions)
+    }
+}
+
+impl From<VMOwnedMemory> for VMMemory {
+    fn from(mem: VMOwnedMemory) -> Self {
+        Self(Box::new(mem))
+    }
+}
+
+impl From<VMSharedMemory> for VMMemory {
+    fn from(mem: VMSharedMemory) -> Self {
+        Self(Box::new(mem))
+    }
+}
+
+/// Represents linear memory that can be either owned or shared
+#[derive(Debug)]
+pub struct VMMemory(pub Box<dyn LinearMemory + 'static>);
+
+impl From<Box<dyn LinearMemory + 'static>> for VMMemory {
+    fn from(mem: Box<dyn LinearMemory + 'static>) -> Self {
+        Self(mem)
+    }
+}
+
+impl LinearMemory for VMMemory {
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType {
+        self.0.ty()
+    }
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages {
+        self.0.size()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+        self.0.grow(delta)
+    }
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, min_size: u64) -> Result<(), MemoryError> {
+        self.0.grow_at_least(min_size)
+    }
+
+    /// Resets the memory down to a zero size
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        self.0.reset()?;
+        Ok(())
+    }
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle {
+        self.0.style()
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+        self.0.vmmemory()
+    }
+
+    /// Attempts to clone this memory (if its clonable)
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        self.0.try_clone()
+    }
+
+    /// Initialize memory with data
+    unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
+        self.0.initialize_with_data(start, data)
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        self.0.copy()
+    }
+
+    // Add current thread to waiter list
+    fn do_wait(
+        &mut self,
+        dst: NotifyLocation,
+        timeout: Option<Duration>,
+    ) -> Result<u32, WaiterError> {
+        self.0.do_wait(dst, timeout)
+    }
+
+    /// Notify waiters from the wait list. Return the number of waiters notified
+    fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+        self.0.do_notify(dst, count)
+    }
+
+    fn thread_conditions(&self) -> Option<&ThreadConditions> {
+        self.0.thread_conditions()
+    }
+}
+
+impl VMMemory {
+    /// Creates a new linear memory instance of the correct type with specified
+    /// minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with owned metadata: this can be used to create a memory
+    /// that will be imported into Wasm modules.
+    pub fn new(memory: &MemoryType, style: &MemoryStyle) -> Result<Self, MemoryError> {
+        Ok(if memory.shared {
+            Self(Box::new(VMSharedMemory::new(memory, style)?))
+        } else {
+            Self(Box::new(VMOwnedMemory::new(memory, style)?))
+        })
+    }
+
+    /// Returns the number of pages in the allocated memory block
+    pub fn get_runtime_size(&self) -> u32 {
+        self.0.size().0
+    }
+
+    /// Create a new linear memory instance with specified minimum and maximum number of wasm pages.
+    ///
+    /// This creates a `Memory` with metadata owned by a VM, pointed to by
+    /// `vm_memory_location`: this can be used to create a local memory.
+    ///
+    /// # Safety
+    /// - `vm_memory_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        memory: &MemoryType,
+        style: &MemoryStyle,
+        vm_memory_location: NonNull<VMMemoryDefinition>,
+    ) -> Result<Self, MemoryError> {
+        Ok(if memory.shared {
+            Self(Box::new(VMSharedMemory::from_definition(
+                memory,
+                style,
+                vm_memory_location,
+            )?))
+        } else {
+            Self(Box::new(VMOwnedMemory::from_definition(
+                memory,
+                style,
+                vm_memory_location,
+            )?))
+        })
+    }
+
+    /// Creates VMMemory from a custom implementation - the following into implementations
+    /// are natively supported
+    /// - VMOwnedMemory -> VMMemory
+    /// - Box<dyn LinearMemory + 'static> -> VMMemory
+    pub fn from_custom<IntoVMMemory>(memory: IntoVMMemory) -> Self
+    where
+        IntoVMMemory: Into<Self>,
+    {
+        memory.into()
+    }
+
+    /// Copies this memory to a new memory
+    pub fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError> {
+        LinearMemory::copy(self)
+    }
+}
+
+#[doc(hidden)]
+/// Default implementation to initialize memory with data
+pub unsafe fn initialize_memory_with_data(
+    memory: &VMMemoryDefinition,
+    start: usize,
+    data: &[u8],
+) -> Result<(), Trap> {
+    let mem_slice = slice::from_raw_parts_mut(memory.base, memory.current_length);
+    let end = start + data.len();
+    let to_init = &mut mem_slice[start..end];
+    to_init.copy_from_slice(data);
+
+    Ok(())
+}
+
+/// Represents memory that is used by the WebAsssembly module
+pub trait LinearMemory
+where
+    Self: std::fmt::Debug + Send,
+{
+    /// Returns the type for this memory.
+    fn ty(&self) -> MemoryType;
+
+    /// Returns the size of hte memory in pages
+    fn size(&self) -> Pages;
+
+    /// Returns the memory style for this memory.
+    fn style(&self) -> MemoryStyle;
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages.
+    fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError>;
+
+    /// Grows the memory to at least a minimum size. If the memory is already big enough
+    /// for the min size then this function does nothing
+    fn grow_at_least(&mut self, _min_size: u64) -> Result<(), MemoryError> {
+        Err(MemoryError::UnsupportedOperation {
+            message: "grow_at_least() is not supported".to_string(),
+        })
+    }
+
+    /// Resets the memory back to zero length
+    fn reset(&mut self) -> Result<(), MemoryError> {
+        Err(MemoryError::UnsupportedOperation {
+            message: "reset() is not supported".to_string(),
+        })
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    fn vmmemory(&self) -> NonNull<VMMemoryDefinition>;
+
+    /// Attempts to clone this memory (if its clonable)
+    fn try_clone(&self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError>;
+
+    #[doc(hidden)]
+    /// # Safety
+    /// This function is unsafe because WebAssembly specification requires that data is always set at initialization time.
+    /// It should be the implementors responsibility to make sure this respects the spec
+    unsafe fn initialize_with_data(&self, start: usize, data: &[u8]) -> Result<(), Trap> {
+        let memory = self.vmmemory().as_ref();
+
+        initialize_memory_with_data(memory, start, data)
+    }
+
+    /// Copies this memory to a new memory
+    fn copy(&mut self) -> Result<Box<dyn LinearMemory + 'static>, MemoryError>;
+
+    /// Add current thread to the waiter hash, and wait until notified or timout.
+    /// Return 0 if the waiter has been notified, 2 if the timeout occured, or None if en error happened
+    fn do_wait(
+        &mut self,
+        _dst: NotifyLocation,
+        _timeout: Option<Duration>,
+    ) -> Result<u32, WaiterError> {
+        Err(WaiterError::Unimplemented)
+    }
+
+    /// Notify waiters from the wait list. Return the number of waiters notified
+    fn do_notify(&mut self, _dst: NotifyLocation, _count: u32) -> u32 {
+        0
+    }
+
+    /// Access the internal atomics handler.
+    ///
+    /// Will be [`None`] if the memory does not support atomics.
+    fn thread_conditions(&self) -> Option<&ThreadConditions> {
+        None
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/mmap.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/mmap.rs
new file mode 100644
index 0000000..fb3be54
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/mmap.rs
@@ -0,0 +1,347 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Low-level abstraction for allocating and managing zero-filled pages
+//! of memory.
+
+use more_asserts::assert_le;
+use more_asserts::assert_lt;
+use std::io;
+use std::ptr;
+use std::slice;
+
+/// Round `size` up to the nearest multiple of `page_size`.
+fn round_up_to_page_size(size: usize, page_size: usize) -> usize {
+    (size + (page_size - 1)) & !(page_size - 1)
+}
+
+/// A simple struct consisting of a page-aligned pointer to page-aligned
+/// and initially-zeroed memory and a length.
+#[derive(Debug)]
+pub struct Mmap {
+    // Note that this is stored as a `usize` instead of a `*const` or `*mut`
+    // pointer to allow this structure to be natively `Send` and `Sync` without
+    // `unsafe impl`. This type is sendable across threads and shareable since
+    // the coordination all happens at the OS layer.
+    ptr: usize,
+    total_size: usize,
+    accessible_size: usize,
+}
+
+impl Mmap {
+    /// Construct a new empty instance of `Mmap`.
+    pub fn new() -> Self {
+        // Rust's slices require non-null pointers, even when empty. `Vec`
+        // contains code to create a non-null dangling pointer value when
+        // constructed empty, so we reuse that here.
+        let empty = Vec::<u8>::new();
+        Self {
+            ptr: empty.as_ptr() as usize,
+            total_size: 0,
+            accessible_size: 0,
+        }
+    }
+
+    /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned accessible memory.
+    pub fn with_at_least(size: usize) -> Result<Self, String> {
+        let page_size = region::page::size();
+        let rounded_size = round_up_to_page_size(size, page_size);
+        Self::accessible_reserved(rounded_size, rounded_size)
+    }
+
+    /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory,
+    /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size`
+    /// must be native page-size multiples.
+    #[cfg(not(target_os = "windows"))]
+    pub fn accessible_reserved(
+        accessible_size: usize,
+        mapping_size: usize,
+    ) -> Result<Self, String> {
+        let page_size = region::page::size();
+        assert_le!(accessible_size, mapping_size);
+        assert_eq!(mapping_size & (page_size - 1), 0);
+        assert_eq!(accessible_size & (page_size - 1), 0);
+
+        // Mmap may return EINVAL if the size is zero, so just
+        // special-case that.
+        if mapping_size == 0 {
+            return Ok(Self::new());
+        }
+
+        Ok(if accessible_size == mapping_size {
+            // Allocate a single read-write region at once.
+            let ptr = unsafe {
+                libc::mmap(
+                    ptr::null_mut(),
+                    mapping_size,
+                    libc::PROT_READ | libc::PROT_WRITE,
+                    libc::MAP_PRIVATE | libc::MAP_ANON,
+                    -1,
+                    0,
+                )
+            };
+            if ptr as isize == -1_isize {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            Self {
+                ptr: ptr as usize,
+                total_size: mapping_size,
+                accessible_size,
+            }
+        } else {
+            // Reserve the mapping size.
+            let ptr = unsafe {
+                libc::mmap(
+                    ptr::null_mut(),
+                    mapping_size,
+                    libc::PROT_NONE,
+                    libc::MAP_PRIVATE | libc::MAP_ANON,
+                    -1,
+                    0,
+                )
+            };
+            if ptr as isize == -1_isize {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            let mut result = Self {
+                ptr: ptr as usize,
+                total_size: mapping_size,
+                accessible_size,
+            };
+
+            if accessible_size != 0 {
+                // Commit the accessible size.
+                result.make_accessible(0, accessible_size)?;
+            }
+
+            result
+        })
+    }
+
+    /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned accessible memory,
+    /// within a reserved mapping of `mapping_size` bytes. `accessible_size` and `mapping_size`
+    /// must be native page-size multiples.
+    #[cfg(target_os = "windows")]
+    pub fn accessible_reserved(
+        accessible_size: usize,
+        mapping_size: usize,
+    ) -> Result<Self, String> {
+        use winapi::um::memoryapi::VirtualAlloc;
+        use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_NOACCESS, PAGE_READWRITE};
+
+        let page_size = region::page::size();
+        assert_le!(accessible_size, mapping_size);
+        assert_eq!(mapping_size & (page_size - 1), 0);
+        assert_eq!(accessible_size & (page_size - 1), 0);
+
+        // VirtualAlloc may return ERROR_INVALID_PARAMETER if the size is zero,
+        // so just special-case that.
+        if mapping_size == 0 {
+            return Ok(Self::new());
+        }
+
+        Ok(if accessible_size == mapping_size {
+            // Allocate a single read-write region at once.
+            let ptr = unsafe {
+                VirtualAlloc(
+                    ptr::null_mut(),
+                    mapping_size,
+                    MEM_RESERVE | MEM_COMMIT,
+                    PAGE_READWRITE,
+                )
+            };
+            if ptr.is_null() {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            Self {
+                ptr: ptr as usize,
+                total_size: mapping_size,
+                accessible_size,
+            }
+        } else {
+            // Reserve the mapping size.
+            let ptr =
+                unsafe { VirtualAlloc(ptr::null_mut(), mapping_size, MEM_RESERVE, PAGE_NOACCESS) };
+            if ptr.is_null() {
+                return Err(io::Error::last_os_error().to_string());
+            }
+
+            let mut result = Self {
+                ptr: ptr as usize,
+                total_size: mapping_size,
+                accessible_size,
+            };
+
+            if accessible_size != 0 {
+                // Commit the accessible size.
+                result.make_accessible(0, accessible_size)?;
+            }
+
+            result
+        })
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes accessible.
+    /// `start` and `len` must be native page-size multiples and describe a range within
+    /// `self`'s reserved memory.
+    #[cfg(not(target_os = "windows"))]
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> {
+        let page_size = region::page::size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert_lt!(len, self.total_size);
+        assert_lt!(start, self.total_size - len);
+
+        // Commit the accessible size.
+        let ptr = self.ptr as *const u8;
+        unsafe { region::protect(ptr.add(start), len, region::Protection::READ_WRITE) }
+            .map_err(|e| e.to_string())
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes accessible.
+    /// `start` and `len` must be native page-size multiples and describe a range within
+    /// `self`'s reserved memory.
+    #[cfg(target_os = "windows")]
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<(), String> {
+        use winapi::ctypes::c_void;
+        use winapi::um::memoryapi::VirtualAlloc;
+        use winapi::um::winnt::{MEM_COMMIT, PAGE_READWRITE};
+        let page_size = region::page::size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert_lt!(len, self.len());
+        assert_lt!(start, self.len() - len);
+
+        // Commit the accessible size.
+        let ptr = self.ptr as *const u8;
+        if unsafe {
+            VirtualAlloc(
+                ptr.add(start) as *mut c_void,
+                len,
+                MEM_COMMIT,
+                PAGE_READWRITE,
+            )
+        }
+        .is_null()
+        {
+            return Err(io::Error::last_os_error().to_string());
+        }
+
+        Ok(())
+    }
+
+    /// Return the allocated memory as a slice of u8.
+    pub fn as_slice(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, self.total_size) }
+    }
+
+    /// Return the allocated memory as a slice of u8.
+    pub fn as_slice_accessible(&self) -> &[u8] {
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, self.accessible_size) }
+    }
+
+    /// Return the allocated memory as a slice of u8.
+    pub fn as_slice_arbitary(&self, size: usize) -> &[u8] {
+        let size = usize::min(size, self.total_size);
+        unsafe { slice::from_raw_parts(self.ptr as *const u8, size) }
+    }
+
+    /// Return the allocated memory as a mutable slice of u8.
+    pub fn as_mut_slice(&mut self) -> &mut [u8] {
+        unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, self.total_size) }
+    }
+
+    /// Return the allocated memory as a mutable slice of u8.
+    pub fn as_mut_slice_accessible(&mut self) -> &mut [u8] {
+        unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, self.accessible_size) }
+    }
+
+    /// Return the allocated memory as a mutable slice of u8.
+    pub fn as_mut_slice_arbitary(&mut self, size: usize) -> &mut [u8] {
+        let size = usize::min(size, self.total_size);
+        unsafe { slice::from_raw_parts_mut(self.ptr as *mut u8, size) }
+    }
+
+    /// Return the allocated memory as a pointer to u8.
+    pub fn as_ptr(&self) -> *const u8 {
+        self.ptr as *const u8
+    }
+
+    /// Return the allocated memory as a mutable pointer to u8.
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.ptr as *mut u8
+    }
+
+    /// Return the length of the allocated memory.
+    pub fn len(&self) -> usize {
+        self.total_size
+    }
+
+    /// Return whether any memory has been allocated.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Duplicate in a new memory mapping.
+    #[deprecated = "use `copy` instead"]
+    pub fn duplicate(&mut self, size_hint: Option<usize>) -> Result<Self, String> {
+        self.copy(size_hint)
+    }
+
+    /// Duplicate in a new memory mapping.
+    pub fn copy(&mut self, size_hint: Option<usize>) -> Result<Self, String> {
+        // NOTE: accessible_size != used size as the value is not
+        //       automatically updated when the pre-provisioned space is used
+        let mut copy_size = self.accessible_size;
+        if let Some(size_hint) = size_hint {
+            copy_size = usize::max(copy_size, size_hint);
+        }
+
+        let mut new = Self::accessible_reserved(copy_size, self.total_size)?;
+        new.as_mut_slice_arbitary(copy_size)
+            .copy_from_slice(self.as_slice_arbitary(copy_size));
+        Ok(new)
+    }
+}
+
+impl Drop for Mmap {
+    #[cfg(not(target_os = "windows"))]
+    fn drop(&mut self) {
+        if self.total_size != 0 {
+            let r = unsafe { libc::munmap(self.ptr as *mut libc::c_void, self.total_size) };
+            assert_eq!(r, 0, "munmap failed: {}", io::Error::last_os_error());
+        }
+    }
+
+    #[cfg(target_os = "windows")]
+    fn drop(&mut self) {
+        if self.len() != 0 {
+            use winapi::ctypes::c_void;
+            use winapi::um::memoryapi::VirtualFree;
+            use winapi::um::winnt::MEM_RELEASE;
+            let r = unsafe { VirtualFree(self.ptr as *mut c_void, 0, MEM_RELEASE) };
+            assert_ne!(r, 0);
+        }
+    }
+}
+
+fn _assert() {
+    fn _assert_send_sync<T: Send + Sync>() {}
+    _assert_send_sync::<Mmap>();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_round_up_to_page_size() {
+        assert_eq!(round_up_to_page_size(0, 4096), 0);
+        assert_eq!(round_up_to_page_size(1, 4096), 4096);
+        assert_eq!(round_up_to_page_size(4096, 4096), 4096);
+        assert_eq!(round_up_to_page_size(4097, 4096), 8192);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/probestack.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/probestack.rs
new file mode 100644
index 0000000..cba4389
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/probestack.rs
@@ -0,0 +1,64 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! This section defines the `PROBESTACK` intrinsic which is used in the
+//! implementation of "stack probes" on certain platforms.
+//!
+//! The purpose of a stack probe is to provide a static guarantee that if a
+//! thread has a guard page then a stack overflow is guaranteed to hit that
+//! guard page. If a function did not have a stack probe then there's a risk of
+//! having a stack frame *larger* than the guard page, so a function call could
+//! skip over the guard page entirely and then later hit maybe the heap or
+//! another thread, possibly leading to security vulnerabilities such as [The
+//! Stack Clash], for example.
+//!
+//! [The Stack Clash]: https://blog.qualys.com/securitylabs/2017/06/19/the-stack-clash
+
+// A declaration for the stack probe function in Rust's standard library, for
+// catching callstack overflow.
+cfg_if::cfg_if! {
+    if #[cfg(all(
+            target_os = "windows",
+            target_env = "msvc",
+            target_pointer_width = "64"
+            ))] {
+        extern "C" {
+            pub fn __chkstk();
+        }
+        /// The probestack for 64bit Windows when compiled with MSVC (note the double underscore)
+        pub const PROBESTACK: unsafe extern "C" fn() = __chkstk;
+    } else if #[cfg(all(
+            target_os = "windows",
+            target_env = "msvc",
+            target_pointer_width = "32"
+            ))] {
+        extern "C" {
+            pub fn _chkstk();
+        }
+        /// The probestack for 32bit Windows when compiled with MSVC (note the singular underscore)
+        pub const PROBESTACK: unsafe extern "C" fn() = _chkstk;
+    } else if #[cfg(all(target_os = "windows", target_env = "gnu"))] {
+        extern "C" {
+            // ___chkstk (note the triple underscore) is implemented in compiler-builtins/src/x86_64.rs
+            // by the Rust compiler for the MinGW target
+            #[cfg(all(target_os = "windows", target_env = "gnu"))]
+            pub fn ___chkstk();
+        }
+        /// The probestack for Windows when compiled with GNU
+        pub const PROBESTACK: unsafe extern "C" fn() = ___chkstk;
+    } else if #[cfg(not(any(target_arch = "x86_64", target_arch = "x86")))] {
+        // As per
+        // https://github.com/rust-lang/compiler-builtins/blob/cae3e6ea23739166504f9f9fb50ec070097979d4/src/probestack.rs#L39,
+        // LLVM only has stack-probe support on x86-64 and x86. Thus, on any other CPU
+        // architecture, we simply use an empty stack-probe function.
+        extern "C" fn empty_probestack() {}
+        /// A default probestack for other architectures
+        pub const PROBESTACK: unsafe extern "C" fn() = empty_probestack;
+    } else {
+        extern "C" {
+            pub fn __rust_probestack();
+        }
+        /// The probestack based on the Rust probestack
+        pub static PROBESTACK: unsafe extern "C" fn() = __rust_probestack;
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/sig_registry.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/sig_registry.rs
new file mode 100644
index 0000000..08edf97
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/sig_registry.rs
@@ -0,0 +1,75 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Implement a registry of function signatures, for fast indirect call
+//! signature checking.
+
+use crate::vmcontext::VMSharedSignatureIndex;
+use more_asserts::{assert_lt, debug_assert_lt};
+use std::collections::{hash_map, HashMap};
+use std::convert::TryFrom;
+use std::sync::RwLock;
+use wasmer_types::FunctionType;
+
+/// WebAssembly requires that the caller and callee signatures in an indirect
+/// call must match. To implement this efficiently, keep a registry of all
+/// signatures, shared by all instances, so that call sites can just do an
+/// index comparison.
+#[derive(Debug, Default)]
+pub struct SignatureRegistry {
+    // This structure is stored in an `Engine` and is intended to be shared
+    // across many instances. Ideally instances can themselves be sent across
+    // threads, and ideally we can compile across many threads. As a result we
+    // use interior mutability here with a lock to avoid having callers to
+    // externally synchronize calls to compilation.
+    inner: RwLock<Inner>,
+}
+
+#[derive(Debug, Default)]
+struct Inner {
+    signature2index: HashMap<FunctionType, VMSharedSignatureIndex>,
+    index2signature: HashMap<VMSharedSignatureIndex, FunctionType>,
+}
+
+impl SignatureRegistry {
+    /// Create a new `SignatureRegistry`.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Register a signature and return its unique index.
+    pub fn register(&self, sig: &FunctionType) -> VMSharedSignatureIndex {
+        let mut inner = self.inner.write().unwrap();
+        let len = inner.signature2index.len();
+        let entry = inner.signature2index.entry(sig.clone());
+        match entry {
+            hash_map::Entry::Occupied(entry) => *entry.get(),
+            hash_map::Entry::Vacant(entry) => {
+                // Keep `signature_hash` len under 2**32 -- VMSharedSignatureIndex::new(std::u32::MAX)
+                // is reserved for VMSharedSignatureIndex::default().
+                debug_assert_lt!(
+                    len,
+                    std::u32::MAX as usize,
+                    "Invariant check: signature_hash.len() < std::u32::MAX"
+                );
+                let sig_id = VMSharedSignatureIndex::new(u32::try_from(len).unwrap());
+                entry.insert(sig_id);
+                inner.index2signature.insert(sig_id, sig.clone());
+                sig_id
+            }
+        }
+    }
+
+    /// Looks up a shared signature index within this registry.
+    ///
+    /// Note that for this operation to be semantically correct the `idx` must
+    /// have previously come from a call to `register` of this same object.
+    pub fn lookup(&self, idx: VMSharedSignatureIndex) -> Option<FunctionType> {
+        self.inner
+            .read()
+            .unwrap()
+            .index2signature
+            .get(&idx)
+            .cloned()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/store.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/store.rs
new file mode 100644
index 0000000..8813ee2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/store.rs
@@ -0,0 +1,296 @@
+use crate::{
+    VMExternObj, VMFunction, VMFunctionEnvironment, VMGlobal, VMInstance, VMMemory, VMTable,
+};
+use core::slice::Iter;
+use std::{cell::UnsafeCell, fmt, marker::PhantomData, num::NonZeroUsize, ptr::NonNull};
+use wasmer_types::StoreId;
+
+/// Trait to represent an object managed by a context. This is implemented on
+/// the VM types managed by the context.
+pub trait StoreObject: Sized {
+    fn list(ctx: &StoreObjects) -> &Vec<Self>;
+    fn list_mut(ctx: &mut StoreObjects) -> &mut Vec<Self>;
+}
+macro_rules! impl_context_object {
+    ($($field:ident => $ty:ty,)*) => {
+        $(
+            impl StoreObject for $ty {
+                fn list(ctx: &StoreObjects) -> &Vec<Self> {
+                    &ctx.$field
+                }
+                fn list_mut(ctx: &mut StoreObjects) -> &mut Vec<Self> {
+                    &mut ctx.$field
+                }
+            }
+        )*
+    };
+}
+impl_context_object! {
+    functions => VMFunction,
+    tables => VMTable,
+    globals => VMGlobal,
+    instances => VMInstance,
+    memories => VMMemory,
+    extern_objs => VMExternObj,
+    function_environments => VMFunctionEnvironment,
+}
+
+/// Set of objects managed by a context.
+#[derive(Debug, Default)]
+pub struct StoreObjects {
+    id: StoreId,
+    memories: Vec<VMMemory>,
+    tables: Vec<VMTable>,
+    globals: Vec<VMGlobal>,
+    functions: Vec<VMFunction>,
+    instances: Vec<VMInstance>,
+    extern_objs: Vec<VMExternObj>,
+    function_environments: Vec<VMFunctionEnvironment>,
+}
+
+impl StoreObjects {
+    /// Returns the ID of this context.
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Sets the ID of this store
+    pub fn set_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Returns a pair of mutable references from two handles.
+    ///
+    /// Panics if both handles point to the same object.
+    pub fn get_2_mut<T: StoreObject>(
+        &mut self,
+        a: InternalStoreHandle<T>,
+        b: InternalStoreHandle<T>,
+    ) -> (&mut T, &mut T) {
+        assert_ne!(a.index(), b.index());
+        let list = T::list_mut(self);
+        if a.index() < b.index() {
+            let (low, high) = list.split_at_mut(b.index());
+            (&mut low[a.index()], &mut high[0])
+        } else {
+            let (low, high) = list.split_at_mut(a.index());
+            (&mut high[0], &mut low[a.index()])
+        }
+    }
+
+    /// Return an immutable iterator over all globals
+    pub fn iter_globals(&self) -> Iter<VMGlobal> {
+        self.globals.iter()
+    }
+
+    /// Return an vector of all globals and converted to u128
+    pub fn as_u128_globals(&self) -> Vec<u128> {
+        self.iter_globals()
+            .map(|v| unsafe { v.vmglobal().as_ref().val.u128 })
+            .collect()
+    }
+
+    /// Set a global, at index idx. Will panic if idx is out of range
+    /// Safety: the caller should check taht the raw value is compatible
+    /// with destination VMGlobal type
+    pub fn set_global_unchecked(&self, idx: usize, val: u128) {
+        assert!(idx < self.globals.len());
+        unsafe {
+            self.globals[idx].vmglobal().as_mut().val.u128 = val;
+        }
+    }
+}
+
+/// Handle to an object managed by a context.
+///
+/// Internally this is just an integer index into a context. A reference to the
+/// context must be passed in separately to access the actual object.
+pub struct StoreHandle<T> {
+    id: StoreId,
+    internal: InternalStoreHandle<T>,
+}
+
+impl<T> Clone for StoreHandle<T> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            internal: self.internal,
+        }
+    }
+}
+
+impl<T> std::hash::Hash for StoreHandle<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.id.hash(state);
+        self.internal.idx.hash(state);
+    }
+}
+
+impl<T: StoreObject> fmt::Debug for StoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StoreHandle")
+            .field("id", &self.id)
+            .field("internal", &self.internal.index())
+            .finish()
+    }
+}
+
+impl<T: StoreObject> PartialEq for StoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id && self.internal == other.internal
+    }
+}
+
+impl<T: StoreObject> Eq for StoreHandle<T> {}
+
+impl<T: StoreObject> StoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(ctx: &mut StoreObjects, val: T) -> Self {
+        Self {
+            id: ctx.id,
+            internal: InternalStoreHandle::new(ctx, val),
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, ctx: &'a StoreObjects) -> &'a T {
+        assert_eq!(self.id, ctx.id, "object used with the wrong context");
+        self.internal.get(ctx)
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, ctx: &'a mut StoreObjects) -> &'a mut T {
+        assert_eq!(self.id, ctx.id, "object used with the wrong context");
+        self.internal.get_mut(ctx)
+    }
+
+    /// Returns the internal handle contains within this handle.
+    pub fn internal_handle(&self) -> InternalStoreHandle<T> {
+        self.internal
+    }
+
+    /// Returns the ID of the context associated with the handle.
+    pub fn store_id(&self) -> StoreId {
+        self.id
+    }
+
+    /// Overrides the store id with a new ID
+    pub fn set_store_id(&mut self, id: StoreId) {
+        self.id = id;
+    }
+
+    /// Constructs a `StoreHandle` from a `StoreId` and an `InternalStoreHandle`.
+    ///
+    /// # Safety
+    /// Handling `InternalStoreHandle` values is unsafe because they do not track context ID.
+    pub unsafe fn from_internal(id: StoreId, internal: InternalStoreHandle<T>) -> Self {
+        Self { id, internal }
+    }
+}
+
+/// Internal handle to an object owned by the current context.
+///
+/// Unlike `StoreHandle` this does not track the context ID: it is only
+/// intended to be used within objects already owned by a context.
+#[repr(transparent)]
+pub struct InternalStoreHandle<T> {
+    // Use a NonZero here to reduce the size of Option<InternalStoreHandle>.
+    idx: NonZeroUsize,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for InternalStoreHandle<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<T> Copy for InternalStoreHandle<T> {}
+
+impl<T> fmt::Debug for InternalStoreHandle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("InternalStoreHandle")
+            .field("idx", &self.idx)
+            .finish()
+    }
+}
+impl<T> PartialEq for InternalStoreHandle<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.idx == other.idx
+    }
+}
+impl<T> Eq for InternalStoreHandle<T> {}
+
+impl<T: StoreObject> InternalStoreHandle<T> {
+    /// Moves the given object into a context and returns a handle to it.
+    pub fn new(ctx: &mut StoreObjects, val: T) -> Self {
+        let list = T::list_mut(ctx);
+        let idx = NonZeroUsize::new(list.len() + 1).unwrap();
+        list.push(val);
+        Self {
+            idx,
+            marker: PhantomData,
+        }
+    }
+
+    /// Returns a reference to the object that this handle points to.
+    pub fn get<'a>(&self, ctx: &'a StoreObjects) -> &'a T {
+        &T::list(ctx)[self.idx.get() - 1]
+    }
+
+    /// Returns a mutable reference to the object that this handle points to.
+    pub fn get_mut<'a>(&self, ctx: &'a mut StoreObjects) -> &'a mut T {
+        &mut T::list_mut(ctx)[self.idx.get() - 1]
+    }
+
+    pub(crate) fn index(&self) -> usize {
+        self.idx.get()
+    }
+
+    pub(crate) fn from_index(idx: usize) -> Option<Self> {
+        NonZeroUsize::new(idx).map(|idx| Self {
+            idx,
+            marker: PhantomData,
+        })
+    }
+}
+
+/// Data used by the generated code is generally located inline within the
+/// `VMContext` for items defined in an instance. Host-defined objects are
+/// allocated separately and owned directly by the context.
+pub enum MaybeInstanceOwned<T> {
+    /// The data is owned here.
+    Host(Box<UnsafeCell<T>>),
+
+    /// The data is stored inline in the `VMContext` of an instance.
+    Instance(NonNull<T>),
+}
+
+impl<T> MaybeInstanceOwned<T> {
+    /// Returns underlying pointer to the VM data.
+    pub fn as_ptr(&self) -> NonNull<T> {
+        match self {
+            Self::Host(p) => unsafe { NonNull::new_unchecked(p.get()) },
+            Self::Instance(p) => *p,
+        }
+    }
+}
+
+impl<T> std::fmt::Debug for MaybeInstanceOwned<T>
+where
+    T: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Host(p) => {
+                write!(f, "host(")?;
+                p.as_ref().fmt(f)?;
+                write!(f, ")")
+            }
+            Self::Instance(p) => {
+                write!(f, "instance(")?;
+                unsafe { p.as_ref().fmt(f)? };
+                write!(f, ")")
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/table.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/table.rs
new file mode 100644
index 0000000..00c2555
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/table.rs
@@ -0,0 +1,358 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! Memory management for tables.
+//!
+//! `Table` is to WebAssembly tables what `Memory` is to WebAssembly linear memories.
+
+use crate::store::MaybeInstanceOwned;
+use crate::vmcontext::VMTableDefinition;
+use crate::Trap;
+use crate::VMExternRef;
+use crate::VMFuncRef;
+use derivative::Derivative;
+use std::cell::UnsafeCell;
+use std::convert::TryFrom;
+use std::fmt;
+use std::ptr::NonNull;
+use wasmer_types::TableStyle;
+use wasmer_types::{TableType, TrapCode, Type as ValType};
+
+/// A reference stored in a table. Can be either an externref or a funcref.
+#[derive(Debug, Clone)]
+pub enum TableElement {
+    /// Opaque pointer to arbitrary host data.
+    ExternRef(Option<VMExternRef>),
+    /// Pointer to function: contains enough information to call it.
+    FuncRef(Option<VMFuncRef>),
+}
+
+impl From<TableElement> for RawTableElement {
+    fn from(other: TableElement) -> Self {
+        match other {
+            TableElement::ExternRef(extern_ref) => Self { extern_ref },
+            TableElement::FuncRef(func_ref) => Self { func_ref },
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union RawTableElement {
+    pub(crate) extern_ref: Option<VMExternRef>,
+    pub(crate) func_ref: Option<VMFuncRef>,
+}
+
+#[cfg(test)]
+#[test]
+fn table_element_size_test() {
+    use std::mem::size_of;
+    assert_eq!(size_of::<RawTableElement>(), size_of::<VMExternRef>());
+    assert_eq!(size_of::<RawTableElement>(), size_of::<VMFuncRef>());
+}
+
+impl fmt::Debug for RawTableElement {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("RawTableElement").finish()
+    }
+}
+
+impl Default for RawTableElement {
+    fn default() -> Self {
+        Self { func_ref: None }
+    }
+}
+
+impl Default for TableElement {
+    fn default() -> Self {
+        Self::FuncRef(None)
+    }
+}
+
+/// A table instance.
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct VMTable {
+    #[derivative(Debug = "ignore")]
+    vec: Vec<RawTableElement>,
+    maximum: Option<u32>,
+    /// The WebAssembly table description.
+    table: TableType,
+    /// Our chosen implementation style.
+    style: TableStyle,
+    #[derivative(Debug = "ignore")]
+    vm_table_definition: MaybeInstanceOwned<VMTableDefinition>,
+}
+
+impl VMTable {
+    /// Create a new linear table instance with specified minimum and maximum number of elements.
+    ///
+    /// This creates a `Table` with metadata owned by a VM, pointed to by
+    /// `vm_table_location`: this can be used to create a local table.
+    pub fn new(table: &TableType, style: &TableStyle) -> Result<Self, String> {
+        unsafe { Self::new_inner(table, style, None) }
+    }
+
+    /// Returns the size of the table
+    pub fn get_runtime_size(&self) -> u32 {
+        self.vec.len() as u32
+    }
+
+    /// Create a new linear table instance with specified minimum and maximum number of elements.
+    ///
+    /// This creates a `Table` with metadata owned by a VM, pointed to by
+    /// `vm_table_location`: this can be used to create a local table.
+    ///
+    /// # Safety
+    /// - `vm_table_location` must point to a valid location in VM memory.
+    pub unsafe fn from_definition(
+        table: &TableType,
+        style: &TableStyle,
+        vm_table_location: NonNull<VMTableDefinition>,
+    ) -> Result<Self, String> {
+        Self::new_inner(table, style, Some(vm_table_location))
+    }
+
+    /// Create a new `Table` with either self-owned or VM owned metadata.
+    unsafe fn new_inner(
+        table: &TableType,
+        style: &TableStyle,
+        vm_table_location: Option<NonNull<VMTableDefinition>>,
+    ) -> Result<Self, String> {
+        match table.ty {
+            ValType::FuncRef | ValType::ExternRef => (),
+            ty => {
+                return Err(format!(
+                    "tables of types other than funcref or externref ({})",
+                    ty
+                ))
+            }
+        };
+        if let Some(max) = table.maximum {
+            if max < table.minimum {
+                return Err(format!(
+                    "Table minimum ({}) is larger than maximum ({})!",
+                    table.minimum, max
+                ));
+            }
+        }
+        let table_minimum = usize::try_from(table.minimum)
+            .map_err(|_| "Table minimum is bigger than usize".to_string())?;
+        let mut vec = vec![RawTableElement::default(); table_minimum];
+        let base = vec.as_mut_ptr();
+        match style {
+            TableStyle::CallerChecksSignature => Ok(Self {
+                vec,
+                maximum: table.maximum,
+                table: *table,
+                style: style.clone(),
+                vm_table_definition: if let Some(table_loc) = vm_table_location {
+                    {
+                        let mut ptr = table_loc;
+                        let td = ptr.as_mut();
+                        td.base = base as _;
+                        td.current_elements = table_minimum as _;
+                    }
+                    MaybeInstanceOwned::Instance(table_loc)
+                } else {
+                    MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMTableDefinition {
+                        base: base as _,
+                        current_elements: table_minimum as _,
+                    })))
+                },
+            }),
+        }
+    }
+
+    /// Get the `VMTableDefinition`.
+    fn get_vm_table_definition(&self) -> NonNull<VMTableDefinition> {
+        self.vm_table_definition.as_ptr()
+    }
+
+    /// Returns the type for this Table.
+    pub fn ty(&self) -> &TableType {
+        &self.table
+    }
+
+    /// Returns the style for this Table.
+    pub fn style(&self) -> &TableStyle {
+        &self.style
+    }
+
+    /// Returns the number of allocated elements.
+    pub fn size(&self) -> u32 {
+        // TODO: investigate this function for race conditions
+        unsafe {
+            let td_ptr = self.get_vm_table_definition();
+            let td = td_ptr.as_ref();
+            td.current_elements
+        }
+    }
+
+    /// Grow table by the specified amount of elements.
+    ///
+    /// Returns `None` if table can't be grown by the specified amount
+    /// of elements, otherwise returns the previous size of the table.
+    pub fn grow(&mut self, delta: u32, init_value: TableElement) -> Option<u32> {
+        let size = self.size();
+        let new_len = size.checked_add(delta)?;
+        if self.maximum.map_or(false, |max| new_len > max) {
+            return None;
+        }
+        if new_len == size {
+            debug_assert_eq!(delta, 0);
+            return Some(size);
+        }
+
+        self.vec
+            .resize(usize::try_from(new_len).unwrap(), init_value.into());
+
+        // update table definition
+        unsafe {
+            let mut td_ptr = self.get_vm_table_definition();
+            let td = td_ptr.as_mut();
+            td.current_elements = new_len;
+            td.base = self.vec.as_mut_ptr() as _;
+        }
+        Some(size)
+    }
+
+    /// Get reference to the specified element.
+    ///
+    /// Returns `None` if the index is out of bounds.
+    pub fn get(&self, index: u32) -> Option<TableElement> {
+        let raw_data = self.vec.get(index as usize).cloned()?;
+        Some(match self.table.ty {
+            ValType::ExternRef => TableElement::ExternRef(unsafe { raw_data.extern_ref }),
+            ValType::FuncRef => TableElement::FuncRef(unsafe { raw_data.func_ref }),
+            _ => todo!("getting invalid type from table, handle this error"),
+        })
+    }
+
+    /// Set reference to the specified element.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the index is out of bounds.
+    pub fn set(&mut self, index: u32, reference: TableElement) -> Result<(), Trap> {
+        match self.vec.get_mut(index as usize) {
+            Some(slot) => {
+                match (self.table.ty, reference) {
+                    (ValType::ExternRef, r @ TableElement::ExternRef(_)) => {
+                        *slot = r.into();
+                    }
+                    (ValType::FuncRef, r @ TableElement::FuncRef(_)) => {
+                        *slot = r.into();
+                    }
+                    // This path should never be hit by the generated code due to Wasm
+                    // validation.
+                    (ty, v) => {
+                        panic!(
+                            "Attempted to set a table of type {} with the value {:?}",
+                            ty, v
+                        )
+                    }
+                };
+
+                Ok(())
+            }
+            None => Err(Trap::lib(TrapCode::TableAccessOutOfBounds)),
+        }
+    }
+
+    /// Return a `VMTableDefinition` for exposing the table to compiled wasm code.
+    pub fn vmtable(&self) -> NonNull<VMTableDefinition> {
+        self.get_vm_table_definition()
+    }
+
+    /// Copy `len` elements from `src_table[src_index..]` into `dst_table[dst_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables.
+    pub fn copy(
+        &mut self,
+        src_table: &Self,
+        dst_index: u32,
+        src_index: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-copy
+
+        if src_index
+            .checked_add(len)
+            .map_or(true, |n| n > src_table.size())
+        {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        if dst_index.checked_add(len).map_or(true, |m| m > self.size()) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        let srcs = src_index..src_index + len;
+        let dsts = dst_index..dst_index + len;
+
+        // Note on the unwraps: the bounds check above means that these will
+        // never panic.
+        //
+        // TODO: investigate replacing this get/set loop with a `memcpy`.
+        if dst_index <= src_index {
+            for (s, d) in (srcs).zip(dsts) {
+                self.set(d, src_table.get(s).unwrap())?;
+            }
+        } else {
+            for (s, d) in srcs.rev().zip(dsts.rev()) {
+                self.set(d, src_table.get(s).unwrap())?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Copies the table into a new table
+    pub fn copy_on_write(&self) -> Result<Self, String> {
+        let mut ret = Self::new(&self.table, &self.style)?;
+        ret.copy(self, 0, 0, self.size())
+            .map_err(|trap| format!("failed to copy the table - {:?}", trap))?;
+        Ok(ret)
+    }
+
+    /// Copy `len` elements from `table[src_index..]` to `table[dst_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables.
+    pub fn copy_within(&mut self, dst_index: u32, src_index: u32, len: u32) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-copy
+
+        if src_index.checked_add(len).map_or(true, |n| n > self.size()) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        if dst_index.checked_add(len).map_or(true, |m| m > self.size()) {
+            return Err(Trap::lib(TrapCode::TableAccessOutOfBounds));
+        }
+
+        let srcs = src_index..src_index + len;
+        let dsts = dst_index..dst_index + len;
+
+        // Note on the unwraps: the bounds check above means that these will
+        // never panic.
+        //
+        // TODO: investigate replacing this get/set loop with a `memcpy`.
+        if dst_index <= src_index {
+            for (s, d) in (srcs).zip(dsts) {
+                self.set(d, self.get(s).unwrap())?;
+            }
+        } else {
+            for (s, d) in srcs.rev().zip(dsts.rev()) {
+                self.set(d, self.get(s).unwrap())?;
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/threadconditions.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/threadconditions.rs
new file mode 100644
index 0000000..cdf6938
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/threadconditions.rs
@@ -0,0 +1,280 @@
+use dashmap::DashMap;
+use fnv::FnvBuildHasher;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+use std::thread::{current, park, park_timeout, Thread};
+use std::time::Duration;
+use thiserror::Error;
+
+/// Error that can occur during wait/notify calls.
+// Non-exhaustive to allow for future variants without breaking changes!
+#[derive(Debug, Error)]
+#[non_exhaustive]
+pub enum WaiterError {
+    /// Wait/Notify is not implemented for this memory
+    Unimplemented,
+    /// To many waiter for an address
+    TooManyWaiters,
+    /// Atomic operations are disabled.
+    AtomicsDisabled,
+}
+
+impl std::fmt::Display for WaiterError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "WaiterError")
+    }
+}
+
+/// A location in memory for a Waiter
+#[derive(Hash, Eq, PartialEq, Clone, Copy, Debug)]
+pub struct NotifyLocation {
+    /// The address of the Waiter location
+    pub address: u32,
+}
+
+#[derive(Debug)]
+struct NotifyWaiter {
+    thread: Thread,
+    notified: bool,
+}
+
+#[derive(Debug, Default)]
+struct NotifyMap {
+    /// If set to true, all waits will fail with an error.
+    closed: AtomicBool,
+    map: DashMap<NotifyLocation, Vec<NotifyWaiter>, FnvBuildHasher>,
+}
+
+/// HashMap of Waiters for the Thread/Notify opcodes
+#[derive(Debug)]
+pub struct ThreadConditions {
+    inner: Arc<NotifyMap>, // The Hasmap with the Notify for the Notify/wait opcodes
+}
+
+impl Clone for ThreadConditions {
+    fn clone(&self) -> Self {
+        Self {
+            inner: Arc::clone(&self.inner),
+        }
+    }
+}
+
+impl ThreadConditions {
+    /// Create a new ThreadConditions
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(NotifyMap::default()),
+        }
+    }
+
+    // To implement Wait / Notify, a HasMap, behind a mutex, will be used
+    // to track the address of waiter. The key of the hashmap is based on the memory
+    // and waiter threads are "park"'d (with or without timeout)
+    // Notify will wake the waiters by simply "unpark" the thread
+    // as the Thread info is stored on the HashMap
+    // once unparked, the waiter thread will remove it's mark on the HashMap
+    // timeout / awake is tracked with a boolean in the HashMap
+    // because `park_timeout` doesn't gives any information on why it returns
+
+    /// Add current thread to the waiter hash
+    pub fn do_wait(
+        &mut self,
+        dst: NotifyLocation,
+        timeout: Option<Duration>,
+    ) -> Result<u32, WaiterError> {
+        if self.inner.closed.load(std::sync::atomic::Ordering::Acquire) {
+            return Err(WaiterError::AtomicsDisabled);
+        }
+
+        // fetch the notifier
+        if self.inner.map.len() >= 1 << 32 {
+            return Err(WaiterError::TooManyWaiters);
+        }
+        self.inner.map.entry(dst).or_default().push(NotifyWaiter {
+            thread: current(),
+            notified: false,
+        });
+        if let Some(timeout) = timeout {
+            park_timeout(timeout);
+        } else {
+            park();
+        }
+        let mut bindding = self.inner.map.get_mut(&dst).unwrap();
+        let v = bindding.value_mut();
+        let id = current().id();
+        let mut ret = 0;
+        v.retain(|cond| {
+            if cond.thread.id() == id {
+                ret = if cond.notified { 0 } else { 2 };
+                false
+            } else {
+                true
+            }
+        });
+        let empty = v.is_empty();
+        drop(bindding);
+        if empty {
+            self.inner.map.remove(&dst);
+        }
+        Ok(ret)
+    }
+
+    /// Notify waiters from the wait list
+    pub fn do_notify(&mut self, dst: NotifyLocation, count: u32) -> u32 {
+        let mut count_token = 0u32;
+        if let Some(mut v) = self.inner.map.get_mut(&dst) {
+            for waiter in v.value_mut() {
+                if count_token < count && !waiter.notified {
+                    waiter.notified = true; // waiter was notified, not just an elapsed timeout
+                    waiter.thread.unpark(); // wakeup!
+                    count_token += 1;
+                }
+            }
+        }
+        count_token
+    }
+
+    /// Wake all the waiters, *without* marking them as notified.
+    ///
+    /// Useful on shutdown to resume execution in all waiters.
+    pub fn wake_all_atomic_waiters(&self) {
+        for mut item in self.inner.map.iter_mut() {
+            for waiter in item.value_mut() {
+                waiter.thread.unpark();
+            }
+        }
+    }
+
+    /// Disable the use of atomics, leading to all atomic waits failing with
+    /// an error, which leads to a Webassembly trap.
+    ///
+    /// Useful for force-closing instances that keep waiting on atomics.
+    pub fn disable_atomics(&self) {
+        self.inner
+            .closed
+            .store(true, std::sync::atomic::Ordering::Release);
+        self.wake_all_atomic_waiters();
+    }
+
+    /// Get a weak handle to this `ThreadConditions` instance.
+    ///
+    /// See [`ThreadConditionsHandle`] for more information.
+    pub fn downgrade(&self) -> ThreadConditionsHandle {
+        ThreadConditionsHandle {
+            inner: Arc::downgrade(&self.inner),
+        }
+    }
+}
+
+/// A weak handle to a `ThreadConditions` instance, which does not prolong its
+/// lifetime.
+///
+/// Internally holds a [`std::sync::Weak`] pointer.
+pub struct ThreadConditionsHandle {
+    inner: std::sync::Weak<NotifyMap>,
+}
+
+impl ThreadConditionsHandle {
+    /// Attempt to upgrade this handle to a strong reference.
+    ///
+    /// Returns `None` if the original `ThreadConditions` instance has been dropped.
+    pub fn upgrade(&self) -> Option<ThreadConditions> {
+        self.inner.upgrade().map(|inner| ThreadConditions { inner })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn threadconditions_notify_nowaiters() {
+        let mut conditions = ThreadConditions::new();
+        let dst = NotifyLocation { address: 0 };
+        let ret = conditions.do_notify(dst, 1);
+        assert_eq!(ret, 0);
+    }
+
+    #[test]
+    fn threadconditions_notify_1waiter() {
+        use std::thread;
+
+        let mut conditions = ThreadConditions::new();
+        let mut threadcond = conditions.clone();
+
+        thread::spawn(move || {
+            let dst = NotifyLocation { address: 0 };
+            let ret = threadcond.do_wait(dst, None).unwrap();
+            assert_eq!(ret, 0);
+        });
+        thread::sleep(Duration::from_millis(10));
+        let dst = NotifyLocation { address: 0 };
+        let ret = conditions.do_notify(dst, 1);
+        assert_eq!(ret, 1);
+    }
+
+    #[test]
+    fn threadconditions_notify_waiter_timeout() {
+        use std::thread;
+
+        let mut conditions = ThreadConditions::new();
+        let mut threadcond = conditions.clone();
+
+        thread::spawn(move || {
+            let dst = NotifyLocation { address: 0 };
+            let ret = threadcond
+                .do_wait(dst, Some(Duration::from_millis(1)))
+                .unwrap();
+            assert_eq!(ret, 2);
+        });
+        thread::sleep(Duration::from_millis(50));
+        let dst = NotifyLocation { address: 0 };
+        let ret = conditions.do_notify(dst, 1);
+        assert_eq!(ret, 0);
+    }
+
+    #[test]
+    fn threadconditions_notify_waiter_mismatch() {
+        use std::thread;
+
+        let mut conditions = ThreadConditions::new();
+        let mut threadcond = conditions.clone();
+
+        thread::spawn(move || {
+            let dst = NotifyLocation { address: 8 };
+            let ret = threadcond
+                .do_wait(dst, Some(Duration::from_millis(10)))
+                .unwrap();
+            assert_eq!(ret, 2);
+        });
+        thread::sleep(Duration::from_millis(1));
+        let dst = NotifyLocation { address: 0 };
+        let ret = conditions.do_notify(dst, 1);
+        assert_eq!(ret, 0);
+        thread::sleep(Duration::from_millis(100));
+    }
+
+    #[test]
+    fn threadconditions_notify_2waiters() {
+        use std::thread;
+
+        let mut conditions = ThreadConditions::new();
+        let mut threadcond = conditions.clone();
+        let mut threadcond2 = conditions.clone();
+
+        thread::spawn(move || {
+            let dst = NotifyLocation { address: 0 };
+            let ret = threadcond.do_wait(dst, None).unwrap();
+            assert_eq!(ret, 0);
+        });
+        thread::spawn(move || {
+            let dst = NotifyLocation { address: 0 };
+            let ret = threadcond2.do_wait(dst, None).unwrap();
+            assert_eq!(ret, 0);
+        });
+        thread::sleep(Duration::from_millis(20));
+        let dst = NotifyLocation { address: 0 };
+        let ret = conditions.do_notify(dst, 5);
+        assert_eq!(ret, 2);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/mod.rs
new file mode 100644
index 0000000..b77ca6e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/mod.rs
@@ -0,0 +1,17 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! This is the module that facilitates the usage of Traps
+//! in Wasmer Runtime
+
+#[allow(clippy::module_inception)]
+mod trap;
+mod traphandlers;
+
+pub use trap::Trap;
+pub use traphandlers::{
+    catch_traps, on_host_stack, raise_lib_trap, raise_user_trap, set_stack_size,
+    wasmer_call_trampoline, TrapHandlerFn, VMConfig,
+};
+pub use traphandlers::{init_traps, resume_panic};
+pub use wasmer_types::TrapCode;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/trap.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/trap.rs
new file mode 100644
index 0000000..fa8de9c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/trap.rs
@@ -0,0 +1,135 @@
+use backtrace::Backtrace;
+use std::error::Error;
+use std::fmt;
+use wasmer_types::TrapCode;
+
+/// Stores trace message with backtrace.
+#[derive(Debug)]
+pub enum Trap {
+    /// A user-raised trap through `raise_user_trap`.
+    User(Box<dyn Error + Send + Sync>),
+
+    /// A trap raised from the Wasm generated code
+    ///
+    /// Note: this trap is deterministic (assuming a deterministic host implementation)
+    Wasm {
+        /// The program counter in generated code where this trap happened.
+        pc: usize,
+        /// Native stack backtrace at the time the trap occurred
+        backtrace: Backtrace,
+        /// Optional trapcode associated to the signal that caused the trap
+        signal_trap: Option<TrapCode>,
+    },
+
+    /// A trap raised from a wasm libcall
+    ///
+    /// Note: this trap is deterministic (assuming a deterministic host implementation)
+    Lib {
+        /// Code of the trap.
+        trap_code: TrapCode,
+        /// Native stack backtrace at the time the trap occurred
+        backtrace: Backtrace,
+    },
+
+    /// A trap indicating that the runtime was unable to allocate sufficient memory.
+    ///
+    /// Note: this trap is nondeterministic, since it depends on the host system.
+    OOM {
+        /// Native stack backtrace at the time the OOM occurred
+        backtrace: Backtrace,
+    },
+}
+
+fn _assert_trap_is_sync_and_send(t: &Trap) -> (&dyn Sync, &dyn Send) {
+    (t, t)
+}
+
+impl Trap {
+    /// Construct a new Error with the given a user error.
+    ///
+    /// Internally saves a backtrace when constructed.
+    pub fn user(err: Box<dyn Error + Send + Sync>) -> Self {
+        Self::User(err)
+    }
+
+    /// Construct a new Wasm trap with the given source location and backtrace.
+    ///
+    /// Internally saves a backtrace when constructed.
+    pub fn wasm(pc: usize, backtrace: Backtrace, signal_trap: Option<TrapCode>) -> Self {
+        Self::Wasm {
+            pc,
+            backtrace,
+            signal_trap,
+        }
+    }
+
+    /// Returns trap code, if it's a Trap
+    pub fn to_trap(self) -> Option<TrapCode> {
+        unimplemented!()
+    }
+
+    /// Construct a new Wasm trap with the given trap code.
+    ///
+    /// Internally saves a backtrace when constructed.
+    pub fn lib(trap_code: TrapCode) -> Self {
+        let backtrace = Backtrace::new_unresolved();
+        Self::Lib {
+            trap_code,
+            backtrace,
+        }
+    }
+
+    /// Construct a new OOM trap with the given source location and trap code.
+    ///
+    /// Internally saves a backtrace when constructed.
+    pub fn oom() -> Self {
+        let backtrace = Backtrace::new_unresolved();
+        Self::OOM { backtrace }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast<T: Error + 'static>(self) -> Result<T, Self> {
+        match self {
+            // We only try to downcast user errors
+            Self::User(err) if err.is::<T>() => Ok(*err.downcast::<T>().unwrap()),
+            _ => Err(self),
+        }
+    }
+
+    /// Attempts to downcast the `Trap` to a concrete type.
+    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {
+        match &self {
+            // We only try to downcast user errors
+            Self::User(err) if err.is::<T>() => err.downcast_ref::<T>(),
+            _ => None,
+        }
+    }
+
+    /// Returns true if the `Trap` is the same as T
+    pub fn is<T: Error + 'static>(&self) -> bool {
+        match self {
+            Self::User(err) => err.is::<T>(),
+            _ => false,
+        }
+    }
+}
+
+impl std::error::Error for Trap {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match &self {
+            Self::User(err) => Some(&**err),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Trap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::User(e) => write!(f, "{}", e),
+            Self::Lib { .. } => write!(f, "lib"),
+            Self::Wasm { .. } => write!(f, "wasm"),
+            Self::OOM { .. } => write!(f, "Wasmer VM out of memory"),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/traphandlers.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/traphandlers.rs
new file mode 100644
index 0000000..00627b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/trap/traphandlers.rs
@@ -0,0 +1,1110 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! WebAssembly trap handling, which is built on top of the lower-level
+//! signalhandling mechanisms.
+
+use crate::vmcontext::{VMFunctionContext, VMTrampoline};
+use crate::{Trap, VMFunctionBody};
+use backtrace::Backtrace;
+use core::ptr::{read, read_unaligned};
+use corosensei::stack::DefaultStack;
+use corosensei::trap::{CoroutineTrapHandler, TrapHandlerRegs};
+use corosensei::{CoroutineResult, ScopedCoroutine, Yielder};
+use scopeguard::defer;
+use std::any::Any;
+use std::cell::Cell;
+use std::error::Error;
+use std::io;
+use std::mem;
+#[cfg(unix)]
+use std::mem::MaybeUninit;
+use std::ptr::{self, NonNull};
+use std::sync::atomic::{compiler_fence, AtomicPtr, AtomicUsize, Ordering};
+use std::sync::Once;
+use wasmer_types::TrapCode;
+
+/// Configuration for the the runtime VM
+/// Currently only the stack size is configurable
+pub struct VMConfig {
+    /// Optionnal stack size (in byte) of the VM. Value lower than 8K will be rounded to 8K.
+    pub wasm_stack_size: Option<usize>,
+}
+
+// TrapInformation can be stored in the "Undefined Instruction" itself.
+// On x86_64, 0xC? select a "Register" for the Mod R/M part of "ud1" (so with no other bytes after)
+// On Arm64, the udf alows for a 16bits values, so we'll use the same 0xC? to store the trapinfo
+static MAGIC: u8 = 0xc0;
+
+static DEFAULT_STACK_SIZE: AtomicUsize = AtomicUsize::new(1024 * 1024);
+
+// Current definition of `ucontext_t` in the `libc` crate is incorrect
+// on aarch64-apple-drawin so it's defined here with a more accurate definition.
+#[repr(C)]
+#[cfg(all(target_arch = "aarch64", target_os = "macos"))]
+#[allow(non_camel_case_types)]
+struct ucontext_t {
+    uc_onstack: libc::c_int,
+    uc_sigmask: libc::sigset_t,
+    uc_stack: libc::stack_t,
+    uc_link: *mut libc::ucontext_t,
+    uc_mcsize: usize,
+    uc_mcontext: libc::mcontext_t,
+}
+
+// Current definition of `ucontext_t` in the `libc` crate is not present
+// on aarch64-unknown-freebsd so it's defined here.
+#[repr(C)]
+#[cfg(all(target_arch = "aarch64", target_os = "freebsd"))]
+#[allow(non_camel_case_types)]
+struct ucontext_t {
+    uc_sigmask: libc::sigset_t,
+    uc_mcontext: libc::mcontext_t,
+    uc_link: *mut ucontext_t,
+    uc_stack: libc::stack_t,
+    uc_flags: libc::c_int,
+    spare: [libc::c_int; 4],
+}
+
+#[cfg(all(
+    unix,
+    not(all(target_arch = "aarch64", target_os = "macos")),
+    not(all(target_arch = "aarch64", target_os = "freebsd"))
+))]
+use libc::ucontext_t;
+
+/// Default stack size is 1MB.
+pub fn set_stack_size(size: usize) {
+    DEFAULT_STACK_SIZE.store(size.max(8 * 1024).min(100 * 1024 * 1024), Ordering::Relaxed);
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(unix)] {
+        /// Function which may handle custom signals while processing traps.
+        pub type TrapHandlerFn<'a> = dyn Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool + Send + Sync + 'a;
+    } else if #[cfg(target_os = "windows")] {
+        /// Function which may handle custom signals while processing traps.
+        pub type TrapHandlerFn<'a> = dyn Fn(winapi::um::winnt::PEXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
+    }
+}
+
+// Process an IllegalOpcode to see if it has a TrapCode payload
+unsafe fn process_illegal_op(addr: usize) -> Option<TrapCode> {
+    let mut val: Option<u8> = None;
+    if cfg!(target_arch = "x86_64") {
+        val = if read(addr as *mut u8) & 0xf0 == 0x40
+            && read((addr + 1) as *mut u8) == 0x0f
+            && read((addr + 2) as *mut u8) == 0xb9
+        {
+            Some(read((addr + 3) as *mut u8))
+        } else if read(addr as *mut u8) == 0x0f && read((addr + 1) as *mut u8) == 0xb9 {
+            Some(read((addr + 2) as *mut u8))
+        } else {
+            None
+        }
+    }
+    if cfg!(target_arch = "aarch64") {
+        val = if read_unaligned(addr as *mut u32) & 0xffff0000 == 0 {
+            Some(read(addr as *mut u8))
+        } else {
+            None
+        }
+    }
+    match val.and_then(|val| {
+        if val & MAGIC == MAGIC {
+            Some(val & 0xf)
+        } else {
+            None
+        }
+    }) {
+        None => None,
+        Some(val) => match val {
+            0 => Some(TrapCode::StackOverflow),
+            1 => Some(TrapCode::HeapAccessOutOfBounds),
+            2 => Some(TrapCode::HeapMisaligned),
+            3 => Some(TrapCode::TableAccessOutOfBounds),
+            4 => Some(TrapCode::IndirectCallToNull),
+            5 => Some(TrapCode::BadSignature),
+            6 => Some(TrapCode::IntegerOverflow),
+            7 => Some(TrapCode::IntegerDivisionByZero),
+            8 => Some(TrapCode::BadConversionToInteger),
+            9 => Some(TrapCode::UnreachableCodeReached),
+            10 => Some(TrapCode::UnalignedAtomic),
+            _ => None,
+        },
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(unix)] {
+        static mut PREV_SIGSEGV: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+        static mut PREV_SIGBUS: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+        static mut PREV_SIGILL: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+        static mut PREV_SIGFPE: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+
+        unsafe fn platform_init() {
+            let register = |slot: &mut MaybeUninit<libc::sigaction>, signal: i32| {
+                let mut handler: libc::sigaction = mem::zeroed();
+                // The flags here are relatively careful, and they are...
+                //
+                // SA_SIGINFO gives us access to information like the program
+                // counter from where the fault happened.
+                //
+                // SA_ONSTACK allows us to handle signals on an alternate stack,
+                // so that the handler can run in response to running out of
+                // stack space on the main stack. Rust installs an alternate
+                // stack with sigaltstack, so we rely on that.
+                //
+                // SA_NODEFER allows us to reenter the signal handler if we
+                // crash while handling the signal, and fall through to the
+                // Breakpad handler by testing handlingSegFault.
+                handler.sa_flags = libc::SA_SIGINFO | libc::SA_NODEFER | libc::SA_ONSTACK;
+                handler.sa_sigaction = trap_handler as usize;
+                libc::sigemptyset(&mut handler.sa_mask);
+                if libc::sigaction(signal, &handler, slot.as_mut_ptr()) != 0 {
+                    panic!(
+                        "unable to install signal handler: {}",
+                        io::Error::last_os_error(),
+                    );
+                }
+            };
+
+            // Allow handling OOB with signals on all architectures
+            register(&mut PREV_SIGSEGV, libc::SIGSEGV);
+
+            // Handle `unreachable` instructions which execute `ud2` right now
+            register(&mut PREV_SIGILL, libc::SIGILL);
+
+            // x86 uses SIGFPE to report division by zero
+            if cfg!(target_arch = "x86") || cfg!(target_arch = "x86_64") {
+                register(&mut PREV_SIGFPE, libc::SIGFPE);
+            }
+
+            // On ARM, handle Unaligned Accesses.
+            // On Darwin, guard page accesses are raised as SIGBUS.
+            if cfg!(target_arch = "arm") || cfg!(target_vendor = "apple") {
+                register(&mut PREV_SIGBUS, libc::SIGBUS);
+            }
+
+            // This is necessary to support debugging under LLDB on Darwin.
+            // For more details see https://github.com/mono/mono/commit/8e75f5a28e6537e56ad70bf870b86e22539c2fb7
+            #[cfg(target_vendor = "apple")]
+            {
+                use mach::exception_types::*;
+                use mach::kern_return::*;
+                use mach::port::*;
+                use mach::thread_status::*;
+                use mach::traps::*;
+                use mach::mach_types::*;
+
+                extern "C" {
+                    fn task_set_exception_ports(
+                        task: task_t,
+                        exception_mask: exception_mask_t,
+                        new_port: mach_port_t,
+                        behavior: exception_behavior_t,
+                        new_flavor: thread_state_flavor_t,
+                    ) -> kern_return_t;
+                }
+
+                #[allow(non_snake_case)]
+                #[cfg(target_arch = "x86_64")]
+                let MACHINE_THREAD_STATE = x86_THREAD_STATE64;
+                #[allow(non_snake_case)]
+                #[cfg(target_arch = "aarch64")]
+                let MACHINE_THREAD_STATE = 6;
+
+                task_set_exception_ports(
+                    mach_task_self(),
+                    EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC | EXC_MASK_BAD_INSTRUCTION,
+                    MACH_PORT_NULL,
+                    EXCEPTION_STATE_IDENTITY as exception_behavior_t,
+                    MACHINE_THREAD_STATE,
+                );
+            }
+        }
+
+        unsafe extern "C" fn trap_handler(
+            signum: libc::c_int,
+            siginfo: *mut libc::siginfo_t,
+            context: *mut libc::c_void,
+        ) {
+            let previous = match signum {
+                libc::SIGSEGV => &PREV_SIGSEGV,
+                libc::SIGBUS => &PREV_SIGBUS,
+                libc::SIGFPE => &PREV_SIGFPE,
+                libc::SIGILL => &PREV_SIGILL,
+                _ => panic!("unknown signal: {}", signum),
+            };
+            // We try to get the fault address associated to this signal
+            let maybe_fault_address = match signum {
+                libc::SIGSEGV | libc::SIGBUS => {
+                    Some((*siginfo).si_addr() as usize)
+                }
+                _ => None,
+            };
+            let trap_code = match signum {
+                // check if it was cased by a UD and if the Trap info is a payload to it
+                libc::SIGILL => {
+                    let addr = (*siginfo).si_addr() as usize;
+                    process_illegal_op(addr)
+                }
+                _ => None,
+            };
+            let ucontext = &mut *(context as *mut ucontext_t);
+            let (pc, sp) = get_pc_sp(ucontext);
+            let handled = TrapHandlerContext::handle_trap(
+                pc,
+                sp,
+                maybe_fault_address,
+                trap_code,
+                |regs| update_context(ucontext, regs),
+                |handler| handler(signum, siginfo, context),
+            );
+
+            if handled {
+                return;
+            }
+
+            // This signal is not for any compiled wasm code we expect, so we
+            // need to forward the signal to the next handler. If there is no
+            // next handler (SIG_IGN or SIG_DFL), then it's time to crash. To do
+            // this, we set the signal back to its original disposition and
+            // return. This will cause the faulting op to be re-executed which
+            // will crash in the normal way. If there is a next handler, call
+            // it. It will either crash synchronously, fix up the instruction
+            // so that execution can continue and return, or trigger a crash by
+            // returning the signal to it's original disposition and returning.
+            let previous = &*previous.as_ptr();
+            if previous.sa_flags & libc::SA_SIGINFO != 0 {
+                mem::transmute::<
+                    usize,
+                    extern "C" fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void),
+                >(previous.sa_sigaction)(signum, siginfo, context)
+            } else if previous.sa_sigaction == libc::SIG_DFL
+            {
+                libc::sigaction(signum, previous, ptr::null_mut());
+            } else if previous.sa_sigaction != libc::SIG_IGN {
+                mem::transmute::<usize, extern "C" fn(libc::c_int)>(
+                    previous.sa_sigaction
+                )(signum)
+            }
+        }
+
+        unsafe fn get_pc_sp(context: &ucontext_t) -> (usize, usize) {
+            let (pc, sp);
+            cfg_if::cfg_if! {
+                if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    target_arch = "x86_64",
+                ))] {
+                    pc = context.uc_mcontext.gregs[libc::REG_RIP as usize] as usize;
+                    sp = context.uc_mcontext.gregs[libc::REG_RSP as usize] as usize;
+                } else if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    target_arch = "x86",
+                ))] {
+                    pc = context.uc_mcontext.gregs[libc::REG_EIP as usize] as usize;
+                    sp = context.uc_mcontext.gregs[libc::REG_ESP as usize] as usize;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "x86"))] {
+                    pc = context.uc_mcontext.mc_eip as usize;
+                    sp = context.uc_mcontext.mc_esp as usize;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))] {
+                    pc = context.uc_mcontext.mc_rip as usize;
+                    sp = context.uc_mcontext.mc_rsp as usize;
+                } else if #[cfg(all(target_vendor = "apple", target_arch = "x86_64"))] {
+                    pc = (*context.uc_mcontext).__ss.__rip as usize;
+                    sp = (*context.uc_mcontext).__ss.__rsp as usize;
+                } else if #[cfg(all(
+                        any(target_os = "linux", target_os = "android"),
+                        target_arch = "aarch64",
+                    ))] {
+                    pc = context.uc_mcontext.pc as usize;
+                    sp = context.uc_mcontext.sp as usize;
+                } else if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    target_arch = "arm",
+                ))] {
+                    pc = context.uc_mcontext.arm_pc as usize;
+                    sp = context.uc_mcontext.arm_sp as usize;
+                } else if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    any(target_arch = "riscv64", target_arch = "riscv32"),
+                ))] {
+                    pc = context.uc_mcontext.__gregs[libc::REG_PC] as usize;
+                    sp = context.uc_mcontext.__gregs[libc::REG_SP] as usize;
+                } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64"))] {
+                    pc = (*context.uc_mcontext).__ss.__pc as usize;
+                    sp = (*context.uc_mcontext).__ss.__sp as usize;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
+                    pc = context.uc_mcontext.mc_gpregs.gp_elr as usize;
+                    sp = context.uc_mcontext.mc_gpregs.gp_sp as usize;
+                } else {
+                    compile_error!("Unsupported platform");
+                }
+            };
+            (pc, sp)
+        }
+
+        unsafe fn update_context(context: &mut ucontext_t, regs: TrapHandlerRegs) {
+            cfg_if::cfg_if! {
+                if #[cfg(all(
+                        any(target_os = "linux", target_os = "android"),
+                        target_arch = "x86_64",
+                    ))] {
+                    let TrapHandlerRegs { rip, rsp, rbp, rdi, rsi } = regs;
+                    context.uc_mcontext.gregs[libc::REG_RIP as usize] = rip as i64;
+                    context.uc_mcontext.gregs[libc::REG_RSP as usize] = rsp as i64;
+                    context.uc_mcontext.gregs[libc::REG_RBP as usize] = rbp as i64;
+                    context.uc_mcontext.gregs[libc::REG_RDI as usize] = rdi as i64;
+                    context.uc_mcontext.gregs[libc::REG_RSI as usize] = rsi as i64;
+                } else if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    target_arch = "x86",
+                ))] {
+                    let TrapHandlerRegs { eip, esp, ebp, ecx, edx } = regs;
+                    context.uc_mcontext.gregs[libc::REG_EIP as usize] = eip as i32;
+                    context.uc_mcontext.gregs[libc::REG_ESP as usize] = esp as i32;
+                    context.uc_mcontext.gregs[libc::REG_EBP as usize] = ebp as i32;
+                    context.uc_mcontext.gregs[libc::REG_ECX as usize] = ecx as i32;
+                    context.uc_mcontext.gregs[libc::REG_EDX as usize] = edx as i32;
+                } else if #[cfg(all(target_vendor = "apple", target_arch = "x86_64"))] {
+                    let TrapHandlerRegs { rip, rsp, rbp, rdi, rsi } = regs;
+                    (*context.uc_mcontext).__ss.__rip = rip;
+                    (*context.uc_mcontext).__ss.__rsp = rsp;
+                    (*context.uc_mcontext).__ss.__rbp = rbp;
+                    (*context.uc_mcontext).__ss.__rdi = rdi;
+                    (*context.uc_mcontext).__ss.__rsi = rsi;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "x86"))] {
+                    let TrapHandlerRegs { eip, esp, ebp, ecx, edx } = regs;
+                    context.uc_mcontext.mc_eip = eip as libc::register_t;
+                    context.uc_mcontext.mc_esp = esp as libc::register_t;
+                    context.uc_mcontext.mc_ebp = ebp as libc::register_t;
+                    context.uc_mcontext.mc_ecx = ecx as libc::register_t;
+                    context.uc_mcontext.mc_edx = edx as libc::register_t;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))] {
+                    let TrapHandlerRegs { rip, rsp, rbp, rdi, rsi } = regs;
+                    context.uc_mcontext.mc_rip = rip as libc::register_t;
+                    context.uc_mcontext.mc_rsp = rsp as libc::register_t;
+                    context.uc_mcontext.mc_rbp = rbp as libc::register_t;
+                    context.uc_mcontext.mc_rdi = rdi as libc::register_t;
+                    context.uc_mcontext.mc_rsi = rsi as libc::register_t;
+                } else if #[cfg(all(
+                        any(target_os = "linux", target_os = "android"),
+                        target_arch = "aarch64",
+                    ))] {
+                    let TrapHandlerRegs { pc, sp, x0, x1, x29, lr } = regs;
+                    context.uc_mcontext.pc = pc;
+                    context.uc_mcontext.sp = sp;
+                    context.uc_mcontext.regs[0] = x0;
+                    context.uc_mcontext.regs[1] = x1;
+                    context.uc_mcontext.regs[29] = x29;
+                    context.uc_mcontext.regs[30] = lr;
+                } else if #[cfg(all(
+                        any(target_os = "linux", target_os = "android"),
+                        target_arch = "arm",
+                    ))] {
+                    let TrapHandlerRegs {
+                        pc,
+                        r0,
+                        r1,
+                        r7,
+                        r11,
+                        r13,
+                        r14,
+                        cpsr_thumb,
+                        cpsr_endian,
+                    } = regs;
+                    context.uc_mcontext.arm_pc = pc;
+                    context.uc_mcontext.arm_r0 = r0;
+                    context.uc_mcontext.arm_r1 = r1;
+                    context.uc_mcontext.arm_r7 = r7;
+                    context.uc_mcontext.arm_fp = r11;
+                    context.uc_mcontext.arm_sp = r13;
+                    context.uc_mcontext.arm_lr = r14;
+                    if cpsr_thumb {
+                        context.uc_mcontext.arm_cpsr |= 0x20;
+                    } else {
+                        context.uc_mcontext.arm_cpsr &= !0x20;
+                    }
+                    if cpsr_endian {
+                        context.uc_mcontext.arm_cpsr |= 0x200;
+                    } else {
+                        context.uc_mcontext.arm_cpsr &= !0x200;
+                    }
+                } else if #[cfg(all(
+                    any(target_os = "linux", target_os = "android"),
+                    any(target_arch = "riscv64", target_arch = "riscv32"),
+                ))] {
+                    let TrapHandlerRegs { pc, ra, sp, a0, a1, s0 } = regs;
+                    context.uc_mcontext.__gregs[libc::REG_PC] = pc as libc::c_ulong;
+                    context.uc_mcontext.__gregs[libc::REG_RA] = ra as libc::c_ulong;
+                    context.uc_mcontext.__gregs[libc::REG_SP] = sp as libc::c_ulong;
+                    context.uc_mcontext.__gregs[libc::REG_A0] = a0 as libc::c_ulong;
+                    context.uc_mcontext.__gregs[libc::REG_A0 + 1] = a1 as libc::c_ulong;
+                    context.uc_mcontext.__gregs[libc::REG_S0] = s0 as libc::c_ulong;
+                } else if #[cfg(all(target_vendor = "apple", target_arch = "aarch64"))] {
+                    let TrapHandlerRegs { pc, sp, x0, x1, x29, lr } = regs;
+                    (*context.uc_mcontext).__ss.__pc = pc;
+                    (*context.uc_mcontext).__ss.__sp = sp;
+                    (*context.uc_mcontext).__ss.__x[0] = x0;
+                    (*context.uc_mcontext).__ss.__x[1] = x1;
+                    (*context.uc_mcontext).__ss.__fp = x29;
+                    (*context.uc_mcontext).__ss.__lr = lr;
+                } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
+                    let TrapHandlerRegs { pc, sp, x0, x1, x29, lr } = regs;
+                    context.uc_mcontext.mc_gpregs.gp_elr = pc as libc::register_t;
+                    context.uc_mcontext.mc_gpregs.gp_sp = sp as libc::register_t;
+                    context.uc_mcontext.mc_gpregs.gp_x[0] = x0 as libc::register_t;
+                    context.uc_mcontext.mc_gpregs.gp_x[1] = x1 as libc::register_t;
+                    context.uc_mcontext.mc_gpregs.gp_x[29] = x29 as libc::register_t;
+                    context.uc_mcontext.mc_gpregs.gp_x[30] = lr as libc::register_t;
+                } else {
+                    compile_error!("Unsupported platform");
+                }
+            };
+        }
+    } else if #[cfg(target_os = "windows")] {
+        use winapi::um::errhandlingapi::*;
+        use winapi::um::winnt::*;
+        use winapi::um::minwinbase::*;
+        use winapi::vc::excpt::*;
+
+        unsafe fn platform_init() {
+            // our trap handler needs to go first, so that we can recover from
+            // wasm faults and continue execution, so pass `1` as a true value
+            // here.
+            if AddVectoredExceptionHandler(1, Some(exception_handler)).is_null() {
+                panic!("failed to add exception handler: {}", io::Error::last_os_error());
+            }
+        }
+
+        unsafe extern "system" fn exception_handler(
+            exception_info: PEXCEPTION_POINTERS
+        ) -> LONG {
+            // Check the kind of exception, since we only handle a subset within
+            // wasm code. If anything else happens we want to defer to whatever
+            // the rest of the system wants to do for this exception.
+            let record = &*(*exception_info).ExceptionRecord;
+            if record.ExceptionCode != EXCEPTION_ACCESS_VIOLATION &&
+                record.ExceptionCode != EXCEPTION_ILLEGAL_INSTRUCTION &&
+                record.ExceptionCode != EXCEPTION_STACK_OVERFLOW &&
+                record.ExceptionCode != EXCEPTION_INT_DIVIDE_BY_ZERO &&
+                record.ExceptionCode != EXCEPTION_INT_OVERFLOW
+            {
+                return EXCEPTION_CONTINUE_SEARCH;
+            }
+
+            // FIXME: this is what the previous C++ did to make sure that TLS
+            // works by the time we execute this trap handling code. This isn't
+            // exactly super easy to call from Rust though and it's not clear we
+            // necessarily need to do so. Leaving this here in case we need this
+            // in the future, but for now we can probably wait until we see a
+            // strange fault before figuring out how to reimplement this in
+            // Rust.
+            //
+            // if (!NtCurrentTeb()->Reserved1[sThreadLocalArrayPointerIndex]) {
+            //     return EXCEPTION_CONTINUE_SEARCH;
+            // }
+
+            let context = &mut *(*exception_info).ContextRecord;
+            let (pc, sp) = get_pc_sp(context);
+
+            // We try to get the fault address associated to this exception.
+            let maybe_fault_address = match record.ExceptionCode {
+                EXCEPTION_ACCESS_VIOLATION => Some(record.ExceptionInformation[1]),
+                EXCEPTION_STACK_OVERFLOW => Some(sp),
+                _ => None,
+            };
+            let trap_code = match record.ExceptionCode {
+                // check if it was cased by a UD and if the Trap info is a payload to it
+                EXCEPTION_ILLEGAL_INSTRUCTION => {
+                    process_illegal_op(pc)
+                }
+                _ => None,
+            };
+            // This is basically the same as the unix version above, only with a
+            // few parameters tweaked here and there.
+            let handled = TrapHandlerContext::handle_trap(
+                pc,
+                sp,
+                maybe_fault_address,
+                trap_code,
+                |regs| update_context(context, regs),
+                |handler| handler(exception_info),
+            );
+
+            if handled {
+                EXCEPTION_CONTINUE_EXECUTION
+            } else {
+                EXCEPTION_CONTINUE_SEARCH
+            }
+        }
+
+        unsafe fn get_pc_sp(context: &CONTEXT) -> (usize, usize) {
+            let (pc, sp);
+            cfg_if::cfg_if! {
+                if #[cfg(target_arch = "x86_64")] {
+                    pc = context.Rip as usize;
+                    sp = context.Rsp as usize;
+                } else if #[cfg(target_arch = "x86")] {
+                    pc = context.Rip as usize;
+                    sp = context.Rsp as usize;
+                } else {
+                    compile_error!("Unsupported platform");
+                }
+            };
+            (pc, sp)
+        }
+
+        unsafe fn update_context(context: &mut CONTEXT, regs: TrapHandlerRegs) {
+            cfg_if::cfg_if! {
+                if #[cfg(target_arch = "x86_64")] {
+                    let TrapHandlerRegs { rip, rsp, rbp, rdi, rsi } = regs;
+                    context.Rip = rip;
+                    context.Rsp = rsp;
+                    context.Rbp = rbp;
+                    context.Rdi = rdi;
+                    context.Rsi = rsi;
+                } else if #[cfg(target_arch = "x86")] {
+                    let TrapHandlerRegs { eip, esp, ebp, ecx, edx } = regs;
+                    context.Eip = eip;
+                    context.Esp = esp;
+                    context.Ebp = ebp;
+                    context.Ecx = ecx;
+                    context.Edx = edx;
+                } else {
+                    compile_error!("Unsupported platform");
+                }
+            };
+        }
+    }
+}
+
+/// This function is required to be called before any WebAssembly is entered.
+/// This will configure global state such as signal handlers to prepare the
+/// process to receive wasm traps.
+///
+/// This function must not only be called globally once before entering
+/// WebAssembly but it must also be called once-per-thread that enters
+/// WebAssembly. Currently in wasmer's integration this function is called on
+/// creation of a `Store`.
+pub fn init_traps() {
+    static INIT: Once = Once::new();
+    INIT.call_once(|| unsafe {
+        platform_init();
+    });
+}
+
+/// Raises a user-defined trap immediately.
+///
+/// This function performs as-if a wasm trap was just executed, only the trap
+/// has a dynamic payload associated with it which is user-provided. This trap
+/// payload is then returned from `catch_traps` below.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previous called and not yet returned.
+/// Additionally no Rust destructors may be on the stack.
+/// They will be skipped and not executed.
+pub unsafe fn raise_user_trap(data: Box<dyn Error + Send + Sync>) -> ! {
+    unwind_with(UnwindReason::UserTrap(data))
+}
+
+/// Raises a trap from inside library code immediately.
+///
+/// This function performs as-if a wasm trap was just executed. This trap
+/// payload is then returned from `catch_traps` below.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previous called and not yet returned.
+/// Additionally no Rust destructors may be on the stack.
+/// They will be skipped and not executed.
+pub unsafe fn raise_lib_trap(trap: Trap) -> ! {
+    unwind_with(UnwindReason::LibTrap(trap))
+}
+
+/// Carries a Rust panic across wasm code and resumes the panic on the other
+/// side.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previously called and not returned. Additionally no Rust destructors may be on the
+/// stack. They will be skipped and not executed.
+pub unsafe fn resume_panic(payload: Box<dyn Any + Send>) -> ! {
+    unwind_with(UnwindReason::Panic(payload))
+}
+
+/// Call the wasm function pointed to by `callee`.
+///
+/// * `vmctx` - the callee vmctx argument
+/// * `caller_vmctx` - the caller vmctx argument
+/// * `trampoline` - the jit-generated trampoline whose ABI takes 4 values, the
+///   callee vmctx, the caller vmctx, the `callee` argument below, and then the
+///   `values_vec` argument.
+/// * `callee` - the third argument to the `trampoline` function
+/// * `values_vec` - points to a buffer which holds the incoming arguments, and to
+///   which the outgoing return values will be written.
+///
+/// # Safety
+///
+/// Wildly unsafe because it calls raw function pointers and reads/writes raw
+/// function pointers.
+pub unsafe fn wasmer_call_trampoline(
+    trap_handler: Option<*const TrapHandlerFn<'static>>,
+    config: &VMConfig,
+    vmctx: VMFunctionContext,
+    trampoline: VMTrampoline,
+    callee: *const VMFunctionBody,
+    values_vec: *mut u8,
+) -> Result<(), Trap> {
+    catch_traps(trap_handler, config, || {
+        mem::transmute::<_, extern "C" fn(VMFunctionContext, *const VMFunctionBody, *mut u8)>(
+            trampoline,
+        )(vmctx, callee, values_vec);
+    })
+}
+
+/// Catches any wasm traps that happen within the execution of `closure`,
+/// returning them as a `Result`.
+///
+/// # Safety
+///
+/// Highly unsafe since `closure` won't have any dtors run.
+pub unsafe fn catch_traps<F, R>(
+    trap_handler: Option<*const TrapHandlerFn<'static>>,
+    config: &VMConfig,
+    closure: F,
+) -> Result<R, Trap>
+where
+    F: FnOnce() -> R,
+{
+    // Ensure that per-thread initialization is done.
+    lazy_per_thread_init()?;
+    let stack_size = config
+        .wasm_stack_size
+        .unwrap_or_else(|| DEFAULT_STACK_SIZE.load(Ordering::Relaxed));
+    on_wasm_stack(stack_size, trap_handler, closure).map_err(UnwindReason::into_trap)
+}
+
+// We need two separate thread-local variables here:
+// - YIELDER is set within the new stack and is used to unwind back to the root
+//   of the stack from inside it.
+// - TRAP_HANDLER is set from outside the new stack and is solely used from
+//   signal handlers. It must be atomic since it is used by signal handlers.
+//
+// We also do per-thread signal stack initialization on the first time
+// TRAP_HANDLER is accessed.
+thread_local! {
+    static YIELDER: Cell<Option<NonNull<Yielder<(), UnwindReason>>>> = Cell::new(None);
+    static TRAP_HANDLER: AtomicPtr<TrapHandlerContext> = AtomicPtr::new(ptr::null_mut());
+}
+
+/// Read-only information that is used by signal handlers to handle and recover
+/// from traps.
+#[allow(clippy::type_complexity)]
+struct TrapHandlerContext {
+    inner: *const u8,
+    handle_trap: fn(
+        *const u8,
+        usize,
+        usize,
+        Option<usize>,
+        Option<TrapCode>,
+        &mut dyn FnMut(TrapHandlerRegs),
+    ) -> bool,
+    custom_trap: Option<*const TrapHandlerFn<'static>>,
+}
+struct TrapHandlerContextInner<T> {
+    /// Information about the currently running coroutine. This is used to
+    /// reset execution to the root of the coroutine when a trap is handled.
+    coro_trap_handler: CoroutineTrapHandler<Result<T, UnwindReason>>,
+}
+
+impl TrapHandlerContext {
+    /// Runs the given function with a trap handler context. The previous
+    /// trap handler context is preserved and restored afterwards.
+    fn install<T, R>(
+        custom_trap: Option<*const TrapHandlerFn<'static>>,
+        coro_trap_handler: CoroutineTrapHandler<Result<T, UnwindReason>>,
+        f: impl FnOnce() -> R,
+    ) -> R {
+        // Type-erase the trap handler function so that it can be placed in TLS.
+        fn func<T>(
+            ptr: *const u8,
+            pc: usize,
+            sp: usize,
+            maybe_fault_address: Option<usize>,
+            trap_code: Option<TrapCode>,
+            update_regs: &mut dyn FnMut(TrapHandlerRegs),
+        ) -> bool {
+            unsafe {
+                (*(ptr as *const TrapHandlerContextInner<T>)).handle_trap(
+                    pc,
+                    sp,
+                    maybe_fault_address,
+                    trap_code,
+                    update_regs,
+                )
+            }
+        }
+        let inner = TrapHandlerContextInner { coro_trap_handler };
+        let ctx = Self {
+            inner: &inner as *const _ as *const u8,
+            handle_trap: func::<T>,
+            custom_trap,
+        };
+
+        compiler_fence(Ordering::Release);
+        let prev = TRAP_HANDLER.with(|ptr| {
+            let prev = ptr.load(Ordering::Relaxed);
+            ptr.store(&ctx as *const Self as *mut Self, Ordering::Relaxed);
+            prev
+        });
+
+        defer! {
+            TRAP_HANDLER.with(|ptr| ptr.store(prev, Ordering::Relaxed));
+            compiler_fence(Ordering::Acquire);
+        }
+
+        f()
+    }
+
+    /// Attempts to handle the trap if it's a wasm trap.
+    unsafe fn handle_trap(
+        pc: usize,
+        sp: usize,
+        maybe_fault_address: Option<usize>,
+        trap_code: Option<TrapCode>,
+        mut update_regs: impl FnMut(TrapHandlerRegs),
+        call_handler: impl Fn(&TrapHandlerFn<'static>) -> bool,
+    ) -> bool {
+        let ptr = TRAP_HANDLER.with(|ptr| ptr.load(Ordering::Relaxed));
+        if ptr.is_null() {
+            return false;
+        }
+
+        let ctx = &*ptr;
+
+        // Check if this trap is handled by a custom trap handler.
+        if let Some(trap_handler) = ctx.custom_trap {
+            if call_handler(&*trap_handler) {
+                return true;
+            }
+        }
+
+        (ctx.handle_trap)(
+            ctx.inner,
+            pc,
+            sp,
+            maybe_fault_address,
+            trap_code,
+            &mut update_regs,
+        )
+    }
+}
+
+impl<T> TrapHandlerContextInner<T> {
+    unsafe fn handle_trap(
+        &self,
+        pc: usize,
+        sp: usize,
+        maybe_fault_address: Option<usize>,
+        trap_code: Option<TrapCode>,
+        update_regs: &mut dyn FnMut(TrapHandlerRegs),
+    ) -> bool {
+        // Check if this trap occurred while executing on the Wasm stack. We can
+        // only recover from traps if that is the case.
+        if !self.coro_trap_handler.stack_ptr_in_bounds(sp) {
+            return false;
+        }
+
+        let signal_trap = trap_code.or_else(|| {
+            maybe_fault_address.map(|addr| {
+                if self.coro_trap_handler.stack_ptr_in_bounds(addr) {
+                    TrapCode::StackOverflow
+                } else {
+                    TrapCode::HeapAccessOutOfBounds
+                }
+            })
+        });
+
+        // Don't try to generate a backtrace for stack overflows: unwinding
+        // information is often not precise enough to properly describe what is
+        // happenning during a function prologue, which can lead the unwinder to
+        // read invalid memory addresses.
+        //
+        // See: https://github.com/rust-lang/backtrace-rs/pull/357
+        let backtrace = if signal_trap == Some(TrapCode::StackOverflow) {
+            Backtrace::from(vec![])
+        } else {
+            Backtrace::new_unresolved()
+        };
+
+        // Set up the register state for exception return to force the
+        // coroutine to return to its caller with UnwindReason::WasmTrap.
+        let unwind = UnwindReason::WasmTrap {
+            backtrace,
+            signal_trap,
+            pc,
+        };
+        let regs = self
+            .coro_trap_handler
+            .setup_trap_handler(move || Err(unwind));
+        update_regs(regs);
+        true
+    }
+}
+
+enum UnwindReason {
+    /// A panic caused by the host
+    Panic(Box<dyn Any + Send>),
+    /// A custom error triggered by the user
+    UserTrap(Box<dyn Error + Send + Sync>),
+    /// A Trap triggered by a wasm libcall
+    LibTrap(Trap),
+    /// A trap caused by the Wasm generated code
+    WasmTrap {
+        backtrace: Backtrace,
+        pc: usize,
+        signal_trap: Option<TrapCode>,
+    },
+}
+
+impl UnwindReason {
+    fn into_trap(self) -> Trap {
+        match self {
+            Self::UserTrap(data) => Trap::User(data),
+            Self::LibTrap(trap) => trap,
+            Self::WasmTrap {
+                backtrace,
+                pc,
+                signal_trap,
+            } => Trap::wasm(pc, backtrace, signal_trap),
+            Self::Panic(panic) => std::panic::resume_unwind(panic),
+        }
+    }
+}
+
+unsafe fn unwind_with(reason: UnwindReason) -> ! {
+    let yielder = YIELDER
+        .with(|cell| cell.replace(None))
+        .expect("not running on Wasm stack");
+
+    yielder.as_ref().suspend(reason);
+
+    // on_wasm_stack will forcibly reset the coroutine stack after yielding.
+    unreachable!();
+}
+
+/// Runs the given function on a separate stack so that its stack usage can be
+/// bounded. Stack overflows and other traps can be caught and execution
+/// returned to the root of the stack.
+fn on_wasm_stack<F: FnOnce() -> T, T>(
+    stack_size: usize,
+    trap_handler: Option<*const TrapHandlerFn<'static>>,
+    f: F,
+) -> Result<T, UnwindReason> {
+    // Allocating a new stack is pretty expensive since it involves several
+    // system calls. We therefore keep a cache of pre-allocated stacks which
+    // allows them to be reused multiple times.
+    // FIXME(Amanieu): We should refactor this to avoid the lock.
+    lazy_static::lazy_static! {
+        static ref STACK_POOL: crossbeam_queue::SegQueue<DefaultStack> = crossbeam_queue::SegQueue::new();
+    }
+    let stack = STACK_POOL
+        .pop()
+        .unwrap_or_else(|| DefaultStack::new(stack_size).unwrap());
+    let mut stack = scopeguard::guard(stack, |stack| STACK_POOL.push(stack));
+
+    // Create a coroutine with a new stack to run the function on.
+    let mut coro = ScopedCoroutine::with_stack(&mut *stack, move |yielder, ()| {
+        // Save the yielder to TLS so that it can be used later.
+        YIELDER.with(|cell| cell.set(Some(yielder.into())));
+
+        Ok(f())
+    });
+
+    // Ensure that YIELDER is reset on exit even if the coroutine panics,
+    defer! {
+        YIELDER.with(|cell| cell.set(None));
+    }
+
+    // Set up metadata for the trap handler for the duration of the coroutine
+    // execution. This is restored to its previous value afterwards.
+    TrapHandlerContext::install(trap_handler, coro.trap_handler(), || {
+        match coro.resume(()) {
+            CoroutineResult::Yield(trap) => {
+                // This came from unwind_with which requires that there be only
+                // Wasm code on the stack.
+                unsafe {
+                    coro.force_reset();
+                }
+                Err(trap)
+            }
+            CoroutineResult::Return(result) => result,
+        }
+    })
+}
+
+/// When executing on the Wasm stack, temporarily switch back to the host stack
+/// to perform an operation that should not be constrainted by the Wasm stack
+/// limits.
+///
+/// This is particularly important since the usage of the Wasm stack is under
+/// the control of untrusted code. Malicious code could artificially induce a
+/// stack overflow in the middle of a sensitive host operations (e.g. growing
+/// a memory) which would be hard to recover from.
+pub fn on_host_stack<F: FnOnce() -> T, T>(f: F) -> T {
+    // Reset YIEDER to None for the duration of this call to indicate that we
+    // are no longer on the Wasm stack.
+    let yielder_ptr = YIELDER.with(|cell| cell.replace(None));
+
+    // If we are already on the host stack, execute the function directly. This
+    // happens if a host function is called directly from the API.
+    let yielder = match yielder_ptr {
+        Some(ptr) => unsafe { ptr.as_ref() },
+        None => return f(),
+    };
+
+    // Restore YIELDER upon exiting normally or unwinding.
+    defer! {
+        YIELDER.with(|cell| cell.set(yielder_ptr));
+    }
+
+    // on_parent_stack requires the closure to be Send so that the Yielder
+    // cannot be called from the parent stack. This is not a problem for us
+    // since we don't expose the Yielder.
+    struct SendWrapper<T>(T);
+    unsafe impl<T> Send for SendWrapper<T> {}
+    let wrapped = SendWrapper(f);
+    yielder.on_parent_stack(move || {
+        let wrapped = wrapped;
+        (wrapped.0)()
+    })
+}
+
+#[cfg(windows)]
+pub fn lazy_per_thread_init() -> Result<(), Trap> {
+    // We need additional space on the stack to handle stack overflow
+    // exceptions. Rust's initialization code sets this to 0x5000 but this
+    // seems to be insufficient in practice.
+    use winapi::um::processthreadsapi::SetThreadStackGuarantee;
+    if unsafe { SetThreadStackGuarantee(&mut 0x10000) } == 0 {
+        panic!("failed to set thread stack guarantee");
+    }
+
+    Ok(())
+}
+
+/// A module for registering a custom alternate signal stack (sigaltstack).
+///
+/// Rust's libstd installs an alternate stack with size `SIGSTKSZ`, which is not
+/// always large enough for our signal handling code. Override it by creating
+/// and registering our own alternate stack that is large enough and has a guard
+/// page.
+#[cfg(unix)]
+pub fn lazy_per_thread_init() -> Result<(), Trap> {
+    use std::ptr::null_mut;
+
+    thread_local! {
+        /// Thread-local state is lazy-initialized on the first time it's used,
+        /// and dropped when the thread exits.
+        static TLS: Tls = unsafe { init_sigstack() };
+    }
+
+    /// The size of the sigaltstack (not including the guard, which will be
+    /// added). Make this large enough to run our signal handlers.
+    const MIN_STACK_SIZE: usize = 16 * 4096;
+
+    enum Tls {
+        OutOfMemory,
+        Allocated {
+            mmap_ptr: *mut libc::c_void,
+            mmap_size: usize,
+        },
+        BigEnough,
+    }
+
+    unsafe fn init_sigstack() -> Tls {
+        // Check to see if the existing sigaltstack, if it exists, is big
+        // enough. If so we don't need to allocate our own.
+        let mut old_stack = mem::zeroed();
+        let r = libc::sigaltstack(ptr::null(), &mut old_stack);
+        assert_eq!(r, 0, "learning about sigaltstack failed");
+        if old_stack.ss_flags & libc::SS_DISABLE == 0 && old_stack.ss_size >= MIN_STACK_SIZE {
+            return Tls::BigEnough;
+        }
+
+        // ... but failing that we need to allocate our own, so do all that
+        // here.
+        let page_size: usize = region::page::size();
+        let guard_size = page_size;
+        let alloc_size = guard_size + MIN_STACK_SIZE;
+
+        let ptr = libc::mmap(
+            null_mut(),
+            alloc_size,
+            libc::PROT_NONE,
+            libc::MAP_PRIVATE | libc::MAP_ANON,
+            -1,
+            0,
+        );
+        if ptr == libc::MAP_FAILED {
+            return Tls::OutOfMemory;
+        }
+
+        // Prepare the stack with readable/writable memory and then register it
+        // with `sigaltstack`.
+        let stack_ptr = (ptr as usize + guard_size) as *mut libc::c_void;
+        let r = libc::mprotect(
+            stack_ptr,
+            MIN_STACK_SIZE,
+            libc::PROT_READ | libc::PROT_WRITE,
+        );
+        assert_eq!(r, 0, "mprotect to configure memory for sigaltstack failed");
+        let new_stack = libc::stack_t {
+            ss_sp: stack_ptr,
+            ss_flags: 0,
+            ss_size: MIN_STACK_SIZE,
+        };
+        let r = libc::sigaltstack(&new_stack, ptr::null_mut());
+        assert_eq!(r, 0, "registering new sigaltstack failed");
+
+        Tls::Allocated {
+            mmap_ptr: ptr,
+            mmap_size: alloc_size,
+        }
+    }
+
+    // Ensure TLS runs its initializer and return an error if it failed to
+    // set up a separate stack for signal handlers.
+    return TLS.with(|tls| {
+        if let Tls::OutOfMemory = tls {
+            Err(Trap::oom())
+        } else {
+            Ok(())
+        }
+    });
+
+    impl Drop for Tls {
+        fn drop(&mut self) {
+            let (ptr, size) = match self {
+                Self::Allocated {
+                    mmap_ptr,
+                    mmap_size,
+                } => (*mmap_ptr, *mmap_size),
+                _ => return,
+            };
+            unsafe {
+                // Deallocate the stack memory.
+                let r = libc::munmap(ptr, size);
+                debug_assert_eq!(r, 0, "munmap failed during thread shutdown");
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/vm/src/vmcontext.rs b/arbitrator/tools/module_roots/wasmer/lib/vm/src/vmcontext.rs
new file mode 100644
index 0000000..520d100
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/vm/src/vmcontext.rs
@@ -0,0 +1,807 @@
+// This file contains code from external sources.
+// Attributions: https://github.com/wasmerio/wasmer/blob/master/ATTRIBUTIONS.md
+
+//! This file declares `VMContext` and several related structs which contain
+//! fields that compiled wasm code accesses directly.
+
+use crate::global::VMGlobal;
+use crate::instance::Instance;
+use crate::memory::VMMemory;
+use crate::store::InternalStoreHandle;
+use crate::trap::{Trap, TrapCode};
+use crate::VMFunctionBody;
+use crate::VMTable;
+use crate::{VMBuiltinFunctionIndex, VMFunction};
+use std::convert::TryFrom;
+use std::ptr::{self, NonNull};
+use std::sync::atomic::{AtomicPtr, Ordering};
+use std::u32;
+use wasmer_types::RawValue;
+
+/// Union representing the first parameter passed when calling a function.
+///
+/// It may either be a pointer to the [`VMContext`] if it's a Wasm function
+/// or a pointer to arbitrary data controlled by the host if it's a host function.
+#[derive(Copy, Clone, Eq)]
+#[repr(C)]
+pub union VMFunctionContext {
+    /// Wasm functions take a pointer to [`VMContext`].
+    pub vmctx: *mut VMContext,
+    /// Host functions can have custom environments.
+    pub host_env: *mut std::ffi::c_void,
+}
+
+impl VMFunctionContext {
+    /// Check whether the pointer stored is null or not.
+    pub fn is_null(&self) -> bool {
+        unsafe { self.host_env.is_null() }
+    }
+}
+
+impl std::fmt::Debug for VMFunctionContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("VMFunctionContext")
+            .field("vmctx_or_hostenv", unsafe { &self.host_env })
+            .finish()
+    }
+}
+
+impl std::cmp::PartialEq for VMFunctionContext {
+    fn eq(&self, rhs: &Self) -> bool {
+        unsafe { self.host_env as usize == rhs.host_env as usize }
+    }
+}
+
+impl std::hash::Hash for VMFunctionContext {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        unsafe {
+            self.vmctx.hash(state);
+        }
+    }
+}
+
+/// An imported function.
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct VMFunctionImport {
+    /// A pointer to the imported function body.
+    pub body: *const VMFunctionBody,
+
+    /// A pointer to the `VMContext` that owns the function or host env data.
+    pub environment: VMFunctionContext,
+
+    /// Handle to the `VMFunction` in the context.
+    pub handle: InternalStoreHandle<VMFunction>,
+}
+
+#[cfg(test)]
+mod test_vmfunction_import {
+    use super::VMFunctionImport;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+    use wasmer_types::VMOffsets;
+
+    #[test]
+    fn check_vmfunction_import_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMFunctionImport>(),
+            usize::from(offsets.size_of_vmfunction_import())
+        );
+        assert_eq!(
+            offset_of!(VMFunctionImport, body),
+            usize::from(offsets.vmfunction_import_body())
+        );
+        assert_eq!(
+            offset_of!(VMFunctionImport, environment),
+            usize::from(offsets.vmfunction_import_vmctx())
+        );
+    }
+}
+
+/// The `VMDynamicFunctionContext` is the context that dynamic
+/// functions will receive when called (rather than `vmctx`).
+/// A dynamic function is a function for which we don't know the signature
+/// until runtime.
+///
+/// As such, we need to expose the dynamic function `context`
+/// containing the relevant context for running the function indicated
+/// in `address`.
+#[repr(C)]
+pub struct VMDynamicFunctionContext<T> {
+    /// The address of the inner dynamic function.
+    ///
+    /// Note: The function must be on the form of
+    /// `(*mut T, SignatureIndex, *mut i128)`.
+    pub address: *const VMFunctionBody,
+
+    /// The context that the inner dynamic function will receive.
+    pub ctx: T,
+}
+
+// The `ctx` itself must be `Send`, `address` can be passed between
+// threads because all usage is `unsafe` and synchronized.
+unsafe impl<T: Sized + Send + Sync> Send for VMDynamicFunctionContext<T> {}
+// The `ctx` itself must be `Sync`, `address` can be shared between
+// threads because all usage is `unsafe` and synchronized.
+unsafe impl<T: Sized + Send + Sync> Sync for VMDynamicFunctionContext<T> {}
+
+impl<T: Sized + Clone + Send + Sync> Clone for VMDynamicFunctionContext<T> {
+    fn clone(&self) -> Self {
+        Self {
+            address: self.address,
+            ctx: self.ctx.clone(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test_vmdynamicfunction_import_context {
+    use super::VMDynamicFunctionContext;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmdynamicfunction_import_context_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMDynamicFunctionContext<usize>>(),
+            usize::from(offsets.size_of_vmdynamicfunction_import_context())
+        );
+        assert_eq!(
+            offset_of!(VMDynamicFunctionContext<usize>, address),
+            usize::from(offsets.vmdynamicfunction_import_context_address())
+        );
+        assert_eq!(
+            offset_of!(VMDynamicFunctionContext<usize>, ctx),
+            usize::from(offsets.vmdynamicfunction_import_context_ctx())
+        );
+    }
+}
+
+/// A function kind is a calling convention into and out of wasm code.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+#[repr(C)]
+pub enum VMFunctionKind {
+    /// A static function has the native signature:
+    /// `extern "C" (vmctx, arg1, arg2...) -> (result1, result2, ...)`.
+    ///
+    /// This is the default for functions that are defined:
+    /// 1. In the Host, natively
+    /// 2. In the WebAssembly file
+    Static,
+
+    /// A dynamic function has the native signature:
+    /// `extern "C" (ctx, &[Value]) -> Vec<Value>`.
+    ///
+    /// This is the default for functions that are defined:
+    /// 1. In the Host, dynamically
+    Dynamic,
+}
+
+/// The fields compiled code needs to access to utilize a WebAssembly table
+/// imported from another instance.
+#[derive(Clone)]
+#[repr(C)]
+pub struct VMTableImport {
+    /// A pointer to the imported table description.
+    pub definition: NonNull<VMTableDefinition>,
+
+    /// Handle to the `VMTable` in the context.
+    pub handle: InternalStoreHandle<VMTable>,
+}
+
+#[cfg(test)]
+mod test_vmtable_import {
+    use super::VMTableImport;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmtable_import_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMTableImport>(),
+            usize::from(offsets.size_of_vmtable_import())
+        );
+        assert_eq!(
+            offset_of!(VMTableImport, definition),
+            usize::from(offsets.vmtable_import_definition())
+        );
+    }
+}
+
+/// The fields compiled code needs to access to utilize a WebAssembly linear
+/// memory imported from another instance.
+#[derive(Clone)]
+#[repr(C)]
+pub struct VMMemoryImport {
+    /// A pointer to the imported memory description.
+    pub definition: NonNull<VMMemoryDefinition>,
+
+    /// A handle to the `Memory` that owns the memory description.
+    pub handle: InternalStoreHandle<VMMemory>,
+}
+
+#[cfg(test)]
+mod test_vmmemory_import {
+    use super::VMMemoryImport;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmmemory_import_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMMemoryImport>(),
+            usize::from(offsets.size_of_vmmemory_import())
+        );
+        assert_eq!(
+            offset_of!(VMMemoryImport, definition),
+            usize::from(offsets.vmmemory_import_definition())
+        );
+        assert_eq!(
+            offset_of!(VMMemoryImport, handle),
+            usize::from(offsets.vmmemory_import_handle())
+        );
+    }
+}
+
+/// The fields compiled code needs to access to utilize a WebAssembly global
+/// variable imported from another instance.
+#[derive(Clone)]
+#[repr(C)]
+pub struct VMGlobalImport {
+    /// A pointer to the imported global variable description.
+    pub definition: NonNull<VMGlobalDefinition>,
+
+    /// A handle to the `Global` that owns the global description.
+    pub handle: InternalStoreHandle<VMGlobal>,
+}
+
+/// # Safety
+/// This data is safe to share between threads because it's plain data that
+/// is the user's responsibility to synchronize. Additionally, all operations
+/// on `from` are thread-safe through the use of a mutex in [`VMGlobal`].
+unsafe impl Send for VMGlobalImport {}
+/// # Safety
+/// This data is safe to share between threads because it's plain data that
+/// is the user's responsibility to synchronize. And because it's `Clone`, there's
+/// really no difference between passing it by reference or by value as far as
+/// correctness in a multi-threaded context is concerned.
+unsafe impl Sync for VMGlobalImport {}
+
+#[cfg(test)]
+mod test_vmglobal_import {
+    use super::VMGlobalImport;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmglobal_import_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMGlobalImport>(),
+            usize::from(offsets.size_of_vmglobal_import())
+        );
+        assert_eq!(
+            offset_of!(VMGlobalImport, definition),
+            usize::from(offsets.vmglobal_import_definition())
+        );
+    }
+}
+
+/// Do an unsynchronized, non-atomic `memory.copy` for the memory.
+///
+/// # Errors
+///
+/// Returns a `Trap` error when the source or destination ranges are out of
+/// bounds.
+///
+/// # Safety
+/// The memory is not copied atomically and is not synchronized: it's the
+/// caller's responsibility to synchronize.
+pub(crate) unsafe fn memory_copy(
+    mem: &VMMemoryDefinition,
+    dst: u32,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
+    if src
+        .checked_add(len)
+        .map_or(true, |n| usize::try_from(n).unwrap() > mem.current_length)
+        || dst
+            .checked_add(len)
+            .map_or(true, |m| usize::try_from(m).unwrap() > mem.current_length)
+    {
+        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+    }
+
+    let dst = usize::try_from(dst).unwrap();
+    let src = usize::try_from(src).unwrap();
+
+    // Bounds and casts are checked above, by this point we know that
+    // everything is safe.
+    let dst = mem.base.add(dst);
+    let src = mem.base.add(src);
+    ptr::copy(src, dst, len as usize);
+
+    Ok(())
+}
+
+/// Perform the `memory.fill` operation for the memory in an unsynchronized,
+/// non-atomic way.
+///
+/// # Errors
+///
+/// Returns a `Trap` error if the memory range is out of bounds.
+///
+/// # Safety
+/// The memory is not filled atomically and is not synchronized: it's the
+/// caller's responsibility to synchronize.
+pub(crate) unsafe fn memory_fill(
+    mem: &VMMemoryDefinition,
+    dst: u32,
+    val: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    if dst
+        .checked_add(len)
+        .map_or(true, |m| usize::try_from(m).unwrap() > mem.current_length)
+    {
+        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+    }
+
+    let dst = isize::try_from(dst).unwrap();
+    let val = val as u8;
+
+    // Bounds and casts are checked above, by this point we know that
+    // everything is safe.
+    let dst = mem.base.offset(dst);
+    ptr::write_bytes(dst, val, len as usize);
+
+    Ok(())
+}
+
+/// Perform the `memory32.atomic.check32` operation for the memory. Return 0 if same, 1 if different
+///
+/// # Errors
+///
+/// Returns a `Trap` error if the memory range is out of bounds or 32bits unligned.
+///
+/// # Safety
+/// memory access is unsafe
+pub(crate) unsafe fn memory32_atomic_check32(
+    mem: &VMMemoryDefinition,
+    dst: u32,
+    val: u32,
+) -> Result<u32, Trap> {
+    if usize::try_from(dst).unwrap() > mem.current_length {
+        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+    }
+
+    let dst = isize::try_from(dst).unwrap();
+    if dst & 0b11 != 0 {
+        return Err(Trap::lib(TrapCode::UnalignedAtomic));
+    }
+
+    // Bounds and casts are checked above, by this point we know that
+    // everything is safe.
+    let dst = mem.base.offset(dst) as *mut u32;
+    let atomic_dst = AtomicPtr::new(dst);
+    let read_val = *atomic_dst.load(Ordering::Acquire);
+    let ret = if read_val == val { 0 } else { 1 };
+    Ok(ret)
+}
+
+/// Perform the `memory32.atomic.check64` operation for the memory. Return 0 if same, 1 if different
+///
+/// # Errors
+///
+/// Returns a `Trap` error if the memory range is out of bounds or 64bits unaligned.
+///
+/// # Safety
+/// memory access is unsafe
+pub(crate) unsafe fn memory32_atomic_check64(
+    mem: &VMMemoryDefinition,
+    dst: u32,
+    val: u64,
+) -> Result<u32, Trap> {
+    if usize::try_from(dst).unwrap() > mem.current_length {
+        return Err(Trap::lib(TrapCode::HeapAccessOutOfBounds));
+    }
+
+    let dst = isize::try_from(dst).unwrap();
+    if dst & 0b111 != 0 {
+        return Err(Trap::lib(TrapCode::UnalignedAtomic));
+    }
+
+    // Bounds and casts are checked above, by this point we know that
+    // everything is safe.
+    let dst = mem.base.offset(dst) as *mut u64;
+    let atomic_dst = AtomicPtr::new(dst);
+    let read_val = *atomic_dst.load(Ordering::Acquire);
+    let ret = if read_val == val { 0 } else { 1 };
+    Ok(ret)
+}
+
+/// The fields compiled code needs to access to utilize a WebAssembly table
+/// defined within the instance.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct VMTableDefinition {
+    /// Pointer to the table data.
+    pub base: *mut u8,
+
+    /// The current number of elements in the table.
+    pub current_elements: u32,
+}
+
+#[cfg(test)]
+mod test_vmtable_definition {
+    use super::VMTableDefinition;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmtable_definition_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMTableDefinition>(),
+            usize::from(offsets.size_of_vmtable_definition())
+        );
+        assert_eq!(
+            offset_of!(VMTableDefinition, base),
+            usize::from(offsets.vmtable_definition_base())
+        );
+        assert_eq!(
+            offset_of!(VMTableDefinition, current_elements),
+            usize::from(offsets.vmtable_definition_current_elements())
+        );
+    }
+}
+
+/// The storage for a WebAssembly global defined within the instance.
+///
+/// TODO: Pack the globals more densely, rather than using the same size
+/// for every type.
+#[derive(Debug, Clone)]
+#[repr(C, align(16))]
+pub struct VMGlobalDefinition {
+    /// Raw value of the global.
+    pub val: RawValue,
+}
+
+#[cfg(test)]
+mod test_vmglobal_definition {
+    use super::VMGlobalDefinition;
+    use crate::{VMFuncRef, VMOffsets};
+    use more_asserts::assert_ge;
+    use std::mem::{align_of, size_of};
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmglobal_definition_alignment() {
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i32>());
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<i64>());
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f32>());
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<f64>());
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<VMFuncRef>());
+        assert_ge!(align_of::<VMGlobalDefinition>(), align_of::<[u8; 16]>());
+    }
+
+    #[test]
+    fn check_vmglobal_definition_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<*const VMGlobalDefinition>(),
+            usize::from(offsets.size_of_vmglobal_local())
+        );
+    }
+
+    #[test]
+    fn check_vmglobal_begins_aligned() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(offsets.vmctx_globals_begin() % 16, 0);
+    }
+}
+
+impl VMGlobalDefinition {
+    /// Construct a `VMGlobalDefinition`.
+    pub fn new() -> Self {
+        Self {
+            val: Default::default(),
+        }
+    }
+}
+
+/// An index into the shared signature registry, usable for checking signatures
+/// at indirect calls.
+#[repr(C)]
+#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
+pub struct VMSharedSignatureIndex(u32);
+
+#[cfg(test)]
+mod test_vmshared_signature_index {
+    use super::VMSharedSignatureIndex;
+    use std::mem::size_of;
+    use wasmer_types::{ModuleInfo, TargetSharedSignatureIndex, VMOffsets};
+
+    #[test]
+    fn check_vmshared_signature_index() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMSharedSignatureIndex>(),
+            usize::from(offsets.size_of_vmshared_signature_index())
+        );
+    }
+
+    #[test]
+    fn check_target_shared_signature_index() {
+        assert_eq!(
+            size_of::<VMSharedSignatureIndex>(),
+            size_of::<TargetSharedSignatureIndex>()
+        );
+    }
+}
+
+impl VMSharedSignatureIndex {
+    /// Create a new `VMSharedSignatureIndex`.
+    pub fn new(value: u32) -> Self {
+        Self(value)
+    }
+}
+
+impl Default for VMSharedSignatureIndex {
+    fn default() -> Self {
+        Self::new(u32::MAX)
+    }
+}
+
+/// The VM caller-checked "anyfunc" record, for caller-side signature checking.
+/// It consists of the actual function pointer and a signature id to be checked
+/// by the caller.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
+#[repr(C)]
+pub struct VMCallerCheckedAnyfunc {
+    /// Function body.
+    pub func_ptr: *const VMFunctionBody,
+    /// Function signature id.
+    pub type_index: VMSharedSignatureIndex,
+    /// Function `VMContext` or host env.
+    pub vmctx: VMFunctionContext,
+    /// Address of the function call trampoline to invoke this function using
+    /// a dynamic argument list.
+    pub call_trampoline: VMTrampoline,
+    // If more elements are added here, remember to add offset_of tests below!
+}
+
+#[cfg(test)]
+mod test_vmcaller_checked_anyfunc {
+    use super::VMCallerCheckedAnyfunc;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmcaller_checked_anyfunc_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMCallerCheckedAnyfunc>(),
+            usize::from(offsets.size_of_vmcaller_checked_anyfunc())
+        );
+        assert_eq!(
+            offset_of!(VMCallerCheckedAnyfunc, func_ptr),
+            usize::from(offsets.vmcaller_checked_anyfunc_func_ptr())
+        );
+        assert_eq!(
+            offset_of!(VMCallerCheckedAnyfunc, type_index),
+            usize::from(offsets.vmcaller_checked_anyfunc_type_index())
+        );
+        assert_eq!(
+            offset_of!(VMCallerCheckedAnyfunc, vmctx),
+            usize::from(offsets.vmcaller_checked_anyfunc_vmctx())
+        );
+    }
+}
+
+/// An array that stores addresses of builtin functions. We translate code
+/// to use indirect calls. This way, we don't have to patch the code.
+#[repr(C)]
+pub struct VMBuiltinFunctionsArray {
+    ptrs: [usize; Self::len()],
+}
+
+impl VMBuiltinFunctionsArray {
+    pub const fn len() -> usize {
+        VMBuiltinFunctionIndex::builtin_functions_total_number() as usize
+    }
+
+    pub fn initialized() -> Self {
+        use crate::libcalls::*;
+
+        let mut ptrs = [0; Self::len()];
+
+        ptrs[VMBuiltinFunctionIndex::get_memory32_grow_index().index() as usize] =
+            wasmer_vm_memory32_grow as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_grow_index().index() as usize] =
+            wasmer_vm_imported_memory32_grow as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_memory32_size_index().index() as usize] =
+            wasmer_vm_memory32_size as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory32_size_index().index() as usize] =
+            wasmer_vm_imported_memory32_size as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_table_copy_index().index() as usize] =
+            wasmer_vm_table_copy as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_table_init_index().index() as usize] =
+            wasmer_vm_table_init as usize;
+        ptrs[VMBuiltinFunctionIndex::get_elem_drop_index().index() as usize] =
+            wasmer_vm_elem_drop as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_memory_copy_index().index() as usize] =
+            wasmer_vm_memory32_copy as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_copy_index().index() as usize] =
+            wasmer_vm_imported_memory32_copy as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_fill_index().index() as usize] =
+            wasmer_vm_memory32_fill as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_fill_index().index() as usize] =
+            wasmer_vm_imported_memory32_fill as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_init_index().index() as usize] =
+            wasmer_vm_memory32_init as usize;
+        ptrs[VMBuiltinFunctionIndex::get_data_drop_index().index() as usize] =
+            wasmer_vm_data_drop as usize;
+        ptrs[VMBuiltinFunctionIndex::get_raise_trap_index().index() as usize] =
+            wasmer_vm_raise_trap as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_size_index().index() as usize] =
+            wasmer_vm_table_size as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_size_index().index() as usize] =
+            wasmer_vm_imported_table_size as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_grow_index().index() as usize] =
+            wasmer_vm_table_grow as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_grow_index().index() as usize] =
+            wasmer_vm_imported_table_grow as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_get_index().index() as usize] =
+            wasmer_vm_table_get as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_get_index().index() as usize] =
+            wasmer_vm_imported_table_get as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_set_index().index() as usize] =
+            wasmer_vm_table_set as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_table_set_index().index() as usize] =
+            wasmer_vm_imported_table_set as usize;
+        ptrs[VMBuiltinFunctionIndex::get_func_ref_index().index() as usize] =
+            wasmer_vm_func_ref as usize;
+        ptrs[VMBuiltinFunctionIndex::get_table_fill_index().index() as usize] =
+            wasmer_vm_table_fill as usize;
+
+        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait32_index().index() as usize] =
+            wasmer_vm_memory32_atomic_wait32 as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait32_index().index() as usize] =
+            wasmer_vm_imported_memory32_atomic_wait32 as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_wait64_index().index() as usize] =
+            wasmer_vm_memory32_atomic_wait64 as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_wait64_index().index() as usize] =
+            wasmer_vm_imported_memory32_atomic_wait64 as usize;
+        ptrs[VMBuiltinFunctionIndex::get_memory_atomic_notify_index().index() as usize] =
+            wasmer_vm_memory32_atomic_notify as usize;
+        ptrs[VMBuiltinFunctionIndex::get_imported_memory_atomic_notify_index().index() as usize] =
+            wasmer_vm_imported_memory32_atomic_notify as usize;
+
+        debug_assert!(ptrs.iter().cloned().all(|p| p != 0));
+
+        Self { ptrs }
+    }
+}
+
+/// The VM "context", which is pointed to by the `vmctx` arg in the compiler.
+/// This has information about globals, memories, tables, and other runtime
+/// state associated with the current instance.
+///
+/// The struct here is empty, as the sizes of these fields are dynamic, and
+/// we can't describe them in Rust's type system. Sufficient memory is
+/// allocated at runtime.
+///
+/// TODO: We could move the globals into the `vmctx` allocation too.
+#[derive(Debug)]
+#[repr(C, align(16))] // align 16 since globals are aligned to that and contained inside
+pub struct VMContext {}
+
+impl VMContext {
+    /// Return a mutable reference to the associated `Instance`.
+    ///
+    /// # Safety
+    /// This is unsafe because it doesn't work on just any `VMContext`, it must
+    /// be a `VMContext` allocated as part of an `Instance`.
+    #[allow(clippy::cast_ptr_alignment)]
+    #[inline]
+    pub(crate) unsafe fn instance(&self) -> &Instance {
+        &*((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *const Instance)
+    }
+
+    #[inline]
+    pub(crate) unsafe fn instance_mut(&mut self) -> &mut Instance {
+        &mut *((self as *const Self as *mut u8).offset(-Instance::vmctx_offset()) as *mut Instance)
+    }
+}
+
+///
+pub type VMTrampoline = unsafe extern "C" fn(
+    *mut VMContext,        // callee vmctx
+    *const VMFunctionBody, // function we're actually calling
+    *mut RawValue,         // space for arguments and return values
+);
+
+/// The fields compiled code needs to access to utilize a WebAssembly linear
+/// memory defined within the instance, namely the start address and the
+/// size in bytes.
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct VMMemoryDefinition {
+    /// The start address which is always valid, even if the memory grows.
+    pub base: *mut u8,
+
+    /// The current logical size of this linear memory in bytes.
+    pub current_length: usize,
+}
+
+/// # Safety
+/// This data is safe to share between threads because it's plain data that
+/// is the user's responsibility to synchronize.
+unsafe impl Send for VMMemoryDefinition {}
+/// # Safety
+/// This data is safe to share between threads because it's plain data that
+/// is the user's responsibility to synchronize. And it's `Copy` so there's
+/// really no difference between passing it by reference or by value as far as
+/// correctness in a multi-threaded context is concerned.
+unsafe impl Sync for VMMemoryDefinition {}
+
+#[cfg(test)]
+mod test_vmmemory_definition {
+    use super::VMMemoryDefinition;
+    use crate::VMOffsets;
+    use memoffset::offset_of;
+    use std::mem::size_of;
+    use wasmer_types::ModuleInfo;
+
+    #[test]
+    fn check_vmmemory_definition_offsets() {
+        let module = ModuleInfo::new();
+        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
+        assert_eq!(
+            size_of::<VMMemoryDefinition>(),
+            usize::from(offsets.size_of_vmmemory_definition())
+        );
+        assert_eq!(
+            offset_of!(VMMemoryDefinition, base),
+            usize::from(offsets.vmmemory_definition_base())
+        );
+        assert_eq!(
+            offset_of!(VMMemoryDefinition, current_length),
+            usize::from(offsets.vmmemory_definition_current_length())
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/Cargo.toml
new file mode 100644
index 0000000..e767d63
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/Cargo.toml
@@ -0,0 +1,46 @@
+[package]
+name = "wai-bindgen-wasmer"
+description = "Generate WAI glue for a Rust Wasmer host"
+version = "0.18.3"
+categories = ["wasm", "os"]
+keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow = "1.0"
+async-trait = { version = "0.1.50", optional = true }
+bitflags = "1.2"
+once_cell = "1.13"
+thiserror = "1.0"
+tracing-lib = { version = "0.1.26", optional = true, package = "tracing" }
+wai-bindgen-wasmer-impl = { version = "0.2.2" }
+wasmer = { version = "=4.2.8", path = "../api", default-features = false }
+
+[features]
+# Enables generated code to emit events via the `tracing` crate whenever wasm is
+# entered and when native functions are called. Note that tracing is currently
+# only done for imported functions.
+tracing = ["tracing-lib", "wai-bindgen-wasmer-impl/tracing"]
+
+# Enables async support for generated code, although when enabled this still
+# needs to be configured through the macro invocation.
+async = ["async-trait", "wai-bindgen-wasmer-impl/async"]
+
+# Wasmer features
+js = ["wasmer/js-default"]
+sys = ["wasmer/sys"]
+
+# Wasmer compiler (with `sys` feature only)
+cranelift = ["wasmer/cranelift"]
+singlepass = ["wasmer/singlepass"]
+llvm = ["wasmer/llvm"]
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/README.md b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/README.md
new file mode 100644
index 0000000..0566ee2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/README.md
@@ -0,0 +1,14 @@
+# wai-bindgen-wasmer
+
+Runtime utility crate for Wasmer host WAI bindings generated by wai-bindgen-gen-wasmer.
+
+This crate was moved from the https://github.com/wasmerio/wai repository.
+
+wai-bindgen-wasmer needs Wasmer as a dependency, which makes it extremely awkard to use if the
+crate is not in the same repo.
+This is necessary because wai is now used for wasix_http_client bindings, and will also be used
+for all WASI and WASIX syscalls in the future.
+
+The medium-term plan is to rewrite wai-bindgen-gen-wasmer to make this create redundant.
+
+See https://github.com/wasmerio/wai/issues/31 .
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/error.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/error.rs
new file mode 100644
index 0000000..5cfab66
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/error.rs
@@ -0,0 +1,40 @@
+use crate::Region;
+use thiserror::Error;
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum GuestError {
+    #[error("Invalid flag value {0}")]
+    InvalidFlagValue(&'static str),
+    #[error("Invalid enum value {0}")]
+    InvalidEnumValue(&'static str),
+    #[error("Pointer overflow")]
+    PtrOverflow,
+    #[error("Pointer out of bounds: {0:?}")]
+    PtrOutOfBounds(Region),
+    #[error("Pointer not aligned to {1}: {0:?}")]
+    PtrNotAligned(Region, u32),
+    #[error("Pointer already borrowed: {0:?}")]
+    PtrBorrowed(Region),
+    #[error("Borrow checker out of handles")]
+    BorrowCheckerOutOfHandles,
+    #[error("Slice length mismatch")]
+    SliceLengthsDiffer,
+    #[error("In func {funcname}:{location}:")]
+    InFunc {
+        funcname: &'static str,
+        location: &'static str,
+        #[source]
+        err: Box<GuestError>,
+    },
+    #[error("In data {typename}.{field}:")]
+    InDataField {
+        typename: String,
+        field: String,
+        #[source]
+        err: Box<GuestError>,
+    },
+    #[error("Invalid UTF-8 encountered: {0:?}")]
+    InvalidUtf8(#[from] ::std::str::Utf8Error),
+    #[error("Int conversion error: {0:?}")]
+    TryFromIntError(#[from] ::std::num::TryFromIntError),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/le.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/le.rs
new file mode 100644
index 0000000..f821a99
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/le.rs
@@ -0,0 +1,200 @@
+use crate::AllBytesValid;
+use std::cmp::Ordering;
+use std::fmt;
+use std::mem;
+use std::slice;
+
+/// Helper type representing a 1-byte-aligned little-endian value in memory.
+///
+/// This type is used in slice types for Wasmer host bindings. Guest types are
+/// not guaranteed to be either aligned or in the native endianness. This type
+/// wraps these types and provides explicit getters/setters to interact with the
+/// underlying value in a safe host-agnostic manner.
+#[repr(packed)]
+pub struct Le<T>(T);
+
+impl<T> Le<T>
+where
+    T: Endian,
+{
+    /// Creates a new `Le<T>` value where the internals are stored in a way
+    /// that's safe to copy into wasm linear memory.
+    pub fn new(t: T) -> Le<T> {
+        Le(t.into_le())
+    }
+
+    /// Reads the value stored in this `Le<T>`.
+    ///
+    /// This will perform a correct read even if the underlying memory is
+    /// unaligned, and it will also convert to the host's endianness for the
+    /// right representation of `T`.
+    pub fn get(&self) -> T {
+        self.0.from_le()
+    }
+
+    /// Writes the `val` to this slot.
+    ///
+    /// This will work correctly even if the underlying memory is unaligned and
+    /// it will also automatically convert the `val` provided to an endianness
+    /// appropriate for WebAssembly (little-endian).
+    pub fn set(&mut self, val: T) {
+        self.0 = val.into_le();
+    }
+
+    pub(crate) fn from_slice(bytes: &[u8]) -> &[Le<T>] {
+        // SAFETY: The invariants we uphold here are:
+        //
+        // * the lifetime of the input is the same as the output, so we're only
+        //   dealing with valid memory.
+        // * the alignment of the input is the same as the output (1)
+        // * the input isn't being truncated and we're consuming all of it (it
+        //   must be a multiple of the size of `Le<T>`)
+        // * all byte-patterns for `Le<T>` are valid. This is guaranteed by the
+        //   `AllBytesValid` supertrait of `Endian`.
+        unsafe {
+            assert_eq!(mem::align_of::<Le<T>>(), 1);
+            assert!(bytes.len() % mem::size_of::<Le<T>>() == 0);
+            fn all_bytes_valid<T: AllBytesValid>() {}
+            all_bytes_valid::<Le<T>>();
+
+            slice::from_raw_parts(
+                bytes.as_ptr().cast::<Le<T>>(),
+                bytes.len() / mem::size_of::<Le<T>>(),
+            )
+        }
+    }
+
+    pub(crate) fn from_slice_mut(bytes: &mut [u8]) -> &mut [Le<T>] {
+        // SAFETY: see `from_slice` above
+        //
+        // Note that both the input and the output are `mut`, helping to
+        // maintain the guarantee of uniqueness.
+        unsafe {
+            assert_eq!(mem::align_of::<Le<T>>(), 1);
+            assert!(bytes.len() % mem::size_of::<Le<T>>() == 0);
+            slice::from_raw_parts_mut(
+                bytes.as_mut_ptr().cast::<Le<T>>(),
+                bytes.len() / mem::size_of::<Le<T>>(),
+            )
+        }
+    }
+}
+
+impl<T: Copy> Clone for Le<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: Copy> Copy for Le<T> {}
+
+impl<T: Endian + PartialEq> PartialEq for Le<T> {
+    fn eq(&self, other: &Le<T>) -> bool {
+        self.get() == other.get()
+    }
+}
+
+impl<T: Endian + PartialEq> PartialEq<T> for Le<T> {
+    fn eq(&self, other: &T) -> bool {
+        self.get() == *other
+    }
+}
+
+impl<T: Endian + Eq> Eq for Le<T> {}
+
+impl<T: Endian + PartialOrd> PartialOrd for Le<T> {
+    fn partial_cmp(&self, other: &Le<T>) -> Option<Ordering> {
+        self.get().partial_cmp(&other.get())
+    }
+}
+
+impl<T: Endian + Ord> Ord for Le<T> {
+    fn cmp(&self, other: &Le<T>) -> Ordering {
+        self.get().cmp(&other.get())
+    }
+}
+
+impl<T: Endian + fmt::Debug> fmt::Debug for Le<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.get().fmt(f)
+    }
+}
+
+impl<T: Endian> From<T> for Le<T> {
+    fn from(t: T) -> Le<T> {
+        Le::new(t)
+    }
+}
+
+unsafe impl<T: AllBytesValid> AllBytesValid for Le<T> {}
+
+/// Trait used for the implementation of the `Le` type.
+pub trait Endian: AllBytesValid + Copy + Sized {
+    /// Converts this value and any aggregate fields (if any) into little-endian
+    /// byte order
+    fn into_le(self) -> Self;
+    /// Converts this value and any aggregate fields (if any) from
+    /// little-endian byte order
+    #[allow(clippy::wrong_self_convention)]
+    fn from_le(self) -> Self;
+}
+
+macro_rules! primitives {
+    ($($t:ident)*) => ($(
+        impl Endian for $t {
+            #[inline]
+            fn into_le(self) -> Self {
+                Self::from_ne_bytes(self.to_le_bytes())
+            }
+
+            #[inline]
+            fn from_le(self) -> Self {
+                Self::from_le_bytes(self.to_ne_bytes())
+            }
+        }
+    )*)
+}
+
+primitives! {
+    u8 i8
+    u16 i16
+    u32 i32
+    u64 i64
+    f32 f64
+}
+
+#[allow(clippy::unused_unit)]
+macro_rules! tuples {
+    ($(($($t:ident)*))*) => ($(
+        #[allow(non_snake_case)]
+        impl <$($t:Endian,)*> Endian for ($($t,)*) {
+            #[allow(clippy::unused_unit)]
+            fn into_le(self) -> Self {
+                let ($($t,)*) = self;
+                // Needed for single element "tuples".
+                ($($t.into_le(),)*)
+            }
+
+            #[allow(clippy::unused_unit)]
+            fn from_le(self) -> Self {
+                let ($($t,)*) = self;
+                // Needed for single element "tuples".
+                ($($t.from_le(),)*)
+            }
+        }
+    )*)
+}
+
+tuples! {
+    ()
+    (T1)
+    (T1 T2)
+    (T1 T2 T3)
+    (T1 T2 T3 T4)
+    (T1 T2 T3 T4 T5)
+    (T1 T2 T3 T4 T5 T6)
+    (T1 T2 T3 T4 T5 T6 T7)
+    (T1 T2 T3 T4 T5 T6 T7 T8)
+    (T1 T2 T3 T4 T5 T6 T7 T8 T9)
+    (T1 T2 T3 T4 T5 T6 T7 T8 T9 T10)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/lib.rs
new file mode 100644
index 0000000..aadf7ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/lib.rs
@@ -0,0 +1,238 @@
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub use wai_bindgen_wasmer_impl::{export, import};
+
+#[cfg(feature = "async")]
+pub use async_trait::async_trait;
+#[cfg(feature = "tracing-lib")]
+pub use tracing_lib as tracing;
+#[doc(hidden)]
+pub use {anyhow, bitflags, once_cell, wasmer};
+
+mod error;
+mod le;
+mod region;
+mod slab;
+mod table;
+
+pub use error::GuestError;
+pub use le::{Endian, Le};
+pub use region::{AllBytesValid, BorrowChecker, Region};
+pub use table::*;
+
+pub struct RawMemory {
+    pub slice: *mut [u8],
+}
+
+// This type is threadsafe despite its internal pointer because it allows no
+// safe access to the internal pointer. Consumers must uphold Send/Sync
+// guarantees themselves.
+unsafe impl Send for RawMemory {}
+unsafe impl Sync for RawMemory {}
+
+#[doc(hidden)]
+pub mod rt {
+    use crate::slab::Slab;
+    use crate::{Endian, Le};
+    use std::mem;
+    use wasmer::*;
+
+    pub trait RawMem {
+        fn store<T: Endian>(&mut self, offset: i32, val: T) -> Result<(), RuntimeError>;
+        fn store_many<T: Endian>(&mut self, offset: i32, vals: &[T]) -> Result<(), RuntimeError>;
+        fn load<T: Endian>(&self, offset: i32) -> Result<T, RuntimeError>;
+    }
+
+    impl RawMem for [u8] {
+        fn store<T: Endian>(&mut self, offset: i32, val: T) -> Result<(), RuntimeError> {
+            let mem = self
+                .get_mut(offset as usize..)
+                .and_then(|m| m.get_mut(..mem::size_of::<T>()))
+                .ok_or_else(|| RuntimeError::new("out of bounds write"))?;
+            Le::from_slice_mut(mem)[0].set(val);
+            Ok(())
+        }
+
+        fn store_many<T: Endian>(&mut self, offset: i32, val: &[T]) -> Result<(), RuntimeError> {
+            let mem = self
+                .get_mut(offset as usize..)
+                .and_then(|m| {
+                    let len = mem::size_of::<T>().checked_mul(val.len())?;
+                    m.get_mut(..len)
+                })
+                .ok_or_else(|| RuntimeError::new("out of bounds write"))?;
+            for (slot, val) in Le::from_slice_mut(mem).iter_mut().zip(val) {
+                slot.set(*val);
+            }
+            Ok(())
+        }
+
+        fn load<T: Endian>(&self, offset: i32) -> Result<T, RuntimeError> {
+            let mem = self
+                .get(offset as usize..)
+                .and_then(|m| m.get(..mem::size_of::<Le<T>>()))
+                .ok_or_else(|| RuntimeError::new("out of bounds read"))?;
+            Ok(Le::from_slice(mem)[0].get())
+        }
+    }
+
+    pub fn char_from_i32(val: i32) -> Result<char, RuntimeError> {
+        core::char::from_u32(val as u32)
+            .ok_or_else(|| RuntimeError::new("char value out of valid range"))
+    }
+
+    pub fn invalid_variant(name: &str) -> RuntimeError {
+        let msg = format!("invalid discriminant for `{}`", name);
+        RuntimeError::new(msg)
+    }
+
+    pub fn validate_flags<T, U>(
+        bits: T,
+        all: T,
+        name: &str,
+        mk: impl FnOnce(T) -> U,
+    ) -> Result<U, RuntimeError>
+    where
+        T: std::ops::Not<Output = T> + std::ops::BitAnd<Output = T> + From<u8> + PartialEq + Copy,
+    {
+        if bits & !all != 0u8.into() {
+            let msg = format!("invalid flags specified for `{}`", name);
+            Err(RuntimeError::new(msg))
+        } else {
+            Ok(mk(bits))
+        }
+    }
+
+    pub fn bad_int(_: std::num::TryFromIntError) -> RuntimeError {
+        let msg = "out-of-bounds integer conversion";
+        RuntimeError::new(msg)
+    }
+
+    pub fn copy_slice<T: Endian>(
+        store: &mut wasmer::Store,
+        memory: &Memory,
+        free: &TypedFunction<(i32, i32, i32), ()>,
+        base: i32,
+        len: i32,
+        align: i32,
+    ) -> Result<Vec<T>, RuntimeError> {
+        let size = (len as u32)
+            .checked_mul(mem::size_of::<T>() as u32)
+            .ok_or_else(|| RuntimeError::new("array too large to fit in wasm memory"))?;
+        let memory_view = memory.view(store);
+        let slice = unsafe {
+            memory_view
+                .data_unchecked()
+                .get(base as usize..)
+                .and_then(|s| s.get(..size as usize))
+                .ok_or_else(|| RuntimeError::new("out of bounds read"))?
+        };
+        let result = Le::from_slice(slice).iter().map(|s| s.get()).collect();
+        free.call(store, base, size as i32, align)?;
+        Ok(result)
+    }
+
+    macro_rules! as_traits {
+        ($(($name:ident $tr:ident $ty:ident ($($tys:ident)*)))*) => ($(
+            pub fn $name<T: $tr>(t: T) -> $ty {
+                t.$name()
+            }
+
+            pub trait $tr {
+                #[allow(clippy::wrong_self_convention)]
+                fn $name(self) -> $ty;
+            }
+
+            impl<'a, T: Copy + $tr> $tr for &'a T {
+                fn $name(self) -> $ty {
+                    (*self).$name()
+                }
+            }
+
+            $(
+                impl $tr for $tys {
+                    #[inline]
+                    fn $name(self) -> $ty {
+                        self as $ty
+                    }
+                }
+            )*
+        )*)
+    }
+
+    as_traits! {
+        (as_i32 AsI32 i32 (char i8 u8 i16 u16 i32 u32))
+        (as_i64 AsI64 i64 (i64 u64))
+        (as_f32 AsF32 f32 (f32))
+        (as_f64 AsF64 f64 (f64))
+    }
+
+    #[derive(Default, Debug)]
+    pub struct IndexSlab {
+        slab: Slab<ResourceIndex>,
+    }
+
+    impl IndexSlab {
+        pub fn insert(&mut self, resource: ResourceIndex) -> u32 {
+            self.slab.insert(resource)
+        }
+
+        pub fn get(&self, slab_idx: u32) -> Result<ResourceIndex, RuntimeError> {
+            match self.slab.get(slab_idx) {
+                Some(idx) => Ok(*idx),
+                None => Err(RuntimeError::new("invalid index specified for handle")),
+            }
+        }
+
+        pub fn remove(&mut self, slab_idx: u32) -> Result<ResourceIndex, RuntimeError> {
+            match self.slab.remove(slab_idx) {
+                Some(idx) => Ok(idx),
+                None => Err(RuntimeError::new("invalid index specified for handle")),
+            }
+        }
+    }
+
+    #[derive(Default, Debug)]
+    pub struct ResourceSlab {
+        slab: Slab<Resource>,
+    }
+
+    #[derive(Debug)]
+    struct Resource {
+        wasm: i32,
+        refcnt: u32,
+    }
+
+    #[derive(Debug, Copy, Clone)]
+    pub struct ResourceIndex(u32);
+
+    impl ResourceSlab {
+        pub fn insert(&mut self, wasm: i32) -> ResourceIndex {
+            ResourceIndex(self.slab.insert(Resource { wasm, refcnt: 1 }))
+        }
+
+        pub fn get(&self, idx: ResourceIndex) -> i32 {
+            self.slab.get(idx.0).unwrap().wasm
+        }
+
+        pub fn clone(&mut self, idx: ResourceIndex) -> Result<(), RuntimeError> {
+            let resource = self.slab.get_mut(idx.0).unwrap();
+            resource.refcnt = match resource.refcnt.checked_add(1) {
+                Some(cnt) => cnt,
+                None => return Err(RuntimeError::new("resource index count overflow")),
+            };
+            Ok(())
+        }
+
+        pub fn drop(&mut self, idx: ResourceIndex) -> Option<i32> {
+            let resource = self.slab.get_mut(idx.0).unwrap();
+            assert!(resource.refcnt > 0);
+            resource.refcnt -= 1;
+            if resource.refcnt != 0 {
+                return None;
+            }
+            let resource = self.slab.remove(idx.0).unwrap();
+            Some(resource.wasm)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/region.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/region.rs
new file mode 100644
index 0000000..3eee750
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/region.rs
@@ -0,0 +1,325 @@
+use crate::rt::RawMem;
+use crate::{Endian, GuestError, Le};
+use std::collections::HashSet;
+use std::convert::TryInto;
+use std::marker;
+use std::mem;
+use wasmer::RuntimeError;
+
+// This is a pretty naive way to account for borrows. This datastructure
+// could be made a lot more efficient with some effort.
+pub struct BorrowChecker<'a> {
+    /// Maps from handle to region borrowed. A HashMap is probably not ideal
+    /// for this but it works. It would be more efficient if we could
+    /// check `is_borrowed` without an O(n) iteration, by organizing borrows
+    /// by an ordering of Region.
+    shared_borrows: HashSet<Region>,
+    mut_borrows: HashSet<Region>,
+    _marker: marker::PhantomData<&'a mut [u8]>,
+    ptr: *mut u8,
+    len: usize,
+}
+
+// These are not automatically implemented with our storage of `*mut u8`, so we
+// need to manually declare that this type is threadsafe.
+unsafe impl Send for BorrowChecker<'_> {}
+unsafe impl Sync for BorrowChecker<'_> {}
+
+fn to_error(err: impl std::fmt::Display) -> RuntimeError {
+    RuntimeError::new(err.to_string())
+}
+
+impl<'a> BorrowChecker<'a> {
+    pub fn new(data: &'a mut [u8]) -> BorrowChecker<'a> {
+        BorrowChecker {
+            ptr: data.as_mut_ptr(),
+            len: data.len(),
+            shared_borrows: Default::default(),
+            mut_borrows: Default::default(),
+            _marker: marker::PhantomData,
+        }
+    }
+
+    pub fn slice<T: AllBytesValid>(&mut self, ptr: i32, len: i32) -> Result<&'a [T], RuntimeError> {
+        let (ret, r) = self.get_slice(ptr, len)?;
+        // SAFETY: We're promoting the valid lifetime of `ret` from a temporary
+        // borrow on `self` to `'a` on this `BorrowChecker`. At the same time
+        // we're recording that this is a persistent shared borrow (until this
+        // borrow checker is deleted), which disallows future mutable borrows
+        // of the same data.
+        let ret = unsafe { &*(ret as *const [T]) };
+        self.shared_borrows.insert(r);
+        Ok(ret)
+    }
+
+    pub fn slice_mut<T: AllBytesValid>(
+        &mut self,
+        ptr: i32,
+        len: i32,
+    ) -> Result<&'a mut [T], RuntimeError> {
+        let (ret, r) = self.get_slice_mut(ptr, len)?;
+        // SAFETY: see `slice` for how we're extending the lifetime by
+        // recording the borrow here. Note that the `mut_borrows` list is
+        // checked on both shared and mutable borrows in the future since a
+        // mutable borrow can't alias with anything.
+        let ret = unsafe { &mut *(ret as *mut [T]) };
+        self.mut_borrows.insert(r);
+        Ok(ret)
+    }
+
+    fn get_slice<T: AllBytesValid>(
+        &self,
+        ptr: i32,
+        len: i32,
+    ) -> Result<(&[T], Region), RuntimeError> {
+        let r = self.region::<T>(ptr, len)?;
+        if self.is_mut_borrowed(r) {
+            Err(to_error(GuestError::PtrBorrowed(r)))
+        } else {
+            Ok((
+                // SAFETY: invariants to uphold:
+                //
+                // * The lifetime of the input is valid for the lifetime of the
+                //   output. In this case we're threading through the lifetime
+                //   of `&self` to the output.
+                // * The actual output is valid, which is guaranteed with the
+                //   `AllBytesValid` bound.
+                // * We uphold Rust's borrowing guarantees, namely that this
+                //   borrow we're returning isn't overlapping with any mutable
+                //   borrows.
+                // * The region `r` we're returning accurately describes the
+                //   slice we're returning in wasm linear memory.
+                unsafe {
+                    std::slice::from_raw_parts(
+                        self.ptr.add(r.start as usize) as *const T,
+                        len as usize,
+                    )
+                },
+                r,
+            ))
+        }
+    }
+
+    fn get_slice_mut<T>(&mut self, ptr: i32, len: i32) -> Result<(&mut [T], Region), RuntimeError> {
+        let r = self.region::<T>(ptr, len)?;
+        if self.is_mut_borrowed(r) || self.is_shared_borrowed(r) {
+            Err(to_error(GuestError::PtrBorrowed(r)))
+        } else {
+            Ok((
+                // SAFETY: same as `get_slice`, except for that we're threading
+                // through `&mut` properties as well.
+                unsafe {
+                    std::slice::from_raw_parts_mut(
+                        self.ptr.add(r.start as usize) as *mut T,
+                        len as usize,
+                    )
+                },
+                r,
+            ))
+        }
+    }
+
+    fn region<T>(&self, ptr: i32, len: i32) -> Result<Region, RuntimeError> {
+        assert_eq!(std::mem::align_of::<T>(), 1);
+        let r = Region {
+            start: ptr as u32,
+            len: (len as u32)
+                .checked_mul(mem::size_of::<T>() as u32)
+                .ok_or_else(|| to_error(GuestError::PtrOverflow))?,
+        };
+        self.validate_contains(&r)?;
+        Ok(r)
+    }
+
+    pub fn slice_str(&mut self, ptr: i32, len: i32) -> Result<&'a str, RuntimeError> {
+        let bytes = self.slice(ptr, len)?;
+        std::str::from_utf8(bytes).map_err(to_error)
+    }
+
+    fn validate_contains(&self, region: &Region) -> Result<(), RuntimeError> {
+        let end = region
+            .start
+            .checked_add(region.len)
+            .ok_or_else(|| to_error(GuestError::PtrOverflow))? as usize;
+        if end <= self.len {
+            Ok(())
+        } else {
+            Err(to_error(GuestError::PtrOutOfBounds(*region)))
+        }
+    }
+
+    fn is_shared_borrowed(&self, r: Region) -> bool {
+        self.shared_borrows.iter().any(|b| b.overlaps(r))
+    }
+
+    fn is_mut_borrowed(&self, r: Region) -> bool {
+        self.mut_borrows.iter().any(|b| b.overlaps(r))
+    }
+
+    pub fn raw(&self) -> *mut [u8] {
+        std::ptr::slice_from_raw_parts_mut(self.ptr, self.len)
+    }
+}
+
+impl RawMem for BorrowChecker<'_> {
+    fn store<T: Endian>(&mut self, offset: i32, val: T) -> Result<(), RuntimeError> {
+        let (slice, _) = self.get_slice_mut::<Le<T>>(offset, 1)?;
+        slice[0].set(val);
+        Ok(())
+    }
+
+    fn store_many<T: Endian>(&mut self, offset: i32, val: &[T]) -> Result<(), RuntimeError> {
+        let (slice, _) = self.get_slice_mut::<Le<T>>(
+            offset,
+            val.len()
+                .try_into()
+                .map_err(|_| to_error(GuestError::PtrOverflow))?,
+        )?;
+        for (slot, val) in slice.iter_mut().zip(val) {
+            slot.set(*val);
+        }
+        Ok(())
+    }
+
+    fn load<T: Endian>(&self, offset: i32) -> Result<T, RuntimeError> {
+        let (slice, _) = self.get_slice::<Le<T>>(offset, 1)?;
+        Ok(slice[0].get())
+    }
+}
+
+/// Unsafe trait representing types where every byte pattern is valid for their
+/// representation.
+///
+/// This is the set of types which wasmer can have a raw pointer to for
+/// values which reside in wasm linear memory.
+///
+/// # Safety
+///
+/// TODO: add safety docs.
+///
+pub unsafe trait AllBytesValid {}
+
+unsafe impl AllBytesValid for u8 {}
+unsafe impl AllBytesValid for u16 {}
+unsafe impl AllBytesValid for u32 {}
+unsafe impl AllBytesValid for u64 {}
+unsafe impl AllBytesValid for i8 {}
+unsafe impl AllBytesValid for i16 {}
+unsafe impl AllBytesValid for i32 {}
+unsafe impl AllBytesValid for i64 {}
+unsafe impl AllBytesValid for f32 {}
+unsafe impl AllBytesValid for f64 {}
+
+macro_rules! tuples {
+    ($(($($t:ident)*))*) => ($(
+        unsafe impl <$($t:AllBytesValid,)*> AllBytesValid for ($($t,)*) {}
+    )*)
+}
+
+tuples! {
+    ()
+    (T1)
+    (T1 T2)
+    (T1 T2 T3)
+    (T1 T2 T3 T4)
+    (T1 T2 T3 T4 T5)
+    (T1 T2 T3 T4 T5 T6)
+    (T1 T2 T3 T4 T5 T6 T7)
+    (T1 T2 T3 T4 T5 T6 T7 T8)
+    (T1 T2 T3 T4 T5 T6 T7 T8 T9)
+    (T1 T2 T3 T4 T5 T6 T7 T8 T9 T10)
+}
+
+/// Represents a contiguous region in memory.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct Region {
+    pub start: u32,
+    pub len: u32,
+}
+
+impl Region {
+    /// Checks if this `Region` overlaps with `rhs` `Region`.
+    fn overlaps(&self, rhs: Region) -> bool {
+        // Zero-length regions can never overlap!
+        if self.len == 0 || rhs.len == 0 {
+            return false;
+        }
+
+        let self_start = self.start as u64;
+        let self_end = self_start + (self.len - 1) as u64;
+
+        let rhs_start = rhs.start as u64;
+        let rhs_end = rhs_start + (rhs.len - 1) as u64;
+
+        if self_start <= rhs_start {
+            self_end >= rhs_start
+        } else {
+            rhs_end >= self_start
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn nonoverlapping() {
+        let mut bytes = [0; 100];
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(0, 10).unwrap();
+        bc.slice::<u8>(10, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(10, 10).unwrap();
+        bc.slice::<u8>(0, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice_mut::<u8>(0, 10).unwrap();
+        bc.slice_mut::<u8>(10, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice_mut::<u8>(10, 10).unwrap();
+        bc.slice_mut::<u8>(0, 10).unwrap();
+    }
+
+    #[test]
+    fn overlapping() {
+        let mut bytes = [0; 100];
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(0, 10).unwrap();
+        bc.slice_mut::<u8>(9, 10).unwrap_err();
+        bc.slice::<u8>(9, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(0, 10).unwrap();
+        bc.slice_mut::<u8>(2, 5).unwrap_err();
+        bc.slice::<u8>(2, 5).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(9, 10).unwrap();
+        bc.slice_mut::<u8>(0, 10).unwrap_err();
+        bc.slice::<u8>(0, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(2, 5).unwrap();
+        bc.slice_mut::<u8>(0, 10).unwrap_err();
+        bc.slice::<u8>(0, 10).unwrap();
+
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice::<u8>(2, 5).unwrap();
+        bc.slice::<u8>(10, 5).unwrap();
+        bc.slice::<u8>(15, 5).unwrap();
+        bc.slice_mut::<u8>(0, 10).unwrap_err();
+        bc.slice::<u8>(0, 10).unwrap();
+    }
+
+    #[test]
+    fn zero_length() {
+        let mut bytes = [0; 100];
+        let mut bc = BorrowChecker::new(&mut bytes);
+        bc.slice_mut::<u8>(0, 0).unwrap();
+        bc.slice_mut::<u8>(0, 0).unwrap();
+        bc.slice::<u8>(0, 1).unwrap();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/slab.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/slab.rs
new file mode 100644
index 0000000..8a9eb2a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/slab.rs
@@ -0,0 +1,72 @@
+use std::fmt;
+use std::mem;
+
+pub struct Slab<T> {
+    storage: Vec<Entry<T>>,
+    next: usize,
+}
+
+enum Entry<T> {
+    Full(T),
+    Empty { next: usize },
+}
+
+impl<T> Slab<T> {
+    pub fn insert(&mut self, item: T) -> u32 {
+        if self.next == self.storage.len() {
+            self.storage.push(Entry::Empty {
+                next: self.next + 1,
+            });
+        }
+        let ret = self.next as u32;
+        let entry = Entry::Full(item);
+        self.next = match mem::replace(&mut self.storage[self.next], entry) {
+            Entry::Empty { next } => next,
+            _ => unreachable!(),
+        };
+        ret
+    }
+
+    pub fn get(&self, idx: u32) -> Option<&T> {
+        match self.storage.get(idx as usize)? {
+            Entry::Full(b) => Some(b),
+            Entry::Empty { .. } => None,
+        }
+    }
+
+    pub fn get_mut(&mut self, idx: u32) -> Option<&mut T> {
+        match self.storage.get_mut(idx as usize)? {
+            Entry::Full(b) => Some(b),
+            Entry::Empty { .. } => None,
+        }
+    }
+
+    pub fn remove(&mut self, idx: u32) -> Option<T> {
+        let slot = self.storage.get_mut(idx as usize)?;
+        match mem::replace(slot, Entry::Empty { next: self.next }) {
+            Entry::Full(b) => {
+                self.next = idx as usize;
+                Some(b)
+            }
+            Entry::Empty { next } => {
+                *slot = Entry::Empty { next };
+                None
+            }
+        }
+    }
+}
+
+impl<T> Default for Slab<T> {
+    fn default() -> Slab<T> {
+        Slab {
+            storage: Vec::new(),
+            next: 0,
+        }
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Slab<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Slab").finish()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/table.rs b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/table.rs
new file mode 100644
index 0000000..34e301e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wai-bindgen-wasmer/src/table.rs
@@ -0,0 +1,144 @@
+use std::convert::TryFrom;
+use std::fmt;
+use std::mem;
+
+pub struct Table<T> {
+    elems: Vec<Slot<T>>,
+    next: usize,
+}
+
+#[derive(Debug)]
+pub enum RemoveError {
+    NotAllocated,
+}
+
+enum Slot<T> {
+    Empty { next_empty: usize },
+    Full { item: Box<T> },
+}
+
+impl<T> Table<T> {
+    /// Creates a new empty table
+    pub fn new() -> Table<T> {
+        Table {
+            elems: Vec::new(),
+            next: 0,
+        }
+    }
+
+    /// Inserts an item into this table, returning the index that it was
+    /// inserted at.
+    pub fn insert(&mut self, item: T) -> u32 {
+        if self.next == self.elems.len() {
+            let next_empty = self.next + 1;
+            self.elems.push(Slot::Empty { next_empty });
+        }
+        let index = self.next;
+        let ret = u32::try_from(index).unwrap();
+        self.next = match &self.elems[index] {
+            Slot::Empty { next_empty } => *next_empty,
+            Slot::Full { .. } => unreachable!(),
+        };
+        self.elems[index] = Slot::Full {
+            item: Box::new(item),
+        };
+        ret
+    }
+
+    /// Borrows an item from this table.
+    ///
+    /// Returns `None` if the index is not allocated at this time. Otherwise
+    /// returns `Some` with a borrow of the item from this table.
+    pub fn get(&self, item: u32) -> Option<&T> {
+        let index = usize::try_from(item).unwrap();
+        match self.elems.get(index)? {
+            Slot::Empty { .. } => None,
+            Slot::Full { item } => Some(item),
+        }
+    }
+
+    /// Removes an item from this table.
+    ///
+    /// On success it returns back the original item.
+    pub fn remove(&mut self, item: u32) -> Result<T, RemoveError> {
+        let index = usize::try_from(item).unwrap();
+        let new_empty = Slot::Empty {
+            next_empty: self.next,
+        };
+        let slot = self.elems.get_mut(index).ok_or(RemoveError::NotAllocated)?;
+
+        // Assume that `item` is valid, and if it is, we can return quickly
+        match mem::replace(slot, new_empty) {
+            Slot::Full { item } => {
+                self.next = index;
+                Ok(*item)
+            }
+
+            // Oops `item` wasn't valid, put it back where we found it and then
+            // figure out why it was invalid
+            Slot::Empty { next_empty } => {
+                *slot = Slot::Empty { next_empty };
+                Err(RemoveError::NotAllocated)
+            }
+        }
+    }
+}
+
+impl<T> Default for Table<T> {
+    fn default() -> Table<T> {
+        Table::new()
+    }
+}
+
+impl<T> fmt::Debug for Table<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Table")
+            .field("capacity", &self.elems.capacity())
+            .finish()
+    }
+}
+
+impl fmt::Display for RemoveError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RemoveError::NotAllocated => f.write_str("invalid handle index"),
+        }
+    }
+}
+
+impl std::error::Error for RemoveError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn simple() {
+        let mut table = Table::new();
+        assert_eq!(table.insert(0), 0);
+        assert_eq!(table.insert(100), 1);
+        assert_eq!(table.insert(200), 2);
+
+        assert_eq!(*table.get(0).unwrap(), 0);
+        assert_eq!(*table.get(1).unwrap(), 100);
+        assert_eq!(*table.get(2).unwrap(), 200);
+        assert!(table.get(100).is_none());
+
+        assert!(table.remove(0).is_ok());
+        assert!(table.get(0).is_none());
+        assert_eq!(table.insert(1), 0);
+        assert!(table.get(0).is_some());
+
+        table.get(1).unwrap();
+        assert!(table.remove(1).is_ok());
+        assert!(table.remove(1).is_err());
+
+        assert!(table.remove(2).is_ok());
+        assert!(table.remove(0).is_ok());
+
+        assert_eq!(table.insert(100), 0);
+        assert_eq!(table.insert(100), 2);
+        assert_eq!(table.insert(100), 1);
+        assert_eq!(table.insert(100), 3);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/.gitignore b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/.gitignore
new file mode 100644
index 0000000..6c8fbf3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/.gitignore
@@ -0,0 +1 @@
+wit-bindgen/
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/Cargo.toml
new file mode 100644
index 0000000..9fddf0e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/Cargo.toml
@@ -0,0 +1,43 @@
+[package]
+name = "wasmer-wasix-types"
+version = "0.18.3"
+description = "WASI and WASIX types for Wasmer WebAssembly runtime"
+categories = ["wasm", "os"]
+keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+wasmer = { default-features = false, path = "../api", version = "=4.2.8" }
+wasmer-types = { path = "../types", version = "=4.2.8" }
+wasmer-derive = { path = "../derive", version = "=4.2.8" }
+wai-bindgen-gen-rust = "0.2.1"
+wai-bindgen-rust = { version = "0.2.1", default-features = false, features = ["macros"] }
+wai-bindgen-gen-rust-wasm = "0.2.1"
+wai-bindgen-gen-core = "0.2.1"
+wai-parser = "0.2.1"
+serde = { version = "1.0", features = ["derive"], optional = true }
+num_enum = "0.5.7"
+bitflags = "1.3.0"
+cfg-if = "1.0.0"
+anyhow = "1.0.66"
+byteorder = "1.3"
+time = { version = "0.3", features = ["formatting"] }
+tracing = { version = "0.1.37" }
+
+[dev-dependencies.pretty_assertions]
+version = "1.3.0"
+
+[features]
+enable-serde = ["serde", "wasmer-types/serde"]
+
+[package.metadata.docs.rs]
+features = ["wasmer/sys"]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/README.md b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/README.md
new file mode 100644
index 0000000..9b14dee
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/README.md
@@ -0,0 +1,3 @@
+# wasmer-wasix-types
+
+This crate contains WASI(X) type definitions used by `wasmer-wasix`.
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/asyncify.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/asyncify.rs
new file mode 100644
index 0000000..4a3669e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/asyncify.rs
@@ -0,0 +1,11 @@
+use wasmer_derive::ValueType;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+#[repr(C)]
+pub struct __wasi_asyncify_t<O>
+where
+    O: wasmer_types::ValueType,
+{
+    pub start: O,
+    pub end: O,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/lib.rs
new file mode 100644
index 0000000..f1c745d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/lib.rs
@@ -0,0 +1,8 @@
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub mod asyncify;
+pub mod types;
+pub mod wasi;
+pub mod wasix;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/types.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/types.rs
new file mode 100644
index 0000000..ccfadd4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/types.rs
@@ -0,0 +1,296 @@
+#![deny(unused_mut)]
+#![allow(non_camel_case_types, clippy::identity_op)]
+
+//! Wasmer's WASI types implementation.
+//!
+//! Those types aim at being used by [the `wasmer-wasi`
+//! crate](https://github.com/wasmerio/wasmer/blob/master/lib/wasi).
+
+// Needed for #[derive(ValueType)]
+extern crate wasmer_types as wasmer;
+
+pub use crate::types::time::*;
+pub use directory::*;
+pub use file::*;
+pub use io::*;
+pub use net::*;
+pub use signal::*;
+pub use subscription::*;
+
+pub mod file {
+    use crate::wasi::{Fd, Rights};
+
+    pub use crate::wasi::{EventFdFlags, FileDelta, LookupFlags, Oflags};
+
+    pub const __WASI_STDIN_FILENO: Fd = 0;
+    pub const __WASI_STDOUT_FILENO: Fd = 1;
+    pub const __WASI_STDERR_FILENO: Fd = 2;
+
+    pub const EVENT_FD_FLAGS_SEMAPHORE: EventFdFlags = 1;
+
+    pub const __WASI_LOOKUP_SYMLINK_FOLLOW: LookupFlags = 1;
+
+    /// function for debugging rights issues
+    #[allow(dead_code)]
+    pub fn print_right_set(rights: Rights) {
+        // BTreeSet for consistent order
+        let mut right_set = std::collections::BTreeSet::new();
+        for i in 0..28 {
+            let cur_right = rights & Rights::from_bits(1 << i).unwrap();
+            if !cur_right.is_empty() {
+                right_set.insert(cur_right.to_str().unwrap_or("INVALID RIGHT"));
+            }
+        }
+        println!("{:#?}", right_set);
+    }
+}
+
+pub mod directory {
+    use crate::wasi;
+    use std::mem;
+
+    pub const __WASI_DIRCOOKIE_START: wasi::Dircookie = 0;
+
+    pub fn dirent_to_le_bytes(ent: &wasi::Dirent) -> Vec<u8> {
+        let out: Vec<u8> = std::iter::empty()
+            .chain(ent.d_next.to_le_bytes())
+            .chain(ent.d_ino.to_le_bytes())
+            .chain(ent.d_namlen.to_le_bytes())
+            .chain(u32::from(ent.d_type as u8).to_le_bytes())
+            .collect();
+
+        assert_eq!(out.len(), mem::size_of::<wasi::Dirent>());
+        out
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::dirent_to_le_bytes;
+        use crate::wasi;
+
+        #[test]
+        fn test_dirent_to_le_bytes() {
+            let s = wasi::Dirent {
+                d_next: 0x0123456789abcdef,
+                d_ino: 0xfedcba9876543210,
+                d_namlen: 0xaabbccdd,
+                d_type: wasi::Filetype::Directory,
+            };
+
+            assert_eq!(
+                vec![
+                    // d_next
+                    0xef,
+                    0xcd,
+                    0xab,
+                    0x89,
+                    0x67,
+                    0x45,
+                    0x23,
+                    0x01,
+                    //
+                    // d_ino
+                    0x10,
+                    0x32,
+                    0x54,
+                    0x76,
+                    0x98,
+                    0xba,
+                    0xdc,
+                    0xfe,
+                    //
+                    // d_namelen
+                    0xdd,
+                    0xcc,
+                    0xbb,
+                    0xaa,
+                    //
+                    // d_type
+                    // plus padding
+                    wasi::Filetype::Directory as u8,
+                    0x00,
+                    0x00,
+                    0x00,
+                ],
+                dirent_to_le_bytes(&s)
+            );
+        }
+    }
+}
+
+pub mod io {
+    use wasmer_derive::ValueType;
+    use wasmer_types::MemorySize;
+
+    pub use crate::wasi::Bool;
+    pub use crate::wasi::Count;
+    pub use crate::wasi::OptionTag;
+    pub use crate::wasi::StdioMode;
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_ciovec_t<M: MemorySize> {
+        pub buf: M::Offset,
+        pub buf_len: M::Offset,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_iovec_t<M: MemorySize> {
+        pub buf: M::Offset,
+        pub buf_len: M::Offset,
+    }
+}
+
+pub mod time {
+    pub use crate::wasi::OptionTimestamp;
+}
+
+pub mod net {
+    use crate::wasi::Addressfamily;
+    use wasmer_derive::ValueType;
+
+    use crate::wasi::OptionTimestamp;
+
+    pub use crate::wasi::{
+        AddrUnspec, AddrUnspecPort, CidrUnspec, HttpHandles, HttpStatus, RiFlags, RoFlags, SdFlags,
+        SiFlags, SockProto, Timeout,
+    };
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_hardwareaddress_t {
+        pub octs: [u8; 6],
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_ip4_t {
+        pub octs: [u8; 4],
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_ip4_port_t {
+        pub port: u16,
+        pub ip: __wasi_addr_ip4_t,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_cidr_ip4_t {
+        pub ip: __wasi_addr_ip4_t,
+        pub prefix: u8,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_unix_t {
+        pub octs: [u8; 16],
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_unix_port_t {
+        pub port: u16,
+        pub unix: __wasi_addr_unix_t,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_cidr_unix_t {
+        pub unix: __wasi_addr_unix_t,
+        pub prefix: u8,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_ip6_t {
+        pub segs: [u8; 16],
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_ip6_port_t {
+        pub port: u16,
+        pub ip: __wasi_addr_ip6_t,
+    }
+
+    #[derive(Debug, Copy, Clone, PartialEq, Eq, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_cidr_ip6_t {
+        pub ip: __wasi_addr_ip6_t,
+        pub prefix: u8,
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_u {
+        pub octs: [u8; 16],
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_t {
+        pub tag: Addressfamily,
+        // C will add a padding byte here which must be set to zero otherwise the tag will corrupt
+        pub _padding: u8,
+        pub u: __wasi_addr_u,
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_port_u {
+        pub octs: [u8; 18],
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_addr_port_t {
+        pub tag: Addressfamily,
+        // C will add a padding byte here which must be set to zero otherwise the tag will corrupt
+        pub _padding: u8,
+        pub u: __wasi_addr_port_u,
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_cidr_u {
+        pub octs: [u8; 17],
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct __wasi_cidr_t {
+        pub tag: Addressfamily,
+        // C will add a padding byte here which must be set to zero otherwise the tag will corrupt
+        pub _padding: u8,
+        pub u: __wasi_cidr_u,
+    }
+
+    #[derive(Debug, Copy, Clone, ValueType)]
+    #[repr(C)]
+    pub struct Route {
+        pub cidr: __wasi_cidr_t,
+        pub via_router: __wasi_addr_t,
+        pub preferred_until: OptionTimestamp,
+        pub expires_at: OptionTimestamp,
+    }
+
+    pub const __WASI_SOCK_RECV_INPUT_PEEK: RiFlags = 1 << 0;
+    pub const __WASI_SOCK_RECV_INPUT_WAITALL: RiFlags = 1 << 1;
+    pub const __WASI_SOCK_RECV_INPUT_DATA_TRUNCATED: RiFlags = 1 << 2;
+
+    pub const __WASI_SOCK_RECV_OUTPUT_DATA_TRUNCATED: RoFlags = 1 << 0;
+
+    pub const __WASI_SHUT_RD: SdFlags = 1 << 0;
+    pub const __WASI_SHUT_WR: SdFlags = 1 << 1;
+}
+
+pub mod signal {
+    pub use crate::wasi::Signal;
+}
+
+pub mod subscription {
+    pub use crate::wasi::{Eventtype, SubscriptionFsReadwrite};
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings.rs
new file mode 100644
index 0000000..8b07961
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings.rs
@@ -0,0 +1,3719 @@
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::mem::MaybeUninit;
+use wasmer::{MemorySize, ValueType};
+// TODO: Remove once bindings generate wai_bindgen_rust::bitflags::bitflags!  (temp hack)
+use wai_bindgen_rust as wit_bindgen_rust;
+
+use super::ExitCode;
+
+#[doc = " Type names used by low-level WASI interfaces."]
+#[doc = " An array size."]
+#[doc = " "]
+#[doc = " Note: This is similar to `size_t` in POSIX."]
+pub type Size = u32;
+#[doc = " Non-negative file size or length of a region within a file."]
+pub type Filesize = u64;
+#[doc = " Timestamp in nanoseconds."]
+pub type Timestamp = u64;
+#[doc = " A file descriptor handle."]
+pub type Fd = u32;
+#[doc = " A reference to the offset of a directory entry."]
+pub type Dircookie = u64;
+#[doc = " The type for the `dirent::d-namlen` field of `dirent` struct."]
+pub type Dirnamlen = u32;
+#[doc = " File serial number that is unique within its file system."]
+pub type Inode = u64;
+#[doc = " Identifier for a device containing a file system. Can be used in combination"]
+#[doc = " with `inode` to uniquely identify a file or directory in the filesystem."]
+pub type Device = u64;
+pub type Linkcount = u64;
+pub type Snapshot0Linkcount = u32;
+pub type Tid = u32;
+pub type Pid = u32;
+#[doc = " Identifiers for clocks, snapshot0 version."]
+#[repr(u32)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Snapshot0Clockid {
+    #[doc = " The clock measuring real time. Time value zero corresponds with"]
+    #[doc = " 1970-01-01T00:00:00Z."]
+    Realtime,
+    #[doc = " The store-wide monotonic clock, which is defined as a clock measuring"]
+    #[doc = " real time, whose value cannot be adjusted and which cannot have negative"]
+    #[doc = " clock jumps. The epoch of this clock is undefined. The absolute time"]
+    #[doc = " value of this clock therefore has no meaning."]
+    Monotonic,
+    #[doc = " The CPU-time clock associated with the current process."]
+    ProcessCputimeId,
+    #[doc = " The CPU-time clock associated with the current thread."]
+    ThreadCputimeId,
+    #[doc = " The clock type is not known."]
+    Unknown = 255,
+}
+impl core::fmt::Debug for Snapshot0Clockid {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Snapshot0Clockid::Realtime => f.debug_tuple("Snapshot0Clockid::Realtime").finish(),
+            Snapshot0Clockid::Monotonic => f.debug_tuple("Snapshot0Clockid::Monotonic").finish(),
+            Snapshot0Clockid::ProcessCputimeId => {
+                f.debug_tuple("Snapshot0Clockid::ProcessCputimeId").finish()
+            }
+            Snapshot0Clockid::ThreadCputimeId => {
+                f.debug_tuple("Snapshot0Clockid::ThreadCputimeId").finish()
+            }
+            Snapshot0Clockid::Unknown => f.debug_tuple("Snapshot0Clockid::Unknown").finish(),
+        }
+    }
+}
+#[doc = " Identifiers for clocks."]
+#[repr(u32)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+pub enum Clockid {
+    #[doc = " The clock measuring real time. Time value zero corresponds with"]
+    #[doc = " 1970-01-01T00:00:00Z."]
+    Realtime,
+    #[doc = " The store-wide monotonic clock, which is defined as a clock measuring"]
+    #[doc = " real time, whose value cannot be adjusted and which cannot have negative"]
+    #[doc = " clock jumps. The epoch of this clock is undefined. The absolute time"]
+    #[doc = " value of this clock therefore has no meaning."]
+    Monotonic,
+    #[doc = " The CPU-time clock associated with the current process."]
+    ProcessCputimeId,
+    #[doc = " The CPU-time clock associated with the current thread."]
+    ThreadCputimeId,
+    #[doc = " The clock type is unknown."]
+    Unknown = 255,
+}
+impl core::fmt::Debug for Clockid {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Clockid::Realtime => f.debug_tuple("Clockid::Realtime").finish(),
+            Clockid::Monotonic => f.debug_tuple("Clockid::Monotonic").finish(),
+            Clockid::ProcessCputimeId => f.debug_tuple("Clockid::ProcessCputimeId").finish(),
+            Clockid::ThreadCputimeId => f.debug_tuple("Clockid::ThreadCputimeId").finish(),
+            Clockid::Unknown => f.debug_tuple("Clockid::Unknown").finish(),
+        }
+    }
+}
+#[doc = " Error codes returned by functions."]
+#[doc = " Not all of these error codes are returned by the functions provided by this"]
+#[doc = " API; some are used in higher-level library layers, and others are provided"]
+#[doc = " merely for alignment with POSIX."]
+#[repr(u16)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, IntoPrimitive, TryFromPrimitive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Errno {
+    #[doc = " No error occurred. System call completed successfully."]
+    Success,
+    #[doc = " Argument list too long."]
+    Toobig,
+    #[doc = " Permission denied."]
+    Access,
+    #[doc = " Address in use."]
+    Addrinuse,
+    #[doc = " Address not available."]
+    Addrnotavail,
+    #[doc = " Address family not supported."]
+    Afnosupport,
+    #[doc = " Resource unavailable, or operation would block."]
+    Again,
+    #[doc = " Connection already in progress."]
+    Already,
+    #[doc = " Bad file descriptor."]
+    Badf,
+    #[doc = " Bad message."]
+    Badmsg,
+    #[doc = " Device or resource busy."]
+    Busy,
+    #[doc = " Operation canceled."]
+    Canceled,
+    #[doc = " No child processes."]
+    Child,
+    #[doc = " Connection aborted."]
+    Connaborted,
+    #[doc = " Connection refused."]
+    Connrefused,
+    #[doc = " Connection reset."]
+    Connreset,
+    #[doc = " Resource deadlock would occur."]
+    Deadlk,
+    #[doc = " Destination address required."]
+    Destaddrreq,
+    #[doc = " Mathematics argument out of domain of function."]
+    Dom,
+    #[doc = " Reserved."]
+    Dquot,
+    #[doc = " File exists."]
+    Exist,
+    #[doc = " Bad address."]
+    Fault,
+    #[doc = " File too large."]
+    Fbig,
+    #[doc = " Host is unreachable."]
+    Hostunreach,
+    #[doc = " Identifier removed."]
+    Idrm,
+    #[doc = " Illegal byte sequence."]
+    Ilseq,
+    #[doc = " Operation in progress."]
+    Inprogress,
+    #[doc = " Interrupted function."]
+    Intr,
+    #[doc = " Invalid argument."]
+    Inval,
+    #[doc = " I/O error."]
+    Io,
+    #[doc = " Socket is connected."]
+    Isconn,
+    #[doc = " Is a directory."]
+    Isdir,
+    #[doc = " Too many levels of symbolic links."]
+    Loop,
+    #[doc = " File descriptor value too large."]
+    Mfile,
+    #[doc = " Too many links."]
+    Mlink,
+    #[doc = " Message too large."]
+    Msgsize,
+    #[doc = " Reserved."]
+    Multihop,
+    #[doc = " Filename too long."]
+    Nametoolong,
+    #[doc = " Network is down."]
+    Netdown,
+    #[doc = " Connection aborted by network."]
+    Netreset,
+    #[doc = " Network unreachable."]
+    Netunreach,
+    #[doc = " Too many files open in system."]
+    Nfile,
+    #[doc = " No buffer space available."]
+    Nobufs,
+    #[doc = " No such device."]
+    Nodev,
+    #[doc = " No such file or directory."]
+    Noent,
+    #[doc = " Executable file format error."]
+    Noexec,
+    #[doc = " No locks available."]
+    Nolck,
+    #[doc = " Reserved."]
+    Nolink,
+    #[doc = " Not enough space."]
+    Nomem,
+    #[doc = " No message of the desired type."]
+    Nomsg,
+    #[doc = " Protocol not available."]
+    Noprotoopt,
+    #[doc = " No space left on device."]
+    Nospc,
+    #[doc = " Function not supported."]
+    Nosys,
+    #[doc = " The socket is not connected."]
+    Notconn,
+    #[doc = " Not a directory or a symbolic link to a directory."]
+    Notdir,
+    #[doc = " Directory not empty."]
+    Notempty,
+    #[doc = " State not recoverable."]
+    Notrecoverable,
+    #[doc = " Not a socket."]
+    Notsock,
+    #[doc = " Not supported, or operation not supported on socket."]
+    Notsup,
+    #[doc = " Inappropriate I/O control operation."]
+    Notty,
+    #[doc = " No such device or address."]
+    Nxio,
+    #[doc = " Value too large to be stored in data type."]
+    Overflow,
+    #[doc = " Previous owner died."]
+    Ownerdead,
+    #[doc = " Operation not permitted."]
+    Perm,
+    #[doc = " Broken pipe."]
+    Pipe,
+    #[doc = " Protocol error."]
+    Proto,
+    #[doc = " Protocol not supported."]
+    Protonosupport,
+    #[doc = " Protocol wrong type for socket."]
+    Prototype,
+    #[doc = " Result too large."]
+    Range,
+    #[doc = " Read-only file system."]
+    Rofs,
+    #[doc = " Invalid seek."]
+    Spipe,
+    #[doc = " No such process."]
+    Srch,
+    #[doc = " Reserved."]
+    Stale,
+    #[doc = " Connection timed out."]
+    Timedout,
+    #[doc = " Text file busy."]
+    Txtbsy,
+    #[doc = " Cross-device link."]
+    Xdev,
+    #[doc = " Extension: Capabilities insufficient."]
+    Notcapable,
+    #[doc = " Cannot send after socket shutdown."]
+    Shutdown,
+    #[doc = " Memory access violation."]
+    Memviolation,
+    #[doc = " An unknown error has occured"]
+    Unknown,
+}
+impl Errno {
+    pub fn name(&self) -> &'static str {
+        match self {
+            Errno::Success => "success",
+            Errno::Toobig => "toobig",
+            Errno::Access => "access",
+            Errno::Addrinuse => "addrinuse",
+            Errno::Addrnotavail => "addrnotavail",
+            Errno::Afnosupport => "afnosupport",
+            Errno::Again => "again",
+            Errno::Already => "already",
+            Errno::Badf => "badf",
+            Errno::Badmsg => "badmsg",
+            Errno::Busy => "busy",
+            Errno::Canceled => "canceled",
+            Errno::Child => "child",
+            Errno::Connaborted => "connaborted",
+            Errno::Connrefused => "connrefused",
+            Errno::Connreset => "connreset",
+            Errno::Deadlk => "deadlk",
+            Errno::Destaddrreq => "destaddrreq",
+            Errno::Dom => "dom",
+            Errno::Dquot => "dquot",
+            Errno::Exist => "exist",
+            Errno::Fault => "fault",
+            Errno::Fbig => "fbig",
+            Errno::Hostunreach => "hostunreach",
+            Errno::Idrm => "idrm",
+            Errno::Ilseq => "ilseq",
+            Errno::Inprogress => "inprogress",
+            Errno::Intr => "intr",
+            Errno::Inval => "inval",
+            Errno::Io => "io",
+            Errno::Isconn => "isconn",
+            Errno::Isdir => "isdir",
+            Errno::Loop => "loop",
+            Errno::Mfile => "mfile",
+            Errno::Mlink => "mlink",
+            Errno::Msgsize => "msgsize",
+            Errno::Multihop => "multihop",
+            Errno::Nametoolong => "nametoolong",
+            Errno::Netdown => "netdown",
+            Errno::Netreset => "netreset",
+            Errno::Netunreach => "netunreach",
+            Errno::Nfile => "nfile",
+            Errno::Nobufs => "nobufs",
+            Errno::Nodev => "nodev",
+            Errno::Noent => "noent",
+            Errno::Noexec => "noexec",
+            Errno::Nolck => "nolck",
+            Errno::Nolink => "nolink",
+            Errno::Nomem => "nomem",
+            Errno::Nomsg => "nomsg",
+            Errno::Noprotoopt => "noprotoopt",
+            Errno::Nospc => "nospc",
+            Errno::Nosys => "nosys",
+            Errno::Notconn => "notconn",
+            Errno::Notdir => "notdir",
+            Errno::Notempty => "notempty",
+            Errno::Notrecoverable => "notrecoverable",
+            Errno::Notsock => "notsock",
+            Errno::Notsup => "notsup",
+            Errno::Notty => "notty",
+            Errno::Nxio => "nxio",
+            Errno::Overflow => "overflow",
+            Errno::Ownerdead => "ownerdead",
+            Errno::Perm => "perm",
+            Errno::Pipe => "pipe",
+            Errno::Proto => "proto",
+            Errno::Protonosupport => "protonosupport",
+            Errno::Prototype => "prototype",
+            Errno::Range => "range",
+            Errno::Rofs => "rofs",
+            Errno::Spipe => "spipe",
+            Errno::Srch => "srch",
+            Errno::Stale => "stale",
+            Errno::Timedout => "timedout",
+            Errno::Txtbsy => "txtbsy",
+            Errno::Xdev => "xdev",
+            Errno::Notcapable => "notcapable",
+            Errno::Shutdown => "shutdown",
+            Errno::Memviolation => "memviolation",
+            Errno::Unknown => "unknown",
+        }
+    }
+    pub fn message(&self) -> &'static str {
+        match self {
+            Errno::Success => "No error occurred. System call completed successfully.",
+            Errno::Toobig => "Argument list too long.",
+            Errno::Access => "Permission denied.",
+            Errno::Addrinuse => "Address in use.",
+            Errno::Addrnotavail => "Address not available.",
+            Errno::Afnosupport => "Address family not supported.",
+            Errno::Again => "Resource unavailable, or operation would block.",
+            Errno::Already => "Connection already in progress.",
+            Errno::Badf => "Bad file descriptor.",
+            Errno::Badmsg => "Bad message.",
+            Errno::Busy => "Device or resource busy.",
+            Errno::Canceled => "Operation canceled.",
+            Errno::Child => "No child processes.",
+            Errno::Connaborted => "Connection aborted.",
+            Errno::Connrefused => "Connection refused.",
+            Errno::Connreset => "Connection reset.",
+            Errno::Deadlk => "Resource deadlock would occur.",
+            Errno::Destaddrreq => "Destination address required.",
+            Errno::Dom => "Mathematics argument out of domain of function.",
+            Errno::Dquot => "Reserved.",
+            Errno::Exist => "File exists.",
+            Errno::Fault => "Bad address.",
+            Errno::Fbig => "File too large.",
+            Errno::Hostunreach => "Host is unreachable.",
+            Errno::Idrm => "Identifier removed.",
+            Errno::Ilseq => "Illegal byte sequence.",
+            Errno::Inprogress => "Operation in progress.",
+            Errno::Intr => "Interrupted function.",
+            Errno::Inval => "Invalid argument.",
+            Errno::Io => "I/O error.",
+            Errno::Isconn => "Socket is connected.",
+            Errno::Isdir => "Is a directory.",
+            Errno::Loop => "Too many levels of symbolic links.",
+            Errno::Mfile => "File descriptor value too large.",
+            Errno::Mlink => "Too many links.",
+            Errno::Msgsize => "Message too large.",
+            Errno::Multihop => "Reserved.",
+            Errno::Nametoolong => "Filename too long.",
+            Errno::Netdown => "Network is down.",
+            Errno::Netreset => "Connection aborted by network.",
+            Errno::Netunreach => "Network unreachable.",
+            Errno::Nfile => "Too many files open in system.",
+            Errno::Nobufs => "No buffer space available.",
+            Errno::Nodev => "No such device.",
+            Errno::Noent => "No such file or directory.",
+            Errno::Noexec => "Executable file format error.",
+            Errno::Nolck => "No locks available.",
+            Errno::Nolink => "Reserved.",
+            Errno::Nomem => "Not enough space.",
+            Errno::Nomsg => "No message of the desired type.",
+            Errno::Noprotoopt => "Protocol not available.",
+            Errno::Nospc => "No space left on device.",
+            Errno::Nosys => "Function not supported.",
+            Errno::Notconn => "The socket is not connected.",
+            Errno::Notdir => "Not a directory or a symbolic link to a directory.",
+            Errno::Notempty => "Directory not empty.",
+            Errno::Notrecoverable => "State not recoverable.",
+            Errno::Notsock => "Not a socket.",
+            Errno::Notsup => "Not supported, or operation not supported on socket.",
+            Errno::Notty => "Inappropriate I/O control operation.",
+            Errno::Nxio => "No such device or address.",
+            Errno::Overflow => "Value too large to be stored in data type.",
+            Errno::Ownerdead => "Previous owner died.",
+            Errno::Perm => "Operation not permitted.",
+            Errno::Pipe => "Broken pipe.",
+            Errno::Proto => "Protocol error.",
+            Errno::Protonosupport => "Protocol not supported.",
+            Errno::Prototype => "Protocol wrong type for socket.",
+            Errno::Range => "Result too large.",
+            Errno::Rofs => "Read-only file system.",
+            Errno::Spipe => "Invalid seek.",
+            Errno::Srch => "No such process.",
+            Errno::Stale => "Reserved.",
+            Errno::Timedout => "Connection timed out.",
+            Errno::Txtbsy => "Text file busy.",
+            Errno::Xdev => "Cross-device link.",
+            Errno::Notcapable => "Extension: Capabilities insufficient.",
+            Errno::Shutdown => "Cannot send after socket shutdown.",
+            Errno::Memviolation => "Memory access violation.",
+            Errno::Unknown => "An unknown error has occured",
+        }
+    }
+}
+impl core::fmt::Debug for Errno {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "Errno::{}", &self.name())
+    }
+}
+impl core::fmt::Display for Errno {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "{} (error {})", self.name(), *self as i32)
+    }
+}
+impl std::error::Error for Errno {}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " File descriptor rights, determining which actions may be performed."]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Rights : u64 {
+        #[doc = " The right to invoke `fd_datasync`."]
+        #[doc = " "]
+        #[doc = " If `rights::path_open` is set, includes the right to invoke"]
+        #[doc = " `path_open` with `fdflags::dsync`."]
+        const FD_DATASYNC = 1 << 0;
+        #[doc = " The right to invoke `fd_read` and `sock_recv`."]
+        #[doc = " "]
+        #[doc = " If `rights::fd_seek` is set, includes the right to invoke `fd_pread`."]
+        const FD_READ = 1 << 1;
+        #[doc = " The right to invoke `fd_seek`. This flag implies `rights::fd_tell`."]
+        const FD_SEEK = 1 << 2;
+        #[doc = " The right to invoke `fd_fdstat_set_flags`."]
+        const FD_FDSTAT_SET_FLAGS = 1 << 3;
+        #[doc = " The right to invoke `fd_sync`."]
+        #[doc = " "]
+        #[doc = " If `rights::path_open` is set, includes the right to invoke"]
+        #[doc = " `path_open` with `fdflags::rsync` and `fdflags::dsync`."]
+        const FD_SYNC = 1 << 4;
+        #[doc = " The right to invoke `fd_seek` in such a way that the file offset"]
+        #[doc = " remains unaltered (i.e., `whence::cur` with offset zero), or to"]
+        #[doc = " invoke `fd_tell`."]
+        const FD_TELL = 1 << 5;
+        #[doc = " The right to invoke `fd_write` and `sock_send`."]
+        #[doc = " If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`."]
+        const FD_WRITE = 1 << 6;
+        #[doc = " The right to invoke `fd_advise`."]
+        const FD_ADVISE = 1 << 7;
+        #[doc = " The right to invoke `fd_allocate`."]
+        const FD_ALLOCATE = 1 << 8;
+        #[doc = " The right to invoke `path_create_directory`."]
+        const PATH_CREATE_DIRECTORY = 1 << 9;
+        #[doc = " If `rights::path_open` is set, the right to invoke `path_open` with `oflags::creat`."]
+        const PATH_CREATE_FILE = 1 << 10;
+        #[doc = " The right to invoke `path_link` with the file descriptor as the"]
+        #[doc = " source directory."]
+        const PATH_LINK_SOURCE = 1 << 11;
+        #[doc = " The right to invoke `path_link` with the file descriptor as the"]
+        #[doc = " target directory."]
+        const PATH_LINK_TARGET = 1 << 12;
+        #[doc = " The right to invoke `path_open`."]
+        const PATH_OPEN = 1 << 13;
+        #[doc = " The right to invoke `fd_readdir`."]
+        const FD_READDIR = 1 << 14;
+        #[doc = " The right to invoke `path_readlink`."]
+        const PATH_READLINK = 1 << 15;
+        #[doc = " The right to invoke `path_rename` with the file descriptor as the source directory."]
+        const PATH_RENAME_SOURCE = 1 << 16;
+        #[doc = " The right to invoke `path_rename` with the file descriptor as the target directory."]
+        const PATH_RENAME_TARGET = 1 << 17;
+        #[doc = " The right to invoke `path_filestat_get`."]
+        const PATH_FILESTAT_GET = 1 << 18;
+        #[doc = " The right to change a file's size (there is no `path_filestat_set_size`)."]
+        #[doc = " If `rights::path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`."]
+        const PATH_FILESTAT_SET_SIZE = 1 << 19;
+        #[doc = " The right to invoke `path_filestat_set_times`."]
+        const PATH_FILESTAT_SET_TIMES = 1 << 20;
+        #[doc = " The right to invoke `fd_filestat_get`."]
+        const FD_FILESTAT_GET = 1 << 21;
+        #[doc = " The right to invoke `fd_filestat_set_size`."]
+        const FD_FILESTAT_SET_SIZE = 1 << 22;
+        #[doc = " The right to invoke `fd_filestat_set_times`."]
+        const FD_FILESTAT_SET_TIMES = 1 << 23;
+        #[doc = " The right to invoke `path_symlink`."]
+        const PATH_SYMLINK = 1 << 24;
+        #[doc = " The right to invoke `path_remove_directory`."]
+        const PATH_REMOVE_DIRECTORY = 1 << 25;
+        #[doc = " The right to invoke `path_unlink_file`."]
+        const PATH_UNLINK_FILE = 1 << 26;
+        #[doc = " If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`."]
+        #[doc = " If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`."]
+        const POLL_FD_READWRITE = 1 << 27;
+        #[doc = " The right to invoke `sock_shutdown`."]
+        const SOCK_SHUTDOWN = 1 << 28;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_ACCEPT = 1 << 29;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_CONNECT = 1 << 30;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_LISTEN = 1 << 31;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_BIND = 1 << 32;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_RECV = 1 << 33;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_SEND = 1 << 34;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_ADDR_LOCAL = 1 << 35;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_ADDR_REMOTE = 1 << 36;
+        # [doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_RECV_FROM = 1 << 37;
+        #[doc = " TODO: Found in wasmer-wasi-types rust project, but not in wasi-snapshot0"]
+        const SOCK_SEND_TO = 1 << 38;
+    }
+}
+impl Rights {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u64) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " The type of a file descriptor or file."]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Filetype {
+    #[doc = " The type of the file descriptor or file is unknown or is different from any of the other types specified."]
+    Unknown,
+    #[doc = " The file descriptor or file refers to a block device inode."]
+    BlockDevice,
+    #[doc = " The file descriptor or file refers to a character device inode."]
+    CharacterDevice,
+    #[doc = " The file descriptor or file refers to a directory inode."]
+    Directory,
+    #[doc = " The file descriptor or file refers to a regular file inode."]
+    RegularFile,
+    #[doc = " The file descriptor or file refers to a datagram socket."]
+    SocketDgram,
+    #[doc = " The file descriptor or file refers to a byte-stream socket."]
+    SocketStream,
+    #[doc = " The file refers to a symbolic link inode."]
+    SymbolicLink,
+    #[doc = " The file descriptor or file refers to a raw socket."]
+    SocketRaw,
+    #[doc = " The file descriptor or file refers to a sequential packet socket."]
+    SocketSeqpacket,
+}
+impl core::fmt::Debug for Filetype {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Filetype::Unknown => f.debug_tuple("Filetype::Unknown").finish(),
+            Filetype::BlockDevice => f.debug_tuple("Filetype::BlockDevice").finish(),
+            Filetype::CharacterDevice => f.debug_tuple("Filetype::CharacterDevice").finish(),
+            Filetype::Directory => f.debug_tuple("Filetype::Directory").finish(),
+            Filetype::RegularFile => f.debug_tuple("Filetype::RegularFile").finish(),
+            Filetype::SocketDgram => f.debug_tuple("Filetype::SocketDgram").finish(),
+            Filetype::SocketStream => f.debug_tuple("Filetype::SocketStream").finish(),
+            Filetype::SymbolicLink => f.debug_tuple("Filetype::SymbolicLink").finish(),
+            Filetype::SocketRaw => f.debug_tuple("Filetype::SocketRaw").finish(),
+            Filetype::SocketSeqpacket => f.debug_tuple("Filetype::SocketSeqpacket").finish(),
+        }
+    }
+}
+#[doc = " A directory entry, snapshot0 version."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Snapshot0Dirent {
+    #[doc = " The offset of the next directory entry stored in this directory."]
+    pub d_next: Dircookie,
+    #[doc = " The serial number of the file referred to by this directory entry."]
+    pub d_ino: Inode,
+    #[doc = " The length of the name of the directory entry."]
+    pub d_namlen: Dirnamlen,
+    #[doc = " The type of the file referred to by this directory entry."]
+    pub d_type: Filetype,
+}
+impl core::fmt::Debug for Snapshot0Dirent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Snapshot0Dirent")
+            .field("d-next", &self.d_next)
+            .field("d-ino", &self.d_ino)
+            .field("d-namlen", &self.d_namlen)
+            .field("d-type", &self.d_type)
+            .finish()
+    }
+}
+#[doc = " A directory entry."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Dirent {
+    #[doc = " The offset of the next directory entry stored in this directory."]
+    pub d_next: Dircookie,
+    #[doc = " The serial number of the file referred to by this directory entry."]
+    pub d_ino: Inode,
+    #[doc = " The type of the file referred to by this directory entry."]
+    pub d_type: Filetype,
+    #[doc = " The length of the name of the directory entry."]
+    pub d_namlen: Dirnamlen,
+}
+impl core::fmt::Debug for Dirent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Dirent")
+            .field("d-next", &self.d_next)
+            .field("d-ino", &self.d_ino)
+            .field("d-type", &self.d_type)
+            .field("d-namlen", &self.d_namlen)
+            .finish()
+    }
+}
+#[doc = " File or memory access pattern advisory information."]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Advice {
+    #[doc = " The application has no advice to give on its behavior with respect to the specified data."]
+    Normal,
+    #[doc = " The application expects to access the specified data sequentially from lower offsets to higher offsets."]
+    Sequential,
+    #[doc = " The application expects to access the specified data in a random order."]
+    Random,
+    #[doc = " The application expects to access the specified data in the near future."]
+    Willneed,
+    #[doc = " The application expects that it will not access the specified data in the near future."]
+    Dontneed,
+    #[doc = " The application expects to access the specified data once and then not reuse it thereafter."]
+    Noreuse,
+    #[doc = " The application expectations are unknown."]
+    Unknown = 255,
+}
+impl core::fmt::Debug for Advice {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Advice::Normal => f.debug_tuple("Advice::Normal").finish(),
+            Advice::Sequential => f.debug_tuple("Advice::Sequential").finish(),
+            Advice::Random => f.debug_tuple("Advice::Random").finish(),
+            Advice::Willneed => f.debug_tuple("Advice::Willneed").finish(),
+            Advice::Dontneed => f.debug_tuple("Advice::Dontneed").finish(),
+            Advice::Noreuse => f.debug_tuple("Advice::Noreuse").finish(),
+            Advice::Unknown => f.debug_tuple("Advice::Unknown").finish(),
+        }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " File descriptor flags."]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Fdflags : u16 {
+        #[doc = " Append mode: Data written to the file is always appended to the file's end."]
+        const APPEND = 1 << 0;
+        #[doc = " Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized."]
+        const DSYNC = 1 << 1;
+        #[doc = " Non-blocking mode."]
+        const NONBLOCK = 1 << 2;
+        #[doc = " Synchronized read I/O operations."]
+        const RSYNC = 1 << 3;
+        #[doc = " Write according to synchronized I/O file integrity completion. In"]
+        #[doc = " addition to synchronizing the data stored in the file, the implementation"]
+        #[doc = " may also synchronously update the file's metadata."]
+        const SYNC = 1 << 4;
+    }
+}
+impl Fdflags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " File descriptor attributes."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Fdstat {
+    #[doc = " File type."]
+    pub fs_filetype: Filetype,
+    #[doc = " File descriptor flags."]
+    pub fs_flags: Fdflags,
+    #[doc = " Rights that apply to this file descriptor."]
+    pub fs_rights_base: Rights,
+    #[doc = " Maximum set of rights that may be installed on new file descriptors that"]
+    #[doc = " are created through this file descriptor, e.g., through `path_open`."]
+    pub fs_rights_inheriting: Rights,
+}
+impl core::fmt::Debug for Fdstat {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Fdstat")
+            .field("fs-filetype", &self.fs_filetype)
+            .field("fs-flags", &self.fs_flags)
+            .field("fs-rights-base", &self.fs_rights_base)
+            .field("fs-rights-inheriting", &self.fs_rights_inheriting)
+            .finish()
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " Which file time attributes to adjust."]
+    #[doc = " TODO: wit appears to not have support for flags repr"]
+    #[doc = " (@witx repr u16)"]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Fstflags : u16 {
+        #[doc = " Adjust the last data access timestamp to the value stored in `filestat::atim`."]
+        const SET_ATIM = 1 << 0;
+        #[doc = " Adjust the last data access timestamp to the time of clock `clockid::realtime`."]
+        const SET_ATIM_NOW = 1 << 1;
+        #[doc = " Adjust the last data modification timestamp to the value stored in `filestat::mtim`."]
+        const SET_MTIM = 1 << 2;
+        #[doc = " Adjust the last data modification timestamp to the time of clock `clockid::realtime`."]
+        const SET_MTIM_NOW = 1 << 3;
+    }
+}
+impl Fstflags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " Flags determining the method of how paths are resolved."]
+    #[doc = " TODO: wit appears to not have support for flags repr"]
+    #[doc = " (@witx repr u32)"]
+    pub struct Lookup : u32 {
+        #[doc = " As long as the resolved path corresponds to a symbolic link, it is expanded."]
+        const SYMLINK_FOLLOW = 1 << 0;
+    }
+}
+impl Lookup {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u32) -> Self {
+        Self { bits }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " Open flags used by `path_open`."]
+    #[doc = " TODO: wit appears to not have support for flags repr"]
+    #[doc = " (@witx repr u16)"]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Oflags : u16 {
+        #[doc = " Create file if it does not exist."]
+        const CREATE = 1 << 0;
+        #[doc = " Fail if not a directory."]
+        const DIRECTORY = 1 << 1;
+        #[doc = " Fail if file already exists."]
+        const EXCL = 1 << 2;
+        #[doc = " Truncate file to size 0."]
+        const TRUNC = 1 << 3;
+    }
+}
+impl Oflags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " User-provided value that may be attached to objects that is retained when"]
+#[doc = " extracted from the implementation."]
+pub type Userdata = u64;
+#[doc = " Type of a subscription to an event or its occurrence."]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Eventtype {
+    #[doc = " The time value of clock `subscription_clock::id` has"]
+    #[doc = " reached timestamp `subscription_clock::timeout`."]
+    Clock,
+    #[doc = " File descriptor `subscription_fd_readwrite::fd` has data"]
+    #[doc = " available for reading. This event always triggers for regular files."]
+    FdRead,
+    #[doc = " File descriptor `subscription_fd_readwrite::fd` has capacity"]
+    #[doc = " available for writing. This event always triggers for regular files."]
+    FdWrite,
+    #[doc = " Event type is unknown"]
+    Unknown = 255,
+}
+impl core::fmt::Debug for Eventtype {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Eventtype::Clock => f.debug_tuple("Eventtype::Clock").finish(),
+            Eventtype::FdRead => f.debug_tuple("Eventtype::FdRead").finish(),
+            Eventtype::FdWrite => f.debug_tuple("Eventtype::FdWrite").finish(),
+            Eventtype::Unknown => f.debug_tuple("Eventtype::Unknown").finish(),
+        }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " Flags determining how to interpret the timestamp provided in"]
+    #[doc = " `subscription-clock::timeout`."]
+    pub struct Subclockflags : u16 {
+        #[doc = " If set, treat the timestamp provided in"]
+        #[doc = " `subscription-clock::timeout` as an absolute timestamp of clock"]
+        #[doc = " `subscription-clock::id`. If clear, treat the timestamp"]
+        #[doc = " provided in `subscription-clock::timeout` relative to the"]
+        #[doc = " current time value of clock `subscription-clock::id`."]
+        const SUBSCRIPTION_CLOCK_ABSTIME = 1 << 0;
+    }
+}
+impl Subclockflags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " The contents of a `subscription` when type is `eventtype::clock`."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Snapshot0SubscriptionClock {
+    #[doc = " The user-defined unique identifier of the clock."]
+    pub identifier: Userdata,
+    #[doc = " The clock against which to compare the timestamp."]
+    pub id: Snapshot0Clockid,
+    #[doc = " The absolute or relative timestamp."]
+    pub timeout: Timestamp,
+    #[doc = " The amount of time that the implementation may wait additionally"]
+    #[doc = " to coalesce with other events."]
+    pub precision: Timestamp,
+    #[doc = " Flags specifying whether the timeout is absolute or relative"]
+    pub flags: Subclockflags,
+}
+impl core::fmt::Debug for Snapshot0SubscriptionClock {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Snapshot0SubscriptionClock")
+            .field("identifier", &self.identifier)
+            .field("id", &self.id)
+            .field("timeout", &self.timeout)
+            .field("precision", &self.precision)
+            .field("flags", &self.flags)
+            .finish()
+    }
+}
+#[doc = " The contents of a `subscription` when type is `eventtype::clock`."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SubscriptionClock {
+    #[doc = " The clock against which to compare the timestamp."]
+    pub clock_id: Clockid,
+    #[doc = " The absolute or relative timestamp."]
+    pub timeout: Timestamp,
+    #[doc = " The amount of time that the implementation may wait additionally"]
+    #[doc = " to coalesce with other events."]
+    pub precision: Timestamp,
+    #[doc = " Flags specifying whether the timeout is absolute or relative"]
+    pub flags: Subclockflags,
+}
+impl core::fmt::Debug for SubscriptionClock {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("SubscriptionClock")
+            .field("clock-id", &self.clock_id)
+            .field("timeout", &self.timeout)
+            .field("precision", &self.precision)
+            .field("flags", &self.flags)
+            .finish()
+    }
+}
+#[doc = " Identifiers for preopened capabilities."]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Preopentype {
+    #[doc = " A pre-opened directory."]
+    Dir,
+    #[doc = " Unknown."]
+    Unknown = 255,
+}
+impl core::fmt::Debug for Preopentype {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Preopentype::Dir => f.debug_tuple("Preopentype::Dir").finish(),
+            Preopentype::Unknown => f.debug_tuple("Preopentype::Unknown").finish(),
+        }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " The state of the file descriptor subscribed to with"]
+    #[doc = " `eventtype::fd_read` or `eventtype::fd_write`."]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct Eventrwflags : u16 {
+        #[doc = " The peer of this socket has closed or disconnected."]
+        const FD_READWRITE_HANGUP = 1 << 0;
+    }
+}
+impl Eventrwflags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " The contents of an `event` for the `eventtype::fd_read` and"]
+#[doc = " `eventtype::fd_write` variants"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct EventFdReadwrite {
+    #[doc = " The number of bytes available for reading or writing."]
+    pub nbytes: Filesize,
+    #[doc = " The state of the file descriptor."]
+    pub flags: Eventrwflags,
+}
+impl core::fmt::Debug for EventFdReadwrite {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("EventFdReadwrite")
+            .field("nbytes", &self.nbytes)
+            .field("flags", &self.flags)
+            .finish()
+    }
+}
+#[doc = " An event that occurred."]
+#[doc = " The contents of an `event`."]
+#[doc = " An event that occurred."]
+#[doc = " The contents of a `subscription`, snapshot0 version."]
+#[doc = " The contents of a `subscription`."]
+#[doc = " The contents of a `subscription` when the variant is"]
+#[doc = " `eventtype::fd_read` or `eventtype::fd_write`."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SubscriptionFsReadwrite {
+    #[doc = " The file descriptor on which to wait for it to become ready for reading or writing."]
+    pub file_descriptor: Fd,
+}
+impl core::fmt::Debug for SubscriptionFsReadwrite {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("SubscriptionFsReadwrite")
+            .field("file-descriptor", &self.file_descriptor)
+            .finish()
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Socktype {
+    Unknown,
+    Stream,
+    Dgram,
+    Raw,
+    Seqpacket,
+}
+impl core::fmt::Debug for Socktype {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Socktype::Unknown => f.debug_tuple("Socktype::Uknown").finish(),
+            Socktype::Stream => f.debug_tuple("Socktype::Stream").finish(),
+            Socktype::Dgram => f.debug_tuple("Socktype::Dgram").finish(),
+            Socktype::Raw => f.debug_tuple("Socktype::Raw").finish(),
+            Socktype::Seqpacket => f.debug_tuple("Socktype::Seqpacket").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Sockstatus {
+    Opening,
+    Opened,
+    Closed,
+    Failed,
+    Unknown = 255,
+}
+impl core::fmt::Debug for Sockstatus {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Sockstatus::Opening => f.debug_tuple("Sockstatus::Opening").finish(),
+            Sockstatus::Opened => f.debug_tuple("Sockstatus::Opened").finish(),
+            Sockstatus::Closed => f.debug_tuple("Sockstatus::Closed").finish(),
+            Sockstatus::Failed => f.debug_tuple("Sockstatus::Failed").finish(),
+            Sockstatus::Unknown => f.debug_tuple("Sockstatus::Unknown").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Sockoption {
+    Noop,
+    ReusePort,
+    ReuseAddr,
+    NoDelay,
+    DontRoute,
+    OnlyV6,
+    Broadcast,
+    MulticastLoopV4,
+    MulticastLoopV6,
+    Promiscuous,
+    Listening,
+    LastError,
+    KeepAlive,
+    Linger,
+    OobInline,
+    RecvBufSize,
+    SendBufSize,
+    RecvLowat,
+    SendLowat,
+    RecvTimeout,
+    SendTimeout,
+    ConnectTimeout,
+    AcceptTimeout,
+    Ttl,
+    MulticastTtlV4,
+    Type,
+    Proto,
+}
+impl core::fmt::Debug for Sockoption {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Sockoption::Noop => f.debug_tuple("Sockoption::Noop").finish(),
+            Sockoption::ReusePort => f.debug_tuple("Sockoption::ReusePort").finish(),
+            Sockoption::ReuseAddr => f.debug_tuple("Sockoption::ReuseAddr").finish(),
+            Sockoption::NoDelay => f.debug_tuple("Sockoption::NoDelay").finish(),
+            Sockoption::DontRoute => f.debug_tuple("Sockoption::DontRoute").finish(),
+            Sockoption::OnlyV6 => f.debug_tuple("Sockoption::OnlyV6").finish(),
+            Sockoption::Broadcast => f.debug_tuple("Sockoption::Broadcast").finish(),
+            Sockoption::MulticastLoopV4 => f.debug_tuple("Sockoption::MulticastLoopV4").finish(),
+            Sockoption::MulticastLoopV6 => f.debug_tuple("Sockoption::MulticastLoopV6").finish(),
+            Sockoption::Promiscuous => f.debug_tuple("Sockoption::Promiscuous").finish(),
+            Sockoption::Listening => f.debug_tuple("Sockoption::Listening").finish(),
+            Sockoption::LastError => f.debug_tuple("Sockoption::LastError").finish(),
+            Sockoption::KeepAlive => f.debug_tuple("Sockoption::KeepAlive").finish(),
+            Sockoption::Linger => f.debug_tuple("Sockoption::Linger").finish(),
+            Sockoption::OobInline => f.debug_tuple("Sockoption::OobInline").finish(),
+            Sockoption::RecvBufSize => f.debug_tuple("Sockoption::RecvBufSize").finish(),
+            Sockoption::SendBufSize => f.debug_tuple("Sockoption::SendBufSize").finish(),
+            Sockoption::RecvLowat => f.debug_tuple("Sockoption::RecvLowat").finish(),
+            Sockoption::SendLowat => f.debug_tuple("Sockoption::SendLowat").finish(),
+            Sockoption::RecvTimeout => f.debug_tuple("Sockoption::RecvTimeout").finish(),
+            Sockoption::SendTimeout => f.debug_tuple("Sockoption::SendTimeout").finish(),
+            Sockoption::ConnectTimeout => f.debug_tuple("Sockoption::ConnectTimeout").finish(),
+            Sockoption::AcceptTimeout => f.debug_tuple("Sockoption::AcceptTimeout").finish(),
+            Sockoption::Ttl => f.debug_tuple("Sockoption::Ttl").finish(),
+            Sockoption::MulticastTtlV4 => f.debug_tuple("Sockoption::MulticastTtlV4").finish(),
+            Sockoption::Type => f.debug_tuple("Sockoption::Type").finish(),
+            Sockoption::Proto => f.debug_tuple("Sockoption::Proto").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Streamsecurity {
+    Unencrypted,
+    AnyEncryption,
+    ClassicEncryption,
+    DoubleEncryption,
+    Unknown = 255,
+}
+impl core::fmt::Debug for Streamsecurity {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Streamsecurity::Unencrypted => f.debug_tuple("Streamsecurity::Unencrypted").finish(),
+            Streamsecurity::AnyEncryption => {
+                f.debug_tuple("Streamsecurity::AnyEncryption").finish()
+            }
+            Streamsecurity::ClassicEncryption => {
+                f.debug_tuple("Streamsecurity::ClassicEncryption").finish()
+            }
+            Streamsecurity::DoubleEncryption => {
+                f.debug_tuple("Streamsecurity::DoubleEncryption").finish()
+            }
+            Streamsecurity::Unknown => f.debug_tuple("Streamsecurity::Unknown").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Addressfamily {
+    Unspec,
+    Inet4,
+    Inet6,
+    Unix,
+}
+impl core::fmt::Debug for Addressfamily {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Addressfamily::Unspec => f.debug_tuple("Addressfamily::Unspec").finish(),
+            Addressfamily::Inet4 => f.debug_tuple("Addressfamily::Inet4").finish(),
+            Addressfamily::Inet6 => f.debug_tuple("Addressfamily::Inet6").finish(),
+            Addressfamily::Unix => f.debug_tuple("Addressfamily::Unix").finish(),
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Snapshot0Filestat {
+    pub st_dev: Device,
+    pub st_ino: Inode,
+    pub st_filetype: Filetype,
+    pub st_nlink: Snapshot0Linkcount,
+    pub st_size: Filesize,
+    pub st_atim: Timestamp,
+    pub st_mtim: Timestamp,
+    pub st_ctim: Timestamp,
+}
+impl core::fmt::Debug for Snapshot0Filestat {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Snapshot0Filestat")
+            .field("st-dev", &self.st_dev)
+            .field("st-ino", &self.st_ino)
+            .field("st-filetype", &self.st_filetype)
+            .field("st-nlink", &self.st_nlink)
+            .field("st-size", &self.st_size)
+            .field("st-atim", &self.st_atim)
+            .field("st-mtim", &self.st_mtim)
+            .field("st-ctim", &self.st_ctim)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Filestat {
+    pub st_dev: Device,
+    pub st_ino: Inode,
+    pub st_filetype: Filetype,
+    pub st_nlink: Linkcount,
+    pub st_size: Filesize,
+    pub st_atim: Timestamp,
+    pub st_mtim: Timestamp,
+    pub st_ctim: Timestamp,
+}
+impl core::fmt::Debug for Filestat {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Filestat")
+            .field("st-dev", &self.st_dev)
+            .field("st-ino", &self.st_ino)
+            .field("st-filetype", &self.st_filetype)
+            .field("st-nlink", &self.st_nlink)
+            .field("st-size", &self.st_size)
+            .field("st-atim", &self.st_atim)
+            .field("st-mtim", &self.st_mtim)
+            .field("st-ctim", &self.st_ctim)
+            .finish()
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Snapshot0Whence {
+    Cur,
+    End,
+    Set,
+    Unknown = 255,
+}
+impl core::fmt::Debug for Snapshot0Whence {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Snapshot0Whence::Cur => f.debug_tuple("Snapshot0Whence::Cur").finish(),
+            Snapshot0Whence::End => f.debug_tuple("Snapshot0Whence::End").finish(),
+            Snapshot0Whence::Set => f.debug_tuple("Snapshot0Whence::Set").finish(),
+            Snapshot0Whence::Unknown => f.debug_tuple("Snapshot0Whence::Unknown").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Whence {
+    Set,
+    Cur,
+    End,
+    Unknown = 255,
+}
+impl core::fmt::Debug for Whence {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Whence::Set => f.debug_tuple("Whence::Set").finish(),
+            Whence::Cur => f.debug_tuple("Whence::Cur").finish(),
+            Whence::End => f.debug_tuple("Whence::End").finish(),
+            Whence::Unknown => f.debug_tuple("Whence::Unknown").finish(),
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Tty {
+    pub cols: u32,
+    pub rows: u32,
+    pub width: u32,
+    pub height: u32,
+    pub stdin_tty: bool,
+    pub stdout_tty: bool,
+    pub stderr_tty: bool,
+    pub echo: bool,
+    pub line_buffered: bool,
+}
+impl core::fmt::Debug for Tty {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Tty")
+            .field("cols", &self.cols)
+            .field("rows", &self.rows)
+            .field("width", &self.width)
+            .field("height", &self.height)
+            .field("stdin-tty", &self.stdin_tty)
+            .field("stdout-tty", &self.stdout_tty)
+            .field("stderr-tty", &self.stderr_tty)
+            .field("echo", &self.echo)
+            .field("line-buffered", &self.line_buffered)
+            .finish()
+    }
+}
+
+#[doc = " __wasi_option_t"]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum OptionTag {
+    None,
+    Some,
+}
+impl core::fmt::Debug for OptionTag {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            OptionTag::None => f.debug_tuple("OptionTag::None").finish(),
+            OptionTag::Some => f.debug_tuple("OptionTag::Some").finish(),
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct OptionPid {
+    pub tag: OptionTag,
+    pub pid: Pid,
+}
+impl core::fmt::Debug for OptionPid {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("OptionPid")
+            .field("tag", &self.tag)
+            .field("pid", &self.pid)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct OptionFd {
+    pub tag: OptionTag,
+    pub fd: Fd,
+}
+impl core::fmt::Debug for OptionFd {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("OptionFd")
+            .field("tag", &self.tag)
+            .field("fd", &self.fd)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ProcessHandles {
+    pub pid: Pid,
+    pub stdin: OptionFd,
+    pub stdout: OptionFd,
+    pub stderr: OptionFd,
+}
+impl core::fmt::Debug for ProcessHandles {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("ProcessHandles")
+            .field("pid", &self.pid)
+            .field("stdin", &self.stdin)
+            .field("stdout", &self.stdout)
+            .field("stderr", &self.stderr)
+            .finish()
+    }
+}
+pub type EventFdFlags = u16;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PrestatUDir {
+    pub pr_name_len: u32,
+}
+impl core::fmt::Debug for PrestatUDir {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PrestatUDir")
+            .field("pr-name-len", &self.pr_name_len)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PrestatU {
+    pub dir: PrestatUDir,
+}
+impl core::fmt::Debug for PrestatU {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PrestatU").field("dir", &self.dir).finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Prestat {
+    pub pr_type: Preopentype,
+    pub u: PrestatU,
+}
+impl core::fmt::Debug for Prestat {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Prestat")
+            .field("pr-type", &self.pr_type)
+            .field("u", &self.u)
+            .finish()
+    }
+}
+pub type FileDelta = i64;
+pub type LookupFlags = u32;
+pub type Count = u32;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PipeHandles {
+    pub pipe: Fd,
+    pub other: Fd,
+}
+impl core::fmt::Debug for PipeHandles {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("PipeHandles")
+            .field("pipe", &self.pipe)
+            .field("other", &self.other)
+            .finish()
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum StdioMode {
+    Piped,
+    Inherit,
+    Null,
+    Log,
+}
+impl core::fmt::Debug for StdioMode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            StdioMode::Piped => f.debug_tuple("StdioMode::Piped").finish(),
+            StdioMode::Inherit => f.debug_tuple("StdioMode::Inherit").finish(),
+            StdioMode::Null => f.debug_tuple("StdioMode::Null").finish(),
+            StdioMode::Log => f.debug_tuple("StdioMode::Log").finish(),
+        }
+    }
+}
+#[repr(u16)]
+#[derive(Clone, Copy, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum SockProto {
+    Ip,
+    Icmp,
+    Igmp,
+    ProtoThree,
+    Ipip,
+    ProtoFive,
+    Tcp,
+    ProtoSeven,
+    Egp,
+    ProtoNine,
+    ProtoTen,
+    ProtoEleven,
+    Pup,
+    ProtoThirteen,
+    ProtoFourteen,
+    ProtoFifteen,
+    ProtoSixteen,
+    Udp,
+    ProtoEighteen,
+    ProtoNineteen,
+    ProtoTwenty,
+    ProtoTwentyone,
+    Idp,
+    ProtoTwentythree,
+    ProtoTwentyfour,
+    ProtoTwentyfive,
+    ProtoTwentysix,
+    ProtoTwentyseven,
+    ProtoTwentyeight,
+    ProtoTp,
+    ProtoThirty,
+    ProtoThirtyone,
+    ProtoThirtytwo,
+    Dccp,
+    ProtoThirtyfour,
+    ProtoThirtyfive,
+    ProtoThirtysix,
+    ProtoThirtyseven,
+    ProtoThirtyeight,
+    ProtoThirtynine,
+    ProtoFourty,
+    Ipv6,
+    ProtoFourtytwo,
+    Routing,
+    Fragment,
+    ProtoFourtyfive,
+    Rsvp,
+    Gre,
+    ProtoFourtyeight,
+    ProtoFourtynine,
+    Esp,
+    Ah,
+    ProtoFiftytwo,
+    ProtoFiftythree,
+    ProtoFiftyfour,
+    ProtoFiftyfive,
+    ProtoFiftysix,
+    ProtoFiftyseven,
+    Icmpv6,
+    None,
+    Dstopts,
+    ProtoSixtyone,
+    ProtoSixtytwo,
+    ProtoSixtythree,
+    ProtoSixtyfour,
+    ProtoSixtyfive,
+    ProtoSixtysix,
+    ProtoSixtyseven,
+    ProtoSixtyeight,
+    ProtoSixtynine,
+    ProtoSeventy,
+    ProtoSeventyone,
+    ProtoSeventytwo,
+    ProtoSeventythree,
+    ProtoSeventyfour,
+    ProtoSeventyfive,
+    ProtoSeventysix,
+    ProtoSeventyseven,
+    ProtoSeventyeight,
+    ProtoSeventynine,
+    ProtoEighty,
+    ProtoEightyone,
+    ProtoEightytwo,
+    ProtoEightythree,
+    ProtoEightyfour,
+    ProtoEightyfive,
+    ProtoEightysix,
+    ProtoEightyseven,
+    ProtoEightyeight,
+    ProtoEightynine,
+    ProtoNinety,
+    ProtoNinetyone,
+    Mtp,
+    ProtoNinetythree,
+    Beetph,
+    ProtoNinetyfive,
+    ProtoNinetysix,
+    ProtoNineetyseven,
+    Encap,
+    ProtoNinetynine,
+    ProtoOnehundred,
+    ProtoOnehundredandone,
+    ProtoOnehundredandtwo,
+    Pim,
+    ProtoOnehundredandfour,
+    ProtoOnehundredandfive,
+    ProtoOnehundredandsix,
+    ProtoOnehundredandseven,
+    Comp,
+    ProtoOnehundredandnine,
+    ProtoOnehundredandten,
+    ProtoOnehundredandeleven,
+    ProtoOnehundredandtwelve,
+    ProtoOnehundredandthirteen,
+    ProtoOnehundredandfourteen,
+    ProtoOnehundredandfifteen,
+    ProtoOnehundredandsixteen,
+    ProtoOnehundredandseventeen,
+    ProtoOnehundredandeighteen,
+    ProtoOnehundredandnineteen,
+    ProtoOnehundredandtwenty,
+    ProtoOnehundredandtwentyone,
+    ProtoOnehundredandtwentytwo,
+    ProtoOnehundredandtwentythree,
+    ProtoOnehundredandtwentyfour,
+    ProtoOnehundredandtwentyfive,
+    ProtoOnehundredandtwentysix,
+    ProtoOnehundredandtwentyseven,
+    ProtoOnehundredandtwentyeight,
+    ProtoOnehundredandtwentynine,
+    ProtoOnehundredandthirty,
+    ProtoOnehundredandthirtyone,
+    Sctp,
+    ProtoOnehundredandthirtythree,
+    ProtoOnehundredandthirtyfour,
+    Mh,
+    Udplite,
+    Mpls,
+    ProtoOnehundredandthirtyeight,
+    ProtoOnehundredandthirtynine,
+    ProtoOnehundredandfourty,
+    ProtoOnehundredandfourtyone,
+    ProtoOnehundredandfourtytwo,
+    Ethernet,
+    ProtoOnehundredandfourtyfour,
+    ProtoOnehundredandfourtyfive,
+    ProtoOnehundredandfourtysix,
+    ProtoOnehundredandfourtyseven,
+    ProtoOnehundredandfourtyeight,
+    ProtoOnehundredandfourtynine,
+    ProtoOnehundredandfifty,
+    ProtoOnehundredandfiftyone,
+    ProtoOnehundredandfiftytwo,
+    ProtoOnehundredandfiftythree,
+    ProtoOnehundredandfiftyfour,
+    ProtoOnehundredandfiftyfive,
+    ProtoOnehundredandfiftysix,
+    ProtoOnehundredandfiftyseven,
+    ProtoOnehundredandfiftyeight,
+    ProtoOnehundredandfiftynine,
+    ProtoOnehundredandsixty,
+    ProtoOnehundredandsixtyone,
+    ProtoOnehundredandsixtytwo,
+    ProtoOnehundredandsixtythree,
+    ProtoOnehundredandsixtyfour,
+    ProtoOnehundredandsixtyfive,
+    ProtoOnehundredandsixtysix,
+    ProtoOnehundredandsixtyseven,
+    ProtoOnehundredandsixtyeight,
+    ProtoOnehundredandsixtynine,
+    ProtoOnehundredandseventy,
+    ProtoOnehundredandseventyone,
+    ProtoOnehundredandseventytwo,
+    ProtoOnehundredandseventythree,
+    ProtoOnehundredandseventyfour,
+    ProtoOnehundredandseventyfive,
+    ProtoOnehundredandseventysix,
+    ProtoOnehundredandseventyseven,
+    ProtoOnehundredandseventyeight,
+    ProtoOnehundredandseventynine,
+    ProtoOnehundredandeighty,
+    ProtoOnehundredandeightyone,
+    ProtoOnehundredandeightytwo,
+    ProtoOnehundredandeightythree,
+    ProtoOnehundredandeightyfour,
+    ProtoOnehundredandeightyfive,
+    ProtoOnehundredandeightysix,
+    ProtoOnehundredandeightyseven,
+    ProtoOnehundredandeightyeight,
+    ProtoOnehundredandeightynine,
+    ProtoOnehundredandninety,
+    ProtoOnehundredandninetyone,
+    ProtoOnehundredandninetytwo,
+    ProtoOnehundredandninetythree,
+    ProtoOnehundredandninetyfour,
+    ProtoOnehundredandninetyfive,
+    ProtoOnehundredandninetysix,
+    ProtoOnehundredandninetyseven,
+    ProtoOnehundredandninetyeight,
+    ProtoOnehundredandninetynine,
+    ProtoTwohundred,
+    ProtoTwohundredandone,
+    ProtoTwohundredandtwo,
+    ProtoTwohundredandthree,
+    ProtoTwohundredandfour,
+    ProtoTwohundredandfive,
+    ProtoTwohundredandsix,
+    ProtoTwohundredandseven,
+    ProtoTwohundredandeight,
+    ProtoTwohundredandnine,
+    ProtoTwohundredandten,
+    ProtoTwohundredandeleven,
+    ProtoTwohundredandtwelve,
+    ProtoTwohundredandthirteen,
+    ProtoTwohundredandfourteen,
+    ProtoTwohundredandfifteen,
+    ProtoTwohundredandsixteen,
+    ProtoTwohundredandseventeen,
+    ProtoTwohundredandeighteen,
+    ProtoTwohundredandnineteen,
+    ProtoTwohundredandtwenty,
+    ProtoTwohundredandtwentyone,
+    ProtoTwohundredandtwentytwo,
+    ProtoTwohundredandtwentythree,
+    ProtoTwohundredandtwentyfour,
+    ProtoTwohundredandtwentyfive,
+    ProtoTwohundredandtwentysix,
+    ProtoTwohundredandtwentyseven,
+    ProtoTwohundredandtwentyeight,
+    ProtoTwohundredandtwentynine,
+    ProtoTwohundredandthirty,
+    ProtoTwohundredandthirtyone,
+    ProtoTwohundredandthirtytwo,
+    ProtoTwohundredandthirtythree,
+    ProtoTwohundredandthirtyfour,
+    ProtoTwohundredandthirtyfive,
+    ProtoTwohundredandthirtysix,
+    ProtoTwohundredandthirtyseven,
+    ProtoTwohundredandthirtyeight,
+    ProtoTwohundredandthirtynine,
+    ProtoTwohundredandfourty,
+    ProtoTwohundredandfourtyone,
+    ProtoTwohundredandfourtytwo,
+    ProtoTwohundredandfourtythree,
+    ProtoTwohundredandfourtyfour,
+    ProtoTwohundredandfourtyfive,
+    ProtoTwohundredandfourtysix,
+    ProtoTwohundredandfourtyseven,
+    ProtoTwohundredandfourtyeight,
+    ProtoTwohundredandfourtynine,
+    ProtoTwohundredandfifty,
+    ProtoTwohundredandfiftyone,
+    ProtoTwohundredandfiftytwo,
+    ProtoTwohundredandfiftythree,
+    ProtoTwohundredandfiftyfour,
+    ProtoRaw,
+    ProtoTwohundredandfiftysix,
+    ProtoTwohundredandfiftyseven,
+    ProtoTwohundredandfiftyeight,
+    ProtoTwohundredandfiftynine,
+    ProtoTwohundredandsixty,
+    ProtoTwohundredandsixtyone,
+    Mptcp,
+    Max,
+}
+impl core::fmt::Debug for SockProto {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            SockProto::Ip => f.debug_tuple("SockProto::Ip").finish(),
+            SockProto::Icmp => f.debug_tuple("SockProto::Icmp").finish(),
+            SockProto::Igmp => f.debug_tuple("SockProto::Igmp").finish(),
+            SockProto::ProtoThree => f.debug_tuple("SockProto::ProtoThree").finish(),
+            SockProto::Ipip => f.debug_tuple("SockProto::Ipip").finish(),
+            SockProto::ProtoFive => f.debug_tuple("SockProto::ProtoFive").finish(),
+            SockProto::Tcp => f.debug_tuple("SockProto::Tcp").finish(),
+            SockProto::ProtoSeven => f.debug_tuple("SockProto::ProtoSeven").finish(),
+            SockProto::Egp => f.debug_tuple("SockProto::Egp").finish(),
+            SockProto::ProtoNine => f.debug_tuple("SockProto::ProtoNine").finish(),
+            SockProto::ProtoTen => f.debug_tuple("SockProto::ProtoTen").finish(),
+            SockProto::ProtoEleven => f.debug_tuple("SockProto::ProtoEleven").finish(),
+            SockProto::Pup => f.debug_tuple("SockProto::Pup").finish(),
+            SockProto::ProtoThirteen => f.debug_tuple("SockProto::ProtoThirteen").finish(),
+            SockProto::ProtoFourteen => f.debug_tuple("SockProto::ProtoFourteen").finish(),
+            SockProto::ProtoFifteen => f.debug_tuple("SockProto::ProtoFifteen").finish(),
+            SockProto::ProtoSixteen => f.debug_tuple("SockProto::ProtoSixteen").finish(),
+            SockProto::Udp => f.debug_tuple("SockProto::Udp").finish(),
+            SockProto::ProtoEighteen => f.debug_tuple("SockProto::ProtoEighteen").finish(),
+            SockProto::ProtoNineteen => f.debug_tuple("SockProto::ProtoNineteen").finish(),
+            SockProto::ProtoTwenty => f.debug_tuple("SockProto::ProtoTwenty").finish(),
+            SockProto::ProtoTwentyone => f.debug_tuple("SockProto::ProtoTwentyone").finish(),
+            SockProto::Idp => f.debug_tuple("SockProto::Idp").finish(),
+            SockProto::ProtoTwentythree => f.debug_tuple("SockProto::ProtoTwentythree").finish(),
+            SockProto::ProtoTwentyfour => f.debug_tuple("SockProto::ProtoTwentyfour").finish(),
+            SockProto::ProtoTwentyfive => f.debug_tuple("SockProto::ProtoTwentyfive").finish(),
+            SockProto::ProtoTwentysix => f.debug_tuple("SockProto::ProtoTwentysix").finish(),
+            SockProto::ProtoTwentyseven => f.debug_tuple("SockProto::ProtoTwentyseven").finish(),
+            SockProto::ProtoTwentyeight => f.debug_tuple("SockProto::ProtoTwentyeight").finish(),
+            SockProto::ProtoTp => f.debug_tuple("SockProto::ProtoTp").finish(),
+            SockProto::ProtoThirty => f.debug_tuple("SockProto::ProtoThirty").finish(),
+            SockProto::ProtoThirtyone => f.debug_tuple("SockProto::ProtoThirtyone").finish(),
+            SockProto::ProtoThirtytwo => f.debug_tuple("SockProto::ProtoThirtytwo").finish(),
+            SockProto::Dccp => f.debug_tuple("SockProto::Dccp").finish(),
+            SockProto::ProtoThirtyfour => f.debug_tuple("SockProto::ProtoThirtyfour").finish(),
+            SockProto::ProtoThirtyfive => f.debug_tuple("SockProto::ProtoThirtyfive").finish(),
+            SockProto::ProtoThirtysix => f.debug_tuple("SockProto::ProtoThirtysix").finish(),
+            SockProto::ProtoThirtyseven => f.debug_tuple("SockProto::ProtoThirtyseven").finish(),
+            SockProto::ProtoThirtyeight => f.debug_tuple("SockProto::ProtoThirtyeight").finish(),
+            SockProto::ProtoThirtynine => f.debug_tuple("SockProto::ProtoThirtynine").finish(),
+            SockProto::ProtoFourty => f.debug_tuple("SockProto::ProtoFourty").finish(),
+            SockProto::Ipv6 => f.debug_tuple("SockProto::Ipv6").finish(),
+            SockProto::ProtoFourtytwo => f.debug_tuple("SockProto::ProtoFourtytwo").finish(),
+            SockProto::Routing => f.debug_tuple("SockProto::Routing").finish(),
+            SockProto::Fragment => f.debug_tuple("SockProto::Fragment").finish(),
+            SockProto::ProtoFourtyfive => f.debug_tuple("SockProto::ProtoFourtyfive").finish(),
+            SockProto::Rsvp => f.debug_tuple("SockProto::Rsvp").finish(),
+            SockProto::Gre => f.debug_tuple("SockProto::Gre").finish(),
+            SockProto::ProtoFourtyeight => f.debug_tuple("SockProto::ProtoFourtyeight").finish(),
+            SockProto::ProtoFourtynine => f.debug_tuple("SockProto::ProtoFourtynine").finish(),
+            SockProto::Esp => f.debug_tuple("SockProto::Esp").finish(),
+            SockProto::Ah => f.debug_tuple("SockProto::Ah").finish(),
+            SockProto::ProtoFiftytwo => f.debug_tuple("SockProto::ProtoFiftytwo").finish(),
+            SockProto::ProtoFiftythree => f.debug_tuple("SockProto::ProtoFiftythree").finish(),
+            SockProto::ProtoFiftyfour => f.debug_tuple("SockProto::ProtoFiftyfour").finish(),
+            SockProto::ProtoFiftyfive => f.debug_tuple("SockProto::ProtoFiftyfive").finish(),
+            SockProto::ProtoFiftysix => f.debug_tuple("SockProto::ProtoFiftysix").finish(),
+            SockProto::ProtoFiftyseven => f.debug_tuple("SockProto::ProtoFiftyseven").finish(),
+            SockProto::Icmpv6 => f.debug_tuple("SockProto::Icmpv6").finish(),
+            SockProto::None => f.debug_tuple("SockProto::None").finish(),
+            SockProto::Dstopts => f.debug_tuple("SockProto::Dstopts").finish(),
+            SockProto::ProtoSixtyone => f.debug_tuple("SockProto::ProtoSixtyone").finish(),
+            SockProto::ProtoSixtytwo => f.debug_tuple("SockProto::ProtoSixtytwo").finish(),
+            SockProto::ProtoSixtythree => f.debug_tuple("SockProto::ProtoSixtythree").finish(),
+            SockProto::ProtoSixtyfour => f.debug_tuple("SockProto::ProtoSixtyfour").finish(),
+            SockProto::ProtoSixtyfive => f.debug_tuple("SockProto::ProtoSixtyfive").finish(),
+            SockProto::ProtoSixtysix => f.debug_tuple("SockProto::ProtoSixtysix").finish(),
+            SockProto::ProtoSixtyseven => f.debug_tuple("SockProto::ProtoSixtyseven").finish(),
+            SockProto::ProtoSixtyeight => f.debug_tuple("SockProto::ProtoSixtyeight").finish(),
+            SockProto::ProtoSixtynine => f.debug_tuple("SockProto::ProtoSixtynine").finish(),
+            SockProto::ProtoSeventy => f.debug_tuple("SockProto::ProtoSeventy").finish(),
+            SockProto::ProtoSeventyone => f.debug_tuple("SockProto::ProtoSeventyone").finish(),
+            SockProto::ProtoSeventytwo => f.debug_tuple("SockProto::ProtoSeventytwo").finish(),
+            SockProto::ProtoSeventythree => f.debug_tuple("SockProto::ProtoSeventythree").finish(),
+            SockProto::ProtoSeventyfour => f.debug_tuple("SockProto::ProtoSeventyfour").finish(),
+            SockProto::ProtoSeventyfive => f.debug_tuple("SockProto::ProtoSeventyfive").finish(),
+            SockProto::ProtoSeventysix => f.debug_tuple("SockProto::ProtoSeventysix").finish(),
+            SockProto::ProtoSeventyseven => f.debug_tuple("SockProto::ProtoSeventyseven").finish(),
+            SockProto::ProtoSeventyeight => f.debug_tuple("SockProto::ProtoSeventyeight").finish(),
+            SockProto::ProtoSeventynine => f.debug_tuple("SockProto::ProtoSeventynine").finish(),
+            SockProto::ProtoEighty => f.debug_tuple("SockProto::ProtoEighty").finish(),
+            SockProto::ProtoEightyone => f.debug_tuple("SockProto::ProtoEightyone").finish(),
+            SockProto::ProtoEightytwo => f.debug_tuple("SockProto::ProtoEightytwo").finish(),
+            SockProto::ProtoEightythree => f.debug_tuple("SockProto::ProtoEightythree").finish(),
+            SockProto::ProtoEightyfour => f.debug_tuple("SockProto::ProtoEightyfour").finish(),
+            SockProto::ProtoEightyfive => f.debug_tuple("SockProto::ProtoEightyfive").finish(),
+            SockProto::ProtoEightysix => f.debug_tuple("SockProto::ProtoEightysix").finish(),
+            SockProto::ProtoEightyseven => f.debug_tuple("SockProto::ProtoEightyseven").finish(),
+            SockProto::ProtoEightyeight => f.debug_tuple("SockProto::ProtoEightyeight").finish(),
+            SockProto::ProtoEightynine => f.debug_tuple("SockProto::ProtoEightynine").finish(),
+            SockProto::ProtoNinety => f.debug_tuple("SockProto::ProtoNinety").finish(),
+            SockProto::ProtoNinetyone => f.debug_tuple("SockProto::ProtoNinetyone").finish(),
+            SockProto::Mtp => f.debug_tuple("SockProto::Mtp").finish(),
+            SockProto::ProtoNinetythree => f.debug_tuple("SockProto::ProtoNinetythree").finish(),
+            SockProto::Beetph => f.debug_tuple("SockProto::Beetph").finish(),
+            SockProto::ProtoNinetyfive => f.debug_tuple("SockProto::ProtoNinetyfive").finish(),
+            SockProto::ProtoNinetysix => f.debug_tuple("SockProto::ProtoNinetysix").finish(),
+            SockProto::ProtoNineetyseven => f.debug_tuple("SockProto::ProtoNineetyseven").finish(),
+            SockProto::Encap => f.debug_tuple("SockProto::Encap").finish(),
+            SockProto::ProtoNinetynine => f.debug_tuple("SockProto::ProtoNinetynine").finish(),
+            SockProto::ProtoOnehundred => f.debug_tuple("SockProto::ProtoOnehundred").finish(),
+            SockProto::ProtoOnehundredandone => {
+                f.debug_tuple("SockProto::ProtoOnehundredandone").finish()
+            }
+            SockProto::ProtoOnehundredandtwo => {
+                f.debug_tuple("SockProto::ProtoOnehundredandtwo").finish()
+            }
+            SockProto::Pim => f.debug_tuple("SockProto::Pim").finish(),
+            SockProto::ProtoOnehundredandfour => {
+                f.debug_tuple("SockProto::ProtoOnehundredandfour").finish()
+            }
+            SockProto::ProtoOnehundredandfive => {
+                f.debug_tuple("SockProto::ProtoOnehundredandfive").finish()
+            }
+            SockProto::ProtoOnehundredandsix => {
+                f.debug_tuple("SockProto::ProtoOnehundredandsix").finish()
+            }
+            SockProto::ProtoOnehundredandseven => {
+                f.debug_tuple("SockProto::ProtoOnehundredandseven").finish()
+            }
+            SockProto::Comp => f.debug_tuple("SockProto::Comp").finish(),
+            SockProto::ProtoOnehundredandnine => {
+                f.debug_tuple("SockProto::ProtoOnehundredandnine").finish()
+            }
+            SockProto::ProtoOnehundredandten => {
+                f.debug_tuple("SockProto::ProtoOnehundredandten").finish()
+            }
+            SockProto::ProtoOnehundredandeleven => f
+                .debug_tuple("SockProto::ProtoOnehundredandeleven")
+                .finish(),
+            SockProto::ProtoOnehundredandtwelve => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwelve")
+                .finish(),
+            SockProto::ProtoOnehundredandthirteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirteen")
+                .finish(),
+            SockProto::ProtoOnehundredandfourteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourteen")
+                .finish(),
+            SockProto::ProtoOnehundredandfifteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandfifteen")
+                .finish(),
+            SockProto::ProtoOnehundredandsixteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixteen")
+                .finish(),
+            SockProto::ProtoOnehundredandseventeen => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventeen")
+                .finish(),
+            SockProto::ProtoOnehundredandeighteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandeighteen")
+                .finish(),
+            SockProto::ProtoOnehundredandnineteen => f
+                .debug_tuple("SockProto::ProtoOnehundredandnineteen")
+                .finish(),
+            SockProto::ProtoOnehundredandtwenty => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwenty")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentyone")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentythree")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentysix")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandtwentynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandtwentynine")
+                .finish(),
+            SockProto::ProtoOnehundredandthirty => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirty")
+                .finish(),
+            SockProto::ProtoOnehundredandthirtyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirtyone")
+                .finish(),
+            SockProto::Sctp => f.debug_tuple("SockProto::Sctp").finish(),
+            SockProto::ProtoOnehundredandthirtythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirtythree")
+                .finish(),
+            SockProto::ProtoOnehundredandthirtyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirtyfour")
+                .finish(),
+            SockProto::Mh => f.debug_tuple("SockProto::Mh").finish(),
+            SockProto::Udplite => f.debug_tuple("SockProto::Udplite").finish(),
+            SockProto::Mpls => f.debug_tuple("SockProto::Mpls").finish(),
+            SockProto::ProtoOnehundredandthirtyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirtyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandthirtynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandthirtynine")
+                .finish(),
+            SockProto::ProtoOnehundredandfourty => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourty")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtyone")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtytwo")
+                .finish(),
+            SockProto::Ethernet => f.debug_tuple("SockProto::Ethernet").finish(),
+            SockProto::ProtoOnehundredandfourtyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtysix")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandfourtynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandfourtynine")
+                .finish(),
+            SockProto::ProtoOnehundredandfifty => {
+                f.debug_tuple("SockProto::ProtoOnehundredandfifty").finish()
+            }
+            SockProto::ProtoOnehundredandfiftyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftyone")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftythree")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftysix")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandfiftynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandfiftynine")
+                .finish(),
+            SockProto::ProtoOnehundredandsixty => {
+                f.debug_tuple("SockProto::ProtoOnehundredandsixty").finish()
+            }
+            SockProto::ProtoOnehundredandsixtyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtyone")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtythree")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtysix")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandsixtynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandsixtynine")
+                .finish(),
+            SockProto::ProtoOnehundredandseventy => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventy")
+                .finish(),
+            SockProto::ProtoOnehundredandseventyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventyone")
+                .finish(),
+            SockProto::ProtoOnehundredandseventytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandseventythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventythree")
+                .finish(),
+            SockProto::ProtoOnehundredandseventyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandseventyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandseventysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventysix")
+                .finish(),
+            SockProto::ProtoOnehundredandseventyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandseventyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandseventynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandseventynine")
+                .finish(),
+            SockProto::ProtoOnehundredandeighty => f
+                .debug_tuple("SockProto::ProtoOnehundredandeighty")
+                .finish(),
+            SockProto::ProtoOnehundredandeightyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightyone")
+                .finish(),
+            SockProto::ProtoOnehundredandeightytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandeightythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightythree")
+                .finish(),
+            SockProto::ProtoOnehundredandeightyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandeightyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandeightysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightysix")
+                .finish(),
+            SockProto::ProtoOnehundredandeightyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandeightyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandeightynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandeightynine")
+                .finish(),
+            SockProto::ProtoOnehundredandninety => f
+                .debug_tuple("SockProto::ProtoOnehundredandninety")
+                .finish(),
+            SockProto::ProtoOnehundredandninetyone => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetyone")
+                .finish(),
+            SockProto::ProtoOnehundredandninetytwo => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetytwo")
+                .finish(),
+            SockProto::ProtoOnehundredandninetythree => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetythree")
+                .finish(),
+            SockProto::ProtoOnehundredandninetyfour => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetyfour")
+                .finish(),
+            SockProto::ProtoOnehundredandninetyfive => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetyfive")
+                .finish(),
+            SockProto::ProtoOnehundredandninetysix => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetysix")
+                .finish(),
+            SockProto::ProtoOnehundredandninetyseven => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetyseven")
+                .finish(),
+            SockProto::ProtoOnehundredandninetyeight => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetyeight")
+                .finish(),
+            SockProto::ProtoOnehundredandninetynine => f
+                .debug_tuple("SockProto::ProtoOnehundredandninetynine")
+                .finish(),
+            SockProto::ProtoTwohundred => f.debug_tuple("SockProto::ProtoTwohundred").finish(),
+            SockProto::ProtoTwohundredandone => {
+                f.debug_tuple("SockProto::ProtoTwohundredandone").finish()
+            }
+            SockProto::ProtoTwohundredandtwo => {
+                f.debug_tuple("SockProto::ProtoTwohundredandtwo").finish()
+            }
+            SockProto::ProtoTwohundredandthree => {
+                f.debug_tuple("SockProto::ProtoTwohundredandthree").finish()
+            }
+            SockProto::ProtoTwohundredandfour => {
+                f.debug_tuple("SockProto::ProtoTwohundredandfour").finish()
+            }
+            SockProto::ProtoTwohundredandfive => {
+                f.debug_tuple("SockProto::ProtoTwohundredandfive").finish()
+            }
+            SockProto::ProtoTwohundredandsix => {
+                f.debug_tuple("SockProto::ProtoTwohundredandsix").finish()
+            }
+            SockProto::ProtoTwohundredandseven => {
+                f.debug_tuple("SockProto::ProtoTwohundredandseven").finish()
+            }
+            SockProto::ProtoTwohundredandeight => {
+                f.debug_tuple("SockProto::ProtoTwohundredandeight").finish()
+            }
+            SockProto::ProtoTwohundredandnine => {
+                f.debug_tuple("SockProto::ProtoTwohundredandnine").finish()
+            }
+            SockProto::ProtoTwohundredandten => {
+                f.debug_tuple("SockProto::ProtoTwohundredandten").finish()
+            }
+            SockProto::ProtoTwohundredandeleven => f
+                .debug_tuple("SockProto::ProtoTwohundredandeleven")
+                .finish(),
+            SockProto::ProtoTwohundredandtwelve => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwelve")
+                .finish(),
+            SockProto::ProtoTwohundredandthirteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirteen")
+                .finish(),
+            SockProto::ProtoTwohundredandfourteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourteen")
+                .finish(),
+            SockProto::ProtoTwohundredandfifteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandfifteen")
+                .finish(),
+            SockProto::ProtoTwohundredandsixteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandsixteen")
+                .finish(),
+            SockProto::ProtoTwohundredandseventeen => f
+                .debug_tuple("SockProto::ProtoTwohundredandseventeen")
+                .finish(),
+            SockProto::ProtoTwohundredandeighteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandeighteen")
+                .finish(),
+            SockProto::ProtoTwohundredandnineteen => f
+                .debug_tuple("SockProto::ProtoTwohundredandnineteen")
+                .finish(),
+            SockProto::ProtoTwohundredandtwenty => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwenty")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentyone => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentyone")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentytwo => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentytwo")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentythree => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentythree")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentyfour => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentyfour")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentyfive => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentyfive")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentysix => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentysix")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentyseven => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentyseven")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentyeight => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentyeight")
+                .finish(),
+            SockProto::ProtoTwohundredandtwentynine => f
+                .debug_tuple("SockProto::ProtoTwohundredandtwentynine")
+                .finish(),
+            SockProto::ProtoTwohundredandthirty => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirty")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtyone => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtyone")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtytwo => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtytwo")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtythree => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtythree")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtyfour => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtyfour")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtyfive => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtyfive")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtysix => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtysix")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtyseven => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtyseven")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtyeight => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtyeight")
+                .finish(),
+            SockProto::ProtoTwohundredandthirtynine => f
+                .debug_tuple("SockProto::ProtoTwohundredandthirtynine")
+                .finish(),
+            SockProto::ProtoTwohundredandfourty => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourty")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtyone => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtyone")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtytwo => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtytwo")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtythree => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtythree")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtyfour => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtyfour")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtyfive => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtyfive")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtysix => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtysix")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtyseven => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtyseven")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtyeight => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtyeight")
+                .finish(),
+            SockProto::ProtoTwohundredandfourtynine => f
+                .debug_tuple("SockProto::ProtoTwohundredandfourtynine")
+                .finish(),
+            SockProto::ProtoTwohundredandfifty => {
+                f.debug_tuple("SockProto::ProtoTwohundredandfifty").finish()
+            }
+            SockProto::ProtoTwohundredandfiftyone => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftyone")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftytwo => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftytwo")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftythree => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftythree")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftyfour => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftyfour")
+                .finish(),
+            SockProto::ProtoRaw => f.debug_tuple("SockProto::ProtoRaw").finish(),
+            SockProto::ProtoTwohundredandfiftysix => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftysix")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftyseven => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftyseven")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftyeight => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftyeight")
+                .finish(),
+            SockProto::ProtoTwohundredandfiftynine => f
+                .debug_tuple("SockProto::ProtoTwohundredandfiftynine")
+                .finish(),
+            SockProto::ProtoTwohundredandsixty => {
+                f.debug_tuple("SockProto::ProtoTwohundredandsixty").finish()
+            }
+            SockProto::ProtoTwohundredandsixtyone => f
+                .debug_tuple("SockProto::ProtoTwohundredandsixtyone")
+                .finish(),
+            SockProto::Mptcp => f.debug_tuple("SockProto::Mptcp").finish(),
+            SockProto::Max => f.debug_tuple("SockProto::Max").finish(),
+        }
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Bool {
+    False,
+    True,
+}
+impl core::fmt::Debug for Bool {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Bool::False => f.debug_tuple("Bool::False").finish(),
+            Bool::True => f.debug_tuple("Bool::True").finish(),
+        }
+    }
+}
+impl core::fmt::Display for Bool {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Bool::False => write!(f, "false"),
+            Bool::True => write!(f, "true"),
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct OptionTimestamp {
+    pub tag: OptionTag,
+    pub u: Timestamp,
+}
+impl core::fmt::Debug for OptionTimestamp {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("OptionTimestamp")
+            .field("tag", &self.tag)
+            .field("u", &self.u)
+            .finish()
+    }
+}
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+pub enum Signal {
+    Signone = 0,
+    Sighup,
+    Sigint,
+    Sigquit,
+    Sigill,
+    Sigtrap,
+    Sigabrt,
+    Sigbus,
+    Sigfpe,
+    Sigkill,
+    Sigusr1,
+    Sigsegv,
+    Sigusr2,
+    Sigpipe,
+    Sigalrm,
+    Sigterm,
+    Sigstkflt,
+    Sigchld,
+    Sigcont,
+    Sigstop,
+    Sigtstp,
+    Sigttin,
+    Sigttou,
+    Sigurg,
+    Sigxcpu,
+    Sigxfsz,
+    Sigvtalrm,
+    Sigprof,
+    Sigwinch,
+    Sigpoll,
+    Sigpwr,
+    Sigsys,
+}
+impl core::fmt::Debug for Signal {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Signal::Signone => f.debug_tuple("Signal::Signone").finish(),
+            Signal::Sighup => f.debug_tuple("Signal::Sighup").finish(),
+            Signal::Sigint => f.debug_tuple("Signal::Sigint").finish(),
+            Signal::Sigquit => f.debug_tuple("Signal::Sigquit").finish(),
+            Signal::Sigill => f.debug_tuple("Signal::Sigill").finish(),
+            Signal::Sigtrap => f.debug_tuple("Signal::Sigtrap").finish(),
+            Signal::Sigabrt => f.debug_tuple("Signal::Sigabrt").finish(),
+            Signal::Sigbus => f.debug_tuple("Signal::Sigbus").finish(),
+            Signal::Sigfpe => f.debug_tuple("Signal::Sigfpe").finish(),
+            Signal::Sigkill => f.debug_tuple("Signal::Sigkill").finish(),
+            Signal::Sigusr1 => f.debug_tuple("Signal::Sigusr1").finish(),
+            Signal::Sigsegv => f.debug_tuple("Signal::Sigsegv").finish(),
+            Signal::Sigusr2 => f.debug_tuple("Signal::Sigusr2").finish(),
+            Signal::Sigpipe => f.debug_tuple("Signal::Sigpipe").finish(),
+            Signal::Sigalrm => f.debug_tuple("Signal::Sigalrm").finish(),
+            Signal::Sigterm => f.debug_tuple("Signal::Sigterm").finish(),
+            Signal::Sigstkflt => f.debug_tuple("Signal::Sigstkflt").finish(),
+            Signal::Sigchld => f.debug_tuple("Signal::Sigchld").finish(),
+            Signal::Sigcont => f.debug_tuple("Signal::Sigcont").finish(),
+            Signal::Sigstop => f.debug_tuple("Signal::Sigstop").finish(),
+            Signal::Sigtstp => f.debug_tuple("Signal::Sigtstp").finish(),
+            Signal::Sigttin => f.debug_tuple("Signal::Sigttin").finish(),
+            Signal::Sigttou => f.debug_tuple("Signal::Sigttou").finish(),
+            Signal::Sigurg => f.debug_tuple("Signal::Sigurg").finish(),
+            Signal::Sigxcpu => f.debug_tuple("Signal::Sigxcpu").finish(),
+            Signal::Sigxfsz => f.debug_tuple("Signal::Sigxfsz").finish(),
+            Signal::Sigvtalrm => f.debug_tuple("Signal::Sigvtalrm").finish(),
+            Signal::Sigprof => f.debug_tuple("Signal::Sigprof").finish(),
+            Signal::Sigwinch => f.debug_tuple("Signal::Sigwinch").finish(),
+            Signal::Sigpoll => f.debug_tuple("Signal::Sigpoll").finish(),
+            Signal::Sigpwr => f.debug_tuple("Signal::Sigpwr").finish(),
+            Signal::Sigsys => f.debug_tuple("Signal::Sigsys").finish(),
+        }
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct AddrUnspec {
+    pub n0: u8,
+}
+impl core::fmt::Debug for AddrUnspec {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("AddrUnspec").field("n0", &self.n0).finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct AddrUnspecPort {
+    pub port: u16,
+    pub addr: AddrUnspec,
+}
+impl core::fmt::Debug for AddrUnspecPort {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("AddrUnspecPort")
+            .field("port", &self.port)
+            .field("addr", &self.addr)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct CidrUnspec {
+    pub addr: AddrUnspec,
+    pub prefix: u8,
+}
+impl core::fmt::Debug for CidrUnspec {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("CidrUnspec")
+            .field("addr", &self.addr)
+            .field("prefix", &self.prefix)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct HttpHandles {
+    pub req: Fd,
+    pub res: Fd,
+    pub hdr: Fd,
+}
+impl core::fmt::Debug for HttpHandles {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("HttpHandles")
+            .field("req", &self.req)
+            .field("res", &self.res)
+            .field("hdr", &self.hdr)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct HttpStatus {
+    pub ok: Bool,
+    pub redirect: Bool,
+    pub size: Filesize,
+    pub status: u16,
+}
+impl core::fmt::Debug for HttpStatus {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("HttpStatus")
+            .field("ok", &self.ok)
+            .field("redirect", &self.redirect)
+            .field("size", &self.size)
+            .field("status", &self.status)
+            .finish()
+    }
+}
+pub type RiFlags = u16;
+pub type RoFlags = u16;
+pub type SdFlags = u8;
+pub type SiFlags = u16;
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Timeout {
+    Read,
+    Write,
+    Connect,
+    Accept,
+    Unknown = 255,
+}
+impl core::fmt::Debug for Timeout {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Timeout::Read => f.debug_tuple("Timeout::Read").finish(),
+            Timeout::Write => f.debug_tuple("Timeout::Write").finish(),
+            Timeout::Connect => f.debug_tuple("Timeout::Connect").finish(),
+            Timeout::Accept => f.debug_tuple("Timeout::Accept").finish(),
+            Timeout::Unknown => f.debug_tuple("Timeout::Unknown").finish(),
+        }
+    }
+}
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " join flags."]
+    pub struct JoinFlags : u32 {
+        #[doc = " Non-blocking join on the process"]
+        const NON_BLOCKING = 1 << 0 ;
+        #[doc = " Return if a process is stopped"]
+        const WAKE_STOPPED = 1 << 1 ;
+    }
+}
+impl JoinFlags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u32) -> Self {
+        Self { bits }
+    }
+}
+#[doc = " What has happened with the proccess when we joined on it"]
+#[repr(u8)]
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum JoinStatusType {
+    #[doc = " Nothing has happened"]
+    Nothing,
+    #[doc = " The process has exited by a normal exit code"]
+    ExitNormal,
+    #[doc = " The process was terminated by a signal"]
+    ExitSignal,
+    #[doc = " The process was stopped by a signal and can be resumed with SIGCONT"]
+    Stopped,
+}
+impl core::fmt::Debug for JoinStatusType {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            JoinStatusType::Nothing => f.debug_tuple("JoinStatusType::Nothing").finish(),
+            JoinStatusType::ExitNormal => f.debug_tuple("JoinStatusType::ExitNormal").finish(),
+            JoinStatusType::ExitSignal => f.debug_tuple("JoinStatusType::ExitSignal").finish(),
+            JoinStatusType::Stopped => f.debug_tuple("JoinStatusType::Stopped").finish(),
+        }
+    }
+}
+#[doc = " Represents an errno and a signal"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ErrnoSignal {
+    #[doc = " The exit code that was returned"]
+    pub exit_code: Errno,
+    #[doc = " The signal that was returned"]
+    pub signal: Signal,
+}
+impl core::fmt::Debug for ErrnoSignal {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("ErrnoSignal")
+            .field("exit-code", &self.exit_code)
+            .field("signal", &self.signal)
+            .finish()
+    }
+}
+
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " thread state flags"]
+    pub struct ThreadStateFlags : u16 {
+        const TSD_USED = 1 << 0 ;
+        const DLERROR_FLAG = 1 << 1 ;
+    }
+}
+impl ThreadStateFlags {
+    #[doc = " Convert from a raw integer, preserving any unknown bits. See"]
+    #[doc = " <https://github.com/bitflags/bitflags/issues/263#issuecomment-957088321>"]
+    pub fn from_bits_preserve(bits: u16) -> Self {
+        Self { bits }
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Snapshot0Clockid {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Snapshot0Clockid {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Realtime,
+            1 => Self::Monotonic,
+            2 => Self::ProcessCputimeId,
+            3 => Self::ThreadCputimeId,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Snapshot0Clockid");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Clockid {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Clockid {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Realtime,
+            1 => Self::Monotonic,
+            2 => Self::ProcessCputimeId,
+            3 => Self::ThreadCputimeId,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Clockid");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Errno {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Errno {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Success,
+            1 => Self::Toobig,
+            2 => Self::Access,
+            3 => Self::Addrinuse,
+            4 => Self::Addrnotavail,
+            5 => Self::Afnosupport,
+            6 => Self::Again,
+            7 => Self::Already,
+            8 => Self::Badf,
+            9 => Self::Badmsg,
+            10 => Self::Busy,
+            11 => Self::Canceled,
+            12 => Self::Child,
+            13 => Self::Connaborted,
+            14 => Self::Connrefused,
+            15 => Self::Connreset,
+            16 => Self::Deadlk,
+            17 => Self::Destaddrreq,
+            18 => Self::Dom,
+            19 => Self::Dquot,
+            20 => Self::Exist,
+            21 => Self::Fault,
+            22 => Self::Fbig,
+            23 => Self::Hostunreach,
+            24 => Self::Idrm,
+            25 => Self::Ilseq,
+            26 => Self::Inprogress,
+            27 => Self::Intr,
+            28 => Self::Inval,
+            29 => Self::Io,
+            30 => Self::Isconn,
+            31 => Self::Isdir,
+            32 => Self::Loop,
+            33 => Self::Mfile,
+            34 => Self::Mlink,
+            35 => Self::Msgsize,
+            36 => Self::Multihop,
+            37 => Self::Nametoolong,
+            38 => Self::Netdown,
+            39 => Self::Netreset,
+            40 => Self::Netunreach,
+            41 => Self::Nfile,
+            42 => Self::Nobufs,
+            43 => Self::Nodev,
+            44 => Self::Noent,
+            45 => Self::Noexec,
+            46 => Self::Nolck,
+            47 => Self::Nolink,
+            48 => Self::Nomem,
+            49 => Self::Nomsg,
+            50 => Self::Noprotoopt,
+            51 => Self::Nospc,
+            52 => Self::Nosys,
+            53 => Self::Notconn,
+            54 => Self::Notdir,
+            55 => Self::Notempty,
+            56 => Self::Notrecoverable,
+            57 => Self::Notsock,
+            58 => Self::Notsup,
+            59 => Self::Notty,
+            60 => Self::Nxio,
+            61 => Self::Overflow,
+            62 => Self::Ownerdead,
+            63 => Self::Perm,
+            64 => Self::Pipe,
+            65 => Self::Proto,
+            66 => Self::Protonosupport,
+            67 => Self::Prototype,
+            68 => Self::Range,
+            69 => Self::Rofs,
+            70 => Self::Spipe,
+            71 => Self::Srch,
+            72 => Self::Stale,
+            73 => Self::Timedout,
+            74 => Self::Txtbsy,
+            75 => Self::Xdev,
+            76 => Self::Notcapable,
+            77 => Self::Shutdown,
+            78 => Self::Memviolation,
+            79 => Self::Unknown,
+
+            _ => Self::Unknown,
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Rights {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Filetype {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Filetype {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Unknown,
+            1 => Self::BlockDevice,
+            2 => Self::CharacterDevice,
+            3 => Self::Directory,
+            4 => Self::RegularFile,
+            5 => Self::SocketDgram,
+            6 => Self::SocketStream,
+            7 => Self::SymbolicLink,
+            8 => Self::SocketRaw,
+            9 => Self::SocketSeqpacket,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Filetype");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Snapshot0Dirent {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Dirent {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Advice {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Advice {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Normal,
+            1 => Self::Sequential,
+            2 => Self::Random,
+            3 => Self::Willneed,
+            4 => Self::Dontneed,
+            5 => Self::Noreuse,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Advice");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Fdflags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Fdstat {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Fstflags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Lookup {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Oflags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Eventtype {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Eventtype {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Clock,
+            1 => Self::FdRead,
+            2 => Self::FdWrite,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Eventtype");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Subclockflags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Snapshot0SubscriptionClock {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for SubscriptionClock {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Preopentype {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Preopentype {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Dir,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Preopentype");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Eventrwflags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for EventFdReadwrite {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for SubscriptionFsReadwrite {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Socktype {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Socktype {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Unknown,
+            1 => Self::Stream,
+            2 => Self::Dgram,
+            3 => Self::Raw,
+            4 => Self::Seqpacket,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Socktype");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Sockstatus {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Sockstatus {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Opening,
+            1 => Self::Opened,
+            2 => Self::Closed,
+            3 => Self::Failed,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Sockstatus");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Sockoption {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Sockoption {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Noop,
+            1 => Self::ReusePort,
+            2 => Self::ReuseAddr,
+            3 => Self::NoDelay,
+            4 => Self::DontRoute,
+            5 => Self::OnlyV6,
+            6 => Self::Broadcast,
+            7 => Self::MulticastLoopV4,
+            8 => Self::MulticastLoopV6,
+            9 => Self::Promiscuous,
+            10 => Self::Listening,
+            11 => Self::LastError,
+            12 => Self::KeepAlive,
+            13 => Self::Linger,
+            14 => Self::OobInline,
+            15 => Self::RecvBufSize,
+            16 => Self::SendBufSize,
+            17 => Self::RecvLowat,
+            18 => Self::SendLowat,
+            19 => Self::RecvTimeout,
+            20 => Self::SendTimeout,
+            21 => Self::ConnectTimeout,
+            22 => Self::AcceptTimeout,
+            23 => Self::Ttl,
+            24 => Self::MulticastTtlV4,
+            25 => Self::Type,
+            26 => Self::Proto,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Sockoption");
+                Self::Noop
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Streamsecurity {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Streamsecurity {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Unencrypted,
+            1 => Self::AnyEncryption,
+            2 => Self::ClassicEncryption,
+            3 => Self::DoubleEncryption,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Streamsecurity");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Addressfamily {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Addressfamily {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Unspec,
+            1 => Self::Inet4,
+            2 => Self::Inet6,
+            3 => Self::Unix,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Addressfamily");
+                Self::Unspec
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Snapshot0Filestat {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Filestat {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Snapshot0Whence {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Snapshot0Whence {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Cur,
+            1 => Self::End,
+            2 => Self::Set,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Snapshot0Whence");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Whence {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Whence {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Set,
+            1 => Self::Cur,
+            2 => Self::End,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Whence");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Tty {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for OptionTag {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for OptionTag {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::None,
+            1 => Self::Some,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum OptionTag");
+                Self::None
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for OptionPid {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for ProcessHandles {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for OptionFd {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for PrestatUDir {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for PrestatU {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for PipeHandles {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for StdioMode {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for StdioMode {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Piped,
+            1 => Self::Inherit,
+            2 => Self::Null,
+            3 => Self::Log,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum StdioMode");
+                Self::Null
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for SockProto {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for SockProto {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Ip,
+            1 => Self::Icmp,
+            2 => Self::Igmp,
+            3 => Self::ProtoThree,
+            4 => Self::Ipip,
+            5 => Self::ProtoFive,
+            6 => Self::Tcp,
+            7 => Self::ProtoSeven,
+            8 => Self::Egp,
+            9 => Self::ProtoNine,
+            10 => Self::ProtoTen,
+            11 => Self::ProtoEleven,
+            12 => Self::Pup,
+            13 => Self::ProtoThirteen,
+            14 => Self::ProtoFourteen,
+            15 => Self::ProtoFifteen,
+            16 => Self::ProtoSixteen,
+            17 => Self::Udp,
+            18 => Self::ProtoEighteen,
+            19 => Self::ProtoNineteen,
+            20 => Self::ProtoTwenty,
+            21 => Self::ProtoTwentyone,
+            22 => Self::Idp,
+            23 => Self::ProtoTwentythree,
+            24 => Self::ProtoTwentyfour,
+            25 => Self::ProtoTwentyfive,
+            26 => Self::ProtoTwentysix,
+            27 => Self::ProtoTwentyseven,
+            28 => Self::ProtoTwentyeight,
+            29 => Self::ProtoTp,
+            30 => Self::ProtoThirty,
+            31 => Self::ProtoThirtyone,
+            32 => Self::ProtoThirtytwo,
+            33 => Self::Dccp,
+            34 => Self::ProtoThirtyfour,
+            35 => Self::ProtoThirtyfive,
+            36 => Self::ProtoThirtysix,
+            37 => Self::ProtoThirtyseven,
+            38 => Self::ProtoThirtyeight,
+            39 => Self::ProtoThirtynine,
+            40 => Self::ProtoFourty,
+            41 => Self::Ipv6,
+            42 => Self::ProtoFourtytwo,
+            43 => Self::Routing,
+            44 => Self::Fragment,
+            45 => Self::ProtoFourtyfive,
+            46 => Self::Rsvp,
+            47 => Self::Gre,
+            48 => Self::ProtoFourtyeight,
+            49 => Self::ProtoFourtynine,
+            50 => Self::Esp,
+            51 => Self::Ah,
+            52 => Self::ProtoFiftytwo,
+            53 => Self::ProtoFiftythree,
+            54 => Self::ProtoFiftyfour,
+            55 => Self::ProtoFiftyfive,
+            56 => Self::ProtoFiftysix,
+            57 => Self::ProtoFiftyseven,
+            58 => Self::Icmpv6,
+            59 => Self::None,
+            60 => Self::Dstopts,
+            61 => Self::ProtoSixtyone,
+            62 => Self::ProtoSixtytwo,
+            63 => Self::ProtoSixtythree,
+            64 => Self::ProtoSixtyfour,
+            65 => Self::ProtoSixtyfive,
+            66 => Self::ProtoSixtysix,
+            67 => Self::ProtoSixtyseven,
+            68 => Self::ProtoSixtyeight,
+            69 => Self::ProtoSixtynine,
+            70 => Self::ProtoSeventy,
+            71 => Self::ProtoSeventyone,
+            72 => Self::ProtoSeventytwo,
+            73 => Self::ProtoSeventythree,
+            74 => Self::ProtoSeventyfour,
+            75 => Self::ProtoSeventyfive,
+            76 => Self::ProtoSeventysix,
+            77 => Self::ProtoSeventyseven,
+            78 => Self::ProtoSeventyeight,
+            79 => Self::ProtoSeventynine,
+            80 => Self::ProtoEighty,
+            81 => Self::ProtoEightyone,
+            82 => Self::ProtoEightytwo,
+            83 => Self::ProtoEightythree,
+            84 => Self::ProtoEightyfour,
+            85 => Self::ProtoEightyfive,
+            86 => Self::ProtoEightysix,
+            87 => Self::ProtoEightyseven,
+            88 => Self::ProtoEightyeight,
+            89 => Self::ProtoEightynine,
+            90 => Self::ProtoNinety,
+            91 => Self::ProtoNinetyone,
+            92 => Self::Mtp,
+            93 => Self::ProtoNinetythree,
+            94 => Self::Beetph,
+            95 => Self::ProtoNinetyfive,
+            96 => Self::ProtoNinetysix,
+            97 => Self::ProtoNineetyseven,
+            98 => Self::Encap,
+            99 => Self::ProtoNinetynine,
+            100 => Self::ProtoOnehundred,
+            101 => Self::ProtoOnehundredandone,
+            102 => Self::ProtoOnehundredandtwo,
+            103 => Self::Pim,
+            104 => Self::ProtoOnehundredandfour,
+            105 => Self::ProtoOnehundredandfive,
+            106 => Self::ProtoOnehundredandsix,
+            107 => Self::ProtoOnehundredandseven,
+            108 => Self::Comp,
+            109 => Self::ProtoOnehundredandnine,
+            110 => Self::ProtoOnehundredandten,
+            111 => Self::ProtoOnehundredandeleven,
+            112 => Self::ProtoOnehundredandtwelve,
+            113 => Self::ProtoOnehundredandthirteen,
+            114 => Self::ProtoOnehundredandfourteen,
+            115 => Self::ProtoOnehundredandfifteen,
+            116 => Self::ProtoOnehundredandsixteen,
+            117 => Self::ProtoOnehundredandseventeen,
+            118 => Self::ProtoOnehundredandeighteen,
+            119 => Self::ProtoOnehundredandnineteen,
+            120 => Self::ProtoOnehundredandtwenty,
+            121 => Self::ProtoOnehundredandtwentyone,
+            122 => Self::ProtoOnehundredandtwentytwo,
+            123 => Self::ProtoOnehundredandtwentythree,
+            124 => Self::ProtoOnehundredandtwentyfour,
+            125 => Self::ProtoOnehundredandtwentyfive,
+            126 => Self::ProtoOnehundredandtwentysix,
+            127 => Self::ProtoOnehundredandtwentyseven,
+            128 => Self::ProtoOnehundredandtwentyeight,
+            129 => Self::ProtoOnehundredandtwentynine,
+            130 => Self::ProtoOnehundredandthirty,
+            131 => Self::ProtoOnehundredandthirtyone,
+            132 => Self::Sctp,
+            133 => Self::ProtoOnehundredandthirtythree,
+            134 => Self::ProtoOnehundredandthirtyfour,
+            135 => Self::Mh,
+            136 => Self::Udplite,
+            137 => Self::Mpls,
+            138 => Self::ProtoOnehundredandthirtyeight,
+            139 => Self::ProtoOnehundredandthirtynine,
+            140 => Self::ProtoOnehundredandfourty,
+            141 => Self::ProtoOnehundredandfourtyone,
+            142 => Self::ProtoOnehundredandfourtytwo,
+            143 => Self::Ethernet,
+            144 => Self::ProtoOnehundredandfourtyfour,
+            145 => Self::ProtoOnehundredandfourtyfive,
+            146 => Self::ProtoOnehundredandfourtysix,
+            147 => Self::ProtoOnehundredandfourtyseven,
+            148 => Self::ProtoOnehundredandfourtyeight,
+            149 => Self::ProtoOnehundredandfourtynine,
+            150 => Self::ProtoOnehundredandfifty,
+            151 => Self::ProtoOnehundredandfiftyone,
+            152 => Self::ProtoOnehundredandfiftytwo,
+            153 => Self::ProtoOnehundredandfiftythree,
+            154 => Self::ProtoOnehundredandfiftyfour,
+            155 => Self::ProtoOnehundredandfiftyfive,
+            156 => Self::ProtoOnehundredandfiftysix,
+            157 => Self::ProtoOnehundredandfiftyseven,
+            158 => Self::ProtoOnehundredandfiftyeight,
+            159 => Self::ProtoOnehundredandfiftynine,
+            160 => Self::ProtoOnehundredandsixty,
+            161 => Self::ProtoOnehundredandsixtyone,
+            162 => Self::ProtoOnehundredandsixtytwo,
+            163 => Self::ProtoOnehundredandsixtythree,
+            164 => Self::ProtoOnehundredandsixtyfour,
+            165 => Self::ProtoOnehundredandsixtyfive,
+            166 => Self::ProtoOnehundredandsixtysix,
+            167 => Self::ProtoOnehundredandsixtyseven,
+            168 => Self::ProtoOnehundredandsixtyeight,
+            169 => Self::ProtoOnehundredandsixtynine,
+            170 => Self::ProtoOnehundredandseventy,
+            171 => Self::ProtoOnehundredandseventyone,
+            172 => Self::ProtoOnehundredandseventytwo,
+            173 => Self::ProtoOnehundredandseventythree,
+            174 => Self::ProtoOnehundredandseventyfour,
+            175 => Self::ProtoOnehundredandseventyfive,
+            176 => Self::ProtoOnehundredandseventysix,
+            177 => Self::ProtoOnehundredandseventyseven,
+            178 => Self::ProtoOnehundredandseventyeight,
+            179 => Self::ProtoOnehundredandseventynine,
+            180 => Self::ProtoOnehundredandeighty,
+            181 => Self::ProtoOnehundredandeightyone,
+            182 => Self::ProtoOnehundredandeightytwo,
+            183 => Self::ProtoOnehundredandeightythree,
+            184 => Self::ProtoOnehundredandeightyfour,
+            185 => Self::ProtoOnehundredandeightyfive,
+            186 => Self::ProtoOnehundredandeightysix,
+            187 => Self::ProtoOnehundredandeightyseven,
+            188 => Self::ProtoOnehundredandeightyeight,
+            189 => Self::ProtoOnehundredandeightynine,
+            190 => Self::ProtoOnehundredandninety,
+            191 => Self::ProtoOnehundredandninetyone,
+            192 => Self::ProtoOnehundredandninetytwo,
+            193 => Self::ProtoOnehundredandninetythree,
+            194 => Self::ProtoOnehundredandninetyfour,
+            195 => Self::ProtoOnehundredandninetyfive,
+            196 => Self::ProtoOnehundredandninetysix,
+            197 => Self::ProtoOnehundredandninetyseven,
+            198 => Self::ProtoOnehundredandninetyeight,
+            199 => Self::ProtoOnehundredandninetynine,
+            200 => Self::ProtoTwohundred,
+            201 => Self::ProtoTwohundredandone,
+            202 => Self::ProtoTwohundredandtwo,
+            203 => Self::ProtoTwohundredandthree,
+            204 => Self::ProtoTwohundredandfour,
+            205 => Self::ProtoTwohundredandfive,
+            206 => Self::ProtoTwohundredandsix,
+            207 => Self::ProtoTwohundredandseven,
+            208 => Self::ProtoTwohundredandeight,
+            209 => Self::ProtoTwohundredandnine,
+            210 => Self::ProtoTwohundredandten,
+            211 => Self::ProtoTwohundredandeleven,
+            212 => Self::ProtoTwohundredandtwelve,
+            213 => Self::ProtoTwohundredandthirteen,
+            214 => Self::ProtoTwohundredandfourteen,
+            215 => Self::ProtoTwohundredandfifteen,
+            216 => Self::ProtoTwohundredandsixteen,
+            217 => Self::ProtoTwohundredandseventeen,
+            218 => Self::ProtoTwohundredandeighteen,
+            219 => Self::ProtoTwohundredandnineteen,
+            220 => Self::ProtoTwohundredandtwenty,
+            221 => Self::ProtoTwohundredandtwentyone,
+            222 => Self::ProtoTwohundredandtwentytwo,
+            223 => Self::ProtoTwohundredandtwentythree,
+            224 => Self::ProtoTwohundredandtwentyfour,
+            225 => Self::ProtoTwohundredandtwentyfive,
+            226 => Self::ProtoTwohundredandtwentysix,
+            227 => Self::ProtoTwohundredandtwentyseven,
+            228 => Self::ProtoTwohundredandtwentyeight,
+            229 => Self::ProtoTwohundredandtwentynine,
+            230 => Self::ProtoTwohundredandthirty,
+            231 => Self::ProtoTwohundredandthirtyone,
+            232 => Self::ProtoTwohundredandthirtytwo,
+            233 => Self::ProtoTwohundredandthirtythree,
+            234 => Self::ProtoTwohundredandthirtyfour,
+            235 => Self::ProtoTwohundredandthirtyfive,
+            236 => Self::ProtoTwohundredandthirtysix,
+            237 => Self::ProtoTwohundredandthirtyseven,
+            238 => Self::ProtoTwohundredandthirtyeight,
+            239 => Self::ProtoTwohundredandthirtynine,
+            240 => Self::ProtoTwohundredandfourty,
+            241 => Self::ProtoTwohundredandfourtyone,
+            242 => Self::ProtoTwohundredandfourtytwo,
+            243 => Self::ProtoTwohundredandfourtythree,
+            244 => Self::ProtoTwohundredandfourtyfour,
+            245 => Self::ProtoTwohundredandfourtyfive,
+            246 => Self::ProtoTwohundredandfourtysix,
+            247 => Self::ProtoTwohundredandfourtyseven,
+            248 => Self::ProtoTwohundredandfourtyeight,
+            249 => Self::ProtoTwohundredandfourtynine,
+            250 => Self::ProtoTwohundredandfifty,
+            251 => Self::ProtoTwohundredandfiftyone,
+            252 => Self::ProtoTwohundredandfiftytwo,
+            253 => Self::ProtoTwohundredandfiftythree,
+            254 => Self::ProtoTwohundredandfiftyfour,
+            255 => Self::ProtoRaw,
+            256 => Self::ProtoTwohundredandfiftysix,
+            257 => Self::ProtoTwohundredandfiftyseven,
+            258 => Self::ProtoTwohundredandfiftyeight,
+            259 => Self::ProtoTwohundredandfiftynine,
+            260 => Self::ProtoTwohundredandsixty,
+            261 => Self::ProtoTwohundredandsixtyone,
+            262 => Self::Mptcp,
+            263 => Self::Max,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum SockProto");
+                Self::None
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Bool {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Bool {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::False,
+            1 => Self::True,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Bool");
+                Self::False
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for OptionTimestamp {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Signal {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Signal {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Signone,
+            1 => Self::Sighup,
+            2 => Self::Sigint,
+            3 => Self::Sigquit,
+            4 => Self::Sigill,
+            5 => Self::Sigtrap,
+            6 => Self::Sigabrt,
+            7 => Self::Sigbus,
+            8 => Self::Sigfpe,
+            9 => Self::Sigkill,
+            10 => Self::Sigusr1,
+            11 => Self::Sigsegv,
+            12 => Self::Sigusr2,
+            13 => Self::Sigpipe,
+            14 => Self::Sigalrm,
+            15 => Self::Sigterm,
+            16 => Self::Sigstkflt,
+            17 => Self::Sigchld,
+            18 => Self::Sigcont,
+            19 => Self::Sigstop,
+            20 => Self::Sigtstp,
+            21 => Self::Sigttin,
+            22 => Self::Sigttou,
+            23 => Self::Sigurg,
+            24 => Self::Sigxcpu,
+            25 => Self::Sigxfsz,
+            26 => Self::Sigvtalrm,
+            27 => Self::Sigprof,
+            28 => Self::Sigwinch,
+            29 => Self::Sigpoll,
+            30 => Self::Sigpwr,
+            31 => Self::Sigsys,
+
+            _ => Self::Signone,
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for AddrUnspec {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for AddrUnspecPort {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for CidrUnspec {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for HttpHandles {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for HttpStatus {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for Timeout {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for Timeout {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Read,
+            1 => Self::Write,
+            2 => Self::Connect,
+            3 => Self::Accept,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum Timeout");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for JoinFlags {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for JoinStatusType {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for JoinStatusType {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Nothing,
+            1 => Self::ExitNormal,
+            2 => Self::ExitSignal,
+            3 => Self::Stopped,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum JoinStatusType");
+                Self::Nothing
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for ErrnoSignal {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings_manual.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings_manual.rs
new file mode 100644
index 0000000..4d93bf8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/bindings_manual.rs
@@ -0,0 +1,374 @@
+use crate::wasi::bindings::*;
+
+impl Rights {
+    pub const fn all_socket() -> Self {
+        Self::from_bits_truncate(
+            Self::FD_FDSTAT_SET_FLAGS.bits()
+                | Self::FD_FILESTAT_GET.bits()
+                | Self::FD_READ.bits()
+                | Self::FD_WRITE.bits()
+                | Self::POLL_FD_READWRITE.bits()
+                | Self::SOCK_SHUTDOWN.bits()
+                | Self::SOCK_CONNECT.bits()
+                | Self::SOCK_LISTEN.bits()
+                | Self::SOCK_BIND.bits()
+                | Self::SOCK_ACCEPT.bits()
+                | Self::SOCK_RECV.bits()
+                | Self::SOCK_SEND.bits()
+                | Self::SOCK_ADDR_LOCAL.bits()
+                | Self::SOCK_ADDR_REMOTE.bits()
+                | Self::SOCK_RECV_FROM.bits()
+                | Self::SOCK_SEND_TO.bits(),
+        )
+    }
+
+    /// expects a single right, returns None if out of bounds or > 1 bit set
+    pub fn to_str(self) -> Option<&'static str> {
+        Some(match self {
+            Rights::FD_DATASYNC => "Rights::FD_DATASYNC",
+            Rights::FD_READ => "Rights::FD_READ",
+            Rights::FD_SEEK => "Rights::FD_SEEK",
+            Rights::FD_FDSTAT_SET_FLAGS => "Rights::FD_FDSTAT_SET_FLAGS",
+            Rights::FD_SYNC => "Rights::FD_SYNC",
+            Rights::FD_TELL => "Rights::FD_TELL",
+            Rights::FD_WRITE => "Rights::FD_WRITE",
+            Rights::FD_ADVISE => "Rights::FD_ADVISE",
+            Rights::FD_ALLOCATE => "Rights::FD_ALLOCATE",
+            Rights::PATH_CREATE_DIRECTORY => "Rights::PATH_CREATE_DIRECTORY",
+            Rights::PATH_CREATE_FILE => "Rights::PATH_CREATE_FILE",
+            Rights::PATH_LINK_SOURCE => "Rights::PATH_LINK_SOURCE",
+            Rights::PATH_LINK_TARGET => "Rights::PATH_LINK_TARGET",
+            Rights::PATH_OPEN => "Rights::PATH_OPEN",
+            Rights::FD_READDIR => "Rights::FD_READDIR",
+            Rights::PATH_READLINK => "Rights::PATH_READLINK",
+            Rights::PATH_RENAME_SOURCE => "Rights::PATH_RENAME_SOURCE",
+            Rights::PATH_RENAME_TARGET => "Rights::PATH_RENAME_TARGET",
+            Rights::PATH_FILESTAT_GET => "Rights::PATH_FILESTAT_GET",
+            Rights::PATH_FILESTAT_SET_SIZE => "Rights::PATH_FILESTAT_SET_SIZE",
+            Rights::PATH_FILESTAT_SET_TIMES => "Rights::PATH_FILESTAT_SET_TIMES",
+            Rights::FD_FILESTAT_GET => "Rights::FD_FILESTAT_GET",
+            Rights::FD_FILESTAT_SET_SIZE => "Rights::FD_FILESTAT_SET_SIZE",
+            Rights::FD_FILESTAT_SET_TIMES => "Rights::FD_FILESTAT_SET_TIMES",
+            Rights::PATH_SYMLINK => "Rights::PATH_SYMLINK",
+            Rights::PATH_REMOVE_DIRECTORY => "Rights::PATH_REMOVE_DIRECTORY",
+            Rights::PATH_UNLINK_FILE => "Rights::PATH_UNLINK_FILE",
+            Rights::POLL_FD_READWRITE => "Rights::POLL_FD_READWRITE",
+            Rights::SOCK_SHUTDOWN => "Rights::SOCK_SHUTDOWN",
+            Rights::SOCK_ACCEPT => "Rights::SOCK_ACCEPT",
+            Rights::SOCK_CONNECT => "Rights::SOCK_CONNECT",
+            Rights::SOCK_LISTEN => "Rights::SOCK_LISTEN",
+            Rights::SOCK_BIND => "Rights::SOCK_BIND",
+            Rights::SOCK_RECV => "Rights::SOCK_RECV",
+            Rights::SOCK_SEND => "Rights::SOCK_SEND",
+            Rights::SOCK_ADDR_LOCAL => "Rights::SOCK_ADDR_LOCAL",
+            Rights::SOCK_ADDR_REMOTE => "Rights::SOCK_ADDR_REMOTE",
+            Rights::SOCK_RECV_FROM => "Rights::SOCK_RECV_FROM",
+            Rights::SOCK_SEND_TO => "Rights::SOCK_SEND_TO",
+            _ => return None,
+        })
+    }
+}
+
+impl Default for Filestat {
+    fn default() -> Self {
+        Self {
+            st_dev: Default::default(),
+            st_ino: Default::default(),
+            st_filetype: Filetype::Unknown,
+            st_nlink: 1,
+            st_size: Default::default(),
+            st_atim: Default::default(),
+            st_mtim: Default::default(),
+            st_ctim: Default::default(),
+        }
+    }
+}
+
+/// Workaround implementation because `wit-bindgen` does not generate
+/// type aliases, but instead creates the same filetype in each module
+/// for `use` statements in the `.wit` file.
+impl From<Clockid> for Snapshot0Clockid {
+    fn from(other: Clockid) -> Self {
+        match other {
+            Clockid::Realtime => Self::Realtime,
+            Clockid::Monotonic => Self::Monotonic,
+            Clockid::ProcessCputimeId => Self::ProcessCputimeId,
+            Clockid::ThreadCputimeId => Self::ThreadCputimeId,
+            Clockid::Unknown => Self::Unknown,
+        }
+    }
+}
+
+impl From<Snapshot0Clockid> for Clockid {
+    fn from(other: Snapshot0Clockid) -> Self {
+        match other {
+            Snapshot0Clockid::Realtime => Self::Realtime,
+            Snapshot0Clockid::Monotonic => Self::Monotonic,
+            Snapshot0Clockid::ProcessCputimeId => Self::ProcessCputimeId,
+            Snapshot0Clockid::ThreadCputimeId => Self::ThreadCputimeId,
+            Snapshot0Clockid::Unknown => Self::Unknown,
+        }
+    }
+}
+
+impl From<Snapshot0SubscriptionClock> for SubscriptionClock {
+    fn from(other: Snapshot0SubscriptionClock) -> Self {
+        // TODO: this removes Snapshot0SubscriptionClock::identifier, I don't
+        // think this is how it should be
+        Self {
+            clock_id: Clockid::from(other.id),
+            timeout: other.timeout,
+            precision: other.precision,
+            flags: other.flags,
+        }
+    }
+}
+
+impl std::fmt::Display for Sockoption {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match *self {
+            Self::Noop => "Sockoption::Noop",
+            Self::ReusePort => "Sockoption::ReusePort",
+            Self::ReuseAddr => "Sockoption::ReuseAddr",
+            Self::NoDelay => "Sockoption::NoDelay",
+            Self::DontRoute => "Sockoption::DontRoute",
+            Self::OnlyV6 => "Sockoption::OnlyV6",
+            Self::Broadcast => "Sockoption::Broadcast",
+            Self::MulticastLoopV4 => "Sockoption::MulticastLoopV4",
+            Self::MulticastLoopV6 => "Sockoption::MulticastLoopV6",
+            Self::Promiscuous => "Sockoption::Promiscuous",
+            Self::Listening => "Sockoption::Listening",
+            Self::LastError => "Sockoption::LastError",
+            Self::KeepAlive => "Sockoption::KeepAlive",
+            Self::Linger => "Sockoption::Linger",
+            Self::OobInline => "Sockoption::OobInline",
+            Self::RecvBufSize => "Sockoption::RecvBufSize",
+            Self::SendBufSize => "Sockoption::SendBufSize",
+            Self::RecvLowat => "Sockoption::RecvLowat",
+            Self::SendLowat => "Sockoption::SendLowat",
+            Self::RecvTimeout => "Sockoption::RecvTimeout",
+            Self::SendTimeout => "Sockoption::SendTimeout",
+            Self::ConnectTimeout => "Sockoption::ConnectTimeout",
+            Self::AcceptTimeout => "Sockoption::AcceptTimeout",
+            Self::Ttl => "Sockoption::Ttl",
+            Self::MulticastTtlV4 => "Sockoption::MulticastTtlV4",
+            Self::Type => "Sockoption::Type",
+            Self::Proto => "Sockoption::Proto",
+        };
+        write!(f, "{}", s)
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for Fdflags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u16)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for Rights {
+    type Native = i64;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i64
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u64)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for Fstflags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u16)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for Oflags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u16)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum PrestatEnum {
+    Dir { pr_name_len: u32 },
+}
+
+impl PrestatEnum {
+    pub fn untagged(self) -> PrestatU {
+        match self {
+            PrestatEnum::Dir { pr_name_len } => PrestatU {
+                dir: PrestatUDir { pr_name_len },
+            },
+        }
+    }
+}
+
+impl Prestat {
+    #[allow(clippy::trivially_copy_pass_by_ref)]
+    pub fn tagged(&self) -> Option<PrestatEnum> {
+        match self.pr_type {
+            Preopentype::Dir => Some(PrestatEnum::Dir {
+                pr_name_len: self.u.dir.pr_name_len,
+            }),
+            Preopentype::Unknown => None,
+        }
+    }
+}
+
+unsafe impl wasmer::ValueType for Prestat {
+    fn zero_padding_bytes(&self, bytes: &mut [core::mem::MaybeUninit<u8>]) {
+        macro_rules! field {
+            ($($f:tt)*) => {
+                &self.$($f)* as *const _ as usize - self as *const _ as usize
+            };
+        }
+        macro_rules! field_end {
+            ($($f:tt)*) => {
+                field!($($f)*) + core::mem::size_of_val(&self.$($f)*)
+            };
+        }
+        macro_rules! zero {
+            ($start:expr, $end:expr) => {
+                for i in $start..$end {
+                    bytes[i] = core::mem::MaybeUninit::new(0);
+                }
+            };
+        }
+        self.pr_type
+            .zero_padding_bytes(&mut bytes[field!(pr_type)..field_end!(pr_type)]);
+        zero!(field_end!(pr_type), field!(u));
+        match self.pr_type {
+            Preopentype::Dir => {
+                self.u
+                    .dir
+                    .zero_padding_bytes(&mut bytes[field!(u.dir)..field_end!(u.dir)]);
+                zero!(field_end!(u.dir), field_end!(u));
+            }
+            Preopentype::Unknown => {}
+        }
+        zero!(field_end!(u), core::mem::size_of_val(self));
+    }
+}
+
+impl From<Errno> for std::io::ErrorKind {
+    fn from(err: Errno) -> Self {
+        use std::io::ErrorKind;
+        match err {
+            Errno::Access => ErrorKind::PermissionDenied,
+            Errno::Addrinuse => ErrorKind::AddrInUse,
+            Errno::Addrnotavail => ErrorKind::AddrNotAvailable,
+            Errno::Again => ErrorKind::WouldBlock,
+            Errno::Already => ErrorKind::AlreadyExists,
+            Errno::Badf => ErrorKind::InvalidInput,
+            Errno::Badmsg => ErrorKind::InvalidData,
+            Errno::Canceled => ErrorKind::Interrupted,
+            Errno::Connaborted => ErrorKind::ConnectionAborted,
+            Errno::Connrefused => ErrorKind::ConnectionRefused,
+            Errno::Connreset => ErrorKind::ConnectionReset,
+            Errno::Exist => ErrorKind::AlreadyExists,
+            Errno::Intr => ErrorKind::Interrupted,
+            Errno::Inval => ErrorKind::InvalidInput,
+            Errno::Netreset => ErrorKind::ConnectionReset,
+            Errno::Noent => ErrorKind::NotFound,
+            Errno::Nomem => ErrorKind::OutOfMemory,
+            Errno::Nomsg => ErrorKind::InvalidData,
+            Errno::Notconn => ErrorKind::NotConnected,
+            Errno::Perm => ErrorKind::PermissionDenied,
+            Errno::Pipe => ErrorKind::BrokenPipe,
+            Errno::Timedout => ErrorKind::TimedOut,
+            _ => ErrorKind::Other,
+        }
+    }
+}
+
+impl From<Errno> for std::io::Error {
+    fn from(err: Errno) -> Self {
+        let kind: std::io::ErrorKind = err.into();
+        std::io::Error::new(kind, err.message())
+    }
+}
+
+impl From<std::io::Error> for Errno {
+    fn from(err: std::io::Error) -> Self {
+        use std::io::ErrorKind;
+        match err.kind() {
+            ErrorKind::NotFound => Errno::Noent,
+            ErrorKind::PermissionDenied => Errno::Perm,
+            ErrorKind::ConnectionRefused => Errno::Connrefused,
+            ErrorKind::ConnectionReset => Errno::Connreset,
+            ErrorKind::ConnectionAborted => Errno::Connaborted,
+            ErrorKind::NotConnected => Errno::Notconn,
+            ErrorKind::AddrInUse => Errno::Addrinuse,
+            ErrorKind::AddrNotAvailable => Errno::Addrnotavail,
+            ErrorKind::BrokenPipe => Errno::Pipe,
+            ErrorKind::AlreadyExists => Errno::Exist,
+            ErrorKind::WouldBlock => Errno::Again,
+            ErrorKind::InvalidInput => Errno::Io,
+            ErrorKind::InvalidData => Errno::Io,
+            ErrorKind::TimedOut => Errno::Timedout,
+            ErrorKind::WriteZero => Errno::Io,
+            ErrorKind::Interrupted => Errno::Intr,
+            ErrorKind::Other => Errno::Io,
+            ErrorKind::UnexpectedEof => Errno::Io,
+            ErrorKind::Unsupported => Errno::Notsup,
+            _ => Errno::Io,
+        }
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl wasmer::FromToNativeWasmType for JoinFlags {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.bits() as i32
+    }
+    fn from_native(n: Self::Native) -> Self {
+        Self::from_bits_truncate(n as u32)
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        // TODO: find correct implementation
+        false
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/mod.rs
new file mode 100644
index 0000000..c3c9544
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/mod.rs
@@ -0,0 +1,8 @@
+#[allow(unused_imports)]
+pub(crate) mod bindings;
+pub(crate) mod bindings_manual;
+pub use self::bindings::*;
+pub use bindings_manual::*;
+
+mod wasix_manual;
+pub use wasix_manual::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/wasix_manual.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/wasix_manual.rs
new file mode 100644
index 0000000..b8ee2e5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasi/wasix_manual.rs
@@ -0,0 +1,495 @@
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use std::mem::MaybeUninit;
+
+use wasmer::{FromToNativeWasmType, MemorySize, ValueType};
+
+use super::{
+    Errno, ErrnoSignal, EventFdReadwrite, Eventtype, Fd, JoinStatusType, Signal,
+    Snapshot0SubscriptionClock, SubscriptionClock, SubscriptionFsReadwrite, Userdata,
+};
+
+/// Thread local key
+pub type TlKey = u32;
+/// Thread local value
+pub type TlVal = u64;
+/// Thread local user data (associated with the value)
+pub type TlUser = u64;
+/// Long size used by checkpoints
+pub type Longsize = u64;
+
+/// The contents of a `subscription`, snapshot0 version.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union Snapshot0SubscriptionUnion {
+    pub clock: Snapshot0SubscriptionClock,
+    pub fd_readwrite: SubscriptionFsReadwrite,
+}
+/// The contents of a `subscription`.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union SubscriptionUnion {
+    pub clock: SubscriptionClock,
+    pub fd_readwrite: SubscriptionFsReadwrite,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Snapshot0Subscription {
+    pub userdata: Userdata,
+    pub type_: Eventtype,
+    pub u: Snapshot0SubscriptionUnion,
+}
+impl core::fmt::Debug for Snapshot0Subscription {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Snapshot0Subscription")
+            .field("userdata", &self.userdata)
+            .field("type", &self.type_)
+            .finish()
+    }
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Subscription {
+    pub userdata: Userdata,
+    pub type_: Eventtype,
+    pub data: SubscriptionUnion,
+}
+impl core::fmt::Debug for Subscription {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Subscription")
+            .field("userdata", &self.userdata)
+            .field("type", &self.type_)
+            .finish()
+    }
+}
+
+impl From<Snapshot0Subscription> for Subscription {
+    fn from(other: Snapshot0Subscription) -> Self {
+        Self {
+            userdata: other.userdata,
+            type_: other.type_,
+            data: match other.type_ {
+                Eventtype::Clock => SubscriptionUnion {
+                    clock: unsafe {
+                        SubscriptionClock {
+                            clock_id: other.u.clock.id.into(),
+                            timeout: other.u.clock.timeout,
+                            precision: other.u.clock.precision,
+                            flags: other.u.clock.flags,
+                        }
+                    },
+                },
+                Eventtype::FdRead => SubscriptionUnion {
+                    fd_readwrite: unsafe { other.u.fd_readwrite },
+                },
+                Eventtype::FdWrite => SubscriptionUnion {
+                    fd_readwrite: unsafe { other.u.fd_readwrite },
+                },
+                Eventtype::Unknown => SubscriptionUnion {
+                    fd_readwrite: SubscriptionFsReadwrite {
+                        file_descriptor: u32::MAX,
+                    },
+                },
+            },
+        }
+    }
+}
+
+/// The contents of an `event`.
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union EventUnion {
+    pub clock: u8,
+    pub fd_readwrite: EventFdReadwrite,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(C)]
+pub struct StackSnapshot {
+    pub user: u64,
+    pub hash: u128,
+}
+
+/// An event that occurred.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Event {
+    /// User-provided value that got attached to `subscription::userdata`.
+    pub userdata: Userdata,
+    /// If non-zero, an error that occurred while processing the subscription request.
+    pub error: Errno,
+    /// Type of event that was triggered
+    pub type_: Eventtype,
+    /// The type of the event that occurred, and the contents of the event
+    pub u: EventUnion,
+}
+impl core::fmt::Debug for Event {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Event")
+            .field("userdata", &self.userdata)
+            .field("error", &self.error)
+            .field("type", &self.type_)
+            .finish()
+    }
+}
+/// An event that occurred.
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Snapshot0Event {
+    /// User-provided value that got attached to `subscription::userdata`.
+    pub userdata: Userdata,
+    /// If non-zero, an error that occurred while processing the subscription request.
+    pub error: Errno,
+    /// The type of event that occured
+    pub type_: Eventtype,
+    /// The contents of the event, if it is an `eventtype::fd_read` or
+    /// `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+    pub fd_readwrite: EventFdReadwrite,
+}
+impl core::fmt::Debug for Snapshot0Event {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("Snapshot0Event")
+            .field("userdata", &self.userdata)
+            .field("error", &self.error)
+            .field("type", &self.type_)
+            .field("fd-readwrite", &self.fd_readwrite)
+            .finish()
+    }
+}
+
+unsafe impl ValueType for Snapshot0Subscription {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl ValueType for Snapshot0Event {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl ValueType for Subscription {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl ValueType for Event {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl ValueType for StackSnapshot {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union JoinStatusUnion {
+    pub nothing: u8,
+    pub exit_normal: Errno,
+    pub exit_signal: ErrnoSignal,
+    pub stopped: Signal,
+}
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct JoinStatus {
+    pub tag: JoinStatusType,
+    pub u: JoinStatusUnion,
+}
+impl core::fmt::Debug for JoinStatus {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut binding = f.debug_struct("JoinStatus");
+        let mut f = binding.field("tag", &self.tag);
+        f = unsafe {
+            match self.tag {
+                JoinStatusType::Nothing => f.field("nothing", &self.u.nothing),
+                JoinStatusType::ExitNormal => f.field("exit_normal", &self.u.exit_normal),
+                JoinStatusType::ExitSignal => f.field("exit_signal", &self.u.exit_signal),
+                JoinStatusType::Stopped => f.field("stopped", &self.u.stopped),
+            }
+        };
+        f.finish()
+    }
+}
+unsafe impl ValueType for JoinStatus {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+#[doc = " Represents the thread start object"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ThreadStart<M: MemorySize> {
+    pub stack_upper: M::Offset,
+    pub tls_base: M::Offset,
+    pub start_funct: M::Offset,
+    pub start_args: M::Offset,
+    pub reserved: [M::Offset; 10],
+    pub stack_size: M::Offset,
+    pub guard_size: M::Offset,
+}
+impl<M: MemorySize> core::fmt::Debug for ThreadStart<M> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("ThreadStart")
+            .field("stack_upper", &self.stack_upper)
+            .field("tls-base", &self.tls_base)
+            .field("start-funct", &self.start_funct)
+            .field("start-args", &self.start_args)
+            .field("stack_size", &self.stack_size)
+            .field("guard_size", &self.guard_size)
+            .finish()
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl<M: MemorySize> ValueType for ThreadStart<M> {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum ExitCode {
+    Errno(Errno),
+    Other(i32),
+}
+impl ExitCode {
+    pub fn raw(&self) -> i32 {
+        match self {
+            ExitCode::Errno(err) => err.to_native(),
+            ExitCode::Other(code) => *code,
+        }
+    }
+
+    pub fn is_success(&self) -> bool {
+        self.raw() == 0
+    }
+}
+impl core::fmt::Debug for ExitCode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            ExitCode::Errno(a) => write!(f, "ExitCode::{}", a),
+            ExitCode::Other(a) => write!(f, "ExitCode::{}", a),
+        }
+    }
+}
+impl core::fmt::Display for ExitCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        core::fmt::Debug::fmt(&self, f)
+    }
+}
+
+unsafe impl wasmer::FromToNativeWasmType for ExitCode {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self.into()
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        n.into()
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+impl From<Errno> for ExitCode {
+    fn from(val: Errno) -> Self {
+        Self::Errno(val)
+    }
+}
+
+impl From<i32> for ExitCode {
+    fn from(val: i32) -> Self {
+        let err = Errno::from_native(val);
+        match err {
+            Errno::Unknown => Self::Other(val),
+            err => Self::Errno(err),
+        }
+    }
+}
+
+impl From<ExitCode> for Errno {
+    fn from(code: ExitCode) -> Self {
+        match code {
+            ExitCode::Errno(err) => err,
+            ExitCode::Other(code) => Errno::from_native(code),
+        }
+    }
+}
+
+impl From<ExitCode> for i32 {
+    fn from(val: ExitCode) -> Self {
+        match val {
+            ExitCode::Errno(err) => err.to_native(),
+            ExitCode::Other(code) => code,
+        }
+    }
+}
+
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for EpollType {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+wai_bindgen_rust::bitflags::bitflags! {
+    #[doc = " Epoll available event types."]
+    #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+    pub struct EpollType : u32 {
+        #[doc = " The associated file is available for read(2) operations."]
+        const EPOLLIN = 1 << 0;
+        #[doc = " The associated file is available for write(2) operations."]
+        const EPOLLOUT = 1 << 1;
+        #[doc = " Stream socket peer closed connection, or shut down writing"]
+        #[doc = " half of connection.  (This flag is especially useful for"]
+        #[doc = " writing simple code to detect peer shutdown when using"]
+        #[doc = " edge-triggered monitoring.)"]
+        const EPOLLRDHUP = 1 << 2;
+        #[doc = " There is an exceptional condition on the file descriptor."]
+        #[doc = " See the discussion of POLLPRI in poll(2)."]
+        const EPOLLPRI = 1 << 3;
+        #[doc = " Error condition happened on the associated file"]
+        #[doc = " descriptor.  This event is also reported for the write end"]
+        #[doc = " of a pipe when the read end has been closed."]
+        const EPOLLERR = 1 << 4;
+        #[doc = " Hang up happened on the associated file descriptor."]
+        const EPOLLHUP = 1 << 5;
+        #[doc = " Requests edge-triggered notification for the associated"]
+        #[doc = " file descriptor.  The default behavior for epoll is level-"]
+        #[doc = " triggered.  See epoll(7) for more detailed information"]
+        #[doc = " about edge-triggered and level-triggered notification."]
+        const EPOLLET = 1 << 6;
+        #[doc = " Requests one-shot notification for the associated file"]
+        #[doc = " descriptor.  This means that after an event notified for"]
+        #[doc = " the file descriptor by epoll_wait(2), the file descriptor"]
+        #[doc = " is disabled in the interest list and no other events will"]
+        #[doc = " be reported by the epoll interface.  The user must call"]
+        #[doc = " epoll_ctl() with EPOLL_CTL_MOD to rearm the file"]
+        #[doc = " descriptor with a new event mask."]
+        const EPOLLONESHOT = 1 << 7;
+    }
+}
+
+#[doc = " Epoll operation."]
+#[repr(u32)]
+#[derive(Clone, Copy, PartialEq, Eq, num_enum :: TryFromPrimitive, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum EpollCtl {
+    #[doc = " Add an entry to the interest list of the epoll file descriptor, epfd."]
+    Add,
+    #[doc = " Change the settings associated with fd in the interest list to the new settings specified in event."]
+    Mod,
+    #[doc = " Remove (deregister) the target file descriptor fd from the interest list."]
+    Del,
+    #[doc = " Unknown."]
+    Unknown,
+}
+impl core::fmt::Debug for EpollCtl {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            EpollCtl::Add => f.debug_tuple("EPOLL_CTL_ADD").finish(),
+            EpollCtl::Mod => f.debug_tuple("EPOLL_CTL_MOD").finish(),
+            EpollCtl::Del => f.debug_tuple("EPOLL_CTL_DEL").finish(),
+            EpollCtl::Unknown => f.debug_tuple("Unknown").finish(),
+        }
+    }
+}
+// TODO: if necessary, must be implemented in wit-bindgen
+unsafe impl ValueType for EpollCtl {
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
+
+unsafe impl wasmer::FromToNativeWasmType for EpollCtl {
+    type Native = i32;
+
+    fn to_native(self) -> Self::Native {
+        self as i32
+    }
+
+    fn from_native(n: Self::Native) -> Self {
+        match n {
+            0 => Self::Add,
+            1 => Self::Mod,
+            2 => Self::Del,
+
+            q => {
+                tracing::debug!("could not serialize number {q} to enum EpollCtl");
+                Self::Unknown
+            }
+        }
+    }
+
+    fn is_from_store(&self, _store: &impl wasmer::AsStoreRef) -> bool {
+        false
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct EpollEventCtl {
+    pub events: EpollType,
+    pub ptr: u64,
+    pub fd: Fd,
+    pub data1: u32,
+    pub data2: u64,
+}
+
+/// An event that can be triggered
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct EpollData<M: MemorySize> {
+    /// Pointer to the data
+    pub ptr: M::Offset,
+    /// File descriptor
+    pub fd: Fd,
+    /// Associated user data
+    pub data1: u32,
+    /// Associated user data
+    pub data2: u64,
+}
+impl<M> core::fmt::Debug for EpollData<M>
+where
+    M: MemorySize,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("EpollData")
+            .field("ptr", &self.ptr)
+            .field("fd", &self.fd)
+            .field("data1", &self.data1)
+            .field("data2", &self.data2)
+            .finish()
+    }
+}
+
+/// An event that can be triggered
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct EpollEvent<M: MemorySize> {
+    /// Pointer to the data
+    pub events: EpollType,
+    /// File descriptor
+    pub data: EpollData<M>,
+}
+impl<M> core::fmt::Debug for EpollEvent<M>
+where
+    M: MemorySize,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("EpollData")
+            .field("events", &self.events)
+            .field("data", &self.data)
+            .finish()
+    }
+}
+unsafe impl<M> ValueType for EpollEvent<M>
+where
+    M: MemorySize,
+{
+    #[inline]
+    fn zero_padding_bytes(&self, _bytes: &mut [MaybeUninit<u8>]) {}
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasix/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasix/mod.rs
new file mode 100644
index 0000000..8f601ed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasi-types/src/wasix/mod.rs
@@ -0,0 +1,29 @@
+#[cfg(feature = "enable-serde")]
+use serde::*;
+
+// pub mod wasix_http_client_v1;
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "enable-serde", serde(rename_all = "snake_case"))]
+pub enum ThreadStartType {
+    MainThread,
+    ThreadSpawn { start_ptr: u64 },
+}
+
+/// Represents the memory layout of the parts that the thread itself uses
+#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "enable-serde", serde(rename_all = "snake_case"))]
+pub struct WasiMemoryLayout {
+    /// This is the top part of the stack (stacks go backwards)
+    pub stack_upper: u64,
+    /// This is the bottom part of the stack (anything more below this is a stack overflow)
+    pub stack_lower: u64,
+    /// Piece of memory that is marked as none readable/writable so stack overflows cause an exception
+    /// TODO: This field will need to be used to mark the guard memory as inaccessible
+    #[allow(dead_code)]
+    pub guard_size: u64,
+    /// Total size of the stack
+    pub stack_size: u64,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/wasix/Cargo.toml
new file mode 100644
index 0000000..e041ac5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/Cargo.toml
@@ -0,0 +1,205 @@
+[package]
+name = "wasmer-wasix"
+version = "0.18.3"
+description = "WASI and WASIX implementation library for Wasmer WebAssembly runtime"
+categories = ["wasm", "os"]
+keywords = ["wasm", "webassembly", "wasi", "sandbox", "ABI"]
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+xxhash-rust = { version = "0.8.8", features = ["xxh64"] }
+rusty_pool = { version = "0.7.0", optional = true }
+cfg-if = "1.0"
+thiserror = "1"
+tracing = { version = "0.1.37" }
+getrandom = "0.2"
+wasmer-wasix-types = { path = "../wasi-types", version = "0.18.3", features = [ "enable-serde" ] }
+wasmer-types = { path = "../types", version = "=4.2.8", default-features = false }
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["wat", "js-serializable-module"] }
+virtual-mio  = { path = "../virtual-io", version = "0.3.1", default-features = false }
+virtual-fs = { path = "../virtual-fs", version = "0.11.2", default-features = false, features = ["webc-fs"] }
+virtual-net = { path = "../virtual-net", version = "0.6.3", default-features = false, features = ["rkyv"] }
+wasmer-journal = { path = "../journal", version = "0.1.0", default-features = false }
+wasmer-emscripten = { path = "../emscripten", version = "=4.2.8", optional = true }
+typetag = { version = "0.1", optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+bincode = { version = "1.3" }
+chrono = { version = "^0.4.31", default-features = false, features = [ "wasmbind", "std", "clock" ], optional = true }
+derivative = { version = "^2" }
+bytes = "1"
+webc = { workspace = true }
+serde_cbor = { version = "0.11.2" }
+anyhow = { version = "1.0.66" }
+lazy_static = "1.4"
+sha2 = { version = "0.10" }
+waker-fn = { version = "1.1" }
+cooked-waker = "^5"
+rand = "0.8"
+tokio = { version = "1", features = [
+    "sync",
+    "macros",
+    "time",
+    "rt",
+], default_features = false }
+tokio-stream = { version = "0.1", features = [ "sync" ] }
+futures = { version = "0.3" }
+# used by feature='os'
+async-trait = { version = "^0.1" }
+urlencoding = { version = "^2" }
+serde_derive = { version = "^1" }
+serde_json = { version = "^1" }
+serde_yaml = { version = "^0.9" }
+weezl = { version = "^0.1" }
+hex = { version = "^0.4" }
+term_size = { version = "0.3" }
+linked_hash_set = { version = "0.1" }
+http = "0.2.8"
+heapless = "0.7.16"
+once_cell = "1.17.0"
+pin-project = "1.0.12"
+semver = "1.0.17"
+dashmap = "5.4.0"
+tempfile = "3.6.0"
+num_enum = "0.5.7"
+# Used by the WCGI runner
+hyper = { version = "0.14", features = ["server", "stream"], optional = true }
+wcgi = { version = "0.1.2", optional = true }
+wcgi-host = { version = "0.1.2", optional = true }
+tower-http = { version = "0.4.0", features = [
+    "trace",
+    "util",
+    "catch-panic",
+    "cors",
+], optional = true }
+tower = { version = "0.4.13", features = ["make", "util"], optional = true }
+url = "2.3.1"
+rkyv = { workspace = true }
+bytecheck = "0.6.8"
+blake3 = "1.0"
+shared-buffer = { workspace = true }
+petgraph = "0.6.3"
+base64 = "0.21"
+lz4_flex = { version = "0.11" }
+rayon = { version = "1.7.0", optional = true }
+wasm-bindgen = { version = "0.2.87", optional = true }
+js-sys = { version = "0.3.64", optional = true }
+wasm-bindgen-futures = { version = "0.4.37", optional = true }
+web-sys = { version = "0.3.64", features = [
+    "Request",
+    "RequestInit",
+    "Window",
+    "WorkerGlobalScope",
+    "RequestMode",
+    "Response",
+    "Headers",
+], optional = true }
+
+[target.'cfg(not(target_arch = "riscv64"))'.dependencies.reqwest]
+version = "0.11"
+default-features = false
+features = ["rustls-tls", "json", "stream"]
+optional = true
+
+[target.'cfg(target_arch = "riscv64")'.dependencies.reqwest]
+version = "0.11"
+default-features = false
+features = ["native-tls", "json", "stream"]
+optional = true
+
+[target.'cfg(unix)'.dependencies]
+libc = { version = "^0.2", default-features = false }
+
+[target.'cfg(all(unix, not(target_os="ios")))'.dependencies]
+termios = { version = "0.3" }
+
+[target.'cfg(windows)'.dependencies]
+winapi = "0.3"
+
+[dev-dependencies]
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["wat", "js-serializable-module"] }
+tokio = { version = "1", features = [ "sync", "macros", "rt" ], default_features = false }
+pretty_assertions = "1.3.0"
+tracing-test = "0.2.4"
+wasm-bindgen-test = "0.3.0"
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wasm-bindgen-test = "0.3.0"
+tracing-wasm = "0.2"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+tracing-subscriber = { version = "^0.3" }
+wasmer = { path = "../api", version = "=4.2.8", default-features = false, features = ["wat", "js-serializable-module", "cranelift"] }
+
+[features]
+default = ["sys-default"]
+
+time = ["tokio/time"]
+ctrlc = ["tokio/signal"]
+
+webc_runner_rt_wcgi = ["hyper", "wcgi", "wcgi-host", "tower", "tower-http"]
+webc_runner_rt_dcgi = ["webc_runner_rt_wcgi", "journal"]
+webc_runner_rt_dproxy = ["hyper", "tower", "tower-http", "journal"]
+webc_runner_rt_emscripten = ["wasmer-emscripten"]
+
+sys = ["webc/mmap", "time", "virtual-mio/sys"]
+sys-default = [
+    "sys",
+    "logging",
+    "host-fs",
+    "journal",
+    "sys-poll",
+    "sys-thread",
+    "host-vnet",
+    "host-threads",
+    "host-reqwest",
+    "ctrlc"
+]
+sys-poll = []
+sys-thread = ["tokio/rt", "tokio/time", "tokio/rt-multi-thread", "rusty_pool"]
+journal = ["tokio/fs", "wasmer-journal/log-file"]
+
+# Deprecated. Kept it for compatibility
+compiler = []
+
+js = [
+    "virtual-fs/no-time",
+    "getrandom/js",
+    "chrono",
+    "js-sys",
+    "wasm-bindgen",
+    "wasm-bindgen-futures",
+    "web-sys",
+]
+js-default = ["js"]
+test-js = ["js", "wasmer/wat"]
+
+host-vnet = ["virtual-net/host-net"]
+host-threads = []
+host-reqwest = ["reqwest"]
+host-fs = ["virtual-fs/host-fs"]
+remote-vnet = ["virtual-net/remote"]
+
+logging = ["tracing/log"]
+disable-all-logging = ["tracing/release_max_level_off", "tracing/max_level_off"]
+enable-serde = [
+    "typetag",
+    "virtual-fs/enable-serde",
+    "wasmer-wasix-types/enable-serde",
+]
+
+[package.metadata.docs.rs]
+features = [
+    "wasmer/sys",
+    "webc_runner_rt_wcgi",
+    "webc_runner_rt_dcgi",
+    "webc_runner_rt_dproxy",
+    "webc_runner_rt_emscripten",
+    "sys-default",
+]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/README.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/README.md
new file mode 100644
index 0000000..ac56c80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/README.md
@@ -0,0 +1,110 @@
+# `wasmer-wasi` [![Build Status](https://github.com/wasmerio/wasmer/workflows/build/badge.svg?style=flat-square)](https://github.com/wasmerio/wasmer/actions?query=workflow%3Abuild) [![Join Wasmer Slack](https://img.shields.io/static/v1?label=Slack&message=join%20chat&color=brighgreen&style=flat-square)](https://slack.wasmer.io) [![MIT License](https://img.shields.io/github/license/wasmerio/wasmer.svg?style=flat-square)](https://github.com/wasmerio/wasmer/blob/master/LICENSE) [![crates.io](https://img.shields.io/crates/v/wasmer-wasi.svg)](https://crates.io/crates/wasmer-wasi)
+
+This crate provides the necessary imports to use WASI easily from Wasmer.
+[WebAssembly System Interface](https://github.com/WebAssembly/WASI)
+(WASI for short) is a modular system interface for WebAssembly. WASI
+is being standardized in the WebAssembly subgroup.
+
+Very succinctly, from the user perspective, WASI is a set of
+WebAssembly module _imports_ under a specific _namespace_ (which
+varies based on the WASI version). A program compiled for the
+`wasm32-wasi` target will be able to support standard I/O, file I/O,
+filesystem manipulation, memory management, time, string, environment
+variables, program startup etc.
+
+Wasmer WASI is created with the aim to be fully sandboxed.
+We are able to achieve that thanks to our Virtual Filesystem implementation (`wasmer-vfs`)
+and by only allowing secure systemcalls back to the host.
+
+> Note: If you encounter any sandboxing issue please open an issue in the wasmer repo https://github.com/wasmerio/wasmer.
+
+This crate provides the necessary API to create the imports to use
+WASI easily from the Wasmer runtime, through our `ImportObject` API.
+
+## Supported WASI versions
+
+| WASI version             | Support |
+| ------------------------ | ------- |
+| `wasi_unstable`          | ✅       |
+| `wasi_snapshot_preview1` | ✅       |
+
+The special `Latest` version points to `wasi_snapshot_preview1`.
+
+Learn more about [the WASI version
+process](https://github.com/WebAssembly/WASI/tree/main/phases)
+(ephemeral, snapshot, old).
+
+## Usage
+
+Let's consider the following `hello.rs` Rust program:
+
+```rust
+fn main() {
+    println!("Hello, {:?}", std::env::args().nth(1));
+}
+```
+
+Then, let's compile it to a WebAssembly module with WASI support:
+
+```sh
+$ rustc --target wasm32-wasi hello.rs
+```
+
+Finally, let's execute it with the `wasmer` CLI:
+
+```sh
+$ wasmer run hello.wasm Gordon
+Hello, Some("Gordon")
+```
+
+… and programatically with the `wasmer` and the `wasmer-wasi` libraries:
+
+```rust
+use wasmer::{Store, Module, Instance};
+use wasmer_wasix::WasiState;
+
+let mut store = Store::default();
+let module = Module::from_file(&store, "hello.wasm")?;
+
+// Create the `WasiEnv`.
+let wasi_env = WasiState::builder("command-name")
+    .args(&["Gordon"])
+    .finalize()?;
+
+// Generate an `ImportObject`.
+let mut wasi_thread = wasi_env.new_thread();
+let import_object = wasi_thread.import_object(&module)?;
+
+// Let's instantiate the module with the imports.
+let instance = Instance::new(&module, &import_object)?;
+
+// Let's call the `_start` function, which is our `main` function in Rust.
+let start = instance.exports.get_function("_start")?;
+start.call(&[])?;
+```
+
+Check the [fully working example using
+WASI](https://github.com/wasmerio/wasmer/blob/master/examples/wasi.rs).
+
+## More resources
+
+This library is about the WASI implementation inside the Wasmer
+runtime. It contains documentation about the implementation
+itself. However, if you wish to learn more about WASI, here is a list
+of links that may help you:
+
+* [`wasi-libc`](https://github.com/WebAssembly/wasi-libc/), WASI libc
+  implementation for WebAssembly programs built on top of WASI system
+  calls. It provides a wide array of POSIX-compatible C APIs,
+  including support for standard I/O, file I/O, filesystem
+  manipulation, memory management, time, string, environment
+  variables, program startup, and many other APIs,
+* [`wasi-sdk`](https://github.com/WebAssembly/wasi-sdk/), WASI-enabled
+  WebAssembly C/C++ toolchain, based on `wasi-libc`,
+* [WASI API
+  documentation](https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md),
+* [WASI C API header
+  file](https://github.com/WebAssembly/wasi-libc/blob/main/libc-bottom-half/headers/public/wasi/api.h),
+* [WASI Application Binary Interface
+  (ABI)](https://github.com/WebAssembly/WASI/blob/main/legacy/application-abi.md),
+  where we learn about `_start` and `_initialize` (for _reactors_) for example.
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/binary_package.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/binary_package.rs
new file mode 100644
index 0000000..28e5627
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/binary_package.rs
@@ -0,0 +1,222 @@
+use std::sync::Arc;
+
+use anyhow::Context;
+use derivative::*;
+use once_cell::sync::OnceCell;
+use semver::Version;
+use virtual_fs::FileSystem;
+use webc::{compat::SharedBytes, Container};
+
+use crate::{
+    runtime::{
+        module_cache::ModuleHash,
+        resolver::{PackageId, PackageInfo, PackageSpecifier, ResolveError},
+    },
+    Runtime,
+};
+
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct BinaryPackageCommand {
+    name: String,
+    metadata: webc::metadata::Command,
+    #[derivative(Debug = "ignore")]
+    pub(crate) atom: SharedBytes,
+    hash: OnceCell<ModuleHash>,
+}
+
+impl BinaryPackageCommand {
+    pub fn new(name: String, metadata: webc::metadata::Command, atom: SharedBytes) -> Self {
+        Self {
+            name,
+            metadata,
+            atom,
+            hash: OnceCell::new(),
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn metadata(&self) -> &webc::metadata::Command {
+        &self.metadata
+    }
+
+    /// Get a reference to this [`BinaryPackageCommand`]'s atom.
+    ///
+    /// The address of the returned slice is guaranteed to be stable and live as
+    /// long as the [`BinaryPackageCommand`].
+    pub fn atom(&self) -> &[u8] {
+        &self.atom
+    }
+
+    pub fn hash(&self) -> &ModuleHash {
+        self.hash.get_or_init(|| ModuleHash::hash(self.atom()))
+    }
+}
+
+/// A WebAssembly package that has been loaded into memory.
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct BinaryPackage {
+    pub package_name: String,
+    pub when_cached: Option<u128>,
+    /// The name of the [`BinaryPackageCommand`] which is this package's
+    /// entrypoint.
+    pub entrypoint_cmd: Option<String>,
+    pub hash: OnceCell<ModuleHash>,
+    pub webc_fs: Arc<dyn FileSystem + Send + Sync>,
+    pub commands: Vec<BinaryPackageCommand>,
+    pub uses: Vec<String>,
+    pub version: Version,
+    pub file_system_memory_footprint: u64,
+}
+
+impl BinaryPackage {
+    /// Load a [`webc::Container`] and all its dependencies into a
+    /// [`BinaryPackage`].
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub async fn from_webc(
+        container: &Container,
+        rt: &(dyn Runtime + Send + Sync),
+    ) -> Result<Self, anyhow::Error> {
+        let source = rt.source();
+        let root = PackageInfo::from_manifest(container.manifest())?;
+        let root_id = PackageId {
+            package_name: root.name.clone(),
+            version: root.version.clone(),
+        };
+
+        let resolution = crate::runtime::resolver::resolve(&root_id, &root, &*source).await?;
+        let pkg = rt
+            .package_loader()
+            .load_package_tree(container, &resolution)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
+
+        Ok(pkg)
+    }
+
+    /// Load a [`BinaryPackage`] and all its dependencies from a registry.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub async fn from_registry(
+        specifier: &PackageSpecifier,
+        runtime: &(dyn Runtime + Send + Sync),
+    ) -> Result<Self, anyhow::Error> {
+        let source = runtime.source();
+        let root_summary =
+            source
+                .latest(specifier)
+                .await
+                .map_err(|error| ResolveError::Registry {
+                    package: specifier.clone(),
+                    error,
+                })?;
+        let root = runtime.package_loader().load(&root_summary).await?;
+        let id = root_summary.package_id();
+
+        let resolution = crate::runtime::resolver::resolve(&id, &root_summary.pkg, &source)
+            .await
+            .context("Dependency resolution failed")?;
+        let pkg = runtime
+            .package_loader()
+            .load_package_tree(&root, &resolution)
+            .await
+            .map_err(|e| anyhow::anyhow!(e))?;
+
+        Ok(pkg)
+    }
+
+    pub fn get_command(&self, name: &str) -> Option<&BinaryPackageCommand> {
+        self.commands.iter().find(|cmd| cmd.name() == name)
+    }
+
+    /// Get the bytes for the entrypoint command.
+    pub fn entrypoint_bytes(&self) -> Option<&[u8]> {
+        self.entrypoint_cmd
+            .as_deref()
+            .and_then(|name| self.get_command(name))
+            .map(|entry| entry.atom())
+    }
+
+    pub fn hash(&self) -> ModuleHash {
+        *self.hash.get_or_init(|| {
+            if let Some(entry) = self.entrypoint_bytes() {
+                ModuleHash::hash(entry)
+            } else {
+                ModuleHash::hash(self.package_name.as_bytes())
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+    use virtual_fs::AsyncReadExt;
+
+    use crate::{
+        runtime::{package_loader::BuiltinPackageLoader, task_manager::VirtualTaskManager},
+        PluggableRuntime,
+    };
+
+    use super::*;
+
+    fn task_manager() -> Arc<dyn VirtualTaskManager + Send + Sync> {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "sys-thread")] {
+                Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::new(tokio::runtime::Handle::current()))
+            } else {
+                unimplemented!("Unable to get the task manager")
+            }
+        }
+    }
+
+    #[tokio::test]
+    #[cfg_attr(
+        not(feature = "sys-thread"),
+        ignore = "The tokio task manager isn't available on this platform"
+    )]
+    async fn fs_table_can_map_directories_to_different_names() {
+        let temp = TempDir::new().unwrap();
+        let wasmer_toml = r#"
+            [package]
+            name = "some/package"
+            version = "0.0.0"
+            description = "a dummy package"
+
+            [fs]
+            "/public" = "./out"
+        "#;
+        let manifest = temp.path().join("wasmer.toml");
+        std::fs::write(&manifest, wasmer_toml).unwrap();
+        let out = temp.path().join("out");
+        std::fs::create_dir_all(&out).unwrap();
+        let file_txt = "Hello, World!";
+        std::fs::write(out.join("file.txt"), file_txt).unwrap();
+        let webc: Container = webc::wasmer_package::Package::from_manifest(manifest)
+            .unwrap()
+            .into();
+        let tasks = task_manager();
+        let mut runtime = PluggableRuntime::new(tasks);
+        runtime.set_package_loader(
+            BuiltinPackageLoader::new()
+                .with_shared_http_client(runtime.http_client().unwrap().clone()),
+        );
+
+        let pkg = BinaryPackage::from_webc(&webc, &runtime).await.unwrap();
+
+        // We should have mapped "./out/file.txt" on the host to
+        // "/public/file.txt" on the guest.
+        let mut f = pkg
+            .webc_fs
+            .new_open_options()
+            .read(true)
+            .open("/public/file.txt")
+            .unwrap();
+        let mut buffer = String::new();
+        f.read_to_string(&mut buffer).await.unwrap();
+        assert_eq!(buffer, file_txt);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/exec.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/exec.rs
new file mode 100644
index 0000000..21829b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/exec.rs
@@ -0,0 +1,346 @@
+use std::{pin::Pin, sync::Arc};
+
+use crate::{
+    os::task::{
+        thread::{RewindResultType, WasiThreadRunGuard},
+        TaskJoinHandle,
+    },
+    runtime::{
+        task_manager::{
+            TaskWasm, TaskWasmRecycle, TaskWasmRecycleProperties, TaskWasmRunProperties,
+        },
+        TaintReason,
+    },
+    syscalls::rewind_ext,
+    RewindState, SpawnError, WasiError, WasiRuntimeError,
+};
+use futures::Future;
+use tracing::*;
+use wasmer::{Function, FunctionEnvMut, Memory32, Memory64, Module, Store};
+use wasmer_wasix_types::wasi::Errno;
+
+use super::{BinFactory, BinaryPackage};
+use crate::{Runtime, WasiEnv, WasiFunctionEnv};
+
+#[tracing::instrument(level = "trace", skip_all, fields(%name, %binary.package_name))]
+pub async fn spawn_exec(
+    binary: BinaryPackage,
+    name: &str,
+    _store: Store,
+    env: WasiEnv,
+    runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
+) -> Result<TaskJoinHandle, SpawnError> {
+    let wasm = if let Some(cmd) = binary.get_command(name) {
+        cmd.atom.as_ref()
+    } else if let Some(wasm) = binary.entrypoint_bytes() {
+        wasm
+    } else {
+        tracing::error!(
+          command=name,
+          pkg.name=%binary.package_name,
+          pkg.version=%binary.version,
+          "Unable to spawn a command because its package has no entrypoint",
+        );
+        env.on_exit(Some(Errno::Noexec.into())).await;
+        return Err(SpawnError::CompileError);
+    };
+
+    let module = match runtime.load_module(wasm).await {
+        Ok(module) => module,
+        Err(err) => {
+            tracing::error!(
+                command = name,
+                error = &*err,
+                "Failed to compile the module",
+            );
+            env.on_exit(Some(Errno::Noexec.into())).await;
+            return Err(SpawnError::CompileError);
+        }
+    };
+
+    // If the file system has not already been union'ed then do so
+    env.state
+        .fs
+        .conditional_union(&binary)
+        .await
+        .map_err(|err| {
+            tracing::warn!("failed to union file system - {err}");
+            SpawnError::FileSystemError
+        })?;
+    tracing::debug!("{:?}", env.state.fs);
+
+    // Now run the module
+    spawn_exec_module(module, env, runtime)
+}
+
+pub fn spawn_exec_module(
+    module: Module,
+    env: WasiEnv,
+    runtime: &Arc<dyn Runtime + Send + Sync + 'static>,
+) -> Result<TaskJoinHandle, SpawnError> {
+    // Create a new task manager
+    let tasks = runtime.task_manager();
+
+    // Create the signaler
+    let pid = env.pid();
+
+    let join_handle = env.thread.join_handle();
+    {
+        // Create a thread that will run this process
+        let tasks_outer = tasks.clone();
+
+        tasks_outer
+            .task_wasm(TaskWasm::new(Box::new(run_exec), env, module, true))
+            .map_err(|err| {
+                error!("wasi[{}]::failed to launch module - {}", pid, err);
+                SpawnError::UnknownError
+            })?
+    };
+
+    Ok(join_handle)
+}
+
+/// # SAFETY
+/// This must be executed from the same thread that owns the instance as
+/// otherwise it will cause a panic
+unsafe fn run_recycle(
+    callback: Option<Box<TaskWasmRecycle>>,
+    ctx: WasiFunctionEnv,
+    mut store: Store,
+) {
+    if let Some(callback) = callback {
+        let env = ctx.data_mut(&mut store);
+        let memory = env.memory().clone();
+
+        let props = TaskWasmRecycleProperties {
+            env: env.clone(),
+            memory,
+            store,
+        };
+        callback(props);
+    }
+}
+
+pub fn run_exec(props: TaskWasmRunProperties) {
+    let ctx = props.ctx;
+    let mut store = props.store;
+
+    // Create the WasiFunctionEnv
+    let thread = WasiThreadRunGuard::new(ctx.data(&store).thread.clone());
+    let recycle = props.recycle;
+
+    // Perform the initialization
+    let ctx = {
+        // If this module exports an _initialize function, run that first.
+        if let Ok(initialize) = unsafe { ctx.data(&store).inner() }
+            .instance
+            .exports
+            .get_function("_initialize")
+        {
+            let initialize = initialize.clone();
+            if let Err(err) = initialize.call(&mut store, &[]) {
+                thread.thread.set_status_finished(Err(err.into()));
+                ctx.data(&store)
+                    .blocking_on_exit(Some(Errno::Noexec.into()));
+                unsafe { run_recycle(recycle, ctx, store) };
+                return;
+            }
+        }
+
+        WasiFunctionEnv { env: ctx.env }
+    };
+
+    // Bootstrap the process
+    // Unsafe: The bootstrap must be executed in the same thread that runs the
+    //         actual WASM code
+    let rewind_state = match unsafe { ctx.bootstrap(&mut store) } {
+        Ok(r) => r,
+        Err(err) => {
+            tracing::warn!("failed to bootstrap - {}", err);
+            thread.thread.set_status_finished(Err(err));
+            ctx.data(&store)
+                .blocking_on_exit(Some(Errno::Noexec.into()));
+            unsafe { run_recycle(recycle, ctx, store) };
+            return;
+        }
+    };
+
+    // If there is a start function
+    debug!("wasi[{}]::called main()", ctx.data(&store).pid());
+    // TODO: rewrite to use crate::run_wasi_func
+
+    // Call the module
+    call_module(ctx, store, thread, rewind_state, recycle);
+}
+
+fn get_start(ctx: &WasiFunctionEnv, store: &Store) -> Option<Function> {
+    unsafe { ctx.data(store).inner() }
+        .instance
+        .exports
+        .get_function("_start")
+        .map(|a| a.clone())
+        .ok()
+}
+
+/// Calls the module
+fn call_module(
+    ctx: WasiFunctionEnv,
+    mut store: Store,
+    handle: WasiThreadRunGuard,
+    rewind_state: Option<(RewindState, RewindResultType)>,
+    recycle: Option<Box<TaskWasmRecycle>>,
+) {
+    let env = ctx.data(&store);
+    let pid = env.pid();
+    let tasks = env.tasks().clone();
+    handle.thread.set_status_running();
+    let runtime = env.runtime.clone();
+
+    // If we need to rewind then do so
+    if let Some((rewind_state, rewind_result)) = rewind_state {
+        let mut ctx = ctx.env.clone().into_mut(&mut store);
+        if rewind_state.is_64bit {
+            let res = rewind_ext::<Memory64>(
+                &mut ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            );
+            if res != Errno::Success {
+                ctx.data().blocking_on_exit(Some(res.into()));
+                unsafe { run_recycle(recycle, WasiFunctionEnv { env: ctx.as_ref() }, store) };
+                return;
+            }
+        } else {
+            let res = rewind_ext::<Memory32>(
+                &mut ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            );
+            if res != Errno::Success {
+                ctx.data().blocking_on_exit(Some(res.into()));
+                unsafe { run_recycle(recycle, WasiFunctionEnv { env: ctx.as_ref() }, store) };
+                return;
+            }
+        };
+    }
+
+    // Invoke the start function
+    let ret = {
+        // Call the module
+        let call_ret = if let Some(start) = get_start(&ctx, &store) {
+            start.call(&mut store, &[])
+        } else {
+            debug!("wasi[{}]::exec-failed: missing _start function", pid);
+            ctx.data(&store)
+                .blocking_on_exit(Some(Errno::Noexec.into()));
+            unsafe { run_recycle(recycle, ctx, store) };
+            return;
+        };
+
+        if let Err(err) = call_ret {
+            match err.downcast::<WasiError>() {
+                Ok(WasiError::Exit(code)) if code.is_success() => Ok(Errno::Success),
+                Ok(WasiError::Exit(code)) => {
+                    runtime.on_taint(TaintReason::NonZeroExitCode(code));
+                    Err(WasiError::Exit(code).into())
+                }
+                Ok(WasiError::DeepSleep(deep)) => {
+                    // Create the callback that will be invoked when the thread respawns after a deep sleep
+                    let rewind = deep.rewind;
+                    let respawn = {
+                        move |ctx, store, rewind_result| {
+                            // Call the thread
+                            call_module(
+                                ctx,
+                                store,
+                                handle,
+                                Some((rewind, RewindResultType::RewindWithResult(rewind_result))),
+                                recycle,
+                            );
+                        }
+                    };
+
+                    // Spawns the WASM process after a trigger
+                    if let Err(err) = unsafe {
+                        tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
+                    } {
+                        debug!("failed to go into deep sleep - {}", err);
+                    }
+                    return;
+                }
+                Ok(WasiError::UnknownWasiVersion) => {
+                    debug!("failed as wasi version is unknown",);
+                    runtime.on_taint(TaintReason::UnknownWasiVersion);
+                    Ok(Errno::Noexec)
+                }
+                Err(err) => {
+                    runtime.on_taint(TaintReason::RuntimeError(err.clone()));
+                    Err(WasiRuntimeError::from(err))
+                }
+            }
+        } else {
+            Ok(Errno::Success)
+        }
+    };
+
+    let code = if let Err(err) = &ret {
+        err.as_exit_code().unwrap_or_else(|| Errno::Noexec.into())
+    } else {
+        Errno::Success.into()
+    };
+
+    // Cleanup the environment
+    ctx.data(&store).blocking_on_exit(Some(code));
+    unsafe { run_recycle(recycle, ctx, store) };
+
+    debug!("wasi[{pid}]::main() has exited with {code}");
+    handle.thread.set_status_finished(ret.map(|a| a.into()));
+}
+
+impl BinFactory {
+    pub fn spawn<'a>(
+        &'a self,
+        name: String,
+        store: Store,
+        env: WasiEnv,
+    ) -> Pin<Box<dyn Future<Output = Result<TaskJoinHandle, SpawnError>> + 'a>> {
+        Box::pin(async move {
+            // Find the binary (or die trying) and make the spawn type
+            let binary = self
+                .get_binary(name.as_str(), Some(env.fs_root()))
+                .await
+                .ok_or(SpawnError::NotFound);
+            if binary.is_err() {
+                env.on_exit(Some(Errno::Noent.into())).await;
+            }
+            let binary = binary?;
+
+            // Execute
+            spawn_exec(binary, name.as_str(), store, env, &self.runtime).await
+        })
+    }
+
+    pub fn try_built_in(
+        &self,
+        name: String,
+        parent_ctx: Option<&FunctionEnvMut<'_, WasiEnv>>,
+        store: &mut Option<Store>,
+        builder: &mut Option<WasiEnv>,
+    ) -> Result<TaskJoinHandle, SpawnError> {
+        // We check for built in commands
+        if let Some(parent_ctx) = parent_ctx {
+            if self.commands.exists(name.as_str()) {
+                return self
+                    .commands
+                    .exec(parent_ctx, name.as_str(), store, builder);
+            }
+        } else if self.commands.exists(name.as_str()) {
+            tracing::warn!("builtin command without a parent ctx - {}", name);
+        }
+        Err(SpawnError::NotFound)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/mod.rs
new file mode 100644
index 0000000..9a08d7d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/bin_factory/mod.rs
@@ -0,0 +1,117 @@
+use std::{
+    collections::HashMap,
+    ops::Deref,
+    path::Path,
+    sync::{Arc, RwLock},
+};
+
+use anyhow::Context;
+use virtual_fs::{AsyncReadExt, FileSystem};
+use webc::Container;
+
+mod binary_package;
+mod exec;
+
+pub use self::{
+    binary_package::*,
+    exec::{run_exec, spawn_exec, spawn_exec_module},
+};
+use crate::{os::command::Commands, Runtime};
+
+#[derive(Debug, Clone)]
+pub struct BinFactory {
+    pub(crate) commands: Commands,
+    runtime: Arc<dyn Runtime + Send + Sync + 'static>,
+    pub(crate) local: Arc<RwLock<HashMap<String, Option<BinaryPackage>>>>,
+}
+
+impl BinFactory {
+    pub fn new(runtime: Arc<dyn Runtime + Send + Sync + 'static>) -> BinFactory {
+        BinFactory {
+            commands: Commands::new_with_builtins(runtime.clone()),
+            runtime,
+            local: Arc::new(RwLock::new(HashMap::new())),
+        }
+    }
+
+    pub fn runtime(&self) -> &(dyn Runtime + Send + Sync) {
+        self.runtime.deref()
+    }
+
+    pub fn set_binary(&self, name: &str, binary: BinaryPackage) {
+        let mut cache = self.local.write().unwrap();
+        cache.insert(name.to_string(), Some(binary));
+    }
+
+    // TODO: remove allow once BinFactory is refactored
+    // currently fine because a BinFactory is only used by a single process tree
+    #[allow(clippy::await_holding_lock)]
+    pub async fn get_binary(
+        &self,
+        name: &str,
+        fs: Option<&dyn FileSystem>,
+    ) -> Option<BinaryPackage> {
+        let name = name.to_string();
+
+        // Fast path
+        {
+            let cache = self.local.read().unwrap();
+            if let Some(data) = cache.get(&name) {
+                return data.clone();
+            }
+        }
+
+        // Slow path
+        let mut cache = self.local.write().unwrap();
+
+        // Check the cache
+        if let Some(data) = cache.get(&name) {
+            return data.clone();
+        }
+
+        // Check the filesystem for the file
+        if name.starts_with('/') {
+            if let Some(fs) = fs {
+                match load_package_from_filesystem(fs, name.as_ref(), self.runtime()).await {
+                    Ok(pkg) => {
+                        cache.insert(name, Some(pkg.clone()));
+                        return Some(pkg);
+                    }
+                    Err(e) => {
+                        tracing::warn!(
+                            path = name,
+                            error = &*e,
+                            "Unable to load the package from disk"
+                        );
+                    }
+                }
+            }
+        }
+
+        // NAK
+        cache.insert(name, None);
+        None
+    }
+}
+
+async fn load_package_from_filesystem(
+    fs: &dyn FileSystem,
+    path: &Path,
+    rt: &(dyn Runtime + Send + Sync),
+) -> Result<BinaryPackage, anyhow::Error> {
+    let mut f = fs
+        .new_open_options()
+        .read(true)
+        .open(path)
+        .context("Unable to open the file")?;
+
+    let mut data = Vec::with_capacity(f.size() as usize);
+    f.read_to_end(&mut data).await.context("Read failed")?;
+
+    let container = Container::from_bytes(data).context("Unable to parse the WEBC file")?;
+    let pkg = BinaryPackage::from_webc(&container, rt)
+        .await
+        .context("Unable to load the package")?;
+
+    Ok(pkg)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/capabilities.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/capabilities.rs
new file mode 100644
index 0000000..fae47fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/capabilities.rs
@@ -0,0 +1,74 @@
+use std::time::Duration;
+
+use crate::http::HttpClientCapabilityV1;
+
+/// Defines capabilities for a Wasi environment.
+#[derive(Clone, Debug)]
+pub struct Capabilities {
+    pub insecure_allow_all: bool,
+    pub http_client: HttpClientCapabilityV1,
+    pub threading: CapabilityThreadingV1,
+}
+
+impl Capabilities {
+    pub fn new() -> Self {
+        Self {
+            insecure_allow_all: false,
+            http_client: Default::default(),
+            threading: Default::default(),
+        }
+    }
+
+    /// Merges another [`Capabilities`] object into this one, overwriting fields
+    /// if necessary.
+    pub fn update(&mut self, other: Capabilities) {
+        let Capabilities {
+            insecure_allow_all,
+            http_client,
+            threading,
+        } = other;
+        self.insecure_allow_all |= insecure_allow_all;
+        self.http_client.update(http_client);
+        self.threading.update(threading);
+    }
+}
+
+impl Default for Capabilities {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Defines threading related permissions.
+#[derive(Debug, Default, Clone)]
+pub struct CapabilityThreadingV1 {
+    /// Maximum number of threads that can be spawned.
+    ///
+    /// [`None`] means no limit.
+    pub max_threads: Option<usize>,
+
+    /// Flag that indicates if asynchronous threading is disabled
+    /// (default = false)
+    pub enable_asynchronous_threading: bool,
+
+    /// Enables an exponential backoff of the process CPU usage when there
+    /// are no active run tokens (when set holds the maximum amount of
+    /// time that it will pause the CPU)
+    /// (default = off)
+    pub enable_exponential_cpu_backoff: Option<Duration>,
+}
+
+impl CapabilityThreadingV1 {
+    pub fn update(&mut self, other: CapabilityThreadingV1) {
+        let CapabilityThreadingV1 {
+            max_threads,
+            enable_asynchronous_threading,
+            enable_exponential_cpu_backoff,
+        } = other;
+        self.enable_asynchronous_threading |= enable_asynchronous_threading;
+        if let Some(val) = enable_exponential_cpu_backoff {
+            self.enable_exponential_cpu_backoff = Some(val);
+        }
+        self.max_threads = max_threads.or(self.max_threads);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/fd.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/fd.rs
new file mode 100644
index 0000000..06909f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/fd.rs
@@ -0,0 +1,225 @@
+use std::{
+    borrow::Cow,
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    pin::Pin,
+    sync::{atomic::AtomicU64, Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    task::Context,
+};
+
+use futures::Future;
+use serde_derive::{Deserialize, Serialize};
+use std::sync::Mutex as StdMutex;
+use tokio::sync::{watch, Mutex as AsyncMutex};
+use virtual_fs::{Pipe, VirtualFile};
+use wasmer_wasix_types::wasi::{EpollType, Fd as WasiFd, Fdflags, Filestat, Rights};
+
+use crate::{net::socket::InodeSocket, syscalls::EpollJoinWaker};
+
+use super::{
+    InodeGuard, InodeValFilePollGuard, InodeValFilePollGuardJoin, InodeValFilePollGuardMode,
+    InodeWeakGuard, NotificationInner,
+};
+
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Fd {
+    pub rights: Rights,
+    pub rights_inheriting: Rights,
+    pub flags: Fdflags,
+    pub offset: Arc<AtomicU64>,
+    /// Flags that determine how the [`Fd`] can be used.
+    ///
+    /// Used when reopening a [`VirtualFile`] during deserialization.
+    pub open_flags: u16,
+    pub inode: InodeGuard,
+    pub is_stdio: bool,
+}
+
+impl Fd {
+    /// This [`Fd`] can be used with read system calls.
+    pub const READ: u16 = 1;
+    /// This [`Fd`] can be used with write system calls.
+    pub const WRITE: u16 = 2;
+    /// This [`Fd`] can append in write system calls. Note that the append
+    /// permission implies the write permission.
+    pub const APPEND: u16 = 4;
+    /// This [`Fd`] will delete everything before writing. Note that truncate
+    /// permissions require the write permission.
+    ///
+    /// This permission is currently unused when deserializing.
+    pub const TRUNCATE: u16 = 8;
+    /// This [`Fd`] may create a file before writing to it. Note that create
+    /// permissions require write permissions.
+    ///
+    /// This permission is currently unused when deserializing.
+    pub const CREATE: u16 = 16;
+}
+
+/// A file that Wasi knows about that may or may not be open
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct InodeVal {
+    pub stat: RwLock<Filestat>,
+    pub is_preopened: bool,
+    pub name: Cow<'static, str>,
+    pub kind: RwLock<Kind>,
+}
+
+impl InodeVal {
+    pub fn read(&self) -> RwLockReadGuard<Kind> {
+        self.kind.read().unwrap()
+    }
+
+    pub fn write(&self) -> RwLockWriteGuard<Kind> {
+        self.kind.write().unwrap()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EpollFd {
+    /// The events we are polling on
+    pub events: EpollType,
+    /// Pointer to the user data
+    pub ptr: u64,
+    /// File descriptor we are polling on
+    pub fd: WasiFd,
+    /// Associated user data
+    pub data1: u32,
+    /// Associated user data
+    pub data2: u64,
+}
+
+/// Represents all the EpollInterests that have occurred
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct EpollInterest {
+    /// Using a hash set prevents the same interest from
+    /// being triggered more than once
+    pub interest: HashSet<(WasiFd, EpollType)>,
+}
+
+/// Guard the cleans up the selector registrations
+#[derive(Debug)]
+pub enum EpollJoinGuard {
+    Join {
+        join_guard: InodeValFilePollGuardJoin,
+        epoll_waker: Arc<EpollJoinWaker>,
+    },
+    Handler {
+        fd_guard: InodeValFilePollGuard,
+    },
+}
+impl Drop for EpollJoinGuard {
+    fn drop(&mut self) {
+        if let Self::Handler { fd_guard, .. } = self {
+            if let InodeValFilePollGuardMode::Socket { inner } = &mut fd_guard.mode {
+                let mut inner = inner.protected.write().unwrap();
+                inner.remove_handler();
+            }
+        }
+    }
+}
+impl EpollJoinGuard {
+    pub fn is_spent(&self) -> bool {
+        match self {
+            Self::Join { join_guard, .. } => join_guard.is_spent(),
+            Self::Handler { .. } => false,
+        }
+    }
+    pub fn renew(&mut self) {
+        if let Self::Join {
+            join_guard,
+            epoll_waker,
+        } = self
+        {
+            let fd = join_guard.fd();
+            join_guard.reset();
+
+            let waker = epoll_waker.as_waker();
+            let mut cx = Context::from_waker(&waker);
+            if Pin::new(join_guard).poll(&mut cx).is_ready() {
+                tracing::trace!(fd, "join renew already woken");
+                waker.wake();
+            } else {
+                tracing::trace!(fd, "join waker reinstalled");
+            }
+        }
+    }
+}
+
+pub type EpollSubscriptions = HashMap<WasiFd, (EpollFd, Vec<EpollJoinGuard>)>;
+
+/// The core of the filesystem abstraction.  Includes directories,
+/// files, and symlinks.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Kind {
+    File {
+        /// The open file, if it's open
+        #[cfg_attr(feature = "enable-serde", serde(skip))]
+        handle: Option<Arc<RwLock<Box<dyn VirtualFile + Send + Sync + 'static>>>>,
+        /// The path on the host system where the file is located
+        /// This is deprecated and will be removed soon
+        path: PathBuf,
+        /// Marks the file as a special file that only one `fd` can exist for
+        /// This is useful when dealing with host-provided special files that
+        /// should be looked up by path
+        /// TOOD: clarify here?
+        fd: Option<u32>,
+    },
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    Socket {
+        /// Represents a networking socket
+        socket: InodeSocket,
+    },
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    Pipe {
+        /// Reference to the pipe
+        pipe: Pipe,
+    },
+    Epoll {
+        // List of events we are polling on
+        subscriptions: Arc<StdMutex<EpollSubscriptions>>,
+        // Notification pipeline for sending events
+        tx: Arc<watch::Sender<EpollInterest>>,
+        // Notification pipeline for events that need to be
+        // checked on the next wait
+        rx: Arc<AsyncMutex<watch::Receiver<EpollInterest>>>,
+    },
+    Dir {
+        /// Parent directory
+        parent: InodeWeakGuard,
+        /// The path on the host system where the directory is located
+        // TODO: wrap it like VirtualFile
+        path: PathBuf,
+        /// The entries of a directory are lazily filled.
+        entries: HashMap<String, InodeGuard>,
+    },
+    /// The same as Dir but without the irrelevant bits
+    /// The root is immutable after creation; generally the Kind::Root
+    /// branch of whatever code you're writing will be a simpler version of
+    /// your Kind::Dir logic
+    Root {
+        entries: HashMap<String, InodeGuard>,
+    },
+    /// The first two fields are data _about_ the symlink
+    /// the last field is the data _inside_ the symlink
+    ///
+    /// `base_po_dir` should never be the root because:
+    /// - Right now symlinks are not allowed in the immutable root
+    /// - There is always a closer pre-opened dir to the symlink file (by definition of the root being a collection of preopened dirs)
+    Symlink {
+        /// The preopened dir that this symlink file is relative to (via `path_to_symlink`)
+        base_po_dir: WasiFd,
+        /// The path to the symlink from the `base_po_dir`
+        path_to_symlink: PathBuf,
+        /// the value of the symlink as a relative path
+        relative_path: PathBuf,
+    },
+    Buffer {
+        buffer: Vec<u8>,
+    },
+    EventNotifications {
+        inner: Arc<NotificationInner>,
+    },
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/inode_guard.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/inode_guard.rs
new file mode 100644
index 0000000..c944b9d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/inode_guard.rs
@@ -0,0 +1,673 @@
+use std::{
+    future::Future,
+    io::{IoSlice, SeekFrom},
+    ops::{Deref, DerefMut},
+    pin::Pin,
+    sync::{Arc, RwLock},
+    task::{Context, Poll},
+};
+
+use tokio::io::{AsyncRead, AsyncSeek, AsyncWrite};
+use virtual_fs::{FsError, Pipe as VirtualPipe, VirtualFile};
+use wasmer_wasix_types::{
+    types::Eventtype,
+    wasi::{self, EpollType},
+    wasi::{Errno, EventFdReadwrite, Eventrwflags, Subscription},
+};
+
+use super::{notification::NotificationInner, InodeGuard, Kind};
+use crate::{
+    net::socket::{InodeSocketInner, InodeSocketKind},
+    state::{iterate_poll_events, PollEvent, PollEventSet, WasiState},
+    syscalls::{map_io_err, EventResult, EventResultType},
+    utils::{OwnedRwLockReadGuard, OwnedRwLockWriteGuard},
+};
+
+#[derive(Debug, Clone)]
+pub(crate) enum InodeValFilePollGuardMode {
+    File(Arc<RwLock<Box<dyn VirtualFile + Send + Sync + 'static>>>),
+    EventNotifications(Arc<NotificationInner>),
+    Socket { inner: Arc<InodeSocketInner> },
+    Pipe { pipe: Arc<RwLock<Box<VirtualPipe>>> },
+}
+
+pub struct InodeValFilePollGuard {
+    pub(crate) fd: u32,
+    pub(crate) peb: PollEventSet,
+    pub(crate) subscription: Subscription,
+    pub(crate) mode: InodeValFilePollGuardMode,
+}
+
+impl InodeValFilePollGuard {
+    pub(crate) fn new(
+        fd: u32,
+        peb: PollEventSet,
+        subscription: Subscription,
+        guard: &Kind,
+    ) -> Option<Self> {
+        let mode = match guard {
+            Kind::EventNotifications { inner, .. } => {
+                InodeValFilePollGuardMode::EventNotifications(inner.clone())
+            }
+            Kind::Socket { socket, .. } => InodeValFilePollGuardMode::Socket {
+                inner: socket.inner.clone(),
+            },
+            Kind::File {
+                handle: Some(handle),
+                ..
+            } => InodeValFilePollGuardMode::File(handle.clone()),
+            Kind::Pipe { pipe, .. } => InodeValFilePollGuardMode::Pipe {
+                pipe: Arc::new(RwLock::new(Box::new(pipe.clone()))),
+            },
+            _ => {
+                return None;
+            }
+        };
+        Some(Self {
+            fd,
+            mode,
+            peb,
+            subscription,
+        })
+    }
+}
+
+impl std::fmt::Debug for InodeValFilePollGuard {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self.mode {
+            InodeValFilePollGuardMode::File(..) => {
+                write!(f, "guard-file(fd={}, peb={})", self.fd, self.peb)
+            }
+            InodeValFilePollGuardMode::EventNotifications { .. } => {
+                write!(f, "guard-notifications(fd={}, peb={})", self.fd, self.peb)
+            }
+            InodeValFilePollGuardMode::Socket { inner } => {
+                let inner = inner.protected.read().unwrap();
+                match inner.kind {
+                    InodeSocketKind::TcpListener { .. } => {
+                        write!(f, "guard-tcp-listener(fd={}, peb={})", self.fd, self.peb)
+                    }
+                    InodeSocketKind::TcpStream { ref socket, .. } => {
+                        if socket.is_closed() {
+                            write!(
+                                f,
+                                "guard-tcp-stream (closed, fd={}, peb={})",
+                                self.fd, self.peb
+                            )
+                        } else {
+                            write!(f, "guard-tcp-stream(fd={}, peb={})", self.fd, self.peb)
+                        }
+                    }
+                    InodeSocketKind::UdpSocket { .. } => {
+                        write!(f, "guard-udp-socket(fd={}, peb={})", self.fd, self.peb)
+                    }
+                    InodeSocketKind::Raw(..) => {
+                        write!(f, "guard-raw-socket(fd={}, peb={})", self.fd, self.peb)
+                    }
+                    _ => write!(f, "guard-socket(fd={}), peb={})", self.fd, self.peb),
+                }
+            }
+            InodeValFilePollGuardMode::Pipe { .. } => {
+                write!(f, "guard-pipe(...)")
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct InodeValFilePollGuardJoin {
+    mode: InodeValFilePollGuardMode,
+    fd: u32,
+    peb: PollEventSet,
+    subscription: Subscription,
+    spent: bool,
+}
+
+impl InodeValFilePollGuardJoin {
+    pub(crate) fn new(guard: InodeValFilePollGuard) -> Self {
+        Self {
+            mode: guard.mode,
+            fd: guard.fd,
+            peb: guard.peb,
+            subscription: guard.subscription,
+            spent: false,
+        }
+    }
+    pub(crate) fn fd(&self) -> u32 {
+        self.fd
+    }
+    pub(crate) fn peb(&self) -> PollEventSet {
+        self.peb
+    }
+    pub fn is_spent(&self) -> bool {
+        self.spent
+    }
+    pub fn reset(&mut self) {
+        match &self.mode {
+            InodeValFilePollGuardMode::File(_) => {}
+            InodeValFilePollGuardMode::EventNotifications(inner) => {
+                inner.reset();
+            }
+            InodeValFilePollGuardMode::Socket { .. } => {}
+            InodeValFilePollGuardMode::Pipe { .. } => {}
+        }
+        self.spent = false;
+    }
+}
+
+pub const POLL_GUARD_MAX_RET: usize = 4;
+
+impl Future for InodeValFilePollGuardJoin {
+    type Output = heapless::Vec<(EventResult, EpollType), POLL_GUARD_MAX_RET>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
+        // Otherwise we need to register for the event
+        let waker = cx.waker();
+        let mut has_read = false;
+        let mut has_write = false;
+        let mut has_close = false;
+        let mut has_hangup = false;
+
+        let mut ret = heapless::Vec::new();
+        for in_event in iterate_poll_events(self.peb) {
+            match in_event {
+                PollEvent::PollIn => {
+                    has_read = true;
+                }
+                PollEvent::PollOut => {
+                    has_write = true;
+                }
+                PollEvent::PollHangUp => {
+                    has_hangup = true;
+                    has_close = true;
+                }
+                PollEvent::PollError | PollEvent::PollInvalid => {
+                    if !has_hangup {
+                        has_close = true;
+                    }
+                }
+            }
+        }
+        if has_read {
+            let poll_result = match &mut self.mode {
+                InodeValFilePollGuardMode::File(file) => {
+                    let mut guard = file.write().unwrap();
+                    let file = Pin::new(guard.as_mut());
+                    file.poll_read_ready(cx)
+                }
+                InodeValFilePollGuardMode::EventNotifications(inner) => inner.poll(waker).map(Ok),
+                InodeValFilePollGuardMode::Socket { ref inner } => {
+                    let mut guard = inner.protected.write().unwrap();
+                    guard.poll_read_ready(cx)
+                }
+                InodeValFilePollGuardMode::Pipe { pipe } => {
+                    let mut guard = pipe.write().unwrap();
+                    let pipe = Pin::new(guard.as_mut());
+                    pipe.poll_read_ready(cx)
+                }
+            };
+            match poll_result {
+                Poll::Ready(Err(err)) if has_close && is_err_closed(&err) => {
+                    let inner = match self.subscription.type_ {
+                        Eventtype::FdRead | Eventtype::FdWrite => {
+                            Some(EventResultType::Fd(EventFdReadwrite {
+                                nbytes: 0,
+                                flags: if has_hangup {
+                                    Eventrwflags::FD_READWRITE_HANGUP
+                                } else {
+                                    Eventrwflags::empty()
+                                },
+                            }))
+                        }
+                        Eventtype::Clock => Some(EventResultType::Clock(0)),
+                        Eventtype::Unknown => None,
+                    };
+                    if let Some(inner) = inner {
+                        ret.push((
+                            EventResult {
+                                userdata: self.subscription.userdata,
+                                error: Errno::Success,
+                                type_: self.subscription.type_,
+                                inner,
+                            },
+                            EpollType::EPOLLHUP,
+                        ))
+                        .ok();
+                    }
+                }
+                Poll::Ready(bytes_available) => {
+                    let mut error = Errno::Success;
+                    let bytes_available = match bytes_available {
+                        Ok(a) => a,
+                        Err(e) => {
+                            error = map_io_err(e);
+                            0
+                        }
+                    };
+                    let inner = match self.subscription.type_ {
+                        Eventtype::FdRead | Eventtype::FdWrite => {
+                            Some(EventResultType::Fd(EventFdReadwrite {
+                                nbytes: bytes_available as u64,
+                                flags: if bytes_available == 0 {
+                                    Eventrwflags::FD_READWRITE_HANGUP
+                                } else {
+                                    Eventrwflags::empty()
+                                },
+                            }))
+                        }
+                        Eventtype::Clock => Some(EventResultType::Clock(0)),
+                        Eventtype::Unknown => None,
+                    };
+                    if let Some(inner) = inner {
+                        ret.push((
+                            EventResult {
+                                userdata: self.subscription.userdata,
+                                error,
+                                type_: self.subscription.type_,
+                                inner,
+                            },
+                            if error == Errno::Success {
+                                EpollType::EPOLLIN
+                            } else {
+                                EpollType::EPOLLERR
+                            },
+                        ))
+                        .ok();
+                    }
+                }
+                Poll::Pending => {}
+            };
+        }
+        if has_write {
+            let poll_result = match &mut self.mode {
+                InodeValFilePollGuardMode::File(file) => {
+                    let mut guard = file.write().unwrap();
+                    let file = Pin::new(guard.as_mut());
+                    file.poll_write_ready(cx)
+                }
+                InodeValFilePollGuardMode::EventNotifications(inner) => inner.poll(waker).map(Ok),
+                InodeValFilePollGuardMode::Socket { ref inner } => {
+                    let mut guard = inner.protected.write().unwrap();
+                    guard.poll_write_ready(cx)
+                }
+                InodeValFilePollGuardMode::Pipe { pipe } => {
+                    let mut guard = pipe.write().unwrap();
+                    let pipe = Pin::new(guard.as_mut());
+                    pipe.poll_write_ready(cx)
+                }
+            };
+            match poll_result {
+                Poll::Ready(Err(err)) if has_close && is_err_closed(&err) => {
+                    let inner = match self.subscription.type_ {
+                        Eventtype::FdRead | Eventtype::FdWrite => {
+                            Some(EventResultType::Fd(EventFdReadwrite {
+                                nbytes: 0,
+                                flags: if has_hangup {
+                                    Eventrwflags::FD_READWRITE_HANGUP
+                                } else {
+                                    Eventrwflags::empty()
+                                },
+                            }))
+                        }
+                        Eventtype::Clock => Some(EventResultType::Clock(0)),
+                        Eventtype::Unknown => None,
+                    };
+                    if let Some(inner) = inner {
+                        ret.push((
+                            EventResult {
+                                userdata: self.subscription.userdata,
+                                error: Errno::Success,
+                                type_: self.subscription.type_,
+                                inner,
+                            },
+                            EpollType::EPOLLHUP,
+                        ))
+                        .ok();
+                    }
+                }
+                Poll::Ready(bytes_available) => {
+                    let mut error = Errno::Success;
+                    let bytes_available = match bytes_available {
+                        Ok(a) => a,
+                        Err(e) => {
+                            error = map_io_err(e);
+                            0
+                        }
+                    };
+                    let inner = match self.subscription.type_ {
+                        Eventtype::FdRead | Eventtype::FdWrite => {
+                            Some(EventResultType::Fd(EventFdReadwrite {
+                                nbytes: bytes_available as u64,
+                                flags: if bytes_available == 0 {
+                                    Eventrwflags::FD_READWRITE_HANGUP
+                                } else {
+                                    Eventrwflags::empty()
+                                },
+                            }))
+                        }
+                        Eventtype::Clock => Some(EventResultType::Clock(0)),
+                        Eventtype::Unknown => None,
+                    };
+                    if let Some(inner) = inner {
+                        ret.push((
+                            EventResult {
+                                userdata: self.subscription.userdata,
+                                error,
+                                type_: self.subscription.type_,
+                                inner,
+                            },
+                            if error == Errno::Success {
+                                EpollType::EPOLLOUT
+                            } else {
+                                EpollType::EPOLLERR
+                            },
+                        ))
+                        .ok();
+                    }
+                }
+                Poll::Pending => {}
+            };
+        }
+        if !ret.is_empty() {
+            self.spent = true;
+            return Poll::Ready(ret);
+        }
+        Poll::Pending
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct InodeValFileReadGuard {
+    guard: OwnedRwLockReadGuard<Box<dyn VirtualFile + Send + Sync + 'static>>,
+}
+
+impl InodeValFileReadGuard {
+    pub(crate) fn new(file: &Arc<RwLock<Box<dyn VirtualFile + Send + Sync + 'static>>>) -> Self {
+        Self {
+            guard: crate::utils::read_owned(file).unwrap(),
+        }
+    }
+}
+
+impl InodeValFileReadGuard {
+    pub fn into_poll_guard(
+        self,
+        fd: u32,
+        peb: PollEventSet,
+        subscription: Subscription,
+    ) -> InodeValFilePollGuard {
+        InodeValFilePollGuard {
+            fd,
+            peb,
+            subscription,
+            mode: InodeValFilePollGuardMode::File(self.guard.into_inner()),
+        }
+    }
+}
+
+impl Deref for InodeValFileReadGuard {
+    type Target = dyn VirtualFile + Send + Sync + 'static;
+    fn deref(&self) -> &Self::Target {
+        self.guard.deref().deref()
+    }
+}
+
+#[derive(Debug)]
+pub struct InodeValFileWriteGuard {
+    guard: OwnedRwLockWriteGuard<Box<dyn VirtualFile + Send + Sync + 'static>>,
+}
+
+impl InodeValFileWriteGuard {
+    pub(crate) fn new(file: &Arc<RwLock<Box<dyn VirtualFile + Send + Sync + 'static>>>) -> Self {
+        Self {
+            guard: crate::utils::write_owned(file).unwrap(),
+        }
+    }
+    pub(crate) fn swap(
+        &mut self,
+        mut file: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> Box<dyn VirtualFile + Send + Sync + 'static> {
+        std::mem::swap(self.guard.deref_mut(), &mut file);
+        file
+    }
+}
+
+impl Deref for InodeValFileWriteGuard {
+    type Target = dyn VirtualFile + Send + Sync + 'static;
+    fn deref(&self) -> &Self::Target {
+        self.guard.deref().deref()
+    }
+}
+impl DerefMut for InodeValFileWriteGuard {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard.deref_mut().deref_mut()
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct WasiStateFileGuard {
+    inode: InodeGuard,
+}
+
+impl WasiStateFileGuard {
+    pub fn new(state: &WasiState, fd: wasi::Fd) -> Result<Option<Self>, FsError> {
+        let fd_map = state.fs.fd_map.read().unwrap();
+        if let Some(fd) = fd_map.get(&fd) {
+            Ok(Some(Self {
+                inode: fd.inode.clone(),
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn lock_read(&self) -> Option<InodeValFileReadGuard> {
+        let guard = self.inode.read();
+        if let Kind::File { handle, .. } = guard.deref() {
+            handle.as_ref().map(InodeValFileReadGuard::new)
+        } else {
+            // Our public API should ensure that this is not possible
+            unreachable!("Non-file found in standard device location")
+        }
+    }
+
+    pub fn lock_write(&self) -> Option<InodeValFileWriteGuard> {
+        let guard = self.inode.read();
+        if let Kind::File { handle, .. } = guard.deref() {
+            handle.as_ref().map(InodeValFileWriteGuard::new)
+        } else {
+            // Our public API should ensure that this is not possible
+            unreachable!("Non-file found in standard device location")
+        }
+    }
+}
+
+impl VirtualFile for WasiStateFileGuard {
+    fn last_accessed(&self) -> u64 {
+        let guard = self.lock_read();
+        if let Some(file) = guard.as_ref() {
+            file.last_accessed()
+        } else {
+            0
+        }
+    }
+
+    fn last_modified(&self) -> u64 {
+        let guard = self.lock_read();
+        if let Some(file) = guard.as_ref() {
+            file.last_modified()
+        } else {
+            0
+        }
+    }
+
+    fn created_time(&self) -> u64 {
+        let guard = self.lock_read();
+        if let Some(file) = guard.as_ref() {
+            file.created_time()
+        } else {
+            0
+        }
+    }
+
+    fn size(&self) -> u64 {
+        let guard = self.lock_read();
+        if let Some(file) = guard.as_ref() {
+            file.size()
+        } else {
+            0
+        }
+    }
+
+    fn set_len(&mut self, new_size: u64) -> Result<(), FsError> {
+        let mut guard = self.lock_write();
+        if let Some(file) = guard.as_mut() {
+            file.set_len(new_size)
+        } else {
+            Err(FsError::IOError)
+        }
+    }
+
+    fn unlink(&mut self) -> Result<(), FsError> {
+        let mut guard = self.lock_write();
+        if let Some(file) = guard.as_mut() {
+            file.unlink()
+        } else {
+            Err(FsError::IOError)
+        }
+    }
+
+    fn is_open(&self) -> bool {
+        let guard = self.lock_read();
+        if let Some(file) = guard.as_ref() {
+            file.is_open()
+        } else {
+            false
+        }
+    }
+
+    fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<usize>> {
+        let mut guard = self.lock_write();
+        if let Some(file) = guard.as_mut() {
+            let file = Pin::new(file.deref_mut());
+            file.poll_read_ready(cx)
+        } else {
+            Poll::Ready(Ok(0))
+        }
+    }
+
+    fn poll_write_ready(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<std::io::Result<usize>> {
+        let mut guard = self.lock_write();
+        if let Some(file) = guard.as_mut() {
+            let file = Pin::new(file.deref_mut());
+            file.poll_write_ready(cx)
+        } else {
+            Poll::Ready(Ok(0))
+        }
+    }
+}
+
+impl AsyncSeek for WasiStateFileGuard {
+    fn start_seek(self: Pin<&mut Self>, position: SeekFrom) -> std::io::Result<()> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.start_seek(position)
+        } else {
+            Err(std::io::ErrorKind::Unsupported.into())
+        }
+    }
+    fn poll_complete(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<u64>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_complete(cx)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+}
+
+impl AsyncWrite for WasiStateFileGuard {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<std::io::Result<usize>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_write(cx, buf)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+    fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_flush(cx)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_shutdown(cx)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+    fn poll_write_vectored(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        bufs: &[IoSlice<'_>],
+    ) -> Poll<std::io::Result<usize>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_write_vectored(cx, bufs)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+    fn is_write_vectored(&self) -> bool {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.is_write_vectored()
+        } else {
+            false
+        }
+    }
+}
+
+impl AsyncRead for WasiStateFileGuard {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &mut tokio::io::ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        let mut guard = self.lock_write();
+        if let Some(guard) = guard.as_mut() {
+            let file = Pin::new(guard.deref_mut());
+            file.poll_read(cx, buf)
+        } else {
+            Poll::Ready(Err(std::io::ErrorKind::Unsupported.into()))
+        }
+    }
+}
+
+fn is_err_closed(err: &std::io::Error) -> bool {
+    err.kind() == std::io::ErrorKind::ConnectionAborted
+        || err.kind() == std::io::ErrorKind::ConnectionRefused
+        || err.kind() == std::io::ErrorKind::ConnectionReset
+        || err.kind() == std::io::ErrorKind::BrokenPipe
+        || err.kind() == std::io::ErrorKind::NotConnected
+        || err.kind() == std::io::ErrorKind::UnexpectedEof
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/mod.rs
new file mode 100644
index 0000000..c10420c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/mod.rs
@@ -0,0 +1,2123 @@
+mod fd;
+mod inode_guard;
+mod notification;
+
+use std::{
+    borrow::{Borrow, Cow},
+    collections::{HashMap, HashSet, VecDeque},
+    ops::{Deref, DerefMut},
+    path::{Component, Path, PathBuf},
+    pin::Pin,
+    sync::{
+        atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
+        Arc, Mutex, RwLock, Weak,
+    },
+    task::{Context, Poll},
+};
+
+use crate::{
+    net::socket::InodeSocketKind,
+    state::{Stderr, Stdin, Stdout},
+};
+use futures::{future::BoxFuture, Future, TryStreamExt};
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+use tokio::io::AsyncWriteExt;
+use tracing::{debug, trace};
+use virtual_fs::{copy_reference, FileSystem, FsError, OpenOptions, VirtualFile};
+use wasmer_wasix_types::{
+    types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
+    wasi::{
+        Errno, Fd as WasiFd, Fdflags, Fdstat, Filesize, Filestat, Filetype, Preopentype, Prestat,
+        PrestatEnum, Rights, Socktype,
+    },
+};
+
+pub use self::fd::{EpollFd, EpollInterest, EpollJoinGuard, Fd, InodeVal, Kind};
+pub(crate) use self::inode_guard::{
+    InodeValFilePollGuard, InodeValFilePollGuardJoin, InodeValFilePollGuardMode,
+    InodeValFileReadGuard, InodeValFileWriteGuard, WasiStateFileGuard, POLL_GUARD_MAX_RET,
+};
+pub use self::notification::NotificationInner;
+use crate::syscalls::map_io_err;
+use crate::{bin_factory::BinaryPackage, state::PreopenedDir, ALL_RIGHTS};
+
+/// the fd value of the virtual root
+///
+/// Used for interacting with the file system when it has no
+/// pre-opened file descriptors at the root level. Normally
+/// a WASM process will do this in the libc initialization stage
+/// however that does not happen when the WASM process has never
+/// been run. Further that logic could change at any time in libc
+/// which would then break functionality. Instead we use this fixed
+/// file descriptor
+///
+/// This is especially important for fuse mounting journals which
+/// use the same syscalls as a normal WASI application but do not
+/// run the libc initialization logic
+pub const VIRTUAL_ROOT_FD: WasiFd = 3;
+
+const STDIN_DEFAULT_RIGHTS: Rights = {
+    // This might seem a bit overenineered, but it's the only way I
+    // discovered for getting the values in a const environment
+    Rights::from_bits_truncate(
+        Rights::FD_DATASYNC.bits()
+            | Rights::FD_READ.bits()
+            | Rights::FD_SYNC.bits()
+            | Rights::FD_ADVISE.bits()
+            | Rights::FD_FILESTAT_GET.bits()
+            | Rights::POLL_FD_READWRITE.bits(),
+    )
+};
+const STDOUT_DEFAULT_RIGHTS: Rights = {
+    // This might seem a bit overenineered, but it's the only way I
+    // discovered for getting the values in a const environment
+    Rights::from_bits_truncate(
+        Rights::FD_DATASYNC.bits()
+            | Rights::FD_SYNC.bits()
+            | Rights::FD_WRITE.bits()
+            | Rights::FD_ADVISE.bits()
+            | Rights::FD_FILESTAT_GET.bits()
+            | Rights::POLL_FD_READWRITE.bits(),
+    )
+};
+const STDERR_DEFAULT_RIGHTS: Rights = STDOUT_DEFAULT_RIGHTS;
+
+/// A completely aribtrary "big enough" number used as the upper limit for
+/// the number of symlinks that can be traversed when resolving a path
+pub const MAX_SYMLINKS: u32 = 128;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Inode(u64);
+
+impl Inode {
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct InodeGuard {
+    ino: Inode,
+    inner: Arc<InodeVal>,
+}
+impl InodeGuard {
+    pub fn ino(&self) -> Inode {
+        self.ino
+    }
+    pub fn downgrade(&self) -> InodeWeakGuard {
+        InodeWeakGuard {
+            ino: self.ino,
+            inner: Arc::downgrade(&self.inner),
+        }
+    }
+    pub fn ref_cnt(&self) -> usize {
+        Arc::strong_count(&self.inner)
+    }
+}
+impl std::ops::Deref for InodeGuard {
+    type Target = InodeVal;
+    fn deref(&self) -> &Self::Target {
+        self.inner.deref()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct InodeWeakGuard {
+    ino: Inode,
+    inner: Weak<InodeVal>,
+}
+impl InodeWeakGuard {
+    pub fn ino(&self) -> Inode {
+        self.ino
+    }
+    pub fn upgrade(&self) -> Option<InodeGuard> {
+        Weak::upgrade(&self.inner).map(|inner| InodeGuard {
+            ino: self.ino,
+            inner,
+        })
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+struct WasiInodesProtected {
+    seed: u64,
+    lookup: HashMap<Inode, Weak<InodeVal>>,
+}
+
+#[derive(Clone, Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct WasiInodes {
+    protected: Arc<RwLock<WasiInodesProtected>>,
+}
+
+impl WasiInodes {
+    pub fn new() -> Self {
+        Self {
+            protected: Arc::new(RwLock::new(WasiInodesProtected {
+                seed: 1,
+                lookup: Default::default(),
+            })),
+        }
+    }
+
+    /// adds another value to the inodes
+    pub fn add_inode_val(&self, val: InodeVal) -> InodeGuard {
+        let val = Arc::new(val);
+
+        let mut guard = self.protected.write().unwrap();
+        let ino = Inode(guard.seed);
+        guard.seed += 1;
+        guard.lookup.insert(ino, Arc::downgrade(&val));
+
+        // Set the inode value
+        {
+            let mut guard = val.stat.write().unwrap();
+            guard.st_ino = ino.0;
+        }
+
+        // every 100 calls we clear out dead weaks
+        if guard.seed % 100 == 1 {
+            guard.lookup.retain(|_, v| Weak::strong_count(v) > 0);
+        }
+
+        InodeGuard { ino, inner: val }
+    }
+
+    /// Get the `VirtualFile` object at stdout
+    pub(crate) fn stdout(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileReadGuard, FsError> {
+        Self::std_dev_get(fd_map, __WASI_STDOUT_FILENO)
+    }
+    /// Get the `VirtualFile` object at stdout mutably
+    pub(crate) fn stdout_mut(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileWriteGuard, FsError> {
+        Self::std_dev_get_mut(fd_map, __WASI_STDOUT_FILENO)
+    }
+
+    /// Get the `VirtualFile` object at stderr
+    pub(crate) fn stderr(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileReadGuard, FsError> {
+        Self::std_dev_get(fd_map, __WASI_STDERR_FILENO)
+    }
+    /// Get the `VirtualFile` object at stderr mutably
+    pub(crate) fn stderr_mut(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileWriteGuard, FsError> {
+        Self::std_dev_get_mut(fd_map, __WASI_STDERR_FILENO)
+    }
+
+    /// Get the `VirtualFile` object at stdin
+    /// TODO: Review why this is dead
+    #[allow(dead_code)]
+    pub(crate) fn stdin(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileReadGuard, FsError> {
+        Self::std_dev_get(fd_map, __WASI_STDIN_FILENO)
+    }
+    /// Get the `VirtualFile` object at stdin mutably
+    pub(crate) fn stdin_mut(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+    ) -> Result<InodeValFileWriteGuard, FsError> {
+        Self::std_dev_get_mut(fd_map, __WASI_STDIN_FILENO)
+    }
+
+    /// Internal helper function to get a standard device handle.
+    /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
+    fn std_dev_get(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+        fd: WasiFd,
+    ) -> Result<InodeValFileReadGuard, FsError> {
+        if let Some(fd) = fd_map.read().unwrap().get(&fd) {
+            let guard = fd.inode.read();
+            if let Kind::File {
+                handle: Some(handle),
+                ..
+            } = guard.deref()
+            {
+                Ok(InodeValFileReadGuard::new(handle))
+            } else {
+                // Our public API should ensure that this is not possible
+                Err(FsError::NotAFile)
+            }
+        } else {
+            // this should only trigger if we made a mistake in this crate
+            Err(FsError::NoDevice)
+        }
+    }
+    /// Internal helper function to mutably get a standard device handle.
+    /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
+    fn std_dev_get_mut(
+        fd_map: &RwLock<HashMap<u32, Fd>>,
+        fd: WasiFd,
+    ) -> Result<InodeValFileWriteGuard, FsError> {
+        if let Some(fd) = fd_map.read().unwrap().get(&fd) {
+            let guard = fd.inode.read();
+            if let Kind::File {
+                handle: Some(handle),
+                ..
+            } = guard.deref()
+            {
+                Ok(InodeValFileWriteGuard::new(handle))
+            } else {
+                // Our public API should ensure that this is not possible
+                Err(FsError::NotAFile)
+            }
+        } else {
+            // this should only trigger if we made a mistake in this crate
+            Err(FsError::NoDevice)
+        }
+    }
+}
+
+impl Default for WasiInodes {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum WasiFsRoot {
+    Sandbox(Arc<virtual_fs::tmp_fs::TmpFileSystem>),
+    Backing(Arc<Box<dyn FileSystem>>),
+}
+
+impl WasiFsRoot {
+    /// Merge the contents of a filesystem into this one.
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub(crate) async fn merge(
+        &self,
+        other: &Arc<dyn FileSystem + Send + Sync>,
+    ) -> Result<(), virtual_fs::FsError> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => {
+                fs.union(other);
+                Ok(())
+            }
+            WasiFsRoot::Backing(fs) => {
+                merge_filesystems(other, fs).await?;
+                Ok(())
+            }
+        }
+    }
+}
+
+impl FileSystem for WasiFsRoot {
+    fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.read_dir(path),
+            WasiFsRoot::Backing(fs) => fs.read_dir(path),
+        }
+    }
+    fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.create_dir(path),
+            WasiFsRoot::Backing(fs) => fs.create_dir(path),
+        }
+    }
+    fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.remove_dir(path),
+            WasiFsRoot::Backing(fs) => fs.remove_dir(path),
+        }
+    }
+    fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        let this = self.clone();
+        Box::pin(async move {
+            match this {
+                WasiFsRoot::Sandbox(fs) => fs.rename(&from, &to).await,
+                WasiFsRoot::Backing(fs) => fs.rename(&from, &to).await,
+            }
+        })
+    }
+    fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.metadata(path),
+            WasiFsRoot::Backing(fs) => fs.metadata(path),
+        }
+    }
+    fn symlink_metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.symlink_metadata(path),
+            WasiFsRoot::Backing(fs) => fs.symlink_metadata(path),
+        }
+    }
+    fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.remove_file(path),
+            WasiFsRoot::Backing(fs) => fs.remove_file(path),
+        }
+    }
+    fn new_open_options(&self) -> OpenOptions {
+        match self {
+            WasiFsRoot::Sandbox(fs) => fs.new_open_options(),
+            WasiFsRoot::Backing(fs) => fs.new_open_options(),
+        }
+    }
+}
+
+/// Merge the contents of one filesystem into another.
+///
+#[tracing::instrument(level = "trace", skip_all)]
+async fn merge_filesystems(
+    source: &dyn FileSystem,
+    destination: &dyn FileSystem,
+) -> Result<(), virtual_fs::FsError> {
+    tracing::debug!("Falling back to a recursive copy to merge filesystems");
+    let files = futures::stream::FuturesUnordered::new();
+
+    let mut to_check = VecDeque::new();
+    to_check.push_back(PathBuf::from("/"));
+
+    while let Some(path) = to_check.pop_front() {
+        let metadata = match source.metadata(&path) {
+            Ok(m) => m,
+            Err(err) => {
+                tracing::debug!(path=%path.display(), source_fs=?source, ?err, "failed to get metadata for path while merging file systems");
+                return Err(err);
+            }
+        };
+
+        if metadata.is_dir() {
+            create_dir_all(destination, &path)?;
+
+            for entry in source.read_dir(&path)? {
+                let entry = entry?;
+                to_check.push_back(entry.path);
+            }
+        } else if metadata.is_file() {
+            files.push(async move {
+                copy_reference(source, destination, &path)
+                    .await
+                    .map_err(virtual_fs::FsError::from)
+            });
+        } else {
+            tracing::debug!(
+                path=%path.display(),
+                ?metadata,
+                "Skipping unknown file type while merging"
+            );
+        }
+    }
+
+    files.try_collect().await
+}
+
+fn create_dir_all(fs: &dyn FileSystem, path: &Path) -> Result<(), virtual_fs::FsError> {
+    if fs.metadata(path).is_ok() {
+        return Ok(());
+    }
+
+    if let Some(parent) = path.parent() {
+        create_dir_all(fs, parent)?;
+    }
+
+    fs.create_dir(path)?;
+
+    Ok(())
+}
+
+/// This needs to be exposed so that the multiple use-cases are able
+/// to generated unique file descriptors and update the seed during
+/// journal restoration
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct WasiFdSeed {
+    next_fd: Arc<AtomicU32>,
+}
+
+impl Default for WasiFdSeed {
+    fn default() -> Self {
+        Self::new(3)
+    }
+}
+
+impl WasiFdSeed {
+    pub fn new(initial_val: u32) -> Self {
+        Self {
+            next_fd: Arc::new(AtomicU32::new(initial_val)),
+        }
+    }
+
+    pub fn fork(&self) -> Self {
+        Self {
+            next_fd: Arc::new(AtomicU32::new(self.next_fd.load(Ordering::SeqCst))),
+        }
+    }
+
+    pub fn next_val(&self) -> WasiFd {
+        self.next_fd.fetch_add(1, Ordering::SeqCst)
+    }
+
+    pub fn set_val(&self, val: WasiFd) {
+        self.next_fd.store(val, std::sync::atomic::Ordering::SeqCst)
+    }
+
+    pub fn cur_val(&self) -> WasiFd {
+        self.next_fd.load(Ordering::SeqCst)
+    }
+
+    pub fn clip_val(&self, fd: WasiFd) {
+        loop {
+            let existing = self.next_fd.load(Ordering::SeqCst);
+            if existing >= fd {
+                return;
+            }
+            if self
+                .next_fd
+                .compare_exchange(existing, fd, Ordering::SeqCst, Ordering::Relaxed)
+                .is_ok()
+            {
+                break;
+            }
+        }
+    }
+}
+
+/// Warning, modifying these fields directly may cause invariants to break and
+/// should be considered unsafe.  These fields may be made private in a future release
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct WasiFs {
+    //pub repo: Repo,
+    pub preopen_fds: RwLock<Vec<u32>>,
+    pub fd_map: Arc<RwLock<HashMap<WasiFd, Fd>>>,
+    pub next_fd: WasiFdSeed,
+    pub current_dir: Mutex<String>,
+    #[cfg_attr(feature = "enable-serde", serde(skip, default))]
+    pub root_fs: WasiFsRoot,
+    pub root_inode: InodeGuard,
+    pub has_unioned: Arc<Mutex<HashSet<String>>>,
+
+    // TODO: remove
+    // using an atomic is a hack to enable customization after construction,
+    // but it shouldn't be necessary
+    // It should not be necessary at all.
+    is_wasix: AtomicBool,
+
+    // The preopens when this was initialized
+    pub(crate) init_preopens: Vec<PreopenedDir>,
+    // The virtual file system preopens when this was initialized
+    pub(crate) init_vfs_preopens: Vec<String>,
+}
+
+impl WasiFs {
+    pub fn is_wasix(&self) -> bool {
+        // NOTE: this will only be set once very early in the instance lifetime,
+        // so Relaxed should be okay.
+        self.is_wasix.load(Ordering::Relaxed)
+    }
+
+    pub fn set_is_wasix(&self, is_wasix: bool) {
+        self.is_wasix.store(is_wasix, Ordering::SeqCst);
+    }
+
+    /// Forking the WasiState is used when either fork or vfork is called
+    pub fn fork(&self) -> Self {
+        let fd_map = self.fd_map.read().unwrap().clone();
+        Self {
+            preopen_fds: RwLock::new(self.preopen_fds.read().unwrap().clone()),
+            fd_map: Arc::new(RwLock::new(fd_map)),
+            next_fd: self.next_fd.fork(),
+            current_dir: Mutex::new(self.current_dir.lock().unwrap().clone()),
+            is_wasix: AtomicBool::new(self.is_wasix.load(Ordering::Acquire)),
+            root_fs: self.root_fs.clone(),
+            root_inode: self.root_inode.clone(),
+            has_unioned: Arc::new(Mutex::new(HashSet::new())),
+            init_preopens: self.init_preopens.clone(),
+            init_vfs_preopens: self.init_vfs_preopens.clone(),
+        }
+    }
+
+    /// Closes all the file handles.
+    #[allow(clippy::await_holding_lock)]
+    pub async fn close_all(&self) {
+        let mut to_close = {
+            if let Ok(map) = self.fd_map.read() {
+                map.keys().copied().collect::<HashSet<_>>()
+            } else {
+                HashSet::new()
+            }
+        };
+        to_close.insert(__WASI_STDOUT_FILENO);
+        to_close.insert(__WASI_STDERR_FILENO);
+
+        let _ = tokio::join!(async {
+            for fd in to_close {
+                self.flush(fd).await.ok();
+                self.close_fd(fd).ok();
+            }
+        });
+
+        if let Ok(mut map) = self.fd_map.write() {
+            map.clear();
+        }
+    }
+
+    /// Will conditionally union the binary file system with this one
+    /// if it has not already been unioned
+    pub async fn conditional_union(
+        &self,
+        binary: &BinaryPackage,
+    ) -> Result<(), virtual_fs::FsError> {
+        let package_name = binary.package_name.clone();
+
+        let needs_to_be_unioned = self.has_unioned.lock().unwrap().insert(package_name);
+
+        if !needs_to_be_unioned {
+            return Ok(());
+        }
+
+        self.root_fs.merge(&binary.webc_fs).await?;
+
+        Ok(())
+    }
+
+    /// Created for the builder API. like `new` but with more information
+    pub(crate) fn new_with_preopen(
+        inodes: &WasiInodes,
+        preopens: &[PreopenedDir],
+        vfs_preopens: &[String],
+        fs_backing: WasiFsRoot,
+    ) -> Result<Self, String> {
+        let mut wasi_fs = Self::new_init(fs_backing, inodes)?;
+        wasi_fs.init_preopens = preopens.to_vec();
+        wasi_fs.init_vfs_preopens = vfs_preopens.to_vec();
+        wasi_fs.create_preopens(inodes, false)?;
+        Ok(wasi_fs)
+    }
+
+    /// Converts a relative path into an absolute path
+    pub(crate) fn relative_path_to_absolute(&self, mut path: String) -> String {
+        if path.starts_with("./") {
+            let current_dir = self.current_dir.lock().unwrap();
+            path = format!("{}{}", current_dir.as_str(), &path[1..]);
+            if path.contains("//") {
+                path = path.replace("//", "/");
+            }
+        }
+        path
+    }
+
+    /// Private helper function to init the filesystem, called in `new` and
+    /// `new_with_preopen`
+    fn new_init(fs_backing: WasiFsRoot, inodes: &WasiInodes) -> Result<Self, String> {
+        debug!("Initializing WASI filesystem");
+
+        let stat = Filestat {
+            st_filetype: Filetype::Directory,
+            ..Filestat::default()
+        };
+        let root_kind = Kind::Root {
+            entries: HashMap::new(),
+        };
+        let root_inode = inodes.add_inode_val(InodeVal {
+            stat: RwLock::new(stat),
+            is_preopened: true,
+            name: "/".into(),
+            kind: RwLock::new(root_kind),
+        });
+
+        let wasi_fs = Self {
+            preopen_fds: RwLock::new(vec![]),
+            fd_map: Arc::new(RwLock::new(HashMap::new())),
+            next_fd: WasiFdSeed::default(),
+            current_dir: Mutex::new("/".to_string()),
+            is_wasix: AtomicBool::new(false),
+            root_fs: fs_backing,
+            root_inode,
+            has_unioned: Arc::new(Mutex::new(HashSet::new())),
+            init_preopens: Default::default(),
+            init_vfs_preopens: Default::default(),
+        };
+        wasi_fs.create_stdin(inodes);
+        wasi_fs.create_stdout(inodes);
+        wasi_fs.create_stderr(inodes);
+        wasi_fs.create_rootfd()?;
+
+        Ok(wasi_fs)
+    }
+
+    /// This function is like create dir all, but it also opens it.
+    /// Function is unsafe because it may break invariants and hasn't been tested.
+    /// This is an experimental function and may be removed
+    ///
+    /// # Safety
+    /// - Virtual directories created with this function must not conflict with
+    ///   the standard operation of the WASI filesystem.  This is vague and
+    ///   unlikely in pratice.  [Join the discussion](https://github.com/wasmerio/wasmer/issues/1219)
+    ///   for what the newer, safer WASI FS APIs should look like.
+    #[allow(dead_code)]
+    pub unsafe fn open_dir_all(
+        &mut self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+        name: String,
+        rights: Rights,
+        rights_inheriting: Rights,
+        flags: Fdflags,
+    ) -> Result<WasiFd, FsError> {
+        // TODO: check permissions here? probably not, but this should be
+        // an explicit choice, so justify it in a comment when we remove this one
+        let mut cur_inode = self.get_fd_inode(base).map_err(fs_error_from_wasi_err)?;
+
+        let path: &Path = Path::new(&name);
+        //let n_components = path.components().count();
+        for c in path.components() {
+            let segment_name = c.as_os_str().to_string_lossy().to_string();
+            let guard = cur_inode.read();
+            match guard.deref() {
+                Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => {
+                    if let Some(_entry) = entries.get(&segment_name) {
+                        // TODO: this should be fixed
+                        return Err(FsError::AlreadyExists);
+                    }
+
+                    let kind = Kind::Dir {
+                        parent: cur_inode.downgrade(),
+                        path: PathBuf::from(""),
+                        entries: HashMap::new(),
+                    };
+
+                    drop(guard);
+                    let inode = self.create_inode_with_default_stat(
+                        inodes,
+                        kind,
+                        false,
+                        segment_name.clone().into(),
+                    );
+
+                    // reborrow to insert
+                    {
+                        let mut guard = cur_inode.write();
+                        match guard.deref_mut() {
+                            Kind::Dir {
+                                ref mut entries, ..
+                            }
+                            | Kind::Root { ref mut entries } => {
+                                entries.insert(segment_name, inode.clone());
+                            }
+                            _ => unreachable!("Dir or Root became not Dir or Root"),
+                        }
+                    }
+                    cur_inode = inode;
+                }
+                _ => return Err(FsError::BaseNotDirectory),
+            }
+        }
+
+        // TODO: review open flags (read, write); they were added without consideration
+        self.create_fd(
+            rights,
+            rights_inheriting,
+            flags,
+            Fd::READ | Fd::WRITE,
+            cur_inode,
+        )
+        .map_err(fs_error_from_wasi_err)
+    }
+
+    /// Opens a user-supplied file in the directory specified with the
+    /// name and flags given
+    // dead code because this is an API for external use
+    #[allow(dead_code, clippy::too_many_arguments)]
+    pub fn open_file_at(
+        &mut self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+        file: Box<dyn VirtualFile + Send + Sync + 'static>,
+        open_flags: u16,
+        name: String,
+        rights: Rights,
+        rights_inheriting: Rights,
+        flags: Fdflags,
+    ) -> Result<WasiFd, FsError> {
+        // TODO: check permissions here? probably not, but this should be
+        // an explicit choice, so justify it in a comment when we remove this one
+        let base_inode = self.get_fd_inode(base).map_err(fs_error_from_wasi_err)?;
+
+        let guard = base_inode.read();
+        match guard.deref() {
+            Kind::Dir { ref entries, .. } | Kind::Root { ref entries } => {
+                if let Some(_entry) = entries.get(&name) {
+                    // TODO: eventually change the logic here to allow overwrites
+                    return Err(FsError::AlreadyExists);
+                }
+
+                let kind = Kind::File {
+                    handle: Some(Arc::new(RwLock::new(file))),
+                    path: PathBuf::from(""),
+                    fd: Some(self.next_fd.next_val()),
+                };
+
+                drop(guard);
+                let inode = self
+                    .create_inode(inodes, kind, false, name.clone())
+                    .map_err(|_| FsError::IOError)?;
+
+                {
+                    let mut guard = base_inode.write();
+                    match guard.deref_mut() {
+                        Kind::Dir {
+                            ref mut entries, ..
+                        }
+                        | Kind::Root { ref mut entries } => {
+                            entries.insert(name, inode.clone());
+                        }
+                        _ => unreachable!("Dir or Root became not Dir or Root"),
+                    }
+                }
+
+                self.create_fd(rights, rights_inheriting, flags, open_flags, inode)
+                    .map_err(fs_error_from_wasi_err)
+            }
+            _ => Err(FsError::BaseNotDirectory),
+        }
+    }
+
+    /// Change the backing of a given file descriptor
+    /// Returns the old backing
+    /// TODO: add examples
+    #[allow(dead_code)]
+    pub fn swap_file(
+        &self,
+        fd: WasiFd,
+        mut file: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        match fd {
+            __WASI_STDIN_FILENO => {
+                let mut target = WasiInodes::stdin_mut(&self.fd_map)?;
+                Ok(Some(target.swap(file)))
+            }
+            __WASI_STDOUT_FILENO => {
+                let mut target = WasiInodes::stdout_mut(&self.fd_map)?;
+                Ok(Some(target.swap(file)))
+            }
+            __WASI_STDERR_FILENO => {
+                let mut target = WasiInodes::stderr_mut(&self.fd_map)?;
+                Ok(Some(target.swap(file)))
+            }
+            _ => {
+                let base_inode = self.get_fd_inode(fd).map_err(fs_error_from_wasi_err)?;
+                {
+                    // happy path
+                    let guard = base_inode.read();
+                    match guard.deref() {
+                        Kind::File { ref handle, .. } => {
+                            if let Some(handle) = handle {
+                                let mut handle = handle.write().unwrap();
+                                std::mem::swap(handle.deref_mut(), &mut file);
+                                return Ok(Some(file));
+                            }
+                        }
+                        _ => return Err(FsError::NotAFile),
+                    }
+                }
+                // slow path
+                let mut guard = base_inode.write();
+                match guard.deref_mut() {
+                    Kind::File { ref mut handle, .. } => {
+                        if let Some(handle) = handle {
+                            let mut handle = handle.write().unwrap();
+                            std::mem::swap(handle.deref_mut(), &mut file);
+                            Ok(Some(file))
+                        } else {
+                            handle.replace(Arc::new(RwLock::new(file)));
+                            Ok(None)
+                        }
+                    }
+                    _ => Err(FsError::NotAFile),
+                }
+            }
+        }
+    }
+
+    /// refresh size from filesystem
+    pub fn filestat_resync_size(&self, fd: WasiFd) -> Result<Filesize, Errno> {
+        let inode = self.get_fd_inode(fd)?;
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::File { handle, .. } => {
+                if let Some(h) = handle {
+                    let h = h.read().unwrap();
+                    let new_size = h.size();
+                    drop(h);
+                    drop(guard);
+
+                    inode.stat.write().unwrap().st_size = new_size;
+                    Ok(new_size as Filesize)
+                } else {
+                    Err(Errno::Badf)
+                }
+            }
+            Kind::Dir { .. } | Kind::Root { .. } => Err(Errno::Isdir),
+            _ => Err(Errno::Inval),
+        }
+    }
+
+    /// Changes the current directory
+    pub fn set_current_dir(&self, path: &str) {
+        let mut guard = self.current_dir.lock().unwrap();
+        *guard = path.to_string();
+    }
+
+    /// Gets the current directory
+    pub fn get_current_dir(
+        &self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+    ) -> Result<(InodeGuard, String), Errno> {
+        self.get_current_dir_inner(inodes, base, 0)
+    }
+
+    pub(crate) fn get_current_dir_inner(
+        &self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+        symlink_count: u32,
+    ) -> Result<(InodeGuard, String), Errno> {
+        let current_dir = {
+            let guard = self.current_dir.lock().unwrap();
+            guard.clone()
+        };
+        let cur_inode = self.get_fd_inode(base)?;
+        let inode = self.get_inode_at_path_inner(
+            inodes,
+            cur_inode,
+            current_dir.as_str(),
+            symlink_count,
+            true,
+        )?;
+        Ok((inode, current_dir))
+    }
+
+    /// Internal part of the core path resolution function which implements path
+    /// traversal logic such as resolving relative path segments (such as
+    /// `.` and `..`) and resolving symlinks (while preventing infinite
+    /// loops/stack overflows).
+    ///
+    /// TODO: expand upon exactly what the state of the returned value is,
+    /// explaining lazy-loading from the real file system and synchronizing
+    /// between them.
+    ///
+    /// This is where a lot of the magic happens, be very careful when editing
+    /// this code.
+    ///
+    /// TODO: write more tests for this code
+    fn get_inode_at_path_inner(
+        &self,
+        inodes: &WasiInodes,
+        mut cur_inode: InodeGuard,
+        path: &str,
+        mut symlink_count: u32,
+        follow_symlinks: bool,
+    ) -> Result<InodeGuard, Errno> {
+        if symlink_count > MAX_SYMLINKS {
+            return Err(Errno::Mlink);
+        }
+
+        let path: &Path = Path::new(path);
+        let n_components = path.components().count();
+
+        // TODO: rights checks
+        'path_iter: for (i, component) in path.components().enumerate() {
+            // used to terminate symlink resolution properly
+            let last_component = i + 1 == n_components;
+            // for each component traverse file structure
+            // loading inodes as necessary
+            'symlink_resolution: while symlink_count < MAX_SYMLINKS {
+                let processing_cur_inode = cur_inode.clone();
+                let mut guard = processing_cur_inode.write();
+                match guard.deref_mut() {
+                    Kind::Buffer { .. } => unimplemented!("state::get_inode_at_path for buffers"),
+                    Kind::Dir {
+                        ref mut entries,
+                        ref path,
+                        ref parent,
+                        ..
+                    } => {
+                        match component.as_os_str().to_string_lossy().borrow() {
+                            ".." => {
+                                if let Some(p) = parent.upgrade() {
+                                    cur_inode = p;
+                                    continue 'path_iter;
+                                } else {
+                                    return Err(Errno::Access);
+                                }
+                            }
+                            "." => continue 'path_iter,
+                            _ => (),
+                        }
+                        // used for full resolution of symlinks
+                        let mut loop_for_symlink = false;
+                        if let Some(entry) =
+                            entries.get(component.as_os_str().to_string_lossy().as_ref())
+                        {
+                            cur_inode = entry.clone();
+                        } else {
+                            let file = {
+                                let mut cd = path.clone();
+                                cd.push(component);
+                                cd
+                            };
+                            let metadata = self
+                                .root_fs
+                                .symlink_metadata(&file)
+                                .ok()
+                                .ok_or(Errno::Noent)?;
+                            let file_type = metadata.file_type();
+                            // we want to insert newly opened dirs and files, but not transient symlinks
+                            // TODO: explain why (think about this deeply when well rested)
+                            let should_insert;
+
+                            let kind = if file_type.is_dir() {
+                                should_insert = true;
+                                // load DIR
+                                Kind::Dir {
+                                    parent: cur_inode.downgrade(),
+                                    path: file.clone(),
+                                    entries: Default::default(),
+                                }
+                            } else if file_type.is_file() {
+                                should_insert = true;
+                                // load file
+                                Kind::File {
+                                    handle: None,
+                                    path: file.clone(),
+                                    fd: None,
+                                }
+                            } else if file_type.is_symlink() {
+                                should_insert = false;
+                                let link_value = file.read_link().map_err(map_io_err)?;
+                                debug!("attempting to decompose path {:?}", link_value);
+
+                                let (pre_open_dir_fd, relative_path) = if link_value.is_relative() {
+                                    self.path_into_pre_open_and_relative_path(&file)?
+                                } else {
+                                    tracing::error!("Absolute symlinks are not yet supported");
+                                    return Err(Errno::Notsup);
+                                };
+                                loop_for_symlink = true;
+                                symlink_count += 1;
+                                Kind::Symlink {
+                                    base_po_dir: pre_open_dir_fd,
+                                    path_to_symlink: relative_path.to_owned(),
+                                    relative_path: link_value,
+                                }
+                            } else {
+                                #[cfg(unix)]
+                                {
+                                    //use std::os::unix::fs::FileTypeExt;
+                                    let file_type: Filetype = if file_type.is_char_device() {
+                                        Filetype::CharacterDevice
+                                    } else if file_type.is_block_device() {
+                                        Filetype::BlockDevice
+                                    } else if file_type.is_fifo() {
+                                        // FIFO doesn't seem to fit any other type, so unknown
+                                        Filetype::Unknown
+                                    } else if file_type.is_socket() {
+                                        // TODO: how do we know if it's a `SocketStream` or
+                                        // a `SocketDgram`?
+                                        Filetype::SocketStream
+                                    } else {
+                                        unimplemented!("state::get_inode_at_path unknown file type: not file, directory, symlink, char device, block device, fifo, or socket");
+                                    };
+
+                                    let kind = Kind::File {
+                                        handle: None,
+                                        path: file.clone(),
+                                        fd: None,
+                                    };
+                                    drop(guard);
+                                    let new_inode = self.create_inode_with_stat(
+                                        inodes,
+                                        kind,
+                                        false,
+                                        file.to_string_lossy().to_string().into(),
+                                        Filestat {
+                                            st_filetype: file_type,
+                                            ..Filestat::default()
+                                        },
+                                    );
+
+                                    let mut guard = cur_inode.write();
+                                    if let Kind::Dir {
+                                        ref mut entries, ..
+                                    } = guard.deref_mut()
+                                    {
+                                        entries.insert(
+                                            component.as_os_str().to_string_lossy().to_string(),
+                                            new_inode.clone(),
+                                        );
+                                    } else {
+                                        unreachable!(
+                                            "Attempted to insert special device into non-directory"
+                                        );
+                                    }
+                                    // perhaps just continue with symlink resolution and return at the end
+                                    return Ok(new_inode);
+                                }
+                                #[cfg(not(unix))]
+                                unimplemented!("state::get_inode_at_path unknown file type: not file, directory, or symlink");
+                            };
+                            drop(guard);
+
+                            let new_inode = self.create_inode(
+                                inodes,
+                                kind,
+                                false,
+                                file.to_string_lossy().to_string(),
+                            )?;
+                            if should_insert {
+                                let mut guard = processing_cur_inode.write();
+                                if let Kind::Dir {
+                                    ref mut entries, ..
+                                } = guard.deref_mut()
+                                {
+                                    entries.insert(
+                                        component.as_os_str().to_string_lossy().to_string(),
+                                        new_inode.clone(),
+                                    );
+                                }
+                            }
+                            cur_inode = new_inode;
+
+                            if loop_for_symlink && follow_symlinks {
+                                debug!("Following symlink to {:?}", cur_inode);
+                                continue 'symlink_resolution;
+                            }
+                        }
+                    }
+                    Kind::Root { entries } => {
+                        match component {
+                            // the root's parent is the root
+                            Component::ParentDir => continue 'path_iter,
+                            // the root's current directory is the root
+                            Component::CurDir => continue 'path_iter,
+                            _ => {}
+                        }
+
+                        let component = component.as_os_str().to_string_lossy();
+
+                        if let Some(entry) = entries.get(component.as_ref()) {
+                            cur_inode = entry.clone();
+                        } else if let Some(root) = entries.get(&"/".to_string()) {
+                            cur_inode = root.clone();
+                            continue 'symlink_resolution;
+                        } else {
+                            // Root is not capable of having something other then preopenned folders
+                            return Err(Errno::Notcapable);
+                        }
+                    }
+                    Kind::File { .. }
+                    | Kind::Socket { .. }
+                    | Kind::Pipe { .. }
+                    | Kind::EventNotifications { .. }
+                    | Kind::Epoll { .. } => {
+                        return Err(Errno::Notdir);
+                    }
+                    Kind::Symlink {
+                        base_po_dir,
+                        path_to_symlink,
+                        relative_path,
+                    } => {
+                        let new_base_dir = *base_po_dir;
+                        let new_base_inode = self.get_fd_inode(new_base_dir)?;
+
+                        // allocate to reborrow mutabily to recur
+                        let new_path = {
+                            /*if let Kind::Root { .. } = self.inodes[base_po_dir].kind {
+                                assert!(false, "symlinks should never be relative to the root");
+                            }*/
+                            let mut base = path_to_symlink.clone();
+                            // remove the symlink file itself from the path, leaving just the path from the base
+                            // to the dir containing the symlink
+                            base.pop();
+                            base.push(relative_path);
+                            base.to_string_lossy().to_string()
+                        };
+                        debug!("Following symlink recursively");
+                        drop(guard);
+                        let symlink_inode = self.get_inode_at_path_inner(
+                            inodes,
+                            new_base_inode,
+                            &new_path,
+                            symlink_count + 1,
+                            follow_symlinks,
+                        )?;
+                        cur_inode = symlink_inode;
+                        // if we're at the very end and we found a file, then we're done
+                        // TODO: figure out if this should also happen for directories?
+                        let guard = cur_inode.read();
+                        if let Kind::File { .. } = guard.deref() {
+                            // check if on last step
+                            if last_component {
+                                break 'symlink_resolution;
+                            }
+                        }
+                        continue 'symlink_resolution;
+                    }
+                }
+                break 'symlink_resolution;
+            }
+        }
+
+        Ok(cur_inode)
+    }
+
+    /// Finds the preopened directory that is the "best match" for the given path and
+    /// returns a path relative to this preopened directory.
+    ///
+    /// The "best match" is the preopened directory that has the longest prefix of the
+    /// given path. For example, given preopened directories [`a`, `a/b`, `a/c`] and
+    /// the path `a/b/c/file`, we will return the fd corresponding to the preopened
+    /// directory, `a/b` and the relative path `c/file`.
+    ///
+    /// In the case of a tie, the later preopened fd is preferred.
+    fn path_into_pre_open_and_relative_path<'path>(
+        &self,
+        path: &'path Path,
+    ) -> Result<(WasiFd, &'path Path), Errno> {
+        enum BaseFdAndRelPath<'a> {
+            None,
+            BestMatch {
+                fd: WasiFd,
+                rel_path: &'a Path,
+                max_seen: usize,
+            },
+        }
+
+        impl<'a> BaseFdAndRelPath<'a> {
+            const fn max_seen(&self) -> usize {
+                match self {
+                    Self::None => 0,
+                    Self::BestMatch { max_seen, .. } => *max_seen,
+                }
+            }
+        }
+        let mut res = BaseFdAndRelPath::None;
+        // for each preopened directory
+        let preopen_fds = self.preopen_fds.read().unwrap();
+        for po_fd in preopen_fds.deref() {
+            let po_inode = self.fd_map.read().unwrap()[po_fd].inode.clone();
+            let guard = po_inode.read();
+            let po_path = match guard.deref() {
+                Kind::Dir { path, .. } => &**path,
+                Kind::Root { .. } => Path::new("/"),
+                _ => unreachable!("Preopened FD that's not a directory or the root"),
+            };
+            // stem path based on it
+            if let Ok(stripped_path) = path.strip_prefix(po_path) {
+                // find the max
+                let new_prefix_len = po_path.as_os_str().len();
+                // we use >= to favor later preopens because we iterate in order
+                // whereas WASI libc iterates in reverse to get this behavior.
+                if new_prefix_len >= res.max_seen() {
+                    res = BaseFdAndRelPath::BestMatch {
+                        fd: *po_fd,
+                        rel_path: stripped_path,
+                        max_seen: new_prefix_len,
+                    };
+                }
+            }
+        }
+        match res {
+            // this error may not make sense depending on where it's called
+            BaseFdAndRelPath::None => Err(Errno::Inval),
+            BaseFdAndRelPath::BestMatch { fd, rel_path, .. } => Ok((fd, rel_path)),
+        }
+    }
+
+    /// finds the number of directories between the fd and the inode if they're connected
+    /// expects inode to point to a directory
+    pub(crate) fn path_depth_from_fd(&self, fd: WasiFd, inode: InodeGuard) -> Result<usize, Errno> {
+        let mut counter = 0;
+        let base_inode = self.get_fd_inode(fd)?;
+        let mut cur_inode = inode;
+
+        while cur_inode.ino() != base_inode.ino() {
+            counter += 1;
+
+            let processing_cur_inode = cur_inode.clone();
+            let guard = processing_cur_inode.read();
+
+            match guard.deref() {
+                Kind::Dir { parent, .. } => {
+                    if let Some(p) = parent.upgrade() {
+                        cur_inode = p;
+                    }
+                }
+                _ => return Err(Errno::Inval),
+            }
+        }
+
+        Ok(counter)
+    }
+
+    /// gets a host file from a base directory and a path
+    /// this function ensures the fs remains sandboxed
+    // NOTE: follow symlinks is super weird right now
+    // even if it's false, it still follows symlinks, just not the last
+    // symlink so
+    // This will be resolved when we have tests asserting the correct behavior
+    pub(crate) fn get_inode_at_path(
+        &self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+        path: &str,
+        follow_symlinks: bool,
+    ) -> Result<InodeGuard, Errno> {
+        let base_inode = self.get_fd_inode(base)?;
+        let start_inode =
+            if !base_inode.deref().name.starts_with('/') && self.is_wasix.load(Ordering::Acquire) {
+                let (cur_inode, _) = self.get_current_dir(inodes, base)?;
+                cur_inode
+            } else {
+                self.get_fd_inode(base)?
+            };
+        self.get_inode_at_path_inner(inodes, start_inode, path, 0, follow_symlinks)
+    }
+
+    /// Returns the parent Dir or Root that the file at a given path is in and the file name
+    /// stripped off
+    pub(crate) fn get_parent_inode_at_path(
+        &self,
+        inodes: &WasiInodes,
+        base: WasiFd,
+        path: &Path,
+        follow_symlinks: bool,
+    ) -> Result<(InodeGuard, String), Errno> {
+        let mut parent_dir = std::path::PathBuf::new();
+        let mut components = path.components().rev();
+        let new_entity_name = components
+            .next()
+            .ok_or(Errno::Inval)?
+            .as_os_str()
+            .to_string_lossy()
+            .to_string();
+        for comp in components.rev() {
+            parent_dir.push(comp);
+        }
+        self.get_inode_at_path(inodes, base, &parent_dir.to_string_lossy(), follow_symlinks)
+            .map(|v| (v, new_entity_name))
+    }
+
+    pub fn get_fd(&self, fd: WasiFd) -> Result<Fd, Errno> {
+        let ret = self
+            .fd_map
+            .read()
+            .unwrap()
+            .get(&fd)
+            .ok_or(Errno::Badf)
+            .map(|a| a.clone());
+
+        if ret.is_err() && fd == VIRTUAL_ROOT_FD {
+            Ok(Fd {
+                rights: ALL_RIGHTS,
+                rights_inheriting: ALL_RIGHTS,
+                flags: Fdflags::empty(),
+                offset: Arc::new(AtomicU64::new(0)),
+                open_flags: 0,
+                inode: self.root_inode.clone(),
+                is_stdio: false,
+            })
+        } else {
+            ret
+        }
+    }
+
+    pub fn get_fd_inode(&self, fd: WasiFd) -> Result<InodeGuard, Errno> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if fd == VIRTUAL_ROOT_FD {
+            return Ok(self.root_inode.clone());
+        }
+        self.fd_map
+            .read()
+            .unwrap()
+            .get(&fd)
+            .ok_or(Errno::Badf)
+            .map(|a| a.inode.clone())
+    }
+
+    pub fn filestat_fd(&self, fd: WasiFd) -> Result<Filestat, Errno> {
+        let inode = self.get_fd_inode(fd)?;
+        let guard = inode.stat.read().unwrap();
+        Ok(*guard.deref())
+    }
+
+    pub fn fdstat(&self, fd: WasiFd) -> Result<Fdstat, Errno> {
+        match fd {
+            __WASI_STDIN_FILENO => {
+                return Ok(Fdstat {
+                    fs_filetype: Filetype::CharacterDevice,
+                    fs_flags: Fdflags::empty(),
+                    fs_rights_base: STDIN_DEFAULT_RIGHTS,
+                    fs_rights_inheriting: Rights::empty(),
+                })
+            }
+            __WASI_STDOUT_FILENO => {
+                return Ok(Fdstat {
+                    fs_filetype: Filetype::CharacterDevice,
+                    fs_flags: Fdflags::APPEND,
+                    fs_rights_base: STDOUT_DEFAULT_RIGHTS,
+                    fs_rights_inheriting: Rights::empty(),
+                })
+            }
+            __WASI_STDERR_FILENO => {
+                return Ok(Fdstat {
+                    fs_filetype: Filetype::CharacterDevice,
+                    fs_flags: Fdflags::APPEND,
+                    fs_rights_base: STDERR_DEFAULT_RIGHTS,
+                    fs_rights_inheriting: Rights::empty(),
+                })
+            }
+            VIRTUAL_ROOT_FD => {
+                return Ok(Fdstat {
+                    fs_filetype: Filetype::Directory,
+                    fs_flags: Fdflags::empty(),
+                    // TODO: fix this
+                    fs_rights_base: ALL_RIGHTS,
+                    fs_rights_inheriting: ALL_RIGHTS,
+                });
+            }
+            _ => (),
+        }
+        let fd = self.get_fd(fd)?;
+
+        let guard = fd.inode.read();
+        let deref = guard.deref();
+        Ok(Fdstat {
+            fs_filetype: match deref {
+                Kind::File { .. } => Filetype::RegularFile,
+                Kind::Dir { .. } => Filetype::Directory,
+                Kind::Symlink { .. } => Filetype::SymbolicLink,
+                Kind::Socket { socket } => match &socket.inner.protected.read().unwrap().kind {
+                    InodeSocketKind::TcpStream { .. } => Filetype::SocketStream,
+                    InodeSocketKind::Raw { .. } => Filetype::SocketRaw,
+                    InodeSocketKind::PreSocket { props, .. } => match props.ty {
+                        Socktype::Stream => Filetype::SocketStream,
+                        Socktype::Dgram => Filetype::SocketDgram,
+                        Socktype::Raw => Filetype::SocketRaw,
+                        Socktype::Seqpacket => Filetype::SocketSeqpacket,
+                        _ => Filetype::Unknown,
+                    },
+                    _ => Filetype::Unknown,
+                },
+                _ => Filetype::Unknown,
+            },
+            fs_flags: fd.flags,
+            fs_rights_base: fd.rights,
+            fs_rights_inheriting: fd.rights_inheriting, // TODO(lachlan): Is this right?
+        })
+    }
+
+    pub fn prestat_fd(&self, fd: WasiFd) -> Result<Prestat, Errno> {
+        let inode = self.get_fd_inode(fd)?;
+        //trace!("in prestat_fd {:?}", self.get_fd(fd)?);
+
+        if inode.is_preopened {
+            Ok(self.prestat_fd_inner(inode.deref()))
+        } else {
+            Err(Errno::Badf)
+        }
+    }
+
+    pub(crate) fn prestat_fd_inner(&self, inode_val: &InodeVal) -> Prestat {
+        Prestat {
+            pr_type: Preopentype::Dir,
+            u: PrestatEnum::Dir {
+                // REVIEW:
+                // no need for +1, because there is no 0 end-of-string marker
+                // john: removing the +1 seems cause regression issues
+                pr_name_len: inode_val.name.len() as u32 + 1,
+            }
+            .untagged(),
+        }
+    }
+
+    #[allow(clippy::await_holding_lock)]
+    pub async fn flush(&self, fd: WasiFd) -> Result<(), Errno> {
+        match fd {
+            __WASI_STDIN_FILENO => (),
+            __WASI_STDOUT_FILENO => {
+                let mut file =
+                    WasiInodes::stdout_mut(&self.fd_map).map_err(fs_error_into_wasi_err)?;
+                file.flush().await.map_err(map_io_err)?
+            }
+            __WASI_STDERR_FILENO => {
+                let mut file =
+                    WasiInodes::stderr_mut(&self.fd_map).map_err(fs_error_into_wasi_err)?;
+                file.flush().await.map_err(map_io_err)?
+            }
+            _ => {
+                let fd = self.get_fd(fd)?;
+                if !fd.rights.contains(Rights::FD_DATASYNC) {
+                    return Err(Errno::Access);
+                }
+
+                let file = {
+                    let guard = fd.inode.read();
+                    match guard.deref() {
+                        Kind::File {
+                            handle: Some(file), ..
+                        } => file.clone(),
+                        // TODO: verify this behavior
+                        Kind::Dir { .. } => return Err(Errno::Isdir),
+                        Kind::Buffer { .. } => return Ok(()),
+                        _ => return Err(Errno::Io),
+                    }
+                };
+                drop(fd);
+
+                struct FlushPoller {
+                    file: Arc<RwLock<Box<dyn VirtualFile + Send + Sync>>>,
+                }
+                impl Future for FlushPoller {
+                    type Output = Result<(), Errno>;
+                    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                        let mut file = self.file.write().unwrap();
+                        Pin::new(file.as_mut())
+                            .poll_flush(cx)
+                            .map_err(|_| Errno::Io)
+                    }
+                }
+                FlushPoller { file }.await?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Creates an inode and inserts it given a Kind and some extra data
+    pub(crate) fn create_inode(
+        &self,
+        inodes: &WasiInodes,
+        kind: Kind,
+        is_preopened: bool,
+        name: String,
+    ) -> Result<InodeGuard, Errno> {
+        let stat = self.get_stat_for_kind(&kind)?;
+        Ok(self.create_inode_with_stat(inodes, kind, is_preopened, name.into(), stat))
+    }
+
+    /// Creates an inode and inserts it given a Kind, does not assume the file exists.
+    pub(crate) fn create_inode_with_default_stat(
+        &self,
+        inodes: &WasiInodes,
+        kind: Kind,
+        is_preopened: bool,
+        name: Cow<'static, str>,
+    ) -> InodeGuard {
+        let stat = Filestat::default();
+        self.create_inode_with_stat(inodes, kind, is_preopened, name, stat)
+    }
+
+    /// Creates an inode with the given filestat and inserts it.
+    pub(crate) fn create_inode_with_stat(
+        &self,
+        inodes: &WasiInodes,
+        kind: Kind,
+        is_preopened: bool,
+        name: Cow<'static, str>,
+        mut stat: Filestat,
+    ) -> InodeGuard {
+        match &kind {
+            Kind::File {
+                handle: Some(handle),
+                ..
+            } => {
+                let guard = handle.read().unwrap();
+                stat.st_size = guard.size();
+            }
+            Kind::Buffer { buffer } => {
+                stat.st_size = buffer.len() as u64;
+            }
+            _ => {}
+        }
+
+        let ret = inodes.add_inode_val(InodeVal {
+            stat: RwLock::new(stat),
+            is_preopened,
+            name,
+            kind: RwLock::new(kind),
+        });
+        stat.st_ino = ret.ino().as_u64();
+        ret
+    }
+
+    pub fn create_fd(
+        &self,
+        rights: Rights,
+        rights_inheriting: Rights,
+        flags: Fdflags,
+        open_flags: u16,
+        inode: InodeGuard,
+    ) -> Result<WasiFd, Errno> {
+        let idx = self.next_fd.next_val();
+        self.create_fd_ext(rights, rights_inheriting, flags, open_flags, inode, idx)?;
+        Ok(idx)
+    }
+
+    pub fn make_max_fd(&self, fd: u32) {
+        self.next_fd.clip_val(fd);
+    }
+
+    pub fn create_fd_ext(
+        &self,
+        rights: Rights,
+        rights_inheriting: Rights,
+        flags: Fdflags,
+        open_flags: u16,
+        inode: InodeGuard,
+        idx: WasiFd,
+    ) -> Result<(), Errno> {
+        let is_stdio = matches!(
+            idx,
+            __WASI_STDIN_FILENO | __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO
+        );
+        self.fd_map.write().unwrap().insert(
+            idx,
+            Fd {
+                rights,
+                rights_inheriting,
+                flags,
+                offset: Arc::new(AtomicU64::new(0)),
+                open_flags,
+                inode,
+                is_stdio,
+            },
+        );
+        Ok(())
+    }
+
+    pub fn clone_fd(&self, fd: WasiFd) -> Result<WasiFd, Errno> {
+        let fd = self.get_fd(fd)?;
+        let idx = self.next_fd.next_val();
+        self.fd_map.write().unwrap().insert(
+            idx,
+            Fd {
+                rights: fd.rights,
+                rights_inheriting: fd.rights_inheriting,
+                flags: fd.flags,
+                offset: fd.offset.clone(),
+                open_flags: fd.open_flags,
+                inode: fd.inode,
+                is_stdio: fd.is_stdio,
+            },
+        );
+        Ok(idx)
+    }
+
+    /// Low level function to remove an inode, that is it deletes the WASI FS's
+    /// knowledge of a file.
+    ///
+    /// This function returns the inode if it existed and was removed.
+    ///
+    /// # Safety
+    /// - The caller must ensure that all references to the specified inode have
+    ///   been removed from the filesystem.
+    pub unsafe fn remove_inode(&self, inodes: &WasiInodes, ino: Inode) -> Option<Arc<InodeVal>> {
+        let mut guard = inodes.protected.write().unwrap();
+        guard.lookup.remove(&ino).and_then(|a| Weak::upgrade(&a))
+    }
+
+    pub(crate) fn create_stdout(&self, inodes: &WasiInodes) {
+        self.create_std_dev_inner(
+            inodes,
+            Box::<Stdout>::default(),
+            "stdout",
+            __WASI_STDOUT_FILENO,
+            STDOUT_DEFAULT_RIGHTS,
+            Fdflags::APPEND,
+        );
+    }
+
+    pub(crate) fn create_stdin(&self, inodes: &WasiInodes) {
+        self.create_std_dev_inner(
+            inodes,
+            Box::<Stdin>::default(),
+            "stdin",
+            __WASI_STDIN_FILENO,
+            STDIN_DEFAULT_RIGHTS,
+            Fdflags::empty(),
+        );
+    }
+
+    pub(crate) fn create_stderr(&self, inodes: &WasiInodes) {
+        self.create_std_dev_inner(
+            inodes,
+            Box::<Stderr>::default(),
+            "stderr",
+            __WASI_STDERR_FILENO,
+            STDERR_DEFAULT_RIGHTS,
+            Fdflags::APPEND,
+        );
+    }
+
+    pub(crate) fn create_rootfd(&self) -> Result<(), String> {
+        // create virtual root
+        let all_rights = ALL_RIGHTS;
+        // TODO: make this a list of positive rigths instead of negative ones
+        // root gets all right for now
+        let root_rights = all_rights
+            /*
+            & (!Rights::FD_WRITE)
+            & (!Rights::FD_ALLOCATE)
+            & (!Rights::PATH_CREATE_DIRECTORY)
+            & (!Rights::PATH_CREATE_FILE)
+            & (!Rights::PATH_LINK_SOURCE)
+            & (!Rights::PATH_RENAME_SOURCE)
+            & (!Rights::PATH_RENAME_TARGET)
+            & (!Rights::PATH_FILESTAT_SET_SIZE)
+            & (!Rights::PATH_FILESTAT_SET_TIMES)
+            & (!Rights::FD_FILESTAT_SET_SIZE)
+            & (!Rights::FD_FILESTAT_SET_TIMES)
+            & (!Rights::PATH_SYMLINK)
+            & (!Rights::PATH_UNLINK_FILE)
+            & (!Rights::PATH_REMOVE_DIRECTORY)
+            */;
+        let fd = self
+            .create_fd(
+                root_rights,
+                root_rights,
+                Fdflags::empty(),
+                Fd::READ,
+                self.root_inode.clone(),
+            )
+            .map_err(|e| format!("Could not create root fd: {}", e))?;
+        self.preopen_fds.write().unwrap().push(fd);
+        Ok(())
+    }
+
+    pub(crate) fn create_preopens(
+        &self,
+        inodes: &WasiInodes,
+        ignore_duplicates: bool,
+    ) -> Result<(), String> {
+        for preopen_name in self.init_vfs_preopens.iter() {
+            let kind = Kind::Dir {
+                parent: self.root_inode.downgrade(),
+                path: PathBuf::from(preopen_name),
+                entries: Default::default(),
+            };
+            let rights = Rights::FD_ADVISE
+                | Rights::FD_TELL
+                | Rights::FD_SEEK
+                | Rights::FD_READ
+                | Rights::PATH_OPEN
+                | Rights::FD_READDIR
+                | Rights::PATH_READLINK
+                | Rights::PATH_FILESTAT_GET
+                | Rights::FD_FILESTAT_GET
+                | Rights::PATH_LINK_SOURCE
+                | Rights::PATH_RENAME_SOURCE
+                | Rights::POLL_FD_READWRITE
+                | Rights::SOCK_SHUTDOWN;
+            let inode = self
+                .create_inode(inodes, kind, true, preopen_name.clone())
+                .map_err(|e| {
+                    format!(
+                        "Failed to create inode for preopened dir (name `{}`): WASI error code: {}",
+                        preopen_name, e
+                    )
+                })?;
+            let fd_flags = Fd::READ;
+            let fd = self
+                .create_fd(rights, rights, Fdflags::empty(), fd_flags, inode.clone())
+                .map_err(|e| format!("Could not open fd for file {:?}: {}", preopen_name, e))?;
+            {
+                let mut guard = self.root_inode.write();
+                if let Kind::Root { entries } = guard.deref_mut() {
+                    let existing_entry = entries.insert(preopen_name.clone(), inode);
+                    if existing_entry.is_some() && !ignore_duplicates {
+                        return Err(format!(
+                            "Found duplicate entry for alias `{}`",
+                            preopen_name
+                        ));
+                    }
+                }
+            }
+            self.preopen_fds.write().unwrap().push(fd);
+        }
+
+        for PreopenedDir {
+            path,
+            alias,
+            read,
+            write,
+            create,
+        } in self.init_preopens.iter()
+        {
+            debug!(
+                "Attempting to preopen {} with alias {:?}",
+                &path.to_string_lossy(),
+                &alias
+            );
+            let cur_dir_metadata = self
+                .root_fs
+                .metadata(path)
+                .map_err(|e| format!("Could not get metadata for file {:?}: {}", path, e))?;
+
+            let kind = if cur_dir_metadata.is_dir() {
+                Kind::Dir {
+                    parent: self.root_inode.downgrade(),
+                    path: path.clone(),
+                    entries: Default::default(),
+                }
+            } else {
+                return Err(format!(
+                    "WASI only supports pre-opened directories right now; found \"{}\"",
+                    &path.to_string_lossy()
+                ));
+            };
+
+            let rights = {
+                // TODO: review tell' and fd_readwrite
+                let mut rights = Rights::FD_ADVISE | Rights::FD_TELL | Rights::FD_SEEK;
+                if *read {
+                    rights |= Rights::FD_READ
+                        | Rights::PATH_OPEN
+                        | Rights::FD_READDIR
+                        | Rights::PATH_READLINK
+                        | Rights::PATH_FILESTAT_GET
+                        | Rights::FD_FILESTAT_GET
+                        | Rights::PATH_LINK_SOURCE
+                        | Rights::PATH_RENAME_SOURCE
+                        | Rights::POLL_FD_READWRITE
+                        | Rights::SOCK_SHUTDOWN;
+                }
+                if *write {
+                    rights |= Rights::FD_DATASYNC
+                        | Rights::FD_FDSTAT_SET_FLAGS
+                        | Rights::FD_WRITE
+                        | Rights::FD_SYNC
+                        | Rights::FD_ALLOCATE
+                        | Rights::PATH_OPEN
+                        | Rights::PATH_RENAME_TARGET
+                        | Rights::PATH_FILESTAT_SET_SIZE
+                        | Rights::PATH_FILESTAT_SET_TIMES
+                        | Rights::FD_FILESTAT_SET_SIZE
+                        | Rights::FD_FILESTAT_SET_TIMES
+                        | Rights::PATH_REMOVE_DIRECTORY
+                        | Rights::PATH_UNLINK_FILE
+                        | Rights::POLL_FD_READWRITE
+                        | Rights::SOCK_SHUTDOWN;
+                }
+                if *create {
+                    rights |= Rights::PATH_CREATE_DIRECTORY
+                        | Rights::PATH_CREATE_FILE
+                        | Rights::PATH_LINK_TARGET
+                        | Rights::PATH_OPEN
+                        | Rights::PATH_RENAME_TARGET
+                        | Rights::PATH_SYMLINK;
+                }
+
+                rights
+            };
+            let inode = if let Some(alias) = &alias {
+                self.create_inode(inodes, kind, true, alias.clone())
+            } else {
+                self.create_inode(inodes, kind, true, path.to_string_lossy().into_owned())
+            }
+            .map_err(|e| {
+                format!(
+                    "Failed to create inode for preopened dir: WASI error code: {}",
+                    e
+                )
+            })?;
+            let fd_flags = {
+                let mut fd_flags = 0;
+                if *read {
+                    fd_flags |= Fd::READ;
+                }
+                if *write {
+                    // TODO: introduce API for finer grained control
+                    fd_flags |= Fd::WRITE | Fd::APPEND | Fd::TRUNCATE;
+                }
+                if *create {
+                    fd_flags |= Fd::CREATE;
+                }
+                fd_flags
+            };
+            let fd = self
+                .create_fd(rights, rights, Fdflags::empty(), fd_flags, inode.clone())
+                .map_err(|e| format!("Could not open fd for file {:?}: {}", path, e))?;
+            {
+                let mut guard = self.root_inode.write();
+                if let Kind::Root { entries } = guard.deref_mut() {
+                    let key = if let Some(alias) = &alias {
+                        alias.clone()
+                    } else {
+                        path.to_string_lossy().into_owned()
+                    };
+                    let existing_entry = entries.insert(key.clone(), inode);
+                    if existing_entry.is_some() && !ignore_duplicates {
+                        return Err(format!("Found duplicate entry for alias `{}`", key));
+                    }
+                }
+            }
+            self.preopen_fds.write().unwrap().push(fd);
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn create_std_dev_inner(
+        &self,
+        inodes: &WasiInodes,
+        handle: Box<dyn VirtualFile + Send + Sync + 'static>,
+        name: &'static str,
+        raw_fd: WasiFd,
+        rights: Rights,
+        fd_flags: Fdflags,
+    ) {
+        let inode = {
+            let stat = Filestat {
+                st_filetype: Filetype::CharacterDevice,
+                ..Filestat::default()
+            };
+            let kind = Kind::File {
+                fd: Some(raw_fd),
+                handle: Some(Arc::new(RwLock::new(handle))),
+                path: "".into(),
+            };
+            inodes.add_inode_val(InodeVal {
+                stat: RwLock::new(stat),
+                is_preopened: true,
+                name: name.to_string().into(),
+                kind: RwLock::new(kind),
+            })
+        };
+        self.fd_map.write().unwrap().insert(
+            raw_fd,
+            Fd {
+                rights,
+                rights_inheriting: Rights::empty(),
+                flags: fd_flags,
+                // since we're not calling open on this, we don't need open flags
+                open_flags: 0,
+                offset: Arc::new(AtomicU64::new(0)),
+                inode,
+                is_stdio: true,
+            },
+        );
+    }
+
+    pub fn get_stat_for_kind(&self, kind: &Kind) -> Result<Filestat, Errno> {
+        let md = match kind {
+            Kind::File { handle, path, .. } => match handle {
+                Some(wf) => {
+                    let wf = wf.read().unwrap();
+                    return Ok(Filestat {
+                        st_filetype: Filetype::RegularFile,
+                        st_size: wf.size(),
+                        st_atim: wf.last_accessed(),
+                        st_mtim: wf.last_modified(),
+                        st_ctim: wf.created_time(),
+
+                        ..Filestat::default()
+                    });
+                }
+                None => self
+                    .root_fs
+                    .metadata(path)
+                    .map_err(fs_error_into_wasi_err)?,
+            },
+            Kind::Dir { path, .. } => self
+                .root_fs
+                .metadata(path)
+                .map_err(fs_error_into_wasi_err)?,
+            Kind::Symlink {
+                base_po_dir,
+                path_to_symlink,
+                ..
+            } => {
+                let base_po_inode = &self.fd_map.read().unwrap()[base_po_dir].inode;
+                let guard = base_po_inode.read();
+                match guard.deref() {
+                    Kind::Root { .. } => {
+                        self.root_fs.symlink_metadata(path_to_symlink).map_err(fs_error_into_wasi_err)?
+                    }
+                    Kind::Dir { path, .. } => {
+                        let mut real_path = path.clone();
+                        // PHASE 1: ignore all possible symlinks in `relative_path`
+                        // TODO: walk the segments of `relative_path` via the entries of the Dir
+                        //       use helper function to avoid duplicating this logic (walking this will require
+                        //       &self to be &mut sel
+                        // TODO: adjust size of symlink, too
+                        //      for all paths adjusted think about this
+                        real_path.push(path_to_symlink);
+                        self.root_fs.symlink_metadata(&real_path).map_err(fs_error_into_wasi_err)?
+                    }
+                    // if this triggers, there's a bug in the symlink code
+                    _ => unreachable!("Symlink pointing to something that's not a directory as its base preopened directory"),
+                }
+            }
+            _ => return Err(Errno::Io),
+        };
+        Ok(Filestat {
+            st_filetype: virtual_file_type_to_wasi_file_type(md.file_type()),
+            st_size: md.len(),
+            st_atim: md.accessed(),
+            st_mtim: md.modified(),
+            st_ctim: md.created(),
+            ..Filestat::default()
+        })
+    }
+
+    /// Closes an open FD, handling all details such as FD being preopen
+    pub(crate) fn close_fd(&self, fd: WasiFd) -> Result<(), Errno> {
+        let mut fd_map = self.fd_map.write().unwrap();
+
+        let pfd = fd_map.remove(&fd).ok_or(Errno::Badf);
+        match pfd {
+            Ok(fd_ref) => {
+                let inode = fd_ref.inode.ino().as_u64();
+                let ref_cnt = fd_ref.inode.ref_cnt();
+                if ref_cnt == 1 {
+                    trace!(%fd, %inode, %ref_cnt, "closing file descriptor");
+                } else {
+                    trace!(%fd, %inode, %ref_cnt, "weakening file descriptor");
+                }
+            }
+            Err(err) => {
+                trace!(%fd, "closing file descriptor failed - {}", err);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl std::fmt::Debug for WasiFs {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Ok(guard) = self.current_dir.try_lock() {
+            write!(f, "current_dir={} ", guard.as_str())?;
+        } else {
+            write!(f, "current_dir=(locked) ")?;
+        }
+        write!(f, "next_fd={} ", self.next_fd.cur_val())?;
+        write!(f, "{:?}", self.root_fs)
+    }
+}
+
+/// Returns the default filesystem backing
+pub fn default_fs_backing() -> Box<dyn virtual_fs::FileSystem + Send + Sync> {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "host-fs")] {
+            Box::<virtual_fs::host_fs::FileSystem>::default()
+        } else if #[cfg(not(feature = "host-fs"))] {
+            Box::<virtual_fs::mem_fs::FileSystem>::default()
+        } else {
+            Box::<FallbackFileSystem>::default()
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct FallbackFileSystem;
+
+impl FallbackFileSystem {
+    fn fail() -> ! {
+        panic!("No filesystem set for wasmer-wasi, please enable either the `host-fs` or `mem-fs` feature or set your custom filesystem with `WasiEnvBuilder::set_fs`");
+    }
+}
+
+impl FileSystem for FallbackFileSystem {
+    fn read_dir(&self, _path: &Path) -> Result<virtual_fs::ReadDir, FsError> {
+        Self::fail();
+    }
+    fn create_dir(&self, _path: &Path) -> Result<(), FsError> {
+        Self::fail();
+    }
+    fn remove_dir(&self, _path: &Path) -> Result<(), FsError> {
+        Self::fail();
+    }
+    fn rename<'a>(&'a self, _from: &Path, _to: &Path) -> BoxFuture<'a, Result<(), FsError>> {
+        Self::fail();
+    }
+    fn metadata(&self, _path: &Path) -> Result<virtual_fs::Metadata, FsError> {
+        Self::fail();
+    }
+    fn symlink_metadata(&self, _path: &Path) -> Result<virtual_fs::Metadata, FsError> {
+        Self::fail();
+    }
+    fn remove_file(&self, _path: &Path) -> Result<(), FsError> {
+        Self::fail();
+    }
+    fn new_open_options(&self) -> virtual_fs::OpenOptions {
+        Self::fail();
+    }
+}
+
+pub fn virtual_file_type_to_wasi_file_type(file_type: virtual_fs::FileType) -> Filetype {
+    // TODO: handle other file types
+    if file_type.is_dir() {
+        Filetype::Directory
+    } else if file_type.is_file() {
+        Filetype::RegularFile
+    } else if file_type.is_symlink() {
+        Filetype::SymbolicLink
+    } else {
+        Filetype::Unknown
+    }
+}
+
+pub fn fs_error_from_wasi_err(err: Errno) -> FsError {
+    match err {
+        Errno::Badf => FsError::InvalidFd,
+        Errno::Exist => FsError::AlreadyExists,
+        Errno::Io => FsError::IOError,
+        Errno::Addrinuse => FsError::AddressInUse,
+        Errno::Addrnotavail => FsError::AddressNotAvailable,
+        Errno::Pipe => FsError::BrokenPipe,
+        Errno::Connaborted => FsError::ConnectionAborted,
+        Errno::Connrefused => FsError::ConnectionRefused,
+        Errno::Connreset => FsError::ConnectionReset,
+        Errno::Intr => FsError::Interrupted,
+        Errno::Inval => FsError::InvalidInput,
+        Errno::Notconn => FsError::NotConnected,
+        Errno::Nodev => FsError::NoDevice,
+        Errno::Noent => FsError::EntryNotFound,
+        Errno::Perm => FsError::PermissionDenied,
+        Errno::Timedout => FsError::TimedOut,
+        Errno::Proto => FsError::UnexpectedEof,
+        Errno::Again => FsError::WouldBlock,
+        Errno::Nospc => FsError::WriteZero,
+        Errno::Notempty => FsError::DirectoryNotEmpty,
+        _ => FsError::UnknownError,
+    }
+}
+
+pub fn fs_error_into_wasi_err(fs_error: FsError) -> Errno {
+    match fs_error {
+        FsError::AlreadyExists => Errno::Exist,
+        FsError::AddressInUse => Errno::Addrinuse,
+        FsError::AddressNotAvailable => Errno::Addrnotavail,
+        FsError::BaseNotDirectory => Errno::Notdir,
+        FsError::BrokenPipe => Errno::Pipe,
+        FsError::ConnectionAborted => Errno::Connaborted,
+        FsError::ConnectionRefused => Errno::Connrefused,
+        FsError::ConnectionReset => Errno::Connreset,
+        FsError::Interrupted => Errno::Intr,
+        FsError::InvalidData => Errno::Io,
+        FsError::InvalidFd => Errno::Badf,
+        FsError::InvalidInput => Errno::Inval,
+        FsError::IOError => Errno::Io,
+        FsError::NoDevice => Errno::Nodev,
+        FsError::NotAFile => Errno::Inval,
+        FsError::NotConnected => Errno::Notconn,
+        FsError::EntryNotFound => Errno::Noent,
+        FsError::PermissionDenied => Errno::Perm,
+        FsError::TimedOut => Errno::Timedout,
+        FsError::UnexpectedEof => Errno::Proto,
+        FsError::WouldBlock => Errno::Again,
+        FsError::WriteZero => Errno::Nospc,
+        FsError::DirectoryNotEmpty => Errno::Notempty,
+        FsError::StorageFull => Errno::Overflow,
+        FsError::Lock | FsError::UnknownError => Errno::Io,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/notification.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/notification.rs
new file mode 100644
index 0000000..218ec09
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/fs/notification.rs
@@ -0,0 +1,114 @@
+use std::{
+    collections::VecDeque,
+    sync::Mutex,
+    task::{Poll, Waker},
+};
+
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+struct NotificationState {
+    /// Used for event notifications by the user application or operating system
+    /// (positive number means there are events waiting to be processed)
+    counter: u64,
+    /// Counter used to prevent duplicate notification events
+    last_poll: u64,
+    /// Flag that indicates if this is operating
+    is_semaphore: bool,
+    /// All the registered wakers
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    wakers: VecDeque<Waker>,
+}
+
+impl NotificationState {
+    fn add_waker(&mut self, waker: &Waker) {
+        if !self.wakers.iter().any(|a| a.will_wake(waker)) {
+            self.wakers.push_front(waker.clone());
+        }
+    }
+
+    fn wake_all(&mut self) {
+        self.last_poll = u64::MAX;
+        while let Some(waker) = self.wakers.pop_front() {
+            waker.wake();
+        }
+    }
+
+    fn inc(&mut self, val: u64) {
+        self.counter += val;
+        self.wake_all();
+    }
+
+    fn dec(&mut self) -> u64 {
+        let val = self.counter;
+        if self.is_semaphore {
+            if self.counter > 0 {
+                self.counter -= 1;
+                if self.counter > 0 {
+                    self.wake_all();
+                }
+            }
+        } else {
+            self.counter = 0;
+        }
+        val
+    }
+}
+
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct NotificationInner {
+    /// Receiver that wakes sleeping threads
+    #[cfg_attr(feature = "enable-serde", serde(skip))]
+    state: Mutex<NotificationState>,
+}
+
+impl NotificationInner {
+    pub fn new(initial_val: u64, is_semaphore: bool) -> Self {
+        Self {
+            state: Mutex::new(NotificationState {
+                counter: initial_val,
+                last_poll: u64::MAX,
+                is_semaphore,
+                wakers: Default::default(),
+            }),
+        }
+    }
+    pub fn poll(&self, waker: &Waker) -> Poll<usize> {
+        let mut state = self.state.lock().unwrap();
+        state.add_waker(waker);
+
+        if state.last_poll != state.counter {
+            state.last_poll = state.counter;
+            Poll::Ready(state.counter as usize)
+        } else {
+            Poll::Pending
+        }
+    }
+
+    pub fn write(&self, val: u64) {
+        let mut state = self.state.lock().unwrap();
+        state.inc(val);
+    }
+
+    pub fn read(&self, waker: &Waker) -> Poll<u64> {
+        let mut state = self.state.lock().unwrap();
+        state.add_waker(waker);
+        match state.dec() {
+            0 => Poll::Pending,
+            res => Poll::Ready(res),
+        }
+    }
+
+    pub fn try_read(&self) -> Option<u64> {
+        let mut state = self.state.lock().unwrap();
+        match state.dec() {
+            0 => None,
+            res => Some(res),
+        }
+    }
+
+    pub fn reset(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.last_poll = u64::MAX;
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/client.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/client.rs
new file mode 100644
index 0000000..824834d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/client.rs
@@ -0,0 +1,190 @@
+use std::{collections::HashSet, ops::Deref, sync::Arc};
+
+use futures::future::BoxFuture;
+use http::{HeaderMap, Method, StatusCode};
+use url::Url;
+
+/// Defines http client permissions.
+#[derive(Clone, Debug)]
+pub struct HttpClientCapabilityV1 {
+    pub allow_all: bool,
+    pub allowed_hosts: HashSet<String>,
+}
+
+impl HttpClientCapabilityV1 {
+    pub fn new() -> Self {
+        Self {
+            allow_all: false,
+            allowed_hosts: HashSet::new(),
+        }
+    }
+
+    pub fn new_allow_all() -> Self {
+        Self {
+            allow_all: true,
+            allowed_hosts: HashSet::new(),
+        }
+    }
+
+    pub fn is_deny_all(&self) -> bool {
+        !self.allow_all && self.allowed_hosts.is_empty()
+    }
+
+    pub fn can_access_domain(&self, domain: &str) -> bool {
+        self.allow_all || self.allowed_hosts.contains(domain)
+    }
+
+    pub fn update(&mut self, other: HttpClientCapabilityV1) {
+        let HttpClientCapabilityV1 {
+            allow_all,
+            allowed_hosts,
+        } = other;
+        self.allow_all |= allow_all;
+        self.allowed_hosts.extend(allowed_hosts);
+    }
+}
+
+impl Default for HttpClientCapabilityV1 {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct HttpRequestOptions {
+    pub gzip: bool,
+    pub cors_proxy: Option<String>,
+}
+
+// TODO: use types from http crate?
+pub struct HttpRequest {
+    pub url: Url,
+    pub method: Method,
+    pub headers: HeaderMap,
+    pub body: Option<Vec<u8>>,
+    pub options: HttpRequestOptions,
+}
+
+impl HttpRequest {
+    fn from_http_parts(parts: http::request::Parts, body: impl Into<Option<Vec<u8>>>) -> Self {
+        let http::request::Parts {
+            method,
+            uri,
+            headers,
+            ..
+        } = parts;
+
+        HttpRequest {
+            url: uri.to_string().parse().unwrap(),
+            method,
+            headers,
+            body: body.into(),
+            options: HttpRequestOptions::default(),
+        }
+    }
+}
+
+impl std::fmt::Debug for HttpRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let HttpRequest {
+            url,
+            method,
+            headers,
+            body,
+            options,
+        } = self;
+
+        f.debug_struct("HttpRequest")
+            .field("url", &format_args!("{}", url))
+            .field("method", method)
+            .field("headers", headers)
+            .field("body", &body.as_deref().map(String::from_utf8_lossy))
+            .field("options", &options)
+            .finish()
+    }
+}
+
+impl From<http::Request<Option<Vec<u8>>>> for HttpRequest {
+    fn from(value: http::Request<Option<Vec<u8>>>) -> Self {
+        let (parts, body) = value.into_parts();
+        HttpRequest::from_http_parts(parts, body)
+    }
+}
+
+impl From<http::Request<Vec<u8>>> for HttpRequest {
+    fn from(value: http::Request<Vec<u8>>) -> Self {
+        let (parts, body) = value.into_parts();
+        HttpRequest::from_http_parts(parts, body)
+    }
+}
+
+impl From<http::Request<&str>> for HttpRequest {
+    fn from(value: http::Request<&str>) -> Self {
+        value.map(|body| body.to_string()).into()
+    }
+}
+
+impl From<http::Request<String>> for HttpRequest {
+    fn from(value: http::Request<String>) -> Self {
+        let (parts, body) = value.into_parts();
+        HttpRequest::from_http_parts(parts, body.into_bytes())
+    }
+}
+
+impl From<http::Request<()>> for HttpRequest {
+    fn from(value: http::Request<()>) -> Self {
+        let (parts, _) = value.into_parts();
+        HttpRequest::from_http_parts(parts, None)
+    }
+}
+
+// TODO: use types from http crate?
+pub struct HttpResponse {
+    pub body: Option<Vec<u8>>,
+    pub redirected: bool,
+    pub status: StatusCode,
+    pub headers: HeaderMap,
+}
+
+impl HttpResponse {
+    pub fn is_ok(&self) -> bool {
+        !self.status.is_client_error() && !self.status.is_server_error()
+    }
+}
+
+impl std::fmt::Debug for HttpResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let HttpResponse {
+            body,
+            redirected,
+            status,
+            headers,
+        } = self;
+
+        f.debug_struct("HttpResponse")
+            .field("ok", &self.is_ok())
+            .field("redirected", &redirected)
+            .field("status", &status)
+            .field("headers", &headers)
+            .field("body", &body.as_deref().map(String::from_utf8_lossy))
+            .finish()
+    }
+}
+
+pub trait HttpClient: std::fmt::Debug {
+    // TODO: use custom error type!
+    fn request(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>>;
+}
+
+impl<D, C> HttpClient for D
+where
+    D: Deref<Target = C> + std::fmt::Debug,
+    C: HttpClient + ?Sized + 'static,
+{
+    fn request(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+        let client = &**self;
+        client.request(request)
+    }
+}
+
+pub type DynHttpClient = Arc<dyn HttpClient + Send + Sync + 'static>;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/mod.rs
new file mode 100644
index 0000000..97ca495
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/mod.rs
@@ -0,0 +1,38 @@
+mod client;
+
+#[cfg(feature = "host-reqwest")]
+pub mod reqwest;
+
+#[cfg(feature = "js")]
+mod web_http_client;
+
+#[cfg(feature = "js")]
+pub use self::web_http_client::WebHttpClient;
+
+pub use self::client::*;
+
+pub(crate) const USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "-", env!("CARGO_PKG_VERSION"));
+
+/// Try to instantiate a HTTP client that is suitable for the current platform.
+pub fn default_http_client() -> Option<impl HttpClient + Send + Sync + 'static> {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "host-reqwest")] {
+            Some(self::reqwest::ReqwestHttpClient::default())
+        } else if #[cfg(feature = "js")] {
+            Some(web_http_client::WebHttpClient::default())
+        } else {
+            // Note: We need something to use with turbofish otherwise returning
+            // a plain None will complain about not being able to infer the "T"
+            // in Option<T>
+            #[derive(Debug)]
+            enum Unimplemented {}
+            impl HttpClient for Unimplemented {
+                fn request(&self, _request: HttpRequest) -> futures::future::BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+                    match *self {}
+                }
+            }
+
+            Option::<Unimplemented>::None
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/reqwest.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/reqwest.rs
new file mode 100644
index 0000000..036c1dd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/reqwest.rs
@@ -0,0 +1,96 @@
+use std::time::Duration;
+
+use anyhow::Context;
+use futures::{future::BoxFuture, TryStreamExt};
+use std::convert::TryFrom;
+use tokio::runtime::Handle;
+
+use super::{HttpRequest, HttpResponse};
+
+#[derive(Clone, Debug)]
+pub struct ReqwestHttpClient {
+    handle: Handle,
+    connect_timeout: Duration,
+    response_body_chunk_timeout: Option<std::time::Duration>,
+}
+
+impl Default for ReqwestHttpClient {
+    fn default() -> Self {
+        Self {
+            handle: Handle::current(),
+            connect_timeout: Self::DEFAULT_CONNECT_TIMEOUT,
+            response_body_chunk_timeout: None,
+        }
+    }
+}
+
+impl ReqwestHttpClient {
+    const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
+
+    pub fn with_connect_timeout(mut self, timeout: Duration) -> Self {
+        self.connect_timeout = timeout;
+        self
+    }
+
+    pub fn with_response_body_chunk_timeout(mut self, timeout: std::time::Duration) -> Self {
+        self.response_body_chunk_timeout = Some(timeout);
+        self
+    }
+
+    async fn request(&self, request: HttpRequest) -> Result<HttpResponse, anyhow::Error> {
+        let method = reqwest::Method::try_from(request.method.as_str())
+            .with_context(|| format!("Invalid http method {}", request.method))?;
+
+        // TODO: use persistent client?
+        let client = {
+            let _guard = Handle::try_current().map_err(|_| self.handle.enter());
+            reqwest::Client::builder()
+                .connect_timeout(self.connect_timeout)
+                .build()
+                .context("Could not create reqwest client")?
+        };
+
+        let mut builder = client.request(method, request.url.as_str());
+        for (header, val) in &request.headers {
+            builder = builder.header(header, val);
+        }
+
+        if let Some(body) = request.body {
+            builder = builder.body(reqwest::Body::from(body));
+        }
+
+        let request = builder
+            .build()
+            .context("Failed to construct http request")?;
+
+        let mut response = client.execute(request).await?;
+        let headers = std::mem::take(response.headers_mut());
+
+        let status = response.status();
+        let data = if let Some(timeout) = self.response_body_chunk_timeout {
+            let mut stream = response.bytes_stream();
+            let mut buf = Vec::new();
+            while let Some(chunk) = tokio::time::timeout(timeout, stream.try_next()).await?? {
+                buf.extend_from_slice(&chunk);
+            }
+            buf
+        } else {
+            response.bytes().await?.to_vec()
+        };
+
+        Ok(HttpResponse {
+            status,
+            redirected: false,
+            body: Some(data),
+            headers,
+        })
+    }
+}
+
+impl super::HttpClient for ReqwestHttpClient {
+    fn request(&self, request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+        let client = self.clone();
+        let f = async move { client.request(request).await };
+        Box::pin(f)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/web_http_client.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/web_http_client.rs
new file mode 100644
index 0000000..3eaf942
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/http/web_http_client.rs
@@ -0,0 +1,341 @@
+use std::sync::Arc;
+
+use anyhow::{Context, Error};
+use futures::{channel::oneshot, future::BoxFuture};
+use http::header::{HeaderMap, HeaderValue, IntoHeaderName};
+use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen_futures::JsFuture;
+use web_sys::{RequestInit, RequestMode, Window, WorkerGlobalScope};
+
+use crate::{
+    http::{HttpClient, HttpRequest, HttpRequestOptions, HttpResponse},
+    utils::web::js_error,
+    VirtualTaskManager, WasiThreadError,
+};
+
+#[derive(Debug, Default, Clone)]
+#[non_exhaustive]
+pub struct WebHttpClient {
+    default_headers: HeaderMap,
+    tasks: Option<Arc<dyn VirtualTaskManager + Send + Sync>>,
+}
+
+impl WebHttpClient {
+    pub fn new() -> Self {
+        WebHttpClient {
+            default_headers: HeaderMap::new(),
+            tasks: None,
+        }
+    }
+
+    pub fn with_task_manager(
+        &mut self,
+        tasks: Arc<dyn VirtualTaskManager + Send + Sync>,
+    ) -> &mut Self {
+        self.tasks = Some(tasks);
+        self
+    }
+
+    pub fn with_default_header(
+        &mut self,
+        name: impl IntoHeaderName,
+        value: HeaderValue,
+    ) -> &mut Self {
+        self.default_headers.insert(name, value);
+        self
+    }
+
+    pub fn extend_default_headers(&mut self, map: HeaderMap) -> &mut Self {
+        self.default_headers.extend(map);
+        self
+    }
+
+    /// Execute a `fetch()` request.
+    ///
+    /// # Hack
+    ///
+    /// This function is here to work around issues that are associated with the
+    /// promises we get when calling into JavaScript.
+    ///
+    /// Under most conditions it's perfectly fine to call
+    /// [`wasm_bindgen_futures::spawn_local()`] directly from the
+    /// [`WebHttpClient::request()`] method, however there is a pretty nasty
+    /// gotcha when it comes to syscalls.
+    ///
+    /// - The Wasmer VM doesn't support `async` host functions, so all
+    ///   syscalls must block
+    /// - Some syscalls need to run asynchronous operations
+    /// - To call async code from a sync function, we use
+    ///   [`crate::syscalls::__asyncify_light()`] which uses
+    ///   [`futures::executor::block_on()`] to poll the future on the current
+    ///   thread until it resolves
+    /// - In order for a [`wasm_bindgen_futures::spawn_local()`] future (i.e.
+    ///   `fetch()`) to run to completion, you need to return control to the
+    ///   JavaScript event loop
+    ///
+    /// This causes a nasty deadlock where the syscall won't return until the
+    /// `fetch()` promise resolves, but the `fetch()` promise can't resolve
+    /// until the syscall returns.
+    ///
+    /// We saw one example of this when a WASIX program uses the `wasmer run
+    /// ...` virtual command and the [`crate::Runtime`] needs to load a package
+    /// from the registry.
+    ///
+    /// The workaround is use a [`VirtualTaskManager`] to run `fetch()` on a
+    /// background thread and hope *that* thread doesn't get stuck in a
+    /// deadlock. Otherwise if no [`VirtualTaskManager`] was provided, we'll run
+    /// the `fetch()` request on the current event loop and hope for the best.
+    fn spawn_js(
+        &self,
+        request: HttpRequest,
+    ) -> Result<oneshot::Receiver<Result<HttpResponse, Error>>, WasiThreadError> {
+        let (sender, receiver) = oneshot::channel();
+
+        fn spawn_fetch(request: HttpRequest, sender: oneshot::Sender<Result<HttpResponse, Error>>) {
+            wasm_bindgen_futures::spawn_local(async move {
+                let result = fetch(request).await;
+                let _ = sender.send(result);
+            });
+        }
+
+        match self.tasks.as_deref() {
+            Some(tasks) => {
+                tasks.task_shared(Box::new(|| {
+                    Box::pin(async move {
+                        spawn_fetch(request, sender);
+                    })
+                }))?;
+            }
+            None => {
+                spawn_fetch(request, sender);
+            }
+        }
+
+        Ok(receiver)
+    }
+}
+
+impl HttpClient for WebHttpClient {
+    fn request(&self, mut request: HttpRequest) -> BoxFuture<'_, Result<HttpResponse, Error>> {
+        for (name, value) in &self.default_headers {
+            if !request.headers.contains_key(name) {
+                request.headers.insert(name, value.clone());
+            }
+        }
+
+        let receiver = self.spawn_js(request);
+
+        Box::pin(async move {
+            match receiver?.await {
+                Ok(result) => result,
+                Err(e) => Err(Error::new(e)),
+            }
+        })
+    }
+}
+
+/// Send a `fetch()` request using the browser APIs.
+async fn fetch(request: HttpRequest) -> Result<HttpResponse, Error> {
+    let HttpRequest {
+        url,
+        method,
+        headers,
+        body,
+        options: HttpRequestOptions {
+            gzip: _,
+            cors_proxy,
+        },
+    } = request;
+
+    let mut opts = RequestInit::new();
+    opts.method(method.as_str());
+    opts.mode(RequestMode::Cors);
+
+    if let Some(data) = body {
+        let data_len = data.len();
+        let array = js_sys::Uint8Array::new_with_length(data_len as u32);
+        array.copy_from(&data[..]);
+
+        opts.body(Some(&array));
+    }
+
+    let request = {
+        let request = web_sys::Request::new_with_str_and_init(url.as_str(), &opts)
+            .map_err(js_error)
+            .context("Could not construct request object")?;
+
+        let set_headers = request.headers();
+
+        for (name, val) in headers.iter() {
+            let val = String::from_utf8_lossy(val.as_bytes());
+            set_headers
+                .set(name.as_str(), &val)
+                .map_err(js_error)
+                .with_context(|| format!("could not apply request header: '{name}': '{val}'"))?;
+        }
+        request
+    };
+
+    let resp_value = match call_fetch(&request).await {
+        Ok(a) => a,
+        Err(e) => {
+            // If the request failed it may be because of CORS so if a cors proxy
+            // is configured then try again with the cors proxy
+            let url = if let Some(cors_proxy) = cors_proxy {
+                format!("https://{}/{}", cors_proxy, url)
+            } else {
+                return Err(js_error(e).context(format!("Could not fetch '{url}'")));
+            };
+
+            let request = web_sys::Request::new_with_str_and_init(&url, &opts)
+                .map_err(js_error)
+                .with_context(|| format!("Could not construct request for url '{url}'"))?;
+
+            let set_headers = request.headers();
+            for (name, val) in headers.iter() {
+                let value = String::from_utf8_lossy(val.as_bytes());
+                set_headers
+                    .set(name.as_str(), &value)
+                    .map_err(js_error)
+                    .with_context(|| {
+                        anyhow::anyhow!("Could not apply request header: '{name}': '{value}'")
+                    })?;
+            }
+
+            call_fetch(&request)
+                .await
+                .map_err(js_error)
+                .with_context(|| format!("Could not fetch '{url}'"))?
+        }
+    };
+
+    let response = resp_value.dyn_ref().unwrap();
+    read_response(response).await
+}
+
+async fn read_response(response: &web_sys::Response) -> Result<HttpResponse, anyhow::Error> {
+    let status = http::StatusCode::from_u16(response.status())?;
+    let headers = headers(response.headers()).context("Unable to read the headers")?;
+    let body = get_response_data(response).await?;
+
+    Ok(HttpResponse {
+        body: Some(body),
+        redirected: response.redirected(),
+        status,
+        headers,
+    })
+}
+
+fn headers(headers: web_sys::Headers) -> Result<http::HeaderMap, anyhow::Error> {
+    let iter = js_sys::try_iter(&headers)
+        .map_err(js_error)?
+        .context("Not an iterator")?;
+    let mut header_map = http::HeaderMap::new();
+
+    for pair in iter {
+        let pair = pair.map_err(js_error)?;
+        let [key, value]: [js_sys::JsString; 2] =
+            js_array(&pair).context("Unable to unpack the header's key-value pairs")?;
+
+        let key = String::from(key);
+        let key: http::HeaderName = key.parse()?;
+        let value = String::from(value);
+        let value = http::HeaderValue::from_str(&value)
+            .with_context(|| format!("Invalid header value: {value}"))?;
+
+        header_map.insert(key, value);
+    }
+
+    Ok(header_map)
+}
+
+fn js_array<T, const N: usize>(value: &JsValue) -> Result<[T; N], anyhow::Error>
+where
+    T: JsCast,
+{
+    let array: &js_sys::Array = value.dyn_ref().context("Not an array")?;
+
+    let mut items = Vec::new();
+
+    for value in array.iter() {
+        let item = value
+            .dyn_into()
+            .map_err(|_| anyhow::anyhow!("Unable to cast to a {}", std::any::type_name::<T>()))?;
+        items.push(item);
+    }
+
+    <[T; N]>::try_from(items).map_err(|original| {
+        anyhow::anyhow!(
+            "Unable to turn a list of {} items into an array of {N} items",
+            original.len()
+        )
+    })
+}
+
+pub async fn get_response_data(resp: &web_sys::Response) -> Result<Vec<u8>, anyhow::Error> {
+    let buffer = JsFuture::from(resp.array_buffer().unwrap())
+        .await
+        .map_err(js_error)
+        .with_context(|| "Could not retrieve response body".to_string())?;
+
+    let buffer = js_sys::Uint8Array::new(&buffer);
+
+    Ok(buffer.to_vec())
+}
+
+fn call_fetch(request: &web_sys::Request) -> JsFuture {
+    let global = js_sys::global();
+    if JsValue::from_str("WorkerGlobalScope").js_in(&global)
+        && global.is_instance_of::<WorkerGlobalScope>()
+    {
+        JsFuture::from(
+            global
+                .unchecked_into::<WorkerGlobalScope>()
+                .fetch_with_request(request),
+        )
+    } else {
+        JsFuture::from(
+            global
+                .unchecked_into::<Window>()
+                .fetch_with_request(request),
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::resolver::WapmSource;
+
+    #[wasm_bindgen_test::wasm_bindgen_test]
+    async fn query_the_wasmer_registry_graphql_endpoint() {
+        let http_client = WebHttpClient::default();
+        let query = r#"{
+            "query": "{ info { defaultFrontend } }"
+        }"#;
+        let request = http::Request::post(WapmSource::WASMER_PROD_ENDPOINT)
+            .header(http::header::CONTENT_TYPE, "application/json")
+            .body(query)
+            .unwrap();
+
+        let response = http_client.request(request.into()).await.unwrap();
+
+        assert_eq!(
+            response
+                .headers
+                .get(http::header::CONTENT_TYPE)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            "application/json",
+        );
+        let body: serde_json::Value =
+            serde_json::from_slice(response.body.as_deref().unwrap()).unwrap();
+        let frontend_url = body
+            .pointer("/data/info/defaultFrontend")
+            .unwrap()
+            .as_str()
+            .unwrap();
+        assert_eq!(frontend_url, "https://wasmer.io");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/memory_and_snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/memory_and_snapshot.rs
new file mode 100644
index 0000000..145f5ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/memory_and_snapshot.rs
@@ -0,0 +1,221 @@
+use std::collections::{hash_map, BTreeMap};
+
+use crate::os::task::process::MemorySnapshotRegion;
+
+use super::*;
+
+/// This value is tweaked to minimize the amount of journal
+/// entries for a nominal workload but keep the resolution
+/// high enough that it reduces overhead and inefficiency.
+///
+/// The test case used to tune this value was a HTTP server
+/// serving a HTTP web page on hyper compiled to WASM. The
+/// server was first warmed up with a bunch of requests then
+/// the journal entries measured on subsequent requests, these
+/// are the values
+///
+/// Resolution | Journal Size | Memory Overhead
+/// -----------|--------------|----------------
+/// 128 bytes  | 3584 bytes   | 12.5%
+/// 256 bytes  | 4096 bytes   | 6.25%
+/// 512 bytes  | 7680 bytes   | 3.12%
+/// 1024 bytes | 12288 bytes  | 1.56%
+/// 2048 bytes | 22528 bytes  | 0.78%
+/// 4096 bytes | 32769 bytes  | 0.39%
+///
+/// Based on this data we have settled on 512 byte memory resolution
+/// for region extents which keeps the journal size to a reasonable
+/// value and the memory overhead of the hash table within an acceptable
+/// limit
+const MEMORY_REGION_RESOLUTION: u64 = 512;
+
+impl JournalEffector {
+    pub fn save_memory_and_snapshot(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        guard: &mut MutexGuard<'_, WasiProcessInner>,
+        trigger: SnapshotTrigger,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(ctx) };
+
+        // Compute all the regions that we need to save which is basically
+        // everything in the memory except for the memory stacks.
+        //
+        // We do not want the regions to be greater than 64KB as this will
+        // otherwise create too much inefficiency. We choose 64KB as its
+        // aligned with the standard WASM page size.
+        let mut cur = 0u64;
+        let mut regions = Vec::<MemorySnapshotRegion>::new();
+        while cur < memory.data_size() {
+            let mut again = false;
+            let next = ((cur + MEMORY_REGION_RESOLUTION) / MEMORY_REGION_RESOLUTION)
+                * MEMORY_REGION_RESOLUTION;
+            let mut end = memory.data_size().min(next);
+            for (_, thread) in guard.threads.iter() {
+                let layout = thread.memory_layout();
+                if cur >= layout.stack_lower && cur < layout.stack_upper {
+                    cur = layout.stack_upper;
+                    again = true;
+                    break;
+                }
+                if end > layout.stack_lower && end < layout.stack_upper {
+                    end = end.min(layout.stack_lower);
+                }
+            }
+            if again {
+                continue;
+            }
+
+            let region = cur..end;
+            regions.push(region.into());
+            cur = end;
+        }
+
+        // Next we examine the dirty page manager and filter out any pages
+        // that have not been explicitly written to (according to the
+        // PTE)
+        //
+        // # TODO
+        // https://docs.kernel.org/admin-guide/mm/soft-dirty.html
+
+        // Now that we know all the regions that need to be saved we
+        // enter a processing loop that dumps all the data to the log
+        // file in an orderly manner.
+        let memory = unsafe { env.memory_view(ctx) };
+        let journal = ctx.data().active_journal()?;
+
+        let mut regions_phase2 = BTreeMap::new();
+        for region in regions.drain(..) {
+            // We grab this region of memory as a vector and hash
+            // it, which allows us to make some logging efficiency
+            // gains.
+            #[cfg(not(feature = "sys"))]
+            let data = memory
+                .copy_range_to_vec(region.into())
+                .map_err(mem_error_to_wasi)?;
+
+            // For x86 implementations running natively we have a
+            // performance optimization that avoids a copy of the
+            // memory when hashing for changed regions
+            #[cfg(feature = "sys")]
+            let data = {
+                let d = unsafe { memory.data_unchecked() };
+                if region.end > d.len() as u64 {
+                    return Err(anyhow::anyhow!(
+                        "memory access out of bounds ({} vs {})",
+                        region.end,
+                        d.len()
+                    ));
+                }
+                &d[region.start as usize..region.end as usize]
+            };
+
+            // Compute a checksum and skip the memory if its already
+            // been saved to the journal once already
+            let hash = {
+                let h: [u8; 32] = blake3::hash(data).into();
+                u64::from_be_bytes([h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]])
+            };
+            match guard.snapshot_memory_hash.entry(region) {
+                hash_map::Entry::Occupied(mut val) => {
+                    if *val.get() == hash {
+                        continue;
+                    }
+                    val.insert(hash);
+                }
+                hash_map::Entry::Vacant(vacant) => {
+                    vacant.insert(hash);
+                }
+            }
+
+            regions_phase2.insert(region, ());
+        }
+
+        // Combine regions together that are next to each other
+        regions.clear();
+        let mut last_end = None;
+        for (region, _) in regions_phase2.iter() {
+            if Some(region.start) == last_end {
+                regions.last_mut().unwrap().end = region.end;
+            } else {
+                regions.push(*region);
+            }
+            last_end = Some(region.end);
+        }
+
+        // Perform the writes
+        for region in regions {
+            // We grab this region of memory as a vector and hash
+            // it, which allows us to make some logging efficiency
+            // gains.
+            let data = memory
+                .copy_range_to_vec(region.into())
+                .map_err(mem_error_to_wasi)?;
+
+            // Now we write it to the snap snapshot capturer
+            journal
+                .write(JournalEntry::UpdateMemoryRegionV1 {
+                    region: region.into(),
+                    data: data.into(),
+                })
+                .map_err(map_snapshot_err)?;
+        }
+
+        // Finally we mark the end of the snapshot so that
+        // it can act as a restoration point
+        let when = SystemTime::now();
+        journal
+            .write(JournalEntry::SnapshotV1 { when, trigger })
+            .map_err(map_snapshot_err)?;
+        Ok(())
+    }
+
+    /// # Safety
+    ///
+    /// This function manipulates the memory of the process and thus must be executed
+    /// by the WASM process thread itself.
+    ///
+    pub unsafe fn apply_memory(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        region: Range<u64>,
+        mut data: &[u8],
+    ) -> anyhow::Result<()> {
+        let (env, mut store) = ctx.data_and_store_mut();
+
+        let memory = unsafe { env.memory() };
+        memory.grow_at_least(&mut store, region.end + data.len() as u64)?;
+
+        // Write the data to the memory
+        let memory = unsafe { env.memory_view(&store) };
+        memory
+            .write(region.start, data)
+            .map_err(|err| WasiRuntimeError::Runtime(RuntimeError::user(err.into())))?;
+
+        // Break the region down into chunks that align with the resolution
+        let mut offset = region.start;
+        while offset < region.end {
+            let next = region.end.min(offset + MEMORY_REGION_RESOLUTION);
+            let region = offset..next;
+            offset = next;
+
+            // Compute the hash and update it
+            let size = region.end - region.start;
+            let hash = {
+                let h: [u8; 32] = blake3::hash(&data[..size as usize]).into();
+                u64::from_be_bytes([h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]])
+            };
+            env.process
+                .inner
+                .0
+                .lock()
+                .unwrap()
+                .snapshot_memory_hash
+                .insert(region.into(), hash);
+
+            // Shift the data pointer
+            data = &data[size as usize..];
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/mod.rs
new file mode 100644
index 0000000..632207a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/mod.rs
@@ -0,0 +1,103 @@
+pub(super) use std::{borrow::Cow, ops::Range, sync::MutexGuard, time::SystemTime};
+
+pub(super) use anyhow::bail;
+pub(super) use bytes::Bytes;
+pub(super) use wasmer::{FunctionEnvMut, RuntimeError, WasmPtr};
+pub(super) use wasmer_types::MemorySize;
+pub(super) use wasmer_wasix_types::{
+    types::__wasi_ciovec_t,
+    wasi::{
+        Advice, EpollCtl, EpollEventCtl, Errno, ExitCode, Fd, Fdflags, Filesize, Fstflags,
+        LookupFlags, Oflags, Rights, Snapshot0Clockid, Timestamp, Whence,
+    },
+};
+
+pub(super) use crate::{
+    mem_error_to_wasi,
+    os::task::process::WasiProcessInner,
+    syscalls::{fd_write_internal, FdWriteSource},
+    utils::map_snapshot_err,
+    WasiEnv, WasiRuntimeError, WasiThreadId,
+};
+
+use super::*;
+
+#[cfg(feature = "journal")]
+mod syscalls {
+    pub(super) use super::*;
+    mod chdir;
+    mod clock_time;
+    mod epoll_create;
+    mod epoll_ctl;
+    mod fd_advise;
+    mod fd_allocate;
+    mod fd_close;
+    mod fd_duplicate;
+    mod fd_event;
+    mod fd_pipe;
+    mod fd_renumber;
+    mod fd_seek;
+    mod fd_set_flags;
+    mod fd_set_rights;
+    mod fd_set_size;
+    mod fd_set_times;
+    mod fd_write;
+    mod path_create_directory;
+    mod path_link;
+    mod path_open;
+    mod path_remove_directory;
+    mod path_rename;
+    mod path_set_times;
+    mod path_symlink;
+    mod path_unlink;
+    mod port_addr_add;
+    mod port_addr_clear;
+    mod port_addr_remove;
+    mod port_bridge;
+    mod port_dhcp_acquire;
+    mod port_gateway_set;
+    mod port_route_add;
+    mod port_route_clear;
+    mod port_route_remove;
+    mod port_unbridge;
+    mod sock_accept;
+    mod sock_bind;
+    mod sock_connect;
+    mod sock_join_ipv4_multicast;
+    mod sock_join_ipv6_multicast;
+    mod sock_leave_ipv4_multicast;
+    mod sock_leave_ipv6_multicast;
+    mod sock_listen;
+    mod sock_open;
+    mod sock_send;
+    mod sock_send_file;
+    mod sock_send_to;
+    mod sock_set_opt_flag;
+    mod sock_set_opt_size;
+    mod sock_set_opt_time;
+    mod sock_shutdown;
+    mod tty_set;
+}
+#[cfg(feature = "journal")]
+mod memory_and_snapshot;
+#[cfg(feature = "journal")]
+mod process_exit;
+#[cfg(feature = "journal")]
+mod save_event;
+#[cfg(feature = "journal")]
+mod thread_exit;
+#[cfg(feature = "journal")]
+mod thread_state;
+
+/// The journal effector is an adapter that will be removed in a future refactor.
+/// Its purpose is to put the code that does mappings from WASM memory through its
+/// abstractions into concrete journal objects that can be stored. Instead of this
+/// what should be done is that the syscalls themselves can be represented as a
+/// strongly typed object that can be passed directly to the journal but in order
+/// to do this we require an extensive refactoring of the WASIX syscalls which
+/// is not in scope at this time.
+///
+/// Separating this out now makes it easier to eliminate later without hurting the
+/// journal event abstraction through leaking abstraction layers.
+#[derive(Debug, Clone)]
+pub struct JournalEffector {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/process_exit.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/process_exit.rs
new file mode 100644
index 0000000..d57264e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/process_exit.rs
@@ -0,0 +1,38 @@
+use virtual_mio::InlineWaker;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_process_exit(env: &WasiEnv, exit_code: Option<ExitCode>) -> anyhow::Result<()> {
+        env.active_journal()?
+            .write(JournalEntry::ProcessExitV1 { exit_code })
+            .map_err(map_snapshot_err)?;
+        Ok(())
+    }
+
+    /// # Safety
+    ///
+    /// This function manipulates the memory of the process and thus must be executed
+    /// by the WASM process thread itself.
+    ///
+    pub unsafe fn apply_process_exit(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        exit_code: Option<ExitCode>,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        // If we are in the phase of replaying journals then we
+        // close all the file descriptors but we don't actually send
+        // any signals
+        if env.replaying_journal {
+            let state = env.state.clone();
+            InlineWaker::block_on(state.fs.close_all());
+        } else {
+            env.blocking_on_exit(exit_code);
+        }
+
+        // Reset the memory back to a zero size
+        let memory = ctx.data_mut().inner().memory().clone();
+        memory.reset(ctx)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/save_event.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/save_event.rs
new file mode 100644
index 0000000..415b61c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/save_event.rs
@@ -0,0 +1,19 @@
+use super::*;
+
+impl JournalEffector {
+    pub(crate) fn save_event(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        event: JournalEntry,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        if !env.should_journal() {
+            return Ok(());
+        }
+
+        ctx.data()
+            .active_journal()?
+            .write(event)
+            .map_err(map_snapshot_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/chdir.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/chdir.rs
new file mode 100644
index 0000000..aa3041a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/chdir.rs
@@ -0,0 +1,18 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_chdir(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: String) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::ChangeDirectoryV1 { path: path.into() })
+    }
+
+    pub fn apply_chdir(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: &str) -> anyhow::Result<()> {
+        crate::syscalls::chdir_internal(ctx, path).map_err(|err| {
+            anyhow::format_err!(
+                "snapshot restore error: failed to change directory (path={}) - {}",
+                path,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/clock_time.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/clock_time.rs
new file mode 100644
index 0000000..c196732
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/clock_time.rs
@@ -0,0 +1,28 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_clock_time_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        clock_id: Snapshot0Clockid,
+        time: Timestamp,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SetClockTimeV1 { clock_id, time })
+    }
+
+    pub fn apply_clock_time_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        clock_id: Snapshot0Clockid,
+        time: Timestamp,
+    ) -> anyhow::Result<()> {
+        let ret = crate::syscalls::clock_time_set_internal(ctx, clock_id, time);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed to set clock time (clock_id={:?}, time={}) - {}",
+                clock_id,
+                time,
+                ret
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_create.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
new file mode 100644
index 0000000..7fbe2ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_create.rs
@@ -0,0 +1,29 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_epoll_create(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::EpollCreateV1 { fd })
+    }
+
+    pub fn apply_epoll_create(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
+        let ret_fd = crate::syscalls::epoll_create_internal(ctx)
+            .map_err(|err| {
+                anyhow::format_err!("journal restore error: failed to create epoll - {}", err)
+            })?
+            .map_err(|err| {
+                anyhow::format_err!("journal restore error: failed to create epoll - {}", err)
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after epoll create (from={}, to={}) - {}",
+                ret_fd,
+                fd,
+                ret
+            );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs
new file mode 100644
index 0000000..e471999
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/epoll_ctl.rs
@@ -0,0 +1,51 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_epoll_ctl(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        epfd: Fd,
+        op: EpollCtl,
+        fd: Fd,
+        event: Option<EpollEventCtl>,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            },
+        )
+    }
+
+    pub fn apply_epoll_ctl(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        pfd: Fd,
+        op: EpollCtl,
+        fd: Fd,
+        event: Option<EpollEventCtl>,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::epoll_ctl_internal(ctx, pfd, op, fd, event.as_ref())
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to epoll ctl (pfd={}, op={:?}, fd={}) - {}",
+                    pfd,
+                    op,
+                    fd,
+                    err
+                )
+            })?
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to epoll ctl (pfd={}, op={:?}, fd={}) - {}",
+                    pfd,
+                    op,
+                    fd,
+                    err
+                )
+            })?;
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_advise.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_advise.rs
new file mode 100644
index 0000000..12cd5e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_advise.rs
@@ -0,0 +1,41 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_advise(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+        advice: Advice,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::FileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice,
+            },
+        )
+    }
+
+    pub fn apply_fd_advise(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+        advice: Advice,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_advise_internal(ctx, fd, offset, len, advice).map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to advise file descriptor (fd={}, offset={}, len={}, advice={:?}) - {}",
+                fd,
+                offset,
+                len,
+                advice,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs
new file mode 100644
index 0000000..6ecacb8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_allocate.rs
@@ -0,0 +1,34 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_allocate(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len },
+        )
+    }
+
+    pub fn apply_fd_allocate(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_allocate_internal(ctx, fd, offset, len)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to allocate on file descriptor (fd={}, offset={}, len={}) - {}",
+                    fd,
+                    offset,
+                    len,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_close.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_close.rs
new file mode 100644
index 0000000..4ec6691
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_close.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_close(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::CloseFileDescriptorV1 { fd })
+    }
+
+    pub fn apply_fd_close(ctx: &mut FunctionEnvMut<'_, WasiEnv>, fd: Fd) -> anyhow::Result<()> {
+        let env = ctx.data();
+        let (_, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+        if let Err(err) = state.fs.close_fd(fd) {
+            bail!(
+                "journal restore error: failed to close descriptor (fd={}) - {}",
+                fd,
+                err
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
new file mode 100644
index 0000000..a53be32
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_duplicate.rs
@@ -0,0 +1,44 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_duplicate(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        original_fd: Fd,
+        copied_fd: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            },
+        )
+    }
+
+    pub fn apply_fd_duplicate(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        original_fd: Fd,
+        copied_fd: Fd,
+    ) -> anyhow::Result<()> {
+        let ret_fd = crate::syscalls::fd_dup_internal(ctx, original_fd)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to duplicate file descriptor (original={}, copied={}) - {}",
+                    original_fd,
+                    copied_fd,
+                    err
+                )
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, copied_fd);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after duplicate (from={}, to={}) - {}",
+                ret_fd,
+                copied_fd,
+                ret
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_event.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_event.rs
new file mode 100644
index 0000000..a307389
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_event.rs
@@ -0,0 +1,47 @@
+use wasmer_wasix_types::wasi::EventFdFlags;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_event(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        initial_val: u64,
+        flags: EventFdFlags,
+        fd: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::CreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            },
+        )
+    }
+
+    pub fn apply_fd_event(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        initial_val: u64,
+        flags: EventFdFlags,
+        fd: Fd,
+    ) -> anyhow::Result<()> {
+        let ret_fd = crate::syscalls::fd_event_internal(ctx, initial_val, flags)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!("journal restore error: failed to create event - {}", err)
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after create event (from={}, to={}) - {}",
+                ret_fd,
+                fd,
+                ret
+            );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
new file mode 100644
index 0000000..21b32d8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_pipe.rs
@@ -0,0 +1,43 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_pipe(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd1: Fd,
+        fd2: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::CreatePipeV1 { fd1, fd2 })
+    }
+
+    pub fn apply_fd_pipe(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd1: Fd,
+        fd2: Fd,
+    ) -> anyhow::Result<()> {
+        let (ret_fd1, ret_fd2) = crate::syscalls::fd_pipe_internal(ctx).map_err(|err| {
+            anyhow::format_err!("journal restore error: failed to create pipe - {}", err)
+        })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd1, fd1);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after create pipe (from={}, to={}) - {}",
+                ret_fd1,
+                fd1,
+                ret
+            );
+        }
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd2, fd2);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after create pipe (from={}, to={}) - {}",
+                ret_fd2,
+                fd2,
+                ret
+            );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs
new file mode 100644
index 0000000..c439d75
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_renumber.rs
@@ -0,0 +1,34 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_renumber(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        from: Fd,
+        to: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::RenumberFileDescriptorV1 {
+                old_fd: from,
+                new_fd: to,
+            },
+        )
+    }
+
+    pub fn apply_fd_renumber(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        from: Fd,
+        to: Fd,
+    ) -> anyhow::Result<()> {
+        let ret = crate::syscalls::fd_renumber_internal(ctx, from, to);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed to renumber descriptor (from={}, to={}) - {}",
+                from,
+                to,
+                ret
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_seek.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_seek.rs
new file mode 100644
index 0000000..7cd7787
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_seek.rs
@@ -0,0 +1,33 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_seek(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: i64,
+        whence: Whence,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence },
+        )
+    }
+
+    pub fn apply_fd_seek(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: i64,
+        whence: Whence,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_seek_internal(ctx, fd, offset, whence)?.map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to seek (fd={}, offset={}, whence={:?}) - {}",
+                fd,
+                offset,
+                whence,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs
new file mode 100644
index 0000000..669041a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_flags.rs
@@ -0,0 +1,27 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_set_flags(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: Fdflags,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::FileDescriptorSetFlagsV1 { fd, flags })
+    }
+
+    pub fn apply_fd_set_flags(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: Fdflags,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_fdstat_set_flags_internal(ctx, fd, flags).map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to set file flags (fd={}, flags={:?}) - {}",
+                fd,
+                flags,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs
new file mode 100644
index 0000000..6d77752
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_rights.rs
@@ -0,0 +1,38 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_set_rights(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            },
+        )
+    }
+
+    pub fn apply_fd_set_rights(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_fdstat_set_rights_internal(ctx, fd, fs_rights_base, fs_rights_inheriting)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set file rights (fd={}, fs_rights_base={:?}, fs_rights_inheriting={:?}) - {}",
+                    fd,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs
new file mode 100644
index 0000000..58980c1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_size.rs
@@ -0,0 +1,27 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_set_size(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        st_size: Filesize,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::FileDescriptorSetSizeV1 { fd, st_size })
+    }
+
+    pub fn apply_fd_set_size(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        st_size: Filesize,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_filestat_set_size_internal(ctx, fd, st_size).map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to set file size (fd={}, st_size={}) - {}",
+                fd,
+                st_size,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs
new file mode 100644
index 0000000..633ba07
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_set_times.rs
@@ -0,0 +1,42 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_set_times(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            },
+        )
+    }
+
+    pub fn apply_fd_set_times(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::fd_filestat_set_times_internal(ctx, fd, st_atim, st_mtim, fst_flags)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set file times (fd={}, st_atim={}, st_mtim={}, fst_flags={:?}) - {}",
+                    fd,
+                    st_atim,
+                    st_mtim,
+                    fst_flags,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_write.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_write.rs
new file mode 100644
index 0000000..689adc9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/fd_write.rs
@@ -0,0 +1,72 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_fd_write<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        mut offset: u64,
+        written: usize,
+        iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+        iovs_len: M::Offset,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        let iovs_arr = iovs.slice(&memory, iovs_len)?;
+
+        let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+        let mut remaining: M::Offset = TryFrom::<usize>::try_from(written).unwrap_or_default();
+        for iovs in iovs_arr.iter() {
+            let sub = iovs.buf_len.min(remaining);
+            if sub == M::ZERO {
+                continue;
+            }
+            remaining -= sub;
+
+            let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                .slice(&memory, sub)
+                .map_err(mem_error_to_wasi)?
+                .access()
+                .map_err(mem_error_to_wasi)?;
+            let data = Cow::Borrowed(buf.as_ref());
+            let data_len = data.len();
+
+            ctx.data()
+                .active_journal()?
+                .write(JournalEntry::FileDescriptorWriteV1 {
+                    fd,
+                    offset,
+                    data,
+                    is_64bit: M::is_64bit(),
+                })
+                .map_err(map_snapshot_err)?;
+
+            offset += data_len as u64;
+        }
+        Ok(())
+    }
+
+    pub fn apply_fd_write<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        offset: u64,
+        data: Cow<'_, [u8]>,
+    ) -> anyhow::Result<()> {
+        fd_write_internal(
+            ctx,
+            fd,
+            FdWriteSource::<'_, M>::Buffer(data),
+            offset,
+            true,
+            false,
+        )?
+        .map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to write to descriptor (fd={}, offset={}) - {}",
+                fd,
+                offset,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs
new file mode 100644
index 0000000..223bce3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_create_directory.rs
@@ -0,0 +1,44 @@
+use std::path::Path;
+
+use virtual_fs::FileSystem;
+
+use crate::VIRTUAL_ROOT_FD;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_create_directory(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::CreateDirectoryV1 {
+                fd,
+                path: path.into(),
+            },
+        )
+    }
+
+    pub fn apply_path_create_directory(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: &str,
+    ) -> anyhow::Result<()> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if fd == VIRTUAL_ROOT_FD {
+            ctx.data().state.fs.root_fs.create_dir(Path::new(path))?;
+        } else {
+            crate::syscalls::path_create_directory_internal(ctx, fd, path).map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to create directory path (fd={}, path={}) - {}",
+                    fd,
+                    path,
+                    err
+                )
+            })?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_link.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_link.rs
new file mode 100644
index 0000000..822f671
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_link.rs
@@ -0,0 +1,46 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_link(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_fd: Fd,
+        old_flags: LookupFlags,
+        old_path: String,
+        new_fd: Fd,
+        new_path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::CreateHardLinkV1 {
+                old_fd,
+                old_flags,
+                old_path: old_path.into(),
+                new_fd,
+                new_path: new_path.into(),
+            },
+        )
+    }
+
+    pub fn apply_path_link(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_fd: Fd,
+        old_flags: LookupFlags,
+        old_path: &str,
+        new_fd: Fd,
+        new_path: &str,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::path_link_internal(ctx, old_fd, old_flags, old_path, new_fd, new_path)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to create hard link (old_fd={}, old_flags={}, old_path={}, new_fd={}, new_path={}) - {}",
+                    old_fd,
+                    old_flags,
+                    old_path,
+                    new_fd,
+                    new_path,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_open.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_open.rs
new file mode 100644
index 0000000..f63e303
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_open.rs
@@ -0,0 +1,77 @@
+use super::*;
+
+impl JournalEffector {
+    #[allow(clippy::too_many_arguments)]
+    pub fn save_path_open(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        dirfd: Fd,
+        dirflags: LookupFlags,
+        path: String,
+        o_flags: Oflags,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+        fs_flags: Fdflags,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path: path.into(),
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            },
+        )
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn apply_path_open(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        dirfd: Fd,
+        dirflags: LookupFlags,
+        path: &str,
+        o_flags: Oflags,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+        fs_flags: Fdflags,
+    ) -> anyhow::Result<()> {
+        let res = crate::syscalls::path_open_internal(
+            ctx,
+            dirfd,
+            dirflags,
+            path,
+            o_flags,
+            fs_rights_base,
+            fs_rights_inheriting,
+            fs_flags,
+        );
+        let ret_fd = match res? {
+            Ok(fd) => fd,
+            Err(err) => {
+                bail!(
+                    "journal restore error: failed to open descriptor (fd={}, path={}) - {}",
+                    fd,
+                    path,
+                    err
+                );
+            }
+        };
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                "journal restore error: failed renumber file descriptor after open (from={}, to={}) - {}",
+                ret_fd,
+                fd,
+                ret
+            );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs
new file mode 100644
index 0000000..f26fb5d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_remove_directory.rs
@@ -0,0 +1,40 @@
+use std::path::Path;
+
+use virtual_fs::FileSystem;
+
+use crate::VIRTUAL_ROOT_FD;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_remove_directory(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::RemoveDirectoryV1 {
+                fd,
+                path: Cow::Owned(path),
+            },
+        )
+    }
+
+    pub fn apply_path_remove_directory(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: &str,
+    ) -> anyhow::Result<()> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if fd == VIRTUAL_ROOT_FD {
+            ctx.data().state.fs.root_fs.remove_dir(Path::new(path))?;
+        } else if let Err(err) = crate::syscalls::path_remove_directory_internal(ctx, fd, path) {
+            bail!(
+                "journal restore error: failed to remove directory - {}",
+                err
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_rename.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_rename.rs
new file mode 100644
index 0000000..63d66dd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_rename.rs
@@ -0,0 +1,55 @@
+use crate::{syscalls::__asyncify_light, VIRTUAL_ROOT_FD};
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_rename(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_fd: Fd,
+        old_path: String,
+        new_fd: Fd,
+        new_path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::PathRenameV1 {
+                old_fd,
+                old_path: Cow::Owned(old_path),
+                new_fd,
+                new_path: Cow::Owned(new_path),
+            },
+        )
+    }
+
+    pub fn apply_path_rename(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_fd: Fd,
+        old_path: &str,
+        new_fd: Fd,
+        new_path: &str,
+    ) -> anyhow::Result<()> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if old_fd == VIRTUAL_ROOT_FD && new_fd == VIRTUAL_ROOT_FD {
+            let state = ctx.data().state.clone();
+            let old_path = old_path.to_string();
+            let new_path = new_path.to_string();
+            __asyncify_light(ctx.data(), None, async move {
+                state.fs_rename(old_path, new_path).await
+            })??;
+        } else {
+            let ret =
+                crate::syscalls::path_rename_internal(ctx, old_fd, old_path, new_fd, new_path)?;
+            if ret != Errno::Success {
+                bail!(
+                    "journal restore error: failed to rename path (old_fd={}, old_path={}, new_fd={}, new_path={}) - {}",
+                    old_fd,
+                    old_path,
+                    new_fd,
+                    new_path,
+                    ret
+                );
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_set_times.rs
new file mode 100644
index 0000000..440acc2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_set_times.rs
@@ -0,0 +1,57 @@
+use crate::VIRTUAL_ROOT_FD;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_set_times(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: LookupFlags,
+        path: String,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::PathSetTimesV1 {
+                fd,
+                flags,
+                path: path.into(),
+                st_atim,
+                st_mtim,
+                fst_flags,
+            },
+        )
+    }
+
+    pub fn apply_path_set_times(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        flags: LookupFlags,
+        path: &str,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> anyhow::Result<()> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if fd == VIRTUAL_ROOT_FD {
+            // we ignore this record as its not implemented yet
+        } else {
+            crate::syscalls::path_filestat_set_times_internal(ctx, fd, flags, path, st_atim, st_mtim, fst_flags)
+                .map_err(|err| {
+                    anyhow::format_err!(
+                        "journal restore error: failed to set path times (fd={}, flags={}, path={}, st_atim={}, st_mtim={}, fst_flags={:?}) - {}",
+                        fd,
+                        flags,
+                        path,
+                        st_atim,
+                        st_mtim,
+                        fst_flags,
+                        err
+                    )
+                })?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_symlink.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_symlink.rs
new file mode 100644
index 0000000..60591ca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_symlink.rs
@@ -0,0 +1,38 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_symlink(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_path: String,
+        fd: Fd,
+        new_path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::CreateSymbolicLinkV1 {
+                old_path: old_path.into(),
+                fd,
+                new_path: new_path.into(),
+            },
+        )
+    }
+
+    pub fn apply_path_symlink(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        old_path: &str,
+        fd: Fd,
+        new_path: &str,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::path_symlink_internal(ctx, old_path, fd, new_path)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to create symlink (old_path={}, fd={}, new_path={}) - {}",
+                    old_path,
+                    fd,
+                    new_path,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_unlink.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_unlink.rs
new file mode 100644
index 0000000..035d2e9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/path_unlink.rs
@@ -0,0 +1,45 @@
+use std::path::Path;
+
+use virtual_fs::FileSystem;
+
+use crate::VIRTUAL_ROOT_FD;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_path_unlink(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: String,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::UnlinkFileV1 {
+                fd,
+                path: Cow::Owned(path),
+            },
+        )
+    }
+
+    pub fn apply_path_unlink(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        path: &str,
+    ) -> anyhow::Result<()> {
+        // see `VIRTUAL_ROOT_FD` for details as to why this exists
+        if fd == VIRTUAL_ROOT_FD {
+            ctx.data().state.fs.root_fs.remove_file(Path::new(path))?;
+        } else {
+            let ret = crate::syscalls::path_unlink_file_internal(ctx, fd, path)?;
+            if ret != Errno::Success {
+                bail!(
+                    "journal restore error: failed to remove file (fd={}, path={}) - {}",
+                    fd,
+                    path,
+                    ret
+                );
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs
new file mode 100644
index 0000000..ae508e7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_add.rs
@@ -0,0 +1,29 @@
+use virtual_net::IpCidr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_addr_add(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        cidr: IpCidr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortAddAddrV1 { cidr })
+    }
+
+    pub fn apply_port_addr_add(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        cidr: IpCidr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_addr_add_internal(ctx, cidr)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to add address to port file descriptor (cidr={:?}) - {}",
+                    cidr,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs
new file mode 100644
index 0000000..d68a2a8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_clear.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_addr_clear(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortAddrClearV1)
+    }
+
+    pub fn apply_port_addr_clear(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        crate::syscalls::port_addr_clear_internal(ctx)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to clear port addresses - {}",
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs
new file mode 100644
index 0000000..b2d46f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_addr_remove.rs
@@ -0,0 +1,29 @@
+use std::net::IpAddr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_addr_remove(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        addr: IpAddr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortDelAddrV1 { addr })
+    }
+
+    pub fn apply_port_addr_remove(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        addr: IpAddr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_addr_remove_internal(ctx, addr)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to remove address from port (ip={}) - {}",
+                    addr,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_bridge.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_bridge.rs
new file mode 100644
index 0000000..bdfd5ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_bridge.rs
@@ -0,0 +1,41 @@
+use virtual_net::StreamSecurity;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_bridge(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        network: String,
+        token: String,
+        security: StreamSecurity,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::PortBridgeV1 {
+                network: network.into(),
+                token: token.into(),
+                security,
+            },
+        )
+    }
+
+    pub fn apply_port_bridge(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        network: &str,
+        token: &str,
+        security: StreamSecurity,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_bridge_internal(ctx, network, token, security)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to bridge the network file descriptor (network={}, security={:?}) - {}",
+                    network,
+                    security,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs
new file mode 100644
index 0000000..98ef069
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_dhcp_acquire.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_dhcp_acquire(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortDhcpAcquireV1)
+    }
+
+    pub fn apply_port_dhcp_acquire(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        crate::syscalls::port_dhcp_acquire_internal(ctx)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to acquire DHCP address - {}",
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs
new file mode 100644
index 0000000..a0251a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_gateway_set.rs
@@ -0,0 +1,29 @@
+use std::net::IpAddr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_gateway_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        ip: IpAddr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortGatewaySetV1 { ip })
+    }
+
+    pub fn apply_port_gateway_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        ip: IpAddr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_gateway_set_internal(ctx, ip)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set gateway address (ip={}) - {}",
+                    ip,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_add.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_add.rs
new file mode 100644
index 0000000..e2f44eb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_add.rs
@@ -0,0 +1,53 @@
+use std::{net::IpAddr, time::Duration};
+use virtual_net::IpCidr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_route_add(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::PortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            },
+        )
+    }
+
+    pub fn apply_port_route_add(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_route_add_internal(
+            ctx,
+            cidr,
+            via_router,
+            preferred_until,
+            expires_at,
+        )
+        .map(|r| r.map_err(|err| err.to_string()))
+        .unwrap_or_else(|err| Err(err.to_string()))
+        .map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to add route (cidr={:?}, via_router={}, preferred_until={:?}, expires_at={:?}) - {}",
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs
new file mode 100644
index 0000000..dfb1774
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_clear.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_route_clear(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortRouteClearV1)
+    }
+
+    pub fn apply_port_route_clear(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        crate::syscalls::port_route_clear_internal(ctx)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to clear routing table - {}",
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs
new file mode 100644
index 0000000..3a980bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_route_remove.rs
@@ -0,0 +1,29 @@
+use std::net::IpAddr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_route_remove(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        ip: IpAddr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortRouteDelV1 { ip })
+    }
+
+    pub fn apply_port_route_remove(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        ip: IpAddr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::port_route_remove_internal(ctx, ip)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to remove route (ip={}) - {}",
+                    ip,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs
new file mode 100644
index 0000000..0fc1ae9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/port_unbridge.rs
@@ -0,0 +1,20 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_port_unbridge(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::PortUnbridgeV1)
+    }
+
+    pub fn apply_port_unbridge(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> anyhow::Result<()> {
+        crate::syscalls::port_unbridge_internal(ctx)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to un-bridge network - {}",
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_accept.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
new file mode 100644
index 0000000..b66d440
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_accept.rs
@@ -0,0 +1,114 @@
+use std::net::SocketAddr;
+
+use wasmer_wasix_types::wasi::{Addressfamily, SockProto, Socktype};
+
+use crate::{
+    fs::Kind,
+    net::socket::{InodeSocket, InodeSocketKind, SocketProperties},
+};
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_accepted(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        listen_fd: Fd,
+        fd: Fd,
+        addr: SocketAddr,
+        peer_addr: SocketAddr,
+        fd_flags: Fdflags,
+        nonblocking: bool,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr: addr,
+                peer_addr,
+                fd_flags,
+                non_blocking: nonblocking,
+            },
+        )
+    }
+
+    pub fn apply_sock_accepted(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        _listen_fd: Fd,
+        fd: Fd,
+        addr: SocketAddr,
+        peer_addr: SocketAddr,
+        fd_flags: Fdflags,
+        nonblocking: bool,
+    ) -> anyhow::Result<()> {
+        let kind = Kind::Socket {
+            socket: InodeSocket::new(InodeSocketKind::RemoteSocket {
+                local_addr: addr,
+                peer_addr,
+                ttl: 0,
+                multicast_ttl: 0,
+                props: SocketProperties {
+                    family: match peer_addr.is_ipv4() {
+                        true => Addressfamily::Inet4,
+                        false => Addressfamily::Inet6,
+                    },
+                    ty: Socktype::Stream,
+                    pt: SockProto::Tcp,
+                    only_v6: false,
+                    reuse_port: false,
+                    reuse_addr: false,
+                    no_delay: None,
+                    keep_alive: None,
+                    dont_route: None,
+                    send_buf_size: None,
+                    recv_buf_size: None,
+                    write_timeout: None,
+                    read_timeout: None,
+                    accept_timeout: None,
+                    connect_timeout: None,
+                    handler: None,
+                },
+            }),
+        };
+
+        let env = ctx.data();
+        let state = env.state();
+        let inodes = &state.inodes;
+        let inode = state
+            .fs
+            .create_inode_with_default_stat(inodes, kind, false, "socket".into());
+
+        let mut new_flags = Fdflags::empty();
+        if nonblocking {
+            new_flags.set(Fdflags::NONBLOCK, true);
+        }
+
+        let mut new_flags = Fdflags::empty();
+        if fd_flags.contains(Fdflags::NONBLOCK) {
+            new_flags.set(Fdflags::NONBLOCK, true);
+        }
+
+        let rights = Rights::all_socket();
+        let ret_fd = state
+            .fs
+            .create_fd(rights, rights, new_flags, 0, inode)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to create remote accepted socket - {}",
+                    err
+                )
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                    "journal restore error: failed renumber file descriptor after accepting socket (from={}, to={}) - {}",
+                    ret_fd,
+                    fd,
+                    ret
+                );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_bind.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_bind.rs
new file mode 100644
index 0000000..73c3e3a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_bind.rs
@@ -0,0 +1,32 @@
+use std::net::SocketAddr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_bind(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SocketBindV1 { fd, addr })
+    }
+
+    pub fn apply_sock_bind(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_bind_internal(ctx, fd, addr)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to bind socket to address (fd={}, addr={}) - {}",
+                    fd,
+                    addr,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_connect.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
new file mode 100644
index 0000000..a727634
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_connect.rs
@@ -0,0 +1,95 @@
+use std::net::SocketAddr;
+
+use wasmer_wasix_types::wasi::{Addressfamily, SockProto, Socktype};
+
+use crate::{
+    fs::Kind,
+    net::socket::{InodeSocket, InodeSocketKind, SocketProperties},
+};
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_connect(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            },
+        )
+    }
+
+    pub fn apply_sock_connect(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        let kind = Kind::Socket {
+            socket: InodeSocket::new(InodeSocketKind::RemoteSocket {
+                local_addr,
+                peer_addr,
+                ttl: 0,
+                multicast_ttl: 0,
+                props: SocketProperties {
+                    family: match peer_addr.is_ipv4() {
+                        true => Addressfamily::Inet4,
+                        false => Addressfamily::Inet6,
+                    },
+                    ty: Socktype::Stream,
+                    pt: SockProto::Tcp,
+                    only_v6: false,
+                    reuse_port: false,
+                    reuse_addr: false,
+                    no_delay: None,
+                    keep_alive: None,
+                    dont_route: None,
+                    send_buf_size: None,
+                    recv_buf_size: None,
+                    write_timeout: None,
+                    read_timeout: None,
+                    accept_timeout: None,
+                    connect_timeout: None,
+                    handler: None,
+                },
+            }),
+        };
+
+        let env = ctx.data();
+        let state = env.state();
+        let inodes = &state.inodes;
+        let inode = state
+            .fs
+            .create_inode_with_default_stat(inodes, kind, false, "socket".into());
+
+        let rights = Rights::all_socket();
+        let ret_fd = state
+            .fs
+            .create_fd(rights, rights, Fdflags::empty(), 0, inode)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to create remote connected socket - {}",
+                    err
+                )
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                    "journal restore error: failed renumber file descriptor after connecting the socket (from={}, to={}) - {}",
+                    ret_fd,
+                    fd,
+                    ret
+                );
+        }
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs
new file mode 100644
index 0000000..589bb08
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv4_multicast.rs
@@ -0,0 +1,42 @@
+use std::net::Ipv4Addr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_join_ipv4_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            },
+        )
+    }
+
+    pub fn apply_sock_join_ipv4_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_join_multicast_v4_internal(ctx, fd, multiaddr, iface)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to join ipv4 multicast (fd={}, multiaddr={:?}, iface={:?}) - {}",
+                    fd,
+                    multiaddr,
+                    iface,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs
new file mode 100644
index 0000000..17e7d87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_join_ipv6_multicast.rs
@@ -0,0 +1,42 @@
+use std::net::Ipv6Addr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_join_ipv6_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv6Addr,
+        iface: u32,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+        )
+    }
+
+    pub fn apply_sock_join_ipv6_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv6Addr,
+        iface: u32,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_join_multicast_v6_internal(ctx, fd, multiaddr, iface)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to join ipv6 multicast (fd={}, multiaddr={}, iface={}) - {}",
+                    fd,
+                    multiaddr,
+                    iface,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs
new file mode 100644
index 0000000..9fd3b78
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv4_multicast.rs
@@ -0,0 +1,42 @@
+use std::net::Ipv4Addr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_leave_ipv4_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+        )
+    }
+
+    pub fn apply_sock_leave_ipv4_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv4Addr,
+        iface: Ipv4Addr,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_leave_multicast_v4_internal(ctx, fd, multiaddr, iface)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to leave ipv4 multicast (fd={}, multiaddr={}, iface={}) - {}",
+                    fd,
+                    multiaddr,
+                    iface,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs
new file mode 100644
index 0000000..b91f710
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_leave_ipv6_multicast.rs
@@ -0,0 +1,42 @@
+use std::net::Ipv6Addr;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_leave_ipv6_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv6Addr,
+        iface: u32,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            },
+        )
+    }
+
+    pub fn apply_sock_leave_ipv6_multicast(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        multiaddr: Ipv6Addr,
+        iface: u32,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_leave_multicast_v6_internal(ctx, fd, multiaddr, iface)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to leave ipv6 multicast (fd={}, multiaddr={}, iface={}) - {}",
+                    fd,
+                    multiaddr,
+                    iface,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_listen.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_listen.rs
new file mode 100644
index 0000000..40a420a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_listen.rs
@@ -0,0 +1,36 @@
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_listen(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        backlog: usize,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketListenV1 {
+                fd,
+                backlog: backlog as u32,
+            },
+        )
+    }
+
+    pub fn apply_sock_listen(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        backlog: usize,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_listen_internal(ctx, fd, backlog)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to listen on socket (fd={}, backlog={}) - {}",
+                    fd,
+                    backlog,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_open.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_open.rs
new file mode 100644
index 0000000..eaa07b4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_open.rs
@@ -0,0 +1,54 @@
+use wasmer_wasix_types::wasi::{Addressfamily, SockProto, Socktype};
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_open(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        af: Addressfamily,
+        ty: Socktype,
+        pt: SockProto,
+        fd: Fd,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SocketOpenV1 { af, ty, pt, fd })
+    }
+
+    pub fn apply_sock_open(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        af: Addressfamily,
+        ty: Socktype,
+        pt: SockProto,
+        fd: Fd,
+    ) -> anyhow::Result<()> {
+        let ret_fd = crate::syscalls::sock_open_internal(ctx, af, ty, pt)
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to open socket (af={:?}, ty={:?}, pt={:?}) - {}",
+                    af,
+                    ty,
+                    pt,
+                    err
+                )
+            })?
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to open socket (af={:?}, ty={:?}, pt={:?}) - {}",
+                    af,
+                    ty,
+                    pt,
+                    err
+                )
+            })?;
+
+        let ret = crate::syscalls::fd_renumber_internal(ctx, ret_fd, fd);
+        if ret != Errno::Success {
+            bail!(
+                    "journal restore error: failed renumber file descriptor after opening socket (from={}, to={}) - {}",
+                    ret_fd,
+                    fd,
+                    ret
+                );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send.rs
new file mode 100644
index 0000000..710b9cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send.rs
@@ -0,0 +1,66 @@
+use wasmer_wasix_types::wasi::SiFlags;
+
+use crate::syscalls::sock_send_internal;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_send<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        sent: usize,
+        iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+        iovs_len: M::Offset,
+        si_flags: SiFlags,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        let iovs_arr = iovs.slice(&memory, iovs_len)?;
+
+        let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+        let mut remaining: M::Offset = TryFrom::<usize>::try_from(sent).unwrap_or_default();
+        for iovs in iovs_arr.iter() {
+            let sub = iovs.buf_len.min(remaining);
+            if sub == M::ZERO {
+                continue;
+            }
+            remaining -= sub;
+
+            let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                .slice(&memory, sub)
+                .map_err(mem_error_to_wasi)?
+                .access()
+                .map_err(mem_error_to_wasi)?;
+            ctx.data()
+                .active_journal()?
+                .write(JournalEntry::SocketSendV1 {
+                    fd,
+                    data: Cow::Borrowed(buf.as_ref()),
+                    is_64bit: M::is_64bit(),
+                    flags: si_flags,
+                })
+                .map_err(map_snapshot_err)?;
+        }
+        Ok(())
+    }
+
+    pub fn apply_sock_send<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        sock: Fd,
+        si_data: Cow<'_, [u8]>,
+        si_flags: SiFlags,
+    ) -> anyhow::Result<()> {
+        let data_len = si_data.len();
+        sock_send_internal(ctx, sock, FdWriteSource::<'_, M>::Buffer(si_data), si_flags)?.map_err(
+            |err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to send on socket (fd={}, data.len={}) - {}",
+                    sock,
+                    data_len,
+                    err
+                )
+            },
+        )?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs
new file mode 100644
index 0000000..abf21ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_file.rs
@@ -0,0 +1,43 @@
+use crate::syscalls::sock_send_file_internal;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_send_file<M: MemorySize>(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        socket_fd: Fd,
+        file_fd: Fd,
+        offset: Filesize,
+        count: Filesize,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            },
+        )
+    }
+
+    pub fn apply_sock_send_file(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        socket_fd: Fd,
+        file_fd: Fd,
+        offset: Filesize,
+        count: Filesize,
+    ) -> anyhow::Result<()> {
+        sock_send_file_internal(ctx, socket_fd, file_fd, offset, count)?.map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to send_file on socket (sock={}, in_fd={}, offset={}, count={}) - {}",
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
new file mode 100644
index 0000000..f1e7608
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_send_to.rs
@@ -0,0 +1,75 @@
+use std::net::SocketAddr;
+use wasmer_wasix_types::wasi::SiFlags;
+
+use crate::syscalls::sock_send_to_internal;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_send_to<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        sent: usize,
+        iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+        iovs_len: M::Offset,
+        addr: SocketAddr,
+        si_flags: SiFlags,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        let iovs_arr = iovs.slice(&memory, iovs_len)?;
+
+        let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+        let mut remaining: M::Offset = TryFrom::<usize>::try_from(sent).unwrap_or_default();
+        for iovs in iovs_arr.iter() {
+            let sub = iovs.buf_len.min(remaining);
+            if sub == M::ZERO {
+                continue;
+            }
+            remaining -= sub;
+
+            let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                .slice(&memory, sub)
+                .map_err(mem_error_to_wasi)?
+                .access()
+                .map_err(mem_error_to_wasi)?;
+            ctx.data()
+                .active_journal()?
+                .write(JournalEntry::SocketSendToV1 {
+                    fd,
+                    data: Cow::Borrowed(buf.as_ref()),
+                    addr,
+                    is_64bit: M::is_64bit(),
+                    flags: si_flags,
+                })
+                .map_err(map_snapshot_err)?;
+        }
+        Ok(())
+    }
+
+    pub fn apply_sock_send_to<M: MemorySize>(
+        ctx: &FunctionEnvMut<'_, WasiEnv>,
+        sock: Fd,
+        si_data: Cow<'_, [u8]>,
+        si_flags: SiFlags,
+        addr: SocketAddr,
+    ) -> anyhow::Result<()> {
+        let data_len = si_data.len();
+        sock_send_to_internal::<M>(
+            ctx,
+            sock,
+            FdWriteSource::<'_, M>::Buffer(si_data),
+            si_flags,
+            addr,
+        )?
+        .map_err(|err| {
+            anyhow::format_err!(
+                "journal restore error: failed to send_to on socket (fd={}, data.len={}) - {}",
+                sock,
+                data_len,
+                err
+            )
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs
new file mode 100644
index 0000000..ead9f50
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_flag.rs
@@ -0,0 +1,35 @@
+use wasmer_wasix_types::wasi::Sockoption;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_set_opt_flag(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        opt: Sockoption,
+        flag: bool,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SocketSetOptFlagV1 { fd, opt, flag })
+    }
+
+    pub fn apply_sock_set_opt_flag(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        opt: Sockoption,
+        flag: bool,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_set_opt_flag_internal(ctx, fd, opt, flag)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set socket option (fd={}, opt={:?}, flag={}) - {}",
+                    fd,
+                    opt,
+                    flag,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs
new file mode 100644
index 0000000..867f351
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_size.rs
@@ -0,0 +1,35 @@
+use wasmer_wasix_types::wasi::Sockoption;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_set_opt_size(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        opt: Sockoption,
+        size: Filesize,
+    ) -> anyhow::Result<()> {
+        Self::save_event(ctx, JournalEntry::SocketSetOptSizeV1 { fd, opt, size })
+    }
+
+    pub fn apply_sock_set_opt_size(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        opt: Sockoption,
+        size: Filesize,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_set_opt_size_internal(ctx, fd, opt, size)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set socket option (fd={}, opt={:?}, size={}) - {}",
+                    fd,
+                    opt,
+                    size,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs
new file mode 100644
index 0000000..0dbdf7a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_set_opt_time.rs
@@ -0,0 +1,44 @@
+use std::time::Duration;
+
+use crate::net::socket::TimeType;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_set_opt_time(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        ty: TimeType,
+        time: Option<Duration>,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketSetOptTimeV1 {
+                fd,
+                ty: ty.into(),
+                time,
+            },
+        )
+    }
+
+    pub fn apply_sock_set_opt_time(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        ty: TimeType,
+        time: Option<Duration>,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_set_opt_time_internal(ctx, fd, ty, time)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to set socket option (fd={}, opt={:?}, time={:?}) - {}",
+                    fd,
+                    ty,
+                    time,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs
new file mode 100644
index 0000000..6149721
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/sock_shutdown.rs
@@ -0,0 +1,38 @@
+use std::net::Shutdown;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_sock_shutdown(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        shutdown: Shutdown,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SocketShutdownV1 {
+                fd,
+                how: shutdown.into(),
+            },
+        )
+    }
+
+    pub fn apply_sock_shutdown(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        fd: Fd,
+        shutdown: Shutdown,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::sock_shutdown_internal(ctx, fd, shutdown)
+            .map(|r| r.map_err(|err| err.to_string()))
+            .unwrap_or_else(|err| Err(err.to_string()))
+            .map_err(|err| {
+                anyhow::format_err!(
+                    "journal restore error: failed to shutdown socket (fd={}, how={:?}) - {}",
+                    fd,
+                    shutdown,
+                    err
+                )
+            })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/tty_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/tty_set.rs
new file mode 100644
index 0000000..536c5a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/syscalls/tty_set.rs
@@ -0,0 +1,38 @@
+use crate::WasiTtyState;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_tty_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        state: WasiTtyState,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::TtySetV1 {
+                tty: wasmer_wasix_types::wasi::Tty {
+                    cols: state.cols,
+                    rows: state.rows,
+                    width: state.width,
+                    height: state.height,
+                    stdin_tty: state.stdin_tty,
+                    stdout_tty: state.stdout_tty,
+                    stderr_tty: state.stderr_tty,
+                    echo: state.echo,
+                    line_buffered: state.line_buffered,
+                },
+                line_feeds: state.line_feeds,
+            },
+        )
+    }
+
+    pub fn apply_tty_set(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        state: WasiTtyState,
+    ) -> anyhow::Result<()> {
+        crate::syscalls::tty_set_internal(ctx, state).map_err(|err| {
+            anyhow::format_err!("journal restore error: failed to set tty - {}", err)
+        })?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_exit.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_exit.rs
new file mode 100644
index 0000000..eae7f88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_exit.rs
@@ -0,0 +1,34 @@
+use wasmer_wasix_types::wasi::Signal;
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_thread_exit(
+        env: &WasiEnv,
+        id: WasiThreadId,
+        exit_code: Option<ExitCode>,
+    ) -> anyhow::Result<()> {
+        env.active_journal()?
+            .write(JournalEntry::CloseThreadV1 {
+                id: id.raw(),
+                exit_code,
+            })
+            .map_err(map_snapshot_err)?;
+        Ok(())
+    }
+
+    pub fn apply_thread_exit(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        tid: WasiThreadId,
+        exit_code: Option<ExitCode>,
+    ) -> anyhow::Result<()> {
+        let env = ctx.data();
+        if let Some(thread) = env.process.get_thread(&tid) {
+            if let Some(code) = exit_code {
+                thread.set_status_finished(Ok(code));
+            }
+            thread.signal(Signal::Sigkill);
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_state.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_state.rs
new file mode 100644
index 0000000..0c824b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/thread_state.rs
@@ -0,0 +1,90 @@
+use std::sync::Arc;
+
+use wasmer_wasix_types::wasix::ThreadStartType;
+
+use crate::{
+    os::task::thread::{RewindResultType, WasiMemoryLayout},
+    syscalls::thread_spawn_internal_using_layout,
+    RewindState,
+};
+
+use super::*;
+
+impl JournalEffector {
+    pub fn save_thread_state<M: MemorySize>(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        id: WasiThreadId,
+        memory_stack: Bytes,
+        rewind_stack: Bytes,
+        store_data: Bytes,
+        start: ThreadStartType,
+        layout: WasiMemoryLayout,
+    ) -> anyhow::Result<()> {
+        Self::save_event(
+            ctx,
+            JournalEntry::SetThreadV1 {
+                id: id.raw(),
+                call_stack: Cow::Owned(rewind_stack.into()),
+                memory_stack: Cow::Owned(memory_stack.into()),
+                store_data: Cow::Owned(store_data.into()),
+                start,
+                layout,
+                is_64bit: M::is_64bit(),
+            },
+        )
+    }
+
+    /// This will take the supplied stacks and apply them to the memory region
+    /// dedicated to this thread. After that it will spawn a WASM thread and
+    // continue the thread where it left off, which may even mean it goes
+    // straight back to sleep.
+    pub fn apply_thread_state<M: MemorySize>(
+        ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+        tid: WasiThreadId,
+        memory_stack: Bytes,
+        rewind_stack: Bytes,
+        store_data: Bytes,
+        start: ThreadStartType,
+        layout: WasiMemoryLayout,
+    ) -> anyhow::Result<()> {
+        let start_ptr: M::Offset = match start {
+            ThreadStartType::MainThread => {
+                return Err(anyhow::format_err!(
+                    "unable to restore a main thread via this method"
+                ));
+            }
+            ThreadStartType::ThreadSpawn { start_ptr } => start_ptr
+                .try_into()
+                .map_err(|_| anyhow::format_err!("overflow while processing thread restoration"))?,
+        };
+
+        // Create the thread for this ID
+        let thread_handle = Arc::new(ctx.data().process.new_thread_with_id(
+            layout.clone(),
+            start,
+            tid,
+        )?);
+
+        // Now spawn the thread itself
+        thread_spawn_internal_using_layout::<M>(
+            ctx,
+            thread_handle,
+            layout.clone(),
+            start_ptr,
+            Some((
+                RewindState {
+                    memory_stack,
+                    rewind_stack,
+                    store_data,
+                    start,
+                    layout,
+                    is_64bit: M::is_64bit(),
+                },
+                RewindResultType::RewindRestart,
+            )),
+        )
+        .map_err(|err| anyhow::format_err!("failed to spawn thread - {}", err))?;
+
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/unimplemented.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/unimplemented.rs
new file mode 100644
index 0000000..6e82767
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/effector/unimplemented.rs
@@ -0,0 +1,4 @@
+#[derive(Debug, Clone)]
+pub struct JournalEffector {}
+
+impl JournalEffector {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/mod.rs
new file mode 100644
index 0000000..34787b0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/journal/mod.rs
@@ -0,0 +1,8 @@
+#[cfg(feature = "journal")]
+mod effector;
+#[cfg(not(feature = "journal"))]
+#[path = "effector/unimplemented.rs"]
+mod effector;
+
+pub use effector::*;
+pub use wasmer_journal::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/lib.rs
new file mode 100644
index 0000000..a73916d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/lib.rs
@@ -0,0 +1,793 @@
+// FIXME: merge with ./lib.rs_upstream
+
+#![doc(html_favicon_url = "https://wasmer.io/images/icons/favicon-32x32.png")]
+#![doc(html_logo_url = "https://github.com/wasmerio.png?size=200")]
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+//! Wasmer's WASI implementation
+//!
+//! Use `generate_import_object` to create an [`Imports`].  This [`Imports`]
+//! can be combined with a module to create an `Instance` which can execute WASI
+//! Wasm functions.
+//!
+//! See `state` for the experimental WASI FS API.  Also see the
+//! [WASI plugin example](https://github.com/wasmerio/wasmer/blob/master/examples/plugin.rs)
+//! for an example of how to extend WASI using the WASI FS API.
+
+#[cfg(all(not(feature = "sys"), not(feature = "js")))]
+compile_error!("At least the `sys` or the `js` feature must be enabled. Please, pick one.");
+
+#[cfg(all(feature = "sys", feature = "js"))]
+compile_error!(
+    "Cannot have both `sys` and `js` features enabled at the same time. Please, pick one."
+);
+
+#[cfg(all(feature = "sys", target_arch = "wasm32"))]
+compile_error!("The `sys` feature must be enabled only for non-`wasm32` target.");
+
+#[cfg(all(feature = "js", not(target_arch = "wasm32")))]
+compile_error!(
+    "The `js` feature must be enabled only for the `wasm32` target (either `wasm32-unknown-unknown` or `wasm32-wasi`)."
+);
+
+#[cfg(all(test, target_arch = "wasm32"))]
+wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
+
+#[cfg(test)]
+#[macro_use]
+extern crate pretty_assertions;
+
+#[macro_use]
+mod macros;
+pub mod bin_factory;
+pub mod os;
+// TODO: should this be pub?
+pub mod net;
+// TODO: should this be pub?
+pub mod capabilities;
+pub mod fs;
+pub mod http;
+pub mod journal;
+mod rewind;
+pub mod runners;
+pub mod runtime;
+mod state;
+mod syscalls;
+mod utils;
+
+use std::sync::Arc;
+
+#[allow(unused_imports)]
+use bytes::{Bytes, BytesMut};
+use os::task::control_plane::ControlPlaneError;
+use thiserror::Error;
+use tracing::error;
+// re-exports needed for OS
+pub use wasmer;
+pub use wasmer_wasix_types;
+
+use wasmer::{
+    imports, namespace, AsStoreMut, Exports, FunctionEnv, Imports, Memory32, MemoryAccessError,
+    MemorySize, RuntimeError,
+};
+
+pub use virtual_fs;
+pub use virtual_fs::{DuplexPipe, FsError, Pipe, VirtualFile, WasiBidirectionalSharedPipePair};
+pub use virtual_net;
+pub use virtual_net::{UnsupportedVirtualNetworking, VirtualNetworking};
+
+#[cfg(feature = "host-vnet")]
+pub use virtual_net::{
+    host::{LocalNetworking, LocalTcpListener, LocalTcpStream, LocalUdpSocket},
+    io_err_into_net_error,
+};
+use wasmer_wasix_types::wasi::{Errno, ExitCode};
+
+pub use crate::{
+    fs::{default_fs_backing, Fd, WasiFs, WasiInodes, VIRTUAL_ROOT_FD},
+    os::{
+        task::{
+            control_plane::WasiControlPlane,
+            process::{WasiProcess, WasiProcessId},
+            thread::{WasiThread, WasiThreadError, WasiThreadHandle, WasiThreadId},
+        },
+        WasiTtyState,
+    },
+    rewind::*,
+    runtime::{task_manager::VirtualTaskManager, PluggableRuntime, Runtime},
+    state::{
+        WasiEnv, WasiEnvBuilder, WasiEnvInit, WasiFunctionEnv, WasiInstanceHandles,
+        WasiStateCreationError, ALL_RIGHTS,
+    },
+    syscalls::{journal::wait_for_snapshot, rewind, rewind_ext, types, unwind},
+    utils::is_wasix_module,
+    utils::{
+        get_wasi_version, get_wasi_versions, is_wasi_module,
+        store::{capture_store_snapshot, restore_store_snapshot, StoreSnapshot},
+        WasiVersion,
+    },
+};
+
+/// This is returned in `RuntimeError`.
+/// Use `downcast` or `downcast_ref` to retrieve the `ExitCode`.
+#[derive(Error, Debug)]
+pub enum WasiError {
+    #[error("WASI exited with code: {0}")]
+    Exit(ExitCode),
+    #[error("WASI deep sleep: {0:?}")]
+    DeepSleep(DeepSleepWork),
+    #[error("The WASI version could not be determined")]
+    UnknownWasiVersion,
+}
+
+pub type WasiResult<T> = Result<Result<T, Errno>, WasiError>;
+
+#[deny(unused, dead_code)]
+#[derive(Error, Debug)]
+pub enum SpawnError {
+    /// Failed during serialization
+    #[error("serialization failed")]
+    Serialization,
+    /// Failed during deserialization
+    #[error("deserialization failed")]
+    Deserialization,
+    /// Invalid Wasmer process
+    #[error("invalid wasmer")]
+    InvalidWasmer,
+    /// Failed to fetch the Wasmer process
+    #[error("fetch failed")]
+    FetchFailed,
+    /// Failed to compile the Wasmer process
+    #[error("compile error")]
+    CompileError,
+    /// Invalid ABI
+    #[error("Wasmer process has an invalid ABI")]
+    InvalidABI,
+    /// Bad handle
+    #[error("bad handle")]
+    BadHandle,
+    /// Call is unsupported
+    #[error("unsupported")]
+    Unsupported,
+    /// Not found
+    #[error("not found")]
+    NotFound,
+    /// Bad request
+    #[error("bad request")]
+    BadRequest,
+    /// Access denied
+    #[error("access denied")]
+    AccessDenied,
+    /// Internal error has occurred
+    #[error("internal error")]
+    InternalError,
+    /// An error occurred while preparing the file system
+    #[error("file system error")]
+    FileSystemError,
+    /// Memory allocation failed
+    #[error("memory allocation failed")]
+    MemoryAllocationFailed,
+    /// Memory access violation
+    #[error("memory access violation")]
+    MemoryAccessViolation,
+    /// Some other unhandled error. If you see this, it's probably a bug.
+    #[error("unknown error found")]
+    UnknownError,
+    #[error("runtime error")]
+    Runtime(#[from] WasiRuntimeError),
+    #[error(transparent)]
+    Other(#[from] Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl SpawnError {
+    /// Returns `true` if the spawn error is [`NotFound`].
+    ///
+    /// [`NotFound`]: SpawnError::NotFound
+    #[must_use]
+    pub fn is_not_found(&self) -> bool {
+        matches!(self, Self::NotFound)
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum WasiRuntimeError {
+    #[error("WASI state setup failed")]
+    Init(#[from] WasiStateCreationError),
+    #[error("Loading exports failed")]
+    Export(#[from] wasmer::ExportError),
+    #[error("Instantiation failed")]
+    Instantiation(#[from] wasmer::InstantiationError),
+    #[error("WASI error")]
+    Wasi(#[from] WasiError),
+    #[error("Process manager error")]
+    ControlPlane(#[from] ControlPlaneError),
+    #[error("{0}")]
+    Runtime(#[from] RuntimeError),
+    #[error("Memory access error")]
+    Thread(#[from] WasiThreadError),
+    #[error("{0}")]
+    Anyhow(#[from] Arc<anyhow::Error>),
+}
+
+impl WasiRuntimeError {
+    /// Retrieve the concrete exit code returned by an instance.
+    ///
+    /// Returns [`None`] if a general execution error ocurred.
+    pub fn as_exit_code(&self) -> Option<ExitCode> {
+        if let WasiRuntimeError::Wasi(WasiError::Exit(code)) = self {
+            Some(*code)
+        } else if let WasiRuntimeError::Runtime(err) = self {
+            if let Some(WasiError::Exit(code)) = err.downcast_ref() {
+                Some(*code)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+}
+
+#[allow(clippy::result_large_err)]
+pub(crate) fn run_wasi_func(
+    func: &wasmer::Function,
+    store: &mut impl AsStoreMut,
+    params: &[wasmer::Value],
+) -> Result<Box<[wasmer::Value]>, WasiRuntimeError> {
+    func.call(store, params).map_err(|err| {
+        if let Some(_werr) = err.downcast_ref::<WasiError>() {
+            let werr = err.downcast::<WasiError>().unwrap();
+            WasiRuntimeError::Wasi(werr)
+        } else {
+            WasiRuntimeError::Runtime(err)
+        }
+    })
+}
+
+/// Run a main function.
+///
+/// This is usually called "_start" in WASI modules.
+/// The function will not receive arguments or return values.
+///
+/// An exit code that is not 0 will be returned as a `WasiError::Exit`.
+#[allow(clippy::result_large_err)]
+pub(crate) fn run_wasi_func_start(
+    func: &wasmer::Function,
+    store: &mut impl AsStoreMut,
+) -> Result<(), WasiRuntimeError> {
+    run_wasi_func(func, store, &[])?;
+    Ok(())
+}
+
+#[derive(Debug)]
+pub struct WasiVFork {
+    /// The unwound stack before the vfork occured
+    pub rewind_stack: BytesMut,
+    /// The memory stack before the vfork occured
+    pub memory_stack: BytesMut,
+    /// The mutable parts of the store
+    pub store_data: Bytes,
+    /// The environment before the vfork occured
+    pub env: Box<WasiEnv>,
+
+    /// Handle of the thread we have forked (dropping this handle
+    /// will signal that the thread is dead)
+    pub handle: WasiThreadHandle,
+}
+
+impl Clone for WasiVFork {
+    fn clone(&self) -> Self {
+        Self {
+            rewind_stack: self.rewind_stack.clone(),
+            memory_stack: self.memory_stack.clone(),
+            store_data: self.store_data.clone(),
+            env: Box::new(self.env.as_ref().clone()),
+            handle: self.handle.clone(),
+        }
+    }
+}
+
+/// Create an [`Imports`] with an existing [`WasiEnv`]. `WasiEnv`
+/// needs a [`WasiState`], that can be constructed from a
+/// [`WasiEnvBuilder`](state::WasiEnvBuilder).
+pub fn generate_import_object_from_env(
+    store: &mut impl AsStoreMut,
+    ctx: &FunctionEnv<WasiEnv>,
+    version: WasiVersion,
+) -> Imports {
+    match version {
+        WasiVersion::Snapshot0 => generate_import_object_snapshot0(store, ctx),
+        WasiVersion::Snapshot1 | WasiVersion::Latest => {
+            generate_import_object_snapshot1(store, ctx)
+        }
+        WasiVersion::Wasix32v1 => generate_import_object_wasix32_v1(store, ctx),
+        WasiVersion::Wasix64v1 => generate_import_object_wasix64_v1(store, ctx),
+    }
+}
+
+fn wasi_exports_generic(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    use syscalls::*;
+    let namespace = namespace! {
+        "thread-spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn::<Memory32>),
+    };
+    namespace
+}
+
+fn wasi_unstable_exports(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    use syscalls::*;
+    let namespace = namespace! {
+        "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory32>),
+        "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory32>),
+        "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory32>),
+        "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory32>),
+        "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory32>),
+        "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory32>),
+        "fd_advise" => Function::new_typed_with_env(&mut store, env, fd_advise),
+        "fd_allocate" => Function::new_typed_with_env(&mut store, env, fd_allocate),
+        "fd_close" => Function::new_typed_with_env(&mut store, env, fd_close),
+        "fd_datasync" => Function::new_typed_with_env(&mut store, env, fd_datasync),
+        "fd_fdstat_get" => Function::new_typed_with_env(&mut store, env, fd_fdstat_get::<Memory32>),
+        "fd_fdstat_set_flags" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_flags),
+        "fd_fdstat_set_rights" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_rights),
+        "fd_filestat_get" => Function::new_typed_with_env(&mut store, env, legacy::snapshot0::fd_filestat_get),
+        "fd_filestat_set_size" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_size),
+        "fd_filestat_set_times" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_times),
+        "fd_pread" => Function::new_typed_with_env(&mut store, env, fd_pread::<Memory32>),
+        "fd_prestat_get" => Function::new_typed_with_env(&mut store, env, fd_prestat_get::<Memory32>),
+        "fd_prestat_dir_name" => Function::new_typed_with_env(&mut store, env, fd_prestat_dir_name::<Memory32>),
+        "fd_pwrite" => Function::new_typed_with_env(&mut store, env, fd_pwrite::<Memory32>),
+        "fd_read" => Function::new_typed_with_env(&mut store, env, fd_read::<Memory32>),
+        "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory32>),
+        "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
+        "fd_seek" => Function::new_typed_with_env(&mut store, env, legacy::snapshot0::fd_seek),
+        "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
+        "fd_tell" => Function::new_typed_with_env(&mut store, env, fd_tell::<Memory32>),
+        "fd_write" => Function::new_typed_with_env(&mut store, env, fd_write::<Memory32>),
+        "path_create_directory" => Function::new_typed_with_env(&mut store, env, path_create_directory::<Memory32>),
+        "path_filestat_get" => Function::new_typed_with_env(&mut store, env, legacy::snapshot0::path_filestat_get),
+        "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory32>),
+        "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory32>),
+        "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory32>),
+        "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory32>),
+        "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory32>),
+        "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory32>),
+        "path_symlink" => Function::new_typed_with_env(&mut store, env, path_symlink::<Memory32>),
+        "path_unlink_file" => Function::new_typed_with_env(&mut store, env, path_unlink_file::<Memory32>),
+        "poll_oneoff" => Function::new_typed_with_env(&mut store, env, legacy::snapshot0::poll_oneoff::<Memory32>),
+        "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory32>),
+        "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
+        "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory32>),
+        "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory32>),
+        "sock_recv" => Function::new_typed_with_env(&mut store, env, sock_recv::<Memory32>),
+        "sock_send" => Function::new_typed_with_env(&mut store, env, sock_send::<Memory32>),
+        "sock_shutdown" => Function::new_typed_with_env(&mut store, env, sock_shutdown),
+        "thread-spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn::<Memory32>),
+    };
+    namespace
+}
+
+fn wasi_snapshot_preview1_exports(
+    mut store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> Exports {
+    use syscalls::*;
+    let namespace = namespace! {
+        "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory32>),
+        "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory32>),
+        "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory32>),
+        "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory32>),
+        "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory32>),
+        "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory32>),
+        "fd_advise" => Function::new_typed_with_env(&mut store, env, fd_advise),
+        "fd_allocate" => Function::new_typed_with_env(&mut store, env, fd_allocate),
+        "fd_close" => Function::new_typed_with_env(&mut store, env, fd_close),
+        "fd_datasync" => Function::new_typed_with_env(&mut store, env, fd_datasync),
+        "fd_fdstat_get" => Function::new_typed_with_env(&mut store, env, fd_fdstat_get::<Memory32>),
+        "fd_fdstat_set_flags" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_flags),
+        "fd_fdstat_set_rights" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_rights),
+        "fd_filestat_get" => Function::new_typed_with_env(&mut store, env, fd_filestat_get::<Memory32>),
+        "fd_filestat_set_size" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_size),
+        "fd_filestat_set_times" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_times),
+        "fd_pread" => Function::new_typed_with_env(&mut store, env, fd_pread::<Memory32>),
+        "fd_prestat_get" => Function::new_typed_with_env(&mut store, env, fd_prestat_get::<Memory32>),
+        "fd_prestat_dir_name" => Function::new_typed_with_env(&mut store, env, fd_prestat_dir_name::<Memory32>),
+        "fd_pwrite" => Function::new_typed_with_env(&mut store, env, fd_pwrite::<Memory32>),
+        "fd_read" => Function::new_typed_with_env(&mut store, env, fd_read::<Memory32>),
+        "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory32>),
+        "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
+        "fd_seek" => Function::new_typed_with_env(&mut store, env, fd_seek::<Memory32>),
+        "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
+        "fd_tell" => Function::new_typed_with_env(&mut store, env, fd_tell::<Memory32>),
+        "fd_write" => Function::new_typed_with_env(&mut store, env, fd_write::<Memory32>),
+        "path_create_directory" => Function::new_typed_with_env(&mut store, env, path_create_directory::<Memory32>),
+        "path_filestat_get" => Function::new_typed_with_env(&mut store, env, path_filestat_get::<Memory32>),
+        "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory32>),
+        "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory32>),
+        "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory32>),
+        "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory32>),
+        "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory32>),
+        "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory32>),
+        "path_symlink" => Function::new_typed_with_env(&mut store, env, path_symlink::<Memory32>),
+        "path_unlink_file" => Function::new_typed_with_env(&mut store, env, path_unlink_file::<Memory32>),
+        "poll_oneoff" => Function::new_typed_with_env(&mut store, env, poll_oneoff::<Memory32>),
+        "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory32>),
+        "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
+        "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory32>),
+        "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory32>),
+        "sock_accept" => Function::new_typed_with_env(&mut store, env, sock_accept::<Memory32>),
+        "sock_recv" => Function::new_typed_with_env(&mut store, env, sock_recv::<Memory32>),
+        "sock_send" => Function::new_typed_with_env(&mut store, env, sock_send::<Memory32>),
+        "sock_shutdown" => Function::new_typed_with_env(&mut store, env, sock_shutdown),
+        "thread-spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn::<Memory32>),
+    };
+    namespace
+}
+
+fn wasix_exports_32(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    use syscalls::*;
+    let namespace = namespace! {
+        "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory32>),
+        "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory32>),
+        "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory32>),
+        "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory32>),
+        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set::<Memory32>),
+        "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory32>),
+        "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory32>),
+        "epoll_create" => Function::new_typed_with_env(&mut store, env, epoll_create::<Memory32>),
+        "epoll_ctl" => Function::new_typed_with_env(&mut store, env, epoll_ctl::<Memory32>),
+        "epoll_wait" => Function::new_typed_with_env(&mut store, env, epoll_wait::<Memory32>),
+        "fd_advise" => Function::new_typed_with_env(&mut store, env, fd_advise),
+        "fd_allocate" => Function::new_typed_with_env(&mut store, env, fd_allocate),
+        "fd_close" => Function::new_typed_with_env(&mut store, env, fd_close),
+        "fd_datasync" => Function::new_typed_with_env(&mut store, env, fd_datasync),
+        "fd_fdstat_get" => Function::new_typed_with_env(&mut store, env, fd_fdstat_get::<Memory32>),
+        "fd_fdstat_set_flags" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_flags),
+        "fd_fdstat_set_rights" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_rights),
+        "fd_filestat_get" => Function::new_typed_with_env(&mut store, env, fd_filestat_get::<Memory32>),
+        "fd_filestat_set_size" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_size),
+        "fd_filestat_set_times" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_times),
+        "fd_pread" => Function::new_typed_with_env(&mut store, env, fd_pread::<Memory32>),
+        "fd_prestat_get" => Function::new_typed_with_env(&mut store, env, fd_prestat_get::<Memory32>),
+        "fd_prestat_dir_name" => Function::new_typed_with_env(&mut store, env, fd_prestat_dir_name::<Memory32>),
+        "fd_pwrite" => Function::new_typed_with_env(&mut store, env, fd_pwrite::<Memory32>),
+        "fd_read" => Function::new_typed_with_env(&mut store, env, fd_read::<Memory32>),
+        "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory32>),
+        "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
+        "fd_dup" => Function::new_typed_with_env(&mut store, env, fd_dup::<Memory32>),
+        "fd_event" => Function::new_typed_with_env(&mut store, env, fd_event::<Memory32>),
+        "fd_seek" => Function::new_typed_with_env(&mut store, env, fd_seek::<Memory32>),
+        "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
+        "fd_tell" => Function::new_typed_with_env(&mut store, env, fd_tell::<Memory32>),
+        "fd_write" => Function::new_typed_with_env(&mut store, env, fd_write::<Memory32>),
+        "fd_pipe" => Function::new_typed_with_env(&mut store, env, fd_pipe::<Memory32>),
+        "path_create_directory" => Function::new_typed_with_env(&mut store, env, path_create_directory::<Memory32>),
+        "path_filestat_get" => Function::new_typed_with_env(&mut store, env, path_filestat_get::<Memory32>),
+        "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory32>),
+        "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory32>),
+        "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory32>),
+        "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory32>),
+        "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory32>),
+        "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory32>),
+        "path_symlink" => Function::new_typed_with_env(&mut store, env, path_symlink::<Memory32>),
+        "path_unlink_file" => Function::new_typed_with_env(&mut store, env, path_unlink_file::<Memory32>),
+        "poll_oneoff" => Function::new_typed_with_env(&mut store, env, poll_oneoff::<Memory32>),
+        "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory32>),
+        "proc_fork" => Function::new_typed_with_env(&mut store, env, proc_fork::<Memory32>),
+        "proc_join" => Function::new_typed_with_env(&mut store, env, proc_join::<Memory32>),
+        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal::<Memory32>),
+        "proc_exec" => Function::new_typed_with_env(&mut store, env, proc_exec::<Memory32>),
+        "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
+        "proc_raise_interval" => Function::new_typed_with_env(&mut store, env, proc_raise_interval),
+        "proc_spawn" => Function::new_typed_with_env(&mut store, env, proc_spawn::<Memory32>),
+        "proc_id" => Function::new_typed_with_env(&mut store, env, proc_id::<Memory32>),
+        "proc_parent" => Function::new_typed_with_env(&mut store, env, proc_parent::<Memory32>),
+        "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory32>),
+        "tty_get" => Function::new_typed_with_env(&mut store, env, tty_get::<Memory32>),
+        "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::<Memory32>),
+        "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::<Memory32>),
+        "chdir" => Function::new_typed_with_env(&mut store, env, chdir::<Memory32>),
+        "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::<Memory32>),
+        "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory32>),
+        "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory32>),
+        "thread_sleep" => Function::new_typed_with_env(&mut store, env, thread_sleep::<Memory32>),
+        "thread_id" => Function::new_typed_with_env(&mut store, env, thread_id::<Memory32>),
+        "thread_signal" => Function::new_typed_with_env(&mut store, env, thread_signal),
+        "thread_join" => Function::new_typed_with_env(&mut store, env, thread_join::<Memory32>),
+        "thread_parallelism" => Function::new_typed_with_env(&mut store, env, thread_parallelism::<Memory32>),
+        "thread_exit" => Function::new_typed_with_env(&mut store, env, thread_exit),
+        "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory32>),
+        "stack_checkpoint" => Function::new_typed_with_env(&mut store, env, stack_checkpoint::<Memory32>),
+        "stack_restore" => Function::new_typed_with_env(&mut store, env, stack_restore::<Memory32>),
+        "futex_wait" => Function::new_typed_with_env(&mut store, env, futex_wait::<Memory32>),
+        "futex_wake" => Function::new_typed_with_env(&mut store, env, futex_wake::<Memory32>),
+        "futex_wake_all" => Function::new_typed_with_env(&mut store, env, futex_wake_all::<Memory32>),
+        "port_bridge" => Function::new_typed_with_env(&mut store, env, port_bridge::<Memory32>),
+        "port_unbridge" => Function::new_typed_with_env(&mut store, env, port_unbridge),
+        "port_dhcp_acquire" => Function::new_typed_with_env(&mut store, env, port_dhcp_acquire),
+        "port_addr_add" => Function::new_typed_with_env(&mut store, env, port_addr_add::<Memory32>),
+        "port_addr_remove" => Function::new_typed_with_env(&mut store, env, port_addr_remove::<Memory32>),
+        "port_addr_clear" => Function::new_typed_with_env(&mut store, env, port_addr_clear),
+        "port_addr_list" => Function::new_typed_with_env(&mut store, env, port_addr_list::<Memory32>),
+        "port_mac" => Function::new_typed_with_env(&mut store, env, port_mac::<Memory32>),
+        "port_gateway_set" => Function::new_typed_with_env(&mut store, env, port_gateway_set::<Memory32>),
+        "port_route_add" => Function::new_typed_with_env(&mut store, env, port_route_add::<Memory32>),
+        "port_route_remove" => Function::new_typed_with_env(&mut store, env, port_route_remove::<Memory32>),
+        "port_route_clear" => Function::new_typed_with_env(&mut store, env, port_route_clear),
+        "port_route_list" => Function::new_typed_with_env(&mut store, env, port_route_list::<Memory32>),
+        "sock_status" => Function::new_typed_with_env(&mut store, env, sock_status::<Memory32>),
+        "sock_addr_local" => Function::new_typed_with_env(&mut store, env, sock_addr_local::<Memory32>),
+        "sock_addr_peer" => Function::new_typed_with_env(&mut store, env, sock_addr_peer::<Memory32>),
+        "sock_open" => Function::new_typed_with_env(&mut store, env, sock_open::<Memory32>),
+        "sock_set_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_set_opt_flag),
+        "sock_get_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_get_opt_flag::<Memory32>),
+        "sock_set_opt_time" => Function::new_typed_with_env(&mut store, env, sock_set_opt_time::<Memory32>),
+        "sock_get_opt_time" => Function::new_typed_with_env(&mut store, env, sock_get_opt_time::<Memory32>),
+        "sock_set_opt_size" => Function::new_typed_with_env(&mut store, env, sock_set_opt_size),
+        "sock_get_opt_size" => Function::new_typed_with_env(&mut store, env, sock_get_opt_size::<Memory32>),
+        "sock_join_multicast_v4" => Function::new_typed_with_env(&mut store, env, sock_join_multicast_v4::<Memory32>),
+        "sock_leave_multicast_v4" => Function::new_typed_with_env(&mut store, env, sock_leave_multicast_v4::<Memory32>),
+        "sock_join_multicast_v6" => Function::new_typed_with_env(&mut store, env, sock_join_multicast_v6::<Memory32>),
+        "sock_leave_multicast_v6" => Function::new_typed_with_env(&mut store, env, sock_leave_multicast_v6::<Memory32>),
+        "sock_bind" => Function::new_typed_with_env(&mut store, env, sock_bind::<Memory32>),
+        "sock_listen" => Function::new_typed_with_env(&mut store, env, sock_listen::<Memory32>),
+        "sock_accept" => Function::new_typed_with_env(&mut store, env, sock_accept_v2::<Memory32>),
+        "sock_accept_v2" => Function::new_typed_with_env(&mut store, env, sock_accept_v2::<Memory32>),
+        "sock_connect" => Function::new_typed_with_env(&mut store, env, sock_connect::<Memory32>),
+        "sock_recv" => Function::new_typed_with_env(&mut store, env, sock_recv::<Memory32>),
+        "sock_recv_from" => Function::new_typed_with_env(&mut store, env, sock_recv_from::<Memory32>),
+        "sock_send" => Function::new_typed_with_env(&mut store, env, sock_send::<Memory32>),
+        "sock_send_to" => Function::new_typed_with_env(&mut store, env, sock_send_to::<Memory32>),
+        "sock_send_file" => Function::new_typed_with_env(&mut store, env, sock_send_file::<Memory32>),
+        "sock_shutdown" => Function::new_typed_with_env(&mut store, env, sock_shutdown),
+        "resolve" => Function::new_typed_with_env(&mut store, env, resolve::<Memory32>),
+    };
+    namespace
+}
+
+fn wasix_exports_64(mut store: &mut impl AsStoreMut, env: &FunctionEnv<WasiEnv>) -> Exports {
+    use syscalls::*;
+    let namespace = namespace! {
+        "args_get" => Function::new_typed_with_env(&mut store, env, args_get::<Memory64>),
+        "args_sizes_get" => Function::new_typed_with_env(&mut store, env, args_sizes_get::<Memory64>),
+        "clock_res_get" => Function::new_typed_with_env(&mut store, env, clock_res_get::<Memory64>),
+        "clock_time_get" => Function::new_typed_with_env(&mut store, env, clock_time_get::<Memory64>),
+        "clock_time_set" => Function::new_typed_with_env(&mut store, env, clock_time_set::<Memory64>),
+        "environ_get" => Function::new_typed_with_env(&mut store, env, environ_get::<Memory64>),
+        "environ_sizes_get" => Function::new_typed_with_env(&mut store, env, environ_sizes_get::<Memory64>),
+        "epoll_create" => Function::new_typed_with_env(&mut store, env, epoll_create::<Memory64>),
+        "epoll_ctl" => Function::new_typed_with_env(&mut store, env, epoll_ctl::<Memory64>),
+        "epoll_wait" => Function::new_typed_with_env(&mut store, env, epoll_wait::<Memory64>),
+        "fd_advise" => Function::new_typed_with_env(&mut store, env, fd_advise),
+        "fd_allocate" => Function::new_typed_with_env(&mut store, env, fd_allocate),
+        "fd_close" => Function::new_typed_with_env(&mut store, env, fd_close),
+        "fd_datasync" => Function::new_typed_with_env(&mut store, env, fd_datasync),
+        "fd_fdstat_get" => Function::new_typed_with_env(&mut store, env, fd_fdstat_get::<Memory64>),
+        "fd_fdstat_set_flags" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_flags),
+        "fd_fdstat_set_rights" => Function::new_typed_with_env(&mut store, env, fd_fdstat_set_rights),
+        "fd_filestat_get" => Function::new_typed_with_env(&mut store, env, fd_filestat_get::<Memory64>),
+        "fd_filestat_set_size" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_size),
+        "fd_filestat_set_times" => Function::new_typed_with_env(&mut store, env, fd_filestat_set_times),
+        "fd_pread" => Function::new_typed_with_env(&mut store, env, fd_pread::<Memory64>),
+        "fd_prestat_get" => Function::new_typed_with_env(&mut store, env, fd_prestat_get::<Memory64>),
+        "fd_prestat_dir_name" => Function::new_typed_with_env(&mut store, env, fd_prestat_dir_name::<Memory64>),
+        "fd_pwrite" => Function::new_typed_with_env(&mut store, env, fd_pwrite::<Memory64>),
+        "fd_read" => Function::new_typed_with_env(&mut store, env, fd_read::<Memory64>),
+        "fd_readdir" => Function::new_typed_with_env(&mut store, env, fd_readdir::<Memory64>),
+        "fd_renumber" => Function::new_typed_with_env(&mut store, env, fd_renumber),
+        "fd_dup" => Function::new_typed_with_env(&mut store, env, fd_dup::<Memory64>),
+        "fd_event" => Function::new_typed_with_env(&mut store, env, fd_event::<Memory64>),
+        "fd_seek" => Function::new_typed_with_env(&mut store, env, fd_seek::<Memory64>),
+        "fd_sync" => Function::new_typed_with_env(&mut store, env, fd_sync),
+        "fd_tell" => Function::new_typed_with_env(&mut store, env, fd_tell::<Memory64>),
+        "fd_write" => Function::new_typed_with_env(&mut store, env, fd_write::<Memory64>),
+        "fd_pipe" => Function::new_typed_with_env(&mut store, env, fd_pipe::<Memory64>),
+        "path_create_directory" => Function::new_typed_with_env(&mut store, env, path_create_directory::<Memory64>),
+        "path_filestat_get" => Function::new_typed_with_env(&mut store, env, path_filestat_get::<Memory64>),
+        "path_filestat_set_times" => Function::new_typed_with_env(&mut store, env, path_filestat_set_times::<Memory64>),
+        "path_link" => Function::new_typed_with_env(&mut store, env, path_link::<Memory64>),
+        "path_open" => Function::new_typed_with_env(&mut store, env, path_open::<Memory64>),
+        "path_readlink" => Function::new_typed_with_env(&mut store, env, path_readlink::<Memory64>),
+        "path_remove_directory" => Function::new_typed_with_env(&mut store, env, path_remove_directory::<Memory64>),
+        "path_rename" => Function::new_typed_with_env(&mut store, env, path_rename::<Memory64>),
+        "path_symlink" => Function::new_typed_with_env(&mut store, env, path_symlink::<Memory64>),
+        "path_unlink_file" => Function::new_typed_with_env(&mut store, env, path_unlink_file::<Memory64>),
+        "poll_oneoff" => Function::new_typed_with_env(&mut store, env, poll_oneoff::<Memory64>),
+        "proc_exit" => Function::new_typed_with_env(&mut store, env, proc_exit::<Memory64>),
+        "proc_fork" => Function::new_typed_with_env(&mut store, env, proc_fork::<Memory64>),
+        "proc_join" => Function::new_typed_with_env(&mut store, env, proc_join::<Memory64>),
+        "proc_signal" => Function::new_typed_with_env(&mut store, env, proc_signal::<Memory64>),
+        "proc_exec" => Function::new_typed_with_env(&mut store, env, proc_exec::<Memory64>),
+        "proc_raise" => Function::new_typed_with_env(&mut store, env, proc_raise),
+        "proc_raise_interval" => Function::new_typed_with_env(&mut store, env, proc_raise_interval),
+        "proc_spawn" => Function::new_typed_with_env(&mut store, env, proc_spawn::<Memory64>),
+        "proc_id" => Function::new_typed_with_env(&mut store, env, proc_id::<Memory64>),
+        "proc_parent" => Function::new_typed_with_env(&mut store, env, proc_parent::<Memory64>),
+        "random_get" => Function::new_typed_with_env(&mut store, env, random_get::<Memory64>),
+        "tty_get" => Function::new_typed_with_env(&mut store, env, tty_get::<Memory64>),
+        "tty_set" => Function::new_typed_with_env(&mut store, env, tty_set::<Memory64>),
+        "getcwd" => Function::new_typed_with_env(&mut store, env, getcwd::<Memory64>),
+        "chdir" => Function::new_typed_with_env(&mut store, env, chdir::<Memory64>),
+        "callback_signal" => Function::new_typed_with_env(&mut store, env, callback_signal::<Memory64>),
+        "thread_spawn" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory64>),
+        "thread_spawn_v2" => Function::new_typed_with_env(&mut store, env, thread_spawn_v2::<Memory64>),
+        "thread_sleep" => Function::new_typed_with_env(&mut store, env, thread_sleep::<Memory64>),
+        "thread_id" => Function::new_typed_with_env(&mut store, env, thread_id::<Memory64>),
+        "thread_signal" => Function::new_typed_with_env(&mut store, env, thread_signal),
+        "thread_join" => Function::new_typed_with_env(&mut store, env, thread_join::<Memory64>),
+        "thread_parallelism" => Function::new_typed_with_env(&mut store, env, thread_parallelism::<Memory64>),
+        "thread_exit" => Function::new_typed_with_env(&mut store, env, thread_exit),
+        "sched_yield" => Function::new_typed_with_env(&mut store, env, sched_yield::<Memory64>),
+        "stack_checkpoint" => Function::new_typed_with_env(&mut store, env, stack_checkpoint::<Memory64>),
+        "stack_restore" => Function::new_typed_with_env(&mut store, env, stack_restore::<Memory64>),
+        "futex_wait" => Function::new_typed_with_env(&mut store, env, futex_wait::<Memory64>),
+        "futex_wake" => Function::new_typed_with_env(&mut store, env, futex_wake::<Memory64>),
+        "futex_wake_all" => Function::new_typed_with_env(&mut store, env, futex_wake_all::<Memory64>),
+        "port_bridge" => Function::new_typed_with_env(&mut store, env, port_bridge::<Memory64>),
+        "port_unbridge" => Function::new_typed_with_env(&mut store, env, port_unbridge),
+        "port_dhcp_acquire" => Function::new_typed_with_env(&mut store, env, port_dhcp_acquire),
+        "port_addr_add" => Function::new_typed_with_env(&mut store, env, port_addr_add::<Memory64>),
+        "port_addr_remove" => Function::new_typed_with_env(&mut store, env, port_addr_remove::<Memory64>),
+        "port_addr_clear" => Function::new_typed_with_env(&mut store, env, port_addr_clear),
+        "port_addr_list" => Function::new_typed_with_env(&mut store, env, port_addr_list::<Memory64>),
+        "port_mac" => Function::new_typed_with_env(&mut store, env, port_mac::<Memory64>),
+        "port_gateway_set" => Function::new_typed_with_env(&mut store, env, port_gateway_set::<Memory64>),
+        "port_route_add" => Function::new_typed_with_env(&mut store, env, port_route_add::<Memory64>),
+        "port_route_remove" => Function::new_typed_with_env(&mut store, env, port_route_remove::<Memory64>),
+        "port_route_clear" => Function::new_typed_with_env(&mut store, env, port_route_clear),
+        "port_route_list" => Function::new_typed_with_env(&mut store, env, port_route_list::<Memory64>),
+        "sock_status" => Function::new_typed_with_env(&mut store, env, sock_status::<Memory64>),
+        "sock_addr_local" => Function::new_typed_with_env(&mut store, env, sock_addr_local::<Memory64>),
+        "sock_addr_peer" => Function::new_typed_with_env(&mut store, env, sock_addr_peer::<Memory64>),
+        "sock_open" => Function::new_typed_with_env(&mut store, env, sock_open::<Memory64>),
+        "sock_set_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_set_opt_flag),
+        "sock_get_opt_flag" => Function::new_typed_with_env(&mut store, env, sock_get_opt_flag::<Memory64>),
+        "sock_set_opt_time" => Function::new_typed_with_env(&mut store, env, sock_set_opt_time::<Memory64>),
+        "sock_get_opt_time" => Function::new_typed_with_env(&mut store, env, sock_get_opt_time::<Memory64>),
+        "sock_set_opt_size" => Function::new_typed_with_env(&mut store, env, sock_set_opt_size),
+        "sock_get_opt_size" => Function::new_typed_with_env(&mut store, env, sock_get_opt_size::<Memory64>),
+        "sock_join_multicast_v4" => Function::new_typed_with_env(&mut store, env, sock_join_multicast_v4::<Memory64>),
+        "sock_leave_multicast_v4" => Function::new_typed_with_env(&mut store, env, sock_leave_multicast_v4::<Memory64>),
+        "sock_join_multicast_v6" => Function::new_typed_with_env(&mut store, env, sock_join_multicast_v6::<Memory64>),
+        "sock_leave_multicast_v6" => Function::new_typed_with_env(&mut store, env, sock_leave_multicast_v6::<Memory64>),
+        "sock_bind" => Function::new_typed_with_env(&mut store, env, sock_bind::<Memory64>),
+        "sock_listen" => Function::new_typed_with_env(&mut store, env, sock_listen::<Memory64>),
+        "sock_accept" => Function::new_typed_with_env(&mut store, env, sock_accept_v2::<Memory64>),
+        "sock_accept_v2" => Function::new_typed_with_env(&mut store, env, sock_accept_v2::<Memory64>),
+        "sock_connect" => Function::new_typed_with_env(&mut store, env, sock_connect::<Memory64>),
+        "sock_recv" => Function::new_typed_with_env(&mut store, env, sock_recv::<Memory64>),
+        "sock_recv_from" => Function::new_typed_with_env(&mut store, env, sock_recv_from::<Memory64>),
+        "sock_send" => Function::new_typed_with_env(&mut store, env, sock_send::<Memory64>),
+        "sock_send_to" => Function::new_typed_with_env(&mut store, env, sock_send_to::<Memory64>),
+        "sock_send_file" => Function::new_typed_with_env(&mut store, env, sock_send_file::<Memory64>),
+        "sock_shutdown" => Function::new_typed_with_env(&mut store, env, sock_shutdown),
+        "resolve" => Function::new_typed_with_env(&mut store, env, resolve::<Memory64>),
+    };
+    namespace
+}
+
+pub type InstanceInitializer =
+    Box<dyn FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>>;
+
+type ModuleInitializer =
+    Box<dyn FnOnce(&wasmer::Instance, &dyn wasmer::AsStoreRef) -> Result<(), anyhow::Error>>;
+
+/// No-op module initializer.
+fn stub_initializer(
+    _instance: &wasmer::Instance,
+    _store: &dyn wasmer::AsStoreRef,
+) -> Result<(), anyhow::Error> {
+    Ok(())
+}
+
+// TODO: split function into two variants, one for JS and one for sys.
+// (this will make code less messy)
+fn import_object_for_all_wasi_versions(
+    _module: &wasmer::Module,
+    store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> (Imports, ModuleInitializer) {
+    let exports_wasi_generic = wasi_exports_generic(store, env);
+    let exports_wasi_unstable = wasi_unstable_exports(store, env);
+    let exports_wasi_snapshot_preview1 = wasi_snapshot_preview1_exports(store, env);
+    let exports_wasix_32v1 = wasix_exports_32(store, env);
+    let exports_wasix_64v1 = wasix_exports_64(store, env);
+
+    // Allowed due to JS feature flag complications.
+    #[allow(unused_mut)]
+    let mut imports = imports! {
+        "wasi" => exports_wasi_generic,
+        "wasi_unstable" => exports_wasi_unstable,
+        "wasi_snapshot_preview1" => exports_wasi_snapshot_preview1,
+        "wasix_32v1" => exports_wasix_32v1,
+        "wasix_64v1" => exports_wasix_64v1,
+    };
+
+    let init = Box::new(stub_initializer) as ModuleInitializer;
+
+    (imports, init)
+}
+
+/// Combines a state generating function with the import list for legacy WASI
+fn generate_import_object_snapshot0(
+    store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> Imports {
+    let exports_unstable = wasi_unstable_exports(store, env);
+    imports! {
+        "wasi_unstable" => exports_unstable
+    }
+}
+
+fn generate_import_object_snapshot1(
+    store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> Imports {
+    let exports_wasi_snapshot_preview1 = wasi_snapshot_preview1_exports(store, env);
+    imports! {
+        "wasi_snapshot_preview1" => exports_wasi_snapshot_preview1
+    }
+}
+
+/// Combines a state generating function with the import list for snapshot 1
+fn generate_import_object_wasix32_v1(
+    store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> Imports {
+    let exports_wasix_32v1 = wasix_exports_32(store, env);
+    imports! {
+        "wasix_32v1" => exports_wasix_32v1
+    }
+}
+
+fn generate_import_object_wasix64_v1(
+    store: &mut impl AsStoreMut,
+    env: &FunctionEnv<WasiEnv>,
+) -> Imports {
+    let exports_wasix_64v1 = wasix_exports_64(store, env);
+    imports! {
+        "wasix_64v1" => exports_wasix_64v1
+    }
+}
+
+fn mem_error_to_wasi(err: MemoryAccessError) -> Errno {
+    match err {
+        MemoryAccessError::HeapOutOfBounds => Errno::Memviolation,
+        MemoryAccessError::Overflow => Errno::Overflow,
+        MemoryAccessError::NonUtf8String => Errno::Inval,
+        _ => Errno::Unknown,
+    }
+}
+
+/// Run a synchronous function that would normally be blocking.
+///
+/// When the `sys-thread` feature is enabled, this will call
+/// [`tokio::task::block_in_place()`]. Otherwise, it calls the function
+/// immediately.
+pub(crate) fn block_in_place<Ret>(thunk: impl FnOnce() -> Ret) -> Ret {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "sys-thread")] {
+            tokio::task::block_in_place(thunk)
+        } else {
+            thunk()
+        }
+    }
+}
+
+/// Spawns a new blocking task that runs the provided closure.
+///
+/// The closure is executed on a separate thread, allowing it to perform blocking operations
+/// without blocking the main thread. The closure is wrapped in a `Future` that resolves to the
+/// result of the closure's execution.
+pub(crate) async fn spawn_blocking<F, R>(f: F) -> Result<R, tokio::task::JoinError>
+where
+    F: FnOnce() -> R + Send + 'static,
+    R: Send + 'static,
+{
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "wasm32")] {
+            Ok(block_in_place(f))
+        } else {
+            tokio::task::spawn_blocking(f).await
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/macros.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/macros.rs
new file mode 100644
index 0000000..fa2df0d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/macros.rs
@@ -0,0 +1,105 @@
+//! Macros to simplify some common WASI-specific tasks.
+
+/// Like the `try!` macro or `?` syntax: returns the value if the computation
+/// succeeded or returns the error value.
+macro_rules! wasi_try {
+    ($expr:expr) => {{
+        let res: Result<_, crate::syscalls::types::wasi::Errno> = $expr;
+        match res {
+            Ok(val) => {
+                //tracing::trace!("wasi::wasi_try::val: {:?}", val);
+                val
+            }
+            Err(err) => {
+                //tracing::debug!("wasi::wasi_try::err: {:?}", err);
+                return err;
+            }
+        }
+    }};
+}
+
+/// Like the `try!` macro or `?` syntax: returns the value if the computation
+/// succeeded or returns the error value. Results are wrapped in an Ok
+macro_rules! wasi_try_ok {
+    ($expr:expr) => {{
+        let res: Result<_, crate::syscalls::types::wasi::Errno> = $expr;
+        match res {
+            Ok(val) => {
+                //tracing::trace!("wasi::wasi_try_ok::val: {:?}", val);
+                val
+            }
+            Err(err) => {
+                //tracing::debug!("wasi::wasi_try_ok::err: {:?}", err);
+                return Ok(err);
+            }
+        }
+    }};
+}
+
+macro_rules! wasi_try_ok_ok {
+    ($expr:expr) => {{
+        let res: Result<_, crate::syscalls::types::wasi::Errno> = $expr;
+        match res {
+            Ok(val) => val,
+            Err(err) => {
+                return Ok(Err(err));
+            }
+        }
+    }};
+}
+
+/// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
+macro_rules! wasi_try_mem {
+    ($expr:expr) => {{
+        wasi_try!($expr.map_err($crate::mem_error_to_wasi))
+    }};
+}
+
+/// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
+macro_rules! wasi_try_mem_ok {
+    ($expr:expr) => {{
+        wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi))
+    }};
+
+    ($expr:expr, $thread:expr) => {{
+        wasi_try_ok!($expr.map_err($crate::mem_error_to_wasi), $thread)
+    }};
+}
+
+/// Like `wasi_try` but converts a `MemoryAccessError` to a `wasi::Errno`.
+macro_rules! wasi_try_mem_ok_ok {
+    ($expr:expr) => {{
+        wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi))
+    }};
+
+    ($expr:expr, $thread:expr) => {{
+        wasi_try_ok_ok!($expr.map_err($crate::mem_error_to_wasi), $thread)
+    }};
+}
+
+/// Reads a string from Wasm memory.
+macro_rules! get_input_str {
+    ($memory:expr, $data:expr, $len:expr) => {{
+        wasi_try_mem!($data.read_utf8_string($memory, $len))
+    }};
+}
+
+macro_rules! get_input_str_ok {
+    ($memory:expr, $data:expr, $len:expr) => {{
+        wasi_try_mem_ok!($data.read_utf8_string($memory, $len))
+    }};
+}
+
+#[allow(unused_macros)]
+macro_rules! get_input_str_bus {
+    ($memory:expr, $data:expr, $len:expr) => {{
+        wasi_try_mem_bus!($data.read_utf8_string($memory, $len))
+    }};
+}
+
+#[allow(unused_macros)]
+macro_rules! get_input_str_bus_ok {
+    ($memory:expr, $data:expr, $len:expr) => {{
+        wasi_try_mem_bus_ok!($data.read_utf8_string($memory, $len))
+    }};
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/mod.rs
new file mode 100644
index 0000000..76600a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/mod.rs
@@ -0,0 +1,400 @@
+use std::{
+    intrinsics::transmute,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr},
+    time::Duration,
+};
+
+use virtual_net::{IpCidr, IpRoute, NetworkError};
+use wasmer::{MemoryView, WasmPtr};
+use wasmer_types::MemorySize;
+use wasmer_wasix_types::{
+    types::{
+        OptionTag, OptionTimestamp, Route, __wasi_addr_ip4_t, __wasi_addr_ip6_t,
+        __wasi_addr_port_t, __wasi_addr_port_u, __wasi_addr_t, __wasi_addr_u, __wasi_cidr_t,
+        __wasi_cidr_u,
+    },
+    wasi::{Addressfamily, Errno},
+};
+
+pub mod socket;
+
+#[allow(dead_code)]
+pub(crate) fn read_ip<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_t, M>,
+) -> Result<IpAddr, Errno> {
+    let addr_ptr = ptr.deref(memory);
+    let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
+
+    let o = addr.u.octs;
+    Ok(match addr.tag {
+        Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
+        Addressfamily::Inet6 => {
+            let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(o) };
+            IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h))
+        }
+        _ => return Err(Errno::Inval),
+    })
+}
+
+pub(crate) fn read_ip_v4<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_ip4_t, M>,
+) -> Result<Ipv4Addr, Errno> {
+    let addr_ptr = ptr.deref(memory);
+    let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
+
+    let o = addr.octs;
+    Ok(Ipv4Addr::new(o[0], o[1], o[2], o[3]))
+}
+
+pub(crate) fn read_ip_v6<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_ip6_t, M>,
+) -> Result<Ipv6Addr, Errno> {
+    let addr_ptr = ptr.deref(memory);
+    let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
+
+    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(addr.segs) };
+    Ok(Ipv6Addr::new(a, b, c, d, e, f, g, h))
+}
+
+pub fn write_ip<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_t, M>,
+    ip: IpAddr,
+) -> Result<(), Errno> {
+    let ip = match ip {
+        IpAddr::V4(ip) => {
+            let o = ip.octets();
+            __wasi_addr_t {
+                tag: Addressfamily::Inet4,
+                _padding: 0,
+                u: __wasi_addr_u {
+                    octs: [o[0], o[1], o[2], o[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                },
+            }
+        }
+        IpAddr::V6(ip) => {
+            let o = ip.octets();
+            __wasi_addr_t {
+                tag: Addressfamily::Inet6,
+                _padding: 0,
+                u: __wasi_addr_u { octs: o },
+            }
+        }
+    };
+
+    let addr_ptr = ptr.deref(memory);
+    addr_ptr.write(ip).map_err(crate::mem_error_to_wasi)?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+pub(crate) fn read_cidr<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_cidr_t, M>,
+) -> Result<IpCidr, Errno> {
+    let addr_ptr = ptr.deref(memory);
+    let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
+
+    let o = addr.u.octs;
+    Ok(match addr.tag {
+        Addressfamily::Inet4 => IpCidr {
+            ip: IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
+            prefix: o[4],
+        },
+        Addressfamily::Inet6 => {
+            let [a, b, c, d, e, f, g, h] = {
+                let o = [
+                    o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10], o[11],
+                    o[12], o[13], o[14], o[15],
+                ];
+                unsafe { transmute::<_, [u16; 8]>(o) }
+            };
+            IpCidr {
+                ip: IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h)),
+                prefix: o[16],
+            }
+        }
+        _ => return Err(Errno::Inval),
+    })
+}
+
+#[allow(dead_code)]
+pub(crate) fn write_cidr<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_cidr_t, M>,
+    cidr: IpCidr,
+) -> Result<(), Errno> {
+    let p = cidr.prefix;
+    let cidr = match cidr.ip {
+        IpAddr::V4(ip) => {
+            let o = ip.octets();
+            __wasi_cidr_t {
+                tag: Addressfamily::Inet4,
+                _padding: 0,
+                u: __wasi_cidr_u {
+                    octs: [
+                        o[0], o[1], o[2], o[3], p, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    ],
+                },
+            }
+        }
+        IpAddr::V6(ip) => {
+            let o = ip.octets();
+            __wasi_cidr_t {
+                tag: Addressfamily::Inet6,
+                _padding: 0,
+                u: __wasi_cidr_u {
+                    octs: [
+                        o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10], o[11],
+                        o[12], o[13], o[14], o[15], p,
+                    ],
+                },
+            }
+        }
+    };
+
+    let addr_ptr = ptr.deref(memory);
+    addr_ptr.write(cidr).map_err(crate::mem_error_to_wasi)?;
+    Ok(())
+}
+
+pub(crate) fn read_ip_port<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<(IpAddr, u16), Errno> {
+    let addr_ptr = ptr.deref(memory);
+    let addr = addr_ptr.read().map_err(crate::mem_error_to_wasi)?;
+    let o = addr.u.octs;
+    Ok(match addr.tag {
+        Addressfamily::Inet4 => {
+            let port = u16::from_ne_bytes([o[0], o[1]]);
+            (IpAddr::V4(Ipv4Addr::new(o[2], o[3], o[4], o[5])), port)
+        }
+        Addressfamily::Inet6 => {
+            let octets: [u8; 16] = o[2..18].try_into().unwrap();
+            (
+                IpAddr::V6(Ipv6Addr::from(octets)),
+                u16::from_ne_bytes([o[0], o[1]]),
+            )
+        }
+        _ => {
+            tracing::debug!("invalid address family ({})", addr.tag as u8);
+            return Err(Errno::Inval);
+        }
+    })
+}
+
+#[allow(dead_code)]
+pub(crate) fn write_ip_port<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<__wasi_addr_port_t, M>,
+    ip: IpAddr,
+    port: u16,
+) -> Result<(), Errno> {
+    let p = port.to_be_bytes();
+    let ipport = match ip {
+        IpAddr::V4(ip) => {
+            let o = ip.octets();
+            __wasi_addr_port_t {
+                tag: Addressfamily::Inet4,
+                _padding: 0,
+                u: __wasi_addr_port_u {
+                    octs: [
+                        p[0], p[1], o[0], o[1], o[2], o[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                    ],
+                },
+            }
+        }
+        IpAddr::V6(ip) => {
+            let o = ip.octets();
+            __wasi_addr_port_t {
+                tag: Addressfamily::Inet6,
+                _padding: 0,
+                u: __wasi_addr_port_u {
+                    octs: [
+                        p[0], p[1], o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9],
+                        o[10], o[11], o[12], o[13], o[14], o[15],
+                    ],
+                },
+            }
+        }
+    };
+
+    let addr_ptr = ptr.deref(memory);
+    addr_ptr.write(ipport).map_err(crate::mem_error_to_wasi)?;
+    Ok(())
+}
+
+#[allow(dead_code)]
+pub(crate) fn read_route<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<Route, M>,
+) -> Result<IpRoute, Errno> {
+    let route_ptr = ptr.deref(memory);
+    let route = route_ptr.read().map_err(crate::mem_error_to_wasi)?;
+
+    Ok(IpRoute {
+        cidr: {
+            let o = route.cidr.u.octs;
+            match route.cidr.tag {
+                Addressfamily::Inet4 => IpCidr {
+                    ip: IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
+                    prefix: o[4],
+                },
+                Addressfamily::Inet6 => {
+                    let [a, b, c, d, e, f, g, h] = {
+                        let o = [
+                            o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10],
+                            o[11], o[12], o[13], o[14], o[15],
+                        ];
+                        unsafe { transmute::<_, [u16; 8]>(o) }
+                    };
+                    IpCidr {
+                        ip: IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h)),
+                        prefix: o[16],
+                    }
+                }
+                _ => return Err(Errno::Inval),
+            }
+        },
+        via_router: {
+            let o = route.via_router.u.octs;
+            match route.via_router.tag {
+                Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::new(o[0], o[1], o[2], o[3])),
+                Addressfamily::Inet6 => {
+                    let [a, b, c, d, e, f, g, h] = unsafe { transmute::<_, [u16; 8]>(o) };
+                    IpAddr::V6(Ipv6Addr::new(a, b, c, d, e, f, g, h))
+                }
+                _ => return Err(Errno::Inval),
+            }
+        },
+        preferred_until: match route.preferred_until.tag {
+            OptionTag::None => None,
+            OptionTag::Some => Some(Duration::from_nanos(route.preferred_until.u)),
+        },
+        expires_at: match route.expires_at.tag {
+            OptionTag::None => None,
+            OptionTag::Some => Some(Duration::from_nanos(route.expires_at.u)),
+        },
+    })
+}
+
+pub(crate) fn write_route<M: MemorySize>(
+    memory: &MemoryView,
+    ptr: WasmPtr<Route, M>,
+    route: IpRoute,
+) -> Result<(), Errno> {
+    let cidr = {
+        let p = route.cidr.prefix;
+        match route.cidr.ip {
+            IpAddr::V4(ip) => {
+                let o = ip.octets();
+                __wasi_cidr_t {
+                    tag: Addressfamily::Inet4,
+                    _padding: 0,
+                    u: __wasi_cidr_u {
+                        octs: [
+                            o[0], o[1], o[2], o[3], p, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                        ],
+                    },
+                }
+            }
+            IpAddr::V6(ip) => {
+                let o = ip.octets();
+                __wasi_cidr_t {
+                    tag: Addressfamily::Inet6,
+                    _padding: 0,
+                    u: __wasi_cidr_u {
+                        octs: [
+                            o[0], o[1], o[2], o[3], o[4], o[5], o[6], o[7], o[8], o[9], o[10],
+                            o[11], o[12], o[13], o[14], o[15], p,
+                        ],
+                    },
+                }
+            }
+        }
+    };
+    let via_router = match route.via_router {
+        IpAddr::V4(ip) => {
+            let o = ip.octets();
+            __wasi_addr_t {
+                tag: Addressfamily::Inet4,
+                _padding: 0,
+                u: __wasi_addr_u {
+                    octs: [o[0], o[1], o[2], o[3], 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                },
+            }
+        }
+        IpAddr::V6(ip) => {
+            let o = ip.octets();
+            __wasi_addr_t {
+                tag: Addressfamily::Inet6,
+                _padding: 0,
+                u: __wasi_addr_u { octs: o },
+            }
+        }
+    };
+    let preferred_until = match route.preferred_until {
+        None => OptionTimestamp {
+            tag: OptionTag::None,
+            u: 0,
+        },
+        Some(u) => OptionTimestamp {
+            tag: OptionTag::Some,
+            u: u.as_nanos() as u64,
+        },
+    };
+    let expires_at = match route.expires_at {
+        None => OptionTimestamp {
+            tag: OptionTag::None,
+            u: 0,
+        },
+        Some(u) => OptionTimestamp {
+            tag: OptionTag::Some,
+            u: u.as_nanos() as u64,
+        },
+    };
+
+    let route = Route {
+        cidr,
+        via_router,
+        preferred_until,
+        expires_at,
+    };
+
+    let route_ptr = ptr.deref(memory);
+    route_ptr.write(route).map_err(crate::mem_error_to_wasi)?;
+    Ok(())
+}
+
+pub fn net_error_into_wasi_err(net_error: NetworkError) -> Errno {
+    match net_error {
+        NetworkError::InvalidFd => Errno::Badf,
+        NetworkError::AlreadyExists => Errno::Exist,
+        NetworkError::Lock => Errno::Io,
+        NetworkError::IOError => Errno::Io,
+        NetworkError::AddressInUse => Errno::Addrinuse,
+        NetworkError::AddressNotAvailable => Errno::Addrnotavail,
+        NetworkError::BrokenPipe => Errno::Pipe,
+        NetworkError::ConnectionAborted => Errno::Connaborted,
+        NetworkError::ConnectionRefused => Errno::Connrefused,
+        NetworkError::ConnectionReset => Errno::Connreset,
+        NetworkError::Interrupted => Errno::Intr,
+        NetworkError::InvalidData => Errno::Io,
+        NetworkError::InvalidInput => Errno::Inval,
+        NetworkError::NotConnected => Errno::Notconn,
+        NetworkError::NoDevice => Errno::Nodev,
+        NetworkError::PermissionDenied => Errno::Perm,
+        NetworkError::TimedOut => Errno::Timedout,
+        NetworkError::UnexpectedEof => Errno::Proto,
+        NetworkError::WouldBlock => Errno::Again,
+        NetworkError::WriteZero => Errno::Nospc,
+        NetworkError::TooManyOpenFiles => Errno::Mfile,
+        NetworkError::InsufficientMemory => Errno::Nomem,
+        NetworkError::Unsupported => Errno::Notsup,
+        NetworkError::UnknownError => Errno::Io,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/socket.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/socket.rs
new file mode 100644
index 0000000..bbf6c8d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/net/socket.rs
@@ -0,0 +1,1518 @@
+use std::{
+    future::Future,
+    io,
+    mem::MaybeUninit,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    pin::Pin,
+    sync::{Arc, RwLock},
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use derivative::Derivative;
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+use virtual_mio::InterestHandler;
+use virtual_net::{
+    net_error_into_io_err, NetworkError, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket,
+    VirtualTcpListener, VirtualTcpSocket, VirtualUdpSocket,
+};
+use wasmer_types::MemorySize;
+use wasmer_wasix_types::wasi::{Addressfamily, Errno, Rights, SockProto, Sockoption, Socktype};
+
+use crate::{net::net_error_into_wasi_err, VirtualTaskManager};
+
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum InodeHttpSocketType {
+    /// Used to feed the bytes into the request itself
+    Request,
+    /// Used to receive the bytes from the HTTP server
+    Response,
+    /// Used to read the headers from the HTTP server
+    Headers,
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct SocketProperties {
+    pub family: Addressfamily,
+    pub ty: Socktype,
+    pub pt: SockProto,
+    pub only_v6: bool,
+    pub reuse_port: bool,
+    pub reuse_addr: bool,
+    pub no_delay: Option<bool>,
+    pub keep_alive: Option<bool>,
+    pub dont_route: Option<bool>,
+    pub send_buf_size: Option<usize>,
+    pub recv_buf_size: Option<usize>,
+    pub write_timeout: Option<Duration>,
+    pub read_timeout: Option<Duration>,
+    pub accept_timeout: Option<Duration>,
+    pub connect_timeout: Option<Duration>,
+    #[derivative(Debug = "ignore")]
+    pub handler: Option<Box<dyn InterestHandler + Send + Sync>>,
+}
+
+#[derive(Debug)]
+//#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum InodeSocketKind {
+    PreSocket {
+        props: SocketProperties,
+        addr: Option<SocketAddr>,
+    },
+    Icmp(Box<dyn VirtualIcmpSocket + Sync>),
+    Raw(Box<dyn VirtualRawSocket + Sync>),
+    TcpListener {
+        socket: Box<dyn VirtualTcpListener + Sync>,
+        accept_timeout: Option<Duration>,
+    },
+    TcpStream {
+        socket: Box<dyn VirtualTcpSocket + Sync>,
+        write_timeout: Option<Duration>,
+        read_timeout: Option<Duration>,
+    },
+    UdpSocket {
+        socket: Box<dyn VirtualUdpSocket + Sync>,
+        peer: Option<SocketAddr>,
+    },
+    RemoteSocket {
+        props: SocketProperties,
+        local_addr: SocketAddr,
+        peer_addr: SocketAddr,
+        ttl: u32,
+        multicast_ttl: u32,
+    },
+}
+
+pub enum WasiSocketOption {
+    Noop,
+    ReusePort,
+    ReuseAddr,
+    NoDelay,
+    DontRoute,
+    OnlyV6,
+    Broadcast,
+    MulticastLoopV4,
+    MulticastLoopV6,
+    Promiscuous,
+    Listening,
+    LastError,
+    KeepAlive,
+    Linger,
+    OobInline,
+    RecvBufSize,
+    SendBufSize,
+    RecvLowat,
+    SendLowat,
+    RecvTimeout,
+    SendTimeout,
+    ConnectTimeout,
+    AcceptTimeout,
+    Ttl,
+    MulticastTtlV4,
+    Type,
+    Proto,
+}
+
+impl From<Sockoption> for WasiSocketOption {
+    fn from(opt: Sockoption) -> Self {
+        use WasiSocketOption::*;
+        match opt {
+            Sockoption::Noop => Noop,
+            Sockoption::ReusePort => ReusePort,
+            Sockoption::ReuseAddr => ReuseAddr,
+            Sockoption::NoDelay => NoDelay,
+            Sockoption::DontRoute => DontRoute,
+            Sockoption::OnlyV6 => OnlyV6,
+            Sockoption::Broadcast => Broadcast,
+            Sockoption::MulticastLoopV4 => MulticastLoopV4,
+            Sockoption::MulticastLoopV6 => MulticastLoopV6,
+            Sockoption::Promiscuous => Promiscuous,
+            Sockoption::Listening => Listening,
+            Sockoption::LastError => LastError,
+            Sockoption::KeepAlive => KeepAlive,
+            Sockoption::Linger => Linger,
+            Sockoption::OobInline => OobInline,
+            Sockoption::RecvBufSize => RecvBufSize,
+            Sockoption::SendBufSize => SendBufSize,
+            Sockoption::RecvLowat => RecvLowat,
+            Sockoption::SendLowat => SendLowat,
+            Sockoption::RecvTimeout => RecvTimeout,
+            Sockoption::SendTimeout => SendTimeout,
+            Sockoption::ConnectTimeout => ConnectTimeout,
+            Sockoption::AcceptTimeout => AcceptTimeout,
+            Sockoption::Ttl => Ttl,
+            Sockoption::MulticastTtlV4 => MulticastTtlV4,
+            Sockoption::Type => Type,
+            Sockoption::Proto => Proto,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum WasiSocketStatus {
+    Opening,
+    Opened,
+    Closed,
+    Failed,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum TimeType {
+    ReadTimeout,
+    WriteTimeout,
+    AcceptTimeout,
+    ConnectTimeout,
+    BindTimeout,
+    Linger,
+}
+
+impl From<TimeType> for wasmer_journal::SocketOptTimeType {
+    fn from(value: TimeType) -> Self {
+        match value {
+            TimeType::ReadTimeout => Self::ReadTimeout,
+            TimeType::WriteTimeout => Self::WriteTimeout,
+            TimeType::AcceptTimeout => Self::AcceptTimeout,
+            TimeType::ConnectTimeout => Self::ConnectTimeout,
+            TimeType::BindTimeout => Self::BindTimeout,
+            TimeType::Linger => Self::Linger,
+        }
+    }
+}
+
+impl From<wasmer_journal::SocketOptTimeType> for TimeType {
+    fn from(value: wasmer_journal::SocketOptTimeType) -> Self {
+        use wasmer_journal::SocketOptTimeType;
+        match value {
+            SocketOptTimeType::ReadTimeout => TimeType::ReadTimeout,
+            SocketOptTimeType::WriteTimeout => TimeType::WriteTimeout,
+            SocketOptTimeType::AcceptTimeout => TimeType::AcceptTimeout,
+            SocketOptTimeType::ConnectTimeout => TimeType::ConnectTimeout,
+            SocketOptTimeType::BindTimeout => TimeType::BindTimeout,
+            SocketOptTimeType::Linger => TimeType::Linger,
+        }
+    }
+}
+
+#[derive(Debug)]
+//#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub(crate) struct InodeSocketProtected {
+    pub kind: InodeSocketKind,
+}
+
+#[derive(Debug)]
+//#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub(crate) struct InodeSocketInner {
+    pub protected: RwLock<InodeSocketProtected>,
+}
+
+#[derive(Debug, Clone)]
+//#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct InodeSocket {
+    pub(crate) inner: Arc<InodeSocketInner>,
+}
+
+impl InodeSocket {
+    pub fn new(kind: InodeSocketKind) -> Self {
+        let protected = InodeSocketProtected { kind };
+        Self {
+            inner: Arc::new(InodeSocketInner {
+                protected: RwLock::new(protected),
+            }),
+        }
+    }
+
+    pub fn poll_read_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.protected.write().unwrap();
+        inner.poll_read_ready(cx)
+    }
+
+    pub fn poll_write_ready(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        let mut inner = self.inner.protected.write().unwrap();
+        inner.poll_read_ready(cx)
+    }
+
+    pub async fn bind(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        net: &dyn VirtualNetworking,
+        set_addr: SocketAddr,
+    ) -> Result<Option<InodeSocket>, Errno> {
+        let timeout = self
+            .opt_time(TimeType::BindTimeout)
+            .ok()
+            .flatten()
+            .unwrap_or(Duration::from_secs(30));
+
+        let socket = {
+            let mut inner = self.inner.protected.write().unwrap();
+            match &mut inner.kind {
+                InodeSocketKind::PreSocket { props, addr, .. } => {
+                    match props.family {
+                        Addressfamily::Inet4 => {
+                            if !set_addr.is_ipv4() {
+                                tracing::debug!(
+                                    "IP address is the wrong type IPv4 ({set_addr}) vs IPv6 family"
+                                );
+                                return Err(Errno::Inval);
+                            }
+                        }
+                        Addressfamily::Inet6 => {
+                            if !set_addr.is_ipv6() {
+                                tracing::debug!(
+                                    "IP address is the wrong type IPv6 ({set_addr}) vs IPv4 family"
+                                );
+                                return Err(Errno::Inval);
+                            }
+                        }
+                        _ => {
+                            return Err(Errno::Notsup);
+                        }
+                    }
+
+                    addr.replace(set_addr);
+                    let addr = (*addr).unwrap();
+
+                    match props.ty {
+                        Socktype::Stream => {
+                            // we already set the socket address - next we need a listen or connect so nothing
+                            // more to do at this time
+                            return Ok(None);
+                        }
+                        Socktype::Dgram => {
+                            let reuse_port = props.reuse_port;
+                            let reuse_addr = props.reuse_addr;
+                            drop(inner);
+
+                            net.bind_udp(addr, reuse_port, reuse_addr)
+                        }
+                        _ => return Err(Errno::Inval),
+                    }
+                }
+                InodeSocketKind::RemoteSocket {
+                    props,
+                    local_addr: addr,
+                    ..
+                } => {
+                    match props.family {
+                        Addressfamily::Inet4 => {
+                            if !set_addr.is_ipv4() {
+                                tracing::debug!(
+                                    "IP address is the wrong type IPv4 ({set_addr}) vs IPv6 family"
+                                );
+                                return Err(Errno::Inval);
+                            }
+                        }
+                        Addressfamily::Inet6 => {
+                            if !set_addr.is_ipv6() {
+                                tracing::debug!(
+                                    "IP address is the wrong type IPv6 ({set_addr}) vs IPv4 family"
+                                );
+                                return Err(Errno::Inval);
+                            }
+                        }
+                        _ => {
+                            return Err(Errno::Notsup);
+                        }
+                    }
+
+                    *addr = set_addr;
+                    let addr = *addr;
+
+                    match props.ty {
+                        Socktype::Stream => {
+                            // we already set the socket address - next we need a listen or connect so nothing
+                            // more to do at this time
+                            return Ok(None);
+                        }
+                        Socktype::Dgram => {
+                            let reuse_port = props.reuse_port;
+                            let reuse_addr = props.reuse_addr;
+                            drop(inner);
+
+                            net.bind_udp(addr, reuse_port, reuse_addr)
+                        }
+                        _ => return Err(Errno::Inval),
+                    }
+                }
+                _ => return Err(Errno::Notsup),
+            }
+        };
+
+        tokio::select! {
+            socket = socket => {
+                let socket = socket.map_err(net_error_into_wasi_err)?;
+                Ok(Some(InodeSocket::new(InodeSocketKind::UdpSocket { socket, peer: None })))
+            },
+            _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+        }
+    }
+
+    pub async fn listen(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        net: &dyn VirtualNetworking,
+        _backlog: usize,
+    ) -> Result<Option<InodeSocket>, Errno> {
+        let timeout = self
+            .opt_time(TimeType::AcceptTimeout)
+            .ok()
+            .flatten()
+            .unwrap_or(Duration::from_secs(30));
+
+        let socket = {
+            let inner = self.inner.protected.read().unwrap();
+            match &inner.kind {
+                InodeSocketKind::PreSocket { props, addr, .. } => match props.ty {
+                    Socktype::Stream => {
+                        if addr.is_none() {
+                            tracing::warn!("wasi[?]::sock_listen - failed - address not set");
+                            return Err(Errno::Inval);
+                        }
+                        let addr = *addr.as_ref().unwrap();
+                        let only_v6 = props.only_v6;
+                        let reuse_port = props.reuse_port;
+                        let reuse_addr = props.reuse_addr;
+                        drop(inner);
+
+                        net.listen_tcp(addr, only_v6, reuse_port, reuse_addr)
+                    }
+                    ty => {
+                        tracing::warn!(
+                            "wasi[?]::sock_listen - failed - not supported(pre-socket:{:?})",
+                            ty
+                        );
+                        return Err(Errno::Notsup);
+                    }
+                },
+                InodeSocketKind::RemoteSocket {
+                    props,
+                    local_addr: addr,
+                    ..
+                } => match props.ty {
+                    Socktype::Stream => {
+                        let addr = *addr;
+                        let only_v6 = props.only_v6;
+                        let reuse_port = props.reuse_port;
+                        let reuse_addr = props.reuse_addr;
+                        drop(inner);
+
+                        net.listen_tcp(addr, only_v6, reuse_port, reuse_addr)
+                    }
+                    ty => {
+                        tracing::warn!(
+                            "wasi[?]::sock_listen - failed - not supported(remote-socket:{:?})",
+                            ty
+                        );
+                        return Err(Errno::Notsup);
+                    }
+                },
+                InodeSocketKind::Icmp(_) => {
+                    tracing::warn!("wasi[?]::sock_listen - failed - not supported(icmp)");
+                    return Err(Errno::Notsup);
+                }
+                InodeSocketKind::Raw(_) => {
+                    tracing::warn!("wasi[?]::sock_listen - failed - not supported(raw)");
+                    return Err(Errno::Notsup);
+                }
+                InodeSocketKind::TcpListener { .. } => {
+                    tracing::warn!(
+                        "wasi[?]::sock_listen - failed - already listening (tcp-listener)"
+                    );
+                    return Err(Errno::Notsup);
+                }
+                InodeSocketKind::TcpStream { .. } => {
+                    tracing::warn!("wasi[?]::sock_listen - failed - not supported(tcp-stream)");
+                    return Err(Errno::Notsup);
+                }
+                InodeSocketKind::UdpSocket { .. } => {
+                    tracing::warn!("wasi[?]::sock_listen - failed - not supported(udp-socket)");
+                    return Err(Errno::Notsup);
+                }
+            }
+        };
+
+        tokio::select! {
+            socket = socket => {
+                let socket = socket.map_err(net_error_into_wasi_err)?;
+                Ok(Some(InodeSocket::new(InodeSocketKind::TcpListener {
+                    socket,
+                    accept_timeout: Some(timeout),
+                })))
+            },
+            _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+        }
+    }
+
+    pub async fn accept(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        nonblocking: bool,
+        timeout: Option<Duration>,
+    ) -> Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr), Errno> {
+        struct SocketAccepter<'a> {
+            sock: &'a InodeSocket,
+            nonblocking: bool,
+            handler_registered: bool,
+        }
+        impl<'a> Drop for SocketAccepter<'a> {
+            fn drop(&mut self) {
+                if self.handler_registered {
+                    let mut inner = self.sock.inner.protected.write().unwrap();
+                    inner.remove_handler();
+                }
+            }
+        }
+        impl<'a> Future for SocketAccepter<'a> {
+            type Output = Result<(Box<dyn VirtualTcpSocket + Sync>, SocketAddr), Errno>;
+            fn poll(
+                mut self: Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Self::Output> {
+                loop {
+                    let mut inner = self.sock.inner.protected.write().unwrap();
+                    return match &mut inner.kind {
+                        InodeSocketKind::TcpListener { socket, .. } => match socket.try_accept() {
+                            Ok((child, addr)) => Poll::Ready(Ok((child, addr))),
+                            Err(NetworkError::WouldBlock) if self.nonblocking => {
+                                Poll::Ready(Err(Errno::Again))
+                            }
+                            Err(NetworkError::WouldBlock) if !self.handler_registered => {
+                                let res = socket.set_handler(cx.waker().into());
+                                if let Err(err) = res {
+                                    return Poll::Ready(Err(net_error_into_wasi_err(err)));
+                                }
+                                drop(inner);
+                                self.handler_registered = true;
+                                continue;
+                            }
+                            Err(NetworkError::WouldBlock) => Poll::Pending,
+                            Err(err) => Poll::Ready(Err(net_error_into_wasi_err(err))),
+                        },
+                        InodeSocketKind::PreSocket { .. } => Poll::Ready(Err(Errno::Notconn)),
+                        _ => Poll::Ready(Err(Errno::Notsup)),
+                    };
+                }
+            }
+        }
+
+        let acceptor = SocketAccepter {
+            sock: self,
+            nonblocking,
+            handler_registered: false,
+        };
+        if let Some(timeout) = timeout {
+            tokio::select! {
+                res = acceptor => res,
+                _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+            }
+        } else {
+            acceptor.await
+        }
+    }
+
+    pub fn close(&self) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::TcpListener { .. } => {}
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.close().map_err(net_error_into_wasi_err)?;
+            }
+            InodeSocketKind::Icmp(_) => {}
+            InodeSocketKind::UdpSocket { .. } => {}
+            InodeSocketKind::Raw(_) => {}
+            InodeSocketKind::PreSocket { .. } => return Err(Errno::Notconn),
+            InodeSocketKind::RemoteSocket { .. } => {}
+        };
+        Ok(())
+    }
+
+    pub async fn connect(
+        &mut self,
+        tasks: &dyn VirtualTaskManager,
+        net: &dyn VirtualNetworking,
+        peer: SocketAddr,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<Option<InodeSocket>, Errno> {
+        let new_write_timeout;
+        let new_read_timeout;
+
+        let timeout = timeout.unwrap_or(Duration::from_secs(30));
+
+        let handler;
+        let connect = {
+            let mut inner = self.inner.protected.write().unwrap();
+            match &mut inner.kind {
+                InodeSocketKind::PreSocket { props, addr, .. } => {
+                    handler = props.handler.take();
+                    new_write_timeout = props.write_timeout;
+                    new_read_timeout = props.read_timeout;
+                    match props.ty {
+                        Socktype::Stream => {
+                            let no_delay = props.no_delay;
+                            let keep_alive = props.keep_alive;
+                            let dont_route = props.dont_route;
+                            let addr = match addr {
+                                Some(a) => *a,
+                                None => {
+                                    let ip = match peer.is_ipv4() {
+                                        true => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+                                        false => IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                                    };
+                                    SocketAddr::new(ip, 0)
+                                }
+                            };
+                            Box::pin(async move {
+                                let mut ret = net.connect_tcp(addr, peer).await?;
+                                if let Some(no_delay) = no_delay {
+                                    ret.set_nodelay(no_delay).ok();
+                                }
+                                if let Some(keep_alive) = keep_alive {
+                                    ret.set_keepalive(keep_alive).ok();
+                                }
+                                if let Some(dont_route) = dont_route {
+                                    ret.set_dontroute(dont_route).ok();
+                                }
+                                Ok(ret)
+                            })
+                        }
+                        Socktype::Dgram => return Err(Errno::Inval),
+                        _ => return Err(Errno::Notsup),
+                    }
+                }
+                InodeSocketKind::UdpSocket {
+                    peer: target_peer, ..
+                } => {
+                    target_peer.replace(peer);
+                    return Ok(None);
+                }
+                InodeSocketKind::RemoteSocket { peer_addr, .. } => {
+                    *peer_addr = peer;
+                    return Ok(None);
+                }
+                _ => return Err(Errno::Notsup),
+            }
+        };
+
+        let mut socket = tokio::select! {
+            res = connect => res.map_err(net_error_into_wasi_err)?,
+            _ = tasks.sleep_now(timeout) => return Err(Errno::Timedout)
+        };
+
+        if let Some(handler) = handler {
+            socket
+                .set_handler(handler)
+                .map_err(net_error_into_wasi_err)?;
+        }
+
+        let socket = InodeSocket::new(InodeSocketKind::TcpStream {
+            socket,
+            write_timeout: new_write_timeout,
+            read_timeout: new_read_timeout,
+        });
+
+        Ok(Some(socket))
+    }
+
+    pub fn status(&self) -> Result<WasiSocketStatus, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        Ok(match &inner.kind {
+            InodeSocketKind::PreSocket { .. } => WasiSocketStatus::Opening,
+            InodeSocketKind::TcpListener { .. } => WasiSocketStatus::Opened,
+            InodeSocketKind::TcpStream { .. } => WasiSocketStatus::Opened,
+            InodeSocketKind::UdpSocket { .. } => WasiSocketStatus::Opened,
+            InodeSocketKind::RemoteSocket { .. } => WasiSocketStatus::Opened,
+            _ => WasiSocketStatus::Failed,
+        })
+    }
+
+    pub fn addr_local(&self) -> Result<SocketAddr, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        Ok(match &inner.kind {
+            InodeSocketKind::PreSocket { props, addr, .. } => {
+                if let Some(addr) = addr {
+                    *addr
+                } else {
+                    SocketAddr::new(
+                        match props.family {
+                            Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+                            Addressfamily::Inet6 => IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                            _ => return Err(Errno::Inval),
+                        },
+                        0,
+                    )
+                }
+            }
+            InodeSocketKind::Icmp(sock) => sock.addr_local().map_err(net_error_into_wasi_err)?,
+            InodeSocketKind::TcpListener { socket, .. } => {
+                socket.addr_local().map_err(net_error_into_wasi_err)?
+            }
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.addr_local().map_err(net_error_into_wasi_err)?
+            }
+            InodeSocketKind::UdpSocket { socket, .. } => {
+                socket.addr_local().map_err(net_error_into_wasi_err)?
+            }
+            InodeSocketKind::RemoteSocket {
+                local_addr: addr, ..
+            } => *addr,
+            _ => return Err(Errno::Notsup),
+        })
+    }
+
+    pub fn addr_peer(&self) -> Result<SocketAddr, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        Ok(match &inner.kind {
+            InodeSocketKind::PreSocket { props, .. } => SocketAddr::new(
+                match props.family {
+                    Addressfamily::Inet4 => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+                    Addressfamily::Inet6 => IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                    _ => return Err(Errno::Inval),
+                },
+                0,
+            ),
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.addr_peer().map_err(net_error_into_wasi_err)?
+            }
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .addr_peer()
+                .map_err(net_error_into_wasi_err)?
+                .map(Ok)
+                .unwrap_or_else(|| {
+                    socket
+                        .addr_local()
+                        .map_err(net_error_into_wasi_err)
+                        .map(|addr| {
+                            SocketAddr::new(
+                                match addr {
+                                    SocketAddr::V4(_) => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
+                                    SocketAddr::V6(_) => IpAddr::V6(Ipv6Addr::UNSPECIFIED),
+                                },
+                                0,
+                            )
+                        })
+                })?,
+            InodeSocketKind::RemoteSocket { peer_addr, .. } => *peer_addr,
+            _ => return Err(Errno::Notsup),
+        })
+    }
+
+    pub fn set_opt_flag(&mut self, option: WasiSocketOption, val: bool) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                match option {
+                    WasiSocketOption::OnlyV6 => props.only_v6 = val,
+                    WasiSocketOption::ReusePort => props.reuse_port = val,
+                    WasiSocketOption::ReuseAddr => props.reuse_addr = val,
+                    WasiSocketOption::NoDelay => props.no_delay = Some(val),
+                    WasiSocketOption::KeepAlive => props.keep_alive = Some(val),
+                    WasiSocketOption::DontRoute => props.dont_route = Some(val),
+                    _ => return Err(Errno::Inval),
+                };
+            }
+            InodeSocketKind::Raw(sock) => match option {
+                WasiSocketOption::Promiscuous => {
+                    sock.set_promiscuous(val).map_err(net_error_into_wasi_err)?
+                }
+                _ => return Err(Errno::Inval),
+            },
+            InodeSocketKind::TcpStream { socket, .. } => match option {
+                WasiSocketOption::NoDelay => {
+                    socket.set_nodelay(val).map_err(net_error_into_wasi_err)?
+                }
+                WasiSocketOption::KeepAlive => {
+                    socket.set_keepalive(val).map_err(net_error_into_wasi_err)?
+                }
+                WasiSocketOption::DontRoute => {
+                    socket.set_dontroute(val).map_err(net_error_into_wasi_err)?
+                }
+                _ => return Err(Errno::Inval),
+            },
+            InodeSocketKind::TcpListener { .. } => return Err(Errno::Inval),
+            InodeSocketKind::UdpSocket { socket, .. } => match option {
+                WasiSocketOption::Broadcast => {
+                    socket.set_broadcast(val).map_err(net_error_into_wasi_err)?
+                }
+                WasiSocketOption::MulticastLoopV4 => socket
+                    .set_multicast_loop_v4(val)
+                    .map_err(net_error_into_wasi_err)?,
+                WasiSocketOption::MulticastLoopV6 => socket
+                    .set_multicast_loop_v6(val)
+                    .map_err(net_error_into_wasi_err)?,
+                _ => return Err(Errno::Inval),
+            },
+            _ => return Err(Errno::Notsup),
+        }
+        Ok(())
+    }
+
+    pub fn get_opt_flag(&self, option: WasiSocketOption) -> Result<bool, Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        Ok(match &mut inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => match option {
+                WasiSocketOption::OnlyV6 => props.only_v6,
+                WasiSocketOption::ReusePort => props.reuse_port,
+                WasiSocketOption::ReuseAddr => props.reuse_addr,
+                WasiSocketOption::NoDelay => props.no_delay.unwrap_or_default(),
+                WasiSocketOption::KeepAlive => props.keep_alive.unwrap_or_default(),
+                _ => return Err(Errno::Inval),
+            },
+            InodeSocketKind::Raw(sock) => match option {
+                WasiSocketOption::Promiscuous => {
+                    sock.promiscuous().map_err(net_error_into_wasi_err)?
+                }
+                _ => return Err(Errno::Inval),
+            },
+            InodeSocketKind::TcpStream { socket, .. } => match option {
+                WasiSocketOption::NoDelay => socket.nodelay().map_err(net_error_into_wasi_err)?,
+                WasiSocketOption::KeepAlive => {
+                    socket.keepalive().map_err(net_error_into_wasi_err)?
+                }
+                WasiSocketOption::DontRoute => {
+                    socket.dontroute().map_err(net_error_into_wasi_err)?
+                }
+                _ => return Err(Errno::Inval),
+            },
+            InodeSocketKind::UdpSocket { socket, .. } => match option {
+                WasiSocketOption::Broadcast => {
+                    socket.broadcast().map_err(net_error_into_wasi_err)?
+                }
+                WasiSocketOption::MulticastLoopV4 => socket
+                    .multicast_loop_v4()
+                    .map_err(net_error_into_wasi_err)?,
+                WasiSocketOption::MulticastLoopV6 => socket
+                    .multicast_loop_v6()
+                    .map_err(net_error_into_wasi_err)?,
+                _ => return Err(Errno::Inval),
+            },
+            _ => return Err(Errno::Notsup),
+        })
+    }
+
+    pub fn set_send_buf_size(&mut self, size: usize) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                props.send_buf_size = Some(size);
+            }
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket
+                    .set_send_buf_size(size)
+                    .map_err(net_error_into_wasi_err)?;
+            }
+            _ => return Err(Errno::Notsup),
+        }
+        Ok(())
+    }
+
+    pub fn send_buf_size(&self) -> Result<usize, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                Ok(props.send_buf_size.unwrap_or_default())
+            }
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.send_buf_size().map_err(net_error_into_wasi_err)
+            }
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn set_recv_buf_size(&mut self, size: usize) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                props.recv_buf_size = Some(size);
+            }
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket
+                    .set_recv_buf_size(size)
+                    .map_err(net_error_into_wasi_err)?;
+            }
+            _ => return Err(Errno::Notsup),
+        }
+        Ok(())
+    }
+
+    pub fn recv_buf_size(&self) -> Result<usize, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                Ok(props.recv_buf_size.unwrap_or_default())
+            }
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.recv_buf_size().map_err(net_error_into_wasi_err)
+            }
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn set_linger(&mut self, linger: Option<std::time::Duration>) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.set_linger(linger).map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::RemoteSocket { .. } => Ok(()),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn linger(&self) -> Result<Option<std::time::Duration>, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.linger().map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn set_opt_time(
+        &self,
+        ty: TimeType,
+        timeout: Option<std::time::Duration>,
+    ) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::TcpStream {
+                write_timeout,
+                read_timeout,
+                ..
+            } => {
+                match ty {
+                    TimeType::WriteTimeout => *write_timeout = timeout,
+                    TimeType::ReadTimeout => *read_timeout = timeout,
+                    _ => return Err(Errno::Inval),
+                }
+                Ok(())
+            }
+            InodeSocketKind::TcpListener { accept_timeout, .. } => {
+                match ty {
+                    TimeType::AcceptTimeout => *accept_timeout = timeout,
+                    _ => return Err(Errno::Inval),
+                }
+                Ok(())
+            }
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                match ty {
+                    TimeType::ConnectTimeout => props.connect_timeout = timeout,
+                    TimeType::AcceptTimeout => props.accept_timeout = timeout,
+                    TimeType::ReadTimeout => props.read_timeout = timeout,
+                    TimeType::WriteTimeout => props.write_timeout = timeout,
+                    _ => return Err(Errno::Io),
+                }
+                Ok(())
+            }
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn opt_time(&self, ty: TimeType) -> Result<Option<std::time::Duration>, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::TcpStream {
+                read_timeout,
+                write_timeout,
+                ..
+            } => Ok(match ty {
+                TimeType::ReadTimeout => *read_timeout,
+                TimeType::WriteTimeout => *write_timeout,
+                _ => return Err(Errno::Inval),
+            }),
+            InodeSocketKind::TcpListener { accept_timeout, .. } => Ok(match ty {
+                TimeType::AcceptTimeout => *accept_timeout,
+                _ => return Err(Errno::Inval),
+            }),
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => match ty {
+                TimeType::ConnectTimeout => Ok(props.connect_timeout),
+                TimeType::AcceptTimeout => Ok(props.accept_timeout),
+                TimeType::ReadTimeout => Ok(props.read_timeout),
+                TimeType::WriteTimeout => Ok(props.write_timeout),
+                _ => Err(Errno::Inval),
+            },
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn set_ttl(&self, ttl: u32) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.set_ttl(ttl).map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::UdpSocket { socket, .. } => {
+                socket.set_ttl(ttl).map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::RemoteSocket { ttl: set_ttl, .. } => {
+                *set_ttl = ttl;
+                Ok(())
+            }
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn ttl(&self) -> Result<u32, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.ttl().map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::UdpSocket { socket, .. } => {
+                socket.ttl().map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::RemoteSocket { ttl, .. } => Ok(*ttl),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn set_multicast_ttl_v4(&self, ttl: u32) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .set_multicast_ttl_v4(ttl)
+                .map_err(net_error_into_wasi_err),
+            InodeSocketKind::RemoteSocket {
+                multicast_ttl: set_ttl,
+                ..
+            } => {
+                *set_ttl = ttl;
+                Ok(())
+            }
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn multicast_ttl_v4(&self) -> Result<u32, Errno> {
+        let inner = self.inner.protected.read().unwrap();
+        match &inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => {
+                socket.multicast_ttl_v4().map_err(net_error_into_wasi_err)
+            }
+            InodeSocketKind::RemoteSocket { multicast_ttl, .. } => Ok(*multicast_ttl),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn join_multicast_v4(&self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .join_multicast_v4(multiaddr, iface)
+                .map_err(net_error_into_wasi_err),
+            InodeSocketKind::RemoteSocket { .. } => Ok(()),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn leave_multicast_v4(&self, multiaddr: Ipv4Addr, iface: Ipv4Addr) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .leave_multicast_v4(multiaddr, iface)
+                .map_err(net_error_into_wasi_err),
+            InodeSocketKind::RemoteSocket { .. } => Ok(()),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn join_multicast_v6(&self, multiaddr: Ipv6Addr, iface: u32) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .join_multicast_v6(multiaddr, iface)
+                .map_err(net_error_into_wasi_err),
+            InodeSocketKind::RemoteSocket { .. } => Ok(()),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub fn leave_multicast_v6(&mut self, multiaddr: Ipv6Addr, iface: u32) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::UdpSocket { socket, .. } => socket
+                .leave_multicast_v6(multiaddr, iface)
+                .map_err(net_error_into_wasi_err),
+            InodeSocketKind::RemoteSocket { .. } => Ok(()),
+            InodeSocketKind::PreSocket { .. } => Err(Errno::Io),
+            _ => Err(Errno::Notsup),
+        }
+    }
+
+    pub async fn send(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        buf: &[u8],
+        timeout: Option<Duration>,
+        nonblocking: bool,
+    ) -> Result<usize, Errno> {
+        struct SocketSender<'a, 'b> {
+            inner: &'a InodeSocketInner,
+            data: &'b [u8],
+            nonblocking: bool,
+            handler_registered: bool,
+        }
+        impl<'a, 'b> Drop for SocketSender<'a, 'b> {
+            fn drop(&mut self) {
+                if self.handler_registered {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    inner.remove_handler();
+                }
+            }
+        }
+        impl<'a, 'b> Future for SocketSender<'a, 'b> {
+            type Output = Result<usize, Errno>;
+            fn poll(
+                mut self: Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> Poll<Self::Output> {
+                loop {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    let res = match &mut inner.kind {
+                        InodeSocketKind::Raw(socket) => socket.try_send(self.data),
+                        InodeSocketKind::TcpStream { socket, .. } => socket.try_send(self.data),
+                        InodeSocketKind::UdpSocket { socket, peer } => {
+                            if let Some(peer) = peer {
+                                socket.try_send_to(self.data, *peer)
+                            } else {
+                                Err(NetworkError::NotConnected)
+                            }
+                        }
+                        InodeSocketKind::PreSocket { .. } => {
+                            return Poll::Ready(Err(Errno::Notconn))
+                        }
+                        InodeSocketKind::RemoteSocket { .. } => {
+                            return Poll::Ready(Ok(self.data.len()))
+                        }
+                        _ => return Poll::Ready(Err(Errno::Notsup)),
+                    };
+                    return match res {
+                        Ok(amt) => Poll::Ready(Ok(amt)),
+                        Err(NetworkError::WouldBlock) if self.nonblocking => {
+                            Poll::Ready(Err(Errno::Again))
+                        }
+                        Err(NetworkError::WouldBlock) if !self.handler_registered => {
+                            inner
+                                .set_handler(cx.waker().into())
+                                .map_err(net_error_into_wasi_err)?;
+                            drop(inner);
+                            self.handler_registered = true;
+                            continue;
+                        }
+                        Err(NetworkError::WouldBlock) => Poll::Pending,
+                        Err(err) => Poll::Ready(Err(net_error_into_wasi_err(err))),
+                    };
+                }
+            }
+        }
+
+        let poller = SocketSender {
+            inner: &self.inner,
+            data: buf,
+            nonblocking,
+            handler_registered: false,
+        };
+        if let Some(timeout) = timeout {
+            tokio::select! {
+                res = poller => res,
+                _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+            }
+        } else {
+            poller.await
+        }
+    }
+
+    pub async fn send_to<M: MemorySize>(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        buf: &[u8],
+        addr: SocketAddr,
+        timeout: Option<Duration>,
+        nonblocking: bool,
+    ) -> Result<usize, Errno> {
+        struct SocketSender<'a, 'b> {
+            inner: &'a InodeSocketInner,
+            data: &'b [u8],
+            addr: SocketAddr,
+            nonblocking: bool,
+            handler_registered: bool,
+        }
+        impl<'a, 'b> Drop for SocketSender<'a, 'b> {
+            fn drop(&mut self) {
+                if self.handler_registered {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    inner.remove_handler();
+                }
+            }
+        }
+        impl<'a, 'b> Future for SocketSender<'a, 'b> {
+            type Output = Result<usize, Errno>;
+            fn poll(
+                mut self: Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> Poll<Self::Output> {
+                loop {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    let res = match &mut inner.kind {
+                        InodeSocketKind::Icmp(socket) => socket.try_send_to(self.data, self.addr),
+                        InodeSocketKind::UdpSocket { socket, .. } => {
+                            socket.try_send_to(self.data, self.addr)
+                        }
+                        InodeSocketKind::PreSocket { .. } => {
+                            return Poll::Ready(Err(Errno::Notconn))
+                        }
+                        InodeSocketKind::RemoteSocket { .. } => {
+                            return Poll::Ready(Ok(self.data.len()))
+                        }
+                        _ => return Poll::Ready(Err(Errno::Notsup)),
+                    };
+                    return match res {
+                        Ok(amt) => Poll::Ready(Ok(amt)),
+                        Err(NetworkError::WouldBlock) if self.nonblocking => {
+                            Poll::Ready(Err(Errno::Again))
+                        }
+                        Err(NetworkError::WouldBlock) if !self.handler_registered => {
+                            inner
+                                .set_handler(cx.waker().into())
+                                .map_err(net_error_into_wasi_err)?;
+                            self.handler_registered = true;
+                            drop(inner);
+                            continue;
+                        }
+                        Err(NetworkError::WouldBlock) => Poll::Pending,
+                        Err(err) => Poll::Ready(Err(net_error_into_wasi_err(err))),
+                    };
+                }
+            }
+        }
+
+        let poller = SocketSender {
+            inner: &self.inner,
+            data: buf,
+            addr,
+            nonblocking,
+            handler_registered: false,
+        };
+        if let Some(timeout) = timeout {
+            tokio::select! {
+                res = poller => res,
+                _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+            }
+        } else {
+            poller.await
+        }
+    }
+
+    pub async fn recv(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        buf: &mut [MaybeUninit<u8>],
+        timeout: Option<Duration>,
+        nonblocking: bool,
+    ) -> Result<usize, Errno> {
+        struct SocketReceiver<'a, 'b> {
+            inner: &'a InodeSocketInner,
+            data: &'b mut [MaybeUninit<u8>],
+            nonblocking: bool,
+            handler_registered: bool,
+        }
+        impl<'a, 'b> Drop for SocketReceiver<'a, 'b> {
+            fn drop(&mut self) {
+                if self.handler_registered {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    inner.remove_handler();
+                }
+            }
+        }
+        impl<'a, 'b> Future for SocketReceiver<'a, 'b> {
+            type Output = Result<usize, Errno>;
+            fn poll(
+                mut self: Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> Poll<Self::Output> {
+                loop {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    let res = match &mut inner.kind {
+                        InodeSocketKind::Raw(socket) => socket.try_recv(self.data),
+                        InodeSocketKind::TcpStream { socket, .. } => socket.try_recv(self.data),
+                        InodeSocketKind::UdpSocket { socket, peer } => {
+                            if let Some(peer) = peer {
+                                match socket.try_recv_from(self.data) {
+                                    Ok((amt, addr)) if addr == *peer => Ok(amt),
+                                    Ok(_) => Err(NetworkError::WouldBlock),
+                                    Err(err) => Err(err),
+                                }
+                            } else {
+                                match socket.try_recv_from(self.data) {
+                                    Ok((amt, _)) => Ok(amt),
+                                    Err(err) => Err(err),
+                                }
+                            }
+                        }
+                        InodeSocketKind::RemoteSocket { .. } => {
+                            return Poll::Pending;
+                        }
+                        InodeSocketKind::PreSocket { .. } => {
+                            return Poll::Ready(Err(Errno::Notconn))
+                        }
+                        _ => return Poll::Ready(Err(Errno::Notsup)),
+                    };
+                    return match res {
+                        Ok(amt) => Poll::Ready(Ok(amt)),
+                        Err(NetworkError::WouldBlock) if self.nonblocking => {
+                            Poll::Ready(Err(Errno::Again))
+                        }
+                        Err(NetworkError::WouldBlock) if !self.handler_registered => {
+                            inner
+                                .set_handler(cx.waker().into())
+                                .map_err(net_error_into_wasi_err)?;
+                            self.handler_registered = true;
+                            drop(inner);
+                            continue;
+                        }
+
+                        Err(NetworkError::WouldBlock) => Poll::Pending,
+                        Err(err) => Poll::Ready(Err(net_error_into_wasi_err(err))),
+                    };
+                }
+            }
+        }
+
+        let poller = SocketReceiver {
+            inner: &self.inner,
+            data: buf,
+            nonblocking,
+            handler_registered: false,
+        };
+        if let Some(timeout) = timeout {
+            tokio::select! {
+                res = poller => res,
+                _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+            }
+        } else {
+            poller.await
+        }
+    }
+
+    pub async fn recv_from(
+        &self,
+        tasks: &dyn VirtualTaskManager,
+        buf: &mut [MaybeUninit<u8>],
+        timeout: Option<Duration>,
+        nonblocking: bool,
+    ) -> Result<(usize, SocketAddr), Errno> {
+        struct SocketReceiver<'a, 'b> {
+            inner: &'a InodeSocketInner,
+            data: &'b mut [MaybeUninit<u8>],
+            nonblocking: bool,
+            handler_registered: bool,
+        }
+        impl<'a, 'b> Drop for SocketReceiver<'a, 'b> {
+            fn drop(&mut self) {
+                if self.handler_registered {
+                    let mut inner = self.inner.protected.write().unwrap();
+                    inner.remove_handler();
+                }
+            }
+        }
+        impl<'a, 'b> Future for SocketReceiver<'a, 'b> {
+            type Output = Result<(usize, SocketAddr), Errno>;
+            fn poll(
+                mut self: Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> Poll<Self::Output> {
+                let mut inner = self.inner.protected.write().unwrap();
+                loop {
+                    let res = match &mut inner.kind {
+                        InodeSocketKind::Icmp(socket) => socket.try_recv_from(self.data),
+                        InodeSocketKind::UdpSocket { socket, .. } => {
+                            socket.try_recv_from(self.data)
+                        }
+                        InodeSocketKind::RemoteSocket { .. } => {
+                            return Poll::Pending;
+                        }
+                        InodeSocketKind::PreSocket { .. } => {
+                            return Poll::Ready(Err(Errno::Notconn))
+                        }
+                        _ => return Poll::Ready(Err(Errno::Notsup)),
+                    };
+                    return match res {
+                        Ok((amt, addr)) => Poll::Ready(Ok((amt, addr))),
+                        Err(NetworkError::WouldBlock) if self.nonblocking => {
+                            Poll::Ready(Err(Errno::Again))
+                        }
+                        Err(NetworkError::WouldBlock) if !self.handler_registered => {
+                            inner
+                                .set_handler(cx.waker().into())
+                                .map_err(net_error_into_wasi_err)?;
+                            self.handler_registered = true;
+                            continue;
+                        }
+                        Err(NetworkError::WouldBlock) => Poll::Pending,
+                        Err(err) => Poll::Ready(Err(net_error_into_wasi_err(err))),
+                    };
+                }
+            }
+        }
+
+        let poller = SocketReceiver {
+            inner: &self.inner,
+            data: buf,
+            nonblocking,
+            handler_registered: false,
+        };
+        if let Some(timeout) = timeout {
+            tokio::select! {
+                res = poller => res,
+                _ = tasks.sleep_now(timeout) => Err(Errno::Timedout)
+            }
+        } else {
+            poller.await
+        }
+    }
+
+    pub fn shutdown(&mut self, how: std::net::Shutdown) -> Result<(), Errno> {
+        let mut inner = self.inner.protected.write().unwrap();
+        match &mut inner.kind {
+            InodeSocketKind::TcpStream { socket, .. } => {
+                socket.shutdown(how).map_err(net_error_into_wasi_err)?;
+            }
+            InodeSocketKind::RemoteSocket { .. } => return Ok(()),
+            InodeSocketKind::PreSocket { .. } => return Err(Errno::Notconn),
+            _ => return Err(Errno::Notsup),
+        }
+        Ok(())
+    }
+
+    pub async fn can_write(&self) -> bool {
+        if let Ok(mut guard) = self.inner.protected.try_write() {
+            #[allow(clippy::match_like_matches_macro)]
+            match &mut guard.kind {
+                InodeSocketKind::TcpStream { .. }
+                | InodeSocketKind::RemoteSocket { .. }
+                | InodeSocketKind::UdpSocket { .. }
+                | InodeSocketKind::Raw(..) => true,
+                _ => false,
+            }
+        } else {
+            false
+        }
+    }
+}
+
+impl InodeSocketProtected {
+    pub fn remove_handler(&mut self) {
+        match &mut self.kind {
+            InodeSocketKind::TcpListener { socket, .. } => socket.remove_handler(),
+            InodeSocketKind::TcpStream { socket, .. } => socket.remove_handler(),
+            InodeSocketKind::UdpSocket { socket, .. } => socket.remove_handler(),
+            InodeSocketKind::Raw(socket) => socket.remove_handler(),
+            InodeSocketKind::Icmp(socket) => socket.remove_handler(),
+            InodeSocketKind::PreSocket { props, .. } => {
+                props.handler.take();
+            }
+            InodeSocketKind::RemoteSocket { props, .. } => {
+                props.handler.take();
+            }
+        }
+    }
+
+    pub fn poll_read_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        match &mut self.kind {
+            InodeSocketKind::TcpListener { socket, .. } => socket.poll_read_ready(cx),
+            InodeSocketKind::TcpStream { socket, .. } => socket.poll_read_ready(cx),
+            InodeSocketKind::UdpSocket { socket, .. } => socket.poll_read_ready(cx),
+            InodeSocketKind::Raw(socket) => socket.poll_read_ready(cx),
+            InodeSocketKind::Icmp(socket) => socket.poll_read_ready(cx),
+            InodeSocketKind::PreSocket { .. } => Poll::Pending,
+            InodeSocketKind::RemoteSocket { .. } => Poll::Pending,
+        }
+        .map_err(net_error_into_io_err)
+    }
+
+    pub fn poll_write_ready(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        match &mut self.kind {
+            InodeSocketKind::TcpListener { socket, .. } => socket.poll_write_ready(cx),
+            InodeSocketKind::TcpStream { socket, .. } => socket.poll_write_ready(cx),
+            InodeSocketKind::UdpSocket { socket, .. } => socket.poll_write_ready(cx),
+            InodeSocketKind::Raw(socket) => socket.poll_write_ready(cx),
+            InodeSocketKind::Icmp(socket) => socket.poll_write_ready(cx),
+            InodeSocketKind::PreSocket { .. } => Poll::Pending,
+            InodeSocketKind::RemoteSocket { .. } => Poll::Pending,
+        }
+        .map_err(net_error_into_io_err)
+    }
+
+    pub fn set_handler(
+        &mut self,
+        handler: Box<dyn InterestHandler + Send + Sync>,
+    ) -> virtual_net::Result<()> {
+        match &mut self.kind {
+            InodeSocketKind::TcpListener { socket, .. } => socket.set_handler(handler),
+            InodeSocketKind::TcpStream { socket, .. } => socket.set_handler(handler),
+            InodeSocketKind::UdpSocket { socket, .. } => socket.set_handler(handler),
+            InodeSocketKind::Raw(socket) => socket.set_handler(handler),
+            InodeSocketKind::Icmp(socket) => socket.set_handler(handler),
+            InodeSocketKind::PreSocket { props, .. }
+            | InodeSocketKind::RemoteSocket { props, .. } => {
+                props.handler.replace(handler);
+                Ok(())
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+struct IndefinitePoll {}
+
+impl Future for IndefinitePoll {
+    type Output = ();
+    fn poll(
+        self: Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        std::task::Poll::Pending
+    }
+}
+
+// TODO: review allow...
+#[allow(dead_code)]
+pub(crate) fn all_socket_rights() -> Rights {
+    Rights::FD_FDSTAT_SET_FLAGS
+        .union(Rights::FD_FILESTAT_GET)
+        .union(Rights::FD_READ)
+        .union(Rights::FD_WRITE)
+        .union(Rights::POLL_FD_READWRITE)
+        .union(Rights::SOCK_SHUTDOWN)
+        .union(Rights::SOCK_CONNECT)
+        .union(Rights::SOCK_LISTEN)
+        .union(Rights::SOCK_BIND)
+        .union(Rights::SOCK_ACCEPT)
+        .union(Rights::SOCK_RECV)
+        .union(Rights::SOCK_SEND)
+        .union(Rights::SOCK_ADDR_LOCAL)
+        .union(Rights::SOCK_ADDR_REMOTE)
+        .union(Rights::SOCK_RECV_FROM)
+        .union(Rights::SOCK_SEND_TO)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/cmd_wasmer.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
new file mode 100644
index 0000000..c0a0536
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/cmd_wasmer.rs
@@ -0,0 +1,164 @@
+use std::{any::Any, sync::Arc};
+
+use crate::{
+    os::task::{OwnedTaskStatus, TaskJoinHandle},
+    runtime::task_manager::InlineWaker,
+    SpawnError,
+};
+use wasmer::{FunctionEnvMut, Store};
+use wasmer_wasix_types::wasi::Errno;
+
+use crate::{
+    bin_factory::{spawn_exec, BinaryPackage},
+    syscalls::stderr_write,
+    Runtime, WasiEnv,
+};
+
+const HELP: &str = r#"USAGE:
+    wasmer <SUBCOMMAND>
+
+OPTIONS:
+    -h, --help       Print help information
+
+SUBCOMMANDS:
+    run            Run a WebAssembly file. Formats accepted: wasm, wat
+"#;
+
+const HELP_RUN: &str = r#"USAGE:
+    wasmer run <FILE> [ARGS]...
+
+ARGS:
+    <FILE>       File to run
+    <ARGS>...    Application arguments
+"#;
+
+use crate::os::command::VirtualCommand;
+
+#[derive(Debug, Clone)]
+pub struct CmdWasmer {
+    runtime: Arc<dyn Runtime + Send + Sync + 'static>,
+}
+
+impl CmdWasmer {
+    const NAME: &'static str = "wasmer";
+
+    pub fn new(runtime: Arc<dyn Runtime + Send + Sync + 'static>) -> Self {
+        Self { runtime }
+    }
+}
+
+impl CmdWasmer {
+    async fn run<'a>(
+        &self,
+        parent_ctx: &FunctionEnvMut<'a, WasiEnv>,
+        name: &str,
+        store: &mut Option<Store>,
+        config: &mut Option<WasiEnv>,
+        what: Option<String>,
+        mut args: Vec<String>,
+    ) -> Result<TaskJoinHandle, SpawnError> {
+        // If the first argument is a '--' then skip it
+        if args.first().map(|a| a.as_str()) == Some("--") {
+            args = args.into_iter().skip(1).collect();
+        }
+
+        if let Some(what) = what {
+            let store = store.take().ok_or(SpawnError::UnknownError)?;
+            let mut env = config.take().ok_or(SpawnError::UnknownError)?;
+
+            // Set the arguments of the environment by replacing the state
+            let mut state = env.state.fork();
+            args.insert(0, what.clone());
+            state.args = args;
+            env.state = Arc::new(state);
+
+            if let Ok(binary) = self.get_package(&what).await {
+                // Now run the module
+                spawn_exec(binary, name, store, env, &self.runtime).await
+            } else {
+                let _ = unsafe {
+                    stderr_write(
+                        parent_ctx,
+                        format!("package not found - {}\r\n", what).as_bytes(),
+                    )
+                }
+                .await;
+
+                let handle = OwnedTaskStatus::new_finished_with_code(Errno::Noent.into()).handle();
+                Ok(handle)
+            }
+            // Get the binary
+        } else {
+            let _ = unsafe { stderr_write(parent_ctx, HELP_RUN.as_bytes()) }.await;
+            let handle = OwnedTaskStatus::new_finished_with_code(Errno::Success.into()).handle();
+            Ok(handle)
+        }
+    }
+
+    pub async fn get_package(&self, name: &str) -> Result<BinaryPackage, anyhow::Error> {
+        // Need to make sure this task runs on the main runtime.
+        let (tx, rx) = tokio::sync::oneshot::channel();
+        let specifier = name.parse()?;
+        let rt = self.runtime.clone();
+        self.runtime.task_manager().task_shared(Box::new(|| {
+            Box::pin(async move {
+                let res = BinaryPackage::from_registry(&specifier, rt.as_ref()).await;
+                tx.send(res)
+                    .expect("could not send response to output channel");
+            })
+        }))?;
+        rx.await
+            .map_err(|_| anyhow::anyhow!("package retrieval response channel died"))?
+    }
+}
+
+impl VirtualCommand for CmdWasmer {
+    fn name(&self) -> &str {
+        Self::NAME
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn exec(
+        &self,
+        parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
+        name: &str,
+        store: &mut Option<Store>,
+        env: &mut Option<WasiEnv>,
+    ) -> Result<TaskJoinHandle, SpawnError> {
+        // Read the command we want to run
+        let env_inner = env.as_ref().ok_or(SpawnError::UnknownError)?;
+        let args = env_inner.state.args.clone();
+        let mut args = args.iter().map(|s| s.as_str());
+        let _alias = args.next();
+        let cmd = args.next();
+
+        // Check the command
+        let fut = async {
+            match cmd {
+                Some("run") => {
+                    let what = args.next().map(|a| a.to_string());
+                    let args = args.map(|a| a.to_string()).collect();
+                    self.run(parent_ctx, name, store, env, what, args).await
+                }
+                Some("--help") | None => {
+                    unsafe { stderr_write(parent_ctx, HELP.as_bytes()) }
+                        .await
+                        .ok();
+                    let handle =
+                        OwnedTaskStatus::new_finished_with_code(Errno::Success.into()).handle();
+                    Ok(handle)
+                }
+                Some(what) => {
+                    let what = Some(what.to_string());
+                    let args = args.map(|a| a.to_string()).collect();
+                    self.run(parent_ctx, name, store, env, what, args).await
+                }
+            }
+        };
+
+        InlineWaker::block_on(fut)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/mod.rs
new file mode 100644
index 0000000..470ca45
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/builtins/mod.rs
@@ -0,0 +1 @@
+pub mod cmd_wasmer;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/mod.rs
new file mode 100644
index 0000000..d5ecc59
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/command/mod.rs
@@ -0,0 +1,108 @@
+pub mod builtins;
+
+use std::{collections::HashMap, sync::Arc};
+
+use wasmer::{FunctionEnvMut, Store};
+use wasmer_wasix_types::wasi::Errno;
+
+use crate::{
+    runtime::task_manager::InlineWaker, syscalls::stderr_write, Runtime, SpawnError, WasiEnv,
+};
+
+use super::task::{OwnedTaskStatus, TaskJoinHandle, TaskStatus};
+
+/// A command available to an OS environment.
+pub trait VirtualCommand
+where
+    Self: std::fmt::Debug,
+{
+    /// Returns the canonical name of the command.
+    fn name(&self) -> &str;
+
+    /// Retrieve the command as as a [`std::any::Any`] reference.
+    fn as_any(&self) -> &dyn std::any::Any;
+
+    /// Executes the command.
+    fn exec(
+        &self,
+        parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
+        path: &str,
+        store: &mut Option<Store>,
+        config: &mut Option<WasiEnv>,
+    ) -> Result<TaskJoinHandle, SpawnError>;
+}
+
+#[derive(Debug, Clone)]
+pub struct Commands {
+    commands: HashMap<String, Arc<dyn VirtualCommand + Send + Sync + 'static>>,
+}
+
+impl Commands {
+    fn new() -> Self {
+        Self {
+            commands: HashMap::new(),
+        }
+    }
+
+    // TODO: this method should be somewhere on the runtime, not here.
+    pub fn new_with_builtins(runtime: Arc<dyn Runtime + Send + Sync + 'static>) -> Self {
+        let mut cmd = Self::new();
+        let cmd_wasmer = builtins::cmd_wasmer::CmdWasmer::new(runtime.clone());
+        cmd.register_command(cmd_wasmer);
+
+        cmd
+    }
+
+    /// Register a command.
+    ///
+    /// The command will be available with it's canonical name ([`VirtualCommand::name()`]) at /bin/NAME.
+    pub fn register_command<C: VirtualCommand + Send + Sync + 'static>(&mut self, cmd: C) {
+        let path = format!("/bin/{}", cmd.name());
+        self.register_command_with_path(cmd, path);
+    }
+
+    /// Register a command at a custom path.
+    pub fn register_command_with_path<C: VirtualCommand + Send + Sync + 'static>(
+        &mut self,
+        cmd: C,
+        path: String,
+    ) {
+        self.commands.insert(path, Arc::new(cmd));
+    }
+
+    /// Determine if a command exists at the given path.
+    pub fn exists(&self, path: &str) -> bool {
+        let name = path.to_string();
+        self.commands.contains_key(&name)
+    }
+
+    /// Get a command by its path.
+    pub fn get(&self, path: &str) -> Option<&Arc<dyn VirtualCommand + Send + Sync + 'static>> {
+        self.commands.get(path)
+    }
+
+    /// Execute a command.
+    pub fn exec(
+        &self,
+        parent_ctx: &FunctionEnvMut<'_, WasiEnv>,
+        path: &str,
+        store: &mut Option<Store>,
+        builder: &mut Option<WasiEnv>,
+    ) -> Result<TaskJoinHandle, SpawnError> {
+        let path = path.to_string();
+        if let Some(cmd) = self.commands.get(&path) {
+            cmd.exec(parent_ctx, path.as_str(), store, builder)
+        } else {
+            unsafe {
+                InlineWaker::block_on(stderr_write(
+                    parent_ctx,
+                    format!("wasm command unknown - {}\r\n", path).as_bytes(),
+                ))
+            }
+            .ok();
+
+            let res = OwnedTaskStatus::new(TaskStatus::Finished(Ok(Errno::Noent.into())));
+            Ok(res.handle())
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/common.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/common.rs
new file mode 100644
index 0000000..eba65bc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/common.rs
@@ -0,0 +1,16 @@
+pub type Pid = u32;
+
+pub fn is_mobile(user_agent: &str) -> bool {
+    user_agent.contains("Android")
+        || user_agent.contains("BlackBerry")
+        || user_agent.contains("iPhone")
+        || user_agent.contains("iPad")
+        || user_agent.contains("iPod")
+        || user_agent.contains("Open Mini")
+        || user_agent.contains("IEMobile")
+        || user_agent.contains("WPDesktop")
+}
+
+pub fn is_ssh(user_agent: &str) -> bool {
+    user_agent.contains("ssh")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/cconst.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/cconst.rs
new file mode 100644
index 0000000..e7ba5f1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/cconst.rs
@@ -0,0 +1,81 @@
+#![allow(dead_code)]
+pub struct ConsoleConst {}
+
+impl ConsoleConst {
+    pub const TERM_KEY_ENTER: u32 = 13;
+    pub const TERM_KEY_BACKSPACE: u32 = 8;
+    pub const TERM_KEY_INSERT: u32 = 45;
+    pub const TERM_KEY_DEL: u32 = 46;
+    pub const TERM_KEY_TAB: u32 = 9;
+    pub const TERM_KEY_HOME: u32 = 36;
+    pub const TERM_KEY_END: u32 = 35;
+    pub const TERM_KEY_PAGE_UP: u32 = 33;
+    pub const TERM_KEY_PAGE_DOWN: u32 = 34;
+    pub const TERM_KEY_LEFT_ARROW: u32 = 37;
+    pub const TERM_KEY_UP_ARROW: u32 = 38;
+    pub const TERM_KEY_RIGHT_ARROW: u32 = 39;
+    pub const TERM_KEY_DOWN_ARROW: u32 = 40;
+    pub const TERM_KEY_C: u32 = 67;
+    pub const TERM_KEY_L: u32 = 76;
+    pub const TERM_KEY_F1: u32 = 112;
+    pub const TERM_KEY_F2: u32 = 113;
+    pub const TERM_KEY_F3: u32 = 114;
+    pub const TERM_KEY_F4: u32 = 115;
+    pub const TERM_KEY_F5: u32 = 116;
+    pub const TERM_KEY_F6: u32 = 117;
+    pub const TERM_KEY_F7: u32 = 118;
+    pub const TERM_KEY_F8: u32 = 119;
+    pub const TERM_KEY_F9: u32 = 120;
+    pub const TERM_KEY_F10: u32 = 121;
+    pub const TERM_KEY_F11: u32 = 122;
+    pub const TERM_KEY_F12: u32 = 123;
+
+    pub const TERM_CURSOR_UP: &'static str = "\x1b[A";
+    pub const TERM_CURSOR_DOWN: &'static str = "\x1b[B";
+    pub const TERM_CURSOR_RIGHT: &'static str = "\x1b[C";
+    pub const TERM_CURSOR_LEFT: &'static str = "\x1b[D";
+
+    pub const TERM_DELETE_LINE: &'static str = "\x1b[2K\r";
+    pub const TERM_DELETE_RIGHT: &'static str = "\x1b[0K\r";
+    pub const TERM_DELETE_LEFT: &'static str = "\x1b[1K\r";
+    pub const TERM_DELETE_BELOW: &'static str = "\x1b[0J\r";
+    pub const TERM_DELETE_ABOVE: &'static str = "\x1b[1J\r";
+    pub const TERM_DELETE_ALL: &'static str = "\x1b[2J\r";
+    pub const TERM_DELETE_SAVED: &'static str = "\x1b[3J\r";
+
+    pub const TERM_CURSOR_SAVE: &'static str = "\x1b[s";
+    pub const TERM_CURSOR_RESTORE: &'static str = "\x1b[u";
+
+    pub const TERM_WRAPAROUND: &'static str = "\x1b[?7h";
+    pub const TERM_REVERSE_WRAPAROUND: &'static str = "\x1b[?45h";
+
+    pub const TERM_NO_WRAPAROUND: &'static str = "\x1b[?7l";
+    pub const TERM_NO_REVERSE_WRAPAROUND: &'static str = "\x1b[?45l";
+
+    pub const COL_RESET: &'static str = "\x1B[0m";
+    pub const COL_BLACK: &'static str = "\x1B[0;30m";
+    pub const COL_GRAY: &'static str = "\x1B[1;30m";
+    pub const COL_RED: &'static str = "\x1B[0;31m";
+    pub const COL_LIGHT_RED: &'static str = "\x1B[1;31m";
+    pub const COL_GREEN: &'static str = "\x1B[0;32m";
+    pub const COL_LIGHT_GREEN: &'static str = "\x1B[1;32m";
+    pub const COL_BROWN: &'static str = "\x1B[0;33m";
+    pub const COL_YELLOW: &'static str = "\x1B[1;33m";
+    pub const COL_BLUE: &'static str = "\x1B[0;34m";
+    pub const COL_LIGHT_BLUE: &'static str = "\x1B[1;34m";
+    pub const COL_PURPLE: &'static str = "\x1B[0;35m";
+    pub const COL_LIGHT_PURPLE: &'static str = "\x1B[1;35m";
+    pub const COL_CYAN: &'static str = "\x1B[0;36m";
+    pub const COL_LIGHT_CYAN: &'static str = "\x1B[1;36m";
+    pub const COL_LIGHT_GRAY: &'static str = "\x1B[0;37m";
+    pub const COL_WHITE: &'static str = "\x1B[1;37m";
+
+    pub const WELCOME_LARGE: &'static str = include_str!("txt/welcome_large.txt");
+    pub const WELCOME_MEDIUM: &'static str = include_str!("txt/welcome_medium.txt");
+    pub const WELCOME_SMALL: &'static str = include_str!("txt/welcome_small.txt");
+
+    pub const ABOUT: &'static str = include_str!("txt/about.md");
+    pub const ABOUT_WASMER: &'static str = include_str!("txt/about_wasmer.md");
+    pub const HELP: &'static str = include_str!("txt/help.md");
+    pub const BAD_WORKER: &'static str = include_str!("txt/bad_worker.md");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/mod.rs
new file mode 100644
index 0000000..a56b89d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/mod.rs
@@ -0,0 +1,408 @@
+#![allow(unused_imports)]
+#![allow(dead_code)]
+
+pub mod cconst;
+
+use std::{
+    borrow::Cow,
+    collections::HashMap,
+    io::Write,
+    ops::{Deref, DerefMut},
+    path::{Path, PathBuf},
+    sync::{atomic::AtomicBool, Arc, Mutex},
+};
+
+use derivative::*;
+use linked_hash_set::LinkedHashSet;
+use tokio::sync::{mpsc, RwLock};
+#[allow(unused_imports, dead_code)]
+use tracing::{debug, error, info, trace, warn};
+use virtual_fs::{
+    ArcBoxFile, ArcFile, AsyncWriteExt, CombineFile, DeviceFile, DuplexPipe, FileSystem, Pipe,
+    PipeRx, PipeTx, RootFileSystemBuilder, StaticFile, VirtualFile,
+};
+#[cfg(feature = "sys")]
+use wasmer::Engine;
+use wasmer_wasix_types::{types::__WASI_STDIN_FILENO, wasi::Errno};
+
+use super::{cconst::ConsoleConst, common::*, task::TaskJoinHandle};
+use crate::{
+    bin_factory::{spawn_exec, BinFactory, BinaryPackage},
+    capabilities::Capabilities,
+    os::task::{control_plane::WasiControlPlane, process::WasiProcess},
+    runtime::{resolver::PackageSpecifier, task_manager::InlineWaker},
+    Runtime, SpawnError, WasiEnv, WasiEnvBuilder, WasiRuntimeError,
+};
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct Console {
+    user_agent: Option<String>,
+    boot_cmd: String,
+    uses: LinkedHashSet<String>,
+    is_mobile: bool,
+    is_ssh: bool,
+    whitelabel: bool,
+    token: Option<String>,
+    no_welcome: bool,
+    prompt: String,
+    env: HashMap<String, String>,
+    runtime: Arc<dyn Runtime + Send + Sync>,
+    stdin: ArcBoxFile,
+    stdout: ArcBoxFile,
+    stderr: ArcBoxFile,
+    capabilities: Capabilities,
+    ro_files: HashMap<String, Cow<'static, [u8]>>,
+    memfs_memory_limiter: Option<virtual_fs::limiter::DynFsMemoryLimiter>,
+}
+
+impl Console {
+    pub fn new(webc_boot_package: &str, runtime: Arc<dyn Runtime + Send + Sync + 'static>) -> Self {
+        Self {
+            boot_cmd: webc_boot_package.to_string(),
+            uses: LinkedHashSet::new(),
+            is_mobile: false,
+            is_ssh: false,
+            user_agent: None,
+            whitelabel: false,
+            token: None,
+            no_welcome: false,
+            env: HashMap::new(),
+            runtime,
+            prompt: "wasmer.sh".to_string(),
+            stdin: ArcBoxFile::new(Box::new(Pipe::channel().0)),
+            stdout: ArcBoxFile::new(Box::new(Pipe::channel().0)),
+            stderr: ArcBoxFile::new(Box::new(Pipe::channel().0)),
+            capabilities: Default::default(),
+            memfs_memory_limiter: None,
+            ro_files: Default::default(),
+        }
+    }
+
+    pub fn with_prompt(mut self, prompt: String) -> Self {
+        self.prompt = prompt;
+        self
+    }
+
+    pub fn with_boot_cmd(mut self, cmd: String) -> Self {
+        let prog = cmd.split_once(' ').map(|a| a.0).unwrap_or(cmd.as_str());
+        self.uses.insert(prog.to_string());
+        self.boot_cmd = cmd;
+        self
+    }
+
+    pub fn with_uses(mut self, uses: Vec<String>) -> Self {
+        self.uses = uses.into_iter().collect();
+        self
+    }
+
+    pub fn with_env(mut self, env: HashMap<String, String>) -> Self {
+        self.env = env;
+        self
+    }
+
+    pub fn with_user_agent(mut self, user_agent: &str) -> Self {
+        self.is_mobile = is_mobile(user_agent);
+        self.is_ssh = is_ssh(user_agent);
+        self.user_agent = Some(user_agent.to_string());
+        self
+    }
+
+    pub fn with_no_welcome(mut self, no_welcome: bool) -> Self {
+        self.no_welcome = no_welcome;
+        self
+    }
+
+    pub fn with_token(mut self, token: String) -> Self {
+        self.token = Some(token);
+        self
+    }
+
+    pub fn with_capabilities(mut self, caps: Capabilities) -> Self {
+        self.capabilities = caps;
+        self
+    }
+
+    pub fn with_stdin(mut self, stdin: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.stdin = ArcBoxFile::new(stdin);
+        self
+    }
+
+    pub fn with_stdout(mut self, stdout: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.stdout = ArcBoxFile::new(stdout);
+        self
+    }
+
+    pub fn with_stderr(mut self, stderr: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.stderr = ArcBoxFile::new(stderr);
+        self
+    }
+
+    pub fn with_ro_files(mut self, ro_files: HashMap<String, Cow<'static, [u8]>>) -> Self {
+        self.ro_files = ro_files;
+        self
+    }
+
+    pub fn with_mem_fs_memory_limiter(
+        mut self,
+        limiter: virtual_fs::limiter::DynFsMemoryLimiter,
+    ) -> Self {
+        self.memfs_memory_limiter = Some(limiter);
+        self
+    }
+
+    pub fn run(&mut self) -> Result<(TaskJoinHandle, WasiProcess), SpawnError> {
+        // Extract the program name from the arguments
+        let empty_args: Vec<&str> = Vec::new();
+        let (webc, prog, args) = match self.boot_cmd.split_once(' ') {
+            Some((webc, args)) => (
+                webc,
+                webc.split_once('/').map(|a| a.1).unwrap_or(webc),
+                args.split(' ').collect::<Vec<_>>(),
+            ),
+            None => (
+                self.boot_cmd.as_str(),
+                self.boot_cmd
+                    .split_once('/')
+                    .map(|a| a.1)
+                    .unwrap_or(self.boot_cmd.as_str()),
+                empty_args,
+            ),
+        };
+
+        let webc_ident: PackageSpecifier = match webc.parse() {
+            Ok(ident) => ident,
+            Err(e) => {
+                tracing::debug!(webc, error = &*e, "Unable to parse the WEBC identifier");
+                return Err(SpawnError::BadRequest);
+            }
+        };
+
+        let resolved_package = InlineWaker::block_on(BinaryPackage::from_registry(
+            &webc_ident,
+            self.runtime.as_ref(),
+        ));
+
+        let pkg = match resolved_package {
+            Ok(pkg) => pkg,
+            Err(e) => {
+                let mut stderr = self.stderr.clone();
+                InlineWaker::block_on(async {
+                    let mut buffer = Vec::new();
+                    writeln!(buffer, "Error: {e}").ok();
+                    let mut source = e.source();
+                    while let Some(s) = source {
+                        writeln!(buffer, "  Caused by: {s}").ok();
+                        source = s.source();
+                    }
+
+                    virtual_fs::AsyncWriteExt::write_all(&mut stderr, &buffer)
+                        .await
+                        .ok();
+                });
+                tracing::debug!("failed to get webc dependency - {}", webc);
+                return Err(SpawnError::NotFound);
+            }
+        };
+
+        let wasi_opts = webc::metadata::annotations::Wasi::new(prog);
+
+        let root_fs = RootFileSystemBuilder::new()
+            .with_tty(Box::new(CombineFile::new(
+                Box::new(self.stdout.clone()),
+                Box::new(self.stdin.clone()),
+            )))
+            .build();
+
+        if let Some(limiter) = &self.memfs_memory_limiter {
+            root_fs.set_memory_limiter(limiter.clone());
+        }
+
+        let builder = crate::runners::wasi::WasiRunner::new()
+            .with_envs(self.env.clone().into_iter())
+            .with_args(args)
+            .with_capabilities(self.capabilities.clone())
+            .with_stdin(Box::new(self.stdin.clone()))
+            .with_stdout(Box::new(self.stdout.clone()))
+            .with_stderr(Box::new(self.stderr.clone()))
+            .prepare_webc_env(
+                prog,
+                &wasi_opts,
+                Some(&pkg),
+                self.runtime.clone(),
+                Some(root_fs),
+            )
+            // TODO: better error conversion
+            .map_err(|err| SpawnError::Other(err.into()))?;
+
+        let env = builder.build()?;
+
+        // Display the welcome message
+        if !self.whitelabel && !self.no_welcome {
+            InlineWaker::block_on(self.draw_welcome());
+        }
+
+        let wasi_process = env.process.clone();
+
+        if let Err(err) = env.uses(self.uses.clone()) {
+            let mut stderr = self.stderr.clone();
+            InlineWaker::block_on(async {
+                virtual_fs::AsyncWriteExt::write_all(
+                    &mut stderr,
+                    format!("{}\r\n", err).as_bytes(),
+                )
+                .await
+                .ok();
+            });
+            tracing::debug!("failed to load used dependency - {}", err);
+            return Err(SpawnError::BadRequest);
+        }
+
+        // The custom readonly files have to be added after the uses packages
+        // otherwise they will be overriden by their attached file systems
+        for (path, data) in self.ro_files.clone() {
+            let path = PathBuf::from(path);
+            env.fs_root().remove_file(&path).ok();
+            let mut file = env
+                .fs_root()
+                .new_open_options()
+                .create(true)
+                .truncate(true)
+                .write(true)
+                .open(&path)
+                .map_err(|err| SpawnError::Other(err.into()))?;
+            InlineWaker::block_on(file.copy_reference(Box::new(StaticFile::new(data))))
+                .map_err(|err| SpawnError::Other(err.into()))?;
+        }
+
+        // Build the config
+        // Run the binary
+        let store = self.runtime.new_store();
+        let process = InlineWaker::block_on(spawn_exec(pkg, prog, store, env, &self.runtime))?;
+
+        // Return the process
+        Ok((process, wasi_process))
+    }
+
+    pub async fn draw_welcome(&self) {
+        let welcome = match (self.is_mobile, self.is_ssh) {
+            (true, _) => ConsoleConst::WELCOME_MEDIUM,
+            (_, true) => ConsoleConst::WELCOME_SMALL,
+            (_, _) => ConsoleConst::WELCOME_LARGE,
+        };
+        let mut data = welcome
+            .replace("\\x1B", "\x1B")
+            .replace("\\r", "\r")
+            .replace("\\n", "\n");
+        data.insert_str(0, ConsoleConst::TERM_NO_WRAPAROUND);
+
+        let mut stderr = self.stderr.clone();
+        virtual_fs::AsyncWriteExt::write_all(&mut stderr, data.as_str().as_bytes())
+            .await
+            .ok();
+    }
+}
+
+#[cfg(all(test, not(target_family = "wasm")))]
+mod tests {
+    use virtual_fs::{AsyncSeekExt, BufferFile, Pipe};
+
+    use super::*;
+
+    use std::{io::Read, sync::Arc};
+
+    use crate::{
+        runtime::{package_loader::BuiltinPackageLoader, task_manager::tokio::TokioTaskManager},
+        PluggableRuntime,
+    };
+
+    /// Test that [`Console`] correctly runs a command with arguments and
+    /// specified env vars, and that the TTY correctly handles stdout output.
+    ///
+    /// Note that this test currently aborts the process unconditionally due
+    /// to a misaligned pointer access in stack_checkpoint() triggering a panic
+    /// in a function that isn't allowed to unwind.
+    ///
+    /// See [#4284](https://github.com/wasmerio/wasmer/issues/4284) for more.
+    #[test]
+    #[cfg_attr(not(feature = "host-reqwest"), ignore = "Requires a HTTP client")]
+    #[ignore = "Unconditionally aborts (CC #4284)"]
+    fn test_console_dash_tty_with_args_and_env() {
+        let tokio_rt = tokio::runtime::Runtime::new().unwrap();
+        let rt_handle = tokio_rt.handle().clone();
+        let _guard = rt_handle.enter();
+
+        let tm = TokioTaskManager::new(tokio_rt);
+        let mut rt = PluggableRuntime::new(Arc::new(tm));
+        let client = rt.http_client().unwrap().clone();
+        rt.set_engine(Some(wasmer::Engine::default()))
+            .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
+
+        let env: HashMap<String, String> = [("MYENV1".to_string(), "VAL1".to_string())]
+            .into_iter()
+            .collect();
+
+        // Pass some arguments.
+        let cmd = "sharrattj/dash -s stdin";
+
+        let (mut stdin_tx, stdin_rx) = Pipe::channel();
+        let (stdout_tx, mut stdout_rx) = Pipe::channel();
+
+        let (mut handle, _proc) = Console::new(cmd, Arc::new(rt))
+            .with_env(env)
+            .with_stdin(Box::new(stdin_rx))
+            .with_stdout(Box::new(stdout_tx))
+            .run()
+            .unwrap();
+
+        let code = rt_handle
+            .block_on(async move {
+                virtual_fs::AsyncWriteExt::write_all(
+                    &mut stdin_tx,
+                    b"echo hello $MYENV1 > /dev/tty; exit\n",
+                )
+                .await?;
+
+                stdin_tx.close();
+                std::mem::drop(stdin_tx);
+
+                let res = handle.wait_finished().await?;
+                Ok::<_, anyhow::Error>(res)
+            })
+            .unwrap();
+
+        assert_eq!(code.raw(), 78);
+
+        let mut out = String::new();
+        stdout_rx.read_to_string(&mut out).unwrap();
+
+        assert_eq!(out, "hello VAL1\n");
+    }
+
+    /// Regression test to ensure merging of multiple packages works correctly.
+    #[test]
+    fn test_console_python_merge() {
+        let tokio_rt = tokio::runtime::Runtime::new().unwrap();
+        let rt_handle = tokio_rt.handle().clone();
+        let _guard = rt_handle.enter();
+
+        let tm = TokioTaskManager::new(tokio_rt);
+        let mut rt = PluggableRuntime::new(Arc::new(tm));
+        let client = rt.http_client().unwrap().clone();
+        rt.set_engine(Some(wasmer::Engine::default()))
+            .set_package_loader(BuiltinPackageLoader::new().with_shared_http_client(client));
+
+        let cmd = "wasmer-tests/python-env-dump --help";
+
+        let (mut handle, _proc) = Console::new(cmd, Arc::new(rt)).run().unwrap();
+
+        let code = rt_handle
+            .block_on(async move {
+                let res = handle.wait_finished().await?;
+                Ok::<_, anyhow::Error>(res)
+            })
+            .unwrap();
+
+        assert_eq!(code.raw(), 0);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about.md
new file mode 100644
index 0000000..113b3c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about.md
@@ -0,0 +1,8 @@
+# Wasmer Terminal
+
+This terminal is an Wasmer powered terminal hosted in a browser which implements
+a basic operating system and is natively integrated with ATE and Wasmer.
+
+For more information try:
+
+about wasmer
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about_wasmer.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about_wasmer.md
new file mode 100644
index 0000000..8d09228
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/about_wasmer.md
@@ -0,0 +1,14 @@
+# Wasmer
+
+Wasmer is a fast and secure WebAssembly runtime that enables super
+lightweight containers to run anywhere: from Desktop to the Cloud, Edge and
+IoT devices.
+
+Features:
+• Secure by default. No file, network, or environment access, unless
+  explicitly enabled.
+• Supports WASI and Emscripten out of the box.
+• Fast. Run WebAssembly at near-native speeds.
+• Embeddable in multiple programming languages
+• Compliant with latest WebAssembly Proposals (SIMD, Reference Types,
+  Threads, ...)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/bad_worker.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/bad_worker.md
new file mode 100644
index 0000000..589c5ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/bad_worker.md
@@ -0,0 +1,19 @@
+
+\x1B[1;31mBackground worker threads failed - {error}\x1B[30;1m
+
+It would appear that your browser does not support background worker threads
+which means that https://wasmer.sh will not be able to launch processes and
+effectively becomes very limited.\x1B[37;1m
+
+List supported major browsers:
+
+- Chrome for Desktop - \x1B[30;1mversion 68 and above\x1B[37;1m
+- Chrome for Android - \x1B[30;1mversion 96 and above\x1B[37;1m
+- Firefox for Desktop - \x1B[30;1mversion 79 and above\x1B[37;1m
+- Firefox for Android - \x1B[30;1mversion 92 and above\x1B[37;1m
+- Edge - \x1B[30;1mversion 79 and above\x1B[30;1m
+
+The full list is provided here:
+https://caniuse.com/sharedarraybuffer\x1B[37;1m
+
+Please install and/or upgrade your browser to continue
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/help.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/help.md
new file mode 100644
index 0000000..a16e21d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/help.md
@@ -0,0 +1,25 @@
+# wasmer.sh
+
+## The Shell
+
+The Wasmer WASM shell is an browser based operating system that integrates
+with the WebAssembly community to assembly and build micro-applications.
+
+Including:
+- MemFS file system with mount points
+- stdin, stdout, stderr and tty support
+- Private file system space per process.
+- Full support for piping and TTY.
+- Fully multi-threaded.
+- Support for basic bash commands.
+
+## coreutil commands:
+
+    arch, base32, base64, basename, cat, cksum, comm, cp, csplit, cut,
+    date, dircolors, dirname, echo, env, expand, factor, false, fmt, fold,
+    hashsum, head, join, link, ln, ls, md5sum, mkdir, mktemp, mv, nl, nproc,
+    numfmt, od, paste, printenv, printf, ptx, pwd, readlink, realpath,
+    relpath, rm, rmdir, seq, sha1sum, sha224sum, sha256sum, sha3-224sum,
+    sha3-256sum, sha3-384sum, sha3-512sum, sha384sum, sha3sum, sha512sum,
+    shake128sum, shake256sum, shred, shuf, sleep, sum, tee, touch, tr, true,
+    truncate, tsort, unexpand, uniq, unlink, wc, yes
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_large.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_large.txt
new file mode 100644
index 0000000..2c32f50
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_large.txt
@@ -0,0 +1,10 @@
+\x1B[1;34m██╗    ██╗ █████╗ ███████╗███╗   ███╗███████╗██████╗    ███████╗██╗  ██╗
+██║    ██║██╔══██╗██╔════╝████╗ ████║██╔════╝██╔══██╗   ██╔════╝██║  ██║
+██║ █╗ ██║███████║███████╗██╔████╔██║█████╗  ██████╔╝   ███████╗███████║
+██║███╗██║██╔══██║╚════██║██║╚██╔╝██║██╔══╝  ██╔══██╗   ╚════██║██╔══██║
+╚███╔███╔╝██║  ██║███████║██║ ╚═╝ ██║███████╗██║  ██║██╗███████║██║  ██║
+ ╚══╝╚══╝ ╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═╝\x1B[37;1m\r
+ QUICK START:                         MORE INFO:\x1B[1;30m\r
+• Wasmer commands:  wasmer            • Usage Information: help\r
+• Core utils:       coreutils         • About Wasmer: about wasmer\r
+• Pipe: echo blah | cat\x1B[37;0m\r\r\n
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_medium.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_medium.txt
new file mode 100644
index 0000000..ebfde1a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_medium.txt
@@ -0,0 +1,7 @@
+\x1B[1;34m██╗    ██╗ █████╗ ███████╗███╗   ███╗███████╗██████╗ \r
+██║    ██║██╔══██╗██╔════╝████╗ ████║██╔════╝██╔══██╗\r
+██║ █╗ ██║███████║███████╗██╔████╔██║█████╗  ██████╔╝\r
+██║███╗██║██╔══██║╚════██║██║╚██╔╝██║██╔══╝  ██╔══██╗\r
+╚███╔███╔╝██║  ██║███████║██║ ╚═╝ ██║███████╗██║  ██║\r
+ ╚══╝╚══╝ ╚═╝  ╚═╝╚══════╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝\x1B[37;1m\r
+ Type 'help' for commands.\x1B[37;0m\r\r\n
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_small.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_small.txt
new file mode 100644
index 0000000..181669a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/console/txt/welcome_small.txt
@@ -0,0 +1,4 @@
+\x1B[1;34m _ _ _ _____  ___ ____  _____  ____ \r
+| | | (____ |/___|    \| ___ |/ ___)\r
+| | | / ___ |___ | | | | ____| |    \r
+ \___/\_____(___/|_|_|_|_____|_|    \x1B[37;0m\r\r\n
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/mod.rs
new file mode 100644
index 0000000..9e25c09
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/mod.rs
@@ -0,0 +1,9 @@
+pub mod common;
+mod console;
+pub mod tty;
+
+pub mod command;
+pub mod task;
+
+pub use console::*;
+pub use tty::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/posix_err.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/posix_err.rs
new file mode 100644
index 0000000..22febb0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/posix_err.rs
@@ -0,0 +1,262 @@
+pub const ERR_OK: u32 = 0;
+pub const ERR_EPERM: u32 = 1; /* Operation not permitted */
+pub const ERR_ENOENT: u32 = 2;
+pub const ERR_ESRCH: u32 = 3; /* No such process */
+pub const ERR_EINTR: u32 = 4; /* Interrupted system call */
+pub const ERR_EIO: u32 = 5; /* I/O error */
+pub const ERR_ENXIO: u32 = 6; /* No such device or address */
+pub const ERR_E2BIG: u32 = 7; /* Arg list too long */
+pub const ERR_ENOEXEC: u32 = 8; /* Exec format error */
+pub const ERR_EBADF: u32 = 9; /* Bad file number */
+pub const ERR_ECHILD: u32 = 10; /* No child processes */
+pub const ERR_EAGAIN: u32 = 11; /* Try again */
+pub const ERR_ENOMEM: u32 = 12; /* Out of memory */
+pub const ERR_EACCES: u32 = 13; /* Permission denied */
+pub const ERR_EFAULT: u32 = 14; /* Bad address */
+pub const ERR_ENOTBLK: u32 = 15; /* Block device required */
+pub const ERR_EBUSY: u32 = 16; /* Device or resource busy */
+pub const ERR_EEXIST: u32 = 17; /* File exists */
+pub const ERR_EXDEV: u32 = 18; /* Cross-device link */
+pub const ERR_ENODEV: u32 = 19; /* No such device */
+pub const ERR_ENOTDIR: u32 = 20; /* Not a directory */
+pub const ERR_EISDIR: u32 = 21; /* Is a directory */
+pub const ERR_EINVAL: u32 = 22; /* Invalid argument */
+pub const ERR_ENFILE: u32 = 23; /* File table overflow */
+pub const ERR_EMFILE: u32 = 24; /* Too many open files */
+pub const ERR_ENOTTY: u32 = 25; /* Not a typewriter */
+pub const ERR_ETXTBSY: u32 = 26; /* Text file busy */
+pub const ERR_EFBIG: u32 = 27; /* File too large */
+pub const ERR_ENOSPC: u32 = 28; /* No space left on device */
+pub const ERR_ESPIPE: u32 = 29; /* Illegal seek */
+pub const ERR_EROFS: u32 = 30; /* Read-only file system */
+pub const ERR_EMLINK: u32 = 31; /* Too many links */
+pub const ERR_EPIPE: u32 = 32; /* Broken pipe */
+pub const ERR_EDOM: u32 = 33; /* Math argument out of domain of func */
+pub const ERR_ERANGE: u32 = 34; /* Math result not representable */
+pub const ERR_EDEADLK: u32 = 35; /* Resource deadlock would occur */
+pub const ERR_ENAMETOOLONG: u32 = 36; /* File name too long */
+pub const ERR_ENOLCK: u32 = 37; /* No record locks available */
+pub const ERR_ENOSYS: u32 = 38; /* Function not implemented */
+pub const ERR_ENOTEMPTY: u32 = 39; /* Directory not empty */
+pub const ERR_ELOOP: u32 = 40; /* Too many symbolic links encountered */
+pub const ERR_EWOULDBLOCK: u32 = ERR_EAGAIN; /* Operation would block */
+pub const ERR_ENOMSG: u32 = 42; /* No message of desired type */
+pub const ERR_EIDRM: u32 = 43; /* Identifier removed */
+pub const ERR_ECHRNG: u32 = 44; /* Channel number out of range */
+pub const ERR_EL2NSYNC: u32 = 45; /* Level 2 not synchronized */
+pub const ERR_EL3HLT: u32 = 46; /* Level 3 halted */
+pub const ERR_EL3RST: u32 = 47; /* Level 3 reset */
+pub const ERR_ELNRNG: u32 = 48; /* Link number out of range */
+pub const ERR_EUNATCH: u32 = 49; /* Protocol driver not attached */
+pub const ERR_ENOCSI: u32 = 50; /* No CSI structure available */
+pub const ERR_EL2HLT: u32 = 51; /* Level 2 halted */
+pub const ERR_EBADE: u32 = 52; /* Invalid exchange */
+pub const ERR_EBADR: u32 = 53; /* Invalid request descriptor */
+pub const ERR_EXFULL: u32 = 54; /* Exchange full */
+pub const ERR_ENOANO: u32 = 55; /* No anode */
+pub const ERR_EBADRQC: u32 = 56; /* Invalid request code */
+pub const ERR_EBADSLT: u32 = 57; /* Invalid slot */
+
+pub const ERR_EDEADLOCK: u32 = ERR_EDEADLK;
+
+pub const ERR_EBFONT: u32 = 59; /* Bad font file format */
+pub const ERR_ENOSTR: u32 = 60; /* Device not a stream */
+pub const ERR_ENODATA: u32 = 61; /* No data available */
+pub const ERR_ETIME: u32 = 62; /* Timer expired */
+pub const ERR_ENOSR: u32 = 63; /* Out of streams resources */
+pub const ERR_ENONET: u32 = 64; /* Machine is not on the network */
+pub const ERR_ENOPKG: u32 = 65; /* Package not installed */
+pub const ERR_EREMOTE: u32 = 66; /* Object is remote */
+pub const ERR_ENOLINK: u32 = 67; /* Link has been severed */
+pub const ERR_EADV: u32 = 68; /* Advertise error */
+pub const ERR_ESRMNT: u32 = 69; /* Srmount error */
+pub const ERR_ECOMM: u32 = 70; /* Communication error on send */
+pub const ERR_EPROTO: u32 = 71; /* Protocol error */
+pub const ERR_EMULTIHOP: u32 = 72; /* Multihop attempted */
+pub const ERR_EDOTDOT: u32 = 73; /* RFS specific error */
+pub const ERR_EBADMSG: u32 = 74; /* Not a data message */
+pub const ERR_EOVERFLOW: u32 = 75; /* Value too large for defined data type */
+pub const ERR_ENOTUNIQ: u32 = 76; /* Name not unique on network */
+pub const ERR_EBADFD: u32 = 77; /* File descriptor in bad state */
+pub const ERR_EREMCHG: u32 = 78; /* Remote address changed */
+pub const ERR_ELIBACC: u32 = 79; /* Can not access a needed shared library */
+pub const ERR_ELIBBAD: u32 = 80; /* Accessing a corrupted shared library */
+pub const ERR_ELIBSCN: u32 = 81; /* .lib section in a.out corrupted */
+pub const ERR_ELIBMAX: u32 = 82; /* Attempting to link in too many shared libraries */
+pub const ERR_ELIBEXEC: u32 = 83; /* Cannot exec a shared library directly */
+pub const ERR_EILSEQ: u32 = 84; /* Illegal byte sequence */
+pub const ERR_ERESTART: u32 = 85; /* Interrupted system call should be restarted */
+pub const ERR_ESTRPIPE: u32 = 86; /* Streams pipe error */
+pub const ERR_EUSERS: u32 = 87; /* Too many users */
+pub const ERR_ENOTSOCK: u32 = 88; /* Socket operation on non-socket */
+pub const ERR_EDESTADDRREQ: u32 = 89; /* Destination address required */
+pub const ERR_EMSGSIZE: u32 = 90; /* Message too long */
+pub const ERR_EPROTOTYPE: u32 = 91; /* Protocol wrong type for socket */
+pub const ERR_ENOPROTOOPT: u32 = 92; /* Protocol not available */
+pub const ERR_EPROTONOSUPPORT: u32 = 93; /* Protocol not supported */
+pub const ERR_ESOCKTNOSUPPORT: u32 = 94; /* Socket type not supported */
+pub const ERR_EOPNOTSUPP: u32 = 95; /* Operation not supported on transport endpoint */
+pub const ERR_EPFNOSUPPORT: u32 = 96; /* Protocol family not supported */
+pub const ERR_EAFNOSUPPORT: u32 = 97; /* Address family not supported by protocol */
+pub const ERR_EADDRINUSE: u32 = 98; /* Address already in use */
+pub const ERR_EADDRNOTAVAIL: u32 = 99; /* Cannot assign requested address */
+pub const ERR_ENETDOWN: u32 = 100; /* Network is down */
+pub const ERR_ENETUNREACH: u32 = 101; /* Network is unreachable */
+pub const ERR_ENETRESET: u32 = 102; /* Network dropped connection because of reset */
+pub const ERR_ECONNABORTED: u32 = 103; /* Software caused connection abort */
+pub const ERR_ECONNRESET: u32 = 104; /* Connection reset by peer */
+pub const ERR_ENOBUFS: u32 = 105; /* No buffer space available */
+pub const ERR_EISCONN: u32 = 106; /* Transport endpoint is already connected */
+pub const ERR_ENOTCONN: u32 = 107; /* Transport endpoint is not connected */
+pub const ERR_ESHUTDOWN: u32 = 108; /* Cannot send after transport endpoint shutdown */
+pub const ERR_ETOOMANYREFS: u32 = 109; /* Too many references: cannot splice */
+pub const ERR_ETIMEDOUT: u32 = 110; /* Connection timed out */
+pub const ERR_ECONNREFUSED: u32 = 111; /* Connection refused */
+pub const ERR_EHOSTDOWN: u32 = 112; /* Host is down */
+pub const ERR_EHOSTUNREACH: u32 = 113; /* No route to host */
+pub const ERR_EALREADY: u32 = 114; /* Operation already in progress */
+pub const ERR_EINPROGRESS: u32 = 115; /* Operation now in progress */
+pub const ERR_ESTALE: u32 = 116; /* Stale NFS file handle */
+pub const ERR_EUCLEAN: u32 = 117; /* Structure needs cleaning */
+pub const ERR_ENOTNAM: u32 = 118; /* Not a XENIX named type file */
+pub const ERR_ENAVAIL: u32 = 119; /* No XENIX semaphores available */
+pub const ERR_EISNAM: u32 = 120; /* Is a named type file */
+pub const ERR_EREMOTEIO: u32 = 121; /* Remote I/O error */
+pub const ERR_EDQUOT: u32 = 122; /* Quota exceeded */
+
+pub const ERR_ENOMEDIUM: u32 = 123; /* No medium found */
+pub const ERR_EMEDIUMTYPE: u32 = 124; /* Wrong medium type */
+
+pub const ERR_TERMINATED: u32 = 130; /* Process was terminated */
+pub const ERR_PANIC: u32 = 99999; /* Process has panicked */
+
+pub fn exit_code_to_message(code: u32) -> &'static str {
+    match code {
+        ERR_OK => "Ok",
+        ERR_EPERM => "Operation not permitted",
+        ERR_ENOENT => "No such file or directory",
+        ERR_ESRCH => "No such process",
+        ERR_EINTR => "Interrupted system call",
+        ERR_EIO => "I/O error",
+        ERR_ENXIO => "No such device or address",
+        ERR_E2BIG => "Arg list too long",
+        ERR_ENOEXEC => "Exec format error",
+        ERR_EBADF => "Bad file number",
+        ERR_ECHILD => "No child processes",
+        ERR_EAGAIN => "Try again",
+        ERR_ENOMEM => "Out of memory",
+        ERR_EACCES => "Permission denied",
+        ERR_EFAULT => "Bad address",
+        ERR_ENOTBLK => "Block device required",
+        ERR_EBUSY => "Device or resource busy",
+        ERR_EEXIST => "File exists",
+        ERR_EXDEV => "Cross-device link",
+        ERR_ENODEV => "No such device",
+        ERR_ENOTDIR => "Not a directory",
+        ERR_EISDIR => "Is a directory",
+        ERR_EINVAL => "Invalid argument",
+        ERR_ENFILE => "File table overflow",
+        ERR_EMFILE => "Too many open files",
+        ERR_ENOTTY => "Not a typewriter",
+        ERR_ETXTBSY => "Text file busy",
+        ERR_EFBIG => "File too large",
+        ERR_ENOSPC => "No space left on device",
+        ERR_ESPIPE => "Illegal seek",
+        ERR_EROFS => "Read-only file system",
+        ERR_EMLINK => "Too many links",
+        ERR_EPIPE => "Broken pipe",
+        ERR_EDOM => "Math argument out of domain of func",
+        ERR_ERANGE => "Math result not representable",
+        ERR_EDEADLK => "Resource deadlock would occur",
+        ERR_ENAMETOOLONG => "File name too long",
+        ERR_ENOLCK => "No record locks available",
+        ERR_ENOSYS => "Function not implemented",
+        ERR_ENOTEMPTY => "Directory not empty",
+        ERR_ELOOP => "Too many symbolic links encountered",
+        ERR_ENOMSG => "No message of desired type",
+        ERR_EIDRM => "Identifier removed",
+        ERR_ECHRNG => "Channel number out of range",
+        ERR_EL2NSYNC => "Level 2 not synchronized",
+        ERR_EL3HLT => "Level 3 halted",
+        ERR_EL3RST => "Level 3 reset",
+        ERR_ELNRNG => "Link number out of range",
+        ERR_EUNATCH => "Protocol driver not attached",
+        ERR_ENOCSI => "No CSI structure available",
+        ERR_EL2HLT => "Level 2 halted",
+        ERR_EBADE => "Invalid exchange",
+        ERR_EBADR => "Invalid request descriptor",
+        ERR_EXFULL => "Exchange full",
+        ERR_ENOANO => "No anode",
+        ERR_EBADRQC => "Invalid request code",
+        ERR_EBADSLT => "Invalid slot",
+        ERR_EBFONT => "Bad font file format",
+        ERR_ENOSTR => "Device not a stream",
+        ERR_ENODATA => "No data available",
+        ERR_ETIME => "Timer expired",
+        ERR_ENOSR => "Out of streams resources",
+        ERR_ENONET => "Machine is not on the network",
+        ERR_ENOPKG => "Package not installed",
+        ERR_EREMOTE => "Object is remote",
+        ERR_ENOLINK => "Link has been severed",
+        ERR_EADV => "Advertise error",
+        ERR_ESRMNT => "Srmount error",
+        ERR_ECOMM => "Communication error on send",
+        ERR_EPROTO => "Protocol error",
+        ERR_EMULTIHOP => "Multihop attempted",
+        ERR_EDOTDOT => "RFS specific error",
+        ERR_EBADMSG => "Not a data message",
+        ERR_EOVERFLOW => "Value too large for defined data type",
+        ERR_ENOTUNIQ => "Name not unique on network",
+        ERR_EBADFD => "File descriptor in bad state",
+        ERR_EREMCHG => "Remote address changed",
+        ERR_ELIBACC => "Can not access a needed shared library",
+        ERR_ELIBBAD => "Accessing a corrupted shared library",
+        ERR_ELIBSCN => ".lib section in a.out corrupted",
+        ERR_ELIBMAX => "Attempting to link in too many shared libraries",
+        ERR_ELIBEXEC => "Cannot exec a shared library directly",
+        ERR_EILSEQ => "Illegal byte sequence",
+        ERR_ERESTART => "Interrupted system call should be restarted",
+        ERR_ESTRPIPE => "Streams pipe error",
+        ERR_EUSERS => "Too many users",
+        ERR_ENOTSOCK => "Socket operation on non-socket",
+        ERR_EDESTADDRREQ => "Destination address required",
+        ERR_EMSGSIZE => "Message too long",
+        ERR_EPROTOTYPE => "Protocol wrong type for socket",
+        ERR_ENOPROTOOPT => "Protocol not available",
+        ERR_EPROTONOSUPPORT => "Protocol not supported",
+        ERR_ESOCKTNOSUPPORT => "Socket type not supported",
+        ERR_EOPNOTSUPP => "Operation not supported on transport endpoint",
+        ERR_EPFNOSUPPORT => "Protocol family not supported",
+        ERR_EAFNOSUPPORT => "Address family not supported by protocol",
+        ERR_EADDRINUSE => "Address already in use",
+        ERR_EADDRNOTAVAIL => "Cannot assign requested address",
+        ERR_ENETDOWN => "Network is down",
+        ERR_ENETUNREACH => "Network is unreachable",
+        ERR_ENETRESET => "Network dropped connection because of reset",
+        ERR_ECONNABORTED => "Software caused connection abort",
+        ERR_ECONNRESET => "Connection reset by peer",
+        ERR_ENOBUFS => "No buffer space available",
+        ERR_EISCONN => "Transport endpoint is already connected",
+        ERR_ENOTCONN => "Transport endpoint is not connected",
+        ERR_ESHUTDOWN => "Cannot send after transport endpoint shutdown",
+        ERR_ETOOMANYREFS => "Too many references: cannot splice",
+        ERR_ETIMEDOUT => "Connection timed out",
+        ERR_ECONNREFUSED => "Connection refused",
+        ERR_EHOSTDOWN => "Host is down",
+        ERR_EHOSTUNREACH => "No route to host",
+        ERR_EALREADY => "Operation already in progress",
+        ERR_EINPROGRESS => "Operation now in progress",
+        ERR_ESTALE => "Stale NFS file handle",
+        ERR_EUCLEAN => "Structure needs cleaning",
+        ERR_ENOTNAM => "Not a XENIX named type file",
+        ERR_ENAVAIL => "No XENIX semaphores available",
+        ERR_EISNAM => "Is a named type file",
+        ERR_EREMOTEIO => "Remote I/O error",
+        ERR_EDQUOT => "Quota exceeded",
+        ERR_ENOMEDIUM => "No medium found",
+        ERR_EMEDIUMTYPE => "Wrong medium type",
+        ERR_PANIC => "Process has panicked",
+        ERR_TERMINATED => "Process was terminated",
+        _ => "Unknown error",
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/backoff.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/backoff.rs
new file mode 100644
index 0000000..b5dc12b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/backoff.rs
@@ -0,0 +1,199 @@
+use std::{
+    collections::HashMap,
+    pin::Pin,
+    sync::{
+        atomic::{AtomicU32, Ordering},
+        Arc,
+    },
+    task::{Context, Poll, Waker},
+    time::Duration,
+};
+
+use futures::{Future, FutureExt};
+use wasmer_wasix_types::wasi::Snapshot0Clockid;
+
+use crate::{syscalls::platform_clock_time_get, VirtualTaskManager, WasiProcess};
+
+use super::process::LockableWasiProcessInner;
+
+/// Represents the CPU backoff properties for a process
+/// which will be used to determine if the CPU should be
+/// throttled or not
+#[derive(Debug)]
+pub struct WasiProcessCpuBackoff {
+    /// Referenced list of wakers that will be triggered
+    /// when the process goes active again due to a token
+    /// being acquired
+    cpu_backoff_wakers: HashMap<u64, Waker>,
+    /// Seed used to register CPU release wakers
+    cpu_backoff_waker_seed: u64,
+    /// The amount of CPU backoff time we are currently waiting
+    cpu_backoff_time: Duration,
+    /// When the backoff is reset the cool-off period will keep
+    /// things running for a short period of time extra
+    cpu_run_cool_off: u128,
+    /// Maximum amount of CPU backoff time before it starts capping
+    max_cpu_backoff_time: Duration,
+    /// Amount of time the CPU should cool-off after exiting run
+    /// before it begins a backoff
+    max_cpu_cool_off_time: Duration,
+}
+
+impl WasiProcessCpuBackoff {
+    pub fn new(max_cpu_backoff_time: Duration, max_cpu_cool_off_time: Duration) -> Self {
+        Self {
+            cpu_backoff_wakers: Default::default(),
+            cpu_backoff_waker_seed: 0,
+            cpu_backoff_time: Duration::ZERO,
+            cpu_run_cool_off: 0,
+            max_cpu_backoff_time,
+            max_cpu_cool_off_time,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct CpuRunToken {
+    tokens: Arc<AtomicU32>,
+}
+
+impl Drop for CpuRunToken {
+    fn drop(&mut self) {
+        self.tokens.fetch_sub(1, Ordering::SeqCst);
+    }
+}
+
+pub struct CpuBackoffToken {
+    /// The amount of CPU backoff time we are currently waiting
+    cpu_backoff_time: Duration,
+    /// How long should the CPU backoff for
+    wait: Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>,
+    /// ID used to unregister the wakers
+    waker_id: Option<u64>,
+    /// The inner protected region of the process with a conditional
+    /// variable that is used for coordination such as checksums.
+    inner: LockableWasiProcessInner,
+}
+
+impl CpuBackoffToken {
+    pub fn backoff_time(&self) -> Duration {
+        self.cpu_backoff_time
+    }
+}
+
+impl Future for CpuBackoffToken {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let inner = self.inner.clone();
+        let mut inner = inner.0.lock().unwrap();
+
+        // Registering the waker will unregister any previous wakers
+        // so that we don't go into an endless memory growth situation
+        if let Some(waker_id) = self.waker_id.take() {
+            if inner.backoff.cpu_backoff_wakers.remove(&waker_id).is_none() {
+                // if we did not remove the waker, then someone else did
+                // which means we were woken and should exit the backoff phase
+                return Poll::Ready(());
+            }
+        }
+
+        // Register ourselves as a waker to be woken
+        let id = inner.backoff.cpu_backoff_waker_seed + 1;
+        inner.backoff.cpu_backoff_waker_seed = id;
+        inner
+            .backoff
+            .cpu_backoff_wakers
+            .insert(id, cx.waker().clone());
+
+        // Now poll the waiting period
+        let ret = self.wait.poll_unpin(cx);
+
+        // If we have reached the end of the wait period
+        // then we need to exponentially grow it any future
+        // backoff's so that it gets slower
+        if ret.is_ready() && self.cpu_backoff_time == inner.backoff.cpu_backoff_time {
+            inner.backoff.cpu_backoff_time *= 2;
+            if inner.backoff.cpu_backoff_time > inner.backoff.max_cpu_backoff_time {
+                inner.backoff.cpu_backoff_time = inner.backoff.max_cpu_backoff_time;
+            }
+        }
+
+        ret
+    }
+}
+
+impl Drop for CpuBackoffToken {
+    fn drop(&mut self) {
+        if let Some(waker_id) = self.waker_id.take() {
+            let mut inner = self.inner.0.lock().unwrap();
+            inner.backoff.cpu_backoff_wakers.remove(&waker_id);
+        }
+    }
+}
+
+impl WasiProcess {
+    // Releases the CPU backoff (if one is active)
+    pub fn acquire_cpu_run_token(&self) -> CpuRunToken {
+        self.cpu_run_tokens.fetch_add(1, Ordering::SeqCst);
+
+        let mut inner = self.inner.0.lock().unwrap();
+        for (_, waker) in inner.backoff.cpu_backoff_wakers.iter() {
+            waker.wake_by_ref();
+        }
+        inner.backoff.cpu_backoff_wakers.clear();
+        inner.backoff.cpu_backoff_time = Duration::ZERO;
+        inner.backoff.cpu_run_cool_off = 0;
+
+        CpuRunToken {
+            tokens: self.cpu_run_tokens.clone(),
+        }
+    }
+
+    // Determine if we should do a CPU backoff
+    pub fn acquire_cpu_backoff_token(
+        &self,
+        tasks: &Arc<dyn VirtualTaskManager>,
+    ) -> Option<CpuBackoffToken> {
+        // If run tokens are held then we should allow executing to
+        // continue at its top pace
+        if self.cpu_run_tokens.load(Ordering::SeqCst) > 0 {
+            return None;
+        }
+
+        let cpu_backoff_time = {
+            let mut inner = self.inner.0.lock().unwrap();
+
+            // check again as it might have changed (race condition)
+            if self.cpu_run_tokens.load(Ordering::SeqCst) > 0 {
+                return None;
+            }
+
+            // Check if a cool-off-period has passed
+            let now =
+                platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000).unwrap() as u128;
+            if inner.backoff.cpu_run_cool_off == 0 {
+                inner.backoff.cpu_run_cool_off =
+                    now + (1_000_000 * inner.backoff.max_cpu_cool_off_time.as_millis());
+            }
+            if now <= inner.backoff.cpu_run_cool_off {
+                return None;
+            }
+
+            // The amount of time we wait will be increased when a full
+            // time slice is executed
+            if inner.backoff.cpu_backoff_time == Duration::ZERO {
+                inner.backoff.cpu_backoff_time = Duration::from_millis(1);
+            }
+            inner.backoff.cpu_backoff_time
+        };
+        let how_long = tasks.sleep_now(cpu_backoff_time);
+
+        Some(CpuBackoffToken {
+            cpu_backoff_time,
+            wait: how_long,
+            waker_id: None,
+            inner: self.inner.clone(),
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/control_plane.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/control_plane.rs
new file mode 100644
index 0000000..8a27069
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/control_plane.rs
@@ -0,0 +1,271 @@
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc, RwLock,
+    },
+    time::Duration,
+};
+
+use crate::{runtime::module_cache::ModuleHash, WasiProcess, WasiProcessId};
+
+#[derive(Debug, Clone)]
+pub struct WasiControlPlane {
+    state: Arc<State>,
+}
+
+#[derive(Debug, Clone)]
+pub struct WasiControlPlaneHandle {
+    inner: std::sync::Weak<State>,
+}
+
+impl WasiControlPlaneHandle {
+    fn new(inner: &Arc<State>) -> Self {
+        Self {
+            inner: Arc::downgrade(inner),
+        }
+    }
+
+    pub fn upgrade(&self) -> Option<WasiControlPlane> {
+        self.inner.upgrade().map(|state| WasiControlPlane { state })
+    }
+
+    pub fn must_upgrade(&self) -> WasiControlPlane {
+        let state = self.inner.upgrade().expect("control plane unavailable");
+        WasiControlPlane { state }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ControlPlaneConfig {
+    /// Total number of tasks (processes + threads) that can be spawned.
+    pub max_task_count: Option<usize>,
+    /// Flag that indicates if asynchronous threading is enables (opt-in)
+    pub enable_asynchronous_threading: bool,
+    /// Enables an exponential backoff of the process CPU usage when there
+    /// are no active run tokens (when set holds the maximum amount of
+    /// time that it will pause the CPU)
+    /// (default = off)
+    pub enable_exponential_cpu_backoff: Option<Duration>,
+}
+
+impl ControlPlaneConfig {
+    pub fn new() -> Self {
+        Self {
+            max_task_count: None,
+            enable_asynchronous_threading: false,
+            enable_exponential_cpu_backoff: None,
+        }
+    }
+}
+
+impl Default for ControlPlaneConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug)]
+struct State {
+    config: ControlPlaneConfig,
+
+    /// Total number of active tasks (threads) across all processes.
+    task_count: Arc<AtomicUsize>,
+
+    /// Mutable state.
+    mutable: RwLock<MutableState>,
+}
+
+#[derive(Debug)]
+struct MutableState {
+    /// Seed used to generate process ID's
+    process_seed: u32,
+    /// The processes running on this machine
+    processes: HashMap<WasiProcessId, WasiProcess>,
+    // TODO: keep a queue of terminated process ids for id reuse.
+}
+
+impl WasiControlPlane {
+    pub fn new(config: ControlPlaneConfig) -> Self {
+        Self {
+            state: Arc::new(State {
+                config,
+                task_count: Arc::new(AtomicUsize::new(0)),
+                mutable: RwLock::new(MutableState {
+                    process_seed: 0,
+                    processes: Default::default(),
+                }),
+            }),
+        }
+    }
+
+    pub fn handle(&self) -> WasiControlPlaneHandle {
+        WasiControlPlaneHandle::new(&self.state)
+    }
+
+    /// Get the current count of active tasks (threads).
+    fn active_task_count(&self) -> usize {
+        self.state.task_count.load(Ordering::SeqCst)
+    }
+
+    /// Returns the configuration for this control plane
+    pub(crate) fn config(&self) -> &ControlPlaneConfig {
+        &self.state.config
+    }
+
+    /// Register a new task.
+    ///
+    // Currently just increments the task counter.
+    pub(crate) fn register_task(&self) -> Result<TaskCountGuard, ControlPlaneError> {
+        let count = self.state.task_count.fetch_add(1, Ordering::SeqCst);
+        if let Some(max) = self.state.config.max_task_count {
+            if count > max {
+                self.state.task_count.fetch_sub(1, Ordering::SeqCst);
+                return Err(ControlPlaneError::TaskLimitReached { max: count });
+            }
+        }
+        Ok(TaskCountGuard(self.state.task_count.clone()))
+    }
+
+    /// Creates a new process
+    // FIXME: De-register terminated processes!
+    // Currently they just accumulate.
+    pub fn new_process(&self, module_hash: ModuleHash) -> Result<WasiProcess, ControlPlaneError> {
+        if let Some(max) = self.state.config.max_task_count {
+            if self.active_task_count() >= max {
+                // NOTE: task count is not incremented here, only when new threads are spawned.
+                // A process will always have a main thread.
+                return Err(ControlPlaneError::TaskLimitReached { max });
+            }
+        }
+
+        // Create the process first to do all the allocations before locking.
+        let mut proc = WasiProcess::new(WasiProcessId::from(0), module_hash, self.handle());
+
+        let mut mutable = self.state.mutable.write().unwrap();
+
+        let pid = mutable.next_process_id()?;
+        proc.set_pid(pid);
+        mutable.processes.insert(pid, proc.clone());
+        Ok(proc)
+    }
+
+    /// Generates a new process ID
+    pub fn generate_id(&self) -> Result<WasiProcessId, ControlPlaneError> {
+        let mut mutable = self.state.mutable.write().unwrap();
+        mutable.next_process_id()
+    }
+
+    /// Gets a reference to a running process
+    pub fn get_process(&self, pid: WasiProcessId) -> Option<WasiProcess> {
+        self.state
+            .mutable
+            .read()
+            .unwrap()
+            .processes
+            .get(&pid)
+            .cloned()
+    }
+}
+
+impl MutableState {
+    fn next_process_id(&mut self) -> Result<WasiProcessId, ControlPlaneError> {
+        // TODO: reuse terminated ids, handle wrap-around, ...
+        let id = self.process_seed.checked_add(1).ok_or({
+            ControlPlaneError::TaskLimitReached {
+                max: u32::MAX as usize,
+            }
+        })?;
+        self.process_seed = id;
+        Ok(WasiProcessId::from(id))
+    }
+}
+
+impl Default for WasiControlPlane {
+    fn default() -> Self {
+        let config = ControlPlaneConfig::default();
+        Self::new(config)
+    }
+}
+
+/// Guard that ensures the [`WasiControlPlane`] task counter is decremented when dropped.
+#[derive(Debug)]
+pub struct TaskCountGuard(Arc<AtomicUsize>);
+
+impl Drop for TaskCountGuard {
+    fn drop(&mut self) {
+        self.0.fetch_sub(1, Ordering::SeqCst);
+    }
+}
+
+#[derive(thiserror::Error, PartialEq, Eq, Clone, Debug)]
+pub enum ControlPlaneError {
+    /// The maximum number of execution tasks has been reached.
+    #[error("The maximum number of execution tasks has been reached ({max})")]
+    TaskLimitReached {
+        /// The maximum number of tasks.
+        max: usize,
+    },
+}
+
+#[cfg(test)]
+mod tests {
+    use wasmer_wasix_types::wasix::ThreadStartType;
+
+    use crate::os::task::thread::WasiMemoryLayout;
+
+    use super::*;
+
+    /// Simple test to ensure task limits are respected.
+    #[test]
+    fn test_control_plane_task_limits() {
+        let p = WasiControlPlane::new(ControlPlaneConfig {
+            max_task_count: Some(2),
+            enable_asynchronous_threading: false,
+            enable_exponential_cpu_backoff: None,
+        });
+
+        let p1 = p.new_process(ModuleHash::random()).unwrap();
+        let _t1 = p1
+            .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
+            .unwrap();
+        let _t2 = p1
+            .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
+            .unwrap();
+
+        assert_eq!(
+            p.new_process(ModuleHash::random()).unwrap_err(),
+            ControlPlaneError::TaskLimitReached { max: 2 }
+        );
+    }
+
+    /// Simple test to ensure task limits are respected and that thread drop guards work.
+    #[test]
+    fn test_control_plane_task_limits_with_dropped_threads() {
+        let p = WasiControlPlane::new(ControlPlaneConfig {
+            max_task_count: Some(2),
+            enable_asynchronous_threading: false,
+            enable_exponential_cpu_backoff: None,
+        });
+
+        let p1 = p.new_process(ModuleHash::random()).unwrap();
+
+        for _ in 0..10 {
+            let _thread = p1
+                .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
+                .unwrap();
+        }
+
+        let _t1 = p1
+            .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
+            .unwrap();
+        let _t2 = p1
+            .new_thread(WasiMemoryLayout::default(), ThreadStartType::MainThread)
+            .unwrap();
+
+        assert_eq!(
+            p.new_process(ModuleHash::random()).unwrap_err(),
+            ControlPlaneError::TaskLimitReached { max: 2 }
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/mod.rs
new file mode 100644
index 0000000..755645f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/mod.rs
@@ -0,0 +1,14 @@
+//! OS task management for processes and threads.
+
+pub mod backoff;
+pub mod control_plane;
+pub mod process;
+pub mod signal;
+mod task_join_handle;
+pub mod thread;
+
+#[allow(unused_imports)]
+pub(crate) use process::WasiProcessInner;
+pub use task_join_handle::{
+    OwnedTaskStatus, TaskJoinHandle, TaskStatus, TaskTerminatedError, VirtualTaskHandle,
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/process.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/process.rs
new file mode 100644
index 0000000..3d56365
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/process.rs
@@ -0,0 +1,744 @@
+#[cfg(feature = "journal")]
+use crate::{journal::JournalEffector, syscalls::do_checkpoint_from_outside, unwind, WasiResult};
+use crate::{
+    journal::SnapshotTrigger, runtime::module_cache::ModuleHash, WasiEnv, WasiRuntimeError,
+};
+use serde::{Deserialize, Serialize};
+#[cfg(feature = "journal")]
+use std::collections::HashSet;
+use std::{
+    collections::HashMap,
+    convert::TryInto,
+    ops::Range,
+    sync::{
+        atomic::{AtomicU32, Ordering},
+        Arc, Condvar, Mutex, MutexGuard, RwLock, Weak,
+    },
+    task::Waker,
+    time::Duration,
+};
+use tracing::trace;
+use wasmer::FunctionEnvMut;
+use wasmer_wasix_types::{
+    types::Signal,
+    wasi::{Errno, ExitCode, Snapshot0Clockid},
+    wasix::ThreadStartType,
+};
+
+use crate::{
+    os::task::signal::WasiSignalInterval, syscalls::platform_clock_time_get, WasiThread,
+    WasiThreadHandle, WasiThreadId,
+};
+
+use super::{
+    backoff::WasiProcessCpuBackoff,
+    control_plane::{ControlPlaneError, WasiControlPlaneHandle},
+    signal::{SignalDeliveryError, SignalHandlerAbi},
+    task_join_handle::OwnedTaskStatus,
+    thread::WasiMemoryLayout,
+    TaskStatus,
+};
+
+/// Represents the ID of a sub-process
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct WasiProcessId(u32);
+
+impl WasiProcessId {
+    pub fn raw(&self) -> u32 {
+        self.0
+    }
+}
+
+impl From<i32> for WasiProcessId {
+    fn from(id: i32) -> Self {
+        Self(id as u32)
+    }
+}
+
+impl From<WasiProcessId> for i32 {
+    fn from(val: WasiProcessId) -> Self {
+        val.0 as i32
+    }
+}
+
+impl From<u32> for WasiProcessId {
+    fn from(id: u32) -> Self {
+        Self(id)
+    }
+}
+
+impl From<WasiProcessId> for u32 {
+    fn from(val: WasiProcessId) -> Self {
+        val.0
+    }
+}
+
+impl std::fmt::Display for WasiProcessId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::fmt::Debug for WasiProcessId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+pub type LockableWasiProcessInner = Arc<(Mutex<WasiProcessInner>, Condvar)>;
+
+/// Represents a process running within the compute state
+/// TODO: fields should be private and only accessed via methods.
+#[derive(Debug, Clone)]
+pub struct WasiProcess {
+    /// Unique ID of this process
+    pub(crate) pid: WasiProcessId,
+    /// Hash of the module that this process is using
+    pub(crate) module_hash: ModuleHash,
+    /// List of all the children spawned from this thread
+    pub(crate) parent: Option<Weak<RwLock<WasiProcessInner>>>,
+    /// The inner protected region of the process with a conditional
+    /// variable that is used for coordination such as snapshots.
+    pub(crate) inner: LockableWasiProcessInner,
+    /// Reference back to the compute engine
+    // TODO: remove this reference, access should happen via separate state instead
+    // (we don't want cyclical references)
+    pub(crate) compute: WasiControlPlaneHandle,
+    /// Reference to the exit code for the main thread
+    pub(crate) finished: Arc<OwnedTaskStatus>,
+    /// Number of threads waiting for children to exit
+    pub(crate) waiting: Arc<AtomicU32>,
+    /// Number of tokens that are currently active and thus
+    /// the exponential backoff of CPU is halted (as in CPU
+    /// is allowed to run freely)
+    pub(crate) cpu_run_tokens: Arc<AtomicU32>,
+}
+
+/// Represents a freeze of all threads to perform some action
+/// on the total state-machine. This is normally done for
+/// things like snapshots which require the memory to remain
+/// stable while it performs a diff.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum WasiProcessCheckpoint {
+    /// No checkpoint will take place and the process
+    /// should just execute as per normal
+    Execute,
+    /// The process needs to take a snapshot of the
+    /// memory and state-machine
+    Snapshot { trigger: SnapshotTrigger },
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct MemorySnapshotRegion {
+    pub start: u64,
+    pub end: u64,
+}
+
+impl From<Range<u64>> for MemorySnapshotRegion {
+    fn from(value: Range<u64>) -> Self {
+        Self {
+            start: value.start,
+            end: value.end,
+        }
+    }
+}
+
+#[allow(clippy::from_over_into)]
+impl Into<Range<u64>> for MemorySnapshotRegion {
+    fn into(self) -> Range<u64> {
+        self.start..self.end
+    }
+}
+
+// TODO: fields should be private and only accessed via methods.
+#[derive(Debug)]
+pub struct WasiProcessInner {
+    /// Unique ID of this process
+    pub pid: WasiProcessId,
+    /// Number of threads waiting for children to exit
+    pub(crate) waiting: Arc<AtomicU32>,
+    /// The threads that make up this process
+    pub threads: HashMap<WasiThreadId, WasiThread>,
+    /// Number of threads running for this process
+    pub thread_count: u32,
+    /// Signals that will be triggered at specific intervals
+    pub signal_intervals: HashMap<Signal, WasiSignalInterval>,
+    /// List of all the children spawned from this thread
+    pub children: Vec<WasiProcess>,
+    /// Represents a checkpoint which blocks all the threads
+    /// and then executes some maintenance action
+    pub checkpoint: WasiProcessCheckpoint,
+    /// List of situations that the process will checkpoint on
+    #[cfg(feature = "journal")]
+    pub snapshot_on: HashSet<SnapshotTrigger>,
+    /// Any wakers waiting on this process (for example for a checkpoint)
+    pub wakers: Vec<Waker>,
+    /// The snapshot memory significantly reduce the amount of
+    /// duplicate entries in the journal for memory that has not changed
+    #[cfg(feature = "journal")]
+    pub snapshot_memory_hash: HashMap<MemorySnapshotRegion, u64>,
+    /// Represents all the backoff properties for this process
+    /// which will be used to determine if the CPU should be
+    /// throttled or not
+    pub(super) backoff: WasiProcessCpuBackoff,
+}
+
+pub enum MaybeCheckpointResult<'a> {
+    NotThisTime(FunctionEnvMut<'a, WasiEnv>),
+    Unwinding,
+}
+
+impl WasiProcessInner {
+    /// Checkpoints the process which will cause all other threads to
+    /// pause and for the thread and memory state to be saved
+    #[cfg(feature = "journal")]
+    pub fn checkpoint<M: wasmer_types::MemorySize>(
+        inner: LockableWasiProcessInner,
+        ctx: FunctionEnvMut<'_, WasiEnv>,
+        for_what: WasiProcessCheckpoint,
+    ) -> WasiResult<MaybeCheckpointResult<'_>> {
+        // Set the checkpoint flag and then enter the normal processing loop
+        {
+            let mut guard = inner.0.lock().unwrap();
+            guard.checkpoint = for_what;
+            for waker in guard.wakers.drain(..) {
+                waker.wake();
+            }
+            inner.1.notify_all();
+        }
+
+        Self::maybe_checkpoint::<M>(inner, ctx)
+    }
+
+    /// If a checkpoint has been started this will block the current process
+    /// until the checkpoint operation has completed
+    #[cfg(feature = "journal")]
+    pub fn maybe_checkpoint<M: wasmer_types::MemorySize>(
+        inner: LockableWasiProcessInner,
+        ctx: FunctionEnvMut<'_, WasiEnv>,
+    ) -> WasiResult<MaybeCheckpointResult<'_>> {
+        // Enter the lock which will determine if we are in a checkpoint or not
+
+        use bytes::Bytes;
+        use wasmer::AsStoreMut;
+        use wasmer_types::OnCalledAction;
+
+        use crate::{os::task::thread::RewindResultType, rewind_ext, WasiError};
+        let guard = inner.0.lock().unwrap();
+        if guard.checkpoint == WasiProcessCheckpoint::Execute {
+            // No checkpoint so just carry on
+            return Ok(Ok(MaybeCheckpointResult::NotThisTime(ctx)));
+        }
+        trace!("checkpoint capture");
+        drop(guard);
+
+        // Perform the unwind action
+        let thread_layout = ctx.data().thread.memory_layout().clone();
+        unwind::<M, _>(ctx, move |mut ctx, memory_stack, rewind_stack| {
+            // Grab all the globals and serialize them
+            let store_data = crate::utils::store::capture_store_snapshot(&mut ctx.as_store_mut())
+                .serialize()
+                .unwrap();
+            let memory_stack = memory_stack.freeze();
+            let rewind_stack = rewind_stack.freeze();
+            let store_data = Bytes::from(store_data);
+
+            tracing::debug!(
+                "stack snapshot unwind (memory_stack={}, rewind_stack={}, store_data={})",
+                memory_stack.len(),
+                rewind_stack.len(),
+                store_data.len(),
+            );
+
+            // Write our thread state to the snapshot
+            let thread_start = ctx.data().thread.thread_start_type();
+            let tid = ctx.data().thread.tid();
+            if let Err(err) = JournalEffector::save_thread_state::<M>(
+                &mut ctx,
+                tid,
+                memory_stack.clone(),
+                rewind_stack.clone(),
+                store_data.clone(),
+                thread_start,
+                thread_layout,
+            ) {
+                return wasmer_types::OnCalledAction::Trap(err.into());
+            }
+
+            let mut guard = inner.0.lock().unwrap();
+
+            // Wait for the checkpoint to finish (or if we are the last thread
+            // to freeze then we have to execute the checksum operation)
+            loop {
+                if let WasiProcessCheckpoint::Snapshot { trigger } = guard.checkpoint {
+                    ctx.data().thread.set_checkpointing(true);
+
+                    // Now if we are the last thread we also write the memory
+                    let is_last_thread = guard
+                        .threads
+                        .values()
+                        .all(|t| t.is_check_pointing() || t.is_deep_sleeping());
+                    if is_last_thread {
+                        if let Err(err) =
+                            JournalEffector::save_memory_and_snapshot(&mut ctx, &mut guard, trigger)
+                        {
+                            inner.1.notify_all();
+                            return wasmer_types::OnCalledAction::Trap(err.into());
+                        }
+
+                        // Clear the checkpointing flag and notify everyone to wake up
+                        ctx.data().thread.set_checkpointing(false);
+                        trace!("checkpoint complete");
+                        guard.checkpoint = WasiProcessCheckpoint::Execute;
+                        for waker in guard.wakers.drain(..) {
+                            waker.wake();
+                        }
+                        inner.1.notify_all();
+                    } else {
+                        guard = inner.1.wait(guard).unwrap();
+                    }
+                    continue;
+                }
+
+                ctx.data().thread.set_checkpointing(false);
+                trace!("checkpoint finished");
+
+                // Rewind the stack and carry on
+                return match rewind_ext::<M>(
+                    &mut ctx,
+                    Some(memory_stack),
+                    rewind_stack,
+                    store_data,
+                    RewindResultType::RewindWithoutResult,
+                ) {
+                    Errno::Success => OnCalledAction::InvokeAgain,
+                    err => {
+                        tracing::warn!(
+                            "snapshot resumption failed - could not rewind the stack - errno={}",
+                            err
+                        );
+                        OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                    }
+                };
+            }
+        })?;
+
+        Ok(Ok(MaybeCheckpointResult::Unwinding))
+    }
+
+    // Execute any checkpoints that can be executed while outside of the WASM process
+    #[cfg(not(feature = "journal"))]
+    pub fn do_checkpoints_from_outside(_ctx: &mut FunctionEnvMut<'_, WasiEnv>) {}
+
+    // Execute any checkpoints that can be executed while outside of the WASM process
+    #[cfg(feature = "journal")]
+    pub fn do_checkpoints_from_outside(ctx: &mut FunctionEnvMut<'_, WasiEnv>) {
+        let inner = ctx.data().process.inner.clone();
+        let mut guard = inner.0.lock().unwrap();
+
+        // Wait for the checkpoint to finish (or if we are the last thread
+        // to freeze then we have to execute the checksum operation)
+        while let WasiProcessCheckpoint::Snapshot { trigger } = guard.checkpoint {
+            ctx.data().thread.set_checkpointing(true);
+
+            // Now if we are the last thread we also write the memory
+            let is_last_thread = guard
+                .threads
+                .values()
+                .all(|t| t.is_check_pointing() || t.is_deep_sleeping());
+            if is_last_thread {
+                if let Err(err) =
+                    JournalEffector::save_memory_and_snapshot(ctx, &mut guard, trigger)
+                {
+                    inner.1.notify_all();
+                    tracing::error!("failed to snapshot memory and threads - {}", err);
+                    return;
+                }
+
+                // Clear the checkpointing flag and notify everyone to wake up
+                ctx.data().thread.set_checkpointing(false);
+                trace!("checkpoint complete");
+                guard.checkpoint = WasiProcessCheckpoint::Execute;
+                for waker in guard.wakers.drain(..) {
+                    waker.wake();
+                }
+                inner.1.notify_all();
+            } else {
+                guard = inner.1.wait(guard).unwrap();
+            }
+            continue;
+        }
+
+        ctx.data().thread.set_checkpointing(false);
+        trace!("checkpoint finished");
+    }
+}
+
+// TODO: why do we need this, how is it used?
+pub(crate) struct WasiProcessWait {
+    waiting: Arc<AtomicU32>,
+}
+
+impl WasiProcessWait {
+    pub fn new(process: &WasiProcess) -> Self {
+        process.waiting.fetch_add(1, Ordering::AcqRel);
+        Self {
+            waiting: process.waiting.clone(),
+        }
+    }
+}
+
+impl Drop for WasiProcessWait {
+    fn drop(&mut self) {
+        self.waiting.fetch_sub(1, Ordering::AcqRel);
+    }
+}
+
+impl WasiProcess {
+    pub fn new(pid: WasiProcessId, module_hash: ModuleHash, plane: WasiControlPlaneHandle) -> Self {
+        let max_cpu_backoff_time = plane
+            .upgrade()
+            .and_then(|p| p.config().enable_exponential_cpu_backoff)
+            .unwrap_or(Duration::from_secs(30));
+        let max_cpu_cool_off_time = Duration::from_millis(500);
+
+        let waiting = Arc::new(AtomicU32::new(0));
+        let inner = Arc::new((
+            Mutex::new(WasiProcessInner {
+                pid,
+                threads: Default::default(),
+                thread_count: Default::default(),
+                signal_intervals: Default::default(),
+                children: Default::default(),
+                checkpoint: WasiProcessCheckpoint::Execute,
+                wakers: Default::default(),
+                waiting: waiting.clone(),
+                #[cfg(feature = "journal")]
+                snapshot_on: Default::default(),
+                #[cfg(feature = "journal")]
+                snapshot_memory_hash: Default::default(),
+                backoff: WasiProcessCpuBackoff::new(max_cpu_backoff_time, max_cpu_cool_off_time),
+            }),
+            Condvar::new(),
+        ));
+
+        #[derive(Debug)]
+        struct SignalHandler(LockableWasiProcessInner);
+        impl SignalHandlerAbi for SignalHandler {
+            fn signal(&self, signal: u8) -> Result<(), SignalDeliveryError> {
+                if let Ok(signal) = signal.try_into() {
+                    signal_process_internal(&self.0, signal);
+                    Ok(())
+                } else {
+                    Err(SignalDeliveryError)
+                }
+            }
+        }
+
+        WasiProcess {
+            pid,
+            module_hash,
+            parent: None,
+            compute: plane,
+            inner: inner.clone(),
+            finished: Arc::new(
+                OwnedTaskStatus::new(TaskStatus::Pending)
+                    .with_signal_handler(Arc::new(SignalHandler(inner))),
+            ),
+            waiting,
+            cpu_run_tokens: Arc::new(AtomicU32::new(0)),
+        }
+    }
+
+    pub(super) fn set_pid(&mut self, pid: WasiProcessId) {
+        self.pid = pid;
+    }
+
+    /// Gets the process ID of this process
+    pub fn pid(&self) -> WasiProcessId {
+        self.pid
+    }
+
+    /// Gets the process ID of the parent process
+    pub fn ppid(&self) -> WasiProcessId {
+        self.parent
+            .iter()
+            .filter_map(|parent| parent.upgrade())
+            .map(|parent| parent.read().unwrap().pid)
+            .next()
+            .unwrap_or(WasiProcessId(0))
+    }
+
+    /// Gains access to the process internals
+    // TODO: Make this private, all inner access should be exposed with methods.
+    pub fn lock(&self) -> MutexGuard<'_, WasiProcessInner> {
+        self.inner.0.lock().unwrap()
+    }
+
+    /// Creates a a thread and returns it
+    pub fn new_thread(
+        &self,
+        layout: WasiMemoryLayout,
+        start: ThreadStartType,
+    ) -> Result<WasiThreadHandle, ControlPlaneError> {
+        let control_plane = self.compute.must_upgrade();
+
+        // Determine if its the main thread or not
+        let is_main = matches!(start, ThreadStartType::MainThread);
+
+        // Generate a new process ID (this is because the process ID and thread ID
+        // address space must not overlap in libc). For the main proecess the TID=PID
+        let tid: WasiThreadId = if is_main {
+            self.pid().raw().into()
+        } else {
+            let tid: u32 = control_plane.generate_id()?.into();
+            tid.into()
+        };
+
+        self.new_thread_with_id(layout, start, tid)
+    }
+
+    /// Creates a a thread and returns it
+    pub fn new_thread_with_id(
+        &self,
+        layout: WasiMemoryLayout,
+        start: ThreadStartType,
+        tid: WasiThreadId,
+    ) -> Result<WasiThreadHandle, ControlPlaneError> {
+        let control_plane = self.compute.must_upgrade();
+        let task_count_guard = control_plane.register_task()?;
+
+        let is_main = matches!(start, ThreadStartType::MainThread);
+
+        // The wait finished should be the process version if its the main thread
+        let mut inner = self.inner.0.lock().unwrap();
+        let finished = if is_main {
+            self.finished.clone()
+        } else {
+            Arc::new(OwnedTaskStatus::default())
+        };
+
+        // Insert the thread into the pool
+        let ctrl = WasiThread::new(
+            self.pid(),
+            tid,
+            is_main,
+            finished,
+            task_count_guard,
+            layout,
+            start,
+        );
+        inner.threads.insert(tid, ctrl.clone());
+        inner.thread_count += 1;
+
+        Ok(WasiThreadHandle::new(ctrl, &self.inner))
+    }
+
+    /// Gets a reference to a particular thread
+    pub fn get_thread(&self, tid: &WasiThreadId) -> Option<WasiThread> {
+        let inner = self.inner.0.lock().unwrap();
+        inner.threads.get(tid).cloned()
+    }
+
+    /// Signals a particular thread in the process
+    pub fn signal_thread(&self, tid: &WasiThreadId, signal: Signal) {
+        // Sometimes we will signal the process rather than the thread hence this libc hardcoded value
+        let mut tid = tid.raw();
+        if tid == 1073741823 {
+            tid = self.pid().raw();
+        }
+        let tid: WasiThreadId = tid.into();
+
+        let pid = self.pid();
+        tracing::trace!(%pid, %tid, "signal-thread({:?})", signal);
+
+        let inner = self.inner.0.lock().unwrap();
+        if let Some(thread) = inner.threads.get(&tid) {
+            thread.signal(signal);
+        } else {
+            trace!(
+                "wasi[{}]::lost-signal(tid={}, sig={:?})",
+                self.pid(),
+                tid,
+                signal
+            );
+        }
+    }
+
+    /// Signals all the threads in this process
+    pub fn signal_process(&self, signal: Signal) {
+        signal_process_internal(&self.inner, signal);
+    }
+
+    /// Signals one of the threads every interval
+    pub fn signal_interval(&self, signal: Signal, interval: Option<Duration>, repeat: bool) {
+        let mut inner = self.inner.0.lock().unwrap();
+
+        let interval = match interval {
+            None => {
+                inner.signal_intervals.remove(&signal);
+                return;
+            }
+            Some(a) => a,
+        };
+
+        let now = platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000).unwrap() as u128;
+        inner.signal_intervals.insert(
+            signal,
+            WasiSignalInterval {
+                signal,
+                interval,
+                last_signal: now,
+                repeat,
+            },
+        );
+    }
+
+    /// Returns the number of active threads for this process
+    pub fn active_threads(&self) -> u32 {
+        let inner = self.inner.0.lock().unwrap();
+        inner.thread_count
+    }
+
+    /// Waits until the process is finished.
+    pub async fn join(&self) -> Result<ExitCode, Arc<WasiRuntimeError>> {
+        let _guard = WasiProcessWait::new(self);
+        self.finished.await_termination().await
+    }
+
+    /// Attempts to join on the process
+    pub fn try_join(&self) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>> {
+        self.finished.status().into_finished()
+    }
+
+    /// Waits for all the children to be finished
+    pub async fn join_children(&mut self) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>> {
+        let _guard = WasiProcessWait::new(self);
+        let children: Vec<_> = {
+            let inner = self.inner.0.lock().unwrap();
+            inner.children.clone()
+        };
+        if children.is_empty() {
+            return None;
+        }
+        let mut waits = Vec::new();
+        for child in children {
+            if let Some(process) = self.compute.must_upgrade().get_process(child.pid) {
+                let inner = self.inner.clone();
+                waits.push(async move {
+                    let join = process.join().await;
+                    let mut inner = inner.0.lock().unwrap();
+                    inner.children.retain(|a| a.pid != child.pid);
+                    join
+                })
+            }
+        }
+        futures::future::join_all(waits.into_iter())
+            .await
+            .into_iter()
+            .next()
+    }
+
+    /// Waits for any of the children to finished
+    pub async fn join_any_child(&mut self) -> Result<Option<(WasiProcessId, ExitCode)>, Errno> {
+        let _guard = WasiProcessWait::new(self);
+        let children: Vec<_> = {
+            let inner = self.inner.0.lock().unwrap();
+            inner.children.clone()
+        };
+        if children.is_empty() {
+            return Err(Errno::Child);
+        }
+
+        let mut waits = Vec::new();
+        for child in children {
+            if let Some(process) = self.compute.must_upgrade().get_process(child.pid) {
+                let inner = self.inner.clone();
+                waits.push(async move {
+                    let join = process.join().await;
+                    let mut inner = inner.0.lock().unwrap();
+                    inner.children.retain(|a| a.pid != child.pid);
+                    (child, join)
+                })
+            }
+        }
+        let (child, res) = futures::future::select_all(waits.into_iter().map(|a| Box::pin(a)))
+            .await
+            .0;
+
+        let code =
+            res.unwrap_or_else(|e| e.as_exit_code().unwrap_or_else(|| Errno::Canceled.into()));
+
+        Ok(Some((child.pid, code)))
+    }
+
+    /// Terminate the process and all its threads
+    pub fn terminate(&self, exit_code: ExitCode) {
+        // FIXME: this is wrong, threads might still be running!
+        // Need special logic for the main thread.
+        let guard = self.inner.0.lock().unwrap();
+        for thread in guard.threads.values() {
+            thread.set_status_finished(Ok(exit_code))
+        }
+    }
+}
+
+/// Signals all the threads in this process
+fn signal_process_internal(process: &LockableWasiProcessInner, signal: Signal) {
+    #[allow(unused_mut)]
+    let mut guard = process.0.lock().unwrap();
+    let pid = guard.pid;
+    tracing::trace!(%pid, "signal-process({:?})", signal);
+
+    // If the snapshot on ctrl-c is currently registered then we need
+    // to take a snapshot and exit
+    #[cfg(feature = "journal")]
+    {
+        if signal == Signal::Sigint
+            && (guard.snapshot_on.contains(&SnapshotTrigger::Sigint)
+                || guard.snapshot_on.remove(&SnapshotTrigger::FirstSigint))
+        {
+            drop(guard);
+
+            tracing::debug!(%pid, "snapshot-on-interrupt-signal");
+
+            do_checkpoint_from_outside(
+                process,
+                WasiProcessCheckpoint::Snapshot {
+                    trigger: SnapshotTrigger::Sigint,
+                },
+            );
+            return;
+        };
+    }
+
+    // Check if there are subprocesses that will receive this signal
+    // instead of this process
+    if guard.waiting.load(Ordering::Acquire) > 0 {
+        let mut triggered = false;
+        for child in guard.children.iter() {
+            child.signal_process(signal);
+            triggered = true;
+        }
+        if triggered {
+            return;
+        }
+    }
+
+    // Otherwise just send the signal to all the threads
+    for thread in guard.threads.values() {
+        thread.signal(signal);
+    }
+}
+
+impl SignalHandlerAbi for WasiProcess {
+    fn signal(&self, sig: u8) -> Result<(), SignalDeliveryError> {
+        if let Ok(sig) = sig.try_into() {
+            self.signal_process(sig);
+            Ok(())
+        } else {
+            Err(SignalDeliveryError)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/signal.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/signal.rs
new file mode 100644
index 0000000..d6b729b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/signal.rs
@@ -0,0 +1,57 @@
+use std::{sync::Arc, time::Duration};
+
+use wasmer_wasix_types::types::Signal;
+
+#[derive(thiserror::Error, Debug)]
+#[error("Signal could not be delivered")]
+pub struct SignalDeliveryError;
+
+/// Signal handles...well...they process signals
+pub trait SignalHandlerAbi
+where
+    Self: std::fmt::Debug,
+{
+    /// Processes a signal
+    fn signal(&self, signal: u8) -> Result<(), SignalDeliveryError>;
+}
+
+pub type DynSignalHandlerAbi = dyn SignalHandlerAbi + Send + Sync + 'static;
+
+#[derive(Debug)]
+pub struct WasiSignalInterval {
+    /// Signal that will be raised
+    pub signal: Signal,
+    /// Time between the signals
+    pub interval: Duration,
+    /// Flag that indicates if the signal should repeat
+    pub repeat: bool,
+    /// Last time that a signal was triggered
+    pub last_signal: u128,
+}
+
+pub fn default_signal_handler() -> Arc<DynSignalHandlerAbi> {
+    #[derive(Debug)]
+    struct DefaultHandler {}
+    impl SignalHandlerAbi for DefaultHandler {
+        fn signal(&self, signal: u8) -> Result<(), SignalDeliveryError> {
+            if let Ok(signal) = TryInto::<Signal>::try_into(signal) {
+                match signal {
+                    Signal::Sigkill
+                    | Signal::Sigterm
+                    | Signal::Sigabrt
+                    | Signal::Sigquit
+                    | Signal::Sigint
+                    | Signal::Sigstop => {
+                        tracing::debug!("handling terminate signal");
+                        std::process::exit(1);
+                    }
+                    signal => tracing::info!("unhandled signal - {:?}", signal),
+                }
+            } else {
+                tracing::info!("unknown signal - {}", signal)
+            }
+            Ok(())
+        }
+    }
+    Arc::new(DefaultHandler {})
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/task_join_handle.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/task_join_handle.rs
new file mode 100644
index 0000000..5c2329e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/task_join_handle.rs
@@ -0,0 +1,223 @@
+use std::{
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use wasmer_wasix_types::wasi::{Errno, ExitCode};
+
+use crate::WasiRuntimeError;
+
+use super::signal::{default_signal_handler, DynSignalHandlerAbi};
+
+#[derive(Clone, Debug)]
+pub enum TaskStatus {
+    Pending,
+    Running,
+    Finished(Result<ExitCode, Arc<WasiRuntimeError>>),
+}
+
+impl TaskStatus {
+    /// Returns `true` if the task status is [`Pending`].
+    ///
+    /// [`Pending`]: TaskStatus::Pending
+    #[must_use]
+    pub fn is_pending(&self) -> bool {
+        matches!(self, Self::Pending)
+    }
+
+    /// Returns `true` if the task status is [`Running`].
+    ///
+    /// [`Running`]: TaskStatus::Running
+    #[must_use]
+    pub fn is_running(&self) -> bool {
+        matches!(self, Self::Running)
+    }
+
+    pub fn into_finished(self) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>> {
+        match self {
+            Self::Finished(res) => Some(res),
+            _ => None,
+        }
+    }
+
+    /// Returns `true` if the task status is [`Finished`].
+    ///
+    /// [`Finished`]: TaskStatus::Finished
+    #[must_use]
+    pub fn is_finished(&self) -> bool {
+        matches!(self, Self::Finished(..))
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+#[error("Task already terminated")]
+pub struct TaskTerminatedError;
+
+pub trait VirtualTaskHandle: std::fmt::Debug + Send + Sync + 'static {
+    fn status(&self) -> TaskStatus;
+
+    /// Polls to check if the process is ready yet to receive commands
+    fn poll_ready(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), TaskTerminatedError>>;
+
+    fn poll_finished(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<ExitCode, Arc<WasiRuntimeError>>>;
+}
+
+/// A handle that allows awaiting the termination of a task, and retrieving its exit code.
+#[derive(Debug)]
+pub struct OwnedTaskStatus {
+    // The signal handler that can be invoked for this owned task
+    signal_handler: Arc<DynSignalHandlerAbi>,
+
+    watch_tx: tokio::sync::watch::Sender<TaskStatus>,
+    // Even through unused, without this receive there is a race condition
+    // where the previously sent values are lost.
+    #[allow(dead_code)]
+    watch_rx: tokio::sync::watch::Receiver<TaskStatus>,
+}
+
+impl OwnedTaskStatus {
+    pub fn new(status: TaskStatus) -> Self {
+        let (tx, rx) = tokio::sync::watch::channel(status);
+        Self {
+            signal_handler: default_signal_handler(),
+            watch_tx: tx,
+            watch_rx: rx,
+        }
+    }
+
+    /// Sets the signal handler used for this owned task
+    pub fn set_signal_handler(&mut self, handler: Arc<DynSignalHandlerAbi>) {
+        self.signal_handler = handler;
+    }
+
+    /// Attaches a signal handler
+    pub fn with_signal_handler(mut self, handler: Arc<DynSignalHandlerAbi>) -> Self {
+        self.set_signal_handler(handler);
+        self
+    }
+
+    pub fn new_finished_with_code(code: ExitCode) -> Self {
+        Self::new(TaskStatus::Finished(Ok(code)))
+    }
+
+    /// Marks the task as finished.
+    pub fn set_running(&self) {
+        self.watch_tx.send_modify(|value| {
+            // Only set to running if task was pending, otherwise the transition would be invalid.
+            if value.is_pending() {
+                *value = TaskStatus::Running;
+            }
+        })
+    }
+
+    /// Marks the task as finished.
+    pub(crate) fn set_finished(&self, res: Result<ExitCode, Arc<WasiRuntimeError>>) {
+        let inner = match res {
+            Ok(code) => Ok(code),
+            Err(err) => {
+                if let Some(code) = err.as_exit_code() {
+                    Ok(code)
+                } else {
+                    Err(err)
+                }
+            }
+        };
+        self.watch_tx.send_modify(move |old| {
+            if !old.is_finished() {
+                *old = TaskStatus::Finished(inner);
+            }
+        });
+    }
+
+    pub fn status(&self) -> TaskStatus {
+        self.watch_tx.borrow().clone()
+    }
+
+    pub async fn await_termination(&self) -> Result<ExitCode, Arc<WasiRuntimeError>> {
+        let mut receiver = self.watch_tx.subscribe();
+        loop {
+            let status = receiver.borrow_and_update().clone();
+            match status {
+                TaskStatus::Pending | TaskStatus::Running => {}
+                TaskStatus::Finished(res) => {
+                    return res;
+                }
+            }
+            // NOTE: unwrap() is fine, because &self always holds on to the sender.
+            receiver.changed().await.unwrap();
+        }
+    }
+
+    pub async fn await_termination_anyhow(&self) -> anyhow::Result<ExitCode> {
+        Ok(self.await_termination().await?)
+    }
+
+    pub fn handle(&self) -> TaskJoinHandle {
+        TaskJoinHandle {
+            signal_handler: self.signal_handler.clone(),
+            watch: self.watch_tx.subscribe(),
+        }
+    }
+}
+
+impl Default for OwnedTaskStatus {
+    fn default() -> Self {
+        Self::new(TaskStatus::Pending)
+    }
+}
+
+/// A handle that allows awaiting the termination of a task, and retrieving its exit code.
+#[derive(Clone, Debug)]
+pub struct TaskJoinHandle {
+    #[allow(unused)]
+    signal_handler: Arc<DynSignalHandlerAbi>,
+    watch: tokio::sync::watch::Receiver<TaskStatus>,
+}
+
+impl TaskJoinHandle {
+    /// Retrieve the current status.
+    pub fn status(&self) -> TaskStatus {
+        self.watch.borrow().clone()
+    }
+
+    #[cfg(feature = "ctrlc")]
+    pub fn install_ctrlc_handler(&self) {
+        use wasmer::FromToNativeWasmType;
+        use wasmer_wasix_types::wasi::Signal;
+
+        let signal_handler = self.signal_handler.clone();
+
+        tokio::spawn(async move {
+            // Loop sending ctrl-c presses as signals to the signal handler
+            while tokio::signal::ctrl_c().await.is_ok() {
+                if let Err(err) = signal_handler.signal(Signal::Sigint.to_native() as u8) {
+                    tracing::error!("failed to process signal - {}", err);
+                    std::process::exit(1);
+                }
+            }
+        });
+    }
+
+    /// Wait until the task finishes.
+    pub async fn wait_finished(&mut self) -> Result<ExitCode, Arc<WasiRuntimeError>> {
+        loop {
+            let status = self.watch.borrow_and_update().clone();
+            match status {
+                TaskStatus::Pending | TaskStatus::Running => {}
+                TaskStatus::Finished(res) => {
+                    return res;
+                }
+            }
+            if self.watch.changed().await.is_err() {
+                return Ok(Errno::Noent.into());
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/thread.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/thread.rs
new file mode 100644
index 0000000..6983785
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/task/thread.rs
@@ -0,0 +1,631 @@
+use serde::{Deserialize, Serialize};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::{
+    collections::HashMap,
+    ops::{Deref, DerefMut},
+    sync::{Arc, Condvar, Mutex, Weak},
+    task::Waker,
+};
+
+use bytes::{Bytes, BytesMut};
+use wasmer::{ExportError, InstantiationError, MemoryError};
+use wasmer_wasix_types::{
+    types::Signal,
+    wasi::{Errno, ExitCode},
+    wasix::ThreadStartType,
+};
+
+use crate::{
+    os::task::process::{WasiProcessId, WasiProcessInner},
+    syscalls::HandleRewindType,
+    WasiRuntimeError,
+};
+
+use super::{
+    control_plane::TaskCountGuard,
+    task_join_handle::{OwnedTaskStatus, TaskJoinHandle},
+};
+
+/// Represents the ID of a WASI thread
+#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct WasiThreadId(u32);
+
+impl WasiThreadId {
+    pub fn raw(&self) -> u32 {
+        self.0
+    }
+
+    pub fn inc(&mut self) -> WasiThreadId {
+        let ret = *self;
+        self.0 += 1;
+        ret
+    }
+}
+
+impl From<i32> for WasiThreadId {
+    fn from(id: i32) -> Self {
+        Self(id as u32)
+    }
+}
+
+impl From<WasiThreadId> for i32 {
+    fn from(val: WasiThreadId) -> Self {
+        val.0 as i32
+    }
+}
+
+impl From<u32> for WasiThreadId {
+    fn from(id: u32) -> Self {
+        Self(id)
+    }
+}
+
+impl From<WasiThreadId> for u32 {
+    fn from(t: WasiThreadId) -> u32 {
+        t.0
+    }
+}
+
+impl std::fmt::Display for WasiThreadId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl std::fmt::Debug for WasiThreadId {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Represents a linked list of stack snapshots
+#[derive(Debug, Clone)]
+struct ThreadSnapshot {
+    call_stack: Bytes,
+    store_data: Bytes,
+}
+
+/// Represents a linked list of stack snapshots
+#[derive(Debug, Clone, Default)]
+pub struct ThreadStack {
+    memory_stack: Vec<u8>,
+    memory_stack_corrected: Vec<u8>,
+    snapshots: HashMap<u128, ThreadSnapshot>,
+    next: Option<Box<ThreadStack>>,
+}
+
+/// Represents a running thread which allows a joiner to
+/// wait for the thread to exit
+#[derive(Clone, Debug)]
+pub struct WasiThread {
+    state: Arc<WasiThreadState>,
+    layout: WasiMemoryLayout,
+    start: ThreadStartType,
+
+    // This is used for stack rewinds
+    rewind: Option<RewindResult>,
+}
+
+impl WasiThread {
+    /// Sets that a rewind will take place
+    pub(crate) fn set_rewind(&mut self, rewind: RewindResult) {
+        self.rewind.replace(rewind);
+    }
+
+    /// Pops any rewinds that need to take place
+    pub(crate) fn take_rewind(&mut self) -> Option<RewindResult> {
+        self.rewind.take()
+    }
+
+    /// Gets the thread start type for this thread
+    pub fn thread_start_type(&self) -> ThreadStartType {
+        self.start
+    }
+
+    /// Returns true if a rewind of a particular type has been queued
+    /// for processed by a rewind operation
+    pub(crate) fn has_rewind_of_type(&self, type_: HandleRewindType) -> bool {
+        match type_ {
+            HandleRewindType::ResultDriven => match &self.rewind {
+                Some(rewind) => match rewind.rewind_result {
+                    RewindResultType::RewindRestart => true,
+                    RewindResultType::RewindWithoutResult => false,
+                    RewindResultType::RewindWithResult(_) => true,
+                },
+                None => false,
+            },
+            HandleRewindType::ResultLess => match &self.rewind {
+                Some(rewind) => match rewind.rewind_result {
+                    RewindResultType::RewindRestart => true,
+                    RewindResultType::RewindWithoutResult => true,
+                    RewindResultType::RewindWithResult(_) => false,
+                },
+                None => false,
+            },
+        }
+    }
+
+    /// Sets a flag that tells others if this thread is currently
+    /// deep sleeping
+    pub(crate) fn set_deep_sleeping(&self, val: bool) {
+        self.state.deep_sleeping.store(val, Ordering::SeqCst);
+    }
+
+    /// Reads a flag that determines if this thread is currently
+    /// deep sleeping
+    pub(crate) fn is_deep_sleeping(&self) -> bool {
+        self.state.deep_sleeping.load(Ordering::SeqCst)
+    }
+
+    /// Sets a flag that tells others that this thread is currently
+    /// check pointing itself
+    #[cfg(feature = "journal")]
+    pub(crate) fn set_checkpointing(&self, val: bool) {
+        self.state.check_pointing.store(val, Ordering::SeqCst);
+    }
+
+    /// Reads a flag that determines if this thread is currently
+    /// check pointing itself or not
+    #[cfg(feature = "journal")]
+    pub(crate) fn is_check_pointing(&self) -> bool {
+        self.state.check_pointing.load(Ordering::SeqCst)
+    }
+
+    /// Gets the memory layout for this thread
+    #[allow(dead_code)]
+    pub(crate) fn memory_layout(&self) -> &WasiMemoryLayout {
+        &self.layout
+    }
+
+    /// Gets the memory layout for this thread
+    pub(crate) fn set_memory_layout(&mut self, layout: WasiMemoryLayout) {
+        self.layout = layout;
+    }
+}
+
+/// A guard that ensures a thread is marked as terminated when dropped.
+///
+/// Normally the thread result should be manually registered with
+/// [`WasiThread::set_status_running`] or [`WasiThread::set_status_finished`],
+/// but this guard can ensure that the thread is marked as terminated even if
+/// this is forgotten or a panic occurs.
+pub struct WasiThreadRunGuard {
+    pub thread: WasiThread,
+}
+
+impl WasiThreadRunGuard {
+    pub fn new(thread: WasiThread) -> Self {
+        Self { thread }
+    }
+}
+
+impl Drop for WasiThreadRunGuard {
+    fn drop(&mut self) {
+        self.thread
+            .set_status_finished(Err(
+                crate::RuntimeError::new("Thread manager disconnected").into()
+            ));
+    }
+}
+
+/// Represents the memory layout of the parts that the thread itself uses
+pub use wasmer_wasix_types::wasix::WasiMemoryLayout;
+
+#[derive(Clone, Debug)]
+pub enum RewindResultType {
+    // The rewind must restart the operation it had already started
+    RewindRestart,
+    // The rewind has been triggered and should be handled but has not result
+    RewindWithoutResult,
+    // The rewind has been triggered and should be handled with the supplied result
+    RewindWithResult(Bytes),
+}
+
+// Contains the result of a rewind operation
+#[derive(Clone, Debug)]
+pub(crate) struct RewindResult {
+    /// Memory stack used to restore the memory stack (thing that holds local variables) back to where it was
+    pub memory_stack: Option<Bytes>,
+    /// Generic serialized object passed back to the rewind resumption code
+    /// (uses the bincode serializer)
+    pub rewind_result: RewindResultType,
+}
+
+#[derive(Debug)]
+struct WasiThreadState {
+    is_main: bool,
+    pid: WasiProcessId,
+    id: WasiThreadId,
+    signals: Mutex<(Vec<Signal>, Vec<Waker>)>,
+    stack: Mutex<ThreadStack>,
+    status: Arc<OwnedTaskStatus>,
+    #[cfg(feature = "journal")]
+    check_pointing: AtomicBool,
+    deep_sleeping: AtomicBool,
+
+    // Registers the task termination with the ControlPlane on drop.
+    // Never accessed, since it's a drop guard.
+    _task_count_guard: TaskCountGuard,
+}
+
+static NO_MORE_BYTES: [u8; 0] = [0u8; 0];
+
+impl WasiThread {
+    pub fn new(
+        pid: WasiProcessId,
+        id: WasiThreadId,
+        is_main: bool,
+        status: Arc<OwnedTaskStatus>,
+        guard: TaskCountGuard,
+        layout: WasiMemoryLayout,
+        start: ThreadStartType,
+    ) -> Self {
+        Self {
+            state: Arc::new(WasiThreadState {
+                is_main,
+                pid,
+                id,
+                status,
+                signals: Mutex::new((Vec::new(), Vec::new())),
+                stack: Mutex::new(ThreadStack::default()),
+                #[cfg(feature = "journal")]
+                check_pointing: AtomicBool::new(false),
+                deep_sleeping: AtomicBool::new(false),
+                _task_count_guard: guard,
+            }),
+            layout,
+            start,
+            rewind: None,
+        }
+    }
+
+    /// Returns the process ID
+    pub fn pid(&self) -> WasiProcessId {
+        self.state.pid
+    }
+
+    /// Returns the thread ID
+    pub fn tid(&self) -> WasiThreadId {
+        self.state.id
+    }
+
+    /// Returns true if this thread is the main thread
+    pub fn is_main(&self) -> bool {
+        self.state.is_main
+    }
+
+    /// Get a join handle to watch the task status.
+    pub fn join_handle(&self) -> TaskJoinHandle {
+        self.state.status.handle()
+    }
+
+    // TODO: this should be private, access should go through utility methods.
+    pub fn signals(&self) -> &Mutex<(Vec<Signal>, Vec<Waker>)> {
+        &self.state.signals
+    }
+
+    pub fn set_status_running(&self) {
+        self.state.status.set_running();
+    }
+
+    /// Gets or sets the exit code based of a signal that was received
+    /// Note: if the exit code was already set earlier this method will
+    /// just return that earlier set exit code
+    pub fn set_or_get_exit_code_for_signal(&self, sig: Signal) -> ExitCode {
+        let default_exitcode: ExitCode = match sig {
+            Signal::Sigquit | Signal::Sigabrt => Errno::Success.into(),
+            _ => Errno::Intr.into(),
+        };
+        // This will only set the status code if its not already set
+        self.set_status_finished(Ok(default_exitcode));
+        self.try_join()
+            .map(|r| r.unwrap_or(default_exitcode))
+            .unwrap_or(default_exitcode)
+    }
+
+    /// Marks the thread as finished (which will cause anyone that
+    /// joined on it to wake up)
+    pub fn set_status_finished(&self, res: Result<ExitCode, WasiRuntimeError>) {
+        self.state.status.set_finished(res.map_err(Arc::new));
+    }
+
+    /// Waits until the thread is finished or the timeout is reached
+    pub async fn join(&self) -> Result<ExitCode, Arc<WasiRuntimeError>> {
+        self.state.status.await_termination().await
+    }
+
+    /// Attempts to join on the thread
+    pub fn try_join(&self) -> Option<Result<ExitCode, Arc<WasiRuntimeError>>> {
+        self.state.status.status().into_finished()
+    }
+
+    /// Adds a signal for this thread to process
+    pub fn signal(&self, signal: Signal) {
+        let mut guard = self.state.signals.lock().unwrap();
+        if !guard.0.contains(&signal) {
+            guard.0.push(signal);
+        }
+        guard.1.drain(..).for_each(|w| w.wake());
+    }
+
+    /// Returns all the signals that are waiting to be processed
+    pub fn has_signal(&self, signals: &[Signal]) -> bool {
+        let guard = self.state.signals.lock().unwrap();
+        for s in guard.0.iter() {
+            if signals.contains(s) {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Waits for a signal to arrive
+    pub async fn wait_for_signal(&self) {
+        // This poller will process any signals when the main working function is idle
+        struct SignalPoller<'a> {
+            thread: &'a WasiThread,
+        }
+        impl<'a> std::future::Future for SignalPoller<'a> {
+            type Output = ();
+            fn poll(
+                self: std::pin::Pin<&mut Self>,
+                cx: &mut std::task::Context<'_>,
+            ) -> std::task::Poll<Self::Output> {
+                if self.thread.has_signals_or_subscribe(cx.waker()) {
+                    return std::task::Poll::Ready(());
+                }
+                std::task::Poll::Pending
+            }
+        }
+        SignalPoller { thread: self }.await
+    }
+
+    /// Returns all the signals that are waiting to be processed
+    pub fn pop_signals_or_subscribe(&self, waker: &Waker) -> Option<Vec<Signal>> {
+        let mut guard = self.state.signals.lock().unwrap();
+        let mut ret = Vec::new();
+        std::mem::swap(&mut ret, &mut guard.0);
+        match ret.is_empty() {
+            true => {
+                if !guard.1.iter().any(|w| w.will_wake(waker)) {
+                    guard.1.push(waker.clone());
+                }
+                None
+            }
+            false => Some(ret),
+        }
+    }
+
+    /// Returns all the signals that are waiting to be processed
+    pub fn has_signals_or_subscribe(&self, waker: &Waker) -> bool {
+        let mut guard = self.state.signals.lock().unwrap();
+        let has_signals = !guard.0.is_empty();
+        if !has_signals && !guard.1.iter().any(|w| w.will_wake(waker)) {
+            guard.1.push(waker.clone());
+        }
+        has_signals
+    }
+
+    /// Returns all the signals that are waiting to be processed
+    pub fn pop_signals(&self) -> Vec<Signal> {
+        let mut guard = self.state.signals.lock().unwrap();
+        let mut ret = Vec::new();
+        std::mem::swap(&mut ret, &mut guard.0);
+        ret
+    }
+
+    /// Adds a stack snapshot and removes dead ones
+    pub fn add_snapshot(
+        &self,
+        mut memory_stack: &[u8],
+        mut memory_stack_corrected: &[u8],
+        hash: u128,
+        rewind_stack: &[u8],
+        store_data: &[u8],
+    ) {
+        // Lock the stack
+        let mut stack = self.state.stack.lock().unwrap();
+        let mut pstack = stack.deref_mut();
+        loop {
+            // First we validate if the stack is no longer valid
+            let memory_stack_before = pstack.memory_stack.len();
+            let memory_stack_after = memory_stack.len();
+            if memory_stack_before > memory_stack_after
+                || (!pstack
+                    .memory_stack
+                    .iter()
+                    .zip(memory_stack.iter())
+                    .any(|(a, b)| *a == *b)
+                    && !pstack
+                        .memory_stack_corrected
+                        .iter()
+                        .zip(memory_stack.iter())
+                        .any(|(a, b)| *a == *b))
+            {
+                // The stacks have changed so need to start again at this segment
+                let mut new_stack = ThreadStack {
+                    memory_stack: memory_stack.to_vec(),
+                    memory_stack_corrected: memory_stack_corrected.to_vec(),
+                    ..Default::default()
+                };
+                std::mem::swap(pstack, &mut new_stack);
+                memory_stack = &NO_MORE_BYTES[..];
+                memory_stack_corrected = &NO_MORE_BYTES[..];
+
+                // Output debug info for the dead stack
+                let mut disown = Some(Box::new(new_stack));
+                if let Some(disown) = disown.as_ref() {
+                    if !disown.snapshots.is_empty() {
+                        tracing::trace!(
+                            "wasi[{}]::stacks forgotten (memory_stack_before={}, memory_stack_after={})",
+                            self.pid(),
+                            memory_stack_before,
+                            memory_stack_after
+                        );
+                    }
+                }
+                while let Some(disowned) = disown {
+                    for hash in disowned.snapshots.keys() {
+                        tracing::trace!(
+                            "wasi[{}]::stack has been forgotten (hash={})",
+                            self.pid(),
+                            hash
+                        );
+                    }
+                    disown = disowned.next;
+                }
+            } else {
+                memory_stack = &memory_stack[pstack.memory_stack.len()..];
+                memory_stack_corrected =
+                    &memory_stack_corrected[pstack.memory_stack_corrected.len()..];
+            }
+
+            // If there is no more memory stack then we are done and can add the call stack
+            if memory_stack.is_empty() {
+                break;
+            }
+
+            // Otherwise we need to add a next stack pointer and continue the iterations
+            if pstack.next.is_none() {
+                let new_stack = ThreadStack {
+                    memory_stack: memory_stack.to_vec(),
+                    memory_stack_corrected: memory_stack_corrected.to_vec(),
+                    ..Default::default()
+                };
+                pstack.next.replace(Box::new(new_stack));
+            }
+            pstack = pstack.next.as_mut().unwrap();
+        }
+
+        // Add the call stack
+        pstack.snapshots.insert(
+            hash,
+            ThreadSnapshot {
+                call_stack: BytesMut::from(rewind_stack).freeze(),
+                store_data: BytesMut::from(store_data).freeze(),
+            },
+        );
+    }
+
+    /// Gets a snapshot that was previously addedf
+    pub fn get_snapshot(&self, hash: u128) -> Option<(BytesMut, Bytes, Bytes)> {
+        let mut memory_stack = BytesMut::new();
+
+        let stack = self.state.stack.lock().unwrap();
+        let mut pstack = stack.deref();
+        loop {
+            memory_stack.extend(pstack.memory_stack_corrected.iter());
+            if let Some(snapshot) = pstack.snapshots.get(&hash) {
+                return Some((
+                    memory_stack,
+                    snapshot.call_stack.clone(),
+                    snapshot.store_data.clone(),
+                ));
+            }
+            if let Some(next) = pstack.next.as_ref() {
+                pstack = next.deref();
+            } else {
+                return None;
+            }
+        }
+    }
+
+    // Copy the stacks from another thread
+    pub fn copy_stack_from(&self, other: &WasiThread) {
+        let mut stack = {
+            let stack_guard = other.state.stack.lock().unwrap();
+            stack_guard.clone()
+        };
+
+        let mut stack_guard = self.state.stack.lock().unwrap();
+        std::mem::swap(stack_guard.deref_mut(), &mut stack);
+    }
+}
+
+#[derive(Debug)]
+pub struct WasiThreadHandleProtected {
+    thread: WasiThread,
+    inner: Weak<(Mutex<WasiProcessInner>, Condvar)>,
+}
+
+#[derive(Debug, Clone)]
+pub struct WasiThreadHandle {
+    protected: Arc<WasiThreadHandleProtected>,
+}
+
+impl WasiThreadHandle {
+    pub(crate) fn new(
+        thread: WasiThread,
+        inner: &Arc<(Mutex<WasiProcessInner>, Condvar)>,
+    ) -> WasiThreadHandle {
+        Self {
+            protected: Arc::new(WasiThreadHandleProtected {
+                thread,
+                inner: Arc::downgrade(inner),
+            }),
+        }
+    }
+
+    pub fn id(&self) -> WasiThreadId {
+        self.protected.thread.tid()
+    }
+
+    pub fn as_thread(&self) -> WasiThread {
+        self.protected.thread.clone()
+    }
+}
+
+impl Drop for WasiThreadHandleProtected {
+    fn drop(&mut self) {
+        let id = self.thread.tid();
+        if let Some(inner) = Weak::upgrade(&self.inner) {
+            let mut inner = inner.0.lock().unwrap();
+            if let Some(ctrl) = inner.threads.remove(&id) {
+                ctrl.set_status_finished(Ok(Errno::Success.into()));
+            }
+            inner.thread_count -= 1;
+        }
+    }
+}
+
+impl std::ops::Deref for WasiThreadHandle {
+    type Target = WasiThread;
+
+    fn deref(&self) -> &Self::Target {
+        &self.protected.thread
+    }
+}
+
+#[derive(thiserror::Error, Debug, Clone)]
+pub enum WasiThreadError {
+    #[error("Multithreading is not supported")]
+    Unsupported,
+    #[error("The method named is not an exported function")]
+    MethodNotFound,
+    #[error("Failed to create the requested memory - {0}")]
+    MemoryCreateFailed(MemoryError),
+    #[error("{0}")]
+    ExportError(ExportError),
+    #[error("Failed to create the instance")]
+    // Note: Boxed so we can keep the error size down
+    InstanceCreateFailed(Box<InstantiationError>),
+    #[error("Initialization function failed - {0}")]
+    InitFailed(Arc<anyhow::Error>),
+    /// This will happen if WASM is running in a thread has not been created by the spawn_wasm call
+    #[error("WASM context is invalid")]
+    InvalidWasmContext,
+}
+
+impl From<WasiThreadError> for Errno {
+    fn from(a: WasiThreadError) -> Errno {
+        match a {
+            WasiThreadError::Unsupported => Errno::Notsup,
+            WasiThreadError::MethodNotFound => Errno::Inval,
+            WasiThreadError::MemoryCreateFailed(_) => Errno::Nomem,
+            WasiThreadError::ExportError(_) => Errno::Noexec,
+            WasiThreadError::InstanceCreateFailed(_) => Errno::Noexec,
+            WasiThreadError::InitFailed(_) => Errno::Noexec,
+            WasiThreadError::InvalidWasmContext => Errno::Noexec,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/mod.rs
new file mode 100644
index 0000000..dc2ed6c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/mod.rs
@@ -0,0 +1,456 @@
+use std::{
+    borrow::Cow,
+    sync::{Arc, Mutex},
+};
+
+use derivative::*;
+use futures::future::BoxFuture;
+use virtual_fs::{AsyncWriteExt, NullFile, VirtualFile};
+use wasmer_wasix_types::wasi::{Signal, Snapshot0Clockid};
+
+use crate::syscalls::platform_clock_time_get;
+
+use super::task::signal::SignalHandlerAbi;
+
+const TTY_MOBILE_PAUSE: u128 = std::time::Duration::from_millis(200).as_nanos();
+
+pub mod tty_sys;
+
+#[derive(Debug)]
+pub enum InputEvent {
+    Key,
+    Data(String),
+    Raw(Vec<u8>),
+}
+
+#[derive(Clone, Debug)]
+pub struct ConsoleRect {
+    pub cols: u32,
+    pub rows: u32,
+}
+
+impl Default for ConsoleRect {
+    fn default() -> Self {
+        Self { cols: 80, rows: 25 }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct TtyOptionsInner {
+    echo: bool,
+    line_buffering: bool,
+    line_feeds: bool,
+    rect: ConsoleRect,
+}
+
+#[derive(Debug, Clone)]
+pub struct TtyOptions {
+    inner: Arc<Mutex<TtyOptionsInner>>,
+}
+
+impl Default for TtyOptions {
+    fn default() -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(TtyOptionsInner {
+                echo: true,
+                line_buffering: true,
+                line_feeds: true,
+                rect: ConsoleRect { cols: 80, rows: 25 },
+            })),
+        }
+    }
+}
+
+impl TtyOptions {
+    pub fn cols(&self) -> u32 {
+        let inner = self.inner.lock().unwrap();
+        inner.rect.cols
+    }
+
+    pub fn set_cols(&self, cols: u32) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.rect.cols = cols;
+    }
+
+    pub fn rows(&self) -> u32 {
+        let inner = self.inner.lock().unwrap();
+        inner.rect.rows
+    }
+
+    pub fn set_rows(&self, rows: u32) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.rect.rows = rows;
+    }
+
+    pub fn echo(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.echo
+    }
+
+    pub fn set_echo(&self, echo: bool) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.echo = echo;
+    }
+
+    pub fn line_buffering(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.line_buffering
+    }
+
+    pub fn set_line_buffering(&self, line_buffering: bool) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.line_buffering = line_buffering;
+    }
+
+    pub fn line_feeds(&self) -> bool {
+        let inner = self.inner.lock().unwrap();
+        inner.line_feeds
+    }
+
+    pub fn set_line_feeds(&self, line_feeds: bool) {
+        let mut inner = self.inner.lock().unwrap();
+        inner.line_feeds = line_feeds;
+    }
+}
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct Tty {
+    stdin: Box<dyn VirtualFile + Send + Sync + 'static>,
+    stdout: Box<dyn VirtualFile + Send + Sync + 'static>,
+    signaler: Option<Box<dyn SignalHandlerAbi + Send + Sync + 'static>>,
+    is_mobile: bool,
+    last: Option<(String, u128)>,
+    options: TtyOptions,
+    line: String,
+}
+
+impl Tty {
+    pub fn new(
+        stdin: Box<dyn VirtualFile + Send + Sync + 'static>,
+        stdout: Box<dyn VirtualFile + Send + Sync + 'static>,
+        is_mobile: bool,
+        options: TtyOptions,
+    ) -> Self {
+        Self {
+            stdin,
+            stdout,
+            signaler: None,
+            last: None,
+            options,
+            is_mobile,
+            line: String::new(),
+        }
+    }
+
+    pub fn stdin(&self) -> &(dyn VirtualFile + Send + Sync + 'static) {
+        self.stdin.as_ref()
+    }
+
+    pub fn stdin_mut(&mut self) -> &mut (dyn VirtualFile + Send + Sync + 'static) {
+        self.stdin.as_mut()
+    }
+
+    pub fn stdin_replace(
+        &mut self,
+        mut stdin: Box<dyn VirtualFile + Send + Sync + 'static>,
+    ) -> Box<dyn VirtualFile + Send + Sync + 'static> {
+        std::mem::swap(&mut self.stdin, &mut stdin);
+        stdin
+    }
+
+    pub fn stdin_take(&mut self) -> Box<dyn VirtualFile + Send + Sync + 'static> {
+        let mut stdin: Box<dyn VirtualFile + Send + Sync + 'static> = Box::<NullFile>::default();
+        std::mem::swap(&mut self.stdin, &mut stdin);
+        stdin
+    }
+
+    pub fn options(&self) -> TtyOptions {
+        self.options.clone()
+    }
+
+    pub fn set_signaler(&mut self, signaler: Box<dyn SignalHandlerAbi + Send + Sync + 'static>) {
+        self.signaler.replace(signaler);
+    }
+
+    pub fn on_event(mut self, event: InputEvent) -> BoxFuture<'static, Self> {
+        Box::pin(async move {
+            match event {
+                InputEvent::Key => {
+                    // do nothing
+                    self
+                }
+                InputEvent::Data(data) => {
+                    // Due to a nasty bug in xterm.js on Android mobile it sends the keys you press
+                    // twice in a row with a short interval between - this hack will avoid that bug
+                    if self.is_mobile {
+                        let now = platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000)
+                            .unwrap() as u128;
+                        if let Some((what, when)) = self.last.as_ref() {
+                            if what.as_str() == data && now - *when < TTY_MOBILE_PAUSE {
+                                self.last = None;
+                                return self;
+                            }
+                        }
+                        self.last = Some((data.clone(), now))
+                    }
+
+                    self.on_data(data.as_bytes().to_vec().into()).await
+                }
+                InputEvent::Raw(data) => self.on_data(data.into()).await,
+            }
+        })
+    }
+
+    fn on_enter(mut self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move {
+            // Add a line feed on the end and take the line
+            let mut data = self.line.clone();
+            self.line.clear();
+            data.push('\n');
+
+            // If echo is on then write a new line
+            {
+                let echo = {
+                    let options = self.options.inner.lock().unwrap();
+                    options.echo
+                };
+                if echo {
+                    let _ = self.stdout.write("\n".as_bytes()).await;
+                }
+            }
+
+            // Send the data to the process
+            let _ = self.stdin.write(data.as_bytes()).await;
+            self
+        })
+    }
+
+    fn on_ctrl_c(mut self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move {
+            if let Some(signaler) = self.signaler.as_ref() {
+                signaler.signal(Signal::Sigint as u8).ok();
+
+                let (echo, _line_buffering) = {
+                    let options = self.options.inner.lock().unwrap();
+                    (options.echo, options.line_buffering)
+                };
+
+                self.line.clear();
+                if echo {
+                    let _ = self.stdout.write("\n".as_bytes()).await;
+                }
+            }
+            self
+        })
+    }
+
+    fn on_backspace(mut self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        // Remove a character (if there are none left we are done)
+        if self.line.is_empty() {
+            return Box::pin(async move { self });
+        }
+        let len = self.line.len();
+        self.line = self.line[..len - 1].to_string();
+
+        Box::pin(async move {
+            // If echo is on then write the backspace
+            {
+                let echo = {
+                    let options = self.options.inner.lock().unwrap();
+                    options.echo
+                };
+                if echo {
+                    let _ = self.stdout.write("\u{0008} \u{0008}".as_bytes()).await;
+                }
+            }
+            self
+        })
+    }
+
+    fn on_tab(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_cursor_left(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_cursor_right(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_cursor_up(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_cursor_down(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_home(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_end(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_ctrl_l(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_page_up(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_page_down(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f1(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f2(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f3(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f4(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f5(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f6(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f7(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f8(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f9(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f10(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f11(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_f12(self, _data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        Box::pin(async move { self })
+    }
+
+    fn on_data(mut self, data: Cow<'static, [u8]>) -> BoxFuture<'static, Self> {
+        // If we are line buffering then we need to check for some special cases
+        let options = { self.options.inner.lock().unwrap().clone() };
+        if options.line_buffering {
+            let echo = options.echo;
+            return match String::from_utf8_lossy(data.as_ref()).as_ref() {
+                "\r" | "\u{000A}" => self.on_enter(data),
+                "\u{0003}" => self.on_ctrl_c(data),
+                "\u{007F}" => self.on_backspace(data),
+                "\u{0009}" => self.on_tab(data),
+                "\u{001B}\u{005B}\u{0044}" => self.on_cursor_left(data),
+                "\u{001B}\u{005B}\u{0043}" => self.on_cursor_right(data),
+                "\u{0001}" | "\u{001B}\u{005B}\u{0048}" => self.on_home(data),
+                "\u{001B}\u{005B}\u{0046}" => self.on_end(data),
+                "\u{001B}\u{005B}\u{0041}" => self.on_cursor_up(data),
+                "\u{001B}\u{005B}\u{0042}" => self.on_cursor_down(data),
+                "\u{000C}" => self.on_ctrl_l(data),
+                "\u{001B}\u{005B}\u{0035}\u{007E}" => self.on_page_up(data),
+                "\u{001B}\u{005B}\u{0036}\u{007E}" => self.on_page_down(data),
+                "\u{001B}\u{004F}\u{0050}" => self.on_f1(data),
+                "\u{001B}\u{004F}\u{0051}" => self.on_f2(data),
+                "\u{001B}\u{004F}\u{0052}" => self.on_f3(data),
+                "\u{001B}\u{004F}\u{0053}" => self.on_f4(data),
+                "\u{001B}\u{005B}\u{0031}\u{0035}\u{007E}" => self.on_f5(data),
+                "\u{001B}\u{005B}\u{0031}\u{0037}\u{007E}" => self.on_f6(data),
+                "\u{001B}\u{005B}\u{0031}\u{0038}\u{007E}" => self.on_f7(data),
+                "\u{001B}\u{005B}\u{0031}\u{0039}\u{007E}" => self.on_f8(data),
+                "\u{001B}\u{005B}\u{0032}\u{0030}\u{007E}" => self.on_f9(data),
+                "\u{001B}\u{005B}\u{0032}\u{0031}\u{007E}" => self.on_f10(data),
+                "\u{001B}\u{005B}\u{0032}\u{0033}\u{007E}" => self.on_f11(data),
+                "\u{001B}\u{005B}\u{0032}\u{0034}\u{007E}" => self.on_f12(data),
+                _ => Box::pin(async move {
+                    if echo {
+                        let _ = self.stdout.write(data.as_ref()).await;
+                    }
+                    self.line
+                        .push_str(String::from_utf8_lossy(data.as_ref()).as_ref());
+                    self
+                }),
+            };
+        };
+
+        Box::pin(async move {
+            // If the echo is enabled then write it to the terminal
+            if options.echo {
+                // TODO: log / propagate error?
+                let _ = self.stdout.write(data.as_ref()).await;
+            }
+
+            // Now send it to the process
+            let _ = self.stdin.write(data.as_ref()).await;
+            self
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct WasiTtyState {
+    pub cols: u32,
+    pub rows: u32,
+    pub width: u32,
+    pub height: u32,
+    pub stdin_tty: bool,
+    pub stdout_tty: bool,
+    pub stderr_tty: bool,
+    pub echo: bool,
+    pub line_buffered: bool,
+    pub line_feeds: bool,
+}
+
+impl Default for WasiTtyState {
+    fn default() -> Self {
+        Self {
+            rows: 80,
+            cols: 25,
+            width: 800,
+            height: 600,
+            stdin_tty: true,
+            stdout_tty: true,
+            stderr_tty: true,
+            echo: false,
+            line_buffered: false,
+            line_feeds: true,
+        }
+    }
+}
+
+/// Provides access to a TTY.
+pub trait TtyBridge {
+    /// Resets the values
+    fn reset(&self);
+
+    /// Retrieve the current TTY state.
+    fn tty_get(&self) -> WasiTtyState;
+
+    /// Set the TTY state.
+    fn tty_set(&self, _tty_state: WasiTtyState);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/tty_sys.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/tty_sys.rs
new file mode 100644
index 0000000..fbbf9cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/os/tty/tty_sys.rs
@@ -0,0 +1,276 @@
+use super::TtyBridge;
+use crate::WasiTtyState;
+
+/// [`TtyBridge`] implementation for Unix systems.
+#[derive(Debug, Default, Clone)]
+pub struct SysTty;
+
+impl TtyBridge for SysTty {
+    fn reset(&self) {
+        sys::reset().ok();
+    }
+
+    fn tty_get(&self) -> WasiTtyState {
+        let echo = sys::is_mode_echo();
+        let line_buffered = sys::is_mode_line_buffering();
+        let line_feeds = sys::is_mode_line_feeds();
+        let stdin_tty = sys::is_stdin_tty();
+        let stdout_tty = sys::is_stdout_tty();
+        let stderr_tty = sys::is_stderr_tty();
+
+        if let Some((w, h)) = term_size::dimensions() {
+            WasiTtyState {
+                cols: w as u32,
+                rows: h as u32,
+                width: 800,
+                height: 600,
+                stdin_tty,
+                stdout_tty,
+                stderr_tty,
+                echo,
+                line_buffered,
+                line_feeds,
+            }
+        } else {
+            WasiTtyState {
+                rows: 80,
+                cols: 25,
+                width: 800,
+                height: 600,
+                stdin_tty,
+                stdout_tty,
+                stderr_tty,
+                echo,
+                line_buffered,
+                line_feeds,
+            }
+        }
+    }
+
+    fn tty_set(&self, tty_state: WasiTtyState) {
+        if tty_state.echo {
+            sys::set_mode_echo().ok();
+        } else {
+            sys::set_mode_no_echo().ok();
+        }
+        if tty_state.line_buffered {
+            sys::set_mode_line_buffered().ok();
+        } else {
+            sys::set_mode_no_line_buffered().ok();
+        }
+        if tty_state.line_feeds {
+            sys::set_mode_line_feeds().ok();
+        } else {
+            sys::set_mode_no_line_feeds().ok();
+        }
+    }
+}
+
+#[allow(unused_mut)]
+#[cfg(all(unix, not(target_os = "ios")))]
+mod sys {
+    #![allow(unused_imports)]
+    use {
+        libc::{
+            c_int, tcsetattr, termios, ECHO, ECHOCTL, ECHOE, ECHOK, ECHONL, ICANON, ICRNL, IEXTEN,
+            IGNCR, ISIG, IXON, ONLCR, OPOST, TCSANOW,
+        },
+        std::mem,
+        std::os::unix::io::AsRawFd,
+    };
+
+    fn io_result(ret: libc::c_int) -> std::io::Result<()> {
+        match ret {
+            0 => Ok(()),
+            _ => Err(std::io::Error::last_os_error()),
+        }
+    }
+
+    pub fn reset() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag |= ISIG | ICANON | IEXTEN | ECHO | ECHOE | ECHOK | ECHOCTL;
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn is_stdin_tty() -> bool {
+        ::termios::Termios::from_fd(0).is_ok()
+    }
+
+    pub fn is_stdout_tty() -> bool {
+        ::termios::Termios::from_fd(1).is_ok()
+    }
+
+    pub fn is_stderr_tty() -> bool {
+        ::termios::Termios::from_fd(2).is_ok()
+    }
+
+    pub fn is_mode_echo() -> bool {
+        if let Ok(termios) = ::termios::Termios::from_fd(0) {
+            (termios.c_lflag & ::termios::ECHO) != 0
+        } else {
+            false
+        }
+    }
+
+    pub fn is_mode_line_buffering() -> bool {
+        if let Ok(termios) = ::termios::Termios::from_fd(0) {
+            (termios.c_lflag & ::termios::ICANON) != 0
+        } else {
+            false
+        }
+    }
+
+    pub fn is_mode_line_feeds() -> bool {
+        if let Ok(termios) = ::termios::Termios::from_fd(0) {
+            (termios.c_lflag & ::termios::ONLCR) != 0
+        } else {
+            false
+        }
+    }
+
+    pub fn set_mode_no_echo() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag &= !ECHO;
+        termios.c_lflag &= !ECHOE;
+        termios.c_lflag &= !ECHOK;
+        termios.c_lflag &= !ECHOCTL;
+        termios.c_lflag &= !IEXTEN;
+        /*
+        termios.c_lflag &= !ISIG;
+        termios.c_lflag &= !IXON;
+        termios.c_lflag &= !ICRNL;
+        termios.c_lflag &= !OPOST;
+        */
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn set_mode_echo() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag |= ECHO;
+        termios.c_lflag |= ECHOE;
+        termios.c_lflag |= ECHOK;
+        termios.c_lflag |= ECHOCTL;
+        termios.c_lflag |= IEXTEN;
+        /*
+        termios.c_lflag |= ISIG;
+        termios.c_lflag |= IXON;
+        termios.c_lflag |= ICRNL;
+        termios.c_lflag |= OPOST;
+        */
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn set_mode_no_line_buffered() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag &= !ICANON;
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn set_mode_line_buffered() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag |= ICANON;
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn set_mode_no_line_feeds() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag &= !ONLCR;
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+
+    pub fn set_mode_line_feeds() -> Result<(), anyhow::Error> {
+        let mut termios = mem::MaybeUninit::<termios>::uninit();
+        io_result(unsafe { ::libc::tcgetattr(0, termios.as_mut_ptr()) })?;
+        let mut termios = unsafe { termios.assume_init() };
+
+        termios.c_lflag |= ONLCR;
+
+        unsafe { tcsetattr(0, TCSANOW, &termios) };
+        Ok(())
+    }
+}
+
+#[cfg(any(not(unix), target_os = "ios"))]
+mod sys {
+    pub fn reset() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn is_stdin_tty() -> bool {
+        false
+    }
+
+    pub fn is_stdout_tty() -> bool {
+        false
+    }
+
+    pub fn is_stderr_tty() -> bool {
+        false
+    }
+
+    pub fn is_mode_echo() -> bool {
+        true
+    }
+
+    pub fn is_mode_line_buffering() -> bool {
+        true
+    }
+
+    pub fn is_mode_line_feeds() -> bool {
+        true
+    }
+
+    pub fn set_mode_no_echo() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn set_mode_echo() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn set_mode_no_line_buffered() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn set_mode_line_buffered() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn set_mode_no_line_feeds() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+
+    pub fn set_mode_line_feeds() -> Result<(), anyhow::Error> {
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/rewind.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/rewind.rs
new file mode 100644
index 0000000..fb3810b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/rewind.rs
@@ -0,0 +1,60 @@
+use std::pin::Pin;
+
+use bytes::Bytes;
+use futures::Future;
+use wasmer_wasix_types::{
+    wasi::Errno,
+    wasix::{ThreadStartType, WasiMemoryLayout},
+};
+
+use crate::os::task::thread::RewindResultType;
+
+/// Future that will be polled by asyncify methods
+#[doc(hidden)]
+pub type AsyncifyFuture = dyn Future<Output = Bytes> + Send + Sync + 'static;
+
+/// Trait that will be invoked after the rewind has finished
+/// It is possible that the process will be terminated rather
+/// than restored at this point
+pub trait RewindPostProcess {
+    /// Returns the serialized object that is returned on the rewind
+    fn finish(&mut self, res: Result<(), Errno>) -> Bytes;
+}
+
+/// The rewind state after a deep sleep
+pub struct RewindState {
+    /// Memory stack used to restore the stack trace back to where it was
+    pub memory_stack: Bytes,
+    /// Call stack used to restore the stack trace back to where it was
+    pub rewind_stack: Bytes,
+    /// All the global data stored in the store
+    pub store_data: Bytes,
+    /// Describes the type of thread start
+    pub start: ThreadStartType,
+    /// Layout of the memory,
+    pub layout: WasiMemoryLayout,
+    /// Flag that indicates if this rewind is 64-bit or 32-bit memory based
+    pub is_64bit: bool,
+}
+
+pub type RewindStateOption = Option<(RewindState, RewindResultType)>;
+
+/// Represents the work that will be done when a thread goes to deep sleep and
+/// includes the things needed to restore it again
+pub struct DeepSleepWork {
+    /// This is the work that will be performed before the thread is rewoken
+    pub trigger: Pin<Box<AsyncifyFuture>>,
+    /// State that the thread will be rewound to
+    pub rewind: RewindState,
+}
+impl std::fmt::Debug for DeepSleepWork {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "deep-sleep-work(memory_stack_len={}, rewind_stack_len={}, store_size={})",
+            self.rewind.memory_stack.len(),
+            self.rewind.rewind_stack.len(),
+            self.rewind.store_data.len()
+        )
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/callbacks.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/callbacks.rs
new file mode 100644
index 0000000..87b430b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/callbacks.rs
@@ -0,0 +1,87 @@
+use std::sync::Arc;
+
+use derivative::Derivative;
+
+use super::*;
+use crate::runners::wcgi::{self, CreateEnvConfig, CreateEnvResult, RecycleEnvConfig};
+use virtual_fs::NullFile;
+use wasmer_wasix_types::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO};
+
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct DcgiCallbacks {
+    #[derivative(Debug = "ignore")]
+    inner: Arc<dyn wcgi::Callbacks>,
+    factory: DcgiInstanceFactory,
+}
+
+impl DcgiCallbacks {
+    pub fn new<C>(factory: DcgiInstanceFactory, inner: C) -> Self
+    where
+        C: wcgi::Callbacks,
+    {
+        Self {
+            inner: Arc::new(inner),
+            factory,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl wcgi::Callbacks for DcgiCallbacks {
+    fn started(&self, abort: AbortHandle) {
+        self.inner.started(abort)
+    }
+
+    fn on_stderr(&self, stderr: &[u8]) {
+        self.inner.on_stderr(stderr)
+    }
+
+    fn on_stderr_error(&self, error: std::io::Error) {
+        self.inner.on_stderr_error(error)
+    }
+
+    async fn recycle_env(&self, conf: RecycleEnvConfig) {
+        tracing::debug!("recycling DCGI instance");
+
+        // The stdio have to be reattached on each call as they are
+        // read to completion (EOF) during nominal flows
+        conf.env
+            .state
+            .fs
+            .swap_file(__WASI_STDIN_FILENO, Box::<NullFile>::default())
+            .ok();
+        conf.env
+            .state
+            .fs
+            .swap_file(__WASI_STDOUT_FILENO, Box::<NullFile>::default())
+            .ok();
+        conf.env
+            .state
+            .fs
+            .swap_file(__WASI_STDERR_FILENO, Box::<NullFile>::default())
+            .ok();
+
+        // Now we make the instance available for reuse
+        self.factory.release(conf).await;
+    }
+
+    async fn create_env(&self, mut conf: CreateEnvConfig) -> anyhow::Result<CreateEnvResult> {
+        tracing::debug!("attempting to acquire existing DCGI instance");
+
+        if let Some(res) = self.factory.acquire(&mut conf).await {
+            tracing::debug!("found existing DCGI instance");
+            return Ok(res);
+        }
+
+        let mut ret = self.inner.create_env(conf).await;
+
+        if let Ok(ret) = ret.as_mut() {
+            // We disable the cleanup to prevent the instance so that the
+            // resources can be reused
+            ret.env.disable_fs_cleanup = true;
+        }
+
+        ret
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/factory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/factory.rs
new file mode 100644
index 0000000..9e10a74
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/factory.rs
@@ -0,0 +1,105 @@
+use std::sync::{Arc, Mutex};
+
+use derivative::Derivative;
+use virtual_fs::Pipe;
+use wasmer_wasix_types::types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO};
+
+use crate::{
+    runners::wcgi::{CreateEnvConfig, CreateEnvResult, RecycleEnvConfig},
+    state::conv_env_vars,
+    WasiStateCreationError,
+};
+
+use super::*;
+
+#[derive(Debug, Default)]
+struct State {
+    /// Once the instance is running it will
+    instance: Option<DcgiInstance>,
+}
+
+/// This factory will store and reuse instances between invocations thus
+/// allowing for the instances to be stateful.
+#[derive(Derivative, Clone, Default)]
+#[derivative(Debug)]
+pub struct DcgiInstanceFactory {
+    state: Arc<Mutex<State>>,
+}
+
+impl DcgiInstanceFactory {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub async fn release(&self, conf: RecycleEnvConfig) {
+        let mut state = self.state.lock().unwrap();
+        state.instance.replace(DcgiInstance {
+            env: conf.env,
+            //memory: conf.memory,
+            //store: conf.store,
+        });
+    }
+
+    pub async fn acquire(&self, conf: &mut CreateEnvConfig) -> Option<CreateEnvResult> {
+        let mut state = self.state.lock().unwrap();
+        if let Some(inst) = state.instance.take() {
+            tracing::debug!("attempting to reinitialize DCGI instance");
+            match convert_instance(inst, conf) {
+                Ok(converted) => return Some(converted),
+                Err(err) => {
+                    tracing::warn!("failed to reinitialize DCGI instance - {}", err);
+                }
+            }
+        }
+
+        None
+    }
+}
+
+fn convert_instance(
+    inst: DcgiInstance,
+    conf: &mut CreateEnvConfig,
+) -> anyhow::Result<CreateEnvResult> {
+    let mut env = inst.env;
+
+    let (req_body_sender, req_body_receiver) = Pipe::channel();
+    let (res_body_sender, res_body_receiver) = Pipe::channel();
+    let (stderr_sender, stderr_receiver) = Pipe::channel();
+
+    env.reinit()?;
+
+    // Replace the environment variables as these will change
+    // depending on the WCGI call
+    *env.state.envs.lock().unwrap() = conv_env_vars(
+        conf.env
+            .iter()
+            .map(|(k, v)| (k.clone(), v.as_bytes().to_vec()))
+            .collect(),
+    );
+
+    // The stdio have to be reattached on each call as they are
+    // read to completion (EOF) during nominal flows
+    env.state
+        .fs
+        .swap_file(__WASI_STDIN_FILENO, Box::new(req_body_receiver))
+        .map_err(WasiStateCreationError::FileSystemError)?;
+
+    env.state
+        .fs
+        .swap_file(__WASI_STDOUT_FILENO, Box::new(res_body_sender))
+        .map_err(WasiStateCreationError::FileSystemError)?;
+
+    env.state
+        .fs
+        .swap_file(__WASI_STDERR_FILENO, Box::new(stderr_sender))
+        .map_err(WasiStateCreationError::FileSystemError)?;
+
+    Ok(CreateEnvResult {
+        env,
+        //memory: Some((inst.memory, inst.store)),
+        memory: None,
+        body_sender: req_body_sender,
+        body_receiver: res_body_receiver,
+        stderr_receiver,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/handler.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/handler.rs
new file mode 100644
index 0000000..627751f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/handler.rs
@@ -0,0 +1,76 @@
+use std::{ops::Deref, pin::Pin, sync::Arc, task::Poll};
+
+use anyhow::Error;
+use futures::{Future, FutureExt};
+use http::{Request, Response};
+use hyper::{service::Service, Body};
+
+use crate::runners::wcgi;
+
+use super::DcgiInstanceFactory;
+
+/// The shared object that manages the instantiaion of WASI executables and
+/// communicating with them via the CGI protocol.
+#[derive(Clone, Debug)]
+pub(crate) struct Handler {
+    state: Arc<SharedState>,
+    inner: wcgi::Handler,
+}
+
+impl Handler {
+    pub(crate) fn new(handler: wcgi::Handler) -> Self {
+        Handler {
+            state: Arc::new(SharedState {
+                inner: handler.deref().clone(),
+                factory: DcgiInstanceFactory::new(),
+                master_lock: Default::default(),
+            }),
+            inner: handler,
+        }
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, err)]
+    pub(crate) async fn handle(&self, req: Request<Body>) -> Result<Response<Body>, Error> {
+        // we acquire a guard token so that only one request at a time can be processed
+        // which effectively means that DCGI is single-threaded. This is a limitation
+        // of the MVP which should be rectified in future releases.
+        let guard_token = self.state.master_lock.clone().lock_owned().await;
+
+        // Process the request as a normal WCGI request
+        self.inner.handle(req, guard_token).await
+    }
+}
+
+impl Deref for Handler {
+    type Target = Arc<SharedState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.state
+    }
+}
+
+#[derive(derivative::Derivative, Clone)]
+#[derivative(Debug)]
+pub(crate) struct SharedState {
+    pub(crate) inner: Arc<wcgi::SharedState>,
+    factory: DcgiInstanceFactory,
+    master_lock: Arc<tokio::sync::Mutex<()>>,
+}
+
+impl Service<Request<Body>> for Handler {
+    type Response = Response<Body>;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Response<Body>, Error>> + Send>>;
+
+    fn poll_ready(&mut self, _cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        // TODO: We probably should implement some sort of backpressure here...
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: Request<Body>) -> Self::Future {
+        // Note: all fields are reference-counted so cloning is pretty cheap
+        let handler = self.clone();
+        let fut = async move { handler.handle(request).await };
+        fut.boxed()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/instance.rs
new file mode 100644
index 0000000..df04de1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/instance.rs
@@ -0,0 +1,10 @@
+//use wasmer::{Memory, Store};
+
+use crate::WasiEnv;
+
+#[derive(Debug)]
+pub(crate) struct DcgiInstance {
+    pub env: WasiEnv,
+    //pub memory: Memory,
+    //pub store: Store,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/mod.rs
new file mode 100644
index 0000000..f9b4608
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/mod.rs
@@ -0,0 +1,11 @@
+mod callbacks;
+mod factory;
+mod handler;
+mod instance;
+mod runner;
+
+pub use self::runner::{Config, DcgiRunner};
+pub use callbacks::DcgiCallbacks;
+pub use factory::DcgiInstanceFactory;
+pub use futures::future::AbortHandle;
+pub(crate) use instance::DcgiInstance;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/runner.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/runner.rs
new file mode 100644
index 0000000..5731728
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dcgi/runner.rs
@@ -0,0 +1,233 @@
+use std::{net::SocketAddr, sync::Arc};
+
+use anyhow::Error;
+use wasmer_journal::FilteredJournalBuilder;
+use wcgi_host::CgiDialect;
+use webc::metadata::Command;
+
+use crate::{
+    bin_factory::BinaryPackage,
+    capabilities::Capabilities,
+    journal::DynJournal,
+    runners::{
+        dcgi::handler::Handler,
+        wcgi::{self, NoOpWcgiCallbacks, WcgiRunner},
+        MappedDirectory,
+    },
+    runtime::{DynRuntime, OverriddenRuntime},
+    Runtime,
+};
+
+use super::{DcgiCallbacks, DcgiInstanceFactory};
+
+#[derive(Debug)]
+pub struct DcgiRunner {
+    config: Config,
+    inner: wcgi::WcgiRunner,
+}
+
+impl DcgiRunner {
+    pub fn new(factory: DcgiInstanceFactory) -> Self {
+        let callbacks = DcgiCallbacks::new(factory, NoOpWcgiCallbacks);
+        DcgiRunner {
+            config: Config {
+                inner: wcgi::Config::new(callbacks.clone()),
+            },
+            inner: WcgiRunner::new(callbacks),
+        }
+    }
+
+    pub fn config(&mut self) -> &mut Config {
+        &mut self.config
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn prepare_handler(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<Handler, Error> {
+        let inner: wcgi::Handler =
+            self.inner
+                .prepare_handler(command_name, pkg, true, CgiDialect::Rfc3875, runtime)?;
+        Ok(Handler::new(inner))
+    }
+}
+
+/// The base URI used by a [`Dcgi`] runner.
+pub const DCGI_RUNNER_URI: &str = "https://webc.org/runner/dcgi";
+
+impl crate::runners::Runner for DcgiRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command.runner.starts_with(DCGI_RUNNER_URI))
+    }
+
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<DynRuntime>,
+    ) -> Result<(), Error> {
+        // We use a filter in front of the journals supplied to the runtime.
+        // The reason for this is that DCGI currently only supports persisting the
+        // file system changes as it is unable to run the main function more than
+        // once due to limitations in the runtime
+        let journals = runtime
+            .journals()
+            .clone()
+            .into_iter()
+            .map(|journal| {
+                let journal = FilteredJournalBuilder::new()
+                    .with_ignore_memory(true)
+                    .with_ignore_threads(true)
+                    .with_ignore_core(true)
+                    .with_ignore_snapshots(true)
+                    .with_ignore_networking(true)
+                    .with_ignore_stdio(true)
+                    .build(journal);
+                Arc::new(journal) as Arc<DynJournal>
+            })
+            .collect::<Vec<_>>();
+        let runtime = OverriddenRuntime::new(runtime).with_journals(journals);
+        let runtime = Arc::new(runtime) as Arc<DynRuntime>;
+
+        //We now pass the runtime to the the handlers
+        let handler = self.prepare_handler(command_name, pkg, Arc::clone(&runtime))?;
+        self.inner.run_command_with_handler(handler, runtime)
+    }
+}
+
+#[derive(Debug)]
+pub struct Config {
+    inner: wcgi::Config,
+}
+
+impl Config {
+    pub fn inner(&mut self) -> &mut wcgi::Config {
+        &mut self.inner
+    }
+
+    pub fn addr(&mut self, addr: SocketAddr) -> &mut Self {
+        self.inner.addr(addr);
+        self
+    }
+
+    /// Add an argument to the WASI executable's command-line arguments.
+    pub fn arg(&mut self, arg: impl Into<String>) -> &mut Self {
+        self.inner.arg(arg);
+        self
+    }
+
+    /// Add multiple arguments to the WASI executable's command-line arguments.
+    pub fn args<A, S>(&mut self, args: A) -> &mut Self
+    where
+        A: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.inner.args(args);
+        self
+    }
+
+    /// Expose an environment variable to the guest.
+    pub fn env(&mut self, name: impl Into<String>, value: impl Into<String>) -> &mut Self {
+        self.inner.env(name, value);
+        self
+    }
+
+    /// Expose multiple environment variables to the guest.
+    pub fn envs<I, K, V>(&mut self, variables: I) -> &mut Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        self.inner.envs(variables);
+        self
+    }
+
+    /// Forward all of the host's environment variables to the guest.
+    pub fn forward_host_env(&mut self) -> &mut Self {
+        self.inner.forward_host_env();
+        self
+    }
+
+    pub fn map_directory(&mut self, dir: MappedDirectory) -> &mut Self {
+        self.inner.map_directory(dir);
+        self
+    }
+
+    pub fn map_directories(
+        &mut self,
+        mappings: impl IntoIterator<Item = MappedDirectory>,
+    ) -> &mut Self {
+        self.inner.map_directories(mappings);
+        self
+    }
+
+    /// Set callbacks that will be triggered at various points in the runner's
+    /// lifecycle.
+    pub fn callbacks(
+        &mut self,
+        callbacks: impl wcgi::Callbacks + Send + Sync + 'static,
+    ) -> &mut Self {
+        self.inner.callbacks(callbacks);
+        self
+    }
+
+    /// Add a package that should be available to the instance at runtime.
+    pub fn inject_package(&mut self, pkg: BinaryPackage) -> &mut Self {
+        self.inner.inject_package(pkg);
+        self
+    }
+
+    /// Add packages that should be available to the instance at runtime.
+    pub fn inject_packages(
+        &mut self,
+        packages: impl IntoIterator<Item = BinaryPackage>,
+    ) -> &mut Self {
+        self.inner.inject_packages(packages);
+        self
+    }
+
+    pub fn capabilities(&mut self) -> &mut Capabilities {
+        self.inner.capabilities()
+    }
+
+    pub fn add_snapshot_trigger(&mut self, on: crate::journal::SnapshotTrigger) {
+        self.inner.add_snapshot_trigger(on);
+    }
+
+    pub fn add_default_snapshot_triggers(&mut self) -> &mut Self {
+        self.inner.add_default_snapshot_triggers();
+        self
+    }
+
+    pub fn has_snapshot_trigger(&self, on: crate::journal::SnapshotTrigger) -> bool {
+        self.inner.has_snapshot_trigger(on)
+    }
+
+    pub fn with_snapshot_interval(&mut self, period: std::time::Duration) -> &mut Self {
+        self.inner.with_snapshot_interval(period);
+        self
+    }
+
+    pub fn add_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
+        self.inner.add_journal(journal);
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn send_and_sync() {
+        fn assert_send<T: Send>() {}
+        fn assert_sync<T: Sync>() {}
+
+        assert_send::<DcgiRunner>();
+        assert_sync::<DcgiRunner>();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/factory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/factory.rs
new file mode 100644
index 0000000..f5f492f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/factory.rs
@@ -0,0 +1,127 @@
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+    task::Context,
+    time::Instant,
+};
+
+use derivative::Derivative;
+use wasmer_journal::{DynJournal, RecombinedJournal};
+
+use crate::{
+    runners::Runner,
+    runtime::{DynRuntime, OverriddenRuntime},
+};
+
+use super::{
+    handler::Handler, hyper_proxy::HyperProxyConnectorBuilder, instance::DProxyInstance,
+    networking::LocalWithLoopbackNetworking, shard::Shard, socket_manager::SocketManager,
+};
+
+#[derive(Debug, Default)]
+struct State {
+    instance: HashMap<Shard, DProxyInstance>,
+}
+
+/// This factory will store and reuse instances between invocations thus
+/// allowing for the instances to be stateful.
+#[derive(Derivative, Clone, Default)]
+#[derivative(Debug)]
+pub struct DProxyInstanceFactory {
+    state: Arc<Mutex<State>>,
+}
+
+impl DProxyInstanceFactory {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub async fn acquire(&self, handler: &Handler, shard: Shard) -> anyhow::Result<DProxyInstance> {
+        loop {
+            {
+                let state = self.state.lock().unwrap();
+                if let Some(instance) = state.instance.get(&shard).cloned() {
+                    return Ok(instance);
+                }
+            }
+
+            let instance = self.spin_up(handler, shard.clone()).await?;
+
+            let mut state = self.state.lock().unwrap();
+            state.instance.insert(shard.clone(), instance);
+        }
+    }
+
+    pub async fn spin_up(&self, handler: &Handler, shard: Shard) -> anyhow::Result<DProxyInstance> {
+        // Get the runtime with its already wired local networking
+        let runtime = handler.runtime.clone();
+
+        // DProxy is able to resume execution of the stateful workload using memory
+        // snapshots hence the journals it stores are complete journals
+        let journals = runtime
+            .journals()
+            .clone()
+            .into_iter()
+            .map(|journal| {
+                let tx = Box::new(journal.clone());
+                let rx = journal.as_restarted()?;
+                anyhow::Result::Ok(Arc::new(RecombinedJournal::new(tx, rx)) as Arc<DynJournal>)
+            })
+            .collect::<anyhow::Result<Vec<_>>>()?;
+        let mut runtime = OverriddenRuntime::new(runtime).with_journals(journals);
+
+        // We attach a composite networking to the runtime which includes a loopback
+        // networking implementation connected to a socket manager
+        let composite_networking = LocalWithLoopbackNetworking::new();
+        let poll_listening = {
+            let networking = composite_networking.clone();
+            Arc::new(move |cx: &mut Context<'_>| networking.poll_listening(cx))
+        };
+        let socket_manager = Arc::new(SocketManager::new(
+            poll_listening,
+            composite_networking.loopback_networking(),
+            handler.config.proxy_connect_init_timeout,
+            handler.config.proxy_connect_nominal_timeout,
+        ));
+        runtime = runtime.with_networking(Arc::new(composite_networking));
+
+        // The connector uses the socket manager to open sockets to the instance
+        let connector = HyperProxyConnectorBuilder::new(socket_manager.clone())
+            .build()
+            .await;
+
+        // Now we run the actual instance under a WasiRunner
+        #[cfg(feature = "sys")]
+        let handle = tokio::runtime::Handle::current();
+        let this = self.clone();
+        let pkg = handler.config.pkg.clone();
+        let command_name = handler.command_name.clone();
+        let connector_inner = connector.clone();
+        let runtime = Arc::new(runtime) as Arc<DynRuntime>;
+        let mut runner = handler.config.inner.clone();
+        runtime
+            .task_manager()
+            .clone()
+            .task_dedicated(Box::new(move || {
+                #[cfg(feature = "sys")]
+                let _guard = handle.enter();
+                if let Err(err) = runner.run_command(&command_name, &pkg, runtime) {
+                    tracing::error!("Instance Exited: {}", err);
+                } else {
+                    tracing::info!("Instance Exited: Nominal");
+                }
+                {
+                    let mut state = this.state.lock().unwrap();
+                    state.instance.remove(&shard);
+                }
+                connector_inner.shutdown();
+            }))?;
+
+        // Return an instance
+        Ok(DProxyInstance {
+            last_used: Arc::new(Mutex::new(Instant::now())),
+            socket_manager,
+            client: hyper::Client::builder().build(connector),
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/handler.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/handler.rs
new file mode 100644
index 0000000..ea0cf3d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/handler.rs
@@ -0,0 +1,121 @@
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Poll;
+
+use futures::{Future, FutureExt};
+use http::{Request, Response, Uri};
+use hyper::Body;
+use tower::Service;
+
+use crate::runners::dproxy::shard::Shard;
+use crate::Runtime;
+
+use super::factory::DProxyInstanceFactory;
+use super::Config;
+
+#[derive(derivative::Derivative)]
+#[derivative(Debug)]
+pub struct SharedState {
+    pub(crate) config: Config,
+    pub(crate) command_name: String,
+    #[derivative(Debug = "ignore")]
+    pub(crate) runtime: Arc<dyn Runtime + Send + Sync>,
+    pub(crate) factory: DProxyInstanceFactory,
+}
+
+/// Handler which will process DProxy requests
+#[derive(Clone, Debug)]
+pub struct Handler(Arc<SharedState>);
+
+impl Handler {
+    pub(crate) fn new(
+        config: Config,
+        command_name: String,
+        factory: DProxyInstanceFactory,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Self {
+        Handler(Arc::new(SharedState {
+            config,
+            command_name,
+            runtime,
+            factory,
+        }))
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, err)]
+    pub(crate) async fn handle<T>(
+        &self,
+        mut req: Request<Body>,
+        _token: T,
+    ) -> anyhow::Result<Response<Body>>
+    where
+        T: Send + 'static,
+    {
+        tracing::debug!(headers=?req.headers());
+
+        // Determine the shard we are using
+        let shard = req
+            .headers()
+            .get("X-Shard")
+            .map(|v| String::from_utf8_lossy(v.as_bytes()))
+            .map(|s| match s.parse::<u64>() {
+                Ok(id) => Ok(Shard::ById(id)),
+                Err(err) => Err(err),
+            })
+            .unwrap_or(Ok(Shard::Singleton))?;
+
+        // Modify the request URI so that it will work with the hyper proxy
+        let mut new_uri = Uri::builder()
+            .scheme("http")
+            .authority(
+                req.uri()
+                    .authority()
+                    .cloned()
+                    .unwrap_or_else(|| "localhost".parse().unwrap()),
+            )
+            .path_and_query(
+                req.uri()
+                    .path_and_query()
+                    .cloned()
+                    .unwrap_or_else(|| "/".parse().unwrap()),
+            )
+            .build()
+            .unwrap();
+        std::mem::swap(req.uri_mut(), &mut new_uri);
+
+        // Acquire a DProxy instance
+        tracing::debug!("Acquiring DProxy instance instance");
+        let instance = self.factory.acquire(self, shard).await?;
+
+        tracing::debug!("Calling into the DProxy instance");
+        let client = instance.client.clone();
+
+        // Perform the request
+        Ok(client.request(req).await?)
+    }
+}
+
+impl std::ops::Deref for Handler {
+    type Target = Arc<SharedState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Service<Request<Body>> for Handler {
+    type Response = Response<Body>;
+    type Error = anyhow::Error;
+    type Future = Pin<Box<dyn Future<Output = anyhow::Result<Response<Body>>> + Send>>;
+
+    fn poll_ready(&mut self, _cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: Request<Body>) -> Self::Future {
+        // Note: all fields are reference-counted so cloning is pretty cheap
+        let handler = self.clone();
+        let fut = async move { handler.handle(request, ()).await };
+        fut.boxed()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/builder.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/builder.rs
new file mode 100644
index 0000000..00265d2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/builder.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use crate::runners::dproxy::socket_manager::SocketManager;
+
+use super::*;
+
+#[derive(Debug)]
+pub struct HyperProxyConnectorBuilder {
+    socket_manager: Arc<SocketManager>,
+}
+
+impl HyperProxyConnectorBuilder {
+    pub fn new(socket_manager: Arc<SocketManager>) -> Self {
+        Self { socket_manager }
+    }
+
+    pub async fn build(self) -> HyperProxyConnector {
+        HyperProxyConnector {
+            socket_manager: self.socket_manager,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/connector.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/connector.rs
new file mode 100644
index 0000000..a309c8c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/connector.rs
@@ -0,0 +1,46 @@
+use std::sync::Arc;
+
+use tokio_stream::wrappers::BroadcastStream;
+
+use super::socket_manager::SocketManager;
+
+use super::*;
+
+/// A Connector for the WASM processes behind a socket.
+#[derive(Debug, Clone)]
+pub struct HyperProxyConnector {
+    pub(super) socket_manager: Arc<SocketManager>,
+}
+
+impl HyperProxyConnector {
+    pub fn shutdown(&self) {
+        self.socket_manager.shutdown();
+    }
+}
+
+impl Service<Uri> for HyperProxyConnector {
+    type Response = HyperProxyStream;
+    type Error = BoxError;
+
+    #[allow(clippy::type_complexity)]
+    type Future = Pin<Box<dyn Future<Output = Result<HyperProxyStream, BoxError>> + Send>>;
+
+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, _dst: Uri) -> Self::Future {
+        let this = self.clone();
+        Box::pin(async move {
+            let terminate_rx = this.socket_manager.terminate_rx();
+            let socket = this.socket_manager.acquire_http_socket().await?;
+            let (tx, rx) = socket.split();
+            Ok(HyperProxyStream {
+                tx,
+                rx,
+                terminate: BroadcastStream::new(terminate_rx),
+                terminated: false,
+            })
+        })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/mod.rs
new file mode 100644
index 0000000..5dcc7c7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/mod.rs
@@ -0,0 +1,18 @@
+mod builder;
+mod connector;
+mod stream;
+
+pub use builder::*;
+pub use connector::*;
+pub use stream::*;
+
+use super::*;
+
+pub(super) use hyper::{service::Service, Uri};
+pub(super) use std::pin::Pin;
+pub(super) type BoxError = Box<dyn std::error::Error + Send + Sync>;
+pub(super) use std::{
+    future::Future,
+    task::{Context, Poll},
+};
+pub(super) use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/stream.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/stream.rs
new file mode 100644
index 0000000..fd5d0d1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/hyper_proxy/stream.rs
@@ -0,0 +1,93 @@
+use std::io;
+
+use futures::Stream;
+use hyper::client::connect::Connected;
+use tokio_stream::wrappers::BroadcastStream;
+use virtual_net::tcp_pair::{TcpSocketHalfRx, TcpSocketHalfTx};
+
+use super::*;
+
+#[derive(Debug)]
+pub struct HyperProxyStream {
+    pub(super) tx: TcpSocketHalfTx,
+    pub(super) rx: TcpSocketHalfRx,
+    pub(super) terminate: BroadcastStream<()>,
+    pub(super) terminated: bool,
+}
+
+impl AsyncRead for HyperProxyStream {
+    #[inline]
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context,
+        buf: &mut ReadBuf<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        if let Poll::Ready(ret) = Pin::new(&mut self.rx).poll_read(cx, buf) {
+            return Poll::Ready(ret);
+        }
+        if self.terminated {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        if let Poll::Ready(Some(_)) = Pin::new(&mut self.terminate).poll_next(cx) {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        Poll::Pending
+    }
+}
+
+impl AsyncWrite for HyperProxyStream {
+    #[inline]
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, io::Error>> {
+        if let Poll::Ready(ret) = Pin::new(&mut self.tx).poll_write(cx, buf) {
+            return Poll::Ready(ret);
+        }
+        if self.terminated {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        if let Poll::Ready(Some(_)) = Pin::new(&mut self.terminate).poll_next(cx) {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        Poll::Pending
+    }
+
+    #[inline]
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
+        if let Poll::Ready(ret) = Pin::new(&mut self.tx).poll_flush(cx) {
+            return Poll::Ready(ret);
+        }
+        if self.terminated {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        if let Poll::Ready(Some(_)) = Pin::new(&mut self.terminate).poll_next(cx) {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        Poll::Pending
+    }
+
+    #[inline]
+    fn poll_shutdown(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        if let Poll::Ready(ret) = Pin::new(&mut self.tx).poll_shutdown(cx) {
+            return Poll::Ready(ret);
+        }
+        if self.terminated {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        if let Poll::Ready(Some(_)) = Pin::new(&mut self.terminate).poll_next(cx) {
+            return Poll::Ready(Err(io::ErrorKind::ConnectionReset.into()));
+        }
+        Poll::Pending
+    }
+}
+
+impl hyper::client::connect::Connection for HyperProxyStream {
+    fn connected(&self) -> Connected {
+        Connected::new().proxy(true)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/instance.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/instance.rs
new file mode 100644
index 0000000..edbb8e6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/instance.rs
@@ -0,0 +1,15 @@
+use std::{
+    sync::{Arc, Mutex},
+    time::Instant,
+};
+
+use super::{hyper_proxy::HyperProxyConnector, socket_manager::SocketManager};
+
+#[derive(Debug, Clone)]
+pub struct DProxyInstance {
+    #[allow(unused)]
+    pub(super) last_used: Arc<Mutex<Instant>>,
+    #[allow(unused)]
+    pub(super) socket_manager: Arc<SocketManager>,
+    pub(super) client: hyper::Client<HyperProxyConnector>,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/mod.rs
new file mode 100644
index 0000000..5637608
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/mod.rs
@@ -0,0 +1,12 @@
+mod factory;
+pub(super) mod handler;
+mod hyper_proxy;
+mod instance;
+mod networking;
+mod runner;
+mod shard;
+mod socket_manager;
+
+pub use self::factory::DProxyInstanceFactory;
+pub use self::instance::DProxyInstance;
+pub use self::runner::{Config, DProxyRunner};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/networking.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/networking.rs
new file mode 100644
index 0000000..8e46f1c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/networking.rs
@@ -0,0 +1,223 @@
+use std::{
+    net::{IpAddr, SocketAddr},
+    sync::{Arc, Mutex},
+    task::{Context, Poll, Waker},
+    time::Duration,
+};
+
+use virtual_net::{
+    host::LocalNetworking, loopback::LoopbackNetworking, IpCidr, IpRoute, NetworkError,
+    StreamSecurity, VirtualIcmpSocket, VirtualNetworking, VirtualRawSocket, VirtualTcpListener,
+    VirtualTcpSocket, VirtualUdpSocket,
+};
+
+#[derive(Debug, Default)]
+struct LocalWithLoopbackNetworkingListening {
+    addresses: Vec<SocketAddr>,
+    wakers: Vec<Waker>,
+}
+
+#[derive(Debug, Clone)]
+pub struct LocalWithLoopbackNetworking {
+    inner_networking: Arc<dyn VirtualNetworking + Send + Sync + 'static>,
+    local_listening: Arc<Mutex<LocalWithLoopbackNetworkingListening>>,
+    loopback_networking: LoopbackNetworking,
+}
+
+impl LocalWithLoopbackNetworking {
+    pub fn new() -> Self {
+        lazy_static::lazy_static! {
+            static ref LOCAL_NETWORKING: Arc<LocalNetworking> = Arc::new(LocalNetworking::default());
+        }
+        Self {
+            local_listening: Default::default(),
+            inner_networking: LOCAL_NETWORKING.clone(),
+            loopback_networking: LoopbackNetworking::new(),
+        }
+    }
+
+    pub fn poll_listening(&self, cx: &mut Context<'_>) -> Poll<SocketAddr> {
+        let mut listening = self.local_listening.lock().unwrap();
+
+        if let Some(addr) = listening.addresses.first() {
+            return Poll::Ready(*addr);
+        }
+
+        if !listening.wakers.iter().any(|w| w.will_wake(cx.waker())) {
+            listening.wakers.push(cx.waker().clone());
+        }
+
+        Poll::Pending
+    }
+
+    pub fn register_listener(&self, addr: SocketAddr) {
+        let mut listening = self.local_listening.lock().unwrap();
+        listening.addresses.push(addr);
+        listening.addresses.sort_by_key(|a| a.port());
+        listening.wakers.drain(..).for_each(|w| w.wake());
+    }
+
+    pub fn loopback_networking(&self) -> LoopbackNetworking {
+        self.loopback_networking.clone()
+    }
+}
+
+#[allow(unused_variables)]
+#[async_trait::async_trait]
+impl VirtualNetworking for LocalWithLoopbackNetworking {
+    /// Bridges this local network with a remote network, which is required in
+    /// order to make lower level networking calls (such as UDP/TCP)
+    async fn bridge(
+        &self,
+        network: &str,
+        access_token: &str,
+        security: StreamSecurity,
+    ) -> Result<(), NetworkError> {
+        self.inner_networking
+            .bridge(network, access_token, security)
+            .await
+    }
+
+    /// Disconnects from the remote network essentially unbridging it
+    async fn unbridge(&self) -> Result<(), NetworkError> {
+        self.inner_networking.unbridge().await
+    }
+
+    /// Acquires an IP address on the network and configures the routing tables
+    async fn dhcp_acquire(&self) -> Result<Vec<IpAddr>, NetworkError> {
+        self.inner_networking.dhcp_acquire().await
+    }
+
+    /// Adds a static IP address to the interface with a netmask prefix
+    async fn ip_add(&self, ip: IpAddr, prefix: u8) -> Result<(), NetworkError> {
+        self.inner_networking.ip_add(ip, prefix).await
+    }
+
+    /// Removes a static (or dynamic) IP address from the interface
+    async fn ip_remove(&self, ip: IpAddr) -> Result<(), NetworkError> {
+        self.inner_networking.ip_remove(ip).await
+    }
+
+    /// Clears all the assigned IP addresses for this interface
+    async fn ip_clear(&self) -> Result<(), NetworkError> {
+        self.inner_networking.ip_clear().await
+    }
+
+    /// Lists all the IP addresses currently assigned to this interface
+    async fn ip_list(&self) -> Result<Vec<IpCidr>, NetworkError> {
+        self.inner_networking.ip_list().await
+    }
+
+    /// Returns the hardware MAC address for this interface
+    async fn mac(&self) -> Result<[u8; 6], NetworkError> {
+        self.inner_networking.mac().await
+    }
+
+    /// Adds a default gateway to the routing table
+    async fn gateway_set(&self, ip: IpAddr) -> Result<(), NetworkError> {
+        self.inner_networking.gateway_set(ip).await
+    }
+
+    /// Adds a specific route to the routing table
+    async fn route_add(
+        &self,
+        cidr: IpCidr,
+        via_router: IpAddr,
+        preferred_until: Option<Duration>,
+        expires_at: Option<Duration>,
+    ) -> Result<(), NetworkError> {
+        self.inner_networking
+            .route_add(cidr, via_router, preferred_until, expires_at)
+            .await
+    }
+
+    /// Removes a routing rule from the routing table
+    async fn route_remove(&self, cidr: IpAddr) -> Result<(), NetworkError> {
+        self.inner_networking.route_remove(cidr).await
+    }
+
+    /// Clears the routing table for this interface
+    async fn route_clear(&self) -> Result<(), NetworkError> {
+        self.inner_networking.route_clear().await
+    }
+
+    /// Lists all the routes defined in the routing table for this interface
+    async fn route_list(&self) -> Result<Vec<IpRoute>, NetworkError> {
+        self.inner_networking.route_list().await
+    }
+
+    /// Creates a low level socket that can read and write Ethernet packets
+    /// directly to the interface
+    async fn bind_raw(&self) -> Result<Box<dyn VirtualRawSocket + Sync>, NetworkError> {
+        self.inner_networking.bind_raw().await
+    }
+
+    /// Listens for TCP connections on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    async fn listen_tcp(
+        &self,
+        addr: SocketAddr,
+        only_v6: bool,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualTcpListener + Sync>, NetworkError> {
+        let backlog = 1024;
+
+        tracing::debug!("registering listener on loopback networking");
+
+        let ret: Result<Box<dyn VirtualTcpListener + Sync>, NetworkError> = self
+            .loopback_networking
+            .listen_tcp(addr, only_v6, reuse_port, reuse_addr)
+            .await;
+
+        if ret.is_ok() {
+            tracing::debug!("registering listener on loopback networking");
+            self.register_listener(addr);
+        }
+
+        ret
+    }
+
+    /// Opens a UDP socket that listens on a specific IP and Port combination
+    /// Multiple servers (processes or threads) can bind to the same port if they each set
+    /// the reuse-port and-or reuse-addr flags
+    async fn bind_udp(
+        &self,
+        addr: SocketAddr,
+        reuse_port: bool,
+        reuse_addr: bool,
+    ) -> Result<Box<dyn VirtualUdpSocket + Sync>, NetworkError> {
+        self.inner_networking
+            .bind_udp(addr, reuse_port, reuse_addr)
+            .await
+    }
+
+    /// Creates a socket that can be used to send and receive ICMP packets
+    /// from a paritcular IP address
+    async fn bind_icmp(
+        &self,
+        addr: IpAddr,
+    ) -> Result<Box<dyn VirtualIcmpSocket + Sync>, NetworkError> {
+        self.inner_networking.bind_icmp(addr).await
+    }
+
+    /// Opens a TCP connection to a particular destination IP address and port
+    async fn connect_tcp(
+        &self,
+        addr: SocketAddr,
+        peer: SocketAddr,
+    ) -> Result<Box<dyn VirtualTcpSocket + Sync>, NetworkError> {
+        self.inner_networking.connect_tcp(addr, peer).await
+    }
+
+    /// Performs DNS resolution for a specific hostname
+    async fn resolve(
+        &self,
+        host: &str,
+        port: Option<u16>,
+        dns_server: Option<IpAddr>,
+    ) -> Result<Vec<IpAddr>, NetworkError> {
+        self.inner_networking.resolve(host, port, dns_server).await
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/runner.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/runner.rs
new file mode 100644
index 0000000..5fced62
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/runner.rs
@@ -0,0 +1,143 @@
+use std::{net::SocketAddr, sync::Arc, time::Duration};
+
+use anyhow::{Context, Error};
+use http::{Request, Response};
+use hyper::Body;
+use tower::{make::Shared, ServiceBuilder};
+use tower_http::{catch_panic::CatchPanicLayer, cors::CorsLayer, trace::TraceLayer};
+use tracing::Span;
+use webc::metadata::Command;
+
+use crate::{
+    bin_factory::BinaryPackage,
+    runners::wasi::WasiRunner,
+    runtime::{task_manager::VirtualTaskManagerExt, DynRuntime},
+};
+
+use super::factory::DProxyInstanceFactory;
+
+#[derive(Debug)]
+pub struct DProxyRunner {
+    config: Config,
+    factory: DProxyInstanceFactory,
+}
+
+impl DProxyRunner {
+    pub fn new(inner: WasiRunner, pkg: &BinaryPackage) -> Self {
+        Self {
+            config: Config::new(inner, pkg),
+            factory: DProxyInstanceFactory::new(),
+        }
+    }
+
+    pub fn config(&mut self) -> &mut Config {
+        &mut self.config
+    }
+}
+
+/// The base URI used by a [`DProxy`] runner.
+pub const DPROXY_RUNNER_URI: &str = "https://webc.org/runner/dproxy";
+
+impl crate::runners::Runner for DProxyRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command.runner.starts_with(DPROXY_RUNNER_URI))
+    }
+
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        _pkg: &BinaryPackage,
+        runtime: Arc<DynRuntime>,
+    ) -> Result<(), Error> {
+        // Create the handler that will process the HTTP requests
+        let handler = super::handler::Handler::new(
+            self.config.clone(),
+            command_name.to_string(),
+            self.factory.clone(),
+            runtime.clone(),
+        );
+
+        // We create a HTTP server which will reverse proxy all the requests
+        // to the proxy workload
+        let service = ServiceBuilder::new()
+            .layer(
+                TraceLayer::new_for_http()
+                    .make_span_with(|request: &Request<Body>| {
+                        tracing::info_span!(
+                            "request",
+                            method = %request.method(),
+                            uri = %request.uri(),
+                            status_code = tracing::field::Empty,
+                        )
+                    })
+                    .on_response(|response: &Response<_>, _latency: Duration, span: &Span| {
+                        span.record("status_code", &tracing::field::display(response.status()));
+                        tracing::info!("response generated")
+                    }),
+            )
+            .layer(CatchPanicLayer::new())
+            .layer(CorsLayer::permissive())
+            .service(handler);
+
+        let address = self.config.addr;
+        tracing::info!(%address, "Starting the DProxy server");
+
+        runtime
+            .task_manager()
+            .spawn_and_block_on(async move {
+                let (shutdown, _abort_handle) =
+                    futures::future::abortable(futures::future::pending::<()>());
+
+                hyper::Server::bind(&address)
+                    .serve(Shared::new(service))
+                    .with_graceful_shutdown(async {
+                        let _ = shutdown.await;
+                        tracing::info!("Shutting down gracefully");
+                    })
+                    .await
+            })
+            .context("Unable to start the server")??;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub(crate) inner: WasiRunner,
+    pub(crate) addr: SocketAddr,
+    pub(crate) pkg: BinaryPackage,
+    pub(crate) proxy_connect_init_timeout: Duration,
+    pub(crate) proxy_connect_nominal_timeout: Duration,
+}
+
+impl Config {
+    pub fn new(inner: WasiRunner, pkg: &BinaryPackage) -> Self {
+        Self {
+            inner,
+            pkg: pkg.clone(),
+            addr: ([127, 0, 0, 1], 8000).into(),
+            proxy_connect_init_timeout: Duration::from_secs(30),
+            proxy_connect_nominal_timeout: Duration::from_secs(30),
+        }
+    }
+
+    pub fn addr(&mut self, addr: SocketAddr) -> &mut Self {
+        self.addr = addr;
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn send_and_sync() {
+        fn assert_send<T: Send>() {}
+        fn assert_sync<T: Sync>() {}
+
+        assert_send::<DProxyRunner>();
+        assert_sync::<DProxyRunner>();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/shard.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/shard.rs
new file mode 100644
index 0000000..bcea133
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/shard.rs
@@ -0,0 +1,6 @@
+#[derive(Debug, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Shard {
+    #[default]
+    Singleton,
+    ById(u64),
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/socket_manager.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/socket_manager.rs
new file mode 100644
index 0000000..658832f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/dproxy/socket_manager.rs
@@ -0,0 +1,102 @@
+use std::{
+    future::poll_fn,
+    net::{IpAddr, Ipv4Addr, SocketAddr},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    task::{Context, Poll},
+    time::Duration,
+};
+
+use derivative::Derivative;
+use tokio::sync::broadcast;
+use virtual_net::{tcp_pair::TcpSocketHalf, LoopbackNetworking};
+
+pub type PollListeningFn =
+    Arc<dyn Fn(&mut Context<'_>) -> Poll<SocketAddr> + Send + Sync + 'static>;
+
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct SocketManager {
+    #[derivative(Debug = "ignore")]
+    poll_listening: PollListeningFn,
+    loopback_networking: LoopbackNetworking,
+    proxy_connect_init_timeout: Duration,
+    proxy_connect_nominal_timeout: Duration,
+    is_running: AtomicBool,
+    is_terminated: AtomicBool,
+    terminate_all: broadcast::Sender<()>,
+}
+
+impl SocketManager {
+    pub fn new(
+        poll_listening: PollListeningFn,
+        loopback_networking: LoopbackNetworking,
+        proxy_connect_init_timeout: Duration,
+        proxy_connect_nominal_timeout: Duration,
+    ) -> Self {
+        Self {
+            poll_listening,
+            loopback_networking,
+            proxy_connect_init_timeout,
+            proxy_connect_nominal_timeout,
+            is_running: AtomicBool::new(false),
+            is_terminated: AtomicBool::new(false),
+            terminate_all: broadcast::channel(1).0,
+        }
+    }
+
+    pub fn shutdown(&self) {
+        self.is_terminated.store(true, Ordering::SeqCst);
+        self.terminate_all.send(()).ok();
+    }
+
+    pub fn terminate_rx(&self) -> broadcast::Receiver<()> {
+        self.terminate_all.subscribe()
+    }
+
+    pub async fn acquire_http_socket(&self) -> anyhow::Result<TcpSocketHalf> {
+        let mut rx_terminate = self.terminate_all.subscribe();
+
+        if self.is_terminated.load(Ordering::SeqCst) {
+            return Err(anyhow::anyhow!(
+                "failed to open HTTP socket as the instance has terminated"
+            ));
+        }
+        let connect_timeout = if self.is_running.load(Ordering::SeqCst) {
+            self.proxy_connect_nominal_timeout
+        } else {
+            self.proxy_connect_init_timeout
+        };
+
+        let ret = tokio::select! {
+            socket = tokio::time::timeout(connect_timeout, self.open_proxy_http_socket()) => socket??,
+            _ = rx_terminate.recv() => {
+                return Err(anyhow::anyhow!(
+                    "failed to open HTTP socket as the instance has terminated"
+                ));
+            }
+        };
+        self.is_running.store(true, Ordering::Relaxed);
+        Ok(ret)
+    }
+
+    pub async fn open_proxy_http_socket(&self) -> anyhow::Result<TcpSocketHalf> {
+        // We need to find the destination address
+        let poll_listening = self.poll_listening.clone();
+        let port = poll_fn(|cx| poll_listening(cx)).await.port();
+        let dst = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port);
+
+        // Open a connection directly to the loopback port
+        // (or at least try to)
+        self.loopback_networking
+            .loopback_connect_to(SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 0), dst)
+            .ok_or_else(|| {
+                tracing::debug!(
+                    "proxy connection attempt failed - could not connect to http server socket as the loopback socket is not open",
+                );
+                anyhow::anyhow!("failed to open HTTP socket as the loopback socket is not open")
+            })
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/emscripten.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/emscripten.rs
new file mode 100644
index 0000000..7e78101
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/emscripten.rs
@@ -0,0 +1,124 @@
+//! WebC container support for running Emscripten modules
+
+use std::sync::Arc;
+
+use anyhow::{anyhow, Context, Error};
+use serde::{Deserialize, Serialize};
+use wasmer::{FunctionEnv, Instance, Module, Store};
+use wasmer_emscripten::{
+    generate_emscripten_env, is_emscripten_module, run_emscripten_instance, EmEnv,
+    EmscriptenGlobals,
+};
+use webc::metadata::{annotations::Emscripten, Command};
+
+use crate::{bin_factory::BinaryPackage, Runtime};
+
+#[derive(Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct EmscriptenRunner {
+    args: Vec<String>,
+}
+
+impl EmscriptenRunner {
+    /// Constructs a new `EmscriptenRunner` given an `Store`
+    pub fn new() -> Self {
+        EmscriptenRunner::default()
+    }
+
+    /// Returns the current arguments for this `EmscriptenRunner`
+    pub fn get_args(&self) -> Vec<String> {
+        self.args.clone()
+    }
+
+    /// Builder method to provide CLI args to the runner
+    pub fn with_args(mut self, args: Vec<String>) -> Self {
+        self.set_args(args);
+        self
+    }
+
+    /// Set the CLI args
+    pub fn set_args(&mut self, args: Vec<String>) {
+        self.args = args;
+    }
+}
+
+impl crate::runners::Runner for EmscriptenRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command
+            .runner
+            .starts_with(webc::metadata::annotations::EMSCRIPTEN_RUNNER_URI))
+    }
+
+    #[allow(unreachable_code, unused_variables)]
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let cmd = pkg
+            .get_command(command_name)
+            .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?;
+        let Emscripten { main_args, .. } =
+            cmd.metadata().annotation("emscripten")?.unwrap_or_default();
+
+        let mut module = runtime.load_module_sync(cmd.atom())?;
+        module.set_name(command_name);
+
+        let mut store = runtime.new_store();
+        let (mut globals, env) = prepare_emscripten_env(&mut store, &module, command_name)?;
+
+        exec_module(
+            &mut store,
+            &module,
+            &mut globals,
+            env,
+            command_name,
+            main_args.unwrap_or_default(),
+        )?;
+
+        Ok(())
+    }
+}
+
+fn prepare_emscripten_env(
+    store: &mut Store,
+    module: &Module,
+    name: &str,
+) -> Result<(EmscriptenGlobals, FunctionEnv<EmEnv>), anyhow::Error> {
+    if !is_emscripten_module(module) {
+        return Err(anyhow!("Atom {name:?} is not an emscripten module"));
+    }
+
+    let env = FunctionEnv::new(store, EmEnv::new());
+    let emscripten_globals = EmscriptenGlobals::new(store, &env, module);
+    let emscripten_globals = emscripten_globals.map_err(|e| anyhow!("{}", e))?;
+    env.as_mut(store)
+        .set_data(&emscripten_globals.data, Default::default());
+
+    Ok((emscripten_globals, env))
+}
+
+fn exec_module(
+    store: &mut Store,
+    module: &Module,
+    globals: &mut EmscriptenGlobals,
+    em_env: FunctionEnv<EmEnv>,
+    name: &str,
+    args: Vec<String>,
+) -> Result<(), anyhow::Error> {
+    let import_object = generate_emscripten_env(store, &em_env, globals);
+
+    let mut instance = Instance::new(store, module, &import_object)
+        .map_err(|e| anyhow!("Cant instantiate emscripten module {name:?}: {e}"))?;
+
+    run_emscripten_instance(
+        &mut instance,
+        em_env.into_mut(store),
+        globals,
+        name,
+        args.iter().map(|arg| arg.as_str()).collect(),
+        None,
+    )?;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/mod.rs
new file mode 100644
index 0000000..a2bf9eb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/mod.rs
@@ -0,0 +1,17 @@
+mod runner;
+
+#[cfg(feature = "webc_runner_rt_dcgi")]
+pub mod dcgi;
+#[cfg(feature = "webc_runner_rt_dproxy")]
+pub mod dproxy;
+#[cfg(feature = "webc_runner_rt_emscripten")]
+pub mod emscripten;
+pub mod wasi;
+mod wasi_common;
+#[cfg(feature = "webc_runner_rt_wcgi")]
+pub mod wcgi;
+
+pub use self::{
+    runner::Runner,
+    wasi_common::{MappedCommand, MappedDirectory, MountedDirectory},
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/runner.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/runner.rs
new file mode 100644
index 0000000..2504501
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/runner.rs
@@ -0,0 +1,22 @@
+use std::sync::Arc;
+
+use anyhow::Error;
+use webc::metadata::Command;
+
+use crate::{bin_factory::BinaryPackage, Runtime};
+
+/// Trait that all runners have to implement
+pub trait Runner {
+    /// Returns whether the Runner will be able to run the `Command`
+    fn can_run_command(command: &Command) -> Result<bool, Error>
+    where
+        Self: Sized;
+
+    /// Run a command.
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error>;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi.rs
new file mode 100644
index 0000000..aebb6da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi.rs
@@ -0,0 +1,405 @@
+//! WebC container support for running WASI modules
+
+use std::{path::PathBuf, sync::Arc};
+
+use anyhow::{Context, Error};
+use tracing::Instrument;
+use virtual_fs::{ArcBoxFile, FileSystem, TmpFileSystem, VirtualFile};
+use wasmer::{Extern, Module};
+use webc::metadata::{annotations::Wasi, Command};
+
+use crate::{
+    bin_factory::BinaryPackage,
+    capabilities::Capabilities,
+    journal::{DynJournal, SnapshotTrigger},
+    runners::{wasi_common::CommonWasiOptions, MappedDirectory, MountedDirectory},
+    runtime::{module_cache::ModuleHash, task_manager::VirtualTaskManagerExt},
+    Runtime, WasiEnvBuilder, WasiError, WasiRuntimeError,
+};
+
+use super::wasi_common::MappedCommand;
+
+#[derive(Debug, Default, Clone)]
+pub struct WasiRunner {
+    wasi: CommonWasiOptions,
+    stdin: Option<ArcBoxFile>,
+    stdout: Option<ArcBoxFile>,
+    stderr: Option<ArcBoxFile>,
+}
+
+impl WasiRunner {
+    /// Constructs a new `WasiRunner`.
+    pub fn new() -> Self {
+        WasiRunner::default()
+    }
+
+    /// Returns the current arguments for this `WasiRunner`
+    pub fn get_args(&self) -> Vec<String> {
+        self.wasi.args.clone()
+    }
+
+    /// Builder method to provide CLI args to the runner
+    pub fn with_args<A, S>(&mut self, args: A) -> &mut Self
+    where
+        A: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.wasi.args = args.into_iter().map(|s| s.into()).collect();
+        self
+    }
+
+    /// Builder method to provide environment variables to the runner.
+    pub fn with_env(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.wasi.env.insert(key.into(), value.into());
+        self
+    }
+
+    pub fn with_envs<I, K, V>(&mut self, envs: I) -> &mut Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        for (key, value) in envs {
+            self.wasi.env.insert(key.into(), value.into());
+        }
+        self
+    }
+
+    pub fn with_forward_host_env(&mut self, forward: bool) -> &mut Self {
+        self.wasi.forward_host_env = forward;
+        self
+    }
+
+    pub fn with_mapped_directories<I, D>(&mut self, dirs: I) -> &mut Self
+    where
+        I: IntoIterator<Item = D>,
+        D: Into<MappedDirectory>,
+    {
+        self.with_mounted_directories(dirs.into_iter().map(Into::into).map(MountedDirectory::from))
+    }
+
+    pub fn with_mounted_directories<I, D>(&mut self, dirs: I) -> &mut Self
+    where
+        I: IntoIterator<Item = D>,
+        D: Into<MountedDirectory>,
+    {
+        self.wasi.mounts.extend(dirs.into_iter().map(Into::into));
+        self
+    }
+
+    /// Mount a [`FileSystem`] instance at a particular location.
+    pub fn with_mount(&mut self, dest: String, fs: Arc<dyn FileSystem + Send + Sync>) -> &mut Self {
+        self.wasi.mounts.push(MountedDirectory { guest: dest, fs });
+        self
+    }
+
+    /// Override the directory the WASIX instance will start in.
+    pub fn with_current_dir(&mut self, dir: impl Into<PathBuf>) -> &mut Self {
+        self.wasi.current_dir = Some(dir.into());
+        self
+    }
+
+    /// Add a package that should be available to the instance at runtime.
+    pub fn with_injected_package(&mut self, pkg: BinaryPackage) -> &mut Self {
+        self.wasi.injected_packages.push(pkg);
+        self
+    }
+
+    /// Add packages that should be available to the instance at runtime.
+    pub fn with_injected_packages(
+        &mut self,
+        packages: impl IntoIterator<Item = BinaryPackage>,
+    ) -> &mut Self {
+        self.wasi.injected_packages.extend(packages);
+        self
+    }
+
+    pub fn with_mapped_host_command(
+        &mut self,
+        alias: impl Into<String>,
+        target: impl Into<String>,
+    ) -> &mut Self {
+        self.wasi.mapped_host_commands.push(MappedCommand {
+            alias: alias.into(),
+            target: target.into(),
+        });
+        self
+    }
+
+    pub fn with_mapped_host_commands(
+        &mut self,
+        commands: impl IntoIterator<Item = MappedCommand>,
+    ) -> &mut Self {
+        self.wasi.mapped_host_commands.extend(commands);
+        self
+    }
+
+    pub fn capabilities_mut(&mut self) -> &mut Capabilities {
+        &mut self.wasi.capabilities
+    }
+
+    pub fn with_capabilities(&mut self, capabilities: Capabilities) -> &mut Self {
+        self.wasi.capabilities = capabilities;
+        self
+    }
+
+    pub fn with_snapshot_trigger(&mut self, on: SnapshotTrigger) -> &mut Self {
+        self.wasi.snapshot_on.push(on);
+        self
+    }
+
+    pub fn with_default_snapshot_triggers(&mut self) -> &mut Self {
+        for on in crate::journal::DEFAULT_SNAPSHOT_TRIGGERS {
+            if !self.has_snapshot_trigger(on) {
+                self.with_snapshot_trigger(on);
+            }
+        }
+        self
+    }
+
+    pub fn has_snapshot_trigger(&self, on: SnapshotTrigger) -> bool {
+        self.wasi.snapshot_on.iter().any(|t| *t == on)
+    }
+
+    pub fn with_snapshot_interval(&mut self, period: std::time::Duration) -> &mut Self {
+        if !self.has_snapshot_trigger(SnapshotTrigger::PeriodicInterval) {
+            self.with_snapshot_trigger(SnapshotTrigger::PeriodicInterval);
+        }
+        self.wasi.snapshot_interval.replace(period);
+        self
+    }
+
+    pub fn with_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
+        self.wasi.journals.push(journal);
+        self
+    }
+
+    pub fn with_stdin(&mut self, stdin: Box<dyn VirtualFile + Send + Sync>) -> &mut Self {
+        self.stdin = Some(ArcBoxFile::new(stdin));
+        self
+    }
+
+    pub fn with_stdout(&mut self, stdout: Box<dyn VirtualFile + Send + Sync>) -> &mut Self {
+        self.stdout = Some(ArcBoxFile::new(stdout));
+        self
+    }
+
+    pub fn with_stderr(&mut self, stderr: Box<dyn VirtualFile + Send + Sync>) -> &mut Self {
+        self.stderr = Some(ArcBoxFile::new(stderr));
+        self
+    }
+
+    /// Add an item to the list of importable items provided to the instance.
+    pub fn with_import(
+        &mut self,
+        namespace: impl Into<String>,
+        name: impl Into<String>,
+        value: impl Into<Extern>,
+    ) -> &mut Self {
+        self.with_imports([((namespace, name), value)])
+    }
+
+    /// Add multiple import functions.
+    ///
+    /// This method will accept a [`&Imports`][wasmer::Imports] object.
+    pub fn with_imports<I, S1, S2, E>(&mut self, imports: I) -> &mut Self
+    where
+        I: IntoIterator<Item = ((S1, S2), E)>,
+        S1: Into<String>,
+        S2: Into<String>,
+        E: Into<Extern>,
+    {
+        let imports = imports
+            .into_iter()
+            .map(|((ns, n), e)| ((ns.into(), n.into()), e.into()));
+        self.wasi.additional_imports.extend(imports);
+        self
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn prepare_webc_env(
+        &self,
+        program_name: &str,
+        wasi: &Wasi,
+        pkg: Option<&BinaryPackage>,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+        root_fs: Option<TmpFileSystem>,
+    ) -> Result<WasiEnvBuilder, anyhow::Error> {
+        let mut builder = WasiEnvBuilder::new(program_name).runtime(runtime);
+
+        let container_fs = if let Some(pkg) = pkg {
+            builder.add_webc(pkg.clone());
+            builder.set_module_hash(pkg.hash());
+            Some(Arc::clone(&pkg.webc_fs))
+        } else {
+            None
+        };
+
+        self.wasi
+            .prepare_webc_env(&mut builder, container_fs, wasi, root_fs)?;
+
+        if let Some(stdin) = &self.stdin {
+            builder.set_stdin(Box::new(stdin.clone()));
+        }
+        if let Some(stdout) = &self.stdout {
+            builder.set_stdout(Box::new(stdout.clone()));
+        }
+        if let Some(stderr) = &self.stderr {
+            builder.set_stderr(Box::new(stderr.clone()));
+        }
+
+        Ok(builder)
+    }
+
+    pub fn run_wasm(
+        &self,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+        program_name: &str,
+        module: &Module,
+        module_hash: ModuleHash,
+        asyncify: bool,
+    ) -> Result<(), Error> {
+        let wasi = webc::metadata::annotations::Wasi::new(program_name);
+        let mut store = runtime.new_store();
+        let env = self.prepare_webc_env(program_name, &wasi, None, runtime, None)?;
+
+        if asyncify {
+            env.run_with_store_async(module.clone(), module_hash, store)?;
+        } else {
+            env.run_with_store_ext(module.clone(), module_hash, &mut store)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl crate::runners::Runner for WasiRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command
+            .runner
+            .starts_with(webc::metadata::annotations::WASI_RUNNER_URI))
+    }
+
+    #[tracing::instrument(skip_all)]
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let cmd = pkg
+            .get_command(command_name)
+            .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?;
+        let wasi = cmd
+            .metadata()
+            .annotation("wasi")?
+            .unwrap_or_else(|| Wasi::new(command_name));
+
+        #[allow(unused_mut)]
+        let mut env = self
+            .prepare_webc_env(command_name, &wasi, Some(pkg), Arc::clone(&runtime), None)
+            .context("Unable to prepare the WASI environment")?;
+
+        #[cfg(feature = "journal")]
+        {
+            for journal in self.wasi.journals.clone() {
+                env.add_journal(journal);
+            }
+
+            for snapshot_trigger in self.wasi.snapshot_on.iter().cloned() {
+                env.add_snapshot_trigger(snapshot_trigger);
+            }
+        }
+
+        let env = env.build()?;
+        let store = runtime.new_store();
+
+        let command_name = command_name.to_string();
+        let tasks = runtime.task_manager().clone();
+        let pkg = pkg.clone();
+
+        let exit_code = tasks.spawn_and_block_on(
+            async move {
+                let mut task_handle =
+                    crate::bin_factory::spawn_exec(pkg, &command_name, store, env, &runtime)
+                        .await
+                        .context("Spawn failed")?;
+
+                #[cfg(feature = "ctrlc")]
+                task_handle.install_ctrlc_handler();
+
+                task_handle
+                    .wait_finished()
+                    .await
+                    .map_err(|err| {
+                        // We do our best to recover the error
+                        let msg = err.to_string();
+                        let weak = Arc::downgrade(&err);
+                        Arc::into_inner(err).unwrap_or_else(|| {
+                            weak.upgrade()
+                                .map(|err| match err.as_ref() {
+                                    WasiRuntimeError::Init(a) => WasiRuntimeError::Init(a.clone()),
+                                    WasiRuntimeError::Export(a) => {
+                                        WasiRuntimeError::Export(a.clone())
+                                    }
+                                    WasiRuntimeError::Instantiation(a) => {
+                                        WasiRuntimeError::Instantiation(a.clone())
+                                    }
+                                    WasiRuntimeError::Wasi(WasiError::Exit(a)) => {
+                                        WasiRuntimeError::Wasi(WasiError::Exit(*a))
+                                    }
+                                    WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion) => {
+                                        WasiRuntimeError::Wasi(WasiError::UnknownWasiVersion)
+                                    }
+                                    WasiRuntimeError::Wasi(WasiError::DeepSleep(_)) => {
+                                        WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!(
+                                            "deep-sleep"
+                                        )))
+                                    }
+                                    WasiRuntimeError::ControlPlane(a) => {
+                                        WasiRuntimeError::ControlPlane(a.clone())
+                                    }
+                                    WasiRuntimeError::Runtime(a) => {
+                                        WasiRuntimeError::Runtime(a.clone())
+                                    }
+                                    WasiRuntimeError::Thread(a) => {
+                                        WasiRuntimeError::Thread(a.clone())
+                                    }
+                                    WasiRuntimeError::Anyhow(a) => {
+                                        WasiRuntimeError::Anyhow(a.clone())
+                                    }
+                                })
+                                .unwrap_or_else(|| {
+                                    WasiRuntimeError::Anyhow(Arc::new(anyhow::format_err!(
+                                        "{}", msg
+                                    )))
+                                })
+                        })
+                    })
+                    .context("Unable to wait for the process to exit")
+            }
+            .in_current_span(),
+        )??;
+
+        if exit_code.raw() == 0 {
+            Ok(())
+        } else {
+            Err(WasiRuntimeError::Wasi(crate::WasiError::Exit(exit_code)).into())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn send_and_sync() {
+        fn assert_send<T: Send>() {}
+        fn assert_sync<T: Sync>() {}
+
+        assert_send::<WasiRunner>();
+        assert_sync::<WasiRunner>();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi_common.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi_common.rs
new file mode 100644
index 0000000..f2b2bb9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wasi_common.rs
@@ -0,0 +1,503 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::{Context, Error};
+use derivative::Derivative;
+use futures::future::BoxFuture;
+use virtual_fs::{FileSystem, FsError, OverlayFileSystem, RootFileSystemBuilder, TmpFileSystem};
+use wasmer::Imports;
+use webc::metadata::annotations::Wasi as WasiAnnotation;
+
+use crate::{
+    bin_factory::BinaryPackage,
+    capabilities::Capabilities,
+    journal::{DynJournal, SnapshotTrigger},
+    WasiEnvBuilder,
+};
+
+#[derive(Debug, Clone)]
+pub struct MappedCommand {
+    /// The new alias.
+    pub alias: String,
+    /// The original command.
+    pub target: String,
+}
+
+#[derive(Derivative, Default, Clone)]
+#[derivative(Debug)]
+pub(crate) struct CommonWasiOptions {
+    pub(crate) args: Vec<String>,
+    pub(crate) env: HashMap<String, String>,
+    pub(crate) forward_host_env: bool,
+    pub(crate) mapped_host_commands: Vec<MappedCommand>,
+    pub(crate) mounts: Vec<MountedDirectory>,
+    pub(crate) injected_packages: Vec<BinaryPackage>,
+    pub(crate) capabilities: Capabilities,
+    #[derivative(Debug = "ignore")]
+    pub(crate) journals: Vec<Arc<DynJournal>>,
+    pub(crate) snapshot_on: Vec<SnapshotTrigger>,
+    pub(crate) snapshot_interval: Option<std::time::Duration>,
+    pub(crate) current_dir: Option<PathBuf>,
+    pub(crate) additional_imports: Imports,
+}
+
+impl CommonWasiOptions {
+    pub(crate) fn prepare_webc_env(
+        &self,
+        builder: &mut WasiEnvBuilder,
+        container_fs: Option<Arc<dyn FileSystem + Send + Sync>>,
+        wasi: &WasiAnnotation,
+        root_fs: Option<TmpFileSystem>,
+    ) -> Result<(), anyhow::Error> {
+        let root_fs = root_fs.unwrap_or_else(|| RootFileSystemBuilder::default().build());
+        let fs = prepare_filesystem(root_fs, &self.mounts, container_fs)?;
+
+        builder.add_preopen_dir("/")?;
+
+        if self.mounts.iter().all(|m| m.guest != ".") {
+            // The user hasn't mounted "." to anything, so let's map it to "/"
+            builder.add_map_dir(".", "/")?;
+        }
+
+        builder.set_fs(Box::new(fs));
+
+        for pkg in &self.injected_packages {
+            builder.add_webc(pkg.clone());
+        }
+
+        let mapped_cmds = self
+            .mapped_host_commands
+            .iter()
+            .map(|c| (c.alias.as_str(), c.target.as_str()));
+        builder.add_mapped_commands(mapped_cmds);
+
+        self.populate_env(wasi, builder);
+        self.populate_args(wasi, builder);
+
+        *builder.capabilities_mut() = self.capabilities.clone();
+
+        builder.add_imports(&self.additional_imports);
+
+        Ok(())
+    }
+
+    fn populate_env(&self, wasi: &WasiAnnotation, builder: &mut WasiEnvBuilder) {
+        for item in wasi.env.as_deref().unwrap_or_default() {
+            // TODO(Michael-F-Bryan): Convert "wasi.env" in the webc crate from an
+            // Option<Vec<String>> to a HashMap<String, String> so we avoid this
+            // string.split() business
+            match item.split_once('=') {
+                Some((k, v)) => {
+                    builder.add_env(k, v);
+                }
+                None => {
+                    builder.add_env(item, String::new());
+                }
+            }
+        }
+
+        if self.forward_host_env {
+            builder.add_envs(std::env::vars());
+        }
+
+        builder.add_envs(self.env.clone());
+    }
+
+    fn populate_args(&self, wasi: &WasiAnnotation, builder: &mut WasiEnvBuilder) {
+        if let Some(main_args) = &wasi.main_args {
+            builder.add_args(main_args);
+        }
+
+        builder.add_args(&self.args);
+    }
+}
+
+// type ContainerFs =
+//     OverlayFileSystem<TmpFileSystem, [RelativeOrAbsolutePathHack<Arc<dyn FileSystem>>; 1]>;
+
+fn build_directory_mappings(
+    root_fs: &mut TmpFileSystem,
+    mounted_dirs: &[MountedDirectory],
+) -> Result<(), anyhow::Error> {
+    for dir in mounted_dirs {
+        let MountedDirectory {
+            guest: guest_path,
+            fs,
+        } = dir;
+        let mut guest_path = PathBuf::from(guest_path);
+        tracing::debug!(
+            guest=%guest_path.display(),
+            "Mounting",
+        );
+
+        if guest_path.is_relative() {
+            guest_path = apply_relative_path_mounting_hack(&guest_path);
+        }
+
+        let guest_path = root_fs
+            .canonicalize_unchecked(&guest_path)
+            .with_context(|| {
+                format!(
+                    "Unable to canonicalize guest path '{}'",
+                    guest_path.display()
+                )
+            })?;
+
+        if guest_path == Path::new("/") {
+            root_fs
+                .mount_directory_entries(&guest_path, fs, "/".as_ref())
+                .context("Unable to mount to root")?;
+        } else {
+            if let Some(parent) = guest_path.parent() {
+                create_dir_all(&*root_fs, parent).with_context(|| {
+                    format!("Unable to create the \"{}\" directory", parent.display())
+                })?;
+            }
+
+            root_fs
+                .mount(guest_path.clone(), fs, "/".into())
+                .with_context(|| format!("Unable to mount \"{}\"", guest_path.display()))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn prepare_filesystem(
+    mut root_fs: TmpFileSystem,
+    mounted_dirs: &[MountedDirectory],
+    container_fs: Option<Arc<dyn FileSystem + Send + Sync>>,
+) -> Result<Box<dyn FileSystem + Send + Sync>, Error> {
+    if !mounted_dirs.is_empty() {
+        build_directory_mappings(&mut root_fs, mounted_dirs)?;
+    }
+
+    // HACK(Michael-F-Bryan): The WebcVolumeFileSystem only accepts relative
+    // paths, but our Python executable will try to access its standard library
+    // with relative paths assuming that it is being run from the root
+    // directory (i.e. it does `open("lib/python3.6/io.py")` instead of
+    // `open("/lib/python3.6/io.py")`).
+    // Until the FileSystem trait figures out whether relative paths should be
+    // supported or not, we'll add an adapter that automatically retries
+    // operations using an absolute path if it failed using a relative path.
+
+    let fs = if let Some(container) = container_fs {
+        let container = RelativeOrAbsolutePathHack(container);
+        let fs = OverlayFileSystem::new(root_fs, [container]);
+        Box::new(fs) as Box<dyn FileSystem + Send + Sync>
+    } else {
+        let fs = RelativeOrAbsolutePathHack(root_fs);
+        Box::new(fs) as Box<dyn FileSystem + Send + Sync>
+    };
+
+    Ok(fs)
+}
+
+/// HACK: We need this so users can mount host directories at relative paths.
+/// This assumes that the current directory when a runner starts will be "/", so
+/// instead of mounting to a relative path, we just mount to "/$path".
+///
+/// This isn't really a long-term solution because there is no guarantee what
+/// the current directory will be. The WASI spec also doesn't require the
+/// current directory to be part of the "main" filesystem at all, we really
+/// *should* be mounting to a relative directory but that isn't supported by our
+/// virtual fs layer.
+///
+/// See <https://github.com/wasmerio/wasmer/issues/3794> for more.
+fn apply_relative_path_mounting_hack(original: &Path) -> PathBuf {
+    debug_assert!(original.is_relative());
+
+    let root = Path::new("/");
+    let mapped_path = if original == Path::new(".") {
+        root.to_path_buf()
+    } else {
+        root.join(original)
+    };
+
+    tracing::debug!(
+        original_path=%original.display(),
+        remapped_path=%mapped_path.display(),
+        "Remapping a relative path"
+    );
+
+    mapped_path
+}
+
+fn create_dir_all(fs: &dyn FileSystem, path: &Path) -> Result<(), Error> {
+    if fs.metadata(path).is_ok() {
+        return Ok(());
+    }
+
+    if let Some(parent) = path.parent() {
+        create_dir_all(fs, parent)?;
+    }
+
+    fs.create_dir(path)?;
+
+    Ok(())
+}
+
+#[derive(Debug, Clone)]
+pub struct MountedDirectory {
+    pub guest: String,
+    pub fs: Arc<dyn FileSystem + Send + Sync>,
+}
+
+/// A directory that should be mapped from the host filesystem into a WASI
+/// instance (the "guest").
+///
+/// # Panics
+///
+/// Converting a [`MappedDirectory`] to a [`MountedDirectory`] requires enabling
+/// the `host-fs` feature flag. Using the [`From`] implementation without
+/// enabling this feature will result in a runtime panic.
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct MappedDirectory {
+    /// The absolute path for a directory on the host filesystem.
+    pub host: std::path::PathBuf,
+    /// The absolute path specifying where the host directory should be mounted
+    /// inside the guest.
+    pub guest: String,
+}
+
+impl From<MappedDirectory> for MountedDirectory {
+    fn from(value: MappedDirectory) -> Self {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "host-fs")] {
+                let MappedDirectory { host, guest } = value;
+                let fs: Arc<dyn FileSystem + Send + Sync> =
+                    Arc::new(virtual_fs::ScopedDirectoryFileSystem::new_with_default_runtime(host));
+
+                MountedDirectory { guest, fs }
+            } else {
+                unreachable!("The `host-fs` feature needs to be enabled to map {value:?}")
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct RelativeOrAbsolutePathHack<F>(F);
+
+impl<F: FileSystem> RelativeOrAbsolutePathHack<F> {
+    fn execute<Func, Ret>(&self, path: &Path, operation: Func) -> Result<Ret, FsError>
+    where
+        Func: Fn(&F, &Path) -> Result<Ret, FsError>,
+    {
+        // First, try it with the path we were given
+        let result = operation(&self.0, path);
+
+        if result.is_err() && !path.is_absolute() {
+            // we were given a relative path, but maybe the operation will work
+            // using absolute paths instead.
+            let path = Path::new("/").join(path);
+            operation(&self.0, &path)
+        } else {
+            result
+        }
+    }
+}
+
+impl<F: FileSystem> virtual_fs::FileSystem for RelativeOrAbsolutePathHack<F> {
+    fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
+        self.execute(path, |fs, p| fs.read_dir(p))
+    }
+
+    fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.create_dir(p))
+    }
+
+    fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.remove_dir(p))
+    }
+
+    fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        Box::pin(async move { self.0.rename(&from, &to).await })
+    }
+
+    fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        self.execute(path, |fs, p| fs.metadata(p))
+    }
+
+    fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
+        self.execute(path, |fs, p| fs.remove_file(p))
+    }
+
+    fn new_open_options(&self) -> virtual_fs::OpenOptions {
+        virtual_fs::OpenOptions::new(self)
+    }
+}
+
+impl<F: FileSystem> virtual_fs::FileOpener for RelativeOrAbsolutePathHack<F> {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &virtual_fs::OpenOptionsConfig,
+    ) -> virtual_fs::Result<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>> {
+        self.execute(path, |fs, p| {
+            fs.new_open_options().options(conf.clone()).open(p)
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::SystemTime;
+
+    use tempfile::TempDir;
+    use virtual_fs::{DirEntry, FileType, Metadata, WebcVolumeFileSystem};
+    use webc::Container;
+
+    use super::*;
+
+    const PYTHON: &[u8] = include_bytes!("../../../c-api/examples/assets/python-0.1.0.wasmer");
+
+    /// Fixes <https://github.com/wasmerio/wasmer/issues/3789>
+    #[tokio::test]
+    async fn mix_args_from_the_webc_and_user() {
+        let args = CommonWasiOptions {
+            args: vec!["extra".to_string(), "args".to_string()],
+            ..Default::default()
+        };
+        let mut builder = WasiEnvBuilder::new("program-name");
+        let fs = Arc::new(virtual_fs::EmptyFileSystem::default());
+        let mut annotations = WasiAnnotation::new("some-atom");
+        annotations.main_args = Some(vec![
+            "hard".to_string(),
+            "coded".to_string(),
+            "args".to_string(),
+        ]);
+
+        args.prepare_webc_env(&mut builder, Some(fs), &annotations, None)
+            .unwrap();
+
+        assert_eq!(
+            builder.get_args(),
+            [
+                // the program name from
+                "program-name",
+                // from the WEBC's annotations
+                "hard",
+                "coded",
+                "args",
+                // from the user
+                "extra",
+                "args",
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn mix_env_vars_from_the_webc_and_user() {
+        let args = CommonWasiOptions {
+            env: vec![("EXTRA".to_string(), "envs".to_string())]
+                .into_iter()
+                .collect(),
+            ..Default::default()
+        };
+        let mut builder = WasiEnvBuilder::new("python");
+        let fs = Arc::new(virtual_fs::EmptyFileSystem::default());
+        let mut annotations = WasiAnnotation::new("python");
+        annotations.env = Some(vec!["HARD_CODED=env-vars".to_string()]);
+
+        args.prepare_webc_env(&mut builder, Some(fs), &annotations, None)
+            .unwrap();
+
+        assert_eq!(
+            builder.get_env(),
+            [
+                ("HARD_CODED".to_string(), b"env-vars".to_vec()),
+                ("EXTRA".to_string(), b"envs".to_vec()),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    #[cfg_attr(not(feature = "host-fs"), ignore)]
+    async fn python_use_case() {
+        let temp = TempDir::new().unwrap();
+        let sub_dir = temp.path().join("path").join("to");
+        std::fs::create_dir_all(&sub_dir).unwrap();
+        std::fs::write(sub_dir.join("file.txt"), b"Hello, World!").unwrap();
+        let mapping = [MountedDirectory::from(MappedDirectory {
+            guest: "/home".to_string(),
+            host: sub_dir,
+        })];
+        let container = Container::from_bytes(PYTHON).unwrap();
+        let webc_fs = WebcVolumeFileSystem::mount_all(&container);
+
+        let root_fs = RootFileSystemBuilder::default().build();
+        let fs = prepare_filesystem(root_fs, &mapping, Some(Arc::new(webc_fs))).unwrap();
+
+        assert!(fs.metadata("/home/file.txt".as_ref()).unwrap().is_file());
+        assert!(fs.metadata("lib".as_ref()).unwrap().is_dir());
+        assert!(fs
+            .metadata("lib/python3.6/collections/__init__.py".as_ref())
+            .unwrap()
+            .is_file());
+        assert!(fs
+            .metadata("lib/python3.6/encodings/__init__.py".as_ref())
+            .unwrap()
+            .is_file());
+    }
+
+    fn unix_timestamp_nanos(instant: SystemTime) -> Option<u64> {
+        let duration = instant.duration_since(SystemTime::UNIX_EPOCH).ok()?;
+        Some(duration.as_nanos() as u64)
+    }
+
+    #[tokio::test]
+    #[cfg_attr(not(feature = "host-fs"), ignore)]
+    async fn convert_mapped_directory_to_mounted_directory() {
+        let temp = TempDir::new().unwrap();
+        let dir = MappedDirectory {
+            guest: "/mnt/dir".to_string(),
+            host: temp.path().to_path_buf(),
+        };
+        let contents = "Hello, World!";
+        let file_txt = temp.path().join("file.txt");
+        std::fs::write(&file_txt, contents).unwrap();
+        let metadata = std::fs::metadata(&file_txt).unwrap();
+
+        let got = MountedDirectory::from(dir);
+
+        let directory_contents: Vec<_> = got
+            .fs
+            .read_dir("/".as_ref())
+            .unwrap()
+            .map(|entry| entry.unwrap())
+            .collect();
+        assert_eq!(
+            directory_contents,
+            vec![DirEntry {
+                path: PathBuf::from("/file.txt"),
+                metadata: Ok(Metadata {
+                    ft: FileType::new_file(),
+                    // Note: Some timestamps aren't available on MUSL and will
+                    // default to zero.
+                    accessed: metadata
+                        .accessed()
+                        .ok()
+                        .and_then(unix_timestamp_nanos)
+                        .unwrap_or(0),
+                    created: metadata
+                        .created()
+                        .ok()
+                        .and_then(unix_timestamp_nanos)
+                        .unwrap_or(0),
+                    modified: metadata
+                        .modified()
+                        .ok()
+                        .and_then(unix_timestamp_nanos)
+                        .unwrap_or(0),
+                    len: contents.len() as u64,
+                })
+            }]
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/callbacks.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/callbacks.rs
new file mode 100644
index 0000000..1716691
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/callbacks.rs
@@ -0,0 +1,62 @@
+use std::{collections::HashMap, sync::Arc};
+
+use virtual_fs::Pipe;
+use wasmer::{Memory, Module, Store};
+
+use crate::{runtime::module_cache::ModuleHash, WasiEnv};
+
+use super::{create_env::default_recycle_env, handler::SetupBuilder, *};
+
+/// Configuration used for creating a new environment
+pub struct CreateEnvConfig {
+    pub env: HashMap<String, String>,
+    pub program_name: String,
+    pub module: Module,
+    pub module_hash: ModuleHash,
+    pub runtime: Arc<dyn crate::runtime::Runtime + Send + Sync>,
+    pub setup_builder: SetupBuilder,
+}
+
+/// Result of a create operation on a new environment
+pub struct CreateEnvResult {
+    pub env: WasiEnv,
+    pub memory: Option<(Memory, Store)>,
+    pub body_sender: Pipe,
+    pub body_receiver: Pipe,
+    pub stderr_receiver: Pipe,
+}
+
+/// Configuration used for reusing an new environment
+pub struct RecycleEnvConfig {
+    pub env: WasiEnv,
+    pub memory: Memory,
+    pub store: Store,
+}
+
+/// Callbacks that are triggered at various points in the lifecycle of a runner
+/// and any WebAssembly instances it may start.
+#[async_trait::async_trait]
+pub trait Callbacks: Send + Sync + 'static {
+    /// A callback that is called whenever the server starts.
+    fn started(&self, _abort: AbortHandle) {}
+
+    /// Data was written to stderr by an instance.
+    fn on_stderr(&self, _stderr: &[u8]) {}
+
+    /// Reading from stderr failed.
+    fn on_stderr_error(&self, _error: std::io::Error) {}
+
+    /// Recycle the WASI environment
+    async fn recycle_env(&self, conf: RecycleEnvConfig) {
+        default_recycle_env(conf).await
+    }
+
+    /// Create the WASI environment
+    async fn create_env(&self, conf: CreateEnvConfig) -> anyhow::Result<CreateEnvResult> {
+        default_create_env(conf).await
+    }
+}
+
+pub struct NoOpWcgiCallbacks;
+
+impl Callbacks for NoOpWcgiCallbacks {}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/create_env.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/create_env.rs
new file mode 100644
index 0000000..c8ab9fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/create_env.rs
@@ -0,0 +1,48 @@
+use virtual_fs::Pipe;
+
+use crate::{
+    capabilities::Capabilities, http::HttpClientCapabilityV1,
+    runners::wcgi::callbacks::CreateEnvResult, WasiEnvBuilder,
+};
+
+use super::{callbacks::CreateEnvConfig, RecycleEnvConfig};
+
+pub(crate) async fn default_recycle_env(mut conf: RecycleEnvConfig) {
+    tracing::debug!("Destroying the WebAssembly instance");
+
+    conf.env.disable_fs_cleanup = false;
+    conf.env.on_exit(None).await;
+}
+
+pub(crate) async fn default_create_env(conf: CreateEnvConfig) -> anyhow::Result<CreateEnvResult> {
+    tracing::debug!("Creating the WebAssembly instance");
+
+    let (req_body_sender, req_body_receiver) = Pipe::channel();
+    let (res_body_sender, res_body_receiver) = Pipe::channel();
+    let (stderr_sender, stderr_receiver) = Pipe::channel();
+
+    let mut builder = WasiEnvBuilder::new(&conf.program_name);
+
+    (conf.setup_builder)(&mut builder)?;
+
+    builder.add_envs(conf.env);
+
+    let builder = builder
+        .stdin(Box::new(req_body_receiver))
+        .stdout(Box::new(res_body_sender))
+        .stderr(Box::new(stderr_sender))
+        .capabilities(Capabilities {
+            insecure_allow_all: true,
+            http_client: HttpClientCapabilityV1::new_allow_all(),
+            threading: Default::default(),
+        });
+    let env = builder.build()?;
+
+    Ok(CreateEnvResult {
+        env,
+        memory: None,
+        body_sender: req_body_sender,
+        body_receiver: res_body_receiver,
+        stderr_receiver,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/handler.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/handler.rs
new file mode 100644
index 0000000..6f0eb01
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/handler.rs
@@ -0,0 +1,344 @@
+use std::{collections::HashMap, ops::Deref, pin::Pin, sync::Arc, task::Poll};
+
+use anyhow::Error;
+use futures::{Future, FutureExt, StreamExt};
+use http::{Request, Response, StatusCode};
+use hyper::{service::Service, Body};
+use tokio::io::{AsyncBufReadExt, AsyncRead, AsyncWrite, AsyncWriteExt};
+use tracing::Instrument;
+use virtual_mio::InlineWaker;
+use wasmer::Module;
+use wasmer_wasix_types::wasi::ExitCode;
+use wcgi_host::CgiDialect;
+
+use crate::{
+    bin_factory::run_exec,
+    os::task::OwnedTaskStatus,
+    runners::wcgi::{
+        callbacks::{CreateEnvConfig, RecycleEnvConfig},
+        Callbacks,
+    },
+    runtime::{
+        module_cache::ModuleHash,
+        task_manager::{TaskWasm, TaskWasmRecycleProperties},
+    },
+    Runtime, VirtualTaskManager, WasiEnvBuilder,
+};
+
+/// The shared object that manages the instantiaion of WASI executables and
+/// communicating with them via the CGI protocol.
+#[derive(Clone, Debug)]
+pub(crate) struct Handler(Arc<SharedState>);
+
+impl Handler {
+    pub(crate) fn new(state: Arc<SharedState>) -> Self {
+        Handler(state)
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, err)]
+    pub(crate) async fn handle<T>(
+        &self,
+        req: Request<Body>,
+        token: T,
+    ) -> Result<Response<Body>, Error>
+    where
+        T: Send + 'static,
+    {
+        tracing::debug!(headers=?req.headers());
+
+        let (parts, body) = req.into_parts();
+
+        // Note: We want to apply the CGI environment variables *after*
+        // anything specified by WASI annotations so users get a chance to
+        // override things like $DOCUMENT_ROOT and $SCRIPT_FILENAME.
+        let mut request_specific_env = HashMap::new();
+        request_specific_env.insert("REQUEST_METHOD".to_string(), parts.method.to_string());
+        request_specific_env.insert("SCRIPT_NAME".to_string(), parts.uri.path().to_string());
+        if let Some(query) = parts.uri.query() {
+            request_specific_env.insert("QUERY_STRING".to_string(), query.to_string());
+        }
+        self.dialect
+            .prepare_environment_variables(parts, &mut request_specific_env);
+
+        let create = self
+            .callbacks
+            .create_env(CreateEnvConfig {
+                env: request_specific_env,
+                program_name: self.program_name.clone(),
+                module: self.module.clone(),
+                module_hash: self.module_hash,
+                runtime: self.runtime.clone(),
+                setup_builder: self.setup_builder.clone(),
+            })
+            .await?;
+
+        tracing::debug!(
+            dialect=%self.dialect,
+            "Calling into the WCGI executable",
+        );
+
+        let task_manager = self.runtime.task_manager();
+        let env = create.env;
+        let module = self.module.clone();
+
+        // The recycle function will attempt to reuse the instance
+        let callbacks = Arc::clone(&self.callbacks);
+        let recycle = {
+            let callbacks = callbacks.clone();
+            move |props: TaskWasmRecycleProperties| {
+                InlineWaker::block_on(callbacks.recycle_env(RecycleEnvConfig {
+                    env: props.env,
+                    store: props.store,
+                    memory: props.memory,
+                }));
+
+                // We release the token after we recycle the environment
+                // so that race conditions (such as reusing instances) are
+                // avoided
+                drop(token);
+            }
+        };
+        let finished = env.process.finished.clone();
+
+        /*
+         * TODO: Reusing memory for DCGI calls and not just the file system
+         *
+         * DCGI does not support reusing the memory for the following reasons
+         * 1. The environment variables can not be overridden after libc does its lazy loading
+         * 2. The HTTP request variables are passed as environment variables and hence can not be changed
+         *    after the first call is made on the memory
+         * 3. The `SpawnMemoryType` is not send however this handler is running as a Send async. In order
+         *    to fix this the entire handler would need to run in its own non-Send thread.
+
+        // Determine if we are going to create memory and import it or just rely on self creation of memory
+        let spawn_type = create
+            .memory
+            .map(|memory| SpawnMemoryType::ShareMemory(memory, store.as_store_ref()));
+        */
+
+        // We run the WCGI thread on the dedicated WASM
+        // thread pool that has support for asynchronous
+        // threading, etc...
+        task_manager
+            .task_wasm(
+                TaskWasm::new(Box::new(run_exec), env, module, false)
+                    //.with_optional_memory(spawn_type)
+                    .with_recycle(Box::new(recycle)),
+            )
+            .map_err(|err| {
+                tracing::warn!("failed to execute WCGI thread - {}", err);
+                err
+            })?;
+
+        let mut res_body_receiver = tokio::io::BufReader::new(create.body_receiver);
+
+        let stderr_receiver = create.stderr_receiver;
+        let propagate_stderr = self.propagate_stderr;
+        let work_consume_stderr = {
+            let callbacks = callbacks.clone();
+            async move { consume_stderr(stderr_receiver, callbacks, propagate_stderr).await }
+                .in_current_span()
+        };
+
+        tracing::trace!(
+            dialect=%self.dialect,
+            "spawning request forwarder",
+        );
+
+        let req_body_sender = create.body_sender;
+        let ret = drive_request_to_completion(finished, body, req_body_sender).await;
+
+        // When set this will cause any stderr responses to
+        // take precedence over nominal responses but it
+        // will cause the stderr pipe to be read to the end
+        // before transmitting the body
+        if propagate_stderr {
+            if let Some(stderr) = work_consume_stderr.await {
+                if !stderr.is_empty() {
+                    return Ok(Response::builder()
+                        .status(StatusCode::INTERNAL_SERVER_ERROR)
+                        .body(Body::from(stderr))?);
+                }
+            }
+        } else {
+            task_manager
+                .task_shared(Box::new(move || {
+                    Box::pin(async move {
+                        work_consume_stderr.await;
+                    })
+                }))
+                .ok();
+        }
+
+        match ret {
+            Ok(_) => {}
+            Err(e) => {
+                let e = e.to_string();
+                tracing::error!(error = e, "Unable to drive the request to completion");
+                return Ok(Response::builder()
+                    .status(StatusCode::INTERNAL_SERVER_ERROR)
+                    .body(Body::from(e.as_bytes().to_vec()))?);
+            }
+        }
+
+        tracing::trace!(
+            dialect=%self.dialect,
+            "extracting response parts",
+        );
+
+        let parts = self
+            .dialect
+            .extract_response_header(&mut res_body_receiver)
+            .await;
+        let parts = parts?;
+
+        tracing::trace!(
+            dialect=%self.dialect,
+            status=%parts.status,
+            "received response parts",
+        );
+
+        let chunks = futures::stream::try_unfold(res_body_receiver, |mut r| async move {
+            match r.fill_buf().await {
+                Ok(chunk) if chunk.is_empty() => Ok(None),
+                Ok(chunk) => {
+                    let chunk = chunk.to_vec();
+                    r.consume(chunk.len());
+                    Ok(Some((chunk, r)))
+                }
+                Err(e) => Err(e),
+            }
+        });
+        let body = hyper::Body::wrap_stream(chunks);
+
+        tracing::trace!(
+            dialect=%self.dialect,
+            "returning response with body stream",
+        );
+
+        let response = hyper::Response::from_parts(parts, body);
+        Ok(response)
+    }
+}
+
+impl Deref for Handler {
+    type Target = Arc<SharedState>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+/// Drive the request to completion by streaming the request body to the
+/// instance and waiting for it to exit.
+async fn drive_request_to_completion(
+    finished: Arc<OwnedTaskStatus>,
+    mut request_body: hyper::Body,
+    mut instance_stdin: impl AsyncWrite + Send + Sync + Unpin + 'static,
+) -> Result<ExitCode, Error> {
+    let request_body_send = async move {
+        // Copy the request into our instance, chunk-by-chunk. If the instance
+        // dies before we finish writing the body, the instance's side of the
+        // pipe will be automatically closed and we'll error out.
+        let mut request_size = 0;
+        while let Some(res) = request_body.next().await {
+            // FIXME(theduke): figure out how to propagate a body error to the
+            // CGI instance.
+            let chunk = res?;
+            request_size += chunk.len();
+            instance_stdin.write_all(chunk.as_ref()).await?;
+        }
+
+        instance_stdin.shutdown().await?;
+        tracing::debug!(
+            request_size,
+            "Finished forwarding the request to the WCGI server"
+        );
+
+        Ok::<(), Error>(())
+    }
+    .in_current_span();
+
+    let (ret, _) = futures::try_join!(finished.await_termination_anyhow(), request_body_send)?;
+    Ok(ret)
+}
+
+/// Read the instance's stderr, taking care to preserve output even when WASI
+/// pipe errors occur so users still have *something* they use for
+/// troubleshooting.
+async fn consume_stderr(
+    stderr: impl AsyncRead + Send + Unpin + 'static,
+    callbacks: Arc<dyn Callbacks>,
+    propagate_stderr: bool,
+) -> Option<Vec<u8>> {
+    let mut stderr = tokio::io::BufReader::new(stderr);
+
+    let mut propagate = match propagate_stderr {
+        true => Some(Vec::new()),
+        false => None,
+    };
+
+    // Note: we don't want to just read_to_end() because a reading error
+    // would cause us to lose all of stderr. At least this way we'll be
+    // able to show users the partial result.
+    loop {
+        match stderr.fill_buf().await {
+            Ok(chunk) if chunk.is_empty() => {
+                // EOF - the instance's side of the pipe was closed.
+                break;
+            }
+            Ok(chunk) => {
+                tracing::trace!("received stderr (len={})", chunk.len());
+                if let Some(propogate) = propagate.as_mut() {
+                    propogate.write_all(chunk).await.ok();
+                }
+                callbacks.on_stderr(chunk);
+                let bytes_read = chunk.len();
+                stderr.consume(bytes_read);
+            }
+            Err(e) => {
+                tracing::trace!("received stderr (err={})", e);
+                callbacks.on_stderr_error(e);
+                break;
+            }
+        }
+    }
+
+    propagate
+}
+
+pub type SetupBuilder = Arc<dyn Fn(&mut WasiEnvBuilder) -> Result<(), anyhow::Error> + Send + Sync>;
+
+#[derive(derivative::Derivative)]
+#[derivative(Debug)]
+pub(crate) struct SharedState {
+    pub(crate) module: Module,
+    pub(crate) module_hash: ModuleHash,
+    pub(crate) dialect: CgiDialect,
+    pub(crate) program_name: String,
+    pub(crate) propagate_stderr: bool,
+    #[derivative(Debug = "ignore")]
+    pub(crate) setup_builder: SetupBuilder,
+    #[derivative(Debug = "ignore")]
+    pub(crate) callbacks: Arc<dyn Callbacks>,
+    #[derivative(Debug = "ignore")]
+    pub(crate) runtime: Arc<dyn Runtime + Send + Sync>,
+}
+
+impl Service<Request<Body>> for Handler {
+    type Response = Response<Body>;
+    type Error = Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Response<Body>, Error>> + Send>>;
+
+    fn poll_ready(&mut self, _cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
+        // TODO: We probably should implement some sort of backpressure here...
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, request: Request<Body>) -> Self::Future {
+        // Note: all fields are reference-counted so cloning is pretty cheap
+        let handler = self.clone();
+        let fut = async move { handler.handle(request, ()).await };
+        fut.boxed()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/mod.rs
new file mode 100644
index 0000000..29dad55
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/mod.rs
@@ -0,0 +1,11 @@
+mod callbacks;
+mod create_env;
+mod handler;
+mod runner;
+
+pub use self::runner::{Config, WcgiRunner};
+pub use callbacks::NoOpWcgiCallbacks;
+pub use callbacks::{Callbacks, CreateEnvConfig, CreateEnvResult, RecycleEnvConfig};
+pub(crate) use create_env::default_create_env;
+pub use futures::future::AbortHandle;
+pub(crate) use handler::{Handler, SharedState};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/runner.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/runner.rs
new file mode 100644
index 0000000..b814694
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runners/wcgi/runner.rs
@@ -0,0 +1,341 @@
+use std::{net::SocketAddr, sync::Arc, time::Duration};
+
+use anyhow::{Context, Error};
+use http::{Request, Response};
+use hyper::Body;
+use tower::{make::Shared, Service, ServiceBuilder};
+use tower_http::{catch_panic::CatchPanicLayer, cors::CorsLayer, trace::TraceLayer};
+use tracing::Span;
+use wcgi_host::CgiDialect;
+use webc::metadata::{
+    annotations::{Wasi, Wcgi},
+    Command,
+};
+
+use crate::{
+    bin_factory::BinaryPackage,
+    capabilities::Capabilities,
+    runners::{
+        wasi_common::CommonWasiOptions,
+        wcgi::handler::{Handler, SharedState},
+        MappedDirectory,
+    },
+    runtime::task_manager::VirtualTaskManagerExt,
+    Runtime, WasiEnvBuilder,
+};
+
+use super::Callbacks;
+
+#[derive(Debug)]
+pub struct WcgiRunner {
+    config: Config,
+}
+
+impl WcgiRunner {
+    pub fn new<C>(callbacks: C) -> Self
+    where
+        C: Callbacks,
+    {
+        Self {
+            config: Config::new(callbacks),
+        }
+    }
+
+    pub fn config(&mut self) -> &mut Config {
+        &mut self.config
+    }
+
+    #[tracing::instrument(skip_all)]
+    pub(crate) fn prepare_handler(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        propagate_stderr: bool,
+        default_dialect: CgiDialect,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<Handler, Error> {
+        let cmd = pkg
+            .get_command(command_name)
+            .with_context(|| format!("The package doesn't contain a \"{command_name}\" command"))?;
+        let metadata = cmd.metadata();
+        let wasi = metadata
+            .annotation("wasi")?
+            .unwrap_or_else(|| Wasi::new(command_name));
+
+        let module = runtime.load_module_sync(cmd.atom())?;
+
+        let Wcgi { dialect, .. } = metadata.annotation("wcgi")?.unwrap_or_default();
+        let dialect = match dialect {
+            Some(d) => d.parse().context("Unable to parse the CGI dialect")?,
+            None => default_dialect,
+        };
+
+        let container_fs = Arc::clone(&pkg.webc_fs);
+
+        let wasi_common = self.config.wasi.clone();
+        let rt = Arc::clone(&runtime);
+        let setup_builder = move |builder: &mut WasiEnvBuilder| {
+            wasi_common.prepare_webc_env(builder, Some(Arc::clone(&container_fs)), &wasi, None)?;
+            builder.set_runtime(Arc::clone(&rt));
+            Ok(())
+        };
+
+        let shared = SharedState {
+            module,
+            module_hash: pkg.hash(),
+            dialect,
+            propagate_stderr,
+            program_name: command_name.to_string(),
+            setup_builder: Arc::new(setup_builder),
+            callbacks: Arc::clone(&self.config.callbacks),
+            runtime,
+        };
+
+        Ok(Handler::new(Arc::new(shared)))
+    }
+
+    pub(crate) fn run_command_with_handler<S>(
+        &mut self,
+        handler: S,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error>
+    where
+        S: Service<
+            Request<Body>,
+            Response = http::Response<Body>,
+            Error = anyhow::Error,
+            Future = std::pin::Pin<
+                Box<dyn futures::Future<Output = Result<Response<Body>, Error>> + Send>,
+            >,
+        >,
+        S: Clone + Send + Sync + 'static,
+    {
+        let service = ServiceBuilder::new()
+            .layer(
+                TraceLayer::new_for_http()
+                    .make_span_with(|request: &Request<Body>| {
+                        tracing::info_span!(
+                            "request",
+                            method = %request.method(),
+                            uri = %request.uri(),
+                            status_code = tracing::field::Empty,
+                        )
+                    })
+                    .on_response(|response: &Response<_>, _latency: Duration, span: &Span| {
+                        span.record("status_code", &tracing::field::display(response.status()));
+                        tracing::info!("response generated")
+                    }),
+            )
+            .layer(CatchPanicLayer::new())
+            .layer(CorsLayer::permissive())
+            .service(handler);
+
+        let address = self.config.addr;
+        tracing::info!(%address, "Starting the server");
+
+        let callbacks = Arc::clone(&self.config.callbacks);
+        runtime
+            .task_manager()
+            .spawn_and_block_on(async move {
+                let (shutdown, abort_handle) =
+                    futures::future::abortable(futures::future::pending::<()>());
+
+                callbacks.started(abort_handle);
+
+                hyper::Server::bind(&address)
+                    .serve(Shared::new(service))
+                    .with_graceful_shutdown(async {
+                        let _ = shutdown.await;
+                        tracing::info!("Shutting down gracefully");
+                    })
+                    .await
+            })
+            .context("Unable to start the server")??;
+
+        Ok(())
+    }
+}
+
+impl crate::runners::Runner for WcgiRunner {
+    fn can_run_command(command: &Command) -> Result<bool, Error> {
+        Ok(command
+            .runner
+            .starts_with(webc::metadata::annotations::WCGI_RUNNER_URI))
+    }
+
+    fn run_command(
+        &mut self,
+        command_name: &str,
+        pkg: &BinaryPackage,
+        runtime: Arc<dyn Runtime + Send + Sync>,
+    ) -> Result<(), Error> {
+        let handler = self.prepare_handler(
+            command_name,
+            pkg,
+            false,
+            CgiDialect::Wcgi,
+            Arc::clone(&runtime),
+        )?;
+        self.run_command_with_handler(handler, runtime)
+    }
+}
+
+#[derive(derivative::Derivative)]
+#[derivative(Debug)]
+pub struct Config {
+    pub(crate) wasi: CommonWasiOptions,
+    pub(crate) addr: SocketAddr,
+    #[derivative(Debug = "ignore")]
+    pub(crate) callbacks: Arc<dyn Callbacks>,
+}
+
+impl Config {
+    pub fn addr(&mut self, addr: SocketAddr) -> &mut Self {
+        self.addr = addr;
+        self
+    }
+
+    /// Add an argument to the WASI executable's command-line arguments.
+    pub fn arg(&mut self, arg: impl Into<String>) -> &mut Self {
+        self.wasi.args.push(arg.into());
+        self
+    }
+
+    /// Add multiple arguments to the WASI executable's command-line arguments.
+    pub fn args<A, S>(&mut self, args: A) -> &mut Self
+    where
+        A: IntoIterator<Item = S>,
+        S: Into<String>,
+    {
+        self.wasi.args.extend(args.into_iter().map(|s| s.into()));
+        self
+    }
+
+    /// Expose an environment variable to the guest.
+    pub fn env(&mut self, name: impl Into<String>, value: impl Into<String>) -> &mut Self {
+        self.wasi.env.insert(name.into(), value.into());
+        self
+    }
+
+    /// Expose multiple environment variables to the guest.
+    pub fn envs<I, K, V>(&mut self, variables: I) -> &mut Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        self.wasi
+            .env
+            .extend(variables.into_iter().map(|(k, v)| (k.into(), v.into())));
+        self
+    }
+
+    /// Forward all of the host's environment variables to the guest.
+    pub fn forward_host_env(&mut self) -> &mut Self {
+        self.wasi.forward_host_env = true;
+        self
+    }
+
+    pub fn map_directory(&mut self, dir: MappedDirectory) -> &mut Self {
+        self.wasi.mounts.push(dir.into());
+        self
+    }
+
+    pub fn map_directories(
+        &mut self,
+        mappings: impl IntoIterator<Item = MappedDirectory>,
+    ) -> &mut Self {
+        for mapping in mappings {
+            self.map_directory(mapping);
+        }
+        self
+    }
+
+    /// Set callbacks that will be triggered at various points in the runner's
+    /// lifecycle.
+    pub fn callbacks(&mut self, callbacks: impl Callbacks + Send + Sync + 'static) -> &mut Self {
+        self.callbacks = Arc::new(callbacks);
+        self
+    }
+
+    /// Add a package that should be available to the instance at runtime.
+    pub fn inject_package(&mut self, pkg: BinaryPackage) -> &mut Self {
+        self.wasi.injected_packages.push(pkg);
+        self
+    }
+
+    /// Add packages that should be available to the instance at runtime.
+    pub fn inject_packages(
+        &mut self,
+        packages: impl IntoIterator<Item = BinaryPackage>,
+    ) -> &mut Self {
+        self.wasi.injected_packages.extend(packages);
+        self
+    }
+
+    pub fn capabilities(&mut self) -> &mut Capabilities {
+        &mut self.wasi.capabilities
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_snapshot_trigger(&mut self, on: crate::journal::SnapshotTrigger) {
+        self.wasi.snapshot_on.push(on);
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_default_snapshot_triggers(&mut self) -> &mut Self {
+        for on in crate::journal::DEFAULT_SNAPSHOT_TRIGGERS {
+            if !self.has_snapshot_trigger(on) {
+                self.add_snapshot_trigger(on);
+            }
+        }
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn has_snapshot_trigger(&self, on: crate::journal::SnapshotTrigger) -> bool {
+        self.wasi.snapshot_on.iter().any(|t| *t == on)
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_snapshot_interval(&mut self, period: std::time::Duration) -> &mut Self {
+        if !self.has_snapshot_trigger(crate::journal::SnapshotTrigger::PeriodicInterval) {
+            self.add_snapshot_trigger(crate::journal::SnapshotTrigger::PeriodicInterval);
+        }
+        self.wasi.snapshot_interval.replace(period);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_journal(&mut self, journal: Arc<crate::journal::DynJournal>) -> &mut Self {
+        self.wasi.journals.push(journal);
+        self
+    }
+}
+
+impl Config {
+    pub fn new<C>(callbacks: C) -> Self
+    where
+        C: Callbacks,
+    {
+        Self {
+            addr: ([127, 0, 0, 1], 8000).into(),
+            wasi: CommonWasiOptions::default(),
+            callbacks: Arc::new(callbacks),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn send_and_sync() {
+        fn assert_send<T: Send>() {}
+        fn assert_sync<T: Sync>() {}
+
+        assert_send::<WcgiRunner>();
+        assert_sync::<WcgiRunner>();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/mod.rs
new file mode 100644
index 0000000..91d4e62
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/mod.rs
@@ -0,0 +1,566 @@
+pub mod module_cache;
+pub mod package_loader;
+pub mod resolver;
+pub mod task_manager;
+
+pub use self::task_manager::{SpawnMemoryType, VirtualTaskManager};
+use self::{
+    module_cache::{CacheError, ModuleHash},
+    task_manager::InlineWaker,
+};
+
+use std::{
+    fmt,
+    ops::Deref,
+    sync::{Arc, Mutex},
+};
+
+use derivative::Derivative;
+use futures::future::BoxFuture;
+use virtual_net::{DynVirtualNetworking, VirtualNetworking};
+use wasmer::{Module, RuntimeError};
+use wasmer_wasix_types::wasi::ExitCode;
+
+#[cfg(feature = "journal")]
+use crate::journal::DynJournal;
+use crate::{
+    http::{DynHttpClient, HttpClient},
+    os::TtyBridge,
+    runtime::{
+        module_cache::{ModuleCache, ThreadLocalCache},
+        package_loader::{PackageLoader, UnsupportedPackageLoader},
+        resolver::{MultiSource, Source, WapmSource},
+    },
+    WasiTtyState,
+};
+
+#[derive(Clone)]
+pub enum TaintReason {
+    UnknownWasiVersion,
+    NonZeroExitCode(ExitCode),
+    RuntimeError(RuntimeError),
+}
+
+/// Runtime components used when running WebAssembly programs.
+///
+/// Think of this as the "System" in "WebAssembly Systems Interface".
+#[allow(unused_variables)]
+pub trait Runtime
+where
+    Self: fmt::Debug,
+{
+    /// Provides access to all the networking related functions such as sockets.
+    fn networking(&self) -> &DynVirtualNetworking;
+
+    /// Retrieve the active [`VirtualTaskManager`].
+    fn task_manager(&self) -> &Arc<dyn VirtualTaskManager>;
+
+    /// A package loader.
+    fn package_loader(&self) -> Arc<dyn PackageLoader + Send + Sync> {
+        Arc::new(UnsupportedPackageLoader)
+    }
+
+    /// A cache for compiled modules.
+    fn module_cache(&self) -> Arc<dyn ModuleCache + Send + Sync> {
+        // Return a cache that uses a thread-local variable. This isn't ideal
+        // because it allows silently sharing state, possibly between runtimes.
+        //
+        // That said, it means people will still get *some* level of caching
+        // because each cache returned by this default implementation will go
+        // through the same thread-local variable.
+        Arc::new(ThreadLocalCache::default())
+    }
+
+    /// The package registry.
+    fn source(&self) -> Arc<dyn Source + Send + Sync>;
+
+    /// Get a [`wasmer::Engine`] for module compilation.
+    fn engine(&self) -> wasmer::Engine {
+        wasmer::Engine::default()
+    }
+
+    /// Create a new [`wasmer::Store`].
+    fn new_store(&self) -> wasmer::Store {
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "sys")] {
+                wasmer::Store::new(self.engine())
+            } else {
+                wasmer::Store::default()
+            }
+        }
+    }
+
+    /// Get a custom HTTP client
+    fn http_client(&self) -> Option<&DynHttpClient> {
+        None
+    }
+
+    /// Get access to the TTY used by the environment.
+    fn tty(&self) -> Option<&(dyn TtyBridge + Send + Sync)> {
+        None
+    }
+
+    /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
+    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, anyhow::Result<Module>> {
+        let engine = self.engine();
+        let module_cache = self.module_cache();
+
+        let task = async move { load_module(&engine, &module_cache, wasm).await };
+
+        Box::pin(task)
+    }
+
+    /// Load a a Webassembly module, trying to use a pre-compiled version if possible.
+    ///
+    /// Non-async version of [`Self::load_module`].
+    fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, anyhow::Error> {
+        InlineWaker::block_on(self.load_module(wasm))
+    }
+
+    /// Callback thats invokes whenever the instance is tainted, tainting can occur
+    /// for multiple reasons however the most common is a panic within the process
+    fn on_taint(&self, _reason: TaintReason) {}
+
+    /// The list of journals which will be used to restore the state of the
+    /// runtime at a particular point in time
+    #[cfg(feature = "journal")]
+    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
+        &EMPTY_JOURNAL_LIST
+    }
+
+    /// The snapshot capturer takes and restores snapshots of the WASM process at specific
+    /// points in time by reading and writing log entries
+    #[cfg(feature = "journal")]
+    fn active_journal(&self) -> Option<&'_ DynJournal> {
+        None
+    }
+}
+
+pub type DynRuntime = dyn Runtime + Send + Sync;
+
+#[cfg(feature = "journal")]
+static EMPTY_JOURNAL_LIST: Vec<Arc<DynJournal>> = Vec::new();
+
+/// Load a a Webassembly module, trying to use a pre-compiled version if possible.
+///
+// This function exists to provide a reusable baseline implementation for
+// implementing [`Runtime::load_module`], so custom logic can be added on top.
+#[tracing::instrument(level = "debug", skip_all)]
+pub async fn load_module(
+    engine: &wasmer::Engine,
+    module_cache: &(dyn ModuleCache + Send + Sync),
+    wasm: &[u8],
+) -> Result<Module, anyhow::Error> {
+    let hash = ModuleHash::hash(wasm);
+    let result = module_cache.load(hash, engine).await;
+
+    match result {
+        Ok(module) => return Ok(module),
+        Err(CacheError::NotFound) => {}
+        Err(other) => {
+            tracing::warn!(
+                %hash,
+                error=&other as &dyn std::error::Error,
+                "Unable to load the cached module",
+            );
+        }
+    }
+
+    let module = Module::new(&engine, wasm)?;
+
+    if let Err(e) = module_cache.save(hash, engine, &module).await {
+        tracing::warn!(
+            %hash,
+            error=&e as &dyn std::error::Error,
+            "Unable to cache the compiled module",
+        );
+    }
+
+    Ok(module)
+}
+
+#[derive(Debug, Default)]
+pub struct DefaultTty {
+    state: Mutex<WasiTtyState>,
+}
+
+impl TtyBridge for DefaultTty {
+    fn reset(&self) {
+        let mut state = self.state.lock().unwrap();
+        state.echo = false;
+        state.line_buffered = false;
+        state.line_feeds = false
+    }
+
+    fn tty_get(&self) -> WasiTtyState {
+        let state = self.state.lock().unwrap();
+        state.clone()
+    }
+
+    fn tty_set(&self, tty_state: WasiTtyState) {
+        let mut state = self.state.lock().unwrap();
+        *state = tty_state;
+    }
+}
+
+#[derive(Clone, Derivative)]
+#[derivative(Debug)]
+pub struct PluggableRuntime {
+    pub rt: Arc<dyn VirtualTaskManager>,
+    pub networking: DynVirtualNetworking,
+    pub http_client: Option<DynHttpClient>,
+    pub package_loader: Arc<dyn PackageLoader + Send + Sync>,
+    pub source: Arc<dyn Source + Send + Sync>,
+    pub engine: Option<wasmer::Engine>,
+    pub module_cache: Arc<dyn ModuleCache + Send + Sync>,
+    #[derivative(Debug = "ignore")]
+    pub tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
+    #[cfg(feature = "journal")]
+    #[derivative(Debug = "ignore")]
+    pub journals: Vec<Arc<DynJournal>>,
+}
+
+impl PluggableRuntime {
+    pub fn new(rt: Arc<dyn VirtualTaskManager>) -> Self {
+        // TODO: the cfg flags below should instead be handled by separate implementations.
+        cfg_if::cfg_if! {
+            if #[cfg(feature = "host-vnet")] {
+                let networking = Arc::new(virtual_net::host::LocalNetworking::default());
+            } else {
+                let networking = Arc::new(virtual_net::UnsupportedVirtualNetworking::default());
+            }
+        }
+        let http_client =
+            crate::http::default_http_client().map(|client| Arc::new(client) as DynHttpClient);
+
+        let loader = UnsupportedPackageLoader;
+
+        let mut source = MultiSource::new();
+        if let Some(client) = &http_client {
+            source.add_source(WapmSource::new(
+                WapmSource::WASMER_PROD_ENDPOINT.parse().unwrap(),
+                client.clone(),
+            ));
+        }
+
+        Self {
+            rt,
+            networking,
+            http_client,
+            engine: None,
+            tty: None,
+            source: Arc::new(source),
+            package_loader: Arc::new(loader),
+            module_cache: Arc::new(module_cache::in_memory()),
+            #[cfg(feature = "journal")]
+            journals: Vec::new(),
+        }
+    }
+
+    pub fn set_networking_implementation<I>(&mut self, net: I) -> &mut Self
+    where
+        I: VirtualNetworking + Sync,
+    {
+        self.networking = Arc::new(net);
+        self
+    }
+
+    pub fn set_engine(&mut self, engine: Option<wasmer::Engine>) -> &mut Self {
+        self.engine = engine;
+        self
+    }
+
+    pub fn set_tty(&mut self, tty: Arc<dyn TtyBridge + Send + Sync>) -> &mut Self {
+        self.tty = Some(tty);
+        self
+    }
+
+    pub fn set_module_cache(
+        &mut self,
+        module_cache: impl ModuleCache + Send + Sync + 'static,
+    ) -> &mut Self {
+        self.module_cache = Arc::new(module_cache);
+        self
+    }
+
+    pub fn set_source(&mut self, source: impl Source + Send + Sync + 'static) -> &mut Self {
+        self.source = Arc::new(source);
+        self
+    }
+
+    pub fn set_package_loader(
+        &mut self,
+        package_loader: impl PackageLoader + Send + Sync + 'static,
+    ) -> &mut Self {
+        self.package_loader = Arc::new(package_loader);
+        self
+    }
+
+    pub fn set_http_client(
+        &mut self,
+        client: impl HttpClient + Send + Sync + 'static,
+    ) -> &mut Self {
+        self.http_client = Some(Arc::new(client));
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self {
+        self.journals.push(journal);
+        self
+    }
+}
+
+impl Runtime for PluggableRuntime {
+    fn networking(&self) -> &DynVirtualNetworking {
+        &self.networking
+    }
+
+    fn http_client(&self) -> Option<&DynHttpClient> {
+        self.http_client.as_ref()
+    }
+
+    fn package_loader(&self) -> Arc<dyn PackageLoader + Send + Sync> {
+        Arc::clone(&self.package_loader)
+    }
+
+    fn source(&self) -> Arc<dyn Source + Send + Sync> {
+        Arc::clone(&self.source)
+    }
+
+    fn engine(&self) -> wasmer::Engine {
+        if let Some(engine) = self.engine.clone() {
+            engine
+        } else {
+            wasmer::Engine::default()
+        }
+    }
+
+    fn new_store(&self) -> wasmer::Store {
+        self.engine
+            .clone()
+            .map(wasmer::Store::new)
+            .unwrap_or_default()
+    }
+
+    fn task_manager(&self) -> &Arc<dyn VirtualTaskManager> {
+        &self.rt
+    }
+
+    fn tty(&self) -> Option<&(dyn TtyBridge + Send + Sync)> {
+        self.tty.as_deref()
+    }
+
+    fn module_cache(&self) -> Arc<dyn ModuleCache + Send + Sync> {
+        self.module_cache.clone()
+    }
+
+    #[cfg(feature = "journal")]
+    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
+        &self.journals
+    }
+
+    #[cfg(feature = "journal")]
+    fn active_journal(&self) -> Option<&DynJournal> {
+        self.journals.iter().last().map(|a| a.as_ref())
+    }
+}
+
+/// Runtime that allows for certain things to be overridden
+/// such as the active journals
+#[derive(Clone, Derivative)]
+#[derivative(Debug)]
+pub struct OverriddenRuntime {
+    inner: Arc<DynRuntime>,
+    task_manager: Option<Arc<dyn VirtualTaskManager>>,
+    networking: Option<DynVirtualNetworking>,
+    http_client: Option<DynHttpClient>,
+    package_loader: Option<Arc<dyn PackageLoader + Send + Sync>>,
+    source: Option<Arc<dyn Source + Send + Sync>>,
+    engine: Option<wasmer::Engine>,
+    module_cache: Option<Arc<dyn ModuleCache + Send + Sync>>,
+    #[derivative(Debug = "ignore")]
+    tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
+    #[cfg(feature = "journal")]
+    #[derivative(Debug = "ignore")]
+    journals: Option<Vec<Arc<DynJournal>>>,
+}
+
+impl OverriddenRuntime {
+    pub fn new(inner: Arc<DynRuntime>) -> Self {
+        Self {
+            inner,
+            task_manager: None,
+            networking: None,
+            http_client: None,
+            package_loader: None,
+            source: None,
+            engine: None,
+            module_cache: None,
+            tty: None,
+            #[cfg(feature = "journal")]
+            journals: None,
+        }
+    }
+
+    pub fn with_task_manager(mut self, task_manager: Arc<dyn VirtualTaskManager>) -> Self {
+        self.task_manager.replace(task_manager);
+        self
+    }
+
+    pub fn with_networking(mut self, networking: DynVirtualNetworking) -> Self {
+        self.networking.replace(networking);
+        self
+    }
+
+    pub fn with_http_client(mut self, http_client: DynHttpClient) -> Self {
+        self.http_client.replace(http_client);
+        self
+    }
+
+    pub fn with_package_loader(
+        mut self,
+        package_loader: Arc<dyn PackageLoader + Send + Sync>,
+    ) -> Self {
+        self.package_loader.replace(package_loader);
+        self
+    }
+
+    pub fn with_source(mut self, source: Arc<dyn Source + Send + Sync>) -> Self {
+        self.source.replace(source);
+        self
+    }
+
+    pub fn with_engine(mut self, engine: wasmer::Engine) -> Self {
+        self.engine.replace(engine);
+        self
+    }
+
+    pub fn with_module_cache(mut self, module_cache: Arc<dyn ModuleCache + Send + Sync>) -> Self {
+        self.module_cache.replace(module_cache);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_tty(mut self, tty: Arc<dyn TtyBridge + Send + Sync>) -> Self {
+        self.tty.replace(tty);
+        self
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_journals(mut self, journals: Vec<Arc<DynJournal>>) -> Self {
+        self.journals.replace(journals);
+        self
+    }
+}
+
+impl Runtime for OverriddenRuntime {
+    fn networking(&self) -> &DynVirtualNetworking {
+        if let Some(net) = self.networking.as_ref() {
+            net
+        } else {
+            self.inner.networking()
+        }
+    }
+
+    fn task_manager(&self) -> &Arc<dyn VirtualTaskManager> {
+        if let Some(rt) = self.task_manager.as_ref() {
+            rt
+        } else {
+            self.inner.task_manager()
+        }
+    }
+
+    fn source(&self) -> Arc<dyn Source + Send + Sync> {
+        if let Some(source) = self.source.clone() {
+            source
+        } else {
+            self.inner.source()
+        }
+    }
+
+    fn package_loader(&self) -> Arc<dyn PackageLoader + Send + Sync> {
+        if let Some(loader) = self.package_loader.clone() {
+            loader
+        } else {
+            self.inner.package_loader()
+        }
+    }
+
+    fn module_cache(&self) -> Arc<dyn ModuleCache + Send + Sync> {
+        if let Some(cache) = self.module_cache.clone() {
+            cache
+        } else {
+            self.inner.module_cache()
+        }
+    }
+
+    fn engine(&self) -> wasmer::Engine {
+        if let Some(engine) = self.engine.clone() {
+            engine
+        } else {
+            self.inner.engine()
+        }
+    }
+
+    fn new_store(&self) -> wasmer::Store {
+        if let Some(engine) = self.engine.clone() {
+            wasmer::Store::new(engine)
+        } else {
+            self.inner.new_store()
+        }
+    }
+
+    fn http_client(&self) -> Option<&DynHttpClient> {
+        if let Some(client) = self.http_client.as_ref() {
+            Some(client)
+        } else {
+            self.inner.http_client()
+        }
+    }
+
+    fn tty(&self) -> Option<&(dyn TtyBridge + Send + Sync)> {
+        if let Some(tty) = self.tty.as_ref() {
+            Some(tty.deref())
+        } else {
+            self.inner.tty()
+        }
+    }
+
+    #[cfg(feature = "journal")]
+    fn journals(&self) -> &'_ Vec<Arc<DynJournal>> {
+        if let Some(journals) = self.journals.as_ref() {
+            journals
+        } else {
+            self.inner.journals()
+        }
+    }
+
+    #[cfg(feature = "journal")]
+    fn active_journal(&self) -> Option<&'_ DynJournal> {
+        if let Some(journals) = self.journals.as_ref() {
+            journals.iter().last().map(|a| a.as_ref())
+        } else {
+            self.inner.active_journal()
+        }
+    }
+
+    fn load_module<'a>(&'a self, wasm: &'a [u8]) -> BoxFuture<'a, anyhow::Result<Module>> {
+        if self.engine.is_some() || self.module_cache.is_some() {
+            let engine = self.engine();
+            let module_cache = self.module_cache();
+            let task = async move { load_module(&engine, &module_cache, wasm).await };
+            Box::pin(task)
+        } else {
+            self.inner.load_module(wasm)
+        }
+    }
+
+    fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, anyhow::Error> {
+        if self.engine.is_some() || self.module_cache.is_some() {
+            InlineWaker::block_on(self.load_module(wasm))
+        } else {
+            self.inner.load_module_sync(wasm)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/fallback.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/fallback.rs
new file mode 100644
index 0000000..e302627
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/fallback.rs
@@ -0,0 +1,243 @@
+use wasmer::{Engine, Module};
+
+use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
+
+/// [`FallbackCache`] is a combinator for the [`ModuleCache`] trait that enables
+/// the chaining of two caching strategies together, typically via
+/// [`ModuleCache::with_fallback()`].
+///
+/// All operations are attempted using primary cache first, and if that fails,
+/// falls back to using the fallback cache. By chaining different caches
+/// together with [`FallbackCache`], you can create a caching hierarchy tailored
+/// to your application's specific needs, balancing performance, resource usage,
+/// and persistence.
+///
+/// A key assumption of [`FallbackCache`] is that **all operations on the
+/// fallback implementation will be significantly slower than the primary one**.
+///
+/// ## Cache Promotion
+///
+/// Whenever there is a cache miss on the primary cache and the fallback is
+/// able to load a module, that module is automatically added to the primary
+/// cache to improve the speed of future lookups.
+///
+/// This "cache promotion" strategy helps keep frequently accessed modules in
+/// the faster primary cache.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FallbackCache<Primary, Fallback> {
+    primary: Primary,
+    fallback: Fallback,
+}
+
+impl<Primary, Fallback> FallbackCache<Primary, Fallback> {
+    pub(crate) fn new(primary: Primary, fallback: Fallback) -> Self {
+        FallbackCache { primary, fallback }
+    }
+
+    pub fn primary(&self) -> &Primary {
+        &self.primary
+    }
+
+    pub fn primary_mut(&mut self) -> &mut Primary {
+        &mut self.primary
+    }
+
+    pub fn fallback(&self) -> &Fallback {
+        &self.fallback
+    }
+
+    pub fn fallback_mut(&mut self) -> &mut Fallback {
+        &mut self.fallback
+    }
+
+    pub fn into_inner(self) -> (Primary, Fallback) {
+        let FallbackCache { primary, fallback } = self;
+        (primary, fallback)
+    }
+}
+
+#[async_trait::async_trait]
+impl<Primary, Fallback> ModuleCache for FallbackCache<Primary, Fallback>
+where
+    Primary: ModuleCache + Send + Sync,
+    Fallback: ModuleCache + Send + Sync,
+{
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+        let primary_error = match self.primary.load(key, engine).await {
+            Ok(m) => return Ok(m),
+            Err(e) => e,
+        };
+
+        if let Ok(m) = self.fallback.load(key, engine).await {
+            // Now we've got a module, let's make sure it is promoted to the
+            // primary cache.
+            if let Err(e) = self.primary.save(key, engine, &m).await {
+                tracing::warn!(
+                    %key,
+                    error = &e as &dyn std::error::Error,
+                    "Unable to promote a module to the primary cache",
+                );
+            }
+
+            return Ok(m);
+        }
+
+        Err(primary_error)
+    }
+
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError> {
+        futures::try_join!(
+            self.primary.save(key, engine, module),
+            self.fallback.save(key, engine, module)
+        )?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    use super::*;
+    use crate::runtime::module_cache::SharedCache;
+
+    const ADD_WAT: &[u8] = br#"(
+        module
+            (func
+                (export "add")
+                (param $x i64)
+                (param $y i64)
+                (result i64)
+                (i64.add (local.get $x) (local.get $y)))
+        )"#;
+
+    #[derive(Debug)]
+    struct Spy<I> {
+        inner: I,
+        success: AtomicUsize,
+        failures: AtomicUsize,
+    }
+
+    impl<I> Spy<I> {
+        fn new(inner: I) -> Self {
+            Spy {
+                inner,
+                success: AtomicUsize::new(0),
+                failures: AtomicUsize::new(0),
+            }
+        }
+
+        fn success(&self) -> usize {
+            self.success.load(Ordering::SeqCst)
+        }
+
+        fn failures(&self) -> usize {
+            self.failures.load(Ordering::SeqCst)
+        }
+    }
+
+    #[async_trait::async_trait]
+    impl<I: ModuleCache + Send + Sync> ModuleCache for Spy<I> {
+        async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+            match self.inner.load(key, engine).await {
+                Ok(m) => {
+                    self.success.fetch_add(1, Ordering::SeqCst);
+                    Ok(m)
+                }
+                Err(e) => {
+                    self.failures.fetch_add(1, Ordering::SeqCst);
+                    Err(e)
+                }
+            }
+        }
+
+        async fn save(
+            &self,
+            key: ModuleHash,
+            engine: &Engine,
+            module: &Module,
+        ) -> Result<(), CacheError> {
+            match self.inner.save(key, engine, module).await {
+                Ok(_) => {
+                    self.success.fetch_add(1, Ordering::SeqCst);
+                    Ok(())
+                }
+                Err(e) => {
+                    self.failures.fetch_add(1, Ordering::SeqCst);
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn load_from_primary() {
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let primary = SharedCache::default();
+        let fallback = SharedCache::default();
+        primary.save(key, &engine, &module).await.unwrap();
+        let primary = Spy::new(primary);
+        let fallback = Spy::new(fallback);
+        let cache = FallbackCache::new(&primary, &fallback);
+
+        let got = cache.load(key, &engine).await.unwrap();
+
+        // We should have received the same module
+        assert_eq!(module, got);
+        assert_eq!(primary.success(), 1);
+        assert_eq!(primary.failures(), 0);
+        // but the fallback wasn't touched at all
+        assert_eq!(fallback.success(), 0);
+        assert_eq!(fallback.failures(), 0);
+        // And the fallback still doesn't have our module
+        assert!(fallback.load(key, &engine).await.is_err());
+    }
+
+    #[tokio::test]
+    async fn loading_from_fallback_also_populates_primary() {
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let primary = SharedCache::default();
+        let fallback = SharedCache::default();
+        fallback.save(key, &engine, &module).await.unwrap();
+        let primary = Spy::new(primary);
+        let fallback = Spy::new(fallback);
+        let cache = FallbackCache::new(&primary, &fallback);
+
+        let got = cache.load(key, &engine).await.unwrap();
+
+        // We should have received the same module
+        assert_eq!(module, got);
+        // We got a hit on the fallback
+        assert_eq!(fallback.success(), 1);
+        assert_eq!(fallback.failures(), 0);
+        // the load() on our primary failed
+        assert_eq!(primary.failures(), 1);
+        // but afterwards, we updated the primary cache with our module
+        assert_eq!(primary.success(), 1);
+        assert_eq!(primary.load(key, &engine).await.unwrap(), module);
+    }
+
+    #[tokio::test]
+    async fn saving_will_update_both() {
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let primary = SharedCache::default();
+        let fallback = SharedCache::default();
+        let cache = FallbackCache::new(&primary, &fallback);
+
+        cache.save(key, &engine, &module).await.unwrap();
+
+        assert_eq!(primary.load(key, &engine).await.unwrap(), module);
+        assert_eq!(fallback.load(key, &engine).await.unwrap(), module);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/filesystem.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/filesystem.rs
new file mode 100644
index 0000000..30db6f7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/filesystem.rs
@@ -0,0 +1,302 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use tempfile::NamedTempFile;
+use tokio::io::AsyncWriteExt;
+use wasmer::{Engine, Module};
+
+use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
+use crate::runtime::task_manager::tokio::TokioTaskManager;
+use crate::runtime::task_manager::VirtualTaskManagerExt;
+
+/// A cache that saves modules to a folder on the host filesystem using
+/// [`Module::serialize()`].
+#[derive(Debug, Clone)]
+pub struct FileSystemCache {
+    cache_dir: PathBuf,
+    task_manager: Arc<TokioTaskManager>,
+}
+
+impl FileSystemCache {
+    pub fn new(cache_dir: impl Into<PathBuf>, task_manager: Arc<TokioTaskManager>) -> Self {
+        FileSystemCache {
+            cache_dir: cache_dir.into(),
+            task_manager,
+        }
+    }
+
+    pub fn cache_dir(&self) -> &Path {
+        &self.cache_dir
+    }
+
+    fn path(&self, key: ModuleHash, deterministic_id: &str) -> PathBuf {
+        let artifact_version = wasmer_types::MetadataHeader::CURRENT_VERSION;
+        self.cache_dir
+            .join(format!("{deterministic_id}-v{artifact_version}"))
+            .join(key.to_string())
+            .with_extension("bin")
+    }
+}
+
+#[async_trait::async_trait]
+impl ModuleCache for FileSystemCache {
+    #[tracing::instrument(level = "debug", skip_all, fields(% key))]
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+        let path = self.path(key, engine.deterministic_id());
+
+        self.task_manager
+            .runtime_handle()
+            .spawn({
+                let task_manager = self.task_manager.clone();
+                let engine = engine.clone();
+
+                async move {
+                    let bytes = read_file(&path).await?;
+
+                    task_manager
+                    .spawn_await({
+
+                        move || match deserialize(&bytes, &engine) {
+                            Ok(m) => {
+                                tracing::debug!("Cache hit!");
+                                Ok(m)
+                            }
+                            Err(e) => {
+                                tracing::debug!(
+                                    %key,
+                                    path=%path.display(),
+                                    error=&e as &dyn std::error::Error,
+                                    "Deleting the cache file because the artifact couldn't be deserialized",
+                                );
+
+                                if let Err(e) = std::fs::remove_file(&path) {
+                                    tracing::warn!(
+                                        %key,
+                                        path=%path.display(),
+                                        error=&e as &dyn std::error::Error,
+                                        "Unable to remove the corrupted cache file",
+                                    );
+                                }
+
+                                Err(e)
+                            }
+                        }
+                    })
+                    .await
+                    .unwrap()
+                }
+            })
+            .await
+            .unwrap()
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, fields(% key))]
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError> {
+        let path = self.path(key, engine.deterministic_id());
+
+        self.task_manager
+            .runtime_handle()
+            .spawn({
+                let task_manager = self.task_manager.clone();
+                let module = module.clone();
+
+                async move {
+                    let parent = path
+                        .parent()
+                        .expect("Unreachable - always created by joining onto cache_dir");
+
+                    if let Err(e) = tokio::fs::create_dir_all(parent).await {
+                        tracing::warn!(
+                            dir=%parent.display(),
+                            error=&e as &dyn std::error::Error,
+                            "Unable to create the cache directory",
+                        );
+                    }
+
+                    // Note: We save to a temporary file and persist() it at the end so
+                    // concurrent readers won't see a partially written module.
+                    let (file, temp) = NamedTempFile::new_in(parent)
+                        .map_err(CacheError::other)?
+                        .into_parts();
+
+                    let mut file = tokio::fs::File::from_std(file);
+
+                    let serialized = task_manager
+                        .spawn_await(move || module.serialize())
+                        .await
+                        .unwrap()?;
+
+                    let mut writer = tokio::io::BufWriter::new(&mut file);
+                    if let Err(error) = writer.write_all(&serialized).await {
+                        return Err(CacheError::FileWrite { path, error });
+                    }
+                    if let Err(error) = writer.flush().await {
+                        return Err(CacheError::FileWrite { path, error });
+                    }
+
+                    temp.persist(&path).map_err(CacheError::other)?;
+                    tracing::debug!(path=%path.display(), "Saved to disk");
+
+                    Ok(())
+                }
+            })
+            .await
+            .unwrap()
+    }
+}
+
+async fn read_file(path: &Path) -> Result<Vec<u8>, CacheError> {
+    match tokio::fs::read(path).await {
+        Ok(bytes) => Ok(bytes),
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Err(CacheError::NotFound),
+        Err(error) => Err(CacheError::FileRead {
+            path: path.to_path_buf(),
+            error,
+        }),
+    }
+}
+
+fn deserialize(bytes: &[u8], engine: &Engine) -> Result<Module, CacheError> {
+    // We used to compress our compiled modules using LZW encoding in the past.
+    // This was removed because it has a negative impact on startup times for
+    // "wasmer run", so all new compiled modules should be saved directly to
+    // disk.
+    //
+    // For perspective, compiling php.wasm with cranelift took about 4.75
+    // seconds on a M1 Mac.
+    //
+    // Without LZW compression:
+    // - ModuleCache::save(): 408ms, 142MB binary
+    // - ModuleCache::load(): 155ms
+    // With LZW compression:
+    // - ModuleCache::save(): 2.4s, 72MB binary
+    // - ModuleCache::load(): 822ms
+
+    match unsafe { Module::deserialize(engine, bytes) } {
+        // The happy case
+        Ok(m) => Ok(m),
+        Err(wasmer::DeserializeError::Incompatible(_)) => {
+            let bytes = weezl::decode::Decoder::new(weezl::BitOrder::Msb, 8)
+                .decode(bytes)
+                .map_err(CacheError::other)?;
+
+            let m = unsafe { Module::deserialize(engine, bytes)? };
+
+            Ok(m)
+        }
+        Err(e) => Err(CacheError::Deserialize(e)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::runtime::task_manager::tokio::TokioTaskManager;
+    use tempfile::TempDir;
+
+    use super::*;
+
+    const ADD_WAT: &[u8] = br#"(
+        module
+            (func
+                (export "add")
+                (param $x i64)
+                (param $y i64)
+                (result i64)
+                (i64.add (local.get $x) (local.get $y)))
+        )"#;
+
+    fn create_tokio_task_manager() -> Arc<TokioTaskManager> {
+        Arc::new(TokioTaskManager::new(tokio::runtime::Handle::current()))
+    }
+
+    #[tokio::test]
+    async fn save_to_disk() {
+        let temp = TempDir::new().unwrap();
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
+        let key = ModuleHash::from_bytes([0; 8]);
+        let expected_path = cache.path(key, engine.deterministic_id());
+
+        cache.save(key, &engine, &module).await.unwrap();
+
+        assert!(expected_path.exists());
+    }
+
+    #[tokio::test]
+    async fn create_cache_dir_automatically() {
+        let temp = TempDir::new().unwrap();
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let cache_dir = temp.path().join("this").join("doesn't").join("exist");
+        assert!(!cache_dir.exists());
+        let cache = FileSystemCache::new(&cache_dir, create_tokio_task_manager());
+        let key = ModuleHash::from_bytes([0; 8]);
+
+        cache.save(key, &engine, &module).await.unwrap();
+
+        assert!(cache_dir.is_dir());
+    }
+
+    #[tokio::test]
+    async fn missing_file() {
+        let temp = TempDir::new().unwrap();
+        let engine = Engine::default();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
+
+        let err = cache.load(key, &engine).await.unwrap_err();
+
+        assert!(matches!(err, CacheError::NotFound));
+    }
+
+    #[tokio::test]
+    async fn load_from_disk() {
+        let temp = TempDir::new().unwrap();
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
+        let expected_path = cache.path(key, engine.deterministic_id());
+        std::fs::create_dir_all(expected_path.parent().unwrap()).unwrap();
+        let serialized = module.serialize().unwrap();
+        std::fs::write(&expected_path, &serialized).unwrap();
+
+        let module = cache.load(key, &engine).await.unwrap();
+
+        let exports: Vec<_> = module
+            .exports()
+            .map(|export| export.name().to_string())
+            .collect();
+        assert_eq!(exports, ["add"]);
+    }
+
+    /// For backwards compatibility, make sure we can still work with LZW
+    /// compressed modules.
+    #[tokio::test]
+    async fn can_still_load_lzw_compressed_binaries() {
+        let temp = TempDir::new().unwrap();
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let key = ModuleHash::from_bytes([0; 8]);
+        let cache = FileSystemCache::new(temp.path(), create_tokio_task_manager());
+        let expected_path = cache.path(key, engine.deterministic_id());
+        std::fs::create_dir_all(expected_path.parent().unwrap()).unwrap();
+        let serialized = module.serialize().unwrap();
+        let mut encoder = weezl::encode::Encoder::new(weezl::BitOrder::Msb, 8);
+        std::fs::write(&expected_path, encoder.encode(&serialized).unwrap()).unwrap();
+
+        let module = cache.load(key, &engine).await.unwrap();
+
+        let exports: Vec<_> = module
+            .exports()
+            .map(|export| export.name().to_string())
+            .collect();
+        assert_eq!(exports, ["add"]);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/mod.rs
new file mode 100644
index 0000000..88baf42
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/mod.rs
@@ -0,0 +1,71 @@
+//! Cache pre-compiled [`wasmer::Module`]s.
+//!
+//! The core of this module is the [`ModuleCache`] trait, which is designed to
+//! be implemented by different cache storage strategies, such as in-memory
+//! caches ([`SharedCache`] and [`ThreadLocalCache`]), file-based caches
+//! ([`FileSystemCache`]), or distributed caches. Implementing custom caching
+//! strategies allows you to optimize for your specific use case.
+//!
+//! ## Assumptions and Requirements
+//!
+//! The `module_cache` module makes several assumptions:
+//!
+//! - Cache keys are unique, typically derived from the original `*.wasm` or
+//!   `*.wat` file, and using the same key to load or save will always result in
+//!   the "same" module.
+//! - The [`ModuleCache::load()`] method will be called more often than the
+//!   [`ModuleCache::save()`] method, allowing for cache implementations to
+//!   optimize their strategy accordingly.
+//!
+//! Cache implementations are encouraged to take
+//! [`wasmer::Engine::deterministic_id()`] into account when saving and loading
+//! cached modules to ensure correct module retrieval.
+//!
+//! Cache implementations should choose a suitable eviction policy and implement
+//! invalidation transparently as part of [`ModuleCache::load()`] or
+//! [`ModuleCache::save()`].
+//!
+//! ## Combinators
+//!
+//! The `module_cache` module provides combinators for extending and combining
+//! caching strategies. For example, you could use the [`FallbackCache`] to
+//! chain a fast in-memory cache with a slower file-based cache as a fallback.
+
+mod fallback;
+#[cfg(feature = "sys-thread")]
+mod filesystem;
+mod shared;
+mod thread_local;
+mod types;
+
+pub use self::{
+    fallback::FallbackCache,
+    shared::SharedCache,
+    thread_local::ThreadLocalCache,
+    types::{CacheError, ModuleCache, ModuleHash},
+};
+
+#[cfg(feature = "sys-thread")]
+pub use self::filesystem::FileSystemCache;
+
+/// Get a [`ModuleCache`] which should be good enough for most in-memory use
+/// cases.
+///
+/// # Platform-specific Notes
+///
+/// This will use the [`ThreadLocalCache`] when running in the browser.  Each
+/// thread lives in a separate worker, so sharing compiled modules in the
+/// browser requires using a custom [`ModuleCache`] built on top of
+/// [`postMessage()`][pm] and [`SharedArrayBuffer`][sab].
+///
+/// [pm]: https://developer.mozilla.org/en-US/docs/Web/API/Worker/postMessage
+/// [sab]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SharedArrayBuffer
+pub fn in_memory() -> impl ModuleCache + Send + Sync {
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "js")] {
+            ThreadLocalCache::default()
+        } else {
+            SharedCache::default()
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/shared.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/shared.rs
new file mode 100644
index 0000000..fa3f138
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/shared.rs
@@ -0,0 +1,78 @@
+use dashmap::DashMap;
+use wasmer::{Engine, Module};
+
+use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
+
+/// A [`ModuleCache`] based on a <code>[DashMap]<[ModuleHash], [Module]></code>.
+#[derive(Debug, Default, Clone)]
+pub struct SharedCache {
+    modules: DashMap<(ModuleHash, String), Module>,
+}
+
+impl SharedCache {
+    pub fn new() -> SharedCache {
+        SharedCache::default()
+    }
+}
+
+#[async_trait::async_trait]
+impl ModuleCache for SharedCache {
+    #[tracing::instrument(level = "debug", skip_all, fields(%key))]
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+        let key = (key, engine.deterministic_id().to_string());
+
+        match self.modules.get(&key) {
+            Some(m) => {
+                tracing::debug!("Cache hit!");
+                Ok(m.value().clone())
+            }
+
+            None => Err(CacheError::NotFound),
+        }
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, fields(%key))]
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError> {
+        let key = (key, engine.deterministic_id().to_string());
+        self.modules.insert(key, module.clone());
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ADD_WAT: &[u8] = br#"(
+        module
+            (func
+                (export "add")
+                (param $x i64)
+                (param $y i64)
+                (result i64)
+                (i64.add (local.get $x) (local.get $y)))
+        )"#;
+
+    #[tokio::test]
+    async fn round_trip_via_cache() {
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let cache = SharedCache::default();
+        let key = ModuleHash::from_bytes([0; 8]);
+
+        cache.save(key, &engine, &module).await.unwrap();
+        let round_tripped = cache.load(key, &engine).await.unwrap();
+
+        let exports: Vec<_> = round_tripped
+            .exports()
+            .map(|export| export.name().to_string())
+            .collect();
+        assert_eq!(exports, ["add"]);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/thread_local.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/thread_local.rs
new file mode 100644
index 0000000..ef1ad92
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/thread_local.rs
@@ -0,0 +1,84 @@
+use std::{cell::RefCell, collections::HashMap};
+
+use wasmer::{Engine, Module};
+
+use crate::runtime::module_cache::{CacheError, ModuleCache, ModuleHash};
+
+std::thread_local! {
+    static CACHED_MODULES: RefCell<HashMap<(ModuleHash, String), Module>>
+        = RefCell::new(HashMap::new());
+}
+
+/// A cache that will cache modules in a thread-local variable.
+#[derive(Debug, Clone, Default)]
+#[non_exhaustive]
+pub struct ThreadLocalCache {}
+
+impl ThreadLocalCache {
+    fn lookup(&self, key: ModuleHash, deterministic_id: &str) -> Option<Module> {
+        let key = (key, deterministic_id.to_string());
+        CACHED_MODULES.with(|m| m.borrow().get(&key).cloned())
+    }
+
+    fn insert(&self, key: ModuleHash, module: &Module, deterministic_id: &str) {
+        let key = (key, deterministic_id.to_string());
+        CACHED_MODULES.with(|m| m.borrow_mut().insert(key, module.clone()));
+    }
+}
+
+#[async_trait::async_trait]
+impl ModuleCache for ThreadLocalCache {
+    #[tracing::instrument(level = "debug", skip_all, fields(%key))]
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+        match self.lookup(key, engine.deterministic_id()) {
+            Some(m) => {
+                tracing::debug!("Cache hit!");
+                Ok(m)
+            }
+            None => Err(CacheError::NotFound),
+        }
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, fields(%key))]
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError> {
+        self.insert(key, module, engine.deterministic_id());
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const ADD_WAT: &[u8] = br#"(
+        module
+            (func
+                (export "add")
+                (param $x i64)
+                (param $y i64)
+                (result i64)
+                (i64.add (local.get $x) (local.get $y)))
+        )"#;
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn round_trip_via_cache() {
+        let engine = Engine::default();
+        let module = Module::new(&engine, ADD_WAT).unwrap();
+        let cache = ThreadLocalCache::default();
+        let key = ModuleHash::from_bytes([0; 8]);
+
+        cache.save(key, &engine, &module).await.unwrap();
+        let round_tripped = cache.load(key, &engine).await.unwrap();
+
+        let exports: Vec<_> = round_tripped
+            .exports()
+            .map(|export| export.name().to_string())
+            .collect();
+        assert_eq!(exports, ["add"]);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/types.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/types.rs
new file mode 100644
index 0000000..57324cb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/module_cache/types.rs
@@ -0,0 +1,207 @@
+use std::hash::Hash;
+use std::{
+    fmt::{self, Debug, Display, Formatter},
+    ops::Deref,
+    path::PathBuf,
+};
+
+use rand::RngCore;
+use wasmer::{Engine, Module};
+
+use crate::runtime::module_cache::FallbackCache;
+
+/// A cache for compiled WebAssembly modules.
+///
+/// ## Deterministic ID
+///
+/// Implementations are encouraged to take the [`Engine::deterministic_id()`]
+/// into account when saving and loading cached a [`Module`].
+///
+/// ## Assumptions
+///
+/// Implementations can assume that cache keys are unique and that using the
+/// same key to load or save will always result in the "same" module.
+///
+/// Implementations can also assume that [`ModuleCache::load()`] will
+/// be called more often than [`ModuleCache::save()`] and optimise
+/// their caching strategy accordingly.
+///
+#[async_trait::async_trait]
+pub trait ModuleCache: Debug {
+    /// Load a module based on its hash.
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError>;
+
+    /// Save a module so it can be retrieved with [`ModuleCache::load()`] at a
+    /// later time.
+    ///
+    /// # Panics
+    ///
+    /// Implementations are free to assume the [`Module`] being passed in was
+    /// compiled using the provided [`Engine`], and may panic if this isn't the
+    /// case.
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError>;
+
+    /// Chain a second [`ModuleCache`] that will be used as a fallback if
+    /// lookups on the primary cache fail.
+    ///
+    /// The general assumption is that each subsequent cache in the chain will
+    /// be significantly slower than the previous one.
+    ///
+    /// ```rust
+    /// use wasmer_wasix::runtime::module_cache::{
+    ///     ModuleCache, ThreadLocalCache, FileSystemCache, SharedCache,
+    /// };
+    /// use wasmer_wasix::runtime::task_manager::tokio::{RuntimeOrHandle, TokioTaskManager};
+    ///
+    /// let runtime = tokio::runtime::Runtime::new().unwrap();
+    /// let rt_handle = RuntimeOrHandle::from(runtime);
+    /// let task_manager = std::sync::Arc::new(TokioTaskManager::new(rt_handle));
+    ///
+    /// let cache = SharedCache::default()
+    ///     .with_fallback(FileSystemCache::new("~/.local/cache", task_manager));
+    /// ```
+    fn with_fallback<C>(self, other: C) -> FallbackCache<Self, C>
+    where
+        Self: Sized,
+        C: ModuleCache,
+    {
+        FallbackCache::new(self, other)
+    }
+}
+
+#[async_trait::async_trait]
+impl<D, C> ModuleCache for D
+where
+    D: Deref<Target = C> + Debug + Send + Sync,
+    C: ModuleCache + Send + Sync + ?Sized,
+{
+    async fn load(&self, key: ModuleHash, engine: &Engine) -> Result<Module, CacheError> {
+        (**self).load(key, engine).await
+    }
+
+    async fn save(
+        &self,
+        key: ModuleHash,
+        engine: &Engine,
+        module: &Module,
+    ) -> Result<(), CacheError> {
+        (**self).save(key, engine, module).await
+    }
+}
+
+/// Possible errors that may occur during [`ModuleCache`] operations.
+#[derive(Debug, thiserror::Error)]
+pub enum CacheError {
+    #[error("Unable to serialize the module")]
+    Serialize(#[from] wasmer::SerializeError),
+    #[error("Unable to deserialize the module")]
+    Deserialize(#[from] wasmer::DeserializeError),
+    #[error("Unable to read from \"{}\"", path.display())]
+    FileRead {
+        path: PathBuf,
+        #[source]
+        error: std::io::Error,
+    },
+    #[error("Unable to write to \"{}\"", path.display())]
+    FileWrite {
+        path: PathBuf,
+        #[source]
+        error: std::io::Error,
+    },
+    /// The item was not found.
+    #[error("Not found")]
+    NotFound,
+    /// A catch-all variant for any other errors that may occur.
+    #[error(transparent)]
+    Other(Box<dyn std::error::Error + Send + Sync>),
+}
+
+impl CacheError {
+    pub fn other(error: impl std::error::Error + Send + Sync + 'static) -> Self {
+        CacheError::Other(Box::new(error))
+    }
+}
+
+/// The XXHash hash of a WebAssembly module.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct ModuleHash([u8; 8]);
+
+impl ModuleHash {
+    /// Create a new [`ModuleHash`] from the raw XXHash hash.
+    pub fn from_bytes(key: [u8; 8]) -> Self {
+        ModuleHash(key)
+    }
+
+    // Creates a random hash for the module
+    pub fn random() -> Self {
+        let mut rand = rand::thread_rng();
+        let mut key = [0u8; 8];
+        rand.fill_bytes(&mut key);
+        Self(key)
+    }
+
+    /// Parse a XXHash hash from a hex-encoded string.
+    pub fn parse_hex(hex_str: &str) -> Result<Self, hex::FromHexError> {
+        let mut hash = [0_u8; 8];
+        hex::decode_to_slice(hex_str, &mut hash)?;
+        Ok(Self(hash))
+    }
+
+    /// Generate a new [`ModuleCache`] based on the XXHash hash of some bytes.
+    pub fn hash(wasm: impl AsRef<[u8]>) -> Self {
+        let wasm = wasm.as_ref();
+
+        let hash = xxhash_rust::xxh64::xxh64(wasm, 0);
+
+        Self(hash.to_ne_bytes())
+    }
+
+    /// Get the raw XXHash hash.
+    pub fn as_bytes(self) -> [u8; 8] {
+        self.0
+    }
+}
+
+impl Display for ModuleHash {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        for byte in self.0 {
+            write!(f, "{byte:02X}")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn is_object_safe() {
+        let _: Option<Box<dyn ModuleCache>> = None;
+    }
+
+    #[test]
+    fn key_is_displayed_as_hex() {
+        let key = ModuleHash::from_bytes([0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]);
+
+        let repr = key.to_string();
+
+        assert_eq!(repr, "0001020304050607");
+    }
+
+    #[test]
+    fn module_hash_is_just_sha_256() {
+        let wasm = b"\0asm...";
+        let raw = [0x0c, 0xc7, 0x88, 0x60, 0xd4, 0x14, 0x71, 0x4c];
+
+        let hash = ModuleHash::hash(wasm);
+
+        assert_eq!(hash.as_bytes(), raw);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/builtin_loader.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/builtin_loader.rs
new file mode 100644
index 0000000..9fa9096
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/builtin_loader.rs
@@ -0,0 +1,485 @@
+use std::{
+    collections::HashMap,
+    fmt::Write as _,
+    io::{ErrorKind, Write as _},
+    path::PathBuf,
+    sync::{Arc, RwLock},
+};
+
+use anyhow::{Context, Error};
+use bytes::Bytes;
+use http::{HeaderMap, Method};
+use tempfile::NamedTempFile;
+use url::Url;
+use webc::{
+    compat::{Container, ContainerError},
+    DetectError,
+};
+
+use crate::{
+    bin_factory::BinaryPackage,
+    http::{HttpClient, HttpRequest, USER_AGENT},
+    runtime::{
+        package_loader::PackageLoader,
+        resolver::{DistributionInfo, PackageSummary, Resolution, WebcHash},
+    },
+};
+
+/// The builtin [`PackageLoader`] that is used by the `wasmer` CLI and
+/// respects `$WASMER_DIR`.
+#[derive(Debug)]
+pub struct BuiltinPackageLoader {
+    client: Arc<dyn HttpClient + Send + Sync>,
+    in_memory: InMemoryCache,
+    cache: Option<FileSystemCache>,
+    /// A mapping from hostnames to tokens
+    tokens: HashMap<String, String>,
+}
+
+impl BuiltinPackageLoader {
+    pub fn new() -> Self {
+        BuiltinPackageLoader {
+            in_memory: InMemoryCache::default(),
+            client: Arc::new(crate::http::default_http_client().unwrap()),
+            cache: None,
+            tokens: HashMap::new(),
+        }
+    }
+
+    pub fn with_cache_dir(self, cache_dir: impl Into<PathBuf>) -> Self {
+        BuiltinPackageLoader {
+            cache: Some(FileSystemCache {
+                cache_dir: cache_dir.into(),
+            }),
+            ..self
+        }
+    }
+
+    pub fn with_http_client(self, client: impl HttpClient + Send + Sync + 'static) -> Self {
+        self.with_shared_http_client(Arc::new(client))
+    }
+
+    pub fn with_shared_http_client(self, client: Arc<dyn HttpClient + Send + Sync>) -> Self {
+        BuiltinPackageLoader { client, ..self }
+    }
+
+    pub fn with_tokens<I, K, V>(mut self, tokens: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<String>,
+    {
+        for (hostname, token) in tokens {
+            self = self.with_token(hostname, token);
+        }
+
+        self
+    }
+
+    /// Add an API token that will be used whenever sending requests to a
+    /// particular hostname.
+    ///
+    /// Note that this uses [`Url::authority()`] when looking up tokens, so it
+    /// will match both plain hostnames (e.g. `registry.wasmer.io`) and hosts
+    /// with a port number (e.g. `localhost:8000`).
+    pub fn with_token(mut self, hostname: impl Into<String>, token: impl Into<String>) -> Self {
+        self.tokens.insert(hostname.into(), token.into());
+        self
+    }
+
+    /// Insert a container into the in-memory hash.
+    pub fn insert_cached(&self, hash: WebcHash, container: &Container) {
+        self.in_memory.save(container, hash);
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, fields(pkg.hash=%hash))]
+    async fn get_cached(&self, hash: &WebcHash) -> Result<Option<Container>, Error> {
+        if let Some(cached) = self.in_memory.lookup(hash) {
+            return Ok(Some(cached));
+        }
+
+        if let Some(cache) = self.cache.as_ref() {
+            if let Some(cached) = cache.lookup(hash).await? {
+                // Note: We want to propagate it to the in-memory cache, too
+                tracing::debug!("Copying from the filesystem cache to the in-memory cache");
+                self.in_memory.save(&cached, *hash);
+                return Ok(Some(cached));
+            }
+        }
+
+        Ok(None)
+    }
+
+    #[tracing::instrument(level = "debug", skip_all, fields(%dist.webc, %dist.webc_sha256))]
+    async fn download(&self, dist: &DistributionInfo) -> Result<Bytes, Error> {
+        if dist.webc.scheme() == "file" {
+            match crate::runtime::resolver::utils::file_path_from_url(&dist.webc) {
+                Ok(path) => {
+                    let bytes = crate::spawn_blocking({
+                        let path = path.clone();
+                        move || std::fs::read(path)
+                    })
+                    .await?
+                    .with_context(|| format!("Unable to read \"{}\"", path.display()))?;
+                    return Ok(bytes.into());
+                }
+                Err(e) => {
+                    tracing::debug!(
+                        url=%dist.webc,
+                        error=&*e,
+                        "Unable to convert the file:// URL to a path",
+                    );
+                }
+            }
+        }
+
+        let request = HttpRequest {
+            headers: self.headers(&dist.webc),
+            url: dist.webc.clone(),
+            method: Method::GET,
+            body: None,
+            options: Default::default(),
+        };
+
+        tracing::debug!(%request.url, %request.method, "Downloading a webc file");
+        tracing::trace!(?request.headers);
+
+        let response = self.client.request(request).await?;
+
+        tracing::trace!(
+            %response.status,
+            %response.redirected,
+            ?response.headers,
+            response.len=response.body.as_ref().map(|body| body.len()),
+            "Received a response",
+        );
+
+        if !response.is_ok() {
+            let url = &dist.webc;
+            return Err(crate::runtime::resolver::utils::http_error(&response)
+                .context(format!("The GET request to \"{url}\" failed")));
+        }
+
+        let body = response
+            .body
+            .context("The response didn't contain a body")?;
+
+        Ok(body.into())
+    }
+
+    fn headers(&self, url: &Url) -> HeaderMap {
+        let mut headers = HeaderMap::new();
+        headers.insert("Accept", "application/webc".parse().unwrap());
+        headers.insert("User-Agent", USER_AGENT.parse().unwrap());
+
+        if url.has_authority() {
+            if let Some(token) = self.tokens.get(url.authority()) {
+                let header = format!("Bearer {token}");
+                match header.parse() {
+                    Ok(header) => {
+                        headers.insert(http::header::AUTHORIZATION, header);
+                    }
+                    Err(e) => {
+                        tracing::warn!(
+                            error = &e as &dyn std::error::Error,
+                            "An error occurred while parsing the authorization header",
+                        );
+                    }
+                }
+            }
+        }
+
+        headers
+    }
+}
+
+impl Default for BuiltinPackageLoader {
+    fn default() -> Self {
+        BuiltinPackageLoader::new()
+    }
+}
+
+#[async_trait::async_trait]
+impl PackageLoader for BuiltinPackageLoader {
+    #[tracing::instrument(
+        level="debug",
+        skip_all,
+        fields(
+            pkg.name=summary.pkg.name.as_str(),
+            pkg.version=%summary.pkg.version,
+        ),
+    )]
+    async fn load(&self, summary: &PackageSummary) -> Result<Container, Error> {
+        if let Some(container) = self.get_cached(&summary.dist.webc_sha256).await? {
+            tracing::debug!("Cache hit!");
+            return Ok(container);
+        }
+
+        // looks like we had a cache miss and need to download it manually
+        let bytes = self
+            .download(&summary.dist)
+            .await
+            .with_context(|| format!("Unable to download \"{}\"", summary.dist.webc))?;
+
+        // We want to cache the container we downloaded, but we want to do it
+        // in a smart way to keep memory usage down.
+
+        if let Some(cache) = &self.cache {
+            match cache
+                .save_and_load_as_mmapped(bytes.clone(), &summary.dist)
+                .await
+            {
+                Ok(container) => {
+                    tracing::debug!("Cached to disk");
+                    self.in_memory.save(&container, summary.dist.webc_sha256);
+                    // The happy path - we've saved to both caches and loaded the
+                    // container from disk (hopefully using mmap) so we're done.
+                    return Ok(container);
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        error=&*e,
+                        pkg.name=%summary.pkg.name,
+                        pkg.version=%summary.pkg.version,
+                        pkg.hash=%summary.dist.webc_sha256,
+                        pkg.url=%summary.dist.webc,
+                        "Unable to save the downloaded package to disk",
+                    );
+                }
+            }
+        }
+
+        // The sad path - looks like we don't have a filesystem cache so we'll
+        // need to keep the whole thing in memory.
+        let container = crate::spawn_blocking(move || Container::from_bytes(bytes)).await??;
+        // We still want to cache it in memory, of course
+        self.in_memory.save(&container, summary.dist.webc_sha256);
+        Ok(container)
+    }
+
+    async fn load_package_tree(
+        &self,
+        root: &Container,
+        resolution: &Resolution,
+    ) -> Result<BinaryPackage, Error> {
+        super::load_package_tree(root, self, resolution).await
+    }
+}
+
+// FIXME: This implementation will block the async runtime and should use
+// some sort of spawn_blocking() call to run it in the background.
+#[derive(Debug)]
+struct FileSystemCache {
+    cache_dir: PathBuf,
+}
+
+impl FileSystemCache {
+    async fn lookup(&self, hash: &WebcHash) -> Result<Option<Container>, Error> {
+        let path = self.path(hash);
+
+        let container = crate::spawn_blocking({
+            let path = path.clone();
+            move || Container::from_disk(path)
+        })
+        .await?;
+        match container {
+            Ok(c) => Ok(Some(c)),
+            Err(ContainerError::Open { error, .. })
+            | Err(ContainerError::Read { error, .. })
+            | Err(ContainerError::Detect(DetectError::Io(error)))
+                if error.kind() == ErrorKind::NotFound =>
+            {
+                Ok(None)
+            }
+            Err(e) => {
+                let msg = format!("Unable to read \"{}\"", path.display());
+                Err(Error::new(e).context(msg))
+            }
+        }
+    }
+
+    async fn save(&self, webc: Bytes, dist: &DistributionInfo) -> Result<(), Error> {
+        let path = self.path(&dist.webc_sha256);
+        let dist = dist.clone();
+
+        crate::spawn_blocking(move || {
+            let parent = path.parent().expect("Always within cache_dir");
+
+            std::fs::create_dir_all(parent)
+                .with_context(|| format!("Unable to create \"{}\"", parent.display()))?;
+
+            let mut temp = NamedTempFile::new_in(parent)?;
+            temp.write_all(&webc)?;
+            temp.flush()?;
+            temp.as_file_mut().sync_all()?;
+            temp.persist(&path)?;
+
+            tracing::debug!(
+                pkg.hash=%dist.webc_sha256,
+                pkg.url=%dist.webc,
+                path=%path.display(),
+                num_bytes=webc.len(),
+                "Saved to disk",
+            );
+            Result::<_, Error>::Ok(())
+        })
+        .await??;
+
+        Ok(())
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    async fn save_and_load_as_mmapped(
+        &self,
+        webc: Bytes,
+        dist: &DistributionInfo,
+    ) -> Result<Container, Error> {
+        // First, save it to disk
+        self.save(webc, dist).await?;
+
+        // Now try to load it again. The resulting container should use
+        // a memory-mapped file rather than an in-memory buffer.
+        match self.lookup(&dist.webc_sha256).await? {
+            Some(container) => Ok(container),
+            None => {
+                // Something really weird has occurred and we can't see the
+                // saved file. Just error out and let the fallback code do its
+                // thing.
+                Err(Error::msg("Unable to load the downloaded memory from disk"))
+            }
+        }
+    }
+
+    fn path(&self, hash: &WebcHash) -> PathBuf {
+        let hash = hash.as_bytes();
+        let mut filename = String::with_capacity(hash.len() * 2);
+        for b in hash {
+            write!(filename, "{b:02x}").unwrap();
+        }
+        filename.push_str(".bin");
+
+        self.cache_dir.join(filename)
+    }
+}
+
+#[derive(Debug, Default)]
+struct InMemoryCache(RwLock<HashMap<WebcHash, Container>>);
+
+impl InMemoryCache {
+    fn lookup(&self, hash: &WebcHash) -> Option<Container> {
+        self.0.read().unwrap().get(hash).cloned()
+    }
+
+    fn save(&self, container: &Container, hash: WebcHash) {
+        let mut cache = self.0.write().unwrap();
+        cache.entry(hash).or_insert_with(|| container.clone());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{collections::VecDeque, sync::Mutex};
+
+    use futures::future::BoxFuture;
+    use http::{HeaderMap, StatusCode};
+    use tempfile::TempDir;
+
+    use crate::{
+        http::{HttpRequest, HttpResponse},
+        runtime::resolver::PackageInfo,
+    };
+
+    use super::*;
+
+    const PYTHON: &[u8] = include_bytes!("../../../../c-api/examples/assets/python-0.1.0.wasmer");
+
+    #[derive(Debug)]
+    pub(crate) struct DummyClient {
+        requests: Mutex<Vec<HttpRequest>>,
+        responses: Mutex<VecDeque<HttpResponse>>,
+    }
+
+    impl DummyClient {
+        pub fn with_responses(responses: impl IntoIterator<Item = HttpResponse>) -> Self {
+            DummyClient {
+                requests: Mutex::new(Vec::new()),
+                responses: Mutex::new(responses.into_iter().collect()),
+            }
+        }
+    }
+
+    impl HttpClient for DummyClient {
+        fn request(
+            &self,
+            request: HttpRequest,
+        ) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+            let response = self.responses.lock().unwrap().pop_front().unwrap();
+            self.requests.lock().unwrap().push(request);
+            Box::pin(async { Ok(response) })
+        }
+    }
+
+    async fn cache_misses_will_trigger_a_download_internal() {
+        let temp = TempDir::new().unwrap();
+        let client = Arc::new(DummyClient::with_responses([HttpResponse {
+            body: Some(PYTHON.to_vec()),
+            redirected: false,
+            status: StatusCode::OK,
+            headers: HeaderMap::new(),
+        }]));
+        let loader = BuiltinPackageLoader::new()
+            .with_cache_dir(temp.path())
+            .with_shared_http_client(client.clone());
+        let summary = PackageSummary {
+            pkg: PackageInfo {
+                name: "python/python".to_string(),
+                version: "0.1.0".parse().unwrap(),
+                dependencies: Vec::new(),
+                commands: Vec::new(),
+                entrypoint: Some("asdf".to_string()),
+                filesystem: Vec::new(),
+            },
+            dist: DistributionInfo {
+                webc: "https://wasmer.io/python/python".parse().unwrap(),
+                webc_sha256: [0xaa; 32].into(),
+            },
+        };
+
+        let container = loader.load(&summary).await.unwrap();
+
+        // A HTTP request was sent
+        let requests = client.requests.lock().unwrap();
+        let request = &requests[0];
+        assert_eq!(request.url, summary.dist.webc);
+        assert_eq!(request.method, "GET");
+        assert_eq!(request.headers.len(), 2);
+        assert_eq!(request.headers["Accept"], "application/webc");
+        assert_eq!(request.headers["User-Agent"], USER_AGENT);
+        // Make sure we got the right package
+        let manifest = container.manifest();
+        assert_eq!(manifest.entrypoint.as_deref(), Some("python"));
+        // it should have been automatically saved to disk
+        let path = loader
+            .cache
+            .as_ref()
+            .unwrap()
+            .path(&summary.dist.webc_sha256);
+        assert!(path.exists());
+        assert_eq!(std::fs::read(&path).unwrap(), PYTHON);
+        // and cached in memory for next time
+        let in_memory = loader.in_memory.0.read().unwrap();
+        assert!(in_memory.contains_key(&summary.dist.webc_sha256));
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn cache_misses_will_trigger_a_download() {
+        cache_misses_will_trigger_a_download_internal().await
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    #[tokio::test()]
+    async fn cache_misses_will_trigger_a_download() {
+        cache_misses_will_trigger_a_download_internal().await
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/load_package_tree.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/load_package_tree.rs
new file mode 100644
index 0000000..63b2c26
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/load_package_tree.rs
@@ -0,0 +1,466 @@
+use std::{
+    collections::{BTreeMap, HashMap, HashSet},
+    fmt::Debug,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use anyhow::{Context, Error};
+use futures::{future::BoxFuture, StreamExt, TryStreamExt};
+use once_cell::sync::OnceCell;
+use petgraph::visit::EdgeRef;
+use virtual_fs::{FileSystem, OverlayFileSystem, WebcVolumeFileSystem};
+use webc::{
+    compat::{Container, Volume},
+    metadata::annotations::Atom as AtomAnnotation,
+};
+
+use crate::{
+    bin_factory::{BinaryPackage, BinaryPackageCommand},
+    runtime::{
+        package_loader::PackageLoader,
+        resolver::{
+            DependencyGraph, ItemLocation, PackageId, PackageSummary, Resolution,
+            ResolvedFileSystemMapping, ResolvedPackage,
+        },
+    },
+};
+
+/// The maximum number of packages that will be loaded in parallel.
+const MAX_PARALLEL_DOWNLOADS: usize = 32;
+
+/// Given a fully resolved package, load it into memory for execution.
+#[tracing::instrument(level = "debug", skip_all)]
+pub async fn load_package_tree(
+    root: &Container,
+    loader: &dyn PackageLoader,
+    resolution: &Resolution,
+) -> Result<BinaryPackage, Error> {
+    let mut containers = fetch_dependencies(loader, &resolution.package, &resolution.graph).await?;
+    containers.insert(resolution.package.root_package.clone(), root.clone());
+    let fs = filesystem(&containers, &resolution.package)?;
+
+    let root = &resolution.package.root_package;
+    let commands: Vec<BinaryPackageCommand> =
+        commands(&resolution.package.commands, &containers, resolution)?;
+
+    let file_system_memory_footprint = count_file_system(&fs, Path::new("/"));
+
+    let loaded = BinaryPackage {
+        package_name: root.package_name.clone(),
+        version: root.version.clone(),
+        when_cached: crate::syscalls::platform_clock_time_get(
+            wasmer_wasix_types::wasi::Snapshot0Clockid::Monotonic,
+            1_000_000,
+        )
+        .ok()
+        .map(|ts| ts as u128),
+        hash: OnceCell::new(),
+        entrypoint_cmd: resolution.package.entrypoint.clone(),
+        webc_fs: Arc::new(fs),
+        commands,
+        uses: Vec::new(),
+        file_system_memory_footprint,
+    };
+
+    Ok(loaded)
+}
+
+fn commands(
+    commands: &BTreeMap<String, ItemLocation>,
+    containers: &HashMap<PackageId, Container>,
+    resolution: &Resolution,
+) -> Result<Vec<BinaryPackageCommand>, Error> {
+    let mut pkg_commands = Vec::new();
+
+    for (
+        name,
+        ItemLocation {
+            name: original_name,
+            package,
+        },
+    ) in commands
+    {
+        let webc = &containers[package];
+        let manifest = webc.manifest();
+        let command_metadata = &manifest.commands[original_name];
+
+        if let Some(cmd) =
+            load_binary_command(package, name, command_metadata, containers, resolution)?
+        {
+            pkg_commands.push(cmd);
+        }
+    }
+
+    Ok(pkg_commands)
+}
+
+/// Given a [`webc::metadata::Command`], figure out which atom it uses and load
+/// that atom into a [`BinaryPackageCommand`].
+fn load_binary_command(
+    package_id: &PackageId,
+    command_name: &str,
+    cmd: &webc::metadata::Command,
+    containers: &HashMap<PackageId, Container>,
+    resolution: &Resolution,
+) -> Result<Option<BinaryPackageCommand>, anyhow::Error> {
+    let AtomAnnotation {
+        name: atom_name,
+        dependency,
+        ..
+    } = match atom_name_for_command(command_name, cmd)? {
+        Some(name) => name,
+        None => {
+            tracing::warn!(
+                cmd.name=command_name,
+                cmd.runner=%cmd.runner,
+                "Skipping unsupported command",
+            );
+            return Ok(None);
+        }
+    };
+
+    let package = &containers[package_id];
+
+    let webc = match dependency {
+        Some(dep) => {
+            let ix = resolution
+                .graph
+                .packages()
+                .get(package_id)
+                .copied()
+                .unwrap();
+            let graph = resolution.graph.graph();
+            let edge_reference = graph
+                .edges_directed(ix, petgraph::Direction::Outgoing)
+                .find(|edge| edge.weight().alias == dep)
+                .with_context(|| format!("Unable to find the \"{dep}\" dependency for the \"{command_name}\" command in \"{package_id}\""))?;
+
+            let other_package = graph.node_weight(edge_reference.target()).unwrap();
+            &containers[&other_package.id]
+        }
+        None => package,
+    };
+
+    let atom = webc.get_atom(&atom_name);
+
+    if atom.is_none() && cmd.annotations.is_empty() {
+        return Ok(legacy_atom_hack(webc, command_name, cmd));
+    }
+
+    let atom = atom.with_context(|| {
+        format!(
+            "The '{command_name}' command uses the '{atom_name}' atom, but it isn't present in the WEBC file"
+        )
+    })?;
+
+    let cmd = BinaryPackageCommand::new(command_name.to_string(), cmd.clone(), atom);
+
+    Ok(Some(cmd))
+}
+
+fn atom_name_for_command(
+    command_name: &str,
+    cmd: &webc::metadata::Command,
+) -> Result<Option<AtomAnnotation>, anyhow::Error> {
+    use webc::metadata::annotations::{EMSCRIPTEN_RUNNER_URI, WASI_RUNNER_URI, WCGI_RUNNER_URI};
+
+    if let Some(atom) = cmd
+        .atom()
+        .context("Unable to deserialize atom annotations")?
+    {
+        return Ok(Some(atom));
+    }
+
+    if [WASI_RUNNER_URI, WCGI_RUNNER_URI, EMSCRIPTEN_RUNNER_URI]
+        .iter()
+        .any(|uri| cmd.runner.starts_with(uri))
+    {
+        // Note: We use the command name as the atom name as a special case
+        // for known runner types because sometimes people will construct
+        // a manifest by hand instead of using wapm2pirita.
+        tracing::debug!(
+            command = command_name,
+            "No annotations specifying the atom name found. Falling back to the command name"
+        );
+        return Ok(Some(AtomAnnotation::new(command_name, None)));
+    }
+
+    Ok(None)
+}
+
+/// HACK: Some older packages like `sharrattj/bash` and `sharrattj/coreutils`
+/// contain commands with no annotations. When this happens, you can just assume
+/// it wants to use the first atom in the WEBC file.
+///
+/// That works because most of these packages only have a single atom (e.g. in
+/// `sharrattj/coreutils` there are commands for `ls`, `pwd`, and so on, but
+/// under the hood they all use the `coreutils` atom).
+///
+/// See <https://github.com/wasmerio/wasmer/commit/258903140680716da1431d92bced67d486865aeb>
+/// for more.
+fn legacy_atom_hack(
+    webc: &Container,
+    command_name: &str,
+    metadata: &webc::metadata::Command,
+) -> Option<BinaryPackageCommand> {
+    let (name, atom) = webc.atoms().into_iter().next()?;
+
+    tracing::debug!(
+        command_name,
+        atom.name = name.as_str(),
+        atom.len = atom.len(),
+        "(hack) The command metadata is malformed. Falling back to the first atom in the WEBC file",
+    );
+
+    Some(BinaryPackageCommand::new(
+        command_name.to_string(),
+        metadata.clone(),
+        atom,
+    ))
+}
+
+async fn fetch_dependencies(
+    loader: &dyn PackageLoader,
+    pkg: &ResolvedPackage,
+    graph: &DependencyGraph,
+) -> Result<HashMap<PackageId, Container>, Error> {
+    let mut packages = HashSet::new();
+
+    for loc in pkg.commands.values() {
+        packages.insert(loc.package.clone());
+    }
+
+    for mapping in &pkg.filesystem {
+        packages.insert(mapping.package.clone());
+    }
+
+    // We don't need to download the root package
+    packages.remove(&pkg.root_package);
+
+    let packages = packages.into_iter().filter_map(|id| {
+        let crate::runtime::resolver::Node { pkg, dist, .. } = &graph[&id];
+        let summary = PackageSummary {
+            pkg: pkg.clone(),
+            dist: dist.clone()?,
+        };
+        Some((id, summary))
+    });
+    let packages: HashMap<PackageId, Container> = futures::stream::iter(packages)
+        .map(|(id, s)| async move {
+            match loader.load(&s).await {
+                Ok(webc) => Ok((id, webc)),
+                Err(e) => Err(e),
+            }
+        })
+        .buffer_unordered(MAX_PARALLEL_DOWNLOADS)
+        .try_collect()
+        .await?;
+
+    Ok(packages)
+}
+
+/// How many bytes worth of files does a directory contain?
+fn count_file_system(fs: &dyn FileSystem, path: &Path) -> u64 {
+    let mut total = 0;
+
+    let dir = match fs.read_dir(path) {
+        Ok(d) => d,
+        Err(_err) => {
+            return 0;
+        }
+    };
+
+    for entry in dir.flatten() {
+        if let Ok(meta) = entry.metadata() {
+            total += meta.len();
+            if meta.is_dir() {
+                total += count_file_system(fs, entry.path.as_path());
+            }
+        }
+    }
+
+    total
+}
+
+/// Given a set of [`ResolvedFileSystemMapping`]s and the [`Container`] for each
+/// package in a dependency tree, construct the resulting filesystem.
+///
+/// # Note to future readers
+///
+/// Sooo... this code is a bit convoluted because we're constrained by the
+/// filesystem implementations we've got available.
+///
+/// Ideally, we would create a WebcVolumeFileSystem for each volume we're
+/// using, then we'd have a single "union" filesystem which lets you mount
+/// filesystem objects under various paths and can deal with conflicts.
+///
+/// The OverlayFileSystem lets us make files from multiple filesystem
+/// implementations available at the same time, however all of the
+/// filesystems will be mounted at "/", when the user wants to mount volumes
+/// at arbitrary locations.
+///
+/// The TmpFileSystem *does* allow mounting at non-root paths, however it can't
+/// handle nested paths (e.g. mounting to "/lib" and "/lib/python3.10" - see
+/// <https://github.com/wasmerio/wasmer/issues/3678> for more) and you aren't
+/// allowed to mount to "/" because it's a special directory that already
+/// exists.
+///
+/// As a result, we'll duct-tape things together and hope for the best 🤞
+fn filesystem(
+    packages: &HashMap<PackageId, Container>,
+    pkg: &ResolvedPackage,
+) -> Result<impl FileSystem + Send + Sync, Error> {
+    let mut filesystems = Vec::new();
+    let mut volumes: HashMap<&PackageId, BTreeMap<String, Volume>> = HashMap::new();
+
+    let mut mountings: Vec<_> = pkg.filesystem.iter().collect();
+    mountings.sort_by_key(|m| std::cmp::Reverse(m.mount_path.as_path()));
+
+    for ResolvedFileSystemMapping {
+        mount_path,
+        volume_name,
+        package,
+        original_path,
+    } in &pkg.filesystem
+    {
+        // Note: We want to reuse existing Volume instances if we can. That way
+        // we can keep the memory usage down. A webc::compat::Volume is
+        // reference-counted, anyway.
+        let container_volumes = match volumes.entry(package) {
+            std::collections::hash_map::Entry::Occupied(entry) => &*entry.into_mut(),
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                // looks like we need to insert it
+                let container = packages.get(package)
+                    .with_context(|| format!(
+                        "\"{}\" wants to use the \"{}\" package, but it isn't in the dependency tree",
+                        pkg.root_package,
+                        package,
+                    ))?;
+                &*entry.insert(container.volumes())
+            }
+        };
+
+        let volume = container_volumes.get(volume_name).with_context(|| {
+            format!("The \"{package}\" package doesn't have a \"{volume_name}\" volume")
+        })?;
+
+        let original_path = PathBuf::from(original_path);
+        let mount_path = mount_path.clone();
+        // Get a filesystem which will map "$mount_dir/some-path" to
+        // "$original_path/some-path" on the original volume
+        let fs =
+            MappedPathFileSystem::new(WebcVolumeFileSystem::new(volume.clone()), move |path| {
+                let without_mount_dir = path
+                    .strip_prefix(&mount_path)
+                    .map_err(|_| virtual_fs::FsError::BaseNotDirectory)?;
+                let path_on_original_volume = original_path.join(without_mount_dir);
+                Ok(path_on_original_volume)
+            });
+
+        filesystems.push(fs);
+    }
+
+    let fs = OverlayFileSystem::new(virtual_fs::EmptyFileSystem::default(), filesystems);
+
+    Ok(fs)
+}
+
+/// A [`FileSystem`] implementation that lets you map the [`Path`] to something
+/// else.
+#[derive(Clone, PartialEq)]
+struct MappedPathFileSystem<F, M> {
+    inner: F,
+    map: M,
+}
+
+impl<F, M> MappedPathFileSystem<F, M>
+where
+    M: Fn(&Path) -> Result<PathBuf, virtual_fs::FsError> + Send + Sync + 'static,
+{
+    fn new(inner: F, map: M) -> Self {
+        MappedPathFileSystem { inner, map }
+    }
+
+    fn path(&self, path: &Path) -> Result<PathBuf, virtual_fs::FsError> {
+        let path = (self.map)(path)?;
+
+        // Don't forget to make the path absolute again.
+        Ok(Path::new("/").join(path))
+    }
+}
+
+impl<M, F> FileSystem for MappedPathFileSystem<F, M>
+where
+    F: FileSystem,
+    M: Fn(&Path) -> Result<PathBuf, virtual_fs::FsError> + Send + Sync + 'static,
+{
+    fn read_dir(&self, path: &Path) -> virtual_fs::Result<virtual_fs::ReadDir> {
+        let path = self.path(path)?;
+        self.inner.read_dir(&path)
+    }
+
+    fn create_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        let path = self.path(path)?;
+        self.inner.create_dir(&path)
+    }
+
+    fn remove_dir(&self, path: &Path) -> virtual_fs::Result<()> {
+        let path = self.path(path)?;
+        self.inner.remove_dir(&path)
+    }
+
+    fn rename<'a>(&'a self, from: &Path, to: &Path) -> BoxFuture<'a, virtual_fs::Result<()>> {
+        let from = from.to_owned();
+        let to = to.to_owned();
+        Box::pin(async move {
+            let from = self.path(&from)?;
+            let to = self.path(&to)?;
+            self.inner.rename(&from, &to).await
+        })
+    }
+
+    fn metadata(&self, path: &Path) -> virtual_fs::Result<virtual_fs::Metadata> {
+        let path = self.path(path)?;
+        self.inner.metadata(&path)
+    }
+
+    fn remove_file(&self, path: &Path) -> virtual_fs::Result<()> {
+        let path = self.path(path)?;
+        self.inner.remove_file(&path)
+    }
+
+    fn new_open_options(&self) -> virtual_fs::OpenOptions {
+        virtual_fs::OpenOptions::new(self)
+    }
+}
+
+impl<F, M> virtual_fs::FileOpener for MappedPathFileSystem<F, M>
+where
+    F: FileSystem,
+    M: Fn(&Path) -> Result<PathBuf, virtual_fs::FsError> + Send + Sync + 'static,
+{
+    fn open(
+        &self,
+        path: &Path,
+        conf: &virtual_fs::OpenOptionsConfig,
+    ) -> virtual_fs::Result<Box<dyn virtual_fs::VirtualFile + Send + Sync + 'static>> {
+        let path = self.path(path)?;
+        self.inner
+            .new_open_options()
+            .options(conf.clone())
+            .open(path)
+    }
+}
+
+impl<F, M> Debug for MappedPathFileSystem<F, M>
+where
+    F: Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MappedPathFileSystem")
+            .field("inner", &self.inner)
+            .field("map", &std::any::type_name::<M>())
+            .finish()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/mod.rs
new file mode 100644
index 0000000..b9eeb64
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/mod.rs
@@ -0,0 +1,9 @@
+mod builtin_loader;
+mod load_package_tree;
+mod types;
+mod unsupported;
+
+pub use self::{
+    builtin_loader::BuiltinPackageLoader, load_package_tree::load_package_tree,
+    types::PackageLoader, unsupported::UnsupportedPackageLoader,
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/types.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/types.rs
new file mode 100644
index 0000000..afb3e92
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/types.rs
@@ -0,0 +1,43 @@
+use std::{fmt::Debug, ops::Deref};
+
+use anyhow::Error;
+use webc::compat::Container;
+
+use crate::{
+    bin_factory::BinaryPackage,
+    runtime::resolver::{PackageSummary, Resolution},
+};
+
+#[async_trait::async_trait]
+pub trait PackageLoader: Send + Sync + Debug {
+    async fn load(&self, summary: &PackageSummary) -> Result<Container, Error>;
+
+    /// Load a resolved package into memory so it can be executed.
+    ///
+    /// A good default implementation is to just call
+    /// [`load_package_tree()`][super::load_package_tree()].
+    async fn load_package_tree(
+        &self,
+        root: &Container,
+        resolution: &Resolution,
+    ) -> Result<BinaryPackage, Error>;
+}
+
+#[async_trait::async_trait]
+impl<D, P> PackageLoader for D
+where
+    D: Deref<Target = P> + Debug + Send + Sync,
+    P: PackageLoader + ?Sized + 'static,
+{
+    async fn load(&self, summary: &PackageSummary) -> Result<Container, Error> {
+        (**self).load(summary).await
+    }
+
+    async fn load_package_tree(
+        &self,
+        root: &Container,
+        resolution: &Resolution,
+    ) -> Result<BinaryPackage, Error> {
+        (**self).load_package_tree(root, resolution).await
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/unsupported.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/unsupported.rs
new file mode 100644
index 0000000..be5488b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/package_loader/unsupported.rs
@@ -0,0 +1,33 @@
+use anyhow::Error;
+use webc::compat::Container;
+
+use crate::{
+    bin_factory::BinaryPackage,
+    runtime::{
+        package_loader::PackageLoader,
+        resolver::{PackageSummary, Resolution},
+    },
+};
+
+/// A [`PackageLoader`] implementation which will always error out.
+#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
+pub struct UnsupportedPackageLoader;
+
+#[async_trait::async_trait]
+impl PackageLoader for UnsupportedPackageLoader {
+    async fn load(&self, _summary: &PackageSummary) -> Result<Container, Error> {
+        Err(Error::new(Unsupported))
+    }
+
+    async fn load_package_tree(
+        &self,
+        _root: &Container,
+        _resolution: &Resolution,
+    ) -> Result<BinaryPackage, Error> {
+        Err(Error::new(Unsupported))
+    }
+}
+
+#[derive(Debug, Copy, Clone, thiserror::Error)]
+#[error("Loading of packages is not supported in this runtime (no PackageLoader configured)")]
+struct Unsupported;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/filesystem_source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/filesystem_source.rs
new file mode 100644
index 0000000..c20ceff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/filesystem_source.rs
@@ -0,0 +1,46 @@
+use anyhow::Context;
+use webc::compat::Container;
+
+use crate::runtime::resolver::{
+    DistributionInfo, PackageInfo, PackageSpecifier, PackageSummary, QueryError, Source, WebcHash,
+};
+
+/// A [`Source`] that knows how to query files on the filesystem.
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct FileSystemSource {}
+
+#[async_trait::async_trait]
+impl Source for FileSystemSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        let path = match package {
+            PackageSpecifier::Path(path) => path.canonicalize().with_context(|| {
+                format!(
+                    "Unable to get the canonical form for \"{}\"",
+                    path.display()
+                )
+            })?,
+            _ => return Err(QueryError::Unsupported),
+        };
+
+        let webc_sha256 = crate::block_in_place(|| WebcHash::for_file(&path))
+            .with_context(|| format!("Unable to hash \"{}\"", path.display()))?;
+        let container = crate::block_in_place(|| Container::from_disk(&path))
+            .with_context(|| format!("Unable to parse \"{}\"", path.display()))?;
+
+        let url = crate::runtime::resolver::utils::url_from_file_path(&path)
+            .ok_or_else(|| anyhow::anyhow!("Unable to turn \"{}\" into a URL", path.display()))?;
+
+        let pkg = PackageInfo::from_manifest(container.manifest())
+            .context("Unable to determine the package's metadata")?;
+        let summary = PackageSummary {
+            pkg,
+            dist: DistributionInfo {
+                webc: url,
+                webc_sha256,
+            },
+        };
+
+        Ok(vec![summary])
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/in_memory_source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/in_memory_source.rs
new file mode 100644
index 0000000..0de44ac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/in_memory_source.rs
@@ -0,0 +1,197 @@
+use std::{
+    collections::{BTreeMap, VecDeque},
+    fs::File,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{Context, Error};
+use semver::Version;
+
+use crate::runtime::resolver::{PackageSpecifier, PackageSummary, QueryError, Source};
+
+/// A [`Source`] that tracks packages in memory.
+///
+/// Primarily used during testing.
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct InMemorySource {
+    packages: BTreeMap<String, Vec<PackageSummary>>,
+}
+
+impl InMemorySource {
+    pub fn new() -> Self {
+        InMemorySource::default()
+    }
+
+    /// Recursively walk a directory, adding all valid WEBC files to the source.
+    pub fn from_directory_tree(dir: impl Into<PathBuf>) -> Result<Self, Error> {
+        let mut source = InMemorySource::default();
+
+        let mut to_check: VecDeque<PathBuf> = VecDeque::new();
+        to_check.push_back(dir.into());
+
+        fn process_entry(
+            path: &Path,
+            source: &mut InMemorySource,
+            to_check: &mut VecDeque<PathBuf>,
+        ) -> Result<(), Error> {
+            let metadata = std::fs::metadata(path).context("Unable to get filesystem metadata")?;
+
+            if metadata.is_dir() {
+                for entry in path.read_dir().context("Unable to read the directory")? {
+                    to_check.push_back(entry?.path());
+                }
+            } else if metadata.is_file() {
+                let f = File::open(path).context("Unable to open the file")?;
+                if webc::detect(f).is_ok() {
+                    source
+                        .add_webc(path)
+                        .with_context(|| format!("Unable to load \"{}\"", path.display()))?;
+                }
+            }
+
+            Ok(())
+        }
+
+        while let Some(path) = to_check.pop_front() {
+            process_entry(&path, &mut source, &mut to_check)
+                .with_context(|| format!("Unable to add entries from \"{}\"", path.display()))?;
+        }
+
+        Ok(source)
+    }
+
+    /// Add a new [`PackageSummary`] to the [`InMemorySource`].
+    pub fn add(&mut self, summary: PackageSummary) {
+        let summaries = self.packages.entry(summary.pkg.name.clone()).or_default();
+        summaries.push(summary);
+        summaries.sort_by(|left, right| left.pkg.version.cmp(&right.pkg.version));
+        summaries.dedup_by(|left, right| left.pkg.version == right.pkg.version);
+    }
+
+    pub fn add_webc(&mut self, path: impl AsRef<Path>) -> Result<(), Error> {
+        let summary = PackageSummary::from_webc_file(path)?;
+        self.add(summary);
+
+        Ok(())
+    }
+
+    pub fn packages(&self) -> &BTreeMap<String, Vec<PackageSummary>> {
+        &self.packages
+    }
+
+    pub fn get(&self, package_name: &str, version: &Version) -> Option<&PackageSummary> {
+        let summaries = self.packages.get(package_name)?;
+        summaries.iter().find(|s| s.pkg.version == *version)
+    }
+}
+
+#[async_trait::async_trait]
+impl Source for InMemorySource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        match package {
+            PackageSpecifier::Registry { full_name, version } => {
+                match self.packages.get(full_name) {
+                    Some(summaries) => {
+                        let matches: Vec<_> = summaries
+                            .iter()
+                            .filter(|summary| version.matches(&summary.pkg.version))
+                            .cloned()
+                            .collect();
+
+                        tracing::debug!(
+                            matches = ?matches
+                                .iter()
+                                .map(|summary| summary.package_id().to_string())
+                                .collect::<Vec<_>>(),
+                        );
+
+                        if matches.is_empty() {
+                            return Err(QueryError::NoMatches {
+                                archived_versions: Vec::new(),
+                            });
+                        }
+
+                        Ok(matches)
+                    }
+                    None => Err(QueryError::NotFound),
+                }
+            }
+            PackageSpecifier::Url(_) | PackageSpecifier::Path(_) => Err(QueryError::Unsupported),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::TempDir;
+
+    use crate::runtime::resolver::{
+        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
+        Dependency, WebcHash,
+    };
+
+    use super::*;
+
+    const PYTHON: &[u8] = include_bytes!("../../../../c-api/examples/assets/python-0.1.0.wasmer");
+    const COREUTILS_16: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc");
+    const COREUTILS_11: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc");
+    const BASH: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc");
+
+    #[test]
+    fn load_a_directory_tree() {
+        let temp = TempDir::new().unwrap();
+        std::fs::write(temp.path().join("python-0.1.0.webc"), PYTHON).unwrap();
+        std::fs::write(temp.path().join("coreutils-1.0.16.webc"), COREUTILS_16).unwrap();
+        std::fs::write(temp.path().join("coreutils-1.0.11.webc"), COREUTILS_11).unwrap();
+        let nested = temp.path().join("nested");
+        std::fs::create_dir(&nested).unwrap();
+        let bash = nested.join("bash-1.0.12.webc");
+        std::fs::write(&bash, BASH).unwrap();
+
+        let source = InMemorySource::from_directory_tree(temp.path()).unwrap();
+
+        assert_eq!(
+            source
+                .packages
+                .keys()
+                .map(|k| k.as_str())
+                .collect::<Vec<_>>(),
+            ["python", "sharrattj/bash", "sharrattj/coreutils"]
+        );
+        assert_eq!(source.packages["sharrattj/coreutils"].len(), 2);
+        assert_eq!(
+            source.packages["sharrattj/bash"][0],
+            PackageSummary {
+                pkg: PackageInfo {
+                    name: "sharrattj/bash".to_string(),
+                    version: "1.0.16".parse().unwrap(),
+                    dependencies: vec![Dependency {
+                        alias: "coreutils".to_string(),
+                        pkg: "sharrattj/coreutils@^1.0.16".parse().unwrap()
+                    }],
+                    commands: vec![crate::runtime::resolver::Command {
+                        name: "bash".to_string(),
+                    }],
+                    entrypoint: Some("bash".to_string()),
+                    filesystem: vec![FileSystemMapping {
+                        volume_name: "atom".to_string(),
+                        mount_path: "/".to_string(),
+                        original_path: "/".to_string(),
+                        dependency_name: None,
+                    }],
+                },
+                dist: DistributionInfo {
+                    webc: crate::runtime::resolver::utils::url_from_file_path(
+                        bash.canonicalize().unwrap()
+                    )
+                    .unwrap(),
+                    webc_sha256: WebcHash::from_bytes([
+                        161, 101, 23, 194, 244, 92, 186, 213, 143, 33, 200, 128, 238, 23, 185, 174,
+                        180, 195, 144, 145, 78, 17, 227, 159, 118, 64, 83, 153, 0, 205, 253, 215,
+                    ]),
+                },
+            }
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/inputs.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/inputs.rs
new file mode 100644
index 0000000..a232c46
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/inputs.rs
@@ -0,0 +1,473 @@
+use std::{
+    fmt::{self, Display, Formatter},
+    fs::File,
+    io::{BufRead, BufReader, Read},
+    path::{Path, PathBuf},
+    str::FromStr,
+};
+
+use anyhow::{Context, Error};
+use semver::{Version, VersionReq};
+use sha2::{Digest, Sha256};
+use url::Url;
+use webc::{
+    metadata::{annotations::Wapm as WapmAnnotations, Manifest, UrlOrManifest},
+    Container,
+};
+
+use crate::runtime::resolver::PackageId;
+
+/// A reference to *some* package somewhere that the user wants to run.
+///
+/// # Security Considerations
+///
+/// The [`PackageSpecifier::Path`] variant doesn't specify which filesystem a
+/// [`Source`][source] will eventually query. Consumers of [`PackageSpecifier`]
+/// should be wary of sandbox escapes.
+///
+/// [source]: crate::runtime::resolver::Source
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum PackageSpecifier {
+    Registry {
+        full_name: String,
+        version: VersionReq,
+    },
+    Url(Url),
+    /// A `*.webc` file on disk.
+    Path(PathBuf),
+}
+
+impl PackageSpecifier {
+    pub fn parse(s: &str) -> Result<Self, anyhow::Error> {
+        s.parse()
+    }
+}
+
+impl FromStr for PackageSpecifier {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // There is no function in std for checking if a string is a valid path
+        // and we can't do Path::new(s).exists() because that assumes the
+        // package being specified is on the local filesystem, so let's make a
+        // best-effort guess.
+        if s.starts_with('.') || s.starts_with('/') {
+            return Ok(PackageSpecifier::Path(s.into()));
+        }
+        #[cfg(windows)]
+        if s.contains('\\') {
+            return Ok(PackageSpecifier::Path(s.into()));
+        }
+        if Path::new(s).exists() {
+            return Ok(PackageSpecifier::Path(s.into()));
+        }
+
+        if let Ok(url) = Url::parse(s) {
+            if url.has_host() {
+                return Ok(PackageSpecifier::Url(url));
+            }
+        }
+
+        // TODO: Replace this with something more rigorous that can also handle
+        // the locator field
+        let (full_name, version) = match s.split_once('@') {
+            Some((n, v)) => (n, v),
+            None => (s, "*"),
+        };
+
+        let invalid_character = full_name
+            .char_indices()
+            .find(|(_, c)| !matches!(c, 'a'..='z' | 'A'..='Z' | '0'..='9' | '.'| '-'|'_' | '/'));
+        if let Some((index, c)) = invalid_character {
+            anyhow::bail!("Invalid character, {c:?}, at offset {index}");
+        }
+
+        let version = if version == "latest" {
+            // let people write "some/package@latest"
+            VersionReq::STAR
+        } else {
+            version
+                .parse()
+                .with_context(|| format!("Invalid version number, \"{version}\""))?
+        };
+
+        Ok(PackageSpecifier::Registry {
+            full_name: full_name.to_string(),
+            version,
+        })
+    }
+}
+
+impl Display for PackageSpecifier {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PackageSpecifier::Registry { full_name, version } => {
+                write!(f, "{full_name}")?;
+
+                if !version.comparators.is_empty() {
+                    write!(f, "@{version}")?;
+                }
+
+                Ok(())
+            }
+            PackageSpecifier::Url(url) => Display::fmt(url, f),
+            PackageSpecifier::Path(path) => write!(f, "{}", path.display()),
+        }
+    }
+}
+
+/// A dependency constraint.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Dependency {
+    pub alias: String,
+    pub pkg: PackageSpecifier,
+}
+
+impl Dependency {
+    pub fn package_name(&self) -> Option<&str> {
+        match &self.pkg {
+            PackageSpecifier::Registry { full_name, .. } => Some(full_name),
+            _ => None,
+        }
+    }
+
+    pub fn alias(&self) -> &str {
+        &self.alias
+    }
+
+    pub fn version(&self) -> Option<&VersionReq> {
+        match &self.pkg {
+            PackageSpecifier::Registry { version, .. } => Some(version),
+            _ => None,
+        }
+    }
+}
+
+/// Some metadata a [`Source`][source] can provide about a package without
+/// needing to download the entire `*.webc` file.
+///
+/// [source]: crate::runtime::resolver::Source
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PackageSummary {
+    pub pkg: PackageInfo,
+    pub dist: DistributionInfo,
+}
+
+impl PackageSummary {
+    pub fn package_id(&self) -> PackageId {
+        self.pkg.id()
+    }
+
+    pub fn from_webc_file(path: impl AsRef<Path>) -> Result<PackageSummary, Error> {
+        let path = path.as_ref().canonicalize()?;
+        let container = Container::from_disk(&path)?;
+        let webc_sha256 = WebcHash::for_file(&path)?;
+        let url = crate::runtime::resolver::utils::url_from_file_path(&path).ok_or_else(|| {
+            anyhow::anyhow!("Unable to turn \"{}\" into a file:// URL", path.display())
+        })?;
+
+        let pkg = PackageInfo::from_manifest(container.manifest())?;
+        let dist = DistributionInfo {
+            webc: url,
+            webc_sha256,
+        };
+
+        Ok(PackageSummary { pkg, dist })
+    }
+}
+
+/// Information about a package's contents.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PackageInfo {
+    /// The package's full name (i.e. `wasmer/wapm2pirita`).
+    pub name: String,
+    /// The package version.
+    pub version: Version,
+    /// Commands this package exposes to the outside world.
+    pub commands: Vec<Command>,
+    /// The name of a [`Command`] that should be used as this package's
+    /// entrypoint.
+    pub entrypoint: Option<String>,
+    /// Any dependencies this package may have.
+    pub dependencies: Vec<Dependency>,
+    pub filesystem: Vec<FileSystemMapping>,
+}
+
+impl PackageInfo {
+    pub fn from_manifest(manifest: &Manifest) -> Result<Self, Error> {
+        let WapmAnnotations { name, version, .. } = manifest
+            .wapm()?
+            .context("Unable to find the \"wapm\" annotations")?;
+
+        let dependencies = manifest
+            .use_map
+            .iter()
+            .map(|(alias, value)| {
+                Ok(Dependency {
+                    alias: alias.clone(),
+                    pkg: url_or_manifest_to_specifier(value)?,
+                })
+            })
+            .collect::<Result<Vec<_>, Error>>()?;
+
+        let commands = manifest
+            .commands
+            .iter()
+            .map(|(name, _value)| crate::runtime::resolver::Command {
+                name: name.to_string(),
+            })
+            .collect();
+
+        let filesystem = filesystem_mapping_from_manifest(manifest)?;
+
+        Ok(PackageInfo {
+            name,
+            version: version.parse()?,
+            dependencies,
+            commands,
+            entrypoint: manifest.entrypoint.clone(),
+            filesystem,
+        })
+    }
+
+    pub fn id(&self) -> PackageId {
+        PackageId {
+            package_name: self.name.clone(),
+            version: self.version.clone(),
+        }
+    }
+}
+
+fn filesystem_mapping_from_manifest(
+    manifest: &Manifest,
+) -> Result<Vec<FileSystemMapping>, serde_cbor::Error> {
+    match manifest.filesystem()? {
+        Some(webc::metadata::annotations::FileSystemMappings(mappings)) => {
+            let mappings = mappings
+                .into_iter()
+                .map(|mapping| FileSystemMapping {
+                    volume_name: mapping.volume_name,
+                    mount_path: mapping.mount_path,
+                    dependency_name: mapping.from,
+                    original_path: mapping.original_path,
+                })
+                .collect();
+
+            Ok(mappings)
+        }
+        None => {
+            // A "fs" annotation hasn't been attached to this package. This was
+            // the case when *.webc files were generated by wapm2pirita version
+            // 1.0.29 and earlier.
+            //
+            // To maintain compatibility with those older packages, we'll say
+            // that the "atom" volume from the current package is mounted to "/"
+            // and contains all files in the package.
+            tracing::debug!(
+                "No \"fs\" package annotations found. Mounting the \"atom\" volume to \"/\" for compatibility."
+            );
+            Ok(vec![FileSystemMapping {
+                volume_name: "atom".to_string(),
+                mount_path: "/".to_string(),
+                original_path: "/".to_string(),
+                dependency_name: None,
+            }])
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct FileSystemMapping {
+    /// The volume to be mounted.
+    pub volume_name: String,
+    /// Where the volume should be mounted within the resulting filesystem.
+    pub mount_path: String,
+    /// The path of the mapped item within its original volume.
+    pub original_path: String,
+    /// The name of the package this volume comes from (current package if
+    /// `None`).
+    pub dependency_name: Option<String>,
+}
+
+fn url_or_manifest_to_specifier(value: &UrlOrManifest) -> Result<PackageSpecifier, Error> {
+    match value {
+        UrlOrManifest::Url(url) => Ok(PackageSpecifier::Url(url.clone())),
+        UrlOrManifest::Manifest(manifest) => {
+            if let Ok(Some(WapmAnnotations { name, version, .. })) =
+                manifest.package_annotation("wapm")
+            {
+                let version = version.parse()?;
+                return Ok(PackageSpecifier::Registry {
+                    full_name: name,
+                    version,
+                });
+            }
+
+            if let Some(origin) = manifest
+                .origin
+                .as_deref()
+                .and_then(|origin| Url::parse(origin).ok())
+            {
+                return Ok(PackageSpecifier::Url(origin));
+            }
+
+            Err(Error::msg(
+                "Unable to determine a package specifier for a vendored dependency",
+            ))
+        }
+        UrlOrManifest::RegistryDependentUrl(specifier) => specifier.parse(),
+    }
+}
+
+/// Information used when retrieving a package.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DistributionInfo {
+    /// A URL that can be used to download the `*.webc` file.
+    pub webc: Url,
+    /// A SHA-256 checksum for the `*.webc` file.
+    pub webc_sha256: WebcHash,
+}
+
+/// The SHA-256 hash of a `*.webc` file.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WebcHash([u8; 32]);
+
+impl WebcHash {
+    pub fn from_bytes(bytes: [u8; 32]) -> Self {
+        WebcHash(bytes)
+    }
+
+    /// Parse a sha256 hash from a hex-encoded string.
+    pub fn parse_hex(hex_str: &str) -> Result<Self, hex::FromHexError> {
+        let mut hash = [0_u8; 32];
+        hex::decode_to_slice(hex_str, &mut hash)?;
+        Ok(Self(hash))
+    }
+
+    pub fn for_file(path: &PathBuf) -> Result<Self, std::io::Error> {
+        // check for a hash at the file location
+        let path_hash = path.join(".sha256");
+        if let Ok(mut file) = File::open(&path_hash) {
+            let mut hash = Vec::new();
+            if let Ok(amt) = file.read_to_end(&mut hash) {
+                if amt == 32 {
+                    return Ok(WebcHash::from_bytes(hash[0..32].try_into().unwrap()));
+                }
+            }
+        }
+
+        // compute the hash
+        let mut hasher = Sha256::default();
+        let mut reader = BufReader::new(File::open(path)?);
+
+        loop {
+            let buffer = reader.fill_buf()?;
+            if buffer.is_empty() {
+                break;
+            }
+            hasher.update(buffer);
+            let bytes_read = buffer.len();
+            reader.consume(bytes_read);
+        }
+
+        let hash = hasher.finalize().into();
+
+        // write the cache of the hash to the file system
+        std::fs::write(path_hash, hash).ok();
+        let hash = WebcHash::from_bytes(hash);
+
+        Ok(hash)
+    }
+
+    /// Generate a new [`WebcHash`] based on the SHA-256 hash of some bytes.
+    pub fn sha256(webc: impl AsRef<[u8]>) -> Self {
+        let webc = webc.as_ref();
+
+        let mut hasher = Sha256::default();
+        hasher.update(webc);
+        WebcHash::from_bytes(hasher.finalize().into())
+    }
+
+    pub fn as_bytes(self) -> [u8; 32] {
+        self.0
+    }
+}
+
+impl From<[u8; 32]> for WebcHash {
+    fn from(bytes: [u8; 32]) -> Self {
+        WebcHash::from_bytes(bytes)
+    }
+}
+
+impl Display for WebcHash {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        for byte in self.0 {
+            write!(f, "{byte:02X}")?;
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Command {
+    pub name: String,
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_some_package_specifiers() {
+        let inputs = [
+            (
+                "first",
+                PackageSpecifier::Registry {
+                    full_name: "first".to_string(),
+                    version: VersionReq::STAR,
+                },
+            ),
+            (
+                "namespace/package",
+                PackageSpecifier::Registry {
+                    full_name: "namespace/package".to_string(),
+                    version: VersionReq::STAR,
+                },
+            ),
+            (
+                "namespace/package@1.0.0",
+                PackageSpecifier::Registry {
+                    full_name: "namespace/package".to_string(),
+                    version: "1.0.0".parse().unwrap(),
+                },
+            ),
+            (
+                "namespace/package@latest",
+                PackageSpecifier::Registry {
+                    full_name: "namespace/package".to_string(),
+                    version: VersionReq::STAR,
+                },
+            ),
+            (
+                "https://wapm/io/namespace/package@1.0.0",
+                PackageSpecifier::Url("https://wapm/io/namespace/package@1.0.0".parse().unwrap()),
+            ),
+            (
+                "/path/to/some/file.webc",
+                PackageSpecifier::Path("/path/to/some/file.webc".into()),
+            ),
+            ("./file.webc", PackageSpecifier::Path("./file.webc".into())),
+            #[cfg(windows)]
+            (
+                r"C:\Path\to\some\file.webc",
+                PackageSpecifier::Path(r"C:\Path\to\some\file.webc".into()),
+            ),
+        ];
+
+        for (src, expected) in inputs {
+            let parsed = PackageSpecifier::from_str(src).unwrap();
+            assert_eq!(parsed, expected);
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/mod.rs
new file mode 100644
index 0000000..2b7df92
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/mod.rs
@@ -0,0 +1,28 @@
+mod filesystem_source;
+mod in_memory_source;
+mod inputs;
+mod multi_source;
+mod outputs;
+mod resolve;
+mod source;
+pub(crate) mod utils;
+mod wapm_source;
+mod web_source;
+
+pub use self::{
+    filesystem_source::FileSystemSource,
+    in_memory_source::InMemorySource,
+    inputs::{
+        Command, Dependency, DistributionInfo, FileSystemMapping, PackageInfo, PackageSpecifier,
+        PackageSummary, WebcHash,
+    },
+    multi_source::{MultiSource, MultiSourceStrategy},
+    outputs::{
+        DependencyGraph, Edge, ItemLocation, Node, PackageId, Resolution,
+        ResolvedFileSystemMapping, ResolvedPackage,
+    },
+    resolve::{resolve, ResolveError},
+    source::{QueryError, Source},
+    wapm_source::WapmSource,
+    web_source::WebSource,
+};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/multi_source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/multi_source.rs
new file mode 100644
index 0000000..e778241
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/multi_source.rs
@@ -0,0 +1,103 @@
+use std::sync::Arc;
+
+use crate::runtime::resolver::{PackageSpecifier, PackageSummary, QueryError, Source};
+
+/// A [`Source`] that works by querying multiple [`Source`]s in succession.
+///
+/// # Error Handling
+///
+/// A [`Source`] implementation can return certain non-fatal errors and,
+/// depending on the [`MultiSourceStrategy`], the [`MultiSource`] can choose to
+/// deal with it in different ways. Sometimes
+///
+///
+/// The first [`Source`] to return one or more [`Summaries`][PackageSummary]
+/// will be treated as the canonical source for that [`Dependency`][dep] and no
+/// further [`Source`]s will be queried.
+///
+/// [dep]: crate::runtime::resolver::Dependency
+#[derive(Debug, Clone)]
+pub struct MultiSource {
+    sources: Vec<Arc<dyn Source + Send + Sync>>,
+    strategy: MultiSourceStrategy,
+}
+
+impl MultiSource {
+    pub const fn new() -> Self {
+        MultiSource {
+            sources: Vec::new(),
+            strategy: MultiSourceStrategy::default(),
+        }
+    }
+
+    pub fn add_source(&mut self, source: impl Source + Send + Sync + 'static) -> &mut Self {
+        self.add_shared_source(Arc::new(source))
+    }
+
+    pub fn add_shared_source(&mut self, source: Arc<dyn Source + Send + Sync>) -> &mut Self {
+        self.sources.push(source);
+        self
+    }
+
+    /// Override the strategy used when a [`Source`] returns a non-fatal error.
+    pub fn with_strategy(self, strategy: MultiSourceStrategy) -> Self {
+        MultiSource { strategy, ..self }
+    }
+}
+
+#[async_trait::async_trait]
+impl Source for MultiSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        for source in &self.sources {
+            match source.query(package).await {
+                Ok(summaries) => return Ok(summaries),
+                Err(QueryError::Unsupported) if self.strategy.continue_if_unsupported => continue,
+                Err(QueryError::NotFound) if self.strategy.continue_if_not_found => continue,
+                Err(QueryError::NoMatches { .. }) if self.strategy.continue_if_no_matches => {
+                    continue
+                }
+                Err(e) => return Err(e),
+            }
+        }
+
+        Err(QueryError::NotFound)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub struct MultiSourceStrategy {
+    /// If encountered, treat [`QueryError::Unsupported`] as a non-fatal error
+    /// and query the next [`Source`] in turn.
+    ///
+    /// This flag is **enabled** by default.
+    pub continue_if_unsupported: bool,
+    /// If encountered, treat [`QueryError::NotFound`] as a non-fatal error and
+    /// query the next [`Source`] in turn.
+    ///
+    /// This flag is **enabled** by default and can be used to let earlier
+    /// [`Source`]s "override" later ones.
+    pub continue_if_not_found: bool,
+    /// If encountered, treat [`QueryError::NoMatches`] as a non-fatal error and
+    /// query the next [`Source`] in turn.
+    ///
+    /// This flag is **disabled** by default.
+    pub continue_if_no_matches: bool,
+}
+
+impl MultiSourceStrategy {
+    pub const fn default() -> Self {
+        MultiSourceStrategy {
+            continue_if_unsupported: true,
+            continue_if_not_found: true,
+            continue_if_no_matches: true,
+        }
+    }
+}
+
+impl Default for MultiSourceStrategy {
+    fn default() -> Self {
+        MultiSourceStrategy::default()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/outputs.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/outputs.rs
new file mode 100644
index 0000000..028fc0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/outputs.rs
@@ -0,0 +1,222 @@
+use std::{
+    collections::BTreeMap,
+    fmt::{self, Display, Formatter},
+    ops::Index,
+    path::PathBuf,
+};
+
+use petgraph::{
+    graph::{DiGraph, NodeIndex},
+    visit::EdgeRef,
+};
+use semver::Version;
+
+use crate::runtime::resolver::{DistributionInfo, PackageInfo};
+
+#[derive(Debug, Clone)]
+pub struct Resolution {
+    pub package: ResolvedPackage,
+    pub graph: DependencyGraph,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ItemLocation {
+    /// The item's original name.
+    pub name: String,
+    /// The package this item comes from.
+    pub package: PackageId,
+}
+
+/// An identifier for a package within a dependency graph.
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PackageId {
+    pub package_name: String,
+    pub version: Version,
+}
+
+impl Display for PackageId {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let PackageId {
+            package_name,
+            version,
+        } = self;
+        write!(f, "{package_name}@{version}")
+    }
+}
+
+/// An acyclic, directed dependency graph.
+#[derive(Debug, Clone)]
+pub struct DependencyGraph {
+    root: NodeIndex,
+    graph: DiGraph<Node, Edge>,
+    packages: BTreeMap<PackageId, NodeIndex>,
+}
+
+impl DependencyGraph {
+    pub(crate) fn new(
+        root: NodeIndex,
+        graph: DiGraph<Node, Edge>,
+        packages: BTreeMap<PackageId, NodeIndex>,
+    ) -> Self {
+        if cfg!(debug_assertions) {
+            // Note: We assume the packages table correctly maps PackageIds to
+            // node indices as part of the PartialEq implementation.
+            for (id, index) in &packages {
+                let node = &graph[*index];
+                assert_eq!(*id, node.id, "Mismatch for node {index:?}");
+            }
+        }
+        debug_assert!(
+            packages.values().any(|ix| *ix == root),
+            "The packages mapping doesn't contain the root node"
+        );
+
+        DependencyGraph {
+            root,
+            graph,
+            packages,
+        }
+    }
+
+    pub fn root_info(&self) -> &PackageInfo {
+        let Node { pkg, .. } = &self.graph[self.root];
+        pkg
+    }
+
+    pub fn root(&self) -> NodeIndex {
+        self.root
+    }
+
+    pub fn graph(&self) -> &DiGraph<Node, Edge> {
+        &self.graph
+    }
+
+    /// Get a mapping from [`PackageId`]s to [`NodeIndex`]s.
+    pub fn packages(&self) -> &BTreeMap<PackageId, NodeIndex> {
+        &self.packages
+    }
+
+    /// Get an iterator over all the packages in this dependency graph and their
+    /// dependency mappings.
+    pub fn iter_dependencies(
+        &self,
+    ) -> impl Iterator<Item = (&'_ PackageId, BTreeMap<&'_ str, &'_ PackageId>)> + '_ {
+        self.packages.iter().map(move |(id, index)| {
+            let dependencies: BTreeMap<_, _> = self
+                .graph
+                .edges(*index)
+                .map(|edge_ref| {
+                    (
+                        edge_ref.weight().alias.as_str(),
+                        &self.graph[edge_ref.target()].id,
+                    )
+                })
+                .collect();
+            (id, dependencies)
+        })
+    }
+
+    /// Visualise this graph as a DOT program.
+    pub fn visualise(&self) -> String {
+        let graph = self.graph.map(|_, node| &node.id, |_, edge| &edge.alias);
+        petgraph::dot::Dot::new(&graph).to_string()
+    }
+}
+
+impl Index<NodeIndex> for DependencyGraph {
+    type Output = Node;
+
+    #[track_caller]
+    fn index(&self, index: NodeIndex) -> &Self::Output {
+        &self.graph[index]
+    }
+}
+
+impl Index<&NodeIndex> for DependencyGraph {
+    type Output = Node;
+
+    #[track_caller]
+    fn index(&self, index: &NodeIndex) -> &Self::Output {
+        &self[*index]
+    }
+}
+
+impl Index<&PackageId> for DependencyGraph {
+    type Output = Node;
+
+    #[track_caller]
+    fn index(&self, index: &PackageId) -> &Self::Output {
+        let index = self.packages[index];
+        &self[index]
+    }
+}
+
+impl PartialEq for DependencyGraph {
+    fn eq(&self, other: &Self) -> bool {
+        let DependencyGraph {
+            root,
+            graph,
+            packages,
+        } = self;
+
+        // Make sure their roots are the same package
+        let this_root = graph.node_weight(*root);
+        let other_root = other.graph.node_weight(other.root);
+
+        match (this_root, other_root) {
+            (Some(lhs), Some(rhs)) if lhs == rhs => {}
+            _ => return false,
+        }
+
+        // the packages table *should* just be an optimisation. We've checked
+        // it is valid as part of DependencyGraph::new() and the entire graph
+        // is immutable, so it's fine to ignore.
+        let _ = packages;
+
+        // Most importantly, the graphs should be "the same" (i.e. if a node
+        // in one graph is a
+        // nodes are connected to the same nodes in both)
+        petgraph::algo::is_isomorphic_matching(graph, &other.graph, Node::eq, Edge::eq)
+    }
+}
+
+impl Eq for DependencyGraph {}
+
+/// A node in the [`DependencyGraph`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Node {
+    pub id: PackageId,
+    pub pkg: PackageInfo,
+    /// Information about how the package is distributed.
+    ///
+    /// This will only ever be missing for the root package.
+    pub dist: Option<DistributionInfo>,
+}
+
+/// An edge in the [`DependencyGraph`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Edge {
+    /// The name used by the package when referring to this dependency.
+    pub alias: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedFileSystemMapping {
+    // TODO: Change this to a new type that isn't coupled to the OS
+    pub mount_path: PathBuf,
+    pub volume_name: String,
+    pub original_path: String,
+    pub package: PackageId,
+}
+
+/// A package that has been resolved, but is not yet runnable.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ResolvedPackage {
+    pub root_package: PackageId,
+    pub commands: BTreeMap<String, ItemLocation>,
+    pub entrypoint: Option<String>,
+    /// A mapping from paths to the volumes that should be mounted there.
+    /// Note: mappings at the start of the list obscure mappings at the end of the list
+    /// thus this list represents an inheritance tree
+    pub filesystem: Vec<ResolvedFileSystemMapping>,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/resolve.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/resolve.rs
new file mode 100644
index 0000000..9407cd7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/resolve.rs
@@ -0,0 +1,1213 @@
+use std::{
+    collections::{BTreeMap, HashSet, VecDeque},
+    path::PathBuf,
+};
+
+use petgraph::{
+    graph::{DiGraph, NodeIndex},
+    visit::EdgeRef,
+};
+use semver::Version;
+
+use crate::runtime::resolver::{
+    outputs::{Edge, Node},
+    DependencyGraph, ItemLocation, PackageId, PackageInfo, PackageSpecifier, PackageSummary,
+    QueryError, Resolution, ResolvedPackage, Source,
+};
+
+use super::ResolvedFileSystemMapping;
+
+/// Given the [`PackageInfo`] for a root package, resolve its dependency graph
+/// and figure out how it could be executed.
+#[tracing::instrument(level = "debug", skip_all)]
+pub async fn resolve(
+    root_id: &PackageId,
+    root: &PackageInfo,
+    source: &dyn Source,
+) -> Result<Resolution, ResolveError> {
+    let graph = resolve_dependency_graph(root_id, root, source).await?;
+    let package = resolve_package(&graph)?;
+
+    Ok(Resolution { graph, package })
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ResolveError {
+    #[error("{}", registry_error_message(.package))]
+    Registry {
+        package: PackageSpecifier,
+        #[source]
+        error: QueryError,
+    },
+    #[error("Dependency cycle detected: {}", print_cycle(_0))]
+    Cycle(Vec<PackageId>),
+    #[error(
+        "Multiple versions of {package_name} were found {}",
+        versions.iter().map(|v| v.to_string()).collect::<Vec<_>>().join(", "),
+    )]
+    DuplicateVersions {
+        package_name: String,
+        versions: Vec<Version>,
+    },
+}
+
+fn registry_error_message(specifier: &PackageSpecifier) -> String {
+    match specifier {
+        PackageSpecifier::Registry { full_name, version } if version.comparators.is_empty() => {
+            format!("Unable to find \"{full_name}\" in the registry")
+        }
+        PackageSpecifier::Registry { full_name, version } => {
+            format!("Unable to find \"{full_name}@{version}\" in the registry")
+        }
+        PackageSpecifier::Url(url) => format!("Unable to resolve \"{url}\""),
+        PackageSpecifier::Path(path) => {
+            format!("Unable to load \"{}\" from disk", path.display())
+        }
+    }
+}
+
+impl ResolveError {
+    pub fn as_cycle(&self) -> Option<&[PackageId]> {
+        match self {
+            ResolveError::Cycle(cycle) => Some(cycle),
+            _ => None,
+        }
+    }
+}
+
+fn print_cycle(packages: &[PackageId]) -> String {
+    packages
+        .iter()
+        .map(|pkg_id| {
+            let PackageId {
+                package_name,
+                version,
+                ..
+            } = pkg_id;
+            format!("{package_name}@{version}")
+        })
+        .collect::<Vec<_>>()
+        .join(" → ")
+}
+
+async fn resolve_dependency_graph(
+    root_id: &PackageId,
+    root: &PackageInfo,
+    source: &dyn Source,
+) -> Result<DependencyGraph, ResolveError> {
+    let DiscoveredPackages {
+        root,
+        graph,
+        indices,
+        packages,
+    } = discover_dependencies(root_id, root, source).await?;
+
+    check_for_duplicate_versions(indices.iter().copied().map(|ix| &graph[ix].id))?;
+    log_dependencies(&graph, root);
+
+    let graph = DependencyGraph::new(root, graph, packages);
+
+    Ok(graph)
+}
+
+async fn discover_dependencies(
+    root_id: &PackageId,
+    root: &PackageInfo,
+    source: &dyn Source,
+) -> Result<DiscoveredPackages, ResolveError> {
+    let mut nodes: BTreeMap<PackageId, NodeIndex> = BTreeMap::new();
+    let mut graph: DiGraph<Node, Edge> = DiGraph::new();
+
+    let root_index = graph.add_node(Node {
+        id: root_id.clone(),
+        pkg: root.clone(),
+        dist: None,
+    });
+    nodes.insert(root_id.clone(), root_index);
+
+    let mut to_visit = VecDeque::new();
+    to_visit.push_back(root_index);
+
+    while let Some(index) = to_visit.pop_front() {
+        let mut to_add = Vec::new();
+
+        for dep in &graph[index].pkg.dependencies {
+            // Get the latest version that satisfies our requirement. If we were
+            // doing this more rigorously, we would be narrowing the version
+            // down using existing requirements and trying to reuse the same
+            // dependency when possible.
+            let dep_summary =
+                source
+                    .latest(&dep.pkg)
+                    .await
+                    .map_err(|error| ResolveError::Registry {
+                        package: dep.pkg.clone(),
+                        error,
+                    })?;
+            let dep_id = dep_summary.package_id();
+
+            let PackageSummary { pkg, dist } = dep_summary;
+
+            let alias = dep.alias().to_string();
+            let node = Node {
+                id: dep_id,
+                pkg,
+                dist: Some(dist),
+            };
+            // Note: We can't add the node to the graph directly because we're
+            // still iterating over it.
+            to_add.push((alias, node));
+        }
+
+        for (alias, node) in to_add {
+            let dep_id = node.id.clone();
+
+            let dep_index = match nodes.get(&dep_id) {
+                Some(&ix) => ix,
+                None => {
+                    // Create a new node and schedule its dependencies to be
+                    // retrieved
+                    let ix = graph.add_node(node);
+                    nodes.insert(dep_id, ix);
+                    to_visit.push_back(ix);
+                    ix
+                }
+            };
+
+            graph.add_edge(index, dep_index, Edge { alias });
+        }
+    }
+
+    let sorted_indices = petgraph::algo::toposort(&graph, None).map_err(|_| cycle_error(&graph))?;
+
+    Ok(DiscoveredPackages {
+        root: root_index,
+        graph,
+        indices: sorted_indices,
+        packages: nodes,
+    })
+}
+
+fn cycle_error(graph: &petgraph::Graph<Node, Edge>) -> ResolveError {
+    // We know the graph has at least one cycle, so use SCC to find it.
+    let mut cycle = petgraph::algo::kosaraju_scc(graph)
+        .into_iter()
+        .find(|cycle| cycle.len() > 1)
+        .expect("We know there is at least one cycle");
+
+    // we want the loop's starting node to be deterministic (for tests), and
+    // nodes with lower indices are normally closer to the root of the
+    // dependency tree.
+    let lowest_index_node = cycle.iter().copied().min().expect("Cycle is non-empty");
+
+    // We want the cycle vector to start with that node, so let's do a bit of
+    // shuffling
+    let offset = cycle
+        .iter()
+        .position(|&node| node == lowest_index_node)
+        .unwrap();
+    cycle.rotate_left(offset);
+
+    // Don't forget to make the cycle start and end with the same node
+    cycle.push(lowest_index_node);
+
+    let package_ids = cycle.into_iter().map(|ix| graph[ix].pkg.id()).collect();
+    ResolveError::Cycle(package_ids)
+}
+
+#[derive(Debug)]
+struct DiscoveredPackages {
+    root: NodeIndex,
+    graph: DiGraph<Node, Edge>,
+    /// All node indices, in topologically sorted order.
+    indices: Vec<NodeIndex>,
+    packages: BTreeMap<PackageId, NodeIndex>,
+}
+
+#[tracing::instrument(level = "debug", name = "dependencies", skip_all)]
+fn log_dependencies(graph: &DiGraph<Node, Edge>, root: NodeIndex) {
+    tracing::debug!(
+        root = root.index(),
+        dependency_count = graph.node_count(),
+        "Resolved dependencies",
+    );
+
+    if tracing::enabled!(tracing::Level::TRACE) {
+        petgraph::visit::depth_first_search(graph, [root], |event| {
+            if let petgraph::visit::DfsEvent::Discover(n, _) = event {
+                let package = &graph[n].id;
+                let dependencies: BTreeMap<_, _> = graph
+                    .edges(n)
+                    .map(|edge_ref| (&edge_ref.weight().alias, &graph[edge_ref.target()].id))
+                    .collect();
+
+                tracing::trace!(%package, ?dependencies);
+            }
+        });
+    }
+}
+
+/// As a workaround for the lack of "proper" dependency merging, we'll make sure
+/// only one copy of each package is in the dependency tree. If the same package
+/// is included in the tree multiple times, they all need to use the exact same
+/// version otherwise it's an error.
+fn check_for_duplicate_versions<'a, I>(package_ids: I) -> Result<(), ResolveError>
+where
+    I: Iterator<Item = &'a PackageId>,
+{
+    let mut package_versions: BTreeMap<&str, HashSet<&Version>> = BTreeMap::new();
+
+    for PackageId {
+        package_name,
+        version,
+    } in package_ids
+    {
+        package_versions
+            .entry(package_name)
+            .or_default()
+            .insert(version);
+    }
+
+    for (package_name, versions) in package_versions {
+        if versions.len() > 1 {
+            let mut versions: Vec<_> = versions.into_iter().cloned().collect();
+            versions.sort();
+            return Err(ResolveError::DuplicateVersions {
+                package_name: package_name.to_string(),
+                versions,
+            });
+        }
+    }
+
+    Ok(())
+}
+
+/// Given some [`DiscoveredPackages`], figure out how the resulting "package"
+/// would look when loaded at runtime.
+fn resolve_package(dependency_graph: &DependencyGraph) -> Result<ResolvedPackage, ResolveError> {
+    // FIXME: This code is all super naive and will break the moment there
+    // are any conflicts or duplicate names.
+    tracing::trace!("Resolving the package");
+
+    let mut commands = BTreeMap::new();
+    let mut filesystem = Vec::new();
+
+    let mut entrypoint = dependency_graph.root_info().entrypoint.clone();
+
+    for index in petgraph::algo::toposort(dependency_graph.graph(), None).expect("acyclic") {
+        let node = &dependency_graph[index];
+        let id = &node.id;
+        let pkg = &node.pkg;
+
+        // update the entrypoint, if necessary
+        if entrypoint.is_none() {
+            if let Some(entry) = &pkg.entrypoint {
+                tracing::trace!(
+                    entrypoint = entry.as_str(),
+                    parent.name=id.package_name.as_str(),
+                    parent.version=%id.version,
+                    "Inheriting the entrypoint",
+                );
+
+                entrypoint = Some(entry.clone());
+            }
+        }
+
+        for cmd in &pkg.commands {
+            // Note: We are traversing in topological order with the root at the
+            // start, so if we ever see any duplicates we should prefer the
+            // earlier copy and skip the later one.
+
+            match commands.entry(cmd.name.clone()) {
+                std::collections::btree_map::Entry::Vacant(entry) => {
+                    let resolved = ItemLocation {
+                        name: cmd.name.clone(),
+                        package: id.clone(),
+                    };
+                    entry.insert(resolved);
+                    tracing::trace!(
+                        command.name=cmd.name.as_str(),
+                        pkg.name=id.package_name.as_str(),
+                        pkg.version=%id.version,
+                        "Discovered command",
+                    );
+                }
+                std::collections::btree_map::Entry::Occupied(_) => {
+                    tracing::trace!(
+                        command.name=cmd.name.as_str(),
+                        pkg.name=id.package_name.as_str(),
+                        pkg.version=%id.version,
+                        "Ignoring duplicate command",
+                    );
+                }
+            }
+        }
+
+        for mapping in &pkg.filesystem {
+            let dep = match &mapping.dependency_name {
+                Some(name) => {
+                    let dep_index = dependency_graph
+                        .graph()
+                        .edges(index)
+                        .find(|edge| edge.weight().alias == *name)
+                        .unwrap()
+                        .target();
+                    &dependency_graph[dep_index].id
+                }
+                None => id,
+            };
+            filesystem.push(ResolvedFileSystemMapping {
+                mount_path: PathBuf::from(&mapping.mount_path),
+                original_path: mapping.original_path.clone(),
+                volume_name: mapping.volume_name.clone(),
+                package: dep.clone(),
+            })
+        }
+    }
+
+    if entrypoint.is_none() {
+        // We *still* haven't been able to figure out what the entrypoint for the
+        // resolved package should be. If there is only one command in the main
+        // package, let's assume they want to use that.
+        //
+        // This works around packages like saghul/quickjs and syrusakbary/cowsay
+        // which don't specify their entrypoints explicitly.
+        if let [cmd] = dependency_graph.root_info().commands.as_slice() {
+            tracing::debug!(
+                command = cmd.name.as_str(),
+                "No entrypoint specified. Falling back to the root package's only command.",
+            );
+            entrypoint = Some(cmd.name.clone());
+        }
+    }
+
+    tracing::debug!("resolved filesystem: {:?}", &filesystem);
+
+    Ok(ResolvedPackage {
+        root_package: dependency_graph.root_info().id(),
+        commands,
+        entrypoint,
+        filesystem,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use crate::runtime::resolver::{
+        inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
+        Dependency, InMemorySource, MultiSource, PackageSpecifier,
+    };
+
+    use super::*;
+
+    struct RegistryBuilder(InMemorySource);
+
+    impl RegistryBuilder {
+        fn new() -> Self {
+            RegistryBuilder(InMemorySource::new())
+        }
+
+        fn register(&mut self, name: &str, version: &str) -> AddPackageVersion<'_> {
+            let pkg = PackageInfo {
+                name: name.to_string(),
+                version: version.parse().unwrap(),
+                dependencies: Vec::new(),
+                commands: Vec::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            };
+            let dist = DistributionInfo {
+                webc: format!("http://localhost/{name}@{version}")
+                    .parse()
+                    .unwrap(),
+                webc_sha256: [0; 32].into(),
+            };
+            let summary = PackageSummary { pkg, dist };
+
+            AddPackageVersion {
+                builder: &mut self.0,
+                summary,
+            }
+        }
+
+        fn finish(&self) -> MultiSource {
+            let mut registry = MultiSource::new();
+            registry.add_source(self.0.clone());
+            registry
+        }
+
+        fn get(&self, package: &str, version: &str) -> &PackageSummary {
+            let version = version.parse().unwrap();
+            self.0.get(package, &version).unwrap()
+        }
+
+        fn start_dependency_graph(&self) -> DependencyGraphBuilder<'_> {
+            DependencyGraphBuilder {
+                dependencies: BTreeMap::new(),
+                source: &self.0,
+            }
+        }
+    }
+
+    #[derive(Debug)]
+    struct AddPackageVersion<'builder> {
+        builder: &'builder mut InMemorySource,
+        summary: PackageSummary,
+    }
+
+    impl<'builder> AddPackageVersion<'builder> {
+        fn with_dependency(&mut self, name: &str, version_constraint: &str) -> &mut Self {
+            self.with_aliased_dependency(name, name, version_constraint)
+        }
+
+        fn with_aliased_dependency(
+            &mut self,
+            alias: &str,
+            name: &str,
+            version_constraint: &str,
+        ) -> &mut Self {
+            let pkg = PackageSpecifier::Registry {
+                full_name: name.to_string(),
+                version: version_constraint.parse().unwrap(),
+            };
+
+            self.summary.pkg.dependencies.push(Dependency {
+                alias: alias.to_string(),
+                pkg,
+            });
+
+            self
+        }
+
+        fn with_command(&mut self, name: &str) -> &mut Self {
+            self.summary
+                .pkg
+                .commands
+                .push(crate::runtime::resolver::Command {
+                    name: name.to_string(),
+                });
+            self
+        }
+
+        fn with_entrypoint(&mut self, name: &str) -> &mut Self {
+            self.summary.pkg.entrypoint = Some(name.to_string());
+            self
+        }
+
+        fn with_fs_mapping(
+            &mut self,
+            volume_name: &str,
+            original_path: &str,
+            mount_path: &str,
+        ) -> &mut Self {
+            self.summary.pkg.filesystem.push(FileSystemMapping {
+                volume_name: volume_name.to_string(),
+                mount_path: mount_path.to_string(),
+                original_path: original_path.to_string(),
+                dependency_name: None,
+            });
+            self
+        }
+
+        fn with_fs_mapping_from_dependency(
+            &mut self,
+            volume_name: &str,
+            mount_path: &str,
+            original_path: &str,
+            dependency: &str,
+        ) -> &mut Self {
+            self.summary.pkg.filesystem.push(FileSystemMapping {
+                volume_name: volume_name.to_string(),
+                mount_path: mount_path.to_string(),
+                original_path: original_path.to_string(),
+                dependency_name: Some(dependency.to_string()),
+            });
+            self
+        }
+    }
+
+    impl<'builder> Drop for AddPackageVersion<'builder> {
+        fn drop(&mut self) {
+            let summary = self.summary.clone();
+            self.builder.add(summary);
+        }
+    }
+
+    #[derive(Debug)]
+    struct DependencyGraphBuilder<'source> {
+        dependencies: BTreeMap<PackageId, BTreeMap<String, PackageId>>,
+        source: &'source InMemorySource,
+    }
+
+    impl<'source> DependencyGraphBuilder<'source> {
+        fn insert(
+            &mut self,
+            package: &str,
+            version: &str,
+        ) -> DependencyGraphEntryBuilder<'source, '_> {
+            let version = version.parse().unwrap();
+            let pkg_id = self.source.get(package, &version).unwrap().package_id();
+            DependencyGraphEntryBuilder {
+                builder: self,
+                pkg_id,
+                dependencies: BTreeMap::new(),
+            }
+        }
+
+        fn finish(self) -> BTreeMap<PackageId, BTreeMap<String, PackageId>> {
+            self.dependencies
+        }
+
+        /// Using the dependency mapping that we've been building up, construct
+        /// a dependency graph using the specified root package.
+        fn graph(self, root_name: &str, version: &str) -> DependencyGraph {
+            let version = version.parse().unwrap();
+            let root_id = self.source.get(root_name, &version).unwrap().package_id();
+
+            let mut graph = DiGraph::new();
+            let mut nodes = BTreeMap::new();
+
+            for id in self.dependencies.keys() {
+                let PackageSummary { pkg, dist } =
+                    self.source.get(&id.package_name, &id.version).unwrap();
+                let index = graph.add_node(Node {
+                    id: pkg.id(),
+                    pkg: pkg.clone(),
+                    dist: Some(dist.clone()),
+                });
+                nodes.insert(id.clone(), index);
+            }
+
+            for (id, deps) in &self.dependencies {
+                let index = nodes[id];
+                for (dep_name, dep_id) in deps {
+                    let dep_index = nodes[dep_id];
+                    graph.add_edge(
+                        index,
+                        dep_index,
+                        Edge {
+                            alias: dep_name.clone(),
+                        },
+                    );
+                }
+            }
+
+            let root_index = nodes[&root_id];
+
+            DependencyGraph::new(root_index, graph, nodes)
+        }
+    }
+
+    #[derive(Debug)]
+    struct DependencyGraphEntryBuilder<'source, 'builder> {
+        builder: &'builder mut DependencyGraphBuilder<'source>,
+        pkg_id: PackageId,
+        dependencies: BTreeMap<String, PackageId>,
+    }
+
+    impl<'source, 'builder> DependencyGraphEntryBuilder<'source, 'builder> {
+        fn with_dependency(&mut self, name: &str, version: &str) -> &mut Self {
+            self.with_aliased_dependency(name, name, version)
+        }
+
+        fn with_aliased_dependency(&mut self, alias: &str, name: &str, version: &str) -> &mut Self {
+            let version = version.parse().unwrap();
+            let dep_id = self
+                .builder
+                .source
+                .get(name, &version)
+                .unwrap()
+                .package_id();
+            self.dependencies.insert(alias.to_string(), dep_id);
+            self
+        }
+    }
+
+    impl<'source, 'builder> Drop for DependencyGraphEntryBuilder<'source, 'builder> {
+        fn drop(&mut self) {
+            self.builder
+                .dependencies
+                .insert(self.pkg_id.clone(), self.dependencies.clone());
+        }
+    }
+
+    macro_rules! map {
+        (
+            $(
+                $key:expr => $value:expr
+            ),*
+            $(,)?
+        ) => {
+            vec![
+                $( ($key.into(), $value.into()) ),*
+            ]
+            .into_iter()
+            .collect()
+        }
+    }
+
+    fn deps(resolution: &Resolution) -> BTreeMap<PackageId, BTreeMap<String, PackageId>> {
+        resolution
+            .graph
+            .iter_dependencies()
+            .map(|(id, deps)| {
+                let deps = deps
+                    .into_iter()
+                    .map(|(name, dep_id)| (name.to_string(), dep_id.clone()))
+                    .collect();
+                (id.clone(), deps)
+            })
+            .collect()
+    }
+
+    #[tokio::test]
+    async fn no_deps_and_no_commands() {
+        let mut builder = RegistryBuilder::new();
+        builder.register("root", "1.0.0");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph.insert("root", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: BTreeMap::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn no_deps_one_command() {
+        let mut builder = RegistryBuilder::new();
+        builder.register("root", "1.0.0").with_command("asdf");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph.insert("root", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: map! {
+                    "asdf" => ItemLocation {
+                        name: "asdf".to_string(),
+                        package: root.package_id(),
+                    },
+                },
+                entrypoint: Some("asdf".to_string()),
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn single_dependency() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "=1.0.0");
+        builder.register("dep", "1.0.0");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("root", "1.0.0")
+            .with_dependency("dep", "1.0.0");
+        dependency_graph.insert("dep", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: BTreeMap::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn linear_dependency_chain() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("first", "1.0.0")
+            .with_dependency("second", "=1.0.0");
+        builder
+            .register("second", "1.0.0")
+            .with_dependency("third", "=1.0.0");
+        builder.register("third", "1.0.0");
+        let registry = builder.finish();
+        let root = builder.get("first", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("first", "1.0.0")
+            .with_dependency("second", "1.0.0");
+        dependency_graph
+            .insert("second", "1.0.0")
+            .with_dependency("third", "1.0.0");
+        dependency_graph.insert("third", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: BTreeMap::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn pick_the_latest_dependency_when_multiple_are_possible() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "^1.0.0");
+        builder.register("dep", "1.0.0");
+        builder.register("dep", "1.0.1");
+        builder.register("dep", "1.0.2");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("root", "1.0.0")
+            .with_dependency("dep", "1.0.2");
+        dependency_graph.insert("dep", "1.0.2");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: BTreeMap::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn version_merging_isnt_implemented_yet() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("first", "=1.0.0")
+            .with_dependency("second", "=1.0.0");
+        builder
+            .register("first", "1.0.0")
+            .with_dependency("common", "^1.0.0");
+        builder
+            .register("second", "1.0.0")
+            .with_dependency("common", ">1.1,<1.3");
+        builder.register("common", "1.0.0");
+        builder.register("common", "1.1.0");
+        builder.register("common", "1.2.0");
+        builder.register("common", "1.5.0");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let result = resolve(&root.package_id(), &root.pkg, &registry).await;
+
+        match result {
+            Err(ResolveError::DuplicateVersions {
+                package_name,
+                versions,
+            }) => {
+                assert_eq!(package_name, "common");
+                assert_eq!(
+                    versions,
+                    [
+                        Version::parse("1.2.0").unwrap(),
+                        Version::parse("1.5.0").unwrap(),
+                    ]
+                );
+            }
+            _ => unreachable!("Expected a duplicate versions error, found {:?}", result),
+        }
+    }
+
+    #[tokio::test]
+    #[ignore = "Version merging isn't implemented"]
+    async fn merge_compatible_versions() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("first", "=1.0.0")
+            .with_dependency("second", "=1.0.0");
+        builder
+            .register("first", "1.0.0")
+            .with_dependency("common", "^1.0.0");
+        builder
+            .register("second", "1.0.0")
+            .with_dependency("common", ">1.1,<1.3");
+        builder.register("common", "1.0.0");
+        builder.register("common", "1.1.0");
+        builder.register("common", "1.2.0");
+        builder.register("common", "1.5.0");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("root", "1.0.0")
+            .with_dependency("first", "1.0.0")
+            .with_dependency("second", "1.0.0");
+        dependency_graph
+            .insert("first", "1.0.0")
+            .with_dependency("common", "1.2.0");
+        dependency_graph
+            .insert("second", "1.0.0")
+            .with_dependency("common", "1.2.0");
+        dependency_graph.insert("common", "1.2.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: BTreeMap::new(),
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn commands_from_dependencies_end_up_in_the_package() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("first", "=1.0.0")
+            .with_dependency("second", "=1.0.0");
+        builder
+            .register("first", "1.0.0")
+            .with_command("first-command");
+        builder
+            .register("second", "1.0.0")
+            .with_command("second-command");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("root", "1.0.0")
+            .with_dependency("first", "1.0.0")
+            .with_dependency("second", "1.0.0");
+        dependency_graph.insert("first", "1.0.0");
+        dependency_graph.insert("second", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: map! {
+                    "first-command" => ItemLocation {
+                        name: "first-command".to_string(),
+                        package: builder.get("first", "1.0.0").package_id(),
+                     },
+                    "second-command" => ItemLocation {
+                        name: "second-command".to_string(),
+                        package: builder.get("second", "1.0.0").package_id(),
+                     },
+                },
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "TODO: Re-order the way commands are resolved"]
+    async fn commands_in_root_shadow_their_dependencies() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "=1.0.0")
+            .with_command("command");
+        builder.register("dep", "1.0.0").with_command("command");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        let mut dependency_graph = builder.start_dependency_graph();
+        dependency_graph
+            .insert("root", "1.0.0")
+            .with_dependency("dep", "1.0.0");
+        dependency_graph.insert("dep", "1.0.0");
+        assert_eq!(deps(&resolution), dependency_graph.finish());
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: map! {
+                    "command" => ItemLocation {
+                        name: "command".to_string(),
+                        package: builder.get("root", "1.0.0").package_id(),
+                     },
+                },
+                entrypoint: None,
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn cyclic_dependencies() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "=1.0.0");
+        builder
+            .register("dep", "1.0.0")
+            .with_dependency("root", "=1.0.0");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let err = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap_err();
+
+        let cycle = err.as_cycle().unwrap().to_vec();
+        assert_eq!(
+            cycle,
+            [
+                builder.get("root", "1.0.0").package_id(),
+                builder.get("dep", "1.0.0").package_id(),
+                builder.get("root", "1.0.0").package_id(),
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn entrypoint_is_inherited() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "=1.0.0");
+        builder
+            .register("dep", "1.0.0")
+            .with_command("entry")
+            .with_entrypoint("entry");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            resolution.package,
+            ResolvedPackage {
+                root_package: root.package_id(),
+                commands: map! {
+                    "entry" => ItemLocation {
+                        name: "entry".to_string(),
+                        package: builder.get("dep", "1.0.0").package_id(),
+                     },
+                },
+                entrypoint: Some("entry".to_string()),
+                filesystem: Vec::new(),
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn infer_entrypoint_if_unspecified_and_only_one_command_in_root_package() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_command("root-cmd")
+            .with_dependency("dep", "=1.0.0");
+        builder.register("dep", "1.0.0").with_command("entry");
+        let registry = builder.finish();
+        let root = builder.get("root", "1.0.0");
+
+        let resolution = resolve(&root.package_id(), &root.pkg, &registry)
+            .await
+            .unwrap();
+
+        assert_eq!(resolution.package.entrypoint.as_deref(), Some("root-cmd"));
+    }
+
+    #[test]
+    fn cyclic_error_message() {
+        let cycle = [
+            PackageId {
+                package_name: "root".to_string(),
+                version: "1.0.0".parse().unwrap(),
+            },
+            PackageId {
+                package_name: "dep".to_string(),
+                version: "1.0.0".parse().unwrap(),
+            },
+            PackageId {
+                package_name: "root".to_string(),
+                version: "1.0.0".parse().unwrap(),
+            },
+        ];
+
+        let message = print_cycle(&cycle);
+
+        assert_eq!(message, "root@1.0.0 → dep@1.0.0 → root@1.0.0");
+    }
+
+    #[test]
+    fn filesystem_with_one_package_and_no_fs_tables() {
+        let mut builder = RegistryBuilder::new();
+        builder.register("root", "1.0.0");
+        let mut dep_builder = builder.start_dependency_graph();
+        dep_builder.insert("root", "1.0.0");
+        let graph = dep_builder.graph("root", "1.0.0");
+
+        let pkg = resolve_package(&graph).unwrap();
+
+        assert!(pkg.filesystem.is_empty());
+    }
+
+    #[test]
+    fn filesystem_with_one_package_and_one_fs_tables() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_fs_mapping("atom", "/publisher/lib", "/lib");
+        let mut dep_builder = builder.start_dependency_graph();
+        dep_builder.insert("root", "1.0.0");
+        let graph = dep_builder.graph("root", "1.0.0");
+
+        let pkg = resolve_package(&graph).unwrap();
+
+        assert_eq!(
+            pkg.filesystem,
+            vec![ResolvedFileSystemMapping {
+                mount_path: PathBuf::from("/lib"),
+                original_path: "/publisher/lib".to_string(),
+                volume_name: "atom".to_string(),
+                package: builder.get("root", "1.0.0").package_id(),
+            }]
+        );
+    }
+
+    #[test]
+    fn merge_fs_mappings_from_multiple_packages() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("first", "=1.0.0")
+            .with_dependency("second", "=1.0.0")
+            .with_fs_mapping("atom", "/root", "/root");
+        builder.register("first", "1.0.0").with_fs_mapping(
+            "atom",
+            "/usr/local/lib/first",
+            "/usr/local/lib/first",
+        );
+        builder.register("second", "1.0.0").with_fs_mapping(
+            "atom",
+            "/usr/local/lib/second",
+            "/usr/local/lib/second",
+        );
+        let mut dep_builder = builder.start_dependency_graph();
+        dep_builder
+            .insert("root", "1.0.0")
+            .with_dependency("first", "1.0.0")
+            .with_dependency("second", "1.0.0");
+        dep_builder.insert("first", "1.0.0");
+        dep_builder.insert("second", "1.0.0");
+        let graph = dep_builder.graph("root", "1.0.0");
+
+        let pkg = resolve_package(&graph).unwrap();
+
+        assert_eq!(
+            pkg.filesystem,
+            vec![
+                ResolvedFileSystemMapping {
+                    mount_path: PathBuf::from("/root"),
+                    original_path: "/root".to_string(),
+                    volume_name: "atom".to_string(),
+                    package: builder.get("root", "1.0.0").package_id(),
+                },
+                ResolvedFileSystemMapping {
+                    mount_path: PathBuf::from("/usr/local/lib/second"),
+                    original_path: "/usr/local/lib/second".to_string(),
+                    volume_name: "atom".to_string(),
+                    package: builder.get("second", "1.0.0").package_id(),
+                },
+                ResolvedFileSystemMapping {
+                    mount_path: PathBuf::from("/usr/local/lib/first"),
+                    volume_name: "atom".to_string(),
+                    original_path: "/usr/local/lib/first".to_string(),
+                    package: builder.get("first", "1.0.0").package_id(),
+                }
+            ]
+        );
+    }
+
+    #[test]
+    fn use_fs_mapping_from_dependency() {
+        let mut builder = RegistryBuilder::new();
+        builder
+            .register("root", "1.0.0")
+            .with_dependency("dep", "=1.0.0")
+            .with_fs_mapping_from_dependency("dep-volume", "/root", "/root", "dep");
+        builder.register("dep", "1.0.0");
+        let mut dep_builder = builder.start_dependency_graph();
+        dep_builder
+            .insert("root", "1.0.0")
+            .with_dependency("dep", "1.0.0");
+        dep_builder.insert("dep", "1.0.0");
+        let graph = dep_builder.graph("root", "1.0.0");
+
+        let pkg = resolve_package(&graph).unwrap();
+
+        assert_eq!(
+            pkg.filesystem,
+            vec![ResolvedFileSystemMapping {
+                mount_path: PathBuf::from("/root"),
+                original_path: "/root".to_string(),
+                volume_name: "dep-volume".to_string(),
+                package: builder.get("dep", "1.0.0").package_id(),
+            }]
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/source.rs
new file mode 100644
index 0000000..75d36d8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/source.rs
@@ -0,0 +1,95 @@
+use std::fmt::{Debug, Display};
+
+use crate::runtime::resolver::{PackageSpecifier, PackageSummary};
+
+/// Something that packages can be downloaded from.
+#[async_trait::async_trait]
+pub trait Source: Sync + Debug {
+    /// Ask this source which packages would satisfy a particular
+    /// [`Dependency`][dep] constraint.
+    ///
+    /// # Assumptions
+    ///
+    /// If this method returns a successful result, it is guaranteed that there
+    /// will be at least one [`PackageSummary`], otherwise implementations
+    /// should return [`QueryError::NotFound`] or [`QueryError::NoMatches`].
+    ///
+    /// [dep]: crate::runtime::resolver::Dependency
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError>;
+
+    /// Run [`Source::query()`] and get the [`PackageSummary`] for the latest
+    /// version.
+    async fn latest(&self, pkg: &PackageSpecifier) -> Result<PackageSummary, QueryError> {
+        let candidates = self.query(pkg).await?;
+        candidates
+            .into_iter()
+            .max_by(|left, right| left.pkg.version.cmp(&right.pkg.version))
+            .ok_or(QueryError::NoMatches {
+                archived_versions: Vec::new(),
+            })
+    }
+}
+
+#[async_trait::async_trait]
+impl<D, S> Source for D
+where
+    D: std::ops::Deref<Target = S> + Debug + Send + Sync,
+    S: Source + ?Sized + Send + Sync + 'static,
+{
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        (**self).query(package).await
+    }
+}
+
+#[derive(Debug)]
+pub enum QueryError {
+    Unsupported,
+    NotFound,
+    NoMatches {
+        archived_versions: Vec<semver::Version>,
+    },
+    Timeout,
+    Other(anyhow::Error),
+}
+
+impl From<anyhow::Error> for QueryError {
+    fn from(value: anyhow::Error) -> Self {
+        Self::Other(value)
+    }
+}
+
+impl Display for QueryError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Unsupported => f.write_str("This type of package specifier isn't supported"),
+            Self::NotFound => f.write_str("Not found"),
+            Self::Timeout => f.write_str("Timed out"),
+            Self::NoMatches { archived_versions } => match archived_versions.as_slice() {
+                [] => f.write_str(
+                    "The package was found, but no published versions matched the constraint",
+                ),
+                [version] => write!(
+                    f,
+                    "The only version satisfying the constraint, {version}, is archived"
+                ),
+                [first, rest @ ..] => {
+                    let num_others = rest.len();
+                    write!(
+                        f,
+                        "Unable to satisfy the request. Version {first}, and {num_others} are all archived"
+                    )
+                }
+            },
+            Self::Other(e) => Display::fmt(e, f),
+        }
+    }
+}
+
+impl std::error::Error for QueryError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Other(e) => Some(&**e),
+            Self::Unsupported | Self::NotFound | Self::NoMatches { .. } | Self::Timeout => None,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/utils.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/utils.rs
new file mode 100644
index 0000000..11f8350
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/utils.rs
@@ -0,0 +1,123 @@
+use std::path::{Path, PathBuf};
+
+use anyhow::Error;
+use http::{HeaderMap, StatusCode};
+use url::Url;
+
+use crate::http::{HttpResponse, USER_AGENT};
+
+/// Polyfill for [`Url::from_file_path()`] that works on `wasm32-unknown-unknown`.
+pub(crate) fn url_from_file_path(path: impl AsRef<Path>) -> Option<Url> {
+    let path = path.as_ref();
+
+    if !path.is_absolute() {
+        return None;
+    }
+
+    let mut buffer = String::new();
+
+    for component in path {
+        if !buffer.ends_with('/') {
+            buffer.push('/');
+        }
+
+        buffer.push_str(component.to_str()?);
+    }
+
+    buffer.insert_str(0, "file://");
+
+    buffer.parse().ok()
+}
+
+pub(crate) fn webc_headers() -> HeaderMap {
+    let mut headers = HeaderMap::new();
+    headers.insert("Accept", "application/webc".parse().unwrap());
+    headers.insert("User-Agent", USER_AGENT.parse().unwrap());
+    headers
+}
+
+pub(crate) fn http_error(response: &HttpResponse) -> Error {
+    let status = response.status;
+
+    if status == StatusCode::SERVICE_UNAVAILABLE {
+        if let Some(retry_after) = response
+            .headers
+            .get("Retry-After")
+            .and_then(|retry_after| retry_after.to_str().ok())
+        {
+            tracing::debug!(
+                %retry_after,
+                "Received 503 Service Unavailable while looking up a package. The backend may still be generating the *.webc file.",
+            );
+            return anyhow::anyhow!("{status} (Retry After: {retry_after})");
+        }
+    }
+
+    Error::msg(status)
+}
+
+pub(crate) fn file_path_from_url(url: &Url) -> Result<PathBuf, Error> {
+    debug_assert_eq!(url.scheme(), "file");
+
+    // Note: The Url::to_file_path() method is platform-specific
+    cfg_if::cfg_if! {
+        if #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))] {
+            use anyhow::Context;
+
+            if let Ok(path) = url.to_file_path() {
+                return Ok(path);
+            }
+
+            // Sometimes we'll get a UNC-like path (e.g.
+            // "file:///?\\C:/\\/path/to/file.txt") and Url::to_file_path()
+            // won't be able to handle the "\\?" so we try to "massage" the URL
+            // a bit.
+            // See <https://github.com/servo/rust-url/issues/450> for more.
+            let modified = url.as_str().replace(r"\\?", "").replace("//?", "").replace('\\', "/");
+            Url::parse(&modified)
+                .ok()
+                .and_then(|url| url.to_file_path().ok())
+                .context("Unable to extract the file path")
+        } else {
+            anyhow::bail!("Url::to_file_path() is not supported on this platform");
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[allow(unused_imports)]
+    use super::*;
+
+    #[test]
+    #[cfg(unix)]
+    fn from_file_path_behaviour_is_identical() {
+        let inputs = [
+            "/",
+            "/path",
+            "/path/to/file.txt",
+            "./path/to/file.txt",
+            ".",
+            "",
+        ];
+
+        for path in inputs {
+            let got = url_from_file_path(path);
+            let expected = Url::from_file_path(path).ok();
+            assert_eq!(got, expected, "Mismatch for \"{path}\"");
+        }
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn to_file_path_can_handle_unc_paths() {
+        let path = Path::new(env!("CARGO_MANIFEST_DIR"))
+            .canonicalize()
+            .unwrap();
+        let url = Url::from_file_path(&path).unwrap();
+
+        let got = file_path_from_url(&url).unwrap();
+
+        assert_eq!(got.canonicalize().unwrap(), path);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/wapm_source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/wapm_source.rs
new file mode 100644
index 0000000..4d81c90
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/wapm_source.rs
@@ -0,0 +1,811 @@
+use std::{
+    path::PathBuf,
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+
+use anyhow::{Context, Error};
+use http::{HeaderMap, Method};
+use semver::{Version, VersionReq};
+use url::Url;
+use webc::metadata::Manifest;
+
+use crate::{
+    http::{HttpClient, HttpRequest, USER_AGENT},
+    runtime::resolver::{
+        DistributionInfo, PackageInfo, PackageSpecifier, PackageSummary, QueryError, Source,
+        WebcHash,
+    },
+};
+
+/// A [`Source`] which will resolve dependencies by pinging a Wasmer-like GraphQL
+/// endpoint.
+#[derive(Debug, Clone)]
+pub struct WapmSource {
+    registry_endpoint: Url,
+    client: Arc<dyn HttpClient + Send + Sync>,
+    cache: Option<FileSystemCache>,
+    token: Option<String>,
+}
+
+impl WapmSource {
+    pub const WASMER_DEV_ENDPOINT: &'static str = "https://registry.wasmer.wtf/graphql";
+    pub const WASMER_PROD_ENDPOINT: &'static str = "https://registry.wasmer.io/graphql";
+
+    pub fn new(registry_endpoint: Url, client: Arc<dyn HttpClient + Send + Sync>) -> Self {
+        WapmSource {
+            registry_endpoint,
+            client,
+            cache: None,
+            token: None,
+        }
+    }
+
+    /// Cache query results locally.
+    pub fn with_local_cache(self, cache_dir: impl Into<PathBuf>, timeout: Duration) -> Self {
+        WapmSource {
+            cache: Some(FileSystemCache::new(cache_dir, timeout)),
+            ..self
+        }
+    }
+
+    pub fn with_auth_token(self, token: impl Into<String>) -> Self {
+        WapmSource {
+            token: Some(token.into()),
+            ..self
+        }
+    }
+
+    pub fn registry_endpoint(&self) -> &Url {
+        &self.registry_endpoint
+    }
+
+    #[tracing::instrument(level = "debug", skip_all)]
+    async fn query_graphql(&self, package_name: &str) -> Result<WapmWebQuery, Error> {
+        #[derive(serde::Serialize)]
+        struct Body {
+            query: String,
+        }
+
+        let body = Body {
+            query: WASMER_WEBC_QUERY_ALL.replace("$NAME", package_name),
+        };
+
+        let request = HttpRequest {
+            url: self.registry_endpoint.clone(),
+            method: Method::POST,
+            body: Some(serde_json::to_string(&body)?.into_bytes()),
+            headers: self.headers(),
+            options: Default::default(),
+        };
+
+        tracing::debug!(%request.url, %request.method, "Querying the GraphQL API");
+        tracing::trace!(?request.headers, request.body=body.query.as_str());
+
+        let response = self.client.request(request).await?;
+
+        if !response.is_ok() {
+            let url = &self.registry_endpoint;
+            let status = response.status;
+
+            let body = if let Some(body) = &response.body {
+                String::from_utf8_lossy(body).into_owned()
+            } else {
+                "<no body>".to_string()
+            };
+
+            tracing::warn!(
+                %url,
+                %status,
+                package=%package_name,
+                %body,
+                "failed to query package info from registry"
+            );
+
+            anyhow::bail!("\"{url}\" replied with {status}");
+        }
+
+        let body = response.body.unwrap_or_default();
+        tracing::trace!(
+            %response.status,
+            %response.redirected,
+            ?response.headers,
+            "Received a response from GraphQL",
+        );
+
+        let response: WapmWebQuery =
+            serde_json::from_slice(&body).context("Unable to deserialize the response")?;
+
+        Ok(response)
+    }
+
+    fn headers(&self) -> HeaderMap {
+        let mut headers = HeaderMap::new();
+        headers.insert("Content-Type", "application/json".parse().unwrap());
+        headers.insert("User-Agent", USER_AGENT.parse().unwrap());
+
+        if let Some(token) = self.token.as_deref() {
+            let raw_header = format!("Bearer {token}");
+
+            match http::HeaderValue::from_str(&raw_header) {
+                Ok(header) => {
+                    headers.insert(http::header::AUTHORIZATION, header);
+                }
+                Err(e) => {
+                    tracing::warn!(
+                        error = &e as &dyn std::error::Error,
+                        "Unable to parse the token into a header",
+                    );
+                }
+            }
+        }
+
+        headers
+    }
+}
+
+#[async_trait::async_trait]
+impl Source for WapmSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        let (package_name, version_constraint) = match package {
+            PackageSpecifier::Registry { full_name, version } => (full_name, version),
+            _ => return Err(QueryError::Unsupported),
+        };
+
+        if let Some(cache) = &self.cache {
+            match cache.lookup_cached_query(package_name) {
+                Ok(Some(cached)) => {
+                    if let Ok(cached) = matching_package_summaries(cached, version_constraint) {
+                        tracing::debug!("Cache hit!");
+                        return Ok(cached);
+                    }
+                }
+                Ok(None) => {}
+                Err(e) => {
+                    tracing::warn!(
+                        package_name,
+                        error = &*e,
+                        "An unexpected error occurred while checking the local query cache",
+                    );
+                }
+            }
+        }
+
+        let response = self.query_graphql(package_name).await?;
+
+        if let Some(cache) = &self.cache {
+            if let Err(e) = cache.update(package_name, &response) {
+                tracing::warn!(
+                    package_name,
+                    error = &*e,
+                    "An error occurred while caching the GraphQL response",
+                );
+            }
+        }
+
+        matching_package_summaries(response, version_constraint)
+    }
+}
+
+fn matching_package_summaries(
+    response: WapmWebQuery,
+    version_constraint: &VersionReq,
+) -> Result<Vec<PackageSummary>, QueryError> {
+    let mut summaries = Vec::new();
+
+    let WapmWebQueryGetPackage { versions, .. } =
+        response.data.get_package.ok_or(QueryError::NotFound)?;
+    let mut archived_versions = Vec::new();
+
+    for pkg_version in versions {
+        let version = match Version::parse(&pkg_version.version) {
+            Ok(v) => v,
+            Err(e) => {
+                tracing::debug!(
+                    pkg.version = pkg_version.version.as_str(),
+                    error = &e as &dyn std::error::Error,
+                    "Skipping a version because it doesn't have a valid version numer",
+                );
+                continue;
+            }
+        };
+
+        if pkg_version.is_archived {
+            tracing::debug!(
+                pkg.version=%version,
+                "Skipping an archived version",
+            );
+            archived_versions.push(version);
+            continue;
+        }
+
+        if version_constraint.matches(&version) {
+            match decode_summary(pkg_version) {
+                Ok(summary) => summaries.push(summary),
+                Err(e) => {
+                    tracing::debug!(
+                        version=%version,
+                        error=&*e,
+                        "Skipping version because its metadata couldn't be parsed"
+                    );
+                }
+            }
+        }
+    }
+
+    if summaries.is_empty() {
+        Err(QueryError::NoMatches { archived_versions })
+    } else {
+        Ok(summaries)
+    }
+}
+
+fn decode_summary(pkg_version: WapmWebQueryGetPackageVersion) -> Result<PackageSummary, Error> {
+    let WapmWebQueryGetPackageVersion {
+        manifest,
+        distribution:
+            WapmWebQueryGetPackageVersionDistribution {
+                pirita_sha256_hash,
+                pirita_download_url,
+            },
+        ..
+    } = pkg_version;
+
+    let manifest = manifest.context("missing Manifest")?;
+    let hash = pirita_sha256_hash.context("missing sha256")?;
+    let webc = pirita_download_url.context("missing download URL")?;
+
+    let manifest: Manifest = serde_json::from_slice(manifest.as_bytes())
+        .context("Unable to deserialize the manifest")?;
+
+    let webc_sha256 = WebcHash::parse_hex(&hash).context("invalid webc sha256 hash in manifest")?;
+
+    Ok(PackageSummary {
+        pkg: PackageInfo::from_manifest(&manifest)?,
+        dist: DistributionInfo { webc, webc_sha256 },
+    })
+}
+
+/// A local cache for package queries.
+#[derive(Debug, Clone)]
+struct FileSystemCache {
+    cache_dir: PathBuf,
+    timeout: Duration,
+}
+
+impl FileSystemCache {
+    fn new(cache_dir: impl Into<PathBuf>, timeout: Duration) -> Self {
+        FileSystemCache {
+            cache_dir: cache_dir.into(),
+            timeout,
+        }
+    }
+
+    fn path(&self, package_name: &str) -> PathBuf {
+        self.cache_dir.join(package_name)
+    }
+
+    fn lookup_cached_query(&self, package_name: &str) -> Result<Option<WapmWebQuery>, Error> {
+        let filename = self.path(package_name);
+
+        let _span =
+            tracing::debug_span!("lookup_cached_query", filename=%filename.display()).entered();
+
+        tracing::trace!("Reading cached entry from disk");
+        let json = match std::fs::read(&filename) {
+            Ok(json) => json,
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
+                tracing::debug!("Cache miss");
+                return Ok(None);
+            }
+            Err(e) => {
+                return Err(
+                    Error::new(e).context(format!("Unable to read \"{}\"", filename.display()))
+                );
+            }
+        };
+
+        let entry: CacheEntry = match serde_json::from_slice(&json) {
+            Ok(entry) => entry,
+            Err(e) => {
+                // If the entry is invalid, we should delete it to avoid work
+                // in the future
+                let _ = std::fs::remove_file(&filename);
+
+                return Err(Error::new(e).context("Unable to parse the cached query"));
+            }
+        };
+
+        if !entry.is_still_valid(self.timeout) {
+            tracing::debug!(timestamp = entry.unix_timestamp, "Cached entry is stale");
+            let _ = std::fs::remove_file(&filename);
+            return Ok(None);
+        }
+
+        if entry.package_name != package_name {
+            let _ = std::fs::remove_file(&filename);
+            anyhow::bail!(
+                "The cached response at \"{}\" corresponds to the \"{}\" package, but expected \"{}\"",
+                filename.display(),
+                entry.package_name,
+                package_name,
+            );
+        }
+
+        Ok(Some(entry.response))
+    }
+
+    fn update(&self, package_name: &str, response: &WapmWebQuery) -> Result<(), Error> {
+        let entry = CacheEntry {
+            unix_timestamp: SystemTime::UNIX_EPOCH
+                .elapsed()
+                .unwrap_or_default()
+                .as_secs(),
+            package_name: package_name.to_string(),
+            response: response.clone(),
+        };
+
+        let _ = std::fs::create_dir_all(&self.cache_dir);
+
+        // First, save our cache entry to disk
+        let mut temp = tempfile::NamedTempFile::new_in(&self.cache_dir)
+            .context("Unable to create a temporary file")?;
+        serde_json::to_writer_pretty(&mut temp, &entry)
+            .context("Unable to serialize the cache entry")?;
+        temp.as_file()
+            .sync_all()
+            .context("Flushing the temp file failed")?;
+
+        // Now we've saved our cache entry we need to move it to the right
+        // location. We do this in two steps so concurrent queries don't see
+        // the cache entry until it has been completely written.
+        let filename = self.path(package_name);
+        tracing::debug!(
+            filename=%filename.display(),
+            package_name,
+            "Saving the query to disk",
+        );
+
+        if let Some(parent) = filename.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        temp.persist(&filename).with_context(|| {
+            format!(
+                "Unable to persist the temp file to \"{}\"",
+                filename.display()
+            )
+        })?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+struct CacheEntry {
+    unix_timestamp: u64,
+    package_name: String,
+    response: WapmWebQuery,
+}
+
+impl CacheEntry {
+    fn is_still_valid(&self, timeout: Duration) -> bool {
+        let timestamp = SystemTime::UNIX_EPOCH + Duration::from_secs(self.unix_timestamp);
+
+        match timestamp.elapsed() {
+            Ok(duration) if duration <= timeout => true,
+            Ok(_) => {
+                // The cached response is too old
+                false
+            }
+            Err(_) => {
+                // It looks like the current time is **after** the time this
+                // entry was recorded. That probably indicates a clock issue
+                // so we should mark the cached value as invalid.
+                false
+            }
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub const WASMER_WEBC_QUERY_ALL: &str = r#"{
+    getPackage(name: "$NAME") {
+        packageName
+        namespace
+        versions {
+        version
+        piritaManifest
+        isArchived
+        distribution {
+            piritaDownloadUrl
+            piritaSha256Hash
+        }
+        }
+    }
+    info {
+        defaultFrontend
+    }
+}"#;
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQuery {
+    #[serde(rename = "data")]
+    pub data: WapmWebQueryData,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQueryData {
+    #[serde(rename = "getPackage")]
+    pub get_package: Option<WapmWebQueryGetPackage>,
+    pub info: WapmWebQueryInfo,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQueryInfo {
+    #[serde(rename = "defaultFrontend")]
+    pub default_frontend: Url,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQueryGetPackage {
+    #[serde(rename = "packageName")]
+    pub package_name: String,
+    pub namespace: String,
+    pub versions: Vec<WapmWebQueryGetPackageVersion>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQueryGetPackageVersion {
+    pub version: String,
+    /// Has the package been archived?
+    #[serde(rename = "isArchived", default)]
+    pub is_archived: bool,
+    /// A JSON string containing a [`Manifest`] definition.
+    #[serde(rename = "piritaManifest")]
+    pub manifest: Option<String>,
+    pub distribution: WapmWebQueryGetPackageVersionDistribution,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, Clone)]
+pub struct WapmWebQueryGetPackageVersionDistribution {
+    #[serde(rename = "piritaDownloadUrl")]
+    pub pirita_download_url: Option<Url>,
+    #[serde(rename = "piritaSha256Hash")]
+    pub pirita_sha256_hash: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Mutex;
+
+    use http::{HeaderMap, StatusCode};
+
+    use crate::{
+        http::HttpResponse,
+        runtime::resolver::inputs::{DistributionInfo, FileSystemMapping, PackageInfo},
+    };
+
+    use super::*;
+
+    // You can check the response with:
+    // curl https://registry.wasmer.io/graphql \
+    //      -H "Content-Type: application/json" \
+    //      -X POST \
+    //      -d '@wasmer_pack_cli_request.json' > wasmer_pack_cli_response.json
+    const WASMER_PACK_CLI_REQUEST: &[u8] = br#"{"query":"{\n    getPackage(name: \"wasmer/wasmer-pack-cli\") {\n        packageName\n        namespace\n        versions {\n        version\n        piritaManifest\n        isArchived\n        distribution {\n            piritaDownloadUrl\n            piritaSha256Hash\n        }\n        }\n    }\n    info {\n        defaultFrontend\n    }\n}"}"#;
+    const WASMER_PACK_CLI_RESPONSE: &[u8] = br#"{"data":{"getPackage":{"packageName":"wasmer-pack-cli","namespace":"wasmer","versions":[{"version":"0.7.1","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:gGeLZqPitpg893Jj/nvGa+1235RezSWA9FjssopzOZY=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.7.1\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.7.1/wasmer-pack-cli-0.7.1.webc","piritaSha256Hash":"e821047f446dd20fb6b43a1648fe98b882276dfc480f020df6f00a49f69771fa"}},{"version":"0.7.0","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:FesCIAS6URjrIAAyy4G5u5HjJjGQBLGmnafjHPHRvqo=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"/home/consulting/Documents/wasmer/wasmer-pack/crates/cli/../../README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.7.0\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.7.0/wasmer-pack-cli-0.7.0.webc","piritaSha256Hash":"d085869201aa602673f70abbd5e14e5a6936216fa93314c5b103cda3da56e29e"}},{"version":"0.6.0","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:CzzhNaav3gjBkCJECGbk7e+qAKurWbcIAzQvEqsr2Co=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"/home/consulting/Documents/wasmer/wasmer-pack/crates/cli/../../README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.6.0\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.6.0/wasmer-pack-cli-0.6.0.webc","piritaSha256Hash":"7e1add1640d0037ff6a726cd7e14ea36159ec2db8cb6debd0e42fa2739bea52b"}},{"version":"0.5.3","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:qdiJVfpi4icJXdR7Y5US/pJ4PjqbAq9PkU+obMZIMlE=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"/home/runner/work/wasmer-pack/wasmer-pack/crates/cli/../../README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.5.3\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.5.3/wasmer-pack-cli-0.5.3.webc","piritaSha256Hash":"44fdcdde23d34175887243d7c375e4e4a7e6e2cd1ae063ebffbede4d1f68f14a"}},{"version":"0.5.2","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:xiwrUFAo+cU1xW/IE6MVseiyjNGHtXooRlkYKiOKzQc=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"/home/consulting/Documents/wasmer/wasmer-pack/crates/cli/../../README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.5.2\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.5.2/wasmer-pack-cli-0.5.2.webc","piritaSha256Hash":"d1dbc8168c3a2491a7158017a9c88df9e0c15bed88ebcd6d9d756e4b03adde95"}},{"version":"0.5.1","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:TliPwutfkFvRite/3/k3OpLqvV0EBKGwyp3L5UjCuEI=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"/home/runner/work/wasmer-pack/wasmer-pack/crates/cli/../../README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.5.1\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.5.1/wasmer-pack-cli-0.5.1.webc","piritaSha256Hash":"c42924619660e2befd69b5c72729388985dcdcbf912d51a00015237fec3e1ade"}},{"version":"0.5.0","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:6UD7NS4KtyNYa3TcnKOvd+kd3LxBCw+JQ8UWRpMXeC0=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.5.0\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.5.0/wasmer-pack-cli-0.5.0.webc","piritaSha256Hash":"d30ca468372faa96469163d2d1546dd34be9505c680677e6ab86a528a268e5f5"}},{"version":"0.5.0-rc.1","piritaManifest":"{\"atoms\": {\"wasmer-pack\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:ThybHIc2elJEcDdQiq5ffT1TVaNs70+WAqoKw4Tkh3E=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/wasmer-pack-cli\", \"readme\": {\"path\": \"README.md\", \"volume\": \"metadata\"}, \"license\": \"MIT\", \"version\": \"0.5.0-rc.1\", \"homepage\": \"https://wasmer.io/\", \"repository\": \"https://github.com/wasmerio/wasmer-pack\", \"description\": \"A code generator that lets you treat WebAssembly modules like native dependencies.\"}}, \"commands\": {\"wasmer-pack\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"wasmer-pack\", \"package\": \"wasmer/wasmer-pack-cli\", \"main_args\": null}}}}, \"entrypoint\": \"wasmer-pack\"}","isArchived":false,"distribution":{"piritaDownloadUrl":"https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.5.0-rc.1/wasmer-pack-cli-0.5.0-rc.1.webc","piritaSha256Hash":"0cd5d6e4c33c92c52784afed3a60c056953104d719717948d4663ff2521fe2bb"}}]},"info":{"defaultFrontend":"https://wasmer.io"}}}"#;
+
+    #[derive(Debug)]
+    struct DummyClient {
+        requests: Mutex<Vec<HttpRequest>>,
+        responses: Mutex<Vec<HttpResponse>>,
+    }
+
+    impl DummyClient {
+        fn new(responses: Vec<HttpResponse>) -> Self {
+            DummyClient {
+                requests: Mutex::new(Vec::new()),
+                responses: Mutex::new(responses),
+            }
+        }
+
+        fn take_requests(&self) -> Vec<HttpRequest> {
+            std::mem::take(&mut *self.requests.lock().unwrap())
+        }
+    }
+
+    impl HttpClient for DummyClient {
+        fn request(
+            &self,
+            request: HttpRequest,
+        ) -> futures::future::BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+            self.requests.lock().unwrap().push(request);
+            let response = self.responses.lock().unwrap().remove(0);
+            Box::pin(async { Ok(response) })
+        }
+    }
+
+    #[tokio::test]
+    async fn run_known_query() {
+        let response = HttpResponse {
+            body: Some(WASMER_PACK_CLI_RESPONSE.to_vec()),
+            redirected: false,
+            status: StatusCode::OK,
+            headers: HeaderMap::new(),
+        };
+        let client = Arc::new(DummyClient::new(vec![response]));
+        let registry_endpoint = WapmSource::WASMER_PROD_ENDPOINT.parse().unwrap();
+        let request = PackageSpecifier::Registry {
+            full_name: "wasmer/wasmer-pack-cli".to_string(),
+            version: "^0.6".parse().unwrap(),
+        };
+        let source = WapmSource::new(registry_endpoint, client.clone());
+
+        let summaries = source.query(&request).await.unwrap();
+
+        assert_eq!(
+            summaries,
+            [PackageSummary {
+                pkg: PackageInfo {
+                    name: "wasmer/wasmer-pack-cli".to_string(),
+                    version: Version::new(0, 6, 0),
+                    dependencies: Vec::new(),
+                    commands: vec![crate::runtime::resolver::Command {
+                        name: "wasmer-pack".to_string(),
+                    },],
+                    entrypoint: Some("wasmer-pack".to_string()),
+                    filesystem: vec![FileSystemMapping {
+                        volume_name: "atom".to_string(),
+                        mount_path: "/".to_string(),
+                        original_path: "/".to_string(),
+                        dependency_name: None,
+                    }],
+                },
+                dist: DistributionInfo {
+                    webc: "https://storage.googleapis.com/wapm-registry-prod/webc/wasmer/wasmer-pack-cli/0.6.0/wasmer-pack-cli-0.6.0.webc"
+                        .parse()
+                        .unwrap(),
+                    webc_sha256: WebcHash::from_bytes([
+                        126, 26, 221, 22, 64, 208, 3, 127, 246, 167, 38, 205, 126, 20, 234, 54, 21,
+                        158, 194, 219, 140, 182, 222, 189, 14, 66, 250, 39, 57, 190, 165, 43,
+                    ]),
+                }
+            }]
+        );
+        let requests = client.take_requests();
+        assert_eq!(requests.len(), 1);
+        let request = &requests[0];
+        assert_eq!(request.method, http::Method::POST);
+        assert_eq!(request.url.as_str(), WapmSource::WASMER_PROD_ENDPOINT);
+        assert_eq!(request.headers.len(), 2);
+        assert_eq!(request.headers["User-Agent"], USER_AGENT);
+        assert_eq!(request.headers["Content-Type"], "application/json");
+        let body: serde_json::Value =
+            serde_json::from_slice(request.body.as_deref().unwrap()).unwrap();
+        let expected_body: serde_json::Value =
+            serde_json::from_slice(WASMER_PACK_CLI_REQUEST).unwrap();
+        assert_eq!(body, expected_body);
+    }
+
+    /// For the full context, see #3946 on GitHub or the original conversation
+    /// [on
+    /// Slack](https://wasmerio.slack.com/archives/C03MX4KL6KH/p1685706988500919).
+    #[tokio::test]
+    async fn skip_package_versions_with_missing_fields() {
+        let body = serde_json::json! {
+            {
+                "data": {
+                    "getPackage": {
+                        "packageName": "cowsay",
+                        "namespace": "_",
+                        "versions": [
+                            {
+                                "version": "0.2.0",
+                                "piritaManifest": "{\"atoms\": {\"cowsay\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:DPmhiSNXCg5261eTUi3BIvAc/aJttGj+nD+bGhQkVQo=\"}}, \"package\": {\"wapm\": {\"name\": \"cowsay\", \"readme\": {\"path\": \"README.md\", \"volume\": \"metadata\"}, \"version\": \"0.2.0\", \"repository\": \"https://github.com/wapm-packages/cowsay\", \"description\": \"cowsay is a program that generates ASCII pictures of a cow with a message\"}}, \"commands\": {\"cowsay\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"cowsay\", \"package\": null, \"main_args\": null}}}, \"cowthink\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"cowsay\", \"package\": null, \"main_args\": null}}}}}",
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://storage.googleapis.com/wapm-registry-prod/packages/_/cowsay/cowsay-0.2.0.webc",
+                                    "piritaSha256Hash": "9586938a0a89219dafe4ae97a901c56d4b3e2a9941520d1309ae880c9a1868c9"
+                                }
+                            },
+                            {
+                                "version": "0.1.3",
+                                "piritaManifest": null,
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://example.com/",
+                                    "piritaSha256Hash": "1234asdf"
+                                }
+                            },
+                            {
+                                "version": "0.1.2",
+                                "piritaManifest": "{}",
+                                "distribution": {
+                                    "piritaDownloadUrl": null,
+                                    "piritaSha256Hash": "1234asdf"
+                                }
+                            },
+                            {
+                                "version": "0.1.3",
+                                "piritaManifest": "{}",
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://example.com/",
+                                    "piritaSha256Hash":null
+                                }
+                            }
+                        ]
+                    },
+                    "info": {
+                        "defaultFrontend": "https://wasmer.io/",
+                    },
+                }
+            }
+
+        };
+        let response = HttpResponse {
+            body: Some(serde_json::to_vec(&body).unwrap()),
+            redirected: false,
+            status: StatusCode::OK,
+            headers: HeaderMap::new(),
+        };
+        let client = Arc::new(DummyClient::new(vec![response]));
+        let registry_endpoint = WapmSource::WASMER_PROD_ENDPOINT.parse().unwrap();
+        let request = PackageSpecifier::Registry {
+            full_name: "_/cowsay".to_string(),
+            version: semver::VersionReq::STAR,
+        };
+        let source = WapmSource::new(registry_endpoint, client.clone());
+
+        let summaries = source.query(&request).await.unwrap();
+
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.version.to_string(), "0.2.0");
+    }
+
+    #[tokio::test]
+    async fn skip_archived_package_versions() {
+        let body = serde_json::json! {
+            {
+                "data": {
+                    "getPackage": {
+                        "packageName": "python",
+                        "namespace": "wasmer",
+                        "versions": [
+                            {
+                                "version": "3.12.2",
+                                "piritaManifest": "{\"atoms\": {\"python\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:ibsq6QL4qB4GtCE8IA2yfHVwI4fLoIGXsALsAx16y5M=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"license\": \"ISC\", \"version\": \"3.12.2\", \"repository\": \"https://github.com/wapm-packages/python\", \"description\": \"Python is an interpreted, high-level, general-purpose programming language\"}}, \"commands\": {\"python\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"python\", \"package\": null, \"main_args\": null}}}}, \"entrypoint\": \"python\"}",
+                                "isArchived": true,
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://storage.googleapis.com/wapm-registry-prod/packages/wasmer/python/python-3.12.0-build.5-a11e0414-c68d-473c-958f-fc96ef7adb20.webc",
+                                    "piritaSha256Hash": "7771ed54376c16da86581736fad84fb761a049915902a7070e854965be0d5874"
+                                }
+                            },
+                            {
+                                "version": "3.12.1",
+                                "piritaManifest": "{\"atoms\": {\"python\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:O36BXLHv3/80cABbAiF7gzuSHzzin1blTfJ42LDhT18=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"license\": \"ISC\", \"version\": \"3.12.1\", \"repository\": \"https://github.com/wapm-packages/python\", \"description\": \"Python is an interpreted, high-level, general-purpose programming language\"}}, \"commands\": {\"python\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"python\", \"package\": null, \"main_args\": null}}}}, \"entrypoint\": \"python\"}",
+                                "isArchived": false,
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://storage.googleapis.com/wapm-registry-prod/packages/wasmer/python/python-3.12.0-build.2-ed98c999-fcda-4f80-96dc-7c0f8be8baa6.webc",
+                                    "piritaSha256Hash": "7835401e3ca1977ba05b5e51541363783b8a7700da270dd851f10fe2e4f27f07"
+                                }
+                            },
+                            {
+                                "version": "3.12.0",
+                                "piritaManifest": "{\"atoms\": {\"python\": {\"kind\": \"https://webc.org/kind/wasm\", \"signature\": \"sha256:O36BXLHv3/80cABbAiF7gzuSHzzin1blTfJ42LDhT18=\"}}, \"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"license\": \"ISC\", \"version\": \"3.12.0\", \"repository\": \"https://github.com/wapm-packages/python\", \"description\": \"Python is an interpreted, high-level, general-purpose programming language\"}}, \"commands\": {\"python\": {\"runner\": \"https://webc.org/runner/wasi/command@unstable_\", \"annotations\": {\"wasi\": {\"atom\": \"python\", \"package\": null, \"main_args\": null}}}}, \"entrypoint\": \"python\"}",
+                                "isArchived": true,
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://storage.googleapis.com/wapm-registry-prod/packages/wasmer/python/python-3.12.0-32065e5e-84fe-4483-a380-0aa750772a3a.webc",
+                                    "piritaSha256Hash": "e5d6e9d16db988eb323e34e2c152ebfb32dc7043d6b7ddc00ad57d3beae24adb"
+                                }
+                            },
+                        ]
+                    },
+                    "info": {
+                        "defaultFrontend": "https://wasmer.io/",
+                    },
+                }
+            }
+        };
+        let response = HttpResponse {
+            body: Some(serde_json::to_vec(&body).unwrap()),
+            redirected: false,
+            status: StatusCode::OK,
+            headers: HeaderMap::new(),
+        };
+        let client = Arc::new(DummyClient::new(vec![response]));
+        let registry_endpoint = WapmSource::WASMER_PROD_ENDPOINT.parse().unwrap();
+        let request = PackageSpecifier::Registry {
+            full_name: "wasmer/python".to_string(),
+            version: semver::VersionReq::STAR,
+        };
+        let source = WapmSource::new(registry_endpoint, client.clone());
+
+        let summaries = source.query(&request).await.unwrap();
+
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.version.to_string(), "3.12.1");
+    }
+
+    #[tokio::test]
+    async fn query_the_backend_again_if_cached_queries_dont_match() {
+        let cached_value = serde_json::from_value(serde_json::json! {
+            {
+                "data": {
+                    "getPackage": {
+                        "packageName": "python",
+                        "namespace": "wasmer",
+                        "versions": [
+                            {
+                                "version": "3.12.0",
+                                "piritaManifest": "{\"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"version\": \"3.12.0\", \"description\": \"Python\"}}}",
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://wasmer.io/wasmer/python@3.12.0",
+                                    "piritaSha256Hash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                                }
+                            },
+                        ]
+                    },
+                    "info": {
+                        "defaultFrontend": "https://wasmer.io/",
+                    },
+                }
+            }
+        }).unwrap();
+        let body = serde_json::json! {
+            {
+                "data": {
+                    "getPackage": {
+                        "packageName": "python",
+                        "namespace": "wasmer",
+                        "versions": [
+                            {
+                                "version": "4.0.0",
+                                "piritaManifest": "{\"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"version\": \"4.0.0\", \"description\": \"Python\"}}}",
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://wasmer.io/wasmer/python@4.0.0",
+                                    "piritaSha256Hash": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+                                }
+                            },
+                            {
+                                "version": "3.12.0",
+                                "piritaManifest": "{\"package\": {\"wapm\": {\"name\": \"wasmer/python\", \"version\": \"3.12.0\", \"description\": \"Python\"}}}",
+                                "distribution": {
+                                    "piritaDownloadUrl": "https://wasmer.io/wasmer/python@3.12.0",
+                                    "piritaSha256Hash": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                                }
+                            },
+                        ]
+                    },
+                    "info": {
+                        "defaultFrontend": "https://wasmer.io/",
+                    },
+                }
+            }
+        };
+        let response = HttpResponse {
+            body: Some(serde_json::to_vec(&body).unwrap()),
+            redirected: false,
+            status: StatusCode::OK,
+            headers: HeaderMap::new(),
+        };
+        let client = Arc::new(DummyClient::new(vec![response]));
+        let registry_endpoint = WapmSource::WASMER_PROD_ENDPOINT.parse().unwrap();
+        let request = PackageSpecifier::Registry {
+            full_name: "wasmer/python".to_string(),
+            version: "4.0.0".parse().unwrap(),
+        };
+        let temp = tempfile::tempdir().unwrap();
+        let source = WapmSource::new(registry_endpoint, client.clone())
+            .with_local_cache(temp.path(), Duration::from_secs(0));
+        source
+            .cache
+            .as_ref()
+            .unwrap()
+            .update("wasmer/python", &cached_value)
+            .unwrap();
+
+        let summaries = source.query(&request).await.unwrap();
+
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.version.to_string(), "4.0.0");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/web_source.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/web_source.rs
new file mode 100644
index 0000000..e20f01d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/resolver/web_source.rs
@@ -0,0 +1,587 @@
+use std::{
+    fmt::Write as _,
+    io::Write,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::{Duration, SystemTime},
+};
+
+use anyhow::{Context, Error};
+use http::Method;
+use sha2::{Digest, Sha256};
+use tempfile::NamedTempFile;
+use url::Url;
+use webc::compat::Container;
+
+use crate::{
+    http::{HttpClient, HttpRequest},
+    runtime::resolver::{
+        DistributionInfo, PackageInfo, PackageSpecifier, PackageSummary, QueryError, Source,
+        WebcHash,
+    },
+};
+
+/// A [`Source`] which can query arbitrary packages on the internet.
+///
+/// # Implementation Notes
+///
+/// Unlike other [`Source`] implementations, this will need to download
+/// a package if it is a [`PackageSpecifier::Url`]. Optionally, these downloaded
+/// packages can be cached in a local directory.
+///
+/// After a certain period ([`WebSource::with_retry_period()`]), the
+/// [`WebSource`] will re-check the uploaded source to make sure the cached
+/// package is still valid. This checking is done using the [ETag][ETag] header,
+/// if available.
+///
+/// [ETag]: https://en.wikipedia.org/wiki/HTTP_ETag
+#[derive(Debug, Clone)]
+pub struct WebSource {
+    cache_dir: PathBuf,
+    client: Arc<dyn HttpClient + Send + Sync>,
+    retry_period: Duration,
+}
+
+impl WebSource {
+    pub const DEFAULT_RETRY_PERIOD: Duration = Duration::from_secs(5 * 60);
+
+    pub fn new(cache_dir: impl Into<PathBuf>, client: Arc<dyn HttpClient + Send + Sync>) -> Self {
+        WebSource {
+            cache_dir: cache_dir.into(),
+            client,
+            retry_period: WebSource::DEFAULT_RETRY_PERIOD,
+        }
+    }
+
+    /// Set the period after which an item should be marked as "possibly dirty"
+    /// in the cache.
+    pub fn with_retry_period(self, retry_period: Duration) -> Self {
+        WebSource {
+            retry_period,
+            ..self
+        }
+    }
+
+    /// Download a package and cache it locally.
+    #[tracing::instrument(level = "debug", skip_all, fields(%url))]
+    async fn get_locally_cached_file(&self, url: &Url) -> Result<PathBuf, Error> {
+        // This function is a bit tricky because we go to great lengths to avoid
+        // unnecessary downloads.
+
+        let cache_key = sha256(url.as_str().as_bytes());
+
+        // First, we figure out some basic information about the item
+        let cache_info = CacheInfo::for_url(&cache_key, &self.cache_dir);
+
+        // Next we check if we definitely got a cache hit
+        let state = match classify_cache_using_mtime(cache_info, self.retry_period) {
+            Ok(path) => {
+                tracing::debug!(path=%path.display(), "Cache hit!");
+                return Ok(path);
+            }
+            Err(s) => s,
+        };
+
+        // Let's check if the ETag is still valid
+        if let CacheState::PossiblyDirty { etag, path } = &state {
+            match self.get_etag(url).await {
+                Ok(new_etag) if new_etag == *etag => {
+                    return Ok(path.clone());
+                }
+                Ok(different_etag) => {
+                    tracing::debug!(
+                        original_etag=%etag,
+                        new_etag=%different_etag,
+                        path=%path.display(),
+                        "File has been updated. Redownloading.",
+                    );
+                }
+                Err(e) => {
+                    tracing::debug!(
+                        error=&*e,
+                        path=%path.display(),
+                        original_etag=%etag,
+                        "Unable to check if the etag is out of date",
+                    )
+                }
+            }
+        }
+
+        // Oh well, looks like we'll need to download it again
+        let (bytes, etag) = match self.fetch(url).await {
+            Ok((bytes, etag)) => (bytes, etag),
+            Err(e) => {
+                tracing::warn!(error = &*e, "Download failed");
+                match state.take_path() {
+                    Some(path) => {
+                        tracing::debug!(
+                            path=%path.display(),
+                            "Using a possibly stale cached file",
+                        );
+                        return Ok(path);
+                    }
+                    None => {
+                        return Err(e);
+                    }
+                }
+            }
+        };
+
+        let path = self.cache_dir.join(&cache_key);
+        self.atomically_save_file(&path, &bytes)
+            .await
+            .with_context(|| {
+                format!(
+                    "Unable to save the downloaded file to \"{}\"",
+                    path.display()
+                )
+            })?;
+
+        if let Some(etag) = etag {
+            if let Err(e) = self
+                .atomically_save_file(path.with_extension("etag"), etag.as_bytes())
+                .await
+            {
+                tracing::warn!(
+                    error=&*e,
+                    %etag,
+                    %url,
+                    path=%path.display(),
+                    "Unable to save the etag file",
+                )
+            }
+        }
+
+        Ok(path)
+    }
+
+    async fn atomically_save_file(&self, path: impl AsRef<Path>, data: &[u8]) -> Result<(), Error> {
+        // FIXME: This will all block the main thread
+
+        let path = path.as_ref();
+
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)
+                .with_context(|| format!("Unable to create \"{}\"", parent.display()))?;
+        }
+
+        let mut temp = NamedTempFile::new_in(&self.cache_dir)?;
+        temp.write_all(data)?;
+        temp.as_file().sync_all()?;
+        temp.persist(path)?;
+
+        Ok(())
+    }
+
+    async fn get_etag(&self, url: &Url) -> Result<String, Error> {
+        let request = HttpRequest {
+            url: url.clone(),
+            method: Method::HEAD,
+            headers: super::utils::webc_headers(),
+            body: None,
+            options: Default::default(),
+        };
+
+        let response = self.client.request(request).await?;
+
+        if !response.is_ok() {
+            return Err(super::utils::http_error(&response)
+                .context(format!("The HEAD request to \"{url}\" failed")));
+        }
+
+        let etag = response
+            .headers
+            .get("ETag")
+            .context("The HEAD request didn't contain an ETag header`")?
+            .to_str()
+            .context("The ETag wasn't valid UTF-8")?;
+
+        Ok(etag.to_string())
+    }
+
+    async fn fetch(&self, url: &Url) -> Result<(Vec<u8>, Option<String>), Error> {
+        let request = HttpRequest {
+            url: url.clone(),
+            method: Method::GET,
+            headers: super::utils::webc_headers(),
+            body: None,
+            options: Default::default(),
+        };
+        let response = self.client.request(request).await?;
+
+        if !response.is_ok() {
+            return Err(super::utils::http_error(&response)
+                .context(format!("The GET request to \"{url}\" failed")));
+        }
+
+        let body = response.body.context("Response didn't contain a body")?;
+
+        let etag = response
+            .headers
+            .get("ETag")
+            .and_then(|etag| etag.to_str().ok())
+            .map(|etag| etag.to_string());
+
+        Ok((body, etag))
+    }
+}
+
+#[async_trait::async_trait]
+impl Source for WebSource {
+    #[tracing::instrument(level = "debug", skip_all, fields(%package))]
+    async fn query(&self, package: &PackageSpecifier) -> Result<Vec<PackageSummary>, QueryError> {
+        let url = match package {
+            PackageSpecifier::Url(url) => url,
+            _ => return Err(QueryError::Unsupported),
+        };
+
+        let local_path = self
+            .get_locally_cached_file(url)
+            .await
+            .context("Unable to get the locally cached file")?;
+
+        let webc_sha256 = crate::block_in_place(|| WebcHash::for_file(&local_path))
+            .with_context(|| format!("Unable to hash \"{}\"", local_path.display()))?;
+
+        // Note: We want to use Container::from_disk() rather than the bytes
+        // our HTTP client gave us because then we can use memory-mapped files
+        let container = crate::block_in_place(|| Container::from_disk(&local_path))
+            .with_context(|| format!("Unable to load \"{}\"", local_path.display()))?;
+        let pkg = PackageInfo::from_manifest(container.manifest())
+            .context("Unable to determine the package's metadata")?;
+
+        let dist = DistributionInfo {
+            webc: url.clone(),
+            webc_sha256,
+        };
+
+        Ok(vec![PackageSummary { pkg, dist }])
+    }
+}
+
+fn sha256(bytes: &[u8]) -> String {
+    let mut hasher = Sha256::default();
+    hasher.update(bytes);
+    let hash = hasher.finalize();
+    let mut buffer = String::with_capacity(hash.len() * 2);
+    for byte in hash {
+        write!(buffer, "{byte:02X}").expect("Unreachable");
+    }
+
+    buffer
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum CacheInfo {
+    /// An item isn't in the cache, but could be cached later on.
+    Miss,
+    /// An item in the cache.
+    Hit {
+        path: PathBuf,
+        etag: Option<String>,
+        last_modified: Option<SystemTime>,
+    },
+}
+
+impl CacheInfo {
+    fn for_url(key: &str, checkout_dir: &Path) -> CacheInfo {
+        let path = checkout_dir.join(key);
+
+        if !path.exists() {
+            return CacheInfo::Miss;
+        }
+
+        let etag = std::fs::read_to_string(path.with_extension("etag")).ok();
+        let last_modified = path.metadata().and_then(|m| m.modified()).ok();
+
+        CacheInfo::Hit {
+            etag,
+            last_modified,
+            path,
+        }
+    }
+}
+
+fn classify_cache_using_mtime(
+    info: CacheInfo,
+    invalidation_threshold: Duration,
+) -> Result<PathBuf, CacheState> {
+    let (path, last_modified, etag) = match info {
+        CacheInfo::Hit {
+            path,
+            last_modified: Some(last_modified),
+            etag,
+            ..
+        } => (path, last_modified, etag),
+        CacheInfo::Hit {
+            path,
+            last_modified: None,
+            etag: Some(etag),
+            ..
+        } => return Err(CacheState::PossiblyDirty { etag, path }),
+        CacheInfo::Hit {
+            etag: None,
+            last_modified: None,
+            path,
+            ..
+        } => {
+            return Err(CacheState::UnableToVerify { path });
+        }
+        CacheInfo::Miss { .. } => return Err(CacheState::Miss),
+    };
+
+    if let Ok(time_since_last_modified) = last_modified.elapsed() {
+        if time_since_last_modified <= invalidation_threshold {
+            return Ok(path);
+        }
+    }
+
+    match etag {
+        Some(etag) => Err(CacheState::PossiblyDirty { etag, path }),
+        None => Err(CacheState::UnableToVerify { path }),
+    }
+}
+
+/// Classification of how valid an item is based on filesystem metadata.
+#[derive(Debug)]
+enum CacheState {
+    /// The item isn't in the cache.
+    Miss,
+    /// The cached item might be invalid, but it has an ETag we can use for
+    /// further validation.
+    PossiblyDirty { etag: String, path: PathBuf },
+    /// The cached item exists on disk, but we weren't able to tell whether it is still
+    /// valid, and there aren't any other ways to validate it further. You can
+    /// probably reuse this if you are having internet issues.
+    UnableToVerify { path: PathBuf },
+}
+
+impl CacheState {
+    fn take_path(self) -> Option<PathBuf> {
+        match self {
+            CacheState::PossiblyDirty { path, .. } | CacheState::UnableToVerify { path } => {
+                Some(path)
+            }
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{collections::VecDeque, sync::Mutex};
+
+    use futures::future::BoxFuture;
+    use http::{header::IntoHeaderName, HeaderMap, StatusCode};
+    use tempfile::TempDir;
+
+    use crate::http::HttpResponse;
+
+    use super::*;
+
+    const PYTHON: &[u8] = include_bytes!("../../../../c-api/examples/assets/python-0.1.0.wasmer");
+    const COREUTILS: &[u8] = include_bytes!("../../../../../tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc");
+    const DUMMY_URL: &str = "http://my-registry.io/some/package";
+    const DUMMY_URL_HASH: &str = "4D7481F44E1D971A8C60D3C7BD505E2727602CF9369ED623920E029C2BA2351D";
+
+    #[derive(Debug)]
+    pub(crate) struct DummyClient {
+        requests: Mutex<Vec<HttpRequest>>,
+        responses: Mutex<VecDeque<HttpResponse>>,
+    }
+
+    impl DummyClient {
+        pub fn with_responses(responses: impl IntoIterator<Item = HttpResponse>) -> Self {
+            DummyClient {
+                requests: Mutex::new(Vec::new()),
+                responses: Mutex::new(responses.into_iter().collect()),
+            }
+        }
+    }
+
+    impl HttpClient for DummyClient {
+        fn request(
+            &self,
+            request: HttpRequest,
+        ) -> BoxFuture<'_, Result<HttpResponse, anyhow::Error>> {
+            let response = self.responses.lock().unwrap().pop_front().unwrap();
+            self.requests.lock().unwrap().push(request);
+            Box::pin(async { Ok(response) })
+        }
+    }
+
+    struct ResponseBuilder(HttpResponse);
+
+    impl ResponseBuilder {
+        pub fn new() -> Self {
+            ResponseBuilder(HttpResponse {
+                body: None,
+                redirected: false,
+                status: StatusCode::OK,
+                headers: HeaderMap::new(),
+            })
+        }
+
+        pub fn with_status(mut self, code: StatusCode) -> Self {
+            self.0.status = code;
+            self
+        }
+
+        pub fn with_body(mut self, body: impl Into<Vec<u8>>) -> Self {
+            self.0.body = Some(body.into());
+            self
+        }
+
+        pub fn with_etag(self, value: &str) -> Self {
+            self.with_header("ETag", value)
+        }
+
+        pub fn with_header(mut self, name: impl IntoHeaderName, value: &str) -> Self {
+            self.0.headers.insert(name, value.parse().unwrap());
+            self
+        }
+
+        pub fn build(self) -> HttpResponse {
+            self.0
+        }
+    }
+
+    async fn empty_cache_does_a_full_download_internal() {
+        let dummy_etag = "This is an etag";
+        let temp = TempDir::new().unwrap();
+        let client = DummyClient::with_responses([ResponseBuilder::new()
+            .with_body(PYTHON)
+            .with_etag(dummy_etag)
+            .build()]);
+        let source = WebSource::new(temp.path(), Arc::new(client));
+        let spec = PackageSpecifier::Url(DUMMY_URL.parse().unwrap());
+
+        let summaries = source.query(&spec).await.unwrap();
+
+        // We got the right response, as expected
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.name, "python");
+        // But we should have also cached the file and etag
+        let path = temp.path().join(DUMMY_URL_HASH);
+        assert!(path.exists());
+        let etag_path = path.with_extension("etag");
+        assert!(etag_path.exists());
+        // And they should contain the correct content
+        assert_eq!(std::fs::read_to_string(etag_path).unwrap(), dummy_etag);
+        assert_eq!(std::fs::read(path).unwrap(), PYTHON);
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn empty_cache_does_a_full_download() {
+        empty_cache_does_a_full_download_internal().await
+    }
+    #[cfg(target_arch = "wasm32")]
+    #[tokio::test()]
+    async fn empty_cache_does_a_full_download() {
+        empty_cache_does_a_full_download_internal().await
+    }
+
+    async fn cache_hit_internal() {
+        let temp = TempDir::new().unwrap();
+        let client = Arc::new(DummyClient::with_responses([]));
+        let source = WebSource::new(temp.path(), client.clone());
+        let spec = PackageSpecifier::Url(DUMMY_URL.parse().unwrap());
+        // Prime the cache
+        std::fs::write(temp.path().join(DUMMY_URL_HASH), PYTHON).unwrap();
+
+        let summaries = source.query(&spec).await.unwrap();
+
+        // We got the right response, as expected
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.name, "python");
+        // And no requests were sent
+        assert_eq!(client.requests.lock().unwrap().len(), 0);
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn cache_hit() {
+        cache_hit_internal().await
+    }
+    #[cfg(target_arch = "wasm32")]
+    #[tokio::test()]
+    async fn cache_hit() {
+        cache_hit_internal().await
+    }
+
+    async fn fall_back_to_stale_cache_if_request_fails_internal() {
+        let temp = TempDir::new().unwrap();
+        let client = Arc::new(DummyClient::with_responses([ResponseBuilder::new()
+            .with_status(StatusCode::INTERNAL_SERVER_ERROR)
+            .build()]));
+        // Add something to the cache
+        let python_path = temp.path().join(DUMMY_URL_HASH);
+        std::fs::write(&python_path, PYTHON).unwrap();
+        let source = WebSource::new(temp.path(), client.clone()).with_retry_period(Duration::ZERO);
+        let spec = PackageSpecifier::Url(DUMMY_URL.parse().unwrap());
+
+        let summaries = source.query(&spec).await.unwrap();
+
+        // We got the right response, as expected
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.name, "python");
+        // And one request was sent
+        assert_eq!(client.requests.lock().unwrap().len(), 1);
+        // The etag file wasn't written
+        assert!(!python_path.with_extension("etag").exists());
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn fall_back_to_stale_cache_if_request_fails() {
+        fall_back_to_stale_cache_if_request_fails_internal().await
+    }
+    #[cfg(target_arch = "wasm32")]
+    #[tokio::test()]
+    async fn fall_back_to_stale_cache_if_request_fails() {
+        fall_back_to_stale_cache_if_request_fails_internal().await
+    }
+
+    async fn download_again_if_etag_is_different_internal() {
+        let temp = TempDir::new().unwrap();
+        let client = Arc::new(DummyClient::with_responses([
+            ResponseBuilder::new().with_etag("coreutils").build(),
+            ResponseBuilder::new()
+                .with_body(COREUTILS)
+                .with_etag("coreutils")
+                .build(),
+        ]));
+        // Add Python to the cache
+        let path = temp.path().join(DUMMY_URL_HASH);
+        std::fs::write(&path, PYTHON).unwrap();
+        std::fs::write(path.with_extension("etag"), "python").unwrap();
+        // but create a source that will always want to re-check the etags
+        let source =
+            WebSource::new(temp.path(), client.clone()).with_retry_period(Duration::new(0, 0));
+        let spec = PackageSpecifier::Url(DUMMY_URL.parse().unwrap());
+
+        let summaries = source.query(&spec).await.unwrap();
+
+        // Instead of Python (the originally cached item), we should get coreutils
+        assert_eq!(summaries.len(), 1);
+        assert_eq!(summaries[0].pkg.name, "sharrattj/coreutils");
+        // both a HEAD and GET request were sent
+        let requests = client.requests.lock().unwrap();
+        assert_eq!(requests.len(), 2);
+        assert_eq!(requests[0].method, "HEAD");
+        assert_eq!(requests[1].method, "GET");
+        // The etag file was also updated
+        assert_eq!(
+            std::fs::read_to_string(path.with_extension("etag")).unwrap(),
+            "coreutils"
+        );
+    }
+    #[cfg(not(target_arch = "wasm32"))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn download_again_if_etag_is_different() {
+        download_again_if_etag_is_different_internal().await
+    }
+    #[cfg(target_arch = "wasm32")]
+    #[tokio::test()]
+    async fn download_again_if_etag_is_different() {
+        download_again_if_etag_is_different_internal().await
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/mod.rs
new file mode 100644
index 0000000..49699c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/mod.rs
@@ -0,0 +1,463 @@
+// TODO: should be behind a different , tokio specific feature flag.
+#[cfg(feature = "sys-thread")]
+pub mod tokio;
+
+use std::ops::Deref;
+use std::task::{Context, Poll};
+use std::{pin::Pin, time::Duration};
+
+use bytes::Bytes;
+use derivative::Derivative;
+use futures::future::BoxFuture;
+use futures::{Future, TryFutureExt};
+use wasmer::{AsStoreMut, AsStoreRef, Memory, MemoryType, Module, Store, StoreMut, StoreRef};
+use wasmer_wasix_types::wasi::{Errno, ExitCode};
+
+use crate::os::task::thread::WasiThreadError;
+use crate::syscalls::AsyncifyFuture;
+use crate::{capture_store_snapshot, StoreSnapshot, WasiEnv, WasiFunctionEnv, WasiThread};
+
+pub use virtual_mio::waker::*;
+
+#[derive(Debug)]
+pub enum SpawnMemoryType<'a> {
+    CreateMemory,
+    CreateMemoryOfType(MemoryType),
+    // TODO: is there a way to get rid of the memory reference
+    ShareMemory(Memory, StoreRef<'a>),
+    // TODO: is there a way to get rid of the memory reference
+    // Note: The message sender is triggered once the memory
+    // has been copied, this makes sure its not modified until
+    // its been properly copied
+    CopyMemory(Memory, StoreRef<'a>),
+}
+
+pub type WasmResumeTask = dyn FnOnce(WasiFunctionEnv, Store, Bytes) + Send + 'static;
+
+pub type WasmResumeTrigger = dyn FnOnce() -> Pin<Box<dyn Future<Output = Result<Bytes, ExitCode>> + Send + 'static>>
+    + Send
+    + Sync;
+
+/// The properties passed to the task
+#[derive(Derivative)]
+#[derivative(Debug)]
+pub struct TaskWasmRunProperties {
+    pub ctx: WasiFunctionEnv,
+    pub store: Store,
+    /// The result of the asynchronous trigger serialized into bytes using the bincode serializer
+    /// When no trigger is associated with the run operation (i.e. spawning threads) then this will be None.
+    /// (if the trigger returns an ExitCode then the WASM process will be terminated without resuming)
+    pub trigger_result: Option<Result<Bytes, ExitCode>>,
+    /// The instance will be recycled back to this function when the WASM run has finished
+    #[derivative(Debug = "ignore")]
+    pub recycle: Option<Box<TaskWasmRecycle>>,
+}
+
+/// Callback that will be invoked
+pub type TaskWasmRun = dyn FnOnce(TaskWasmRunProperties) + Send + 'static;
+
+/// Callback that will be invoked
+pub type TaskExecModule = dyn FnOnce(Module) + Send + 'static;
+
+/// The properties passed to the task
+#[derive(Debug)]
+pub struct TaskWasmRecycleProperties {
+    pub env: WasiEnv,
+    pub memory: Memory,
+    pub store: Store,
+}
+
+/// Callback that will be invoked
+pub type TaskWasmRecycle = dyn FnOnce(TaskWasmRecycleProperties) + Send + 'static;
+
+/// Represents a WASM task that will be executed on a dedicated thread
+pub struct TaskWasm<'a, 'b> {
+    pub run: Box<TaskWasmRun>,
+    pub recycle: Option<Box<TaskWasmRecycle>>,
+    pub env: WasiEnv,
+    pub module: Module,
+    pub globals: Option<&'b StoreSnapshot>,
+    pub spawn_type: SpawnMemoryType<'a>,
+    pub trigger: Option<Box<WasmResumeTrigger>>,
+    pub update_layout: bool,
+}
+
+impl<'a, 'b> TaskWasm<'a, 'b> {
+    pub fn new(run: Box<TaskWasmRun>, env: WasiEnv, module: Module, update_layout: bool) -> Self {
+        let shared_memory = module.imports().memories().next().map(|a| *a.ty());
+        Self {
+            run,
+            env,
+            module,
+            globals: None,
+            spawn_type: match shared_memory {
+                Some(ty) => SpawnMemoryType::CreateMemoryOfType(ty),
+                None => SpawnMemoryType::CreateMemory,
+            },
+            trigger: None,
+            update_layout,
+            recycle: None,
+        }
+    }
+
+    pub fn with_memory(mut self, spawn_type: SpawnMemoryType<'a>) -> Self {
+        self.spawn_type = spawn_type;
+        self
+    }
+
+    pub fn with_optional_memory(mut self, spawn_type: Option<SpawnMemoryType<'a>>) -> Self {
+        if let Some(spawn_type) = spawn_type {
+            self.spawn_type = spawn_type;
+        }
+        self
+    }
+
+    pub fn with_globals(mut self, snapshot: &'b StoreSnapshot) -> Self {
+        self.globals.replace(snapshot);
+        self
+    }
+
+    pub fn with_trigger(mut self, trigger: Box<WasmResumeTrigger>) -> Self {
+        self.trigger.replace(trigger);
+        self
+    }
+
+    pub fn with_recycle(mut self, trigger: Box<TaskWasmRecycle>) -> Self {
+        self.recycle.replace(trigger);
+        self
+    }
+}
+
+/// A task executor backed by a thread pool.
+///
+/// ## Thread Safety
+///
+/// Due to [#4158], it is possible to pass non-thread safe objects across
+/// threads by capturing them in the task passed to
+/// [`VirtualTaskManager::task_shared()`] or
+/// [`VirtualTaskManager::task_dedicated()`].
+///
+/// If your task needs access to a [`wasmer::Module`], [`wasmer::Memory`], or
+/// [`wasmer::Instance`], it should explicitly transfer the objects using
+/// either [`VirtualTaskManager::task_wasm()`] when in syscall context or
+/// [`VirtualTaskManager::spawn_with_module()`] for higher level code.
+///
+/// [#4158]: https://github.com/wasmerio/wasmer/issues/4158
+#[allow(unused_variables)]
+pub trait VirtualTaskManager: std::fmt::Debug + Send + Sync + 'static {
+    /// Build a new Webassembly memory.
+    ///
+    /// May return `None` if the memory can just be auto-constructed.
+    fn build_memory(
+        &self,
+        mut store: &mut StoreMut,
+        spawn_type: SpawnMemoryType,
+    ) -> Result<Option<Memory>, WasiThreadError> {
+        match spawn_type {
+            SpawnMemoryType::CreateMemoryOfType(mut ty) => {
+                ty.shared = true;
+
+                // Note: If memory is shared, maximum needs to be set in the
+                // browser otherwise creation will fail.
+                let _ = ty.maximum.get_or_insert(wasmer_types::Pages::max_value());
+
+                let mem = Memory::new(&mut store, ty).map_err(|err| {
+                    tracing::error!(
+                        error = &err as &dyn std::error::Error,
+                        memory_type=?ty,
+                        "could not create memory",
+                    );
+                    WasiThreadError::MemoryCreateFailed(err)
+                })?;
+                Ok(Some(mem))
+            }
+            SpawnMemoryType::ShareMemory(mem, old_store) => {
+                let mem = mem.share_in_store(&old_store, store).map_err(|err| {
+                    tracing::warn!(
+                        error = &err as &dyn std::error::Error,
+                        "could not clone memory",
+                    );
+                    WasiThreadError::MemoryCreateFailed(err)
+                })?;
+                Ok(Some(mem))
+            }
+            SpawnMemoryType::CopyMemory(mem, old_store) => {
+                let mem = mem.copy_to_store(&old_store, store).map_err(|err| {
+                    tracing::warn!(
+                        error = &err as &dyn std::error::Error,
+                        "could not copy memory",
+                    );
+                    WasiThreadError::MemoryCreateFailed(err)
+                })?;
+                Ok(Some(mem))
+            }
+            SpawnMemoryType::CreateMemory => Ok(None),
+        }
+    }
+
+    /// Pause the current thread of execution.
+    ///
+    /// This is typically invoked whenever a WASM thread goes idle. Besides
+    /// acting as a platform-agnostic [`std::thread::sleep()`], this also gives
+    /// the runtime a chance to do asynchronous work like pumping an event
+    /// loop.
+    fn sleep_now(
+        &self,
+        time: Duration,
+    ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>;
+
+    /// Run an asynchronous operation on the thread pool.
+    ///
+    /// This task must not block execution or it could cause deadlocks.
+    ///
+    /// See the "Thread Safety" documentation on [`VirtualTaskManager`] for
+    /// limitations on what a `task` can and can't contain.
+    fn task_shared(
+        &self,
+        task: Box<dyn FnOnce() -> BoxFuture<'static, ()> + Send + 'static>,
+    ) -> Result<(), WasiThreadError>;
+
+    /// Run a blocking WebAssembly operation on the thread pool.
+    ///
+    /// This is primarily used inside the context of a syscall and allows
+    /// the transfer of things like [`wasmer::Module`] across threads.
+    fn task_wasm(&self, task: TaskWasm) -> Result<(), WasiThreadError>;
+
+    /// Run a blocking operation on the thread pool.
+    ///
+    /// It is okay for this task to block execution and any async futures within
+    /// its scope.
+    fn task_dedicated(
+        &self,
+        task: Box<dyn FnOnce() + Send + 'static>,
+    ) -> Result<(), WasiThreadError>;
+
+    /// Returns the amount of parallelism that is possible on this platform.
+    fn thread_parallelism(&self) -> Result<usize, WasiThreadError>;
+
+    /// Schedule a blocking task to run on the threadpool, explicitly
+    /// transferring a [`Module`] to the task.
+    ///
+    /// This should be preferred over [`VirtualTaskManager::task_dedicated()`]
+    /// where possible because [`wasmer::Module`] is actually `!Send` in the
+    /// browser and can only be transferred to background threads via
+    /// an explicit `postMessage()`. See [#4158] for more details.
+    ///
+    /// This is very similar to [`VirtualTaskManager::task_wasm()`], but
+    /// intended for use outside of a syscall context. For example, when you are
+    /// running in the browser and want to run a WebAssembly module in the
+    /// background.
+    ///
+    /// [#4158]: https://github.com/wasmerio/wasmer/issues/4158
+    fn spawn_with_module(
+        &self,
+        module: Module,
+        task: Box<dyn FnOnce(Module) + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        // Note: Ideally, this function and task_wasm() would be superseded by
+        // a more general mechanism for transferring non-thread safe values
+        // to the thread pool.
+        self.task_dedicated(Box::new(move || task(module)))
+    }
+}
+
+impl<D, T> VirtualTaskManager for D
+where
+    D: Deref<Target = T> + std::fmt::Debug + Send + Sync + 'static,
+    T: VirtualTaskManager + ?Sized,
+{
+    fn build_memory(
+        &self,
+        store: &mut StoreMut,
+        spawn_type: SpawnMemoryType,
+    ) -> Result<Option<Memory>, WasiThreadError> {
+        (**self).build_memory(store, spawn_type)
+    }
+
+    fn sleep_now(
+        &self,
+        time: Duration,
+    ) -> Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>> {
+        (**self).sleep_now(time)
+    }
+
+    fn task_shared(
+        &self,
+        task: Box<dyn FnOnce() -> BoxFuture<'static, ()> + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        (**self).task_shared(task)
+    }
+
+    fn task_wasm(&self, task: TaskWasm) -> Result<(), WasiThreadError> {
+        (**self).task_wasm(task)
+    }
+
+    fn task_dedicated(
+        &self,
+        task: Box<dyn FnOnce() + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        (**self).task_dedicated(task)
+    }
+
+    fn thread_parallelism(&self) -> Result<usize, WasiThreadError> {
+        (**self).thread_parallelism()
+    }
+
+    fn spawn_with_module(
+        &self,
+        module: Module,
+        task: Box<dyn FnOnce(Module) + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        (**self).spawn_with_module(module, task)
+    }
+}
+
+impl dyn VirtualTaskManager {
+    /// Starts an WebAssembly task will will run on a dedicated thread
+    /// pulled from the worker pool that has a stateful thread local variable
+    /// After the poller has succeeded
+    #[doc(hidden)]
+    pub unsafe fn resume_wasm_after_poller(
+        &self,
+        task: Box<WasmResumeTask>,
+        ctx: WasiFunctionEnv,
+        mut store: Store,
+        trigger: Pin<Box<AsyncifyFuture>>,
+    ) -> Result<(), WasiThreadError> {
+        // This poller will process any signals when the main working function is idle
+        struct AsyncifyPollerOwned {
+            thread: WasiThread,
+            trigger: Pin<Box<AsyncifyFuture>>,
+        }
+        impl Future for AsyncifyPollerOwned {
+            type Output = Result<Bytes, ExitCode>;
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let work = self.trigger.as_mut();
+                Poll::Ready(if let Poll::Ready(res) = work.poll(cx) {
+                    Ok(res)
+                } else if let Some(forced_exit) = self.thread.try_join() {
+                    return Poll::Ready(Err(forced_exit.unwrap_or_else(|err| {
+                        tracing::debug!("exit runtime error - {}", err);
+                        Errno::Child.into()
+                    })));
+                } else {
+                    return Poll::Pending;
+                })
+            }
+        }
+
+        let snapshot = capture_store_snapshot(&mut store.as_store_mut());
+        let env = ctx.data(&store);
+        let module = env.inner().module_clone();
+        let memory = env.inner().memory_clone();
+        let thread = env.thread.clone();
+        let env = env.clone();
+
+        let thread_inner = thread.clone();
+        self.task_wasm(
+            TaskWasm::new(
+                Box::new(move |props| {
+                    let result = props
+                        .trigger_result
+                        .expect("If there is no result then its likely the trigger did not run");
+                    let result = match result {
+                        Ok(r) => r,
+                        Err(exit_code) => {
+                            thread.set_status_finished(Ok(exit_code));
+                            return;
+                        }
+                    };
+                    task(props.ctx, props.store, result)
+                }),
+                env.clone(),
+                module,
+                false,
+            )
+            .with_memory(SpawnMemoryType::ShareMemory(memory, store.as_store_ref()))
+            .with_globals(&snapshot)
+            .with_trigger(Box::new(move || {
+                Box::pin(async move {
+                    let mut poller = AsyncifyPollerOwned {
+                        thread: thread_inner,
+                        trigger,
+                    };
+                    let res = Pin::new(&mut poller).await;
+                    let res = match res {
+                        Ok(res) => res,
+                        Err(exit_code) => {
+                            env.thread.set_status_finished(Ok(exit_code));
+                            return Err(exit_code);
+                        }
+                    };
+
+                    tracing::trace!("deep sleep woken - res.len={}", res.len());
+                    Ok(res)
+                })
+            })),
+        )
+    }
+}
+
+/// Generic utility methods for VirtualTaskManager
+pub trait VirtualTaskManagerExt {
+    /// Runs the work in the background via the task managers shared background
+    /// threads while blocking the current execution until it finishs
+    fn spawn_and_block_on<A>(
+        &self,
+        task: impl Future<Output = A> + Send + 'static,
+    ) -> Result<A, anyhow::Error>
+    where
+        A: Send + 'static;
+
+    fn spawn_await<O, F>(
+        &self,
+        f: F,
+    ) -> Box<dyn Future<Output = Result<O, Box<dyn std::error::Error>>> + Unpin + Send + 'static>
+    where
+        O: Send + 'static,
+        F: FnOnce() -> O + Send + 'static;
+}
+
+impl<D, T> VirtualTaskManagerExt for D
+where
+    D: Deref<Target = T>,
+    T: VirtualTaskManager + ?Sized,
+{
+    /// Runs the work in the background via the task managers shared background
+    /// threads while blocking the current execution until it finishs
+    fn spawn_and_block_on<A>(
+        &self,
+        task: impl Future<Output = A> + Send + 'static,
+    ) -> Result<A, anyhow::Error>
+    where
+        A: Send + 'static,
+    {
+        let (tx, rx) = ::tokio::sync::oneshot::channel();
+        let work = Box::pin(async move {
+            let ret = task.await;
+            tx.send(ret).ok();
+        });
+        self.task_shared(Box::new(move || work)).unwrap();
+        rx.blocking_recv()
+            .map_err(|_| anyhow::anyhow!("task execution failed - result channel dropped"))
+    }
+
+    fn spawn_await<O, F>(
+        &self,
+        f: F,
+    ) -> Box<dyn Future<Output = Result<O, Box<dyn std::error::Error>>> + Unpin + Send + 'static>
+    where
+        O: Send + 'static,
+        F: FnOnce() -> O + Send + 'static,
+    {
+        let (sender, receiver) = ::tokio::sync::oneshot::channel();
+
+        self.task_dedicated(Box::new(move || {
+            let result = f();
+            let _ = sender.send(result);
+        }))
+        .unwrap();
+
+        Box::new(receiver.map_err(|e| Box::new(e).into()))
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/tokio.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/tokio.rs
new file mode 100644
index 0000000..3940889
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/runtime/task_manager/tokio.rs
@@ -0,0 +1,275 @@
+use std::sync::Mutex;
+use std::{num::NonZeroUsize, pin::Pin, sync::Arc, time::Duration};
+
+use futures::{future::BoxFuture, Future};
+use tokio::runtime::{Handle, Runtime};
+
+use crate::{os::task::thread::WasiThreadError, WasiFunctionEnv};
+
+use super::{TaskWasm, TaskWasmRunProperties, VirtualTaskManager};
+
+#[derive(Debug, Clone)]
+pub enum RuntimeOrHandle {
+    Handle(Handle),
+    Runtime(Handle, Arc<Mutex<Option<Runtime>>>),
+}
+impl From<Handle> for RuntimeOrHandle {
+    fn from(value: Handle) -> Self {
+        Self::Handle(value)
+    }
+}
+impl From<Runtime> for RuntimeOrHandle {
+    fn from(value: Runtime) -> Self {
+        Self::Runtime(value.handle().clone(), Arc::new(Mutex::new(Some(value))))
+    }
+}
+
+impl Drop for RuntimeOrHandle {
+    fn drop(&mut self) {
+        if let Self::Runtime(_, runtime) = self {
+            if let Some(h) = runtime.lock().unwrap().take() {
+                h.shutdown_timeout(Duration::from_secs(0))
+            }
+        }
+    }
+}
+
+impl RuntimeOrHandle {
+    pub fn handle(&self) -> &Handle {
+        match self {
+            Self::Handle(h) => h,
+            Self::Runtime(h, _) => h,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct ThreadPool {
+    inner: rusty_pool::ThreadPool,
+}
+
+impl std::ops::Deref for ThreadPool {
+    type Target = rusty_pool::ThreadPool;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl std::fmt::Debug for ThreadPool {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ThreadPool")
+            .field("name", &self.get_name())
+            .field("current_worker_count", &self.get_current_worker_count())
+            .field("idle_worker_count", &self.get_idle_worker_count())
+            .finish()
+    }
+}
+
+/// A task manager that uses tokio to spawn tasks.
+#[derive(Clone, Debug)]
+pub struct TokioTaskManager {
+    rt: RuntimeOrHandle,
+    pool: Arc<ThreadPool>,
+}
+
+impl TokioTaskManager {
+    pub fn new<I>(rt: I) -> Self
+    where
+        I: Into<RuntimeOrHandle>,
+    {
+        let concurrency = std::thread::available_parallelism()
+            .unwrap_or(NonZeroUsize::new(1).unwrap())
+            .get();
+        let max_threads = 200usize.max(concurrency * 100);
+
+        Self {
+            rt: rt.into(),
+            pool: Arc::new(ThreadPool {
+                inner: rusty_pool::Builder::new()
+                    .name("TokioTaskManager Thread Pool".to_string())
+                    .core_size(max_threads)
+                    .max_size(max_threads)
+                    .build(),
+            }),
+        }
+    }
+
+    pub fn runtime_handle(&self) -> tokio::runtime::Handle {
+        self.rt.handle().clone()
+    }
+
+    pub fn pool_handle(&self) -> Arc<ThreadPool> {
+        self.pool.clone()
+    }
+}
+
+impl Default for TokioTaskManager {
+    fn default() -> Self {
+        Self::new(Handle::current())
+    }
+}
+
+struct TokioRuntimeGuard<'g> {
+    #[allow(unused)]
+    inner: tokio::runtime::EnterGuard<'g>,
+}
+impl<'g> Drop for TokioRuntimeGuard<'g> {
+    fn drop(&mut self) {}
+}
+
+impl VirtualTaskManager for TokioTaskManager {
+    /// See [`VirtualTaskManager::sleep_now`].
+    fn sleep_now(&self, time: Duration) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
+        let handle = self.runtime_handle();
+        Box::pin(async move {
+            SleepNow::default()
+                .enter(handle, time)
+                .await
+                .ok()
+                .unwrap_or(())
+        })
+    }
+
+    /// See [`VirtualTaskManager::task_shared`].
+    fn task_shared(
+        &self,
+        task: Box<dyn FnOnce() -> BoxFuture<'static, ()> + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        self.rt.handle().spawn(async move {
+            let fut = task();
+            fut.await
+        });
+        Ok(())
+    }
+
+    /// See [`VirtualTaskManager::task_wasm`].
+    fn task_wasm(&self, task: TaskWasm) -> Result<(), WasiThreadError> {
+        // Create the context on a new store
+        let run = task.run;
+        let recycle = task.recycle;
+        let (ctx, mut store) = WasiFunctionEnv::new_with_store(
+            task.module,
+            task.env,
+            task.globals,
+            task.spawn_type,
+            task.update_layout,
+        )?;
+
+        // If we have a trigger then we first need to run
+        // the poller to completion
+        if let Some(trigger) = task.trigger {
+            tracing::trace!("spawning task_wasm trigger in async pool");
+
+            let mut trigger = trigger();
+            let pool = self.pool.clone();
+            self.rt.handle().spawn(async move {
+                // We wait for either the trigger or for a snapshot to take place
+                let result = loop {
+                    let env = ctx.data(&store);
+                    break tokio::select! {
+                        r = &mut trigger => r,
+                        _ = env.thread.wait_for_signal() => {
+                            tracing::debug!("wait-for-signal(triggered)");
+                            let mut ctx = ctx.env.clone().into_mut(&mut store);
+                            if let Err(err) = crate::WasiEnv::process_signals_and_exit(&mut ctx) {
+                                match err {
+                                    crate::WasiError::Exit(code) => Err(code),
+                                    err => {
+                                        tracing::error!("failed to process signals - {}", err);
+                                        continue;
+                                    }
+                                }
+                            } else {
+                                continue;
+                            }
+                        }
+                        _ = crate::wait_for_snapshot(env) => {
+                            tracing::debug!("wait-for-snapshot(triggered)");
+                            let mut ctx = ctx.env.clone().into_mut(&mut store);
+                            crate::os::task::WasiProcessInner::do_checkpoints_from_outside(&mut ctx);
+                            continue;
+                        }
+                    };
+                };
+
+                // Build the task that will go on the callback
+                pool.execute(move || {
+                    // Invoke the callback
+                    run(TaskWasmRunProperties {
+                        ctx,
+                        store,
+                        trigger_result: Some(result),
+                        recycle,
+                    });
+                });
+            });
+        } else {
+            tracing::trace!("spawning task_wasm in blocking thread");
+
+            // Run the callback on a dedicated thread
+            self.pool.execute(move || {
+                tracing::trace!("task_wasm started in blocking thread");
+
+                // Invoke the callback
+                run(TaskWasmRunProperties {
+                    ctx,
+                    store,
+                    trigger_result: None,
+                    recycle,
+                });
+            });
+        }
+        Ok(())
+    }
+
+    /// See [`VirtualTaskManager::task_dedicated`].
+    fn task_dedicated(
+        &self,
+        task: Box<dyn FnOnce() + Send + 'static>,
+    ) -> Result<(), WasiThreadError> {
+        self.pool.execute(move || {
+            task();
+        });
+        Ok(())
+    }
+
+    /// See [`VirtualTaskManager::thread_parallelism`].
+    fn thread_parallelism(&self) -> Result<usize, WasiThreadError> {
+        Ok(std::thread::available_parallelism()
+            .map(usize::from)
+            .unwrap_or(8))
+    }
+}
+
+// Used by [`VirtualTaskManager::sleep_now`] to abort a sleep task when drop.
+#[derive(Default)]
+struct SleepNow {
+    abort_handle: Option<tokio::task::AbortHandle>,
+}
+
+impl SleepNow {
+    async fn enter(
+        &mut self,
+        handle: tokio::runtime::Handle,
+        time: Duration,
+    ) -> Result<(), tokio::task::JoinError> {
+        let handle = handle.spawn(async move {
+            if time == Duration::ZERO {
+                tokio::task::yield_now().await;
+            } else {
+                tokio::time::sleep(time).await;
+            }
+        });
+        self.abort_handle = Some(handle.abort_handle());
+        handle.await
+    }
+}
+
+impl Drop for SleepNow {
+    fn drop(&mut self) {
+        if let Some(h) = self.abort_handle.as_ref() {
+            h.abort()
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/builder.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/builder.rs
new file mode 100644
index 0000000..f46e6b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/builder.rs
@@ -0,0 +1,1233 @@
+//! Builder system for configuring a [`WasiState`] and creating it.
+
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use rand::Rng;
+use thiserror::Error;
+use virtual_fs::{ArcFile, FileSystem, FsError, TmpFileSystem, VirtualFile};
+use wasmer::{AsStoreMut, Extern, Imports, Instance, Module, Store};
+
+#[cfg(feature = "journal")]
+use crate::journal::{DynJournal, SnapshotTrigger};
+use crate::{
+    bin_factory::{BinFactory, BinaryPackage},
+    capabilities::Capabilities,
+    fs::{WasiFs, WasiFsRoot, WasiInodes},
+    os::task::control_plane::{ControlPlaneConfig, ControlPlaneError, WasiControlPlane},
+    runtime::module_cache::ModuleHash,
+    state::WasiState,
+    syscalls::{
+        rewind_ext2,
+        types::{__WASI_STDERR_FILENO, __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO},
+    },
+    Runtime, WasiEnv, WasiError, WasiFunctionEnv, WasiRuntimeError,
+};
+
+use super::env::WasiEnvInit;
+
+/// Builder API for configuring a [`WasiEnv`] environment needed to run WASI modules.
+///
+/// Usage:
+/// ```no_run
+/// # use wasmer_wasix::{WasiEnv, WasiStateCreationError};
+/// # fn main() -> Result<(), WasiStateCreationError> {
+/// let mut state_builder = WasiEnv::builder("wasi-prog-name");
+/// state_builder
+///    .env("ENV_VAR", "ENV_VAL")
+///    .arg("--verbose")
+///    .preopen_dir("src")?
+///    .map_dir("name_wasi_sees", "path/on/host/fs")?
+///    .build_init()?;
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Default)]
+pub struct WasiEnvBuilder {
+    /// Command line arguments.
+    pub(super) args: Vec<String>,
+    /// Environment variables.
+    pub(super) envs: Vec<(String, Vec<u8>)>,
+    /// Pre-opened directories that will be accessible from WASI.
+    pub(super) preopens: Vec<PreopenedDir>,
+    /// Pre-opened virtual directories that will be accessible from WASI.
+    vfs_preopens: Vec<String>,
+    #[allow(clippy::type_complexity)]
+    pub(super) setup_fs_fn:
+        Option<Box<dyn Fn(&WasiInodes, &mut WasiFs) -> Result<(), String> + Send>>,
+    pub(super) stdout: Option<Box<dyn VirtualFile + Send + Sync + 'static>>,
+    pub(super) stderr: Option<Box<dyn VirtualFile + Send + Sync + 'static>>,
+    pub(super) stdin: Option<Box<dyn VirtualFile + Send + Sync + 'static>>,
+    pub(super) fs: Option<WasiFsRoot>,
+    pub(super) runtime: Option<Arc<dyn crate::Runtime + Send + Sync + 'static>>,
+    pub(super) current_dir: Option<PathBuf>,
+
+    /// List of webc dependencies to be injected.
+    pub(super) uses: Vec<BinaryPackage>,
+
+    pub(super) module_hash: Option<ModuleHash>,
+
+    /// List of host commands to map into the WASI instance.
+    pub(super) map_commands: HashMap<String, PathBuf>,
+
+    pub(super) capabilites: Capabilities,
+    pub(super) additional_imports: Imports,
+
+    #[cfg(feature = "journal")]
+    pub(super) snapshot_on: Vec<SnapshotTrigger>,
+
+    #[cfg(feature = "journal")]
+    pub(super) snapshot_interval: Option<std::time::Duration>,
+
+    #[cfg(feature = "journal")]
+    pub(super) journals: Vec<Arc<DynJournal>>,
+}
+
+impl std::fmt::Debug for WasiEnvBuilder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // TODO: update this when stable
+        f.debug_struct("WasiEnvBuilder")
+            .field("args", &self.args)
+            .field("envs", &self.envs)
+            .field("preopens", &self.preopens)
+            .field("uses", &self.uses)
+            .field("setup_fs_fn exists", &self.setup_fs_fn.is_some())
+            .field("stdout_override exists", &self.stdout.is_some())
+            .field("stderr_override exists", &self.stderr.is_some())
+            .field("stdin_override exists", &self.stdin.is_some())
+            .field("runtime_override_exists", &self.runtime.is_some())
+            .finish()
+    }
+}
+
+/// Error type returned when bad data is given to [`WasiEnvBuilder`].
+#[derive(Error, Debug, Clone, PartialEq, Eq)]
+pub enum WasiStateCreationError {
+    #[error("bad environment variable format: `{0}`")]
+    EnvironmentVariableFormatError(String),
+    #[error("argument contains null byte: `{0}`")]
+    ArgumentContainsNulByte(String),
+    #[error("preopened directory not found: `{0}`")]
+    PreopenedDirectoryNotFound(PathBuf),
+    #[error("preopened directory error: `{0}`")]
+    PreopenedDirectoryError(String),
+    #[error("mapped dir alias has wrong format: `{0}`")]
+    MappedDirAliasFormattingError(String),
+    #[error("wasi filesystem creation error: `{0}`")]
+    WasiFsCreationError(String),
+    #[error("wasi filesystem setup error: `{0}`")]
+    WasiFsSetupError(String),
+    #[error(transparent)]
+    FileSystemError(#[from] FsError),
+    #[error("wasi inherit error: `{0}`")]
+    WasiInheritError(String),
+    #[error("wasi include package: `{0}`")]
+    WasiIncludePackageError(String),
+    #[error("control plane error")]
+    ControlPlane(#[from] ControlPlaneError),
+}
+
+fn validate_mapped_dir_alias(alias: &str) -> Result<(), WasiStateCreationError> {
+    if !alias.bytes().all(|b| b != b'\0') {
+        return Err(WasiStateCreationError::MappedDirAliasFormattingError(
+            format!("Alias \"{}\" contains a nul byte", alias),
+        ));
+    }
+
+    Ok(())
+}
+
+pub type SetupFsFn = Box<dyn Fn(&WasiInodes, &mut WasiFs) -> Result<(), String> + Send>;
+
+// TODO add other WasiFS APIs here like swapping out stdout, for example (though we need to
+// return stdout somehow, it's unclear what that API should look like)
+impl WasiEnvBuilder {
+    /// Creates an empty [`WasiEnvBuilder`].
+    pub fn new(program_name: impl Into<String>) -> Self {
+        WasiEnvBuilder {
+            args: vec![program_name.into()],
+            ..WasiEnvBuilder::default()
+        }
+    }
+
+    /// Add an environment variable pair.
+    ///
+    /// Both the key and value of an environment variable must not
+    /// contain a nul byte (`0x0`), and the key must not contain the
+    /// `=` byte (`0x3d`).
+    pub fn env<Key, Value>(mut self, key: Key, value: Value) -> Self
+    where
+        Key: AsRef<[u8]>,
+        Value: AsRef<[u8]>,
+    {
+        self.add_env(key, value);
+        self
+    }
+
+    /// Add an environment variable pair.
+    ///
+    /// Both the key and value of an environment variable must not
+    /// contain a nul byte (`0x0`), and the key must not contain the
+    /// `=` byte (`0x3d`).
+    pub fn add_env<Key, Value>(&mut self, key: Key, value: Value)
+    where
+        Key: AsRef<[u8]>,
+        Value: AsRef<[u8]>,
+    {
+        self.envs.push((
+            String::from_utf8_lossy(key.as_ref()).to_string(),
+            value.as_ref().to_vec(),
+        ));
+    }
+
+    /// Add multiple environment variable pairs.
+    ///
+    /// Both the key and value of the environment variables must not
+    /// contain a nul byte (`0x0`), and the key must not contain the
+    /// `=` byte (`0x3d`).
+    pub fn envs<I, Key, Value>(mut self, env_pairs: I) -> Self
+    where
+        I: IntoIterator<Item = (Key, Value)>,
+        Key: AsRef<[u8]>,
+        Value: AsRef<[u8]>,
+    {
+        self.add_envs(env_pairs);
+
+        self
+    }
+
+    /// Add multiple environment variable pairs.
+    ///
+    /// Both the key and value of the environment variables must not
+    /// contain a nul byte (`0x0`), and the key must not contain the
+    /// `=` byte (`0x3d`).
+    pub fn add_envs<I, Key, Value>(&mut self, env_pairs: I)
+    where
+        I: IntoIterator<Item = (Key, Value)>,
+        Key: AsRef<[u8]>,
+        Value: AsRef<[u8]>,
+    {
+        for (key, value) in env_pairs {
+            self.add_env(key, value);
+        }
+    }
+
+    /// Get a reference to the configured environment variables.
+    pub fn get_env(&self) -> &[(String, Vec<u8>)] {
+        &self.envs
+    }
+
+    /// Get a mutable reference to the configured environment variables.
+    pub fn get_env_mut(&mut self) -> &mut Vec<(String, Vec<u8>)> {
+        &mut self.envs
+    }
+
+    /// Add an argument.
+    ///
+    /// Arguments must not contain the nul (0x0) byte
+    // TODO: should take Into<Vec<u8>>
+    pub fn arg<V>(mut self, arg: V) -> Self
+    where
+        V: AsRef<[u8]>,
+    {
+        self.add_arg(arg);
+        self
+    }
+
+    /// Add an argument.
+    ///
+    /// Arguments must not contain the nul (0x0) byte.
+    // TODO: should take Into<Vec<u8>>
+    pub fn add_arg<V>(&mut self, arg: V)
+    where
+        V: AsRef<[u8]>,
+    {
+        self.args
+            .push(String::from_utf8_lossy(arg.as_ref()).to_string());
+    }
+
+    /// Add multiple arguments.
+    ///
+    /// Arguments must not contain the nul (0x0) byte
+    pub fn args<I, Arg>(mut self, args: I) -> Self
+    where
+        I: IntoIterator<Item = Arg>,
+        Arg: AsRef<[u8]>,
+    {
+        self.add_args(args);
+
+        self
+    }
+
+    /// Add multiple arguments.
+    ///
+    /// Arguments must not contain the nul (0x0) byte
+    pub fn add_args<I, Arg>(&mut self, args: I)
+    where
+        I: IntoIterator<Item = Arg>,
+        Arg: AsRef<[u8]>,
+    {
+        for arg in args {
+            self.add_arg(arg);
+        }
+    }
+
+    /// Get a reference to the configured arguments.
+    pub fn get_args(&self) -> &[String] {
+        &self.args
+    }
+
+    /// Get a mutable reference to the configured arguments.
+    pub fn get_args_mut(&mut self) -> &mut Vec<String> {
+        &mut self.args
+    }
+
+    /// Adds a container this module inherits from.
+    ///
+    /// This will make all of the container's files and commands available to the
+    /// resulting WASI instance.
+    pub fn use_webc(mut self, pkg: BinaryPackage) -> Self {
+        self.add_webc(pkg);
+        self
+    }
+
+    /// Sets the module hash for the running process. This ensures that the journal
+    /// can restore the records for the right module. If no module hash is supplied
+    /// then the process will start with a random module hash.
+    pub fn set_module_hash(&mut self, hash: ModuleHash) -> &mut Self {
+        self.module_hash.replace(hash);
+        self
+    }
+
+    /// Adds a container this module inherits from.
+    ///
+    /// This will make all of the container's files and commands available to the
+    /// resulting WASI instance.
+    pub fn add_webc(&mut self, pkg: BinaryPackage) -> &mut Self {
+        self.uses.push(pkg);
+        self
+    }
+
+    /// Adds a list of other containers this module inherits from.
+    ///
+    /// This will make all of the container's files and commands available to the
+    /// resulting WASI instance.
+    pub fn uses<I>(mut self, uses: I) -> Self
+    where
+        I: IntoIterator<Item = BinaryPackage>,
+    {
+        for pkg in uses {
+            self.add_webc(pkg);
+        }
+        self
+    }
+
+    /// Map an atom to a local binary
+    pub fn map_command<Name, Target>(mut self, name: Name, target: Target) -> Self
+    where
+        Name: AsRef<str>,
+        Target: AsRef<str>,
+    {
+        self.add_mapped_command(name, target);
+        self
+    }
+
+    /// Map an atom to a local binary
+    pub fn add_mapped_command<Name, Target>(&mut self, name: Name, target: Target)
+    where
+        Name: AsRef<str>,
+        Target: AsRef<str>,
+    {
+        let path_buf = PathBuf::from(target.as_ref().to_string());
+        self.map_commands
+            .insert(name.as_ref().to_string(), path_buf);
+    }
+
+    /// Maps a series of atoms to the local binaries
+    pub fn map_commands<I, Name, Target>(mut self, map_commands: I) -> Self
+    where
+        I: IntoIterator<Item = (Name, Target)>,
+        Name: AsRef<str>,
+        Target: AsRef<str>,
+    {
+        self.add_mapped_commands(map_commands);
+        self
+    }
+
+    /// Maps a series of atoms to local binaries.
+    pub fn add_mapped_commands<I, Name, Target>(&mut self, map_commands: I)
+    where
+        I: IntoIterator<Item = (Name, Target)>,
+        Name: AsRef<str>,
+        Target: AsRef<str>,
+    {
+        for (alias, target) in map_commands {
+            self.add_mapped_command(alias, target);
+        }
+    }
+
+    /// Preopen a directory
+    ///
+    /// This opens the given directory at the virtual root, `/`, and allows
+    /// the WASI module to read and write to the given directory.
+    pub fn preopen_dir<P>(mut self, po_dir: P) -> Result<Self, WasiStateCreationError>
+    where
+        P: AsRef<Path>,
+    {
+        self.add_preopen_dir(po_dir)?;
+        Ok(self)
+    }
+
+    /// Adds a preopen a directory
+    ///
+    /// This opens the given directory at the virtual root, `/`, and allows
+    /// the WASI module to read and write to the given directory.
+    pub fn add_preopen_dir<P>(&mut self, po_dir: P) -> Result<(), WasiStateCreationError>
+    where
+        P: AsRef<Path>,
+    {
+        let mut pdb = PreopenDirBuilder::new();
+        let path = po_dir.as_ref();
+        pdb.directory(path).read(true).write(true).create(true);
+        let preopen = pdb.build()?;
+
+        self.preopens.push(preopen);
+
+        Ok(())
+    }
+
+    /// Preopen multiple directories.
+    ///
+    /// This opens the given directories at the virtual root, `/`, and allows
+    /// the WASI module to read and write to the given directory.
+    pub fn preopen_dirs<I, P>(mut self, dirs: I) -> Result<Self, WasiStateCreationError>
+    where
+        I: IntoIterator<Item = P>,
+        P: AsRef<Path>,
+    {
+        for po_dir in dirs {
+            self.add_preopen_dir(po_dir)?;
+        }
+
+        Ok(self)
+    }
+
+    /// Preopen a directory and configure it.
+    ///
+    /// Usage:
+    ///
+    /// ```no_run
+    /// # use wasmer_wasix::{WasiEnv, WasiStateCreationError};
+    /// # fn main() -> Result<(), WasiStateCreationError> {
+    /// WasiEnv::builder("program_name")
+    ///    .preopen_build(|p| p.directory("src").read(true).write(true).create(true))?
+    ///    .preopen_build(|p| p.directory(".").alias("dot").read(true))?
+    ///    .build_init()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn preopen_build<F>(mut self, inner: F) -> Result<Self, WasiStateCreationError>
+    where
+        F: Fn(&mut PreopenDirBuilder) -> &mut PreopenDirBuilder,
+    {
+        self.add_preopen_build(inner)?;
+        Ok(self)
+    }
+
+    /// Preopen a directory and configure it.
+    ///
+    /// Usage:
+    ///
+    /// ```no_run
+    /// # use wasmer_wasix::{WasiEnv, WasiStateCreationError};
+    /// # fn main() -> Result<(), WasiStateCreationError> {
+    /// WasiEnv::builder("program_name")
+    ///    .preopen_build(|p| p.directory("src").read(true).write(true).create(true))?
+    ///    .preopen_build(|p| p.directory(".").alias("dot").read(true))?
+    ///    .build_init()?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn add_preopen_build<F>(&mut self, inner: F) -> Result<(), WasiStateCreationError>
+    where
+        F: Fn(&mut PreopenDirBuilder) -> &mut PreopenDirBuilder,
+    {
+        let mut pdb = PreopenDirBuilder::new();
+        let po_dir = inner(&mut pdb).build()?;
+
+        self.preopens.push(po_dir);
+
+        Ok(())
+    }
+
+    /// Preopen the given directories from the
+    /// Virtual FS.
+    pub fn preopen_vfs_dirs<I>(&mut self, po_dirs: I) -> Result<&mut Self, WasiStateCreationError>
+    where
+        I: IntoIterator<Item = String>,
+    {
+        for po_dir in po_dirs {
+            self.vfs_preopens.push(po_dir);
+        }
+
+        Ok(self)
+    }
+
+    /// Preopen a directory with a different name exposed to the WASI.
+    pub fn map_dir<P>(mut self, alias: &str, po_dir: P) -> Result<Self, WasiStateCreationError>
+    where
+        P: AsRef<Path>,
+    {
+        self.add_map_dir(alias, po_dir)?;
+        Ok(self)
+    }
+
+    /// Preopen a directory with a different name exposed to the WASI.
+    pub fn add_map_dir<P>(&mut self, alias: &str, po_dir: P) -> Result<(), WasiStateCreationError>
+    where
+        P: AsRef<Path>,
+    {
+        let mut pdb = PreopenDirBuilder::new();
+        let path = po_dir.as_ref();
+        pdb.directory(path)
+            .alias(alias)
+            .read(true)
+            .write(true)
+            .create(true);
+        let preopen = pdb.build()?;
+
+        self.preopens.push(preopen);
+
+        Ok(())
+    }
+
+    /// Preopen directorys with a different names exposed to the WASI.
+    pub fn map_dirs<I, P>(mut self, mapped_dirs: I) -> Result<Self, WasiStateCreationError>
+    where
+        I: IntoIterator<Item = (String, P)>,
+        P: AsRef<Path>,
+    {
+        for (alias, dir) in mapped_dirs {
+            self.add_map_dir(&alias, dir)?;
+        }
+
+        Ok(self)
+    }
+
+    /// Specifies one or more journal files that Wasmer will use to restore
+    /// the state of the WASM process.
+    ///
+    /// The state of the WASM process and its sandbox will be reapplied use
+    /// the journals in the order that you specify here.
+    ///
+    /// The last journal file specified will be created if it does not exist
+    /// and opened for read and write. New journal events will be written to this
+    /// file
+    #[cfg(feature = "journal")]
+    pub fn add_journal(&mut self, journal: Arc<DynJournal>) {
+        self.journals.push(journal);
+    }
+
+    pub fn set_current_dir(&mut self, dir: impl Into<PathBuf>) {
+        self.current_dir = Some(dir.into());
+    }
+
+    pub fn current_dir(mut self, dir: impl Into<PathBuf>) -> Self {
+        self.set_current_dir(dir);
+        self
+    }
+
+    /// Overwrite the default WASI `stdout`, if you want to hold on to the
+    /// original `stdout` use [`WasiFs::swap_file`] after building.
+    pub fn stdout(mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.stdout = Some(new_file);
+
+        self
+    }
+
+    /// Overwrite the default WASI `stdout`, if you want to hold on to the
+    /// original `stdout` use [`WasiFs::swap_file`] after building.
+    pub fn set_stdout(&mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) {
+        self.stdout = Some(new_file);
+    }
+
+    /// Overwrite the default WASI `stderr`, if you want to hold on to the
+    /// original `stderr` use [`WasiFs::swap_file`] after building.
+    pub fn stderr(mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.set_stderr(new_file);
+        self
+    }
+
+    /// Overwrite the default WASI `stderr`, if you want to hold on to the
+    /// original `stderr` use [`WasiFs::swap_file`] after building.
+    pub fn set_stderr(&mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) {
+        self.stderr = Some(new_file);
+    }
+
+    /// Overwrite the default WASI `stdin`, if you want to hold on to the
+    /// original `stdin` use [`WasiFs::swap_file`] after building.
+    pub fn stdin(mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) -> Self {
+        self.stdin = Some(new_file);
+
+        self
+    }
+
+    /// Overwrite the default WASI `stdin`, if you want to hold on to the
+    /// original `stdin` use [`WasiFs::swap_file`] after building.
+    pub fn set_stdin(&mut self, new_file: Box<dyn VirtualFile + Send + Sync + 'static>) {
+        self.stdin = Some(new_file);
+    }
+
+    /// Sets the FileSystem to be used with this WASI instance.
+    ///
+    /// This is usually used in case a custom `virtual_fs::FileSystem` is needed.
+    pub fn fs(mut self, fs: Box<dyn virtual_fs::FileSystem + Send + Sync>) -> Self {
+        self.set_fs(fs);
+        self
+    }
+
+    pub fn set_fs(&mut self, fs: Box<dyn virtual_fs::FileSystem + Send + Sync>) {
+        self.fs = Some(WasiFsRoot::Backing(Arc::new(fs)));
+    }
+
+    /// Sets a new sandbox FileSystem to be used with this WASI instance.
+    ///
+    /// This is usually used in case a custom `virtual_fs::FileSystem` is needed.
+    pub fn sandbox_fs(mut self, fs: TmpFileSystem) -> Self {
+        self.fs = Some(WasiFsRoot::Sandbox(Arc::new(fs)));
+        self
+    }
+
+    /// Configure the WASI filesystem before running.
+    // TODO: improve ergonomics on this function
+    pub fn setup_fs(mut self, setup_fs_fn: SetupFsFn) -> Self {
+        self.setup_fs_fn = Some(setup_fs_fn);
+
+        self
+    }
+
+    /// Sets the WASI runtime implementation and overrides the default
+    /// implementation
+    pub fn runtime(mut self, runtime: Arc<dyn Runtime + Send + Sync>) -> Self {
+        self.set_runtime(runtime);
+        self
+    }
+
+    pub fn set_runtime(&mut self, runtime: Arc<dyn Runtime + Send + Sync>) {
+        self.runtime = Some(runtime);
+    }
+
+    pub fn capabilities(mut self, capabilities: Capabilities) -> Self {
+        self.set_capabilities(capabilities);
+        self
+    }
+
+    pub fn capabilities_mut(&mut self) -> &mut Capabilities {
+        &mut self.capabilites
+    }
+
+    pub fn set_capabilities(&mut self, capabilities: Capabilities) {
+        self.capabilites = capabilities;
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn add_snapshot_trigger(&mut self, on: SnapshotTrigger) {
+        self.snapshot_on.push(on);
+    }
+
+    #[cfg(feature = "journal")]
+    pub fn with_snapshot_interval(&mut self, interval: std::time::Duration) {
+        self.snapshot_interval.replace(interval);
+    }
+
+    /// Add an item to the list of importable items provided to the instance.
+    pub fn import(
+        mut self,
+        namespace: impl Into<String>,
+        name: impl Into<String>,
+        value: impl Into<Extern>,
+    ) -> Self {
+        self.add_imports([((namespace, name), value)]);
+        self
+    }
+
+    /// Add an item to the list of importable items provided to the instance.
+    pub fn add_import(
+        &mut self,
+        namespace: impl Into<String>,
+        name: impl Into<String>,
+        value: impl Into<Extern>,
+    ) {
+        self.add_imports([((namespace, name), value)]);
+    }
+
+    pub fn add_imports<I, S1, S2, E>(&mut self, imports: I)
+    where
+        I: IntoIterator<Item = ((S1, S2), E)>,
+        S1: Into<String>,
+        S2: Into<String>,
+        E: Into<Extern>,
+    {
+        let imports = imports
+            .into_iter()
+            .map(|((ns, n), e)| ((ns.into(), n.into()), e.into()));
+        self.additional_imports.extend(imports);
+    }
+
+    pub fn imports<I, S1, S2, E>(mut self, imports: I) -> Self
+    where
+        I: IntoIterator<Item = ((S1, S2), E)>,
+        S1: Into<String>,
+        S2: Into<String>,
+        E: Into<Extern>,
+    {
+        self.add_imports(imports);
+        self
+    }
+
+    /// Consumes the [`WasiEnvBuilder`] and produces a [`WasiEnvInit`], which
+    /// can be used to construct a new [`WasiEnv`].
+    ///
+    /// Returns the error from `WasiFs::new` if there's an error
+    ///
+    /// NOTE: You should prefer to not work directly with [`WasiEnvInit`].
+    /// Use [`WasiEnvBuilder::run`] or [`WasiEnvBuilder::run_with_store`] instead
+    /// to ensure proper invokation of WASI modules.
+    pub fn build_init(mut self) -> Result<WasiEnvInit, WasiStateCreationError> {
+        for arg in self.args.iter() {
+            for b in arg.as_bytes().iter() {
+                if *b == 0 {
+                    return Err(WasiStateCreationError::ArgumentContainsNulByte(arg.clone()));
+                }
+            }
+        }
+
+        enum InvalidCharacter {
+            Nul,
+            Equal,
+        }
+
+        for (env_key, env_value) in self.envs.iter() {
+            match env_key.as_bytes().iter().find_map(|&ch| {
+                if ch == 0 {
+                    Some(InvalidCharacter::Nul)
+                } else if ch == b'=' {
+                    Some(InvalidCharacter::Equal)
+                } else {
+                    None
+                }
+            }) {
+                Some(InvalidCharacter::Nul) => {
+                    return Err(WasiStateCreationError::EnvironmentVariableFormatError(
+                        format!("found nul byte in env var key \"{}\" (key=value)", env_key),
+                    ))
+                }
+
+                Some(InvalidCharacter::Equal) => {
+                    return Err(WasiStateCreationError::EnvironmentVariableFormatError(
+                        format!(
+                            "found equal sign in env var key \"{}\" (key=value)",
+                            env_key
+                        ),
+                    ))
+                }
+
+                None => (),
+            }
+
+            if env_value.iter().any(|&ch| ch == 0) {
+                return Err(WasiStateCreationError::EnvironmentVariableFormatError(
+                    format!(
+                        "found nul byte in env var value \"{}\" (key=value)",
+                        String::from_utf8_lossy(env_value),
+                    ),
+                ));
+            }
+        }
+
+        // TODO: must be used! (runtime was removed from env, must ensure configured runtime is used)
+        // // Get a reference to the runtime
+        // let runtime = self
+        //     .runtime
+        //     .clone()
+        //     .unwrap_or_else(|| Arc::new(PluggableRuntimeImplementation::default()));
+
+        // Determine the STDIN
+        let stdin: Box<dyn VirtualFile + Send + Sync + 'static> = self
+            .stdin
+            .take()
+            .unwrap_or_else(|| Box::new(ArcFile::new(Box::<super::Stdin>::default())));
+
+        let fs_backing = self
+            .fs
+            .take()
+            .unwrap_or_else(|| WasiFsRoot::Sandbox(Arc::new(TmpFileSystem::new())));
+
+        if let Some(dir) = &self.current_dir {
+            match fs_backing.read_dir(dir) {
+                Ok(_) => {
+                    // All good
+                }
+                Err(FsError::EntryNotFound) => {
+                    fs_backing.create_dir(dir).map_err(|err| {
+                        WasiStateCreationError::WasiFsSetupError(format!(
+                            "Could not create specified current directory at '{}': {err}",
+                            dir.display()
+                        ))
+                    })?;
+                }
+                Err(err) => {
+                    return Err(WasiStateCreationError::WasiFsSetupError(format!(
+                        "Could check specified current directory at '{}': {err}",
+                        dir.display()
+                    )));
+                }
+            }
+        }
+
+        // self.preopens are checked in [`PreopenDirBuilder::build`]
+        let inodes = crate::state::WasiInodes::new();
+        let wasi_fs = {
+            // self.preopens are checked in [`PreopenDirBuilder::build`]
+            let mut wasi_fs =
+                WasiFs::new_with_preopen(&inodes, &self.preopens, &self.vfs_preopens, fs_backing)
+                    .map_err(WasiStateCreationError::WasiFsCreationError)?;
+
+            // set up the file system, overriding base files and calling the setup function
+            wasi_fs
+                .swap_file(__WASI_STDIN_FILENO, stdin)
+                .map_err(WasiStateCreationError::FileSystemError)?;
+
+            if let Some(stdout_override) = self.stdout.take() {
+                wasi_fs
+                    .swap_file(__WASI_STDOUT_FILENO, stdout_override)
+                    .map_err(WasiStateCreationError::FileSystemError)?;
+            }
+
+            if let Some(stderr_override) = self.stderr.take() {
+                wasi_fs
+                    .swap_file(__WASI_STDERR_FILENO, stderr_override)
+                    .map_err(WasiStateCreationError::FileSystemError)?;
+            }
+
+            if let Some(f) = &self.setup_fs_fn {
+                f(&inodes, &mut wasi_fs).map_err(WasiStateCreationError::WasiFsSetupError)?;
+            }
+            wasi_fs
+        };
+
+        if let Some(dir) = &self.current_dir {
+            let s = dir.to_str().ok_or_else(|| {
+                WasiStateCreationError::WasiFsSetupError(format!(
+                    "Specified current directory is not valid UTF-8: '{}'",
+                    dir.display()
+                ))
+            })?;
+            wasi_fs.set_current_dir(s);
+        }
+
+        let state = WasiState {
+            fs: wasi_fs,
+            secret: rand::thread_rng().gen::<[u8; 32]>(),
+            inodes,
+            args: self.args.clone(),
+            preopen: self.vfs_preopens.clone(),
+            futexs: Default::default(),
+            clock_offset: Default::default(),
+            envs: std::sync::Mutex::new(conv_env_vars(self.envs)),
+        };
+
+        let runtime = self.runtime.unwrap_or_else(|| {
+            #[cfg(feature = "sys-thread")]
+            {
+                #[allow(unused_mut)]
+                let mut runtime = crate::runtime::PluggableRuntime::new(Arc::new(crate::runtime::task_manager::tokio::TokioTaskManager::default()));
+                #[cfg(feature = "journal")]
+                for journal in self.journals.clone() {
+                    runtime.add_journal(journal);
+                }
+                Arc::new(runtime)
+            }
+
+            #[cfg(not(feature = "sys-thread"))]
+            {
+                panic!("this build does not support a default runtime - specify one with WasiEnvBuilder::runtime()");
+            }
+        });
+
+        let uses = self.uses;
+        let map_commands = self.map_commands;
+
+        let bin_factory = BinFactory::new(runtime.clone());
+
+        let capabilities = self.capabilites;
+
+        let plane_config = ControlPlaneConfig {
+            max_task_count: capabilities.threading.max_threads,
+            enable_asynchronous_threading: capabilities.threading.enable_asynchronous_threading,
+            enable_exponential_cpu_backoff: capabilities.threading.enable_exponential_cpu_backoff,
+        };
+        let control_plane = WasiControlPlane::new(plane_config);
+
+        let init = WasiEnvInit {
+            state,
+            runtime,
+            webc_dependencies: uses,
+            mapped_commands: map_commands,
+            control_plane,
+            bin_factory,
+            capabilities,
+            memory_ty: None,
+            process: None,
+            thread: None,
+            #[cfg(feature = "journal")]
+            call_initialize: self.journals.is_empty(),
+            #[cfg(not(feature = "journal"))]
+            call_initialize: true,
+            can_deep_sleep: false,
+            extra_tracing: true,
+            #[cfg(feature = "journal")]
+            snapshot_on: self.snapshot_on,
+            additional_imports: self.additional_imports,
+        };
+
+        Ok(init)
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub fn build(self) -> Result<WasiEnv, WasiRuntimeError> {
+        let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random);
+        let init = self.build_init()?;
+        WasiEnv::from_init(init, module_hash)
+    }
+
+    /// Construct a [`WasiFunctionEnv`].
+    ///
+    /// NOTE: you still must call [`WasiFunctionEnv::initialize`] to make an
+    /// instance usable.
+    #[doc(hidden)]
+    #[allow(clippy::result_large_err)]
+    pub fn finalize(
+        self,
+        store: &mut impl AsStoreMut,
+    ) -> Result<WasiFunctionEnv, WasiRuntimeError> {
+        let module_hash = self.module_hash.unwrap_or_else(ModuleHash::random);
+        let init = self.build_init()?;
+        let env = WasiEnv::from_init(init, module_hash)?;
+        let func_env = WasiFunctionEnv::new(store, env);
+        Ok(func_env)
+    }
+
+    /// Consumes the [`WasiEnvBuilder`] and produces a [`WasiEnvInit`], which
+    /// can be used to construct a new [`WasiEnv`].
+    ///
+    /// Returns the error from `WasiFs::new` if there's an error
+    // FIXME: use a proper custom error type
+    #[allow(clippy::result_large_err)]
+    pub fn instantiate(
+        self,
+        module: Module,
+        store: &mut impl AsStoreMut,
+    ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
+        self.instantiate_ext(module, ModuleHash::random(), store)
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub fn instantiate_ext(
+        self,
+        module: Module,
+        module_hash: ModuleHash,
+        store: &mut impl AsStoreMut,
+    ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
+        let init = self.build_init()?;
+        WasiEnv::instantiate(init, module, module_hash, store)
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub fn run(self, module: Module) -> Result<(), WasiRuntimeError> {
+        self.run_ext(module, ModuleHash::random())
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub fn run_ext(self, module: Module, module_hash: ModuleHash) -> Result<(), WasiRuntimeError> {
+        let mut store = wasmer::Store::default();
+        self.run_with_store_ext(module, module_hash, &mut store)
+    }
+
+    #[allow(clippy::result_large_err)]
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn run_with_store(self, module: Module, store: &mut Store) -> Result<(), WasiRuntimeError> {
+        self.run_with_store_ext(module, ModuleHash::random(), store)
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub fn run_with_store_ext(
+        self,
+        module: Module,
+        module_hash: ModuleHash,
+        store: &mut Store,
+    ) -> Result<(), WasiRuntimeError> {
+        // If no handle or runtime exists then create one
+        #[cfg(feature = "sys-thread")]
+        let _guard = if tokio::runtime::Handle::try_current().is_err() {
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+            Some(runtime)
+        } else {
+            None
+        };
+        #[cfg(feature = "sys-thread")]
+        let _guard = _guard.as_ref().map(|r| r.enter());
+
+        if self.capabilites.threading.enable_asynchronous_threading {
+            tracing::warn!(
+                "The enable_asynchronous_threading capability is enabled. Use WasiEnvBuilder::run_with_store_async() to avoid spurious errors.",
+            );
+        }
+
+        let (instance, env) = self.instantiate_ext(module, module_hash, store)?;
+
+        // Bootstrap the process
+        // Unsafe: The bootstrap must be executed in the same thread that runs the
+        //         actual WASM code
+        let rewind_state = unsafe { env.bootstrap(store)? };
+        if rewind_state.is_some() {
+            let mut ctx = env.env.clone().into_mut(store);
+            rewind_ext2(&mut ctx, rewind_state)
+                .map_err(|exit| WasiRuntimeError::Wasi(WasiError::Exit(exit)))?;
+        }
+
+        let start = instance.exports.get_function("_start")?;
+        env.data(&store).thread.set_status_running();
+
+        let result = crate::run_wasi_func_start(start, store);
+        let (result, exit_code) = super::wasi_exit_code(result);
+
+        let pid = env.data(&store).pid();
+        let tid = env.data(&store).tid();
+        tracing::trace!(
+            %pid,
+            %tid,
+            %exit_code,
+            error=result.as_ref().err().map(|e| e as &dyn std::error::Error),
+            "main exit",
+        );
+
+        env.on_exit(store, Some(exit_code));
+
+        result
+    }
+
+    /// Start the WASI executable with async threads enabled.
+    #[allow(clippy::result_large_err)]
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn run_with_store_async(
+        self,
+        module: Module,
+        module_hash: ModuleHash,
+        mut store: Store,
+    ) -> Result<(), WasiRuntimeError> {
+        let (_, env) = self.instantiate_ext(module, module_hash, &mut store)?;
+        env.run_async(store)?;
+        Ok(())
+    }
+}
+
+pub(crate) fn conv_env_vars(envs: Vec<(String, Vec<u8>)>) -> Vec<Vec<u8>> {
+    envs.into_iter()
+        .map(|(key, value)| {
+            let mut env = Vec::with_capacity(key.len() + value.len() + 1);
+            env.extend_from_slice(key.as_bytes());
+            env.push(b'=');
+            env.extend_from_slice(&value);
+
+            env
+        })
+        .collect()
+}
+
+/// Builder for preopened directories.
+#[derive(Debug, Default)]
+pub struct PreopenDirBuilder {
+    path: Option<PathBuf>,
+    alias: Option<String>,
+    read: bool,
+    write: bool,
+    create: bool,
+}
+
+/// The built version of `PreopenDirBuilder`
+#[derive(Debug, Clone, Default)]
+pub(crate) struct PreopenedDir {
+    pub(crate) path: PathBuf,
+    pub(crate) alias: Option<String>,
+    pub(crate) read: bool,
+    pub(crate) write: bool,
+    pub(crate) create: bool,
+}
+
+impl PreopenDirBuilder {
+    /// Create an empty builder
+    pub(crate) fn new() -> Self {
+        PreopenDirBuilder::default()
+    }
+
+    /// Point the preopened directory to the path given by `po_dir`
+    pub fn directory<FilePath>(&mut self, po_dir: FilePath) -> &mut Self
+    where
+        FilePath: AsRef<Path>,
+    {
+        let path = po_dir.as_ref();
+        self.path = Some(path.to_path_buf());
+
+        self
+    }
+
+    /// Make this preopened directory appear to the WASI program as `alias`
+    pub fn alias(&mut self, alias: &str) -> &mut Self {
+        // We mount at preopened dirs at `/` by default and multiple `/` in a row
+        // are equal to a single `/`.
+        let alias = alias.trim_start_matches('/');
+        self.alias = Some(alias.to_string());
+
+        self
+    }
+
+    /// Set read permissions affecting files in the directory
+    pub fn read(&mut self, toggle: bool) -> &mut Self {
+        self.read = toggle;
+
+        self
+    }
+
+    /// Set write permissions affecting files in the directory
+    pub fn write(&mut self, toggle: bool) -> &mut Self {
+        self.write = toggle;
+
+        self
+    }
+
+    /// Set create permissions affecting files in the directory
+    ///
+    /// Create implies `write` permissions
+    pub fn create(&mut self, toggle: bool) -> &mut Self {
+        self.create = toggle;
+        if toggle {
+            self.write = true;
+        }
+
+        self
+    }
+
+    pub(crate) fn build(&self) -> Result<PreopenedDir, WasiStateCreationError> {
+        // ensure at least one is set
+        if !(self.read || self.write || self.create) {
+            return Err(WasiStateCreationError::PreopenedDirectoryError("Preopened directories must have at least one of read, write, create permissions set".to_string()));
+        }
+
+        if self.path.is_none() {
+            return Err(WasiStateCreationError::PreopenedDirectoryError(
+                "Preopened directories must point to a host directory".to_string(),
+            ));
+        }
+        let path = self.path.clone().unwrap();
+
+        /*
+        if !path.exists() {
+            return Err(WasiStateCreationError::PreopenedDirectoryNotFound(path));
+        }
+        */
+
+        if let Some(alias) = &self.alias {
+            validate_mapped_dir_alias(alias)?;
+        }
+
+        Ok(PreopenedDir {
+            path,
+            alias: self.alias.clone(),
+            read: self.read,
+            write: self.write,
+            create: self.create,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn env_var_errors() {
+        #[cfg(not(target_arch = "wasm32"))]
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .unwrap();
+        #[cfg(not(target_arch = "wasm32"))]
+        let handle = runtime.handle().clone();
+        #[cfg(not(target_arch = "wasm32"))]
+        let _guard = handle.enter();
+
+        // `=` in the key is invalid.
+        assert!(
+            WasiEnv::builder("test_prog")
+                .env("HOM=E", "/home/home")
+                .build_init()
+                .is_err(),
+            "equal sign in key must be invalid"
+        );
+
+        // `\0` in the key is invalid.
+        assert!(
+            WasiEnvBuilder::new("test_prog")
+                .env("HOME\0", "/home/home")
+                .build_init()
+                .is_err(),
+            "nul in key must be invalid"
+        );
+
+        // `=` in the value is valid.
+        assert!(
+            WasiEnvBuilder::new("test_prog")
+                .env("HOME", "/home/home=home")
+                .build_init()
+                .is_ok(),
+            "equal sign in the value must be valid"
+        );
+
+        // `\0` in the value is invalid.
+        assert!(
+            WasiEnvBuilder::new("test_prog")
+                .env("HOME", "/home/home\0")
+                .build_init()
+                .is_err(),
+            "nul in value must be invalid"
+        );
+    }
+
+    #[test]
+    fn nul_character_in_args() {
+        let output = WasiEnvBuilder::new("test_prog")
+            .arg("--h\0elp")
+            .build_init();
+        let err = output.expect_err("should fail");
+        assert!(matches!(
+            err,
+            WasiStateCreationError::ArgumentContainsNulByte(_)
+        ));
+
+        let output = WasiEnvBuilder::new("test_prog")
+            .args(["--help", "--wat\0"])
+            .build_init();
+        let err = output.expect_err("should fail");
+        assert!(matches!(
+            err,
+            WasiStateCreationError::ArgumentContainsNulByte(_)
+        ));
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/env.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/env.rs
new file mode 100644
index 0000000..6f7237e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/env.rs
@@ -0,0 +1,1259 @@
+use std::{
+    collections::HashMap,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
+
+use derivative::Derivative;
+use futures::future::BoxFuture;
+use rand::Rng;
+use virtual_fs::{FileSystem, FsError, StaticFile, VirtualFile};
+use virtual_net::DynVirtualNetworking;
+use wasmer::{
+    AsStoreMut, AsStoreRef, FunctionEnvMut, Global, Imports, Instance, Memory, MemoryType,
+    MemoryView, Module, TypedFunction,
+};
+use wasmer_wasix_types::{
+    types::Signal,
+    wasi::{Errno, ExitCode, Snapshot0Clockid},
+    wasix::ThreadStartType,
+};
+
+#[cfg(feature = "journal")]
+use crate::journal::{DynJournal, JournalEffector, SnapshotTrigger};
+use crate::{
+    bin_factory::{BinFactory, BinaryPackage},
+    capabilities::Capabilities,
+    fs::{WasiFsRoot, WasiInodes},
+    import_object_for_all_wasi_versions,
+    os::task::{
+        control_plane::ControlPlaneError,
+        process::{WasiProcess, WasiProcessId},
+        thread::{WasiMemoryLayout, WasiThread, WasiThreadHandle, WasiThreadId},
+    },
+    runtime::{
+        module_cache::ModuleHash, resolver::PackageSpecifier, task_manager::InlineWaker,
+        SpawnMemoryType,
+    },
+    syscalls::platform_clock_time_get,
+    Runtime, VirtualTaskManager, WasiControlPlane, WasiEnvBuilder, WasiError, WasiFunctionEnv,
+    WasiResult, WasiRuntimeError, WasiStateCreationError, WasiVFork,
+};
+
+pub(crate) use super::handles::*;
+use super::WasiState;
+
+/// Various [`TypedFunction`] and [`Global`] handles for an active WASI(X) instance.
+///
+/// Used to access and modify runtime state.
+// TODO: make fields private
+#[derive(Derivative, Clone)]
+#[derivative(Debug)]
+pub struct WasiInstanceHandles {
+    // TODO: the two fields below are instance specific, while all others are module specific.
+    // Should be split up.
+    /// Represents a reference to the memory
+    pub(crate) memory: Memory,
+    pub(crate) instance: wasmer::Instance,
+
+    /// Points to the current location of the memory stack pointer
+    pub(crate) stack_pointer: Option<Global>,
+
+    /// Main function that will be invoked (name = "_start")
+    #[derivative(Debug = "ignore")]
+    pub(crate) start: Option<TypedFunction<(), ()>>,
+
+    /// Function thats invoked to initialize the WASM module (name = "_initialize")
+    #[derivative(Debug = "ignore")]
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) initialize: Option<TypedFunction<(), ()>>,
+
+    /// Represents the callback for spawning a thread (name = "wasi_thread_start")
+    /// (due to limitations with i64 in browsers the parameters are broken into i32 pairs)
+    /// [this takes a user_data field]
+    #[derivative(Debug = "ignore")]
+    pub(crate) thread_spawn: Option<TypedFunction<(i32, i32), ()>>,
+
+    /// Represents the callback for signals (name = "__wasm_signal")
+    /// Signals are triggered asynchronously at idle times of the process
+    #[derivative(Debug = "ignore")]
+    pub(crate) signal: Option<TypedFunction<i32, ()>>,
+
+    /// Flag that indicates if the signal callback has been set by the WASM
+    /// process - if it has not been set then the runtime behaves differently
+    /// when a CTRL-C is pressed.
+    pub(crate) signal_set: bool,
+
+    /// asyncify_start_unwind(data : i32): call this to start unwinding the
+    /// stack from the current location. "data" must point to a data
+    /// structure as described above (with fields containing valid data).
+    #[derivative(Debug = "ignore")]
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_start_unwind: Option<TypedFunction<i32, ()>>,
+
+    /// asyncify_stop_unwind(): call this to note that unwinding has
+    /// concluded. If no other code will run before you start to rewind,
+    /// this is not strictly necessary, however, if you swap between
+    /// coroutines, or even just want to run some normal code during a
+    /// "sleep", then you must call this at the proper time. Otherwise,
+    /// the code will think it is still unwinding when it should not be,
+    /// which means it will keep unwinding in a meaningless way.
+    #[derivative(Debug = "ignore")]
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_stop_unwind: Option<TypedFunction<(), ()>>,
+
+    /// asyncify_start_rewind(data : i32): call this to start rewinding the
+    /// stack vack up to the location stored in the provided data. This prepares
+    /// for the rewind; to start it, you must call the first function in the
+    /// call stack to be unwound.
+    #[derivative(Debug = "ignore")]
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_start_rewind: Option<TypedFunction<i32, ()>>,
+
+    /// asyncify_stop_rewind(): call this to note that rewinding has
+    /// concluded, and normal execution can resume.
+    #[derivative(Debug = "ignore")]
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub(crate) asyncify_stop_rewind: Option<TypedFunction<(), ()>>,
+
+    /// asyncify_get_state(): call this to get the current value of the
+    /// internal "__asyncify_state" variable as described above.
+    /// It can be used to distinguish between unwinding/rewinding and normal
+    /// calls, so that you know when to start an asynchronous operation and
+    /// when to propagate results back.
+    #[allow(dead_code)]
+    #[derivative(Debug = "ignore")]
+    pub(crate) asyncify_get_state: Option<TypedFunction<(), i32>>,
+}
+
+impl WasiInstanceHandles {
+    pub fn new(memory: Memory, store: &impl AsStoreRef, instance: Instance) -> Self {
+        WasiInstanceHandles {
+            memory,
+            stack_pointer: instance
+                .exports
+                .get_global("__stack_pointer")
+                .map(|a| a.clone())
+                .ok(),
+            start: instance.exports.get_typed_function(store, "_start").ok(),
+            initialize: instance
+                .exports
+                .get_typed_function(store, "_initialize")
+                .ok(),
+            thread_spawn: instance
+                .exports
+                .get_typed_function(store, "wasi_thread_start")
+                .ok(),
+            signal: instance
+                .exports
+                .get_typed_function(&store, "__wasm_signal")
+                .ok(),
+            signal_set: false,
+            asyncify_start_unwind: instance
+                .exports
+                .get_typed_function(store, "asyncify_start_unwind")
+                .ok(),
+            asyncify_stop_unwind: instance
+                .exports
+                .get_typed_function(store, "asyncify_stop_unwind")
+                .ok(),
+            asyncify_start_rewind: instance
+                .exports
+                .get_typed_function(store, "asyncify_start_rewind")
+                .ok(),
+            asyncify_stop_rewind: instance
+                .exports
+                .get_typed_function(store, "asyncify_stop_rewind")
+                .ok(),
+            asyncify_get_state: instance
+                .exports
+                .get_typed_function(store, "asyncify_get_state")
+                .ok(),
+            instance,
+        }
+    }
+
+    pub fn module(&self) -> &Module {
+        self.instance.module()
+    }
+
+    pub fn module_clone(&self) -> Module {
+        self.instance.module().clone()
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory_view<'a>(&'a self, store: &'a (impl AsStoreRef + ?Sized)) -> MemoryView<'a> {
+        self.memory.view(store)
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub fn memory(&self) -> &Memory {
+        &self.memory
+    }
+
+    /// Copy the lazy reference so that when it's initialized during the
+    /// export phase, all the other references get a copy of it
+    pub fn memory_clone(&self) -> Memory {
+        self.memory.clone()
+    }
+
+    pub fn instance(&self) -> &Instance {
+        &self.instance
+    }
+}
+
+/// Data required to construct a [`WasiEnv`].
+#[derive(Debug)]
+pub struct WasiEnvInit {
+    pub(crate) state: WasiState,
+    pub runtime: Arc<dyn Runtime + Send + Sync>,
+    pub webc_dependencies: Vec<BinaryPackage>,
+    pub mapped_commands: HashMap<String, PathBuf>,
+    pub bin_factory: BinFactory,
+    pub capabilities: Capabilities,
+
+    pub control_plane: WasiControlPlane,
+    pub memory_ty: Option<MemoryType>,
+    pub process: Option<WasiProcess>,
+    pub thread: Option<WasiThreadHandle>,
+
+    /// Whether to call the `_initialize` function in the WASI module.
+    /// Will be true for regular new instances, but false for threads.
+    pub call_initialize: bool,
+
+    /// Indicates if the calling environment is capable of deep sleeping
+    pub can_deep_sleep: bool,
+
+    /// Indicates if extra tracing should be output
+    pub extra_tracing: bool,
+
+    /// Additional functionality provided to the WASIX instance, besides the
+    /// normal WASIX syscalls.
+    pub additional_imports: Imports,
+
+    /// Indicates triggers that will cause a snapshot to be taken
+    #[cfg(feature = "journal")]
+    pub snapshot_on: Vec<SnapshotTrigger>,
+}
+
+impl WasiEnvInit {
+    pub fn duplicate(&self) -> Self {
+        let inodes = WasiInodes::new();
+
+        // TODO: preserve preopens?
+        let fs =
+            crate::fs::WasiFs::new_with_preopen(&inodes, &[], &[], self.state.fs.root_fs.clone())
+                .unwrap();
+
+        Self {
+            state: WasiState {
+                secret: rand::thread_rng().gen::<[u8; 32]>(),
+                inodes,
+                fs,
+                futexs: Default::default(),
+                clock_offset: std::sync::Mutex::new(
+                    self.state.clock_offset.lock().unwrap().clone(),
+                ),
+                args: self.state.args.clone(),
+                envs: std::sync::Mutex::new(self.state.envs.lock().unwrap().deref().clone()),
+                preopen: self.state.preopen.clone(),
+            },
+            runtime: self.runtime.clone(),
+            webc_dependencies: self.webc_dependencies.clone(),
+            mapped_commands: self.mapped_commands.clone(),
+            bin_factory: self.bin_factory.clone(),
+            capabilities: self.capabilities.clone(),
+            control_plane: self.control_plane.clone(),
+            memory_ty: None,
+            process: None,
+            thread: None,
+            call_initialize: self.call_initialize,
+            can_deep_sleep: self.can_deep_sleep,
+            extra_tracing: false,
+            #[cfg(feature = "journal")]
+            snapshot_on: self.snapshot_on.clone(),
+            additional_imports: self.additional_imports.clone(),
+        }
+    }
+}
+
+/// The environment provided to the WASI imports.
+pub struct WasiEnv {
+    pub control_plane: WasiControlPlane,
+    /// Represents the process this environment is attached to
+    pub process: WasiProcess,
+    /// Represents the thread this environment is attached to
+    pub thread: WasiThread,
+    /// Represents the layout of the memory
+    pub layout: WasiMemoryLayout,
+    /// Represents a fork of the process that is currently in play
+    pub vfork: Option<WasiVFork>,
+    /// Seed used to rotate around the events returned by `poll_oneoff`
+    pub poll_seed: u64,
+    /// Shared state of the WASI system. Manages all the data that the
+    /// executing WASI program can see.
+    pub(crate) state: Arc<WasiState>,
+    /// Binary factory attached to this environment
+    pub bin_factory: BinFactory,
+    /// List of the handles that are owned by this context
+    /// (this can be used to ensure that threads own themselves or others)
+    pub owned_handles: Vec<WasiThreadHandle>,
+    /// Implementation of the WASI runtime.
+    pub runtime: Arc<dyn Runtime + Send + Sync + 'static>,
+
+    pub capabilities: Capabilities,
+
+    /// Is this environment capable and setup for deep sleeping
+    pub enable_deep_sleep: bool,
+
+    /// Enables the snap shotting functionality
+    pub enable_journal: bool,
+
+    /// Enables an exponential backoff of the process CPU usage when there
+    /// are no active run tokens (when set holds the maximum amount of
+    /// time that it will pause the CPU)
+    pub enable_exponential_cpu_backoff: Option<Duration>,
+
+    /// Flag that indicatees if the environment is currently replaying the journal
+    /// (and hence it should not record new events)
+    pub replaying_journal: bool,
+
+    /// Flag that indicates the cleanup of the environment is to be disabled
+    /// (this is normally used so that the instance can be reused later on)
+    pub(crate) disable_fs_cleanup: bool,
+
+    /// Inner functions and references that are loaded before the environment starts
+    /// (inner is not safe to send between threads and so it is private and will
+    ///  not be cloned when `WasiEnv` is cloned)
+    /// TODO: We should move this outside of `WasiEnv` with some refactoring
+    inner: WasiInstanceHandlesPointer,
+}
+
+impl std::fmt::Debug for WasiEnv {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "env(pid={}, tid={})", self.pid().raw(), self.tid().raw())
+    }
+}
+
+impl Clone for WasiEnv {
+    fn clone(&self) -> Self {
+        Self {
+            control_plane: self.control_plane.clone(),
+            process: self.process.clone(),
+            poll_seed: self.poll_seed,
+            thread: self.thread.clone(),
+            layout: self.layout.clone(),
+            vfork: self.vfork.clone(),
+            state: self.state.clone(),
+            bin_factory: self.bin_factory.clone(),
+            inner: Default::default(),
+            owned_handles: self.owned_handles.clone(),
+            runtime: self.runtime.clone(),
+            capabilities: self.capabilities.clone(),
+            enable_deep_sleep: self.enable_deep_sleep,
+            enable_journal: self.enable_journal,
+            enable_exponential_cpu_backoff: self.enable_exponential_cpu_backoff,
+            replaying_journal: self.replaying_journal,
+            disable_fs_cleanup: self.disable_fs_cleanup,
+        }
+    }
+}
+
+impl WasiEnv {
+    /// Construct a new [`WasiEnvBuilder`] that allows customizing an environment.
+    pub fn builder(program_name: impl Into<String>) -> WasiEnvBuilder {
+        WasiEnvBuilder::new(program_name)
+    }
+
+    /// Forking the WasiState is used when either fork or vfork is called
+    pub fn fork(&self) -> Result<(Self, WasiThreadHandle), ControlPlaneError> {
+        let process = self.control_plane.new_process(self.process.module_hash)?;
+        let handle = process.new_thread(self.layout.clone(), ThreadStartType::MainThread)?;
+
+        let thread = handle.as_thread();
+        thread.copy_stack_from(&self.thread);
+
+        let state = Arc::new(self.state.fork());
+
+        let bin_factory = self.bin_factory.clone();
+
+        let new_env = Self {
+            control_plane: self.control_plane.clone(),
+            process,
+            thread,
+            layout: self.layout.clone(),
+            vfork: None,
+            poll_seed: 0,
+            bin_factory,
+            state,
+            inner: Default::default(),
+            owned_handles: Vec::new(),
+            runtime: self.runtime.clone(),
+            capabilities: self.capabilities.clone(),
+            enable_deep_sleep: self.enable_deep_sleep,
+            enable_journal: self.enable_journal,
+            enable_exponential_cpu_backoff: self.enable_exponential_cpu_backoff,
+            replaying_journal: false,
+            disable_fs_cleanup: self.disable_fs_cleanup,
+        };
+        Ok((new_env, handle))
+    }
+
+    pub fn pid(&self) -> WasiProcessId {
+        self.process.pid()
+    }
+
+    pub fn tid(&self) -> WasiThreadId {
+        self.thread.tid()
+    }
+
+    /// Re-initializes this environment so that it can be executed again
+    pub fn reinit(&mut self) -> Result<(), WasiStateCreationError> {
+        // If the cleanup logic is enabled then we need to rebuild the
+        // file descriptors which would have been destroyed when the
+        // main thread exited
+        if !self.disable_fs_cleanup {
+            // First we clear any open files as the descriptors would
+            // otherwise clash
+            if let Ok(mut map) = self.state.fs.fd_map.write() {
+                map.clear();
+            }
+            self.state.fs.preopen_fds.write().unwrap().clear();
+            self.state.fs.next_fd.set_val(3);
+            *self.state.fs.current_dir.lock().unwrap() = "/".to_string();
+
+            // We need to rebuild the basic file descriptors
+            self.state.fs.create_stdin(&self.state.inodes);
+            self.state.fs.create_stdout(&self.state.inodes);
+            self.state.fs.create_stderr(&self.state.inodes);
+            self.state
+                .fs
+                .create_rootfd()
+                .map_err(WasiStateCreationError::WasiFsSetupError)?;
+            self.state
+                .fs
+                .create_preopens(&self.state.inodes, true)
+                .map_err(WasiStateCreationError::WasiFsSetupError)?;
+        }
+
+        // The process and thread state need to be reset
+        self.process = WasiProcess::new(
+            self.process.pid,
+            self.process.module_hash,
+            self.process.compute.clone(),
+        );
+        self.thread = WasiThread::new(
+            self.thread.pid(),
+            self.thread.tid(),
+            self.thread.is_main(),
+            self.process.finished.clone(),
+            self.process.compute.must_upgrade().register_task()?,
+            self.thread.memory_layout().clone(),
+            self.thread.thread_start_type(),
+        );
+
+        Ok(())
+    }
+
+    /// Returns true if this module is capable of deep sleep
+    /// (needs asyncify to unwind and rewin)
+    ///
+    /// # Safety
+    ///
+    /// This function should only be called from within a syscall
+    /// as it accessed objects that are a thread local (functions)
+    pub unsafe fn capable_of_deep_sleep(&self) -> bool {
+        if !self.control_plane.config().enable_asynchronous_threading {
+            return false;
+        }
+        let inner = self.inner();
+        inner.asyncify_get_state.is_some()
+            && inner.asyncify_start_rewind.is_some()
+            && inner.asyncify_start_unwind.is_some()
+    }
+
+    /// Returns true if this thread can go into a deep sleep
+    pub fn layout(&self) -> &WasiMemoryLayout {
+        &self.layout
+    }
+
+    #[allow(clippy::result_large_err)]
+    pub(crate) fn from_init(
+        init: WasiEnvInit,
+        module_hash: ModuleHash,
+    ) -> Result<Self, WasiRuntimeError> {
+        let process = if let Some(p) = init.process {
+            p
+        } else {
+            init.control_plane.new_process(module_hash)?
+        };
+
+        #[cfg(feature = "journal")]
+        {
+            process.inner.0.lock().unwrap().snapshot_on = init.snapshot_on.into_iter().collect();
+        }
+
+        let layout = WasiMemoryLayout::default();
+        let thread = if let Some(t) = init.thread {
+            t
+        } else {
+            process.new_thread(layout.clone(), ThreadStartType::MainThread)?
+        };
+
+        let mut env = Self {
+            control_plane: init.control_plane,
+            process,
+            thread: thread.as_thread(),
+            layout,
+            vfork: None,
+            poll_seed: 0,
+            state: Arc::new(init.state),
+            inner: Default::default(),
+            owned_handles: Vec::new(),
+            #[cfg(feature = "journal")]
+            enable_journal: init.runtime.active_journal().is_some(),
+            #[cfg(not(feature = "journal"))]
+            enable_journal: false,
+            replaying_journal: false,
+            enable_deep_sleep: init.capabilities.threading.enable_asynchronous_threading,
+            enable_exponential_cpu_backoff: init
+                .capabilities
+                .threading
+                .enable_exponential_cpu_backoff,
+            runtime: init.runtime,
+            bin_factory: init.bin_factory,
+            capabilities: init.capabilities,
+            disable_fs_cleanup: false,
+        };
+        env.owned_handles.push(thread);
+
+        // TODO: should not be here - should be callers responsibility!
+        for pkg in &init.webc_dependencies {
+            env.use_package(pkg)?;
+        }
+
+        #[cfg(feature = "sys")]
+        env.map_commands(init.mapped_commands.clone())?;
+
+        Ok(env)
+    }
+
+    // FIXME: use custom error type
+    #[allow(clippy::result_large_err)]
+    pub(crate) fn instantiate(
+        mut init: WasiEnvInit,
+        module: Module,
+        module_hash: ModuleHash,
+        store: &mut impl AsStoreMut,
+    ) -> Result<(Instance, WasiFunctionEnv), WasiRuntimeError> {
+        let call_initialize = init.call_initialize;
+        let spawn_type = init.memory_ty.take();
+
+        if init.extra_tracing {
+            for import in module.imports() {
+                tracing::trace!("import {}.{}", import.module(), import.name());
+            }
+        }
+
+        let additional_imports = init.additional_imports.clone();
+
+        let env = Self::from_init(init, module_hash)?;
+        let pid = env.process.pid();
+
+        let mut store = store.as_store_mut();
+
+        let tasks = env.runtime.task_manager().clone();
+        let mut func_env = WasiFunctionEnv::new(&mut store, env);
+
+        // Determine if shared memory needs to be created and imported
+        let shared_memory = module.imports().memories().next().map(|a| *a.ty());
+
+        // Determine if we are going to create memory and import it or just rely on self creation of memory
+        let spawn_type = if let Some(t) = spawn_type {
+            SpawnMemoryType::CreateMemoryOfType(t)
+        } else {
+            match shared_memory {
+                Some(ty) => SpawnMemoryType::CreateMemoryOfType(ty),
+                None => SpawnMemoryType::CreateMemory,
+            }
+        };
+        let memory = tasks.build_memory(&mut store, spawn_type)?;
+
+        // Let's instantiate the module with the imports.
+        let (mut import_object, instance_init_callback) =
+            import_object_for_all_wasi_versions(&module, &mut store, &func_env.env);
+
+        for ((namespace, name), value) in &additional_imports {
+            // Note: We don't want to let downstream users override WASIX
+            // syscalls
+            if !import_object.exists(&namespace, &name) {
+                import_object.define(&namespace, &name, value);
+            }
+        }
+
+        let imported_memory = if let Some(memory) = memory {
+            import_object.define("env", "memory", memory.clone());
+            Some(memory)
+        } else {
+            None
+        };
+
+        // Construct the instance.
+        let instance = match Instance::new(&mut store, &module, &import_object) {
+            Ok(a) => a,
+            Err(err) => {
+                tracing::error!(
+                    %pid,
+                    error = &err as &dyn std::error::Error,
+                    "Instantiation failed",
+                );
+                func_env
+                    .data(&store)
+                    .blocking_on_exit(Some(Errno::Noexec.into()));
+                return Err(err.into());
+            }
+        };
+
+        // Run initializers.
+        instance_init_callback(&instance, &store).unwrap();
+
+        // Initialize the WASI environment
+        if let Err(err) =
+            func_env.initialize_with_memory(&mut store, instance.clone(), imported_memory, true)
+        {
+            tracing::error!(
+                %pid,
+                error = &err as &dyn std::error::Error,
+                "Initialization failed",
+            );
+            func_env
+                .data(&store)
+                .blocking_on_exit(Some(Errno::Noexec.into()));
+            return Err(err.into());
+        }
+
+        // If this module exports an _initialize function, run that first.
+        if call_initialize {
+            if let Ok(initialize) = instance.exports.get_function("_initialize") {
+                if let Err(err) = crate::run_wasi_func_start(initialize, &mut store) {
+                    func_env
+                        .data(&store)
+                        .blocking_on_exit(Some(Errno::Noexec.into()));
+                    return Err(err);
+                }
+            }
+        }
+
+        Ok((instance, func_env))
+    }
+
+    /// Returns a copy of the current runtime implementation for this environment
+    pub fn runtime(&self) -> &(dyn Runtime + Send + Sync) {
+        self.runtime.deref()
+    }
+
+    /// Returns a copy of the current tasks implementation for this environment
+    pub fn tasks(&self) -> &Arc<dyn VirtualTaskManager> {
+        self.runtime.task_manager()
+    }
+
+    pub fn fs_root(&self) -> &WasiFsRoot {
+        &self.state.fs.root_fs
+    }
+
+    /// Overrides the runtime implementation for this environment
+    pub fn set_runtime<R>(&mut self, runtime: R)
+    where
+        R: Runtime + Send + Sync + 'static,
+    {
+        self.runtime = Arc::new(runtime);
+    }
+
+    /// Returns the number of active threads
+    pub fn active_threads(&self) -> u32 {
+        self.process.active_threads()
+    }
+
+    /// Porcesses any signals that are batched up or any forced exit codes
+    pub fn process_signals_and_exit(ctx: &mut FunctionEnvMut<'_, Self>) -> WasiResult<bool> {
+        // If a signal handler has never been set then we need to handle signals
+        // differently
+        let env = ctx.data();
+        let inner = env
+            .try_inner()
+            .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        if !inner.signal_set {
+            let signals = env.thread.pop_signals();
+            if !signals.is_empty() {
+                for sig in signals {
+                    if sig == Signal::Sigint
+                        || sig == Signal::Sigquit
+                        || sig == Signal::Sigkill
+                        || sig == Signal::Sigabrt
+                    {
+                        let exit_code = env.thread.set_or_get_exit_code_for_signal(sig);
+                        return Err(WasiError::Exit(exit_code));
+                    } else {
+                        tracing::trace!(pid=%env.pid(), ?sig, "Signal ignored");
+                    }
+                }
+                return Ok(Ok(true));
+            }
+        }
+
+        // Check for forced exit
+        if let Some(forced_exit) = env.should_exit() {
+            return Err(WasiError::Exit(forced_exit));
+        }
+
+        Self::process_signals(ctx)
+    }
+
+    /// Porcesses any signals that are batched up
+    pub(crate) fn process_signals(ctx: &mut FunctionEnvMut<'_, Self>) -> WasiResult<bool> {
+        // If a signal handler has never been set then we need to handle signals
+        // differently
+        let env = ctx.data();
+        let inner = env
+            .try_inner()
+            .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        if !inner.signal_set {
+            return Ok(Ok(false));
+        }
+
+        // Check for any signals that we need to trigger
+        // (but only if a signal handler is registered)
+        let ret = if inner.signal.as_ref().is_some() {
+            let signals = env.thread.pop_signals();
+            Self::process_signals_internal(ctx, signals)?
+        } else {
+            false
+        };
+
+        Ok(Ok(ret))
+    }
+
+    pub(crate) fn process_signals_internal(
+        ctx: &mut FunctionEnvMut<'_, Self>,
+        mut signals: Vec<Signal>,
+    ) -> Result<bool, WasiError> {
+        let env = ctx.data();
+        let inner = env
+            .try_inner()
+            .ok_or_else(|| WasiError::Exit(Errno::Fault.into()))?;
+        if let Some(handler) = inner.signal.clone() {
+            // We might also have signals that trigger on timers
+            let mut now = 0;
+            {
+                let mut has_signal_interval = false;
+                let inner = env.process.inner.0.lock().unwrap();
+                if !inner.signal_intervals.is_empty() {
+                    now = platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000).unwrap()
+                        as u128;
+                    for signal in inner.signal_intervals.values() {
+                        let elapsed = now - signal.last_signal;
+                        if elapsed >= signal.interval.as_nanos() {
+                            has_signal_interval = true;
+                            break;
+                        }
+                    }
+                }
+                if has_signal_interval {
+                    let mut inner = env.process.inner.0.lock().unwrap();
+                    for signal in inner.signal_intervals.values_mut() {
+                        let elapsed = now - signal.last_signal;
+                        if elapsed >= signal.interval.as_nanos() {
+                            signal.last_signal = now;
+                            signals.push(signal.signal);
+                        }
+                    }
+                }
+            }
+
+            for signal in signals {
+                tracing::trace!(
+                    pid=%ctx.data().pid(),
+                    ?signal,
+                    "Processing signal",
+                );
+                if let Err(err) = handler.call(ctx, signal as i32) {
+                    match err.downcast::<WasiError>() {
+                        Ok(wasi_err) => {
+                            tracing::warn!(
+                                pid=%ctx.data().pid(),
+                                wasi_err=&wasi_err as &dyn std::error::Error,
+                                "signal handler wasi error",
+                            );
+                            return Err(wasi_err);
+                        }
+                        Err(runtime_err) => {
+                            // anything other than a kill command should report
+                            // the error, killed things may not gracefully close properly
+                            if signal != Signal::Sigkill {
+                                tracing::warn!(
+                                    pid=%ctx.data().pid(),
+                                    runtime_err=&runtime_err as &dyn std::error::Error,
+                                    "signal handler runtime error",
+                                );
+                            }
+                            return Err(WasiError::Exit(Errno::Intr.into()));
+                        }
+                    }
+                }
+            }
+            Ok(true)
+        } else {
+            tracing::trace!("no signal handler");
+            Ok(false)
+        }
+    }
+
+    /// Returns an exit code if the thread or process has been forced to exit
+    pub fn should_exit(&self) -> Option<ExitCode> {
+        // Check for forced exit
+        if let Some(forced_exit) = self.thread.try_join() {
+            return Some(forced_exit.unwrap_or_else(|err| {
+                tracing::debug!(
+                    error = &*err as &dyn std::error::Error,
+                    "exit runtime error",
+                );
+                Errno::Child.into()
+            }));
+        }
+        if let Some(forced_exit) = self.process.try_join() {
+            return Some(forced_exit.unwrap_or_else(|err| {
+                tracing::debug!(
+                    error = &*err as &dyn std::error::Error,
+                    "exit runtime error",
+                );
+                Errno::Child.into()
+            }));
+        }
+        None
+    }
+
+    /// Accesses the virtual networking implementation
+    pub fn net(&self) -> &DynVirtualNetworking {
+        self.runtime.networking()
+    }
+
+    /// Providers safe access to the initialized part of WasiEnv
+    /// (it must be initialized before it can be used)
+    /// This has been marked as unsafe as it will panic if its executed
+    /// on the wrong thread or before the inner is set
+    pub(crate) unsafe fn inner(&self) -> WasiInstanceGuard<'_> {
+        self.inner.get().expect(
+            "You must initialize the WasiEnv before using it and can not pass it between threads",
+        )
+    }
+
+    /// Providers safe access to the initialized part of WasiEnv
+    pub(crate) fn try_inner(&self) -> Option<WasiInstanceGuard<'_>> {
+        self.inner.get()
+    }
+
+    /// Providers safe access to the initialized part of WasiEnv
+    /// (it must be initialized before it can be used)
+    pub(crate) fn try_inner_mut(&mut self) -> Option<WasiInstanceGuardMut<'_>> {
+        self.inner.get_mut()
+    }
+
+    /// Sets the inner object (this should only be called when
+    /// creating the instance and eventually should be moved out
+    /// of the WasiEnv)
+    #[doc(hidden)]
+    pub(crate) fn set_inner(&mut self, handles: WasiInstanceHandles) {
+        self.inner.set(handles)
+    }
+
+    /// Swaps this inner with the WasiEnvironment of another, this
+    /// is used by the vfork so that the inner handles can be restored
+    /// after the vfork finishes.
+    #[doc(hidden)]
+    pub(crate) fn swap_inner(&mut self, other: &mut Self) {
+        std::mem::swap(&mut self.inner, &mut other.inner);
+    }
+
+    /// Tries to clone the instance from this environment
+    pub fn try_clone_instance(&self) -> Option<Instance> {
+        self.inner.get().map(|i| i.instance.clone())
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub(crate) fn try_memory(&self) -> Option<WasiInstanceGuardMemory<'_>> {
+        self.try_inner().map(|i| i.memory())
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    /// This has been marked as unsafe as it will panic if its executed
+    /// on the wrong thread or before the inner is set
+    pub(crate) unsafe fn memory(&self) -> WasiInstanceGuardMemory<'_> {
+        self.try_memory().expect(
+            "You must initialize the WasiEnv before using it and can not pass it between threads",
+        )
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    pub(crate) fn try_memory_view<'a>(
+        &self,
+        store: &'a (impl AsStoreRef + ?Sized),
+    ) -> Option<MemoryView<'a>> {
+        self.try_memory().map(|m| m.view(store))
+    }
+
+    /// Providers safe access to the memory
+    /// (it must be initialized before it can be used)
+    /// This has been marked as unsafe as it will panic if its executed
+    /// on the wrong thread or before the inner is set
+    pub(crate) unsafe fn memory_view<'a>(
+        &self,
+        store: &'a (impl AsStoreRef + ?Sized),
+    ) -> MemoryView<'a> {
+        self.try_memory_view(store).expect(
+            "You must initialize the WasiEnv before using it and can not pass it between threads",
+        )
+    }
+
+    /// Copy the lazy reference so that when it's initialized during the
+    /// export phase, all the other references get a copy of it
+    #[allow(dead_code)]
+    pub(crate) fn try_memory_clone(&self) -> Option<Memory> {
+        self.try_inner().map(|i| i.memory_clone())
+    }
+
+    /// Get the WASI state
+    pub(crate) fn state(&self) -> &WasiState {
+        &self.state
+    }
+
+    /// Get the `VirtualFile` object at stdout
+    pub fn stdout(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.state.stdout()
+    }
+
+    /// Get the `VirtualFile` object at stderr
+    pub fn stderr(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.state.stderr()
+    }
+
+    /// Get the `VirtualFile` object at stdin
+    pub fn stdin(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.state.stdin()
+    }
+
+    /// Returns true if the process should perform snapshots or not
+    pub fn should_journal(&self) -> bool {
+        self.enable_journal && !self.replaying_journal
+    }
+
+    /// Returns the active journal or fails with an error
+    #[cfg(feature = "journal")]
+    pub fn active_journal(&self) -> Result<&DynJournal, Errno> {
+        self.runtime().active_journal().ok_or_else(|| {
+            tracing::warn!("failed to save thread exit as there is not active journal");
+            Errno::Fault
+        })
+    }
+
+    /// Returns true if a particular snapshot trigger is enabled
+    #[cfg(feature = "journal")]
+    pub fn has_snapshot_trigger(&self, trigger: SnapshotTrigger) -> bool {
+        let guard = self.process.inner.0.lock().unwrap();
+        guard.snapshot_on.contains(&trigger)
+    }
+
+    /// Returns true if a particular snapshot trigger is enabled
+    #[cfg(feature = "journal")]
+    pub fn pop_snapshot_trigger(&mut self, trigger: SnapshotTrigger) -> bool {
+        let mut guard = self.process.inner.0.lock().unwrap();
+        if trigger.only_once() {
+            guard.snapshot_on.remove(&trigger)
+        } else {
+            guard.snapshot_on.contains(&trigger)
+        }
+    }
+
+    /// Internal helper function to get a standard device handle.
+    /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
+    pub fn std_dev_get(
+        &self,
+        fd: crate::syscalls::WasiFd,
+    ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.state.std_dev_get(fd)
+    }
+
+    /// Unsafe:
+    ///
+    /// This will access the memory of the WASM process and create a view into it which is
+    /// inherently unsafe as it could corrupt the memory. Also accessing the memory is not
+    /// thread safe.
+    pub(crate) unsafe fn get_memory_and_wasi_state<'a>(
+        &'a self,
+        store: &'a impl AsStoreRef,
+        _mem_index: u32,
+    ) -> (MemoryView<'a>, &WasiState) {
+        let memory = self.memory_view(store);
+        let state = self.state.deref();
+        (memory, state)
+    }
+
+    /// Unsafe:
+    ///
+    /// This will access the memory of the WASM process and create a view into it which is
+    /// inherently unsafe as it could corrupt the memory. Also accessing the memory is not
+    /// thread safe.
+    pub(crate) unsafe fn get_memory_and_wasi_state_and_inodes<'a>(
+        &'a self,
+        store: &'a impl AsStoreRef,
+        _mem_index: u32,
+    ) -> (MemoryView<'a>, &WasiState, &WasiInodes) {
+        let memory = self.memory_view(store);
+        let state = self.state.deref();
+        let inodes = &state.inodes;
+        (memory, state, inodes)
+    }
+
+    pub(crate) fn get_wasi_state_and_inodes(&self) -> (&WasiState, &WasiInodes) {
+        let state = self.state.deref();
+        let inodes = &state.inodes;
+        (state, inodes)
+    }
+
+    /// Make all the commands in a [`BinaryPackage`] available to the WASI
+    /// instance.
+    ///
+    /// The [`BinaryPackageCommand::atom()`][cmd-atom] will be saved to
+    /// `/bin/command`.
+    ///
+    /// This will also merge the command's filesystem
+    /// ([`BinaryPackage::webc_fs`][pkg-fs]) into the current filesystem.
+    ///
+    /// [cmd-atom]: crate::bin_factory::BinaryPackageCommand::atom()
+    /// [pkg-fs]: crate::bin_factory::BinaryPackage::webc_fs
+    pub fn use_package(&self, pkg: &BinaryPackage) -> Result<(), WasiStateCreationError> {
+        tracing::trace!(packagae=%pkg.package_name, "merging package dependency into wasi environment");
+        let root_fs = &self.state.fs.root_fs;
+
+        // We first need to copy any files in the package over to the
+        // main file system
+        if let Err(e) = InlineWaker::block_on(root_fs.merge(&pkg.webc_fs)) {
+            tracing::warn!(
+                error = &e as &dyn std::error::Error,
+                "Unable to merge the package's filesystem into the main one",
+            );
+        }
+
+        // Next, make sure all commands will be available
+
+        if !pkg.commands.is_empty() {
+            let _ = root_fs.create_dir(Path::new("/bin"));
+
+            for command in &pkg.commands {
+                let path = format!("/bin/{}", command.name());
+                let path = Path::new(path.as_str());
+
+                // FIXME(Michael-F-Bryan): This is pretty sketchy.
+                // We should be using some sort of reference-counted
+                // pointer to some bytes that are either on the heap
+                // or from a memory-mapped file. However, that's not
+                // possible here because things like memfs and
+                // WasiEnv are expecting a Cow<'static, [u8]>. It's
+                // too hard to refactor those at the moment, and we
+                // were pulling the same trick before by storing an
+                // "ownership" object in the BinaryPackageCommand,
+                // so as long as packages aren't removed from the
+                // module cache it should be fine.
+                // See https://github.com/wasmerio/wasmer/issues/3875
+                let atom: &'static [u8] = unsafe { std::mem::transmute(command.atom()) };
+
+                match root_fs {
+                    WasiFsRoot::Sandbox(root_fs) => {
+                        // As a short-cut, when we are using a TmpFileSystem
+                        // we can (unsafely) add the file to the filesystem
+                        // without any copying.
+                        if let Err(err) = root_fs
+                            .new_open_options_ext()
+                            .insert_ro_file(path, atom.into())
+                        {
+                            tracing::debug!(
+                                "failed to add package [{}] command [{}] - {}",
+                                pkg.package_name,
+                                command.name(),
+                                err
+                            );
+                            continue;
+                        }
+                    }
+                    WasiFsRoot::Backing(fs) => {
+                        let mut f = fs.new_open_options().create(true).write(true).open(path)?;
+                        if let Err(e) =
+                            InlineWaker::block_on(f.copy_reference(Box::new(StaticFile::new(atom))))
+                        {
+                            tracing::warn!(
+                                error = &e as &dyn std::error::Error,
+                                "Unable to copy file reference",
+                            );
+                        }
+                    }
+                }
+
+                let mut package = pkg.clone();
+                package.entrypoint_cmd = Some(command.name().to_string());
+                self.bin_factory
+                    .set_binary(path.as_os_str().to_string_lossy().as_ref(), package);
+
+                tracing::debug!(
+                    package=%pkg.package_name,
+                    command_name=command.name(),
+                    path=%path.display(),
+                    "Injected a command into the filesystem",
+                );
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Given a list of packages, load them from the registry and make them
+    /// available.
+    pub fn uses<I>(&self, uses: I) -> Result<(), WasiStateCreationError>
+    where
+        I: IntoIterator<Item = String>,
+    {
+        let rt = self.runtime();
+
+        for package_name in uses {
+            let specifier = package_name.parse::<PackageSpecifier>().map_err(|e| {
+                WasiStateCreationError::WasiIncludePackageError(format!(
+                    "package_name={package_name}, {}",
+                    e
+                ))
+            })?;
+            let pkg = InlineWaker::block_on(BinaryPackage::from_registry(&specifier, rt)).map_err(
+                |e| {
+                    WasiStateCreationError::WasiIncludePackageError(format!(
+                        "package_name={package_name}, {}",
+                        e
+                    ))
+                },
+            )?;
+            self.use_package(&pkg)?;
+        }
+
+        Ok(())
+    }
+
+    #[cfg(feature = "sys")]
+    pub fn map_commands(
+        &self,
+        map_commands: std::collections::HashMap<String, std::path::PathBuf>,
+    ) -> Result<(), WasiStateCreationError> {
+        // Load all the mapped atoms
+        #[allow(unused_imports)]
+        use std::path::Path;
+
+        #[allow(unused_imports)]
+        use virtual_fs::FileSystem;
+
+        #[cfg(feature = "sys")]
+        for (command, target) in map_commands.iter() {
+            // Read the file
+            let file = std::fs::read(target).map_err(|err| {
+                WasiStateCreationError::WasiInheritError(format!(
+                    "failed to read local binary [{}] - {}",
+                    target.as_os_str().to_string_lossy(),
+                    err
+                ))
+            })?;
+            let file: std::borrow::Cow<'static, [u8]> = file.into();
+
+            if let WasiFsRoot::Sandbox(root_fs) = &self.state.fs.root_fs {
+                let _ = root_fs.create_dir(Path::new("/bin"));
+
+                let path = format!("/bin/{}", command);
+                let path = Path::new(path.as_str());
+                if let Err(err) = root_fs.new_open_options_ext().insert_ro_file(path, file) {
+                    tracing::debug!("failed to add atom command [{}] - {}", command, err);
+                    continue;
+                }
+            } else {
+                tracing::debug!("failed to add atom command [{}] to the root file system as it is not sandboxed", command);
+                continue;
+            }
+        }
+        Ok(())
+    }
+
+    /// Cleans up all the open files (if this is the main thread)
+    #[allow(clippy::await_holding_lock)]
+    pub fn blocking_on_exit(&self, exit_code: Option<ExitCode>) {
+        let cleanup = self.on_exit(exit_code);
+        InlineWaker::block_on(cleanup);
+    }
+
+    /// Cleans up all the open files (if this is the main thread)
+    #[allow(clippy::await_holding_lock)]
+    pub fn on_exit(&self, exit_code: Option<ExitCode>) -> BoxFuture<'static, ()> {
+        const CLEANUP_TIMEOUT: Duration = Duration::from_secs(10);
+
+        // If snap-shooting is enabled then we should record an event that the thread has exited.
+        #[cfg(feature = "journal")]
+        if self.should_journal() {
+            if let Err(err) = JournalEffector::save_thread_exit(self, self.tid(), exit_code) {
+                tracing::warn!("failed to save snapshot event for thread exit - {}", err);
+            }
+
+            if self.thread.is_main() {
+                if let Err(err) = JournalEffector::save_process_exit(self, exit_code) {
+                    tracing::warn!("failed to save snapshot event for process exit - {}", err);
+                }
+            }
+        }
+
+        // If this is the main thread then also close all the files
+        if self.thread.is_main() {
+            let process = self.process.clone();
+            let disable_fs_cleanup = self.disable_fs_cleanup;
+            let pid = self.pid();
+
+            let timeout = self.tasks().sleep_now(CLEANUP_TIMEOUT);
+            let state = self.state.clone();
+            Box::pin(async move {
+                if !disable_fs_cleanup {
+                    tracing::trace!(pid = %pid, "cleaning up open file handles");
+
+                    // Perform the clean operation using the asynchronous runtime
+                    tokio::select! {
+                        _ = timeout => {
+                            tracing::debug!(
+                                "WasiEnv::cleanup has timed out after {CLEANUP_TIMEOUT:?}"
+                            );
+                        },
+                        _ = state.fs.close_all() => { }
+                    }
+
+                    // Now send a signal that the thread is terminated
+                    process.signal_process(Signal::Sigquit);
+                }
+
+                // Terminate the process
+                let exit_code = exit_code.unwrap_or_else(|| Errno::Canceled.into());
+                process.terminate(exit_code);
+            })
+        } else {
+            Box::pin(async {})
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/func_env.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/func_env.rs
new file mode 100644
index 0000000..001f329
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/func_env.rs
@@ -0,0 +1,318 @@
+use std::sync::Arc;
+
+use tracing::trace;
+use wasmer::{
+    AsStoreMut, AsStoreRef, ExportError, FunctionEnv, Imports, Instance, Memory, Module, Store,
+};
+use wasmer_wasix_types::wasi::ExitCode;
+
+#[allow(unused_imports)]
+use crate::os::task::thread::RewindResultType;
+#[cfg(feature = "journal")]
+use crate::syscalls::restore_snapshot;
+use crate::{
+    import_object_for_all_wasi_versions,
+    runtime::SpawnMemoryType,
+    state::WasiInstanceHandles,
+    utils::{get_wasi_version, get_wasi_versions, store::restore_store_snapshot},
+    RewindStateOption, StoreSnapshot, WasiEnv, WasiError, WasiRuntimeError, WasiThreadError,
+};
+
+/// The default stack size for WASIX - the number itself is the default that compilers
+/// have used in the past when compiling WASM apps.
+///
+/// (this is only used for programs that have no stack pointer)
+const DEFAULT_STACK_SIZE: u64 = 1_048_576u64;
+const DEFAULT_STACK_BASE: u64 = DEFAULT_STACK_SIZE;
+
+#[derive(Clone, Debug)]
+pub struct WasiFunctionEnv {
+    pub env: FunctionEnv<WasiEnv>,
+}
+
+impl WasiFunctionEnv {
+    pub fn new(store: &mut impl AsStoreMut, env: WasiEnv) -> Self {
+        Self {
+            env: FunctionEnv::new(store, env),
+        }
+    }
+
+    // Creates a new environment context on a new store
+    pub fn new_with_store(
+        module: Module,
+        env: WasiEnv,
+        store_snapshot: Option<&StoreSnapshot>,
+        spawn_type: SpawnMemoryType,
+        update_layout: bool,
+    ) -> Result<(Self, Store), WasiThreadError> {
+        // Create a new store and put the memory object in it
+        // (but only if it has imported memory)
+        let mut store = env.runtime.new_store();
+        let memory = env
+            .tasks()
+            .build_memory(&mut store.as_store_mut(), spawn_type)?;
+
+        // Build the context object and import the memory
+        let mut ctx = WasiFunctionEnv::new(&mut store, env);
+        let (mut import_object, init) =
+            import_object_for_all_wasi_versions(&module, &mut store, &ctx.env);
+        if let Some(memory) = memory.clone() {
+            import_object.define("env", "memory", memory);
+        }
+
+        let instance = Instance::new(&mut store, &module, &import_object).map_err(|err| {
+            tracing::warn!("failed to create instance - {}", err);
+            WasiThreadError::InstanceCreateFailed(Box::new(err))
+        })?;
+
+        init(&instance, &store).map_err(|err| {
+            tracing::warn!("failed to init instance - {}", err);
+            WasiThreadError::InitFailed(Arc::new(err))
+        })?;
+
+        // Initialize the WASI environment
+        ctx.initialize_with_memory(&mut store, instance, memory, update_layout)
+            .map_err(|err| {
+                tracing::warn!("failed initialize environment - {}", err);
+                WasiThreadError::ExportError(err)
+            })?;
+
+        // Set all the globals
+        if let Some(snapshot) = store_snapshot {
+            restore_store_snapshot(&mut store, snapshot);
+        }
+
+        Ok((ctx, store))
+    }
+
+    /// Get an `Imports` for a specific version of WASI detected in the module.
+    pub fn import_object(
+        &self,
+        store: &mut impl AsStoreMut,
+        module: &Module,
+    ) -> Result<Imports, WasiError> {
+        let wasi_version = get_wasi_version(module, false).ok_or(WasiError::UnknownWasiVersion)?;
+        Ok(crate::generate_import_object_from_env(
+            store,
+            &self.env,
+            wasi_version,
+        ))
+    }
+
+    /// Gets a reference to the WasiEnvironment
+    pub fn data<'a>(&'a self, store: &'a impl AsStoreRef) -> &'a WasiEnv {
+        self.env.as_ref(store)
+    }
+
+    /// Gets a mutable- reference to the host state in this context.
+    pub fn data_mut<'a>(&'a self, store: &'a mut impl AsStoreMut) -> &'a mut WasiEnv {
+        self.env.as_mut(store)
+    }
+
+    /// Initializes the WasiEnv using the instance exports
+    /// (this must be executed before attempting to use it)
+    /// (as the stores can not by themselves be passed between threads we can store the module
+    ///  in a thread-local variables and use it later - for multithreading)
+    pub fn initialize(
+        &mut self,
+        store: &mut impl AsStoreMut,
+        instance: Instance,
+    ) -> Result<(), ExportError> {
+        self.initialize_with_memory(store, instance, None, true)
+    }
+
+    /// Initializes the WasiEnv using the instance exports and a provided optional memory
+    /// (this must be executed before attempting to use it)
+    /// (as the stores can not by themselves be passed between threads we can store the module
+    ///  in a thread-local variables and use it later - for multithreading)
+    pub fn initialize_with_memory(
+        &mut self,
+        store: &mut impl AsStoreMut,
+        instance: Instance,
+        memory: Option<Memory>,
+        update_layout: bool,
+    ) -> Result<(), ExportError> {
+        let is_wasix_module = crate::utils::is_wasix_module(instance.module());
+
+        // First we get the malloc function which if it exists will be used to
+        // create the pthread_self structure
+        let memory = instance.exports.get_memory("memory").map_or_else(
+            |e| {
+                if let Some(memory) = memory {
+                    Ok(memory)
+                } else {
+                    Err(e)
+                }
+            },
+            |v| Ok(v.clone()),
+        )?;
+
+        let new_inner = WasiInstanceHandles::new(memory, store, instance);
+        let stack_pointer = new_inner.stack_pointer.clone();
+
+        let env = self.data_mut(store);
+        env.set_inner(new_inner);
+
+        env.state.fs.set_is_wasix(is_wasix_module);
+
+        // If the stack offset and size is not set then do so
+        if update_layout {
+            // Set the base stack
+            let stack_base = if let Some(stack_pointer) = stack_pointer {
+                match stack_pointer.get(store) {
+                    wasmer::Value::I32(a) => a as u64,
+                    wasmer::Value::I64(a) => a as u64,
+                    _ => DEFAULT_STACK_BASE,
+                }
+            } else {
+                DEFAULT_STACK_BASE
+            };
+            if stack_base == 0 {
+                return Err(ExportError::Missing(
+                    "stack_pointer is not set to the upper stack range".to_string(),
+                ));
+            }
+
+            // Update the stack layout which is need for asyncify
+            let env = self.data_mut(store);
+            let tid = env.tid();
+            let layout = &mut env.layout;
+            layout.stack_upper = stack_base;
+            layout.stack_size = layout.stack_upper - layout.stack_lower;
+
+            // Replace the thread object itself
+            env.thread.set_memory_layout(layout.clone());
+
+            // Replace the thread object with this new layout
+            {
+                let mut guard = env.process.lock();
+                guard
+                    .threads
+                    .values_mut()
+                    .filter(|t| t.tid() == tid)
+                    .for_each(|t| t.set_memory_layout(layout.clone()))
+            }
+        }
+        tracing::trace!("initializing with layout {:?}", self.data(store).layout);
+
+        Ok(())
+    }
+
+    /// Like `import_object` but containing all the WASI versions detected in
+    /// the module.
+    pub fn import_object_for_all_wasi_versions(
+        &self,
+        store: &mut impl AsStoreMut,
+        module: &Module,
+    ) -> Result<Imports, WasiError> {
+        let wasi_versions =
+            get_wasi_versions(module, false).ok_or(WasiError::UnknownWasiVersion)?;
+
+        let mut resolver = Imports::new();
+        for version in wasi_versions.iter() {
+            let new_import_object =
+                crate::generate_import_object_from_env(store, &self.env, *version);
+            for ((n, m), e) in new_import_object.into_iter() {
+                resolver.define(&n, &m, e);
+            }
+        }
+
+        Ok(resolver)
+    }
+
+    /// # Safety
+    ///
+    /// This function should only be called from within a syscall
+    /// as it can potentially execute local thread variable cleanup
+    /// code
+    pub fn on_exit(&self, store: &mut impl AsStoreMut, exit_code: Option<ExitCode>) {
+        trace!(
+            "wasi[{}:{}]::on_exit",
+            self.data(store).pid(),
+            self.data(store).tid()
+        );
+
+        // Cleans up all the open files (if this is the main thread)
+        self.data(store).blocking_on_exit(exit_code);
+    }
+
+    /// Bootstraps this main thread and context with any journals that
+    /// may be present
+    ///
+    /// # Safety
+    ///
+    /// This function manipulates the memory of the process and thus must be executed
+    /// by the WASM process thread itself.
+    ///
+    #[allow(clippy::result_large_err)]
+    #[allow(unused_variables, unused_mut)]
+    pub unsafe fn bootstrap(
+        &self,
+        mut store: &'_ mut impl AsStoreMut,
+    ) -> Result<RewindStateOption, WasiRuntimeError> {
+        #[allow(unused_mut)]
+        let mut rewind_state = None;
+
+        #[cfg(feature = "journal")]
+        {
+            // If there are journals we need to restore then do so (this will
+            // prevent the initialization function from running
+            let restore_journals = self.data(&store).runtime.journals().clone();
+            if !restore_journals.is_empty() {
+                self.data_mut(&mut store).replaying_journal = true;
+
+                for journal in restore_journals {
+                    let ctx = self.env.clone().into_mut(&mut store);
+                    let rewind = match restore_snapshot(ctx, journal, true) {
+                        Ok(r) => r,
+                        Err(err) => {
+                            self.data_mut(&mut store).replaying_journal = false;
+                            return Err(err);
+                        }
+                    };
+                    rewind_state = rewind.map(|rewind| (rewind, RewindResultType::RewindRestart));
+                }
+
+                self.data_mut(&mut store).replaying_journal = false;
+            }
+
+            // If there is no rewind state then the journal is being replayed
+            // and hence we do not need to write an init module event
+            //
+            // But otherwise we need to notify the journal of the module hash
+            // so that recompiled modules will restart
+            if rewind_state.is_none() {
+                // The first event we save is an event that records the module hash.
+                // Note: This is used to detect if an incorrect journal is used on the wrong
+                // process or if a process has been recompiled
+                let wasm_hash = self.data(&store).process.module_hash.as_bytes();
+                let mut ctx = self.env.clone().into_mut(&mut store);
+                crate::journal::JournalEffector::save_event(
+                    &mut ctx,
+                    crate::journal::JournalEntry::InitModuleV1 { wasm_hash },
+                )
+                .map_err(|err| {
+                    WasiRuntimeError::Runtime(wasmer::RuntimeError::new(format!(
+                        "journal failed to save the module initialization event - {}",
+                        err
+                    )))
+                })?;
+            } else {
+                // Otherwise we should emit a clear ethereal event
+                let mut ctx = self.env.clone().into_mut(&mut store);
+                crate::journal::JournalEffector::save_event(
+                    &mut ctx,
+                    crate::journal::JournalEntry::ClearEtherealV1,
+                )
+                .map_err(|err| {
+                    WasiRuntimeError::Runtime(wasmer::RuntimeError::new(format!(
+                        "journal failed to save clear ethereal event - {}",
+                        err
+                    )))
+                })?;
+            }
+        }
+
+        Ok(rewind_state)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/global.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/global.rs
new file mode 100644
index 0000000..a3313f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/global.rs
@@ -0,0 +1,29 @@
+#![cfg_attr(feature = "js", allow(unused))]
+use wasmer::Memory;
+
+use crate::WasiInstanceHandles;
+
+pub(crate) type WasiInstanceGuard<'a> = &'a WasiInstanceHandles;
+pub(crate) type WasiInstanceGuardMut<'a> = &'a mut WasiInstanceHandles;
+pub(crate) type WasiInstanceGuardMemory<'a> = &'a Memory;
+
+/// This pointer provides global access to some instance handles
+#[derive(Debug, Clone, Default)]
+pub(crate) struct WasiInstanceHandlesPointer {
+    inner: Option<WasiInstanceHandles>,
+}
+impl WasiInstanceHandlesPointer {
+    pub fn get(&self) -> Option<&WasiInstanceHandles> {
+        self.inner.as_ref()
+    }
+    pub fn get_mut(&mut self) -> Option<&mut WasiInstanceHandles> {
+        self.inner.as_mut()
+    }
+    pub fn set(&mut self, val: WasiInstanceHandles) {
+        self.inner.replace(val);
+    }
+    #[allow(dead_code)]
+    pub fn clear(&mut self) {
+        self.inner.take();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/mod.rs
new file mode 100644
index 0000000..77a6701
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/mod.rs
@@ -0,0 +1,7 @@
+mod global;
+mod thread_local;
+
+#[cfg(feature = "sys")]
+pub(crate) use global::*;
+#[cfg(feature = "js")]
+pub(crate) use thread_local::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/thread_local.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/thread_local.rs
new file mode 100644
index 0000000..f7dc80c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/handles/thread_local.rs
@@ -0,0 +1,169 @@
+#![cfg_attr(feature = "sys", allow(unused))]
+use std::cell::{Ref, RefCell, RefMut};
+use std::ops::{Deref, DerefMut};
+use std::{
+    collections::HashMap,
+    rc::Rc,
+    sync::atomic::{AtomicU64, Ordering},
+};
+
+use wasmer::Memory;
+
+use crate::WasiInstanceHandles;
+
+static LOCAL_INSTANCE_SEED: AtomicU64 = AtomicU64::new(1);
+thread_local! {
+    static THREAD_LOCAL_INSTANCE_HANDLES: RefCell<HashMap<u64, Rc<RefCell<WasiInstanceHandles>>>>
+        = RefCell::new(HashMap::new());
+}
+
+/// This non-sendable guard provides memory safe access
+/// to the WasiInstance object but only when it is
+/// constructed with certain constraints
+pub(crate) struct WasiInstanceGuard<'a> {
+    // the order is very important as the first value is
+    // dropped before the reference count is dropped
+    borrow: Ref<'static, WasiInstanceHandles>,
+    _pointer: &'a WasiInstanceHandlesPointer,
+    _inner: Rc<RefCell<WasiInstanceHandles>>,
+}
+impl<'a> Deref for WasiInstanceGuard<'a> {
+    type Target = WasiInstanceHandles;
+    fn deref(&self) -> &Self::Target {
+        self.borrow.deref()
+    }
+}
+
+/// This non-sendable guard provides memory safe access
+/// to the WasiInstance object but only when it is
+/// constructed with certain constraints. This one provides
+/// mutable access
+pub(crate) struct WasiInstanceGuardMut<'a> {
+    // the order is very important as the first value is
+    // dropped before the reference count is dropped
+    borrow: RefMut<'static, WasiInstanceHandles>,
+    _pointer: &'a WasiInstanceHandlesPointer,
+    _inner: Rc<RefCell<WasiInstanceHandles>>,
+}
+impl<'a> Deref for WasiInstanceGuardMut<'a> {
+    type Target = WasiInstanceHandles;
+
+    fn deref(&self) -> &Self::Target {
+        self.borrow.deref()
+    }
+}
+impl<'a> DerefMut for WasiInstanceGuardMut<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.borrow.deref_mut()
+    }
+}
+
+/// This handle protects the WasiInstance and makes it
+/// accessible only when you are in the current thread
+/// otherwise it will return None. This means it becomes
+/// possible to make WasiEnv send without unsafe code
+/// however it means that access to the must be checked
+#[derive(Debug, Default, Clone)]
+pub(crate) struct WasiInstanceHandlesPointer {
+    /// Inner functions and references that are loaded before the environment starts
+    id: Option<u64>,
+}
+impl Drop for WasiInstanceHandlesPointer {
+    fn drop(&mut self) {
+        self.clear();
+    }
+}
+impl WasiInstanceHandlesPointer {
+    pub fn get(&self) -> Option<WasiInstanceGuard<'_>> {
+        self.id
+            .iter()
+            .filter_map(|id| {
+                THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
+                    let map = map.borrow();
+                    if let Some(inner) = map.get(id) {
+                        let borrow: Ref<WasiInstanceHandles> = inner.borrow();
+                        let borrow: Ref<'static, WasiInstanceHandles> =
+                            unsafe { std::mem::transmute(borrow) };
+                        Some(WasiInstanceGuard {
+                            borrow,
+                            _pointer: self,
+                            _inner: inner.clone(),
+                        })
+                    } else {
+                        None
+                    }
+                })
+            })
+            .next()
+    }
+    pub fn get_mut(&self) -> Option<WasiInstanceGuardMut<'_>> {
+        self.id
+            .into_iter()
+            .filter_map(|id| {
+                THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
+                    let map = map.borrow_mut();
+                    if let Some(inner) = map.get(&id) {
+                        let borrow: RefMut<WasiInstanceHandles> = inner.borrow_mut();
+                        let borrow: RefMut<'static, WasiInstanceHandles> =
+                            unsafe { std::mem::transmute(borrow) };
+                        Some(WasiInstanceGuardMut {
+                            borrow,
+                            _pointer: self,
+                            _inner: inner.clone(),
+                        })
+                    } else {
+                        None
+                    }
+                })
+            })
+            .next()
+    }
+    pub fn set(&mut self, val: WasiInstanceHandles) {
+        self.clear();
+
+        let id = LOCAL_INSTANCE_SEED.fetch_add(1, Ordering::SeqCst);
+        THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
+            let mut map = map.borrow_mut();
+            map.insert(id, Rc::new(RefCell::new(val)));
+        });
+        if let Some(old_id) = self.id.replace(id) {
+            Self::destroy(old_id)
+        }
+    }
+    #[allow(dead_code)]
+    pub fn clear(&mut self) {
+        if let Some(id) = self.id.take() {
+            Self::destroy(id)
+        }
+    }
+    fn destroy(id: u64) {
+        THREAD_LOCAL_INSTANCE_HANDLES.with(|map| {
+            let mut map = map.borrow_mut();
+            map.remove(&id);
+        })
+    }
+}
+
+/// This provides access to the memory inside the instance
+pub(crate) struct WasiInstanceGuardMemory<'a> {
+    // the order is very important as the first value is
+    // dropped before the reference count is dropped
+    borrow: &'a Memory,
+    _guard: WasiInstanceGuard<'a>,
+}
+impl<'a> Deref for WasiInstanceGuardMemory<'a> {
+    type Target = Memory;
+    fn deref(&self) -> &Self::Target {
+        self.borrow
+    }
+}
+impl<'a> WasiInstanceGuard<'a> {
+    pub fn memory(self) -> WasiInstanceGuardMemory<'a> {
+        let borrow: &Memory = &self.memory;
+        let borrow: &'a Memory = unsafe { std::mem::transmute(borrow) };
+        WasiInstanceGuardMemory {
+            borrow,
+            _guard: self,
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/mod.rs
new file mode 100644
index 0000000..aa8f6dc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/mod.rs
@@ -0,0 +1,262 @@
+//! WARNING: the API exposed here is unstable and very experimental.  Certain things are not ready
+//! yet and may be broken in patch releases.  If you're using this and have any specific needs,
+//! please [let us know here](https://github.com/wasmerio/wasmer/issues/583) or by filing an issue.
+//!
+//! Wasmer always has a virtual root directory located at `/` at which all pre-opened directories can
+//! be found.  It's possible to traverse between preopened directories this way as well (for example
+//! `preopen-dir1/../preopen-dir2`).
+//!
+//! A preopened directory is a directory or directory + name combination passed into the
+//! `generate_import_object` function.  These are directories that the caller has given
+//! the WASI module permission to access.
+//!
+//! You can implement `VirtualFile` for your own types to get custom behavior and extend WASI, see the
+//! [WASI plugin example](https://github.com/wasmerio/wasmer/blob/master/examples/plugin.rs).
+
+#![allow(clippy::cognitive_complexity, clippy::too_many_arguments)]
+
+mod builder;
+mod env;
+mod func_env;
+mod handles;
+mod run;
+mod types;
+
+use std::{
+    collections::{BTreeMap, HashMap},
+    path::Path,
+    sync::Mutex,
+    task::Waker,
+    time::Duration,
+};
+
+use run::*;
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+use virtual_fs::{FileOpener, FileSystem, FsError, OpenOptions, VirtualFile};
+use wasmer_wasix_types::wasi::{Errno, Fd as WasiFd, Rights, Snapshot0Clockid};
+
+pub use self::{
+    builder::*,
+    env::{WasiEnv, WasiEnvInit, WasiInstanceHandles},
+    func_env::WasiFunctionEnv,
+    types::*,
+};
+pub use crate::fs::{InodeGuard, InodeWeakGuard};
+use crate::{
+    fs::{fs_error_into_wasi_err, WasiFs, WasiFsRoot, WasiInodes, WasiStateFileGuard},
+    syscalls::types::*,
+    utils::WasiParkingLot,
+};
+pub(crate) use handles::*;
+
+/// all the rights enabled
+pub const ALL_RIGHTS: Rights = Rights::all();
+
+struct WasiStateOpener {
+    root_fs: WasiFsRoot,
+}
+
+impl FileOpener for WasiStateOpener {
+    fn open(
+        &self,
+        path: &Path,
+        conf: &virtual_fs::OpenOptionsConfig,
+    ) -> virtual_fs::Result<Box<dyn VirtualFile + Send + Sync + 'static>> {
+        let mut new_options = self.root_fs.new_open_options();
+        new_options.options(conf.clone());
+        new_options.open(path)
+    }
+}
+
+/// Represents a futex which will make threads wait for completion in a more
+/// CPU efficient manner
+#[derive(Debug, Default)]
+pub struct WasiFutex {
+    pub(crate) wakers: BTreeMap<u64, Option<Waker>>,
+}
+
+/// Structure that holds the state of BUS calls to this process and from
+/// this process. BUS calls are the equivalent of RPC's with support
+/// for all the major serializers
+#[derive(Debug, Default)]
+pub struct WasiBusState {
+    poll_waker: WasiParkingLot,
+}
+
+impl WasiBusState {
+    /// Gets a reference to the waker that can be used for
+    /// asynchronous calls
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub fn get_poll_waker(&self) -> Waker {
+        self.poll_waker.get_waker()
+    }
+
+    /// Wakes one of the reactors thats currently waiting
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub fn poll_wake(&self) {
+        self.poll_waker.wake()
+    }
+
+    /// Will wait until either the reactor is triggered
+    /// or the timeout occurs
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub fn poll_wait(&self, timeout: Duration) -> bool {
+        self.poll_waker.wait(timeout)
+    }
+}
+
+/// Stores the state of the futexes
+#[derive(Debug, Default)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub(crate) struct WasiFutexState {
+    pub poller_seed: u64,
+    pub futexes: HashMap<u64, WasiFutex>,
+}
+
+/// Top level data type containing all* the state with which WASI can
+/// interact.
+///
+/// * The contents of files are not stored and may be modified by
+/// other, concurrently running programs.  Data such as the contents
+/// of directories are lazily loaded.
+#[derive(Debug)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub(crate) struct WasiState {
+    pub secret: [u8; 32],
+
+    pub fs: WasiFs,
+    pub inodes: WasiInodes,
+    pub futexs: Mutex<WasiFutexState>,
+    pub clock_offset: Mutex<HashMap<Snapshot0Clockid, i64>>,
+    pub args: Vec<String>,
+    pub envs: Mutex<Vec<Vec<u8>>>,
+
+    // TODO: should not be here, since this requires active work to resolve.
+    // State should only hold active runtime state that can be reproducibly re-created.
+    pub preopen: Vec<String>,
+}
+
+impl WasiState {
+    // fn new(fs: WasiFs, inodes: Arc<RwLock<WasiInodes>>) -> Self {
+    //     WasiState {
+    //         fs,
+    //         secret: rand::thread_rng().gen::<[u8; 32]>(),
+    //         inodes,
+    //         args: Vec::new(),
+    //         preopen: Vec::new(),
+    //         threading: Default::default(),
+    //         futexs: Default::default(),
+    //         clock_offset: Default::default(),
+    //         envs: Vec::new(),
+    //     }
+    // }
+}
+
+// Implementations of direct to FS calls so that we can easily change their implementation
+impl WasiState {
+    pub(crate) fn fs_read_dir<P: AsRef<Path>>(
+        &self,
+        path: P,
+    ) -> Result<virtual_fs::ReadDir, Errno> {
+        self.fs
+            .root_fs
+            .read_dir(path.as_ref())
+            .map_err(fs_error_into_wasi_err)
+    }
+
+    pub(crate) fn fs_create_dir<P: AsRef<Path>>(&self, path: P) -> Result<(), Errno> {
+        self.fs
+            .root_fs
+            .create_dir(path.as_ref())
+            .map_err(fs_error_into_wasi_err)
+    }
+
+    pub(crate) fn fs_remove_dir<P: AsRef<Path>>(&self, path: P) -> Result<(), Errno> {
+        self.fs
+            .root_fs
+            .remove_dir(path.as_ref())
+            .map_err(fs_error_into_wasi_err)
+    }
+
+    pub(crate) async fn fs_rename<P: AsRef<Path>, Q: AsRef<Path>>(
+        &self,
+        from: P,
+        to: Q,
+    ) -> Result<(), Errno> {
+        self.fs
+            .root_fs
+            .rename(from.as_ref(), to.as_ref())
+            .await
+            .map_err(fs_error_into_wasi_err)
+    }
+
+    pub(crate) fn fs_remove_file<P: AsRef<Path>>(&self, path: P) -> Result<(), Errno> {
+        self.fs
+            .root_fs
+            .remove_file(path.as_ref())
+            .map_err(fs_error_into_wasi_err)
+    }
+
+    pub(crate) fn fs_new_open_options(&self) -> OpenOptions {
+        self.fs.root_fs.new_open_options()
+    }
+
+    /// Turn the WasiState into bytes
+    #[cfg(feature = "enable-serde")]
+    pub fn freeze(&self) -> Option<Vec<u8>> {
+        bincode::serialize(self).ok()
+    }
+
+    /// Get a WasiState from bytes
+    #[cfg(feature = "enable-serde")]
+    pub fn unfreeze(bytes: &[u8]) -> Option<Self> {
+        bincode::deserialize(bytes).ok()
+    }
+
+    /// Get the `VirtualFile` object at stdout
+    pub fn stdout(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.std_dev_get(__WASI_STDOUT_FILENO)
+    }
+
+    /// Get the `VirtualFile` object at stderr
+    pub fn stderr(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.std_dev_get(__WASI_STDERR_FILENO)
+    }
+
+    /// Get the `VirtualFile` object at stdin
+    pub fn stdin(&self) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        self.std_dev_get(__WASI_STDIN_FILENO)
+    }
+
+    /// Internal helper function to get a standard device handle.
+    /// Expects one of `__WASI_STDIN_FILENO`, `__WASI_STDOUT_FILENO`, `__WASI_STDERR_FILENO`.
+    fn std_dev_get(
+        &self,
+        fd: WasiFd,
+    ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError> {
+        let ret = WasiStateFileGuard::new(self, fd)?.map(|a| {
+            let ret = Box::new(a);
+            let ret: Box<dyn VirtualFile + Send + Sync + 'static> = ret;
+            ret
+        });
+        Ok(ret)
+    }
+
+    /// Forking the WasiState is used when either fork or vfork is called
+    pub fn fork(&self) -> Self {
+        WasiState {
+            fs: self.fs.fork(),
+            secret: self.secret,
+            inodes: self.inodes.clone(),
+            futexs: Default::default(),
+            clock_offset: Mutex::new(self.clock_offset.lock().unwrap().clone()),
+            args: self.args.clone(),
+            envs: Mutex::new(self.envs.lock().unwrap().clone()),
+            preopen: self.preopen.clone(),
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/pipe.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/pipe.rs
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/run.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/run.rs
new file mode 100644
index 0000000..f878f44
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/run.rs
@@ -0,0 +1,211 @@
+use virtual_mio::InlineWaker;
+use wasmer::{RuntimeError, Store};
+use wasmer_wasix_types::wasi::ExitCode;
+
+use crate::{os::task::thread::RewindResultType, RewindStateOption, WasiError, WasiRuntimeError};
+
+use super::*;
+
+impl WasiFunctionEnv {
+    #[allow(clippy::result_large_err)]
+    pub fn run_async(self, mut store: Store) -> Result<(Self, Store), WasiRuntimeError> {
+        // If no handle or runtime exists then create one
+        #[cfg(feature = "sys-thread")]
+        let _guard = if tokio::runtime::Handle::try_current().is_err() {
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+            Some(runtime)
+        } else {
+            None
+        };
+        #[cfg(feature = "sys-thread")]
+        let _guard = _guard.as_ref().map(|r| r.enter());
+
+        self.data(&store).thread.set_status_running();
+
+        let tasks = self.data(&store).tasks().clone();
+        let pid = self.data(&store).pid();
+        let tid = self.data(&store).tid();
+
+        // The return value is passed synchronously and will block until the result
+        // is returned this is because the main thread can go into a deep sleep and
+        // exit the dedicated thread
+        let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
+
+        let this = self.clone();
+        tasks.task_dedicated(Box::new(move || {
+            // Unsafe: The bootstrap must be executed in the same thread that runs the
+            //         actual WASM code
+            let rewind_state = unsafe {
+                match this.bootstrap(&mut store) {
+                    Ok(a) => a,
+                    Err(err) => {
+                        tracing::warn!("failed to bootstrap - {}", err);
+                        this.on_exit(&mut store, None);
+                        tx.send(Err(err)).ok();
+                        return;
+                    }
+                }
+            };
+            run_with_deep_sleep(store, rewind_state, this, tx);
+        }))?;
+
+        let result = InlineWaker::block_on(rx.recv());
+        let store = match result {
+            Some(result) => {
+                tracing::trace!(
+                    %pid,
+                    %tid,
+                    error=result.as_ref().err().map(|e| e as &dyn std::error::Error),
+                    "main exit",
+                );
+                result?
+            }
+            None => {
+                tracing::trace!(
+                    %pid,
+                    %tid,
+                    "main premature termination",
+                );
+                return Err(WasiRuntimeError::Runtime(RuntimeError::new(
+                    "main thread terminated without a result, this normally means a panic occurred",
+                )));
+            }
+        };
+        Ok((self, store))
+    }
+}
+
+fn run_with_deep_sleep(
+    mut store: Store,
+    rewind_state: RewindStateOption,
+    env: WasiFunctionEnv,
+    sender: tokio::sync::mpsc::UnboundedSender<Result<Store, WasiRuntimeError>>,
+) {
+    if let Some((rewind_state, rewind_result)) = rewind_state {
+        tracing::trace!("Rewinding");
+        let mut ctx = env.env.clone().into_mut(&mut store);
+        let errno = if rewind_state.is_64bit {
+            crate::rewind_ext::<wasmer_types::Memory64>(
+                &mut ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            )
+        } else {
+            crate::rewind_ext::<wasmer_types::Memory32>(
+                &mut ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            )
+        };
+
+        if errno != Errno::Success {
+            let exit_code = ExitCode::from(errno);
+            env.on_exit(&mut store, Some(exit_code));
+            if exit_code.is_success() {
+                let _ = sender.send(Ok(store));
+            } else {
+                let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit(exit_code))));
+            }
+            return;
+        }
+    }
+
+    let instance = match env.data(&store).try_clone_instance() {
+        Some(instance) => instance,
+        None => {
+            tracing::debug!("Unable to clone the instance");
+            env.on_exit(&mut store, None);
+            let _ = sender.send(Err(WasiRuntimeError::Wasi(WasiError::Exit(
+                Errno::Noexec.into(),
+            ))));
+            return;
+        }
+    };
+
+    let start = match instance.exports.get_function("_start") {
+        Ok(start) => start,
+        Err(e) => {
+            tracing::debug!("Unable to get the _start function");
+            env.on_exit(&mut store, None);
+            let _ = sender.send(Err(e.into()));
+            return;
+        }
+    };
+
+    let result = start.call(&mut store, &[]);
+    handle_result(store, env, result, sender);
+}
+
+fn handle_result(
+    mut store: Store,
+    env: WasiFunctionEnv,
+    result: Result<Box<[wasmer::Value]>, RuntimeError>,
+    sender: tokio::sync::mpsc::UnboundedSender<Result<Store, WasiRuntimeError>>,
+) {
+    let result: Result<_, WasiRuntimeError> = match result.map_err(|e| e.downcast::<WasiError>()) {
+        Err(Ok(WasiError::DeepSleep(work))) => {
+            let pid = env.data(&store).pid();
+            let tid = env.data(&store).tid();
+            tracing::trace!(%pid, %tid, "entered a deep sleep");
+
+            let tasks = env.data(&store).tasks().clone();
+            let rewind = work.rewind;
+            let respawn = move |ctx, store, res| {
+                run_with_deep_sleep(
+                    store,
+                    Some((rewind, RewindResultType::RewindWithResult(res))),
+                    ctx,
+                    sender,
+                )
+            };
+
+            // Spawns the WASM process after a trigger
+            unsafe {
+                tasks
+                    .resume_wasm_after_poller(Box::new(respawn), env, store, work.trigger)
+                    .unwrap();
+            }
+
+            return;
+        }
+        Ok(_) => Ok(()),
+        Err(Ok(other)) => Err(other.into()),
+        Err(Err(e)) => Err(e.into()),
+    };
+
+    let (result, exit_code) = wasi_exit_code(result);
+    env.on_exit(&mut store, Some(exit_code));
+    sender.send(result.map(|_| store)).ok();
+}
+
+/// Extract the exit code from a `Result<(), WasiRuntimeError>`.
+///
+/// We need this because calling `exit(0)` inside a WASI program technically
+/// triggers [`WasiError`] with an exit code of `0`, but the end user won't want
+/// that treated as an error.
+pub(super) fn wasi_exit_code(
+    mut result: Result<(), WasiRuntimeError>,
+) -> (Result<(), WasiRuntimeError>, ExitCode) {
+    let exit_code = match &result {
+        Ok(_) => Errno::Success.into(),
+        Err(err) => match err.as_exit_code() {
+            Some(code) if code.is_success() => {
+                // This is actually not an error, so we need to fix up the
+                // result
+                result = Ok(());
+                Errno::Success.into()
+            }
+            Some(other) => other,
+            None => Errno::Noexec.into(),
+        },
+    };
+
+    (result, exit_code)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/types.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/types.rs
new file mode 100644
index 0000000..ac909d6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/state/types.rs
@@ -0,0 +1,108 @@
+// TODO: review allow..
+use cfg_if::cfg_if;
+
+/// types for use in the WASI filesystem
+#[cfg(feature = "enable-serde")]
+use serde::{Deserialize, Serialize};
+
+cfg_if! {
+    if #[cfg(feature = "host-fs")] {
+        pub use virtual_fs::host_fs::{Stderr, Stdin, Stdout};
+    } else {
+        pub use virtual_fs::mem_fs::{Stderr, Stdin, Stdout};
+    }
+}
+
+#[derive(Debug, Clone)]
+#[allow(clippy::enum_variant_names)]
+pub enum PollEvent {
+    /// Data available to read
+    PollIn = 1,
+    /// Data available to write (will still block if data is greater than space available unless
+    /// the fd is configured to not block)
+    PollOut = 2,
+    /// Something didn't work. ignored as input
+    PollError = 4,
+    /// Connection closed. ignored as input
+    PollHangUp = 8,
+    /// Invalid request. ignored as input
+    PollInvalid = 16,
+}
+
+impl PollEvent {
+    fn from_i16(raw_num: i16) -> Option<PollEvent> {
+        Some(match raw_num {
+            1 => PollEvent::PollIn,
+            2 => PollEvent::PollOut,
+            4 => PollEvent::PollError,
+            8 => PollEvent::PollHangUp,
+            16 => PollEvent::PollInvalid,
+            _ => return None,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PollEventBuilder {
+    inner: PollEventSet,
+}
+
+pub type PollEventSet = i16;
+
+#[derive(Debug)]
+pub struct PollEventIter {
+    pes: PollEventSet,
+    i: usize,
+}
+
+impl Iterator for PollEventIter {
+    type Item = PollEvent;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.pes == 0 || self.i > 15 {
+            None
+        } else {
+            while self.i < 16 {
+                let result = PollEvent::from_i16(self.pes & (1 << self.i));
+                self.pes &= !(1 << self.i);
+                self.i += 1;
+                if let Some(r) = result {
+                    return Some(r);
+                }
+            }
+            unreachable!("Internal logic error in PollEventIter");
+        }
+    }
+}
+
+pub fn iterate_poll_events(pes: PollEventSet) -> PollEventIter {
+    PollEventIter { pes, i: 0 }
+}
+
+#[allow(dead_code)]
+impl PollEventBuilder {
+    pub fn new() -> PollEventBuilder {
+        PollEventBuilder { inner: 0 }
+    }
+
+    pub fn add(mut self, event: PollEvent) -> PollEventBuilder {
+        self.inner |= event as PollEventSet;
+        self
+    }
+
+    pub fn build(self) -> PollEventSet {
+        self.inner
+    }
+}
+
+pub trait WasiPath {}
+
+/*
+TODO: Think about using this
+trait WasiFdBacking: std::fmt::Debug {
+    fn get_stat(&self) -> &Filestat;
+    fn get_stat_mut(&mut self) -> &mut Filestat;
+    fn is_preopened(&self) -> bool;
+    fn get_name(&self) -> &str;
+}
+*/
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/close_thread.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/close_thread.rs
new file mode 100644
index 0000000..159cafb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/close_thread.rs
@@ -0,0 +1,36 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_close_thread(
+        &mut self,
+        id: u32,
+        exit_code: Option<ExitCode>,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        if id == self.ctx.data().tid().raw() {
+            tracing::trace!(%id, ?exit_code, "Replay journal - CloseThread(main)");
+            if self.bootstrapping {
+                self.clear_ethereal(differ_ethereal);
+                self.staged_differ_memory.clear();
+                self.differ_memory.clear();
+                self.rewind = None;
+            } else {
+                JournalEffector::apply_process_exit(&mut self.ctx, exit_code)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+        } else if let Some(differ_ethereal) = differ_ethereal {
+            tracing::trace!(%id, ?exit_code, "Differ(end) journal - CloseThread");
+            differ_ethereal.push(JournalEntry::CloseThreadV1 { id, exit_code });
+        } else {
+            tracing::trace!(%id, ?exit_code, "Replay journal - CloseThread");
+            JournalEffector::apply_thread_exit(
+                &mut self.ctx,
+                Into::<WasiThreadId>::into(id),
+                exit_code,
+            )
+            .map_err(anyhow_err_to_runtime_err)?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_advise.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_advise.rs
new file mode 100644
index 0000000..2e094bc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_advise.rs
@@ -0,0 +1,17 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_advise(
+        &mut self,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+        advice: Advice,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %offset, %len, ?advice, "Replay journal - FdAdvise");
+        JournalEffector::apply_fd_advise(&mut self.ctx, fd, offset, len, advice)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs
new file mode 100644
index 0000000..dbf1896
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_allocate.rs
@@ -0,0 +1,16 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_allocate(
+        &mut self,
+        fd: Fd,
+        offset: Filesize,
+        len: Filesize,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %offset, %len, "Replay journal - FdAllocate");
+        JournalEffector::apply_fd_allocate(&mut self.ctx, fd, offset, len)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_close.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_close.rs
new file mode 100644
index 0000000..26b308c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_close.rs
@@ -0,0 +1,12 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_close(&mut self, fd: u32) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, "Replay journal - FdClose");
+        self.stdout_fds.remove(&fd);
+        self.stderr_fds.remove(&fd);
+        JournalEffector::apply_fd_close(&mut self.ctx, fd).map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_dup.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_dup.rs
new file mode 100644
index 0000000..dd4bd8d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_dup.rs
@@ -0,0 +1,26 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_dup(
+        &mut self,
+        original_fd: u32,
+        copied_fd: u32,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%original_fd, %copied_fd, "Replay journal - FdDuplicate");
+        self.real_fd.insert(copied_fd);
+        if original_fd != copied_fd {
+            self.stdout_fds.remove(&copied_fd);
+            self.stderr_fds.remove(&copied_fd);
+        }
+        if self.stdout_fds.contains(&original_fd) {
+            self.stdout_fds.insert(copied_fd);
+        }
+        if self.stderr_fds.contains(&original_fd) {
+            self.stderr_fds.insert(copied_fd);
+        }
+        JournalEffector::apply_fd_duplicate(&mut self.ctx, original_fd, copied_fd)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_open.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_open.rs
new file mode 100644
index 0000000..2393bac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_open.rs
@@ -0,0 +1,31 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_open(
+        &mut self,
+        fd: u32,
+        dirfd: u32,
+        dirflags: u32,
+        path: Cow<'a, str>,
+        o_flags: Oflags,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+        fs_flags: Fdflags,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %dirfd, %dirflags,  "Replay journal - FdOpen {}", path);
+        JournalEffector::apply_path_open(
+            &mut self.ctx,
+            fd,
+            dirfd,
+            dirflags,
+            &path,
+            o_flags,
+            fs_rights_base,
+            fs_rights_inheriting,
+            fs_flags,
+        )
+        .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs
new file mode 100644
index 0000000..b2b485f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_renumber.rs
@@ -0,0 +1,26 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_renumber(
+        &mut self,
+        old_fd: u32,
+        new_fd: u32,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%old_fd, %new_fd, "Replay journal - FdRenumber");
+        self.real_fd.insert(new_fd);
+        if old_fd != new_fd {
+            self.stdout_fds.remove(&new_fd);
+            self.stderr_fds.remove(&new_fd);
+        }
+        if self.stdout_fds.remove(&old_fd) {
+            self.stdout_fds.insert(new_fd);
+        }
+        if self.stderr_fds.remove(&old_fd) {
+            self.stderr_fds.insert(new_fd);
+        }
+        JournalEffector::apply_fd_renumber(&mut self.ctx, old_fd, new_fd)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_seek.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_seek.rs
new file mode 100644
index 0000000..c57b10d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_seek.rs
@@ -0,0 +1,16 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_seek(
+        &mut self,
+        fd: u32,
+        offset: i64,
+        whence: Whence,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %offset, ?whence, "Replay journal - FdSeek");
+        JournalEffector::apply_fd_seek(&mut self.ctx, fd, offset, whence)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs
new file mode 100644
index 0000000..db2511c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_flags.rs
@@ -0,0 +1,15 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_set_flags(
+        &mut self,
+        fd: Fd,
+        flags: Fdflags,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, ?flags, "Replay journal - FdSetFlags");
+        JournalEffector::apply_fd_set_flags(&mut self.ctx, fd, flags)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs
new file mode 100644
index 0000000..479fe23
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_rights.rs
@@ -0,0 +1,21 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_set_rights(
+        &mut self,
+        fd: Fd,
+        fs_rights_base: Rights,
+        fs_rights_inheriting: Rights,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, "Replay journal - FdSetRights");
+        JournalEffector::apply_fd_set_rights(
+            &mut self.ctx,
+            fd,
+            fs_rights_base,
+            fs_rights_inheriting,
+        )
+        .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs
new file mode 100644
index 0000000..12084fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_size.rs
@@ -0,0 +1,15 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_set_size(
+        &mut self,
+        fd: Fd,
+        st_size: Filesize,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %st_size, "Replay journal - FdSetSize");
+        JournalEffector::apply_fd_set_size(&mut self.ctx, fd, st_size)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs
new file mode 100644
index 0000000..7c615e9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_set_times.rs
@@ -0,0 +1,17 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_set_times(
+        &mut self,
+        fd: Fd,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %st_atim, %st_mtim, ?fst_flags, "Replay journal - FdSetTimes");
+        JournalEffector::apply_fd_set_times(&mut self.ctx, fd, st_atim, st_mtim, fst_flags)
+            .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_write.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_write.rs
new file mode 100644
index 0000000..06e7249
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/fd_write.rs
@@ -0,0 +1,30 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_fd_write(
+        &mut self,
+        fd: u32,
+        offset: u64,
+        data: Cow<'a, [u8]>,
+        is_64bit: bool,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, %offset, "Replay journal - FdWrite");
+        if self.stdout_fds.contains(&fd) {
+            self.stdout.push((offset, data, is_64bit));
+            return Ok(());
+        }
+        if self.stderr_fds.contains(&fd) {
+            self.stderr.push((offset, data, is_64bit));
+            return Ok(());
+        }
+
+        if is_64bit {
+            JournalEffector::apply_fd_write::<Memory64>(&self.ctx, fd, offset, data)
+        } else {
+            JournalEffector::apply_fd_write::<Memory32>(&self.ctx, fd, offset, data)
+        }
+        .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/init_module.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/init_module.rs
new file mode 100644
index 0000000..2e0dfe5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/init_module.rs
@@ -0,0 +1,16 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_init_module(
+        &mut self,
+        wasm_hash: [u8; 8],
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!("Replay journal - InitModule {:?}", wasm_hash);
+        self.clear_ethereal(differ_ethereal);
+        self.differ_memory.clear();
+        self.journal_module_hash.replace(wasm_hash);
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/mod.rs
new file mode 100644
index 0000000..49a5d1d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/mod.rs
@@ -0,0 +1,46 @@
+mod close_thread;
+mod fd_advise;
+mod fd_allocate;
+mod fd_close;
+mod fd_dup;
+mod fd_open;
+mod fd_renumber;
+mod fd_seek;
+mod fd_set_flags;
+mod fd_set_rights;
+mod fd_set_size;
+mod fd_set_times;
+mod fd_write;
+mod init_module;
+mod path_set_times;
+mod process_exit;
+mod set_thread;
+mod snapshot;
+mod tty_set;
+mod update_memory;
+
+use crate::journal::JournalEffector;
+use crate::syscalls::anyhow_err_to_runtime_err;
+use crate::syscalls::JournalSyscallPlayer;
+use crate::RewindState;
+use crate::WasiRuntimeError;
+use crate::WasiThreadId;
+use std::borrow::Cow;
+use std::ops::Range;
+use std::time::SystemTime;
+use wasmer::RuntimeError;
+use wasmer_journal::JournalEntry;
+use wasmer_journal::SnapshotTrigger;
+use wasmer_types::Memory32;
+use wasmer_types::Memory64;
+use wasmer_wasix_types::wasi::Advice;
+use wasmer_wasix_types::wasi::ExitCode;
+use wasmer_wasix_types::wasi::Fd;
+use wasmer_wasix_types::wasi::Fdflags;
+use wasmer_wasix_types::wasi::Filesize;
+use wasmer_wasix_types::wasi::Tty;
+use wasmer_wasix_types::wasi::Whence;
+use wasmer_wasix_types::wasi::{Fstflags, LookupFlags, Timestamp};
+use wasmer_wasix_types::wasi::{Oflags, Rights};
+use wasmer_wasix_types::wasix::ThreadStartType;
+use wasmer_wasix_types::wasix::WasiMemoryLayout;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/path_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/path_set_times.rs
new file mode 100644
index 0000000..c91fe3c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/path_set_times.rs
@@ -0,0 +1,27 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_path_set_times(
+        &mut self,
+        fd: Fd,
+        flags: LookupFlags,
+        path: Cow<'_, str>,
+        st_atim: Timestamp,
+        st_mtim: Timestamp,
+        fst_flags: Fstflags,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(%fd, "Replay journal - PathSetTimes");
+        JournalEffector::apply_path_set_times(
+            &mut self.ctx,
+            fd,
+            flags,
+            &path,
+            st_atim,
+            st_mtim,
+            fst_flags,
+        )
+        .map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/process_exit.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/process_exit.rs
new file mode 100644
index 0000000..6228c88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/process_exit.rs
@@ -0,0 +1,21 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_process_exit(
+        &mut self,
+        exit_code: Option<ExitCode>,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!(?exit_code, "Replay journal - ProcessExit");
+        if self.bootstrapping {
+            self.clear_ethereal(differ_ethereal);
+            self.differ_memory.clear();
+            self.rewind = None;
+        } else {
+            JournalEffector::apply_process_exit(&mut self.ctx, exit_code)
+                .map_err(anyhow_err_to_runtime_err)?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/set_thread.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/set_thread.rs
new file mode 100644
index 0000000..2d21e1d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/set_thread.rs
@@ -0,0 +1,57 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_set_thread(
+        &mut self,
+        id: u32,
+        call_stack: Cow<'a, [u8]>,
+        memory_stack: Cow<'a, [u8]>,
+        store_data: Cow<'a, [u8]>,
+        is_64bit: bool,
+        start: ThreadStartType,
+        layout: WasiMemoryLayout,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        if Some(self.cur_module_hash) != self.journal_module_hash {
+            tracing::trace!(%id, "Skipping journal entry - SetThread call_stack={} bytes memory_stack={} bytes store_data={} bytes", call_stack.len(), memory_stack.len(), store_data.len());
+            return Ok(());
+        }
+
+        let state = RewindState {
+            memory_stack: memory_stack.to_vec().into(),
+            rewind_stack: call_stack.to_vec().into(),
+            store_data: store_data.to_vec().into(),
+            start,
+            layout: layout.clone(),
+            is_64bit,
+        };
+
+        if Into::<WasiThreadId>::into(id) == self.ctx.data().tid() {
+            tracing::trace!(%id, "Differ(end) journal - SetThread(main) call_stack={} bytes memory_stack={} bytes store_data={} bytes", call_stack.len(), memory_stack.len(), store_data.len());
+            self.rewind.replace(state);
+        } else if let Some(differ_ethereal) = differ_ethereal {
+            tracing::trace!(%id, "Differ(ether) journal - SetThread call_stack={} bytes memory_stack={} bytes store_data={} bytes", call_stack.len(), memory_stack.len(), store_data.len());
+            differ_ethereal.push(JournalEntry::SetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                start,
+                layout,
+                is_64bit,
+            });
+        } else if self.bootstrapping {
+            tracing::trace!(%id, "Differ(end) journal - SetThread({id}) call_stack={} bytes memory_stack={} bytes store_data={} bytes", call_stack.len(), memory_stack.len(), store_data.len());
+            self.spawn_threads.insert(id.into(), state);
+        } else {
+            return Err(WasiRuntimeError::Runtime(RuntimeError::user(
+                anyhow::format_err!(
+                    "Snapshot restoration does not currently support live updates of running threads."
+                )
+                .into(),
+            )));
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/snapshot.rs
new file mode 100644
index 0000000..3b6e543
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/snapshot.rs
@@ -0,0 +1,50 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_snapshot(
+        &mut self,
+        when: SystemTime,
+        trigger: SnapshotTrigger,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        // If we are not in the same module then we fire off an exit
+        // that simulates closing the process (hence keeps everything
+        // in a clean state)
+        let mut clear_ethereal = false;
+        if self.journal_module_hash.is_some()
+            && Some(self.cur_module_hash) != self.journal_module_hash
+        {
+            tracing::error!(
+                "The WASM module hash does not match the journal module hash (journal_hash={:x?} vs module_hash{:x?}) - forcing a restart",
+                self.journal_module_hash.unwrap(),
+                self.cur_module_hash
+            );
+            self.clear_ethereal(differ_ethereal);
+            return Ok(());
+        }
+
+        tracing::trace!("Replay journal - Snapshot (trigger={:?})", trigger);
+
+        // Execute all the ethereal events
+        if let Some(ethereal_events) = differ_ethereal {
+            for next in ethereal_events.drain(..) {
+                tracing::trace!("Replay(ether) snapshot event - {next:?}");
+                if let Err(err) = self.play_event(next, None) {
+                    tracing::warn!("failed to replay event - {}", err);
+                    return Err(err);
+                }
+            }
+            for (region, data) in self.staged_differ_memory.drain(..) {
+                tracing::trace!(
+                    "Differ(end) memory event - {region:?} data.len={}",
+                    data.len()
+                );
+                self.differ_memory.push((region, data));
+            }
+        }
+
+        self.ctx.data_mut().pop_snapshot_trigger(trigger);
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/tty_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/tty_set.rs
new file mode 100644
index 0000000..2d0206e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/tty_set.rs
@@ -0,0 +1,27 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_tty_set(
+        &mut self,
+        tty: Tty,
+        line_feeds: bool,
+    ) -> Result<(), WasiRuntimeError> {
+        tracing::trace!("Replay journal - TtySet");
+        let state = crate::WasiTtyState {
+            cols: tty.cols,
+            rows: tty.rows,
+            width: tty.width,
+            height: tty.height,
+            stdin_tty: tty.stdin_tty,
+            stdout_tty: tty.stdout_tty,
+            stderr_tty: tty.stderr_tty,
+            echo: tty.echo,
+            line_buffered: tty.line_buffered,
+            line_feeds,
+        };
+
+        JournalEffector::apply_tty_set(&mut self.ctx, state).map_err(anyhow_err_to_runtime_err)?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/update_memory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/update_memory.rs
new file mode 100644
index 0000000..746e535
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/actions/update_memory.rs
@@ -0,0 +1,29 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(crate) unsafe fn action_update_memory(
+        &mut self,
+        region: Range<u64>,
+        data: Cow<'a, [u8]>,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        if Some(self.cur_module_hash) != self.journal_module_hash {
+            tracing::trace!("Ignored journal - UpdateMemory");
+            return Ok(());
+        }
+
+        if self.bootstrapping {
+            tracing::trace!("Differ(stage) journal - UpdateMemory");
+            self.staged_differ_memory.push((region, data));
+        } else if let Some(differ_ethereal) = differ_ethereal {
+            tracing::trace!("Differ(ether) journal - UpdateMemory");
+            differ_ethereal.push(JournalEntry::UpdateMemoryRegionV1 { region, data });
+        } else {
+            tracing::trace!("Replay journal - UpdateMemory");
+            JournalEffector::apply_memory(&mut self.ctx, region, &data)
+                .map_err(anyhow_err_to_runtime_err)?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/clear_ethereal.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/clear_ethereal.rs
new file mode 100644
index 0000000..2ce4fc9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/clear_ethereal.rs
@@ -0,0 +1,19 @@
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    pub(super) fn clear_ethereal(
+        &mut self,
+        mut differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) {
+        tracing::trace!("Replay journal - ClearEthereal");
+        self.spawn_threads.clear();
+        self.stdout.clear();
+        self.stderr.clear();
+        self.stdout_fds.clear();
+        self.stderr_fds.clear();
+        self.stdout_fds.insert(1 as WasiFd);
+        self.stderr_fds.insert(2 as WasiFd);
+        differ_ethereal.iter_mut().for_each(|e| e.clear());
+        self.staged_differ_memory.clear();
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/do_checkpoint_from_outside.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/do_checkpoint_from_outside.rs
new file mode 100644
index 0000000..36603d3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/do_checkpoint_from_outside.rs
@@ -0,0 +1,24 @@
+use crate::os::task::process::LockableWasiProcessInner;
+
+use super::WasiProcessCheckpoint;
+
+pub(crate) fn do_checkpoint_from_outside(
+    process: &LockableWasiProcessInner,
+    checkpoint: WasiProcessCheckpoint,
+) {
+    let mut guard = process.0.lock().unwrap();
+
+    // Initiate the checksum (if one already exists we must wait for it to end
+    // before we start the next checksum)
+
+    // TODO: Disabled as this blocks the async runtime
+    //while !matches!(guard.checkpoint, WasiProcessCheckpoint::Execute) {
+    //    guard = process.1.wait(guard).unwrap();
+    //}
+
+    guard.checkpoint = checkpoint;
+    for waker in guard.wakers.drain(..) {
+        waker.wake();
+    }
+    process.1.notify_all();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot.rs
new file mode 100644
index 0000000..83fd7fa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot.rs
@@ -0,0 +1,30 @@
+use super::*;
+
+#[allow(clippy::extra_unused_type_parameters)]
+#[cfg(not(feature = "journal"))]
+pub fn maybe_snapshot<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    Ok(Ok(ctx))
+}
+
+#[cfg(feature = "journal")]
+pub fn maybe_snapshot<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    use crate::os::task::process::{WasiProcessCheckpoint, WasiProcessInner};
+
+    if !ctx.data().enable_journal {
+        return Ok(Ok(ctx));
+    }
+
+    let inner = ctx.data().process.inner.clone();
+    let res = wasi_try_ok_ok!(WasiProcessInner::maybe_checkpoint::<M>(inner, ctx)?);
+    match res {
+        MaybeCheckpointResult::Unwinding => return Ok(Err(Errno::Success)),
+        MaybeCheckpointResult::NotThisTime(c) => {
+            ctx = c;
+        }
+    }
+    Ok(Ok(ctx))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_many.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_many.rs
new file mode 100644
index 0000000..866d899
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_many.rs
@@ -0,0 +1,44 @@
+use super::*;
+
+#[allow(clippy::extra_unused_type_parameters)]
+#[cfg(not(feature = "journal"))]
+pub fn maybe_snapshot_many<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    _trigger: crate::journal::SnapshotTrigger,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    Ok(Ok(ctx))
+}
+
+#[cfg(feature = "journal")]
+pub fn maybe_snapshot_many<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    trigger: crate::journal::SnapshotTrigger,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    use crate::os::task::process::{WasiProcessCheckpoint, WasiProcessInner};
+
+    if unsafe { handle_rewind_ext_with_default::<M, ()>(&mut ctx, HandleRewindType::ResultLess) }
+        .is_some()
+    {
+        return Ok(Ok(ctx));
+    }
+
+    if !ctx.data().enable_journal {
+        return Ok(Ok(ctx));
+    }
+
+    if ctx.data_mut().has_snapshot_trigger(trigger) {
+        let inner = ctx.data().process.inner.clone();
+        let res = wasi_try_ok_ok!(WasiProcessInner::checkpoint::<M>(
+            inner,
+            ctx,
+            WasiProcessCheckpoint::Snapshot { trigger },
+        )?);
+        match res {
+            MaybeCheckpointResult::Unwinding => return Ok(Err(Errno::Success)),
+            MaybeCheckpointResult::NotThisTime(c) => {
+                ctx = c;
+            }
+        }
+    }
+    Ok(Ok(ctx))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_once.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_once.rs
new file mode 100644
index 0000000..8938f63
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/maybe_snapshot_once.rs
@@ -0,0 +1,44 @@
+use super::*;
+
+#[allow(clippy::extra_unused_type_parameters)]
+#[cfg(not(feature = "journal"))]
+pub fn maybe_snapshot_once<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    _trigger: crate::journal::SnapshotTrigger,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    Ok(Ok(ctx))
+}
+
+#[cfg(feature = "journal")]
+pub fn maybe_snapshot_once<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    trigger: crate::journal::SnapshotTrigger,
+) -> WasiResult<FunctionEnvMut<'_, WasiEnv>> {
+    use crate::os::task::process::{WasiProcessCheckpoint, WasiProcessInner};
+
+    if unsafe { handle_rewind_ext_with_default::<M, ()>(&mut ctx, HandleRewindType::ResultLess) }
+        .is_some()
+    {
+        return Ok(Ok(ctx));
+    }
+
+    if !ctx.data().enable_journal {
+        return Ok(Ok(ctx));
+    }
+
+    if ctx.data_mut().pop_snapshot_trigger(trigger) {
+        let inner = ctx.data().process.inner.clone();
+        let res = wasi_try_ok_ok!(WasiProcessInner::checkpoint::<M>(
+            inner,
+            ctx,
+            WasiProcessCheckpoint::Snapshot { trigger },
+        )?);
+        match res {
+            MaybeCheckpointResult::Unwinding => return Ok(Err(Errno::Success)),
+            MaybeCheckpointResult::NotThisTime(c) => {
+                ctx = c;
+            }
+        }
+    }
+    Ok(Ok(ctx))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/mod.rs
new file mode 100644
index 0000000..984c9b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/mod.rs
@@ -0,0 +1,78 @@
+#[cfg(feature = "journal")]
+mod actions;
+mod clear_ethereal;
+mod do_checkpoint_from_outside;
+mod maybe_snapshot;
+mod maybe_snapshot_many;
+mod maybe_snapshot_once;
+#[cfg(feature = "journal")]
+mod play_event;
+mod restore_snapshot;
+mod wait_for_snapshot;
+
+#[cfg(feature = "journal")]
+use actions::*;
+use clear_ethereal::*;
+use wasmer_journal::JournalEntry;
+
+pub use do_checkpoint_from_outside::*;
+pub use maybe_snapshot::*;
+pub use maybe_snapshot_many::*;
+pub use maybe_snapshot_once::*;
+pub use restore_snapshot::*;
+pub use wait_for_snapshot::*;
+
+use crate::os::task::process::MemorySnapshotRegion;
+use std::{collections::BTreeMap, ops::Range};
+
+use super::*;
+
+pub struct JournalSyscallPlayer<'a, 'c> {
+    pub ctx: FunctionEnvMut<'c, WasiEnv>,
+    pub bootstrapping: bool,
+
+    pub journal_module_hash: Option<[u8; 8]>,
+    pub rewind: Option<RewindState>,
+    pub cur_module_hash: [u8; 8],
+    pub real_fd: HashSet<WasiFd>,
+
+    // We delay the spawning of threads until the end as its
+    // possible that the threads will be cancelled before all the
+    // events finished the streaming process
+    pub spawn_threads: BTreeMap<WasiThreadId, RewindState>,
+    pub staged_differ_memory: Vec<(Range<u64>, Cow<'a, [u8]>)>,
+    pub differ_memory: Vec<(Range<u64>, Cow<'a, [u8]>)>,
+
+    // We capture the stdout and stderr while we replay
+    pub stdout: Vec<(u64, Cow<'a, [u8]>, bool)>,
+    pub stderr: Vec<(u64, Cow<'a, [u8]>, bool)>,
+    pub stdout_fds: HashSet<u32>,
+    pub stderr_fds: HashSet<u32>,
+}
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    pub fn new(mut ctx: FunctionEnvMut<'c, WasiEnv>, bootstrapping: bool) -> Self {
+        let cur_module_hash: [u8; 8] = ctx.data().process.module_hash.as_bytes();
+        let mut ret = JournalSyscallPlayer {
+            ctx,
+            bootstrapping,
+            cur_module_hash,
+            journal_module_hash: None,
+            rewind: None,
+            spawn_threads: Default::default(),
+            staged_differ_memory: Default::default(),
+            differ_memory: Default::default(),
+            stdout: Default::default(),
+            stderr: Default::default(),
+            stdout_fds: Default::default(),
+            stderr_fds: Default::default(),
+            real_fd: Default::default(),
+        };
+
+        // We capture the stdout and stderr while we replay
+        ret.stdout_fds.insert(1 as WasiFd);
+        ret.stderr_fds.insert(2 as WasiFd);
+
+        ret
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/play_event.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/play_event.rs
new file mode 100644
index 0000000..be62674
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/play_event.rs
@@ -0,0 +1,749 @@
+use std::ops::Range;
+
+use super::*;
+
+impl<'a, 'c> JournalSyscallPlayer<'a, 'c> {
+    #[allow(clippy::result_large_err)]
+    pub(super) unsafe fn play_event(
+        &mut self,
+        next: JournalEntry<'a>,
+        differ_ethereal: Option<&mut Vec<JournalEntry<'a>>>,
+    ) -> Result<(), WasiRuntimeError> {
+        match next {
+            JournalEntry::InitModuleV1 { wasm_hash } => {
+                self.action_init_module(wasm_hash, differ_ethereal)?;
+            }
+            JournalEntry::ClearEtherealV1 => {
+                self.clear_ethereal(differ_ethereal);
+            }
+            JournalEntry::ProcessExitV1 { exit_code } => {
+                self.action_process_exit(exit_code, differ_ethereal)?;
+            }
+            JournalEntry::FileDescriptorWriteV1 {
+                fd,
+                offset,
+                data,
+                is_64bit,
+            } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_write(fd, offset, data, is_64bit)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %offset, "Differ(ether) journal - FdWrite");
+                    differ_ethereal.push(JournalEntry::FileDescriptorWriteV1 {
+                        fd,
+                        offset,
+                        data,
+                        is_64bit,
+                    });
+                } else {
+                    self.action_fd_write(fd, offset, data, is_64bit)?;
+                }
+            }
+            JournalEntry::FileDescriptorSeekV1 { fd, offset, whence } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_seek(fd, offset, whence)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %offset, ?whence, "Differ(ether) journal - FdSeek");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSeekV1 { fd, offset, whence });
+                } else {
+                    self.action_fd_seek(fd, offset, whence)?;
+                }
+            }
+            JournalEntry::UpdateMemoryRegionV1 { region, data } => {
+                self.action_update_memory(region, data, differ_ethereal)?;
+            }
+            JournalEntry::CloseThreadV1 { id, exit_code } => {
+                self.action_close_thread(id, exit_code, differ_ethereal)?;
+            }
+            JournalEntry::SetThreadV1 {
+                id,
+                call_stack,
+                memory_stack,
+                store_data,
+                is_64bit,
+                start,
+                layout,
+            } => {
+                self.action_set_thread(
+                    id,
+                    call_stack,
+                    memory_stack,
+                    store_data,
+                    is_64bit,
+                    start,
+                    layout,
+                    differ_ethereal,
+                )?;
+            }
+            JournalEntry::CloseFileDescriptorV1 { fd } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_close(fd)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - FdClose");
+                    differ_ethereal.push(JournalEntry::CloseFileDescriptorV1 { fd });
+                } else {
+                    self.action_fd_close(fd)?;
+                }
+            }
+            JournalEntry::OpenFileDescriptorV1 {
+                fd,
+                dirfd,
+                dirflags,
+                path,
+                o_flags,
+                fs_rights_base,
+                fs_rights_inheriting,
+                fs_flags,
+            } => {
+                self.real_fd.insert(fd);
+                self.action_fd_open(
+                    fd,
+                    dirfd,
+                    dirflags,
+                    path,
+                    o_flags,
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                    fs_flags,
+                )?;
+            }
+            JournalEntry::RemoveDirectoryV1 { fd, path } => {
+                tracing::trace!("Replay journal - RemoveDirectory {}", path);
+                JournalEffector::apply_path_remove_directory(&mut self.ctx, fd, &path)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::UnlinkFileV1 { fd, path } => {
+                tracing::trace!("Replay journal - UnlinkFile {}", path);
+                JournalEffector::apply_path_unlink(&mut self.ctx, fd, &path)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::PathRenameV1 {
+                old_fd,
+                old_path,
+                new_fd,
+                new_path,
+            } => {
+                tracing::trace!("Replay journal - PathRename {}->{}", old_path, new_path);
+                JournalEffector::apply_path_rename(
+                    &mut self.ctx,
+                    old_fd,
+                    &old_path,
+                    new_fd,
+                    &new_path,
+                )
+                .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::SnapshotV1 { when, trigger } => {
+                self.action_snapshot(when, trigger, differ_ethereal)?;
+            }
+            JournalEntry::SetClockTimeV1 { clock_id, time } => {
+                tracing::trace!(?clock_id, %time, "Replay journal - ClockTimeSet");
+                JournalEffector::apply_clock_time_set(&mut self.ctx, clock_id, time)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd } => {
+                if self.real_fd.remove(&old_fd) {
+                    self.action_fd_renumber(old_fd, new_fd)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%old_fd, %new_fd, "Differ(ether) journal - FdRenumber");
+                    differ_ethereal.push(JournalEntry::RenumberFileDescriptorV1 { old_fd, new_fd });
+                } else {
+                    self.action_fd_renumber(old_fd, new_fd)?;
+                }
+            }
+            JournalEntry::DuplicateFileDescriptorV1 {
+                original_fd,
+                copied_fd,
+            } => {
+                if self.real_fd.contains(&original_fd) {
+                    self.action_fd_dup(original_fd, copied_fd)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%original_fd, %copied_fd, "Differ(ether) journal - FdDuplicate");
+                    differ_ethereal.push(JournalEntry::DuplicateFileDescriptorV1 {
+                        original_fd,
+                        copied_fd,
+                    });
+                } else {
+                    self.action_fd_dup(original_fd, copied_fd)?;
+                }
+            }
+            JournalEntry::CreateDirectoryV1 { fd, path } => {
+                tracing::trace!(%fd, %path, "Replay journal - CreateDirectory");
+                JournalEffector::apply_path_create_directory(&mut self.ctx, fd, &path)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::PathSetTimesV1 {
+                fd,
+                flags,
+                path,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - PathSetTimes");
+                    differ_ethereal.push(JournalEntry::PathSetTimesV1 {
+                        fd,
+                        flags,
+                        path,
+                        st_atim,
+                        st_mtim,
+                        fst_flags,
+                    });
+                } else {
+                    self.action_path_set_times(fd, flags, path, st_atim, st_mtim, fst_flags)?;
+                }
+            }
+            JournalEntry::FileDescriptorSetTimesV1 {
+                fd,
+                st_atim,
+                st_mtim,
+                fst_flags,
+            } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags)?
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %st_atim, %st_mtim, ?fst_flags, "Differ(ether) journal - FdSetTimes");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSetTimesV1 {
+                        fd,
+                        st_atim,
+                        st_mtim,
+                        fst_flags,
+                    });
+                } else {
+                    self.action_fd_set_times(fd, st_atim, st_mtim, fst_flags)?
+                }
+            }
+            JournalEntry::FileDescriptorSetSizeV1 { fd, st_size } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_set_size(fd, st_size)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %st_size, "Differ(ether) journal - FdSetSize");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSetSizeV1 { fd, st_size });
+                } else {
+                    self.action_fd_set_size(fd, st_size)?;
+                }
+            }
+            JournalEntry::FileDescriptorSetFlagsV1 { fd, flags } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_set_flags(fd, flags)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?flags, "Differ(ether) journal - FdSetFlags");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSetFlagsV1 { fd, flags });
+                } else {
+                    self.action_fd_set_flags(fd, flags)?;
+                }
+            }
+            JournalEntry::FileDescriptorSetRightsV1 {
+                fd,
+                fs_rights_base,
+                fs_rights_inheriting,
+            } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - FdSetRights");
+                    differ_ethereal.push(JournalEntry::FileDescriptorSetRightsV1 {
+                        fd,
+                        fs_rights_base,
+                        fs_rights_inheriting,
+                    });
+                } else {
+                    self.action_fd_set_rights(fd, fs_rights_base, fs_rights_inheriting)?;
+                }
+            }
+            JournalEntry::FileDescriptorAdviseV1 {
+                fd,
+                offset,
+                len,
+                advice,
+            } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_advise(fd, offset, len, advice)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %offset, %len, ?advice, "Differ(ether) journal - FdAdvise");
+                    differ_ethereal.push(JournalEntry::FileDescriptorAdviseV1 {
+                        fd,
+                        offset,
+                        len,
+                        advice,
+                    });
+                } else {
+                    self.action_fd_advise(fd, offset, len, advice)?;
+                }
+            }
+            JournalEntry::FileDescriptorAllocateV1 { fd, offset, len } => {
+                if self.real_fd.contains(&fd) {
+                    self.action_fd_allocate(fd, offset, len)?;
+                } else if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %offset, %len, "Differ(ether) journal - FdAllocate");
+                    differ_ethereal.push(JournalEntry::FileDescriptorAllocateV1 {
+                        fd,
+                        offset,
+                        len,
+                    });
+                } else {
+                    self.action_fd_allocate(fd, offset, len)?;
+                }
+            }
+            JournalEntry::CreateHardLinkV1 {
+                old_fd,
+                old_path,
+                old_flags,
+                new_fd,
+                new_path,
+            } => {
+                tracing::trace!("Replay journal - PathLink {}->{}", old_path, new_path);
+                JournalEffector::apply_path_link(
+                    &mut self.ctx,
+                    old_fd,
+                    old_flags,
+                    &old_path,
+                    new_fd,
+                    &new_path,
+                )
+                .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::CreateSymbolicLinkV1 {
+                old_path,
+                fd,
+                new_path,
+            } => {
+                tracing::trace!("Replay journal - PathSymlink {}->{}", old_path, new_path);
+                JournalEffector::apply_path_symlink(&mut self.ctx, &old_path, fd, &new_path)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::ChangeDirectoryV1 { path } => {
+                tracing::trace!("Replay journal - ChangeDirection {}", path);
+                JournalEffector::apply_chdir(&mut self.ctx, &path)
+                    .map_err(anyhow_err_to_runtime_err)?;
+            }
+            JournalEntry::CreatePipeV1 { fd1, fd2 } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd1, %fd2,  "Differ(ether) journal - CreatePipe");
+                    differ_ethereal.push(JournalEntry::CreatePipeV1 { fd1, fd2 });
+                } else {
+                    tracing::trace!(%fd1, %fd2,  "Replay journal - CreatePipe");
+                    JournalEffector::apply_fd_pipe(&mut self.ctx, fd1, fd2)
+                        .map_err(anyhow_err_to_runtime_err)?;
+                }
+            }
+            JournalEntry::EpollCreateV1 { fd } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - EpollCreate");
+                    differ_ethereal.push(JournalEntry::EpollCreateV1 { fd });
+                } else {
+                    tracing::trace!(%fd, "Replay journal - EpollCreate");
+                    JournalEffector::apply_epoll_create(&mut self.ctx, fd)
+                        .map_err(anyhow_err_to_runtime_err)?;
+                }
+            }
+            JournalEntry::EpollCtlV1 {
+                epfd,
+                op,
+                fd,
+                event,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%epfd, %fd, ?op, "Differ(ether) journal - EpollCtl");
+                    differ_ethereal.push(JournalEntry::EpollCtlV1 {
+                        epfd,
+                        op,
+                        fd,
+                        event,
+                    });
+                } else {
+                    tracing::trace!(%epfd, %fd, ?op, "Replay journal - EpollCtl");
+                    JournalEffector::apply_epoll_ctl(&mut self.ctx, epfd, op, fd, event)
+                        .map_err(anyhow_err_to_runtime_err)?;
+                }
+            }
+            JournalEntry::TtySetV1 { tty, line_feeds } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!("Differ(ether) journal - TtySet");
+                    differ_ethereal.push(JournalEntry::TtySetV1 { tty, line_feeds });
+                } else {
+                    self.action_tty_set(tty, line_feeds)?;
+                }
+            }
+            JournalEntry::PortAddAddrV1 { cidr } => {
+                tracing::trace!(?cidr, "Replay journal - PortAddAddr");
+                JournalEffector::apply_port_addr_add(&mut self.ctx, cidr)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortDelAddrV1 { addr } => {
+                tracing::trace!(?addr, "Replay journal - PortDelAddr");
+                JournalEffector::apply_port_addr_remove(&mut self.ctx, addr)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortAddrClearV1 => {
+                tracing::trace!("Replay journal - PortAddrClear");
+                JournalEffector::apply_port_addr_clear(&mut self.ctx)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortBridgeV1 {
+                network,
+                token,
+                security,
+            } => {
+                tracing::trace!("Replay journal - PortBridge");
+                JournalEffector::apply_port_bridge(&mut self.ctx, &network, &token, security)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortUnbridgeV1 => {
+                tracing::trace!("Replay journal - PortUnBridge");
+                JournalEffector::apply_port_unbridge(&mut self.ctx)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortDhcpAcquireV1 => {
+                tracing::trace!("Replay journal - PortDhcpAcquire");
+                JournalEffector::apply_port_dhcp_acquire(&mut self.ctx)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortGatewaySetV1 { ip } => {
+                tracing::trace!(?ip, "Replay journal - PortGatewaySet");
+                JournalEffector::apply_port_gateway_set(&mut self.ctx, ip)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortRouteAddV1 {
+                cidr,
+                via_router,
+                preferred_until,
+                expires_at,
+            } => {
+                tracing::trace!(?cidr, "Replay journal - PortRouteAdd");
+                JournalEffector::apply_port_route_add(
+                    &mut self.ctx,
+                    cidr,
+                    via_router,
+                    preferred_until,
+                    expires_at,
+                )
+                .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortRouteClearV1 => {
+                tracing::trace!("Replay journal - PortRouteClear");
+                JournalEffector::apply_port_route_clear(&mut self.ctx)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::PortRouteDelV1 { ip } => {
+                tracing::trace!(?ip, "Replay journal - PortRouteDel");
+                JournalEffector::apply_port_route_remove(&mut self.ctx, ip)
+                    .map_err(anyhow_err_to_runtime_err)?
+            }
+            JournalEntry::SocketOpenV1 { af, ty, pt, fd } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(?af, ?ty, ?pt, %fd, "Differ(ether) journal - SocketOpen");
+                    differ_ethereal.push(JournalEntry::SocketOpenV1 { af, ty, pt, fd });
+                } else {
+                    tracing::trace!(?af, ?ty, ?pt, %fd, "Replay journal - SocketOpen");
+                    JournalEffector::apply_sock_open(&mut self.ctx, af, ty, pt, fd)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketListenV1 { fd, backlog } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - SocketListen");
+                    differ_ethereal.push(JournalEntry::SocketListenV1 { fd, backlog });
+                } else {
+                    tracing::trace!(%fd, "Replay journal - SocketListen");
+                    JournalEffector::apply_sock_listen(&mut self.ctx, fd, backlog as usize)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketBindV1 { fd, addr } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?addr, "Differ(ether) journal - SocketBind");
+                    differ_ethereal.push(JournalEntry::SocketBindV1 { fd, addr });
+                } else {
+                    tracing::trace!(%fd, ?addr, "Replay journal - SocketBind");
+                    JournalEffector::apply_sock_bind(&mut self.ctx, fd, addr)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketConnectedV1 {
+                fd,
+                local_addr,
+                peer_addr,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?peer_addr, "Differ(ether) journal - SockConnect");
+                    differ_ethereal.push(JournalEntry::SocketConnectedV1 {
+                        fd,
+                        local_addr,
+                        peer_addr,
+                    });
+                } else {
+                    tracing::trace!(%fd, ?peer_addr, "Replay journal - SockConnect");
+                    JournalEffector::apply_sock_connect(&mut self.ctx, fd, local_addr, peer_addr)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketAcceptedV1 {
+                listen_fd,
+                fd,
+                local_addr: addr,
+                peer_addr,
+                fd_flags,
+                non_blocking: nonblocking,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%listen_fd, %fd, ?peer_addr, "Differ(ether) journal - SocketAccept");
+                    differ_ethereal.push(JournalEntry::SocketAcceptedV1 {
+                        listen_fd,
+                        fd,
+                        local_addr: addr,
+                        peer_addr,
+                        fd_flags,
+                        non_blocking: nonblocking,
+                    });
+                } else {
+                    tracing::trace!(%listen_fd, %fd, ?peer_addr, "Replay journal - SocketAccept");
+                    JournalEffector::apply_sock_accepted(
+                        &mut self.ctx,
+                        listen_fd,
+                        fd,
+                        addr,
+                        peer_addr,
+                        fd_flags,
+                        nonblocking,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketJoinIpv4MulticastV1 {
+                fd,
+                multiaddr,
+                iface,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?multiaddr, "Differ(ether) journal - JoinIpv4Multicast");
+                    differ_ethereal.push(JournalEntry::SocketJoinIpv4MulticastV1 {
+                        fd,
+                        multiaddr,
+                        iface,
+                    });
+                } else {
+                    tracing::trace!(%fd, ?multiaddr, "Replay journal - JoinIpv4Multicast");
+                    JournalEffector::apply_sock_join_ipv4_multicast(
+                        &mut self.ctx,
+                        fd,
+                        multiaddr,
+                        iface,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketJoinIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?multiaddr, "Differ(ether) journal - JoinIpv6Multicast");
+                    differ_ethereal.push(JournalEntry::SocketJoinIpv6MulticastV1 {
+                        fd,
+                        multi_addr: multiaddr,
+                        iface,
+                    });
+                } else {
+                    tracing::trace!(%fd, ?multiaddr, "Replay journal - JoinIpv6Multicast");
+                    JournalEffector::apply_sock_join_ipv6_multicast(
+                        &mut self.ctx,
+                        fd,
+                        multiaddr,
+                        iface,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketLeaveIpv4MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?multiaddr, "Differ(ether) journal - LeaveIpv4Multicast");
+                    differ_ethereal.push(JournalEntry::SocketLeaveIpv4MulticastV1 {
+                        fd,
+                        multi_addr: multiaddr,
+                        iface,
+                    });
+                } else {
+                    tracing::trace!(%fd, ?multiaddr, "Replay journal - LeaveIpv4Multicast");
+                    JournalEffector::apply_sock_leave_ipv4_multicast(
+                        &mut self.ctx,
+                        fd,
+                        multiaddr,
+                        iface,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketLeaveIpv6MulticastV1 {
+                fd,
+                multi_addr: multiaddr,
+                iface,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?multiaddr, "Differ(ether) journal - LeaveIpv6Multicast");
+                    differ_ethereal.push(JournalEntry::SocketLeaveIpv6MulticastV1 {
+                        fd,
+                        multi_addr: multiaddr,
+                        iface,
+                    });
+                } else {
+                    tracing::trace!(%fd, ?multiaddr, "Replay journal - LeaveIpv6Multicast");
+                    JournalEffector::apply_sock_leave_ipv6_multicast(
+                        &mut self.ctx,
+                        fd,
+                        multiaddr,
+                        iface,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSendFileV1 {
+                socket_fd,
+                file_fd,
+                offset,
+                count,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%socket_fd, %file_fd, %offset, %count, "Differ(ether) journal - SockSendFile");
+                    differ_ethereal.push(JournalEntry::SocketSendFileV1 {
+                        socket_fd,
+                        file_fd,
+                        offset,
+                        count,
+                    });
+                } else {
+                    tracing::trace!(%socket_fd, %file_fd, %offset, %count, "Replay journal - SockSendFile");
+                    JournalEffector::apply_sock_send_file(
+                        &mut self.ctx,
+                        socket_fd,
+                        file_fd,
+                        offset,
+                        count,
+                    )
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSendToV1 {
+                fd,
+                data,
+                flags,
+                addr,
+                is_64bit,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - SocketSendTo data={} bytes", data.len());
+                    differ_ethereal.push(JournalEntry::SocketSendToV1 {
+                        fd,
+                        data,
+                        flags,
+                        addr,
+                        is_64bit,
+                    });
+                } else {
+                    tracing::trace!(%fd, "Replay journal - SocketSendTo data={} bytes", data.len());
+                    if is_64bit {
+                        JournalEffector::apply_sock_send_to::<Memory64>(
+                            &self.ctx, fd, data, flags, addr,
+                        )
+                    } else {
+                        JournalEffector::apply_sock_send_to::<Memory32>(
+                            &self.ctx, fd, data, flags, addr,
+                        )
+                    }
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSendV1 {
+                fd,
+                data,
+                flags,
+                is_64bit,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, "Differ(ether) journal - SocketSend data={} bytes", data.len());
+                    differ_ethereal.push(JournalEntry::SocketSendV1 {
+                        fd,
+                        data,
+                        flags,
+                        is_64bit,
+                    });
+                } else {
+                    tracing::trace!(%fd, "Replay journal - SocketSend data={} bytes", data.len());
+                    if is_64bit {
+                        JournalEffector::apply_sock_send::<Memory64>(&self.ctx, fd, data, flags)
+                    } else {
+                        JournalEffector::apply_sock_send::<Memory32>(&self.ctx, fd, data, flags)
+                    }
+                    .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSetOptFlagV1 { fd, opt, flag } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?opt, %flag, "Differ(ether) journal - SocketSetOptFlag");
+                    differ_ethereal.push(JournalEntry::SocketSetOptFlagV1 { fd, opt, flag });
+                } else {
+                    tracing::trace!(%fd, ?opt, %flag, "Replay journal - SocketSetOptFlag");
+                    JournalEffector::apply_sock_set_opt_flag(&mut self.ctx, fd, opt, flag)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSetOptSizeV1 { fd, opt, size } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?opt, %size, "Differ(ether) journal - SocketSetOptSize");
+                    differ_ethereal.push(JournalEntry::SocketSetOptSizeV1 { fd, opt, size });
+                } else {
+                    tracing::trace!(%fd, ?opt, %size, "Replay journal - SocketSetOptSize");
+                    JournalEffector::apply_sock_set_opt_size(&mut self.ctx, fd, opt, size)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketSetOptTimeV1 { fd, ty, time } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?ty, ?time, "Differ(ether) journal - SocketSetOptTime");
+                    differ_ethereal.push(JournalEntry::SocketSetOptTimeV1 { fd, ty, time });
+                } else {
+                    tracing::trace!(%fd, ?ty, ?time, "Replay journal - SocketSetOptTime");
+                    JournalEffector::apply_sock_set_opt_time(&mut self.ctx, fd, ty.into(), time)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::SocketShutdownV1 { fd, how } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, ?how, "Differ(ether) journal - SocketShutdown");
+                    differ_ethereal.push(JournalEntry::SocketShutdownV1 { fd, how });
+                } else {
+                    tracing::trace!(%fd, ?how, "Replay journal - SocketShutdown");
+                    JournalEffector::apply_sock_shutdown(&mut self.ctx, fd, how.into())
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+            JournalEntry::CreateEventV1 {
+                initial_val,
+                flags,
+                fd,
+            } => {
+                if let Some(differ_ethereal) = differ_ethereal {
+                    tracing::trace!(%fd, %flags, "Differ(ether) journal - CreateEvent");
+                    differ_ethereal.push(JournalEntry::CreateEventV1 {
+                        initial_val,
+                        flags,
+                        fd,
+                    });
+                } else {
+                    tracing::trace!(%fd, %flags, "Replay journal - CreateEvent");
+                    JournalEffector::apply_fd_event(&mut self.ctx, initial_val, flags, fd)
+                        .map_err(anyhow_err_to_runtime_err)?
+                }
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/restore_snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/restore_snapshot.rs
new file mode 100644
index 0000000..6535ebf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/restore_snapshot.rs
@@ -0,0 +1,89 @@
+use super::*;
+
+/// Safety: This function manipulates the memory of the process and thus must
+/// be executed by the WASM process thread itself.
+///
+#[allow(clippy::result_large_err)]
+#[cfg(feature = "journal")]
+pub unsafe fn restore_snapshot(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    journal: Arc<DynJournal>,
+    bootstrapping: bool,
+) -> Result<Option<RewindState>, WasiRuntimeError> {
+    use std::{collections::BTreeMap, ops::Range};
+
+    use crate::{journal::Journal, os::task::process::MemorySnapshotRegion};
+
+    // Create the journal replay runner
+    let mut runner = JournalSyscallPlayer::new(ctx, bootstrapping);
+
+    // We read all the logs from the journal into the state machine
+    let mut ethereal_events = Vec::new();
+    while let Some(next) = journal.read().map_err(anyhow_err_to_runtime_err)? {
+        runner.play_event(next.into_inner(), Some(&mut ethereal_events));
+    }
+
+    // Check for events that are orphaned
+    for evt in ethereal_events {
+        tracing::debug!("Orphaned ethereal events - {:?}", evt);
+    }
+
+    // Now output the stdout and stderr
+    for (offset, data, is_64bit) in runner.stdout {
+        if is_64bit {
+            JournalEffector::apply_fd_write::<Memory64>(&runner.ctx, 1, offset, data)
+        } else {
+            JournalEffector::apply_fd_write::<Memory32>(&runner.ctx, 1, offset, data)
+        }
+        .map_err(anyhow_err_to_runtime_err)?;
+    }
+
+    for (offset, data, is_64bit) in runner.stderr {
+        if is_64bit {
+            JournalEffector::apply_fd_write::<Memory64>(&runner.ctx, 2, offset, data)
+        } else {
+            JournalEffector::apply_fd_write::<Memory32>(&runner.ctx, 2, offset, data)
+        }
+        .map_err(anyhow_err_to_runtime_err)?;
+    }
+
+    // Apply the memory changes (if this is in bootstrapping mode we differed them)
+    for (region, data) in runner.differ_memory {
+        tracing::trace!(
+            "Replay journal - UpdateMemory - region:{:?}, data.len={}",
+            region,
+            data.len()
+        );
+        JournalEffector::apply_memory(&mut runner.ctx, region, &data)
+            .map_err(anyhow_err_to_runtime_err)?;
+    }
+
+    // Spawn all the threads
+    for (thread_id, thread_state) in runner.spawn_threads {
+        if thread_state.is_64bit {
+            JournalEffector::apply_thread_state::<Memory64>(
+                &mut runner.ctx,
+                thread_id,
+                thread_state.memory_stack,
+                thread_state.rewind_stack,
+                thread_state.store_data,
+                thread_state.start,
+                thread_state.layout,
+            )
+            .map_err(anyhow_err_to_runtime_err)?;
+        } else {
+            JournalEffector::apply_thread_state::<Memory32>(
+                &mut runner.ctx,
+                thread_id,
+                thread_state.memory_stack,
+                thread_state.rewind_stack,
+                thread_state.store_data,
+                thread_state.start,
+                thread_state.layout,
+            )
+            .map_err(anyhow_err_to_runtime_err)?;
+        }
+    }
+
+    Ok(runner.rewind)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/wait_for_snapshot.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/wait_for_snapshot.rs
new file mode 100644
index 0000000..bead215
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/journal/wait_for_snapshot.rs
@@ -0,0 +1,31 @@
+use super::*;
+
+#[cfg(not(feature = "journal"))]
+pub fn wait_for_snapshot(_env: &WasiEnv) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
+    Box::pin(std::future::pending())
+}
+
+#[cfg(feature = "journal")]
+pub fn wait_for_snapshot(env: &WasiEnv) -> Pin<Box<dyn Future<Output = ()> + Send + Sync>> {
+    use crate::os::task::process::{LockableWasiProcessInner, WasiProcessCheckpoint};
+
+    struct Poller {
+        inner: LockableWasiProcessInner,
+    }
+    impl Future for Poller {
+        type Output = ();
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            let mut guard = self.inner.0.lock().unwrap();
+            if !matches!(guard.checkpoint, WasiProcessCheckpoint::Execute) {
+                return Poll::Ready(());
+            }
+            if !guard.wakers.iter().any(|w| w.will_wake(cx.waker())) {
+                guard.wakers.push(cx.waker().clone());
+            }
+            Poll::Pending
+        }
+    }
+    Box::pin(Poller {
+        inner: env.process.inner.clone(),
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/mod.rs
new file mode 100644
index 0000000..62cc08f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/mod.rs
@@ -0,0 +1,5 @@
+//! These modules provide wrappers and implementations for older version of WASI.
+//!
+//! If you are relying on legacy WASI, please upgrade for the best experience.
+
+pub mod snapshot0;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/snapshot0.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/snapshot0.rs
new file mode 100644
index 0000000..215c996
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/legacy/snapshot0.rs
@@ -0,0 +1,131 @@
+use tracing::{field, instrument, trace_span};
+use wasmer::{AsStoreMut, AsStoreRef, FunctionEnvMut, Memory, WasmPtr};
+use wasmer_wasix_types::wasi::{
+    Errno, Event, EventFdReadwrite, Eventrwflags, Eventtype, ExitCode, Fd, Filesize, Filestat,
+    Filetype, Snapshot0Event, Snapshot0Filestat, Snapshot0Subscription, Snapshot0Whence,
+    Subscription, Whence,
+};
+
+use crate::{
+    mem_error_to_wasi,
+    os::task::thread::WasiThread,
+    state::{PollEventBuilder, PollEventSet},
+    syscalls::types,
+    syscalls::{self, handle_rewind},
+    Memory32, MemorySize, WasiEnv, WasiError,
+};
+
+/// Wrapper around `syscalls::fd_filestat_get` for old Snapshot0
+#[instrument(level = "debug", skip_all, ret)]
+pub fn fd_filestat_get(
+    mut ctx: FunctionEnvMut<WasiEnv>,
+    fd: Fd,
+    buf: WasmPtr<Snapshot0Filestat, Memory32>,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let result = syscalls::fd_filestat_get_old::<Memory32>(ctx.as_mut(), fd, buf);
+
+    result
+}
+
+/// Wrapper around `syscalls::path_filestat_get` for old Snapshot0
+#[instrument(level = "debug", skip_all, ret)]
+pub fn path_filestat_get(
+    mut ctx: FunctionEnvMut<WasiEnv>,
+    fd: Fd,
+    flags: types::LookupFlags,
+    path: WasmPtr<u8, Memory32>,
+    path_len: u32,
+    buf: WasmPtr<Snapshot0Filestat, Memory32>,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let result =
+        syscalls::path_filestat_get_old::<Memory32>(ctx.as_mut(), fd, flags, path, path_len, buf);
+
+    result
+}
+
+/// Wrapper around `syscalls::fd_seek` with extra logic to remap the values
+/// of `Whence`
+#[instrument(level = "debug", skip_all, ret)]
+pub fn fd_seek(
+    ctx: FunctionEnvMut<WasiEnv>,
+    fd: Fd,
+    offset: types::FileDelta,
+    whence: Snapshot0Whence,
+    newoffset: WasmPtr<Filesize, Memory32>,
+) -> Result<Errno, WasiError> {
+    let new_whence = match whence {
+        Snapshot0Whence::Cur => Whence::Cur,
+        Snapshot0Whence::End => Whence::End,
+        Snapshot0Whence::Set => Whence::Set,
+        Snapshot0Whence::Unknown => return Ok(Errno::Inval),
+    };
+    syscalls::fd_seek::<Memory32>(ctx, fd, offset, new_whence, newoffset)
+}
+
+/// Wrapper around `syscalls::poll_oneoff` with extra logic to add the removed
+/// userdata field back
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
+pub fn poll_oneoff<M: MemorySize>(
+    mut ctx: FunctionEnvMut<WasiEnv>,
+    in_: WasmPtr<Snapshot0Subscription, Memory32>,
+    out_: WasmPtr<Snapshot0Event, Memory32>,
+    nsubscriptions: u32,
+    nevents: WasmPtr<u32, Memory32>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let mut subscriptions = Vec::new();
+    let in_origs = wasi_try_mem_ok!(in_.slice(&memory, nsubscriptions));
+    let in_origs = wasi_try_mem_ok!(in_origs.read_to_vec());
+    for in_orig in in_origs {
+        subscriptions.push((
+            None,
+            PollEventSet::default(),
+            Into::<Subscription>::into(in_orig),
+        ));
+    }
+
+    // Function to invoke once the poll is finished
+    let process_events = |ctx: &FunctionEnvMut<'_, WasiEnv>, triggered_events: Vec<Event>| {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+
+        // Process all the events that were triggered
+        let mut events_seen: u32 = 0;
+        let event_array = wasi_try_mem!(out_.slice(&memory, nsubscriptions));
+        for event in triggered_events {
+            let event = Snapshot0Event {
+                userdata: event.userdata,
+                error: event.error,
+                type_: Eventtype::FdRead,
+                fd_readwrite: match event.type_ {
+                    Eventtype::FdRead => unsafe { event.u.fd_readwrite },
+                    Eventtype::FdWrite => unsafe { event.u.fd_readwrite },
+                    Eventtype::Clock => EventFdReadwrite {
+                        nbytes: 0,
+                        flags: Eventrwflags::empty(),
+                    },
+                    Eventtype::Unknown => return Errno::Inval,
+                },
+            };
+            wasi_try_mem!(event_array.index(events_seen as u64).write(event));
+            events_seen += 1;
+        }
+        let out_ptr = nevents.deref(&memory);
+        wasi_try_mem!(out_ptr.write(events_seen));
+        Errno::Success
+    };
+
+    // We clear the number of events
+    wasi_try_mem_ok!(nevents.write(&memory, 0));
+
+    // Poll and receive all the events that triggered
+    syscalls::poll_oneoff_internal::<M, _>(ctx, subscriptions, process_events)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/mod.rs
new file mode 100644
index 0000000..0374b9d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/mod.rs
@@ -0,0 +1,1518 @@
+#![allow(unused, clippy::too_many_arguments, clippy::cognitive_complexity)]
+
+pub mod types {
+    pub use wasmer_wasix_types::{types::*, wasi};
+}
+
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "android",
+    target_vendor = "apple"
+))]
+pub mod unix;
+#[cfg(target_family = "wasm")]
+pub mod wasm;
+#[cfg(target_os = "windows")]
+pub mod windows;
+
+pub mod journal;
+pub mod wasi;
+pub mod wasix;
+
+use bytes::{Buf, BufMut};
+use futures::{
+    future::{BoxFuture, LocalBoxFuture},
+    Future,
+};
+use tracing::instrument;
+pub use wasi::*;
+pub use wasix::*;
+use wasmer_journal::SnapshotTrigger;
+use wasmer_wasix_types::wasix::ThreadStartType;
+
+pub mod legacy;
+
+pub(crate) use std::{
+    borrow::{Borrow, Cow},
+    cell::RefCell,
+    collections::{hash_map::Entry, HashMap, HashSet},
+    convert::{Infallible, TryInto},
+    io::{self, Read, Seek, Write},
+    mem::transmute,
+    net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    num::NonZeroU64,
+    ops::{Deref, DerefMut},
+    path::Path,
+    pin::Pin,
+    sync::{
+        atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering},
+        mpsc, Arc, Condvar, Mutex,
+    },
+    task::{Context, Poll},
+    thread::LocalKey,
+    time::Duration,
+};
+use std::{io::IoSlice, marker::PhantomData, mem::MaybeUninit, task::Waker, time::Instant};
+
+pub(crate) use bytes::{Bytes, BytesMut};
+pub(crate) use cooked_waker::IntoWaker;
+pub use journal::*;
+pub(crate) use sha2::Sha256;
+pub(crate) use tracing::{debug, error, trace, warn};
+#[cfg(any(
+    target_os = "freebsd",
+    target_os = "linux",
+    target_os = "android",
+    target_vendor = "apple"
+))]
+pub use unix::*;
+#[cfg(target_family = "wasm")]
+pub use wasm::*;
+
+pub(crate) use virtual_fs::{
+    AsyncSeekExt, AsyncWriteExt, DuplexPipe, FileSystem, FsError, VirtualFile,
+};
+pub(crate) use virtual_net::StreamSecurity;
+pub(crate) use wasmer::{
+    AsStoreMut, AsStoreRef, Extern, Function, FunctionEnv, FunctionEnvMut, Global, Instance,
+    Memory, Memory32, Memory64, MemoryAccessError, MemoryError, MemorySize, MemoryView, Module,
+    OnCalledAction, Pages, RuntimeError, Store, TypedFunction, Value, WasmPtr, WasmSlice,
+};
+pub(crate) use wasmer_wasix_types::{asyncify::__wasi_asyncify_t, wasi::EventUnion};
+#[cfg(target_os = "windows")]
+pub use windows::*;
+
+pub(crate) use self::types::{
+    wasi::{
+        Addressfamily, Advice, Clockid, Dircookie, Dirent, Errno, Event, EventFdReadwrite,
+        Eventrwflags, Eventtype, ExitCode, Fd as WasiFd, Fdflags, Fdstat, Filesize, Filestat,
+        Filetype, Fstflags, Linkcount, Longsize, OptionFd, Pid, Prestat, Rights, Snapshot0Clockid,
+        Sockoption, Sockstatus, Socktype, StackSnapshot, StdioMode as WasiStdioMode,
+        Streamsecurity, Subscription, SubscriptionFsReadwrite, Tid, Timestamp, TlKey, TlUser,
+        TlVal, Tty, Whence,
+    },
+    *,
+};
+use self::{state::WasiInstanceGuardMemory, utils::WasiDummyWaker};
+pub(crate) use crate::os::task::{
+    process::{WasiProcessId, WasiProcessWait},
+    thread::{WasiThread, WasiThreadId},
+};
+pub(crate) use crate::{
+    bin_factory::spawn_exec_module,
+    import_object_for_all_wasi_versions, mem_error_to_wasi,
+    net::{
+        read_ip_port,
+        socket::{InodeHttpSocketType, InodeSocket, InodeSocketKind},
+        write_ip_port,
+    },
+    runtime::SpawnMemoryType,
+    state::{
+        self, iterate_poll_events, InodeGuard, InodeWeakGuard, PollEvent, PollEventBuilder,
+        WasiFutex, WasiState,
+    },
+    utils::{self, map_io_err},
+    Runtime, VirtualTaskManager, WasiEnv, WasiError, WasiFunctionEnv, WasiInstanceHandles,
+    WasiVFork,
+};
+use crate::{
+    fs::{
+        fs_error_into_wasi_err, virtual_file_type_to_wasi_file_type, Fd, InodeVal, Kind,
+        MAX_SYMLINKS,
+    },
+    journal::{DynJournal, JournalEffector},
+    os::task::{
+        process::{MaybeCheckpointResult, WasiProcessCheckpoint},
+        thread::{RewindResult, RewindResultType},
+    },
+    runtime::task_manager::InlineWaker,
+    utils::store::StoreSnapshot,
+    DeepSleepWork, RewindPostProcess, RewindState, RewindStateOption, SpawnError, WasiInodes,
+    WasiResult, WasiRuntimeError,
+};
+pub(crate) use crate::{net::net_error_into_wasi_err, utils::WasiParkingLot};
+
+pub(crate) fn to_offset<M: MemorySize>(offset: usize) -> Result<M::Offset, Errno> {
+    let ret: M::Offset = offset.try_into().map_err(|_| Errno::Inval)?;
+    Ok(ret)
+}
+
+pub(crate) fn from_offset<M: MemorySize>(offset: M::Offset) -> Result<usize, Errno> {
+    let ret: usize = offset.try_into().map_err(|_| Errno::Inval)?;
+    Ok(ret)
+}
+
+pub(crate) fn write_bytes_inner<T: Write, M: MemorySize>(
+    mut write_loc: T,
+    memory: &MemoryView,
+    iovs_arr_cell: WasmSlice<__wasi_ciovec_t<M>>,
+) -> Result<usize, Errno> {
+    let mut bytes_written = 0usize;
+    for iov in iovs_arr_cell.iter() {
+        let iov_inner = iov.read().map_err(mem_error_to_wasi)?;
+        let bytes = WasmPtr::<u8, M>::new(iov_inner.buf)
+            .slice(memory, iov_inner.buf_len)
+            .map_err(mem_error_to_wasi)?;
+        let bytes = bytes.read_to_vec().map_err(mem_error_to_wasi)?;
+        write_loc.write_all(&bytes).map_err(map_io_err)?;
+
+        bytes_written += from_offset::<M>(iov_inner.buf_len)?;
+    }
+    Ok(bytes_written)
+}
+
+pub(crate) fn write_bytes<T: Write, M: MemorySize>(
+    mut write_loc: T,
+    memory: &MemoryView,
+    iovs_arr: WasmSlice<__wasi_ciovec_t<M>>,
+) -> Result<usize, Errno> {
+    let result = write_bytes_inner::<_, M>(&mut write_loc, memory, iovs_arr);
+    write_loc.flush();
+    result
+}
+
+pub(crate) fn copy_from_slice<M: MemorySize>(
+    mut read_loc: &[u8],
+    memory: &MemoryView,
+    iovs_arr: WasmSlice<__wasi_iovec_t<M>>,
+) -> Result<usize, Errno> {
+    let mut bytes_read = 0usize;
+
+    let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+    for iovs in iovs_arr.iter() {
+        let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+            .slice(memory, iovs.buf_len)
+            .map_err(mem_error_to_wasi)?
+            .access()
+            .map_err(mem_error_to_wasi)?;
+
+        let to_read = from_offset::<M>(iovs.buf_len)?;
+        let to_read = to_read.min(read_loc.len());
+        if to_read == 0 {
+            break;
+        }
+        let (left, right) = read_loc.split_at(to_read);
+        buf.copy_from_slice(left);
+
+        read_loc = right;
+        bytes_read += to_read;
+    }
+    Ok(bytes_read)
+}
+
+pub(crate) fn read_bytes<T: Read, M: MemorySize>(
+    mut reader: T,
+    memory: &MemoryView,
+    iovs_arr: WasmSlice<__wasi_iovec_t<M>>,
+) -> Result<usize, Errno> {
+    let mut bytes_read = 0usize;
+
+    let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+    for iovs in iovs_arr.iter() {
+        let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+            .slice(memory, iovs.buf_len)
+            .map_err(mem_error_to_wasi)?
+            .access()
+            .map_err(mem_error_to_wasi)?;
+
+        let to_read = buf.len();
+        let has_read = reader.read(buf.as_mut()).map_err(map_io_err)?;
+
+        bytes_read += has_read;
+        if has_read != to_read {
+            return Ok(bytes_read);
+        }
+    }
+    Ok(bytes_read)
+}
+
+/// Writes data to the stderr
+
+// TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
+#[allow(clippy::await_holding_lock)]
+pub unsafe fn stderr_write<'a>(
+    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    buf: &[u8],
+) -> LocalBoxFuture<'a, Result<(), Errno>> {
+    let env = ctx.data();
+    let (memory, state, inodes) = env.get_memory_and_wasi_state_and_inodes(ctx, 0);
+
+    let buf = buf.to_vec();
+    let fd_map = state.fs.fd_map.clone();
+    Box::pin(async move {
+        let mut stderr = WasiInodes::stderr_mut(&fd_map).map_err(fs_error_into_wasi_err)?;
+        stderr.write_all(&buf).await.map_err(map_io_err)
+    })
+}
+
+fn block_on_with_timeout<T, Fut>(
+    tasks: &Arc<dyn VirtualTaskManager>,
+    timeout: Option<Duration>,
+    work: Fut,
+) -> WasiResult<T>
+where
+    Fut: Future<Output = WasiResult<T>>,
+{
+    let mut nonblocking = false;
+    if timeout == Some(Duration::ZERO) {
+        nonblocking = true;
+    }
+    let timeout = async {
+        if let Some(timeout) = timeout {
+            if !nonblocking {
+                tasks.sleep_now(timeout).await
+            } else {
+                InfiniteSleep::default().await
+            }
+        } else {
+            InfiniteSleep::default().await
+        }
+    };
+
+    let work = async move {
+        tokio::select! {
+            // The main work we are doing
+            res = work => res,
+            // Optional timeout
+            _ = timeout => Ok(Err(Errno::Timedout)),
+        }
+    };
+
+    // Fast path
+    if nonblocking {
+        let waker = WasiDummyWaker.into_waker();
+        let mut cx = Context::from_waker(&waker);
+        let mut pinned_work = Box::pin(work);
+        if let Poll::Ready(res) = pinned_work.as_mut().poll(&mut cx) {
+            return res;
+        }
+        return Ok(Err(Errno::Again));
+    }
+
+    // Slow path, block on the work and process process
+    InlineWaker::block_on(work)
+}
+
+/// Asyncify takes the current thread and blocks on the async runtime associated with it
+/// thus allowed for asynchronous operations to execute. It has built in functionality
+/// to (optionally) timeout the IO, force exit the process, callback signals and pump
+/// synchronous IO engine
+pub(crate) fn __asyncify<T, Fut>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    timeout: Option<Duration>,
+    work: Fut,
+) -> WasiResult<T>
+where
+    T: 'static,
+    Fut: std::future::Future<Output = Result<T, Errno>>,
+{
+    let mut env = ctx.data();
+
+    // Check if we need to exit the asynchronous loop
+    if let Some(exit_code) = env.should_exit() {
+        return Err(WasiError::Exit(exit_code));
+    }
+
+    // This poller will process any signals when the main working function is idle
+    struct SignalPoller<'a, 'b, Fut, T>
+    where
+        Fut: Future<Output = Result<T, Errno>>,
+    {
+        ctx: &'a mut FunctionEnvMut<'b, WasiEnv>,
+        pinned_work: Pin<Box<Fut>>,
+    }
+    impl<'a, 'b, Fut, T> Future for SignalPoller<'a, 'b, Fut, T>
+    where
+        Fut: Future<Output = Result<T, Errno>>,
+    {
+        type Output = Result<Fut::Output, WasiError>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            if let Poll::Ready(res) = Pin::new(&mut self.pinned_work).poll(cx) {
+                return Poll::Ready(Ok(res));
+            }
+            if let Some(signals) = self.ctx.data().thread.pop_signals_or_subscribe(cx.waker()) {
+                if let Err(err) = WasiEnv::process_signals_internal(self.ctx, signals) {
+                    return Poll::Ready(Err(err));
+                }
+                return Poll::Ready(Ok(Err(Errno::Intr)));
+            }
+            Poll::Pending
+        }
+    }
+
+    // Block on the work
+    let mut pinned_work = Box::pin(work);
+    let tasks = env.tasks().clone();
+    let poller = SignalPoller { ctx, pinned_work };
+    block_on_with_timeout(&tasks, timeout, poller)
+}
+
+/// Future that will be polled by asyncify methods
+/// (the return value is what will be returned in rewind
+///  or in the instant response)
+pub type AsyncifyFuture = dyn Future<Output = Bytes> + Send + Sync + 'static;
+
+// This poller will process any signals when the main working function is idle
+struct AsyncifyPoller<'a, 'b, 'c, T, Fut>
+where
+    Fut: Future<Output = T> + Send + Sync + 'static,
+{
+    process_signals: bool,
+    ctx: &'b mut FunctionEnvMut<'c, WasiEnv>,
+    work: &'a mut Pin<Box<Fut>>,
+}
+impl<'a, 'b, 'c, T, Fut> Future for AsyncifyPoller<'a, 'b, 'c, T, Fut>
+where
+    Fut: Future<Output = T> + Send + Sync + 'static,
+{
+    type Output = Result<T, WasiError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if let Poll::Ready(res) = self.work.as_mut().poll(cx) {
+            return Poll::Ready(Ok(res));
+        }
+
+        let env = self.ctx.data();
+        if let Some(forced_exit) = env.thread.try_join() {
+            return Poll::Ready(Err(WasiError::Exit(forced_exit.unwrap_or_else(|err| {
+                tracing::debug!("exit runtime error - {}", err);
+                Errno::Child.into()
+            }))));
+        }
+        if self.process_signals && env.thread.has_signals_or_subscribe(cx.waker()) {
+            let signals = env.thread.signals().lock().unwrap();
+            for sig in signals.0.iter() {
+                if *sig == Signal::Sigint
+                    || *sig == Signal::Sigquit
+                    || *sig == Signal::Sigkill
+                    || *sig == Signal::Sigabrt
+                {
+                    let exit_code = env.thread.set_or_get_exit_code_for_signal(*sig);
+                    return Poll::Ready(Err(WasiError::Exit(exit_code)));
+                }
+            }
+        }
+        Poll::Pending
+    }
+}
+
+pub enum AsyncifyAction<'a, R> {
+    /// Indicates that asyncify callback finished and the
+    /// caller now has ownership of the ctx again
+    Finish(FunctionEnvMut<'a, WasiEnv>, R),
+    /// Indicates that asyncify should unwind by immediately exiting
+    /// the current function
+    Unwind,
+}
+
+/// Exponentially increasing backoff of CPU usage
+///
+/// Under certain conditions the process will exponentially backoff
+/// using waits that either put the thread into a low usage state
+/// or even underload the thread completely when deep sleep is enabled
+///
+/// The use-case for this is to handle rogue WASM processes that
+/// generate excessively high CPU usage and need to be artificially
+/// throttled
+///
+pub(crate) fn maybe_backoff<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<FunctionEnvMut<'_, WasiEnv>, Errno>, WasiError> {
+    let env = ctx.data();
+
+    // Fast path that exits this high volume call if we do not have
+    // exponential backoff enabled
+    if env.enable_exponential_cpu_backoff.is_none() {
+        return Ok(Ok(ctx));
+    }
+
+    // Determine if we need to do a backoff, if so lets do one
+    if let Some(backoff) = env.process.acquire_cpu_backoff_token(env.tasks()) {
+        tracing::trace!("exponential CPU backoff {:?}", backoff.backoff_time());
+        if let AsyncifyAction::Finish(mut ctx, _) =
+            __asyncify_with_deep_sleep::<M, _, _>(ctx, backoff)?
+        {
+            Ok(Ok(ctx))
+        } else {
+            Ok(Err(Errno::Success))
+        }
+    } else {
+        Ok(Ok(ctx))
+    }
+}
+
+/// Asyncify takes the current thread and blocks on the async runtime associated with it
+/// thus allowed for asynchronous operations to execute. It has built in functionality
+/// to (optionally) timeout the IO, force exit the process, callback signals and pump
+/// synchronous IO engine
+///
+/// This will either return the `ctx` as the asyncify has completed successfully
+/// or it will return an WasiError which will exit the WASM call using asyncify
+/// and instead process it on a shared task
+///
+pub(crate) fn __asyncify_with_deep_sleep<M: MemorySize, T, Fut>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    work: Fut,
+) -> Result<AsyncifyAction<'_, T>, WasiError>
+where
+    T: serde::Serialize + serde::de::DeserializeOwned,
+    Fut: Future<Output = T> + Send + Sync + 'static,
+{
+    // Determine the deep sleep time
+    let deep_sleep_time = match ctx.data().enable_journal {
+        true => Duration::from_micros(100),
+        false => Duration::from_millis(50),
+    };
+
+    // Determine if we should process signals or now
+    let process_signals = ctx
+        .data()
+        .try_inner()
+        .map(|i| !i.signal_set)
+        .unwrap_or(true);
+
+    // Box up the trigger
+    let mut trigger = Box::pin(work);
+
+    // Define the work
+    let tasks = ctx.data().tasks().clone();
+    let work = async move {
+        let env = ctx.data();
+
+        // Create the deep sleeper
+        let tasks_for_deep_sleep = if env.enable_deep_sleep {
+            Some(env.tasks().clone())
+        } else {
+            None
+        };
+
+        let deep_sleep_wait = async {
+            if let Some(tasks) = tasks_for_deep_sleep {
+                tasks.sleep_now(deep_sleep_time).await
+            } else {
+                InfiniteSleep::default().await
+            }
+        };
+
+        Ok(tokio::select! {
+            // Inner wait with finializer
+            res = AsyncifyPoller {
+                process_signals,
+                ctx: &mut ctx,
+                work: &mut trigger,
+            } => {
+                let result = res?;
+                AsyncifyAction::Finish(ctx, result)
+            },
+            // Determines when and if we should go into a deep sleep
+            _ = deep_sleep_wait => {
+                let pid = ctx.data().pid();
+                let tid = ctx.data().tid();
+
+                // We put thread into a deep sleeping state and
+                // notify anyone who is waiting for that
+                let thread = ctx.data().thread.clone();
+                thread.set_deep_sleeping(true);
+                ctx.data().process.inner.1.notify_one();
+
+                tracing::trace!(%pid, %tid, "thread entering deep sleep");
+                deep_sleep::<M>(ctx, Box::pin(async move {
+                    // After this wakes the background work or waking
+                    // event has triggered and its time to result
+                    let result = trigger.await;
+                    tracing::trace!(%pid, %tid, "thread leaving deep sleep");
+                    thread.set_deep_sleeping(false);
+                    bincode::serialize(&result).unwrap().into()
+                }))?;
+                AsyncifyAction::Unwind
+            },
+        })
+    };
+
+    // Block until the work is finished or until we
+    // unload the thread using asyncify
+    InlineWaker::block_on(work)
+}
+
+/// Asyncify takes the current thread and blocks on the async runtime associated with it
+/// thus allowed for asynchronous operations to execute. It has built in functionality
+/// to (optionally) timeout the IO, force exit the process, callback signals and pump
+/// synchronous IO engine
+pub(crate) fn __asyncify_light<T, Fut>(
+    env: &WasiEnv,
+    timeout: Option<Duration>,
+    work: Fut,
+) -> WasiResult<T>
+where
+    T: 'static,
+    Fut: Future<Output = Result<T, Errno>>,
+{
+    let snapshot_wait = wait_for_snapshot(env);
+
+    // This poller will process any signals when the main working function is idle
+    struct Poller<'a, Fut, T>
+    where
+        Fut: Future<Output = Result<T, Errno>>,
+    {
+        env: &'a WasiEnv,
+        pinned_work: Pin<Box<Fut>>,
+        pinned_snapshot: Pin<Box<dyn Future<Output = ()>>>,
+    }
+    impl<'a, Fut, T> Future for Poller<'a, Fut, T>
+    where
+        Fut: Future<Output = Result<T, Errno>>,
+    {
+        type Output = Result<Fut::Output, WasiError>;
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            if let Poll::Ready(res) = Pin::new(&mut self.pinned_work).poll(cx) {
+                return Poll::Ready(Ok(res));
+            }
+            if let Poll::Ready(()) = Pin::new(&mut self.pinned_snapshot).poll(cx) {
+                return Poll::Ready(Ok(Err(Errno::Intr)));
+            }
+            if let Some(exit_code) = self.env.should_exit() {
+                return Poll::Ready(Err(WasiError::Exit(exit_code)));
+            }
+            if self.env.thread.has_signals_or_subscribe(cx.waker()) {
+                return Poll::Ready(Ok(Err(Errno::Intr)));
+            }
+            Poll::Pending
+        }
+    }
+
+    // Block until the work is finished or until we
+    // unload the thread using asyncify
+    Ok(InlineWaker::block_on(work))
+}
+
+// This should be compiled away, it will simply wait forever however its never
+// used by itself, normally this is passed into asyncify which will still abort
+// the operating on timeouts, signals or other work due to a select! around the await
+#[derive(Default)]
+pub struct InfiniteSleep {}
+impl std::future::Future for InfiniteSleep {
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Poll::Pending
+    }
+}
+
+/// Performs an immutable operation on the socket while running in an asynchronous runtime
+/// This has built in signal support
+pub(crate) fn __sock_asyncify<T, F, Fut>(
+    env: &WasiEnv,
+    sock: WasiFd,
+    rights: Rights,
+    actor: F,
+) -> Result<T, Errno>
+where
+    F: FnOnce(crate::net::socket::InodeSocket, Fd) -> Fut,
+    Fut: std::future::Future<Output = Result<T, Errno>>,
+{
+    let fd_entry = env.state.fs.get_fd(sock)?;
+    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+        return Err(Errno::Access);
+    }
+
+    let mut work = {
+        let inode = fd_entry.inode.clone();
+        let tasks = env.tasks().clone();
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::Socket { socket } => {
+                // Clone the socket and release the lock
+                let socket = socket.clone();
+                drop(guard);
+
+                // Start the work using the socket
+                actor(socket, fd_entry)
+            }
+            _ => {
+                return Err(Errno::Notsock);
+            }
+        }
+    };
+
+    // Block until the work is finished or until we
+    // unload the thread using asyncify
+    InlineWaker::block_on(work)
+}
+
+/// Performs mutable work on a socket under an asynchronous runtime with
+/// built in signal processing
+pub(crate) fn __sock_asyncify_mut<T, F, Fut>(
+    ctx: &'_ mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    rights: Rights,
+    actor: F,
+) -> Result<T, Errno>
+where
+    F: FnOnce(crate::net::socket::InodeSocket, Fd) -> Fut,
+    Fut: std::future::Future<Output = Result<T, Errno>>,
+{
+    let env = ctx.data();
+    let tasks = env.tasks().clone();
+
+    let fd_entry = env.state.fs.get_fd(sock)?;
+    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+        return Err(Errno::Access);
+    }
+
+    let inode = fd_entry.inode.clone();
+    let mut guard = inode.write();
+    match guard.deref_mut() {
+        Kind::Socket { socket } => {
+            // Clone the socket and release the lock
+            let socket = socket.clone();
+            drop(guard);
+
+            // Start the work using the socket
+            let mut work = actor(socket, fd_entry);
+
+            // Otherwise we block on the work and process it
+            // using an asynchronou context
+            InlineWaker::block_on(work)
+        }
+        _ => Err(Errno::Notsock),
+    }
+}
+
+/// Performs an immutable operation on the socket while running in an asynchronous runtime
+/// This has built in signal support
+pub(crate) fn __sock_actor<T, F>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    rights: Rights,
+    actor: F,
+) -> Result<T, Errno>
+where
+    T: 'static,
+    F: FnOnce(crate::net::socket::InodeSocket, Fd) -> Result<T, Errno>,
+{
+    let env = ctx.data();
+    let tasks = env.tasks().clone();
+
+    let fd_entry = env.state.fs.get_fd(sock)?;
+    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+        return Err(Errno::Access);
+    }
+
+    let inode = fd_entry.inode.clone();
+
+    let tasks = env.tasks().clone();
+    let mut guard = inode.write();
+    match guard.deref_mut() {
+        Kind::Socket { socket } => {
+            // Clone the socket and release the lock
+            let socket = socket.clone();
+            drop(guard);
+
+            // Start the work using the socket
+            actor(socket, fd_entry)
+        }
+        _ => Err(Errno::Notsock),
+    }
+}
+
+/// Performs mutable work on a socket under an asynchronous runtime with
+/// built in signal processing
+pub(crate) fn __sock_actor_mut<T, F>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    rights: Rights,
+    actor: F,
+) -> Result<T, Errno>
+where
+    T: 'static,
+    F: FnOnce(crate::net::socket::InodeSocket, Fd) -> Result<T, Errno>,
+{
+    let env = ctx.data();
+    let tasks = env.tasks().clone();
+
+    let fd_entry = env.state.fs.get_fd(sock)?;
+    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+        return Err(Errno::Access);
+    }
+
+    let inode = fd_entry.inode.clone();
+    let mut guard = inode.write();
+    match guard.deref_mut() {
+        Kind::Socket { socket } => {
+            // Clone the socket and release the lock
+            let socket = socket.clone();
+            drop(guard);
+
+            // Start the work using the socket
+            actor(socket, fd_entry)
+        }
+        _ => Err(Errno::Notsock),
+    }
+}
+
+/// Replaces a socket with another socket in under an asynchronous runtime.
+/// This is used for opening sockets or connecting sockets which changes
+/// the fundamental state of the socket to another state machine
+pub(crate) fn __sock_upgrade<'a, F, Fut>(
+    ctx: &'a mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    rights: Rights,
+    actor: F,
+) -> Result<(), Errno>
+where
+    F: FnOnce(crate::net::socket::InodeSocket) -> Fut,
+    Fut: std::future::Future<Output = Result<Option<crate::net::socket::InodeSocket>, Errno>> + 'a,
+{
+    let env = ctx.data();
+    let fd_entry = env.state.fs.get_fd(sock)?;
+    if !rights.is_empty() && !fd_entry.rights.contains(rights) {
+        tracing::warn!(
+            "wasi[{}:{}]::sock_upgrade(fd={}, rights={:?}) - failed - no access rights to upgrade",
+            ctx.data().pid(),
+            ctx.data().tid(),
+            sock,
+            rights
+        );
+        return Err(Errno::Access);
+    }
+
+    let tasks = env.tasks().clone();
+    {
+        let inode = fd_entry.inode;
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::Socket { socket } => {
+                let socket = socket.clone();
+                drop(guard);
+
+                // Start the work using the socket
+                let work = actor(socket);
+
+                // Block on the work and process it
+                let res = InlineWaker::block_on(work);
+                let new_socket = res?;
+
+                if let Some(mut new_socket) = new_socket {
+                    let mut guard = inode.write();
+                    match guard.deref_mut() {
+                        Kind::Socket { socket, .. } => {
+                            std::mem::swap(socket, &mut new_socket);
+                        }
+                        _ => {
+                            tracing::warn!(
+                                "wasi[{}:{}]::sock_upgrade(fd={}, rights={:?}) - failed - not a socket",
+                                ctx.data().pid(),
+                                ctx.data().tid(),
+                                sock,
+                                rights
+                            );
+                            return Err(Errno::Notsock);
+                        }
+                    }
+                }
+            }
+            _ => {
+                tracing::warn!(
+                    "wasi[{}:{}]::sock_upgrade(fd={}, rights={:?}) - failed - not a socket",
+                    ctx.data().pid(),
+                    ctx.data().tid(),
+                    sock,
+                    rights
+                );
+                return Err(Errno::Notsock);
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[must_use]
+pub(crate) fn write_buffer_array<M: MemorySize>(
+    memory: &MemoryView,
+    from: &[Vec<u8>],
+    ptr_buffer: WasmPtr<WasmPtr<u8, M>, M>,
+    buffer: WasmPtr<u8, M>,
+) -> Errno {
+    let ptrs = wasi_try_mem!(ptr_buffer.slice(memory, wasi_try!(to_offset::<M>(from.len()))));
+
+    let mut current_buffer_offset = 0usize;
+    for ((i, sub_buffer), ptr) in from.iter().enumerate().zip(ptrs.iter()) {
+        let mut buf_offset = buffer.offset();
+        buf_offset += wasi_try!(to_offset::<M>(current_buffer_offset));
+        let new_ptr = WasmPtr::new(buf_offset);
+        wasi_try_mem!(ptr.write(new_ptr));
+
+        let data =
+            wasi_try_mem!(new_ptr.slice(memory, wasi_try!(to_offset::<M>(sub_buffer.len()))));
+        wasi_try_mem!(data.write_slice(sub_buffer));
+        wasi_try_mem!(wasi_try_mem!(
+            new_ptr.add_offset(wasi_try!(to_offset::<M>(sub_buffer.len())))
+        )
+        .write(memory, 0));
+
+        current_buffer_offset += sub_buffer.len() + 1;
+    }
+
+    Errno::Success
+}
+
+pub(crate) fn get_current_time_in_nanos() -> Result<Timestamp, Errno> {
+    let now = platform_clock_time_get(Snapshot0Clockid::Monotonic, 1_000_000).unwrap() as u128;
+    Ok(now as Timestamp)
+}
+
+pub(crate) fn get_stack_lower(env: &WasiEnv) -> u64 {
+    env.layout.stack_lower
+}
+
+pub(crate) fn get_stack_upper(env: &WasiEnv) -> u64 {
+    env.layout.stack_upper
+}
+
+pub(crate) unsafe fn get_memory_stack_pointer(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<u64, String> {
+    // Get the current value of the stack pointer (which we will use
+    // to save all of the stack)
+    let stack_upper = get_stack_upper(ctx.data());
+    let stack_pointer = if let Some(stack_pointer) = ctx.data().inner().stack_pointer.clone() {
+        match stack_pointer.get(ctx) {
+            Value::I32(a) => a as u64,
+            Value::I64(a) => a as u64,
+            _ => stack_upper,
+        }
+    } else {
+        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+    };
+    Ok(stack_pointer)
+}
+
+pub(crate) unsafe fn get_memory_stack_offset(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<u64, String> {
+    let stack_upper = get_stack_upper(ctx.data());
+    let stack_pointer = get_memory_stack_pointer(ctx)?;
+    Ok(stack_upper - stack_pointer)
+}
+
+pub(crate) fn set_memory_stack_offset(
+    env: &WasiEnv,
+    store: &mut impl AsStoreMut,
+    offset: u64,
+) -> Result<(), String> {
+    // Sets the stack pointer
+    let stack_upper = get_stack_upper(env);
+    let stack_pointer = stack_upper - offset;
+    if let Some(stack_pointer_ptr) = env
+        .try_inner()
+        .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())?
+        .stack_pointer
+        .clone()
+    {
+        match stack_pointer_ptr.get(store) {
+            Value::I32(_) => {
+                stack_pointer_ptr.set(store, Value::I32(stack_pointer as i32));
+            }
+            Value::I64(_) => {
+                stack_pointer_ptr.set(store, Value::I64(stack_pointer as i64));
+            }
+            _ => {
+                return Err(
+                    "failed to save stack: __stack_pointer global is of an unknown type"
+                        .to_string(),
+                );
+            }
+        }
+    } else {
+        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+    }
+    Ok(())
+}
+
+#[allow(dead_code)]
+pub(crate) fn get_memory_stack<M: MemorySize>(
+    env: &WasiEnv,
+    store: &mut impl AsStoreMut,
+) -> Result<BytesMut, String> {
+    // Get the current value of the stack pointer (which we will use
+    // to save all of the stack)
+    let stack_base = get_stack_upper(env);
+    let stack_pointer = if let Some(stack_pointer) = env
+        .try_inner()
+        .ok_or_else(|| "unable to access the stack pointer of the instance".to_string())?
+        .stack_pointer
+        .clone()
+    {
+        match stack_pointer.get(store) {
+            Value::I32(a) => a as u64,
+            Value::I64(a) => a as u64,
+            _ => stack_base,
+        }
+    } else {
+        return Err("failed to save stack: not exported __stack_pointer global".to_string());
+    };
+    let memory = env
+        .try_memory_view(store)
+        .ok_or_else(|| "unable to access the memory of the instance".to_string())?;
+    let stack_offset = env.layout.stack_upper - stack_pointer;
+
+    // Read the memory stack into a vector
+    let memory_stack_ptr = WasmPtr::<u8, M>::new(
+        stack_pointer
+            .try_into()
+            .map_err(|err| format!("failed to save stack: stack pointer overflow (stack_pointer={}, stack_lower={}, stack_upper={})", stack_offset, env.layout.stack_lower, env.layout.stack_upper))?,
+    );
+
+    memory_stack_ptr
+        .slice(
+            &memory,
+            stack_offset
+                .try_into()
+                .map_err(|err| format!("failed to save stack: stack pointer overflow (stack_pointer={}, stack_lower={}, stack_upper={})", stack_offset, env.layout.stack_lower, env.layout.stack_upper))?,
+        )
+        .and_then(|memory_stack| memory_stack.read_to_bytes())
+        .map_err(|err| format!("failed to read stack: {}", err))
+}
+
+#[allow(dead_code)]
+pub(crate) fn set_memory_stack<M: MemorySize>(
+    env: &WasiEnv,
+    store: &mut impl AsStoreMut,
+    stack: Bytes,
+) -> Result<(), String> {
+    // First we restore the memory stack
+    let stack_upper = get_stack_upper(env);
+    let stack_offset = stack.len() as u64;
+    let stack_pointer = stack_upper - stack_offset;
+    let stack_ptr = WasmPtr::<u8, M>::new(
+        stack_pointer
+            .try_into()
+            .map_err(|_| "failed to restore stack: stack pointer overflow".to_string())?,
+    );
+
+    let memory = env
+        .try_memory_view(store)
+        .ok_or_else(|| "unable to set the stack pointer of the instance".to_string())?;
+    stack_ptr
+        .slice(
+            &memory,
+            stack_offset
+                .try_into()
+                .map_err(|_| "failed to restore stack: stack pointer overflow".to_string())?,
+        )
+        .and_then(|memory_stack| memory_stack.write_slice(&stack[..]))
+        .map_err(|err| format!("failed to write stack: {}", err))?;
+
+    // Set the stack pointer itself and return
+    set_memory_stack_offset(env, store, stack_offset)?;
+    Ok(())
+}
+
+/// Puts the process to deep sleep and wakes it again when
+/// the supplied future completes
+#[must_use = "you must return the result immediately so the stack can unwind"]
+pub(crate) fn deep_sleep<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    trigger: Pin<Box<AsyncifyFuture>>,
+) -> Result<(), WasiError> {
+    // Grab all the globals and serialize them
+    let store_data = crate::utils::store::capture_store_snapshot(&mut ctx.as_store_mut())
+        .serialize()
+        .unwrap();
+    let store_data = Bytes::from(store_data);
+    let thread_start = ctx.data().thread.thread_start_type();
+
+    // Perform the unwind action
+    let tasks = ctx.data().tasks().clone();
+    let res = unwind::<M, _>(ctx, move |mut ctx, memory_stack, rewind_stack| {
+        let memory_stack = memory_stack.freeze();
+        let rewind_stack = rewind_stack.freeze();
+        let thread_layout = ctx.data().thread.memory_layout().clone();
+
+        // If journal'ing is enabled then we dump the stack into the journal
+        if ctx.data().enable_journal {
+            // Grab all the globals and serialize them
+            let store_data = crate::utils::store::capture_store_snapshot(&mut ctx.as_store_mut())
+                .serialize()
+                .unwrap();
+            let store_data = Bytes::from(store_data);
+
+            tracing::debug!(
+                "stack snapshot unwind (memory_stack={}, rewind_stack={}, store_data={})",
+                memory_stack.len(),
+                rewind_stack.len(),
+                store_data.len(),
+            );
+
+            #[cfg(feature = "journal")]
+            {
+                // Write our thread state to the snapshot
+                let tid = ctx.data().thread.tid();
+                let thread_start = ctx.data().thread.thread_start_type();
+                if let Err(err) = JournalEffector::save_thread_state::<M>(
+                    &mut ctx,
+                    tid,
+                    memory_stack.clone(),
+                    rewind_stack.clone(),
+                    store_data.clone(),
+                    thread_start,
+                    thread_layout.clone(),
+                ) {
+                    return wasmer_types::OnCalledAction::Trap(err.into());
+                }
+            }
+
+            // If all the threads are now in a deep sleep state
+            // then we can trigger the idle snapshot event
+            let inner = ctx.data().process.inner.clone();
+            let is_idle = {
+                let mut guard = inner.0.lock().unwrap();
+                guard.threads.values().all(WasiThread::is_deep_sleeping)
+            };
+
+            // When we idle the journal functionality may be set
+            // will take a snapshot of the memory and threads so
+            // that it can resumed.
+            #[cfg(feature = "journal")]
+            {
+                if is_idle && ctx.data_mut().has_snapshot_trigger(SnapshotTrigger::Idle) {
+                    let mut guard = inner.0.lock().unwrap();
+                    if let Err(err) = JournalEffector::save_memory_and_snapshot(
+                        &mut ctx,
+                        &mut guard,
+                        SnapshotTrigger::Idle,
+                    ) {
+                        return wasmer_types::OnCalledAction::Trap(err.into());
+                    }
+                }
+            }
+        }
+
+        // Schedule the process on the stack so that it can be resumed
+        OnCalledAction::Trap(Box::new(WasiError::DeepSleep(DeepSleepWork {
+            trigger,
+            rewind: RewindState {
+                memory_stack,
+                rewind_stack,
+                store_data,
+                start: thread_start,
+                layout: thread_layout,
+                is_64bit: M::is_64bit(),
+            },
+        })))
+    })?;
+
+    // If there is an error then exit the process, otherwise we are done
+    match res {
+        Errno::Success => Ok(()),
+        err => Err(WasiError::Exit(ExitCode::Errno(err))),
+    }
+}
+
+#[must_use = "you must return the result immediately so the stack can unwind"]
+pub fn unwind<M: MemorySize, F>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    callback: F,
+) -> Result<Errno, WasiError>
+where
+    F: FnOnce(FunctionEnvMut<'_, WasiEnv>, BytesMut, BytesMut) -> OnCalledAction
+        + Send
+        + Sync
+        + 'static,
+{
+    // Get the current stack pointer (this will be used to determine the
+    // upper limit of stack space remaining to unwind into)
+    let (env, mut store) = ctx.data_and_store_mut();
+    let memory_stack = match get_memory_stack::<M>(env, &mut store) {
+        Ok(a) => a,
+        Err(err) => {
+            warn!("unable to get the memory stack - {}", err);
+            return Err(WasiError::Exit(Errno::Unknown.into()));
+        }
+    };
+
+    // Perform a check to see if we have enough room
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    // Write the addresses to the start of the stack space
+    let unwind_pointer = env.layout.stack_lower;
+    let unwind_data_start =
+        unwind_pointer + (std::mem::size_of::<__wasi_asyncify_t<M::Offset>>() as u64);
+    let unwind_data = __wasi_asyncify_t::<M::Offset> {
+        start: wasi_try_ok!(unwind_data_start.try_into().map_err(|_| Errno::Overflow)),
+        end: wasi_try_ok!(env
+            .layout
+            .stack_upper
+            .try_into()
+            .map_err(|_| Errno::Overflow)),
+    };
+    let unwind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> =
+        WasmPtr::new(wasi_try_ok!(unwind_pointer
+            .try_into()
+            .map_err(|_| Errno::Overflow)));
+    wasi_try_mem_ok!(unwind_data_ptr.write(&memory, unwind_data));
+
+    // Invoke the callback that will prepare to unwind
+    // We need to start unwinding the stack
+    let asyncify_data = wasi_try_ok!(unwind_pointer.try_into().map_err(|_| Errno::Overflow));
+    if let Some(asyncify_start_unwind) = wasi_try_ok!(env.try_inner().ok_or(Errno::Fault))
+        .asyncify_start_unwind
+        .clone()
+    {
+        asyncify_start_unwind.call(&mut ctx, asyncify_data);
+    } else {
+        warn!("failed to unwind the stack because the asyncify_start_rewind export is missing");
+        return Err(WasiError::Exit(Errno::Noexec.into()));
+    }
+
+    // Set callback that will be invoked when this process finishes
+    let env = ctx.data();
+    let unwind_stack_begin: u64 = unwind_data.start.into();
+    let total_stack_space = env.layout.stack_size;
+    let func = ctx.as_ref();
+    trace!(
+        stack_upper = env.layout.stack_upper,
+        stack_lower = env.layout.stack_lower,
+        "wasi[{}:{}]::unwinding (used_stack_space={} total_stack_space={})",
+        ctx.data().pid(),
+        ctx.data().tid(),
+        memory_stack.len(),
+        total_stack_space
+    );
+    ctx.as_store_mut().on_called(move |mut store| {
+        let mut ctx = func.into_mut(&mut store);
+        let env = ctx.data();
+        let memory = env
+            .try_memory_view(&ctx)
+            .ok_or_else(|| "failed to save stack: stack pointer overflow - unable to access the memory of the instance".to_string())?;
+
+        let unwind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> = WasmPtr::new(
+            unwind_pointer
+                .try_into()
+                .map_err(|_| Errno::Overflow)
+                .unwrap(),
+        );
+        let unwind_data_result = unwind_data_ptr.read(&memory).unwrap();
+        let unwind_stack_finish: u64 = unwind_data_result.start.into();
+        let unwind_size = unwind_stack_finish - unwind_stack_begin;
+        trace!(
+            "wasi[{}:{}]::unwound (memory_stack_size={} unwind_size={})",
+            ctx.data().pid(),
+            ctx.data().tid(),
+            memory_stack.len(),
+            unwind_size
+        );
+
+        // Read the memory stack into a vector
+        let unwind_stack_ptr = WasmPtr::<u8, M>::new(
+            unwind_stack_begin
+                .try_into()
+                .map_err(|_| "failed to save stack: stack pointer overflow".to_string())?,
+        );
+        let unwind_stack = unwind_stack_ptr
+            .slice(
+                &memory,
+                unwind_size
+                    .try_into()
+                    .map_err(|_| "failed to save stack: stack pointer overflow".to_string())?,
+            )
+            .and_then(|memory_stack| memory_stack.read_to_bytes())
+            .map_err(|err| format!("failed to read stack: {}", err))?;
+
+        // Notify asyncify that we are no longer unwinding
+        if let Some(asyncify_stop_unwind) = env
+            .try_inner()
+            .into_iter()
+            .filter_map(|i| i.asyncify_stop_unwind.clone())
+            .next()
+        {
+            asyncify_stop_unwind.call(&mut ctx);
+        } else {
+            warn!("failed to unwind the stack because the asyncify_start_rewind export is missing");
+            return Ok(OnCalledAction::Finish);
+        }
+
+        Ok(callback(ctx, memory_stack, unwind_stack))
+    });
+
+    // We need to exit the function so that it can unwind and then invoke the callback
+    Ok(Errno::Success)
+}
+
+#[instrument(level = "debug", skip_all, fields(memory_stack_len = memory_stack.len(), rewind_stack_len = rewind_stack.len(), store_data_len = store_data.len()))]
+#[must_use = "the action must be passed to the call loop"]
+pub fn rewind<M: MemorySize, T>(
+    mut ctx: FunctionEnvMut<WasiEnv>,
+    memory_stack: Bytes,
+    rewind_stack: Bytes,
+    store_data: Bytes,
+    result: T,
+) -> Errno
+where
+    T: serde::Serialize,
+{
+    let rewind_result = bincode::serialize(&result).unwrap().into();
+    rewind_ext::<M>(
+        &mut ctx,
+        Some(memory_stack),
+        rewind_stack,
+        store_data,
+        RewindResultType::RewindWithResult(rewind_result),
+    )
+}
+
+#[instrument(level = "debug", skip_all, fields(rewind_stack_len = rewind_stack.len(), store_data_len = store_data.len()))]
+#[must_use = "the action must be passed to the call loop"]
+pub fn rewind_ext<M: MemorySize>(
+    ctx: &mut FunctionEnvMut<WasiEnv>,
+    memory_stack: Option<Bytes>,
+    rewind_stack: Bytes,
+    store_data: Bytes,
+    rewind_result: RewindResultType,
+) -> Errno {
+    // Store the memory stack so that it can be restored later
+    ctx.data_mut().thread.set_rewind(RewindResult {
+        memory_stack,
+        rewind_result,
+    });
+
+    // Deserialize the store data back into a snapshot
+    let store_snapshot = match StoreSnapshot::deserialize(&store_data[..]) {
+        Ok(a) => a,
+        Err(err) => {
+            warn!("snapshot restore failed - the store snapshot could not be deserialized");
+            return Errno::Unknown;
+        }
+    };
+    crate::utils::store::restore_store_snapshot(ctx, &store_snapshot);
+    let env = ctx.data();
+    let memory = match env.try_memory_view(&ctx) {
+        Some(v) => v,
+        None => {
+            warn!("snapshot restore failed - unable to access the memory of the instance");
+            return Errno::Unknown;
+        }
+    };
+
+    // Write the addresses to the start of the stack space
+    let rewind_pointer = env.layout.stack_lower;
+    let rewind_data_start =
+        rewind_pointer + (std::mem::size_of::<__wasi_asyncify_t<M::Offset>>() as u64);
+    let rewind_data_end = rewind_data_start + (rewind_stack.len() as u64);
+    if rewind_data_end > env.layout.stack_upper {
+        warn!(
+            "attempting to rewind a stack bigger than the allocated stack space ({} > {})",
+            rewind_data_end, env.layout.stack_upper
+        );
+        return Errno::Overflow;
+    }
+    let rewind_data = __wasi_asyncify_t::<M::Offset> {
+        start: wasi_try!(rewind_data_end.try_into().map_err(|_| Errno::Overflow)),
+        end: wasi_try!(env
+            .layout
+            .stack_upper
+            .try_into()
+            .map_err(|_| Errno::Overflow)),
+    };
+    let rewind_data_ptr: WasmPtr<__wasi_asyncify_t<M::Offset>, M> =
+        WasmPtr::new(wasi_try!(rewind_pointer
+            .try_into()
+            .map_err(|_| Errno::Overflow)));
+    wasi_try_mem!(rewind_data_ptr.write(&memory, rewind_data));
+
+    // Copy the data to the address
+    let rewind_stack_ptr = WasmPtr::<u8, M>::new(wasi_try!(rewind_data_start
+        .try_into()
+        .map_err(|_| Errno::Overflow)));
+    wasi_try_mem!(rewind_stack_ptr
+        .slice(
+            &memory,
+            wasi_try!(rewind_stack.len().try_into().map_err(|_| Errno::Overflow))
+        )
+        .and_then(|stack| { stack.write_slice(&rewind_stack[..]) }));
+
+    // Invoke the callback that will prepare to rewind
+    let asyncify_data = wasi_try!(rewind_pointer.try_into().map_err(|_| Errno::Overflow));
+    if let Some(asyncify_start_rewind) = env
+        .try_inner()
+        .into_iter()
+        .filter_map(|a| a.asyncify_start_rewind.clone())
+        .next()
+    {
+        asyncify_start_rewind.call(ctx, asyncify_data);
+    } else {
+        warn!("failed to rewind the stack because the asyncify_start_rewind export is missing or inaccessible");
+        return Errno::Noexec;
+    }
+
+    Errno::Success
+}
+
+pub fn rewind_ext2(
+    ctx: &mut FunctionEnvMut<WasiEnv>,
+    rewind_state: RewindStateOption,
+) -> Result<(), ExitCode> {
+    if let Some((rewind_state, rewind_result)) = rewind_state {
+        tracing::trace!("Rewinding");
+        let errno = if rewind_state.is_64bit {
+            crate::rewind_ext::<wasmer_types::Memory64>(
+                ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            )
+        } else {
+            crate::rewind_ext::<wasmer_types::Memory32>(
+                ctx,
+                Some(rewind_state.memory_stack),
+                rewind_state.rewind_stack,
+                rewind_state.store_data,
+                rewind_result,
+            )
+        };
+
+        if errno != Errno::Success {
+            let exit_code = ExitCode::from(errno);
+            ctx.data().on_exit(Some(exit_code));
+            return Err(exit_code);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn anyhow_err_to_runtime_err(err: anyhow::Error) -> WasiRuntimeError {
+    WasiRuntimeError::Runtime(RuntimeError::user(err.into()))
+}
+
+pub(crate) unsafe fn handle_rewind<M: MemorySize, T>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Option<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    handle_rewind_ext::<M, T>(ctx, HandleRewindType::ResultDriven).flatten()
+}
+
+pub(crate) enum HandleRewindType {
+    /// Handle rewind types that have a result to be processed
+    ResultDriven,
+    /// Handle rewind types that are result-less (generally these
+    /// are caused by snapshot events)
+    ResultLess,
+}
+
+pub(crate) unsafe fn handle_rewind_ext_with_default<M: MemorySize, T>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    type_: HandleRewindType,
+) -> Option<T>
+where
+    T: serde::de::DeserializeOwned + Default,
+{
+    let ret = handle_rewind_ext::<M, T>(ctx, type_);
+    ret.unwrap_or_default()
+}
+
+pub(crate) unsafe fn handle_rewind_ext<M: MemorySize, T>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    type_: HandleRewindType,
+) -> Option<Option<T>>
+where
+    T: serde::de::DeserializeOwned,
+{
+    let env = ctx.data();
+    if !env.thread.has_rewind_of_type(type_) {
+        return None;
+    };
+
+    // If the stack has been restored
+    let tid = env.tid();
+    let pid = env.pid();
+    if let Some(result) = ctx.data_mut().thread.take_rewind() {
+        // Deserialize the result
+        let memory_stack = result.memory_stack;
+
+        // Notify asyncify that we are no longer rewinding
+        let env = ctx.data();
+        if let Some(asyncify_stop_rewind) = env.inner().asyncify_stop_unwind.clone() {
+            asyncify_stop_rewind.call(ctx);
+        } else {
+            warn!("failed to handle rewind because the asyncify_start_rewind export is missing or inaccessible");
+            return Some(None);
+        }
+
+        // Restore the memory stack
+        let (env, mut store) = ctx.data_and_store_mut();
+        if let Some(memory_stack) = memory_stack {
+            set_memory_stack::<M>(env, &mut store, memory_stack);
+        }
+
+        match result.rewind_result {
+            RewindResultType::RewindRestart => {
+                debug!(%pid, %tid, "rewind for syscall restart");
+                None
+            }
+            RewindResultType::RewindWithoutResult => {
+                debug!(%pid, %tid, "rewind with no result");
+                Some(None)
+            }
+            RewindResultType::RewindWithResult(rewind_result) => {
+                debug!(%pid, %tid, "rewind with result (data={})", rewind_result.len());
+                let ret = bincode::deserialize(&rewind_result)
+                    .expect("failed to deserialize the rewind result");
+                Some(Some(ret))
+            }
+        }
+    } else {
+        debug!(%pid, %tid, "rewind miss");
+        Some(None)
+    }
+}
+
+// Function to prepare the WASI environment
+pub(crate) fn _prepare_wasi(wasi_env: &mut WasiEnv, args: Option<Vec<String>>) {
+    // Swap out the arguments with the new ones
+    if let Some(args) = args {
+        let mut wasi_state = wasi_env.state.fork();
+        wasi_state.args = args;
+        wasi_env.state = Arc::new(wasi_state);
+    }
+
+    // Close any files after the STDERR that are not preopened
+    let close_fds = {
+        let preopen_fds = {
+            let preopen_fds = wasi_env.state.fs.preopen_fds.read().unwrap();
+            preopen_fds.iter().copied().collect::<HashSet<_>>()
+        };
+        let mut fd_map = wasi_env.state.fs.fd_map.read().unwrap();
+        fd_map
+            .keys()
+            .filter_map(|a| match *a {
+                a if a <= __WASI_STDERR_FILENO => None,
+                a if preopen_fds.contains(&a) => None,
+                a => Some(a),
+            })
+            .collect::<Vec<_>>()
+    };
+
+    // Now close all these files
+    for fd in close_fds {
+        let _ = wasi_env.state.fs.close_fd(fd);
+    }
+}
+
+pub(crate) fn conv_spawn_err_to_errno(err: &SpawnError) -> Errno {
+    match err {
+        SpawnError::AccessDenied => Errno::Access,
+        SpawnError::NotFound => Errno::Noent,
+        SpawnError::Unsupported => Errno::Noexec,
+        _ => Errno::Inval,
+    }
+}
+
+pub(crate) fn conv_spawn_err_to_exit_code(err: &SpawnError) -> ExitCode {
+    conv_spawn_err_to_errno(err).into()
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/unix/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/unix/mod.rs
new file mode 100644
index 0000000..11b6bd1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/unix/mod.rs
@@ -0,0 +1,61 @@
+use std::mem;
+
+use libc::{
+    clock_getres, clock_gettime, timespec, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID,
+    CLOCK_REALTIME, CLOCK_THREAD_CPUTIME_ID,
+};
+use wasmer::WasmRef;
+use wasmer_wasix_types::wasi::{Errno, Snapshot0Clockid, Timestamp};
+
+use crate::syscalls::types::*;
+
+pub fn platform_clock_res_get(
+    clock_id: Snapshot0Clockid,
+    resolution: WasmRef<Timestamp>,
+) -> Result<i64, Errno> {
+    let unix_clock_id = match clock_id {
+        Snapshot0Clockid::Monotonic => CLOCK_MONOTONIC,
+        Snapshot0Clockid::ProcessCputimeId => CLOCK_PROCESS_CPUTIME_ID,
+        Snapshot0Clockid::Realtime => CLOCK_REALTIME,
+        Snapshot0Clockid::ThreadCputimeId => CLOCK_THREAD_CPUTIME_ID,
+        _ => return Err(Errno::Inval),
+    };
+
+    let (output, timespec_out) = unsafe {
+        let mut timespec_out: timespec = timespec {
+            tv_sec: 0,
+            tv_nsec: 0,
+        };
+        (clock_getres(unix_clock_id, &mut timespec_out), timespec_out)
+    };
+
+    let t_out = (timespec_out.tv_sec * 1_000_000_000).wrapping_add(timespec_out.tv_nsec);
+    Ok(t_out)
+}
+
+pub fn platform_clock_time_get(
+    clock_id: Snapshot0Clockid,
+    precision: Timestamp,
+) -> Result<i64, Errno> {
+    let unix_clock_id = match clock_id {
+        Snapshot0Clockid::Monotonic => CLOCK_MONOTONIC,
+        Snapshot0Clockid::ProcessCputimeId => CLOCK_PROCESS_CPUTIME_ID,
+        Snapshot0Clockid::Realtime => CLOCK_REALTIME,
+        Snapshot0Clockid::ThreadCputimeId => CLOCK_THREAD_CPUTIME_ID,
+        _ => return Err(Errno::Inval),
+    };
+
+    let (output, timespec_out) = unsafe {
+        let mut timespec_out: timespec = timespec {
+            tv_sec: 0,
+            tv_nsec: 0,
+        };
+        (
+            clock_gettime(unix_clock_id, &mut timespec_out),
+            timespec_out,
+        )
+    };
+
+    let t_out = (timespec_out.tv_sec * 1_000_000_000).wrapping_add(timespec_out.tv_nsec);
+    Ok(t_out)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_get.rs
new file mode 100644
index 0000000..8a316d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_get.rs
@@ -0,0 +1,41 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `args_get()`
+/// Read command-line argument data.
+/// The sizes of the buffers should match that returned by [`args_sizes_get()`](#args_sizes_get).
+/// Inputs:
+/// - `char **argv`
+///     A pointer to a buffer to write the argument pointers.
+/// - `char *argv_buf`
+///     A pointer to a buffer to write the argument string data.
+///
+#[instrument(level = "debug", skip_all, ret)]
+pub fn args_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    argv: WasmPtr<WasmPtr<u8, M>, M>,
+    argv_buf: WasmPtr<u8, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let args = state
+        .args
+        .iter()
+        .map(|a| a.as_bytes().to_vec())
+        .collect::<Vec<_>>();
+    let result = write_buffer_array(&memory, &args, argv, argv_buf);
+
+    debug!(
+        "args:\n{}",
+        state
+            .args
+            .iter()
+            .enumerate()
+            .map(|(i, v)| format!("{:>20}: {}", i, v))
+            .collect::<Vec<String>>()
+            .join("\n")
+    );
+
+    result
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_sizes_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
new file mode 100644
index 0000000..08ec71c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/args_sizes_get.rs
@@ -0,0 +1,33 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `args_sizes_get()`
+/// Return command-line argument data sizes.
+/// Outputs:
+/// - `size_t *argc`
+///     The number of arguments.
+/// - `size_t *argv_buf_size`
+///     The size of the argument string data.
+#[instrument(level = "debug", skip_all, ret)]
+pub fn args_sizes_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    argc: WasmPtr<M::Offset, M>,
+    argv_buf_size: WasmPtr<M::Offset, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let argc = argc.deref(&memory);
+    let argv_buf_size = argv_buf_size.deref(&memory);
+
+    let argc_val: M::Offset = wasi_try!(state.args.len().try_into().map_err(|_| Errno::Overflow));
+    let argv_buf_size_val: usize = state.args.iter().map(|v| v.len() + 1).sum();
+    let argv_buf_size_val: M::Offset =
+        wasi_try!(argv_buf_size_val.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem!(argc.write(argc_val));
+    wasi_try_mem!(argv_buf_size.write(argv_buf_size_val));
+
+    debug!("argc={}, argv_buf_size={}", argc_val, argv_buf_size_val);
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_res_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_res_get.rs
new file mode 100644
index 0000000..ddcac9e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_res_get.rs
@@ -0,0 +1,25 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `clock_res_get()`
+/// Get the resolution of the specified clock
+/// Input:
+/// - `Clockid clock_id`
+///     The ID of the clock to get the resolution of
+/// Output:
+/// - `Timestamp *resolution`
+///     The resolution of the clock in nanoseconds
+#[instrument(level = "trace", skip_all, ret)]
+pub fn clock_res_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    clock_id: Snapshot0Clockid,
+    resolution: WasmPtr<Timestamp, M>,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let out_addr = resolution.deref(&memory);
+    let t_out = wasi_try!(platform_clock_res_get(clock_id, out_addr));
+    wasi_try_mem!(resolution.write(&memory, t_out as Timestamp));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_get.rs
new file mode 100644
index 0000000..3ba7dac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_get.rs
@@ -0,0 +1,35 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `clock_time_get()`
+/// Get the time of the specified clock
+/// Inputs:
+/// - `Clockid clock_id`
+///     The ID of the clock to query
+/// - `Timestamp precision`
+///     The maximum amount of error the reading may have
+/// Output:
+/// - `Timestamp *time`
+///     The value of the clock in nanoseconds
+//#[instrument(level = "trace", skip_all, fields(?clock_id, %precision), ret)]
+pub fn clock_time_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    clock_id: Snapshot0Clockid,
+    precision: Timestamp,
+    time: WasmPtr<Timestamp, M>,
+) -> Result<Errno, WasiError> {
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let mut t_out = wasi_try_ok!(platform_clock_time_get(clock_id, precision));
+    {
+        let guard = env.state.clock_offset.lock().unwrap();
+        if let Some(offset) = guard.get(&clock_id) {
+            t_out += *offset;
+        }
+    };
+    wasi_try_mem_ok!(time.write(&memory, t_out as Timestamp));
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_set.rs
new file mode 100644
index 0000000..27a618a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/clock_time_set.rs
@@ -0,0 +1,49 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `clock_time_set()`
+/// Set the time of the specified clock
+/// Inputs:
+/// - `Clockid clock_id`
+///     The ID of the clock to query
+/// - `Timestamp *time`
+///     The value of the clock in nanoseconds
+#[instrument(level = "trace", skip_all, fields(?clock_id, %time), ret)]
+pub fn clock_time_set<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    clock_id: Snapshot0Clockid,
+    time: Timestamp,
+) -> Result<Errno, WasiError> {
+    let ret = clock_time_set_internal(&mut ctx, clock_id, time);
+    let env = ctx.data();
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        if env.enable_journal {
+            JournalEffector::save_clock_time_set(&mut ctx, clock_id, time).map_err(|err| {
+                tracing::error!("failed to save clock time set event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+        }
+    }
+    Ok(ret)
+}
+
+pub fn clock_time_set_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    clock_id: Snapshot0Clockid,
+    time: Timestamp,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let precision = 1 as Timestamp;
+    let t_now = wasi_try!(platform_clock_time_get(clock_id, precision));
+
+    let t_target = time as i64;
+    let t_offset = t_target - t_now;
+
+    let mut guard = env.state.clock_offset.lock().unwrap();
+    guard.insert(clock_id, t_offset);
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_get.rs
new file mode 100644
index 0000000..0c3b0c6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_get.rs
@@ -0,0 +1,28 @@
+use super::*;
+use crate::{journal::SnapshotTrigger, syscalls::*};
+
+/// ### `environ_get()`
+/// Read environment variable data.
+/// The sizes of the buffers should match that returned by [`environ_sizes_get()`](#environ_sizes_get).
+/// Inputs:
+/// - `char **environ`
+///     A pointer to a buffer to write the environment variable pointers.
+/// - `char *environ_buf`
+///     A pointer to a buffer to write the environment variable string data.
+#[instrument(level = "debug", skip_all, ret)]
+pub fn environ_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    environ: WasmPtr<WasmPtr<u8, M>, M>,
+    environ_buf: WasmPtr<u8, M>,
+) -> Result<Errno, WasiError> {
+    ctx = wasi_try_ok!(maybe_snapshot_once::<M>(
+        ctx,
+        SnapshotTrigger::FirstEnviron
+    )?);
+
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let envs = state.envs.lock().unwrap();
+    Ok(write_buffer_array(&memory, &envs, environ, environ_buf))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs
new file mode 100644
index 0000000..73f4ddd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/environ_sizes_get.rs
@@ -0,0 +1,47 @@
+use super::*;
+use crate::{journal::SnapshotTrigger, syscalls::*};
+
+/// ### `environ_sizes_get()`
+/// Return command-line argument data sizes.
+/// Outputs:
+/// - `size_t *environ_count`
+///     The number of environment variables.
+/// - `size_t *environ_buf_size`
+///     The size of the environment variable string data.
+#[instrument(level = "trace", skip_all, ret)]
+pub fn environ_sizes_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    environ_count: WasmPtr<M::Offset, M>,
+    environ_buf_size: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    ctx = wasi_try_ok!(maybe_snapshot_once::<M>(
+        ctx,
+        SnapshotTrigger::FirstEnviron
+    )?);
+
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let environ_count = environ_count.deref(&memory);
+    let environ_buf_size = environ_buf_size.deref(&memory);
+
+    let env_var_count: M::Offset = wasi_try_ok!(state
+        .envs
+        .lock()
+        .unwrap()
+        .len()
+        .try_into()
+        .map_err(|_| Errno::Overflow));
+    let env_buf_size: usize = state.envs.lock().unwrap().iter().map(|v| v.len() + 1).sum();
+    let env_buf_size: M::Offset =
+        wasi_try_ok!(env_buf_size.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(environ_count.write(env_var_count));
+    wasi_try_mem_ok!(environ_buf_size.write(env_buf_size));
+
+    trace!(
+        %env_var_count,
+        %env_buf_size
+    );
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_advise.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_advise.rs
new file mode 100644
index 0000000..ed2a436
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_advise.rs
@@ -0,0 +1,47 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_advise()`
+/// Advise the system about how a file will be used
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor the advice applies to
+/// - `Filesize offset`
+///     The offset from which the advice applies
+/// - `Filesize len`
+///     The length from the offset to which the advice applies
+/// - `__wasi_advice_t advice`
+///     The advice to give
+#[instrument(level = "debug", skip_all, fields(%fd, %offset, %len, ?advice), ret)]
+pub fn fd_advise(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: Filesize,
+    len: Filesize,
+    advice: Advice,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(fd_advise_internal(&mut ctx, fd, offset, len, advice));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_advise(&mut ctx, fd, offset, len, advice).map_err(|err| {
+            tracing::error!("failed to save file descriptor advise event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_advise_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: Filesize,
+    len: Filesize,
+    advice: Advice,
+) -> Result<(), Errno> {
+    // this is used for our own benefit, so just returning success is a valid
+    // implementation for now
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_allocate.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_allocate.rs
new file mode 100644
index 0000000..23462cb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_allocate.rs
@@ -0,0 +1,74 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_allocate`
+/// Allocate extra space for a file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to allocate for
+/// - `Filesize offset`
+///     The offset from the start marking the beginning of the allocation
+/// - `Filesize len`
+///     The length from the offset marking the end of the allocation
+#[instrument(level = "debug", skip_all, fields(%fd, %offset, %len), ret)]
+pub fn fd_allocate(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: Filesize,
+    len: Filesize,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(fd_allocate_internal(&mut ctx, fd, offset, len));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_allocate(&mut ctx, fd, offset, len).map_err(|err| {
+            tracing::error!("failed to save file descriptor allocate event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_allocate_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: Filesize,
+    len: Filesize,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd_entry = state.fs.get_fd(fd)?;
+    let inode = fd_entry.inode;
+
+    if !fd_entry.rights.contains(Rights::FD_ALLOCATE) {
+        return Err(Errno::Access);
+    }
+    let new_size = offset.checked_add(len).ok_or(Errno::Inval)?;
+    {
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::File { handle, .. } => {
+                if let Some(handle) = handle {
+                    let mut handle = handle.write().unwrap();
+                    handle.set_len(new_size).map_err(fs_error_into_wasi_err)?;
+                } else {
+                    return Err(Errno::Badf);
+                }
+            }
+            Kind::Socket { .. } => return Err(Errno::Badf),
+            Kind::Pipe { .. } => return Err(Errno::Badf),
+            Kind::Buffer { buffer } => {
+                buffer.resize(new_size as usize, 0);
+            }
+            Kind::Symlink { .. } => return Err(Errno::Badf),
+            Kind::EventNotifications { .. } | Kind::Epoll { .. } => return Err(Errno::Badf),
+            Kind::Dir { .. } | Kind::Root { .. } => return Err(Errno::Isdir),
+        }
+    }
+    inode.stat.write().unwrap().st_size = new_size;
+    debug!(%new_size);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_close.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_close.rs
new file mode 100644
index 0000000..9196d2a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_close.rs
@@ -0,0 +1,44 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_close()`
+/// Close an open file descriptor
+/// For sockets this will flush the data before the socket is closed
+/// Inputs:
+/// - `Fd fd`
+///     A file descriptor mapping to an open file to close
+/// Errors:
+/// - `Errno::Isdir`
+///     If `fd` is a directory
+/// - `Errno::Badf`
+///     If `fd` is invalid or not open
+#[instrument(level = "debug", skip_all, fields(pid = ctx.data().process.pid().raw(), %fd), ret)]
+pub fn fd_close(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    // HACK: As a special case, we don't want to close fd 3 because it can break
+    // some programs...
+    // - On Wasix, we have some default fd, 0:stdin, 1:stdout, 2:stderr, 3:root
+    // - On Posix, we have some default fd: 0:stdin, 1:stdout, 2:stderr
+    // - A POSIX program might want to closed all open fd (e.g. when Python
+    //   spawns subprocesses), so it blindly does fd_close() for fd=3..255
+    // - Wasix doesn't work well when 3:root is closed, because it's the root
+    if fd == 3 {
+        tracing::debug!("Skipping fd_close(3)");
+        return Ok(Errno::Success);
+    }
+
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    wasi_try_ok!(state.fs.close_fd(fd));
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_close(&mut ctx, fd).map_err(|err| {
+            tracing::error!("failed to save close descriptor event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_datasync.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_datasync.rs
new file mode 100644
index 0000000..7552305
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_datasync.rs
@@ -0,0 +1,24 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_datasync()`
+/// Synchronize the file data to disk
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to sync
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_datasync(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let state = env.state.clone();
+    let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+    if !fd_entry.rights.contains(Rights::FD_DATASYNC) {
+        return Ok(Errno::Access);
+    }
+
+    #[allow(clippy::await_holding_lock)]
+    Ok(wasi_try_ok!(__asyncify(&mut ctx, None, async move {
+        state.fs.flush(fd).await.map(|_| Errno::Success)
+    })?))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_dup.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_dup.rs
new file mode 100644
index 0000000..3dfe826
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_dup.rs
@@ -0,0 +1,45 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_dup()`
+/// Duplicates the file handle
+/// Inputs:
+/// - `Fd fd`
+///   File handle to be cloned
+/// Outputs:
+/// - `Fd fd`
+///   The new file handle that is a duplicate of the original
+#[instrument(level = "debug", skip_all, fields(%fd, ret_fd = field::Empty), ret)]
+pub fn fd_dup<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    ret_fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    let copied_fd = wasi_try_ok!(fd_dup_internal(&mut ctx, fd));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_duplicate(&mut ctx, fd, copied_fd).map_err(|err| {
+            tracing::error!("failed to save file descriptor duplicate event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Span::current().record("ret_fd", copied_fd);
+    let env = ctx.data();
+    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    wasi_try_mem_ok!(ret_fd.write(&memory, copied_fd));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_dup_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+) -> Result<WasiFd, Errno> {
+    let env = ctx.data();
+    let (memory, state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd = state.fs.clone_fd(fd)?;
+    Ok(fd)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_event.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_event.rs
new file mode 100644
index 0000000..6f3a01f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_event.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::{fs::NotificationInner, syscalls::*};
+
+/// ### `fd_event()`
+/// Creates a file handle for event notifications
+#[instrument(level = "debug", skip_all, fields(%initial_val, ret_fd = field::Empty), ret)]
+pub fn fd_event<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    initial_val: u64,
+    flags: EventFdFlags,
+    ret_fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    let fd = wasi_try_ok!(fd_event_internal(&mut ctx, initial_val, flags)?);
+
+    let env = ctx.data();
+    let (memory, state, _) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    Span::current().record("ret_fd", fd);
+    wasi_try_mem_ok!(ret_fd.write(&memory, fd));
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_event(&mut ctx, initial_val, flags, fd).map_err(|err| {
+            tracing::error!("failed to save fd_event event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub fn fd_event_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    initial_val: u64,
+    flags: EventFdFlags,
+) -> Result<Result<WasiFd, Errno>, WasiError> {
+    let env = ctx.data();
+    let (memory, state, mut inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let is_semaphore = flags & EVENT_FD_FLAGS_SEMAPHORE != 0;
+    let kind = Kind::EventNotifications {
+        inner: Arc::new(NotificationInner::new(initial_val, is_semaphore)),
+    };
+
+    let inode =
+        state
+            .fs
+            .create_inode_with_default_stat(inodes, kind, false, "event".to_string().into());
+    let rights = Rights::FD_READ
+        | Rights::FD_WRITE
+        | Rights::POLL_FD_READWRITE
+        | Rights::FD_FDSTAT_SET_FLAGS;
+    let fd = wasi_try_ok_ok!(state
+        .fs
+        .create_fd(rights, rights, Fdflags::empty(), 0, inode));
+
+    Ok(Ok(fd))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs
new file mode 100644
index 0000000..4f0ced4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_get.rs
@@ -0,0 +1,27 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_fdstat_get()`
+/// Get metadata of a file descriptor
+/// Input:
+/// - `Fd fd`
+///     The file descriptor whose metadata will be accessed
+/// Output:
+/// - `Fdstat *buf`
+///     The location where the metadata will be written
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
+pub fn fd_fdstat_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    buf_ptr: WasmPtr<Fdstat, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let stat = wasi_try!(state.fs.fdstat(fd));
+
+    let buf = buf_ptr.deref(&memory);
+
+    wasi_try_mem!(buf.write(stat));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs
new file mode 100644
index 0000000..cedd78f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_flags.rs
@@ -0,0 +1,56 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_fdstat_set_flags()`
+/// Set file descriptor flags for a file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to apply the new flags to
+/// - `Fdflags flags`
+///     The flags to apply to `fd`
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_fdstat_set_flags(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: Fdflags,
+) -> Result<Errno, WasiError> {
+    let ret = fd_fdstat_set_flags_internal(&mut ctx, fd, flags)?;
+    let env = ctx.data();
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        if env.enable_journal {
+            JournalEffector::save_fd_set_flags(&mut ctx, fd, flags).map_err(|err| {
+                tracing::error!("failed to save file set flags event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+        }
+    }
+
+    Ok(ret)
+}
+
+pub(crate) fn fd_fdstat_set_flags_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: Fdflags,
+) -> Result<Errno, WasiError> {
+    {
+        let env = ctx.data();
+        let (_, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+        let mut fd_map = state.fs.fd_map.write().unwrap();
+        let fd_entry = wasi_try_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+        let inode = fd_entry.inode.clone();
+
+        if !fd_entry.rights.contains(Rights::FD_FDSTAT_SET_FLAGS) {
+            return Ok(Errno::Access);
+        }
+    }
+
+    let env = ctx.data();
+    let (_, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let mut fd_map = state.fs.fd_map.write().unwrap();
+    let fd_entry = wasi_try_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+    fd_entry.flags = flags;
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs
new file mode 100644
index 0000000..ce9aa91
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_fdstat_set_rights.rs
@@ -0,0 +1,62 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_fdstat_set_rights()`
+/// Set the rights of a file descriptor.  This can only be used to remove rights
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to apply the new rights to
+/// - `Rights fs_rights_base`
+///     The rights to apply to `fd`
+/// - `Rights fs_rights_inheriting`
+///     The inheriting rights to apply to `fd`
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_fdstat_set_rights(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(fd_fdstat_set_rights_internal(
+        &mut ctx,
+        fd,
+        fs_rights_base,
+        fs_rights_inheriting
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_set_rights(&mut ctx, fd, fs_rights_base, fs_rights_inheriting)
+            .map_err(|err| {
+                tracing::error!("failed to save file set rights event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_fdstat_set_rights_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let mut fd_map = state.fs.fd_map.write().unwrap();
+    let fd_entry = fd_map.get_mut(&fd).ok_or(Errno::Badf)?;
+
+    // ensure new rights are a subset of current rights
+    if fd_entry.rights | fs_rights_base != fd_entry.rights
+        || fd_entry.rights_inheriting | fs_rights_inheriting != fd_entry.rights_inheriting
+    {
+        return Err(Errno::Notcapable);
+    }
+
+    fd_entry.rights = fs_rights_base;
+    fd_entry.rights_inheriting = fs_rights_inheriting;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
new file mode 100644
index 0000000..46a3dc3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_get.rs
@@ -0,0 +1,84 @@
+use super::*;
+use crate::syscalls::*;
+use crate::types::wasi::Snapshot0Filestat;
+
+/// ### `fd_filestat_get()`
+/// Get the metadata of an open file
+/// Input:
+/// - `Fd fd`
+///     The open file descriptor whose metadata will be read
+/// Output:
+/// - `Filestat *buf`
+///     Where the metadata from `fd` will be written
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_filestat_get<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    buf: WasmPtr<Filestat, M>,
+) -> Errno {
+    let stat = wasi_try!(fd_filestat_get_internal(&mut ctx, fd));
+
+    let env = ctx.data();
+    let (memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let buf = buf.deref(&memory);
+    wasi_try_mem!(buf.write(stat));
+
+    Errno::Success
+}
+
+/// ### `fd_filestat_get()`
+/// Get the metadata of an open file
+/// Input:
+/// - `__wasi_fd_t fd`
+///     The open file descriptor whose metadata will be read
+/// Output:
+/// - `__wasi_filestat_t *buf`
+///     Where the metadata from `fd` will be written
+pub(crate) fn fd_filestat_get_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+) -> Result<Filestat, Errno> {
+    let env = ctx.data();
+    let (_, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let fd_entry = state.fs.get_fd(fd)?;
+    if !fd_entry.rights.contains(Rights::FD_FILESTAT_GET) {
+        return Err(Errno::Access);
+    }
+
+    state.fs.filestat_fd(fd)
+}
+
+/// ### `fd_filestat_get_old()`
+/// Get the metadata of an open file
+/// Input:
+/// - `Fd fd`
+///     The open file descriptor whose metadata will be read
+/// Output:
+/// - `Snapshot0Filestat *buf`
+///     Where the metadata from `fd` will be written
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_filestat_get_old<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    buf: WasmPtr<Snapshot0Filestat, M>,
+) -> Errno {
+    let stat = wasi_try!(fd_filestat_get_internal(&mut ctx, fd));
+
+    let env = ctx.data();
+    let (memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let old_stat = Snapshot0Filestat {
+        st_dev: stat.st_dev,
+        st_ino: stat.st_ino,
+        st_filetype: stat.st_filetype,
+        st_nlink: stat.st_nlink as u32,
+        st_size: stat.st_size,
+        st_atim: stat.st_atim,
+        st_mtim: stat.st_mtim,
+        st_ctim: stat.st_ctim,
+    };
+
+    let buf = buf.deref(&memory);
+    wasi_try_mem!(buf.write(old_stat));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs
new file mode 100644
index 0000000..ddb3617
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_size.rs
@@ -0,0 +1,69 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_filestat_set_size()`
+/// Change the size of an open file, zeroing out any new bytes
+/// Inputs:
+/// - `Fd fd`
+///     File descriptor to adjust
+/// - `Filesize st_size`
+///     New size that `fd` will be set to
+#[instrument(level = "debug", skip_all, fields(%fd, %st_size), ret)]
+pub fn fd_filestat_set_size(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    st_size: Filesize,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(fd_filestat_set_size_internal(&mut ctx, fd, st_size));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_set_size(&mut ctx, fd, st_size).map_err(|err| {
+            tracing::error!("failed to save file set size event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_filestat_set_size_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    st_size: Filesize,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd_entry = state.fs.get_fd(fd)?;
+    let inode = fd_entry.inode;
+
+    if !fd_entry.rights.contains(Rights::FD_FILESTAT_SET_SIZE) {
+        return Err(Errno::Access);
+    }
+
+    {
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::File { handle, .. } => {
+                if let Some(handle) = handle {
+                    let mut handle = handle.write().unwrap();
+                    handle.set_len(st_size).map_err(fs_error_into_wasi_err)?;
+                } else {
+                    return Err(Errno::Badf);
+                }
+            }
+            Kind::Buffer { buffer } => {
+                buffer.resize(st_size as usize, 0);
+            }
+            Kind::Socket { .. } => return Err(Errno::Badf),
+            Kind::Pipe { .. } => return Err(Errno::Badf),
+            Kind::Symlink { .. } => return Err(Errno::Badf),
+            Kind::EventNotifications { .. } | Kind::Epoll { .. } => return Err(Errno::Badf),
+            Kind::Dir { .. } | Kind::Root { .. } => return Err(Errno::Isdir),
+        }
+    }
+    inode.stat.write().unwrap().st_size = st_size;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs
new file mode 100644
index 0000000..df7db20
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_filestat_set_times.rs
@@ -0,0 +1,81 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_filestat_set_times()`
+/// Set timestamp metadata on a file
+/// Inputs:
+/// - `Timestamp st_atim`
+///     Last accessed time
+/// - `Timestamp st_mtim`
+///     Last modified time
+/// - `Fstflags fst_flags`
+///     Bit-vector for controlling which times get set
+#[instrument(level = "debug", skip_all, fields(%fd, %st_atim, %st_mtim), ret)]
+pub fn fd_filestat_set_times(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    st_atim: Timestamp,
+    st_mtim: Timestamp,
+    fst_flags: Fstflags,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(fd_filestat_set_times_internal(
+        &mut ctx, fd, st_atim, st_mtim, fst_flags
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_set_times(&mut ctx, fd, st_atim, st_mtim, fst_flags).map_err(
+            |err| {
+                tracing::error!("failed to save file set times event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_filestat_set_times_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    st_atim: Timestamp,
+    st_mtim: Timestamp,
+    fst_flags: Fstflags,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd_entry = state.fs.get_fd(fd)?;
+
+    if !fd_entry.rights.contains(Rights::FD_FILESTAT_SET_TIMES) {
+        return Err(Errno::Access);
+    }
+
+    if (fst_flags.contains(Fstflags::SET_ATIM) && fst_flags.contains(Fstflags::SET_ATIM_NOW))
+        || (fst_flags.contains(Fstflags::SET_MTIM) && fst_flags.contains(Fstflags::SET_MTIM_NOW))
+    {
+        return Err(Errno::Inval);
+    }
+
+    let inode = fd_entry.inode;
+
+    if fst_flags.contains(Fstflags::SET_ATIM) || fst_flags.contains(Fstflags::SET_ATIM_NOW) {
+        let time_to_set = if fst_flags.contains(Fstflags::SET_ATIM) {
+            st_atim
+        } else {
+            get_current_time_in_nanos()?
+        };
+        inode.stat.write().unwrap().st_atim = time_to_set;
+    }
+
+    if fst_flags.contains(Fstflags::SET_MTIM) || fst_flags.contains(Fstflags::SET_MTIM_NOW) {
+        let time_to_set = if fst_flags.contains(Fstflags::SET_MTIM) {
+            st_mtim
+        } else {
+            get_current_time_in_nanos()?
+        };
+        inode.stat.write().unwrap().st_mtim = time_to_set;
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
new file mode 100644
index 0000000..9cdf725
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_dir_name.rs
@@ -0,0 +1,46 @@
+use super::*;
+use crate::syscalls::*;
+
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn fd_prestat_dir_name<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let path_chars = wasi_try_mem!(path.slice(&memory, path_len));
+
+    let inode = wasi_try!(state.fs.get_fd_inode(fd));
+    Span::current().record("path", inode.name.as_ref());
+
+    // check inode-val.is_preopened?
+
+    let guard = inode.read();
+    match guard.deref() {
+        Kind::Dir { .. } | Kind::Root { .. } => {
+            // TODO: verify this: null termination, etc
+            let path_len: u64 = path_len.into();
+            if (inode.name.len() as u64) < path_len {
+                wasi_try_mem!(path_chars
+                    .subslice(0..inode.name.len() as u64)
+                    .write_slice(inode.name.as_bytes()));
+                wasi_try_mem!(path_chars.index(inode.name.len() as u64).write(0));
+
+                //trace!("=> result: \"{}\"", inode_val.name);
+
+                Errno::Success
+            } else {
+                Errno::Overflow
+            }
+        }
+        Kind::Symlink { .. }
+        | Kind::Buffer { .. }
+        | Kind::File { .. }
+        | Kind::Socket { .. }
+        | Kind::Pipe { .. }
+        | Kind::EventNotifications { .. }
+        | Kind::Epoll { .. } => Errno::Notdir,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_get.rs
new file mode 100644
index 0000000..77a07b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_prestat_get.rs
@@ -0,0 +1,25 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_prestat_get()`
+/// Get metadata about a preopened file descriptor
+/// Input:
+/// - `Fd fd`
+///     The preopened file descriptor to query
+/// Output:
+/// - `__wasi_prestat *buf`
+///     Where the metadata will be written
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
+pub fn fd_prestat_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    buf: WasmPtr<Prestat, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let prestat_ptr = buf.deref(&memory);
+    wasi_try_mem!(prestat_ptr.write(wasi_try!(state.fs.prestat_fd(fd))));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_read.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_read.rs
new file mode 100644
index 0000000..78b9569
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_read.rs
@@ -0,0 +1,407 @@
+use std::{collections::VecDeque, task::Waker};
+
+use virtual_fs::{AsyncReadExt, DeviceFile, ReadBuf};
+
+use super::*;
+use crate::{
+    fs::NotificationInner,
+    journal::SnapshotTrigger,
+    net::socket::TimeType,
+    os::task::process::{MaybeCheckpointResult, WasiProcessCheckpoint, WasiProcessInner},
+    syscalls::*,
+};
+
+/// ### `fd_read()`
+/// Read data from file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     File descriptor from which data will be read
+/// - `const __wasi_iovec_t *iovs`
+///     Vectors where data will be stored
+/// - `u32 iovs_len`
+///     Length of data in `iovs`
+/// Output:
+/// - `u32 *nread`
+///     Number of bytes read
+///
+#[instrument(level = "trace", skip_all, fields(%fd, nread = field::Empty), ret)]
+pub fn fd_read<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    iovs: WasmPtr<__wasi_iovec_t<M>, M>,
+    iovs_len: M::Offset,
+    nread: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let pid = ctx.data().pid();
+    let tid = ctx.data().tid();
+
+    let offset = {
+        let mut env = ctx.data();
+        let state = env.state.clone();
+        let inodes = state.inodes.clone();
+
+        let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+        fd_entry.offset.load(Ordering::Acquire) as usize
+    };
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    if fd == DeviceFile::STDIN {
+        ctx = wasi_try_ok!(maybe_snapshot_once::<M>(ctx, SnapshotTrigger::FirstStdin)?);
+    }
+
+    let res = fd_read_internal::<M>(&mut ctx, fd, iovs, iovs_len, offset, nread, true)?;
+    fd_read_internal_handler(ctx, res, nread)
+}
+
+/// ### `fd_pread()`
+/// Read from the file at the given offset without updating the file cursor.
+/// This acts like a stateless version of Seek + Read
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to read the data with
+/// - `const __wasi_iovec_t* iovs'
+///     Vectors where the data will be stored
+/// - `size_t iovs_len`
+///     The number of vectors to store the data into
+/// - `Filesize offset`
+///     The file cursor to use: the starting position from which data will be read
+/// Output:
+/// - `size_t nread`
+///     The number of bytes read
+#[instrument(level = "trace", skip_all, fields(%fd, %offset, ?nread), ret)]
+pub fn fd_pread<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    iovs: WasmPtr<__wasi_iovec_t<M>, M>,
+    iovs_len: M::Offset,
+    offset: Filesize,
+    nread: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let pid = ctx.data().pid();
+    let tid = ctx.data().tid();
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    if fd == DeviceFile::STDIN {
+        ctx = wasi_try_ok!(maybe_snapshot_once::<M>(ctx, SnapshotTrigger::FirstStdin)?);
+    }
+
+    let res = fd_read_internal::<M>(&mut ctx, fd, iovs, iovs_len, offset as usize, nread, false)?;
+    fd_read_internal_handler::<M>(ctx, res, nread)
+}
+
+pub(crate) fn fd_read_internal_handler<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    res: Result<usize, Errno>,
+    nread: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let mut ret = Errno::Success;
+    let bytes_read = match res {
+        Ok(bytes_read) => bytes_read,
+        Err(err) => {
+            ret = err;
+            0
+        }
+    };
+    Span::current().record("nread", bytes_read);
+
+    let bytes_read: M::Offset = wasi_try_ok!(bytes_read.try_into().map_err(|_| Errno::Overflow));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let nread_ref = nread.deref(&memory);
+    wasi_try_mem_ok!(nread_ref.write(bytes_read));
+
+    Ok(ret)
+}
+
+pub(crate) fn fd_read_internal<M: MemorySize>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    iovs: WasmPtr<__wasi_iovec_t<M>, M>,
+    iovs_len: M::Offset,
+    offset: usize,
+    nread: WasmPtr<M::Offset, M>,
+    should_update_cursor: bool,
+) -> WasiResult<usize> {
+    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let state = env.state();
+
+    let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(fd));
+    let is_stdio = fd_entry.is_stdio;
+
+    let bytes_read = {
+        if !is_stdio && !fd_entry.rights.contains(Rights::FD_READ) {
+            // TODO: figure out the error to return when lacking rights
+            return Ok(Err(Errno::Access));
+        }
+
+        let inode = fd_entry.inode;
+        let fd_flags = fd_entry.flags;
+
+        let (bytes_read, can_update_cursor) = {
+            let mut guard = inode.write();
+            match guard.deref_mut() {
+                Kind::File { handle, .. } => {
+                    if let Some(handle) = handle {
+                        let handle = handle.clone();
+
+                        drop(guard);
+
+                        let res = __asyncify_light(
+                            env,
+                            if fd_flags.contains(Fdflags::NONBLOCK) {
+                                Some(Duration::ZERO)
+                            } else {
+                                None
+                            },
+                            async move {
+                                let mut handle = match handle.write() {
+                                    Ok(a) => a,
+                                    Err(_) => return Err(Errno::Fault),
+                                };
+                                if !is_stdio {
+                                    handle
+                                        .seek(std::io::SeekFrom::Start(offset as u64))
+                                        .await
+                                        .map_err(map_io_err)?;
+                                }
+
+                                let mut total_read = 0usize;
+
+                                let iovs_arr =
+                                    iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                                let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+                                for iovs in iovs_arr.iter() {
+                                    let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                        .slice(&memory, iovs.buf_len)
+                                        .map_err(mem_error_to_wasi)?
+                                        .access()
+                                        .map_err(mem_error_to_wasi)?;
+                                    let local_read =
+                                        match handle.read(buf.as_mut()).await.map_err(|err| {
+                                            let err = From::<std::io::Error>::from(err);
+                                            match err {
+                                                Errno::Again => {
+                                                    if is_stdio {
+                                                        Errno::Badf
+                                                    } else {
+                                                        Errno::Again
+                                                    }
+                                                }
+                                                a => a,
+                                            }
+                                        }) {
+                                            Ok(s) => s,
+                                            Err(_) if total_read > 0 => break,
+                                            Err(err) => return Err(err),
+                                        };
+                                    total_read += local_read;
+                                    if local_read != buf.len() {
+                                        break;
+                                    }
+                                }
+                                Ok(total_read)
+                            },
+                        );
+                        let read = wasi_try_ok_ok!(res?.map_err(|err| match err {
+                            Errno::Timedout => Errno::Again,
+                            a => a,
+                        }));
+                        (read, true)
+                    } else {
+                        return Ok(Err(Errno::Badf));
+                    }
+                }
+                Kind::Socket { socket } => {
+                    let socket = socket.clone();
+
+                    drop(guard);
+
+                    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+                    let timeout = socket
+                        .opt_time(TimeType::ReadTimeout)
+                        .ok()
+                        .flatten()
+                        .unwrap_or(Duration::from_secs(30));
+
+                    let tasks = env.tasks().clone();
+                    let res = __asyncify_light(
+                        env,
+                        if fd_flags.contains(Fdflags::NONBLOCK) {
+                            Some(Duration::ZERO)
+                        } else {
+                            None
+                        },
+                        async move {
+                            let mut total_read = 0usize;
+
+                            let iovs_arr =
+                                iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                            let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+                            for iovs in iovs_arr.iter() {
+                                let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi)?
+                                    .access()
+                                    .map_err(mem_error_to_wasi)?;
+
+                                let local_read = socket
+                                    .recv(
+                                        tasks.deref(),
+                                        buf.as_mut_uninit(),
+                                        Some(timeout),
+                                        nonblocking,
+                                    )
+                                    .await?;
+                                total_read += local_read;
+                                if total_read != buf.len() {
+                                    break;
+                                }
+                            }
+                            Ok(total_read)
+                        },
+                    );
+                    let res = res?.map_err(|err| match err {
+                        Errno::Timedout => Errno::Again,
+                        a => a,
+                    });
+                    match res {
+                        Err(Errno::Connaborted) | Err(Errno::Connreset) => (0, false),
+                        res => {
+                            let bytes_read = wasi_try_ok_ok!(res);
+                            (bytes_read, false)
+                        }
+                    }
+                }
+                Kind::Pipe { pipe } => {
+                    let mut pipe = pipe.clone();
+
+                    drop(guard);
+
+                    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+
+                    let res = __asyncify_light(
+                        env,
+                        if fd_flags.contains(Fdflags::NONBLOCK) {
+                            Some(Duration::ZERO)
+                        } else {
+                            None
+                        },
+                        async move {
+                            let mut total_read = 0usize;
+
+                            let iovs_arr =
+                                iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                            let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+                            for iovs in iovs_arr.iter() {
+                                let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi)?
+                                    .access()
+                                    .map_err(mem_error_to_wasi)?;
+
+                                let local_read = match nonblocking {
+                                    true => match pipe.try_read(buf.as_mut()) {
+                                        Some(amt) => amt,
+                                        None => {
+                                            return Err(Errno::Again);
+                                        }
+                                    },
+                                    false => {
+                                        virtual_fs::AsyncReadExt::read(&mut pipe, buf.as_mut())
+                                            .await?
+                                    }
+                                };
+                                total_read += local_read;
+                                if local_read != buf.len() {
+                                    break;
+                                }
+                            }
+                            Ok(total_read)
+                        },
+                    );
+
+                    let bytes_read = wasi_try_ok_ok!(res?.map_err(|err| match err {
+                        Errno::Timedout => Errno::Again,
+                        a => a,
+                    }));
+
+                    (bytes_read, false)
+                }
+                Kind::Dir { .. } | Kind::Root { .. } => {
+                    // TODO: verify
+                    return Ok(Err(Errno::Isdir));
+                }
+                Kind::EventNotifications { inner } => {
+                    // Create a poller
+                    struct NotifyPoller {
+                        inner: Arc<NotificationInner>,
+                        non_blocking: bool,
+                    }
+                    let poller = NotifyPoller {
+                        inner: inner.clone(),
+                        non_blocking: fd_flags.contains(Fdflags::NONBLOCK),
+                    };
+
+                    drop(guard);
+
+                    // The poller will register itself for notifications and wait for the
+                    // counter to drop
+                    impl Future for NotifyPoller {
+                        type Output = Result<u64, Errno>;
+                        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                            if self.non_blocking {
+                                Poll::Ready(self.inner.try_read().ok_or(Errno::Again))
+                            } else {
+                                self.inner.read(cx.waker()).map(Ok)
+                            }
+                        }
+                    }
+
+                    // Yield until the notifications are triggered
+                    let tasks_inner = env.tasks().clone();
+
+                    let res = __asyncify_light(env, None, poller)?.map_err(|err| match err {
+                        Errno::Timedout => Errno::Again,
+                        a => a,
+                    });
+                    let val = wasi_try_ok_ok!(res);
+
+                    let mut memory = unsafe { env.memory_view(ctx) };
+                    let reader = val.to_ne_bytes();
+                    let iovs_arr = wasi_try_mem_ok_ok!(iovs.slice(&memory, iovs_len));
+                    let ret = wasi_try_ok_ok!(read_bytes(&reader[..], &memory, iovs_arr));
+                    (ret, false)
+                }
+                Kind::Symlink { .. } | Kind::Epoll { .. } => {
+                    return Ok(Err(Errno::Notsup));
+                }
+                Kind::Buffer { buffer } => {
+                    let memory = unsafe { env.memory_view(ctx) };
+                    let iovs_arr = wasi_try_mem_ok_ok!(iovs.slice(&memory, iovs_len));
+                    let read = wasi_try_ok_ok!(read_bytes(&buffer[offset..], &memory, iovs_arr));
+                    (read, true)
+                }
+            }
+        };
+
+        if !is_stdio && should_update_cursor && can_update_cursor {
+            // reborrow
+            let mut fd_map = state.fs.fd_map.write().unwrap();
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+            let old = fd_entry
+                .offset
+                .fetch_add(bytes_read as u64, Ordering::AcqRel);
+        }
+
+        bytes_read
+    };
+
+    Ok(Ok(bytes_read))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_readdir.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_readdir.rs
new file mode 100644
index 0000000..2595b1e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_readdir.rs
@@ -0,0 +1,141 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_readdir()`
+/// Read data from directory specified by file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     File descriptor from which directory data will be read
+/// - `void *buf`
+///     Buffer where directory entries are stored
+/// - `u32 buf_len`
+///     Length of data in `buf`
+/// - `Dircookie cookie`
+///     Where the directory reading should start from
+/// Output:
+/// - `u32 *bufused`
+///     The Number of bytes stored in `buf`; if less than `buf_len` then entire
+///     directory has been read
+#[instrument(level = "trace", skip_all, fields(%fd), ret)]
+pub fn fd_readdir<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    buf: WasmPtr<u8, M>,
+    buf_len: M::Offset,
+    cookie: Dircookie,
+    bufused: WasmPtr<M::Offset, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    // TODO: figure out how this is supposed to work;
+    // is it supposed to pack the buffer full every time until it can't? or do one at a time?
+
+    let buf_arr = wasi_try_mem!(buf.slice(&memory, buf_len));
+    let bufused_ref = bufused.deref(&memory);
+    let working_dir = wasi_try!(state.fs.get_fd(fd));
+    let mut cur_cookie = cookie;
+    let mut buf_idx = 0usize;
+
+    let entries: Vec<(String, Filetype, u64)> = {
+        let guard = working_dir.inode.read();
+        match guard.deref() {
+            Kind::Dir { path, entries, .. } => {
+                trace!("reading dir {:?}", path);
+                // TODO: refactor this code
+                // we need to support multiple calls,
+                // simple and obviously correct implementation for now:
+                // maintain consistent order via lexacographic sorting
+                let fs_info = wasi_try!(wasi_try!(state.fs_read_dir(path))
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(fs_error_into_wasi_err));
+                let mut entry_vec = wasi_try!(fs_info
+                    .into_iter()
+                    .map(|entry| {
+                        let filename = entry.file_name().to_string_lossy().to_string();
+                        trace!("getting file: {:?}", filename);
+                        let filetype = virtual_file_type_to_wasi_file_type(
+                            entry.file_type().map_err(fs_error_into_wasi_err)?,
+                        );
+                        Ok((
+                            filename, filetype, 0, // TODO: inode
+                        ))
+                    })
+                    .collect::<Result<Vec<(String, Filetype, u64)>, _>>());
+                entry_vec.extend(entries.iter().filter(|(_, inode)| inode.is_preopened).map(
+                    |(name, inode)| {
+                        let stat = inode.stat.read().unwrap();
+                        (inode.name.to_string(), stat.st_filetype, stat.st_ino)
+                    },
+                ));
+                // adding . and .. special folders
+                // TODO: inode
+                entry_vec.push((".".to_string(), Filetype::Directory, 0));
+                entry_vec.push(("..".to_string(), Filetype::Directory, 0));
+                entry_vec.sort_by(|a, b| a.0.cmp(&b.0));
+                entry_vec
+            }
+            Kind::Root { entries } => {
+                trace!("reading root");
+                let sorted_entries = {
+                    let mut entry_vec: Vec<(String, InodeGuard)> = entries
+                        .iter()
+                        .map(|(a, b)| (a.clone(), b.clone()))
+                        .collect();
+                    entry_vec.sort_by(|a, b| a.0.cmp(&b.0));
+                    entry_vec
+                };
+                sorted_entries
+                    .into_iter()
+                    .map(|(name, inode)| {
+                        let stat = inode.stat.read().unwrap();
+                        (format!("/{}", inode.name), stat.st_filetype, stat.st_ino)
+                    })
+                    .collect()
+            }
+            Kind::File { .. }
+            | Kind::Symlink { .. }
+            | Kind::Buffer { .. }
+            | Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Errno::Notdir,
+        }
+    };
+
+    for (entry_path_str, wasi_file_type, ino) in entries.iter().skip(cookie as usize) {
+        cur_cookie += 1;
+        let namlen = entry_path_str.len();
+        trace!("returning dirent for {}", entry_path_str);
+        let dirent = Dirent {
+            d_next: cur_cookie,
+            d_ino: *ino,
+            d_namlen: namlen as u32,
+            d_type: *wasi_file_type,
+        };
+        let dirent_bytes = dirent_to_le_bytes(&dirent);
+        let buf_len: u64 = buf_len.into();
+        let upper_limit = std::cmp::min(
+            (buf_len - buf_idx as u64) as usize,
+            std::mem::size_of::<Dirent>(),
+        );
+        for (i, b) in dirent_bytes.iter().enumerate().take(upper_limit) {
+            wasi_try_mem!(buf_arr.index((i + buf_idx) as u64).write(*b));
+        }
+        buf_idx += upper_limit;
+        if upper_limit != std::mem::size_of::<Dirent>() {
+            break;
+        }
+        let upper_limit = std::cmp::min((buf_len - buf_idx as u64) as usize, namlen);
+        for (i, b) in entry_path_str.bytes().take(upper_limit).enumerate() {
+            wasi_try_mem!(buf_arr.index((i + buf_idx) as u64).write(b));
+        }
+        buf_idx += upper_limit;
+        if upper_limit != namlen {
+            break;
+        }
+    }
+
+    let buf_idx: M::Offset = wasi_try!(buf_idx.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem!(bufused_ref.write(buf_idx));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_renumber.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_renumber.rs
new file mode 100644
index 0000000..55add2e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_renumber.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_renumber()`
+/// Atomically copy file descriptor
+/// Inputs:
+/// - `Fd from`
+///     File descriptor to copy
+/// - `Fd to`
+///     Location to copy file descriptor to
+#[instrument(level = "debug", skip_all, fields(%from, %to), ret)]
+pub fn fd_renumber(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    from: WasiFd,
+    to: WasiFd,
+) -> Result<Errno, WasiError> {
+    let ret = fd_renumber_internal(&mut ctx, from, to);
+    let env = ctx.data();
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        if env.enable_journal {
+            JournalEffector::save_fd_renumber(&mut ctx, from, to).map_err(|err| {
+                tracing::error!("failed to save file descriptor renumber event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+        }
+    }
+    Ok(ret)
+}
+
+pub(crate) fn fd_renumber_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    from: WasiFd,
+    to: WasiFd,
+) -> Errno {
+    if from == to {
+        return Errno::Success;
+    }
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+
+    let mut fd_map = state.fs.fd_map.write().unwrap();
+    let fd_entry = wasi_try!(fd_map.get_mut(&from).ok_or(Errno::Badf));
+
+    let new_fd_entry = Fd {
+        // TODO: verify this is correct
+        offset: fd_entry.offset.clone(),
+        rights: fd_entry.rights_inheriting,
+        inode: fd_entry.inode.clone(),
+        ..*fd_entry
+    };
+    fd_map.insert(to, new_fd_entry);
+    state.fs.make_max_fd(to + 1);
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_seek.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_seek.rs
new file mode 100644
index 0000000..02c6b06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_seek.rs
@@ -0,0 +1,144 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_seek()`
+/// Update file descriptor offset
+/// Inputs:
+/// - `Fd fd`
+///     File descriptor to mutate
+/// - `FileDelta offset`
+///     Number of bytes to adjust offset by
+/// - `Whence whence`
+///     What the offset is relative to
+/// Output:
+/// - `Filesize *fd`
+///     The new offset relative to the start of the file
+#[instrument(level = "trace", skip_all, fields(%fd, %offset, ?whence), ret)]
+pub fn fd_seek<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: FileDelta,
+    whence: Whence,
+    newoffset: WasmPtr<Filesize, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let new_offset = wasi_try_ok!(fd_seek_internal(&mut ctx, fd, offset, whence)?);
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_seek(&mut ctx, fd, offset, whence).map_err(|err| {
+            tracing::error!("failed to save file descriptor seek event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    // reborrow
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let new_offset_ref = newoffset.deref(&memory);
+    let fd_entry = wasi_try_ok!(env.state.fs.get_fd(fd));
+    wasi_try_mem_ok!(new_offset_ref.write(new_offset));
+
+    trace!(
+        %new_offset,
+    );
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn fd_seek_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: FileDelta,
+    whence: Whence,
+) -> Result<Result<Filesize, Errno>, WasiError> {
+    let env = ctx.data();
+    let state = env.state.clone();
+    let (memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(fd));
+
+    if !fd_entry.rights.contains(Rights::FD_SEEK) {
+        return Ok(Err(Errno::Access));
+    }
+
+    // TODO: handle case if fd is a dir?
+    let new_offset = match whence {
+        Whence::Cur => {
+            let mut fd_map = state.fs.fd_map.write().unwrap();
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+
+            #[allow(clippy::comparison_chain)]
+            if offset > 0 {
+                let offset = offset as u64;
+                fd_entry.offset.fetch_add(offset, Ordering::AcqRel) + offset
+            } else if offset < 0 {
+                let offset = offset.unsigned_abs();
+                // FIXME: need to handle underflow!
+                fd_entry.offset.fetch_sub(offset, Ordering::AcqRel) - offset
+            } else {
+                fd_entry.offset.load(Ordering::Acquire)
+            }
+        }
+        Whence::End => {
+            use std::io::SeekFrom;
+            let mut guard = fd_entry.inode.write();
+            let deref_mut = guard.deref_mut();
+            match deref_mut {
+                Kind::File { ref mut handle, .. } => {
+                    // TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
+                    #[allow(clippy::await_holding_lock)]
+                    if let Some(handle) = handle {
+                        let handle = handle.clone();
+                        drop(guard);
+
+                        wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+                            let mut handle = handle.write().unwrap();
+                            let end = handle
+                                .seek(SeekFrom::End(offset))
+                                .await
+                                .map_err(map_io_err)?;
+
+                            // TODO: handle case if fd_entry.offset uses 64 bits of a u64
+                            drop(handle);
+                            let mut fd_map = state.fs.fd_map.write().unwrap();
+                            let fd_entry = fd_map.get_mut(&fd).ok_or(Errno::Badf)?;
+                            fd_entry.offset.store(end, Ordering::Release);
+                            Ok(())
+                        })?);
+                    } else {
+                        return Ok(Err(Errno::Inval));
+                    }
+                }
+                Kind::Symlink { .. } => {
+                    unimplemented!("wasi::fd_seek not implemented for symlinks")
+                }
+                Kind::Dir { .. }
+                | Kind::Root { .. }
+                | Kind::Socket { .. }
+                | Kind::Pipe { .. }
+                | Kind::EventNotifications { .. }
+                | Kind::Epoll { .. } => {
+                    // TODO: check this
+                    return Ok(Err(Errno::Inval));
+                }
+                Kind::Buffer { .. } => {
+                    // seeking buffers probably makes sense
+                    // FIXME: implement this
+                    return Ok(Err(Errno::Inval));
+                }
+            }
+            fd_entry.offset.load(Ordering::Acquire)
+        }
+        Whence::Set => {
+            let mut fd_map = state.fs.fd_map.write().unwrap();
+            let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+            fd_entry.offset.store(offset as u64, Ordering::Release);
+            offset as u64
+        }
+        _ => return Ok(Err(Errno::Inval)),
+    };
+
+    Ok(Ok(new_offset))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_sync.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_sync.rs
new file mode 100644
index 0000000..d0600bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_sync.rs
@@ -0,0 +1,73 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_sync()`
+/// Synchronize file and metadata to disk (TODO: expand upon what this means in our system)
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to sync
+/// Errors:
+/// TODO: figure out which errors this should return
+/// - `Errno::Perm`
+/// - `Errno::Notcapable`
+#[instrument(level = "debug", skip_all, fields(%fd), ret)]
+pub fn fd_sync(mut ctx: FunctionEnvMut<'_, WasiEnv>, fd: WasiFd) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let (_, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+    if !fd_entry.rights.contains(Rights::FD_SYNC) {
+        return Ok(Errno::Access);
+    }
+    let inode = fd_entry.inode;
+
+    // TODO: implement this for more than files
+    {
+        let mut guard = inode.write();
+        match guard.deref_mut() {
+            Kind::File { handle, .. } => {
+                if let Some(handle) = handle {
+                    let handle = handle.clone();
+                    drop(guard);
+
+                    // TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
+                    #[allow(clippy::await_holding_lock)]
+                    let size = {
+                        wasi_try_ok!(__asyncify(&mut ctx, None, async move {
+                            // TODO: remove allow once inodes are refactored (see comments on [`WasiState`])
+                            #[allow(clippy::await_holding_lock)]
+                            let mut handle = handle.write().unwrap();
+                            handle.flush().await.map_err(map_io_err)?;
+                            Ok(handle.size())
+                        })?)
+                    };
+
+                    // Update FileStat to reflect the correct current size.
+                    // TODO: don't lock twice - currently needed to not keep a lock on all inodes
+                    {
+                        let env = ctx.data();
+                        let (_, mut state, inodes) =
+                            unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+                        let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+                        let inode = fd_entry.inode;
+                        let mut guard = inode.stat.write().unwrap();
+                        guard.st_size = size;
+                    }
+                } else {
+                    return Ok(Errno::Inval);
+                }
+            }
+            Kind::Root { .. } | Kind::Dir { .. } => return Ok(Errno::Isdir),
+            Kind::Buffer { .. }
+            | Kind::Symlink { .. }
+            | Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Ok(Errno::Inval),
+        }
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_tell.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_tell.rs
new file mode 100644
index 0000000..7f01c7b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_tell.rs
@@ -0,0 +1,33 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_tell()`
+/// Get the offset of the file descriptor
+/// Inputs:
+/// - `Fd fd`
+///     The file descriptor to access
+/// Output:
+/// - `Filesize *offset`
+///     The offset of `fd` relative to the start of the file
+#[instrument(level = "debug", skip_all, fields(%fd, offset = field::Empty), ret)]
+pub fn fd_tell<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    offset: WasmPtr<Filesize, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let offset_ref = offset.deref(&memory);
+
+    let fd_entry = wasi_try!(state.fs.get_fd(fd));
+
+    if !fd_entry.rights.contains(Rights::FD_TELL) {
+        return Errno::Access;
+    }
+
+    let offset = fd_entry.offset.load(Ordering::Acquire);
+    Span::current().record("offset", offset);
+    wasi_try_mem!(offset_ref.write(offset));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_write.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_write.rs
new file mode 100644
index 0000000..e586d89
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/fd_write.rs
@@ -0,0 +1,435 @@
+use std::task::Waker;
+
+use super::*;
+#[cfg(feature = "journal")]
+use crate::{
+    journal::{JournalEffector, JournalEntry},
+    utils::map_snapshot_err,
+};
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `fd_write()`
+/// Write data to the file descriptor
+/// Inputs:
+/// - `Fd`
+///     File descriptor (opened with writing) to write to
+/// - `const __wasi_ciovec_t *iovs`
+///     List of vectors to read data from
+/// - `u32 iovs_len`
+///     Length of data in `iovs`
+/// Output:
+/// - `u32 *nwritten`
+///     Number of bytes written
+/// Errors:
+///
+#[instrument(level = "trace", skip_all, fields(%fd, nwritten = field::Empty), ret)]
+pub fn fd_write<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+    iovs_len: M::Offset,
+    nwritten: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let offset = {
+        let state = env.state.clone();
+        let inodes = state.inodes.clone();
+
+        let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+        fd_entry.offset.load(Ordering::Acquire) as usize
+    };
+
+    let bytes_written = wasi_try_ok!(fd_write_internal::<M>(
+        &ctx,
+        fd,
+        FdWriteSource::Iovs { iovs, iovs_len },
+        offset as u64,
+        true,
+        env.enable_journal,
+    )?);
+
+    Span::current().record("nwritten", bytes_written);
+
+    let mut env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let nwritten_ref = nwritten.deref(&memory);
+    let bytes_written: M::Offset =
+        wasi_try_ok!(bytes_written.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(nwritten_ref.write(bytes_written));
+
+    Ok(Errno::Success)
+}
+
+/// ### `fd_pwrite()`
+/// Write to a file without adjusting its offset
+/// Inputs:
+/// - `Fd`
+///     File descriptor (opened with writing) to write to
+/// - `const __wasi_ciovec_t *iovs`
+///     List of vectors to read data from
+/// - `u32 iovs_len`
+///     Length of data in `iovs`
+/// - `Filesize offset`
+///     The offset to write at
+/// Output:
+/// - `u32 *nwritten`
+///     Number of bytes written
+#[instrument(level = "trace", skip_all, fields(%fd, %offset, nwritten = field::Empty), ret)]
+pub fn fd_pwrite<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+    iovs_len: M::Offset,
+    offset: Filesize,
+    nwritten: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let enable_snapshot_capture = ctx.data().enable_journal;
+
+    let bytes_written = wasi_try_ok!(fd_write_internal::<M>(
+        &ctx,
+        fd,
+        FdWriteSource::Iovs { iovs, iovs_len },
+        offset,
+        false,
+        enable_snapshot_capture,
+    )?);
+
+    Span::current().record("nwritten", bytes_written);
+
+    let mut env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let nwritten_ref = nwritten.deref(&memory);
+    let bytes_written: M::Offset =
+        wasi_try_ok!(bytes_written.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(nwritten_ref.write(bytes_written));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) enum FdWriteSource<'a, M: MemorySize> {
+    Iovs {
+        iovs: WasmPtr<__wasi_ciovec_t<M>, M>,
+        iovs_len: M::Offset,
+    },
+    Buffer(Cow<'a, [u8]>),
+}
+
+pub(crate) fn fd_write_internal<M: MemorySize>(
+    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    data: FdWriteSource<'_, M>,
+    offset: u64,
+    should_update_cursor: bool,
+    should_snapshot: bool,
+) -> Result<Result<usize, Errno>, WasiError> {
+    let mut env = ctx.data();
+    let state = env.state.clone();
+
+    let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(fd));
+    let is_stdio = fd_entry.is_stdio;
+
+    let bytes_written = {
+        if !is_stdio && !fd_entry.rights.contains(Rights::FD_WRITE) {
+            return Ok(Err(Errno::Access));
+        }
+
+        let fd_flags = fd_entry.flags;
+        let mut memory = unsafe { env.memory_view(&ctx) };
+
+        let (bytes_written, can_update_cursor, can_snapshot) = {
+            let (mut memory, _) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+            let mut guard = fd_entry.inode.write();
+            match guard.deref_mut() {
+                Kind::File { handle, .. } => {
+                    if let Some(handle) = handle {
+                        let handle = handle.clone();
+                        drop(guard);
+
+                        let res = __asyncify_light(
+                            env,
+                            if fd_entry.flags.contains(Fdflags::NONBLOCK) {
+                                Some(Duration::ZERO)
+                            } else {
+                                None
+                            },
+                            async {
+                                let mut handle = handle.write().unwrap();
+                                if !is_stdio {
+                                    handle
+                                        .seek(std::io::SeekFrom::Start(offset))
+                                        .await
+                                        .map_err(map_io_err)?;
+                                }
+
+                                let mut written = 0usize;
+
+                                match &data {
+                                    FdWriteSource::Iovs { iovs, iovs_len } => {
+                                        let iovs_arr = iovs
+                                            .slice(&memory, *iovs_len)
+                                            .map_err(mem_error_to_wasi)?;
+                                        let iovs_arr =
+                                            iovs_arr.access().map_err(mem_error_to_wasi)?;
+                                        for iovs in iovs_arr.iter() {
+                                            let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                                .slice(&memory, iovs.buf_len)
+                                                .map_err(mem_error_to_wasi)?
+                                                .access()
+                                                .map_err(mem_error_to_wasi)?;
+                                            let local_written =
+                                                match handle.write(buf.as_ref()).await {
+                                                    Ok(s) => s,
+                                                    Err(_) if written > 0 => break,
+                                                    Err(err) => return Err(map_io_err(err)),
+                                                };
+                                            written += local_written;
+                                            if local_written != buf.len() {
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    FdWriteSource::Buffer(data) => {
+                                        handle.write_all(data).await?;
+                                        written += data.len();
+                                    }
+                                }
+
+                                if is_stdio {
+                                    handle.flush().await.map_err(map_io_err)?;
+                                }
+                                Ok(written)
+                            },
+                        );
+                        let written = wasi_try_ok_ok!(res?.map_err(|err| match err {
+                            Errno::Timedout => Errno::Again,
+                            a => a,
+                        }));
+
+                        (written, true, true)
+                    } else {
+                        return Ok(Err(Errno::Inval));
+                    }
+                }
+                Kind::Socket { socket } => {
+                    let socket = socket.clone();
+                    drop(guard);
+
+                    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+                    let timeout = socket
+                        .opt_time(TimeType::WriteTimeout)
+                        .ok()
+                        .flatten()
+                        .unwrap_or(Duration::from_secs(30));
+
+                    let tasks = env.tasks().clone();
+
+                    let res = __asyncify_light(env, None, async {
+                        let mut sent = 0usize;
+
+                        match &data {
+                            FdWriteSource::Iovs { iovs, iovs_len } => {
+                                let iovs_arr =
+                                    iovs.slice(&memory, *iovs_len).map_err(mem_error_to_wasi)?;
+                                let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+                                for iovs in iovs_arr.iter() {
+                                    let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                        .slice(&memory, iovs.buf_len)
+                                        .map_err(mem_error_to_wasi)?
+                                        .access()
+                                        .map_err(mem_error_to_wasi)?;
+                                    let local_sent = socket
+                                        .send(
+                                            tasks.deref(),
+                                            buf.as_ref(),
+                                            Some(timeout),
+                                            nonblocking,
+                                        )
+                                        .await?;
+                                    sent += local_sent;
+                                    if local_sent != buf.len() {
+                                        break;
+                                    }
+                                }
+                            }
+                            FdWriteSource::Buffer(data) => {
+                                sent += socket
+                                    .send(tasks.deref(), data.as_ref(), Some(timeout), nonblocking)
+                                    .await?;
+                            }
+                        }
+                        Ok(sent)
+                    });
+                    let written = wasi_try_ok_ok!(res?);
+                    (written, false, false)
+                }
+                Kind::Pipe { pipe } => {
+                    let mut written = 0usize;
+
+                    match &data {
+                        FdWriteSource::Iovs { iovs, iovs_len } => {
+                            let iovs_arr = wasi_try_ok_ok!(iovs
+                                .slice(&memory, *iovs_len)
+                                .map_err(mem_error_to_wasi));
+                            let iovs_arr =
+                                wasi_try_ok_ok!(iovs_arr.access().map_err(mem_error_to_wasi));
+                            for iovs in iovs_arr.iter() {
+                                let buf = wasi_try_ok_ok!(WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi));
+                                let buf = wasi_try_ok_ok!(buf.access().map_err(mem_error_to_wasi));
+                                let local_written =
+                                    wasi_try_ok_ok!(std::io::Write::write(pipe, buf.as_ref())
+                                        .map_err(map_io_err));
+
+                                written += local_written;
+                                if local_written != buf.len() {
+                                    break;
+                                }
+                            }
+                        }
+                        FdWriteSource::Buffer(data) => {
+                            wasi_try_ok_ok!(
+                                std::io::Write::write_all(pipe, data).map_err(map_io_err)
+                            );
+                            written += data.len();
+                        }
+                    }
+
+                    (written, false, true)
+                }
+                Kind::Dir { .. } | Kind::Root { .. } => {
+                    // TODO: verify
+                    return Ok(Err(Errno::Isdir));
+                }
+                Kind::EventNotifications { inner } => {
+                    let mut written = 0usize;
+
+                    match &data {
+                        FdWriteSource::Iovs { iovs, iovs_len } => {
+                            let iovs_arr = wasi_try_ok_ok!(iovs
+                                .slice(&memory, *iovs_len)
+                                .map_err(mem_error_to_wasi));
+                            let iovs_arr =
+                                wasi_try_ok_ok!(iovs_arr.access().map_err(mem_error_to_wasi));
+                            for iovs in iovs_arr.iter() {
+                                let buf_len: usize = wasi_try_ok_ok!(iovs
+                                    .buf_len
+                                    .try_into()
+                                    .map_err(|_| Errno::Inval));
+                                let will_be_written = buf_len;
+
+                                let val_cnt = buf_len / std::mem::size_of::<u64>();
+                                let val_cnt: M::Offset =
+                                    wasi_try_ok_ok!(val_cnt.try_into().map_err(|_| Errno::Inval));
+
+                                let vals = wasi_try_ok_ok!(WasmPtr::<u64, M>::new(iovs.buf)
+                                    .slice(&memory, val_cnt as M::Offset)
+                                    .map_err(mem_error_to_wasi));
+                                let vals =
+                                    wasi_try_ok_ok!(vals.access().map_err(mem_error_to_wasi));
+                                for val in vals.iter() {
+                                    inner.write(*val);
+                                }
+
+                                written += will_be_written;
+                            }
+                        }
+                        FdWriteSource::Buffer(data) => {
+                            let cnt = data.len() / std::mem::size_of::<u64>();
+                            for n in 0..cnt {
+                                let start = n * std::mem::size_of::<u64>();
+                                let data = [
+                                    data[start],
+                                    data[start + 1],
+                                    data[start + 2],
+                                    data[start + 3],
+                                    data[start + 4],
+                                    data[start + 5],
+                                    data[start + 6],
+                                    data[start + 7],
+                                ];
+                                inner.write(u64::from_ne_bytes(data));
+                            }
+                        }
+                    }
+
+                    (written, false, true)
+                }
+                Kind::Symlink { .. } | Kind::Epoll { .. } => return Ok(Err(Errno::Inval)),
+                Kind::Buffer { buffer } => {
+                    let mut written = 0usize;
+
+                    match &data {
+                        FdWriteSource::Iovs { iovs, iovs_len } => {
+                            let iovs_arr = wasi_try_ok_ok!(iovs
+                                .slice(&memory, *iovs_len)
+                                .map_err(mem_error_to_wasi));
+                            let iovs_arr =
+                                wasi_try_ok_ok!(iovs_arr.access().map_err(mem_error_to_wasi));
+                            for iovs in iovs_arr.iter() {
+                                let buf = wasi_try_ok_ok!(WasmPtr::<u8, M>::new(iovs.buf)
+                                    .slice(&memory, iovs.buf_len)
+                                    .map_err(mem_error_to_wasi));
+                                let buf = wasi_try_ok_ok!(buf.access().map_err(mem_error_to_wasi));
+                                let local_written =
+                                    wasi_try_ok_ok!(std::io::Write::write(buffer, buf.as_ref())
+                                        .map_err(map_io_err));
+                                written += local_written;
+                                if local_written != buf.len() {
+                                    break;
+                                }
+                            }
+                        }
+                        FdWriteSource::Buffer(data) => {
+                            wasi_try_ok_ok!(
+                                std::io::Write::write_all(buffer, data).map_err(map_io_err)
+                            );
+                            written += data.len();
+                        }
+                    }
+
+                    (written, false, true)
+                }
+            }
+        };
+
+        #[cfg(feature = "journal")]
+        if should_snapshot && can_snapshot && bytes_written > 0 {
+            if let FdWriteSource::Iovs { iovs, iovs_len } = data {
+                JournalEffector::save_fd_write(ctx, fd, offset, bytes_written, iovs, iovs_len)
+                    .map_err(|err| {
+                        tracing::error!("failed to save terminal data - {}", err);
+                        WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                    })?;
+            }
+        }
+
+        env = ctx.data();
+        memory = unsafe { env.memory_view(&ctx) };
+
+        // reborrow and update the size
+        if !is_stdio {
+            if can_update_cursor && should_update_cursor {
+                let mut fd_map = state.fs.fd_map.write().unwrap();
+                let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&fd).ok_or(Errno::Badf));
+                fd_entry
+                    .offset
+                    .fetch_add(bytes_written as u64, Ordering::AcqRel);
+            }
+
+            // we set the size but we don't return any errors if it fails as
+            // pipes and sockets will not do anything with this
+            let (mut memory, _, inodes) =
+                unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+            // Cast is valid because we don't support 128 bit systems...
+            fd_entry.inode.stat.write().unwrap().st_size += bytes_written as u64;
+        }
+        bytes_written
+    };
+
+    Ok(Ok(bytes_written))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/mod.rs
new file mode 100644
index 0000000..f336026
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/mod.rs
@@ -0,0 +1,89 @@
+mod args_get;
+mod args_sizes_get;
+mod clock_res_get;
+mod clock_time_get;
+mod clock_time_set;
+mod environ_get;
+mod environ_sizes_get;
+mod fd_advise;
+mod fd_allocate;
+mod fd_close;
+mod fd_datasync;
+mod fd_dup;
+mod fd_event;
+mod fd_fdstat_get;
+mod fd_fdstat_set_flags;
+mod fd_fdstat_set_rights;
+mod fd_filestat_get;
+mod fd_filestat_set_size;
+mod fd_filestat_set_times;
+mod fd_prestat_dir_name;
+mod fd_prestat_get;
+mod fd_read;
+mod fd_readdir;
+mod fd_renumber;
+mod fd_seek;
+mod fd_sync;
+mod fd_tell;
+mod fd_write;
+mod path_create_directory;
+mod path_filestat_get;
+mod path_filestat_set_times;
+mod path_link;
+mod path_open;
+mod path_readlink;
+mod path_remove_directory;
+mod path_rename;
+mod path_symlink;
+mod path_unlink_file;
+mod poll_oneoff;
+mod proc_exit;
+mod proc_raise;
+mod random_get;
+mod thread_spawn;
+
+pub use args_get::*;
+pub use args_sizes_get::*;
+pub use clock_res_get::*;
+pub use clock_time_get::*;
+pub use clock_time_set::*;
+pub use environ_get::*;
+pub use environ_sizes_get::*;
+pub use fd_advise::*;
+pub use fd_allocate::*;
+pub use fd_close::*;
+pub use fd_datasync::*;
+pub use fd_dup::*;
+pub use fd_event::*;
+pub use fd_fdstat_get::*;
+pub use fd_fdstat_set_flags::*;
+pub use fd_fdstat_set_rights::*;
+pub use fd_filestat_get::*;
+pub use fd_filestat_set_size::*;
+pub use fd_filestat_set_times::*;
+pub use fd_prestat_dir_name::*;
+pub use fd_prestat_get::*;
+pub use fd_read::*;
+pub use fd_readdir::*;
+pub use fd_renumber::*;
+pub use fd_seek::*;
+pub use fd_sync::*;
+pub use fd_tell::*;
+pub use fd_write::*;
+pub use path_create_directory::*;
+pub use path_filestat_get::*;
+pub use path_filestat_set_times::*;
+pub use path_link::*;
+pub use path_open::*;
+pub use path_readlink::*;
+pub use path_remove_directory::*;
+pub use path_rename::*;
+pub use path_symlink::*;
+pub use path_unlink_file::*;
+pub use poll_oneoff::*;
+pub use proc_exit::*;
+pub use proc_raise::*;
+pub use random_get::*;
+pub use thread_spawn::*;
+
+use tracing::{debug_span, field, instrument, trace_span, Span};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_create_directory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_create_directory.rs
new file mode 100644
index 0000000..b7263ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_create_directory.rs
@@ -0,0 +1,164 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_create_directory()`
+/// Create directory at a path
+/// Inputs:
+/// - `Fd fd`
+///     The directory that the path is relative to
+/// - `const char *path`
+///     String containing path data
+/// - `u32 path_len`
+///     The length of `path`
+/// Errors:
+/// Required Rights:
+/// - Rights::PATH_CREATE_DIRECTORY
+///     This right must be set on the directory that the file is created in (TODO: verify that this is true)
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn path_create_directory<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path_string.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_string.starts_with("./") {
+        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+        trace!(
+            %path_string
+        );
+    }
+
+    wasi_try_ok!(path_create_directory_internal(&mut ctx, fd, &path_string));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_create_directory(&mut ctx, fd, path_string).map_err(|err| {
+            tracing::error!("failed to save create directory event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn path_create_directory_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: &str,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let working_dir = state.fs.get_fd(fd)?;
+    {
+        let guard = working_dir.inode.read();
+        if let Kind::Root { .. } = guard.deref() {
+            trace!("root has no rights to create a directories");
+            return Err(Errno::Access);
+        }
+    }
+    if !working_dir.rights.contains(Rights::PATH_CREATE_DIRECTORY) {
+        trace!("working directory (fd={fd}) has no rights to create a directory");
+        return Err(Errno::Access);
+    }
+
+    let path = std::path::PathBuf::from(path);
+    let path_vec = path
+        .components()
+        .map(|comp| {
+            comp.as_os_str()
+                .to_str()
+                .map(|inner_str| inner_str.to_string())
+                .ok_or(Errno::Inval)
+        })
+        .collect::<Result<Vec<String>, Errno>>()?;
+    if path_vec.is_empty() {
+        trace!("path vector is inva;id (its empty)");
+        return Err(Errno::Inval);
+    }
+
+    let mut cur_dir_inode = working_dir.inode;
+    for comp in &path_vec {
+        let processing_cur_dir_inode = cur_dir_inode.clone();
+        let mut guard = processing_cur_dir_inode.write();
+        match guard.deref_mut() {
+            Kind::Dir {
+                ref mut entries,
+                path,
+                parent,
+            } => {
+                match comp.borrow() {
+                    ".." => {
+                        if let Some(p) = parent.upgrade() {
+                            cur_dir_inode = p;
+                            continue;
+                        }
+                    }
+                    "." => continue,
+                    _ => (),
+                }
+                if let Some(child) = entries.get(comp) {
+                    cur_dir_inode = child.clone();
+                } else {
+                    let mut adjusted_path = path.clone();
+                    drop(guard);
+
+                    // TODO: double check this doesn't risk breaking the sandbox
+                    adjusted_path.push(comp);
+                    if let Ok(adjusted_path_stat) = path_filestat_get_internal(
+                        &memory,
+                        state,
+                        inodes,
+                        fd,
+                        0,
+                        &adjusted_path.to_string_lossy(),
+                    ) {
+                        if adjusted_path_stat.st_filetype != Filetype::Directory {
+                            trace!("path is not a directory");
+                            return Err(Errno::Notdir);
+                        }
+                    } else {
+                        state.fs_create_dir(&adjusted_path)?;
+                    }
+                    let kind = Kind::Dir {
+                        parent: cur_dir_inode.downgrade(),
+                        path: adjusted_path,
+                        entries: Default::default(),
+                    };
+                    let new_inode = state
+                        .fs
+                        .create_inode(inodes, kind, false, comp.to_string())?;
+
+                    // reborrow to insert
+                    {
+                        let mut guard = cur_dir_inode.write();
+                        if let Kind::Dir {
+                            ref mut entries, ..
+                        } = guard.deref_mut()
+                        {
+                            entries.insert(comp.to_string(), new_inode.clone());
+                        }
+                    }
+                    cur_dir_inode = new_inode;
+                }
+            }
+            Kind::Root { .. } => {
+                trace!("the root node can no create a directory");
+                return Err(Errno::Access);
+            }
+            _ => {
+                trace!("path is not a directory");
+                return Err(Errno::Notdir);
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_get.rs
new file mode 100644
index 0000000..4941f62
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_get.rs
@@ -0,0 +1,141 @@
+use super::*;
+use crate::syscalls::*;
+use crate::types::wasi::Snapshot0Filestat;
+
+/// ### `path_filestat_get()`
+/// Access metadata about a file or directory
+/// Inputs:
+/// - `Fd fd`
+///     The directory that `path` is relative to
+/// - `LookupFlags flags`
+///     Flags to control how `path` is understood
+/// - `const char *path`
+///     String containing the file path
+/// - `u32 path_len`
+///     The length of the `path` string
+/// Output:
+/// - `__wasi_file_stat_t *buf`
+///     The location where the metadata will be stored
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn path_filestat_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: LookupFlags,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    buf: WasmPtr<Filestat, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let mut path_string = unsafe { get_input_str!(&memory, path, path_len) };
+
+    // Convert relative paths into absolute paths
+    if path_string.starts_with("./") {
+        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+    }
+    tracing::trace!(path = path_string.as_str());
+
+    let stat = wasi_try!(path_filestat_get_internal(
+        &memory,
+        state,
+        inodes,
+        fd,
+        flags,
+        &path_string
+    ));
+
+    wasi_try_mem!(buf.deref(&memory).write(stat));
+
+    Errno::Success
+}
+
+/// ### `path_filestat_get_internal()`
+/// return a Filstat or Errno
+pub(crate) fn path_filestat_get_internal(
+    memory: &MemoryView,
+    state: &WasiState,
+    inodes: &crate::WasiInodes,
+    fd: WasiFd,
+    flags: LookupFlags,
+    path_string: &str,
+) -> Result<Filestat, Errno> {
+    let root_dir = state.fs.get_fd(fd)?;
+
+    if !root_dir.rights.contains(Rights::PATH_FILESTAT_GET) {
+        return Err(Errno::Access);
+    }
+    let file_inode = state.fs.get_inode_at_path(
+        inodes,
+        fd,
+        path_string,
+        flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
+    )?;
+    let st_ino = file_inode.ino().as_u64();
+    let mut stat = if file_inode.is_preopened {
+        *file_inode.stat.read().unwrap().deref()
+    } else {
+        let guard = file_inode.read();
+        state.fs.get_stat_for_kind(guard.deref())?
+    };
+    stat.st_ino = st_ino;
+    Ok(stat)
+}
+
+/// ### `path_filestat_get_old()`
+/// Access metadata about a file or directory
+/// Inputs:
+/// - `Fd fd`
+///     The directory that `path` is relative to
+/// - `LookupFlags flags`
+///     Flags to control how `path` is understood
+/// - `const char *path`
+///     String containing the file path
+/// - `u32 path_len`
+///     The length of the `path` string
+/// Output:
+/// - `__wasi_file_stat_t *buf`
+///     The location where the metadata will be stored
+#[instrument(level = "trace", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn path_filestat_get_old<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: LookupFlags,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    buf: WasmPtr<Snapshot0Filestat, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let mut path_string = unsafe { get_input_str!(&memory, path, path_len) };
+
+    // Convert relative paths into absolute paths
+    if path_string.starts_with("./") {
+        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+    }
+    tracing::trace!(path = path_string.as_str());
+
+    let stat = wasi_try!(path_filestat_get_internal(
+        &memory,
+        state,
+        inodes,
+        fd,
+        flags,
+        &path_string
+    ));
+
+    let old_stat = Snapshot0Filestat {
+        st_dev: stat.st_dev,
+        st_ino: stat.st_ino,
+        st_filetype: stat.st_filetype,
+        st_nlink: stat.st_nlink as u32,
+        st_size: stat.st_size,
+        st_atim: stat.st_atim,
+        st_mtim: stat.st_mtim,
+        st_ctim: stat.st_ctim,
+    };
+    wasi_try_mem!(buf.deref(&memory).write(old_stat));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs
new file mode 100644
index 0000000..c471374
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_filestat_set_times.rs
@@ -0,0 +1,126 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_filestat_set_times()`
+/// Update time metadata on a file or directory
+/// Inputs:
+/// - `Fd fd`
+///     The directory relative to which the path is resolved
+/// - `LookupFlags flags`
+///     Flags to control how the path is understood
+/// - `const char *path`
+///     String containing the file path
+/// - `u32 path_len`
+///     The length of the `path` string
+/// - `Timestamp st_atim`
+///     The timestamp that the last accessed time attribute is set to
+/// -  `Timestamp st_mtim`
+///     The timestamp that the last modified time attribute is set to
+/// - `Fstflags fst_flags`
+///     A bitmask controlling which attributes are set
+#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty, %st_atim, %st_mtim), ret)]
+pub fn path_filestat_set_times<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: LookupFlags,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    st_atim: Timestamp,
+    st_mtim: Timestamp,
+    fst_flags: Fstflags,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path_string.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_string.starts_with("./") {
+        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+        trace!(
+            %path_string
+        );
+    }
+
+    wasi_try_ok!(path_filestat_set_times_internal(
+        &mut ctx,
+        fd,
+        flags,
+        &path_string,
+        st_atim,
+        st_mtim,
+        fst_flags
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_set_times(
+            &mut ctx,
+            fd,
+            flags,
+            path_string,
+            st_atim,
+            st_mtim,
+            fst_flags,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save file set times event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn path_filestat_set_times_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    flags: LookupFlags,
+    path: &str,
+    st_atim: Timestamp,
+    st_mtim: Timestamp,
+    fst_flags: Fstflags,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let fd_entry = state.fs.get_fd(fd)?;
+    let fd_inode = fd_entry.inode;
+    if !fd_entry.rights.contains(Rights::PATH_FILESTAT_SET_TIMES) {
+        return Err(Errno::Access);
+    }
+    if (fst_flags.contains(Fstflags::SET_ATIM) && fst_flags.contains(Fstflags::SET_ATIM_NOW))
+        || (fst_flags.contains(Fstflags::SET_MTIM) && fst_flags.contains(Fstflags::SET_MTIM_NOW))
+    {
+        return Err(Errno::Inval);
+    }
+
+    let file_inode =
+        state
+            .fs
+            .get_inode_at_path(inodes, fd, path, flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0)?;
+    let stat = {
+        let guard = file_inode.read();
+        state.fs.get_stat_for_kind(guard.deref())?
+    };
+
+    if fst_flags.contains(Fstflags::SET_ATIM) || fst_flags.contains(Fstflags::SET_ATIM_NOW) {
+        let time_to_set = if fst_flags.contains(Fstflags::SET_ATIM) {
+            st_atim
+        } else {
+            get_current_time_in_nanos()?
+        };
+        fd_inode.stat.write().unwrap().st_atim = time_to_set;
+    }
+    if fst_flags.contains(Fstflags::SET_MTIM) || fst_flags.contains(Fstflags::SET_MTIM_NOW) {
+        let time_to_set = if fst_flags.contains(Fstflags::SET_MTIM) {
+            st_mtim
+        } else {
+            get_current_time_in_nanos()?
+        };
+        fd_inode.stat.write().unwrap().st_mtim = time_to_set;
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_link.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_link.rs
new file mode 100644
index 0000000..9b0388d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_link.rs
@@ -0,0 +1,139 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_link()`
+/// Create a hard link
+/// Inputs:
+/// - `Fd old_fd`
+///     The directory relative to which the `old_path` is
+/// - `LookupFlags old_flags`
+///     Flags to control how `old_path` is understood
+/// - `const char *old_path`
+///     String containing the old file path
+/// - `u32 old_path_len`
+///     Length of the `old_path` string
+/// - `Fd new_fd`
+///     The directory relative to which the `new_path` is
+/// - `const char *new_path`
+///     String containing the new file path
+/// - `u32 old_path_len`
+///     Length of the `new_path` string
+#[instrument(level = "debug", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty, follow_symlinks = false), ret)]
+pub fn path_link<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    old_fd: WasiFd,
+    old_flags: LookupFlags,
+    old_path: WasmPtr<u8, M>,
+    old_path_len: M::Offset,
+    new_fd: WasiFd,
+    new_path: WasmPtr<u8, M>,
+    new_path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    if old_flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0 {
+        Span::current().record("follow_symlinks", true);
+    }
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let mut old_path_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
+    Span::current().record("old_path", old_path_str.as_str());
+    let mut new_path_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
+    Span::current().record("new_path", new_path_str.as_str());
+
+    wasi_try_ok!(path_link_internal(
+        &mut ctx,
+        old_fd,
+        old_flags,
+        &old_path_str,
+        new_fd,
+        &new_path_str
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_link(
+            &mut ctx,
+            old_fd,
+            old_flags,
+            old_path_str,
+            new_fd,
+            new_path_str,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save path hard link event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn path_link_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    old_fd: WasiFd,
+    old_flags: LookupFlags,
+    old_path: &str,
+    new_fd: WasiFd,
+    new_path: &str,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let source_fd = state.fs.get_fd(old_fd)?;
+    let target_fd = state.fs.get_fd(new_fd)?;
+
+    if !source_fd.rights.contains(Rights::PATH_LINK_SOURCE)
+        || !target_fd.rights.contains(Rights::PATH_LINK_TARGET)
+    {
+        return Err(Errno::Access);
+    }
+
+    // Convert relative paths into absolute paths
+    let old_path_str = ctx
+        .data()
+        .state
+        .fs
+        .relative_path_to_absolute(old_path.to_string());
+    let new_path_str = ctx
+        .data()
+        .state
+        .fs
+        .relative_path_to_absolute(new_path.to_string());
+
+    let source_inode = state.fs.get_inode_at_path(
+        inodes,
+        old_fd,
+        &old_path_str,
+        old_flags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
+    )?;
+    let target_path_arg = std::path::PathBuf::from(&new_path_str);
+    let (target_parent_inode, new_entry_name) =
+        state
+            .fs
+            .get_parent_inode_at_path(inodes, new_fd, &target_path_arg, false)?;
+
+    if source_inode.stat.write().unwrap().st_nlink == Linkcount::max_value() {
+        return Err(Errno::Mlink);
+    }
+    {
+        let mut guard = target_parent_inode.write();
+        match guard.deref_mut() {
+            Kind::Dir { entries, .. } => {
+                if entries.contains_key(&new_entry_name) {
+                    return Err(Errno::Exist);
+                }
+                entries.insert(new_entry_name, source_inode.clone());
+            }
+            Kind::Root { .. } => return Err(Errno::Inval),
+            Kind::File { .. }
+            | Kind::Symlink { .. }
+            | Kind::Buffer { .. }
+            | Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Err(Errno::Notdir),
+        }
+    }
+    source_inode.stat.write().unwrap().st_nlink += 1;
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_open.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_open.rs
new file mode 100644
index 0000000..5852834
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_open.rs
@@ -0,0 +1,383 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_open()`
+/// Open file located at the given path
+/// Inputs:
+/// - `Fd dirfd`
+///     The fd corresponding to the directory that the file is in
+/// - `LookupFlags dirflags`
+///     Flags specifying how the path will be resolved
+/// - `char *path`
+///     The path of the file or directory to open
+/// - `u32 path_len`
+///     The length of the `path` string
+/// - `Oflags o_flags`
+///     How the file will be opened
+/// - `Rights fs_rights_base`
+///     The rights of the created file descriptor
+/// - `Rights fs_rightsinheriting`
+///     The rights of file descriptors derived from the created file descriptor
+/// - `Fdflags fs_flags`
+///     The flags of the file descriptor
+/// Output:
+/// - `Fd* fd`
+///     The new file descriptor
+/// Possible Errors:
+/// - `Errno::Access`, `Errno::Badf`, `Errno::Fault`, `Errno::Fbig?`, `Errno::Inval`, `Errno::Io`, `Errno::Loop`, `Errno::Mfile`, `Errno::Nametoolong?`, `Errno::Nfile`, `Errno::Noent`, `Errno::Notdir`, `Errno::Rofs`, and `Errno::Notcapable`
+#[instrument(level = "debug", skip_all, fields(%dirfd, path = field::Empty, follow_symlinks = field::Empty, ret_fd = field::Empty), ret)]
+pub fn path_open<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    dirfd: WasiFd,
+    dirflags: LookupFlags,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    o_flags: Oflags,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+    fs_flags: Fdflags,
+    fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    if dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0 {
+        Span::current().record("follow_symlinks", true);
+    }
+    let env = ctx.data();
+    let (memory, mut state, mut inodes) =
+        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    /* TODO: find actual upper bound on name size (also this is a path, not a name :think-fish:) */
+    let path_len64: u64 = path_len.into();
+    if path_len64 > 1024u64 * 1024u64 {
+        return Ok(Errno::Nametoolong);
+    }
+
+    // o_flags:
+    // - __WASI_O_CREAT (create if it does not exist)
+    // - __WASI_O_DIRECTORY (fail if not dir)
+    // - __WASI_O_EXCL (fail if file exists)
+    // - __WASI_O_TRUNC (truncate size to 0)
+
+    let mut path_string = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path_string.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_string.starts_with("./") {
+        path_string = ctx.data().state.fs.relative_path_to_absolute(path_string);
+        trace!(
+            %path_string
+        );
+    }
+
+    let out_fd = wasi_try_ok!(path_open_internal(
+        &mut ctx,
+        dirfd,
+        dirflags,
+        &path_string,
+        o_flags,
+        fs_rights_base,
+        fs_rights_inheriting,
+        fs_flags,
+    )?);
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_open(
+            &mut ctx,
+            out_fd,
+            dirfd,
+            dirflags,
+            path_string,
+            o_flags,
+            fs_rights_base,
+            fs_rights_inheriting,
+            fs_flags,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save unlink event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, mut state, mut inodes) =
+        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    Span::current().record("ret_fd", out_fd);
+
+    let fd_ref = fd.deref(&memory);
+    wasi_try_mem_ok!(fd_ref.write(out_fd));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn path_open_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    dirfd: WasiFd,
+    dirflags: LookupFlags,
+    path: &str,
+    o_flags: Oflags,
+    fs_rights_base: Rights,
+    fs_rights_inheriting: Rights,
+    fs_flags: Fdflags,
+) -> Result<Result<WasiFd, Errno>, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, mut inodes) =
+        unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let path_arg = std::path::PathBuf::from(&path);
+    let maybe_inode = state.fs.get_inode_at_path(
+        inodes,
+        dirfd,
+        path,
+        dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0,
+    );
+
+    let working_dir = wasi_try_ok_ok!(state.fs.get_fd(dirfd));
+    let working_dir_rights_inheriting = working_dir.rights_inheriting;
+
+    // ASSUMPTION: open rights apply recursively
+    if !working_dir.rights.contains(Rights::PATH_OPEN) {
+        return Ok(Err(Errno::Access));
+    }
+
+    let mut open_flags = 0;
+    // TODO: traverse rights of dirs properly
+    // COMMENTED OUT: WASI isn't giving appropriate rights here when opening
+    //              TODO: look into this; file a bug report if this is a bug
+    //
+    // Maximum rights: should be the working dir rights
+    // Minimum rights: whatever rights are provided
+    let adjusted_rights = /*fs_rights_base &*/ working_dir_rights_inheriting;
+    let mut open_options = state.fs_new_open_options();
+
+    let target_rights = match maybe_inode {
+        Ok(_) => {
+            let write_permission = adjusted_rights.contains(Rights::FD_WRITE);
+
+            // append, truncate, and create all require the permission to write
+            let (append_permission, truncate_permission, create_permission) = if write_permission {
+                (
+                    fs_flags.contains(Fdflags::APPEND),
+                    o_flags.contains(Oflags::TRUNC),
+                    o_flags.contains(Oflags::CREATE),
+                )
+            } else {
+                (false, false, false)
+            };
+
+            virtual_fs::OpenOptionsConfig {
+                read: fs_rights_base.contains(Rights::FD_READ),
+                write: write_permission,
+                create_new: create_permission && o_flags.contains(Oflags::EXCL),
+                create: create_permission,
+                append: append_permission,
+                truncate: truncate_permission,
+            }
+        }
+        Err(_) => virtual_fs::OpenOptionsConfig {
+            append: fs_flags.contains(Fdflags::APPEND),
+            write: fs_rights_base.contains(Rights::FD_WRITE),
+            read: fs_rights_base.contains(Rights::FD_READ),
+            create_new: o_flags.contains(Oflags::CREATE) && o_flags.contains(Oflags::EXCL),
+            create: o_flags.contains(Oflags::CREATE),
+            truncate: o_flags.contains(Oflags::TRUNC),
+        },
+    };
+
+    let parent_rights = virtual_fs::OpenOptionsConfig {
+        read: working_dir.rights.contains(Rights::FD_READ),
+        write: working_dir.rights.contains(Rights::FD_WRITE),
+        // The parent is a directory, which is why these options
+        // aren't inherited from the parent (append / truncate doesn't work on directories)
+        create_new: true,
+        create: true,
+        append: true,
+        truncate: true,
+    };
+
+    let minimum_rights = target_rights.minimum_rights(&parent_rights);
+
+    open_options.options(minimum_rights.clone());
+
+    let inode = if let Ok(inode) = maybe_inode {
+        // Happy path, we found the file we're trying to open
+        let processing_inode = inode.clone();
+        let mut guard = processing_inode.write();
+
+        let deref_mut = guard.deref_mut();
+        match deref_mut {
+            Kind::File {
+                ref mut handle,
+                path,
+                fd,
+                ..
+            } => {
+                if let Some(special_fd) = fd {
+                    // short circuit if we're dealing with a special file
+                    assert!(handle.is_some());
+                    return Ok(Ok(*special_fd));
+                }
+                if o_flags.contains(Oflags::DIRECTORY) {
+                    return Ok(Err(Errno::Notdir));
+                }
+                if o_flags.contains(Oflags::EXCL) {
+                    return Ok(Err(Errno::Exist));
+                }
+
+                let open_options = open_options
+                    .write(minimum_rights.write)
+                    .create(minimum_rights.create)
+                    .append(minimum_rights.append)
+                    .truncate(minimum_rights.truncate);
+
+                if minimum_rights.read {
+                    open_flags |= Fd::READ;
+                }
+                if minimum_rights.write {
+                    open_flags |= Fd::WRITE;
+                }
+                if minimum_rights.create {
+                    open_flags |= Fd::CREATE;
+                }
+                if minimum_rights.truncate {
+                    open_flags |= Fd::TRUNCATE;
+                }
+                *handle = Some(Arc::new(std::sync::RwLock::new(wasi_try_ok_ok!(
+                    open_options.open(&path).map_err(fs_error_into_wasi_err)
+                ))));
+
+                if let Some(handle) = handle {
+                    let handle = handle.read().unwrap();
+                    if let Some(fd) = handle.get_special_fd() {
+                        // We clone the file descriptor so that when its closed
+                        // nothing bad happens
+                        let dup_fd = wasi_try_ok_ok!(state.fs.clone_fd(fd));
+                        trace!(
+                            %dup_fd
+                        );
+
+                        // some special files will return a constant FD rather than
+                        // actually open the file (/dev/stdin, /dev/stdout, /dev/stderr)
+                        return Ok(Ok(dup_fd));
+                    }
+                }
+            }
+            Kind::Buffer { .. } => unimplemented!("wasi::path_open for Buffer type files"),
+            Kind::Root { .. } => {
+                if !o_flags.contains(Oflags::DIRECTORY) {
+                    return Ok(Err(Errno::Notcapable));
+                }
+            }
+            Kind::Dir { .. }
+            | Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => {}
+            Kind::Symlink {
+                base_po_dir,
+                path_to_symlink,
+                relative_path,
+            } => {
+                // I think this should return an error (because symlinks should be resolved away by the path traversal)
+                // TODO: investigate this
+                unimplemented!("SYMLINKS IN PATH_OPEN");
+            }
+        }
+        inode
+    } else {
+        // less-happy path, we have to try to create the file
+        if o_flags.contains(Oflags::CREATE) {
+            if o_flags.contains(Oflags::DIRECTORY) {
+                return Ok(Err(Errno::Notdir));
+            }
+            // strip end file name
+
+            let (parent_inode, new_entity_name) =
+                wasi_try_ok_ok!(state.fs.get_parent_inode_at_path(
+                    inodes,
+                    dirfd,
+                    &path_arg,
+                    dirflags & __WASI_LOOKUP_SYMLINK_FOLLOW != 0
+                ));
+            let new_file_host_path = {
+                let guard = parent_inode.read();
+                match guard.deref() {
+                    Kind::Dir { path, .. } => {
+                        let mut new_path = path.clone();
+                        new_path.push(&new_entity_name);
+                        new_path
+                    }
+                    Kind::Root { .. } => {
+                        let mut new_path = std::path::PathBuf::new();
+                        new_path.push(&new_entity_name);
+                        new_path
+                    }
+                    _ => return Ok(Err(Errno::Inval)),
+                }
+            };
+            // once we got the data we need from the parent, we lookup the host file
+            // todo: extra check that opening with write access is okay
+            let handle = {
+                let open_options = open_options
+                    .read(minimum_rights.read)
+                    .append(minimum_rights.append)
+                    .write(minimum_rights.write)
+                    .create_new(minimum_rights.create_new);
+
+                if minimum_rights.read {
+                    open_flags |= Fd::READ;
+                }
+                if minimum_rights.write {
+                    open_flags |= Fd::WRITE;
+                }
+                if minimum_rights.create_new {
+                    open_flags |= Fd::CREATE;
+                }
+                if minimum_rights.truncate {
+                    open_flags |= Fd::TRUNCATE;
+                }
+
+                Some(wasi_try_ok_ok!(open_options
+                    .open(&new_file_host_path)
+                    .map_err(|e| { fs_error_into_wasi_err(e) })))
+            };
+
+            let new_inode = {
+                let kind = Kind::File {
+                    handle: handle.map(|a| Arc::new(std::sync::RwLock::new(a))),
+                    path: new_file_host_path,
+                    fd: None,
+                };
+                wasi_try_ok_ok!(state
+                    .fs
+                    .create_inode(inodes, kind, false, new_entity_name.clone()))
+            };
+
+            {
+                let mut guard = parent_inode.write();
+                if let Kind::Dir {
+                    ref mut entries, ..
+                } = guard.deref_mut()
+                {
+                    entries.insert(new_entity_name, new_inode.clone());
+                }
+            }
+
+            new_inode
+        } else {
+            return Ok(Err(maybe_inode.unwrap_err()));
+        }
+    };
+
+    // TODO: check and reduce these
+    // TODO: ensure a mutable fd to root can never be opened
+    let out_fd = wasi_try_ok_ok!(state.fs.create_fd(
+        adjusted_rights,
+        fs_rights_inheriting,
+        fs_flags,
+        open_flags,
+        inode
+    ));
+
+    Ok(Ok(out_fd))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_readlink.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_readlink.rs
new file mode 100644
index 0000000..e835890
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_readlink.rs
@@ -0,0 +1,74 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_readlink()`
+/// Read the value of a symlink
+/// Inputs:
+/// - `Fd dir_fd`
+///     The base directory from which `path` is understood
+/// - `const char *path`
+///     Pointer to UTF-8 bytes that make up the path to the symlink
+/// - `u32 path_len`
+///     The number of bytes to read from `path`
+/// - `u32 buf_len`
+///     Space available pointed to by `buf`
+/// Outputs:
+/// - `char *buf`
+///     Pointer to characters containing the path that the symlink points to
+/// - `u32 buf_used`
+///     The number of bytes written to `buf`
+#[instrument(level = "debug", skip_all, fields(%dir_fd, path = field::Empty), ret)]
+pub fn path_readlink<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    dir_fd: WasiFd,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+    buf: WasmPtr<u8, M>,
+    buf_len: M::Offset,
+    buf_used: WasmPtr<M::Offset, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let base_dir = wasi_try!(state.fs.get_fd(dir_fd));
+    if !base_dir.rights.contains(Rights::PATH_READLINK) {
+        return Errno::Access;
+    }
+    let mut path_str = unsafe { get_input_str!(&memory, path, path_len) };
+    Span::current().record("path", path_str.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_str.starts_with("./") {
+        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
+        trace!(
+            %path_str
+        );
+    }
+
+    let inode = wasi_try!(state.fs.get_inode_at_path(inodes, dir_fd, &path_str, false));
+
+    {
+        let guard = inode.read();
+        if let Kind::Symlink { relative_path, .. } = guard.deref() {
+            let rel_path_str = relative_path.to_string_lossy();
+            let buf_len: u64 = buf_len.into();
+            let bytes = rel_path_str.bytes();
+            if bytes.len() as u64 >= buf_len {
+                return Errno::Overflow;
+            }
+            let bytes: Vec<_> = bytes.collect();
+
+            let out = wasi_try_mem!(buf.slice(&memory, wasi_try!(to_offset::<M>(bytes.len()))));
+            wasi_try_mem!(out.write_slice(&bytes));
+            // should we null terminate this?
+
+            let bytes_len: M::Offset =
+                wasi_try!(bytes.len().try_into().map_err(|_| Errno::Overflow));
+            wasi_try_mem!(buf_used.deref(&memory).write(bytes_len));
+        } else {
+            return Errno::Inval;
+        }
+    }
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_remove_directory.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
new file mode 100644
index 0000000..d6ac9e6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_remove_directory.rs
@@ -0,0 +1,105 @@
+use super::*;
+use crate::syscalls::*;
+
+/// Returns Errno::Notemtpy if directory is not empty
+#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn path_remove_directory<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Errno {
+    // TODO check if fd is a dir, ensure it's within sandbox, etc.
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let base_dir = wasi_try!(state.fs.get_fd(fd));
+    let mut path_str = unsafe { get_input_str!(&memory, path, path_len) };
+    Span::current().record("path", path_str.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_str.starts_with("./") {
+        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
+        trace!(
+            %path_str
+        );
+    }
+
+    wasi_try!(path_remove_directory_internal(&mut ctx, fd, &path_str));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        wasi_try!(
+            JournalEffector::save_path_remove_directory(&mut ctx, fd, path_str).map_err(|err| {
+                tracing::error!("failed to save remove directory event - {}", err);
+                Errno::Fault
+            })
+        )
+    }
+
+    Errno::Success
+}
+
+pub(crate) fn path_remove_directory_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: &str,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let inode = state.fs.get_inode_at_path(inodes, fd, path, false)?;
+    let (parent_inode, childs_name) =
+        state
+            .fs
+            .get_parent_inode_at_path(inodes, fd, std::path::Path::new(&path), false)?;
+
+    let host_path_to_remove = {
+        let guard = inode.read();
+        match guard.deref() {
+            Kind::Dir { entries, path, .. } => {
+                if !entries.is_empty() || state.fs_read_dir(path)?.count() != 0 {
+                    return Err(Errno::Notempty);
+                }
+                path.clone()
+            }
+            Kind::Root { .. } => return Err(Errno::Access),
+            _ => return Err(Errno::Notdir),
+        }
+    };
+
+    {
+        let mut guard = parent_inode.write();
+        match guard.deref_mut() {
+            Kind::Dir {
+                ref mut entries, ..
+            } => {
+                let removed_inode = entries.remove(&childs_name).ok_or(Errno::Inval)?;
+
+                // TODO: make this a debug assert in the future
+                assert!(inode.ino() == removed_inode.ino());
+            }
+            Kind::Root { .. } => return Err(Errno::Access),
+            _ => unreachable!(
+                "Internal logic error in wasi::path_remove_directory, parent is not a directory"
+            ),
+        }
+    }
+
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    if let Err(err) = state.fs_remove_dir(host_path_to_remove) {
+        // reinsert to prevent FS from being in bad state
+        let mut guard = parent_inode.write();
+        if let Kind::Dir {
+            ref mut entries, ..
+        } = guard.deref_mut()
+        {
+            entries.insert(childs_name, inode);
+        }
+        return Err(err);
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_rename.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_rename.rs
new file mode 100644
index 0000000..147c8f2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_rename.rs
@@ -0,0 +1,216 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_rename()`
+/// Rename a file or directory
+/// Inputs:
+/// - `Fd old_fd`
+///     The base directory for `old_path`
+/// - `const char* old_path`
+///     Pointer to UTF8 bytes, the file to be renamed
+/// - `u32 old_path_len`
+///     The number of bytes to read from `old_path`
+/// - `Fd new_fd`
+///     The base directory for `new_path`
+/// - `const char* new_path`
+///     Pointer to UTF8 bytes, the new file name
+/// - `u32 new_path_len`
+///     The number of bytes to read from `new_path`
+#[instrument(level = "debug", skip_all, fields(%old_fd, %new_fd, old_path = field::Empty, new_path = field::Empty), ret)]
+pub fn path_rename<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    old_fd: WasiFd,
+    old_path: WasmPtr<u8, M>,
+    old_path_len: M::Offset,
+    new_fd: WasiFd,
+    new_path: WasmPtr<u8, M>,
+    new_path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let mut source_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
+    Span::current().record("old_path", source_str.as_str());
+    source_str = ctx.data().state.fs.relative_path_to_absolute(source_str);
+    let mut target_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
+    Span::current().record("new_path", target_str.as_str());
+    target_str = ctx.data().state.fs.relative_path_to_absolute(target_str);
+
+    let ret = path_rename_internal(&mut ctx, old_fd, &source_str, new_fd, &target_str)?;
+    let env = ctx.data();
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        if env.enable_journal {
+            JournalEffector::save_path_rename(&mut ctx, old_fd, source_str, new_fd, target_str)
+                .map_err(|err| {
+                    tracing::error!("failed to save path rename event - {}", err);
+                    WasiError::Exit(ExitCode::Errno(Errno::Fault))
+                })?;
+        }
+    }
+    Ok(ret)
+}
+
+pub fn path_rename_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    source_fd: WasiFd,
+    source_path: &str,
+    target_fd: WasiFd,
+    target_path: &str,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    {
+        let source_fd = wasi_try_ok!(state.fs.get_fd(source_fd));
+        if !source_fd.rights.contains(Rights::PATH_RENAME_SOURCE) {
+            return Ok(Errno::Access);
+        }
+        let target_fd = wasi_try_ok!(state.fs.get_fd(target_fd));
+        if !target_fd.rights.contains(Rights::PATH_RENAME_TARGET) {
+            return Ok(Errno::Access);
+        }
+    }
+
+    // this is to be sure the source file is fetch from filesystem if needed
+    wasi_try_ok!(state
+        .fs
+        .get_inode_at_path(inodes, source_fd, source_path, true));
+    // Create the destination inode if the file exists.
+    let _ = state
+        .fs
+        .get_inode_at_path(inodes, target_fd, target_path, true);
+    let (source_parent_inode, source_entry_name) = wasi_try_ok!(state.fs.get_parent_inode_at_path(
+        inodes,
+        source_fd,
+        Path::new(source_path),
+        true
+    ));
+    let (target_parent_inode, target_entry_name) = wasi_try_ok!(state.fs.get_parent_inode_at_path(
+        inodes,
+        target_fd,
+        Path::new(target_path),
+        true
+    ));
+    let mut need_create = true;
+    let host_adjusted_target_path = {
+        let guard = target_parent_inode.read();
+        match guard.deref() {
+            Kind::Dir { entries, path, .. } => {
+                if entries.contains_key(&target_entry_name) {
+                    need_create = false;
+                }
+                let mut out_path = path.clone();
+                out_path.push(std::path::Path::new(&target_entry_name));
+                out_path
+            }
+            Kind::Root { .. } => return Ok(Errno::Notcapable),
+            Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Ok(Errno::Inval),
+            Kind::Symlink { .. } | Kind::File { .. } | Kind::Buffer { .. } => {
+                debug!("fatal internal logic error: parent of inode is not a directory");
+                return Ok(Errno::Inval);
+            }
+        }
+    };
+
+    let source_entry = {
+        let mut guard = source_parent_inode.write();
+        match guard.deref_mut() {
+            Kind::Dir { entries, .. } => {
+                wasi_try_ok!(entries.remove(&source_entry_name).ok_or(Errno::Noent))
+            }
+            Kind::Root { .. } => return Ok(Errno::Notcapable),
+            Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => {
+                return Ok(Errno::Inval);
+            }
+            Kind::Symlink { .. } | Kind::File { .. } | Kind::Buffer { .. } => {
+                debug!("fatal internal logic error: parent of inode is not a directory");
+                return Ok(Errno::Inval);
+            }
+        }
+    };
+
+    {
+        let mut guard = source_entry.write();
+        match guard.deref_mut() {
+            Kind::File { ref path, .. } => {
+                let result = {
+                    let path_clone = path.clone();
+                    drop(guard);
+                    let state = state;
+                    let host_adjusted_target_path = host_adjusted_target_path.clone();
+                    __asyncify_light(env, None, async move {
+                        state
+                            .fs_rename(path_clone, &host_adjusted_target_path)
+                            .await
+                    })?
+                };
+                // if the above operation failed we have to revert the previous change and then fail
+                if let Err(e) = result {
+                    let mut guard = source_parent_inode.write();
+                    if let Kind::Dir { entries, .. } = guard.deref_mut() {
+                        entries.insert(source_entry_name, source_entry);
+                        return Ok(e);
+                    }
+                } else {
+                    {
+                        let mut guard = source_entry.write();
+                        if let Kind::File { ref mut path, .. } = guard.deref_mut() {
+                            *path = host_adjusted_target_path;
+                        } else {
+                            unreachable!()
+                        }
+                    }
+                }
+            }
+            Kind::Dir { ref path, .. } => {
+                let cloned_path = path.clone();
+                let res = {
+                    let state = state;
+                    let host_adjusted_target_path = host_adjusted_target_path.clone();
+                    __asyncify_light(env, None, async move {
+                        state
+                            .fs_rename(cloned_path, &host_adjusted_target_path)
+                            .await
+                    })?
+                };
+                if let Err(e) = res {
+                    return Ok(e);
+                }
+                {
+                    drop(guard);
+                    let mut guard = source_entry.write();
+                    if let Kind::Dir { path, .. } = guard.deref_mut() {
+                        *path = host_adjusted_target_path;
+                    }
+                }
+            }
+            Kind::Buffer { .. } => {}
+            Kind::Symlink { .. } => {}
+            Kind::Socket { .. } => {}
+            Kind::Pipe { .. } => {}
+            Kind::Epoll { .. } => {}
+            Kind::EventNotifications { .. } => {}
+            Kind::Root { .. } => unreachable!("The root can not be moved"),
+        }
+    }
+
+    if need_create {
+        let mut guard = target_parent_inode.write();
+        if let Kind::Dir { entries, .. } = guard.deref_mut() {
+            let result = entries.insert(target_entry_name, source_entry);
+            assert!(
+                result.is_none(),
+                "fatal error: race condition on filesystem detected or internal logic error"
+            );
+        }
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_symlink.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_symlink.rs
new file mode 100644
index 0000000..66a4598
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_symlink.rs
@@ -0,0 +1,137 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_symlink()`
+/// Create a symlink
+/// Inputs:
+/// - `const char *old_path`
+///     Array of UTF-8 bytes representing the source path
+/// - `u32 old_path_len`
+///     The number of bytes to read from `old_path`
+/// - `Fd fd`
+///     The base directory from which the paths are understood
+/// - `const char *new_path`
+///     Array of UTF-8 bytes representing the target path
+/// - `u32 new_path_len`
+///     The number of bytes to read from `new_path`
+#[instrument(level = "debug", skip_all, fields(%fd, old_path = field::Empty, new_path = field::Empty), ret)]
+pub fn path_symlink<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    old_path: WasmPtr<u8, M>,
+    old_path_len: M::Offset,
+    fd: WasiFd,
+    new_path: WasmPtr<u8, M>,
+    new_path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let mut old_path_str = unsafe { get_input_str_ok!(&memory, old_path, old_path_len) };
+    Span::current().record("old_path", old_path_str.as_str());
+    let mut new_path_str = unsafe { get_input_str_ok!(&memory, new_path, new_path_len) };
+    Span::current().record("new_path", new_path_str.as_str());
+    old_path_str = ctx.data().state.fs.relative_path_to_absolute(old_path_str);
+    new_path_str = ctx.data().state.fs.relative_path_to_absolute(new_path_str);
+
+    wasi_try_ok!(path_symlink_internal(
+        &mut ctx,
+        &old_path_str,
+        fd,
+        &new_path_str
+    ));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_path_symlink(&mut ctx, old_path_str, fd, new_path_str).map_err(
+            |err| {
+                tracing::error!("failed to save path symbolic link event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub fn path_symlink_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    old_path: &str,
+    fd: WasiFd,
+    new_path: &str,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let base_fd = state.fs.get_fd(fd)?;
+    if !base_fd.rights.contains(Rights::PATH_SYMLINK) {
+        return Err(Errno::Access);
+    }
+
+    // get the depth of the parent + 1 (UNDER INVESTIGATION HMMMMMMMM THINK FISH ^ THINK FISH)
+    let old_path_path = std::path::Path::new(old_path);
+    let (source_inode, _) = state
+        .fs
+        .get_parent_inode_at_path(inodes, fd, old_path_path, true)?;
+    let depth = state.fs.path_depth_from_fd(fd, source_inode);
+
+    // depth == -1 means folder is not relative. See issue #3233.
+    let depth = match depth {
+        Ok(depth) => depth as i32 - 1,
+        Err(_) => -1,
+    };
+
+    let new_path_path = std::path::Path::new(new_path);
+    let (target_parent_inode, entry_name) =
+        state
+            .fs
+            .get_parent_inode_at_path(inodes, fd, new_path_path, true)?;
+
+    // short circuit if anything is wrong, before we create an inode
+    {
+        let guard = target_parent_inode.read();
+        match guard.deref() {
+            Kind::Dir { entries, .. } => {
+                if entries.contains_key(&entry_name) {
+                    return Err(Errno::Exist);
+                }
+            }
+            Kind::Root { .. } => return Err(Errno::Notcapable),
+            Kind::Socket { .. }
+            | Kind::Pipe { .. }
+            | Kind::EventNotifications { .. }
+            | Kind::Epoll { .. } => return Err(Errno::Inval),
+            Kind::File { .. } | Kind::Symlink { .. } | Kind::Buffer { .. } => {
+                unreachable!("get_parent_inode_at_path returned something other than a Dir or Root")
+            }
+        }
+    }
+
+    let mut source_path = std::path::Path::new(old_path);
+    let mut relative_path = std::path::PathBuf::new();
+    for _ in 0..depth {
+        relative_path.push("..");
+    }
+    relative_path.push(source_path);
+
+    let kind = Kind::Symlink {
+        base_po_dir: fd,
+        path_to_symlink: std::path::PathBuf::from(new_path),
+        relative_path,
+    };
+    let new_inode =
+        state
+            .fs
+            .create_inode_with_default_stat(inodes, kind, false, entry_name.clone().into());
+
+    {
+        let mut guard = target_parent_inode.write();
+        if let Kind::Dir {
+            ref mut entries, ..
+        } = guard.deref_mut()
+        {
+            entries.insert(entry_name, new_inode);
+        }
+    }
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_unlink_file.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
new file mode 100644
index 0000000..c79a581
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/path_unlink_file.rs
@@ -0,0 +1,120 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `path_unlink_file()`
+/// Unlink a file, deleting if the number of hardlinks is 1
+/// Inputs:
+/// - `Fd fd`
+///     The base file descriptor from which the path is understood
+/// - `const char *path`
+///     Array of UTF-8 bytes representing the path
+/// - `u32 path_len`
+///     The number of bytes in the `path` array
+#[instrument(level = "debug", skip_all, fields(%fd, path = field::Empty), ret)]
+pub fn path_unlink_file<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let base_dir = wasi_try_ok!(state.fs.get_fd(fd));
+    if !base_dir.rights.contains(Rights::PATH_UNLINK_FILE) {
+        return Ok(Errno::Access);
+    }
+    let mut path_str = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path_str.as_str());
+
+    // Convert relative paths into absolute paths
+    if path_str.starts_with("./") {
+        path_str = ctx.data().state.fs.relative_path_to_absolute(path_str);
+    }
+
+    let ret = path_unlink_file_internal(&mut ctx, fd, &path_str)?;
+    let env = ctx.data();
+
+    if ret == Errno::Success {
+        #[cfg(feature = "journal")]
+        if env.enable_journal {
+            wasi_try_ok!(
+                JournalEffector::save_path_unlink(&mut ctx, fd, path_str).map_err(|err| {
+                    tracing::error!("failed to save unlink event - {}", err);
+                    Errno::Fault
+                })
+            )
+        }
+    }
+
+    Ok(ret)
+}
+
+pub(crate) fn path_unlink_file_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    path: &str,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let inode = wasi_try_ok!(state.fs.get_inode_at_path(inodes, fd, path, false));
+    let (parent_inode, childs_name) = wasi_try_ok!(state.fs.get_parent_inode_at_path(
+        inodes,
+        fd,
+        std::path::Path::new(path),
+        false
+    ));
+
+    let removed_inode = {
+        let mut guard = parent_inode.write();
+        match guard.deref_mut() {
+            Kind::Dir {
+                ref mut entries, ..
+            } => {
+                let removed_inode = wasi_try_ok!(entries.remove(&childs_name).ok_or(Errno::Inval));
+                // TODO: make this a debug assert in the future
+                assert!(inode.ino() == removed_inode.ino());
+                debug_assert!(inode.stat.read().unwrap().st_nlink > 0);
+                removed_inode
+            }
+            Kind::Root { .. } => return Ok(Errno::Access),
+            _ => unreachable!(
+                "Internal logic error in wasi::path_unlink_file, parent is not a directory"
+            ),
+        }
+    };
+
+    let st_nlink = {
+        let mut guard = removed_inode.stat.write().unwrap();
+        guard.st_nlink -= 1;
+        guard.st_nlink
+    };
+    if st_nlink == 0 {
+        {
+            let mut guard = removed_inode.read();
+            match guard.deref() {
+                Kind::File { handle, path, .. } => {
+                    if let Some(h) = handle {
+                        let mut h = h.write().unwrap();
+                        wasi_try_ok!(h.unlink().map_err(fs_error_into_wasi_err));
+                    } else {
+                        // File is closed
+                        // problem with the abstraction, we can't call unlink because there's no handle
+                        // drop mutable borrow on `path`
+                        let path = path.clone();
+                        drop(guard);
+                        wasi_try_ok!(state.fs_remove_file(path));
+                    }
+                }
+                Kind::Dir { .. } | Kind::Root { .. } => return Ok(Errno::Isdir),
+                Kind::Symlink { .. } => {
+                    // TODO: actually delete real symlinks and do nothing for virtual symlinks
+                }
+                _ => unimplemented!("wasi::path_unlink_file for Buffer"),
+            }
+        }
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/poll_oneoff.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
new file mode 100644
index 0000000..d9d6e0f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/poll_oneoff.rs
@@ -0,0 +1,452 @@
+use serde::{Deserialize, Serialize};
+use wasmer_wasix_types::wasi::{SubscriptionClock, Userdata};
+
+use super::*;
+use crate::{
+    fs::{InodeValFilePollGuard, InodeValFilePollGuardJoin},
+    state::PollEventSet,
+    syscalls::*,
+    WasiInodes,
+};
+
+/// An event that occurred.
+#[derive(Serialize, Deserialize)]
+pub enum EventResultType {
+    Clock(u8),
+    Fd(EventFdReadwrite),
+}
+
+/// An event that occurred.
+#[derive(Serialize, Deserialize)]
+pub struct EventResult {
+    /// User-provided value that got attached to `subscription::userdata`.
+    pub userdata: Userdata,
+    /// If non-zero, an error that occurred while processing the subscription request.
+    pub error: Errno,
+    /// Type of event that was triggered
+    pub type_: Eventtype,
+    /// The type of the event that occurred, and the contents of the event
+    pub inner: EventResultType,
+}
+impl EventResult {
+    pub fn into_event(self) -> Event {
+        Event {
+            userdata: self.userdata,
+            error: self.error,
+            type_: self.type_,
+            u: match self.inner {
+                EventResultType::Clock(id) => EventUnion { clock: id },
+                EventResultType::Fd(fd) => EventUnion { fd_readwrite: fd },
+            },
+        }
+    }
+}
+
+/// ### `poll_oneoff()`
+/// Concurrently poll for a set of events
+/// Inputs:
+/// - `const __wasi_subscription_t *in`
+///     The events to subscribe to
+/// - `__wasi_event_t *out`
+///     The events that have occured
+/// - `u32 nsubscriptions`
+///     The number of subscriptions and the number of events
+/// Output:
+/// - `u32 nevents`
+///     The number of events seen
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
+pub fn poll_oneoff<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    in_: WasmPtr<Subscription, M>,
+    out_: WasmPtr<Event, M>,
+    nsubscriptions: M::Offset,
+    nevents: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    ctx.data_mut().poll_seed += 1;
+    let mut env = ctx.data();
+    let mut memory = unsafe { env.memory_view(&ctx) };
+
+    let subscription_array = wasi_try_mem_ok!(in_.slice(&memory, nsubscriptions));
+    let mut subscriptions = Vec::with_capacity(subscription_array.len() as usize);
+    for n in 0..subscription_array.len() {
+        let n = (n + env.poll_seed) % subscription_array.len();
+        let sub = subscription_array.index(n);
+        let s = wasi_try_mem_ok!(sub.read());
+        subscriptions.push((None, PollEventSet::default(), s));
+    }
+
+    // We clear the number of events
+    wasi_try_mem_ok!(nevents.write(&memory, M::ZERO));
+
+    // Function to invoke once the poll is finished
+    let process_events = |ctx: &FunctionEnvMut<'_, WasiEnv>, triggered_events: Vec<Event>| {
+        let mut env = ctx.data();
+        let mut memory = unsafe { env.memory_view(&ctx) };
+
+        // Process all the events that were triggered
+        let mut events_seen: u32 = 0;
+        let event_array = wasi_try_mem!(out_.slice(&memory, nsubscriptions));
+        for event in triggered_events {
+            wasi_try_mem!(event_array.index(events_seen as u64).write(event));
+            events_seen += 1;
+        }
+        let events_seen: M::Offset = wasi_try!(events_seen.try_into().map_err(|_| Errno::Overflow));
+        let out_ptr = nevents.deref(&memory);
+        wasi_try_mem!(out_ptr.write(events_seen));
+        Errno::Success
+    };
+
+    // Poll and receive all the events that triggered
+    poll_oneoff_internal::<M, _>(ctx, subscriptions, process_events)
+}
+
+struct PollBatch {
+    pid: WasiProcessId,
+    tid: WasiThreadId,
+    evts: Vec<Event>,
+    joins: Vec<InodeValFilePollGuardJoin>,
+}
+impl PollBatch {
+    fn new(pid: WasiProcessId, tid: WasiThreadId, fds: Vec<InodeValFilePollGuard>) -> Self {
+        Self {
+            pid,
+            tid,
+            evts: Vec::new(),
+            joins: fds
+                .into_iter()
+                .map(InodeValFilePollGuardJoin::new)
+                .collect(),
+        }
+    }
+}
+impl Future for PollBatch {
+    type Output = Result<Vec<EventResult>, Errno>;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let pid = self.pid;
+        let tid = self.tid;
+        let mut done = false;
+
+        let mut evts = Vec::new();
+        for mut join in self.joins.iter_mut() {
+            let fd = join.fd();
+            let peb = join.peb();
+            let mut guard = Pin::new(join);
+            match guard.poll(cx) {
+                Poll::Pending => {}
+                Poll::Ready(e) => {
+                    for (evt, readiness) in e {
+                        tracing::trace!(
+                            fd,
+                            readiness = ?readiness,
+                            userdata = evt.userdata,
+                            ty = evt.type_ as u8,
+                            peb,
+                            "triggered"
+                        );
+                        evts.push(evt);
+                    }
+                }
+            }
+        }
+
+        if !evts.is_empty() {
+            return Poll::Ready(Ok(evts));
+        }
+
+        Poll::Pending
+    }
+}
+
+pub(crate) fn poll_fd_guard(
+    state: &Arc<WasiState>,
+    peb: PollEventSet,
+    fd: WasiFd,
+    s: Subscription,
+) -> Result<InodeValFilePollGuard, Errno> {
+    Ok(match fd {
+        __WASI_STDERR_FILENO => WasiInodes::stderr(&state.fs.fd_map)
+            .map(|g| g.into_poll_guard(fd, peb, s))
+            .map_err(fs_error_into_wasi_err)?,
+        __WASI_STDOUT_FILENO => WasiInodes::stdout(&state.fs.fd_map)
+            .map(|g| g.into_poll_guard(fd, peb, s))
+            .map_err(fs_error_into_wasi_err)?,
+        _ => {
+            let fd_entry = state.fs.get_fd(fd)?;
+            if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+                return Err(Errno::Access);
+            }
+            let inode = fd_entry.inode;
+
+            {
+                let guard = inode.read();
+                if let Some(guard) =
+                    crate::fs::InodeValFilePollGuard::new(fd, peb, s, guard.deref())
+                {
+                    guard
+                } else {
+                    return Err(Errno::Badf);
+                }
+            }
+        }
+    })
+}
+
+/// ### `poll_oneoff()`
+/// Concurrently poll for a set of events
+/// Inputs:
+/// - `const __wasi_subscription_t *in`
+///     The events to subscribe to
+/// - `__wasi_event_t *out`
+///     The events that have occured
+/// - `u32 nsubscriptions`
+///     The number of subscriptions and the number of events
+/// Output:
+/// - `u32 nevents`
+///     The number of events seen
+pub(crate) fn poll_oneoff_internal<'a, M: MemorySize, After>(
+    mut ctx: FunctionEnvMut<'a, WasiEnv>,
+    mut subs: Vec<(Option<WasiFd>, PollEventSet, Subscription)>,
+    process_events: After,
+) -> Result<Errno, WasiError>
+where
+    After: FnOnce(&FunctionEnvMut<'a, WasiEnv>, Vec<Event>) -> Errno,
+{
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let pid = ctx.data().pid();
+    let tid = ctx.data().tid();
+
+    // Determine if we are in silent polling mode
+    let mut env = ctx.data();
+    let state = ctx.data().state.deref();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    // These are used when we capture what clocks (timeouts) are being
+    // subscribed too
+    let clock_cnt = subs
+        .iter()
+        .filter(|a| a.2.type_ == Eventtype::Clock)
+        .count();
+    let mut clock_subs: Vec<(SubscriptionClock, u64)> = Vec::with_capacity(subs.len());
+    let mut time_to_sleep = Duration::MAX;
+
+    // First we extract all the subscriptions into an array so that they
+    // can be processed
+    let mut env = ctx.data();
+    let state = ctx.data().state.deref();
+    let mut memory = unsafe { env.memory_view(&ctx) };
+    for (fd, peb, s) in subs.iter_mut() {
+        let fd = match s.type_ {
+            Eventtype::FdRead => {
+                let file_descriptor = unsafe { s.data.fd_readwrite.file_descriptor };
+                match file_descriptor {
+                    __WASI_STDIN_FILENO | __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO => (),
+                    fd => {
+                        let fd_entry = match state.fs.get_fd(fd) {
+                            Ok(a) => a,
+                            Err(err) => return Ok(err),
+                        };
+                        if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+                            return Ok(Errno::Access);
+                        }
+                    }
+                }
+                *fd = Some(file_descriptor);
+                *peb |= (PollEvent::PollIn as PollEventSet);
+                file_descriptor
+            }
+            Eventtype::FdWrite => {
+                let file_descriptor = unsafe { s.data.fd_readwrite.file_descriptor };
+                match file_descriptor {
+                    __WASI_STDIN_FILENO | __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO => (),
+                    fd => {
+                        let fd_entry = match state.fs.get_fd(fd) {
+                            Ok(a) => a,
+                            Err(err) => return Ok(err),
+                        };
+                        if !fd_entry.rights.contains(Rights::POLL_FD_READWRITE) {
+                            return Ok(Errno::Access);
+                        }
+                    }
+                }
+                *fd = Some(file_descriptor);
+                *peb |= (PollEvent::PollOut as PollEventSet);
+                file_descriptor
+            }
+            Eventtype::Clock => {
+                let clock_info = unsafe { s.data.clock };
+                if clock_info.clock_id == Clockid::Realtime
+                    || clock_info.clock_id == Clockid::Monotonic
+                {
+                    // Ignore duplicates
+                    if clock_subs
+                        .iter()
+                        .any(|c| c.0.clock_id == clock_info.clock_id && c.1 == s.userdata)
+                    {
+                        continue;
+                    }
+
+                    // If the timeout duration is zero then this is an immediate check rather than
+                    // a sleep itself
+                    if clock_info.timeout == 0 {
+                        time_to_sleep = Duration::MAX;
+                    } else if clock_info.timeout == 1 {
+                        time_to_sleep = Duration::ZERO;
+                        clock_subs.push((clock_info, s.userdata));
+                    } else {
+                        time_to_sleep = Duration::from_nanos(clock_info.timeout);
+                        clock_subs.push((clock_info, s.userdata));
+                    }
+                    continue;
+                } else {
+                    error!("polling not implemented for these clocks yet");
+                    return Ok(Errno::Inval);
+                }
+            }
+            Eventtype::Unknown => {
+                continue;
+            }
+        };
+    }
+
+    let mut events_seen: u32 = 0;
+
+    let batch = {
+        // Build the batch of things we are going to poll
+        let state = ctx.data().state.clone();
+        let tasks = ctx.data().tasks().clone();
+        let mut guards = {
+            // We start by building a list of files we are going to poll
+            // and open a read lock on them all
+            let mut fd_guards = Vec::with_capacity(subs.len());
+
+            #[allow(clippy::significant_drop_in_scrutinee)]
+            for (fd, peb, s) in subs {
+                if let Some(fd) = fd {
+                    let wasi_file_ref = wasi_try_ok!(poll_fd_guard(&state, peb, fd, s));
+                    fd_guards.push(wasi_file_ref);
+                }
+            }
+
+            if fd_guards.len() > 10 {
+                let small_list: Vec<_> = fd_guards.iter().take(10).collect();
+                tracing::Span::current().record("fd_guards", format!("{:?}...", small_list));
+            } else {
+                tracing::Span::current().record("fd_guards", format!("{:?}", fd_guards));
+            }
+
+            fd_guards
+        };
+
+        // Block polling the file descriptors
+        PollBatch::new(pid, tid, guards)
+    };
+
+    // If the time is infinite then we omit the time_to_sleep parameter
+    let timeout = match time_to_sleep {
+        Duration::ZERO => {
+            Span::current().record("timeout_ns", "nonblocking");
+            Some(Duration::ZERO)
+        }
+        Duration::MAX => {
+            Span::current().record("timeout_ns", "infinite");
+            None
+        }
+        time => {
+            Span::current().record("timeout_ns", time.as_millis());
+            Some(time)
+        }
+    };
+    let tasks = env.tasks().clone();
+    let timeout = async move {
+        if let Some(timeout) = timeout {
+            tasks.sleep_now(timeout).await;
+        } else {
+            InfiniteSleep::default().await
+        }
+    };
+
+    // Build the trigger using the timeout
+    let trigger = async move {
+        tokio::select! {
+            res = batch => res,
+            _ = timeout => Err(Errno::Timedout)
+        }
+    };
+
+    // We replace the process events callback with another callback
+    // which will interpret the error codes
+    let process_events = {
+        let clock_subs = clock_subs.clone();
+        |ctx: &FunctionEnvMut<'a, WasiEnv>, events: Result<Vec<Event>, Errno>| {
+            // Process the result
+            match events {
+                Ok(evts) => {
+                    // If its a timeout then return an event for it
+                    if evts.len() == 1 {
+                        Span::current().record("seen", &format!("{:?}", evts.first().unwrap()));
+                    } else {
+                        Span::current().record("seen", &format!("trigger_cnt=({})", evts.len()));
+                    }
+
+                    // Process the events
+                    process_events(ctx, evts)
+                }
+                Err(Errno::Timedout) => {
+                    // The timeout has triggered so lets add that event
+                    if clock_subs.is_empty() {
+                        tracing::warn!("triggered_timeout (without any clock subscriptions)",);
+                    }
+                    let mut evts = Vec::new();
+                    for (clock_info, userdata) in clock_subs {
+                        let evt = Event {
+                            userdata,
+                            error: Errno::Success,
+                            type_: Eventtype::Clock,
+                            u: EventUnion { clock: 0 },
+                        };
+                        Span::current().record(
+                            "seen",
+                            &format!(
+                                "clock(id={},userdata={})",
+                                clock_info.clock_id as u32, evt.userdata
+                            ),
+                        );
+                        evts.push(evt);
+                    }
+                    process_events(ctx, evts)
+                }
+                // If nonblocking the Errno::Again needs to be turned into an empty list
+                Err(Errno::Again) => process_events(ctx, Default::default()),
+                // Otherwise process the error
+                Err(err) => {
+                    tracing::warn!("failed to poll during deep sleep - {}", err);
+                    err
+                }
+            }
+        }
+    };
+
+    // If we are rewound then its time to process them
+    if let Some(events) = unsafe { handle_rewind::<M, Result<Vec<EventResult>, Errno>>(&mut ctx) } {
+        let events = events.map(|events| events.into_iter().map(EventResult::into_event).collect());
+        process_events(&ctx, events);
+        return Ok(Errno::Success);
+    }
+
+    // We use asyncify with a deep sleep to wait on new IO events
+    let res = __asyncify_with_deep_sleep::<M, Result<Vec<EventResult>, Errno>, _>(
+        ctx,
+        Box::pin(trigger),
+    )?;
+    if let AsyncifyAction::Finish(mut ctx, events) = res {
+        let events = events.map(|events| events.into_iter().map(EventResult::into_event).collect());
+        process_events(&ctx, events);
+    }
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_exit.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_exit.rs
new file mode 100644
index 0000000..58b83d5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_exit.rs
@@ -0,0 +1,58 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_exit()`
+/// Terminate the process normally. An exit code of 0 indicates successful
+/// termination of the program. The meanings of other values is dependent on
+/// the environment.
+/// Inputs:
+/// - `ExitCode`
+///   Exit code to return to the operating system
+#[instrument(level = "debug", skip_all)]
+pub fn proc_exit<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    code: ExitCode,
+) -> Result<(), WasiError> {
+    debug!(%code);
+
+    // If we are in a vfork we need to return to the point we left off
+    if let Some(mut vfork) = ctx.data_mut().vfork.take() {
+        // Restore the WasiEnv to the point when we vforked
+        vfork.env.swap_inner(ctx.data_mut());
+        std::mem::swap(vfork.env.as_mut(), ctx.data_mut());
+        let mut child_env = *vfork.env;
+        child_env.owned_handles.push(vfork.handle);
+
+        // Terminate the child process
+        child_env.process.terminate(code);
+
+        // Jump back to the vfork point and current on execution
+        let child_pid = child_env.process.pid();
+        let memory_stack = vfork.memory_stack.freeze();
+        let rewind_stack = vfork.rewind_stack.freeze();
+        let store_data = vfork.store_data;
+        unwind::<M, _>(ctx, move |mut ctx, _, _| {
+            // Now rewind the previous stack and carry on from where we did the vfork
+            match rewind::<M, _>(
+                ctx,
+                memory_stack,
+                rewind_stack,
+                store_data,
+                ForkResult {
+                    pid: child_pid.raw() as Pid,
+                    ret: Errno::Success,
+                },
+            ) {
+                Errno::Success => OnCalledAction::InvokeAgain,
+                err => {
+                    warn!("fork failed - could not rewind the stack - errno={}", err);
+                    OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                }
+            }
+        })?;
+        return Ok(());
+    }
+
+    // Otherwise just exit
+    Err(WasiError::Exit(code))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_raise.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_raise.rs
new file mode 100644
index 0000000..6cd8cdf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/proc_raise.rs
@@ -0,0 +1,43 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_raise()`
+/// Send a signal to the process of the calling thread.
+/// Note: This is similar to `raise` in POSIX.
+/// Inputs:
+/// - `Signal`
+///   Signal to be raised for this process
+#[instrument(level = "debug", skip_all, fields(sig), ret)]
+pub fn proc_raise(mut ctx: FunctionEnvMut<'_, WasiEnv>, sig: Signal) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    env.process.signal_process(sig);
+
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    Ok(Errno::Success)
+}
+
+/// ### `proc_raise()`
+/// Send a signal to the process of the calling thread.
+/// Note: This is similar to `raise` in POSIX.
+/// Inputs:
+/// - `Signal`
+///   Signal to be raised for this process
+pub fn proc_raise_interval(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sig: Signal,
+    interval: Timestamp,
+    repeat: Bool,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let interval = match interval {
+        0 => None,
+        a => Some(Duration::from_millis(a)),
+    };
+    let repeat = matches!(repeat, Bool::True);
+    env.process.signal_interval(sig, interval, repeat);
+
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/random_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/random_get.rs
new file mode 100644
index 0000000..f8c3153
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/random_get.rs
@@ -0,0 +1,30 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `random_get()`
+/// Fill buffer with high-quality random data.  This function may be slow and block
+/// Inputs:
+/// - `void *buf`
+///     A pointer to a buffer where the random bytes will be written
+/// - `size_t buf_len`
+///     The number of bytes that will be written
+#[instrument(level = "trace", skip_all, fields(%buf_len), ret)]
+pub fn random_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    buf: WasmPtr<u8, M>,
+    buf_len: M::Offset,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let buf_len64: u64 = buf_len.into();
+    let mut u8_buffer = vec![0; buf_len64 as usize];
+    let res = getrandom::getrandom(&mut u8_buffer);
+    match res {
+        Ok(()) => {
+            let buf = wasi_try_mem!(buf.slice(&memory, buf_len));
+            wasi_try_mem!(buf.write_slice(&u8_buffer));
+            Errno::Success
+        }
+        Err(_) => Errno::Io,
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/thread_spawn.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/thread_spawn.rs
new file mode 100644
index 0000000..be8e9de
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasi/thread_spawn.rs
@@ -0,0 +1,28 @@
+use super::*;
+use crate::syscalls::*;
+
+use wasmer::Memory;
+use wasmer_wasix_types::wasi::ThreadStart;
+
+/// ### `thread_spawn()`
+/// Creates a new thread by spawning that shares the same
+/// memory address space, file handles and main event loops.
+///
+/// ## Parameters
+///
+/// * `start_ptr` - Pointer to the structure that describes the thread to be launched
+///
+/// ## Return
+///
+/// Returns the thread index of the newly created thread
+/// (indices always start from the same value as `pid` and increments in steps)
+#[instrument(level = "debug", skip_all, ret)]
+pub fn thread_spawn<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    start_ptr: WasmPtr<ThreadStart<M>, M>,
+) -> i32 {
+    thread_spawn_internal_from_wasi(&mut ctx, start_ptr)
+        .map(|tid| tid as i32)
+        .map_err(|errno| errno as i32)
+        .unwrap_or_else(|err| -err)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/callback_signal.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/callback_signal.rs
new file mode 100644
index 0000000..e5dcb80
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/callback_signal.rs
@@ -0,0 +1,46 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `callback_signal()`
+/// Sets the callback to invoke signals
+///
+/// ### Parameters
+///
+/// * `name` - Name of the function that will be invoked
+#[instrument(level = "trace", skip_all, fields(name = field::Empty, funct_is_some = field::Empty), ret)]
+pub fn callback_signal<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: WasmPtr<u8, M>,
+    name_len: M::Offset,
+) -> Result<(), WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let name = match name.read_utf8_string(&memory, name_len) {
+        Ok(a) => a,
+        Err(err) => {
+            warn!(
+                "failed to access memory that holds the name of the signal callback: {}",
+                err
+            );
+            return Ok(());
+        }
+    };
+    Span::current().record("name", name.as_str());
+
+    let funct = unsafe { env.inner() }
+        .instance
+        .exports
+        .get_typed_function(&ctx, &name)
+        .ok();
+    Span::current().record("funct_is_some", funct.is_some());
+
+    {
+        let mut inner = ctx.data_mut().try_inner_mut().unwrap();
+        inner.signal = funct;
+        inner.signal_set = true;
+    }
+
+    let _ = unsafe { WasiEnv::process_signals_and_exit(&mut ctx)? };
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/chdir.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/chdir.rs
new file mode 100644
index 0000000..beb4b93
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/chdir.rs
@@ -0,0 +1,42 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `chdir()`
+/// Sets the current working directory
+#[instrument(level = "debug", skip_all, fields(name = field::Empty), ret)]
+pub fn chdir<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    path: WasmPtr<u8, M>,
+    path_len: M::Offset,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(&ctx, 0) };
+    let path = unsafe { get_input_str_ok!(&memory, path, path_len) };
+    Span::current().record("path", path.as_str());
+
+    wasi_try_ok!(chdir_internal(&mut ctx, &path,));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_chdir(&mut ctx, path).map_err(|err| {
+            tracing::error!("failed to chdir event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub fn chdir_internal(ctx: &mut FunctionEnvMut<'_, WasiEnv>, path: &str) -> Result<(), Errno> {
+    let env = ctx.data();
+    let (memory, mut state) = unsafe { env.get_memory_and_wasi_state(ctx, 0) };
+
+    // Check if the directory exists
+    if state.fs.root_fs.read_dir(Path::new(path)).is_err() {
+        return Err(Errno::Noent);
+    }
+
+    state.fs.set_current_dir(path);
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_create.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_create.rs
new file mode 100644
index 0000000..cf9d942
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_create.rs
@@ -0,0 +1,68 @@
+use serde::{Deserialize, Serialize};
+use wasmer_wasix_types::wasi::{SubscriptionClock, Userdata};
+
+use super::*;
+use crate::{
+    fs::{InodeValFilePollGuard, InodeValFilePollGuardJoin},
+    state::PollEventSet,
+    syscalls::*,
+    WasiInodes,
+};
+use std::sync::Mutex as StdMutex;
+use tokio::sync::Mutex as AsyncMutex;
+
+/// ### `epoll_create()`
+/// Create an epoll interest list
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
+pub fn epoll_create<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ret_fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    let fd = wasi_try_ok!(epoll_create_internal(&mut ctx)?);
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_epoll_create(&mut ctx, fd).map_err(|err| {
+            tracing::error!("failed to save epoll_create event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Span::current().record("fd", fd);
+
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    wasi_try_mem_ok!(ret_fd.write(&memory, fd));
+
+    Ok(Errno::Success)
+}
+
+pub fn epoll_create_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<WasiFd, Errno>, WasiError> {
+    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let (tx, rx) = tokio::sync::watch::channel(Default::default());
+
+    let inode = state.fs.create_inode_with_default_stat(
+        inodes,
+        Kind::Epoll {
+            subscriptions: Arc::new(StdMutex::new(HashMap::new())),
+            tx: Arc::new(tx),
+            rx: Arc::new(AsyncMutex::new(rx)),
+        },
+        false,
+        "pipe".to_string().into(),
+    );
+
+    let rights = Rights::POLL_FD_READWRITE | Rights::FD_FDSTAT_SET_FLAGS;
+    let fd = wasi_try_ok_ok!(state
+        .fs
+        .create_fd(rights, rights, Fdflags::empty(), 0, inode));
+
+    Ok(Ok(fd))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_ctl.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
new file mode 100644
index 0000000..06ff541
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_ctl.rs
@@ -0,0 +1,306 @@
+use serde::{Deserialize, Serialize};
+use tokio::sync::{mpsc::UnboundedSender, watch};
+use virtual_mio::{InterestHandler, InterestType};
+use virtual_net::net_error_into_io_err;
+use wasmer_wasix_types::wasi::{
+    EpollCtl, EpollEvent, EpollEventCtl, EpollType, SubscriptionClock, SubscriptionUnion, Userdata,
+};
+
+use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+
+use futures::Future;
+
+use super::*;
+use crate::{
+    fs::{
+        EpollFd, EpollInterest, EpollJoinGuard, InodeValFilePollGuard, InodeValFilePollGuardJoin,
+        InodeValFilePollGuardMode, POLL_GUARD_MAX_RET,
+    },
+    state::PollEventSet,
+    syscalls::*,
+    WasiInodes,
+};
+
+/// ### `epoll_ctl()`
+/// Modifies an epoll interest list
+/// Output:
+/// - `Fd fd`
+///   The new file handle that is used to modify or wait on the interest list
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty, fd), ret)]
+pub fn epoll_ctl<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    epfd: WasiFd,
+    op: EpollCtl,
+    fd: WasiFd,
+    event_ref: WasmPtr<EpollEvent<M>, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+
+    let memory = unsafe { env.memory_view(&ctx) };
+    let event = if event_ref.offset() != M::ZERO {
+        Some(wasi_try_mem_ok!(event_ref.read(&memory)))
+    } else {
+        None
+    };
+
+    let event_ctl = event.map(|evt| EpollEventCtl {
+        events: evt.events,
+        ptr: evt.data.ptr.into(),
+        fd: evt.data.fd,
+        data1: evt.data.data1,
+        data2: evt.data.data2,
+    });
+
+    wasi_try_ok!(epoll_ctl_internal(
+        &mut ctx,
+        epfd,
+        op,
+        fd,
+        event_ctl.as_ref()
+    )?);
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_epoll_ctl(&mut ctx, epfd, op, fd, event_ctl).map_err(|err| {
+            tracing::error!("failed to save epoll_create event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn epoll_ctl_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    epfd: WasiFd,
+    op: EpollCtl,
+    fd: WasiFd,
+    event_ctl: Option<&EpollEventCtl>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let fd_entry = wasi_try_ok_ok!(env.state.fs.get_fd(epfd));
+
+    let tasks = env.tasks().clone();
+    let mut inode_guard = fd_entry.inode.read();
+    match inode_guard.deref() {
+        Kind::Epoll {
+            subscriptions, tx, ..
+        } => {
+            if let EpollCtl::Del | EpollCtl::Mod = op {
+                let mut guard = subscriptions.lock().unwrap();
+                guard.remove(&fd);
+
+                tracing::trace!(fd, "unregistering waker");
+            }
+            if let EpollCtl::Add | EpollCtl::Mod = op {
+                if let Some(event) = event_ctl {
+                    let epoll_fd = EpollFd {
+                        events: event.events,
+                        ptr: event.ptr,
+                        fd: event.fd,
+                        data1: event.data1,
+                        data2: event.data2,
+                    };
+
+                    // Output debug
+                    tracing::trace!(
+                        peb = ?event.events,
+                        ptr = ?event.ptr,
+                        data1 = event.data1,
+                        data2 = event.data2,
+                        fd = event.fd,
+                        "registering waker"
+                    );
+
+                    {
+                        // We have to register the subscription before we register the waker
+                        // as otherwise there is a race condition
+                        let mut guard = subscriptions.lock().unwrap();
+                        guard.insert(event.fd, (epoll_fd.clone(), Vec::new()));
+                    }
+
+                    // Now we register the epoll waker
+                    let tx = tx.clone();
+                    let mut fd_guards =
+                        wasi_try_ok_ok!(register_epoll_waker(&env.state, &epoll_fd, tx));
+
+                    // After the guards are created we need to attach them to the subscription
+                    let mut guard = subscriptions.lock().unwrap();
+                    if let Some(subs) = guard.get_mut(&event.fd) {
+                        subs.1.append(&mut fd_guards);
+                    }
+                }
+            }
+            Ok(Ok(()))
+        }
+        _ => Ok(Err(Errno::Inval)),
+    }
+}
+
+#[derive(Debug)]
+pub struct EpollJoinWaker {
+    fd: WasiFd,
+    readiness: EpollType,
+    tx: Arc<watch::Sender<EpollInterest>>,
+}
+impl EpollJoinWaker {
+    pub fn new(
+        fd: WasiFd,
+        readiness: EpollType,
+        tx: Arc<watch::Sender<EpollInterest>>,
+    ) -> Arc<Self> {
+        Arc::new(Self { fd, readiness, tx })
+    }
+
+    fn wake_now(&self) {
+        self.tx.send_modify(|i| {
+            i.interest.insert((self.fd, self.readiness));
+        });
+    }
+    pub fn as_waker(self: &Arc<Self>) -> Waker {
+        let s: *const Self = Arc::into_raw(Arc::clone(self));
+        let raw_waker = RawWaker::new(s as *const (), &VTABLE);
+        unsafe { Waker::from_raw(raw_waker) }
+    }
+}
+pub struct EpollHandler {
+    fd: WasiFd,
+    tx: Arc<watch::Sender<EpollInterest>>,
+}
+impl EpollHandler {
+    pub fn new(fd: WasiFd, tx: Arc<watch::Sender<EpollInterest>>) -> Box<Self> {
+        Box::new(Self { fd, tx })
+    }
+}
+impl InterestHandler for EpollHandler {
+    fn push_interest(&mut self, interest: InterestType) {
+        let readiness = match interest {
+            InterestType::Readable => EpollType::EPOLLIN,
+            InterestType::Writable => EpollType::EPOLLOUT,
+            InterestType::Closed => EpollType::EPOLLHUP,
+            InterestType::Error => EpollType::EPOLLERR,
+        };
+        self.tx.send_modify(|i| {
+            i.interest.insert((self.fd, readiness));
+        });
+    }
+
+    fn pop_interest(&mut self, interest: InterestType) -> bool {
+        let readiness = match interest {
+            InterestType::Readable => EpollType::EPOLLIN,
+            InterestType::Writable => EpollType::EPOLLOUT,
+            InterestType::Closed => EpollType::EPOLLHUP,
+            InterestType::Error => EpollType::EPOLLERR,
+        };
+        let mut ret = false;
+        self.tx.send_modify(move |i| {
+            ret = i.interest.iter().any(|(_, b)| *b == readiness);
+            i.interest.retain(|(_, b)| *b != readiness);
+        });
+        ret
+    }
+
+    fn has_interest(&self, interest: InterestType) -> bool {
+        let readiness = match interest {
+            InterestType::Readable => EpollType::EPOLLIN,
+            InterestType::Writable => EpollType::EPOLLOUT,
+            InterestType::Closed => EpollType::EPOLLHUP,
+            InterestType::Error => EpollType::EPOLLERR,
+        };
+        let mut ret = false;
+        self.tx.send_modify(move |i| {
+            ret = i.interest.iter().any(|(_, b)| *b == readiness);
+        });
+        ret
+    }
+}
+
+fn inline_waker_wake(s: &EpollJoinWaker) {
+    let waker_arc = unsafe { Arc::from_raw(s) };
+    waker_arc.wake_now();
+}
+
+fn inline_waker_clone(s: &EpollJoinWaker) -> RawWaker {
+    let arc = unsafe { Arc::from_raw(s) };
+    std::mem::forget(arc.clone());
+    RawWaker::new(Arc::into_raw(arc) as *const (), &VTABLE)
+}
+
+const VTABLE: RawWakerVTable = unsafe {
+    RawWakerVTable::new(
+        |s| inline_waker_clone(&*(s as *const EpollJoinWaker)), // clone
+        |s| inline_waker_wake(&*(s as *const EpollJoinWaker)),  // wake
+        |s| (*(s as *const EpollJoinWaker)).wake_now(), // wake by ref (don't decrease refcount)
+        |s| drop(Arc::from_raw(s as *const EpollJoinWaker)), // decrease refcount
+    )
+};
+
+pub(super) fn register_epoll_waker(
+    state: &Arc<WasiState>,
+    event: &EpollFd,
+    tx: Arc<watch::Sender<EpollInterest>>,
+) -> Result<Vec<EpollJoinGuard>, Errno> {
+    let mut type_ = Eventtype::FdRead;
+    let mut peb = PollEventBuilder::new();
+    if event.events.contains(EpollType::EPOLLOUT) {
+        type_ = Eventtype::FdWrite;
+        peb = peb.add(PollEvent::PollOut);
+    }
+    if event.events.contains(EpollType::EPOLLIN) {
+        type_ = Eventtype::FdRead;
+        peb = peb.add(PollEvent::PollIn);
+    }
+    if event.events.contains(EpollType::EPOLLERR) {
+        peb = peb.add(PollEvent::PollError);
+    }
+    if event.events.contains(EpollType::EPOLLHUP) | event.events.contains(EpollType::EPOLLRDHUP) {
+        peb = peb.add(PollEvent::PollHangUp);
+    }
+
+    // Create a dummy subscription
+    let s = Subscription {
+        userdata: event.data2,
+        type_,
+        data: SubscriptionUnion {
+            fd_readwrite: SubscriptionFsReadwrite {
+                file_descriptor: event.fd,
+            },
+        },
+    };
+
+    // Get guard object which we will register the waker against
+    let mut ret = Vec::new();
+    let fd_guard = poll_fd_guard(state, peb.build(), event.fd, s)?;
+    match &fd_guard.mode {
+        // Sockets now use epoll
+        InodeValFilePollGuardMode::Socket { inner, .. } => {
+            let handler = EpollHandler::new(event.fd, tx);
+
+            let mut inner = inner.protected.write().unwrap();
+            inner.set_handler(handler).map_err(net_error_into_io_err)?;
+            drop(inner);
+
+            ret.push(EpollJoinGuard::Handler { fd_guard })
+        }
+        _ => {
+            // Otherwise we fall back on the regular polling guard
+
+            // First we create the waker
+            let epoll_waker = EpollJoinWaker::new(event.fd, event.events, tx);
+            let waker = epoll_waker.as_waker();
+            let mut cx = Context::from_waker(&waker);
+
+            // Now we use the waker to trigger events
+            let mut join_guard = InodeValFilePollGuardJoin::new(fd_guard);
+            if Pin::new(&mut join_guard).poll(&mut cx).is_ready() {
+                waker.wake();
+            }
+            ret.push(EpollJoinGuard::Join {
+                join_guard,
+                epoll_waker,
+            });
+        }
+    }
+    Ok(ret)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_wait.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_wait.rs
new file mode 100644
index 0000000..e67675f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/epoll_wait.rs
@@ -0,0 +1,214 @@
+use serde::{Deserialize, Serialize};
+use wasmer_wasix_types::wasi::{
+    EpollCtl, EpollData, EpollEvent, EpollType, SubscriptionClock, Userdata,
+};
+
+use super::*;
+use crate::{
+    fs::{EpollFd, InodeValFilePollGuard, InodeValFilePollGuardJoin, POLL_GUARD_MAX_RET},
+    state::PollEventSet,
+    syscalls::*,
+    WasiInodes,
+};
+
+const TIMEOUT_FOREVER: u64 = u64::MAX;
+
+/// ### `epoll_wait()`
+/// Wait for an I/O event on an epoll file descriptor
+#[instrument(level = "trace", skip_all, fields(timeout_ms = field::Empty, fd_guards = field::Empty, seen = field::Empty), ret)]
+pub fn epoll_wait<'a, M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'a, WasiEnv>,
+    epfd: WasiFd,
+    events: WasmPtr<EpollEvent<M>, M>,
+    maxevents: i32,
+    timeout: Timestamp,
+    ret_nevents: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    if timeout == TIMEOUT_FOREVER {
+        tracing::trace!(maxevents, epfd, "waiting forever on wakers");
+    } else {
+        tracing::trace!(maxevents, epfd, timeout, "waiting on wakers");
+    }
+
+    let (rx, tx, subscriptions) = {
+        let fd_entry = wasi_try_ok!(ctx.data().state.fs.get_fd(epfd));
+        let mut inode_guard = fd_entry.inode.read();
+        match inode_guard.deref() {
+            Kind::Epoll {
+                rx,
+                tx,
+                subscriptions,
+                ..
+            } => (rx.clone(), tx.clone(), subscriptions.clone()),
+            _ => return Ok(Errno::Inval),
+        }
+    };
+
+    // We enter a controlled loop that will continuously poll and react to
+    // epoll events until something of interest needs to be returned to the
+    // caller or a timeout happens
+    let work = {
+        let state = ctx.data().state.clone();
+        async move {
+            let mut ret: Vec<(EpollFd, EpollType)> = Vec::new();
+
+            // Loop until some events of interest are returned
+            loop {
+                // We wait for our turn then read the next event from the
+                let mut rx = rx.lock().await;
+
+                // We first extract all the interest that has been registered
+                // and cycle through it
+                let mut removed = Vec::new();
+                let interest: Vec<_> = rx
+                    .borrow_and_update()
+                    .interest
+                    .clone()
+                    .into_iter()
+                    .collect();
+                {
+                    let mut guard = subscriptions.lock().unwrap();
+                    for (fd, readiness) in interest {
+                        removed.push((fd, readiness));
+
+                        // Get the data for this fd
+                        let (fd, joins) = match guard.get_mut(&fd) {
+                            Some(a) => a,
+                            None => {
+                                tracing::debug!(fd, readiness=?readiness, "orphaned interest");
+                                continue;
+                            }
+                        };
+
+                        // We have to renew any joins that have now been spent
+                        for join in joins {
+                            if join.is_spent() {
+                                join.renew();
+                            }
+                        }
+
+                        // Record the event
+                        ret.push((fd.clone(), readiness));
+                        if ret.len() + POLL_GUARD_MAX_RET >= (maxevents as usize) {
+                            break;
+                        }
+                    }
+                }
+
+                // Remove anything that was signaled
+                if !removed.is_empty() {
+                    // Now update the notification system
+                    tx.send_modify(|i| {
+                        for (fd, readiness) in removed {
+                            i.interest.remove(&(fd, readiness));
+                        }
+                    });
+                }
+
+                // If we have results then return them
+                if !ret.is_empty() {
+                    return Ok(ret);
+                }
+
+                // Otherwise we wait to be triggered again
+                rx.changed().await.ok();
+            }
+        }
+    };
+
+    // Build the trigger using the timeout
+    let trigger = {
+        let timeout = if timeout == TIMEOUT_FOREVER {
+            None
+        } else {
+            Some(ctx.data().tasks().sleep_now(Duration::from_nanos(timeout)))
+        };
+        async move {
+            if let Some(timeout) = timeout {
+                tokio::select! {
+                    res = work => res,
+                    _ = timeout => Err(Errno::Timedout)
+                }
+            } else {
+                work.await
+            }
+        }
+    };
+
+    // We replace the process events callback with another callback
+    // which will interpret the error codes
+    let process_events = {
+        let events_out = events;
+        move |ctx: &FunctionEnvMut<'a, WasiEnv>,
+              events: Result<Vec<(EpollFd, EpollType)>, Errno>| {
+            let env = ctx.data();
+            let memory = unsafe { env.memory_view(ctx) };
+
+            // Process the result
+            match events {
+                Ok(evts) => {
+                    let mut nevents = 0;
+
+                    let event_array = wasi_try_mem!(events_out.slice(
+                        &memory,
+                        wasi_try!(maxevents.try_into().map_err(|_| Errno::Overflow))
+                    ));
+                    for (event, readiness) in evts {
+                        tracing::trace!(fd = event.fd, readiness = ?readiness, "triggered");
+                        wasi_try_mem!(event_array.index(nevents as u64).write(EpollEvent {
+                            events: readiness,
+                            data: EpollData {
+                                ptr: wasi_try!(event.ptr.try_into().map_err(|_| Errno::Overflow)),
+                                fd: event.fd,
+                                data1: event.data1,
+                                data2: event.data2
+                            }
+                        }));
+                        nevents += 1;
+                        if nevents >= maxevents {
+                            break;
+                        }
+                    }
+                    tracing::trace!("{} events triggered", nevents);
+                    wasi_try_mem!(ret_nevents.write(
+                        &memory,
+                        wasi_try!(nevents.try_into().map_err(|_| Errno::Overflow))
+                    ));
+                    Errno::Success
+                }
+                Err(Errno::Timedout) => {
+                    // In a timeout scenario we return zero events
+                    wasi_try_mem!(ret_nevents.write(&memory, M::ZERO));
+                    Errno::Success
+                }
+                Err(err) => {
+                    tracing::warn!("failed to epoll during deep sleep - {}", err);
+                    err
+                }
+            }
+        }
+    };
+
+    // If we are rewound then its time to process them
+    if let Some(events) =
+        unsafe { handle_rewind::<M, Result<Vec<(EpollFd, EpollType)>, Errno>>(&mut ctx) }
+    {
+        return Ok(process_events(&ctx, events));
+    }
+
+    // We use asyncify with a deep sleep to wait on new IO events
+    let res = __asyncify_with_deep_sleep::<M, Result<Vec<(EpollFd, EpollType)>, Errno>, _>(
+        ctx,
+        Box::pin(trigger),
+    )?;
+    if let AsyncifyAction::Finish(mut ctx, events) = res {
+        Ok(process_events(&ctx, events))
+    } else {
+        Ok(Errno::Success)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/fd_pipe.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/fd_pipe.rs
new file mode 100644
index 0000000..7752053
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/fd_pipe.rs
@@ -0,0 +1,74 @@
+use virtual_fs::Pipe;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `fd_pipe()`
+/// Creates ta pipe that feeds data between two file handles
+/// Output:
+/// - `Fd`
+///     First file handle that represents one end of the pipe
+/// - `Fd`
+///     Second file handle that represents the other end of the pipe
+#[instrument(level = "trace", skip_all, fields(fd1 = field::Empty, fd2 = field::Empty), ret)]
+pub fn fd_pipe<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ro_fd1: WasmPtr<WasiFd, M>,
+    ro_fd2: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    let (fd1, fd2) = wasi_try_ok!(fd_pipe_internal(&mut ctx));
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_fd_pipe(&mut ctx, fd1, fd2).map_err(|err| {
+            tracing::error!("failed to save create pipe event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    Span::current().record("fd1", fd1).record("fd2", fd2);
+
+    wasi_try_mem_ok!(ro_fd1.write(&memory, fd1));
+    wasi_try_mem_ok!(ro_fd2.write(&memory, fd2));
+
+    Ok(Errno::Success)
+}
+
+pub fn fd_pipe_internal(ctx: &mut FunctionEnvMut<'_, WasiEnv>) -> Result<(WasiFd, WasiFd), Errno> {
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    let (pipe1, pipe2) = Pipe::channel();
+
+    let inode1 = state.fs.create_inode_with_default_stat(
+        inodes,
+        Kind::Pipe { pipe: pipe1 },
+        false,
+        "pipe".to_string().into(),
+    );
+    let inode2 = state.fs.create_inode_with_default_stat(
+        inodes,
+        Kind::Pipe { pipe: pipe2 },
+        false,
+        "pipe".to_string().into(),
+    );
+
+    let rights = Rights::FD_READ
+        | Rights::FD_WRITE
+        | Rights::FD_SYNC
+        | Rights::FD_DATASYNC
+        | Rights::POLL_FD_READWRITE
+        | Rights::SOCK_SEND
+        | Rights::FD_FDSTAT_SET_FLAGS;
+    let fd1 = state
+        .fs
+        .create_fd(rights, rights, Fdflags::empty(), 0, inode1)?;
+    let fd2 = state
+        .fs
+        .create_fd(rights, rights, Fdflags::empty(), 0, inode2)?;
+
+    Ok((fd1, fd2))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wait.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wait.rs
new file mode 100644
index 0000000..69b46f4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wait.rs
@@ -0,0 +1,176 @@
+use std::task::Waker;
+
+use super::*;
+use crate::syscalls::*;
+
+/// Poller returns true if its triggered and false if it times out
+struct FutexPoller {
+    state: Arc<WasiState>,
+    poller_idx: u64,
+    futex_idx: u64,
+    expected: u32,
+    timeout: Option<Pin<Box<dyn Future<Output = ()> + Send + Sync + 'static>>>,
+}
+impl Future for FutexPoller {
+    type Output = bool;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<bool> {
+        let mut guard = self.state.futexs.lock().unwrap();
+
+        // If the futex itself is no longer registered then it was likely
+        // woken by a wake call
+        let futex = match guard.futexes.get_mut(&self.futex_idx) {
+            Some(f) => f,
+            None => return Poll::Ready(true),
+        };
+        let waker = match futex.wakers.get_mut(&self.poller_idx) {
+            Some(w) => w,
+            None => return Poll::Ready(true),
+        };
+
+        // Register the waker
+        waker.replace(cx.waker().clone());
+
+        // Check for timeout
+        drop(guard);
+        if let Some(timeout) = self.timeout.as_mut() {
+            let timeout = timeout.as_mut();
+            if timeout.poll(cx).is_ready() {
+                self.timeout.take();
+                return Poll::Ready(false);
+            }
+        }
+
+        // We will now wait to be woken
+        Poll::Pending
+    }
+}
+impl Drop for FutexPoller {
+    fn drop(&mut self) {
+        let mut guard = self.state.futexs.lock().unwrap();
+
+        let mut should_remove = false;
+        if let Some(futex) = guard.futexes.get_mut(&self.futex_idx) {
+            if let Some(Some(waker)) = futex.wakers.remove(&self.poller_idx) {
+                waker.wake();
+            }
+            should_remove = futex.wakers.is_empty();
+        }
+        if should_remove {
+            guard.futexes.remove(&self.futex_idx);
+        }
+    }
+}
+
+/// Wait for a futex_wake operation to wake us.
+/// Returns with EINVAL if the futex doesn't hold the expected value.
+/// Returns false on timeout, and true in all other cases.
+///
+/// ## Parameters
+///
+/// * `futex` - Memory location that holds the value that will be checked
+/// * `expected` - Expected value that should be currently held at the memory location
+/// * `timeout` - Timeout should the futex not be triggered in the allocated time
+#[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, poller_idx = field::Empty, %expected, timeout = field::Empty, woken = field::Empty))]
+pub fn futex_wait<M: MemorySize + 'static>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    futex_ptr: WasmPtr<u32, M>,
+    expected: u32,
+    timeout: WasmPtr<OptionTimestamp, M>,
+    ret_woken: WasmPtr<Bool, M>,
+) -> Result<Errno, WasiError> {
+    futex_wait_internal(ctx, futex_ptr, expected, timeout, ret_woken)
+}
+
+pub(super) fn futex_wait_internal<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    futex_ptr: WasmPtr<u32, M>,
+    expected: u32,
+    timeout: WasmPtr<OptionTimestamp, M>,
+    ret_woken: WasmPtr<Bool, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    // If we were just restored then we were woken after a deep sleep
+    // and thus we repeat all the checks again, we do not immediately
+    // exit here as it could be the case that we were woken but the
+    // expected value does not match
+    if let Some(_woken) = unsafe { handle_rewind::<M, bool>(&mut ctx) } {
+        // fall through so the normal checks kick in, this will
+        // ensure that the expected value has changed before
+        // this syscall returns even if it was woken
+    }
+
+    // Determine the timeout
+    let mut env = ctx.data();
+    let timeout = {
+        let memory = unsafe { env.memory_view(&ctx) };
+        wasi_try_mem_ok!(timeout.read(&memory))
+    };
+    let timeout = match timeout.tag {
+        OptionTag::Some => Some(Duration::from_nanos(timeout.u)),
+        _ => None,
+    };
+    Span::current().record("timeout", &format!("{:?}", timeout));
+
+    let state = env.state.clone();
+    let futex_idx: u64 = wasi_try_ok!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    Span::current().record("futex_idx", futex_idx);
+
+    // We generate a new poller which also registers in the
+    // shared state futex lookup. When this object is dropped
+    // it will remove itself from the lookup. It can also be
+    // removed whenever the wake call is invoked (which could
+    // be before the poller is polled).
+    let poller = {
+        let mut guard = env.state.futexs.lock().unwrap();
+        guard.poller_seed += 1;
+        let poller_idx = guard.poller_seed;
+
+        // Create the timeout if one exists
+        let timeout = timeout.map(|timeout| env.tasks().sleep_now(timeout));
+
+        // We insert the futex before we check the condition variable to avoid
+        // certain race conditions
+        let futex = guard.futexes.entry(futex_idx).or_default();
+        futex.wakers.insert(poller_idx, Default::default());
+
+        Span::current().record("poller_idx", poller_idx);
+        FutexPoller {
+            state: env.state.clone(),
+            poller_idx,
+            futex_idx,
+            expected,
+            timeout,
+        }
+    };
+
+    // We check if the expected value has changed
+    let memory = unsafe { env.memory_view(&ctx) };
+    let val = wasi_try_mem_ok!(futex_ptr.read(&memory));
+    if val != expected {
+        // We have been triggered so do not go into a wait
+        wasi_try_mem_ok!(ret_woken.write(&memory, Bool::True));
+        return Ok(Errno::Success);
+    }
+
+    // We clear the woken flag (so if the poller fails to trigger
+    // then the value is not set) - the poller will set it to true
+    wasi_try_mem_ok!(ret_woken.write(&memory, Bool::False));
+
+    // We use asyncify on the poller and potentially go into deep sleep
+    tracing::trace!("wait on {futex_idx}");
+    let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, Box::pin(poller))?;
+    if let AsyncifyAction::Finish(ctx, res) = res {
+        let mut env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        if res {
+            wasi_try_mem_ok!(ret_woken.write(&memory, Bool::True));
+        } else {
+            wasi_try_mem_ok!(ret_woken.write(&memory, Bool::False));
+        }
+    }
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake.rs
new file mode 100644
index 0000000..88e5a7d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake.rs
@@ -0,0 +1,53 @@
+use super::*;
+use crate::syscalls::*;
+
+/// Wake up one thread that's blocked on futex_wait on this futex.
+/// Returns true if this actually woke up such a thread,
+/// or false if no thread was waiting on this futex.
+///
+/// ## Parameters
+///
+/// * `futex` - Memory location that holds a futex that others may be waiting on
+#[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, woken = field::Empty), ret)]
+pub fn futex_wake<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    futex_ptr: WasmPtr<u32, M>,
+    ret_woken: WasmPtr<Bool, M>,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let state = env.state.deref();
+
+    let pointer: u64 = wasi_try!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    Span::current().record("futex_idx", pointer);
+
+    let mut woken = false;
+    let woken = {
+        let mut guard = state.futexs.lock().unwrap();
+        if let Some(futex) = guard.futexes.get_mut(&pointer) {
+            let first = futex.wakers.keys().copied().next();
+            if let Some(id) = first {
+                if let Some(Some(w)) = futex.wakers.remove(&id) {
+                    w.wake();
+                }
+            }
+            if futex.wakers.is_empty() {
+                guard.futexes.remove(&pointer);
+            }
+            tracing::trace!("wake(hit) on {pointer}");
+            true
+        } else {
+            tracing::trace!("wake(miss) on {pointer}");
+            true
+        }
+    };
+    Span::current().record("woken", woken);
+
+    let woken = match woken {
+        false => Bool::False,
+        true => Bool::True,
+    };
+    wasi_try_mem!(ret_woken.write(&memory, woken));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake_all.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake_all.rs
new file mode 100644
index 0000000..432a4ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/futex_wake_all.rs
@@ -0,0 +1,46 @@
+use super::*;
+use crate::syscalls::*;
+
+/// Wake up all threads that are waiting on futex_wait on this futex.
+///
+/// ## Parameters
+///
+/// * `futex` - Memory location that holds a futex that others may be waiting on
+#[instrument(level = "trace", skip_all, fields(futex_idx = field::Empty, woken = field::Empty), ret)]
+pub fn futex_wake_all<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    futex_ptr: WasmPtr<u32, M>,
+    ret_woken: WasmPtr<Bool, M>,
+) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let state = env.state.deref();
+
+    let pointer: u64 = wasi_try!(futex_ptr.offset().try_into().map_err(|_| Errno::Overflow));
+    //Span::current().record("futex_idx", pointer);
+
+    let mut woken = false;
+    let woken = {
+        let mut guard = state.futexs.lock().unwrap();
+        if let Some(futex) = guard.futexes.remove(&pointer) {
+            for waker in futex.wakers {
+                if let Some(waker) = waker.1 {
+                    waker.wake();
+                }
+            }
+            tracing::trace!("wake_all (hit) on {pointer}");
+            true
+        } else {
+            tracing::trace!("wake_all (miss) on {pointer}");
+            true
+        }
+    };
+    //Span::current().record("woken", woken);
+
+    let woken = match woken {
+        false => Bool::False,
+        true => Bool::True,
+    };
+    wasi_try_mem!(ret_woken.write(&memory, woken));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/getcwd.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/getcwd.rs
new file mode 100644
index 0000000..2725022
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/getcwd.rs
@@ -0,0 +1,52 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `getcwd()`
+/// Returns the current working directory
+/// If the path exceeds the size of the buffer then this function
+/// will return ERANGE
+#[instrument(level = "debug", skip_all, fields(path = field::Empty, max_path_len = field::Empty), ret)]
+pub fn getcwd<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    path: WasmPtr<u8, M>,
+    path_len: WasmPtr<M::Offset, M>,
+) -> Errno {
+    let env = ctx.data();
+    let (memory, mut state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let (_, cur_dir) = wasi_try!(state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD,));
+    Span::current().record("path", cur_dir.as_str());
+
+    let max_path_len = wasi_try_mem!(path_len.read(&memory));
+    let max_path_len64: u64 = max_path_len.into();
+    let path_slice = match (path.is_null(), max_path_len64) {
+        (true, _) => None,
+        (_, 0) => None,
+        (_, _) => Some(wasi_try_mem!(path.slice(&memory, max_path_len))),
+    };
+    Span::current().record("max_path_len", max_path_len64);
+
+    let cur_dir = cur_dir.as_bytes();
+    wasi_try_mem!(path_len.write(&memory, wasi_try!(to_offset::<M>(cur_dir.len()))));
+    if cur_dir.len() as u64 > max_path_len64 {
+        return Errno::Range;
+    }
+
+    if let Some(path_slice) = path_slice {
+        let cur_dir = {
+            let mut u8_buffer = vec![0; max_path_len64 as usize];
+            let cur_dir_len = cur_dir.len();
+            if (cur_dir_len as u64) <= max_path_len64 {
+                u8_buffer[..cur_dir_len].clone_from_slice(cur_dir);
+            } else {
+                return Errno::Range;
+            }
+            u8_buffer
+        };
+
+        wasi_try_mem!(path_slice.write_slice(cur_dir.as_ref()));
+        Errno::Success
+    } else {
+        Errno::Inval
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/mod.rs
new file mode 100644
index 0000000..01b03aa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/mod.rs
@@ -0,0 +1,137 @@
+mod callback_signal;
+mod chdir;
+mod epoll_create;
+mod epoll_ctl;
+mod epoll_wait;
+mod fd_pipe;
+mod futex_wait;
+mod futex_wake;
+mod futex_wake_all;
+mod getcwd;
+mod port_addr_add;
+mod port_addr_clear;
+mod port_addr_list;
+mod port_addr_remove;
+mod port_bridge;
+mod port_dhcp_acquire;
+mod port_gateway_set;
+mod port_mac;
+mod port_route_add;
+mod port_route_clear;
+mod port_route_list;
+mod port_route_remove;
+mod port_unbridge;
+mod proc_exec;
+mod proc_fork;
+mod proc_id;
+mod proc_join;
+mod proc_parent;
+mod proc_signal;
+mod proc_spawn;
+mod resolve;
+mod sched_yield;
+mod sock_accept;
+mod sock_addr_local;
+mod sock_addr_peer;
+mod sock_bind;
+mod sock_connect;
+mod sock_get_opt_flag;
+mod sock_get_opt_size;
+mod sock_get_opt_time;
+mod sock_join_multicast_v4;
+mod sock_join_multicast_v6;
+mod sock_leave_multicast_v4;
+mod sock_leave_multicast_v6;
+mod sock_listen;
+mod sock_open;
+mod sock_recv;
+mod sock_recv_from;
+mod sock_send;
+mod sock_send_file;
+mod sock_send_to;
+mod sock_set_opt_flag;
+mod sock_set_opt_size;
+mod sock_set_opt_time;
+mod sock_shutdown;
+mod sock_status;
+mod stack_checkpoint;
+mod stack_restore;
+mod thread_exit;
+mod thread_id;
+mod thread_join;
+mod thread_parallelism;
+mod thread_signal;
+mod thread_sleep;
+mod thread_spawn;
+mod tty_get;
+mod tty_set;
+
+pub use callback_signal::*;
+pub use chdir::*;
+pub use epoll_create::*;
+pub use epoll_ctl::*;
+pub use epoll_wait::*;
+pub use fd_pipe::*;
+pub use futex_wait::*;
+pub use futex_wake::*;
+pub use futex_wake_all::*;
+pub use getcwd::*;
+pub use port_addr_add::*;
+pub use port_addr_clear::*;
+pub use port_addr_list::*;
+pub use port_addr_remove::*;
+pub use port_bridge::*;
+pub use port_dhcp_acquire::*;
+pub use port_gateway_set::*;
+pub use port_mac::*;
+pub use port_route_add::*;
+pub use port_route_clear::*;
+pub use port_route_list::*;
+pub use port_route_remove::*;
+pub use port_unbridge::*;
+pub use proc_exec::*;
+pub use proc_fork::*;
+pub use proc_id::*;
+pub use proc_join::*;
+pub use proc_parent::*;
+pub use proc_signal::*;
+pub use proc_spawn::*;
+pub use resolve::*;
+pub use sched_yield::*;
+pub use sock_accept::*;
+pub use sock_addr_local::*;
+pub use sock_addr_peer::*;
+pub use sock_bind::*;
+pub use sock_connect::*;
+pub use sock_get_opt_flag::*;
+pub use sock_get_opt_size::*;
+pub use sock_get_opt_time::*;
+pub use sock_join_multicast_v4::*;
+pub use sock_join_multicast_v6::*;
+pub use sock_leave_multicast_v4::*;
+pub use sock_leave_multicast_v6::*;
+pub use sock_listen::*;
+pub use sock_open::*;
+pub use sock_recv::*;
+pub use sock_recv_from::*;
+pub use sock_send::*;
+pub use sock_send_file::*;
+pub use sock_send_to::*;
+pub use sock_set_opt_flag::*;
+pub use sock_set_opt_size::*;
+pub use sock_set_opt_time::*;
+pub use sock_shutdown::*;
+pub use sock_status::*;
+pub use stack_checkpoint::*;
+pub use stack_restore::*;
+pub use thread_exit::*;
+pub use thread_id::*;
+pub use thread_join::*;
+pub use thread_parallelism::*;
+pub use thread_signal::*;
+pub use thread_sleep::*;
+pub use thread_spawn::*;
+pub use tty_get::*;
+pub use tty_set::*;
+
+use tracing::{debug_span, field, instrument, trace_span, Span};
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_add.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_add.rs
new file mode 100644
index 0000000..5a9d590
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_add.rs
@@ -0,0 +1,48 @@
+use virtual_net::IpCidr;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_addr_add()`
+/// Adds another static address to the local port
+///
+/// ## Parameters
+///
+/// * `addr` - Address to be added
+#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+pub fn port_addr_add<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ip: WasmPtr<__wasi_cidr_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let cidr = wasi_try_ok!(crate::net::read_cidr(&memory, ip));
+    Span::current().record("ip", &format!("{:?}", cidr));
+
+    wasi_try_ok!(port_addr_add_internal(&mut ctx, cidr)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_addr_add(&mut ctx, cidr).map_err(|err| {
+            tracing::error!("failed to save port_addr_add event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_addr_add_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    cidr: IpCidr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.ip_add(cidr.ip, cidr.prefix)
+            .await
+            .map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_clear.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_clear.rs
new file mode 100644
index 0000000..9ceb6c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_clear.rs
@@ -0,0 +1,30 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_addr_clear()`
+/// Clears all the addresses on the local port
+#[instrument(level = "debug", skip_all, ret)]
+pub fn port_addr_clear(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    wasi_try_ok!(port_addr_clear_internal(&mut ctx)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_addr_clear(&mut ctx).map_err(|err| {
+            tracing::error!("failed to save port_addr_clear event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_addr_clear_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.ip_clear().await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_list.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_list.rs
new file mode 100644
index 0000000..5439085
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_list.rs
@@ -0,0 +1,51 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_ip_list()`
+/// Returns a list of all the addresses owned by the local port
+/// This function fills the output buffer as much as possible.
+/// If the buffer is not big enough then the naddrs address will be
+/// filled with the buffer size needed and the EOVERFLOW will be returned
+///
+/// ## Parameters
+///
+/// * `addrs` - The buffer where addresses will be stored
+///
+/// ## Return
+///
+/// The number of addresses returned.
+#[instrument(level = "debug", skip_all, fields(naddrs = field::Empty), ret)]
+pub fn port_addr_list<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    addrs_ptr: WasmPtr<__wasi_cidr_t, M>,
+    naddrs_ptr: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let mut env = ctx.data();
+    let mut memory = unsafe { env.memory_view(&ctx) };
+    let max_addrs = wasi_try_mem_ok!(naddrs_ptr.read(&memory));
+    let max_addrs: u64 = wasi_try_ok!(max_addrs.try_into().map_err(|_| Errno::Overflow));
+
+    let net = env.net().clone();
+    let addrs = wasi_try_ok!(__asyncify(&mut ctx, None, async {
+        net.ip_list().await.map_err(net_error_into_wasi_err)
+    })?);
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    Span::current().record("naddrs", addrs.len());
+
+    let addrs_len: M::Offset = wasi_try_ok!(addrs.len().try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(naddrs_ptr.write(&memory, addrs_len));
+    if addrs.len() as u64 > max_addrs {
+        return Ok(Errno::Overflow);
+    }
+
+    let ref_addrs = wasi_try_mem_ok!(
+        addrs_ptr.slice(&memory, wasi_try_ok!(to_offset::<M>(max_addrs as usize)))
+    );
+    for n in 0..addrs.len() {
+        let nip = ref_addrs.index(n as u64);
+        crate::net::write_cidr(&memory, nip.as_ptr::<M>(), *addrs.get(n).unwrap());
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_remove.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_remove.rs
new file mode 100644
index 0000000..eb68924
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_addr_remove.rs
@@ -0,0 +1,44 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_addr_remove()`
+/// Removes an address from the local port
+///
+/// ## Parameters
+///
+/// * `addr` - Address to be removed
+#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+pub fn port_addr_remove<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ip: WasmPtr<__wasi_addr_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
+    Span::current().record("ip", &format!("{:?}", ip));
+
+    wasi_try_ok!(port_addr_remove_internal(&mut ctx, ip)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_addr_remove(&mut ctx, ip).map_err(|err| {
+            tracing::error!("failed to save port_addr_remove event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_addr_remove_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ip: IpAddr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.ip_remove(ip).await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_bridge.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_bridge.rs
new file mode 100644
index 0000000..e686ec5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_bridge.rs
@@ -0,0 +1,69 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_bridge()`
+/// Securely connects to a particular remote network
+///
+/// ## Parameters
+///
+/// * `network` - Fully qualified identifier for the network
+/// * `token` - Access token used to authenticate with the network
+/// * `security` - Level of encryption to encapsulate the network connection with
+#[instrument(level = "debug", skip_all, fields(network = field::Empty, ?security), ret)]
+pub fn port_bridge<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    network: WasmPtr<u8, M>,
+    network_len: M::Offset,
+    token: WasmPtr<u8, M>,
+    token_len: M::Offset,
+    security: Streamsecurity,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let network = unsafe { get_input_str_ok!(&memory, network, network_len) };
+    Span::current().record("network", network.as_str());
+
+    let token = unsafe { get_input_str_ok!(&memory, token, token_len) };
+    let security = match security {
+        Streamsecurity::Unencrypted => StreamSecurity::Unencrypted,
+        Streamsecurity::AnyEncryption => StreamSecurity::AnyEncyption,
+        Streamsecurity::ClassicEncryption => StreamSecurity::ClassicEncryption,
+        Streamsecurity::DoubleEncryption => StreamSecurity::DoubleEncryption,
+        _ => return Ok(Errno::Inval),
+    };
+
+    wasi_try_ok!(port_bridge_internal(
+        &mut ctx,
+        network.as_str(),
+        token.as_str(),
+        security
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_bridge(&mut ctx, network, token, security).map_err(|err| {
+            tracing::error!("failed to save port_bridge event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_bridge_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    network: &str,
+    token: &str,
+    security: StreamSecurity,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+        net.bridge(network, token, security)
+            .await
+            .map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs
new file mode 100644
index 0000000..1415f76
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_dhcp_acquire.rs
@@ -0,0 +1,31 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_dhcp_acquire()`
+/// Acquires a set of IP addresses using DHCP
+#[instrument(level = "debug", skip_all, ret)]
+pub fn port_dhcp_acquire(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    wasi_try_ok!(port_dhcp_acquire_internal(&mut ctx)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_dhcp_acquire(&mut ctx).map_err(|err| {
+            tracing::error!("failed to save port_dhcp_acquire event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_dhcp_acquire_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    let tasks = env.tasks().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+        net.dhcp_acquire().await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_gateway_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_gateway_set.rs
new file mode 100644
index 0000000..fc0549e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_gateway_set.rs
@@ -0,0 +1,44 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_gateway_set()`
+/// Adds a default gateway to the port
+///
+/// ## Parameters
+///
+/// * `addr` - Address of the default gateway
+#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+pub fn port_gateway_set<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ip: WasmPtr<__wasi_addr_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
+    Span::current().record("ip", &format!("{:?}", ip));
+
+    wasi_try_ok!(port_gateway_set_internal(&mut ctx, ip)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_gateway_set(&mut ctx, ip).map_err(|err| {
+            tracing::error!("failed to save port_gateway_set event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_gateway_set_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ip: IpAddr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.gateway_set(ip).await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_mac.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_mac.rs
new file mode 100644
index 0000000..93b13c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_mac.rs
@@ -0,0 +1,26 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_mac()`
+/// Returns the MAC address of the local port
+#[instrument(level = "debug", skip_all, fields(max = field::Empty), ret)]
+pub fn port_mac<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ret_mac: WasmPtr<__wasi_hardwareaddress_t, M>,
+) -> Result<Errno, WasiError> {
+    let mut env = ctx.data();
+    let mut memory = unsafe { env.memory_view(&ctx) };
+
+    let net = env.net().clone();
+    let mac = wasi_try_ok!(__asyncify(&mut ctx, None, async {
+        net.mac().await.map_err(net_error_into_wasi_err)
+    })?);
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    Span::current().record("mac", hex::encode(mac.as_ref()).as_str());
+
+    let mac = __wasi_hardwareaddress_t { octs: mac };
+    wasi_try_mem_ok!(ret_mac.write(&memory, mac));
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_add.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_add.rs
new file mode 100644
index 0000000..00e9f78
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_add.rs
@@ -0,0 +1,80 @@
+use virtual_net::IpCidr;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_route_add()`
+/// Adds a new route to the local port
+#[instrument(level = "debug", skip_all, fields(cidr = field::Empty, via_router = field::Empty), ret)]
+pub fn port_route_add<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    cidr: WasmPtr<__wasi_cidr_t, M>,
+    via_router: WasmPtr<__wasi_addr_t, M>,
+    preferred_until: WasmPtr<OptionTimestamp, M>,
+    expires_at: WasmPtr<OptionTimestamp, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let cidr = wasi_try_ok!(crate::net::read_cidr(&memory, cidr));
+    Span::current().record("cidr", &format!("{:?}", cidr));
+
+    let via_router = wasi_try_ok!(crate::net::read_ip(&memory, via_router));
+    Span::current().record("via_router", &format!("{:?}", via_router));
+
+    let preferred_until = wasi_try_mem_ok!(preferred_until.read(&memory));
+    let preferred_until = match preferred_until.tag {
+        OptionTag::None => None,
+        OptionTag::Some => Some(Duration::from_nanos(preferred_until.u)),
+        _ => return Ok(Errno::Inval),
+    };
+    let expires_at = wasi_try_mem_ok!(expires_at.read(&memory));
+    let expires_at = match expires_at.tag {
+        OptionTag::None => None,
+        OptionTag::Some => Some(Duration::from_nanos(expires_at.u)),
+        _ => return Ok(Errno::Inval),
+    };
+
+    wasi_try_ok!(port_route_add_internal(
+        &mut ctx,
+        cidr,
+        via_router,
+        preferred_until,
+        expires_at
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_route_add(
+            &mut ctx,
+            cidr,
+            via_router,
+            preferred_until,
+            expires_at,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save port_route_add event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_route_add_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    cidr: IpCidr,
+    via_router: IpAddr,
+    preferred_until: Option<Duration>,
+    expires_at: Option<Duration>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.route_add(cidr, via_router, preferred_until, expires_at)
+            .await
+            .map_err(net_error_into_wasi_err)
+    })?);
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_clear.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_clear.rs
new file mode 100644
index 0000000..3eca5de
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_clear.rs
@@ -0,0 +1,30 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_route_clear()`
+/// Clears all the routes in the local port
+#[instrument(level = "debug", skip_all, ret)]
+pub fn port_route_clear(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    wasi_try_ok!(port_route_clear_internal(&mut ctx)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_route_clear(&mut ctx).map_err(|err| {
+            tracing::error!("failed to save port_route_clear event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_route_clear_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.route_clear().await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_list.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_list.rs
new file mode 100644
index 0000000..31b0ee3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_list.rs
@@ -0,0 +1,57 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_route_list()`
+/// Returns a list of all the routes owned by the local port
+/// This function fills the output buffer as much as possible.
+/// If the buffer is too small this will return EOVERFLOW and
+/// fill nroutes with the size of the buffer needed.
+///
+/// ## Parameters
+///
+/// * `routes` - The buffer where routes will be stored
+#[instrument(level = "debug", skip_all, fields(nroutes = field::Empty, max_routes = field::Empty), ret)]
+pub fn port_route_list<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    routes_ptr: WasmPtr<Route, M>,
+    nroutes_ptr: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let mut env = ctx.data();
+    let mut memory = unsafe { env.memory_view(&ctx) };
+    let ref_nroutes = nroutes_ptr.deref(&memory);
+    let max_routes: usize = wasi_try_ok!(wasi_try_mem_ok!(ref_nroutes.read())
+        .try_into()
+        .map_err(|_| Errno::Inval));
+    Span::current().record("max_routes", max_routes);
+    let ref_routes =
+        wasi_try_mem_ok!(routes_ptr.slice(&memory, wasi_try_ok!(to_offset::<M>(max_routes))));
+
+    let net = env.net().clone();
+    let routes = wasi_try_ok!(__asyncify(&mut ctx, None, async {
+        net.route_list().await.map_err(net_error_into_wasi_err)
+    })?);
+    Span::current().record("nroutes", routes.len());
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let routes_len: M::Offset = wasi_try_ok!(routes.len().try_into().map_err(|_| Errno::Inval));
+    let nroutes = nroutes_ptr.deref(&memory);
+    wasi_try_mem_ok!(nroutes.write(routes_len));
+    if routes.len() > max_routes {
+        return Ok(Errno::Overflow);
+    }
+
+    let ref_routes =
+        wasi_try_mem_ok!(routes_ptr.slice(&memory, wasi_try_ok!(to_offset::<M>(max_routes))));
+    for n in 0..routes.len() {
+        let nroute = ref_routes.index(n as u64);
+        crate::net::write_route(
+            &memory,
+            nroute.as_ptr::<M>(),
+            routes.get(n).unwrap().clone(),
+        );
+    }
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_remove.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_remove.rs
new file mode 100644
index 0000000..0b1b5da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_route_remove.rs
@@ -0,0 +1,41 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_route_remove()`
+/// Removes an existing route from the local port
+#[instrument(level = "debug", skip_all, fields(ip = field::Empty), ret)]
+pub fn port_route_remove<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    ip: WasmPtr<__wasi_addr_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let ip = wasi_try_ok!(crate::net::read_ip(&memory, ip));
+    Span::current().record("ip", &format!("{:?}", ip));
+
+    wasi_try_ok!(port_route_remove_internal(&mut ctx, ip)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_route_remove(&mut ctx, ip).map_err(|err| {
+            tracing::error!("failed to save port_route_remove event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_route_remove_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    ip: IpAddr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async {
+        net.route_remove(ip).await.map_err(net_error_into_wasi_err)
+    })?);
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_unbridge.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_unbridge.rs
new file mode 100644
index 0000000..4495cd0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/port_unbridge.rs
@@ -0,0 +1,30 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `port_unbridge()`
+/// Disconnects from a remote network
+#[instrument(level = "debug", skip_all, ret)]
+pub fn port_unbridge(mut ctx: FunctionEnvMut<'_, WasiEnv>) -> Result<Errno, WasiError> {
+    wasi_try_ok!(port_unbridge_internal(&mut ctx)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_port_unbridge(&mut ctx).map_err(|err| {
+            tracing::error!("failed to save port_unbridge event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn port_unbridge_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+        net.unbridge().await.map_err(net_error_into_wasi_err)
+    })?);
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_exec.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_exec.rs
new file mode 100644
index 0000000..8e2e71f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_exec.rs
@@ -0,0 +1,254 @@
+use wasmer::FromToNativeWasmType;
+
+use super::*;
+use crate::{
+    os::task::{OwnedTaskStatus, TaskStatus},
+    syscalls::*,
+};
+
+/// Replaces the current process with a new process
+///
+/// ## Parameters
+///
+/// * `name` - Name of the process to be spawned
+/// * `args` - List of the arguments to pass the process
+///   (entries are separated by line feeds)
+///
+/// ## Return
+///
+/// Returns a bus process id that can be used to invoke calls
+#[instrument(level = "debug", skip_all, fields(name = field::Empty, %args_len), ret)]
+pub fn proc_exec<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: WasmPtr<u8, M>,
+    name_len: M::Offset,
+    args: WasmPtr<u8, M>,
+    args_len: M::Offset,
+) -> Result<(), WasiError> {
+    WasiEnv::process_signals_and_exit(&mut ctx)?;
+
+    // If we were just restored the stack then we were woken after a deep sleep
+    if let Some(exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
+        // We should never get here as the process will be termined
+        // in the `WasiEnv::process_signals_and_exit()` call
+        let exit_code = ExitCode::from_native(exit_code);
+        ctx.data().process.terminate(exit_code);
+        return Err(WasiError::Exit(exit_code));
+    }
+
+    let memory = unsafe { ctx.data().memory_view(&ctx) };
+    let mut name = name.read_utf8_string(&memory, name_len).map_err(|err| {
+        warn!("failed to execve as the name could not be read - {}", err);
+        WasiError::Exit(Errno::Inval.into())
+    })?;
+    Span::current().record("name", name.as_str());
+    let args = args.read_utf8_string(&memory, args_len).map_err(|err| {
+        warn!("failed to execve as the args could not be read - {}", err);
+        WasiError::Exit(Errno::Inval.into())
+    })?;
+    let args: Vec<_> = args
+        .split(&['\n', '\r'])
+        .map(|a| a.to_string())
+        .filter(|a| !a.is_empty())
+        .collect();
+
+    // Convert relative paths into absolute paths
+    if name.starts_with("./") {
+        name = ctx.data().state.fs.relative_path_to_absolute(name);
+    }
+    trace!(name);
+
+    // Convert the preopen directories
+    let preopen = ctx.data().state.preopen.clone();
+
+    // Get the current working directory
+    let (_, cur_dir) = {
+        let (memory, state, inodes) =
+            unsafe { ctx.data().get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+        match state.fs.get_current_dir(inodes, crate::VIRTUAL_ROOT_FD) {
+            Ok(a) => a,
+            Err(err) => {
+                warn!("failed to create subprocess for fork - {}", err);
+                return Err(WasiError::Exit(err.into()));
+            }
+        }
+    };
+
+    let new_store = ctx.data().runtime.new_store();
+
+    // If we are in a vfork we need to first spawn a subprocess of this type
+    // with the forked WasiEnv, then do a longjmp back to the vfork point.
+    if let Some(mut vfork) = ctx.data_mut().vfork.take() {
+        // We will need the child pid later
+        let child_process = ctx.data().process.clone();
+        let child_pid = child_process.pid();
+        let child_finished = child_process.finished;
+
+        // Restore the WasiEnv to the point when we vforked
+        vfork.env.swap_inner(ctx.data_mut());
+        std::mem::swap(vfork.env.as_mut(), ctx.data_mut());
+        let mut wasi_env = *vfork.env;
+        wasi_env.owned_handles.push(vfork.handle);
+        _prepare_wasi(&mut wasi_env, Some(args));
+
+        // Recrod the stack offsets before we give up ownership of the wasi_env
+        let stack_lower = wasi_env.layout.stack_lower;
+        let stack_upper = wasi_env.layout.stack_upper;
+
+        // Spawn a new process with this current execution environment
+        let mut err_exit_code: ExitCode = Errno::Success.into();
+
+        {
+            let bin_factory = Box::new(ctx.data().bin_factory.clone());
+            let tasks = wasi_env.tasks().clone();
+
+            let mut new_store = Some(new_store);
+            let mut config = Some(wasi_env);
+
+            match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut new_store, &mut config) {
+                Ok(a) => {}
+                Err(err) => {
+                    if !err.is_not_found() {
+                        error!("builtin failed - {}", err);
+                    }
+
+                    let new_store = new_store.take().unwrap();
+                    let env = config.take().unwrap();
+
+                    let name_inner = name.clone();
+                    __asyncify_light(ctx.data(), None, async {
+                        let ret = bin_factory.spawn(name_inner, new_store, env).await;
+                        match ret {
+                            Ok(ret) => {
+                                trace!(%child_pid, "spawned sub-process");
+                            }
+                            Err(err) => {
+                                err_exit_code = conv_spawn_err_to_exit_code(&err);
+
+                                debug!(%child_pid, "process failed with (err={})", err_exit_code);
+                                child_finished.set_finished(Ok(err_exit_code));
+
+                                warn!(
+                                    "failed to execve as the process could not be spawned (vfork) - {}",
+                                    err
+                                );
+                                let _ = unsafe {
+                                    stderr_write(
+                                        &ctx,
+                                        format!(
+                                            "wasm execute failed [{}] - {}\n",
+                                            name.as_str(),
+                                            err
+                                        )
+                                        .as_bytes(),
+                                    )
+                                }
+                                .await;
+                            }
+                        }
+
+                        Ok(())
+                    });
+                }
+            }
+        };
+
+        // Jump back to the vfork point and current on execution
+        // note: fork does not return any values hence passing `()`
+        let memory_stack = vfork.memory_stack.freeze();
+        let rewind_stack = vfork.rewind_stack.freeze();
+        let store_data = vfork.store_data;
+        unwind::<M, _>(ctx, move |mut ctx, _, _| {
+            // Rewind the stack
+            match rewind::<M, _>(
+                ctx,
+                memory_stack,
+                rewind_stack,
+                store_data,
+                ForkResult {
+                    pid: child_pid.raw() as Pid,
+                    ret: Errno::Success,
+                },
+            ) {
+                Errno::Success => OnCalledAction::InvokeAgain,
+                err => {
+                    warn!("fork failed - could not rewind the stack - errno={}", err);
+                    OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                }
+            }
+        })?;
+        Ok(())
+    }
+    // Otherwise we need to unwind the stack to get out of the current executing
+    // callstack, steal the memory/WasiEnv and switch it over to a new thread
+    // on the new module
+    else {
+        // Prepare the environment
+        let mut wasi_env = ctx.data().clone();
+        _prepare_wasi(&mut wasi_env, Some(args));
+
+        // Get a reference to the runtime
+        let bin_factory = ctx.data().bin_factory.clone();
+        let tasks = wasi_env.tasks().clone();
+
+        // Create the process and drop the context
+        let bin_factory = Box::new(ctx.data().bin_factory.clone());
+
+        let mut new_store = Some(new_store);
+        let mut builder = Some(wasi_env);
+
+        let process = match bin_factory.try_built_in(
+            name.clone(),
+            Some(&ctx),
+            &mut new_store,
+            &mut builder,
+        ) {
+            Ok(a) => Ok(a),
+            Err(err) => {
+                if !err.is_not_found() {
+                    error!("builtin failed - {}", err);
+                }
+
+                let new_store = new_store.take().unwrap();
+                let env = builder.take().unwrap();
+
+                // Spawn a new process with this current execution environment
+                InlineWaker::block_on(bin_factory.spawn(name, new_store, env))
+            }
+        };
+
+        match process {
+            Ok(mut process) => {
+                // If we support deep sleeping then we switch to deep sleep mode
+                let env = ctx.data();
+                let thread = env.thread.clone();
+
+                // The poller will wait for the process to actually finish
+                let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+                    process
+                        .wait_finished()
+                        .await
+                        .unwrap_or_else(|_| Errno::Child.into())
+                        .to_native()
+                })?;
+                match res {
+                    AsyncifyAction::Finish(mut ctx, result) => {
+                        // When we arrive here the process should already be terminated
+                        let exit_code = ExitCode::from_native(result);
+                        ctx.data().process.terminate(exit_code);
+                        WasiEnv::process_signals_and_exit(&mut ctx)?;
+                        Err(WasiError::Exit(Errno::Unknown.into()))
+                    }
+                    AsyncifyAction::Unwind => Ok(()),
+                }
+            }
+            Err(err) => {
+                warn!(
+                    "failed to execve as the process could not be spawned (fork)[0] - {}",
+                    err
+                );
+                Err(WasiError::Exit(Errno::Noexec.into()))
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_fork.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_fork.rs
new file mode 100644
index 0000000..31092c8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_fork.rs
@@ -0,0 +1,317 @@
+use super::*;
+use crate::{
+    capture_store_snapshot,
+    os::task::OwnedTaskStatus,
+    runtime::task_manager::{TaskWasm, TaskWasmRunProperties},
+    syscalls::*,
+    WasiThreadHandle,
+};
+use serde::{Deserialize, Serialize};
+use wasmer::Memory;
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct ForkResult {
+    pub pid: Pid,
+    pub ret: Errno,
+}
+
+/// ### `proc_fork()`
+/// Forks the current process into a new subprocess. If the function
+/// returns a zero then its the new subprocess. If it returns a positive
+/// number then its the current process and the $pid represents the child.
+#[instrument(level = "debug", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
+pub fn proc_fork<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    mut copy_memory: Bool,
+    pid_ptr: WasmPtr<Pid, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    // If we were just restored then we need to return the value instead
+    if let Some(result) = unsafe { handle_rewind::<M, ForkResult>(&mut ctx) } {
+        if result.pid == 0 {
+            trace!("handle_rewind - i am child (ret={})", result.ret);
+        } else {
+            trace!(
+                "handle_rewind - i am parent (child={}, ret={})",
+                result.pid,
+                result.ret
+            );
+        }
+        let memory = unsafe { ctx.data().memory_view(&ctx) };
+        wasi_try_mem_ok!(pid_ptr.write(&memory, result.pid));
+        return Ok(result.ret);
+    }
+    trace!(%copy_memory, "capturing");
+
+    // Fork the environment which will copy all the open file handlers
+    // and associate a new context but otherwise shares things like the
+    // file system interface. The handle to the forked process is stored
+    // in the parent process context
+    let (mut child_env, mut child_handle) = match ctx.data().fork() {
+        Ok(p) => p,
+        Err(err) => {
+            debug!("could not fork process: {err}");
+            // TODO: evaluate the appropriate error code, document it in the spec.
+            return Ok(Errno::Perm);
+        }
+    };
+    let child_pid = child_env.process.pid();
+    let child_finished = child_env.process.finished.clone();
+
+    // We write a zero to the PID before we capture the stack
+    // so that this is what will be returned to the child
+    {
+        let mut inner = ctx.data().process.lock();
+        inner.children.push(child_env.process.clone());
+    }
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    // Setup some properties in the child environment
+    wasi_try_mem_ok!(pid_ptr.write(&memory, 0));
+    let pid = child_env.pid();
+    let tid = child_env.tid();
+
+    // Pass some offsets to the unwind function
+    let pid_offset = pid_ptr.offset();
+
+    // If we are not copying the memory then we act like a `vfork`
+    // instead which will pretend to be the new process for a period
+    // of time until `proc_exec` is called at which point the fork
+    // actually occurs
+    if copy_memory == Bool::False {
+        // Perform the unwind action
+        return unwind::<M, _>(ctx, move |mut ctx, mut memory_stack, rewind_stack| {
+            // Grab all the globals and serialize them
+            let store_data = crate::utils::store::capture_store_snapshot(&mut ctx.as_store_mut())
+                .serialize()
+                .unwrap();
+            let store_data = Bytes::from(store_data);
+
+            // We first fork the environment and replace the current environment
+            // so that the process can continue to prepare for the real fork as
+            // if it had actually forked
+            child_env.swap_inner(ctx.data_mut());
+            std::mem::swap(ctx.data_mut(), &mut child_env);
+            ctx.data_mut().vfork.replace(WasiVFork {
+                rewind_stack: rewind_stack.clone(),
+                memory_stack: memory_stack.clone(),
+                store_data: store_data.clone(),
+                env: Box::new(child_env),
+                handle: child_handle,
+            });
+
+            // Carry on as if the fork had taken place (which basically means
+            // it prevents to be the new process with the old one suspended)
+            // Rewind the stack and carry on
+            match rewind::<M, _>(
+                ctx,
+                memory_stack.freeze(),
+                rewind_stack.freeze(),
+                store_data,
+                ForkResult {
+                    pid: 0,
+                    ret: Errno::Success,
+                },
+            ) {
+                Errno::Success => OnCalledAction::InvokeAgain,
+                err => {
+                    warn!("failed - could not rewind the stack - errno={}", err);
+                    OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                }
+            }
+        });
+    }
+
+    // Create the thread that will back this forked process
+    let state = env.state.clone();
+    let bin_factory = env.bin_factory.clone();
+
+    // Perform the unwind action
+    let snapshot = capture_store_snapshot(&mut ctx.as_store_mut());
+    unwind::<M, _>(ctx, move |mut ctx, mut memory_stack, rewind_stack| {
+        let tasks = ctx.data().tasks().clone();
+        let span = debug_span!(
+            "unwind",
+            memory_stack_len = memory_stack.len(),
+            rewind_stack_len = rewind_stack.len()
+        );
+        let _span_guard = span.enter();
+        let memory_stack = memory_stack.freeze();
+        let rewind_stack = rewind_stack.freeze();
+
+        // Grab all the globals and serialize them
+        let store_data = snapshot.serialize().unwrap();
+        let store_data = Bytes::from(store_data);
+
+        // Now we use the environment and memory references
+        let runtime = child_env.runtime.clone();
+        let tasks = child_env.tasks().clone();
+        let child_memory_stack = memory_stack.clone();
+        let child_rewind_stack = rewind_stack.clone();
+
+        let module = unsafe { ctx.data().inner() }.module_clone();
+        let memory = unsafe { ctx.data().inner() }.memory_clone();
+        let spawn_type = SpawnMemoryType::CopyMemory(memory, ctx.as_store_ref());
+
+        // Spawn a new process with this current execution environment
+        let signaler = Box::new(child_env.process.clone());
+        {
+            let runtime = runtime.clone();
+            let tasks = tasks.clone();
+            let tasks_outer = tasks.clone();
+            let store_data = store_data.clone();
+
+            let run = move |mut props: TaskWasmRunProperties| {
+                let ctx = props.ctx;
+                let mut store = props.store;
+
+                // Rewind the stack and carry on
+                {
+                    trace!("rewinding child");
+                    let mut ctx = ctx.env.clone().into_mut(&mut store);
+                    let (data, mut store) = ctx.data_and_store_mut();
+                    match rewind::<M, _>(
+                        ctx,
+                        child_memory_stack,
+                        child_rewind_stack,
+                        store_data.clone(),
+                        ForkResult {
+                            pid: 0,
+                            ret: Errno::Success,
+                        },
+                    ) {
+                        Errno::Success => OnCalledAction::InvokeAgain,
+                        err => {
+                            warn!(
+                                "wasm rewind failed - could not rewind the stack - errno={}",
+                                err
+                            );
+                            return;
+                        }
+                    };
+                }
+
+                // Invoke the start function
+                run::<M>(ctx, store, child_handle, None);
+            };
+
+            tasks_outer
+                .task_wasm(
+                    TaskWasm::new(Box::new(run), child_env, module, false)
+                        .with_globals(&snapshot)
+                        .with_memory(spawn_type),
+                )
+                .map_err(|err| {
+                    warn!(
+                        "failed to fork as the process could not be spawned - {}",
+                        err
+                    );
+                    err
+                })
+                .ok();
+        };
+
+        // Rewind the stack and carry on
+        match rewind::<M, _>(
+            ctx,
+            memory_stack,
+            rewind_stack,
+            store_data,
+            ForkResult {
+                pid: child_pid.raw() as Pid,
+                ret: Errno::Success,
+            },
+        ) {
+            Errno::Success => OnCalledAction::InvokeAgain,
+            err => {
+                warn!("failed - could not rewind the stack - errno={}", err);
+                OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+            }
+        }
+    })
+}
+
+fn run<M: MemorySize>(
+    ctx: WasiFunctionEnv,
+    mut store: Store,
+    child_handle: WasiThreadHandle,
+    rewind_state: Option<(RewindState, RewindResultType)>,
+) -> ExitCode {
+    let env = ctx.data(&store);
+    let tasks = env.tasks().clone();
+    let pid = env.pid();
+    let tid = env.tid();
+
+    // If we need to rewind then do so
+    if let Some((rewind_state, rewind_result)) = rewind_state {
+        let mut ctx = ctx.env.clone().into_mut(&mut store);
+        let res = rewind_ext::<M>(
+            &mut ctx,
+            Some(rewind_state.memory_stack),
+            rewind_state.rewind_stack,
+            rewind_state.store_data,
+            rewind_result,
+        );
+        if res != Errno::Success {
+            return res.into();
+        }
+    }
+
+    let mut ret: ExitCode = Errno::Success.into();
+    let err = if ctx.data(&store).thread.is_main() {
+        trace!(%pid, %tid, "re-invoking main");
+        let start = unsafe { ctx.data(&store).inner() }.start.clone().unwrap();
+        start.call(&mut store)
+    } else {
+        trace!(%pid, %tid, "re-invoking thread_spawn");
+        let start = unsafe { ctx.data(&store).inner() }
+            .thread_spawn
+            .clone()
+            .unwrap();
+        start.call(&mut store, 0, 0)
+    };
+    if let Err(err) = err {
+        match err.downcast::<WasiError>() {
+            Ok(WasiError::Exit(exit_code)) => {
+                ret = exit_code;
+            }
+            Ok(WasiError::DeepSleep(deep)) => {
+                trace!(%pid, %tid, "entered a deep sleep");
+
+                // Create the respawn function
+                let respawn = {
+                    let tasks = tasks.clone();
+                    let rewind_state = deep.rewind;
+                    move |ctx, store, rewind_result| {
+                        run::<M>(
+                            ctx,
+                            store,
+                            child_handle,
+                            Some((
+                                rewind_state,
+                                RewindResultType::RewindWithResult(rewind_result),
+                            )),
+                        );
+                    }
+                };
+
+                /// Spawns the WASM process after a trigger
+                unsafe {
+                    tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
+                };
+                return Errno::Success.into();
+            }
+            _ => {}
+        }
+    }
+    trace!(%pid, %tid, "child exited (code = {})", ret);
+
+    // Clean up the environment and return the result
+    ctx.on_exit((&mut store), Some(ret));
+
+    // We drop the handle at the last moment which will close the thread
+    drop(child_handle);
+    ret
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_id.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_id.rs
new file mode 100644
index 0000000..bbbc25f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_id.rs
@@ -0,0 +1,16 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_id()`
+/// Returns the handle of the current process
+#[instrument(level = "debug", skip_all, fields(pid = field::Empty), ret)]
+pub fn proc_id<M: MemorySize>(ctx: FunctionEnvMut<'_, WasiEnv>, ret_pid: WasmPtr<Pid, M>) -> Errno {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let pid = env.process.pid();
+    Span::current().record("pid", pid.raw());
+
+    wasi_try_mem!(ret_pid.write(&memory, pid.raw() as Pid));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_join.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_join.rs
new file mode 100644
index 0000000..3bc85e2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_join.rs
@@ -0,0 +1,205 @@
+use std::task::Waker;
+
+use serde::{Deserialize, Serialize};
+use wasmer::FromToNativeWasmType;
+use wasmer_wasix_types::wasi::{JoinFlags, JoinStatus, JoinStatusType, JoinStatusUnion, OptionPid};
+
+use super::*;
+use crate::{syscalls::*, WasiProcess};
+
+#[derive(Serialize, Deserialize)]
+enum JoinStatusResult {
+    Nothing,
+    ExitNormal(WasiProcessId, ExitCode),
+    Err(Errno),
+}
+
+/// ### `proc_join()`
+/// Joins the child process, blocking this one until the other finishes
+///
+/// ## Parameters
+///
+/// * `pid` - Handle of the child process to wait on
+//#[instrument(level = "trace", skip_all, fields(pid = ctx.data().process.pid().raw()), ret)]
+pub fn proc_join<M: MemorySize + 'static>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    pid_ptr: WasmPtr<OptionPid, M>,
+    flags: JoinFlags,
+    status_ptr: WasmPtr<JoinStatus, M>,
+) -> Result<Errno, WasiError> {
+    proc_join_internal(ctx, pid_ptr, flags, status_ptr)
+}
+
+pub(super) fn proc_join_internal<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    pid_ptr: WasmPtr<OptionPid, M>,
+    flags: JoinFlags,
+    status_ptr: WasmPtr<JoinStatus, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    // This lambda will look at what we wrote in the status variable
+    // and use this to determine the return code sent back to the caller
+    let ret_result = {
+        move |ctx: FunctionEnvMut<'_, WasiEnv>, status: JoinStatusResult| {
+            let mut ret = Errno::Success;
+
+            let view = unsafe { ctx.data().memory_view(&ctx) };
+            let status = match status {
+                JoinStatusResult::Nothing => JoinStatus {
+                    tag: JoinStatusType::Nothing,
+                    u: JoinStatusUnion { nothing: 0 },
+                },
+                JoinStatusResult::ExitNormal(pid, exit_code) => {
+                    let option_pid = OptionPid {
+                        tag: OptionTag::Some,
+                        pid: pid.raw() as Pid,
+                    };
+                    pid_ptr.write(&view, option_pid).ok();
+
+                    JoinStatus {
+                        tag: JoinStatusType::ExitNormal,
+                        u: JoinStatusUnion {
+                            exit_normal: exit_code.into(),
+                        },
+                    }
+                }
+                JoinStatusResult::Err(err) => {
+                    ret = err;
+                    JoinStatus {
+                        tag: JoinStatusType::Nothing,
+                        u: JoinStatusUnion { nothing: 0 },
+                    }
+                }
+            };
+            wasi_try_mem_ok!(status_ptr.write(&view, status));
+            Ok(ret)
+        }
+    };
+
+    // If we were just restored the stack then we were woken after a deep sleep
+    // and the return calues are already set
+    if let Some(status) = unsafe { handle_rewind::<M, _>(&mut ctx) } {
+        let ret = ret_result(ctx, status);
+        tracing::trace!("rewound join ret={:?}", ret);
+        return ret;
+    }
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let option_pid = wasi_try_mem_ok!(pid_ptr.read(&memory));
+    let option_pid = match option_pid.tag {
+        OptionTag::None => None,
+        OptionTag::Some => Some(option_pid.pid),
+    };
+    tracing::trace!("filter_pid = {:?}", option_pid);
+
+    // Clear the existing values (in case something goes wrong)
+    wasi_try_mem_ok!(pid_ptr.write(
+        &memory,
+        OptionPid {
+            tag: OptionTag::None,
+            pid: 0,
+        }
+    ));
+    wasi_try_mem_ok!(status_ptr.write(
+        &memory,
+        JoinStatus {
+            tag: JoinStatusType::Nothing,
+            u: JoinStatusUnion { nothing: 0 },
+        }
+    ));
+
+    // If the ID is maximum then it means wait for any of the children
+    let pid = match option_pid {
+        None => {
+            let mut process = ctx.data_mut().process.clone();
+
+            // We wait for any process to exit (if it takes too long
+            // then we go into a deep sleep)
+            let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+                let child_exit = process.join_any_child().await;
+                match child_exit {
+                    Ok(Some((pid, exit_code))) => {
+                        tracing::trace!(%pid, %exit_code, "triggered child join");
+                        trace!(ret_id = pid.raw(), exit_code = exit_code.raw());
+                        JoinStatusResult::ExitNormal(pid, exit_code)
+                    }
+                    Ok(None) => {
+                        tracing::trace!("triggered child join (no child)");
+                        JoinStatusResult::Err(Errno::Child)
+                    }
+                    Err(err) => {
+                        tracing::trace!(%err, "error triggered on child join");
+                        JoinStatusResult::Err(err)
+                    }
+                }
+            })?;
+            return match res {
+                AsyncifyAction::Finish(ctx, result) => ret_result(ctx, result),
+                AsyncifyAction::Unwind => Ok(Errno::Success),
+            };
+        }
+        Some(pid) => pid,
+    };
+
+    // Otherwise we wait for the specific PID
+    let pid: WasiProcessId = pid.into();
+
+    // Waiting for a process that is an explicit child will join it
+    // meaning it will no longer be a sub-process of the main process
+    let mut process = {
+        let mut inner = ctx.data().process.lock();
+        let process = inner
+            .children
+            .iter()
+            .filter(|c| c.pid == pid)
+            .map(Clone::clone)
+            .next();
+        inner.children.retain(|c| c.pid != pid);
+        process
+    };
+
+    // Otherwise it could be the case that we are waiting for a process
+    // that is not a child of this process but may still be running
+    if process.is_none() {
+        process = ctx.data().control_plane.get_process(pid);
+    }
+
+    if let Some(process) = process {
+        // We can already set the process ID
+        wasi_try_mem_ok!(pid_ptr.write(
+            &memory,
+            OptionPid {
+                tag: OptionTag::Some,
+                pid: pid.raw(),
+            }
+        ));
+
+        if flags.contains(JoinFlags::NON_BLOCKING) {
+            if let Some(status) = process.try_join() {
+                let exit_code = status.unwrap_or_else(|_| Errno::Child.into());
+                ret_result(ctx, JoinStatusResult::ExitNormal(pid, exit_code))
+            } else {
+                ret_result(ctx, JoinStatusResult::Nothing)
+            }
+        } else {
+            // Wait for the process to finish
+            let process2 = process.clone();
+            let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+                let exit_code = process.join().await.unwrap_or_else(|_| Errno::Child.into());
+                tracing::trace!(%exit_code, "triggered child join");
+                JoinStatusResult::ExitNormal(pid, exit_code)
+            })?;
+            match res {
+                AsyncifyAction::Finish(ctx, result) => ret_result(ctx, result),
+                AsyncifyAction::Unwind => Ok(Errno::Success),
+            }
+        }
+    } else {
+        trace!(ret_id = pid.raw(), "status=nothing");
+        ret_result(ctx, JoinStatusResult::Nothing)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_parent.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_parent.rs
new file mode 100644
index 0000000..f1efee7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_parent.rs
@@ -0,0 +1,27 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_parent()`
+/// Returns the parent handle of the supplied process
+#[instrument(level = "debug", skip_all, fields(%pid, parent = field::Empty), ret)]
+pub fn proc_parent<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    pid: Pid,
+    ret_parent: WasmPtr<Pid, M>,
+) -> Errno {
+    let env = ctx.data();
+    let pid: WasiProcessId = pid.into();
+    if pid == env.process.pid() {
+        let memory = unsafe { env.memory_view(&ctx) };
+        Span::current().record("parent", env.process.ppid().raw());
+        wasi_try_mem!(ret_parent.write(&memory, env.process.ppid().raw() as Pid));
+        Errno::Success
+    } else if let Some(process) = env.control_plane.get_process(pid) {
+        let memory = unsafe { env.memory_view(&ctx) };
+        Span::current().record("parent", process.pid().raw());
+        wasi_try_mem!(ret_parent.write(&memory, process.pid().raw() as Pid));
+        Errno::Success
+    } else {
+        Errno::Badf
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_signal.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_signal.rs
new file mode 100644
index 0000000..5cb8bf8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_signal.rs
@@ -0,0 +1,28 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `proc_signal()`
+/// Sends a signal to a child process
+///
+/// ## Parameters
+///
+/// * `pid` - Handle of the child process to wait on
+/// * `sig` - Signal to send the child process
+#[instrument(level = "trace", skip_all, fields(%pid, ?sig), ret)]
+pub fn proc_signal<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    pid: Pid,
+    sig: Signal,
+) -> Result<Errno, WasiError> {
+    let process = {
+        let pid: WasiProcessId = pid.into();
+        ctx.data().control_plane.get_process(pid)
+    };
+    if let Some(process) = process {
+        process.signal_process(sig);
+    }
+
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_spawn.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_spawn.rs
new file mode 100644
index 0000000..bbec1b3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/proc_spawn.rs
@@ -0,0 +1,261 @@
+use virtual_fs::Pipe;
+use wasmer_wasix_types::wasi::ProcessHandles;
+
+use super::*;
+use crate::syscalls::*;
+
+/// Spawns a new process within the context of this machine
+///
+/// ## Parameters
+///
+/// * `name` - Name of the process to be spawned
+/// * `chroot` - Indicates if the process will chroot or not
+/// * `args` - List of the arguments to pass the process
+///   (entries are separated by line feeds)
+/// * `preopen` - List of the preopens for this process
+///   (entries are separated by line feeds)
+/// * `stdin` - How will stdin be handled
+/// * `stdout` - How will stdout be handled
+/// * `stderr` - How will stderr be handled
+/// * `working_dir` - Working directory where this process should run
+///   (passing '.' will use the current directory)
+///
+/// ## Return
+///
+/// Returns a bus process id that can be used to invoke calls
+#[instrument(level = "debug", skip_all, fields(name = field::Empty, working_dir = field::Empty), ret)]
+pub fn proc_spawn<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: WasmPtr<u8, M>,
+    name_len: M::Offset,
+    chroot: Bool,
+    args: WasmPtr<u8, M>,
+    args_len: M::Offset,
+    preopen: WasmPtr<u8, M>,
+    preopen_len: M::Offset,
+    stdin: WasiStdioMode,
+    stdout: WasiStdioMode,
+    stderr: WasiStdioMode,
+    working_dir: WasmPtr<u8, M>,
+    working_dir_len: M::Offset,
+    ret_handles: WasmPtr<ProcessHandles, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let control_plane = &env.control_plane;
+    let memory = unsafe { env.memory_view(&ctx) };
+    let name = unsafe { get_input_str_ok!(&memory, name, name_len) };
+    let args = unsafe { get_input_str_ok!(&memory, args, args_len) };
+    let preopen = unsafe { get_input_str_ok!(&memory, preopen, preopen_len) };
+    let working_dir = unsafe { get_input_str_ok!(&memory, working_dir, working_dir_len) };
+
+    Span::current()
+        .record("name", name.as_str())
+        .record("working_dir", working_dir.as_str());
+
+    if chroot == Bool::True {
+        warn!("chroot is not currently supported",);
+        return Ok(Errno::Notsup);
+    }
+
+    let args: Vec<_> = args
+        .split(&['\n', '\r'])
+        .map(|a| a.to_string())
+        .filter(|a| !a.is_empty())
+        .collect();
+
+    let preopen: Vec<_> = preopen
+        .split(&['\n', '\r'])
+        .map(|a| a.to_string())
+        .filter(|a| !a.is_empty())
+        .collect();
+
+    let (handles, ctx) = match proc_spawn_internal(
+        ctx,
+        name,
+        Some(args),
+        Some(preopen),
+        Some(working_dir),
+        stdin,
+        stdout,
+        stderr,
+    )? {
+        Ok(a) => a,
+        Err(err) => {
+            return Ok(err);
+        }
+    };
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem_ok!(ret_handles.write(&memory, handles));
+    Ok(Errno::Success)
+}
+
+pub fn proc_spawn_internal(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    name: String,
+    args: Option<Vec<String>>,
+    preopen: Option<Vec<String>>,
+    working_dir: Option<String>,
+    stdin: WasiStdioMode,
+    stdout: WasiStdioMode,
+    stderr: WasiStdioMode,
+) -> WasiResult<(ProcessHandles, FunctionEnvMut<'_, WasiEnv>)> {
+    let env = ctx.data();
+
+    // Build a new store that will be passed to the thread
+    let new_store = ctx.data().runtime.new_store();
+
+    // Fork the current environment and set the new arguments
+    let (mut child_env, handle) = match ctx.data().fork() {
+        Ok(x) => x,
+        Err(err) => {
+            // TODO: evaluate the appropriate error code, document it in the spec.
+            return Ok(Err(Errno::Access));
+        }
+    };
+    let child_process = child_env.process.clone();
+    if let Some(args) = args {
+        let mut child_state = env.state.fork();
+        child_state.args = args;
+        child_env.state = Arc::new(child_state);
+    }
+
+    // Take ownership of this child
+    ctx.data_mut().owned_handles.push(handle);
+    let env = ctx.data();
+
+    // Preopen
+    if let Some(preopen) = preopen {
+        if !preopen.is_empty() {
+            for preopen in preopen {
+                warn!(
+                    "preopens are not yet supported for spawned processes [{}]",
+                    preopen
+                );
+            }
+            return Ok(Err(Errno::Notsup));
+        }
+    }
+
+    // Change the current directory
+    if let Some(working_dir) = working_dir {
+        child_env.state.fs.set_current_dir(working_dir.as_str());
+    }
+
+    // Replace the STDIO
+    let (stdin, stdout, stderr) = {
+        let (child_state, child_inodes) = child_env.get_wasi_state_and_inodes();
+        let mut conv_stdio_mode = |mode: WasiStdioMode, fd: WasiFd| -> Result<OptionFd, Errno> {
+            match mode {
+                WasiStdioMode::Piped => {
+                    let (pipe1, pipe2) = Pipe::channel();
+                    let inode1 = child_state.fs.create_inode_with_default_stat(
+                        child_inodes,
+                        Kind::Pipe { pipe: pipe1 },
+                        false,
+                        "pipe".into(),
+                    );
+                    let inode2 = child_state.fs.create_inode_with_default_stat(
+                        child_inodes,
+                        Kind::Pipe { pipe: pipe2 },
+                        false,
+                        "pipe".into(),
+                    );
+
+                    let rights = crate::net::socket::all_socket_rights();
+                    let pipe = ctx.data().state.fs.create_fd(
+                        rights,
+                        rights,
+                        Fdflags::empty(),
+                        0,
+                        inode1,
+                    )?;
+                    child_state.fs.create_fd_ext(
+                        rights,
+                        rights,
+                        Fdflags::empty(),
+                        0,
+                        inode2,
+                        fd,
+                    )?;
+
+                    trace!("fd_pipe (fd1={}, fd2={})", pipe, fd);
+                    Ok(OptionFd {
+                        tag: OptionTag::Some,
+                        fd: pipe,
+                    })
+                }
+                WasiStdioMode::Inherit => Ok(OptionFd {
+                    tag: OptionTag::None,
+                    fd: u32::MAX,
+                }),
+                _ => {
+                    child_state.fs.close_fd(fd);
+                    Ok(OptionFd {
+                        tag: OptionTag::None,
+                        fd: u32::MAX,
+                    })
+                }
+            }
+        };
+        let stdin = match conv_stdio_mode(stdin, 0) {
+            Ok(a) => a,
+            Err(err) => return Ok(Err(err)),
+        };
+        let stdout = match conv_stdio_mode(stdout, 1) {
+            Ok(a) => a,
+            Err(err) => return Ok(Err(err)),
+        };
+        let stderr = match conv_stdio_mode(stderr, 2) {
+            Ok(a) => a,
+            Err(err) => return Ok(Err(err)),
+        };
+        (stdin, stdout, stderr)
+    };
+
+    // Create the new process
+    let bin_factory = Box::new(ctx.data().bin_factory.clone());
+    let child_pid = child_env.pid();
+
+    let mut new_store = Some(new_store);
+    let mut builder = Some(child_env);
+
+    // First we try the built in commands
+    let mut process =
+        match bin_factory.try_built_in(name.clone(), Some(&ctx), &mut new_store, &mut builder) {
+            Ok(a) => a,
+            Err(err) => {
+                if !err.is_not_found() {
+                    error!("builtin failed - {}", err);
+                }
+                // Now we actually spawn the process
+                let child_work =
+                    bin_factory.spawn(name, new_store.take().unwrap(), builder.take().unwrap());
+
+                match __asyncify(&mut ctx, None, async move { Ok(child_work.await) })?
+                    .map_err(|err| Errno::Unknown)
+                {
+                    Ok(Ok(a)) => a,
+                    Ok(Err(err)) => return Ok(Err(conv_spawn_err_to_errno(&err))),
+                    Err(err) => return Ok(Err(err)),
+                }
+            }
+        };
+
+    // Add the process to the environment state
+    {
+        let mut inner = ctx.data().process.lock();
+        inner.children.push(child_process);
+    }
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let handles = ProcessHandles {
+        pid: child_pid.raw(),
+        stdin,
+        stdout,
+        stderr,
+    };
+    Ok(Ok((handles, ctx)))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/resolve.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/resolve.rs
new file mode 100644
index 0000000..2e40e6e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/resolve.rs
@@ -0,0 +1,63 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `resolve()`
+/// Resolves a hostname and a port to one or more IP addresses.
+///
+/// Note: This is similar to `getaddrinfo` in POSIX
+///
+/// When successful, the contents of the output buffer consist of a sequence of
+/// IPv4 and/or IPv6 addresses. Each address entry consists of a addr_t object.
+/// This function fills the output buffer as much as possible.
+///
+/// ## Parameters
+///
+/// * `host` - Host to resolve
+/// * `port` - Port hint (zero if no hint is supplied)
+/// * `addrs` - The buffer where addresses will be stored
+///
+/// ## Return
+///
+/// The number of IP addresses returned during the DNS resolution.
+#[instrument(level = "debug", skip_all, fields(host = field::Empty, %port), ret)]
+pub fn resolve<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    host: WasmPtr<u8, M>,
+    host_len: M::Offset,
+    port: u16,
+    addrs: WasmPtr<__wasi_addr_t, M>,
+    naddrs: M::Offset,
+    ret_naddrs: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let naddrs: usize = wasi_try_ok!(naddrs.try_into().map_err(|_| Errno::Inval));
+    let mut env = ctx.data();
+    let host_str = {
+        let memory = unsafe { env.memory_view(&ctx) };
+        unsafe { get_input_str_ok!(&memory, host, host_len) }
+    };
+    Span::current().record("host", host_str.as_str());
+
+    let port = if port > 0 { Some(port) } else { None };
+
+    let net = env.net().clone();
+    let tasks = env.tasks().clone();
+    let found_ips = wasi_try_ok!(__asyncify(&mut ctx, None, async move {
+        net.resolve(host_str.as_str(), port, None)
+            .await
+            .map_err(net_error_into_wasi_err)
+    })?);
+    env = ctx.data();
+
+    let mut idx = 0;
+    let memory = unsafe { env.memory_view(&ctx) };
+    let addrs = wasi_try_mem_ok!(addrs.slice(&memory, wasi_try_ok!(to_offset::<M>(naddrs))));
+    for found_ip in found_ips.iter().take(naddrs) {
+        crate::net::write_ip(&memory, addrs.index(idx).as_ptr::<M>(), *found_ip);
+        idx += 1;
+    }
+
+    let idx: M::Offset = wasi_try_ok!(idx.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(ret_naddrs.write(&memory, idx));
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sched_yield.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sched_yield.rs
new file mode 100644
index 0000000..aef27d4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sched_yield.rs
@@ -0,0 +1,14 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sched_yield()`
+/// Yields execution of the thread
+#[instrument(level = "trace", skip_all, ret)]
+pub fn sched_yield<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+) -> Result<Errno, WasiError> {
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+
+    //trace!("wasi[{}:{}]::sched_yield", ctx.data().pid(), ctx.data().tid());
+    thread_sleep_internal::<M>(ctx, 0)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_accept.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_accept.rs
new file mode 100644
index 0000000..727bf85
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_accept.rs
@@ -0,0 +1,160 @@
+use std::task::Waker;
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_accept()`
+/// Accept a new incoming connection.
+/// Note: This is similar to `accept` in POSIX.
+///
+/// ## Parameters
+///
+/// * `fd` - The listening socket.
+/// * `flags` - The desired values of the file descriptor flags.
+///
+/// ## Return
+///
+/// New socket connection
+#[instrument(level = "debug", skip_all, fields(%sock, fd = field::Empty), ret)]
+pub fn sock_accept<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    fd_flags: Fdflags,
+    ro_fd: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    let env = ctx.data();
+    let (memory, state, _) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+
+    let (fd, _, _) = wasi_try_ok!(sock_accept_internal(env, sock, fd_flags, nonblocking)?);
+
+    wasi_try_mem_ok!(ro_fd.write(&memory, fd));
+
+    Ok(Errno::Success)
+}
+
+/// ### `sock_accept_v2()`
+/// Accept a new incoming connection.
+/// Note: This is similar to `accept` in POSIX.
+///
+/// ## Parameters
+///
+/// * `fd` - The listening socket.
+/// * `flags` - The desired values of the file descriptor flags.
+/// * `ro_addr` - Returns the address and port of the client
+///
+/// ## Return
+///
+/// New socket connection
+#[instrument(level = "debug", skip_all, fields(%sock, fd = field::Empty), ret)]
+pub fn sock_accept_v2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    fd_flags: Fdflags,
+    ro_fd: WasmPtr<WasiFd, M>,
+    ro_addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let (memory, state, _) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let nonblocking = fd_flags.contains(Fdflags::NONBLOCK);
+
+    let (fd, local_addr, peer_addr) =
+        wasi_try_ok!(sock_accept_internal(env, sock, fd_flags, nonblocking)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_accepted(
+            &mut ctx,
+            sock,
+            fd,
+            local_addr,
+            peer_addr,
+            fd_flags,
+            nonblocking,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save sock_accepted event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, state, _) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    wasi_try_mem_ok!(ro_fd.write(&memory, fd));
+    wasi_try_ok!(crate::net::write_ip_port(
+        &memory,
+        ro_addr,
+        peer_addr.ip(),
+        peer_addr.port()
+    ));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_accept_internal(
+    env: &WasiEnv,
+    sock: WasiFd,
+    mut fd_flags: Fdflags,
+    mut nonblocking: bool,
+) -> Result<Result<(WasiFd, SocketAddr, SocketAddr), Errno>, WasiError> {
+    let state = env.state();
+    let inodes = &state.inodes;
+
+    let tasks = env.tasks().clone();
+    let (child, local_addr, peer_addr, fd_flags) = wasi_try_ok_ok!(__sock_asyncify(
+        env,
+        sock,
+        Rights::SOCK_ACCEPT,
+        move |socket, fd| async move {
+            if fd.flags.contains(Fdflags::NONBLOCK) {
+                fd_flags.set(Fdflags::NONBLOCK, true);
+                nonblocking = true;
+            }
+            let timeout = socket
+                .opt_time(TimeType::AcceptTimeout)
+                .ok()
+                .flatten()
+                .unwrap_or(Duration::from_secs(30));
+            let local_addr = socket.addr_local()?;
+            socket
+                .accept(tasks.deref(), nonblocking, Some(timeout))
+                .await
+                .map(|a| (a.0, local_addr, a.1, fd_flags))
+        },
+    ));
+
+    let kind = Kind::Socket {
+        socket: InodeSocket::new(InodeSocketKind::TcpStream {
+            socket: child,
+            write_timeout: None,
+            read_timeout: None,
+        }),
+    };
+    let inode = state
+        .fs
+        .create_inode_with_default_stat(inodes, kind, false, "socket".into());
+
+    let mut new_flags = Fdflags::empty();
+    if fd_flags.contains(Fdflags::NONBLOCK) {
+        new_flags.set(Fdflags::NONBLOCK, true);
+    }
+
+    let mut new_flags = Fdflags::empty();
+    if fd_flags.contains(Fdflags::NONBLOCK) {
+        new_flags.set(Fdflags::NONBLOCK, true);
+    }
+
+    let rights = Rights::all_socket();
+    let fd = wasi_try_ok_ok!(state.fs.create_fd(rights, rights, new_flags, 0, inode));
+    Span::current().record("fd", fd);
+
+    Ok(Ok((fd, local_addr, peer_addr)))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_local.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_local.rs
new file mode 100644
index 0000000..ac329bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_local.rs
@@ -0,0 +1,38 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_addr_local()`
+/// Returns the local address to which the socket is bound.
+///
+/// Note: This is similar to `getsockname` in POSIX
+///
+/// When successful, the contents of the output buffer consist of an IP address,
+/// either IP4 or IP6.
+///
+/// ## Parameters
+///
+/// * `fd` - Socket that the address is bound to
+#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+pub fn sock_addr_local<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ret_addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Errno {
+    let addr = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| socket.addr_local()
+    ));
+
+    Span::current().record("addr", &format!("{:?}", addr));
+
+    let memory = unsafe { ctx.data().memory_view(&ctx) };
+    wasi_try!(crate::net::write_ip_port(
+        &memory,
+        ret_addr,
+        addr.ip(),
+        addr.port()
+    ));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs
new file mode 100644
index 0000000..c49aea0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_addr_peer.rs
@@ -0,0 +1,38 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_addr_peer()`
+/// Returns the remote address to which the socket is connected to.
+///
+/// Note: This is similar to `getpeername` in POSIX
+///
+/// When successful, the contents of the output buffer consist of an IP address,
+/// either IP4 or IP6.
+///
+/// ## Parameters
+///
+/// * `fd` - Socket that the address is bound to
+#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+pub fn sock_addr_peer<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ro_addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Errno {
+    let addr = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| socket.addr_peer()
+    ));
+    Span::current().record("addr", &format!("{:?}", addr));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try!(crate::net::write_ip_port(
+        &memory,
+        ro_addr,
+        addr.ip(),
+        addr.port()
+    ));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_bind.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_bind.rs
new file mode 100644
index 0000000..ca030f4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_bind.rs
@@ -0,0 +1,55 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_bind()`
+/// Bind a socket
+/// Note: This is similar to `bind` in POSIX using PF_INET
+///
+/// ## Parameters
+///
+/// * `fd` - File descriptor of the socket to be bind
+/// * `addr` - Address to bind the socket to
+#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+pub fn sock_bind<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let addr = wasi_try_ok!(crate::net::read_ip_port(&memory, addr));
+    let addr = SocketAddr::new(addr.0, addr.1);
+    Span::current().record("addr", &format!("{:?}", addr));
+
+    wasi_try_ok!(sock_bind_internal(&mut ctx, sock, addr)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_bind(&mut ctx, sock, addr).map_err(|err| {
+            tracing::error!("failed to save sock_bind event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_bind_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    addr: SocketAddr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+
+    let tasks = ctx.data().tasks().clone();
+    wasi_try_ok_ok!(__sock_upgrade(
+        ctx,
+        sock,
+        Rights::SOCK_BIND,
+        move |socket| async move { socket.bind(tasks.deref(), net.deref(), addr).await }
+    ));
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_connect.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_connect.rs
new file mode 100644
index 0000000..e935bec
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_connect.rs
@@ -0,0 +1,65 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_connect()`
+/// Initiate a connection on a socket to the specified address
+///
+/// Polling the socket handle will wait for data to arrive or for
+/// the socket status to change which can be queried via 'sock_status'
+///
+/// Note: This is similar to `connect` in POSIX
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `addr` - Address of the socket to connect to
+#[instrument(level = "debug", skip_all, fields(%sock, addr = field::Empty), ret)]
+pub fn sock_connect<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let addr = wasi_try_ok!(crate::net::read_ip_port(&memory, addr));
+    let peer_addr = SocketAddr::new(addr.0, addr.1);
+    Span::current().record("addr", &format!("{:?}", peer_addr));
+
+    wasi_try_ok!(sock_connect_internal(&mut ctx, sock, peer_addr)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        let local_addr = wasi_try_ok!(__sock_actor(
+            &mut ctx,
+            sock,
+            Rights::empty(),
+            |socket, _| socket.addr_local()
+        ));
+        JournalEffector::save_sock_connect(&mut ctx, sock, local_addr, peer_addr).map_err(
+            |err| {
+                tracing::error!("failed to save sock_connected event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_connect_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    addr: SocketAddr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    let tasks = ctx.data().tasks().clone();
+    wasi_try_ok_ok!(__sock_upgrade(
+        ctx,
+        sock,
+        Rights::SOCK_CONNECT,
+        move |mut socket| async move { socket.connect(tasks.deref(), net.deref(), addr, None).await }
+    ));
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
new file mode 100644
index 0000000..5408360
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_flag.rs
@@ -0,0 +1,37 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_get_opt_flag()`
+/// Retrieve status of particular socket seting
+/// Note: This is similar to `getsockopt` in POSIX for SO_REUSEADDR
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `sockopt` - Socket option to be retrieved
+#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+pub fn sock_get_opt_flag<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    ret_flag: WasmPtr<Bool, M>,
+) -> Errno {
+    let option: crate::net::socket::WasiSocketOption = opt.into();
+    let flag = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| socket.get_opt_flag(option)
+    ));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let flag = match flag {
+        false => Bool::False,
+        true => Bool::True,
+    };
+
+    wasi_try_mem!(ret_flag.write(&memory, flag));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs
new file mode 100644
index 0000000..cedb2cd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_size.rs
@@ -0,0 +1,39 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_get_opt_size()`
+/// Retrieve the size of particular option for this socket
+/// Note: This is similar to `getsockopt` in POSIX for SO_RCVBUF
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `sockopt` - Socket option to be retrieved
+#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+pub fn sock_get_opt_size<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    ret_size: WasmPtr<Filesize, M>,
+) -> Errno {
+    let size = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| match opt {
+            Sockoption::RecvBufSize => socket.recv_buf_size().map(|a| a as Filesize),
+            Sockoption::SendBufSize => socket.send_buf_size().map(|a| a as Filesize),
+            Sockoption::Ttl => socket.ttl().map(|a| a as Filesize),
+            Sockoption::MulticastTtlV4 => {
+                socket.multicast_ttl_v4().map(|a| a as Filesize)
+            }
+            _ => Err(Errno::Inval),
+        }
+    ));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem!(ret_size.write(&memory, size));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs
new file mode 100644
index 0000000..02e8386
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_get_opt_time.rs
@@ -0,0 +1,51 @@
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_get_opt_time()`
+/// Retrieve one of the times on the socket
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `sockopt` - Socket option to be retrieved
+#[instrument(level = "debug", skip_all, fields(%sock, %opt), ret)]
+pub fn sock_get_opt_time<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    ret_time: WasmPtr<OptionTimestamp, M>,
+) -> Errno {
+    let ty = match opt {
+        Sockoption::RecvTimeout => TimeType::ReadTimeout,
+        Sockoption::SendTimeout => TimeType::WriteTimeout,
+        Sockoption::ConnectTimeout => TimeType::ConnectTimeout,
+        Sockoption::AcceptTimeout => TimeType::AcceptTimeout,
+        Sockoption::Linger => TimeType::Linger,
+        _ => return Errno::Inval,
+    };
+
+    let time = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| socket.opt_time(ty)
+    ));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let time = match time {
+        None => OptionTimestamp {
+            tag: OptionTag::None,
+            u: 0,
+        },
+        Some(timeout) => OptionTimestamp {
+            tag: OptionTag::Some,
+            u: timeout.as_nanos() as Timestamp,
+        },
+    };
+
+    wasi_try_mem!(ret_time.write(&memory, time));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs
new file mode 100644
index 0000000..56ef67e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v4.rs
@@ -0,0 +1,52 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_join_multicast_v4()`
+/// Joins a particular multicast IPv4 group
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `multiaddr` - Multicast group to joined
+/// * `interface` - Interface that will join
+#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+pub fn sock_join_multicast_v4<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: WasmPtr<__wasi_addr_ip4_t, M>,
+    iface: WasmPtr<__wasi_addr_ip4_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let multiaddr = wasi_try_ok!(crate::net::read_ip_v4(&memory, multiaddr));
+    let iface = wasi_try_ok!(crate::net::read_ip_v4(&memory, iface));
+
+    wasi_try_ok!(sock_join_multicast_v4_internal(
+        &mut ctx, sock, multiaddr, iface
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_join_ipv4_multicast(&mut ctx, sock, multiaddr, iface).map_err(
+            |err| {
+                tracing::error!("failed to save sock_join_ipv4_multicast event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_join_multicast_v4_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: Ipv4Addr,
+    iface: Ipv4Addr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    wasi_try_ok_ok!(__sock_actor_mut(ctx, sock, Rights::empty(), |socket, _| {
+        socket.join_multicast_v4(multiaddr, iface)
+    }));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs
new file mode 100644
index 0000000..420ddfb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_join_multicast_v6.rs
@@ -0,0 +1,51 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_join_multicast_v6()`
+/// Joins a particular multicast IPv6 group
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `multiaddr` - Multicast group to joined
+/// * `interface` - Interface that will join
+#[instrument(level = "debug", skip_all, fields(%sock, %iface), ret)]
+pub fn sock_join_multicast_v6<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: WasmPtr<__wasi_addr_ip6_t, M>,
+    iface: u32,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let multiaddr = wasi_try_ok!(crate::net::read_ip_v6(&memory, multiaddr));
+
+    wasi_try_ok!(sock_join_multicast_v6_internal(
+        &mut ctx, sock, multiaddr, iface
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_join_ipv6_multicast(&mut ctx, sock, multiaddr, iface).map_err(
+            |err| {
+                tracing::error!("failed to save sock_join_ipv6_multicast event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_join_multicast_v6_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: Ipv6Addr,
+    iface: u32,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    wasi_try_ok_ok!(__sock_actor_mut(ctx, sock, Rights::empty(), |socket, _| {
+        socket.join_multicast_v6(multiaddr, iface)
+    }));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs
new file mode 100644
index 0000000..b668c62
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v4.rs
@@ -0,0 +1,52 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_leave_multicast_v4()`
+/// Leaves a particular multicast IPv4 group
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `multiaddr` - Multicast group to leave
+/// * `interface` - Interface that will left
+#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+pub fn sock_leave_multicast_v4<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: WasmPtr<__wasi_addr_ip4_t, M>,
+    iface: WasmPtr<__wasi_addr_ip4_t, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let multiaddr = wasi_try_ok!(crate::net::read_ip_v4(&memory, multiaddr));
+    let iface = wasi_try_ok!(crate::net::read_ip_v4(&memory, iface));
+
+    wasi_try_ok!(sock_leave_multicast_v4_internal(
+        &mut ctx, sock, multiaddr, iface
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_leave_ipv4_multicast(&mut ctx, sock, multiaddr, iface).map_err(
+            |err| {
+                tracing::error!("failed to save sock_leave_ipv4_multicast event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_leave_multicast_v4_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: Ipv4Addr,
+    iface: Ipv4Addr,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    wasi_try_ok_ok!(__sock_actor_mut(ctx, sock, Rights::empty(), |socket, _| {
+        socket.leave_multicast_v4(multiaddr, iface)
+    }));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs
new file mode 100644
index 0000000..886bfd5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_leave_multicast_v6.rs
@@ -0,0 +1,54 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_leave_multicast_v6()`
+/// Leaves a particular multicast IPv6 group
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `multiaddr` - Multicast group to leave
+/// * `interface` - Interface that will left
+#[instrument(level = "debug", skip_all, fields(%sock, %iface), ret)]
+pub fn sock_leave_multicast_v6<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: WasmPtr<__wasi_addr_ip6_t, M>,
+    iface: u32,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let multiaddr = wasi_try_ok!(crate::net::read_ip_v6(&memory, multiaddr));
+
+    wasi_try_ok!(sock_leave_multicast_v6_internal(
+        &mut ctx, sock, multiaddr, iface
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_leave_ipv6_multicast(&mut ctx, sock, multiaddr, iface).map_err(
+            |err| {
+                tracing::error!("failed to save sock_leave_ipv6_multicast event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            },
+        )?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_leave_multicast_v6_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    multiaddr: Ipv6Addr,
+    iface: u32,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    wasi_try_ok_ok!(__sock_actor_mut(
+        ctx,
+        sock,
+        Rights::empty(),
+        |mut socket, _| socket.leave_multicast_v6(multiaddr, iface)
+    ));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_listen.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_listen.rs
new file mode 100644
index 0000000..1bc969e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_listen.rs
@@ -0,0 +1,56 @@
+use super::*;
+use crate::{journal::SnapshotTrigger, syscalls::*};
+
+/// ### `sock_listen()`
+/// Listen for connections on a socket
+///
+/// Polling the socket handle will wait until a connection
+/// attempt is made
+///
+/// Note: This is similar to `listen`
+///
+/// ## Parameters
+///
+/// * `fd` - File descriptor of the socket to be bind
+/// * `backlog` - Maximum size of the queue for pending connections
+#[instrument(level = "debug", skip_all, fields(%sock, %backlog), ret)]
+pub fn sock_listen<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    backlog: M::Offset,
+) -> Result<Errno, WasiError> {
+    ctx = wasi_try_ok!(maybe_snapshot_once::<M>(ctx, SnapshotTrigger::FirstListen)?);
+
+    let env = ctx.data();
+    let backlog: usize = wasi_try_ok!(backlog.try_into().map_err(|_| Errno::Inval));
+
+    wasi_try_ok!(sock_listen_internal(&mut ctx, sock, backlog)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_listen(&mut ctx, sock, backlog).map_err(|err| {
+            tracing::error!("failed to save sock_listen event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_listen_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    backlog: usize,
+) -> Result<Result<(), Errno>, WasiError> {
+    let env = ctx.data();
+    let net = env.net().clone();
+    let tasks = ctx.data().tasks().clone();
+    wasi_try_ok_ok!(__sock_upgrade(
+        ctx,
+        sock,
+        Rights::SOCK_LISTEN,
+        |socket| async move { socket.listen(tasks.deref(), net.deref(), backlog).await }
+    ));
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_open.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_open.rs
new file mode 100644
index 0000000..02eb651
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_open.rs
@@ -0,0 +1,110 @@
+use super::*;
+use crate::{net::socket::SocketProperties, syscalls::*};
+
+/// ### `sock_open()`
+/// Create an endpoint for communication.
+///
+/// creates an endpoint for communication and returns a file descriptor
+/// tor that refers to that endpoint. The file descriptor returned by a successful
+/// call will be the lowest-numbered file descriptor not currently open
+/// for the process.
+///
+/// Note: This is similar to `socket` in POSIX using PF_INET
+///
+/// ## Parameters
+///
+/// * `af` - Address family
+/// * `socktype` - Socket type, either datagram or stream
+/// * `sock_proto` - Socket protocol
+///
+/// ## Return
+///
+/// The file descriptor of the socket that has been opened.
+#[instrument(level = "debug", skip_all, fields(?af, ?ty, ?pt, sock = field::Empty), ret)]
+pub fn sock_open<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    af: Addressfamily,
+    ty: Socktype,
+    pt: SockProto,
+    ro_sock: WasmPtr<WasiFd, M>,
+) -> Result<Errno, WasiError> {
+    // only certain combinations are supported
+    match pt {
+        SockProto::Tcp => {
+            if ty != Socktype::Stream {
+                return Ok(Errno::Notsup);
+            }
+        }
+        SockProto::Udp => {
+            if ty != Socktype::Dgram {
+                return Ok(Errno::Notsup);
+            }
+        }
+        _ => {}
+    }
+
+    let fd = wasi_try_ok!(sock_open_internal(&mut ctx, af, ty, pt)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_open(&mut ctx, af, ty, pt, fd).map_err(|err| {
+            tracing::error!("failed to save sock_open event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+    wasi_try_mem_ok!(ro_sock.write(&memory, fd));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_open_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    af: Addressfamily,
+    ty: Socktype,
+    pt: SockProto,
+) -> Result<Result<WasiFd, Errno>, WasiError> {
+    let env = ctx.data();
+    let (memory, state, inodes) = unsafe { env.get_memory_and_wasi_state_and_inodes(&ctx, 0) };
+
+    let kind = match ty {
+        Socktype::Stream | Socktype::Dgram => Kind::Socket {
+            socket: InodeSocket::new(InodeSocketKind::PreSocket {
+                props: SocketProperties {
+                    family: af,
+                    ty,
+                    pt,
+                    only_v6: false,
+                    reuse_port: false,
+                    reuse_addr: false,
+                    no_delay: None,
+                    keep_alive: None,
+                    dont_route: None,
+                    send_buf_size: None,
+                    recv_buf_size: None,
+                    write_timeout: None,
+                    read_timeout: None,
+                    accept_timeout: None,
+                    connect_timeout: None,
+                    handler: None,
+                },
+                addr: None,
+            }),
+        },
+        _ => return Ok(Err(Errno::Notsup)),
+    };
+
+    let inode =
+        state
+            .fs
+            .create_inode_with_default_stat(inodes, kind, false, "socket".to_string().into());
+    let rights = Rights::all_socket();
+    let fd = wasi_try_ok_ok!(state
+        .fs
+        .create_fd(rights, rights, Fdflags::empty(), 0, inode));
+    Span::current().record("sock", fd);
+
+    Ok(Ok(fd))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv.rs
new file mode 100644
index 0000000..565a80e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv.rs
@@ -0,0 +1,164 @@
+use std::{mem::MaybeUninit, task::Waker};
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_recv()`
+/// Receive a message from a socket.
+/// Note: This is similar to `recv` in POSIX, though it also supports reading
+/// the data into multiple buffers in the manner of `readv`.
+///
+/// ## Parameters
+///
+/// * `ri_data` - List of scatter/gather vectors to which to store data.
+/// * `ri_flags` - Message flags.
+///
+/// ## Return
+///
+/// Number of bytes stored in ri_data and message flags.
+#[instrument(level = "trace", skip_all, fields(%sock, nread = field::Empty), ret)]
+pub fn sock_recv<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
+    ri_data_len: M::Offset,
+    ri_flags: RiFlags,
+    ro_data_len: WasmPtr<M::Offset, M>,
+    ro_flags: WasmPtr<RoFlags, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let fd_entry = wasi_try_ok!(env.state.fs.get_fd(sock));
+    let guard = fd_entry.inode.read();
+    let use_read = matches!(guard.deref(), Kind::Pipe { .. });
+    drop(guard);
+    if use_read {
+        fd_read(ctx, sock, ri_data, ri_data_len, ro_data_len)
+    } else {
+        let pid = ctx.data().pid();
+        let tid = ctx.data().tid();
+
+        let res = sock_recv_internal::<M>(
+            &mut ctx,
+            sock,
+            ri_data,
+            ri_data_len,
+            ri_flags,
+            ro_data_len,
+            ro_flags,
+        )?;
+
+        sock_recv_internal_handler(ctx, res, ro_data_len, ro_flags)
+    }
+}
+
+pub(super) fn sock_recv_internal_handler<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    res: Result<usize, Errno>,
+    ro_data_len: WasmPtr<M::Offset, M>,
+    ro_flags: WasmPtr<RoFlags, M>,
+) -> Result<Errno, WasiError> {
+    let mut ret = Errno::Success;
+    let bytes_read = match res {
+        Ok(bytes_read) => {
+            trace!(
+                %bytes_read,
+            );
+            bytes_read
+        }
+        Err(err) => {
+            let socket_err = err.name();
+            trace!(
+                %socket_err,
+            );
+            ret = err;
+            0
+        }
+    };
+    Span::current().record("nread", bytes_read);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let bytes_read: M::Offset = wasi_try_ok!(bytes_read.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(ro_flags.write(&memory, 0));
+    wasi_try_mem_ok!(ro_data_len.write(&memory, bytes_read));
+
+    Ok(ret)
+}
+
+/// ### `sock_recv()`
+/// Receive a message from a socket.
+/// Note: This is similar to `recv` in POSIX, though it also supports reading
+/// the data into multiple buffers in the manner of `readv`.
+///
+/// ## Parameters
+///
+/// * `ri_data` - List of scatter/gather vectors to which to store data.
+/// * `ri_flags` - Message flags.
+///
+/// ## Return
+///
+/// Number of bytes stored in ri_data and message flags.
+pub(super) fn sock_recv_internal<M: MemorySize>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
+    ri_data_len: M::Offset,
+    ri_flags: RiFlags,
+    ro_data_len: WasmPtr<M::Offset, M>,
+    ro_flags: WasmPtr<RoFlags, M>,
+) -> WasiResult<usize> {
+    wasi_try_ok_ok!(WasiEnv::process_signals_and_exit(ctx)?);
+
+    let mut env = ctx.data();
+    let memory = unsafe { env.memory_view(ctx) };
+
+    let peek = (ri_flags & __WASI_SOCK_RECV_INPUT_PEEK) != 0;
+    let data = wasi_try_ok_ok!(__sock_asyncify(
+        env,
+        sock,
+        Rights::SOCK_RECV,
+        |socket, fd| async move {
+            let iovs_arr = ri_data
+                .slice(&memory, ri_data_len)
+                .map_err(mem_error_to_wasi)?;
+            let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+
+            let mut total_read = 0;
+            for iovs in iovs_arr.iter() {
+                let mut buf = WasmPtr::<u8, M>::new(iovs.buf)
+                    .slice(&memory, iovs.buf_len)
+                    .map_err(mem_error_to_wasi)?
+                    .access()
+                    .map_err(mem_error_to_wasi)?;
+
+                let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                let timeout = socket
+                    .opt_time(TimeType::ReadTimeout)
+                    .ok()
+                    .flatten()
+                    .unwrap_or(Duration::from_secs(30));
+
+                let local_read = match socket
+                    .recv(
+                        env.tasks().deref(),
+                        buf.as_mut_uninit(),
+                        Some(timeout),
+                        nonblocking,
+                    )
+                    .await
+                {
+                    Ok(s) => s,
+                    Err(_) if total_read > 0 => break,
+                    Err(err) => return Err(err),
+                };
+                total_read += local_read;
+                if local_read != buf.len() {
+                    break;
+                }
+            }
+            Ok(total_read)
+        }
+    ));
+    Ok(Ok(data))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv_from.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv_from.rs
new file mode 100644
index 0000000..17df5ba
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_recv_from.rs
@@ -0,0 +1,146 @@
+use std::{mem::MaybeUninit, task::Waker};
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_recv_from()`
+/// Receive a message and its peer address from a socket.
+/// Note: This is similar to `recvfrom` in POSIX, though it also supports reading
+/// the data into multiple buffers in the manner of `readv`.
+///
+/// ## Parameters
+///
+/// * `ri_data` - List of scatter/gather vectors to which to store data.
+/// * `ri_flags` - Message flags.
+///
+/// ## Return
+///
+/// Number of bytes stored in ri_data and message flags.
+#[instrument(level = "trace", skip_all, fields(%sock, nread = field::Empty, peer = field::Empty), ret)]
+pub fn sock_recv_from<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
+    ri_data_len: M::Offset,
+    ri_flags: RiFlags,
+    ro_data_len: WasmPtr<M::Offset, M>,
+    ro_flags: WasmPtr<RoFlags, M>,
+    ro_addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<Errno, WasiError> {
+    sock_recv_from_internal(
+        ctx,
+        sock,
+        ri_data,
+        ri_data_len,
+        ri_flags,
+        ro_data_len,
+        ro_flags,
+        ro_addr,
+    )
+}
+
+pub(super) fn sock_recv_from_internal<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ri_data: WasmPtr<__wasi_iovec_t<M>, M>,
+    ri_data_len: M::Offset,
+    _ri_flags: RiFlags,
+    ro_data_len: WasmPtr<M::Offset, M>,
+    ro_flags: WasmPtr<RoFlags, M>,
+    ro_addr: WasmPtr<__wasi_addr_port_t, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let mut env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let iovs_arr = wasi_try_mem_ok!(ri_data.slice(&memory, ri_data_len));
+
+    let max_size = {
+        let mut max_size = 0usize;
+        for iovs in iovs_arr.iter() {
+            let iovs = wasi_try_mem_ok!(iovs.read());
+            let buf_len: usize = wasi_try_ok!(iovs.buf_len.try_into().map_err(|_| Errno::Overflow));
+            max_size += buf_len;
+        }
+        max_size
+    };
+
+    let (bytes_read, peer) = {
+        if max_size <= 10240 {
+            let mut buf: [MaybeUninit<u8>; 10240] = unsafe { MaybeUninit::uninit().assume_init() };
+            let writer = &mut buf[..max_size];
+            let (amt, peer) = wasi_try_ok!(__sock_asyncify(
+                env,
+                sock,
+                Rights::SOCK_RECV,
+                |socket, fd| async move {
+                    let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                    let timeout = socket
+                        .opt_time(TimeType::ReadTimeout)
+                        .ok()
+                        .flatten()
+                        .unwrap_or(Duration::from_secs(30));
+                    socket
+                        .recv_from(env.tasks().deref(), writer, Some(timeout), nonblocking)
+                        .await
+                },
+            ));
+
+            if amt > 0 {
+                let buf: &[MaybeUninit<u8>] = &buf[..amt];
+                let buf: &[u8] = unsafe { std::mem::transmute(buf) };
+                wasi_try_ok!(copy_from_slice(buf, &memory, iovs_arr).map(|_| (amt, peer)))
+            } else {
+                (amt, peer)
+            }
+        } else {
+            let (data, peer) = wasi_try_ok!(__sock_asyncify(
+                env,
+                sock,
+                Rights::SOCK_RECV_FROM,
+                |socket, fd| async move {
+                    let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                    let timeout = socket
+                        .opt_time(TimeType::ReadTimeout)
+                        .ok()
+                        .flatten()
+                        .unwrap_or(Duration::from_secs(30));
+
+                    let mut buf = Vec::with_capacity(max_size);
+                    unsafe {
+                        buf.set_len(max_size);
+                    }
+                    socket
+                        .recv_from(env.tasks().deref(), &mut buf, Some(timeout), nonblocking)
+                        .await
+                        .map(|(amt, addr)| {
+                            unsafe {
+                                buf.set_len(amt);
+                            }
+                            let buf: Vec<u8> = unsafe { std::mem::transmute(buf) };
+                            (buf, addr)
+                        })
+                }
+            ));
+
+            let data_len = data.len();
+            if data_len > 0 {
+                let mut reader = &data[..];
+                wasi_try_ok!(read_bytes(reader, &memory, iovs_arr).map(|_| (data_len, peer)))
+            } else {
+                (0, peer)
+            }
+        }
+    };
+    Span::current()
+        .record("nread", bytes_read)
+        .record("peer", &format!("{:?}", peer));
+
+    wasi_try_ok!(write_ip_port(&memory, ro_addr, peer.ip(), peer.port()));
+
+    let bytes_read: M::Offset = wasi_try_ok!(bytes_read.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(ro_flags.write(&memory, 0));
+    wasi_try_mem_ok!(ro_data_len.write(&memory, bytes_read));
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send.rs
new file mode 100644
index 0000000..c1ae785
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send.rs
@@ -0,0 +1,160 @@
+use std::{mem::MaybeUninit, task::Waker};
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_send()`
+/// Send a message on a socket.
+/// Note: This is similar to `send` in POSIX, though it also supports writing
+/// the data from multiple buffers in the manner of `writev`.
+///
+/// ## Parameters
+///
+/// * `si_data` - List of scatter/gather vectors to which to retrieve data
+/// * `si_flags` - Message flags.
+///
+/// ## Return
+///
+/// Number of bytes transmitted.
+#[instrument(level = "trace", skip_all, fields(%fd, nsent = field::Empty), ret)]
+pub fn sock_send<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    fd: WasiFd,
+    si_data: WasmPtr<__wasi_ciovec_t<M>, M>,
+    si_data_len: M::Offset,
+    si_flags: SiFlags,
+    ret_data_len: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let env = ctx.data();
+    let fd_entry = env.state.fs.get_fd(fd).unwrap();
+    let guard = fd_entry.inode.read();
+    let use_write = matches!(guard.deref(), Kind::Pipe { .. });
+    drop(guard);
+
+    let bytes_written = if use_write {
+        let offset = {
+            let state = env.state.clone();
+            let inodes = state.inodes.clone();
+
+            let fd_entry = wasi_try_ok!(state.fs.get_fd(fd));
+            fd_entry.offset.load(Ordering::Acquire) as usize
+        };
+
+        wasi_try_ok!(fd_write_internal::<M>(
+            &ctx,
+            fd,
+            FdWriteSource::Iovs {
+                iovs: si_data,
+                iovs_len: si_data_len
+            },
+            offset as u64,
+            true,
+            env.enable_journal,
+        )?)
+    } else {
+        wasi_try_ok!(sock_send_internal::<M>(
+            &ctx,
+            fd,
+            FdWriteSource::Iovs {
+                iovs: si_data,
+                iovs_len: si_data_len
+            },
+            si_flags,
+        )?)
+    };
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_send(&ctx, fd, bytes_written, si_data, si_data_len, si_flags)
+            .map_err(|err| {
+                tracing::error!("failed to save sock_send event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+    }
+
+    Span::current().record("nsent", bytes_written);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let bytes_written: M::Offset =
+        wasi_try_ok!(bytes_written.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(ret_data_len.write(&memory, bytes_written));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_send_internal<M: MemorySize>(
+    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    si_data: FdWriteSource<'_, M>,
+    si_flags: SiFlags,
+) -> Result<Result<usize, Errno>, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let runtime = env.runtime.clone();
+
+    let bytes_written = wasi_try_ok_ok!(__sock_asyncify(
+        env,
+        sock,
+        Rights::SOCK_SEND,
+        |socket, fd| async move {
+            let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+            let timeout = socket
+                .opt_time(TimeType::WriteTimeout)
+                .ok()
+                .flatten()
+                .unwrap_or(Duration::from_secs(30));
+
+            match si_data {
+                FdWriteSource::Iovs { iovs, iovs_len } => {
+                    let iovs_arr = iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                    let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+
+                    let mut sent = 0usize;
+                    for iovs in iovs_arr.iter() {
+                        let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                            .slice(&memory, iovs.buf_len)
+                            .map_err(mem_error_to_wasi)?
+                            .access()
+                            .map_err(mem_error_to_wasi)?;
+                        let local_sent = match socket
+                            .send(
+                                env.tasks().deref(),
+                                buf.as_ref(),
+                                Some(timeout),
+                                nonblocking,
+                            )
+                            .await
+                        {
+                            Ok(s) => s,
+                            Err(_) if sent > 0 => break,
+                            Err(err) => return Err(err),
+                        };
+                        sent += local_sent;
+                        if local_sent != buf.len() {
+                            break;
+                        }
+                    }
+                    Ok(sent)
+                }
+                FdWriteSource::Buffer(data) => {
+                    socket
+                        .send(
+                            env.tasks().deref(),
+                            data.as_ref(),
+                            Some(timeout),
+                            nonblocking,
+                        )
+                        .await
+                }
+            }
+        }
+    ));
+    trace!(
+        %bytes_written,
+    );
+
+    Ok(Ok(bytes_written))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_file.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_file.rs
new file mode 100644
index 0000000..70419d7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_file.rs
@@ -0,0 +1,235 @@
+use virtual_fs::AsyncReadExt;
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*, WasiInodes};
+
+/// ### `sock_send_file()`
+/// Sends the entire contents of a file down a socket
+///
+/// ## Parameters
+///
+/// * `in_fd` - Open file that has the data to be transmitted
+/// * `offset` - Offset into the file to start reading at
+/// * `count` - Number of bytes to be sent
+///
+/// ## Return
+///
+/// Number of bytes transmitted.
+#[instrument(level = "debug", skip_all, fields(%sock, %in_fd, %offset, %count, nsent = field::Empty), ret)]
+pub fn sock_send_file<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    in_fd: WasiFd,
+    offset: Filesize,
+    count: Filesize,
+    ret_sent: WasmPtr<Filesize, M>,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    let total_written = wasi_try_ok!(sock_send_file_internal(
+        &mut ctx, sock, in_fd, offset, count
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_send_file::<M>(&mut ctx, sock, in_fd, offset, total_written)
+            .map_err(|err| {
+                tracing::error!("failed to save sock_send_file event - {}", err);
+                WasiError::Exit(ExitCode::Errno(Errno::Fault))
+            })?;
+    }
+
+    Span::current().record("nsent", total_written);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem_ok!(ret_sent.write(&memory, total_written as Filesize));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_send_file_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    in_fd: WasiFd,
+    offset: Filesize,
+    mut count: Filesize,
+) -> Result<Result<Filesize, Errno>, WasiError> {
+    let mut env = ctx.data();
+    let net = env.net();
+    let tasks = env.tasks().clone();
+    let state = env.state.clone();
+
+    // Set the offset of the file
+    {
+        let mut fd_map = state.fs.fd_map.write().unwrap();
+        let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&in_fd).ok_or(Errno::Badf));
+        fd_entry.offset.store(offset, Ordering::Release);
+    }
+
+    // Enter a loop that will process all the data
+    let mut total_written: Filesize = 0;
+    while (count > 0) {
+        let sub_count = count.min(4096);
+        count -= sub_count;
+
+        let fd_entry = wasi_try_ok_ok!(state.fs.get_fd(in_fd));
+        let fd_flags = fd_entry.flags;
+
+        let data = {
+            match in_fd {
+                __WASI_STDIN_FILENO => {
+                    let mut stdin = wasi_try_ok_ok!(
+                        WasiInodes::stdin_mut(&state.fs.fd_map).map_err(fs_error_into_wasi_err)
+                    );
+                    let data = wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+                        // TODO: optimize with MaybeUninit
+                        let mut buf = vec![0u8; sub_count as usize];
+                        let amt = stdin.read(&mut buf[..]).await.map_err(map_io_err)?;
+                        buf.truncate(amt);
+                        Ok(buf)
+                    })?);
+                    env = ctx.data();
+                    data
+                }
+                __WASI_STDOUT_FILENO | __WASI_STDERR_FILENO => return Ok(Err(Errno::Inval)),
+                _ => {
+                    if !fd_entry.rights.contains(Rights::FD_READ) {
+                        // TODO: figure out the error to return when lacking rights
+                        return Ok(Err(Errno::Access));
+                    }
+
+                    let offset = fd_entry.offset.load(Ordering::Acquire) as usize;
+                    let inode = fd_entry.inode;
+                    let data = {
+                        let mut guard = inode.write();
+                        match guard.deref_mut() {
+                            Kind::File { handle, .. } => {
+                                if let Some(handle) = handle {
+                                    let data =
+                                        wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+                                            let mut buf = vec![0u8; sub_count as usize];
+
+                                            let mut handle = handle.write().unwrap();
+                                            handle
+                                                .seek(std::io::SeekFrom::Start(offset as u64))
+                                                .await
+                                                .map_err(map_io_err)?;
+                                            let amt = handle
+                                                .read(&mut buf[..])
+                                                .await
+                                                .map_err(map_io_err)?;
+                                            buf.truncate(amt);
+                                            Ok(buf)
+                                        })?);
+                                    env = ctx.data();
+                                    data
+                                } else {
+                                    return Ok(Err(Errno::Inval));
+                                }
+                            }
+                            Kind::Socket { socket, .. } => {
+                                let socket = socket.clone();
+                                let tasks = tasks.clone();
+                                drop(guard);
+
+                                let read_timeout = socket
+                                    .opt_time(TimeType::WriteTimeout)
+                                    .ok()
+                                    .flatten()
+                                    .unwrap_or(Duration::from_secs(30));
+
+                                let data = wasi_try_ok_ok!(__asyncify(ctx, None, async {
+                                    let mut buf = Vec::with_capacity(sub_count as usize);
+                                    unsafe {
+                                        buf.set_len(sub_count as usize);
+                                    }
+                                    socket
+                                        .recv(tasks.deref(), &mut buf, Some(read_timeout), false)
+                                        .await
+                                        .map(|amt| {
+                                            unsafe {
+                                                buf.set_len(amt);
+                                            }
+                                            let buf: Vec<u8> = unsafe { std::mem::transmute(buf) };
+                                            buf
+                                        })
+                                })?);
+                                env = ctx.data();
+                                data
+                            }
+                            Kind::Pipe { ref mut pipe, .. } => {
+                                let data = wasi_try_ok_ok!(__asyncify(ctx, None, async move {
+                                    // TODO: optimize with MaybeUninit
+                                    let mut buf = vec![0u8; sub_count as usize];
+                                    let amt = virtual_fs::AsyncReadExt::read(pipe, &mut buf[..])
+                                        .await
+                                        .map_err(map_io_err)?;
+                                    buf.truncate(amt);
+                                    Ok(buf)
+                                })?);
+                                env = ctx.data();
+                                data
+                            }
+                            Kind::Epoll { .. } => {
+                                return Ok(Err(Errno::Inval));
+                            }
+                            Kind::Dir { .. } | Kind::Root { .. } => {
+                                return Ok(Err(Errno::Isdir));
+                            }
+                            Kind::EventNotifications { .. } => {
+                                return Ok(Err(Errno::Inval));
+                            }
+                            Kind::Symlink { .. } => unimplemented!("Symlinks in wasi::fd_read"),
+                            Kind::Buffer { buffer } => {
+                                // TODO: optimize with MaybeUninit
+                                let mut buf = vec![0u8; sub_count as usize];
+
+                                let mut buf_read = &buffer[offset..];
+                                let amt = wasi_try_ok_ok!(std::io::Read::read(
+                                    &mut buf_read,
+                                    &mut buf[..]
+                                )
+                                .map_err(map_io_err));
+                                buf.truncate(amt);
+                                buf
+                            }
+                        }
+                    };
+
+                    // reborrow
+                    let mut fd_map = state.fs.fd_map.write().unwrap();
+                    let fd_entry = wasi_try_ok_ok!(fd_map.get_mut(&in_fd).ok_or(Errno::Badf));
+                    fd_entry
+                        .offset
+                        .fetch_add(data.len() as u64, Ordering::AcqRel);
+
+                    data
+                }
+            }
+        };
+
+        // Write it down to the socket
+        let tasks = ctx.data().tasks().clone();
+        let bytes_written = wasi_try_ok_ok!(__sock_asyncify_mut(
+            ctx,
+            sock,
+            Rights::SOCK_SEND,
+            |socket, fd| async move {
+                let write_timeout = socket
+                    .opt_time(TimeType::ReadTimeout)
+                    .ok()
+                    .flatten()
+                    .unwrap_or(Duration::from_secs(30));
+                socket
+                    .send(tasks.deref(), &data, Some(write_timeout), true)
+                    .await
+            },
+        ));
+        env = ctx.data();
+
+        total_written += bytes_written as u64;
+    }
+
+    Ok(Ok(total_written))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_to.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_to.rs
new file mode 100644
index 0000000..48ec746
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_send_to.rs
@@ -0,0 +1,156 @@
+use std::task::Waker;
+
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_send_to()`
+/// Send a message on a socket to a specific address.
+/// Note: This is similar to `sendto` in POSIX, though it also supports writing
+/// the data from multiple buffers in the manner of `writev`.
+///
+/// ## Parameters
+///
+/// * `si_data` - List of scatter/gather vectors to which to retrieve data
+/// * `si_flags` - Message flags.
+/// * `addr` - Address of the socket to send message to
+///
+/// ## Return
+///
+/// Number of bytes transmitted.
+#[instrument(level = "trace", skip_all, fields(%sock, ?addr, nsent = field::Empty), ret)]
+pub fn sock_send_to<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    si_data: WasmPtr<__wasi_ciovec_t<M>, M>,
+    si_data_len: M::Offset,
+    si_flags: SiFlags,
+    addr: WasmPtr<__wasi_addr_port_t, M>,
+    ret_data_len: WasmPtr<M::Offset, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let iovs_arr = wasi_try_mem_ok!(si_data.slice(&memory, si_data_len));
+
+    let (addr_ip, addr_port) = {
+        let memory = unsafe { env.memory_view(&ctx) };
+        wasi_try_ok!(read_ip_port(&memory, addr))
+    };
+    let addr = SocketAddr::new(addr_ip, addr_port);
+    Span::current().record("addr", &format!("{:?}", addr));
+
+    let bytes_written = wasi_try_ok!(sock_send_to_internal(
+        &ctx,
+        sock,
+        FdWriteSource::Iovs {
+            iovs: si_data,
+            iovs_len: si_data_len
+        },
+        si_flags,
+        addr,
+    )?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_send_to::<M>(
+            &ctx,
+            sock,
+            bytes_written,
+            si_data,
+            si_data_len,
+            addr,
+            si_flags,
+        )
+        .map_err(|err| {
+            tracing::error!("failed to save sock_send_to event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Span::current().record("nsent", bytes_written);
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let bytes_written: M::Offset =
+        wasi_try_ok!(bytes_written.try_into().map_err(|_| Errno::Overflow));
+    wasi_try_mem_ok!(ret_data_len.write(&memory, bytes_written));
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_send_to_internal<M: MemorySize>(
+    ctx: &FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    si_data: FdWriteSource<'_, M>,
+    _si_flags: SiFlags,
+    addr: SocketAddr,
+) -> Result<Result<usize, Errno>, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+
+    let bytes_written = {
+        wasi_try_ok_ok!(__sock_asyncify(
+            env,
+            sock,
+            Rights::SOCK_SEND_TO,
+            |socket, fd| async move {
+                let nonblocking = fd.flags.contains(Fdflags::NONBLOCK);
+                let timeout = socket
+                    .opt_time(TimeType::WriteTimeout)
+                    .ok()
+                    .flatten()
+                    .unwrap_or(Duration::from_secs(30));
+
+                match si_data {
+                    FdWriteSource::Iovs { iovs, iovs_len } => {
+                        let iovs_arr = iovs.slice(&memory, iovs_len).map_err(mem_error_to_wasi)?;
+                        let iovs_arr = iovs_arr.access().map_err(mem_error_to_wasi)?;
+
+                        let mut sent = 0usize;
+                        for iovs in iovs_arr.iter() {
+                            let buf = WasmPtr::<u8, M>::new(iovs.buf)
+                                .slice(&memory, iovs.buf_len)
+                                .map_err(mem_error_to_wasi)?
+                                .access()
+                                .map_err(mem_error_to_wasi)?;
+                            let local_sent = match socket
+                                .send_to::<M>(
+                                    env.tasks().deref(),
+                                    buf.as_ref(),
+                                    addr,
+                                    Some(timeout),
+                                    nonblocking,
+                                )
+                                .await
+                            {
+                                Ok(s) => s,
+                                Err(_) if sent > 0 => break,
+                                Err(err) => return Err(err),
+                            };
+                            sent += local_sent;
+                            if local_sent != buf.len() {
+                                break;
+                            }
+                        }
+                        Ok(sent)
+                    }
+                    FdWriteSource::Buffer(data) => {
+                        socket
+                            .send_to::<M>(
+                                env.tasks().deref(),
+                                data.as_ref(),
+                                addr,
+                                Some(timeout),
+                                nonblocking,
+                            )
+                            .await
+                    }
+                }
+            },
+        ))
+    };
+    trace!(
+        %bytes_written,
+    );
+
+    Ok(Ok(bytes_written))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs
new file mode 100644
index 0000000..9937795
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_flag.rs
@@ -0,0 +1,53 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_set_opt_flag()`
+/// Sets a particular socket setting
+/// Note: This is similar to `setsockopt` in POSIX for SO_REUSEADDR
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `sockopt` - Socket option to be set
+/// * `flag` - Value to set the option to
+#[instrument(level = "debug", skip_all, fields(%sock, %opt, %flag), ret)]
+pub fn sock_set_opt_flag(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    flag: Bool,
+) -> Result<Errno, WasiError> {
+    let flag = match flag {
+        Bool::False => false,
+        Bool::True => true,
+        _ => return Ok(Errno::Inval),
+    };
+
+    wasi_try_ok!(sock_set_opt_flag_internal(&mut ctx, sock, opt, flag)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_set_opt_flag(&mut ctx, sock, opt, flag).map_err(|err| {
+            tracing::error!("failed to save sock_set_opt_flag event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_set_opt_flag_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    flag: bool,
+) -> Result<Result<(), Errno>, WasiError> {
+    let option: crate::net::socket::WasiSocketOption = opt.into();
+    wasi_try_ok_ok!(__sock_actor_mut(
+        ctx,
+        sock,
+        Rights::empty(),
+        |mut socket, _| socket.set_opt_flag(option, flag)
+    ));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs
new file mode 100644
index 0000000..a9bdb84
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_size.rs
@@ -0,0 +1,62 @@
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_set_opt_size()
+/// Set size of particular option for this socket
+/// Note: This is similar to `setsockopt` in POSIX for SO_RCVBUF
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `opt` - Socket option to be set
+/// * `size` - Buffer size
+#[instrument(level = "debug", skip_all, fields(%sock, %opt, %size), ret)]
+pub fn sock_set_opt_size(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    size: Filesize,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(sock_set_opt_size_internal(&mut ctx, sock, opt, size)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_set_opt_size(&mut ctx, sock, opt, size).map_err(|err| {
+            tracing::error!("failed to save sock_set_opt_size event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_set_opt_size_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    size: Filesize,
+) -> Result<Result<(), Errno>, WasiError> {
+    let ty = match opt {
+        Sockoption::RecvTimeout => TimeType::ReadTimeout,
+        Sockoption::SendTimeout => TimeType::WriteTimeout,
+        Sockoption::ConnectTimeout => TimeType::ConnectTimeout,
+        Sockoption::AcceptTimeout => TimeType::AcceptTimeout,
+        Sockoption::Linger => TimeType::Linger,
+        _ => return Ok(Err(Errno::Inval)),
+    };
+
+    let option: crate::net::socket::WasiSocketOption = opt.into();
+    wasi_try_ok_ok!(__sock_actor_mut(
+        ctx,
+        sock,
+        Rights::empty(),
+        |mut socket, _| match opt {
+            Sockoption::RecvBufSize => socket.set_recv_buf_size(size as usize),
+            Sockoption::SendBufSize => socket.set_send_buf_size(size as usize),
+            Sockoption::Ttl => socket.set_ttl(size as u32),
+            Sockoption::MulticastTtlV4 => socket.set_multicast_ttl_v4(size as u32),
+            _ => Err(Errno::Inval),
+        }
+    ));
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs
new file mode 100644
index 0000000..6196cc5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_set_opt_time.rs
@@ -0,0 +1,62 @@
+use super::*;
+use crate::{net::socket::TimeType, syscalls::*};
+
+/// ### `sock_set_opt_time()`
+/// Sets one of the times the socket
+///
+/// ## Parameters
+///
+/// * `fd` - Socket descriptor
+/// * `sockopt` - Socket option to be set
+/// * `time` - Value to set the time to
+#[instrument(level = "debug", skip_all, fields(%sock, %opt, time = field::Empty), ret)]
+pub fn sock_set_opt_time<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    opt: Sockoption,
+    time: WasmPtr<OptionTimestamp, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let time = wasi_try_mem_ok!(time.read(&memory));
+    let time = match time.tag {
+        OptionTag::None => None,
+        OptionTag::Some => Some(Duration::from_nanos(time.u)),
+        _ => return Ok(Errno::Inval),
+    };
+    Span::current().record("time", &format!("{:?}", time));
+
+    let ty = match opt {
+        Sockoption::RecvTimeout => TimeType::ReadTimeout,
+        Sockoption::SendTimeout => TimeType::WriteTimeout,
+        Sockoption::ConnectTimeout => TimeType::ConnectTimeout,
+        Sockoption::AcceptTimeout => TimeType::AcceptTimeout,
+        Sockoption::Linger => TimeType::Linger,
+        _ => return Ok(Errno::Inval),
+    };
+
+    wasi_try_ok!(sock_set_opt_time_internal(&mut ctx, sock, ty, time)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_set_opt_time(&mut ctx, sock, ty, time).map_err(|err| {
+            tracing::error!("failed to save sock_set_opt_time event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_set_opt_time_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ty: TimeType,
+    time: Option<Duration>,
+) -> Result<Result<(), Errno>, WasiError> {
+    wasi_try_ok_ok!(__sock_actor_mut(ctx, sock, Rights::empty(), |socket, _| {
+        socket.set_opt_time(ty, time)
+    }));
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_shutdown.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_shutdown.rs
new file mode 100644
index 0000000..8ef8963
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_shutdown.rs
@@ -0,0 +1,53 @@
+use std::net::Shutdown;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_shutdown()`
+/// Shut down socket send and receive channels.
+/// Note: This is similar to `shutdown` in POSIX.
+///
+/// ## Parameters
+///
+/// * `how` - Which channels on the socket to shut down.
+#[instrument(level = "debug", skip_all, fields(%sock), ret)]
+pub fn sock_shutdown(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    how: SdFlags,
+) -> Result<Errno, WasiError> {
+    let both = __WASI_SHUT_RD | __WASI_SHUT_WR;
+    let shutdown = match how {
+        __WASI_SHUT_RD => std::net::Shutdown::Read,
+        __WASI_SHUT_WR => std::net::Shutdown::Write,
+        a if a == both => std::net::Shutdown::Both,
+        _ => return Ok(Errno::Inval),
+    };
+
+    wasi_try_ok!(sock_shutdown_internal(&mut ctx, sock, shutdown)?);
+
+    #[cfg(feature = "journal")]
+    if ctx.data().enable_journal {
+        JournalEffector::save_sock_shutdown(&mut ctx, sock, shutdown).map_err(|err| {
+            tracing::error!("failed to save sock_shutdown event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub(crate) fn sock_shutdown_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    shutdown: Shutdown,
+) -> Result<Result<(), Errno>, WasiError> {
+    wasi_try_ok_ok!(__sock_actor_mut(
+        ctx,
+        sock,
+        Rights::SOCK_SHUTDOWN,
+        |mut socket, _| socket.shutdown(shutdown)
+    ));
+
+    Ok(Ok(()))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_status.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_status.rs
new file mode 100644
index 0000000..81a7b96
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/sock_status.rs
@@ -0,0 +1,32 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `sock_status()`
+/// Returns the current status of a socket
+#[instrument(level = "debug", skip_all, fields(%sock, status = field::Empty), ret)]
+pub fn sock_status<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    sock: WasiFd,
+    ret_status: WasmPtr<Sockstatus, M>,
+) -> Errno {
+    let status = wasi_try!(__sock_actor(
+        &mut ctx,
+        sock,
+        Rights::empty(),
+        |socket, _| socket.status()
+    ));
+
+    use crate::net::socket::WasiSocketStatus;
+    let status = match status {
+        WasiSocketStatus::Opening => Sockstatus::Opening,
+        WasiSocketStatus::Opened => Sockstatus::Opened,
+        WasiSocketStatus::Closed => Sockstatus::Closed,
+        WasiSocketStatus::Failed => Sockstatus::Failed,
+    };
+    Span::current().record("status", &format!("{:?}", status));
+
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem!(ret_status.write(&memory, status));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs
new file mode 100644
index 0000000..7100ce7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_checkpoint.rs
@@ -0,0 +1,149 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `stack_checkpoint()`
+/// Creates a snapshot of the current stack which allows it to be restored
+/// later using its stack hash.
+#[instrument(level = "trace", skip_all, ret)]
+pub fn stack_checkpoint<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    snapshot_ptr: WasmPtr<StackSnapshot, M>,
+    ret_val: WasmPtr<Longsize, M>,
+) -> Result<Errno, WasiError> {
+    // If we were just restored then we need to return the value instead
+    if let Some(val) = unsafe { handle_rewind::<M, Longsize>(&mut ctx) } {
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        wasi_try_mem_ok!(ret_val.write(&memory, val));
+        trace!("restored - (ret={})", val);
+        return Ok(Errno::Success);
+    }
+    trace!("capturing",);
+
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    // Set the return value that we will give back to
+    // indicate we are a normal function call that has not yet
+    // been restored
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem_ok!(ret_val.write(&memory, 0));
+
+    // Pass some offsets to the unwind function
+    let ret_offset = ret_val.offset();
+    let snapshot_offset = snapshot_ptr.offset();
+    let secret = env.state().secret;
+
+    // We clear the target memory location before we grab the stack so that
+    // it correctly hashes
+    if let Err(err) = snapshot_ptr.write(&memory, StackSnapshot { hash: 0, user: 0 }) {
+        warn!(
+            %err
+        );
+    }
+
+    // Perform the unwind action
+    unwind::<M, _>(ctx, move |mut ctx, mut memory_stack, rewind_stack| {
+        // Grab all the globals and serialize them
+        let store_data = crate::utils::store::capture_store_snapshot(&mut ctx.as_store_mut())
+            .serialize()
+            .unwrap();
+        let env = ctx.data();
+        let store_data = Bytes::from(store_data);
+
+        // We compute the hash again for two reasons... integrity so if there
+        // is a long jump that goes to the wrong place it will fail gracefully.
+        // and security so that the stack can not be used to attempt to break
+        // out of the sandbox
+        let hash = {
+            use sha2::{Digest, Sha256};
+            let mut hasher = Sha256::new();
+            hasher.update(&secret[..]);
+            hasher.update(&memory_stack[..]);
+            hasher.update(&rewind_stack[..]);
+            hasher.update(&store_data[..]);
+            let hash: [u8; 16] = hasher.finalize()[..16].try_into().unwrap();
+            u128::from_le_bytes(hash)
+        };
+
+        // Build a stack snapshot
+        let snapshot = StackSnapshot {
+            hash,
+            user: ret_offset.into(),
+        };
+
+        // Get a reference directly to the bytes of snapshot
+        let val_bytes = unsafe {
+            let p = &snapshot;
+            ::std::slice::from_raw_parts(
+                (p as *const StackSnapshot) as *const u8,
+                ::std::mem::size_of::<StackSnapshot>(),
+            )
+        };
+
+        // The snapshot may itself reside on the stack (which means we
+        // need to update the memory stack rather than write to the memory
+        // as otherwise the rewind will wipe out the structure)
+        // This correct memory stack is stored as well for validation purposes
+        let mut memory_stack_corrected = memory_stack.clone();
+        {
+            let snapshot_offset: u64 = snapshot_offset.into();
+            if snapshot_offset >= env.layout.stack_lower
+                && (snapshot_offset + val_bytes.len() as u64) <= env.layout.stack_upper
+            {
+                // Make sure its within the "active" part of the memory stack
+                // (note - the area being written to might not go past the memory pointer)
+                let offset = env.layout.stack_upper - snapshot_offset;
+                if (offset as usize) < memory_stack_corrected.len() {
+                    let left = memory_stack_corrected.len() - (offset as usize);
+                    let end = offset + (val_bytes.len().min(left) as u64);
+                    if end as usize <= memory_stack_corrected.len() {
+                        let pstart = memory_stack_corrected.len() - offset as usize;
+                        let pend = pstart + val_bytes.len();
+                        let pbytes = &mut memory_stack_corrected[pstart..pend];
+                        pbytes.clone_from_slice(val_bytes);
+                    }
+                }
+            }
+        }
+
+        /// Add a snapshot to the stack
+        ctx.data().thread.add_snapshot(
+            &memory_stack[..],
+            &memory_stack_corrected[..],
+            hash,
+            &rewind_stack[..],
+            &store_data[..],
+        );
+        trace!(hash = snapshot.hash, user = snapshot.user);
+
+        // Save the stack snapshot
+        let env = ctx.data();
+        let memory = unsafe { env.memory_view(&ctx) };
+        let snapshot_ptr: WasmPtr<StackSnapshot, M> = WasmPtr::new(snapshot_offset);
+        if let Err(err) = snapshot_ptr.write(&memory, snapshot) {
+            warn!("could not save stack snapshot - {}", err);
+            return OnCalledAction::Trap(Box::new(WasiError::Exit(mem_error_to_wasi(err).into())));
+        }
+
+        // Rewind the stack and carry on
+        let pid = ctx.data().pid();
+        let tid = ctx.data().tid();
+        match rewind::<M, _>(
+            ctx,
+            memory_stack_corrected.freeze(),
+            rewind_stack.freeze(),
+            store_data,
+            0 as Longsize,
+        ) {
+            Errno::Success => OnCalledAction::InvokeAgain,
+            err => {
+                warn!(
+                    "failed checkpoint - could not rewind the stack - errno={}",
+                    err
+                );
+                OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+            }
+        }
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_restore.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_restore.rs
new file mode 100644
index 0000000..b601d58
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/stack_restore.rs
@@ -0,0 +1,73 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `stack_restore()`
+/// Restores the current stack to a previous stack described by its
+/// stack hash.
+///
+/// ## Parameters
+///
+/// * `snapshot_ptr` - Contains a previously made snapshot
+#[instrument(level = "trace", skip_all, ret)]
+pub fn stack_restore<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    snapshot_ptr: WasmPtr<StackSnapshot, M>,
+    mut val: Longsize,
+) -> Result<(), WasiError> {
+    // Read the snapshot from the stack
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let snapshot = match snapshot_ptr.read(&memory) {
+        Ok(a) => {
+            trace!("with_ret={}, hash={}, user={}", val, a.hash, a.user);
+            a
+        }
+        Err(err) => {
+            warn!("failed to read stack snapshot - {}", err);
+            return Err(WasiError::Exit(mem_error_to_wasi(err).into()));
+        }
+    };
+
+    // Perform the unwind action
+    unwind::<M, _>(ctx, move |mut ctx, _, _| {
+        // Let the stack (or fail trying!)
+        let env = ctx.data();
+        if let Some((mut memory_stack, rewind_stack, store_data)) =
+            env.thread.get_snapshot(snapshot.hash)
+        {
+            let env = ctx.data();
+            let memory = unsafe { env.memory_view(&ctx) };
+
+            // Rewind the stack - after this point we must immediately return
+            // so that the execution can end here and continue elsewhere.
+            let pid = ctx.data().pid();
+            let tid = ctx.data().tid();
+
+            let rewind_result = bincode::serialize(&val).unwrap().into();
+            let ret = rewind_ext::<M>(
+                &mut ctx,
+                None, // we do not restore the thread memory as `longjmp`` is not meant to do this
+                rewind_stack,
+                store_data,
+                RewindResultType::RewindWithResult(rewind_result),
+            );
+            match ret {
+                Errno::Success => OnCalledAction::InvokeAgain,
+                err => {
+                    warn!("failed to rewind the stack - errno={}", err);
+                    OnCalledAction::Trap(Box::new(WasiError::Exit(err.into())))
+                }
+            }
+        } else {
+            warn!(
+                "snapshot stack restore failed - the snapshot can not be found and hence restored (hash={})",
+                snapshot.hash
+            );
+            OnCalledAction::Trap(Box::new(WasiError::Exit(Errno::Unknown.into())))
+        }
+    });
+
+    // Return so the stack can be unwound (which will then
+    // be rewound again but with a different location)
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_exit.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_exit.rs
new file mode 100644
index 0000000..77ff6d1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_exit.rs
@@ -0,0 +1,17 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_exit()`
+/// Terminates the current running thread, if this is the last thread then
+/// the process will also exit with the specified exit code. An exit code
+/// of 0 indicates successful termination of the thread. The meanings of
+/// other values is dependent on the environment.
+///
+/// ## Parameters
+///
+/// * `rval` - The exit code returned by the process.
+#[instrument(level = "debug", skip_all, fields(%exitcode), ret)]
+pub fn thread_exit(ctx: FunctionEnvMut<'_, WasiEnv>, exitcode: ExitCode) -> Result<(), WasiError> {
+    tracing::debug!(%exitcode);
+    Err(WasiError::Exit(exitcode))
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_id.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_id.rs
new file mode 100644
index 0000000..a8d8de9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_id.rs
@@ -0,0 +1,18 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_id()`
+/// Returns the index of the current thread
+/// (threads indices are sequencial from zero)
+#[instrument(level = "trace", skip_all, fields(tid = field::Empty), ret)]
+pub fn thread_id<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    ret_tid: WasmPtr<Tid, M>,
+) -> Errno {
+    let env = ctx.data();
+    let tid: Tid = env.thread.tid().into();
+    Span::current().record("tid", tid);
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem!(ret_tid.write(&memory, tid));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_join.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_join.rs
new file mode 100644
index 0000000..9b9c878
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_join.rs
@@ -0,0 +1,51 @@
+use std::task::Waker;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_join()`
+/// Joins this thread with another thread, blocking this
+/// one until the other finishes
+///
+/// ## Parameters
+///
+/// * `tid` - Handle of the thread to wait on
+//#[instrument(level = "debug", skip_all, fields(%join_tid), ret)]
+pub fn thread_join<M: MemorySize + 'static>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    join_tid: Tid,
+) -> Result<Errno, WasiError> {
+    thread_join_internal::<M>(ctx, join_tid)
+}
+
+pub(super) fn thread_join_internal<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    join_tid: Tid,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+    if let Some(_child_exit_code) = unsafe { handle_rewind::<M, i32>(&mut ctx) } {
+        return Ok(Errno::Success);
+    }
+
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    let env = ctx.data();
+    let tid: WasiThreadId = join_tid.into();
+    let other_thread = env.process.get_thread(&tid);
+    if let Some(other_thread) = other_thread {
+        let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+            other_thread
+                .join()
+                .await
+                .map_err(|err| {
+                    err.as_exit_code()
+                        .unwrap_or(ExitCode::Errno(Errno::Unknown))
+                })
+                .unwrap_or_else(|a| a)
+                .raw()
+        })?;
+        Ok(Errno::Success)
+    } else {
+        Ok(Errno::Success)
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_parallelism.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_parallelism.rs
new file mode 100644
index 0000000..c8c9758
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_parallelism.rs
@@ -0,0 +1,22 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_parallelism()`
+/// Returns the available parallelism which is normally the
+/// number of available cores that can run concurrently
+#[instrument(level = "debug", skip_all, fields(parallelism = field::Empty), ret)]
+pub fn thread_parallelism<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    ret_parallelism: WasmPtr<M::Offset, M>,
+) -> Errno {
+    let env = ctx.data();
+    let parallelism = wasi_try!(env.tasks().thread_parallelism().map_err(|err| {
+        let err: Errno = err.into();
+        err
+    }));
+    Span::current().record("parallelism", parallelism);
+    let parallelism: M::Offset = wasi_try!(parallelism.try_into().map_err(|_| Errno::Overflow));
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem!(ret_parallelism.write(&memory, parallelism));
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_signal.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_signal.rs
new file mode 100644
index 0000000..8700050
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_signal.rs
@@ -0,0 +1,26 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_signal()`
+/// Send a signal to a particular thread in the current process.
+/// Note: This is similar to `signal` in POSIX.
+/// Inputs:
+/// - `Signal`
+///   Signal to be raised for this process
+#[instrument(level = "debug", skip_all, fields(%tid, ?sig), ret)]
+pub fn thread_signal(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    tid: Tid,
+    sig: Signal,
+) -> Result<Errno, WasiError> {
+    {
+        let tid: WasiThreadId = tid.into();
+        ctx.data().process.signal_thread(&tid, sig);
+    }
+
+    let env = ctx.data();
+
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_sleep.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_sleep.rs
new file mode 100644
index 0000000..4925d4d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_sleep.rs
@@ -0,0 +1,48 @@
+use std::task::Waker;
+
+use super::*;
+use crate::syscalls::*;
+
+/// ### `thread_sleep()`
+/// Sends the current thread to sleep for a period of time
+///
+/// ## Parameters
+///
+/// * `duration` - Amount of time that the thread should sleep
+#[instrument(level = "debug", skip_all, fields(%duration), ret)]
+pub fn thread_sleep<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    duration: Timestamp,
+) -> Result<Errno, WasiError> {
+    thread_sleep_internal::<M>(ctx, duration)
+}
+
+pub(crate) fn thread_sleep_internal<M: MemorySize + 'static>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    duration: Timestamp,
+) -> Result<Errno, WasiError> {
+    wasi_try_ok!(WasiEnv::process_signals_and_exit(&mut ctx)?);
+
+    if let Some(()) = unsafe { handle_rewind::<M, _>(&mut ctx) } {
+        return Ok(Errno::Success);
+    }
+
+    ctx = wasi_try_ok!(maybe_backoff::<M>(ctx)?);
+    ctx = wasi_try_ok!(maybe_snapshot::<M>(ctx)?);
+
+    let env = ctx.data();
+
+    #[cfg(feature = "sys-thread")]
+    if duration == 0 {
+        std::thread::yield_now();
+    }
+
+    if duration > 0 {
+        let duration = Duration::from_nanos(duration);
+        let tasks = env.tasks().clone();
+        let res = __asyncify_with_deep_sleep::<M, _, _>(ctx, async move {
+            tasks.sleep_now(duration).await;
+        })?;
+    }
+    Ok(Errno::Success)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_spawn.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_spawn.rs
new file mode 100644
index 0000000..f30d2d7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/thread_spawn.rs
@@ -0,0 +1,286 @@
+use std::f32::consts::E;
+
+use super::*;
+#[cfg(feature = "journal")]
+use crate::journal::JournalEffector;
+use crate::{
+    capture_store_snapshot,
+    os::task::thread::WasiMemoryLayout,
+    runtime::{
+        task_manager::{TaskWasm, TaskWasmRunProperties},
+        TaintReason,
+    },
+    syscalls::*,
+    WasiThreadHandle,
+};
+
+use wasmer::Memory;
+use wasmer_wasix_types::wasi::ThreadStart;
+
+/// ### `thread_spawn()`
+/// Creates a new thread by spawning that shares the same
+/// memory address space, file handles and main event loops.
+///
+/// ## Parameters
+///
+/// * `start_ptr` - Pointer to the structure that describes the thread to be launched
+/// * `ret_tid` - ID of the thread that was launched
+///
+/// ## Return
+///
+/// Returns the thread index of the newly created thread
+/// (indices always start from the same value as `pid` and increments in steps)
+//#[instrument(level = "debug", skip_all, ret)]
+pub fn thread_spawn_v2<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    start_ptr: WasmPtr<ThreadStart<M>, M>,
+    ret_tid: WasmPtr<Tid, M>,
+) -> Errno {
+    // Create the thread
+    let tid = wasi_try!(thread_spawn_internal_from_wasi(&mut ctx, start_ptr));
+
+    // Success
+    let memory = unsafe { ctx.data().memory_view(&ctx) };
+    wasi_try_mem!(ret_tid.write(&memory, tid));
+    Errno::Success
+}
+
+pub fn thread_spawn_internal_from_wasi<M: MemorySize>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    start_ptr: WasmPtr<ThreadStart<M>, M>,
+) -> Result<Tid, Errno> {
+    // Now we use the environment and memory references
+    let env = ctx.data();
+    let memory = unsafe { env.memory_view(&ctx) };
+    let runtime = env.runtime.clone();
+    let tasks = env.tasks().clone();
+    let start_ptr_offset = start_ptr.offset();
+
+    // Read the properties about the stack which we will use for asyncify
+    let layout = {
+        let start: ThreadStart<M> = start_ptr.read(&memory).map_err(mem_error_to_wasi)?;
+        let stack_upper: u64 = start.stack_upper.try_into().map_err(|_| Errno::Overflow)?;
+        let stack_size: u64 = start.stack_size.try_into().map_err(|_| Errno::Overflow)?;
+        let guard_size: u64 = start.guard_size.try_into().map_err(|_| Errno::Overflow)?;
+        let tls_base: u64 = start.tls_base.try_into().map_err(|_| Errno::Overflow)?;
+        let stack_lower = stack_upper - stack_size;
+
+        WasiMemoryLayout {
+            stack_upper,
+            stack_lower,
+            guard_size,
+            stack_size,
+        }
+    };
+    tracing::trace!("spawn with layout {:?}", layout);
+
+    // Create the handle that represents this thread
+    let thread_start = ThreadStartType::ThreadSpawn {
+        start_ptr: start_ptr_offset.into(),
+    };
+    let mut thread_handle = match env.process.new_thread(layout.clone(), thread_start) {
+        Ok(h) => Arc::new(h),
+        Err(err) => {
+            error!(
+                stack_base = layout.stack_lower,
+                "failed to create thread handle",
+            );
+            // TODO: evaluate the appropriate error code, document it in the spec.
+            return Err(Errno::Access);
+        }
+    };
+    let thread_id: Tid = thread_handle.id().into();
+    Span::current().record("tid", thread_id);
+
+    // Spawn the thread
+    thread_spawn_internal_using_layout::<M>(ctx, thread_handle, layout, start_ptr_offset, None)?;
+
+    // Success
+    Ok(thread_id)
+}
+
+pub fn thread_spawn_internal_using_layout<M: MemorySize>(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    thread_handle: Arc<WasiThreadHandle>,
+    layout: WasiMemoryLayout,
+    start_ptr_offset: M::Offset,
+    rewind_state: Option<(RewindState, RewindResultType)>,
+) -> Result<(), Errno> {
+    // We extract the memory which will be passed to the thread
+    let env = ctx.data();
+    let tasks = env.tasks().clone();
+    let thread_memory = unsafe { env.inner() }.memory_clone();
+
+    // We capture some local variables
+    let state = env.state.clone();
+    let mut thread_env = env.clone();
+    thread_env.thread = thread_handle.as_thread();
+    thread_env.layout = layout;
+
+    // TODO: Currently asynchronous threading does not work with multi
+    //       threading in JS but it does work for the main thread. This will
+    //       require more work to find out why.
+    thread_env.enable_deep_sleep = if cfg!(feature = "js") {
+        false
+    } else {
+        unsafe { env.capable_of_deep_sleep() }
+    };
+
+    // This next function gets a context for the local thread and then
+    // calls into the process
+    let mut execute_module = {
+        let thread_handle = thread_handle;
+        move |ctx: WasiFunctionEnv, mut store: Store| {
+            // Call the thread
+            call_module::<M>(ctx, store, start_ptr_offset, thread_handle, rewind_state)
+        }
+    };
+
+    // If the process does not export a thread spawn function then obviously
+    // we can't spawn a background thread
+    if unsafe { env.inner() }.thread_spawn.is_none() {
+        warn!("thread failed - the program does not export a `wasi_thread_start` function");
+        return Err(Errno::Notcapable);
+    }
+    let thread_module = unsafe { env.inner() }.module_clone();
+    let globals = capture_store_snapshot(&mut ctx.as_store_mut());
+    let spawn_type =
+        crate::runtime::SpawnMemoryType::ShareMemory(thread_memory, ctx.as_store_ref());
+
+    // Now spawn a thread
+    trace!("threading: spawning background thread");
+    let run = move |props: TaskWasmRunProperties| {
+        execute_module(props.ctx, props.store);
+    };
+    tasks
+        .task_wasm(
+            TaskWasm::new(Box::new(run), thread_env, thread_module, false)
+                .with_globals(&globals)
+                .with_memory(spawn_type),
+        )
+        .map_err(Into::<Errno>::into)?;
+
+    // Success
+    Ok(())
+}
+
+/// Calls the module
+fn call_module<M: MemorySize>(
+    mut ctx: WasiFunctionEnv,
+    mut store: Store,
+    start_ptr_offset: M::Offset,
+    thread_handle: Arc<WasiThreadHandle>,
+    rewind_state: Option<(RewindState, RewindResultType)>,
+) -> Result<Tid, Errno> {
+    let env = ctx.data(&store);
+    let tasks = env.tasks().clone();
+
+    // This function calls into the module
+    let call_module_internal = move |env: &WasiFunctionEnv, store: &mut Store| {
+        // We either call the reactor callback or the thread spawn callback
+        //trace!("threading: invoking thread callback (reactor={})", reactor);
+        let spawn = unsafe { env.data(&store).inner() }
+            .thread_spawn
+            .clone()
+            .unwrap();
+        let tid = env.data(&store).tid();
+        let call_ret = spawn.call(
+            store,
+            tid.raw().try_into().map_err(|_| Errno::Overflow).unwrap(),
+            start_ptr_offset
+                .try_into()
+                .map_err(|_| Errno::Overflow)
+                .unwrap(),
+        );
+        let mut ret = Errno::Success;
+        if let Err(err) = call_ret {
+            match err.downcast::<WasiError>() {
+                Ok(WasiError::Exit(code)) => {
+                    ret = if code.is_success() {
+                        Errno::Success
+                    } else {
+                        env.data(&store)
+                            .runtime
+                            .on_taint(TaintReason::NonZeroExitCode(code));
+                        Errno::Noexec
+                    };
+                }
+                Ok(WasiError::DeepSleep(deep)) => {
+                    trace!("entered a deep sleep");
+                    return Err(deep);
+                }
+                Ok(WasiError::UnknownWasiVersion) => {
+                    debug!("failed as wasi version is unknown",);
+                    env.data(&store)
+                        .runtime
+                        .on_taint(TaintReason::UnknownWasiVersion);
+                    ret = Errno::Noexec;
+                }
+                Err(err) => {
+                    debug!("failed with runtime error: {}", err);
+                    env.data(&store)
+                        .runtime
+                        .on_taint(TaintReason::RuntimeError(err));
+                    ret = Errno::Noexec;
+                }
+            }
+        }
+        trace!("callback finished (ret={})", ret);
+
+        // Clean up the environment
+        env.on_exit(store, Some(ret.into()));
+
+        // Return the result
+        Ok(ret as u32)
+    };
+
+    // If we need to rewind then do so
+    if let Some((rewind_state, rewind_result)) = rewind_state {
+        let mut ctx = ctx.env.clone().into_mut(&mut store);
+        let res = rewind_ext::<M>(
+            &mut ctx,
+            Some(rewind_state.memory_stack),
+            rewind_state.rewind_stack,
+            rewind_state.store_data,
+            rewind_result,
+        );
+        if res != Errno::Success {
+            return Err(res);
+        }
+    }
+
+    // Now invoke the module
+    let ret = call_module_internal(&ctx, &mut store);
+
+    // If it went to deep sleep then we need to handle that
+    match ret {
+        Ok(ret) => {
+            // Frees the handle so that it closes
+            drop(thread_handle);
+            Ok(ret as Pid)
+        }
+        Err(deep) => {
+            // Create the callback that will be invoked when the thread respawns after a deep sleep
+            let rewind = deep.rewind;
+            let respawn = {
+                let tasks = tasks.clone();
+                move |ctx, store, trigger_res| {
+                    // Call the thread
+                    call_module::<M>(
+                        ctx,
+                        store,
+                        start_ptr_offset,
+                        thread_handle,
+                        Some((rewind, RewindResultType::RewindWithResult(trigger_res))),
+                    );
+                }
+            };
+
+            /// Spawns the WASM process after a trigger
+            unsafe {
+                tasks.resume_wasm_after_poller(Box::new(respawn), ctx, store, deep.trigger)
+            };
+            Err(Errno::Unknown)
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_get.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_get.rs
new file mode 100644
index 0000000..937917a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_get.rs
@@ -0,0 +1,37 @@
+use super::*;
+use crate::syscalls::*;
+
+/// ### `tty_get()`
+/// Retrieves the current state of the TTY
+#[instrument(level = "debug", skip_all, ret)]
+pub fn tty_get<M: MemorySize>(
+    ctx: FunctionEnvMut<'_, WasiEnv>,
+    tty_state: WasmPtr<Tty, M>,
+) -> Errno {
+    let env = ctx.data();
+
+    let env = ctx.data();
+    let bridge = if let Some(t) = env.runtime.tty() {
+        t
+    } else {
+        return Errno::Notsup;
+    };
+
+    let state = bridge.tty_get();
+    let state = Tty {
+        cols: state.cols,
+        rows: state.rows,
+        width: state.width,
+        height: state.height,
+        stdin_tty: state.stdin_tty,
+        stdout_tty: state.stdout_tty,
+        stderr_tty: state.stderr_tty,
+        echo: state.echo,
+        line_buffered: state.line_buffered,
+    };
+
+    let memory = unsafe { env.memory_view(&ctx) };
+    wasi_try_mem!(tty_state.write(&memory, state));
+
+    Errno::Success
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_set.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_set.rs
new file mode 100644
index 0000000..24866d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasix/tty_set.rs
@@ -0,0 +1,67 @@
+use super::*;
+use crate::{syscalls::*, WasiTtyState};
+
+/// ### `tty_set()`
+/// Updates the properties of the rect
+#[instrument(level = "debug", skip_all, ret)]
+pub fn tty_set<M: MemorySize>(
+    mut ctx: FunctionEnvMut<'_, WasiEnv>,
+    tty_state: WasmPtr<Tty, M>,
+) -> Result<Errno, WasiError> {
+    let env = ctx.data();
+
+    let memory = unsafe { env.memory_view(&ctx) };
+    let state = wasi_try_mem_ok!(tty_state.read(&memory));
+    let echo = state.echo;
+    let line_buffered = state.line_buffered;
+    let line_feeds = true;
+    debug!(
+        %echo,
+        %line_buffered,
+        %line_feeds
+    );
+
+    let state = crate::os::tty::WasiTtyState {
+        cols: state.cols,
+        rows: state.rows,
+        width: state.width,
+        height: state.height,
+        stdin_tty: state.stdin_tty,
+        stdout_tty: state.stdout_tty,
+        stderr_tty: state.stderr_tty,
+        echo,
+        line_buffered,
+        line_feeds,
+    };
+
+    wasi_try_ok!({
+        #[allow(clippy::redundant_clone)]
+        tty_set_internal(&mut ctx, state.clone())
+    });
+    let env = ctx.data();
+
+    #[cfg(feature = "journal")]
+    if env.enable_journal {
+        JournalEffector::save_tty_set(&mut ctx, state).map_err(|err| {
+            tracing::error!("failed to save path symbolic link event - {}", err);
+            WasiError::Exit(ExitCode::Errno(Errno::Fault))
+        })?;
+    }
+
+    Ok(Errno::Success)
+}
+
+pub fn tty_set_internal(
+    ctx: &mut FunctionEnvMut<'_, WasiEnv>,
+    state: WasiTtyState,
+) -> Result<(), Errno> {
+    let env = ctx.data();
+    let bridge = if let Some(t) = env.runtime.tty() {
+        t
+    } else {
+        return Err(Errno::Notsup);
+    };
+    bridge.tty_set(state);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasm.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasm.rs
new file mode 100644
index 0000000..dd731f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/wasm.rs
@@ -0,0 +1,33 @@
+use std::mem;
+
+use chrono::prelude::*;
+use wasmer::WasmRef;
+
+use crate::syscalls::types::{
+    wasi::{Errno, Snapshot0Clockid, Timestamp},
+    *,
+};
+
+pub fn platform_clock_res_get(
+    clock_id: Snapshot0Clockid,
+    resolution: WasmRef<Timestamp>,
+) -> Result<i64, Errno> {
+    let t_out = match clock_id {
+        Snapshot0Clockid::Monotonic => 10_000_000,
+        Snapshot0Clockid::Realtime => 1,
+        Snapshot0Clockid::ProcessCputimeId => 1,
+        Snapshot0Clockid::ThreadCputimeId => 1,
+        _ => return Err(Errno::Inval),
+    };
+    Ok(t_out)
+}
+
+pub fn platform_clock_time_get(
+    clock_id: Snapshot0Clockid,
+    precision: Timestamp,
+) -> Result<i64, Errno> {
+    Local::now()
+        .timestamp_nanos_opt()
+        .map(|ts| ts as i64)
+        .ok_or(Errno::Overflow)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/windows.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/windows.rs
new file mode 100644
index 0000000..a1481d4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/syscalls/windows.rs
@@ -0,0 +1,54 @@
+use tracing::debug;
+use wasmer::WasmRef;
+
+use crate::syscalls::types::wasi::{self, Timestamp};
+
+pub fn platform_clock_res_get(
+    clock_id: wasi::Snapshot0Clockid,
+    resolution: WasmRef<Timestamp>,
+) -> Result<i64, wasi::Errno> {
+    let resolution_val = match clock_id {
+        // resolution of monotonic clock at 10ms, from:
+        // https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-gettickcount64
+        wasi::Snapshot0Clockid::Monotonic => 10_000_000,
+        // TODO: verify or compute this
+        wasi::Snapshot0Clockid::Realtime => 1,
+        wasi::Snapshot0Clockid::ProcessCputimeId => {
+            return Err(wasi::Errno::Inval);
+        }
+        wasi::Snapshot0Clockid::ThreadCputimeId => {
+            return Err(wasi::Errno::Inval);
+        }
+        _ => return Err(wasi::Errno::Inval),
+    };
+    Ok(resolution_val)
+}
+
+pub fn platform_clock_time_get(
+    clock_id: wasi::Snapshot0Clockid,
+    precision: Timestamp,
+) -> Result<i64, wasi::Errno> {
+    let nanos = match clock_id {
+        wasi::Snapshot0Clockid::Monotonic => {
+            let tick_ms = unsafe { winapi::um::sysinfoapi::GetTickCount64() };
+            tick_ms * 1_000_000
+        }
+        wasi::Snapshot0Clockid::Realtime => {
+            let duration = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map_err(|e| {
+                    debug!("Error in wasi::platform_clock_time_get: {:?}", e);
+                    wasi::Errno::Io
+                })?;
+            duration.as_nanos() as u64
+        }
+        wasi::Snapshot0Clockid::ProcessCputimeId => {
+            unimplemented!("wasi::platform_clock_time_get(wasi::Clockid::ProcessCputimeId, ..)")
+        }
+        wasi::Snapshot0Clockid::ThreadCputimeId => {
+            unimplemented!("wasi::platform_clock_time_get(wasi::Clockid::ThreadCputimeId, ..)")
+        }
+        _ => return Err(wasi::Errno::Inval),
+    };
+    Ok(nanos as i64)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/dummy_waker.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/dummy_waker.rs
new file mode 100644
index 0000000..16159b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/dummy_waker.rs
@@ -0,0 +1,24 @@
+/// A "mock" no-op [`std::task::Waker`] implementation.
+///
+/// Needed for polling futures outside of an async runtime, since the `poll()`
+/// functions requires a `[std::task::Context]` with a supplied waker.
+#[derive(Debug, Clone)]
+pub struct WasiDummyWaker;
+
+impl cooked_waker::Wake for WasiDummyWaker {
+    fn wake(self) {}
+}
+
+impl cooked_waker::WakeRef for WasiDummyWaker {
+    fn wake_by_ref(&self) {}
+}
+
+unsafe impl cooked_waker::ViaRawPointer for WasiDummyWaker {
+    type Target = ();
+    fn into_raw(self) -> *mut () {
+        std::ptr::null_mut()
+    }
+    unsafe fn from_raw(_ptr: *mut ()) -> Self {
+        WasiDummyWaker
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/mod.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/mod.rs
new file mode 100644
index 0000000..cd93005
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/mod.rs
@@ -0,0 +1,290 @@
+mod dummy_waker;
+mod owned_mutex_guard;
+pub mod store;
+mod thread_parker;
+
+#[cfg(feature = "js")]
+pub(crate) mod web;
+
+pub use self::{dummy_waker::WasiDummyWaker, thread_parker::WasiParkingLot};
+
+pub(crate) use owned_mutex_guard::{
+    read_owned, write_owned, OwnedRwLockReadGuard, OwnedRwLockWriteGuard,
+};
+
+use std::collections::BTreeSet;
+
+use wasmer::Module;
+use wasmer_wasix_types::wasi::Errno;
+
+/// Check if a provided module is compiled for some version of WASI.
+/// Use [`get_wasi_version`] to find out which version of WASI the module is.
+pub fn is_wasi_module(module: &Module) -> bool {
+    get_wasi_version(module, false).is_some()
+}
+
+/// Returns if the module is WASIX or not
+pub fn is_wasix_module(module: &Module) -> bool {
+    match get_wasi_versions(module, false).ok_or(false) {
+        Ok(wasi_versions) => {
+            wasi_versions.contains(&WasiVersion::Wasix32v1)
+                || wasi_versions.contains(&WasiVersion::Wasix64v1)
+        }
+        Err(_) => false,
+    }
+}
+
+pub fn map_io_err(err: std::io::Error) -> Errno {
+    From::<std::io::Error>::from(err)
+}
+
+#[cfg(feature = "journal")]
+pub fn map_snapshot_err(err: anyhow::Error) -> Errno {
+    tracing::warn!("unknown snapshot error: {}", err);
+    Errno::Unknown
+}
+
+/// The version of WASI. This is determined by the imports namespace
+/// string.
+#[derive(Debug, Clone, Copy, Eq)]
+pub enum WasiVersion {
+    /// `wasi_unstable`.
+    Snapshot0,
+
+    /// `wasi_snapshot_preview1`.
+    Snapshot1,
+
+    /// `wasix_32v1`.
+    Wasix32v1,
+
+    /// `wasix_64v1`.
+    Wasix64v1,
+
+    /// Latest version.
+    ///
+    /// It's a “floating” version, i.e. it's an alias to the latest
+    /// version (for the moment, `Snapshot1`). Using this version is a
+    /// way to ensure that modules will run only if they come with the
+    /// latest WASI version (in case of security issues for instance),
+    /// by just updating the runtime.
+    ///
+    /// Note that this version is never returned by an API. It is
+    /// provided only by the user.
+    Latest,
+}
+
+impl WasiVersion {
+    /// Get the version as its namespace str as it appears in Wasm modules.
+    pub const fn get_namespace_str(&self) -> &'static str {
+        match *self {
+            WasiVersion::Snapshot0 => SNAPSHOT0_NAMESPACE,
+            WasiVersion::Snapshot1 => SNAPSHOT1_NAMESPACE,
+            WasiVersion::Wasix32v1 => WASIX_32V1_NAMESPACE,
+            WasiVersion::Wasix64v1 => WASIX_64V1_NAMESPACE,
+            WasiVersion::Latest => SNAPSHOT1_NAMESPACE,
+        }
+    }
+}
+
+impl PartialEq<WasiVersion> for WasiVersion {
+    fn eq(&self, other: &Self) -> bool {
+        matches!(
+            (*self, *other),
+            (Self::Snapshot1, Self::Latest)
+                | (Self::Latest, Self::Snapshot1)
+                | (Self::Latest, Self::Latest)
+                | (Self::Snapshot0, Self::Snapshot0)
+                | (Self::Snapshot1, Self::Snapshot1)
+                | (Self::Wasix32v1, Self::Wasix32v1)
+                | (Self::Wasix64v1, Self::Wasix64v1)
+        )
+    }
+}
+
+impl PartialOrd for WasiVersion {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for WasiVersion {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        if self == other {
+            return std::cmp::Ordering::Equal;
+        }
+        match (*self, *other) {
+            (Self::Snapshot1, Self::Snapshot0) => std::cmp::Ordering::Greater,
+            (Self::Wasix32v1, Self::Snapshot1) | (Self::Wasix32v1, Self::Snapshot0) => {
+                std::cmp::Ordering::Greater
+            }
+            (Self::Wasix64v1, Self::Wasix32v1)
+            | (Self::Wasix64v1, Self::Snapshot1)
+            | (Self::Wasix64v1, Self::Snapshot0) => std::cmp::Ordering::Greater,
+            (Self::Latest, Self::Wasix64v1)
+            | (Self::Latest, Self::Wasix32v1)
+            | (Self::Latest, Self::Snapshot1)
+            | (Self::Latest, Self::Snapshot0) => std::cmp::Ordering::Greater,
+            // they are not equal and not greater so they must be less
+            (_, _) => std::cmp::Ordering::Less,
+        }
+    }
+}
+
+/// Namespace for the `Snapshot0` version.
+const SNAPSHOT0_NAMESPACE: &str = "wasi_unstable";
+
+/// Namespace for the `Snapshot1` version.
+const SNAPSHOT1_NAMESPACE: &str = "wasi_snapshot_preview1";
+
+/// Namespace for the `wasix` version.
+const WASIX_32V1_NAMESPACE: &str = "wasix_32v1";
+
+/// Namespace for the `wasix` version.
+const WASIX_64V1_NAMESPACE: &str = "wasix_64v1";
+
+/// Namespace for the `wasix` version.
+const WASIX_HTTP_V1_NAMESPACE: &str = "wasix_http_client_v1";
+
+/// Detect the version of WASI being used based on the import
+/// namespaces.
+///
+/// A strict detection expects that all imports live in a single WASI
+/// namespace. A non-strict detection expects that at least one WASI
+/// namespace exists to detect the version. Note that the strict
+/// detection is faster than the non-strict one.
+pub fn get_wasi_version(module: &Module, strict: bool) -> Option<WasiVersion> {
+    let mut imports = module.imports().functions().map(|f| f.module().to_owned());
+
+    if strict {
+        let first_module = imports.next()?;
+        if imports.all(|module| module == first_module) {
+            match first_module.as_str() {
+                SNAPSHOT0_NAMESPACE => Some(WasiVersion::Snapshot0),
+                SNAPSHOT1_NAMESPACE => Some(WasiVersion::Snapshot1),
+                WASIX_32V1_NAMESPACE => Some(WasiVersion::Wasix32v1),
+                WASIX_64V1_NAMESPACE => Some(WasiVersion::Wasix64v1),
+                _ => None,
+            }
+        } else {
+            None
+        }
+    } else {
+        // Check that at least a WASI namespace exists, and use the
+        // first one in the list to detect the WASI version.
+        imports.find_map(|module| match module.as_str() {
+            SNAPSHOT0_NAMESPACE => Some(WasiVersion::Snapshot0),
+            SNAPSHOT1_NAMESPACE => Some(WasiVersion::Snapshot1),
+            WASIX_32V1_NAMESPACE => Some(WasiVersion::Wasix32v1),
+            WASIX_64V1_NAMESPACE => Some(WasiVersion::Wasix64v1),
+            _ => None,
+        })
+    }
+}
+
+/// Like [`get_wasi_version`] but detects multiple WASI versions in a single module.
+/// Thus `strict` behaves differently in this function as multiple versions are
+/// always supported. `strict` indicates whether non-WASI imports should trigger a
+/// failure or be ignored.
+pub fn get_wasi_versions(module: &Module, strict: bool) -> Option<BTreeSet<WasiVersion>> {
+    let mut out = BTreeSet::new();
+    let imports = module.imports().functions().map(|f| f.module().to_owned());
+
+    let mut non_wasi_seen = false;
+    for ns in imports {
+        match ns.as_str() {
+            SNAPSHOT0_NAMESPACE => {
+                out.insert(WasiVersion::Snapshot0);
+            }
+            SNAPSHOT1_NAMESPACE => {
+                out.insert(WasiVersion::Snapshot1);
+            }
+            WASIX_32V1_NAMESPACE => {
+                out.insert(WasiVersion::Wasix32v1);
+            }
+            WASIX_64V1_NAMESPACE => {
+                out.insert(WasiVersion::Wasix64v1);
+            }
+            WASIX_HTTP_V1_NAMESPACE => {
+                out.insert(WasiVersion::Wasix64v1);
+            }
+            _ => {
+                non_wasi_seen = true;
+            }
+        }
+    }
+    if strict && non_wasi_seen {
+        None
+    } else {
+        Some(out)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn wasi_version_equality() {
+        assert_eq!(WasiVersion::Snapshot0, WasiVersion::Snapshot0);
+        assert_eq!(WasiVersion::Wasix64v1, WasiVersion::Wasix64v1);
+        assert_eq!(WasiVersion::Wasix32v1, WasiVersion::Wasix32v1);
+        assert_eq!(WasiVersion::Snapshot1, WasiVersion::Snapshot1);
+        assert_eq!(WasiVersion::Snapshot1, WasiVersion::Latest);
+        assert_eq!(WasiVersion::Latest, WasiVersion::Snapshot1);
+        assert_eq!(WasiVersion::Latest, WasiVersion::Latest);
+        assert!(WasiVersion::Wasix32v1 != WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Wasix64v1 != WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Snapshot1 != WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Wasix64v1 != WasiVersion::Snapshot1);
+        assert!(WasiVersion::Snapshot1 != WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Wasix32v1 != WasiVersion::Snapshot1);
+        assert!(WasiVersion::Snapshot0 != WasiVersion::Snapshot1);
+        assert!(WasiVersion::Snapshot1 != WasiVersion::Snapshot0);
+        assert!(WasiVersion::Snapshot0 != WasiVersion::Latest);
+        assert!(WasiVersion::Latest != WasiVersion::Snapshot0);
+        assert!(WasiVersion::Snapshot0 != WasiVersion::Latest);
+        assert!(WasiVersion::Latest != WasiVersion::Snapshot0);
+        assert!(WasiVersion::Wasix32v1 != WasiVersion::Latest);
+        assert!(WasiVersion::Wasix64v1 != WasiVersion::Latest);
+    }
+
+    #[test]
+    fn wasi_version_ordering() {
+        assert!(WasiVersion::Snapshot0 <= WasiVersion::Snapshot0);
+        assert!(WasiVersion::Snapshot1 <= WasiVersion::Snapshot1);
+        assert!(WasiVersion::Wasix32v1 <= WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Wasix64v1 <= WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Latest <= WasiVersion::Latest);
+        assert!(WasiVersion::Snapshot0 >= WasiVersion::Snapshot0);
+        assert!(WasiVersion::Snapshot1 >= WasiVersion::Snapshot1);
+        assert!(WasiVersion::Wasix32v1 >= WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Wasix64v1 >= WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Latest >= WasiVersion::Latest);
+
+        assert!(WasiVersion::Snapshot0 < WasiVersion::Latest);
+        assert!(WasiVersion::Snapshot0 < WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Snapshot0 < WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Snapshot0 < WasiVersion::Snapshot1);
+        assert!(WasiVersion::Latest > WasiVersion::Snapshot0);
+        assert!(WasiVersion::Wasix32v1 > WasiVersion::Snapshot0);
+        assert!(WasiVersion::Wasix64v1 > WasiVersion::Snapshot0);
+        assert!(WasiVersion::Snapshot1 > WasiVersion::Snapshot0);
+
+        assert!(WasiVersion::Snapshot1 < WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Snapshot1 < WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Wasix32v1 > WasiVersion::Snapshot1);
+        assert!(WasiVersion::Wasix64v1 > WasiVersion::Snapshot1);
+
+        assert!(WasiVersion::Wasix32v1 < WasiVersion::Latest);
+        assert!(WasiVersion::Wasix32v1 > WasiVersion::Snapshot1);
+        assert!(WasiVersion::Wasix64v1 < WasiVersion::Latest);
+        assert!(WasiVersion::Wasix64v1 > WasiVersion::Snapshot1);
+        assert!(WasiVersion::Latest > WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Snapshot1 < WasiVersion::Wasix32v1);
+        assert!(WasiVersion::Latest > WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Snapshot1 < WasiVersion::Wasix32v1);
+
+        assert!(WasiVersion::Wasix32v1 < WasiVersion::Wasix64v1);
+        assert!(WasiVersion::Wasix64v1 > WasiVersion::Wasix32v1);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/owned_mutex_guard.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/owned_mutex_guard.rs
new file mode 100644
index 0000000..4edc710
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/owned_mutex_guard.rs
@@ -0,0 +1,251 @@
+/// Extends the standard library RwLock to include an owned version of the read
+/// and write locking functions.
+///
+/// This implementation contains unsafe code and has two levels of protection
+/// that prevent the lock from being released after the memory is freed.
+///
+/// 1. The internals use a Option which is cleared before the Drop completes
+/// 2. The Arc reference is placed as the last field which should be dropped last
+///    (https://doc.rust-lang.org/reference/destructors.html#:~:text=The%20fields%20of%20a%20struct,first%20element%20to%20the%20last.)
+use std::ops::{Deref, DerefMut};
+use std::sync::{Arc, LockResult, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+/// Locks this rwlock with shared read access, blocking the current thread
+/// until it can be acquired.
+///
+/// The calling thread will be blocked until there are no more writers which
+/// hold the lock. There may be other readers currently inside the lock when
+/// this method returns. This method does not provide any guarantees with
+/// respect to the ordering of whether contentious readers or writers will
+/// acquire the lock first.
+///
+/// Returns an RAII guard which will release this thread's shared access
+/// once it is dropped.
+///
+/// # Errors
+///
+/// This function will return an error if the RwLock is poisoned. An RwLock
+/// is poisoned whenever a writer panics while holding an exclusive lock.
+/// The failure will occur immediately after the lock has been acquired.
+///
+/// # Panics
+///
+/// This function might panic when called if the lock is already held by the current thread.
+///
+// # Examples
+//
+// ```
+// use std::sync::{Arc, RwLock};
+// use std::thread;
+// use crate::utils::owned_mutex_guard::read_owned;
+//
+// let lock = Arc::new(RwLock::new(1));
+// let c_lock = Arc::clone(&lock);
+//
+// let n = read_owned(&lock).unwrap();
+// assert_eq!(*n, 1);
+//
+// thread::spawn(move || {
+//     let r = read_owned(&c_lock);
+//     assert!(r.is_ok());
+// }).join().unwrap();
+// ```
+pub(crate) fn read_owned<T>(lock: &Arc<RwLock<T>>) -> LockResult<OwnedRwLockReadGuard<T>> {
+    OwnedRwLockReadGuard::new(lock)
+}
+
+/// Locks this rwlock with exclusive write access, blocking the current
+/// thread until it can be acquired.
+///
+/// This function will not return while other writers or other readers
+/// currently have access to the lock.
+///
+/// Returns an RAII guard which will drop the write access of this rwlock
+/// when dropped.
+///
+/// # Errors
+///
+/// This function will return an error if the RwLock is poisoned. An RwLock
+/// is poisoned whenever a writer panics while holding an exclusive lock.
+/// An error will be returned when the lock is acquired.
+///
+/// # Panics
+///
+/// This function might panic when called if the lock is already held by the current thread.
+///
+// # Examples
+//
+// ```
+// use std::sync::RwLock;
+// use crate::utils::owned_mutex_guard::write_owned;
+//
+// let lock = RwLock::new(1);
+//
+// let mut n = write_owned(&lock).unwrap();
+// *n = 2;
+// ```
+pub(crate) fn write_owned<T>(lock: &Arc<RwLock<T>>) -> LockResult<OwnedRwLockWriteGuard<T>> {
+    OwnedRwLockWriteGuard::new(lock)
+}
+
+pub(crate) struct OwnedRwLockReadGuard<T: 'static> {
+    // This option is guaranteed to be `.is_some()` while in scope and cleared during the `Drop`
+    guard: Option<RwLockReadGuard<'static, T>>,
+    // as a precaution we keep the reference as the last field so that it is destructed after the guard
+    // (https://doc.rust-lang.org/reference/destructors.html#:~:text=The%20fields%20of%20a%20struct,first%20element%20to%20the%20last.)
+    #[allow(unused)]
+    ownership: Arc<RwLock<T>>,
+}
+
+unsafe impl<T> Send for OwnedRwLockReadGuard<T> where T: Send {}
+
+impl<T> Drop for OwnedRwLockReadGuard<T>
+where
+    T: Sized,
+{
+    fn drop(&mut self) {
+        // we must close the lock before we release the arc reference
+        self.guard.take();
+    }
+}
+
+impl<T> std::fmt::Debug for OwnedRwLockReadGuard<T>
+where
+    T: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(guard) = self.guard.as_ref() {
+            write!(f, "{:?}", guard)
+        } else {
+            write!(f, "none")
+        }
+    }
+}
+
+impl<T> std::fmt::Display for OwnedRwLockReadGuard<T>
+where
+    T: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(guard) = self.guard.as_ref() {
+            write!(f, "{}", guard)
+        } else {
+            write!(f, "none")
+        }
+    }
+}
+
+impl<T> OwnedRwLockReadGuard<T> {
+    fn new(lock: &Arc<RwLock<T>>) -> LockResult<Self> {
+        let conv = |guard: RwLockReadGuard<'_, T>| {
+            let guard: RwLockReadGuard<'static, T> = unsafe { std::mem::transmute(guard) };
+            Self {
+                ownership: lock.clone(),
+                guard: Some(guard),
+            }
+        };
+        let guard = lock.read().map_err(|err| {
+            let guard = err.into_inner();
+            PoisonError::new(conv(guard))
+        })?;
+        Ok(conv(guard))
+    }
+
+    /// Converts this guard into an owned reference of the underlying lockable object
+    #[allow(dead_code)]
+    pub fn into_inner(self) -> Arc<RwLock<T>> {
+        self.ownership.clone()
+    }
+}
+
+impl<T> Deref for OwnedRwLockReadGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard.as_ref().unwrap()
+    }
+}
+
+pub(crate) struct OwnedRwLockWriteGuard<T: 'static> {
+    // This option is guaranteed to be `.is_some()` while in scope and cleared during the `Drop`
+    guard: Option<RwLockWriteGuard<'static, T>>,
+    // as a precaution we keep the reference as the last field so that it is destructed after the guard
+    // (https://doc.rust-lang.org/reference/destructors.html#:~:text=The%20fields%20of%20a%20struct,first%20element%20to%20the%20last.)
+    #[allow(unused)]
+    ownership: Arc<RwLock<T>>,
+}
+
+unsafe impl<T> Send for OwnedRwLockWriteGuard<T> where T: Send {}
+
+impl<T> Drop for OwnedRwLockWriteGuard<T>
+where
+    T: Sized,
+{
+    fn drop(&mut self) {
+        // we must close the lock before we release the arc reference
+        self.guard.take();
+    }
+}
+
+impl<T> std::fmt::Debug for OwnedRwLockWriteGuard<T>
+where
+    T: std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(guard) = self.guard.as_ref() {
+            write!(f, "{:?}", guard)
+        } else {
+            write!(f, "none")
+        }
+    }
+}
+
+impl<T> std::fmt::Display for OwnedRwLockWriteGuard<T>
+where
+    T: std::fmt::Display,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(guard) = self.guard.as_ref() {
+            write!(f, "{}", guard)
+        } else {
+            write!(f, "none")
+        }
+    }
+}
+
+impl<T> OwnedRwLockWriteGuard<T> {
+    fn new(lock: &Arc<RwLock<T>>) -> LockResult<Self> {
+        let conv = |guard: RwLockWriteGuard<'_, T>| {
+            let guard: RwLockWriteGuard<'static, T> = unsafe { std::mem::transmute(guard) };
+            Self {
+                ownership: lock.clone(),
+                guard: Some(guard),
+            }
+        };
+        let guard = lock.write().map_err(|err| {
+            let guard = err.into_inner();
+            PoisonError::new(conv(guard))
+        })?;
+        Ok(conv(guard))
+    }
+
+    /// Converts this guard into an owned reference of the underlying lockable object
+    #[allow(dead_code)]
+    pub fn into_inner(self) -> Arc<RwLock<T>> {
+        self.ownership.clone()
+    }
+}
+
+impl<T> Deref for OwnedRwLockWriteGuard<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.guard.as_ref().unwrap()
+    }
+}
+
+impl<T> DerefMut for OwnedRwLockWriteGuard<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.guard.as_mut().unwrap()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/store.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/store.rs
new file mode 100644
index 0000000..fdfb6ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/store.rs
@@ -0,0 +1,30 @@
+/// A snapshot that captures the runtime state of an instance.
+#[derive(Default, serde::Serialize, serde::Deserialize, Clone, Debug)]
+pub struct StoreSnapshot {
+    /// Values of all globals, indexed by the same index used in Webassembly.
+    pub globals: Vec<u128>,
+}
+
+impl StoreSnapshot {
+    pub fn serialize(&self) -> Result<Vec<u8>, bincode::Error> {
+        bincode::serialize(self)
+    }
+
+    pub fn deserialize(data: &[u8]) -> Result<Self, bincode::Error> {
+        bincode::deserialize(data)
+    }
+}
+
+pub fn capture_store_snapshot(store: &mut impl wasmer::AsStoreMut) -> StoreSnapshot {
+    let objs = store.objects_mut();
+    let globals = objs.as_u128_globals();
+    StoreSnapshot { globals }
+}
+
+pub fn restore_store_snapshot(store: &mut impl wasmer::AsStoreMut, snapshot: &StoreSnapshot) {
+    let objs = store.objects_mut();
+
+    for (index, value) in snapshot.globals.iter().enumerate() {
+        objs.set_global_unchecked(index, *value);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/thread_parker.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/thread_parker.rs
new file mode 100644
index 0000000..5c622e2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/thread_parker.rs
@@ -0,0 +1,71 @@
+use std::{
+    sync::{Arc, Condvar, Mutex},
+    task::Waker,
+    time::Duration,
+};
+
+/// Represents a waker that can be used to put a thread to
+/// sleep while it waits for an event to occur
+#[derive(Debug)]
+pub struct WasiParkingLot {
+    waker: Waker,
+    #[allow(dead_code)]
+    run: Arc<(Mutex<bool>, Condvar)>,
+}
+
+impl Default for WasiParkingLot {
+    fn default() -> Self {
+        Self::new(true)
+    }
+}
+
+impl WasiParkingLot {
+    /// Creates a new parking lot with a specific value
+    pub fn new(initial_val: bool) -> Self {
+        let run = Arc::new((Mutex::new(initial_val), Condvar::default()));
+        let waker = {
+            let run = run.clone();
+            waker_fn::waker_fn(move || {
+                let mut guard = run.0.lock().unwrap();
+                *guard = true;
+                run.1.notify_one();
+            })
+        };
+
+        Self { waker, run }
+    }
+
+    /// Gets a reference to the waker that can be used for
+    /// asynchronous calls
+    pub fn get_waker(&self) -> Waker {
+        self.waker.clone()
+    }
+
+    /// Wakes one of the reactors thats currently waiting
+    pub fn wake(&self) {
+        self.waker.wake_by_ref();
+    }
+
+    /// Will wait until either the reactor is triggered
+    /// or the timeout occurs
+    // TODO: review allow...
+    #[allow(dead_code)]
+    pub fn wait(&self, timeout: Duration) -> bool {
+        let mut run = self.run.0.lock().unwrap();
+        if *run {
+            *run = false;
+            return true;
+        }
+        loop {
+            let woken = self.run.1.wait_timeout(run, timeout).unwrap();
+            if woken.1.timed_out() {
+                return false;
+            }
+            run = woken.0;
+            if *run {
+                *run = false;
+                return true;
+            }
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/web.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/web.rs
new file mode 100644
index 0000000..ee340c1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/src/utils/web.rs
@@ -0,0 +1,15 @@
+use wasm_bindgen::{JsCast, JsValue};
+
+/// Try to extract the most appropriate error message from a [`JsValue`],
+/// falling back to a generic error message.
+pub fn js_error(value: JsValue) -> anyhow::Error {
+    if let Some(e) = value.dyn_ref::<js_sys::Error>() {
+        anyhow::Error::msg(String::from(e.message()))
+    } else if let Some(obj) = value.dyn_ref::<js_sys::Object>() {
+        return anyhow::Error::msg(String::from(obj.to_string()));
+    } else if let Some(s) = value.dyn_ref::<js_sys::JsString>() {
+        return anyhow::Error::msg(String::from(s));
+    } else {
+        anyhow::anyhow!("An unknown error occurred: {value:?}")
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/README.md b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/README.md
new file mode 100644
index 0000000..3453e28
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/README.md
@@ -0,0 +1,541 @@
+# WASIX integration tests
+
+## default file system tree
+
+We should see these four directories by default
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift -- ../wasix/tests/coreutils.wasm ls
+```
+
+Expected:
+
+```
+bin
+dev
+etc
+tmp
+```
+
+## using /dev/stderr
+
+This test ensures that the dev character devices are working properly, there should be two lines with blah as tee will
+send it both to the console and to the file
+
+```sh
+cd ../../cli
+echo blah | cargo run --features compiler,cranelift -- ../wasix/tests/coreutils.wasm tee /dev/stderr
+```
+
+Expected:
+
+```
+blah
+blah
+```
+
+## atomic_wait and atomic_wake syscalls
+
+When we convert this from syscalls to native language constructs in WASM this test
+needs to continue to pass.
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- ../wasix/tests/example-condvar.wasm
+```
+
+Expected:
+
+```
+condvar1 thread spawn
+condvar1 thread started
+condvar1 thread sleep(1sec) start
+condvar loop
+condvar wait
+condvar1 thread sleep(1sec) end
+condvar1 thread set condition
+condvar1 thread notify
+condvar woken
+condvar parent done
+condvar1 thread exit
+all done
+```
+
+## cowsay
+
+Piping to cowsay should, well.... display a cow that says something
+
+```sh
+cd ../../cli
+echo blah | cargo run --features compiler,cranelift,debug -- ../wasix/tests/cowsay.wasm
+```
+
+Expected:
+
+```
+ ______
+< blah >
+ ------
+        \   ^__^
+         \  (oo)\_______
+            (__)\       )\/\
+               ||----w |
+                ||     ||
+```
+
+## polling and event notifications
+
+This test makes sure the event notifications works correctly `fd_event` - this construct is used
+in `tokio` in order to wake up the main IO thread that is blocked on an `poll_oneoff`.
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- ../wasix/tests/example-epoll.wasm
+```
+
+Expected:
+
+```
+EFD_NONBLOCK:4
+success write to efd, write 8 bytes(4) at 1669077621s 935291us
+success read from efd, read 8 bytes(4) at 1669077621s 937666us
+success write to efd, write 8 bytes(4) at 1669077622s 937881us
+success read from efd, read 8 bytes(4) at 1669077622s 938309us
+success write to efd, write 8 bytes(4) at 1669077623s 939714us
+success read from efd, read 8 bytes(4) at 1669077623s 940002us
+success write to efd, write 8 bytes(4) at 1669077624s 941033us
+success read from efd, read 8 bytes(4) at 1669077624s 941205us
+success write to efd, write 8 bytes(4) at 1669077625s 943658us
+success read from efd, read 8 bytes(4) at 1669077625s 943956us
+```
+
+## fork and execve
+
+The ability to fork the current process and run a different image but retain the existing open
+file handles (which is needed for stdin and stdout redirection)
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --use sharrattj/coreutils --enable-threads ../wasix/tests/example
+-execve.wasm
+```
+
+Expected:
+
+```
+Main program started
+execve: echo hi-from-child
+hi-from-child
+Child(1) exited with 0
+execve: echo hi-from-parent
+hi-from-parent
+```
+
+## longjmp
+
+longjmp is used by C programs that save and restore the stack at specific points - this functionality
+is often used for exception handling
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-longjmp.wasm
+```
+
+Expected:
+
+```
+(A1)
+(B1)
+(A2) r=10001
+(B2) r=20001
+(A3) r=10002
+(B3) r=20002
+(A4) r=10003
+```
+
+## Yet another longjmp implemenation
+
+This one is initiated from `rust` code and thus has the risk of leaking memory but uses different interfaces
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-stack.wasm
+```
+
+Expected:
+
+```
+before long jump
+after long jump [val=10]
+before long jump
+after long jump [val=20]
+```
+
+## fork
+
+Simple fork example that is a crude multi-threading implementation - used by `dash`
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-fork.wasm
+```
+
+Expected:
+
+```
+Parent has x = 0
+Child has x = 2
+Child(1) exited with 0
+```
+
+## fork and longjmp
+
+Performs a longjmp of a stack that was recorded before the fork - this test ensures that the stacks that have
+been recorded are preserved after a fork. The behavior is needed for `dash`
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-fork-longjmp.wasm
+```
+
+Expected:
+
+```
+Parent has x = 0
+Child has x = 2
+Child(1) exited with 5
+```
+
+### multi threading
+
+full multi-threading with shared memory and shared compiled modules
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-multi-threading.wasm
+```
+
+Expected:
+
+```
+thread 1 started
+thread 2 started
+thread 3 started
+thread 4 started
+thread 5 started
+thread 6 started
+thread 7 started
+thread 8 started
+thread 9 started
+waiting for threads
+thread 1 finished
+thread 2 finished
+thread 3 finished
+thread 4 finished
+thread 5 finished
+thread 6 finished
+thread 7 finished
+thread 8 finished
+thread 9 finished
+all done
+```
+
+## pipes
+
+Uses the `fd_pipe` syscall to create a bidirection pipe with two file descriptors then forks
+the process to write and read to this pipe.
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-pipe.wasm
+```
+
+Expected:
+
+```
+this text should be printed by the child
+this text should be printed by the parent
+```
+
+## signals
+
+Tests that signals can be received and processed by WASM applications
+
+```sh
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-signal.wasm
+```
+
+Note: This test requires that a signal is sent to the process asynchronously
+
+```sh
+kill -s SIGINT 16967
+```
+
+Expected:
+
+```
+received SIGHUP
+
+```
+
+## sleep
+
+Puts the process to sleep for 50ms
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-sleep.wasm
+```
+
+Expected:
+
+```
+```
+
+## Spawning sub-processes
+
+Uses `posix_spawn` to launch a sub-process and wait on it to exit
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads --use sharrattj/coreutils ../wasix/tests/example
+-spawn.wasm
+```
+
+Expected:
+
+```
+Child pid: 1
+hi
+Child status 0
+```
+
+## TCP client
+
+Connects to 8.8.8.8:53 over TCP to verify TCP clients work
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-tcp-client.wasm
+```
+
+Expected:
+
+```
+Successfully connected to server in port 53
+Finished.
+```
+
+## TCP listener
+
+Waits for a connection after listening on 127.0.0.1:7878
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-tcp-listener.wasm
+```
+
+In order to test this a curl command is needed below asynchronously and then it needs to be killed
+
+```sh
+curl 127.0.0.1:7878
+```
+
+Expected: 
+
+```
+Listening on 127.0.0.1:7878
+Connection established!
+```
+
+## Thread local variables
+
+Tests that thread local variables work correctly
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-thread-local.wasm
+```
+
+Expected:
+
+```
+VAR1 in main before change: FirstEnum
+VAR1 in main after change: ThirdEnum(340282366920938463463374607431768211455)
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 1: FirstEnum
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 2: FirstEnum
+VAR1 in thread step 3: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in thread step 4: SecondEnum(4)
+VAR1 in main after thread midpoint: SecondEnum(998877)
+VAR1 in main after thread join: SecondEnum(998877)
+```
+
+## vforking
+
+Tests that lightweight forking that does not copy the memory but retains the
+open file descriptors works correctly.
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads ../wasix/tests/example-vfork.wasm
+```
+
+Expected:
+
+```
+Parent waiting on Child(1)
+Child(1) exited with 10
+```
+
+## web server
+
+Advanced test case that uses `tokio`, TCP listeners, asynchronous IO, event notifications, multi-threading
+and mapped directories to serve HTTP content.
+
+
+```sh
+cd ../../cli
+cargo run --features compiler,cranelift,debug -- --enable-threads --mapdir /public:/prog/deploy/wasmer-web/public ../wasix/tests/web-server.wasm -- --port 8080 --log-level trace
+```
+
+Note: This requires that a curl command be made to the HTTP server asynchronously
+
+```sh
+john@AlienWorld:/prog/wasix-libc/examples$ curl 127.0.0.1:8080
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="Description" content="The Wasmer Shell is an browser based operating system powered by wasmer.io that integrates that allows the WebAssembly community to assembly and build browser hosted applications.">
+    <meta property="og:url" content="https://wasmer.sh" />
+    <meta property="og:title" content="wasmer.sh" />
+    <meta property="og:description" content="An browser based operating system powered by wasmer.io that integrates that allows the WebAssembly community to assembly and build browser hosted applications" />
+    <meta property="og:image" content="https://wasmer.sh/favicon.png" />
+    <meta property="og:type" content="website" />
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="mobile-web-app-capable" content="yes">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <link rel="stylesheet" href="xterm.css" />
+    <link rel="stylesheet" href="wasmer.css" />
+    <link rel="icon" href="/favicon.png">
+    <title>wasmer.sh</title>
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <script type="module" defer="defer" src="main.js"></script>
+  </head>
+
+  <body>
+    <canvas id="frontBuffer"></canvas>
+    <div id="terminal"></div>
+  </body>
+</html>
+```
+
+Expected:
+
+```
+2022-11-22T01:16:38.873595Z  INFO static_web_server::logger: logging level: trace
+2022-11-22T01:16:38.873971Z DEBUG static_web_server::server: initializing tokio runtime with multi thread scheduler
+2022-11-22T01:16:38.874273Z TRACE mio::sys::wasi: select::register: fd=7, token=Token(2147483648), interests=READABLE
+2022-11-22T01:16:38.874750Z TRACE static_web_server::server: starting web server
+2022-11-22T01:16:38.875090Z  INFO static_web_server::server: server bound to tcp socket [::]:8080
+2022-11-22T01:16:38.875504Z  INFO static_web_server::server: runtime worker threads: 1
+2022-11-22T01:16:38.875604Z  INFO static_web_server::server: security headers: enabled=false
+2022-11-22T01:16:38.875894Z  INFO static_web_server::server: auto compression: enabled=true
+2022-11-22T01:16:38.876151Z  INFO static_web_server::server: directory listing: enabled=false
+2022-11-22T01:16:38.876238Z  INFO static_web_server::server: directory listing order code: 6
+2022-11-22T01:16:38.876302Z  INFO static_web_server::server: cache control headers: enabled=true
+2022-11-22T01:16:38.876690Z  INFO static_web_server::server: basic authentication: enabled=false
+2022-11-22T01:16:38.876786Z  INFO static_web_server::server: log remote address: enabled=false
+2022-11-22T01:16:38.877243Z  INFO static_web_server::server: grace period before graceful shutdown: 0s
+2022-11-22T01:16:38.877405Z TRACE mio::poll: registering event source with poller: token=Token(0), interests=READABLE | WRITABLE
+2022-11-22T01:16:38.877513Z TRACE mio::sys::wasi: select::register: fd=8, token=Token(0), interests=READABLE | WRITABLE
+2022-11-22T01:16:38.877645Z  INFO Server::start_server{addr_str="[::]:8080" threads=1}: static_web_server::server: close time.busy=0.00ns time.idle=9.53µs
+2022-11-22T01:16:38.877731Z  INFO static_web_server::server: listening on http://[::]:8080
+2022-11-22T01:16:38.877793Z  INFO static_web_server::server: press ctrl+c to shut down the server
+2022-11-22T01:16:47.494953Z TRACE mio::poll: registering event source with poller: token=Token(1), interests=READABLE | WRITABLE
+2022-11-22T01:16:47.495488Z TRACE mio::sys::wasi: select::register: fd=10, token=Token(1), interests=READABLE | WRITABLE
+2022-11-22T01:16:47.495966Z TRACE hyper::proto::h1::conn: Conn::read_head
+2022-11-22T01:16:47.496094Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: Init, writing: Init, keep_alive: Busy }
+2022-11-22T01:16:47.496342Z TRACE hyper::proto::h1::conn: Conn::read_head
+2022-11-22T01:16:47.496762Z TRACE hyper::proto::h1::io: received 8114 bytes
+2022-11-22T01:16:47.496877Z TRACE parse_headers: hyper::proto::h1::role: Request.parse bytes=8114
+2022-11-22T01:16:47.496956Z TRACE parse_headers: hyper::proto::h1::role: Request.parse Complete(78)
+2022-11-22T01:16:47.497058Z TRACE parse_headers: hyper::proto::h1::role: close time.busy=181µs time.idle=9.48µs
+2022-11-22T01:16:47.497136Z DEBUG hyper::proto::h1::io: parsed 3 headers
+2022-11-22T01:16:47.497202Z DEBUG hyper::proto::h1::conn: incoming body is empty
+2022-11-22T01:16:47.497276Z  INFO static_web_server::handler: incoming request: method=GET uri=/
+2022-11-22T01:16:47.497344Z TRACE static_web_server::static_files: dir? base="./public", route=""
+2022-11-22T01:16:47.497755Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: KeepAlive, writing: Init, keep_alive: Busy }
+2022-11-22T01:16:47.504970Z DEBUG static_web_server::static_files: dir: appending index.html to directory path
+2022-11-22T01:16:47.505117Z TRACE static_web_server::static_files: dir: "./public/index.html"
+2022-11-22T01:16:47.505321Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: KeepAlive, writing: Init, keep_alive: Busy }
+2022-11-22T01:16:47.506066Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: KeepAlive, writing: Init, keep_alive: Busy }
+2022-11-22T01:16:47.506221Z TRACE encode_headers: hyper::proto::h1::role: Server::encode status=200, body=Some(Unknown), req_method=Some(GET)
+2022-11-22T01:16:47.506321Z TRACE encode_headers: hyper::proto::h1::role: close time.busy=99.2µs time.idle=7.56µs
+2022-11-22T01:16:47.506744Z DEBUG hyper::proto::h1::io: flushed 209 bytes
+2022-11-22T01:16:47.506911Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: KeepAlive, writing: Body(Encoder { kind: Length(1323), is_last: false }), keep_alive: Busy }
+2022-11-22T01:16:47.508942Z TRACE hyper::proto::h1::encode: sized write, len = 1323
+2022-11-22T01:16:47.509049Z TRACE hyper::proto::h1::io: buffer.queue self.len=0 buf.len=1323
+2022-11-22T01:16:47.509134Z TRACE hyper::proto::h1::dispatch: no more write body allowed, user body is_end_stream = false
+2022-11-22T01:16:47.509557Z DEBUG hyper::proto::h1::io: flushed 1323 bytes
+2022-11-22T01:16:47.509654Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: Init, writing: Init, keep_alive: Idle }
+2022-11-22T01:16:47.509957Z TRACE hyper::proto::h1::conn: Conn::read_head
+2022-11-22T01:16:47.510057Z TRACE parse_headers: hyper::proto::h1::role: Request.parse bytes=8036
+2022-11-22T01:16:47.510142Z TRACE parse_headers: hyper::proto::h1::role: close time.busy=81.8µs time.idle=9.02µs
+2022-11-22T01:16:47.510217Z TRACE hyper::proto::h1::conn: State::close_read()
+2022-11-22T01:16:47.510282Z DEBUG hyper::proto::h1::conn: parse error (invalid HTTP method parsed) with 8036 bytes
+2022-11-22T01:16:47.510346Z DEBUG hyper::proto::h1::role: sending automatic response (400 Bad Request) for parse error
+2022-11-22T01:16:47.510425Z TRACE encode_headers: hyper::proto::h1::role: Server::encode status=400, body=None, req_method=None
+2022-11-22T01:16:47.510506Z TRACE encode_headers: hyper::proto::h1::role: close time.busy=78.0µs time.idle=7.84µs
+2022-11-22T01:16:47.510662Z DEBUG hyper::proto::h1::io: flushed 84 bytes
+2022-11-22T01:16:47.510742Z TRACE hyper::proto::h1::conn: flushed({role=server}): State { reading: Closed, writing: Closed, keep_alive: Disabled, error: hyper::Error(Parse(Method)) }
+2022-11-22T01:16:47.510915Z TRACE hyper::proto::h1::conn: shut down IO complete
+2022-11-22T01:16:47.510992Z DEBUG hyper::server::server::new_svc: connection error: invalid HTTP method parsed
+2022-11-22T01:16:47.511058Z TRACE mio::poll: deregistering event source from poller
+2022-11-22T01:16:47.511123Z TRACE mio::sys::wasi: select::deregister: fd=10
+```
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.rs
new file mode 100644
index 0000000..a76f231
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.rs
@@ -0,0 +1,28 @@
+// WASI:
+// env: DOG=1
+// env: CAT=2
+
+use std::env;
+
+fn get_env_var(var_name: &str) -> Result<String, env::VarError> {
+    env::var(var_name)
+}
+
+fn main() {
+    let mut env_vars = env::vars()
+        .map(|(key, value)| format!("{}={}", key, value))
+        .collect::<Vec<String>>();
+
+    env_vars.sort();
+
+    println!("Env vars:");
+    for e in env_vars {
+        println!("{}", e);
+    }
+
+    env::set_var("WASI_ENVVAR_TEST", "HELLO");
+
+    println!("DOG {:?}", get_env_var("DOG"));
+    println!("DOG_TYPE {:?}", get_env_var("DOG_TYPE"));
+    println!("SET VAR {:?}", env::var("WASI_ENVVAR_TEST"));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wasm
new file mode 100755
index 0000000..31a87ac
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wat b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wat
new file mode 100644
index 0000000..08b1cab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/envvar.wat
@@ -0,0 +1,25993 @@
+(module
+  (type $t0 (func (param i32 i32) (result i32)))
+  (type $t1 (func (param i32 i32 i32) (result i32)))
+  (type $t2 (func (param i32)))
+  (type $t3 (func (param i32 i32)))
+  (type $t4 (func (param i32 i32 i32)))
+  (type $t5 (func (param i32) (result i32)))
+  (type $t6 (func (param i32 i32 i32 i32)))
+  (type $t7 (func))
+  (type $t8 (func (param i32) (result i64)))
+  (type $t9 (func (param i32 i32 i32 i32) (result i32)))
+  (type $t10 (func (result i32)))
+  (type $t11 (func (param i32 i32 i32 i32 i32)))
+  (type $t12 (func (param i32 i32 i32 i32 i32 i32) (result i32)))
+  (type $t13 (func (param i32 i32 i32 i32 i32 i32 i32) (result i32)))
+  (type $t14 (func (param i64 i32 i32) (result i32)))
+  (import "wasi_snapshot_preview1" "proc_exit" (func $wasi_snapshot_preview1.proc_exit (type $t2)))
+  (import "wasi_snapshot_preview1" "fd_write" (func $wasi_snapshot_preview1.fd_write (type $t9)))
+  (import "wasi_snapshot_preview1" "fd_prestat_get" (func $wasi_snapshot_preview1.fd_prestat_get (type $t0)))
+  (import "wasi_snapshot_preview1" "fd_prestat_dir_name" (func $wasi_snapshot_preview1.fd_prestat_dir_name (type $t1)))
+  (import "wasi_snapshot_preview1" "environ_sizes_get" (func $wasi_snapshot_preview1.environ_sizes_get (type $t0)))
+  (import "wasi_snapshot_preview1" "environ_get" (func $wasi_snapshot_preview1.environ_get (type $t0)))
+  (func $_start (type $t7)
+    (local $l0 i32)
+    call $f154
+    call $f152
+    call $f33
+    local.tee $l0
+    if $I0
+      local.get $l0
+      call $wasi_snapshot_preview1.proc_exit
+      unreachable
+    end)
+  (func $f7 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32)
+    global.get $g0
+    i32.const 96
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    loop $L0
+      block $B1
+        local.get $l2
+        i32.const -1
+        i32.eq
+        br_if $B1
+        local.get $l1
+        local.get $l2
+        local.get $p0
+        call $f9
+        local.get $l1
+        i32.load
+        local.get $l1
+        i32.load offset=4
+        call $f10
+        local.get $l2
+        i32.const -1
+        i32.add
+        local.set $l2
+        br $L0
+      end
+    end
+    local.get $l1
+    i32.const 96
+    i32.add
+    global.set $g0)
+  (func $f8 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=8
+    local.get $p1
+    i32.load
+    local.get $p1
+    i32.load offset=8
+    call $f27
+    i32.const 255
+    i32.and
+    i32.const 255
+    i32.eq)
+  (func $f9 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    i32.const 2
+    local.get $p1
+    i32.lt_u
+    if $I0
+      local.get $p1
+      i32.const 2
+      call $f174
+      unreachable
+    end
+    local.get $p0
+    i32.const 2
+    local.get $p1
+    i32.sub
+    i32.store offset=4
+    local.get $p0
+    local.get $p2
+    local.get $p1
+    i32.const 12
+    i32.mul
+    i32.add
+    i32.store)
+  (func $f10 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0
+      local.get $p1
+      i32.const 2
+      i32.lt_u
+      br_if $B0
+      local.get $p0
+      i32.const 12
+      i32.add
+      local.get $p0
+      call $f8
+      i32.eqz
+      br_if $B0
+      local.get $l2
+      i32.const 8
+      i32.add
+      local.get $p0
+      i32.const 8
+      i32.add
+      i32.load
+      i32.store
+      local.get $l2
+      local.get $p0
+      i64.load align=4
+      i64.store
+      local.get $p1
+      i32.const -2
+      i32.add
+      local.set $p1
+      loop $L1
+        block $B2
+          local.get $p0
+          i32.const 8
+          i32.add
+          local.get $p0
+          i32.const 20
+          i32.add
+          i32.load
+          i32.store
+          local.get $p0
+          local.get $p0
+          i32.const 12
+          i32.add
+          local.tee $l3
+          i64.load align=4
+          i64.store align=4
+          local.get $p1
+          i32.eqz
+          br_if $B2
+          local.get $p0
+          i32.const 24
+          i32.add
+          local.get $l2
+          call $f8
+          i32.eqz
+          br_if $B2
+          local.get $p1
+          i32.const -1
+          i32.add
+          local.set $p1
+          local.get $l3
+          local.set $p0
+          br $L1
+        end
+      end
+      local.get $p0
+      i32.const 12
+      i32.add
+      local.get $l2
+      i64.load
+      i64.store align=4
+      local.get $p0
+      i32.const 20
+      i32.add
+      local.get $l2
+      i32.const 8
+      i32.add
+      i32.load
+      i32.store
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f11 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p2
+    call $f13
+    local.get $l3
+    i32.const 0
+    i32.store offset=24
+    local.get $l3
+    local.get $l3
+    i64.load offset=8
+    i64.store offset=16
+    local.get $l3
+    i32.const 16
+    i32.add
+    local.get $p1
+    local.get $p2
+    call $f17
+    local.get $p0
+    i32.const 8
+    i32.add
+    local.get $l3
+    i32.load offset=24
+    i32.store
+    local.get $p0
+    local.get $l3
+    i64.load offset=16
+    i64.store align=4
+    local.get $l3
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f12 (type $t7)
+    call $f169
+    unreachable)
+  (func $f13 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    block $B0
+      local.get $p1
+      i32.const -1
+      i32.gt_s
+      if $I1
+        block $B2
+          local.get $p1
+          i32.eqz
+          if $I3
+            i32.const 1
+            local.set $l2
+            br $B2
+          end
+          local.get $p1
+          i32.const 1
+          call $f36
+          local.tee $l2
+          i32.eqz
+          br_if $B0
+        end
+        local.get $p0
+        local.get $p1
+        i32.store offset=4
+        local.get $p0
+        local.get $l2
+        i32.store
+        return
+      end
+      call $f12
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    call $f168
+    unreachable)
+  (func $f14 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    block $B0
+      block $B1
+        local.get $p0
+        i32.load offset=4
+        local.tee $l3
+        local.get $p1
+        i32.sub
+        local.get $p2
+        i32.lt_u
+        if $I2
+          local.get $p1
+          local.get $p2
+          i32.add
+          local.tee $p2
+          local.get $p1
+          i32.lt_u
+          br_if $B0
+          local.get $l3
+          i32.const 1
+          i32.shl
+          local.tee $p1
+          local.get $p2
+          local.get $p1
+          local.get $p2
+          i32.gt_u
+          select
+          local.tee $p1
+          i32.const 0
+          i32.lt_s
+          br_if $B0
+          block $B3 (result i32)
+            local.get $l3
+            i32.eqz
+            if $I4
+              local.get $p1
+              i32.const 1
+              call $f36
+              br $B3
+            end
+            local.get $p0
+            i32.load
+            local.get $l3
+            i32.const 1
+            local.get $p1
+            call $f37
+          end
+          local.tee $p2
+          i32.eqz
+          br_if $B1
+          local.get $p0
+          local.get $p1
+          i32.store offset=4
+          local.get $p0
+          local.get $p2
+          i32.store
+        end
+        return
+      end
+      local.get $p1
+      i32.const 1
+      call $f168
+      unreachable
+    end
+    call $f169
+    unreachable)
+  (func $f15 (type $t2) (param $p0 i32)
+    local.get $p0
+    i32.load offset=4
+    if $I0
+      local.get $p0
+      i32.load
+      call $f145
+    end)
+  (func $f16 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load
+    local.get $p0
+    i32.load offset=8
+    local.get $p1
+    call $f224)
+  (func $f17 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    local.get $p0
+    local.get $p0
+    i32.load offset=8
+    local.get $p2
+    call $f14
+    local.get $p0
+    local.get $p0
+    i32.load offset=8
+    local.tee $l3
+    local.get $p2
+    i32.add
+    i32.store offset=8
+    local.get $l3
+    local.get $p0
+    i32.load
+    i32.add
+    local.get $p2
+    local.get $p1
+    local.get $p2
+    call $f26)
+  (func $f18 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    loop $L0
+      block $B1
+        block $B2
+          local.get $p0
+          i32.load offset=8
+          local.tee $l2
+          local.get $p0
+          i32.load offset=12
+          i32.eq
+          if $I3
+            local.get $l1
+            i32.const 0
+            i32.store offset=16
+            br $B2
+          end
+          local.get $p0
+          local.get $l2
+          i32.const 12
+          i32.add
+          i32.store offset=8
+          local.get $l1
+          i32.const 24
+          i32.add
+          local.tee $l3
+          local.get $l2
+          i32.const 8
+          i32.add
+          i32.load
+          i32.store
+          local.get $l1
+          local.get $l2
+          i64.load align=4
+          local.tee $l4
+          i64.store offset=16
+          local.get $l4
+          i32.wrap_i64
+          br_if $B1
+        end
+        local.get $l1
+        i32.const 16
+        i32.add
+        local.tee $l2
+        i32.load
+        if $I4
+          local.get $l2
+          call $f15
+        end
+        local.get $l1
+        local.get $p0
+        i64.load align=4
+        i64.store offset=16
+        local.get $l1
+        i32.const 16
+        i32.add
+        local.tee $p0
+        i32.load offset=4
+        if $I5
+          local.get $p0
+          i32.load
+          call $f145
+        end
+        local.get $l1
+        i32.const 32
+        i32.add
+        global.set $g0
+        return
+      end
+      local.get $l1
+      i32.const 8
+      i32.add
+      local.get $l3
+      i32.load
+      local.tee $l2
+      i32.store
+      local.get $l1
+      local.get $l1
+      i64.load offset=16
+      local.tee $l4
+      i64.store
+      local.get $l3
+      local.get $l2
+      i32.store
+      local.get $l1
+      local.get $l4
+      i64.store offset=16
+      local.get $l1
+      i32.const 16
+      i32.add
+      call $f15
+      br $L0
+    end
+    unreachable)
+  (func $f19 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    local.get $p0
+    i32.const 4
+    i32.add
+    local.set $l1
+    block $B0
+      local.get $p0
+      i32.load
+      if $I1
+        local.get $l1
+        i32.load
+        i32.eqz
+        br_if $B0
+      end
+      local.get $l1
+      call $f15
+    end)
+  (func $f20 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    local.get $p0
+    local.get $p1
+    local.get $p2
+    call $f28)
+  (func $f21 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=8
+    local.get $p1
+    call $f225)
+  (func $f22 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0
+      local.get $p1
+      local.get $p2
+      i32.const 1048756
+      call $f20
+      if $I1
+        local.get $l3
+        i32.const 1048759
+        i32.const 1
+        call $f11
+        local.get $p0
+        i32.const 0
+        i32.store
+        local.get $p0
+        i32.const 12
+        i32.add
+        local.get $l3
+        i32.const 8
+        i32.add
+        i32.load
+        i32.store
+        local.get $p0
+        local.get $l3
+        i64.load
+        i64.store offset=4 align=4
+        br $B0
+      end
+      local.get $p1
+      local.get $p2
+      i32.const 1048760
+      call $f20
+      if $I2
+        local.get $l3
+        i32.const 1048763
+        i32.const 1
+        call $f11
+        local.get $p0
+        i32.const 0
+        i32.store
+        local.get $p0
+        i32.const 12
+        i32.add
+        local.get $l3
+        i32.const 8
+        i32.add
+        i32.load
+        i32.store
+        local.get $p0
+        local.get $l3
+        i64.load
+        i64.store offset=4 align=4
+        br $B0
+      end
+      local.get $p0
+      i64.const 1
+      i64.store align=4
+    end
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f23 (type $t7)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    block $B0
+      i32.const 24
+      i32.const 4
+      call $f36
+      local.tee $l1
+      if $I1
+        local.get $l0
+        i32.const -64
+        i32.sub
+        i32.const 1048764
+        i32.const 5
+        call $f11
+        local.get $l0
+        i32.const 40
+        i32.add
+        i32.const 1048769
+        i32.const 5
+        call $f11
+        local.get $l1
+        i32.const 8
+        i32.add
+        local.get $l0
+        i32.const 72
+        i32.add
+        i32.load
+        i32.store
+        local.get $l1
+        local.get $l0
+        i64.load offset=64
+        i64.store align=4
+        local.get $l1
+        local.get $l0
+        i64.load offset=40
+        i64.store offset=12 align=4
+        local.get $l1
+        i32.const 20
+        i32.add
+        local.get $l0
+        i32.const 48
+        i32.add
+        local.tee $l2
+        i32.load
+        i32.store
+        local.get $l1
+        call $f7
+        local.get $l0
+        i64.const 4
+        i64.store offset=56
+        local.get $l0
+        i64.const 1
+        i64.store offset=44 align=4
+        local.get $l0
+        i32.const 1048784
+        i32.store offset=40
+        local.get $l0
+        i32.const 40
+        i32.add
+        call $f115
+        local.get $l0
+        local.get $l1
+        i32.const 24
+        i32.add
+        local.tee $l3
+        i32.store offset=76
+        local.get $l0
+        local.get $l1
+        i32.store offset=72
+        local.get $l0
+        i32.const 2
+        i32.store offset=68
+        local.get $l0
+        local.get $l1
+        i32.store offset=64
+        loop $L2
+          local.get $l1
+          local.get $l3
+          i32.eq
+          if $I3
+            local.get $l0
+            i32.const 0
+            i32.store offset=40
+            br $B0
+          end
+          local.get $l0
+          local.get $l1
+          i32.const 12
+          i32.add
+          i32.store offset=72
+          local.get $l2
+          local.get $l1
+          i32.const 8
+          i32.add
+          i32.load
+          i32.store
+          local.get $l0
+          local.get $l1
+          i64.load align=4
+          local.tee $l4
+          i64.store offset=40
+          local.get $l4
+          i32.wrap_i64
+          i32.eqz
+          br_if $B0
+          local.get $l0
+          i32.const 8
+          i32.add
+          local.get $l2
+          i32.load
+          local.tee $l1
+          i32.store
+          local.get $l0
+          local.get $l0
+          i64.load offset=40
+          local.tee $l4
+          i64.store
+          local.get $l0
+          i32.const 24
+          i32.add
+          local.get $l1
+          i32.store
+          local.get $l0
+          local.get $l4
+          i64.store offset=16
+          local.get $l0
+          i32.const 1
+          i32.store offset=60
+          local.get $l0
+          i64.const 2
+          i64.store offset=44 align=4
+          local.get $l0
+          i32.const 1048796
+          i32.store offset=40
+          local.get $l0
+          i32.const 1
+          i32.store offset=36
+          local.get $l0
+          local.get $l0
+          i32.const 32
+          i32.add
+          i32.store offset=56
+          local.get $l0
+          local.get $l0
+          i32.const 16
+          i32.add
+          i32.store offset=32
+          local.get $l0
+          i32.const 40
+          i32.add
+          call $f115
+          local.get $l0
+          i32.const 16
+          i32.add
+          call $f15
+          local.get $l0
+          i32.load offset=76
+          local.set $l3
+          local.get $l0
+          i32.load offset=72
+          local.set $l1
+          br $L2
+        end
+        unreachable
+      end
+      i32.const 24
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    local.get $l0
+    i32.const -64
+    i32.sub
+    call $f18
+    call $f94
+    local.get $l0
+    i32.const -64
+    i32.sub
+    i32.const 1048756
+    i32.const 3
+    call $f22
+    local.get $l0
+    i32.const 60
+    i32.add
+    local.tee $l1
+    i32.const 1
+    i32.store
+    local.get $l0
+    i32.const 2
+    i32.store offset=20
+    local.get $l0
+    i64.const 2
+    i64.store offset=44 align=4
+    local.get $l0
+    i32.const 1048840
+    i32.store offset=40
+    local.get $l0
+    local.get $l0
+    i32.const -64
+    i32.sub
+    i32.store offset=16
+    local.get $l0
+    local.get $l0
+    i32.const 16
+    i32.add
+    i32.store offset=56
+    local.get $l0
+    i32.const 40
+    i32.add
+    call $f115
+    local.get $l0
+    i32.const -64
+    i32.sub
+    call $f19
+    local.get $l0
+    i32.const -64
+    i32.sub
+    i32.const 1048884
+    i32.const 8
+    call $f22
+    local.get $l1
+    i32.const 1
+    i32.store
+    local.get $l0
+    i32.const 2
+    i32.store offset=20
+    local.get $l0
+    i64.const 2
+    i64.store offset=44 align=4
+    local.get $l0
+    i32.const 1048868
+    i32.store offset=40
+    local.get $l0
+    local.get $l0
+    i32.const -64
+    i32.sub
+    i32.store offset=16
+    local.get $l0
+    local.get $l0
+    i32.const 16
+    i32.add
+    i32.store offset=56
+    local.get $l0
+    i32.const 40
+    i32.add
+    call $f115
+    local.get $l0
+    i32.const -64
+    i32.sub
+    call $f19
+    local.get $l0
+    i32.const -64
+    i32.sub
+    call $f90
+    local.get $l1
+    i32.const 1
+    i32.store
+    local.get $l0
+    i32.const 2
+    i32.store offset=20
+    local.get $l0
+    i64.const 2
+    i64.store offset=44 align=4
+    local.get $l0
+    i32.const 1048900
+    i32.store offset=40
+    local.get $l0
+    local.get $l0
+    i32.const -64
+    i32.sub
+    i32.store offset=16
+    local.get $l0
+    local.get $l0
+    i32.const 16
+    i32.add
+    i32.store offset=56
+    local.get $l0
+    i32.const 40
+    i32.add
+    call $f115
+    local.get $l0
+    i32.const -64
+    i32.sub
+    call $f19
+    local.get $l0
+    i32.const 80
+    i32.add
+    global.set $g0)
+  (func $__original_main (type $t10) (result i32)
+    call $f33)
+  (func $main (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    call $f33)
+  (func $f26 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32)
+    global.get $g0
+    i32.const 96
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    local.get $l4
+    local.get $p1
+    i32.store offset=8
+    local.get $l4
+    local.get $p3
+    i32.store offset=12
+    local.get $p1
+    local.get $p3
+    i32.eq
+    if $I0
+      local.get $p0
+      local.get $p2
+      local.get $p1
+      call $f162
+      drop
+      local.get $l4
+      i32.const 96
+      i32.add
+      global.set $g0
+      return
+    end
+    local.get $l4
+    i32.const 60
+    i32.add
+    i32.const 4
+    i32.store
+    local.get $l4
+    i32.const 52
+    i32.add
+    i32.const 5
+    i32.store
+    local.get $l4
+    i32.const 36
+    i32.add
+    i32.const 3
+    i32.store
+    local.get $l4
+    i64.const 3
+    i64.store offset=20 align=4
+    local.get $l4
+    i32.const 1048976
+    i32.store offset=16
+    local.get $l4
+    i32.const 5
+    i32.store offset=44
+    local.get $l4
+    local.get $l4
+    i32.const 8
+    i32.add
+    i32.store offset=64
+    local.get $l4
+    local.get $l4
+    i32.const 12
+    i32.add
+    i32.store offset=68
+    local.get $l4
+    i64.const 4
+    i64.store offset=88
+    local.get $l4
+    i64.const 1
+    i64.store offset=76 align=4
+    local.get $l4
+    i32.const 1049052
+    i32.store offset=72
+    local.get $l4
+    local.get $l4
+    i32.const 40
+    i32.add
+    i32.store offset=32
+    local.get $l4
+    local.get $l4
+    i32.const 72
+    i32.add
+    i32.store offset=56
+    local.get $l4
+    local.get $l4
+    i32.const 68
+    i32.add
+    i32.store offset=48
+    local.get $l4
+    local.get $l4
+    i32.const -64
+    i32.sub
+    i32.store offset=40
+    local.get $l4
+    i32.const 16
+    i32.add
+    i32.const 1049136
+    call $f177
+    unreachable)
+  (func $f27 (type $t9) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (result i32)
+    local.get $p0
+    local.get $p2
+    local.get $p3
+    local.get $p1
+    local.get $p1
+    local.get $p3
+    i32.gt_u
+    select
+    call $f167
+    local.tee $p0
+    if $I0
+      i32.const -1
+      i32.const 1
+      local.get $p0
+      i32.const 0
+      i32.lt_s
+      select
+      return
+    end
+    i32.const -1
+    local.get $p1
+    local.get $p3
+    i32.ne
+    local.get $p1
+    local.get $p3
+    i32.lt_u
+    select)
+  (func $f28 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    local.get $p1
+    i32.const 3
+    i32.eq
+    if $I0 (result i32)
+      local.get $p0
+      local.get $p2
+      i32.eq
+      if $I1
+        i32.const 1
+        return
+      end
+      local.get $p0
+      local.get $p2
+      local.get $p1
+      call $f167
+      i32.eqz
+    else
+      i32.const 0
+    end)
+  (func $f29 (type $t2) (param $p0 i32)
+    nop)
+  (func $f30 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.const 4
+    i32.add
+    local.set $l3
+    block $B0
+      local.get $p0
+      i32.load
+      i32.const 1
+      i32.ne
+      if $I1
+        local.get $l2
+        local.get $p1
+        i32.const 1049172
+        i32.const 2
+        call $f222
+        local.get $l2
+        local.get $l3
+        i32.store offset=12
+        local.get $l2
+        local.get $l2
+        i32.const 12
+        i32.add
+        i32.const 1049176
+        call $f206
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.const 1049152
+      i32.const 3
+      call $f222
+      local.get $l2
+      local.get $l3
+      i32.store offset=12
+      local.get $l2
+      local.get $l2
+      i32.const 12
+      i32.add
+      i32.const 1049156
+      call $f206
+    end
+    local.get $l2
+    call $f207
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f31 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.set $p0
+    local.get $p1
+    call $f220
+    i32.eqz
+    if $I0
+      local.get $p1
+      call $f221
+      i32.eqz
+      if $I1
+        local.get $p0
+        local.get $p1
+        call $f178
+        return
+      end
+      local.get $p0
+      local.get $p1
+      call $f230
+      return
+    end
+    local.get $p0
+    local.get $p1
+    call $f226)
+  (func $f32 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f140)
+  (func $f33 (type $t10) (result i32)
+    (local $l0 i32) (local $l1 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    local.get $l0
+    i32.const 3
+    i32.store offset=12
+    local.get $l0
+    i32.const 12
+    i32.add
+    call $f139
+    local.get $l0
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f34 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $p0
+    i32.load
+    call_indirect (type $t7) $T0
+    local.get $l1
+    i32.const 0
+    i32.store8 offset=15
+    local.get $l1
+    i32.const 15
+    i32.add
+    i32.load8_u
+    local.get $l1
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f35 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    local.get $p0
+    i32.load
+    i32.store offset=12
+    local.get $l1
+    i32.const 12
+    i32.add
+    call $f34
+    local.get $l1
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f36 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    local.get $p1
+    call $f129)
+  (func $f37 (type $t9) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (result i32)
+    local.get $p0
+    local.get $p1
+    local.get $p2
+    local.get $p3
+    call $f130)
+  (func $f38 (type $t8) (param $p0 i32) (result i64)
+    i64.const 8634666484767235598)
+  (func $f39 (type $t8) (param $p0 i32) (result i64)
+    i64.const 9212946136330284990)
+  (func $f40 (type $t8) (param $p0 i32) (result i64)
+    i64.const 1229646359891580772)
+  (func $f41 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.set $p0
+    local.get $p1
+    call $f220
+    i32.eqz
+    if $I0
+      local.get $p1
+      call $f221
+      i32.eqz
+      if $I1
+        local.get $p0
+        i64.load8_u
+        i32.const 1
+        local.get $p1
+        call $f214
+        return
+      end
+      local.get $p0
+      local.get $p1
+      call $f229
+      return
+    end
+    local.get $p0
+    local.get $p1
+    call $f200)
+  (func $f42 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0 (result i32)
+      i32.const 1
+      local.get $p2
+      i32.const 1050388
+      i32.const 1
+      call $f218
+      br_if $B0
+      drop
+      local.get $l3
+      i32.const 8
+      i32.add
+      local.get $p0
+      local.get $p1
+      call $f195
+      local.get $l3
+      local.get $l3
+      i32.load offset=8
+      local.get $l3
+      i32.load offset=12
+      call $f195
+      local.get $l3
+      local.get $l3
+      i64.load
+      i64.store offset=16
+      local.get $l3
+      i32.const 40
+      i32.add
+      local.get $l3
+      i32.const 16
+      i32.add
+      call $f196
+      local.get $l3
+      i32.load offset=40
+      local.tee $l4
+      if $I1
+        local.get $l3
+        i32.const 48
+        i32.add
+        local.set $l10
+        local.get $l3
+        i32.const -64
+        i32.sub
+        local.set $l11
+        loop $L2
+          local.get $l3
+          i32.load offset=52
+          local.set $l7
+          local.get $l3
+          i32.load offset=48
+          local.set $l8
+          local.get $l3
+          i32.load offset=44
+          local.set $p0
+          local.get $l3
+          i32.const 4
+          i32.store offset=64
+          local.get $l3
+          i32.const 4
+          i32.store offset=48
+          local.get $l3
+          local.get $l4
+          i32.store offset=40
+          local.get $l3
+          local.get $p0
+          local.get $l4
+          i32.add
+          i32.store offset=44
+          i32.const 4
+          local.set $l4
+          loop $L3
+            block $B4
+              block $B5
+                block $B6
+                  block $B7 (result i64)
+                    block $B8
+                      block $B9
+                        block $B10
+                          block $B11
+                            block $B12
+                              block $B13
+                                block $B14
+                                  local.get $l4
+                                  i32.const 4
+                                  i32.ne
+                                  if $I15
+                                    local.get $l10
+                                    call $f184
+                                    local.tee $l4
+                                    i32.const 1114112
+                                    i32.ne
+                                    br_if $B14
+                                  end
+                                  local.get $l3
+                                  i32.load offset=40
+                                  local.tee $l5
+                                  local.get $l3
+                                  i32.load offset=44
+                                  local.tee $p0
+                                  i32.ne
+                                  if $I16
+                                    local.get $l3
+                                    local.get $l5
+                                    i32.const 1
+                                    i32.add
+                                    local.tee $p1
+                                    i32.store offset=40
+                                    i32.const 2
+                                    local.set $l4
+                                    block $B17 (result i32)
+                                      local.get $l5
+                                      i32.load8_s
+                                      local.tee $l6
+                                      i32.const -1
+                                      i32.gt_s
+                                      if $I18
+                                        local.get $l6
+                                        i32.const 255
+                                        i32.and
+                                        br $B17
+                                      end
+                                      block $B19 (result i32)
+                                        local.get $p0
+                                        local.get $p1
+                                        i32.eq
+                                        if $I20
+                                          local.get $p0
+                                          local.set $p1
+                                          i32.const 0
+                                          br $B19
+                                        end
+                                        local.get $l3
+                                        local.get $l5
+                                        i32.const 2
+                                        i32.add
+                                        local.tee $p1
+                                        i32.store offset=40
+                                        local.get $l5
+                                        i32.load8_u offset=1
+                                        i32.const 63
+                                        i32.and
+                                      end
+                                      local.tee $l12
+                                      local.get $l6
+                                      i32.const 31
+                                      i32.and
+                                      local.tee $l9
+                                      i32.const 6
+                                      i32.shl
+                                      i32.or
+                                      local.get $l6
+                                      i32.const 255
+                                      i32.and
+                                      local.tee $l6
+                                      i32.const 223
+                                      i32.le_u
+                                      br_if $B17
+                                      drop
+                                      block $B21 (result i32)
+                                        local.get $p0
+                                        local.get $p1
+                                        i32.eq
+                                        if $I22
+                                          local.get $p0
+                                          local.set $l5
+                                          i32.const 0
+                                          br $B21
+                                        end
+                                        local.get $l3
+                                        local.get $p1
+                                        i32.const 1
+                                        i32.add
+                                        local.tee $l5
+                                        i32.store offset=40
+                                        local.get $p1
+                                        i32.load8_u
+                                        i32.const 63
+                                        i32.and
+                                      end
+                                      local.get $l12
+                                      i32.const 6
+                                      i32.shl
+                                      i32.or
+                                      local.tee $p1
+                                      local.get $l9
+                                      i32.const 12
+                                      i32.shl
+                                      i32.or
+                                      local.get $l6
+                                      i32.const 240
+                                      i32.lt_u
+                                      br_if $B17
+                                      drop
+                                      local.get $p0
+                                      local.get $l5
+                                      i32.eq
+                                      if $I23 (result i32)
+                                        i32.const 0
+                                      else
+                                        local.get $l3
+                                        local.get $l5
+                                        i32.const 1
+                                        i32.add
+                                        i32.store offset=40
+                                        local.get $l5
+                                        i32.load8_u
+                                        i32.const 63
+                                        i32.and
+                                      end
+                                      local.get $l9
+                                      i32.const 18
+                                      i32.shl
+                                      i32.const 1835008
+                                      i32.and
+                                      local.get $p1
+                                      i32.const 6
+                                      i32.shl
+                                      i32.or
+                                      i32.or
+                                    end
+                                    local.tee $p0
+                                    i32.const -9
+                                    i32.add
+                                    local.tee $l5
+                                    i32.const 30
+                                    i32.le_u
+                                    br_if $B11
+                                    local.get $p0
+                                    i32.const 92
+                                    i32.eq
+                                    br_if $B9
+                                    local.get $p0
+                                    i32.const 1114112
+                                    i32.ne
+                                    br_if $B10
+                                  end
+                                  local.get $l3
+                                  i32.load offset=64
+                                  i32.const 4
+                                  i32.eq
+                                  br_if $B13
+                                  local.get $l11
+                                  call $f184
+                                  local.tee $l4
+                                  i32.const 1114112
+                                  i32.eq
+                                  br_if $B13
+                                end
+                                local.get $p2
+                                i32.load offset=24
+                                local.get $l4
+                                local.get $p2
+                                i32.const 28
+                                i32.add
+                                i32.load
+                                i32.load offset=16
+                                call_indirect (type $t0) $T0
+                                br_if $B12
+                                local.get $l3
+                                i32.load offset=48
+                                local.set $l4
+                                br $L3
+                              end
+                              loop $L24
+                                local.get $l7
+                                i32.eqz
+                                br_if $B4
+                                local.get $l3
+                                local.get $l8
+                                i32.store offset=28
+                                local.get $l3
+                                i32.const 1
+                                i32.store offset=60
+                                local.get $l3
+                                i32.const 1
+                                i32.store offset=52
+                                local.get $l3
+                                i32.const 1051688
+                                i32.store offset=48
+                                local.get $l3
+                                i32.const 1
+                                i32.store offset=44
+                                local.get $l3
+                                i32.const 1051680
+                                i32.store offset=40
+                                local.get $l3
+                                i32.const 13
+                                i32.store offset=36
+                                local.get $l7
+                                i32.const -1
+                                i32.add
+                                local.set $l7
+                                local.get $l8
+                                i32.const 1
+                                i32.add
+                                local.set $l8
+                                local.get $l3
+                                local.get $l3
+                                i32.const 32
+                                i32.add
+                                i32.store offset=56
+                                local.get $l3
+                                local.get $l3
+                                i32.const 28
+                                i32.add
+                                i32.store offset=32
+                                local.get $p2
+                                local.get $l3
+                                i32.const 40
+                                i32.add
+                                call $f219
+                                i32.eqz
+                                br_if $L24
+                              end
+                            end
+                            i32.const 1
+                            br $B0
+                          end
+                          i32.const 116
+                          local.set $p1
+                          block $B25
+                            local.get $l5
+                            i32.const 1
+                            i32.sub
+                            br_table $B6 $B10 $B10 $B25 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B10 $B9 $B10 $B10 $B10 $B10 $B9 $B5
+                          end
+                          i32.const 114
+                          local.set $p1
+                          br $B5
+                        end
+                        local.get $p0
+                        i32.const 1
+                        i32.or
+                        i32.clz
+                        i32.const 2
+                        i32.shr_u
+                        i32.const 7
+                        i32.xor
+                        i64.extend_i32_u
+                        i64.const 21474836480
+                        i64.or
+                        local.get $p0
+                        call $f198
+                        br_if $B7
+                        drop
+                        i32.const 1
+                        local.set $l4
+                        local.get $p0
+                        call $f199
+                        i32.eqz
+                        br_if $B8
+                      end
+                      local.get $p0
+                      local.set $p1
+                      br $B5
+                    end
+                    local.get $p0
+                    i32.const 1
+                    i32.or
+                    i32.clz
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 7
+                    i32.xor
+                    i64.extend_i32_u
+                    i64.const 21474836480
+                    i64.or
+                  end
+                  local.set $l13
+                  i32.const 3
+                  local.set $l4
+                  local.get $p0
+                  local.set $p1
+                  br $B5
+                end
+                i32.const 110
+                local.set $p1
+              end
+              local.get $l3
+              local.get $l13
+              i64.store offset=56
+              local.get $l3
+              local.get $p1
+              i32.store offset=52
+              local.get $l3
+              local.get $l4
+              i32.store offset=48
+              br $L3
+            end
+          end
+          local.get $l3
+          i32.const 40
+          i32.add
+          local.get $l3
+          i32.const 16
+          i32.add
+          call $f196
+          local.get $l3
+          i32.load offset=40
+          local.tee $l4
+          br_if $L2
+        end
+      end
+      local.get $p2
+      i32.const 1050388
+      i32.const 1
+      call $f218
+    end
+    local.get $l3
+    i32.const 80
+    i32.add
+    global.set $g0)
+  (func $f43 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load offset=8
+    local.set $l3
+    local.get $p0
+    i32.load
+    local.set $p0
+    local.get $l2
+    local.get $p1
+    call $f223
+    local.get $l3
+    if $I0
+      loop $L1
+        local.get $l2
+        local.get $p0
+        i32.store offset=12
+        local.get $l2
+        local.get $l2
+        i32.const 12
+        i32.add
+        call $f203
+        local.get $p0
+        i32.const 1
+        i32.add
+        local.set $p0
+        local.get $l3
+        i32.const -1
+        i32.add
+        local.tee $l3
+        br_if $L1
+      end
+    end
+    local.get $l2
+    call $f208
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f44 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load
+    local.get $p0
+    i32.load offset=8
+    local.get $p1
+    call $f42)
+  (func $f45 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f188)
+  (func $f46 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=4
+    local.get $p1
+    call $f225)
+  (func $f47 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f229)
+  (func $f48 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    i32.const 0
+    i32.store offset=4
+    block $B0 (result i32)
+      block $B1
+        local.get $p1
+        i32.const 128
+        i32.ge_u
+        if $I2
+          local.get $p1
+          i32.const 2048
+          i32.lt_u
+          br_if $B1
+          local.get $p1
+          i32.const 65536
+          i32.lt_u
+          if $I3
+            local.get $l2
+            local.get $p1
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=6
+            local.get $l2
+            local.get $p1
+            i32.const 6
+            i32.shr_u
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=5
+            local.get $l2
+            local.get $p1
+            i32.const 12
+            i32.shr_u
+            i32.const 15
+            i32.and
+            i32.const 224
+            i32.or
+            i32.store8 offset=4
+            i32.const 3
+            br $B0
+          end
+          local.get $l2
+          local.get $p1
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=7
+          local.get $l2
+          local.get $p1
+          i32.const 18
+          i32.shr_u
+          i32.const 240
+          i32.or
+          i32.store8 offset=4
+          local.get $l2
+          local.get $p1
+          i32.const 6
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=6
+          local.get $l2
+          local.get $p1
+          i32.const 12
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=5
+          i32.const 4
+          br $B0
+        end
+        local.get $l2
+        local.get $p1
+        i32.store8 offset=4
+        i32.const 1
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.const 63
+      i32.and
+      i32.const 128
+      i32.or
+      i32.store8 offset=5
+      local.get $l2
+      local.get $p1
+      i32.const 6
+      i32.shr_u
+      i32.const 31
+      i32.and
+      i32.const 192
+      i32.or
+      i32.store8 offset=4
+      i32.const 2
+    end
+    local.set $p1
+    local.get $l2
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.get $l2
+    i32.const 4
+    i32.add
+    local.get $p1
+    call $f49
+    i32.const 0
+    local.set $p1
+    local.get $l2
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I4
+      local.get $l2
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I5
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $l3
+        i32.load offset=4
+        if $I6
+          local.get $l3
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f49 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $p1
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                local.get $p3
+                if $I6
+                  loop $L7
+                    local.get $p1
+                    local.get $p3
+                    i32.store offset=12
+                    local.get $p1
+                    local.get $p2
+                    i32.store offset=8
+                    local.get $p1
+                    i32.const 16
+                    i32.add
+                    i32.const 2
+                    local.get $p1
+                    i32.const 8
+                    i32.add
+                    call $f142
+                    block $B8
+                      local.get $p1
+                      i32.load16_u offset=16
+                      i32.const 1
+                      i32.ne
+                      if $I9
+                        local.get $p1
+                        i32.load offset=20
+                        local.tee $l4
+                        i32.eqz
+                        if $I10
+                          i32.const 28
+                          i32.const 1
+                          call $f36
+                          local.tee $p2
+                          i32.eqz
+                          br_if $B2
+                          local.get $p2
+                          i32.const 24
+                          i32.add
+                          i32.const 1050942
+                          i32.load align=1
+                          i32.store align=1
+                          local.get $p2
+                          i32.const 16
+                          i32.add
+                          i32.const 1050934
+                          i64.load align=1
+                          i64.store align=1
+                          local.get $p2
+                          i32.const 8
+                          i32.add
+                          i32.const 1050926
+                          i64.load align=1
+                          i64.store align=1
+                          local.get $p2
+                          i32.const 1050918
+                          i64.load align=1
+                          i64.store align=1
+                          i32.const 12
+                          i32.const 4
+                          call $f36
+                          local.tee $p3
+                          i32.eqz
+                          br_if $B1
+                          local.get $p3
+                          i64.const 120259084316
+                          i64.store offset=4 align=4
+                          local.get $p3
+                          local.get $p2
+                          i32.store
+                          i32.const 12
+                          i32.const 4
+                          call $f36
+                          local.tee $p2
+                          br_if $B4
+                          i32.const 12
+                          i32.const 4
+                          call $f168
+                          unreachable
+                        end
+                        local.get $p3
+                        local.get $l4
+                        i32.lt_u
+                        br_if $B0
+                        local.get $p2
+                        local.get $l4
+                        i32.add
+                        local.set $p2
+                        local.get $p3
+                        local.get $l4
+                        i32.sub
+                        local.set $p3
+                        br $B8
+                      end
+                      local.get $p1
+                      local.get $p1
+                      i32.load16_u offset=18
+                      i32.store16 offset=30
+                      local.get $p1
+                      i32.const 30
+                      i32.add
+                      i32.load16_u
+                      local.tee $l4
+                      call $f101
+                      i32.const 255
+                      i32.and
+                      i32.const 15
+                      i32.ne
+                      br_if $B5
+                    end
+                    local.get $p3
+                    br_if $L7
+                  end
+                end
+                local.get $p0
+                i32.const 3
+                i32.store8
+                br $B3
+              end
+              local.get $p0
+              i32.const 0
+              i32.store
+              local.get $p0
+              i32.const 4
+              i32.add
+              local.get $l4
+              i32.store
+              br $B3
+            end
+            local.get $p2
+            i32.const 14
+            i32.store8 offset=8
+            local.get $p2
+            i32.const 1050348
+            i32.store offset=4
+            local.get $p2
+            local.get $p3
+            i32.store
+            local.get $p2
+            local.get $p1
+            i32.load16_u offset=16 align=1
+            i32.store16 offset=9 align=1
+            local.get $p2
+            i32.const 11
+            i32.add
+            local.get $p1
+            i32.const 18
+            i32.add
+            i32.load8_u
+            i32.store8
+            local.get $p0
+            i32.const 4
+            i32.add
+            local.get $p2
+            i32.store
+            local.get $p0
+            i32.const 2
+            i32.store
+          end
+          local.get $p1
+          i32.const 32
+          i32.add
+          global.set $g0
+          return
+        end
+        i32.const 28
+        i32.const 1
+        call $f168
+        unreachable
+      end
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    local.get $l4
+    local.get $p3
+    call $f174
+    unreachable)
+  (func $f50 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    i32.const 0
+    i32.store offset=4
+    block $B0 (result i32)
+      block $B1
+        local.get $p1
+        i32.const 128
+        i32.ge_u
+        if $I2
+          local.get $p1
+          i32.const 2048
+          i32.lt_u
+          br_if $B1
+          local.get $p1
+          i32.const 65536
+          i32.lt_u
+          if $I3
+            local.get $l2
+            local.get $p1
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=6
+            local.get $l2
+            local.get $p1
+            i32.const 6
+            i32.shr_u
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=5
+            local.get $l2
+            local.get $p1
+            i32.const 12
+            i32.shr_u
+            i32.const 15
+            i32.and
+            i32.const 224
+            i32.or
+            i32.store8 offset=4
+            i32.const 3
+            br $B0
+          end
+          local.get $l2
+          local.get $p1
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=7
+          local.get $l2
+          local.get $p1
+          i32.const 18
+          i32.shr_u
+          i32.const 240
+          i32.or
+          i32.store8 offset=4
+          local.get $l2
+          local.get $p1
+          i32.const 6
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=6
+          local.get $l2
+          local.get $p1
+          i32.const 12
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=5
+          i32.const 4
+          br $B0
+        end
+        local.get $l2
+        local.get $p1
+        i32.store8 offset=4
+        i32.const 1
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.const 63
+      i32.and
+      i32.const 128
+      i32.or
+      i32.store8 offset=5
+      local.get $l2
+      local.get $p1
+      i32.const 6
+      i32.shr_u
+      i32.const 31
+      i32.and
+      i32.const 192
+      i32.or
+      i32.store8 offset=4
+      i32.const 2
+    end
+    local.set $p1
+    local.get $l2
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.get $l2
+    i32.const 4
+    i32.add
+    local.get $p1
+    call $f51
+    i32.const 0
+    local.set $p1
+    local.get $l2
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I4
+      local.get $l2
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I5
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $l3
+        i32.load offset=4
+        if $I6
+          local.get $l3
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f51 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l5
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                block $B6
+                  local.get $p3
+                  if $I7
+                    loop $L8
+                      local.get $p1
+                      i32.load
+                      local.tee $l4
+                      i32.load offset=4
+                      br_if $B4
+                      local.get $l4
+                      i32.const -1
+                      i32.store offset=4
+                      local.get $l5
+                      i32.const 8
+                      i32.add
+                      local.get $l4
+                      i32.const 8
+                      i32.add
+                      local.get $p2
+                      local.get $p3
+                      call $f103
+                      local.get $l4
+                      local.get $l4
+                      i32.load offset=4
+                      i32.const 1
+                      i32.add
+                      i32.store offset=4
+                      block $B9
+                        local.get $l5
+                        i32.load offset=8
+                        i32.const 1
+                        i32.ne
+                        if $I10
+                          local.get $l5
+                          i32.load offset=12
+                          local.tee $l4
+                          i32.eqz
+                          if $I11
+                            i32.const 28
+                            i32.const 1
+                            call $f36
+                            local.tee $p1
+                            i32.eqz
+                            br_if $B3
+                            local.get $p1
+                            i32.const 24
+                            i32.add
+                            i32.const 1050942
+                            i32.load align=1
+                            i32.store align=1
+                            local.get $p1
+                            i32.const 16
+                            i32.add
+                            i32.const 1050934
+                            i64.load align=1
+                            i64.store align=1
+                            local.get $p1
+                            i32.const 8
+                            i32.add
+                            i32.const 1050926
+                            i64.load align=1
+                            i64.store align=1
+                            local.get $p1
+                            i32.const 1050918
+                            i64.load align=1
+                            i64.store align=1
+                            i32.const 12
+                            i32.const 4
+                            call $f36
+                            local.tee $p2
+                            i32.eqz
+                            br_if $B2
+                            local.get $p2
+                            i64.const 120259084316
+                            i64.store offset=4 align=4
+                            local.get $p2
+                            local.get $p1
+                            i32.store
+                            i32.const 12
+                            i32.const 4
+                            call $f36
+                            local.tee $p1
+                            br_if $B5
+                            i32.const 12
+                            i32.const 4
+                            call $f168
+                            unreachable
+                          end
+                          local.get $p3
+                          local.get $l4
+                          i32.lt_u
+                          br_if $B1
+                          local.get $p2
+                          local.get $l4
+                          i32.add
+                          local.set $p2
+                          local.get $p3
+                          local.get $l4
+                          i32.sub
+                          local.set $p3
+                          br $B9
+                        end
+                        block $B12 (result i32)
+                          block $B13
+                            block $B14
+                              block $B15
+                                local.get $l5
+                                i32.load8_u offset=12
+                                local.tee $l4
+                                i32.const 1
+                                i32.sub
+                                br_table $B13 $B14 $B15
+                              end
+                              local.get $l5
+                              i32.load offset=16
+                              call $f101
+                              i32.const 255
+                              i32.and
+                              br $B12
+                            end
+                            local.get $l5
+                            i32.load offset=16
+                            i32.load8_u offset=8
+                            br $B12
+                          end
+                          local.get $l5
+                          i32.load8_u offset=13
+                        end
+                        i32.const 15
+                        i32.ne
+                        br_if $B6
+                        local.get $l4
+                        i32.const 2
+                        i32.lt_u
+                        br_if $B9
+                        local.get $l5
+                        i32.load offset=16
+                        local.tee $l4
+                        i32.load
+                        local.get $l4
+                        i32.load offset=4
+                        i32.load
+                        call_indirect (type $t2) $T0
+                        local.get $l4
+                        i32.load offset=4
+                        local.tee $l6
+                        i32.load offset=4
+                        if $I16
+                          local.get $l6
+                          i32.load offset=8
+                          drop
+                          local.get $l4
+                          i32.load
+                          call $f145
+                        end
+                        local.get $l4
+                        call $f145
+                      end
+                      local.get $p3
+                      br_if $L8
+                    end
+                  end
+                  local.get $p0
+                  i32.const 3
+                  i32.store8
+                  br $B0
+                end
+                local.get $p0
+                local.get $l5
+                i64.load offset=12 align=4
+                i64.store align=4
+                br $B0
+              end
+              local.get $p1
+              i32.const 14
+              i32.store8 offset=8
+              local.get $p1
+              i32.const 1050348
+              i32.store offset=4
+              local.get $p1
+              local.get $p2
+              i32.store
+              local.get $p1
+              local.get $l5
+              i32.load16_u offset=24 align=1
+              i32.store16 offset=9 align=1
+              local.get $p1
+              i32.const 11
+              i32.add
+              local.get $l5
+              i32.const 26
+              i32.add
+              i32.load8_u
+              i32.store8
+              local.get $p0
+              i32.const 4
+              i32.add
+              local.get $p1
+              i32.store
+              local.get $p0
+              i32.const 2
+              i32.store
+              br $B0
+            end
+            i32.const 1049320
+            i32.const 16
+            local.get $l5
+            i32.const 24
+            i32.add
+            i32.const 1049620
+            call $f192
+            unreachable
+          end
+          i32.const 28
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        i32.const 12
+        i32.const 4
+        call $f168
+        unreachable
+      end
+      local.get $l4
+      local.get $p3
+      call $f174
+      unreachable
+    end
+    local.get $l5
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f52 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1049216
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f53 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1049240
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f54 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i64)
+    global.get $g0
+    i32.const 96
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    i32.const 1
+    local.set $l2
+    block $B0
+      block $B1
+        i32.const 1060568
+        i32.load
+        i32.const 1
+        i32.ne
+        if $I2
+          i32.const 1060568
+          i64.const 1
+          i64.store
+          br $B1
+        end
+        i32.const 1060572
+        i32.load
+        i32.const 1
+        i32.gt_u
+        br_if $B0
+      end
+      i32.const 1060500
+      i32.load
+      local.tee $l2
+      i32.const 2
+      i32.gt_u
+      if $I3
+        i32.const 1
+        local.set $l2
+        br $B0
+      end
+      block $B4
+        block $B5
+          block $B6
+            local.get $l2
+            i32.const 1
+            i32.sub
+            br_table $B5 $B4 $B6
+          end
+          local.get $l1
+          i32.const -64
+          i32.sub
+          i32.const 1050160
+          i32.const 14
+          call $f88
+          block $B7
+            local.get $l1
+            i32.load offset=64
+            local.tee $l4
+            i32.eqz
+            if $I8
+              i32.const 5
+              local.set $l2
+              br $B7
+            end
+            local.get $l1
+            i32.load offset=68
+            block $B9
+              block $B10
+                local.get $l1
+                i32.const 72
+                i32.add
+                i32.load
+                i32.const -1
+                i32.add
+                local.tee $l2
+                i32.const 3
+                i32.gt_u
+                br_if $B10
+                block $B11
+                  block $B12
+                    local.get $l2
+                    i32.const 1
+                    i32.sub
+                    br_table $B10 $B10 $B11 $B12
+                  end
+                  i32.const 4
+                  local.set $l2
+                  i32.const 1
+                  local.set $l3
+                  local.get $l4
+                  i32.const 1050174
+                  i32.eq
+                  br_if $B9
+                  local.get $l4
+                  i32.load8_u
+                  i32.const 48
+                  i32.ne
+                  br_if $B10
+                  br $B9
+                end
+                i32.const 1
+                local.set $l2
+                i32.const 3
+                local.set $l3
+                local.get $l4
+                i32.const 1051508
+                i32.eq
+                br_if $B9
+                local.get $l4
+                i32.load align=1
+                i32.const 1819047270
+                i32.eq
+                br_if $B9
+              end
+              i32.const 0
+              local.set $l2
+              i32.const 2
+              local.set $l3
+            end
+            i32.eqz
+            br_if $B7
+            local.get $l4
+            call $f145
+          end
+          i32.const 1060500
+          i32.const 1
+          local.get $l3
+          local.get $l2
+          i32.const 5
+          i32.eq
+          local.tee $l3
+          select
+          i32.store
+          i32.const 4
+          local.get $l2
+          local.get $l3
+          select
+          local.set $l2
+          br $B0
+        end
+        i32.const 4
+        local.set $l2
+        br $B0
+      end
+      i32.const 0
+      local.set $l2
+    end
+    local.get $l1
+    local.get $l2
+    i32.store8 offset=35
+    block $B13
+      block $B14
+        local.get $p0
+        i32.load offset=12
+        local.tee $l2
+        if $I15
+          local.get $l1
+          local.get $l2
+          i32.store offset=36
+          local.get $l1
+          i32.const 24
+          i32.add
+          local.get $p0
+          call $f187
+          local.get $l1
+          i32.load offset=24
+          local.tee $l2
+          local.get $l1
+          i32.load offset=28
+          i32.load offset=12
+          call_indirect (type $t8) $T0
+          local.set $l6
+          local.get $l2
+          i32.const 0
+          local.get $l6
+          i64.const 1229646359891580772
+          i64.eq
+          select
+          br_if $B14
+          local.get $l1
+          i32.const 16
+          i32.add
+          local.get $p0
+          call $f187
+          local.get $l1
+          i32.load offset=16
+          local.tee $l2
+          local.get $l1
+          i32.load offset=20
+          i32.load offset=12
+          call_indirect (type $t8) $T0
+          local.set $l6
+          i32.const 8
+          local.set $p0
+          i32.const 1051792
+          local.set $l3
+          local.get $l2
+          i32.eqz
+          local.get $l6
+          i64.const 8634666484767235598
+          i64.ne
+          i32.or
+          i32.eqz
+          if $I16
+            local.get $l2
+            i32.load
+            local.set $l3
+            local.get $l2
+            i32.load offset=8
+            local.set $p0
+          end
+          local.get $l1
+          local.get $l3
+          i32.store offset=40
+          br $B13
+        end
+        i32.const 1049576
+        i32.const 43
+        i32.const 1049516
+        call $f172
+        unreachable
+      end
+      local.get $l1
+      local.get $l2
+      i32.load
+      i32.store offset=40
+      local.get $l2
+      i32.load offset=4
+      local.set $p0
+    end
+    local.get $l1
+    local.get $p0
+    i32.store offset=44
+    i32.const 0
+    local.set $p0
+    i32.const 1060556
+    i32.load
+    i32.const 1
+    i32.ne
+    if $I17
+      i32.const 1060556
+      i64.const 1
+      i64.store align=4
+      i32.const 1060564
+      i32.const 0
+      i32.store
+    end
+    local.get $l1
+    call $f81
+    local.tee $l2
+    i32.store offset=52
+    block $B18
+      local.get $l2
+      i32.load offset=16
+      local.tee $l3
+      if $I19
+        local.get $l2
+        i32.const 16
+        i32.add
+        i32.const 0
+        local.get $l3
+        select
+        local.tee $p0
+        i32.load offset=4
+        local.tee $l4
+        i32.const -1
+        i32.add
+        local.set $l3
+        local.get $l4
+        i32.eqz
+        br_if $B18
+        local.get $p0
+        i32.load
+        local.set $p0
+      end
+      local.get $l1
+      local.get $l3
+      i32.const 9
+      local.get $p0
+      select
+      i32.store offset=60
+      local.get $l1
+      local.get $p0
+      i32.const 1051800
+      local.get $p0
+      select
+      i32.store offset=56
+      local.get $l1
+      local.get $l1
+      i32.const 35
+      i32.add
+      i32.store offset=76
+      local.get $l1
+      local.get $l1
+      i32.const 36
+      i32.add
+      i32.store offset=72
+      local.get $l1
+      local.get $l1
+      i32.const 40
+      i32.add
+      i32.store offset=68
+      local.get $l1
+      local.get $l1
+      i32.const 56
+      i32.add
+      i32.store offset=64
+      i32.const 0
+      local.set $l4
+      local.get $l1
+      i32.const 8
+      i32.add
+      i32.const 0
+      local.get $l1
+      call $f114
+      local.get $l1
+      i32.load offset=12
+      local.set $p0
+      block $B20
+        local.get $l1
+        i32.load offset=8
+        local.tee $l3
+        if $I21
+          local.get $l1
+          local.get $p0
+          i32.store offset=84
+          local.get $l1
+          local.get $l3
+          i32.store offset=80
+          local.get $l1
+          i32.const -64
+          i32.sub
+          local.get $l1
+          i32.const 80
+          i32.add
+          i32.const 1051848
+          call $f131
+          local.get $l1
+          local.get $l1
+          i32.load offset=80
+          local.get $l1
+          i32.load offset=84
+          call $f114
+          block $B22
+            local.get $l1
+            i32.load
+            local.tee $l4
+            i32.eqz
+            br_if $B22
+            local.get $l4
+            local.get $l1
+            i32.load offset=4
+            local.tee $l5
+            i32.load
+            call_indirect (type $t2) $T0
+            local.get $l5
+            i32.load offset=4
+            i32.eqz
+            br_if $B22
+            local.get $l5
+            i32.load offset=8
+            drop
+            local.get $l4
+            call $f145
+          end
+          i32.const 1
+          local.set $l4
+          br $B20
+        end
+        local.get $l1
+        i32.const -64
+        i32.sub
+        local.get $l1
+        i32.const 88
+        i32.add
+        i32.const 1051812
+        call $f131
+      end
+      local.get $l2
+      local.get $l2
+      i32.load
+      local.tee $l2
+      i32.const -1
+      i32.add
+      i32.store
+      local.get $l2
+      i32.const 1
+      i32.eq
+      if $I23
+        local.get $l1
+        i32.const 52
+        i32.add
+        call $f78
+      end
+      block $B24
+        local.get $l4
+        i32.const 1
+        i32.xor
+        local.get $l3
+        i32.const 0
+        i32.ne
+        i32.and
+        i32.eqz
+        br_if $B24
+        local.get $l3
+        local.get $p0
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p0
+        i32.load offset=4
+        i32.eqz
+        br_if $B24
+        local.get $p0
+        i32.load offset=8
+        drop
+        local.get $l3
+        call $f145
+      end
+      local.get $l1
+      i32.const 96
+      i32.add
+      global.set $g0
+      return
+    end
+    local.get $l3
+    i32.const 0
+    call $f173
+    unreachable)
+  (func $f55 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    local.get $p1
+    i32.store offset=12
+    local.get $l3
+    local.get $p0
+    i32.store offset=8
+    local.get $l3
+    i32.const 8
+    i32.add
+    i32.const 1052068
+    i32.const 0
+    local.get $p2
+    call $f134
+    unreachable)
+  (func $f56 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load8_u offset=4
+    i32.eqz
+    if $I0
+      local.get $p0
+      i32.const 0
+      i32.store8 offset=4
+      local.get $p0
+      i32.load
+      local.set $l1
+      local.get $p0
+      i32.const 1
+      i32.store
+      local.get $l1
+      i32.load
+      local.tee $p0
+      local.get $p0
+      i32.load
+      local.tee $p0
+      i32.const -1
+      i32.add
+      i32.store
+      local.get $p0
+      i32.const 1
+      i32.eq
+      if $I1
+        local.get $l1
+        call $f57
+      end
+      local.get $l1
+      call $f145
+      return
+    end
+    i32.const 1052440
+    i32.const 32
+    i32.const 1052424
+    call $f55
+    unreachable)
+  (func $f57 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.tee $l3
+    i32.const 16
+    i32.add
+    local.set $l4
+    block $B0
+      local.get $l3
+      i32.const 28
+      i32.add
+      i32.load8_u
+      i32.const 2
+      i32.eq
+      br_if $B0
+      local.get $l3
+      i32.const 29
+      i32.add
+      i32.load8_u
+      br_if $B0
+      local.get $l2
+      i32.const 8
+      i32.add
+      local.get $l4
+      call $f79
+      local.get $l2
+      i32.load8_u offset=8
+      i32.const 2
+      i32.ne
+      br_if $B0
+      local.get $l2
+      i32.load offset=12
+      local.tee $l1
+      i32.load
+      local.get $l1
+      i32.load offset=4
+      i32.load
+      call_indirect (type $t2) $T0
+      local.get $l1
+      i32.load offset=4
+      local.tee $l5
+      i32.load offset=4
+      if $I1
+        local.get $l5
+        i32.load offset=8
+        drop
+        local.get $l1
+        i32.load
+        call $f145
+      end
+      local.get $l1
+      call $f145
+    end
+    local.get $l3
+    i32.const 20
+    i32.add
+    i32.load
+    if $I2
+      local.get $l4
+      i32.load
+      call $f145
+    end
+    local.get $p0
+    i32.load
+    local.tee $l1
+    local.get $l1
+    i32.load offset=4
+    local.tee $l1
+    i32.const -1
+    i32.add
+    i32.store offset=4
+    local.get $l1
+    i32.const 1
+    i32.eq
+    if $I3
+      local.get $p0
+      i32.load
+      call $f145
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f58 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0 (result i32)
+      local.get $p2
+      i32.load
+      i32.const 1
+      i32.eq
+      if $I1
+        i32.const 1051512
+        local.set $p2
+        i32.const 9
+        br $B0
+      end
+      local.get $l3
+      i32.const 16
+      i32.add
+      local.get $p2
+      i32.load offset=4
+      local.get $p2
+      i32.const 8
+      i32.add
+      i32.load
+      call $f201
+      i32.const 1051512
+      local.get $l3
+      i32.load offset=20
+      local.get $l3
+      i32.load offset=16
+      i32.const 1
+      i32.eq
+      local.tee $l4
+      select
+      local.set $p2
+      i32.const 9
+      local.get $l3
+      i32.const 24
+      i32.add
+      i32.load
+      local.get $l4
+      select
+    end
+    local.set $l4
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p2
+    local.get $l4
+    call $f195
+    local.get $l3
+    i32.load offset=8
+    local.get $l3
+    i32.load offset=12
+    local.get $p1
+    call $f197
+    block $B2
+      local.get $p0
+      i32.load
+      local.tee $p2
+      i32.eqz
+      br_if $B2
+      local.get $p0
+      i32.load offset=4
+      i32.eqz
+      br_if $B2
+      local.get $p2
+      call $f145
+    end
+    local.get $l3
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f59 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.load
+    i32.store offset=12
+    local.get $l2
+    i32.const 12
+    i32.add
+    local.get $p1
+    call $f60
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f60 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load8_u
+    local.get $p0
+    i32.const 0
+    i32.store8
+    i32.const 1
+    i32.and
+    if $I0
+      i32.const 1
+      local.set $l4
+      loop $L1
+        block $B2
+          block $B3
+            block $B4
+              i32.const 1060577
+              i32.load8_u
+              i32.eqz
+              if $I5
+                i32.const 1060496
+                i32.load
+                local.set $l2
+                i32.const 1060496
+                local.get $l4
+                i32.const 10
+                i32.eq
+                i32.store
+                i32.const 1060577
+                i32.const 0
+                i32.store8
+                local.get $l2
+                i32.const 1
+                i32.le_u
+                if $I6
+                  local.get $l2
+                  i32.const 1
+                  i32.sub
+                  br_if $B2
+                  i32.const 1051360
+                  i32.const 31
+                  i32.const 1051344
+                  call $f55
+                  unreachable
+                end
+                local.get $l2
+                i32.load
+                local.tee $p1
+                local.get $l2
+                i32.load offset=8
+                local.tee $l3
+                i32.const 3
+                i32.shl
+                i32.add
+                local.set $l5
+                local.get $l2
+                i32.load offset=4
+                local.set $l7
+                local.get $p1
+                local.set $p0
+                local.get $l3
+                i32.eqz
+                br_if $B4
+                loop $L7
+                  local.get $p0
+                  i32.load
+                  local.tee $l3
+                  i32.eqz
+                  if $I8
+                    local.get $p0
+                    i32.const 8
+                    i32.add
+                    local.set $p0
+                    br $B4
+                  end
+                  local.get $l3
+                  local.get $p0
+                  i32.const 4
+                  i32.add
+                  i32.load
+                  call $f80
+                  local.get $p0
+                  i32.const 8
+                  i32.add
+                  local.tee $p0
+                  local.get $l5
+                  i32.ne
+                  br_if $L7
+                end
+                br $B3
+              end
+              i32.const 1052440
+              i32.const 32
+              i32.const 1052424
+              call $f55
+              unreachable
+            end
+            local.get $p0
+            local.get $l5
+            i32.eq
+            br_if $B3
+            loop $L9
+              local.get $p0
+              i32.load
+              local.tee $l3
+              i32.eqz
+              br_if $B3
+              local.get $l3
+              local.get $p0
+              i32.const 4
+              i32.add
+              i32.load
+              local.tee $l6
+              i32.load
+              call_indirect (type $t2) $T0
+              local.get $l6
+              i32.load offset=4
+              if $I10
+                local.get $l6
+                i32.load offset=8
+                drop
+                local.get $l3
+                call $f145
+              end
+              local.get $p0
+              i32.const 8
+              i32.add
+              local.tee $p0
+              local.get $l5
+              i32.ne
+              br_if $L9
+            end
+          end
+          local.get $l7
+          if $I11
+            local.get $p1
+            call $f145
+          end
+          local.get $l2
+          call $f145
+        end
+        local.get $l4
+        local.get $l4
+        i32.const 10
+        i32.lt_u
+        local.tee $p0
+        i32.add
+        local.set $l4
+        local.get $p0
+        br_if $L1
+      end
+      return
+    end
+    i32.const 1049576
+    i32.const 43
+    i32.const 1049516
+    call $f172
+    unreachable)
+  (func $f61 (type $t2) (param $p0 i32)
+    block $B0
+      local.get $p0
+      i32.load8_u offset=4
+      br_if $B0
+      i32.const 1060568
+      i32.load
+      i32.const 1
+      i32.ne
+      if $I1
+        i32.const 1060568
+        i64.const 1
+        i64.store
+        br $B0
+      end
+      i32.const 1060572
+      i32.load
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.load
+      i32.const 1
+      i32.store8 offset=4
+    end
+    local.get $p0
+    i32.load
+    i32.load
+    i32.const 0
+    i32.store8)
+  (func $f62 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32)
+    local.get $p0
+    i32.load8_u offset=4
+    i32.const 2
+    i32.eq
+    if $I0
+      local.get $p0
+      i32.const 8
+      i32.add
+      i32.load
+      local.tee $l1
+      i32.load
+      local.get $l1
+      i32.load offset=4
+      i32.load
+      call_indirect (type $t2) $T0
+      local.get $l1
+      i32.load offset=4
+      local.tee $l2
+      i32.load offset=4
+      if $I1
+        local.get $l2
+        i32.load offset=8
+        drop
+        local.get $l1
+        i32.load
+        call $f145
+      end
+      local.get $p0
+      i32.load offset=8
+      call $f145
+    end)
+  (func $f63 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    block $B0
+      local.get $p0
+      i32.load offset=4
+      local.tee $l1
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.const 8
+      i32.add
+      i32.load
+      i32.eqz
+      br_if $B0
+      local.get $l1
+      call $f145
+    end)
+  (func $f64 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=4
+    i32.load
+    call_indirect (type $t2) $T0
+    local.get $p0
+    i32.load offset=4
+    local.tee $l1
+    i32.load offset=4
+    if $I0
+      local.get $l1
+      i32.load offset=8
+      drop
+      local.get $p0
+      i32.load
+      call $f145
+    end)
+  (func $f65 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    block $B0
+      local.get $p0
+      i32.load
+      local.tee $l1
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.load offset=4
+      i32.eqz
+      br_if $B0
+      local.get $l1
+      call $f145
+    end)
+  (func $f66 (type $t2) (param $p0 i32)
+    local.get $p0
+    i32.const 8
+    i32.add
+    i32.load
+    if $I0
+      local.get $p0
+      i32.load offset=4
+      call $f145
+    end)
+  (func $f67 (type $t5) (param $p0 i32) (result i32)
+    local.get $p0
+    i32.eqz
+    if $I0
+      i32.const 1049576
+      i32.const 43
+      i32.const 1049516
+      call $f172
+      unreachable
+    end
+    local.get $p0)
+  (func $f68 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f48)
+  (func $f69 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f50)
+  (func $f70 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0
+      local.get $p0
+      i32.load
+      local.tee $p0
+      block $B1 (result i32)
+        block $B2
+          local.get $p1
+          i32.const 128
+          i32.ge_u
+          if $I3
+            local.get $l2
+            i32.const 0
+            i32.store offset=12
+            local.get $p1
+            i32.const 2048
+            i32.lt_u
+            br_if $B2
+            local.get $p1
+            i32.const 65536
+            i32.lt_u
+            if $I4
+              local.get $l2
+              local.get $p1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=14
+              local.get $l2
+              local.get $p1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=13
+              local.get $l2
+              local.get $p1
+              i32.const 12
+              i32.shr_u
+              i32.const 15
+              i32.and
+              i32.const 224
+              i32.or
+              i32.store8 offset=12
+              i32.const 3
+              br $B1
+            end
+            local.get $l2
+            local.get $p1
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=15
+            local.get $l2
+            local.get $p1
+            i32.const 18
+            i32.shr_u
+            i32.const 240
+            i32.or
+            i32.store8 offset=12
+            local.get $l2
+            local.get $p1
+            i32.const 6
+            i32.shr_u
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=14
+            local.get $l2
+            local.get $p1
+            i32.const 12
+            i32.shr_u
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=13
+            i32.const 4
+            br $B1
+          end
+          local.get $p0
+          i32.load offset=8
+          local.tee $l3
+          local.get $p0
+          i32.load offset=4
+          i32.eq
+          if $I5 (result i32)
+            local.get $p0
+            i32.const 1
+            call $f71
+            local.get $p0
+            i32.load offset=8
+          else
+            local.get $l3
+          end
+          local.get $p0
+          i32.load
+          i32.add
+          local.get $p1
+          i32.store8
+          local.get $p0
+          local.get $p0
+          i32.load offset=8
+          i32.const 1
+          i32.add
+          i32.store offset=8
+          br $B0
+        end
+        local.get $l2
+        local.get $p1
+        i32.const 63
+        i32.and
+        i32.const 128
+        i32.or
+        i32.store8 offset=13
+        local.get $l2
+        local.get $p1
+        i32.const 6
+        i32.shr_u
+        i32.const 31
+        i32.and
+        i32.const 192
+        i32.or
+        i32.store8 offset=12
+        i32.const 2
+      end
+      local.tee $p1
+      call $f71
+      local.get $p0
+      local.get $p0
+      i32.load offset=8
+      local.tee $l3
+      local.get $p1
+      i32.add
+      i32.store offset=8
+      local.get $l3
+      local.get $p0
+      i32.load
+      i32.add
+      local.get $l2
+      i32.const 12
+      i32.add
+      local.get $p1
+      call $f162
+      drop
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0
+    i32.const 0)
+  (func $f71 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32)
+    block $B0
+      block $B1
+        local.get $p0
+        i32.load offset=4
+        local.tee $l2
+        local.get $p0
+        i32.load offset=8
+        local.tee $l3
+        i32.sub
+        local.get $p1
+        i32.lt_u
+        if $I2
+          local.get $p1
+          local.get $l3
+          i32.add
+          local.tee $p1
+          local.get $l3
+          i32.lt_u
+          br_if $B0
+          local.get $l2
+          i32.const 1
+          i32.shl
+          local.tee $l3
+          local.get $p1
+          local.get $l3
+          local.get $p1
+          i32.gt_u
+          select
+          local.tee $p1
+          i32.const 0
+          i32.lt_s
+          br_if $B0
+          block $B3 (result i32)
+            local.get $l2
+            i32.eqz
+            if $I4
+              local.get $p1
+              i32.const 1
+              call $f36
+              br $B3
+            end
+            local.get $p0
+            i32.load
+            local.get $l2
+            i32.const 1
+            local.get $p1
+            call $f37
+          end
+          local.tee $l2
+          i32.eqz
+          br_if $B1
+          local.get $p0
+          local.get $p1
+          i32.store offset=4
+          local.get $p0
+          local.get $l2
+          i32.store
+        end
+        return
+      end
+      local.get $p1
+      i32.const 1
+      call $f168
+      unreachable
+    end
+    call $f169
+    unreachable)
+  (func $f72 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.load
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1049216
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f73 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.load
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1049240
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f74 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.load
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1049264
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f75 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load
+    local.get $p1
+    local.get $p2
+    call $f51
+    i32.const 0
+    local.set $p1
+    local.get $l3
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I0
+      local.get $l3
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I1
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $p2
+        i32.load offset=4
+        if $I2
+          local.get $p2
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f76 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load
+    local.get $p1
+    local.get $p2
+    call $f49
+    i32.const 0
+    local.set $p1
+    local.get $l3
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I0
+      local.get $l3
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I1
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $p2
+        i32.load offset=4
+        if $I2
+          local.get $p2
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f77 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    local.get $p2
+    call $f71
+    local.get $p0
+    local.get $p0
+    i32.load offset=8
+    local.tee $l3
+    local.get $p2
+    i32.add
+    i32.store offset=8
+    local.get $l3
+    local.get $p0
+    i32.load
+    i32.add
+    local.get $p1
+    local.get $p2
+    call $f162
+    drop
+    i32.const 0)
+  (func $f78 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32)
+    block $B0
+      local.get $p0
+      i32.load
+      local.tee $l1
+      i32.const 16
+      i32.add
+      i32.load
+      local.tee $l2
+      i32.eqz
+      br_if $B0
+      local.get $l2
+      i32.const 0
+      i32.store8
+      local.get $l1
+      i32.const 20
+      i32.add
+      i32.load
+      i32.eqz
+      br_if $B0
+      local.get $l1
+      i32.load offset=16
+      call $f145
+    end
+    local.get $l1
+    i32.const 28
+    i32.add
+    i32.load
+    call $f145
+    local.get $p0
+    i32.load
+    local.tee $l1
+    local.get $l1
+    i32.load offset=4
+    local.tee $l1
+    i32.const -1
+    i32.add
+    i32.store offset=4
+    local.get $l1
+    i32.const 1
+    i32.eq
+    if $I1
+      local.get $p0
+      i32.load
+      call $f145
+    end)
+  (func $f79 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    block $B0
+      block $B1
+        local.get $p1
+        i32.load offset=8
+        local.tee $l6
+        i32.eqz
+        if $I2
+          i32.const 3
+          local.set $l3
+          br $B1
+        end
+        block $B3 (result i32)
+          loop $L4
+            local.get $p1
+            i32.const 1
+            i32.store8 offset=13
+            block $B5
+              block $B6
+                block $B7
+                  local.get $p1
+                  i32.load8_u offset=12
+                  local.tee $l2
+                  i32.const 2
+                  i32.ne
+                  if $I8
+                    local.get $p1
+                    i32.load offset=8
+                    local.tee $l3
+                    local.get $l5
+                    i32.lt_u
+                    br_if $B7
+                    local.get $l3
+                    local.get $l5
+                    i32.sub
+                    local.set $l3
+                    block $B9
+                      local.get $l2
+                      i32.const 1
+                      i32.eq
+                      br_if $B9
+                      local.get $p1
+                      i32.load
+                      local.set $l2
+                      local.get $l4
+                      local.get $l3
+                      i32.store offset=12
+                      local.get $l4
+                      local.get $l2
+                      local.get $l5
+                      i32.add
+                      i32.store offset=8
+                      local.get $l4
+                      i32.const 16
+                      i32.add
+                      i32.const 1
+                      local.get $l4
+                      i32.const 8
+                      i32.add
+                      call $f142
+                      local.get $l4
+                      i32.load16_u offset=16
+                      i32.const 1
+                      i32.eq
+                      if $I10
+                        local.get $l4
+                        local.get $l4
+                        i32.load16_u offset=18
+                        i32.store16 offset=30
+                        local.get $l4
+                        i32.const 30
+                        i32.add
+                        i32.load16_u
+                        local.tee $l2
+                        i32.const 8
+                        i32.eq
+                        br_if $B9
+                        local.get $p1
+                        i32.const 0
+                        i32.store8 offset=13
+                        i32.const 0
+                        local.get $l2
+                        call $f101
+                        i32.const 255
+                        i32.and
+                        i32.const 15
+                        i32.ne
+                        br_if $B3
+                        drop
+                        br $B5
+                      end
+                      local.get $l4
+                      i32.load offset=20
+                      local.set $l3
+                    end
+                    local.get $p1
+                    i32.const 0
+                    i32.store8 offset=13
+                    local.get $l3
+                    i32.eqz
+                    br_if $B6
+                    local.get $l3
+                    local.get $l5
+                    i32.add
+                    local.set $l5
+                    br $B5
+                  end
+                  i32.const 1049576
+                  i32.const 43
+                  i32.const 1049516
+                  call $f172
+                  unreachable
+                end
+                local.get $l5
+                local.get $l3
+                call $f174
+                unreachable
+              end
+              block $B11
+                i32.const 33
+                i32.const 1
+                call $f36
+                local.tee $l2
+                if $I12
+                  local.get $l2
+                  i32.const 32
+                  i32.add
+                  i32.const 1050454
+                  i32.load8_u
+                  i32.store8
+                  local.get $l2
+                  i32.const 24
+                  i32.add
+                  i32.const 1050446
+                  i64.load align=1
+                  i64.store align=1
+                  local.get $l2
+                  i32.const 16
+                  i32.add
+                  i32.const 1050438
+                  i64.load align=1
+                  i64.store align=1
+                  local.get $l2
+                  i32.const 8
+                  i32.add
+                  i32.const 1050430
+                  i64.load align=1
+                  i64.store align=1
+                  local.get $l2
+                  i32.const 1050422
+                  i64.load align=1
+                  i64.store align=1
+                  i32.const 12
+                  i32.const 4
+                  call $f36
+                  local.tee $l3
+                  i32.eqz
+                  br_if $B11
+                  local.get $l3
+                  i64.const 141733920801
+                  i64.store offset=4 align=4
+                  local.get $l3
+                  local.get $l2
+                  i32.store
+                  i32.const 12
+                  i32.const 4
+                  call $f36
+                  local.tee $l2
+                  i32.eqz
+                  if $I13
+                    i32.const 12
+                    i32.const 4
+                    call $f168
+                    unreachable
+                  end
+                  local.get $l2
+                  i32.const 14
+                  i32.store8 offset=8
+                  local.get $l2
+                  i32.const 1050348
+                  i32.store offset=4
+                  local.get $l2
+                  local.get $l3
+                  i32.store
+                  local.get $l2
+                  local.get $l4
+                  i32.load16_u offset=16 align=1
+                  i32.store16 offset=9 align=1
+                  local.get $l2
+                  i32.const 11
+                  i32.add
+                  local.get $l4
+                  i32.const 18
+                  i32.add
+                  i32.load8_u
+                  i32.store8
+                  i32.const 2
+                  br $B3
+                end
+                i32.const 33
+                i32.const 1
+                call $f168
+                unreachable
+              end
+              i32.const 12
+              i32.const 4
+              call $f168
+              unreachable
+            end
+            local.get $l5
+            local.get $l6
+            i32.lt_u
+            br_if $L4
+          end
+          i32.const 3
+        end
+        local.set $l3
+        local.get $l5
+        i32.eqz
+        br_if $B1
+        local.get $p1
+        i32.load offset=8
+        local.tee $l6
+        local.get $l5
+        i32.lt_u
+        br_if $B0
+        local.get $p1
+        i32.const 0
+        i32.store offset=8
+        local.get $l6
+        local.get $l5
+        i32.sub
+        local.tee $l6
+        i32.eqz
+        br_if $B1
+        local.get $p1
+        i32.load
+        local.tee $l7
+        local.get $l5
+        local.get $l7
+        i32.add
+        local.get $l6
+        call $f159
+        local.get $p1
+        local.get $l6
+        i32.store offset=8
+      end
+      local.get $p0
+      local.get $l3
+      i32.store
+      local.get $p0
+      i32.const 4
+      i32.add
+      local.get $l2
+      i32.store
+      local.get $l4
+      i32.const 32
+      i32.add
+      global.set $g0
+      return
+    end
+    i32.const 1049792
+    i32.const 28
+    i32.const 1049776
+    call $f172
+    unreachable)
+  (func $f80 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    local.tee $l2
+    local.get $l2
+    local.get $p1
+    i32.load offset=4
+    local.tee $l2
+    i32.const 15
+    i32.add
+    i32.const -16
+    i32.and
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    local.get $l4
+    local.get $p0
+    local.get $l2
+    call $f162
+    local.get $p1
+    i32.load offset=12
+    call_indirect (type $t2) $T0
+    local.get $l2
+    if $I0
+      local.get $p1
+      i32.load offset=8
+      drop
+      local.get $p0
+      call $f145
+    end
+    global.set $g0)
+  (func $f81 (type $t10) (result i32)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    block $B0
+      block $B1
+        i32.const 1060560
+        i32.load
+        local.tee $l0
+        i32.const 1
+        i32.add
+        i32.const 0
+        i32.gt_s
+        if $I2
+          i32.const 1060560
+          local.get $l0
+          i32.store
+          i32.const 1060564
+          i32.load
+          local.tee $l2
+          i32.eqz
+          if $I3
+            local.get $l1
+            i32.const 0
+            i32.store offset=8
+            local.get $l1
+            i32.const 8
+            i32.add
+            call $f85
+            local.set $l2
+            i32.const 1060560
+            i32.load
+            br_if $B0
+            i32.const 1060560
+            i32.const -1
+            i32.store
+            block $B4
+              i32.const 1060564
+              i32.load
+              local.tee $l0
+              i32.eqz
+              br_if $B4
+              local.get $l0
+              local.get $l0
+              i32.load
+              local.tee $l0
+              i32.const -1
+              i32.add
+              i32.store
+              local.get $l0
+              i32.const 1
+              i32.ne
+              br_if $B4
+              i32.const 1060564
+              call $f78
+            end
+            i32.const 1060564
+            local.get $l2
+            i32.store
+            i32.const 1060560
+            i32.const 1060560
+            i32.load
+            i32.const 1
+            i32.add
+            local.tee $l0
+            i32.store
+          end
+          local.get $l0
+          br_if $B0
+          i32.const 1060560
+          i32.const -1
+          i32.store
+          local.get $l2
+          local.get $l2
+          i32.load
+          local.tee $l0
+          i32.const 1
+          i32.add
+          i32.store
+          local.get $l0
+          i32.const -1
+          i32.le_s
+          br_if $B1
+          i32.const 1060560
+          i32.const 1060560
+          i32.load
+          i32.const 1
+          i32.add
+          i32.store
+          local.get $l1
+          i32.const 32
+          i32.add
+          global.set $g0
+          local.get $l2
+          return
+        end
+        i32.const 1049336
+        i32.const 24
+        local.get $l1
+        i32.const 24
+        i32.add
+        i32.const 1049652
+        call $f192
+        unreachable
+      end
+      unreachable
+    end
+    i32.const 1049320
+    i32.const 16
+    local.get $l1
+    i32.const 24
+    i32.add
+    i32.const 1049620
+    call $f192
+    unreachable)
+  (func $f82 (type $t7)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 96
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    i32.const 1060556
+    i32.load
+    i32.const 1
+    i32.ne
+    if $I0
+      i32.const 1060556
+      i64.const 1
+      i64.store align=4
+      i32.const 1060564
+      i32.const 0
+      i32.store
+    end
+    call $f81
+    local.tee $l1
+    i32.const 0
+    local.get $l1
+    i32.load offset=24
+    local.tee $l3
+    local.get $l3
+    i32.const 2
+    i32.eq
+    local.tee $l3
+    select
+    i32.store offset=24
+    local.get $l0
+    local.get $l1
+    i32.store offset=8
+    block $B1
+      local.get $l3
+      br_if $B1
+      block $B2
+        block $B3
+          local.get $l0
+          i32.load offset=8
+          local.tee $l3
+          i32.const 28
+          i32.add
+          local.tee $l4
+          i32.load
+          local.tee $l1
+          i32.load8_u
+          i32.eqz
+          if $I4
+            local.get $l1
+            i32.const 1
+            i32.store8
+            i32.const 0
+            local.set $l1
+            block $B5
+              i32.const 1060568
+              i32.load
+              i32.const 1
+              i32.eq
+              if $I6
+                i32.const 1060572
+                i32.load
+                local.set $l1
+                br $B5
+              end
+              i32.const 1060568
+              i64.const 1
+              i64.store
+            end
+            i32.const 1060572
+            local.get $l1
+            i32.store
+            local.get $l3
+            i32.const 32
+            i32.add
+            i32.load8_u
+            br_if $B3
+            local.get $l3
+            i32.const 24
+            i32.add
+            local.tee $l2
+            local.get $l2
+            i32.load
+            local.tee $l2
+            i32.const 1
+            local.get $l2
+            select
+            i32.store
+            local.get $l2
+            if $I7
+              local.get $l2
+              i32.const 2
+              i32.ne
+              if $I8
+                i32.const 1049912
+                i32.const 23
+                i32.const 1049896
+                call $f55
+                unreachable
+              end
+              local.get $l0
+              i32.load offset=8
+              i32.const 24
+              i32.add
+              local.tee $l5
+              i32.load
+              local.set $l2
+              local.get $l5
+              i32.const 0
+              i32.store
+              local.get $l0
+              local.get $l2
+              i32.store offset=12
+              local.get $l2
+              i32.const 2
+              i32.ne
+              br_if $B2
+              block $B9
+                local.get $l1
+                br_if $B9
+                i32.const 1060568
+                i32.load
+                i32.const 1
+                i32.ne
+                if $I10
+                  i32.const 1060568
+                  i64.const 1
+                  i64.store
+                  br $B9
+                end
+                i32.const 1060572
+                i32.load
+                i32.eqz
+                br_if $B9
+                local.get $l3
+                i32.const 1
+                i32.store8 offset=32
+              end
+              local.get $l4
+              i32.load
+              i32.const 0
+              i32.store8
+              br $B1
+            end
+            local.get $l0
+            i32.load offset=8
+            i32.const 36
+            i32.add
+            local.tee $l0
+            local.get $l4
+            i32.load
+            call $f83
+            local.get $l0
+            i32.load
+            drop
+            i32.const 1052356
+            i32.const 29
+            i32.const 1052340
+            call $f55
+            unreachable
+          end
+          i32.const 1052440
+          i32.const 32
+          i32.const 1052424
+          call $f55
+          unreachable
+        end
+        local.get $l0
+        local.get $l4
+        i32.store offset=72
+        local.get $l0
+        local.get $l1
+        i32.const 0
+        i32.ne
+        i32.store8 offset=76
+        i32.const 1049668
+        i32.const 43
+        local.get $l0
+        i32.const 72
+        i32.add
+        i32.const 1049728
+        call $f192
+        unreachable
+      end
+      local.get $l0
+      i32.const 60
+      i32.add
+      i32.const 4
+      i32.store
+      local.get $l0
+      i32.const 52
+      i32.add
+      i32.const 14
+      i32.store
+      local.get $l0
+      i32.const 36
+      i32.add
+      i32.const 3
+      i32.store
+      local.get $l0
+      local.get $l0
+      i32.const 12
+      i32.add
+      i32.store offset=64
+      local.get $l0
+      i32.const 1049936
+      i32.store offset=68
+      local.get $l0
+      i64.const 3
+      i64.store offset=20 align=4
+      local.get $l0
+      i32.const 1049552
+      i32.store offset=16
+      local.get $l0
+      i32.const 14
+      i32.store offset=44
+      local.get $l0
+      i64.const 4
+      i64.store offset=88
+      local.get $l0
+      i64.const 1
+      i64.store offset=76 align=4
+      local.get $l0
+      i32.const 1049972
+      i32.store offset=72
+      local.get $l0
+      local.get $l0
+      i32.const 40
+      i32.add
+      i32.store offset=32
+      local.get $l0
+      local.get $l0
+      i32.const 72
+      i32.add
+      i32.store offset=56
+      local.get $l0
+      local.get $l0
+      i32.const 68
+      i32.add
+      i32.store offset=48
+      local.get $l0
+      local.get $l0
+      i32.const -64
+      i32.sub
+      i32.store offset=40
+      local.get $l0
+      i32.const 16
+      i32.add
+      i32.const 1049980
+      call $f84
+      unreachable
+    end
+    local.get $l0
+    i32.load offset=8
+    local.tee $l1
+    local.get $l1
+    i32.load
+    local.tee $l1
+    i32.const -1
+    i32.add
+    i32.store
+    local.get $l1
+    i32.const 1
+    i32.eq
+    if $I11
+      local.get $l0
+      i32.const 8
+      i32.add
+      call $f78
+    end
+    local.get $l0
+    i32.const 96
+    i32.add
+    global.set $g0)
+  (func $f83 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p0
+    i32.load offset=4
+    local.tee $p0
+    local.get $p1
+    local.get $p0
+    select
+    i32.store offset=4
+    local.get $p0
+    i32.eqz
+    local.get $p0
+    local.get $p1
+    i32.eq
+    i32.or
+    i32.eqz
+    if $I0
+      i32.const 1051056
+      i32.const 54
+      i32.const 1051040
+      call $f55
+      unreachable
+    end)
+  (func $f84 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p1
+    i32.load
+    local.get $p1
+    i32.load offset=4
+    local.get $p1
+    i32.load offset=8
+    local.get $p1
+    i32.load offset=12
+    call $f186
+    local.get $l2
+    local.get $p0
+    i32.store offset=24
+    local.get $l2
+    i32.const 1049532
+    i32.store offset=20
+    local.get $l2
+    i32.const 1
+    i32.store offset=16
+    local.get $l2
+    local.get $l2
+    i32.store offset=28
+    local.get $l2
+    i32.const 16
+    i32.add
+    call $f133
+    unreachable)
+  (func $f85 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i64)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4 (result i32)
+              i32.const 0
+              local.get $p0
+              i32.load
+              local.tee $l2
+              i32.eqz
+              br_if $B4
+              drop
+              local.get $l1
+              local.get $p0
+              i64.load offset=4 align=4
+              i64.store offset=36 align=4
+              local.get $l1
+              local.get $l2
+              i32.store offset=32
+              local.get $l1
+              i32.const 16
+              i32.add
+              local.get $l1
+              i32.const 32
+              i32.add
+              call $f170
+              local.get $l1
+              i32.const 8
+              i32.add
+              i32.const 0
+              local.get $l1
+              i32.load offset=16
+              local.tee $p0
+              local.get $l1
+              i32.load offset=24
+              call $f193
+              local.get $l1
+              i32.load offset=8
+              br_if $B3
+              local.get $l1
+              i32.const 40
+              i32.add
+              local.get $l1
+              i32.const 24
+              i32.add
+              i32.load
+              i32.store
+              local.get $l1
+              local.get $l1
+              i64.load offset=16
+              i64.store offset=32
+              local.get $l1
+              local.get $l1
+              i32.const 32
+              i32.add
+              call $f86
+              local.get $l1
+              i32.load offset=4
+              local.set $l4
+              local.get $l1
+              i32.load
+            end
+            local.set $l2
+            i32.const 1060576
+            i32.load8_u
+            br_if $B2
+            i32.const 1060576
+            i32.const 1
+            i32.store8
+            block $B5
+              i32.const 1060472
+              i64.load
+              local.tee $l5
+              i64.const -1
+              i64.ne
+              if $I6
+                i32.const 1060472
+                local.get $l5
+                i64.const 1
+                i64.add
+                i64.store
+                local.get $l5
+                i64.const 0
+                i64.ne
+                br_if $B5
+                i32.const 1049576
+                i32.const 43
+                i32.const 1049516
+                call $f172
+                unreachable
+              end
+              i32.const 1050012
+              i32.const 55
+              i32.const 1049996
+              call $f55
+              unreachable
+            end
+            i32.const 1060576
+            i32.const 0
+            i32.store8
+            i32.const 1
+            i32.const 1
+            call $f36
+            local.tee $l3
+            i32.eqz
+            br_if $B1
+            local.get $l3
+            i32.const 0
+            i32.store8
+            i32.const 48
+            i32.const 8
+            call $f36
+            local.tee $p0
+            i32.eqz
+            br_if $B0
+            local.get $p0
+            i64.const 1
+            i64.store offset=36 align=4
+            local.get $p0
+            i32.const 0
+            i32.store offset=24
+            local.get $p0
+            local.get $l4
+            i32.store offset=20
+            local.get $p0
+            local.get $l2
+            i32.store offset=16
+            local.get $p0
+            local.get $l5
+            i64.store offset=8
+            local.get $p0
+            i64.const 4294967297
+            i64.store
+            local.get $p0
+            local.get $l3
+            i64.extend_i32_u
+            i64.store offset=28 align=4
+            local.get $l1
+            i32.const 48
+            i32.add
+            global.set $g0
+            local.get $p0
+            return
+          end
+          local.get $l1
+          i32.load offset=12
+          local.set $l2
+          local.get $l1
+          i32.const 40
+          i32.add
+          local.get $l1
+          i64.load offset=20 align=4
+          i64.store
+          local.get $l1
+          local.get $p0
+          i32.store offset=36
+          local.get $l1
+          local.get $l2
+          i32.store offset=32
+          i32.const 1050067
+          i32.const 47
+          local.get $l1
+          i32.const 32
+          i32.add
+          i32.const 1049636
+          call $f192
+          unreachable
+        end
+        i32.const 1052440
+        i32.const 32
+        i32.const 1052424
+        call $f55
+        unreachable
+      end
+      i32.const 1
+      i32.const 1
+      call $f168
+      unreachable
+    end
+    i32.const 48
+    i32.const 8
+    call $f168
+    unreachable)
+  (func $f86 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p1
+            i32.load offset=4
+            local.tee $l2
+            local.get $p1
+            i32.load offset=8
+            local.tee $l3
+            i32.eq
+            if $I4
+              local.get $l3
+              i32.const 1
+              i32.add
+              local.tee $l2
+              local.get $l3
+              i32.lt_u
+              local.get $l2
+              i32.const 0
+              i32.lt_s
+              i32.or
+              br_if $B2
+              block $B5 (result i32)
+                local.get $l3
+                i32.eqz
+                if $I6
+                  local.get $l2
+                  i32.const 1
+                  call $f36
+                  br $B5
+                end
+                local.get $p1
+                i32.load
+                local.get $l3
+                i32.const 1
+                local.get $l2
+                call $f37
+              end
+              local.tee $l5
+              i32.eqz
+              br_if $B3
+              local.get $p1
+              local.get $l2
+              i32.store offset=4
+              local.get $p1
+              local.get $l5
+              i32.store
+            end
+            local.get $l2
+            local.get $l3
+            i32.eq
+            if $I7
+              local.get $p1
+              i32.const 1
+              call $f71
+              local.get $p1
+              i32.load offset=8
+              local.set $l3
+              local.get $p1
+              i32.load offset=4
+              local.set $l2
+            end
+            local.get $p1
+            local.get $l3
+            i32.const 1
+            i32.add
+            local.tee $l4
+            i32.store offset=8
+            local.get $l3
+            local.get $p1
+            i32.load
+            local.tee $l5
+            i32.add
+            i32.const 0
+            i32.store8
+            local.get $l2
+            local.get $l4
+            i32.eq
+            if $I8
+              local.get $l5
+              local.set $p1
+              local.get $l2
+              local.set $l4
+              br $B0
+            end
+            local.get $l2
+            local.get $l4
+            i32.lt_u
+            br_if $B1
+            local.get $l4
+            i32.eqz
+            if $I9
+              i32.const 0
+              local.set $l4
+              i32.const 1
+              local.set $p1
+              local.get $l2
+              i32.eqz
+              br_if $B0
+              local.get $l5
+              call $f145
+              br $B0
+            end
+            local.get $l5
+            local.get $l2
+            i32.const 1
+            local.get $l4
+            call $f37
+            local.tee $p1
+            br_if $B0
+            local.get $l4
+            i32.const 1
+            call $f168
+            unreachable
+          end
+          local.get $l2
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        call $f169
+        unreachable
+      end
+      i32.const 1049820
+      i32.const 36
+      i32.const 1049776
+      call $f172
+      unreachable
+    end
+    local.get $p0
+    local.get $l4
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f87 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.load
+    i32.const 24
+    i32.add
+    local.tee $l3
+    i32.load
+    local.set $l1
+    local.get $l3
+    i32.const 2
+    i32.store
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $l1
+            i32.const 2
+            i32.le_u
+            if $I4
+              local.get $l1
+              i32.const 1
+              i32.sub
+              br_if $B2
+              br $B3
+            end
+            i32.const 1050132
+            i32.const 28
+            i32.const 1050116
+            call $f55
+            unreachable
+          end
+          local.get $p0
+          i32.load
+          local.tee $l3
+          i32.const 28
+          i32.add
+          local.tee $l1
+          i32.load
+          local.tee $p0
+          i32.load8_u
+          br_if $B1
+          local.get $p0
+          i32.const 1
+          i32.store8
+          i32.const 0
+          local.set $p0
+          block $B5
+            i32.const 1060568
+            i32.load
+            i32.const 1
+            i32.eq
+            if $I6
+              i32.const 1060572
+              i32.load
+              local.set $p0
+              br $B5
+            end
+            i32.const 1060568
+            i64.const 1
+            i64.store
+          end
+          i32.const 1060572
+          local.get $p0
+          i32.store
+          local.get $l3
+          i32.const 32
+          i32.add
+          i32.load8_u
+          br_if $B0
+          local.get $l1
+          i32.load
+          i32.const 0
+          i32.store8
+        end
+        local.get $l2
+        i32.const 16
+        i32.add
+        global.set $g0
+        return
+      end
+      i32.const 1052440
+      i32.const 32
+      i32.const 1052424
+      call $f55
+      unreachable
+    end
+    local.get $l2
+    local.get $l1
+    i32.store offset=8
+    local.get $l2
+    local.get $p0
+    i32.const 0
+    i32.ne
+    i32.store8 offset=12
+    i32.const 1049668
+    i32.const 43
+    local.get $l2
+    i32.const 8
+    i32.add
+    i32.const 1049728
+    call $f192
+    unreachable)
+  (func $f88 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    local.get $p2
+    i32.store offset=28
+    local.get $l3
+    local.get $p1
+    i32.store offset=24
+    block $B0
+      block $B1
+        block $B2
+          local.get $p2
+          i32.const 1
+          i32.add
+          local.tee $l4
+          i32.const -1
+          i32.le_s
+          br_if $B2
+          block $B3
+            local.get $l4
+            if $I4
+              local.get $l4
+              i32.const 1
+              call $f36
+              local.tee $l6
+              br_if $B3
+              local.get $l4
+              i32.const 1
+              call $f168
+              unreachable
+            end
+            call $f169
+            unreachable
+          end
+          local.get $l3
+          i32.const 16
+          i32.add
+          i32.const 0
+          local.get $l6
+          local.get $p1
+          local.get $p2
+          call $f162
+          local.tee $p1
+          local.get $p2
+          call $f193
+          block $B5
+            block $B6
+              local.get $l3
+              i32.load offset=16
+              i32.eqz
+              if $I7
+                local.get $l3
+                local.get $p2
+                i32.store offset=48
+                local.get $l3
+                local.get $l4
+                i32.store offset=44
+                local.get $l3
+                local.get $p1
+                i32.store offset=40
+                local.get $l3
+                i32.const 8
+                i32.add
+                local.get $l3
+                i32.const 40
+                i32.add
+                call $f86
+                local.get $l3
+                i32.load offset=12
+                local.set $l7
+                local.get $l3
+                i32.load offset=8
+                local.tee $l6
+                call $f155
+                local.tee $l4
+                br_if $B6
+                br $B5
+              end
+              local.get $l3
+              i32.load offset=20
+              local.set $p0
+              local.get $l3
+              i32.const 52
+              i32.add
+              local.get $p2
+              i32.store
+              local.get $l3
+              i32.const 48
+              i32.add
+              local.get $l4
+              i32.store
+              local.get $l3
+              local.get $p1
+              i32.store offset=44
+              local.get $l3
+              local.get $p0
+              i32.store offset=40
+              local.get $l3
+              i32.const -64
+              i32.sub
+              local.get $l3
+              i32.const 40
+              i32.add
+              call $f91
+              local.get $l3
+              local.get $l3
+              i64.load offset=64
+              i64.store offset=32
+              local.get $l3
+              i32.const 60
+              i32.add
+              i32.const 2
+              i32.store
+              local.get $l3
+              i32.const 76
+              i32.add
+              i32.const 15
+              i32.store
+              local.get $l3
+              i64.const 2
+              i64.store offset=44 align=4
+              local.get $l3
+              i32.const 1050212
+              i32.store offset=40
+              local.get $l3
+              i32.const 16
+              i32.store offset=68
+              local.get $l3
+              local.get $l3
+              i32.const -64
+              i32.sub
+              i32.store offset=56
+              local.get $l3
+              local.get $l3
+              i32.const 32
+              i32.add
+              i32.store offset=72
+              local.get $l3
+              local.get $l3
+              i32.const 24
+              i32.add
+              i32.store offset=64
+              local.get $l3
+              i32.const 40
+              i32.add
+              i32.const 1050248
+              call $f84
+              unreachable
+            end
+            block $B8
+              block $B9
+                local.get $l4
+                i32.load8_u
+                if $I10
+                  local.get $l4
+                  i32.const 1
+                  i32.add
+                  local.set $l5
+                  i32.const 0
+                  local.set $p2
+                  loop $L11
+                    local.get $p2
+                    local.get $l5
+                    i32.add
+                    local.get $p2
+                    i32.const 1
+                    i32.add
+                    local.tee $p1
+                    local.set $p2
+                    i32.load8_u
+                    br_if $L11
+                  end
+                  local.get $p1
+                  i32.const -1
+                  i32.eq
+                  br_if $B1
+                  local.get $p1
+                  i32.const -1
+                  i32.le_s
+                  br_if $B2
+                  local.get $p1
+                  br_if $B9
+                end
+                i32.const 1
+                local.set $l5
+                i32.const 0
+                local.set $p1
+                br $B8
+              end
+              local.get $p1
+              i32.const 1
+              call $f36
+              local.tee $l5
+              i32.eqz
+              br_if $B0
+            end
+            local.get $l5
+            local.get $l4
+            local.get $p1
+            call $f162
+            drop
+            local.get $p1
+            i64.extend_i32_u
+            local.tee $l9
+            i64.const 32
+            i64.shl
+            local.get $l9
+            i64.or
+            local.set $l9
+          end
+          local.get $l6
+          i32.const 0
+          i32.store8
+          local.get $l7
+          if $I12
+            local.get $l6
+            call $f145
+          end
+          local.get $p0
+          local.get $l9
+          i64.store32 offset=4
+          local.get $p0
+          local.get $l5
+          i32.store
+          local.get $p0
+          i32.const 8
+          i32.add
+          local.get $l9
+          i64.const 32
+          i64.shr_u
+          i64.store32
+          local.get $l3
+          i32.const 80
+          i32.add
+          global.set $g0
+          return
+        end
+        call $f12
+        unreachable
+      end
+      local.get $p1
+      i32.const 0
+      call $f173
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    call $f168
+    unreachable)
+  (func $f89 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0
+      block $B1
+        i32.const 35
+        i32.const 1
+        call $f36
+        local.tee $l1
+        if $I2
+          local.get $l1
+          i32.const 31
+          i32.add
+          i32.const 1052599
+          i32.load align=1
+          i32.store align=1
+          local.get $l1
+          i32.const 24
+          i32.add
+          i32.const 1052592
+          i64.load align=1
+          i64.store align=1
+          local.get $l1
+          i32.const 16
+          i32.add
+          i32.const 1052584
+          i64.load align=1
+          i64.store align=1
+          local.get $l1
+          i32.const 8
+          i32.add
+          i32.const 1052576
+          i64.load align=1
+          i64.store align=1
+          local.get $l1
+          i32.const 1052568
+          i64.load align=1
+          i64.store align=1
+          i32.const 12
+          i32.const 4
+          call $f36
+          local.tee $l3
+          i32.eqz
+          br_if $B1
+          local.get $l3
+          i64.const 150323855395
+          i64.store offset=4 align=4
+          local.get $l3
+          local.get $l1
+          i32.store
+          i32.const 12
+          i32.const 4
+          call $f36
+          local.tee $l1
+          i32.eqz
+          br_if $B0
+          local.get $l1
+          i32.const 16
+          i32.store8 offset=8
+          local.get $l1
+          i32.const 1050348
+          i32.store offset=4
+          local.get $l1
+          local.get $l3
+          i32.store
+          local.get $l1
+          local.get $l2
+          i32.load16_u offset=13 align=1
+          i32.store16 offset=9 align=1
+          local.get $l1
+          i32.const 11
+          i32.add
+          local.get $l2
+          i32.const 15
+          i32.add
+          i32.load8_u
+          i32.store8
+          local.get $p0
+          i32.const 8
+          i32.add
+          local.get $l1
+          i32.store
+          local.get $p0
+          i64.const 8589934593
+          i64.store align=4
+          local.get $l2
+          i32.const 16
+          i32.add
+          global.set $g0
+          return
+        end
+        i32.const 35
+        i32.const 1
+        call $f168
+        unreachable
+      end
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    i32.const 12
+    i32.const 4
+    call $f168
+    unreachable)
+  (func $f90 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    i32.const 8
+    i32.add
+    i32.const 1048812
+    i32.const 16
+    call $f88
+    block $B0
+      local.get $l1
+      i32.load offset=8
+      local.tee $l2
+      if $I1
+        local.get $l1
+        i32.load offset=12
+        local.set $l3
+        local.get $l1
+        i32.const 40
+        i32.add
+        local.get $l2
+        local.get $l1
+        i32.const 16
+        i32.add
+        i32.load
+        local.tee $l4
+        call $f201
+        i32.const 1
+        local.set $l5
+        block $B2
+          local.get $l1
+          i32.load offset=40
+          i32.const 1
+          i32.ne
+          if $I3
+            i32.const 0
+            local.set $l5
+            br $B2
+          end
+          local.get $l1
+          local.get $l1
+          i64.load offset=44 align=4
+          i64.store offset=52 align=4
+          local.get $l1
+          local.get $l4
+          i32.store offset=48
+          local.get $l1
+          local.get $l3
+          i32.store offset=44
+          local.get $l1
+          local.get $l2
+          i32.store offset=40
+          local.get $l1
+          i32.const 24
+          i32.add
+          local.get $l1
+          i32.const 40
+          i32.add
+          call $f170
+          local.get $l1
+          i32.load offset=32
+          local.set $l4
+          local.get $l1
+          i32.load offset=28
+          local.set $l3
+          local.get $l1
+          i32.load offset=24
+          local.set $l2
+        end
+        local.get $p0
+        i32.const 12
+        i32.add
+        local.get $l4
+        i32.store
+        local.get $p0
+        i32.const 8
+        i32.add
+        local.get $l3
+        i32.store
+        local.get $p0
+        local.get $l2
+        i32.store offset=4
+        br $B0
+      end
+      local.get $p0
+      i32.const 0
+      i32.store offset=4
+      i32.const 1
+      local.set $l5
+    end
+    local.get $p0
+    local.get $l5
+    i32.store
+    local.get $l1
+    i32.const -64
+    i32.sub
+    global.set $g0)
+  (func $f91 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0
+      block $B1
+        i32.const 33
+        i32.const 1
+        call $f36
+        local.tee $l2
+        if $I2
+          local.get $l2
+          i32.const 32
+          i32.add
+          i32.const 1050421
+          i32.load8_u
+          i32.store8
+          local.get $l2
+          i32.const 24
+          i32.add
+          i32.const 1050413
+          i64.load align=1
+          i64.store align=1
+          local.get $l2
+          i32.const 16
+          i32.add
+          i32.const 1050405
+          i64.load align=1
+          i64.store align=1
+          local.get $l2
+          i32.const 8
+          i32.add
+          i32.const 1050397
+          i64.load align=1
+          i64.store align=1
+          local.get $l2
+          i32.const 1050389
+          i64.load align=1
+          i64.store align=1
+          i32.const 12
+          i32.const 4
+          call $f36
+          local.tee $l4
+          i32.eqz
+          br_if $B1
+          local.get $l4
+          i64.const 141733920801
+          i64.store offset=4 align=4
+          local.get $l4
+          local.get $l2
+          i32.store
+          i32.const 12
+          i32.const 4
+          call $f36
+          local.tee $l2
+          i32.eqz
+          br_if $B0
+          local.get $l2
+          i32.const 11
+          i32.store8 offset=8
+          local.get $l2
+          i32.const 1050348
+          i32.store offset=4
+          local.get $l2
+          local.get $l4
+          i32.store
+          local.get $l2
+          local.get $l3
+          i32.load16_u offset=13 align=1
+          i32.store16 offset=9 align=1
+          local.get $l2
+          i32.const 11
+          i32.add
+          local.get $l3
+          i32.const 15
+          i32.add
+          i32.load8_u
+          i32.store8
+          local.get $p0
+          i32.const 2
+          i32.store8
+          local.get $p0
+          local.get $l3
+          i32.load16_u offset=10 align=1
+          i32.store16 offset=1 align=1
+          local.get $p0
+          i32.const 3
+          i32.add
+          local.get $l3
+          i32.const 12
+          i32.add
+          i32.load8_u
+          i32.store8
+          local.get $p0
+          i32.const 4
+          i32.add
+          local.get $l2
+          i32.store
+          local.get $p1
+          i32.const 8
+          i32.add
+          i32.load
+          if $I3
+            local.get $p1
+            i32.load offset=4
+            call $f145
+          end
+          local.get $l3
+          i32.const 16
+          i32.add
+          global.set $g0
+          return
+        end
+        i32.const 33
+        i32.const 1
+        call $f168
+        unreachable
+      end
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    i32.const 12
+    i32.const 4
+    call $f168
+    unreachable)
+  (func $f92 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l2
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p0
+            i32.load8_u
+            i32.const 1
+            i32.sub
+            br_table $B1 $B2 $B3
+          end
+          local.get $l2
+          local.get $p0
+          i32.const 4
+          i32.add
+          i32.load
+          local.tee $p0
+          i32.store offset=4
+          local.get $l2
+          i32.const 8
+          i32.add
+          local.get $p0
+          call $f104
+          local.get $l2
+          i32.const 60
+          i32.add
+          i32.const 2
+          i32.store
+          local.get $l2
+          i32.const 36
+          i32.add
+          i32.const 17
+          i32.store
+          local.get $l2
+          i64.const 3
+          i64.store offset=44 align=4
+          local.get $l2
+          i32.const 1050772
+          i32.store offset=40
+          local.get $l2
+          i32.const 18
+          i32.store offset=28
+          local.get $l2
+          local.get $l2
+          i32.const 24
+          i32.add
+          i32.store offset=56
+          local.get $l2
+          local.get $l2
+          i32.const 4
+          i32.add
+          i32.store offset=32
+          local.get $l2
+          local.get $l2
+          i32.const 8
+          i32.add
+          i32.store offset=24
+          local.get $p1
+          local.get $l2
+          i32.const 40
+          i32.add
+          call $f219
+          local.set $p0
+          local.get $l2
+          i32.load offset=12
+          i32.eqz
+          br_if $B0
+          local.get $l2
+          i32.load offset=8
+          call $f145
+          br $B0
+        end
+        local.get $p0
+        i32.const 4
+        i32.add
+        i32.load
+        local.tee $p0
+        i32.load
+        local.get $p1
+        local.get $p0
+        i32.load offset=4
+        i32.load offset=32
+        call_indirect (type $t0) $T0
+        local.set $p0
+        br $B0
+      end
+      i32.const 1050455
+      local.set $l3
+      i32.const 22
+      local.set $l4
+      block $B4
+        block $B5 (result i32)
+          block $B6
+            block $B7
+              block $B8
+                block $B9
+                  block $B10
+                    block $B11
+                      block $B12
+                        block $B13
+                          block $B14
+                            block $B15
+                              block $B16
+                                block $B17
+                                  block $B18
+                                    block $B19
+                                      block $B20
+                                        block $B21
+                                          block $B22
+                                            local.get $p0
+                                            i32.load8_u offset=1
+                                            i32.const 1
+                                            i32.sub
+                                            br_table $B21 $B20 $B19 $B18 $B17 $B16 $B15 $B14 $B13 $B12 $B11 $B10 $B9 $B8 $B7 $B6 $B4 $B22
+                                          end
+                                          i32.const 1050736
+                                          local.set $l3
+                                          i32.const 16
+                                          local.set $l4
+                                          br $B4
+                                        end
+                                        i32.const 1050719
+                                        local.set $l3
+                                        i32.const 17
+                                        local.set $l4
+                                        br $B4
+                                      end
+                                      i32.const 1050701
+                                      local.set $l3
+                                      i32.const 18
+                                      local.set $l4
+                                      br $B4
+                                    end
+                                    i32.const 1050685
+                                    local.set $l3
+                                    i32.const 16
+                                    local.set $l4
+                                    br $B4
+                                  end
+                                  i32.const 1050667
+                                  local.set $l3
+                                  i32.const 18
+                                  local.set $l4
+                                  br $B4
+                                end
+                                i32.const 1050654
+                                local.set $l3
+                                i32.const 13
+                                local.set $l4
+                                br $B4
+                              end
+                              i32.const 1050640
+                              br $B5
+                            end
+                            i32.const 1050619
+                            local.set $l3
+                            i32.const 21
+                            local.set $l4
+                            br $B4
+                          end
+                          i32.const 1050608
+                          local.set $l3
+                          i32.const 11
+                          local.set $l4
+                          br $B4
+                        end
+                        i32.const 1050587
+                        local.set $l3
+                        i32.const 21
+                        local.set $l4
+                        br $B4
+                      end
+                      i32.const 1050566
+                      local.set $l3
+                      i32.const 21
+                      local.set $l4
+                      br $B4
+                    end
+                    i32.const 1050543
+                    local.set $l3
+                    i32.const 23
+                    local.set $l4
+                    br $B4
+                  end
+                  i32.const 1050531
+                  local.set $l3
+                  i32.const 12
+                  local.set $l4
+                  br $B4
+                end
+                i32.const 1050522
+                local.set $l3
+                i32.const 9
+                local.set $l4
+                br $B4
+              end
+              i32.const 1050512
+              local.set $l3
+              i32.const 10
+              local.set $l4
+              br $B4
+            end
+            i32.const 1050491
+            local.set $l3
+            i32.const 21
+            local.set $l4
+            br $B4
+          end
+          i32.const 1050477
+        end
+        local.set $l3
+        i32.const 14
+        local.set $l4
+      end
+      local.get $l2
+      i32.const 60
+      i32.add
+      i32.const 1
+      i32.store
+      local.get $l2
+      local.get $l4
+      i32.store offset=28
+      local.get $l2
+      local.get $l3
+      i32.store offset=24
+      local.get $l2
+      i32.const 19
+      i32.store offset=12
+      local.get $l2
+      i64.const 1
+      i64.store offset=44 align=4
+      local.get $l2
+      i32.const 1050752
+      i32.store offset=40
+      local.get $l2
+      local.get $l2
+      i32.const 24
+      i32.add
+      i32.store offset=8
+      local.get $l2
+      local.get $l2
+      i32.const 8
+      i32.add
+      i32.store offset=56
+      local.get $p1
+      local.get $l2
+      i32.const 40
+      i32.add
+      call $f219
+      local.set $p0
+    end
+    local.get $l2
+    i32.const -64
+    i32.sub
+    global.set $g0
+    local.get $p0)
+  (func $f93 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=4
+    local.get $p1
+    call $f42)
+  (func $f94 (type $t7)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i64) (local $l7 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    local.get $l0
+    i32.const 16
+    i32.store offset=44
+    local.get $l0
+    i32.const 1048812
+    i32.store offset=40
+    local.get $l0
+    i32.const 5
+    i32.store offset=52
+    local.get $l0
+    i32.const 1048828
+    i32.store offset=48
+    i32.const 17
+    i32.const 1
+    call $f36
+    local.tee $l2
+    if $I0
+      local.get $l0
+      i32.const 32
+      i32.add
+      i32.const 0
+      local.get $l2
+      i32.const 1048812
+      i32.const 16
+      call $f162
+      local.tee $l2
+      i32.const 16
+      call $f193
+      block $B1
+        local.get $l0
+        i32.load offset=32
+        if $I2
+          local.get $l0
+          i32.load offset=36
+          local.set $l1
+          local.get $l0
+          i32.const 76
+          i32.add
+          i32.const 16
+          i32.store
+          local.get $l0
+          i32.const 72
+          i32.add
+          i32.const 17
+          i32.store
+          local.get $l0
+          local.get $l2
+          i32.store offset=68
+          local.get $l0
+          local.get $l1
+          i32.store offset=64
+          local.get $l0
+          i32.const 56
+          i32.add
+          local.get $l0
+          i32.const -64
+          i32.sub
+          call $f91
+          local.get $l0
+          i64.load offset=56
+          local.tee $l6
+          i64.const 8
+          i64.shr_u
+          local.set $l7
+          local.get $l6
+          i32.wrap_i64
+          local.set $l1
+          br $B1
+        end
+        local.get $l0
+        i32.const 16
+        i32.store offset=72
+        local.get $l0
+        i32.const 17
+        i32.store offset=68
+        local.get $l0
+        local.get $l2
+        i32.store offset=64
+        local.get $l0
+        i32.const 24
+        i32.add
+        local.get $l0
+        i32.const -64
+        i32.sub
+        call $f86
+        local.get $l0
+        i32.load offset=28
+        local.set $l4
+        local.get $l0
+        i32.load offset=24
+        local.set $l2
+        i32.const 6
+        i32.const 1
+        call $f36
+        local.tee $l1
+        i32.eqz
+        if $I3
+          i32.const 6
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        local.get $l0
+        i32.const 16
+        i32.add
+        i32.const 0
+        local.get $l1
+        i32.const 1048828
+        i32.const 5
+        call $f162
+        local.tee $l1
+        i32.const 5
+        call $f193
+        local.get $l0
+        i32.load offset=16
+        if $I4
+          local.get $l0
+          i32.load offset=20
+          local.set $l3
+          local.get $l0
+          i32.const 76
+          i32.add
+          i32.const 5
+          i32.store
+          local.get $l0
+          i32.const 72
+          i32.add
+          i32.const 6
+          i32.store
+          local.get $l0
+          local.get $l1
+          i32.store offset=68
+          local.get $l0
+          local.get $l3
+          i32.store offset=64
+          local.get $l0
+          i32.const 56
+          i32.add
+          local.get $l0
+          i32.const -64
+          i32.sub
+          call $f91
+          local.get $l0
+          i64.load offset=56
+          local.set $l6
+          local.get $l2
+          i32.const 0
+          i32.store8
+          local.get $l6
+          i64.const 8
+          i64.shr_u
+          local.set $l7
+          local.get $l6
+          i32.wrap_i64
+          local.set $l1
+          local.get $l4
+          i32.eqz
+          br_if $B1
+          local.get $l2
+          call $f145
+          br $B1
+        end
+        local.get $l0
+        i32.const 5
+        i32.store offset=72
+        local.get $l0
+        i32.const 6
+        i32.store offset=68
+        local.get $l0
+        local.get $l1
+        i32.store offset=64
+        local.get $l0
+        i32.const 8
+        i32.add
+        local.get $l0
+        i32.const -64
+        i32.sub
+        call $f86
+        local.get $l0
+        i32.load offset=12
+        block $B5 (result i32)
+          i32.const 3
+          local.get $l2
+          local.get $l0
+          i32.load offset=8
+          local.tee $l3
+          call $f158
+          i32.const -1
+          i32.ne
+          br_if $B5
+          drop
+          i32.const 1061076
+          i64.load32_u
+          i64.const 24
+          i64.shl
+          local.set $l7
+          i32.const 0
+        end
+        local.set $l1
+        local.get $l3
+        i32.const 0
+        i32.store8
+        if $I6
+          local.get $l3
+          call $f145
+        end
+        local.get $l2
+        i32.const 0
+        i32.store8
+        local.get $l4
+        i32.eqz
+        br_if $B1
+        local.get $l2
+        call $f145
+      end
+      local.get $l1
+      i32.const 255
+      i32.and
+      i32.const 3
+      i32.eq
+      if $I7
+        local.get $l0
+        i32.const 80
+        i32.add
+        global.set $g0
+        return
+      end
+      local.get $l0
+      local.get $l1
+      i64.extend_i32_u
+      i64.const 255
+      i64.and
+      local.get $l7
+      i64.const 8
+      i64.shl
+      i64.or
+      i64.store offset=64
+      local.get $l0
+      i32.const 40
+      i32.add
+      local.get $l0
+      i32.const 48
+      i32.add
+      local.get $l0
+      i32.const -64
+      i32.sub
+      call $f95
+      unreachable
+    end
+    i32.const 17
+    i32.const 1
+    call $f168
+    unreachable)
+  (func $f95 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 44
+    i32.add
+    i32.const 15
+    i32.store
+    local.get $l3
+    i32.const 36
+    i32.add
+    i32.const 16
+    i32.store
+    local.get $l3
+    i32.const 20
+    i32.add
+    i32.const 3
+    i32.store
+    local.get $l3
+    i64.const 3
+    i64.store offset=4 align=4
+    local.get $l3
+    i32.const 1050308
+    i32.store
+    local.get $l3
+    local.get $p2
+    i32.store offset=40
+    local.get $l3
+    local.get $p1
+    i32.store offset=32
+    local.get $l3
+    i32.const 16
+    i32.store offset=28
+    local.get $l3
+    local.get $p0
+    i32.store offset=24
+    local.get $l3
+    local.get $l3
+    i32.const 24
+    i32.add
+    i32.store offset=16
+    local.get $l3
+    i32.const 1050332
+    call $f84
+    unreachable)
+  (func $f96 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    i32.const 0
+    i32.store)
+  (func $f97 (type $t8) (param $p0 i32) (result i64)
+    i64.const 6492544822980680759)
+  (func $f98 (type $t5) (param $p0 i32) (result i32)
+    i32.const 0)
+  (func $f99 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p1
+    i32.load offset=8
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.load
+    i32.store)
+  (func $f100 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=8
+    local.get $p1
+    call $f224)
+  (func $f101 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    i32.const 16
+    local.set $l1
+    block $B0
+      local.get $p0
+      i32.const 65535
+      i32.gt_u
+      br_if $B0
+      local.get $p0
+      i32.const 65535
+      i32.and
+      i32.const -2
+      i32.add
+      local.tee $p0
+      i32.const 71
+      i32.gt_u
+      br_if $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                block $B6
+                  block $B7
+                    block $B8
+                      block $B9
+                        block $B10
+                          block $B11
+                            block $B12
+                              block $B13
+                                block $B14
+                                  local.get $p0
+                                  i32.const 1
+                                  i32.sub
+                                  br_table $B7 $B8 $B0 $B1 $B0 $B0 $B0 $B0 $B0 $B0 $B9 $B14 $B13 $B0 $B0 $B0 $B0 $B2 $B0 $B0 $B0 $B0 $B0 $B0 $B5 $B4 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B6 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B10 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B12 $B11 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B0 $B3 $B12
+                                end
+                                i32.const 2
+                                return
+                              end
+                              i32.const 3
+                              return
+                            end
+                            i32.const 1
+                            return
+                          end
+                          i32.const 8
+                          return
+                        end
+                        i32.const 5
+                        return
+                      end
+                      i32.const 4
+                      return
+                    end
+                    i32.const 7
+                    return
+                  end
+                  i32.const 6
+                  return
+                end
+                i32.const 0
+                return
+              end
+              i32.const 15
+              return
+            end
+            i32.const 11
+            return
+          end
+          i32.const 13
+          return
+        end
+        i32.const 9
+        return
+      end
+      i32.const 10
+      local.set $l1
+    end
+    local.get $l1)
+  (func $f102 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i64)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    block $B0
+      block $B1
+        local.get $p1
+        i32.load offset=8
+        local.get $p3
+        i32.add
+        local.get $p1
+        i32.load offset=4
+        i32.le_u
+        br_if $B1
+        local.get $l4
+        i32.const 16
+        i32.add
+        local.get $p1
+        call $f79
+        local.get $l4
+        i32.load offset=20
+        local.set $l5
+        local.get $l4
+        i32.load offset=16
+        local.tee $l6
+        i32.const 255
+        i32.and
+        i32.const 3
+        i32.ne
+        if $I2
+          local.get $p0
+          i32.const 1
+          i32.store
+          local.get $p0
+          local.get $l6
+          i64.extend_i32_u
+          local.get $l5
+          i64.extend_i32_u
+          i64.const 32
+          i64.shl
+          i64.or
+          i64.store offset=4 align=4
+          br $B0
+        end
+        local.get $l6
+        i32.const 3
+        i32.and
+        i32.const 2
+        i32.ne
+        br_if $B1
+        local.get $l5
+        i32.load
+        local.get $l5
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $l5
+        i32.load offset=4
+        local.tee $l6
+        i32.load offset=4
+        if $I3
+          local.get $l6
+          i32.load offset=8
+          drop
+          local.get $l5
+          i32.load
+          call $f145
+        end
+        local.get $l5
+        call $f145
+      end
+      local.get $p1
+      i32.load offset=4
+      local.get $p3
+      i32.gt_u
+      if $I4
+        local.get $p1
+        local.get $p3
+        call $f71
+        local.get $p1
+        local.get $p1
+        i32.load offset=8
+        local.tee $l5
+        local.get $p3
+        i32.add
+        i32.store offset=8
+        local.get $l5
+        local.get $p1
+        i32.load
+        i32.add
+        local.get $p2
+        local.get $p3
+        call $f162
+        drop
+        local.get $p0
+        i32.const 0
+        i32.store
+        local.get $p0
+        local.get $p3
+        i32.store offset=4
+        br $B0
+      end
+      local.get $p1
+      i32.const 1
+      i32.store8 offset=13
+      block $B5 (result i32)
+        local.get $p1
+        i32.load8_u offset=12
+        i32.const -1
+        i32.add
+        local.tee $l5
+        i32.const 1
+        i32.le_u
+        if $I6
+          local.get $l5
+          i32.const 1
+          i32.sub
+          i32.eqz
+          if $I7
+            i32.const 1049576
+            i32.const 43
+            i32.const 1049516
+            call $f172
+            unreachable
+          end
+          local.get $p3
+          i64.extend_i32_u
+          local.set $l7
+          i32.const 0
+          br $B5
+        end
+        local.get $l4
+        local.get $p3
+        i32.store offset=12
+        local.get $l4
+        local.get $p2
+        i32.store offset=8
+        local.get $l4
+        i32.const 16
+        i32.add
+        i32.const 1
+        local.get $l4
+        i32.const 8
+        i32.add
+        call $f142
+        local.get $l4
+        i32.load16_u offset=16
+        i32.const 1
+        i32.ne
+        if $I8
+          local.get $l4
+          i64.load32_u offset=20
+          local.set $l7
+          i32.const 0
+          br $B5
+        end
+        local.get $l4
+        local.get $l4
+        i32.load16_u offset=18
+        i32.store16 offset=30
+        local.get $p3
+        i64.extend_i32_u
+        local.get $l4
+        i32.const 30
+        i32.add
+        i32.load16_u
+        local.tee $p2
+        i64.extend_i32_u
+        i64.const 65535
+        i64.and
+        i64.const 32
+        i64.shl
+        local.get $p2
+        i32.const 8
+        i32.eq
+        select
+        local.set $l7
+        local.get $p2
+        i32.const 8
+        i32.ne
+      end
+      local.set $p2
+      local.get $p0
+      local.get $l7
+      i64.store offset=4 align=4
+      local.get $p0
+      local.get $p2
+      i32.store
+      local.get $p1
+      i32.const 0
+      i32.store8 offset=13
+    end
+    local.get $l4
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f103 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i64)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    block $B0
+      block $B1
+        local.get $p1
+        i32.load8_u offset=16
+        i32.eqz
+        br_if $B1
+        local.get $l4
+        i32.const 16
+        i32.add
+        local.get $p1
+        call $f79
+        block $B2
+          block $B3
+            local.get $l4
+            i32.load8_u offset=16
+            i32.const 3
+            i32.eq
+            if $I4
+              local.get $p1
+              i32.load8_u offset=12
+              i32.const 2
+              i32.ne
+              br_if $B3
+              i32.const 1049576
+              i32.const 43
+              i32.const 1049516
+              call $f172
+              unreachable
+            end
+            local.get $l4
+            i64.load offset=16
+            local.tee $l10
+            i64.const 255
+            i64.and
+            i64.const 3
+            i64.ne
+            br_if $B2
+          end
+          local.get $p1
+          i32.const 0
+          i32.store8 offset=16
+          br $B1
+        end
+        local.get $l10
+        i32.wrap_i64
+        local.tee $l5
+        i32.const 255
+        i32.and
+        i32.const 3
+        i32.ne
+        if $I5
+          local.get $p0
+          i32.const 1
+          i32.store
+          local.get $p0
+          local.get $l10
+          i64.store offset=4 align=4
+          br $B0
+        end
+        local.get $l5
+        i32.const 3
+        i32.and
+        i32.const 2
+        i32.ne
+        br_if $B1
+        local.get $l10
+        i64.const 32
+        i64.shr_u
+        i32.wrap_i64
+        local.tee $l5
+        i32.load
+        local.get $l5
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $l5
+        i32.load offset=4
+        local.tee $l7
+        i32.load offset=4
+        if $I6
+          local.get $l7
+          i32.load offset=8
+          drop
+          local.get $l5
+          i32.load
+          call $f145
+        end
+        local.get $l5
+        call $f145
+      end
+      local.get $l4
+      i32.const 8
+      i32.add
+      local.get $p2
+      local.get $p3
+      call $f194
+      local.get $l4
+      i32.load offset=8
+      i32.eqz
+      if $I7
+        local.get $p0
+        local.get $p1
+        local.get $p2
+        local.get $p3
+        call $f102
+        br $B0
+      end
+      block $B8
+        local.get $l4
+        i32.load offset=12
+        local.tee $l5
+        i32.const -1
+        i32.ne
+        if $I9
+          local.get $l5
+          i32.const 1
+          i32.add
+          local.set $l7
+          local.get $l5
+          local.get $p3
+          i32.lt_u
+          br_if $B8
+          local.get $l7
+          local.get $p3
+          call $f173
+          unreachable
+        end
+        i32.const 1054816
+        i32.const 44
+        i32.const 1054860
+        call $f172
+        unreachable
+      end
+      local.get $l4
+      i32.const 16
+      i32.add
+      local.get $p1
+      local.get $p2
+      local.get $l7
+      call $f102
+      local.get $l4
+      i32.const 24
+      i32.add
+      i32.load
+      local.set $l6
+      local.get $l4
+      i32.load offset=20
+      local.set $l5
+      block $B10
+        local.get $l4
+        i32.load offset=16
+        local.tee $l8
+        i32.const 1
+        i32.le_u
+        if $I11
+          local.get $l8
+          i32.const 1
+          i32.sub
+          br_if $B10
+          local.get $p0
+          i32.const 1
+          i32.store
+          local.get $p0
+          local.get $l5
+          i64.extend_i32_u
+          local.get $l6
+          i64.extend_i32_u
+          i64.const 32
+          i64.shl
+          i64.or
+          i64.store offset=4 align=4
+          br $B0
+        end
+        local.get $l5
+        i32.const 255
+        i32.and
+        i32.const 2
+        i32.lt_u
+        br_if $B10
+        local.get $l6
+        i32.load
+        local.get $l6
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $l6
+        i32.load offset=4
+        local.tee $l8
+        i32.load offset=4
+        if $I12
+          local.get $l8
+          i32.load offset=8
+          drop
+          local.get $l6
+          i32.load
+          call $f145
+        end
+        local.get $l6
+        call $f145
+      end
+      local.get $p1
+      i32.const 1
+      i32.store8 offset=16
+      local.get $l4
+      i32.const 16
+      i32.add
+      local.get $p1
+      call $f79
+      block $B13
+        block $B14
+          block $B15
+            block $B16
+              local.get $l4
+              i32.load8_u offset=16
+              i32.const 3
+              i32.eq
+              if $I17
+                local.get $p1
+                i32.load8_u offset=12
+                i32.const 2
+                i32.ne
+                br_if $B16
+                i32.const 1049576
+                i32.const 43
+                i32.const 1049516
+                call $f172
+                unreachable
+              end
+              local.get $l4
+              i64.load8_u offset=16
+              i64.const 3
+              i64.ne
+              br_if $B15
+            end
+            local.get $p1
+            i32.const 0
+            i32.store8 offset=16
+            local.get $l5
+            local.get $l7
+            i32.eq
+            br_if $B14
+            br $B13
+          end
+          local.get $l4
+          i32.load offset=20
+          local.set $l6
+          local.get $l5
+          local.get $l7
+          i32.ne
+          local.get $l4
+          i32.load offset=16
+          local.tee $l8
+          i32.const 255
+          i32.and
+          i32.const 3
+          i32.ne
+          i32.or
+          local.get $l8
+          i32.const 3
+          i32.and
+          i32.const 2
+          i32.eq
+          if $I18
+            local.get $l6
+            i32.load
+            local.get $l6
+            i32.load offset=4
+            i32.load
+            call_indirect (type $t2) $T0
+            local.get $l6
+            i32.load offset=4
+            local.tee $l8
+            i32.load offset=4
+            if $I19
+              local.get $l8
+              i32.load offset=8
+              drop
+              local.get $l6
+              i32.load
+              call $f145
+            end
+            local.get $l6
+            call $f145
+          end
+          br_if $B13
+        end
+        local.get $l4
+        i32.const 16
+        i32.add
+        local.get $p1
+        local.get $p2
+        local.get $l7
+        i32.add
+        local.get $p3
+        local.get $l7
+        i32.sub
+        call $f102
+        local.get $l4
+        i32.load offset=16
+        i32.const 1
+        i32.ne
+        if $I20
+          local.get $p0
+          i32.const 0
+          i32.store
+          local.get $p0
+          local.get $l4
+          i32.load offset=20
+          local.get $l5
+          i32.add
+          i32.store offset=4
+          br $B0
+        end
+        local.get $p0
+        i32.const 0
+        i32.store
+        local.get $p0
+        local.get $l5
+        i32.store offset=4
+        local.get $l4
+        i32.load8_u offset=20
+        i32.const 2
+        i32.lt_u
+        br_if $B0
+        local.get $l4
+        i32.const 24
+        i32.add
+        i32.load
+        local.tee $p0
+        i32.load
+        local.get $p0
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p0
+        i32.load offset=4
+        local.tee $p1
+        i32.load offset=4
+        if $I21
+          local.get $p1
+          i32.load offset=8
+          drop
+          local.get $p0
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        call $f145
+        br $B0
+      end
+      local.get $p0
+      i32.const 0
+      i32.store
+      local.get $p0
+      local.get $l5
+      i32.store offset=4
+    end
+    local.get $l4
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f104 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 1056
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    i32.const 8
+    i32.add
+    i32.const 1024
+    call $f166
+    drop
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p1
+            local.get $l2
+            i32.const 8
+            i32.add
+            call $f165
+            i32.const 0
+            i32.ge_s
+            if $I4
+              local.get $l2
+              i32.load8_u offset=8
+              if $I5
+                local.get $l2
+                i32.const 9
+                i32.add
+                local.set $l4
+                i32.const 0
+                local.set $p1
+                loop $L6
+                  local.get $p1
+                  local.get $l4
+                  i32.add
+                  local.get $p1
+                  i32.const 1
+                  i32.add
+                  local.tee $l3
+                  local.set $p1
+                  i32.load8_u
+                  br_if $L6
+                end
+                local.get $l3
+                i32.const -1
+                i32.eq
+                br_if $B3
+              end
+              local.get $l2
+              i32.const 1032
+              i32.add
+              local.get $l2
+              i32.const 8
+              i32.add
+              local.get $l3
+              call $f201
+              local.get $l2
+              i32.load offset=1032
+              i32.const 1
+              i32.eq
+              br_if $B2
+              local.get $l2
+              i32.const 1040
+              i32.add
+              i32.load
+              local.tee $p1
+              i32.const -1
+              i32.le_s
+              br_if $B1
+              local.get $l2
+              i32.load offset=1036
+              local.set $l4
+              block $B7
+                local.get $p1
+                i32.eqz
+                if $I8
+                  i32.const 1
+                  local.set $l3
+                  br $B7
+                end
+                local.get $p1
+                i32.const 1
+                call $f36
+                local.tee $l3
+                i32.eqz
+                br_if $B0
+              end
+              local.get $l3
+              local.get $l4
+              local.get $p1
+              call $f162
+              local.set $l3
+              local.get $p0
+              local.get $p1
+              i32.store offset=8
+              local.get $p0
+              local.get $p1
+              i32.store offset=4
+              local.get $p0
+              local.get $l3
+              i32.store
+              local.get $l2
+              i32.const 1056
+              i32.add
+              global.set $g0
+              return
+            end
+            i32.const 1052516
+            i32.const 18
+            i32.const 1052500
+            call $f55
+            unreachable
+          end
+          local.get $l3
+          i32.const 0
+          call $f173
+          unreachable
+        end
+        local.get $l2
+        local.get $l2
+        i64.load offset=1036 align=4
+        i64.store offset=1048
+        i32.const 1049668
+        i32.const 43
+        local.get $l2
+        i32.const 1048
+        i32.add
+        i32.const 1049712
+        call $f192
+        unreachable
+      end
+      call $f12
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    call $f168
+    unreachable)
+  (func $f105 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    local.get $p0
+    local.get $p1
+    i32.load
+    local.get $p2
+    local.get $p3
+    local.get $p1
+    i32.load offset=4
+    i32.load offset=12
+    call_indirect (type $t6) $T0)
+  (func $f106 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    local.get $p0
+    local.get $p1
+    i32.load
+    local.get $p2
+    local.get $p3
+    local.get $p1
+    i32.load offset=4
+    i32.load offset=16
+    call_indirect (type $t6) $T0)
+  (func $f107 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p1
+    i32.load
+    local.get $p1
+    i32.load offset=4
+    i32.load offset=20
+    call_indirect (type $t3) $T0)
+  (func $f108 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    local.get $p0
+    local.get $p1
+    i32.load
+    local.get $p2
+    local.get $p3
+    local.get $p1
+    i32.load offset=4
+    i32.load offset=24
+    call_indirect (type $t6) $T0)
+  (func $f109 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p1
+    i32.load
+    local.set $l4
+    local.get $p1
+    i32.load offset=4
+    local.set $p1
+    local.get $l3
+    i32.const 24
+    i32.add
+    local.get $p2
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    i32.const 16
+    i32.add
+    local.get $p2
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    local.get $p2
+    i64.load align=4
+    i64.store offset=8
+    local.get $p0
+    local.get $l4
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p1
+    i32.load offset=28
+    call_indirect (type $t4) $T0
+    local.get $l3
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f110 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $p1
+    global.set $g0
+    local.get $p1
+    local.get $p3
+    i32.store offset=12
+    local.get $p1
+    local.get $p2
+    i32.store offset=8
+    i32.const 1
+    local.set $p2
+    local.get $p1
+    i32.const 16
+    i32.add
+    i32.const 2
+    local.get $p1
+    i32.const 8
+    i32.add
+    call $f142
+    block $B0
+      local.get $p1
+      i32.load16_u offset=16
+      i32.const 1
+      i32.ne
+      if $I1
+        local.get $p0
+        local.get $p1
+        i32.load offset=20
+        i32.store offset=4
+        i32.const 0
+        local.set $p2
+        br $B0
+      end
+      local.get $p1
+      local.get $p1
+      i32.load16_u offset=18
+      i32.store16 offset=30
+      local.get $p0
+      local.get $p1
+      i32.const 30
+      i32.add
+      i32.load16_u
+      i64.extend_i32_u
+      i64.const 65535
+      i64.and
+      i64.const 32
+      i64.shl
+      i64.store offset=4 align=4
+    end
+    local.get $p0
+    local.get $p2
+    i32.store
+    local.get $p1
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f111 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            i32.const 1060577
+            i32.load8_u
+            i32.eqz
+            if $I4
+              i32.const 1060577
+              i32.const 1
+              i32.store8
+              block $B5
+                i32.const 1060496
+                i32.load
+                local.tee $l1
+                i32.const 1
+                i32.le_u
+                if $I6
+                  local.get $l1
+                  i32.const 1
+                  i32.sub
+                  i32.eqz
+                  br_if $B5
+                  i32.const 12
+                  i32.const 4
+                  call $f36
+                  local.tee $l1
+                  i32.eqz
+                  br_if $B3
+                  local.get $l1
+                  i32.const 0
+                  i32.store offset=8
+                  local.get $l1
+                  i64.const 4
+                  i64.store align=4
+                  i32.const 1060496
+                  local.get $l1
+                  i32.store
+                end
+                block $B7
+                  local.get $l1
+                  i32.load offset=8
+                  local.tee $l2
+                  local.get $l1
+                  i32.load offset=4
+                  i32.ne
+                  if $I8
+                    local.get $l1
+                    i32.load
+                    local.set $l3
+                    br $B7
+                  end
+                  local.get $l2
+                  i32.const 1
+                  i32.add
+                  local.tee $l4
+                  local.get $l2
+                  i32.lt_u
+                  br_if $B1
+                  local.get $l2
+                  i32.const 1
+                  i32.shl
+                  local.tee $l3
+                  local.get $l4
+                  local.get $l3
+                  local.get $l4
+                  i32.gt_u
+                  select
+                  local.tee $l4
+                  i32.const 536870911
+                  i32.and
+                  local.tee $l3
+                  local.get $l4
+                  i32.ne
+                  br_if $B1
+                  local.get $l4
+                  i32.const 3
+                  i32.shl
+                  local.tee $l5
+                  i32.const 0
+                  i32.lt_s
+                  br_if $B1
+                  local.get $l3
+                  local.get $l4
+                  i32.eq
+                  i32.const 2
+                  i32.shl
+                  local.set $l6
+                  block $B9 (result i32)
+                    local.get $l2
+                    i32.eqz
+                    if $I10
+                      local.get $l5
+                      local.get $l6
+                      call $f36
+                      br $B9
+                    end
+                    local.get $l1
+                    i32.load
+                    local.get $l2
+                    i32.const 3
+                    i32.shl
+                    i32.const 4
+                    local.get $l5
+                    call $f37
+                  end
+                  local.tee $l3
+                  i32.eqz
+                  br_if $B2
+                  local.get $l1
+                  local.get $l4
+                  i32.store offset=4
+                  local.get $l1
+                  local.get $l3
+                  i32.store
+                  local.get $l1
+                  i32.load offset=8
+                  local.set $l2
+                end
+                local.get $l3
+                local.get $l2
+                i32.const 3
+                i32.shl
+                i32.add
+                local.tee $l2
+                i32.const 1051724
+                i32.store offset=4
+                local.get $l2
+                local.get $p0
+                i32.store
+                i32.const 1
+                local.set $l2
+                local.get $l1
+                local.get $l1
+                i32.load offset=8
+                i32.const 1
+                i32.add
+                i32.store offset=8
+                i32.const 1060577
+                i32.const 0
+                i32.store8
+                br $B0
+              end
+              i32.const 1060577
+              i32.const 0
+              i32.store8
+              local.get $p0
+              i32.const 1051724
+              i32.load
+              call_indirect (type $t2) $T0
+              i32.const 1051728
+              i32.load
+              i32.eqz
+              br_if $B0
+              i32.const 1051732
+              i32.load
+              drop
+              local.get $p0
+              call $f145
+              i32.const 0
+              return
+            end
+            i32.const 1052440
+            i32.const 32
+            i32.const 1052424
+            call $f55
+            unreachable
+          end
+          i32.const 12
+          i32.const 4
+          call $f168
+          unreachable
+        end
+        local.get $l5
+        local.get $l6
+        call $f168
+        unreachable
+      end
+      call $f169
+      unreachable
+    end
+    local.get $l2)
+  (func $f112 (type $t10) (result i32)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              i32.const 1060492
+              i32.load8_u
+              i32.eqz
+              if $I5
+                i32.const 1060492
+                i32.const 1
+                i32.store8
+                block $B6
+                  i32.const 1060488
+                  i32.load
+                  local.tee $l0
+                  i32.const 1
+                  i32.le_u
+                  if $I7
+                    local.get $l0
+                    i32.const 1
+                    i32.sub
+                    i32.eqz
+                    if $I8
+                      i32.const 1060492
+                      i32.const 0
+                      i32.store8
+                      call $f190
+                      unreachable
+                    end
+                    i32.const 4
+                    i32.const 4
+                    call $f36
+                    local.tee $l0
+                    i32.eqz
+                    br_if $B4
+                    local.get $l0
+                    i32.const 1060488
+                    i32.store
+                    local.get $l0
+                    call $f111
+                    i32.const 1024
+                    i32.const 1
+                    call $f36
+                    local.tee $l3
+                    i32.eqz
+                    br_if $B3
+                    local.get $l1
+                    i32.const 12
+                    i32.add
+                    local.tee $l4
+                    local.get $l1
+                    i32.const 15
+                    i32.add
+                    i32.load8_u
+                    i32.store8
+                    local.get $l1
+                    local.get $l1
+                    i32.load16_u offset=13 align=1
+                    i32.store16 offset=10
+                    i32.const 40
+                    i32.const 4
+                    call $f36
+                    local.tee $l0
+                    i32.eqz
+                    br_if $B2
+                    local.get $l0
+                    i32.const 0
+                    i32.store8 offset=32
+                    local.get $l0
+                    i32.const 0
+                    i32.store16 offset=28
+                    local.get $l0
+                    i64.const 1024
+                    i64.store offset=20 align=4
+                    local.get $l0
+                    local.get $l3
+                    i32.store offset=16
+                    local.get $l0
+                    i64.const 1
+                    i64.store offset=8 align=4
+                    local.get $l0
+                    i64.const 4294967297
+                    i64.store align=4
+                    local.get $l0
+                    local.get $l1
+                    i32.load16_u offset=10
+                    i32.store16 offset=33 align=1
+                    local.get $l0
+                    i32.const 0
+                    i32.store8 offset=36
+                    local.get $l0
+                    local.get $l1
+                    i32.load16_u offset=7 align=1
+                    i32.store16 offset=37 align=1
+                    local.get $l0
+                    i32.const 35
+                    i32.add
+                    local.get $l4
+                    i32.load8_u
+                    i32.store8
+                    local.get $l0
+                    i32.const 39
+                    i32.add
+                    local.get $l1
+                    i32.const 9
+                    i32.add
+                    i32.load8_u
+                    i32.store8
+                    i32.eqz
+                    br_if $B6
+                    local.get $l0
+                    local.get $l0
+                    i32.load
+                    local.tee $l2
+                    i32.const 1
+                    i32.add
+                    i32.store
+                    local.get $l2
+                    i32.const -1
+                    i32.le_s
+                    br_if $B1
+                    i32.const 4
+                    i32.const 4
+                    call $f36
+                    local.tee $l2
+                    i32.eqz
+                    br_if $B0
+                    i32.const 1060488
+                    local.get $l2
+                    i32.store
+                    local.get $l2
+                    local.get $l0
+                    i32.store
+                    br $B6
+                  end
+                  local.get $l0
+                  i32.load
+                  local.tee $l0
+                  local.get $l0
+                  i32.load
+                  local.tee $l2
+                  i32.const 1
+                  i32.add
+                  i32.store
+                  local.get $l2
+                  i32.const -1
+                  i32.le_s
+                  br_if $B1
+                end
+                i32.const 1060492
+                i32.const 0
+                i32.store8
+                local.get $l1
+                i32.const 16
+                i32.add
+                global.set $g0
+                local.get $l0
+                return
+              end
+              i32.const 1052440
+              i32.const 32
+              i32.const 1052424
+              call $f55
+              unreachable
+            end
+            i32.const 4
+            i32.const 4
+            call $f168
+            unreachable
+          end
+          i32.const 1024
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        i32.const 40
+        i32.const 4
+        call $f168
+        unreachable
+      end
+      unreachable
+    end
+    i32.const 4
+    i32.const 4
+    call $f168
+    unreachable)
+  (func $f113 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p1
+    i32.load
+    local.set $p1
+    block $B0
+      i32.const 1060568
+      i32.load
+      i32.const 1
+      i32.eq
+      if $I1
+        i32.const 1060572
+        i32.load
+        local.set $l4
+        br $B0
+      end
+      i32.const 1060568
+      i64.const 1
+      i64.store
+    end
+    i32.const 1060572
+    local.get $l4
+    i32.store
+    local.get $l3
+    local.get $l4
+    i32.const 0
+    i32.ne
+    i32.store8 offset=4
+    local.get $l3
+    local.get $p1
+    i32.const 8
+    i32.add
+    i32.store
+    local.get $l3
+    i32.const 3
+    i32.store8 offset=12
+    local.get $l3
+    local.get $l3
+    i32.store offset=8
+    local.get $l3
+    i32.const 40
+    i32.add
+    local.get $p2
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    i32.const 32
+    i32.add
+    local.get $p2
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    local.get $p2
+    i64.load align=4
+    i64.store offset=24
+    block $B2
+      block $B3
+        block $B4
+          block $B5
+            local.get $l3
+            i32.const 8
+            i32.add
+            i32.const 1050964
+            local.get $l3
+            i32.const 24
+            i32.add
+            call $f179
+            if $I6
+              local.get $l3
+              i32.load8_u offset=12
+              i32.const 3
+              i32.eq
+              if $I7
+                i32.const 15
+                i32.const 1
+                call $f36
+                local.tee $p1
+                i32.eqz
+                br_if $B4
+                local.get $p1
+                i32.const 7
+                i32.add
+                i32.const 1050953
+                i64.load align=1
+                i64.store align=1
+                local.get $p1
+                i32.const 1050946
+                i64.load align=1
+                i64.store align=1
+                i32.const 12
+                i32.const 4
+                call $f36
+                local.tee $p2
+                i32.eqz
+                br_if $B3
+                local.get $p2
+                i64.const 64424509455
+                i64.store offset=4 align=4
+                local.get $p2
+                local.get $p1
+                i32.store
+                i32.const 12
+                i32.const 4
+                call $f36
+                local.tee $p1
+                i32.eqz
+                br_if $B2
+                local.get $p1
+                i32.const 16
+                i32.store8 offset=8
+                local.get $p1
+                i32.const 1050348
+                i32.store offset=4
+                local.get $p1
+                local.get $p2
+                i32.store
+                local.get $p1
+                local.get $l3
+                i32.load16_u offset=24 align=1
+                i32.store16 offset=9 align=1
+                local.get $p1
+                i32.const 11
+                i32.add
+                local.get $l3
+                i32.const 26
+                i32.add
+                i32.load8_u
+                i32.store8
+                local.get $p0
+                i32.const 4
+                i32.add
+                local.get $p1
+                i32.store
+                local.get $p0
+                i32.const 2
+                i32.store
+                br $B5
+              end
+              local.get $p0
+              local.get $l3
+              i64.load offset=12 align=4
+              i64.store align=4
+              br $B5
+            end
+            local.get $p0
+            i32.const 3
+            i32.store8
+            local.get $l3
+            i32.load8_u offset=12
+            i32.const 2
+            i32.ne
+            br_if $B5
+            local.get $l3
+            i32.const 16
+            i32.add
+            i32.load
+            local.tee $p0
+            i32.load
+            local.get $p0
+            i32.load offset=4
+            i32.load
+            call_indirect (type $t2) $T0
+            local.get $p0
+            i32.load offset=4
+            local.tee $p1
+            i32.load offset=4
+            if $I8
+              local.get $p1
+              i32.load offset=8
+              drop
+              local.get $p0
+              i32.load
+              call $f145
+            end
+            local.get $l3
+            i32.load offset=16
+            call $f145
+          end
+          block $B9
+            local.get $l3
+            i32.load8_u offset=4
+            br_if $B9
+            i32.const 1060568
+            i32.load
+            i32.const 1
+            i32.ne
+            if $I10
+              i32.const 1060568
+              i64.const 1
+              i64.store
+              br $B9
+            end
+            i32.const 1060572
+            i32.load
+            i32.eqz
+            br_if $B9
+            local.get $l3
+            i32.load
+            i32.const 1
+            i32.store8 offset=28
+          end
+          local.get $l3
+          i32.const 48
+          i32.add
+          global.set $g0
+          return
+        end
+        i32.const 15
+        i32.const 1
+        call $f168
+        unreachable
+      end
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    i32.const 12
+    i32.const 4
+    call $f168
+    unreachable)
+  (func $f114 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0
+      block $B1
+        i32.const 1060540
+        i32.load
+        i32.const 1
+        i32.ne
+        if $I2
+          i32.const 1060540
+          i64.const 1
+          i64.store align=4
+          i32.const 1060548
+          i32.const 0
+          i32.store
+          br $B1
+        end
+        i32.const 1060544
+        i32.load
+        br_if $B0
+        i32.const 1060548
+        i32.load
+        local.set $l4
+      end
+      i32.const 1060548
+      local.get $p1
+      i32.store
+      i32.const 1060552
+      i32.load
+      local.set $l5
+      i32.const 1060552
+      local.get $p2
+      i32.store
+      i32.const 1060544
+      i32.const 0
+      i32.store
+      block $B3
+        local.get $l4
+        i32.eqz
+        br_if $B3
+        local.get $l3
+        local.get $l4
+        local.get $l5
+        i32.load offset=20
+        call_indirect (type $t3) $T0
+        local.get $l3
+        i32.load8_u
+        i32.const 2
+        i32.ne
+        br_if $B3
+        local.get $l3
+        i32.load offset=4
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $p2
+        i32.load offset=4
+        if $I4
+          local.get $p2
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p1
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i32.store
+      local.get $p0
+      local.get $l5
+      i32.store offset=4
+      local.get $l3
+      i32.const 16
+      i32.add
+      global.set $g0
+      return
+    end
+    i32.const 1049320
+    i32.const 16
+    local.get $l3
+    i32.const 8
+    i32.add
+    i32.const 1049620
+    call $f192
+    unreachable)
+  (func $f115 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 96
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    i32.const 24
+    i32.add
+    local.get $p0
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l1
+    i32.const 16
+    i32.add
+    local.get $p0
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l1
+    local.get $p0
+    i64.load align=4
+    i64.store offset=8
+    local.get $l1
+    i32.const 6
+    i32.store offset=36
+    local.get $l1
+    i32.const 1050912
+    i32.store offset=32
+    block $B0
+      block $B1
+        block $B2
+          i32.const 1060524
+          i32.load
+          i32.const 1
+          i32.ne
+          if $I3
+            i32.const 1060524
+            i64.const -4294967295
+            i64.store align=4
+            i32.const 1060532
+            i32.const 0
+            i32.store
+            local.get $l1
+            i32.const 56
+            i32.add
+            local.set $l2
+            br $B2
+          end
+          local.get $l1
+          i32.const 56
+          i32.add
+          local.set $l2
+          i32.const 1060528
+          i32.load
+          br_if $B1
+          i32.const 1060528
+          i32.const -1
+          i32.store
+          local.get $l1
+          i32.const 56
+          i32.add
+          local.set $l2
+          i32.const 1060532
+          i32.load
+          local.tee $p0
+          i32.eqz
+          br_if $B2
+          i32.const 1060536
+          i32.load
+          local.set $l3
+          local.get $l1
+          i32.const 88
+          i32.add
+          local.get $l1
+          i32.const 24
+          i32.add
+          i64.load
+          i64.store
+          local.get $l1
+          i32.const 80
+          i32.add
+          local.get $l1
+          i32.const 16
+          i32.add
+          i64.load
+          i64.store
+          local.get $l1
+          local.get $l1
+          i64.load offset=8
+          i64.store offset=72
+          local.get $l1
+          i32.const 56
+          i32.add
+          local.get $p0
+          local.get $l1
+          i32.const 72
+          i32.add
+          local.get $l3
+          i32.load offset=28
+          call_indirect (type $t4) $T0
+          i32.const 1060528
+          i32.const 1060528
+          i32.load
+          i32.const 1
+          i32.add
+          i32.store
+          br $B0
+        end
+        i32.const 1060528
+        i32.const 0
+        i32.store
+      end
+      local.get $l1
+      call $f112
+      local.tee $p0
+      i32.store offset=48
+      local.get $l1
+      i32.const 88
+      i32.add
+      local.get $l1
+      i32.const 24
+      i32.add
+      i64.load
+      i64.store
+      local.get $l1
+      i32.const 80
+      i32.add
+      local.get $l1
+      i32.const 16
+      i32.add
+      i64.load
+      i64.store
+      local.get $l1
+      local.get $l1
+      i64.load offset=8
+      i64.store offset=72
+      local.get $l2
+      local.get $l1
+      i32.const 48
+      i32.add
+      local.get $l1
+      i32.const 72
+      i32.add
+      call $f113
+      local.get $p0
+      local.get $p0
+      i32.load
+      local.tee $p0
+      i32.const -1
+      i32.add
+      i32.store
+      local.get $p0
+      i32.const 1
+      i32.eq
+      if $I4
+        local.get $l1
+        i32.const 48
+        i32.add
+        call $f57
+      end
+      local.get $l1
+      i32.const 56
+      i32.add
+      local.set $l2
+    end
+    block $B5
+      local.get $l1
+      i32.load offset=56
+      local.tee $p0
+      i32.const 255
+      i32.and
+      i32.const 4
+      i32.ne
+      if $I6
+        local.get $l1
+        local.get $l2
+        i32.load offset=4
+        i32.store offset=44
+        local.get $l1
+        local.get $p0
+        i32.store offset=40
+        br $B5
+      end
+      local.get $l1
+      call $f112
+      local.tee $p0
+      i32.store offset=56
+      local.get $l1
+      i32.const 88
+      i32.add
+      local.get $l1
+      i32.const 24
+      i32.add
+      i64.load
+      i64.store
+      local.get $l1
+      i32.const 80
+      i32.add
+      local.get $l1
+      i32.const 16
+      i32.add
+      i64.load
+      i64.store
+      local.get $l1
+      local.get $l1
+      i64.load offset=8
+      i64.store offset=72
+      local.get $l1
+      i32.const 40
+      i32.add
+      local.get $l1
+      i32.const 56
+      i32.add
+      local.get $l1
+      i32.const 72
+      i32.add
+      call $f113
+      local.get $p0
+      local.get $p0
+      i32.load
+      local.tee $p0
+      i32.const -1
+      i32.add
+      i32.store
+      local.get $p0
+      i32.const 1
+      i32.eq
+      if $I7
+        local.get $l1
+        i32.const 56
+        i32.add
+        call $f57
+      end
+      local.get $l1
+      i32.load8_u offset=40
+      local.set $p0
+    end
+    local.get $p0
+    i32.const 255
+    i32.and
+    i32.const 3
+    i32.eq
+    if $I8
+      local.get $p0
+      i32.const 3
+      i32.and
+      i32.const 2
+      i32.eq
+      if $I9
+        local.get $l1
+        i32.load offset=44
+        local.tee $p0
+        i32.load
+        local.get $p0
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p0
+        i32.load offset=4
+        local.tee $l2
+        i32.load offset=4
+        if $I10
+          local.get $l2
+          i32.load offset=8
+          drop
+          local.get $p0
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        call $f145
+      end
+      local.get $l1
+      i32.const 96
+      i32.add
+      global.set $g0
+      return
+    end
+    local.get $l1
+    local.get $l1
+    i64.load offset=40
+    i64.store offset=48
+    local.get $l1
+    i32.const 92
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l1
+    i32.const 68
+    i32.add
+    i32.const 15
+    i32.store
+    local.get $l1
+    i64.const 2
+    i64.store offset=76 align=4
+    local.get $l1
+    i32.const 1050856
+    i32.store offset=72
+    local.get $l1
+    i32.const 19
+    i32.store offset=60
+    local.get $l1
+    local.get $l1
+    i32.const 56
+    i32.add
+    i32.store offset=88
+    local.get $l1
+    local.get $l1
+    i32.const 48
+    i32.add
+    i32.store offset=64
+    local.get $l1
+    local.get $l1
+    i32.const 32
+    i32.add
+    i32.store offset=56
+    local.get $l1
+    i32.const 72
+    i32.add
+    i32.const 1050896
+    call $f84
+    unreachable)
+  (func $f116 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $p1
+    global.set $g0
+    local.get $p3
+    i32.const 3
+    i32.shl
+    local.set $p3
+    local.get $p2
+    i32.const -8
+    i32.add
+    local.set $l4
+    block $B0 (result i32)
+      loop $L1
+        local.get $p3
+        i32.eqz
+        if $I2
+          i32.const 0
+          local.set $l5
+          i32.const 1
+          br $B0
+        end
+        local.get $p3
+        i32.const -8
+        i32.add
+        local.set $p3
+        local.get $l4
+        i32.const 8
+        i32.add
+        local.set $l4
+        local.get $p2
+        i32.load offset=4
+        local.set $l5
+        local.get $p2
+        i32.const 8
+        i32.add
+        local.set $p2
+        local.get $l5
+        i32.eqz
+        br_if $L1
+      end
+      local.get $l4
+      i32.load
+    end
+    local.set $p2
+    local.get $p1
+    local.get $l5
+    i32.store offset=12
+    local.get $p1
+    local.get $p2
+    i32.store offset=8
+    local.get $p1
+    i32.const 16
+    i32.add
+    i32.const 2
+    local.get $p1
+    i32.const 8
+    i32.add
+    call $f142
+    local.get $p0
+    block $B3 (result i32)
+      local.get $p1
+      i32.load16_u offset=16
+      i32.const 1
+      i32.ne
+      if $I4
+        local.get $p0
+        local.get $p1
+        i32.load offset=20
+        i32.store offset=4
+        i32.const 0
+        br $B3
+      end
+      local.get $p1
+      local.get $p1
+      i32.load16_u offset=18
+      i32.store16 offset=30
+      local.get $p0
+      local.get $p1
+      i32.const 30
+      i32.add
+      i32.load16_u
+      i64.extend_i32_u
+      i64.const 65535
+      i64.and
+      i64.const 32
+      i64.shl
+      i64.store offset=4 align=4
+      i32.const 1
+    end
+    i32.store
+    local.get $p1
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f117 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 3
+    i32.store8 offset=12
+    local.get $l3
+    local.get $p1
+    i32.store offset=8
+    local.get $l3
+    i32.const 40
+    i32.add
+    local.get $p2
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    i32.const 32
+    i32.add
+    local.get $p2
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l3
+    local.get $p2
+    i64.load align=4
+    i64.store offset=24
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $l3
+            i32.const 8
+            i32.add
+            i32.const 1050988
+            local.get $l3
+            i32.const 24
+            i32.add
+            call $f179
+            if $I4
+              local.get $l3
+              i32.load8_u offset=12
+              i32.const 3
+              i32.eq
+              if $I5
+                i32.const 15
+                i32.const 1
+                call $f36
+                local.tee $p1
+                i32.eqz
+                br_if $B3
+                local.get $p1
+                i32.const 7
+                i32.add
+                i32.const 1050953
+                i64.load align=1
+                i64.store align=1
+                local.get $p1
+                i32.const 1050946
+                i64.load align=1
+                i64.store align=1
+                i32.const 12
+                i32.const 4
+                call $f36
+                local.tee $p2
+                i32.eqz
+                br_if $B2
+                local.get $p2
+                i64.const 64424509455
+                i64.store offset=4 align=4
+                local.get $p2
+                local.get $p1
+                i32.store
+                i32.const 12
+                i32.const 4
+                call $f36
+                local.tee $p1
+                i32.eqz
+                br_if $B1
+                local.get $p1
+                i32.const 16
+                i32.store8 offset=8
+                local.get $p1
+                i32.const 1050348
+                i32.store offset=4
+                local.get $p1
+                local.get $p2
+                i32.store
+                local.get $p1
+                local.get $l3
+                i32.load16_u offset=24 align=1
+                i32.store16 offset=9 align=1
+                local.get $p1
+                i32.const 11
+                i32.add
+                local.get $l3
+                i32.const 26
+                i32.add
+                i32.load8_u
+                i32.store8
+                local.get $p0
+                i32.const 4
+                i32.add
+                local.get $p1
+                i32.store
+                local.get $p0
+                i32.const 2
+                i32.store
+                br $B0
+              end
+              local.get $p0
+              local.get $l3
+              i64.load offset=12 align=4
+              i64.store align=4
+              br $B0
+            end
+            local.get $p0
+            i32.const 3
+            i32.store8
+            local.get $l3
+            i32.load8_u offset=12
+            i32.const 2
+            i32.ne
+            br_if $B0
+            local.get $l3
+            i32.const 16
+            i32.add
+            i32.load
+            local.tee $p0
+            i32.load
+            local.get $p0
+            i32.load offset=4
+            i32.load
+            call_indirect (type $t2) $T0
+            local.get $p0
+            i32.load offset=4
+            local.tee $p1
+            i32.load offset=4
+            if $I6
+              local.get $p1
+              i32.load offset=8
+              drop
+              local.get $p0
+              i32.load
+              call $f145
+            end
+            local.get $l3
+            i32.load offset=16
+            call $f145
+            br $B0
+          end
+          i32.const 15
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        i32.const 12
+        i32.const 4
+        call $f168
+        unreachable
+      end
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    local.get $l3
+    i32.const 48
+    i32.add
+    global.set $g0)
+  (func $f118 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.get $p1
+    local.get $p2
+    call $f51
+    i32.const 0
+    local.set $p1
+    local.get $l3
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I0
+      local.get $l3
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I1
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $p2
+        i32.load offset=4
+        if $I2
+          local.get $p2
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f119 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p0
+    i32.load
+    local.get $p1
+    local.get $p2
+    call $f49
+    i32.const 0
+    local.set $p1
+    local.get $l3
+    i32.load8_u offset=8
+    i32.const 3
+    i32.ne
+    if $I0
+      local.get $l3
+      i64.load offset=8
+      local.set $l4
+      local.get $p0
+      i32.load8_u offset=4
+      i32.const 2
+      i32.eq
+      if $I1
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $p1
+        i32.load
+        local.get $p1
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p1
+        i32.load offset=4
+        local.tee $p2
+        i32.load offset=4
+        if $I2
+          local.get $p2
+          i32.load offset=8
+          drop
+          local.get $p1
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        i32.load offset=8
+        call $f145
+      end
+      local.get $p0
+      local.get $l4
+      i64.store offset=4 align=4
+      i32.const 1
+      local.set $p1
+    end
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1)
+  (func $f120 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    i32.const 3
+    i32.store8)
+  (func $f121 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 2
+    i32.or
+    local.set $l4
+    i32.const 1060504
+    i32.load
+    local.set $l1
+    loop $L0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                local.get $l1
+                local.tee $l2
+                i32.const 3
+                i32.gt_u
+                br_if $B5
+                block $B6
+                  block $B7
+                    local.get $l2
+                    i32.const 1
+                    i32.sub
+                    br_table $B4 $B5 $B6 $B7
+                  end
+                  i32.const 1060504
+                  i32.const 2
+                  i32.const 1060504
+                  i32.load
+                  local.tee $l1
+                  local.get $l1
+                  local.get $l2
+                  i32.eq
+                  select
+                  i32.store
+                  local.get $l1
+                  local.get $l2
+                  i32.ne
+                  br_if $L0
+                  local.get $l3
+                  i32.const 1060504
+                  i32.store
+                  local.get $p0
+                  local.get $l2
+                  i32.const 1
+                  i32.eq
+                  i32.const 1051124
+                  i32.load
+                  call_indirect (type $t3) $T0
+                  local.get $l3
+                  i32.const 3
+                  i32.store offset=4
+                  local.get $l3
+                  call $f122
+                end
+                local.get $l3
+                i32.const 16
+                i32.add
+                global.set $g0
+                return
+              end
+              local.get $l2
+              i32.const 3
+              i32.and
+              i32.const 2
+              i32.eq
+              if $I8
+                loop $L9
+                  i32.const 1060556
+                  i32.load
+                  i32.const 1
+                  i32.ne
+                  if $I10
+                    i32.const 1060556
+                    i64.const 1
+                    i64.store align=4
+                    i32.const 1060564
+                    i32.const 0
+                    i32.store
+                  end
+                  local.get $l2
+                  local.set $l1
+                  call $f81
+                  local.set $l5
+                  i32.const 1060504
+                  local.get $l4
+                  i32.const 1060504
+                  i32.load
+                  local.tee $l2
+                  local.get $l1
+                  local.get $l2
+                  i32.eq
+                  select
+                  i32.store
+                  local.get $l3
+                  i32.const 0
+                  i32.store8 offset=8
+                  local.get $l3
+                  local.get $l5
+                  i32.store
+                  local.get $l3
+                  local.get $l1
+                  i32.const -4
+                  i32.and
+                  i32.store offset=4
+                  local.get $l1
+                  local.get $l2
+                  i32.eq
+                  if $I11
+                    local.get $l3
+                    i32.load8_u offset=8
+                    i32.eqz
+                    br_if $B3
+                    br $B2
+                  end
+                  block $B12
+                    local.get $l3
+                    i32.load
+                    local.tee $l1
+                    i32.eqz
+                    br_if $B12
+                    local.get $l1
+                    local.get $l1
+                    i32.load
+                    local.tee $l1
+                    i32.const -1
+                    i32.add
+                    i32.store
+                    local.get $l1
+                    i32.const 1
+                    i32.ne
+                    br_if $B12
+                    local.get $l3
+                    call $f78
+                  end
+                  local.get $l2
+                  i32.const 3
+                  i32.and
+                  i32.const 2
+                  i32.eq
+                  br_if $L9
+                  br $B1
+                end
+                unreachable
+              end
+              i32.const 1051172
+              i32.const 57
+              i32.const 1051156
+              call $f55
+              unreachable
+            end
+            i32.const 1051248
+            i32.const 42
+            i32.const 1051232
+            call $f55
+            unreachable
+          end
+          loop $L13
+            call $f82
+            local.get $l3
+            i32.load8_u offset=8
+            i32.eqz
+            br_if $L13
+          end
+        end
+        local.get $l3
+        i32.load
+        local.tee $l2
+        i32.eqz
+        br_if $B1
+        local.get $l2
+        local.get $l2
+        i32.load
+        local.tee $l2
+        i32.const -1
+        i32.add
+        i32.store
+        local.get $l2
+        i32.const 1
+        i32.ne
+        br_if $B1
+        local.get $l3
+        call $f78
+        i32.const 1060504
+        i32.load
+        local.set $l1
+        br $L0
+      end
+      i32.const 1060504
+      i32.load
+      local.set $l1
+      br $L0
+    end
+    unreachable)
+  (func $f122 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l1
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.tee $l2
+    i32.load
+    local.set $l3
+    local.get $l2
+    local.get $p0
+    i32.load offset=4
+    i32.store
+    local.get $l1
+    local.get $l3
+    i32.const 3
+    i32.and
+    local.tee $p0
+    i32.store offset=12
+    local.get $p0
+    i32.const 2
+    i32.eq
+    if $I0
+      block $B1
+        local.get $l3
+        i32.const -4
+        i32.and
+        local.tee $p0
+        if $I2
+          loop $L3
+            local.get $p0
+            i32.load offset=4
+            local.get $p0
+            i32.load
+            local.set $l2
+            local.get $p0
+            i32.const 0
+            i32.store
+            local.get $l2
+            i32.eqz
+            br_if $B1
+            local.get $p0
+            i32.const 1
+            i32.store8 offset=8
+            local.get $l1
+            local.get $l2
+            i32.store offset=16
+            local.get $l1
+            i32.const 16
+            i32.add
+            call $f87
+            local.get $l1
+            i32.load offset=16
+            local.tee $p0
+            local.get $p0
+            i32.load
+            local.tee $p0
+            i32.const -1
+            i32.add
+            i32.store
+            local.get $p0
+            i32.const 1
+            i32.eq
+            if $I4
+              local.get $l1
+              i32.const 16
+              i32.add
+              call $f78
+            end
+            local.tee $p0
+            br_if $L3
+          end
+        end
+        local.get $l1
+        i32.const -64
+        i32.sub
+        global.set $g0
+        return
+      end
+      i32.const 1049576
+      i32.const 43
+      i32.const 1049516
+      call $f172
+      unreachable
+    end
+    local.get $l1
+    i32.const 52
+    i32.add
+    i32.const 14
+    i32.store
+    local.get $l1
+    i32.const 36
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l1
+    i64.const 3
+    i64.store offset=20 align=4
+    local.get $l1
+    i32.const 1049492
+    i32.store offset=16
+    local.get $l1
+    i32.const 14
+    i32.store offset=44
+    local.get $l1
+    local.get $l1
+    i32.const 12
+    i32.add
+    i32.store offset=56
+    local.get $l1
+    i32.const 1049936
+    i32.store offset=60
+    local.get $l1
+    local.get $l1
+    i32.const 40
+    i32.add
+    i32.store offset=32
+    local.get $l1
+    local.get $l1
+    i32.const 60
+    i32.add
+    i32.store offset=48
+    local.get $l1
+    local.get $l1
+    i32.const 56
+    i32.add
+    i32.store offset=40
+    local.get $l1
+    i32.const 16
+    i32.add
+    i32.const 1051292
+    call $f84
+    unreachable)
+  (func $f123 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i64)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.load8_u
+    local.set $l3
+    local.get $l2
+    i32.const 40
+    i32.add
+    call $f89
+    block $B0
+      local.get $l2
+      i32.load offset=40
+      i32.const 1
+      i32.ne
+      if $I1
+        local.get $l2
+        i32.const 48
+        i32.add
+        i64.load
+        local.set $l6
+        local.get $l2
+        i32.load offset=44
+        local.set $l4
+        br $B0
+      end
+      local.get $l2
+      i32.load8_u offset=44
+      i32.const 2
+      i32.ge_u
+      if $I2
+        local.get $l2
+        i32.const 48
+        i32.add
+        i32.load
+        local.tee $p0
+        i32.load
+        local.get $p0
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p0
+        i32.load offset=4
+        local.tee $l5
+        i32.load offset=4
+        if $I3
+          local.get $l5
+          i32.load offset=8
+          drop
+          local.get $p0
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        call $f145
+      end
+    end
+    local.get $l2
+    local.get $l6
+    i64.store offset=4 align=4
+    local.get $l2
+    local.get $l4
+    i32.store
+    local.get $l2
+    local.get $l3
+    i32.store8 offset=12
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    local.get $l3
+    local.get $l2
+    call $f143
+    block $B4
+      block $B5
+        local.get $l2
+        i32.const 16
+        i32.add
+        i32.load
+        i32.const 1052603
+        i32.const 17
+        call $f218
+        br_if $B5
+        local.get $l3
+        i32.eqz
+        if $I6
+          local.get $l2
+          i64.const 4
+          i64.store offset=56
+          local.get $l2
+          i64.const 1
+          i64.store offset=44 align=4
+          local.get $l2
+          i32.const 1051500
+          i32.store offset=40
+          local.get $p1
+          local.get $l2
+          i32.const 40
+          i32.add
+          call $f219
+          br_if $B5
+        end
+        i32.const 0
+        local.set $p0
+        local.get $l2
+        i32.load
+        local.tee $p1
+        i32.eqz
+        br_if $B4
+        local.get $l2
+        i32.load offset=4
+        i32.eqz
+        br_if $B4
+        local.get $p1
+        call $f145
+        br $B4
+      end
+      i32.const 1
+      local.set $p0
+      local.get $l2
+      i32.load
+      local.tee $p1
+      i32.eqz
+      br_if $B4
+      local.get $l2
+      i32.load offset=4
+      i32.eqz
+      br_if $B4
+      local.get $p1
+      call $f145
+    end
+    local.get $l2
+    i32.const -64
+    i32.sub
+    global.set $g0
+    local.get $p0)
+  (func $f124 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $p0
+    global.set $g0
+    block $B0 (result i32)
+      local.get $p2
+      i32.load
+      i32.const 1
+      i32.eq
+      if $I1
+        i32.const 1051512
+        local.set $p2
+        i32.const 9
+        br $B0
+      end
+      local.get $p0
+      i32.const 16
+      i32.add
+      local.get $p2
+      i32.load offset=4
+      local.get $p2
+      i32.const 8
+      i32.add
+      i32.load
+      call $f201
+      i32.const 1051512
+      local.get $p0
+      i32.load offset=20
+      local.get $p0
+      i32.load offset=16
+      i32.const 1
+      i32.eq
+      local.tee $l3
+      select
+      local.set $p2
+      i32.const 9
+      local.get $p0
+      i32.const 24
+      i32.add
+      i32.load
+      local.get $l3
+      select
+    end
+    local.set $l3
+    local.get $p0
+    i32.const 8
+    i32.add
+    local.get $p2
+    local.get $l3
+    call $f195
+    local.get $p0
+    i32.load offset=8
+    local.get $p0
+    i32.load offset=12
+    local.get $p1
+    call $f197
+    local.get $p0
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f125 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    i32.const 1051521
+    i32.const 25
+    local.get $p1
+    call $f224)
+  (func $f126 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    i32.const 32
+    i32.add
+    local.get $p0
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l1
+    i32.const 24
+    i32.add
+    local.get $p0
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l1
+    local.get $p0
+    i64.load align=4
+    i64.store offset=16
+    local.get $l1
+    i32.const 8
+    i32.add
+    local.get $l1
+    i32.const 40
+    i32.add
+    local.get $l1
+    i32.const 16
+    i32.add
+    call $f117
+    local.get $l1
+    i32.load8_u offset=8
+    i32.const 2
+    i32.eq
+    if $I0
+      local.get $l1
+      i32.load offset=12
+      local.tee $p0
+      i32.load
+      local.get $p0
+      i32.load offset=4
+      i32.load
+      call_indirect (type $t2) $T0
+      local.get $p0
+      i32.load offset=4
+      local.tee $l2
+      i32.load offset=4
+      if $I1
+        local.get $l2
+        i32.load offset=8
+        drop
+        local.get $p0
+        i32.load
+        call $f145
+      end
+      local.get $p0
+      call $f145
+    end
+    local.get $l1
+    i32.const 48
+    i32.add
+    global.set $g0)
+  (func $f127 (type $t2) (param $p0 i32)
+    (local $l1 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    i32.const 20
+    i32.add
+    i32.const 1
+    i32.store
+    local.get $l1
+    i64.const 2
+    i64.store offset=4 align=4
+    local.get $l1
+    i32.const 1051660
+    i32.store
+    local.get $l1
+    i32.const 4
+    i32.store offset=28
+    local.get $l1
+    local.get $p0
+    i32.store offset=24
+    local.get $l1
+    local.get $l1
+    i32.const 24
+    i32.add
+    i32.store offset=16
+    local.get $l1
+    call $f126
+    unreachable)
+  (func $f128 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $p1
+    global.set $g0
+    local.get $p1
+    i32.const 20
+    i32.store offset=12
+    local.get $p1
+    local.get $p0
+    i32.store offset=20
+    local.get $p1
+    local.get $p1
+    i32.const 20
+    i32.add
+    i32.store offset=8
+    local.get $p1
+    i32.const 52
+    i32.add
+    i32.const 1
+    i32.store
+    local.get $p1
+    i64.const 2
+    i64.store offset=36 align=4
+    local.get $p1
+    i32.const 1051776
+    i32.store offset=32
+    local.get $p1
+    local.get $p1
+    i32.const 8
+    i32.add
+    i32.store offset=48
+    local.get $p1
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 56
+    i32.add
+    local.get $p1
+    i32.const 32
+    i32.add
+    call $f117
+    local.get $p1
+    i32.load8_u offset=24
+    i32.const 2
+    i32.eq
+    if $I0
+      local.get $p1
+      i32.load offset=28
+      local.tee $p0
+      i32.load
+      local.get $p0
+      i32.load offset=4
+      i32.load
+      call_indirect (type $t2) $T0
+      local.get $p0
+      i32.load offset=4
+      local.tee $l2
+      i32.load offset=4
+      if $I1
+        local.get $l2
+        i32.load offset=8
+        drop
+        local.get $p0
+        i32.load
+        call $f145
+      end
+      local.get $p0
+      call $f145
+    end
+    local.get $p1
+    i32.const -64
+    i32.sub
+    global.set $g0)
+  (func $f129 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p1
+    i32.const 8
+    i32.gt_u
+    local.get $p1
+    local.get $p0
+    i32.gt_u
+    i32.or
+    i32.eqz
+    if $I0
+      local.get $p0
+      call $f144
+      return
+    end
+    local.get $p0
+    local.get $p1
+    call $f150)
+  (func $f130 (type $t9) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (result i32)
+    local.get $p2
+    i32.const 8
+    i32.le_u
+    i32.const 0
+    local.get $p2
+    local.get $p3
+    i32.le_u
+    select
+    i32.eqz
+    if $I0
+      local.get $p3
+      local.get $p2
+      call $f150
+      local.tee $p2
+      i32.eqz
+      if $I1
+        i32.const 0
+        return
+      end
+      local.get $p2
+      local.get $p0
+      local.get $p3
+      local.get $p1
+      local.get $p1
+      local.get $p3
+      i32.gt_u
+      select
+      call $f162
+      local.get $p0
+      call $f145
+      return
+    end
+    local.get $p0
+    local.get $p3
+    call $f147)
+  (func $f131 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 20
+    i32.add
+    i32.const 3
+    i32.store
+    local.get $l3
+    i32.const 52
+    i32.add
+    i32.const 22
+    i32.store
+    local.get $l3
+    i32.const 44
+    i32.add
+    i32.const 19
+    i32.store
+    local.get $l3
+    i64.const 4
+    i64.store offset=4 align=4
+    local.get $l3
+    i32.const 1051912
+    i32.store
+    local.get $l3
+    i32.const 19
+    i32.store offset=36
+    local.get $l3
+    local.get $p0
+    i32.load offset=8
+    i32.store offset=48
+    local.get $l3
+    local.get $p0
+    i32.load offset=4
+    i32.store offset=40
+    local.get $l3
+    local.get $p0
+    i32.load
+    i32.store offset=32
+    local.get $l3
+    local.get $l3
+    i32.const 32
+    i32.add
+    i32.store offset=16
+    local.get $l3
+    i32.const 24
+    i32.add
+    local.get $p1
+    local.get $l3
+    local.get $p2
+    i32.load offset=28
+    local.tee $l4
+    call_indirect (type $t4) $T0
+    local.get $l3
+    i32.load8_u offset=24
+    i32.const 2
+    i32.eq
+    if $I0
+      local.get $l3
+      i32.load offset=28
+      local.tee $p2
+      i32.load
+      local.get $p2
+      i32.load offset=4
+      i32.load
+      call_indirect (type $t2) $T0
+      local.get $p2
+      i32.load offset=4
+      local.tee $l5
+      i32.load offset=4
+      if $I1
+        local.get $l5
+        i32.load offset=8
+        drop
+        local.get $p2
+        i32.load
+        call $f145
+      end
+      local.get $p2
+      call $f145
+    end
+    block $B2
+      block $B3
+        block $B4
+          block $B5
+            local.get $p0
+            i32.load offset=12
+            i32.load8_u
+            local.tee $p0
+            i32.const -3
+            i32.add
+            i32.const 255
+            i32.and
+            local.tee $p2
+            i32.const 1
+            i32.add
+            i32.const 0
+            local.get $p2
+            i32.const 2
+            i32.lt_u
+            select
+            i32.const 1
+            i32.sub
+            br_table $B3 $B4 $B5
+          end
+          i32.const 1060578
+          i32.load8_u
+          br_if $B2
+          i32.const 1060578
+          i32.const 1
+          i32.store8
+          local.get $l3
+          i32.const 52
+          i32.add
+          i32.const 1
+          i32.store
+          local.get $l3
+          i64.const 1
+          i64.store offset=36 align=4
+          local.get $l3
+          i32.const 1050752
+          i32.store offset=32
+          local.get $l3
+          i32.const 23
+          i32.store offset=4
+          local.get $l3
+          local.get $p0
+          i32.store8 offset=63
+          local.get $l3
+          local.get $l3
+          i32.store offset=48
+          local.get $l3
+          local.get $l3
+          i32.const 63
+          i32.add
+          i32.store
+          local.get $l3
+          i32.const 24
+          i32.add
+          local.get $p1
+          local.get $l3
+          i32.const 32
+          i32.add
+          local.get $l4
+          call_indirect (type $t4) $T0
+          i32.const 1060578
+          i32.const 0
+          i32.store8
+          local.get $l3
+          i32.load8_u offset=24
+          i32.const 2
+          i32.ne
+          br_if $B3
+          local.get $l3
+          i32.load offset=28
+          local.tee $p0
+          i32.load
+          local.get $p0
+          i32.load offset=4
+          i32.load
+          call_indirect (type $t2) $T0
+          local.get $p0
+          i32.load offset=4
+          local.tee $p1
+          i32.load offset=4
+          if $I6
+            local.get $p1
+            i32.load offset=8
+            drop
+            local.get $p0
+            i32.load
+            call $f145
+          end
+          local.get $p0
+          call $f145
+          br $B3
+        end
+        i32.const 1060480
+        i32.load8_u
+        i32.const 1060480
+        i32.const 0
+        i32.store8
+        i32.eqz
+        br_if $B3
+        local.get $l3
+        i64.const 4
+        i64.store offset=48
+        local.get $l3
+        i64.const 1
+        i64.store offset=36 align=4
+        local.get $l3
+        i32.const 1052024
+        i32.store offset=32
+        local.get $l3
+        local.get $p1
+        local.get $l3
+        i32.const 32
+        i32.add
+        local.get $l4
+        call_indirect (type $t4) $T0
+        local.get $l3
+        i32.load8_u
+        i32.const 2
+        i32.ne
+        br_if $B3
+        local.get $l3
+        i32.load offset=4
+        local.tee $p0
+        i32.load
+        local.get $p0
+        i32.load offset=4
+        i32.load
+        call_indirect (type $t2) $T0
+        local.get $p0
+        i32.load offset=4
+        local.tee $p1
+        i32.load offset=4
+        if $I7
+          local.get $p1
+          i32.load offset=8
+          drop
+          local.get $p0
+          i32.load
+          call $f145
+        end
+        local.get $p0
+        call $f145
+      end
+      local.get $l3
+      i32.const -64
+      i32.sub
+      global.set $g0
+      return
+    end
+    i32.const 1052440
+    i32.const 32
+    i32.const 1052424
+    call $f55
+    unreachable)
+  (func $f132 (type $t2) (param $p0 i32)
+    local.get $p0
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i32.load
+    local.get $p0
+    i32.load offset=4
+    i32.load offset=12
+    call_indirect (type $t5) $T0
+    i32.store)
+  (func $f133 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i64)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $p0
+    i32.load offset=12
+    call $f67
+    local.set $l2
+    local.get $p0
+    i32.load offset=8
+    call $f67
+    local.set $l3
+    local.get $l1
+    i32.const 8
+    i32.add
+    local.get $l2
+    call $f187
+    local.get $l1
+    i64.load offset=8
+    local.set $l5
+    local.get $l2
+    i32.load offset=8
+    local.set $l4
+    local.get $l1
+    local.get $l2
+    i32.load offset=12
+    i32.store offset=28
+    local.get $l1
+    local.get $l4
+    i32.store offset=24
+    local.get $l1
+    local.get $l5
+    i64.store offset=16
+    local.get $l1
+    i32.const 0
+    i32.store offset=36
+    local.get $l1
+    local.get $l3
+    i32.store offset=32
+    local.get $l1
+    i32.const 32
+    i32.add
+    i32.const 1052032
+    local.get $p0
+    i32.load offset=8
+    local.get $l1
+    i32.const 16
+    i32.add
+    call $f134
+    unreachable)
+  (func $f134 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    i32.const 1
+    local.set $l5
+    local.get $p3
+    i32.load offset=12
+    local.set $l6
+    local.get $p3
+    i32.load offset=8
+    local.set $l7
+    local.get $p3
+    i32.load offset=4
+    local.set $l8
+    local.get $p3
+    i32.load
+    local.set $p3
+    block $B0
+      block $B1
+        block $B2
+          i32.const 1060568
+          i32.load
+          i32.const 1
+          i32.ne
+          if $I3
+            i32.const 1060568
+            i64.const 4294967297
+            i64.store
+            br $B2
+          end
+          i32.const 1060572
+          i32.const 1060572
+          i32.load
+          i32.const 1
+          i32.add
+          local.tee $l5
+          i32.store
+          local.get $l5
+          i32.const 2
+          i32.gt_u
+          br_if $B1
+        end
+        local.get $l4
+        i32.const 24
+        i32.add
+        local.get $p3
+        local.get $l8
+        local.get $l7
+        local.get $l6
+        call $f186
+        local.get $l4
+        local.get $p2
+        i32.store offset=48
+        local.get $l4
+        i32.const 1049532
+        i32.store offset=44
+        local.get $l4
+        i32.const 1
+        i32.store offset=40
+        i32.const 1060512
+        i32.load
+        local.set $p2
+        local.get $l4
+        local.get $l4
+        i32.const 24
+        i32.add
+        i32.store offset=52
+        local.get $p2
+        i32.const -1
+        i32.gt_s
+        if $I4
+          i32.const 1060512
+          local.get $p2
+          i32.const 1
+          i32.add
+          i32.store
+          block $B5
+            i32.const 1060520
+            i32.load
+            local.tee $p2
+            i32.eqz
+            if $I6
+              local.get $l4
+              i32.const 8
+              i32.add
+              local.get $p0
+              local.get $p1
+              i32.load offset=16
+              call_indirect (type $t3) $T0
+              local.get $l4
+              local.get $l4
+              i64.load offset=8
+              i64.store offset=40
+              local.get $l4
+              i32.const 40
+              i32.add
+              call $f54
+              br $B5
+            end
+            i32.const 1060516
+            i32.load
+            local.get $l4
+            i32.const 16
+            i32.add
+            local.get $p0
+            local.get $p1
+            i32.load offset=16
+            call_indirect (type $t3) $T0
+            local.get $l4
+            local.get $l4
+            i64.load offset=16
+            i64.store offset=40
+            local.get $l4
+            i32.const 40
+            i32.add
+            local.get $p2
+            i32.load offset=12
+            call_indirect (type $t3) $T0
+          end
+          i32.const 1060512
+          i32.const 1060512
+          i32.load
+          i32.const -1
+          i32.add
+          i32.store
+          local.get $l5
+          i32.const 1
+          i32.le_u
+          br_if $B0
+          local.get $l4
+          i64.const 4
+          i64.store offset=72
+          local.get $l4
+          i64.const 1
+          i64.store offset=60 align=4
+          local.get $l4
+          i32.const 1052208
+          i32.store offset=56
+          local.get $l4
+          i32.const 56
+          i32.add
+          call $f126
+          unreachable
+        end
+        local.get $l4
+        i64.const 4
+        i64.store offset=72
+        local.get $l4
+        i64.const 1
+        i64.store offset=60 align=4
+        local.get $l4
+        i32.const 1052560
+        i32.store offset=56
+        local.get $l4
+        i32.const 56
+        i32.add
+        call $f127
+        unreachable
+      end
+      local.get $l4
+      i64.const 4
+      i64.store offset=72
+      local.get $l4
+      i64.const 1
+      i64.store offset=60 align=4
+      local.get $l4
+      i32.const 1052156
+      i32.store offset=56
+      local.get $l4
+      i32.const 56
+      i32.add
+      call $f126
+      unreachable
+    end
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $p2
+    global.set $g0
+    local.get $p2
+    local.get $p1
+    i32.store offset=4
+    local.get $p2
+    local.get $p0
+    i32.store
+    unreachable)
+  (func $f135 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l2
+    global.set $g0
+    local.get $p1
+    i32.load offset=4
+    local.tee $l3
+    i32.eqz
+    if $I0
+      local.get $p1
+      i32.const 4
+      i32.add
+      local.set $l3
+      local.get $p1
+      i32.load
+      local.set $l4
+      local.get $l2
+      i32.const 0
+      i32.store offset=32
+      local.get $l2
+      i64.const 1
+      i64.store offset=24
+      local.get $l2
+      local.get $l2
+      i32.const 24
+      i32.add
+      i32.store offset=36
+      local.get $l2
+      i32.const 56
+      i32.add
+      local.get $l4
+      i32.const 16
+      i32.add
+      i64.load align=4
+      i64.store
+      local.get $l2
+      i32.const 48
+      i32.add
+      local.get $l4
+      i32.const 8
+      i32.add
+      i64.load align=4
+      i64.store
+      local.get $l2
+      local.get $l4
+      i64.load align=4
+      i64.store offset=40
+      local.get $l2
+      i32.const 36
+      i32.add
+      i32.const 1049264
+      local.get $l2
+      i32.const 40
+      i32.add
+      call $f179
+      drop
+      local.get $l2
+      i32.const 16
+      i32.add
+      local.tee $l4
+      local.get $l2
+      i32.load offset=32
+      i32.store
+      local.get $l2
+      local.get $l2
+      i64.load offset=24
+      i64.store offset=8
+      block $B1
+        local.get $p1
+        i32.load offset=4
+        local.tee $l5
+        i32.eqz
+        br_if $B1
+        local.get $p1
+        i32.const 8
+        i32.add
+        i32.load
+        i32.eqz
+        br_if $B1
+        local.get $l5
+        call $f145
+      end
+      local.get $l3
+      local.get $l2
+      i64.load offset=8
+      i64.store align=4
+      local.get $l3
+      i32.const 8
+      i32.add
+      local.get $l4
+      i32.load
+      i32.store
+      local.get $l3
+      i32.load
+      local.set $l3
+    end
+    local.get $p1
+    i32.const 1
+    i32.store offset=4
+    local.get $p1
+    i32.const 12
+    i32.add
+    i32.load
+    local.set $l4
+    local.get $p1
+    i32.const 8
+    i32.add
+    local.tee $p1
+    i32.load
+    local.set $l5
+    local.get $p1
+    i64.const 0
+    i64.store align=4
+    i32.const 12
+    i32.const 4
+    call $f36
+    local.tee $p1
+    i32.eqz
+    if $I2
+      i32.const 12
+      i32.const 4
+      call $f168
+      unreachable
+    end
+    local.get $p1
+    local.get $l4
+    i32.store offset=8
+    local.get $p1
+    local.get $l5
+    i32.store offset=4
+    local.get $p1
+    local.get $l3
+    i32.store
+    local.get $p0
+    i32.const 1052052
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store
+    local.get $l2
+    i32.const -64
+    i32.sub
+    global.set $g0)
+  (func $f136 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l2
+    global.set $g0
+    local.get $p1
+    i32.const 4
+    i32.add
+    local.set $l4
+    local.get $p1
+    i32.load offset=4
+    i32.eqz
+    if $I0
+      local.get $p1
+      i32.load
+      local.set $l3
+      local.get $l2
+      i32.const 0
+      i32.store offset=32
+      local.get $l2
+      i64.const 1
+      i64.store offset=24
+      local.get $l2
+      local.get $l2
+      i32.const 24
+      i32.add
+      i32.store offset=36
+      local.get $l2
+      i32.const 56
+      i32.add
+      local.get $l3
+      i32.const 16
+      i32.add
+      i64.load align=4
+      i64.store
+      local.get $l2
+      i32.const 48
+      i32.add
+      local.get $l3
+      i32.const 8
+      i32.add
+      i64.load align=4
+      i64.store
+      local.get $l2
+      local.get $l3
+      i64.load align=4
+      i64.store offset=40
+      local.get $l2
+      i32.const 36
+      i32.add
+      i32.const 1049264
+      local.get $l2
+      i32.const 40
+      i32.add
+      call $f179
+      drop
+      local.get $l2
+      i32.const 16
+      i32.add
+      local.tee $l3
+      local.get $l2
+      i32.load offset=32
+      i32.store
+      local.get $l2
+      local.get $l2
+      i64.load offset=24
+      i64.store offset=8
+      block $B1
+        local.get $p1
+        i32.load offset=4
+        local.tee $l5
+        i32.eqz
+        br_if $B1
+        local.get $p1
+        i32.const 8
+        i32.add
+        i32.load
+        i32.eqz
+        br_if $B1
+        local.get $l5
+        call $f145
+      end
+      local.get $l4
+      local.get $l2
+      i64.load offset=8
+      i64.store align=4
+      local.get $l4
+      i32.const 8
+      i32.add
+      local.get $l3
+      i32.load
+      i32.store
+    end
+    local.get $p0
+    i32.const 1052052
+    i32.store offset=4
+    local.get $p0
+    local.get $l4
+    i32.store
+    local.get $l2
+    i32.const -64
+    i32.sub
+    global.set $g0)
+  (func $f137 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32)
+    local.get $p1
+    i32.load
+    local.set $l2
+    local.get $p1
+    i32.const 0
+    i32.store
+    block $B0
+      local.get $l2
+      if $I1
+        local.get $p1
+        i32.load offset=4
+        local.set $l3
+        i32.const 8
+        i32.const 4
+        call $f36
+        local.tee $p1
+        i32.eqz
+        br_if $B0
+        local.get $p1
+        local.get $l3
+        i32.store offset=4
+        local.get $p1
+        local.get $l2
+        i32.store
+        local.get $p0
+        i32.const 1052088
+        i32.store offset=4
+        local.get $p0
+        local.get $p1
+        i32.store
+        return
+      end
+      unreachable
+    end
+    i32.const 8
+    i32.const 4
+    call $f168
+    unreachable)
+  (func $f138 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p1
+    i32.load
+    i32.eqz
+    if $I0
+      unreachable
+    end
+    local.get $p0
+    i32.const 1052088
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f139 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l1
+    global.set $g0
+    local.get $l1
+    i32.const 1049192
+    i32.store offset=4
+    local.get $l1
+    local.get $p0
+    i32.store
+    block $B0
+      block $B1
+        block $B2
+          i32.const 4
+          i32.const 1
+          call $f36
+          local.tee $p0
+          if $I3
+            local.get $p0
+            i32.const 1852399981
+            i32.store align=1
+            local.get $l1
+            i64.const 17179869188
+            i64.store offset=12 align=4
+            local.get $l1
+            local.get $p0
+            i32.store offset=8
+            local.get $l1
+            i32.const 8
+            i32.add
+            call $f85
+            local.set $l2
+            block $B4
+              i32.const 1060556
+              i32.load
+              i32.const 1
+              i32.ne
+              if $I5
+                i32.const 1060556
+                i64.const 1
+                i64.store align=4
+                i32.const 1060564
+                i32.const 0
+                i32.store
+                br $B4
+              end
+              i32.const 1060560
+              i32.load
+              local.tee $p0
+              i32.const 1
+              i32.add
+              i32.const 0
+              i32.le_s
+              br_if $B2
+              i32.const 1060564
+              i32.load
+              br_if $B1
+              local.get $p0
+              br_if $B0
+            end
+            i32.const 0
+            local.set $p0
+            i32.const 1060564
+            local.get $l2
+            i32.store
+            i32.const 1060560
+            i32.const 0
+            i32.store
+            local.get $l1
+            i32.const 0
+            i32.store offset=24
+            local.get $l1
+            i32.const 0
+            i32.store offset=28
+            local.get $l1
+            local.get $l1
+            i32.store offset=8
+            block $B6 (result i32)
+              local.get $l1
+              i32.const 8
+              i32.add
+              call $f132
+              i32.const 0
+              if $I7
+                i32.const 1060572
+                block $B8 (result i32)
+                  i32.const 1060568
+                  i32.load
+                  i32.const 1
+                  i32.eq
+                  if $I9
+                    i32.const 1060572
+                    i32.load
+                    i32.const -1
+                    i32.add
+                    br $B8
+                  end
+                  i32.const 1060568
+                  i64.const 1
+                  i64.store
+                  i32.const -1
+                end
+                i32.store
+                i32.const 1
+                local.set $p0
+                local.get $l1
+                i32.load offset=28
+                local.set $l3
+                local.get $l1
+                i32.load offset=24
+                br $B6
+              end
+              local.get $l1
+              i32.load offset=8
+            end
+            local.set $l2
+            i32.const 1060504
+            i32.load
+            i32.const 3
+            i32.ne
+            if $I10
+              local.get $l1
+              i32.const 1
+              i32.store8 offset=28
+              local.get $l1
+              local.get $l1
+              i32.const 28
+              i32.add
+              i32.store offset=8
+              local.get $l1
+              i32.const 8
+              i32.add
+              call $f121
+            end
+            i32.const 101
+            local.get $l2
+            local.get $p0
+            select
+            block $B11
+              local.get $p0
+              i32.eqz
+              br_if $B11
+              local.get $l2
+              local.get $l3
+              i32.load
+              call_indirect (type $t2) $T0
+              local.get $l3
+              i32.load offset=4
+              i32.eqz
+              br_if $B11
+              local.get $l3
+              i32.load offset=8
+              drop
+              local.get $l2
+              call $f145
+            end
+            local.get $l1
+            i32.const 32
+            i32.add
+            global.set $g0
+            return
+          end
+          i32.const 4
+          i32.const 1
+          call $f168
+          unreachable
+        end
+        i32.const 1049336
+        i32.const 24
+        local.get $l1
+        i32.const 8
+        i32.add
+        i32.const 1049652
+        call $f192
+        unreachable
+      end
+      i32.const 1051600
+      i32.const 38
+      i32.const 1051584
+      call $f55
+      unreachable
+    end
+    i32.const 1049320
+    i32.const 16
+    local.get $l1
+    i32.const 8
+    i32.add
+    i32.const 1049620
+    call $f192
+    unreachable)
+  (func $f140 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0
+      local.get $p0
+      i32.load
+      i32.eqz
+      if $I1
+        local.get $l2
+        local.get $p1
+        i32.const 1052266
+        i32.const 10
+        call $f222
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.const 1052256
+      i32.const 10
+      call $f222
+      local.get $l2
+      local.get $p0
+      i32.store offset=12
+      local.get $l2
+      local.get $l2
+      i32.const 12
+      i32.add
+      i32.const 1049288
+      call $f206
+    end
+    local.get $l2
+    call $f207
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f141 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p1
+    i32.const 1052276
+    i32.const 8
+    call $f222
+    local.get $l2
+    local.get $p0
+    i32.store offset=12
+    local.get $l2
+    local.get $l2
+    i32.const 12
+    i32.add
+    i32.const 1049856
+    call $f206
+    local.get $l2
+    local.get $p0
+    i32.const 4
+    i32.add
+    i32.store offset=12
+    local.get $l2
+    local.get $l2
+    i32.const 12
+    i32.add
+    i32.const 1052284
+    call $f206
+    local.get $l2
+    call $f207
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f142 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    block $B0 (result i32)
+      local.get $p1
+      local.get $p2
+      i32.const 1
+      local.get $l3
+      i32.const 12
+      i32.add
+      call $wasi_snapshot_preview1.fd_write
+      local.tee $p1
+      i32.eqz
+      if $I1
+        local.get $p0
+        i32.const 4
+        i32.add
+        local.get $l3
+        i32.load offset=12
+        i32.store
+        i32.const 0
+        br $B0
+      end
+      local.get $p0
+      local.get $p1
+      i32.store16 offset=2
+      i32.const 1
+    end
+    i32.store16
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f143 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    local.get $p0
+    local.get $p2
+    i32.store8 offset=16
+    local.get $p0
+    i32.const 0
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store
+    local.get $p0
+    local.get $p3
+    i32.store offset=8
+    local.get $p0
+    i32.const 12
+    i32.add
+    i32.const 1051392
+    i32.store)
+  (func $f144 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l11
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                block $B6
+                  block $B7
+                    block $B8
+                      block $B9
+                        block $B10
+                          local.get $p0
+                          i32.const 236
+                          i32.le_u
+                          if $I11
+                            i32.const 1060580
+                            i32.load
+                            local.tee $l5
+                            i32.const 16
+                            local.get $p0
+                            i32.const 19
+                            i32.add
+                            i32.const -16
+                            i32.and
+                            local.get $p0
+                            i32.const 11
+                            i32.lt_u
+                            select
+                            local.tee $l6
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $p0
+                            i32.shr_u
+                            local.tee $l1
+                            i32.const 3
+                            i32.and
+                            if $I12
+                              local.get $l1
+                              i32.const 1
+                              i32.and
+                              local.get $p0
+                              i32.or
+                              i32.const 1
+                              i32.xor
+                              local.tee $l2
+                              i32.const 3
+                              i32.shl
+                              local.tee $l4
+                              i32.const 1060628
+                              i32.add
+                              i32.load
+                              local.tee $l1
+                              i32.const 8
+                              i32.add
+                              local.set $p0
+                              block $B13
+                                local.get $l1
+                                i32.load offset=8
+                                local.tee $l3
+                                local.get $l4
+                                i32.const 1060620
+                                i32.add
+                                local.tee $l4
+                                i32.eq
+                                if $I14
+                                  i32.const 1060580
+                                  local.get $l5
+                                  i32.const -2
+                                  local.get $l2
+                                  i32.rotl
+                                  i32.and
+                                  i32.store
+                                  br $B13
+                                end
+                                i32.const 1060596
+                                i32.load
+                                drop
+                                local.get $l4
+                                local.get $l3
+                                i32.store offset=8
+                                local.get $l3
+                                local.get $l4
+                                i32.store offset=12
+                              end
+                              local.get $l1
+                              local.get $l2
+                              i32.const 3
+                              i32.shl
+                              local.tee $l2
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $l1
+                              local.get $l2
+                              i32.add
+                              local.tee $l1
+                              local.get $l1
+                              i32.load offset=4
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              br $B0
+                            end
+                            local.get $l6
+                            i32.const 1060588
+                            i32.load
+                            local.tee $l8
+                            i32.le_u
+                            br_if $B10
+                            local.get $l1
+                            if $I15
+                              block $B16
+                                i32.const 2
+                                local.get $p0
+                                i32.shl
+                                local.tee $l2
+                                i32.const 0
+                                local.get $l2
+                                i32.sub
+                                i32.or
+                                local.get $l1
+                                local.get $p0
+                                i32.shl
+                                i32.and
+                                local.tee $p0
+                                i32.const 0
+                                local.get $p0
+                                i32.sub
+                                i32.and
+                                i32.const -1
+                                i32.add
+                                local.tee $p0
+                                local.get $p0
+                                i32.const 12
+                                i32.shr_u
+                                i32.const 16
+                                i32.and
+                                local.tee $p0
+                                i32.shr_u
+                                local.tee $l1
+                                i32.const 5
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $l2
+                                local.get $p0
+                                i32.or
+                                local.get $l1
+                                local.get $l2
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 2
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 1
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 1
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                i32.add
+                                local.tee $l2
+                                i32.const 3
+                                i32.shl
+                                local.tee $l3
+                                i32.const 1060628
+                                i32.add
+                                i32.load
+                                local.tee $l1
+                                i32.load offset=8
+                                local.tee $p0
+                                local.get $l3
+                                i32.const 1060620
+                                i32.add
+                                local.tee $l3
+                                i32.eq
+                                if $I17
+                                  i32.const 1060580
+                                  local.get $l5
+                                  i32.const -2
+                                  local.get $l2
+                                  i32.rotl
+                                  i32.and
+                                  local.tee $l5
+                                  i32.store
+                                  br $B16
+                                end
+                                i32.const 1060596
+                                i32.load
+                                drop
+                                local.get $l3
+                                local.get $p0
+                                i32.store offset=8
+                                local.get $p0
+                                local.get $l3
+                                i32.store offset=12
+                              end
+                              local.get $l1
+                              i32.const 8
+                              i32.add
+                              local.set $p0
+                              local.get $l1
+                              local.get $l6
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $l1
+                              local.get $l2
+                              i32.const 3
+                              i32.shl
+                              local.tee $l2
+                              i32.add
+                              local.get $l2
+                              local.get $l6
+                              i32.sub
+                              local.tee $l4
+                              i32.store
+                              local.get $l1
+                              local.get $l6
+                              i32.add
+                              local.tee $l6
+                              local.get $l4
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $l8
+                              if $I18
+                                local.get $l8
+                                i32.const 3
+                                i32.shr_u
+                                local.tee $l3
+                                i32.const 3
+                                i32.shl
+                                i32.const 1060620
+                                i32.add
+                                local.set $l1
+                                i32.const 1060600
+                                i32.load
+                                local.set $l2
+                                block $B19 (result i32)
+                                  local.get $l5
+                                  i32.const 1
+                                  local.get $l3
+                                  i32.shl
+                                  local.tee $l3
+                                  i32.and
+                                  i32.eqz
+                                  if $I20
+                                    i32.const 1060580
+                                    local.get $l3
+                                    local.get $l5
+                                    i32.or
+                                    i32.store
+                                    local.get $l1
+                                    br $B19
+                                  end
+                                  local.get $l1
+                                  i32.load offset=8
+                                end
+                                local.tee $l3
+                                local.get $l2
+                                i32.store offset=12
+                                local.get $l1
+                                local.get $l2
+                                i32.store offset=8
+                                local.get $l2
+                                local.get $l1
+                                i32.store offset=12
+                                local.get $l2
+                                local.get $l3
+                                i32.store offset=8
+                              end
+                              i32.const 1060600
+                              local.get $l6
+                              i32.store
+                              i32.const 1060588
+                              local.get $l4
+                              i32.store
+                              br $B0
+                            end
+                            i32.const 1060584
+                            i32.load
+                            local.tee $l10
+                            i32.eqz
+                            br_if $B10
+                            local.get $l10
+                            i32.const 0
+                            local.get $l10
+                            i32.sub
+                            i32.and
+                            i32.const -1
+                            i32.add
+                            local.tee $p0
+                            local.get $p0
+                            i32.const 12
+                            i32.shr_u
+                            i32.const 16
+                            i32.and
+                            local.tee $p0
+                            i32.shr_u
+                            local.tee $l1
+                            i32.const 5
+                            i32.shr_u
+                            i32.const 8
+                            i32.and
+                            local.tee $l2
+                            local.get $p0
+                            i32.or
+                            local.get $l1
+                            local.get $l2
+                            i32.shr_u
+                            local.tee $p0
+                            i32.const 2
+                            i32.shr_u
+                            i32.const 4
+                            i32.and
+                            local.tee $l1
+                            i32.or
+                            local.get $p0
+                            local.get $l1
+                            i32.shr_u
+                            local.tee $p0
+                            i32.const 1
+                            i32.shr_u
+                            i32.const 2
+                            i32.and
+                            local.tee $l1
+                            i32.or
+                            local.get $p0
+                            local.get $l1
+                            i32.shr_u
+                            local.tee $p0
+                            i32.const 1
+                            i32.shr_u
+                            i32.const 1
+                            i32.and
+                            local.tee $l1
+                            i32.or
+                            local.get $p0
+                            local.get $l1
+                            i32.shr_u
+                            i32.add
+                            i32.const 2
+                            i32.shl
+                            i32.const 1060884
+                            i32.add
+                            i32.load
+                            local.tee $l1
+                            i32.load offset=4
+                            i32.const -8
+                            i32.and
+                            local.get $l6
+                            i32.sub
+                            local.set $l2
+                            local.get $l1
+                            local.set $l4
+                            loop $L21
+                              block $B22
+                                local.get $l4
+                                i32.load offset=16
+                                local.tee $p0
+                                i32.eqz
+                                if $I23
+                                  local.get $l4
+                                  i32.const 20
+                                  i32.add
+                                  i32.load
+                                  local.tee $p0
+                                  i32.eqz
+                                  br_if $B22
+                                end
+                                local.get $p0
+                                i32.load offset=4
+                                i32.const -8
+                                i32.and
+                                local.get $l6
+                                i32.sub
+                                local.tee $l3
+                                local.get $l2
+                                local.get $l3
+                                local.get $l2
+                                i32.lt_u
+                                local.tee $l3
+                                select
+                                local.set $l2
+                                local.get $p0
+                                local.get $l1
+                                local.get $l3
+                                select
+                                local.set $l1
+                                local.get $p0
+                                local.set $l4
+                                br $L21
+                              end
+                            end
+                            local.get $l1
+                            i32.load offset=24
+                            local.set $l9
+                            local.get $l1
+                            local.get $l1
+                            i32.load offset=12
+                            local.tee $l3
+                            i32.ne
+                            if $I24
+                              i32.const 1060596
+                              i32.load
+                              local.get $l1
+                              i32.load offset=8
+                              local.tee $p0
+                              i32.le_u
+                              if $I25
+                                local.get $p0
+                                i32.load offset=12
+                                drop
+                              end
+                              local.get $l3
+                              local.get $p0
+                              i32.store offset=8
+                              local.get $p0
+                              local.get $l3
+                              i32.store offset=12
+                              br $B1
+                            end
+                            local.get $l1
+                            i32.const 20
+                            i32.add
+                            local.tee $l4
+                            i32.load
+                            local.tee $p0
+                            i32.eqz
+                            if $I26
+                              local.get $l1
+                              i32.load offset=16
+                              local.tee $p0
+                              i32.eqz
+                              br_if $B9
+                              local.get $l1
+                              i32.const 16
+                              i32.add
+                              local.set $l4
+                            end
+                            loop $L27
+                              local.get $l4
+                              local.set $l7
+                              local.get $p0
+                              local.tee $l3
+                              i32.const 20
+                              i32.add
+                              local.tee $l4
+                              i32.load
+                              local.tee $p0
+                              br_if $L27
+                              local.get $l3
+                              i32.const 16
+                              i32.add
+                              local.set $l4
+                              local.get $l3
+                              i32.load offset=16
+                              local.tee $p0
+                              br_if $L27
+                            end
+                            local.get $l7
+                            i32.const 0
+                            i32.store
+                            br $B1
+                          end
+                          i32.const -1
+                          local.set $l6
+                          local.get $p0
+                          i32.const -65
+                          i32.gt_u
+                          br_if $B10
+                          local.get $p0
+                          i32.const 19
+                          i32.add
+                          local.tee $p0
+                          i32.const -16
+                          i32.and
+                          local.set $l6
+                          i32.const 1060584
+                          i32.load
+                          local.tee $l8
+                          i32.eqz
+                          br_if $B10
+                          i32.const 0
+                          local.get $l6
+                          i32.sub
+                          local.set $l4
+                          block $B28
+                            block $B29
+                              block $B30
+                                block $B31 (result i32)
+                                  i32.const 0
+                                  local.get $p0
+                                  i32.const 8
+                                  i32.shr_u
+                                  local.tee $p0
+                                  i32.eqz
+                                  br_if $B31
+                                  drop
+                                  i32.const 31
+                                  local.get $l6
+                                  i32.const 16777215
+                                  i32.gt_u
+                                  br_if $B31
+                                  drop
+                                  local.get $p0
+                                  local.get $p0
+                                  i32.const 1048320
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 8
+                                  i32.and
+                                  local.tee $p0
+                                  i32.shl
+                                  local.tee $l1
+                                  local.get $l1
+                                  i32.const 520192
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  local.tee $l1
+                                  i32.shl
+                                  local.tee $l2
+                                  local.get $l2
+                                  i32.const 245760
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.and
+                                  local.tee $l2
+                                  i32.shl
+                                  i32.const 15
+                                  i32.shr_u
+                                  local.get $p0
+                                  local.get $l1
+                                  i32.or
+                                  local.get $l2
+                                  i32.or
+                                  i32.sub
+                                  local.tee $p0
+                                  i32.const 1
+                                  i32.shl
+                                  local.get $l6
+                                  local.get $p0
+                                  i32.const 21
+                                  i32.add
+                                  i32.shr_u
+                                  i32.const 1
+                                  i32.and
+                                  i32.or
+                                  i32.const 28
+                                  i32.add
+                                end
+                                local.tee $l7
+                                i32.const 2
+                                i32.shl
+                                i32.const 1060884
+                                i32.add
+                                i32.load
+                                local.tee $l2
+                                i32.eqz
+                                if $I32
+                                  i32.const 0
+                                  local.set $p0
+                                  br $B30
+                                end
+                                local.get $l6
+                                i32.const 0
+                                i32.const 25
+                                local.get $l7
+                                i32.const 1
+                                i32.shr_u
+                                i32.sub
+                                local.get $l7
+                                i32.const 31
+                                i32.eq
+                                select
+                                i32.shl
+                                local.set $l1
+                                i32.const 0
+                                local.set $p0
+                                loop $L33
+                                  block $B34
+                                    local.get $l2
+                                    i32.load offset=4
+                                    i32.const -8
+                                    i32.and
+                                    local.get $l6
+                                    i32.sub
+                                    local.tee $l5
+                                    local.get $l4
+                                    i32.ge_u
+                                    br_if $B34
+                                    local.get $l2
+                                    local.set $l3
+                                    local.get $l5
+                                    local.tee $l4
+                                    br_if $B34
+                                    i32.const 0
+                                    local.set $l4
+                                    local.get $l2
+                                    local.set $p0
+                                    br $B29
+                                  end
+                                  local.get $p0
+                                  local.get $l2
+                                  i32.const 20
+                                  i32.add
+                                  i32.load
+                                  local.tee $l5
+                                  local.get $l5
+                                  local.get $l2
+                                  local.get $l1
+                                  i32.const 29
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  i32.add
+                                  i32.const 16
+                                  i32.add
+                                  i32.load
+                                  local.tee $l2
+                                  i32.eq
+                                  select
+                                  local.get $p0
+                                  local.get $l5
+                                  select
+                                  local.set $p0
+                                  local.get $l1
+                                  local.get $l2
+                                  i32.const 0
+                                  i32.ne
+                                  i32.shl
+                                  local.set $l1
+                                  local.get $l2
+                                  br_if $L33
+                                end
+                              end
+                              local.get $p0
+                              local.get $l3
+                              i32.or
+                              i32.eqz
+                              if $I35
+                                i32.const 2
+                                local.get $l7
+                                i32.shl
+                                local.tee $p0
+                                i32.const 0
+                                local.get $p0
+                                i32.sub
+                                i32.or
+                                local.get $l8
+                                i32.and
+                                local.tee $p0
+                                i32.eqz
+                                br_if $B10
+                                local.get $p0
+                                i32.const 0
+                                local.get $p0
+                                i32.sub
+                                i32.and
+                                i32.const -1
+                                i32.add
+                                local.tee $p0
+                                local.get $p0
+                                i32.const 12
+                                i32.shr_u
+                                i32.const 16
+                                i32.and
+                                local.tee $p0
+                                i32.shr_u
+                                local.tee $l1
+                                i32.const 5
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $l2
+                                local.get $p0
+                                i32.or
+                                local.get $l1
+                                local.get $l2
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 2
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 1
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                local.tee $p0
+                                i32.const 1
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.tee $l1
+                                i32.or
+                                local.get $p0
+                                local.get $l1
+                                i32.shr_u
+                                i32.add
+                                i32.const 2
+                                i32.shl
+                                i32.const 1060884
+                                i32.add
+                                i32.load
+                                local.set $p0
+                              end
+                              local.get $p0
+                              i32.eqz
+                              br_if $B28
+                            end
+                            loop $L36
+                              local.get $p0
+                              i32.load offset=4
+                              i32.const -8
+                              i32.and
+                              local.get $l6
+                              i32.sub
+                              local.tee $l5
+                              local.get $l4
+                              i32.lt_u
+                              local.set $l1
+                              local.get $l5
+                              local.get $l4
+                              local.get $l1
+                              select
+                              local.set $l4
+                              local.get $p0
+                              local.get $l3
+                              local.get $l1
+                              select
+                              local.set $l3
+                              local.get $p0
+                              i32.load offset=16
+                              local.tee $l2
+                              if $I37 (result i32)
+                                local.get $l2
+                              else
+                                local.get $p0
+                                i32.const 20
+                                i32.add
+                                i32.load
+                              end
+                              local.tee $p0
+                              br_if $L36
+                            end
+                          end
+                          local.get $l3
+                          i32.eqz
+                          br_if $B10
+                          local.get $l4
+                          i32.const 1060588
+                          i32.load
+                          local.get $l6
+                          i32.sub
+                          i32.ge_u
+                          br_if $B10
+                          local.get $l3
+                          i32.load offset=24
+                          local.set $l7
+                          local.get $l3
+                          local.get $l3
+                          i32.load offset=12
+                          local.tee $l1
+                          i32.ne
+                          if $I38
+                            i32.const 1060596
+                            i32.load
+                            local.get $l3
+                            i32.load offset=8
+                            local.tee $p0
+                            i32.le_u
+                            if $I39
+                              local.get $p0
+                              i32.load offset=12
+                              drop
+                            end
+                            local.get $l1
+                            local.get $p0
+                            i32.store offset=8
+                            local.get $p0
+                            local.get $l1
+                            i32.store offset=12
+                            br $B2
+                          end
+                          local.get $l3
+                          i32.const 20
+                          i32.add
+                          local.tee $l2
+                          i32.load
+                          local.tee $p0
+                          i32.eqz
+                          if $I40
+                            local.get $l3
+                            i32.load offset=16
+                            local.tee $p0
+                            i32.eqz
+                            br_if $B8
+                            local.get $l3
+                            i32.const 16
+                            i32.add
+                            local.set $l2
+                          end
+                          loop $L41
+                            local.get $l2
+                            local.set $l5
+                            local.get $p0
+                            local.tee $l1
+                            i32.const 20
+                            i32.add
+                            local.tee $l2
+                            i32.load
+                            local.tee $p0
+                            br_if $L41
+                            local.get $l1
+                            i32.const 16
+                            i32.add
+                            local.set $l2
+                            local.get $l1
+                            i32.load offset=16
+                            local.tee $p0
+                            br_if $L41
+                          end
+                          local.get $l5
+                          i32.const 0
+                          i32.store
+                          br $B2
+                        end
+                        i32.const 1060588
+                        i32.load
+                        local.tee $l1
+                        local.get $l6
+                        i32.ge_u
+                        if $I42
+                          i32.const 1060600
+                          i32.load
+                          local.set $p0
+                          block $B43
+                            local.get $l1
+                            local.get $l6
+                            i32.sub
+                            local.tee $l2
+                            i32.const 16
+                            i32.ge_u
+                            if $I44
+                              local.get $p0
+                              local.get $l6
+                              i32.add
+                              local.tee $l3
+                              local.get $l2
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              i32.const 1060588
+                              local.get $l2
+                              i32.store
+                              i32.const 1060600
+                              local.get $l3
+                              i32.store
+                              local.get $p0
+                              local.get $l1
+                              i32.add
+                              local.get $l2
+                              i32.store
+                              local.get $p0
+                              local.get $l6
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              br $B43
+                            end
+                            local.get $p0
+                            local.get $l1
+                            i32.const 3
+                            i32.or
+                            i32.store offset=4
+                            local.get $p0
+                            local.get $l1
+                            i32.add
+                            local.tee $l1
+                            local.get $l1
+                            i32.load offset=4
+                            i32.const 1
+                            i32.or
+                            i32.store offset=4
+                            i32.const 1060600
+                            i32.const 0
+                            i32.store
+                            i32.const 1060588
+                            i32.const 0
+                            i32.store
+                          end
+                          local.get $p0
+                          i32.const 8
+                          i32.add
+                          local.set $p0
+                          br $B0
+                        end
+                        i32.const 1060592
+                        i32.load
+                        local.tee $l1
+                        local.get $l6
+                        i32.gt_u
+                        if $I45
+                          i32.const 1060604
+                          i32.load
+                          local.tee $p0
+                          local.get $l6
+                          i32.add
+                          local.tee $l2
+                          local.get $l1
+                          local.get $l6
+                          i32.sub
+                          local.tee $l1
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                          i32.const 1060592
+                          local.get $l1
+                          i32.store
+                          i32.const 1060604
+                          local.get $l2
+                          i32.store
+                          local.get $p0
+                          local.get $l6
+                          i32.const 3
+                          i32.or
+                          i32.store offset=4
+                          local.get $p0
+                          i32.const 8
+                          i32.add
+                          local.set $p0
+                          br $B0
+                        end
+                        i32.const 0
+                        local.set $p0
+                        local.get $l6
+                        i32.const 71
+                        i32.add
+                        local.tee $l4
+                        block $B46 (result i32)
+                          i32.const 1061052
+                          i32.load
+                          if $I47
+                            i32.const 1061060
+                            i32.load
+                            br $B46
+                          end
+                          i32.const 1061064
+                          i64.const -1
+                          i64.store align=4
+                          i32.const 1061056
+                          i64.const 281474976776192
+                          i64.store align=4
+                          i32.const 1061052
+                          local.get $l11
+                          i32.const 12
+                          i32.add
+                          i32.const -16
+                          i32.and
+                          i32.const 1431655768
+                          i32.xor
+                          i32.store
+                          i32.const 1061072
+                          i32.const 0
+                          i32.store
+                          i32.const 1061024
+                          i32.const 0
+                          i32.store
+                          i32.const 65536
+                        end
+                        local.tee $l2
+                        i32.add
+                        local.tee $l5
+                        i32.const 0
+                        local.get $l2
+                        i32.sub
+                        local.tee $l7
+                        i32.and
+                        local.tee $l2
+                        local.get $l6
+                        i32.le_u
+                        if $I48
+                          i32.const 1061076
+                          i32.const 48
+                          i32.store
+                          br $B0
+                        end
+                        block $B49
+                          i32.const 1061020
+                          i32.load
+                          local.tee $p0
+                          i32.eqz
+                          br_if $B49
+                          i32.const 1061012
+                          i32.load
+                          local.tee $l3
+                          local.get $l2
+                          i32.add
+                          local.tee $l8
+                          local.get $l3
+                          i32.gt_u
+                          i32.const 0
+                          local.get $l8
+                          local.get $p0
+                          i32.le_u
+                          select
+                          br_if $B49
+                          i32.const 0
+                          local.set $p0
+                          i32.const 1061076
+                          i32.const 48
+                          i32.store
+                          br $B0
+                        end
+                        i32.const 1061024
+                        i32.load8_u
+                        i32.const 4
+                        i32.and
+                        br_if $B5
+                        block $B50
+                          block $B51
+                            i32.const 1060604
+                            i32.load
+                            local.tee $l3
+                            if $I52
+                              i32.const 1061028
+                              local.set $p0
+                              loop $L53
+                                local.get $p0
+                                i32.load
+                                local.tee $l8
+                                local.get $l3
+                                i32.le_u
+                                if $I54
+                                  local.get $l8
+                                  local.get $p0
+                                  i32.load offset=4
+                                  i32.add
+                                  local.get $l3
+                                  i32.gt_u
+                                  br_if $B51
+                                end
+                                local.get $p0
+                                i32.load offset=8
+                                local.tee $p0
+                                br_if $L53
+                              end
+                            end
+                            i32.const 0
+                            call $f153
+                            local.tee $l1
+                            i32.const -1
+                            i32.eq
+                            br_if $B6
+                            local.get $l2
+                            local.set $l5
+                            i32.const 1061056
+                            i32.load
+                            local.tee $p0
+                            i32.const -1
+                            i32.add
+                            local.tee $l3
+                            local.get $l1
+                            i32.and
+                            if $I55
+                              local.get $l2
+                              local.get $l1
+                              i32.sub
+                              local.get $l1
+                              local.get $l3
+                              i32.add
+                              i32.const 0
+                              local.get $p0
+                              i32.sub
+                              i32.and
+                              i32.add
+                              local.set $l5
+                            end
+                            local.get $l5
+                            local.get $l6
+                            i32.le_u
+                            local.get $l5
+                            i32.const 2147483646
+                            i32.gt_u
+                            i32.or
+                            br_if $B6
+                            i32.const 1061020
+                            i32.load
+                            local.tee $p0
+                            if $I56
+                              i32.const 1061012
+                              i32.load
+                              local.tee $l3
+                              local.get $l5
+                              i32.add
+                              local.tee $l7
+                              local.get $l3
+                              i32.le_u
+                              local.get $l7
+                              local.get $p0
+                              i32.gt_u
+                              i32.or
+                              br_if $B6
+                            end
+                            local.get $l5
+                            call $f153
+                            local.tee $p0
+                            local.get $l1
+                            i32.ne
+                            br_if $B50
+                            br $B4
+                          end
+                          local.get $l5
+                          local.get $l1
+                          i32.sub
+                          local.get $l7
+                          i32.and
+                          local.tee $l5
+                          i32.const 2147483646
+                          i32.gt_u
+                          br_if $B6
+                          local.get $l5
+                          call $f153
+                          local.tee $l1
+                          local.get $p0
+                          i32.load
+                          local.get $p0
+                          i32.load offset=4
+                          i32.add
+                          i32.eq
+                          br_if $B7
+                          local.get $l1
+                          local.set $p0
+                        end
+                        local.get $l6
+                        i32.const 72
+                        i32.add
+                        local.get $l5
+                        i32.le_u
+                        local.get $l5
+                        i32.const 2147483646
+                        i32.gt_u
+                        i32.or
+                        local.get $p0
+                        local.tee $l1
+                        i32.const -1
+                        i32.eq
+                        i32.or
+                        i32.eqz
+                        if $I57
+                          i32.const 1061060
+                          i32.load
+                          local.tee $p0
+                          local.get $l4
+                          local.get $l5
+                          i32.sub
+                          i32.add
+                          i32.const 0
+                          local.get $p0
+                          i32.sub
+                          i32.and
+                          local.tee $p0
+                          i32.const 2147483646
+                          i32.gt_u
+                          br_if $B4
+                          local.get $p0
+                          call $f153
+                          i32.const -1
+                          i32.ne
+                          if $I58
+                            local.get $p0
+                            local.get $l5
+                            i32.add
+                            local.set $l5
+                            br $B4
+                          end
+                          i32.const 0
+                          local.get $l5
+                          i32.sub
+                          call $f153
+                          drop
+                          br $B6
+                        end
+                        local.get $l1
+                        i32.const -1
+                        i32.ne
+                        br_if $B4
+                        br $B6
+                      end
+                      i32.const 0
+                      local.set $l3
+                      br $B1
+                    end
+                    i32.const 0
+                    local.set $l1
+                    br $B2
+                  end
+                  local.get $l1
+                  i32.const -1
+                  i32.ne
+                  br_if $B4
+                end
+                i32.const 1061024
+                i32.const 1061024
+                i32.load
+                i32.const 4
+                i32.or
+                i32.store
+              end
+              local.get $l2
+              i32.const 2147483646
+              i32.gt_u
+              br_if $B3
+              local.get $l2
+              call $f153
+              local.tee $l1
+              i32.const 0
+              call $f153
+              local.tee $p0
+              i32.ge_u
+              local.get $l1
+              i32.const -1
+              i32.eq
+              i32.or
+              local.get $p0
+              i32.const -1
+              i32.eq
+              i32.or
+              br_if $B3
+              local.get $p0
+              local.get $l1
+              i32.sub
+              local.tee $l5
+              local.get $l6
+              i32.const 56
+              i32.add
+              i32.le_u
+              br_if $B3
+            end
+            i32.const 1061012
+            i32.const 1061012
+            i32.load
+            local.get $l5
+            i32.add
+            local.tee $p0
+            i32.store
+            local.get $p0
+            i32.const 1061016
+            i32.load
+            i32.gt_u
+            if $I59
+              i32.const 1061016
+              local.get $p0
+              i32.store
+            end
+            block $B60
+              block $B61
+                block $B62
+                  i32.const 1060604
+                  i32.load
+                  local.tee $l7
+                  if $I63
+                    i32.const 1061028
+                    local.set $p0
+                    loop $L64
+                      local.get $l1
+                      local.get $p0
+                      i32.load
+                      local.tee $l2
+                      local.get $p0
+                      i32.load offset=4
+                      local.tee $l3
+                      i32.add
+                      i32.eq
+                      br_if $B62
+                      local.get $p0
+                      i32.load offset=8
+                      local.tee $p0
+                      br_if $L64
+                    end
+                    br $B61
+                  end
+                  i32.const 1060596
+                  i32.load
+                  local.tee $p0
+                  i32.const 0
+                  local.get $l1
+                  local.get $p0
+                  i32.ge_u
+                  select
+                  i32.eqz
+                  if $I65
+                    i32.const 1060596
+                    local.get $l1
+                    i32.store
+                  end
+                  i32.const 0
+                  local.set $p0
+                  i32.const 1061032
+                  local.get $l5
+                  i32.store
+                  i32.const 1061028
+                  local.get $l1
+                  i32.store
+                  i32.const 1060612
+                  i32.const -1
+                  i32.store
+                  i32.const 1060616
+                  i32.const 1061052
+                  i32.load
+                  i32.store
+                  i32.const 1061040
+                  i32.const 0
+                  i32.store
+                  loop $L66
+                    local.get $p0
+                    i32.const 1060628
+                    i32.add
+                    local.get $p0
+                    i32.const 1060620
+                    i32.add
+                    local.tee $l2
+                    i32.store
+                    local.get $p0
+                    i32.const 1060632
+                    i32.add
+                    local.get $l2
+                    i32.store
+                    local.get $p0
+                    i32.const 8
+                    i32.add
+                    local.tee $p0
+                    i32.const 256
+                    i32.ne
+                    br_if $L66
+                  end
+                  local.get $l1
+                  i32.const -8
+                  local.get $l1
+                  i32.sub
+                  i32.const 15
+                  i32.and
+                  i32.const 0
+                  local.get $l1
+                  i32.const 8
+                  i32.add
+                  i32.const 15
+                  i32.and
+                  select
+                  local.tee $p0
+                  i32.add
+                  local.tee $l2
+                  local.get $l5
+                  i32.const -56
+                  i32.add
+                  local.tee $l3
+                  local.get $p0
+                  i32.sub
+                  local.tee $p0
+                  i32.const 1
+                  i32.or
+                  i32.store offset=4
+                  i32.const 1060608
+                  i32.const 1061068
+                  i32.load
+                  i32.store
+                  i32.const 1060592
+                  local.get $p0
+                  i32.store
+                  i32.const 1060604
+                  local.get $l2
+                  i32.store
+                  local.get $l1
+                  local.get $l3
+                  i32.add
+                  i32.const 56
+                  i32.store offset=4
+                  br $B60
+                end
+                local.get $p0
+                i32.load8_u offset=12
+                i32.const 8
+                i32.and
+                local.get $l1
+                local.get $l7
+                i32.le_u
+                i32.or
+                local.get $l2
+                local.get $l7
+                i32.gt_u
+                i32.or
+                br_if $B61
+                local.get $l7
+                i32.const -8
+                local.get $l7
+                i32.sub
+                i32.const 15
+                i32.and
+                i32.const 0
+                local.get $l7
+                i32.const 8
+                i32.add
+                i32.const 15
+                i32.and
+                select
+                local.tee $l1
+                i32.add
+                local.tee $l2
+                i32.const 1060592
+                i32.load
+                local.get $l5
+                i32.add
+                local.tee $l4
+                local.get $l1
+                i32.sub
+                local.tee $l1
+                i32.const 1
+                i32.or
+                i32.store offset=4
+                local.get $p0
+                local.get $l3
+                local.get $l5
+                i32.add
+                i32.store offset=4
+                i32.const 1060608
+                i32.const 1061068
+                i32.load
+                i32.store
+                i32.const 1060592
+                local.get $l1
+                i32.store
+                i32.const 1060604
+                local.get $l2
+                i32.store
+                local.get $l4
+                local.get $l7
+                i32.add
+                i32.const 56
+                i32.store offset=4
+                br $B60
+              end
+              local.get $l1
+              i32.const 1060596
+              i32.load
+              local.tee $l3
+              i32.lt_u
+              if $I67
+                i32.const 1060596
+                local.get $l1
+                i32.store
+                local.get $l1
+                local.set $l3
+              end
+              local.get $l1
+              local.get $l5
+              i32.add
+              local.set $l2
+              i32.const 1061028
+              local.set $p0
+              block $B68
+                block $B69
+                  block $B70
+                    block $B71
+                      block $B72
+                        block $B73
+                          loop $L74
+                            local.get $l2
+                            local.get $p0
+                            i32.load
+                            i32.ne
+                            if $I75
+                              local.get $p0
+                              i32.load offset=8
+                              local.tee $p0
+                              br_if $L74
+                              br $B73
+                            end
+                          end
+                          local.get $p0
+                          i32.load8_u offset=12
+                          i32.const 8
+                          i32.and
+                          i32.eqz
+                          br_if $B72
+                        end
+                        i32.const 1061028
+                        local.set $p0
+                        loop $L76
+                          local.get $p0
+                          i32.load
+                          local.tee $l2
+                          local.get $l7
+                          i32.le_u
+                          if $I77
+                            local.get $l2
+                            local.get $p0
+                            i32.load offset=4
+                            i32.add
+                            local.tee $l3
+                            local.get $l7
+                            i32.gt_u
+                            br_if $B71
+                          end
+                          local.get $p0
+                          i32.load offset=8
+                          local.set $p0
+                          br $L76
+                        end
+                        unreachable
+                      end
+                      local.get $p0
+                      local.get $l1
+                      i32.store
+                      local.get $p0
+                      local.get $p0
+                      i32.load offset=4
+                      local.get $l5
+                      i32.add
+                      i32.store offset=4
+                      local.get $l1
+                      i32.const -8
+                      local.get $l1
+                      i32.sub
+                      i32.const 15
+                      i32.and
+                      i32.const 0
+                      local.get $l1
+                      i32.const 8
+                      i32.add
+                      i32.const 15
+                      i32.and
+                      select
+                      i32.add
+                      local.tee $l8
+                      local.get $l6
+                      i32.const 3
+                      i32.or
+                      i32.store offset=4
+                      local.get $l2
+                      i32.const -8
+                      local.get $l2
+                      i32.sub
+                      i32.const 15
+                      i32.and
+                      i32.const 0
+                      local.get $l2
+                      i32.const 8
+                      i32.add
+                      i32.const 15
+                      i32.and
+                      select
+                      i32.add
+                      local.tee $l1
+                      local.get $l8
+                      i32.sub
+                      local.get $l6
+                      i32.sub
+                      local.set $p0
+                      local.get $l6
+                      local.get $l8
+                      i32.add
+                      local.set $l4
+                      local.get $l1
+                      local.get $l7
+                      i32.eq
+                      if $I78
+                        i32.const 1060604
+                        local.get $l4
+                        i32.store
+                        i32.const 1060592
+                        i32.const 1060592
+                        i32.load
+                        local.get $p0
+                        i32.add
+                        local.tee $p0
+                        i32.store
+                        local.get $l4
+                        local.get $p0
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        br $B69
+                      end
+                      local.get $l1
+                      i32.const 1060600
+                      i32.load
+                      i32.eq
+                      if $I79
+                        i32.const 1060600
+                        local.get $l4
+                        i32.store
+                        i32.const 1060588
+                        i32.const 1060588
+                        i32.load
+                        local.get $p0
+                        i32.add
+                        local.tee $p0
+                        i32.store
+                        local.get $l4
+                        local.get $p0
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        local.get $p0
+                        local.get $l4
+                        i32.add
+                        local.get $p0
+                        i32.store
+                        br $B69
+                      end
+                      local.get $l1
+                      i32.load offset=4
+                      local.tee $l6
+                      i32.const 3
+                      i32.and
+                      i32.const 1
+                      i32.eq
+                      if $I80
+                        local.get $l6
+                        i32.const -8
+                        i32.and
+                        local.set $l9
+                        block $B81
+                          local.get $l6
+                          i32.const 255
+                          i32.le_u
+                          if $I82
+                            local.get $l1
+                            i32.load offset=8
+                            local.tee $l3
+                            local.get $l6
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $l6
+                            i32.const 3
+                            i32.shl
+                            i32.const 1060620
+                            i32.add
+                            i32.ne
+                            drop
+                            local.get $l3
+                            local.get $l1
+                            i32.load offset=12
+                            local.tee $l2
+                            i32.eq
+                            if $I83
+                              i32.const 1060580
+                              i32.const 1060580
+                              i32.load
+                              i32.const -2
+                              local.get $l6
+                              i32.rotl
+                              i32.and
+                              i32.store
+                              br $B81
+                            end
+                            local.get $l2
+                            local.get $l3
+                            i32.store offset=8
+                            local.get $l3
+                            local.get $l2
+                            i32.store offset=12
+                            br $B81
+                          end
+                          local.get $l1
+                          i32.load offset=24
+                          local.set $l7
+                          block $B84
+                            local.get $l1
+                            local.get $l1
+                            i32.load offset=12
+                            local.tee $l5
+                            i32.ne
+                            if $I85
+                              local.get $l3
+                              local.get $l1
+                              i32.load offset=8
+                              local.tee $l2
+                              i32.le_u
+                              if $I86
+                                local.get $l2
+                                i32.load offset=12
+                                drop
+                              end
+                              local.get $l5
+                              local.get $l2
+                              i32.store offset=8
+                              local.get $l2
+                              local.get $l5
+                              i32.store offset=12
+                              br $B84
+                            end
+                            block $B87
+                              local.get $l1
+                              i32.const 20
+                              i32.add
+                              local.tee $l2
+                              i32.load
+                              local.tee $l6
+                              br_if $B87
+                              local.get $l1
+                              i32.const 16
+                              i32.add
+                              local.tee $l2
+                              i32.load
+                              local.tee $l6
+                              br_if $B87
+                              i32.const 0
+                              local.set $l5
+                              br $B84
+                            end
+                            loop $L88
+                              local.get $l2
+                              local.set $l3
+                              local.get $l6
+                              local.tee $l5
+                              i32.const 20
+                              i32.add
+                              local.tee $l2
+                              i32.load
+                              local.tee $l6
+                              br_if $L88
+                              local.get $l5
+                              i32.const 16
+                              i32.add
+                              local.set $l2
+                              local.get $l5
+                              i32.load offset=16
+                              local.tee $l6
+                              br_if $L88
+                            end
+                            local.get $l3
+                            i32.const 0
+                            i32.store
+                          end
+                          local.get $l7
+                          i32.eqz
+                          br_if $B81
+                          block $B89
+                            local.get $l1
+                            local.get $l1
+                            i32.load offset=28
+                            local.tee $l2
+                            i32.const 2
+                            i32.shl
+                            i32.const 1060884
+                            i32.add
+                            local.tee $l3
+                            i32.load
+                            i32.eq
+                            if $I90
+                              local.get $l3
+                              local.get $l5
+                              i32.store
+                              local.get $l5
+                              br_if $B89
+                              i32.const 1060584
+                              i32.const 1060584
+                              i32.load
+                              i32.const -2
+                              local.get $l2
+                              i32.rotl
+                              i32.and
+                              i32.store
+                              br $B81
+                            end
+                            local.get $l7
+                            i32.const 16
+                            i32.const 20
+                            local.get $l7
+                            i32.load offset=16
+                            local.get $l1
+                            i32.eq
+                            select
+                            i32.add
+                            local.get $l5
+                            i32.store
+                            local.get $l5
+                            i32.eqz
+                            br_if $B81
+                          end
+                          local.get $l5
+                          local.get $l7
+                          i32.store offset=24
+                          local.get $l1
+                          i32.load offset=16
+                          local.tee $l2
+                          if $I91
+                            local.get $l5
+                            local.get $l2
+                            i32.store offset=16
+                            local.get $l2
+                            local.get $l5
+                            i32.store offset=24
+                          end
+                          local.get $l1
+                          i32.load offset=20
+                          local.tee $l2
+                          i32.eqz
+                          br_if $B81
+                          local.get $l5
+                          i32.const 20
+                          i32.add
+                          local.get $l2
+                          i32.store
+                          local.get $l2
+                          local.get $l5
+                          i32.store offset=24
+                        end
+                        local.get $l1
+                        local.get $l9
+                        i32.add
+                        local.set $l1
+                        local.get $p0
+                        local.get $l9
+                        i32.add
+                        local.set $p0
+                      end
+                      local.get $l1
+                      local.get $l1
+                      i32.load offset=4
+                      i32.const -2
+                      i32.and
+                      i32.store offset=4
+                      local.get $p0
+                      local.get $l4
+                      i32.add
+                      local.get $p0
+                      i32.store
+                      local.get $l4
+                      local.get $p0
+                      i32.const 1
+                      i32.or
+                      i32.store offset=4
+                      local.get $p0
+                      i32.const 255
+                      i32.le_u
+                      if $I92
+                        local.get $p0
+                        i32.const 3
+                        i32.shr_u
+                        local.tee $l1
+                        i32.const 3
+                        i32.shl
+                        i32.const 1060620
+                        i32.add
+                        local.set $p0
+                        block $B93 (result i32)
+                          i32.const 1060580
+                          i32.load
+                          local.tee $l2
+                          i32.const 1
+                          local.get $l1
+                          i32.shl
+                          local.tee $l1
+                          i32.and
+                          i32.eqz
+                          if $I94
+                            i32.const 1060580
+                            local.get $l1
+                            local.get $l2
+                            i32.or
+                            i32.store
+                            local.get $p0
+                            br $B93
+                          end
+                          local.get $p0
+                          i32.load offset=8
+                        end
+                        local.tee $l2
+                        local.get $l4
+                        i32.store offset=12
+                        local.get $p0
+                        local.get $l4
+                        i32.store offset=8
+                        local.get $l4
+                        local.get $p0
+                        i32.store offset=12
+                        local.get $l4
+                        local.get $l2
+                        i32.store offset=8
+                        br $B69
+                      end
+                      local.get $l4
+                      block $B95 (result i32)
+                        i32.const 0
+                        local.get $p0
+                        i32.const 8
+                        i32.shr_u
+                        local.tee $l1
+                        i32.eqz
+                        br_if $B95
+                        drop
+                        i32.const 31
+                        local.get $p0
+                        i32.const 16777215
+                        i32.gt_u
+                        br_if $B95
+                        drop
+                        local.get $l1
+                        local.get $l1
+                        i32.const 1048320
+                        i32.add
+                        i32.const 16
+                        i32.shr_u
+                        i32.const 8
+                        i32.and
+                        local.tee $l1
+                        i32.shl
+                        local.tee $l2
+                        local.get $l2
+                        i32.const 520192
+                        i32.add
+                        i32.const 16
+                        i32.shr_u
+                        i32.const 4
+                        i32.and
+                        local.tee $l2
+                        i32.shl
+                        local.tee $l3
+                        local.get $l3
+                        i32.const 245760
+                        i32.add
+                        i32.const 16
+                        i32.shr_u
+                        i32.const 2
+                        i32.and
+                        local.tee $l3
+                        i32.shl
+                        i32.const 15
+                        i32.shr_u
+                        local.get $l1
+                        local.get $l2
+                        i32.or
+                        local.get $l3
+                        i32.or
+                        i32.sub
+                        local.tee $l1
+                        i32.const 1
+                        i32.shl
+                        local.get $p0
+                        local.get $l1
+                        i32.const 21
+                        i32.add
+                        i32.shr_u
+                        i32.const 1
+                        i32.and
+                        i32.or
+                        i32.const 28
+                        i32.add
+                      end
+                      local.tee $l2
+                      i32.store offset=28
+                      local.get $l4
+                      i64.const 0
+                      i64.store offset=16 align=4
+                      local.get $l2
+                      i32.const 2
+                      i32.shl
+                      i32.const 1060884
+                      i32.add
+                      local.set $l1
+                      i32.const 1060584
+                      i32.load
+                      local.tee $l3
+                      i32.const 1
+                      local.get $l2
+                      i32.shl
+                      local.tee $l6
+                      i32.and
+                      i32.eqz
+                      if $I96
+                        local.get $l1
+                        local.get $l4
+                        i32.store
+                        i32.const 1060584
+                        local.get $l3
+                        local.get $l6
+                        i32.or
+                        i32.store
+                        local.get $l4
+                        local.get $l1
+                        i32.store offset=24
+                        local.get $l4
+                        local.get $l4
+                        i32.store offset=8
+                        local.get $l4
+                        local.get $l4
+                        i32.store offset=12
+                        br $B69
+                      end
+                      local.get $p0
+                      i32.const 0
+                      i32.const 25
+                      local.get $l2
+                      i32.const 1
+                      i32.shr_u
+                      i32.sub
+                      local.get $l2
+                      i32.const 31
+                      i32.eq
+                      select
+                      i32.shl
+                      local.set $l2
+                      local.get $l1
+                      i32.load
+                      local.set $l1
+                      loop $L97
+                        local.get $l1
+                        local.tee $l3
+                        i32.load offset=4
+                        i32.const -8
+                        i32.and
+                        local.get $p0
+                        i32.eq
+                        br_if $B70
+                        local.get $l2
+                        i32.const 29
+                        i32.shr_u
+                        local.set $l1
+                        local.get $l2
+                        i32.const 1
+                        i32.shl
+                        local.set $l2
+                        local.get $l3
+                        local.get $l1
+                        i32.const 4
+                        i32.and
+                        i32.add
+                        i32.const 16
+                        i32.add
+                        local.tee $l6
+                        i32.load
+                        local.tee $l1
+                        br_if $L97
+                      end
+                      local.get $l6
+                      local.get $l4
+                      i32.store
+                      local.get $l4
+                      local.get $l3
+                      i32.store offset=24
+                      local.get $l4
+                      local.get $l4
+                      i32.store offset=12
+                      local.get $l4
+                      local.get $l4
+                      i32.store offset=8
+                      br $B69
+                    end
+                    local.get $l1
+                    i32.const -8
+                    local.get $l1
+                    i32.sub
+                    i32.const 15
+                    i32.and
+                    i32.const 0
+                    local.get $l1
+                    i32.const 8
+                    i32.add
+                    i32.const 15
+                    i32.and
+                    select
+                    local.tee $p0
+                    i32.add
+                    local.tee $l4
+                    local.get $l5
+                    i32.const -56
+                    i32.add
+                    local.tee $l2
+                    local.get $p0
+                    i32.sub
+                    local.tee $p0
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $l1
+                    local.get $l2
+                    i32.add
+                    i32.const 56
+                    i32.store offset=4
+                    local.get $l7
+                    local.get $l3
+                    i32.const 55
+                    local.get $l3
+                    i32.sub
+                    i32.const 15
+                    i32.and
+                    i32.const 0
+                    local.get $l3
+                    i32.const -55
+                    i32.add
+                    i32.const 15
+                    i32.and
+                    select
+                    i32.add
+                    i32.const -63
+                    i32.add
+                    local.tee $l2
+                    local.get $l2
+                    local.get $l7
+                    i32.const 16
+                    i32.add
+                    i32.lt_u
+                    select
+                    local.tee $l2
+                    i32.const 35
+                    i32.store offset=4
+                    i32.const 1060608
+                    i32.const 1061068
+                    i32.load
+                    i32.store
+                    i32.const 1060592
+                    local.get $p0
+                    i32.store
+                    i32.const 1060604
+                    local.get $l4
+                    i32.store
+                    local.get $l2
+                    i32.const 16
+                    i32.add
+                    i32.const 1061036
+                    i64.load align=4
+                    i64.store align=4
+                    local.get $l2
+                    i32.const 1061028
+                    i64.load align=4
+                    i64.store offset=8 align=4
+                    i32.const 1061036
+                    local.get $l2
+                    i32.const 8
+                    i32.add
+                    i32.store
+                    i32.const 1061032
+                    local.get $l5
+                    i32.store
+                    i32.const 1061028
+                    local.get $l1
+                    i32.store
+                    i32.const 1061040
+                    i32.const 0
+                    i32.store
+                    local.get $l2
+                    i32.const 36
+                    i32.add
+                    local.set $p0
+                    loop $L98
+                      local.get $p0
+                      i32.const 7
+                      i32.store
+                      local.get $p0
+                      i32.const 4
+                      i32.add
+                      local.tee $p0
+                      local.get $l3
+                      i32.lt_u
+                      br_if $L98
+                    end
+                    local.get $l2
+                    local.get $l7
+                    i32.eq
+                    br_if $B60
+                    local.get $l2
+                    local.get $l2
+                    i32.load offset=4
+                    i32.const -2
+                    i32.and
+                    i32.store offset=4
+                    local.get $l2
+                    local.get $l2
+                    local.get $l7
+                    i32.sub
+                    local.tee $l3
+                    i32.store
+                    local.get $l7
+                    local.get $l3
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $l3
+                    i32.const 255
+                    i32.le_u
+                    if $I99
+                      local.get $l3
+                      i32.const 3
+                      i32.shr_u
+                      local.tee $l1
+                      i32.const 3
+                      i32.shl
+                      i32.const 1060620
+                      i32.add
+                      local.set $p0
+                      block $B100 (result i32)
+                        i32.const 1060580
+                        i32.load
+                        local.tee $l2
+                        i32.const 1
+                        local.get $l1
+                        i32.shl
+                        local.tee $l1
+                        i32.and
+                        i32.eqz
+                        if $I101
+                          i32.const 1060580
+                          local.get $l1
+                          local.get $l2
+                          i32.or
+                          i32.store
+                          local.get $p0
+                          br $B100
+                        end
+                        local.get $p0
+                        i32.load offset=8
+                      end
+                      local.tee $l4
+                      local.get $l7
+                      i32.store offset=12
+                      local.get $p0
+                      local.get $l7
+                      i32.store offset=8
+                      local.get $l7
+                      local.get $p0
+                      i32.store offset=12
+                      local.get $l7
+                      local.get $l4
+                      i32.store offset=8
+                      br $B60
+                    end
+                    local.get $l7
+                    i64.const 0
+                    i64.store offset=16 align=4
+                    local.get $l7
+                    i32.const 28
+                    i32.add
+                    block $B102 (result i32)
+                      i32.const 0
+                      local.get $l3
+                      i32.const 8
+                      i32.shr_u
+                      local.tee $l1
+                      i32.eqz
+                      br_if $B102
+                      drop
+                      i32.const 31
+                      local.get $l3
+                      i32.const 16777215
+                      i32.gt_u
+                      br_if $B102
+                      drop
+                      local.get $l1
+                      local.get $l1
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $p0
+                      i32.shl
+                      local.tee $l1
+                      local.get $l1
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $l1
+                      i32.shl
+                      local.tee $l2
+                      local.get $l2
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $l2
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      local.get $p0
+                      local.get $l1
+                      i32.or
+                      local.get $l2
+                      i32.or
+                      i32.sub
+                      local.tee $p0
+                      i32.const 1
+                      i32.shl
+                      local.get $l3
+                      local.get $p0
+                      i32.const 21
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      i32.or
+                      i32.const 28
+                      i32.add
+                    end
+                    local.tee $p0
+                    i32.store
+                    local.get $p0
+                    i32.const 2
+                    i32.shl
+                    i32.const 1060884
+                    i32.add
+                    local.set $l1
+                    i32.const 1060584
+                    i32.load
+                    local.tee $l2
+                    i32.const 1
+                    local.get $p0
+                    i32.shl
+                    local.tee $l4
+                    i32.and
+                    i32.eqz
+                    if $I103
+                      local.get $l1
+                      local.get $l7
+                      i32.store
+                      i32.const 1060584
+                      local.get $l2
+                      local.get $l4
+                      i32.or
+                      i32.store
+                      local.get $l7
+                      i32.const 24
+                      i32.add
+                      local.get $l1
+                      i32.store
+                      local.get $l7
+                      local.get $l7
+                      i32.store offset=8
+                      local.get $l7
+                      local.get $l7
+                      i32.store offset=12
+                      br $B60
+                    end
+                    local.get $l3
+                    i32.const 0
+                    i32.const 25
+                    local.get $p0
+                    i32.const 1
+                    i32.shr_u
+                    i32.sub
+                    local.get $p0
+                    i32.const 31
+                    i32.eq
+                    select
+                    i32.shl
+                    local.set $p0
+                    local.get $l1
+                    i32.load
+                    local.set $l1
+                    loop $L104
+                      local.get $l1
+                      local.tee $l2
+                      i32.load offset=4
+                      i32.const -8
+                      i32.and
+                      local.get $l3
+                      i32.eq
+                      br_if $B68
+                      local.get $p0
+                      i32.const 29
+                      i32.shr_u
+                      local.set $l1
+                      local.get $p0
+                      i32.const 1
+                      i32.shl
+                      local.set $p0
+                      local.get $l2
+                      local.get $l1
+                      i32.const 4
+                      i32.and
+                      i32.add
+                      i32.const 16
+                      i32.add
+                      local.tee $l4
+                      i32.load
+                      local.tee $l1
+                      br_if $L104
+                    end
+                    local.get $l4
+                    local.get $l7
+                    i32.store
+                    local.get $l7
+                    i32.const 24
+                    i32.add
+                    local.get $l2
+                    i32.store
+                    local.get $l7
+                    local.get $l7
+                    i32.store offset=12
+                    local.get $l7
+                    local.get $l7
+                    i32.store offset=8
+                    br $B60
+                  end
+                  local.get $l3
+                  i32.load offset=8
+                  local.set $p0
+                  local.get $l3
+                  local.get $l4
+                  i32.store offset=8
+                  local.get $p0
+                  local.get $l4
+                  i32.store offset=12
+                  local.get $l4
+                  i32.const 0
+                  i32.store offset=24
+                  local.get $l4
+                  local.get $p0
+                  i32.store offset=8
+                  local.get $l4
+                  local.get $l3
+                  i32.store offset=12
+                end
+                local.get $l8
+                i32.const 8
+                i32.add
+                local.set $p0
+                br $B0
+              end
+              local.get $l2
+              i32.load offset=8
+              local.set $p0
+              local.get $l2
+              local.get $l7
+              i32.store offset=8
+              local.get $p0
+              local.get $l7
+              i32.store offset=12
+              local.get $l7
+              i32.const 24
+              i32.add
+              i32.const 0
+              i32.store
+              local.get $l7
+              local.get $p0
+              i32.store offset=8
+              local.get $l7
+              local.get $l2
+              i32.store offset=12
+            end
+            i32.const 1060592
+            i32.load
+            local.tee $l1
+            local.get $l6
+            i32.le_u
+            br_if $B3
+            i32.const 1060604
+            i32.load
+            local.tee $p0
+            local.get $l6
+            i32.add
+            local.tee $l2
+            local.get $l1
+            local.get $l6
+            i32.sub
+            local.tee $l1
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            i32.const 1060592
+            local.get $l1
+            i32.store
+            i32.const 1060604
+            local.get $l2
+            i32.store
+            local.get $p0
+            local.get $l6
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $p0
+            i32.const 8
+            i32.add
+            local.set $p0
+            br $B0
+          end
+          i32.const 0
+          local.set $p0
+          i32.const 1061076
+          i32.const 48
+          i32.store
+          br $B0
+        end
+        block $B105
+          local.get $l7
+          i32.eqz
+          br_if $B105
+          block $B106
+            local.get $l3
+            i32.load offset=28
+            local.tee $p0
+            i32.const 2
+            i32.shl
+            i32.const 1060884
+            i32.add
+            local.tee $l2
+            i32.load
+            local.get $l3
+            i32.eq
+            if $I107
+              local.get $l2
+              local.get $l1
+              i32.store
+              local.get $l1
+              br_if $B106
+              i32.const 1060584
+              local.get $l8
+              i32.const -2
+              local.get $p0
+              i32.rotl
+              i32.and
+              local.tee $l8
+              i32.store
+              br $B105
+            end
+            local.get $l7
+            i32.const 16
+            i32.const 20
+            local.get $l7
+            i32.load offset=16
+            local.get $l3
+            i32.eq
+            select
+            i32.add
+            local.get $l1
+            i32.store
+            local.get $l1
+            i32.eqz
+            br_if $B105
+          end
+          local.get $l1
+          local.get $l7
+          i32.store offset=24
+          local.get $l3
+          i32.load offset=16
+          local.tee $p0
+          if $I108
+            local.get $l1
+            local.get $p0
+            i32.store offset=16
+            local.get $p0
+            local.get $l1
+            i32.store offset=24
+          end
+          local.get $l3
+          i32.const 20
+          i32.add
+          i32.load
+          local.tee $p0
+          i32.eqz
+          br_if $B105
+          local.get $l1
+          i32.const 20
+          i32.add
+          local.get $p0
+          i32.store
+          local.get $p0
+          local.get $l1
+          i32.store offset=24
+        end
+        block $B109
+          local.get $l4
+          i32.const 15
+          i32.le_u
+          if $I110
+            local.get $l3
+            local.get $l4
+            local.get $l6
+            i32.add
+            local.tee $p0
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $p0
+            local.get $l3
+            i32.add
+            local.tee $p0
+            local.get $p0
+            i32.load offset=4
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            br $B109
+          end
+          local.get $l3
+          local.get $l6
+          i32.add
+          local.tee $l5
+          local.get $l4
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $l3
+          local.get $l6
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $l4
+          local.get $l5
+          i32.add
+          local.get $l4
+          i32.store
+          local.get $l4
+          i32.const 255
+          i32.le_u
+          if $I111
+            local.get $l4
+            i32.const 3
+            i32.shr_u
+            local.tee $l1
+            i32.const 3
+            i32.shl
+            i32.const 1060620
+            i32.add
+            local.set $p0
+            block $B112 (result i32)
+              i32.const 1060580
+              i32.load
+              local.tee $l2
+              i32.const 1
+              local.get $l1
+              i32.shl
+              local.tee $l1
+              i32.and
+              i32.eqz
+              if $I113
+                i32.const 1060580
+                local.get $l1
+                local.get $l2
+                i32.or
+                i32.store
+                local.get $p0
+                br $B112
+              end
+              local.get $p0
+              i32.load offset=8
+            end
+            local.tee $l2
+            local.get $l5
+            i32.store offset=12
+            local.get $p0
+            local.get $l5
+            i32.store offset=8
+            local.get $l5
+            local.get $p0
+            i32.store offset=12
+            local.get $l5
+            local.get $l2
+            i32.store offset=8
+            br $B109
+          end
+          local.get $l5
+          block $B114 (result i32)
+            i32.const 0
+            local.get $l4
+            i32.const 8
+            i32.shr_u
+            local.tee $l1
+            i32.eqz
+            br_if $B114
+            drop
+            i32.const 31
+            local.get $l4
+            i32.const 16777215
+            i32.gt_u
+            br_if $B114
+            drop
+            local.get $l1
+            local.get $l1
+            i32.const 1048320
+            i32.add
+            i32.const 16
+            i32.shr_u
+            i32.const 8
+            i32.and
+            local.tee $p0
+            i32.shl
+            local.tee $l1
+            local.get $l1
+            i32.const 520192
+            i32.add
+            i32.const 16
+            i32.shr_u
+            i32.const 4
+            i32.and
+            local.tee $l1
+            i32.shl
+            local.tee $l2
+            local.get $l2
+            i32.const 245760
+            i32.add
+            i32.const 16
+            i32.shr_u
+            i32.const 2
+            i32.and
+            local.tee $l2
+            i32.shl
+            i32.const 15
+            i32.shr_u
+            local.get $p0
+            local.get $l1
+            i32.or
+            local.get $l2
+            i32.or
+            i32.sub
+            local.tee $p0
+            i32.const 1
+            i32.shl
+            local.get $l4
+            local.get $p0
+            i32.const 21
+            i32.add
+            i32.shr_u
+            i32.const 1
+            i32.and
+            i32.or
+            i32.const 28
+            i32.add
+          end
+          local.tee $p0
+          i32.store offset=28
+          local.get $l5
+          i64.const 0
+          i64.store offset=16 align=4
+          local.get $p0
+          i32.const 2
+          i32.shl
+          i32.const 1060884
+          i32.add
+          local.set $l1
+          local.get $l8
+          i32.const 1
+          local.get $p0
+          i32.shl
+          local.tee $l2
+          i32.and
+          i32.eqz
+          if $I115
+            local.get $l1
+            local.get $l5
+            i32.store
+            i32.const 1060584
+            local.get $l2
+            local.get $l8
+            i32.or
+            i32.store
+            local.get $l5
+            local.get $l1
+            i32.store offset=24
+            local.get $l5
+            local.get $l5
+            i32.store offset=8
+            local.get $l5
+            local.get $l5
+            i32.store offset=12
+            br $B109
+          end
+          local.get $l4
+          i32.const 0
+          i32.const 25
+          local.get $p0
+          i32.const 1
+          i32.shr_u
+          i32.sub
+          local.get $p0
+          i32.const 31
+          i32.eq
+          select
+          i32.shl
+          local.set $p0
+          local.get $l1
+          i32.load
+          local.set $l6
+          block $B116
+            loop $L117
+              local.get $l6
+              local.tee $l1
+              i32.load offset=4
+              i32.const -8
+              i32.and
+              local.get $l4
+              i32.eq
+              br_if $B116
+              local.get $p0
+              i32.const 29
+              i32.shr_u
+              local.set $l2
+              local.get $p0
+              i32.const 1
+              i32.shl
+              local.set $p0
+              local.get $l1
+              local.get $l2
+              i32.const 4
+              i32.and
+              i32.add
+              i32.const 16
+              i32.add
+              local.tee $l2
+              i32.load
+              local.tee $l6
+              br_if $L117
+            end
+            local.get $l2
+            local.get $l5
+            i32.store
+            local.get $l5
+            local.get $l1
+            i32.store offset=24
+            local.get $l5
+            local.get $l5
+            i32.store offset=12
+            local.get $l5
+            local.get $l5
+            i32.store offset=8
+            br $B109
+          end
+          local.get $l1
+          i32.load offset=8
+          local.set $p0
+          local.get $l1
+          local.get $l5
+          i32.store offset=8
+          local.get $p0
+          local.get $l5
+          i32.store offset=12
+          local.get $l5
+          i32.const 0
+          i32.store offset=24
+          local.get $l5
+          local.get $p0
+          i32.store offset=8
+          local.get $l5
+          local.get $l1
+          i32.store offset=12
+        end
+        local.get $l3
+        i32.const 8
+        i32.add
+        local.set $p0
+        br $B0
+      end
+      block $B118
+        local.get $l9
+        i32.eqz
+        br_if $B118
+        block $B119
+          local.get $l1
+          i32.load offset=28
+          local.tee $p0
+          i32.const 2
+          i32.shl
+          i32.const 1060884
+          i32.add
+          local.tee $l4
+          i32.load
+          local.get $l1
+          i32.eq
+          if $I120
+            local.get $l4
+            local.get $l3
+            i32.store
+            local.get $l3
+            br_if $B119
+            i32.const 1060584
+            local.get $l10
+            i32.const -2
+            local.get $p0
+            i32.rotl
+            i32.and
+            i32.store
+            br $B118
+          end
+          local.get $l9
+          i32.const 16
+          i32.const 20
+          local.get $l9
+          i32.load offset=16
+          local.get $l1
+          i32.eq
+          select
+          i32.add
+          local.get $l3
+          i32.store
+          local.get $l3
+          i32.eqz
+          br_if $B118
+        end
+        local.get $l3
+        local.get $l9
+        i32.store offset=24
+        local.get $l1
+        i32.load offset=16
+        local.tee $p0
+        if $I121
+          local.get $l3
+          local.get $p0
+          i32.store offset=16
+          local.get $p0
+          local.get $l3
+          i32.store offset=24
+        end
+        local.get $l1
+        i32.const 20
+        i32.add
+        i32.load
+        local.tee $p0
+        i32.eqz
+        br_if $B118
+        local.get $l3
+        i32.const 20
+        i32.add
+        local.get $p0
+        i32.store
+        local.get $p0
+        local.get $l3
+        i32.store offset=24
+      end
+      block $B122
+        local.get $l2
+        i32.const 15
+        i32.le_u
+        if $I123
+          local.get $l1
+          local.get $l2
+          local.get $l6
+          i32.add
+          local.tee $p0
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $p0
+          local.get $l1
+          i32.add
+          local.tee $p0
+          local.get $p0
+          i32.load offset=4
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          br $B122
+        end
+        local.get $l1
+        local.get $l6
+        i32.add
+        local.tee $l7
+        local.get $l2
+        i32.const 1
+        i32.or
+        i32.store offset=4
+        local.get $l1
+        local.get $l6
+        i32.const 3
+        i32.or
+        i32.store offset=4
+        local.get $l2
+        local.get $l7
+        i32.add
+        local.get $l2
+        i32.store
+        local.get $l8
+        if $I124
+          local.get $l8
+          i32.const 3
+          i32.shr_u
+          local.tee $l3
+          i32.const 3
+          i32.shl
+          i32.const 1060620
+          i32.add
+          local.set $p0
+          i32.const 1060600
+          i32.load
+          local.set $l4
+          block $B125 (result i32)
+            i32.const 1
+            local.get $l3
+            i32.shl
+            local.tee $l3
+            local.get $l5
+            i32.and
+            i32.eqz
+            if $I126
+              i32.const 1060580
+              local.get $l3
+              local.get $l5
+              i32.or
+              i32.store
+              local.get $p0
+              br $B125
+            end
+            local.get $p0
+            i32.load offset=8
+          end
+          local.tee $l3
+          local.get $l4
+          i32.store offset=12
+          local.get $p0
+          local.get $l4
+          i32.store offset=8
+          local.get $l4
+          local.get $p0
+          i32.store offset=12
+          local.get $l4
+          local.get $l3
+          i32.store offset=8
+        end
+        i32.const 1060600
+        local.get $l7
+        i32.store
+        i32.const 1060588
+        local.get $l2
+        i32.store
+      end
+      local.get $l1
+      i32.const 8
+      i32.add
+      local.set $p0
+    end
+    local.get $l11
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p0)
+  (func $f145 (type $t2) (param $p0 i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32)
+    block $B0
+      local.get $p0
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.const -8
+      i32.add
+      local.tee $l3
+      local.get $p0
+      i32.const -4
+      i32.add
+      i32.load
+      local.tee $l1
+      i32.const -8
+      i32.and
+      local.tee $p0
+      i32.add
+      local.set $l5
+      block $B1
+        local.get $l1
+        i32.const 1
+        i32.and
+        br_if $B1
+        local.get $l1
+        i32.const 3
+        i32.and
+        i32.eqz
+        br_if $B0
+        local.get $l3
+        local.get $l3
+        i32.load
+        local.tee $l2
+        i32.sub
+        local.tee $l3
+        i32.const 1060596
+        i32.load
+        local.tee $l4
+        i32.lt_u
+        br_if $B0
+        local.get $p0
+        local.get $l2
+        i32.add
+        local.set $p0
+        local.get $l3
+        i32.const 1060600
+        i32.load
+        i32.ne
+        if $I2
+          local.get $l2
+          i32.const 255
+          i32.le_u
+          if $I3
+            local.get $l3
+            i32.load offset=8
+            local.tee $l4
+            local.get $l2
+            i32.const 3
+            i32.shr_u
+            local.tee $l2
+            i32.const 3
+            i32.shl
+            i32.const 1060620
+            i32.add
+            i32.ne
+            drop
+            local.get $l4
+            local.get $l3
+            i32.load offset=12
+            local.tee $l1
+            i32.eq
+            if $I4
+              i32.const 1060580
+              i32.const 1060580
+              i32.load
+              i32.const -2
+              local.get $l2
+              i32.rotl
+              i32.and
+              i32.store
+              br $B1
+            end
+            local.get $l1
+            local.get $l4
+            i32.store offset=8
+            local.get $l4
+            local.get $l1
+            i32.store offset=12
+            br $B1
+          end
+          local.get $l3
+          i32.load offset=24
+          local.set $l6
+          block $B5
+            local.get $l3
+            local.get $l3
+            i32.load offset=12
+            local.tee $l1
+            i32.ne
+            if $I6
+              local.get $l4
+              local.get $l3
+              i32.load offset=8
+              local.tee $l2
+              i32.le_u
+              if $I7
+                local.get $l2
+                i32.load offset=12
+                drop
+              end
+              local.get $l1
+              local.get $l2
+              i32.store offset=8
+              local.get $l2
+              local.get $l1
+              i32.store offset=12
+              br $B5
+            end
+            block $B8
+              local.get $l3
+              i32.const 20
+              i32.add
+              local.tee $l2
+              i32.load
+              local.tee $l4
+              br_if $B8
+              local.get $l3
+              i32.const 16
+              i32.add
+              local.tee $l2
+              i32.load
+              local.tee $l4
+              br_if $B8
+              i32.const 0
+              local.set $l1
+              br $B5
+            end
+            loop $L9
+              local.get $l2
+              local.set $l7
+              local.get $l4
+              local.tee $l1
+              i32.const 20
+              i32.add
+              local.tee $l2
+              i32.load
+              local.tee $l4
+              br_if $L9
+              local.get $l1
+              i32.const 16
+              i32.add
+              local.set $l2
+              local.get $l1
+              i32.load offset=16
+              local.tee $l4
+              br_if $L9
+            end
+            local.get $l7
+            i32.const 0
+            i32.store
+          end
+          local.get $l6
+          i32.eqz
+          br_if $B1
+          block $B10
+            local.get $l3
+            local.get $l3
+            i32.load offset=28
+            local.tee $l2
+            i32.const 2
+            i32.shl
+            i32.const 1060884
+            i32.add
+            local.tee $l4
+            i32.load
+            i32.eq
+            if $I11
+              local.get $l4
+              local.get $l1
+              i32.store
+              local.get $l1
+              br_if $B10
+              i32.const 1060584
+              i32.const 1060584
+              i32.load
+              i32.const -2
+              local.get $l2
+              i32.rotl
+              i32.and
+              i32.store
+              br $B1
+            end
+            local.get $l6
+            i32.const 16
+            i32.const 20
+            local.get $l6
+            i32.load offset=16
+            local.get $l3
+            i32.eq
+            select
+            i32.add
+            local.get $l1
+            i32.store
+            local.get $l1
+            i32.eqz
+            br_if $B1
+          end
+          local.get $l1
+          local.get $l6
+          i32.store offset=24
+          local.get $l3
+          i32.load offset=16
+          local.tee $l2
+          if $I12
+            local.get $l1
+            local.get $l2
+            i32.store offset=16
+            local.get $l2
+            local.get $l1
+            i32.store offset=24
+          end
+          local.get $l3
+          i32.load offset=20
+          local.tee $l2
+          i32.eqz
+          br_if $B1
+          local.get $l1
+          i32.const 20
+          i32.add
+          local.get $l2
+          i32.store
+          local.get $l2
+          local.get $l1
+          i32.store offset=24
+          br $B1
+        end
+        local.get $l5
+        i32.load offset=4
+        local.tee $l1
+        i32.const 3
+        i32.and
+        i32.const 3
+        i32.ne
+        br_if $B1
+        local.get $l5
+        local.get $l1
+        i32.const -2
+        i32.and
+        i32.store offset=4
+        i32.const 1060588
+        local.get $p0
+        i32.store
+        local.get $p0
+        local.get $l3
+        i32.add
+        local.get $p0
+        i32.store
+        local.get $l3
+        local.get $p0
+        i32.const 1
+        i32.or
+        i32.store offset=4
+        return
+      end
+      local.get $l5
+      local.get $l3
+      i32.le_u
+      br_if $B0
+      local.get $l5
+      i32.load offset=4
+      local.tee $l1
+      i32.const 1
+      i32.and
+      i32.eqz
+      br_if $B0
+      block $B13
+        local.get $l1
+        i32.const 2
+        i32.and
+        i32.eqz
+        if $I14
+          local.get $l5
+          i32.const 1060604
+          i32.load
+          i32.eq
+          if $I15
+            i32.const 1060604
+            local.get $l3
+            i32.store
+            i32.const 1060592
+            i32.const 1060592
+            i32.load
+            local.get $p0
+            i32.add
+            local.tee $p0
+            i32.store
+            local.get $l3
+            local.get $p0
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $l3
+            i32.const 1060600
+            i32.load
+            i32.ne
+            br_if $B0
+            i32.const 1060588
+            i32.const 0
+            i32.store
+            i32.const 1060600
+            i32.const 0
+            i32.store
+            return
+          end
+          local.get $l5
+          i32.const 1060600
+          i32.load
+          i32.eq
+          if $I16
+            i32.const 1060600
+            local.get $l3
+            i32.store
+            i32.const 1060588
+            i32.const 1060588
+            i32.load
+            local.get $p0
+            i32.add
+            local.tee $p0
+            i32.store
+            local.get $l3
+            local.get $p0
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $p0
+            local.get $l3
+            i32.add
+            local.get $p0
+            i32.store
+            return
+          end
+          local.get $l1
+          i32.const -8
+          i32.and
+          local.get $p0
+          i32.add
+          local.set $p0
+          block $B17
+            local.get $l1
+            i32.const 255
+            i32.le_u
+            if $I18
+              local.get $l5
+              i32.load offset=12
+              local.set $l2
+              local.get $l5
+              i32.load offset=8
+              local.tee $l4
+              local.get $l1
+              i32.const 3
+              i32.shr_u
+              local.tee $l1
+              i32.const 3
+              i32.shl
+              i32.const 1060620
+              i32.add
+              local.tee $l7
+              i32.ne
+              if $I19
+                i32.const 1060596
+                i32.load
+                drop
+              end
+              local.get $l2
+              local.get $l4
+              i32.eq
+              if $I20
+                i32.const 1060580
+                i32.const 1060580
+                i32.load
+                i32.const -2
+                local.get $l1
+                i32.rotl
+                i32.and
+                i32.store
+                br $B17
+              end
+              local.get $l2
+              local.get $l7
+              i32.ne
+              if $I21
+                i32.const 1060596
+                i32.load
+                drop
+              end
+              local.get $l2
+              local.get $l4
+              i32.store offset=8
+              local.get $l4
+              local.get $l2
+              i32.store offset=12
+              br $B17
+            end
+            local.get $l5
+            i32.load offset=24
+            local.set $l6
+            block $B22
+              local.get $l5
+              local.get $l5
+              i32.load offset=12
+              local.tee $l1
+              i32.ne
+              if $I23
+                i32.const 1060596
+                i32.load
+                local.get $l5
+                i32.load offset=8
+                local.tee $l2
+                i32.le_u
+                if $I24
+                  local.get $l2
+                  i32.load offset=12
+                  drop
+                end
+                local.get $l1
+                local.get $l2
+                i32.store offset=8
+                local.get $l2
+                local.get $l1
+                i32.store offset=12
+                br $B22
+              end
+              block $B25
+                local.get $l5
+                i32.const 20
+                i32.add
+                local.tee $l2
+                i32.load
+                local.tee $l4
+                br_if $B25
+                local.get $l5
+                i32.const 16
+                i32.add
+                local.tee $l2
+                i32.load
+                local.tee $l4
+                br_if $B25
+                i32.const 0
+                local.set $l1
+                br $B22
+              end
+              loop $L26
+                local.get $l2
+                local.set $l7
+                local.get $l4
+                local.tee $l1
+                i32.const 20
+                i32.add
+                local.tee $l2
+                i32.load
+                local.tee $l4
+                br_if $L26
+                local.get $l1
+                i32.const 16
+                i32.add
+                local.set $l2
+                local.get $l1
+                i32.load offset=16
+                local.tee $l4
+                br_if $L26
+              end
+              local.get $l7
+              i32.const 0
+              i32.store
+            end
+            local.get $l6
+            i32.eqz
+            br_if $B17
+            block $B27
+              local.get $l5
+              local.get $l5
+              i32.load offset=28
+              local.tee $l2
+              i32.const 2
+              i32.shl
+              i32.const 1060884
+              i32.add
+              local.tee $l4
+              i32.load
+              i32.eq
+              if $I28
+                local.get $l4
+                local.get $l1
+                i32.store
+                local.get $l1
+                br_if $B27
+                i32.const 1060584
+                i32.const 1060584
+                i32.load
+                i32.const -2
+                local.get $l2
+                i32.rotl
+                i32.and
+                i32.store
+                br $B17
+              end
+              local.get $l6
+              i32.const 16
+              i32.const 20
+              local.get $l6
+              i32.load offset=16
+              local.get $l5
+              i32.eq
+              select
+              i32.add
+              local.get $l1
+              i32.store
+              local.get $l1
+              i32.eqz
+              br_if $B17
+            end
+            local.get $l1
+            local.get $l6
+            i32.store offset=24
+            local.get $l5
+            i32.load offset=16
+            local.tee $l2
+            if $I29
+              local.get $l1
+              local.get $l2
+              i32.store offset=16
+              local.get $l2
+              local.get $l1
+              i32.store offset=24
+            end
+            local.get $l5
+            i32.load offset=20
+            local.tee $l2
+            i32.eqz
+            br_if $B17
+            local.get $l1
+            i32.const 20
+            i32.add
+            local.get $l2
+            i32.store
+            local.get $l2
+            local.get $l1
+            i32.store offset=24
+          end
+          local.get $p0
+          local.get $l3
+          i32.add
+          local.get $p0
+          i32.store
+          local.get $l3
+          local.get $p0
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $l3
+          i32.const 1060600
+          i32.load
+          i32.ne
+          br_if $B13
+          i32.const 1060588
+          local.get $p0
+          i32.store
+          return
+        end
+        local.get $l5
+        local.get $l1
+        i32.const -2
+        i32.and
+        i32.store offset=4
+        local.get $p0
+        local.get $l3
+        i32.add
+        local.get $p0
+        i32.store
+        local.get $l3
+        local.get $p0
+        i32.const 1
+        i32.or
+        i32.store offset=4
+      end
+      local.get $p0
+      i32.const 255
+      i32.le_u
+      if $I30
+        local.get $p0
+        i32.const 3
+        i32.shr_u
+        local.tee $l1
+        i32.const 3
+        i32.shl
+        i32.const 1060620
+        i32.add
+        local.set $p0
+        block $B31 (result i32)
+          i32.const 1060580
+          i32.load
+          local.tee $l2
+          i32.const 1
+          local.get $l1
+          i32.shl
+          local.tee $l1
+          i32.and
+          i32.eqz
+          if $I32
+            i32.const 1060580
+            local.get $l1
+            local.get $l2
+            i32.or
+            i32.store
+            local.get $p0
+            br $B31
+          end
+          local.get $p0
+          i32.load offset=8
+        end
+        local.tee $l2
+        local.get $l3
+        i32.store offset=12
+        local.get $p0
+        local.get $l3
+        i32.store offset=8
+        local.get $l3
+        local.get $p0
+        i32.store offset=12
+        local.get $l3
+        local.get $l2
+        i32.store offset=8
+        return
+      end
+      local.get $l3
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $l3
+      i32.const 28
+      i32.add
+      block $B33 (result i32)
+        i32.const 0
+        local.get $p0
+        i32.const 8
+        i32.shr_u
+        local.tee $l1
+        i32.eqz
+        br_if $B33
+        drop
+        i32.const 31
+        local.get $p0
+        i32.const 16777215
+        i32.gt_u
+        br_if $B33
+        drop
+        local.get $l1
+        local.get $l1
+        i32.const 1048320
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 8
+        i32.and
+        local.tee $l1
+        i32.shl
+        local.tee $l2
+        local.get $l2
+        i32.const 520192
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 4
+        i32.and
+        local.tee $l2
+        i32.shl
+        local.tee $l4
+        local.get $l4
+        i32.const 245760
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 2
+        i32.and
+        local.tee $l4
+        i32.shl
+        i32.const 15
+        i32.shr_u
+        local.get $l1
+        local.get $l2
+        i32.or
+        local.get $l4
+        i32.or
+        i32.sub
+        local.tee $l1
+        i32.const 1
+        i32.shl
+        local.get $p0
+        local.get $l1
+        i32.const 21
+        i32.add
+        i32.shr_u
+        i32.const 1
+        i32.and
+        i32.or
+        i32.const 28
+        i32.add
+      end
+      local.tee $l2
+      i32.store
+      local.get $l2
+      i32.const 2
+      i32.shl
+      i32.const 1060884
+      i32.add
+      local.set $l1
+      block $B34
+        i32.const 1060584
+        i32.load
+        local.tee $l4
+        i32.const 1
+        local.get $l2
+        i32.shl
+        local.tee $l7
+        i32.and
+        i32.eqz
+        if $I35
+          local.get $l1
+          local.get $l3
+          i32.store
+          i32.const 1060584
+          local.get $l4
+          local.get $l7
+          i32.or
+          i32.store
+          local.get $l3
+          i32.const 24
+          i32.add
+          local.get $l1
+          i32.store
+          local.get $l3
+          local.get $l3
+          i32.store offset=8
+          local.get $l3
+          local.get $l3
+          i32.store offset=12
+          br $B34
+        end
+        local.get $p0
+        i32.const 0
+        i32.const 25
+        local.get $l2
+        i32.const 1
+        i32.shr_u
+        i32.sub
+        local.get $l2
+        i32.const 31
+        i32.eq
+        select
+        i32.shl
+        local.set $l2
+        local.get $l1
+        i32.load
+        local.set $l1
+        block $B36
+          loop $L37
+            local.get $l1
+            local.tee $l4
+            i32.load offset=4
+            i32.const -8
+            i32.and
+            local.get $p0
+            i32.eq
+            br_if $B36
+            local.get $l2
+            i32.const 29
+            i32.shr_u
+            local.set $l1
+            local.get $l2
+            i32.const 1
+            i32.shl
+            local.set $l2
+            local.get $l4
+            local.get $l1
+            i32.const 4
+            i32.and
+            i32.add
+            i32.const 16
+            i32.add
+            local.tee $l7
+            i32.load
+            local.tee $l1
+            br_if $L37
+          end
+          local.get $l7
+          local.get $l3
+          i32.store
+          local.get $l3
+          local.get $l3
+          i32.store offset=12
+          local.get $l3
+          i32.const 24
+          i32.add
+          local.get $l4
+          i32.store
+          local.get $l3
+          local.get $l3
+          i32.store offset=8
+          br $B34
+        end
+        local.get $l4
+        i32.load offset=8
+        local.set $p0
+        local.get $l4
+        local.get $l3
+        i32.store offset=8
+        local.get $p0
+        local.get $l3
+        i32.store offset=12
+        local.get $l3
+        i32.const 24
+        i32.add
+        i32.const 0
+        i32.store
+        local.get $l3
+        local.get $p0
+        i32.store offset=8
+        local.get $l3
+        local.get $l4
+        i32.store offset=12
+      end
+      i32.const 1060612
+      i32.const 1060612
+      i32.load
+      i32.const -1
+      i32.add
+      local.tee $p0
+      i32.store
+      local.get $p0
+      br_if $B0
+      i32.const 1061036
+      local.set $l3
+      loop $L38
+        local.get $l3
+        i32.load
+        local.tee $p0
+        i32.const 8
+        i32.add
+        local.set $l3
+        local.get $p0
+        br_if $L38
+      end
+      i32.const 1060612
+      i32.const -1
+      i32.store
+    end)
+  (func $f146 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    block $B0
+      block $B1 (result i32)
+        i32.const 0
+        local.get $p0
+        i32.eqz
+        br_if $B1
+        drop
+        local.get $p0
+        local.get $p1
+        i32.mul
+        local.tee $l2
+        local.get $p0
+        local.get $p1
+        i32.or
+        i32.const 65536
+        i32.lt_u
+        br_if $B1
+        drop
+        local.get $l2
+        i32.const -1
+        local.get $l2
+        local.get $p0
+        i32.div_u
+        local.get $p1
+        i32.eq
+        select
+      end
+      local.tee $l2
+      call $f144
+      local.tee $p0
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.const -4
+      i32.add
+      i32.load8_u
+      i32.const 3
+      i32.and
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      local.get $l2
+      call $f166
+      drop
+    end
+    local.get $p0)
+  (func $f147 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32)
+    local.get $p0
+    i32.eqz
+    if $I0
+      local.get $p1
+      call $f144
+      return
+    end
+    local.get $p1
+    i32.const -64
+    i32.ge_u
+    if $I1
+      i32.const 1061076
+      i32.const 48
+      i32.store
+      i32.const 0
+      return
+    end
+    local.get $p0
+    i32.const -8
+    i32.add
+    local.set $l6
+    i32.const 1060596
+    i32.load
+    local.set $l11
+    local.get $p0
+    i32.const -4
+    i32.add
+    local.tee $l7
+    i32.load
+    local.tee $l8
+    i32.const 3
+    i32.and
+    local.tee $l5
+    i32.const 1
+    i32.eq
+    local.get $l8
+    i32.const -8
+    i32.and
+    local.tee $l2
+    i32.const 1
+    i32.lt_s
+    i32.or
+    drop
+    i32.const 16
+    local.get $p1
+    i32.const 19
+    i32.add
+    i32.const -16
+    i32.and
+    local.get $p1
+    i32.const 11
+    i32.lt_u
+    select
+    local.set $l3
+    block $B2
+      block $B3
+        local.get $l5
+        i32.eqz
+        if $I4
+          local.get $l3
+          i32.const 256
+          i32.lt_u
+          local.get $l2
+          local.get $l3
+          i32.const 4
+          i32.or
+          i32.lt_u
+          i32.or
+          br_if $B3
+          local.get $l2
+          local.get $l3
+          i32.sub
+          i32.const 1061060
+          i32.load
+          i32.const 1
+          i32.shl
+          i32.le_u
+          br_if $B2
+          br $B3
+        end
+        local.get $l2
+        local.get $l6
+        i32.add
+        local.set $l4
+        local.get $l2
+        local.get $l3
+        i32.ge_u
+        if $I5
+          local.get $l2
+          local.get $l3
+          i32.sub
+          local.tee $p1
+          i32.const 16
+          i32.lt_u
+          br_if $B2
+          local.get $l7
+          local.get $l3
+          local.get $l8
+          i32.const 1
+          i32.and
+          i32.or
+          i32.const 2
+          i32.or
+          i32.store
+          local.get $l3
+          local.get $l6
+          i32.add
+          local.tee $l2
+          local.get $p1
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $l4
+          local.get $l4
+          i32.load offset=4
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $l2
+          local.get $p1
+          call $f148
+          local.get $p0
+          return
+        end
+        local.get $l4
+        i32.const 1060604
+        i32.load
+        i32.eq
+        if $I6
+          i32.const 1060592
+          i32.load
+          local.get $l2
+          i32.add
+          local.tee $l2
+          local.get $l3
+          i32.le_u
+          br_if $B3
+          local.get $l7
+          local.get $l3
+          local.get $l8
+          i32.const 1
+          i32.and
+          i32.or
+          i32.const 2
+          i32.or
+          i32.store
+          i32.const 1060604
+          local.get $l3
+          local.get $l6
+          i32.add
+          local.tee $p1
+          i32.store
+          i32.const 1060592
+          local.get $l2
+          local.get $l3
+          i32.sub
+          local.tee $l2
+          i32.store
+          local.get $p1
+          local.get $l2
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $p0
+          return
+        end
+        local.get $l4
+        i32.const 1060600
+        i32.load
+        i32.eq
+        if $I7
+          i32.const 1060588
+          i32.load
+          local.get $l2
+          i32.add
+          local.tee $l2
+          local.get $l3
+          i32.lt_u
+          br_if $B3
+          block $B8
+            local.get $l2
+            local.get $l3
+            i32.sub
+            local.tee $p1
+            i32.const 16
+            i32.ge_u
+            if $I9
+              local.get $l7
+              local.get $l3
+              local.get $l8
+              i32.const 1
+              i32.and
+              i32.or
+              i32.const 2
+              i32.or
+              i32.store
+              local.get $l3
+              local.get $l6
+              i32.add
+              local.tee $l5
+              local.get $p1
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $l2
+              local.get $l6
+              i32.add
+              local.tee $l2
+              local.get $p1
+              i32.store
+              local.get $l2
+              local.get $l2
+              i32.load offset=4
+              i32.const -2
+              i32.and
+              i32.store offset=4
+              br $B8
+            end
+            local.get $l7
+            local.get $l8
+            i32.const 1
+            i32.and
+            local.get $l2
+            i32.or
+            i32.const 2
+            i32.or
+            i32.store
+            local.get $l2
+            local.get $l6
+            i32.add
+            local.tee $p1
+            local.get $p1
+            i32.load offset=4
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            i32.const 0
+            local.set $p1
+            i32.const 0
+            local.set $l5
+          end
+          i32.const 1060600
+          local.get $l5
+          i32.store
+          i32.const 1060588
+          local.get $p1
+          i32.store
+          local.get $p0
+          return
+        end
+        local.get $l4
+        i32.load offset=4
+        local.tee $l5
+        i32.const 2
+        i32.and
+        br_if $B3
+        local.get $l5
+        i32.const -8
+        i32.and
+        local.get $l2
+        i32.add
+        local.tee $l9
+        local.get $l3
+        i32.lt_u
+        br_if $B3
+        local.get $l9
+        local.get $l3
+        i32.sub
+        local.set $l12
+        block $B10
+          local.get $l5
+          i32.const 255
+          i32.le_u
+          if $I11
+            local.get $l4
+            i32.load offset=8
+            local.tee $l2
+            local.get $l5
+            i32.const 3
+            i32.shr_u
+            local.tee $l5
+            i32.const 3
+            i32.shl
+            i32.const 1060620
+            i32.add
+            i32.ne
+            drop
+            local.get $l2
+            local.get $l4
+            i32.load offset=12
+            local.tee $p1
+            i32.eq
+            if $I12
+              i32.const 1060580
+              i32.const 1060580
+              i32.load
+              i32.const -2
+              local.get $l5
+              i32.rotl
+              i32.and
+              i32.store
+              br $B10
+            end
+            local.get $p1
+            local.get $l2
+            i32.store offset=8
+            local.get $l2
+            local.get $p1
+            i32.store offset=12
+            br $B10
+          end
+          local.get $l4
+          i32.load offset=24
+          local.set $l10
+          block $B13
+            local.get $l4
+            local.get $l4
+            i32.load offset=12
+            local.tee $l2
+            i32.ne
+            if $I14
+              local.get $l11
+              local.get $l4
+              i32.load offset=8
+              local.tee $p1
+              i32.le_u
+              if $I15
+                local.get $p1
+                i32.load offset=12
+                drop
+              end
+              local.get $l2
+              local.get $p1
+              i32.store offset=8
+              local.get $p1
+              local.get $l2
+              i32.store offset=12
+              br $B13
+            end
+            block $B16
+              local.get $l4
+              i32.const 20
+              i32.add
+              local.tee $p1
+              i32.load
+              local.tee $l5
+              br_if $B16
+              local.get $l4
+              i32.const 16
+              i32.add
+              local.tee $p1
+              i32.load
+              local.tee $l5
+              br_if $B16
+              i32.const 0
+              local.set $l2
+              br $B13
+            end
+            loop $L17
+              local.get $p1
+              local.set $l11
+              local.get $l5
+              local.tee $l2
+              i32.const 20
+              i32.add
+              local.tee $p1
+              i32.load
+              local.tee $l5
+              br_if $L17
+              local.get $l2
+              i32.const 16
+              i32.add
+              local.set $p1
+              local.get $l2
+              i32.load offset=16
+              local.tee $l5
+              br_if $L17
+            end
+            local.get $l11
+            i32.const 0
+            i32.store
+          end
+          local.get $l10
+          i32.eqz
+          br_if $B10
+          block $B18
+            local.get $l4
+            local.get $l4
+            i32.load offset=28
+            local.tee $p1
+            i32.const 2
+            i32.shl
+            i32.const 1060884
+            i32.add
+            local.tee $l5
+            i32.load
+            i32.eq
+            if $I19
+              local.get $l5
+              local.get $l2
+              i32.store
+              local.get $l2
+              br_if $B18
+              i32.const 1060584
+              i32.const 1060584
+              i32.load
+              i32.const -2
+              local.get $p1
+              i32.rotl
+              i32.and
+              i32.store
+              br $B10
+            end
+            local.get $l10
+            i32.const 16
+            i32.const 20
+            local.get $l10
+            i32.load offset=16
+            local.get $l4
+            i32.eq
+            select
+            i32.add
+            local.get $l2
+            i32.store
+            local.get $l2
+            i32.eqz
+            br_if $B10
+          end
+          local.get $l2
+          local.get $l10
+          i32.store offset=24
+          local.get $l4
+          i32.load offset=16
+          local.tee $p1
+          if $I20
+            local.get $l2
+            local.get $p1
+            i32.store offset=16
+            local.get $p1
+            local.get $l2
+            i32.store offset=24
+          end
+          local.get $l4
+          i32.load offset=20
+          local.tee $p1
+          i32.eqz
+          br_if $B10
+          local.get $l2
+          i32.const 20
+          i32.add
+          local.get $p1
+          i32.store
+          local.get $p1
+          local.get $l2
+          i32.store offset=24
+        end
+        local.get $l12
+        i32.const 15
+        i32.le_u
+        if $I21
+          local.get $l7
+          local.get $l8
+          i32.const 1
+          i32.and
+          local.get $l9
+          i32.or
+          i32.const 2
+          i32.or
+          i32.store
+          local.get $l6
+          local.get $l9
+          i32.add
+          local.tee $p1
+          local.get $p1
+          i32.load offset=4
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $p0
+          return
+        end
+        local.get $l7
+        local.get $l3
+        local.get $l8
+        i32.const 1
+        i32.and
+        i32.or
+        i32.const 2
+        i32.or
+        i32.store
+        local.get $l3
+        local.get $l6
+        i32.add
+        local.tee $p1
+        local.get $l12
+        i32.const 3
+        i32.or
+        i32.store offset=4
+        local.get $l6
+        local.get $l9
+        i32.add
+        local.tee $l2
+        local.get $l2
+        i32.load offset=4
+        i32.const 1
+        i32.or
+        i32.store offset=4
+        local.get $p1
+        local.get $l12
+        call $f148
+        local.get $p0
+        return
+      end
+      local.get $p1
+      call $f144
+      local.tee $l2
+      i32.eqz
+      if $I22
+        i32.const 0
+        return
+      end
+      local.get $l2
+      local.get $p0
+      local.get $l7
+      i32.load
+      local.tee $l2
+      i32.const -8
+      i32.and
+      i32.const 4
+      i32.const 8
+      local.get $l2
+      i32.const 3
+      i32.and
+      select
+      i32.sub
+      local.tee $l2
+      local.get $p1
+      local.get $l2
+      local.get $p1
+      i32.lt_u
+      select
+      call $f162
+      local.get $p0
+      call $f145
+      local.set $p0
+    end
+    local.get $p0)
+  (func $f148 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32)
+    local.get $p0
+    local.get $p1
+    i32.add
+    local.set $l5
+    block $B0
+      block $B1
+        local.get $p0
+        i32.load offset=4
+        local.tee $l2
+        i32.const 1
+        i32.and
+        br_if $B1
+        local.get $l2
+        i32.const 3
+        i32.and
+        i32.eqz
+        br_if $B0
+        local.get $p0
+        i32.load
+        local.tee $l3
+        local.get $p1
+        i32.add
+        local.set $p1
+        local.get $p0
+        local.get $l3
+        i32.sub
+        local.tee $p0
+        i32.const 1060600
+        i32.load
+        i32.ne
+        if $I2
+          i32.const 1060596
+          i32.load
+          local.set $l4
+          local.get $l3
+          i32.const 255
+          i32.le_u
+          if $I3
+            local.get $p0
+            i32.load offset=8
+            local.tee $l4
+            local.get $l3
+            i32.const 3
+            i32.shr_u
+            local.tee $l3
+            i32.const 3
+            i32.shl
+            i32.const 1060620
+            i32.add
+            i32.ne
+            drop
+            local.get $l4
+            local.get $p0
+            i32.load offset=12
+            local.tee $l2
+            i32.eq
+            if $I4
+              i32.const 1060580
+              i32.const 1060580
+              i32.load
+              i32.const -2
+              local.get $l3
+              i32.rotl
+              i32.and
+              i32.store
+              br $B1
+            end
+            local.get $l2
+            local.get $l4
+            i32.store offset=8
+            local.get $l4
+            local.get $l2
+            i32.store offset=12
+            br $B1
+          end
+          local.get $p0
+          i32.load offset=24
+          local.set $l6
+          block $B5
+            local.get $p0
+            local.get $p0
+            i32.load offset=12
+            local.tee $l2
+            i32.ne
+            if $I6
+              local.get $l4
+              local.get $p0
+              i32.load offset=8
+              local.tee $l3
+              i32.le_u
+              if $I7
+                local.get $l3
+                i32.load offset=12
+                drop
+              end
+              local.get $l2
+              local.get $l3
+              i32.store offset=8
+              local.get $l3
+              local.get $l2
+              i32.store offset=12
+              br $B5
+            end
+            block $B8
+              local.get $p0
+              i32.const 20
+              i32.add
+              local.tee $l3
+              i32.load
+              local.tee $l4
+              br_if $B8
+              local.get $p0
+              i32.const 16
+              i32.add
+              local.tee $l3
+              i32.load
+              local.tee $l4
+              br_if $B8
+              i32.const 0
+              local.set $l2
+              br $B5
+            end
+            loop $L9
+              local.get $l3
+              local.set $l7
+              local.get $l4
+              local.tee $l2
+              i32.const 20
+              i32.add
+              local.tee $l3
+              i32.load
+              local.tee $l4
+              br_if $L9
+              local.get $l2
+              i32.const 16
+              i32.add
+              local.set $l3
+              local.get $l2
+              i32.load offset=16
+              local.tee $l4
+              br_if $L9
+            end
+            local.get $l7
+            i32.const 0
+            i32.store
+          end
+          local.get $l6
+          i32.eqz
+          br_if $B1
+          block $B10
+            local.get $p0
+            local.get $p0
+            i32.load offset=28
+            local.tee $l3
+            i32.const 2
+            i32.shl
+            i32.const 1060884
+            i32.add
+            local.tee $l4
+            i32.load
+            i32.eq
+            if $I11
+              local.get $l4
+              local.get $l2
+              i32.store
+              local.get $l2
+              br_if $B10
+              i32.const 1060584
+              i32.const 1060584
+              i32.load
+              i32.const -2
+              local.get $l3
+              i32.rotl
+              i32.and
+              i32.store
+              br $B1
+            end
+            local.get $l6
+            i32.const 16
+            i32.const 20
+            local.get $l6
+            i32.load offset=16
+            local.get $p0
+            i32.eq
+            select
+            i32.add
+            local.get $l2
+            i32.store
+            local.get $l2
+            i32.eqz
+            br_if $B1
+          end
+          local.get $l2
+          local.get $l6
+          i32.store offset=24
+          local.get $p0
+          i32.load offset=16
+          local.tee $l3
+          if $I12
+            local.get $l2
+            local.get $l3
+            i32.store offset=16
+            local.get $l3
+            local.get $l2
+            i32.store offset=24
+          end
+          local.get $p0
+          i32.load offset=20
+          local.tee $l3
+          i32.eqz
+          br_if $B1
+          local.get $l2
+          i32.const 20
+          i32.add
+          local.get $l3
+          i32.store
+          local.get $l3
+          local.get $l2
+          i32.store offset=24
+          br $B1
+        end
+        local.get $l5
+        i32.load offset=4
+        local.tee $l2
+        i32.const 3
+        i32.and
+        i32.const 3
+        i32.ne
+        br_if $B1
+        local.get $l5
+        local.get $l2
+        i32.const -2
+        i32.and
+        i32.store offset=4
+        i32.const 1060588
+        local.get $p1
+        i32.store
+        local.get $l5
+        local.get $p1
+        i32.store
+        local.get $p0
+        local.get $p1
+        i32.const 1
+        i32.or
+        i32.store offset=4
+        return
+      end
+      block $B13
+        local.get $l5
+        i32.load offset=4
+        local.tee $l2
+        i32.const 2
+        i32.and
+        i32.eqz
+        if $I14
+          local.get $l5
+          i32.const 1060604
+          i32.load
+          i32.eq
+          if $I15
+            i32.const 1060604
+            local.get $p0
+            i32.store
+            i32.const 1060592
+            i32.const 1060592
+            i32.load
+            local.get $p1
+            i32.add
+            local.tee $p1
+            i32.store
+            local.get $p0
+            local.get $p1
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $p0
+            i32.const 1060600
+            i32.load
+            i32.ne
+            br_if $B0
+            i32.const 1060588
+            i32.const 0
+            i32.store
+            i32.const 1060600
+            i32.const 0
+            i32.store
+            return
+          end
+          local.get $l5
+          i32.const 1060600
+          i32.load
+          i32.eq
+          if $I16
+            i32.const 1060600
+            local.get $p0
+            i32.store
+            i32.const 1060588
+            i32.const 1060588
+            i32.load
+            local.get $p1
+            i32.add
+            local.tee $p1
+            i32.store
+            local.get $p0
+            local.get $p1
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $p0
+            local.get $p1
+            i32.add
+            local.get $p1
+            i32.store
+            return
+          end
+          i32.const 1060596
+          i32.load
+          local.set $l3
+          local.get $l2
+          i32.const -8
+          i32.and
+          local.get $p1
+          i32.add
+          local.set $p1
+          block $B17
+            local.get $l2
+            i32.const 255
+            i32.le_u
+            if $I18
+              local.get $l5
+              i32.load offset=8
+              local.tee $l4
+              local.get $l2
+              i32.const 3
+              i32.shr_u
+              local.tee $l2
+              i32.const 3
+              i32.shl
+              i32.const 1060620
+              i32.add
+              i32.ne
+              drop
+              local.get $l4
+              local.get $l5
+              i32.load offset=12
+              local.tee $l3
+              i32.eq
+              if $I19
+                i32.const 1060580
+                i32.const 1060580
+                i32.load
+                i32.const -2
+                local.get $l2
+                i32.rotl
+                i32.and
+                i32.store
+                br $B17
+              end
+              local.get $l3
+              local.get $l4
+              i32.store offset=8
+              local.get $l4
+              local.get $l3
+              i32.store offset=12
+              br $B17
+            end
+            local.get $l5
+            i32.load offset=24
+            local.set $l6
+            block $B20
+              local.get $l5
+              local.get $l5
+              i32.load offset=12
+              local.tee $l2
+              i32.ne
+              if $I21
+                local.get $l3
+                local.get $l5
+                i32.load offset=8
+                local.tee $l3
+                i32.le_u
+                if $I22
+                  local.get $l3
+                  i32.load offset=12
+                  drop
+                end
+                local.get $l2
+                local.get $l3
+                i32.store offset=8
+                local.get $l3
+                local.get $l2
+                i32.store offset=12
+                br $B20
+              end
+              block $B23
+                local.get $l5
+                i32.const 20
+                i32.add
+                local.tee $l3
+                i32.load
+                local.tee $l4
+                br_if $B23
+                local.get $l5
+                i32.const 16
+                i32.add
+                local.tee $l3
+                i32.load
+                local.tee $l4
+                br_if $B23
+                i32.const 0
+                local.set $l2
+                br $B20
+              end
+              loop $L24
+                local.get $l3
+                local.set $l7
+                local.get $l4
+                local.tee $l2
+                i32.const 20
+                i32.add
+                local.tee $l3
+                i32.load
+                local.tee $l4
+                br_if $L24
+                local.get $l2
+                i32.const 16
+                i32.add
+                local.set $l3
+                local.get $l2
+                i32.load offset=16
+                local.tee $l4
+                br_if $L24
+              end
+              local.get $l7
+              i32.const 0
+              i32.store
+            end
+            local.get $l6
+            i32.eqz
+            br_if $B17
+            block $B25
+              local.get $l5
+              local.get $l5
+              i32.load offset=28
+              local.tee $l3
+              i32.const 2
+              i32.shl
+              i32.const 1060884
+              i32.add
+              local.tee $l4
+              i32.load
+              i32.eq
+              if $I26
+                local.get $l4
+                local.get $l2
+                i32.store
+                local.get $l2
+                br_if $B25
+                i32.const 1060584
+                i32.const 1060584
+                i32.load
+                i32.const -2
+                local.get $l3
+                i32.rotl
+                i32.and
+                i32.store
+                br $B17
+              end
+              local.get $l6
+              i32.const 16
+              i32.const 20
+              local.get $l6
+              i32.load offset=16
+              local.get $l5
+              i32.eq
+              select
+              i32.add
+              local.get $l2
+              i32.store
+              local.get $l2
+              i32.eqz
+              br_if $B17
+            end
+            local.get $l2
+            local.get $l6
+            i32.store offset=24
+            local.get $l5
+            i32.load offset=16
+            local.tee $l3
+            if $I27
+              local.get $l2
+              local.get $l3
+              i32.store offset=16
+              local.get $l3
+              local.get $l2
+              i32.store offset=24
+            end
+            local.get $l5
+            i32.load offset=20
+            local.tee $l3
+            i32.eqz
+            br_if $B17
+            local.get $l2
+            i32.const 20
+            i32.add
+            local.get $l3
+            i32.store
+            local.get $l3
+            local.get $l2
+            i32.store offset=24
+          end
+          local.get $p0
+          local.get $p1
+          i32.add
+          local.get $p1
+          i32.store
+          local.get $p0
+          local.get $p1
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $p0
+          i32.const 1060600
+          i32.load
+          i32.ne
+          br_if $B13
+          i32.const 1060588
+          local.get $p1
+          i32.store
+          return
+        end
+        local.get $l5
+        local.get $l2
+        i32.const -2
+        i32.and
+        i32.store offset=4
+        local.get $p0
+        local.get $p1
+        i32.add
+        local.get $p1
+        i32.store
+        local.get $p0
+        local.get $p1
+        i32.const 1
+        i32.or
+        i32.store offset=4
+      end
+      local.get $p1
+      i32.const 255
+      i32.le_u
+      if $I28
+        local.get $p1
+        i32.const 3
+        i32.shr_u
+        local.tee $l2
+        i32.const 3
+        i32.shl
+        i32.const 1060620
+        i32.add
+        local.set $p1
+        block $B29 (result i32)
+          i32.const 1060580
+          i32.load
+          local.tee $l3
+          i32.const 1
+          local.get $l2
+          i32.shl
+          local.tee $l2
+          i32.and
+          i32.eqz
+          if $I30
+            i32.const 1060580
+            local.get $l2
+            local.get $l3
+            i32.or
+            i32.store
+            local.get $p1
+            br $B29
+          end
+          local.get $p1
+          i32.load offset=8
+        end
+        local.tee $l3
+        local.get $p0
+        i32.store offset=12
+        local.get $p1
+        local.get $p0
+        i32.store offset=8
+        local.get $p0
+        local.get $p1
+        i32.store offset=12
+        local.get $p0
+        local.get $l3
+        i32.store offset=8
+        return
+      end
+      local.get $p0
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $p0
+      i32.const 28
+      i32.add
+      block $B31 (result i32)
+        i32.const 0
+        local.get $p1
+        i32.const 8
+        i32.shr_u
+        local.tee $l2
+        i32.eqz
+        br_if $B31
+        drop
+        i32.const 31
+        local.get $p1
+        i32.const 16777215
+        i32.gt_u
+        br_if $B31
+        drop
+        local.get $l2
+        local.get $l2
+        i32.const 1048320
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 8
+        i32.and
+        local.tee $l2
+        i32.shl
+        local.tee $l3
+        local.get $l3
+        i32.const 520192
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 4
+        i32.and
+        local.tee $l3
+        i32.shl
+        local.tee $l4
+        local.get $l4
+        i32.const 245760
+        i32.add
+        i32.const 16
+        i32.shr_u
+        i32.const 2
+        i32.and
+        local.tee $l4
+        i32.shl
+        i32.const 15
+        i32.shr_u
+        local.get $l2
+        local.get $l3
+        i32.or
+        local.get $l4
+        i32.or
+        i32.sub
+        local.tee $l2
+        i32.const 1
+        i32.shl
+        local.get $p1
+        local.get $l2
+        i32.const 21
+        i32.add
+        i32.shr_u
+        i32.const 1
+        i32.and
+        i32.or
+        i32.const 28
+        i32.add
+      end
+      local.tee $l3
+      i32.store
+      local.get $l3
+      i32.const 2
+      i32.shl
+      i32.const 1060884
+      i32.add
+      local.set $l2
+      i32.const 1060584
+      i32.load
+      local.tee $l4
+      i32.const 1
+      local.get $l3
+      i32.shl
+      local.tee $l7
+      i32.and
+      i32.eqz
+      if $I32
+        local.get $l2
+        local.get $p0
+        i32.store
+        i32.const 1060584
+        local.get $l4
+        local.get $l7
+        i32.or
+        i32.store
+        local.get $p0
+        i32.const 24
+        i32.add
+        local.get $l2
+        i32.store
+        local.get $p0
+        local.get $p0
+        i32.store offset=8
+        local.get $p0
+        local.get $p0
+        i32.store offset=12
+        return
+      end
+      local.get $p1
+      i32.const 0
+      i32.const 25
+      local.get $l3
+      i32.const 1
+      i32.shr_u
+      i32.sub
+      local.get $l3
+      i32.const 31
+      i32.eq
+      select
+      i32.shl
+      local.set $l3
+      local.get $l2
+      i32.load
+      local.set $l2
+      block $B33
+        loop $L34
+          local.get $l2
+          local.tee $l4
+          i32.load offset=4
+          i32.const -8
+          i32.and
+          local.get $p1
+          i32.eq
+          br_if $B33
+          local.get $l3
+          i32.const 29
+          i32.shr_u
+          local.set $l2
+          local.get $l3
+          i32.const 1
+          i32.shl
+          local.set $l3
+          local.get $l4
+          local.get $l2
+          i32.const 4
+          i32.and
+          i32.add
+          i32.const 16
+          i32.add
+          local.tee $l7
+          i32.load
+          local.tee $l2
+          br_if $L34
+        end
+        local.get $l7
+        local.get $p0
+        i32.store
+        local.get $p0
+        i32.const 24
+        i32.add
+        local.get $l4
+        i32.store
+        local.get $p0
+        local.get $p0
+        i32.store offset=12
+        local.get $p0
+        local.get $p0
+        i32.store offset=8
+        return
+      end
+      local.get $l4
+      i32.load offset=8
+      local.set $p1
+      local.get $l4
+      local.get $p0
+      i32.store offset=8
+      local.get $p1
+      local.get $p0
+      i32.store offset=12
+      local.get $p0
+      i32.const 24
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p0
+      local.get $p1
+      i32.store offset=8
+      local.get $p0
+      local.get $l4
+      i32.store offset=12
+    end)
+  (func $f149 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    block $B0
+      local.get $p0
+      i32.const 16
+      local.get $p0
+      i32.const 16
+      i32.gt_u
+      select
+      local.tee $l3
+      local.get $l3
+      i32.const -1
+      i32.add
+      i32.and
+      i32.eqz
+      if $I1
+        local.get $l3
+        local.set $p0
+        br $B0
+      end
+      i32.const 32
+      local.set $l2
+      loop $L2
+        local.get $l2
+        local.tee $p0
+        i32.const 1
+        i32.shl
+        local.set $l2
+        local.get $p0
+        local.get $l3
+        i32.lt_u
+        br_if $L2
+      end
+    end
+    i32.const -64
+    local.get $p0
+    i32.sub
+    local.get $p1
+    i32.le_u
+    if $I3
+      i32.const 1061076
+      i32.const 48
+      i32.store
+      i32.const 0
+      return
+    end
+    i32.const 16
+    local.get $p1
+    i32.const 19
+    i32.add
+    i32.const -16
+    i32.and
+    local.get $p1
+    i32.const 11
+    i32.lt_u
+    select
+    local.tee $l3
+    i32.const 12
+    i32.or
+    local.get $p0
+    i32.add
+    call $f144
+    local.tee $l2
+    i32.eqz
+    if $I4
+      i32.const 0
+      return
+    end
+    local.get $l2
+    i32.const -8
+    i32.add
+    local.set $p1
+    block $B5
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.get $l2
+      i32.and
+      i32.eqz
+      if $I6
+        local.get $p1
+        local.set $p0
+        br $B5
+      end
+      local.get $l2
+      i32.const -4
+      i32.add
+      local.tee $l5
+      i32.load
+      local.tee $l6
+      i32.const -8
+      i32.and
+      local.get $p0
+      local.get $l2
+      i32.add
+      i32.const -1
+      i32.add
+      i32.const 0
+      local.get $p0
+      i32.sub
+      i32.and
+      i32.const -8
+      i32.add
+      local.tee $l2
+      local.get $p0
+      local.get $l2
+      i32.add
+      local.get $l2
+      local.get $p1
+      i32.sub
+      i32.const 15
+      i32.gt_u
+      select
+      local.tee $p0
+      local.get $p1
+      i32.sub
+      local.tee $l2
+      i32.sub
+      local.set $l4
+      local.get $l6
+      i32.const 3
+      i32.and
+      i32.eqz
+      if $I7
+        local.get $p0
+        local.get $l4
+        i32.store offset=4
+        local.get $p0
+        local.get $p1
+        i32.load
+        local.get $l2
+        i32.add
+        i32.store
+        br $B5
+      end
+      local.get $p0
+      local.get $l4
+      local.get $p0
+      i32.load offset=4
+      i32.const 1
+      i32.and
+      i32.or
+      i32.const 2
+      i32.or
+      i32.store offset=4
+      local.get $p0
+      local.get $l4
+      i32.add
+      local.tee $l4
+      local.get $l4
+      i32.load offset=4
+      i32.const 1
+      i32.or
+      i32.store offset=4
+      local.get $l5
+      local.get $l2
+      local.get $l5
+      i32.load
+      i32.const 1
+      i32.and
+      i32.or
+      i32.const 2
+      i32.or
+      i32.store
+      local.get $p0
+      local.get $p0
+      i32.load offset=4
+      i32.const 1
+      i32.or
+      i32.store offset=4
+      local.get $p1
+      local.get $l2
+      call $f148
+    end
+    block $B8
+      local.get $p0
+      i32.load offset=4
+      local.tee $p1
+      i32.const 3
+      i32.and
+      i32.eqz
+      br_if $B8
+      local.get $p1
+      i32.const -8
+      i32.and
+      local.tee $l2
+      local.get $l3
+      i32.const 16
+      i32.add
+      i32.le_u
+      br_if $B8
+      local.get $p0
+      local.get $l3
+      local.get $p1
+      i32.const 1
+      i32.and
+      i32.or
+      i32.const 2
+      i32.or
+      i32.store offset=4
+      local.get $p0
+      local.get $l3
+      i32.add
+      local.tee $p1
+      local.get $l2
+      local.get $l3
+      i32.sub
+      local.tee $l3
+      i32.const 3
+      i32.or
+      i32.store offset=4
+      local.get $p0
+      local.get $l2
+      i32.add
+      local.tee $l2
+      local.get $l2
+      i32.load offset=4
+      i32.const 1
+      i32.or
+      i32.store offset=4
+      local.get $p1
+      local.get $l3
+      call $f148
+    end
+    local.get $p0
+    i32.const 8
+    i32.add)
+  (func $f150 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.const 16
+    i32.le_u
+    if $I0
+      local.get $p1
+      call $f144
+      return
+    end
+    local.get $p0
+    local.get $p1
+    call $f149)
+  (func $f151 (type $t2) (param $p0 i32)
+    local.get $p0
+    call $wasi_snapshot_preview1.proc_exit
+    unreachable)
+  (func $f152 (type $t7)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    i32.const 3
+    local.set $l1
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              loop $L5
+                local.get $l1
+                local.get $l2
+                i32.const 8
+                i32.add
+                call $wasi_snapshot_preview1.fd_prestat_get
+                local.tee $l0
+                i32.const 8
+                i32.gt_u
+                br_if $B3
+                block $B6
+                  block $B7
+                    local.get $l0
+                    i32.const 1
+                    i32.sub
+                    br_table $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B6 $B7
+                  end
+                  local.get $l2
+                  i32.load8_u offset=8
+                  i32.eqz
+                  if $I8
+                    local.get $l2
+                    i32.load offset=12
+                    local.tee $l0
+                    i32.const 1
+                    i32.add
+                    call $f144
+                    local.tee $l3
+                    i32.eqz
+                    br_if $B1
+                    local.get $l1
+                    local.get $l3
+                    local.get $l0
+                    call $wasi_snapshot_preview1.fd_prestat_dir_name
+                    br_if $B4
+                    local.get $l3
+                    local.get $l2
+                    i32.load offset=12
+                    i32.add
+                    i32.const 0
+                    i32.store8
+                    local.get $l1
+                    i32.const -1
+                    i32.le_s
+                    br_if $B0
+                    block $B9
+                      i32.const 1061088
+                      i32.load
+                      local.tee $l0
+                      i32.const 1061084
+                      i32.load
+                      i32.ne
+                      if $I10
+                        i32.const 1061080
+                        i32.load
+                        local.set $l4
+                        br $B9
+                      end
+                      i32.const 8
+                      local.get $l0
+                      i32.const 1
+                      i32.shl
+                      i32.const 4
+                      local.get $l0
+                      select
+                      local.tee $l6
+                      call $f146
+                      local.tee $l4
+                      i32.eqz
+                      br_if $B2
+                      local.get $l4
+                      i32.const 1061080
+                      i32.load
+                      local.tee $l5
+                      local.get $l0
+                      i32.const 3
+                      i32.shl
+                      call $f162
+                      local.set $l0
+                      local.get $l5
+                      call $f145
+                      i32.const 1061084
+                      local.get $l6
+                      i32.store
+                      i32.const 1061080
+                      local.get $l0
+                      i32.store
+                      i32.const 1061088
+                      i32.load
+                      local.set $l0
+                    end
+                    i32.const 1061088
+                    local.get $l0
+                    i32.const 1
+                    i32.add
+                    i32.store
+                    local.get $l4
+                    local.get $l0
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.tee $l0
+                    local.get $l1
+                    i32.store offset=4
+                    local.get $l0
+                    local.get $l3
+                    i32.store
+                  end
+                  local.get $l1
+                  i32.const 1
+                  i32.add
+                  local.tee $l0
+                  local.get $l1
+                  i32.lt_u
+                  local.get $l0
+                  local.set $l1
+                  i32.eqz
+                  br_if $L5
+                end
+              end
+              local.get $l2
+              i32.const 16
+              i32.add
+              global.set $g0
+              return
+            end
+            local.get $l3
+            call $f145
+          end
+          i32.const 71
+          call $f151
+          unreachable
+        end
+        local.get $l3
+        call $f145
+      end
+      i32.const 70
+      call $f151
+      unreachable
+    end
+    unreachable)
+  (func $f153 (type $t5) (param $p0 i32) (result i32)
+    local.get $p0
+    i32.eqz
+    if $I0
+      memory.size
+      i32.const 16
+      i32.shl
+      return
+    end
+    local.get $p0
+    i32.const 65535
+    i32.and
+    local.get $p0
+    i32.const -1
+    i32.le_s
+    i32.or
+    i32.eqz
+    if $I1
+      local.get $p0
+      i32.const 16
+      i32.shr_u
+      memory.grow
+      local.tee $p0
+      i32.const -1
+      i32.eq
+      if $I2
+        i32.const 1061076
+        i32.const 48
+        i32.store
+        i32.const -1
+        return
+      end
+      local.get $p0
+      i32.const 16
+      i32.shl
+      return
+    end
+    unreachable)
+  (func $f154 (type $t7)
+    (local $l0 i32) (local $l1 i32) (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    block $B0
+      block $B1
+        local.get $l0
+        i32.const 12
+        i32.add
+        local.get $l0
+        i32.const 8
+        i32.add
+        call $wasi_snapshot_preview1.environ_sizes_get
+        br_if $B1
+        local.get $l0
+        i32.load offset=12
+        local.tee $l1
+        i32.eqz
+        br_if $B0
+        block $B2
+          block $B3
+            local.get $l1
+            i32.const 1
+            i32.add
+            local.tee $l2
+            local.get $l1
+            i32.lt_u
+            br_if $B3
+            local.get $l0
+            i32.load offset=8
+            call $f144
+            local.tee $l0
+            i32.eqz
+            br_if $B3
+            local.get $l2
+            i32.const 4
+            call $f146
+            local.tee $l1
+            br_if $B2
+            local.get $l0
+            call $f145
+          end
+          i32.const 70
+          call $f151
+          unreachable
+        end
+        local.get $l1
+        local.get $l0
+        call $wasi_snapshot_preview1.environ_get
+        if $I4
+          local.get $l0
+          call $f145
+          local.get $l1
+          call $f145
+          br $B1
+        end
+        i32.const 1060484
+        local.get $l1
+        i32.store
+      end
+      i32.const 71
+      call $f151
+      unreachable
+    end
+    local.get $l0
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f155 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    block $B0
+      local.get $p0
+      call $f161
+      local.tee $l1
+      local.get $p0
+      i32.sub
+      local.tee $l4
+      i32.eqz
+      br_if $B0
+      local.get $l1
+      i32.load8_u
+      br_if $B0
+      i32.const 1060484
+      i32.load
+      local.tee $l2
+      i32.eqz
+      br_if $B0
+      local.get $l2
+      i32.load
+      local.tee $l1
+      i32.eqz
+      br_if $B0
+      local.get $l2
+      i32.const 4
+      i32.add
+      local.set $l2
+      loop $L1
+        block $B2
+          local.get $p0
+          local.get $l1
+          local.get $l4
+          call $f163
+          i32.eqz
+          if $I3
+            local.get $l1
+            local.get $l4
+            i32.add
+            local.tee $l1
+            i32.load8_u
+            i32.const 61
+            i32.eq
+            br_if $B2
+          end
+          local.get $l2
+          i32.load
+          local.set $l1
+          local.get $l2
+          i32.const 4
+          i32.add
+          local.set $l2
+          local.get $l1
+          br_if $L1
+          br $B0
+        end
+      end
+      local.get $l1
+      i32.const 1
+      i32.add
+      local.set $l3
+    end
+    local.get $l3)
+  (func $f156 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    block $B0
+      i32.const 1060484
+      i32.load
+      local.tee $l4
+      i32.eqz
+      br_if $B0
+      local.get $l4
+      i32.load
+      local.tee $l3
+      i32.eqz
+      br_if $B0
+      local.get $p1
+      i32.const 1
+      i32.add
+      local.set $l6
+      local.get $l4
+      local.set $p1
+      loop $L1
+        local.get $p0
+        local.get $l3
+        local.get $l6
+        call $f163
+        i32.eqz
+        if $I2
+          local.get $p1
+          local.get $p0
+          i32.store
+          local.get $l3
+          local.get $p2
+          call $f157
+          i32.const 0
+          return
+        end
+        local.get $l5
+        i32.const 1
+        i32.add
+        local.set $l5
+        local.get $p1
+        i32.load offset=4
+        local.set $l3
+        local.get $p1
+        i32.const 4
+        i32.add
+        local.set $p1
+        local.get $l3
+        br_if $L1
+      end
+    end
+    local.get $l5
+    i32.const 2
+    i32.shl
+    local.tee $l6
+    i32.const 8
+    i32.add
+    local.set $l3
+    block $B3
+      block $B4
+        i32.const 1061096
+        i32.load
+        local.tee $p1
+        local.get $l4
+        i32.eq
+        if $I5
+          local.get $l4
+          local.get $l3
+          call $f147
+          local.tee $l3
+          br_if $B4
+          br $B3
+        end
+        local.get $l3
+        call $f144
+        local.tee $l3
+        i32.eqz
+        br_if $B3
+        local.get $l5
+        if $I6
+          local.get $l3
+          local.get $l4
+          local.get $l6
+          call $f162
+          drop
+        end
+        local.get $p1
+        call $f145
+      end
+      i32.const 1061096
+      local.get $l3
+      i32.store
+      i32.const 1060484
+      local.get $l3
+      i32.store
+      local.get $l3
+      local.get $l5
+      i32.const 2
+      i32.shl
+      i32.add
+      local.tee $p1
+      local.get $p0
+      i32.store
+      local.get $p1
+      i32.const 4
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p2
+      if $I7
+        i32.const 0
+        local.get $p2
+        call $f157
+      end
+      i32.const 0
+      return
+    end
+    local.get $p2
+    call $f145
+    i32.const -1)
+  (func $f157 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    i32.const 1061104
+    i32.load
+    local.tee $l3
+    if $I0
+      i32.const 1061100
+      i32.load
+      local.set $l2
+      loop $L1
+        local.get $p0
+        local.get $l2
+        i32.load
+        local.tee $l4
+        i32.eq
+        if $I2
+          local.get $l2
+          local.get $p1
+          i32.store
+          local.get $p0
+          call $f145
+          return
+        end
+        local.get $p1
+        i32.eqz
+        local.get $l4
+        i32.or
+        i32.eqz
+        if $I3
+          local.get $l2
+          local.get $p1
+          i32.store
+          i32.const 0
+          local.set $p1
+        end
+        local.get $l2
+        i32.const 4
+        i32.add
+        local.set $l2
+        local.get $l5
+        i32.const 1
+        i32.add
+        local.tee $l5
+        local.get $l3
+        i32.lt_u
+        br_if $L1
+      end
+    end
+    block $B4
+      local.get $p1
+      i32.eqz
+      br_if $B4
+      i32.const 1061100
+      i32.load
+      local.get $l3
+      i32.const 2
+      i32.shl
+      i32.const 4
+      i32.add
+      call $f147
+      local.tee $p0
+      i32.eqz
+      br_if $B4
+      i32.const 1061100
+      local.get $p0
+      i32.store
+      i32.const 1061104
+      i32.const 1061104
+      i32.load
+      local.tee $l2
+      i32.const 1
+      i32.add
+      i32.store
+      local.get $p0
+      local.get $l2
+      i32.const 2
+      i32.shl
+      i32.add
+      local.get $p1
+      i32.store
+    end)
+  (func $f158 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    block $B0
+      block $B1
+        local.get $p0
+        i32.eqz
+        br_if $B1
+        local.get $p0
+        call $f161
+        local.tee $l3
+        local.get $p0
+        i32.sub
+        local.tee $l2
+        i32.eqz
+        br_if $B1
+        local.get $l3
+        i32.load8_u
+        i32.eqz
+        br_if $B0
+      end
+      i32.const 1061076
+      i32.const 28
+      i32.store
+      i32.const -1
+      return
+    end
+    local.get $l2
+    local.get $p1
+    call $f160
+    local.tee $l3
+    i32.add
+    i32.const 2
+    i32.add
+    call $f144
+    local.tee $l4
+    i32.eqz
+    if $I2
+      i32.const -1
+      return
+    end
+    local.get $l4
+    local.get $p0
+    local.get $l2
+    call $f162
+    local.tee $p0
+    local.get $l2
+    i32.add
+    local.tee $l4
+    i32.const 61
+    i32.store8
+    local.get $l4
+    i32.const 1
+    i32.add
+    local.get $p1
+    local.get $l3
+    i32.const 1
+    i32.add
+    call $f162
+    drop
+    local.get $p0
+    local.get $l2
+    local.get $p0
+    call $f156)
+  (func $f159 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    block $B0
+      local.get $p0
+      local.get $p1
+      i32.eq
+      br_if $B0
+      local.get $p1
+      local.get $p0
+      i32.sub
+      local.get $p2
+      i32.sub
+      i32.const 0
+      local.get $p2
+      i32.const 1
+      i32.shl
+      i32.sub
+      i32.le_u
+      if $I1
+        local.get $p0
+        local.get $p1
+        local.get $p2
+        call $f162
+        drop
+        br $B0
+      end
+      local.get $p0
+      local.get $p1
+      i32.xor
+      i32.const 3
+      i32.and
+      local.set $l3
+      block $B2
+        block $B3
+          local.get $p0
+          local.get $p1
+          i32.lt_u
+          if $I4
+            local.get $l3
+            if $I5
+              local.get $p0
+              local.set $l3
+              br $B2
+            end
+            local.get $p0
+            i32.const 3
+            i32.and
+            i32.eqz
+            if $I6
+              local.get $p0
+              local.set $l3
+              br $B3
+            end
+            local.get $p0
+            local.set $l3
+            loop $L7
+              local.get $p2
+              i32.eqz
+              br_if $B0
+              local.get $l3
+              local.get $p1
+              i32.load8_u
+              i32.store8
+              local.get $p1
+              i32.const 1
+              i32.add
+              local.set $p1
+              local.get $p2
+              i32.const -1
+              i32.add
+              local.set $p2
+              local.get $l3
+              i32.const 1
+              i32.add
+              local.tee $l3
+              i32.const 3
+              i32.and
+              br_if $L7
+            end
+            br $B3
+          end
+          block $B8
+            local.get $l3
+            if $I9
+              local.get $p2
+              local.set $l3
+              br $B8
+            end
+            block $B10
+              local.get $p0
+              local.get $p2
+              i32.add
+              i32.const 3
+              i32.and
+              i32.eqz
+              if $I11
+                local.get $p2
+                local.set $l3
+                br $B10
+              end
+              local.get $p1
+              i32.const -1
+              i32.add
+              local.set $l4
+              local.get $p0
+              i32.const -1
+              i32.add
+              local.set $l5
+              loop $L12
+                local.get $p2
+                i32.eqz
+                br_if $B0
+                local.get $p2
+                local.get $l5
+                i32.add
+                local.tee $l6
+                local.get $p2
+                local.get $l4
+                i32.add
+                i32.load8_u
+                i32.store8
+                local.get $p2
+                i32.const -1
+                i32.add
+                local.tee $l3
+                local.set $p2
+                local.get $l6
+                i32.const 3
+                i32.and
+                br_if $L12
+              end
+            end
+            local.get $l3
+            i32.const 4
+            i32.lt_u
+            br_if $B8
+            local.get $p0
+            i32.const -4
+            i32.add
+            local.set $p2
+            local.get $p1
+            i32.const -4
+            i32.add
+            local.set $l4
+            loop $L13
+              local.get $p2
+              local.get $l3
+              i32.add
+              local.get $l3
+              local.get $l4
+              i32.add
+              i32.load
+              i32.store
+              local.get $l3
+              i32.const -4
+              i32.add
+              local.tee $l3
+              i32.const 3
+              i32.gt_u
+              br_if $L13
+            end
+          end
+          local.get $l3
+          i32.eqz
+          br_if $B0
+          local.get $p1
+          i32.const -1
+          i32.add
+          local.set $p1
+          local.get $p0
+          i32.const -1
+          i32.add
+          local.set $p0
+          loop $L14
+            local.get $p0
+            local.get $l3
+            i32.add
+            local.get $p1
+            local.get $l3
+            i32.add
+            i32.load8_u
+            i32.store8
+            local.get $l3
+            i32.const -1
+            i32.add
+            local.tee $l3
+            br_if $L14
+          end
+          br $B0
+        end
+        local.get $p2
+        i32.const 4
+        i32.lt_u
+        br_if $B2
+        local.get $p2
+        local.set $p0
+        loop $L15
+          local.get $l3
+          local.get $p1
+          i32.load
+          i32.store
+          local.get $p1
+          i32.const 4
+          i32.add
+          local.set $p1
+          local.get $l3
+          i32.const 4
+          i32.add
+          local.set $l3
+          local.get $p0
+          i32.const -4
+          i32.add
+          local.tee $p0
+          i32.const 3
+          i32.gt_u
+          br_if $L15
+        end
+        local.get $p2
+        i32.const 3
+        i32.and
+        local.set $p2
+      end
+      local.get $p2
+      i32.eqz
+      br_if $B0
+      loop $L16
+        local.get $l3
+        local.get $p1
+        i32.load8_u
+        i32.store8
+        local.get $l3
+        i32.const 1
+        i32.add
+        local.set $l3
+        local.get $p1
+        i32.const 1
+        i32.add
+        local.set $p1
+        local.get $p2
+        i32.const -1
+        i32.add
+        local.tee $p2
+        br_if $L16
+      end
+    end)
+  (func $f160 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32)
+    block $B0
+      block $B1
+        block $B2
+          local.get $p0
+          local.tee $l1
+          i32.const 3
+          i32.and
+          i32.eqz
+          br_if $B2
+          local.get $p0
+          i32.load8_u
+          i32.eqz
+          if $I3
+            i32.const 0
+            return
+          end
+          local.get $p0
+          i32.const 1
+          i32.add
+          local.set $l1
+          loop $L4
+            local.get $l1
+            i32.const 3
+            i32.and
+            i32.eqz
+            br_if $B2
+            local.get $l1
+            i32.load8_u
+            local.get $l1
+            i32.const 1
+            i32.add
+            local.tee $l3
+            local.set $l1
+            br_if $L4
+          end
+          br $B1
+        end
+        local.get $l1
+        i32.const -4
+        i32.add
+        local.set $l1
+        loop $L5
+          local.get $l1
+          i32.const 4
+          i32.add
+          local.tee $l1
+          i32.load
+          local.tee $l2
+          i32.const -1
+          i32.xor
+          local.get $l2
+          i32.const -16843009
+          i32.add
+          i32.and
+          i32.const -2139062144
+          i32.and
+          i32.eqz
+          br_if $L5
+        end
+        local.get $l2
+        i32.const 255
+        i32.and
+        i32.eqz
+        if $I6
+          local.get $l1
+          local.get $p0
+          i32.sub
+          return
+        end
+        loop $L7
+          local.get $l1
+          i32.load8_u offset=1
+          local.get $l1
+          i32.const 1
+          i32.add
+          local.tee $l2
+          local.set $l1
+          br_if $L7
+        end
+        br $B0
+      end
+      local.get $l3
+      i32.const -1
+      i32.add
+      local.set $l2
+    end
+    local.get $l2
+    local.get $p0
+    i32.sub)
+  (func $f161 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    block $B0
+      local.get $p0
+      i32.const 3
+      i32.and
+      if $I1
+        loop $L2
+          local.get $p0
+          i32.load8_u
+          local.tee $l1
+          i32.eqz
+          local.get $l1
+          i32.const 61
+          i32.eq
+          i32.or
+          br_if $B0
+          local.get $p0
+          i32.const 1
+          i32.add
+          local.tee $p0
+          i32.const 3
+          i32.and
+          br_if $L2
+        end
+      end
+      block $B3
+        local.get $p0
+        i32.load
+        local.tee $l1
+        i32.const -1
+        i32.xor
+        local.get $l1
+        i32.const -16843009
+        i32.add
+        i32.and
+        i32.const -2139062144
+        i32.and
+        br_if $B3
+        loop $L4
+          local.get $l1
+          i32.const 1027423549
+          i32.xor
+          local.tee $l1
+          i32.const -1
+          i32.xor
+          local.get $l1
+          i32.const -16843009
+          i32.add
+          i32.and
+          i32.const -2139062144
+          i32.and
+          br_if $B3
+          local.get $p0
+          i32.load offset=4
+          local.set $l1
+          local.get $p0
+          i32.const 4
+          i32.add
+          local.set $p0
+          local.get $l1
+          i32.const -16843009
+          i32.add
+          local.get $l1
+          i32.const -1
+          i32.xor
+          i32.and
+          i32.const -2139062144
+          i32.and
+          i32.eqz
+          br_if $L4
+        end
+      end
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.set $p0
+      loop $L5
+        local.get $p0
+        i32.const 1
+        i32.add
+        local.tee $p0
+        i32.load8_u
+        local.tee $l1
+        i32.eqz
+        br_if $B0
+        local.get $l1
+        i32.const 61
+        i32.ne
+        br_if $L5
+      end
+    end
+    local.get $p0)
+  (func $f162 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32)
+    block $B0
+      local.get $p2
+      i32.eqz
+      local.get $p1
+      i32.const 3
+      i32.and
+      i32.eqz
+      i32.or
+      i32.eqz
+      if $I1
+        local.get $p0
+        local.set $l3
+        loop $L2
+          local.get $l3
+          local.get $p1
+          i32.load8_u
+          i32.store8
+          local.get $p2
+          i32.const -1
+          i32.add
+          local.set $l4
+          local.get $l3
+          i32.const 1
+          i32.add
+          local.set $l3
+          local.get $p1
+          i32.const 1
+          i32.add
+          local.set $p1
+          local.get $p2
+          i32.const 1
+          i32.eq
+          br_if $B0
+          local.get $l4
+          local.set $p2
+          local.get $p1
+          i32.const 3
+          i32.and
+          br_if $L2
+        end
+        br $B0
+      end
+      local.get $p2
+      local.set $l4
+      local.get $p0
+      local.set $l3
+    end
+    block $B3
+      local.get $l3
+      i32.const 3
+      i32.and
+      local.tee $p2
+      i32.eqz
+      if $I4
+        block $B5
+          local.get $l4
+          i32.const 16
+          i32.lt_u
+          if $I6
+            local.get $l4
+            local.set $p2
+            br $B5
+          end
+          local.get $l4
+          i32.const -16
+          i32.add
+          local.set $p2
+          loop $L7
+            local.get $l3
+            local.get $p1
+            i32.load
+            i32.store
+            local.get $l3
+            i32.const 4
+            i32.add
+            local.get $p1
+            i32.const 4
+            i32.add
+            i32.load
+            i32.store
+            local.get $l3
+            i32.const 8
+            i32.add
+            local.get $p1
+            i32.const 8
+            i32.add
+            i32.load
+            i32.store
+            local.get $l3
+            i32.const 12
+            i32.add
+            local.get $p1
+            i32.const 12
+            i32.add
+            i32.load
+            i32.store
+            local.get $l3
+            i32.const 16
+            i32.add
+            local.set $l3
+            local.get $p1
+            i32.const 16
+            i32.add
+            local.set $p1
+            local.get $l4
+            i32.const -16
+            i32.add
+            local.tee $l4
+            i32.const 15
+            i32.gt_u
+            br_if $L7
+          end
+        end
+        local.get $p2
+        i32.const 8
+        i32.and
+        if $I8
+          local.get $l3
+          local.get $p1
+          i64.load align=4
+          i64.store align=4
+          local.get $l3
+          i32.const 8
+          i32.add
+          local.set $l3
+          local.get $p1
+          i32.const 8
+          i32.add
+          local.set $p1
+        end
+        local.get $p2
+        i32.const 4
+        i32.and
+        if $I9
+          local.get $l3
+          local.get $p1
+          i32.load
+          i32.store
+          local.get $l3
+          i32.const 4
+          i32.add
+          local.set $l3
+          local.get $p1
+          i32.const 4
+          i32.add
+          local.set $p1
+        end
+        local.get $p2
+        i32.const 2
+        i32.and
+        if $I10
+          local.get $l3
+          local.get $p1
+          i32.load8_u
+          i32.store8
+          local.get $l3
+          local.get $p1
+          i32.load8_u offset=1
+          i32.store8 offset=1
+          local.get $l3
+          i32.const 2
+          i32.add
+          local.set $l3
+          local.get $p1
+          i32.const 2
+          i32.add
+          local.set $p1
+        end
+        local.get $p2
+        i32.const 1
+        i32.and
+        i32.eqz
+        br_if $B3
+        local.get $l3
+        local.get $p1
+        i32.load8_u
+        i32.store8
+        local.get $p0
+        return
+      end
+      block $B11
+        local.get $l4
+        i32.const 32
+        i32.lt_u
+        br_if $B11
+        local.get $p2
+        i32.const -1
+        i32.add
+        local.tee $p2
+        i32.const 2
+        i32.gt_u
+        br_if $B11
+        block $B12
+          block $B13
+            block $B14
+              local.get $p2
+              i32.const 1
+              i32.sub
+              br_table $B13 $B12 $B14
+            end
+            local.get $l3
+            local.get $p1
+            i32.load8_u offset=1
+            i32.store8 offset=1
+            local.get $l3
+            local.get $p1
+            i32.load
+            local.tee $l5
+            i32.store8
+            local.get $l3
+            local.get $p1
+            i32.load8_u offset=2
+            i32.store8 offset=2
+            local.get $l4
+            i32.const -3
+            i32.add
+            local.set $l8
+            local.get $l3
+            i32.const 3
+            i32.add
+            local.set $l9
+            local.get $l4
+            i32.const -20
+            i32.add
+            i32.const -16
+            i32.and
+            local.set $l10
+            i32.const 0
+            local.set $p2
+            loop $L15
+              local.get $p2
+              local.get $l9
+              i32.add
+              local.tee $l3
+              local.get $p1
+              local.get $p2
+              i32.add
+              local.tee $l6
+              i32.const 4
+              i32.add
+              i32.load
+              local.tee $l7
+              i32.const 8
+              i32.shl
+              local.get $l5
+              i32.const 24
+              i32.shr_u
+              i32.or
+              i32.store
+              local.get $l3
+              i32.const 4
+              i32.add
+              local.get $l6
+              i32.const 8
+              i32.add
+              i32.load
+              local.tee $l5
+              i32.const 8
+              i32.shl
+              local.get $l7
+              i32.const 24
+              i32.shr_u
+              i32.or
+              i32.store
+              local.get $l3
+              i32.const 8
+              i32.add
+              local.get $l6
+              i32.const 12
+              i32.add
+              i32.load
+              local.tee $l7
+              i32.const 8
+              i32.shl
+              local.get $l5
+              i32.const 24
+              i32.shr_u
+              i32.or
+              i32.store
+              local.get $l3
+              i32.const 12
+              i32.add
+              local.get $l6
+              i32.const 16
+              i32.add
+              i32.load
+              local.tee $l5
+              i32.const 8
+              i32.shl
+              local.get $l7
+              i32.const 24
+              i32.shr_u
+              i32.or
+              i32.store
+              local.get $p2
+              i32.const 16
+              i32.add
+              local.set $p2
+              local.get $l8
+              i32.const -16
+              i32.add
+              local.tee $l8
+              i32.const 16
+              i32.gt_u
+              br_if $L15
+            end
+            local.get $p2
+            local.get $l9
+            i32.add
+            local.set $l3
+            local.get $p1
+            local.get $p2
+            i32.add
+            i32.const 3
+            i32.add
+            local.set $p1
+            local.get $l4
+            local.get $l10
+            i32.sub
+            i32.const -19
+            i32.add
+            local.set $l4
+            br $B11
+          end
+          local.get $l3
+          local.get $p1
+          i32.load
+          local.tee $l5
+          i32.store8
+          local.get $l3
+          local.get $p1
+          i32.load8_u offset=1
+          i32.store8 offset=1
+          local.get $l4
+          i32.const -2
+          i32.add
+          local.set $l8
+          local.get $l3
+          i32.const 2
+          i32.add
+          local.set $l9
+          local.get $l4
+          i32.const -20
+          i32.add
+          i32.const -16
+          i32.and
+          local.set $l10
+          i32.const 0
+          local.set $p2
+          loop $L16
+            local.get $p2
+            local.get $l9
+            i32.add
+            local.tee $l3
+            local.get $p1
+            local.get $p2
+            i32.add
+            local.tee $l6
+            i32.const 4
+            i32.add
+            i32.load
+            local.tee $l7
+            i32.const 16
+            i32.shl
+            local.get $l5
+            i32.const 16
+            i32.shr_u
+            i32.or
+            i32.store
+            local.get $l3
+            i32.const 4
+            i32.add
+            local.get $l6
+            i32.const 8
+            i32.add
+            i32.load
+            local.tee $l5
+            i32.const 16
+            i32.shl
+            local.get $l7
+            i32.const 16
+            i32.shr_u
+            i32.or
+            i32.store
+            local.get $l3
+            i32.const 8
+            i32.add
+            local.get $l6
+            i32.const 12
+            i32.add
+            i32.load
+            local.tee $l7
+            i32.const 16
+            i32.shl
+            local.get $l5
+            i32.const 16
+            i32.shr_u
+            i32.or
+            i32.store
+            local.get $l3
+            i32.const 12
+            i32.add
+            local.get $l6
+            i32.const 16
+            i32.add
+            i32.load
+            local.tee $l5
+            i32.const 16
+            i32.shl
+            local.get $l7
+            i32.const 16
+            i32.shr_u
+            i32.or
+            i32.store
+            local.get $p2
+            i32.const 16
+            i32.add
+            local.set $p2
+            local.get $l8
+            i32.const -16
+            i32.add
+            local.tee $l8
+            i32.const 17
+            i32.gt_u
+            br_if $L16
+          end
+          local.get $p2
+          local.get $l9
+          i32.add
+          local.set $l3
+          local.get $p1
+          local.get $p2
+          i32.add
+          i32.const 2
+          i32.add
+          local.set $p1
+          local.get $l4
+          local.get $l10
+          i32.sub
+          i32.const -18
+          i32.add
+          local.set $l4
+          br $B11
+        end
+        local.get $l3
+        local.get $p1
+        i32.load
+        local.tee $l5
+        i32.store8
+        local.get $l4
+        i32.const -1
+        i32.add
+        local.set $l8
+        local.get $l3
+        i32.const 1
+        i32.add
+        local.set $l9
+        local.get $l4
+        i32.const -20
+        i32.add
+        i32.const -16
+        i32.and
+        local.set $l10
+        i32.const 0
+        local.set $p2
+        loop $L17
+          local.get $p2
+          local.get $l9
+          i32.add
+          local.tee $l3
+          local.get $p1
+          local.get $p2
+          i32.add
+          local.tee $l6
+          i32.const 4
+          i32.add
+          i32.load
+          local.tee $l7
+          i32.const 24
+          i32.shl
+          local.get $l5
+          i32.const 8
+          i32.shr_u
+          i32.or
+          i32.store
+          local.get $l3
+          i32.const 4
+          i32.add
+          local.get $l6
+          i32.const 8
+          i32.add
+          i32.load
+          local.tee $l5
+          i32.const 24
+          i32.shl
+          local.get $l7
+          i32.const 8
+          i32.shr_u
+          i32.or
+          i32.store
+          local.get $l3
+          i32.const 8
+          i32.add
+          local.get $l6
+          i32.const 12
+          i32.add
+          i32.load
+          local.tee $l7
+          i32.const 24
+          i32.shl
+          local.get $l5
+          i32.const 8
+          i32.shr_u
+          i32.or
+          i32.store
+          local.get $l3
+          i32.const 12
+          i32.add
+          local.get $l6
+          i32.const 16
+          i32.add
+          i32.load
+          local.tee $l5
+          i32.const 24
+          i32.shl
+          local.get $l7
+          i32.const 8
+          i32.shr_u
+          i32.or
+          i32.store
+          local.get $p2
+          i32.const 16
+          i32.add
+          local.set $p2
+          local.get $l8
+          i32.const -16
+          i32.add
+          local.tee $l8
+          i32.const 18
+          i32.gt_u
+          br_if $L17
+        end
+        local.get $p2
+        local.get $l9
+        i32.add
+        local.set $l3
+        local.get $p1
+        local.get $p2
+        i32.add
+        i32.const 1
+        i32.add
+        local.set $p1
+        local.get $l4
+        local.get $l10
+        i32.sub
+        i32.const -17
+        i32.add
+        local.set $l4
+      end
+      local.get $l4
+      i32.const 16
+      i32.and
+      if $I18
+        local.get $l3
+        local.get $p1
+        i32.load16_u align=1
+        i32.store16 align=1
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=2
+        i32.store8 offset=2
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=3
+        i32.store8 offset=3
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=4
+        i32.store8 offset=4
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=5
+        i32.store8 offset=5
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=6
+        i32.store8 offset=6
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=7
+        i32.store8 offset=7
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=8
+        i32.store8 offset=8
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=9
+        i32.store8 offset=9
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=10
+        i32.store8 offset=10
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=11
+        i32.store8 offset=11
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=12
+        i32.store8 offset=12
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=13
+        i32.store8 offset=13
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=14
+        i32.store8 offset=14
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=15
+        i32.store8 offset=15
+        local.get $l3
+        i32.const 16
+        i32.add
+        local.set $l3
+        local.get $p1
+        i32.const 16
+        i32.add
+        local.set $p1
+      end
+      local.get $l4
+      i32.const 8
+      i32.and
+      if $I19
+        local.get $l3
+        local.get $p1
+        i32.load8_u
+        i32.store8
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=1
+        i32.store8 offset=1
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=2
+        i32.store8 offset=2
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=3
+        i32.store8 offset=3
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=4
+        i32.store8 offset=4
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=5
+        i32.store8 offset=5
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=6
+        i32.store8 offset=6
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=7
+        i32.store8 offset=7
+        local.get $l3
+        i32.const 8
+        i32.add
+        local.set $l3
+        local.get $p1
+        i32.const 8
+        i32.add
+        local.set $p1
+      end
+      local.get $l4
+      i32.const 4
+      i32.and
+      if $I20
+        local.get $l3
+        local.get $p1
+        i32.load8_u
+        i32.store8
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=1
+        i32.store8 offset=1
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=2
+        i32.store8 offset=2
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=3
+        i32.store8 offset=3
+        local.get $l3
+        i32.const 4
+        i32.add
+        local.set $l3
+        local.get $p1
+        i32.const 4
+        i32.add
+        local.set $p1
+      end
+      local.get $l4
+      i32.const 2
+      i32.and
+      if $I21
+        local.get $l3
+        local.get $p1
+        i32.load8_u
+        i32.store8
+        local.get $l3
+        local.get $p1
+        i32.load8_u offset=1
+        i32.store8 offset=1
+        local.get $l3
+        i32.const 2
+        i32.add
+        local.set $l3
+        local.get $p1
+        i32.const 2
+        i32.add
+        local.set $p1
+      end
+      local.get $l4
+      i32.const 1
+      i32.and
+      i32.eqz
+      br_if $B3
+      local.get $l3
+      local.get $p1
+      i32.load8_u
+      i32.store8
+    end
+    local.get $p0)
+  (func $f163 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    local.get $p2
+    i32.eqz
+    if $I0
+      i32.const 0
+      return
+    end
+    block $B1
+      local.get $p0
+      i32.load8_u
+      local.tee $l3
+      i32.eqz
+      br_if $B1
+      local.get $p0
+      i32.const 1
+      i32.add
+      local.set $p0
+      local.get $p2
+      i32.const -1
+      i32.add
+      local.set $p2
+      loop $L2
+        local.get $p1
+        i32.load8_u
+        local.tee $l5
+        local.get $l3
+        i32.ne
+        if $I3
+          local.get $l3
+          local.set $l4
+          br $B1
+        end
+        local.get $p2
+        i32.eqz
+        if $I4
+          local.get $l3
+          local.set $l4
+          br $B1
+        end
+        local.get $l5
+        i32.eqz
+        if $I5
+          local.get $l3
+          local.set $l4
+          br $B1
+        end
+        local.get $p2
+        i32.const -1
+        i32.add
+        local.set $p2
+        local.get $p1
+        i32.const 1
+        i32.add
+        local.set $p1
+        local.get $p0
+        i32.load8_u
+        local.set $l3
+        local.get $p0
+        i32.const 1
+        i32.add
+        local.set $p0
+        local.get $l3
+        br_if $L2
+      end
+    end
+    local.get $l4
+    i32.const 255
+    i32.and
+    local.get $p1
+    i32.load8_u
+    i32.sub)
+  (func $f164 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    i32.const 1061132
+    i32.load
+    local.tee $l2
+    i32.eqz
+    if $I0
+      i32.const 1061132
+      i32.const 1061108
+      i32.store
+      i32.const 1061108
+      local.set $l2
+    end
+    block $B1
+      block $B2
+        loop $L3
+          local.get $p0
+          local.get $l1
+          i32.const 1052624
+          i32.add
+          i32.load8_u
+          i32.ne
+          if $I4
+            i32.const 77
+            local.set $l3
+            local.get $l1
+            i32.const 1
+            i32.add
+            local.tee $l1
+            i32.const 77
+            i32.ne
+            br_if $L3
+            br $B2
+          end
+        end
+        local.get $l1
+        local.tee $l3
+        br_if $B2
+        i32.const 1052704
+        local.set $p0
+        br $B1
+      end
+      i32.const 1052704
+      local.set $l1
+      loop $L5
+        local.get $l1
+        i32.load8_u
+        local.get $l1
+        i32.const 1
+        i32.add
+        local.tee $p0
+        local.set $l1
+        br_if $L5
+        local.get $p0
+        local.set $l1
+        local.get $l3
+        i32.const -1
+        i32.add
+        local.tee $l3
+        br_if $L5
+      end
+    end
+    local.get $l2
+    i32.load offset=20
+    drop
+    local.get $p0)
+  (func $f165 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    local.get $p0
+    call $f164
+    local.tee $p0
+    call $f160
+    local.tee $l2
+    i32.const 1024
+    i32.ge_u
+    if $I0
+      local.get $p1
+      local.get $p0
+      i32.const 1023
+      call $f162
+      i32.const 1023
+      i32.add
+      i32.const 0
+      i32.store8
+      i32.const 68
+      return
+    end
+    local.get $p1
+    local.get $p0
+    local.get $l2
+    i32.const 1
+    i32.add
+    call $f162
+    drop
+    i32.const 0)
+  (func $f166 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    block $B0
+      local.get $p1
+      i32.eqz
+      br_if $B0
+      local.get $p0
+      i32.const 0
+      i32.store8
+      local.get $p0
+      local.get $p1
+      i32.add
+      local.tee $l2
+      i32.const -1
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $p1
+      i32.const 3
+      i32.lt_u
+      br_if $B0
+      local.get $p0
+      i32.const 0
+      i32.store8 offset=2
+      local.get $p0
+      i32.const 0
+      i32.store8 offset=1
+      local.get $l2
+      i32.const -3
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $l2
+      i32.const -2
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $p1
+      i32.const 7
+      i32.lt_u
+      br_if $B0
+      local.get $p0
+      i32.const 0
+      i32.store8 offset=3
+      local.get $l2
+      i32.const -4
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $p1
+      i32.const 9
+      i32.lt_u
+      br_if $B0
+      local.get $p0
+      i32.const 0
+      local.get $p0
+      i32.sub
+      i32.const 3
+      i32.and
+      local.tee $l3
+      i32.add
+      local.tee $l2
+      i32.const 0
+      i32.store
+      local.get $l2
+      local.get $p1
+      local.get $l3
+      i32.sub
+      i32.const -4
+      i32.and
+      local.tee $l3
+      i32.add
+      local.tee $p1
+      i32.const -4
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $l3
+      i32.const 9
+      i32.lt_u
+      br_if $B0
+      local.get $l2
+      i32.const 0
+      i32.store offset=8
+      local.get $l2
+      i32.const 0
+      i32.store offset=4
+      local.get $p1
+      i32.const -8
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p1
+      i32.const -12
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $l3
+      i32.const 25
+      i32.lt_u
+      br_if $B0
+      local.get $l2
+      i32.const 0
+      i32.store offset=24
+      local.get $l2
+      i32.const 0
+      i32.store offset=20
+      local.get $l2
+      i32.const 0
+      i32.store offset=16
+      local.get $l2
+      i32.const 0
+      i32.store offset=12
+      local.get $p1
+      i32.const -16
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p1
+      i32.const -20
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p1
+      i32.const -24
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $p1
+      i32.const -28
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $l3
+      local.get $l2
+      i32.const 4
+      i32.and
+      i32.const 24
+      i32.or
+      local.tee $l3
+      i32.sub
+      local.tee $p1
+      i32.const 32
+      i32.lt_u
+      br_if $B0
+      local.get $l2
+      local.get $l3
+      i32.add
+      local.set $l2
+      loop $L1
+        local.get $l2
+        i64.const 0
+        i64.store
+        local.get $l2
+        i32.const 24
+        i32.add
+        i64.const 0
+        i64.store
+        local.get $l2
+        i32.const 16
+        i32.add
+        i64.const 0
+        i64.store
+        local.get $l2
+        i32.const 8
+        i32.add
+        i64.const 0
+        i64.store
+        local.get $l2
+        i32.const 32
+        i32.add
+        local.set $l2
+        local.get $p1
+        i32.const -32
+        i32.add
+        local.tee $p1
+        i32.const 31
+        i32.gt_u
+        br_if $L1
+      end
+    end
+    local.get $p0)
+  (func $f167 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32)
+    block $B0
+      local.get $p2
+      i32.eqz
+      br_if $B0
+      loop $L1
+        local.get $p0
+        i32.load8_u
+        local.tee $l4
+        local.get $p1
+        i32.load8_u
+        local.tee $l5
+        i32.eq
+        if $I2
+          local.get $p1
+          i32.const 1
+          i32.add
+          local.set $p1
+          local.get $p0
+          i32.const 1
+          i32.add
+          local.set $p0
+          local.get $p2
+          i32.const -1
+          i32.add
+          local.tee $p2
+          br_if $L1
+          br $B0
+        end
+      end
+      local.get $l4
+      local.get $l5
+      i32.sub
+      local.set $l3
+    end
+    local.get $l3)
+  (func $f168 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p1
+    i32.const 1060508
+    i32.load
+    local.tee $p0
+    i32.const 21
+    local.get $p0
+    select
+    call_indirect (type $t3) $T0
+    unreachable)
+  (func $f169 (type $t7)
+    i32.const 1054301
+    i32.const 17
+    i32.const 1054320
+    call $f172
+    unreachable)
+  (func $f170 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p1
+    i64.load align=4
+    i64.store align=4
+    local.get $p0
+    i32.const 8
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i32.load
+    i32.store)
+  (func $f171 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    local.get $p2
+    i32.store offset=4
+    local.get $l3
+    local.get $p1
+    i32.store
+    local.get $l3
+    i32.const 28
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l3
+    i32.const 44
+    i32.add
+    i32.const 20
+    i32.store
+    local.get $l3
+    i64.const 2
+    i64.store offset=12 align=4
+    local.get $l3
+    i32.const 1054472
+    i32.store offset=8
+    local.get $l3
+    i32.const 20
+    i32.store offset=36
+    local.get $l3
+    local.get $l3
+    i32.const 32
+    i32.add
+    i32.store offset=24
+    local.get $l3
+    local.get $l3
+    i32.store offset=40
+    local.get $l3
+    local.get $l3
+    i32.const 4
+    i32.add
+    i32.store offset=32
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p0
+    call $f177
+    unreachable)
+  (func $f172 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i64.const 4
+    i64.store offset=16
+    local.get $l3
+    i64.const 1
+    i64.store offset=4 align=4
+    local.get $l3
+    local.get $p1
+    i32.store offset=28
+    local.get $l3
+    local.get $p0
+    i32.store offset=24
+    local.get $l3
+    local.get $l3
+    i32.const 24
+    i32.add
+    i32.store
+    local.get $l3
+    local.get $p2
+    call $f177
+    unreachable)
+  (func $f173 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p1
+    i32.store offset=4
+    local.get $l2
+    local.get $p0
+    i32.store
+    local.get $l2
+    i32.const 28
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l2
+    i32.const 44
+    i32.add
+    i32.const 20
+    i32.store
+    local.get $l2
+    i64.const 2
+    i64.store offset=12 align=4
+    local.get $l2
+    i32.const 1054716
+    i32.store offset=8
+    local.get $l2
+    i32.const 20
+    i32.store offset=36
+    local.get $l2
+    local.get $l2
+    i32.const 32
+    i32.add
+    i32.store offset=24
+    local.get $l2
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.store offset=40
+    local.get $l2
+    local.get $l2
+    i32.store offset=32
+    local.get $l2
+    i32.const 8
+    i32.add
+    i32.const 1054732
+    call $f177
+    unreachable)
+  (func $f174 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p1
+    i32.store offset=4
+    local.get $l2
+    local.get $p0
+    i32.store
+    local.get $l2
+    i32.const 28
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l2
+    i32.const 44
+    i32.add
+    i32.const 20
+    i32.store
+    local.get $l2
+    i64.const 2
+    i64.store offset=12 align=4
+    local.get $l2
+    i32.const 1054784
+    i32.store offset=8
+    local.get $l2
+    i32.const 20
+    i32.store offset=36
+    local.get $l2
+    local.get $l2
+    i32.const 32
+    i32.add
+    i32.store offset=24
+    local.get $l2
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.store offset=40
+    local.get $l2
+    local.get $l2
+    i32.store offset=32
+    local.get $l2
+    i32.const 8
+    i32.add
+    i32.const 1054800
+    call $f177
+    unreachable)
+  (func $f175 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i32) (local $l14 i32)
+    local.get $p0
+    i32.load offset=16
+    local.set $l3
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p0
+            i32.load offset=8
+            local.tee $l13
+            i32.const 1
+            i32.ne
+            if $I4
+              local.get $l3
+              br_if $B3
+              local.get $p0
+              i32.load offset=24
+              local.get $p1
+              local.get $p2
+              local.get $p0
+              i32.const 28
+              i32.add
+              i32.load
+              i32.load offset=12
+              call_indirect (type $t1) $T0
+              local.set $l3
+              br $B1
+            end
+            local.get $l3
+            i32.eqz
+            br_if $B2
+          end
+          block $B5
+            local.get $p2
+            i32.eqz
+            if $I6
+              i32.const 0
+              local.set $p2
+              br $B5
+            end
+            local.get $p1
+            local.get $p2
+            i32.add
+            local.set $l7
+            local.get $p0
+            i32.const 20
+            i32.add
+            i32.load
+            i32.const 1
+            i32.add
+            local.set $l10
+            local.get $p1
+            local.tee $l3
+            local.set $l11
+            loop $L7
+              local.get $l3
+              i32.const 1
+              i32.add
+              local.set $l5
+              block $B8
+                block $B9 (result i32)
+                  local.get $l3
+                  i32.load8_s
+                  local.tee $l4
+                  i32.const -1
+                  i32.le_s
+                  if $I10
+                    block $B11 (result i32)
+                      local.get $l5
+                      local.get $l7
+                      i32.eq
+                      if $I12
+                        i32.const 0
+                        local.set $l8
+                        local.get $l7
+                        br $B11
+                      end
+                      local.get $l3
+                      i32.load8_u offset=1
+                      i32.const 63
+                      i32.and
+                      local.set $l8
+                      local.get $l3
+                      i32.const 2
+                      i32.add
+                      local.tee $l5
+                    end
+                    local.set $l3
+                    local.get $l4
+                    i32.const 31
+                    i32.and
+                    local.set $l9
+                    local.get $l8
+                    local.get $l9
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    local.get $l4
+                    i32.const 255
+                    i32.and
+                    local.tee $l14
+                    i32.const 223
+                    i32.le_u
+                    br_if $B9
+                    drop
+                    block $B13 (result i32)
+                      local.get $l3
+                      local.get $l7
+                      i32.eq
+                      if $I14
+                        i32.const 0
+                        local.set $l12
+                        local.get $l7
+                        br $B13
+                      end
+                      local.get $l3
+                      i32.load8_u
+                      i32.const 63
+                      i32.and
+                      local.set $l12
+                      local.get $l3
+                      i32.const 1
+                      i32.add
+                      local.tee $l5
+                    end
+                    local.set $l4
+                    local.get $l12
+                    local.get $l8
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    local.set $l8
+                    local.get $l8
+                    local.get $l9
+                    i32.const 12
+                    i32.shl
+                    i32.or
+                    local.get $l14
+                    i32.const 240
+                    i32.lt_u
+                    br_if $B9
+                    drop
+                    block $B15 (result i32)
+                      local.get $l4
+                      local.get $l7
+                      i32.eq
+                      if $I16
+                        local.get $l5
+                        local.set $l3
+                        i32.const 0
+                        br $B15
+                      end
+                      local.get $l4
+                      i32.const 1
+                      i32.add
+                      local.set $l3
+                      local.get $l4
+                      i32.load8_u
+                      i32.const 63
+                      i32.and
+                    end
+                    local.get $l9
+                    i32.const 18
+                    i32.shl
+                    i32.const 1835008
+                    i32.and
+                    local.get $l8
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    i32.or
+                    local.tee $l4
+                    i32.const 1114112
+                    i32.ne
+                    br_if $B8
+                    br $B5
+                  end
+                  local.get $l4
+                  i32.const 255
+                  i32.and
+                end
+                local.set $l4
+                local.get $l5
+                local.set $l3
+              end
+              local.get $l10
+              i32.const -1
+              i32.add
+              local.tee $l10
+              if $I17
+                local.get $l6
+                local.get $l11
+                i32.sub
+                local.get $l3
+                i32.add
+                local.set $l6
+                local.get $l3
+                local.set $l11
+                local.get $l3
+                local.get $l7
+                i32.ne
+                br_if $L7
+                br $B5
+              end
+            end
+            local.get $l4
+            i32.const 1114112
+            i32.eq
+            br_if $B5
+            block $B18
+              local.get $l6
+              i32.eqz
+              local.get $p2
+              local.get $l6
+              i32.eq
+              i32.or
+              i32.eqz
+              if $I19
+                i32.const 0
+                local.set $l3
+                local.get $l6
+                local.get $p2
+                i32.ge_u
+                br_if $B18
+                local.get $p1
+                local.get $l6
+                i32.add
+                i32.load8_s
+                i32.const -64
+                i32.lt_s
+                br_if $B18
+              end
+              local.get $p1
+              local.set $l3
+            end
+            local.get $l6
+            local.get $p2
+            local.get $l3
+            select
+            local.set $p2
+            local.get $l3
+            local.get $p1
+            local.get $l3
+            select
+            local.set $p1
+          end
+          local.get $l13
+          br_if $B2
+          br $B0
+        end
+        i32.const 0
+        local.set $l5
+        local.get $p2
+        if $I20
+          local.get $p2
+          local.set $l4
+          local.get $p1
+          local.set $l3
+          loop $L21
+            local.get $l5
+            local.get $l3
+            i32.load8_u
+            i32.const 192
+            i32.and
+            i32.const 128
+            i32.eq
+            i32.add
+            local.set $l5
+            local.get $l3
+            i32.const 1
+            i32.add
+            local.set $l3
+            local.get $l4
+            i32.const -1
+            i32.add
+            local.tee $l4
+            br_if $L21
+          end
+        end
+        local.get $p2
+        local.get $l5
+        i32.sub
+        local.get $p0
+        i32.load offset=12
+        local.tee $l7
+        i32.ge_u
+        br_if $B0
+        i32.const 0
+        local.set $l6
+        i32.const 0
+        local.set $l5
+        local.get $p2
+        if $I22
+          local.get $p2
+          local.set $l4
+          local.get $p1
+          local.set $l3
+          loop $L23
+            local.get $l5
+            local.get $l3
+            i32.load8_u
+            i32.const 192
+            i32.and
+            i32.const 128
+            i32.eq
+            i32.add
+            local.set $l5
+            local.get $l3
+            i32.const 1
+            i32.add
+            local.set $l3
+            local.get $l4
+            i32.const -1
+            i32.add
+            local.tee $l4
+            br_if $L23
+          end
+        end
+        local.get $l5
+        local.get $p2
+        i32.sub
+        local.get $l7
+        i32.add
+        local.tee $l3
+        local.set $l4
+        block $B24
+          block $B25
+            block $B26
+              i32.const 0
+              local.get $p0
+              i32.load8_u offset=48
+              local.tee $l5
+              local.get $l5
+              i32.const 3
+              i32.eq
+              select
+              i32.const 1
+              i32.sub
+              br_table $B25 $B26 $B25 $B24
+            end
+            local.get $l3
+            i32.const 1
+            i32.shr_u
+            local.set $l6
+            local.get $l3
+            i32.const 1
+            i32.add
+            i32.const 1
+            i32.shr_u
+            local.set $l4
+            br $B24
+          end
+          i32.const 0
+          local.set $l4
+          local.get $l3
+          local.set $l6
+        end
+        local.get $l6
+        i32.const 1
+        i32.add
+        local.set $l3
+        block $B27
+          loop $L28
+            local.get $l3
+            i32.const -1
+            i32.add
+            local.tee $l3
+            i32.eqz
+            br_if $B27
+            local.get $p0
+            i32.load offset=24
+            local.get $p0
+            i32.load offset=4
+            local.get $p0
+            i32.load offset=28
+            i32.load offset=16
+            call_indirect (type $t0) $T0
+            i32.eqz
+            br_if $L28
+          end
+          i32.const 1
+          return
+        end
+        local.get $p0
+        i32.load offset=4
+        local.set $l5
+        i32.const 1
+        local.set $l3
+        local.get $p0
+        i32.load offset=24
+        local.get $p1
+        local.get $p2
+        local.get $p0
+        i32.load offset=28
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B1
+        local.get $l4
+        i32.const 1
+        i32.add
+        local.set $l3
+        local.get $p0
+        i32.load offset=28
+        local.set $p1
+        local.get $p0
+        i32.load offset=24
+        local.set $p0
+        loop $L29
+          local.get $l3
+          i32.const -1
+          i32.add
+          local.tee $l3
+          i32.eqz
+          if $I30
+            i32.const 0
+            return
+          end
+          local.get $p0
+          local.get $l5
+          local.get $p1
+          i32.load offset=16
+          call_indirect (type $t0) $T0
+          i32.eqz
+          br_if $L29
+        end
+        i32.const 1
+        return
+      end
+      local.get $l3
+      return
+    end
+    local.get $p0
+    i32.load offset=24
+    local.get $p1
+    local.get $p2
+    local.get $p0
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0)
+  (func $f176 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32)
+    global.get $g0
+    i32.const 112
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    local.get $l4
+    local.get $p3
+    i32.store offset=12
+    local.get $l4
+    local.get $p2
+    i32.store offset=8
+    i32.const 1
+    local.set $l8
+    local.get $p1
+    local.set $l6
+    block $B0
+      local.get $p1
+      i32.const 257
+      i32.lt_u
+      br_if $B0
+      i32.const 0
+      local.get $p1
+      i32.sub
+      local.set $l7
+      i32.const 256
+      local.set $l5
+      loop $L1
+        block $B2
+          local.get $l5
+          local.get $p1
+          i32.ge_u
+          br_if $B2
+          local.get $p0
+          local.get $l5
+          i32.add
+          i32.load8_s
+          i32.const -65
+          i32.le_s
+          br_if $B2
+          i32.const 0
+          local.set $l8
+          local.get $l5
+          local.set $l6
+          br $B0
+        end
+        local.get $l5
+        i32.const -1
+        i32.add
+        local.set $l6
+        i32.const 0
+        local.set $l8
+        local.get $l5
+        i32.const 1
+        i32.eq
+        br_if $B0
+        local.get $l5
+        local.get $l7
+        i32.add
+        local.get $l6
+        local.set $l5
+        i32.const 1
+        i32.ne
+        br_if $L1
+      end
+    end
+    local.get $l4
+    local.get $l6
+    i32.store offset=20
+    local.get $l4
+    local.get $p0
+    i32.store offset=16
+    local.get $l4
+    i32.const 0
+    i32.const 5
+    local.get $l8
+    select
+    i32.store offset=28
+    local.get $l4
+    i32.const 1054336
+    i32.const 1055231
+    local.get $l8
+    select
+    i32.store offset=24
+    block $B3
+      block $B4
+        block $B5
+          local.get $p2
+          local.get $p1
+          i32.gt_u
+          local.tee $l5
+          local.get $p3
+          local.get $p1
+          i32.gt_u
+          i32.or
+          i32.eqz
+          if $I6
+            local.get $p2
+            local.get $p3
+            i32.gt_u
+            br_if $B5
+            block $B7
+              local.get $p2
+              i32.eqz
+              local.get $p1
+              local.get $p2
+              i32.eq
+              i32.or
+              i32.eqz
+              if $I8
+                local.get $p1
+                local.get $p2
+                i32.le_u
+                br_if $B7
+                local.get $p0
+                local.get $p2
+                i32.add
+                i32.load8_s
+                i32.const -64
+                i32.lt_s
+                br_if $B7
+              end
+              local.get $p3
+              local.set $p2
+            end
+            local.get $l4
+            local.get $p2
+            i32.store offset=32
+            local.get $p2
+            i32.eqz
+            local.get $p1
+            local.get $p2
+            i32.eq
+            i32.or
+            br_if $B4
+            local.get $p1
+            i32.const 1
+            i32.add
+            local.set $p3
+            loop $L9
+              local.get $p2
+              local.get $p1
+              i32.lt_u
+              if $I10
+                local.get $p0
+                local.get $p2
+                i32.add
+                i32.load8_s
+                i32.const -64
+                i32.ge_s
+                br_if $B4
+              end
+              local.get $p2
+              i32.const -1
+              i32.add
+              local.set $l5
+              local.get $p2
+              i32.const 1
+              i32.eq
+              br_if $B3
+              local.get $p2
+              local.get $p3
+              i32.eq
+              local.get $l5
+              local.set $p2
+              i32.eqz
+              br_if $L9
+            end
+            br $B3
+          end
+          local.get $l4
+          local.get $p2
+          local.get $p3
+          local.get $l5
+          select
+          i32.store offset=40
+          local.get $l4
+          i32.const 68
+          i32.add
+          i32.const 3
+          i32.store
+          local.get $l4
+          i32.const 92
+          i32.add
+          i32.const 86
+          i32.store
+          local.get $l4
+          i32.const 84
+          i32.add
+          i32.const 86
+          i32.store
+          local.get $l4
+          i64.const 3
+          i64.store offset=52 align=4
+          local.get $l4
+          i32.const 1055272
+          i32.store offset=48
+          local.get $l4
+          i32.const 20
+          i32.store offset=76
+          local.get $l4
+          local.get $l4
+          i32.const 72
+          i32.add
+          i32.store offset=64
+          local.get $l4
+          local.get $l4
+          i32.const 24
+          i32.add
+          i32.store offset=88
+          local.get $l4
+          local.get $l4
+          i32.const 16
+          i32.add
+          i32.store offset=80
+          local.get $l4
+          local.get $l4
+          i32.const 40
+          i32.add
+          i32.store offset=72
+          local.get $l4
+          i32.const 48
+          i32.add
+          i32.const 1055296
+          call $f177
+          unreachable
+        end
+        local.get $l4
+        i32.const 100
+        i32.add
+        i32.const 86
+        i32.store
+        local.get $l4
+        i32.const 92
+        i32.add
+        i32.const 86
+        i32.store
+        local.get $l4
+        i32.const 84
+        i32.add
+        i32.const 20
+        i32.store
+        local.get $l4
+        i32.const 68
+        i32.add
+        i32.const 4
+        i32.store
+        local.get $l4
+        i64.const 4
+        i64.store offset=52 align=4
+        local.get $l4
+        i32.const 1055348
+        i32.store offset=48
+        local.get $l4
+        i32.const 20
+        i32.store offset=76
+        local.get $l4
+        local.get $l4
+        i32.const 72
+        i32.add
+        i32.store offset=64
+        local.get $l4
+        local.get $l4
+        i32.const 24
+        i32.add
+        i32.store offset=96
+        local.get $l4
+        local.get $l4
+        i32.const 16
+        i32.add
+        i32.store offset=88
+        local.get $l4
+        local.get $l4
+        i32.const 12
+        i32.add
+        i32.store offset=80
+        local.get $l4
+        local.get $l4
+        i32.const 8
+        i32.add
+        i32.store offset=72
+        local.get $l4
+        i32.const 48
+        i32.add
+        i32.const 1055380
+        call $f177
+        unreachable
+      end
+      local.get $p2
+      local.set $l5
+    end
+    block $B11
+      local.get $p1
+      local.get $l5
+      i32.eq
+      br_if $B11
+      i32.const 1
+      local.set $l6
+      block $B12
+        block $B13
+          block $B14
+            local.get $p0
+            local.get $l5
+            i32.add
+            local.tee $l7
+            i32.load8_s
+            local.tee $p2
+            i32.const -1
+            i32.le_s
+            if $I15
+              i32.const 0
+              local.set $l8
+              local.get $p0
+              local.get $p1
+              i32.add
+              local.tee $p3
+              local.set $p1
+              local.get $p3
+              local.get $l7
+              i32.const 1
+              i32.add
+              i32.ne
+              if $I16
+                local.get $l7
+                i32.load8_u offset=1
+                i32.const 63
+                i32.and
+                local.set $l8
+                local.get $l7
+                i32.const 2
+                i32.add
+                local.set $p1
+              end
+              local.get $p2
+              i32.const 31
+              i32.and
+              local.set $l7
+              local.get $p2
+              i32.const 255
+              i32.and
+              i32.const 223
+              i32.gt_u
+              br_if $B14
+              local.get $l8
+              local.get $l7
+              i32.const 6
+              i32.shl
+              i32.or
+              local.set $p1
+              br $B13
+            end
+            local.get $l4
+            local.get $p2
+            i32.const 255
+            i32.and
+            i32.store offset=36
+            local.get $l4
+            i32.const 40
+            i32.add
+            local.set $p2
+            br $B12
+          end
+          i32.const 0
+          local.set $p0
+          local.get $p3
+          local.set $l6
+          local.get $p1
+          local.get $p3
+          i32.ne
+          if $I17 (result i32)
+            local.get $p1
+            i32.const 1
+            i32.add
+            local.set $l6
+            local.get $p1
+            i32.load8_u
+            i32.const 63
+            i32.and
+          else
+            i32.const 0
+          end
+          local.get $l8
+          i32.const 6
+          i32.shl
+          i32.or
+          local.set $p0
+          local.get $p2
+          i32.const 255
+          i32.and
+          i32.const 240
+          i32.lt_u
+          if $I18
+            local.get $p0
+            local.get $l7
+            i32.const 12
+            i32.shl
+            i32.or
+            local.set $p1
+            br $B13
+          end
+          i32.const 0
+          local.set $p2
+          local.get $p3
+          local.get $l6
+          i32.ne
+          if $I19 (result i32)
+            local.get $l6
+            i32.load8_u
+            i32.const 63
+            i32.and
+          else
+            i32.const 0
+          end
+          local.get $l7
+          i32.const 18
+          i32.shl
+          i32.const 1835008
+          i32.and
+          local.get $p0
+          i32.const 6
+          i32.shl
+          i32.or
+          i32.or
+          local.tee $p1
+          i32.const 1114112
+          i32.eq
+          br_if $B11
+        end
+        local.get $l4
+        local.get $p1
+        i32.store offset=36
+        i32.const 1
+        local.set $l6
+        local.get $l4
+        i32.const 40
+        i32.add
+        local.set $p2
+        local.get $p1
+        i32.const 128
+        i32.lt_u
+        br_if $B12
+        i32.const 2
+        local.set $l6
+        local.get $p1
+        i32.const 2048
+        i32.lt_u
+        br_if $B12
+        i32.const 3
+        i32.const 4
+        local.get $p1
+        i32.const 65536
+        i32.lt_u
+        select
+        local.set $l6
+      end
+      local.get $l4
+      local.get $l5
+      i32.store offset=40
+      local.get $l4
+      local.get $l5
+      local.get $l6
+      i32.add
+      i32.store offset=44
+      local.get $l4
+      i32.const 68
+      i32.add
+      i32.const 5
+      i32.store
+      local.get $l4
+      i32.const 108
+      i32.add
+      i32.const 86
+      i32.store
+      local.get $l4
+      i32.const 100
+      i32.add
+      i32.const 86
+      i32.store
+      local.get $l4
+      i32.const 92
+      i32.add
+      i32.const 87
+      i32.store
+      local.get $l4
+      i32.const 84
+      i32.add
+      i32.const 88
+      i32.store
+      local.get $l4
+      i64.const 5
+      i64.store offset=52 align=4
+      local.get $l4
+      i32.const 1055448
+      i32.store offset=48
+      local.get $l4
+      local.get $p2
+      i32.store offset=88
+      local.get $l4
+      i32.const 20
+      i32.store offset=76
+      local.get $l4
+      local.get $l4
+      i32.const 72
+      i32.add
+      i32.store offset=64
+      local.get $l4
+      local.get $l4
+      i32.const 24
+      i32.add
+      i32.store offset=104
+      local.get $l4
+      local.get $l4
+      i32.const 16
+      i32.add
+      i32.store offset=96
+      local.get $l4
+      local.get $l4
+      i32.const 36
+      i32.add
+      i32.store offset=80
+      local.get $l4
+      local.get $l4
+      i32.const 32
+      i32.add
+      i32.store offset=72
+      local.get $l4
+      i32.const 48
+      i32.add
+      i32.const 1055488
+      call $f177
+      unreachable
+    end
+    i32.const 1054488
+    i32.const 43
+    i32.const 1054552
+    call $f172
+    unreachable)
+  (func $f177 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p1
+    i32.store offset=12
+    local.get $l2
+    local.get $p0
+    i32.store offset=8
+    local.get $l2
+    i32.const 1054376
+    i32.store offset=4
+    local.get $l2
+    i32.const 1
+    i32.store
+    local.get $l2
+    call $f133
+    unreachable)
+  (func $f178 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i64.load32_u
+    i32.const 1
+    local.get $p1
+    call $f214)
+  (func $f179 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 36
+    i32.add
+    local.get $p1
+    i32.store
+    local.get $l3
+    i32.const 52
+    i32.add
+    local.get $p2
+    i32.const 20
+    i32.add
+    i32.load
+    local.tee $l4
+    i32.store
+    local.get $l3
+    i32.const 3
+    i32.store8 offset=56
+    local.get $l3
+    i32.const 44
+    i32.add
+    local.get $p2
+    i32.load offset=16
+    local.tee $l5
+    local.get $l4
+    i32.const 3
+    i32.shl
+    i32.add
+    i32.store
+    local.get $l3
+    i64.const 137438953472
+    i64.store offset=8
+    local.get $l3
+    local.get $p0
+    i32.store offset=32
+    local.get $l3
+    i32.const 0
+    i32.store offset=24
+    local.get $l3
+    i32.const 0
+    i32.store offset=16
+    local.get $l3
+    local.get $l5
+    i32.store offset=48
+    local.get $l3
+    local.get $l5
+    i32.store offset=40
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p2
+            i32.load offset=8
+            local.tee $l6
+            i32.eqz
+            if $I4
+              local.get $p2
+              i32.load
+              local.set $l8
+              local.get $p2
+              i32.load offset=4
+              local.tee $l9
+              local.get $l4
+              local.get $l4
+              local.get $l9
+              i32.gt_u
+              select
+              local.tee $l6
+              i32.eqz
+              br_if $B3
+              i32.const 1
+              local.set $l4
+              local.get $p0
+              local.get $l8
+              i32.load
+              local.get $l8
+              i32.load offset=4
+              local.get $p1
+              i32.load offset=12
+              call_indirect (type $t1) $T0
+              br_if $B0
+              local.get $l8
+              i32.const 12
+              i32.add
+              local.set $p2
+              i32.const 1
+              local.set $l7
+              loop $L5
+                local.get $l5
+                i32.load
+                local.get $l3
+                i32.const 8
+                i32.add
+                local.get $l5
+                i32.const 4
+                i32.add
+                i32.load
+                call_indirect (type $t0) $T0
+                if $I6
+                  br $B0
+                end
+                local.get $l7
+                local.get $l6
+                i32.ge_u
+                br_if $B3
+                local.get $p2
+                i32.const -4
+                i32.add
+                local.set $p0
+                local.get $p2
+                i32.load
+                local.set $p1
+                local.get $p2
+                i32.const 8
+                i32.add
+                local.set $p2
+                local.get $l5
+                i32.const 8
+                i32.add
+                local.set $l5
+                local.get $l7
+                i32.const 1
+                i32.add
+                local.set $l7
+                local.get $l3
+                i32.load offset=32
+                local.get $p0
+                i32.load
+                local.get $p1
+                local.get $l3
+                i32.load offset=36
+                i32.load offset=12
+                call_indirect (type $t1) $T0
+                i32.eqz
+                br_if $L5
+              end
+              br $B0
+            end
+            local.get $p2
+            i32.load
+            local.set $l8
+            local.get $p2
+            i32.load offset=4
+            local.tee $l9
+            local.get $p2
+            i32.const 12
+            i32.add
+            i32.load
+            local.tee $p2
+            local.get $p2
+            local.get $l9
+            i32.gt_u
+            select
+            local.tee $l10
+            i32.eqz
+            br_if $B3
+            i32.const 1
+            local.set $l4
+            local.get $p0
+            local.get $l8
+            i32.load
+            local.get $l8
+            i32.load offset=4
+            local.get $p1
+            i32.load offset=12
+            call_indirect (type $t1) $T0
+            br_if $B0
+            local.get $l8
+            i32.const 12
+            i32.add
+            local.set $p2
+            local.get $l6
+            i32.const 16
+            i32.add
+            local.set $l5
+            i32.const 1
+            local.set $l7
+            loop $L7
+              local.get $l3
+              local.get $l5
+              i32.const -8
+              i32.add
+              i32.load
+              i32.store offset=12
+              local.get $l3
+              local.get $l5
+              i32.const 16
+              i32.add
+              i32.load8_u
+              i32.store8 offset=56
+              local.get $l3
+              local.get $l5
+              i32.const -4
+              i32.add
+              i32.load
+              i32.store offset=8
+              i32.const 0
+              local.set $p1
+              i32.const 0
+              local.set $p0
+              block $B8
+                block $B9
+                  block $B10
+                    block $B11
+                      local.get $l5
+                      i32.const 8
+                      i32.add
+                      i32.load
+                      i32.const 1
+                      i32.sub
+                      br_table $B10 $B9 $B8 $B11
+                    end
+                    local.get $l5
+                    i32.const 12
+                    i32.add
+                    i32.load
+                    local.set $l4
+                    i32.const 1
+                    local.set $p0
+                    br $B8
+                  end
+                  local.get $l5
+                  i32.const 12
+                  i32.add
+                  i32.load
+                  local.tee $l6
+                  local.get $l3
+                  i32.load offset=52
+                  local.tee $l4
+                  i32.lt_u
+                  if $I12
+                    local.get $l3
+                    i32.load offset=48
+                    local.get $l6
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.tee $l6
+                    i32.load offset=4
+                    i32.const 89
+                    i32.ne
+                    br_if $B8
+                    local.get $l6
+                    i32.load
+                    i32.load
+                    local.set $l4
+                    i32.const 1
+                    local.set $p0
+                    br $B8
+                  end
+                  i32.const 1055836
+                  local.get $l6
+                  local.get $l4
+                  call $f171
+                  unreachable
+                end
+                local.get $l3
+                i32.load offset=40
+                local.tee $l6
+                local.get $l3
+                i32.load offset=44
+                i32.eq
+                br_if $B8
+                local.get $l3
+                local.get $l6
+                i32.const 8
+                i32.add
+                i32.store offset=40
+                local.get $l6
+                i32.load offset=4
+                i32.const 89
+                i32.ne
+                br_if $B8
+                local.get $l6
+                i32.load
+                i32.load
+                local.set $l4
+                i32.const 1
+                local.set $p0
+              end
+              local.get $l3
+              local.get $l4
+              i32.store offset=20
+              local.get $l3
+              local.get $p0
+              i32.store offset=16
+              block $B13
+                block $B14 (result i32)
+                  block $B15
+                    block $B16
+                      block $B17
+                        block $B18
+                          block $B19
+                            local.get $l5
+                            i32.load
+                            i32.const 1
+                            i32.sub
+                            br_table $B18 $B19 $B13 $B15
+                          end
+                          local.get $l3
+                          i32.load offset=40
+                          local.tee $p0
+                          local.get $l3
+                          i32.load offset=44
+                          i32.ne
+                          br_if $B17
+                          br $B13
+                        end
+                        local.get $l5
+                        i32.const 4
+                        i32.add
+                        i32.load
+                        local.tee $p0
+                        local.get $l3
+                        i32.load offset=52
+                        local.tee $l4
+                        i32.ge_u
+                        br_if $B16
+                        local.get $l3
+                        i32.load offset=48
+                        local.get $p0
+                        i32.const 3
+                        i32.shl
+                        i32.add
+                        local.tee $p0
+                        i32.load offset=4
+                        i32.const 89
+                        i32.ne
+                        br_if $B13
+                        local.get $p0
+                        i32.load
+                        i32.load
+                        br $B14
+                      end
+                      local.get $l3
+                      local.get $p0
+                      i32.const 8
+                      i32.add
+                      i32.store offset=40
+                      local.get $p0
+                      i32.load offset=4
+                      i32.const 89
+                      i32.ne
+                      br_if $B13
+                      local.get $p0
+                      i32.load
+                      i32.load
+                      br $B14
+                    end
+                    i32.const 1055836
+                    local.get $p0
+                    local.get $l4
+                    call $f171
+                    unreachable
+                  end
+                  local.get $l5
+                  i32.const 4
+                  i32.add
+                  i32.load
+                end
+                local.set $l4
+                i32.const 1
+                local.set $p1
+              end
+              local.get $l3
+              local.get $l4
+              i32.store offset=28
+              local.get $l3
+              local.get $p1
+              i32.store offset=24
+              block $B20
+                local.get $l5
+                i32.const -16
+                i32.add
+                i32.load
+                i32.const 1
+                i32.ne
+                if $I21
+                  local.get $l3
+                  i32.load offset=40
+                  local.tee $l4
+                  local.get $l3
+                  i32.load offset=44
+                  i32.eq
+                  br_if $B2
+                  local.get $l3
+                  local.get $l4
+                  i32.const 8
+                  i32.add
+                  i32.store offset=40
+                  br $B20
+                end
+                local.get $l5
+                i32.const -12
+                i32.add
+                i32.load
+                local.tee $p0
+                local.get $l3
+                i32.load offset=52
+                local.tee $p1
+                i32.ge_u
+                br_if $B1
+                local.get $l3
+                i32.load offset=48
+                local.get $p0
+                i32.const 3
+                i32.shl
+                i32.add
+                local.set $l4
+              end
+              local.get $l4
+              i32.load
+              local.get $l3
+              i32.const 8
+              i32.add
+              local.get $l4
+              i32.const 4
+              i32.add
+              i32.load
+              call_indirect (type $t0) $T0
+              if $I22
+                i32.const 1
+                local.set $l4
+                br $B0
+              end
+              local.get $l7
+              local.get $l10
+              i32.ge_u
+              br_if $B3
+              local.get $p2
+              i32.const -4
+              i32.add
+              local.set $p0
+              local.get $p2
+              i32.load
+              local.set $p1
+              local.get $p2
+              i32.const 8
+              i32.add
+              local.set $p2
+              local.get $l5
+              i32.const 36
+              i32.add
+              local.set $l5
+              i32.const 1
+              local.set $l4
+              local.get $l7
+              i32.const 1
+              i32.add
+              local.set $l7
+              local.get $l3
+              i32.load offset=32
+              local.get $p0
+              i32.load
+              local.get $p1
+              local.get $l3
+              i32.load offset=36
+              i32.load offset=12
+              call_indirect (type $t1) $T0
+              i32.eqz
+              br_if $L7
+            end
+            br $B0
+          end
+          local.get $l9
+          local.get $l7
+          i32.gt_u
+          if $I23
+            i32.const 1
+            local.set $l4
+            local.get $l3
+            i32.load offset=32
+            local.get $l8
+            local.get $l7
+            i32.const 3
+            i32.shl
+            i32.add
+            local.tee $p0
+            i32.load
+            local.get $p0
+            i32.load offset=4
+            local.get $l3
+            i32.load offset=36
+            i32.load offset=12
+            call_indirect (type $t1) $T0
+            br_if $B0
+          end
+          i32.const 0
+          local.set $l4
+          br $B0
+        end
+        i32.const 1054488
+        i32.const 43
+        i32.const 1054552
+        call $f172
+        unreachable
+      end
+      i32.const 1055820
+      local.get $p0
+      local.get $p1
+      call $f171
+      unreachable
+    end
+    local.get $l3
+    i32.const -64
+    i32.sub
+    global.set $g0
+    local.get $l4)
+  (func $f180 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0
+      local.get $p0
+      local.get $p1
+      call $f181
+      br_if $B0
+      local.get $p1
+      i32.const 28
+      i32.add
+      i32.load
+      local.set $l3
+      local.get $p1
+      i32.load offset=24
+      local.get $l2
+      i64.const 4
+      i64.store offset=24
+      local.get $l2
+      i64.const 1
+      i64.store offset=12 align=4
+      local.get $l2
+      i32.const 1054340
+      i32.store offset=8
+      local.get $l3
+      local.get $l2
+      i32.const 8
+      i32.add
+      call $f179
+      br_if $B0
+      local.get $p0
+      i32.const 4
+      i32.add
+      local.get $p1
+      call $f181
+      local.get $l2
+      i32.const 32
+      i32.add
+      global.set $g0
+      return
+    end
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0
+    i32.const 1)
+  (func $f181 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    block $B0
+      block $B1
+        block $B2 (result i32)
+          block $B3
+            local.get $p1
+            i32.load
+            local.tee $l3
+            i32.const 16
+            i32.and
+            i32.eqz
+            if $I4
+              local.get $p0
+              i32.load
+              local.set $l2
+              local.get $l3
+              i32.const 32
+              i32.and
+              br_if $B3
+              local.get $l2
+              i64.extend_i32_u
+              i32.const 1
+              local.get $p1
+              call $f214
+              br $B2
+            end
+            local.get $p0
+            i32.load
+            local.set $l2
+            i32.const 0
+            local.set $p0
+            loop $L5
+              local.get $p0
+              local.get $l4
+              i32.add
+              i32.const 127
+              i32.add
+              local.get $l2
+              i32.const 15
+              i32.and
+              local.tee $l3
+              i32.const 48
+              i32.or
+              local.get $l3
+              i32.const 87
+              i32.add
+              local.get $l3
+              i32.const 10
+              i32.lt_u
+              select
+              i32.store8
+              local.get $p0
+              i32.const -1
+              i32.add
+              local.set $p0
+              local.get $l2
+              i32.const 4
+              i32.shr_u
+              local.tee $l2
+              br_if $L5
+            end
+            local.get $p0
+            i32.const 128
+            i32.add
+            local.tee $l2
+            i32.const 129
+            i32.ge_u
+            br_if $B1
+            local.get $p1
+            i32.const 1
+            i32.const 1055569
+            i32.const 2
+            local.get $p0
+            local.get $l4
+            i32.add
+            i32.const 128
+            i32.add
+            i32.const 0
+            local.get $p0
+            i32.sub
+            call $f216
+            br $B2
+          end
+          i32.const 0
+          local.set $p0
+          loop $L6
+            local.get $p0
+            local.get $l4
+            i32.add
+            i32.const 127
+            i32.add
+            local.get $l2
+            i32.const 15
+            i32.and
+            local.tee $l3
+            i32.const 48
+            i32.or
+            local.get $l3
+            i32.const 55
+            i32.add
+            local.get $l3
+            i32.const 10
+            i32.lt_u
+            select
+            i32.store8
+            local.get $p0
+            i32.const -1
+            i32.add
+            local.set $p0
+            local.get $l2
+            i32.const 4
+            i32.shr_u
+            local.tee $l2
+            br_if $L6
+          end
+          local.get $p0
+          i32.const 128
+          i32.add
+          local.tee $l2
+          i32.const 129
+          i32.ge_u
+          br_if $B0
+          local.get $p1
+          i32.const 1
+          i32.const 1055569
+          i32.const 2
+          local.get $p0
+          local.get $l4
+          i32.add
+          i32.const 128
+          i32.add
+          i32.const 0
+          local.get $p0
+          i32.sub
+          call $f216
+        end
+        local.get $l4
+        i32.const 128
+        i32.add
+        global.set $g0
+        return
+      end
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $l2
+    i32.const 128
+    call $f174
+    unreachable)
+  (func $f182 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p1
+    i32.load offset=24
+    i32.const 1054348
+    i32.const 11
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0)
+  (func $f183 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p1
+    i32.load offset=24
+    i32.const 1054359
+    i32.const 14
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0)
+  (func $f184 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32)
+    i32.const 1114112
+    local.set $l1
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            local.get $p0
+            i32.load
+            i32.const 1
+            i32.sub
+            br_table $B2 $B3 $B1 $B0
+          end
+          local.get $p0
+          i32.const 1
+          i32.store
+          i32.const 92
+          return
+        end
+        local.get $p0
+        i32.const 0
+        i32.store
+        local.get $p0
+        i32.load offset=4
+        return
+      end
+      block $B4
+        block $B5
+          block $B6
+            block $B7
+              block $B8
+                local.get $p0
+                i32.const 12
+                i32.add
+                i32.load8_u
+                i32.const 1
+                i32.sub
+                br_table $B4 $B5 $B6 $B7 $B8 $B0
+              end
+              local.get $p0
+              i32.const 4
+              i32.store8 offset=12
+              i32.const 92
+              return
+            end
+            local.get $p0
+            i32.const 3
+            i32.store8 offset=12
+            i32.const 117
+            return
+          end
+          local.get $p0
+          i32.const 2
+          i32.store8 offset=12
+          i32.const 123
+          return
+        end
+        local.get $p0
+        i32.load offset=4
+        local.get $p0
+        i32.const 8
+        i32.add
+        i32.load
+        local.tee $l1
+        i32.const 2
+        i32.shl
+        i32.const 28
+        i32.and
+        i32.shr_u
+        i32.const 15
+        i32.and
+        local.tee $l2
+        i32.const 48
+        i32.or
+        local.get $l2
+        i32.const 87
+        i32.add
+        local.get $l2
+        i32.const 10
+        i32.lt_u
+        select
+        local.set $l2
+        local.get $l1
+        if $I9
+          local.get $p0
+          local.get $l1
+          i32.const -1
+          i32.add
+          i32.store offset=8
+          local.get $l2
+          return
+        end
+        local.get $p0
+        i32.const 1
+        i32.store8 offset=12
+        local.get $l2
+        return
+      end
+      local.get $p0
+      i32.const 0
+      i32.store8 offset=12
+      i32.const 125
+      local.set $l1
+    end
+    local.get $l1)
+  (func $f185 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p1
+    local.get $p0
+    i32.load
+    local.get $p0
+    i32.load offset=4
+    call $f175)
+  (func $f186 (type $t11) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (param $p4 i32)
+    local.get $p0
+    local.get $p4
+    i32.store offset=12
+    local.get $p0
+    local.get $p3
+    i32.store offset=8
+    local.get $p0
+    local.get $p2
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f187 (type $t3) (param $p0 i32) (param $p1 i32)
+    local.get $p0
+    local.get $p1
+    i64.load align=4
+    i64.store align=4)
+  (func $f188 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    i32.const 20
+    i32.add
+    i32.const 20
+    i32.store
+    local.get $l2
+    i32.const 12
+    i32.add
+    i32.const 20
+    i32.store
+    local.get $l2
+    i32.const 86
+    i32.store offset=4
+    local.get $l2
+    local.get $p0
+    i32.store
+    local.get $l2
+    local.get $p0
+    i32.const 12
+    i32.add
+    i32.store offset=16
+    local.get $l2
+    local.get $p0
+    i32.const 8
+    i32.add
+    i32.store offset=8
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    local.set $p0
+    local.get $p1
+    i32.load offset=24
+    local.get $l2
+    i32.const 44
+    i32.add
+    i32.const 3
+    i32.store
+    local.get $l2
+    i64.const 3
+    i64.store offset=28 align=4
+    local.get $l2
+    i32.const 1054396
+    i32.store offset=24
+    local.get $l2
+    local.get $l2
+    i32.store offset=40
+    local.get $p0
+    local.get $l2
+    i32.const 24
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 48
+    i32.add
+    global.set $g0)
+  (func $f189 (type $t11) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (param $p4 i32)
+    (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i64) (local $l10 i64) (local $l11 i64) (local $l12 i64) (local $l13 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l5
+    global.set $g0
+    i32.const 1
+    local.set $l7
+    block $B0
+      local.get $p0
+      i32.load8_u offset=4
+      br_if $B0
+      local.get $p0
+      i32.load8_u offset=5
+      local.set $l8
+      local.get $p0
+      i32.load
+      local.tee $l6
+      i32.load8_u
+      i32.const 4
+      i32.and
+      i32.eqz
+      if $I1
+        local.get $l6
+        i32.load offset=24
+        i32.const 1055537
+        i32.const 1055539
+        local.get $l8
+        select
+        i32.const 2
+        i32.const 3
+        local.get $l8
+        select
+        local.get $l6
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        local.get $p0
+        i32.load
+        local.tee $l6
+        i32.load offset=24
+        local.get $p1
+        local.get $p2
+        local.get $l6
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        local.get $p0
+        i32.load
+        local.tee $p1
+        i32.load offset=24
+        i32.const 1054592
+        i32.const 2
+        local.get $p1
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        local.get $p3
+        local.get $p0
+        i32.load
+        local.get $p4
+        i32.load offset=12
+        call_indirect (type $t0) $T0
+        local.set $l7
+        br $B0
+      end
+      local.get $l8
+      i32.eqz
+      if $I2
+        local.get $l6
+        i32.load offset=24
+        i32.const 1055532
+        i32.const 3
+        local.get $l6
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        local.get $p0
+        i32.load
+        local.set $l6
+      end
+      local.get $l5
+      i32.const 1
+      i32.store8 offset=23
+      local.get $l5
+      local.get $l5
+      i32.const 23
+      i32.add
+      i32.store offset=16
+      local.get $l6
+      i64.load offset=8 align=4
+      local.set $l9
+      local.get $l6
+      i64.load offset=16 align=4
+      local.set $l10
+      local.get $l5
+      i32.const 52
+      i32.add
+      i32.const 1055504
+      i32.store
+      local.get $l5
+      local.get $l6
+      i64.load offset=24 align=4
+      i64.store offset=8
+      local.get $l6
+      i64.load offset=32 align=4
+      local.set $l11
+      local.get $l6
+      i64.load offset=40 align=4
+      local.set $l12
+      local.get $l5
+      local.get $l6
+      i32.load8_u offset=48
+      i32.store8 offset=72
+      local.get $l6
+      i64.load align=4
+      local.set $l13
+      local.get $l5
+      local.get $l12
+      i64.store offset=64
+      local.get $l5
+      local.get $l11
+      i64.store offset=56
+      local.get $l5
+      local.get $l10
+      i64.store offset=40
+      local.get $l5
+      local.get $l9
+      i64.store offset=32
+      local.get $l5
+      local.get $l13
+      i64.store offset=24
+      local.get $l5
+      local.get $l5
+      i32.const 8
+      i32.add
+      i32.store offset=48
+      local.get $l5
+      i32.const 8
+      i32.add
+      local.get $p1
+      local.get $p2
+      call $f205
+      br_if $B0
+      local.get $l5
+      i32.const 8
+      i32.add
+      i32.const 1054592
+      i32.const 2
+      call $f205
+      br_if $B0
+      local.get $p3
+      local.get $l5
+      i32.const 24
+      i32.add
+      local.get $p4
+      i32.load offset=12
+      call_indirect (type $t0) $T0
+      br_if $B0
+      local.get $l5
+      i32.load offset=48
+      i32.const 1055535
+      i32.const 2
+      local.get $l5
+      i32.load offset=52
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+      local.set $l7
+    end
+    local.get $p0
+    i32.const 1
+    i32.store8 offset=5
+    local.get $p0
+    local.get $l7
+    i32.store8 offset=4
+    local.get $l5
+    i32.const 80
+    i32.add
+    global.set $g0)
+  (func $f190 (type $t7)
+    (local $l0 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l0
+    global.set $g0
+    local.get $l0
+    i32.const 36
+    i32.store offset=12
+    local.get $l0
+    i32.const 1050796
+    i32.store offset=8
+    local.get $l0
+    i32.const 36
+    i32.add
+    i32.const 1
+    i32.store
+    local.get $l0
+    i64.const 1
+    i64.store offset=20 align=4
+    local.get $l0
+    i32.const 1054568
+    i32.store offset=16
+    local.get $l0
+    i32.const 86
+    i32.store offset=44
+    local.get $l0
+    local.get $l0
+    i32.const 40
+    i32.add
+    i32.store offset=32
+    local.get $l0
+    local.get $l0
+    i32.const 8
+    i32.add
+    i32.store offset=40
+    local.get $l0
+    i32.const 16
+    i32.add
+    i32.const 1054576
+    call $f177
+    unreachable)
+  (func $f191 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    local.get $p0
+    i32.load offset=4
+    i32.load offset=12
+    call_indirect (type $t0) $T0)
+  (func $f192 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32)
+    global.get $g0
+    i32.const -64
+    i32.add
+    local.tee $l4
+    global.set $g0
+    local.get $l4
+    local.get $p1
+    i32.store offset=12
+    local.get $l4
+    local.get $p0
+    i32.store offset=8
+    local.get $l4
+    local.get $p3
+    i32.store offset=20
+    local.get $l4
+    local.get $p2
+    i32.store offset=16
+    local.get $l4
+    i32.const 44
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $l4
+    i32.const 60
+    i32.add
+    i32.const 90
+    i32.store
+    local.get $l4
+    i64.const 2
+    i64.store offset=28 align=4
+    local.get $l4
+    i32.const 1054596
+    i32.store offset=24
+    local.get $l4
+    i32.const 86
+    i32.store offset=52
+    local.get $l4
+    local.get $l4
+    i32.const 48
+    i32.add
+    i32.store offset=40
+    local.get $l4
+    local.get $l4
+    i32.const 16
+    i32.add
+    i32.store offset=56
+    local.get $l4
+    local.get $l4
+    i32.const 8
+    i32.add
+    i32.store offset=48
+    local.get $l4
+    i32.const 24
+    i32.add
+    i32.const 1054636
+    call $f177
+    unreachable)
+  (func $f193 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32)
+    block $B0
+      block $B1
+        local.get $p2
+        i32.const 3
+        i32.and
+        local.tee $l4
+        i32.eqz
+        br_if $B1
+        i32.const 4
+        local.get $l4
+        i32.sub
+        local.tee $l4
+        i32.eqz
+        br_if $B1
+        local.get $p3
+        local.get $l4
+        local.get $l4
+        local.get $p3
+        i32.gt_u
+        select
+        local.set $l5
+        i32.const 0
+        local.set $l4
+        local.get $p1
+        i32.const 255
+        i32.and
+        local.set $l8
+        loop $L2
+          local.get $l4
+          local.get $l5
+          i32.eq
+          br_if $B1
+          local.get $p2
+          local.get $l4
+          i32.add
+          local.get $l4
+          i32.const 1
+          i32.add
+          local.set $l4
+          i32.load8_u
+          local.tee $l6
+          local.get $l8
+          i32.ne
+          br_if $L2
+        end
+        i32.const 1
+        local.set $p3
+        local.get $l6
+        local.get $p1
+        i32.const 255
+        i32.and
+        i32.eq
+        i32.const 1
+        i32.add
+        i32.const 1
+        i32.and
+        local.get $l4
+        i32.add
+        i32.const -1
+        i32.add
+        local.set $l4
+        br $B0
+      end
+      local.get $p1
+      i32.const 255
+      i32.and
+      local.set $l8
+      block $B3
+        block $B4
+          local.get $p3
+          i32.const 8
+          i32.lt_u
+          br_if $B4
+          local.get $l5
+          local.get $p3
+          i32.const -8
+          i32.add
+          local.tee $l6
+          i32.gt_u
+          br_if $B4
+          local.get $l8
+          i32.const 16843009
+          i32.mul
+          local.set $l4
+          loop $L5
+            local.get $p2
+            local.get $l5
+            i32.add
+            local.tee $l7
+            i32.const 4
+            i32.add
+            i32.load
+            local.get $l4
+            i32.xor
+            local.tee $l9
+            i32.const -1
+            i32.xor
+            local.get $l9
+            i32.const -16843009
+            i32.add
+            i32.and
+            local.get $l7
+            i32.load
+            local.get $l4
+            i32.xor
+            local.tee $l7
+            i32.const -1
+            i32.xor
+            local.get $l7
+            i32.const -16843009
+            i32.add
+            i32.and
+            i32.or
+            i32.const -2139062144
+            i32.and
+            i32.eqz
+            if $I6
+              local.get $l5
+              i32.const 8
+              i32.add
+              local.tee $l5
+              local.get $l6
+              i32.le_u
+              br_if $L5
+            end
+          end
+          local.get $l5
+          local.get $p3
+          i32.gt_u
+          br_if $B3
+        end
+        local.get $p2
+        local.get $l5
+        i32.add
+        local.set $p2
+        local.get $p3
+        local.get $l5
+        i32.sub
+        local.set $l6
+        i32.const 0
+        local.set $p3
+        i32.const 0
+        local.set $l4
+        block $B7
+          loop $L8
+            local.get $l4
+            local.get $l6
+            i32.eq
+            br_if $B7
+            local.get $p2
+            local.get $l4
+            i32.add
+            local.get $l4
+            i32.const 1
+            i32.add
+            local.set $l4
+            i32.load8_u
+            local.tee $l7
+            local.get $l8
+            i32.ne
+            br_if $L8
+          end
+          i32.const 1
+          local.set $p3
+          local.get $l7
+          local.get $p1
+          i32.const 255
+          i32.and
+          i32.eq
+          i32.const 1
+          i32.add
+          i32.const 1
+          i32.and
+          local.get $l4
+          i32.add
+          i32.const -1
+          i32.add
+          local.set $l4
+        end
+        local.get $l4
+        local.get $l5
+        i32.add
+        local.set $l4
+        br $B0
+      end
+      local.get $l5
+      local.get $p3
+      call $f174
+      unreachable
+    end
+    local.get $p0
+    local.get $l4
+    i32.store offset=4
+    local.get $p0
+    local.get $p3
+    i32.store)
+  (func $f194 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32)
+    local.get $p2
+    i32.const 0
+    local.get $p2
+    i32.const 4
+    local.get $p1
+    i32.const 3
+    i32.and
+    local.tee $l6
+    i32.sub
+    i32.const 0
+    local.get $l6
+    select
+    local.tee $l5
+    i32.sub
+    i32.const 7
+    i32.and
+    local.get $p2
+    local.get $l5
+    i32.lt_u
+    local.tee $l4
+    select
+    local.tee $l3
+    i32.sub
+    local.set $l6
+    block $B0 (result i32)
+      block $B1
+        block $B2
+          local.get $p2
+          local.get $l3
+          i32.ge_u
+          if $I3
+            local.get $p2
+            local.get $l5
+            local.get $l4
+            select
+            local.set $l8
+            local.get $p1
+            local.get $l6
+            i32.add
+            local.get $p1
+            local.get $p2
+            i32.add
+            local.tee $l4
+            i32.sub
+            local.set $l7
+            local.get $l4
+            i32.const -1
+            i32.add
+            local.set $l5
+            block $B4
+              loop $L5
+                local.get $l3
+                i32.eqz
+                br_if $B4
+                local.get $l7
+                i32.const 1
+                i32.add
+                local.set $l7
+                local.get $l3
+                i32.const -1
+                i32.add
+                local.set $l3
+                local.get $l5
+                i32.load8_u
+                local.get $l5
+                i32.const -1
+                i32.add
+                local.set $l5
+                i32.const 10
+                i32.ne
+                br_if $L5
+              end
+              local.get $l6
+              local.get $l7
+              i32.sub
+              local.set $l3
+              br $B1
+            end
+            loop $L6
+              local.get $l6
+              local.tee $l3
+              local.get $l8
+              i32.gt_u
+              if $I7
+                local.get $l3
+                i32.const -8
+                i32.add
+                local.set $l6
+                local.get $p1
+                local.get $l3
+                i32.add
+                local.tee $l5
+                i32.const -4
+                i32.add
+                i32.load
+                i32.const 168430090
+                i32.xor
+                local.tee $l4
+                i32.const -1
+                i32.xor
+                local.get $l4
+                i32.const -16843009
+                i32.add
+                i32.and
+                local.get $l5
+                i32.const -8
+                i32.add
+                i32.load
+                i32.const 168430090
+                i32.xor
+                local.tee $l4
+                i32.const -1
+                i32.xor
+                local.get $l4
+                i32.const -16843009
+                i32.add
+                i32.and
+                i32.or
+                i32.const -2139062144
+                i32.and
+                i32.eqz
+                br_if $L6
+              end
+            end
+            local.get $l3
+            local.get $p2
+            i32.gt_u
+            br_if $B2
+            local.get $p1
+            i32.const -1
+            i32.add
+            local.set $p2
+            loop $L8
+              i32.const 0
+              local.get $l3
+              i32.eqz
+              br_if $B0
+              drop
+              local.get $p2
+              local.get $l3
+              i32.add
+              local.get $l3
+              i32.const -1
+              i32.add
+              local.set $l3
+              i32.load8_u
+              i32.const 10
+              i32.ne
+              br_if $L8
+            end
+            br $B1
+          end
+          local.get $l6
+          local.get $p2
+          call $f174
+          unreachable
+        end
+        local.get $l3
+        local.get $p2
+        call $f173
+        unreachable
+      end
+      i32.const 1
+    end
+    local.set $p1
+    local.get $p0
+    local.get $l3
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f195 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    local.get $p0
+    local.get $p2
+    i32.store offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f196 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32)
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                local.get $p1
+                i32.load offset=4
+                local.tee $l2
+                if $I6
+                  local.get $p1
+                  i32.load
+                  local.set $l7
+                  block $B7
+                    block $B8
+                      block $B9
+                        block $B10
+                          block $B11
+                            block $B12
+                              loop $L13
+                                local.get $l3
+                                i32.const 1
+                                i32.add
+                                local.set $l5
+                                block $B14 (result i32)
+                                  local.get $l5
+                                  local.get $l3
+                                  local.get $l7
+                                  i32.add
+                                  local.tee $l9
+                                  i32.load8_u
+                                  local.tee $l10
+                                  i32.const 24
+                                  i32.shl
+                                  i32.const 24
+                                  i32.shr_s
+                                  local.tee $l11
+                                  i32.const -1
+                                  i32.gt_s
+                                  br_if $B14
+                                  drop
+                                  block $B15
+                                    block $B16
+                                      block $B17
+                                        local.get $l10
+                                        i32.const 1054975
+                                        i32.add
+                                        i32.load8_u
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $l6
+                                        i32.const 2
+                                        i32.le_u
+                                        if $I18
+                                          local.get $l6
+                                          i32.const 1
+                                          i32.sub
+                                          br_table $B16 $B15 $B17
+                                        end
+                                        local.get $l2
+                                        local.get $l3
+                                        i32.lt_u
+                                        br_if $B8
+                                        local.get $l2
+                                        local.get $l3
+                                        i32.le_u
+                                        br_if $B7
+                                        local.get $p0
+                                        local.get $l3
+                                        i32.store offset=4
+                                        local.get $p0
+                                        local.get $l7
+                                        i32.store
+                                        local.get $p1
+                                        local.get $l2
+                                        local.get $l5
+                                        i32.sub
+                                        i32.store offset=4
+                                        local.get $p1
+                                        local.get $l5
+                                        local.get $l7
+                                        i32.add
+                                        i32.store
+                                        br $B2
+                                      end
+                                      local.get $l3
+                                      i32.const 2
+                                      i32.add
+                                      local.get $l5
+                                      local.get $l7
+                                      i32.add
+                                      local.tee $l4
+                                      i32.const 0
+                                      local.get $l2
+                                      local.get $l5
+                                      i32.gt_u
+                                      select
+                                      local.tee $l6
+                                      i32.const 1054337
+                                      local.get $l6
+                                      select
+                                      i32.load8_u
+                                      i32.const 192
+                                      i32.and
+                                      i32.const 128
+                                      i32.eq
+                                      br_if $B14
+                                      drop
+                                      local.get $l2
+                                      local.get $l3
+                                      i32.lt_u
+                                      br_if $B8
+                                      local.get $l2
+                                      local.get $l3
+                                      i32.le_u
+                                      br_if $B7
+                                      br $B3
+                                    end
+                                    local.get $l5
+                                    local.get $l7
+                                    i32.add
+                                    local.tee $l4
+                                    i32.const 0
+                                    local.get $l2
+                                    local.get $l5
+                                    i32.gt_u
+                                    select
+                                    local.tee $l6
+                                    i32.const 1054337
+                                    local.get $l6
+                                    select
+                                    i32.load8_u
+                                    local.set $l8
+                                    block $B19
+                                      block $B20
+                                        local.get $l10
+                                        i32.const -224
+                                        i32.add
+                                        local.tee $l6
+                                        i32.const 13
+                                        i32.gt_u
+                                        br_if $B20
+                                        block $B21
+                                          block $B22
+                                            local.get $l6
+                                            i32.const 1
+                                            i32.sub
+                                            br_table $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B20 $B21 $B22
+                                          end
+                                          local.get $l8
+                                          i32.const 224
+                                          i32.and
+                                          i32.const 160
+                                          i32.eq
+                                          br_if $B19
+                                          br $B9
+                                        end
+                                        local.get $l8
+                                        i32.const 24
+                                        i32.shl
+                                        i32.const 24
+                                        i32.shr_s
+                                        i32.const -1
+                                        i32.gt_s
+                                        local.get $l8
+                                        i32.const 160
+                                        i32.ge_u
+                                        i32.or
+                                        br_if $B9
+                                        br $B19
+                                      end
+                                      local.get $l11
+                                      i32.const 31
+                                      i32.add
+                                      i32.const 255
+                                      i32.and
+                                      i32.const 11
+                                      i32.le_u
+                                      if $I23
+                                        local.get $l8
+                                        i32.const 24
+                                        i32.shl
+                                        i32.const 24
+                                        i32.shr_s
+                                        i32.const -1
+                                        i32.gt_s
+                                        local.get $l8
+                                        i32.const 192
+                                        i32.ge_u
+                                        i32.or
+                                        br_if $B9
+                                        br $B19
+                                      end
+                                      local.get $l11
+                                      i32.const 254
+                                      i32.and
+                                      i32.const 238
+                                      i32.ne
+                                      local.get $l8
+                                      i32.const 191
+                                      i32.gt_u
+                                      i32.or
+                                      local.get $l8
+                                      i32.const 24
+                                      i32.shl
+                                      i32.const 24
+                                      i32.shr_s
+                                      i32.const -1
+                                      i32.gt_s
+                                      i32.or
+                                      br_if $B9
+                                    end
+                                    local.get $l3
+                                    i32.const 3
+                                    i32.add
+                                    local.get $l7
+                                    local.get $l3
+                                    i32.const 2
+                                    i32.add
+                                    local.tee $l4
+                                    i32.add
+                                    local.tee $l6
+                                    i32.const 0
+                                    local.get $l2
+                                    local.get $l4
+                                    i32.gt_u
+                                    select
+                                    local.tee $l5
+                                    i32.const 1054337
+                                    local.get $l5
+                                    select
+                                    i32.load8_u
+                                    i32.const 192
+                                    i32.and
+                                    i32.const 128
+                                    i32.eq
+                                    br_if $B14
+                                    drop
+                                    local.get $l2
+                                    local.get $l3
+                                    i32.lt_u
+                                    br_if $B8
+                                    local.get $l3
+                                    i32.const -3
+                                    i32.gt_u
+                                    br_if $B5
+                                    local.get $l2
+                                    local.get $l4
+                                    i32.lt_u
+                                    br_if $B4
+                                    br $B1
+                                  end
+                                  local.get $l5
+                                  local.get $l7
+                                  i32.add
+                                  local.tee $l4
+                                  i32.const 0
+                                  local.get $l2
+                                  local.get $l5
+                                  i32.gt_u
+                                  select
+                                  local.tee $l6
+                                  i32.const 1054337
+                                  local.get $l6
+                                  select
+                                  i32.load8_u
+                                  local.set $l8
+                                  block $B24
+                                    block $B25
+                                      local.get $l10
+                                      i32.const -240
+                                      i32.add
+                                      local.tee $l6
+                                      i32.const 4
+                                      i32.gt_u
+                                      br_if $B25
+                                      block $B26
+                                        block $B27
+                                          local.get $l6
+                                          i32.const 1
+                                          i32.sub
+                                          br_table $B25 $B25 $B25 $B26 $B27
+                                        end
+                                        local.get $l8
+                                        i32.const 112
+                                        i32.add
+                                        i32.const 255
+                                        i32.and
+                                        i32.const 48
+                                        i32.lt_u
+                                        br_if $B24
+                                        br $B10
+                                      end
+                                      local.get $l8
+                                      i32.const 24
+                                      i32.shl
+                                      i32.const 24
+                                      i32.shr_s
+                                      i32.const -1
+                                      i32.gt_s
+                                      local.get $l8
+                                      i32.const 144
+                                      i32.ge_u
+                                      i32.or
+                                      br_if $B10
+                                      br $B24
+                                    end
+                                    local.get $l8
+                                    i32.const 191
+                                    i32.gt_u
+                                    local.get $l11
+                                    i32.const 15
+                                    i32.add
+                                    i32.const 255
+                                    i32.and
+                                    i32.const 2
+                                    i32.gt_u
+                                    i32.or
+                                    local.get $l8
+                                    i32.const 24
+                                    i32.shl
+                                    i32.const 24
+                                    i32.shr_s
+                                    i32.const -1
+                                    i32.gt_s
+                                    i32.or
+                                    br_if $B10
+                                  end
+                                  local.get $l7
+                                  local.get $l3
+                                  i32.const 2
+                                  i32.add
+                                  local.tee $l4
+                                  i32.add
+                                  local.tee $l6
+                                  i32.const 0
+                                  local.get $l2
+                                  local.get $l4
+                                  i32.gt_u
+                                  select
+                                  local.tee $l5
+                                  i32.const 1054337
+                                  local.get $l5
+                                  select
+                                  i32.load8_u
+                                  i32.const 192
+                                  i32.and
+                                  i32.const 128
+                                  i32.ne
+                                  br_if $B12
+                                  local.get $l7
+                                  local.get $l3
+                                  i32.const 3
+                                  i32.add
+                                  local.tee $l4
+                                  i32.add
+                                  local.tee $l6
+                                  i32.const 0
+                                  local.get $l2
+                                  local.get $l4
+                                  i32.gt_u
+                                  select
+                                  local.tee $l5
+                                  i32.const 1054337
+                                  local.get $l5
+                                  select
+                                  i32.load8_u
+                                  i32.const 192
+                                  i32.and
+                                  i32.const 128
+                                  i32.ne
+                                  br_if $B11
+                                  local.get $l3
+                                  i32.const 4
+                                  i32.add
+                                end
+                                local.tee $l3
+                                local.get $l2
+                                i32.lt_u
+                                br_if $L13
+                              end
+                              local.get $p1
+                              i64.const 1
+                              i64.store align=4
+                              local.get $p0
+                              local.get $l2
+                              i32.store offset=4
+                              local.get $p0
+                              local.get $l7
+                              i32.store
+                              local.get $p0
+                              i32.const 8
+                              i32.add
+                              i64.const 1
+                              i64.store align=4
+                              return
+                            end
+                            local.get $l2
+                            local.get $l3
+                            i32.lt_u
+                            br_if $B8
+                            local.get $l3
+                            i32.const -3
+                            i32.gt_u
+                            br_if $B5
+                            local.get $l2
+                            local.get $l4
+                            i32.lt_u
+                            br_if $B4
+                            br $B1
+                          end
+                          local.get $l2
+                          local.get $l3
+                          i32.lt_u
+                          br_if $B8
+                          local.get $l3
+                          i32.const -4
+                          i32.gt_u
+                          br_if $B5
+                          local.get $l2
+                          local.get $l4
+                          i32.lt_u
+                          br_if $B4
+                          local.get $p1
+                          local.get $l6
+                          i32.store
+                          local.get $p0
+                          local.get $l3
+                          i32.store offset=4
+                          local.get $p0
+                          local.get $l7
+                          i32.store
+                          local.get $p1
+                          local.get $l2
+                          local.get $l4
+                          i32.sub
+                          i32.store offset=4
+                          local.get $p0
+                          i32.const 12
+                          i32.add
+                          i32.const 3
+                          i32.store
+                          br $B0
+                        end
+                        local.get $l2
+                        local.get $l3
+                        i32.lt_u
+                        br_if $B8
+                        local.get $l2
+                        local.get $l3
+                        i32.le_u
+                        br_if $B7
+                        br $B3
+                      end
+                      local.get $l2
+                      local.get $l3
+                      i32.lt_u
+                      br_if $B8
+                      local.get $l2
+                      local.get $l3
+                      i32.le_u
+                      br_if $B7
+                      br $B3
+                    end
+                    local.get $l3
+                    local.get $l2
+                    call $f173
+                    unreachable
+                  end
+                  local.get $l5
+                  local.get $l2
+                  call $f173
+                  unreachable
+                end
+                local.get $p0
+                i32.const 0
+                i32.store
+                return
+              end
+              local.get $l3
+              local.get $l4
+              call $f174
+              unreachable
+            end
+            local.get $l4
+            local.get $l2
+            call $f173
+            unreachable
+          end
+          local.get $p1
+          local.get $l4
+          i32.store
+          local.get $p0
+          local.get $l3
+          i32.store offset=4
+          local.get $p0
+          local.get $l7
+          i32.store
+          local.get $p1
+          local.get $l2
+          local.get $l5
+          i32.sub
+          i32.store offset=4
+        end
+        local.get $p0
+        i32.const 12
+        i32.add
+        i32.const 1
+        i32.store
+        br $B0
+      end
+      local.get $p1
+      local.get $l6
+      i32.store
+      local.get $p0
+      local.get $l3
+      i32.store offset=4
+      local.get $p0
+      local.get $l7
+      i32.store
+      local.get $p1
+      local.get $l2
+      local.get $l4
+      i32.sub
+      i32.store offset=4
+      local.get $p0
+      i32.const 12
+      i32.add
+      i32.const 2
+      i32.store
+    end
+    local.get $p0
+    i32.const 8
+    i32.add
+    local.get $l9
+    i32.store)
+  (func $f197 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0
+      block $B1
+        local.get $p1
+        if $I2
+          local.get $l3
+          local.get $p1
+          i32.store offset=12
+          local.get $l3
+          local.get $p0
+          i32.store offset=8
+          local.get $l3
+          i32.const 16
+          i32.add
+          local.get $l3
+          i32.const 8
+          i32.add
+          call $f196
+          local.get $l3
+          i32.load offset=16
+          local.tee $p0
+          if $I3
+            loop $L4
+              local.get $l3
+              i32.load offset=28
+              local.set $l5
+              local.get $l3
+              i32.load offset=20
+              local.tee $l6
+              local.get $p1
+              i32.eq
+              br_if $B1
+              i32.const 1
+              local.set $l4
+              local.get $p2
+              i32.load offset=24
+              local.get $p0
+              local.get $l6
+              local.get $p2
+              i32.load offset=28
+              i32.load offset=12
+              call_indirect (type $t1) $T0
+              br_if $B0
+              local.get $l5
+              if $I5
+                local.get $p2
+                i32.load offset=24
+                i32.const 65533
+                local.get $p2
+                i32.load offset=28
+                i32.load offset=16
+                call_indirect (type $t0) $T0
+                br_if $B0
+              end
+              local.get $l3
+              i32.const 16
+              i32.add
+              local.get $l3
+              i32.const 8
+              i32.add
+              call $f196
+              local.get $l3
+              i32.load offset=16
+              local.tee $p0
+              br_if $L4
+            end
+          end
+          i32.const 0
+          local.set $l4
+          br $B0
+        end
+        local.get $p2
+        i32.const 1054336
+        i32.const 0
+        call $f175
+        local.set $l4
+        br $B0
+      end
+      local.get $l5
+      i32.eqz
+      if $I6
+        local.get $p2
+        local.get $p0
+        local.get $p1
+        call $f175
+        local.set $l4
+        br $B0
+      end
+      i32.const 1054876
+      i32.const 35
+      i32.const 1054936
+      call $f172
+      unreachable
+    end
+    local.get $l3
+    i32.const 32
+    i32.add
+    global.set $g0
+    local.get $l4)
+  (func $f198 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32)
+    block $B0 (result i32)
+      local.get $p0
+      i32.const 2048
+      i32.ge_u
+      if $I1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                block $B6
+                  local.get $p0
+                  i32.const 65536
+                  i32.ge_u
+                  if $I7
+                    local.get $p0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const -16
+                    i32.add
+                    local.tee $l1
+                    i32.const 256
+                    i32.lt_u
+                    br_if $B6
+                    i32.const 1055916
+                    local.get $l1
+                    i32.const 256
+                    call $f171
+                    unreachable
+                  end
+                  local.get $p0
+                  i32.const 6
+                  i32.shr_u
+                  i32.const -32
+                  i32.add
+                  local.tee $l1
+                  i32.const 991
+                  i32.gt_u
+                  br_if $B5
+                  i32.const 1059132
+                  i32.load
+                  local.tee $l2
+                  local.get $l1
+                  i32.const 1059152
+                  i32.add
+                  i32.load8_u
+                  local.tee $l1
+                  i32.le_u
+                  br_if $B4
+                  i32.const 1059128
+                  i32.load
+                  local.get $l1
+                  i32.const 3
+                  i32.shl
+                  i32.add
+                  br $B0
+                end
+                local.get $p0
+                i32.const 6
+                i32.shr_u
+                i32.const 63
+                i32.and
+                local.get $l1
+                i32.const 1060144
+                i32.add
+                i32.load8_u
+                i32.const 6
+                i32.shl
+                i32.or
+                local.tee $l1
+                i32.const 1059140
+                i32.load
+                local.tee $l2
+                i32.ge_u
+                br_if $B3
+                i32.const 1059148
+                i32.load
+                local.tee $l2
+                i32.const 1059136
+                i32.load
+                local.get $l1
+                i32.add
+                i32.load8_u
+                local.tee $l1
+                i32.le_u
+                br_if $B2
+                i32.const 1059144
+                i32.load
+                local.get $l1
+                i32.const 3
+                i32.shl
+                i32.add
+                br $B0
+              end
+              i32.const 1055884
+              local.get $l1
+              i32.const 992
+              call $f171
+              unreachable
+            end
+            i32.const 1055900
+            local.get $l1
+            local.get $l2
+            call $f171
+            unreachable
+          end
+          i32.const 1055932
+          local.get $l1
+          local.get $l2
+          call $f171
+          unreachable
+        end
+        i32.const 1055948
+        local.get $l1
+        local.get $l2
+        call $f171
+        unreachable
+      end
+      local.get $p0
+      i32.const 3
+      i32.shr_u
+      i32.const 536870904
+      i32.and
+      i32.const 1058872
+      i32.add
+    end
+    i64.load
+    i64.const 1
+    local.get $p0
+    i32.const 63
+    i32.and
+    i64.extend_i32_u
+    i64.shl
+    i64.and
+    i64.const 0
+    i64.ne)
+  (func $f199 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    local.get $p0
+    i32.const 65536
+    i32.ge_u
+    if $I0
+      block $B1
+        local.get $p0
+        i32.const 131072
+        i32.ge_u
+        if $I2
+          local.get $p0
+          i32.const -195102
+          i32.add
+          i32.const 722658
+          i32.lt_u
+          local.get $p0
+          i32.const -191457
+          i32.add
+          i32.const 3103
+          i32.lt_u
+          i32.or
+          local.get $p0
+          i32.const 2097150
+          i32.and
+          i32.const 178206
+          i32.eq
+          local.get $p0
+          i32.const -183970
+          i32.add
+          i32.const 14
+          i32.lt_u
+          i32.or
+          i32.or
+          local.get $p0
+          i32.const -173783
+          i32.add
+          i32.const 41
+          i32.lt_u
+          local.get $p0
+          i32.const -177973
+          i32.add
+          i32.const 11
+          i32.lt_u
+          i32.or
+          i32.or
+          br_if $B1
+          local.get $p0
+          i32.const -918000
+          i32.add
+          i32.const 196111
+          i32.gt_u
+          return
+        end
+        local.get $p0
+        i32.const 1056653
+        i32.const 35
+        i32.const 1056723
+        i32.const 166
+        i32.const 1056889
+        i32.const 408
+        call $f227
+        local.set $l1
+      end
+      local.get $l1
+      return
+    end
+    local.get $p0
+    i32.const 1055964
+    i32.const 41
+    i32.const 1056046
+    i32.const 293
+    i32.const 1056339
+    i32.const 314
+    call $f227)
+  (func $f200 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    i32.load8_u
+    local.set $l2
+    i32.const 0
+    local.set $p0
+    loop $L0
+      local.get $p0
+      local.get $l3
+      i32.add
+      i32.const 127
+      i32.add
+      local.get $l2
+      i32.const 15
+      i32.and
+      local.tee $l4
+      i32.const 48
+      i32.or
+      local.get $l4
+      i32.const 87
+      i32.add
+      local.get $l4
+      i32.const 10
+      i32.lt_u
+      select
+      i32.store8
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.set $p0
+      local.get $l2
+      i32.const 4
+      i32.shr_u
+      local.tee $l2
+      br_if $L0
+    end
+    local.get $p0
+    i32.const 128
+    i32.add
+    local.tee $l2
+    i32.const 129
+    i32.ge_u
+    if $I1
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    i32.const 1055569
+    i32.const 2
+    local.get $p0
+    local.get $l3
+    i32.add
+    i32.const 128
+    i32.add
+    i32.const 0
+    local.get $p0
+    i32.sub
+    call $f216
+    local.get $l3
+    i32.const 128
+    i32.add
+    global.set $g0)
+  (func $f201 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i64)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $l3
+    i32.const 8
+    i32.add
+    local.get $p1
+    local.get $p2
+    call $f202
+    local.get $p0
+    block $B0 (result i32)
+      local.get $l3
+      i64.load offset=8
+      local.tee $l4
+      i64.const 1095216660480
+      i64.and
+      i64.const 8589934592
+      i64.ne
+      if $I1
+        local.get $p0
+        local.get $l4
+        i64.store offset=4 align=4
+        i32.const 1
+        br $B0
+      end
+      local.get $p0
+      local.get $p1
+      i32.store offset=4
+      local.get $p0
+      i32.const 8
+      i32.add
+      local.get $p2
+      i32.store
+      i32.const 0
+    end
+    i32.store
+    local.get $l3
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f202 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32)
+    block $B0
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              block $B5
+                local.get $p2
+                i32.eqz
+                br_if $B5
+                i32.const 0
+                local.get $p1
+                i32.sub
+                i32.const 0
+                local.get $p1
+                i32.const 3
+                i32.and
+                select
+                local.set $l8
+                local.get $p2
+                i32.const -7
+                i32.add
+                i32.const 0
+                local.get $p2
+                i32.const 7
+                i32.gt_u
+                select
+                local.set $l7
+                loop $L6
+                  block $B7
+                    block $B8
+                      block $B9
+                        local.get $p1
+                        local.get $l3
+                        i32.add
+                        i32.load8_u
+                        local.tee $l5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        local.tee $l6
+                        i32.const -1
+                        i32.le_s
+                        if $I10
+                          block $B11
+                            block $B12
+                              block $B13
+                                local.get $l5
+                                i32.const 1054975
+                                i32.add
+                                i32.load8_u
+                                i32.const -2
+                                i32.add
+                                local.tee $l4
+                                i32.const 2
+                                i32.le_u
+                                if $I14
+                                  local.get $l4
+                                  i32.const 1
+                                  i32.sub
+                                  br_table $B12 $B11 $B13
+                                end
+                                br $B3
+                              end
+                              local.get $l3
+                              i32.const 1
+                              i32.add
+                              local.tee $l4
+                              local.get $p2
+                              i32.ge_u
+                              if $I15
+                                br $B2
+                              end
+                              local.get $p1
+                              local.get $l4
+                              i32.add
+                              i32.load8_u
+                              i32.const 192
+                              i32.and
+                              i32.const 128
+                              i32.eq
+                              br_if $B9
+                              br $B3
+                            end
+                            local.get $l3
+                            i32.const 1
+                            i32.add
+                            local.tee $l4
+                            local.get $p2
+                            i32.ge_u
+                            if $I16
+                              br $B2
+                            end
+                            local.get $p1
+                            local.get $l4
+                            i32.add
+                            i32.load8_u
+                            local.set $l4
+                            block $B17
+                              block $B18
+                                local.get $l5
+                                i32.const -224
+                                i32.add
+                                local.tee $l5
+                                i32.const 13
+                                i32.gt_u
+                                br_if $B18
+                                block $B19
+                                  block $B20
+                                    local.get $l5
+                                    i32.const 1
+                                    i32.sub
+                                    br_table $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B18 $B19 $B20
+                                  end
+                                  local.get $l4
+                                  i32.const 224
+                                  i32.and
+                                  i32.const 160
+                                  i32.ne
+                                  br_if $B4
+                                  br $B17
+                                end
+                                local.get $l4
+                                i32.const 24
+                                i32.shl
+                                i32.const 24
+                                i32.shr_s
+                                i32.const -1
+                                i32.gt_s
+                                br_if $B4
+                                local.get $l4
+                                i32.const 160
+                                i32.lt_u
+                                br_if $B17
+                                br $B4
+                              end
+                              local.get $l6
+                              i32.const 31
+                              i32.add
+                              i32.const 255
+                              i32.and
+                              i32.const 11
+                              i32.le_u
+                              if $I21
+                                local.get $l4
+                                i32.const 24
+                                i32.shl
+                                i32.const 24
+                                i32.shr_s
+                                i32.const -1
+                                i32.gt_s
+                                local.get $l4
+                                i32.const 192
+                                i32.ge_u
+                                i32.or
+                                br_if $B4
+                                br $B17
+                              end
+                              local.get $l6
+                              i32.const 254
+                              i32.and
+                              i32.const 238
+                              i32.ne
+                              local.get $l4
+                              i32.const 191
+                              i32.gt_u
+                              i32.or
+                              local.get $l4
+                              i32.const 24
+                              i32.shl
+                              i32.const 24
+                              i32.shr_s
+                              i32.const -1
+                              i32.gt_s
+                              i32.or
+                              br_if $B4
+                            end
+                            local.get $l3
+                            i32.const 2
+                            i32.add
+                            local.tee $l4
+                            local.get $p2
+                            i32.ge_u
+                            if $I22
+                              br $B2
+                            end
+                            local.get $p1
+                            local.get $l4
+                            i32.add
+                            i32.load8_u
+                            i32.const 192
+                            i32.and
+                            i32.const 128
+                            i32.eq
+                            br_if $B9
+                            br $B1
+                          end
+                          local.get $l3
+                          i32.const 1
+                          i32.add
+                          local.tee $l4
+                          local.get $p2
+                          i32.ge_u
+                          if $I23
+                            br $B2
+                          end
+                          local.get $p1
+                          local.get $l4
+                          i32.add
+                          i32.load8_u
+                          local.set $l4
+                          block $B24
+                            block $B25
+                              local.get $l5
+                              i32.const -240
+                              i32.add
+                              local.tee $l5
+                              i32.const 4
+                              i32.gt_u
+                              br_if $B25
+                              block $B26
+                                block $B27
+                                  local.get $l5
+                                  i32.const 1
+                                  i32.sub
+                                  br_table $B25 $B25 $B25 $B26 $B27
+                                end
+                                local.get $l4
+                                i32.const 112
+                                i32.add
+                                i32.const 255
+                                i32.and
+                                i32.const 48
+                                i32.ge_u
+                                br_if $B3
+                                br $B24
+                              end
+                              local.get $l4
+                              i32.const 24
+                              i32.shl
+                              i32.const 24
+                              i32.shr_s
+                              i32.const -1
+                              i32.gt_s
+                              br_if $B3
+                              local.get $l4
+                              i32.const 144
+                              i32.lt_u
+                              br_if $B24
+                              br $B3
+                            end
+                            local.get $l4
+                            i32.const 191
+                            i32.gt_u
+                            local.get $l6
+                            i32.const 15
+                            i32.add
+                            i32.const 255
+                            i32.and
+                            i32.const 2
+                            i32.gt_u
+                            i32.or
+                            local.get $l4
+                            i32.const 24
+                            i32.shl
+                            i32.const 24
+                            i32.shr_s
+                            i32.const -1
+                            i32.gt_s
+                            i32.or
+                            br_if $B3
+                          end
+                          local.get $l3
+                          i32.const 2
+                          i32.add
+                          local.tee $l4
+                          local.get $p2
+                          i32.ge_u
+                          if $I28
+                            br $B2
+                          end
+                          local.get $p1
+                          local.get $l4
+                          i32.add
+                          i32.load8_u
+                          i32.const 192
+                          i32.and
+                          i32.const 128
+                          i32.ne
+                          br_if $B1
+                          local.get $l3
+                          i32.const 3
+                          i32.add
+                          local.tee $l4
+                          local.get $p2
+                          i32.ge_u
+                          if $I29
+                            br $B2
+                          end
+                          local.get $p1
+                          local.get $l4
+                          i32.add
+                          i32.load8_u
+                          i32.const 192
+                          i32.and
+                          i32.const 128
+                          i32.eq
+                          br_if $B9
+                          local.get $p0
+                          i32.const 769
+                          i32.store16 offset=4
+                          br $B0
+                        end
+                        local.get $l8
+                        local.get $l3
+                        i32.sub
+                        i32.const 3
+                        i32.and
+                        br_if $B8
+                        block $B30
+                          local.get $l3
+                          local.get $l7
+                          i32.ge_u
+                          br_if $B30
+                          loop $L31
+                            local.get $p1
+                            local.get $l3
+                            i32.add
+                            local.tee $l4
+                            i32.const 4
+                            i32.add
+                            i32.load
+                            local.get $l4
+                            i32.load
+                            i32.or
+                            i32.const -2139062144
+                            i32.and
+                            br_if $B30
+                            local.get $l3
+                            i32.const 8
+                            i32.add
+                            local.tee $l3
+                            local.get $l7
+                            i32.lt_u
+                            br_if $L31
+                          end
+                        end
+                        local.get $l3
+                        local.get $p2
+                        i32.ge_u
+                        br_if $B7
+                        loop $L32
+                          local.get $p1
+                          local.get $l3
+                          i32.add
+                          i32.load8_s
+                          i32.const 0
+                          i32.lt_s
+                          br_if $B7
+                          local.get $p2
+                          local.get $l3
+                          i32.const 1
+                          i32.add
+                          local.tee $l3
+                          i32.ne
+                          br_if $L32
+                        end
+                        br $B5
+                      end
+                      local.get $l4
+                      i32.const 1
+                      i32.add
+                      local.set $l3
+                      br $B7
+                    end
+                    local.get $l3
+                    i32.const 1
+                    i32.add
+                    local.set $l3
+                  end
+                  local.get $l3
+                  local.get $p2
+                  i32.lt_u
+                  br_if $L6
+                end
+              end
+              local.get $p0
+              i32.const 2
+              i32.store8 offset=4
+              return
+            end
+            local.get $p0
+            i32.const 257
+            i32.store16 offset=4
+            local.get $p0
+            local.get $l3
+            i32.store
+            return
+          end
+          local.get $p0
+          i32.const 257
+          i32.store16 offset=4
+          br $B0
+        end
+        local.get $p0
+        i32.const 0
+        i32.store8 offset=4
+        br $B0
+      end
+      local.get $p0
+      i32.const 513
+      i32.store16 offset=4
+    end
+    local.get $p0
+    local.get $l3
+    i32.store)
+  (func $f203 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i64) (local $l6 i64) (local $l7 i64) (local $l8 i64) (local $l9 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0 (result i32)
+      i32.const 1
+      local.get $p0
+      i32.load8_u offset=4
+      br_if $B0
+      drop
+      local.get $p0
+      i32.load8_u offset=5
+      local.set $l4
+      local.get $p0
+      i32.load
+      local.tee $l3
+      i32.load8_u
+      i32.const 4
+      i32.and
+      i32.eqz
+      if $I1
+        local.get $p1
+        local.get $l4
+        if $I2 (result i32)
+          i32.const 1
+          local.get $l3
+          i32.load offset=24
+          i32.const 1055537
+          i32.const 2
+          local.get $l3
+          i32.const 28
+          i32.add
+          i32.load
+          i32.load offset=12
+          call_indirect (type $t1) $T0
+          br_if $B0
+          drop
+          local.get $p0
+          i32.load
+        else
+          local.get $l3
+        end
+        i32.const 1049316
+        i32.load
+        call_indirect (type $t0) $T0
+        br $B0
+      end
+      local.get $l4
+      i32.eqz
+      if $I3
+        i32.const 1
+        local.get $l3
+        i32.load offset=24
+        i32.const 1055549
+        i32.const 1
+        local.get $l3
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        drop
+        local.get $p0
+        i32.load
+        local.set $l3
+      end
+      local.get $l2
+      i32.const 1
+      i32.store8 offset=23
+      local.get $l2
+      local.get $l2
+      i32.const 23
+      i32.add
+      i32.store offset=16
+      local.get $l3
+      i64.load offset=8 align=4
+      local.set $l5
+      local.get $l3
+      i64.load offset=16 align=4
+      local.set $l6
+      local.get $l2
+      i32.const 52
+      i32.add
+      i32.const 1055504
+      i32.store
+      local.get $l2
+      local.get $l3
+      i64.load offset=24 align=4
+      i64.store offset=8
+      local.get $l3
+      i64.load offset=32 align=4
+      local.set $l7
+      local.get $l3
+      i64.load offset=40 align=4
+      local.set $l8
+      local.get $l2
+      local.get $l3
+      i32.load8_u offset=48
+      i32.store8 offset=72
+      local.get $l3
+      i64.load align=4
+      local.set $l9
+      local.get $l2
+      local.get $l8
+      i64.store offset=64
+      local.get $l2
+      local.get $l7
+      i64.store offset=56
+      local.get $l2
+      local.get $l6
+      i64.store offset=40
+      local.get $l2
+      local.get $l5
+      i64.store offset=32
+      local.get $l2
+      local.get $l9
+      i64.store offset=24
+      local.get $l2
+      local.get $l2
+      i32.const 8
+      i32.add
+      i32.store offset=48
+      i32.const 1
+      local.get $p1
+      local.get $l2
+      i32.const 24
+      i32.add
+      i32.const 1049316
+      i32.load
+      call_indirect (type $t0) $T0
+      br_if $B0
+      drop
+      local.get $l2
+      i32.load offset=48
+      i32.const 1055535
+      i32.const 2
+      local.get $l2
+      i32.load offset=52
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+    end
+    local.set $p1
+    local.get $p0
+    i32.const 1
+    i32.store8 offset=5
+    local.get $p0
+    local.get $p1
+    i32.store8 offset=4
+    local.get $l2
+    i32.const 80
+    i32.add
+    global.set $g0)
+  (func $f204 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32) (local $l5 i64)
+    local.get $p1
+    i32.load offset=24
+    i32.const 39
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=16
+    call_indirect (type $t0) $T0
+    i32.eqz
+    if $I0
+      i32.const 2
+      local.set $l2
+      block $B1
+        block $B2
+          block $B3
+            local.get $p0
+            i32.load
+            local.tee $p0
+            i32.const -9
+            i32.add
+            local.tee $l3
+            i32.const 30
+            i32.gt_u
+            if $I4
+              local.get $p0
+              i32.const 92
+              i32.ne
+              br_if $B3
+              br $B2
+            end
+            i32.const 116
+            local.set $l4
+            block $B5
+              block $B6
+                local.get $l3
+                i32.const 1
+                i32.sub
+                br_table $B5 $B3 $B3 $B6 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B3 $B2 $B3 $B3 $B3 $B3 $B2 $B1
+              end
+              i32.const 114
+              local.set $l4
+              br $B1
+            end
+            i32.const 110
+            local.set $l4
+            br $B1
+          end
+          block $B7 (result i64)
+            block $B8
+              local.get $p0
+              call $f198
+              i32.eqz
+              if $I9
+                local.get $p0
+                call $f199
+                i32.eqz
+                br_if $B8
+                i32.const 1
+                local.set $l2
+                br $B2
+              end
+              local.get $p0
+              i32.const 1
+              i32.or
+              i32.clz
+              i32.const 2
+              i32.shr_u
+              i32.const 7
+              i32.xor
+              i64.extend_i32_u
+              i64.const 21474836480
+              i64.or
+              br $B7
+            end
+            local.get $p0
+            i32.const 1
+            i32.or
+            i32.clz
+            i32.const 2
+            i32.shr_u
+            i32.const 7
+            i32.xor
+            i64.extend_i32_u
+            i64.const 21474836480
+            i64.or
+          end
+          local.set $l5
+          i32.const 3
+          local.set $l2
+        end
+        local.get $p0
+        local.set $l4
+      end
+      loop $L10
+        local.get $l2
+        local.set $l3
+        i32.const 92
+        local.set $p0
+        i32.const 1
+        local.set $l2
+        block $B11
+          block $B12
+            block $B13
+              block $B14
+                local.get $l3
+                i32.const 1
+                i32.sub
+                br_table $B12 $B11 $B14 $B13
+              end
+              block $B15
+                block $B16
+                  block $B17
+                    block $B18
+                      block $B19
+                        local.get $l5
+                        i64.const 32
+                        i64.shr_u
+                        i32.wrap_i64
+                        i32.const 255
+                        i32.and
+                        i32.const 1
+                        i32.sub
+                        br_table $B15 $B16 $B17 $B18 $B19 $B13
+                      end
+                      local.get $l5
+                      i64.const -1095216660481
+                      i64.and
+                      i64.const 17179869184
+                      i64.or
+                      local.set $l5
+                      i32.const 3
+                      local.set $l2
+                      br $B11
+                    end
+                    local.get $l5
+                    i64.const -1095216660481
+                    i64.and
+                    i64.const 12884901888
+                    i64.or
+                    local.set $l5
+                    i32.const 117
+                    local.set $p0
+                    i32.const 3
+                    local.set $l2
+                    br $B11
+                  end
+                  local.get $l5
+                  i64.const -1095216660481
+                  i64.and
+                  i64.const 8589934592
+                  i64.or
+                  local.set $l5
+                  i32.const 123
+                  local.set $p0
+                  i32.const 3
+                  local.set $l2
+                  br $B11
+                end
+                local.get $l4
+                local.get $l5
+                i32.wrap_i64
+                local.tee $l3
+                i32.const 2
+                i32.shl
+                i32.const 28
+                i32.and
+                i32.shr_u
+                i32.const 15
+                i32.and
+                local.tee $p0
+                i32.const 48
+                i32.or
+                local.get $p0
+                i32.const 87
+                i32.add
+                local.get $p0
+                i32.const 10
+                i32.lt_u
+                select
+                local.set $p0
+                local.get $l3
+                if $I20
+                  local.get $l5
+                  i64.const -1
+                  i64.add
+                  i64.const 4294967295
+                  i64.and
+                  local.get $l5
+                  i64.const -4294967296
+                  i64.and
+                  i64.or
+                  local.set $l5
+                  i32.const 3
+                  local.set $l2
+                  br $B11
+                end
+                local.get $l5
+                i64.const -1095216660481
+                i64.and
+                i64.const 4294967296
+                i64.or
+                local.set $l5
+                i32.const 3
+                local.set $l2
+                br $B11
+              end
+              local.get $l5
+              i64.const -1095216660481
+              i64.and
+              local.set $l5
+              i32.const 125
+              local.set $p0
+              i32.const 3
+              local.set $l2
+              br $B11
+            end
+            local.get $p1
+            i32.load offset=24
+            i32.const 39
+            local.get $p1
+            i32.load offset=28
+            i32.load offset=16
+            call_indirect (type $t0) $T0
+            return
+          end
+          i32.const 0
+          local.set $l2
+          local.get $l4
+          local.set $p0
+        end
+        local.get $p1
+        i32.load offset=24
+        local.get $p0
+        local.get $p1
+        i32.load offset=28
+        i32.load offset=16
+        call_indirect (type $t0) $T0
+        i32.eqz
+        br_if $L10
+      end
+    end
+    i32.const 1)
+  (func $f205 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    block $B0 (result i32)
+      i32.const 0
+      local.get $p2
+      i32.eqz
+      br_if $B0
+      drop
+      local.get $l3
+      i32.const 40
+      i32.add
+      local.set $l8
+      block $B1
+        block $B2
+          block $B3
+            block $B4
+              loop $L5
+                local.get $p0
+                i32.load offset=8
+                i32.load8_u
+                if $I6
+                  local.get $p0
+                  i32.load
+                  i32.const 1055528
+                  i32.const 4
+                  local.get $p0
+                  i32.load offset=4
+                  i32.load offset=12
+                  call_indirect (type $t1) $T0
+                  br_if $B1
+                end
+                local.get $l3
+                i32.const 10
+                i32.store offset=40
+                local.get $l3
+                i64.const 4294967306
+                i64.store offset=32
+                local.get $l3
+                local.get $p2
+                i32.store offset=28
+                local.get $l3
+                i32.const 0
+                i32.store offset=24
+                local.get $l3
+                local.get $p2
+                i32.store offset=20
+                local.get $l3
+                local.get $p1
+                i32.store offset=16
+                local.get $l3
+                i32.const 8
+                i32.add
+                i32.const 10
+                local.get $p1
+                local.get $p2
+                call $f193
+                block $B7 (result i32)
+                  block $B8
+                    block $B9
+                      local.get $l3
+                      i32.load offset=8
+                      i32.const 1
+                      i32.eq
+                      if $I10
+                        local.get $l3
+                        i32.load offset=12
+                        local.set $l4
+                        loop $L11
+                          local.get $l3
+                          local.get $l4
+                          local.get $l3
+                          i32.load offset=24
+                          i32.add
+                          i32.const 1
+                          i32.add
+                          local.tee $l4
+                          i32.store offset=24
+                          block $B12
+                            local.get $l4
+                            local.get $l3
+                            i32.load offset=36
+                            local.tee $l5
+                            i32.lt_u
+                            if $I13
+                              local.get $l3
+                              i32.load offset=20
+                              local.set $l7
+                              br $B12
+                            end
+                            local.get $l3
+                            i32.load offset=20
+                            local.tee $l7
+                            local.get $l4
+                            i32.lt_u
+                            br_if $B12
+                            local.get $l5
+                            i32.const 5
+                            i32.ge_u
+                            br_if $B4
+                            local.get $l4
+                            local.get $l5
+                            i32.sub
+                            local.tee $l6
+                            local.get $l3
+                            i32.load offset=16
+                            i32.add
+                            local.tee $l9
+                            local.get $l8
+                            i32.eq
+                            br_if $B8
+                            local.get $l9
+                            local.get $l8
+                            local.get $l5
+                            call $f167
+                            i32.eqz
+                            br_if $B8
+                          end
+                          local.get $l3
+                          i32.load offset=28
+                          local.tee $l6
+                          local.get $l4
+                          i32.lt_u
+                          local.get $l7
+                          local.get $l6
+                          i32.lt_u
+                          i32.or
+                          br_if $B9
+                          local.get $l3
+                          local.get $l3
+                          local.get $l5
+                          i32.add
+                          i32.const 39
+                          i32.add
+                          i32.load8_u
+                          local.get $l3
+                          i32.load offset=16
+                          local.get $l4
+                          i32.add
+                          local.get $l6
+                          local.get $l4
+                          i32.sub
+                          call $f193
+                          local.get $l3
+                          i32.load offset=4
+                          local.set $l4
+                          local.get $l3
+                          i32.load
+                          i32.const 1
+                          i32.eq
+                          br_if $L11
+                        end
+                      end
+                      local.get $l3
+                      local.get $l3
+                      i32.load offset=28
+                      i32.store offset=24
+                    end
+                    local.get $p0
+                    i32.load offset=8
+                    i32.const 0
+                    i32.store8
+                    local.get $p2
+                    br $B7
+                  end
+                  local.get $p0
+                  i32.load offset=8
+                  i32.const 1
+                  i32.store8
+                  local.get $l6
+                  i32.const 1
+                  i32.add
+                end
+                local.set $l4
+                local.get $p0
+                i32.load offset=4
+                local.set $l5
+                local.get $p0
+                i32.load
+                local.get $l4
+                i32.eqz
+                local.get $p2
+                local.get $l4
+                i32.eq
+                i32.or
+                local.tee $l6
+                i32.eqz
+                if $I14
+                  local.get $p2
+                  local.get $l4
+                  i32.le_u
+                  br_if $B3
+                  local.get $p1
+                  local.get $l4
+                  i32.add
+                  i32.load8_s
+                  i32.const -65
+                  i32.le_s
+                  br_if $B3
+                end
+                local.get $p1
+                local.get $l4
+                local.get $l5
+                i32.load offset=12
+                call_indirect (type $t1) $T0
+                br_if $B1
+                local.get $l6
+                i32.eqz
+                if $I15
+                  local.get $p2
+                  local.get $l4
+                  i32.le_u
+                  br_if $B2
+                  local.get $p1
+                  local.get $l4
+                  i32.add
+                  i32.load8_s
+                  i32.const -65
+                  i32.le_s
+                  br_if $B2
+                end
+                local.get $p1
+                local.get $l4
+                i32.add
+                local.set $p1
+                local.get $p2
+                local.get $l4
+                i32.sub
+                local.tee $p2
+                br_if $L5
+              end
+              i32.const 0
+              br $B0
+            end
+            local.get $l5
+            i32.const 4
+            call $f173
+            unreachable
+          end
+          local.get $p1
+          local.get $p2
+          i32.const 0
+          local.get $l4
+          call $f176
+          unreachable
+        end
+        local.get $p1
+        local.get $p2
+        local.get $l4
+        local.get $p2
+        call $f176
+        unreachable
+      end
+      i32.const 1
+    end
+    local.get $l3
+    i32.const 48
+    i32.add
+    global.set $g0)
+  (func $f206 (type $t4) (param $p0 i32) (param $p1 i32) (param $p2 i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i64) (local $l7 i64) (local $l8 i64) (local $l9 i64) (local $l10 i64)
+    global.get $g0
+    i32.const 80
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    block $B0 (result i32)
+      i32.const 1
+      local.get $p0
+      i32.load8_u offset=8
+      br_if $B0
+      drop
+      local.get $p0
+      i32.load offset=4
+      local.set $l5
+      local.get $p0
+      i32.load
+      local.tee $l4
+      i32.load8_u
+      i32.const 4
+      i32.and
+      i32.eqz
+      if $I1
+        i32.const 1
+        local.get $l4
+        i32.load offset=24
+        i32.const 1055537
+        i32.const 1055547
+        local.get $l5
+        select
+        i32.const 2
+        i32.const 1
+        local.get $l5
+        select
+        local.get $l4
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        drop
+        local.get $p1
+        local.get $p0
+        i32.load
+        local.get $p2
+        i32.load offset=12
+        call_indirect (type $t0) $T0
+        br $B0
+      end
+      local.get $l5
+      i32.eqz
+      if $I2
+        i32.const 1
+        local.get $l4
+        i32.load offset=24
+        i32.const 1055545
+        i32.const 2
+        local.get $l4
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B0
+        drop
+        local.get $p0
+        i32.load
+        local.set $l4
+      end
+      local.get $l3
+      i32.const 1
+      i32.store8 offset=23
+      local.get $l3
+      local.get $l3
+      i32.const 23
+      i32.add
+      i32.store offset=16
+      local.get $l4
+      i64.load offset=8 align=4
+      local.set $l6
+      local.get $l4
+      i64.load offset=16 align=4
+      local.set $l7
+      local.get $l3
+      i32.const 52
+      i32.add
+      i32.const 1055504
+      i32.store
+      local.get $l3
+      local.get $l4
+      i64.load offset=24 align=4
+      i64.store offset=8
+      local.get $l4
+      i64.load offset=32 align=4
+      local.set $l8
+      local.get $l4
+      i64.load offset=40 align=4
+      local.set $l9
+      local.get $l3
+      local.get $l4
+      i32.load8_u offset=48
+      i32.store8 offset=72
+      local.get $l4
+      i64.load align=4
+      local.set $l10
+      local.get $l3
+      local.get $l9
+      i64.store offset=64
+      local.get $l3
+      local.get $l8
+      i64.store offset=56
+      local.get $l3
+      local.get $l7
+      i64.store offset=40
+      local.get $l3
+      local.get $l6
+      i64.store offset=32
+      local.get $l3
+      local.get $l10
+      i64.store offset=24
+      local.get $l3
+      local.get $l3
+      i32.const 8
+      i32.add
+      i32.store offset=48
+      i32.const 1
+      local.get $p1
+      local.get $l3
+      i32.const 24
+      i32.add
+      local.get $p2
+      i32.load offset=12
+      call_indirect (type $t0) $T0
+      br_if $B0
+      drop
+      local.get $l3
+      i32.load offset=48
+      i32.const 1055535
+      i32.const 2
+      local.get $l3
+      i32.load offset=52
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+    end
+    i32.store8 offset=8
+    local.get $p0
+    local.get $p0
+    i32.load offset=4
+    i32.const 1
+    i32.add
+    i32.store offset=4
+    local.get $l3
+    i32.const 80
+    i32.add
+    global.set $g0)
+  (func $f207 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32) (local $l2 i32)
+    local.get $p0
+    i32.load8_u offset=8
+    local.set $l1
+    local.get $p0
+    i32.load offset=4
+    local.tee $l2
+    if $I0
+      local.get $l1
+      i32.const 255
+      i32.and
+      local.set $l1
+      local.get $p0
+      block $B1 (result i32)
+        i32.const 1
+        local.get $l1
+        br_if $B1
+        drop
+        block $B2
+          local.get $l2
+          i32.const 1
+          i32.ne
+          br_if $B2
+          local.get $p0
+          i32.load8_u offset=9
+          i32.eqz
+          br_if $B2
+          local.get $p0
+          i32.load
+          local.tee $l2
+          i32.load8_u
+          i32.const 4
+          i32.and
+          br_if $B2
+          i32.const 1
+          local.get $l2
+          i32.load offset=24
+          i32.const 1055548
+          i32.const 1
+          local.get $l2
+          i32.const 28
+          i32.add
+          i32.load
+          i32.load offset=12
+          call_indirect (type $t1) $T0
+          br_if $B1
+          drop
+        end
+        local.get $p0
+        i32.load
+        local.tee $l1
+        i32.load offset=24
+        i32.const 1054952
+        i32.const 1
+        local.get $l1
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+      end
+      local.tee $l1
+      i32.store8 offset=8
+    end
+    local.get $l1
+    i32.const 255
+    i32.and
+    i32.const 0
+    i32.ne)
+  (func $f208 (type $t5) (param $p0 i32) (result i32)
+    (local $l1 i32)
+    i32.const 1
+    local.set $l1
+    local.get $p0
+    i32.load8_u offset=4
+    if $I0 (result i32)
+      i32.const 1
+    else
+      local.get $p0
+      i32.load
+      local.tee $p0
+      i32.load offset=24
+      i32.const 1055568
+      i32.const 1
+      local.get $p0
+      i32.const 28
+      i32.add
+      i32.load
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+    end)
+  (func $f209 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    i32.const 0
+    i32.store offset=12
+    local.get $p0
+    local.get $l2
+    i32.const 12
+    i32.add
+    block $B0 (result i32)
+      block $B1
+        local.get $p1
+        i32.const 128
+        i32.ge_u
+        if $I2
+          local.get $p1
+          i32.const 2048
+          i32.lt_u
+          br_if $B1
+          local.get $p1
+          i32.const 65536
+          i32.lt_u
+          if $I3
+            local.get $l2
+            local.get $p1
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=14
+            local.get $l2
+            local.get $p1
+            i32.const 6
+            i32.shr_u
+            i32.const 63
+            i32.and
+            i32.const 128
+            i32.or
+            i32.store8 offset=13
+            local.get $l2
+            local.get $p1
+            i32.const 12
+            i32.shr_u
+            i32.const 15
+            i32.and
+            i32.const 224
+            i32.or
+            i32.store8 offset=12
+            i32.const 3
+            br $B0
+          end
+          local.get $l2
+          local.get $p1
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=15
+          local.get $l2
+          local.get $p1
+          i32.const 18
+          i32.shr_u
+          i32.const 240
+          i32.or
+          i32.store8 offset=12
+          local.get $l2
+          local.get $p1
+          i32.const 6
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=14
+          local.get $l2
+          local.get $p1
+          i32.const 12
+          i32.shr_u
+          i32.const 63
+          i32.and
+          i32.const 128
+          i32.or
+          i32.store8 offset=13
+          i32.const 4
+          br $B0
+        end
+        local.get $l2
+        local.get $p1
+        i32.store8 offset=12
+        i32.const 1
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.const 63
+      i32.and
+      i32.const 128
+      i32.or
+      i32.store8 offset=13
+      local.get $l2
+      local.get $p1
+      i32.const 6
+      i32.shr_u
+      i32.const 31
+      i32.and
+      i32.const 192
+      i32.or
+      i32.store8 offset=12
+      i32.const 2
+    end
+    call $f205
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (func $f210 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1055772
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f211 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    local.get $p2
+    call $f205)
+  (func $f212 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f209)
+  (func $f213 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $l2
+    local.get $p0
+    i32.load
+    i32.store offset=4
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l2
+    i32.const 4
+    i32.add
+    i32.const 1055772
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f214 (type $t14) (param $p0 i64) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i64)
+    global.get $g0
+    i32.const 48
+    i32.sub
+    local.tee $l5
+    global.set $g0
+    i32.const 39
+    local.set $l3
+    block $B0
+      local.get $p0
+      i64.const 10000
+      i64.lt_u
+      if $I1
+        local.get $p0
+        local.set $l8
+        br $B0
+      end
+      loop $L2
+        local.get $l5
+        i32.const 9
+        i32.add
+        local.get $l3
+        i32.add
+        local.tee $l4
+        i32.const -4
+        i32.add
+        local.get $p0
+        local.get $p0
+        i64.const 10000
+        i64.div_u
+        local.tee $l8
+        i64.const 10000
+        i64.mul
+        i64.sub
+        i32.wrap_i64
+        local.tee $l6
+        i32.const 65535
+        i32.and
+        i32.const 100
+        i32.div_u
+        local.tee $l7
+        i32.const 1
+        i32.shl
+        i32.const 1055571
+        i32.add
+        i32.load16_u align=1
+        i32.store16 align=1
+        local.get $l4
+        i32.const -2
+        i32.add
+        local.get $l6
+        local.get $l7
+        i32.const 100
+        i32.mul
+        i32.sub
+        i32.const 65535
+        i32.and
+        i32.const 1
+        i32.shl
+        i32.const 1055571
+        i32.add
+        i32.load16_u align=1
+        i32.store16 align=1
+        local.get $l3
+        i32.const -4
+        i32.add
+        local.set $l3
+        local.get $p0
+        i64.const 99999999
+        i64.gt_u
+        local.get $l8
+        local.set $p0
+        br_if $L2
+      end
+    end
+    local.get $l8
+    i32.wrap_i64
+    local.tee $l4
+    i32.const 99
+    i32.gt_s
+    if $I3
+      local.get $l3
+      i32.const -2
+      i32.add
+      local.tee $l3
+      local.get $l5
+      i32.const 9
+      i32.add
+      i32.add
+      local.get $l8
+      i32.wrap_i64
+      local.tee $l4
+      local.get $l4
+      i32.const 65535
+      i32.and
+      i32.const 100
+      i32.div_u
+      local.tee $l4
+      i32.const 100
+      i32.mul
+      i32.sub
+      i32.const 65535
+      i32.and
+      i32.const 1
+      i32.shl
+      i32.const 1055571
+      i32.add
+      i32.load16_u align=1
+      i32.store16 align=1
+    end
+    block $B4
+      local.get $l4
+      i32.const 10
+      i32.ge_s
+      if $I5
+        local.get $l3
+        i32.const -2
+        i32.add
+        local.tee $l3
+        local.get $l5
+        i32.const 9
+        i32.add
+        i32.add
+        local.get $l4
+        i32.const 1
+        i32.shl
+        i32.const 1055571
+        i32.add
+        i32.load16_u align=1
+        i32.store16 align=1
+        br $B4
+      end
+      local.get $l3
+      i32.const -1
+      i32.add
+      local.tee $l3
+      local.get $l5
+      i32.const 9
+      i32.add
+      i32.add
+      local.get $l4
+      i32.const 48
+      i32.add
+      i32.store8
+    end
+    local.get $p2
+    local.get $p1
+    i32.const 1054336
+    i32.const 0
+    local.get $l5
+    i32.const 9
+    i32.add
+    local.get $l3
+    i32.add
+    i32.const 39
+    local.get $l3
+    i32.sub
+    call $f216
+    local.get $l5
+    i32.const 48
+    i32.add
+    global.set $g0)
+  (func $f215 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    local.set $l3
+    local.get $p1
+    i32.load offset=24
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p0
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p0
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p0
+    i64.load align=4
+    i64.store offset=8
+    local.get $l3
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f216 (type $t12) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (param $p4 i32) (param $p5 i32) (result i32)
+    (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32)
+    block $B0 (result i32)
+      local.get $p1
+      if $I1
+        i32.const 43
+        i32.const 1114112
+        local.get $p0
+        i32.load
+        local.tee $l10
+        i32.const 1
+        i32.and
+        local.tee $p1
+        select
+        local.set $l9
+        local.get $p1
+        local.get $p5
+        i32.add
+        br $B0
+      end
+      local.get $p0
+      i32.load
+      local.set $l10
+      i32.const 45
+      local.set $l9
+      local.get $p5
+      i32.const 1
+      i32.add
+    end
+    local.set $l8
+    block $B2
+      local.get $l10
+      i32.const 4
+      i32.and
+      i32.eqz
+      if $I3
+        i32.const 0
+        local.set $p2
+        br $B2
+      end
+      local.get $p3
+      if $I4
+        local.get $p3
+        local.set $l7
+        local.get $p2
+        local.set $p1
+        loop $L5
+          local.get $l6
+          local.get $p1
+          i32.load8_u
+          i32.const 192
+          i32.and
+          i32.const 128
+          i32.eq
+          i32.add
+          local.set $l6
+          local.get $p1
+          i32.const 1
+          i32.add
+          local.set $p1
+          local.get $l7
+          i32.const -1
+          i32.add
+          local.tee $l7
+          br_if $L5
+        end
+      end
+      local.get $p3
+      local.get $l8
+      i32.add
+      local.get $l6
+      i32.sub
+      local.set $l8
+    end
+    block $B6
+      block $B7
+        local.get $p0
+        i32.load offset=8
+        i32.const 1
+        i32.ne
+        if $I8
+          local.get $p0
+          local.get $l9
+          local.get $p2
+          local.get $p3
+          call $f217
+          br_if $B7
+          br $B6
+        end
+        local.get $p0
+        i32.const 12
+        i32.add
+        i32.load
+        local.tee $l7
+        local.get $l8
+        i32.le_u
+        if $I9
+          local.get $p0
+          local.get $l9
+          local.get $p2
+          local.get $p3
+          call $f217
+          br_if $B7
+          br $B6
+        end
+        block $B10
+          local.get $l10
+          i32.const 8
+          i32.and
+          i32.eqz
+          if $I11
+            i32.const 0
+            local.set $p1
+            local.get $l7
+            local.get $l8
+            i32.sub
+            local.tee $l7
+            local.set $l8
+            block $B12
+              block $B13
+                block $B14
+                  i32.const 1
+                  local.get $p0
+                  i32.load8_u offset=48
+                  local.tee $l6
+                  local.get $l6
+                  i32.const 3
+                  i32.eq
+                  select
+                  i32.const 1
+                  i32.sub
+                  br_table $B13 $B14 $B13 $B12
+                end
+                local.get $l7
+                i32.const 1
+                i32.shr_u
+                local.set $p1
+                local.get $l7
+                i32.const 1
+                i32.add
+                i32.const 1
+                i32.shr_u
+                local.set $l8
+                br $B12
+              end
+              i32.const 0
+              local.set $l8
+              local.get $l7
+              local.set $p1
+            end
+            local.get $p1
+            i32.const 1
+            i32.add
+            local.set $p1
+            loop $L15
+              local.get $p1
+              i32.const -1
+              i32.add
+              local.tee $p1
+              i32.eqz
+              br_if $B10
+              local.get $p0
+              i32.load offset=24
+              local.get $p0
+              i32.load offset=4
+              local.get $p0
+              i32.load offset=28
+              i32.load offset=16
+              call_indirect (type $t0) $T0
+              i32.eqz
+              br_if $L15
+            end
+            i32.const 1
+            return
+          end
+          local.get $p0
+          i32.const 1
+          i32.store8 offset=48
+          local.get $p0
+          i32.const 48
+          i32.store offset=4
+          local.get $p0
+          local.get $l9
+          local.get $p2
+          local.get $p3
+          call $f217
+          br_if $B7
+          i32.const 0
+          local.set $p1
+          local.get $l7
+          local.get $l8
+          i32.sub
+          local.tee $p2
+          local.set $p3
+          block $B16
+            block $B17
+              block $B18
+                i32.const 1
+                local.get $p0
+                i32.load8_u offset=48
+                local.tee $l7
+                local.get $l7
+                i32.const 3
+                i32.eq
+                select
+                i32.const 1
+                i32.sub
+                br_table $B17 $B18 $B17 $B16
+              end
+              local.get $p2
+              i32.const 1
+              i32.shr_u
+              local.set $p1
+              local.get $p2
+              i32.const 1
+              i32.add
+              i32.const 1
+              i32.shr_u
+              local.set $p3
+              br $B16
+            end
+            i32.const 0
+            local.set $p3
+            local.get $p2
+            local.set $p1
+          end
+          local.get $p1
+          i32.const 1
+          i32.add
+          local.set $p1
+          block $B19
+            loop $L20
+              local.get $p1
+              i32.const -1
+              i32.add
+              local.tee $p1
+              i32.eqz
+              br_if $B19
+              local.get $p0
+              i32.load offset=24
+              local.get $p0
+              i32.load offset=4
+              local.get $p0
+              i32.load offset=28
+              i32.load offset=16
+              call_indirect (type $t0) $T0
+              i32.eqz
+              br_if $L20
+            end
+            i32.const 1
+            return
+          end
+          local.get $p0
+          i32.load offset=4
+          local.set $p1
+          local.get $p0
+          i32.load offset=24
+          local.get $p4
+          local.get $p5
+          local.get $p0
+          i32.load offset=28
+          i32.load offset=12
+          call_indirect (type $t1) $T0
+          br_if $B7
+          local.get $p3
+          i32.const 1
+          i32.add
+          local.set $l6
+          local.get $p0
+          i32.load offset=28
+          local.set $p2
+          local.get $p0
+          i32.load offset=24
+          local.set $p0
+          loop $L21
+            local.get $l6
+            i32.const -1
+            i32.add
+            local.tee $l6
+            i32.eqz
+            if $I22
+              i32.const 0
+              return
+            end
+            local.get $p0
+            local.get $p1
+            local.get $p2
+            i32.load offset=16
+            call_indirect (type $t0) $T0
+            i32.eqz
+            br_if $L21
+          end
+          br $B7
+        end
+        local.get $p0
+        i32.load offset=4
+        local.set $p1
+        local.get $p0
+        local.get $l9
+        local.get $p2
+        local.get $p3
+        call $f217
+        br_if $B7
+        local.get $p0
+        i32.load offset=24
+        local.get $p4
+        local.get $p5
+        local.get $p0
+        i32.load offset=28
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B7
+        local.get $l8
+        i32.const 1
+        i32.add
+        local.set $l6
+        local.get $p0
+        i32.load offset=28
+        local.set $p2
+        local.get $p0
+        i32.load offset=24
+        local.set $p0
+        loop $L23
+          local.get $l6
+          i32.const -1
+          i32.add
+          local.tee $l6
+          i32.eqz
+          if $I24
+            i32.const 0
+            return
+          end
+          local.get $p0
+          local.get $p1
+          local.get $p2
+          i32.load offset=16
+          call_indirect (type $t0) $T0
+          i32.eqz
+          br_if $L23
+        end
+      end
+      i32.const 1
+      return
+    end
+    local.get $p0
+    i32.load offset=24
+    local.get $p4
+    local.get $p5
+    local.get $p0
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0)
+  (func $f217 (type $t9) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (result i32)
+    block $B0 (result i32)
+      local.get $p1
+      i32.const 1114112
+      i32.ne
+      if $I1
+        i32.const 1
+        local.get $p0
+        i32.load offset=24
+        local.get $p1
+        local.get $p0
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=16
+        call_indirect (type $t0) $T0
+        br_if $B0
+        drop
+      end
+      local.get $p2
+      i32.eqz
+      if $I2
+        i32.const 0
+        return
+      end
+      local.get $p0
+      i32.load offset=24
+      local.get $p2
+      local.get $p3
+      local.get $p0
+      i32.const 28
+      i32.add
+      i32.load
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+    end)
+  (func $f218 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    local.get $p0
+    i32.load offset=24
+    local.get $p1
+    local.get $p2
+    local.get $p0
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0)
+  (func $f219 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p0
+    i32.const 28
+    i32.add
+    i32.load
+    local.set $l3
+    local.get $p0
+    i32.load offset=24
+    local.get $l2
+    i32.const 24
+    i32.add
+    local.get $p1
+    i32.const 16
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    i32.const 16
+    i32.add
+    local.get $p1
+    i32.const 8
+    i32.add
+    i64.load align=4
+    i64.store
+    local.get $l2
+    local.get $p1
+    i64.load align=4
+    i64.store offset=8
+    local.get $l3
+    local.get $l2
+    i32.const 8
+    i32.add
+    call $f179
+    local.get $l2
+    i32.const 32
+    i32.add
+    global.set $g0)
+  (func $f220 (type $t5) (param $p0 i32) (result i32)
+    local.get $p0
+    i32.load8_u
+    i32.const 16
+    i32.and
+    i32.const 4
+    i32.shr_u)
+  (func $f221 (type $t5) (param $p0 i32) (result i32)
+    local.get $p0
+    i32.load8_u
+    i32.const 32
+    i32.and
+    i32.const 5
+    i32.shr_u)
+  (func $f222 (type $t6) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32)
+    local.get $p0
+    local.get $p1
+    i32.load offset=24
+    local.get $p2
+    local.get $p3
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0
+    i32.store8 offset=8
+    local.get $p0
+    local.get $p1
+    i32.store
+    local.get $p0
+    local.get $p3
+    i32.eqz
+    i32.store8 offset=9
+    local.get $p0
+    i32.const 0
+    i32.store offset=4)
+  (func $f223 (type $t3) (param $p0 i32) (param $p1 i32)
+    (local $l2 i32)
+    local.get $p1
+    i32.load offset=24
+    i32.const 1055550
+    i32.const 1
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0
+    local.set $l2
+    local.get $p0
+    i32.const 0
+    i32.store8 offset=5
+    local.get $p0
+    local.get $l2
+    i32.store8 offset=4
+    local.get $p0
+    local.get $p1
+    i32.store)
+  (func $f224 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    (local $l3 i32) (local $l4 i32) (local $l5 i32) (local $l6 i32) (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i32) (local $l14 i32) (local $l15 i64)
+    global.get $g0
+    i32.const 32
+    i32.sub
+    local.tee $l8
+    global.set $g0
+    i32.const 1
+    local.set $l10
+    block $B0
+      block $B1
+        local.get $p2
+        i32.load offset=24
+        i32.const 34
+        local.get $p2
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=16
+        call_indirect (type $t0) $T0
+        br_if $B1
+        block $B2
+          local.get $p1
+          i32.eqz
+          br_if $B2
+          local.get $p0
+          local.get $p1
+          i32.add
+          local.set $l12
+          local.get $p0
+          local.tee $l6
+          local.set $l13
+          loop $L3
+            block $B4
+              local.get $l6
+              i32.const 1
+              i32.add
+              local.set $l4
+              block $B5
+                block $B6 (result i32)
+                  local.get $l6
+                  i32.load8_s
+                  local.tee $l7
+                  i32.const -1
+                  i32.le_s
+                  if $I7
+                    block $B8 (result i32)
+                      local.get $l4
+                      local.get $l12
+                      i32.eq
+                      if $I9
+                        i32.const 0
+                        local.set $l5
+                        local.get $l12
+                        br $B8
+                      end
+                      local.get $l6
+                      i32.load8_u offset=1
+                      i32.const 63
+                      i32.and
+                      local.set $l5
+                      local.get $l6
+                      i32.const 2
+                      i32.add
+                      local.tee $l4
+                    end
+                    local.set $l6
+                    local.get $l5
+                    local.get $l7
+                    i32.const 31
+                    i32.and
+                    local.tee $l11
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    local.get $l7
+                    i32.const 255
+                    i32.and
+                    local.tee $l14
+                    i32.const 223
+                    i32.le_u
+                    br_if $B6
+                    drop
+                    block $B10 (result i32)
+                      local.get $l6
+                      local.get $l12
+                      i32.eq
+                      if $I11
+                        i32.const 0
+                        local.set $l10
+                        local.get $l12
+                        br $B10
+                      end
+                      local.get $l6
+                      i32.load8_u
+                      i32.const 63
+                      i32.and
+                      local.set $l10
+                      local.get $l6
+                      i32.const 1
+                      i32.add
+                      local.tee $l4
+                    end
+                    local.set $l7
+                    local.get $l10
+                    local.get $l5
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    local.tee $l5
+                    local.get $l11
+                    i32.const 12
+                    i32.shl
+                    i32.or
+                    local.get $l14
+                    i32.const 240
+                    i32.lt_u
+                    br_if $B6
+                    drop
+                    block $B12 (result i32)
+                      local.get $l7
+                      local.get $l12
+                      i32.eq
+                      if $I13
+                        local.get $l4
+                        local.set $l6
+                        i32.const 0
+                        br $B12
+                      end
+                      local.get $l7
+                      i32.const 1
+                      i32.add
+                      local.set $l6
+                      local.get $l7
+                      i32.load8_u
+                      i32.const 63
+                      i32.and
+                    end
+                    local.get $l11
+                    i32.const 18
+                    i32.shl
+                    i32.const 1835008
+                    i32.and
+                    local.get $l5
+                    i32.const 6
+                    i32.shl
+                    i32.or
+                    i32.or
+                    local.tee $l5
+                    i32.const 1114112
+                    i32.ne
+                    br_if $B5
+                    br $B4
+                  end
+                  local.get $l7
+                  i32.const 255
+                  i32.and
+                end
+                local.set $l5
+                local.get $l4
+                local.set $l6
+              end
+              i32.const 2
+              local.set $l4
+              block $B14
+                block $B15
+                  block $B16
+                    block $B17
+                      local.get $l5
+                      i32.const -9
+                      i32.add
+                      local.tee $l11
+                      i32.const 30
+                      i32.gt_u
+                      if $I18
+                        local.get $l5
+                        i32.const 92
+                        i32.ne
+                        br_if $B17
+                        br $B16
+                      end
+                      i32.const 116
+                      local.set $l7
+                      block $B19
+                        block $B20
+                          local.get $l11
+                          i32.const 1
+                          i32.sub
+                          br_table $B19 $B17 $B17 $B20 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B17 $B16 $B17 $B17 $B17 $B17 $B16 $B15
+                        end
+                        i32.const 114
+                        local.set $l7
+                        br $B15
+                      end
+                      i32.const 110
+                      local.set $l7
+                      br $B15
+                    end
+                    local.get $l5
+                    call $f198
+                    i32.eqz
+                    if $I21
+                      local.get $l5
+                      call $f199
+                      br_if $B14
+                    end
+                    local.get $l5
+                    i32.const 1
+                    i32.or
+                    i32.clz
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 7
+                    i32.xor
+                    i64.extend_i32_u
+                    i64.const 21474836480
+                    i64.or
+                    local.set $l15
+                    i32.const 3
+                    local.set $l4
+                  end
+                  local.get $l5
+                  local.set $l7
+                end
+                local.get $l8
+                local.get $p1
+                i32.store offset=4
+                local.get $l8
+                local.get $p0
+                i32.store
+                local.get $l8
+                local.get $l3
+                i32.store offset=8
+                local.get $l8
+                local.get $l9
+                i32.store offset=12
+                block $B22
+                  block $B23
+                    local.get $l9
+                    local.get $l3
+                    i32.lt_u
+                    br_if $B23
+                    local.get $l3
+                    i32.eqz
+                    local.get $p1
+                    local.get $l3
+                    i32.eq
+                    i32.or
+                    i32.eqz
+                    if $I24
+                      local.get $l3
+                      local.get $p1
+                      i32.ge_u
+                      br_if $B23
+                      local.get $p0
+                      local.get $l3
+                      i32.add
+                      i32.load8_s
+                      i32.const -65
+                      i32.le_s
+                      br_if $B23
+                    end
+                    local.get $l9
+                    i32.eqz
+                    local.get $p1
+                    local.get $l9
+                    i32.eq
+                    i32.or
+                    i32.eqz
+                    if $I25
+                      local.get $l9
+                      local.get $p1
+                      i32.ge_u
+                      br_if $B23
+                      local.get $p0
+                      local.get $l9
+                      i32.add
+                      i32.load8_s
+                      i32.const -65
+                      i32.le_s
+                      br_if $B23
+                    end
+                    local.get $p2
+                    i32.load offset=24
+                    local.get $p0
+                    local.get $l3
+                    i32.add
+                    local.get $l9
+                    local.get $l3
+                    i32.sub
+                    local.get $p2
+                    i32.load offset=28
+                    i32.load offset=12
+                    call_indirect (type $t1) $T0
+                    i32.eqz
+                    br_if $B22
+                    i32.const 1
+                    local.set $l10
+                    br $B1
+                  end
+                  local.get $l8
+                  local.get $l8
+                  i32.const 12
+                  i32.add
+                  i32.store offset=24
+                  local.get $l8
+                  local.get $l8
+                  i32.const 8
+                  i32.add
+                  i32.store offset=20
+                  local.get $l8
+                  local.get $l8
+                  i32.store offset=16
+                  local.get $l8
+                  i32.const 16
+                  i32.add
+                  local.tee $p0
+                  i32.load
+                  local.tee $p1
+                  i32.load
+                  local.get $p1
+                  i32.load offset=4
+                  local.get $p0
+                  i32.load offset=4
+                  i32.load
+                  local.get $p0
+                  i32.load offset=8
+                  i32.load
+                  call $f176
+                  unreachable
+                end
+                loop $L26
+                  local.get $l4
+                  local.set $l11
+                  i32.const 1
+                  local.set $l10
+                  i32.const 92
+                  local.set $l3
+                  i32.const 1
+                  local.set $l4
+                  block $B27
+                    block $B28 (result i64)
+                      block $B29
+                        block $B30
+                          block $B31
+                            block $B32
+                              local.get $l11
+                              i32.const 1
+                              i32.sub
+                              br_table $B31 $B27 $B32 $B30
+                            end
+                            block $B33
+                              block $B34
+                                block $B35
+                                  block $B36
+                                    local.get $l15
+                                    i64.const 32
+                                    i64.shr_u
+                                    i32.wrap_i64
+                                    i32.const 255
+                                    i32.and
+                                    i32.const 1
+                                    i32.sub
+                                    br_table $B33 $B34 $B35 $B36 $B29 $B30
+                                  end
+                                  local.get $l15
+                                  i64.const -1095216660481
+                                  i64.and
+                                  i64.const 12884901888
+                                  i64.or
+                                  local.set $l15
+                                  i32.const 3
+                                  local.set $l4
+                                  i32.const 117
+                                  local.set $l3
+                                  br $B27
+                                end
+                                local.get $l15
+                                i64.const -1095216660481
+                                i64.and
+                                i64.const 8589934592
+                                i64.or
+                                local.set $l15
+                                i32.const 3
+                                local.set $l4
+                                i32.const 123
+                                local.set $l3
+                                br $B27
+                              end
+                              local.get $l7
+                              local.get $l15
+                              i32.wrap_i64
+                              local.tee $l11
+                              i32.const 2
+                              i32.shl
+                              i32.const 28
+                              i32.and
+                              i32.shr_u
+                              i32.const 15
+                              i32.and
+                              local.tee $l4
+                              i32.const 48
+                              i32.or
+                              local.get $l4
+                              i32.const 87
+                              i32.add
+                              local.get $l4
+                              i32.const 10
+                              i32.lt_u
+                              select
+                              local.set $l3
+                              local.get $l15
+                              i64.const -1
+                              i64.add
+                              i64.const 4294967295
+                              i64.and
+                              local.get $l15
+                              i64.const -4294967296
+                              i64.and
+                              i64.or
+                              local.get $l11
+                              br_if $B28
+                              drop
+                              local.get $l15
+                              i64.const -1095216660481
+                              i64.and
+                              i64.const 4294967296
+                              i64.or
+                              br $B28
+                            end
+                            local.get $l15
+                            i64.const -1095216660481
+                            i64.and
+                            local.set $l15
+                            i32.const 3
+                            local.set $l4
+                            i32.const 125
+                            local.set $l3
+                            br $B27
+                          end
+                          i32.const 0
+                          local.set $l4
+                          local.get $l7
+                          local.set $l3
+                          br $B27
+                        end
+                        block $B37 (result i32)
+                          i32.const 1
+                          local.get $l5
+                          i32.const 128
+                          i32.lt_u
+                          br_if $B37
+                          drop
+                          i32.const 2
+                          local.get $l5
+                          i32.const 2048
+                          i32.lt_u
+                          br_if $B37
+                          drop
+                          i32.const 3
+                          i32.const 4
+                          local.get $l5
+                          i32.const 65536
+                          i32.lt_u
+                          select
+                        end
+                        local.get $l9
+                        i32.add
+                        local.set $l3
+                        br $B14
+                      end
+                      local.get $l15
+                      i64.const -1095216660481
+                      i64.and
+                      i64.const 17179869184
+                      i64.or
+                    end
+                    local.set $l15
+                    i32.const 3
+                    local.set $l4
+                  end
+                  local.get $p2
+                  i32.load offset=24
+                  local.get $l3
+                  local.get $p2
+                  i32.load offset=28
+                  i32.load offset=16
+                  call_indirect (type $t0) $T0
+                  i32.eqz
+                  br_if $L26
+                end
+                br $B1
+              end
+              local.get $l9
+              local.get $l13
+              i32.sub
+              local.get $l6
+              i32.add
+              local.set $l9
+              local.get $l6
+              local.set $l13
+              local.get $l6
+              local.get $l12
+              i32.ne
+              br_if $L3
+            end
+          end
+          local.get $l3
+          i32.eqz
+          local.get $p1
+          local.get $l3
+          i32.eq
+          i32.or
+          br_if $B2
+          local.get $l3
+          local.get $p1
+          i32.ge_u
+          br_if $B0
+          local.get $p0
+          local.get $l3
+          i32.add
+          i32.load8_s
+          i32.const -65
+          i32.le_s
+          br_if $B0
+        end
+        i32.const 1
+        local.set $l10
+        local.get $p2
+        i32.load offset=24
+        local.get $p0
+        local.get $l3
+        i32.add
+        local.get $p1
+        local.get $l3
+        i32.sub
+        local.get $p2
+        i32.load offset=28
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br_if $B1
+        local.get $p2
+        i32.load offset=24
+        i32.const 34
+        local.get $p2
+        i32.load offset=28
+        i32.load offset=16
+        call_indirect (type $t0) $T0
+        local.set $l10
+      end
+      local.get $l8
+      i32.const 32
+      i32.add
+      global.set $g0
+      local.get $l10
+      return
+    end
+    local.get $p0
+    local.get $p1
+    local.get $l3
+    local.get $p1
+    call $f176
+    unreachable)
+  (func $f225 (type $t1) (param $p0 i32) (param $p1 i32) (param $p2 i32) (result i32)
+    local.get $p2
+    local.get $p0
+    local.get $p1
+    call $f175)
+  (func $f226 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.set $l2
+    i32.const 0
+    local.set $p0
+    loop $L0
+      local.get $p0
+      local.get $l3
+      i32.add
+      i32.const 127
+      i32.add
+      local.get $l2
+      i32.const 15
+      i32.and
+      local.tee $l4
+      i32.const 48
+      i32.or
+      local.get $l4
+      i32.const 87
+      i32.add
+      local.get $l4
+      i32.const 10
+      i32.lt_u
+      select
+      i32.store8
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.set $p0
+      local.get $l2
+      i32.const 4
+      i32.shr_u
+      local.tee $l2
+      br_if $L0
+    end
+    local.get $p0
+    i32.const 128
+    i32.add
+    local.tee $l2
+    i32.const 129
+    i32.ge_u
+    if $I1
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    i32.const 1055569
+    i32.const 2
+    local.get $p0
+    local.get $l3
+    i32.add
+    i32.const 128
+    i32.add
+    i32.const 0
+    local.get $p0
+    i32.sub
+    call $f216
+    local.get $l3
+    i32.const 128
+    i32.add
+    global.set $g0)
+  (func $f227 (type $t13) (param $p0 i32) (param $p1 i32) (param $p2 i32) (param $p3 i32) (param $p4 i32) (param $p5 i32) (param $p6 i32) (result i32)
+    (local $l7 i32) (local $l8 i32) (local $l9 i32) (local $l10 i32) (local $l11 i32) (local $l12 i32) (local $l13 i32)
+    i32.const 1
+    local.set $l9
+    block $B0
+      block $B1
+        local.get $p2
+        i32.eqz
+        br_if $B1
+        local.get $p1
+        local.get $p2
+        i32.const 1
+        i32.shl
+        i32.add
+        local.set $l10
+        local.get $p0
+        i32.const 65280
+        i32.and
+        i32.const 8
+        i32.shr_u
+        local.set $l11
+        local.get $p0
+        i32.const 255
+        i32.and
+        local.set $l13
+        block $B2
+          loop $L3
+            local.get $p1
+            i32.const 2
+            i32.add
+            local.set $l12
+            local.get $l7
+            local.get $p1
+            i32.load8_u offset=1
+            local.tee $p2
+            i32.add
+            local.set $l8
+            local.get $l11
+            local.get $p1
+            i32.load8_u
+            local.tee $p1
+            i32.ne
+            if $I4
+              local.get $p1
+              local.get $l11
+              i32.gt_u
+              br_if $B1
+              local.get $l8
+              local.set $l7
+              local.get $l12
+              local.tee $p1
+              local.get $l10
+              i32.ne
+              br_if $L3
+              br $B1
+            end
+            local.get $l8
+            local.get $l7
+            i32.ge_u
+            if $I5
+              local.get $l8
+              local.get $p4
+              i32.gt_u
+              br_if $B2
+              local.get $p3
+              local.get $l7
+              i32.add
+              local.set $p1
+              block $B6
+                loop $L7
+                  local.get $p2
+                  i32.eqz
+                  br_if $B6
+                  local.get $p2
+                  i32.const -1
+                  i32.add
+                  local.set $p2
+                  local.get $p1
+                  i32.load8_u
+                  local.get $p1
+                  i32.const 1
+                  i32.add
+                  local.set $p1
+                  local.get $l13
+                  i32.ne
+                  br_if $L7
+                end
+                i32.const 0
+                local.set $l9
+                br $B0
+              end
+              local.get $l8
+              local.set $l7
+              local.get $l12
+              local.tee $p1
+              local.get $l10
+              i32.ne
+              br_if $L3
+              br $B1
+            end
+          end
+          local.get $l7
+          local.get $l8
+          call $f174
+          unreachable
+        end
+        local.get $l8
+        local.get $p4
+        call $f173
+        unreachable
+      end
+      local.get $p6
+      i32.eqz
+      br_if $B0
+      local.get $p5
+      local.get $p6
+      i32.add
+      local.set $p3
+      local.get $p0
+      i32.const 65535
+      i32.and
+      local.set $p1
+      loop $L8
+        block $B9
+          local.get $p5
+          i32.const 1
+          i32.add
+          local.set $p0
+          block $B10 (result i32)
+            local.get $p0
+            local.get $p5
+            i32.load8_u
+            local.tee $p2
+            i32.const 24
+            i32.shl
+            i32.const 24
+            i32.shr_s
+            local.tee $p4
+            i32.const 0
+            i32.ge_s
+            br_if $B10
+            drop
+            local.get $p0
+            local.get $p3
+            i32.eq
+            br_if $B9
+            local.get $p5
+            i32.load8_u offset=1
+            local.get $p4
+            i32.const 127
+            i32.and
+            i32.const 8
+            i32.shl
+            i32.or
+            local.set $p2
+            local.get $p5
+            i32.const 2
+            i32.add
+          end
+          local.set $p5
+          local.get $p1
+          local.get $p2
+          i32.sub
+          local.tee $p1
+          i32.const 0
+          i32.lt_s
+          br_if $B0
+          local.get $l9
+          i32.const 1
+          i32.xor
+          local.set $l9
+          local.get $p3
+          local.get $p5
+          i32.ne
+          br_if $L8
+          br $B0
+        end
+      end
+      i32.const 1054488
+      i32.const 43
+      i32.const 1054552
+      call $f172
+      unreachable
+    end
+    local.get $l9
+    i32.const 1
+    i32.and)
+  (func $f228 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    local.get $p1
+    i32.load offset=24
+    i32.const 1060424
+    i32.const 9
+    local.get $p1
+    i32.const 28
+    i32.add
+    i32.load
+    i32.load offset=12
+    call_indirect (type $t1) $T0
+    local.set $l3
+    local.get $l2
+    i32.const 0
+    i32.store8 offset=5
+    local.get $l2
+    local.get $l3
+    i32.store8 offset=4
+    local.get $l2
+    local.get $p1
+    i32.store
+    local.get $l2
+    local.get $p0
+    i32.store offset=12
+    local.get $l2
+    i32.const 1060433
+    i32.const 11
+    local.get $l2
+    i32.const 12
+    i32.add
+    i32.const 1060400
+    call $f189
+    local.get $l2
+    local.get $p0
+    i32.const 4
+    i32.add
+    i32.store offset=12
+    local.get $l2
+    i32.const 1060444
+    i32.const 9
+    local.get $l2
+    i32.const 12
+    i32.add
+    i32.const 1060456
+    call $f189
+    local.get $l2
+    i32.load8_u offset=4
+    local.set $p1
+    local.get $l2
+    i32.load8_u offset=5
+    if $I0
+      local.get $p1
+      i32.const 255
+      i32.and
+      local.set $p0
+      local.get $l2
+      block $B1 (result i32)
+        i32.const 1
+        local.get $p0
+        br_if $B1
+        drop
+        local.get $l2
+        i32.load
+        local.tee $p0
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        local.set $p1
+        local.get $p0
+        i32.load offset=24
+        local.set $l3
+        local.get $p0
+        i32.load8_u
+        i32.const 4
+        i32.and
+        i32.eqz
+        if $I2
+          local.get $l3
+          i32.const 1055543
+          i32.const 2
+          local.get $p1
+          call_indirect (type $t1) $T0
+          br $B1
+        end
+        local.get $l3
+        i32.const 1055542
+        i32.const 1
+        local.get $p1
+        call_indirect (type $t1) $T0
+      end
+      local.tee $p1
+      i32.store8 offset=4
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0
+    local.get $p1
+    i32.const 255
+    i32.and
+    i32.const 0
+    i32.ne)
+  (func $f229 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    i32.load8_u
+    local.set $l2
+    i32.const 0
+    local.set $p0
+    loop $L0
+      local.get $p0
+      local.get $l3
+      i32.add
+      i32.const 127
+      i32.add
+      local.get $l2
+      i32.const 15
+      i32.and
+      local.tee $l4
+      i32.const 48
+      i32.or
+      local.get $l4
+      i32.const 55
+      i32.add
+      local.get $l4
+      i32.const 10
+      i32.lt_u
+      select
+      i32.store8
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.set $p0
+      local.get $l2
+      i32.const 4
+      i32.shr_u
+      local.tee $l2
+      br_if $L0
+    end
+    local.get $p0
+    i32.const 128
+    i32.add
+    local.tee $l2
+    i32.const 129
+    i32.ge_u
+    if $I1
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    i32.const 1055569
+    i32.const 2
+    local.get $p0
+    local.get $l3
+    i32.add
+    i32.const 128
+    i32.add
+    i32.const 0
+    local.get $p0
+    i32.sub
+    call $f216
+    local.get $l3
+    i32.const 128
+    i32.add
+    global.set $g0)
+  (func $f230 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l3
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.set $l2
+    i32.const 0
+    local.set $p0
+    loop $L0
+      local.get $p0
+      local.get $l3
+      i32.add
+      i32.const 127
+      i32.add
+      local.get $l2
+      i32.const 15
+      i32.and
+      local.tee $l4
+      i32.const 48
+      i32.or
+      local.get $l4
+      i32.const 55
+      i32.add
+      local.get $l4
+      i32.const 10
+      i32.lt_u
+      select
+      i32.store8
+      local.get $p0
+      i32.const -1
+      i32.add
+      local.set $p0
+      local.get $l2
+      i32.const 4
+      i32.shr_u
+      local.tee $l2
+      br_if $L0
+    end
+    local.get $p0
+    i32.const 128
+    i32.add
+    local.tee $l2
+    i32.const 129
+    i32.ge_u
+    if $I1
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $p1
+    i32.const 1
+    i32.const 1055569
+    i32.const 2
+    local.get $p0
+    local.get $l3
+    i32.add
+    i32.const 128
+    i32.add
+    i32.const 0
+    local.get $p0
+    i32.sub
+    call $f216
+    local.get $l3
+    i32.const 128
+    i32.add
+    global.set $g0)
+  (func $f231 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i64)
+    local.get $p0
+    i32.load
+    local.tee $p0
+    i64.extend_i32_s
+    local.tee $l2
+    local.get $l2
+    i64.const 63
+    i64.shr_s
+    local.tee $l2
+    i64.add
+    local.get $l2
+    i64.xor
+    local.get $p0
+    i32.const -1
+    i32.xor
+    i32.const 31
+    i32.shr_u
+    local.get $p1
+    call $f214)
+  (func $f232 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    local.get $p0
+    i32.load
+    local.get $p1
+    call $f181)
+  (func $f233 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32) (local $l3 i32) (local $l4 i32)
+    global.get $g0
+    i32.const 128
+    i32.sub
+    local.tee $l4
+    global.set $g0
+    local.get $p0
+    i32.load
+    local.set $p0
+    block $B0
+      block $B1
+        block $B2 (result i32)
+          block $B3
+            local.get $p1
+            i32.load
+            local.tee $l3
+            i32.const 16
+            i32.and
+            i32.eqz
+            if $I4
+              local.get $p0
+              i32.load8_u
+              local.set $l2
+              local.get $l3
+              i32.const 32
+              i32.and
+              br_if $B3
+              local.get $l2
+              i64.extend_i32_u
+              i64.const 255
+              i64.and
+              i32.const 1
+              local.get $p1
+              call $f214
+              br $B2
+            end
+            local.get $p0
+            i32.load8_u
+            local.set $l2
+            i32.const 0
+            local.set $p0
+            loop $L5
+              local.get $p0
+              local.get $l4
+              i32.add
+              i32.const 127
+              i32.add
+              local.get $l2
+              i32.const 15
+              i32.and
+              local.tee $l3
+              i32.const 48
+              i32.or
+              local.get $l3
+              i32.const 87
+              i32.add
+              local.get $l3
+              i32.const 10
+              i32.lt_u
+              select
+              i32.store8
+              local.get $p0
+              i32.const -1
+              i32.add
+              local.set $p0
+              local.get $l2
+              i32.const 4
+              i32.shr_u
+              local.tee $l2
+              br_if $L5
+            end
+            local.get $p0
+            i32.const 128
+            i32.add
+            local.tee $l2
+            i32.const 129
+            i32.ge_u
+            br_if $B1
+            local.get $p1
+            i32.const 1
+            i32.const 1055569
+            i32.const 2
+            local.get $p0
+            local.get $l4
+            i32.add
+            i32.const 128
+            i32.add
+            i32.const 0
+            local.get $p0
+            i32.sub
+            call $f216
+            br $B2
+          end
+          i32.const 0
+          local.set $p0
+          loop $L6
+            local.get $p0
+            local.get $l4
+            i32.add
+            i32.const 127
+            i32.add
+            local.get $l2
+            i32.const 15
+            i32.and
+            local.tee $l3
+            i32.const 48
+            i32.or
+            local.get $l3
+            i32.const 55
+            i32.add
+            local.get $l3
+            i32.const 10
+            i32.lt_u
+            select
+            i32.store8
+            local.get $p0
+            i32.const -1
+            i32.add
+            local.set $p0
+            local.get $l2
+            i32.const 4
+            i32.shr_u
+            local.tee $l2
+            br_if $L6
+          end
+          local.get $p0
+          i32.const 128
+          i32.add
+          local.tee $l2
+          i32.const 129
+          i32.ge_u
+          br_if $B0
+          local.get $p1
+          i32.const 1
+          i32.const 1055569
+          i32.const 2
+          local.get $p0
+          local.get $l4
+          i32.add
+          i32.const 128
+          i32.add
+          i32.const 0
+          local.get $p0
+          i32.sub
+          call $f216
+        end
+        local.get $l4
+        i32.const 128
+        i32.add
+        global.set $g0
+        return
+      end
+      local.get $l2
+      i32.const 128
+      call $f174
+      unreachable
+    end
+    local.get $l2
+    i32.const 128
+    call $f174
+    unreachable)
+  (func $f234 (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+    (local $l2 i32)
+    global.get $g0
+    i32.const 16
+    i32.sub
+    local.tee $l2
+    global.set $g0
+    block $B0 (result i32)
+      local.get $p0
+      i32.load
+      local.tee $p0
+      i32.load8_u
+      i32.const 1
+      i32.ne
+      if $I1
+        local.get $p1
+        i32.load offset=24
+        i32.const 1060420
+        i32.const 4
+        local.get $p1
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $t1) $T0
+        br $B0
+      end
+      local.get $l2
+      local.get $p1
+      i32.load offset=24
+      i32.const 1060416
+      i32.const 4
+      local.get $p1
+      i32.const 28
+      i32.add
+      i32.load
+      i32.load offset=12
+      call_indirect (type $t1) $T0
+      i32.store8 offset=8
+      local.get $l2
+      local.get $p1
+      i32.store
+      local.get $l2
+      i32.const 0
+      i32.store8 offset=9
+      local.get $l2
+      i32.const 0
+      i32.store offset=4
+      local.get $l2
+      local.get $p0
+      i32.const 1
+      i32.add
+      i32.store offset=12
+      local.get $l2
+      local.get $l2
+      i32.const 12
+      i32.add
+      i32.const 1055552
+      call $f206
+      local.get $l2
+      i32.load8_u offset=8
+      local.set $p1
+      local.get $l2
+      i32.load offset=4
+      local.tee $p0
+      if $I2
+        local.get $p1
+        i32.const 255
+        i32.and
+        local.set $p1
+        local.get $l2
+        block $B3 (result i32)
+          i32.const 1
+          local.get $p1
+          br_if $B3
+          drop
+          block $B4
+            local.get $p0
+            i32.const 1
+            i32.ne
+            br_if $B4
+            local.get $l2
+            i32.load8_u offset=9
+            i32.eqz
+            br_if $B4
+            local.get $l2
+            i32.load
+            local.tee $p0
+            i32.load8_u
+            i32.const 4
+            i32.and
+            br_if $B4
+            i32.const 1
+            local.get $p0
+            i32.load offset=24
+            i32.const 1055548
+            i32.const 1
+            local.get $p0
+            i32.const 28
+            i32.add
+            i32.load
+            i32.load offset=12
+            call_indirect (type $t1) $T0
+            br_if $B3
+            drop
+          end
+          local.get $l2
+          i32.load
+          local.tee $p0
+          i32.load offset=24
+          i32.const 1054952
+          i32.const 1
+          local.get $p0
+          i32.const 28
+          i32.add
+          i32.load
+          i32.load offset=12
+          call_indirect (type $t1) $T0
+        end
+        local.tee $p1
+        i32.store8 offset=8
+      end
+      local.get $p1
+      i32.const 255
+      i32.and
+      i32.const 0
+      i32.ne
+    end
+    local.get $l2
+    i32.const 16
+    i32.add
+    global.set $g0)
+  (table $T0 104 104 funcref)
+  (memory $memory 17)
+  (global $g0 (mut i32) (i32.const 1048576))
+  (global $__data_end i32 (i32.const 1061136))
+  (global $__heap_base i32 (i32.const 1061136))
+  (export "memory" (memory 0))
+  (export "__data_end" (global 1))
+  (export "__heap_base" (global 2))
+  (export "_start" (func $_start))
+  (export "__original_main" (func $__original_main))
+  (export "main" (func $main))
+  (elem $e0 (i32.const 1) $f21 $f30 $f23 $f215 $f31 $f29 $f32 $f29 $f16 $f29 $f34 $f35 $f47 $f31 $f92 $f93 $f231 $f21 $f46 $f178 $f128 $f45 $f123 $f132 $f29 $f76 $f68 $f72 $f75 $f69 $f73 $f77 $f70 $f74 $f44 $f41 $f29 $f39 $f183 $f66 $f141 $f182 $f29 $f228 $f61 $f125 $f15 $f99 $f96 $f97 $f98 $f21 $f100 $f62 $f118 $f50 $f53 $f119 $f48 $f52 $f60 $f59 $f65 $f124 $f58 $f56 $f110 $f116 $f120 $f49 $f117 $f64 $f105 $f106 $f107 $f108 $f109 $f63 $f135 $f136 $f38 $f137 $f138 $f40 $f43 $f185 $f180 $f204 $f178 $f191 $f29 $f39 $f29 $f205 $f209 $f210 $f29 $f233 $f211 $f212 $f213 $f232 $f234)
+  (data $d0 (i32.const 1048576) "/rustc/3ed3b8bb7b100afecf7d5f52eafbb70fec27f537/src/libcore/slice/mod.rs\00\00\10\00H\00\00\00\f6\0a\00\00\0a\00\00\00\00\00\10\00H\00\00\00\fc\0a\00\00\0e\00\00\00assertion failed: index < len<::core::macros::panic macros>\00\85\00\10\00\1e\00\00\00\03\00\00\00\0a\00\00\00DOG1CAT2DOG=1CAT=2Env vars:\0a\c6\00\10\00\0a\00\00\00\0a\00\00\00\d8\00\10\00\00\00\00\00\d8\00\10\00\01\00\00\00WASI_ENVVAR_TESTHELLODOG \00\00\00\01\01\10\00\04\00\00\00\d8\00\10\00\01\00\00\00DOG_TYPE \00\00\00\18\01\10\00\09\00\00\00\d8\00\10\00\01\00\00\00DOG_TYPESET VAR <\01\10\00\08\00\00\00\d8\00\10\00\01\00\00\00assertion failed: `(left == right)`\0a  left: ``,\0a right: ``: T\01\10\00-\00\00\00\81\01\10\00\0c\00\00\00\8d\01\10\00\03\00\00\00destination and source slices have different lengths\a8\01\10\004\00\00\00/rustc/3ed3b8bb7b100afecf7d5f52eafbb70fec27f537/src/libcore/macros/mod.rs\00\00\00\e4\01\10\00I\00\00\00\17\00\00\00\0d\00\00\00Err\00\06\00\00\00\04\00\00\00\04\00\00\00\07\00\00\00Ok\00\00\08\00\00\00\04\00\00\00\04\00\00\00\09\00\00\00\0a\00\00\00\04\00\00\00\04\00\00\00\0b\00\00\00\0b\00\00\00\0c\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00\1a\00\00\00\1b\00\00\00\1c\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00\1d\00\00\00\1e\00\00\00\1f\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00 \00\00\00!\00\00\00\22\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00#\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00$\00\00\00already borrowedalready mutably borrowed/rustc/3ed3b8bb7b100afecf7d5f52eafbb70fec27f537/src/libcore/macros/mod.rsassertion failed: `(left == right)`\0a  left: ``,\0a right: ``\00Y\03\10\00-\00\00\00\86\03\10\00\0c\00\00\00\92\03\10\00\01\00\00\00\10\03\10\00I\00\00\00\0f\00\00\00(\00\00\00%\00\00\00\00\00\00\00\01\00\00\00&\00\00\00`: \00Y\03\10\00-\00\00\00\86\03\10\00\0c\00\00\00\cc\03\10\00\03\00\00\00called `Option::unwrap()` on a `None` value\00%\00\00\00\00\00\00\00\01\00\00\00'\00\00\00(\00\00\00\10\00\00\00\04\00\00\00)\00\00\00%\00\00\00\00\00\00\00\01\00\00\00*\00\00\00called `Result::unwrap()` on an `Err` value\00+\00\00\00\08\00\00\00\04\00\00\00,\00\00\00-\00\00\00\08\00\00\00\04\00\00\00.\00\00\00<::core::macros::panic macros>\00\00\90\04\10\00\1e\00\00\00\03\00\00\00\0a\00\00\00assertion failed: end <= lenTried to shrink to a larger capacity\19\00\00\00\04\00\00\00\04\00\00\00\0e\00\00\00src/libstd/thread/mod.rs\10\05\10\00\18\00\00\00\89\03\00\00\13\00\00\00inconsistent park state\00\02\00\00\00park state changed unexpectedly\00T\05\10\00\1f\00\00\00\10\05\10\00\18\00\00\00\86\03\00\00\0d\00\00\00\10\05\10\00\18\00\00\00\1f\04\00\00\11\00\00\00failed to generate unique thread ID: bitspace exhaustedthread name may not contain interior null bytes\00\00\10\05\10\00\18\00\00\00\94\04\00\00\12\00\00\00inconsistent state in unparkRUST_BACKTRACE0failed to get environment variable `\00?\06\10\00$\00\00\00\cc\03\10\00\03\00\00\00src/libstd/env.rs\00\00\00t\06\10\00\11\00\00\00\fb\00\00\00\1d\00\00\00failed to set environment variable `` to `\00\00\98\06\10\00$\00\00\00\bc\06\10\00\06\00\00\00\cc\03\10\00\03\00\00\00t\06\10\00\11\00\00\00K\01\00\00\09\00\00\00/\00\00\00\0c\00\00\00\04\00\00\000\00\00\001\00\00\001\00\00\002\00\00\003\00\00\004\00\00\005\00\00\00\22data provided contains a nul bytefailed to write the buffered dataunexpected end of fileother os erroroperation interruptedwrite zerotimed outinvalid datainvalid input parameteroperation would blockentity already existsbroken pipeaddress not availableaddress in usenot connectedconnection abortedconnection resetconnection refusedpermission deniedentity not found6\07\10\00\00\00\00\00 (os error )6\07\10\00\00\00\00\00\88\08\10\00\0b\00\00\00\93\08\10\00\01\00\00\00cannot access stdout during shutdownfailed printing to : \00\00\00\d0\08\10\00\13\00\00\00\e3\08\10\00\02\00\00\00src/libstd/io/stdio.rs\00\00\f8\08\10\00\16\00\00\00\18\03\00\00\09\00\00\00stdoutfailed to write whole bufferformatter error\00\00\006\00\00\00\0c\00\00\00\04\00\00\007\00\00\008\00\00\009\00\00\006\00\00\00\0c\00\00\00\04\00\00\00:\00\00\00;\00\00\00<\00\00\00src/libstd/sync/condvar.rs\00\00\84\09\10\00\1a\00\00\00H\02\00\00\12\00\00\00attempted to use a condition variable with two mutexes\00\00\19\00\00\00\04\00\00\00\04\00\00\00=\00\00\00>\00\00\00src/libstd/sync/once.rs\00\fc\09\10\00\17\00\00\00\a8\01\00\00\15\00\00\00assertion failed: state_and_queue & STATE_MASK == RUNNING\00\00\00\fc\09\10\00\17\00\00\00\8c\01\00\00\15\00\00\00Once instance has previously been poisoned\00\00\fc\09\10\00\17\00\00\00\e9\01\00\00\09\00\00\00src/libstd/sys_common/at_exit_imp.rs\ac\0a\10\00$\00\00\001\00\00\00\0d\00\00\00assertion failed: queue != DONE\00?\00\00\00\10\00\00\00\04\00\00\00@\00\00\00A\00\00\00note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.\0a\14\0b\10\00X\00\00\00full<unknown>PoisonError { inner: .. }src/libstd/sys_common/thread_info.rs\00\00\9a\0b\10\00$\00\00\00(\00\00\00\1a\00\00\00assertion failed: c.borrow().is_none()fatal runtime error: \0a\f6\0b\10\00\15\00\00\00\0b\0c\10\00\01\00\00\00\5cx\00\00\1c\0c\10\00\02\00\00\00\01\00\00\00\00\00\00\00 \00\00\00\08\00\00\00\03")
+  (data $d1 (i32.const 1051716) "\02\00\00\00\03\00\00\00\19\00\00\00\04\00\00\00\04\00\00\00B\00\00\00memory allocation of  bytes failed\00\00\5c\0c\10\00\15\00\00\00q\0c\10\00\0d\00\00\00Box<Any><unnamed>\00\00\00%\00\00\00\00\00\00\00\01\00\00\00C\00\00\00D\00\00\00E\00\00\00F\00\00\00G\00\00\00\00\00\00\00H\00\00\00\08\00\00\00\04\00\00\00I\00\00\00J\00\00\00K\00\00\00L\00\00\00M\00\00\00\00\00\00\00thread '' panicked at '', \00\00\ec\0c\10\00\08\00\00\00\f4\0c\10\00\0f\00\00\00\03\0d\10\00\03\00\00\00\0b\0c\10\00\01\00\00\00note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.\0a\00(\0d\10\00O\00\00\00N\00\00\00\10\00\00\00\04\00\00\00O\00\00\00P\00\00\00/\00\00\00\0c\00\00\00\04\00\00\00Q\00\00\00+\00\00\00\08\00\00\00\04\00\00\00R\00\00\00S\00\00\00+\00\00\00\08\00\00\00\04\00\00\00T\00\00\00thread panicked while processing panic. aborting.\0a\00\00\c8\0d\10\002\00\00\00thread panicked while panicking. aborting.\0a\00\04\0e\10\00+\00\00\00failed to initiate panic, error 8\0e\10\00 \00\00\00NotUnicodeNotPresentNulError\19\00\00\00\04\00\00\00\04\00\00\00U\00\00\00src/libstd/sys/wasi/../wasm/condvar.rs\00\00\8c\0e\10\00&\00\00\00\17\00\00\00\09\00\00\00can't block with web assemblysrc/libstd/sys/wasi/../wasm/mutex.rs\00\00\00\e1\0e\10\00$\00\00\00\16\00\00\00\09\00\00\00cannot recursively acquire mutexsrc/libstd/sys/wasi/os.rs\00\00\008\0f\10\00\19\00\00\00$\00\00\00\0d\00\00\00strerror_r failurerwlock locked for writing\00v\0f\10\00\19\00\00\00operation not supported on wasm yetstack backtrace:\0a\00\00\00\00\00\19\12D;\02?,G\14=30\0a\1b\06FKE7\0fI\0e\17\03@\1d<+6\1fJ-\1c\01 %)!\08\0c\15\16\22.\108>\0b41\18/A\099\11#C2B:\05\04&('\0d*\1e5\07\1aH\13$L\ff\00\00Success\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Link has been severed\00Protocol error\00Bad message\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Operation already in progress\00Operation in progress\00Stale file handle\00Quota exceeded\00Multihop attempted\00Capabilities insufficient\00No error information\00\00src/liballoc/raw_vec.rscapacity overflow\00\00F\16\10\00\17\00\00\00\09\03\00\00\05\00\00\00`\00..\82\16\10\00\02\00\00\00BorrowErrorBorrowMutError\00\00\00[\00\00\00\00\00\00\00\01\00\00\00\5c\00\00\00:\00\00\00\80\16\10\00\00\00\00\00\b8\16\10\00\01\00\00\00\b8\16\10\00\01\00\00\00index out of bounds: the len is  but the index is \00\00\d4\16\10\00 \00\00\00\f4\16\10\00\12\00\00\00called `Option::unwrap()` on a `None` valuesrc/libcore/option.rsC\17\10\00\15\00\00\00}\01\00\00\15\00\00\00\80\16\10\00\00\00\00\00C\17\10\00\15\00\00\00\a4\04\00\00\05\00\00\00: \00\00\80\16\10\00\00\00\00\00\80\17\10\00\02\00\00\00src/libcore/result.rs\00\00\00\94\17\10\00\15\00\00\00\a4\04\00\00\05\00\00\00src/libcore/slice/mod.rsindex  out of range for slice of length \d4\17\10\00\06\00\00\00\da\17\10\00\22\00\00\00\bc\17\10\00\18\00\00\00r\0a\00\00\05\00\00\00slice index starts at  but ends at \00\1c\18\10\00\16\00\00\002\18\10\00\0d\00\00\00\bc\17\10\00\18\00\00\00x\0a\00\00\05\00\00\00attempted to index slice up to maximum usize\bc\17\10\00\18\00\00\00~\0a\00\00\05\00\00\00assertion failed: broken.is_empty()src/libcore/str/lossy.rs\00\bf\18\10\00\18\00\00\00\9b\00\00\00\11\00\00\00)src/libcore/str/mod.rs\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01")
+  (data $d2 (i32.const 1055169) "\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\03\04\04\04\04\04")
+  (data $d3 (i32.const 1055231) "[...]byte index  is out of bounds of `\00\00\00\04\1a\10\00\0b\00\00\00\0f\1a\10\00\16\00\00\00\80\16\10\00\01\00\00\00\e9\18\10\00\16\00\00\00\04\08\00\00\09\00\00\00begin <= end ( <= ) when slicing `\00\00P\1a\10\00\0e\00\00\00^\1a\10\00\04\00\00\00b\1a\10\00\10\00\00\00\80\16\10\00\01\00\00\00\e9\18\10\00\16\00\00\00\08\08\00\00\05\00\00\00 is not a char boundary; it is inside  (bytes ) of `\04\1a\10\00\0b\00\00\00\a4\1a\10\00&\00\00\00\ca\1a\10\00\08\00\00\00\d2\1a\10\00\06\00\00\00\80\16\10\00\01\00\00\00\e9\18\10\00\16\00\00\00\15\08\00\00\05\00\00\00]\00\00\00\0c\00\00\00\04\00\00\00^\00\00\00_\00\00\00`\00\00\00     {\0a,\0a,  { } }(\0a(,\0a[\00a\00\00\00\04\00\00\00\04\00\00\00b\00\00\00]0x00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899\00a\00\00\00\04\00\00\00\04\00\00\00c\00\00\00d\00\00\00e\00\00\00src/libcore/fmt/mod.rs\00\004\1c\10\00\16\00\00\00S\04\00\00(\00\00\004\1c\10\00\16\00\00\00^\04\00\00(\00\00\00src/libcore/unicode/bool_trie.rsl\1c\10\00 \00\00\00'\00\00\00\19\00\00\00l\1c\10\00 \00\00\00(\00\00\00 \00\00\00l\1c\10\00 \00\00\00*\00\00\00\19\00\00\00l\1c\10\00 \00\00\00+\00\00\00\18\00\00\00l\1c\10\00 \00\00\00,\00\00\00 \00\00\00\00\01\03\05\05\06\06\03\07\06\08\08\09\11\0a\1c\0b\19\0c\14\0d\12\0e\0d\0f\04\10\03\12\12\13\09\16\01\17\05\18\02\19\03\1a\07\1c\02\1d\01\1f\16 \03+\04,\02-\0b.\010\031\022\01\a7\02\a9\02\aa\04\ab\08\fa\02\fb\05\fd\04\fe\03\ff\09\adxy\8b\8d\a20WX\8b\8c\90\1c\1d\dd\0e\0fKL\fb\fc./?\5c]_\b5\e2\84\8d\8e\91\92\a9\b1\ba\bb\c5\c6\c9\ca\de\e4\e5\ff\00\04\11\12)147:;=IJ]\84\8e\92\a9\b1\b4\ba\bb\c6\ca\ce\cf\e4\e5\00\04\0d\0e\11\12)14:;EFIJ^de\84\91\9b\9d\c9\ce\cf\0d\11)EIWde\8d\91\a9\b4\ba\bb\c5\c9\df\e4\e5\f0\04\0d\11EIde\80\81\84\b2\bc\be\bf\d5\d7\f0\f1\83\85\8b\a4\a6\be\bf\c5\c7\ce\cf\da\dbH\98\bd\cd\c6\ce\cfINOWY^_\89\8e\8f\b1\b6\b7\bf\c1\c6\c7\d7\11\16\17[\5c\f6\f7\fe\ff\80\0dmq\de\df\0e\0f\1fno\1c\1d_}~\ae\af\bb\bc\fa\16\17\1e\1fFGNOXZ\5c^~\7f\b5\c5\d4\d5\dc\f0\f1\f5rs\8ftu\96\97/_&./\a7\af\b7\bf\c7\cf\d7\df\9a@\97\980\8f\1f\c0\c1\ce\ffNOZ[\07\08\0f\10'/\ee\efno7=?BE\90\91\fe\ffSgu\c8\c9\d0\d1\d8\d9\e7\fe\ff\00 _\22\82\df\04\82D\08\1b\04\06\11\81\ac\0e\80\ab5\1e\15\80\e0\03\19\08\01\04/\044\04\07\03\01\07\06\07\11\0aP\0f\12\07U\08\02\04\1c\0a\09\03\08\03\07\03\02\03\03\03\0c\04\05\03\0b\06\01\0e\15\05:\03\11\07\06\05\10\07W\07\02\07\15\0dP\04C\03-\03\01\04\11\06\0f\0c:\04\1d%_ m\04j%\80\c8\05\82\b0\03\1a\06\82\fd\03Y\07\15\0b\17\09\14\0c\14\0cj\06\0a\06\1a\06Y\07+\05F\0a,\04\0c\04\01\031\0b,\04\1a\06\0b\03\80\ac\06\0a\06\1fAL\04-\03t\08<\03\0f\03<\078\08+\05\82\ff\11\18\08/\11-\03 \10!\0f\80\8c\04\82\97\19\0b\15\88\94\05/\05;\07\02\0e\18\09\80\b00t\0c\80\d6\1a\0c\05\80\ff\05\80\b6\05$\0c\9b\c6\0a\d20\10\84\8d\037\09\81\5c\14\80\b8\08\80\c705\04\0a\068\08F\08\0c\06t\0b\1e\03Z\04Y\09\80\83\18\1c\0a\16\09H\08\80\8a\06\ab\a4\0c\17\041\a1\04\81\da&\07\0c\05\05\80\a5\11\81m\10x(*\06L\04\80\8d\04\80\be\03\1b\03\0f\0d\00\06\01\01\03\01\04\02\08\08\09\02\0a\05\0b\02\10\01\11\04\12\05\13\11\14\02\15\02\17\02\19\04\1c\05\1d\08$\01j\03k\02\bc\02\d1\02\d4\0c\d5\09\d6\02\d7\02\da\01\e0\05\e1\02\e8\02\ee \f0\04\f9\06\fa\02\0c';>NO\8f\9e\9e\9f\06\07\096=>V\f3\d0\d1\04\14\1867VW\bd5\ce\cf\e0\12\87\89\8e\9e\04\0d\0e\11\12)14:EFIJNOdeZ\5c\b6\b7\1b\1c\a8\a9\d8\d9\097\90\91\a8\07\0a;>fi\8f\92o_\ee\efZb\9a\9b'(U\9d\a0\a1\a3\a4\a7\a8\ad\ba\bc\c4\06\0b\0c\15\1d:?EQ\a6\a7\cc\cd\a0\07\19\1a\22%>?\c5\c6\04 #%&(38:HJLPSUVXZ\5c^`cefksx}\7f\8a\a4\aa\af\b0\c0\d0\0cr\a3\a4\cb\ccno^\22{\05\03\04-\03e\04\01/.\80\82\1d\031\0f\1c\04$\09\1e\05+\05D\04\0e*\80\aa\06$\04$\04(\084\0b\01\80\90\817\09\16\0a\08\80\989\03c\08\090\16\05!\03\1b\05\01@8\04K\05/\04\0a\07\09\07@ '\04\0c\096\03:\05\1a\07\04\0c\07PI73\0d3\07.\08\0a\81&\1f\80\81(\08*\80\86\17\09N\04\1e\0fC\0e\19\07\0a\06G\09'\09u\0b?A*\06;\05\0a\06Q\06\01\05\10\03\05\80\8b` H\08\0a\80\a6^\22E\0b\0a\06\0d\139\07\0a6,\04\10\80\c0<dS\0c\01\80\a0E\1bH\08S\1d9\81\07F\0a\1d\03GI7\03\0e\08\0a\069\07\0a\816\19\80\c72\0d\83\9bfu\0b\80\c4\8a\bc\84/\8f\d1\82G\a1\b9\829\07*\04\02`&\0aF\0a(\05\13\82\b0[eK\049\07\11@\04\1c\97\f8\08\82\f3\a5\0d\81\1f1\03\11\04\08\81\8c\89\04k\05\0d\03\09\07\10\93`\80\f6\0as\08n\17F\80\9a\14\0cW\09\19\80\87\81G\03\85B\0f\15\85P+\80\d5-\03\1a\04\02\81p:\05\01\85\00\80\d7)L\04\0a\04\02\83\11DL=\80\c2<\06\01\04U\05\1b4\02\81\0e,\04d\0cV\0a\0d\03]\03=9\1d\0d,\04\09\07\02\0e\06\80\9a\83\d6\0a\0d\03\0b\05t\0cY\07\0c\14\0c\048\08\0a\06(\08\1eRw\031\03\80\a6\0c\14\04\03\05\03\0d\06\85j")
+  (data $d4 (i32.const 1057306) "\c0\fb\ef>\00\00\00\00\00\0e")
+  (data $d5 (i32.const 1057330) "\f8\ff\fb\ff\ff\ff\07\00\00\00\00\00\00\14\fe!\fe\00\0c\00\00\00\02\00\00\00\00\00\00P\1e \80\00\0c\00\00@\06\00\00\00\00\00\00\10\869\02\00\00\00#\00\be!\00\00\0c\00\00\fc\02\00\00\00\00\00\00\d0\1e \c0\00\0c\00\00\00\04\00\00\00\00\00\00@\01 \80\00\00\00\00\00\11\00\00\00\00\00\00\c0\c1=`\00\0c\00\00\00\02\00\00\00\00\00\00\90D0`\00\0c\00\00\00\03\00\00\00\00\00\00X\1e \80\00\0c\00\00\00\00\84\5c\80")
+  (data $d6 (i32.const 1057486) "\f2\07\80\7f")
+  (data $d7 (i32.const 1057502) "\f2\1f\00?")
+  (data $d8 (i32.const 1057515) "\03\00\00\a0\02\00\00\00\00\00\00\fe\7f\df\e0\ff\fe\ff\ff\ff\1f@")
+  (data $d9 (i32.const 1057549) "\e0\fdf\00\00\00\c3\01\00\1e\00d \00 \00\00\00\00\00\00\00\e0\00\00\00\00\00\00\1c\00\00\00\1c\00\00\00\0c\00\00\00\0c\00\00\00\00\00\00\00\b0?@\fe\0f \00\00\00\00\008\00\00\00\00\00\00`\00\00\00\00\02\00\00\00\00\00\00\87\01\04\0e\00\00\80\09\00\00\00\00\00\00@\7f\e5\1f\f8\9f\00\00\00\00\00\00\ff\7f\0f\00\00\00\00\00\f0\17\04\00\00\00\00\f8\0f\00\03\00\00\00<;\00\00\00\00\00\00@\a3\03\00\00\00\00\00\00\f0\cf\00\00\00\f7\ff\fd!\10\03\ff\ff\ff\ff\ff\ff\ff\fb\00\10\00\00\00\00\00\00\00\00\ff\ff\ff\ff\01\00\00\00\00\00\00\80\03\00\00\00\00\00\00\00\00\80\00\00\00\00\ff\ff\ff\ff\00\00\00\00\00\fc\00\00\00\00\00\06")
+  (data $d10 (i32.const 1057773) "\80\f7?\00\00\00\c0")
+  (data $d11 (i32.const 1057790) "\03\00D\08\00\00`\00\00\000\00\00\00\ff\ff\03\80\00\00\00\00\c0?\00\00\80\ff\03\00\00\00\00\00\07\00\00\00\00\00\c83\00\00\00\00 \00\00\00\00\00\00\00\00~f\00\08\10\00\00\00\00\00\10\00\00\00\00\00\00\9d\c1\02\00\00\00\000@\00\00\00\00\00 !\00\00\00\00\00@\00\00\00\00\ff\ff\00\00\ff\ff")
+  (data $d12 (i32.const 1057903) "\01\00\00\00\02\00\03")
+  (data $d13 (i32.const 1057936) "\04\00\00\05\00\00\00\00\00\00\00\00\06\00\00\00\00\00\00\00\00\07\00\00\08\09\0a\00\0b\0c\0d\0e\0f\00\00\10\11\12\00\00\13\14\15\16\00\00\17\18\19\1a\1b\00\1c\00\00\00\1d\00\00\00\00\00\00\1e\1f !\00\00\00\00\00\22\00#\00$%&\00\00\00\00'")
+  (data $d14 (i32.const 1058131) "()")
+  (data $d15 (i32.const 1058149) "*+")
+  (data $d16 (i32.const 1058202) ",")
+  (data $d17 (i32.const 1058221) "-.\00\00/")
+  (data $d18 (i32.const 1058256) "012")
+  (data $d19 (i32.const 1058280) "3\00\00\00)\00\00\00\00\00\004")
+  (data $d20 (i32.const 1058315) "5\006")
+  (data $d21 (i32.const 1058344) "78\00\008889")
+  (data $d22 (i32.const 1058423) " \00\00\00\00\01")
+  (data $d23 (i32.const 1058438) "\c0\07n\f0\00\00\00\00\00\87\00\00\00\00`\00\00\00\00\00\00\00\f0\00\00\00\c0\ff\01\00\00\00\00\00\02\00\00\00\00\00\00\ff\7f\00\00\00\00\00\00\80\03\00\00\00\00\00x\06\07\00\00\00\80\ef\1f\00\00\00\00\00\00\00\08\00\03\00\00\00\00\00\c0\7f\00\1e")
+  (data $d24 (i32.const 1058533) "\80\d3@\00\00\00\80\f8\07\00\00\03\00\00\00\00\00\00X\01\00\80\00\c0\1f\1f\00\00\00\00\00\00\00\00\ff\5c\00\00@")
+  (data $d25 (i32.const 1058582) "\f9\a5\0d")
+  (data $d26 (i32.const 1058597) "\80<\b0\01\00\000")
+  (data $d27 (i32.const 1058614) "\f8\a7\01")
+  (data $d28 (i32.const 1058629) "(\bf\00\00\00\00\e0\bc\0f\00\00\00\00\00\00\00\80\ff\06\00\00\f0\0c\01\00\00\00\fe\07\00\00\00\00\f8y\80\00~\0e\00\00\00\00\00\fc\7f\03")
+  (data $d29 (i32.const 1058686) "\7f\bf\00\00\fc\ff\ff\fcm\00\00\00\00\00\00\00~\b4\bf")
+  (data $d30 (i32.const 1058714) "\a3")
+  (data $d31 (i32.const 1058726) "\18\00\00\00\00\00\00\00\1f\00\00\00\00\00\00\00\7f\00\00\80\00\00\00\00\00\00\00\80\07\00\00\00\00\00\00\00\00`\00\00\00\00\00\00\00\00\a0\c3\07\f8\e7\0f\00\00\00<\00\00\1c\00\00\00\00\00\00\00\ff\ff\ff\ff\ff\ff\7f\f8\ff\ff\ff\ff\ff\1f \00\10\00\00\f8\fe\ff\00\00\7f\ff\ff\f9\db\07\00\00\00\00\00\00\00\f0\00\00\00\00\7f\00\00\00\00\00\f0\07")
+  (data $d32 (i32.const 1058852) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")
+  (data $d33 (i32.const 1058968) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")
+  (data $d34 (i32.const 1059016) "\f8\03")
+  (data $d35 (i32.const 1059050) "\fe\ff\ff\ff\ff\bf\b6")
+  (data $d36 (i32.const 1059066) "\ff\07\00\00\00\00\00\f8\ff\ff\00\00\01")
+  (data $d37 (i32.const 1059090) "\c0\9f\9f=\00\00\00\00\02\00\00\00\ff\ff\ff\07")
+  (data $d38 (i32.const 1059116) "\c0\ff\01\00\00\00\00\00\00\f8\0f \18\22\10\00J\00\00\00h$\10\00\00\02\00\00h&\10\00:\00\00\00\00\01\02\03\04\05\06\07\08\09\08\0a\0b\0c\0d\0e\0f\10\11\12\13\14\02\15\16\17\18\19\1a\1b\1c\1d\1e\1f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a\00\00\00\04\00\00\00\04\00\00\00f\00\00\00SomeNoneUtf8Errorvalid_up_toerror_len\00\00\00a\00\00\00\04\00\00\00\04\00\00\00g")
+  (data $d39 (i32.const 1060472) "\01\00\00\00\00\00\00\00\01\00\00\00\e40\10"))
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-condvar.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-condvar.wasm
new file mode 100755
index 0000000..4aad038
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-condvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-epoll.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-epoll.wasm
new file mode 100644
index 0000000..990c9ad
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-epoll.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-execve.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-execve.wasm
new file mode 100644
index 0000000..a7391e0
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-execve.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork-longjmp.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork-longjmp.wasm
new file mode 100644
index 0000000..c1286dd
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork-longjmp.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork.wasm
new file mode 100755
index 0000000..355379a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-fork.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-longjmp.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-longjmp.wasm
new file mode 100755
index 0000000..c3033b1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-longjmp.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-pipe.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-pipe.wasm
new file mode 100644
index 0000000..0852716
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-pipe.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-signal.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-signal.wasm
new file mode 100755
index 0000000..f8a7fd5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-signal.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-sleep.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-sleep.wasm
new file mode 100644
index 0000000..3a93942
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-sleep.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-spawn.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-spawn.wasm
new file mode 100644
index 0000000..30705e7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-spawn.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-stack.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-stack.wasm
new file mode 100755
index 0000000..3cf2ddb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-stack.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-client.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-client.wasm
new file mode 100644
index 0000000..98ab0db
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-client.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-listener.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-listener.wasm
new file mode 100644
index 0000000..dcbf767
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-tcp-listener.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-thread-local.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-thread-local.wasm
new file mode 100644
index 0000000..cbb99c4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-thread-local.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-vfork.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-vfork.wasm
new file mode 100644
index 0000000..b6a1a17
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/example-vfork.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/runners.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/runners.rs
new file mode 100644
index 0000000..f2e92a1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/runners.rs
@@ -0,0 +1,284 @@
+// Exclude runner tests from wasm targets for now, since they don't run properly
+// there.
+#![cfg(not(target_family = "wasm"))]
+
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+    time::Duration,
+};
+
+use reqwest::Client;
+use tokio::runtime::Handle;
+use wasmer::Engine;
+use wasmer_wasix::{
+    http::HttpClient,
+    runners::Runner,
+    runtime::{
+        module_cache::{FileSystemCache, ModuleCache, SharedCache},
+        package_loader::BuiltinPackageLoader,
+        task_manager::tokio::TokioTaskManager,
+    },
+    PluggableRuntime, Runtime,
+};
+use webc::Container;
+
+mod wasi {
+    use virtual_fs::{AsyncReadExt, AsyncSeekExt};
+    use wasmer_wasix::{bin_factory::BinaryPackage, runners::wasi::WasiRunner, WasiError};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn can_run_wat2wasm() {
+        let webc = download_cached("https://wasmer.io/wasmer/wabt@1.0.37").await;
+        let container = Container::from_bytes(webc).unwrap();
+        let command = &container.manifest().commands["wat2wasm"];
+
+        assert!(WasiRunner::can_run_command(command).unwrap());
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn wat2wasm() {
+        let webc = download_cached("https://wasmer.io/wasmer/wabt@1.0.37").await;
+        let container = Container::from_bytes(webc).unwrap();
+        let (rt, tasks) = runtime();
+        let pkg = BinaryPackage::from_webc(&container, &rt).await.unwrap();
+        let mut stdout = virtual_fs::ArcFile::new(Box::new(virtual_fs::BufferFile::default()));
+
+        let stdout_2 = stdout.clone();
+        let handle = std::thread::spawn(move || {
+            let _guard = tasks.runtime_handle().enter();
+            WasiRunner::new()
+                .with_args(["--version"])
+                .with_stdin(Box::new(virtual_fs::NullFile::default()))
+                .with_stdout(Box::new(stdout_2) as Box<_>)
+                .with_stderr(Box::new(virtual_fs::NullFile::default()))
+                .run_command("wat2wasm", &pkg, Arc::new(rt))
+        });
+
+        handle
+            .join()
+            .unwrap()
+            .expect("The runner encountered an error");
+
+        stdout.rewind().await.unwrap();
+        let mut output = Vec::new();
+        stdout.read_to_end(&mut output).await.unwrap();
+        assert_eq!(String::from_utf8(output).unwrap(), "1.0.37 (git~v1.0.37)\n");
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn python() {
+        let webc = download_cached("https://wasmer.io/python/python@0.1.0").await;
+        let (rt, tasks) = runtime();
+        let container = Container::from_bytes(webc).unwrap();
+        let pkg = BinaryPackage::from_webc(&container, &rt).await.unwrap();
+
+        let handle = std::thread::spawn(move || {
+            let _guard = tasks.runtime_handle().enter();
+            WasiRunner::new()
+                .with_args(["-c", "import sys; sys.exit(42)"])
+                .with_stdin(Box::new(virtual_fs::NullFile::default()))
+                .with_stdout(Box::new(virtual_fs::NullFile::default()))
+                .with_stderr(Box::new(virtual_fs::NullFile::default()))
+                .run_command("python", &pkg, Arc::new(rt))
+        });
+
+        let err = handle.join().unwrap().unwrap_err();
+        let runtime_error = err.chain().find_map(|e| e.downcast_ref::<WasiError>());
+        let exit_code = match runtime_error {
+            Some(WasiError::Exit(code)) => *code,
+            Some(other) => panic!("Something else went wrong: {:?}", other),
+            None => panic!("Not a WasiError: {:?}", err),
+        };
+        assert_eq!(exit_code.raw(), 42);
+    }
+}
+
+#[cfg(feature = "webc_runner_rt_wcgi")]
+mod wcgi {
+    use std::{future::Future, sync::Arc};
+
+    use futures::{channel::mpsc::Sender, future::AbortHandle, SinkExt, StreamExt};
+    use rand::Rng;
+    use tokio::runtime::Handle;
+    use wasmer_wasix::{
+        bin_factory::BinaryPackage,
+        runners::wcgi::{NoOpWcgiCallbacks, WcgiRunner},
+    };
+
+    use super::*;
+
+    #[tokio::test]
+    async fn can_run_staticserver() {
+        let webc = download_cached("https://wasmer.io/Michael-F-Bryan/staticserver@1.0.3").await;
+        let container = Container::from_bytes(webc).unwrap();
+
+        let entrypoint = container.manifest().entrypoint.as_ref().unwrap();
+        assert!(WcgiRunner::can_run_command(&container.manifest().commands[entrypoint]).unwrap());
+    }
+
+    #[tokio::test]
+    async fn staticserver() {
+        let webc = download_cached("https://wasmer.io/Michael-F-Bryan/staticserver@1.0.3").await;
+        let (rt, tasks) = runtime();
+        let container = Container::from_bytes(webc).unwrap();
+        let mut runner = WcgiRunner::new(NoOpWcgiCallbacks);
+        let port = rand::thread_rng().gen_range(10000_u16..65535_u16);
+        let (cb, started) = callbacks(Handle::current());
+        runner
+            .config()
+            .addr(([127, 0, 0, 1], port).into())
+            .callbacks(cb);
+        let pkg = BinaryPackage::from_webc(&container, &rt).await.unwrap();
+
+        // The server blocks so we need to start it on a background thread.
+        let join_handle = std::thread::spawn(move || {
+            let _guard = tasks.runtime_handle().enter();
+            runner.run_command("serve", &pkg, Arc::new(rt)).unwrap();
+        });
+
+        // wait for the server to have started
+        let abort_handle = started.await;
+
+        // Now the server is running, we can check that it is working by
+        // fetching "/" and checking for known content. We also want the server
+        // to close connections immediately so the graceful shutdown can kill
+        // the server immediately instead of waiting for the connection to time
+        // out.
+        let resp = client()
+            .get(format!("http://localhost:{port}/"))
+            .header("Connection", "close")
+            .send()
+            .await
+            .unwrap();
+        let body = resp.error_for_status().unwrap().text().await.unwrap();
+        assert!(body.contains("<title>Index of /</title>"), "{}", body);
+
+        // Make sure the server is shutdown afterwards. Failing tests will leak
+        // the server thread, but that's fine.
+        abort_handle.abort();
+        if let Err(e) = join_handle.join() {
+            std::panic::resume_unwind(e);
+        }
+    }
+
+    fn callbacks(handle: Handle) -> (Callbacks, impl Future<Output = AbortHandle>) {
+        let (sender, mut rx) = futures::channel::mpsc::channel(1);
+
+        let cb = Callbacks { sender, handle };
+        let fut = async move { rx.next().await.unwrap() };
+
+        (cb, fut)
+    }
+
+    struct Callbacks {
+        sender: Sender<AbortHandle>,
+        handle: Handle,
+    }
+
+    impl wasmer_wasix::runners::wcgi::Callbacks for Callbacks {
+        fn started(&self, abort: futures::stream::AbortHandle) {
+            let mut sender = self.sender.clone();
+            self.handle.spawn(async move {
+                sender.send(abort).await.unwrap();
+            });
+        }
+
+        fn on_stderr(&self, stderr: &[u8]) {
+            panic!(
+                "Something was written to stderr: {}",
+                String::from_utf8_lossy(stderr)
+            );
+        }
+    }
+}
+
+async fn download_cached(url: &str) -> bytes::Bytes {
+    let uri: http::Uri = url.parse().unwrap();
+
+    let file_name = Path::new(uri.path()).file_name().unwrap();
+    let cache_dir = tmp_dir().join("downloads");
+    let cached_path = cache_dir.join(file_name);
+
+    if cached_path.exists() {
+        return std::fs::read(&cached_path).unwrap().into();
+    }
+
+    let response = client()
+        .get(url)
+        .header("Accept", "application/webc")
+        .send()
+        .await
+        .unwrap();
+
+    assert_eq!(
+        response.status(),
+        200,
+        "Unable to get \"{url}\": {}",
+        response.status(),
+    );
+
+    let body = response.bytes().await.unwrap();
+
+    std::fs::create_dir_all(&cache_dir).unwrap();
+    std::fs::write(&cached_path, &body).unwrap();
+
+    body
+}
+
+fn client() -> Client {
+    Client::builder()
+        .connect_timeout(Duration::from_secs(30))
+        .build()
+        .unwrap()
+}
+
+#[cfg(not(target_os = "windows"))]
+fn sanitze_name_for_path(name: &str) -> String {
+    name.into()
+}
+#[cfg(target_os = "windows")]
+fn sanitze_name_for_path(name: &str) -> String {
+    name.replace(":", "_")
+}
+
+fn runtime() -> (impl Runtime + Send + Sync, Arc<TokioTaskManager>) {
+    let tasks = TokioTaskManager::new(Handle::current());
+    let tasks = Arc::new(tasks);
+    let mut rt = PluggableRuntime::new(Arc::clone(&tasks) as Arc<_>);
+
+    let cache = SharedCache::default().with_fallback(FileSystemCache::new(
+        tmp_dir().join("compiled"),
+        tasks.clone(),
+    ));
+
+    let cache_dir = Path::new(env!("CARGO_TARGET_TMPDIR"))
+        .join(env!("CARGO_PKG_NAME"))
+        .join(sanitze_name_for_path(
+            std::thread::current().name().unwrap_or("cache"),
+        ));
+
+    std::fs::create_dir_all(&cache_dir).unwrap();
+
+    let http_client: Arc<dyn HttpClient + Send + Sync> =
+        Arc::new(wasmer_wasix::http::default_http_client().unwrap());
+
+    rt.set_engine(Some(Engine::default()))
+        .set_module_cache(cache)
+        .set_package_loader(
+            BuiltinPackageLoader::new()
+                .with_cache_dir(cache_dir)
+                .with_shared_http_client(http_client.clone()),
+        )
+        .set_http_client(http_client);
+
+    (rt, tasks)
+}
+
+fn tmp_dir() -> PathBuf {
+    Path::new(env!("CARGO_TARGET_TMPDIR"))
+        .join(env!("CARGO_PKG_NAME"))
+        .join(module_path!())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stack.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stack.wasm
new file mode 100755
index 0000000..3cf2ddb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stack.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdin-hello.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdin-hello.wasm
new file mode 100644
index 0000000..5974bcb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdin-hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdio.rs b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdio.rs
new file mode 100644
index 0000000..9875aae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/stdio.rs
@@ -0,0 +1,172 @@
+use virtual_fs::{AsyncReadExt, AsyncWriteExt};
+use wasmer::{Module, Store};
+use wasmer_wasix::{Pipe, WasiEnv};
+
+mod sys {
+    #[tokio::test]
+    async fn test_stdout() {
+        super::test_stdout().await;
+    }
+
+    #[tokio::test]
+    async fn test_stdin() {
+        super::test_stdin().await;
+    }
+
+    #[tokio::test]
+    async fn test_env() {
+        super::test_env().await;
+    }
+}
+
+// #[cfg(feature = "js")]
+// mod js {
+//     use wasm_bindgen_test::*;
+
+//     #[wasm_bindgen_test]
+//     fn test_stdout() {
+//         super::test_stdout();
+//     }
+
+//     #[wasm_bindgen_test]
+//     fn test_stdin() {
+//         super::test_stdin();
+//     }
+
+//     #[wasm_bindgen_test]
+//     fn test_env() {
+//         super::test_env();
+//     }
+// }
+
+async fn test_stdout() {
+    let mut store = Store::default();
+    let module = Module::new(&store, br#"
+    (module
+        ;; Import the required fd_write WASI function which will write the given io vectors to stdout
+        ;; The function signature for fd_write is:
+        ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
+        (import "wasi_unstable" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
+
+        (memory 1)
+        (export "memory" (memory 0))
+
+        ;; Write 'hello world\n' to memory at an offset of 8 bytes
+        ;; No trailing newline is required since all stdio writes are flushing
+        (data (i32.const 8) "hello world")
+
+        (func $main (export "_start")
+            ;; Creating a new io vector within linear memory
+            (i32.store (i32.const 0) (i32.const 8))  ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
+            (i32.store (i32.const 4) (i32.const 11))  ;; iov.iov_len - The length of the 'hello world\n' string
+
+            (call $fd_write
+                (i32.const 1) ;; file_descriptor - 1 for stdout
+                (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
+                (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
+                (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
+            )
+            drop ;; Discard the number of bytes written from the top of the stack
+        )
+    )
+    "#).unwrap();
+
+    // Create the `WasiEnv`.
+    let (stdout_tx, mut stdout_rx) = Pipe::channel();
+
+    let builder = WasiEnv::builder("command-name")
+        .args(["Gordon"])
+        .stdout(Box::new(stdout_tx));
+
+    #[cfg(feature = "js")]
+    {
+        builder.run_with_store(module, &mut store).unwrap();
+    }
+    #[cfg(not(feature = "js"))]
+    {
+        std::thread::spawn(move || builder.run_with_store(module, &mut store))
+            .join()
+            .unwrap()
+            .unwrap();
+    }
+
+    let mut stdout_str = String::new();
+    stdout_rx.read_to_string(&mut stdout_str).await.unwrap();
+    let stdout_as_str = stdout_str.as_str();
+    assert_eq!(stdout_as_str, "hello world");
+}
+
+async fn test_env() {
+    let mut store = Store::default();
+    let module = Module::new(&store, include_bytes!("envvar.wasm")).unwrap();
+
+    #[cfg(feature = "js")]
+    tracing_wasm::set_as_global_default_with_config({
+        let mut builder = tracing_wasm::WASMLayerConfigBuilder::new();
+        builder.set_console_config(tracing_wasm::ConsoleConfig::ReportWithoutConsoleColor);
+        builder.build()
+    });
+
+    // Create the `WasiEnv`.
+    let (pipe_tx, mut pipe_rx) = Pipe::channel();
+
+    let builder = WasiEnv::builder("command-name")
+        .args(["Gordon"])
+        .env("DOG", "X")
+        .env("TEST", "VALUE")
+        .env("TEST2", "VALUE2")
+        .stdout(Box::new(pipe_tx));
+
+    #[cfg(feature = "js")]
+    {
+        builder.run_with_store(module, &mut store).unwrap();
+    }
+
+    #[cfg(not(feature = "js"))]
+    {
+        std::thread::spawn(move || builder.run_with_store(module, &mut store))
+            .join()
+            .unwrap()
+            .unwrap();
+    }
+
+    let mut stdout_str = String::new();
+    pipe_rx.read_to_string(&mut stdout_str).await.unwrap();
+    let stdout_as_str = stdout_str.as_str();
+    assert_eq!(stdout_as_str, "Env vars:\nDOG=X\nTEST2=VALUE2\nTEST=VALUE\nDOG Ok(\"X\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n");
+}
+
+async fn test_stdin() {
+    let mut store = Store::default();
+    let module = Module::new(&store, include_bytes!("stdin-hello.wasm")).unwrap();
+
+    // Create the `WasiEnv`.
+    let (mut pipe_tx, pipe_rx) = Pipe::channel();
+    // FIXME: needed? (method not available)
+    // .with_blocking(false);
+
+    // Write to STDIN
+    let buf = "Hello, stdin!\n".as_bytes().to_owned();
+    pipe_tx.write_all(&buf[..]).await.unwrap();
+
+    let builder = WasiEnv::builder("command-name").stdin(Box::new(pipe_rx));
+
+    #[cfg(feature = "js")]
+    {
+        builder.run_with_store(module, &mut store).unwrap();
+    }
+
+    #[cfg(not(feature = "js"))]
+    {
+        std::thread::spawn(move || builder.run_with_store(module, &mut store))
+            .join()
+            .unwrap()
+            .unwrap();
+    }
+
+    // We assure stdin is now empty
+    // Can't easily be tested with current pipe impl.
+    // let mut buf = Vec::new();
+    // pipe.read_to_end(&mut buf).await.unwrap();
+    // assert_eq!(buf.len(), 0);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/web-server.wasm b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/web-server.wasm
new file mode 100755
index 0000000..ae35be7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/lib/wasix/tests/web-server.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_32v1.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_32v1.txt
new file mode 100644
index 0000000..288acb9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_32v1.txt
@@ -0,0 +1,115 @@
+(interface "wasix_32v1"
+  (func (import "wasix_32v1" "args_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "args_sizes_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "environ_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "environ_sizes_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "clock_res_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "clock_time_get") (param i32 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_advise") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_allocate") (param i32 i64 i64) (result i32))
+  (func (import "wasix_32v1" "fd_close") (param i32) (result i32))
+  (func (import "wasix_32v1" "fd_datasync") (param i32) (result i32))
+  (func (import "wasix_32v1" "fd_fdstat_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_fdstat_set_flags") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_fdstat_set_rights") (param i32 i64 i64) (result i32))
+  (func (import "wasix_32v1" "fd_filestat_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_filestat_set_size") (param i32 i64) (result i32))
+  (func (import "wasix_32v1" "fd_filestat_set_times") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_pread") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_prestat_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_prestat_dir_name") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_pwrite") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_read") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_readdir") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasix_32v1" "fd_renumber") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_dup") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_event") (param i64 i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_seek") (param i32 i64 i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_sync") (param i32) (result i32))
+  (func (import "wasix_32v1" "fd_tell") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "fd_write") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "pipe") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_create_directory") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_filestat_get") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_filestat_set_times") (param  i32 i32 i32 i32 i64 i64 i32) (result i32))
+  (func (import "wasix_32v1" "path_link") (param i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_open") (param i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_readlink") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_remove_directory") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_rename") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_symlink") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "path_unlink_file") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "poll_oneoff") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "proc_exit") (param i32)
+  (func (import "wasix_32v1" "proc_raise") (param i32) (result i32))
+  (func (import "wasix_32v1" "sched_yield") (result i32))
+  (func (import "wasix_32v1" "random_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "tty_get") (param i32) (result i32))
+  (func (import "wasix_32v1" "tty_set") (param i32) (result i32))
+  (func (import "wasix_32v1" "getcwd") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "chdir") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "thread_spawn") (param i64 i32 i32) (result i32))
+  (func (import "wasix_32v1" "thread_sleep") (param i64) (result i32))
+  (func (import "wasix_32v1" "thread_id") (param i32) (result i32))
+  (func (import "wasix_32v1" "thread_local_create") (param i64 i32) (result i32))
+  (func (import "wasix_32v1" "thread_local_destroy") (param i32) (result i32))
+  (func (import "wasix_32v1" "thread_local_set") (param i32 i64) (result i32))
+  (func (import "wasix_32v1" "thread_local_get") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "thread_join") (param i32) (result i32))
+  (func (import "wasix_32v1" "thread_parallelism") (param i32) (result i32))
+  (func (import "wasix_32v1" "futex_wait") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "futex_wake") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "futex_wake_all") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "getpid") (param i32) (result i32))
+  (func (import "wasix_32v1" "thread_exit") (param i32)
+  (func (import "wasix_32v1" "process_spawn") (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "bus_open_local") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "bus_open_remote") (param 32 i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "bus_close") (param i32) (result i32))
+  (func (import "wasix_32v1" "bus_call") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "bus_subcall") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "bus_poll") (param i64 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "call_reply") (param i64 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "call_fault") (param i64 i32)
+  (func (import "wasix_32v1" "call_close") (param i64)
+  (func (import "wasix_32v1" "http_request") (param i32 i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "http_status") (param i32 i32)
+  (func (import "wasix_32v1" "port_bridge") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "port_unbridge") (result i32))
+  (func (import "wasix_32v1" "port_dhcp_acquire") (result i32))
+  (func (import "wasix_32v1" "port_addr_add") (param i32) (result i32))
+  (func (import "wasix_32v1" "port_addr_remove") (param i32) (result i32))
+  (func (import "wasix_32v1" "port_addr_clear") (result i32))
+  (func (import "wasix_32v1" "port_mac") (param i32) (result i32))
+  (func (import "wasix_32v1" "port_addr_list") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "port_gateway_set") (param i32) (result i32))
+  (func (import "wasix_32v1" "port_route_add") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "port_route_remove") (param i32) (result i32))
+  (func (import "wasix_32v1" "port_route_clear") (result i32))
+  (func (import "wasix_32v1" "port_route_list") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_shutdown") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_status") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_addr_local") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_addr_peer") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_open") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_set_opt_flag") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_get_opt_flag") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_set_opt_time") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_get_opt_time") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_set_opt_size") (param i32 i32 i64) (result i32))
+  (func (import "wasix_32v1" "sock_get_opt_size") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_join_multicast_v4") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_leave_multicast_v4") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_join_multicast_v6") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_leave_multicast_v6") (param i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_bind") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_listen") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_accept") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_connect") (param i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_recv") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_recv_from") (param i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_send") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_send_to") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasix_32v1" "sock_send_file") (param i32 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_32v1" "resolve") (param i32 i32 i32 i32 i32 i32) (result i32))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_64v1.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_64v1.txt
new file mode 100644
index 0000000..10f4195
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasixx_64v1.txt
@@ -0,0 +1,115 @@
+(interface "wasix_64v1"
+  (func (import "wasix_64v1" "args_get") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "args_sizes_get") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "environ_get") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "environ_sizes_get") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "clock_res_get") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "clock_time_get") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_advise") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasix_64v1" "fd_allocate") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_close") (param i32) (result i32))
+  (func (import "wasix_64v1" "fd_datasync") (param i32) (result i32))
+  (func (import "wasix_64v1" "fd_fdstat_get") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_fdstat_set_flags") (param i32 i32) (result i32))
+  (func (import "wasix_64v1" "fd_fdstat_set_rights") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_filestat_get") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_filestat_set_size") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_filestat_set_times") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasix_64v1" "fd_pread") (param i32 i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_prestat_get") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_prestat_dir_name") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_pwrite") (param i32 i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_read") (param i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_readdir") (param i32 i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "fd_renumber") (param i32 i32) (result i32))
+  (func (import "wasix_64v1" "fd_dup") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_event") (param i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_seek") (param i32 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_sync") (param i32) (result i32))
+  (func (import "wasix_64v1" "fd_tell") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "fd_write") (param i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "pipe") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_create_directory") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_filestat_get") (param i32 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_filestat_set_times") (param  i32 i32 i64 i64 i64 i64 i32) (result i32))
+  (func (import "wasix_64v1" "path_link") (param i32 i32 i64 i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_open") (param i32 i32 i64 i64 i32 i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "path_readlink") (param i32 i64 i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_remove_directory") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_rename") (param i32 i64 i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_symlink") (param i64 i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "path_unlink_file") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "poll_oneoff") (param i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "proc_exit") (param i32)
+  (func (import "wasix_64v1" "proc_raise") (param i32) (result i32))
+  (func (import "wasix_64v1" "sched_yield") (result i32))
+  (func (import "wasix_64v1" "random_get") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "tty_get") (param i64) (result i32))
+  (func (import "wasix_64v1" "tty_set") (param i64) (result i32))
+  (func (import "wasix_64v1" "getcwd") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "chdir") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "thread_spawn") (param i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "thread_sleep") (param i64) (result i32))
+  (func (import "wasix_64v1" "thread_id") (param i64) (result i32))
+  (func (import "wasix_64v1" "thread_local_create") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "thread_local_destroy") (param i32) (result i32))
+  (func (import "wasix_64v1" "thread_local_set") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "thread_local_get") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "thread_join") (param i32) (result i32))
+  (func (import "wasix_64v1" "thread_parallelism") (param i64) (result i32))
+  (func (import "wasix_64v1" "futex_wait") (param i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "futex_wake") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "futex_wake_all") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "getpid") (param i64) (result i32))
+  (func (import "wasix_64v1" "thread_exit") (param i32)
+  (func (import "wasix_64v1" "process_spawn") (param i64 i64 i32 i64 i64 i64 i64 i32 i32 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "bus_open_local") (param i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "bus_open_remote") (param i64 i64 i32 i64 i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "bus_close") (param i32) (result i32))
+  (func (import "wasix_64v1" "bus_call") (param i32 i64 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "bus_subcall") (param i64 i64 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "bus_poll") (param i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "call_reply") (param i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "call_fault") (param i64 i32)
+  (func (import "wasix_64v1" "call_close") (param i64)
+  (func (import "wasix_64v1" "http_request") (param i64 i64 i64 i64 i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "http_status") (param i32 i64)
+  (func (import "wasix_64v1" "port_bridge") (param i64 i64 i64 i64 i32) (result i32))
+  (func (import "wasix_64v1" "port_unbridge") (result i32))
+  (func (import "wasix_64v1" "port_dhcp_acquire") (result i32))
+  (func (import "wasix_64v1" "port_addr_add") (param i64) (result i32))
+  (func (import "wasix_64v1" "port_addr_remove") (param i64) (result i32))
+  (func (import "wasix_64v1" "port_addr_clear") (result i32))
+  (func (import "wasix_64v1" "port_mac") (param i64) (result i32))
+  (func (import "wasix_64v1" "port_addr_list") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "port_gateway_set") (param i64) (result i32))
+  (func (import "wasix_64v1" "port_route_add") (param i64 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "port_route_remove") (param i64) (result i32))
+  (func (import "wasix_64v1" "port_route_clear") (result i32))
+  (func (import "wasix_64v1" "port_route_list") (param i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_shutdown") (param i32 i32) (result i32))
+  (func (import "wasix_64v1" "sock_status") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_addr_local") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_addr_peer") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_open") (param i32 i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_set_opt_flag") (param i32 i32 i32) (result i32))
+  (func (import "wasix_64v1" "sock_get_opt_flag") (param i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_set_opt_time") (param i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_get_opt_time") (param i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_set_opt_size") (param i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_get_opt_size") (param i32 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_join_multicast_v4") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_leave_multicast_v4") (param i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_join_multicast_v6") (param i32 i64 i32) (result i32))
+  (func (import "wasix_64v1" "sock_leave_multicast_v6") (param i32 i64 i32) (result i32))
+  (func (import "wasix_64v1" "sock_bind") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_listen") (param i32 i32) (result i32))
+  (func (import "wasix_64v1" "sock_accept") (param i32 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_connect") (param i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_recv") (param i32 i64 i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_recv_from") (param i32 i64 i64 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_send") (param i32 i64 i64 i32 i64) (result i32))
+  (func (import "wasix_64v1" "sock_send_to") (param i32 i64 i64 i32 i64 i64) (result i32))
+  (func (import "wasix_64v1" "sock_send_file") (param i32 i32 i64 i64 i64) (result i32))
+  (func (import "wasix_64v1" "resolve") (param i64 i64 i32 i64 i32 i64) (result i32))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasm_bus.txt b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasm_bus.txt
new file mode 100644
index 0000000..64d0637
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasix/wia/wasm_bus.txt
@@ -0,0 +1,14 @@
+(interface "wasm-bus"
+  (func (import "wasm-bus" "wasm_bus_drop") (param i32)
+  (func (import "wasm-bus" "wasm_bus_handle") (result i32))
+  (func (import "wasm-bus" "wasm_bus_listen") (param i32 i32)
+  (func (import "wasm-bus" "wasm_bus_callback") (param i32 i32 i32 i32)
+  (func (import "wasm-bus" "wasm_bus_fault") (param i32 i32)
+  (func (import "wasm-bus" "wasm_bus_poll")
+  (func (import "wasm-bus" "wasm_bus_fork")
+  (func (import "wasm-bus" "wasm_bus_reply") (param i32 i32 i32)
+  (func (import "wasm-bus" "wasm_bus_reply_callback") (param i32 i32 i32 i32 i32)
+  (func (import "wasm-bus" "wasm_bus_call") (param i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasm-bus" "wasm_bus_call_instance") (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)) 
+  (func (import "wasm-bus" "wasm_bus_thread_id") (result i32))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/Cargo.toml b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/Cargo.toml
new file mode 100644
index 0000000..c071307
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/Cargo.toml
@@ -0,0 +1,29 @@
+[package]
+name = "wasmer-wasm-interface"
+description = "WASM Interface definition and parser"
+readme = "README.md"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+bincode = { version = "1", optional = true }
+either = "1.5"
+nom = "5"
+serde = { version = "1", features = ["derive"] }
+wasmparser = { workspace = true, optional = true }
+
+[dev-dependencies]
+wat = "1.0"
+
+[features]
+validation = ["wasmparser"]
+binary_encode = ["bincode"]
+default = ["validation"]
+
+[package.metadata.docs.rs]
+rustc-args = ["--cfg", "docsrs"]
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/README.md b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/README.md
new file mode 100644
index 0000000..c3526b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/README.md
@@ -0,0 +1,88 @@
+# Wasm Interface
+
+This is an experimental crate for validating the imports and exports of a WebAssembly module.
+
+For the time being, Wasm Interface provides:
+
+- a convenient text format for specifying the requirements of Wasm modules
+- a convenient way to compose interfaces safely (it ensures no conflicts (duplicates are allowed but they must agree))
+- validation that the modules meet the requirements
+
+## Syntax example
+
+Here's the interface for the current version of [WASI](https://github.com/WebAssembly/WASI):
+
+```lisp
+(interface "wasi_unstable"
+  ;; Here's a bunch of function imports!
+  (func (import "wasi_unstable" "args_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "args_sizes_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "clock_res_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "clock_time_get") (param i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "environ_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "environ_sizes_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_advise") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasi_unstable" "fd_allocate") (param i32 i64 i64) (result i32))
+  (func (import "wasi_unstable" "fd_close") (param i32) (result i32))
+  (func (import "wasi_unstable" "fd_datasync") (param i32) (result i32))
+  (func (import "wasi_unstable" "fd_fdstat_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_fdstat_set_flags") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_fdstat_set_rights") (param i32 i64 i64) (result i32))
+  (func (import "wasi_unstable" "fd_filestat_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_filestat_set_size") (param i32 i64) (result i32))
+  (func (import "wasi_unstable" "fd_filestat_set_times") (param i32 i64 i64 i32) (result i32))
+  (func (import "wasi_unstable" "fd_pread") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasi_unstable" "fd_prestat_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_prestat_dir_name") (param i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_pwrite") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasi_unstable" "fd_read") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_readdir") (param i32 i32 i32 i64 i32) (result i32))
+  (func (import "wasi_unstable" "fd_renumber") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_seek") (param i32 i64 i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_sync") (param i32) (result i32))
+  (func (import "wasi_unstable" "fd_tell") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "fd_write") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_create_directory") (param i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_filestat_get") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_filestat_set_times") (param i32 i32 i32 i32 i64 i64 i32) (result i32))
+  (func (import "wasi_unstable" "path_link") (param i32 i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_open") (param i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_readlink") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_remove_directory") (param i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_rename") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_symlink") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "path_unlink_file") (param i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "poll_oneoff") (param i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "proc_exit") (param i32))
+  (func (import "wasi_unstable" "proc_raise") (param i32) (result i32))
+  (func (import "wasi_unstable" "random_get") (param i32 i32) (result i32))
+  (func (import "wasi_unstable" "sched_yield") (result i32))
+  (func (import "wasi_unstable" "sock_recv") (param i32 i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "sock_send") (param i32 i32 i32 i32 i32) (result i32))
+  (func (import "wasi_unstable" "sock_shutdown") (param i32 i32) (result i32))
+)
+```
+
+
+Notes:
+- multiple `assert-import` and `assert-export` declarations are allowed.
+- comments (starts with `;` and ends with a newline) and whitespace are valid between any tokens
+
+## Semantics
+
+All imports used by the module must be specified in the interface.
+
+All exports in the interface must be exported by the module.
+
+Thus the module may have additional exports than the interface or fewer imports than the interface specifies and be considered valid.
+
+
+## Misc
+
+Wasm Interface serves a slightly different purpose than the proposed WebIDL for Wasm standard, but may be replaced by it in the future if things change.
+
+Due to an issue with nested closures in Rust, `wasm-interface` can't both compile on stable and have good error reporting. This is being fixed and `wasm-interface` will be updated to have better error handling.
+
+See the `parser.rs` file for a comment containing the grammar in a BNF style.
+
+Suggestions, contributions, and thoughts welcome! This is an experiment in the early stages, but we hope to work with the wider community and develop this in cooperation with all interested parties.
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface.rs b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface.rs
new file mode 100644
index 0000000..12a4d1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface.rs
@@ -0,0 +1,205 @@
+//! The definition of a WASM interface
+
+use crate::interface_matcher::InterfaceMatcher;
+use serde::{Deserialize, Serialize};
+use std::collections::{hash_map::Entry, HashMap, HashSet};
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct Interface {
+    /// The name the interface gave itself
+    pub name: Option<String>,
+    /// Things that the module can import
+    pub imports: HashMap<(String, String), Import>,
+    /// Things that the module must export
+    pub exports: HashMap<String, Export>,
+}
+
+impl Interface {
+    pub fn merge(&self, other: Interface) -> Result<Interface, String> {
+        let mut base = self.clone();
+
+        for (key, val) in other.imports {
+            match base.imports.entry(key) {
+                Entry::Occupied(e) if *e.get() != val => {
+                    let (namespace, name) = e.key();
+                    let original_value = e.get();
+                    return Err(format!("Conflict detected: the import \"{namespace}\" \"{name}\" was found but the definitions were different: {original_value:?} {val:?}"));
+                }
+                Entry::Occupied(_) => {
+                    // it's okay for the imported items to be the same.
+                }
+                Entry::Vacant(e) => {
+                    e.insert(val);
+                }
+            };
+        }
+
+        for (key, val) in other.exports {
+            match base.exports.entry(key) {
+                Entry::Occupied(e) if *e.get() != val => {
+                    let name = e.key();
+                    let original_value = e.get();
+                    return Err(format!("Conflict detected: the key \"{name}\" was found in exports but the definitions were different: {original_value:?} {val:?}"));
+                }
+                Entry::Occupied(_) => {
+                    // it's okay for the exported items to be the same.
+                }
+                Entry::Vacant(e) => {
+                    e.insert(val);
+                }
+            };
+        }
+
+        Ok(base)
+    }
+
+    pub fn create_interface_matcher(&self) -> InterfaceMatcher {
+        let mut namespaces = HashSet::new();
+        let mut namespace_imports: HashMap<String, HashSet<Import>> =
+            HashMap::with_capacity(self.imports.len());
+        let mut exports = HashSet::with_capacity(self.exports.len());
+
+        for (_, import) in self.imports.iter() {
+            match import {
+                Import::Func { namespace, .. } | Import::Global { namespace, .. } => {
+                    if !namespaces.contains(namespace) {
+                        namespaces.insert(namespace.clone());
+                    }
+                    let ni = namespace_imports.entry(namespace.clone()).or_default();
+                    ni.insert(import.clone());
+                }
+            }
+        }
+        for (_, export) in self.exports.iter() {
+            exports.insert(export.clone());
+        }
+        InterfaceMatcher {
+            namespaces,
+            namespace_imports,
+            exports,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Import {
+    Func {
+        namespace: String,
+        name: String,
+        params: Vec<WasmType>,
+        result: Vec<WasmType>,
+    },
+    Global {
+        namespace: String,
+        name: String,
+        var_type: WasmType,
+    },
+}
+
+impl Import {
+    pub fn format_key(ns: &str, name: &str) -> (String, String) {
+        (ns.to_string(), name.to_string())
+    }
+
+    /// Get the key used to look this import up in the Interface's import hashmap
+    pub fn get_key(&self) -> (String, String) {
+        match self {
+            Import::Func {
+                namespace, name, ..
+            }
+            | Import::Global {
+                namespace, name, ..
+            } => Self::format_key(namespace, name),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Export {
+    Func {
+        name: String,
+        params: Vec<WasmType>,
+        result: Vec<WasmType>,
+    },
+    Global {
+        name: String,
+        var_type: WasmType,
+    },
+}
+
+impl Export {
+    pub fn format_key(name: &str) -> String {
+        name.to_string()
+    }
+
+    /// Get the key used to look this export up in the Interface's export hashmap
+    pub fn get_key(&self) -> String {
+        match self {
+            Export::Func { name, .. } | Export::Global { name, .. } => Self::format_key(name),
+        }
+    }
+}
+
+/// Primitive wasm type
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum WasmType {
+    I32,
+    I64,
+    F32,
+    F64,
+}
+
+impl std::fmt::Display for WasmType {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                WasmType::I32 => "i32",
+                WasmType::I64 => "i64",
+                WasmType::F32 => "f32",
+                WasmType::F64 => "f64",
+            }
+        )
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::parser;
+
+    #[test]
+    fn merging_works() {
+        let interface1_src =
+            r#"(interface (func (import "env" "plus_one") (param i32) (result i32)))"#;
+        let interface2_src =
+            r#"(interface (func (import "env" "plus_one") (param i64) (result i64)))"#;
+        let interface3_src =
+            r#"(interface (func (import "env" "times_two") (param i64) (result i64)))"#;
+        let interface4_src =
+            r#"(interface (func (import "env" "times_two") (param i64 i64) (result i64)))"#;
+        let interface5_src = r#"(interface (func (export "empty_bank_account") (param) (result)))"#;
+        let interface6_src =
+            r#"(interface (func (export "empty_bank_account") (param) (result i64)))"#;
+
+        let interface1 = parser::parse_interface(interface1_src).unwrap();
+        let interface2 = parser::parse_interface(interface2_src).unwrap();
+        let interface3 = parser::parse_interface(interface3_src).unwrap();
+        let interface4 = parser::parse_interface(interface4_src).unwrap();
+        let interface5 = parser::parse_interface(interface5_src).unwrap();
+        let interface6 = parser::parse_interface(interface6_src).unwrap();
+
+        assert!(interface1.merge(interface2.clone()).is_err());
+        assert!(interface2.merge(interface1.clone()).is_err());
+        assert!(interface1.merge(interface3.clone()).is_ok());
+        assert!(interface2.merge(interface3.clone()).is_ok());
+        assert!(interface3.merge(interface2).is_ok());
+        assert!(
+            interface1.merge(interface1.clone()).is_ok(),
+            "exact matches are accepted"
+        );
+        assert!(interface3.merge(interface4).is_err());
+        assert!(interface5.merge(interface5.clone()).is_ok());
+        assert!(interface5.merge(interface6).is_err());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface_matcher.rs b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface_matcher.rs
new file mode 100644
index 0000000..c9bf62b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/interface_matcher.rs
@@ -0,0 +1,29 @@
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+
+use crate::interface::{Export, Import};
+
+/// A struct containing data for more efficient matching.
+///
+/// An ideal use case for this is to parse [`Interface`]s at compile time,
+/// create [`InterfaceMatcher`]s, and store them as bytes so that they
+/// can be efficiently loaded at runtime for matching.
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct InterfaceMatcher {
+    pub namespaces: HashSet<String>,
+    pub namespace_imports: HashMap<String, HashSet<Import>>,
+    pub exports: HashSet<Export>,
+}
+
+#[cfg(feature = "binary_encode")]
+impl InterfaceMatcher {
+    /// Store the matcher as bytes to avoid reparsing
+    fn into_bytes(&self) -> Vec<u8> {
+        bincode::serialize(self).expect("Could not serialize InterfaceMatcher")
+    }
+
+    /// Load the matcher from bytes to avoid reparsing
+    fn from_bytes(bytes: &[u8]) -> Option<Self> {
+        bincode::deserialize(bytes).ok()
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/lib.rs b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/lib.rs
new file mode 100644
index 0000000..9dea448
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/lib.rs
@@ -0,0 +1,14 @@
+#![type_length_limit = "5795522"]
+//! Definition and parsing of wasm interfaces
+//!
+//! wasm interfaces ensure wasm modules conform to a specific shape
+//! they do this by asserting on the imports and exports of the module.
+#![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
+
+pub mod interface;
+pub mod interface_matcher;
+pub mod parser;
+#[cfg(feature = "validation")]
+pub mod validate;
+
+pub use interface::*;
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/parser.rs b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/parser.rs
new file mode 100644
index 0000000..03475a9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/parser.rs
@@ -0,0 +1,596 @@
+//! Parsers to get a wasm interface from text
+//!
+//! The grammar of the text format is:
+//! interface = "(" interface name? interface-entry* ")"
+//! interface-entry = func | global
+//!
+//! func = import-fn | export-fn
+//! global = import-global | export-global
+//!
+//! import-fn = "(" "func" import-id param-list? result-list? ")"
+//! import-global = "(" "global" import-id type-decl ")"
+//! import-id = "(" "import" namespace name ")"
+//!
+//! export-fn = "(" "func" export-id param-list? result-list? ")"
+//! export-global = "(" "global" export-id type-decl ")"
+//! export-id = "(" export name ")"
+//!
+//! param-list = "(" param type* ")"
+//! result-list = "(" result type* ")"
+//! type-decl = "(" "type" type ")"
+//! namespace = "\"" identifier "\""
+//! name = "\"" identifier "\""
+//! identifier = any character that's not a whitespace character or an open or close parenthesis
+//! type = "i32" | "i64" | "f32" | "f64"
+//!
+//! + means 1 or more
+//! * means 0 or more
+//! ? means 0 or 1
+//! | means "or"
+//! "\"" means one `"` character
+//!
+//! comments start with a `;` character and go until a newline `\n` character is reached
+//! comments and whitespace are valid between any tokens
+
+use either::Either;
+use nom::{
+    branch::*,
+    bytes::complete::{escaped, is_not, tag},
+    character::complete::{char, multispace0, multispace1, one_of},
+    combinator::*,
+    error::context,
+    multi::many0,
+    sequence::{delimited, preceded, tuple},
+    IResult,
+};
+
+use crate::interface::*;
+
+/// Some example input:
+/// (interface "example_interface"
+///     (func (import "ns" "name") (param f64 i32) (result f64 i32))
+///     (func (export "name") (param f64 i32) (result f64 i32))
+///     (global (import "ns" "name") (type f64)))
+pub fn parse_interface(mut input: &str) -> Result<Interface, String> {
+    let mut interface = Interface::default();
+    let interface_inner = preceded(
+        tag("interface"),
+        tuple((
+            opt(preceded(space_comments, identifier)),
+            many0(parse_func_or_global),
+        )),
+    );
+    let interface_parser = preceded(space_comments, s_exp(interface_inner));
+
+    if let Result::Ok((inp, (sig_id, out))) = interface_parser(input) {
+        interface.name = sig_id.map(|s_id| s_id.to_string());
+
+        for entry in out.into_iter() {
+            match entry {
+                Either::Left(import) => {
+                    if let Some(dup) = interface.imports.insert(import.get_key(), import) {
+                        return Err(format!("Duplicate import found {:?}", dup));
+                    }
+                }
+                Either::Right(export) => {
+                    if let Some(dup) = interface.exports.insert(export.get_key(), export) {
+                        return Err(format!("Duplicate export found {:?}", dup));
+                    }
+                }
+            }
+        }
+        input = inp;
+    }
+    // catch trailing comments and spaces
+    if let Ok((inp, _)) = space_comments(input) {
+        input = inp;
+    }
+    if !input.is_empty() {
+        Err(format!("Could not parse remaining input: {}", input))
+    } else {
+        Ok(interface)
+    }
+}
+
+fn parse_comment(input: &str) -> IResult<&str, ()> {
+    map(
+        preceded(multispace0, preceded(char(';'), many0(is_not("\n")))),
+        |_| (),
+    )(input)
+}
+
+/// Consumes spaces and comments
+/// comments must terminate with a new line character
+fn space_comments<'a>(mut input: &'a str) -> IResult<&'a str, ()> {
+    let mut space_found = true;
+    let mut comment_found = true;
+    while space_found || comment_found {
+        let space: IResult<&'a str, _> = multispace1(input);
+        space_found = if let Result::Ok((inp, _)) = space {
+            input = inp;
+            true
+        } else {
+            false
+        };
+        comment_found = if let Result::Ok((inp, _)) = parse_comment(input) {
+            input = inp;
+            true
+        } else {
+            false
+        };
+    }
+    Ok((input, ()))
+}
+
+/// A quoted identifier, must be valid UTF8
+fn identifier(input: &str) -> IResult<&str, &str> {
+    let name_inner = escaped(is_not("\"\\"), '\\', one_of("\"n\\"));
+    context("identifier", delimited(char('"'), name_inner, char('"')))(input)
+}
+
+/// Parses a wasm primitive type
+fn wasm_type(input: &str) -> IResult<&str, WasmType> {
+    let i32_tag = map(tag("i32"), |_| WasmType::I32);
+    let i64_tag = map(tag("i64"), |_| WasmType::I64);
+    let f32_tag = map(tag("f32"), |_| WasmType::F32);
+    let f64_tag = map(tag("f64"), |_| WasmType::F64);
+
+    alt((i32_tag, i64_tag, f32_tag, f64_tag))(input)
+}
+
+/// Parses an S-expression
+fn s_exp<'a, O1, F>(inner: F) -> impl Fn(&'a str) -> IResult<&'a str, O1>
+where
+    F: Fn(&'a str) -> IResult<&'a str, O1>,
+{
+    delimited(
+        char('('),
+        preceded(space_comments, inner),
+        preceded(space_comments, char(')')),
+    )
+}
+
+fn parse_func_or_global(input: &str) -> IResult<&str, Either<Import, Export>> {
+    preceded(space_comments, alt((func, global)))(input)
+}
+
+/// (func (import "ns" "name") (param f64 i32) (result f64 i32))
+/// (func (export "name") (param f64 i32) (result f64 i32))
+fn func(input: &str) -> IResult<&str, Either<Import, Export>> {
+    let param_list_inner = preceded(tag("param"), many0(preceded(space_comments, wasm_type)));
+    let param_list = opt(s_exp(param_list_inner));
+    let result_list_inner = preceded(tag("result"), many0(preceded(space_comments, wasm_type)));
+    let result_list = opt(s_exp(result_list_inner));
+    let import_id_inner = preceded(
+        tag("import"),
+        tuple((
+            preceded(space_comments, identifier),
+            preceded(space_comments, identifier),
+        )),
+    );
+    let export_id_inner = preceded(tag("export"), preceded(space_comments, identifier));
+    let func_id_inner = alt((
+        map(import_id_inner, |(ns, name)| {
+            Either::Left((ns.to_string(), name.to_string()))
+        }),
+        map(export_id_inner, |name| Either::Right(name.to_string())),
+    ));
+    let func_id = s_exp(func_id_inner);
+    let func_import_inner = context(
+        "func import inner",
+        preceded(
+            tag("func"),
+            map(
+                tuple((
+                    preceded(space_comments, func_id),
+                    preceded(space_comments, param_list),
+                    preceded(space_comments, result_list),
+                )),
+                |(func_id, pl, rl)| match func_id {
+                    Either::Left((ns, name)) => Either::Left(Import::Func {
+                        namespace: ns,
+                        name,
+                        params: pl.unwrap_or_default(),
+                        result: rl.unwrap_or_default(),
+                    }),
+                    Either::Right(name) => Either::Right(Export::Func {
+                        name,
+                        params: pl.unwrap_or_default(),
+                        result: rl.unwrap_or_default(),
+                    }),
+                },
+            ),
+        ),
+    );
+    s_exp(func_import_inner)(input)
+}
+
+/// (global (import "ns" "name") (type f64))
+/// (global (export "name") (type f64))
+fn global(input: &str) -> IResult<&str, Either<Import, Export>> {
+    let global_type_inner = preceded(tag("type"), preceded(space_comments, wasm_type));
+    let type_s_exp = s_exp(global_type_inner);
+    let export_inner = preceded(tag("export"), preceded(space_comments, identifier));
+    let import_inner = preceded(
+        tag("import"),
+        tuple((
+            preceded(space_comments, identifier),
+            preceded(space_comments, identifier),
+        )),
+    );
+    let global_id_inner = alt((
+        map(import_inner, |(ns, name)| {
+            Either::Left(Import::Global {
+                namespace: ns.to_string(),
+                name: name.to_string(),
+                // placeholder type, overwritten in `global_inner`
+                var_type: WasmType::I32,
+            })
+        }),
+        map(export_inner, |name| {
+            Either::Right(Export::Global {
+                name: name.to_string(),
+                // placeholder type, overwritten in `global_inner`
+                var_type: WasmType::I32,
+            })
+        }),
+    ));
+    let global_id = s_exp(global_id_inner);
+    let global_inner = context(
+        "global inner",
+        preceded(
+            tag("global"),
+            map(
+                tuple((
+                    preceded(space_comments, global_id),
+                    preceded(space_comments, type_s_exp),
+                )),
+                |(import_or_export, var_type)| match import_or_export {
+                    Either::Left(Import::Global {
+                        namespace, name, ..
+                    }) => Either::Left(Import::Global {
+                        namespace,
+                        name,
+                        var_type,
+                    }),
+                    Either::Right(Export::Global { name, .. }) => {
+                        Either::Right(Export::Global { name, var_type })
+                    }
+                    _ => unreachable!("Invalid value interonally in parse global function"),
+                },
+            ),
+        ),
+    );
+    s_exp(global_inner)(input)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn parse_wasm_type() {
+        let i32_res = wasm_type("i32").unwrap();
+        assert_eq!(i32_res, ("", WasmType::I32));
+        let i64_res = wasm_type("i64").unwrap();
+        assert_eq!(i64_res, ("", WasmType::I64));
+        let f32_res = wasm_type("f32").unwrap();
+        assert_eq!(f32_res, ("", WasmType::F32));
+        let f64_res = wasm_type("f64").unwrap();
+        assert_eq!(f64_res, ("", WasmType::F64));
+
+        assert!(wasm_type("i128").is_err());
+    }
+
+    #[test]
+    fn parse_identifier() {
+        let inner_str = "柴は可愛すぎるだと思います";
+        let input = format!("\"{}\"", &inner_str);
+        let parse_res = identifier(&input).unwrap();
+        assert_eq!(parse_res, ("", inner_str))
+    }
+
+    #[test]
+    fn parse_global_import() {
+        let parse_res = global(r#"(global (import "env" "length") (type i32))"#)
+            .ok()
+            .and_then(|(a, b)| Some((a, b.left()?)))
+            .unwrap();
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                Import::Global {
+                    namespace: "env".to_string(),
+                    name: "length".to_string(),
+                    var_type: WasmType::I32,
+                }
+            )
+        );
+    }
+
+    #[test]
+    fn parse_global_export() {
+        let parse_res = global(r#"(global (export "length") (type i32))"#)
+            .ok()
+            .and_then(|(a, b)| Some((a, b.right()?)))
+            .unwrap();
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                Export::Global {
+                    name: "length".to_string(),
+                    var_type: WasmType::I32,
+                }
+            )
+        );
+    }
+
+    #[test]
+    fn parse_func_import() {
+        let parse_res = func(r#"(func (import "ns" "name") (param f64 i32) (result f64 i32))"#)
+            .ok()
+            .and_then(|(a, b)| Some((a, b.left()?)))
+            .unwrap();
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                Import::Func {
+                    namespace: "ns".to_string(),
+                    name: "name".to_string(),
+                    params: vec![WasmType::F64, WasmType::I32],
+                    result: vec![WasmType::F64, WasmType::I32],
+                }
+            )
+        );
+    }
+
+    #[test]
+    fn parse_func_export() {
+        let parse_res = func(r#"(func (export "name") (param f64 i32) (result f64 i32))"#)
+            .ok()
+            .and_then(|(a, b)| Some((a, b.right()?)))
+            .unwrap();
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                Export::Func {
+                    name: "name".to_string(),
+                    params: vec![WasmType::F64, WasmType::I32],
+                    result: vec![WasmType::F64, WasmType::I32],
+                }
+            )
+        );
+
+        let parse_res = func(r#"(func (export "name"))"#)
+            .ok()
+            .and_then(|(a, b)| Some((a, b.right()?)))
+            .unwrap();
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                Export::Func {
+                    name: "name".to_string(),
+                    params: vec![],
+                    result: vec![],
+                }
+            )
+        )
+    }
+
+    #[test]
+    fn parse_imports_test() {
+        let parse_imports = |in_str| {
+            many0(parse_func_or_global)(in_str)
+                .map(|(a, b)| {
+                    (
+                        a,
+                        b.into_iter().filter_map(|x| x.left()).collect::<Vec<_>>(),
+                    )
+                })
+                .unwrap()
+        };
+        let parse_res =
+            parse_imports(r#"(func (import "ns" "name") (param f64 i32) (result f64 i32))"#);
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                vec![Import::Func {
+                    namespace: "ns".to_string(),
+                    name: "name".to_string(),
+                    params: vec![WasmType::F64, WasmType::I32],
+                    result: vec![WasmType::F64, WasmType::I32],
+                }]
+            )
+        );
+
+        let parse_res = parse_imports(
+            r#"(func (import "ns" "name")
+                                                   (param f64 i32) (result f64 i32))
+        ( global ( import "env" "length" ) ( type
+    ;; i32 is the best type
+    i32 )
+    )
+                                              (func (import "ns" "name2") (param f32
+                                                                          i64)
+                                   ;; The return value comes next
+                                                                    (
+                                                                     result
+                                                                     f64
+                                                                     i32
+                                                                     )
+                                              )"#,
+        );
+        assert_eq!(
+            parse_res,
+            (
+                "",
+                vec![
+                    Import::Func {
+                        namespace: "ns".to_string(),
+                        name: "name".to_string(),
+                        params: vec![WasmType::F64, WasmType::I32],
+                        result: vec![WasmType::F64, WasmType::I32],
+                    },
+                    Import::Global {
+                        namespace: "env".to_string(),
+                        name: "length".to_string(),
+                        var_type: WasmType::I32,
+                    },
+                    Import::Func {
+                        namespace: "ns".to_string(),
+                        name: "name2".to_string(),
+                        params: vec![WasmType::F32, WasmType::I64],
+                        result: vec![WasmType::F64, WasmType::I32],
+                    },
+                ]
+            )
+        );
+    }
+
+    #[test]
+    fn top_level_test() {
+        let parse_res = parse_interface(
+            r#" (interface 
+ (func (import "ns" "name") (param f64 i32) (result f64 i32))
+ (func (export "name2") (param) (result i32))
+ (global (import "env" "length") (type f64)))"#,
+        )
+        .unwrap();
+
+        let imports = vec![
+            Import::Func {
+                namespace: "ns".to_string(),
+                name: "name".to_string(),
+                params: vec![WasmType::F64, WasmType::I32],
+                result: vec![WasmType::F64, WasmType::I32],
+            },
+            Import::Global {
+                namespace: "env".to_string(),
+                name: "length".to_string(),
+                var_type: WasmType::F64,
+            },
+        ];
+        let exports = vec![Export::Func {
+            name: "name2".to_string(),
+            params: vec![],
+            result: vec![WasmType::I32],
+        }];
+        let import_map = imports
+            .into_iter()
+            .map(|entry| (entry.get_key(), entry))
+            .collect::<HashMap<(String, String), Import>>();
+        let export_map = exports
+            .into_iter()
+            .map(|entry| (entry.get_key(), entry))
+            .collect::<HashMap<String, Export>>();
+        assert_eq!(
+            parse_res,
+            Interface {
+                name: None,
+                imports: import_map,
+                exports: export_map,
+            }
+        );
+    }
+
+    #[test]
+    fn duplicates_not_allowed() {
+        let parse_res = parse_interface(
+            r#" (interface "sig_name" (func (import "ns" "name") (param f64 i32) (result f64 i32))
+; test comment
+  ;; hello
+ (func (import "ns" "name") (param) (result i32))
+ (global (export "length") (type f64)))
+
+"#,
+        );
+
+        assert!(parse_res.is_err());
+    }
+
+    #[test]
+    fn test_comment_space_parsing() {
+        let parse_res = space_comments(" ").unwrap();
+        assert_eq!(parse_res, ("", ()));
+        let parse_res = space_comments("").unwrap();
+        assert_eq!(parse_res, ("", ()));
+        let parse_res = space_comments("; hello\n").unwrap();
+        assert_eq!(parse_res, ("", ()));
+        let parse_res = space_comments("abc").unwrap();
+        assert_eq!(parse_res, ("abc", ()));
+        let parse_res = space_comments("\n ; hello\n ").unwrap();
+        assert_eq!(parse_res, ("", ()));
+        let parse_res = space_comments("\n ; hello\n ; abc\n\n ; hello\n").unwrap();
+        assert_eq!(parse_res, ("", ()));
+    }
+
+    #[test]
+    fn test_param_elision() {
+        let parse_res = parse_interface(
+            r#" (interface "interface_name" (func (import "ns" "name") (result f64 i32))
+(func (export "name")))
+"#,
+        )
+        .unwrap();
+
+        let imports = vec![Import::Func {
+            namespace: "ns".to_string(),
+            name: "name".to_string(),
+            params: vec![],
+            result: vec![WasmType::F64, WasmType::I32],
+        }];
+        let exports = vec![Export::Func {
+            name: "name".to_string(),
+            params: vec![],
+            result: vec![],
+        }];
+        let import_map = imports
+            .into_iter()
+            .map(|entry| (entry.get_key(), entry))
+            .collect::<HashMap<(String, String), Import>>();
+        let export_map = exports
+            .into_iter()
+            .map(|entry| (entry.get_key(), entry))
+            .collect::<HashMap<String, Export>>();
+        assert_eq!(
+            parse_res,
+            Interface {
+                name: Some("interface_name".to_string()),
+                imports: import_map,
+                exports: export_map,
+            }
+        );
+    }
+
+    #[test]
+    fn typo_gets_caught() {
+        let interface_src = r#"
+(interface "interface_id"
+(func (import "env" "do_panic") (params i32 i64))
+(global (import "length") (type i32)))"#;
+        let result = parse_interface(interface_src);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn parse_trailing_spaces_on_interface() {
+        let parse_res = parse_interface(
+            r#" (interface "really_good_interface" (func (import "ns" "name") (param f64 i32) (result f64 i32))
+; test comment
+  ;; hello
+ (global (import "ns" "length") (type f64))
+)
+
+"#,
+        );
+
+        assert!(parse_res.is_ok());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/validate.rs b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/validate.rs
new file mode 100644
index 0000000..7901eeb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/lib/wasm-interface/src/validate.rs
@@ -0,0 +1,504 @@
+//! Validate a wasm module given a interface.
+//!
+//! This checks that all imports are specified in the interface and that their types
+//! are correct, as well as that all exports that the interface expects are exported
+//! by the module and that their types are correct.
+
+use crate::{Export, Import, Interface, WasmType};
+use std::collections::HashMap;
+use wasmparser::{CompositeType, ExternalKind, FuncType, GlobalType, Payload, TypeRef};
+
+pub fn validate_wasm_and_report_errors(
+    wasm: &[u8],
+    interface: &Interface,
+) -> Result<(), WasmValidationError> {
+    let mut errors: Vec<String> = vec![];
+    let mut import_fns: HashMap<(String, String), u32> = HashMap::new();
+    let mut export_fns: HashMap<String, u32> = HashMap::new();
+    let mut export_globals: HashMap<String, u32> = HashMap::new();
+    let mut type_defs: Vec<FuncType> = vec![];
+    let mut global_types: Vec<GlobalType> = vec![];
+    let mut fn_sigs: Vec<u32> = vec![];
+
+    let mut val = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
+        threads: true,
+        reference_types: true,
+        simd: true,
+        bulk_memory: true,
+        multi_value: true,
+        ..Default::default()
+    });
+
+    val.validate_all(wasm)
+        .map_err(|e| WasmValidationError::InvalidWasm {
+            error: format!("{}", e),
+        })?;
+
+    let parser = wasmparser::Parser::new(0).parse_all(wasm);
+
+    for res in parser {
+        let payload = res.map_err(|e| WasmValidationError::InvalidWasm {
+            error: format!("{}", e),
+        })?;
+        match payload {
+            Payload::End(_) => break,
+            Payload::ImportSection(reader) => {
+                for item in reader.into_iter_with_offsets() {
+                    let (_offset, import) = item.map_err(|e| WasmValidationError::InvalidWasm {
+                        error: format!("{}", e),
+                    })?;
+
+                    match import.ty {
+                        TypeRef::Func(idx) => {
+                            import_fns.insert(Import::format_key(import.module, import.name), idx);
+                            fn_sigs.push(idx);
+                        }
+                        TypeRef::Global(GlobalType { content_type, .. }) => {
+                            let global_type = wasmparser_type_into_wasm_type(content_type)
+                                .map_err(|err| WasmValidationError::UnsupportedType {
+                                    error: format!(
+                                        "Invalid type found in import \"{}\" \"{}\": {}",
+                                        import.module, import.name, err
+                                    ),
+                                })?;
+                            if let Some(val) = interface
+                                .imports
+                                .get(&Import::format_key(import.module, import.name))
+                            {
+                                if let Import::Global { var_type, .. } = val {
+                                    if *var_type != global_type {
+                                        errors.push(format!(
+                                            "Invalid type on Global \"{}\". Expected {} found {}",
+                                            import.name, var_type, global_type
+                                        ));
+                                    }
+                                } else {
+                                    errors.push(format!(
+                                        "Invalid import type. Expected Global, found {:?}",
+                                        val
+                                    ));
+                                }
+                            } else {
+                                errors.push(format!(
+                                    "Global import \"{}\" not found in the specified interface",
+                                    import.name
+                                ));
+                            }
+                        }
+                        _ => (),
+                    }
+                }
+            }
+            Payload::ExportSection(reader) => {
+                for res in reader.into_iter() {
+                    let export = res.map_err(|e| WasmValidationError::InvalidWasm {
+                        error: format!("{}", e),
+                    })?;
+
+                    match export.kind {
+                        ExternalKind::Func => {
+                            export_fns.insert(Export::format_key(export.name), export.index);
+                        }
+                        ExternalKind::Global => {
+                            export_globals.insert(Export::format_key(export.name), export.index);
+                        }
+                        _ => (),
+                    }
+                }
+            }
+            Payload::GlobalSection(reader) => {
+                for res in reader.into_iter() {
+                    let global = res.map_err(|e| WasmValidationError::InvalidWasm {
+                        error: format!("{}", e),
+                    })?;
+
+                    global_types.push(global.ty);
+                }
+            }
+            Payload::TypeSection(reader) => {
+                for res in reader.into_iter() {
+                    let group = res.map_err(|e| WasmValidationError::InvalidWasm {
+                        error: format!("{}", e),
+                    })?;
+
+                    for ty in group.into_types() {
+                        if let CompositeType::Func(ft) = ty.composite_type {
+                            type_defs.push(ft);
+                        }
+                    }
+                }
+            }
+            Payload::FunctionSection(reader) => {
+                for res in reader.into_iter() {
+                    let func = res.map_err(|e| WasmValidationError::InvalidWasm {
+                        error: format!("{}", e),
+                    })?;
+
+                    fn_sigs.push(func);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    validate_imports(&import_fns, &type_defs, interface, &mut errors);
+    validate_export_fns(&export_fns, &type_defs, &fn_sigs, interface, &mut errors);
+    validate_export_globals(&export_globals, &global_types, interface, &mut errors);
+
+    if errors.is_empty() {
+        Ok(())
+    } else {
+        Err(WasmValidationError::InterfaceViolated { errors })
+    }
+}
+
+/// Validates the import functions, checking the name and type against the given
+/// `Interface`
+fn validate_imports(
+    import_fns: &HashMap<(String, String), u32>,
+    type_defs: &[FuncType],
+    interface: &Interface,
+    errors: &mut Vec<String>,
+) {
+    for (key, val) in import_fns.iter() {
+        if let Some(interface_def) = interface.imports.get(key) {
+            let type_sig = if let Some(v) = type_defs.get(*val as usize) {
+                v
+            } else {
+                errors.push(format!(
+                    "Use of undeclared function reference \"{}\" in import function \"{}\" \"{}\"",
+                    val, key.0, key.1
+                ));
+                continue;
+            };
+            if let Import::Func { params, result, .. } = interface_def {
+                for (i, param) in type_sig
+                    .params()
+                    .iter()
+                    .cloned()
+                    .map(wasmparser_type_into_wasm_type)
+                    .enumerate()
+                {
+                    match param {
+                        Ok(t) => {
+                            if params.get(i).is_none() {
+                                errors.push(format!("Found {} args but the interface only expects {} for imported function \"{}\" \"{}\"", i, params.len(), &key.0, &key.1));
+                                continue;
+                            }
+                            if t != params[i] {
+                                errors.push(format!(
+                                    "Type mismatch in params in imported func \"{}\" \"{}\": argument {}, expected {} found {}",
+                                    &key.0, &key.1, i + 1, params[i], t
+                                ));
+                            }
+                        }
+                        Err(e) => errors.push(format!(
+                            "Invalid type in func \"{}\" \"{}\": {}",
+                            &key.0, &key.1, e
+                        )),
+                    }
+                }
+                for (i, ret) in type_sig
+                    .results()
+                    .iter()
+                    .cloned()
+                    .map(wasmparser_type_into_wasm_type)
+                    .enumerate()
+                {
+                    match ret {
+                        Ok(t) => {
+                            if result.get(i).is_none() {
+                                errors.push(format!("Found {} returns but the interface only expects {} for imported function \"{}\" \"{}\"", i, params.len(), &key.0, &key.1));
+                                continue;
+                            }
+
+                            if t != result[i] {
+                                errors.push(format!(
+                                    "Type mismatch in returns in func \"{}\" \"{}\", return {}, expected {} found {}",
+                                    &key.0, &key.1, i + 1, params[i], t
+                                ));
+                            }
+                        }
+                        Err(e) => errors.push(format!(
+                            "Invalid type in func \"{}\" \"{}\": {}",
+                            &key.0, &key.1, e
+                        )),
+                    }
+                }
+            }
+        } else {
+            // we didn't find the import at all in the interface
+            // TODO: improve error messages by including type information
+            errors.push(format!("Missing import \"{}\" \"{}\"", key.0, key.1));
+        }
+    }
+}
+
+/// Validates the export functions, checking the name and type against the given
+/// `Interface`
+fn validate_export_fns(
+    export_fns: &HashMap<String, u32>,
+    type_defs: &[FuncType],
+    fn_sigs: &Vec<u32>,
+    interface: &Interface,
+    errors: &mut Vec<String>,
+) {
+    'export_loop: for (key, val) in export_fns.iter() {
+        if let Some(interface_def) = interface.exports.get(key) {
+            let type_sig = if let Some(type_idx) = fn_sigs.get(*val as usize) {
+                if let Some(v) = type_defs.get(*type_idx as usize) {
+                    v
+                } else {
+                    errors.push(format!(
+                        "Export \"{}\" refers to type \"{}\" but only {} types were found",
+                        &key,
+                        type_idx,
+                        fn_sigs.len()
+                    ));
+                    continue;
+                }
+            } else {
+                errors.push(format!(
+                    "Use of undeclared function reference \"{}\" in export \"{}\"",
+                    val, &key
+                ));
+                continue;
+            };
+            if let Export::Func { params, result, .. } = interface_def {
+                for (i, param) in type_sig
+                    .params()
+                    .iter()
+                    .cloned()
+                    .map(wasmparser_type_into_wasm_type)
+                    .enumerate()
+                {
+                    match param {
+                        Ok(t) => {
+                            if params.get(i).is_none() {
+                                errors.push(format!("Found {} args but the interface only expects {} for exported function \"{}\"", type_sig.params().len(), params.len(), &key));
+                                continue 'export_loop;
+                            }
+                            if t != params[i] {
+                                errors.push(format!(
+                                    "Type mismatch in params in exported func \"{}\": in argument {}, expected {} found {}",
+                                    &key, i + 1, params[i], t
+                                ));
+                            }
+                        }
+                        Err(e) => errors
+                            .push(format!("Invalid type in exported func \"{}\": {}", &key, e)),
+                    }
+                }
+                for (i, ret) in type_sig
+                    .results()
+                    .iter()
+                    .cloned()
+                    .map(wasmparser_type_into_wasm_type)
+                    .enumerate()
+                {
+                    match ret {
+                        Ok(t) => {
+                            if result.get(i).is_none() {
+                                errors.push(format!("Found {} returns but the interface only expects {} for exported function \"{}\"", i, params.len(), &key));
+                                continue 'export_loop;
+                            }
+
+                            if t != result[i] {
+                                errors.push(format!(
+                                    "Type mismatch in returns in exported func \"{}\": in return {}, expected {} found {}",
+                                    &key, i + 1, result[i], t
+                                ));
+                            }
+                        }
+                        Err(e) => errors
+                            .push(format!("Invalid type in exported func \"{}\": {}", &key, e)),
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Validates the export globals, checking the name and type against the given
+/// `Interface`
+fn validate_export_globals(
+    export_globals: &HashMap<String, u32>,
+    global_types: &Vec<GlobalType>,
+    interface: &Interface,
+    errors: &mut Vec<String>,
+) {
+    for (key, val) in export_globals.iter() {
+        if let Some(Export::Global { var_type, .. }) = interface.exports.get(key) {
+            if global_types.get(*val as usize).is_none() {
+                errors.push(format!(
+                    "Invalid wasm, expected {} global types, found {}",
+                    val,
+                    global_types.len()
+                ));
+            }
+            match wasmparser_type_into_wasm_type(global_types[*val as usize].content_type) {
+                Ok(t) => {
+                    if *var_type != t {
+                        errors.push(format!(
+                            "Type mismatch in global export {}: expected {} found {}",
+                            &key, var_type, t
+                        ));
+                    }
+                }
+                Err(e) => errors.push(format!("In global export {}: {}", &key, e)),
+            }
+        }
+    }
+}
+
+/// Converts Wasmparser's type enum into wasm-interface's type enum
+/// wasmparser's enum contains things which are invalid in many situations
+///
+/// Additionally wasmerparser containers more advanced types like references that
+/// wasm-interface does not yet support
+fn wasmparser_type_into_wasm_type(ty: wasmparser::ValType) -> Result<WasmType, String> {
+    use wasmparser::ValType;
+    Ok(match ty {
+        ValType::I32 => WasmType::I32,
+        ValType::I64 => WasmType::I64,
+        ValType::F32 => WasmType::F32,
+        ValType::F64 => WasmType::F64,
+        e => {
+            return Err(format!("Invalid type found: {:?}", e));
+        }
+    })
+}
+
+#[cfg(test)]
+mod validation_tests {
+    use super::*;
+    use crate::parser;
+
+    #[test]
+    fn global_imports() {
+        const WAT: &str = r#"(module
+(type $t0 (func (param i32 i64)))
+(global $length (import "env" "length") i32)
+(import "env" "do_panic" (func $do_panic (type $t0)))
+)"#;
+        let wasm = wat::parse_str(WAT).unwrap();
+
+        let interface_src = r#"
+(interface
+(func (import "env" "do_panic") (param i32 i64))
+(global (import "env" "length") (type i32)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(result.is_ok());
+
+        // Now set the global import type to mismatch the wasm
+        let interface_src = r#"
+(interface
+(func (import "env" "do_panic") (param i32 i64))
+(global (import "env" "length") (type i64)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(
+            result.is_err(),
+            "global import type mismatch causes an error"
+        );
+
+        // Now set the function import type to mismatch the wasm
+        let interface_src = r#"
+(interface
+(func (import "env" "do_panic") (param i64))
+(global (import "env" "length") (type i32)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(
+            result.is_err(),
+            "function import type mismatch causes an error"
+        );
+
+        // Now try with a module that has an import that the interface doesn't have
+        let interface_src = r#"
+(interface
+(func (import "env" "do_panic") (param i64))
+(global (import "env" "length_plus_plus") (type i32)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(
+            result.is_err(),
+            "all imports must be covered by the interface"
+        );
+    }
+
+    #[test]
+    fn global_exports() {
+        const WAT: &str = r#"(module
+(func (export "as-set_local-first") (param i32) (result i32)
+  (nop) (i32.const 2) (set_local 0) (get_local 0))
+(global (export "num_tries") i64 (i64.const 0))
+)"#;
+        let wasm = wat::parse_str(WAT).unwrap();
+
+        let interface_src = r#"
+(interface
+(func (export "as-set_local-first") (param i32) (result i32))
+(global (export "num_tries") (type i64)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(result.is_ok());
+
+        // Now set the global export type to mismatch the wasm
+        let interface_src = r#"
+(interface
+(func (export "as-set_local-first") (param i32) (result i32))
+(global (export "num_tries") (type f32)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(
+            result.is_err(),
+            "global export type mismatch causes an error"
+        );
+
+        // Now set the function export type to mismatch the wasm
+        let interface_src = r#"
+(interface
+(func (export "as-set_local-first") (param i64) (result i64))
+(global (export "num_tries") (type i64)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(
+            result.is_err(),
+            "function export type mismatch causes an error"
+        );
+
+        // Now try a interface that requires an export that the module doesn't have
+        let interface_src = r#"
+(interface
+(func (export "as-set_local-first") (param i64) (result i64))
+(global (export "numb_trees") (type i64)))"#;
+        let interface = parser::parse_interface(interface_src).unwrap();
+
+        let result = validate_wasm_and_report_errors(&wasm[..], &interface);
+
+        assert!(result.is_err(), "missing a required export is an error");
+    }
+}
+
+#[derive(Debug)]
+pub enum WasmValidationError {
+    InvalidWasm { error: String },
+    InterfaceViolated { errors: Vec<String> },
+    UnsupportedType { error: String },
+}
diff --git a/arbitrator/tools/module_roots/wasmer/rust-toolchain b/arbitrator/tools/module_roots/wasmer/rust-toolchain
new file mode 100644
index 0000000..e4654bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/rust-toolchain
@@ -0,0 +1 @@
+1.73
diff --git a/arbitrator/tools/module_roots/wasmer/rustfmt.toml b/arbitrator/tools/module_roots/wasmer/rustfmt.toml
new file mode 100644
index 0000000..4620097
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/rustfmt.toml
@@ -0,0 +1,6 @@
+# Nightly only, sadly.
+# Need to wait until they are stabilised.
+# imports_granularity = "Crate"
+# group_imports = "StdExternalCrate"
+# reorder_imports = true
+
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/alpine-linux-install-deps.sh b/arbitrator/tools/module_roots/wasmer/scripts/alpine-linux-install-deps.sh
new file mode 100755
index 0000000..baa2d63
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/alpine-linux-install-deps.sh
@@ -0,0 +1,7 @@
+#!/usr/bin/env sh
+# Install package dependencies on Alpine linux.
+#
+# This script is used by the CI!
+
+apk update
+apk add build-base bash musl-dev curl tar make libtool libffi-dev gcc automake autoconf git openssl-dev g++ pkgconfig
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/make-release.py b/arbitrator/tools/module_roots/wasmer/scripts/make-release.py
new file mode 100644
index 0000000..41e5c2a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/make-release.py
@@ -0,0 +1,440 @@
+#! /usr/bin/env python3
+
+import os
+import signal
+import time
+import sys
+import subprocess
+import tempfile
+import datetime
+import re
+
+RELEASE_VERSION=""
+DATE = datetime.date.today().strftime("%d/%m/%Y")
+SIGNOFF_REVIEWER = "Arshia001"
+TAG = "master"
+
+if len(sys.argv) > 1:
+    RELEASE_VERSION = sys.argv[1]
+else:
+    print("no release version as first argument")
+    sys.exit(1)
+
+
+if len(sys.argv) > 2:
+    TAG = sys.argv[2]
+
+RELEASE_VERSION_WITH_V = RELEASE_VERSION
+
+if not(RELEASE_VERSION.startswith("v")):
+    RELEASE_VERSION_WITH_V = "v" + RELEASE_VERSION
+else:
+    RELEASE_VERSION = RELEASE_VERSION[1:]
+
+if os.system("git --version") != 0:
+    print("git not installed")
+    sys.exit(1)
+
+if os.system("gh --version") != 0:
+    print("gh not installed")
+    sys.exit(1)
+
+def get_file_string(file):
+    file_handle = open(file, 'r', newline='')
+    file_string = file_handle.read()
+    file_handle.close()
+    return file_string
+
+def write_file_string(file, file_string):
+    file_handle = open(file, 'w')
+    file_handle.write(file_string)
+    file_handle.close()
+
+def replace(file, pattern, subst):
+    file_string = get_file_string(file)
+    file_string = file_string.replace(pattern, subst,1)
+    write_file_string(file, file_string)
+
+def make_release(version):
+    gh_logged_in = os.system("gh auth status") == 0
+    if not(gh_logged_in):
+        raise Exception("please log in")
+    
+    import tempfile
+
+    temp_dir = tempfile.TemporaryDirectory()
+    print(temp_dir.name)
+    if os.system("git clone https://github.com/wasmerio/wasmer --branch " + TAG + " --depth 1 " + temp_dir.name) != 0:
+        raise Exception("could not clone github repo")
+
+    # generate changelog
+    proc = subprocess.Popen(['gh', "search", "prs", "--repo", "wasmerio/wasmer", "--merged", "--limit", "100", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+    if proc.returncode != 0:
+        print(proc.stdout)
+        raise Exception("could not run gh search prs")
+
+    lines = []
+    for line in proc.stdout:
+        line = line.decode("utf-8").rstrip()
+        if "Release" in line:
+            break
+        lines.append(line)
+
+    changed = []
+    added = []
+    fixed = []
+    release_notes_changed = []
+
+    for l in lines:
+        fields = l.split("\t")
+        pr_number = fields[1]
+        pr_text = fields[3]
+        l = "  - [#" + pr_number + "](https://github.com/wasmerio/wasmer/pull/" + pr_number + ") " + pr_text
+        release_notes_changed.append(l)
+        if "add" in l.lower():
+            added.append(l)
+        elif "fix" in l.lower():
+            fixed.append(l)
+        else:
+            changed.append(l)
+
+    changelog = []
+
+    changelog.append("## **Unreleased**")
+    changelog.append("")
+    changelog.append("## " + RELEASE_VERSION + " - " + DATE)
+    changelog.append("")
+    changelog.append("## Added")
+    changelog.append("")
+    for a in added:
+        changelog.append(a)
+    changelog.append("")
+    changelog.append("## Changed")
+    changelog.append("")
+    for c in changed:
+        changelog.append(c)
+    changelog.append("")
+    changelog.append("## Fixed")
+    changelog.append("")
+    for f in fixed:
+        changelog.append(f)
+    changelog.append("")
+    changelog.append("")
+
+    for l in changelog:
+        print("        " + l)
+
+    proc = subprocess.Popen(['gh','search', "prs", "--repo", "wasmerio/wasmer", "--merged", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    already_released_str = ""
+    for line in proc.stdout:
+        line = line.decode("utf-8").rstrip()
+        if RELEASE_VERSION + "\t" in line:
+            already_released_str = line
+            break
+    
+    already_released = already_released_str != ""
+
+    proc = subprocess.Popen(['gh','pr', "list", "--repo", "wasmerio/wasmer"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    github_link_line = ""
+    for line in proc.stdout:
+        line = line.decode("utf-8").rstrip()
+        if "release-" + RELEASE_VERSION + "\t" in line:
+            github_link_line = line
+            break
+    
+    print("github link line" + github_link_line)
+
+    if github_link_line != "":
+        proc = subprocess.Popen(['git','pull', "origin", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        proc = subprocess.Popen(['git','checkout', "-b", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        
+        proc = subprocess.Popen(['git','pull', "origin", "release-" + RELEASE_VERSION, "--depth", "1"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        for line in proc.stdout:
+            print(line.rstrip())
+
+    if github_link_line == "" and not(already_released):
+
+        # git checkout -b release-3.0.0-rc.2
+        proc = subprocess.Popen(['git','checkout', "-b", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        
+        if proc.returncode != 0:
+            for line in proc.stdout:
+                print(line.rstrip())
+            raise Exception("could not run git checkout -b release-" + RELEASE_VERSION)
+
+        replace(temp_dir.name + "/CHANGELOG.md", "## **Unreleased**", "\r\n".join(changelog))
+
+        proc = subprocess.Popen(['git','commit', "-am", "Update CHANGELOG"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        if proc.returncode != 0:
+            for line in proc.stdout:
+                print(line.rstrip())
+            raise Exception("could not commit CHANGELOG " + RELEASE_VERSION_WITH_V)
+
+        # Update version numbers
+        update_version_py = get_file_string(temp_dir.name + "/scripts/update-version.py")
+        previous_version = re.search("NEXT_VERSION=\'(.*)\'", update_version_py).groups(1)[0]
+        next_version = RELEASE_VERSION
+        print("updating version " + previous_version + " -> " + next_version)
+        update_version_py = re.sub("PREVIOUS_VERSION=\'.*\'","PREVIOUS_VERSION='" + previous_version + "'", update_version_py)
+        update_version_py = re.sub("NEXT_VERSION=\'.*\'","NEXT_VERSION='" + next_version + "'", update_version_py)
+        write_file_string(temp_dir.name + "/scripts/update-version.py", update_version_py)
+        proc = subprocess.Popen(['python3', temp_dir.name + "/scripts/update-version.py"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        proc = subprocess.Popen(['git','commit', "-am", "Release " + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        if proc.returncode != 0:
+            for line in proc.stdout:
+                print(line.rstrip())
+            raise Exception("could not commit CHANGELOG " + RELEASE_VERSION_WITH_V)
+
+
+        proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            print(line)
+        proc.wait()
+
+        proc = subprocess.Popen(['git','push', "-f", "-u", "origin", "release-" + RELEASE_VERSION], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        proc = subprocess.Popen(['gh','pr', "create", "--head", "release-" + RELEASE_VERSION, "--title", "Release " + RELEASE_VERSION, "--body", "[bot] Release wasmer version " + RELEASE_VERSION, "--reviewer", SIGNOFF_REVIEWER], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        proc = subprocess.Popen(['gh','pr', "list", "--repo", "wasmerio/wasmer"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            if "release-" + RELEASE_VERSION + "\t" in line:
+                github_link_line = line
+                break
+
+    pr_number = ""
+    if (already_released):
+        pr_number = already_released_str.split("\t")[1]
+        print("already released in PR " + pr_number)
+    else:
+        pr_number = github_link_line.split("\t")[0]
+        print("releasing in PR " + pr_number)
+
+    while not(already_released):
+        proc = subprocess.Popen(['gh','pr', "checks", pr_number], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        all_checks_have_passed = True
+
+        print("Waiting for checks to pass... PR " + pr_number + "    https://github.com/wasmerio/wasmer/pull/" + pr_number)
+        print("")
+        
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            print("    " + line)
+            if "no checks reported" in line:
+                all_checks_have_passed = False
+            if line.startswith("*") or "pending" in line:
+                all_checks_have_passed = False
+            if line.startswith("X") or "fail" in line:
+                raise Exception("check failed")
+
+        if all_checks_have_passed:
+            break
+        else:
+            time.sleep(5)
+
+    last_commit = ""
+    proc = subprocess.Popen(['git','log'], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+    if proc.returncode == 0:
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            print(line.rstrip())
+            last_commit = line
+            break
+    else:
+        raise Exception("could not git log branch " + RELEASE_VERSION_WITH_V)
+
+    if last_commit == "":
+        raise Exception("could not get last info")
+
+    proc = subprocess.Popen(['git','checkout', "master"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+    if proc.returncode != 0:
+        for line in proc.stdout:
+            print(line.rstrip())
+        raise Exception("could not commit checkout master " + RELEASE_VERSION_WITH_V)
+
+    if not(already_released):
+        proc = subprocess.Popen(['gh','pr', "merge", "--auto", pr_number, "--merge", "--delete-branch"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+    # wait for bors to merge PR
+    while not(already_released):
+
+        print("git pull origin master...")
+        proc = subprocess.Popen(['git','pull', "origin", "master", "--depth", "1"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        if proc.returncode != 0:
+            for line in proc.stdout:
+                print(line.rstrip())
+            raise Exception("could not pull origin ")
+        
+        proc = subprocess.Popen(['gh','search', "prs", "--repo", "wasmerio/wasmer", "--merged", "--sort", "updated"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        github_link_line = ""
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            if RELEASE_VERSION + "\t" in line:
+                github_link_line = line
+                break
+                    
+        current_commit = ""
+        proc = subprocess.Popen(['git','log'], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        if proc.returncode == 0:
+            for line in proc.stdout:
+                line = line.decode("utf-8").rstrip()
+                print(line.rstrip())
+                current_commit = line
+                break
+        else: 
+            raise Exception("could not git log master")
+
+        if current_commit == "":
+            raise Exception("could not get current info")
+
+        if github_link_line != "":
+            print("ok: " + current_commit + " == " + last_commit)
+            print(github_link_line)
+            break
+        else:
+            time.sleep(20)
+
+    # Select the correct merge commit to tag
+    correct_checkout = ""
+    proc = subprocess.Popen(['git','log', "--oneline"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+    if proc.returncode == 0:
+        for line in proc.stdout:
+            line = line.decode("utf-8").rstrip()
+            if "Merge pull request #" + pr_number in line:
+                correct_checkout = line
+    else:
+        raise Exception("could not git log branch " + RELEASE_VERSION_WITH_V)
+
+    if correct_checkout == "":
+        raise Exception("could not get last info")
+
+    print(correct_checkout)
+    checkout_hash = correct_checkout.split(" ")[0]
+    print("checking out hash " + checkout_hash)
+
+    proc = subprocess.Popen(['git','tag', "-d", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    proc = subprocess.Popen(['git','push', "-d", "origin", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    proc = subprocess.Popen(['git','tag', RELEASE_VERSION_WITH_V, checkout_hash], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    proc = subprocess.Popen(['git','push', "-f", "origin", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    # Make release and wait for it to finish
+    if not(already_released):
+        proc = subprocess.Popen(['gh','workflow', "run", "build.yml", "--field", "release=" + RELEASE_VERSION_WITH_V, "--ref", RELEASE_VERSION_WITH_V], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        time.sleep(5)
+
+    while True:
+        # gh run list --workflow=build.yml
+        proc = subprocess.Popen(['gh','run', "list", "--workflow=build.yml"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+        
+        workflow_line = ""
+        if proc.returncode == 0:
+            for line in proc.stdout:
+                line = line.decode("utf-8").rstrip()
+                if RELEASE_VERSION_WITH_V in line:
+                    workflow_line = line
+                    break
+        
+        print("workflow line: " + workflow_line)
+
+        if workflow_line.startswith("X"):
+            raise Exception("release workflow failed")
+
+        proc = subprocess.Popen(['gh','release', "list"], stdout = subprocess.PIPE, cwd = temp_dir.name)
+        proc.wait()
+
+        release_line = ""
+        if proc.returncode == 0:
+            for line in proc.stdout:
+                line = line.decode("utf-8").rstrip()
+                if RELEASE_VERSION_WITH_V in line:
+                    release_line = line
+                    break
+        
+        if release_line != "":
+            break
+        else:
+            print("not released yet")
+
+        time.sleep(30)
+
+    # release done, update release 
+
+    release_notes = [
+        "Install this version of wasmer:",
+        "",
+        "```sh",
+        "curl https://get.wasmer.io -sSfL | sh -s \"" + RELEASE_VERSION_WITH_V + "\"",
+        "```",
+        "",
+    ]
+
+    if not(len(added) == 0) and not(len(changed) == 0):
+        release_notes.append("## What's Changed")
+        release_notes.append("")
+
+    for a in added:
+        release_notes.append(a)
+
+    for c in changed:
+        release_notes.append(c)
+
+    hash = RELEASE_VERSION + "---" + DATE
+    hash = hash.replace(".", "")
+    hash = hash.replace("/", "")
+
+    release_notes.append("")
+    release_notes.append("See full list of changes in the [CHANGELOG](https://github.com/wasmerio/wasmer/blob/master/CHANGELOG.md#" + hash + ")")
+
+    proc = subprocess.Popen(['gh','release', "edit", RELEASE_VERSION_WITH_V, "--notes", "\r\n".join(release_notes)], stdout = subprocess.PIPE, cwd = temp_dir.name)
+    proc.wait()
+
+    raise Exception("script done and merged")
+
+try:
+    make_release(RELEASE_VERSION)
+except Exception as err:
+    while True:
+        print(str(err))
+        if os.system("say " + str(err)) != 0:
+            sys.exit()
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/publish.py b/arbitrator/tools/module_roots/wasmer/scripts/publish.py
new file mode 100644
index 0000000..cf4db4b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/publish.py
@@ -0,0 +1,358 @@
+#! /usr/bin/env python3
+
+"""This is a script for publishing the wasmer crates to crates.io.
+It should be run in the root of wasmer like `python3 scripts/publish.py --help`.
+
+Please lint with pylint and format with black.
+
+$ pylint scripts/publish.py
+
+--------------------------------------------------------------------
+Your code has been rated at 10.00/10 (previous run: 10.00/10, +0.00)
+
+$ black scripts/publish.py
+"""
+
+import argparse
+import itertools
+import os
+import re
+import subprocess
+import time
+import sys
+import typing
+from pprint import pprint
+
+try:
+    # try import tomllib from standard Python library: New in version 3.11.
+    import tomllib
+except ModuleNotFoundError:
+    try:
+        # if tomllib is missing, this is an older python3 version. Try
+        # importing the equivalent third-party library tomli:
+        import tomli as tomllib
+    except ModuleNotFoundError:
+        print("Please install tomli, `pip3 install tomli`")
+        sys.exit(1)
+
+try:
+    from graphlib import TopologicalSorter
+except ImportError:
+    print("Incompatible python3 version: lacks graphlib standard library module.")
+    sys.exit(1)
+
+SETTINGS = {
+    # extra features to put when publishing, for example wasmer-cli needs a
+    # compiler by default otherwise it won't work standalone
+    "publish_features": {
+        "wasmer-cli": "default,cranelift",
+        "wasmer-wasix": "sys,wasmer/sys",
+        "wasmer-wasix-types": "wasmer/sys",
+        "wasmer-wast": "wasmer/sys",
+        "wai-bindgen-wasmer": "sys",
+        "wasmer-cache": "wasmer/sys",
+        "wasmer-emscripten": "wasmer/sys"
+    },
+    # workspace members we want to publish but whose path doesn't start by
+    # "./lib/"
+    "non-lib-workspace-members": set(["tests/lib/wast"]),
+}
+
+
+def get_latest_version_for_crate(crate_name: str) -> typing.Optional[str]:
+    """Fetches the latest version of a given crate name in local cargo registry."""
+    output = subprocess.run(
+        ["cargo", "search", crate_name], capture_output=True, check=True
+    )
+    rexp_src = f'^{crate_name} = "([^"]+)"'
+    prog = re.compile(rexp_src)
+    haystack = output.stdout.decode("utf-8")
+    for line in haystack.splitlines():
+        result = prog.match(line)
+        if result:
+            return result.group(1)
+    return None
+
+
+class Crate:
+    """Represents a workspace crate that is to be published to crates.io."""
+
+    def __init__(
+        self,
+        dependencies: typing.List[str],
+        cargo_manifest: dict,
+        cargo_file_path="Cargo.toml",
+    ):
+        self.name = cargo_manifest["package"]["name"]
+        self.dependencies = dependencies
+        self.cargo_manifest = cargo_manifest
+        if not os.path.isabs(cargo_file_path):
+            cargo_file_path = os.path.join(os.getcwd(), cargo_file_path)
+        self.cargo_file_path = cargo_file_path
+
+    def __str__(self):
+        return f"{self.name}: {self.dependencies} {self.cargo_file_path} {self.path()}"
+
+    @property
+    def path(self) -> str:
+        """Return the absolute filesystem path containing this crate."""
+        return os.path.dirname(self.cargo_file_path)
+
+    @property
+    def version(self) -> str:
+        """Return the crate's version according to its manifest."""
+        return self.cargo_manifest["package"]["version"]
+
+
+class Publisher:
+    """A class responsible for figuring out dependencies,
+    creating a topological sorting in order to publish them
+    to crates.io in a valid order."""
+
+    def __init__(self, version=None, dry_run=True, verbose=True):
+        self.dry_run: bool = dry_run
+        self.verbose: bool = verbose
+
+        # open workspace Cargo.toml
+        with open("Cargo.toml", "rb") as file:
+            data = tomllib.load(file)
+
+        if version is None:
+            version = data["package"]["version"]
+        self.version: str = version
+
+        if self.verbose and not self.dry_run:
+            print(f"Publishing version {self.version}")
+        elif self.verbose and self.dry_run:
+            print(f"Publishing version {self.version} dry run!")
+
+        # define helper function
+        check_local_dep_fn = lambda t: isinstance(t[1], dict) and "path" in t[1]
+        members = set(
+            map(
+                lambda p: p + "/Cargo.toml",
+                filter(
+                    lambda path: (
+                        path.startswith("lib/") and os.path.exists(path + "/Cargo.toml")
+                    )
+                    or path in SETTINGS["non-lib-workspace-members"],
+                    itertools.chain(
+                        data["workspace"]["members"],
+                        map(
+                            lambda p: p[1]["path"],
+                            filter(check_local_dep_fn, data["dependencies"].items()),
+                        ),
+                    ),
+                ),
+            )
+        )
+        crates = []
+        for member in members:
+            with open(member, "rb") as file:
+                member_data = tomllib.load(file)
+
+            def return_dependencies(toml) -> typing.List[str]:
+                acc = set()
+                stack = [toml]
+                while len(stack) > 0:
+                    toml = stack.pop()
+                    if "dependencies" in toml:
+                        acc.update(
+                            list(
+                                map(
+                                    lambda dep: dep[1]["package"]
+                                    if "package" in dep[1]
+                                    else dep[0],
+                                    filter(
+                                        check_local_dep_fn, toml["dependencies"].items()
+                                    ),
+                                )
+                            )
+                        )
+                    if "target" in toml:
+                        stack.append(toml["target"])
+                    for key, value in toml.items():
+                        if key.startswith("cfg"):
+                            stack.append(value)
+                return list(acc)
+
+            dependencies = return_dependencies(member_data)
+            crates.append(Crate(dependencies, member_data, cargo_file_path=member))
+
+        self.crates = crates
+        self.crate_index: typing.Dict[str, Crate] = {c.name: c for c in crates}
+
+        self.create_publish_order()
+
+        self.starting_dir = os.getcwd()
+
+    def create_publish_order(self):
+        """Creates a valid publish order by topologically
+        sorting crates using the dependency graph."""
+        topological_sorter = TopologicalSorter()
+
+        for crate in self.crates:
+            topological_sorter.add(crate.name, *crate.dependencies)
+
+        self.publish_order: typing.List[str] = [*topological_sorter.static_order()]
+
+    def is_crate_already_published(self, crate_name: str) -> bool:
+        """Checks if a given crate name is already published
+        with the version string we intend to publish with."""
+        found_string: str = get_latest_version_for_crate(crate_name)
+        if found_string is None:
+            return False
+
+        return self.version == found_string
+
+    def publish_crate(self, crate_name: str):
+        # pylint: disable=broad-except
+        """Publish a given crate by name."""
+        status = None
+        try:
+            crate = self.crate_index[crate_name]
+            os.chdir(crate.path)
+            extra_args = []
+            if crate_name in SETTINGS["publish_features"]:
+                extra_args = ["--features", SETTINGS["publish_features"][crate_name]]
+            if self.dry_run:
+                print(f"In dry-run: not publishing crate `{crate_name}`")
+                command = ["cargo", "publish", "--dry-run"] + extra_args
+                if self.verbose:
+                    print(*command)
+                output = subprocess.run(command, check=True)
+                if self.verbose:
+                    print(output)
+            else:
+                command = ["cargo", "publish"] + extra_args
+                if self.verbose:
+                    print(*command)
+                output = subprocess.run(command, check=True)
+                if self.verbose:
+                    print(output)
+            if self.verbose:
+                print("Success.")
+        except Exception as exc:
+            if self.verbose:
+                print(f"Failed to publish {crate_name}.")
+            print(exc)
+            status = exc
+        finally:
+            os.chdir(self.starting_dir)
+        return status
+
+    def publish(self):
+        # pylint: disable=too-many-branches
+        """Publish all packages in workspace."""
+        if self.verbose and self.dry_run:
+            print("(Dry run, not actually publishing anything)")
+        if self.verbose:
+            print("Publishing order:")
+            pprint(self.publish_order)
+        status = {}
+        failures = 0
+
+        for crate_name in self.publish_order:
+            print(f"Publishing `{crate_name}`...")
+            if not self.is_crate_already_published(crate_name):
+                status[crate_name] = self.publish_crate(crate_name)
+                if status[crate_name]:
+                    failures = +1
+            else:
+                print(f"`{crate_name}` was already published!")
+                continue
+
+            # sleep for 16 seconds between crates to ensure the crates.io
+            # index has time to update
+            if not self.dry_run:
+                print(
+                    "Sleeping for 16 seconds to allow the `crates.io` index to update..."
+                )
+                time.sleep(16)
+            else:
+                print("In dry-run: not sleeping for crates.io to update.")
+        if failures > 0 and self.verbose:
+            print(f"encountered {failures} failures.")
+            for key, value in status.items():
+                if value is None:
+                    result = "ok"
+                else:
+                    result = str(value)
+                print(f"{key}\t{result}")
+        if self.verbose:
+            print(f"Published {len(status) - failures} crates.")
+        return failures
+
+
+def main():
+    """Main executable function."""
+    os.environ["WASMER_PUBLISH_SCRIPT_IS_RUNNING"] = "1"
+    parser = argparse.ArgumentParser(
+        description="Publish the Wasmer crates to crates.io"
+    )
+    subparsers = parser.add_subparsers(dest="subcommand")
+    health_cmd = subparsers.add_parser(
+        "health-check",
+        help="""Check the dependency graph is a tree, meaning a non-cyclic
+        planar graph. Combine with verbosity to print a topological sorting
+        of the graph.""",
+    )
+    health_cmd.add_argument(
+        "-v",
+        "--verbose",
+        default=False,
+        action="store_true",
+        help="Be verbose.",
+    )
+    health_cmd.add_argument(
+        "--print-dependencies",
+        default=False,
+        action="store_true",
+        help="For each crate, print its dependencies.",
+    )
+    publish_cmd = subparsers.add_parser(
+        "publish", help="Publish Wasmer crates to crates.io."
+    )
+    publish_cmd.add_argument(
+        "--version",
+        default=None,
+        type=str,
+        help="""Define the semver target triple (Default is automatically
+        read from workspace Cargo.toml.""",
+    )
+    publish_cmd.add_argument(
+        "--dry-run",
+        default=False,
+        action="store_true",
+        help="""Run the script without actually publishing anything to
+        crates.io""",
+    )
+    publish_cmd.add_argument(
+        "-v",
+        "--verbose",
+        default=False,
+        action="store_true",
+        help="Be verbose.",
+    )
+
+    args = parser.parse_args()
+    if args.subcommand == "health-check":
+        verbose = args.verbose
+        publisher = Publisher(verbose=verbose)
+        if verbose:
+            print(f"Version is {publisher.version}")
+            pprint(publisher.publish_order)
+        if args.print_dependencies:
+            for crate in publisher.crates:
+                print(f"{crate.name}: {crate.dependencies}")
+        return 0
+
+    if args.subcommand == "publish":
+        verbose = args.verbose
+        publisher = Publisher(dry_run=args.dry_run, verbose=verbose)
+        return publisher.publish()
+    return 0
+
+
+if __name__ == "__main__":
+    main()
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/update-version.py b/arbitrator/tools/module_roots/wasmer/scripts/update-version.py
new file mode 100644
index 0000000..c82f9d6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/update-version.py
@@ -0,0 +1,51 @@
+#!/usr/bin/python
+
+PREVIOUS_VERSION='4.2.7'
+NEXT_VERSION='4.2.8'
+
+import os
+import re
+
+def replace(file, pattern, subst):
+    # Read contents from file as a single string
+    file_handle = open(file, 'r')
+    file_string = file_handle.read()
+    file_handle.close()
+
+    # Use RE package to allow for replacement (also allowing for (multiline) REGEX)
+    file_string = (re.sub(pattern, subst, file_string))
+
+    # Write contents to file.
+    # Using mode 'w' truncates the file.
+    file_handle = open(file, 'w')
+    file_handle.write(file_string)
+    file_handle.close()
+
+def replace_version(path):
+    print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
+    replace(path, "version = \"" + PREVIOUS_VERSION +"\"", "version = \"" + NEXT_VERSION +"\"")
+    replace(path, "version = \"=" + PREVIOUS_VERSION +"\"", "version = \"=" + NEXT_VERSION +"\"")
+    pass
+
+def replace_version_py(path):
+    print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
+    replace(path, "target_version = \"" + PREVIOUS_VERSION +"\"", "target_version = \"" + NEXT_VERSION +"\"")
+    pass
+
+def replace_version_iss(path):
+    print(PREVIOUS_VERSION + " -> " + NEXT_VERSION + " (" + path + ")")
+    replace(path, "AppVersion=" + PREVIOUS_VERSION, "AppVersion=" + NEXT_VERSION)
+    pass
+
+for root, dirs, files in os.walk("."):
+    path = root.split(os.sep)
+    # print((len(path) - 1) * '---', os.path.basename(root))
+    for file in files:
+        if "Cargo.toml" in file:
+            replace_version(root + "/" + file)
+        elif "wasmer.iss" in file:
+            replace_version_iss(root + "/" + file)
+        elif "publish.py" in file:
+            replace_version_py(root + "/" + file)
+
+os.system("cargo generate-lockfile")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/wasmer-binfmt.service.example b/arbitrator/tools/module_roots/wasmer/scripts/wasmer-binfmt.service.example
new file mode 100644
index 0000000..414aef7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/wasmer-binfmt.service.example
@@ -0,0 +1,15 @@
+[Unit]
+Description=Set up wasmer to handle execution of wasm binaries
+DefaultDependencies=no
+Conflicts=shutdown.target
+After=proc-sys-fs-binfmt_misc.automount
+After=proc-sys-fs-binfmt_misc.mount
+Before=sysinit.target shutdown.target
+ConditionPathIsReadWrite=/proc/sys/
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+ExecStart=/usr/bin/wasmer binfmt reregister
+ExecStop=/usr/bin/wasmer binfmt unregister
+TimeoutSec=10s
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo.ico b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo.ico
new file mode 100644
index 0000000..80d69b0
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo.ico differ
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_2.bmp b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_2.bmp
new file mode 100644
index 0000000..91c93ba
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_2.bmp differ
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_small.bmp b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_small.bmp
new file mode 100644
index 0000000..03d6e4d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/media/wizard_logo_small.bmp differ
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wasmer.iss b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wasmer.iss
new file mode 100644
index 0000000..cc86fa3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wasmer.iss
@@ -0,0 +1,95 @@
+[Setup]
+AppName=Wasmer
+AppVersion=4.2.8
+DefaultDirName={pf}\Wasmer
+DefaultGroupName=Wasmer
+Compression=lzma2
+SolidCompression=yes
+OutputDir=.\
+DisableProgramGroupPage=yes
+ChangesEnvironment=yes
+OutputBaseFilename=WasmerInstaller
+WizardImageFile=media\wizard_logo_2.bmp
+WizardSmallImageFile=media\wizard_logo_small.bmp
+SetupIconFile=media\wizard_logo.ico
+DisableWelcomePage=no
+
+[Registry]
+Root: HKCU; Subkey: "Environment"; ValueType:string; ValueName: "WASMER_DIR"; \
+    ValueData: "{app}"; Flags: preservestringtype
+Root: HKCU; Subkey: "Environment"; ValueType:string; ValueName: "WASMER_CACHE_DIR"; \
+    ValueData: "{%USERPROFILE}\.wasmer\cache"; Flags: preservestringtype
+
+[Files]
+Source: "..\..\package\bin\*"; DestDir: "{app}\bin"
+Source: "..\..\package\include\*"; DestDir: "{app}\include"
+Source: "..\..\package\lib\*"; DestDir: "{app}\lib"
+Source: "..\..\package\LICENSE"; DestDir: "{app}"
+Source: "..\..\package\ATTRIBUTIONS"; DestDir: "{app}"
+Source: "wax.cmd"; DestDir: "{app}\bin"
+
+[Dirs]
+Name: "{%USERPROFILE}\.wasmer"
+
+[Code]
+const EnvironmentKey = 'SYSTEM\CurrentControlSet\Control\Session Manager\Environment';
+
+procedure EnvAddPath(Path: string);
+var
+    Paths: string;
+begin
+    { Retrieve current path (use empty string if entry not exists) }
+    if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Paths := '';
+
+    { Skip if string already found in path }
+    if Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';') > 0 then exit;
+
+    { App string to the end of the path variable }
+    Paths := Paths + ';'+ Path +';'
+
+    { Overwrite (or create if missing) path environment variable }
+    if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Log(Format('The [%s] added to PATH: [%s]', [Path, Paths]))
+    else Log(Format('Error while adding the [%s] to PATH: [%s]', [Path, Paths]));
+end;
+
+procedure EnvRemovePath(Path: string);
+var
+    Paths: string;
+    P: Integer;
+begin
+    { Skip if registry entry not exists }
+    if not RegQueryStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths) then
+        exit;
+
+    { Skip if string not found in path }
+    P := Pos(';' + Uppercase(Path) + ';', ';' + Uppercase(Paths) + ';');
+    if P = 0 then exit;
+
+    { Update path variable }
+    Delete(Paths, P - 1, Length(Path) + 1);
+
+    { Overwrite path environment variable }
+    if RegWriteStringValue(HKEY_LOCAL_MACHINE, EnvironmentKey, 'Path', Paths)
+    then Log(Format('The [%s] removed from PATH: [%s]', [Path, Paths]))
+    else Log(Format('Error while removing the [%s] from PATH: [%s]', [Path, Paths]));
+end;
+
+procedure CurStepChanged(CurStep: TSetupStep);
+begin
+    if CurStep = ssPostInstall 
+     then begin 
+     EnvAddPath(ExpandConstant('{app}') +'\bin');
+     EnvAddPath(ExpandConstant('{app}') +'\globals\wapm_packages\.bin');
+     end
+end;
+
+procedure CurUninstallStepChanged(CurUninstallStep: TUninstallStep);
+begin
+    if CurUninstallStep = usPostUninstall
+    then begin 
+    EnvRemovePath(ExpandConstant('{app}') +'\bin');
+    EnvAddPath(ExpandConstant('{app}') +'\globals\wapm_packages\.bin');
+    end
+end;
diff --git a/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wax.cmd b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wax.cmd
new file mode 100644
index 0000000..efe9eaf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/scripts/windows-installer/wax.cmd
@@ -0,0 +1,2 @@
+@echo off
+wapm.exe execute %*
diff --git a/arbitrator/tools/module_roots/wasmer/sm64.us.f3dex2e.wasm b/arbitrator/tools/module_roots/wasmer/sm64.us.f3dex2e.wasm
new file mode 100644
index 0000000..2d60386
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/sm64.us.f3dex2e.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/artifact.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/artifact.rs
new file mode 100644
index 0000000..d619730
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/artifact.rs
@@ -0,0 +1,79 @@
+use std::{fs, path::PathBuf};
+
+use cfg_if::cfg_if;
+use wasmer::{Engine, Module};
+
+#[test]
+fn artifact_serialization_roundtrip() {
+    let file_names = ["bash.wasm", "cowsay.wasm", "python-3.11.3.wasm"];
+
+    for file_name in file_names {
+        let path = PathBuf::from("tests/integration/cli/tests/wasm").join(file_name);
+        let wasm_module = fs::read(path).unwrap();
+        let engine = Engine::default();
+        let module = Module::new(&engine, wasm_module).unwrap();
+        let serialized_bytes = module.serialize().unwrap();
+        let deserialized_module =
+            unsafe { Module::deserialize(&engine, serialized_bytes.clone()) }.unwrap();
+        let reserialized_bytes = deserialized_module.serialize().unwrap();
+        assert_eq!(serialized_bytes, reserialized_bytes);
+    }
+}
+
+// This test is just here to update the compiled objects to their
+// latest version, so we can commit them to the repo.
+#[test]
+#[ignore = "Please enable it when tests fail, so we can generate new versions of the .wasmu files"]
+fn artifact_serialization_build() {
+    use std::str::FromStr;
+    use wasmer::sys::{get_default_compiler_config, Features, NativeEngineExt};
+    use wasmer::{CpuFeature, Target, Triple};
+
+    let file_names = ["bash.wasm", "cowsay.wasm", "python-3.11.3.wasm"];
+    let operating_systems = ["linux", "windows"];
+    let chipset = "x86_64";
+
+    for os in operating_systems {
+        let triple = Triple::from_str(&format!("{}-{}", chipset, os)).unwrap();
+        let mut cpu_feature = CpuFeature::set();
+        cpu_feature.insert(CpuFeature::from_str("sse2").unwrap());
+        let target = Target::new(triple, cpu_feature);
+        for file_name in file_names {
+            let path = PathBuf::from("tests/integration/cli/tests/wasm").join(file_name);
+            let wasm_module = fs::read(path).unwrap();
+            let config = get_default_compiler_config().unwrap();
+            let engine = Engine::new(config, target.clone(), Features::default());
+
+            let module = Module::new(&engine, wasm_module).unwrap();
+            let serialized_bytes = module.serialize().unwrap();
+            let path = PathBuf::from(&format!("tests/compilers/wasmu/{}/{}u", os, file_name));
+            std::fs::write(path, serialized_bytes).unwrap();
+        }
+    }
+}
+
+#[test]
+#[cfg(target_arch = "x86_64")]
+fn artifact_deserialization_roundtrip() {
+    // This test is included to make sure we don't break the serialized format
+    // by mistake. Otherwise, everything in this test is already tested in
+    // `artifact_serialization_roundtrip`.
+    let file_names = ["bash.wasmu", "cowsay.wasmu", "python-3.11.3.wasmu"];
+
+    cfg_if!(
+        if #[cfg(target_os = "windows")] {
+            let base_path = "tests/compilers/wasmu/windows";
+        } else {
+            let base_path = "tests/compilers/wasmu/linux";
+        }
+    );
+
+    for file_name in file_names {
+        let path = PathBuf::from(base_path).join(file_name);
+        let wasm_module_bytes = fs::read(path).unwrap();
+        let engine = Engine::default();
+        let module = unsafe { Module::deserialize(&engine, wasm_module_bytes.clone()) }.unwrap();
+        let reserialized_bytes = module.serialize().unwrap();
+        assert_eq!(wasm_module_bytes.to_vec(), reserialized_bytes);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/config.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/config.rs
new file mode 100644
index 0000000..9673955
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/config.rs
@@ -0,0 +1,110 @@
+use std::sync::Arc;
+use wasmer::sys::Features;
+use wasmer::{CompilerConfig, ModuleMiddleware, Store};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Compiler {
+    LLVM,
+    Cranelift,
+    Singlepass,
+}
+
+#[derive(Clone)]
+pub struct Config {
+    pub compiler: Compiler,
+    pub features: Option<Features>,
+    pub middlewares: Vec<Arc<dyn ModuleMiddleware>>,
+    pub canonicalize_nans: bool,
+}
+
+impl Config {
+    pub fn new(compiler: Compiler) -> Self {
+        Self {
+            compiler,
+            features: None,
+            canonicalize_nans: false,
+            middlewares: vec![],
+        }
+    }
+
+    pub fn set_middlewares(&mut self, middlewares: Vec<Arc<dyn ModuleMiddleware>>) {
+        self.middlewares = middlewares;
+    }
+
+    pub fn set_features(&mut self, features: Features) {
+        self.features = Some(features);
+    }
+
+    pub fn set_nan_canonicalization(&mut self, canonicalize_nans: bool) {
+        self.canonicalize_nans = canonicalize_nans;
+    }
+
+    pub fn store(&self) -> Store {
+        let compiler_config = self.compiler_config(self.canonicalize_nans);
+        let engine = self.engine(compiler_config);
+        Store::new(engine)
+    }
+
+    pub fn headless_store(&self) -> Store {
+        let engine = self.engine_headless();
+        Store::new(engine)
+    }
+
+    pub fn engine(&self, compiler_config: Box<dyn CompilerConfig>) -> wasmer::Engine {
+        let mut engine = wasmer::sys::EngineBuilder::new(compiler_config);
+        if let Some(ref features) = self.features {
+            engine = engine.set_features(Some(features.clone()));
+        }
+        engine.engine().into()
+    }
+
+    pub fn engine_headless(&self) -> wasmer::Engine {
+        wasmer::sys::EngineBuilder::headless().engine().into()
+    }
+
+    pub fn compiler_config(
+        &self,
+        #[allow(unused_variables)] canonicalize_nans: bool,
+    ) -> Box<dyn CompilerConfig> {
+        match &self.compiler {
+            #[cfg(feature = "cranelift")]
+            Compiler::Cranelift => {
+                let mut compiler = wasmer_compiler_cranelift::Cranelift::new();
+                compiler.canonicalize_nans(canonicalize_nans);
+                compiler.enable_verifier();
+                self.add_middlewares(&mut compiler);
+                Box::new(compiler)
+            }
+            #[cfg(feature = "llvm")]
+            Compiler::LLVM => {
+                let mut compiler = wasmer_compiler_llvm::LLVM::new();
+                compiler.canonicalize_nans(canonicalize_nans);
+                compiler.enable_verifier();
+                self.add_middlewares(&mut compiler);
+                Box::new(compiler)
+            }
+            #[cfg(feature = "singlepass")]
+            Compiler::Singlepass => {
+                let mut compiler = wasmer_compiler_singlepass::Singlepass::new();
+                compiler.canonicalize_nans(canonicalize_nans);
+                compiler.enable_verifier();
+                self.add_middlewares(&mut compiler);
+                Box::new(compiler)
+            }
+            #[allow(unreachable_patterns)]
+            compiler => {
+                panic!(
+                    "The {:?} Compiler is not enabled. Enable it via the features",
+                    compiler
+                )
+            }
+        }
+    }
+
+    #[allow(dead_code)]
+    fn add_middlewares(&self, config: &mut dyn CompilerConfig) {
+        for middleware in self.middlewares.iter() {
+            config.push_middleware(middleware.clone());
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/deterministic.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/deterministic.rs
new file mode 100644
index 0000000..83a9a0e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/deterministic.rs
@@ -0,0 +1,44 @@
+use anyhow::Result;
+use wasmer::{wat2wasm, Module, Store};
+
+fn compile_and_compare(wasm: &[u8]) -> Result<()> {
+    let store = Store::default();
+
+    // compile for first time
+    let module = Module::new(&store, wasm)?;
+    let first = module.serialize()?;
+
+    // compile for second time
+    let module = Module::new(&store, wasm)?;
+    let second = module.serialize()?;
+
+    assert!(first == second);
+
+    Ok(())
+}
+
+#[test]
+fn deterministic_empty() -> Result<()> {
+    let wasm_bytes = wat2wasm(
+        br#"
+    (module)
+    "#,
+    )?;
+
+    compile_and_compare(&wasm_bytes)
+}
+
+#[test]
+fn deterministic_table() -> Result<()> {
+    let wasm_bytes = wat2wasm(
+        br#"
+(module
+  (table 2 funcref)
+  (func $f1)
+  (func $f2)
+  (elem (i32.const 0) $f1 $f2))
+"#,
+    )?;
+
+    compile_and_compare(&wasm_bytes)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/imports.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/imports.rs
new file mode 100644
index 0000000..a14273d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/imports.rs
@@ -0,0 +1,509 @@
+//! Testing the imports with different provided functions.
+//! This tests checks that the provided functions (both native and
+//! dynamic ones) work properly.
+
+use anyhow::Result;
+use std::convert::Infallible;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering::SeqCst},
+    Arc,
+};
+use wasmer::FunctionEnv;
+use wasmer::Type as ValueType;
+use wasmer::*;
+
+fn get_module(store: &Store) -> Result<Module> {
+    let wat = r#"
+        (import "host" "0" (func))
+        (import "host" "1" (func (param i32) (result i32)))
+        (import "host" "2" (func (param i32) (param i64)))
+        (import "host" "3" (func (param i32 i64 i32 f32 f64)))
+        (memory $mem 1)
+        (export "memory" (memory $mem))
+
+        (func $foo
+            call 0
+            i32.const 0
+            call 1
+            i32.const 1
+            i32.add
+            i64.const 3
+            call 2
+
+            i32.const 100
+            i64.const 200
+            i32.const 300
+            f32.const 400
+            f64.const 500
+            call 3
+        )
+        (start $foo)
+    "#;
+
+    let module = Module::new(store, wat)?;
+    Ok(module)
+}
+
+#[compiler_test(imports)]
+#[serial_test::serial(dynamic_function)]
+fn dynamic_function(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module(&store)?;
+    static HITS: AtomicUsize = AtomicUsize::new(0);
+    let imports = imports! {
+        "host" => {
+            "0" => Function::new(&mut store, FunctionType::new(vec![], vec![]), |_values| {
+                    assert_eq!(HITS.fetch_add(1, SeqCst), 0);
+                    Ok(vec![])
+                }),
+            "1" => Function::new(&mut store, FunctionType::new(vec![ValueType::I32], vec![ValueType::I32]), |values| {
+                    assert_eq!(values[0], Value::I32(0));
+                    assert_eq!(HITS.fetch_add(1, SeqCst), 1);
+                    Ok(vec![Value::I32(1)])
+                }),
+            "2" => Function::new(&mut store, FunctionType::new(vec![ValueType::I32, ValueType::I64], vec![]), |values| {
+                    assert_eq!(values[0], Value::I32(2));
+                    assert_eq!(values[1], Value::I64(3));
+                    assert_eq!(HITS.fetch_add(1, SeqCst), 2);
+                    Ok(vec![])
+                }),
+            "3" => Function::new(&mut store, FunctionType::new(vec![ValueType::I32, ValueType::I64, ValueType::I32, ValueType::F32, ValueType::F64], vec![]), |values| {
+                    assert_eq!(values[0], Value::I32(100));
+                    assert_eq!(values[1], Value::I64(200));
+                    assert_eq!(values[2], Value::I32(300));
+                    assert_eq!(values[3], Value::F32(400.0));
+                    assert_eq!(values[4], Value::F64(500.0));
+                    assert_eq!(HITS.fetch_add(1, SeqCst), 3);
+                    Ok(vec![])
+                }),
+        }
+    };
+    Instance::new(&mut store, &module, &imports)?;
+    assert_eq!(HITS.swap(0, SeqCst), 4);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+fn dynamic_function_with_env(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module(&store)?;
+
+    #[derive(Clone)]
+    struct Env {
+        counter: Arc<AtomicUsize>,
+    }
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<AtomicUsize>;
+        fn deref(&self) -> &Self::Target {
+            &self.counter
+        }
+    }
+
+    let env: Env = Env {
+        counter: Arc::new(AtomicUsize::new(0)),
+    };
+    let mut env = FunctionEnv::new(&mut store, env);
+    let f0 = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(vec![], vec![]),
+        |env, _values| {
+            assert_eq!(env.data().fetch_add(1, SeqCst), 0);
+            Ok(vec![])
+        },
+    );
+    let f1 = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(vec![ValueType::I32], vec![ValueType::I32]),
+        |env, values| {
+            assert_eq!(values[0], Value::I32(0));
+            assert_eq!(env.data().fetch_add(1, SeqCst), 1);
+            Ok(vec![Value::I32(1)])
+        },
+    );
+    let f2 = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(vec![ValueType::I32, ValueType::I64], vec![]),
+        |env, values| {
+            assert_eq!(values[0], Value::I32(2));
+            assert_eq!(values[1], Value::I64(3));
+            assert_eq!(env.data().fetch_add(1, SeqCst), 2);
+            Ok(vec![])
+        },
+    );
+    let f3 = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(
+            vec![
+                ValueType::I32,
+                ValueType::I64,
+                ValueType::I32,
+                ValueType::F32,
+                ValueType::F64,
+            ],
+            vec![],
+        ),
+        |env, values| {
+            assert_eq!(values[0], Value::I32(100));
+            assert_eq!(values[1], Value::I64(200));
+            assert_eq!(values[2], Value::I32(300));
+            assert_eq!(values[3], Value::F32(400.0));
+            assert_eq!(values[4], Value::F64(500.0));
+            assert_eq!(env.data().fetch_add(1, SeqCst), 3);
+            Ok(vec![])
+        },
+    );
+    Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "0" => f0,
+                "1" => f1,
+                "2" => f2,
+                "3" => f3,
+            },
+        },
+    )?;
+    assert_eq!(env.as_mut(&mut store).load(SeqCst), 4);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+#[serial_test::serial(static_function)]
+fn static_function(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module(&store)?;
+
+    static HITS: AtomicUsize = AtomicUsize::new(0);
+    let f0 = Function::new_typed(&mut store, || {
+        assert_eq!(HITS.fetch_add(1, SeqCst), 0);
+    });
+    let f1 = Function::new_typed(&mut store, |x: i32| -> i32 {
+        assert_eq!(x, 0);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 1);
+        1
+    });
+    let f2 = Function::new_typed(&mut store, |x: i32, y: i64| {
+        assert_eq!(x, 2);
+        assert_eq!(y, 3);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 2);
+    });
+    let f3 = Function::new_typed(&mut store, |a: i32, b: i64, c: i32, d: f32, e: f64| {
+        assert_eq!(a, 100);
+        assert_eq!(b, 200);
+        assert_eq!(c, 300);
+        assert_eq!(d, 400.0);
+        assert_eq!(e, 500.0);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 3);
+    });
+    Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "0" => f0,
+                "1" => f1,
+                "2" => f2,
+                "3" => f3,
+            },
+        },
+    )?;
+    assert_eq!(HITS.swap(0, SeqCst), 4);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+#[serial_test::serial(static_function_with_results)]
+fn static_function_with_results(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module(&store)?;
+
+    static HITS: AtomicUsize = AtomicUsize::new(0);
+    let f0 = Function::new_typed(&mut store, || {
+        assert_eq!(HITS.fetch_add(1, SeqCst), 0);
+    });
+    let f1 = Function::new_typed(&mut store, |x: i32| -> Result<i32, Infallible> {
+        assert_eq!(x, 0);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 1);
+        Ok(1)
+    });
+    let f2 = Function::new_typed(&mut store, |x: i32, y: i64| {
+        assert_eq!(x, 2);
+        assert_eq!(y, 3);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 2);
+    });
+    let f3 = Function::new_typed(&mut store, |a: i32, b: i64, c: i32, d: f32, e: f64| {
+        assert_eq!(a, 100);
+        assert_eq!(b, 200);
+        assert_eq!(c, 300);
+        assert_eq!(d, 400.0);
+        assert_eq!(e, 500.0);
+        assert_eq!(HITS.fetch_add(1, SeqCst), 3);
+    });
+    Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "0" => f0,
+                "1" => f1,
+                "2" => f2,
+                "3" => f3,
+            },
+        },
+    )?;
+    assert_eq!(HITS.swap(0, SeqCst), 4);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+fn static_function_with_env(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module(&store)?;
+
+    #[derive(Clone)]
+    struct Env(Arc<AtomicUsize>);
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<AtomicUsize>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let env: Env = Env(Arc::new(AtomicUsize::new(0)));
+    let mut env = FunctionEnv::new(&mut store, env);
+    let f0 = Function::new_typed_with_env(&mut store, &env, |env: FunctionEnvMut<Env>| {
+        assert_eq!(env.data().fetch_add(1, SeqCst), 0);
+    });
+    let f1 = Function::new_typed_with_env(
+        &mut store,
+        &env,
+        |env: FunctionEnvMut<Env>, x: i32| -> i32 {
+            assert_eq!(x, 0);
+            assert_eq!(env.data().fetch_add(1, SeqCst), 1);
+            1
+        },
+    );
+    let f2 = Function::new_typed_with_env(
+        &mut store,
+        &env,
+        |env: FunctionEnvMut<Env>, x: i32, y: i64| {
+            assert_eq!(x, 2);
+            assert_eq!(y, 3);
+            assert_eq!(env.data().fetch_add(1, SeqCst), 2);
+        },
+    );
+    let f3 = Function::new_typed_with_env(
+        &mut store,
+        &env,
+        |env: FunctionEnvMut<Env>, a: i32, b: i64, c: i32, d: f32, e: f64| {
+            assert_eq!(a, 100);
+            assert_eq!(b, 200);
+            assert_eq!(c, 300);
+            assert_eq!(d, 400.0);
+            assert_eq!(e, 500.0);
+            assert_eq!(env.data().fetch_add(1, SeqCst), 3);
+        },
+    );
+    Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "0" => f0,
+                "1" => f1,
+                "2" => f2,
+                "3" => f3,
+            },
+        },
+    )?;
+    assert_eq!(env.as_mut(&mut store).load(SeqCst), 4);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+fn static_function_that_fails(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (import "host" "0" (func))
+
+        (func $foo
+            call 0
+        )
+        (start $foo)
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let f0 = Function::new_typed(&mut store, || -> Result<Infallible, RuntimeError> {
+        Err(RuntimeError::new("oops"))
+    });
+    let result = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "0" => f0,
+            },
+        },
+    );
+
+    assert!(result.is_err());
+
+    match result {
+        Err(InstantiationError::Start(runtime_error)) => {
+            assert_eq!(runtime_error.message(), "oops")
+        }
+        _ => assert!(false),
+    }
+
+    Ok(())
+}
+
+fn get_module2(store: &Store) -> Result<Module> {
+    let wat = r#"
+        (import "host" "fn" (func))
+        (memory $mem 1)
+        (export "memory" (memory $mem))
+        (export "main" (func $main))
+        (func $main (param) (result)
+          (call 0))
+    "#;
+
+    let module = Module::new(store, wat)?;
+    Ok(module)
+}
+
+#[compiler_test(imports)]
+fn dynamic_function_with_env_wasmer_env_init_works(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module2(&store)?;
+
+    #[allow(dead_code)]
+    #[derive(Clone)]
+    struct Env {
+        memory: Option<Memory>,
+    }
+
+    let env: Env = Env { memory: None };
+    let mut env = FunctionEnv::new(&mut store, env);
+    let f0 = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(vec![], vec![]),
+        |env, _values| {
+            assert!(env.data().memory.as_ref().is_some());
+            Ok(vec![])
+        },
+    );
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "fn" => f0,
+            },
+        },
+    )?;
+    let memory = instance.exports.get_memory("memory")?;
+    env.as_mut(&mut store).memory = Some(memory.clone());
+    let f: TypedFunction<(), ()> = instance.exports.get_typed_function(&mut store, "main")?;
+    f.call(&mut store)?;
+    Ok(())
+}
+
+#[compiler_test(imports)]
+fn multi_use_host_fn_manages_memory_correctly(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = get_module2(&store)?;
+
+    #[allow(dead_code)]
+    #[derive(Clone)]
+    struct Env {
+        memory: Option<Memory>,
+    }
+
+    /*    impl WasmerEnv for Env {
+        fn init_with_instance(&mut self, instance: &Instance) -> Result<(), HostEnvInitError> {
+            let memory = instance.exports.get_memory("memory")?.clone();
+            self.memory.initialize(memory);
+            Ok(())
+        }
+    }*/
+
+    let env: Env = Env { memory: None };
+    let mut env = FunctionEnv::new(&mut store, env);
+    fn host_fn(env: FunctionEnvMut<Env>) {
+        assert!(env.data().memory.is_some());
+        println!("Hello, world!");
+    }
+    let imports = imports! {
+        "host" => {
+            "fn" => Function::new_typed_with_env(&mut store, &env, host_fn),
+        },
+    };
+    let instance1 = Instance::new(&mut store, &module, &imports)?;
+    let instance2 = Instance::new(&mut store, &module, &imports)?;
+    {
+        let f1: TypedFunction<(), ()> = instance1.exports.get_typed_function(&mut store, "main")?;
+        let memory = instance1.exports.get_memory("memory")?;
+        env.as_mut(&mut store).memory = Some(memory.clone());
+        f1.call(&mut store)?;
+    }
+    drop(instance1);
+    {
+        let f2: TypedFunction<(), ()> = instance2.exports.get_typed_function(&mut store, "main")?;
+        let memory = instance2.exports.get_memory("memory")?;
+        env.as_mut(&mut store).memory = Some(memory.clone());
+        f2.call(&mut store)?;
+    }
+    drop(instance2);
+    Ok(())
+}
+
+#[compiler_test(imports)]
+fn instance_local_memory_lifetime(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let mut env = FunctionEnv::new(&mut store, ());
+    let memory: Memory = {
+        let wat = r#"(module
+    (memory $mem 1)
+    (export "memory" (memory $mem))
+)"#;
+        let module = Module::new(&store, wat)?;
+        let instance = Instance::new(&mut store, &module, &imports! {})?;
+        instance.exports.get_memory("memory")?.clone()
+    };
+
+    let wat = r#"(module
+    (import "env" "memory" (memory $mem 1) )
+    (func $get_at (type $get_at_t) (param $idx i32) (result i32)
+      (i32.load (local.get $idx)))
+    (type $get_at_t (func (param i32) (result i32)))
+    (type $set_at_t (func (param i32) (param i32)))
+    (func $set_at (type $set_at_t) (param $idx i32) (param $val i32)
+      (i32.store (local.get $idx) (local.get $val)))
+    (export "get_at" (func $get_at))
+    (export "set_at" (func $set_at))
+)"#;
+    let module = Module::new(&store, wat)?;
+    let imports = imports! {
+        "env" => {
+            "memory" => memory,
+        },
+    };
+    let instance = Instance::new(&mut store, &module, &imports)?;
+    let set_at: TypedFunction<(i32, i32), ()> =
+        instance.exports.get_typed_function(&mut store, "set_at")?;
+    let get_at: TypedFunction<i32, i32> =
+        instance.exports.get_typed_function(&mut store, "get_at")?;
+    set_at.call(&mut store, 200, 123)?;
+    assert_eq!(get_at.call(&mut store, 200)?, 123);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/issues.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/issues.rs
new file mode 100644
index 0000000..471e465
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/issues.rs
@@ -0,0 +1,444 @@
+//! This file is mainly to assure specific issues are working well
+use anyhow::Result;
+use wasmer::FunctionEnv;
+use wasmer::*;
+
+/// Corruption of WasmerEnv when using call indirect.
+///
+/// Note: this one is specific to Singlepass, but we want to test in all
+/// available compilers.
+///
+/// https://github.com/wasmerio/wasmer/issues/2329
+#[compiler_test(issues)]
+fn issue_2329(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+
+    #[derive(Clone, Default)]
+    pub struct Env {
+        memory: Option<Memory>,
+    }
+
+    impl Env {
+        pub fn new() -> Self {
+            Self { memory: None }
+        }
+    }
+
+    pub fn read_memory(mut ctx: FunctionEnvMut<Env>, guest_ptr: u32) -> u32 {
+        dbg!(ctx.data().memory.as_ref());
+        dbg!(guest_ptr);
+        0
+    }
+
+    let wat = r#"
+    (module
+        (type (;0;) (func (param i32) (result i32)))
+        (type (;1;) (func))
+        (type (;2;) (func (param i32 i32) (result i32)))
+        (import "env" "__read_memory" (func $__read_memory (type 0)))
+        (func $read_memory (type 1)
+          (drop
+            (call $_ZN5other8dispatch17h053cb34ef5d0d7b0E
+              (i32.const 1)
+              (i32.const 2)))
+          (drop
+            (call $__read_memory
+              (i32.const 1))))
+        (func $_ZN5other8dispatch17h053cb34ef5d0d7b0E (type 2) (param i32 i32) (result i32)
+          (call_indirect (type 0)
+            (local.get 1)
+            (local.get 0)))
+        (table (;0;) 2 2 funcref)
+        (memory (;0;) 16)
+        (global (;0;) (mut i32) (i32.const 1048576))
+        (global (;1;) i32 (i32.const 1048576))
+        (global (;2;) i32 (i32.const 1048576))
+        (export "memory" (memory 0))
+        (export "read_memory" (func $read_memory))
+        (export "__data_end" (global 1))
+        (export "__heap_base" (global 2))
+        (elem (;0;) (i32.const 1) func $__read_memory))
+    "#;
+    let module = Module::new(&store, wat)?;
+    let env = Env::new();
+    let mut env = FunctionEnv::new(&mut store, env);
+    let imports: Imports = imports! {
+        "env" => {
+            "__read_memory" => Function::new_typed_with_env(
+                &mut store,
+                &env,
+                read_memory
+            ),
+        }
+    };
+    let instance = Instance::new(&mut store, &module, &imports)?;
+    instance
+        .exports
+        .get_function("read_memory")?
+        .call(&mut store, &[])?;
+    Ok(())
+}
+
+#[compiler_test(issues)]
+fn call_with_static_data_pointers(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+
+    #[derive(Clone)]
+    pub struct Env {
+        memory: Option<Memory>,
+    }
+
+    pub fn banana(
+        mut ctx: FunctionEnvMut<Env>,
+        a: u64,
+        b: u64,
+        c: u64,
+        d: u64,
+        e: u64,
+        f: u64,
+        g: u64,
+        h: u64,
+    ) -> u64 {
+        println!("{:?}", (a, b, c, d, e, f, g, h));
+        let mut buf = vec![0; d as usize];
+        let memory = ctx.data().memory.as_ref().unwrap().clone();
+        memory.view(&ctx).read(e, &mut buf).unwrap();
+        let input_string = std::str::from_utf8(&buf).unwrap();
+        assert_eq!(input_string, "bananapeach");
+        0
+    }
+
+    pub fn mango(ctx: FunctionEnvMut<Env>, a: u64) {}
+
+    pub fn chaenomeles(ctx: FunctionEnvMut<Env>, a: u64) -> u64 {
+        0
+    }
+
+    pub fn peach(ctx: FunctionEnvMut<Env>, a: u64, b: u64) -> u64 {
+        0
+    }
+
+    pub fn gas(ctx: FunctionEnvMut<Env>, a: u32) {}
+
+    let wat = r#"
+    (module
+      (type (;0;) (func (param i64)))
+      (type (;1;) (func (param i64) (result i64)))
+      (type (;2;) (func (param i64 i64) (result i64)))
+      (type (;3;) (func (param i64 i64 i64 i64 i64 i64 i64 i64) (result i64)))
+      (type (;4;) (func))
+      (import "env" "mango" (func (;0;) (type 0)))
+      (import "env" "chaenomeles" (func (;1;) (type 1)))
+      (import "env" "peach" (func (;2;) (type 2)))
+      (import "env" "banana" (func (;3;) (type 3)))
+      (import "env" "memory" (memory (;0;) 1024 2048))
+      (func (;4;) (type 4)
+        (local i32 i64)
+        global.get 0
+        i32.const 32
+        i32.sub
+        local.tee 0
+        global.set 0
+        local.get 0
+        i32.const 8
+        i32.add
+        i64.const 0
+        i64.store
+        local.get 0
+        i64.const 0
+        i64.store
+        i64.const 0
+        call 0
+        i64.const 0
+        call 1
+        local.set 1
+        local.get 0
+        i64.const 0
+        i64.store offset=24
+        local.get 0
+        i64.const 0
+        i64.store offset=16
+        i64.const 0
+        i64.const 0
+        call 2
+        local.get 1
+        local.get 0
+        i64.extend_i32_u
+        i64.const 11
+        i32.const 1048576
+        i64.extend_i32_u
+        i64.const 0
+        i64.const 0
+        local.get 0
+        i32.const 16
+        i32.add
+        i64.extend_i32_u
+        call 3
+        return)
+      (global (;0;) (mut i32) (i32.const 1048576))
+      (global (;1;) i32 (i32.const 1048587))
+      (global (;2;) i32 (i32.const 1048592))
+      (global (;3;) (mut i32) (i32.const 0))
+      (export "memory" (memory 0))
+      (export "repro" (func 4))
+      (export "__data_end" (global 1))
+      (export "__heap_base" (global 2))
+      (data (;0;) (i32.const 1048576) "bananapeach"))
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let env = Env { memory: None };
+    let mut env = FunctionEnv::new(&mut store, env);
+    let memory = Memory::new(
+        &mut store,
+        MemoryType::new(Pages(1024), Some(Pages(2048)), false),
+    )
+    .unwrap();
+    env.as_mut(&mut store).memory = Some(memory.clone());
+    let mut exports = Exports::new();
+    exports.insert("memory", memory);
+    exports.insert(
+        "banana",
+        Function::new_typed_with_env(&mut store, &env, banana),
+    );
+    exports.insert(
+        "peach",
+        Function::new_typed_with_env(&mut store, &env, peach),
+    );
+    exports.insert(
+        "chaenomeles",
+        Function::new_typed_with_env(&mut store, &env, chaenomeles),
+    );
+    exports.insert(
+        "mango",
+        Function::new_typed_with_env(&mut store, &env, mango),
+    );
+    exports.insert("gas", Function::new_typed_with_env(&mut store, &env, gas));
+    let mut imports = Imports::new();
+    imports.register_namespace("env", exports);
+    let instance = Instance::new(&mut store, &module, &imports)?;
+    instance
+        .exports
+        .get_function("repro")?
+        .call(&mut store, &[])?;
+    Ok(())
+}
+
+/// Exhaustion of GPRs when calling a function with many floating point arguments
+///
+/// Note: this one is specific to Singlepass, but we want to test in all
+/// available compilers.
+#[compiler_test(issues)]
+fn regression_gpr_exhaustion_for_calls(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module
+          (type (;0;) (func (param f64) (result i32)))
+          (type (;1;) (func (param f64 f64 f64 f64 f64 f64)))
+          (func (;0;) (type 0) (param f64) (result i32)
+            local.get 0
+            local.get 0
+            local.get 0
+            local.get 0
+            f64.const 0
+            f64.const 0
+            f64.const 0
+            f64.const 0
+            f64.const 0
+            f64.const 0
+            f64.const 0
+            i32.const 0
+            call_indirect (type 0)
+            call_indirect (type 1)
+            drop
+            drop
+            drop
+            drop
+            i32.const 0)
+          (table (;0;) 1 1 funcref))
+    "#;
+    let mut env = FunctionEnv::new(&mut store, ());
+    let module = Module::new(&store, wat)?;
+    let imports: Imports = imports! {};
+    let instance = Instance::new(&mut store, &module, &imports)?;
+    Ok(())
+}
+
+#[compiler_test(issues)]
+fn test_start(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let mut env = FunctionEnv::new(&mut store, ());
+    let imports: Imports = imports! {};
+    let wat = r#"
+    (module (func $main (unreachable)) (start $main))
+    "#;
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports);
+    assert!(instance.is_err());
+    if let InstantiationError::Start(err) = instance.unwrap_err() {
+        assert_eq!(err.message(), "unreachable");
+    } else {
+        panic!("_start should have failed with an unreachable error")
+    }
+
+    Ok(())
+}
+
+#[compiler_test(issues)]
+fn test_popcnt(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let mut env = FunctionEnv::new(&mut store, ());
+    let imports: Imports = imports! {};
+
+    let wat = r#"
+    (module
+        (func $popcnt_i32 (export "popcnt_i32") (param i32) (result i32)
+            local.get 0
+            i32.popcnt
+        )
+        (func $popcnt_i64 (export "popcnt_i64") (param i64) (result i64)
+            local.get 0
+            i64.popcnt
+        )
+    )"#;
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports)?;
+
+    let popcnt_i32 = instance.exports.get_function("popcnt_i32").unwrap();
+    let popcnt_i64 = instance.exports.get_function("popcnt_i64").unwrap();
+
+    let get_next_number_i32 = |mut num: i32| {
+        num ^= num << 13;
+        num ^= num >> 17;
+        num ^= num << 5;
+        num
+    };
+    let get_next_number_i64 = |mut num: i64| {
+        num ^= num << 34;
+        num ^= num >> 40;
+        num ^= num << 7;
+        num
+    };
+
+    let mut num = 1;
+    for _ in 1..10000 {
+        let result = popcnt_i32.call(&mut store, &[Value::I32(num)]).unwrap();
+        assert_eq!(&Value::I32(num.count_ones() as i32), result.get(0).unwrap());
+        num = get_next_number_i32(num);
+    }
+
+    let mut num = 1;
+    for _ in 1..10000 {
+        let result = popcnt_i64.call(&mut store, &[Value::I64(num)]).unwrap();
+        assert_eq!(&Value::I64(num.count_ones() as i64), result.get(0).unwrap());
+        num = get_next_number_i64(num);
+    }
+
+    Ok(())
+}
+
+/// Create a large number of local (more than 0x1_0000 bytes, thats 32*16 i64 + 1)
+/// to trigger an issue in the arm64 singlepass compiler
+/// sequence
+///   mov x17, #0x1010
+///   sub xsp, xsp, x17
+/// will tranform to
+///   mov x17, #0x1010
+///   sub xzr, xzr, x17
+/// and the locals
+/// on stack can get corrupted by subsequent calls if they also have locals on stack
+#[compiler_test(issues)]
+fn large_number_local(mut config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+      (module
+        (func (;0;)
+          (local i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+          i64.const 0
+          i64.const 5555
+          i64.add
+          local.set 8
+          i64.const 0
+          i64.const 5555
+          i64.add
+          local.set 9
+          i64.const 0
+          i64.const 5555
+          i64.add
+          local.set 10
+        )
+        (func $large_local (export "large_local") (result i64)
+          (local
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+           i64
+          )
+          (local.set 15 (i64.const 1))
+          (call 0)
+          local.get 6
+          local.get 7
+          i64.add
+          local.get 8
+          i64.add
+          local.get 9
+          i64.add
+          local.get 10
+          i64.add
+          local.get 11
+          i64.add
+          local.get 12
+          i64.add
+          local.get 13
+          i64.add
+          local.get 14
+          i64.add
+          local.get 15
+          i64.add
+          local.get 16
+          i64.add
+        )
+      )
+    "#;
+    let mut env = FunctionEnv::new(&mut store, ());
+    let module = Module::new(&store, wat)?;
+    let imports: Imports = imports! {};
+    let instance = Instance::new(&mut store, &module, &imports)?;
+    let result = instance
+        .exports
+        .get_function("large_local")?
+        .call(&mut store, &[])
+        .unwrap();
+    assert_eq!(&Value::I64(1_i64), result.get(0).unwrap());
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/main.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/main.rs
new file mode 100644
index 0000000..573800e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/main.rs
@@ -0,0 +1,25 @@
+//! This test suite does all the tests that involve any compiler
+//! implementation, such as: singlepass, cranelift or llvm depending
+//! on what's available on the target.
+
+#[macro_use]
+extern crate compiler_test_derive;
+
+mod config;
+mod deterministic;
+mod imports;
+mod issues;
+mod metering;
+mod middlewares;
+// mod multi_value_imports;
+mod artifact;
+mod serialize;
+mod traps;
+mod typed_functions;
+mod wasi;
+mod wast;
+
+pub use crate::config::{Compiler, Config};
+pub use crate::wasi::run_wasi;
+pub use crate::wast::run_wast;
+pub use wasmer_wast::WasiFileSystemKind;
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/metering.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/metering.rs
new file mode 100644
index 0000000..5888a1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/metering.rs
@@ -0,0 +1,172 @@
+use anyhow::Result;
+use wasmer_middlewares::Metering;
+
+use std::sync::Arc;
+use wasmer::wasmparser::Operator;
+use wasmer::FunctionEnv;
+use wasmer::*;
+
+fn cost_always_one(_: &Operator) -> u64 {
+    1
+}
+
+fn run_add_with_limit(mut config: crate::Config, limit: u64) -> Result<()> {
+    config
+        .middlewares
+        .push(Arc::new(Metering::new(limit, cost_always_one)));
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+)"#;
+
+    let import_object = imports! {};
+
+    let module = Module::new(&store, wat).unwrap();
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add")?;
+    f.call(&mut store, 4, 6)?;
+    Ok(())
+}
+
+fn run_loop(mut config: crate::Config, limit: u64, iter_count: i32) -> Result<()> {
+    config
+        .middlewares
+        .push(Arc::new(Metering::new(limit, cost_always_one)));
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "test") (param i32)
+           (local i32)
+           (local.set 1 (i32.const 0))
+           (loop
+            (local.get 1)
+            (i32.const 1)
+            (i32.add)
+            (local.tee 1)
+            (local.get 0)
+            (i32.ne)
+            (br_if 0)
+           )
+        )
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<i32, ()> = instance.exports.get_typed_function(&mut store, "test")?;
+    f.call(&mut store, iter_count)?;
+    Ok(())
+}
+
+#[compiler_test(metering)]
+fn metering_ok(config: crate::Config) -> Result<()> {
+    assert!(run_add_with_limit(config, 4).is_ok());
+    Ok(())
+}
+
+#[compiler_test(metering)]
+fn metering_fail(config: crate::Config) -> Result<()> {
+    assert!(run_add_with_limit(config, 3).is_err());
+    Ok(())
+}
+
+#[compiler_test(metering)]
+fn loop_once(config: crate::Config) -> Result<()> {
+    assert!(run_loop(config.clone(), 12, 1).is_ok());
+    assert!(run_loop(config, 11, 1).is_err());
+    Ok(())
+}
+
+#[compiler_test(metering)]
+fn loop_twice(config: crate::Config) -> Result<()> {
+    assert!(run_loop(config.clone(), 19, 2).is_ok());
+    assert!(run_loop(config, 18, 2).is_err());
+    Ok(())
+}
+
+/// Ported from https://github.com/wasmerio/wasmer/blob/master/tests/middleware_common.rs
+#[compiler_test(metering)]
+fn complex_loop(mut config: crate::Config) -> Result<()> {
+    // Assemblyscript
+    // export function add_to(x: i32, y: i32): i32 {
+    //    for(var i = 0; i < x; i++){
+    //      if(i % 1 == 0){
+    //        y += i;
+    //      } else {
+    //        y *= i
+    //      }
+    //    }
+    //    return y;
+    // }
+    static WAT: &str = r#"
+    (module
+        (type $t0 (func (param i32 i32) (result i32)))
+        (type $t1 (func))
+        (func $add_to (export "add_to") (type $t0) (param $p0 i32) (param $p1 i32) (result i32)
+        (local $l0 i32)
+        block $B0
+            i32.const 0
+            set_local $l0
+            loop $L1
+            get_local $l0
+            get_local $p0
+            i32.lt_s
+            i32.eqz
+            br_if $B0
+            get_local $l0
+            i32.const 1
+            i32.rem_s
+            i32.const 0
+            i32.eq
+            if $I2
+                get_local $p1
+                get_local $l0
+                i32.add
+                set_local $p1
+            else
+                get_local $p1
+                get_local $l0
+                i32.mul
+                set_local $p1
+            end
+            get_local $l0
+            i32.const 1
+            i32.add
+            set_local $l0
+            br $L1
+            unreachable
+            end
+            unreachable
+        end
+        get_local $p1)
+        (func $f1 (type $t1))
+        (table $table (export "table") 1 anyfunc)
+        (memory $memory (export "memory") 0)
+        (global $g0 i32 (i32.const 8))
+        (elem (i32.const 0) $f1))
+    "#;
+    config
+        .middlewares
+        .push(Arc::new(Metering::new(100, cost_always_one)));
+    let mut store = config.store();
+    let mut env = FunctionEnv::new(&mut store, ());
+
+    let module = Module::new(&store, WAT).unwrap();
+
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add_to")?;
+
+    // FIXME: Since now a metering error is signaled with an `unreachable`, it is impossible to verify
+    // the error type. Fix this later.
+    f.call(&mut store, 10_000_000, 4).unwrap_err();
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/middlewares.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/middlewares.rs
new file mode 100644
index 0000000..3935450
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/middlewares.rs
@@ -0,0 +1,218 @@
+use anyhow::Result;
+
+use std::sync::Arc;
+use wasmer::wasmparser::Operator;
+use wasmer::FunctionEnv;
+use wasmer::*;
+
+#[derive(Debug)]
+struct Add2MulGen {
+    value_off: i32,
+}
+
+#[derive(Debug)]
+struct Add2Mul {
+    value_off: i32,
+}
+
+impl ModuleMiddleware for Add2MulGen {
+    fn generate_function_middleware<'a>(
+        &self,
+        _: LocalFunctionIndex,
+    ) -> Box<dyn FunctionMiddleware<'a> + 'a> {
+        Box::new(Add2Mul {
+            value_off: self.value_off,
+        })
+    }
+}
+
+impl<'a> FunctionMiddleware<'a> for Add2Mul {
+    fn feed(
+        &mut self,
+        operator: Operator<'a>,
+        state: &mut MiddlewareReaderState<'a>,
+    ) -> Result<(), MiddlewareError> {
+        match operator {
+            Operator::I32Add => {
+                state.push_operator(Operator::I32Mul);
+                if self.value_off != 0 {
+                    state.push_operator(Operator::I32Const {
+                        value: self.value_off,
+                    });
+                    state.push_operator(Operator::I32Add);
+                }
+            }
+            _ => {
+                state.push_operator(operator);
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct FusionGen;
+
+#[derive(Debug)]
+struct Fusion {
+    state: i32,
+}
+
+impl ModuleMiddleware for FusionGen {
+    fn generate_function_middleware<'a>(
+        &self,
+        _: LocalFunctionIndex,
+    ) -> Box<dyn FunctionMiddleware<'a> + 'a> {
+        Box::new(Fusion { state: 0 })
+    }
+}
+
+impl<'a> FunctionMiddleware<'a> for Fusion {
+    fn feed(
+        &mut self,
+        operator: Operator<'a>,
+        state: &mut MiddlewareReaderState<'a>,
+    ) -> Result<(), MiddlewareError> {
+        match (operator, self.state) {
+            (Operator::I32Add, 0) => {
+                self.state = 1;
+            }
+            (Operator::I32Mul, 1) => {
+                state.push_operator(Operator::Select);
+                self.state = 0;
+            }
+            (operator, 1) => {
+                state.push_operator(Operator::I32Add);
+                state.push_operator(operator);
+                self.state = 0;
+            }
+            (operator, _) => {
+                state.push_operator(operator);
+            }
+        }
+        Ok(())
+    }
+}
+
+#[compiler_test(middlewares)]
+fn middleware_basic(mut config: crate::Config) -> Result<()> {
+    config.set_middlewares(vec![
+        Arc::new(Add2MulGen { value_off: 0 }) as Arc<dyn ModuleMiddleware>
+    ]);
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let mut env = FunctionEnv::new(&mut store, ());
+
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add")?;
+    let result = f.call(&mut store, 4, 6)?;
+    assert_eq!(result, 24);
+    Ok(())
+}
+
+#[compiler_test(middlewares)]
+fn middleware_one_to_multi(mut config: crate::Config) -> Result<()> {
+    config.set_middlewares(vec![
+        Arc::new(Add2MulGen { value_off: 1 }) as Arc<dyn ModuleMiddleware>
+    ]);
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let mut env = FunctionEnv::new(&mut store, ());
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add")?;
+    let result = f.call(&mut store, 4, 6)?;
+    assert_eq!(result, 25);
+    Ok(())
+}
+
+#[compiler_test(middlewares)]
+fn middleware_multi_to_one(mut config: crate::Config) -> Result<()> {
+    config.set_middlewares(vec![Arc::new(FusionGen) as Arc<dyn ModuleMiddleware>]);
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "testfunc") (param i32 i32) (result i32)
+           (local.get 0)
+           (local.get 1)
+           (i32.const 1)
+           (i32.add)
+           (i32.mul))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let mut env = FunctionEnv::new(&mut store, ());
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> = instance
+        .exports
+        .get_typed_function(&mut store, "testfunc")?;
+    let result = f.call(&mut store, 10, 20)?;
+    assert_eq!(result, 10);
+    Ok(())
+}
+
+#[compiler_test(middlewares)]
+fn middleware_chain_order_1(mut config: crate::Config) -> Result<()> {
+    config.set_middlewares(vec![
+        Arc::new(Add2MulGen { value_off: 0 }) as Arc<dyn ModuleMiddleware>,
+        Arc::new(Add2MulGen { value_off: 2 }) as Arc<dyn ModuleMiddleware>,
+    ]);
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add")?;
+    let result = f.call(&mut store, 4, 6)?;
+    assert_eq!(result, 24);
+    Ok(())
+}
+
+#[compiler_test(middlewares)]
+fn middleware_chain_order_2(mut config: crate::Config) -> Result<()> {
+    config.set_middlewares(vec![
+        Arc::new(Add2MulGen { value_off: 2 }) as Arc<dyn ModuleMiddleware>,
+        Arc::new(Add2MulGen { value_off: 0 }) as Arc<dyn ModuleMiddleware>,
+    ]);
+    let mut store = config.store();
+    let wat = r#"(module
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let import_object = imports! {};
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let f: TypedFunction<(i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "add")?;
+    let result = f.call(&mut store, 4, 6)?;
+    assert_eq!(result, 48);
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/multi_value_imports.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/multi_value_imports.rs
new file mode 100644
index 0000000..26f2919
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/multi_value_imports.rs
@@ -0,0 +1,205 @@
+//! Testing the imports with different provided functions.
+//! This tests checks that the provided functions (both native and
+//! dynamic ones) work properly.
+
+use wasmer::*;
+
+macro_rules! mvr_test {
+    ($test_name:ident, $( $result_type:ty ),* ) => {
+        mod $test_name {
+            use wasmer::*;
+
+            fn get_module(store: &Store) -> anyhow::Result<wasmer::Module> {
+                let wat: String = r#"
+  (type $type (func (param i32) (result
+"#.to_string() +
+                    &stringify!( $( $result_type ),* ).replace(",", "").replace("(", "").replace(")", "") + &r#")))
+  (import "host" "callback_fn" (func $callback_fn (type $type)))
+  (func (export "test_call") (type $type)
+    get_local 0
+    call $callback_fn)
+  (func (export "test_call_indirect") (type $type)
+    (i32.const 1)
+    (call_indirect (type $type) (i32.const 0))
+  )
+  (table funcref
+    (elem
+      $callback_fn
+    )
+  )
+"#.to_string();
+                Ok(wasmer::Module::new(&store, &wat)?)
+            }
+
+            fn callback_fn(n: i32) -> ( $( $result_type ),* ) {
+                ( $( <$result_type>::expected_value(n) ),* )
+            }
+
+            #[compiler_test(multi_value_imports)]
+            fn native(config: crate::Config) -> anyhow::Result<()> {
+                let mut store = config.store();
+                let module = get_module(&store)?;
+                let instance = wasmer::Instance::new(
+                    &module,
+                    &wasmer::imports! {
+                        "host" => {
+                            "callback_fn" => wasmer::Function::new_native(&store, callback_fn)
+                        }
+                    }
+                )?;
+                let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice();
+                assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?,
+                           expected_value);
+                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?,
+                           expected_value);
+                Ok(())
+            }
+
+            fn dynamic_callback_fn(values: &[wasmer::Value]) -> anyhow::Result<Vec<wasmer::Val>, wasmer::RuntimeError> {
+                assert_eq!(values[0], wasmer::Value::I32(1));
+                Ok(vec![ $( <$result_type>::expected_val(1) ),* ])
+            }
+
+            #[compiler_test(multi_value_imports)]
+            fn dynamic(config: crate::Config) -> anyhow::Result<()> {
+                let mut store = config.store();
+                let module = get_module(&store)?;
+                let callback_fn = wasmer::Function::new(&store, &wasmer::FunctionType::new(vec![wasmer::ValType::I32], vec![ $( <$result_type>::expected_valtype() ),* ]), dynamic_callback_fn);
+                let instance = wasmer::Instance::new(
+                    &module,
+                    &wasmer::imports! {
+                        "host" => {
+                            "callback_fn" => callback_fn
+                        }
+                    }
+                )?;
+                let expected_value = vec![ $( <$result_type>::expected_val(1) ),* ].into_boxed_slice();
+                assert_eq!(instance.exports.get_function("test_call")?.call(&[wasmer::Val::I32(1)])?,
+                           expected_value);
+                assert_eq!(instance.exports.get_function("test_call_indirect")?.call(&[wasmer::Val::I32(1)])?,
+                           expected_value);
+                Ok(())
+            }
+        }
+    }
+}
+
+trait ExpectedExpr {
+    fn expected_value(n: i32) -> Self;
+    fn expected_val(n: i32) -> wasmer::Val;
+    fn expected_valtype() -> wasmer::ValType;
+}
+impl ExpectedExpr for i32 {
+    fn expected_value(n: i32) -> i32 {
+        n + 1
+    }
+    fn expected_val(n: i32) -> wasmer::Val {
+        wasmer::Val::I32(Self::expected_value(n))
+    }
+    fn expected_valtype() -> wasmer::ValType {
+        wasmer::ValType::I32
+    }
+}
+impl ExpectedExpr for i64 {
+    fn expected_value(n: i32) -> i64 {
+        n as i64 + 2i64
+    }
+    fn expected_val(n: i32) -> wasmer::Val {
+        wasmer::Val::I64(Self::expected_value(n))
+    }
+    fn expected_valtype() -> wasmer::ValType {
+        wasmer::ValType::I64
+    }
+}
+impl ExpectedExpr for f32 {
+    fn expected_value(n: i32) -> f32 {
+        n as f32 * 0.1
+    }
+    fn expected_val(n: i32) -> wasmer::Val {
+        wasmer::Val::F32(Self::expected_value(n))
+    }
+    fn expected_valtype() -> wasmer::ValType {
+        wasmer::ValType::F32
+    }
+}
+impl ExpectedExpr for f64 {
+    fn expected_value(n: i32) -> f64 {
+        n as f64 * 0.12
+    }
+    fn expected_val(n: i32) -> wasmer::Val {
+        wasmer::Val::F64(Self::expected_value(n))
+    }
+    fn expected_valtype() -> wasmer::ValType {
+        wasmer::ValType::F64
+    }
+}
+
+mvr_test!(test_mvr_i32_i32, i32, i32);
+mvr_test!(test_mvr_i32_f32, i32, f32);
+mvr_test!(test_mvr_f32_i32, f32, i32);
+mvr_test!(test_mvr_f32_f32, f32, f32);
+
+mvr_test!(test_mvr_i64_i32, i64, i32);
+mvr_test!(test_mvr_i64_f32, i64, f32);
+mvr_test!(test_mvr_f64_i32, f64, i32);
+mvr_test!(test_mvr_f64_f32, f64, f32);
+
+mvr_test!(test_mvr_i32_i64, i32, i64);
+mvr_test!(test_mvr_f32_i64, f32, i64);
+mvr_test!(test_mvr_i32_f64, i32, f64);
+mvr_test!(test_mvr_f32_f64, f32, f64);
+
+mvr_test!(test_mvr_i32_i32_i32, i32, i32, i32);
+mvr_test!(test_mvr_i32_i32_f32, i32, i32, f32);
+mvr_test!(test_mvr_i32_f32_i32, i32, f32, i32);
+mvr_test!(test_mvr_i32_f32_f32, i32, f32, f32);
+mvr_test!(test_mvr_f32_i32_i32, f32, i32, i32);
+mvr_test!(test_mvr_f32_i32_f32, f32, i32, f32);
+mvr_test!(test_mvr_f32_f32_i32, f32, f32, i32);
+mvr_test!(test_mvr_f32_f32_f32, f32, f32, f32);
+
+mvr_test!(test_mvr_i32_i32_i64, i32, i32, i64);
+mvr_test!(test_mvr_i32_f32_i64, i32, f32, i64);
+mvr_test!(test_mvr_f32_i32_i64, f32, i32, i64);
+mvr_test!(test_mvr_f32_f32_i64, f32, f32, i64);
+mvr_test!(test_mvr_i32_i32_f64, i32, i32, f64);
+mvr_test!(test_mvr_i32_f32_f64, i32, f32, f64);
+mvr_test!(test_mvr_f32_i32_f64, f32, i32, f64);
+mvr_test!(test_mvr_f32_f32_f64, f32, f32, f64);
+
+mvr_test!(test_mvr_i32_i64_i32, i32, i64, i32);
+mvr_test!(test_mvr_i32_i64_f32, i32, i64, f32);
+mvr_test!(test_mvr_f32_i64_i32, f32, i64, i32);
+mvr_test!(test_mvr_f32_i64_f32, f32, i64, f32);
+mvr_test!(test_mvr_i32_f64_i32, i32, f64, i32);
+mvr_test!(test_mvr_i32_f64_f32, i32, f64, f32);
+mvr_test!(test_mvr_f32_f64_i32, f32, f64, i32);
+mvr_test!(test_mvr_f32_f64_f32, f32, f64, f32);
+
+mvr_test!(test_mvr_i64_i32_i32, i64, i32, i32);
+mvr_test!(test_mvr_i64_i32_f32, i64, i32, f32);
+mvr_test!(test_mvr_i64_f32_i32, i64, f32, i32);
+mvr_test!(test_mvr_i64_f32_f32, i64, f32, f32);
+mvr_test!(test_mvr_f64_i32_i32, f64, i32, i32);
+mvr_test!(test_mvr_f64_i32_f32, f64, i32, f32);
+mvr_test!(test_mvr_f64_f32_i32, f64, f32, i32);
+mvr_test!(test_mvr_f64_f32_f32, f64, f32, f32);
+
+mvr_test!(test_mvr_i32_i32_i32_i32, i32, i32, i32, i32);
+mvr_test!(test_mvr_i32_i32_i32_f32, i32, i32, i32, f32);
+mvr_test!(test_mvr_i32_i32_f32_i32, i32, i32, f32, i32);
+mvr_test!(test_mvr_i32_i32_f32_f32, i32, i32, f32, f32);
+mvr_test!(test_mvr_i32_f32_i32_i32, i32, f32, i32, i32);
+mvr_test!(test_mvr_i32_f32_i32_f32, i32, f32, i32, f32);
+mvr_test!(test_mvr_i32_f32_f32_i32, i32, f32, f32, i32);
+mvr_test!(test_mvr_i32_f32_f32_f32, i32, f32, f32, f32);
+mvr_test!(test_mvr_f32_i32_i32_i32, f32, i32, i32, i32);
+mvr_test!(test_mvr_f32_i32_i32_f32, f32, i32, i32, f32);
+mvr_test!(test_mvr_f32_i32_f32_i32, f32, i32, f32, i32);
+mvr_test!(test_mvr_f32_i32_f32_f32, f32, i32, f32, f32);
+mvr_test!(test_mvr_f32_f32_i32_i32, f32, f32, i32, i32);
+mvr_test!(test_mvr_f32_f32_i32_f32, f32, f32, i32, f32);
+mvr_test!(test_mvr_f32_f32_f32_i32, f32, f32, f32, i32);
+mvr_test!(test_mvr_f32_f32_f32_f32, f32, f32, f32, f32);
+
+mvr_test!(test_mvr_i32_i32_i32_i32_i32, i32, i32, i32, i32, i32);
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/serialize.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/serialize.rs
new file mode 100644
index 0000000..fce0451
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/serialize.rs
@@ -0,0 +1,87 @@
+use anyhow::Result;
+use wasmer::*;
+
+#[test]
+fn sanity_test_artifact_deserialize() {
+    let engine = Engine::headless();
+    let result = unsafe { Module::deserialize(&engine, &[]) };
+    assert!(result.is_err());
+}
+
+#[compiler_test(serialize)]
+fn test_serialize(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module
+        (func $hello (import "" "hello"))
+        (func (export "run") (call $hello))
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let serialized_bytes = module.serialize()?;
+    assert!(!serialized_bytes.is_empty());
+    Ok(())
+}
+
+#[compiler_test(serialize)]
+fn test_deserialize(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $name
+            (import "host" "sum_part" (func (param i32 i64 i32 f32 f64) (result i64)))
+            (func (export "test_call") (result i64)
+                i32.const 100
+                i64.const 200
+                i32.const 300
+                f32.const 400
+                f64.const 500
+                call 0
+            )
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let serialized_bytes = module.serialize()?;
+
+    let headless_store = config.headless_store();
+    let deserialized_module = unsafe { Module::deserialize(&headless_store, serialized_bytes)? };
+    assert_eq!(deserialized_module.name(), Some("name"));
+    assert_eq!(
+        deserialized_module.exports().collect::<Vec<_>>(),
+        module.exports().collect::<Vec<_>>()
+    );
+    assert_eq!(
+        deserialized_module.imports().collect::<Vec<_>>(),
+        module.imports().collect::<Vec<_>>()
+    );
+
+    let func_type = FunctionType::new(
+        vec![Type::I32, Type::I64, Type::I32, Type::F32, Type::F64],
+        vec![Type::I64],
+    );
+    let f0 = Function::new(&mut store, &func_type, |params| {
+        let param_0: i64 = params[0].unwrap_i32() as i64;
+        let param_1: i64 = params[1].unwrap_i64() as i64;
+        let param_2: i64 = params[2].unwrap_i32() as i64;
+        let param_3: i64 = params[3].unwrap_f32() as i64;
+        let param_4: i64 = params[4].unwrap_f64() as i64;
+        Ok(vec![Value::I64(
+            param_0 + param_1 + param_2 + param_3 + param_4,
+        )])
+    });
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "host" => {
+                "sum_part" => f0
+            }
+        },
+    )?;
+
+    let test_call = instance.exports.get_function("test_call")?;
+    let result = test_call.call(&mut store, &[])?;
+    assert_eq!(result.to_vec(), vec![Value::I64(1500)]);
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/traps.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/traps.rs
new file mode 100644
index 0000000..1f369dd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/traps.rs
@@ -0,0 +1,492 @@
+use anyhow::Result;
+use std::panic::{self, AssertUnwindSafe};
+use wasmer::*;
+
+#[compiler_test(traps)]
+fn test_trap_return(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module
+        (func $hello (import "" "hello"))
+        (func (export "run") (call $hello))
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let hello_type = FunctionType::new(vec![], vec![]);
+    let hello_func = Function::new(&mut store, &hello_type, |_| {
+        Err(RuntimeError::new("test 123"))
+    });
+
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "" => {
+                "hello" => hello_func
+            }
+        },
+    )?;
+    let run_func = instance
+        .exports
+        .get_function("run")
+        .expect("expected function export");
+
+    let e = run_func
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+
+    assert_eq!(e.message(), "test 123");
+
+    Ok(())
+}
+
+#[cfg_attr(target_env = "musl", ignore)]
+#[compiler_test(traps)]
+fn test_trap_trace(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $hello_mod
+            (func (export "run") (call $hello))
+            (func $hello (unreachable))
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let run_func = instance
+        .exports
+        .get_function("run")
+        .expect("expected function export");
+
+    let e = run_func
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+
+    let trace = e.trace();
+    assert_eq!(trace.len(), 2);
+    assert_eq!(trace[0].module_name(), "hello_mod");
+    assert_eq!(trace[0].func_index(), 1);
+    assert_eq!(trace[0].function_name(), Some("hello"));
+    assert_eq!(trace[1].module_name(), "hello_mod");
+    assert_eq!(trace[1].func_index(), 0);
+    assert_eq!(trace[1].function_name(), None);
+    assert!(
+        e.message().contains("unreachable"),
+        "wrong message: {}",
+        e.message()
+    );
+
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn test_trap_trace_cb(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $hello_mod
+            (import "" "throw" (func $throw))
+            (func (export "run") (call $hello))
+            (func $hello (call $throw))
+        )
+    "#;
+
+    let fn_type = FunctionType::new(vec![], vec![]);
+    let fn_func = Function::new(&mut store, &fn_type, |_| Err(RuntimeError::new("cb throw")));
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "" => {
+                "throw" => fn_func
+            }
+        },
+    )?;
+    let run_func = instance
+        .exports
+        .get_function("run")
+        .expect("expected function export");
+
+    let e = run_func
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+
+    let trace = e.trace();
+    println!("Trace {:?}", trace);
+    // TODO: Reenable this (disabled as it was not working with llvm/singlepass)
+    // assert_eq!(trace.len(), 2);
+    // assert_eq!(trace[0].module_name(), "hello_mod");
+    // assert_eq!(trace[0].func_index(), 2);
+    // assert_eq!(trace[1].module_name(), "hello_mod");
+    // assert_eq!(trace[1].func_index(), 1);
+    assert_eq!(e.message(), "cb throw");
+
+    Ok(())
+}
+
+#[cfg_attr(target_env = "musl", ignore)]
+#[compiler_test(traps)]
+fn test_trap_stack_overflow(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $rec_mod
+            (func $run (export "run") (call $run))
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let run_func = instance
+        .exports
+        .get_function("run")
+        .expect("expected function export");
+
+    let e = run_func
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+
+    // We specifically don't check the stack trace here: stack traces after
+    // stack overflows are not generally possible due to unreliable unwinding
+    // information.
+    assert!(e.message().contains("call stack exhausted"));
+
+    Ok(())
+}
+
+#[cfg_attr(target_env = "musl", ignore)]
+#[compiler_test(traps)]
+fn trap_display_pretty(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $m
+            (func $die unreachable)
+            (func call $die)
+            (func $foo call 1)
+            (func (export "bar") call $foo)
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let run_func = instance
+        .exports
+        .get_function("bar")
+        .expect("expected function export");
+
+    let e = run_func
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+    assert_eq!(
+        e.to_string(),
+        "\
+RuntimeError: unreachable
+    at die (m[0]:0x23)
+    at <unnamed> (m[1]:0x27)
+    at foo (m[2]:0x2c)
+    at <unnamed> (m[3]:0x31)"
+    );
+    Ok(())
+}
+
+#[cfg_attr(target_env = "musl", ignore)]
+#[compiler_test(traps)]
+fn trap_display_multi_module(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $a
+            (func $die unreachable)
+            (func call $die)
+            (func $foo call 1)
+            (func (export "bar") call $foo)
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let bar = instance.exports.get_function("bar")?.clone();
+
+    let wat = r#"
+        (module $b
+            (import "" "" (func $bar))
+            (func $middle call $bar)
+            (func (export "bar2") call $middle)
+        )
+    "#;
+    let module = Module::new(&store, wat)?;
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "" => {
+                "" => bar
+            }
+        },
+    )?;
+    let bar2 = instance
+        .exports
+        .get_function("bar2")
+        .expect("expected function export");
+
+    let e = bar2
+        .call(&mut store, &[])
+        .expect_err("error calling function");
+    assert_eq!(
+        e.to_string(),
+        "\
+RuntimeError: unreachable
+    at die (a[0]:0x23)
+    at <unnamed> (a[1]:0x27)
+    at foo (a[2]:0x2c)
+    at <unnamed> (a[3]:0x31)
+    at middle (b[1]:0x29)
+    at <unnamed> (b[2]:0x2e)"
+    );
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn trap_start_function_import(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let binary = r#"
+        (module $a
+            (import "" "" (func $foo))
+            (start $foo)
+        )
+    "#;
+
+    let module = Module::new(&store, binary)?;
+    let sig = FunctionType::new(vec![], vec![]);
+    let func = Function::new(&mut store, &sig, |_| Err(RuntimeError::new("user trap")));
+    let err = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "" => {
+                "" => func
+            }
+        },
+    )
+    .err()
+    .unwrap();
+    match err {
+        InstantiationError::Link(_)
+        | InstantiationError::DifferentStores
+        | InstantiationError::DifferentArchOS
+        | InstantiationError::CpuFeature(_) => {
+            panic!("It should be a start error")
+        }
+        InstantiationError::Start(err) => {
+            assert_eq!(err.message(), "user trap");
+        }
+    }
+
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn rust_panic_import(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let binary = r#"
+        (module $a
+            (import "" "foo" (func $foo))
+            (import "" "bar" (func $bar))
+            (func (export "foo") call $foo)
+            (func (export "bar") call $bar)
+        )
+    "#;
+
+    let module = Module::new(&store, binary)?;
+    let sig = FunctionType::new(vec![], vec![]);
+    let func = Function::new(&mut store, &sig, |_| panic!("this is a panic"));
+    let f0 = Function::new_typed(&mut store, || panic!("this is another panic"));
+    let instance = Instance::new(
+        &mut store,
+        &module,
+        &imports! {
+            "" => {
+                "foo" => func,
+                "bar" => f0
+            }
+        },
+    )?;
+    let func = instance.exports.get_function("foo")?.clone();
+    let err = panic::catch_unwind(AssertUnwindSafe(|| {
+        drop(func.call(&mut store, &[]));
+    }))
+    .unwrap_err();
+    assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+
+    // TODO: Reenable this (disabled as it was not working with llvm/singlepass)
+    // It doesn't work either with cranelift and `--test-threads=1`.
+    // let func = instance.exports.get_function("bar")?.clone();
+    // let err = panic::catch_unwind(AssertUnwindSafe(|| {
+    //     drop(func.call(&[]));
+    // }))
+    // .unwrap_err();
+    // assert_eq!(
+    //     err.downcast_ref::<&'static str>(),
+    //     Some(&"this is another panic")
+    // );
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn rust_panic_start_function(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let binary = r#"
+        (module $a
+            (import "" "" (func $foo))
+            (start $foo)
+        )
+    "#;
+
+    let module = Module::new(&store, binary)?;
+    let sig = FunctionType::new(vec![], vec![]);
+    let func = Function::new(&mut store, &sig, |_| panic!("this is a panic"));
+    let err = panic::catch_unwind(AssertUnwindSafe(|| {
+        drop(Instance::new(
+            &mut store,
+            &module,
+            &imports! {
+                "" => {
+                    "" => func
+                }
+            },
+        ));
+    }))
+    .unwrap_err();
+    assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
+
+    let func = Function::new_typed(&mut store, || panic!("this is another panic"));
+    let err = panic::catch_unwind(AssertUnwindSafe(|| {
+        drop(Instance::new(
+            &mut store,
+            &module,
+            &imports! {
+                "" => {
+                    "" => func
+                }
+            },
+        ));
+    }))
+    .unwrap_err();
+    assert_eq!(
+        err.downcast_ref::<&'static str>(),
+        Some(&"this is another panic")
+    );
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn mismatched_arguments(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let binary = r#"
+        (module $a
+            (func (export "foo") (param i32))
+        )
+    "#;
+
+    let module = Module::new(&store, binary)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let func: &Function = instance.exports.get("foo")?;
+    assert_eq!(
+        func.call(&mut store, &[]).unwrap_err().message(),
+        "Parameters of type [] did not match signature [I32] -> []"
+    );
+    assert_eq!(
+        func.call(&mut store, &[Value::F32(0.0)])
+            .unwrap_err()
+            .message(),
+        "Parameters of type [F32] did not match signature [I32] -> []",
+    );
+    assert_eq!(
+        func.call(&mut store, &[Value::I32(0), Value::I32(1)])
+            .unwrap_err()
+            .message(),
+        "Parameters of type [I32, I32] did not match signature [I32] -> []"
+    );
+    Ok(())
+}
+
+#[cfg_attr(target_env = "musl", ignore)]
+#[compiler_test(traps)]
+fn call_signature_mismatch(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let binary = r#"
+        (module $a
+            (func $foo
+                i32.const 0
+                call_indirect)
+            (func $bar (param i32))
+            (start $foo)
+
+            (table 1 anyfunc)
+            (elem (i32.const 0) 1)
+        )
+    "#;
+
+    let module = Module::new(&store, binary)?;
+    let err = Instance::new(&mut store, &module, &imports! {}).expect_err("expected error");
+    assert_eq!(
+        format!("{}", err),
+        "\
+RuntimeError: indirect call type mismatch
+    at foo (a[0]:0x30)\
+"
+    );
+    Ok(())
+}
+
+#[compiler_test(traps)]
+#[cfg_attr(target_env = "musl", ignore)]
+fn start_trap_pretty(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let wat = r#"
+        (module $m
+            (func $die unreachable)
+            (func call $die)
+            (func $foo call 1)
+            (func $start call $foo)
+            (start $start)
+        )
+    "#;
+
+    let module = Module::new(&store, wat)?;
+    let err = Instance::new(&mut store, &module, &imports! {}).expect_err("expected error");
+
+    assert_eq!(
+        format!("{}", err),
+        "\
+RuntimeError: unreachable
+    at die (m[0]:0x1d)
+    at <unnamed> (m[1]:0x21)
+    at foo (m[2]:0x26)
+    at start (m[3]:0x2b)\
+"
+    );
+    Ok(())
+}
+
+#[compiler_test(traps)]
+fn present_after_module_drop(config: crate::Config) -> Result<()> {
+    let mut store = config.store();
+    let module = Module::new(&store, r#"(func (export "foo") unreachable)"#)?;
+    let instance = Instance::new(&mut store, &module, &imports! {})?;
+    let func: Function = instance.exports.get_function("foo")?.clone();
+
+    println!("asserting before we drop modules");
+    assert_trap(func.call(&mut store, &[]).unwrap_err());
+    drop((instance, module));
+
+    println!("asserting after drop");
+    assert_trap(func.call(&mut store, &[]).unwrap_err());
+    return Ok(());
+
+    fn assert_trap(t: RuntimeError) {
+        println!("{}", t);
+        // assert_eq!(t.trace().len(), 1);
+        // assert_eq!(t.trace()[0].func_index(), 0);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/typed_functions.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/typed_functions.rs
new file mode 100644
index 0000000..f55447a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/typed_functions.rs
@@ -0,0 +1,476 @@
+#![allow(clippy::unnecessary_operation)] // We use x1 multiplies for clarity
+
+use anyhow::Result;
+use std::convert::Infallible;
+use std::sync::{Arc, Mutex};
+
+use wasmer::FunctionEnv;
+use wasmer::Type as ValueType;
+use wasmer::*;
+
+fn long_f(a: u32, b: u32, c: u32, d: u32, e: u32, f: u16, g: u64, h: u64, i: u16, j: u32) -> u64 {
+    j as u64
+        + i as u64 * 10
+        + h * 100
+        + g * 1000
+        + f as u64 * 10000
+        + e as u64 * 100000
+        + d as u64 * 1000000
+        + c as u64 * 10000000
+        + b as u64 * 100000000
+        + a as u64 * 1000000000
+}
+
+fn long_f_dynamic(values: &[Value]) -> Result<Vec<Value>, RuntimeError> {
+    Ok(vec![Value::I64(
+        values[9].unwrap_i32() as i64
+            + values[8].unwrap_i32() as i64 * 10
+            + values[7].unwrap_i64() * 100
+            + values[6].unwrap_i64() * 1000
+            + values[5].unwrap_i32() as i64 * 10000
+            + values[4].unwrap_i32() as i64 * 100000
+            + values[3].unwrap_i32() as i64 * 1000000
+            + values[2].unwrap_i32() as i64 * 10000000
+            + values[1].unwrap_i32() as i64 * 100000000
+            + values[0].unwrap_i32() as i64 * 1000000000,
+    )])
+}
+
+#[compiler_test(typed_functions)]
+fn typed_function_works_for_wasm(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+    let wat = r#"(module
+        (func $multiply (import "env" "multiply") (param i32 i32) (result i32))
+        (func (export "add") (param i32 i32) (result i32)
+           (i32.add (local.get 0)
+                    (local.get 1)))
+        (func (export "double_then_add") (param i32 i32) (result i32)
+           (i32.add (call $multiply (local.get 0) (i32.const 2))
+                    (call $multiply (local.get 1) (i32.const 2))))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let mut env = FunctionEnv::new(&mut store, ());
+
+    let import_object = imports! {
+        "env" => {
+            "multiply" => Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<_>, a: i32, b: i32| a * b),
+        },
+    };
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    {
+        let f: TypedFunction<(i32, i32), i32> =
+            instance.exports.get_typed_function(&mut store, "add")?;
+        let result = f.call(&mut store, 4, 6)?;
+        assert_eq!(result, 10);
+    }
+
+    {
+        let f: &Function = instance.exports.get("double_then_add")?;
+        let result = f.call(&mut store, &[Value::I32(4), Value::I32(6)])?;
+        assert_eq!(result[0], Value::I32(20));
+    }
+
+    {
+        let dyn_f: &Function = instance.exports.get("double_then_add")?;
+        let f: TypedFunction<(i32, i32), i32> = dyn_f.typed(&mut store).unwrap();
+        let result = f.call(&mut store, 4, 6)?;
+        assert_eq!(result, 20);
+    }
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn typed_host_function_closure_panics(config: crate::Config) {
+    let mut store = config.store();
+    let state = 3;
+    Function::new_typed(&mut store, move |_: i32| {
+        println!("{}", state);
+    });
+}
+
+#[compiler_test(typed_functions)]
+fn typed_with_env_host_function_closure_panics(config: crate::Config) {
+    let mut store = config.store();
+    let env: i32 = 4;
+    let mut env = FunctionEnv::new(&mut store, env);
+    let state = 3;
+    Function::new_typed_with_env(
+        &mut store,
+        &env,
+        move |_env: FunctionEnvMut<i32>, _: i32| {
+            println!("{}", state);
+        },
+    );
+}
+
+#[compiler_test(typed_functions)]
+fn non_typed_functions_and_closures_with_no_env_work(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+    let wat = r#"(module
+        (func $multiply1 (import "env" "multiply1") (param i32 i32) (result i32))
+        (func $multiply2 (import "env" "multiply2") (param i32 i32) (result i32))
+        (func $multiply3 (import "env" "multiply3") (param i32 i32) (result i32))
+        (func $multiply4 (import "env" "multiply4") (param i32 i32) (result i32))
+
+        (func (export "test") (param i32 i32 i32 i32 i32) (result i32)
+           (call $multiply4
+             (call $multiply3
+               (call $multiply2
+                  (call $multiply1
+                    (local.get 0)
+                    (local.get 1))
+                  (local.get 2))
+               (local.get 3))
+              (local.get 4)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let env: i32 = 10;
+    let mut env = FunctionEnv::new(&mut store, env);
+    let ty = FunctionType::new(vec![Type::I32, Type::I32], vec![Type::I32]);
+    let captured_by_closure = 20;
+    let import_object = imports! {
+        "env" => {
+            "multiply1" => Function::new_with_env(&mut store, &env, &ty, move |_env, args| {
+                if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
+                    Ok(vec![Value::I32(v1 * v2 * captured_by_closure)])
+                } else {
+                    panic!("Invalid arguments");
+                }
+            }),
+            "multiply2" => Function::new_with_env(&mut store, &env, &ty, move |env, args| {
+                if let (Value::I32(v1), Value::I32(v2)) = (&args[0], &args[1]) {
+                    Ok(vec![Value::I32(v1 * v2 * captured_by_closure * env.data())])
+                } else {
+                    panic!("Invalid arguments");
+                }
+            }),
+            "multiply3" => Function::new_typed_with_env(&mut store, &env, |_env: FunctionEnvMut<_>, arg1: i32, arg2: i32| -> i32
+                                                {arg1 * arg2 }),
+            "multiply4" => Function::new_typed_with_env(&mut store, &env, |env: FunctionEnvMut<i32>, arg1: i32, arg2: i32| -> i32
+                                                         {arg1 * arg2 * env.data() }),
+        },
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    let test: TypedFunction<(i32, i32, i32, i32, i32), i32> =
+        instance.exports.get_typed_function(&mut store, "test")?;
+
+    let result = test.call(&mut store, 2, 3, 4, 5, 6)?;
+    let manually_computed_result = 6 * (5 * (4 * (3 * 2 * 20) * 10 * 20)) * 10;
+    assert_eq!(result, manually_computed_result);
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn typed_function_works_for_wasm_function_manyparams(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+    let wat = r#"(module
+        (func $longf (import "env" "longf") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64))
+        (func (export "longf_pure") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64)
+           (call $longf (local.get 0) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get 5) (local.get 6) (local.get 7) (local.get 8) (local.get 9)))
+        (func (export "longf") (result i64)
+           (call $longf (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i64.const 7) (i64.const 8) (i32.const 9) (i32.const 0)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+    let import_object = imports! {
+        "env" => {
+            "longf" => Function::new_typed(&mut store, long_f),
+        },
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    {
+        let dyn_f: &Function = instance.exports.get("longf")?;
+        let f: TypedFunction<(), i64> = dyn_f.typed(&mut store).unwrap();
+        let result = f.call(&mut store)?;
+        assert_eq!(result, 1234567890);
+    }
+
+    {
+        let dyn_f: &Function = instance.exports.get("longf_pure")?;
+        let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
+            dyn_f.typed(&mut store).unwrap();
+        let result = f.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+        assert_eq!(result, 1234567890);
+    }
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn typed_function_works_for_wasm_function_manyparams_dynamic(
+    config: crate::Config,
+) -> anyhow::Result<()> {
+    let mut store = config.store();
+    let wat = r#"(module
+        (func $longf (import "env" "longf") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64))
+        (func (export "longf_pure") (param i32 i32 i32 i32 i32 i32 i64 i64 i32 i32) (result i64)
+           (call $longf (local.get 0) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get 5) (local.get 6) (local.get 7) (local.get 8) (local.get 9)))
+        (func (export "longf") (result i64)
+           (call $longf (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i64.const 7) (i64.const 8) (i32.const 9) (i32.const 0)))
+)"#;
+    let module = Module::new(&store, wat).unwrap();
+
+    let import_object = imports! {
+        "env" => {
+            "longf" => Function::new(&mut store, FunctionType::new(vec![ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I32, ValueType::I64 , ValueType::I64 ,ValueType::I32, ValueType::I32], vec![ValueType::I64]), long_f_dynamic),
+        },
+    };
+
+    let instance = Instance::new(&mut store, &module, &import_object)?;
+
+    {
+        let dyn_f: &Function = instance.exports.get("longf")?;
+        let f: TypedFunction<(), i64> = dyn_f.typed(&mut store).unwrap();
+        let result = f.call(&mut store)?;
+        assert_eq!(result, 1234567890);
+    }
+
+    {
+        let dyn_f: &Function = instance.exports.get("longf_pure")?;
+        let f: TypedFunction<(u32, u32, u32, u32, u32, u16, u64, u64, u16, u32), i64> =
+            dyn_f.typed(&mut store).unwrap();
+        let result = f.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+        assert_eq!(result, 1234567890);
+    }
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn static_host_function_without_env(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+
+    fn f(a: i32, b: i64, c: f32, d: f64) -> (f64, f32, i64, i32) {
+        (d * 4.0, c * 3.0, b * 2, a)
+    }
+
+    fn f_ok(a: i32, b: i64, c: f32, d: f64) -> Result<(f64, f32, i64, i32), Infallible> {
+        Ok((d * 4.0, c * 3.0, b * 2, a))
+    }
+
+    fn long_f(
+        a: u32,
+        b: u32,
+        c: u32,
+        d: u32,
+        e: u32,
+        f: u16,
+        g: u64,
+        h: u64,
+        i: u16,
+        j: u32,
+    ) -> (u32, u64, u32) {
+        (
+            a + b * 10 + c * 100 + d * 1000 + e * 10000 + f as u32 * 100000,
+            g + h * 10,
+            i as u32 + j * 10,
+        )
+    }
+
+    // Native static host function that returns a tuple.
+    {
+        let f = Function::new_typed(&mut store, f);
+        let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+            f.typed(&mut store).unwrap();
+        let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+        assert_eq!(result, (28.0, 15.0, 6, 1));
+    }
+
+    // Native static host function that returns a tuple.
+    {
+        let long_f = Function::new_typed(&mut store, long_f);
+        let long_f_typed: TypedFunction<
+            (u32, u32, u32, u32, u32, u16, u64, u64, u16, u32),
+            (u32, u64, u32),
+        > = long_f.typed(&mut store).unwrap();
+        let result = long_f_typed.call(&mut store, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)?;
+        assert_eq!(result, (654321, 87, 09));
+    }
+
+    // Native static host function that returns a result of a tuple.
+    {
+        let f = Function::new_typed(&mut store, f_ok);
+        let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+            f.typed(&mut store).unwrap();
+        let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+        assert_eq!(result, (28.0, 15.0, 6, 1));
+    }
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn static_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+
+    fn f(mut env: FunctionEnvMut<Env>, a: i32, b: i64, c: f32, d: f64) -> (f64, f32, i64, i32) {
+        let mut guard = env.data().0.lock().unwrap();
+        assert_eq!(*guard, 100);
+        *guard = 101;
+
+        (d * 4.0, c * 3.0, b * 2, a)
+    }
+
+    fn f_ok(
+        mut env: FunctionEnvMut<Env>,
+        a: i32,
+        b: i64,
+        c: f32,
+        d: f64,
+    ) -> Result<(f64, f32, i64, i32), Infallible> {
+        let mut guard = env.data().0.lock().unwrap();
+        assert_eq!(*guard, 100);
+        *guard = 101;
+
+        Ok((d * 4.0, c * 3.0, b * 2, a))
+    }
+
+    #[derive(Clone)]
+    struct Env(Arc<Mutex<i32>>);
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<Mutex<i32>>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    // Native static host function that returns a tuple.
+    {
+        let env = Env(Arc::new(Mutex::new(100)));
+        let mut env = FunctionEnv::new(&mut store, env);
+
+        let f = Function::new_typed_with_env(&mut store, &env, f);
+        let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+            f.typed(&mut store).unwrap();
+
+        assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
+
+        let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+
+        assert_eq!(result, (28.0, 15.0, 6, 1));
+        assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 101);
+    }
+
+    // Native static host function that returns a result of a tuple.
+    {
+        let env = Env(Arc::new(Mutex::new(100)));
+        let mut env = FunctionEnv::new(&mut store, env);
+
+        let f = Function::new_typed_with_env(&mut store, &env, f_ok);
+        let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+            f.typed(&mut store).unwrap();
+
+        assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
+
+        let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+
+        assert_eq!(result, (28.0, 15.0, 6, 1));
+        assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 101);
+    }
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn dynamic_host_function_without_env(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+    let f = Function::new(
+        &mut store,
+        FunctionType::new(
+            vec![
+                ValueType::I32,
+                ValueType::I64,
+                ValueType::F32,
+                ValueType::F64,
+            ],
+            vec![
+                ValueType::F64,
+                ValueType::F32,
+                ValueType::I64,
+                ValueType::I32,
+            ],
+        ),
+        |values| {
+            Ok(vec![
+                Value::F64(values[3].unwrap_f64() * 4.0),
+                Value::F32(values[2].unwrap_f32() * 3.0),
+                Value::I64(values[1].unwrap_i64() * 2),
+                Value::I32(values[0].unwrap_i32()),
+            ])
+        },
+    );
+    let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+        f.typed(&mut store).unwrap();
+    let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+
+    assert_eq!(result, (28.0, 15.0, 6, 1));
+
+    Ok(())
+}
+
+#[compiler_test(typed_functions)]
+fn dynamic_host_function_with_env(config: crate::Config) -> anyhow::Result<()> {
+    let mut store = config.store();
+
+    #[derive(Clone)]
+    struct Env(Arc<Mutex<i32>>);
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<Mutex<i32>>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    let env = Env(Arc::new(Mutex::new(100)));
+    let mut env = FunctionEnv::new(&mut store, env);
+    let f = Function::new_with_env(
+        &mut store,
+        &env,
+        FunctionType::new(
+            vec![
+                ValueType::I32,
+                ValueType::I64,
+                ValueType::F32,
+                ValueType::F64,
+            ],
+            vec![
+                ValueType::F64,
+                ValueType::F32,
+                ValueType::I64,
+                ValueType::I32,
+            ],
+        ),
+        |mut env, values| {
+            let mut guard = env.data().0.lock().unwrap();
+            assert_eq!(*guard, 100);
+
+            *guard = 101;
+
+            Ok(vec![
+                Value::F64(values[3].unwrap_f64() * 4.0),
+                Value::F32(values[2].unwrap_f32() * 3.0),
+                Value::I64(values[1].unwrap_i64() * 2),
+                Value::I32(values[0].unwrap_i32()),
+            ])
+        },
+    );
+
+    let f_typed: TypedFunction<(i32, i64, f32, f64), (f64, f32, i64, i32)> =
+        f.typed(&mut store).unwrap();
+
+    assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 100);
+
+    let result = f_typed.call(&mut store, 1, 3, 5.0, 7.0)?;
+
+    assert_eq!(result, (28.0, 15.0, 6, 1));
+    assert_eq!(*env.as_mut(&mut store).0.lock().unwrap(), 101);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasi.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasi.rs
new file mode 100644
index 0000000..ffe3765
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasi.rs
@@ -0,0 +1,42 @@
+use std::fs::File;
+use std::io::Read;
+use wasmer_wast::{WasiFileSystemKind, WasiTest};
+
+// The generated tests (from build.rs) look like:
+// #[cfg(test)]
+// mod [compiler] {
+//     mod [spec] {
+//         mod [vfs] {
+//             #[test]
+//             fn [test_name]() -> anyhow::Result<()> {
+//                 crate::run_wasi("tests/spectests/[test_name].wast", "[compiler]", WasiFileSystemKind::[vfs])
+//             }
+//         }
+//     }
+// }
+include!(concat!(env!("OUT_DIR"), "/generated_wasitests.rs"));
+
+pub fn run_wasi(
+    config: crate::Config,
+    wast_path: &str,
+    base_dir: &str,
+    filesystem_kind: WasiFileSystemKind,
+) -> anyhow::Result<()> {
+    println!("Running wasi wast `{}`", wast_path);
+    let mut store = config.store();
+
+    let source = {
+        let mut out = String::new();
+        let mut f = File::open(wast_path)?;
+        f.read_to_string(&mut out)?;
+        out
+    };
+    let tokens = WasiTest::lex_string(&source)?;
+    let wasi_test = WasiTest::parse_tokens(&tokens)?;
+
+    let succeeded = wasi_test.run(&mut store, base_dir, filesystem_kind)?;
+
+    assert!(succeeded);
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/bash.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/bash.wasmu
new file mode 100644
index 0000000..f42497b
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/bash.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/cowsay.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/cowsay.wasmu
new file mode 100644
index 0000000..2610632
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/cowsay.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/python-3.11.3.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/python-3.11.3.wasmu
new file mode 100644
index 0000000..970ea31
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/linux/python-3.11.3.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/bash.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/bash.wasmu
new file mode 100644
index 0000000..9005b87
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/bash.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/cowsay.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/cowsay.wasmu
new file mode 100644
index 0000000..dc444bc
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/cowsay.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/python-3.11.3.wasmu b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/python-3.11.3.wasmu
new file mode 100644
index 0000000..191322d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/compilers/wasmu/windows/python-3.11.3.wasmu differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/compilers/wast.rs b/arbitrator/tools/module_roots/wasmer/tests/compilers/wast.rs
new file mode 100644
index 0000000..f79ceac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/compilers/wast.rs
@@ -0,0 +1,75 @@
+use ::wasmer::sys::Features;
+use std::path::Path;
+use wasmer_wast::Wast;
+
+// The generated tests (from build.rs) look like:
+// #[cfg(test)]
+// mod [compiler] {
+//     mod [spec] {
+//         mod [vfs] {
+//             #[test]
+//             fn [test_name]() -> anyhow::Result<()> {
+//                 crate::run_wasi("tests/spectests/[test_name].wast", "[compiler]", WasiFileSystemKind::[vfs])
+//             }
+//         }
+//     }
+// }
+include!(concat!(env!("OUT_DIR"), "/generated_spectests.rs"));
+
+pub fn run_wast(mut config: crate::Config, wast_path: &str) -> anyhow::Result<()> {
+    println!("Running wast `{}`", wast_path);
+    let try_nan_canonicalization = wast_path.contains("nan-canonicalization");
+    let mut features = Features::default();
+    let is_bulkmemory = wast_path.contains("bulk-memory");
+    let is_simd = wast_path.contains("simd");
+    let is_threads = wast_path.contains("threads");
+    if is_bulkmemory {
+        features.bulk_memory(true);
+    }
+    if is_simd {
+        features.simd(true);
+    }
+    if is_threads {
+        features.threads(true);
+    }
+    if config.compiler == crate::Compiler::Singlepass {
+        features.multi_value(false);
+    }
+    config.set_features(features);
+    config.set_nan_canonicalization(try_nan_canonicalization);
+
+    let store = config.store();
+    let mut wast = Wast::new_with_spectest(store);
+    // `bulk-memory-operations/bulk.wast` checks for a message that
+    // specifies which element is uninitialized, but our traps don't
+    // shepherd that information out.
+    wast.allow_trap_message("uninitialized element 2", "uninitialized element");
+    // `liking.wast` has different wording but the same meaning
+    wast.allow_trap_message("out of bounds memory access", "memory out of bounds");
+    if cfg!(feature = "coverage") {
+        wast.disable_assert_and_exhaustion();
+    }
+    if is_simd {
+        // We allow this, so tests can be run properly for `simd_const` test.
+        wast.allow_instantiation_failures(&[
+            "Validation error: multiple tables",
+            "Validation error: unknown memory 0",
+            "Validation error: Invalid var_u32",
+        ]);
+    }
+    if is_threads {
+        // We allow this, so tests can be run properly for `simd_const` test.
+        wast.allow_instantiation_failures(&["Validation error: multiple tables"]);
+    }
+    if config.compiler == crate::Compiler::Singlepass {
+        // We don't support multivalue yet in singlepass
+        wast.allow_instantiation_failures(&[
+            "Validation error: invalid result arity: func type returns multiple values",
+            "Validation error: blocks, loops, and ifs may only produce a resulttype when multi-value is not enabled",
+            "Validation error: func type returns multiple values but the multi-value feature is not enabled",
+        ]);
+    }
+    wast.fail_fast = false;
+    let path = Path::new(wast_path);
+    wast.run_file(path)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/deprecated.rs b/arbitrator/tools/module_roots/wasmer/tests/deprecated.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/deprecated.rs
@@ -0,0 +1 @@
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/deprecated/README.md b/arbitrator/tools/module_roots/wasmer/tests/deprecated/README.md
new file mode 100644
index 0000000..8ee7575
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/deprecated/README.md
@@ -0,0 +1,11 @@
+# Tests: Deprecated
+
+In this folder we will test deprecated APIs to verify that they
+still work the way it should, so users of Wasmer are happy while
+transitioning to newer APIs.
+
+As time passes and adoption of new APIs rises, tests on this folder
+should start tending towards 0.
+
+Therefore, deprecated tests are intended to be deleted on the long
+term.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/add.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/add.wat
new file mode 100644
index 0000000..a544516
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/add.wat
@@ -0,0 +1,3 @@
+(module
+  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y)))
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/call_indirect.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/call_indirect.wat
new file mode 100644
index 0000000..613b5bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/call_indirect.wat
@@ -0,0 +1,30 @@
+(module
+ (type $multiply_signature (func (param i32 i32) (result i32)))
+ (table 1 1 anyfunc)
+ (elem (i32.const 0) $multiply)
+ (memory $0 1)
+ (export "memory" (memory $0))
+ (export "dispatch" (func $dispatch))
+ (export "multiply" (func $multiply))
+ (export "main" (func $main))
+ (func $dispatch (; 0 ;) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+  (call_indirect (type $multiply_signature)
+   (get_local $1)
+   (get_local $2)
+   (get_local $0)
+  )
+ )
+ (func $multiply (; 1 ;) (type $multiply_signature) (param $0 i32) (param $1 i32) (result i32)
+  (i32.mul
+   (get_local $1)
+   (get_local $0)
+  )
+ )
+ (func $main (; 2 ;) (result i32)
+  (call $dispatch
+   (i32.const 0)
+   (i32.const 20)
+   (i32.const 30)
+  )
+ )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/fac.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/fac.wat
new file mode 100644
index 0000000..4de9c0f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/fac.wat
@@ -0,0 +1,82 @@
+(module
+  ;; Recursive factorial
+  (func (export "fac-rec") (param i64) (result i64)
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
+      )
+    )
+  )
+
+  ;; Recursive factorial named
+  (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
+    (if (result i64) (i64.eq (local.get $n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get $n)
+          (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  ;; Iterative factorial
+  (func (export "fac-iter") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
+    (block
+      (loop
+        (if
+          (i64.eq (local.get 1) (i64.const 0))
+          (then (br 2))
+          (else
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
+          )
+        )
+        (br 0)
+      )
+    )
+    (local.get 2)
+  )
+
+  ;; Iterative factorial named
+  (func (export "fac-iter-named") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (if
+          (i64.eq (local.get $i) (i64.const 0))
+          (then (br $done))
+          (else
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  ;; Optimized factorial.
+  (func (export "fac-opt") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+      (loop
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/fib.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/fib.wat
new file mode 100644
index 0000000..c23fbb6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/fib.wat
@@ -0,0 +1,20 @@
+(module
+    (func $main (result i32)
+        (call $fib (i32.const 40))
+    )
+
+    (func $fib (param $n i32) (result i32)
+        (if (i32.eq (get_local $n) (i32.const 0))
+            (then (return (i32.const 1)))
+        )
+        (if (i32.eq (get_local $n) (i32.const 1))
+            (then (return (i32.const 1)))
+        )
+        (i32.add
+            (call $fib (i32.sub (get_local $n) (i32.const 1)))
+            (call $fib (i32.sub (get_local $n) (i32.const 2)))
+        )
+    )
+
+    (export "_start" (func $main))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/global.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/global.wat
new file mode 100644
index 0000000..9260ed7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/global.wat
@@ -0,0 +1,8 @@
+(module
+    (global $xxx (mut i32) (i32.const 42))
+    (func $main (result i32)
+        (global.set $xxx (i32.const 0))
+        (i32.const 1)
+    )
+    (export "_start" (func $main))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/invalid.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/invalid.wat
new file mode 100644
index 0000000..866bbe1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/invalid.wat
@@ -0,0 +1,5 @@
+(module
+  (func (export "sqrt") (param f32) (result f32)
+    f32.sqrt
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/memory.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/memory.wat
new file mode 100755
index 0000000..09c3685
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/memory.wat
@@ -0,0 +1,42 @@
+(module
+    (memory 1)
+    (table 20 anyfunc)
+    (elem (i32.const 9) $f)
+    (func $f (param i32) (result i32)
+        (get_local 0)
+    )
+    (func $main (export "main") (result i32)
+        (local i32)
+        (set_local 0 (i32.const 100))
+        (i32.store (get_local 0) (i32.const 1602))
+        (i32.load (get_local 0))
+
+        (drop)
+        (memory.grow (i32.const 0))
+
+        (drop)
+        (memory.grow (i32.const 2))
+
+        (drop)
+        (memory.grow (i32.const 65536))
+        
+        (drop)
+        (memory.grow (i32.const 12))
+    )
+
+
+    (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (local.get $i))))
+    (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (local.get $i))))
+    (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (local.get $i))))
+    (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (local.get $i))))
+    (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (local.get $i))))
+    (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (local.get $i))))
+    (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (local.get $i))))
+    (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (local.get $i))))
+    (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (local.get $i))))
+    (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (local.get $i))))
+    (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (local.get $i))))
+    (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (local.get $i))))
+    (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (local.get $i))))
+    (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (local.get $i))))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/no_start.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/no_start.wat
new file mode 100644
index 0000000..b6e7ee1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/no_start.wat
@@ -0,0 +1,5 @@
+(module
+  (type (;0;) (func (param f64) (result i32)))
+  (func (;0;) (type 0) (param f64) (result i32)
+    unreachable))
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/test.py b/arbitrator/tools/module_roots/wasmer/tests/examples/test.py
new file mode 100644
index 0000000..ce47b77
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/test.py
@@ -0,0 +1 @@
+print("hello")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/examples/trap.wat b/arbitrator/tools/module_roots/wasmer/tests/examples/trap.wat
new file mode 100644
index 0000000..9210cfa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/examples/trap.wat
@@ -0,0 +1,5 @@
+(module
+    (func $main (export "_start") (result i32)
+        (i32.div_s (i32.const 0) (i32.const 0))
+    )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/ignores.txt b/arbitrator/tools/module_roots/wasmer/tests/ignores.txt
new file mode 100644
index 0000000..d32e3e1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/ignores.txt
@@ -0,0 +1,345 @@
+# Compilers
+singlepass spec::simd # Singlepass doesn't support yet SIMD (no one asked for this feature)
+
+# Traps
+## Traps. Tracing doesn't work properly in Singlepass
+## Unwinding is not properly implemented in Singlepass
+# Needs investigation
+singlepass+aarch64+macos traps::test_trap_trace
+cranelift+aarch64+macos    traps::test_trap_trace
+llvm+aarch64    traps::test_trap_trace
+llvm+riscv64    traps::test_trap_trace
+singlepass+aarch64+macos traps::test_trap_stack_overflow # Need to investigate
+singlepass+aarch64+macos traps::trap_display_pretty
+llvm       traps::trap_display_pretty
+windows    trap_display_pretty
+cranelift+aarch64+macos    traps::trap_display_pretty
+singlepass+aarch64+macos traps::trap_display_multi_module
+llvm       traps::trap_display_multi_module
+cranelift+aarch64+macos    traps::trap_display_multi_module
+windows+singlepass   traps::trap_display_multi_module
+singlepass traps::call_signature_mismatch   # Need to investigate, get foo (a[0]:0x33) instead of 0x30 for inderect call
+llvm       traps::call_signature_mismatch
+macos+aarch64    traps::call_signature_mismatch
+singlepass+aarch64+macos traps::start_trap_pretty
+llvm       traps::start_trap_pretty
+cranelift+aarch64+macos    traps::start_trap_pretty
+
+# LLVM currently doesn't implement stack probing on AArch64, RISC-V.
+# https://github.com/wasmerio/wasmer/issues/2808
+llvm+aarch64      spec::skip_stack_guard_page
+llvm+riscv64      spec::skip_stack_guard_page
+
+# riscv support is still early, function call ABI needs some work
+llvm+riscv64      static_function::llvm::universal
+llvm+riscv64      static_function_with_env::llvm::universal
+llvm+riscv64      static_function_with_results::llvm::universal
+llvm+riscv64      spec::f32::llvm::universal
+llvm+riscv64      spec::f64::llvm::universal
+llvm+riscv64      spec::float_misc::llvm::universal
+llvm+riscv64      spec::memory_copy::llvm::universal
+llvm+riscv64      spec::memory_init::llvm::universal
+llvm+riscv64      spec::memory_trap::llvm::universal
+llvm+riscv64      spec::multi_value::binary::llvm::universal
+llvm+riscv64      spec::multi_value::block::llvm::universal
+llvm+riscv64      spec::simd::simd_align::llvm::universal
+llvm+riscv64      spec::simd::simd_f32x4_rounding::llvm::universal
+llvm+riscv64      spec::simd::simd_f64x2_rounding::llvm::universal
+llvm+riscv64      wasmer::nan_canonicalization::llvm::universal
+llvm+riscv64      wasmer::stack_overflow_sret::llvm::universal
+# riscv support on Cranelift is also very young
+cranelift+riscv64 spec::align::cranelift::universal
+cranelift+riscv64 spec::memory_copy::cranelift::universal
+cranelift+riscv64 spec::memory_trap::cranelift::universal
+cranelift+riscv64 spec::r#if::cranelift::universal
+
+# no SIMD on riscv, Cranelift will not handle them
+cranelift+riscv64 spec::simd
+
+# Windows doesn't overcommit and fails to allocate 4GB of memory
+windows wasmer::max_size_of_memory
+
+# Some AARCH64 CPU have issue with segfault writin 64bits on border page, where the 1 32bits might be written.
+aarch64+linux spec::align
+aarch64+linux spec::memory_trap
+
+# Frontends
+
+## WASI
+
+### These tests don't pass due to race conditions in the new way we run tests.
+### It's not built to be run in parallel with itself, so we disable it for now.
+
+wasitests::snapshot1::host_fs::writing
+wasitests::unstable::host_fs::writing
+wasitests::snapshot1::mem_fs::writing
+wasitests::unstable::mem_fs::writing
+
+### due to hard-coded direct calls into WASI for wasi unstable
+
+wasitests::snapshot1::host_fs::fd_read
+wasitests::snapshot1::host_fs::poll_oneoff
+wasitests::snapshot1::host_fs::fd_pread
+wasitests::snapshot1::host_fs::fd_close
+wasitests::snapshot1::host_fs::fd_allocate
+wasitests::snapshot1::host_fs::close_preopen_fd
+wasitests::snapshot1::host_fs::envvar
+wasitests::snapshot1::mem_fs::fd_read
+wasitests::snapshot1::mem_fs::poll_oneoff
+wasitests::snapshot1::mem_fs::fd_pread
+wasitests::snapshot1::mem_fs::fd_close
+wasitests::snapshot1::mem_fs::fd_allocate
+wasitests::snapshot1::mem_fs::close_preopen_fd
+wasitests::snapshot1::mem_fs::envvar
+
+### TODO: resolve the disabled tests below. These are newly disabled tests from the migration:
+
+### due to git clone not preserving symlinks:
+wasitests::snapshot1::host_fs::readlink
+wasitests::unstable::host_fs::readlink
+wasitests::snapshot1::mem_fs::readlink
+wasitests::unstable::mem_fs::readlink
+
+### failing due to `remove_dir_all`. this test is also bad for parallelism
+wasitests::snapshot1::host_fs::create_dir
+wasitests::unstable::host_fs::create_dir
+wasitests::snapshot1::mem_fs::create_dir
+wasitests::unstable::mem_fs::create_dir
+
+### failing because it closes `stdout` which breaks our testing system
+wasitests::unstable::host_fs::fd_close
+wasitests::unstable::mem_fs::fd_close
+
+### failing because we're operating on stdout which is now overridden.
+### TODO: check WasiFile implementation
+### Alterative: split test into 2 parts, one printing to stderr, the other printing to stdout to test the real versions
+wasitests::unstable::host_fs::poll_oneoff
+wasitests::unstable::mem_fs::poll_oneoff
+
+### randomly failed, mainly on windows but also on macos, due to a race condition when concurently testing multiple compiler / engines
+wasitests::snapshot1::host_fs::fd_rename_path
+
+# This tests are disabled for now
+wasitests::unstable::host_fs::unix_open_special_files
+wasitests::snapshot1::host_fs::unix_open_special_files
+wasitests::unstable::mem_fs::unix_open_special_files
+wasitests::snapshot1::mem_fs::unix_open_special_files
+
+# These tests are all tests that are disabled for unstable + snapshot1,
+# so they are also disabled for nightly
+wasitests::nightly_2022_10_18::host_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::host_fs::create_dir
+wasitests::nightly_2022_10_18::host_fs::envvar
+wasitests::nightly_2022_10_18::host_fs::fd_allocate
+wasitests::nightly_2022_10_18::host_fs::fd_close
+wasitests::nightly_2022_10_18::host_fs::fd_pread
+wasitests::nightly_2022_10_18::host_fs::fd_read
+wasitests::nightly_2022_10_18::host_fs::fd_rename_path
+wasitests::nightly_2022_10_18::host_fs::poll_oneoff
+wasitests::nightly_2022_10_18::host_fs::readlink
+wasitests::nightly_2022_10_18::host_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::host_fs::writing
+
+wasitests::nightly_2022_10_18::mem_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::mem_fs::create_dir
+wasitests::nightly_2022_10_18::mem_fs::envvar
+wasitests::nightly_2022_10_18::mem_fs::fd_allocate
+wasitests::nightly_2022_10_18::mem_fs::fd_close
+wasitests::nightly_2022_10_18::mem_fs::fd_pread
+wasitests::nightly_2022_10_18::mem_fs::fd_read
+wasitests::nightly_2022_10_18::mem_fs::poll_oneoff
+wasitests::nightly_2022_10_18::mem_fs::readlink
+wasitests::nightly_2022_10_18::mem_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::mem_fs::writing
+
+wasitests::snapshot1::tmp_fs::close_preopen_fd
+wasitests::snapshot1::tmp_fs::create_dir
+wasitests::snapshot1::tmp_fs::envvar
+wasitests::snapshot1::tmp_fs::fd_allocate
+wasitests::snapshot1::tmp_fs::fd_close
+wasitests::snapshot1::tmp_fs::fd_pread
+wasitests::snapshot1::tmp_fs::fd_read
+wasitests::snapshot1::tmp_fs::poll_oneoff
+wasitests::snapshot1::tmp_fs::readlink
+wasitests::snapshot1::tmp_fs::unix_open_special_files
+wasitests::snapshot1::tmp_fs::writing
+wasitests::unstable::tmp_fs::close_preopen_fd
+wasitests::unstable::tmp_fs::create_dir
+wasitests::unstable::tmp_fs::envvar
+wasitests::unstable::tmp_fs::fd_allocate
+wasitests::unstable::tmp_fs::fd_close
+wasitests::unstable::tmp_fs::fd_pread
+wasitests::unstable::tmp_fs::fd_read
+wasitests::unstable::tmp_fs::poll_oneoff
+wasitests::unstable::tmp_fs::readlink
+wasitests::unstable::tmp_fs::unix_open_special_files
+wasitests::unstable::tmp_fs::writing
+wasitests::nightly_2022_10_18::tmp_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::tmp_fs::create_dir
+wasitests::nightly_2022_10_18::tmp_fs::envvar
+wasitests::nightly_2022_10_18::tmp_fs::fd_allocate
+wasitests::nightly_2022_10_18::tmp_fs::fd_close
+wasitests::nightly_2022_10_18::tmp_fs::fd_pread
+wasitests::nightly_2022_10_18::tmp_fs::fd_read
+wasitests::nightly_2022_10_18::tmp_fs::poll_oneoff
+wasitests::nightly_2022_10_18::tmp_fs::readlink
+wasitests::nightly_2022_10_18::tmp_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::tmp_fs::writing
+
+wasitests::snapshot1::passthru_fs::close_preopen_fd
+wasitests::snapshot1::passthru_fs::create_dir
+wasitests::snapshot1::passthru_fs::envvar
+wasitests::snapshot1::passthru_fs::fd_allocate
+wasitests::snapshot1::passthru_fs::fd_close
+wasitests::snapshot1::passthru_fs::fd_pread
+wasitests::snapshot1::passthru_fs::fd_read
+wasitests::snapshot1::passthru_fs::poll_oneoff
+wasitests::snapshot1::passthru_fs::readlink
+wasitests::snapshot1::passthru_fs::unix_open_special_files
+wasitests::snapshot1::passthru_fs::writing
+wasitests::unstable::passthru_fs::close_preopen_fd
+wasitests::unstable::passthru_fs::create_dir
+wasitests::unstable::passthru_fs::envvar
+wasitests::unstable::passthru_fs::fd_allocate
+wasitests::unstable::passthru_fs::fd_close
+wasitests::unstable::passthru_fs::fd_pread
+wasitests::unstable::passthru_fs::fd_read
+wasitests::unstable::passthru_fs::poll_oneoff
+wasitests::unstable::passthru_fs::readlink
+wasitests::unstable::passthru_fs::unix_open_special_files
+wasitests::unstable::passthru_fs::writing
+wasitests::nightly_2022_10_18::passthru_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::passthru_fs::create_dir
+wasitests::nightly_2022_10_18::passthru_fs::envvar
+wasitests::nightly_2022_10_18::passthru_fs::fd_allocate
+wasitests::nightly_2022_10_18::passthru_fs::fd_close
+wasitests::nightly_2022_10_18::passthru_fs::fd_pread
+wasitests::nightly_2022_10_18::passthru_fs::fd_read
+wasitests::nightly_2022_10_18::passthru_fs::poll_oneoff
+wasitests::nightly_2022_10_18::passthru_fs::readlink
+wasitests::nightly_2022_10_18::passthru_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::passthru_fs::writing
+
+wasitests::snapshot1::tmp_fs::close_preopen_fd
+wasitests::snapshot1::tmp_fs::create_dir
+wasitests::snapshot1::tmp_fs::envvar
+wasitests::snapshot1::tmp_fs::fd_allocate
+wasitests::snapshot1::tmp_fs::fd_close
+wasitests::snapshot1::tmp_fs::fd_pread
+wasitests::snapshot1::tmp_fs::fd_read
+wasitests::snapshot1::tmp_fs::poll_oneoff
+wasitests::snapshot1::tmp_fs::readlink
+wasitests::snapshot1::tmp_fs::unix_open_special_files
+wasitests::snapshot1::tmp_fs::writing
+wasitests::unstable::tmp_fs::close_preopen_fd
+wasitests::unstable::tmp_fs::create_dir
+wasitests::unstable::tmp_fs::envvar
+wasitests::unstable::tmp_fs::fd_allocate
+wasitests::unstable::tmp_fs::fd_close
+wasitests::unstable::tmp_fs::fd_pread
+wasitests::unstable::tmp_fs::fd_read
+wasitests::unstable::tmp_fs::poll_oneoff
+wasitests::unstable::tmp_fs::readlink
+wasitests::unstable::tmp_fs::unix_open_special_files
+wasitests::unstable::tmp_fs::writing
+wasitests::nightly_2022_10_18::tmp_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::tmp_fs::create_dir
+wasitests::nightly_2022_10_18::tmp_fs::envvar
+wasitests::nightly_2022_10_18::tmp_fs::fd_allocate
+wasitests::nightly_2022_10_18::tmp_fs::fd_close
+wasitests::nightly_2022_10_18::tmp_fs::fd_pread
+wasitests::nightly_2022_10_18::tmp_fs::fd_read
+wasitests::nightly_2022_10_18::tmp_fs::poll_oneoff
+wasitests::nightly_2022_10_18::tmp_fs::readlink
+wasitests::nightly_2022_10_18::tmp_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::tmp_fs::writing
+
+wasitests::snapshot1::union_fs::close_preopen_fd
+wasitests::snapshot1::union_fs::create_dir
+wasitests::snapshot1::union_fs::envvar
+wasitests::snapshot1::union_fs::fd_allocate
+wasitests::snapshot1::union_fs::fd_close
+wasitests::snapshot1::union_fs::fd_pread
+wasitests::snapshot1::union_fs::fd_read
+wasitests::snapshot1::union_fs::poll_oneoff
+wasitests::snapshot1::union_fs::readlink
+wasitests::snapshot1::union_fs::unix_open_special_files
+wasitests::snapshot1::union_fs::writing
+wasitests::unstable::union_fs::close_preopen_fd
+wasitests::unstable::union_fs::create_dir
+wasitests::unstable::union_fs::envvar
+wasitests::unstable::union_fs::fd_allocate
+wasitests::unstable::union_fs::fd_close
+wasitests::unstable::union_fs::fd_pread
+wasitests::unstable::union_fs::fd_read
+wasitests::unstable::union_fs::poll_oneoff
+wasitests::unstable::union_fs::readlink
+wasitests::unstable::union_fs::unix_open_special_files
+wasitests::unstable::union_fs::writing
+wasitests::nightly_2022_10_18::union_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::union_fs::create_dir
+wasitests::nightly_2022_10_18::union_fs::envvar
+wasitests::nightly_2022_10_18::union_fs::fd_allocate
+wasitests::nightly_2022_10_18::union_fs::fd_close
+wasitests::nightly_2022_10_18::union_fs::fd_pread
+wasitests::nightly_2022_10_18::union_fs::fd_read
+wasitests::nightly_2022_10_18::union_fs::poll_oneoff
+wasitests::nightly_2022_10_18::union_fs::readlink
+wasitests::nightly_2022_10_18::union_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::union_fs::writing
+
+wasitests::snapshot1::root_fs::close_preopen_fd
+wasitests::snapshot1::root_fs::create_dir
+wasitests::snapshot1::root_fs::envvar
+wasitests::snapshot1::root_fs::fd_allocate
+wasitests::snapshot1::root_fs::fd_close
+wasitests::snapshot1::root_fs::fd_pread
+wasitests::snapshot1::root_fs::fd_read
+wasitests::snapshot1::root_fs::poll_oneoff
+wasitests::snapshot1::root_fs::readlink
+wasitests::snapshot1::root_fs::unix_open_special_files
+wasitests::snapshot1::root_fs::writing
+wasitests::unstable::root_fs::close_preopen_fd
+wasitests::unstable::root_fs::create_dir
+wasitests::unstable::root_fs::envvar
+wasitests::unstable::root_fs::fd_allocate
+wasitests::unstable::root_fs::fd_close
+wasitests::unstable::root_fs::fd_pread
+wasitests::unstable::root_fs::fd_read
+wasitests::unstable::root_fs::poll_oneoff
+wasitests::unstable::root_fs::readlink
+wasitests::unstable::root_fs::unix_open_special_files
+wasitests::unstable::root_fs::writing
+wasitests::nightly_2022_10_18::root_fs::close_preopen_fd
+wasitests::nightly_2022_10_18::root_fs::create_dir
+wasitests::nightly_2022_10_18::root_fs::envvar
+wasitests::nightly_2022_10_18::root_fs::fd_allocate
+wasitests::nightly_2022_10_18::root_fs::fd_close
+wasitests::nightly_2022_10_18::root_fs::fd_pread
+wasitests::nightly_2022_10_18::root_fs::fd_read
+wasitests::nightly_2022_10_18::root_fs::poll_oneoff
+wasitests::nightly_2022_10_18::root_fs::readlink
+wasitests::nightly_2022_10_18::root_fs::unix_open_special_files
+wasitests::nightly_2022_10_18::root_fs::writing
+
+# These tests are failing in CI for some reason, but didn't fail on older compiler versions
+wasitests::nightly_2022_10_18::passthru_fs::path_symlink
+wasitests::nightly_2022_10_18::root_fs::path_symlink
+wasitests::nightly_2022_10_18::tmp_fs::path_symlink
+wasitests::nightly_2022_10_18::union_fs::path_symlink
+wasitests::nightly_2022_10_18::mem_fs::path_symlink
+wasitests::nightly_2022_10_18::host_fs::path_symlink
+
+wasitests::nightly_2022_10_18::mem_fs::fd_append
+wasitests::nightly_2022_10_18::host_fs::fd_append
+wasitests::nightly_2022_10_18::passthru_fs::fd_append
+wasitests::nightly_2022_10_18::root_fs::fd_append
+wasitests::nightly_2022_10_18::tmp_fs::fd_append
+wasitests::nightly_2022_10_18::union_fs::fd_append
+
+# FIXME: Those tests seems to fails on CI, but can't rproduce the issue on local Windows
+windows     wasitests::snapshot1::host_fs::path_rename
+windows     wasitests::nightly_2022_10_18::host_fs::path_rename
+
+# FIXME - re-enable once the path resolution failures in WasiFs have been worked out
+path_rename
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/README.md b/arbitrator/tools/module_roots/wasmer/tests/integration/README.md
new file mode 100644
index 0000000..8883946
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/README.md
@@ -0,0 +1,38 @@
+# Wasmer Integration tests
+
+All Wasmer end to end integration tests live here.
+We have different kind of integration tests:
+
+## CLI Integration tests
+
+This tests check that the `wasmer` CLI works as it should when running it
+as a Command in a shell, for each of the supported compilers.
+
+### Snapshot Tests
+
+A snapshot test suite is located at `./cli/tests/snapshot.rs`.
+
+The file contains tests that run various Webassembly files through `wasmer run`.
+The output is stored as snapshots in the repository.
+
+The [insta](https://github.com/mitsuhiko/insta) crate is used for snapshots.
+
+#### Working With Snapshots
+
+* Install the cargo-insta CLI
+  `cargo install cargo-insta`
+* Update snapshots:
+  ```
+  cd ./cli/
+  cargo insta test --review -- snapshot
+  ```
+
+## C Integration tests
+
+This tests verify that Wasmer wasm-c-api tests are passing for each of the
+supported compilers.
+
+## Rust Integration tests
+
+This tests verify that the `wasmer` API fulfill the required API that
+external users use.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/Cargo.toml
new file mode 100644
index 0000000..114d4a4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "wasmer-integration-tests-cli"
+version = "4.2.8"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+description = "CLI integration tests"
+repository = "https://github.com/wasmerio/wasmer"
+edition = "2021"
+publish = false
+
+[dev-dependencies]
+rand = "0.8.5"
+target-lexicon = "0.12.4"
+serde = { version = "1.0.147", features = ["derive"] }
+insta = { version = "1.21.1", features = ["json"] }
+md5 = "0.7.0"
+hex = "0.4.3"
+pretty_assertions = "1.3.0"
+object = "0.30.0"
+reqwest = { version = "0.11.14", default-features = false, features = ["json", "blocking", "rustls-tls"] }
+tokio = { version = "1", features = [ "rt", "rt-multi-thread", "macros" ] }
+assert_cmd = "2.0.8"
+predicates = "2.1.5"
+once_cell = "1.17.1"
+futures = "0.3.28"
+regex = "1.8.3"
+libc = "0.2.147"
+
+[dependencies]
+anyhow = "1"
+tempfile = "3.6.0"
+target-lexicon = "0.12.5"
+tar = "0.4.38"
+flate2 = "1.0.24"
+dirs = "4.0.0"
+derivative = { version = "^2" }
+wasmer-registry = { path = "../../../lib/registry", default-features = false }
+
+[features]
+default = ["webc_runner"]
+webc_runner = []
+debug = []
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/build.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/build.rs
new file mode 100644
index 0000000..9057ee2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/build.rs
@@ -0,0 +1,6 @@
+fn main() {
+    println!(
+        "cargo:rustc-env=CARGO_BUILD_TARGET={}",
+        std::env::var("TARGET").unwrap()
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/assets.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/assets.rs
new file mode 100644
index 0000000..f669263
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/assets.rs
@@ -0,0 +1,175 @@
+use std::path::PathBuf;
+use std::{env, path::Path};
+
+pub fn c_asset_path() -> &'static Path {
+    Path::new(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../../lib/c-api/examples/assets/"
+    ))
+}
+
+pub fn asset_path() -> &'static Path {
+    Path::new(concat!(
+        env!("CARGO_MANIFEST_DIR"),
+        "/../../../tests/examples/"
+    ))
+}
+
+pub fn wasmer_include_path() -> &'static Path {
+    Path::new(concat!(env!("CARGO_MANIFEST_DIR"), "/../../../lib/c-api/"))
+}
+
+pub fn wasmer_target_path() -> &'static Path {
+    let path = if cfg!(feature = "debug") {
+        concat!(env!("CARGO_MANIFEST_DIR"), "/../../../target/debug/")
+    } else {
+        concat!(env!("CARGO_MANIFEST_DIR"), "/../../../target/release/")
+    };
+    Path::new(path)
+}
+
+pub fn wasmer_target_path_2() -> &'static Path {
+    let path = if cfg!(feature = "debug") {
+        concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../../target/",
+            env!("CARGO_BUILD_TARGET"),
+            "/debug/"
+        )
+    } else {
+        concat!(
+            env!("CARGO_MANIFEST_DIR"),
+            "/../../../target/",
+            env!("CARGO_BUILD_TARGET"),
+            "/release/"
+        )
+    };
+    Path::new(path)
+}
+
+/* env var TARGET is set by tests/integration/cli/build.rs on compile-time */
+
+pub const LIBWASMER_FILENAME: &str = {
+    if cfg!(windows) {
+        "wasmer.lib"
+    } else {
+        "libwasmer.a"
+    }
+};
+
+/// Get the path to the `libwasmer.a` static library.
+pub fn get_libwasmer_path() -> PathBuf {
+    let mut ret = env::var("WASMER_TEST_LIBWASMER_PATH")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| wasmer_target_path().join(LIBWASMER_FILENAME));
+
+    if !ret.exists() {
+        ret = wasmer_target_path_2().join(LIBWASMER_FILENAME);
+    }
+    if !ret.exists() {
+        panic!("Could not find libwasmer path! {:?}", ret);
+    }
+    ret
+}
+
+/// Get the path to the `wasmer` executable to be used in this test.
+pub fn get_wasmer_path() -> PathBuf {
+    let mut ret = env::var("WASMER_TEST_WASMER_PATH")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| wasmer_target_path().join("wasmer"));
+
+    if !ret.exists() {
+        ret = wasmer_target_path_2().join("wasmer");
+    }
+    if !ret.exists() {
+        ret = match get_repo_root_path() {
+            Some(s) => {
+                let release_dir = s.join("target").join("release");
+
+                if cfg!(windows) {
+                    release_dir.join("wasmer.exe")
+                } else {
+                    release_dir.join("wasmer")
+                }
+            }
+            None => {
+                panic!("Could not find wasmer executable path! {:?}", ret);
+            }
+        };
+    }
+
+    if !ret.exists() {
+        ret = match get_repo_root_path() {
+            Some(s) => {
+                let executable = if cfg!(windows) {
+                    "wasmer.exe"
+                } else {
+                    "wasmer"
+                };
+                s.join("target")
+                    .join(target_lexicon::HOST.to_string())
+                    .join("release")
+                    .join(executable)
+            }
+            None => {
+                panic!("Could not find wasmer executable path! {:?}", ret);
+            }
+        };
+    }
+
+    if !ret.exists() {
+        if let Some(root) = get_repo_root_path() {
+            use std::process::Stdio;
+            let _ = std::process::Command::new("ls")
+                .arg(root.join("target"))
+                .stdout(Stdio::inherit())
+                .stderr(Stdio::inherit())
+                .stdin(Stdio::null())
+                .output();
+        }
+        panic!(
+            "cannot find wasmer / wasmer.exe for integration test at '{}'!",
+            ret.display()
+        );
+    }
+    ret
+}
+
+pub fn get_repo_root_path() -> Option<PathBuf> {
+    let mut current_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    let mut counter = 0;
+    let mut result = None;
+    'outer: while counter < 50 {
+        counter += 1;
+        if current_dir.join("CHANGELOG.md").exists() && current_dir.join("LICENSE").exists() {
+            result = Some(current_dir.to_path_buf());
+            break 'outer;
+        } else {
+            current_dir = current_dir.parent()?;
+        }
+    }
+    result
+}
+
+pub fn get_wasmer_dir() -> Result<PathBuf, anyhow::Error> {
+    if let Ok(s) = std::env::var("WASMER_DIR") {
+        Ok(Path::new(&s).to_path_buf())
+    } else if let Some(root_dir) = get_repo_root_path().and_then(|root| {
+        if root.join("package").exists() {
+            Some(root.join("package"))
+        } else {
+            None
+        }
+    }) {
+        Ok(root_dir)
+    } else {
+        let home_dir = dirs::home_dir()
+            .ok_or(anyhow::anyhow!("no home dir"))?
+            .join(".wasmer");
+        if home_dir.exists() {
+            Ok(home_dir)
+        } else {
+            Err(anyhow::anyhow!("no .wasmer home dir"))
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/fixtures.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/fixtures.rs
new file mode 100644
index 0000000..7f04785
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/fixtures.rs
@@ -0,0 +1,64 @@
+//! Paths for commonly used test files.
+
+use std::path::{Path, PathBuf};
+
+use crate::{asset_path, c_asset_path};
+
+/// A WEBC file containing the Python interpreter, compiled to WASI.
+pub fn python() -> PathBuf {
+    c_asset_path().join("python-0.1.0.wasmer")
+}
+
+/// A WEBC file containing the coreutils.
+pub fn coreutils() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("webc")
+        .join("coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc")
+}
+
+/// A WEBC file containing bash.
+pub fn bash() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("webc")
+        .join("bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc")
+}
+
+/// A WEBC file containing `wat2wasm`, `wasm-validate`, and other helpful
+/// WebAssembly-related commands.
+pub fn wabt() -> PathBuf {
+    c_asset_path().join("wabt-1.0.37.wasmer")
+}
+
+/// A WEBC file containing the WCGI static server.
+pub fn static_server() -> PathBuf {
+    c_asset_path().join("staticserver.webc")
+}
+
+/// The QuickJS interpreter, compiled to a WASI module.
+pub fn qjs() -> PathBuf {
+    c_asset_path().join("qjs.wasm")
+}
+
+pub fn hello() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("webc")
+        .join("hello-0.1.0-665d2ddc-80e6-4845-85d3-4587b1693bb7.webc")
+}
+
+/// The `wasmer.toml` file for QuickJS.
+pub fn qjs_wasmer_toml() -> PathBuf {
+    c_asset_path().join("qjs-wasmer.toml")
+}
+
+/// A `*.wat` file which calculates fib(40) and exits with no output.
+pub fn fib() -> PathBuf {
+    asset_path().join("fib.wat")
+}
+
+/// A `*.wat` file with no `_start()` function.
+pub fn wat_no_start() -> PathBuf {
+    asset_path().join("no_start.wat")
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/lib.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/lib.rs
new file mode 100644
index 0000000..2411acd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/lib.rs
@@ -0,0 +1,9 @@
+#![forbid(unsafe_code)]
+
+mod assets;
+pub mod fixtures;
+pub mod link_code;
+mod util;
+
+pub use assets::*;
+pub use util::*;
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/link_code.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/link_code.rs
new file mode 100644
index 0000000..0346dbc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/link_code.rs
@@ -0,0 +1,73 @@
+use crate::assets::*;
+use anyhow::bail;
+use std::path::PathBuf;
+use std::process::Command;
+
+/// Data used to run a linking command for generated artifacts.
+#[derive(Debug)]
+pub struct LinkCode {
+    /// The directory to operate in.
+    pub current_dir: PathBuf,
+    /// Path to the linker used to run the linking command.
+    pub linker_path: PathBuf,
+    /// String used as an optimization flag.
+    pub optimization_flag: String,
+    /// Paths of objects to link.
+    pub object_paths: Vec<PathBuf>,
+    /// Path to the output target.
+    pub output_path: PathBuf,
+    /// Path to the static libwasmer library.
+    pub libwasmer_path: PathBuf,
+}
+
+impl Default for LinkCode {
+    fn default() -> Self {
+        #[cfg(not(windows))]
+        let linker = "cc";
+        #[cfg(windows)]
+        let linker = "clang";
+        Self {
+            current_dir: std::env::current_dir().unwrap(),
+            linker_path: PathBuf::from(linker),
+            optimization_flag: String::from("-O2"),
+            object_paths: vec![],
+            output_path: PathBuf::from("a.out"),
+            libwasmer_path: get_libwasmer_path(),
+        }
+    }
+}
+
+impl LinkCode {
+    pub fn run(&self) -> anyhow::Result<()> {
+        let mut command = Command::new(&self.linker_path);
+        let command = command
+            .current_dir(&self.current_dir)
+            .arg(&self.optimization_flag)
+            .args(
+                self.object_paths
+                    .iter()
+                    .map(|path| path.canonicalize().unwrap()),
+            )
+            .arg(&self.libwasmer_path.canonicalize()?);
+        #[cfg(windows)]
+        let command = command
+            .arg("-luserenv")
+            .arg("-lWs2_32")
+            .arg("-ladvapi32")
+            .arg("-lbcrypt");
+        #[cfg(not(windows))]
+        let command = command.arg("-ldl").arg("-lm").arg("-pthread");
+        let output = command.arg("-o").arg(&self.output_path).output()?;
+
+        if !output.status.success() {
+            bail!(
+                "linking failed with: stdout: {}\n\nstderr: {}",
+                std::str::from_utf8(&output.stdout)
+                    .expect("stdout is not utf8! need to handle arbitrary bytes"),
+                std::str::from_utf8(&output.stderr)
+                    .expect("stderr is not utf8! need to handle arbitrary bytes")
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/util.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/util.rs
new file mode 100644
index 0000000..5fd4386
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/src/util.rs
@@ -0,0 +1,50 @@
+use anyhow::bail;
+use std::path::Path;
+use std::process::Command;
+
+#[derive(Debug, Copy, Clone)]
+pub enum Compiler {
+    Cranelift,
+    LLVM,
+    Singlepass,
+}
+
+impl Compiler {
+    pub const fn to_flag(self) -> &'static str {
+        match self {
+            Compiler::Cranelift => "--cranelift",
+            Compiler::LLVM => "--llvm",
+            Compiler::Singlepass => "--singlepass",
+        }
+    }
+}
+
+pub fn run_code(
+    operating_dir: &Path,
+    executable_path: &Path,
+    args: &[String],
+    stderr: bool,
+) -> anyhow::Result<String> {
+    let output = Command::new(executable_path.canonicalize()?)
+        .current_dir(operating_dir)
+        .args(args)
+        .output()?;
+
+    if !output.status.success() && !stderr {
+        bail!(
+            "running executable failed: stdout: {}\n\nstderr: {}",
+            std::str::from_utf8(&output.stdout)
+                .expect("stdout is not utf8! need to handle arbitrary bytes"),
+            std::str::from_utf8(&output.stderr)
+                .expect("stderr is not utf8! need to handle arbitrary bytes")
+        );
+    }
+    let output = std::str::from_utf8(if stderr {
+        &output.stderr
+    } else {
+        &output.stdout
+    })
+    .expect("output from running executable is not utf-8");
+
+    Ok(output.to_owned())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/config.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/config.rs
new file mode 100644
index 0000000..491ae4b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/config.rs
@@ -0,0 +1,360 @@
+use std::path::Path;
+
+use assert_cmd::Command;
+use predicates::str::contains;
+use tempfile::TempDir;
+use wasmer_integration_tests_cli::get_wasmer_path;
+use wasmer_registry::WasmerConfig;
+
+fn setup_wasmer_dir() -> TempDir {
+    let temp = TempDir::new().unwrap();
+
+    let config_path = WasmerConfig::get_file_location(temp.path());
+    WasmerConfig::default().save(&config_path).unwrap();
+
+    temp
+}
+
+fn contains_path(path: impl AsRef<Path>) -> predicates::str::ContainsPredicate {
+    let expected = path.as_ref().display().to_string();
+    contains(expected)
+}
+
+fn wasmer_cmd(temp: &TempDir) -> Command {
+    let mut cmd = Command::new(get_wasmer_path());
+    cmd.env("WASMER_DIR", temp.path());
+    cmd
+}
+
+#[test]
+fn wasmer_config_multiget() {
+    let temp = setup_wasmer_dir();
+    let wasmer_dir = temp.path();
+
+    let bin_path = wasmer_dir.join("bin");
+    let include_path = wasmer_dir.join("include");
+    let bin = bin_path.display().to_string();
+    let include = format!("-I{}", include_path.display());
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--bindir")
+        .arg("--cflags")
+        .env("WASMER_DIR", wasmer_dir)
+        .assert()
+        .success()
+        .stdout(contains(bin))
+        .stdout(contains(include));
+}
+
+#[test]
+fn wasmer_config_conflicting_flags() {
+    let temp = setup_wasmer_dir();
+
+    let expected_1 = if cfg!(windows) {
+        "Usage: wasmer.exe config --bindir --cflags"
+    } else {
+        "Usage: wasmer config --bindir --cflags"
+    };
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--bindir")
+        .arg("--cflags")
+        .arg("--pkg-config")
+        .assert()
+        .stderr(contains(
+            "error: the argument '--bindir' cannot be used with '--pkg-config'",
+        ))
+        .stderr(contains(expected_1))
+        .stderr(contains("For more information, try '--help'."));
+}
+
+#[test]
+fn c_flags() {
+    let temp = setup_wasmer_dir();
+    let wasmer_dir = temp.path();
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--bindir")
+        .assert()
+        .success()
+        .stdout(contains_path(temp.path().join("bin")));
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--cflags")
+        .assert()
+        .success()
+        .stdout(contains(format!(
+            "-I{}\n",
+            wasmer_dir.join("include").display()
+        )));
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--includedir")
+        .assert()
+        .success()
+        .stdout(contains_path(wasmer_dir.join("include")));
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--libdir")
+        .assert()
+        .success()
+        .stdout(contains_path(wasmer_dir.join("lib")));
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--libs")
+        .assert()
+        .stdout(contains(format!(
+            "-L{} -lwasmer\n",
+            wasmer_dir.join("lib").display()
+        )));
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--prefix")
+        .assert()
+        .success()
+        .stdout(contains_path(wasmer_dir));
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--pkg-config")
+        .output()
+        .unwrap();
+
+    let pkg_config = vec![
+        format!("prefix={}", wasmer_dir.display()),
+        format!("exec_prefix={}", wasmer_dir.join("bin").display()),
+        format!("includedir={}", wasmer_dir.join("include").display()),
+        format!("libdir={}", wasmer_dir.join("lib").display()),
+        format!(""),
+        format!("Name: wasmer"),
+        format!("Description: The Wasmer library for running WebAssembly"),
+        format!("Version: {}", env!("CARGO_PKG_VERSION")),
+        format!("Cflags: -I{}", wasmer_dir.join("include").display()),
+        format!("Libs: -L{} -lwasmer", wasmer_dir.join("lib").display()),
+    ]
+    .join("\n");
+
+    assert!(output.status.success());
+    let stderr = std::str::from_utf8(&output.stdout)
+        .unwrap()
+        .replace("\r\n", "\n");
+    assert_eq!(stderr.trim(), pkg_config.trim());
+
+    wasmer_cmd(&temp)
+        .arg("config")
+        .arg("--config-path")
+        .assert()
+        .success()
+        .stdout(contains_path(temp.path().join("wasmer.toml")));
+}
+
+#[test]
+fn get_and_set_config_fields() -> anyhow::Result<()> {
+    let temp = setup_wasmer_dir();
+
+    // ---- config get
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.token")
+        .output()?;
+
+    let original_token = String::from_utf8_lossy(&output.stdout);
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("registry.token")
+        .arg("abc123")
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.token")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        "abc123\n".to_string()
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("registry.token")
+        .arg(original_token.to_string().trim())
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.token")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        format!("{}\n", original_token.to_string().trim())
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.url")
+        .output()?;
+
+    let original_url = String::from_utf8_lossy(&output.stdout);
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("registry.url")
+        .arg("wasmer.wtf")
+        .output()?;
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+
+    assert_eq!(output_str, "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.url")
+        .output()?;
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+    assert_eq!(
+        output_str,
+        "https://registry.wasmer.wtf/graphql\n".to_string()
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("registry.url")
+        .arg(original_url.to_string().trim())
+        .output()?;
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+    assert_eq!(output_str, "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("registry.url")
+        .output()?;
+
+    let output_str = String::from_utf8_lossy(&output.stdout);
+    assert_eq!(output_str, original_url.to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("telemetry.enabled")
+        .output()?;
+
+    let original_output = String::from_utf8_lossy(&output.stdout);
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("telemetry.enabled")
+        .arg("true")
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("telemetry.enabled")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        "true\n".to_string()
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("telemetry.enabled")
+        .arg(original_output.to_string().trim())
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("telemetry.enabled")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        original_output.to_string()
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("update-notifications.enabled")
+        .output()?;
+
+    let original_output = String::from_utf8_lossy(&output.stdout);
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("update-notifications.enabled")
+        .arg("true")
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("update-notifications.enabled")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        "true\n".to_string()
+    );
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("set")
+        .arg("update-notifications.enabled")
+        .arg(original_output.to_string().trim())
+        .output()?;
+
+    assert_eq!(String::from_utf8_lossy(&output.stdout), "".to_string());
+
+    let output = wasmer_cmd(&temp)
+        .arg("config")
+        .arg("get")
+        .arg("update-notifications.enabled")
+        .output()?;
+
+    assert_eq!(
+        String::from_utf8_lossy(&output.stdout),
+        original_output.to_string()
+    );
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/create_exe.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/create_exe.rs
new file mode 100644
index 0000000..4511e34
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/create_exe.rs
@@ -0,0 +1,856 @@
+//! Tests of the `wasmer create-exe` command.
+
+use std::{
+    fs,
+    io::prelude::*,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use anyhow::{bail, Context};
+use assert_cmd::prelude::OutputAssertExt;
+use tempfile::TempDir;
+use wasmer_integration_tests_cli::*;
+
+const JS_TEST_SRC_CODE: &[u8] =
+    b"function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));\n";
+
+/// Data used to run the `wasmer compile` command.
+#[derive(Debug)]
+struct WasmerCreateExe {
+    /// The directory to operate in.
+    current_dir: PathBuf,
+    /// Path to wasmer executable used to run the command.
+    wasmer_path: PathBuf,
+    /// Path to the Wasm file to compile.
+    wasm_path: PathBuf,
+    /// Path to the native executable produced by compiling the Wasm.
+    native_executable_path: PathBuf,
+    /// Compiler with which to compile the Wasm.
+    compiler: Compiler,
+    /// Extra CLI flags
+    extra_cli_flags: Vec<String>,
+}
+
+impl Default for WasmerCreateExe {
+    fn default() -> Self {
+        #[cfg(not(windows))]
+        let native_executable_path = PathBuf::from("wasm.out");
+        #[cfg(windows)]
+        let native_executable_path = PathBuf::from("wasm.exe");
+        Self {
+            current_dir: std::env::current_dir().unwrap(),
+            wasmer_path: get_wasmer_path(),
+            wasm_path: PathBuf::from(fixtures::qjs()),
+            native_executable_path,
+            compiler: Compiler::Cranelift,
+            extra_cli_flags: vec![],
+        }
+    }
+}
+
+impl WasmerCreateExe {
+    fn run(&self) -> anyhow::Result<Vec<u8>> {
+        let mut output = Command::new(&self.wasmer_path);
+        output.current_dir(&self.current_dir);
+        output.arg("create-exe");
+        output.arg(&self.wasm_path.canonicalize()?);
+        output.arg(self.compiler.to_flag());
+        output.args(self.extra_cli_flags.iter());
+        output.arg("-o");
+        output.arg(&self.native_executable_path);
+        if !self.extra_cli_flags.contains(&"--target".to_string()) {
+            let tarball_path = get_repo_root_path().unwrap().join("link.tar.gz");
+            assert!(tarball_path.exists(), "link.tar.gz does not exist");
+            output.arg("--tarball");
+            output.arg(&tarball_path);
+        }
+        let cmd = format!("{:?}", output);
+
+        println!("(integration-test) running create-exe: {cmd}");
+
+        let output = output.output()?;
+
+        let stdout = std::str::from_utf8(&output.stdout)
+            .expect("stdout is not utf8! need to handle arbitrary bytes");
+
+        assert!(
+            stdout.contains("headless."),
+            "create-exe stdout should link with libwasmer-headless"
+        );
+
+        if !output.status.success() {
+            bail!(
+                "{cmd}\r\n failed with: stdout: {stdout}\n\nstderr: {}",
+                std::str::from_utf8(&output.stderr)
+                    .expect("stderr is not utf8! need to handle arbitrary bytes")
+            );
+        }
+        Ok(output.stdout)
+    }
+}
+
+/// Data used to run the `wasmer compile` command.
+#[derive(Debug)]
+struct WasmerCreateObj {
+    /// The directory to operate in.
+    current_dir: PathBuf,
+    /// Path to wasmer executable used to run the command.
+    wasmer_path: PathBuf,
+    /// Path to the Wasm file to compile.
+    wasm_path: PathBuf,
+    /// Path to the object file produced by compiling the Wasm.
+    output_object_path: PathBuf,
+    /// Compiler with which to compile the Wasm.
+    compiler: Compiler,
+    /// Extra CLI flags
+    extra_cli_flags: Vec<String>,
+}
+
+impl Default for WasmerCreateObj {
+    fn default() -> Self {
+        #[cfg(not(windows))]
+        let output_object_path = PathBuf::from("wasm.o");
+        #[cfg(windows)]
+        let output_object_path = PathBuf::from("wasm.obj");
+        Self {
+            current_dir: std::env::current_dir().unwrap(),
+            wasmer_path: get_wasmer_path(),
+            wasm_path: PathBuf::from(fixtures::qjs()),
+            output_object_path,
+            compiler: Compiler::Cranelift,
+            extra_cli_flags: vec![],
+        }
+    }
+}
+
+impl WasmerCreateObj {
+    fn run(&self) -> anyhow::Result<Vec<u8>> {
+        let mut output = Command::new(&self.wasmer_path);
+        output.current_dir(&self.current_dir);
+        output.arg("create-obj");
+        output.arg(&self.wasm_path.canonicalize()?);
+        output.arg(self.compiler.to_flag());
+        output.args(self.extra_cli_flags.iter());
+        output.arg("-o");
+        output.arg(&self.output_object_path);
+
+        let cmd = format!("{:?}", output);
+
+        println!("(integration-test) running create-obj: {cmd}");
+
+        let output = output.output()?;
+
+        if !output.status.success() {
+            bail!(
+                "{cmd}\r\n failed with: stdout: {}\n\nstderr: {}",
+                std::str::from_utf8(&output.stdout)
+                    .expect("stdout is not utf8! need to handle arbitrary bytes"),
+                std::str::from_utf8(&output.stderr)
+                    .expect("stderr is not utf8! need to handle arbitrary bytes")
+            );
+        }
+        Ok(output.stdout)
+    }
+}
+
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn test_create_exe_with_pirita_works_1() {
+    let tempdir = TempDir::new().unwrap();
+    let path = tempdir.path();
+    let wasm_out = path.join("out.obj");
+    let cmd = Command::new(get_wasmer_path())
+        .arg("create-obj")
+        .arg(fixtures::wabt())
+        .arg("-o")
+        .arg(&wasm_out)
+        .output()
+        .unwrap();
+
+    let stderr = String::from_utf8_lossy(&cmd.stderr);
+
+    assert_eq!(stderr.lines().map(|s| s.trim().to_string()).collect::<Vec<_>>(), vec![
+        format!("error: cannot compile more than one atom at a time"),
+        format!("│   1: note: use --atom <ATOM> to specify which atom to compile"),
+        format!("╰─▶ 2: where <ATOM> is one of: wabt, wasm-interp, wasm-strip, wasm-validate, wasm2wat, wast2json, wat2wasm"),
+    ]);
+
+    assert!(!cmd.status.success());
+
+    let cmd = Command::new(get_wasmer_path())
+        .arg("create-obj")
+        .arg(fixtures::wabt())
+        .arg("--atom")
+        .arg("wasm2wat")
+        .arg("-o")
+        .arg(&wasm_out)
+        .output()
+        .unwrap();
+
+    let stderr = String::from_utf8_lossy(&cmd.stderr);
+
+    let real_out = wasm_out.canonicalize().unwrap().display().to_string();
+    let real_out = real_out
+        .strip_prefix(r"\\?\")
+        .unwrap_or(&real_out)
+        .to_string();
+    assert_eq!(
+        stderr
+            .lines()
+            .map(|s| s.trim().to_string())
+            .collect::<Vec<_>>(),
+        vec![format!("✔ Object compiled successfully to `{real_out}`"),]
+    );
+
+    assert!(cmd.status.success());
+}
+
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn test_create_exe_with_precompiled_works_1() {
+    use object::{Object, ObjectSymbol};
+
+    let tempdir = TempDir::new().unwrap();
+    let path = tempdir.path();
+    let wasm_out = path.join("out.obj");
+    let _ = Command::new(get_wasmer_path())
+        .arg("create-obj")
+        .arg(fixtures::qjs())
+        .arg("--prefix")
+        .arg("sha123123")
+        .arg("-o")
+        .arg(&wasm_out)
+        .output()
+        .unwrap();
+
+    let file = std::fs::read(&wasm_out).unwrap();
+    let obj_file = object::File::parse(&*file).unwrap();
+    let names = obj_file
+        .symbols()
+        .filter_map(|s| Some(s.name().ok()?.to_string()))
+        .collect::<Vec<_>>();
+
+    assert!(
+        names.contains(&"_wasmer_function_sha123123_1".to_string())
+            || names.contains(&"wasmer_function_sha123123_1".to_string())
+    );
+
+    let _ = Command::new(get_wasmer_path())
+        .arg("create-obj")
+        .arg(fixtures::qjs())
+        .arg("-o")
+        .arg(&wasm_out)
+        .output()
+        .unwrap();
+
+    let file = std::fs::read(&wasm_out).unwrap();
+    let obj_file = object::File::parse(&*file).unwrap();
+    let names = obj_file
+        .symbols()
+        .filter_map(|s| Some(s.name().ok()?.to_string()))
+        .collect::<Vec<_>>();
+
+    assert!(
+        names.contains(
+            &"_wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_1"
+                .to_string()
+        ) || names.contains(
+            &"wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_1"
+                .to_string()
+        )
+    );
+}
+
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+// Also ignored on macOS because it's flaky
+#[cfg_attr(any(target_os = "windows", target_os = "macos"), ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_works() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::qjs());
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("wasm.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("wasm.exe");
+
+    WasmerCreateExe {
+        current_dir: operating_dir.clone(),
+        wasm_path,
+        native_executable_path: executable_path.clone(),
+        compiler: Compiler::Cranelift,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &["--eval".to_string(), "function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));".to_string()],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+
+    Ok(())
+}
+
+/// Tests that "-c" and "-- -c" are treated differently
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+// FIXME: Fix an re-enable test
+// See https://github.com/wasmerio/wasmer/issues/3615
+#[allow(dead_code)]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_works_multi_command_args_handling() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::wabt());
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("multicommand.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("multicommand.exe");
+
+    WasmerCreateExe {
+        current_dir: operating_dir.clone(),
+        wasm_path,
+        native_executable_path: executable_path.clone(),
+        compiler: Compiler::Cranelift,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &[
+            "--command".to_string(),
+            "wasm-strip".to_string(),
+            "--".to_string(),
+            "-c".to_string(),
+        ],
+        true,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(
+        result_lines,
+        vec![
+            "wasm-strip: unknown option '-c'",
+            "Try '--help' for more information.",
+            "WASI exited with code: 1"
+        ]
+    );
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &["-c".to_string(), "wasm-strip".to_string()],
+        true,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(
+        result_lines,
+        vec![
+            "wasm-strip: expected filename argument.",
+            "Try '--help' for more information.",
+            "WASI exited with code: 1"
+        ]
+    );
+
+    Ok(())
+}
+
+/// Tests that create-exe works with underscores and dashes in command names
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_works_underscore_module_name() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+    let wasm_path = operating_dir.join(fixtures::wabt());
+
+    let atoms = &[
+        "wabt",
+        "wasm-interp",
+        "wasm-strip",
+        "wasm-validate",
+        "wasm2wat",
+        "wast2json",
+        "wat2wasm",
+    ];
+
+    let mut create_exe_flags = Vec::new();
+
+    for a in atoms.iter() {
+        let object_path = operating_dir.as_path().join(&format!("{a}.o"));
+        let _output: Vec<u8> = WasmerCreateObj {
+            current_dir: operating_dir.clone(),
+            wasm_path: wasm_path.clone(),
+            output_object_path: object_path.clone(),
+            compiler: Compiler::Cranelift,
+            extra_cli_flags: vec!["--atom".to_string(), a.to_string()],
+            ..Default::default()
+        }
+        .run()
+        .context("Failed to create-obj wasm with Wasmer")?;
+
+        assert!(
+            object_path.exists(),
+            "create-obj successfully completed but object output file `{}` missing",
+            object_path.display()
+        );
+
+        create_exe_flags.push("--precompiled-atom".to_string());
+        create_exe_flags.push(format!(
+            "{a}:{}",
+            object_path.canonicalize().unwrap().display()
+        ));
+    }
+
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("multicommand.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("multicommand.exe");
+
+    WasmerCreateExe {
+        current_dir: operating_dir,
+        wasm_path,
+        native_executable_path: executable_path,
+        compiler: Compiler::Cranelift,
+        extra_cli_flags: create_exe_flags,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    Ok(())
+}
+
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_works_multi_command() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::wabt());
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("multicommand.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("multicommand.exe");
+
+    WasmerCreateExe {
+        current_dir: operating_dir.clone(),
+        wasm_path,
+        native_executable_path: executable_path.clone(),
+        compiler: Compiler::Cranelift,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &[
+            "--command".to_string(),
+            "wasm2wat".to_string(),
+            "--version".to_string(),
+        ],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["1.0.37 (git~v1.0.37)"]);
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &[
+            "-c".to_string(),
+            "wasm-validate".to_string(),
+            "--version".to_string(),
+        ],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["1.0.37 (git~v1.0.37)"]);
+
+    Ok(())
+}
+
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_works_with_file() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::qjs());
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("wasm.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("wasm.exe");
+
+    WasmerCreateExe {
+        current_dir: operating_dir.clone(),
+        wasm_path,
+        native_executable_path: executable_path.clone(),
+        compiler: Compiler::Cranelift,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    {
+        let mut f = fs::OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(operating_dir.join("test.js"))?;
+        f.write_all(JS_TEST_SRC_CODE)?;
+    }
+
+    // test with `--dir`
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &[
+            "--dir=.".to_string(),
+            "--script".to_string(),
+            "test.js".to_string(),
+        ],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+
+    // test with `--mapdir`
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &[
+            "--mapdir=abc:.".to_string(),
+            "--script".to_string(),
+            "abc/test.js".to_string(),
+        ],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+
+    Ok(())
+}
+
+fn create_obj(args: Vec<String>) -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.as_path().join(fixtures::qjs());
+
+    let object_path = operating_dir.as_path().join("wasm");
+    let _output: Vec<u8> = WasmerCreateObj {
+        current_dir: operating_dir,
+        wasm_path,
+        output_object_path: object_path.clone(),
+        compiler: Compiler::Cranelift,
+        extra_cli_flags: args,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-obj wasm with Wasmer")?;
+
+    assert!(
+        object_path.exists(),
+        "create-obj successfully completed but object output file `{}` missing",
+        object_path.display()
+    );
+
+    Ok(())
+}
+
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_obj_default() -> anyhow::Result<()> {
+    create_obj(vec![])
+}
+
+fn create_exe_with_object_input(args: Vec<String>) -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::qjs());
+
+    #[cfg(not(windows))]
+    let object_path = operating_dir.join("wasm.o");
+    #[cfg(windows)]
+    let object_path = operating_dir.join("wasm.obj");
+
+    let mut create_obj_args = args.clone();
+    create_obj_args.push("--prefix".to_string());
+    create_obj_args.push("abc123".to_string());
+    create_obj_args.push("--debug-dir".to_string());
+    create_obj_args.push(format!(
+        "{}",
+        operating_dir.join("compile-create-obj").display()
+    ));
+
+    WasmerCreateObj {
+        current_dir: operating_dir.clone(),
+        wasm_path: wasm_path.clone(),
+        output_object_path: object_path.clone(),
+        compiler: Compiler::Cranelift,
+        extra_cli_flags: create_obj_args,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-obj wasm with Wasmer")?;
+
+    assert!(
+        object_path.exists(),
+        "create-obj successfully completed but object output file `{}` missing",
+        object_path.display()
+    );
+
+    #[cfg(not(windows))]
+    let executable_path = operating_dir.join("wasm.out");
+    #[cfg(windows)]
+    let executable_path = operating_dir.join("wasm.exe");
+
+    let mut create_exe_args = args;
+    create_exe_args.push("--precompiled-atom".to_string());
+    create_exe_args.push(format!("qjs:abc123:{}", object_path.display()));
+    create_exe_args.push("--debug-dir".to_string());
+    create_exe_args.push(format!(
+        "{}",
+        operating_dir.join("compile-create-exe").display()
+    ));
+
+    let create_exe_stdout = WasmerCreateExe {
+        current_dir: std::env::current_dir().unwrap(),
+        wasm_path,
+        native_executable_path: executable_path.clone(),
+        compiler: Compiler::Cranelift,
+        extra_cli_flags: create_exe_args,
+        ..Default::default()
+    }
+    .run()
+    .context("Failed to create-exe wasm with Wasmer")?;
+
+    let create_exe_stdout = std::str::from_utf8(&create_exe_stdout).unwrap();
+    assert!(
+        create_exe_stdout.contains("Using cached object file for atom \"qjs\"."),
+        "missed cache hit"
+    );
+
+    let result = run_code(
+        &operating_dir,
+        &executable_path,
+        &["--eval".to_string(), "function greet(name) { return JSON.stringify('Hello, ' + name); }; print(greet('World'));".to_string()],
+        false,
+    )
+    .context("Failed to run generated executable")?;
+    let result_lines = result.lines().collect::<Vec<&str>>();
+    assert_eq!(result_lines, vec!["\"Hello, World\""],);
+
+    Ok(())
+}
+
+// Ignored because of -lunwind linker issue on Windows
+// see https://github.com/wasmerio/wasmer/issues/3459
+#[cfg_attr(target_os = "windows", ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn create_exe_with_object_input_default() -> anyhow::Result<()> {
+    create_exe_with_object_input(vec![])
+}
+
+/// TODO: on linux-musl, the packaging of libwasmer.a doesn't work properly
+/// Tracked in https://github.com/wasmerio/wasmer/issues/3271
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+#[ignore = "See https://github.com/wasmerio/wasmer/issues/4285"]
+fn test_wasmer_create_exe_pirita_works() {
+    // let temp_dir = Path::new("debug");
+    // std::fs::create_dir_all(&temp_dir);
+
+    use wasmer_integration_tests_cli::get_repo_root_path;
+    let temp_dir = TempDir::new().unwrap();
+    let temp_dir = temp_dir.path().to_path_buf();
+    let python_wasmer_path = temp_dir.join("python.wasmer");
+    std::fs::copy(fixtures::python(), &python_wasmer_path).unwrap();
+    let python_exe_output_path = temp_dir.join("python");
+
+    let native_target = target_lexicon::HOST;
+    let tmp_targz_path = get_repo_root_path().unwrap().join("link.tar.gz");
+
+    println!("compiling to target {native_target}");
+
+    let mut cmd = Command::new(get_wasmer_path());
+    cmd.arg("create-exe");
+    cmd.arg(&python_wasmer_path);
+    cmd.arg("--tarball");
+    cmd.arg(&tmp_targz_path);
+    cmd.arg("--target");
+    cmd.arg(format!("{native_target}"));
+    cmd.arg("-o");
+    cmd.arg(&python_exe_output_path);
+    // change temp_dir to a local path and run this test again
+    // to output the compilation files into a debug folder
+    //
+    // cmd.arg("--debug-dir");
+    // cmd.arg(&temp_dir);
+
+    cmd.assert().success();
+
+    println!("compilation ok!");
+
+    if !python_exe_output_path.exists() {
+        panic!(
+            "python_exe_output_path {} does not exist",
+            python_exe_output_path.display()
+        );
+    }
+
+    println!("invoking command...");
+
+    let mut command = Command::new(&python_exe_output_path);
+    command.arg("-c");
+    command.arg("print(\"hello\")");
+
+    command.assert().success().stdout("hello\n");
+}
+
+// FIXME: Fix and re-enable this test
+// See https://github.com/wasmerio/wasmer/issues/3615
+#[test]
+#[ignore]
+fn test_cross_compile_python_windows() {
+    let temp_dir = TempDir::new().unwrap();
+
+    let targets: &[&str] = if cfg!(windows) {
+        &[
+            "aarch64-darwin",
+            "x86_64-darwin",
+            "x86_64-linux-gnu",
+            "aarch64-linux-gnu",
+        ]
+    } else {
+        &[
+            "aarch64-darwin",
+            "x86_64-darwin",
+            "x86_64-linux-gnu",
+            "aarch64-linux-gnu",
+            "x86_64-windows-gnu",
+        ]
+    };
+
+    let compilers: &[&str] = if cfg!(target_env = "musl") {
+        // MUSL has no support for LLVM in C-API
+        &["cranelift", "singlepass"]
+    } else {
+        &["cranelift", "singlepass", "llvm"]
+    };
+
+    // llvm-objdump  --disassemble-all --demangle ./objects/wasmer_vm-50cb118b098c15db.wasmer_vm.60425a0a-cgu.12.rcgu.o
+    // llvm-objdump --macho --exports-trie ~/.wasmer/cache/wasmer-darwin-arm64/lib/libwasmer.dylib
+    let excluded_combinations = &[
+        ("aarch64-darwin", "llvm"), // LLVM: aarch64 not supported relocation Arm64MovwG0 not supported
+        ("aarch64-linux-gnu", "llvm"), // LLVM: aarch64 not supported relocation Arm64MovwG0 not supported
+        // https://github.com/ziglang/zig/issues/13729
+        ("x86_64-darwin", "llvm"), // undefined reference to symbol 'wasmer_vm_raise_trap' kind Unknown
+        ("x86_64-windows-gnu", "llvm"), // unimplemented symbol `wasmer_vm_raise_trap` kind Unknown
+    ];
+
+    for t in targets {
+        for c in compilers {
+            if excluded_combinations.contains(&(t, c)) {
+                continue;
+            }
+            println!("{t} target {c}");
+            let python_wasmer_path = temp_dir.path().join(format!("{t}-python"));
+
+            let tarball = match std::env::var("GITHUB_TOKEN") {
+                Ok(_) => Some(assert_tarball_is_present_local(t).unwrap()),
+                Err(_) => None,
+            };
+            let mut cmd = Command::new(get_wasmer_path());
+
+            cmd.arg("create-exe");
+            cmd.arg(fixtures::python());
+            cmd.arg("--target");
+            cmd.arg(t);
+            cmd.arg("-o");
+            cmd.arg(python_wasmer_path.clone());
+            cmd.arg(format!("--{c}"));
+            if std::env::var("GITHUB_TOKEN").is_ok() {
+                cmd.arg("--debug-dir");
+                cmd.arg(format!("{t}-{c}"));
+            }
+
+            if t.contains("x86_64") && *c == "singlepass" {
+                cmd.arg("-m");
+                cmd.arg("avx");
+            }
+
+            if let Some(t) = tarball {
+                cmd.arg("--tarball");
+                cmd.arg(t);
+            }
+
+            let assert = cmd.assert().success();
+
+            if !python_wasmer_path.exists() {
+                let p = std::fs::read_dir(temp_dir.path())
+                    .unwrap()
+                    .filter_map(|e| Some(e.ok()?.path()))
+                    .collect::<Vec<_>>();
+                let output = assert.get_output();
+                panic!("target {t} was not compiled correctly tempdir: {p:#?}, {output:?}",);
+            }
+        }
+    }
+}
+
+fn assert_tarball_is_present_local(target: &str) -> Result<PathBuf, anyhow::Error> {
+    let wasmer_dir = std::env::var("WASMER_DIR").expect("no WASMER_DIR set");
+    let directory = match target {
+        "aarch64-darwin" => "wasmer-darwin-arm64.tar.gz",
+        "x86_64-darwin" => "wasmer-darwin-amd64.tar.gz",
+        "x86_64-linux-gnu" => "wasmer-linux-amd64.tar.gz",
+        "aarch64-linux-gnu" => "wasmer-linux-aarch64.tar.gz",
+        "x86_64-windows-gnu" => "wasmer-windows-gnu64.tar.gz",
+        _ => return Err(anyhow::anyhow!("unknown target {target}")),
+    };
+    let libwasmer_cache_path = Path::new(&wasmer_dir).join("cache").join(directory);
+    if !libwasmer_cache_path.exists() {
+        return Err(anyhow::anyhow!(
+            "targz {} does not exist",
+            libwasmer_cache_path.display()
+        ));
+    }
+    println!("using targz {}", libwasmer_cache_path.display());
+    Ok(libwasmer_cache_path)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init1.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init1.toml
new file mode 100644
index 0000000..6ff92fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init1.toml
@@ -0,0 +1,19 @@
+[package]
+name = 'ciuser/testfirstproject'
+version = '0.1.0'
+description = 'Description for package testfirstproject'
+
+# See more keys and definitions at https://docs.wasmer.io/registry/manifest
+
+[[module]]
+name = 'testfirstproject'
+source = 'testfirstproject.wasm'
+abi = 'wasi'
+
+[module.interfaces]
+wasi = '0.1.0-unstable'
+
+[[command]]
+name = 'testfirstproject'
+module = 'testfirstproject'
+runner = 'wasi'
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init2.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init2.toml
new file mode 100644
index 0000000..52310b2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init2.toml
@@ -0,0 +1,6 @@
+[package]
+name = "wasmer"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init4.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init4.toml
new file mode 100644
index 0000000..f013412
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init4.toml
@@ -0,0 +1,19 @@
+[package]
+name = 'ciuser/wasmer'
+version = '0.1.0'
+description = 'Description for package wasmer'
+
+# See more keys and definitions at https://docs.wasmer.io/registry/manifest
+
+[[module]]
+name = 'wasmer'
+source = 'target/wasm32-wasi/release/wasmer.wasm'
+abi = 'wasi'
+
+[module.interfaces]
+wasi = '0.1.0-unstable'
+
+[[command]]
+name = 'wasmer'
+module = 'wasmer'
+runner = 'wasi'
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init6.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init6.toml
new file mode 100644
index 0000000..fc044af
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/fixtures/init6.toml
@@ -0,0 +1,13 @@
+[package]
+name = "WAPMUSERNAME/largewasmfile"
+version = "RANDOMVERSION1.RANDOMVERSION2.RANDOMVERSION3"
+description = "published from wasmer largewasmfile"
+
+[[module]]
+name = "largewasmfile"
+source = "largewasmfile.wasm"
+abi = "wasi"
+
+[[command]]
+name = "largewasmfile"
+module = "largewasmfile"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/gen_c_header.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/gen_c_header.rs
new file mode 100644
index 0000000..ee1a5a6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/gen_c_header.rs
@@ -0,0 +1,75 @@
+use std::{path::PathBuf, process::Command};
+
+use wasmer_integration_tests_cli::{fixtures, get_wasmer_path};
+
+#[test]
+fn gen_c_header_works() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::qjs());
+    let out_path = temp_dir.path().join("header.h");
+
+    let _ = Command::new(get_wasmer_path())
+        .arg("gen-c-header")
+        .arg(&wasm_path)
+        .arg("-o")
+        .arg(&out_path)
+        .output()
+        .unwrap();
+
+    let file = std::fs::read_to_string(&out_path).expect("no header.h file");
+    assert!(file.contains("wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0"), "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file");
+
+    let _ = Command::new(get_wasmer_path())
+        .arg("gen-c-header")
+        .arg(&wasm_path)
+        .arg("-o")
+        .arg(&out_path)
+        .arg("--prefix")
+        .arg("abc123")
+        .output()
+        .unwrap();
+
+    let file = std::fs::read_to_string(&out_path).expect("no header.h file");
+    assert!(
+        file.contains("wasmer_function_abc123_0"),
+        "no wasmer_function_abc123_0 in file"
+    );
+
+    Ok(())
+}
+
+#[test]
+fn gen_c_header_works_pirita() -> anyhow::Result<()> {
+    let temp_dir = tempfile::tempdir()?;
+    let operating_dir: PathBuf = temp_dir.path().to_owned();
+
+    let wasm_path = operating_dir.join(fixtures::wabt());
+    let out_path = temp_dir.path().join("header.h");
+
+    let _ = Command::new(get_wasmer_path())
+        .arg("gen-c-header")
+        .arg(&wasm_path)
+        .arg("-o")
+        .arg(&out_path)
+        .arg("--atom")
+        .arg("wasm-validate")
+        .output()
+        .unwrap();
+
+    let file = std::fs::read_to_string(&out_path).expect("no header.h file");
+    assert!(file.contains("wasmer_function_0f41d38dcfb5abc1fadb5e9acbc5c645e53fe4d0dd86270b72a09bfeee04d055_0"), "no wasmer_function_6f62a6bc5c8f8e3e12a54e2ecbc5674ccfe1c75f91d8e4dd6ebb3fec422a4d6c_0 in file");
+
+    let cmd = Command::new(get_wasmer_path())
+        .arg("gen-c-header")
+        .arg(&wasm_path)
+        .arg("-o")
+        .arg(&out_path)
+        .output()
+        .unwrap();
+
+    assert!(!cmd.status.success());
+
+    Ok(())
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/init.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/init.rs
new file mode 100644
index 0000000..eb9c14b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/init.rs
@@ -0,0 +1,61 @@
+#[macro_use]
+extern crate pretty_assertions;
+
+use assert_cmd::prelude::OutputAssertExt;
+use tempfile::TempDir;
+
+use std::process::Command;
+use wasmer_integration_tests_cli::get_wasmer_path;
+
+// Test that wasmer init without arguments works
+#[test]
+fn wasmer_init_works_1() {
+    let wasmer_dir = TempDir::new().unwrap();
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path().join("testfirstproject");
+    std::fs::create_dir_all(&path).unwrap();
+
+    Command::new(get_wasmer_path())
+        .arg("init")
+        .arg("--namespace=ciuser")
+        .current_dir(&path)
+        .env("WASMER_DIR", wasmer_dir.path())
+        .assert()
+        .success();
+
+    assert_eq!(
+        std::fs::read_to_string(path.join("wasmer.toml")).unwrap(),
+        include_str!("./fixtures/init1.toml"),
+    );
+}
+
+#[test]
+fn wasmer_init_works_2() {
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path();
+    let path = path.join("testfirstproject");
+    std::fs::create_dir_all(&path).unwrap();
+    std::fs::write(
+        path.join("Cargo.toml"),
+        include_bytes!("./fixtures/init2.toml"),
+    )
+    .unwrap();
+    std::fs::create_dir_all(path.join("src")).unwrap();
+    std::fs::write(path.join("src").join("main.rs"), b"fn main() { }").unwrap();
+
+    Command::new(get_wasmer_path())
+        .arg("init")
+        .arg("--namespace=ciuser")
+        .current_dir(&path)
+        .assert()
+        .success();
+
+    assert_eq!(
+        std::fs::read_to_string(path.join("Cargo.toml")).unwrap(),
+        include_str!("./fixtures/init2.toml")
+    );
+    assert_eq!(
+        std::fs::read_to_string(path.join("wasmer.toml")).unwrap(),
+        include_str!("./fixtures/init4.toml")
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/login.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/login.rs
new file mode 100644
index 0000000..1dd58b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/login.rs
@@ -0,0 +1,61 @@
+use assert_cmd::prelude::OutputAssertExt;
+use predicates::str::contains;
+use tempfile::TempDir;
+
+use std::process::Command;
+use wasmer_integration_tests_cli::get_wasmer_path;
+
+#[test]
+fn login_works() {
+    let wasmer_dir = TempDir::new().unwrap();
+
+    // running test locally: should always pass since
+    // developers don't have access to WAPM_DEV_TOKEN
+    if std::env::var("GITHUB_TOKEN").is_err() {
+        return;
+    }
+    let wapm_dev_token = std::env::var("WAPM_DEV_TOKEN").expect("WAPM_DEV_TOKEN env var not set");
+    // Special case: GitHub secrets aren't visible to outside collaborators
+    if wapm_dev_token.is_empty() {
+        return;
+    }
+    let assert = Command::new(get_wasmer_path())
+        .arg("login")
+        .arg("--registry=wasmer.wtf")
+        .arg(wapm_dev_token)
+        .env("WASMER_DIR", wasmer_dir.path())
+        .assert();
+
+    assert
+        .success()
+        .stdout(contains(r#"Login for Wasmer user "ciuser" saved"#));
+}
+
+#[test]
+fn run_whoami_works() {
+    let wasmer_dir = TempDir::new().unwrap();
+
+    // running test locally: should always pass since
+    // developers don't have access to WAPM_DEV_TOKEN
+    if std::env::var("GITHUB_TOKEN").is_err() {
+        return;
+    }
+
+    let ciuser_token = std::env::var("WAPM_DEV_TOKEN").expect("no CIUSER / WAPM_DEV_TOKEN token");
+    // Special case: GitHub secrets aren't visible to outside collaborators
+    if ciuser_token.is_empty() {
+        return;
+    }
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("whoami")
+        .arg("--registry=wasmer.wtf")
+        .env("WASMER_TOKEN", &ciuser_token)
+        .env("WASMER_DIR", wasmer_dir.path())
+        .assert()
+        .success();
+
+    assert.stdout(
+        "logged into registry \"https://registry.wasmer.wtf/graphql\" as user \"ciuser\"\n",
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/msrv.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/msrv.rs
new file mode 100644
index 0000000..8beac17
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/msrv.rs
@@ -0,0 +1,104 @@
+//! Integration tests which makes sure various parts of the project (CI,
+//! Dockerfiles, etc.) are all using the Rust version specified in `/Cargo.toml`.
+
+use std::path::Path;
+
+use once_cell::sync::Lazy;
+use regex::Regex;
+
+static MSRV: Lazy<String> = Lazy::new(|| {
+    let cargo_toml = project_root().join("Cargo.toml");
+    let contents = std::fs::read_to_string(cargo_toml).unwrap();
+    let rust_version_line = contents
+        .lines()
+        .find(|line| line.contains("rust-version") && line.contains('"'))
+        .unwrap();
+    let pieces: Vec<_> = rust_version_line.split('"').collect();
+    let [_, msrv, _] = pieces.as_slice() else {
+        panic!();
+    };
+
+    msrv.to_string()
+});
+
+#[test]
+fn docker_file_is_up_to_date() {
+    let pattern = Regex::new(r"1\.\d\d").unwrap();
+    let dockerfile = project_root()
+        .join(".github")
+        .join("cross-linux-riscv64")
+        .join("Dockerfile");
+
+    let contents = std::fs::read_to_string(&dockerfile).unwrap();
+    let expected = pattern.replace_all(&contents, MSRV.as_str());
+
+    ensure_file_contents(dockerfile, expected);
+}
+
+#[test]
+fn rust_toolchain_file_is_up_to_date() {
+    let pattern = Regex::new(r"1\.\d\d").unwrap();
+    let rust_toolchain = project_root().join("rust-toolchain");
+
+    let contents = std::fs::read_to_string(&rust_toolchain).unwrap();
+    let expected = pattern.replace_all(&contents, MSRV.as_str());
+
+    ensure_file_contents(rust_toolchain, expected);
+}
+
+#[test]
+fn ci_files_are_up_to_date() {
+    let pattern = Regex::new(r#"MSRV:\s*"\d+\.\d+""#).unwrap();
+    let replacement = format!("MSRV: \"{}\"", MSRV.as_str());
+    let workflows = project_root().join(".github").join("workflows");
+
+    for result in workflows.read_dir().unwrap() {
+        let path = result.unwrap().path();
+
+        let contents = std::fs::read_to_string(&path).unwrap();
+        let expected = pattern.replace_all(&contents, &replacement);
+
+        ensure_file_contents(path, expected);
+    }
+}
+
+/// Get the root directory for this repository.
+fn project_root() -> &'static Path {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(3)
+        .unwrap()
+}
+
+/// Check that a particular file has the desired contents.
+///
+/// If the file is missing or outdated, this function will update the file and
+/// trigger a panic to fail any test this is called from.
+fn ensure_file_contents(path: impl AsRef<Path>, contents: impl AsRef<str>) {
+    let path = path.as_ref();
+    let contents = contents.as_ref();
+
+    if let Ok(old_contents) = std::fs::read_to_string(path) {
+        if contents == old_contents {
+            // File is already up to date
+            return;
+        }
+    }
+
+    let display_path = path.strip_prefix(project_root()).unwrap_or(path);
+
+    eprintln!("{} was not up-to-date, updating...", display_path.display());
+
+    if std::env::var("CI").is_ok() {
+        eprintln!("Note: run `cargo test` locally and commit the updated files");
+    }
+
+    if let Some(parent) = path.parent() {
+        let _ = std::fs::create_dir_all(parent);
+    }
+    std::fs::write(&path, contents).unwrap();
+    panic!(
+        "\"{}\" was not up to date and has been updated. Please commit the changes and re-run the tests.",
+        path.strip_prefix(project_root()).unwrap_or(path).display()
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/packages/js-script/src/index.js b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/packages/js-script/src/index.js
new file mode 100644
index 0000000..184dfcc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/packages/js-script/src/index.js
@@ -0,0 +1 @@
+console.log("Hello, World!");
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/publish.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/publish.rs
new file mode 100644
index 0000000..003cd6f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/publish.rs
@@ -0,0 +1,182 @@
+use assert_cmd::prelude::OutputAssertExt;
+use predicates::str::contains;
+use wasmer_integration_tests_cli::{fixtures, get_wasmer_path};
+
+#[test]
+fn wasmer_publish() {
+    // Only run this test in the CI
+    if std::env::var("GITHUB_TOKEN").is_err() {
+        return;
+    }
+
+    let wapm_dev_token = std::env::var("WAPM_DEV_TOKEN").ok();
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path();
+    let username = "ciuser";
+
+    let random1 = format!("{}", rand::random::<u32>());
+    let random2 = format!("{}", rand::random::<u32>());
+    let random3 = format!("{}", rand::random::<u32>());
+
+    std::fs::copy(fixtures::qjs(), path.join("largewasmfile.wasm")).unwrap();
+    std::fs::write(
+        path.join("wasmer.toml"),
+        include_str!("./fixtures/init6.toml")
+            .replace("WAPMUSERNAME", username) // <-- TODO!
+            .replace("RANDOMVERSION1", &random1)
+            .replace("RANDOMVERSION2", &random2)
+            .replace("RANDOMVERSION3", &random3),
+    )
+    .unwrap();
+
+    let mut cmd = std::process::Command::new(get_wasmer_path());
+    cmd.arg("publish")
+        .arg("--quiet")
+        .arg("--registry=wasmer.wtf")
+        .arg(path);
+
+    if let Some(token) = wapm_dev_token {
+        // Special case: GitHub secrets aren't visible to outside collaborators
+        if token.is_empty() {
+            return;
+        }
+        cmd.arg("--token").arg(token);
+    }
+
+    cmd.assert().success().stdout(format!(
+        "🚀 Successfully published package `{username}/largewasmfile@{random1}.{random2}.{random3}`\n"
+    ));
+}
+
+// Runs a full integration test to test that the flow wasmer init - cargo build -
+// wasmer publish is working
+#[test]
+fn wasmer_init_publish() {
+    // Only run this test in the CI
+    if std::env::var("GITHUB_TOKEN").is_err() {
+        return;
+    }
+
+    let wapm_dev_token = std::env::var("WAPM_DEV_TOKEN").ok();
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path();
+    let username = "ciuser";
+
+    let random1 = format!("{}", rand::random::<u32>());
+    let random2 = format!("{}", rand::random::<u32>());
+    let random3 = format!("{}", rand::random::<u32>());
+
+    // Create a new Rust project and build it
+    std::process::Command::new("cargo")
+        .arg("init")
+        .arg("--bin")
+        .arg(path.join("randomversion"))
+        .assert()
+        .success();
+    std::process::Command::new("cargo")
+        .arg("build")
+        .arg("--release")
+        .arg("--target")
+        .arg("wasm32-wasi")
+        .arg("--manifest-path")
+        .arg(path.join("randomversion").join("Cargo.toml"))
+        .assert()
+        .success();
+
+    // generate the wasmer.toml
+    std::process::Command::new(get_wasmer_path())
+        .arg("init")
+        .arg("--namespace")
+        .arg(username)
+        .arg("--version")
+        .arg(format!("{random1}.{random2}.{random3}"))
+        .arg(path.join("randomversion"))
+        .assert()
+        .success();
+
+    let s = std::fs::read_to_string(path.join("randomversion").join("wasmer.toml")).unwrap();
+
+    println!("{s}");
+
+    // publish
+    let mut cmd = std::process::Command::new(get_wasmer_path());
+    cmd.arg("publish")
+        .arg("--quiet")
+        .arg("--registry=wasmer.wtf")
+        .arg(path.join("randomversion"));
+
+    if let Some(token) = wapm_dev_token {
+        // Special case: GitHub secrets aren't visible to outside collaborators
+        if token.is_empty() {
+            return;
+        }
+        cmd.arg("--token").arg(token);
+    }
+
+    let assert = cmd.assert();
+
+    assert.success().stdout(format!(
+        "🚀 Successfully published package `{username}/randomversion@{random1}.{random2}.{random3}`\n"
+    ));
+}
+
+#[test]
+fn wasmer_publish_and_run() {
+    // Only run this test in the CI
+    if std::env::var("GITHUB_TOKEN").is_err() {
+        return;
+    }
+
+    let wapm_dev_token = std::env::var("WAPM_DEV_TOKEN").ok();
+    let tempdir = tempfile::tempdir().unwrap();
+    let path = tempdir.path();
+    let username = "ciuser";
+
+    let random_major = format!("{}", rand::random::<u32>());
+    let random_minor = format!("{}", rand::random::<u32>());
+    let random_patch = format!("{}", rand::random::<u32>());
+
+    std::fs::copy(fixtures::qjs(), path.join("largewasmfile.wasm")).unwrap();
+    std::fs::write(
+        path.join("wasmer.toml"),
+        include_str!("./fixtures/init6.toml")
+            .replace("WAPMUSERNAME", username) // <-- TODO!
+            .replace("RANDOMVERSION1", &random_major)
+            .replace("RANDOMVERSION2", &random_minor)
+            .replace("RANDOMVERSION3", &random_patch),
+    )
+    .unwrap();
+
+    let package_name =
+        format!("{username}/largewasmfile@{random_major}.{random_minor}.{random_patch}",);
+
+    let mut cmd = std::process::Command::new(get_wasmer_path());
+    cmd.arg("publish")
+        .arg("--quiet")
+        .arg("--wait")
+        .arg("--timeout=60s")
+        .arg("--registry=wasmer.wtf")
+        .arg(path);
+
+    if let Some(token) = wapm_dev_token {
+        // Special case: GitHub secrets aren't visible to outside collaborators
+        if token.is_empty() {
+            return;
+        }
+        cmd.arg("--token").arg(token);
+    }
+
+    cmd.assert().success().stdout(format!(
+        "🚀 Successfully published package `{package_name}`\n"
+    ));
+
+    let assert = std::process::Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(format!("https://wasmer.wtf/{package_name}"))
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/run.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/run.rs
new file mode 100644
index 0000000..e02d29a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/run.rs
@@ -0,0 +1,1062 @@
+//! Basic tests for the `run` subcommand
+
+use std::{
+    io::{ErrorKind, Read},
+    path::Path,
+    process::{Child, Command, Stdio},
+    time::{Duration, Instant},
+};
+
+use assert_cmd::{assert::Assert, prelude::OutputAssertExt};
+use once_cell::sync::Lazy;
+use predicates::str::contains;
+use rand::Rng;
+use reqwest::{blocking::Client, IntoUrl};
+use tempfile::TempDir;
+use wasmer_integration_tests_cli::{asset_path, fixtures, get_wasmer_path};
+
+const HTTP_GET_TIMEOUT: Duration = Duration::from_secs(5);
+
+static RUST_LOG: Lazy<String> = Lazy::new(|| {
+    if cfg!(feature = "debug") {
+        "trace".to_string()
+    } else {
+        [
+            "info",
+            "wasmer_wasix::resolve=debug",
+            "wasmer_wasix::runners=debug",
+            "wasmer_wasix=debug",
+            "virtual_fs::trace_fs=trace",
+        ]
+        .join(",")
+    }
+});
+
+/// A version of `$RUST_LOG` used for checking cache messages.
+static CACHE_RUST_LOG: Lazy<String> = Lazy::new(|| {
+    [
+        "wasmer_wasix::runtime::resolver::wapm_source=debug",
+        "wasmer_wasix::runtime::resolver::web_source=debug",
+        "wasmer_wasix::runtime::package_loader::builtin_loader=debug",
+        "wasmer_wasix::runtime::module_cache::filesystem=debug",
+    ]
+    .join(",")
+});
+
+/// Ignored on Windows because running vendored packages does not work
+/// since Windows does not allow `::` characters in filenames (every other OS does)
+///
+/// The syntax for vendored package atoms has to be reworked for this to be fixed, see
+/// https://github.com/wasmerio/wasmer/issues/3535
+// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
+#[test]
+#[ignore]
+fn test_run_customlambda() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("config")
+        .arg("--bindir")
+        .assert()
+        .success();
+    let bindir = std::str::from_utf8(&assert.get_output().stdout)
+        .expect("wasmer config --bindir stdout failed");
+
+    // /Users/fs/.wasmer/bin
+    let checkouts_path = Path::new(bindir.trim())
+        .parent()
+        .expect("--bindir: no parent")
+        .join("checkouts");
+    println!("checkouts path: {}", checkouts_path.display());
+    let _ = std::fs::remove_dir_all(&checkouts_path);
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/ciuser/customlambda")
+        // TODO: this argument should not be necessary later
+        // see https://github.com/wasmerio/wasmer/issues/3514
+        .arg("customlambda.py")
+        .arg("55")
+        .assert()
+        .success();
+    assert.stdout("139583862445\n");
+
+    // Run again to verify the caching
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/ciuser/customlambda")
+        // TODO: this argument should not be necessary later
+        // see https://github.com/wasmerio/wasmer/issues/3514
+        .arg("customlambda.py")
+        .arg("55")
+        .assert()
+        .success();
+    assert.stdout("139583862445\n");
+}
+
+#[test]
+fn run_wasi_works() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::qjs())
+        .arg("--")
+        .arg("-e")
+        .arg("print(3 * (4 + 5))")
+        .assert()
+        .success();
+
+    assert.stdout("27\n");
+}
+
+// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
+#[test]
+#[ignore]
+fn test_wasmer_run_pirita_works() {
+    let temp_dir = tempfile::TempDir::new().unwrap();
+    let python_wasmer_path = temp_dir.path().join("python.wasmer");
+    std::fs::copy(fixtures::python(), &python_wasmer_path).unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(python_wasmer_path)
+        .arg("--")
+        .arg("-c")
+        .arg("print(\"hello\")")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+}
+
+// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
+#[test]
+#[ignore]
+fn test_wasmer_run_pirita_url_works() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.wtf/syrusakbary/python")
+        .arg("--")
+        .arg("-c")
+        .arg("print(\"hello\")")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+}
+
+#[test]
+fn test_wasmer_run_works_with_dir() {
+    let temp_dir = tempfile::TempDir::new().unwrap();
+    let qjs_path = temp_dir.path().join("qjs.wasm");
+
+    std::fs::copy(fixtures::qjs(), &qjs_path).unwrap();
+    std::fs::copy(
+        fixtures::qjs_wasmer_toml(),
+        temp_dir.path().join("wasmer.toml"),
+    )
+    .unwrap();
+
+    assert!(temp_dir.path().exists());
+    assert!(temp_dir.path().join("wasmer.toml").exists());
+    assert!(temp_dir.path().join("qjs.wasm").exists());
+
+    // test with "wasmer qjs.wasm"
+    Command::new(get_wasmer_path())
+        .arg(temp_dir.path())
+        .arg("--")
+        .arg("--quit")
+        .assert()
+        .success();
+
+    // test again with "wasmer run qjs.wasm"
+    Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(temp_dir.path())
+        .arg("--")
+        .arg("--quit")
+        .assert()
+        .success();
+}
+
+// FIXME: Re-enable. See https://github.com/wasmerio/wasmer/issues/3717
+#[ignore]
+#[test]
+fn test_wasmer_run_works() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("test.py")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+
+    // same test again, but this time with "wasmer run ..."
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("test.py")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+
+    // same test again, but this time without specifying the registry in the URL
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("python/python@0.1.0")
+        .arg(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("test.py")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+
+    // same test again, but this time with only the command "python" (should be looked up locally)
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("_/python")
+        .arg(format!("--mapdir=.:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("test.py")
+        .assert()
+        .success();
+
+    assert.stdout("hello\n");
+}
+
+#[test]
+fn run_no_imports_wasm_works() {
+    Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::fib())
+        .assert()
+        .success();
+}
+
+#[test]
+fn run_wasi_works_non_existent() -> anyhow::Result<()> {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("does-not/exist")
+        .assert()
+        .failure();
+
+    assert
+        .stderr(contains(
+            "Unable to find \"does-not/exist\" in the registry",
+        ))
+        .stderr(contains("1: Not found"));
+
+    Ok(())
+}
+
+#[test]
+fn run_test_caching_works_for_packages() {
+    // we're testing the cache, so we don't want to reuse the current user's
+    // $WASMER_DIR
+    let wasmer_dir = TempDir::new().unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("/app/test.py")
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .assert();
+
+    assert
+        .success()
+        .stderr(contains("wapm_source: Querying the GraphQL API"))
+        .stderr(contains("builtin_loader: Downloading a webc file"))
+        .stderr(contains("module_cache::filesystem: Saved to disk"));
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("/app/test.py")
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .assert()
+        .success();
+
+    assert
+        .stderr(contains("wapm_source: Cache hit!"))
+        .stderr(contains("builtin_loader: Cache hit!"))
+        .stderr(contains("module_cache::filesystem: Cache hit!"));
+}
+
+#[test]
+fn run_test_caching_works_for_packages_with_versions() {
+    let wasmer_dir = TempDir::new().unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("/app/test.py")
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .assert()
+        .success();
+
+    assert
+        .success()
+        .stderr(contains("wapm_source: Querying the GraphQL API"))
+        .stderr(contains("builtin_loader: Downloading a webc file"))
+        .stderr(contains("module_cache::filesystem: Saved to disk"));
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("--registry=wasmer.io")
+        .arg("/app/test.py")
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .assert();
+
+    assert
+        .success()
+        .stderr(contains("wapm_source: Cache hit!"))
+        .stderr(contains("builtin_loader: Cache hit!"))
+        .stderr(contains("module_cache::filesystem: Cache hit!"));
+}
+
+#[test]
+fn run_test_caching_works_for_urls() {
+    let wasmer_dir = TempDir::new().unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("/app/test.py")
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .assert()
+        .success();
+
+    assert
+        .success()
+        .stderr(contains("builtin_loader: Downloading a webc file"))
+        .stderr(contains("module_cache::filesystem: Saved to disk"));
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/python/python@0.1.0")
+        .arg(format!("--mapdir=/app:{}", asset_path().display()))
+        .arg("/app/test.py")
+        .env("RUST_LOG", &*CACHE_RUST_LOG)
+        .env("WASMER_CACHE_DIR", wasmer_dir.path())
+        .assert()
+        .success();
+
+    assert
+        // Got a cache hit downloading the *.webc file's metadata
+        .stderr(contains("web_source: Cache hit"))
+        // Cache hit downloading the *.webc file
+        .stderr(contains(
+            r#"builtin_loader: Cache hit! pkg.name="python" pkg.version=0.1.0"#,
+        ))
+        // Cache hit compiling the module
+        .stderr(contains("module_cache::filesystem: Cache hit!"));
+}
+
+// This test verifies that "wasmer run --invoke _start module.wat"
+// works the same as "wasmer run module.wat" (without --invoke).
+#[test]
+fn run_invoke_works_with_nomain_wasi() {
+    // In this example the function "wasi_unstable.arg_sizes_get"
+    // is a function that is imported from the WASI env.
+    let wasi_wat = "
+    (module
+        (import \"wasi_unstable\" \"args_sizes_get\"
+          (func $__wasi_args_sizes_get (param i32 i32) (result i32)))
+        (func $_start)
+        (memory 1)
+        (export \"memory\" (memory 0))
+        (export \"_start\" (func $_start))
+      )
+    ";
+
+    let random = rand::random::<u64>();
+    let module_file = std::env::temp_dir().join(format!("{random}.wat"));
+    std::fs::write(&module_file, wasi_wat.as_bytes()).unwrap();
+
+    Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(&module_file)
+        .assert()
+        .success();
+
+    Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("--invoke")
+        .arg("_start")
+        .arg(&module_file)
+        .assert()
+        .success();
+
+    std::fs::remove_file(&module_file).unwrap();
+}
+
+#[test]
+fn run_no_start_wasm_report_error() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::wat_no_start())
+        .assert()
+        .failure();
+
+    assert.stderr(contains("The module doesn't contain a \"_start\" function"));
+}
+
+// Test that wasmer can run a complex path
+#[test]
+fn test_wasmer_run_complex_url() {
+    let wasm_test_path = fixtures::qjs();
+    let wasm_test_path = wasm_test_path.canonicalize().unwrap_or(wasm_test_path);
+    let mut wasm_test_path = format!("{}", wasm_test_path.display());
+    if wasm_test_path.starts_with(r#"\\?\"#) {
+        wasm_test_path = wasm_test_path.replacen(r#"\\?\"#, "", 1);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        wasm_test_path = wasm_test_path.replace("D:\\", "D://");
+        wasm_test_path = wasm_test_path.replace("C:\\", "C://");
+        wasm_test_path = wasm_test_path.replace("c:\\", "c://");
+        wasm_test_path = wasm_test_path.replace("\\", "/");
+        // wasmer run used to fail on c:\Users\username\wapm_packages\ ...
+        assert!(
+            wasm_test_path.contains("://"),
+            "wasm_test_path path is not complex enough"
+        );
+    }
+
+    Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(wasm_test_path)
+        .arg("--")
+        .arg("-q")
+        .assert()
+        .success();
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasi_runner_on_disk() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::qjs())
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+/// See <https://github.com/wasmerio/wasmer/issues/4010> for more.
+#[test]
+fn wasi_runner_on_disk_mount_using_relative_directory_on_the_host() {
+    let temp = TempDir::new_in(env!("CARGO_TARGET_TMPDIR")).unwrap();
+    std::fs::write(temp.path().join("main.py"), "print('Hello, World!')").unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::python())
+        .arg("--mapdir=/app:.")
+        .arg("--")
+        .arg("/app/main.py")
+        .env("RUST_LOG", &*RUST_LOG)
+        .current_dir(temp.path())
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasi_runner_on_disk_with_mounted_directories() {
+    let temp = TempDir::new().unwrap();
+    std::fs::write(temp.path().join("index.js"), "console.log('Hello, World!')").unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::qjs())
+        .arg(format!("--mapdir=/app:{}", temp.path().display()))
+        .arg("--")
+        .arg("/app/index.js")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasi_runner_on_disk_with_mounted_directories_and_webc_volumes() {
+    let temp = TempDir::new().unwrap();
+    std::fs::write(temp.path().join("main.py"), "print('Hello, World!')").unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::python())
+        .arg(format!("--mapdir=/app:{}", temp.path().display()))
+        .arg("--")
+        .arg("-B")
+        .arg("/app/main.py")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasi_runner_on_disk_with_dependencies() {
+    let port = random_port();
+    let mut cmd = Command::new(get_wasmer_path());
+    cmd.arg("run")
+        .arg(fixtures::hello())
+        .arg(format!("--env=SERVER_PORT={port}"))
+        .arg("--net")
+        .arg("--")
+        .arg("--log-level=info")
+        .env("RUST_LOG", &*RUST_LOG);
+    let mut child = JoinableChild::spawn(cmd);
+    child.wait_for_stderr("listening");
+
+    // Make sure we get the page we want
+    let html = reqwest::blocking::get(format!("http://localhost:{port}/"))
+        .unwrap()
+        .text()
+        .unwrap();
+    assert!(html.contains("<title>Hello World</title>"), "{html}");
+
+    // and make sure our request was logged
+    child
+        .join()
+        .stderr(contains("incoming request: method=GET uri=/"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn webc_files_on_disk_with_multiple_commands_require_an_entrypoint_flag() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::wabt())
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    let msg = r#"Unable to determine the WEBC file's entrypoint. Please choose one of ["wasm-interp", "wasm-strip", "wasm-validate", "wasm2wat", "wast2json", "wat2wasm"]"#;
+    assert.failure().stderr(contains(msg));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasi_runner_on_disk_with_env_vars() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::python())
+        .arg("--env=SOME_VAR=Hello, World!")
+        .arg("--")
+        .arg("-B")
+        .arg("-c")
+        .arg("import os; print(os.environ['SOME_VAR'])")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wcgi_runner_on_disk() {
+    // Start the WCGI server in the background
+    let port = random_port();
+    let mut cmd = Command::new(get_wasmer_path());
+    cmd.arg("run")
+        .arg(format!("--addr=127.0.0.1:{port}"))
+        .arg(fixtures::static_server())
+        .env("RUST_LOG", &*RUST_LOG);
+
+    // Let's run the command and wait until the server has started
+    let mut child = JoinableChild::spawn(cmd);
+    child.wait_for_stdout("WCGI Server running");
+
+    // make the request
+    let body = http_get(format!("http://127.0.0.1:{port}/")).unwrap();
+    assert!(body.contains("<title>Index of /</title>"), "{body}");
+
+    // Let's make sure 404s work too
+    let err = http_get(format!("http://127.0.0.1:{port}/this/does/not/exist.html")).unwrap_err();
+    assert_eq!(err.status().unwrap(), reqwest::StatusCode::NOT_FOUND);
+
+    // And kill the server, making sure it generated the expected logs
+    let assert = child.join();
+
+    assert
+        .stderr(contains("Starting the server"))
+        .stderr(contains(
+            "response generated method=GET uri=/ status_code=200 OK",
+        ))
+        .stderr(contains(
+            "response generated method=GET uri=/this/does/not/exist.html status_code=404 Not Found",
+        ));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wcgi_runner_on_disk_with_mounted_directories() {
+    let temp = TempDir::new().unwrap();
+    std::fs::write(temp.path().join("file.txt"), "Hello, World!").unwrap();
+    // Start the WCGI server in the background
+    let port = random_port();
+    let mut cmd = Command::new(get_wasmer_path());
+    cmd.arg("run")
+        .arg(format!("--addr=127.0.0.1:{port}"))
+        .arg(format!("--mapdir=/path/to:{}", temp.path().display()))
+        .arg(fixtures::static_server())
+        .env("RUST_LOG", &*RUST_LOG);
+
+    // Let's run the command and wait until the server has started
+    let mut child = JoinableChild::spawn(cmd);
+    child.wait_for_stdout("WCGI Server running");
+
+    let body = http_get(format!("http://127.0.0.1:{port}/path/to/file.txt")).unwrap();
+    assert!(body.contains("Hello, World!"), "{body}");
+
+    // And kill the server, making sure it generated the expected logs
+    let assert = child.join();
+
+    assert
+        .stderr(contains("Starting the server"))
+        .stderr(contains(
+            "response generated method=GET uri=/path/to/file.txt status_code=200 OK",
+        ));
+}
+
+/// See https://github.com/wasmerio/wasmer/issues/3794
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn issue_3794_unable_to_mount_relative_paths() {
+    let temp = TempDir::new().unwrap();
+    std::fs::write(temp.path().join("message.txt"), b"Hello, World!").unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::coreutils())
+        .arg(format!("--mapdir=./some-dir/:{}", temp.path().display()))
+        .arg("--command-name=cat")
+        .arg("--")
+        .arg("./some-dir/message.txt")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+#[cfg_attr(
+    windows,
+    ignore = "FIXME(Michael-F-Bryan): Temporarily broken on Windows - https://github.com/wasmerio/wasmer/issues/3929"
+)]
+fn merged_filesystem_contains_all_files() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::bash())
+        .arg("--entrypoint=bash")
+        .arg("--use")
+        .arg(fixtures::coreutils())
+        .arg("--use")
+        .arg(fixtures::python())
+        .arg("--")
+        .arg("-c")
+        .arg("ls -l /usr/coreutils/*.md && ls -l /lib/python3.6/*.py")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert
+        .success()
+        .stdout(contains("/usr/coreutils/README.md"))
+        .stdout(contains("/lib/python3.6/this.py"));
+}
+
+#[test]
+fn run_a_wasi_executable() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::qjs())
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+fn wasm_file_with_no_abi() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::fib())
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success();
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn error_if_no_start_function_found() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(fixtures::wat_no_start())
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert
+        .failure()
+        .stderr(contains("The module doesn't contain a \"_start\" function"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn run_a_pre_compiled_wasm_file() {
+    let temp = TempDir::new().unwrap();
+    let dest = temp.path().join("qjs.wasmu");
+    let qjs = fixtures::qjs();
+    // Make sure it is compiled
+    Command::new(get_wasmer_path())
+        .arg("compile")
+        .arg("-o")
+        .arg(&dest)
+        .arg(&qjs)
+        .assert()
+        .success();
+    assert!(dest.exists());
+
+    // Now we can try to run the compiled artifact
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(&dest)
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn wasmer_run_some_directory() {
+    let temp = TempDir::new().unwrap();
+    std::fs::copy(fixtures::qjs(), temp.path().join("qjs.wasm")).unwrap();
+    std::fs::copy(fixtures::qjs_wasmer_toml(), temp.path().join("wasmer.toml")).unwrap();
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(temp.path())
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn run_quickjs_via_package_name() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("saghul/quickjs")
+        .arg("--entrypoint=quickjs")
+        .arg("--registry=wasmer.io")
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+fn run_quickjs_via_url() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("https://wasmer.io/saghul/quickjs")
+        .arg("--entrypoint=quickjs")
+        .arg("--")
+        .arg("--eval")
+        .arg("console.log('Hello, World!')")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+#[test]
+#[cfg_attr(
+    all(target_env = "musl", target_os = "linux"),
+    ignore = "wasmer run-unstable segfaults on musl"
+)]
+#[cfg_attr(
+    windows,
+    ignore = "TODO(Michael-F-Bryan): Figure out why WasiFs::get_inode_at_path_inner() returns Errno::notcapable on Windows"
+)]
+fn run_bash_using_coreutils() {
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg("sharrattj/bash")
+        .arg("--entrypoint=bash")
+        .arg("--use=sharrattj/coreutils")
+        .arg("--registry=wasmer.io")
+        .arg("--")
+        .arg("-c")
+        .arg("ls /bin")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    // Note: the resulting filesystem should contain the main command as
+    // well as the commands from all the --use packages
+
+    let some_expected_binaries = [
+        "arch", "base32", "base64", "baseenc", "basename", "bash", "cat",
+    ]
+    .join("\n");
+    assert.success().stdout(contains(some_expected_binaries));
+}
+
+#[test]
+fn run_a_package_that_uses_an_atom_from_a_dependency() {
+    let js_script_dir = project_root()
+        .join("tests")
+        .join("integration")
+        .join("cli")
+        .join("tests")
+        .join("packages")
+        .join("js-script");
+
+    let assert = Command::new(get_wasmer_path())
+        .arg("run")
+        .arg(&js_script_dir)
+        .arg("--registry=wasmer.io")
+        .env("RUST_LOG", &*RUST_LOG)
+        .assert();
+
+    assert.success().stdout(contains("Hello, World!"));
+}
+
+fn project_root() -> &'static Path {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(3)
+        .unwrap()
+}
+
+/// A helper that wraps [`Child`] to make sure it gets terminated
+/// when it is no longer needed.
+struct JoinableChild {
+    command: Command,
+    child: Option<Child>,
+}
+
+impl JoinableChild {
+    fn spawn(mut cmd: Command) -> Self {
+        let child = cmd
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .unwrap();
+
+        JoinableChild {
+            child: Some(child),
+            command: cmd,
+        }
+    }
+
+    /// Keep reading lines from the child's stdout until a line containing the
+    /// desired text is found.
+    fn wait_for_stdout(&mut self, text: &str) -> String {
+        let stdout = self
+            .child
+            .as_mut()
+            .and_then(|child| child.stdout.as_mut())
+            .unwrap();
+
+        wait_for(text, stdout)
+    }
+
+    /// Keep reading lines from the child's stderr until a line containing the
+    /// desired text is found.
+    fn wait_for_stderr(&mut self, text: &str) -> String {
+        let stderr = self
+            .child
+            .as_mut()
+            .and_then(|child| child.stderr.as_mut())
+            .unwrap();
+
+        wait_for(text, stderr)
+    }
+
+    /// Kill the underlying [`Child`] and get an [`Assert`] we
+    /// can use to check it.
+    fn join(mut self) -> Assert {
+        let mut child = self.child.take().unwrap();
+        child.kill().unwrap();
+        child.wait_with_output().unwrap().assert()
+    }
+}
+
+fn wait_for(text: &str, reader: &mut dyn Read) -> String {
+    let mut all_output = String::new();
+
+    loop {
+        let line = read_line(reader).unwrap();
+
+        if line.is_empty() {
+            eprintln!("=== All Output === ");
+            eprintln!("{all_output}");
+            panic!("EOF before \"{text}\" was found");
+        }
+
+        let found = line.contains(text);
+        all_output.push_str(&line);
+
+        if found {
+            return all_output;
+        }
+    }
+}
+
+fn read_line(reader: &mut dyn Read) -> Result<String, std::io::Error> {
+    let mut line = Vec::new();
+
+    while !line.ends_with(&[b'\n']) {
+        let mut buffer = [0_u8];
+        match reader.read_exact(&mut buffer) {
+            Ok(_) => {
+                line.push(buffer[0]);
+            }
+            Err(e) if e.kind() == ErrorKind::UnexpectedEof => break,
+            Err(e) => return Err(e),
+        }
+    }
+
+    let line = String::from_utf8(line).map_err(|e| std::io::Error::new(ErrorKind::Other, e))?;
+    Ok(line)
+}
+
+impl Drop for JoinableChild {
+    fn drop(&mut self) {
+        if let Some(mut child) = self.child.take() {
+            eprintln!("==== WARNING: Child was dropped before being joined ====");
+            eprintln!("Command: {:?}", self.command);
+
+            let _ = child.kill();
+
+            if let Some(mut stderr) = child.stderr.take() {
+                let mut buffer = String::new();
+                if stderr.read_to_string(&mut buffer).is_ok() {
+                    eprintln!("---- STDERR ----");
+                    eprintln!("{buffer}");
+                }
+            }
+
+            if let Some(mut stdout) = child.stdout.take() {
+                let mut buffer = String::new();
+                if stdout.read_to_string(&mut buffer).is_ok() {
+                    eprintln!("---- STDOUT ----");
+                    eprintln!("{buffer}");
+                }
+            }
+
+            if !std::thread::panicking() {
+                panic!("Child was dropped before being joined");
+            }
+        }
+    }
+}
+
+/// Send a GET request to a particular URL, automatically retrying (with
+/// a timeout) if there are any connection errors.
+fn http_get(url: impl IntoUrl) -> Result<String, reqwest::Error> {
+    let start = Instant::now();
+    let url = url.into_url().unwrap();
+
+    let client = Client::new();
+
+    while start.elapsed() < HTTP_GET_TIMEOUT {
+        match client.get(url.clone()).send() {
+            Ok(response) => {
+                return response.error_for_status()?.text();
+            }
+            Err(e) if e.is_connect() => continue,
+            Err(other) => return Err(other),
+        }
+    }
+
+    panic!("Didn't receive a response from \"{url}\" within the allocated time");
+}
+
+fn random_port() -> u16 {
+    rand::thread_rng().gen_range(10_000_u16..u16::MAX)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshot.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshot.rs
new file mode 100644
index 0000000..b231512
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshot.rs
@@ -0,0 +1,1279 @@
+use std::{
+    io::{Read, Write},
+    path::{Path, PathBuf},
+    process::{Child, Stdio},
+    sync::Arc,
+    time::Duration,
+};
+
+use anyhow::Error;
+use derivative::Derivative;
+use futures::TryFutureExt;
+use insta::assert_json_snapshot;
+
+use tempfile::NamedTempFile;
+use wasmer_integration_tests_cli::get_wasmer_path;
+
+#[derive(Derivative, serde::Serialize, serde::Deserialize, Clone)]
+#[derivative(Debug, PartialEq)]
+pub struct TestIncludeWeb {
+    pub name: String,
+    #[derivative(Debug = "ignore", PartialEq = "ignore")]
+    #[serde(skip, default = "default_include_webc")]
+    pub webc: Arc<NamedTempFile>,
+}
+
+fn default_include_webc() -> Arc<NamedTempFile> {
+    Arc::new(NamedTempFile::new().unwrap())
+}
+impl Eq for TestIncludeWeb {}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq)]
+pub struct TestSpec {
+    pub name: Option<String>,
+    // Uses a hex-encoded String for better review output.
+    #[serde(skip)]
+    pub wasm_hash: String,
+    /// Name of webc dependencies to inject.
+    pub use_packages: Vec<String>,
+    pub include_webcs: Vec<TestIncludeWeb>,
+    pub cli_args: Vec<String>,
+    #[serde(skip)]
+    pub stdin: Option<Vec<u8>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    pub stdin_hash: Option<String>,
+    pub enable_threads: bool,
+    pub enable_network: bool,
+    #[serde(skip_serializing_if = "is_false")]
+    #[serde(default)]
+    pub enable_async_threads: bool,
+}
+
+fn is_false(b: &bool) -> bool {
+    !(*b)
+}
+
+static WEBC_BASH: &[u8] =
+    include_bytes!("./webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc");
+static WEBC_COREUTILS_16: &[u8] =
+    include_bytes!("./webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc");
+static WEBC_COREUTILS_11: &[u8] =
+    include_bytes!("./webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc");
+static WEBC_DASH: &[u8] =
+    include_bytes!("./webc/dash-1.0.18-f0d13233-bcda-4cf1-9a23-3460bffaae2a.webc");
+static WEBC_PYTHON: &[u8] = include_bytes!("./webc/python-0.1.0.webc");
+static WEBC_WEB_SERVER: &[u8] = include_bytes!(
+    "./webc/static-web-server-async-1.0.3-5d739d1a-20b7-4edf-8cf4-44e813f96b25.webc"
+);
+static WEBC_WASMER_SH: &[u8] =
+    include_bytes!("./webc/wasmer-sh-1.0.63-dd3d67d1-de94-458c-a9ee-caea3b230ccf.webc");
+
+impl std::fmt::Debug for TestSpec {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("TestSpec")
+            .field("name", &self.name)
+            // TODO: show hash of code?
+            // .field("wasm_code", &self.wasm_code)
+            .field("use_packages", &self.use_packages)
+            .field("include_webcs", &self.include_webcs)
+            .field("cli_args", &self.cli_args)
+            .field("stdin", &self.stdin)
+            .finish()
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq, Debug)]
+pub struct TestOutput {
+    // Either a plain string, or a hex-encoded string for binary output.
+    pub stdout: String,
+    // Either a plain string, or a hex-encoded string for binary output.
+    pub stderr: String,
+    pub exit_code: i32,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq, Debug)]
+pub enum TestResult {
+    Success(TestOutput),
+    Error(String),
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Clone, PartialEq, Eq, Debug)]
+pub struct TestSnapshot {
+    pub spec: TestSpec,
+    pub result: TestResult,
+}
+
+impl TestSnapshot {
+    pub fn convert_stdout_to_hash(&mut self) {
+        self.result = match &self.result {
+            TestResult::Success(a) => TestResult::Success(TestOutput {
+                stdout: format!("hash: {:x}", md5::compute(a.stdout.as_bytes())),
+                stderr: a.stderr.clone(),
+                exit_code: a.exit_code,
+            }),
+            res => res.clone(),
+        };
+    }
+}
+
+pub struct TestBuilder {
+    spec: TestSpec,
+}
+
+type RunWith = Box<dyn FnOnce(Child) -> Result<i32, Error> + 'static>;
+
+impl TestBuilder {
+    pub fn new() -> Self {
+        Self {
+            spec: TestSpec {
+                name: None,
+                wasm_hash: String::new(),
+                use_packages: Vec::new(),
+                include_webcs: Vec::new(),
+                cli_args: Vec::new(),
+                stdin: None,
+                stdin_hash: None,
+                enable_threads: true,
+                enable_network: false,
+                enable_async_threads: false,
+            },
+        }
+    }
+
+    pub fn arg(mut self, arg: impl Into<String>) -> Self {
+        self.spec.cli_args.push(arg.into());
+        self
+    }
+
+    pub fn with_async_threads(mut self) -> Self {
+        self.spec.enable_async_threads = true;
+        self
+    }
+
+    pub fn args<I: IntoIterator<Item = S>, S: AsRef<str>>(mut self, args: I) -> Self {
+        let args = args.into_iter().map(|s| s.as_ref().to_string());
+        self.spec.cli_args.extend(args);
+        self
+    }
+
+    pub fn stdin_str(self, s: impl Into<String>) -> Self {
+        let str = s.into();
+        self.stdin(str.as_bytes())
+    }
+
+    pub fn stdin(mut self, s: &[u8]) -> Self {
+        self.spec.stdin_hash = Some(format!("{:x}", md5::compute(s)));
+        self.spec.stdin = Some(s.to_vec());
+        self
+    }
+
+    pub fn use_pkg(mut self, s: impl Into<String>) -> Self {
+        self.spec.use_packages.push(s.into());
+        self
+    }
+
+    pub fn include_static_package(mut self, name: &str, data: &[u8]) -> Self {
+        let package = build_test_file(data);
+        self.spec.include_webcs.push(TestIncludeWeb {
+            name: name.to_string(),
+            webc: Arc::new(package),
+        });
+        self
+    }
+
+    pub fn use_coreutils(self) -> Self {
+        // TODO: use custom compiled coreutils
+        self.use_pkg("sharrattj/coreutils")
+            .include_static_package("sharrattj/coreutils@1.0.16", WEBC_COREUTILS_16)
+    }
+
+    pub fn use_dash(self) -> Self {
+        // TODO: use custom compiled dash
+        self.use_pkg("sharrattj/dash")
+            .include_static_package("sharrattj/dash@1.0.16", WEBC_DASH)
+            .include_static_package("sharrattj/coreutils@1.0.11", WEBC_COREUTILS_11)
+    }
+
+    pub fn use_bash(self) -> Self {
+        // TODO: use custom compiled bash
+        self.use_pkg("sharrattj/bash")
+            .include_static_package("sharrattj/bash@1.0.12", WEBC_BASH)
+            .include_static_package("sharrattj/coreutils@1.0.11", WEBC_COREUTILS_11)
+    }
+
+    // Enable thread support.
+    // NOTE: ENABLED BY DEFAULT.
+    pub fn enable_threads(mut self, enabled: bool) -> Self {
+        self.spec.enable_threads = enabled;
+        self
+    }
+
+    pub fn enable_network(mut self, enabled: bool) -> Self {
+        self.spec.enable_network = enabled;
+        self
+    }
+
+    pub fn run_file(self, path: impl AsRef<Path>) -> TestSnapshot {
+        snapshot_file(path.as_ref(), self.spec)
+    }
+
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.spec.name = Some(name.to_string());
+        self
+    }
+
+    pub fn run_wasm(self, code: &[u8]) -> TestSnapshot {
+        #[allow(unused_mut)]
+        let mut snapshot = build_snapshot(self.spec, code);
+        // TODO: figure out why snapshot exit code is 79 on macos
+        #[cfg(target_os = "macos")]
+        if let TestResult::Success(ref mut output) = snapshot.result {
+            if output.exit_code == 79 {
+                output.exit_code = 78;
+            }
+        }
+        snapshot
+    }
+
+    pub fn run_wasm_with(self, code: &[u8], with: RunWith) -> TestSnapshot {
+        build_snapshot_with(self.spec, code, with)
+    }
+}
+
+impl Default for TestBuilder {
+    fn default() -> Self {
+        TestBuilder::new()
+    }
+}
+
+pub fn wasm_dir() -> PathBuf {
+    std::env::current_dir()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .join("wasm")
+}
+
+fn wasmer_path() -> PathBuf {
+    let path = std::env::var("WASMER_PATH")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| get_wasmer_path());
+    if !path.is_file() {
+        panic!("Could not find wasmer binary: '{}'", path.display());
+    }
+    path
+}
+
+fn build_test_file(contents: &[u8]) -> NamedTempFile {
+    let mut named_file = NamedTempFile::new().unwrap();
+    let file = named_file.as_file_mut();
+    file.write_all(contents).unwrap();
+    file.flush().unwrap();
+    named_file
+}
+
+fn bytes_to_hex_string(bytes: Vec<u8>) -> String {
+    if let Ok(s) = String::from_utf8(bytes.clone()) {
+        s
+    } else {
+        hex::encode(bytes)
+    }
+}
+
+pub fn run_test_with(spec: TestSpec, code: &[u8], with: RunWith) -> TestResult {
+    let wasm_path = build_test_file(code);
+
+    let mut cmd = std::process::Command::new(wasmer_path());
+
+    // let shell = xshell::Shell::new().unwrap();
+    // let wasmer = wasmer_path();
+
+    // let mut cmd = xshell::cmd!(shell, "{wasmer}");
+    if spec.enable_threads {
+        cmd.arg("--enable-threads");
+    }
+    if spec.enable_network {
+        cmd.arg("--net");
+    }
+
+    if spec.enable_async_threads {
+        cmd.arg("--enable-async-threads");
+    }
+
+    for pkg in &spec.use_packages {
+        cmd.args(["--use", pkg]);
+    }
+
+    for pkg in &spec.include_webcs {
+        cmd.arg("--include-webc").arg(pkg.webc.path());
+    }
+
+    cmd.env("RUST_LOG", "off");
+
+    cmd.env("RUST_BACKTRACE", "1");
+
+    cmd.arg(wasm_path.path());
+    if !spec.cli_args.is_empty() {
+        cmd.arg("--").args(&spec.cli_args);
+    }
+
+    // Stdio.
+    cmd.stdout(Stdio::piped());
+    cmd.stderr(Stdio::piped());
+    if spec.stdin.is_some() {
+        cmd.stdin(Stdio::piped());
+    }
+
+    dbg!(&cmd);
+    let mut proc = match cmd.spawn() {
+        Ok(p) => p,
+        Err(err) => {
+            return TestResult::Error(format!("Could not spawn wasmer command: {err}"));
+        }
+    };
+
+    let mut stdout_handle = proc.stdout.take().unwrap();
+    let mut stderr_handle = proc.stderr.take().unwrap();
+
+    let stdout_thread = std::thread::spawn(move || -> Result<Vec<u8>, std::io::Error> {
+        let mut buffer = Vec::new();
+        stdout_handle.read_to_end(&mut buffer)?;
+        Ok(buffer)
+    });
+    let stderr_thread = std::thread::spawn(move || -> Result<Vec<u8>, std::io::Error> {
+        let mut buffer = Vec::new();
+        stderr_handle.read_to_end(&mut buffer)?;
+        Ok(buffer)
+    });
+
+    if let Some(stdin) = &spec.stdin {
+        proc.stdin.take().unwrap().write_all(stdin).unwrap();
+    }
+
+    let status = with(proc);
+
+    let status = match status {
+        Ok(status) => status,
+        Err(err) => {
+            let stdout = stdout_thread.join().unwrap().unwrap();
+            let stderr = stderr_thread.join().unwrap().unwrap();
+            return TestResult::Error(format!(
+                "Command failed: {err}\n\nSTDOUT:\n{}\n\nSTDERR:\n{}",
+                String::from_utf8_lossy(&stdout),
+                String::from_utf8_lossy(&stderr)
+            ));
+        }
+    };
+
+    let stdout = bytes_to_hex_string(stdout_thread.join().unwrap().unwrap());
+    let stderr = bytes_to_hex_string(stderr_thread.join().unwrap().unwrap());
+
+    // we do some post processing to replace the temporary random name of the binary
+    // with a fixed name as otherwise the results are not comparable. this occurs
+    // because bash (and others) use the process name in the printf on stdout
+    let stdout = stdout.replace(
+        wasm_path
+            .path()
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .as_ref(),
+        "test.wasm",
+    );
+    let stderr = stderr.replace(
+        wasm_path
+            .path()
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .as_ref(),
+        "test.wasm",
+    );
+
+    TestResult::Success(TestOutput {
+        stdout,
+        stderr,
+        exit_code: status,
+    })
+}
+
+pub fn build_snapshot(mut spec: TestSpec, code: &[u8]) -> TestSnapshot {
+    spec.wasm_hash = format!("{:x}", md5::compute(code));
+
+    let result = run_test_with(
+        spec.clone(),
+        code,
+        Box::new(|mut child| {
+            child
+                .wait()
+                .map_err(|err| err.into())
+                .map(|status| status.code().unwrap_or_default())
+        }),
+    );
+
+    TestSnapshot { spec, result }
+}
+
+pub fn build_snapshot_with(mut spec: TestSpec, code: &[u8], with: RunWith) -> TestSnapshot {
+    spec.wasm_hash = format!("{:x}", md5::compute(code));
+
+    let result = run_test_with(spec.clone(), code, with);
+
+    TestSnapshot { spec, result }
+}
+
+pub fn snapshot_file(path: &Path, spec: TestSpec) -> TestSnapshot {
+    let code = std::fs::read(path)
+        .map_err(|err| format!("Could not read wasm file '{}': {err}", path.display()))
+        .unwrap();
+    build_snapshot(spec, &code)
+}
+
+macro_rules! function {
+    () => {{
+        fn f() {}
+        fn type_name_of<T>(_: T) -> &'static str {
+            std::any::type_name::<T>()
+        }
+        let name = type_name_of(f);
+        &name[..name.len() - 3]
+    }};
+}
+
+#[cfg_attr(
+    any(
+        target_env = "musl",
+        all(target_os = "macos", target_arch = "x86_64"), // Output is slightly different in macos x86_64
+        target_os = "windows"
+    ),
+    ignore
+)]
+#[test]
+fn test_snapshot_condvar() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-condvar.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_condvar_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-condvar.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Test that the expected default directories are present.
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_default_file_system_tree() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .arg("ls")
+        .run_wasm(include_bytes!("./wasm/coreutils.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// TODO: figure out why this hangs on Windows and Mac OS
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_stdin_stdout_stderr() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("blah")
+        .args(["tee", "/dev/stderr"])
+        .run_wasm(include_bytes!("./wasm/coreutils.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Piping to cowsay should, well.... display a cow that says something
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_cowsay() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("blah\n")
+        .run_wasm(include_bytes!("./wasm/cowsay.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_epoll() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-epoll.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_epoll_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-epoll.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_file_copy() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .stdin_str("hi")
+        .arg("/dev/stdin")
+        .arg("/dev/stdout")
+        .run_wasm(include_bytes!("./wasm/example-file-copy.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_execve() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-execve.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_readdir_tree() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .args(["/"])
+        .run_wasm(include_bytes!("./wasm/example-readdir_tree.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_minimodem_tx() {
+    let mut snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("This message wont get through")
+        .arg("--tx")
+        .arg("--tx-carrier")
+        .arg("--stdio")
+        .arg("--float-samples")
+        .arg("same")
+        .run_wasm(include_bytes!("./wasm/minimodem.wasm"));
+    snapshot.convert_stdout_to_hash();
+
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_minimodem_rx() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .arg("--rx")
+        .arg("--tx-carrier")
+        .arg("--stdio")
+        .arg("--float-samples")
+        .arg("same")
+        .stdin(include_bytes!("./wasm/minimodem.data"))
+        .run_wasm(include_bytes!("./wasm/minimodem.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+fn test_run_http_request(
+    port: u16,
+    what: &str,
+    expected_size: Option<usize>,
+) -> Result<i32, Error> {
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()?;
+
+    let http_get = move |url: String, max_retries: i32| {
+        rt.block_on(async move {
+            let mut n = 1;
+
+            loop {
+                println!("http request (attempt #{n}): {url}");
+
+                let pending_request = reqwest::get(&url)
+                    .and_then(|r| futures::future::ready(r.error_for_status()))
+                    .and_then(|r| r.bytes());
+
+                match tokio::time::timeout(Duration::from_secs(2), pending_request)
+                    .await
+                    .map_err(Error::from)
+                    .and_then(|result| result.map_err(Error::from))
+                {
+                    Ok(body) => return Ok(body),
+                    Err(e) if n <= max_retries => {
+                        eprintln!("non-fatal error: {e}... Retrying");
+                        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+
+                        n += 1;
+                        continue;
+                    }
+                    Err(e) => {
+                        return Err(e);
+                    }
+                }
+            }
+        })
+    };
+
+    let expected_size = match expected_size {
+        None => {
+            let url = format!("http://localhost:{}/{}.size", port, what);
+            let expected_size = String::from_utf8_lossy(http_get(url, 50)?.as_ref())
+                .trim()
+                .parse()?;
+            if expected_size == 0 {
+                return Err(anyhow::format_err!("There was no data returned"));
+            }
+            expected_size
+        }
+        Some(s) => s,
+    };
+    println!("expected_size: {}", expected_size);
+
+    let url = format!("http://localhost:{}/{}", port, what);
+    let reference_data = http_get(url.clone(), 50)?;
+    for _ in 0..20 {
+        let test_data = http_get(url.clone(), 2)?;
+        println!("actual_size: {}", test_data.len());
+
+        if expected_size != test_data.len() {
+            return Err(anyhow::format_err!(
+                "The actual size and expected size does not match {} vs {}",
+                test_data.len(),
+                expected_size
+            ));
+        }
+        if test_data
+            .iter()
+            .zip(reference_data.iter())
+            .any(|(a, b)| a != b)
+        {
+            return Err(anyhow::format_err!("The returned data is inconsistent"));
+        }
+    }
+    Ok(0)
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_tokio() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-tokio.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_unix_pipe() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-unix-pipe.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[test]
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+fn test_snapshot_web_server() {
+    let name: &str = function!();
+    let port = 7777;
+
+    let with = move |mut child: Child| {
+        let ret = test_run_http_request(port, "main.js", None);
+        child.kill().ok();
+        ret
+    };
+
+    let script = format!(
+        r#"
+cat /public/main.js | wc -c > /public/main.js.size
+rm -r -f /cfg/
+cd /public
+/bin/webserver --log-level warn --root /public --port {}"#,
+        port
+    );
+    let builder = TestBuilder::new()
+        .with_name(name)
+        .enable_network(true)
+        .include_static_package("sharrattj/static-web-server@1.0.92", WEBC_WEB_SERVER)
+        .include_static_package("sharrattj/wasmer-sh@1.0.63", WEBC_WASMER_SH)
+        .use_coreutils()
+        .use_pkg("sharrattj/wasmer-sh")
+        .stdin_str(script);
+
+    let snapshot = builder.run_wasm_with(include_bytes!("./wasm/dash.wasm"), Box::new(with));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_web_server_epoll() {
+    let name = function!();
+    let port = 7778;
+
+    let with = move |mut child: Child| {
+        let ret = test_run_http_request(port, "null", Some(0));
+        child.kill().ok();
+        ret
+    };
+
+    let builder = TestBuilder::new()
+        .with_name(name)
+        .with_async_threads()
+        .enable_network(true)
+        .arg("--root")
+        .arg("/dev")
+        .arg("--log-level")
+        .arg("warn")
+        .arg("--port")
+        .arg(&format!("{}", port));
+
+    let snapshot = builder.run_wasm_with(
+        include_bytes!("./wasm/web-server-epoll.wasm"),
+        Box::new(with),
+    );
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_web_server_poll() {
+    let name = function!();
+    let port = 7779;
+
+    let with = move |mut child: Child| {
+        let ret = test_run_http_request(port, "null", Some(0));
+        child.kill().ok();
+        ret
+    };
+
+    let builder = TestBuilder::new()
+        .with_name(name)
+        .with_async_threads()
+        .enable_network(true)
+        .arg("--root")
+        .arg("/dev")
+        .arg("--log-level")
+        .arg("warn")
+        .arg("--port")
+        .arg(&format!("{}", port));
+
+    let snapshot = builder.run_wasm_with(
+        include_bytes!("./wasm/web-server-poll.wasm"),
+        Box::new(with),
+    );
+    assert_json_snapshot!(snapshot);
+}
+// The ability to fork the current process and run a different image but retain
+// the existing open file handles (which is needed for stdin and stdout redirection)
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_fork_and_exec() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-execve.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// The ability to fork the current process and run a different image but retain
+// the existing open file handles (which is needed for stdin and stdout redirection)
+#[cfg(not(target_os = "windows"))]
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_fork_and_exec_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-execve.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// longjmp is used by C programs that save and restore the stack at specific
+// points - this functionality is often used for exception handling
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_longjump() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-longjmp.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Simple fork example that is a crude multi-threading implementation - used by `dash`
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_fork() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-fork.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Simple fork example that is a crude multi-threading implementation - used by `dash`
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_fork_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-fork.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Uses the `fd_pipe` syscall to create a bidirection pipe with two file
+// descriptors then forks the process to write and read to this pipe.
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_pipes() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-pipe.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Performs a longjmp of a stack that was recorded before the fork.
+// This test ensures that the stacks that have been recorded are preserved
+// after a fork.
+// The behavior is needed for `dash`
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_longjump_fork() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-fork-longjmp.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Performs a longjmp of a stack that was recorded before the fork.
+// This test ensures that the stacks that have been recorded are preserved
+// after a fork.
+// The behavior is needed for `dash`
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_longjump_fork_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-fork-longjmp.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// full multi-threading with shared memory and shared compiled modules
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_multithreading() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-multi-threading.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// test for traditional wasi threads
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_wasi_threads() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .enable_threads(true)
+        .run_wasm(include_bytes!("./wasm/wasi-threads.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// multithreading with shared memory access
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_threaded_memory() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/threaded-memory.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// full multi-threading with shared memory and shared compiled modules
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_multithreading_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-multi-threading.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// full multi-threading with shared memory and shared compiled modules
+#[cfg(target_os = "linux")]
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_sleep() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-sleep.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// full multi-threading with shared memory and shared compiled modules
+#[cfg(target_os = "linux")]
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_sleep_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-sleep.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Uses `posix_spawn` to launch a sub-process and wait on it to exit
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_process_spawn() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-spawn.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Uses `posix_spawn` to launch a sub-process and wait on it to exit
+#[cfg(not(target_os = "windows"))]
+#[cfg_attr(
+    any(target_env = "musl", target_os = "macos", target_os = "windows"),
+    ignore
+)]
+#[test]
+fn test_snapshot_process_spawn_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-spawn.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// FIXME: re-enable - hangs on windows and macos
+// Connects to 8.8.8.8:53 over TCP to verify TCP clients work
+// #[test]
+// fn test_snapshot_tcp_client() {
+//     let snapshot = TestBuilder::new()
+//         .with_name(function!())
+//         .use_coreutils()
+//         .run_wasm(include_bytes!("./wasm/example-tcp-client.wasm"));
+//     assert_json_snapshot!(snapshot);
+// }
+
+// Tests that thread local variables work correctly
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_thread_locals() {
+    let mut snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-thread-local.wasm"));
+
+    match &mut snapshot.result {
+        TestResult::Success(out) => {
+            // Output is non-deterministic, so just check for pass/failure by
+            // resetting the output.
+            out.stderr = String::new();
+            out.stdout = String::new();
+        }
+        TestResult::Error(_) => {}
+    };
+
+    assert_json_snapshot!(snapshot);
+}
+
+// Tests that lightweight forking that does not copy the memory but retains the
+// open file descriptors works correctly.
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_vfork() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/example-vfork.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+// Tests that lightweight forking that does not copy the memory but retains the
+// open file descriptors works correctly. Uses asynchronous threading
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_vfork_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-vfork.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_signals() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/example-signal.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_signals_async() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .with_async_threads()
+        .run_wasm(include_bytes!("./wasm/example-signal.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg(target_os = "linux")]
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_echo() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("echo 2")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_echo_to_cat() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .stdin_str("echo hello | cat")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_python() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .include_static_package("syrusakbary/python@0.1.0", WEBC_PYTHON)
+        .stdin_str("wasmer run syrusakbary/python -- -c 'print(10)'")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_python_3_11_3() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .arg("-c")
+        .arg("print(10)")
+        .run_wasm(include_bytes!("./wasm/python-3.11.3.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_dev_zero() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .stdin_str("head -c 10 /dev/zero")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_dev_urandom() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .stdin_str("head -c 10 /dev/urandom | wc -c")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_dash() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_dash()
+        .stdin_str("/bin/dash\necho hi\nexit\nexit\n")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_dash_bash() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_bash()
+        .stdin_str("/bin/bash\necho hi\nexit\nexit\n")
+        .run_wasm(include_bytes!("./wasm/dash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_echo() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("echo hello\n")
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_ls() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("ls\nexit\n")
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_cd_ls() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("cd bin\nls\nexit\n")
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_pipe() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("echo hello | cat\nexit\n")
+        .use_coreutils()
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_python() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_coreutils()
+        .include_static_package("syrusakbary/python@0.1.0", WEBC_PYTHON)
+        .stdin_str("wasmer run syrusakbary/python -- -c 'print(10)'\n")
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_bash() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("/bin/bash\necho hi\nexit\necho hi2\n")
+        .use_bash()
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_bash_dash() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .use_dash()
+        .stdin_str("/bin/dash\necho hi\nexit\nexit\n")
+        .run_wasm(include_bytes!("./wasm/bash.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_catsay() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("meoooww")
+        .run_wasm(include_bytes!("./wasm/catsay.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_quickjs() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .stdin_str("print(2+2);\n\\q\n")
+        .run_wasm(include_bytes!("./wasm/qjs.wasm"));
+    assert_json_snapshot!(snapshot);
+}
+
+#[cfg_attr(any(target_env = "musl", target_os = "windows"), ignore)]
+#[test]
+fn test_snapshot_fs_rename() {
+    let snapshot = TestBuilder::new()
+        .with_name(function!())
+        .run_wasm(include_bytes!("./wasm/fs-rename.wasm"));
+    assert_json_snapshot!(snapshot);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_bash.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_bash.snap
new file mode 100644
index 0000000..8d3ed12
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_bash.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_bash",
+    "use_packages": [
+      "sharrattj/bash"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/bash@1.0.12"
+      },
+      {
+        "name": "sharrattj/coreutils@1.0.11"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "eb83da76ee5fbab28288ecf6385c69db",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\nhi2\n",
+      "stderr": "test.wasm-5.1# bash-5.1# bash-5.1# exit\ntest.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_cd_ls.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_cd_ls.snap
new file mode 100644
index 0000000..ff3c1de
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_cd_ls.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_cd_ls",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "862caddcc944cee7b673a57ec2f866e5",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "arch\nbase32\nbase64\nbaseenc\nbasename\ncat\nchcon\nchgrp\nchmod\nchown\nchroot\ncksum\ncomm\ncp\ncsplit\ncut\ndate\ndd\ndf\ndircolors\ndirname\ndu\necho\nenv\nexpand\nexpr\nfactor\nfalse\nfmt\nfold\ngroups\nhashsum\nhead\nhostid\nhostname\nid\ninstall\njoin\nkill\nlink\nln\nlogname\nls\nmkdir\nmkfifo\nmknod\nmktemp\nmore\nmv\nnice\nnl\nnohup\nnproc\nnumfmt\nod\npaste\npathchk\npinky\npr\nprintenv\nprintf\nptx\npwd\nreadlink\nrealpath\nrelpath\nrm\nrmdir\nruncon\nseq\nsh\nshred\nshuf\nsleep\nsort\nsplit\nstat\nstdbuf\nsum\nsync\ntac\ntail\ntee\ntest\ntimeout\ntouch\ntr\ntrue\ntruncate\ntsort\ntty\nuname\nunexpand\nuniq\nunlink\nuptime\nusers\nwasmer\nwc\nwho\nwhoami\nyes\n",
+      "stderr": "test.wasm-5.1# test.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_dash.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_dash.snap
new file mode 100644
index 0000000..7b88455
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_dash.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_dash",
+    "use_packages": [
+      "sharrattj/dash"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/dash@1.0.16"
+      },
+      {
+        "name": "sharrattj/coreutils@1.0.11"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "702da725f176c20024965c8830b620ae",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\n",
+      "stderr": "test.wasm-5.1# # # test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_echo.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_echo.snap
new file mode 100644
index 0000000..9ce6021
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_echo.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_echo",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "stdin_hash": "664d0430ee33458602e580520841a2d4",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hello\n",
+      "stderr": "test.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_ls.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_ls.snap
new file mode 100644
index 0000000..4a4bd67
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_ls.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_ls",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "ceb5d83a0368a10c813f8e05c42a3a7d",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "bin\ndev\netc\ntmp\nusr\n",
+      "stderr": "test.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_pipe.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_pipe.snap
new file mode 100644
index 0000000..0d633da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_pipe.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_pipe",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "d83523479d9f84e9f94230d5aed27347",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hello\n",
+      "stderr": "test.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_python.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_python.snap
new file mode 100644
index 0000000..7b319ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_bash_python.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_bash_python",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      },
+      {
+        "name": "syrusakbary/python@0.1.0"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "bda2b0db976f1724ef16ae1491211d52",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "10\n",
+      "stderr": "test.wasm-5.1# test.wasm-5.1# exit\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_catsay.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_catsay.snap
new file mode 100644
index 0000000..4b830b7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_catsay.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_catsay",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "stdin_hash": "ed17ce0ab9af325cceb217a26ee9b8a1",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": " _________ \n< meoooww >\n --------- \n  \\                              _\n   \\                            | \\\n    \\                           | |\n     \\                          | |\n      \\    |\\                   | |\n       \\  /, ~\\                / /\n         X     `-.....-------./ /\n          ~-. ~  ~              |\n             \\             /    |\n              \\  /_     ___\\   /\n              | /\\ ~~~~~   \\ |\n              | | \\        || |\n              | |\\ \\       || )\n             (_/ (_/      ((_/\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar.snap
new file mode 100644
index 0000000..22042d2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_condvar",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "condvar1 thread spawn\ncondvar1 thread started\ncondvar1 thread sleep(1sec) start\ncondvar loop\ncondvar wait\ncondvar1 thread sleep(1sec) end\ncondvar1 thread set condition\ncondvar1 thread notify\ncondvar woken\ncondvar parent done\ncondvar1 thread exit\nall done\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar_async.snap
new file mode 100644
index 0000000..468efca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_condvar_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_condvar_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "condvar1 thread spawn\ncondvar1 thread started\ncondvar1 thread sleep(1sec) start\ncondvar loop\ncondvar wait\ncondvar1 thread sleep(1sec) end\ncondvar1 thread set condition\ncondvar1 thread notify\ncondvar woken\ncondvar parent done\ncondvar1 thread exit\nall done\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_cowsay.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_cowsay.snap
new file mode 100644
index 0000000..c779056
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_cowsay.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_cowsay",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "stdin_hash": "0d599f0ec05c3bda8c3b8a68c32a1b47",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": " ______\n< blah >\n ------\n        \\   ^__^\n         \\  (oo)\\_______\n            (__)\\       )\\/\\\n               ||----w |\n                ||     ||\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_bash.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_bash.snap
new file mode 100644
index 0000000..0524458
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_bash.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_bash",
+    "use_packages": [
+      "sharrattj/bash"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/bash@1.0.12"
+      },
+      {
+        "name": "sharrattj/coreutils@1.0.11"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "31837f6a5667cb17dd97f274b20281bb",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\n",
+      "stderr": "# bash-5.1# exit\n# # ",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dash.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dash.snap
new file mode 100644
index 0000000..fef3870
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dash.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_dash",
+    "use_packages": [
+      "sharrattj/dash"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/dash@1.0.16"
+      },
+      {
+        "name": "sharrattj/coreutils@1.0.11"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "702da725f176c20024965c8830b620ae",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\n",
+      "stderr": "# # \n# # ",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_urandom.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_urandom.snap
new file mode 100644
index 0000000..eac5087
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_urandom.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_dev_urandom",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "80a57e78213b40607259d3909a44b0cf",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "10\n",
+      "stderr": "# # \n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_zero.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_zero.snap
new file mode 100644
index 0000000..3c099d0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_dev_zero.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_dev_zero",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "a911ff36e7a2d67baba7c3dcb45ac5c9",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000",
+      "stderr": "# # \n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo.snap
new file mode 100644
index 0000000..9fb5500
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_echo",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "stdin_hash": "f21e64a91c2b4c628da60b9a6ef26c46",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "2\n",
+      "stderr": "# # \n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo_to_cat.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo_to_cat.snap
new file mode 100644
index 0000000..7d48959
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_echo_to_cat.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_echo_to_cat",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "4a75babacd4e06efe6c6594a2864f61f",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hello\n",
+      "stderr": "# # \n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_python.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_python.snap
new file mode 100644
index 0000000..12569ae
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_dash_python.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_dash_python",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      },
+      {
+        "name": "syrusakbary/python@0.1.0"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "56c581e32481cdbf1d70227f3c4b1a84",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "10\n",
+      "stderr": "# # \n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_default_file_system_tree.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_default_file_system_tree.snap
new file mode 100644
index 0000000..9f89403
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_default_file_system_tree.snap
@@ -0,0 +1,23 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_default_file_system_tree",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "ls"
+    ],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "bin\ndev\netc\ntmp\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll.snap
new file mode 100644
index 0000000..db55c60
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_epoll",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "EFD_NONBLOCK:4\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll_async.snap
new file mode 100644
index 0000000..6b7bc10
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_epoll_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_epoll_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "EFD_NONBLOCK:4\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\nsuccess write to efd, write 8 bytes(4)\nsuccess read from efd, read 8 bytes(4)\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve.snap
new file mode 100644
index 0000000..58b48f3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_execve",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "Main program started\nexecve: echo hi-from-child\nhi-from-child\nhi-from-parent\n",
+      "stderr": "Child(2) exited with 0\nexecve: echo hi-from-parent\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve_async.snap
new file mode 100644
index 0000000..c829281
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_execve_async.snap
@@ -0,0 +1,30 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 381
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_execve_async",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "debug_output": false,
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "Main program started\nexecve: echo hi-from-child\nhi-from-child\nChild(2) exited with 0\nexecve: echo hi-from-parent\nhi-from-parent\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_file_copy.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_file_copy.snap
new file mode 100644
index 0000000..fdc0f77
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_file_copy.snap
@@ -0,0 +1,31 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_file_copy",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [
+      "/dev/stdin",
+      "/dev/stdout"
+    ],
+    "stdin_hash": "49f68a5c8493ec2c0bf489821c21fc3b",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork.snap
new file mode 100644
index 0000000..dd5d128
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_fork",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent has x = 0\nParent memory is good\nChild(2) exited with 3\n",
+      "stderr": "Child has x = 2\nChild memory is good\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec.snap
new file mode 100644
index 0000000..ec95ba7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_fork_and_exec",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "Main program started\nexecve: echo hi-from-child\nhi-from-child\nhi-from-parent\n",
+      "stderr": "Child(2) exited with 0\nexecve: echo hi-from-parent\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec_async.snap
new file mode 100644
index 0000000..4c22fb4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_and_exec_async.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_fork_and_exec_async",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "Main program started\nexecve: echo hi-from-child\nhi-from-child\nhi-from-parent\n",
+      "stderr": "Child(2) exited with 0\nexecve: echo hi-from-parent\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_async.snap
new file mode 100644
index 0000000..2b0d9c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fork_async.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_fork_async",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent has x = 0\nParent memory is good\nChild(2) exited with 3\n",
+      "stderr": "Child has x = 2\nChild memory is good\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fs_rename.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fs_rename.snap
new file mode 100644
index 0000000..f50db20
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_fs_rename.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_fs_rename",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "/test-dir/a:a\n/test-dir/b:a\n/test-dir/c:c\n/test-dir/d:c\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump.snap
new file mode 100644
index 0000000..b31aa8b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_longjump",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "(A1)\n(A2) r=10001\n(A3) r=10002\n(A4) r=10003\n",
+      "stderr": "(B1)\n(B2) r=20001\n(B3) r=20002\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork.snap
new file mode 100644
index 0000000..45761ca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_longjump_fork",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent memory is good\nParent memory after longjmp is good\nParent has x = 0\nChild(2) exited with 5\n",
+      "stderr": "Child memory is good\nChild memory after longjmp is good\nChild has x = 2\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork_async.snap
new file mode 100644
index 0000000..6bf455e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_longjump_fork_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_longjump_fork_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent memory is good\nParent memory after longjmp is good\nParent has x = 0\nChild(2) exited with 5\n",
+      "stderr": "Child memory is good\nChild memory after longjmp is good\nChild has x = 2\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_rx.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_rx.snap
new file mode 100644
index 0000000..299f111
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_rx.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_minimodem_rx",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "--rx",
+      "--tx-carrier",
+      "--stdio",
+      "--float-samples",
+      "same"
+    ],
+    "stdin_hash": "eeaf940b4ae9db7eb9a4f45a24989a57",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "This message wont get through\n",
+      "stderr": "### CARRIER 521 @ 2083.3 Hz ###\n\n### NOCARRIER ndata=46 confidence=140169.578 ampl=45.976 bps=521.03 (0.0% fast) ###\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_tx.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_tx.snap
new file mode 100644
index 0000000..963f4f4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_minimodem_tx.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_minimodem_tx",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "--tx",
+      "--tx-carrier",
+      "--stdio",
+      "--float-samples",
+      "same"
+    ],
+    "stdin_hash": "efbbebc40e07bc2365088f9506f8a5d1",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hash: 50e55400b51b975eab31f31cb07419fd",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading.snap
new file mode 100644
index 0000000..8dd6958
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_multithreading",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "thread 1 started\nthread 2 started\nthread 3 started\nthread 4 started\nthread 5 started\nthread 6 started\nthread 7 started\nthread 8 started\nthread 9 started\nwaiting for threads\nthread 1 finished\nthread 2 finished\nthread 3 finished\nthread 4 finished\nthread 5 finished\nthread 6 finished\nthread 7 finished\nthread 8 finished\nthread 9 finished\nall done\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading_async.snap
new file mode 100644
index 0000000..9a0ae73
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_multithreading_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_multithreading_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "thread 1 started\nthread 2 started\nthread 3 started\nthread 4 started\nthread 5 started\nthread 6 started\nthread 7 started\nthread 8 started\nthread 9 started\nwaiting for threads\nthread 1 finished\nthread 2 finished\nthread 3 finished\nthread 4 finished\nthread 5 finished\nthread 6 finished\nthread 7 finished\nthread 8 finished\nthread 9 finished\nall done\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_pipes.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_pipes.snap
new file mode 100644
index 0000000..f1d1616
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_pipes.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_pipes",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "this text should be printed by the parent\n",
+      "stderr": "this text should be printed by the child\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn.snap
new file mode 100644
index 0000000..753813f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_process_spawn",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\n",
+      "stderr": "Child pid: 2\nChild status 0\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn_async.snap
new file mode 100644
index 0000000..680d134
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_process_spawn_async.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_process_spawn_async",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "hi\n",
+      "stderr": "Child pid: 2\nChild status 0\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_python_3_11_3.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_python_3_11_3.snap
new file mode 100644
index 0000000..0761c7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_python_3_11_3.snap
@@ -0,0 +1,25 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 1093
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_python_3_11_3",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "-c",
+      "print(10)"
+    ],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "10\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_quickjs.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_quickjs.snap
new file mode 100644
index 0000000..c6dc1a1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_quickjs.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_quickjs",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "stdin_hash": "7b1ec18c69fb609403f75c6e673f2d33",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "QuickJS - Type \"\\h\" for help\nqjs > \u001b[32;1mp\u001b[0m\u001b[J\u001b[D\u001b[32;1mpr\u001b[0m\u001b[J\u001b[2D\u001b[32;1mpri\u001b[0m\u001b[J\u001b[3D\u001b[32;1mprin\u001b[0m\u001b[J\u001b[4D\u001b[32;1mprint\u001b[0m\u001b[J\u001b[5D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[J\u001b[6D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[32m2\u001b[0m\u001b[J\u001b[7D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m+\u001b[0m\u001b[J\u001b[8D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m+\u001b[0m\u001b[32m2\u001b[0m\u001b[J\u001b[9D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m+\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m)\u001b[0m\u001b[J\u001b[10D\u001b[33;1mprint\u001b[0m\u001b[32;1m(\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m+\u001b[0m\u001b[32m2\u001b[0m\u001b[32;1m);\u001b[0m\u001b[J\n4\n\u001b[37;1mundefined\n\u001b[0mqjs > \u001b[32;1m\\\u001b[0m\u001b[J\u001b[D\u001b[32;1m\\\u001b[0m\u001b[32;1mq\u001b[0m\u001b[J\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_readdir_tree.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_readdir_tree.snap
new file mode 100644
index 0000000..64adb78
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_readdir_tree.snap
@@ -0,0 +1,29 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_readdir_tree",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [
+      "/"
+    ],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "/\n  .app:\n  .private:\n  bin:\n    arch\n    base32\n    base64\n    baseenc\n    basename\n    cat\n    chcon\n    chgrp\n    chmod\n    chown\n    chroot\n    cksum\n    comm\n    cp\n    csplit\n    cut\n    date\n    dd\n    df\n    dircolors\n    dirname\n    du\n    echo\n    env\n    expand\n    expr\n    factor\n    false\n    fmt\n    fold\n    groups\n    hashsum\n    head\n    hostid\n    hostname\n    id\n    install\n    join\n    kill\n    link\n    ln\n    logname\n    ls\n    mkdir\n    mkfifo\n    mknod\n    mktemp\n    more\n    mv\n    nice\n    nl\n    nohup\n    nproc\n    numfmt\n    od\n    paste\n    pathchk\n    pinky\n    pr\n    printenv\n    printf\n    ptx\n    pwd\n    readlink\n    realpath\n    relpath\n    rm\n    rmdir\n    runcon\n    seq\n    sh\n    shred\n    shuf\n    sleep\n    sort\n    split\n    stat\n    stdbuf\n    sum\n    sync\n    tac\n    tail\n    tee\n    test\n    timeout\n    touch\n    tr\n    true\n    truncate\n    tsort\n    tty\n    uname\n    unexpand\n    uniq\n    unlink\n    uptime\n    users\n    wasmer\n    wc\n    who\n    whoami\n    yes\n  dev:\n    null\n    stderr\n    stdin\n    stdout\n    tty\n    urandom\n    zero\n  etc:\n  tmp:\n  usr:\n    coreutils:\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals.snap
new file mode 100644
index 0000000..0ccba61
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_signals",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "received SIGHUP\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals_async.snap
new file mode 100644
index 0000000..8dcea22
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_signals_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_signals_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "received SIGHUP\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep.snap
new file mode 100644
index 0000000..62ae583
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_sleep",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "before\ndone\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep_async.snap
new file mode 100644
index 0000000..ddfed6d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_sleep_async.snap
@@ -0,0 +1,22 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_sleep_async",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "before\ndone\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_stdin_stdout_stderr.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_stdin_stdout_stderr.snap
new file mode 100644
index 0000000..7ea4f5c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_stdin_stdout_stderr.snap
@@ -0,0 +1,25 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_stdin_stdout_stderr",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "tee",
+      "/dev/stderr"
+    ],
+    "stdin_hash": "6f1ed002ab5595859014ebf0951522d9",
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "blah",
+      "stderr": "blah",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tcp_client.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tcp_client.snap
new file mode 100644
index 0000000..fbe7f50
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tcp_client.snap
@@ -0,0 +1,23 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": null,
+    "wasm_hash": "1ed22ea4a1af6d569d6deadc3ba93364",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "cli_args": [],
+    "debug_output": false,
+    "enable_threads": true,
+  },
+  "result": {
+    "Success": {
+      "stdout": "Successfully connected to server in port 53\nFinished.\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_thread_locals.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_thread_locals.snap
new file mode 100644
index 0000000..9c3bc7f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_thread_locals.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_thread_locals",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_threaded_memory.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_threaded_memory.snap
new file mode 100644
index 0000000..11024a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_threaded_memory.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_threaded_memory",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "thread 1 started\nincrementing counter (val=0)\nthread 2 started\nincrementing counter (val=1)\nthread 3 started\nincrementing counter (val=2)\nthread 4 started\nincrementing counter (val=3)\nthread 5 started\nincrementing counter (val=4)\nthread 6 started\nincrementing counter (val=5)\nthread 7 started\nincrementing counter (val=6)\nthread 8 started\nincrementing counter (val=7)\nthread 9 started\nincrementing counter (val=8)\nwaiting for threads\nthread 1 finished\nthread 2 finished\nthread 3 finished\nthread 4 finished\nthread 5 finished\nthread 6 finished\nthread 7 finished\nthread 8 finished\nthread 9 finished\nall done\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tokio.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tokio.snap
new file mode 100644
index 0000000..604057d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_tokio.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_tokio",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "step-B1\nstep-B2\nstep-B3\nstep-B4\n",
+      "stderr": "step-1\nreceived ErrorKind::WouldBlock - receiving on an empty channel\nstep-2\nstep-3\ndata match verified (len=128)\nstep-4\nreceived ErrorKind::WouldBlock - receiving on an empty channel\nstep-5\nstep-A1\nstep-A2\ndata match verified (len=128)\nstep-A3\nstep-A4\ndata match verified (len=128)\nstep-A5\nreceived ErrorKind::WouldBlock - receiving on an empty channel\nstep-A6\nstep-A7\nreceived ErrorKind::WouldBlock - receiving on an empty channel\nstep-A8\nall done\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_unix_pipe.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_unix_pipe.snap
new file mode 100644
index 0000000..6a5e973
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_unix_pipe.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_unix_pipe",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "all done\n",
+      "stderr": "received ErrorKind::WouldBlock\ndata matche verified (len=128)\nreceived ErrorKind::WouldBlock\ndata matche verified (len=128)\n",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork.snap
new file mode 100644
index 0000000..c241ef7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork.snap
@@ -0,0 +1,27 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_vfork",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent waiting on Child(2)\nChild(2) exited with 10\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork_async.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork_async.snap
new file mode 100644
index 0000000..f8ecb0a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_vfork_async.snap
@@ -0,0 +1,28 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_vfork_async",
+    "use_packages": [
+      "sharrattj/coreutils"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "Parent waiting on Child(2)\nChild(2) exited with 10\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_wasi_threads.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_wasi_threads.snap
new file mode 100644
index 0000000..e1dfbd0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_wasi_threads.snap
@@ -0,0 +1,21 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_wasi_threads",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [],
+    "enable_threads": true,
+    "enable_network": false
+  },
+  "result": {
+    "Success": {
+      "stdout": "x = 1\ny = 0\nz = 0\n",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server.snap
new file mode 100644
index 0000000..e930894
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server.snap
@@ -0,0 +1,36 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 739
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_web_server",
+    "use_packages": [
+      "sharrattj/coreutils",
+      "sharrattj/wasmer-sh"
+    ],
+    "include_webcs": [
+      {
+        "name": "sharrattj/static-web-server@1.0.92"
+      },
+      {
+        "name": "sharrattj/wasmer-sh@1.0.63"
+      },
+      {
+        "name": "sharrattj/coreutils@1.0.16"
+      }
+    ],
+    "cli_args": [],
+    "stdin_hash": "ea308175bb22236a4c3ab8ac6643d3ce",
+    "enable_threads": true,
+    "enable_network": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "# # # # # ",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_epoll.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_epoll.snap
new file mode 100644
index 0000000..617d71e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_epoll.snap
@@ -0,0 +1,30 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+assertion_line: 772
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_web_server_epoll",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "--root",
+      "/dev",
+      "--log-level",
+      "warn",
+      "--port",
+      "7778"
+    ],
+    "enable_threads": true,
+    "enable_network": true,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_poll.snap b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_poll.snap
new file mode 100644
index 0000000..4948b85
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/snapshots/snapshot__snapshot_web_server_poll.snap
@@ -0,0 +1,29 @@
+---
+source: tests/integration/cli/tests/snapshot.rs
+expression: snapshot
+---
+{
+  "spec": {
+    "name": "snapshot::test_snapshot_web_server_poll",
+    "use_packages": [],
+    "include_webcs": [],
+    "cli_args": [
+      "--root",
+      "/dev",
+      "--log-level",
+      "warn",
+      "--port",
+      "7779"
+    ],
+    "enable_threads": true,
+    "enable_network": true,
+    "enable_async_threads": true
+  },
+  "result": {
+    "Success": {
+      "stdout": "",
+      "stderr": "",
+      "exit_code": 0
+    }
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/bash.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/bash.wasm
new file mode 100644
index 0000000..364a0fd
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/bash.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/catsay.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/catsay.wasm
new file mode 100755
index 0000000..bb103f0
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/catsay.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/coreutils.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/coreutils.wasm
new file mode 100755
index 0000000..e5b7685
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/coreutils.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/cowsay.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/cowsay.wasm
new file mode 100755
index 0000000..073f7a7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/cowsay.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/dash.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/dash.wasm
new file mode 100755
index 0000000..268d91a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/dash.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-condvar.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-condvar.wasm
new file mode 100755
index 0000000..493cb20
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-condvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-epoll.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-epoll.wasm
new file mode 100644
index 0000000..c80447d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-epoll.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-execve.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-execve.wasm
new file mode 100644
index 0000000..9444f76
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-execve.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-file-copy.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-file-copy.wasm
new file mode 100644
index 0000000..a1577ce
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-file-copy.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork-longjmp.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork-longjmp.wasm
new file mode 100644
index 0000000..532a887
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork-longjmp.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork.wasm
new file mode 100755
index 0000000..83b45f5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-fork.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-http-ok.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-http-ok.wasm
new file mode 100644
index 0000000..3e2def3
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-http-ok.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-longjmp.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-longjmp.wasm
new file mode 100755
index 0000000..ae48607
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-longjmp.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-multi-threading.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-multi-threading.wasm
new file mode 100644
index 0000000..e0c82b1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-multi-threading.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-pipe.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-pipe.wasm
new file mode 100644
index 0000000..1f94e45
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-pipe.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-readdir_tree.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-readdir_tree.wasm
new file mode 100644
index 0000000..4cc30ce
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-readdir_tree.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-signal.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-signal.wasm
new file mode 100755
index 0000000..52dcbda
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-signal.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-sleep.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-sleep.wasm
new file mode 100644
index 0000000..769f8f4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-sleep.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-spawn.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-spawn.wasm
new file mode 100644
index 0000000..4690183
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-spawn.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-stack.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-stack.wasm
new file mode 100755
index 0000000..3cf2ddb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-stack.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-client.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-client.wasm
new file mode 100644
index 0000000..98ab0db
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-client.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-listener.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-listener.wasm
new file mode 100644
index 0000000..d2da83a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tcp-listener.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-thread-local.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-thread-local.wasm
new file mode 100644
index 0000000..767be4a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-thread-local.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tokio.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tokio.wasm
new file mode 100644
index 0000000..77b1a65
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-tokio.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-unix-pipe.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-unix-pipe.wasm
new file mode 100644
index 0000000..b415f6c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-unix-pipe.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-vfork.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-vfork.wasm
new file mode 100644
index 0000000..7818145
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/example-vfork.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/fs-rename.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/fs-rename.wasm
new file mode 100644
index 0000000..a4c99b5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/fs-rename.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/kibi.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/kibi.wasm
new file mode 100644
index 0000000..bbe14d6
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/kibi.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.data b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.data
new file mode 100644
index 0000000..4519656
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.data differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.wasm
new file mode 100644
index 0000000..83bcf0b
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/minimodem.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/mother.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/mother.wasm
new file mode 100644
index 0000000..f4fe3a4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/mother.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/multi-threading.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/multi-threading.wasm
new file mode 100644
index 0000000..64a4ebe
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/multi-threading.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/python-3.11.3.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/python-3.11.3.wasm
new file mode 100644
index 0000000..afc10f7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/python-3.11.3.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/qjs.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/qjs.wasm
new file mode 100755
index 0000000..3c51223
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/qjs.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/stdin-hello.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/stdin-hello.wasm
new file mode 100644
index 0000000..5974bcb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/stdin-hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/threaded-memory.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/threaded-memory.wasm
new file mode 100644
index 0000000..2d636fe
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/threaded-memory.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/wasi-threads.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/wasi-threads.wasm
new file mode 100644
index 0000000..54c3977
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/wasi-threads.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-epoll.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-epoll.wasm
new file mode 100755
index 0000000..5056b86
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-epoll.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-poll.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-poll.wasm
new file mode 100755
index 0000000..e2b9de9
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/wasm/web-server-poll.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc
new file mode 100644
index 0000000..2382fca
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/bash-1.0.16-f097441a-a80b-4e0d-87d7-684918ef4bb6.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc
new file mode 100644
index 0000000..68f1a5f
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.11-9d7746ca-694f-11ed-b932-dead3543c068.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc
new file mode 100644
index 0000000..fa5bd07
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/coreutils-1.0.16-e27dbb4f-2ef2-4b44-b46a-ddd86497c6d7.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/dash-1.0.18-f0d13233-bcda-4cf1-9a23-3460bffaae2a.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/dash-1.0.18-f0d13233-bcda-4cf1-9a23-3460bffaae2a.webc
new file mode 100644
index 0000000..2e3e537
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/dash-1.0.18-f0d13233-bcda-4cf1-9a23-3460bffaae2a.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/hello-0.1.0-665d2ddc-80e6-4845-85d3-4587b1693bb7.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/hello-0.1.0-665d2ddc-80e6-4845-85d3-4587b1693bb7.webc
new file mode 100644
index 0000000..b612265
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/hello-0.1.0-665d2ddc-80e6-4845-85d3-4587b1693bb7.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/python-0.1.0.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/python-0.1.0.webc
new file mode 100644
index 0000000..43eeccc
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/python-0.1.0.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-1.0.96-e2b80276-c194-473d-bbd0-27c8a2c96a59.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-1.0.96-e2b80276-c194-473d-bbd0-27c8a2c96a59.webc
new file mode 100644
index 0000000..4d6641e
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-1.0.96-e2b80276-c194-473d-bbd0-27c8a2c96a59.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-async-1.0.3-5d739d1a-20b7-4edf-8cf4-44e813f96b25.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-async-1.0.3-5d739d1a-20b7-4edf-8cf4-44e813f96b25.webc
new file mode 100644
index 0000000..9b80792
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/static-web-server-async-1.0.3-5d739d1a-20b7-4edf-8cf4-44e813f96b25.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/wasmer-sh-1.0.63-dd3d67d1-de94-458c-a9ee-caea3b230ccf.webc b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/wasmer-sh-1.0.63-dd3d67d1-de94-458c-a9ee-caea3b230ccf.webc
new file mode 100644
index 0000000..7293f0c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/integration/cli/tests/webc/wasmer-sh-1.0.63-dd3d67d1-de94-458c-a9ee-caea3b230ccf.webc differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/.gitignore
new file mode 100644
index 0000000..55e8065
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/.gitignore
@@ -0,0 +1,37 @@
+### Xcode ###
+# Xcode
+#
+# gitignore contributors: remember to update Global/Xcode.gitignore, Objective-C.gitignore & Swift.gitignore
+
+## User settings
+xcuserdata/
+
+## compatibility with Xcode 8 and earlier (ignoring not required starting Xcode 9)
+*.xcscmblueprint
+*.xccheckout
+
+## compatibility with Xcode 3 and earlier (ignoring not required starting Xcode 4)
+build/
+DerivedData/
+*.moved-aside
+*.pbxuser
+!default.pbxuser
+*.mode1v3
+!default.mode1v3
+*.mode2v3
+!default.mode2v3
+*.perspectivev3
+!default.perspectivev3
+
+## Gcc Patch
+/*.gcno
+
+### Xcode Patch ###
+*.xcodeproj/*
+!*.xcodeproj/project.pbxproj
+!*.xcodeproj/xcshareddata/
+!*.xcworkspace/contents.xcworkspacedata
+**/xcshareddata/WorkspaceSettings.xcsettings
+
+# Artifacts from iOS tests
+**/*.dylib
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/Cargo.toml
new file mode 100644
index 0000000..3fd303c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "wasmer-integration-tests-ios"
+version = "4.2.8"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+description = "iOS integration tests"
+repository = "https://github.com/wasmerio/wasmer"
+edition = "2018"
+publish = false
+
+[features]
+default = ["webc_runner"]
+webc_runner = []
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.pbxproj b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.pbxproj
new file mode 100644
index 0000000..21a1535
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.pbxproj
@@ -0,0 +1,604 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 54;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		6315FBEE26CC45F10059CE47 /* calc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6315FBEC26CC45F10059CE47 /* calc.cpp */; };
+		63CD62C426C9492100424C7A /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 63CD62C326C9492100424C7A /* AppDelegate.swift */; };
+		63CD62C626C9492100424C7A /* SceneDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 63CD62C526C9492100424C7A /* SceneDelegate.swift */; };
+		63CD62C826C9492100424C7A /* ViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = 63CD62C726C9492100424C7A /* ViewController.swift */; };
+		63CD62CB26C9492100424C7A /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 63CD62C926C9492100424C7A /* Main.storyboard */; };
+		63CD62CD26C9492400424C7A /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 63CD62CC26C9492400424C7A /* Assets.xcassets */; };
+		63CD62D026C9492400424C7A /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 63CD62CE26C9492400424C7A /* LaunchScreen.storyboard */; };
+		63CD62DB26C9492400424C7A /* DylibExampleTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 63CD62DA26C9492400424C7A /* DylibExampleTests.swift */; };
+		63CD62FB26C94F4700424C7A /* libwasmer.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 63CD62F826C94EB600424C7A /* libwasmer.a */; };
+		63CD62FF26C952CC00424C7A /* sum.wasm in Resources */ = {isa = PBXBuildFile; fileRef = 63CD62FE26C952CC00424C7A /* sum.wasm */; };
+		63CD630126C9541E00424C7A /* sum.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 63CD630026C9541E00424C7A /* sum.dylib */; };
+		63CD630226C9541E00424C7A /* sum.dylib in Embed .dylib in App bundle */ = {isa = PBXBuildFile; fileRef = 63CD630026C9541E00424C7A /* sum.dylib */; settings = {ATTRIBUTES = (CodeSignOnCopy, ); }; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		63CD62D726C9492400424C7A /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 63CD62B826C9492100424C7A /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 63CD62BF26C9492100424C7A;
+			remoteInfo = DylibExample;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		63CD630326C9541E00424C7A /* Embed .dylib in App bundle */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 12;
+			dstPath = "";
+			dstSubfolderSpec = 6;
+			files = (
+				63CD630226C9541E00424C7A /* sum.dylib in Embed .dylib in App bundle */,
+			);
+			name = "Embed .dylib in App bundle";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		6311890B26CBAD2C007746B2 /* sum.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = sum.dylib; path = DylibExample/sum.dylib; sourceTree = "<group>"; };
+		6315FBEC26CC45F10059CE47 /* calc.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = calc.cpp; sourceTree = "<group>"; };
+		6315FBED26CC45F10059CE47 /* calc.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = calc.h; sourceTree = "<group>"; };
+		63CD62C026C9492100424C7A /* DylibExample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = DylibExample.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		63CD62C326C9492100424C7A /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		63CD62C526C9492100424C7A /* SceneDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SceneDelegate.swift; sourceTree = "<group>"; };
+		63CD62C726C9492100424C7A /* ViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ViewController.swift; sourceTree = "<group>"; };
+		63CD62CA26C9492100424C7A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		63CD62CC26C9492400424C7A /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		63CD62CF26C9492400424C7A /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		63CD62D126C9492400424C7A /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		63CD62D626C9492400424C7A /* DylibExampleTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = DylibExampleTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		63CD62DA26C9492400424C7A /* DylibExampleTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DylibExampleTests.swift; sourceTree = "<group>"; };
+		63CD62DC26C9492400424C7A /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		63CD62F426C94D6000424C7A /* DylibExample-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "DylibExample-Bridging-Header.h"; sourceTree = "<group>"; };
+		63CD62F826C94EB600424C7A /* libwasmer.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libwasmer.a; path = ../../../../target/universal/release/libwasmer.a; sourceTree = "<group>"; };
+		63CD62FE26C952CC00424C7A /* sum.wasm */ = {isa = PBXFileReference; lastKnownFileType = text; path = sum.wasm; sourceTree = "<group>"; };
+		63CD630026C9541E00424C7A /* sum.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = sum.dylib; path = DylibExample/sum.dylib; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		63CD62BD26C9492100424C7A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				63CD630126C9541E00424C7A /* sum.dylib in Frameworks */,
+				63CD62FB26C94F4700424C7A /* libwasmer.a in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		63CD62D326C9492400424C7A /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		63CD62B726C9492100424C7A = {
+			isa = PBXGroup;
+			children = (
+				6311890B26CBAD2C007746B2 /* sum.dylib */,
+				63CD62F826C94EB600424C7A /* libwasmer.a */,
+				63CD62C226C9492100424C7A /* DylibExample */,
+				63CD62D926C9492400424C7A /* DylibExampleTests */,
+				63CD62C126C9492100424C7A /* Products */,
+				63CD62FA26C94F4700424C7A /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		63CD62C126C9492100424C7A /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				63CD62C026C9492100424C7A /* DylibExample.app */,
+				63CD62D626C9492400424C7A /* DylibExampleTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		63CD62C226C9492100424C7A /* DylibExample */ = {
+			isa = PBXGroup;
+			children = (
+				63CD62C326C9492100424C7A /* AppDelegate.swift */,
+				63CD62C526C9492100424C7A /* SceneDelegate.swift */,
+				63CD62C726C9492100424C7A /* ViewController.swift */,
+				63CD62C926C9492100424C7A /* Main.storyboard */,
+				63CD62CC26C9492400424C7A /* Assets.xcassets */,
+				63CD62CE26C9492400424C7A /* LaunchScreen.storyboard */,
+				63CD62D126C9492400424C7A /* Info.plist */,
+				63CD62F426C94D6000424C7A /* DylibExample-Bridging-Header.h */,
+				63CD62FE26C952CC00424C7A /* sum.wasm */,
+				6315FBEC26CC45F10059CE47 /* calc.cpp */,
+				6315FBED26CC45F10059CE47 /* calc.h */,
+			);
+			path = DylibExample;
+			sourceTree = "<group>";
+		};
+		63CD62D926C9492400424C7A /* DylibExampleTests */ = {
+			isa = PBXGroup;
+			children = (
+				63CD62DA26C9492400424C7A /* DylibExampleTests.swift */,
+				63CD62DC26C9492400424C7A /* Info.plist */,
+			);
+			path = DylibExampleTests;
+			sourceTree = "<group>";
+		};
+		63CD62FA26C94F4700424C7A /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				63CD630026C9541E00424C7A /* sum.dylib */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		63CD62BF26C9492100424C7A /* DylibExample */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 63CD62EA26C9492400424C7A /* Build configuration list for PBXNativeTarget "DylibExample" */;
+			buildPhases = (
+				63CD62F326C94B1D00424C7A /* Build Headless Wasmer */,
+				63CD62FD26C951EF00424C7A /* Compile .wasm to .dylib */,
+				63CD62BC26C9492100424C7A /* Sources */,
+				63CD62BD26C9492100424C7A /* Frameworks */,
+				63CD62BE26C9492100424C7A /* Resources */,
+				63CD630326C9541E00424C7A /* Embed .dylib in App bundle */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = DylibExample;
+			productName = DylibExample;
+			productReference = 63CD62C026C9492100424C7A /* DylibExample.app */;
+			productType = "com.apple.product-type.application";
+		};
+		63CD62D526C9492400424C7A /* DylibExampleTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 63CD62ED26C9492400424C7A /* Build configuration list for PBXNativeTarget "DylibExampleTests" */;
+			buildPhases = (
+				63CD62D226C9492400424C7A /* Sources */,
+				63CD62D326C9492400424C7A /* Frameworks */,
+				63CD62D426C9492400424C7A /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				63CD62D826C9492400424C7A /* PBXTargetDependency */,
+			);
+			name = DylibExampleTests;
+			productName = DylibExampleTests;
+			productReference = 63CD62D626C9492400424C7A /* DylibExampleTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		63CD62B826C9492100424C7A /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 1250;
+				LastUpgradeCheck = 1250;
+				TargetAttributes = {
+					63CD62BF26C9492100424C7A = {
+						CreatedOnToolsVersion = 12.5;
+						LastSwiftMigration = 1250;
+					};
+					63CD62D526C9492400424C7A = {
+						CreatedOnToolsVersion = 12.5;
+						TestTargetID = 63CD62BF26C9492100424C7A;
+					};
+				};
+			};
+			buildConfigurationList = 63CD62BB26C9492100424C7A /* Build configuration list for PBXProject "DylibExample" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 63CD62B726C9492100424C7A;
+			productRefGroup = 63CD62C126C9492100424C7A /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				63CD62BF26C9492100424C7A /* DylibExample */,
+				63CD62D526C9492400424C7A /* DylibExampleTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		63CD62BE26C9492100424C7A /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				63CD62D026C9492400424C7A /* LaunchScreen.storyboard in Resources */,
+				63CD62CD26C9492400424C7A /* Assets.xcassets in Resources */,
+				63CD62CB26C9492100424C7A /* Main.storyboard in Resources */,
+				63CD62FF26C952CC00424C7A /* sum.wasm in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		63CD62D426C9492400424C7A /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		63CD62F326C94B1D00424C7A /* Build Headless Wasmer */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Build Headless Wasmer";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "#!/bin/bash\nexport PATH=$(bash -l -c 'echo $PATH')\ncd ../../../../\nmake build-wasmer\nmake build-capi-headless-ios\n";
+		};
+		63CD62FD26C951EF00424C7A /* Compile .wasm to .dylib */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputFileListPaths = (
+			);
+			inputPaths = (
+			);
+			name = "Compile .wasm to .dylib";
+			outputFileListPaths = (
+			);
+			outputPaths = (
+				"$(DERIVED_FILE_DIR)/sum.dylib",
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "export ARCH='x86_64-apple-ios'\nif [[ `uname -m` == 'arm64' ]]; then\n  export ARCH='aarch64-apple-ios-sim'\nfi\n\n\n./../../../../target/release/wasmer compile DylibExample/sum.wasm --target $ARCH --dylib  -o DylibExample/sum.dylib\n";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		63CD62BC26C9492100424C7A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				63CD62C826C9492100424C7A /* ViewController.swift in Sources */,
+				6315FBEE26CC45F10059CE47 /* calc.cpp in Sources */,
+				63CD62C426C9492100424C7A /* AppDelegate.swift in Sources */,
+				63CD62C626C9492100424C7A /* SceneDelegate.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		63CD62D226C9492400424C7A /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				63CD62DB26C9492400424C7A /* DylibExampleTests.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		63CD62D826C9492400424C7A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 63CD62BF26C9492100424C7A /* DylibExample */;
+			targetProxy = 63CD62D726C9492400424C7A /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		63CD62C926C9492100424C7A /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				63CD62CA26C9492100424C7A /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		63CD62CE26C9492400424C7A /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				63CD62CF26C9492400424C7A /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		63CD62E826C9492400424C7A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.5;
+				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
+				MTL_FAST_MATH = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+			};
+			name = Debug;
+		};
+		63CD62E926C9492400424C7A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_QUOTED_INCLUDE_IN_FRAMEWORK_HEADER = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu11;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.5;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				MTL_FAST_MATH = YES;
+				SDKROOT = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		63CD62EB26C9492400424C7A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ENABLE_MODULES = YES;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "";
+				ENABLE_BITCODE = NO;
+				EXCLUDED_ARCHS = "";
+				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
+				HEADER_SEARCH_PATHS = "../../../../lib/c-api/";
+				INFOPLIST_FILE = DylibExample/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = (
+					"../../../../target/universal/release/**",
+					"$(PROJECT_DIR)/DylibExample",
+				);
+				NEW_SETTING = "";
+				PATH = "/Users/nathanhorrigan/.wasmer/bin:/Users/nathanhorrigan/.cargo/bin:/Users/nathanhorrigan/Android/Sdk/tools:/Users/nathanhorrigan/Android/Sdk/tools/bin:/Users/nathanhorrigan/Android/Sdk/platform-tools:/Users/nathanhorrigan/.pyenv/shims:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin:/Users/nathanhorrigan/.wasmer/globals/wapm_packages/.bin";
+				PRODUCT_BUNDLE_IDENTIFIER = io.wasmer.DylibExample;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "DylibExample/DylibExample-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 1;
+			};
+			name = Debug;
+		};
+		63CD62EC26C9492400424C7A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				ASSETCATALOG_COMPILER_GLOBAL_ACCENT_COLOR_NAME = AccentColor;
+				CLANG_ENABLE_MODULES = YES;
+				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_STYLE = Automatic;
+				DEVELOPMENT_TEAM = "";
+				ENABLE_BITCODE = NO;
+				"EXCLUDED_ARCHS[sdk=iphonesimulator*]" = arm64;
+				HEADER_SEARCH_PATHS = "../../../../lib/c-api/";
+				INFOPLIST_FILE = DylibExample/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = (
+					"../../../../target/universal/release/**",
+					"$(PROJECT_DIR)/DylibExample",
+				);
+				NEW_SETTING = "";
+				PATH = "/Users/nathanhorrigan/.wasmer/bin:/Users/nathanhorrigan/.cargo/bin:/Users/nathanhorrigan/Android/Sdk/tools:/Users/nathanhorrigan/Android/Sdk/tools/bin:/Users/nathanhorrigan/Android/Sdk/platform-tools:/Users/nathanhorrigan/.pyenv/shims:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/Apple/usr/bin:/Users/nathanhorrigan/.wasmer/globals/wapm_packages/.bin";
+				PRODUCT_BUNDLE_IDENTIFIER = io.wasmer.DylibExample;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				SWIFT_OBJC_BRIDGING_HEADER = "DylibExample/DylibExample-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = 1;
+			};
+			name = Release;
+		};
+		63CD62EE26C9492400424C7A /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				HEADER_SEARCH_PATHS = "../../../../lib/c-api/**";
+				INFOPLIST_FILE = DylibExampleTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.5;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = "../../../../target/universal/release/**";
+				PRODUCT_BUNDLE_IDENTIFIER = io.wasmer.DylibExampleTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				"PROVISIONING_PROFILE_SPECIFIER[sdk=macosx*]" = "";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/DylibExample.app/DylibExample";
+			};
+			name = Debug;
+		};
+		63CD62EF26C9492400424C7A /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Manual;
+				DEVELOPMENT_TEAM = "";
+				HEADER_SEARCH_PATHS = "../../../../lib/c-api/**";
+				INFOPLIST_FILE = DylibExampleTests/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 14.5;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+					"@loader_path/Frameworks",
+				);
+				LIBRARY_SEARCH_PATHS = "../../../../target/universal/release/**";
+				PRODUCT_BUNDLE_IDENTIFIER = io.wasmer.DylibExampleTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PROVISIONING_PROFILE_SPECIFIER = "";
+				"PROVISIONING_PROFILE_SPECIFIER[sdk=macosx*]" = "";
+				SWIFT_VERSION = 5.0;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/DylibExample.app/DylibExample";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		63CD62BB26C9492100424C7A /* Build configuration list for PBXProject "DylibExample" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				63CD62E826C9492400424C7A /* Debug */,
+				63CD62E926C9492400424C7A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		63CD62EA26C9492400424C7A /* Build configuration list for PBXNativeTarget "DylibExample" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				63CD62EB26C9492400424C7A /* Debug */,
+				63CD62EC26C9492400424C7A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		63CD62ED26C9492400424C7A /* Build configuration list for PBXNativeTarget "DylibExampleTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				63CD62EE26C9492400424C7A /* Debug */,
+				63CD62EF26C9492400424C7A /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 63CD62B826C9492100424C7A /* Project object */;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100644
index 0000000..919434a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
new file mode 100644
index 0000000..18d9810
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/xcshareddata/xcschemes/DylibExample.xcscheme b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/xcshareddata/xcschemes/DylibExample.xcscheme
new file mode 100644
index 0000000..6cddf2c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample.xcodeproj/xcshareddata/xcschemes/DylibExample.xcscheme
@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1250"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "63CD62BF26C9492100424C7A"
+               BuildableName = "DylibExample.app"
+               BlueprintName = "DylibExample"
+               ReferencedContainer = "container:DylibExample.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "63CD62D526C9492400424C7A"
+               BuildableName = "DylibExampleTests.xctest"
+               BlueprintName = "DylibExampleTests"
+               ReferencedContainer = "container:DylibExample.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "63CD62E026C9492400424C7A"
+               BuildableName = "DylibExampleUITests.xctest"
+               BlueprintName = "DylibExampleUITests"
+               ReferencedContainer = "container:DylibExample.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "63CD62BF26C9492100424C7A"
+            BuildableName = "DylibExample.app"
+            BlueprintName = "DylibExample"
+            ReferencedContainer = "container:DylibExample.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "63CD62BF26C9492100424C7A"
+            BuildableName = "DylibExample.app"
+            BlueprintName = "DylibExample"
+            ReferencedContainer = "container:DylibExample.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/AppDelegate.swift b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/AppDelegate.swift
new file mode 100644
index 0000000..a2a5265
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/AppDelegate.swift
@@ -0,0 +1,36 @@
+//
+//  AppDelegate.swift
+//  DylibExample
+//
+//  Created by Nathan Horrigan on 15/08/2021.
+//
+
+import UIKit
+
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Override point for customization after application launch.
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        // Called when a new scene session is being created.
+        // Use this method to select a configuration to create the new scene with.
+        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    }
+
+    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
+        // Called when the user discards a scene session.
+        // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
+        // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
+    }
+
+
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AccentColor.colorset/Contents.json b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AccentColor.colorset/Contents.json
new file mode 100644
index 0000000..eb87897
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AccentColor.colorset/Contents.json
@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AppIcon.appiconset/Contents.json b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AppIcon.appiconset/Contents.json
new file mode 100644
index 0000000..9221b9b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/AppIcon.appiconset/Contents.json
@@ -0,0 +1,98 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/Contents.json b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/Contents.json
new file mode 100644
index 0000000..73c0059
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Assets.xcassets/Contents.json
@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/LaunchScreen.storyboard b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/LaunchScreen.storyboard
new file mode 100644
index 0000000..865e932
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/LaunchScreen.storyboard
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="13122.16" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" launchScreen="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="01J-lp-oVM">
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="13104.12"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="EHf-IW-A2E">
+            <objects>
+                <viewController id="01J-lp-oVM" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="Ze5-6b-2t3">
+                        <rect key="frame" x="0.0" y="0.0" width="375" height="667"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <color key="backgroundColor" xcode11CocoaTouchSystemColor="systemBackgroundColor" cocoaTouchSystemColor="whiteColor"/>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                    </view>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="iYj-Kq-Ea1" userLabel="First Responder" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="53" y="375"/>
+        </scene>
+    </scenes>
+</document>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/Main.storyboard b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/Main.storyboard
new file mode 100644
index 0000000..46b74d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Base.lproj/Main.storyboard
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<document type="com.apple.InterfaceBuilder3.CocoaTouch.Storyboard.XIB" version="3.0" toolsVersion="18122" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES" initialViewController="BYZ-38-t0r">
+    <device id="retina6_1" orientation="portrait" appearance="light"/>
+    <dependencies>
+        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="18093"/>
+        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
+        <capability name="System colors in document resources" minToolsVersion="11.0"/>
+        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
+    </dependencies>
+    <scenes>
+        <!--View Controller-->
+        <scene sceneID="tne-QT-ifu">
+            <objects>
+                <viewController id="BYZ-38-t0r" customClass="ViewController" customModule="DylibExample" customModuleProvider="target" sceneMemberID="viewController">
+                    <view key="view" contentMode="scaleToFill" id="8bC-Xf-vdC">
+                        <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
+                        <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
+                        <subviews>
+                            <label opaque="NO" userInteractionEnabled="NO" contentMode="left" horizontalHuggingPriority="251" verticalHuggingPriority="251" misplaced="YES" text="The sum of 1 + 3 = ?" textAlignment="center" lineBreakMode="tailTruncation" baselineAdjustment="alignBaselines" adjustsFontSizeToFit="NO" translatesAutoresizingMaskIntoConstraints="NO" id="Vpr-hH-YMQ">
+                                <rect key="frame" x="99" y="438" width="217" height="21"/>
+                                <fontDescription key="fontDescription" type="system" pointSize="17"/>
+                                <nil key="textColor"/>
+                                <nil key="highlightedColor"/>
+                            </label>
+                        </subviews>
+                        <viewLayoutGuide key="safeArea" id="6Tk-OE-BBY"/>
+                        <color key="backgroundColor" systemColor="systemBackgroundColor"/>
+                        <constraints>
+                            <constraint firstItem="Vpr-hH-YMQ" firstAttribute="centerX" secondItem="6Tk-OE-BBY" secondAttribute="centerX" id="Ji2-mk-twz"/>
+                            <constraint firstItem="Vpr-hH-YMQ" firstAttribute="centerY" secondItem="6Tk-OE-BBY" secondAttribute="centerY" id="xFk-LR-xQd"/>
+                        </constraints>
+                    </view>
+                    <connections>
+                        <outlet property="label" destination="Vpr-hH-YMQ" id="l1C-dt-cHd"/>
+                    </connections>
+                </viewController>
+                <placeholder placeholderIdentifier="IBFirstResponder" id="dkx-z0-nzr" sceneMemberID="firstResponder"/>
+            </objects>
+            <point key="canvasLocation" x="137.68115942028987" y="114.50892857142857"/>
+        </scene>
+    </scenes>
+    <resources>
+        <systemColor name="systemBackgroundColor">
+            <color white="1" alpha="1" colorSpace="custom" customColorSpace="genericGamma22GrayColorSpace"/>
+        </systemColor>
+    </resources>
+</document>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/DylibExample-Bridging-Header.h b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/DylibExample-Bridging-Header.h
new file mode 100644
index 0000000..7ce8fb5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/DylibExample-Bridging-Header.h
@@ -0,0 +1,4 @@
+#include "wasm.h"
+#include "wasmer.h"
+#include "wasmer_wasm.h"
+#include "calc.h"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Info.plist b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Info.plist
new file mode 100644
index 0000000..5b531f7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/Info.plist
@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>LSRequiresIPhoneOS</key>
+	<true/>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneConfigurationName</key>
+					<string>Default Configuration</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+					<key>UISceneStoryboardFile</key>
+					<string>Main</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
+	<key>UIApplicationSupportsIndirectInputEvents</key>
+	<true/>
+	<key>UILaunchStoryboardName</key>
+	<string>LaunchScreen</string>
+	<key>UIMainStoryboardFile</key>
+	<string>Main</string>
+	<key>UIRequiredDeviceCapabilities</key>
+	<array>
+		<string>armv7</string>
+	</array>
+	<key>UISupportedInterfaceOrientations</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+	<key>UISupportedInterfaceOrientations~ipad</key>
+	<array>
+		<string>UIInterfaceOrientationPortrait</string>
+		<string>UIInterfaceOrientationPortraitUpsideDown</string>
+		<string>UIInterfaceOrientationLandscapeLeft</string>
+		<string>UIInterfaceOrientationLandscapeRight</string>
+	</array>
+</dict>
+</plist>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/SceneDelegate.swift b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/SceneDelegate.swift
new file mode 100644
index 0000000..2ca113a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/SceneDelegate.swift
@@ -0,0 +1,52 @@
+//
+//  SceneDelegate.swift
+//  DylibExample
+//
+//  Created by Nathan Horrigan on 15/08/2021.
+//
+
+import UIKit
+
+class SceneDelegate: UIResponder, UIWindowSceneDelegate {
+
+    var window: UIWindow?
+
+
+    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
+        // Use this method to optionally configure and attach the UIWindow `window` to the provided UIWindowScene `scene`.
+        // If using a storyboard, the `window` property will automatically be initialized and attached to the scene.
+        // This delegate does not imply the connecting scene or session are new (see `application:configurationForConnectingSceneSession` instead).
+        guard let _ = (scene as? UIWindowScene) else { return }
+    }
+
+    func sceneDidDisconnect(_ scene: UIScene) {
+        // Called as the scene is being released by the system.
+        // This occurs shortly after the scene enters the background, or when its session is discarded.
+        // Release any resources associated with this scene that can be re-created the next time the scene connects.
+        // The scene may re-connect later, as its session was not necessarily discarded (see `application:didDiscardSceneSessions` instead).
+    }
+
+    func sceneDidBecomeActive(_ scene: UIScene) {
+        // Called when the scene has moved from an inactive state to an active state.
+        // Use this method to restart any tasks that were paused (or not yet started) when the scene was inactive.
+    }
+
+    func sceneWillResignActive(_ scene: UIScene) {
+        // Called when the scene will move from an active state to an inactive state.
+        // This may occur due to temporary interruptions (ex. an incoming phone call).
+    }
+
+    func sceneWillEnterForeground(_ scene: UIScene) {
+        // Called as the scene transitions from the background to the foreground.
+        // Use this method to undo the changes made on entering the background.
+    }
+
+    func sceneDidEnterBackground(_ scene: UIScene) {
+        // Called as the scene transitions from the foreground to the background.
+        // Use this method to save data, release shared resources, and store enough scene-specific state information
+        // to restore the scene back to its current state.
+    }
+
+
+}
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/ViewController.swift b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/ViewController.swift
new file mode 100644
index 0000000..b1da022
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/ViewController.swift
@@ -0,0 +1,18 @@
+//
+//  ViewController.swift
+//  DylibExample
+//
+//  Created by Nathan Horrigan on 15/08/2021.
+//
+
+import UIKit
+
+class ViewController: UIViewController {
+    @IBOutlet weak var label: UILabel!
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        let sum = calculate_sum(1, 3)
+        label.text = "The sum of 1 + 3 = \(sum)"
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.cpp b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.cpp
new file mode 100644
index 0000000..55a6701
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.cpp
@@ -0,0 +1,123 @@
+//
+//  WASM.cpp
+//  DylibExample
+//
+//  Created by Nathan Horrigan on 17/08/2021.
+//
+
+#include "calc.h"
+
+#include <any>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <filesystem>
+#include <CoreFoundation/CFBundle.h>
+
+std::string get_resources_dir()
+{
+
+  CFURLRef resourceURL = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle());
+  char resourcePath[PATH_MAX];
+  if (CFURLGetFileSystemRepresentation(resourceURL, true,
+                                       (UInt8 *)resourcePath,
+                                       PATH_MAX))
+  {
+    if (resourceURL != NULL)
+    {
+      CFRelease(resourceURL);
+    }
+
+    return resourcePath;
+  }
+
+  return "";
+}
+
+inline std::vector<uint8_t> read_vector_from_disk(std::string file_path)
+{
+  std::ifstream instream(file_path, std::ios::in | std::ios::binary);
+  std::vector<uint8_t> data((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());
+  return data;
+}
+
+int calculate_sum(int a, int b)
+{
+  printf("Creating the store...\n");
+  wasm_engine_t *engine = wasm_engine_new();
+  wasm_store_t *store = wasm_store_new(engine);
+
+  printf("Loading .dylib file...\n");
+  std::string wasm_path = get_resources_dir() + "/sum.dylib";
+  std::vector<uint8_t> dylib = read_vector_from_disk(wasm_path.c_str());
+  uint8_t *wasm_bytes = dylib.data();
+
+  wasm_byte_vec_t imported_bytes;
+  imported_bytes.size = dylib.size();
+  imported_bytes.data = (wasm_byte_t *)wasm_bytes;
+
+  printf("Compiling module...\n");
+  wasm_module_t *module;
+  module = wasm_module_deserialize(store, &imported_bytes);
+
+  if (!module)
+  {
+    printf("> Error compiling module!\n");
+
+    return 1;
+  }
+
+  printf("Creating imports...\n");
+  wasm_extern_vec_t import_object = WASM_EMPTY_VEC;
+
+  printf("Instantiating module...\n");
+  wasm_instance_t *instance = wasm_instance_new(store, module, &import_object, NULL);
+
+  if (!instance)
+  {
+    printf("> Error instantiating module!\n");
+
+    return 1;
+  }
+
+  printf("Retrieving exports...\n");
+  wasm_extern_vec_t exports;
+  wasm_instance_exports(instance, &exports);
+
+  if (exports.size == 0)
+  {
+    printf("> Error accessing exports!\n");
+
+    return 1;
+  }
+
+  printf("Retrieving the `sum` function...\n");
+  wasm_func_t *sum_func = wasm_extern_as_func(exports.data[0]);
+
+  if (sum_func == NULL)
+  {
+    printf("> Failed to get the `sum` function!\n");
+
+    return 1;
+  }
+
+  printf("Calling `sum` function...\n");
+  wasm_val_t args_val[2] = {WASM_I32_VAL(a), WASM_I32_VAL(b)};
+  wasm_val_t results_val[1] = {WASM_INIT_VAL};
+  wasm_val_vec_t args = WASM_ARRAY_VEC(args_val);
+  wasm_val_vec_t results = WASM_ARRAY_VEC(results_val);
+
+  if (wasm_func_call(sum_func, &args, &results))
+  {
+    printf("> Error calling the `sum` function!\n");
+
+    return 1;
+  }
+
+  printf("Results of `sum`: %d\n", results_val[0].of.i32);
+
+  return results_val[0].of.i32;
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.h b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.h
new file mode 100644
index 0000000..e1c7116
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/calc.h
@@ -0,0 +1,24 @@
+//
+//  WASM.hpp
+//  DylibExample
+//
+//  Created by Nathan Horrigan on 17/08/2021.
+//
+
+#ifndef calc_h
+#define calc_h
+#include "wasm.h"
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    int calculate_sum(int a, int b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* calc_h */
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/sum.wasm b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/sum.wasm
new file mode 100644
index 0000000..f1b05ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExample/sum.wasm
@@ -0,0 +1,7 @@
+(module
+(type $sum_t (func (param i32 i32) (result i32)))
+(func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
+local.get $x
+local.get $y
+i32.add)
+(export "sum" (func $sum_f)))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/DylibExampleTests.swift b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/DylibExampleTests.swift
new file mode 100644
index 0000000..7ee1e2a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/DylibExampleTests.swift
@@ -0,0 +1,33 @@
+//
+//  DylibExampleTests.swift
+//  DylibExampleTests
+//
+//  Created by Nathan Horrigan on 15/08/2021.
+//
+
+import XCTest
+@testable import DylibExample
+
+class DylibExampleTests: XCTestCase {
+
+    override func setUpWithError() throws {
+        // Put setup code here. This method is called before the invocation of each test method in the class.
+    }
+
+    override func tearDownWithError() throws {
+        // Put teardown code here. This method is called after the invocation of each test method in the class.
+    }
+
+    func testExample() throws {
+        let sum = calculate_sum(5, 2)
+        assert(sum == 7, "WASM loaded successfully")
+    }
+
+    func testPerformanceExample() throws {
+        // This is an example of a performance test case.
+        self.measure {
+            // Put the code you want to measure the time of here.
+        }
+    }
+
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/Info.plist b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/Info.plist
new file mode 100644
index 0000000..64d65ca
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/DylibExample/DylibExampleTests/Info.plist
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>$(PRODUCT_BUNDLE_PACKAGE_TYPE)</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+</dict>
+</plist>
diff --git a/arbitrator/tools/module_roots/wasmer/tests/integration/ios/tests/dylib.rs b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/tests/dylib.rs
new file mode 100644
index 0000000..db452ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/integration/ios/tests/dylib.rs
@@ -0,0 +1,54 @@
+#[cfg(test)]
+#[cfg(target_os = "macos")]
+mod tests {
+    use std::process::{Command, Output, Stdio};
+
+    #[test]
+    fn test_runtime() {
+        // Remove anuthing left over from tests
+        remove_existing_artificats();
+
+        // Tets the 'DylibExample' scheme
+        let success = run_ios_test("DylibExample/DylibExample.xcodeproj", "DylibExample");
+        if !success {
+            panic!("Dylib iOS Tests failed with the above output!");
+        }
+    }
+
+    fn run_ios_test(dir: &str, scheme: &str) -> bool {
+        let command = Command::new("xcodebuild")
+            .arg("test")
+            .arg("-project")
+            .arg(dir)
+            .arg("-scheme")
+            .arg(scheme)
+            .arg("-destination")
+            .arg("platform=iOS Simulator,name=iPhone 12 Pro")
+            .arg("CODE_SIGNING_ALLOWED=NO")
+            .stdout(Stdio::inherit())
+            .stderr(Stdio::inherit())
+            .output()
+            .expect("Could not run iOS Test");
+
+        // Get output from xcodebuild CLI:
+        let stderr = String::from_utf8(command.stderr).unwrap();
+
+        /*
+            An iOS Test Result is quite odd, we check stderr for the phrase 'TEST FAILED'
+            and then return stdout which contains the failure reason;
+            We also check that the command executed correctly!
+        */
+        let command_success = command.status.success();
+        let test_success = !stderr.contains("** TEST FAILED **");
+
+        command_success && test_success
+    }
+
+    fn remove_existing_artificats() -> Output {
+        Command::new("rm")
+            .arg("-f")
+            .arg("DylibExample/DylibExample/sum.dylib")
+            .output()
+            .expect("Could not clear artificats")
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/README.md b/arbitrator/tools/module_roots/wasmer/tests/lib/README.md
new file mode 100644
index 0000000..354f6c8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/README.md
@@ -0,0 +1,3 @@
+# Wasmer Test libraries
+
+Here is the place where the test libraries will live.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/Cargo.toml
new file mode 100644
index 0000000..e4036c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/Cargo.toml
@@ -0,0 +1,24 @@
+[lib]
+proc-macro = true
+
+[package]
+name = "compiler-test-derive"
+version = "0.0.1"
+authors = ["Wasmer Engineering <engineering@wasmer.io>"]
+edition = "2018"
+license = "MIT"
+
+description = "A macro to generate easily tests across compilers and engines"
+keywords = ["unsafe", "body", "fn", "safety", "hygiene"]
+categories = ["rust-patterns", ]
+
+[dependencies]
+proc-macro2 = "1.*"
+quote = "1.*"
+syn =  { version = "1.*", features = ["full"] }
+
+[features]
+
+[dev-dependencies]
+pretty_assertions = "1.0"
+trybuild = "1.0.11"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/build.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/build.rs
new file mode 100644
index 0000000..d65caeb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/build.rs
@@ -0,0 +1,12 @@
+fn main() {
+    println!("cargo:rerun-if-changed=../../ignores.txt");
+    if let Ok(os) = std::env::var("CARGO_CFG_TARGET_OS") {
+        println!("cargo:rustc-env=CFG_TARGET_OS={}", os);
+    }
+    if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ARCH") {
+        println!("cargo:rustc-env=CFG_TARGET_ARCH={}", os);
+    }
+    if let Ok(os) = std::env::var("CARGO_CFG_TARGET_ENV") {
+        println!("cargo:rustc-env=CFG_TARGET_ENV={}", os);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/ignores.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/ignores.rs
new file mode 100644
index 0000000..12364cf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/ignores.rs
@@ -0,0 +1,229 @@
+use std::fs::File;
+use std::path::PathBuf;
+
+use std::io::{BufRead, BufReader};
+
+pub const CFG_TARGET_OS: &str = env!("CFG_TARGET_OS");
+pub const CFG_TARGET_ARCH: &str = env!("CFG_TARGET_ARCH");
+pub const CFG_TARGET_ENV: &str = env!("CFG_TARGET_ENV");
+
+#[derive(Debug, Clone)]
+struct IgnorePattern {
+    os: Option<String>,
+    arch: Option<String>,
+    target_env: Option<String>,
+    engine: Option<String>,
+    compiler: Option<String>,
+    pattern_to_ignore: String,
+}
+
+impl IgnorePattern {
+    fn should_ignore(
+        &self,
+        os: &str,
+        arch: &str,
+        target_env: &str,
+        engine: &str,
+        compiler: &str,
+        canonical_path: &str,
+    ) -> bool {
+        self.os.as_ref().map_or(true, |val| val == os)
+            && self.arch.as_ref().map_or(true, |val| val == arch)
+            && self
+                .target_env
+                .as_ref()
+                .map_or(true, |val| val == target_env)
+            && self.engine.as_ref().map_or(true, |val| val == engine)
+            && self.compiler.as_ref().map_or(true, |val| val == compiler)
+            && (self.pattern_to_ignore == "*" || canonical_path.contains(&*self.pattern_to_ignore))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Ignores {
+    /// The canonical path, and the set of features
+    patterns: Vec<IgnorePattern>,
+}
+
+impl Ignores {
+    /// If the path matches any of the paths on the list
+    pub fn should_ignore(
+        &self,
+        os: &str,
+        arch: &str,
+        target_env: &str,
+        engine: &str,
+        compiler: &str,
+        canonical_path: &str,
+    ) -> bool {
+        self.patterns.iter().any(|p| {
+            // println!(" -> {:?}", p);
+            p.should_ignore(os, arch, target_env, engine, compiler, canonical_path)
+        })
+    }
+
+    pub fn should_ignore_host(&self, engine: &str, compiler: &str, canonical_path: &str) -> bool {
+        self.should_ignore(
+            CFG_TARGET_OS,
+            CFG_TARGET_ARCH,
+            CFG_TARGET_ENV,
+            engine,
+            compiler,
+            canonical_path,
+        )
+    }
+
+    /// Build a Ignore structure from a file path
+    pub fn build_from_path(path: PathBuf) -> Ignores {
+        let file = File::open(path).unwrap();
+        let reader = BufReader::new(file);
+        let mut patterns = Vec::new();
+
+        for (i, line) in reader.lines().enumerate() {
+            let line = line.unwrap();
+            // If the line has a `#` we discard all the content that comes after
+            let line = if line.contains('#') {
+                let l: Vec<&str> = line.splitn(2, '#').collect();
+                l[0].to_string()
+            } else {
+                line
+            };
+
+            let line = line.trim().to_string();
+
+            // If the lines contains ` ` it means the test should be ignored
+            // on the features exposed
+            if line.contains(' ') {
+                let l: Vec<&str> = line.splitn(2, ' ').collect();
+                let mut os: Option<String> = None;
+                let mut arch: Option<String> = None;
+                let mut target_env: Option<String> = None;
+                let mut engine: Option<String> = None;
+                let mut compiler: Option<String> = None;
+                for alias in l[0].trim().split('+') {
+                    match alias {
+                        // Operating Systems
+                        "windows" | "macos" | "linux" => {
+                            os = Some(alias.to_string());
+                        }
+                        // Environments
+                        "musl" => {
+                            target_env = Some(alias.to_string());
+                        }
+                        // Chipset architectures
+                        "aarch64" | "x86" | "x64" | "riscv64" => {
+                            arch = Some(alias.to_string());
+                        }
+                        // Engines
+                        "universal" | "engine" => {
+                            engine = Some(alias.to_string());
+                        }
+                        // Compilers
+                        "cranelift" | "llvm" | "singlepass" => {
+                            compiler = Some(alias.to_string());
+                        }
+                        other => {
+                            panic!("Alias {:?} not currently supported (defined in ignores.txt in line {})", other, i+1);
+                        }
+                    }
+                }
+                let pattern_to_ignore = l[1].trim().to_string();
+                patterns.push(IgnorePattern {
+                    os,
+                    arch,
+                    target_env,
+                    engine,
+                    compiler,
+                    pattern_to_ignore,
+                });
+            } else {
+                if line.is_empty() {
+                    continue;
+                }
+                patterns.push(IgnorePattern {
+                    os: None,
+                    arch: None,
+                    target_env: None,
+                    engine: None,
+                    compiler: None,
+                    pattern_to_ignore: line,
+                });
+            };
+        }
+        Ignores { patterns }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn features_match() -> Result<(), ()> {
+        assert!(IgnorePattern {
+            os: None,
+            arch: None,
+            target_env: None,
+            engine: None,
+            compiler: None,
+            pattern_to_ignore: "*".to_string()
+        }
+        .should_ignore(
+            "unknown",
+            "unknown",
+            "",
+            "engine",
+            "compiler",
+            "some::random::text"
+        ));
+        assert!(IgnorePattern {
+            os: None,
+            arch: None,
+            target_env: None,
+            engine: None,
+            compiler: None,
+            pattern_to_ignore: "some::random".to_string()
+        }
+        .should_ignore(
+            "unknown",
+            "unknown",
+            "",
+            "engine",
+            "compiler",
+            "some::random::text"
+        ));
+        assert!(!IgnorePattern {
+            os: Some("macos".to_string()),
+            arch: None,
+            target_env: None,
+            engine: None,
+            compiler: None,
+            pattern_to_ignore: "other".to_string()
+        }
+        .should_ignore(
+            "unknown",
+            "unknown",
+            "",
+            "engine",
+            "compiler",
+            "some::random::text"
+        ));
+        assert!(!IgnorePattern {
+            os: Some("macos".to_string()),
+            arch: None,
+            target_env: None,
+            engine: Some("universal".to_string()),
+            compiler: None,
+            pattern_to_ignore: "other".to_string()
+        }
+        .should_ignore(
+            "macos",
+            "unknown",
+            "",
+            "universal",
+            "compiler",
+            "some::random::text"
+        ));
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/lib.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/lib.rs
new file mode 100644
index 0000000..83c95eb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/lib.rs
@@ -0,0 +1,137 @@
+#[cfg(proc_macro)]
+extern crate proc_macro;
+
+use proc_macro2::TokenStream;
+use quote::quote;
+use std::path::Path;
+use syn::*;
+
+mod ignores;
+
+#[cfg(proc_macro)]
+#[proc_macro_attribute]
+pub fn compiler_test(
+    attrs: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    compiler_test_impl(attrs.into(), input.into()).into()
+}
+
+fn compiler_test_impl(attrs: TokenStream, input: TokenStream) -> TokenStream {
+    let path: Option<ExprPath> = parse2::<ExprPath>(attrs).ok();
+    let mut my_fn: ItemFn = match syn::parse2(input) {
+        Ok(f) => f,
+        Err(e) => return e.into_compile_error(),
+    };
+    let fn_name = &my_fn.sig.ident;
+
+    // Let's build the ignores to append an `#[ignore]` macro to the
+    // autogenerated tests in case the test appears in the `ignores.txt` path;
+
+    let tests_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .ancestors()
+        .nth(2)
+        .unwrap();
+    let ignores_txt_path = tests_dir.join("ignores.txt");
+
+    let ignores = crate::ignores::Ignores::build_from_path(ignores_txt_path);
+
+    let should_ignore = |test_name: &str, compiler_name: &str, engine_name: &str| {
+        let compiler_name = compiler_name.to_lowercase();
+        let engine_name = engine_name.to_lowercase();
+        // We construct the path manually because we can't get the
+        // source_file location from the `Span` (it's only available in nightly)
+        let full_path = format!(
+            "{}::{}::{}::{}",
+            quote! { #path },
+            test_name,
+            compiler_name,
+            engine_name
+        )
+        .replace(' ', "");
+
+        // println!("{} -> Should ignore: {}", full_path, should_ignore);
+        ignores.should_ignore_host(&engine_name, &compiler_name, &full_path)
+    };
+    let construct_engine_test = |func: &::syn::ItemFn,
+                                 compiler_name: &str,
+                                 engine_name: &str,
+                                 engine_feature_name: &str|
+     -> ::proc_macro2::TokenStream {
+        let config_compiler = ::quote::format_ident!("{}", compiler_name);
+        let test_name = ::quote::format_ident!("{}", engine_name.to_lowercase());
+        let mut new_sig = func.sig.clone();
+        let attrs = func
+            .attrs
+            .clone()
+            .iter()
+            .fold(quote! {}, |acc, new| quote! {#acc #new});
+        new_sig.ident = test_name;
+        new_sig.inputs = ::syn::punctuated::Punctuated::new();
+        let f = quote! {
+            #[test_log::test]
+            #attrs
+            #[cfg(feature = #engine_feature_name)]
+            #new_sig {
+                #fn_name(crate::Config::new(crate::Compiler::#config_compiler))
+            }
+        };
+        if should_ignore(
+            &func.sig.ident.to_string().replace("r#", ""),
+            compiler_name,
+            engine_name,
+        ) && !cfg!(test)
+        {
+            quote! {
+                #[ignore]
+                #f
+            }
+        } else {
+            f
+        }
+    };
+
+    let construct_compiler_test =
+        |func: &::syn::ItemFn, compiler_name: &str| -> ::proc_macro2::TokenStream {
+            let mod_name = ::quote::format_ident!("{}", compiler_name.to_lowercase());
+            let universal_engine_test =
+                construct_engine_test(func, compiler_name, "Universal", "universal");
+            let compiler_name_lowercase = compiler_name.to_lowercase();
+
+            quote! {
+                #[cfg(feature = #compiler_name_lowercase)]
+                mod #mod_name {
+                    use super::*;
+
+                    #universal_engine_test
+                }
+            }
+        };
+
+    let singlepass_compiler_test = construct_compiler_test(&my_fn, "Singlepass");
+    let cranelift_compiler_test = construct_compiler_test(&my_fn, "Cranelift");
+    let llvm_compiler_test = construct_compiler_test(&my_fn, "LLVM");
+
+    // We remove the method decorators
+    my_fn.attrs = vec![];
+
+    let x = quote! {
+        #[cfg(test)]
+        mod #fn_name {
+            use super::*;
+
+            #[allow(unused)]
+            #my_fn
+
+            #singlepass_compiler_test
+            #cranelift_compiler_test
+            #llvm_compiler_test
+        }
+    };
+
+    #[allow(clippy::useless_conversion)]
+    x.into()
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/tests.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/tests.rs
new file mode 100644
index 0000000..b25b399
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/compiler-test-derive/src/tests.rs
@@ -0,0 +1,94 @@
+use super::*;
+use pretty_assertions::assert_eq;
+
+macro_rules! gen_tests {(
+    $(
+        $test_name:ident:
+        stringify! {
+            #[$function:ident $(($($attrs:tt)*))?]
+            $($input:tt)*
+        } == $output:expr;
+    )*
+) => (
+    $(
+        #[test]
+        fn $test_name()
+        {
+            let input: TokenStream =
+                stringify!($($input)*)
+                    .parse()
+                    .expect("Syntax error in test");
+            let output: TokenStream =
+                $output
+                    .parse()
+                    .expect("Syntax error in test");
+            let attrs: TokenStream =
+                stringify!($($($attrs)*)?)
+                    .parse()
+                    .expect("Syntax error in test");
+            let ret = $function(attrs, input).to_string();
+            eprintln!("{}", ret);
+            assert_eq!(ret, output.to_string());
+        }
+    )*
+)}
+
+gen_tests! {
+    identity_for_no_unsafe:
+    stringify! {
+        #[compiler_test_impl(derive_test)]
+        #[cold]
+        fn foo(config: crate::Config) {
+            // Do tests
+        }
+    } == stringify! {
+        #[cfg(test)]
+        mod foo {
+            use super::*;
+
+            #[allow(unused)]
+            fn foo(config: crate::Config) {
+                // Do tests
+            }
+
+            #[cfg(feature = "singlepass")]
+            mod singlepass {
+                use super::*;
+                #[test_log::test]
+                #[cold]
+                #[cfg(feature = "universal")]
+                fn universal() {
+                    foo(crate::Config::new(
+                        crate::Compiler::Singlepass
+                    ))
+                }
+            }
+
+            #[cfg(feature = "cranelift")]
+            mod cranelift {
+                use super::*;
+                #[test_log::test]
+                #[cold]
+                #[cfg(feature = "universal")]
+                fn universal() {
+                    foo(crate::Config::new(
+                        crate::Compiler::Cranelift
+                    ))
+                }
+            }
+
+            #[cfg(feature = "llvm")]
+            mod llvm {
+                use super::*;
+                #[test_log::test]
+                #[cold]
+                #[cfg(feature = "universal")]
+                fn universal() {
+                    foo(crate::Config::new(
+                        crate::Compiler::LLVM
+                    ))
+                }
+            }
+        }
+    };
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/Cargo.toml
new file mode 100644
index 0000000..0374ef8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "test-generator"
+version = "0.1.0"
+edition = "2018"
+publish = false
+license = "Apache-2.0 WITH LLVM-exception"
+
+[dependencies]
+anyhow = "1.0"
+target-lexicon = "0.12"
+
+[features]
+test-universal = []
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/lib.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/lib.rs
new file mode 100644
index 0000000..b1e4a16
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/lib.rs
@@ -0,0 +1,106 @@
+//! Build library to generate a program which runs all the testsuites.
+//!
+//! By generating a separate `#[test]` test for each file, we allow cargo test
+//! to automatically run the files in parallel.
+//!
+//! > This program is inspired/forked from:
+//! > https://github.com/bytecodealliance/wasmtime/blob/master/build.rs
+mod processors;
+
+pub use crate::processors::{emscripten_processor, wasi_processor, wast_processor};
+use anyhow::Context;
+use std::fmt::Write;
+use std::path::{Path, PathBuf};
+
+pub struct Testsuite {
+    pub buffer: String,
+    pub path: Vec<String>,
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub struct Test {
+    pub name: String,
+    pub body: String,
+}
+
+pub fn test_directory_module(
+    out: &mut Testsuite,
+    path: impl AsRef<Path>,
+    processor: impl Fn(&mut Testsuite, PathBuf) -> Option<Test>,
+) -> anyhow::Result<usize> {
+    let path = path.as_ref();
+    let testsuite = &extract_name(path);
+    with_test_module(out, testsuite, |out| test_directory(out, path, processor))
+}
+
+fn write_test(out: &mut Testsuite, testname: &str, body: &str) -> anyhow::Result<()> {
+    writeln!(
+        out.buffer,
+        "#[compiler_test({})]",
+        out.path[..out.path.len() - 1].join("::")
+    )?;
+    writeln!(
+        out.buffer,
+        "fn r#{}(config: crate::Config) -> anyhow::Result<()> {{",
+        &testname
+    )?;
+    writeln!(out.buffer, "{}", body)?;
+    writeln!(out.buffer, "}}")?;
+    writeln!(out.buffer)?;
+    Ok(())
+}
+
+pub fn test_directory(
+    out: &mut Testsuite,
+    path: impl AsRef<Path>,
+    processor: impl Fn(&mut Testsuite, PathBuf) -> Option<Test>,
+) -> anyhow::Result<usize> {
+    let path = path.as_ref();
+    let mut dir_entries: Vec<_> = path
+        .read_dir()
+        .context(format!("failed to read {:?}", path))?
+        .map(|r| r.expect("reading testsuite directory entry"))
+        .filter_map(|dir_entry| processor(out, dir_entry.path()))
+        .collect();
+
+    dir_entries.sort();
+
+    for Test {
+        name: testname,
+        body,
+    } in dir_entries.iter()
+    {
+        out.path.push(testname.to_string());
+        write_test(out, testname, body).unwrap();
+        out.path.pop().unwrap();
+    }
+
+    Ok(dir_entries.len())
+}
+
+/// Extract a valid Rust identifier from the stem of a path.
+pub fn extract_name(path: impl AsRef<Path>) -> String {
+    path.as_ref()
+        .file_stem()
+        .expect("filename should have a stem")
+        .to_str()
+        .expect("filename should be representable as a string")
+        .replace(['-', '/'], "_")
+}
+
+pub fn with_test_module<T>(
+    out: &mut Testsuite,
+    testsuite: &str,
+    f: impl FnOnce(&mut Testsuite) -> anyhow::Result<T>,
+) -> anyhow::Result<T> {
+    out.path.push(testsuite.to_string());
+    out.buffer.push_str("mod ");
+    out.buffer.push_str(testsuite);
+    out.buffer.push_str(" {\n");
+
+    let result = f(out)?;
+
+    out.buffer.push_str("}\n");
+    out.path.pop().unwrap();
+    Ok(result)
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/processors.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/processors.rs
new file mode 100644
index 0000000..ce7ca22
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/test-generator/src/processors.rs
@@ -0,0 +1,95 @@
+//! Here we define the processors usable for each test genrator
+use crate::{extract_name, Test, Testsuite};
+use std::path::PathBuf;
+
+/// Given a Testsuite and a path, process the path in case is a wast
+/// file.
+pub fn wast_processor(_out: &mut Testsuite, p: PathBuf) -> Option<Test> {
+    let ext = p.extension()?;
+    // Only look at wast files.
+    if ext != "wast" {
+        return None;
+    }
+
+    // Ignore files starting with `.`, which could be editor temporary files
+    if p.file_stem()?.to_str()?.starts_with('.') {
+        return None;
+    }
+
+    let testname = extract_name(&p);
+
+    // The implementation of `run_wast` lives in /tests/spectest.rs
+    let body = format!("crate::run_wast(config, r#\"{}\"#)", p.display());
+
+    Some(Test {
+        name: testname,
+        body,
+    })
+}
+
+/// Given a Testsuite and a path, process the path in case is a Emscripten
+/// wasm file.
+pub fn emscripten_processor(_out: &mut Testsuite, p: PathBuf) -> Option<Test> {
+    let ext = p.extension()?;
+    // Only look at wast files.
+    if ext != "wasm" {
+        return None;
+    }
+
+    let outfile = {
+        let mut out_ext = p.clone();
+        out_ext.set_extension("out");
+        if out_ext.exists() {
+            out_ext
+        } else {
+            return None;
+        }
+    };
+
+    let testname = extract_name(&p);
+
+    // The implementation of `run_emscripten` lives in /tests/emtest.rs
+    let body = format!(
+        "crate::emscripten::run_emscripten(config, r#\"{}\"#, r#\"{}\"#)",
+        p.display(),
+        outfile.display()
+    );
+
+    Some(Test {
+        name: testname,
+        body,
+    })
+}
+
+/// Given a Testsuite and a path, process the path in case is a WASI
+/// wasm file.
+pub fn wasi_processor(
+    _out: &mut Testsuite,
+    p: PathBuf,
+    wasi_filesystem_kind: &str,
+) -> Option<Test> {
+    let ext = p.extension()?;
+    // Only look at wast files.
+    if ext != "wast" {
+        return None;
+    }
+
+    let wasm_dir = {
+        let mut inner = p.clone();
+        inner.pop();
+        inner
+    };
+    let testname = extract_name(&p);
+
+    let body = format!(
+        "crate::run_wasi(config, r#\"{}\"#, \"{}\", crate::{})",
+        p.display(),
+        wasm_dir.display(),
+        wasi_filesystem_kind,
+    );
+
+    Some(Test {
+        name: testname,
+        body,
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/Cargo.toml
new file mode 100644
index 0000000..fe805ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "wasmer-wast"
+version = "4.2.8"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+description = "wast testing support for wasmer"
+license = "MIT OR Apache-2.0 WITH LLVM-exception"
+categories = ["wasm"]
+keywords = ["wasm", "webassembly"]
+repository = "https://github.com/wasmerio/wasmer"
+readme = "README.md"
+edition = "2018"
+
+[dependencies]
+anyhow = "1.0"
+wasmer = { path = "../../../lib/api", version = "=4.2.8", default-features = false }
+wasmer-wasix = { path = "../../../lib/wasix", version = "0.18.3" }
+virtual-fs = { path = "../../../lib/virtual-fs", version = "0.11.2" }
+wast = "38.0"
+serde = "1"
+tempfile = "3.6.0"
+thiserror = "1.0"
+futures = "0.3"
+tokio = { version = "1", features = [ "io-util", "rt" ], default_features = false }
+
+[features]
+default = ["wat"]
+wat = ["wasmer/wat"]
+
+[badges]
+maintenance = { status = "actively-developed" }
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/README.md b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/README.md
new file mode 100644
index 0000000..a4f673f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/README.md
@@ -0,0 +1,7 @@
+This is the `wasmer-wast` crate, which contains an implementation of WebAssembly's
+"wast" test scripting language, which is used in the
+[WebAssembly spec testsuite], using wasmer for execution.
+
+[WebAssembly spec testsuite]: https://github.com/WebAssembly/testsuite
+
+> Note: this project started as a fork of [this crate](https://crates.io/crates/wasmtime-wast).
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/error.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/error.rs
new file mode 100644
index 0000000..53f0ab6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/error.rs
@@ -0,0 +1,37 @@
+use std::fmt;
+use thiserror::Error;
+
+/// A Directive Error
+#[derive(Debug)]
+pub struct DirectiveError {
+    /// The line where the directive is defined
+    pub line: usize,
+    /// The column where the directive is defined
+    pub col: usize,
+    /// The failing message received when running the directive
+    pub message: String,
+}
+
+/// A structure holding the list of all executed directives
+#[derive(Error, Debug)]
+pub struct DirectiveErrors {
+    /// The filename where the error occured
+    pub filename: String,
+    /// The list of errors
+    pub errors: Vec<DirectiveError>,
+}
+
+impl fmt::Display for DirectiveErrors {
+    // This trait requires `fmt` with this exact signature.
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // Write strictly the first element into the supplied output
+        // stream: `f`. Returns `fmt::Result` which indicates whether the
+        // operation succeeded or failed. Note that `write!` uses syntax which
+        // is very similar to `println!`.
+        writeln!(f, "Failed directives on {}:", self.filename)?;
+        for error in self.errors.iter() {
+            writeln!(f, "  • {} ({}:{})", error.message, error.line, error.col)?;
+        }
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/lib.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/lib.rs
new file mode 100644
index 0000000..30c5b83
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/lib.rs
@@ -0,0 +1,27 @@
+//! Implementation of the WAST text format for wasmer.
+
+#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
+#![warn(unused_import_braces)]
+#![allow(clippy::new_without_default)]
+#![warn(
+    clippy::float_arithmetic,
+    clippy::mut_mut,
+    clippy::nonminimal_bool,
+    clippy::map_unwrap_or,
+    clippy::print_stdout,
+    clippy::unicode_not_nfc,
+    clippy::use_self
+)]
+
+mod error;
+mod spectest;
+mod wasi_wast;
+mod wast;
+
+pub use crate::error::{DirectiveError, DirectiveErrors};
+pub use crate::spectest::spectest_importobject;
+pub use crate::wasi_wast::{WasiFileSystemKind, WasiTest};
+pub use crate::wast::Wast;
+
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/spectest.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/spectest.rs
new file mode 100644
index 0000000..7eda1b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/spectest.rs
@@ -0,0 +1,53 @@
+use wasmer::*;
+
+/// Return an instance implementing the "spectest" interface used in the
+/// spec testsuite.
+#[allow(clippy::print_stdout)]
+pub fn spectest_importobject(store: &mut Store) -> Imports {
+    let print = Function::new_typed(store, || {});
+    let print_i32 = Function::new_typed(store, |val: i32| println!("{}: i32", val));
+    let print_i64 = Function::new_typed(store, |val: i64| println!("{}: i64", val));
+    let print_f32 = Function::new_typed(store, |val: f32| println!("{}: f32", val));
+    let print_f64 = Function::new_typed(store, |val: f64| println!("{}: f64", val));
+    let print_i32_f32 = Function::new_typed(store, |i: i32, f: f32| {
+        println!("{}: i32", i);
+        println!("{}: f32", f);
+    });
+    let print_f64_f64 = Function::new_typed(store, |f1: f64, f2: f64| {
+        println!("{}: f64", f1);
+        println!("{}: f64", f2);
+    });
+
+    let global_i32 = Global::new(store, Value::I32(666));
+    let global_i64 = Global::new(store, Value::I64(666));
+    let global_f32 = Global::new(store, Value::F32(f32::from_bits(0x4426_8000)));
+    let global_f64 = Global::new(store, Value::F64(f64::from_bits(0x4084_d000_0000_0000)));
+
+    let ty = TableType::new(Type::FuncRef, 10, Some(20));
+    let table = Table::new(store, ty, Value::FuncRef(None)).unwrap();
+
+    let ty = MemoryType::new(1, Some(2), false);
+    let memory = Memory::new(store, ty).unwrap();
+
+    let ty = MemoryType::new(1, Some(2), true);
+    let shared_memory = Memory::new(store, ty).unwrap();
+
+    imports! {
+        "spectest" => {
+            "print" => print,
+            "print_i32" => print_i32,
+            "print_i64" => print_i64,
+            "print_f32" => print_f32,
+            "print_f64" => print_f64,
+            "print_i32_f32" => print_i32_f32,
+            "print_f64_f64" => print_f64_f64,
+            "global_i32" => global_i32,
+            "global_i64" => global_i64,
+            "global_f32" => global_f32,
+            "global_f64" => global_f64,
+            "table" => table,
+            "memory" => memory,
+            "shared_memory" => shared_memory,
+        },
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wasi_wast.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wasi_wast.rs
new file mode 100644
index 0000000..5dc1e7f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wasi_wast.rs
@@ -0,0 +1,750 @@
+use std::{
+    fs::{read_dir, File, OpenOptions, ReadDir},
+    future::Future,
+    io::{self, Read, SeekFrom},
+    path::{Path, PathBuf},
+    pin::Pin,
+    sync::{mpsc, Arc, Mutex},
+    task::{Context, Poll},
+};
+
+use virtual_fs::{
+    host_fs, mem_fs, passthru_fs, tmp_fs, union_fs, AsyncRead, AsyncSeek, AsyncWrite,
+    AsyncWriteExt, FileSystem, Pipe, ReadBuf, RootFileSystemBuilder,
+};
+use wasmer::{FunctionEnv, Imports, Module, Store};
+use wasmer_wasix::runtime::{
+    module_cache::ModuleHash,
+    task_manager::{tokio::TokioTaskManager, InlineWaker},
+};
+use wasmer_wasix::types::wasi::{Filesize, Timestamp};
+use wasmer_wasix::{
+    generate_import_object_from_env, get_wasi_version, FsError, PluggableRuntime, VirtualFile,
+    WasiEnv, WasiEnvBuilder, WasiVersion,
+};
+use wast::parser::{self, Parse, ParseBuffer, Parser};
+
+/// The kind of filesystem `WasiTest` is going to use.
+#[derive(Debug)]
+pub enum WasiFileSystemKind {
+    /// Instruct the test runner to use `virtual_fs::host_fs`.
+    Host,
+
+    /// Instruct the test runner to use `virtual_fs::mem_fs`.
+    InMemory,
+
+    /// Instruct the test runner to use `virtual_fs::tmp_fs`
+    Tmp,
+
+    /// Instruct the test runner to use `virtual_fs::passtru_fs`
+    PassthruMemory,
+
+    /// Instruct the test runner to use `virtual_fs::union_fs<host_fs, mem_fs>`
+    UnionHostMemory,
+
+    /// Instruct the test runner to use the TempFs returned by `virtual_fs::builder::RootFileSystemBuilder`
+    RootFileSystemBuilder,
+}
+
+/// Crate holding metadata parsed from the WASI WAST about the test to be run.
+#[derive(Debug, Clone, Hash)]
+pub struct WasiTest<'a> {
+    wasm_path: &'a str,
+    args: Vec<&'a str>,
+    envs: Vec<(&'a str, &'a str)>,
+    dirs: Vec<&'a str>,
+    mapped_dirs: Vec<(&'a str, &'a str)>,
+    temp_dirs: Vec<&'a str>,
+    assert_return: Option<AssertReturn>,
+    stdin: Option<Stdin<'a>>,
+    assert_stdout: Option<AssertStdout<'a>>,
+    assert_stderr: Option<AssertStderr<'a>>,
+}
+
+// TODO: add `test_fs` here to sandbox better
+const BASE_TEST_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../../wasi-wast/wasi/");
+
+fn get_stdio_output(rx: &mpsc::Receiver<Vec<u8>>) -> anyhow::Result<String> {
+    let mut stdio = Vec::new();
+    while let Ok(mut buf) = rx.try_recv() {
+        stdio.append(&mut buf);
+    }
+    let stdout_str = std::str::from_utf8(&stdio[..])?;
+    #[cfg(target_os = "windows")]
+    // normalize line endings
+    return Ok(stdout_str.replace("\r\n", "\n"));
+
+    #[cfg(not(target_os = "windows"))]
+    return Ok(stdout_str.to_string());
+}
+
+#[allow(dead_code)]
+impl<'a> WasiTest<'a> {
+    /// Turn a WASI WAST string into a list of tokens.
+    pub fn lex_string(wast: &'a str) -> parser::Result<ParseBuffer<'a>> {
+        ParseBuffer::new(wast)
+    }
+
+    /// Turn a WASI WAST list of tokens into a `WasiTest` struct.
+    pub fn parse_tokens(tokens: &'a ParseBuffer<'a>) -> parser::Result<Self> {
+        parser::parse(tokens)
+    }
+
+    /// Execute the WASI test and assert.
+    pub fn run(
+        &self,
+        mut store: &mut Store,
+        base_path: &str,
+        filesystem_kind: WasiFileSystemKind,
+    ) -> anyhow::Result<bool> {
+        use anyhow::Context;
+
+        #[cfg(not(target_arch = "wasm32"))]
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()?;
+        #[cfg(not(target_arch = "wasm32"))]
+        let handle = runtime.handle().clone();
+        #[cfg(not(target_arch = "wasm32"))]
+        let _guard = handle.enter();
+        #[cfg(not(target_arch = "wasm32"))]
+        let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::new(runtime)));
+        #[cfg(target_arch = "wasm32")]
+        let mut rt = PluggableRuntime::new(Arc::new(TokioTaskManager::default()));
+        rt.set_engine(Some(store.engine().clone()));
+
+        let mut pb = PathBuf::from(base_path);
+        pb.push(self.wasm_path);
+        let wasm_bytes = {
+            let mut wasm_module = File::open(pb)?;
+            let mut out = vec![];
+            wasm_module.read_to_end(&mut out)?;
+            out
+        };
+        let module_hash = ModuleHash::hash(&wasm_bytes);
+
+        let module = Module::new(store, wasm_bytes)?;
+        let (builder, _tempdirs, mut stdin_tx, stdout_rx, stderr_rx) =
+            { InlineWaker::block_on(async { self.create_wasi_env(filesystem_kind).await }) }?;
+
+        let (instance, _wasi_env) =
+            builder
+                .runtime(Arc::new(rt))
+                .instantiate_ext(module, module_hash, store)?;
+
+        let start = instance.exports.get_function("_start")?;
+
+        if let Some(stdin) = &self.stdin {
+            // let mut wasi_stdin = { wasi_env.data(store).stdin().unwrap().unwrap() };
+            // Then we can write to it!
+            let data = stdin.stream.to_string();
+            InlineWaker::block_on(async move {
+                stdin_tx.write_all(data.as_bytes()).await?;
+                stdin_tx.shutdown().await?;
+
+                Ok::<_, anyhow::Error>(())
+            })?;
+        } else {
+            std::mem::drop(stdin_tx);
+        }
+
+        // TODO: handle errors here when the error fix gets shipped
+        match start.call(&mut store, &[]) {
+            Ok(_) => {}
+            Err(e) => {
+                let stdout_str = get_stdio_output(&stdout_rx)?;
+                let stderr_str = get_stdio_output(&stderr_rx)?;
+                Err(e).with_context(|| {
+                    format!(
+                        "failed to run WASI `_start` function: failed with stdout: \"{}\"\nstderr: \"{}\"",
+                        stdout_str,
+                        stderr_str,
+                    )
+                })?;
+            }
+        }
+
+        if let Some(expected_stdout) = &self.assert_stdout {
+            let stdout_str = get_stdio_output(&stdout_rx)?;
+            dbg!(&expected_stdout, &stdout_str);
+            assert_eq!(stdout_str, expected_stdout.expected);
+        }
+
+        if let Some(expected_stderr) = &self.assert_stderr {
+            let stderr_str = get_stdio_output(&stderr_rx)?;
+            assert_eq!(stderr_str, expected_stderr.expected);
+        }
+
+        Ok(true)
+    }
+
+    /// Create the wasi env with the given metadata.
+    #[allow(clippy::type_complexity)]
+    async fn create_wasi_env(
+        &self,
+        filesystem_kind: WasiFileSystemKind,
+    ) -> anyhow::Result<(
+        WasiEnvBuilder,
+        Vec<tempfile::TempDir>,
+        Pipe,
+        mpsc::Receiver<Vec<u8>>,
+        mpsc::Receiver<Vec<u8>>,
+    )> {
+        let mut builder = WasiEnv::builder(self.wasm_path);
+
+        let (stdin_tx, stdin_rx) = Pipe::channel();
+        builder.set_stdin(Box::new(stdin_rx));
+
+        for (name, value) in &self.envs {
+            builder.add_env(name, value);
+        }
+
+        let mut host_temp_dirs_to_not_drop = vec![];
+
+        match filesystem_kind {
+            WasiFileSystemKind::Host => {
+                let fs = host_fs::FileSystem::default();
+
+                for (alias, real_dir) in &self.mapped_dirs {
+                    let mut dir = PathBuf::from(BASE_TEST_DIR);
+                    dir.push(real_dir);
+                    builder.add_map_dir(alias, dir)?;
+                }
+
+                // due to the structure of our code, all preopen dirs must be mapped now
+                for dir in &self.dirs {
+                    let mut new_dir = PathBuf::from(BASE_TEST_DIR);
+                    new_dir.push(dir);
+                    builder.add_map_dir(dir, new_dir)?;
+                }
+
+                for alias in &self.temp_dirs {
+                    let temp_dir = tempfile::tempdir()?;
+                    builder.add_map_dir(alias, temp_dir.path())?;
+                    host_temp_dirs_to_not_drop.push(temp_dir);
+                }
+
+                builder.set_fs(Box::new(fs));
+            }
+
+            other => {
+                let fs: Box<dyn FileSystem + Send + Sync> = match other {
+                    WasiFileSystemKind::InMemory => Box::<mem_fs::FileSystem>::default(),
+                    WasiFileSystemKind::Tmp => Box::<tmp_fs::TmpFileSystem>::default(),
+                    WasiFileSystemKind::PassthruMemory => {
+                        let fs = Box::<mem_fs::FileSystem>::default();
+                        Box::new(passthru_fs::PassthruFileSystem::new(fs))
+                    }
+                    WasiFileSystemKind::RootFileSystemBuilder => {
+                        Box::new(RootFileSystemBuilder::new().build())
+                    }
+                    WasiFileSystemKind::UnionHostMemory => {
+                        let a = mem_fs::FileSystem::default();
+                        let b = mem_fs::FileSystem::default();
+                        let c = mem_fs::FileSystem::default();
+                        let d = mem_fs::FileSystem::default();
+                        let e = mem_fs::FileSystem::default();
+                        let f = mem_fs::FileSystem::default();
+
+                        let mut union = union_fs::UnionFileSystem::new();
+
+                        union.mount("mem_fs", "/test_fs", false, Box::new(a), None);
+                        union.mount("mem_fs_2", "/snapshot1", false, Box::new(b), None);
+                        union.mount("mem_fs_3", "/tests", false, Box::new(c), None);
+                        union.mount("mem_fs_4", "/nightly_2022_10_18", false, Box::new(d), None);
+                        union.mount("mem_fs_5", "/unstable", false, Box::new(e), None);
+                        union.mount("mem_fs_6", "/.tmp_wasmer_wast_0", false, Box::new(f), None);
+
+                        Box::new(union)
+                    }
+                    _ => {
+                        panic!("unexpected filesystem type {:?}", other);
+                    }
+                };
+
+                let mut temp_dir_index: usize = 0;
+
+                let root = PathBuf::from("/");
+
+                map_host_fs_to_mem_fs(&*fs, read_dir(BASE_TEST_DIR)?, &root).await?;
+
+                for (alias, real_dir) in &self.mapped_dirs {
+                    let mut path = root.clone();
+                    path.push(real_dir);
+                    builder.add_map_dir(alias, path)?;
+                }
+
+                for dir in &self.dirs {
+                    let mut new_dir = PathBuf::from("/");
+                    new_dir.push(dir);
+
+                    builder.add_map_dir(dir, new_dir)?;
+                }
+
+                for alias in &self.temp_dirs {
+                    let temp_dir_name =
+                        PathBuf::from(format!("/.tmp_wasmer_wast_{}", temp_dir_index));
+                    fs.create_dir(temp_dir_name.as_path())?;
+                    builder.add_map_dir(alias, temp_dir_name)?;
+                    temp_dir_index += 1;
+                }
+
+                builder.set_fs(fs);
+            }
+        }
+
+        let (stdout, stdout_rx) = OutputCapturerer::new();
+        let (stderr, stderr_rx) = OutputCapturerer::new();
+        let builder = builder
+            .args(&self.args)
+            // adding this causes some tests to fail. TODO: investigate this
+            //.env("RUST_BACKTRACE", "1")
+            .stdout(Box::new(stdout))
+            .stderr(Box::new(stderr));
+
+        Ok((
+            builder,
+            host_temp_dirs_to_not_drop,
+            stdin_tx,
+            stdout_rx,
+            stderr_rx,
+        ))
+    }
+
+    /// Get the correct [`WasiVersion`] from the Wasm [`Module`].
+    fn get_version(&self, module: &Module) -> anyhow::Result<WasiVersion> {
+        use anyhow::Context;
+        let version = get_wasi_version(module, true)
+            .with_context(|| "failed to detect a version of WASI from the module")?;
+        Ok(version)
+    }
+
+    /// Get the correct WASI import object for the given module and set it up with the
+    /// [`WasiEnv`].
+    fn get_imports(
+        &self,
+        store: &mut Store,
+        ctx: &FunctionEnv<WasiEnv>,
+        module: &Module,
+    ) -> anyhow::Result<Imports> {
+        let version = self.get_version(module)?;
+        Ok(generate_import_object_from_env(store, ctx, version))
+    }
+}
+
+mod wasi_kw {
+    wast::custom_keyword!(wasi_test);
+    wast::custom_keyword!(envs);
+    wast::custom_keyword!(args);
+    wast::custom_keyword!(preopens);
+    wast::custom_keyword!(map_dirs);
+    wast::custom_keyword!(temp_dirs);
+    wast::custom_keyword!(assert_return);
+    wast::custom_keyword!(stdin);
+    wast::custom_keyword!(assert_stdout);
+    wast::custom_keyword!(assert_stderr);
+    wast::custom_keyword!(fake_i64_const = "i64.const");
+}
+
+impl<'a> Parse<'a> for WasiTest<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        parser.parens(|parser| {
+            parser.parse::<wasi_kw::wasi_test>()?;
+            // TODO: improve error message here
+            let wasm_path = parser.parse::<&'a str>()?;
+
+            // TODO: allow these to come in any order
+            let envs = if parser.peek2::<wasi_kw::envs>() {
+                parser.parens(|p| p.parse::<Envs>())?.envs
+            } else {
+                vec![]
+            };
+
+            let args = if parser.peek2::<wasi_kw::args>() {
+                parser.parens(|p| p.parse::<Args>())?.args
+            } else {
+                vec![]
+            };
+
+            let dirs = if parser.peek2::<wasi_kw::preopens>() {
+                parser.parens(|p| p.parse::<Preopens>())?.preopens
+            } else {
+                vec![]
+            };
+
+            let mapped_dirs = if parser.peek2::<wasi_kw::map_dirs>() {
+                parser.parens(|p| p.parse::<MapDirs>())?.map_dirs
+            } else {
+                vec![]
+            };
+
+            let temp_dirs = if parser.peek2::<wasi_kw::temp_dirs>() {
+                parser.parens(|p| p.parse::<TempDirs>())?.temp_dirs
+            } else {
+                vec![]
+            };
+
+            let assert_return = if parser.peek2::<wasi_kw::assert_return>() {
+                Some(parser.parens(|p| p.parse::<AssertReturn>())?)
+            } else {
+                None
+            };
+
+            let stdin = if parser.peek2::<wasi_kw::stdin>() {
+                Some(parser.parens(|p| p.parse::<Stdin>())?)
+            } else {
+                None
+            };
+
+            let assert_stdout = if parser.peek2::<wasi_kw::assert_stdout>() {
+                Some(parser.parens(|p| p.parse::<AssertStdout>())?)
+            } else {
+                None
+            };
+
+            let assert_stderr = if parser.peek2::<wasi_kw::assert_stderr>() {
+                Some(parser.parens(|p| p.parse::<AssertStderr>())?)
+            } else {
+                None
+            };
+
+            Ok(Self {
+                wasm_path,
+                args,
+                envs,
+                dirs,
+                mapped_dirs,
+                temp_dirs,
+                assert_return,
+                stdin,
+                assert_stdout,
+                assert_stderr,
+            })
+        })
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+struct Envs<'a> {
+    envs: Vec<(&'a str, &'a str)>,
+}
+
+impl<'a> Parse<'a> for Envs<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        let mut envs = vec![];
+        parser.parse::<wasi_kw::envs>()?;
+
+        while parser.peek::<&'a str>() {
+            let res = parser.parse::<&'a str>()?;
+            let mut strs = res.split('=');
+            let first = strs.next().unwrap();
+            let second = strs.next().unwrap();
+            //debug_assert!(strs.next().is_none());
+            envs.push((first, second));
+        }
+        Ok(Self { envs })
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+struct Args<'a> {
+    args: Vec<&'a str>,
+}
+
+impl<'a> Parse<'a> for Args<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        let mut args = vec![];
+        parser.parse::<wasi_kw::args>()?;
+
+        while parser.peek::<&'a str>() {
+            let res = parser.parse::<&'a str>()?;
+            args.push(res);
+        }
+        Ok(Self { args })
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+struct Preopens<'a> {
+    preopens: Vec<&'a str>,
+}
+
+impl<'a> Parse<'a> for Preopens<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        let mut preopens = vec![];
+        parser.parse::<wasi_kw::preopens>()?;
+
+        while parser.peek::<&'a str>() {
+            let res = parser.parse::<&'a str>()?;
+            preopens.push(res);
+        }
+        Ok(Self { preopens })
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+struct MapDirs<'a> {
+    map_dirs: Vec<(&'a str, &'a str)>,
+}
+
+impl<'a> Parse<'a> for MapDirs<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        let mut map_dirs = vec![];
+        parser.parse::<wasi_kw::map_dirs>()?;
+
+        while parser.peek::<&'a str>() {
+            let res = parser.parse::<&'a str>()?;
+            let mut iter = res.split(':');
+            let dir = iter.next().unwrap();
+            let alias = iter.next().unwrap();
+            map_dirs.push((dir, alias));
+        }
+        Ok(Self { map_dirs })
+    }
+}
+
+#[derive(Debug, Clone, Hash)]
+struct TempDirs<'a> {
+    temp_dirs: Vec<&'a str>,
+}
+
+impl<'a> Parse<'a> for TempDirs<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        let mut temp_dirs = vec![];
+        parser.parse::<wasi_kw::temp_dirs>()?;
+
+        while parser.peek::<&'a str>() {
+            let alias = parser.parse::<&'a str>()?;
+            temp_dirs.push(alias);
+        }
+        Ok(Self { temp_dirs })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct AssertReturn {
+    return_value: i64,
+}
+
+impl<'a> Parse<'a> for AssertReturn {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        parser.parse::<wasi_kw::assert_return>()?;
+        let return_value = parser.parens(|p| {
+            p.parse::<wasi_kw::fake_i64_const>()?;
+            p.parse::<i64>()
+        })?;
+        Ok(Self { return_value })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct Stdin<'a> {
+    stream: &'a str,
+}
+
+impl<'a> Parse<'a> for Stdin<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        parser.parse::<wasi_kw::stdin>()?;
+        Ok(Self {
+            stream: parser.parse()?,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct AssertStdout<'a> {
+    expected: &'a str,
+}
+
+impl<'a> Parse<'a> for AssertStdout<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        parser.parse::<wasi_kw::assert_stdout>()?;
+        Ok(Self {
+            expected: parser.parse()?,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+struct AssertStderr<'a> {
+    expected: &'a str,
+}
+
+impl<'a> Parse<'a> for AssertStderr<'a> {
+    fn parse(parser: Parser<'a>) -> parser::Result<Self> {
+        parser.parse::<wasi_kw::assert_stderr>()?;
+        Ok(Self {
+            expected: parser.parse()?,
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_parse() {
+        let pb = wast::parser::ParseBuffer::new(
+            r#"(wasi_test "my_wasm.wasm"
+                    (envs "HELLO=WORLD" "RUST_BACKTRACE=1")
+                    (args "hello" "world" "--help")
+                    (preopens "." "src/io")
+                    (assert_return (i64.const 0))
+                    (stdin "This is another \"string\" inside a string!")
+                    (assert_stdout "This is a \"string\" inside a string!")
+                    (assert_stderr "")
+)"#,
+        )
+        .unwrap();
+        let result = wast::parser::parse::<WasiTest>(&pb).unwrap();
+
+        assert_eq!(result.args, vec!["hello", "world", "--help"]);
+        assert_eq!(
+            result.envs,
+            vec![("HELLO", "WORLD"), ("RUST_BACKTRACE", "1")]
+        );
+        assert_eq!(result.dirs, vec![".", "src/io"]);
+        assert_eq!(result.assert_return.unwrap().return_value, 0);
+        assert_eq!(
+            result.assert_stdout.unwrap().expected,
+            "This is a \"string\" inside a string!"
+        );
+        assert_eq!(
+            result.stdin.unwrap().stream,
+            "This is another \"string\" inside a string!"
+        );
+        assert_eq!(result.assert_stderr.unwrap().expected, "");
+    }
+}
+
+#[derive(Debug, Clone)]
+struct OutputCapturerer {
+    output: Arc<Mutex<mpsc::Sender<Vec<u8>>>>,
+}
+
+impl OutputCapturerer {
+    fn new() -> (Self, mpsc::Receiver<Vec<u8>>) {
+        let (tx, rx) = mpsc::channel();
+        (
+            Self {
+                output: Arc::new(Mutex::new(tx)),
+            },
+            rx,
+        )
+    }
+}
+
+impl VirtualFile for OutputCapturerer {
+    fn last_accessed(&self) -> Timestamp {
+        0
+    }
+    fn last_modified(&self) -> Timestamp {
+        0
+    }
+    fn created_time(&self) -> Timestamp {
+        0
+    }
+    fn size(&self) -> u64 {
+        0
+    }
+    fn set_len(&mut self, _new_size: Filesize) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn unlink(&mut self) -> Result<(), FsError> {
+        Ok(())
+    }
+    fn poll_read_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(0))
+    }
+    fn poll_write_ready(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<usize>> {
+        Poll::Ready(Ok(8192))
+    }
+}
+
+impl AsyncSeek for OutputCapturerer {
+    fn start_seek(self: Pin<&mut Self>, _position: SeekFrom) -> io::Result<()> {
+        Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not seek logging wrapper",
+        ))
+    }
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<u64>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not seek logging wrapper",
+        )))
+    }
+}
+
+impl AsyncWrite for OutputCapturerer {
+    fn poll_write(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<io::Result<usize>> {
+        self.output
+            .lock()
+            .unwrap()
+            .send(buf.to_vec())
+            .map_err(|err| io::Error::new(io::ErrorKind::BrokenPipe, err.to_string()))?;
+        Poll::Ready(Ok(buf.len()))
+    }
+    fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+    fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+impl AsyncRead for OutputCapturerer {
+    fn poll_read(
+        self: Pin<&mut Self>,
+        _cx: &mut Context<'_>,
+        _buf: &mut ReadBuf<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Err(io::Error::new(
+            io::ErrorKind::Other,
+            "can not read from logging wrapper",
+        )))
+    }
+}
+
+/// When using `virtual_fs::mem_fs`, we cannot rely on `BASE_TEST_DIR`
+/// because the host filesystem cannot be used. Instead, we are
+/// copying `BASE_TEST_DIR` to the `mem_fs`.
+fn map_host_fs_to_mem_fs<'a>(
+    fs: &'a dyn FileSystem,
+    directory_reader: ReadDir,
+    path_prefix: &'a Path,
+) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + 'a>> {
+    Box::pin(async move {
+        for entry in directory_reader {
+            let entry = entry?;
+            let entry_type = entry.file_type()?;
+
+            let path = path_prefix.join(entry.path().file_name().unwrap());
+
+            if entry_type.is_dir() {
+                fs.create_dir(&path)?;
+
+                map_host_fs_to_mem_fs(fs, read_dir(entry.path())?, &path).await?
+            } else if entry_type.is_file() {
+                let mut host_file = OpenOptions::new().read(true).open(entry.path())?;
+                let mut mem_file = fs
+                    .new_open_options()
+                    .create_new(true)
+                    .write(true)
+                    .open(path)?;
+                let mut buffer = Vec::new();
+                Read::read_to_end(&mut host_file, &mut buffer)?;
+                mem_file.write_all(&buffer).await?;
+            } else if entry_type.is_symlink() {
+                //unimplemented!("`mem_fs` does not support symlink for the moment");
+            }
+        }
+
+        Ok(())
+    })
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wast.rs b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wast.rs
new file mode 100644
index 0000000..80b02ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/lib/wast/src/wast.rs
@@ -0,0 +1,655 @@
+use crate::error::{DirectiveError, DirectiveErrors};
+use crate::spectest::spectest_importobject;
+use anyhow::{anyhow, bail, Result};
+use std::collections::{HashMap, HashSet};
+use std::path::Path;
+use std::str;
+use wasmer::*;
+
+/// The wast test script language allows modules to be defined and actions
+/// to be performed on them.
+#[allow(dead_code)]
+pub struct Wast {
+    /// Wast files have a concept of a "current" module, which is the most
+    /// recently defined.
+    current: Option<Instance>,
+    /// The Import Object that all wast tests will have
+    import_object: Imports,
+    /// The instances in the test
+    instances: HashMap<String, Instance>,
+    /// Allowed failures (ideally this should be empty)
+    allowed_instantiation_failures: HashSet<String>,
+    /// If the (expected from .wast, actual) message pair is in this list,
+    /// treat the strings as matching.
+    match_trap_messages: HashMap<String, String>,
+    /// If the current module was an allowed failure, we allow test to fail
+    current_is_allowed_failure: bool,
+    /// The store in which the tests are executing.
+    store: Store,
+    /// A flag indicating if Wast tests should stop as soon as one test fails.
+    pub fail_fast: bool,
+    /// A flag indicating that assert_trap and assert_exhaustion should be skipped.
+    /// See https://github.com/wasmerio/wasmer/issues/1550 for more info
+    disable_assert_trap_exhaustion: bool,
+}
+
+impl Wast {
+    /// Construct a new instance of `Wast` with a given imports.
+    pub fn new(store: Store, import_object: Imports) -> Self {
+        Self {
+            current: None,
+            store,
+            import_object,
+            allowed_instantiation_failures: HashSet::new(),
+            match_trap_messages: HashMap::new(),
+            current_is_allowed_failure: false,
+            instances: HashMap::new(),
+            fail_fast: true,
+            disable_assert_trap_exhaustion: false,
+        }
+    }
+
+    /// A list of instantiation failures to allow.
+    pub fn allow_instantiation_failures(&mut self, failures: &[&str]) {
+        for &failure_str in failures.iter() {
+            self.allowed_instantiation_failures
+                .insert(failure_str.to_string());
+        }
+    }
+
+    /// A list of alternative messages to permit for a trap failure.
+    pub fn allow_trap_message(&mut self, expected: &str, allowed: &str) {
+        self.match_trap_messages
+            .insert(expected.into(), allowed.into());
+    }
+
+    /// Do not run any code in assert_trap or assert_exhaustion.
+    pub fn disable_assert_and_exhaustion(&mut self) {
+        self.disable_assert_trap_exhaustion = true;
+    }
+
+    /// Construct a new instance of `Wast` with the spectests imports.
+    pub fn new_with_spectest(mut store: Store) -> Self {
+        let import_object = spectest_importobject(&mut store);
+        Self::new(store, import_object)
+    }
+
+    fn get_instance(&self, instance_name: Option<&str>) -> Result<Instance> {
+        match instance_name {
+            Some(name) => self
+                .instances
+                .get(name)
+                .cloned()
+                .ok_or_else(|| anyhow!("failed to find instance named `{}`", name)),
+            None => self
+                .current
+                .clone()
+                .ok_or_else(|| anyhow!("no previous instance found")),
+        }
+    }
+
+    /// Perform the action portion of a command.
+    fn perform_execute(&mut self, exec: wast::WastExecute<'_>) -> Result<Vec<Value>> {
+        match exec {
+            wast::WastExecute::Invoke(invoke) => self.perform_invoke(invoke),
+            wast::WastExecute::Module(mut module) => {
+                let binary = module.encode()?;
+                let result = self.instantiate(&binary);
+                result.map(|_| Vec::new())
+            }
+            wast::WastExecute::Get { module, global } => self.get(module.map(|s| s.name()), global),
+        }
+    }
+
+    fn perform_invoke(&mut self, exec: wast::WastInvoke<'_>) -> Result<Vec<Value>> {
+        let values = exec
+            .args
+            .iter()
+            .map(|a| self.runtime_value(a))
+            .collect::<Result<Vec<_>>>()?;
+        self.invoke(exec.module.map(|i| i.name()), exec.name, &values)
+    }
+
+    fn assert_return(
+        &self,
+        result: Result<Vec<Value>>,
+        results: &[wast::AssertExpression],
+    ) -> Result<()> {
+        let values = result?;
+        for (v, e) in values.iter().zip(results) {
+            if self.val_matches(v, e)? {
+                continue;
+            }
+            if let Value::V128(bits) = v {
+                if let wast::AssertExpression::V128(pattern) = e {
+                    bail!(
+                        "expected {:?}, got {:?} (v128 bits: {})",
+                        e,
+                        v128_format(*bits, pattern),
+                        bits
+                    );
+                }
+            }
+            bail!("expected {:?}, got {:?}", e, v)
+        }
+        Ok(())
+    }
+
+    fn assert_trap(&self, result: Result<Vec<Value>>, expected: &str) -> Result<()> {
+        let actual = match result {
+            Ok(values) => bail!("expected trap, got {:?}", values),
+            Err(t) => format!("{}", t),
+        };
+        if self.matches_message_assert_trap(expected, &actual) {
+            return Ok(());
+        }
+        bail!("expected '{}', got '{}'", expected, actual)
+    }
+
+    fn run_directive(&mut self, test: &Path, directive: wast::WastDirective) -> Result<()> {
+        use wast::WastDirective::*;
+
+        match directive {
+            Module(mut module) => {
+                let binary = module.encode()?;
+                self.module(module.id.map(|s| s.name()), &binary)?;
+            }
+            Register {
+                span: _,
+                name,
+                module,
+            } => {
+                self.register(module.map(|s| s.name()), name)?;
+            }
+            Invoke(i) => {
+                self.perform_invoke(i)?;
+            }
+            AssertReturn {
+                span: _,
+                exec,
+                results,
+            } => {
+                let result = self.perform_execute(exec);
+                self.assert_return(result, &results)?;
+            }
+            AssertTrap {
+                span: _,
+                exec,
+                message,
+            } => {
+                if !self.disable_assert_trap_exhaustion {
+                    let result = self.perform_execute(exec);
+                    self.assert_trap(result, message)?;
+                }
+            }
+            AssertExhaustion {
+                span: _,
+                call,
+                message,
+            } => {
+                if !self.disable_assert_trap_exhaustion {
+                    let result = self.perform_invoke(call);
+                    self.assert_trap(result, message)?;
+                }
+            }
+            AssertInvalid {
+                span: _,
+                module,
+                message,
+            } => {
+                let wasm = match module {
+                    wast::QuoteModule::Module(mut m) => m.encode()?,
+                    wast::QuoteModule::Quote(list) => self.parse_quote_module(test, &list)?,
+                };
+                let err = match self.module(None, &wasm) {
+                    Ok(()) => bail!("expected module to fail to build"),
+                    Err(e) => e,
+                };
+                let error_message = format!("{:?}", err);
+                if !Self::matches_message_assert_invalid(message, &error_message) {
+                    bail!(
+                        "assert_invalid: expected \"{}\", got \"{}\"",
+                        message,
+                        error_message
+                    )
+                }
+            }
+            QuoteModule { .. } => {
+                // Do nothing
+            }
+            AssertException { .. } => {
+                // Do nothing for now
+            }
+            AssertMalformed {
+                module,
+                span: _,
+                message: _,
+            } => {
+                let mut module = match module {
+                    wast::QuoteModule::Module(m) => m,
+                    // This is a `*.wat` parser test which we're not
+                    // interested in.
+                    wast::QuoteModule::Quote(_) => return Ok(()),
+                };
+                let bytes = module.encode()?;
+                if self.module(None, &bytes).is_ok() {
+                    bail!("expected malformed module to fail to instantiate");
+                }
+            }
+            AssertUnlinkable {
+                span: _,
+                mut module,
+                message,
+            } => {
+                let bytes = module.encode()?;
+                let err = match self.module(None, &bytes) {
+                    Ok(()) => bail!("expected module to fail to link"),
+                    Err(e) => e,
+                };
+                let error_message = format!("{:?}", err);
+                if !Self::matches_message_assert_unlinkable(message, &error_message) {
+                    bail!(
+                        "assert_unlinkable: expected {}, got {}",
+                        message,
+                        error_message
+                    )
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Run a wast script from a byte buffer.
+    pub fn run_buffer(&mut self, test: &Path, wast: &[u8]) -> Result<()> {
+        let wast = str::from_utf8(wast)?;
+        let filename = test.to_str().unwrap();
+        let adjust_wast = |mut err: wast::Error| {
+            err.set_path(filename.as_ref());
+            err.set_text(wast);
+            err
+        };
+
+        let buf = wast::parser::ParseBuffer::new(wast).map_err(adjust_wast)?;
+        let ast = wast::parser::parse::<wast::Wast>(&buf).map_err(adjust_wast)?;
+        let mut errors = Vec::with_capacity(ast.directives.len());
+        for directive in ast.directives {
+            let sp = directive.span();
+            if let Err(e) = self.run_directive(test, directive) {
+                let message = format!("{}", e);
+                // If depends on an instance that doesn't exist
+                if message.contains("no previous instance found") {
+                    continue;
+                }
+                // We don't compute it, comes from instantiating an instance
+                // that we expected to fail.
+                if self.current.is_none() && self.current_is_allowed_failure {
+                    continue;
+                }
+                let (line, col) = sp.linecol_in(wast);
+                errors.push(DirectiveError {
+                    line: line + 1,
+                    col,
+                    message,
+                });
+                if self.fail_fast {
+                    break;
+                }
+            }
+        }
+        if !errors.is_empty() {
+            return Err(DirectiveErrors {
+                filename: filename.to_string(),
+                errors,
+            }
+            .into());
+        }
+        Ok(())
+    }
+
+    fn parse_quote_module(&self, test: &Path, source: &[&[u8]]) -> Result<Vec<u8>> {
+        let mut ret = String::new();
+        for src in source {
+            match str::from_utf8(src) {
+                Ok(s) => ret.push_str(s),
+                Err(_) => bail!("malformed UTF-8 encoding"),
+            }
+            ret.push(' ');
+        }
+        let buf = wast::parser::ParseBuffer::new(&ret)?;
+        let mut wat = wast::parser::parse::<wast::Wat>(&buf)?;
+
+        // TODO: when memory64 merges into the proper spec then this should be
+        // removed since it will presumably no longer be a text-format error but
+        // rather a validation error. Currently all non-memory64 proposals
+        // assert that this offset is a text-parser error, whereas with memory64
+        // support that error is deferred until later.
+        if ret.contains("offset=4294967296") && !test.iter().any(|t| t == "memory64") {
+            bail!("i32 constant out of bounds");
+        }
+        Ok(wat.module.encode()?)
+    }
+
+    /// Run a wast script from a file.
+    pub fn run_file(&mut self, path: &Path) -> Result<()> {
+        let bytes = std::fs::read(path)?;
+        self.run_buffer(path, &bytes)
+    }
+}
+
+// This is the implementation specific to the Runtime
+impl Wast {
+    /// Define a module and register it.
+    fn module(&mut self, instance_name: Option<&str>, module: &[u8]) -> Result<()> {
+        let instance = match self.instantiate(module) {
+            Ok(i) => i,
+            Err(e) => {
+                // We set the current to None to allow running other
+                // spectests when `fail_fast` is `false`.
+                self.current = None;
+                let error_message = format!("{}", e);
+                self.current_is_allowed_failure = false;
+                for allowed_failure in self.allowed_instantiation_failures.iter() {
+                    if error_message.contains(allowed_failure) {
+                        self.current_is_allowed_failure = true;
+                        break;
+                    }
+                }
+                bail!("instantiation failed with: {}", e)
+            }
+        };
+        if let Some(name) = instance_name {
+            self.instances.insert(name.to_string(), instance.clone());
+        }
+        self.current = Some(instance);
+        self.current_is_allowed_failure = false;
+        Ok(())
+    }
+
+    fn instantiate(&mut self, module: &[u8]) -> Result<Instance> {
+        let module = Module::new(&self.store, module)?;
+        let mut imports = self.import_object.clone();
+
+        for import in module.imports() {
+            let module_name = import.module();
+            if imports.contains_namespace(module_name) {
+                continue;
+            }
+            let instance = self
+                .instances
+                .get(module_name)
+                .ok_or_else(|| anyhow!("constant expression required"))?;
+            imports.register_namespace(module_name, instance.exports.clone());
+        }
+
+        let instance = Instance::new(&mut self.store, &module, &imports)?;
+        Ok(instance)
+    }
+
+    /// Register an instance to make it available for performing actions.
+    fn register(&mut self, name: Option<&str>, as_name: &str) -> Result<()> {
+        let instance = self.get_instance(name)?;
+        self.instances.insert(as_name.to_string(), instance);
+        Ok(())
+    }
+
+    /// Invoke an exported function from an instance.
+    fn invoke(
+        &mut self,
+        instance_name: Option<&str>,
+        field: &str,
+        args: &[Value],
+    ) -> Result<Vec<Value>> {
+        let instance = self.get_instance(instance_name)?;
+        let func: &Function = instance.exports.get(field)?;
+        match func.call(&mut self.store, args) {
+            Ok(result) => Ok(result.into()),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    /// Get the value of an exported global from an instance.
+    fn get(&mut self, instance_name: Option<&str>, field: &str) -> Result<Vec<Value>> {
+        let instance = self.get_instance(instance_name)?;
+        let global: &Global = instance.exports.get(field)?;
+        Ok(vec![global.get(&mut self.store)])
+    }
+
+    /// Translate from a `script::Value` to a `Value`.
+    fn runtime_value(&mut self, v: &wast::Expression<'_>) -> Result<Value> {
+        use wast::Instruction::*;
+
+        if v.instrs.len() != 1 {
+            bail!("too many instructions in {:?}", v);
+        }
+        Ok(match &v.instrs[0] {
+            I32Const(x) => Value::I32(*x),
+            I64Const(x) => Value::I64(*x),
+            F32Const(x) => Value::F32(f32::from_bits(x.bits)),
+            F64Const(x) => Value::F64(f64::from_bits(x.bits)),
+            V128Const(x) => Value::V128(u128::from_le_bytes(x.to_le_bytes())),
+            RefNull(wast::HeapType::Func) => Value::FuncRef(None),
+            RefNull(wast::HeapType::Extern) => Value::null(),
+            RefExtern(number) => Value::ExternRef(Some(ExternRef::new(&mut self.store, *number))),
+            other => bail!("couldn't convert {:?} to a runtime value", other),
+        })
+    }
+
+    // Checks if the `assert_unlinkable` message matches the expected one
+    fn matches_message_assert_unlinkable(expected: &str, actual: &str) -> bool {
+        actual.contains(expected)
+    }
+
+    // Checks if the `assert_invalid` message matches the expected one
+    fn matches_message_assert_invalid(expected: &str, actual: &str) -> bool {
+        actual.contains(expected)
+            // Waiting on https://github.com/WebAssembly/bulk-memory-operations/pull/137
+            // to propagate to WebAssembly/testsuite.
+            || (expected.contains("unknown table") && actual.contains("unknown elem"))
+            // wasmparser return the wrong message
+            || (expected.contains("unknown memory") && actual.contains("no linear memories are present"))
+            // `elem.wast` and `proposals/bulk-memory-operations/elem.wast` disagree
+            // on the expected error message for the same error.
+            || (expected.contains("out of bounds") && actual.contains("does not fit"))
+            // handle `unknown global $NUM` error messages that wasmparser doesn't return yet
+            || (expected.contains("unknown global") && actual.contains("unknown global"))
+            // handle `unknown memory $NUM` error messages that wasmparser doesn't return yet
+            || (expected.contains("unknown memory") && actual.contains("unknown memory"))
+            || (expected.contains("unknown memory") && actual.contains("Data segment extends past end of the data section"))
+    }
+
+    // Checks if the `assert_trap` message matches the expected one
+    fn matches_message_assert_trap(&self, expected: &str, actual: &str) -> bool {
+        actual.contains(expected)
+            || self
+                .match_trap_messages
+                .get(expected)
+                .map_or(false, |alternative| actual.contains(alternative))
+    }
+
+    fn val_matches(&self, actual: &Value, expected: &wast::AssertExpression) -> Result<bool> {
+        Ok(match (actual, expected) {
+            (Value::I32(a), wast::AssertExpression::I32(b)) => a == b,
+            (Value::I64(a), wast::AssertExpression::I64(b)) => a == b,
+            // Note that these float comparisons are comparing bits, not float
+            // values, so we're testing for bit-for-bit equivalence
+            (Value::F32(a), wast::AssertExpression::F32(b)) => f32_matches(*a, b),
+            (Value::F64(a), wast::AssertExpression::F64(b)) => f64_matches(*a, b),
+            (Value::V128(a), wast::AssertExpression::V128(b)) => v128_matches(*a, b),
+            (Value::FuncRef(None), wast::AssertExpression::RefNull(Some(wast::HeapType::Func))) => {
+                true
+            }
+            (Value::FuncRef(Some(_)), wast::AssertExpression::RefNull(_)) => false,
+            (Value::FuncRef(None), wast::AssertExpression::RefFunc(None)) => true,
+            (Value::FuncRef(None), wast::AssertExpression::RefFunc(Some(_))) => false,
+            (
+                Value::ExternRef(None),
+                wast::AssertExpression::RefNull(Some(wast::HeapType::Extern)),
+            ) => true,
+            (Value::ExternRef(None), wast::AssertExpression::RefExtern(_)) => false,
+
+            (Value::ExternRef(Some(_)), wast::AssertExpression::RefNull(_)) => false,
+            (Value::ExternRef(Some(extern_ref)), wast::AssertExpression::RefExtern(num)) => {
+                extern_ref.downcast(&self.store) == Some(num)
+            }
+            _ => bail!(
+                "don't know how to compare {:?} and {:?} yet",
+                actual,
+                expected
+            ),
+        })
+    }
+}
+
+fn extract_lane_as_i8(bytes: u128, lane: usize) -> i8 {
+    (bytes >> (lane * 8)) as i8
+}
+
+fn extract_lane_as_i16(bytes: u128, lane: usize) -> i16 {
+    (bytes >> (lane * 16)) as i16
+}
+
+fn extract_lane_as_i32(bytes: u128, lane: usize) -> i32 {
+    (bytes >> (lane * 32)) as i32
+}
+
+fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 {
+    (bytes >> (lane * 64)) as i64
+}
+
+fn f32_matches(actual: f32, expected: &wast::NanPattern<wast::Float32>) -> bool {
+    match expected {
+        wast::NanPattern::CanonicalNan => actual.is_canonical_nan(),
+        wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
+        wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
+    }
+}
+
+fn f64_matches(actual: f64, expected: &wast::NanPattern<wast::Float64>) -> bool {
+    match expected {
+        wast::NanPattern::CanonicalNan => actual.is_canonical_nan(),
+        wast::NanPattern::ArithmeticNan => actual.is_arithmetic_nan(),
+        wast::NanPattern::Value(expected_value) => actual.to_bits() == expected_value.bits,
+    }
+}
+
+fn v128_matches(actual: u128, expected: &wast::V128Pattern) -> bool {
+    match expected {
+        wast::V128Pattern::I8x16(b) => b
+            .iter()
+            .enumerate()
+            .all(|(i, b)| *b == extract_lane_as_i8(actual, i)),
+        wast::V128Pattern::I16x8(b) => b
+            .iter()
+            .enumerate()
+            .all(|(i, b)| *b == extract_lane_as_i16(actual, i)),
+        wast::V128Pattern::I32x4(b) => b
+            .iter()
+            .enumerate()
+            .all(|(i, b)| *b == extract_lane_as_i32(actual, i)),
+        wast::V128Pattern::I64x2(b) => b
+            .iter()
+            .enumerate()
+            .all(|(i, b)| *b == extract_lane_as_i64(actual, i)),
+        wast::V128Pattern::F32x4(b) => b.iter().enumerate().all(|(i, b)| {
+            let a = extract_lane_as_i32(actual, i) as u32;
+            f32_matches(f32::from_bits(a), b)
+        }),
+        wast::V128Pattern::F64x2(b) => b.iter().enumerate().all(|(i, b)| {
+            let a = extract_lane_as_i64(actual, i) as u64;
+            f64_matches(f64::from_bits(a), b)
+        }),
+    }
+}
+
+fn v128_format(actual: u128, expected: &wast::V128Pattern) -> wast::V128Pattern {
+    match expected {
+        wast::V128Pattern::I8x16(_) => wast::V128Pattern::I8x16([
+            extract_lane_as_i8(actual, 0),
+            extract_lane_as_i8(actual, 1),
+            extract_lane_as_i8(actual, 2),
+            extract_lane_as_i8(actual, 3),
+            extract_lane_as_i8(actual, 4),
+            extract_lane_as_i8(actual, 5),
+            extract_lane_as_i8(actual, 6),
+            extract_lane_as_i8(actual, 7),
+            extract_lane_as_i8(actual, 8),
+            extract_lane_as_i8(actual, 9),
+            extract_lane_as_i8(actual, 10),
+            extract_lane_as_i8(actual, 11),
+            extract_lane_as_i8(actual, 12),
+            extract_lane_as_i8(actual, 13),
+            extract_lane_as_i8(actual, 14),
+            extract_lane_as_i8(actual, 15),
+        ]),
+        wast::V128Pattern::I16x8(_) => wast::V128Pattern::I16x8([
+            extract_lane_as_i16(actual, 0),
+            extract_lane_as_i16(actual, 1),
+            extract_lane_as_i16(actual, 2),
+            extract_lane_as_i16(actual, 3),
+            extract_lane_as_i16(actual, 4),
+            extract_lane_as_i16(actual, 5),
+            extract_lane_as_i16(actual, 6),
+            extract_lane_as_i16(actual, 7),
+        ]),
+        wast::V128Pattern::I32x4(_) => wast::V128Pattern::I32x4([
+            extract_lane_as_i32(actual, 0),
+            extract_lane_as_i32(actual, 1),
+            extract_lane_as_i32(actual, 2),
+            extract_lane_as_i32(actual, 3),
+        ]),
+        wast::V128Pattern::I64x2(_) => wast::V128Pattern::I64x2([
+            extract_lane_as_i64(actual, 0),
+            extract_lane_as_i64(actual, 1),
+        ]),
+        wast::V128Pattern::F32x4(_) => wast::V128Pattern::F32x4([
+            wast::NanPattern::Value(wast::Float32 {
+                bits: extract_lane_as_i32(actual, 0) as _,
+            }),
+            wast::NanPattern::Value(wast::Float32 {
+                bits: extract_lane_as_i32(actual, 1) as _,
+            }),
+            wast::NanPattern::Value(wast::Float32 {
+                bits: extract_lane_as_i32(actual, 2) as _,
+            }),
+            wast::NanPattern::Value(wast::Float32 {
+                bits: extract_lane_as_i32(actual, 3) as _,
+            }),
+        ]),
+        wast::V128Pattern::F64x2(_) => wast::V128Pattern::F64x2([
+            wast::NanPattern::Value(wast::Float64 {
+                bits: extract_lane_as_i64(actual, 0) as _,
+            }),
+            wast::NanPattern::Value(wast::Float64 {
+                bits: extract_lane_as_i64(actual, 1) as _,
+            }),
+        ]),
+    }
+}
+
+pub trait NaNCheck {
+    fn is_arithmetic_nan(&self) -> bool;
+    fn is_canonical_nan(&self) -> bool;
+}
+
+impl NaNCheck for f32 {
+    fn is_arithmetic_nan(&self) -> bool {
+        const AF32_NAN: u32 = 0x0040_0000;
+        (self.to_bits() & AF32_NAN) == AF32_NAN
+    }
+
+    fn is_canonical_nan(&self) -> bool {
+        (self.to_bits() & 0x7fff_ffff) == 0x7fc0_0000
+    }
+}
+
+impl NaNCheck for f64 {
+    fn is_arithmetic_nan(&self) -> bool {
+        const AF64_NAN: u64 = 0x0008_0000_0000_0000;
+        (self.to_bits() & AF64_NAN) == AF64_NAN
+    }
+
+    fn is_canonical_nan(&self) -> bool {
+        (self.to_bits() & 0x7fff_ffff_ffff_ffff) == 0x7ff8_0000_0000_0000
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.lock b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.lock
new file mode 100644
index 0000000..59c7e8f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.lock
@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "rust-wasi-tests"
+version = "0.1.0"
+dependencies = [
+ "wasi",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.toml
new file mode 100644
index 0000000..45731f7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "rust-wasi-tests"
+version = "0.1.0"
+edition = "2021"
+
+[workspace]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+wasi = "0.11.0"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/bin/fs-rename.rs b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/bin/fs-rename.rs
new file mode 100644
index 0000000..840e2f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/bin/fs-rename.rs
@@ -0,0 +1,34 @@
+use std::fs::{self, File};
+use std::os::fd::AsRawFd;
+use std::path::Path;
+
+fn print_contents(path: impl AsRef<Path> + Copy) {
+    let contents = fs::read_to_string(path).unwrap();
+    println!(
+        "{}:{contents}",
+        path.as_ref().to_string_lossy().into_owned()
+    );
+}
+
+fn main() {
+    unsafe {
+        fs::create_dir("/test-dir").unwrap();
+
+        fs::write("/test-dir/a", "a").unwrap();
+        print_contents("/test-dir/a");
+
+        let dir = File::open("/test-dir").unwrap();
+        let dir_raw_fd = dir.as_raw_fd() as u32;
+
+        wasi::path_rename(dir_raw_fd, "a", dir_raw_fd, "b").unwrap();
+
+        print_contents("/test-dir/b");
+
+        fs::write("/test-dir/c", "c").unwrap();
+        print_contents("/test-dir/c");
+
+        fs::rename("/test-dir/c", "/test-dir/d").unwrap();
+
+        print_contents("/test-dir/d");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/lib.rs b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/lib.rs
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/rust-wasi-tests/src/lib.rs
@@ -0,0 +1 @@
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/.gitignore
new file mode 100644
index 0000000..917660a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/.gitignore
@@ -0,0 +1 @@
+*.wasm
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/LICENSE b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/LICENSE
new file mode 100644
index 0000000..2038971
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Casper Beyer
+
+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/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/README.md
new file mode 100644
index 0000000..ea1dcd9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/README.md
@@ -0,0 +1 @@
+# WebAssembly System Interface tests for libstd
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/build.sh b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/build.sh
new file mode 100755
index 0000000..d063bb0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/build.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+set -ueo pipefail
+
+for input in *.rs; do
+  output="$(basename $input .rs).wasm"
+
+  echo "Compiling $input"
+  rustc +nightly --target=wasm32-wasi -o "$output" "$input"
+done
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.arg b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.arg
new file mode 100644
index 0000000..c8b8852
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.arg
@@ -0,0 +1,3 @@
+none
+some
+many
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.rs
new file mode 100644
index 0000000..8b59fb4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-many.rs
@@ -0,0 +1,10 @@
+use std::env;
+
+fn main() {
+  let args = env::args().collect::<Vec<String>>();
+  assert_eq!(args.len(), 4);
+  assert_eq!(args[0], "env_args-many.wasm");
+  assert_eq!(args[1], "none");
+  assert_eq!(args[2], "some");
+  assert_eq!(args[3], "many");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-none.arg b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-none.arg
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-none.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-none.rs
new file mode 100644
index 0000000..fabcd5d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-none.rs
@@ -0,0 +1,7 @@
+use std::env;
+
+fn main() {
+  let args = env::args().collect::<Vec<String>>();
+  assert_eq!(args.len(), 1);
+  assert_eq!(args[0], "env_args-none.wasm");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.arg b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.arg
new file mode 100644
index 0000000..363ef61
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.arg
@@ -0,0 +1 @@
+some
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.rs
new file mode 100644
index 0000000..a983397
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_args-some.rs
@@ -0,0 +1,8 @@
+use std::env;
+
+fn main() {
+  let args = env::args().collect::<Vec<String>>();
+  assert_eq!(args.len(), 2);
+  assert_eq!(args[0], "env_args-some.wasm");
+  assert_eq!(args[1], "some");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.env b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.env
new file mode 100644
index 0000000..eb5fcb6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.env
@@ -0,0 +1,3 @@
+NONE=none
+SOME=some
+MANY=many
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.rs
new file mode 100644
index 0000000..dc49743
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-many.rs
@@ -0,0 +1,10 @@
+use std::collections::HashMap;
+use std::env;
+
+fn main() {
+    let vars = env::vars().collect::<HashMap<String, String>>();
+    assert_eq!(vars.len(), 3);
+    assert_eq!(vars["NONE"], "none".to_string());
+    assert_eq!(vars["SOME"], "some".to_string());
+    assert_eq!(vars["MANY"], "many".to_string());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-none.env b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-none.env
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-none.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-none.rs
new file mode 100644
index 0000000..c0eace5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-none.rs
@@ -0,0 +1,6 @@
+use std::env;
+
+fn main() {
+  let vars = env::vars().collect::<Vec<(String, String)>>();
+  assert_eq!(vars.len(), 0);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.env b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.env
new file mode 100644
index 0000000..4415634
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.env
@@ -0,0 +1 @@
+SOME=some
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.rs
new file mode 100644
index 0000000..619ee65
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/env_vars-some.rs
@@ -0,0 +1,7 @@
+use std::env;
+
+fn main() {
+  let vars = env::vars().collect::<Vec<(String, String)>>();
+  assert_eq!(vars.len(), 1);
+  assert_eq!(vars[0], ("SOME".to_string(), "some".to_string()));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-existing-directory.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-existing-directory.rs
new file mode 100644
index 0000000..5152133
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-existing-directory.rs
@@ -0,0 +1,7 @@
+use std::fs;
+
+fn main() {
+    assert!(
+        fs::create_dir("/fyi/fs_create_dir-existing-directory.dir/existing_directory").is_err()
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-new-directory.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-new-directory.rs
new file mode 100644
index 0000000..e9f99d6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_create_dir-new-directory.rs
@@ -0,0 +1,5 @@
+use std::fs;
+
+fn main() {
+    assert!(fs::create_dir("/fyi/fs_create_dir-new-directory.dir/new_directory").is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_file_create.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_file_create.rs
new file mode 100644
index 0000000..f4bb160
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_file_create.rs
@@ -0,0 +1,9 @@
+use std::fs;
+
+fn main() {
+    assert!(fs::File::create("/fyi/fs_file_create.dir/new_file").is_ok());
+    assert!(fs::metadata("/fyi/fs_file_create.dir/new_file")
+        .unwrap()
+        .is_file());
+    assert!(fs::remove_file("/fyi/fs_file_create.dir/new_file").is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-directory.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-directory.rs
new file mode 100644
index 0000000..1eafecd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-directory.rs
@@ -0,0 +1,6 @@
+use std::fs;
+
+fn main() {
+    let metadata = fs::metadata("/fyi/fs_metadata-directory.dir/directory").unwrap();
+    assert!(metadata.is_dir());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-file.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-file.rs
new file mode 100644
index 0000000..ae47808
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_metadata-file.rs
@@ -0,0 +1,6 @@
+use std::fs;
+
+fn main() {
+    let metadata = fs::metadata("/fyi/fs_metadata-file.dir/file").unwrap();
+    assert!(metadata.is_file());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-directory.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-directory.rs
new file mode 100644
index 0000000..ed04b88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-directory.rs
@@ -0,0 +1,8 @@
+use std::fs;
+
+fn main() {
+    let old_path = "/fyi/fs_rename-directory.dir/old_directory";
+    let new_path = "/fyi/fs_rename-directory.dir/new_directory";
+
+    assert!(fs::rename(old_path, new_path).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-file.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-file.rs
new file mode 100644
index 0000000..2da55f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/fs_rename-file.rs
@@ -0,0 +1,8 @@
+use std::fs;
+
+fn main() {
+    let old_path = "/fyi/fs_rename-file.dir/old_file";
+    let new_path = "/fyi/fs_rename-file.dir/new_file";
+
+    assert!(fs::rename(old_path, new_path).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.rs
new file mode 100644
index 0000000..7d417bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.rs
@@ -0,0 +1,6 @@
+use std::io;
+use std::io::Write;
+
+fn main() {
+  assert!(io::stderr().write_all(include_bytes!("io_stderr-beowulf.stderr")).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.stderr b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.stderr
new file mode 100644
index 0000000..1856685
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-beowulf.stderr
@@ -0,0 +1,3182 @@
+Hwæt. We Gardena in geardagum,
+þeodcyninga, þrym gefrunon,
+hu ða æþelingas ellen fremedon.
+Oft Scyld Scefing sceaþena þreatum,
+monegum mægþum, meodosetla ofteah,
+egsode eorlas. Syððan ærest wearð
+feasceaft funden, he þæs frofre gebad,
+weox under wolcnum, weorðmyndum þah,
+oðþæt him æghwylc þara ymbsittendra
+ofer hronrade hyran scolde,
+gomban gyldan. þæt wæs god cyning.
+ðæm eafera wæs æfter cenned,
+geong in geardum, þone god sende
+folce to frofre; fyrenðearfe ongeat
+þe hie ær drugon aldorlease
+lange hwile. Him þæs liffrea,
+wuldres wealdend, woroldare forgeaf;
+Beowulf wæs breme blæd wide sprang,
+Scyldes eafera Scedelandum in.
+Swa sceal geong guma gode gewyrcean,
+fromum feohgiftum on fæder bearme,
+þæt hine on ylde eft gewunigen
+wilgesiþas, þonne wig cume,
+leode gelæsten; lofdædum sceal
+in mægþa gehwære man geþeon.
+Him ða Scyld gewat to gescæphwile
+felahror feran on frean wære.
+Hi hyne þa ætbæron to brimes faroðe,
+swæse gesiþas, swa he selfa bæd,
+þenden wordum weold wine Scyldinga;
+leof landfruma lange ahte.
+þær æt hyðe stod hringedstefna,
+isig ond utfus, æþelinges fær.
+Aledon þa leofne þeoden,
+beaga bryttan, on bearm scipes,
+mærne be mæste. þær wæs madma fela
+of feorwegum, frætwa, gelæded;
+ne hyrde ic cymlicor ceol gegyrwan
+hildewæpnum ond heaðowædum,
+billum ond byrnum; him on bearme læg
+madma mænigo, þa him mid scoldon
+on flodes æht feor gewitan.
+Nalæs hi hine læssan lacum teodan,
+þeodgestreonum, þon þa dydon
+þe hine æt frumsceafte forð onsendon
+ænne ofer yðe umborwesende.
+þa gyt hie him asetton segen geldenne
+heah ofer heafod, leton holm beran,
+geafon on garsecg; him wæs geomor sefa,
+murnende mod. Men ne cunnon
+secgan to soðe, selerædende,
+hæleð under heofenum, hwa þæm hlæste onfeng.
+ða wæs on burgum Beowulf Scyldinga,
+leof leodcyning, longe þrage
+folcum gefræge fæder ellor hwearf,
+aldor of earde, oþþæt him eft onwoc
+heah Healfdene; heold þenden lifde,
+gamol ond guðreouw, glæde Scyldingas.
+ðæm feower bearn forð gerimed
+in worold wocun, weoroda ræswan,
+Heorogar ond Hroðgar ond Halga til;
+hyrde ic þæt wæs Onelan cwen,
+Heaðoscilfingas healsgebedda.
+þa wæs Hroðgare heresped gyfen,
+wiges weorðmynd, þæt him his winemagas
+georne hyrdon, oðð þæt seo geogoð geweox,
+magodriht micel. Him on mod bearn
+þæt healreced hatan wolde,
+medoærn micel, men gewyrcean
+þonne yldo bearn æfre gefrunon,
+ond þær on innan eall gedælan
+geongum ond ealdum, swylc him god sealde,
+buton folcscare ond feorum gumena.
+ða ic wide gefrægn weorc gebannan
+manigre mægþe geond þisne middangeard,
+folcstede frætwan. Him on fyrste gelomp,
+ædre mid yldum, þæt hit wearð ealgearo,
+healærna mæst; scop him Heort naman
+se þe his wordes geweald wide hæfde.
+He beot ne aleh, beagas dælde,
+sinc æt symle. Sele hlifade,
+heah ond horngeap, heaðowylma bad,
+laðan liges; ne wæs hit lenge þa gen
+þæt se ecghete aþumsweorum,
+æfter wælniðe wæcnan scolde.
+ða se ellengæst earfoðlice
+þrage geþolode, se þe in þystrum bad,
+þæt he dogora gehwam dream gehyrde
+hludne in healle; þær wæs hearpan sweg,
+swutol sang scopes. Sægde se þe cuþe
+frumsceaft fira feorran reccan,
+cwæð þæt se ælmihtiga eorðan worhte,
+wlitebeorhtne wang, swa wæter bebugeð,
+gesette sigehreþig sunnan ond monan
+leoman to leohte landbuendum
+ond gefrætwade foldan sceatas
+leomum ond leafum, lif eac gesceop
+cynna gehwylcum þara ðe cwice hwyrfaþ.
+Swa ða drihtguman dreamum lifdon
+eadiglice, oððæt an ongan
+fyrene fremman feond on helle.
+Wæs se grimma gæst Grendel haten,
+mære mearcstapa, se þe moras heold,
+fen ond fæsten; fifelcynnes eard
+wonsæli wer weardode hwile,
+siþðan him scyppend forscrifen hæfde
+in Caines cynne. þone cwealm gewræc
+ece drihten, þæs þe he Abel slog;
+ne gefeah he þære fæhðe, ac he hine feor forwræc,
+metod for þy mane, mancynne fram.
+þanon untydras ealle onwocon,
+eotenas ond ylfe ond orcneas,
+swylce gigantas, þa wið gode wunnon
+lange þrage; he him ðæs lean forgeald.
+Gewat ða neosian, syþðan niht becom,
+hean huses, hu hit Hringdene
+æfter beorþege gebun hæfdon.
+Fand þa ðær inne æþelinga gedriht
+swefan æfter symble; sorge ne cuðon,
+wonsceaft wera. Wiht unhælo,
+grim ond grædig, gearo sona wæs,
+reoc ond reþe, ond on ræste genam
+þritig þegna, þanon eft gewat
+huðe hremig to ham faran,
+mid þære wælfylle wica neosan.
+ða wæs on uhtan mid ærdæge
+Grendles guðcræft gumum undyrne;
+þa wæs æfter wiste wop up ahafen,
+micel morgensweg. Mære þeoden,
+æþeling ærgod, unbliðe sæt,
+þolode ðryðswyð, þegnsorge dreah,
+syðþan hie þæs laðan last sceawedon,
+wergan gastes; wæs þæt gewin to strang,
+lað ond longsum. Næs hit lengra fyrst,
+ac ymb ane niht eft gefremede
+morðbeala mare ond no mearn fore,
+fæhðe ond fyrene; wæs to fæst on þam.
+þa wæs eaðfynde þe him elles hwær
+gerumlicor ræste sohte,
+bed æfter burum, ða him gebeacnod wæs,
+gesægd soðlice sweotolan tacne
+healðegnes hete; heold hyne syðþan
+fyr ond fæstor se þæm feonde ætwand.
+Swa rixode ond wið rihte wan,
+ana wið eallum, oðþæt idel stod
+husa selest. Wæs seo hwil micel;
+XII wintra tid torn geþolode
+wine Scyldinga, weana gehwelcne,
+sidra sorga. Forðam secgum wearð,
+ylda bearnum, undyrne cuð,
+gyddum geomore, þætte Grendel wan
+hwile wið Hroþgar, heteniðas wæg,
+fyrene ond fæhðe fela missera,
+singale sæce, sibbe ne wolde
+wið manna hwone mægenes Deniga,
+feorhbealo feorran, fea þingian,
+ne þær nænig witena wenan þorfte
+beorhtre bote to banan folmum,
+ac se æglæca ehtende wæs,
+deorc deaþscua, duguþe ond geogoþe,
+seomade ond syrede, sinnihte heold
+mistige moras. men ne cunnon
+hwyder helrunan hwyrftum scriþað.
+Swa fela fyrena feond mancynnes,
+atol angengea, oft gefremede,
+heardra hynða. Heorot eardode,
+sincfage sel sweartum nihtum;
+no he þone gifstol gretan moste,
+maþðum for metode, ne his myne wisse.
+þæt wæs wræc micel wine Scyldinga,
+modes brecða. Monig oft gesæt
+rice to rune; ræd eahtedon
+hwæt swiðferhðum selest wære
+wið færgryrum to gefremmanne.
+Hwilum hie geheton æt hærgtrafum
+wigweorþunga, wordum bædon
+þæt him gastbona geoce gefremede
+wið þeodþreaum. Swylc wæs þeaw hyra,
+hæþenra hyht; helle gemundon
+in modsefan, metod hie ne cuþon,
+dæda demend, ne wiston hie drihten god,
+ne hie huru heofena helm herian ne cuþon,
+wuldres waldend. Wa bið þæm ðe sceal
+þurh sliðne nið sawle bescufan
+in fyres fæþm, frofre ne wenan,
+wihte gewendan; wel bið þæm þe mot
+æfter deaðdæge drihten secean
+ond to fæder fæþmum freoðo wilnian.
+Swa ða mælceare maga Healfdenes
+singala seað, ne mihte snotor hæleð
+wean onwendan; wæs þæt gewin to swyð,
+laþ ond longsum, þe on ða leode becom,
+nydwracu niþgrim, nihtbealwa mæst.
+þæt fram ham gefrægn Higelaces þegn,
+god mid Geatum, Grendles dæda;
+se wæs moncynnes mægenes strengest
+on þæm dæge þysses lifes,
+æþele ond eacen. Het him yðlidan
+godne gegyrwan, cwæð, hu guðcyning
+ofer swanrade secean wolde,
+mærne þeoden, þa him wæs manna þearf.
+ðone siðfæt him snotere ceorlas
+lythwon logon, þeah he him leof wære;
+hwetton higerofne, hæl sceawedon.
+Hæfde se goda Geata leoda
+cempan gecorone þara þe he cenoste
+findan mihte; XVna sum
+sundwudu sohte; secg wisade,
+lagucræftig mon, landgemyrcu.
+Fyrst forð gewat. Flota wæs on yðum,
+bat under beorge. Beornas gearwe
+on stefn stigon; streamas wundon,
+sund wið sande; secgas bæron
+on bearm nacan beorhte frætwe,
+guðsearo geatolic; guman ut scufon,
+weras on wilsið, wudu bundenne.
+Gewat þa ofer wægholm, winde gefysed,
+flota famiheals fugle gelicost,
+oðþæt ymb antid oþres dogores
+wundenstefna gewaden hæfde
+þæt ða liðende land gesawon,
+brimclifu blican, beorgas steape,
+side sænæssas; þa wæs sund liden,
+eoletes æt ende. þanon up hraðe
+Wedera leode on wang stigon,
+sæwudu sældon syrcan hrysedon,
+guðgewædo, gode þancedon
+þæs þe him yþlade eaðe wurdon.
+þa of wealle geseah weard Scildinga,
+se þe holmclifu healdan scolde,
+beran ofer bolcan beorhte randas,
+fyrdsearu fuslicu; hine fyrwyt bræc
+modgehygdum, hwæt þa men wæron.
+Gewat him þa to waroðe wicge ridan
+þegn Hroðgares, þrymmum cwehte
+mægenwudu mundum, meþelwordum frægn:
+Hwæt syndon ge searohæbbendra,
+byrnum werede, þe þus brontne ceol
+ofer lagustræte lædan cwomon,
+hider ofer holmas? le wæs
+endesæta, ægwearde heold,
+þe on land Dena laðra nænig
+mid scipherge sceðþan ne meahte.
+No her cuðlicor cuman ongunnon
+lindhæbbende; ne ge leafnesword
+guðfremmendra gearwe ne wisson,
+maga gemedu. Næfre ic maran geseah
+eorla ofer eorþan ðonne is eower sum,
+secg on searwum; nis þæt seldguma,
+wæpnum geweorðad, næfne him his wlite leoge,
+ænlic ansyn. Nu ic eower sceal
+frumcyn witan, ær ge fyr heonan ,
+leassceaweras, on land Dena
+furþur feran. Nu ge feorbuend,
+mereliðende, minne gehyrað
+anfealdne geþoht: Ofost is selest
+to gecyðanne hwanan eowre cyme syndon.
+Him se yldesta ondswarode,
+werodes wisa, wordhord onleac:
+We synt gumcynnes Geata leode
+ond Higelaces heorðgeneatas.
+Wæs min fæder folcum gecyþed,
+æþele ordfruma, Ecgþeow haten.
+Gebad wintra worn, ær he on weg hwurfe,
+gamol of geardum; hine gearwe geman
+witena welhwylc wide geond eorþan.
+We þurh holdne hige hlaford þinne,
+sunu Healfdenes, secean cwomon,
+leodgebyrgean; wes þu us larena god.
+Habbað we to þæm mæran micel ærende,
+Deniga frean, ne sceal þær dyrne sum
+wesan, þæs ic wene. þu wast gif hit is
+swa we soþlice secgan hyrdon
+þæt mid Scyldingum sceaðona ic nat hwylc,
+deogol dædhata, deorcum nihtum
+eaweð þurh egsan uncuðne nið,
+hynðu ond hrafyl. Ic þæs Hroðgar mæg
+þurh rumne sefan ræd gelæran,
+hu he frod ond god feond oferswyðeþ,
+gyf him edwendan æfre scolde
+bealuwa bisigu, bot eft cuman,
+ond þa cearwylmas colran wurðaþ;
+oððe a syþðan earfoðþrage,
+þreanyd þolað, þenden þær wunað
+on heahstede husa selest.
+Weard maþelode, ðær on wicge sæt,
+ombeht unforht: æghwæþres sceal
+scearp scyldwiga gescad witan,
+worda ond worca, se þe wel þenceð.
+Ic þæt gehyre, þæt þis is hold weorod
+frean Scyldinga. Gewitaþ forð beran
+wæpen ond gewædu; ic eow wisige.
+Swylce ic maguþegnas mine hate
+wið feonda gehwone flotan eowerne,
+niwtyrwydne nacan on sande
+arum healdan, oþðæt eft byreð
+ofer lagustreamas leofne mannan
+wudu wundenhals to Wedermearce,
+godfremmendra swylcum gifeþe bið
+þæt þone hilderæs hal gedigeð.
+Gewiton him þa feran. Flota stille bad,
+seomode on sale sidfæþmed scip,
+on ancre fæst. Eoforlic scionon
+ofer hleorberan gehroden golde,
+fah ond fyrheard; ferhwearde heold
+guþmod grimmon. Guman onetton,
+sigon ætsomne, oþþæt hy sæl timbred,
+geatolic ond goldfah, ongyton mihton;
+þæt wæs foremærost foldbuendum
+receda under roderum, on þæm se rica bad;
+lixte se leoma ofer landa fela.
+Him þa hildedeor hof modigra
+torht getæhte, þæt hie him to mihton
+gegnum gangan; guðbeorna sum
+wicg gewende, word æfter cwæð:
+Mæl is me to feran; fæder alwalda
+mid arstafum eowic gehealde
+siða gesunde. Ic to sæ wille
+wið wrað werod wearde healdan.
+Stræt wæs stanfah, stig wisode
+gumum ætgædere. Guðbyrne scan
+heard hondlocen, hringiren scir
+song in searwum, þa hie to sele furðum
+in hyra gryregeatwum gangan cwomon.
+Setton sæmeþe side scyldas,
+rondas regnhearde, wið þæs recedes weal,
+bugon þa to bence. Byrnan hringdon,
+guðsearo gumena; garas stodon,
+sæmanna searo, samod ætgædere,
+æscholt ufan græg; wæs se irenþreat
+wæpnum gewurþad. þa ðær wlonc hæleð
+oretmecgas æfter æþelum frægn:
+Hwanon ferigeað ge fætte scyldas,
+græge syrcan ond grimhelmas,
+heresceafta heap? Ic eom Hroðgares
+ar ond ombiht. Ne seah ic elþeodige
+þus manige men modiglicran.
+Wen ic þæt ge for wlenco, nalles for wræcsiðum,
+ac for higeþrymmum Hroðgar sohton.
+Him þa ellenrof andswarode,
+wlanc Wedera leod, word æfter spræc,
+heard under helme: We synt Higelaces
+beodgeneatas; Beowulf is min nama.
+Wille ic asecgan sunu Healfdenes,
+mærum þeodne, min ærende,
+aldre þinum, gif he us geunnan wile
+þæt we hine swa godne gretan moton.
+Wulfgar maþelode þæt wæs Wendla leod;
+wæs his modsefa manegum gecyðed,
+wig ond wisdom: Ic þæs wine Deniga,
+frean Scildinga, frinan wille,
+beaga bryttan, swa þu bena eart,
+þeoden mærne, ymb þinne sið,
+ond þe þa ondsware ædre gecyðan
+ðe me se goda agifan þenceð.
+Hwearf þa hrædlice þær Hroðgar sæt
+eald ond anhar mid his eorla gedriht;
+eode ellenrof, þæt he for eaxlum gestod
+Deniga frean; cuþe he duguðe þeaw.
+Wulfgar maðelode to his winedrihtne:
+Her syndon geferede, feorran cumene
+ofer geofenes begang Geata leode;
+þone yldestan oretmecgas
+Beowulf nemnað. Hy benan synt
+þæt hie, þeoden min, wið þe moton
+wordum wrixlan. No ðu him wearne geteoh
+ðinra gegncwida, glædman Hroðgar.
+Hy on wiggetawum wyrðe þinceað
+eorla geæhtlan; huru se aldor deah,
+se þæm heaðorincum hider wisade.
+Hroðgar maþelode, helm Scyldinga:
+Ic hine cuðe cnihtwesende.
+Wæs his ealdfæder Ecgþeo haten,
+ðæm to ham forgeaf Hreþel Geata
+angan dohtor; is his eafora nu
+heard her cumen, sohte holdne wine.
+ðonne sægdon þæt sæliþende,
+þa ðe gifsceattas Geata fyredon
+þyder to þance, þæt he XXXtiges
+manna mægencræft on his mundgripe
+heaþorof hæbbe. Hine halig god
+for arstafum us onsende,
+to Westdenum, þæs ic wen hæbbe,
+wið Grendles gryre. Ic þæm godan sceal
+for his modþræce madmas beodan.
+Beo ðu on ofeste, hat in gan
+seon sibbegedriht samod ætgædere;
+gesaga him eac wordum þæt hie sint wilcuman
+Deniga leodum.
+[] word inne abead:
+Eow het secgan sigedrihten min,
+aldor Eastdena, þæt he eower æþelu can,
+ond ge him syndon ofer sæwylmas
+heardhicgende hider wilcuman.
+Nu ge moton gangan in eowrum guðgeatawum
+under heregriman Hroðgar geseon;
+lætað hildebord her onbidan,
+wudu, wælsceaftas, worda geþinges.
+Aras þa se rica, ymb hine rinc manig,
+þryðlic þegna heap; sume þær bidon,
+heaðoreaf heoldon, swa him se hearda bebead.
+Snyredon ætsomne, þa secg wisode,
+under Heorotes hrof
+heard under helme, þæt he on heoðe gestod.
+Beowulf maðelode on him byrne scan,
+searonet seowed smiþes orþancum:
+Wæs þu, Hroðgar, hal. Ic eom Higelaces
+mæg ond magoðegn; hæbbe ic mærða fela
+ongunnen on geogoþe. Me wearð Grendles þing
+on minre eþeltyrf undyrne cuð;
+secgað sæliðend þæt þæs sele stande,
+reced selesta, rinca gehwylcum
+idel ond unnyt, siððan æfenleoht
+under heofenes hador beholen weorþeð.
+þa me þæt gelærdon leode mine
+þa selestan, snotere ceorlas,
+þeoden Hroðgar, þæt ic þe sohte,
+forþan hie mægenes cræft minne cuþon,
+selfe ofersawon, ða ic of searwum cwom,
+fah from feondum. þær ic fife geband,
+yðde eotena cyn ond on yðum slog
+niceras nihtes, nearoþearfe dreah,
+wræc Wedera nið wean ahsodon,
+forgrand gramum, ond nu wið Grendel sceal,
+wið þam aglæcan, ana gehegan
+ðing wið þyrse. Ic þe nu ða,
+brego Beorhtdena, biddan wille,
+eodor Scyldinga, anre bene,
+þæt ðu me ne forwyrne, wigendra hleo,
+freowine folca, nu ic þus feorran com,
+þæt ic mote ana ond minra eorla gedryht,
+þes hearda heap, Heorot fælsian.
+Hæbbe ic eac geahsod þæt se æglæca
+for his wonhydum wæpna ne recceð.
+Ic þæt þonne forhicge swa me Higelac sie,
+min mondrihten, modes bliðe,
+þæt ic sweord bere oþðe sidne scyld,
+geolorand to guþe, ac ic mid grape sceal
+fon wið feonde ond ymb feorh sacan,
+lað wið laþum; ðær gelyfan sceal
+dryhtnes dome se þe hine deað nimeð.
+Wen ic þæt he wille, gif he wealdan mot,
+in þæm guðsele Geotena leode
+etan unforhte, swa he oft dyde,
+mægen Hreðmanna. Na þu minne þearft
+hafalan hydan, ac he me habban wile
+dreore fahne, gif mec deað nimeð.
+Byreð blodig wæl, byrgean þenceð,
+eteð angenga unmurnlice,
+mearcað morhopu; no ðu ymb mines ne þearft
+lices feorme leng sorgian.
+Onsend Higelace, gif mec hild nime,
+beaduscruda betst, þæt mine breost wereð,
+hrægla selest; þæt is Hrædlan laf,
+Welandes geweorc. Gæð a wyrd swa hio scel.
+Hroðgar maþelode, helm Scyldinga:
+For gewyrhtum þu, wine min Beowulf,
+ond for arstafum usic sohtest.
+Gesloh þin fæder fæhðe mæste;
+wearþ he Heaþolafe to handbonan
+mid Wilfingum; ða hine Wedera cyn
+for herebrogan habban ne mihte.
+þanon he gesohte Suðdena folc
+ofer yða gewealc, Arscyldinga.
+ða ic furþum weold folce Deniga
+ond on geogoðe heold ginne rice,
+hordburh hæleþa; ða wæs Heregar dead,
+min yldra mæg unlifigende,
+bearn Healfdenes; se wæs betera ðonne ic.
+Siððan þa fæhðe feo þingode;
+sende ic Wylfingum ofer wæteres hrycg
+ealde madmas; he me aþas swor.
+Sorh is me to secganne on sefan minum
+gumena ængum hwæt me Grendel hafað
+hynðo on Heorote mid his heteþancum,
+færniða gefremed. Is min fletwerod,
+wigheap gewanod; hie wyrd forsweop
+on Grendles gryre. God eaþe mæg
+þone dolsceaðan dæda getwæfan.
+Ful oft gebeotedon beore druncne
+ofer ealowæge oretmecgas
+þæt hie in beorsele bidan woldon
+Grendles guþe mid gryrum ecga.
+ðonne wæs þeos medoheal on morgentid,
+drihtsele dreorfah, þonne dæg lixte,
+eal bencþelu blode bestymed,
+heall heorudreore; ahte ic holdra þy læs,
+deorre duguðe, þe þa deað fornam.
+Site nu to symle ond onsæl meoto,
+sigehreð secgum, swa þin sefa hwette.
+þa wæs Geatmæcgum geador ætsomne
+on beorsele benc gerymed;
+þær swiðferhþe sittan eodon,
+þryðum dealle. þegn nytte beheold,
+se þe on handa bær hroden ealowæge,
+scencte scir wered. Scop hwilum sang
+hador on Heorote. þær wæs hæleða dream,
+duguð unlytel Dena ond Wedera.
+Unferð maþelode, Ecglafes bearn,
+þe æt fotum sæt frean Scyldinga,
+onband beadurune wæs him Beowulfes sið,
+modges merefaran, micel æfþunca,
+forþon þe he ne uþe þæt ænig oðer man
+æfre mærða þon ma middangeardes
+gehedde under heofenum þonne he sylfa:
+Eart þu se Beowulf, se þe wið Brecan wunne,
+on sidne sæ ymb sund flite,
+ðær git for wlence wada cunnedon
+ond for dolgilpe on deop wæter
+aldrum neþdon? Ne inc ænig mon,
+ne leof ne lað, belean mihte
+sorhfullne sið, þa git on sund reon.
+þær git eagorstream earmum þehton,
+mæton merestræta, mundum brugdon,
+glidon ofer garsecg; geofon yþum weol,
+wintrys wylmum. Git on wæteres æht
+seofon niht swuncon; he þe æt sunde oferflat,
+hæfde mare mægen. þa hine on morgentid
+on Heaþoræmas holm up ætbær;
+ðonon he gesohte swæsne eþel,
+leof his leodum, lond Brondinga,
+freoðoburh fægere, þær he folc ahte
+burh ond beagas. Beot eal wið þe
+sunu Beanstanes soðe gelæste.
+ðonne wene ic to þe wyrsan geþingea,
+ðeah þu heaðoræsa gehwær dohte,
+grimre guðe, gif þu Grendles dearst
+nihtlongne fyrst nean bidan.
+Beowulf maþelode, bearn Ecgþeowes:
+Hwæt. þu worn fela, wine min Unferð,
+beore druncen ymb Brecan spræce,
+sægdest from his siðe. Soð ic talige,
+þæt ic merestrengo maran ahte,
+earfeþo on yþum, ðonne ænig oþer man.
+Wit þæt gecwædon cnihtwesende
+ond gebeotedon wæron begen þa git
+on geogoðfeore þæt wit on garsecg ut
+aldrum neðdon, ond þæt geæfndon swa.
+Hæfdon swurd nacod, þa wit on sund reon,
+heard on handa; wit unc wið hronfixas
+werian þohton. No he wiht fram me
+flodyþum feor fleotan meahte,
+hraþor on holme; no ic fram him wolde.
+ða wit ætsomne on sæ wæron
+fif nihta fyrst, oþþæt unc flod todraf,
+wado weallende, wedera cealdost,
+nipende niht, ond norþanwind
+heaðogrim ondhwearf; hreo wæron yþa.
+Wæs merefixa mod onhrered;
+þær me wið laðum licsyrce min,
+heard, hondlocen, helpe gefremede,
+beadohrægl broden on breostum læg
+golde gegyrwed. Me to grunde teah
+fah feondscaða, fæste hæfde
+grim on grape; hwæþre me gyfeþe wearð
+þæt ic aglæcan orde geræhte,
+hildebille; heaþoræs fornam
+mihtig meredeor þurh mine hand.
+Swa mec gelome laðgeteonan
+þreatedon þearle. Ic him þenode
+deoran sweorde, swa hit gedefe wæs.
+Næs hie ðære fylle gefean hæfdon,
+manfordædlan, þæt hie me þegon,
+symbel ymbsæton sægrunde neah;
+ac on mergenne mecum wunde
+be yðlafe uppe lægon,
+sweordum aswefede, þæt syðþan na
+ymb brontne ford brimliðende
+lade ne letton. Leoht eastan com,
+beorht beacen godes; brimu swaþredon,
+þæt ic sænæssas geseon mihte,
+windige weallas. Wyrd oft nereð
+unfægne eorl, þonne his ellen deah.
+Hwæþere me gesælde þæt ic mid sweorde ofsloh
+niceras nigene. No ic on niht gefrægn
+under heofones hwealf heardran feohtan,
+ne on egstreamum earmran mannon;
+hwaþere ic fara feng feore gedigde,
+siþes werig. ða mec sæ oþbær,
+flod æfter faroðe on Finna land,
+wadu weallendu. No ic wiht fram þe
+swylcra searoniða secgan hyrde,
+billa brogan. Breca næfre git
+æt heaðolace, ne gehwæþer incer,
+swa deorlice dæd gefremede
+fagum sweordum no ic þæs fela gylpe,
+þeah ðu þinum broðrum to banan wurde,
+heafodmægum; þæs þu in helle scealt
+werhðo dreogan, þeah þin wit duge.
+Secge ic þe to soðe, sunu Ecglafes,
+þæt næfre Grendel swa fela gryra gefremede,
+atol æglæca, ealdre þinum,
+hynðo on Heorote, gif þin hige wære,
+sefa swa searogrim, swa þu self talast.
+Ac he hafað onfunden þæt he þa fæhðe ne þearf,
+atole ecgþræce eower leode
+swiðe onsittan, Sigescyldinga;
+nymeð nydbade, nænegum arað
+leode Deniga, ac he lust wigeð,
+swefeð ond sendeþ, secce ne weneþ
+to Gardenum. Ac ic him Geata sceal
+eafoð ond ellen ungeara nu,
+guþe gebeodan. Gæþ eft se þe mot
+to medo modig, siþþan morgenleoht
+ofer ylda bearn oþres dogores,
+sunne sweglwered suþan scineð.
+þa wæs on salum sinces brytta,
+gamolfeax ond guðrof; geoce gelyfde
+brego Beorhtdena, gehyrde on Beowulfe
+folces hyrde fæstrædne geþoht.
+ðær wæs hæleþa hleahtor, hlyn swynsode,
+word wæron wynsume. Eode Wealhþeow forð,
+cwen Hroðgares, cynna gemyndig,
+grette goldhroden guman on healle,
+ond þa freolic wif ful gesealde
+ærest Eastdena eþelwearde,
+bæd hine bliðne æt þære beorþege,
+leodum leofne. He on lust geþeah
+symbel ond seleful, sigerof kyning.
+Ymbeode þa ides Helminga
+duguþe ond geogoþe dæl æghwylcne,
+sincfato sealde, oþþæt sæl alamp
+þæt hio Beowulfe, beaghroden cwen
+mode geþungen, medoful ætbær;
+grette Geata leod, gode þancode
+wisfæst wordum þæs ðe hire se willa gelamp
+þæt heo on ænigne eorl gelyfde
+fyrena frofre. He þæt ful geþeah,
+wælreow wiga, æt Wealhþeon,
+ond þa gyddode guþe gefysed;
+Beowulf maþelode, bearn Ecgþeowes:
+Ic þæt hogode, þa ic on holm gestah,
+sæbat gesæt mid minre secga gedriht,
+þæt ic anunga eowra leoda
+willan geworhte oþðe on wæl crunge,
+feondgrapum fæst. Ic gefremman sceal
+eorlic ellen, oþðe endedæg
+on þisse meoduhealle minne gebidan.
+ðam wife þa word wel licodon,
+gilpcwide Geates; eode goldhroden
+freolicu folccwen to hire frean sittan.
+þa wæs eft swa ær inne on healle
+þryðword sprecen, ðeod on sælum,
+sigefolca sweg, oþþæt semninga
+sunu Healfdenes secean wolde
+æfenræste; wiste þæm ahlæcan
+to þæm heahsele hilde geþinged,
+siððan hie sunnan leoht geseon ne meahton,
+oðþe nipende niht ofer ealle,
+scaduhelma gesceapu scriðan cwoman,
+wan under wolcnum. Werod eall aras.
+Gegrette þa guma oþerne,
+Hroðgar Beowulf, ond him hæl abead,
+winærnes geweald, ond þæt word acwæð:
+Næfre ic ænegum men ær alyfde,
+siþðan ic hond ond rond hebban mihte,
+ðryþærn Dena buton þe nu ða.
+Hafa nu ond geheald husa selest,
+gemyne mærþo, mægenellen cyð,
+waca wið wraþum. Ne bið þe wilna gad,
+gif þu þæt ellenweorc aldre gedigest.
+ða him Hroþgar gewat mid his hæleþa gedryht,
+eodur Scyldinga, ut of healle;
+wolde wigfruma Wealhþeo secan,
+cwen to gebeddan. Hæfde kyningwuldor
+Grendle togeanes, swa guman gefrungon,
+seleweard aseted; sundornytte beheold
+ymb aldor Dena, eotonweard abead.
+Huru Geata leod georne truwode
+modgan mægnes, metodes hyldo.
+ða he him of dyde isernbyrnan,
+helm of hafelan, sealde his hyrsted sweord,
+irena cyst, ombihtþegne,
+ond gehealdan het hildegeatwe.
+Gespræc þa se goda gylpworda sum,
+Beowulf Geata, ær he on bed stige:
+No ic me an herewæsmun hnagran talige,
+guþgeweorca, þonne Grendel hine;
+forþan ic hine sweorde swebban nelle,
+aldre beneotan, þeah ic eal mæge.
+Nat he þara goda þæt he me ongean slea,
+rand geheawe, þeah ðe he rof sie
+niþgeweorca; ac wit on niht sculon
+secge ofersittan, gif he gesecean dear
+wig ofer wæpen, ond siþðan witig god
+on swa hwæþere hond, halig dryhten,
+mærðo deme, swa him gemet þince.
+Hylde hine þa heaþodeor, hleorbolster onfeng
+eorles andwlitan, ond hine ymb monig
+snellic særinc selereste gebeah.
+Nænig heora þohte þæt he þanon scolde
+eft eardlufan æfre gesecean,
+folc oþðe freoburh, þær he afeded wæs;
+ac hie hæfdon gefrunen þæt hie ær to fela micles
+in þæm winsele wældeað fornam,
+Denigea leode. Ac him dryhten forgeaf
+wigspeda gewiofu, Wedera leodum,
+frofor ond fultum, þæt hie feond heora
+ðurh anes cræft ealle ofercomon,
+selfes mihtum. Soð is gecyþed
+þæt mihtig god manna cynnes
+weold wideferhð. Com on wanre niht
+scriðan sceadugenga. Sceotend swæfon,
+þa þæt hornreced healdan scoldon,
+ealle buton anum. þæt wæs yldum cuþ
+þæt hie ne moste, þa metod nolde,
+se scynscaþa under sceadu bregdan;
+ac he wæccende wraþum on andan
+bad bolgenmod beadwa geþinges.
+ða com of more under misthleoþum
+Grendel gongan, godes yrre bær;
+mynte se manscaða manna cynnes
+sumne besyrwan in sele þam hean.
+Wod under wolcnum to þæs þe he winreced,
+goldsele gumena, gearwost wisse,
+fættum fahne. Ne wæs þæt forma sið
+þæt he Hroþgares ham gesohte;
+næfre he on aldordagum ær ne siþðan
+heardran hæle, healðegnas fand.
+Com þa to recede rinc siðian,
+dreamum bedæled. Duru sona onarn,
+fyrbendum fæst, syþðan he hire folmum æthran;
+onbræd þa bealohydig, ða he gebolgen wæs,
+recedes muþan. Raþe æfter þon
+on fagne flor feond treddode,
+eode yrremod; him of eagum stod
+ligge gelicost leoht unfæger.
+Geseah he in recede rinca manige,
+swefan sibbegedriht samod ætgædere,
+magorinca heap. þa his mod ahlog;
+mynte þæt he gedælde, ærþon dæg cwome,
+atol aglæca, anra gehwylces
+lif wið lice, þa him alumpen wæs
+wistfylle wen. Ne wæs þæt wyrd þa gen
+þæt he ma moste manna cynnes
+ðicgean ofer þa niht. þryðswyð beheold
+mæg Higelaces, hu se manscaða
+under færgripum gefaran wolde.
+Ne þæt se aglæca yldan þohte,
+ac he gefeng hraðe forman siðe
+slæpendne rinc, slat unwearnum,
+bat banlocan, blod edrum dranc,
+synsnædum swealh; sona hæfde
+unlyfigendes eal gefeormod,
+fet ond folma. Forð near ætstop,
+nam þa mid handa higeþihtigne
+rinc on ræste, ræhte ongean
+feond mid folme; he onfeng hraþe
+inwitþancum ond wið earm gesæt.
+Sona þæt onfunde fyrena hyrde
+þæt he ne mette middangeardes,
+eorþan sceata, on elran men
+mundgripe maran. He on mode wearð
+forht on ferhðe; no þy ær fram meahte.
+Hyge wæs him hinfus, wolde on heolster fleon,
+secan deofla gedræg; ne wæs his drohtoð þær
+swylce he on ealderdagum ær gemette.
+Gemunde þa se goda, mæg Higelaces,
+æfenspræce, uplang astod
+ond him fæste wiðfeng; fingras burston.
+Eoten wæs utweard; eorl furþur stop.
+Mynte se mæra, þær he meahte swa,
+widre gewindan ond on weg þanon
+fleon on fenhopu; wiste his fingra geweald
+on grames grapum. þæt wæs geocor sið
+þæt se hearmscaþa to Heorute ateah.
+Dryhtsele dynede; Denum eallum wearð,
+ceasterbuendum, cenra gehwylcum,
+eorlum ealuscerwen. Yrre wæron begen,
+reþe renweardas. Reced hlynsode.
+þa wæs wundor micel þæt se winsele
+wiðhæfde heaþodeorum, þæt he on hrusan ne feol,
+fæger foldbold; ac he þæs fæste wæs
+innan ond utan irenbendum
+searoþoncum besmiþod. þær fram sylle abeag
+medubenc monig, mine gefræge,
+golde geregnad, þær þa graman wunnon.
+þæs ne wendon ær witan Scyldinga
+þæt hit a mid gemete manna ænig,
+betlic ond banfag, tobrecan meahte,
+listum tolucan, nymþe liges fæþm
+swulge on swaþule. Sweg up astag
+niwe geneahhe; Norðdenum stod
+atelic egesa, anra gehwylcum
+þara þe of wealle wop gehyrdon,
+gryreleoð galan godes ondsacan,
+sigeleasne sang, sar wanigean
+helle hæfton. Heold hine fæste
+se þe manna wæs mægene strengest
+on þæm dæge þysses lifes.
+Nolde eorla hleo ænige þinga
+þone cwealmcuman cwicne forlætan,
+ne his lifdagas leoda ænigum
+nytte tealde. þær genehost brægd
+eorl Beowulfes ealde lafe,
+wolde freadrihtnes feorh ealgian,
+mæres þeodnes, ðær hie meahton swa.
+Hie þæt ne wiston, þa hie gewin drugon,
+heardhicgende hildemecgas,
+ond on healfa gehwone heawan þohton,
+sawle secan, þone synscaðan
+ænig ofer eorþan irenna cyst,
+guðbilla nan, gretan nolde,
+ac he sigewæpnum forsworen hæfde,
+ecga gehwylcre. Scolde his aldorgedal
+on ðæm dæge þysses lifes
+earmlic wurðan, ond se ellorgast
+on feonda geweald feor siðian.
+ða þæt onfunde se þe fela æror
+modes myrðe manna cynne,
+fyrene gefremede he wæs fag wið god,
+þæt him se lichoma læstan nolde,
+ac hine se modega mæg Hygelaces
+hæfde be honda; wæs gehwæþer oðrum
+lifigende lað. Licsar gebad
+atol æglæca; him on eaxle wearð
+syndolh sweotol, seonowe onsprungon,
+burston banlocan. Beowulfe wearð
+guðhreð gyfeþe; scolde Grendel þonan
+feorhseoc fleon under fenhleoðu,
+secean wynleas wic; wiste þe geornor
+þæt his aldres wæs ende gegongen,
+dogera dægrim. Denum eallum wearð
+æfter þam wælræse willa gelumpen.
+Hæfde þa gefælsod se þe ær feorran com,
+snotor ond swyðferhð, sele Hroðgares,
+genered wið niðe; nihtweorce gefeh,
+ellenmærþum. Hæfde Eastdenum
+Geatmecga leod gilp gelæsted,
+swylce oncyþðe ealle gebette,
+inwidsorge, þe hie ær drugon
+ond for þreanydum þolian scoldon,
+torn unlytel. þæt wæs tacen sweotol,
+syþðan hildedeor hond alegde,
+earm ond eaxle þær wæs eal geador
+Grendles grape under geapne hrof.
+ða wæs on morgen mine gefræge
+ymb þa gifhealle guðrinc monig;
+ferdon folctogan feorran ond nean
+geond widwegas wundor sceawian,
+laþes lastas. No his lifgedal
+sarlic þuhte secga ænegum
+þara þe tirleases trode sceawode,
+hu he werigmod on weg þanon,
+niða ofercumen, on nicera mere
+fæge ond geflymed feorhlastas bær.
+ðær wæs on blode brim weallende,
+atol yða geswing eal gemenged
+haton heolfre, heorodreore weol.
+Deaðfæge deog, siððan dreama leas
+in fenfreoðo feorh alegde,
+hæþene sawle; þær him hel onfeng.
+þanon eft gewiton ealdgesiðas,
+swylce geong manig of gomenwaþe
+fram mere modge mearum ridan,
+beornas on blancum. ðær wæs Beowulfes
+mærðo mæned; monig oft gecwæð
+þætte suð ne norð be sæm tweonum
+ofer eormengrund oþer nænig
+under swegles begong selra nære
+rondhæbbendra, rices wyrðra.
+Ne hie huru winedrihten wiht ne logon,
+glædne Hroðgar, ac þæt wæs god cyning.
+Hwilum heaþorofe hleapan leton,
+on geflit faran fealwe mearas
+ðær him foldwegas fægere þuhton,
+cystum cuðe. Hwilum cyninges þegn,
+guma gilphlæden, gidda gemyndig,
+se ðe ealfela ealdgesegena
+worn gemunde, word oþer fand
+soðe gebunden; secg eft ongan
+sið Beowulfes snyttrum styrian
+ond on sped wrecan spel gerade,
+wordum wrixlan. Welhwylc gecwæð
+þæt he fram Sigemundes secgan hyrde
+ellendædum, uncuþes fela,
+Wælsinges gewin, wide siðas,
+þara þe gumena bearn gearwe ne wiston,
+fæhðe ond fyrena, buton Fitela mid hine,
+þonne he swulces hwæt secgan wolde,
+eam his nefan, swa hie a wæron
+æt niða gehwam nydgesteallan;
+hæfdon ealfela eotena cynnes
+sweordum gesæged. Sigemunde gesprong
+æfter deaðdæge dom unlytel,
+syþðan wiges heard wyrm acwealde,
+hordes hyrde. He under harne stan,
+æþelinges bearn, ana geneðde
+frecne dæde, ne wæs him Fitela mid.
+hwæþre him gesælde ðæt þæt swurd þurhwod
+wrætlicne wyrm, þæt hit on wealle ætstod,
+dryhtlic iren; draca morðre swealt.
+Hæfde aglæca elne gegongen
+þæt he beahhordes brucan moste
+selfes dome; sæbat gehleod,
+bær on bearm scipes beorhte frætwa,
+Wælses eafera. Wyrm hat gemealt.
+Se wæs wreccena wide mærost
+ofer werþeode, wigendra hleo,
+ellendædum he þæs ær onðah,
+siððan Heremodes hild sweðrode,
+eafoð ond ellen. He mid Eotenum wearð
+on feonda geweald forð forlacen,
+snude forsended. Hine sorhwylmas
+lemede to lange; he his leodum wearð,
+eallum æþellingum to aldorceare;
+swylce oft bemearn ærran mælum
+swiðferhþes sið snotor ceorl monig,
+se þe him bealwa to bote gelyfde,
+þæt þæt ðeodnes bearn geþeon scolde,
+fæderæþelum onfon, folc gehealdan,
+hord ond hleoburh, hæleþa rice,
+eþel Scyldinga. He þær eallum wearð,
+mæg Higelaces, manna cynne,
+freondum gefægra; hine fyren onwod.
+Hwilum flitende fealwe stræte
+mearum mæton. ða wæs morgenleoht
+scofen ond scynded. Eode scealc monig
+swiðhicgende to sele þam hean
+searowundor seon; swylce self cyning
+of brydbure, beahhorda weard,
+tryddode tirfæst getrume micle,
+cystum gecyþed, ond his cwen mid him
+medostigge mæt mægþa hose.
+Hroðgar maþelode he to healle geong,
+stod on stapole, geseah steapne hrof,
+golde fahne, ond Grendles hond:
+ðisse ansyne alwealdan þanc
+lungre gelimpe. Fela ic laþes gebad,
+grynna æt Grendle; a mæg god wyrcan
+wunder æfter wundre, wuldres hyrde.
+ðæt wæs ungeara þæt ic ænigra me
+weana ne wende to widan feore
+bote gebidan, þonne blode fah
+husa selest heorodreorig stod,
+wea widscofen witena gehwylcum
+ðara þe ne wendon þæt hie wideferhð
+leoda landgeweorc laþum beweredon
+scuccum ond scinnum. Nu scealc hafað
+þurh drihtnes miht dæd gefremede ðe
+we ealle ær ne meahton
+snyttrum besyrwan. Hwæt, þæt secgan mæg
+efne swa hwylc mægþa swa ðone magan cende
+æfter gumcynnum, gyf heo gyt lyfað,
+þæt hyre ealdmetod este wære
+bearngebyrdo. Nu ic, Beowulf, þec,
+secg betsta, me for sunu wylle
+freogan on ferhþe; heald forð tela
+niwe sibbe. Ne bið þe nænigra gad
+worolde wilna, þe ic geweald hæbbe.
+Ful oft ic for læssan lean teohhode,
+hordweorþunge hnahran rince,
+sæmran æt sæcce. þu þe self hafast
+dædum gefremed þæt þin dom lyfað
+awa to aldre. Alwalda þec
+gode forgylde, swa he nu gyt dyde.
+Beowulf maþelode, bearn Ecþeowes:
+We þæt ellenweorc estum miclum,
+feohtan fremedon, frecne geneðdon
+eafoð uncuþes. Uþe ic swiþor
+þæt ðu hine selfne geseon moste,
+feond on frætewum fylwerigne.
+Ic hine hrædlice heardan clammum
+on wælbedde wriþan þohte,
+þæt he for mundgripe minum scolde
+licgean lifbysig, butan his lic swice.
+Ic hine ne mihte, þa metod nolde,
+ganges getwæman, no ic him þæs georne ætfealh,
+feorhgeniðlan; wæs to foremihtig
+feond on feþe. Hwæþere he his folme forlet
+to lifwraþe last weardian,
+earm ond eaxle. No þær ænige swa þeah
+feasceaft guma frofre gebohte;
+no þy leng leofað laðgeteona,
+synnum geswenced, ac hyne sar hafað
+mid nydgripe nearwe befongen,
+balwon bendum. ðær abidan sceal
+maga mane fah miclan domes,
+hu him scir metod scrifan wille.
+ða wæs swigra secg, sunu Eclafes,
+on gylpspræce guðgeweorca,
+siþðan æþelingas eorles cræfte
+ofer heanne hrof hand sceawedon,
+feondes fingras. Foran æghwylc wæs,
+stiðra nægla gehwylc, style gelicost,
+hæþenes handsporu hilderinces,
+egl, unheoru. æghwylc gecwæð
+þæt him heardra nan hrinan wolde
+iren ærgod, þæt ðæs ahlæcan
+blodge beadufolme onberan wolde.
+ða wæs haten hreþe Heort innanweard
+folmum gefrætwod. Fela þæra wæs,
+wera ond wifa, þe þæt winreced,
+gestsele gyredon. Goldfag scinon
+web æfter wagum, wundorsiona fela
+secga gehwylcum þara þe on swylc starað.
+Wæs þæt beorhte bold tobrocen swiðe,
+eal inneweard irenbendum fæst,
+heorras tohlidene. Hrof ana genæs,
+ealles ansund, þe se aglæca,
+fyrendædum fag, on fleam gewand,
+aldres orwena. No þæt yðe byð
+to befleonne, fremme se þe wille,
+ac gesecan sceal sawlberendra,
+nyde genydde, niþða bearna,
+grundbuendra gearwe stowe,
+þær his lichoma legerbedde fæst
+swefeþ æfter symle. þa wæs sæl ond mæl
+þæt to healle gang Healfdenes sunu;
+wolde self cyning symbel þicgan.
+Ne gefrægen ic þa mægþe maran weorode
+ymb hyra sincgyfan sel gebæran.
+Bugon þa to bence blædagande,
+fylle gefægon; fægere geþægon
+medoful manig magas þara
+swiðhicgende on sele þam hean,
+Hroðgar ond Hroþulf. Heorot innan wæs
+freondum afylled; nalles facenstafas
+|eodscyldingas þenden fremedon.
+Forgeaf þa Beowulfe bearn Healfdenes
+segen gyldenne sigores to leane;
+hroden hildecumbor, helm ond byrnan,
+mære maðþumsweord manige gesawon
+beforan beorn beran. Beowulf geþah
+ful on flette; no he þære feohgyfte
+for sceotendum scamigan ðorfte.
+Ne gefrægn ic freondlicor feower madmas
+golde gegyrede gummanna fela
+in ealobence oðrum gesellan.
+Ymb þæs helmes hrof heafodbeorge
+wirum bewunden walu utan heold,
+þæt him fela laf frecne ne meahton
+scurheard sceþðan, þonne scyldfreca
+ongean gramum gangan scolde.
+Heht ða eorla hleo eahta mearas
+fætedhleore on flet teon,
+in under eoderas. þara anum stod
+sadol searwum fah, since gewurþad;
+þæt wæs hildesetl heahcyninges,
+ðonne sweorda gelac sunu Healfdenes
+efnan wolde. Næfre on ore læg
+widcuþes wig, ðonne walu feollon.
+Ond ða Beowulfe bega gehwæþres
+eodor Ingwina onweald geteah,
+wicga ond wæpna, het hine wel brucan.
+Swa manlice mære þeoden,
+hordweard hæleþa, heaþoræsas geald
+mearum ond madmum, swa hy næfre man lyhð,
+se þe secgan wile soð æfter rihte.
+ða gyt æghwylcum eorla drihten
+þara þe mid Beowulfe brimlade teah
+on þære medubence maþðum gesealde,
+yrfelafe, ond þone ænne heht
+golde forgyldan, þone ðe Grendel ær
+mane acwealde, swa he hyra ma wolde,
+nefne him witig god wyrd forstode
+ond ðæs mannes mod. Metod eallum weold
+gumena cynnes, swa he nu git deð.
+Forþan bið andgit æghwær selest,
+ferhðes foreþanc. Fela sceal gebidan
+leofes ond laþes se þe longe her
+on ðyssum windagum worolde bruceð.
+þær wæs sang ond sweg samod ætgædere
+fore Healfdenes hildewisan,
+gomenwudu greted, gid oft wrecen,
+ðonne healgamen Hroþgares scop
+æfter medobence mænan scolde
+be Finnes eaferum, ða hie se fær begeat,
+hæleð Healfdena, Hnæf Scyldinga,
+in Freswæle feallan scolde.
+Ne huru Hildeburh herian þorfte
+Eotena treowe; unsynnum wearð
+beloren leofum æt þam lindplegan,
+bearnum ond broðrum; hie on gebyrd hruron,
+gare wunde. þæt wæs geomuru ides.
+Nalles holinga Hoces dohtor
+meotodsceaft bemearn, syþðan morgen com,
+ða heo under swegle geseon meahte
+morþorbealo maga, þær heo ær mæste heold
+worolde wynne. Wig ealle fornam
+Finnes þegnas nemne feaum anum,
+þæt he ne mehte on þæm meðelstede
+wig Hengeste wiht gefeohtan,
+ne þa wealafe wige forþringan
+þeodnes ðegna. ac hig him geþingo budon,
+þæt hie him oðer flet eal gerymdon,
+healle ond heahsetl, þæt hie healfre geweald
+wið Eotena bearn agan moston,
+ond æt feohgyftum Folcwaldan sunu
+dogra gehwylce Dene weorþode,
+Hengestes heap hringum wenede
+efne swa swiðe sincgestreonum
+fættan goldes, swa he Fresena cyn
+on beorsele byldan wolde.
+ða hie getruwedon on twa healfa
+fæste frioðuwære. Fin Hengeste
+elne, unflitme aðum benemde
+þæt he þa wealafe weotena dome
+arum heolde, þæt ðær ænig mon
+wordum ne worcum wære ne bræce,
+ne þurh inwitsearo æfre gemænden
+ðeah hie hira beaggyfan banan folgedon
+ðeodenlease, þa him swa geþearfod wæs.
+gyf þonne Frysna hwylc frecnan spræce
+ðæs morþorhetes myndgiend wære,
+þonne hit sweordes ecg seðan scolde.
+Ad wæs geæfned ond icge gold
+ahæfen of horde. Herescyldinga
+betst beadorinca wæs on bæl gearu.
+æt þæm ade wæs eþgesyne
+swatfah syrce, swyn ealgylden,
+eofer irenheard, æþeling manig
+wundum awyrded; sume on wæle crungon.
+Het ða Hildeburh æt Hnæfes ade
+hire selfre sunu sweoloðe befæstan,
+banfatu bærnan ond on bæl don
+eame on eaxle. Ides gnornode,
+geomrode giddum. Guðrinc astah.
+Wand to wolcnum wælfyra mæst,
+hlynode for hlawe; hafelan multon,
+bengeato burston, ðonne blod ætspranc,
+laðbite lices. Lig ealle forswealg,
+gæsta gifrost, þara ðe þær guð fornam
+bega folces; wæs hira blæd scacen.
+Gewiton him ða wigend wica neosian,
+freondum befeallen, Frysland geseon,
+hamas ond heaburh. Hengest ða gyt
+wælfagne winter wunode mid Finne
+eal unhlitme. Eard gemunde,
+þeah þe he ne meahte on mere drifan
+hringedstefnan; holm storme weol,
+won wið winde, winter yþe beleac
+isgebinde, oþðæt oþer com
+gear in geardas, swa nu gyt deð,
+þa ðe syngales sele bewitiað,
+wuldortorhtan weder. ða wæs winter scacen,
+fæger foldan bearm. Fundode wrecca,
+gist of geardum; he to gyrnwræce
+swiðor þohte þonne to sælade,
+gif he torngemot þurhteon mihte
+þæt he Eotena bearn inne gemunde.
+Swa he ne forwyrnde woroldrædenne,
+þonne him Hunlafing hildeleoman,
+billa selest, on bearm dyde,
+þæs wæron mid Eotenum ecge cuðe.
+Swylce ferhðfrecan Fin eft begeat
+sweordbealo sliðen æt his selfes ham,
+siþðan grimne gripe Guðlaf ond Oslaf
+æfter sæsiðe, sorge, mændon,
+ætwiton weana dæl; ne meahte wæfre mod
+forhabban in hreþre. ða wæs heal roden
+feonda feorum, swilce Fin slægen,
+cyning on corþre, ond seo cwen numen.
+Sceotend Scyldinga to scypon feredon
+eal ingesteald eorðcyninges,
+swylce hie æt Finnes ham findan meahton
+sigla, searogimma. Hie on sælade
+drihtlice wif to Denum feredon,
+læddon to leodum. Leoð wæs asungen,
+gleomannes gyd. Gamen eft astah,
+beorhtode bencsweg; byrelas sealdon
+win of wunderfatum. þa cwom Wealhþeo forð
+gan under gyldnum beage, þær þa godan twegen
+sæton suhtergefæderan; þa gyt wæs hiera sib ætgædere,
+æghwylc oðrum trywe. Swylce þær Unferþ þyle
+æt fotum sæt frean Scyldinga; gehwylc hiora his ferhþe treowde,
+þæt he hæfde mod micel, þeah þe he his magum nære
+arfæst æt ecga gelacum. Spræc ða ides Scyldinga:
+Onfoh þissum fulle, freodrihten min,
+sinces brytta. þu on sælum wes,
+goldwine gumena, ond to Geatum spræc
+mildum wordum, swa sceal man don.
+Beo wið Geatas glæd, geofena gemyndig,
+nean ond feorran þu nu hafast.
+Me man sægde þæt þu ðe for sunu wolde
+hererinc habban. Heorot is gefælsod,
+beahsele beorhta; bruc þenden þu mote
+manigra medo, ond þinum magum læf
+folc ond rice, þonne ðu forð scyle
+metodsceaft seon. Ic minne can
+glædne Hroþulf, þæt he þa geogoðe wile
+arum healdan, gyf þu ær þonne he,
+wine Scildinga, worold oflætest;
+wene ic þæt he mid gode gyldan wille
+uncran eaferan, gif he þæt eal gemon,
+hwæt wit to willan ond to worðmyndum
+umborwesendum ær arna gefremedon.
+Hwearf þa bi bence þær hyre byre wæron,
+Hreðric ond Hroðmund, ond hæleþa bearn,
+giogoð ætgædere; þær se goda sæt,
+Beowulf Geata, be þæm gebroðrum twæm.
+Him wæs ful boren ond freondlaþu
+wordum bewægned, ond wunden gold
+estum geeawed, earmreade twa,
+hrægl ond hringas, healsbeaga mæst
+þara þe ic on foldan gefrægen hæbbe.
+Nænigne ic under swegle selran hyrde
+hordmaððum hæleþa, syþðan Hama ætwæg
+to þære byrhtan byrig Brosinga mene,
+sigle ond sincfæt; searoniðas fleah
+Eormenrices, geceas ecne ræd.
+þone hring hæfde Higelac Geata,
+nefa Swertinges, nyhstan siðe,
+siðþan he under segne sinc ealgode,
+wælreaf werede; hyne wyrd fornam,
+syþðan he for wlenco wean ahsode,
+fæhðe to Frysum. He þa frætwe wæg,
+eorclanstanas ofer yða ful,
+rice þeoden; he under rande gecranc.
+Gehwearf þa in Francna fæþm feorh cyninges,
+breostgewædu ond se beah somod;
+wyrsan wigfrecan wæl reafedon
+æfter guðsceare, Geata leode,
+hreawic heoldon. Heal swege onfeng.
+Wealhðeo maþelode, heo fore þæm werede spræc:
+Bruc ðisses beages, Beowulf leofa,
+hyse, mid hæle, ond þisses hrægles neot,
+þeodgestreona, ond geþeoh tela,
+cen þec mid cræfte ond þyssum cnyhtum wes
+lara liðe; ic þe þæs lean geman.
+Hafast þu gefered þæt ðe feor ond neah
+ealne wideferhþ weras ehtigað,
+efne swa side swa sæ bebugeð,
+windgeard, weallas. Wes þenden þu lifige,
+æþeling, eadig. Ic þe an tela
+sincgestreona. Beo þu suna minum
+dædum gedefe, dreamhealdende.
+Her is æghwylc eorl oþrum getrywe,
+modes milde, mandrihtne hold;
+þegnas syndon geþwære, þeod ealgearo,
+druncne dryhtguman doð swa ic bidde.
+Eode þa to setle. þær wæs symbla cyst;
+druncon win weras. Wyrd ne cuþon,
+geosceaft grimme, swa hit agangen wearð
+eorla manegum, syþðan æfen cwom
+ond him Hroþgar gewat to hofe sinum,
+rice to ræste. Reced weardode
+unrim eorla, swa hie oft ær dydon.
+Bencþelu beredon; hit geondbræded wearð
+beddum ond bolstrum. Beorscealca sum
+fus ond fæge fletræste gebeag.
+Setton him to heafdon hilderandas,
+bordwudu beorhtan; þær on bence wæs
+ofer æþelinge yþgesene
+heaþosteapa helm, hringed byrne,
+þrecwudu þrymlic. Wæs þeaw hyra
+þæt hie oft wæron an wig gearwe,
+ge æt ham ge on herge, ge gehwæþer þara,
+efne swylce mæla swylce hira mandryhtne
+þearf gesælde; wæs seo þeod tilu.
+Sigon þa to slæpe. Sum sare angeald
+æfenræste, swa him ful oft gelamp,
+siþðan goldsele Grendel warode,
+unriht æfnde, oþþæt ende becwom,
+swylt æfter synnum. þæt gesyne wearþ,
+widcuþ werum, þætte wrecend þa gyt
+lifde æfter laþum, lange þrage,
+æfter guðceare. Grendles modor,
+ides, aglæcwif, yrmþe gemunde,
+se þe wæteregesan wunian scolde,
+cealde streamas, siþðan Cain wearð
+to ecgbanan angan breþer,
+fæderenmæge; he þa fag gewat,
+morþre gemearcod, mandream fleon,
+westen warode. þanon woc fela
+geosceaftgasta; wæs þæra Grendel sum,
+heorowearh hetelic, se æt Heorote fand
+wæccendne wer wiges bidan.
+þær him aglæca ætgræpe wearð;
+hwæþre he gemunde mægenes strenge,
+gimfæste gife ðe him god sealde,
+ond him to anwaldan are gelyfde,
+frofre ond fultum; ðy he þone feond ofercwom,
+gehnægde helle gast. þa he hean gewat,
+dreame bedæled, deaþwic seon,
+mancynnes feond, ond his modor þa gyt,
+gifre ond galgmod, gegan wolde
+sorhfulne sið, sunu deað wrecan.
+Com þa to Heorote, ðær Hringdene
+geond þæt sæld swæfun. þa ðær sona wearð
+edhwyrft eorlum, siþðan inne fealh
+Grendles modor. Wæs se gryre læssa
+efne swa micle swa bið mægþa cræft,
+wiggryre wifes, be wæpnedmen,
+þonne heoru bunden, hamere geþuren,
+sweord swate fah swin ofer helme
+ecgum dyhttig andweard scireð.
+þa wæs on healle heardecg togen
+sweord ofer setlum, sidrand manig
+hafen handa fæst; helm ne gemunde,
+byrnan side, þa hine se broga angeat.
+Heo wæs on ofste, wolde ut þanon,
+feore beorgan, þa heo onfunden wæs.
+Hraðe heo æþelinga anne hæfde
+fæste befangen, þa heo to fenne gang.
+Se wæs Hroþgare hæleþa leofost
+on gesiðes had be sæm tweonum,
+rice randwiga, þone ðe heo on ræste abreat,
+blædfæstne beorn. Næs Beowulf ðær,
+ac wæs oþer in ær geteohhod
+æfter maþðumgife mærum Geate.
+Hream wearð in Heorote; heo under heolfre genam
+cuþe folme; cearu wæs geniwod,
+geworden in wicun. Ne wæs þæt gewrixle til,
+þæt hie on ba healfa bicgan scoldon
+freonda feorum. þa wæs frod cyning,
+har hilderinc, on hreon mode,
+syðþan he aldorþegn unlyfigendne,
+þone deorestan deadne wisse.
+Hraþe wæs to bure Beowulf fetod,
+sigoreadig secg. Samod ærdæge
+eode eorla sum, æþele cempa
+self mid gesiðum þær se snotera bad,
+hwæþer him alwalda æfre wille
+æfter weaspelle wyrpe gefremman.
+Gang ða æfter flore fyrdwyrðe man
+mid his handscale healwudu dynede,
+þæt he þone wisan wordum nægde
+frean Ingwina, frægn gif him wære
+æfter neodlaðum niht getæse.
+Hroðgar maþelode, helm Scyldinga:
+Ne frin þu æfter sælum. Sorh is geniwod
+Denigea leodum. Dead is æschere,
+Yrmenlafes yldra broþor,
+min runwita ond min rædbora,
+eaxlgestealla, ðonne we on orlege
+hafelan weredon, þonne hniton feþan,
+eoferas cynsedan. Swylc scolde eorl wesan,
+æþeling ærgod, swylc æschere wæs.
+Wearð him on Heorote to handbanan
+wælgæst wæfre; ic ne wat hwæder
+atol æse wlanc eftsiðas teah,
+fylle gefægnod. Heo þa fæhðe wræc
+þe þu gystranniht Grendel cwealdest
+þurh hæstne had heardum clammum,
+forþan he to lange leode mine
+wanode ond wyrde. He æt wige gecrang
+ealdres scyldig, ond nu oþer cwom
+mihtig manscaða, wolde hyre mæg wrecan,
+ge feor hafað fæhðe gestæled
+(þæs þe þincean mæg þegne monegum,
+se þe æfter sincgyfan on sefan greoteþ),
+hreþerbealo hearde; nu seo hand ligeð,
+se þe eow welhwylcra wilna dohte.
+Ic þæt londbuend, leode mine,
+selerædende, secgan hyrde
+þæt hie gesawon swylce twegen
+micle mearcstapan moras healdan,
+ellorgæstas. ðæra oðer wæs,
+þæs þe hie gewislicost gewitan meahton,
+idese onlicnæs; oðer earmsceapen
+on weres wæstmum wræclastas træd,
+næfne he wæs mara þonne ænig man oðer;
+þone on geardagum Grendel nemdon
+foldbuende. No hie fæder cunnon,
+hwæþer him ænig wæs ær acenned
+dyrnra gasta. Hie dygel lond
+warigeað, wulfhleoþu, windige næssas,
+frecne fengelad, ðær fyrgenstream
+under næssa genipu niþer gewiteð,
+flod under foldan. Nis þæt feor heonon
+milgemearces þæt se mere standeð;
+ofer þæm hongiað hrinde bearwas,
+wudu wyrtum fæst wæter oferhelmað.
+þær mæg nihta gehwæm niðwundor seon,
+fyr on flode. No þæs frod leofað
+gumena bearna, þæt þone grund wite;
+ðeah þe hæðstapa hundum geswenced,
+heorot hornum trum, holtwudu sece,
+feorran geflymed, ær he feorh seleð,
+aldor on ofre, ær he in wille
+hafelan hydan. Nis þæt heoru stow!
+þonon yðgeblond up astigeð
+won to wolcnum, þonne wind styreþ,
+lað gewidru, oðþæt lyft drysmaþ,
+roderas reotað. Nu is se ræd gelang
+eft æt þe anum. Eard git ne const,
+frecne stowe, ðær þu findan miht
+felasinnigne secg; sec gif þu dyrre.
+Ic þe þa fæhðe feo leanige,
+ealdgestreonum, swa ic ær dyde,
+wundnum golde, gyf þu on weg cymest."
+Beowulf maþelode, bearn Ecgþeowes:
+"Ne sorga, snotor guma; selre bið æghwæm
+þæt he his freond wrece, þonne he fela murne.
+Ure æghwylc sceal ende gebidan
+worolde lifes; wyrce se þe mote
+domes ær deaþe; þæt bið drihtguman
+unlifgendum æfter selest.
+Aris, rices weard, uton raþe feran
+Grendles magan gang sceawigan.
+Ic hit þe gehate, no he on helm losaþ,
+ne on foldan fæþm, ne on fyrgenholt,
+ne on gyfenes grund, ga þær he wille.
+ðys dogor þu geþyld hafa
+weana gehwylces, swa ic þe wene to."
+Ahleop ða se gomela, gode þancode,
+mihtigan drihtne, þæs se man gespræc.
+þa wæs Hroðgare hors gebæted,
+wicg wundenfeax. Wisa fengel
+geatolic gende; gumfeþa stop
+lindhæbbendra. Lastas wæron
+æfter waldswaþum wide gesyne,
+gang ofer grundas, þær heo gegnum for
+ofer myrcan mor, magoþegna bær
+þone selestan sawolleasne
+þara þe mid Hroðgare ham eahtode.
+Ofereode þa æþelinga bearn
+steap stanhliðo, stige nearwe,
+enge anpaðas, uncuð gelad,
+neowle næssas, nicorhusa fela.
+He feara sum beforan gengde
+wisra monna wong sceawian,
+oþþæt he færinga fyrgenbeamas
+ofer harne stan hleonian funde,
+wynleasne wudu; wæter under stod
+dreorig ond gedrefed. Denum eallum wæs,
+winum Scyldinga, weorce on mode
+to geþolianne, ðegne monegum,
+oncyð eorla gehwæm, syðþan æscheres
+on þam holmclife hafelan metton.
+Flod blode weol (folc to sægon),
+hatan heolfre. Horn stundum song
+fuslic fyrdleoð. Feþa eal gesæt.
+Gesawon ða æfter wætere wyrmcynnes fela,
+sellice sædracan, sund cunnian,
+swylce on næshleoðum nicras licgean,
+ða on undernmæl oft bewitigað
+sorhfulne sið on seglrade,
+wyrmas ond wildeor; hie on weg hruron,
+bitere ond gebolgne, bearhtm ongeaton,
+guðhorn galan. Sumne Geata leod
+of flanbogan feores getwæfde,
+yðgewinnes, þæt him on aldre stod
+herestræl hearda; he on holme wæs
+sundes þe sænra, ðe hyne swylt fornam.
+Hræþe wearð on yðum mid eoferspreotum
+heorohocyhtum hearde genearwod,
+niða genæged, ond on næs togen,
+wundorlic wægbora; weras sceawedon
+gryrelicne gist. Gyrede hine Beowulf
+eorlgewædum, nalles for ealdre mearn.
+Scolde herebyrne hondum gebroden,
+sid ond searofah, sund cunnian,
+seo ðe bancofan beorgan cuþe,
+þæt him hildegrap hreþre ne mihte,
+eorres inwitfeng, aldre gesceþðan;
+ac se hwita helm hafelan werede,
+se þe meregrundas mengan scolde,
+secan sundgebland since geweorðad,
+befongen freawrasnum, swa hine fyrndagum
+worhte wæpna smið, wundrum teode,
+besette swinlicum, þæt hine syðþan no
+brond ne beadomecas bitan ne meahton.
+Næs þæt þonne mætost mægenfultuma
+þæt him on ðearfe lah ðyle Hroðgares;
+wæs þæm hæftmece Hrunting nama.
+þæt wæs an foran ealdgestreona;
+ecg wæs iren, atertanum fah,
+ahyrded heaþoswate; næfre hit æt hilde ne swac
+manna ængum þara þe hit mid mundum bewand,
+se ðe gryresiðas gegan dorste,
+folcstede fara; næs þæt forma sið
+þæt hit ellenweorc æfnan scolde.
+Huru ne gemunde mago Ecglafes,
+eafoþes cræftig, þæt he ær gespræc
+wine druncen, þa he þæs wæpnes onlah
+selran sweordfrecan. Selfa ne dorste
+under yða gewin aldre geneþan,
+drihtscype dreogan; þær he dome forleas,
+ellenmærðum. Ne wæs þæm oðrum swa,
+syðþan he hine to guðe gegyred hæfde.
+Beowulf maðelode, bearn Ecgþeowes:
+"Geþenc nu, se mæra maga Healfdenes,
+snottra fengel, nu ic eom siðes fus,
+goldwine gumena, hwæt wit geo spræcon,
+gif ic æt þearfe þinre scolde
+aldre linnan, þæt ðu me a wære
+forðgewitenum on fæder stæle.
+Wes þu mundbora minum magoþegnum,
+hondgesellum, gif mec hild nime;
+swylce þu ða madmas þe þu me sealdest,
+Hroðgar leofa, Higelace onsend.
+Mæg þonne on þæm golde ongitan Geata dryhten,
+geseon sunu Hrædles, þonne he on þæt sinc starað,
+þæt ic gumcystum godne funde
+beaga bryttan, breac þonne moste.
+Ond þu Unferð læt ealde lafe,
+wrætlic wægsweord, widcuðne man
+heardecg habban; ic me mid Hruntinge
+dom gewyrce, oþðe mec deað nimeð."
+æfter þæm wordum Wedergeata leod
+efste mid elne, nalas ondsware
+bidan wolde; brimwylm onfeng
+hilderince. ða wæs hwil dæges
+ær he þone grundwong ongytan mehte.
+Sona þæt onfunde se ðe floda begong
+heorogifre beheold hund missera,
+grim ond grædig, þæt þær gumena sum
+ælwihta eard ufan cunnode.
+Grap þa togeanes, guðrinc gefeng
+atolan clommum. No þy ær in gescod
+halan lice; hring utan ymbbearh,
+þæt heo þone fyrdhom ðurhfon ne mihte,
+locene leoðosyrcan laþan fingrum.
+Bær þa seo brimwylf, þa heo to botme com,
+hringa þengel to hofe sinum,
+swa he ne mihte, no he þæs modig wæs,
+wæpna gewealdan, ac hine wundra þæs fela
+swencte on sunde, sædeor monig
+hildetuxum heresyrcan bræc,
+ehton aglæcan. ða se eorl ongeat
+þæt he in niðsele nathwylcum wæs,
+þær him nænig wæter wihte ne sceþede,
+ne him for hrofsele hrinan ne mehte
+færgripe flodes; fyrleoht geseah,
+blacne leoman, beorhte scinan.
+Ongeat þa se goda grundwyrgenne,
+merewif mihtig; mægenræs forgeaf
+hildebille, hond sweng ne ofteah,
+þæt hire on hafelan hringmæl agol
+grædig guðleoð. ða se gist onfand
+þæt se beadoleoma bitan nolde,
+aldre sceþðan, ac seo ecg geswac
+ðeodne æt þearfe; ðolode ær fela
+hondgemota, helm oft gescær,
+fæges fyrdhrægl; ða wæs forma sið
+deorum madme, þæt his dom alæg.
+Eft wæs anræd, nalas elnes læt,
+mærða gemyndig mæg Hylaces.
+Wearp ða wundenmæl wrættum gebunden
+yrre oretta, þæt hit on eorðan læg,
+stið ond stylecg; strenge getruwode,
+mundgripe mægenes. Swa sceal man don,
+þonne he æt guðe gegan þenceð
+longsumne lof, na ymb his lif cearað.
+Gefeng þa be eaxle (nalas for fæhðe mearn)
+Guðgeata leod Grendles modor;
+brægd þa beadwe heard, þa he gebolgen wæs,
+feorhgeniðlan, þæt heo on flet gebeah.
+Heo him eft hraþe andlean forgeald
+grimman grapum ond him togeanes feng;
+oferwearp þa werigmod wigena strengest,
+feþecempa, þæt he on fylle wearð.
+Ofsæt þa þone selegyst ond hyre seax geteah,
+brad ond brunecg, wolde hire bearn wrecan,
+angan eaferan. Him on eaxle læg
+breostnet broden; þæt gebearh feore,
+wið ord ond wið ecge ingang forstod.
+Hæfde ða forsiðod sunu Ecgþeowes
+under gynne grund, Geata cempa,
+nemne him heaðobyrne helpe gefremede,
+herenet hearde, ond halig god
+geweold wigsigor; witig drihten,
+rodera rædend, hit on ryht gesced
+yðelice, syþðan he eft astod.
+Geseah ða on searwum sigeeadig bil,
+eald sweord eotenisc, ecgum þyhtig,
+wigena weorðmynd; þæt wæs wæpna cyst,
+buton hit wæs mare ðonne ænig mon oðer
+to beadulace ætberan meahte,
+god ond geatolic, giganta geweorc.
+He gefeng þa fetelhilt, freca Scyldinga
+hreoh ond heorogrim hringmæl gebrægd,
+aldres orwena, yrringa sloh,
+þæt hire wið halse heard grapode,
+banhringas bræc. Bil eal ðurhwod
+fægne flæschoman; heo on flet gecrong.
+Sweord wæs swatig, secg weorce gefeh.
+Lixte se leoma, leoht inne stod,
+efne swa of hefene hadre scineð
+rodores candel. He æfter recede wlat;
+hwearf þa be wealle, wæpen hafenade
+heard be hiltum Higelaces ðegn,
+yrre ond anræd. Næs seo ecg fracod
+hilderince, ac he hraþe wolde
+Grendle forgyldan guðræsa fela
+ðara þe he geworhte to Westdenum
+oftor micle ðonne on ænne sið,
+þonne he Hroðgares heorðgeneatas
+sloh on sweofote, slæpende fræt
+folces Denigea fyftyne men
+ond oðer swylc ut offerede,
+laðlicu lac. He him þæs lean forgeald,
+reþe cempa, to ðæs þe he on ræste geseah
+guðwerigne Grendel licgan
+aldorleasne, swa him ær gescod
+hild æt Heorote. Hra wide sprong,
+syþðan he æfter deaðe drepe þrowade,
+heorosweng heardne, ond hine þa heafde becearf.
+Sona þæt gesawon snottre ceorlas,
+þa ðe mid Hroðgare on holm wliton,
+þæt wæs yðgeblond eal gemenged,
+brim blode fah. Blondenfeaxe,
+gomele ymb godne, ongeador spræcon
+þæt hig þæs æðelinges eft ne wendon
+þæt he sigehreðig secean come
+mærne þeoden; þa ðæs monige gewearð
+þæt hine seo brimwylf abroten hæfde.
+ða com non dæges. Næs ofgeafon
+hwate Scyldingas; gewat him ham þonon
+goldwine gumena. Gistas setan
+modes seoce ond on mere staredon,
+wiston ond ne wendon þæt hie heora winedrihten
+selfne gesawon. þa þæt sweord ongan
+æfter heaþoswate hildegicelum,
+wigbil wanian. þæt wæs wundra sum,
+þæt hit eal gemealt ise gelicost,
+ðonne forstes bend fæder onlæteð,
+onwindeð wælrapas, se geweald hafað
+sæla ond mæla; þæt is soð metod.
+Ne nom he in þæm wicum, Wedergeata leod,
+maðmæhta ma, þeh he þær monige geseah,
+buton þone hafelan ond þa hilt somod
+since fage. Sweord ær gemealt,
+forbarn brodenmæl; wæs þæt blod to þæs hat,
+ættren ellorgæst se þær inne swealt.
+Sona wæs on sunde se þe ær æt sæcce gebad
+wighryre wraðra, wæter up þurhdeaf.
+Wæron yðgebland eal gefælsod,
+eacne eardas, þa se ellorgast
+oflet lifdagas ond þas lænan gesceaft.
+Com þa to lande lidmanna helm
+swiðmod swymman; sælace gefeah,
+mægenbyrþenne þara þe he him mid hæfde.
+Eodon him þa togeanes, gode þancodon,
+ðryðlic þegna heap, þeodnes gefegon,
+þæs þe hi hyne gesundne geseon moston.
+ða wæs of þæm hroran helm ond byrne
+lungre alysed. Lagu drusade,
+wæter under wolcnum, wældreore fag.
+Ferdon forð þonon feþelastum
+ferhþum fægne, foldweg mæton,
+cuþe stræte. Cyningbalde men
+from þæm holmclife hafelan bæron
+earfoðlice heora æghwæþrum,
+felamodigra; feower scoldon
+on þæm wælstenge weorcum geferian
+to þæm goldsele Grendles heafod,
+oþðæt semninga to sele comon
+frome fyrdhwate feowertyne
+Geata gongan; gumdryhten mid
+modig on gemonge meodowongas træd.
+ða com in gan ealdor ðegna,
+dædcene mon dome gewurþad,
+hæle hildedeor, Hroðgar gretan.
+þa wæs be feaxe on flet boren
+Grendles heafod, þær guman druncon,
+egeslic for eorlum ond þære idese mid,
+wliteseon wrætlic; weras on sawon.
+Beowulf maþelode, bearn Ecgþeowes:
+"Hwæt! we þe þas sælac, sunu Healfdenes,
+leod Scyldinga, lustum brohton
+tires to tacne, þe þu her to locast.
+Ic þæt unsofte ealdre gedigde
+wigge under wætere, weorc geneþde
+earfoðlice; ætrihte wæs
+guð getwæfed, nymðe mec god scylde.
+Ne meahte ic æt hilde mid Hruntinge
+wiht gewyrcan, þeah þæt wæpen duge;
+ac me geuðe ylda waldend
+þæt ic on wage geseah wlitig hangian
+eald sweord eacen (oftost wisode
+winigea leasum), þæt ic ðy wæpne gebræd.
+Ofsloh ða æt þære sæcce, þa me sæl ageald,
+huses hyrdas. þa þæt hildebil
+forbarn brogdenmæl, swa þæt blod gesprang,
+hatost heaþoswata. Ic þæt hilt þanan
+feondum ætferede, fyrendæda wræc,
+deaðcwealm Denigea, swa hit gedefe wæs.
+Ic hit þe þonne gehate, þæt þu on Heorote most
+sorhleas swefan mid þinra secga gedryht
+ond þegna gehwylc þinra leoda,
+duguðe ond iogoþe, þæt þu him ondrædan ne þearft,
+þeoden Scyldinga, on þa healfe,
+aldorbealu eorlum, swa þu ær dydest."
+ða wæs gylden hilt gamelum rince,
+harum hildfruman, on hand gyfen,
+enta ærgeweorc; hit on æht gehwearf
+æfter deofla hryre Denigea frean,
+wundorsmiþa geweorc, ond þa þas worold ofgeaf
+gromheort guma, godes ondsaca,
+morðres scyldig, ond his modor eac,
+on geweald gehwearf woroldcyninga
+ðæm selestan be sæm tweonum
+ðara þe on Scedenigge sceattas dælde.
+Hroðgar maðelode, hylt sceawode,
+ealde lafe, on ðæm wæs or writen
+fyrngewinnes, syðþan flod ofsloh,
+gifen geotende, giganta cyn
+(frecne geferdon); þæt wæs fremde þeod
+ecean dryhtne; him þæs endelean
+þurh wæteres wylm waldend sealde.
+Swa wæs on ðæm scennum sciran goldes
+þurh runstafas rihte gemearcod,
+geseted ond gesæd hwam þæt sweord geworht,
+irena cyst, ærest wære,
+wreoþenhilt ond wyrmfah. ða se wisa spræc
+sunu Healfdenes (swigedon ealle):
+"þæt, la, mæg secgan se þe soð ond riht
+fremeð on folce, feor eal gemon,
+eald OEweard, þæt ðes eorl wære
+geboren betera! Blæd is aræred
+geond widwegas, wine min Beowulf,
+ðin ofer þeoda gehwylce. Eal þu hit geþyldum healdest,
+mægen mid modes snyttrum. Ic þe sceal mine gelæstan
+freode, swa wit furðum spræcon. ðu scealt to frofre weorþan
+eal langtwidig leodum þinum,
+hæleðum to helpe. Ne wearð Heremod swa
+eaforum Ecgwelan, Arscyldingum;
+ne geweox he him to willan, ac to wælfealle
+ond to deaðcwalum Deniga leodum;
+breat bolgenmod beodgeneatas,
+eaxlgesteallan, oþþæt he ana hwearf,
+mære þeoden, mondreamum from.
+ðeah þe hine mihtig god mægenes wynnum,
+eafeþum stepte, ofer ealle men
+forð gefremede, hwæþere him on ferhþe greow
+breosthord blodreow. Nallas beagas geaf
+Denum æfter dome; dreamleas gebad
+þæt he þæs gewinnes weorc þrowade,
+leodbealo longsum. ðu þe lær be þon,
+gumcyste ongit; ic þis gid be þe
+awræc wintrum frod. Wundor is to secganne
+hu mihtig god manna cynne
+þurh sidne sefan snyttru bryttað,
+eard ond eorlscipe; he ah ealra geweald.
+Hwilum he on lufan læteð hworfan
+monnes modgeþonc mæran cynnes,
+seleð him on eþle eorþan wynne
+to healdanne, hleoburh wera,
+gedeð him swa gewealdene worolde dælas,
+side rice, þæt he his selfa ne mæg
+for his unsnyttrum ende geþencean.
+Wunað he on wiste; no hine wiht dweleð
+adl ne yldo, ne him inwitsorh
+on sefan sweorceð, ne gesacu ohwær
+ecghete eoweð, ac him eal worold
+wendeð on willan (he þæt wyrse ne con),
+oðþæt him on innan oferhygda dæl
+weaxeð ond wridað. þonne se weard swefeð,
+sawele hyrde; bið se slæp to fæst,
+bisgum gebunden, bona swiðe neah,
+se þe of flanbogan fyrenum sceoteð.
+þonne bið on hreþre under helm drepen
+biteran stræle (him bebeorgan ne con),
+wom wundorbebodum wergan gastes;
+þinceð him to lytel þæt he lange heold,
+gytsað gromhydig, nallas on gylp seleð
+fædde beagas, ond he þa forðgesceaft
+forgyteð ond forgymeð, þæs þe him ær god sealde,
+wuldres waldend, weorðmynda dæl.
+Hit on endestæf eft gelimpeð
+þæt se lichoma læne gedreoseð,
+fæge gefealleð; fehð oþer to,
+se þe unmurnlice madmas dæleþ,
+eorles ærgestreon, egesan ne gymeð.
+Bebeorh þe ðone bealonið, Beowulf leofa,
+secg betsta, ond þe þæt selre geceos,
+ece rædas; oferhyda ne gym,
+mære cempa. Nu is þines mægnes blæd
+ane hwile. Eft sona bið
+þæt þec adl oððe ecg eafoþes getwæfeð,
+oððe fyres feng, oððe flodes wylm,
+oððe gripe meces, oððe gares fliht,
+oððe atol yldo; oððe eagena bearhtm
+forsiteð ond forsworceð; semninga bið
+þæt ðec, dryhtguma, deað oferswyðeð.
+Swa ic Hringdena hund missera
+weold under wolcnum ond hig wigge beleac
+manigum mægþa geond þysne middangeard,
+æscum ond ecgum, þæt ic me ænigne
+under swegles begong gesacan ne tealde.
+Hwæt, me þæs on eþle edwenden cwom,
+gyrn æfter gomene, seoþðan Grendel wearð,
+ealdgewinna, ingenga min;
+ic þære socne singales wæg
+modceare micle. þæs sig metode þanc,
+ecean dryhtne, þæs ðe ic on aldre gebad
+þæt ic on þone hafelan heorodreorigne
+ofer ealdgewin eagum starige!
+Ga nu to setle, symbelwynne dreoh
+wigge weorþad; unc sceal worn fela
+maþma gemænra, siþðan morgen bið."
+Geat wæs glædmod, geong sona to
+setles neosan, swa se snottra heht.
+þa wæs eft swa ær ellenrofum
+fletsittendum fægere gereorded
+niowan stefne. Nihthelm geswearc
+deorc ofer dryhtgumum. Duguð eal aras.
+Wolde blondenfeax beddes neosan,
+gamela Scylding. Geat unigmetes wel,
+rofne randwigan, restan lyste;
+sona him seleþegn siðes wergum,
+feorrancundum, forð wisade,
+se for andrysnum ealle beweotede
+þegnes þearfe, swylce þy dogore
+heaþoliðende habban scoldon.
+Reste hine þa rumheort; reced hliuade
+geap ond goldfah; gæst inne swæf
+oþþæt hrefn blaca heofones wynne
+bliðheort bodode. ða com beorht scacan
+scaþan onetton,
+wæron æþelingas eft to leodum
+fuse to farenne; wolde feor þanon
+cuma collenferhð ceoles neosan.
+Heht þa se hearda Hrunting beran
+sunu Ecglafes, heht his sweord niman,
+leoflic iren; sægde him þæs leanes þanc,
+cwæð, he þone guðwine godne tealde,
+wigcræftigne, nales wordum log
+meces ecge; þæt wæs modig secg.
+Ond þa siðfrome, searwum gearwe
+wigend wæron; eode weorð Denum
+æþeling to yppan, þær se oþer wæs,
+hæle hildedeor Hroðgar grette.
+Beowulf maþelode, bearn Ecgþeowes:
+"Nu we sæliðend secgan wyllað,
+feorran cumene, þæt we fundiaþ
+Higelac secan. Wæron her tela
+willum bewenede; þu us wel dohtest.
+Gif ic þonne on eorþan owihte mæg
+þinre modlufan maran tilian,
+gumena dryhten, ðonne ic gyt dyde,
+guðgeweorca, ic beo gearo sona.
+Gif ic þæt gefricge ofer floda begang,
+þæt þec ymbsittend egesan þywað,
+swa þec hetende hwilum dydon,
+ic ðe þusenda þegna bringe,
+hæleþa to helpe. Ic on Higelac wat,
+Geata dryhten, þeah ðe he geong sy,
+folces hyrde, þæt he mec fremman wile
+wordum ond worcum, þæt ic þe wel herige
+ond þe to geoce garholt bere,
+mægenes fultum, þær ðe bið manna þearf.
+Gif him þonne Hreþric to hofum Geata
+geþingeð, þeodnes bearn, he mæg þær fela
+freonda findan; feorcyþðe beoð
+selran gesohte þæm þe him selfa deah."
+Hroðgar maþelode him on ondsware:
+"þe þa wordcwydas wigtig drihten
+on sefan sende; ne hyrde ic snotorlicor
+on swa geongum feore guman þingian.
+þu eart mægenes strang ond on mode frod,
+wis wordcwida. Wen ic talige,
+gif þæt gegangeð, þæt ðe gar nymeð,
+hild heorugrimme, Hreþles eaferan,
+adl oþðe iren ealdor ðinne,
+folces hyrde, ond þu þin feorh hafast,
+þæt þe Sægeatas selran næbben
+to geceosenne cyning ænigne,
+hordweard hæleþa, gyf þu healdan wylt
+maga rice. Me þin modsefa
+licað leng swa wel, leofa Beowulf.
+Hafast þu gefered þæt þam folcum sceal,
+Geata leodum ond Gardenum,
+sib gemæne, ond sacu restan,
+inwitniþas, þe hie ær drugon,
+wesan, þenden ic wealde widan rices,
+maþmas gemæne, manig oþerne
+godum gegretan ofer ganotes bæð;
+sceal hringnaca ofer heafu bringan
+lac ond luftacen. Ic þa leode wat
+ge wið feond ge wið freond fæste geworhte,
+æghwæs untæle ealde wisan."
+ða git him eorla hleo inne gesealde,
+mago Healfdenes, maþmas [XII];
+het hine mid þæm lacum leode swæse
+secean on gesyntum, snude eft cuman.
+Gecyste þa cyning æþelum god,
+þeoden Scyldinga, ðegn betstan
+ond be healse genam; hruron him tearas,
+blondenfeaxum. Him wæs bega wen,
+ealdum infrodum, oþres swiðor,
+þæt hie seoððan no geseon moston,
+modige on meþle. Wæs him se man to þon leof
+þæt he þone breostwylm forberan ne mehte,
+ac him on hreþre hygebendum fæst
+æfter deorum men dyrne langað
+beorn wið blode. Him Beowulf þanan,
+guðrinc goldwlanc, græsmoldan træd
+since hremig; sægenga bad
+agendfrean, se þe on ancre rad.
+þa wæs on gange gifu Hroðgares
+oft geæhted; þæt wæs an cyning,
+æghwæs orleahtre, oþþæt hine yldo benam
+mægenes wynnum, se þe oft manegum scod.
+Cwom þa to flode felamodigra,
+hægstealdra heap, hringnet bæron,
+locene leoðosyrcan. Landweard onfand
+eftsið eorla, swa he ær dyde;
+no he mid hearme of hliðes nosan
+gæstas grette, ac him togeanes rad,
+cwæð þæt wilcuman Wedera leodum
+scaþan scirhame to scipe foron.
+þa wæs on sande sægeap naca
+hladen herewædum, hringedstefna,
+mearum ond maðmum; mæst hlifade
+ofer Hroðgares hordgestreonum.
+He þæm batwearde bunden golde
+swurd gesealde, þæt he syðþan wæs
+on meodubence maþme þy weorþra,
+yrfelafe. Gewat him on naca
+drefan deop wæter, Dena land ofgeaf.
+þa wæs be mæste merehrægla sum,
+segl sale fæst; sundwudu þunede.
+No þær wegflotan wind ofer yðum
+siðes getwæfde; sægenga for,
+fleat famigheals forð ofer yðe,
+bundenstefna ofer brimstreamas,
+þæt hie Geata clifu ongitan meahton,
+cuþe næssas. Ceol up geþrang
+lyftgeswenced, on lande stod.
+Hraþe wæs æt holme hyðweard geara,
+se þe ær lange tid leofra manna
+fus æt faroðe feor wlatode;
+sælde to sande sidfæþme scip,
+oncerbendum fæst, þy læs hym yþa ðrym
+wudu wynsuman forwrecan meahte.
+Het þa up beran æþelinga gestreon,
+frætwe ond fætgold; næs him feor þanon
+to gesecanne sinces bryttan,
+Higelac Hreþling, þær æt ham wunað
+selfa mid gesiðum sæwealle neah.
+Bold wæs betlic, bregorof cyning,
+heah in healle, Hygd swiðe geong,
+wis, welþungen, þeah ðe wintra lyt
+under burhlocan gebiden hæbbe,
+Hæreþes dohtor; næs hio hnah swa þeah,
+ne to gneað gifa Geata leodum,
+maþmgestreona. Mod þryðo wæg,
+fremu folces cwen, firen ondrysne.
+Nænig þæt dorste deor geneþan
+swæsra gesiða, nefne sinfrea,
+þæt hire an dæges eagum starede,
+ac him wælbende weotode tealde
+handgewriþene; hraþe seoþðan wæs
+æfter mundgripe mece geþinged,
+þæt hit sceadenmæl scyran moste,
+cwealmbealu cyðan. Ne bið swylc cwenlic þeaw
+idese to efnanne, þeah ðe hio ænlicu sy,
+þætte freoðuwebbe feores onsæce
+æfter ligetorne leofne mannan.
+Huru þæt onhohsnode Hemminges mæg;
+ealodrincende oðer sædan,
+þæt hio leodbealewa læs gefremede,
+inwitniða, syððan ærest wearð
+gyfen goldhroden geongum cempan,
+æðelum diore, syððan hio Offan flet
+ofer fealone flod be fæder lare
+siðe gesohte; ðær hio syððan well
+in gumstole, gode, mære,
+lifgesceafta lifigende breac,
+hiold heahlufan wið hæleþa brego,
+ealles moncynnes mine gefræge
+þone selestan bi sæm tweonum,
+eormencynnes. Forðam Offa wæs
+geofum ond guðum, garcene man,
+wide geweorðod, wisdome heold
+eðel sinne; þonon Eomer woc
+hæleðum to helpe, Hemminges mæg,
+nefa Garmundes, niða cræftig.
+Gewat him ða se hearda mid his hondscole
+sylf æfter sande sæwong tredan,
+wide waroðas. Woruldcandel scan,
+sigel suðan fus. Hi sið drugon,
+elne geeodon, to ðæs ðe eorla hleo,
+bonan Ongenþeoes burgum in innan,
+geongne guðcyning godne gefrunon
+hringas dælan. Higelace wæs
+sið Beowulfes snude gecyðed,
+þæt ðær on worðig wigendra hleo,
+lindgestealla, lifigende cwom,
+heaðolaces hal to hofe gongan.
+Hraðe wæs gerymed, swa se rica bebead,
+feðegestum flet innanweard.
+Gesæt þa wið sylfne se ða sæcce genæs,
+mæg wið mæge, syððan mandryhten
+þurh hleoðorcwyde holdne gegrette,
+meaglum wordum. Meoduscencum hwearf
+geond þæt healreced Hæreðes dohtor,
+lufode ða leode, liðwæge bær
+hæleðum to handa. Higelac ongan
+sinne geseldan in sele þam hean
+fægre fricgcean (hyne fyrwet bræc,
+hwylce Sægeata siðas wæron):
+"Hu lomp eow on lade, leofa Biowulf,
+þa ðu færinga feorr gehogodest
+sæcce secean ofer sealt wæter,
+hilde to Hiorote? Ac ðu Hroðgare
+widcuðne wean wihte gebettest,
+mærum ðeodne? Ic ðæs modceare
+sorhwylmum seað, siðe ne truwode
+leofes mannes; ic ðe lange bæd
+þæt ðu þone wælgæst wihte ne grette,
+lete Suðdene sylfe geweorðan
+guðe wið Grendel. Gode ic þanc secge
+þæs ðe ic ðe gesundne geseon moste."
+Biowulf maðelode, bearn Ecgðioes:
+"þæt is undyrne, dryhten Higelac,
+micel gemeting, monegum fira,
+hwylc orleghwil uncer Grendles
+wearð on ðam wange, þær he worna fela
+Sigescyldingum sorge gefremede,
+yrmðe to aldre. Ic ðæt eall gewræc,
+swa begylpan ne þearf Grendeles maga
+ænig ofer eorðan uhthlem þone,
+se ðe lengest leofað laðan cynnes,
+facne bifongen. Ic ðær furðum cwom
+to ðam hringsele Hroðgar gretan;
+sona me se mæra mago Healfdenes,
+syððan he modsefan minne cuðe,
+wið his sylfes sunu setl getæhte.
+Weorod wæs on wynne; ne seah ic widan feorh
+under heofones hwealf healsittendra
+medudream maran. Hwilum mæru cwen,
+friðusibb folca, flet eall geondhwearf,
+bædde byre geonge; oft hio beahwriðan
+secge sealde, ær hie to setle geong.
+Hwilum for duguðe dohtor Hroðgares
+eorlum on ende ealuwæge bær;
+þa ic Freaware fletsittende
+nemnan hyrde, þær hio nægled sinc
+hæleðum sealde. Sio gehaten is,
+geong, goldhroden, gladum suna Frodan;
+hafað þæs geworden wine Scyldinga,
+rices hyrde, ond þæt ræd talað,
+þæt he mid ðy wife wælfæhða dæl,
+sæcca gesette. Oft seldan hwær
+æfter leodhryre lytle hwile
+bongar bugeð, þeah seo bryd duge!
+Mæg þæs þonne ofþyncan ðeodne Heaðobeardna
+ond þegna gehwam þara leoda,
+þonne he mid fæmnan on flett gæð,
+dryhtbearn Dena, duguða biwenede;
+on him gladiað gomelra lafe,
+heard ond hringmæl Heaðabeardna gestreon
+þenden hie ðam wæpnum wealdan moston,
+oððæt hie forlæddan to ðam lindplegan
+swæse gesiðas ond hyra sylfra feorh.
+þonne cwið æt beore se ðe beah gesyhð,
+eald æscwiga, se ðe eall geman,
+garcwealm gumena (him bið grim sefa),
+onginneð geomormod geongum cempan
+þurh hreðra gehygd higes cunnian,
+wigbealu weccean, ond þæt word acwyð:
+'Meaht ðu, min wine, mece gecnawan
+þone þin fæder to gefeohte bær
+under heregriman hindeman siðe,
+dyre iren, þær hyne Dene slogon,
+weoldon wælstowe, syððan Wiðergyld læg,
+æfter hæleþa hryre, hwate Scyldungas?
+Nu her þara banena byre nathwylces
+frætwum hremig on flet gæð,
+morðres gylpeð, ond þone maðþum byreð,
+þone þe ðu mid rihte rædan sceoldest.'
+Manað swa ond myndgað mæla gehwylce
+sarum wordum, oððæt sæl cymeð
+þæt se fæmnan þegn fore fæder dædum
+æfter billes bite blodfag swefeð,
+ealdres scyldig; him se oðer þonan
+losað lifigende, con him land geare.
+þonne bioð abrocene on ba healfe
+aðsweord eorla; syððan Ingelde
+weallað wælniðas, ond him wiflufan
+æfter cearwælmum colran weorðað.
+þy ic Heaðobeardna hyldo ne telge,
+dryhtsibbe dæl Denum unfæcne,
+freondscipe fæstne. Ic sceal forð sprecan
+gen ymbe Grendel, þæt ðu geare cunne,
+sinces brytta, to hwan syððan wearð
+hondræs hæleða. Syððan heofones gim
+glad ofer grundas, gæst yrre cwom,
+eatol, æfengrom, user neosan,
+ðær we gesunde sæl weardodon.
+þær wæs Hondscio hild onsæge,
+feorhbealu fægum; he fyrmest læg,
+gyrded cempa; him Grendel wearð,
+mærum maguþegne to muðbonan,
+leofes mannes lic eall forswealg.
+No ðy ær ut ða gen idelhende
+bona blodigtoð, bealewa gemyndig,
+of ðam goldsele gongan wolde,
+ac he mægnes rof min costode,
+grapode gearofolm. Glof hangode
+sid ond syllic, searobendum fæst;
+sio wæs orðoncum eall gegyrwed
+deofles cræftum ond dracan fellum.
+He mec þær on innan unsynnigne,
+dior dædfruma, gedon wolde
+manigra sumne; hyt ne mihte swa,
+syððan ic on yrre uppriht astod.
+To lang ys to reccenne hu ic ðam leodsceaðan
+yfla gehwylces ondlean forgeald;
+þær ic, þeoden min, þine leode
+weorðode weorcum. He on weg losade,
+lytle hwile lifwynna breac;
+hwæþre him sio swiðre swaðe weardade
+hand on Hiorte, ond he hean ðonan
+modes geomor meregrund gefeoll.
+Me þone wælræs wine Scildunga
+fættan golde fela leanode,
+manegum maðmum, syððan mergen com
+ond we to symble geseten hæfdon.
+þær wæs gidd ond gleo. Gomela Scilding,
+felafricgende, feorran rehte;
+hwilum hildedeor hearpan wynne,
+gomenwudu grette, hwilum gyd awræc
+soð ond sarlic, hwilum syllic spell
+rehte æfter rihte rumheort cyning.
+Hwilum eft ongan, eldo gebunden,
+gomel guðwiga gioguðe cwiðan,
+hildestrengo; hreðer inne weoll,
+þonne he wintrum frod worn gemunde.
+Swa we þær inne ondlangne dæg
+niode naman, oððæt niht becwom
+oðer to yldum. þa wæs eft hraðe
+gearo gyrnwræce Grendeles modor,
+siðode sorhfull; sunu deað fornam,
+wighete Wedra. Wif unhyre
+hyre bearn gewræc, beorn acwealde
+ellenlice; þær wæs æschere,
+frodan fyrnwitan, feorh uðgenge.
+Noðer hy hine ne moston, syððan mergen cwom,
+deaðwerigne, Denia leode,
+bronde forbærnan, ne on bęl hladan
+leofne mannan; hio þæt lic ætbær
+feondes fæðmum under firgenstream.
+þæt wæs Hroðgare hreowa tornost
+þara þe leodfruman lange begeate.
+þa se ðeoden mec ðine life
+healsode hreohmod, þæt ic on holma geþring
+eorlscipe efnde, ealdre geneðde,
+mærðo fremede; he me mede gehet.
+Ic ða ðæs wælmes, þe is wide cuð,
+grimne gryrelicne grundhyrde fond;
+þær unc hwile wæs hand gemæne,
+holm heolfre weoll, ond ic heafde becearf
+in ðam guðsele Grendeles modor
+eacnum ecgum, unsofte þonan
+feorh oðferede. Næs ic fæge þa gyt,
+ac me eorla hleo eft gesealde
+maðma menigeo, maga Healfdenes.
+Swa se ðeodkyning þeawum lyfde.
+Nealles ic ðam leanum forloren hæfde,
+mægnes mede, ac he me maðmas geaf,
+sunu Healfdenes, on minne sylfes dom;
+ða ic ðe, beorncyning, bringan wylle,
+estum geywan. Gen is eall æt ðe
+lissa gelong; ic lyt hafo
+heafodmaga nefne, Hygelac, ðec."
+Het ða in beran eaforheafodsegn,
+heaðosteapne helm, hare byrnan,
+guðsweord geatolic, gyd æfter wræc:
+"Me ðis hildesceorp Hroðgar sealde,
+snotra fengel, sume worde het
+þæt ic his ærest ðe est gesægde;
+cwæð þæt hyt hæfde Hiorogar cyning,
+leod Scyldunga lange hwile;
+no ðy ær suna sinum syllan wolde,
+hwatum Heorowearde, þeah he him hold wære,
+breostgewædu. Bruc ealles well!"
+Hyrde ic þæt þam frætwum feower mearas
+lungre, gelice, last weardode,
+æppelfealuwe; he him est geteah
+meara ond maðma. Swa sceal mæg don,
+nealles inwitnet oðrum bregdon
+dyrnum cræfte, deað renian
+hondgesteallan. Hygelace wæs,
+niða heardum, nefa swyðe hold,
+ond gehwæðer oðrum hroþra gemyndig.
+Hyrde ic þæt he ðone healsbeah Hygde gesealde,
+wrætlicne wundurmaððum, ðone þe him Wealhðeo geaf,
+ðeodnes dohtor, þrio wicg somod
+swancor ond sadolbeorht; hyre syððan wæs
+æfter beahðege breost geweorðod.
+Swa bealdode bearn Ecgðeowes,
+guma guðum cuð, godum dædum,
+dreah æfter dome, nealles druncne slog
+heorðgeneatas; næs him hreoh sefa,
+ac he mancynnes mæste cræfte
+ginfæstan gife, þe him god sealde,
+heold hildedeor. Hean wæs lange,
+swa hyne Geata bearn godne ne tealdon,
+ne hyne on medobence micles wyrðne
+drihten Wedera gedon wolde;
+swyðe wendon þæt he sleac wære,
+æðeling unfrom. Edwenden cwom
+tireadigum menn torna gehwylces.
+Het ða eorla hleo in gefetian,
+heaðorof cyning, Hreðles lafe
+golde gegyrede; næs mid Geatum ða
+sincmaðþum selra on sweordes had;
+þæt he on Biowulfes bearm alegde
+ond him gesealde seofan þusendo,
+bold ond bregostol. Him wæs bam samod
+on ðam leodscipe lond gecynde,
+eard, eðelriht, oðrum swiðor
+side rice þam ðær selra wæs.
+Eft þæt geiode ufaran dogrum
+hildehlæmmum, syððan Hygelac læg
+ond Heardrede hildemeceas
+under bordhreoðan to bonan wurdon,
+ða hyne gesohtan on sigeþeode
+hearde hildefrecan, Heaðoscilfingas,
+niða genægdan nefan Hererices,
+syððan Beowulfe brade rice
+on hand gehwearf; he geheold tela
+fiftig wintra (wæs ða frod cyning,
+eald eþelweard), oððæt an ongan
+deorcum nihtum draca ricsian,
+se ðe on heaum hofe hord beweotode,
+stanbeorh steapne; stig under læg,
+eldum uncuð. þær on innan giong
+niða nathwylc, se ðe neh gefeng
+hæðnum horde, hond [...],
+since fahne. He þæt syððan [...],
+þeah ðe he slæpende besyred wurde
+þeofes cræfte; þæt sie ðiod onfand,
+bufolc beorna, þæt he gebolgen wæs.
+Nealles mid gewealdum wyrmhord abræc
+sylfes willum, se ðe him sare gesceod,
+ac for þreanedlan þeow nathwylces
+hæleða bearna heteswengeas fleah,
+ærnes þearfa, ond ðær inne fealh,
+secg synbysig, sona onfunde
+þæt þær ðam gyste gryrebroga stod;
+hwæðre earmsceapen
+sceapen
+þa hyne se fær begeat.
+Sincfæt [...]; þær wæs swylcra fela
+in ðam eorðhuse ærgestreona,
+swa hy on geardagum gumena nathwylc,
+eormenlafe æþelan cynnes,
+þanchycgende þær gehydde,
+deore maðmas. Ealle hie deað fornam
+ærran mælum, ond se an ða gen
+leoda duguðe, se ðær lengest hwearf,
+weard winegeomor, wende þæs ylcan,
+þæt he lytel fæc longgestreona
+brucan moste. Beorh eallgearo
+wunode on wonge wæteryðum neah,
+niwe be næsse, nearocræftum fæst.
+þær on innan bær eorlgestreona
+hringa hyrde hordwyrðne dæl,
+fættan goldes, fea worda cwæð:
+"Heald þu nu, hruse, nu hæleð ne moston,
+eorla æhte! Hwæt, hyt ær on ðe
+gode begeaton. Guðdeað fornam,
+feorhbealo frecne, fyra gehwylcne
+leoda minra, þara ðe þis lif ofgeaf,
+gesawon seledream. Ic nah hwa sweord wege
+oððe feormie fæted wæge,
+dryncfæt deore; duguð ellor sceoc.
+Sceal se hearda helm hyrsted golde
+fætum befeallen; feormynd swefað,
+þa ðe beadogriman bywan sceoldon,
+ge swylce seo herepad, sio æt hilde gebad
+ofer borda gebræc bite irena,
+brosnað æfter beorne. Ne mæg byrnan hring
+æfter wigfruman wide feran,
+hæleðum be healfe. Næs hearpan wyn,
+gomen gleobeames, ne god hafoc
+geond sæl swingeð, ne se swifta mearh
+burhstede beateð. Bealocwealm hafað
+fela feorhcynna forð onsended!"
+Swa giomormod giohðo mænde
+an æfter eallum, unbliðe hwearf
+dæges ond nihtes, oððæt deaðes wylm
+hran æt heortan. Hordwynne fond
+eald uhtsceaða opene standan,
+se ðe byrnende biorgas seceð,
+nacod niðdraca, nihtes fleogeð
+fyre befangen; hyne foldbuend
+swiðe ondrædað. He gesecean sceall
+hord on hrusan, þær he hæðen gold
+warað wintrum frod, ne byð him wihte ðy sel.
+Swa se ðeodsceaða þreo hund wintra
+heold on hrusan hordærna sum,
+eacencræftig, oððæt hyne an abealch
+mon on mode; mandryhtne bær
+fæted wæge, frioðowære bæd
+hlaford sinne. ða wæs hord rasod,
+onboren beaga hord, bene getiðad
+feasceaftum men. Frea sceawode
+fira fyrngeweorc forman siðe.
+þa se wyrm onwoc, wroht wæs geniwad;
+stonc ða æfter stane, stearcheort onfand
+feondes fotlast; he to forð gestop
+dyrnan cræfte dracan heafde neah.
+Swa mæg unfæge eaðe gedigan
+wean ond wræcsið, se ðe waldendes
+hyldo gehealdeþ! Hordweard sohte
+georne æfter grunde, wolde guman findan,
+þone þe him on sweofote sare geteode,
+hat ond hreohmod hlæw oft ymbehwearf
+ealne utanweardne, ne ðær ænig mon
+on þære westenne; hwæðre wiges gefeh,
+beaduwe weorces, hwilum on beorh æthwearf,
+sincfæt sohte. He þæt sona onfand
+ðæt hæfde gumena sum goldes gefandod,
+heahgestreona. Hordweard onbad
+earfoðlice oððæt æfen cwom;
+wæs ða gebolgen beorges hyrde,
+wolde se laða lige forgyldan
+drincfæt dyre. þa wæs dæg sceacen
+wyrme on willan; no on wealle læg,
+bidan wolde, ac mid bæle for,
+fyre gefysed. Wæs se fruma egeslic
+leodum on lande, swa hyt lungre wearð
+on hyra sincgifan sare geendod.
+ða se gæst ongan gledum spiwan,
+beorht hofu bærnan; bryneleoma stod
+eldum on andan. No ðær aht cwices
+lað lyftfloga læfan wolde.
+Wæs þæs wyrmes wig wide gesyne,
+nearofages nið nean ond feorran,
+hu se guðsceaða Geata leode
+hatode ond hynde; hord eft gesceat,
+dryhtsele dyrnne, ær dæges hwile.
+Hæfde landwara lige befangen,
+bæle ond bronde, beorges getruwode,
+wiges ond wealles; him seo wen geleah.
+þa wæs Biowulfe broga gecyðed
+snude to soðe, þæt his sylfes ham,
+bolda selest, brynewylmum mealt,
+gifstol Geata. þæt ðam godan wæs
+hreow on hreðre, hygesorga mæst;
+wende se wisa þæt he wealdende
+ofer ealde riht, ecean dryhtne,
+bitre gebulge. Breost innan weoll
+þeostrum geþoncum, swa him geþywe ne wæs.
+Hæfde ligdraca leoda fæsten,
+ealond utan, eorðweard ðone
+gledum forgrunden; him ðæs guðkyning,
+Wedera þioden, wræce leornode.
+Heht him þa gewyrcean wigendra hleo
+eallirenne, eorla dryhten,
+wigbord wrætlic; wisse he gearwe
+þæt him holtwudu helpan ne meahte,
+lind wið lige. Sceolde lændaga
+æþeling ærgod ende gebidan,
+worulde lifes, ond se wyrm somod,
+þeah ðe hordwelan heolde lange.
+Oferhogode ða hringa fengel
+þæt he þone widflogan weorode gesohte,
+sidan herge; no he him þa sæcce ondred,
+ne him þæs wyrmes wig for wiht dyde,
+eafoð ond ellen, forðon he ær fela
+nearo neðende niða gedigde,
+hildehlemma, syððan he Hroðgares,
+sigoreadig secg, sele fælsode
+ond æt guðe forgrap Grendeles mægum
+laðan cynnes. No þæt læsest wæs
+hondgemota, þær mon Hygelac sloh,
+syððan Geata cyning guðe ræsum,
+freawine folca Freslondum on,
+Hreðles eafora hiorodryncum swealt,
+bille gebeaten. þonan Biowulf com
+sylfes cræfte, sundnytte dreah;
+hæfde him on earme ana [XXX]
+hildegeatwa, þa he to holme beag.
+Nealles Hetware hremge þorfton
+feðewiges, þe him foran ongean
+linde bæron; lyt eft becwom
+fram þam hildfrecan hames niosan.
+Oferswam ða sioleða bigong sunu Ecgðeowes,
+earm anhaga, eft to leodum;
+þær him Hygd gebead hord ond rice,
+beagas ond bregostol, bearne ne truwode
+þæt he wið ælfylcum eþelstolas
+healdan cuðe, ða wæs Hygelac dead.
+No ðy ær feasceafte findan meahton
+æt ðam æðelinge ænige ðinga,
+þæt he Heardrede hlaford wære
+oððe þone cynedom ciosan wolde;
+hwæðre he him on folce freondlarum heold,
+estum mid are, oððæt he yldra wearð,
+Wedergeatum weold. Hyne wræcmæcgas
+ofer sæ sohtan, suna Ohteres;
+hæfdon hy forhealden helm Scylfinga,
+þone selestan sæcyninga
+þara ðe in Swiorice sinc brytnade,
+mærne þeoden. Him þæt to mearce wearð;
+he þær for feorme feorhwunde hleat
+sweordes swengum, sunu Hygelaces,
+ond him eft gewat Ongenðioes bearn
+hames niosan, syððan Heardred læg,
+let ðone bregostol Biowulf healdan,
+Geatum wealdan. þæt wæs god cyning!
+Se ðæs leodhryres lean gemunde
+uferan dogrum, Eadgilse wearð
+feasceaftum freond, folce gestepte
+ofer sæ side sunu Ohteres,
+wigum ond wæpnum; he gewræc syððan
+cealdum cearsiðum, cyning ealdre bineat.
+Swa he niða gehwane genesen hæfde,
+sliðra geslyhta, sunu Ecgðiowes,
+ellenweorca, oð ðone anne dæg
+þe he wið þam wyrme gewegan sceolde.
+Gewat þa [XII]a sum torne gebolgen
+dryhten Geata dracan sceawian.
+Hæfde þa gefrunen hwanan sio fæhð aras,
+bealonið biorna; him to bearme cwom
+maðþumfæt mære þurh ðæs meldan hond.
+Se wæs on ðam ðreate þreotteoða secg,
+se ðæs orleges or onstealde,
+hæft hygegiomor, sceolde hean ðonon
+wong wisian. He ofer willan giong
+to ðæs ðe he eorðsele anne wisse,
+hlæw under hrusan holmwylme neh,
+yðgewinne; se wæs innan full
+wrætta ond wira. Weard unhiore,
+gearo guðfreca, goldmaðmas heold,
+eald under eorðan. Næs þæt yðe ceap
+to gegangenne gumena ænigum!
+Gesæt ða on næsse niðheard cyning,
+þenden hælo abead heorðgeneatum,
+goldwine Geata. Him wæs geomor sefa,
+wæfre ond wælfus, wyrd ungemete neah,
+se ðone gomelan gretan sceolde,
+secean sawle hord, sundur gedælan
+lif wið lice, no þon lange wæs
+feorh æþelinges flæsce bewunden.
+Biowulf maþelade, bearn Ecgðeowes:
+"Fela ic on giogoðe guðræsa genæs,
+orleghwila; ic þæt eall gemon.
+Ic wæs syfanwintre, þa mec sinca baldor,
+freawine folca, æt minum fæder genam;
+heold mec ond hæfde Hreðel cyning,
+geaf me sinc ond symbel, sibbe gemunde.
+Næs ic him to life laðra owihte,
+beorn in burgum, þonne his bearna hwylc,
+Herebeald ond Hæðcyn oððe Hygelac min.
+Wæs þam yldestan ungedefelice
+mæges dædum morþorbed stred,
+syððan hyne Hæðcyn of hornbogan,
+his freawine, flane geswencte,
+miste mercelses ond his mæg ofscet,
+broðor oðerne blodigan gare.
+þæt wæs feohleas gefeoht, fyrenum gesyngad,
+hreðre hygemeðe; sceolde hwæðre swa þeah
+æðeling unwrecen ealdres linnan.
+Swa bið geomorlic gomelum ceorle
+to gebidanne, þæt his byre ride
+giong on galgan, þonne he gyd wrece,
+sarigne sang, þonne his sunu hangað
+hrefne to hroðre, ond he him helpe ne mæg,
+eald ond infrod, ænige gefremman.
+Symble bið gemyndgad morna gehwylce
+eaforan ellorsið; oðres ne gymeð
+to gebidanne burgum in innan
+yrfeweardas, þonne se an hafað
+þurh deaðes nyd dæda gefondad.
+Gesyhð sorhcearig on his suna bure
+winsele westne, windge reste
+reote berofene. Ridend swefað,
+hæleð in hoðman; nis þær hearpan sweg,
+gomen in geardum, swylce ðær iu wæron.
+Gewiteð þonne on sealman, sorhleoð gæleð
+an æfter anum; þuhte him eall to rum,
+wongas ond wicstede. Swa Wedra helm
+æfter Herebealde heortan sorge
+weallende wæg. Wihte ne meahte
+on ðam feorhbonan fæghðe gebetan;
+no ðy ær he þone heaðorinc hatian ne meahte
+laðum dædum, þeah him leof ne wæs.
+He ða mid þære sorhge, þe him swa sar belamp,
+gumdream ofgeaf, godes leoht geceas,
+eaferum læfde, swa deð eadig mon,
+lond ond leodbyrig, þa he of life gewat.
+þa wæs synn ond sacu Sweona ond Geata
+ofer wid wæter, wroht gemæne,
+herenið hearda, syððan Hreðel swealt,
+oððe him Ongenðeowes eaferan wæran
+frome, fyrdhwate, freode ne woldon
+ofer heafo healdan, ac ymb Hreosnabeorh
+eatolne inwitscear oft gefremedon.
+þæt mægwine mine gewræcan,
+fæhðe ond fyrene, swa hyt gefræge wæs,
+þeah ðe oðer his ealdre gebohte,
+heardan ceape; Hæðcynne wearð,
+Geata dryhtne, guð onsæge.
+þa ic on morgne gefrægn mæg oðerne
+billes ecgum on bonan stælan,
+þær Ongenþeow Eofores niosað.
+Guðhelm toglad, gomela Scylfing
+hreas hildeblac; hond gemunde
+fæhðo genoge, feorhsweng ne ofteah.
+Ic him þa maðmas, þe he me sealde,
+geald æt guðe, swa me gifeðe wæs,
+leohtan sweorde; he me lond forgeaf,
+eard, eðelwyn. Næs him ænig þearf
+þæt he to Gifðum oððe to Gardenum
+oððe in Swiorice secean þurfe
+wyrsan wigfrecan, weorðe gecypan.
+Symle ic him on feðan beforan wolde,
+ana on orde, ond swa to aldre sceall
+sæcce fremman, þenden þis sweord þolað,
+þæt mec ær ond sið oft gelæste.
+Syððan ic for dugeðum Dæghrefne wearð
+to handbonan, Huga cempan;
+nalles he ða frætwe Frescyninge,
+breostweorðunge, bringan moste,
+ac in compe gecrong cumbles hyrde,
+æþeling on elne; ne wæs ecg bona,
+ac him hildegrap heortan wylmas,
+banhus gebræc. Nu sceall billes ecg,
+hond ond heard sweord, ymb hord wigan."
+Beowulf maðelode, beotwordum spræc
+niehstan siðe: "Ic geneðde fela
+guða on geogoðe; gyt ic wylle,
+frod folces weard, fæhðe secan,
+mærðu fremman, gif mec se mansceaða
+of eorðsele ut geseceð."
+Gegrette ða gumena gehwylcne,
+hwate helmberend, hindeman siðe,
+swæse gesiðas: "Nolde ic sweord beran,
+wæpen to wyrme, gif ic wiste hu
+wið ðam aglæcean elles meahte
+gylpe wiðgripan, swa ic gio wið Grendle dyde.
+Ac ic ðær heaðufyres hates wene,
+oreðes ond attres; forðon ic me on hafu
+bord ond byrnan. Nelle ic beorges weard
+forfleon fotes trem, ac unc furður sceal
+weorðan æt wealle, swa unc wyrd geteoð,
+metod manna gehwæs. Ic eom on mode from
+þæt ic wið þone guðflogan gylp ofersitte.
+Gebide ge on beorge byrnum werede,
+secgas on searwum, hwæðer sel mæge
+æfter wælræse wunde gedygan
+uncer twega. Nis þæt eower sið
+ne gemet mannes, nefne min anes,
+þæt he wið aglæcean eofoðo dæle,
+eorlscype efne. Ic mid elne sceall
+gold gegangan, oððe guð nimeð,
+feorhbealu frecne, frean eowerne!"
+Aras ða bi ronde rof oretta,
+heard under helme, hiorosercean bær
+under stancleofu, strengo getruwode
+anes mannes. Ne bið swylc earges sið!
+Geseah ða be wealle se ðe worna fela,
+gumcystum god, guða gedigde,
+hildehlemma, þonne hnitan feðan,
+stondan stanbogan, stream ut þonan
+brecan of beorge. Wæs þære burnan wælm
+heaðofyrum hat; ne meahte horde neah
+unbyrnende ænige hwile
+deop gedygan for dracan lege.
+Let ða of breostum, ða he gebolgen wæs,
+Wedergeata leod word ut faran,
+stearcheort styrmde; stefn in becom
+heaðotorht hlynnan under harne stan.
+Hete wæs onhrered, hordweard oncniow
+mannes reorde; næs ðær mara fyrst
+freode to friclan. From ærest cwom
+oruð aglæcean ut of stane,
+hat hildeswat. Hruse dynede.
+Biorn under beorge bordrand onswaf
+wið ðam gryregieste, Geata dryhten;
+ða wæs hringbogan heorte gefysed
+sæcce to seceanne. Sweord ær gebræd
+god guðcyning, gomele lafe,
+ecgum unslaw; æghwæðrum wæs
+bealohycgendra broga fram oðrum.
+Stiðmod gestod wið steapne rond
+winia bealdor, ða se wyrm gebeah
+snude tosomne; he on searwum bad.
+Gewat ða byrnende gebogen scriðan,
+to gescipe scyndan. Scyld wel gebearg
+life ond lice læssan hwile
+mærum þeodne þonne his myne sohte,
+ðær he þy fyrste, forman dogore
+wealdan moste swa him wyrd ne gescraf
+hreð æt hilde. Hond up abræd
+Geata dryhten, gryrefahne sloh
+incgelafe, þæt sio ecg gewac
+brun on bane, bat unswiðor
+þonne his ðiodcyning þearfe hæfde,
+bysigum gebæded. þa wæs beorges weard
+æfter heaðuswenge on hreoum mode,
+wearp wælfyre; wide sprungon
+hildeleoman. Hreðsigora ne gealp
+goldwine Geata; guðbill geswac,
+nacod æt niðe, swa hyt no sceolde,
+iren ærgod. Ne wæs þæt eðe sið,
+þæt se mæra maga Ecgðeowes
+grundwong þone ofgyfan wolde;
+sceolde ofer willan wic eardian
+elles hwergen, swa sceal æghwylc mon
+alætan lændagas. Næs ða long to ðon
+þæt ða aglæcean hy eft gemetton.
+Hyrte hyne hordweard (hreðer æðme weoll)
+niwan stefne; nearo ðrowode,
+fyre befongen, se ðe ær folce weold.
+Nealles him on heape handgesteallan,
+æðelinga bearn, ymbe gestodon
+hildecystum, ac hy on holt bugon,
+ealdre burgan. Hiora in anum weoll
+sefa wið sorgum; sibb æfre ne mæg
+wiht onwendan þam ðe wel þenceð.
+Wiglaf wæs haten Weoxstanes sunu,
+leoflic lindwiga, leod Scylfinga,
+mæg ælfheres; geseah his mondryhten
+under heregriman hat þrowian.
+Gemunde ða ða are þe he him ær forgeaf,
+wicstede weligne Wægmundinga,
+folcrihta gehwylc, swa his fæder ahte.
+Ne mihte ða forhabban; hond rond gefeng,
+geolwe linde, gomel swyrd geteah,
+þæt wæs mid eldum Eanmundes laf,
+suna Ohteres. þam æt sæcce wearð,
+wræccan wineleasum, Weohstan bana
+meces ecgum, ond his magum ætbær
+brunfagne helm, hringde byrnan,
+eald sweord etonisc; þæt him Onela forgeaf,
+his gædelinges guðgewædu,
+fyrdsearo fuslic, no ymbe ða fæhðe spræc,
+þeah ðe he his broðor bearn abredwade.
+He frætwe geheold fela missera,
+bill ond byrnan, oððæt his byre mihte
+eorlscipe efnan swa his ærfæder;
+geaf him ða mid Geatum guðgewæda,
+æghwæs unrim, þa he of ealdre gewat,
+frod on forðweg. þa wæs forma sið
+geongan cempan, þæt he guðe ræs
+mid his freodryhtne fremman sceolde.
+Ne gemealt him se modsefa, ne his mæges laf
+gewac æt wige; þæt se wyrm onfand,
+syððan hie togædre gegan hæfdon.
+Wiglaf maðelode, wordrihta fela
+sægde gesiðum (him wæs sefa geomor):
+"Ic ðæt mæl geman, þær we medu þegun,
+þonne we geheton ussum hlaforde
+in biorsele, ðe us ðas beagas geaf,
+þæt we him ða guðgetawa gyldan woldon
+gif him þyslicu þearf gelumpe,
+helmas ond heard sweord. ðe he usic on herge geceas
+to ðyssum siðfate sylfes willum,
+onmunde usic mærða, ond me þas maðmas geaf,
+þe he usic garwigend gode tealde,
+hwate helmberend, þeah ðe hlaford us
+þis ellenweorc ana aðohte
+to gefremmanne, folces hyrde,
+for ðam he manna mæst mærða gefremede,
+dæda dollicra. Nu is se dæg cumen
+þæt ure mandryhten mægenes behofað,
+godra guðrinca; wutun gongan to,
+helpan hildfruman, þenden hyt sy,
+gledegesa grim. God wat on mec
+þæt me is micle leofre þæt minne lichaman
+mid minne goldgyfan gled fæðmie.
+Ne þynceð me gerysne þæt we rondas beren
+eft to earde, nemne we æror mægen
+fane gefyllan, feorh ealgian
+Wedra ðeodnes. Ic wat geare
+þæt næron ealdgewyrht, þæt he ana scyle
+Geata duguðe gnorn þrowian,
+gesigan æt sæcce; urum sceal sweord ond helm,
+byrne ond beaduscrud, bam gemæne."
+Wod þa þurh þone wælrec, wigheafolan bær
+frean on fultum, fea worda cwæð:
+"Leofa Biowulf, læst eall tela,
+swa ðu on geoguðfeore geara gecwæde
+þæt ðu ne alæte be ðe lifigendum
+dom gedreosan. Scealt nu dædum rof,
+æðeling anhydig, ealle mægene
+feorh ealgian; ic ðe fullæstu."
+æfter ðam wordum wyrm yrre cwom,
+atol inwitgæst, oðre siðe
+fyrwylmum fah fionda niosian,
+laðra manna; ligyðum for.
+Born bord wið rond, byrne ne meahte
+geongum garwigan geoce gefremman,
+ac se maga geonga under his mæges scyld
+elne geeode, þa his agen wæs
+gledum forgrunden. þa gen guðcyning
+mærða gemunde, mægenstrengo sloh
+hildebille, þæt hyt on heafolan stod
+niþe genyded; Nægling forbærst,
+geswac æt sæcce sweord Biowulfes,
+gomol ond grægmæl. Him þæt gifeðe ne wæs
+þæt him irenna ecge mihton
+helpan æt hilde; wæs sio hond to strong,
+se ðe meca gehwane, mine gefræge,
+swenge ofersohte, þonne he to sæcce bær
+wæpen wundrum heard; næs him wihte ðe sel.
+þa wæs þeodsceaða þriddan siðe,
+frecne fyrdraca, fæhða gemyndig,
+ræsde on ðone rofan, þa him rum ageald,
+hat ond heaðogrim, heals ealne ymbefeng
+biteran banum; he geblodegod wearð
+sawuldriore, swat yðum weoll.
+ða ic æt þearfe gefrægn þeodcyninges
+andlongne eorl ellen cyðan,
+cræft ond cenðu, swa him gecynde wæs.
+Ne hedde he þæs heafolan, ac sio hand gebarn
+modiges mannes, þær he his mæges healp,
+þæt he þone niðgæst nioðor hwene sloh,
+secg on searwum, þæt ðæt sweord gedeaf,
+fah ond fæted, þæt ðæt fyr ongon
+sweðrian syððan. þa gen sylf cyning
+geweold his gewitte, wællseaxe gebræd
+biter ond beaduscearp, þæt he on byrnan wæg;
+forwrat Wedra helm wyrm on middan.
+Feond gefyldan (ferh ellen wræc),
+ond hi hyne þa begen abroten hæfdon,
+sibæðelingas. Swylc sceolde secg wesan,
+þegn æt ðearfe! þæt ðam þeodne wæs
+siðast sigehwila sylfes dædum,
+worlde geweorces. ða sio wund ongon,
+þe him se eorðdraca ær geworhte,
+swelan ond swellan; he þæt sona onfand,
+þæt him on breostum bealoniðe weoll
+attor on innan. ða se æðeling giong
+þæt he bi wealle wishycgende
+gesæt on sesse; seah on enta geweorc,
+hu ða stanbogan stapulum fæste
+ece eorðreced innan healde.
+Hyne þa mid handa heorodreorigne,
+þeoden mærne, þegn ungemete till
+winedryhten his wætere gelafede,
+hilde sædne, ond his helm onspeon.
+Biowulf maþelode (he ofer benne spræc,
+wunde wælbleate; wisse he gearwe
+þæt he dæghwila gedrogen hæfde,
+eorðan wynne; ða wæs eall sceacen
+dogorgerimes, deað ungemete neah):
+"Nu ic suna minum syllan wolde
+guðgewædu, þær me gifeðe swa
+ænig yrfeweard æfter wurde
+lice gelenge. Ic ðas leode heold
+fiftig wintra; næs se folccyning,
+ymbesittendra ænig ðara,
+þe mec guðwinum gretan dorste,
+egesan ðeon. Ic on earde bad
+mælgesceafta, heold min tela,
+ne sohte searoniðas, ne me swor fela
+aða on unriht. Ic ðæs ealles mæg
+feorhbennum seoc gefean habban;
+for ðam me witan ne ðearf waldend fira
+morðorbealo maga, þonne min sceaceð
+lif of lice. Nu ðu lungre geong
+hord sceawian under harne stan,
+Wiglaf leofa, nu se wyrm ligeð,
+swefeð sare wund, since bereafod.
+Bio nu on ofoste, þæt ic ærwelan,
+goldæht ongite, gearo sceawige
+swegle searogimmas, þæt ic ðy seft mæge
+æfter maððumwelan min alætan
+lif ond leodscipe, þone ic longe heold."
+ða ic snude gefrægn sunu Wihstanes
+æfter wordcwydum wundum dryhtne
+hyran heaðosiocum, hringnet beran,
+brogdne beadusercean under beorges hrof.
+Geseah ða sigehreðig, þa he bi sesse geong,
+magoþegn modig maððumsigla fealo,
+gold glitinian grunde getenge,
+wundur on wealle, ond þæs wyrmes denn,
+ealdes uhtflogan, orcas stondan,
+fyrnmanna fatu feormendlease,
+hyrstum behrorene; þær wæs helm monig
+eald ond omig, earmbeaga fela
+searwum gesæled. Sinc eaðe mæg,
+gold on grunde, gumcynnes gehwone
+oferhigian, hyde se ðe wylle.
+Swylce he siomian geseah segn eallgylden
+heah ofer horde, hondwundra mæst,
+gelocen leoðocræftum; of ðam leoma stod,
+þæt he þone grundwong ongitan meahte,
+wræte giondwlitan. Næs ðæs wyrmes þær
+onsyn ænig, ac hyne ecg fornam.
+ða ic on hlæwe gefrægn hord reafian,
+eald enta geweorc, anne mannan,
+him on bearm hladon bunan ond discas
+sylfes dome; segn eac genom,
+beacna beorhtost. Bill ær gescod
+(ecg wæs iren) ealdhlafordes
+þam ðara maðma mundbora wæs
+longe hwile, ligegesan wæg
+hatne for horde, hioroweallende
+middelnihtum, oðþæt he morðre swealt.
+Ar wæs on ofoste, eftsiðes georn,
+frætwum gefyrðred; hyne fyrwet bræc,
+hwæðer collenferð cwicne gemette
+in ðam wongstede Wedra þeoden
+ellensiocne, þær he hine ær forlet.
+He ða mid þam maðmum mærne þioden,
+dryhten sinne, driorigne fand
+ealdres æt ende; he hine eft ongon
+wæteres weorpan, oðþæt wordes ord
+breosthord þurhbræc.
+gomel on giohðe (gold sceawode):
+"Ic ðara frætwa frean ealles ðanc,
+wuldurcyninge, wordum secge,
+ecum dryhtne, þe ic her on starie,
+þæs ðe ic moste minum leodum
+ær swyltdæge swylc gestrynan.
+Nu ic on maðma hord mine bebohte
+frode feorhlege, fremmað gena
+leoda þearfe; ne mæg ic her leng wesan.
+Hatað heaðomære hlæw gewyrcean
+beorhtne æfter bæle æt brimes nosan;
+se scel to gemyndum minum leodum
+heah hlifian on Hronesnæsse,
+þæt hit sæliðend syððan hatan
+Biowulfes biorh, ða ðe brentingas
+ofer floda genipu feorran drifað."
+Dyde him of healse hring gyldenne
+þioden þristhydig, þegne gesealde,
+geongum garwigan, goldfahne helm,
+beah ond byrnan, het hyne brucan well:
+"þu eart endelaf usses cynnes,
+Wægmundinga. Ealle wyrd forsweop
+mine magas to metodsceafte,
+eorlas on elne; ic him æfter sceal."
+þæt wæs þam gomelan gingæste word
+breostgehygdum, ær he bæl cure,
+hate heaðowylmas; him of hreðre gewat
+sawol secean soðfæstra dom.
+ða wæs gegongen guman unfrodum
+earfoðlice, þæt he on eorðan geseah
+þone leofestan lifes æt ende
+bleate gebæran. Bona swylce læg,
+egeslic eorðdraca ealdre bereafod,
+bealwe gebæded. Beahhordum leng
+wyrm wohbogen wealdan ne moste,
+ac hine irenna ecga fornamon,
+hearde, heaðoscearde homera lafe,
+þæt se widfloga wundum stille
+hreas on hrusan hordærne neah.
+Nalles æfter lyfte lacende hwearf
+middelnihtum, maðmæhta wlonc
+ansyn ywde, ac he eorðan gefeoll
+for ðæs hildfruman hondgeweorce.
+Huru þæt on lande lyt manna ðah,
+mægenagendra, mine gefræge,
+þeah ðe he dæda gehwæs dyrstig wære,
+þæt he wið attorsceaðan oreðe geræsde,
+oððe hringsele hondum styrede,
+gif he wæccende weard onfunde
+buon on beorge. Biowulfe wearð
+dryhtmaðma dæl deaðe forgolden;
+hæfde æghwæðer ende gefered
+lænan lifes. Næs ða lang to ðon
+þæt ða hildlatan holt ofgefan,
+tydre treowlogan tyne ætsomne.
+ða ne dorston ær dareðum lacan
+on hyra mandryhtnes miclan þearfe,
+ac hy scamiende scyldas bæran,
+guðgewædu, þær se gomela læg,
+wlitan on Wilaf. He gewergad sæt,
+feðecempa, frean eaxlum neah,
+wehte hyne wætre; him wiht ne speow.
+Ne meahte he on eorðan, ðeah he uðe wel,
+on ðam frumgare feorh gehealdan,
+ne ðæs wealdendes wiht oncirran;
+wolde dom godes dædum rædan
+gumena gehwylcum, swa he nu gen deð.
+þa wæs æt ðam geongan grim ondswaru
+eðbegete þam ðe ær his elne forleas.
+Wiglaf maðelode, Weohstanes sunu,
+sec, sarigferð (seah on unleofe):
+"þæt, la, mæg secgan se ðe wyle soð specan
+þæt se mondryhten se eow ða maðmas geaf,
+eoredgeatwe, þe ge þær on standað,
+þonne he on ealubence oft gesealde
+healsittendum helm ond byrnan,
+þeoden his þegnum, swylce he þrydlicost
+ower feor oððe neah findan meahte,
+þæt he genunga guðgewædu
+wraðe forwurpe, ða hyne wig beget.
+Nealles folccyning fyrdgesteallum
+gylpan þorfte; hwæðre him god uðe,
+sigora waldend, þæt he hyne sylfne gewræc
+ana mid ecge, þa him wæs elnes þearf.
+Ic him lifwraðe lytle meahte
+ætgifan æt guðe, ond ongan swa þeah
+ofer min gemet mæges helpan;
+symle wæs þy sæmra, þonne ic sweorde drep
+ferhðgeniðlan, fyr unswiðor
+weoll of gewitte. Wergendra to lyt
+þrong ymbe þeoden, þa hyne sio þrag becwom.
+Nu sceal sincþego ond swyrdgifu,
+eall eðelwyn eowrum cynne,
+lufen alicgean; londrihtes mot
+þære mægburge monna æghwylc
+idel hweorfan, syððan æðelingas
+feorran gefricgean fleam eowerne,
+domleasan dæd. Deað bið sella
+eorla gehwylcum þonne edwitlif!"
+Heht ða þæt heaðoweorc to hagan biodan
+up ofer ecgclif, þær þæt eorlweorod
+morgenlongne dæg modgiomor sæt,
+bordhæbbende, bega on wenum,
+endedogores ond eftcymes
+leofes monnes. Lyt swigode
+niwra spella se ðe næs gerad,
+ac he soðlice sægde ofer ealle:
+"Nu is wilgeofa Wedra leoda,
+dryhten Geata, deaðbedde fæst,
+wunað wælreste wyrmes dædum.
+Him on efn ligeð ealdorgewinna
+sexbennum seoc; sweorde ne meahte
+on ðam aglæcean ænige þinga
+wunde gewyrcean. Wiglaf siteð
+ofer Biowulfe, byre Wihstanes,
+eorl ofer oðrum unlifigendum,
+healdeð higemæðum heafodwearde
+leofes ond laðes. Nu ys leodum wen
+orleghwile, syððan underne
+Froncum ond Frysum fyll cyninges
+wide weorðeð. Wæs sio wroht scepen
+heard wið Hugas, syððan Higelac cwom
+faran flotherge on Fresna land,
+þær hyne Hetware hilde genægdon,
+elne geeodon mid ofermægene,
+þæt se byrnwiga bugan sceolde,
+feoll on feðan, nalles frætwe geaf
+ealdor dugoðe. Us wæs a syððan
+Merewioingas milts ungyfeðe.
+Ne ic to Sweoðeode sibbe oððe treowe
+wihte ne wene, ac wæs wide cuð
+þætte Ongenðio ealdre besnyðede
+Hæðcen Hreþling wið Hrefnawudu,
+þa for onmedlan ærest gesohton
+Geata leode Guðscilfingas.
+Sona him se froda fæder Ohtheres,
+eald ond egesfull, ondslyht ageaf,
+abreot brimwisan, bryd ahredde,
+gomela iomeowlan golde berofene,
+Onelan modor ond Ohtheres,
+ond ða folgode feorhgeniðlan,
+oððæt hi oðeodon earfoðlice
+in Hrefnesholt hlafordlease.
+Besæt ða sinherge sweorda lafe,
+wundum werge, wean oft gehet
+earmre teohhe ondlonge niht,
+cwæð, he on mergenne meces ecgum
+getan wolde, sum on galgtreowum
+fuglum to gamene. Frofor eft gelamp
+sarigmodum somod ærdæge,
+syððan hie Hygelaces horn ond byman,
+gealdor ongeaton, þa se goda com
+leoda dugoðe on last faran.
+Wæs sio swatswaðu Sweona ond Geata,
+wælræs weora wide gesyne,
+hu ða folc mid him fæhðe towehton.
+Gewat him ða se goda mid his gædelingum,
+frod, felageomor, fæsten secean,
+eorl Ongenþio, ufor oncirde;
+hæfde Higelaces hilde gefrunen,
+wlonces wigcræft, wiðres ne truwode,
+þæt he sæmannum onsacan mihte,
+heaðoliðendum hord forstandan,
+bearn ond bryde; beah eft þonan
+eald under eorðweall. þa wæs æht boden
+Sweona leodum, segn Higelaces
+freoðowong þone forð ofereodon,
+syððan Hreðlingas to hagan þrungon.
+þær wearð Ongenðiow ecgum sweorda,
+blondenfexa, on bid wrecen,
+þæt se þeodcyning ðafian sceolde
+Eafores anne dom. Hyne yrringa
+Wulf Wonreding wæpne geræhte,
+þæt him for swenge swat ædrum sprong
+forð under fexe. Næs he forht swa ðeh,
+gomela Scilfing, ac forgeald hraðe
+wyrsan wrixle wælhlem þone,
+syððan ðeodcyning þyder oncirde.
+Ne meahte se snella sunu Wonredes
+ealdum ceorle ondslyht giofan,
+ac he him on heafde helm ær gescer,
+þæt he blode fah bugan sceolde,
+feoll on foldan; næs he fæge þa git,
+ac he hyne gewyrpte, þeah ðe him wund hrine.
+Let se hearda Higelaces þegn
+bradne mece, þa his broðor læg,
+eald sweord eotonisc, entiscne helm
+brecan ofer bordweal; ða gebeah cyning,
+folces hyrde, wæs in feorh dropen.
+ða wæron monige þe his mæg wriðon,
+ricone arærdon, ða him gerymed wearð
+þæt hie wælstowe wealdan moston.
+þenden reafode rinc oðerne,
+nam on Ongenðio irenbyrnan,
+heard swyrd hilted ond his helm somod,
+hares hyrste Higelace bær.
+He ðam frætwum feng ond him fægre gehet
+leana mid leodum, ond gelæste swa;
+geald þone guðræs Geata dryhten,
+Hreðles eafora, þa he to ham becom,
+Iofore ond Wulfe mid ofermaðmum,
+sealde hiora gehwæðrum hund þusenda
+landes ond locenra beaga (ne ðorfte him ða lean oðwitan
+mon on middangearde), syððan hie ða mærða geslogon,
+ond ða Iofore forgeaf angan dohtor,
+hamweorðunge, hyldo to wedde.
+þæt ys sio fæhðo ond se feondscipe,
+wælnið wera, ðæs ðe ic wen hafo,
+þe us seceað to Sweona leoda,
+syððan hie gefricgeað frean userne
+ealdorleasne, þone ðe ær geheold
+wið hettendum hord ond rice
+æfter hæleða hryre, hwate Scildingas,
+folcred fremede oððe furður gen
+eorlscipe efnde. Nu is ofost betost
+þæt we þeodcyning þær sceawian
+ond þone gebringan, þe us beagas geaf,
+on adfære. Ne scel anes hwæt
+meltan mid þam modigan, ac þær is maðma hord,
+gold unrime grimme geceapod,
+ond nu æt siðestan sylfes feore
+beagas gebohte. þa sceall brond fretan,
+æled þeccean, nalles eorl wegan
+maððum to gemyndum, ne mægð scyne
+habban on healse hringweorðunge,
+ac sceal geomormod, golde bereafod,
+oft nalles æne elland tredan,
+nu se herewisa hleahtor alegde,
+gamen ond gleodream. Forðon sceall gar wesan
+monig, morgenceald, mundum bewunden,
+hæfen on handa, nalles hearpan sweg
+wigend weccean, ac se wonna hrefn
+fus ofer fægum fela reordian,
+earne secgan hu him æt æte speow,
+þenden he wið wulf wæl reafode."
+Swa se secg hwata secggende wæs
+laðra spella; he ne leag fela
+wyrda ne worda. Weorod eall aras;
+eodon unbliðe under Earnanæs,
+wollenteare wundur sceawian.
+Fundon ða on sande sawulleasne
+hlimbed healdan þone þe him hringas geaf
+ærran mælum; þa wæs endedæg
+godum gegongen, þæt se guðcyning,
+Wedra þeoden, wundordeaðe swealt.
+ær hi þær gesegan syllicran wiht,
+wyrm on wonge wiðerræhtes þær
+laðne licgean; wæs se legdraca
+grimlic, gryrefah, gledum beswæled.
+Se wæs fiftiges fotgemearces
+lang on legere, lyftwynne heold
+nihtes hwilum, nyðer eft gewat
+dennes niosian; wæs ða deaðe fæst,
+hæfde eorðscrafa ende genyttod.
+Him big stodan bunan ond orcas,
+discas lagon ond dyre swyrd,
+omige, þurhetone, swa hie wið eorðan fæðm
+þusend wintra þær eardodon.
+þonne wæs þæt yrfe, eacencræftig,
+iumonna gold galdre bewunden,
+þæt ðam hringsele hrinan ne moste
+gumena ænig, nefne god sylfa,
+sigora soðcyning, sealde þam ðe he wolde
+(he is manna gehyld) hord openian,
+efne swa hwylcum manna swa him gemet ðuhte.
+þa wæs gesyne þæt se sið ne ðah
+þam ðe unrihte inne gehydde
+wræte under wealle. Weard ær ofsloh
+feara sumne; þa sio fæhð gewearð
+gewrecen wraðlice. Wundur hwar þonne
+eorl ellenrof ende gefere
+lifgesceafta, þonne leng ne mæg
+mon mid his magum meduseld buan.
+Swa wæs Biowulfe, þa he biorges weard
+sohte, searoniðas; seolfa ne cuðe
+þurh hwæt his worulde gedal weorðan sceolde.
+Swa hit oð domes dæg diope benemdon
+þeodnas mære, þa ðæt þær dydon,
+þæt se secg wære synnum scildig,
+hergum geheaðerod, hellbendum fæst,
+wommum gewitnad, se ðone wong strude,
+næs he goldhwæte gearwor hæfde
+agendes est ær gesceawod.
+Wiglaf maðelode, Wihstanes sunu:
+"Oft sceall eorl monig anes willan
+wræc adreogan, swa us geworden is.
+Ne meahton we gelæran leofne þeoden,
+rices hyrde, ræd ænigne,
+þæt he ne grette goldweard þone,
+lete hyne licgean þær he longe wæs,
+wicum wunian oð woruldende;
+heold on heahgesceap. Hord ys gesceawod,
+grimme gegongen; wæs þæt gifeðe to swið
+þe ðone þeodcyning þyder ontyhte.
+Ic wæs þær inne ond þæt eall geondseh,
+recedes geatwa, þa me gerymed wæs,
+nealles swæslice sið alyfed
+inn under eorðweall. Ic on ofoste gefeng
+micle mid mundum mægenbyrðenne
+hordgestreona, hider ut ætbær
+cyninge minum. Cwico wæs þa gena,
+wis ond gewittig; worn eall gespræc
+gomol on gehðo ond eowic gretan het,
+bæd þæt ge geworhton æfter wines dædum
+in bælstede beorh þone hean,
+micelne ond mærne, swa he manna wæs
+wigend weorðfullost wide geond eorðan,
+þenden he burhwelan brucan moste.
+Uton nu efstan oðre siðe,
+seon ond secean searogimma geþræc,
+wundur under wealle; ic eow wisige,
+þæt ge genoge neon sceawiað
+beagas ond brad gold. Sie sio bær gearo,
+ædre geæfned, þonne we ut cymen,
+ond þonne geferian frean userne,
+leofne mannan, þær he longe sceal
+on ðæs waldendes wære geþolian."
+Het ða gebeodan byre Wihstanes,
+hæle hildedior, hæleða monegum,
+boldagendra, þæt hie bælwudu
+feorran feredon, folcagende,
+godum togenes: "Nu sceal gled fretan,
+weaxan wonna leg wigena strengel,
+þone ðe oft gebad isernscure,
+þonne stræla storm strengum gebæded
+scoc ofer scildweall, sceft nytte heold,
+feðergearwum fus flane fulleode."
+Huru se snotra sunu Wihstanes
+acigde of corðre cyninges þegnas
+syfone tosomne, þa selestan,
+eode eahta sum under inwithrof
+hilderinca; sum on handa bær
+æledleoman, se ðe on orde geong.
+Næs ða on hlytme hwa þæt hord strude,
+syððan orwearde ænigne dæl
+secgas gesegon on sele wunian,
+læne licgan; lyt ænig mearn
+þæt hi ofostlice ut geferedon
+dyre maðmas. Dracan ec scufun,
+wyrm ofer weallclif, leton weg niman,
+flod fæðmian frætwa hyrde.
+þa wæs wunden gold on wæn hladen,
+æghwæs unrim, æþeling boren,
+har hilderinc to Hronesnæsse.
+Him ða gegiredan Geata leode
+ad on eorðan unwaclicne,
+helmum behongen, hildebordum,
+beorhtum byrnum, swa he bena wæs;
+alegdon ða tomiddes mærne þeoden
+hæleð hiofende, hlaford leofne.
+Ongunnon þa on beorge bælfyra mæst
+wigend weccan; wudurec astah,
+sweart ofer swioðole, swogende leg
+wope bewunden (windblond gelæg),
+oðþæt he ða banhus gebrocen hæfde,
+hat on hreðre. Higum unrote
+modceare mændon, mondryhtnes cwealm;
+swylce giomorgyd Geatisc meowle
+bundenheorde
+song sorgcearig swiðe geneahhe
+þæt hio hyre heofungdagas hearde ondrede,
+wælfylla worn, werudes egesan,
+hynðo ond hæftnyd. Heofon rece swealg.
+Geworhton ða Wedra leode
+hleo on hoe, se wæs heah ond brad,
+wægliðendum wide gesyne,
+ond betimbredon on tyn dagum
+beadurofes becn, bronda lafe
+wealle beworhton, swa hyt weorðlicost
+foresnotre men findan mihton.
+Hi on beorg dydon beg ond siglu,
+eall swylce hyrsta, swylce on horde ær
+niðhedige men genumen hæfdon,
+forleton eorla gestreon eorðan healdan,
+gold on greote, þær hit nu gen lifað
+eldum swa unnyt swa hit æror wæs.
+þa ymbe hlæw riodan hildediore,
+æþelinga bearn, ealra twelfe,
+woldon ceare cwiðan ond kyning mænan,
+wordgyd wrecan ond ymb wer sprecan;
+eahtodan eorlscipe ond his ellenweorc
+duguðum demdon, swa hit gedefe bið
+þæt mon his winedryhten wordum herge,
+ferhðum freoge, þonne he forð scile
+of lichaman læded weorðan.
+Swa begnornodon Geata leode
+hlafordes hryre, heorðgeneatas,
+cwædon þæt he wære wyruldcyninga
+manna mildust ond monðwærust,
+leodum liðost ond lofgeornost.
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.rs
new file mode 100644
index 0000000..187b776
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.rs
@@ -0,0 +1,6 @@
+use std::io;
+use std::io::Write;
+
+fn main() {
+  assert!(io::stderr().write_all(include_bytes!("io_stderr-hello.stderr")).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.stderr b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.stderr
new file mode 100644
index 0000000..130d52c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stderr-hello.stderr
@@ -0,0 +1 @@
+Hello, stderr!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.rs
new file mode 100644
index 0000000..30a2a28
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.rs
@@ -0,0 +1,11 @@
+use std::io;
+use std::io::Read;
+
+fn main() {
+    let mut stdin = String::new();
+    assert!(io::stdin().read_to_string(&mut stdin).is_ok());
+    assert_eq!(
+        stdin,
+        String::from_utf8_lossy(include_bytes!("io_stdin-beowulf.stdin"))
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.stdin b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.stdin
new file mode 100644
index 0000000..1856685
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-beowulf.stdin
@@ -0,0 +1,3182 @@
+Hwæt. We Gardena in geardagum,
+þeodcyninga, þrym gefrunon,
+hu ða æþelingas ellen fremedon.
+Oft Scyld Scefing sceaþena þreatum,
+monegum mægþum, meodosetla ofteah,
+egsode eorlas. Syððan ærest wearð
+feasceaft funden, he þæs frofre gebad,
+weox under wolcnum, weorðmyndum þah,
+oðþæt him æghwylc þara ymbsittendra
+ofer hronrade hyran scolde,
+gomban gyldan. þæt wæs god cyning.
+ðæm eafera wæs æfter cenned,
+geong in geardum, þone god sende
+folce to frofre; fyrenðearfe ongeat
+þe hie ær drugon aldorlease
+lange hwile. Him þæs liffrea,
+wuldres wealdend, woroldare forgeaf;
+Beowulf wæs breme blæd wide sprang,
+Scyldes eafera Scedelandum in.
+Swa sceal geong guma gode gewyrcean,
+fromum feohgiftum on fæder bearme,
+þæt hine on ylde eft gewunigen
+wilgesiþas, þonne wig cume,
+leode gelæsten; lofdædum sceal
+in mægþa gehwære man geþeon.
+Him ða Scyld gewat to gescæphwile
+felahror feran on frean wære.
+Hi hyne þa ætbæron to brimes faroðe,
+swæse gesiþas, swa he selfa bæd,
+þenden wordum weold wine Scyldinga;
+leof landfruma lange ahte.
+þær æt hyðe stod hringedstefna,
+isig ond utfus, æþelinges fær.
+Aledon þa leofne þeoden,
+beaga bryttan, on bearm scipes,
+mærne be mæste. þær wæs madma fela
+of feorwegum, frætwa, gelæded;
+ne hyrde ic cymlicor ceol gegyrwan
+hildewæpnum ond heaðowædum,
+billum ond byrnum; him on bearme læg
+madma mænigo, þa him mid scoldon
+on flodes æht feor gewitan.
+Nalæs hi hine læssan lacum teodan,
+þeodgestreonum, þon þa dydon
+þe hine æt frumsceafte forð onsendon
+ænne ofer yðe umborwesende.
+þa gyt hie him asetton segen geldenne
+heah ofer heafod, leton holm beran,
+geafon on garsecg; him wæs geomor sefa,
+murnende mod. Men ne cunnon
+secgan to soðe, selerædende,
+hæleð under heofenum, hwa þæm hlæste onfeng.
+ða wæs on burgum Beowulf Scyldinga,
+leof leodcyning, longe þrage
+folcum gefræge fæder ellor hwearf,
+aldor of earde, oþþæt him eft onwoc
+heah Healfdene; heold þenden lifde,
+gamol ond guðreouw, glæde Scyldingas.
+ðæm feower bearn forð gerimed
+in worold wocun, weoroda ræswan,
+Heorogar ond Hroðgar ond Halga til;
+hyrde ic þæt wæs Onelan cwen,
+Heaðoscilfingas healsgebedda.
+þa wæs Hroðgare heresped gyfen,
+wiges weorðmynd, þæt him his winemagas
+georne hyrdon, oðð þæt seo geogoð geweox,
+magodriht micel. Him on mod bearn
+þæt healreced hatan wolde,
+medoærn micel, men gewyrcean
+þonne yldo bearn æfre gefrunon,
+ond þær on innan eall gedælan
+geongum ond ealdum, swylc him god sealde,
+buton folcscare ond feorum gumena.
+ða ic wide gefrægn weorc gebannan
+manigre mægþe geond þisne middangeard,
+folcstede frætwan. Him on fyrste gelomp,
+ædre mid yldum, þæt hit wearð ealgearo,
+healærna mæst; scop him Heort naman
+se þe his wordes geweald wide hæfde.
+He beot ne aleh, beagas dælde,
+sinc æt symle. Sele hlifade,
+heah ond horngeap, heaðowylma bad,
+laðan liges; ne wæs hit lenge þa gen
+þæt se ecghete aþumsweorum,
+æfter wælniðe wæcnan scolde.
+ða se ellengæst earfoðlice
+þrage geþolode, se þe in þystrum bad,
+þæt he dogora gehwam dream gehyrde
+hludne in healle; þær wæs hearpan sweg,
+swutol sang scopes. Sægde se þe cuþe
+frumsceaft fira feorran reccan,
+cwæð þæt se ælmihtiga eorðan worhte,
+wlitebeorhtne wang, swa wæter bebugeð,
+gesette sigehreþig sunnan ond monan
+leoman to leohte landbuendum
+ond gefrætwade foldan sceatas
+leomum ond leafum, lif eac gesceop
+cynna gehwylcum þara ðe cwice hwyrfaþ.
+Swa ða drihtguman dreamum lifdon
+eadiglice, oððæt an ongan
+fyrene fremman feond on helle.
+Wæs se grimma gæst Grendel haten,
+mære mearcstapa, se þe moras heold,
+fen ond fæsten; fifelcynnes eard
+wonsæli wer weardode hwile,
+siþðan him scyppend forscrifen hæfde
+in Caines cynne. þone cwealm gewræc
+ece drihten, þæs þe he Abel slog;
+ne gefeah he þære fæhðe, ac he hine feor forwræc,
+metod for þy mane, mancynne fram.
+þanon untydras ealle onwocon,
+eotenas ond ylfe ond orcneas,
+swylce gigantas, þa wið gode wunnon
+lange þrage; he him ðæs lean forgeald.
+Gewat ða neosian, syþðan niht becom,
+hean huses, hu hit Hringdene
+æfter beorþege gebun hæfdon.
+Fand þa ðær inne æþelinga gedriht
+swefan æfter symble; sorge ne cuðon,
+wonsceaft wera. Wiht unhælo,
+grim ond grædig, gearo sona wæs,
+reoc ond reþe, ond on ræste genam
+þritig þegna, þanon eft gewat
+huðe hremig to ham faran,
+mid þære wælfylle wica neosan.
+ða wæs on uhtan mid ærdæge
+Grendles guðcræft gumum undyrne;
+þa wæs æfter wiste wop up ahafen,
+micel morgensweg. Mære þeoden,
+æþeling ærgod, unbliðe sæt,
+þolode ðryðswyð, þegnsorge dreah,
+syðþan hie þæs laðan last sceawedon,
+wergan gastes; wæs þæt gewin to strang,
+lað ond longsum. Næs hit lengra fyrst,
+ac ymb ane niht eft gefremede
+morðbeala mare ond no mearn fore,
+fæhðe ond fyrene; wæs to fæst on þam.
+þa wæs eaðfynde þe him elles hwær
+gerumlicor ræste sohte,
+bed æfter burum, ða him gebeacnod wæs,
+gesægd soðlice sweotolan tacne
+healðegnes hete; heold hyne syðþan
+fyr ond fæstor se þæm feonde ætwand.
+Swa rixode ond wið rihte wan,
+ana wið eallum, oðþæt idel stod
+husa selest. Wæs seo hwil micel;
+XII wintra tid torn geþolode
+wine Scyldinga, weana gehwelcne,
+sidra sorga. Forðam secgum wearð,
+ylda bearnum, undyrne cuð,
+gyddum geomore, þætte Grendel wan
+hwile wið Hroþgar, heteniðas wæg,
+fyrene ond fæhðe fela missera,
+singale sæce, sibbe ne wolde
+wið manna hwone mægenes Deniga,
+feorhbealo feorran, fea þingian,
+ne þær nænig witena wenan þorfte
+beorhtre bote to banan folmum,
+ac se æglæca ehtende wæs,
+deorc deaþscua, duguþe ond geogoþe,
+seomade ond syrede, sinnihte heold
+mistige moras. men ne cunnon
+hwyder helrunan hwyrftum scriþað.
+Swa fela fyrena feond mancynnes,
+atol angengea, oft gefremede,
+heardra hynða. Heorot eardode,
+sincfage sel sweartum nihtum;
+no he þone gifstol gretan moste,
+maþðum for metode, ne his myne wisse.
+þæt wæs wræc micel wine Scyldinga,
+modes brecða. Monig oft gesæt
+rice to rune; ræd eahtedon
+hwæt swiðferhðum selest wære
+wið færgryrum to gefremmanne.
+Hwilum hie geheton æt hærgtrafum
+wigweorþunga, wordum bædon
+þæt him gastbona geoce gefremede
+wið þeodþreaum. Swylc wæs þeaw hyra,
+hæþenra hyht; helle gemundon
+in modsefan, metod hie ne cuþon,
+dæda demend, ne wiston hie drihten god,
+ne hie huru heofena helm herian ne cuþon,
+wuldres waldend. Wa bið þæm ðe sceal
+þurh sliðne nið sawle bescufan
+in fyres fæþm, frofre ne wenan,
+wihte gewendan; wel bið þæm þe mot
+æfter deaðdæge drihten secean
+ond to fæder fæþmum freoðo wilnian.
+Swa ða mælceare maga Healfdenes
+singala seað, ne mihte snotor hæleð
+wean onwendan; wæs þæt gewin to swyð,
+laþ ond longsum, þe on ða leode becom,
+nydwracu niþgrim, nihtbealwa mæst.
+þæt fram ham gefrægn Higelaces þegn,
+god mid Geatum, Grendles dæda;
+se wæs moncynnes mægenes strengest
+on þæm dæge þysses lifes,
+æþele ond eacen. Het him yðlidan
+godne gegyrwan, cwæð, hu guðcyning
+ofer swanrade secean wolde,
+mærne þeoden, þa him wæs manna þearf.
+ðone siðfæt him snotere ceorlas
+lythwon logon, þeah he him leof wære;
+hwetton higerofne, hæl sceawedon.
+Hæfde se goda Geata leoda
+cempan gecorone þara þe he cenoste
+findan mihte; XVna sum
+sundwudu sohte; secg wisade,
+lagucræftig mon, landgemyrcu.
+Fyrst forð gewat. Flota wæs on yðum,
+bat under beorge. Beornas gearwe
+on stefn stigon; streamas wundon,
+sund wið sande; secgas bæron
+on bearm nacan beorhte frætwe,
+guðsearo geatolic; guman ut scufon,
+weras on wilsið, wudu bundenne.
+Gewat þa ofer wægholm, winde gefysed,
+flota famiheals fugle gelicost,
+oðþæt ymb antid oþres dogores
+wundenstefna gewaden hæfde
+þæt ða liðende land gesawon,
+brimclifu blican, beorgas steape,
+side sænæssas; þa wæs sund liden,
+eoletes æt ende. þanon up hraðe
+Wedera leode on wang stigon,
+sæwudu sældon syrcan hrysedon,
+guðgewædo, gode þancedon
+þæs þe him yþlade eaðe wurdon.
+þa of wealle geseah weard Scildinga,
+se þe holmclifu healdan scolde,
+beran ofer bolcan beorhte randas,
+fyrdsearu fuslicu; hine fyrwyt bræc
+modgehygdum, hwæt þa men wæron.
+Gewat him þa to waroðe wicge ridan
+þegn Hroðgares, þrymmum cwehte
+mægenwudu mundum, meþelwordum frægn:
+Hwæt syndon ge searohæbbendra,
+byrnum werede, þe þus brontne ceol
+ofer lagustræte lædan cwomon,
+hider ofer holmas? le wæs
+endesæta, ægwearde heold,
+þe on land Dena laðra nænig
+mid scipherge sceðþan ne meahte.
+No her cuðlicor cuman ongunnon
+lindhæbbende; ne ge leafnesword
+guðfremmendra gearwe ne wisson,
+maga gemedu. Næfre ic maran geseah
+eorla ofer eorþan ðonne is eower sum,
+secg on searwum; nis þæt seldguma,
+wæpnum geweorðad, næfne him his wlite leoge,
+ænlic ansyn. Nu ic eower sceal
+frumcyn witan, ær ge fyr heonan ,
+leassceaweras, on land Dena
+furþur feran. Nu ge feorbuend,
+mereliðende, minne gehyrað
+anfealdne geþoht: Ofost is selest
+to gecyðanne hwanan eowre cyme syndon.
+Him se yldesta ondswarode,
+werodes wisa, wordhord onleac:
+We synt gumcynnes Geata leode
+ond Higelaces heorðgeneatas.
+Wæs min fæder folcum gecyþed,
+æþele ordfruma, Ecgþeow haten.
+Gebad wintra worn, ær he on weg hwurfe,
+gamol of geardum; hine gearwe geman
+witena welhwylc wide geond eorþan.
+We þurh holdne hige hlaford þinne,
+sunu Healfdenes, secean cwomon,
+leodgebyrgean; wes þu us larena god.
+Habbað we to þæm mæran micel ærende,
+Deniga frean, ne sceal þær dyrne sum
+wesan, þæs ic wene. þu wast gif hit is
+swa we soþlice secgan hyrdon
+þæt mid Scyldingum sceaðona ic nat hwylc,
+deogol dædhata, deorcum nihtum
+eaweð þurh egsan uncuðne nið,
+hynðu ond hrafyl. Ic þæs Hroðgar mæg
+þurh rumne sefan ræd gelæran,
+hu he frod ond god feond oferswyðeþ,
+gyf him edwendan æfre scolde
+bealuwa bisigu, bot eft cuman,
+ond þa cearwylmas colran wurðaþ;
+oððe a syþðan earfoðþrage,
+þreanyd þolað, þenden þær wunað
+on heahstede husa selest.
+Weard maþelode, ðær on wicge sæt,
+ombeht unforht: æghwæþres sceal
+scearp scyldwiga gescad witan,
+worda ond worca, se þe wel þenceð.
+Ic þæt gehyre, þæt þis is hold weorod
+frean Scyldinga. Gewitaþ forð beran
+wæpen ond gewædu; ic eow wisige.
+Swylce ic maguþegnas mine hate
+wið feonda gehwone flotan eowerne,
+niwtyrwydne nacan on sande
+arum healdan, oþðæt eft byreð
+ofer lagustreamas leofne mannan
+wudu wundenhals to Wedermearce,
+godfremmendra swylcum gifeþe bið
+þæt þone hilderæs hal gedigeð.
+Gewiton him þa feran. Flota stille bad,
+seomode on sale sidfæþmed scip,
+on ancre fæst. Eoforlic scionon
+ofer hleorberan gehroden golde,
+fah ond fyrheard; ferhwearde heold
+guþmod grimmon. Guman onetton,
+sigon ætsomne, oþþæt hy sæl timbred,
+geatolic ond goldfah, ongyton mihton;
+þæt wæs foremærost foldbuendum
+receda under roderum, on þæm se rica bad;
+lixte se leoma ofer landa fela.
+Him þa hildedeor hof modigra
+torht getæhte, þæt hie him to mihton
+gegnum gangan; guðbeorna sum
+wicg gewende, word æfter cwæð:
+Mæl is me to feran; fæder alwalda
+mid arstafum eowic gehealde
+siða gesunde. Ic to sæ wille
+wið wrað werod wearde healdan.
+Stræt wæs stanfah, stig wisode
+gumum ætgædere. Guðbyrne scan
+heard hondlocen, hringiren scir
+song in searwum, þa hie to sele furðum
+in hyra gryregeatwum gangan cwomon.
+Setton sæmeþe side scyldas,
+rondas regnhearde, wið þæs recedes weal,
+bugon þa to bence. Byrnan hringdon,
+guðsearo gumena; garas stodon,
+sæmanna searo, samod ætgædere,
+æscholt ufan græg; wæs se irenþreat
+wæpnum gewurþad. þa ðær wlonc hæleð
+oretmecgas æfter æþelum frægn:
+Hwanon ferigeað ge fætte scyldas,
+græge syrcan ond grimhelmas,
+heresceafta heap? Ic eom Hroðgares
+ar ond ombiht. Ne seah ic elþeodige
+þus manige men modiglicran.
+Wen ic þæt ge for wlenco, nalles for wræcsiðum,
+ac for higeþrymmum Hroðgar sohton.
+Him þa ellenrof andswarode,
+wlanc Wedera leod, word æfter spræc,
+heard under helme: We synt Higelaces
+beodgeneatas; Beowulf is min nama.
+Wille ic asecgan sunu Healfdenes,
+mærum þeodne, min ærende,
+aldre þinum, gif he us geunnan wile
+þæt we hine swa godne gretan moton.
+Wulfgar maþelode þæt wæs Wendla leod;
+wæs his modsefa manegum gecyðed,
+wig ond wisdom: Ic þæs wine Deniga,
+frean Scildinga, frinan wille,
+beaga bryttan, swa þu bena eart,
+þeoden mærne, ymb þinne sið,
+ond þe þa ondsware ædre gecyðan
+ðe me se goda agifan þenceð.
+Hwearf þa hrædlice þær Hroðgar sæt
+eald ond anhar mid his eorla gedriht;
+eode ellenrof, þæt he for eaxlum gestod
+Deniga frean; cuþe he duguðe þeaw.
+Wulfgar maðelode to his winedrihtne:
+Her syndon geferede, feorran cumene
+ofer geofenes begang Geata leode;
+þone yldestan oretmecgas
+Beowulf nemnað. Hy benan synt
+þæt hie, þeoden min, wið þe moton
+wordum wrixlan. No ðu him wearne geteoh
+ðinra gegncwida, glædman Hroðgar.
+Hy on wiggetawum wyrðe þinceað
+eorla geæhtlan; huru se aldor deah,
+se þæm heaðorincum hider wisade.
+Hroðgar maþelode, helm Scyldinga:
+Ic hine cuðe cnihtwesende.
+Wæs his ealdfæder Ecgþeo haten,
+ðæm to ham forgeaf Hreþel Geata
+angan dohtor; is his eafora nu
+heard her cumen, sohte holdne wine.
+ðonne sægdon þæt sæliþende,
+þa ðe gifsceattas Geata fyredon
+þyder to þance, þæt he XXXtiges
+manna mægencræft on his mundgripe
+heaþorof hæbbe. Hine halig god
+for arstafum us onsende,
+to Westdenum, þæs ic wen hæbbe,
+wið Grendles gryre. Ic þæm godan sceal
+for his modþræce madmas beodan.
+Beo ðu on ofeste, hat in gan
+seon sibbegedriht samod ætgædere;
+gesaga him eac wordum þæt hie sint wilcuman
+Deniga leodum.
+[] word inne abead:
+Eow het secgan sigedrihten min,
+aldor Eastdena, þæt he eower æþelu can,
+ond ge him syndon ofer sæwylmas
+heardhicgende hider wilcuman.
+Nu ge moton gangan in eowrum guðgeatawum
+under heregriman Hroðgar geseon;
+lætað hildebord her onbidan,
+wudu, wælsceaftas, worda geþinges.
+Aras þa se rica, ymb hine rinc manig,
+þryðlic þegna heap; sume þær bidon,
+heaðoreaf heoldon, swa him se hearda bebead.
+Snyredon ætsomne, þa secg wisode,
+under Heorotes hrof
+heard under helme, þæt he on heoðe gestod.
+Beowulf maðelode on him byrne scan,
+searonet seowed smiþes orþancum:
+Wæs þu, Hroðgar, hal. Ic eom Higelaces
+mæg ond magoðegn; hæbbe ic mærða fela
+ongunnen on geogoþe. Me wearð Grendles þing
+on minre eþeltyrf undyrne cuð;
+secgað sæliðend þæt þæs sele stande,
+reced selesta, rinca gehwylcum
+idel ond unnyt, siððan æfenleoht
+under heofenes hador beholen weorþeð.
+þa me þæt gelærdon leode mine
+þa selestan, snotere ceorlas,
+þeoden Hroðgar, þæt ic þe sohte,
+forþan hie mægenes cræft minne cuþon,
+selfe ofersawon, ða ic of searwum cwom,
+fah from feondum. þær ic fife geband,
+yðde eotena cyn ond on yðum slog
+niceras nihtes, nearoþearfe dreah,
+wræc Wedera nið wean ahsodon,
+forgrand gramum, ond nu wið Grendel sceal,
+wið þam aglæcan, ana gehegan
+ðing wið þyrse. Ic þe nu ða,
+brego Beorhtdena, biddan wille,
+eodor Scyldinga, anre bene,
+þæt ðu me ne forwyrne, wigendra hleo,
+freowine folca, nu ic þus feorran com,
+þæt ic mote ana ond minra eorla gedryht,
+þes hearda heap, Heorot fælsian.
+Hæbbe ic eac geahsod þæt se æglæca
+for his wonhydum wæpna ne recceð.
+Ic þæt þonne forhicge swa me Higelac sie,
+min mondrihten, modes bliðe,
+þæt ic sweord bere oþðe sidne scyld,
+geolorand to guþe, ac ic mid grape sceal
+fon wið feonde ond ymb feorh sacan,
+lað wið laþum; ðær gelyfan sceal
+dryhtnes dome se þe hine deað nimeð.
+Wen ic þæt he wille, gif he wealdan mot,
+in þæm guðsele Geotena leode
+etan unforhte, swa he oft dyde,
+mægen Hreðmanna. Na þu minne þearft
+hafalan hydan, ac he me habban wile
+dreore fahne, gif mec deað nimeð.
+Byreð blodig wæl, byrgean þenceð,
+eteð angenga unmurnlice,
+mearcað morhopu; no ðu ymb mines ne þearft
+lices feorme leng sorgian.
+Onsend Higelace, gif mec hild nime,
+beaduscruda betst, þæt mine breost wereð,
+hrægla selest; þæt is Hrædlan laf,
+Welandes geweorc. Gæð a wyrd swa hio scel.
+Hroðgar maþelode, helm Scyldinga:
+For gewyrhtum þu, wine min Beowulf,
+ond for arstafum usic sohtest.
+Gesloh þin fæder fæhðe mæste;
+wearþ he Heaþolafe to handbonan
+mid Wilfingum; ða hine Wedera cyn
+for herebrogan habban ne mihte.
+þanon he gesohte Suðdena folc
+ofer yða gewealc, Arscyldinga.
+ða ic furþum weold folce Deniga
+ond on geogoðe heold ginne rice,
+hordburh hæleþa; ða wæs Heregar dead,
+min yldra mæg unlifigende,
+bearn Healfdenes; se wæs betera ðonne ic.
+Siððan þa fæhðe feo þingode;
+sende ic Wylfingum ofer wæteres hrycg
+ealde madmas; he me aþas swor.
+Sorh is me to secganne on sefan minum
+gumena ængum hwæt me Grendel hafað
+hynðo on Heorote mid his heteþancum,
+færniða gefremed. Is min fletwerod,
+wigheap gewanod; hie wyrd forsweop
+on Grendles gryre. God eaþe mæg
+þone dolsceaðan dæda getwæfan.
+Ful oft gebeotedon beore druncne
+ofer ealowæge oretmecgas
+þæt hie in beorsele bidan woldon
+Grendles guþe mid gryrum ecga.
+ðonne wæs þeos medoheal on morgentid,
+drihtsele dreorfah, þonne dæg lixte,
+eal bencþelu blode bestymed,
+heall heorudreore; ahte ic holdra þy læs,
+deorre duguðe, þe þa deað fornam.
+Site nu to symle ond onsæl meoto,
+sigehreð secgum, swa þin sefa hwette.
+þa wæs Geatmæcgum geador ætsomne
+on beorsele benc gerymed;
+þær swiðferhþe sittan eodon,
+þryðum dealle. þegn nytte beheold,
+se þe on handa bær hroden ealowæge,
+scencte scir wered. Scop hwilum sang
+hador on Heorote. þær wæs hæleða dream,
+duguð unlytel Dena ond Wedera.
+Unferð maþelode, Ecglafes bearn,
+þe æt fotum sæt frean Scyldinga,
+onband beadurune wæs him Beowulfes sið,
+modges merefaran, micel æfþunca,
+forþon þe he ne uþe þæt ænig oðer man
+æfre mærða þon ma middangeardes
+gehedde under heofenum þonne he sylfa:
+Eart þu se Beowulf, se þe wið Brecan wunne,
+on sidne sæ ymb sund flite,
+ðær git for wlence wada cunnedon
+ond for dolgilpe on deop wæter
+aldrum neþdon? Ne inc ænig mon,
+ne leof ne lað, belean mihte
+sorhfullne sið, þa git on sund reon.
+þær git eagorstream earmum þehton,
+mæton merestræta, mundum brugdon,
+glidon ofer garsecg; geofon yþum weol,
+wintrys wylmum. Git on wæteres æht
+seofon niht swuncon; he þe æt sunde oferflat,
+hæfde mare mægen. þa hine on morgentid
+on Heaþoræmas holm up ætbær;
+ðonon he gesohte swæsne eþel,
+leof his leodum, lond Brondinga,
+freoðoburh fægere, þær he folc ahte
+burh ond beagas. Beot eal wið þe
+sunu Beanstanes soðe gelæste.
+ðonne wene ic to þe wyrsan geþingea,
+ðeah þu heaðoræsa gehwær dohte,
+grimre guðe, gif þu Grendles dearst
+nihtlongne fyrst nean bidan.
+Beowulf maþelode, bearn Ecgþeowes:
+Hwæt. þu worn fela, wine min Unferð,
+beore druncen ymb Brecan spræce,
+sægdest from his siðe. Soð ic talige,
+þæt ic merestrengo maran ahte,
+earfeþo on yþum, ðonne ænig oþer man.
+Wit þæt gecwædon cnihtwesende
+ond gebeotedon wæron begen þa git
+on geogoðfeore þæt wit on garsecg ut
+aldrum neðdon, ond þæt geæfndon swa.
+Hæfdon swurd nacod, þa wit on sund reon,
+heard on handa; wit unc wið hronfixas
+werian þohton. No he wiht fram me
+flodyþum feor fleotan meahte,
+hraþor on holme; no ic fram him wolde.
+ða wit ætsomne on sæ wæron
+fif nihta fyrst, oþþæt unc flod todraf,
+wado weallende, wedera cealdost,
+nipende niht, ond norþanwind
+heaðogrim ondhwearf; hreo wæron yþa.
+Wæs merefixa mod onhrered;
+þær me wið laðum licsyrce min,
+heard, hondlocen, helpe gefremede,
+beadohrægl broden on breostum læg
+golde gegyrwed. Me to grunde teah
+fah feondscaða, fæste hæfde
+grim on grape; hwæþre me gyfeþe wearð
+þæt ic aglæcan orde geræhte,
+hildebille; heaþoræs fornam
+mihtig meredeor þurh mine hand.
+Swa mec gelome laðgeteonan
+þreatedon þearle. Ic him þenode
+deoran sweorde, swa hit gedefe wæs.
+Næs hie ðære fylle gefean hæfdon,
+manfordædlan, þæt hie me þegon,
+symbel ymbsæton sægrunde neah;
+ac on mergenne mecum wunde
+be yðlafe uppe lægon,
+sweordum aswefede, þæt syðþan na
+ymb brontne ford brimliðende
+lade ne letton. Leoht eastan com,
+beorht beacen godes; brimu swaþredon,
+þæt ic sænæssas geseon mihte,
+windige weallas. Wyrd oft nereð
+unfægne eorl, þonne his ellen deah.
+Hwæþere me gesælde þæt ic mid sweorde ofsloh
+niceras nigene. No ic on niht gefrægn
+under heofones hwealf heardran feohtan,
+ne on egstreamum earmran mannon;
+hwaþere ic fara feng feore gedigde,
+siþes werig. ða mec sæ oþbær,
+flod æfter faroðe on Finna land,
+wadu weallendu. No ic wiht fram þe
+swylcra searoniða secgan hyrde,
+billa brogan. Breca næfre git
+æt heaðolace, ne gehwæþer incer,
+swa deorlice dæd gefremede
+fagum sweordum no ic þæs fela gylpe,
+þeah ðu þinum broðrum to banan wurde,
+heafodmægum; þæs þu in helle scealt
+werhðo dreogan, þeah þin wit duge.
+Secge ic þe to soðe, sunu Ecglafes,
+þæt næfre Grendel swa fela gryra gefremede,
+atol æglæca, ealdre þinum,
+hynðo on Heorote, gif þin hige wære,
+sefa swa searogrim, swa þu self talast.
+Ac he hafað onfunden þæt he þa fæhðe ne þearf,
+atole ecgþræce eower leode
+swiðe onsittan, Sigescyldinga;
+nymeð nydbade, nænegum arað
+leode Deniga, ac he lust wigeð,
+swefeð ond sendeþ, secce ne weneþ
+to Gardenum. Ac ic him Geata sceal
+eafoð ond ellen ungeara nu,
+guþe gebeodan. Gæþ eft se þe mot
+to medo modig, siþþan morgenleoht
+ofer ylda bearn oþres dogores,
+sunne sweglwered suþan scineð.
+þa wæs on salum sinces brytta,
+gamolfeax ond guðrof; geoce gelyfde
+brego Beorhtdena, gehyrde on Beowulfe
+folces hyrde fæstrædne geþoht.
+ðær wæs hæleþa hleahtor, hlyn swynsode,
+word wæron wynsume. Eode Wealhþeow forð,
+cwen Hroðgares, cynna gemyndig,
+grette goldhroden guman on healle,
+ond þa freolic wif ful gesealde
+ærest Eastdena eþelwearde,
+bæd hine bliðne æt þære beorþege,
+leodum leofne. He on lust geþeah
+symbel ond seleful, sigerof kyning.
+Ymbeode þa ides Helminga
+duguþe ond geogoþe dæl æghwylcne,
+sincfato sealde, oþþæt sæl alamp
+þæt hio Beowulfe, beaghroden cwen
+mode geþungen, medoful ætbær;
+grette Geata leod, gode þancode
+wisfæst wordum þæs ðe hire se willa gelamp
+þæt heo on ænigne eorl gelyfde
+fyrena frofre. He þæt ful geþeah,
+wælreow wiga, æt Wealhþeon,
+ond þa gyddode guþe gefysed;
+Beowulf maþelode, bearn Ecgþeowes:
+Ic þæt hogode, þa ic on holm gestah,
+sæbat gesæt mid minre secga gedriht,
+þæt ic anunga eowra leoda
+willan geworhte oþðe on wæl crunge,
+feondgrapum fæst. Ic gefremman sceal
+eorlic ellen, oþðe endedæg
+on þisse meoduhealle minne gebidan.
+ðam wife þa word wel licodon,
+gilpcwide Geates; eode goldhroden
+freolicu folccwen to hire frean sittan.
+þa wæs eft swa ær inne on healle
+þryðword sprecen, ðeod on sælum,
+sigefolca sweg, oþþæt semninga
+sunu Healfdenes secean wolde
+æfenræste; wiste þæm ahlæcan
+to þæm heahsele hilde geþinged,
+siððan hie sunnan leoht geseon ne meahton,
+oðþe nipende niht ofer ealle,
+scaduhelma gesceapu scriðan cwoman,
+wan under wolcnum. Werod eall aras.
+Gegrette þa guma oþerne,
+Hroðgar Beowulf, ond him hæl abead,
+winærnes geweald, ond þæt word acwæð:
+Næfre ic ænegum men ær alyfde,
+siþðan ic hond ond rond hebban mihte,
+ðryþærn Dena buton þe nu ða.
+Hafa nu ond geheald husa selest,
+gemyne mærþo, mægenellen cyð,
+waca wið wraþum. Ne bið þe wilna gad,
+gif þu þæt ellenweorc aldre gedigest.
+ða him Hroþgar gewat mid his hæleþa gedryht,
+eodur Scyldinga, ut of healle;
+wolde wigfruma Wealhþeo secan,
+cwen to gebeddan. Hæfde kyningwuldor
+Grendle togeanes, swa guman gefrungon,
+seleweard aseted; sundornytte beheold
+ymb aldor Dena, eotonweard abead.
+Huru Geata leod georne truwode
+modgan mægnes, metodes hyldo.
+ða he him of dyde isernbyrnan,
+helm of hafelan, sealde his hyrsted sweord,
+irena cyst, ombihtþegne,
+ond gehealdan het hildegeatwe.
+Gespræc þa se goda gylpworda sum,
+Beowulf Geata, ær he on bed stige:
+No ic me an herewæsmun hnagran talige,
+guþgeweorca, þonne Grendel hine;
+forþan ic hine sweorde swebban nelle,
+aldre beneotan, þeah ic eal mæge.
+Nat he þara goda þæt he me ongean slea,
+rand geheawe, þeah ðe he rof sie
+niþgeweorca; ac wit on niht sculon
+secge ofersittan, gif he gesecean dear
+wig ofer wæpen, ond siþðan witig god
+on swa hwæþere hond, halig dryhten,
+mærðo deme, swa him gemet þince.
+Hylde hine þa heaþodeor, hleorbolster onfeng
+eorles andwlitan, ond hine ymb monig
+snellic særinc selereste gebeah.
+Nænig heora þohte þæt he þanon scolde
+eft eardlufan æfre gesecean,
+folc oþðe freoburh, þær he afeded wæs;
+ac hie hæfdon gefrunen þæt hie ær to fela micles
+in þæm winsele wældeað fornam,
+Denigea leode. Ac him dryhten forgeaf
+wigspeda gewiofu, Wedera leodum,
+frofor ond fultum, þæt hie feond heora
+ðurh anes cræft ealle ofercomon,
+selfes mihtum. Soð is gecyþed
+þæt mihtig god manna cynnes
+weold wideferhð. Com on wanre niht
+scriðan sceadugenga. Sceotend swæfon,
+þa þæt hornreced healdan scoldon,
+ealle buton anum. þæt wæs yldum cuþ
+þæt hie ne moste, þa metod nolde,
+se scynscaþa under sceadu bregdan;
+ac he wæccende wraþum on andan
+bad bolgenmod beadwa geþinges.
+ða com of more under misthleoþum
+Grendel gongan, godes yrre bær;
+mynte se manscaða manna cynnes
+sumne besyrwan in sele þam hean.
+Wod under wolcnum to þæs þe he winreced,
+goldsele gumena, gearwost wisse,
+fættum fahne. Ne wæs þæt forma sið
+þæt he Hroþgares ham gesohte;
+næfre he on aldordagum ær ne siþðan
+heardran hæle, healðegnas fand.
+Com þa to recede rinc siðian,
+dreamum bedæled. Duru sona onarn,
+fyrbendum fæst, syþðan he hire folmum æthran;
+onbræd þa bealohydig, ða he gebolgen wæs,
+recedes muþan. Raþe æfter þon
+on fagne flor feond treddode,
+eode yrremod; him of eagum stod
+ligge gelicost leoht unfæger.
+Geseah he in recede rinca manige,
+swefan sibbegedriht samod ætgædere,
+magorinca heap. þa his mod ahlog;
+mynte þæt he gedælde, ærþon dæg cwome,
+atol aglæca, anra gehwylces
+lif wið lice, þa him alumpen wæs
+wistfylle wen. Ne wæs þæt wyrd þa gen
+þæt he ma moste manna cynnes
+ðicgean ofer þa niht. þryðswyð beheold
+mæg Higelaces, hu se manscaða
+under færgripum gefaran wolde.
+Ne þæt se aglæca yldan þohte,
+ac he gefeng hraðe forman siðe
+slæpendne rinc, slat unwearnum,
+bat banlocan, blod edrum dranc,
+synsnædum swealh; sona hæfde
+unlyfigendes eal gefeormod,
+fet ond folma. Forð near ætstop,
+nam þa mid handa higeþihtigne
+rinc on ræste, ræhte ongean
+feond mid folme; he onfeng hraþe
+inwitþancum ond wið earm gesæt.
+Sona þæt onfunde fyrena hyrde
+þæt he ne mette middangeardes,
+eorþan sceata, on elran men
+mundgripe maran. He on mode wearð
+forht on ferhðe; no þy ær fram meahte.
+Hyge wæs him hinfus, wolde on heolster fleon,
+secan deofla gedræg; ne wæs his drohtoð þær
+swylce he on ealderdagum ær gemette.
+Gemunde þa se goda, mæg Higelaces,
+æfenspræce, uplang astod
+ond him fæste wiðfeng; fingras burston.
+Eoten wæs utweard; eorl furþur stop.
+Mynte se mæra, þær he meahte swa,
+widre gewindan ond on weg þanon
+fleon on fenhopu; wiste his fingra geweald
+on grames grapum. þæt wæs geocor sið
+þæt se hearmscaþa to Heorute ateah.
+Dryhtsele dynede; Denum eallum wearð,
+ceasterbuendum, cenra gehwylcum,
+eorlum ealuscerwen. Yrre wæron begen,
+reþe renweardas. Reced hlynsode.
+þa wæs wundor micel þæt se winsele
+wiðhæfde heaþodeorum, þæt he on hrusan ne feol,
+fæger foldbold; ac he þæs fæste wæs
+innan ond utan irenbendum
+searoþoncum besmiþod. þær fram sylle abeag
+medubenc monig, mine gefræge,
+golde geregnad, þær þa graman wunnon.
+þæs ne wendon ær witan Scyldinga
+þæt hit a mid gemete manna ænig,
+betlic ond banfag, tobrecan meahte,
+listum tolucan, nymþe liges fæþm
+swulge on swaþule. Sweg up astag
+niwe geneahhe; Norðdenum stod
+atelic egesa, anra gehwylcum
+þara þe of wealle wop gehyrdon,
+gryreleoð galan godes ondsacan,
+sigeleasne sang, sar wanigean
+helle hæfton. Heold hine fæste
+se þe manna wæs mægene strengest
+on þæm dæge þysses lifes.
+Nolde eorla hleo ænige þinga
+þone cwealmcuman cwicne forlætan,
+ne his lifdagas leoda ænigum
+nytte tealde. þær genehost brægd
+eorl Beowulfes ealde lafe,
+wolde freadrihtnes feorh ealgian,
+mæres þeodnes, ðær hie meahton swa.
+Hie þæt ne wiston, þa hie gewin drugon,
+heardhicgende hildemecgas,
+ond on healfa gehwone heawan þohton,
+sawle secan, þone synscaðan
+ænig ofer eorþan irenna cyst,
+guðbilla nan, gretan nolde,
+ac he sigewæpnum forsworen hæfde,
+ecga gehwylcre. Scolde his aldorgedal
+on ðæm dæge þysses lifes
+earmlic wurðan, ond se ellorgast
+on feonda geweald feor siðian.
+ða þæt onfunde se þe fela æror
+modes myrðe manna cynne,
+fyrene gefremede he wæs fag wið god,
+þæt him se lichoma læstan nolde,
+ac hine se modega mæg Hygelaces
+hæfde be honda; wæs gehwæþer oðrum
+lifigende lað. Licsar gebad
+atol æglæca; him on eaxle wearð
+syndolh sweotol, seonowe onsprungon,
+burston banlocan. Beowulfe wearð
+guðhreð gyfeþe; scolde Grendel þonan
+feorhseoc fleon under fenhleoðu,
+secean wynleas wic; wiste þe geornor
+þæt his aldres wæs ende gegongen,
+dogera dægrim. Denum eallum wearð
+æfter þam wælræse willa gelumpen.
+Hæfde þa gefælsod se þe ær feorran com,
+snotor ond swyðferhð, sele Hroðgares,
+genered wið niðe; nihtweorce gefeh,
+ellenmærþum. Hæfde Eastdenum
+Geatmecga leod gilp gelæsted,
+swylce oncyþðe ealle gebette,
+inwidsorge, þe hie ær drugon
+ond for þreanydum þolian scoldon,
+torn unlytel. þæt wæs tacen sweotol,
+syþðan hildedeor hond alegde,
+earm ond eaxle þær wæs eal geador
+Grendles grape under geapne hrof.
+ða wæs on morgen mine gefræge
+ymb þa gifhealle guðrinc monig;
+ferdon folctogan feorran ond nean
+geond widwegas wundor sceawian,
+laþes lastas. No his lifgedal
+sarlic þuhte secga ænegum
+þara þe tirleases trode sceawode,
+hu he werigmod on weg þanon,
+niða ofercumen, on nicera mere
+fæge ond geflymed feorhlastas bær.
+ðær wæs on blode brim weallende,
+atol yða geswing eal gemenged
+haton heolfre, heorodreore weol.
+Deaðfæge deog, siððan dreama leas
+in fenfreoðo feorh alegde,
+hæþene sawle; þær him hel onfeng.
+þanon eft gewiton ealdgesiðas,
+swylce geong manig of gomenwaþe
+fram mere modge mearum ridan,
+beornas on blancum. ðær wæs Beowulfes
+mærðo mæned; monig oft gecwæð
+þætte suð ne norð be sæm tweonum
+ofer eormengrund oþer nænig
+under swegles begong selra nære
+rondhæbbendra, rices wyrðra.
+Ne hie huru winedrihten wiht ne logon,
+glædne Hroðgar, ac þæt wæs god cyning.
+Hwilum heaþorofe hleapan leton,
+on geflit faran fealwe mearas
+ðær him foldwegas fægere þuhton,
+cystum cuðe. Hwilum cyninges þegn,
+guma gilphlæden, gidda gemyndig,
+se ðe ealfela ealdgesegena
+worn gemunde, word oþer fand
+soðe gebunden; secg eft ongan
+sið Beowulfes snyttrum styrian
+ond on sped wrecan spel gerade,
+wordum wrixlan. Welhwylc gecwæð
+þæt he fram Sigemundes secgan hyrde
+ellendædum, uncuþes fela,
+Wælsinges gewin, wide siðas,
+þara þe gumena bearn gearwe ne wiston,
+fæhðe ond fyrena, buton Fitela mid hine,
+þonne he swulces hwæt secgan wolde,
+eam his nefan, swa hie a wæron
+æt niða gehwam nydgesteallan;
+hæfdon ealfela eotena cynnes
+sweordum gesæged. Sigemunde gesprong
+æfter deaðdæge dom unlytel,
+syþðan wiges heard wyrm acwealde,
+hordes hyrde. He under harne stan,
+æþelinges bearn, ana geneðde
+frecne dæde, ne wæs him Fitela mid.
+hwæþre him gesælde ðæt þæt swurd þurhwod
+wrætlicne wyrm, þæt hit on wealle ætstod,
+dryhtlic iren; draca morðre swealt.
+Hæfde aglæca elne gegongen
+þæt he beahhordes brucan moste
+selfes dome; sæbat gehleod,
+bær on bearm scipes beorhte frætwa,
+Wælses eafera. Wyrm hat gemealt.
+Se wæs wreccena wide mærost
+ofer werþeode, wigendra hleo,
+ellendædum he þæs ær onðah,
+siððan Heremodes hild sweðrode,
+eafoð ond ellen. He mid Eotenum wearð
+on feonda geweald forð forlacen,
+snude forsended. Hine sorhwylmas
+lemede to lange; he his leodum wearð,
+eallum æþellingum to aldorceare;
+swylce oft bemearn ærran mælum
+swiðferhþes sið snotor ceorl monig,
+se þe him bealwa to bote gelyfde,
+þæt þæt ðeodnes bearn geþeon scolde,
+fæderæþelum onfon, folc gehealdan,
+hord ond hleoburh, hæleþa rice,
+eþel Scyldinga. He þær eallum wearð,
+mæg Higelaces, manna cynne,
+freondum gefægra; hine fyren onwod.
+Hwilum flitende fealwe stræte
+mearum mæton. ða wæs morgenleoht
+scofen ond scynded. Eode scealc monig
+swiðhicgende to sele þam hean
+searowundor seon; swylce self cyning
+of brydbure, beahhorda weard,
+tryddode tirfæst getrume micle,
+cystum gecyþed, ond his cwen mid him
+medostigge mæt mægþa hose.
+Hroðgar maþelode he to healle geong,
+stod on stapole, geseah steapne hrof,
+golde fahne, ond Grendles hond:
+ðisse ansyne alwealdan þanc
+lungre gelimpe. Fela ic laþes gebad,
+grynna æt Grendle; a mæg god wyrcan
+wunder æfter wundre, wuldres hyrde.
+ðæt wæs ungeara þæt ic ænigra me
+weana ne wende to widan feore
+bote gebidan, þonne blode fah
+husa selest heorodreorig stod,
+wea widscofen witena gehwylcum
+ðara þe ne wendon þæt hie wideferhð
+leoda landgeweorc laþum beweredon
+scuccum ond scinnum. Nu scealc hafað
+þurh drihtnes miht dæd gefremede ðe
+we ealle ær ne meahton
+snyttrum besyrwan. Hwæt, þæt secgan mæg
+efne swa hwylc mægþa swa ðone magan cende
+æfter gumcynnum, gyf heo gyt lyfað,
+þæt hyre ealdmetod este wære
+bearngebyrdo. Nu ic, Beowulf, þec,
+secg betsta, me for sunu wylle
+freogan on ferhþe; heald forð tela
+niwe sibbe. Ne bið þe nænigra gad
+worolde wilna, þe ic geweald hæbbe.
+Ful oft ic for læssan lean teohhode,
+hordweorþunge hnahran rince,
+sæmran æt sæcce. þu þe self hafast
+dædum gefremed þæt þin dom lyfað
+awa to aldre. Alwalda þec
+gode forgylde, swa he nu gyt dyde.
+Beowulf maþelode, bearn Ecþeowes:
+We þæt ellenweorc estum miclum,
+feohtan fremedon, frecne geneðdon
+eafoð uncuþes. Uþe ic swiþor
+þæt ðu hine selfne geseon moste,
+feond on frætewum fylwerigne.
+Ic hine hrædlice heardan clammum
+on wælbedde wriþan þohte,
+þæt he for mundgripe minum scolde
+licgean lifbysig, butan his lic swice.
+Ic hine ne mihte, þa metod nolde,
+ganges getwæman, no ic him þæs georne ætfealh,
+feorhgeniðlan; wæs to foremihtig
+feond on feþe. Hwæþere he his folme forlet
+to lifwraþe last weardian,
+earm ond eaxle. No þær ænige swa þeah
+feasceaft guma frofre gebohte;
+no þy leng leofað laðgeteona,
+synnum geswenced, ac hyne sar hafað
+mid nydgripe nearwe befongen,
+balwon bendum. ðær abidan sceal
+maga mane fah miclan domes,
+hu him scir metod scrifan wille.
+ða wæs swigra secg, sunu Eclafes,
+on gylpspræce guðgeweorca,
+siþðan æþelingas eorles cræfte
+ofer heanne hrof hand sceawedon,
+feondes fingras. Foran æghwylc wæs,
+stiðra nægla gehwylc, style gelicost,
+hæþenes handsporu hilderinces,
+egl, unheoru. æghwylc gecwæð
+þæt him heardra nan hrinan wolde
+iren ærgod, þæt ðæs ahlæcan
+blodge beadufolme onberan wolde.
+ða wæs haten hreþe Heort innanweard
+folmum gefrætwod. Fela þæra wæs,
+wera ond wifa, þe þæt winreced,
+gestsele gyredon. Goldfag scinon
+web æfter wagum, wundorsiona fela
+secga gehwylcum þara þe on swylc starað.
+Wæs þæt beorhte bold tobrocen swiðe,
+eal inneweard irenbendum fæst,
+heorras tohlidene. Hrof ana genæs,
+ealles ansund, þe se aglæca,
+fyrendædum fag, on fleam gewand,
+aldres orwena. No þæt yðe byð
+to befleonne, fremme se þe wille,
+ac gesecan sceal sawlberendra,
+nyde genydde, niþða bearna,
+grundbuendra gearwe stowe,
+þær his lichoma legerbedde fæst
+swefeþ æfter symle. þa wæs sæl ond mæl
+þæt to healle gang Healfdenes sunu;
+wolde self cyning symbel þicgan.
+Ne gefrægen ic þa mægþe maran weorode
+ymb hyra sincgyfan sel gebæran.
+Bugon þa to bence blædagande,
+fylle gefægon; fægere geþægon
+medoful manig magas þara
+swiðhicgende on sele þam hean,
+Hroðgar ond Hroþulf. Heorot innan wæs
+freondum afylled; nalles facenstafas
+|eodscyldingas þenden fremedon.
+Forgeaf þa Beowulfe bearn Healfdenes
+segen gyldenne sigores to leane;
+hroden hildecumbor, helm ond byrnan,
+mære maðþumsweord manige gesawon
+beforan beorn beran. Beowulf geþah
+ful on flette; no he þære feohgyfte
+for sceotendum scamigan ðorfte.
+Ne gefrægn ic freondlicor feower madmas
+golde gegyrede gummanna fela
+in ealobence oðrum gesellan.
+Ymb þæs helmes hrof heafodbeorge
+wirum bewunden walu utan heold,
+þæt him fela laf frecne ne meahton
+scurheard sceþðan, þonne scyldfreca
+ongean gramum gangan scolde.
+Heht ða eorla hleo eahta mearas
+fætedhleore on flet teon,
+in under eoderas. þara anum stod
+sadol searwum fah, since gewurþad;
+þæt wæs hildesetl heahcyninges,
+ðonne sweorda gelac sunu Healfdenes
+efnan wolde. Næfre on ore læg
+widcuþes wig, ðonne walu feollon.
+Ond ða Beowulfe bega gehwæþres
+eodor Ingwina onweald geteah,
+wicga ond wæpna, het hine wel brucan.
+Swa manlice mære þeoden,
+hordweard hæleþa, heaþoræsas geald
+mearum ond madmum, swa hy næfre man lyhð,
+se þe secgan wile soð æfter rihte.
+ða gyt æghwylcum eorla drihten
+þara þe mid Beowulfe brimlade teah
+on þære medubence maþðum gesealde,
+yrfelafe, ond þone ænne heht
+golde forgyldan, þone ðe Grendel ær
+mane acwealde, swa he hyra ma wolde,
+nefne him witig god wyrd forstode
+ond ðæs mannes mod. Metod eallum weold
+gumena cynnes, swa he nu git deð.
+Forþan bið andgit æghwær selest,
+ferhðes foreþanc. Fela sceal gebidan
+leofes ond laþes se þe longe her
+on ðyssum windagum worolde bruceð.
+þær wæs sang ond sweg samod ætgædere
+fore Healfdenes hildewisan,
+gomenwudu greted, gid oft wrecen,
+ðonne healgamen Hroþgares scop
+æfter medobence mænan scolde
+be Finnes eaferum, ða hie se fær begeat,
+hæleð Healfdena, Hnæf Scyldinga,
+in Freswæle feallan scolde.
+Ne huru Hildeburh herian þorfte
+Eotena treowe; unsynnum wearð
+beloren leofum æt þam lindplegan,
+bearnum ond broðrum; hie on gebyrd hruron,
+gare wunde. þæt wæs geomuru ides.
+Nalles holinga Hoces dohtor
+meotodsceaft bemearn, syþðan morgen com,
+ða heo under swegle geseon meahte
+morþorbealo maga, þær heo ær mæste heold
+worolde wynne. Wig ealle fornam
+Finnes þegnas nemne feaum anum,
+þæt he ne mehte on þæm meðelstede
+wig Hengeste wiht gefeohtan,
+ne þa wealafe wige forþringan
+þeodnes ðegna. ac hig him geþingo budon,
+þæt hie him oðer flet eal gerymdon,
+healle ond heahsetl, þæt hie healfre geweald
+wið Eotena bearn agan moston,
+ond æt feohgyftum Folcwaldan sunu
+dogra gehwylce Dene weorþode,
+Hengestes heap hringum wenede
+efne swa swiðe sincgestreonum
+fættan goldes, swa he Fresena cyn
+on beorsele byldan wolde.
+ða hie getruwedon on twa healfa
+fæste frioðuwære. Fin Hengeste
+elne, unflitme aðum benemde
+þæt he þa wealafe weotena dome
+arum heolde, þæt ðær ænig mon
+wordum ne worcum wære ne bræce,
+ne þurh inwitsearo æfre gemænden
+ðeah hie hira beaggyfan banan folgedon
+ðeodenlease, þa him swa geþearfod wæs.
+gyf þonne Frysna hwylc frecnan spræce
+ðæs morþorhetes myndgiend wære,
+þonne hit sweordes ecg seðan scolde.
+Ad wæs geæfned ond icge gold
+ahæfen of horde. Herescyldinga
+betst beadorinca wæs on bæl gearu.
+æt þæm ade wæs eþgesyne
+swatfah syrce, swyn ealgylden,
+eofer irenheard, æþeling manig
+wundum awyrded; sume on wæle crungon.
+Het ða Hildeburh æt Hnæfes ade
+hire selfre sunu sweoloðe befæstan,
+banfatu bærnan ond on bæl don
+eame on eaxle. Ides gnornode,
+geomrode giddum. Guðrinc astah.
+Wand to wolcnum wælfyra mæst,
+hlynode for hlawe; hafelan multon,
+bengeato burston, ðonne blod ætspranc,
+laðbite lices. Lig ealle forswealg,
+gæsta gifrost, þara ðe þær guð fornam
+bega folces; wæs hira blæd scacen.
+Gewiton him ða wigend wica neosian,
+freondum befeallen, Frysland geseon,
+hamas ond heaburh. Hengest ða gyt
+wælfagne winter wunode mid Finne
+eal unhlitme. Eard gemunde,
+þeah þe he ne meahte on mere drifan
+hringedstefnan; holm storme weol,
+won wið winde, winter yþe beleac
+isgebinde, oþðæt oþer com
+gear in geardas, swa nu gyt deð,
+þa ðe syngales sele bewitiað,
+wuldortorhtan weder. ða wæs winter scacen,
+fæger foldan bearm. Fundode wrecca,
+gist of geardum; he to gyrnwræce
+swiðor þohte þonne to sælade,
+gif he torngemot þurhteon mihte
+þæt he Eotena bearn inne gemunde.
+Swa he ne forwyrnde woroldrædenne,
+þonne him Hunlafing hildeleoman,
+billa selest, on bearm dyde,
+þæs wæron mid Eotenum ecge cuðe.
+Swylce ferhðfrecan Fin eft begeat
+sweordbealo sliðen æt his selfes ham,
+siþðan grimne gripe Guðlaf ond Oslaf
+æfter sæsiðe, sorge, mændon,
+ætwiton weana dæl; ne meahte wæfre mod
+forhabban in hreþre. ða wæs heal roden
+feonda feorum, swilce Fin slægen,
+cyning on corþre, ond seo cwen numen.
+Sceotend Scyldinga to scypon feredon
+eal ingesteald eorðcyninges,
+swylce hie æt Finnes ham findan meahton
+sigla, searogimma. Hie on sælade
+drihtlice wif to Denum feredon,
+læddon to leodum. Leoð wæs asungen,
+gleomannes gyd. Gamen eft astah,
+beorhtode bencsweg; byrelas sealdon
+win of wunderfatum. þa cwom Wealhþeo forð
+gan under gyldnum beage, þær þa godan twegen
+sæton suhtergefæderan; þa gyt wæs hiera sib ætgædere,
+æghwylc oðrum trywe. Swylce þær Unferþ þyle
+æt fotum sæt frean Scyldinga; gehwylc hiora his ferhþe treowde,
+þæt he hæfde mod micel, þeah þe he his magum nære
+arfæst æt ecga gelacum. Spræc ða ides Scyldinga:
+Onfoh þissum fulle, freodrihten min,
+sinces brytta. þu on sælum wes,
+goldwine gumena, ond to Geatum spræc
+mildum wordum, swa sceal man don.
+Beo wið Geatas glæd, geofena gemyndig,
+nean ond feorran þu nu hafast.
+Me man sægde þæt þu ðe for sunu wolde
+hererinc habban. Heorot is gefælsod,
+beahsele beorhta; bruc þenden þu mote
+manigra medo, ond þinum magum læf
+folc ond rice, þonne ðu forð scyle
+metodsceaft seon. Ic minne can
+glædne Hroþulf, þæt he þa geogoðe wile
+arum healdan, gyf þu ær þonne he,
+wine Scildinga, worold oflætest;
+wene ic þæt he mid gode gyldan wille
+uncran eaferan, gif he þæt eal gemon,
+hwæt wit to willan ond to worðmyndum
+umborwesendum ær arna gefremedon.
+Hwearf þa bi bence þær hyre byre wæron,
+Hreðric ond Hroðmund, ond hæleþa bearn,
+giogoð ætgædere; þær se goda sæt,
+Beowulf Geata, be þæm gebroðrum twæm.
+Him wæs ful boren ond freondlaþu
+wordum bewægned, ond wunden gold
+estum geeawed, earmreade twa,
+hrægl ond hringas, healsbeaga mæst
+þara þe ic on foldan gefrægen hæbbe.
+Nænigne ic under swegle selran hyrde
+hordmaððum hæleþa, syþðan Hama ætwæg
+to þære byrhtan byrig Brosinga mene,
+sigle ond sincfæt; searoniðas fleah
+Eormenrices, geceas ecne ræd.
+þone hring hæfde Higelac Geata,
+nefa Swertinges, nyhstan siðe,
+siðþan he under segne sinc ealgode,
+wælreaf werede; hyne wyrd fornam,
+syþðan he for wlenco wean ahsode,
+fæhðe to Frysum. He þa frætwe wæg,
+eorclanstanas ofer yða ful,
+rice þeoden; he under rande gecranc.
+Gehwearf þa in Francna fæþm feorh cyninges,
+breostgewædu ond se beah somod;
+wyrsan wigfrecan wæl reafedon
+æfter guðsceare, Geata leode,
+hreawic heoldon. Heal swege onfeng.
+Wealhðeo maþelode, heo fore þæm werede spræc:
+Bruc ðisses beages, Beowulf leofa,
+hyse, mid hæle, ond þisses hrægles neot,
+þeodgestreona, ond geþeoh tela,
+cen þec mid cræfte ond þyssum cnyhtum wes
+lara liðe; ic þe þæs lean geman.
+Hafast þu gefered þæt ðe feor ond neah
+ealne wideferhþ weras ehtigað,
+efne swa side swa sæ bebugeð,
+windgeard, weallas. Wes þenden þu lifige,
+æþeling, eadig. Ic þe an tela
+sincgestreona. Beo þu suna minum
+dædum gedefe, dreamhealdende.
+Her is æghwylc eorl oþrum getrywe,
+modes milde, mandrihtne hold;
+þegnas syndon geþwære, þeod ealgearo,
+druncne dryhtguman doð swa ic bidde.
+Eode þa to setle. þær wæs symbla cyst;
+druncon win weras. Wyrd ne cuþon,
+geosceaft grimme, swa hit agangen wearð
+eorla manegum, syþðan æfen cwom
+ond him Hroþgar gewat to hofe sinum,
+rice to ræste. Reced weardode
+unrim eorla, swa hie oft ær dydon.
+Bencþelu beredon; hit geondbræded wearð
+beddum ond bolstrum. Beorscealca sum
+fus ond fæge fletræste gebeag.
+Setton him to heafdon hilderandas,
+bordwudu beorhtan; þær on bence wæs
+ofer æþelinge yþgesene
+heaþosteapa helm, hringed byrne,
+þrecwudu þrymlic. Wæs þeaw hyra
+þæt hie oft wæron an wig gearwe,
+ge æt ham ge on herge, ge gehwæþer þara,
+efne swylce mæla swylce hira mandryhtne
+þearf gesælde; wæs seo þeod tilu.
+Sigon þa to slæpe. Sum sare angeald
+æfenræste, swa him ful oft gelamp,
+siþðan goldsele Grendel warode,
+unriht æfnde, oþþæt ende becwom,
+swylt æfter synnum. þæt gesyne wearþ,
+widcuþ werum, þætte wrecend þa gyt
+lifde æfter laþum, lange þrage,
+æfter guðceare. Grendles modor,
+ides, aglæcwif, yrmþe gemunde,
+se þe wæteregesan wunian scolde,
+cealde streamas, siþðan Cain wearð
+to ecgbanan angan breþer,
+fæderenmæge; he þa fag gewat,
+morþre gemearcod, mandream fleon,
+westen warode. þanon woc fela
+geosceaftgasta; wæs þæra Grendel sum,
+heorowearh hetelic, se æt Heorote fand
+wæccendne wer wiges bidan.
+þær him aglæca ætgræpe wearð;
+hwæþre he gemunde mægenes strenge,
+gimfæste gife ðe him god sealde,
+ond him to anwaldan are gelyfde,
+frofre ond fultum; ðy he þone feond ofercwom,
+gehnægde helle gast. þa he hean gewat,
+dreame bedæled, deaþwic seon,
+mancynnes feond, ond his modor þa gyt,
+gifre ond galgmod, gegan wolde
+sorhfulne sið, sunu deað wrecan.
+Com þa to Heorote, ðær Hringdene
+geond þæt sæld swæfun. þa ðær sona wearð
+edhwyrft eorlum, siþðan inne fealh
+Grendles modor. Wæs se gryre læssa
+efne swa micle swa bið mægþa cræft,
+wiggryre wifes, be wæpnedmen,
+þonne heoru bunden, hamere geþuren,
+sweord swate fah swin ofer helme
+ecgum dyhttig andweard scireð.
+þa wæs on healle heardecg togen
+sweord ofer setlum, sidrand manig
+hafen handa fæst; helm ne gemunde,
+byrnan side, þa hine se broga angeat.
+Heo wæs on ofste, wolde ut þanon,
+feore beorgan, þa heo onfunden wæs.
+Hraðe heo æþelinga anne hæfde
+fæste befangen, þa heo to fenne gang.
+Se wæs Hroþgare hæleþa leofost
+on gesiðes had be sæm tweonum,
+rice randwiga, þone ðe heo on ræste abreat,
+blædfæstne beorn. Næs Beowulf ðær,
+ac wæs oþer in ær geteohhod
+æfter maþðumgife mærum Geate.
+Hream wearð in Heorote; heo under heolfre genam
+cuþe folme; cearu wæs geniwod,
+geworden in wicun. Ne wæs þæt gewrixle til,
+þæt hie on ba healfa bicgan scoldon
+freonda feorum. þa wæs frod cyning,
+har hilderinc, on hreon mode,
+syðþan he aldorþegn unlyfigendne,
+þone deorestan deadne wisse.
+Hraþe wæs to bure Beowulf fetod,
+sigoreadig secg. Samod ærdæge
+eode eorla sum, æþele cempa
+self mid gesiðum þær se snotera bad,
+hwæþer him alwalda æfre wille
+æfter weaspelle wyrpe gefremman.
+Gang ða æfter flore fyrdwyrðe man
+mid his handscale healwudu dynede,
+þæt he þone wisan wordum nægde
+frean Ingwina, frægn gif him wære
+æfter neodlaðum niht getæse.
+Hroðgar maþelode, helm Scyldinga:
+Ne frin þu æfter sælum. Sorh is geniwod
+Denigea leodum. Dead is æschere,
+Yrmenlafes yldra broþor,
+min runwita ond min rædbora,
+eaxlgestealla, ðonne we on orlege
+hafelan weredon, þonne hniton feþan,
+eoferas cynsedan. Swylc scolde eorl wesan,
+æþeling ærgod, swylc æschere wæs.
+Wearð him on Heorote to handbanan
+wælgæst wæfre; ic ne wat hwæder
+atol æse wlanc eftsiðas teah,
+fylle gefægnod. Heo þa fæhðe wræc
+þe þu gystranniht Grendel cwealdest
+þurh hæstne had heardum clammum,
+forþan he to lange leode mine
+wanode ond wyrde. He æt wige gecrang
+ealdres scyldig, ond nu oþer cwom
+mihtig manscaða, wolde hyre mæg wrecan,
+ge feor hafað fæhðe gestæled
+(þæs þe þincean mæg þegne monegum,
+se þe æfter sincgyfan on sefan greoteþ),
+hreþerbealo hearde; nu seo hand ligeð,
+se þe eow welhwylcra wilna dohte.
+Ic þæt londbuend, leode mine,
+selerædende, secgan hyrde
+þæt hie gesawon swylce twegen
+micle mearcstapan moras healdan,
+ellorgæstas. ðæra oðer wæs,
+þæs þe hie gewislicost gewitan meahton,
+idese onlicnæs; oðer earmsceapen
+on weres wæstmum wræclastas træd,
+næfne he wæs mara þonne ænig man oðer;
+þone on geardagum Grendel nemdon
+foldbuende. No hie fæder cunnon,
+hwæþer him ænig wæs ær acenned
+dyrnra gasta. Hie dygel lond
+warigeað, wulfhleoþu, windige næssas,
+frecne fengelad, ðær fyrgenstream
+under næssa genipu niþer gewiteð,
+flod under foldan. Nis þæt feor heonon
+milgemearces þæt se mere standeð;
+ofer þæm hongiað hrinde bearwas,
+wudu wyrtum fæst wæter oferhelmað.
+þær mæg nihta gehwæm niðwundor seon,
+fyr on flode. No þæs frod leofað
+gumena bearna, þæt þone grund wite;
+ðeah þe hæðstapa hundum geswenced,
+heorot hornum trum, holtwudu sece,
+feorran geflymed, ær he feorh seleð,
+aldor on ofre, ær he in wille
+hafelan hydan. Nis þæt heoru stow!
+þonon yðgeblond up astigeð
+won to wolcnum, þonne wind styreþ,
+lað gewidru, oðþæt lyft drysmaþ,
+roderas reotað. Nu is se ræd gelang
+eft æt þe anum. Eard git ne const,
+frecne stowe, ðær þu findan miht
+felasinnigne secg; sec gif þu dyrre.
+Ic þe þa fæhðe feo leanige,
+ealdgestreonum, swa ic ær dyde,
+wundnum golde, gyf þu on weg cymest."
+Beowulf maþelode, bearn Ecgþeowes:
+"Ne sorga, snotor guma; selre bið æghwæm
+þæt he his freond wrece, þonne he fela murne.
+Ure æghwylc sceal ende gebidan
+worolde lifes; wyrce se þe mote
+domes ær deaþe; þæt bið drihtguman
+unlifgendum æfter selest.
+Aris, rices weard, uton raþe feran
+Grendles magan gang sceawigan.
+Ic hit þe gehate, no he on helm losaþ,
+ne on foldan fæþm, ne on fyrgenholt,
+ne on gyfenes grund, ga þær he wille.
+ðys dogor þu geþyld hafa
+weana gehwylces, swa ic þe wene to."
+Ahleop ða se gomela, gode þancode,
+mihtigan drihtne, þæs se man gespræc.
+þa wæs Hroðgare hors gebæted,
+wicg wundenfeax. Wisa fengel
+geatolic gende; gumfeþa stop
+lindhæbbendra. Lastas wæron
+æfter waldswaþum wide gesyne,
+gang ofer grundas, þær heo gegnum for
+ofer myrcan mor, magoþegna bær
+þone selestan sawolleasne
+þara þe mid Hroðgare ham eahtode.
+Ofereode þa æþelinga bearn
+steap stanhliðo, stige nearwe,
+enge anpaðas, uncuð gelad,
+neowle næssas, nicorhusa fela.
+He feara sum beforan gengde
+wisra monna wong sceawian,
+oþþæt he færinga fyrgenbeamas
+ofer harne stan hleonian funde,
+wynleasne wudu; wæter under stod
+dreorig ond gedrefed. Denum eallum wæs,
+winum Scyldinga, weorce on mode
+to geþolianne, ðegne monegum,
+oncyð eorla gehwæm, syðþan æscheres
+on þam holmclife hafelan metton.
+Flod blode weol (folc to sægon),
+hatan heolfre. Horn stundum song
+fuslic fyrdleoð. Feþa eal gesæt.
+Gesawon ða æfter wætere wyrmcynnes fela,
+sellice sædracan, sund cunnian,
+swylce on næshleoðum nicras licgean,
+ða on undernmæl oft bewitigað
+sorhfulne sið on seglrade,
+wyrmas ond wildeor; hie on weg hruron,
+bitere ond gebolgne, bearhtm ongeaton,
+guðhorn galan. Sumne Geata leod
+of flanbogan feores getwæfde,
+yðgewinnes, þæt him on aldre stod
+herestræl hearda; he on holme wæs
+sundes þe sænra, ðe hyne swylt fornam.
+Hræþe wearð on yðum mid eoferspreotum
+heorohocyhtum hearde genearwod,
+niða genæged, ond on næs togen,
+wundorlic wægbora; weras sceawedon
+gryrelicne gist. Gyrede hine Beowulf
+eorlgewædum, nalles for ealdre mearn.
+Scolde herebyrne hondum gebroden,
+sid ond searofah, sund cunnian,
+seo ðe bancofan beorgan cuþe,
+þæt him hildegrap hreþre ne mihte,
+eorres inwitfeng, aldre gesceþðan;
+ac se hwita helm hafelan werede,
+se þe meregrundas mengan scolde,
+secan sundgebland since geweorðad,
+befongen freawrasnum, swa hine fyrndagum
+worhte wæpna smið, wundrum teode,
+besette swinlicum, þæt hine syðþan no
+brond ne beadomecas bitan ne meahton.
+Næs þæt þonne mætost mægenfultuma
+þæt him on ðearfe lah ðyle Hroðgares;
+wæs þæm hæftmece Hrunting nama.
+þæt wæs an foran ealdgestreona;
+ecg wæs iren, atertanum fah,
+ahyrded heaþoswate; næfre hit æt hilde ne swac
+manna ængum þara þe hit mid mundum bewand,
+se ðe gryresiðas gegan dorste,
+folcstede fara; næs þæt forma sið
+þæt hit ellenweorc æfnan scolde.
+Huru ne gemunde mago Ecglafes,
+eafoþes cræftig, þæt he ær gespræc
+wine druncen, þa he þæs wæpnes onlah
+selran sweordfrecan. Selfa ne dorste
+under yða gewin aldre geneþan,
+drihtscype dreogan; þær he dome forleas,
+ellenmærðum. Ne wæs þæm oðrum swa,
+syðþan he hine to guðe gegyred hæfde.
+Beowulf maðelode, bearn Ecgþeowes:
+"Geþenc nu, se mæra maga Healfdenes,
+snottra fengel, nu ic eom siðes fus,
+goldwine gumena, hwæt wit geo spræcon,
+gif ic æt þearfe þinre scolde
+aldre linnan, þæt ðu me a wære
+forðgewitenum on fæder stæle.
+Wes þu mundbora minum magoþegnum,
+hondgesellum, gif mec hild nime;
+swylce þu ða madmas þe þu me sealdest,
+Hroðgar leofa, Higelace onsend.
+Mæg þonne on þæm golde ongitan Geata dryhten,
+geseon sunu Hrædles, þonne he on þæt sinc starað,
+þæt ic gumcystum godne funde
+beaga bryttan, breac þonne moste.
+Ond þu Unferð læt ealde lafe,
+wrætlic wægsweord, widcuðne man
+heardecg habban; ic me mid Hruntinge
+dom gewyrce, oþðe mec deað nimeð."
+æfter þæm wordum Wedergeata leod
+efste mid elne, nalas ondsware
+bidan wolde; brimwylm onfeng
+hilderince. ða wæs hwil dæges
+ær he þone grundwong ongytan mehte.
+Sona þæt onfunde se ðe floda begong
+heorogifre beheold hund missera,
+grim ond grædig, þæt þær gumena sum
+ælwihta eard ufan cunnode.
+Grap þa togeanes, guðrinc gefeng
+atolan clommum. No þy ær in gescod
+halan lice; hring utan ymbbearh,
+þæt heo þone fyrdhom ðurhfon ne mihte,
+locene leoðosyrcan laþan fingrum.
+Bær þa seo brimwylf, þa heo to botme com,
+hringa þengel to hofe sinum,
+swa he ne mihte, no he þæs modig wæs,
+wæpna gewealdan, ac hine wundra þæs fela
+swencte on sunde, sædeor monig
+hildetuxum heresyrcan bræc,
+ehton aglæcan. ða se eorl ongeat
+þæt he in niðsele nathwylcum wæs,
+þær him nænig wæter wihte ne sceþede,
+ne him for hrofsele hrinan ne mehte
+færgripe flodes; fyrleoht geseah,
+blacne leoman, beorhte scinan.
+Ongeat þa se goda grundwyrgenne,
+merewif mihtig; mægenræs forgeaf
+hildebille, hond sweng ne ofteah,
+þæt hire on hafelan hringmæl agol
+grædig guðleoð. ða se gist onfand
+þæt se beadoleoma bitan nolde,
+aldre sceþðan, ac seo ecg geswac
+ðeodne æt þearfe; ðolode ær fela
+hondgemota, helm oft gescær,
+fæges fyrdhrægl; ða wæs forma sið
+deorum madme, þæt his dom alæg.
+Eft wæs anræd, nalas elnes læt,
+mærða gemyndig mæg Hylaces.
+Wearp ða wundenmæl wrættum gebunden
+yrre oretta, þæt hit on eorðan læg,
+stið ond stylecg; strenge getruwode,
+mundgripe mægenes. Swa sceal man don,
+þonne he æt guðe gegan þenceð
+longsumne lof, na ymb his lif cearað.
+Gefeng þa be eaxle (nalas for fæhðe mearn)
+Guðgeata leod Grendles modor;
+brægd þa beadwe heard, þa he gebolgen wæs,
+feorhgeniðlan, þæt heo on flet gebeah.
+Heo him eft hraþe andlean forgeald
+grimman grapum ond him togeanes feng;
+oferwearp þa werigmod wigena strengest,
+feþecempa, þæt he on fylle wearð.
+Ofsæt þa þone selegyst ond hyre seax geteah,
+brad ond brunecg, wolde hire bearn wrecan,
+angan eaferan. Him on eaxle læg
+breostnet broden; þæt gebearh feore,
+wið ord ond wið ecge ingang forstod.
+Hæfde ða forsiðod sunu Ecgþeowes
+under gynne grund, Geata cempa,
+nemne him heaðobyrne helpe gefremede,
+herenet hearde, ond halig god
+geweold wigsigor; witig drihten,
+rodera rædend, hit on ryht gesced
+yðelice, syþðan he eft astod.
+Geseah ða on searwum sigeeadig bil,
+eald sweord eotenisc, ecgum þyhtig,
+wigena weorðmynd; þæt wæs wæpna cyst,
+buton hit wæs mare ðonne ænig mon oðer
+to beadulace ætberan meahte,
+god ond geatolic, giganta geweorc.
+He gefeng þa fetelhilt, freca Scyldinga
+hreoh ond heorogrim hringmæl gebrægd,
+aldres orwena, yrringa sloh,
+þæt hire wið halse heard grapode,
+banhringas bræc. Bil eal ðurhwod
+fægne flæschoman; heo on flet gecrong.
+Sweord wæs swatig, secg weorce gefeh.
+Lixte se leoma, leoht inne stod,
+efne swa of hefene hadre scineð
+rodores candel. He æfter recede wlat;
+hwearf þa be wealle, wæpen hafenade
+heard be hiltum Higelaces ðegn,
+yrre ond anræd. Næs seo ecg fracod
+hilderince, ac he hraþe wolde
+Grendle forgyldan guðræsa fela
+ðara þe he geworhte to Westdenum
+oftor micle ðonne on ænne sið,
+þonne he Hroðgares heorðgeneatas
+sloh on sweofote, slæpende fræt
+folces Denigea fyftyne men
+ond oðer swylc ut offerede,
+laðlicu lac. He him þæs lean forgeald,
+reþe cempa, to ðæs þe he on ræste geseah
+guðwerigne Grendel licgan
+aldorleasne, swa him ær gescod
+hild æt Heorote. Hra wide sprong,
+syþðan he æfter deaðe drepe þrowade,
+heorosweng heardne, ond hine þa heafde becearf.
+Sona þæt gesawon snottre ceorlas,
+þa ðe mid Hroðgare on holm wliton,
+þæt wæs yðgeblond eal gemenged,
+brim blode fah. Blondenfeaxe,
+gomele ymb godne, ongeador spræcon
+þæt hig þæs æðelinges eft ne wendon
+þæt he sigehreðig secean come
+mærne þeoden; þa ðæs monige gewearð
+þæt hine seo brimwylf abroten hæfde.
+ða com non dæges. Næs ofgeafon
+hwate Scyldingas; gewat him ham þonon
+goldwine gumena. Gistas setan
+modes seoce ond on mere staredon,
+wiston ond ne wendon þæt hie heora winedrihten
+selfne gesawon. þa þæt sweord ongan
+æfter heaþoswate hildegicelum,
+wigbil wanian. þæt wæs wundra sum,
+þæt hit eal gemealt ise gelicost,
+ðonne forstes bend fæder onlæteð,
+onwindeð wælrapas, se geweald hafað
+sæla ond mæla; þæt is soð metod.
+Ne nom he in þæm wicum, Wedergeata leod,
+maðmæhta ma, þeh he þær monige geseah,
+buton þone hafelan ond þa hilt somod
+since fage. Sweord ær gemealt,
+forbarn brodenmæl; wæs þæt blod to þæs hat,
+ættren ellorgæst se þær inne swealt.
+Sona wæs on sunde se þe ær æt sæcce gebad
+wighryre wraðra, wæter up þurhdeaf.
+Wæron yðgebland eal gefælsod,
+eacne eardas, þa se ellorgast
+oflet lifdagas ond þas lænan gesceaft.
+Com þa to lande lidmanna helm
+swiðmod swymman; sælace gefeah,
+mægenbyrþenne þara þe he him mid hæfde.
+Eodon him þa togeanes, gode þancodon,
+ðryðlic þegna heap, þeodnes gefegon,
+þæs þe hi hyne gesundne geseon moston.
+ða wæs of þæm hroran helm ond byrne
+lungre alysed. Lagu drusade,
+wæter under wolcnum, wældreore fag.
+Ferdon forð þonon feþelastum
+ferhþum fægne, foldweg mæton,
+cuþe stræte. Cyningbalde men
+from þæm holmclife hafelan bæron
+earfoðlice heora æghwæþrum,
+felamodigra; feower scoldon
+on þæm wælstenge weorcum geferian
+to þæm goldsele Grendles heafod,
+oþðæt semninga to sele comon
+frome fyrdhwate feowertyne
+Geata gongan; gumdryhten mid
+modig on gemonge meodowongas træd.
+ða com in gan ealdor ðegna,
+dædcene mon dome gewurþad,
+hæle hildedeor, Hroðgar gretan.
+þa wæs be feaxe on flet boren
+Grendles heafod, þær guman druncon,
+egeslic for eorlum ond þære idese mid,
+wliteseon wrætlic; weras on sawon.
+Beowulf maþelode, bearn Ecgþeowes:
+"Hwæt! we þe þas sælac, sunu Healfdenes,
+leod Scyldinga, lustum brohton
+tires to tacne, þe þu her to locast.
+Ic þæt unsofte ealdre gedigde
+wigge under wætere, weorc geneþde
+earfoðlice; ætrihte wæs
+guð getwæfed, nymðe mec god scylde.
+Ne meahte ic æt hilde mid Hruntinge
+wiht gewyrcan, þeah þæt wæpen duge;
+ac me geuðe ylda waldend
+þæt ic on wage geseah wlitig hangian
+eald sweord eacen (oftost wisode
+winigea leasum), þæt ic ðy wæpne gebræd.
+Ofsloh ða æt þære sæcce, þa me sæl ageald,
+huses hyrdas. þa þæt hildebil
+forbarn brogdenmæl, swa þæt blod gesprang,
+hatost heaþoswata. Ic þæt hilt þanan
+feondum ætferede, fyrendæda wræc,
+deaðcwealm Denigea, swa hit gedefe wæs.
+Ic hit þe þonne gehate, þæt þu on Heorote most
+sorhleas swefan mid þinra secga gedryht
+ond þegna gehwylc þinra leoda,
+duguðe ond iogoþe, þæt þu him ondrædan ne þearft,
+þeoden Scyldinga, on þa healfe,
+aldorbealu eorlum, swa þu ær dydest."
+ða wæs gylden hilt gamelum rince,
+harum hildfruman, on hand gyfen,
+enta ærgeweorc; hit on æht gehwearf
+æfter deofla hryre Denigea frean,
+wundorsmiþa geweorc, ond þa þas worold ofgeaf
+gromheort guma, godes ondsaca,
+morðres scyldig, ond his modor eac,
+on geweald gehwearf woroldcyninga
+ðæm selestan be sæm tweonum
+ðara þe on Scedenigge sceattas dælde.
+Hroðgar maðelode, hylt sceawode,
+ealde lafe, on ðæm wæs or writen
+fyrngewinnes, syðþan flod ofsloh,
+gifen geotende, giganta cyn
+(frecne geferdon); þæt wæs fremde þeod
+ecean dryhtne; him þæs endelean
+þurh wæteres wylm waldend sealde.
+Swa wæs on ðæm scennum sciran goldes
+þurh runstafas rihte gemearcod,
+geseted ond gesæd hwam þæt sweord geworht,
+irena cyst, ærest wære,
+wreoþenhilt ond wyrmfah. ða se wisa spræc
+sunu Healfdenes (swigedon ealle):
+"þæt, la, mæg secgan se þe soð ond riht
+fremeð on folce, feor eal gemon,
+eald OEweard, þæt ðes eorl wære
+geboren betera! Blæd is aræred
+geond widwegas, wine min Beowulf,
+ðin ofer þeoda gehwylce. Eal þu hit geþyldum healdest,
+mægen mid modes snyttrum. Ic þe sceal mine gelæstan
+freode, swa wit furðum spræcon. ðu scealt to frofre weorþan
+eal langtwidig leodum þinum,
+hæleðum to helpe. Ne wearð Heremod swa
+eaforum Ecgwelan, Arscyldingum;
+ne geweox he him to willan, ac to wælfealle
+ond to deaðcwalum Deniga leodum;
+breat bolgenmod beodgeneatas,
+eaxlgesteallan, oþþæt he ana hwearf,
+mære þeoden, mondreamum from.
+ðeah þe hine mihtig god mægenes wynnum,
+eafeþum stepte, ofer ealle men
+forð gefremede, hwæþere him on ferhþe greow
+breosthord blodreow. Nallas beagas geaf
+Denum æfter dome; dreamleas gebad
+þæt he þæs gewinnes weorc þrowade,
+leodbealo longsum. ðu þe lær be þon,
+gumcyste ongit; ic þis gid be þe
+awræc wintrum frod. Wundor is to secganne
+hu mihtig god manna cynne
+þurh sidne sefan snyttru bryttað,
+eard ond eorlscipe; he ah ealra geweald.
+Hwilum he on lufan læteð hworfan
+monnes modgeþonc mæran cynnes,
+seleð him on eþle eorþan wynne
+to healdanne, hleoburh wera,
+gedeð him swa gewealdene worolde dælas,
+side rice, þæt he his selfa ne mæg
+for his unsnyttrum ende geþencean.
+Wunað he on wiste; no hine wiht dweleð
+adl ne yldo, ne him inwitsorh
+on sefan sweorceð, ne gesacu ohwær
+ecghete eoweð, ac him eal worold
+wendeð on willan (he þæt wyrse ne con),
+oðþæt him on innan oferhygda dæl
+weaxeð ond wridað. þonne se weard swefeð,
+sawele hyrde; bið se slæp to fæst,
+bisgum gebunden, bona swiðe neah,
+se þe of flanbogan fyrenum sceoteð.
+þonne bið on hreþre under helm drepen
+biteran stræle (him bebeorgan ne con),
+wom wundorbebodum wergan gastes;
+þinceð him to lytel þæt he lange heold,
+gytsað gromhydig, nallas on gylp seleð
+fædde beagas, ond he þa forðgesceaft
+forgyteð ond forgymeð, þæs þe him ær god sealde,
+wuldres waldend, weorðmynda dæl.
+Hit on endestæf eft gelimpeð
+þæt se lichoma læne gedreoseð,
+fæge gefealleð; fehð oþer to,
+se þe unmurnlice madmas dæleþ,
+eorles ærgestreon, egesan ne gymeð.
+Bebeorh þe ðone bealonið, Beowulf leofa,
+secg betsta, ond þe þæt selre geceos,
+ece rædas; oferhyda ne gym,
+mære cempa. Nu is þines mægnes blæd
+ane hwile. Eft sona bið
+þæt þec adl oððe ecg eafoþes getwæfeð,
+oððe fyres feng, oððe flodes wylm,
+oððe gripe meces, oððe gares fliht,
+oððe atol yldo; oððe eagena bearhtm
+forsiteð ond forsworceð; semninga bið
+þæt ðec, dryhtguma, deað oferswyðeð.
+Swa ic Hringdena hund missera
+weold under wolcnum ond hig wigge beleac
+manigum mægþa geond þysne middangeard,
+æscum ond ecgum, þæt ic me ænigne
+under swegles begong gesacan ne tealde.
+Hwæt, me þæs on eþle edwenden cwom,
+gyrn æfter gomene, seoþðan Grendel wearð,
+ealdgewinna, ingenga min;
+ic þære socne singales wæg
+modceare micle. þæs sig metode þanc,
+ecean dryhtne, þæs ðe ic on aldre gebad
+þæt ic on þone hafelan heorodreorigne
+ofer ealdgewin eagum starige!
+Ga nu to setle, symbelwynne dreoh
+wigge weorþad; unc sceal worn fela
+maþma gemænra, siþðan morgen bið."
+Geat wæs glædmod, geong sona to
+setles neosan, swa se snottra heht.
+þa wæs eft swa ær ellenrofum
+fletsittendum fægere gereorded
+niowan stefne. Nihthelm geswearc
+deorc ofer dryhtgumum. Duguð eal aras.
+Wolde blondenfeax beddes neosan,
+gamela Scylding. Geat unigmetes wel,
+rofne randwigan, restan lyste;
+sona him seleþegn siðes wergum,
+feorrancundum, forð wisade,
+se for andrysnum ealle beweotede
+þegnes þearfe, swylce þy dogore
+heaþoliðende habban scoldon.
+Reste hine þa rumheort; reced hliuade
+geap ond goldfah; gæst inne swæf
+oþþæt hrefn blaca heofones wynne
+bliðheort bodode. ða com beorht scacan
+scaþan onetton,
+wæron æþelingas eft to leodum
+fuse to farenne; wolde feor þanon
+cuma collenferhð ceoles neosan.
+Heht þa se hearda Hrunting beran
+sunu Ecglafes, heht his sweord niman,
+leoflic iren; sægde him þæs leanes þanc,
+cwæð, he þone guðwine godne tealde,
+wigcræftigne, nales wordum log
+meces ecge; þæt wæs modig secg.
+Ond þa siðfrome, searwum gearwe
+wigend wæron; eode weorð Denum
+æþeling to yppan, þær se oþer wæs,
+hæle hildedeor Hroðgar grette.
+Beowulf maþelode, bearn Ecgþeowes:
+"Nu we sæliðend secgan wyllað,
+feorran cumene, þæt we fundiaþ
+Higelac secan. Wæron her tela
+willum bewenede; þu us wel dohtest.
+Gif ic þonne on eorþan owihte mæg
+þinre modlufan maran tilian,
+gumena dryhten, ðonne ic gyt dyde,
+guðgeweorca, ic beo gearo sona.
+Gif ic þæt gefricge ofer floda begang,
+þæt þec ymbsittend egesan þywað,
+swa þec hetende hwilum dydon,
+ic ðe þusenda þegna bringe,
+hæleþa to helpe. Ic on Higelac wat,
+Geata dryhten, þeah ðe he geong sy,
+folces hyrde, þæt he mec fremman wile
+wordum ond worcum, þæt ic þe wel herige
+ond þe to geoce garholt bere,
+mægenes fultum, þær ðe bið manna þearf.
+Gif him þonne Hreþric to hofum Geata
+geþingeð, þeodnes bearn, he mæg þær fela
+freonda findan; feorcyþðe beoð
+selran gesohte þæm þe him selfa deah."
+Hroðgar maþelode him on ondsware:
+"þe þa wordcwydas wigtig drihten
+on sefan sende; ne hyrde ic snotorlicor
+on swa geongum feore guman þingian.
+þu eart mægenes strang ond on mode frod,
+wis wordcwida. Wen ic talige,
+gif þæt gegangeð, þæt ðe gar nymeð,
+hild heorugrimme, Hreþles eaferan,
+adl oþðe iren ealdor ðinne,
+folces hyrde, ond þu þin feorh hafast,
+þæt þe Sægeatas selran næbben
+to geceosenne cyning ænigne,
+hordweard hæleþa, gyf þu healdan wylt
+maga rice. Me þin modsefa
+licað leng swa wel, leofa Beowulf.
+Hafast þu gefered þæt þam folcum sceal,
+Geata leodum ond Gardenum,
+sib gemæne, ond sacu restan,
+inwitniþas, þe hie ær drugon,
+wesan, þenden ic wealde widan rices,
+maþmas gemæne, manig oþerne
+godum gegretan ofer ganotes bæð;
+sceal hringnaca ofer heafu bringan
+lac ond luftacen. Ic þa leode wat
+ge wið feond ge wið freond fæste geworhte,
+æghwæs untæle ealde wisan."
+ða git him eorla hleo inne gesealde,
+mago Healfdenes, maþmas [XII];
+het hine mid þæm lacum leode swæse
+secean on gesyntum, snude eft cuman.
+Gecyste þa cyning æþelum god,
+þeoden Scyldinga, ðegn betstan
+ond be healse genam; hruron him tearas,
+blondenfeaxum. Him wæs bega wen,
+ealdum infrodum, oþres swiðor,
+þæt hie seoððan no geseon moston,
+modige on meþle. Wæs him se man to þon leof
+þæt he þone breostwylm forberan ne mehte,
+ac him on hreþre hygebendum fæst
+æfter deorum men dyrne langað
+beorn wið blode. Him Beowulf þanan,
+guðrinc goldwlanc, græsmoldan træd
+since hremig; sægenga bad
+agendfrean, se þe on ancre rad.
+þa wæs on gange gifu Hroðgares
+oft geæhted; þæt wæs an cyning,
+æghwæs orleahtre, oþþæt hine yldo benam
+mægenes wynnum, se þe oft manegum scod.
+Cwom þa to flode felamodigra,
+hægstealdra heap, hringnet bæron,
+locene leoðosyrcan. Landweard onfand
+eftsið eorla, swa he ær dyde;
+no he mid hearme of hliðes nosan
+gæstas grette, ac him togeanes rad,
+cwæð þæt wilcuman Wedera leodum
+scaþan scirhame to scipe foron.
+þa wæs on sande sægeap naca
+hladen herewædum, hringedstefna,
+mearum ond maðmum; mæst hlifade
+ofer Hroðgares hordgestreonum.
+He þæm batwearde bunden golde
+swurd gesealde, þæt he syðþan wæs
+on meodubence maþme þy weorþra,
+yrfelafe. Gewat him on naca
+drefan deop wæter, Dena land ofgeaf.
+þa wæs be mæste merehrægla sum,
+segl sale fæst; sundwudu þunede.
+No þær wegflotan wind ofer yðum
+siðes getwæfde; sægenga for,
+fleat famigheals forð ofer yðe,
+bundenstefna ofer brimstreamas,
+þæt hie Geata clifu ongitan meahton,
+cuþe næssas. Ceol up geþrang
+lyftgeswenced, on lande stod.
+Hraþe wæs æt holme hyðweard geara,
+se þe ær lange tid leofra manna
+fus æt faroðe feor wlatode;
+sælde to sande sidfæþme scip,
+oncerbendum fæst, þy læs hym yþa ðrym
+wudu wynsuman forwrecan meahte.
+Het þa up beran æþelinga gestreon,
+frætwe ond fætgold; næs him feor þanon
+to gesecanne sinces bryttan,
+Higelac Hreþling, þær æt ham wunað
+selfa mid gesiðum sæwealle neah.
+Bold wæs betlic, bregorof cyning,
+heah in healle, Hygd swiðe geong,
+wis, welþungen, þeah ðe wintra lyt
+under burhlocan gebiden hæbbe,
+Hæreþes dohtor; næs hio hnah swa þeah,
+ne to gneað gifa Geata leodum,
+maþmgestreona. Mod þryðo wæg,
+fremu folces cwen, firen ondrysne.
+Nænig þæt dorste deor geneþan
+swæsra gesiða, nefne sinfrea,
+þæt hire an dæges eagum starede,
+ac him wælbende weotode tealde
+handgewriþene; hraþe seoþðan wæs
+æfter mundgripe mece geþinged,
+þæt hit sceadenmæl scyran moste,
+cwealmbealu cyðan. Ne bið swylc cwenlic þeaw
+idese to efnanne, þeah ðe hio ænlicu sy,
+þætte freoðuwebbe feores onsæce
+æfter ligetorne leofne mannan.
+Huru þæt onhohsnode Hemminges mæg;
+ealodrincende oðer sædan,
+þæt hio leodbealewa læs gefremede,
+inwitniða, syððan ærest wearð
+gyfen goldhroden geongum cempan,
+æðelum diore, syððan hio Offan flet
+ofer fealone flod be fæder lare
+siðe gesohte; ðær hio syððan well
+in gumstole, gode, mære,
+lifgesceafta lifigende breac,
+hiold heahlufan wið hæleþa brego,
+ealles moncynnes mine gefræge
+þone selestan bi sæm tweonum,
+eormencynnes. Forðam Offa wæs
+geofum ond guðum, garcene man,
+wide geweorðod, wisdome heold
+eðel sinne; þonon Eomer woc
+hæleðum to helpe, Hemminges mæg,
+nefa Garmundes, niða cræftig.
+Gewat him ða se hearda mid his hondscole
+sylf æfter sande sæwong tredan,
+wide waroðas. Woruldcandel scan,
+sigel suðan fus. Hi sið drugon,
+elne geeodon, to ðæs ðe eorla hleo,
+bonan Ongenþeoes burgum in innan,
+geongne guðcyning godne gefrunon
+hringas dælan. Higelace wæs
+sið Beowulfes snude gecyðed,
+þæt ðær on worðig wigendra hleo,
+lindgestealla, lifigende cwom,
+heaðolaces hal to hofe gongan.
+Hraðe wæs gerymed, swa se rica bebead,
+feðegestum flet innanweard.
+Gesæt þa wið sylfne se ða sæcce genæs,
+mæg wið mæge, syððan mandryhten
+þurh hleoðorcwyde holdne gegrette,
+meaglum wordum. Meoduscencum hwearf
+geond þæt healreced Hæreðes dohtor,
+lufode ða leode, liðwæge bær
+hæleðum to handa. Higelac ongan
+sinne geseldan in sele þam hean
+fægre fricgcean (hyne fyrwet bræc,
+hwylce Sægeata siðas wæron):
+"Hu lomp eow on lade, leofa Biowulf,
+þa ðu færinga feorr gehogodest
+sæcce secean ofer sealt wæter,
+hilde to Hiorote? Ac ðu Hroðgare
+widcuðne wean wihte gebettest,
+mærum ðeodne? Ic ðæs modceare
+sorhwylmum seað, siðe ne truwode
+leofes mannes; ic ðe lange bæd
+þæt ðu þone wælgæst wihte ne grette,
+lete Suðdene sylfe geweorðan
+guðe wið Grendel. Gode ic þanc secge
+þæs ðe ic ðe gesundne geseon moste."
+Biowulf maðelode, bearn Ecgðioes:
+"þæt is undyrne, dryhten Higelac,
+micel gemeting, monegum fira,
+hwylc orleghwil uncer Grendles
+wearð on ðam wange, þær he worna fela
+Sigescyldingum sorge gefremede,
+yrmðe to aldre. Ic ðæt eall gewræc,
+swa begylpan ne þearf Grendeles maga
+ænig ofer eorðan uhthlem þone,
+se ðe lengest leofað laðan cynnes,
+facne bifongen. Ic ðær furðum cwom
+to ðam hringsele Hroðgar gretan;
+sona me se mæra mago Healfdenes,
+syððan he modsefan minne cuðe,
+wið his sylfes sunu setl getæhte.
+Weorod wæs on wynne; ne seah ic widan feorh
+under heofones hwealf healsittendra
+medudream maran. Hwilum mæru cwen,
+friðusibb folca, flet eall geondhwearf,
+bædde byre geonge; oft hio beahwriðan
+secge sealde, ær hie to setle geong.
+Hwilum for duguðe dohtor Hroðgares
+eorlum on ende ealuwæge bær;
+þa ic Freaware fletsittende
+nemnan hyrde, þær hio nægled sinc
+hæleðum sealde. Sio gehaten is,
+geong, goldhroden, gladum suna Frodan;
+hafað þæs geworden wine Scyldinga,
+rices hyrde, ond þæt ræd talað,
+þæt he mid ðy wife wælfæhða dæl,
+sæcca gesette. Oft seldan hwær
+æfter leodhryre lytle hwile
+bongar bugeð, þeah seo bryd duge!
+Mæg þæs þonne ofþyncan ðeodne Heaðobeardna
+ond þegna gehwam þara leoda,
+þonne he mid fæmnan on flett gæð,
+dryhtbearn Dena, duguða biwenede;
+on him gladiað gomelra lafe,
+heard ond hringmæl Heaðabeardna gestreon
+þenden hie ðam wæpnum wealdan moston,
+oððæt hie forlæddan to ðam lindplegan
+swæse gesiðas ond hyra sylfra feorh.
+þonne cwið æt beore se ðe beah gesyhð,
+eald æscwiga, se ðe eall geman,
+garcwealm gumena (him bið grim sefa),
+onginneð geomormod geongum cempan
+þurh hreðra gehygd higes cunnian,
+wigbealu weccean, ond þæt word acwyð:
+'Meaht ðu, min wine, mece gecnawan
+þone þin fæder to gefeohte bær
+under heregriman hindeman siðe,
+dyre iren, þær hyne Dene slogon,
+weoldon wælstowe, syððan Wiðergyld læg,
+æfter hæleþa hryre, hwate Scyldungas?
+Nu her þara banena byre nathwylces
+frætwum hremig on flet gæð,
+morðres gylpeð, ond þone maðþum byreð,
+þone þe ðu mid rihte rædan sceoldest.'
+Manað swa ond myndgað mæla gehwylce
+sarum wordum, oððæt sæl cymeð
+þæt se fæmnan þegn fore fæder dædum
+æfter billes bite blodfag swefeð,
+ealdres scyldig; him se oðer þonan
+losað lifigende, con him land geare.
+þonne bioð abrocene on ba healfe
+aðsweord eorla; syððan Ingelde
+weallað wælniðas, ond him wiflufan
+æfter cearwælmum colran weorðað.
+þy ic Heaðobeardna hyldo ne telge,
+dryhtsibbe dæl Denum unfæcne,
+freondscipe fæstne. Ic sceal forð sprecan
+gen ymbe Grendel, þæt ðu geare cunne,
+sinces brytta, to hwan syððan wearð
+hondræs hæleða. Syððan heofones gim
+glad ofer grundas, gæst yrre cwom,
+eatol, æfengrom, user neosan,
+ðær we gesunde sæl weardodon.
+þær wæs Hondscio hild onsæge,
+feorhbealu fægum; he fyrmest læg,
+gyrded cempa; him Grendel wearð,
+mærum maguþegne to muðbonan,
+leofes mannes lic eall forswealg.
+No ðy ær ut ða gen idelhende
+bona blodigtoð, bealewa gemyndig,
+of ðam goldsele gongan wolde,
+ac he mægnes rof min costode,
+grapode gearofolm. Glof hangode
+sid ond syllic, searobendum fæst;
+sio wæs orðoncum eall gegyrwed
+deofles cræftum ond dracan fellum.
+He mec þær on innan unsynnigne,
+dior dædfruma, gedon wolde
+manigra sumne; hyt ne mihte swa,
+syððan ic on yrre uppriht astod.
+To lang ys to reccenne hu ic ðam leodsceaðan
+yfla gehwylces ondlean forgeald;
+þær ic, þeoden min, þine leode
+weorðode weorcum. He on weg losade,
+lytle hwile lifwynna breac;
+hwæþre him sio swiðre swaðe weardade
+hand on Hiorte, ond he hean ðonan
+modes geomor meregrund gefeoll.
+Me þone wælræs wine Scildunga
+fættan golde fela leanode,
+manegum maðmum, syððan mergen com
+ond we to symble geseten hæfdon.
+þær wæs gidd ond gleo. Gomela Scilding,
+felafricgende, feorran rehte;
+hwilum hildedeor hearpan wynne,
+gomenwudu grette, hwilum gyd awræc
+soð ond sarlic, hwilum syllic spell
+rehte æfter rihte rumheort cyning.
+Hwilum eft ongan, eldo gebunden,
+gomel guðwiga gioguðe cwiðan,
+hildestrengo; hreðer inne weoll,
+þonne he wintrum frod worn gemunde.
+Swa we þær inne ondlangne dæg
+niode naman, oððæt niht becwom
+oðer to yldum. þa wæs eft hraðe
+gearo gyrnwræce Grendeles modor,
+siðode sorhfull; sunu deað fornam,
+wighete Wedra. Wif unhyre
+hyre bearn gewræc, beorn acwealde
+ellenlice; þær wæs æschere,
+frodan fyrnwitan, feorh uðgenge.
+Noðer hy hine ne moston, syððan mergen cwom,
+deaðwerigne, Denia leode,
+bronde forbærnan, ne on bęl hladan
+leofne mannan; hio þæt lic ætbær
+feondes fæðmum under firgenstream.
+þæt wæs Hroðgare hreowa tornost
+þara þe leodfruman lange begeate.
+þa se ðeoden mec ðine life
+healsode hreohmod, þæt ic on holma geþring
+eorlscipe efnde, ealdre geneðde,
+mærðo fremede; he me mede gehet.
+Ic ða ðæs wælmes, þe is wide cuð,
+grimne gryrelicne grundhyrde fond;
+þær unc hwile wæs hand gemæne,
+holm heolfre weoll, ond ic heafde becearf
+in ðam guðsele Grendeles modor
+eacnum ecgum, unsofte þonan
+feorh oðferede. Næs ic fæge þa gyt,
+ac me eorla hleo eft gesealde
+maðma menigeo, maga Healfdenes.
+Swa se ðeodkyning þeawum lyfde.
+Nealles ic ðam leanum forloren hæfde,
+mægnes mede, ac he me maðmas geaf,
+sunu Healfdenes, on minne sylfes dom;
+ða ic ðe, beorncyning, bringan wylle,
+estum geywan. Gen is eall æt ðe
+lissa gelong; ic lyt hafo
+heafodmaga nefne, Hygelac, ðec."
+Het ða in beran eaforheafodsegn,
+heaðosteapne helm, hare byrnan,
+guðsweord geatolic, gyd æfter wræc:
+"Me ðis hildesceorp Hroðgar sealde,
+snotra fengel, sume worde het
+þæt ic his ærest ðe est gesægde;
+cwæð þæt hyt hæfde Hiorogar cyning,
+leod Scyldunga lange hwile;
+no ðy ær suna sinum syllan wolde,
+hwatum Heorowearde, þeah he him hold wære,
+breostgewædu. Bruc ealles well!"
+Hyrde ic þæt þam frætwum feower mearas
+lungre, gelice, last weardode,
+æppelfealuwe; he him est geteah
+meara ond maðma. Swa sceal mæg don,
+nealles inwitnet oðrum bregdon
+dyrnum cræfte, deað renian
+hondgesteallan. Hygelace wæs,
+niða heardum, nefa swyðe hold,
+ond gehwæðer oðrum hroþra gemyndig.
+Hyrde ic þæt he ðone healsbeah Hygde gesealde,
+wrætlicne wundurmaððum, ðone þe him Wealhðeo geaf,
+ðeodnes dohtor, þrio wicg somod
+swancor ond sadolbeorht; hyre syððan wæs
+æfter beahðege breost geweorðod.
+Swa bealdode bearn Ecgðeowes,
+guma guðum cuð, godum dædum,
+dreah æfter dome, nealles druncne slog
+heorðgeneatas; næs him hreoh sefa,
+ac he mancynnes mæste cræfte
+ginfæstan gife, þe him god sealde,
+heold hildedeor. Hean wæs lange,
+swa hyne Geata bearn godne ne tealdon,
+ne hyne on medobence micles wyrðne
+drihten Wedera gedon wolde;
+swyðe wendon þæt he sleac wære,
+æðeling unfrom. Edwenden cwom
+tireadigum menn torna gehwylces.
+Het ða eorla hleo in gefetian,
+heaðorof cyning, Hreðles lafe
+golde gegyrede; næs mid Geatum ða
+sincmaðþum selra on sweordes had;
+þæt he on Biowulfes bearm alegde
+ond him gesealde seofan þusendo,
+bold ond bregostol. Him wæs bam samod
+on ðam leodscipe lond gecynde,
+eard, eðelriht, oðrum swiðor
+side rice þam ðær selra wæs.
+Eft þæt geiode ufaran dogrum
+hildehlæmmum, syððan Hygelac læg
+ond Heardrede hildemeceas
+under bordhreoðan to bonan wurdon,
+ða hyne gesohtan on sigeþeode
+hearde hildefrecan, Heaðoscilfingas,
+niða genægdan nefan Hererices,
+syððan Beowulfe brade rice
+on hand gehwearf; he geheold tela
+fiftig wintra (wæs ða frod cyning,
+eald eþelweard), oððæt an ongan
+deorcum nihtum draca ricsian,
+se ðe on heaum hofe hord beweotode,
+stanbeorh steapne; stig under læg,
+eldum uncuð. þær on innan giong
+niða nathwylc, se ðe neh gefeng
+hæðnum horde, hond [...],
+since fahne. He þæt syððan [...],
+þeah ðe he slæpende besyred wurde
+þeofes cræfte; þæt sie ðiod onfand,
+bufolc beorna, þæt he gebolgen wæs.
+Nealles mid gewealdum wyrmhord abræc
+sylfes willum, se ðe him sare gesceod,
+ac for þreanedlan þeow nathwylces
+hæleða bearna heteswengeas fleah,
+ærnes þearfa, ond ðær inne fealh,
+secg synbysig, sona onfunde
+þæt þær ðam gyste gryrebroga stod;
+hwæðre earmsceapen
+sceapen
+þa hyne se fær begeat.
+Sincfæt [...]; þær wæs swylcra fela
+in ðam eorðhuse ærgestreona,
+swa hy on geardagum gumena nathwylc,
+eormenlafe æþelan cynnes,
+þanchycgende þær gehydde,
+deore maðmas. Ealle hie deað fornam
+ærran mælum, ond se an ða gen
+leoda duguðe, se ðær lengest hwearf,
+weard winegeomor, wende þæs ylcan,
+þæt he lytel fæc longgestreona
+brucan moste. Beorh eallgearo
+wunode on wonge wæteryðum neah,
+niwe be næsse, nearocræftum fæst.
+þær on innan bær eorlgestreona
+hringa hyrde hordwyrðne dæl,
+fættan goldes, fea worda cwæð:
+"Heald þu nu, hruse, nu hæleð ne moston,
+eorla æhte! Hwæt, hyt ær on ðe
+gode begeaton. Guðdeað fornam,
+feorhbealo frecne, fyra gehwylcne
+leoda minra, þara ðe þis lif ofgeaf,
+gesawon seledream. Ic nah hwa sweord wege
+oððe feormie fæted wæge,
+dryncfæt deore; duguð ellor sceoc.
+Sceal se hearda helm hyrsted golde
+fætum befeallen; feormynd swefað,
+þa ðe beadogriman bywan sceoldon,
+ge swylce seo herepad, sio æt hilde gebad
+ofer borda gebræc bite irena,
+brosnað æfter beorne. Ne mæg byrnan hring
+æfter wigfruman wide feran,
+hæleðum be healfe. Næs hearpan wyn,
+gomen gleobeames, ne god hafoc
+geond sæl swingeð, ne se swifta mearh
+burhstede beateð. Bealocwealm hafað
+fela feorhcynna forð onsended!"
+Swa giomormod giohðo mænde
+an æfter eallum, unbliðe hwearf
+dæges ond nihtes, oððæt deaðes wylm
+hran æt heortan. Hordwynne fond
+eald uhtsceaða opene standan,
+se ðe byrnende biorgas seceð,
+nacod niðdraca, nihtes fleogeð
+fyre befangen; hyne foldbuend
+swiðe ondrædað. He gesecean sceall
+hord on hrusan, þær he hæðen gold
+warað wintrum frod, ne byð him wihte ðy sel.
+Swa se ðeodsceaða þreo hund wintra
+heold on hrusan hordærna sum,
+eacencræftig, oððæt hyne an abealch
+mon on mode; mandryhtne bær
+fæted wæge, frioðowære bæd
+hlaford sinne. ða wæs hord rasod,
+onboren beaga hord, bene getiðad
+feasceaftum men. Frea sceawode
+fira fyrngeweorc forman siðe.
+þa se wyrm onwoc, wroht wæs geniwad;
+stonc ða æfter stane, stearcheort onfand
+feondes fotlast; he to forð gestop
+dyrnan cræfte dracan heafde neah.
+Swa mæg unfæge eaðe gedigan
+wean ond wræcsið, se ðe waldendes
+hyldo gehealdeþ! Hordweard sohte
+georne æfter grunde, wolde guman findan,
+þone þe him on sweofote sare geteode,
+hat ond hreohmod hlæw oft ymbehwearf
+ealne utanweardne, ne ðær ænig mon
+on þære westenne; hwæðre wiges gefeh,
+beaduwe weorces, hwilum on beorh æthwearf,
+sincfæt sohte. He þæt sona onfand
+ðæt hæfde gumena sum goldes gefandod,
+heahgestreona. Hordweard onbad
+earfoðlice oððæt æfen cwom;
+wæs ða gebolgen beorges hyrde,
+wolde se laða lige forgyldan
+drincfæt dyre. þa wæs dæg sceacen
+wyrme on willan; no on wealle læg,
+bidan wolde, ac mid bæle for,
+fyre gefysed. Wæs se fruma egeslic
+leodum on lande, swa hyt lungre wearð
+on hyra sincgifan sare geendod.
+ða se gæst ongan gledum spiwan,
+beorht hofu bærnan; bryneleoma stod
+eldum on andan. No ðær aht cwices
+lað lyftfloga læfan wolde.
+Wæs þæs wyrmes wig wide gesyne,
+nearofages nið nean ond feorran,
+hu se guðsceaða Geata leode
+hatode ond hynde; hord eft gesceat,
+dryhtsele dyrnne, ær dæges hwile.
+Hæfde landwara lige befangen,
+bæle ond bronde, beorges getruwode,
+wiges ond wealles; him seo wen geleah.
+þa wæs Biowulfe broga gecyðed
+snude to soðe, þæt his sylfes ham,
+bolda selest, brynewylmum mealt,
+gifstol Geata. þæt ðam godan wæs
+hreow on hreðre, hygesorga mæst;
+wende se wisa þæt he wealdende
+ofer ealde riht, ecean dryhtne,
+bitre gebulge. Breost innan weoll
+þeostrum geþoncum, swa him geþywe ne wæs.
+Hæfde ligdraca leoda fæsten,
+ealond utan, eorðweard ðone
+gledum forgrunden; him ðæs guðkyning,
+Wedera þioden, wræce leornode.
+Heht him þa gewyrcean wigendra hleo
+eallirenne, eorla dryhten,
+wigbord wrætlic; wisse he gearwe
+þæt him holtwudu helpan ne meahte,
+lind wið lige. Sceolde lændaga
+æþeling ærgod ende gebidan,
+worulde lifes, ond se wyrm somod,
+þeah ðe hordwelan heolde lange.
+Oferhogode ða hringa fengel
+þæt he þone widflogan weorode gesohte,
+sidan herge; no he him þa sæcce ondred,
+ne him þæs wyrmes wig for wiht dyde,
+eafoð ond ellen, forðon he ær fela
+nearo neðende niða gedigde,
+hildehlemma, syððan he Hroðgares,
+sigoreadig secg, sele fælsode
+ond æt guðe forgrap Grendeles mægum
+laðan cynnes. No þæt læsest wæs
+hondgemota, þær mon Hygelac sloh,
+syððan Geata cyning guðe ræsum,
+freawine folca Freslondum on,
+Hreðles eafora hiorodryncum swealt,
+bille gebeaten. þonan Biowulf com
+sylfes cræfte, sundnytte dreah;
+hæfde him on earme ana [XXX]
+hildegeatwa, þa he to holme beag.
+Nealles Hetware hremge þorfton
+feðewiges, þe him foran ongean
+linde bæron; lyt eft becwom
+fram þam hildfrecan hames niosan.
+Oferswam ða sioleða bigong sunu Ecgðeowes,
+earm anhaga, eft to leodum;
+þær him Hygd gebead hord ond rice,
+beagas ond bregostol, bearne ne truwode
+þæt he wið ælfylcum eþelstolas
+healdan cuðe, ða wæs Hygelac dead.
+No ðy ær feasceafte findan meahton
+æt ðam æðelinge ænige ðinga,
+þæt he Heardrede hlaford wære
+oððe þone cynedom ciosan wolde;
+hwæðre he him on folce freondlarum heold,
+estum mid are, oððæt he yldra wearð,
+Wedergeatum weold. Hyne wræcmæcgas
+ofer sæ sohtan, suna Ohteres;
+hæfdon hy forhealden helm Scylfinga,
+þone selestan sæcyninga
+þara ðe in Swiorice sinc brytnade,
+mærne þeoden. Him þæt to mearce wearð;
+he þær for feorme feorhwunde hleat
+sweordes swengum, sunu Hygelaces,
+ond him eft gewat Ongenðioes bearn
+hames niosan, syððan Heardred læg,
+let ðone bregostol Biowulf healdan,
+Geatum wealdan. þæt wæs god cyning!
+Se ðæs leodhryres lean gemunde
+uferan dogrum, Eadgilse wearð
+feasceaftum freond, folce gestepte
+ofer sæ side sunu Ohteres,
+wigum ond wæpnum; he gewræc syððan
+cealdum cearsiðum, cyning ealdre bineat.
+Swa he niða gehwane genesen hæfde,
+sliðra geslyhta, sunu Ecgðiowes,
+ellenweorca, oð ðone anne dæg
+þe he wið þam wyrme gewegan sceolde.
+Gewat þa [XII]a sum torne gebolgen
+dryhten Geata dracan sceawian.
+Hæfde þa gefrunen hwanan sio fæhð aras,
+bealonið biorna; him to bearme cwom
+maðþumfæt mære þurh ðæs meldan hond.
+Se wæs on ðam ðreate þreotteoða secg,
+se ðæs orleges or onstealde,
+hæft hygegiomor, sceolde hean ðonon
+wong wisian. He ofer willan giong
+to ðæs ðe he eorðsele anne wisse,
+hlæw under hrusan holmwylme neh,
+yðgewinne; se wæs innan full
+wrætta ond wira. Weard unhiore,
+gearo guðfreca, goldmaðmas heold,
+eald under eorðan. Næs þæt yðe ceap
+to gegangenne gumena ænigum!
+Gesæt ða on næsse niðheard cyning,
+þenden hælo abead heorðgeneatum,
+goldwine Geata. Him wæs geomor sefa,
+wæfre ond wælfus, wyrd ungemete neah,
+se ðone gomelan gretan sceolde,
+secean sawle hord, sundur gedælan
+lif wið lice, no þon lange wæs
+feorh æþelinges flæsce bewunden.
+Biowulf maþelade, bearn Ecgðeowes:
+"Fela ic on giogoðe guðræsa genæs,
+orleghwila; ic þæt eall gemon.
+Ic wæs syfanwintre, þa mec sinca baldor,
+freawine folca, æt minum fæder genam;
+heold mec ond hæfde Hreðel cyning,
+geaf me sinc ond symbel, sibbe gemunde.
+Næs ic him to life laðra owihte,
+beorn in burgum, þonne his bearna hwylc,
+Herebeald ond Hæðcyn oððe Hygelac min.
+Wæs þam yldestan ungedefelice
+mæges dædum morþorbed stred,
+syððan hyne Hæðcyn of hornbogan,
+his freawine, flane geswencte,
+miste mercelses ond his mæg ofscet,
+broðor oðerne blodigan gare.
+þæt wæs feohleas gefeoht, fyrenum gesyngad,
+hreðre hygemeðe; sceolde hwæðre swa þeah
+æðeling unwrecen ealdres linnan.
+Swa bið geomorlic gomelum ceorle
+to gebidanne, þæt his byre ride
+giong on galgan, þonne he gyd wrece,
+sarigne sang, þonne his sunu hangað
+hrefne to hroðre, ond he him helpe ne mæg,
+eald ond infrod, ænige gefremman.
+Symble bið gemyndgad morna gehwylce
+eaforan ellorsið; oðres ne gymeð
+to gebidanne burgum in innan
+yrfeweardas, þonne se an hafað
+þurh deaðes nyd dæda gefondad.
+Gesyhð sorhcearig on his suna bure
+winsele westne, windge reste
+reote berofene. Ridend swefað,
+hæleð in hoðman; nis þær hearpan sweg,
+gomen in geardum, swylce ðær iu wæron.
+Gewiteð þonne on sealman, sorhleoð gæleð
+an æfter anum; þuhte him eall to rum,
+wongas ond wicstede. Swa Wedra helm
+æfter Herebealde heortan sorge
+weallende wæg. Wihte ne meahte
+on ðam feorhbonan fæghðe gebetan;
+no ðy ær he þone heaðorinc hatian ne meahte
+laðum dædum, þeah him leof ne wæs.
+He ða mid þære sorhge, þe him swa sar belamp,
+gumdream ofgeaf, godes leoht geceas,
+eaferum læfde, swa deð eadig mon,
+lond ond leodbyrig, þa he of life gewat.
+þa wæs synn ond sacu Sweona ond Geata
+ofer wid wæter, wroht gemæne,
+herenið hearda, syððan Hreðel swealt,
+oððe him Ongenðeowes eaferan wæran
+frome, fyrdhwate, freode ne woldon
+ofer heafo healdan, ac ymb Hreosnabeorh
+eatolne inwitscear oft gefremedon.
+þæt mægwine mine gewræcan,
+fæhðe ond fyrene, swa hyt gefræge wæs,
+þeah ðe oðer his ealdre gebohte,
+heardan ceape; Hæðcynne wearð,
+Geata dryhtne, guð onsæge.
+þa ic on morgne gefrægn mæg oðerne
+billes ecgum on bonan stælan,
+þær Ongenþeow Eofores niosað.
+Guðhelm toglad, gomela Scylfing
+hreas hildeblac; hond gemunde
+fæhðo genoge, feorhsweng ne ofteah.
+Ic him þa maðmas, þe he me sealde,
+geald æt guðe, swa me gifeðe wæs,
+leohtan sweorde; he me lond forgeaf,
+eard, eðelwyn. Næs him ænig þearf
+þæt he to Gifðum oððe to Gardenum
+oððe in Swiorice secean þurfe
+wyrsan wigfrecan, weorðe gecypan.
+Symle ic him on feðan beforan wolde,
+ana on orde, ond swa to aldre sceall
+sæcce fremman, þenden þis sweord þolað,
+þæt mec ær ond sið oft gelæste.
+Syððan ic for dugeðum Dæghrefne wearð
+to handbonan, Huga cempan;
+nalles he ða frætwe Frescyninge,
+breostweorðunge, bringan moste,
+ac in compe gecrong cumbles hyrde,
+æþeling on elne; ne wæs ecg bona,
+ac him hildegrap heortan wylmas,
+banhus gebræc. Nu sceall billes ecg,
+hond ond heard sweord, ymb hord wigan."
+Beowulf maðelode, beotwordum spræc
+niehstan siðe: "Ic geneðde fela
+guða on geogoðe; gyt ic wylle,
+frod folces weard, fæhðe secan,
+mærðu fremman, gif mec se mansceaða
+of eorðsele ut geseceð."
+Gegrette ða gumena gehwylcne,
+hwate helmberend, hindeman siðe,
+swæse gesiðas: "Nolde ic sweord beran,
+wæpen to wyrme, gif ic wiste hu
+wið ðam aglæcean elles meahte
+gylpe wiðgripan, swa ic gio wið Grendle dyde.
+Ac ic ðær heaðufyres hates wene,
+oreðes ond attres; forðon ic me on hafu
+bord ond byrnan. Nelle ic beorges weard
+forfleon fotes trem, ac unc furður sceal
+weorðan æt wealle, swa unc wyrd geteoð,
+metod manna gehwæs. Ic eom on mode from
+þæt ic wið þone guðflogan gylp ofersitte.
+Gebide ge on beorge byrnum werede,
+secgas on searwum, hwæðer sel mæge
+æfter wælræse wunde gedygan
+uncer twega. Nis þæt eower sið
+ne gemet mannes, nefne min anes,
+þæt he wið aglæcean eofoðo dæle,
+eorlscype efne. Ic mid elne sceall
+gold gegangan, oððe guð nimeð,
+feorhbealu frecne, frean eowerne!"
+Aras ða bi ronde rof oretta,
+heard under helme, hiorosercean bær
+under stancleofu, strengo getruwode
+anes mannes. Ne bið swylc earges sið!
+Geseah ða be wealle se ðe worna fela,
+gumcystum god, guða gedigde,
+hildehlemma, þonne hnitan feðan,
+stondan stanbogan, stream ut þonan
+brecan of beorge. Wæs þære burnan wælm
+heaðofyrum hat; ne meahte horde neah
+unbyrnende ænige hwile
+deop gedygan for dracan lege.
+Let ða of breostum, ða he gebolgen wæs,
+Wedergeata leod word ut faran,
+stearcheort styrmde; stefn in becom
+heaðotorht hlynnan under harne stan.
+Hete wæs onhrered, hordweard oncniow
+mannes reorde; næs ðær mara fyrst
+freode to friclan. From ærest cwom
+oruð aglæcean ut of stane,
+hat hildeswat. Hruse dynede.
+Biorn under beorge bordrand onswaf
+wið ðam gryregieste, Geata dryhten;
+ða wæs hringbogan heorte gefysed
+sæcce to seceanne. Sweord ær gebræd
+god guðcyning, gomele lafe,
+ecgum unslaw; æghwæðrum wæs
+bealohycgendra broga fram oðrum.
+Stiðmod gestod wið steapne rond
+winia bealdor, ða se wyrm gebeah
+snude tosomne; he on searwum bad.
+Gewat ða byrnende gebogen scriðan,
+to gescipe scyndan. Scyld wel gebearg
+life ond lice læssan hwile
+mærum þeodne þonne his myne sohte,
+ðær he þy fyrste, forman dogore
+wealdan moste swa him wyrd ne gescraf
+hreð æt hilde. Hond up abræd
+Geata dryhten, gryrefahne sloh
+incgelafe, þæt sio ecg gewac
+brun on bane, bat unswiðor
+þonne his ðiodcyning þearfe hæfde,
+bysigum gebæded. þa wæs beorges weard
+æfter heaðuswenge on hreoum mode,
+wearp wælfyre; wide sprungon
+hildeleoman. Hreðsigora ne gealp
+goldwine Geata; guðbill geswac,
+nacod æt niðe, swa hyt no sceolde,
+iren ærgod. Ne wæs þæt eðe sið,
+þæt se mæra maga Ecgðeowes
+grundwong þone ofgyfan wolde;
+sceolde ofer willan wic eardian
+elles hwergen, swa sceal æghwylc mon
+alætan lændagas. Næs ða long to ðon
+þæt ða aglæcean hy eft gemetton.
+Hyrte hyne hordweard (hreðer æðme weoll)
+niwan stefne; nearo ðrowode,
+fyre befongen, se ðe ær folce weold.
+Nealles him on heape handgesteallan,
+æðelinga bearn, ymbe gestodon
+hildecystum, ac hy on holt bugon,
+ealdre burgan. Hiora in anum weoll
+sefa wið sorgum; sibb æfre ne mæg
+wiht onwendan þam ðe wel þenceð.
+Wiglaf wæs haten Weoxstanes sunu,
+leoflic lindwiga, leod Scylfinga,
+mæg ælfheres; geseah his mondryhten
+under heregriman hat þrowian.
+Gemunde ða ða are þe he him ær forgeaf,
+wicstede weligne Wægmundinga,
+folcrihta gehwylc, swa his fæder ahte.
+Ne mihte ða forhabban; hond rond gefeng,
+geolwe linde, gomel swyrd geteah,
+þæt wæs mid eldum Eanmundes laf,
+suna Ohteres. þam æt sæcce wearð,
+wræccan wineleasum, Weohstan bana
+meces ecgum, ond his magum ætbær
+brunfagne helm, hringde byrnan,
+eald sweord etonisc; þæt him Onela forgeaf,
+his gædelinges guðgewædu,
+fyrdsearo fuslic, no ymbe ða fæhðe spræc,
+þeah ðe he his broðor bearn abredwade.
+He frætwe geheold fela missera,
+bill ond byrnan, oððæt his byre mihte
+eorlscipe efnan swa his ærfæder;
+geaf him ða mid Geatum guðgewæda,
+æghwæs unrim, þa he of ealdre gewat,
+frod on forðweg. þa wæs forma sið
+geongan cempan, þæt he guðe ræs
+mid his freodryhtne fremman sceolde.
+Ne gemealt him se modsefa, ne his mæges laf
+gewac æt wige; þæt se wyrm onfand,
+syððan hie togædre gegan hæfdon.
+Wiglaf maðelode, wordrihta fela
+sægde gesiðum (him wæs sefa geomor):
+"Ic ðæt mæl geman, þær we medu þegun,
+þonne we geheton ussum hlaforde
+in biorsele, ðe us ðas beagas geaf,
+þæt we him ða guðgetawa gyldan woldon
+gif him þyslicu þearf gelumpe,
+helmas ond heard sweord. ðe he usic on herge geceas
+to ðyssum siðfate sylfes willum,
+onmunde usic mærða, ond me þas maðmas geaf,
+þe he usic garwigend gode tealde,
+hwate helmberend, þeah ðe hlaford us
+þis ellenweorc ana aðohte
+to gefremmanne, folces hyrde,
+for ðam he manna mæst mærða gefremede,
+dæda dollicra. Nu is se dæg cumen
+þæt ure mandryhten mægenes behofað,
+godra guðrinca; wutun gongan to,
+helpan hildfruman, þenden hyt sy,
+gledegesa grim. God wat on mec
+þæt me is micle leofre þæt minne lichaman
+mid minne goldgyfan gled fæðmie.
+Ne þynceð me gerysne þæt we rondas beren
+eft to earde, nemne we æror mægen
+fane gefyllan, feorh ealgian
+Wedra ðeodnes. Ic wat geare
+þæt næron ealdgewyrht, þæt he ana scyle
+Geata duguðe gnorn þrowian,
+gesigan æt sæcce; urum sceal sweord ond helm,
+byrne ond beaduscrud, bam gemæne."
+Wod þa þurh þone wælrec, wigheafolan bær
+frean on fultum, fea worda cwæð:
+"Leofa Biowulf, læst eall tela,
+swa ðu on geoguðfeore geara gecwæde
+þæt ðu ne alæte be ðe lifigendum
+dom gedreosan. Scealt nu dædum rof,
+æðeling anhydig, ealle mægene
+feorh ealgian; ic ðe fullæstu."
+æfter ðam wordum wyrm yrre cwom,
+atol inwitgæst, oðre siðe
+fyrwylmum fah fionda niosian,
+laðra manna; ligyðum for.
+Born bord wið rond, byrne ne meahte
+geongum garwigan geoce gefremman,
+ac se maga geonga under his mæges scyld
+elne geeode, þa his agen wæs
+gledum forgrunden. þa gen guðcyning
+mærða gemunde, mægenstrengo sloh
+hildebille, þæt hyt on heafolan stod
+niþe genyded; Nægling forbærst,
+geswac æt sæcce sweord Biowulfes,
+gomol ond grægmæl. Him þæt gifeðe ne wæs
+þæt him irenna ecge mihton
+helpan æt hilde; wæs sio hond to strong,
+se ðe meca gehwane, mine gefræge,
+swenge ofersohte, þonne he to sæcce bær
+wæpen wundrum heard; næs him wihte ðe sel.
+þa wæs þeodsceaða þriddan siðe,
+frecne fyrdraca, fæhða gemyndig,
+ræsde on ðone rofan, þa him rum ageald,
+hat ond heaðogrim, heals ealne ymbefeng
+biteran banum; he geblodegod wearð
+sawuldriore, swat yðum weoll.
+ða ic æt þearfe gefrægn þeodcyninges
+andlongne eorl ellen cyðan,
+cræft ond cenðu, swa him gecynde wæs.
+Ne hedde he þæs heafolan, ac sio hand gebarn
+modiges mannes, þær he his mæges healp,
+þæt he þone niðgæst nioðor hwene sloh,
+secg on searwum, þæt ðæt sweord gedeaf,
+fah ond fæted, þæt ðæt fyr ongon
+sweðrian syððan. þa gen sylf cyning
+geweold his gewitte, wællseaxe gebræd
+biter ond beaduscearp, þæt he on byrnan wæg;
+forwrat Wedra helm wyrm on middan.
+Feond gefyldan (ferh ellen wræc),
+ond hi hyne þa begen abroten hæfdon,
+sibæðelingas. Swylc sceolde secg wesan,
+þegn æt ðearfe! þæt ðam þeodne wæs
+siðast sigehwila sylfes dædum,
+worlde geweorces. ða sio wund ongon,
+þe him se eorðdraca ær geworhte,
+swelan ond swellan; he þæt sona onfand,
+þæt him on breostum bealoniðe weoll
+attor on innan. ða se æðeling giong
+þæt he bi wealle wishycgende
+gesæt on sesse; seah on enta geweorc,
+hu ða stanbogan stapulum fæste
+ece eorðreced innan healde.
+Hyne þa mid handa heorodreorigne,
+þeoden mærne, þegn ungemete till
+winedryhten his wætere gelafede,
+hilde sædne, ond his helm onspeon.
+Biowulf maþelode (he ofer benne spræc,
+wunde wælbleate; wisse he gearwe
+þæt he dæghwila gedrogen hæfde,
+eorðan wynne; ða wæs eall sceacen
+dogorgerimes, deað ungemete neah):
+"Nu ic suna minum syllan wolde
+guðgewædu, þær me gifeðe swa
+ænig yrfeweard æfter wurde
+lice gelenge. Ic ðas leode heold
+fiftig wintra; næs se folccyning,
+ymbesittendra ænig ðara,
+þe mec guðwinum gretan dorste,
+egesan ðeon. Ic on earde bad
+mælgesceafta, heold min tela,
+ne sohte searoniðas, ne me swor fela
+aða on unriht. Ic ðæs ealles mæg
+feorhbennum seoc gefean habban;
+for ðam me witan ne ðearf waldend fira
+morðorbealo maga, þonne min sceaceð
+lif of lice. Nu ðu lungre geong
+hord sceawian under harne stan,
+Wiglaf leofa, nu se wyrm ligeð,
+swefeð sare wund, since bereafod.
+Bio nu on ofoste, þæt ic ærwelan,
+goldæht ongite, gearo sceawige
+swegle searogimmas, þæt ic ðy seft mæge
+æfter maððumwelan min alætan
+lif ond leodscipe, þone ic longe heold."
+ða ic snude gefrægn sunu Wihstanes
+æfter wordcwydum wundum dryhtne
+hyran heaðosiocum, hringnet beran,
+brogdne beadusercean under beorges hrof.
+Geseah ða sigehreðig, þa he bi sesse geong,
+magoþegn modig maððumsigla fealo,
+gold glitinian grunde getenge,
+wundur on wealle, ond þæs wyrmes denn,
+ealdes uhtflogan, orcas stondan,
+fyrnmanna fatu feormendlease,
+hyrstum behrorene; þær wæs helm monig
+eald ond omig, earmbeaga fela
+searwum gesæled. Sinc eaðe mæg,
+gold on grunde, gumcynnes gehwone
+oferhigian, hyde se ðe wylle.
+Swylce he siomian geseah segn eallgylden
+heah ofer horde, hondwundra mæst,
+gelocen leoðocræftum; of ðam leoma stod,
+þæt he þone grundwong ongitan meahte,
+wræte giondwlitan. Næs ðæs wyrmes þær
+onsyn ænig, ac hyne ecg fornam.
+ða ic on hlæwe gefrægn hord reafian,
+eald enta geweorc, anne mannan,
+him on bearm hladon bunan ond discas
+sylfes dome; segn eac genom,
+beacna beorhtost. Bill ær gescod
+(ecg wæs iren) ealdhlafordes
+þam ðara maðma mundbora wæs
+longe hwile, ligegesan wæg
+hatne for horde, hioroweallende
+middelnihtum, oðþæt he morðre swealt.
+Ar wæs on ofoste, eftsiðes georn,
+frætwum gefyrðred; hyne fyrwet bræc,
+hwæðer collenferð cwicne gemette
+in ðam wongstede Wedra þeoden
+ellensiocne, þær he hine ær forlet.
+He ða mid þam maðmum mærne þioden,
+dryhten sinne, driorigne fand
+ealdres æt ende; he hine eft ongon
+wæteres weorpan, oðþæt wordes ord
+breosthord þurhbræc.
+gomel on giohðe (gold sceawode):
+"Ic ðara frætwa frean ealles ðanc,
+wuldurcyninge, wordum secge,
+ecum dryhtne, þe ic her on starie,
+þæs ðe ic moste minum leodum
+ær swyltdæge swylc gestrynan.
+Nu ic on maðma hord mine bebohte
+frode feorhlege, fremmað gena
+leoda þearfe; ne mæg ic her leng wesan.
+Hatað heaðomære hlæw gewyrcean
+beorhtne æfter bæle æt brimes nosan;
+se scel to gemyndum minum leodum
+heah hlifian on Hronesnæsse,
+þæt hit sæliðend syððan hatan
+Biowulfes biorh, ða ðe brentingas
+ofer floda genipu feorran drifað."
+Dyde him of healse hring gyldenne
+þioden þristhydig, þegne gesealde,
+geongum garwigan, goldfahne helm,
+beah ond byrnan, het hyne brucan well:
+"þu eart endelaf usses cynnes,
+Wægmundinga. Ealle wyrd forsweop
+mine magas to metodsceafte,
+eorlas on elne; ic him æfter sceal."
+þæt wæs þam gomelan gingæste word
+breostgehygdum, ær he bæl cure,
+hate heaðowylmas; him of hreðre gewat
+sawol secean soðfæstra dom.
+ða wæs gegongen guman unfrodum
+earfoðlice, þæt he on eorðan geseah
+þone leofestan lifes æt ende
+bleate gebæran. Bona swylce læg,
+egeslic eorðdraca ealdre bereafod,
+bealwe gebæded. Beahhordum leng
+wyrm wohbogen wealdan ne moste,
+ac hine irenna ecga fornamon,
+hearde, heaðoscearde homera lafe,
+þæt se widfloga wundum stille
+hreas on hrusan hordærne neah.
+Nalles æfter lyfte lacende hwearf
+middelnihtum, maðmæhta wlonc
+ansyn ywde, ac he eorðan gefeoll
+for ðæs hildfruman hondgeweorce.
+Huru þæt on lande lyt manna ðah,
+mægenagendra, mine gefræge,
+þeah ðe he dæda gehwæs dyrstig wære,
+þæt he wið attorsceaðan oreðe geræsde,
+oððe hringsele hondum styrede,
+gif he wæccende weard onfunde
+buon on beorge. Biowulfe wearð
+dryhtmaðma dæl deaðe forgolden;
+hæfde æghwæðer ende gefered
+lænan lifes. Næs ða lang to ðon
+þæt ða hildlatan holt ofgefan,
+tydre treowlogan tyne ætsomne.
+ða ne dorston ær dareðum lacan
+on hyra mandryhtnes miclan þearfe,
+ac hy scamiende scyldas bæran,
+guðgewædu, þær se gomela læg,
+wlitan on Wilaf. He gewergad sæt,
+feðecempa, frean eaxlum neah,
+wehte hyne wætre; him wiht ne speow.
+Ne meahte he on eorðan, ðeah he uðe wel,
+on ðam frumgare feorh gehealdan,
+ne ðæs wealdendes wiht oncirran;
+wolde dom godes dædum rædan
+gumena gehwylcum, swa he nu gen deð.
+þa wæs æt ðam geongan grim ondswaru
+eðbegete þam ðe ær his elne forleas.
+Wiglaf maðelode, Weohstanes sunu,
+sec, sarigferð (seah on unleofe):
+"þæt, la, mæg secgan se ðe wyle soð specan
+þæt se mondryhten se eow ða maðmas geaf,
+eoredgeatwe, þe ge þær on standað,
+þonne he on ealubence oft gesealde
+healsittendum helm ond byrnan,
+þeoden his þegnum, swylce he þrydlicost
+ower feor oððe neah findan meahte,
+þæt he genunga guðgewædu
+wraðe forwurpe, ða hyne wig beget.
+Nealles folccyning fyrdgesteallum
+gylpan þorfte; hwæðre him god uðe,
+sigora waldend, þæt he hyne sylfne gewræc
+ana mid ecge, þa him wæs elnes þearf.
+Ic him lifwraðe lytle meahte
+ætgifan æt guðe, ond ongan swa þeah
+ofer min gemet mæges helpan;
+symle wæs þy sæmra, þonne ic sweorde drep
+ferhðgeniðlan, fyr unswiðor
+weoll of gewitte. Wergendra to lyt
+þrong ymbe þeoden, þa hyne sio þrag becwom.
+Nu sceal sincþego ond swyrdgifu,
+eall eðelwyn eowrum cynne,
+lufen alicgean; londrihtes mot
+þære mægburge monna æghwylc
+idel hweorfan, syððan æðelingas
+feorran gefricgean fleam eowerne,
+domleasan dæd. Deað bið sella
+eorla gehwylcum þonne edwitlif!"
+Heht ða þæt heaðoweorc to hagan biodan
+up ofer ecgclif, þær þæt eorlweorod
+morgenlongne dæg modgiomor sæt,
+bordhæbbende, bega on wenum,
+endedogores ond eftcymes
+leofes monnes. Lyt swigode
+niwra spella se ðe næs gerad,
+ac he soðlice sægde ofer ealle:
+"Nu is wilgeofa Wedra leoda,
+dryhten Geata, deaðbedde fæst,
+wunað wælreste wyrmes dædum.
+Him on efn ligeð ealdorgewinna
+sexbennum seoc; sweorde ne meahte
+on ðam aglæcean ænige þinga
+wunde gewyrcean. Wiglaf siteð
+ofer Biowulfe, byre Wihstanes,
+eorl ofer oðrum unlifigendum,
+healdeð higemæðum heafodwearde
+leofes ond laðes. Nu ys leodum wen
+orleghwile, syððan underne
+Froncum ond Frysum fyll cyninges
+wide weorðeð. Wæs sio wroht scepen
+heard wið Hugas, syððan Higelac cwom
+faran flotherge on Fresna land,
+þær hyne Hetware hilde genægdon,
+elne geeodon mid ofermægene,
+þæt se byrnwiga bugan sceolde,
+feoll on feðan, nalles frætwe geaf
+ealdor dugoðe. Us wæs a syððan
+Merewioingas milts ungyfeðe.
+Ne ic to Sweoðeode sibbe oððe treowe
+wihte ne wene, ac wæs wide cuð
+þætte Ongenðio ealdre besnyðede
+Hæðcen Hreþling wið Hrefnawudu,
+þa for onmedlan ærest gesohton
+Geata leode Guðscilfingas.
+Sona him se froda fæder Ohtheres,
+eald ond egesfull, ondslyht ageaf,
+abreot brimwisan, bryd ahredde,
+gomela iomeowlan golde berofene,
+Onelan modor ond Ohtheres,
+ond ða folgode feorhgeniðlan,
+oððæt hi oðeodon earfoðlice
+in Hrefnesholt hlafordlease.
+Besæt ða sinherge sweorda lafe,
+wundum werge, wean oft gehet
+earmre teohhe ondlonge niht,
+cwæð, he on mergenne meces ecgum
+getan wolde, sum on galgtreowum
+fuglum to gamene. Frofor eft gelamp
+sarigmodum somod ærdæge,
+syððan hie Hygelaces horn ond byman,
+gealdor ongeaton, þa se goda com
+leoda dugoðe on last faran.
+Wæs sio swatswaðu Sweona ond Geata,
+wælræs weora wide gesyne,
+hu ða folc mid him fæhðe towehton.
+Gewat him ða se goda mid his gædelingum,
+frod, felageomor, fæsten secean,
+eorl Ongenþio, ufor oncirde;
+hæfde Higelaces hilde gefrunen,
+wlonces wigcræft, wiðres ne truwode,
+þæt he sæmannum onsacan mihte,
+heaðoliðendum hord forstandan,
+bearn ond bryde; beah eft þonan
+eald under eorðweall. þa wæs æht boden
+Sweona leodum, segn Higelaces
+freoðowong þone forð ofereodon,
+syððan Hreðlingas to hagan þrungon.
+þær wearð Ongenðiow ecgum sweorda,
+blondenfexa, on bid wrecen,
+þæt se þeodcyning ðafian sceolde
+Eafores anne dom. Hyne yrringa
+Wulf Wonreding wæpne geræhte,
+þæt him for swenge swat ædrum sprong
+forð under fexe. Næs he forht swa ðeh,
+gomela Scilfing, ac forgeald hraðe
+wyrsan wrixle wælhlem þone,
+syððan ðeodcyning þyder oncirde.
+Ne meahte se snella sunu Wonredes
+ealdum ceorle ondslyht giofan,
+ac he him on heafde helm ær gescer,
+þæt he blode fah bugan sceolde,
+feoll on foldan; næs he fæge þa git,
+ac he hyne gewyrpte, þeah ðe him wund hrine.
+Let se hearda Higelaces þegn
+bradne mece, þa his broðor læg,
+eald sweord eotonisc, entiscne helm
+brecan ofer bordweal; ða gebeah cyning,
+folces hyrde, wæs in feorh dropen.
+ða wæron monige þe his mæg wriðon,
+ricone arærdon, ða him gerymed wearð
+þæt hie wælstowe wealdan moston.
+þenden reafode rinc oðerne,
+nam on Ongenðio irenbyrnan,
+heard swyrd hilted ond his helm somod,
+hares hyrste Higelace bær.
+He ðam frætwum feng ond him fægre gehet
+leana mid leodum, ond gelæste swa;
+geald þone guðræs Geata dryhten,
+Hreðles eafora, þa he to ham becom,
+Iofore ond Wulfe mid ofermaðmum,
+sealde hiora gehwæðrum hund þusenda
+landes ond locenra beaga (ne ðorfte him ða lean oðwitan
+mon on middangearde), syððan hie ða mærða geslogon,
+ond ða Iofore forgeaf angan dohtor,
+hamweorðunge, hyldo to wedde.
+þæt ys sio fæhðo ond se feondscipe,
+wælnið wera, ðæs ðe ic wen hafo,
+þe us seceað to Sweona leoda,
+syððan hie gefricgeað frean userne
+ealdorleasne, þone ðe ær geheold
+wið hettendum hord ond rice
+æfter hæleða hryre, hwate Scildingas,
+folcred fremede oððe furður gen
+eorlscipe efnde. Nu is ofost betost
+þæt we þeodcyning þær sceawian
+ond þone gebringan, þe us beagas geaf,
+on adfære. Ne scel anes hwæt
+meltan mid þam modigan, ac þær is maðma hord,
+gold unrime grimme geceapod,
+ond nu æt siðestan sylfes feore
+beagas gebohte. þa sceall brond fretan,
+æled þeccean, nalles eorl wegan
+maððum to gemyndum, ne mægð scyne
+habban on healse hringweorðunge,
+ac sceal geomormod, golde bereafod,
+oft nalles æne elland tredan,
+nu se herewisa hleahtor alegde,
+gamen ond gleodream. Forðon sceall gar wesan
+monig, morgenceald, mundum bewunden,
+hæfen on handa, nalles hearpan sweg
+wigend weccean, ac se wonna hrefn
+fus ofer fægum fela reordian,
+earne secgan hu him æt æte speow,
+þenden he wið wulf wæl reafode."
+Swa se secg hwata secggende wæs
+laðra spella; he ne leag fela
+wyrda ne worda. Weorod eall aras;
+eodon unbliðe under Earnanæs,
+wollenteare wundur sceawian.
+Fundon ða on sande sawulleasne
+hlimbed healdan þone þe him hringas geaf
+ærran mælum; þa wæs endedæg
+godum gegongen, þæt se guðcyning,
+Wedra þeoden, wundordeaðe swealt.
+ær hi þær gesegan syllicran wiht,
+wyrm on wonge wiðerræhtes þær
+laðne licgean; wæs se legdraca
+grimlic, gryrefah, gledum beswæled.
+Se wæs fiftiges fotgemearces
+lang on legere, lyftwynne heold
+nihtes hwilum, nyðer eft gewat
+dennes niosian; wæs ða deaðe fæst,
+hæfde eorðscrafa ende genyttod.
+Him big stodan bunan ond orcas,
+discas lagon ond dyre swyrd,
+omige, þurhetone, swa hie wið eorðan fæðm
+þusend wintra þær eardodon.
+þonne wæs þæt yrfe, eacencræftig,
+iumonna gold galdre bewunden,
+þæt ðam hringsele hrinan ne moste
+gumena ænig, nefne god sylfa,
+sigora soðcyning, sealde þam ðe he wolde
+(he is manna gehyld) hord openian,
+efne swa hwylcum manna swa him gemet ðuhte.
+þa wæs gesyne þæt se sið ne ðah
+þam ðe unrihte inne gehydde
+wræte under wealle. Weard ær ofsloh
+feara sumne; þa sio fæhð gewearð
+gewrecen wraðlice. Wundur hwar þonne
+eorl ellenrof ende gefere
+lifgesceafta, þonne leng ne mæg
+mon mid his magum meduseld buan.
+Swa wæs Biowulfe, þa he biorges weard
+sohte, searoniðas; seolfa ne cuðe
+þurh hwæt his worulde gedal weorðan sceolde.
+Swa hit oð domes dæg diope benemdon
+þeodnas mære, þa ðæt þær dydon,
+þæt se secg wære synnum scildig,
+hergum geheaðerod, hellbendum fæst,
+wommum gewitnad, se ðone wong strude,
+næs he goldhwæte gearwor hæfde
+agendes est ær gesceawod.
+Wiglaf maðelode, Wihstanes sunu:
+"Oft sceall eorl monig anes willan
+wræc adreogan, swa us geworden is.
+Ne meahton we gelæran leofne þeoden,
+rices hyrde, ræd ænigne,
+þæt he ne grette goldweard þone,
+lete hyne licgean þær he longe wæs,
+wicum wunian oð woruldende;
+heold on heahgesceap. Hord ys gesceawod,
+grimme gegongen; wæs þæt gifeðe to swið
+þe ðone þeodcyning þyder ontyhte.
+Ic wæs þær inne ond þæt eall geondseh,
+recedes geatwa, þa me gerymed wæs,
+nealles swæslice sið alyfed
+inn under eorðweall. Ic on ofoste gefeng
+micle mid mundum mægenbyrðenne
+hordgestreona, hider ut ætbær
+cyninge minum. Cwico wæs þa gena,
+wis ond gewittig; worn eall gespræc
+gomol on gehðo ond eowic gretan het,
+bæd þæt ge geworhton æfter wines dædum
+in bælstede beorh þone hean,
+micelne ond mærne, swa he manna wæs
+wigend weorðfullost wide geond eorðan,
+þenden he burhwelan brucan moste.
+Uton nu efstan oðre siðe,
+seon ond secean searogimma geþræc,
+wundur under wealle; ic eow wisige,
+þæt ge genoge neon sceawiað
+beagas ond brad gold. Sie sio bær gearo,
+ædre geæfned, þonne we ut cymen,
+ond þonne geferian frean userne,
+leofne mannan, þær he longe sceal
+on ðæs waldendes wære geþolian."
+Het ða gebeodan byre Wihstanes,
+hæle hildedior, hæleða monegum,
+boldagendra, þæt hie bælwudu
+feorran feredon, folcagende,
+godum togenes: "Nu sceal gled fretan,
+weaxan wonna leg wigena strengel,
+þone ðe oft gebad isernscure,
+þonne stræla storm strengum gebæded
+scoc ofer scildweall, sceft nytte heold,
+feðergearwum fus flane fulleode."
+Huru se snotra sunu Wihstanes
+acigde of corðre cyninges þegnas
+syfone tosomne, þa selestan,
+eode eahta sum under inwithrof
+hilderinca; sum on handa bær
+æledleoman, se ðe on orde geong.
+Næs ða on hlytme hwa þæt hord strude,
+syððan orwearde ænigne dæl
+secgas gesegon on sele wunian,
+læne licgan; lyt ænig mearn
+þæt hi ofostlice ut geferedon
+dyre maðmas. Dracan ec scufun,
+wyrm ofer weallclif, leton weg niman,
+flod fæðmian frætwa hyrde.
+þa wæs wunden gold on wæn hladen,
+æghwæs unrim, æþeling boren,
+har hilderinc to Hronesnæsse.
+Him ða gegiredan Geata leode
+ad on eorðan unwaclicne,
+helmum behongen, hildebordum,
+beorhtum byrnum, swa he bena wæs;
+alegdon ða tomiddes mærne þeoden
+hæleð hiofende, hlaford leofne.
+Ongunnon þa on beorge bælfyra mæst
+wigend weccan; wudurec astah,
+sweart ofer swioðole, swogende leg
+wope bewunden (windblond gelæg),
+oðþæt he ða banhus gebrocen hæfde,
+hat on hreðre. Higum unrote
+modceare mændon, mondryhtnes cwealm;
+swylce giomorgyd Geatisc meowle
+bundenheorde
+song sorgcearig swiðe geneahhe
+þæt hio hyre heofungdagas hearde ondrede,
+wælfylla worn, werudes egesan,
+hynðo ond hæftnyd. Heofon rece swealg.
+Geworhton ða Wedra leode
+hleo on hoe, se wæs heah ond brad,
+wægliðendum wide gesyne,
+ond betimbredon on tyn dagum
+beadurofes becn, bronda lafe
+wealle beworhton, swa hyt weorðlicost
+foresnotre men findan mihton.
+Hi on beorg dydon beg ond siglu,
+eall swylce hyrsta, swylce on horde ær
+niðhedige men genumen hæfdon,
+forleton eorla gestreon eorðan healdan,
+gold on greote, þær hit nu gen lifað
+eldum swa unnyt swa hit æror wæs.
+þa ymbe hlæw riodan hildediore,
+æþelinga bearn, ealra twelfe,
+woldon ceare cwiðan ond kyning mænan,
+wordgyd wrecan ond ymb wer sprecan;
+eahtodan eorlscipe ond his ellenweorc
+duguðum demdon, swa hit gedefe bið
+þæt mon his winedryhten wordum herge,
+ferhðum freoge, þonne he forð scile
+of lichaman læded weorðan.
+Swa begnornodon Geata leode
+hlafordes hryre, heorðgeneatas,
+cwædon þæt he wære wyruldcyninga
+manna mildust ond monðwærust,
+leodum liðost ond lofgeornost.
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.rs
new file mode 100644
index 0000000..0ab1139
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.rs
@@ -0,0 +1,11 @@
+use std::io;
+use std::io::Read;
+
+fn main() {
+    let mut stdin = String::new();
+    assert!(io::stdin().read_to_string(&mut stdin).is_ok());
+    assert_eq!(
+        stdin,
+        String::from_utf8_lossy(include_bytes!("io_stdin-hello.stdin"))
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.stdin b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.stdin
new file mode 100644
index 0000000..d8a52cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdin-hello.stdin
@@ -0,0 +1 @@
+Hello, stdin!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.rs
new file mode 100644
index 0000000..eed90b2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.rs
@@ -0,0 +1,6 @@
+use std::io;
+use std::io::Write;
+
+fn main() {
+  assert!(io::stdout().write_all(include_bytes!("io_stdout-beowulf.stdout")).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.stdout
new file mode 100644
index 0000000..1856685
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-beowulf.stdout
@@ -0,0 +1,3182 @@
+Hwæt. We Gardena in geardagum,
+þeodcyninga, þrym gefrunon,
+hu ða æþelingas ellen fremedon.
+Oft Scyld Scefing sceaþena þreatum,
+monegum mægþum, meodosetla ofteah,
+egsode eorlas. Syððan ærest wearð
+feasceaft funden, he þæs frofre gebad,
+weox under wolcnum, weorðmyndum þah,
+oðþæt him æghwylc þara ymbsittendra
+ofer hronrade hyran scolde,
+gomban gyldan. þæt wæs god cyning.
+ðæm eafera wæs æfter cenned,
+geong in geardum, þone god sende
+folce to frofre; fyrenðearfe ongeat
+þe hie ær drugon aldorlease
+lange hwile. Him þæs liffrea,
+wuldres wealdend, woroldare forgeaf;
+Beowulf wæs breme blæd wide sprang,
+Scyldes eafera Scedelandum in.
+Swa sceal geong guma gode gewyrcean,
+fromum feohgiftum on fæder bearme,
+þæt hine on ylde eft gewunigen
+wilgesiþas, þonne wig cume,
+leode gelæsten; lofdædum sceal
+in mægþa gehwære man geþeon.
+Him ða Scyld gewat to gescæphwile
+felahror feran on frean wære.
+Hi hyne þa ætbæron to brimes faroðe,
+swæse gesiþas, swa he selfa bæd,
+þenden wordum weold wine Scyldinga;
+leof landfruma lange ahte.
+þær æt hyðe stod hringedstefna,
+isig ond utfus, æþelinges fær.
+Aledon þa leofne þeoden,
+beaga bryttan, on bearm scipes,
+mærne be mæste. þær wæs madma fela
+of feorwegum, frætwa, gelæded;
+ne hyrde ic cymlicor ceol gegyrwan
+hildewæpnum ond heaðowædum,
+billum ond byrnum; him on bearme læg
+madma mænigo, þa him mid scoldon
+on flodes æht feor gewitan.
+Nalæs hi hine læssan lacum teodan,
+þeodgestreonum, þon þa dydon
+þe hine æt frumsceafte forð onsendon
+ænne ofer yðe umborwesende.
+þa gyt hie him asetton segen geldenne
+heah ofer heafod, leton holm beran,
+geafon on garsecg; him wæs geomor sefa,
+murnende mod. Men ne cunnon
+secgan to soðe, selerædende,
+hæleð under heofenum, hwa þæm hlæste onfeng.
+ða wæs on burgum Beowulf Scyldinga,
+leof leodcyning, longe þrage
+folcum gefræge fæder ellor hwearf,
+aldor of earde, oþþæt him eft onwoc
+heah Healfdene; heold þenden lifde,
+gamol ond guðreouw, glæde Scyldingas.
+ðæm feower bearn forð gerimed
+in worold wocun, weoroda ræswan,
+Heorogar ond Hroðgar ond Halga til;
+hyrde ic þæt wæs Onelan cwen,
+Heaðoscilfingas healsgebedda.
+þa wæs Hroðgare heresped gyfen,
+wiges weorðmynd, þæt him his winemagas
+georne hyrdon, oðð þæt seo geogoð geweox,
+magodriht micel. Him on mod bearn
+þæt healreced hatan wolde,
+medoærn micel, men gewyrcean
+þonne yldo bearn æfre gefrunon,
+ond þær on innan eall gedælan
+geongum ond ealdum, swylc him god sealde,
+buton folcscare ond feorum gumena.
+ða ic wide gefrægn weorc gebannan
+manigre mægþe geond þisne middangeard,
+folcstede frætwan. Him on fyrste gelomp,
+ædre mid yldum, þæt hit wearð ealgearo,
+healærna mæst; scop him Heort naman
+se þe his wordes geweald wide hæfde.
+He beot ne aleh, beagas dælde,
+sinc æt symle. Sele hlifade,
+heah ond horngeap, heaðowylma bad,
+laðan liges; ne wæs hit lenge þa gen
+þæt se ecghete aþumsweorum,
+æfter wælniðe wæcnan scolde.
+ða se ellengæst earfoðlice
+þrage geþolode, se þe in þystrum bad,
+þæt he dogora gehwam dream gehyrde
+hludne in healle; þær wæs hearpan sweg,
+swutol sang scopes. Sægde se þe cuþe
+frumsceaft fira feorran reccan,
+cwæð þæt se ælmihtiga eorðan worhte,
+wlitebeorhtne wang, swa wæter bebugeð,
+gesette sigehreþig sunnan ond monan
+leoman to leohte landbuendum
+ond gefrætwade foldan sceatas
+leomum ond leafum, lif eac gesceop
+cynna gehwylcum þara ðe cwice hwyrfaþ.
+Swa ða drihtguman dreamum lifdon
+eadiglice, oððæt an ongan
+fyrene fremman feond on helle.
+Wæs se grimma gæst Grendel haten,
+mære mearcstapa, se þe moras heold,
+fen ond fæsten; fifelcynnes eard
+wonsæli wer weardode hwile,
+siþðan him scyppend forscrifen hæfde
+in Caines cynne. þone cwealm gewræc
+ece drihten, þæs þe he Abel slog;
+ne gefeah he þære fæhðe, ac he hine feor forwræc,
+metod for þy mane, mancynne fram.
+þanon untydras ealle onwocon,
+eotenas ond ylfe ond orcneas,
+swylce gigantas, þa wið gode wunnon
+lange þrage; he him ðæs lean forgeald.
+Gewat ða neosian, syþðan niht becom,
+hean huses, hu hit Hringdene
+æfter beorþege gebun hæfdon.
+Fand þa ðær inne æþelinga gedriht
+swefan æfter symble; sorge ne cuðon,
+wonsceaft wera. Wiht unhælo,
+grim ond grædig, gearo sona wæs,
+reoc ond reþe, ond on ræste genam
+þritig þegna, þanon eft gewat
+huðe hremig to ham faran,
+mid þære wælfylle wica neosan.
+ða wæs on uhtan mid ærdæge
+Grendles guðcræft gumum undyrne;
+þa wæs æfter wiste wop up ahafen,
+micel morgensweg. Mære þeoden,
+æþeling ærgod, unbliðe sæt,
+þolode ðryðswyð, þegnsorge dreah,
+syðþan hie þæs laðan last sceawedon,
+wergan gastes; wæs þæt gewin to strang,
+lað ond longsum. Næs hit lengra fyrst,
+ac ymb ane niht eft gefremede
+morðbeala mare ond no mearn fore,
+fæhðe ond fyrene; wæs to fæst on þam.
+þa wæs eaðfynde þe him elles hwær
+gerumlicor ræste sohte,
+bed æfter burum, ða him gebeacnod wæs,
+gesægd soðlice sweotolan tacne
+healðegnes hete; heold hyne syðþan
+fyr ond fæstor se þæm feonde ætwand.
+Swa rixode ond wið rihte wan,
+ana wið eallum, oðþæt idel stod
+husa selest. Wæs seo hwil micel;
+XII wintra tid torn geþolode
+wine Scyldinga, weana gehwelcne,
+sidra sorga. Forðam secgum wearð,
+ylda bearnum, undyrne cuð,
+gyddum geomore, þætte Grendel wan
+hwile wið Hroþgar, heteniðas wæg,
+fyrene ond fæhðe fela missera,
+singale sæce, sibbe ne wolde
+wið manna hwone mægenes Deniga,
+feorhbealo feorran, fea þingian,
+ne þær nænig witena wenan þorfte
+beorhtre bote to banan folmum,
+ac se æglæca ehtende wæs,
+deorc deaþscua, duguþe ond geogoþe,
+seomade ond syrede, sinnihte heold
+mistige moras. men ne cunnon
+hwyder helrunan hwyrftum scriþað.
+Swa fela fyrena feond mancynnes,
+atol angengea, oft gefremede,
+heardra hynða. Heorot eardode,
+sincfage sel sweartum nihtum;
+no he þone gifstol gretan moste,
+maþðum for metode, ne his myne wisse.
+þæt wæs wræc micel wine Scyldinga,
+modes brecða. Monig oft gesæt
+rice to rune; ræd eahtedon
+hwæt swiðferhðum selest wære
+wið færgryrum to gefremmanne.
+Hwilum hie geheton æt hærgtrafum
+wigweorþunga, wordum bædon
+þæt him gastbona geoce gefremede
+wið þeodþreaum. Swylc wæs þeaw hyra,
+hæþenra hyht; helle gemundon
+in modsefan, metod hie ne cuþon,
+dæda demend, ne wiston hie drihten god,
+ne hie huru heofena helm herian ne cuþon,
+wuldres waldend. Wa bið þæm ðe sceal
+þurh sliðne nið sawle bescufan
+in fyres fæþm, frofre ne wenan,
+wihte gewendan; wel bið þæm þe mot
+æfter deaðdæge drihten secean
+ond to fæder fæþmum freoðo wilnian.
+Swa ða mælceare maga Healfdenes
+singala seað, ne mihte snotor hæleð
+wean onwendan; wæs þæt gewin to swyð,
+laþ ond longsum, þe on ða leode becom,
+nydwracu niþgrim, nihtbealwa mæst.
+þæt fram ham gefrægn Higelaces þegn,
+god mid Geatum, Grendles dæda;
+se wæs moncynnes mægenes strengest
+on þæm dæge þysses lifes,
+æþele ond eacen. Het him yðlidan
+godne gegyrwan, cwæð, hu guðcyning
+ofer swanrade secean wolde,
+mærne þeoden, þa him wæs manna þearf.
+ðone siðfæt him snotere ceorlas
+lythwon logon, þeah he him leof wære;
+hwetton higerofne, hæl sceawedon.
+Hæfde se goda Geata leoda
+cempan gecorone þara þe he cenoste
+findan mihte; XVna sum
+sundwudu sohte; secg wisade,
+lagucræftig mon, landgemyrcu.
+Fyrst forð gewat. Flota wæs on yðum,
+bat under beorge. Beornas gearwe
+on stefn stigon; streamas wundon,
+sund wið sande; secgas bæron
+on bearm nacan beorhte frætwe,
+guðsearo geatolic; guman ut scufon,
+weras on wilsið, wudu bundenne.
+Gewat þa ofer wægholm, winde gefysed,
+flota famiheals fugle gelicost,
+oðþæt ymb antid oþres dogores
+wundenstefna gewaden hæfde
+þæt ða liðende land gesawon,
+brimclifu blican, beorgas steape,
+side sænæssas; þa wæs sund liden,
+eoletes æt ende. þanon up hraðe
+Wedera leode on wang stigon,
+sæwudu sældon syrcan hrysedon,
+guðgewædo, gode þancedon
+þæs þe him yþlade eaðe wurdon.
+þa of wealle geseah weard Scildinga,
+se þe holmclifu healdan scolde,
+beran ofer bolcan beorhte randas,
+fyrdsearu fuslicu; hine fyrwyt bræc
+modgehygdum, hwæt þa men wæron.
+Gewat him þa to waroðe wicge ridan
+þegn Hroðgares, þrymmum cwehte
+mægenwudu mundum, meþelwordum frægn:
+Hwæt syndon ge searohæbbendra,
+byrnum werede, þe þus brontne ceol
+ofer lagustræte lædan cwomon,
+hider ofer holmas? le wæs
+endesæta, ægwearde heold,
+þe on land Dena laðra nænig
+mid scipherge sceðþan ne meahte.
+No her cuðlicor cuman ongunnon
+lindhæbbende; ne ge leafnesword
+guðfremmendra gearwe ne wisson,
+maga gemedu. Næfre ic maran geseah
+eorla ofer eorþan ðonne is eower sum,
+secg on searwum; nis þæt seldguma,
+wæpnum geweorðad, næfne him his wlite leoge,
+ænlic ansyn. Nu ic eower sceal
+frumcyn witan, ær ge fyr heonan ,
+leassceaweras, on land Dena
+furþur feran. Nu ge feorbuend,
+mereliðende, minne gehyrað
+anfealdne geþoht: Ofost is selest
+to gecyðanne hwanan eowre cyme syndon.
+Him se yldesta ondswarode,
+werodes wisa, wordhord onleac:
+We synt gumcynnes Geata leode
+ond Higelaces heorðgeneatas.
+Wæs min fæder folcum gecyþed,
+æþele ordfruma, Ecgþeow haten.
+Gebad wintra worn, ær he on weg hwurfe,
+gamol of geardum; hine gearwe geman
+witena welhwylc wide geond eorþan.
+We þurh holdne hige hlaford þinne,
+sunu Healfdenes, secean cwomon,
+leodgebyrgean; wes þu us larena god.
+Habbað we to þæm mæran micel ærende,
+Deniga frean, ne sceal þær dyrne sum
+wesan, þæs ic wene. þu wast gif hit is
+swa we soþlice secgan hyrdon
+þæt mid Scyldingum sceaðona ic nat hwylc,
+deogol dædhata, deorcum nihtum
+eaweð þurh egsan uncuðne nið,
+hynðu ond hrafyl. Ic þæs Hroðgar mæg
+þurh rumne sefan ræd gelæran,
+hu he frod ond god feond oferswyðeþ,
+gyf him edwendan æfre scolde
+bealuwa bisigu, bot eft cuman,
+ond þa cearwylmas colran wurðaþ;
+oððe a syþðan earfoðþrage,
+þreanyd þolað, þenden þær wunað
+on heahstede husa selest.
+Weard maþelode, ðær on wicge sæt,
+ombeht unforht: æghwæþres sceal
+scearp scyldwiga gescad witan,
+worda ond worca, se þe wel þenceð.
+Ic þæt gehyre, þæt þis is hold weorod
+frean Scyldinga. Gewitaþ forð beran
+wæpen ond gewædu; ic eow wisige.
+Swylce ic maguþegnas mine hate
+wið feonda gehwone flotan eowerne,
+niwtyrwydne nacan on sande
+arum healdan, oþðæt eft byreð
+ofer lagustreamas leofne mannan
+wudu wundenhals to Wedermearce,
+godfremmendra swylcum gifeþe bið
+þæt þone hilderæs hal gedigeð.
+Gewiton him þa feran. Flota stille bad,
+seomode on sale sidfæþmed scip,
+on ancre fæst. Eoforlic scionon
+ofer hleorberan gehroden golde,
+fah ond fyrheard; ferhwearde heold
+guþmod grimmon. Guman onetton,
+sigon ætsomne, oþþæt hy sæl timbred,
+geatolic ond goldfah, ongyton mihton;
+þæt wæs foremærost foldbuendum
+receda under roderum, on þæm se rica bad;
+lixte se leoma ofer landa fela.
+Him þa hildedeor hof modigra
+torht getæhte, þæt hie him to mihton
+gegnum gangan; guðbeorna sum
+wicg gewende, word æfter cwæð:
+Mæl is me to feran; fæder alwalda
+mid arstafum eowic gehealde
+siða gesunde. Ic to sæ wille
+wið wrað werod wearde healdan.
+Stræt wæs stanfah, stig wisode
+gumum ætgædere. Guðbyrne scan
+heard hondlocen, hringiren scir
+song in searwum, þa hie to sele furðum
+in hyra gryregeatwum gangan cwomon.
+Setton sæmeþe side scyldas,
+rondas regnhearde, wið þæs recedes weal,
+bugon þa to bence. Byrnan hringdon,
+guðsearo gumena; garas stodon,
+sæmanna searo, samod ætgædere,
+æscholt ufan græg; wæs se irenþreat
+wæpnum gewurþad. þa ðær wlonc hæleð
+oretmecgas æfter æþelum frægn:
+Hwanon ferigeað ge fætte scyldas,
+græge syrcan ond grimhelmas,
+heresceafta heap? Ic eom Hroðgares
+ar ond ombiht. Ne seah ic elþeodige
+þus manige men modiglicran.
+Wen ic þæt ge for wlenco, nalles for wræcsiðum,
+ac for higeþrymmum Hroðgar sohton.
+Him þa ellenrof andswarode,
+wlanc Wedera leod, word æfter spræc,
+heard under helme: We synt Higelaces
+beodgeneatas; Beowulf is min nama.
+Wille ic asecgan sunu Healfdenes,
+mærum þeodne, min ærende,
+aldre þinum, gif he us geunnan wile
+þæt we hine swa godne gretan moton.
+Wulfgar maþelode þæt wæs Wendla leod;
+wæs his modsefa manegum gecyðed,
+wig ond wisdom: Ic þæs wine Deniga,
+frean Scildinga, frinan wille,
+beaga bryttan, swa þu bena eart,
+þeoden mærne, ymb þinne sið,
+ond þe þa ondsware ædre gecyðan
+ðe me se goda agifan þenceð.
+Hwearf þa hrædlice þær Hroðgar sæt
+eald ond anhar mid his eorla gedriht;
+eode ellenrof, þæt he for eaxlum gestod
+Deniga frean; cuþe he duguðe þeaw.
+Wulfgar maðelode to his winedrihtne:
+Her syndon geferede, feorran cumene
+ofer geofenes begang Geata leode;
+þone yldestan oretmecgas
+Beowulf nemnað. Hy benan synt
+þæt hie, þeoden min, wið þe moton
+wordum wrixlan. No ðu him wearne geteoh
+ðinra gegncwida, glædman Hroðgar.
+Hy on wiggetawum wyrðe þinceað
+eorla geæhtlan; huru se aldor deah,
+se þæm heaðorincum hider wisade.
+Hroðgar maþelode, helm Scyldinga:
+Ic hine cuðe cnihtwesende.
+Wæs his ealdfæder Ecgþeo haten,
+ðæm to ham forgeaf Hreþel Geata
+angan dohtor; is his eafora nu
+heard her cumen, sohte holdne wine.
+ðonne sægdon þæt sæliþende,
+þa ðe gifsceattas Geata fyredon
+þyder to þance, þæt he XXXtiges
+manna mægencræft on his mundgripe
+heaþorof hæbbe. Hine halig god
+for arstafum us onsende,
+to Westdenum, þæs ic wen hæbbe,
+wið Grendles gryre. Ic þæm godan sceal
+for his modþræce madmas beodan.
+Beo ðu on ofeste, hat in gan
+seon sibbegedriht samod ætgædere;
+gesaga him eac wordum þæt hie sint wilcuman
+Deniga leodum.
+[] word inne abead:
+Eow het secgan sigedrihten min,
+aldor Eastdena, þæt he eower æþelu can,
+ond ge him syndon ofer sæwylmas
+heardhicgende hider wilcuman.
+Nu ge moton gangan in eowrum guðgeatawum
+under heregriman Hroðgar geseon;
+lætað hildebord her onbidan,
+wudu, wælsceaftas, worda geþinges.
+Aras þa se rica, ymb hine rinc manig,
+þryðlic þegna heap; sume þær bidon,
+heaðoreaf heoldon, swa him se hearda bebead.
+Snyredon ætsomne, þa secg wisode,
+under Heorotes hrof
+heard under helme, þæt he on heoðe gestod.
+Beowulf maðelode on him byrne scan,
+searonet seowed smiþes orþancum:
+Wæs þu, Hroðgar, hal. Ic eom Higelaces
+mæg ond magoðegn; hæbbe ic mærða fela
+ongunnen on geogoþe. Me wearð Grendles þing
+on minre eþeltyrf undyrne cuð;
+secgað sæliðend þæt þæs sele stande,
+reced selesta, rinca gehwylcum
+idel ond unnyt, siððan æfenleoht
+under heofenes hador beholen weorþeð.
+þa me þæt gelærdon leode mine
+þa selestan, snotere ceorlas,
+þeoden Hroðgar, þæt ic þe sohte,
+forþan hie mægenes cræft minne cuþon,
+selfe ofersawon, ða ic of searwum cwom,
+fah from feondum. þær ic fife geband,
+yðde eotena cyn ond on yðum slog
+niceras nihtes, nearoþearfe dreah,
+wræc Wedera nið wean ahsodon,
+forgrand gramum, ond nu wið Grendel sceal,
+wið þam aglæcan, ana gehegan
+ðing wið þyrse. Ic þe nu ða,
+brego Beorhtdena, biddan wille,
+eodor Scyldinga, anre bene,
+þæt ðu me ne forwyrne, wigendra hleo,
+freowine folca, nu ic þus feorran com,
+þæt ic mote ana ond minra eorla gedryht,
+þes hearda heap, Heorot fælsian.
+Hæbbe ic eac geahsod þæt se æglæca
+for his wonhydum wæpna ne recceð.
+Ic þæt þonne forhicge swa me Higelac sie,
+min mondrihten, modes bliðe,
+þæt ic sweord bere oþðe sidne scyld,
+geolorand to guþe, ac ic mid grape sceal
+fon wið feonde ond ymb feorh sacan,
+lað wið laþum; ðær gelyfan sceal
+dryhtnes dome se þe hine deað nimeð.
+Wen ic þæt he wille, gif he wealdan mot,
+in þæm guðsele Geotena leode
+etan unforhte, swa he oft dyde,
+mægen Hreðmanna. Na þu minne þearft
+hafalan hydan, ac he me habban wile
+dreore fahne, gif mec deað nimeð.
+Byreð blodig wæl, byrgean þenceð,
+eteð angenga unmurnlice,
+mearcað morhopu; no ðu ymb mines ne þearft
+lices feorme leng sorgian.
+Onsend Higelace, gif mec hild nime,
+beaduscruda betst, þæt mine breost wereð,
+hrægla selest; þæt is Hrædlan laf,
+Welandes geweorc. Gæð a wyrd swa hio scel.
+Hroðgar maþelode, helm Scyldinga:
+For gewyrhtum þu, wine min Beowulf,
+ond for arstafum usic sohtest.
+Gesloh þin fæder fæhðe mæste;
+wearþ he Heaþolafe to handbonan
+mid Wilfingum; ða hine Wedera cyn
+for herebrogan habban ne mihte.
+þanon he gesohte Suðdena folc
+ofer yða gewealc, Arscyldinga.
+ða ic furþum weold folce Deniga
+ond on geogoðe heold ginne rice,
+hordburh hæleþa; ða wæs Heregar dead,
+min yldra mæg unlifigende,
+bearn Healfdenes; se wæs betera ðonne ic.
+Siððan þa fæhðe feo þingode;
+sende ic Wylfingum ofer wæteres hrycg
+ealde madmas; he me aþas swor.
+Sorh is me to secganne on sefan minum
+gumena ængum hwæt me Grendel hafað
+hynðo on Heorote mid his heteþancum,
+færniða gefremed. Is min fletwerod,
+wigheap gewanod; hie wyrd forsweop
+on Grendles gryre. God eaþe mæg
+þone dolsceaðan dæda getwæfan.
+Ful oft gebeotedon beore druncne
+ofer ealowæge oretmecgas
+þæt hie in beorsele bidan woldon
+Grendles guþe mid gryrum ecga.
+ðonne wæs þeos medoheal on morgentid,
+drihtsele dreorfah, þonne dæg lixte,
+eal bencþelu blode bestymed,
+heall heorudreore; ahte ic holdra þy læs,
+deorre duguðe, þe þa deað fornam.
+Site nu to symle ond onsæl meoto,
+sigehreð secgum, swa þin sefa hwette.
+þa wæs Geatmæcgum geador ætsomne
+on beorsele benc gerymed;
+þær swiðferhþe sittan eodon,
+þryðum dealle. þegn nytte beheold,
+se þe on handa bær hroden ealowæge,
+scencte scir wered. Scop hwilum sang
+hador on Heorote. þær wæs hæleða dream,
+duguð unlytel Dena ond Wedera.
+Unferð maþelode, Ecglafes bearn,
+þe æt fotum sæt frean Scyldinga,
+onband beadurune wæs him Beowulfes sið,
+modges merefaran, micel æfþunca,
+forþon þe he ne uþe þæt ænig oðer man
+æfre mærða þon ma middangeardes
+gehedde under heofenum þonne he sylfa:
+Eart þu se Beowulf, se þe wið Brecan wunne,
+on sidne sæ ymb sund flite,
+ðær git for wlence wada cunnedon
+ond for dolgilpe on deop wæter
+aldrum neþdon? Ne inc ænig mon,
+ne leof ne lað, belean mihte
+sorhfullne sið, þa git on sund reon.
+þær git eagorstream earmum þehton,
+mæton merestræta, mundum brugdon,
+glidon ofer garsecg; geofon yþum weol,
+wintrys wylmum. Git on wæteres æht
+seofon niht swuncon; he þe æt sunde oferflat,
+hæfde mare mægen. þa hine on morgentid
+on Heaþoræmas holm up ætbær;
+ðonon he gesohte swæsne eþel,
+leof his leodum, lond Brondinga,
+freoðoburh fægere, þær he folc ahte
+burh ond beagas. Beot eal wið þe
+sunu Beanstanes soðe gelæste.
+ðonne wene ic to þe wyrsan geþingea,
+ðeah þu heaðoræsa gehwær dohte,
+grimre guðe, gif þu Grendles dearst
+nihtlongne fyrst nean bidan.
+Beowulf maþelode, bearn Ecgþeowes:
+Hwæt. þu worn fela, wine min Unferð,
+beore druncen ymb Brecan spræce,
+sægdest from his siðe. Soð ic talige,
+þæt ic merestrengo maran ahte,
+earfeþo on yþum, ðonne ænig oþer man.
+Wit þæt gecwædon cnihtwesende
+ond gebeotedon wæron begen þa git
+on geogoðfeore þæt wit on garsecg ut
+aldrum neðdon, ond þæt geæfndon swa.
+Hæfdon swurd nacod, þa wit on sund reon,
+heard on handa; wit unc wið hronfixas
+werian þohton. No he wiht fram me
+flodyþum feor fleotan meahte,
+hraþor on holme; no ic fram him wolde.
+ða wit ætsomne on sæ wæron
+fif nihta fyrst, oþþæt unc flod todraf,
+wado weallende, wedera cealdost,
+nipende niht, ond norþanwind
+heaðogrim ondhwearf; hreo wæron yþa.
+Wæs merefixa mod onhrered;
+þær me wið laðum licsyrce min,
+heard, hondlocen, helpe gefremede,
+beadohrægl broden on breostum læg
+golde gegyrwed. Me to grunde teah
+fah feondscaða, fæste hæfde
+grim on grape; hwæþre me gyfeþe wearð
+þæt ic aglæcan orde geræhte,
+hildebille; heaþoræs fornam
+mihtig meredeor þurh mine hand.
+Swa mec gelome laðgeteonan
+þreatedon þearle. Ic him þenode
+deoran sweorde, swa hit gedefe wæs.
+Næs hie ðære fylle gefean hæfdon,
+manfordædlan, þæt hie me þegon,
+symbel ymbsæton sægrunde neah;
+ac on mergenne mecum wunde
+be yðlafe uppe lægon,
+sweordum aswefede, þæt syðþan na
+ymb brontne ford brimliðende
+lade ne letton. Leoht eastan com,
+beorht beacen godes; brimu swaþredon,
+þæt ic sænæssas geseon mihte,
+windige weallas. Wyrd oft nereð
+unfægne eorl, þonne his ellen deah.
+Hwæþere me gesælde þæt ic mid sweorde ofsloh
+niceras nigene. No ic on niht gefrægn
+under heofones hwealf heardran feohtan,
+ne on egstreamum earmran mannon;
+hwaþere ic fara feng feore gedigde,
+siþes werig. ða mec sæ oþbær,
+flod æfter faroðe on Finna land,
+wadu weallendu. No ic wiht fram þe
+swylcra searoniða secgan hyrde,
+billa brogan. Breca næfre git
+æt heaðolace, ne gehwæþer incer,
+swa deorlice dæd gefremede
+fagum sweordum no ic þæs fela gylpe,
+þeah ðu þinum broðrum to banan wurde,
+heafodmægum; þæs þu in helle scealt
+werhðo dreogan, þeah þin wit duge.
+Secge ic þe to soðe, sunu Ecglafes,
+þæt næfre Grendel swa fela gryra gefremede,
+atol æglæca, ealdre þinum,
+hynðo on Heorote, gif þin hige wære,
+sefa swa searogrim, swa þu self talast.
+Ac he hafað onfunden þæt he þa fæhðe ne þearf,
+atole ecgþræce eower leode
+swiðe onsittan, Sigescyldinga;
+nymeð nydbade, nænegum arað
+leode Deniga, ac he lust wigeð,
+swefeð ond sendeþ, secce ne weneþ
+to Gardenum. Ac ic him Geata sceal
+eafoð ond ellen ungeara nu,
+guþe gebeodan. Gæþ eft se þe mot
+to medo modig, siþþan morgenleoht
+ofer ylda bearn oþres dogores,
+sunne sweglwered suþan scineð.
+þa wæs on salum sinces brytta,
+gamolfeax ond guðrof; geoce gelyfde
+brego Beorhtdena, gehyrde on Beowulfe
+folces hyrde fæstrædne geþoht.
+ðær wæs hæleþa hleahtor, hlyn swynsode,
+word wæron wynsume. Eode Wealhþeow forð,
+cwen Hroðgares, cynna gemyndig,
+grette goldhroden guman on healle,
+ond þa freolic wif ful gesealde
+ærest Eastdena eþelwearde,
+bæd hine bliðne æt þære beorþege,
+leodum leofne. He on lust geþeah
+symbel ond seleful, sigerof kyning.
+Ymbeode þa ides Helminga
+duguþe ond geogoþe dæl æghwylcne,
+sincfato sealde, oþþæt sæl alamp
+þæt hio Beowulfe, beaghroden cwen
+mode geþungen, medoful ætbær;
+grette Geata leod, gode þancode
+wisfæst wordum þæs ðe hire se willa gelamp
+þæt heo on ænigne eorl gelyfde
+fyrena frofre. He þæt ful geþeah,
+wælreow wiga, æt Wealhþeon,
+ond þa gyddode guþe gefysed;
+Beowulf maþelode, bearn Ecgþeowes:
+Ic þæt hogode, þa ic on holm gestah,
+sæbat gesæt mid minre secga gedriht,
+þæt ic anunga eowra leoda
+willan geworhte oþðe on wæl crunge,
+feondgrapum fæst. Ic gefremman sceal
+eorlic ellen, oþðe endedæg
+on þisse meoduhealle minne gebidan.
+ðam wife þa word wel licodon,
+gilpcwide Geates; eode goldhroden
+freolicu folccwen to hire frean sittan.
+þa wæs eft swa ær inne on healle
+þryðword sprecen, ðeod on sælum,
+sigefolca sweg, oþþæt semninga
+sunu Healfdenes secean wolde
+æfenræste; wiste þæm ahlæcan
+to þæm heahsele hilde geþinged,
+siððan hie sunnan leoht geseon ne meahton,
+oðþe nipende niht ofer ealle,
+scaduhelma gesceapu scriðan cwoman,
+wan under wolcnum. Werod eall aras.
+Gegrette þa guma oþerne,
+Hroðgar Beowulf, ond him hæl abead,
+winærnes geweald, ond þæt word acwæð:
+Næfre ic ænegum men ær alyfde,
+siþðan ic hond ond rond hebban mihte,
+ðryþærn Dena buton þe nu ða.
+Hafa nu ond geheald husa selest,
+gemyne mærþo, mægenellen cyð,
+waca wið wraþum. Ne bið þe wilna gad,
+gif þu þæt ellenweorc aldre gedigest.
+ða him Hroþgar gewat mid his hæleþa gedryht,
+eodur Scyldinga, ut of healle;
+wolde wigfruma Wealhþeo secan,
+cwen to gebeddan. Hæfde kyningwuldor
+Grendle togeanes, swa guman gefrungon,
+seleweard aseted; sundornytte beheold
+ymb aldor Dena, eotonweard abead.
+Huru Geata leod georne truwode
+modgan mægnes, metodes hyldo.
+ða he him of dyde isernbyrnan,
+helm of hafelan, sealde his hyrsted sweord,
+irena cyst, ombihtþegne,
+ond gehealdan het hildegeatwe.
+Gespræc þa se goda gylpworda sum,
+Beowulf Geata, ær he on bed stige:
+No ic me an herewæsmun hnagran talige,
+guþgeweorca, þonne Grendel hine;
+forþan ic hine sweorde swebban nelle,
+aldre beneotan, þeah ic eal mæge.
+Nat he þara goda þæt he me ongean slea,
+rand geheawe, þeah ðe he rof sie
+niþgeweorca; ac wit on niht sculon
+secge ofersittan, gif he gesecean dear
+wig ofer wæpen, ond siþðan witig god
+on swa hwæþere hond, halig dryhten,
+mærðo deme, swa him gemet þince.
+Hylde hine þa heaþodeor, hleorbolster onfeng
+eorles andwlitan, ond hine ymb monig
+snellic særinc selereste gebeah.
+Nænig heora þohte þæt he þanon scolde
+eft eardlufan æfre gesecean,
+folc oþðe freoburh, þær he afeded wæs;
+ac hie hæfdon gefrunen þæt hie ær to fela micles
+in þæm winsele wældeað fornam,
+Denigea leode. Ac him dryhten forgeaf
+wigspeda gewiofu, Wedera leodum,
+frofor ond fultum, þæt hie feond heora
+ðurh anes cræft ealle ofercomon,
+selfes mihtum. Soð is gecyþed
+þæt mihtig god manna cynnes
+weold wideferhð. Com on wanre niht
+scriðan sceadugenga. Sceotend swæfon,
+þa þæt hornreced healdan scoldon,
+ealle buton anum. þæt wæs yldum cuþ
+þæt hie ne moste, þa metod nolde,
+se scynscaþa under sceadu bregdan;
+ac he wæccende wraþum on andan
+bad bolgenmod beadwa geþinges.
+ða com of more under misthleoþum
+Grendel gongan, godes yrre bær;
+mynte se manscaða manna cynnes
+sumne besyrwan in sele þam hean.
+Wod under wolcnum to þæs þe he winreced,
+goldsele gumena, gearwost wisse,
+fættum fahne. Ne wæs þæt forma sið
+þæt he Hroþgares ham gesohte;
+næfre he on aldordagum ær ne siþðan
+heardran hæle, healðegnas fand.
+Com þa to recede rinc siðian,
+dreamum bedæled. Duru sona onarn,
+fyrbendum fæst, syþðan he hire folmum æthran;
+onbræd þa bealohydig, ða he gebolgen wæs,
+recedes muþan. Raþe æfter þon
+on fagne flor feond treddode,
+eode yrremod; him of eagum stod
+ligge gelicost leoht unfæger.
+Geseah he in recede rinca manige,
+swefan sibbegedriht samod ætgædere,
+magorinca heap. þa his mod ahlog;
+mynte þæt he gedælde, ærþon dæg cwome,
+atol aglæca, anra gehwylces
+lif wið lice, þa him alumpen wæs
+wistfylle wen. Ne wæs þæt wyrd þa gen
+þæt he ma moste manna cynnes
+ðicgean ofer þa niht. þryðswyð beheold
+mæg Higelaces, hu se manscaða
+under færgripum gefaran wolde.
+Ne þæt se aglæca yldan þohte,
+ac he gefeng hraðe forman siðe
+slæpendne rinc, slat unwearnum,
+bat banlocan, blod edrum dranc,
+synsnædum swealh; sona hæfde
+unlyfigendes eal gefeormod,
+fet ond folma. Forð near ætstop,
+nam þa mid handa higeþihtigne
+rinc on ræste, ræhte ongean
+feond mid folme; he onfeng hraþe
+inwitþancum ond wið earm gesæt.
+Sona þæt onfunde fyrena hyrde
+þæt he ne mette middangeardes,
+eorþan sceata, on elran men
+mundgripe maran. He on mode wearð
+forht on ferhðe; no þy ær fram meahte.
+Hyge wæs him hinfus, wolde on heolster fleon,
+secan deofla gedræg; ne wæs his drohtoð þær
+swylce he on ealderdagum ær gemette.
+Gemunde þa se goda, mæg Higelaces,
+æfenspræce, uplang astod
+ond him fæste wiðfeng; fingras burston.
+Eoten wæs utweard; eorl furþur stop.
+Mynte se mæra, þær he meahte swa,
+widre gewindan ond on weg þanon
+fleon on fenhopu; wiste his fingra geweald
+on grames grapum. þæt wæs geocor sið
+þæt se hearmscaþa to Heorute ateah.
+Dryhtsele dynede; Denum eallum wearð,
+ceasterbuendum, cenra gehwylcum,
+eorlum ealuscerwen. Yrre wæron begen,
+reþe renweardas. Reced hlynsode.
+þa wæs wundor micel þæt se winsele
+wiðhæfde heaþodeorum, þæt he on hrusan ne feol,
+fæger foldbold; ac he þæs fæste wæs
+innan ond utan irenbendum
+searoþoncum besmiþod. þær fram sylle abeag
+medubenc monig, mine gefræge,
+golde geregnad, þær þa graman wunnon.
+þæs ne wendon ær witan Scyldinga
+þæt hit a mid gemete manna ænig,
+betlic ond banfag, tobrecan meahte,
+listum tolucan, nymþe liges fæþm
+swulge on swaþule. Sweg up astag
+niwe geneahhe; Norðdenum stod
+atelic egesa, anra gehwylcum
+þara þe of wealle wop gehyrdon,
+gryreleoð galan godes ondsacan,
+sigeleasne sang, sar wanigean
+helle hæfton. Heold hine fæste
+se þe manna wæs mægene strengest
+on þæm dæge þysses lifes.
+Nolde eorla hleo ænige þinga
+þone cwealmcuman cwicne forlætan,
+ne his lifdagas leoda ænigum
+nytte tealde. þær genehost brægd
+eorl Beowulfes ealde lafe,
+wolde freadrihtnes feorh ealgian,
+mæres þeodnes, ðær hie meahton swa.
+Hie þæt ne wiston, þa hie gewin drugon,
+heardhicgende hildemecgas,
+ond on healfa gehwone heawan þohton,
+sawle secan, þone synscaðan
+ænig ofer eorþan irenna cyst,
+guðbilla nan, gretan nolde,
+ac he sigewæpnum forsworen hæfde,
+ecga gehwylcre. Scolde his aldorgedal
+on ðæm dæge þysses lifes
+earmlic wurðan, ond se ellorgast
+on feonda geweald feor siðian.
+ða þæt onfunde se þe fela æror
+modes myrðe manna cynne,
+fyrene gefremede he wæs fag wið god,
+þæt him se lichoma læstan nolde,
+ac hine se modega mæg Hygelaces
+hæfde be honda; wæs gehwæþer oðrum
+lifigende lað. Licsar gebad
+atol æglæca; him on eaxle wearð
+syndolh sweotol, seonowe onsprungon,
+burston banlocan. Beowulfe wearð
+guðhreð gyfeþe; scolde Grendel þonan
+feorhseoc fleon under fenhleoðu,
+secean wynleas wic; wiste þe geornor
+þæt his aldres wæs ende gegongen,
+dogera dægrim. Denum eallum wearð
+æfter þam wælræse willa gelumpen.
+Hæfde þa gefælsod se þe ær feorran com,
+snotor ond swyðferhð, sele Hroðgares,
+genered wið niðe; nihtweorce gefeh,
+ellenmærþum. Hæfde Eastdenum
+Geatmecga leod gilp gelæsted,
+swylce oncyþðe ealle gebette,
+inwidsorge, þe hie ær drugon
+ond for þreanydum þolian scoldon,
+torn unlytel. þæt wæs tacen sweotol,
+syþðan hildedeor hond alegde,
+earm ond eaxle þær wæs eal geador
+Grendles grape under geapne hrof.
+ða wæs on morgen mine gefræge
+ymb þa gifhealle guðrinc monig;
+ferdon folctogan feorran ond nean
+geond widwegas wundor sceawian,
+laþes lastas. No his lifgedal
+sarlic þuhte secga ænegum
+þara þe tirleases trode sceawode,
+hu he werigmod on weg þanon,
+niða ofercumen, on nicera mere
+fæge ond geflymed feorhlastas bær.
+ðær wæs on blode brim weallende,
+atol yða geswing eal gemenged
+haton heolfre, heorodreore weol.
+Deaðfæge deog, siððan dreama leas
+in fenfreoðo feorh alegde,
+hæþene sawle; þær him hel onfeng.
+þanon eft gewiton ealdgesiðas,
+swylce geong manig of gomenwaþe
+fram mere modge mearum ridan,
+beornas on blancum. ðær wæs Beowulfes
+mærðo mæned; monig oft gecwæð
+þætte suð ne norð be sæm tweonum
+ofer eormengrund oþer nænig
+under swegles begong selra nære
+rondhæbbendra, rices wyrðra.
+Ne hie huru winedrihten wiht ne logon,
+glædne Hroðgar, ac þæt wæs god cyning.
+Hwilum heaþorofe hleapan leton,
+on geflit faran fealwe mearas
+ðær him foldwegas fægere þuhton,
+cystum cuðe. Hwilum cyninges þegn,
+guma gilphlæden, gidda gemyndig,
+se ðe ealfela ealdgesegena
+worn gemunde, word oþer fand
+soðe gebunden; secg eft ongan
+sið Beowulfes snyttrum styrian
+ond on sped wrecan spel gerade,
+wordum wrixlan. Welhwylc gecwæð
+þæt he fram Sigemundes secgan hyrde
+ellendædum, uncuþes fela,
+Wælsinges gewin, wide siðas,
+þara þe gumena bearn gearwe ne wiston,
+fæhðe ond fyrena, buton Fitela mid hine,
+þonne he swulces hwæt secgan wolde,
+eam his nefan, swa hie a wæron
+æt niða gehwam nydgesteallan;
+hæfdon ealfela eotena cynnes
+sweordum gesæged. Sigemunde gesprong
+æfter deaðdæge dom unlytel,
+syþðan wiges heard wyrm acwealde,
+hordes hyrde. He under harne stan,
+æþelinges bearn, ana geneðde
+frecne dæde, ne wæs him Fitela mid.
+hwæþre him gesælde ðæt þæt swurd þurhwod
+wrætlicne wyrm, þæt hit on wealle ætstod,
+dryhtlic iren; draca morðre swealt.
+Hæfde aglæca elne gegongen
+þæt he beahhordes brucan moste
+selfes dome; sæbat gehleod,
+bær on bearm scipes beorhte frætwa,
+Wælses eafera. Wyrm hat gemealt.
+Se wæs wreccena wide mærost
+ofer werþeode, wigendra hleo,
+ellendædum he þæs ær onðah,
+siððan Heremodes hild sweðrode,
+eafoð ond ellen. He mid Eotenum wearð
+on feonda geweald forð forlacen,
+snude forsended. Hine sorhwylmas
+lemede to lange; he his leodum wearð,
+eallum æþellingum to aldorceare;
+swylce oft bemearn ærran mælum
+swiðferhþes sið snotor ceorl monig,
+se þe him bealwa to bote gelyfde,
+þæt þæt ðeodnes bearn geþeon scolde,
+fæderæþelum onfon, folc gehealdan,
+hord ond hleoburh, hæleþa rice,
+eþel Scyldinga. He þær eallum wearð,
+mæg Higelaces, manna cynne,
+freondum gefægra; hine fyren onwod.
+Hwilum flitende fealwe stræte
+mearum mæton. ða wæs morgenleoht
+scofen ond scynded. Eode scealc monig
+swiðhicgende to sele þam hean
+searowundor seon; swylce self cyning
+of brydbure, beahhorda weard,
+tryddode tirfæst getrume micle,
+cystum gecyþed, ond his cwen mid him
+medostigge mæt mægþa hose.
+Hroðgar maþelode he to healle geong,
+stod on stapole, geseah steapne hrof,
+golde fahne, ond Grendles hond:
+ðisse ansyne alwealdan þanc
+lungre gelimpe. Fela ic laþes gebad,
+grynna æt Grendle; a mæg god wyrcan
+wunder æfter wundre, wuldres hyrde.
+ðæt wæs ungeara þæt ic ænigra me
+weana ne wende to widan feore
+bote gebidan, þonne blode fah
+husa selest heorodreorig stod,
+wea widscofen witena gehwylcum
+ðara þe ne wendon þæt hie wideferhð
+leoda landgeweorc laþum beweredon
+scuccum ond scinnum. Nu scealc hafað
+þurh drihtnes miht dæd gefremede ðe
+we ealle ær ne meahton
+snyttrum besyrwan. Hwæt, þæt secgan mæg
+efne swa hwylc mægþa swa ðone magan cende
+æfter gumcynnum, gyf heo gyt lyfað,
+þæt hyre ealdmetod este wære
+bearngebyrdo. Nu ic, Beowulf, þec,
+secg betsta, me for sunu wylle
+freogan on ferhþe; heald forð tela
+niwe sibbe. Ne bið þe nænigra gad
+worolde wilna, þe ic geweald hæbbe.
+Ful oft ic for læssan lean teohhode,
+hordweorþunge hnahran rince,
+sæmran æt sæcce. þu þe self hafast
+dædum gefremed þæt þin dom lyfað
+awa to aldre. Alwalda þec
+gode forgylde, swa he nu gyt dyde.
+Beowulf maþelode, bearn Ecþeowes:
+We þæt ellenweorc estum miclum,
+feohtan fremedon, frecne geneðdon
+eafoð uncuþes. Uþe ic swiþor
+þæt ðu hine selfne geseon moste,
+feond on frætewum fylwerigne.
+Ic hine hrædlice heardan clammum
+on wælbedde wriþan þohte,
+þæt he for mundgripe minum scolde
+licgean lifbysig, butan his lic swice.
+Ic hine ne mihte, þa metod nolde,
+ganges getwæman, no ic him þæs georne ætfealh,
+feorhgeniðlan; wæs to foremihtig
+feond on feþe. Hwæþere he his folme forlet
+to lifwraþe last weardian,
+earm ond eaxle. No þær ænige swa þeah
+feasceaft guma frofre gebohte;
+no þy leng leofað laðgeteona,
+synnum geswenced, ac hyne sar hafað
+mid nydgripe nearwe befongen,
+balwon bendum. ðær abidan sceal
+maga mane fah miclan domes,
+hu him scir metod scrifan wille.
+ða wæs swigra secg, sunu Eclafes,
+on gylpspræce guðgeweorca,
+siþðan æþelingas eorles cræfte
+ofer heanne hrof hand sceawedon,
+feondes fingras. Foran æghwylc wæs,
+stiðra nægla gehwylc, style gelicost,
+hæþenes handsporu hilderinces,
+egl, unheoru. æghwylc gecwæð
+þæt him heardra nan hrinan wolde
+iren ærgod, þæt ðæs ahlæcan
+blodge beadufolme onberan wolde.
+ða wæs haten hreþe Heort innanweard
+folmum gefrætwod. Fela þæra wæs,
+wera ond wifa, þe þæt winreced,
+gestsele gyredon. Goldfag scinon
+web æfter wagum, wundorsiona fela
+secga gehwylcum þara þe on swylc starað.
+Wæs þæt beorhte bold tobrocen swiðe,
+eal inneweard irenbendum fæst,
+heorras tohlidene. Hrof ana genæs,
+ealles ansund, þe se aglæca,
+fyrendædum fag, on fleam gewand,
+aldres orwena. No þæt yðe byð
+to befleonne, fremme se þe wille,
+ac gesecan sceal sawlberendra,
+nyde genydde, niþða bearna,
+grundbuendra gearwe stowe,
+þær his lichoma legerbedde fæst
+swefeþ æfter symle. þa wæs sæl ond mæl
+þæt to healle gang Healfdenes sunu;
+wolde self cyning symbel þicgan.
+Ne gefrægen ic þa mægþe maran weorode
+ymb hyra sincgyfan sel gebæran.
+Bugon þa to bence blædagande,
+fylle gefægon; fægere geþægon
+medoful manig magas þara
+swiðhicgende on sele þam hean,
+Hroðgar ond Hroþulf. Heorot innan wæs
+freondum afylled; nalles facenstafas
+|eodscyldingas þenden fremedon.
+Forgeaf þa Beowulfe bearn Healfdenes
+segen gyldenne sigores to leane;
+hroden hildecumbor, helm ond byrnan,
+mære maðþumsweord manige gesawon
+beforan beorn beran. Beowulf geþah
+ful on flette; no he þære feohgyfte
+for sceotendum scamigan ðorfte.
+Ne gefrægn ic freondlicor feower madmas
+golde gegyrede gummanna fela
+in ealobence oðrum gesellan.
+Ymb þæs helmes hrof heafodbeorge
+wirum bewunden walu utan heold,
+þæt him fela laf frecne ne meahton
+scurheard sceþðan, þonne scyldfreca
+ongean gramum gangan scolde.
+Heht ða eorla hleo eahta mearas
+fætedhleore on flet teon,
+in under eoderas. þara anum stod
+sadol searwum fah, since gewurþad;
+þæt wæs hildesetl heahcyninges,
+ðonne sweorda gelac sunu Healfdenes
+efnan wolde. Næfre on ore læg
+widcuþes wig, ðonne walu feollon.
+Ond ða Beowulfe bega gehwæþres
+eodor Ingwina onweald geteah,
+wicga ond wæpna, het hine wel brucan.
+Swa manlice mære þeoden,
+hordweard hæleþa, heaþoræsas geald
+mearum ond madmum, swa hy næfre man lyhð,
+se þe secgan wile soð æfter rihte.
+ða gyt æghwylcum eorla drihten
+þara þe mid Beowulfe brimlade teah
+on þære medubence maþðum gesealde,
+yrfelafe, ond þone ænne heht
+golde forgyldan, þone ðe Grendel ær
+mane acwealde, swa he hyra ma wolde,
+nefne him witig god wyrd forstode
+ond ðæs mannes mod. Metod eallum weold
+gumena cynnes, swa he nu git deð.
+Forþan bið andgit æghwær selest,
+ferhðes foreþanc. Fela sceal gebidan
+leofes ond laþes se þe longe her
+on ðyssum windagum worolde bruceð.
+þær wæs sang ond sweg samod ætgædere
+fore Healfdenes hildewisan,
+gomenwudu greted, gid oft wrecen,
+ðonne healgamen Hroþgares scop
+æfter medobence mænan scolde
+be Finnes eaferum, ða hie se fær begeat,
+hæleð Healfdena, Hnæf Scyldinga,
+in Freswæle feallan scolde.
+Ne huru Hildeburh herian þorfte
+Eotena treowe; unsynnum wearð
+beloren leofum æt þam lindplegan,
+bearnum ond broðrum; hie on gebyrd hruron,
+gare wunde. þæt wæs geomuru ides.
+Nalles holinga Hoces dohtor
+meotodsceaft bemearn, syþðan morgen com,
+ða heo under swegle geseon meahte
+morþorbealo maga, þær heo ær mæste heold
+worolde wynne. Wig ealle fornam
+Finnes þegnas nemne feaum anum,
+þæt he ne mehte on þæm meðelstede
+wig Hengeste wiht gefeohtan,
+ne þa wealafe wige forþringan
+þeodnes ðegna. ac hig him geþingo budon,
+þæt hie him oðer flet eal gerymdon,
+healle ond heahsetl, þæt hie healfre geweald
+wið Eotena bearn agan moston,
+ond æt feohgyftum Folcwaldan sunu
+dogra gehwylce Dene weorþode,
+Hengestes heap hringum wenede
+efne swa swiðe sincgestreonum
+fættan goldes, swa he Fresena cyn
+on beorsele byldan wolde.
+ða hie getruwedon on twa healfa
+fæste frioðuwære. Fin Hengeste
+elne, unflitme aðum benemde
+þæt he þa wealafe weotena dome
+arum heolde, þæt ðær ænig mon
+wordum ne worcum wære ne bræce,
+ne þurh inwitsearo æfre gemænden
+ðeah hie hira beaggyfan banan folgedon
+ðeodenlease, þa him swa geþearfod wæs.
+gyf þonne Frysna hwylc frecnan spræce
+ðæs morþorhetes myndgiend wære,
+þonne hit sweordes ecg seðan scolde.
+Ad wæs geæfned ond icge gold
+ahæfen of horde. Herescyldinga
+betst beadorinca wæs on bæl gearu.
+æt þæm ade wæs eþgesyne
+swatfah syrce, swyn ealgylden,
+eofer irenheard, æþeling manig
+wundum awyrded; sume on wæle crungon.
+Het ða Hildeburh æt Hnæfes ade
+hire selfre sunu sweoloðe befæstan,
+banfatu bærnan ond on bæl don
+eame on eaxle. Ides gnornode,
+geomrode giddum. Guðrinc astah.
+Wand to wolcnum wælfyra mæst,
+hlynode for hlawe; hafelan multon,
+bengeato burston, ðonne blod ætspranc,
+laðbite lices. Lig ealle forswealg,
+gæsta gifrost, þara ðe þær guð fornam
+bega folces; wæs hira blæd scacen.
+Gewiton him ða wigend wica neosian,
+freondum befeallen, Frysland geseon,
+hamas ond heaburh. Hengest ða gyt
+wælfagne winter wunode mid Finne
+eal unhlitme. Eard gemunde,
+þeah þe he ne meahte on mere drifan
+hringedstefnan; holm storme weol,
+won wið winde, winter yþe beleac
+isgebinde, oþðæt oþer com
+gear in geardas, swa nu gyt deð,
+þa ðe syngales sele bewitiað,
+wuldortorhtan weder. ða wæs winter scacen,
+fæger foldan bearm. Fundode wrecca,
+gist of geardum; he to gyrnwræce
+swiðor þohte þonne to sælade,
+gif he torngemot þurhteon mihte
+þæt he Eotena bearn inne gemunde.
+Swa he ne forwyrnde woroldrædenne,
+þonne him Hunlafing hildeleoman,
+billa selest, on bearm dyde,
+þæs wæron mid Eotenum ecge cuðe.
+Swylce ferhðfrecan Fin eft begeat
+sweordbealo sliðen æt his selfes ham,
+siþðan grimne gripe Guðlaf ond Oslaf
+æfter sæsiðe, sorge, mændon,
+ætwiton weana dæl; ne meahte wæfre mod
+forhabban in hreþre. ða wæs heal roden
+feonda feorum, swilce Fin slægen,
+cyning on corþre, ond seo cwen numen.
+Sceotend Scyldinga to scypon feredon
+eal ingesteald eorðcyninges,
+swylce hie æt Finnes ham findan meahton
+sigla, searogimma. Hie on sælade
+drihtlice wif to Denum feredon,
+læddon to leodum. Leoð wæs asungen,
+gleomannes gyd. Gamen eft astah,
+beorhtode bencsweg; byrelas sealdon
+win of wunderfatum. þa cwom Wealhþeo forð
+gan under gyldnum beage, þær þa godan twegen
+sæton suhtergefæderan; þa gyt wæs hiera sib ætgædere,
+æghwylc oðrum trywe. Swylce þær Unferþ þyle
+æt fotum sæt frean Scyldinga; gehwylc hiora his ferhþe treowde,
+þæt he hæfde mod micel, þeah þe he his magum nære
+arfæst æt ecga gelacum. Spræc ða ides Scyldinga:
+Onfoh þissum fulle, freodrihten min,
+sinces brytta. þu on sælum wes,
+goldwine gumena, ond to Geatum spræc
+mildum wordum, swa sceal man don.
+Beo wið Geatas glæd, geofena gemyndig,
+nean ond feorran þu nu hafast.
+Me man sægde þæt þu ðe for sunu wolde
+hererinc habban. Heorot is gefælsod,
+beahsele beorhta; bruc þenden þu mote
+manigra medo, ond þinum magum læf
+folc ond rice, þonne ðu forð scyle
+metodsceaft seon. Ic minne can
+glædne Hroþulf, þæt he þa geogoðe wile
+arum healdan, gyf þu ær þonne he,
+wine Scildinga, worold oflætest;
+wene ic þæt he mid gode gyldan wille
+uncran eaferan, gif he þæt eal gemon,
+hwæt wit to willan ond to worðmyndum
+umborwesendum ær arna gefremedon.
+Hwearf þa bi bence þær hyre byre wæron,
+Hreðric ond Hroðmund, ond hæleþa bearn,
+giogoð ætgædere; þær se goda sæt,
+Beowulf Geata, be þæm gebroðrum twæm.
+Him wæs ful boren ond freondlaþu
+wordum bewægned, ond wunden gold
+estum geeawed, earmreade twa,
+hrægl ond hringas, healsbeaga mæst
+þara þe ic on foldan gefrægen hæbbe.
+Nænigne ic under swegle selran hyrde
+hordmaððum hæleþa, syþðan Hama ætwæg
+to þære byrhtan byrig Brosinga mene,
+sigle ond sincfæt; searoniðas fleah
+Eormenrices, geceas ecne ræd.
+þone hring hæfde Higelac Geata,
+nefa Swertinges, nyhstan siðe,
+siðþan he under segne sinc ealgode,
+wælreaf werede; hyne wyrd fornam,
+syþðan he for wlenco wean ahsode,
+fæhðe to Frysum. He þa frætwe wæg,
+eorclanstanas ofer yða ful,
+rice þeoden; he under rande gecranc.
+Gehwearf þa in Francna fæþm feorh cyninges,
+breostgewædu ond se beah somod;
+wyrsan wigfrecan wæl reafedon
+æfter guðsceare, Geata leode,
+hreawic heoldon. Heal swege onfeng.
+Wealhðeo maþelode, heo fore þæm werede spræc:
+Bruc ðisses beages, Beowulf leofa,
+hyse, mid hæle, ond þisses hrægles neot,
+þeodgestreona, ond geþeoh tela,
+cen þec mid cræfte ond þyssum cnyhtum wes
+lara liðe; ic þe þæs lean geman.
+Hafast þu gefered þæt ðe feor ond neah
+ealne wideferhþ weras ehtigað,
+efne swa side swa sæ bebugeð,
+windgeard, weallas. Wes þenden þu lifige,
+æþeling, eadig. Ic þe an tela
+sincgestreona. Beo þu suna minum
+dædum gedefe, dreamhealdende.
+Her is æghwylc eorl oþrum getrywe,
+modes milde, mandrihtne hold;
+þegnas syndon geþwære, þeod ealgearo,
+druncne dryhtguman doð swa ic bidde.
+Eode þa to setle. þær wæs symbla cyst;
+druncon win weras. Wyrd ne cuþon,
+geosceaft grimme, swa hit agangen wearð
+eorla manegum, syþðan æfen cwom
+ond him Hroþgar gewat to hofe sinum,
+rice to ræste. Reced weardode
+unrim eorla, swa hie oft ær dydon.
+Bencþelu beredon; hit geondbræded wearð
+beddum ond bolstrum. Beorscealca sum
+fus ond fæge fletræste gebeag.
+Setton him to heafdon hilderandas,
+bordwudu beorhtan; þær on bence wæs
+ofer æþelinge yþgesene
+heaþosteapa helm, hringed byrne,
+þrecwudu þrymlic. Wæs þeaw hyra
+þæt hie oft wæron an wig gearwe,
+ge æt ham ge on herge, ge gehwæþer þara,
+efne swylce mæla swylce hira mandryhtne
+þearf gesælde; wæs seo þeod tilu.
+Sigon þa to slæpe. Sum sare angeald
+æfenræste, swa him ful oft gelamp,
+siþðan goldsele Grendel warode,
+unriht æfnde, oþþæt ende becwom,
+swylt æfter synnum. þæt gesyne wearþ,
+widcuþ werum, þætte wrecend þa gyt
+lifde æfter laþum, lange þrage,
+æfter guðceare. Grendles modor,
+ides, aglæcwif, yrmþe gemunde,
+se þe wæteregesan wunian scolde,
+cealde streamas, siþðan Cain wearð
+to ecgbanan angan breþer,
+fæderenmæge; he þa fag gewat,
+morþre gemearcod, mandream fleon,
+westen warode. þanon woc fela
+geosceaftgasta; wæs þæra Grendel sum,
+heorowearh hetelic, se æt Heorote fand
+wæccendne wer wiges bidan.
+þær him aglæca ætgræpe wearð;
+hwæþre he gemunde mægenes strenge,
+gimfæste gife ðe him god sealde,
+ond him to anwaldan are gelyfde,
+frofre ond fultum; ðy he þone feond ofercwom,
+gehnægde helle gast. þa he hean gewat,
+dreame bedæled, deaþwic seon,
+mancynnes feond, ond his modor þa gyt,
+gifre ond galgmod, gegan wolde
+sorhfulne sið, sunu deað wrecan.
+Com þa to Heorote, ðær Hringdene
+geond þæt sæld swæfun. þa ðær sona wearð
+edhwyrft eorlum, siþðan inne fealh
+Grendles modor. Wæs se gryre læssa
+efne swa micle swa bið mægþa cræft,
+wiggryre wifes, be wæpnedmen,
+þonne heoru bunden, hamere geþuren,
+sweord swate fah swin ofer helme
+ecgum dyhttig andweard scireð.
+þa wæs on healle heardecg togen
+sweord ofer setlum, sidrand manig
+hafen handa fæst; helm ne gemunde,
+byrnan side, þa hine se broga angeat.
+Heo wæs on ofste, wolde ut þanon,
+feore beorgan, þa heo onfunden wæs.
+Hraðe heo æþelinga anne hæfde
+fæste befangen, þa heo to fenne gang.
+Se wæs Hroþgare hæleþa leofost
+on gesiðes had be sæm tweonum,
+rice randwiga, þone ðe heo on ræste abreat,
+blædfæstne beorn. Næs Beowulf ðær,
+ac wæs oþer in ær geteohhod
+æfter maþðumgife mærum Geate.
+Hream wearð in Heorote; heo under heolfre genam
+cuþe folme; cearu wæs geniwod,
+geworden in wicun. Ne wæs þæt gewrixle til,
+þæt hie on ba healfa bicgan scoldon
+freonda feorum. þa wæs frod cyning,
+har hilderinc, on hreon mode,
+syðþan he aldorþegn unlyfigendne,
+þone deorestan deadne wisse.
+Hraþe wæs to bure Beowulf fetod,
+sigoreadig secg. Samod ærdæge
+eode eorla sum, æþele cempa
+self mid gesiðum þær se snotera bad,
+hwæþer him alwalda æfre wille
+æfter weaspelle wyrpe gefremman.
+Gang ða æfter flore fyrdwyrðe man
+mid his handscale healwudu dynede,
+þæt he þone wisan wordum nægde
+frean Ingwina, frægn gif him wære
+æfter neodlaðum niht getæse.
+Hroðgar maþelode, helm Scyldinga:
+Ne frin þu æfter sælum. Sorh is geniwod
+Denigea leodum. Dead is æschere,
+Yrmenlafes yldra broþor,
+min runwita ond min rædbora,
+eaxlgestealla, ðonne we on orlege
+hafelan weredon, þonne hniton feþan,
+eoferas cynsedan. Swylc scolde eorl wesan,
+æþeling ærgod, swylc æschere wæs.
+Wearð him on Heorote to handbanan
+wælgæst wæfre; ic ne wat hwæder
+atol æse wlanc eftsiðas teah,
+fylle gefægnod. Heo þa fæhðe wræc
+þe þu gystranniht Grendel cwealdest
+þurh hæstne had heardum clammum,
+forþan he to lange leode mine
+wanode ond wyrde. He æt wige gecrang
+ealdres scyldig, ond nu oþer cwom
+mihtig manscaða, wolde hyre mæg wrecan,
+ge feor hafað fæhðe gestæled
+(þæs þe þincean mæg þegne monegum,
+se þe æfter sincgyfan on sefan greoteþ),
+hreþerbealo hearde; nu seo hand ligeð,
+se þe eow welhwylcra wilna dohte.
+Ic þæt londbuend, leode mine,
+selerædende, secgan hyrde
+þæt hie gesawon swylce twegen
+micle mearcstapan moras healdan,
+ellorgæstas. ðæra oðer wæs,
+þæs þe hie gewislicost gewitan meahton,
+idese onlicnæs; oðer earmsceapen
+on weres wæstmum wræclastas træd,
+næfne he wæs mara þonne ænig man oðer;
+þone on geardagum Grendel nemdon
+foldbuende. No hie fæder cunnon,
+hwæþer him ænig wæs ær acenned
+dyrnra gasta. Hie dygel lond
+warigeað, wulfhleoþu, windige næssas,
+frecne fengelad, ðær fyrgenstream
+under næssa genipu niþer gewiteð,
+flod under foldan. Nis þæt feor heonon
+milgemearces þæt se mere standeð;
+ofer þæm hongiað hrinde bearwas,
+wudu wyrtum fæst wæter oferhelmað.
+þær mæg nihta gehwæm niðwundor seon,
+fyr on flode. No þæs frod leofað
+gumena bearna, þæt þone grund wite;
+ðeah þe hæðstapa hundum geswenced,
+heorot hornum trum, holtwudu sece,
+feorran geflymed, ær he feorh seleð,
+aldor on ofre, ær he in wille
+hafelan hydan. Nis þæt heoru stow!
+þonon yðgeblond up astigeð
+won to wolcnum, þonne wind styreþ,
+lað gewidru, oðþæt lyft drysmaþ,
+roderas reotað. Nu is se ræd gelang
+eft æt þe anum. Eard git ne const,
+frecne stowe, ðær þu findan miht
+felasinnigne secg; sec gif þu dyrre.
+Ic þe þa fæhðe feo leanige,
+ealdgestreonum, swa ic ær dyde,
+wundnum golde, gyf þu on weg cymest."
+Beowulf maþelode, bearn Ecgþeowes:
+"Ne sorga, snotor guma; selre bið æghwæm
+þæt he his freond wrece, þonne he fela murne.
+Ure æghwylc sceal ende gebidan
+worolde lifes; wyrce se þe mote
+domes ær deaþe; þæt bið drihtguman
+unlifgendum æfter selest.
+Aris, rices weard, uton raþe feran
+Grendles magan gang sceawigan.
+Ic hit þe gehate, no he on helm losaþ,
+ne on foldan fæþm, ne on fyrgenholt,
+ne on gyfenes grund, ga þær he wille.
+ðys dogor þu geþyld hafa
+weana gehwylces, swa ic þe wene to."
+Ahleop ða se gomela, gode þancode,
+mihtigan drihtne, þæs se man gespræc.
+þa wæs Hroðgare hors gebæted,
+wicg wundenfeax. Wisa fengel
+geatolic gende; gumfeþa stop
+lindhæbbendra. Lastas wæron
+æfter waldswaþum wide gesyne,
+gang ofer grundas, þær heo gegnum for
+ofer myrcan mor, magoþegna bær
+þone selestan sawolleasne
+þara þe mid Hroðgare ham eahtode.
+Ofereode þa æþelinga bearn
+steap stanhliðo, stige nearwe,
+enge anpaðas, uncuð gelad,
+neowle næssas, nicorhusa fela.
+He feara sum beforan gengde
+wisra monna wong sceawian,
+oþþæt he færinga fyrgenbeamas
+ofer harne stan hleonian funde,
+wynleasne wudu; wæter under stod
+dreorig ond gedrefed. Denum eallum wæs,
+winum Scyldinga, weorce on mode
+to geþolianne, ðegne monegum,
+oncyð eorla gehwæm, syðþan æscheres
+on þam holmclife hafelan metton.
+Flod blode weol (folc to sægon),
+hatan heolfre. Horn stundum song
+fuslic fyrdleoð. Feþa eal gesæt.
+Gesawon ða æfter wætere wyrmcynnes fela,
+sellice sædracan, sund cunnian,
+swylce on næshleoðum nicras licgean,
+ða on undernmæl oft bewitigað
+sorhfulne sið on seglrade,
+wyrmas ond wildeor; hie on weg hruron,
+bitere ond gebolgne, bearhtm ongeaton,
+guðhorn galan. Sumne Geata leod
+of flanbogan feores getwæfde,
+yðgewinnes, þæt him on aldre stod
+herestræl hearda; he on holme wæs
+sundes þe sænra, ðe hyne swylt fornam.
+Hræþe wearð on yðum mid eoferspreotum
+heorohocyhtum hearde genearwod,
+niða genæged, ond on næs togen,
+wundorlic wægbora; weras sceawedon
+gryrelicne gist. Gyrede hine Beowulf
+eorlgewædum, nalles for ealdre mearn.
+Scolde herebyrne hondum gebroden,
+sid ond searofah, sund cunnian,
+seo ðe bancofan beorgan cuþe,
+þæt him hildegrap hreþre ne mihte,
+eorres inwitfeng, aldre gesceþðan;
+ac se hwita helm hafelan werede,
+se þe meregrundas mengan scolde,
+secan sundgebland since geweorðad,
+befongen freawrasnum, swa hine fyrndagum
+worhte wæpna smið, wundrum teode,
+besette swinlicum, þæt hine syðþan no
+brond ne beadomecas bitan ne meahton.
+Næs þæt þonne mætost mægenfultuma
+þæt him on ðearfe lah ðyle Hroðgares;
+wæs þæm hæftmece Hrunting nama.
+þæt wæs an foran ealdgestreona;
+ecg wæs iren, atertanum fah,
+ahyrded heaþoswate; næfre hit æt hilde ne swac
+manna ængum þara þe hit mid mundum bewand,
+se ðe gryresiðas gegan dorste,
+folcstede fara; næs þæt forma sið
+þæt hit ellenweorc æfnan scolde.
+Huru ne gemunde mago Ecglafes,
+eafoþes cræftig, þæt he ær gespræc
+wine druncen, þa he þæs wæpnes onlah
+selran sweordfrecan. Selfa ne dorste
+under yða gewin aldre geneþan,
+drihtscype dreogan; þær he dome forleas,
+ellenmærðum. Ne wæs þæm oðrum swa,
+syðþan he hine to guðe gegyred hæfde.
+Beowulf maðelode, bearn Ecgþeowes:
+"Geþenc nu, se mæra maga Healfdenes,
+snottra fengel, nu ic eom siðes fus,
+goldwine gumena, hwæt wit geo spræcon,
+gif ic æt þearfe þinre scolde
+aldre linnan, þæt ðu me a wære
+forðgewitenum on fæder stæle.
+Wes þu mundbora minum magoþegnum,
+hondgesellum, gif mec hild nime;
+swylce þu ða madmas þe þu me sealdest,
+Hroðgar leofa, Higelace onsend.
+Mæg þonne on þæm golde ongitan Geata dryhten,
+geseon sunu Hrædles, þonne he on þæt sinc starað,
+þæt ic gumcystum godne funde
+beaga bryttan, breac þonne moste.
+Ond þu Unferð læt ealde lafe,
+wrætlic wægsweord, widcuðne man
+heardecg habban; ic me mid Hruntinge
+dom gewyrce, oþðe mec deað nimeð."
+æfter þæm wordum Wedergeata leod
+efste mid elne, nalas ondsware
+bidan wolde; brimwylm onfeng
+hilderince. ða wæs hwil dæges
+ær he þone grundwong ongytan mehte.
+Sona þæt onfunde se ðe floda begong
+heorogifre beheold hund missera,
+grim ond grædig, þæt þær gumena sum
+ælwihta eard ufan cunnode.
+Grap þa togeanes, guðrinc gefeng
+atolan clommum. No þy ær in gescod
+halan lice; hring utan ymbbearh,
+þæt heo þone fyrdhom ðurhfon ne mihte,
+locene leoðosyrcan laþan fingrum.
+Bær þa seo brimwylf, þa heo to botme com,
+hringa þengel to hofe sinum,
+swa he ne mihte, no he þæs modig wæs,
+wæpna gewealdan, ac hine wundra þæs fela
+swencte on sunde, sædeor monig
+hildetuxum heresyrcan bræc,
+ehton aglæcan. ða se eorl ongeat
+þæt he in niðsele nathwylcum wæs,
+þær him nænig wæter wihte ne sceþede,
+ne him for hrofsele hrinan ne mehte
+færgripe flodes; fyrleoht geseah,
+blacne leoman, beorhte scinan.
+Ongeat þa se goda grundwyrgenne,
+merewif mihtig; mægenræs forgeaf
+hildebille, hond sweng ne ofteah,
+þæt hire on hafelan hringmæl agol
+grædig guðleoð. ða se gist onfand
+þæt se beadoleoma bitan nolde,
+aldre sceþðan, ac seo ecg geswac
+ðeodne æt þearfe; ðolode ær fela
+hondgemota, helm oft gescær,
+fæges fyrdhrægl; ða wæs forma sið
+deorum madme, þæt his dom alæg.
+Eft wæs anræd, nalas elnes læt,
+mærða gemyndig mæg Hylaces.
+Wearp ða wundenmæl wrættum gebunden
+yrre oretta, þæt hit on eorðan læg,
+stið ond stylecg; strenge getruwode,
+mundgripe mægenes. Swa sceal man don,
+þonne he æt guðe gegan þenceð
+longsumne lof, na ymb his lif cearað.
+Gefeng þa be eaxle (nalas for fæhðe mearn)
+Guðgeata leod Grendles modor;
+brægd þa beadwe heard, þa he gebolgen wæs,
+feorhgeniðlan, þæt heo on flet gebeah.
+Heo him eft hraþe andlean forgeald
+grimman grapum ond him togeanes feng;
+oferwearp þa werigmod wigena strengest,
+feþecempa, þæt he on fylle wearð.
+Ofsæt þa þone selegyst ond hyre seax geteah,
+brad ond brunecg, wolde hire bearn wrecan,
+angan eaferan. Him on eaxle læg
+breostnet broden; þæt gebearh feore,
+wið ord ond wið ecge ingang forstod.
+Hæfde ða forsiðod sunu Ecgþeowes
+under gynne grund, Geata cempa,
+nemne him heaðobyrne helpe gefremede,
+herenet hearde, ond halig god
+geweold wigsigor; witig drihten,
+rodera rædend, hit on ryht gesced
+yðelice, syþðan he eft astod.
+Geseah ða on searwum sigeeadig bil,
+eald sweord eotenisc, ecgum þyhtig,
+wigena weorðmynd; þæt wæs wæpna cyst,
+buton hit wæs mare ðonne ænig mon oðer
+to beadulace ætberan meahte,
+god ond geatolic, giganta geweorc.
+He gefeng þa fetelhilt, freca Scyldinga
+hreoh ond heorogrim hringmæl gebrægd,
+aldres orwena, yrringa sloh,
+þæt hire wið halse heard grapode,
+banhringas bræc. Bil eal ðurhwod
+fægne flæschoman; heo on flet gecrong.
+Sweord wæs swatig, secg weorce gefeh.
+Lixte se leoma, leoht inne stod,
+efne swa of hefene hadre scineð
+rodores candel. He æfter recede wlat;
+hwearf þa be wealle, wæpen hafenade
+heard be hiltum Higelaces ðegn,
+yrre ond anræd. Næs seo ecg fracod
+hilderince, ac he hraþe wolde
+Grendle forgyldan guðræsa fela
+ðara þe he geworhte to Westdenum
+oftor micle ðonne on ænne sið,
+þonne he Hroðgares heorðgeneatas
+sloh on sweofote, slæpende fræt
+folces Denigea fyftyne men
+ond oðer swylc ut offerede,
+laðlicu lac. He him þæs lean forgeald,
+reþe cempa, to ðæs þe he on ræste geseah
+guðwerigne Grendel licgan
+aldorleasne, swa him ær gescod
+hild æt Heorote. Hra wide sprong,
+syþðan he æfter deaðe drepe þrowade,
+heorosweng heardne, ond hine þa heafde becearf.
+Sona þæt gesawon snottre ceorlas,
+þa ðe mid Hroðgare on holm wliton,
+þæt wæs yðgeblond eal gemenged,
+brim blode fah. Blondenfeaxe,
+gomele ymb godne, ongeador spræcon
+þæt hig þæs æðelinges eft ne wendon
+þæt he sigehreðig secean come
+mærne þeoden; þa ðæs monige gewearð
+þæt hine seo brimwylf abroten hæfde.
+ða com non dæges. Næs ofgeafon
+hwate Scyldingas; gewat him ham þonon
+goldwine gumena. Gistas setan
+modes seoce ond on mere staredon,
+wiston ond ne wendon þæt hie heora winedrihten
+selfne gesawon. þa þæt sweord ongan
+æfter heaþoswate hildegicelum,
+wigbil wanian. þæt wæs wundra sum,
+þæt hit eal gemealt ise gelicost,
+ðonne forstes bend fæder onlæteð,
+onwindeð wælrapas, se geweald hafað
+sæla ond mæla; þæt is soð metod.
+Ne nom he in þæm wicum, Wedergeata leod,
+maðmæhta ma, þeh he þær monige geseah,
+buton þone hafelan ond þa hilt somod
+since fage. Sweord ær gemealt,
+forbarn brodenmæl; wæs þæt blod to þæs hat,
+ættren ellorgæst se þær inne swealt.
+Sona wæs on sunde se þe ær æt sæcce gebad
+wighryre wraðra, wæter up þurhdeaf.
+Wæron yðgebland eal gefælsod,
+eacne eardas, þa se ellorgast
+oflet lifdagas ond þas lænan gesceaft.
+Com þa to lande lidmanna helm
+swiðmod swymman; sælace gefeah,
+mægenbyrþenne þara þe he him mid hæfde.
+Eodon him þa togeanes, gode þancodon,
+ðryðlic þegna heap, þeodnes gefegon,
+þæs þe hi hyne gesundne geseon moston.
+ða wæs of þæm hroran helm ond byrne
+lungre alysed. Lagu drusade,
+wæter under wolcnum, wældreore fag.
+Ferdon forð þonon feþelastum
+ferhþum fægne, foldweg mæton,
+cuþe stræte. Cyningbalde men
+from þæm holmclife hafelan bæron
+earfoðlice heora æghwæþrum,
+felamodigra; feower scoldon
+on þæm wælstenge weorcum geferian
+to þæm goldsele Grendles heafod,
+oþðæt semninga to sele comon
+frome fyrdhwate feowertyne
+Geata gongan; gumdryhten mid
+modig on gemonge meodowongas træd.
+ða com in gan ealdor ðegna,
+dædcene mon dome gewurþad,
+hæle hildedeor, Hroðgar gretan.
+þa wæs be feaxe on flet boren
+Grendles heafod, þær guman druncon,
+egeslic for eorlum ond þære idese mid,
+wliteseon wrætlic; weras on sawon.
+Beowulf maþelode, bearn Ecgþeowes:
+"Hwæt! we þe þas sælac, sunu Healfdenes,
+leod Scyldinga, lustum brohton
+tires to tacne, þe þu her to locast.
+Ic þæt unsofte ealdre gedigde
+wigge under wætere, weorc geneþde
+earfoðlice; ætrihte wæs
+guð getwæfed, nymðe mec god scylde.
+Ne meahte ic æt hilde mid Hruntinge
+wiht gewyrcan, þeah þæt wæpen duge;
+ac me geuðe ylda waldend
+þæt ic on wage geseah wlitig hangian
+eald sweord eacen (oftost wisode
+winigea leasum), þæt ic ðy wæpne gebræd.
+Ofsloh ða æt þære sæcce, þa me sæl ageald,
+huses hyrdas. þa þæt hildebil
+forbarn brogdenmæl, swa þæt blod gesprang,
+hatost heaþoswata. Ic þæt hilt þanan
+feondum ætferede, fyrendæda wræc,
+deaðcwealm Denigea, swa hit gedefe wæs.
+Ic hit þe þonne gehate, þæt þu on Heorote most
+sorhleas swefan mid þinra secga gedryht
+ond þegna gehwylc þinra leoda,
+duguðe ond iogoþe, þæt þu him ondrædan ne þearft,
+þeoden Scyldinga, on þa healfe,
+aldorbealu eorlum, swa þu ær dydest."
+ða wæs gylden hilt gamelum rince,
+harum hildfruman, on hand gyfen,
+enta ærgeweorc; hit on æht gehwearf
+æfter deofla hryre Denigea frean,
+wundorsmiþa geweorc, ond þa þas worold ofgeaf
+gromheort guma, godes ondsaca,
+morðres scyldig, ond his modor eac,
+on geweald gehwearf woroldcyninga
+ðæm selestan be sæm tweonum
+ðara þe on Scedenigge sceattas dælde.
+Hroðgar maðelode, hylt sceawode,
+ealde lafe, on ðæm wæs or writen
+fyrngewinnes, syðþan flod ofsloh,
+gifen geotende, giganta cyn
+(frecne geferdon); þæt wæs fremde þeod
+ecean dryhtne; him þæs endelean
+þurh wæteres wylm waldend sealde.
+Swa wæs on ðæm scennum sciran goldes
+þurh runstafas rihte gemearcod,
+geseted ond gesæd hwam þæt sweord geworht,
+irena cyst, ærest wære,
+wreoþenhilt ond wyrmfah. ða se wisa spræc
+sunu Healfdenes (swigedon ealle):
+"þæt, la, mæg secgan se þe soð ond riht
+fremeð on folce, feor eal gemon,
+eald OEweard, þæt ðes eorl wære
+geboren betera! Blæd is aræred
+geond widwegas, wine min Beowulf,
+ðin ofer þeoda gehwylce. Eal þu hit geþyldum healdest,
+mægen mid modes snyttrum. Ic þe sceal mine gelæstan
+freode, swa wit furðum spræcon. ðu scealt to frofre weorþan
+eal langtwidig leodum þinum,
+hæleðum to helpe. Ne wearð Heremod swa
+eaforum Ecgwelan, Arscyldingum;
+ne geweox he him to willan, ac to wælfealle
+ond to deaðcwalum Deniga leodum;
+breat bolgenmod beodgeneatas,
+eaxlgesteallan, oþþæt he ana hwearf,
+mære þeoden, mondreamum from.
+ðeah þe hine mihtig god mægenes wynnum,
+eafeþum stepte, ofer ealle men
+forð gefremede, hwæþere him on ferhþe greow
+breosthord blodreow. Nallas beagas geaf
+Denum æfter dome; dreamleas gebad
+þæt he þæs gewinnes weorc þrowade,
+leodbealo longsum. ðu þe lær be þon,
+gumcyste ongit; ic þis gid be þe
+awræc wintrum frod. Wundor is to secganne
+hu mihtig god manna cynne
+þurh sidne sefan snyttru bryttað,
+eard ond eorlscipe; he ah ealra geweald.
+Hwilum he on lufan læteð hworfan
+monnes modgeþonc mæran cynnes,
+seleð him on eþle eorþan wynne
+to healdanne, hleoburh wera,
+gedeð him swa gewealdene worolde dælas,
+side rice, þæt he his selfa ne mæg
+for his unsnyttrum ende geþencean.
+Wunað he on wiste; no hine wiht dweleð
+adl ne yldo, ne him inwitsorh
+on sefan sweorceð, ne gesacu ohwær
+ecghete eoweð, ac him eal worold
+wendeð on willan (he þæt wyrse ne con),
+oðþæt him on innan oferhygda dæl
+weaxeð ond wridað. þonne se weard swefeð,
+sawele hyrde; bið se slæp to fæst,
+bisgum gebunden, bona swiðe neah,
+se þe of flanbogan fyrenum sceoteð.
+þonne bið on hreþre under helm drepen
+biteran stræle (him bebeorgan ne con),
+wom wundorbebodum wergan gastes;
+þinceð him to lytel þæt he lange heold,
+gytsað gromhydig, nallas on gylp seleð
+fædde beagas, ond he þa forðgesceaft
+forgyteð ond forgymeð, þæs þe him ær god sealde,
+wuldres waldend, weorðmynda dæl.
+Hit on endestæf eft gelimpeð
+þæt se lichoma læne gedreoseð,
+fæge gefealleð; fehð oþer to,
+se þe unmurnlice madmas dæleþ,
+eorles ærgestreon, egesan ne gymeð.
+Bebeorh þe ðone bealonið, Beowulf leofa,
+secg betsta, ond þe þæt selre geceos,
+ece rædas; oferhyda ne gym,
+mære cempa. Nu is þines mægnes blæd
+ane hwile. Eft sona bið
+þæt þec adl oððe ecg eafoþes getwæfeð,
+oððe fyres feng, oððe flodes wylm,
+oððe gripe meces, oððe gares fliht,
+oððe atol yldo; oððe eagena bearhtm
+forsiteð ond forsworceð; semninga bið
+þæt ðec, dryhtguma, deað oferswyðeð.
+Swa ic Hringdena hund missera
+weold under wolcnum ond hig wigge beleac
+manigum mægþa geond þysne middangeard,
+æscum ond ecgum, þæt ic me ænigne
+under swegles begong gesacan ne tealde.
+Hwæt, me þæs on eþle edwenden cwom,
+gyrn æfter gomene, seoþðan Grendel wearð,
+ealdgewinna, ingenga min;
+ic þære socne singales wæg
+modceare micle. þæs sig metode þanc,
+ecean dryhtne, þæs ðe ic on aldre gebad
+þæt ic on þone hafelan heorodreorigne
+ofer ealdgewin eagum starige!
+Ga nu to setle, symbelwynne dreoh
+wigge weorþad; unc sceal worn fela
+maþma gemænra, siþðan morgen bið."
+Geat wæs glædmod, geong sona to
+setles neosan, swa se snottra heht.
+þa wæs eft swa ær ellenrofum
+fletsittendum fægere gereorded
+niowan stefne. Nihthelm geswearc
+deorc ofer dryhtgumum. Duguð eal aras.
+Wolde blondenfeax beddes neosan,
+gamela Scylding. Geat unigmetes wel,
+rofne randwigan, restan lyste;
+sona him seleþegn siðes wergum,
+feorrancundum, forð wisade,
+se for andrysnum ealle beweotede
+þegnes þearfe, swylce þy dogore
+heaþoliðende habban scoldon.
+Reste hine þa rumheort; reced hliuade
+geap ond goldfah; gæst inne swæf
+oþþæt hrefn blaca heofones wynne
+bliðheort bodode. ða com beorht scacan
+scaþan onetton,
+wæron æþelingas eft to leodum
+fuse to farenne; wolde feor þanon
+cuma collenferhð ceoles neosan.
+Heht þa se hearda Hrunting beran
+sunu Ecglafes, heht his sweord niman,
+leoflic iren; sægde him þæs leanes þanc,
+cwæð, he þone guðwine godne tealde,
+wigcræftigne, nales wordum log
+meces ecge; þæt wæs modig secg.
+Ond þa siðfrome, searwum gearwe
+wigend wæron; eode weorð Denum
+æþeling to yppan, þær se oþer wæs,
+hæle hildedeor Hroðgar grette.
+Beowulf maþelode, bearn Ecgþeowes:
+"Nu we sæliðend secgan wyllað,
+feorran cumene, þæt we fundiaþ
+Higelac secan. Wæron her tela
+willum bewenede; þu us wel dohtest.
+Gif ic þonne on eorþan owihte mæg
+þinre modlufan maran tilian,
+gumena dryhten, ðonne ic gyt dyde,
+guðgeweorca, ic beo gearo sona.
+Gif ic þæt gefricge ofer floda begang,
+þæt þec ymbsittend egesan þywað,
+swa þec hetende hwilum dydon,
+ic ðe þusenda þegna bringe,
+hæleþa to helpe. Ic on Higelac wat,
+Geata dryhten, þeah ðe he geong sy,
+folces hyrde, þæt he mec fremman wile
+wordum ond worcum, þæt ic þe wel herige
+ond þe to geoce garholt bere,
+mægenes fultum, þær ðe bið manna þearf.
+Gif him þonne Hreþric to hofum Geata
+geþingeð, þeodnes bearn, he mæg þær fela
+freonda findan; feorcyþðe beoð
+selran gesohte þæm þe him selfa deah."
+Hroðgar maþelode him on ondsware:
+"þe þa wordcwydas wigtig drihten
+on sefan sende; ne hyrde ic snotorlicor
+on swa geongum feore guman þingian.
+þu eart mægenes strang ond on mode frod,
+wis wordcwida. Wen ic talige,
+gif þæt gegangeð, þæt ðe gar nymeð,
+hild heorugrimme, Hreþles eaferan,
+adl oþðe iren ealdor ðinne,
+folces hyrde, ond þu þin feorh hafast,
+þæt þe Sægeatas selran næbben
+to geceosenne cyning ænigne,
+hordweard hæleþa, gyf þu healdan wylt
+maga rice. Me þin modsefa
+licað leng swa wel, leofa Beowulf.
+Hafast þu gefered þæt þam folcum sceal,
+Geata leodum ond Gardenum,
+sib gemæne, ond sacu restan,
+inwitniþas, þe hie ær drugon,
+wesan, þenden ic wealde widan rices,
+maþmas gemæne, manig oþerne
+godum gegretan ofer ganotes bæð;
+sceal hringnaca ofer heafu bringan
+lac ond luftacen. Ic þa leode wat
+ge wið feond ge wið freond fæste geworhte,
+æghwæs untæle ealde wisan."
+ða git him eorla hleo inne gesealde,
+mago Healfdenes, maþmas [XII];
+het hine mid þæm lacum leode swæse
+secean on gesyntum, snude eft cuman.
+Gecyste þa cyning æþelum god,
+þeoden Scyldinga, ðegn betstan
+ond be healse genam; hruron him tearas,
+blondenfeaxum. Him wæs bega wen,
+ealdum infrodum, oþres swiðor,
+þæt hie seoððan no geseon moston,
+modige on meþle. Wæs him se man to þon leof
+þæt he þone breostwylm forberan ne mehte,
+ac him on hreþre hygebendum fæst
+æfter deorum men dyrne langað
+beorn wið blode. Him Beowulf þanan,
+guðrinc goldwlanc, græsmoldan træd
+since hremig; sægenga bad
+agendfrean, se þe on ancre rad.
+þa wæs on gange gifu Hroðgares
+oft geæhted; þæt wæs an cyning,
+æghwæs orleahtre, oþþæt hine yldo benam
+mægenes wynnum, se þe oft manegum scod.
+Cwom þa to flode felamodigra,
+hægstealdra heap, hringnet bæron,
+locene leoðosyrcan. Landweard onfand
+eftsið eorla, swa he ær dyde;
+no he mid hearme of hliðes nosan
+gæstas grette, ac him togeanes rad,
+cwæð þæt wilcuman Wedera leodum
+scaþan scirhame to scipe foron.
+þa wæs on sande sægeap naca
+hladen herewædum, hringedstefna,
+mearum ond maðmum; mæst hlifade
+ofer Hroðgares hordgestreonum.
+He þæm batwearde bunden golde
+swurd gesealde, þæt he syðþan wæs
+on meodubence maþme þy weorþra,
+yrfelafe. Gewat him on naca
+drefan deop wæter, Dena land ofgeaf.
+þa wæs be mæste merehrægla sum,
+segl sale fæst; sundwudu þunede.
+No þær wegflotan wind ofer yðum
+siðes getwæfde; sægenga for,
+fleat famigheals forð ofer yðe,
+bundenstefna ofer brimstreamas,
+þæt hie Geata clifu ongitan meahton,
+cuþe næssas. Ceol up geþrang
+lyftgeswenced, on lande stod.
+Hraþe wæs æt holme hyðweard geara,
+se þe ær lange tid leofra manna
+fus æt faroðe feor wlatode;
+sælde to sande sidfæþme scip,
+oncerbendum fæst, þy læs hym yþa ðrym
+wudu wynsuman forwrecan meahte.
+Het þa up beran æþelinga gestreon,
+frætwe ond fætgold; næs him feor þanon
+to gesecanne sinces bryttan,
+Higelac Hreþling, þær æt ham wunað
+selfa mid gesiðum sæwealle neah.
+Bold wæs betlic, bregorof cyning,
+heah in healle, Hygd swiðe geong,
+wis, welþungen, þeah ðe wintra lyt
+under burhlocan gebiden hæbbe,
+Hæreþes dohtor; næs hio hnah swa þeah,
+ne to gneað gifa Geata leodum,
+maþmgestreona. Mod þryðo wæg,
+fremu folces cwen, firen ondrysne.
+Nænig þæt dorste deor geneþan
+swæsra gesiða, nefne sinfrea,
+þæt hire an dæges eagum starede,
+ac him wælbende weotode tealde
+handgewriþene; hraþe seoþðan wæs
+æfter mundgripe mece geþinged,
+þæt hit sceadenmæl scyran moste,
+cwealmbealu cyðan. Ne bið swylc cwenlic þeaw
+idese to efnanne, þeah ðe hio ænlicu sy,
+þætte freoðuwebbe feores onsæce
+æfter ligetorne leofne mannan.
+Huru þæt onhohsnode Hemminges mæg;
+ealodrincende oðer sædan,
+þæt hio leodbealewa læs gefremede,
+inwitniða, syððan ærest wearð
+gyfen goldhroden geongum cempan,
+æðelum diore, syððan hio Offan flet
+ofer fealone flod be fæder lare
+siðe gesohte; ðær hio syððan well
+in gumstole, gode, mære,
+lifgesceafta lifigende breac,
+hiold heahlufan wið hæleþa brego,
+ealles moncynnes mine gefræge
+þone selestan bi sæm tweonum,
+eormencynnes. Forðam Offa wæs
+geofum ond guðum, garcene man,
+wide geweorðod, wisdome heold
+eðel sinne; þonon Eomer woc
+hæleðum to helpe, Hemminges mæg,
+nefa Garmundes, niða cræftig.
+Gewat him ða se hearda mid his hondscole
+sylf æfter sande sæwong tredan,
+wide waroðas. Woruldcandel scan,
+sigel suðan fus. Hi sið drugon,
+elne geeodon, to ðæs ðe eorla hleo,
+bonan Ongenþeoes burgum in innan,
+geongne guðcyning godne gefrunon
+hringas dælan. Higelace wæs
+sið Beowulfes snude gecyðed,
+þæt ðær on worðig wigendra hleo,
+lindgestealla, lifigende cwom,
+heaðolaces hal to hofe gongan.
+Hraðe wæs gerymed, swa se rica bebead,
+feðegestum flet innanweard.
+Gesæt þa wið sylfne se ða sæcce genæs,
+mæg wið mæge, syððan mandryhten
+þurh hleoðorcwyde holdne gegrette,
+meaglum wordum. Meoduscencum hwearf
+geond þæt healreced Hæreðes dohtor,
+lufode ða leode, liðwæge bær
+hæleðum to handa. Higelac ongan
+sinne geseldan in sele þam hean
+fægre fricgcean (hyne fyrwet bræc,
+hwylce Sægeata siðas wæron):
+"Hu lomp eow on lade, leofa Biowulf,
+þa ðu færinga feorr gehogodest
+sæcce secean ofer sealt wæter,
+hilde to Hiorote? Ac ðu Hroðgare
+widcuðne wean wihte gebettest,
+mærum ðeodne? Ic ðæs modceare
+sorhwylmum seað, siðe ne truwode
+leofes mannes; ic ðe lange bæd
+þæt ðu þone wælgæst wihte ne grette,
+lete Suðdene sylfe geweorðan
+guðe wið Grendel. Gode ic þanc secge
+þæs ðe ic ðe gesundne geseon moste."
+Biowulf maðelode, bearn Ecgðioes:
+"þæt is undyrne, dryhten Higelac,
+micel gemeting, monegum fira,
+hwylc orleghwil uncer Grendles
+wearð on ðam wange, þær he worna fela
+Sigescyldingum sorge gefremede,
+yrmðe to aldre. Ic ðæt eall gewræc,
+swa begylpan ne þearf Grendeles maga
+ænig ofer eorðan uhthlem þone,
+se ðe lengest leofað laðan cynnes,
+facne bifongen. Ic ðær furðum cwom
+to ðam hringsele Hroðgar gretan;
+sona me se mæra mago Healfdenes,
+syððan he modsefan minne cuðe,
+wið his sylfes sunu setl getæhte.
+Weorod wæs on wynne; ne seah ic widan feorh
+under heofones hwealf healsittendra
+medudream maran. Hwilum mæru cwen,
+friðusibb folca, flet eall geondhwearf,
+bædde byre geonge; oft hio beahwriðan
+secge sealde, ær hie to setle geong.
+Hwilum for duguðe dohtor Hroðgares
+eorlum on ende ealuwæge bær;
+þa ic Freaware fletsittende
+nemnan hyrde, þær hio nægled sinc
+hæleðum sealde. Sio gehaten is,
+geong, goldhroden, gladum suna Frodan;
+hafað þæs geworden wine Scyldinga,
+rices hyrde, ond þæt ræd talað,
+þæt he mid ðy wife wælfæhða dæl,
+sæcca gesette. Oft seldan hwær
+æfter leodhryre lytle hwile
+bongar bugeð, þeah seo bryd duge!
+Mæg þæs þonne ofþyncan ðeodne Heaðobeardna
+ond þegna gehwam þara leoda,
+þonne he mid fæmnan on flett gæð,
+dryhtbearn Dena, duguða biwenede;
+on him gladiað gomelra lafe,
+heard ond hringmæl Heaðabeardna gestreon
+þenden hie ðam wæpnum wealdan moston,
+oððæt hie forlæddan to ðam lindplegan
+swæse gesiðas ond hyra sylfra feorh.
+þonne cwið æt beore se ðe beah gesyhð,
+eald æscwiga, se ðe eall geman,
+garcwealm gumena (him bið grim sefa),
+onginneð geomormod geongum cempan
+þurh hreðra gehygd higes cunnian,
+wigbealu weccean, ond þæt word acwyð:
+'Meaht ðu, min wine, mece gecnawan
+þone þin fæder to gefeohte bær
+under heregriman hindeman siðe,
+dyre iren, þær hyne Dene slogon,
+weoldon wælstowe, syððan Wiðergyld læg,
+æfter hæleþa hryre, hwate Scyldungas?
+Nu her þara banena byre nathwylces
+frætwum hremig on flet gæð,
+morðres gylpeð, ond þone maðþum byreð,
+þone þe ðu mid rihte rædan sceoldest.'
+Manað swa ond myndgað mæla gehwylce
+sarum wordum, oððæt sæl cymeð
+þæt se fæmnan þegn fore fæder dædum
+æfter billes bite blodfag swefeð,
+ealdres scyldig; him se oðer þonan
+losað lifigende, con him land geare.
+þonne bioð abrocene on ba healfe
+aðsweord eorla; syððan Ingelde
+weallað wælniðas, ond him wiflufan
+æfter cearwælmum colran weorðað.
+þy ic Heaðobeardna hyldo ne telge,
+dryhtsibbe dæl Denum unfæcne,
+freondscipe fæstne. Ic sceal forð sprecan
+gen ymbe Grendel, þæt ðu geare cunne,
+sinces brytta, to hwan syððan wearð
+hondræs hæleða. Syððan heofones gim
+glad ofer grundas, gæst yrre cwom,
+eatol, æfengrom, user neosan,
+ðær we gesunde sæl weardodon.
+þær wæs Hondscio hild onsæge,
+feorhbealu fægum; he fyrmest læg,
+gyrded cempa; him Grendel wearð,
+mærum maguþegne to muðbonan,
+leofes mannes lic eall forswealg.
+No ðy ær ut ða gen idelhende
+bona blodigtoð, bealewa gemyndig,
+of ðam goldsele gongan wolde,
+ac he mægnes rof min costode,
+grapode gearofolm. Glof hangode
+sid ond syllic, searobendum fæst;
+sio wæs orðoncum eall gegyrwed
+deofles cræftum ond dracan fellum.
+He mec þær on innan unsynnigne,
+dior dædfruma, gedon wolde
+manigra sumne; hyt ne mihte swa,
+syððan ic on yrre uppriht astod.
+To lang ys to reccenne hu ic ðam leodsceaðan
+yfla gehwylces ondlean forgeald;
+þær ic, þeoden min, þine leode
+weorðode weorcum. He on weg losade,
+lytle hwile lifwynna breac;
+hwæþre him sio swiðre swaðe weardade
+hand on Hiorte, ond he hean ðonan
+modes geomor meregrund gefeoll.
+Me þone wælræs wine Scildunga
+fættan golde fela leanode,
+manegum maðmum, syððan mergen com
+ond we to symble geseten hæfdon.
+þær wæs gidd ond gleo. Gomela Scilding,
+felafricgende, feorran rehte;
+hwilum hildedeor hearpan wynne,
+gomenwudu grette, hwilum gyd awræc
+soð ond sarlic, hwilum syllic spell
+rehte æfter rihte rumheort cyning.
+Hwilum eft ongan, eldo gebunden,
+gomel guðwiga gioguðe cwiðan,
+hildestrengo; hreðer inne weoll,
+þonne he wintrum frod worn gemunde.
+Swa we þær inne ondlangne dæg
+niode naman, oððæt niht becwom
+oðer to yldum. þa wæs eft hraðe
+gearo gyrnwræce Grendeles modor,
+siðode sorhfull; sunu deað fornam,
+wighete Wedra. Wif unhyre
+hyre bearn gewræc, beorn acwealde
+ellenlice; þær wæs æschere,
+frodan fyrnwitan, feorh uðgenge.
+Noðer hy hine ne moston, syððan mergen cwom,
+deaðwerigne, Denia leode,
+bronde forbærnan, ne on bęl hladan
+leofne mannan; hio þæt lic ætbær
+feondes fæðmum under firgenstream.
+þæt wæs Hroðgare hreowa tornost
+þara þe leodfruman lange begeate.
+þa se ðeoden mec ðine life
+healsode hreohmod, þæt ic on holma geþring
+eorlscipe efnde, ealdre geneðde,
+mærðo fremede; he me mede gehet.
+Ic ða ðæs wælmes, þe is wide cuð,
+grimne gryrelicne grundhyrde fond;
+þær unc hwile wæs hand gemæne,
+holm heolfre weoll, ond ic heafde becearf
+in ðam guðsele Grendeles modor
+eacnum ecgum, unsofte þonan
+feorh oðferede. Næs ic fæge þa gyt,
+ac me eorla hleo eft gesealde
+maðma menigeo, maga Healfdenes.
+Swa se ðeodkyning þeawum lyfde.
+Nealles ic ðam leanum forloren hæfde,
+mægnes mede, ac he me maðmas geaf,
+sunu Healfdenes, on minne sylfes dom;
+ða ic ðe, beorncyning, bringan wylle,
+estum geywan. Gen is eall æt ðe
+lissa gelong; ic lyt hafo
+heafodmaga nefne, Hygelac, ðec."
+Het ða in beran eaforheafodsegn,
+heaðosteapne helm, hare byrnan,
+guðsweord geatolic, gyd æfter wræc:
+"Me ðis hildesceorp Hroðgar sealde,
+snotra fengel, sume worde het
+þæt ic his ærest ðe est gesægde;
+cwæð þæt hyt hæfde Hiorogar cyning,
+leod Scyldunga lange hwile;
+no ðy ær suna sinum syllan wolde,
+hwatum Heorowearde, þeah he him hold wære,
+breostgewædu. Bruc ealles well!"
+Hyrde ic þæt þam frætwum feower mearas
+lungre, gelice, last weardode,
+æppelfealuwe; he him est geteah
+meara ond maðma. Swa sceal mæg don,
+nealles inwitnet oðrum bregdon
+dyrnum cræfte, deað renian
+hondgesteallan. Hygelace wæs,
+niða heardum, nefa swyðe hold,
+ond gehwæðer oðrum hroþra gemyndig.
+Hyrde ic þæt he ðone healsbeah Hygde gesealde,
+wrætlicne wundurmaððum, ðone þe him Wealhðeo geaf,
+ðeodnes dohtor, þrio wicg somod
+swancor ond sadolbeorht; hyre syððan wæs
+æfter beahðege breost geweorðod.
+Swa bealdode bearn Ecgðeowes,
+guma guðum cuð, godum dædum,
+dreah æfter dome, nealles druncne slog
+heorðgeneatas; næs him hreoh sefa,
+ac he mancynnes mæste cræfte
+ginfæstan gife, þe him god sealde,
+heold hildedeor. Hean wæs lange,
+swa hyne Geata bearn godne ne tealdon,
+ne hyne on medobence micles wyrðne
+drihten Wedera gedon wolde;
+swyðe wendon þæt he sleac wære,
+æðeling unfrom. Edwenden cwom
+tireadigum menn torna gehwylces.
+Het ða eorla hleo in gefetian,
+heaðorof cyning, Hreðles lafe
+golde gegyrede; næs mid Geatum ða
+sincmaðþum selra on sweordes had;
+þæt he on Biowulfes bearm alegde
+ond him gesealde seofan þusendo,
+bold ond bregostol. Him wæs bam samod
+on ðam leodscipe lond gecynde,
+eard, eðelriht, oðrum swiðor
+side rice þam ðær selra wæs.
+Eft þæt geiode ufaran dogrum
+hildehlæmmum, syððan Hygelac læg
+ond Heardrede hildemeceas
+under bordhreoðan to bonan wurdon,
+ða hyne gesohtan on sigeþeode
+hearde hildefrecan, Heaðoscilfingas,
+niða genægdan nefan Hererices,
+syððan Beowulfe brade rice
+on hand gehwearf; he geheold tela
+fiftig wintra (wæs ða frod cyning,
+eald eþelweard), oððæt an ongan
+deorcum nihtum draca ricsian,
+se ðe on heaum hofe hord beweotode,
+stanbeorh steapne; stig under læg,
+eldum uncuð. þær on innan giong
+niða nathwylc, se ðe neh gefeng
+hæðnum horde, hond [...],
+since fahne. He þæt syððan [...],
+þeah ðe he slæpende besyred wurde
+þeofes cræfte; þæt sie ðiod onfand,
+bufolc beorna, þæt he gebolgen wæs.
+Nealles mid gewealdum wyrmhord abræc
+sylfes willum, se ðe him sare gesceod,
+ac for þreanedlan þeow nathwylces
+hæleða bearna heteswengeas fleah,
+ærnes þearfa, ond ðær inne fealh,
+secg synbysig, sona onfunde
+þæt þær ðam gyste gryrebroga stod;
+hwæðre earmsceapen
+sceapen
+þa hyne se fær begeat.
+Sincfæt [...]; þær wæs swylcra fela
+in ðam eorðhuse ærgestreona,
+swa hy on geardagum gumena nathwylc,
+eormenlafe æþelan cynnes,
+þanchycgende þær gehydde,
+deore maðmas. Ealle hie deað fornam
+ærran mælum, ond se an ða gen
+leoda duguðe, se ðær lengest hwearf,
+weard winegeomor, wende þæs ylcan,
+þæt he lytel fæc longgestreona
+brucan moste. Beorh eallgearo
+wunode on wonge wæteryðum neah,
+niwe be næsse, nearocræftum fæst.
+þær on innan bær eorlgestreona
+hringa hyrde hordwyrðne dæl,
+fættan goldes, fea worda cwæð:
+"Heald þu nu, hruse, nu hæleð ne moston,
+eorla æhte! Hwæt, hyt ær on ðe
+gode begeaton. Guðdeað fornam,
+feorhbealo frecne, fyra gehwylcne
+leoda minra, þara ðe þis lif ofgeaf,
+gesawon seledream. Ic nah hwa sweord wege
+oððe feormie fæted wæge,
+dryncfæt deore; duguð ellor sceoc.
+Sceal se hearda helm hyrsted golde
+fætum befeallen; feormynd swefað,
+þa ðe beadogriman bywan sceoldon,
+ge swylce seo herepad, sio æt hilde gebad
+ofer borda gebræc bite irena,
+brosnað æfter beorne. Ne mæg byrnan hring
+æfter wigfruman wide feran,
+hæleðum be healfe. Næs hearpan wyn,
+gomen gleobeames, ne god hafoc
+geond sæl swingeð, ne se swifta mearh
+burhstede beateð. Bealocwealm hafað
+fela feorhcynna forð onsended!"
+Swa giomormod giohðo mænde
+an æfter eallum, unbliðe hwearf
+dæges ond nihtes, oððæt deaðes wylm
+hran æt heortan. Hordwynne fond
+eald uhtsceaða opene standan,
+se ðe byrnende biorgas seceð,
+nacod niðdraca, nihtes fleogeð
+fyre befangen; hyne foldbuend
+swiðe ondrædað. He gesecean sceall
+hord on hrusan, þær he hæðen gold
+warað wintrum frod, ne byð him wihte ðy sel.
+Swa se ðeodsceaða þreo hund wintra
+heold on hrusan hordærna sum,
+eacencræftig, oððæt hyne an abealch
+mon on mode; mandryhtne bær
+fæted wæge, frioðowære bæd
+hlaford sinne. ða wæs hord rasod,
+onboren beaga hord, bene getiðad
+feasceaftum men. Frea sceawode
+fira fyrngeweorc forman siðe.
+þa se wyrm onwoc, wroht wæs geniwad;
+stonc ða æfter stane, stearcheort onfand
+feondes fotlast; he to forð gestop
+dyrnan cræfte dracan heafde neah.
+Swa mæg unfæge eaðe gedigan
+wean ond wræcsið, se ðe waldendes
+hyldo gehealdeþ! Hordweard sohte
+georne æfter grunde, wolde guman findan,
+þone þe him on sweofote sare geteode,
+hat ond hreohmod hlæw oft ymbehwearf
+ealne utanweardne, ne ðær ænig mon
+on þære westenne; hwæðre wiges gefeh,
+beaduwe weorces, hwilum on beorh æthwearf,
+sincfæt sohte. He þæt sona onfand
+ðæt hæfde gumena sum goldes gefandod,
+heahgestreona. Hordweard onbad
+earfoðlice oððæt æfen cwom;
+wæs ða gebolgen beorges hyrde,
+wolde se laða lige forgyldan
+drincfæt dyre. þa wæs dæg sceacen
+wyrme on willan; no on wealle læg,
+bidan wolde, ac mid bæle for,
+fyre gefysed. Wæs se fruma egeslic
+leodum on lande, swa hyt lungre wearð
+on hyra sincgifan sare geendod.
+ða se gæst ongan gledum spiwan,
+beorht hofu bærnan; bryneleoma stod
+eldum on andan. No ðær aht cwices
+lað lyftfloga læfan wolde.
+Wæs þæs wyrmes wig wide gesyne,
+nearofages nið nean ond feorran,
+hu se guðsceaða Geata leode
+hatode ond hynde; hord eft gesceat,
+dryhtsele dyrnne, ær dæges hwile.
+Hæfde landwara lige befangen,
+bæle ond bronde, beorges getruwode,
+wiges ond wealles; him seo wen geleah.
+þa wæs Biowulfe broga gecyðed
+snude to soðe, þæt his sylfes ham,
+bolda selest, brynewylmum mealt,
+gifstol Geata. þæt ðam godan wæs
+hreow on hreðre, hygesorga mæst;
+wende se wisa þæt he wealdende
+ofer ealde riht, ecean dryhtne,
+bitre gebulge. Breost innan weoll
+þeostrum geþoncum, swa him geþywe ne wæs.
+Hæfde ligdraca leoda fæsten,
+ealond utan, eorðweard ðone
+gledum forgrunden; him ðæs guðkyning,
+Wedera þioden, wræce leornode.
+Heht him þa gewyrcean wigendra hleo
+eallirenne, eorla dryhten,
+wigbord wrætlic; wisse he gearwe
+þæt him holtwudu helpan ne meahte,
+lind wið lige. Sceolde lændaga
+æþeling ærgod ende gebidan,
+worulde lifes, ond se wyrm somod,
+þeah ðe hordwelan heolde lange.
+Oferhogode ða hringa fengel
+þæt he þone widflogan weorode gesohte,
+sidan herge; no he him þa sæcce ondred,
+ne him þæs wyrmes wig for wiht dyde,
+eafoð ond ellen, forðon he ær fela
+nearo neðende niða gedigde,
+hildehlemma, syððan he Hroðgares,
+sigoreadig secg, sele fælsode
+ond æt guðe forgrap Grendeles mægum
+laðan cynnes. No þæt læsest wæs
+hondgemota, þær mon Hygelac sloh,
+syððan Geata cyning guðe ræsum,
+freawine folca Freslondum on,
+Hreðles eafora hiorodryncum swealt,
+bille gebeaten. þonan Biowulf com
+sylfes cræfte, sundnytte dreah;
+hæfde him on earme ana [XXX]
+hildegeatwa, þa he to holme beag.
+Nealles Hetware hremge þorfton
+feðewiges, þe him foran ongean
+linde bæron; lyt eft becwom
+fram þam hildfrecan hames niosan.
+Oferswam ða sioleða bigong sunu Ecgðeowes,
+earm anhaga, eft to leodum;
+þær him Hygd gebead hord ond rice,
+beagas ond bregostol, bearne ne truwode
+þæt he wið ælfylcum eþelstolas
+healdan cuðe, ða wæs Hygelac dead.
+No ðy ær feasceafte findan meahton
+æt ðam æðelinge ænige ðinga,
+þæt he Heardrede hlaford wære
+oððe þone cynedom ciosan wolde;
+hwæðre he him on folce freondlarum heold,
+estum mid are, oððæt he yldra wearð,
+Wedergeatum weold. Hyne wræcmæcgas
+ofer sæ sohtan, suna Ohteres;
+hæfdon hy forhealden helm Scylfinga,
+þone selestan sæcyninga
+þara ðe in Swiorice sinc brytnade,
+mærne þeoden. Him þæt to mearce wearð;
+he þær for feorme feorhwunde hleat
+sweordes swengum, sunu Hygelaces,
+ond him eft gewat Ongenðioes bearn
+hames niosan, syððan Heardred læg,
+let ðone bregostol Biowulf healdan,
+Geatum wealdan. þæt wæs god cyning!
+Se ðæs leodhryres lean gemunde
+uferan dogrum, Eadgilse wearð
+feasceaftum freond, folce gestepte
+ofer sæ side sunu Ohteres,
+wigum ond wæpnum; he gewræc syððan
+cealdum cearsiðum, cyning ealdre bineat.
+Swa he niða gehwane genesen hæfde,
+sliðra geslyhta, sunu Ecgðiowes,
+ellenweorca, oð ðone anne dæg
+þe he wið þam wyrme gewegan sceolde.
+Gewat þa [XII]a sum torne gebolgen
+dryhten Geata dracan sceawian.
+Hæfde þa gefrunen hwanan sio fæhð aras,
+bealonið biorna; him to bearme cwom
+maðþumfæt mære þurh ðæs meldan hond.
+Se wæs on ðam ðreate þreotteoða secg,
+se ðæs orleges or onstealde,
+hæft hygegiomor, sceolde hean ðonon
+wong wisian. He ofer willan giong
+to ðæs ðe he eorðsele anne wisse,
+hlæw under hrusan holmwylme neh,
+yðgewinne; se wæs innan full
+wrætta ond wira. Weard unhiore,
+gearo guðfreca, goldmaðmas heold,
+eald under eorðan. Næs þæt yðe ceap
+to gegangenne gumena ænigum!
+Gesæt ða on næsse niðheard cyning,
+þenden hælo abead heorðgeneatum,
+goldwine Geata. Him wæs geomor sefa,
+wæfre ond wælfus, wyrd ungemete neah,
+se ðone gomelan gretan sceolde,
+secean sawle hord, sundur gedælan
+lif wið lice, no þon lange wæs
+feorh æþelinges flæsce bewunden.
+Biowulf maþelade, bearn Ecgðeowes:
+"Fela ic on giogoðe guðræsa genæs,
+orleghwila; ic þæt eall gemon.
+Ic wæs syfanwintre, þa mec sinca baldor,
+freawine folca, æt minum fæder genam;
+heold mec ond hæfde Hreðel cyning,
+geaf me sinc ond symbel, sibbe gemunde.
+Næs ic him to life laðra owihte,
+beorn in burgum, þonne his bearna hwylc,
+Herebeald ond Hæðcyn oððe Hygelac min.
+Wæs þam yldestan ungedefelice
+mæges dædum morþorbed stred,
+syððan hyne Hæðcyn of hornbogan,
+his freawine, flane geswencte,
+miste mercelses ond his mæg ofscet,
+broðor oðerne blodigan gare.
+þæt wæs feohleas gefeoht, fyrenum gesyngad,
+hreðre hygemeðe; sceolde hwæðre swa þeah
+æðeling unwrecen ealdres linnan.
+Swa bið geomorlic gomelum ceorle
+to gebidanne, þæt his byre ride
+giong on galgan, þonne he gyd wrece,
+sarigne sang, þonne his sunu hangað
+hrefne to hroðre, ond he him helpe ne mæg,
+eald ond infrod, ænige gefremman.
+Symble bið gemyndgad morna gehwylce
+eaforan ellorsið; oðres ne gymeð
+to gebidanne burgum in innan
+yrfeweardas, þonne se an hafað
+þurh deaðes nyd dæda gefondad.
+Gesyhð sorhcearig on his suna bure
+winsele westne, windge reste
+reote berofene. Ridend swefað,
+hæleð in hoðman; nis þær hearpan sweg,
+gomen in geardum, swylce ðær iu wæron.
+Gewiteð þonne on sealman, sorhleoð gæleð
+an æfter anum; þuhte him eall to rum,
+wongas ond wicstede. Swa Wedra helm
+æfter Herebealde heortan sorge
+weallende wæg. Wihte ne meahte
+on ðam feorhbonan fæghðe gebetan;
+no ðy ær he þone heaðorinc hatian ne meahte
+laðum dædum, þeah him leof ne wæs.
+He ða mid þære sorhge, þe him swa sar belamp,
+gumdream ofgeaf, godes leoht geceas,
+eaferum læfde, swa deð eadig mon,
+lond ond leodbyrig, þa he of life gewat.
+þa wæs synn ond sacu Sweona ond Geata
+ofer wid wæter, wroht gemæne,
+herenið hearda, syððan Hreðel swealt,
+oððe him Ongenðeowes eaferan wæran
+frome, fyrdhwate, freode ne woldon
+ofer heafo healdan, ac ymb Hreosnabeorh
+eatolne inwitscear oft gefremedon.
+þæt mægwine mine gewræcan,
+fæhðe ond fyrene, swa hyt gefræge wæs,
+þeah ðe oðer his ealdre gebohte,
+heardan ceape; Hæðcynne wearð,
+Geata dryhtne, guð onsæge.
+þa ic on morgne gefrægn mæg oðerne
+billes ecgum on bonan stælan,
+þær Ongenþeow Eofores niosað.
+Guðhelm toglad, gomela Scylfing
+hreas hildeblac; hond gemunde
+fæhðo genoge, feorhsweng ne ofteah.
+Ic him þa maðmas, þe he me sealde,
+geald æt guðe, swa me gifeðe wæs,
+leohtan sweorde; he me lond forgeaf,
+eard, eðelwyn. Næs him ænig þearf
+þæt he to Gifðum oððe to Gardenum
+oððe in Swiorice secean þurfe
+wyrsan wigfrecan, weorðe gecypan.
+Symle ic him on feðan beforan wolde,
+ana on orde, ond swa to aldre sceall
+sæcce fremman, þenden þis sweord þolað,
+þæt mec ær ond sið oft gelæste.
+Syððan ic for dugeðum Dæghrefne wearð
+to handbonan, Huga cempan;
+nalles he ða frætwe Frescyninge,
+breostweorðunge, bringan moste,
+ac in compe gecrong cumbles hyrde,
+æþeling on elne; ne wæs ecg bona,
+ac him hildegrap heortan wylmas,
+banhus gebræc. Nu sceall billes ecg,
+hond ond heard sweord, ymb hord wigan."
+Beowulf maðelode, beotwordum spræc
+niehstan siðe: "Ic geneðde fela
+guða on geogoðe; gyt ic wylle,
+frod folces weard, fæhðe secan,
+mærðu fremman, gif mec se mansceaða
+of eorðsele ut geseceð."
+Gegrette ða gumena gehwylcne,
+hwate helmberend, hindeman siðe,
+swæse gesiðas: "Nolde ic sweord beran,
+wæpen to wyrme, gif ic wiste hu
+wið ðam aglæcean elles meahte
+gylpe wiðgripan, swa ic gio wið Grendle dyde.
+Ac ic ðær heaðufyres hates wene,
+oreðes ond attres; forðon ic me on hafu
+bord ond byrnan. Nelle ic beorges weard
+forfleon fotes trem, ac unc furður sceal
+weorðan æt wealle, swa unc wyrd geteoð,
+metod manna gehwæs. Ic eom on mode from
+þæt ic wið þone guðflogan gylp ofersitte.
+Gebide ge on beorge byrnum werede,
+secgas on searwum, hwæðer sel mæge
+æfter wælræse wunde gedygan
+uncer twega. Nis þæt eower sið
+ne gemet mannes, nefne min anes,
+þæt he wið aglæcean eofoðo dæle,
+eorlscype efne. Ic mid elne sceall
+gold gegangan, oððe guð nimeð,
+feorhbealu frecne, frean eowerne!"
+Aras ða bi ronde rof oretta,
+heard under helme, hiorosercean bær
+under stancleofu, strengo getruwode
+anes mannes. Ne bið swylc earges sið!
+Geseah ða be wealle se ðe worna fela,
+gumcystum god, guða gedigde,
+hildehlemma, þonne hnitan feðan,
+stondan stanbogan, stream ut þonan
+brecan of beorge. Wæs þære burnan wælm
+heaðofyrum hat; ne meahte horde neah
+unbyrnende ænige hwile
+deop gedygan for dracan lege.
+Let ða of breostum, ða he gebolgen wæs,
+Wedergeata leod word ut faran,
+stearcheort styrmde; stefn in becom
+heaðotorht hlynnan under harne stan.
+Hete wæs onhrered, hordweard oncniow
+mannes reorde; næs ðær mara fyrst
+freode to friclan. From ærest cwom
+oruð aglæcean ut of stane,
+hat hildeswat. Hruse dynede.
+Biorn under beorge bordrand onswaf
+wið ðam gryregieste, Geata dryhten;
+ða wæs hringbogan heorte gefysed
+sæcce to seceanne. Sweord ær gebræd
+god guðcyning, gomele lafe,
+ecgum unslaw; æghwæðrum wæs
+bealohycgendra broga fram oðrum.
+Stiðmod gestod wið steapne rond
+winia bealdor, ða se wyrm gebeah
+snude tosomne; he on searwum bad.
+Gewat ða byrnende gebogen scriðan,
+to gescipe scyndan. Scyld wel gebearg
+life ond lice læssan hwile
+mærum þeodne þonne his myne sohte,
+ðær he þy fyrste, forman dogore
+wealdan moste swa him wyrd ne gescraf
+hreð æt hilde. Hond up abræd
+Geata dryhten, gryrefahne sloh
+incgelafe, þæt sio ecg gewac
+brun on bane, bat unswiðor
+þonne his ðiodcyning þearfe hæfde,
+bysigum gebæded. þa wæs beorges weard
+æfter heaðuswenge on hreoum mode,
+wearp wælfyre; wide sprungon
+hildeleoman. Hreðsigora ne gealp
+goldwine Geata; guðbill geswac,
+nacod æt niðe, swa hyt no sceolde,
+iren ærgod. Ne wæs þæt eðe sið,
+þæt se mæra maga Ecgðeowes
+grundwong þone ofgyfan wolde;
+sceolde ofer willan wic eardian
+elles hwergen, swa sceal æghwylc mon
+alætan lændagas. Næs ða long to ðon
+þæt ða aglæcean hy eft gemetton.
+Hyrte hyne hordweard (hreðer æðme weoll)
+niwan stefne; nearo ðrowode,
+fyre befongen, se ðe ær folce weold.
+Nealles him on heape handgesteallan,
+æðelinga bearn, ymbe gestodon
+hildecystum, ac hy on holt bugon,
+ealdre burgan. Hiora in anum weoll
+sefa wið sorgum; sibb æfre ne mæg
+wiht onwendan þam ðe wel þenceð.
+Wiglaf wæs haten Weoxstanes sunu,
+leoflic lindwiga, leod Scylfinga,
+mæg ælfheres; geseah his mondryhten
+under heregriman hat þrowian.
+Gemunde ða ða are þe he him ær forgeaf,
+wicstede weligne Wægmundinga,
+folcrihta gehwylc, swa his fæder ahte.
+Ne mihte ða forhabban; hond rond gefeng,
+geolwe linde, gomel swyrd geteah,
+þæt wæs mid eldum Eanmundes laf,
+suna Ohteres. þam æt sæcce wearð,
+wræccan wineleasum, Weohstan bana
+meces ecgum, ond his magum ætbær
+brunfagne helm, hringde byrnan,
+eald sweord etonisc; þæt him Onela forgeaf,
+his gædelinges guðgewædu,
+fyrdsearo fuslic, no ymbe ða fæhðe spræc,
+þeah ðe he his broðor bearn abredwade.
+He frætwe geheold fela missera,
+bill ond byrnan, oððæt his byre mihte
+eorlscipe efnan swa his ærfæder;
+geaf him ða mid Geatum guðgewæda,
+æghwæs unrim, þa he of ealdre gewat,
+frod on forðweg. þa wæs forma sið
+geongan cempan, þæt he guðe ræs
+mid his freodryhtne fremman sceolde.
+Ne gemealt him se modsefa, ne his mæges laf
+gewac æt wige; þæt se wyrm onfand,
+syððan hie togædre gegan hæfdon.
+Wiglaf maðelode, wordrihta fela
+sægde gesiðum (him wæs sefa geomor):
+"Ic ðæt mæl geman, þær we medu þegun,
+þonne we geheton ussum hlaforde
+in biorsele, ðe us ðas beagas geaf,
+þæt we him ða guðgetawa gyldan woldon
+gif him þyslicu þearf gelumpe,
+helmas ond heard sweord. ðe he usic on herge geceas
+to ðyssum siðfate sylfes willum,
+onmunde usic mærða, ond me þas maðmas geaf,
+þe he usic garwigend gode tealde,
+hwate helmberend, þeah ðe hlaford us
+þis ellenweorc ana aðohte
+to gefremmanne, folces hyrde,
+for ðam he manna mæst mærða gefremede,
+dæda dollicra. Nu is se dæg cumen
+þæt ure mandryhten mægenes behofað,
+godra guðrinca; wutun gongan to,
+helpan hildfruman, þenden hyt sy,
+gledegesa grim. God wat on mec
+þæt me is micle leofre þæt minne lichaman
+mid minne goldgyfan gled fæðmie.
+Ne þynceð me gerysne þæt we rondas beren
+eft to earde, nemne we æror mægen
+fane gefyllan, feorh ealgian
+Wedra ðeodnes. Ic wat geare
+þæt næron ealdgewyrht, þæt he ana scyle
+Geata duguðe gnorn þrowian,
+gesigan æt sæcce; urum sceal sweord ond helm,
+byrne ond beaduscrud, bam gemæne."
+Wod þa þurh þone wælrec, wigheafolan bær
+frean on fultum, fea worda cwæð:
+"Leofa Biowulf, læst eall tela,
+swa ðu on geoguðfeore geara gecwæde
+þæt ðu ne alæte be ðe lifigendum
+dom gedreosan. Scealt nu dædum rof,
+æðeling anhydig, ealle mægene
+feorh ealgian; ic ðe fullæstu."
+æfter ðam wordum wyrm yrre cwom,
+atol inwitgæst, oðre siðe
+fyrwylmum fah fionda niosian,
+laðra manna; ligyðum for.
+Born bord wið rond, byrne ne meahte
+geongum garwigan geoce gefremman,
+ac se maga geonga under his mæges scyld
+elne geeode, þa his agen wæs
+gledum forgrunden. þa gen guðcyning
+mærða gemunde, mægenstrengo sloh
+hildebille, þæt hyt on heafolan stod
+niþe genyded; Nægling forbærst,
+geswac æt sæcce sweord Biowulfes,
+gomol ond grægmæl. Him þæt gifeðe ne wæs
+þæt him irenna ecge mihton
+helpan æt hilde; wæs sio hond to strong,
+se ðe meca gehwane, mine gefræge,
+swenge ofersohte, þonne he to sæcce bær
+wæpen wundrum heard; næs him wihte ðe sel.
+þa wæs þeodsceaða þriddan siðe,
+frecne fyrdraca, fæhða gemyndig,
+ræsde on ðone rofan, þa him rum ageald,
+hat ond heaðogrim, heals ealne ymbefeng
+biteran banum; he geblodegod wearð
+sawuldriore, swat yðum weoll.
+ða ic æt þearfe gefrægn þeodcyninges
+andlongne eorl ellen cyðan,
+cræft ond cenðu, swa him gecynde wæs.
+Ne hedde he þæs heafolan, ac sio hand gebarn
+modiges mannes, þær he his mæges healp,
+þæt he þone niðgæst nioðor hwene sloh,
+secg on searwum, þæt ðæt sweord gedeaf,
+fah ond fæted, þæt ðæt fyr ongon
+sweðrian syððan. þa gen sylf cyning
+geweold his gewitte, wællseaxe gebræd
+biter ond beaduscearp, þæt he on byrnan wæg;
+forwrat Wedra helm wyrm on middan.
+Feond gefyldan (ferh ellen wræc),
+ond hi hyne þa begen abroten hæfdon,
+sibæðelingas. Swylc sceolde secg wesan,
+þegn æt ðearfe! þæt ðam þeodne wæs
+siðast sigehwila sylfes dædum,
+worlde geweorces. ða sio wund ongon,
+þe him se eorðdraca ær geworhte,
+swelan ond swellan; he þæt sona onfand,
+þæt him on breostum bealoniðe weoll
+attor on innan. ða se æðeling giong
+þæt he bi wealle wishycgende
+gesæt on sesse; seah on enta geweorc,
+hu ða stanbogan stapulum fæste
+ece eorðreced innan healde.
+Hyne þa mid handa heorodreorigne,
+þeoden mærne, þegn ungemete till
+winedryhten his wætere gelafede,
+hilde sædne, ond his helm onspeon.
+Biowulf maþelode (he ofer benne spræc,
+wunde wælbleate; wisse he gearwe
+þæt he dæghwila gedrogen hæfde,
+eorðan wynne; ða wæs eall sceacen
+dogorgerimes, deað ungemete neah):
+"Nu ic suna minum syllan wolde
+guðgewædu, þær me gifeðe swa
+ænig yrfeweard æfter wurde
+lice gelenge. Ic ðas leode heold
+fiftig wintra; næs se folccyning,
+ymbesittendra ænig ðara,
+þe mec guðwinum gretan dorste,
+egesan ðeon. Ic on earde bad
+mælgesceafta, heold min tela,
+ne sohte searoniðas, ne me swor fela
+aða on unriht. Ic ðæs ealles mæg
+feorhbennum seoc gefean habban;
+for ðam me witan ne ðearf waldend fira
+morðorbealo maga, þonne min sceaceð
+lif of lice. Nu ðu lungre geong
+hord sceawian under harne stan,
+Wiglaf leofa, nu se wyrm ligeð,
+swefeð sare wund, since bereafod.
+Bio nu on ofoste, þæt ic ærwelan,
+goldæht ongite, gearo sceawige
+swegle searogimmas, þæt ic ðy seft mæge
+æfter maððumwelan min alætan
+lif ond leodscipe, þone ic longe heold."
+ða ic snude gefrægn sunu Wihstanes
+æfter wordcwydum wundum dryhtne
+hyran heaðosiocum, hringnet beran,
+brogdne beadusercean under beorges hrof.
+Geseah ða sigehreðig, þa he bi sesse geong,
+magoþegn modig maððumsigla fealo,
+gold glitinian grunde getenge,
+wundur on wealle, ond þæs wyrmes denn,
+ealdes uhtflogan, orcas stondan,
+fyrnmanna fatu feormendlease,
+hyrstum behrorene; þær wæs helm monig
+eald ond omig, earmbeaga fela
+searwum gesæled. Sinc eaðe mæg,
+gold on grunde, gumcynnes gehwone
+oferhigian, hyde se ðe wylle.
+Swylce he siomian geseah segn eallgylden
+heah ofer horde, hondwundra mæst,
+gelocen leoðocræftum; of ðam leoma stod,
+þæt he þone grundwong ongitan meahte,
+wræte giondwlitan. Næs ðæs wyrmes þær
+onsyn ænig, ac hyne ecg fornam.
+ða ic on hlæwe gefrægn hord reafian,
+eald enta geweorc, anne mannan,
+him on bearm hladon bunan ond discas
+sylfes dome; segn eac genom,
+beacna beorhtost. Bill ær gescod
+(ecg wæs iren) ealdhlafordes
+þam ðara maðma mundbora wæs
+longe hwile, ligegesan wæg
+hatne for horde, hioroweallende
+middelnihtum, oðþæt he morðre swealt.
+Ar wæs on ofoste, eftsiðes georn,
+frætwum gefyrðred; hyne fyrwet bræc,
+hwæðer collenferð cwicne gemette
+in ðam wongstede Wedra þeoden
+ellensiocne, þær he hine ær forlet.
+He ða mid þam maðmum mærne þioden,
+dryhten sinne, driorigne fand
+ealdres æt ende; he hine eft ongon
+wæteres weorpan, oðþæt wordes ord
+breosthord þurhbræc.
+gomel on giohðe (gold sceawode):
+"Ic ðara frætwa frean ealles ðanc,
+wuldurcyninge, wordum secge,
+ecum dryhtne, þe ic her on starie,
+þæs ðe ic moste minum leodum
+ær swyltdæge swylc gestrynan.
+Nu ic on maðma hord mine bebohte
+frode feorhlege, fremmað gena
+leoda þearfe; ne mæg ic her leng wesan.
+Hatað heaðomære hlæw gewyrcean
+beorhtne æfter bæle æt brimes nosan;
+se scel to gemyndum minum leodum
+heah hlifian on Hronesnæsse,
+þæt hit sæliðend syððan hatan
+Biowulfes biorh, ða ðe brentingas
+ofer floda genipu feorran drifað."
+Dyde him of healse hring gyldenne
+þioden þristhydig, þegne gesealde,
+geongum garwigan, goldfahne helm,
+beah ond byrnan, het hyne brucan well:
+"þu eart endelaf usses cynnes,
+Wægmundinga. Ealle wyrd forsweop
+mine magas to metodsceafte,
+eorlas on elne; ic him æfter sceal."
+þæt wæs þam gomelan gingæste word
+breostgehygdum, ær he bæl cure,
+hate heaðowylmas; him of hreðre gewat
+sawol secean soðfæstra dom.
+ða wæs gegongen guman unfrodum
+earfoðlice, þæt he on eorðan geseah
+þone leofestan lifes æt ende
+bleate gebæran. Bona swylce læg,
+egeslic eorðdraca ealdre bereafod,
+bealwe gebæded. Beahhordum leng
+wyrm wohbogen wealdan ne moste,
+ac hine irenna ecga fornamon,
+hearde, heaðoscearde homera lafe,
+þæt se widfloga wundum stille
+hreas on hrusan hordærne neah.
+Nalles æfter lyfte lacende hwearf
+middelnihtum, maðmæhta wlonc
+ansyn ywde, ac he eorðan gefeoll
+for ðæs hildfruman hondgeweorce.
+Huru þæt on lande lyt manna ðah,
+mægenagendra, mine gefræge,
+þeah ðe he dæda gehwæs dyrstig wære,
+þæt he wið attorsceaðan oreðe geræsde,
+oððe hringsele hondum styrede,
+gif he wæccende weard onfunde
+buon on beorge. Biowulfe wearð
+dryhtmaðma dæl deaðe forgolden;
+hæfde æghwæðer ende gefered
+lænan lifes. Næs ða lang to ðon
+þæt ða hildlatan holt ofgefan,
+tydre treowlogan tyne ætsomne.
+ða ne dorston ær dareðum lacan
+on hyra mandryhtnes miclan þearfe,
+ac hy scamiende scyldas bæran,
+guðgewædu, þær se gomela læg,
+wlitan on Wilaf. He gewergad sæt,
+feðecempa, frean eaxlum neah,
+wehte hyne wætre; him wiht ne speow.
+Ne meahte he on eorðan, ðeah he uðe wel,
+on ðam frumgare feorh gehealdan,
+ne ðæs wealdendes wiht oncirran;
+wolde dom godes dædum rædan
+gumena gehwylcum, swa he nu gen deð.
+þa wæs æt ðam geongan grim ondswaru
+eðbegete þam ðe ær his elne forleas.
+Wiglaf maðelode, Weohstanes sunu,
+sec, sarigferð (seah on unleofe):
+"þæt, la, mæg secgan se ðe wyle soð specan
+þæt se mondryhten se eow ða maðmas geaf,
+eoredgeatwe, þe ge þær on standað,
+þonne he on ealubence oft gesealde
+healsittendum helm ond byrnan,
+þeoden his þegnum, swylce he þrydlicost
+ower feor oððe neah findan meahte,
+þæt he genunga guðgewædu
+wraðe forwurpe, ða hyne wig beget.
+Nealles folccyning fyrdgesteallum
+gylpan þorfte; hwæðre him god uðe,
+sigora waldend, þæt he hyne sylfne gewræc
+ana mid ecge, þa him wæs elnes þearf.
+Ic him lifwraðe lytle meahte
+ætgifan æt guðe, ond ongan swa þeah
+ofer min gemet mæges helpan;
+symle wæs þy sæmra, þonne ic sweorde drep
+ferhðgeniðlan, fyr unswiðor
+weoll of gewitte. Wergendra to lyt
+þrong ymbe þeoden, þa hyne sio þrag becwom.
+Nu sceal sincþego ond swyrdgifu,
+eall eðelwyn eowrum cynne,
+lufen alicgean; londrihtes mot
+þære mægburge monna æghwylc
+idel hweorfan, syððan æðelingas
+feorran gefricgean fleam eowerne,
+domleasan dæd. Deað bið sella
+eorla gehwylcum þonne edwitlif!"
+Heht ða þæt heaðoweorc to hagan biodan
+up ofer ecgclif, þær þæt eorlweorod
+morgenlongne dæg modgiomor sæt,
+bordhæbbende, bega on wenum,
+endedogores ond eftcymes
+leofes monnes. Lyt swigode
+niwra spella se ðe næs gerad,
+ac he soðlice sægde ofer ealle:
+"Nu is wilgeofa Wedra leoda,
+dryhten Geata, deaðbedde fæst,
+wunað wælreste wyrmes dædum.
+Him on efn ligeð ealdorgewinna
+sexbennum seoc; sweorde ne meahte
+on ðam aglæcean ænige þinga
+wunde gewyrcean. Wiglaf siteð
+ofer Biowulfe, byre Wihstanes,
+eorl ofer oðrum unlifigendum,
+healdeð higemæðum heafodwearde
+leofes ond laðes. Nu ys leodum wen
+orleghwile, syððan underne
+Froncum ond Frysum fyll cyninges
+wide weorðeð. Wæs sio wroht scepen
+heard wið Hugas, syððan Higelac cwom
+faran flotherge on Fresna land,
+þær hyne Hetware hilde genægdon,
+elne geeodon mid ofermægene,
+þæt se byrnwiga bugan sceolde,
+feoll on feðan, nalles frætwe geaf
+ealdor dugoðe. Us wæs a syððan
+Merewioingas milts ungyfeðe.
+Ne ic to Sweoðeode sibbe oððe treowe
+wihte ne wene, ac wæs wide cuð
+þætte Ongenðio ealdre besnyðede
+Hæðcen Hreþling wið Hrefnawudu,
+þa for onmedlan ærest gesohton
+Geata leode Guðscilfingas.
+Sona him se froda fæder Ohtheres,
+eald ond egesfull, ondslyht ageaf,
+abreot brimwisan, bryd ahredde,
+gomela iomeowlan golde berofene,
+Onelan modor ond Ohtheres,
+ond ða folgode feorhgeniðlan,
+oððæt hi oðeodon earfoðlice
+in Hrefnesholt hlafordlease.
+Besæt ða sinherge sweorda lafe,
+wundum werge, wean oft gehet
+earmre teohhe ondlonge niht,
+cwæð, he on mergenne meces ecgum
+getan wolde, sum on galgtreowum
+fuglum to gamene. Frofor eft gelamp
+sarigmodum somod ærdæge,
+syððan hie Hygelaces horn ond byman,
+gealdor ongeaton, þa se goda com
+leoda dugoðe on last faran.
+Wæs sio swatswaðu Sweona ond Geata,
+wælræs weora wide gesyne,
+hu ða folc mid him fæhðe towehton.
+Gewat him ða se goda mid his gædelingum,
+frod, felageomor, fæsten secean,
+eorl Ongenþio, ufor oncirde;
+hæfde Higelaces hilde gefrunen,
+wlonces wigcræft, wiðres ne truwode,
+þæt he sæmannum onsacan mihte,
+heaðoliðendum hord forstandan,
+bearn ond bryde; beah eft þonan
+eald under eorðweall. þa wæs æht boden
+Sweona leodum, segn Higelaces
+freoðowong þone forð ofereodon,
+syððan Hreðlingas to hagan þrungon.
+þær wearð Ongenðiow ecgum sweorda,
+blondenfexa, on bid wrecen,
+þæt se þeodcyning ðafian sceolde
+Eafores anne dom. Hyne yrringa
+Wulf Wonreding wæpne geræhte,
+þæt him for swenge swat ædrum sprong
+forð under fexe. Næs he forht swa ðeh,
+gomela Scilfing, ac forgeald hraðe
+wyrsan wrixle wælhlem þone,
+syððan ðeodcyning þyder oncirde.
+Ne meahte se snella sunu Wonredes
+ealdum ceorle ondslyht giofan,
+ac he him on heafde helm ær gescer,
+þæt he blode fah bugan sceolde,
+feoll on foldan; næs he fæge þa git,
+ac he hyne gewyrpte, þeah ðe him wund hrine.
+Let se hearda Higelaces þegn
+bradne mece, þa his broðor læg,
+eald sweord eotonisc, entiscne helm
+brecan ofer bordweal; ða gebeah cyning,
+folces hyrde, wæs in feorh dropen.
+ða wæron monige þe his mæg wriðon,
+ricone arærdon, ða him gerymed wearð
+þæt hie wælstowe wealdan moston.
+þenden reafode rinc oðerne,
+nam on Ongenðio irenbyrnan,
+heard swyrd hilted ond his helm somod,
+hares hyrste Higelace bær.
+He ðam frætwum feng ond him fægre gehet
+leana mid leodum, ond gelæste swa;
+geald þone guðræs Geata dryhten,
+Hreðles eafora, þa he to ham becom,
+Iofore ond Wulfe mid ofermaðmum,
+sealde hiora gehwæðrum hund þusenda
+landes ond locenra beaga (ne ðorfte him ða lean oðwitan
+mon on middangearde), syððan hie ða mærða geslogon,
+ond ða Iofore forgeaf angan dohtor,
+hamweorðunge, hyldo to wedde.
+þæt ys sio fæhðo ond se feondscipe,
+wælnið wera, ðæs ðe ic wen hafo,
+þe us seceað to Sweona leoda,
+syððan hie gefricgeað frean userne
+ealdorleasne, þone ðe ær geheold
+wið hettendum hord ond rice
+æfter hæleða hryre, hwate Scildingas,
+folcred fremede oððe furður gen
+eorlscipe efnde. Nu is ofost betost
+þæt we þeodcyning þær sceawian
+ond þone gebringan, þe us beagas geaf,
+on adfære. Ne scel anes hwæt
+meltan mid þam modigan, ac þær is maðma hord,
+gold unrime grimme geceapod,
+ond nu æt siðestan sylfes feore
+beagas gebohte. þa sceall brond fretan,
+æled þeccean, nalles eorl wegan
+maððum to gemyndum, ne mægð scyne
+habban on healse hringweorðunge,
+ac sceal geomormod, golde bereafod,
+oft nalles æne elland tredan,
+nu se herewisa hleahtor alegde,
+gamen ond gleodream. Forðon sceall gar wesan
+monig, morgenceald, mundum bewunden,
+hæfen on handa, nalles hearpan sweg
+wigend weccean, ac se wonna hrefn
+fus ofer fægum fela reordian,
+earne secgan hu him æt æte speow,
+þenden he wið wulf wæl reafode."
+Swa se secg hwata secggende wæs
+laðra spella; he ne leag fela
+wyrda ne worda. Weorod eall aras;
+eodon unbliðe under Earnanæs,
+wollenteare wundur sceawian.
+Fundon ða on sande sawulleasne
+hlimbed healdan þone þe him hringas geaf
+ærran mælum; þa wæs endedæg
+godum gegongen, þæt se guðcyning,
+Wedra þeoden, wundordeaðe swealt.
+ær hi þær gesegan syllicran wiht,
+wyrm on wonge wiðerræhtes þær
+laðne licgean; wæs se legdraca
+grimlic, gryrefah, gledum beswæled.
+Se wæs fiftiges fotgemearces
+lang on legere, lyftwynne heold
+nihtes hwilum, nyðer eft gewat
+dennes niosian; wæs ða deaðe fæst,
+hæfde eorðscrafa ende genyttod.
+Him big stodan bunan ond orcas,
+discas lagon ond dyre swyrd,
+omige, þurhetone, swa hie wið eorðan fæðm
+þusend wintra þær eardodon.
+þonne wæs þæt yrfe, eacencræftig,
+iumonna gold galdre bewunden,
+þæt ðam hringsele hrinan ne moste
+gumena ænig, nefne god sylfa,
+sigora soðcyning, sealde þam ðe he wolde
+(he is manna gehyld) hord openian,
+efne swa hwylcum manna swa him gemet ðuhte.
+þa wæs gesyne þæt se sið ne ðah
+þam ðe unrihte inne gehydde
+wræte under wealle. Weard ær ofsloh
+feara sumne; þa sio fæhð gewearð
+gewrecen wraðlice. Wundur hwar þonne
+eorl ellenrof ende gefere
+lifgesceafta, þonne leng ne mæg
+mon mid his magum meduseld buan.
+Swa wæs Biowulfe, þa he biorges weard
+sohte, searoniðas; seolfa ne cuðe
+þurh hwæt his worulde gedal weorðan sceolde.
+Swa hit oð domes dæg diope benemdon
+þeodnas mære, þa ðæt þær dydon,
+þæt se secg wære synnum scildig,
+hergum geheaðerod, hellbendum fæst,
+wommum gewitnad, se ðone wong strude,
+næs he goldhwæte gearwor hæfde
+agendes est ær gesceawod.
+Wiglaf maðelode, Wihstanes sunu:
+"Oft sceall eorl monig anes willan
+wræc adreogan, swa us geworden is.
+Ne meahton we gelæran leofne þeoden,
+rices hyrde, ræd ænigne,
+þæt he ne grette goldweard þone,
+lete hyne licgean þær he longe wæs,
+wicum wunian oð woruldende;
+heold on heahgesceap. Hord ys gesceawod,
+grimme gegongen; wæs þæt gifeðe to swið
+þe ðone þeodcyning þyder ontyhte.
+Ic wæs þær inne ond þæt eall geondseh,
+recedes geatwa, þa me gerymed wæs,
+nealles swæslice sið alyfed
+inn under eorðweall. Ic on ofoste gefeng
+micle mid mundum mægenbyrðenne
+hordgestreona, hider ut ætbær
+cyninge minum. Cwico wæs þa gena,
+wis ond gewittig; worn eall gespræc
+gomol on gehðo ond eowic gretan het,
+bæd þæt ge geworhton æfter wines dædum
+in bælstede beorh þone hean,
+micelne ond mærne, swa he manna wæs
+wigend weorðfullost wide geond eorðan,
+þenden he burhwelan brucan moste.
+Uton nu efstan oðre siðe,
+seon ond secean searogimma geþræc,
+wundur under wealle; ic eow wisige,
+þæt ge genoge neon sceawiað
+beagas ond brad gold. Sie sio bær gearo,
+ædre geæfned, þonne we ut cymen,
+ond þonne geferian frean userne,
+leofne mannan, þær he longe sceal
+on ðæs waldendes wære geþolian."
+Het ða gebeodan byre Wihstanes,
+hæle hildedior, hæleða monegum,
+boldagendra, þæt hie bælwudu
+feorran feredon, folcagende,
+godum togenes: "Nu sceal gled fretan,
+weaxan wonna leg wigena strengel,
+þone ðe oft gebad isernscure,
+þonne stræla storm strengum gebæded
+scoc ofer scildweall, sceft nytte heold,
+feðergearwum fus flane fulleode."
+Huru se snotra sunu Wihstanes
+acigde of corðre cyninges þegnas
+syfone tosomne, þa selestan,
+eode eahta sum under inwithrof
+hilderinca; sum on handa bær
+æledleoman, se ðe on orde geong.
+Næs ða on hlytme hwa þæt hord strude,
+syððan orwearde ænigne dæl
+secgas gesegon on sele wunian,
+læne licgan; lyt ænig mearn
+þæt hi ofostlice ut geferedon
+dyre maðmas. Dracan ec scufun,
+wyrm ofer weallclif, leton weg niman,
+flod fæðmian frætwa hyrde.
+þa wæs wunden gold on wæn hladen,
+æghwæs unrim, æþeling boren,
+har hilderinc to Hronesnæsse.
+Him ða gegiredan Geata leode
+ad on eorðan unwaclicne,
+helmum behongen, hildebordum,
+beorhtum byrnum, swa he bena wæs;
+alegdon ða tomiddes mærne þeoden
+hæleð hiofende, hlaford leofne.
+Ongunnon þa on beorge bælfyra mæst
+wigend weccan; wudurec astah,
+sweart ofer swioðole, swogende leg
+wope bewunden (windblond gelæg),
+oðþæt he ða banhus gebrocen hæfde,
+hat on hreðre. Higum unrote
+modceare mændon, mondryhtnes cwealm;
+swylce giomorgyd Geatisc meowle
+bundenheorde
+song sorgcearig swiðe geneahhe
+þæt hio hyre heofungdagas hearde ondrede,
+wælfylla worn, werudes egesan,
+hynðo ond hæftnyd. Heofon rece swealg.
+Geworhton ða Wedra leode
+hleo on hoe, se wæs heah ond brad,
+wægliðendum wide gesyne,
+ond betimbredon on tyn dagum
+beadurofes becn, bronda lafe
+wealle beworhton, swa hyt weorðlicost
+foresnotre men findan mihton.
+Hi on beorg dydon beg ond siglu,
+eall swylce hyrsta, swylce on horde ær
+niðhedige men genumen hæfdon,
+forleton eorla gestreon eorðan healdan,
+gold on greote, þær hit nu gen lifað
+eldum swa unnyt swa hit æror wæs.
+þa ymbe hlæw riodan hildediore,
+æþelinga bearn, ealra twelfe,
+woldon ceare cwiðan ond kyning mænan,
+wordgyd wrecan ond ymb wer sprecan;
+eahtodan eorlscipe ond his ellenweorc
+duguðum demdon, swa hit gedefe bið
+þæt mon his winedryhten wordum herge,
+ferhðum freoge, þonne he forð scile
+of lichaman læded weorðan.
+Swa begnornodon Geata leode
+hlafordes hryre, heorðgeneatas,
+cwædon þæt he wære wyruldcyninga
+manna mildust ond monðwærust,
+leodum liðost ond lofgeornost.
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.rs
new file mode 100644
index 0000000..a572acc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.rs
@@ -0,0 +1,6 @@
+use std::io;
+use std::io::Write;
+
+fn main() {
+  assert!(io::stdout().write_all(include_bytes!("io_stdout-hello.stdout")).is_ok());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.stdout
new file mode 100644
index 0000000..c8fdade
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/io_stdout-hello.stdout
@@ -0,0 +1 @@
+Hello, stdout!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/main.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/main.rs
new file mode 100644
index 0000000..f328e4d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/main.rs
@@ -0,0 +1 @@
+fn main() {}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.rs
new file mode 100644
index 0000000..d449cbe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.rs
@@ -0,0 +1,14 @@
+// WASI:
+// mapdir: /dev:/dev
+
+use std::fs;
+use std::io::Write;
+
+fn main() {
+    let mut f = fs::OpenOptions::new()
+        .write(true)
+        .open("/dev/null")
+        .unwrap();
+    let result = f.write(b"hello, world!").unwrap();
+    println!("{}", result);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.stdout
new file mode 100644
index 0000000..b1bd38b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/port_unix_open_special_files.stdout
@@ -0,0 +1 @@
+13
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.rs
new file mode 100644
index 0000000..d55b4b8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.rs
@@ -0,0 +1,30 @@
+// WASI:
+// mapdir: hamlet:test_fs/hamlet
+
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_close(fd: u32) -> u16;
+    fn fd_fdstat_set_flags(fd: u32, flags: u16) -> u16;
+}
+
+const FIRST_PREOPEN_FD: u32 = 4;
+
+fn main() {
+    let result = unsafe { fd_fdstat_set_flags(FIRST_PREOPEN_FD, 1 << 2) };
+    println!(
+        "accessing preopen fd was a {}",
+        if result == 0 { "success" } else { "failure" }
+    );
+
+    let result = unsafe { fd_close(FIRST_PREOPEN_FD) };
+    println!(
+        "Closing preopen fd was a {}",
+        if result == 0 { "success" } else { "failure" }
+    );
+
+    let result = unsafe { fd_fdstat_set_flags(FIRST_PREOPEN_FD, 1 << 2) };
+    println!(
+        "accessing closed preopen fd was an EBADF error: {}",
+        if result == 8 { "true" } else { "false" }
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.stdout
new file mode 100644
index 0000000..e6e9b9f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_close_preopen_fd.stdout
@@ -0,0 +1,3 @@
+accessing preopen fd was a success
+Closing preopen fd was a success
+accessing closed preopen fd was an EBADF error: true
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.rs
new file mode 100644
index 0000000..6590080
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.rs
@@ -0,0 +1,40 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::*;
+
+fn main() {
+    let mut path = PathBuf::from("test_fs/wasitests/testing/nested/directories");
+    let test_file = path.join("test.file");
+    fs::create_dir_all(&path).unwrap();
+    {
+        let mut file = fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(&test_file)
+            .unwrap();
+
+        assert_eq!(file.write(b"hello").unwrap(), 5);
+
+        file.flush().unwrap();
+        file.seek(SeekFrom::Start(0)).unwrap();
+        let mut in_str = String::new();
+        file.read_to_string(&mut in_str).unwrap();
+        assert_eq!(&in_str, "hello");
+    }
+    fs::remove_file(&test_file).unwrap();
+    println!("Test file exists: {}", test_file.exists());
+    assert!(!test_file.exists());
+    for _ in 0..3 {
+        fs::remove_dir_all(&path).unwrap();
+        println!("Dir exists: {}", path.exists());
+        assert!(!path.exists());
+        path.pop();
+    }
+
+    println!("Success");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.stdout
new file mode 100644
index 0000000..cc1a8aa
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_create_dir.stdout
@@ -0,0 +1,5 @@
+Test file exists: false
+Dir exists: false
+Dir exists: false
+Dir exists: false
+Success
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.env b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.env
new file mode 100644
index 0000000..666dc18
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.env
@@ -0,0 +1,2 @@
+DOG=1
+CAT=2
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.rs
new file mode 100644
index 0000000..1846114
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.rs
@@ -0,0 +1,38 @@
+// WASI:
+// env: DOG=1
+// env: CAT=2
+
+use std::env;
+
+fn get_env_var(var_name: &str) -> Result<String, env::VarError> {
+    #[cfg(not(target = "wasi"))]
+    match var_name {
+        "DOG" => Ok("1".to_string()),
+        "CAT" => Ok("2".to_string()),
+        _ => Err(env::VarError::NotPresent),
+    }
+    #[cfg(target = "wasi")]
+    env::var(var_name)
+}
+
+fn main() {
+    #[cfg(not(target = "wasi"))]
+    let mut env_vars = vec!["DOG=1".to_string(), "CAT=2".to_string()];
+    #[cfg(target = "wasi")]
+    let mut env_vars = env::vars()
+        .map(|(key, value)| format!("{}={}", key, value))
+        .collect::<Vec<String>>();
+
+    env_vars.sort();
+
+    println!("Env vars:");
+    for e in env_vars {
+        println!("{}", e);
+    }
+
+    env::set_var("WASI_ENVVAR_TEST", "HELLO");
+
+    println!("DOG {:?}", get_env_var("DOG"));
+    println!("DOG_TYPE {:?}", get_env_var("DOG_TYPE"));
+    println!("SET VAR {:?}", env::var("WASI_ENVVAR_TEST"));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.stdout
new file mode 100644
index 0000000..67848f4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_envvar.stdout
@@ -0,0 +1,6 @@
+Env vars:
+CAT=2
+DOG=1
+DOG Ok("1")
+DOG_TYPE Err(NotPresent)
+SET VAR Ok("HELLO")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.rs
new file mode 100644
index 0000000..d74a7f7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.rs
@@ -0,0 +1,57 @@
+// WASI:
+// tempdir: .
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_allocate(fd: u32, offset: u64, length: u64) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn allocate(fd: u32, offset: u64, length: u64) -> u16 {
+    unsafe { fd_allocate(fd, offset, length) }
+}
+
+fn main() {
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+    #[cfg(target_os = "wasi")]
+    {
+        base.push("fd_allocate_file.txt");
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&base)
+            .expect("Could not create file");
+
+        {
+            use std::io::Write;
+            // example text from https://www.un.org/en/universal-declaration-human-rights/
+            file.write_all(b"All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.\n").unwrap();
+            let raw_fd = file.as_raw_fd();
+            file.flush().unwrap();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 171);
+            allocate(raw_fd as u32, len, 1234);
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 1234 + 171);
+        }
+    }
+    #[cfg(target_os = "wasi")]
+    std::fs::remove_file(&base).unwrap();
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!("171");
+        println!("1405");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.stdout
new file mode 100644
index 0000000..d8a0f88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_allocate.stdout
@@ -0,0 +1,2 @@
+171
+1405
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.rs
new file mode 100644
index 0000000..dcc07ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.rs
@@ -0,0 +1,55 @@
+// WASI:
+// tempdir: .
+
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+static STR1: &str = "Hello, world!\n";
+static STR2: &str = "Goodbye, world!\n";
+
+fn main() {
+    let file = {
+        #[cfg(not(target_os = "wasi"))]
+        let mut base = PathBuf::from("test_fs/temp");
+        #[cfg(target_os = "wasi")]
+        let mut base = PathBuf::from(".");
+
+        base.push("fd_append_test");
+        base
+    };
+
+    {
+        let mut file_handle = OpenOptions::new()
+            .create_new(true)
+            .append(true)
+            .open(&file)
+            .expect("Couldn't create file");
+        file_handle.write_all(STR1.as_bytes()).unwrap();
+        file_handle.flush().unwrap();
+        file_handle.sync_all().unwrap();
+    }
+    {
+        let mut file_handle = OpenOptions::new()
+            .append(true)
+            .open(&file)
+            .expect("Couldn't reopen file to append");
+        file_handle.write_all(STR2.as_bytes()).unwrap();
+        file_handle.flush().unwrap();
+        file_handle.sync_all().unwrap();
+    }
+
+    {
+        let mut file_handle = OpenOptions::new()
+            .read(true)
+            .open(&file)
+            .expect("Couldn't reopen file to read");
+
+        let mut test = String::new();
+        file_handle.read_to_string(&mut test).unwrap();
+
+        assert_eq!(&test, &format!("{}{}", STR1, STR2));
+        println!("{:?}", &test);
+    }
+    std::fs::remove_file(&file).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.stdout
new file mode 100644
index 0000000..e9d92ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_append.stdout
@@ -0,0 +1 @@
+"Hello, world!\nGoodbye, world!\n"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.rs
new file mode 100644
index 0000000..ef02e38
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.rs
@@ -0,0 +1,63 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_close(fd: u32) -> u16;
+}
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("/hamlet");
+
+    base.push("act3/scene3.txt");
+    let file = fs::File::open(&base).expect("could not open file");
+
+    #[cfg(target_os = "wasi")]
+    {
+        let file_fd = file.as_raw_fd() as u32;
+        let stdout_fd = std::io::stdout().as_raw_fd() as u32;
+        let stderr_fd = std::io::stderr().as_raw_fd() as u32;
+        let stdin_fd = std::io::stdin().as_raw_fd() as u32;
+
+        let result = unsafe { fd_close(file_fd) };
+        if result == 0 {
+            println!("Successfully closed file!")
+        } else {
+            println!("Could not close file");
+        }
+
+        let result = unsafe { fd_close(stderr_fd) };
+        if result == 0 {
+            println!("Successfully closed stderr!")
+        } else {
+            println!("Could not close stderr");
+        }
+        let result = unsafe { fd_close(stdin_fd) };
+        if result == 0 {
+            println!("Successfully closed stdin!")
+        } else {
+            println!("Could not close stdin");
+        }
+        let result = unsafe { fd_close(stdout_fd) };
+        if result == 0 {
+            println!("Successfully closed stdout!")
+        } else {
+            println!("Could not close stdout");
+        }
+    }
+    #[cfg(not(target_os = "wasi"))]
+    {
+        println!("Successfully closed file!");
+        println!("Successfully closed stderr!");
+        println!("Successfully closed stdin!");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.stdout
new file mode 100644
index 0000000..53c9c27
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_close.stdout
@@ -0,0 +1,3 @@
+Successfully closed file!
+Successfully closed stderr!
+Successfully closed stdin!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.rs
new file mode 100644
index 0000000..8a50d1d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.rs
@@ -0,0 +1,84 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[repr(C)]
+struct WasiIovec {
+    pub buf: u32,
+    pub buf_len: u32,
+}
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_pread(fd: u32, iovs: u32, iovs_len: u32, offset: u64, nread: u32) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn pread(fd: u32, iovs: &[&mut [u8]], offset: u64) -> u32 {
+    let mut nread = 0;
+    let mut processed_iovs = vec![];
+
+    for iov in iovs {
+        processed_iovs.push(WasiIovec {
+            buf: iov.as_ptr() as usize as u32,
+            buf_len: iov.len() as u32,
+        })
+    }
+
+    unsafe {
+        fd_pread(
+            fd,
+            processed_iovs.as_ptr() as usize as u32,
+            processed_iovs.len() as u32,
+            offset,
+            &mut nread as *mut u32 as usize as u32,
+        );
+    }
+    nread
+}
+
+fn main() {
+    let mut base = PathBuf::from("/hamlet");
+
+    base.push("act3/scene4.txt");
+    let file = fs::File::open(&base).expect("Could not open file");
+    let mut buffer = [0u8; 64];
+
+    #[cfg(target_os = "wasi")]
+    {
+        let raw_fd = file.as_raw_fd() as u32;
+        assert_eq!(pread(raw_fd, &[&mut buffer], 75), 64);
+        let str_val = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val);
+        for i in 0..buffer.len() {
+            buffer[i] = 0;
+        }
+        assert_eq!(pread(raw_fd, &[&mut buffer], 75), 64);
+        let str_val2 = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val2);
+
+        println!("Read the same data? {}", str_val == str_val2);
+    }
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!(
+            " POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+ POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+Read the same data? true"
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.stdout
new file mode 100644
index 0000000..c351468
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_pread.stdout
@@ -0,0 +1,9 @@
+ POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+ POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+Read the same data? true
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.rs
new file mode 100644
index 0000000..17394d7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.rs
@@ -0,0 +1,86 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+// this program is used in the pause/resume test
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[repr(C)]
+struct WasiIovec {
+    pub buf: u32,
+    pub buf_len: u32,
+}
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_read(fd: u32, iovs: u32, iovs_len: u32, nread: u32) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn read(fd: u32, iovs: &[&mut [u8]]) -> u32 {
+    let mut nread = 0;
+    let mut processed_iovs = vec![];
+
+    for iov in iovs {
+        processed_iovs.push(WasiIovec {
+            buf: iov.as_ptr() as usize as u32,
+            buf_len: iov.len() as u32,
+        })
+    }
+
+    unsafe {
+        fd_read(
+            fd,
+            processed_iovs.as_ptr() as usize as u32,
+            processed_iovs.len() as u32,
+            &mut nread as *mut u32 as usize as u32,
+        );
+    }
+    nread
+}
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("/hamlet");
+
+    base.push("act3/scene4.txt");
+    let file = fs::File::open(&base).expect("Could not open file");
+    let mut buffer = [0u8; 64];
+
+    #[cfg(target_os = "wasi")]
+    {
+        let raw_fd = file.as_raw_fd() as u32;
+        assert_eq!(read(raw_fd, &[&mut buffer]), 64);
+        let str_val = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val);
+    }
+    // leak the file handle so that we can use it later
+    std::mem::forget(file);
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!(
+            "SCENE IV. The Queen's closet.
+
+    Enter QUEEN GERTRUDE and POLO"
+        );
+    }
+}
+
+#[cfg(target_os = "wasi")]
+#[no_mangle]
+fn second_entry() -> bool {
+    let raw_fd = 5;
+    let mut buffer = [0u8; 8];
+    let _ = read(raw_fd, &[&mut buffer]);
+
+    &buffer == b"NIUS \n\nL"
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.stdout
new file mode 100644
index 0000000..0d6f3c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_read.stdout
@@ -0,0 +1,3 @@
+SCENE IV. The Queen's closet.
+
+    Enter QUEEN GERTRUDE and POLO
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rename_path.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rename_path.rs
new file mode 100644
index 0000000..07acfd7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rename_path.rs
@@ -0,0 +1,28 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let mut idx = 0;
+    fs::create_dir_all(PathBuf::from("test_fs/wasitests"))
+        .expect("cannot create the parent directory");
+
+    let old_path = loop {
+        let old_path = PathBuf::from(format!("test_fs/wasitests/dirtorename-{}", idx));
+        if fs::create_dir(old_path.clone()).ok().is_some() {
+            break old_path;
+        }
+        idx += 1;
+        if idx > 10 {
+            panic!("too many try at creating the folder");
+        }
+    };
+
+    let new_path = PathBuf::from(format!("test_fs/wasitests/dirrenamed-{}", idx));
+
+    fs::rename(old_path, &new_path).expect("cannot rename the directory");
+
+    fs::remove_dir(&new_path).expect("cannot remove the directory");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rename_path.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rename_path.stdout
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rights.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rights.rs
new file mode 100644
index 0000000..71bc68e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rights.rs
@@ -0,0 +1,27 @@
+// WASI:
+// tempdir: .
+
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+fn main() {
+    let file = {
+        let mut base = PathBuf::from(".");
+
+        base.push("foo.txt");
+        base
+    };
+
+    let mut filehandle = std::fs::OpenOptions::new()
+        .read(false) // <- should only be writeable, not readable
+        .write(true)
+        .create(true)
+        .open(&file)
+        .unwrap();
+    filehandle.write_all(b"test").unwrap();
+
+    let mut contents = String::new();
+    assert!(filehandle.read_to_string(&mut contents).is_err());
+
+    std::fs::remove_file(&file).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rights.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_rights.stdout
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.rs
new file mode 100644
index 0000000..342d7bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.rs
@@ -0,0 +1,44 @@
+// WASI:
+// tempdir: .
+
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+    #[cfg(target_os = "wasi")]
+    {
+        base.push("fd_sync_file.txt");
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&base)
+            .expect("Could not create file");
+
+        {
+            use std::io::Write;
+            // example text from https://www.un.org/en/universal-declaration-human-rights/
+            file.write_all(b"All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.").unwrap();
+            file.sync_all().unwrap();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 170);
+            file.set_len(170 + 1234).unwrap();
+            file.sync_all().unwrap();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 1234 + 170);
+        }
+    }
+    #[cfg(target_os = "wasi")]
+    std::fs::remove_file(&base).unwrap();
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!("170");
+        println!("1404");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.stdout
new file mode 100644
index 0000000..ccda92f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fd_sync.stdout
@@ -0,0 +1,2 @@
+170
+1404
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.rs
new file mode 100644
index 0000000..a28909e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.rs
@@ -0,0 +1,18 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+
+fn main() {
+    let this_file = fs::File::open("/hamlet/act1/scene1.txt").expect("could not find file");
+    let md = this_file.metadata().unwrap();
+    println!("is dir: {}", md.is_dir());
+    let filetype = md.file_type();
+    println!(
+        "filetype: {} {} {}",
+        filetype.is_dir(),
+        filetype.is_file(),
+        filetype.is_symlink()
+    );
+    println!("file info: {}", md.len());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.stdout
new file mode 100644
index 0000000..20f2304
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_file_metadata.stdout
@@ -0,0 +1,3 @@
+is dir: false
+filetype: false true false
+file info: 8866
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.rs
new file mode 100644
index 0000000..acd9dde
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.rs
@@ -0,0 +1,10 @@
+fn main() {
+    #[cfg(target = "wasi")]
+    let result = std::fs::read_dir("..");
+    #[cfg(not(target = "wasi"))]
+    let result: Result<(), String> = Err("placeholder".to_string());
+    println!(
+        "Reading the parent directory was okay? {:?}",
+        result.is_ok()
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.stdout
new file mode 100644
index 0000000..e98c9da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fs_sandbox.stdout
@@ -0,0 +1 @@
+Reading the parent directory was okay? false
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.rs
new file mode 100644
index 0000000..568523f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.rs
@@ -0,0 +1,47 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom};
+use std::path::PathBuf;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("/hamlet");
+
+    base.push("act1/scene3.txt");
+
+    let mut file = fs::File::open(&base).expect("Could not open file");
+
+    let mut buffer = [0u8; 32];
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Start(123)).unwrap(), 123);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::End(-123)).unwrap(), 6617);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Current(-250)).unwrap(), 6399);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Current(50)).unwrap(), 6481);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.stdout
new file mode 100644
index 0000000..c9f09be
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_fseek.stdout
@@ -0,0 +1,11 @@
+SCENE III. A room in Polonius' h
+ouse.
+
+    Enter LAERTES and OPH
+    And, sister, as the winds gi
+r talk with the Lord Hamlet.
+   
+uits,
+    Breathing like sanctif
+is is for all:
+    I would not, 
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.rs
new file mode 100644
index 0000000..e7a11a9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.stdout
new file mode 100644
index 0000000..af5626b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_hello.stdout
@@ -0,0 +1 @@
+Hello, world!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.rs
new file mode 100644
index 0000000..c2bc33b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.rs
@@ -0,0 +1,30 @@
+// WASI:
+// dir: test_fs
+#![feature(wasi_ext)]
+
+use std::fs;
+use std::os::wasi::fs::MetadataExt;
+
+// `test_fs` will be implicit.
+// this need experimentat MetadataExt
+// this program does nothing in native
+// it only tests things in wasi
+fn main() {
+    let meta1 = fs::metadata("/hamlet/act1/scene1.txt").expect("could not find src file");
+    let meta2 = fs::metadata("/hamlet/act1/scene2.txt").expect("could not find src file");
+    if meta1.dev() == meta2.dev() && meta1.ino() == meta2.ino() {
+        println!("Warning, different files from same folder have same dev/inod");
+    }
+    let meta3 = fs::metadata("/hamlet/act2/scene1.txt").expect("could not find src file");
+    if meta1.dev() == meta3.dev() && meta1.ino() == meta3.ino() {
+        println!(
+            "Warning, different files from different folder with same name  have same dev/inod"
+        );
+    }
+    let meta4 = fs::metadata("/hamlet/act1/../act1/scene1.txt").expect("could not find src file");
+    if meta1.dev() != meta4.dev() || meta1.ino() != meta4.ino() {
+        println!("Warning, same files have different dev/inod");
+    }
+
+    println!("all done");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.stdout
new file mode 100644
index 0000000..de63914
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_inode.stdout
@@ -0,0 +1 @@
+all done
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.rs
new file mode 100644
index 0000000..1a19f10
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.rs
@@ -0,0 +1,13 @@
+// We don't have access to libc, so we just use isatty
+// as an external function
+// use libc::isatty;
+
+extern "C" {
+    pub fn isatty(fd: i32) -> i32;
+}
+
+fn main() {
+    println!("stdin: {}", unsafe { isatty(0) });
+    println!("stdout: {}", unsafe { isatty(1) });
+    println!("stderr: {}", unsafe { isatty(2) });
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.stdout
new file mode 100644
index 0000000..497b578
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_isatty.stdout
@@ -0,0 +1,3 @@
+stdin: 1
+stdout: 1
+stderr: 1
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.rs
new file mode 100644
index 0000000..112d5db
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.rs
@@ -0,0 +1,19 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+
+fn main() {
+    std::env::set_current_dir("/hamlet").unwrap();
+
+    let read_dir = fs::read_dir(".").unwrap();
+    let mut out = vec![];
+    for entry in read_dir {
+        out.push(format!("{:?}", entry.unwrap().path()));
+    }
+    out.sort();
+
+    for p in out {
+        println!("{}", p);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.stdout
new file mode 100644
index 0000000..8f5d6ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir.stdout
@@ -0,0 +1,7 @@
+"./README.md"
+"./act1"
+"./act2"
+"./act3"
+"./act4"
+"./act5"
+"./bookmarks"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.rs
new file mode 100644
index 0000000..537560f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.rs
@@ -0,0 +1,20 @@
+// WASI:
+// mapdir: /hamlet:test_fs/hamlet
+
+use std::fs;
+use std::io::Read;
+use std::path::PathBuf;
+
+fn main() {
+    let mut base = PathBuf::from("/hamlet");
+
+    base.push("act3/scene3.txt");
+
+    println!("File exists? {}", base.exists());
+
+    let mut f = fs::File::open(&base).unwrap();
+    let mut s = String::new();
+    f.read_to_string(&mut s).unwrap();
+
+    println!("{}", s.chars().take(252).collect::<String>());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.stdout
new file mode 100644
index 0000000..9b511c6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_mapdir_with_leading_slash.stdout
@@ -0,0 +1,10 @@
+File exists? true
+SCENE III. A room in the castle.
+
+    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    I like him not, nor stands it safe with us
+    To let his madness range. Therefore prepare you;
+    I your commission will forthwith dispatch,
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.rs
new file mode 100644
index 0000000..31dafc7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.rs
@@ -0,0 +1,39 @@
+// WASI:
+// mapdir: act5:test_fs/hamlet/act5
+// tempdir: temp
+
+use std::fs;
+use std::io::Read;
+
+fn main() {
+    {
+        std::fs::hard_link("/hamlet/act5/scene1.txt", "/tmp/scene_of_the_day.txt").unwrap();
+        let mut f = fs::OpenOptions::new()
+            .read(true)
+            .open("/tmp/scene_of_the_day.txt")
+            .unwrap();
+        let mut buffer = [0u8; 64];
+        f.read_exact(&mut buffer).unwrap();
+
+        println!("{}", std::str::from_utf8(&buffer[..]).unwrap());
+        for b in buffer.iter_mut() {
+            *b = 0;
+        }
+
+        let mut f = fs::OpenOptions::new()
+            .read(true)
+            .open("/hamlet/act5/scene1.txt")
+            .unwrap();
+        f.read_exact(&mut buffer).unwrap();
+        println!("{}", std::str::from_utf8(&buffer[..]).unwrap());
+    }
+
+    std::fs::remove_file("/tmp/scene_of_the_day.txt").unwrap();
+    let path = std::path::PathBuf::from("act5/scene1.txt");
+
+    if path.exists() {
+        println!("Path still exists");
+    } else {
+        println!("Path was deleted!");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.stdout
new file mode 100644
index 0000000..5766601
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_link.stdout
@@ -0,0 +1,9 @@
+ACT V
+SCENE I. A churchyard.
+
+    Enter two Clowns, with spades,
+ACT V
+SCENE I. A churchyard.
+
+    Enter two Clowns, with spades,
+Path was deleted!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.rs
new file mode 100644
index 0000000..7469ae2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.rs
@@ -0,0 +1,225 @@
+// WASI:
+// tempdir: temp
+
+use std::fs;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+fn run_with_toplevel_dir() {
+    let base = PathBuf::from("/tmp");
+
+    let file_to_create = base.join("path_rename_file.txt");
+    let file_to_rename_to = base.join("path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        // text from https://ja.wikipedia.org/wiki/柴犬
+        let shiba_string = "「柴犬」という名前は中央高地で使われていたもので、文献上では、昭和初期の日本犬保存会の会誌「日本犬」で用いられている。一般的には、「柴」は小ぶりな雑木を指す。
+由来には諸説があり、
+
+    柴藪を巧みにくぐり抜けて猟を助けることから
+    赤褐色の毛色が枯れ柴に似ている（柴赤）ことから
+    小さなものを表す古語の「柴」から
+
+の3つの説が代表的。";
+        let shiba_bytes: Vec<u8> = shiba_string.bytes().collect();
+        f.write_all(&shiba_bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("The original file still exists!");
+        return;
+    } else {
+        println!("The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("The moved file does not exist!");
+        return;
+    }
+
+    // TODO: add temp directory suport for native execution...
+    // until then, don't actually inspect the directory when running native code.
+    for item in fs::read_dir(&base).unwrap() {
+        println!(
+            "Found item: {}",
+            item.unwrap().path().file_name().unwrap().to_str().unwrap()
+        );
+    }
+
+    let mut out_str = String::new();
+    file.read_to_string(&mut out_str).unwrap();
+    let mut test_str = String::new();
+    let mut out_chars = out_str.chars();
+    out_chars.next().unwrap();
+    test_str.push(out_chars.next().unwrap());
+    test_str.push(out_chars.next().unwrap());
+
+    println!("{}", test_str);
+    std::fs::remove_file(file_to_rename_to).unwrap();
+}
+
+fn run_with_toplevel_dir_overwrite() {
+    let base = PathBuf::from("/tmp");
+
+    let file_to_create = base.join("path_rename_file.txt");
+    let file_to_rename_to = base.join("path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        // text from https://ja.wikipedia.org/wiki/柴犬
+        let shiba_string = "「柴犬」という名前は中央高地で使われていたもので、文献上では、昭和初期の日本犬保存会の会誌「日本犬」で用いられている。一般的には、「柴」は小ぶりな雑木を指す。
+由来には諸説があり、
+
+    柴藪を巧みにくぐり抜けて猟を助けることから
+    赤褐色の毛色が枯れ柴に似ている（柴赤）ことから
+    小さなものを表す古語の「柴」から
+
+の3つの説が代表的。";
+        f.write_all(shiba_string.as_bytes()).unwrap();
+    }
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_rename_to)
+            .unwrap();
+
+        let lorem_string = "lorem ispum";
+        f.write_all(lorem_string.as_bytes()).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("The original file still exists!");
+        return;
+    } else {
+        println!("The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("The moved file does not exist!");
+        return;
+    }
+
+    // TODO: add temp directory suport for native execution...
+    // until then, don't actually inspect the directory when running native code.
+    for item in fs::read_dir(&base).unwrap() {
+        println!(
+            "Found item: {}",
+            item.unwrap().path().file_name().unwrap().to_str().unwrap()
+        );
+    }
+
+    let mut out_str = String::new();
+    file.read_to_string(&mut out_str).unwrap();
+    let mut test_str = String::new();
+    let mut out_chars = out_str.chars();
+    out_chars.next().unwrap();
+    test_str.push(out_chars.next().unwrap());
+    test_str.push(out_chars.next().unwrap());
+
+    println!("{}", test_str);
+    std::fs::remove_file(file_to_rename_to).unwrap();
+}
+
+fn run_with_sub_dir() {
+    let base = PathBuf::from("/tmp");
+
+    //make a sub-directory
+    fs::create_dir(base.join("sub")).unwrap();
+
+    let file_to_create = base.join("sub/path_rename_file.txt");
+    let file_to_rename_to = base.join("sub/path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        let string = "Hello world";
+        let bytes: Vec<u8> = string.bytes().collect();
+        f.write_all(&bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let _file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("run_with_sub_dir: The original file still exists!");
+        return;
+    } else {
+        println!("run_with_sub_dir: The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("run_with_sub_dir: The moved file does not exist!");
+        return;
+    }
+    fs::remove_dir_all(base.join("sub")).unwrap();
+}
+
+fn run_with_different_sub_dirs() {
+    let base = PathBuf::from("/tmp");
+
+    //make sub-directories
+    fs::create_dir(base.join("a")).unwrap();
+    fs::create_dir(base.join("a/b")).unwrap();
+    fs::create_dir(base.join("c")).unwrap();
+    fs::create_dir(base.join("c/d")).unwrap();
+    fs::create_dir(base.join("c/d/e")).unwrap();
+
+    let file_to_create = base.join("a/b/path_rename_file.txt");
+    let file_to_rename_to = base.join("c/d/e/path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        let string = "Hello world";
+        let bytes: Vec<u8> = string.bytes().collect();
+        f.write_all(&bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let _file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("run_with_different_sub_dirs: The original file still exists!");
+        return;
+    } else {
+        println!("run_with_different_sub_dirs: The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("run_with_different_sub_dirs: The moved file does not exist!");
+        return;
+    }
+
+    fs::remove_dir_all(base.join("a")).unwrap();
+    fs::remove_dir_all(base.join("c")).unwrap();
+}
+
+fn main() {
+    run_with_toplevel_dir();
+    run_with_toplevel_dir_overwrite();
+    run_with_sub_dir();
+    run_with_different_sub_dirs();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.stdout
new file mode 100644
index 0000000..e3dd86d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_rename.stdout
@@ -0,0 +1,8 @@
+The original file does not still exist!
+Found item: path_renamed_file.txt
+柴犬
+The original file does not still exist!
+Found item: path_renamed_file.txt
+柴犬
+run_with_sub_dir: The original file does not still exist!
+run_with_different_sub_dirs: The original file does not still exist!
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.rs
new file mode 100644
index 0000000..aedff9a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.rs
@@ -0,0 +1,28 @@
+// WASI:
+// tempdir: temp
+// mapdir: hamlet:test_fs/hamlet
+
+use std::fs;
+use std::io::Read;
+use std::path::PathBuf;
+
+fn main() {
+    let base = PathBuf::from("/hamlet");
+
+    let symlink_loc = base.join("/tmp/act3");
+    let symlink_target = "/hamlet/act3";
+    let scene1 = symlink_loc.join("scene1.txt");
+
+    #[allow(deprecated)]
+    std::fs::soft_link(&symlink_target, &symlink_loc).unwrap();
+
+    let mut file = fs::File::open(&scene1).expect("Could not open file");
+
+    let mut buffer = [0u8; 64];
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 64);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    std::fs::remove_file(symlink_loc).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.stdout
new file mode 100644
index 0000000..085a928
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_path_symlink.stdout
@@ -0,0 +1,4 @@
+ACT III
+SCENE I. A room in the castle.
+
+    Enter KING CLAUDIUS,
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.rs
new file mode 100644
index 0000000..0778cd6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.rs
@@ -0,0 +1,13 @@
+// WASI:
+// stdin: "Hello, world!"
+
+use std::io;
+
+fn main() {
+    let mut input = String::new();
+    io::stdin().read_line(&mut input).unwrap();
+
+    let output: String = input.chars().rev().collect();
+
+    println!("{}", output);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdin b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdin
new file mode 100644
index 0000000..5dd01c1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdin
@@ -0,0 +1 @@
+Hello, world!
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdout
new file mode 100644
index 0000000..20d0e69
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_pipe_reverse.stdout
@@ -0,0 +1 @@
+!dlrow ,olleH
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.rs
new file mode 100644
index 0000000..e4b464d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.rs
@@ -0,0 +1,204 @@
+// WASI:
+// mapdir: hamlet:test_fs/hamlet
+// tempdir: temp
+
+use std::fs;
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn poll_oneoff(subscriptions: u32, events: u32, nsubscriptions: u32, nevents: u32) -> u16;
+}
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct __wasi_event_t {
+    pub userdata: u64,
+    pub error: u16,
+    pub type_: __wasi_eventtype_t,
+    pub u: __wasi_event_u,
+}
+
+impl Default for __wasi_event_t {
+    fn default() -> Self {
+        __wasi_event_t {
+            userdata: 0,
+            error: 0,
+            type_: 0,
+            u: __wasi_event_u {
+                fd_readwrite: __wasi_event_fd_readwrite_t {
+                    nbytes: 0,
+                    flags: 0,
+                },
+            },
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_event_fd_readwrite_t {
+    pub nbytes: u64,
+    pub flags: u16,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __wasi_event_u {
+    pub fd_readwrite: __wasi_event_fd_readwrite_t,
+}
+
+impl std::fmt::Debug for __wasi_event_u {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "__wasi_event_u {{ ")?;
+        write!(f, "{:?} }}", unsafe { self.fd_readwrite })
+    }
+}
+
+#[allow(non_camel_case_types)]
+pub type __wasi_eventtype_t = u8;
+#[allow(non_camel_case_types)]
+pub const __WASI_EVENTTYPE_CLOCK: u8 = 0;
+#[allow(non_camel_case_types)]
+pub const __WASI_EVENTTYPE_FD_READ: u8 = 1;
+#[allow(non_camel_case_types)]
+pub const __WASI_EVENTTYPE_FD_WRITE: u8 = 2;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_subscription_clock_t {
+    pub userdata: u64,
+    pub clock_id: u32,
+    pub timeout: u64,
+    pub precision: u64,
+    pub flags: u16,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_subscription_fs_readwrite_t {
+    pub fd: u32,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __wasi_subscription_u {
+    clock: __wasi_subscription_clock_t,
+    fd_readwrite: __wasi_subscription_fs_readwrite_t,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct __wasi_subscription_t {
+    pub userdata: u64,
+    pub type_: __wasi_eventtype_t,
+    pub u: __wasi_subscription_u,
+}
+
+fn poll(fds: &[u32], read: &[bool], write: &[bool]) -> Result<Vec<__wasi_event_t>, u16> {
+    assert!(fds.len() == read.len() && read.len() == write.len());
+
+    let in_ = fds
+        .iter()
+        .enumerate()
+        .map(|(i, n)| {
+            let mut type_ = 0;
+            if read[i] {
+                type_ |= __WASI_EVENTTYPE_FD_READ;
+            }
+            if write[i] {
+                type_ |= __WASI_EVENTTYPE_FD_WRITE;
+            }
+            __wasi_subscription_t {
+                userdata: 0x123456,
+                type_,
+                u: __wasi_subscription_u {
+                    fd_readwrite: __wasi_subscription_fs_readwrite_t { fd: *n as u32 },
+                },
+            }
+        })
+        .collect::<Vec<_>>();
+    let mut out_ = vec![Default::default(); in_.len()];
+    let mut nsubscriptions: u32 = 0;
+    let result = unsafe {
+        poll_oneoff(
+            in_.as_ptr() as usize as u32,
+            out_.as_mut_ptr() as usize as u32,
+            in_.len() as u32,
+            (&mut nsubscriptions as *mut u32) as usize as u32,
+        )
+    };
+
+    if result == 0 {
+        Ok(out_)
+    } else {
+        Err(result)
+    }
+}
+
+fn main() {
+    let base = PathBuf::from("/hamlet");
+
+    let path = base.join("act4/scene1.txt");
+    let path2 = base.join("poll_oneoff_write.txt");
+    {
+        let file = fs::File::open(&path).expect("Could not open file");
+        let file2 = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&path2)
+            .expect("Could not open file");
+        file2.set_len(1234).unwrap();
+
+        let fds = vec![file.as_raw_fd() as u32];
+        let mut result = poll(fds.as_slice(), &[true], &[false]).expect("First poll");
+        while result[0].error != 0 {
+            result = poll(fds.as_slice(), &[true], &[false]).expect("subsequent polls");
+        }
+        println!("{:?}", result[0]);
+
+        let fds = vec![file.as_raw_fd() as u32, file2.as_raw_fd() as u32];
+        result = poll(fds.as_slice(), &[true, false], &[false, true]).expect("First poll");
+        while result[0].error != 0 {
+            result =
+                poll(fds.as_slice(), &[true, false], &[false, true]).expect("subsequent polls");
+        }
+        println!("{:?}", result);
+
+        // stdin, stdout, stderr checking
+        let fds = vec![std::io::stdin().as_raw_fd() as u32];
+        print!("Stdin: ");
+        println!(
+            "{}",
+            if poll(fds.as_slice(), &[true], &[false]).is_ok() {
+                "OK"
+            } else {
+                "ERROR"
+            }
+        );
+        let fds = vec![std::io::stdout().as_raw_fd() as u32];
+        print!("Stdout: ");
+        println!(
+            "{}",
+            if poll(fds.as_slice(), &[false], &[true]).is_ok() {
+                "OK"
+            } else {
+                "ERROR"
+            }
+        );
+        let fds = vec![std::io::stderr().as_raw_fd() as u32];
+        print!("Stderr: ");
+        println!(
+            "{}",
+            if poll(fds.as_slice(), &[false], &[true]).is_ok() {
+                "OK"
+            } else {
+                "ERROR"
+            }
+        );
+    }
+
+    std::fs::remove_file(path2).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.stdout
new file mode 100644
index 0000000..0b96e30
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_poll_oneoff.stdout
@@ -0,0 +1,5 @@
+__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }
+[__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }, __wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 8192, flags: 0 } } }]
+Stdin: OK
+Stdout: OK
+Stderr: OK
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.rs
new file mode 100644
index 0000000..8d4084d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.rs
@@ -0,0 +1,15 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io::Read;
+
+// NOTE: This program is no longer a quine because we want to sandbox these tests to `test_fs`, in the future
+// `test_fs` will be implicit.
+fn main() {
+    let mut this_file = fs::File::open("/hamlet/act1/scene2.txt").expect("could not find src file");
+    let _ = this_file.metadata().unwrap();
+    let mut in_str = String::new();
+    this_file.read_to_string(&mut in_str).unwrap();
+    println!("{}", in_str);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.stdout
new file mode 100644
index 0000000..1ef4181
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_quine.stdout
@@ -0,0 +1,513 @@
+SCENE II. A room of state in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants 
+
+KING CLAUDIUS
+
+    Though yet of Hamlet our dear brother's death
+    The memory be green, and that it us befitted
+    To bear our hearts in grief and our whole kingdom
+    To be contracted in one brow of woe,
+    Yet so far hath discretion fought with nature
+    That we with wisest sorrow think on him,
+    Together with remembrance of ourselves.
+    Therefore our sometime sister, now our queen,
+    The imperial jointress to this warlike state,
+    Have we, as 'twere with a defeated joy,--
+    With an auspicious and a dropping eye,
+    With mirth in funeral and with dirge in marriage,
+    In equal scale weighing delight and dole,--
+    Taken to wife: nor have we herein barr'd
+    Your better wisdoms, which have freely gone
+    With this affair along. For all, our thanks.
+    Now follows, that you know, young Fortinbras,
+    Holding a weak supposal of our worth,
+    Or thinking by our late dear brother's death
+    Our state to be disjoint and out of frame,
+    Colleagued with the dream of his advantage,
+    He hath not fail'd to pester us with message,
+    Importing the surrender of those lands
+    Lost by his father, with all bonds of law,
+    To our most valiant brother. So much for him.
+    Now for ourself and for this time of meeting:
+    Thus much the business is: we have here writ
+    To Norway, uncle of young Fortinbras,--
+    Who, impotent and bed-rid, scarcely hears
+    Of this his nephew's purpose,--to suppress
+    His further gait herein; in that the levies,
+    The lists and full proportions, are all made
+    Out of his subject: and we here dispatch
+    You, good Cornelius, and you, Voltimand,
+    For bearers of this greeting to old Norway;
+    Giving to you no further personal power
+    To business with the king, more than the scope
+    Of these delated articles allow.
+    Farewell, and let your haste commend your duty.
+
+CORNELIUS VOLTIMAND
+
+    In that and all things will we show our duty.
+
+KING CLAUDIUS
+
+    We doubt it nothing: heartily farewell.
+
+    Exeunt VOLTIMAND and CORNELIUS
+    And now, Laertes, what's the news with you?
+    You told us of some suit; what is't, Laertes?
+    You cannot speak of reason to the Dane,
+    And loose your voice: what wouldst thou beg, Laertes,
+    That shall not be my offer, not thy asking?
+    The head is not more native to the heart,
+    The hand more instrumental to the mouth,
+    Than is the throne of Denmark to thy father.
+    What wouldst thou have, Laertes?
+
+LAERTES
+
+    My dread lord,
+    Your leave and favour to return to France;
+    From whence though willingly I came to Denmark,
+    To show my duty in your coronation,
+    Yet now, I must confess, that duty done,
+    My thoughts and wishes bend again toward France
+    And bow them to your gracious leave and pardon.
+
+KING CLAUDIUS
+
+    Have you your father's leave? What says Polonius?
+
+LORD POLONIUS
+
+    He hath, my lord, wrung from me my slow leave
+    By laboursome petition, and at last
+    Upon his will I seal'd my hard consent:
+    I do beseech you, give him leave to go.
+
+KING CLAUDIUS
+
+    Take thy fair hour, Laertes; time be thine,
+    And thy best graces spend it at thy will!
+    But now, my cousin Hamlet, and my son,--
+
+HAMLET
+
+    [Aside] A little more than kin, and less than kind.
+
+KING CLAUDIUS
+
+    How is it that the clouds still hang on you?
+
+HAMLET
+
+    Not so, my lord; I am too much i' the sun.
+
+QUEEN GERTRUDE
+
+    Good Hamlet, cast thy nighted colour off,
+    And let thine eye look like a friend on Denmark.
+    Do not for ever with thy vailed lids
+    Seek for thy noble father in the dust:
+    Thou know'st 'tis common; all that lives must die,
+    Passing through nature to eternity.
+
+HAMLET
+
+    Ay, madam, it is common.
+
+QUEEN GERTRUDE
+
+    If it be,
+    Why seems it so particular with thee?
+
+HAMLET
+
+    Seems, madam! nay it is; I know not 'seems.'
+    'Tis not alone my inky cloak, good mother,
+    Nor customary suits of solemn black,
+    Nor windy suspiration of forced breath,
+    No, nor the fruitful river in the eye,
+    Nor the dejected 'havior of the visage,
+    Together with all forms, moods, shapes of grief,
+    That can denote me truly: these indeed seem,
+    For they are actions that a man might play:
+    But I have that within which passeth show;
+    These but the trappings and the suits of woe.
+
+KING CLAUDIUS
+
+    'Tis sweet and commendable in your nature, Hamlet,
+    To give these mourning duties to your father:
+    But, you must know, your father lost a father;
+    That father lost, lost his, and the survivor bound
+    In filial obligation for some term
+    To do obsequious sorrow: but to persever
+    In obstinate condolement is a course
+    Of impious stubbornness; 'tis unmanly grief;
+    It shows a will most incorrect to heaven,
+    A heart unfortified, a mind impatient,
+    An understanding simple and unschool'd:
+    For what we know must be and is as common
+    As any the most vulgar thing to sense,
+    Why should we in our peevish opposition
+    Take it to heart? Fie! 'tis a fault to heaven,
+    A fault against the dead, a fault to nature,
+    To reason most absurd: whose common theme
+    Is death of fathers, and who still hath cried,
+    From the first corse till he that died to-day,
+    'This must be so.' We pray you, throw to earth
+    This unprevailing woe, and think of us
+    As of a father: for let the world take note,
+    You are the most immediate to our throne;
+    And with no less nobility of love
+    Than that which dearest father bears his son,
+    Do I impart toward you. For your intent
+    In going back to school in Wittenberg,
+    It is most retrograde to our desire:
+    And we beseech you, bend you to remain
+    Here, in the cheer and comfort of our eye,
+    Our chiefest courtier, cousin, and our son.
+
+QUEEN GERTRUDE
+
+    Let not thy mother lose her prayers, Hamlet:
+    I pray thee, stay with us; go not to Wittenberg.
+
+HAMLET
+
+    I shall in all my best obey you, madam.
+
+KING CLAUDIUS
+
+    Why, 'tis a loving and a fair reply:
+    Be as ourself in Denmark. Madam, come;
+    This gentle and unforced accord of Hamlet
+    Sits smiling to my heart: in grace whereof,
+    No jocund health that Denmark drinks to-day,
+    But the great cannon to the clouds shall tell,
+    And the king's rouse the heavens all bruit again,
+    Re-speaking earthly thunder. Come away.
+
+    Exeunt all but HAMLET
+
+HAMLET
+
+    O, that this too too solid flesh would melt
+    Thaw and resolve itself into a dew!
+    Or that the Everlasting had not fix'd
+    His canon 'gainst self-slaughter! O God! God!
+    How weary, stale, flat and unprofitable,
+    Seem to me all the uses of this world!
+    Fie on't! ah fie! 'tis an unweeded garden,
+    That grows to seed; things rank and gross in nature
+    Possess it merely. That it should come to this!
+    But two months dead: nay, not so much, not two:
+    So excellent a king; that was, to this,
+    Hyperion to a satyr; so loving to my mother
+    That he might not beteem the winds of heaven
+    Visit her face too roughly. Heaven and earth!
+    Must I remember? why, she would hang on him,
+    As if increase of appetite had grown
+    By what it fed on: and yet, within a month--
+    Let me not think on't--Frailty, thy name is woman!--
+    A little month, or ere those shoes were old
+    With which she follow'd my poor father's body,
+    Like Niobe, all tears:--why she, even she--
+    O, God! a beast, that wants discourse of reason,
+    Would have mourn'd longer--married with my uncle,
+    My father's brother, but no more like my father
+    Than I to Hercules: within a month:
+    Ere yet the salt of most unrighteous tears
+    Had left the flushing in her galled eyes,
+    She married. O, most wicked speed, to post
+    With such dexterity to incestuous sheets!
+    It is not nor it cannot come to good:
+    But break, my heart; for I must hold my tongue.
+
+    Enter HORATIO, MARCELLUS, and BERNARDO
+
+HORATIO
+
+    Hail to your lordship!
+
+HAMLET
+
+    I am glad to see you well:
+    Horatio,--or I do forget myself.
+
+HORATIO
+
+    The same, my lord, and your poor servant ever.
+
+HAMLET
+
+    Sir, my good friend; I'll change that name with you:
+    And what make you from Wittenberg, Horatio? Marcellus?
+
+MARCELLUS
+
+    My good lord--
+
+HAMLET
+
+    I am very glad to see you. Good even, sir.
+    But what, in faith, make you from Wittenberg?
+
+HORATIO
+
+    A truant disposition, good my lord.
+
+HAMLET
+
+    I would not hear your enemy say so,
+    Nor shall you do mine ear that violence,
+    To make it truster of your own report
+    Against yourself: I know you are no truant.
+    But what is your affair in Elsinore?
+    We'll teach you to drink deep ere you depart.
+
+HORATIO
+
+    My lord, I came to see your father's funeral.
+
+HAMLET
+
+    I pray thee, do not mock me, fellow-student;
+    I think it was to see my mother's wedding.
+
+HORATIO
+
+    Indeed, my lord, it follow'd hard upon.
+
+HAMLET
+
+    Thrift, thrift, Horatio! the funeral baked meats
+    Did coldly furnish forth the marriage tables.
+    Would I had met my dearest foe in heaven
+    Or ever I had seen that day, Horatio!
+    My father!--methinks I see my father.
+
+HORATIO
+
+    Where, my lord?
+
+HAMLET
+
+    In my mind's eye, Horatio.
+
+HORATIO
+
+    I saw him once; he was a goodly king.
+
+HAMLET
+
+    He was a man, take him for all in all,
+    I shall not look upon his like again.
+
+HORATIO
+
+    My lord, I think I saw him yesternight.
+
+HAMLET
+
+    Saw? who?
+
+HORATIO
+
+    My lord, the king your father.
+
+HAMLET
+
+    The king my father!
+
+HORATIO
+
+    Season your admiration for awhile
+    With an attent ear, till I may deliver,
+    Upon the witness of these gentlemen,
+    This marvel to you.
+
+HAMLET
+
+    For God's love, let me hear.
+
+HORATIO
+
+    Two nights together had these gentlemen,
+    Marcellus and Bernardo, on their watch,
+    In the dead vast and middle of the night,
+    Been thus encounter'd. A figure like your father,
+    Armed at point exactly, cap-a-pe,
+    Appears before them, and with solemn march
+    Goes slow and stately by them: thrice he walk'd
+    By their oppress'd and fear-surprised eyes,
+    Within his truncheon's length; whilst they, distilled
+    Almost to jelly with the act of fear,
+    Stand dumb and speak not to him. This to me
+    In dreadful secrecy impart they did;
+    And I with them the third night kept the watch;
+    Where, as they had deliver'd, both in time,
+    Form of the thing, each word made true and good,
+    The apparition comes: I knew your father;
+    These hands are not more like.
+
+HAMLET
+
+    But where was this?
+
+MARCELLUS
+
+    My lord, upon the platform where we watch'd.
+
+HAMLET
+
+    Did you not speak to it?
+
+HORATIO
+
+    My lord, I did;
+    But answer made it none: yet once methought
+    It lifted up its head and did address
+    Itself to motion, like as it would speak;
+    But even then the morning cock crew loud,
+    And at the sound it shrunk in haste away,
+    And vanish'd from our sight.
+
+HAMLET
+
+    'Tis very strange.
+
+HORATIO
+
+    As I do live, my honour'd lord, 'tis true;
+    And we did think it writ down in our duty
+    To let you know of it.
+
+HAMLET
+
+    Indeed, indeed, sirs, but this troubles me.
+    Hold you the watch to-night?
+
+MARCELLUS BERNARDO
+
+    We do, my lord.
+
+HAMLET
+
+    Arm'd, say you?
+
+MARCELLUS BERNARDO
+
+    Arm'd, my lord.
+
+HAMLET
+
+    From top to toe?
+
+MARCELLUS BERNARDO
+
+    My lord, from head to foot.
+
+HAMLET
+
+    Then saw you not his face?
+
+HORATIO
+
+    O, yes, my lord; he wore his beaver up.
+
+HAMLET
+
+    What, look'd he frowningly?
+
+HORATIO
+
+    A countenance more in sorrow than in anger.
+
+HAMLET
+
+    Pale or red?
+
+HORATIO
+
+    Nay, very pale.
+
+HAMLET
+
+    And fix'd his eyes upon you?
+
+HORATIO
+
+    Most constantly.
+
+HAMLET
+
+    I would I had been there.
+
+HORATIO
+
+    It would have much amazed you.
+
+HAMLET
+
+    Very like, very like. Stay'd it long?
+
+HORATIO
+
+    While one with moderate haste might tell a hundred.
+
+MARCELLUS BERNARDO
+
+    Longer, longer.
+
+HORATIO
+
+    Not when I saw't.
+
+HAMLET
+
+    His beard was grizzled--no?
+
+HORATIO
+
+    It was, as I have seen it in his life,
+    A sable silver'd.
+
+HAMLET
+
+    I will watch to-night;
+    Perchance 'twill walk again.
+
+HORATIO
+
+    I warrant it will.
+
+HAMLET
+
+    If it assume my noble father's person,
+    I'll speak to it, though hell itself should gape
+    And bid me hold my peace. I pray you all,
+    If you have hitherto conceal'd this sight,
+    Let it be tenable in your silence still;
+    And whatsoever else shall hap to-night,
+    Give it an understanding, but no tongue:
+    I will requite your loves. So, fare you well:
+    Upon the platform, 'twixt eleven and twelve,
+    I'll visit you.
+
+All
+
+    Our duty to your honour.
+
+HAMLET
+
+    Your loves, as mine to you: farewell.
+
+    Exeunt all but HAMLET
+    My father's spirit in arms! all is not well;
+    I doubt some foul play: would the night were come!
+    Till then sit still, my soul: foul deeds will rise,
+    Though all the earth o'erwhelm them, to men's eyes.
+
+    Exit
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_readlink.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_readlink.rs
new file mode 100644
index 0000000..7bc3d7b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_readlink.rs
@@ -0,0 +1,28 @@
+// WASI:
+// dir: test_fs
+
+use std::io::Read;
+
+fn main() {
+    let sym_link_path = "/hamlet/bookmarks/2019-07-16";
+
+    let p = std::path::Path::new(sym_link_path);
+    dbg!(&p);
+    println!("{}", p.exists());
+    let link_path = std::fs::read_link(sym_link_path).expect("Could not read link");
+    println!("{}", link_path.to_string_lossy());
+
+    let mut some_contents =
+        std::fs::File::open(sym_link_path).expect("Could not open file via symlink");
+
+    let mut buffer = [0; 128];
+
+    assert_eq!(
+        some_contents
+            .read(&mut buffer)
+            .expect("Could not read 128 bytes from file"),
+        128
+    );
+    let str_val = std::str::from_utf8(&buffer[..]).expect("Could not parse buffer bytes as UTF-8");
+    println!("{}", str_val);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_readlink.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_readlink.stdout
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.rs
new file mode 100644
index 0000000..2a2dde6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.rs
@@ -0,0 +1,42 @@
+// WASI:
+// mapdir: act1:test_fs/hamlet/act1
+// mapdir: act2:test_fs/hamlet/act2
+// mapdir: act1-again:test_fs/hamlet/act1
+
+use std::fs;
+
+fn main() {
+    let results = {
+        let mut out = vec![];
+
+        let read_dir = fs::read_dir("/").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("/hamlet/act1/..").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("/hamlet/act1/../../..").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("/hamlet/act1/../../hamlet/act2/../act1/../../../").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let f = fs::OpenOptions::new().write(true).open("/abc");
+
+        if f.is_ok() {
+            out.push("ROOT IS NOT SAFE".to_string());
+        } else {
+            out.push("ROOT IS SAFE".to_string());
+        }
+
+        out
+    };
+
+    for result in results {
+        println!("{}", result);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.stdout
new file mode 100644
index 0000000..ffc4812
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_wasi_sees_virtual_root.stdout
@@ -0,0 +1,20 @@
+"/.app"
+"/.private"
+"/bin"
+"/dev"
+"/etc"
+"/fyi"
+"/hamlet"
+"/tmp"
+"/hamlet/act1/../README.md"
+"/hamlet/act1/../act1"
+"/hamlet/act1/../act2"
+"/hamlet/act1/../act3"
+"/hamlet/act1/../act4"
+"/hamlet/act1/../act5"
+"/hamlet/act1/../bookmarks"
+"/."
+"//"
+"/."
+"//"
+ROOT IS SAFE
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.rs
new file mode 100644
index 0000000..443ea46
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.rs
@@ -0,0 +1,34 @@
+// WASI:
+// mapdir: act1:test_fs/hamlet/act1
+// mapdir: act2:test_fs/hamlet/act2
+// mapdir: act1-again:test_fs/hamlet/act1
+
+use std::fs;
+use std::io::Write;
+
+pub const BYTE_STR: &'static [u8] = b"abcdefghijklmnopqrstuvwxyz";
+
+fn main() {
+    do_logic_on_path("/hamlet/act1/abc", "/hamlet/act1/abc");
+}
+
+fn do_logic_on_path(path: &'static str, alt_path: &'static str) {
+    {
+        let mut f = fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(path)
+            .unwrap();
+        f.write_all(BYTE_STR).unwrap();
+    }
+
+    println!("{}", fs::read_to_string(alt_path).unwrap());
+    fs::remove_file(path).unwrap();
+
+    let file_path = std::path::Path::new(path);
+    if file_path.exists() {
+        println!("file is here");
+    } else {
+        println!("file is gone")
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.stdout b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.stdout
new file mode 100644
index 0000000..a471ade
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/ported_writing.stdout
@@ -0,0 +1,2 @@
+abcdefghijklmnopqrstuvwxyz
+file is gone
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.rs
new file mode 100644
index 0000000..24ec32c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.rs
@@ -0,0 +1,5 @@
+use std::process;
+
+fn main() {
+  process::exit(0);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.status b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.status
new file mode 100644
index 0000000..573541a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-0.status
@@ -0,0 +1 @@
+0
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.rs
new file mode 100644
index 0000000..2191345
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.rs
@@ -0,0 +1,5 @@
+use std::process;
+
+fn main() {
+  process::exit(1);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.status b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.status
new file mode 100644
index 0000000..d00491f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-1.status
@@ -0,0 +1 @@
+1
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.rs
new file mode 100644
index 0000000..8ff2e51
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.rs
@@ -0,0 +1,5 @@
+use std::process;
+
+fn main() {
+  process::exit(120);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.status b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.status
new file mode 100644
index 0000000..52bd8e4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/process_exit-120.status
@@ -0,0 +1 @@
+120
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test.sh b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test.sh
new file mode 100755
index 0000000..9dbe44c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+set -ueo pipefail
+
+bash build.sh
+
+status=0
+
+# Define skip list as an array
+SKIP_LIST=("ported_readlink.wasm" "fs_create_dir-existing-directory.wasm" "fs_rename-directory.wasm" "fs_rename-file.wasm")
+
+# List and process .foo files
+for file in *.wasm; do
+    if [[ " ${SKIP_LIST[@]} " =~ " ${file} " ]]; then
+        echo "Skipping $file"
+    else
+        echo "Testing $file"
+        ./wasm-test.sh $file || status=1
+    fi
+done
+
+exit $status
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/README.md
new file mode 100644
index 0000000..3384bc2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/README.md
@@ -0,0 +1,9 @@
+# Test FS
+
+This is a test "file system" used in some of the WASI integration tests.
+
+It's just a bunch of files in a tree.
+
+If you make changes here, please regenerate the tests with `make wasitests`!
+
+The contents of `temp` are deleted before each run.  If you want to test making or mutating files, do it in that sub directory.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_create_dir-existing-directory.dir/existing_directory/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_create_dir-existing-directory.dir/existing_directory/.gitignore
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_create_dir-new-directory.dir/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_create_dir-new-directory.dir/.gitignore
new file mode 100644
index 0000000..8d0c781
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_create_dir-new-directory.dir/.gitignore
@@ -0,0 +1 @@
+new_directory
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_file_create.dir/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_file_create.dir/.gitignore
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_metadata-directory.dir/directory/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_metadata-directory.dir/directory/.gitignore
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_metadata-file.dir/file b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_metadata-file.dir/file
new file mode 100644
index 0000000..1a010b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_metadata-file.dir/file
@@ -0,0 +1 @@
+file
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-directory.dir/old_directory/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-directory.dir/old_directory/.gitignore
new file mode 100644
index 0000000..e69de29
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/.gitignore
new file mode 100644
index 0000000..1501d1e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/.gitignore
@@ -0,0 +1 @@
+new_file
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/old_file b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/old_file
new file mode 100644
index 0000000..f73f309
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/fyi/fs_rename-file.dir/old_file
@@ -0,0 +1 @@
+file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/README.md
new file mode 100644
index 0000000..6b96137
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/README.md
@@ -0,0 +1,3 @@
+# Hamlet split in to acts and scenes
+
+From: http://shakespeare.mit.edu/hamlet/full.html
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene1.txt
new file mode 100644
index 0000000..0e0b797
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene1.txt
@@ -0,0 +1,392 @@
+
+The Tragedy of Hamlet, Prince of Denmark
+Shakespeare homepage | Hamlet | Entire play
+ACT I
+SCENE I. Elsinore. A platform before the castle.
+
+    FRANCISCO at his post. Enter to him BERNARDO 
+
+BERNARDO
+
+    Who's there?
+
+FRANCISCO
+
+    Nay, answer me: stand, and unfold yourself.
+
+BERNARDO
+
+    Long live the king!
+
+FRANCISCO
+
+    Bernardo?
+
+BERNARDO
+
+    He.
+
+FRANCISCO
+
+    You come most carefully upon your hour.
+
+BERNARDO
+
+    'Tis now struck twelve; get thee to bed, Francisco.
+
+FRANCISCO
+
+    For this relief much thanks: 'tis bitter cold,
+    And I am sick at heart.
+
+BERNARDO
+
+    Have you had quiet guard?
+
+FRANCISCO
+
+    Not a mouse stirring.
+
+BERNARDO
+
+    Well, good night.
+    If you do meet Horatio and Marcellus,
+    The rivals of my watch, bid them make haste.
+
+FRANCISCO
+
+    I think I hear them. Stand, ho! Who's there?
+
+    Enter HORATIO and MARCELLUS
+
+HORATIO
+
+    Friends to this ground.
+
+MARCELLUS
+
+    And liegemen to the Dane.
+
+FRANCISCO
+
+    Give you good night.
+
+MARCELLUS
+
+    O, farewell, honest soldier:
+    Who hath relieved you?
+
+FRANCISCO
+
+    Bernardo has my place.
+    Give you good night.
+
+    Exit
+
+MARCELLUS
+
+    Holla! Bernardo!
+
+BERNARDO
+
+    Say,
+    What, is Horatio there?
+
+HORATIO
+
+    A piece of him.
+
+BERNARDO
+
+    Welcome, Horatio: welcome, good Marcellus.
+
+MARCELLUS
+
+    What, has this thing appear'd again to-night?
+
+BERNARDO
+
+    I have seen nothing.
+
+MARCELLUS
+
+    Horatio says 'tis but our fantasy,
+    And will not let belief take hold of him
+    Touching this dreaded sight, twice seen of us:
+    Therefore I have entreated him along
+    With us to watch the minutes of this night;
+    That if again this apparition come,
+    He may approve our eyes and speak to it.
+
+HORATIO
+
+    Tush, tush, 'twill not appear.
+
+BERNARDO
+
+    Sit down awhile;
+    And let us once again assail your ears,
+    That are so fortified against our story
+    What we have two nights seen.
+
+HORATIO
+
+    Well, sit we down,
+    And let us hear Bernardo speak of this.
+
+BERNARDO
+
+    Last night of all,
+    When yond same star that's westward from the pole
+    Had made his course to illume that part of heaven
+    Where now it burns, Marcellus and myself,
+    The bell then beating one,--
+
+    Enter Ghost
+
+MARCELLUS
+
+    Peace, break thee off; look, where it comes again!
+
+BERNARDO
+
+    In the same figure, like the king that's dead.
+
+MARCELLUS
+
+    Thou art a scholar; speak to it, Horatio.
+
+BERNARDO
+
+    Looks it not like the king? mark it, Horatio.
+
+HORATIO
+
+    Most like: it harrows me with fear and wonder.
+
+BERNARDO
+
+    It would be spoke to.
+
+MARCELLUS
+
+    Question it, Horatio.
+
+HORATIO
+
+    What art thou that usurp'st this time of night,
+    Together with that fair and warlike form
+    In which the majesty of buried Denmark
+    Did sometimes march? by heaven I charge thee, speak!
+
+MARCELLUS
+
+    It is offended.
+
+BERNARDO
+
+    See, it stalks away!
+
+HORATIO
+
+    Stay! speak, speak! I charge thee, speak!
+
+    Exit Ghost
+
+MARCELLUS
+
+    'Tis gone, and will not answer.
+
+BERNARDO
+
+    How now, Horatio! you tremble and look pale:
+    Is not this something more than fantasy?
+    What think you on't?
+
+HORATIO
+
+    Before my God, I might not this believe
+    Without the sensible and true avouch
+    Of mine own eyes.
+
+MARCELLUS
+
+    Is it not like the king?
+
+HORATIO
+
+    As thou art to thyself:
+    Such was the very armour he had on
+    When he the ambitious Norway combated;
+    So frown'd he once, when, in an angry parle,
+    He smote the sledded Polacks on the ice.
+    'Tis strange.
+
+MARCELLUS
+
+    Thus twice before, and jump at this dead hour,
+    With martial stalk hath he gone by our watch.
+
+HORATIO
+
+    In what particular thought to work I know not;
+    But in the gross and scope of my opinion,
+    This bodes some strange eruption to our state.
+
+MARCELLUS
+
+    Good now, sit down, and tell me, he that knows,
+    Why this same strict and most observant watch
+    So nightly toils the subject of the land,
+    And why such daily cast of brazen cannon,
+    And foreign mart for implements of war;
+    Why such impress of shipwrights, whose sore task
+    Does not divide the Sunday from the week;
+    What might be toward, that this sweaty haste
+    Doth make the night joint-labourer with the day:
+    Who is't that can inform me?
+
+HORATIO
+
+    That can I;
+    At least, the whisper goes so. Our last king,
+    Whose image even but now appear'd to us,
+    Was, as you know, by Fortinbras of Norway,
+    Thereto prick'd on by a most emulate pride,
+    Dared to the combat; in which our valiant Hamlet--
+    For so this side of our known world esteem'd him--
+    Did slay this Fortinbras; who by a seal'd compact,
+    Well ratified by law and heraldry,
+    Did forfeit, with his life, all those his lands
+    Which he stood seized of, to the conqueror:
+    Against the which, a moiety competent
+    Was gaged by our king; which had return'd
+    To the inheritance of Fortinbras,
+    Had he been vanquisher; as, by the same covenant,
+    And carriage of the article design'd,
+    His fell to Hamlet. Now, sir, young Fortinbras,
+    Of unimproved mettle hot and full,
+    Hath in the skirts of Norway here and there
+    Shark'd up a list of lawless resolutes,
+    For food and diet, to some enterprise
+    That hath a stomach in't; which is no other--
+    As it doth well appear unto our state--
+    But to recover of us, by strong hand
+    And terms compulsatory, those foresaid lands
+    So by his father lost: and this, I take it,
+    Is the main motive of our preparations,
+    The source of this our watch and the chief head
+    Of this post-haste and romage in the land.
+
+BERNARDO
+
+    I think it be no other but e'en so:
+    Well may it sort that this portentous figure
+    Comes armed through our watch; so like the king
+    That was and is the question of these wars.
+
+HORATIO
+
+    A mote it is to trouble the mind's eye.
+    In the most high and palmy state of Rome,
+    A little ere the mightiest Julius fell,
+    The graves stood tenantless and the sheeted dead
+    Did squeak and gibber in the Roman streets:
+    As stars with trains of fire and dews of blood,
+    Disasters in the sun; and the moist star
+    Upon whose influence Neptune's empire stands
+    Was sick almost to doomsday with eclipse:
+    And even the like precurse of fierce events,
+    As harbingers preceding still the fates
+    And prologue to the omen coming on,
+    Have heaven and earth together demonstrated
+    Unto our climatures and countrymen.--
+    But soft, behold! lo, where it comes again!
+
+    Re-enter Ghost
+    I'll cross it, though it blast me. Stay, illusion!
+    If thou hast any sound, or use of voice,
+    Speak to me:
+    If there be any good thing to be done,
+    That may to thee do ease and grace to me,
+    Speak to me:
+
+    Cock crows
+    If thou art privy to thy country's fate,
+    Which, happily, foreknowing may avoid, O, speak!
+    Or if thou hast uphoarded in thy life
+    Extorted treasure in the womb of earth,
+    For which, they say, you spirits oft walk in death,
+    Speak of it: stay, and speak! Stop it, Marcellus.
+
+MARCELLUS
+
+    Shall I strike at it with my partisan?
+
+HORATIO
+
+    Do, if it will not stand.
+
+BERNARDO
+
+    'Tis here!
+
+HORATIO
+
+    'Tis here!
+
+MARCELLUS
+
+    'Tis gone!
+
+    Exit Ghost
+    We do it wrong, being so majestical,
+    To offer it the show of violence;
+    For it is, as the air, invulnerable,
+    And our vain blows malicious mockery.
+
+BERNARDO
+
+    It was about to speak, when the cock crew.
+
+HORATIO
+
+    And then it started like a guilty thing
+    Upon a fearful summons. I have heard,
+    The cock, that is the trumpet to the morn,
+    Doth with his lofty and shrill-sounding throat
+    Awake the god of day; and, at his warning,
+    Whether in sea or fire, in earth or air,
+    The extravagant and erring spirit hies
+    To his confine: and of the truth herein
+    This present object made probation.
+
+MARCELLUS
+
+    It faded on the crowing of the cock.
+    Some say that ever 'gainst that season comes
+    Wherein our Saviour's birth is celebrated,
+    The bird of dawning singeth all night long:
+    And then, they say, no spirit dares stir abroad;
+    The nights are wholesome; then no planets strike,
+    No fairy takes, nor witch hath power to charm,
+    So hallow'd and so gracious is the time.
+
+HORATIO
+
+    So have I heard and do in part believe it.
+    But, look, the morn, in russet mantle clad,
+    Walks o'er the dew of yon high eastward hill:
+    Break we our watch up; and by my advice,
+    Let us impart what we have seen to-night
+    Unto young Hamlet; for, upon my life,
+    This spirit, dumb to us, will speak to him.
+    Do you consent we shall acquaint him with it,
+    As needful in our loves, fitting our duty?
+
+MARCELLUS
+
+    Let's do't, I pray; and I this morning know
+    Where we shall find him most conveniently.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene2.txt
new file mode 100644
index 0000000..4b1ec1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene2.txt
@@ -0,0 +1,512 @@
+SCENE II. A room of state in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants 
+
+KING CLAUDIUS
+
+    Though yet of Hamlet our dear brother's death
+    The memory be green, and that it us befitted
+    To bear our hearts in grief and our whole kingdom
+    To be contracted in one brow of woe,
+    Yet so far hath discretion fought with nature
+    That we with wisest sorrow think on him,
+    Together with remembrance of ourselves.
+    Therefore our sometime sister, now our queen,
+    The imperial jointress to this warlike state,
+    Have we, as 'twere with a defeated joy,--
+    With an auspicious and a dropping eye,
+    With mirth in funeral and with dirge in marriage,
+    In equal scale weighing delight and dole,--
+    Taken to wife: nor have we herein barr'd
+    Your better wisdoms, which have freely gone
+    With this affair along. For all, our thanks.
+    Now follows, that you know, young Fortinbras,
+    Holding a weak supposal of our worth,
+    Or thinking by our late dear brother's death
+    Our state to be disjoint and out of frame,
+    Colleagued with the dream of his advantage,
+    He hath not fail'd to pester us with message,
+    Importing the surrender of those lands
+    Lost by his father, with all bonds of law,
+    To our most valiant brother. So much for him.
+    Now for ourself and for this time of meeting:
+    Thus much the business is: we have here writ
+    To Norway, uncle of young Fortinbras,--
+    Who, impotent and bed-rid, scarcely hears
+    Of this his nephew's purpose,--to suppress
+    His further gait herein; in that the levies,
+    The lists and full proportions, are all made
+    Out of his subject: and we here dispatch
+    You, good Cornelius, and you, Voltimand,
+    For bearers of this greeting to old Norway;
+    Giving to you no further personal power
+    To business with the king, more than the scope
+    Of these delated articles allow.
+    Farewell, and let your haste commend your duty.
+
+CORNELIUS VOLTIMAND
+
+    In that and all things will we show our duty.
+
+KING CLAUDIUS
+
+    We doubt it nothing: heartily farewell.
+
+    Exeunt VOLTIMAND and CORNELIUS
+    And now, Laertes, what's the news with you?
+    You told us of some suit; what is't, Laertes?
+    You cannot speak of reason to the Dane,
+    And loose your voice: what wouldst thou beg, Laertes,
+    That shall not be my offer, not thy asking?
+    The head is not more native to the heart,
+    The hand more instrumental to the mouth,
+    Than is the throne of Denmark to thy father.
+    What wouldst thou have, Laertes?
+
+LAERTES
+
+    My dread lord,
+    Your leave and favour to return to France;
+    From whence though willingly I came to Denmark,
+    To show my duty in your coronation,
+    Yet now, I must confess, that duty done,
+    My thoughts and wishes bend again toward France
+    And bow them to your gracious leave and pardon.
+
+KING CLAUDIUS
+
+    Have you your father's leave? What says Polonius?
+
+LORD POLONIUS
+
+    He hath, my lord, wrung from me my slow leave
+    By laboursome petition, and at last
+    Upon his will I seal'd my hard consent:
+    I do beseech you, give him leave to go.
+
+KING CLAUDIUS
+
+    Take thy fair hour, Laertes; time be thine,
+    And thy best graces spend it at thy will!
+    But now, my cousin Hamlet, and my son,--
+
+HAMLET
+
+    [Aside] A little more than kin, and less than kind.
+
+KING CLAUDIUS
+
+    How is it that the clouds still hang on you?
+
+HAMLET
+
+    Not so, my lord; I am too much i' the sun.
+
+QUEEN GERTRUDE
+
+    Good Hamlet, cast thy nighted colour off,
+    And let thine eye look like a friend on Denmark.
+    Do not for ever with thy vailed lids
+    Seek for thy noble father in the dust:
+    Thou know'st 'tis common; all that lives must die,
+    Passing through nature to eternity.
+
+HAMLET
+
+    Ay, madam, it is common.
+
+QUEEN GERTRUDE
+
+    If it be,
+    Why seems it so particular with thee?
+
+HAMLET
+
+    Seems, madam! nay it is; I know not 'seems.'
+    'Tis not alone my inky cloak, good mother,
+    Nor customary suits of solemn black,
+    Nor windy suspiration of forced breath,
+    No, nor the fruitful river in the eye,
+    Nor the dejected 'havior of the visage,
+    Together with all forms, moods, shapes of grief,
+    That can denote me truly: these indeed seem,
+    For they are actions that a man might play:
+    But I have that within which passeth show;
+    These but the trappings and the suits of woe.
+
+KING CLAUDIUS
+
+    'Tis sweet and commendable in your nature, Hamlet,
+    To give these mourning duties to your father:
+    But, you must know, your father lost a father;
+    That father lost, lost his, and the survivor bound
+    In filial obligation for some term
+    To do obsequious sorrow: but to persever
+    In obstinate condolement is a course
+    Of impious stubbornness; 'tis unmanly grief;
+    It shows a will most incorrect to heaven,
+    A heart unfortified, a mind impatient,
+    An understanding simple and unschool'd:
+    For what we know must be and is as common
+    As any the most vulgar thing to sense,
+    Why should we in our peevish opposition
+    Take it to heart? Fie! 'tis a fault to heaven,
+    A fault against the dead, a fault to nature,
+    To reason most absurd: whose common theme
+    Is death of fathers, and who still hath cried,
+    From the first corse till he that died to-day,
+    'This must be so.' We pray you, throw to earth
+    This unprevailing woe, and think of us
+    As of a father: for let the world take note,
+    You are the most immediate to our throne;
+    And with no less nobility of love
+    Than that which dearest father bears his son,
+    Do I impart toward you. For your intent
+    In going back to school in Wittenberg,
+    It is most retrograde to our desire:
+    And we beseech you, bend you to remain
+    Here, in the cheer and comfort of our eye,
+    Our chiefest courtier, cousin, and our son.
+
+QUEEN GERTRUDE
+
+    Let not thy mother lose her prayers, Hamlet:
+    I pray thee, stay with us; go not to Wittenberg.
+
+HAMLET
+
+    I shall in all my best obey you, madam.
+
+KING CLAUDIUS
+
+    Why, 'tis a loving and a fair reply:
+    Be as ourself in Denmark. Madam, come;
+    This gentle and unforced accord of Hamlet
+    Sits smiling to my heart: in grace whereof,
+    No jocund health that Denmark drinks to-day,
+    But the great cannon to the clouds shall tell,
+    And the king's rouse the heavens all bruit again,
+    Re-speaking earthly thunder. Come away.
+
+    Exeunt all but HAMLET
+
+HAMLET
+
+    O, that this too too solid flesh would melt
+    Thaw and resolve itself into a dew!
+    Or that the Everlasting had not fix'd
+    His canon 'gainst self-slaughter! O God! God!
+    How weary, stale, flat and unprofitable,
+    Seem to me all the uses of this world!
+    Fie on't! ah fie! 'tis an unweeded garden,
+    That grows to seed; things rank and gross in nature
+    Possess it merely. That it should come to this!
+    But two months dead: nay, not so much, not two:
+    So excellent a king; that was, to this,
+    Hyperion to a satyr; so loving to my mother
+    That he might not beteem the winds of heaven
+    Visit her face too roughly. Heaven and earth!
+    Must I remember? why, she would hang on him,
+    As if increase of appetite had grown
+    By what it fed on: and yet, within a month--
+    Let me not think on't--Frailty, thy name is woman!--
+    A little month, or ere those shoes were old
+    With which she follow'd my poor father's body,
+    Like Niobe, all tears:--why she, even she--
+    O, God! a beast, that wants discourse of reason,
+    Would have mourn'd longer--married with my uncle,
+    My father's brother, but no more like my father
+    Than I to Hercules: within a month:
+    Ere yet the salt of most unrighteous tears
+    Had left the flushing in her galled eyes,
+    She married. O, most wicked speed, to post
+    With such dexterity to incestuous sheets!
+    It is not nor it cannot come to good:
+    But break, my heart; for I must hold my tongue.
+
+    Enter HORATIO, MARCELLUS, and BERNARDO
+
+HORATIO
+
+    Hail to your lordship!
+
+HAMLET
+
+    I am glad to see you well:
+    Horatio,--or I do forget myself.
+
+HORATIO
+
+    The same, my lord, and your poor servant ever.
+
+HAMLET
+
+    Sir, my good friend; I'll change that name with you:
+    And what make you from Wittenberg, Horatio? Marcellus?
+
+MARCELLUS
+
+    My good lord--
+
+HAMLET
+
+    I am very glad to see you. Good even, sir.
+    But what, in faith, make you from Wittenberg?
+
+HORATIO
+
+    A truant disposition, good my lord.
+
+HAMLET
+
+    I would not hear your enemy say so,
+    Nor shall you do mine ear that violence,
+    To make it truster of your own report
+    Against yourself: I know you are no truant.
+    But what is your affair in Elsinore?
+    We'll teach you to drink deep ere you depart.
+
+HORATIO
+
+    My lord, I came to see your father's funeral.
+
+HAMLET
+
+    I pray thee, do not mock me, fellow-student;
+    I think it was to see my mother's wedding.
+
+HORATIO
+
+    Indeed, my lord, it follow'd hard upon.
+
+HAMLET
+
+    Thrift, thrift, Horatio! the funeral baked meats
+    Did coldly furnish forth the marriage tables.
+    Would I had met my dearest foe in heaven
+    Or ever I had seen that day, Horatio!
+    My father!--methinks I see my father.
+
+HORATIO
+
+    Where, my lord?
+
+HAMLET
+
+    In my mind's eye, Horatio.
+
+HORATIO
+
+    I saw him once; he was a goodly king.
+
+HAMLET
+
+    He was a man, take him for all in all,
+    I shall not look upon his like again.
+
+HORATIO
+
+    My lord, I think I saw him yesternight.
+
+HAMLET
+
+    Saw? who?
+
+HORATIO
+
+    My lord, the king your father.
+
+HAMLET
+
+    The king my father!
+
+HORATIO
+
+    Season your admiration for awhile
+    With an attent ear, till I may deliver,
+    Upon the witness of these gentlemen,
+    This marvel to you.
+
+HAMLET
+
+    For God's love, let me hear.
+
+HORATIO
+
+    Two nights together had these gentlemen,
+    Marcellus and Bernardo, on their watch,
+    In the dead vast and middle of the night,
+    Been thus encounter'd. A figure like your father,
+    Armed at point exactly, cap-a-pe,
+    Appears before them, and with solemn march
+    Goes slow and stately by them: thrice he walk'd
+    By their oppress'd and fear-surprised eyes,
+    Within his truncheon's length; whilst they, distilled
+    Almost to jelly with the act of fear,
+    Stand dumb and speak not to him. This to me
+    In dreadful secrecy impart they did;
+    And I with them the third night kept the watch;
+    Where, as they had deliver'd, both in time,
+    Form of the thing, each word made true and good,
+    The apparition comes: I knew your father;
+    These hands are not more like.
+
+HAMLET
+
+    But where was this?
+
+MARCELLUS
+
+    My lord, upon the platform where we watch'd.
+
+HAMLET
+
+    Did you not speak to it?
+
+HORATIO
+
+    My lord, I did;
+    But answer made it none: yet once methought
+    It lifted up its head and did address
+    Itself to motion, like as it would speak;
+    But even then the morning cock crew loud,
+    And at the sound it shrunk in haste away,
+    And vanish'd from our sight.
+
+HAMLET
+
+    'Tis very strange.
+
+HORATIO
+
+    As I do live, my honour'd lord, 'tis true;
+    And we did think it writ down in our duty
+    To let you know of it.
+
+HAMLET
+
+    Indeed, indeed, sirs, but this troubles me.
+    Hold you the watch to-night?
+
+MARCELLUS BERNARDO
+
+    We do, my lord.
+
+HAMLET
+
+    Arm'd, say you?
+
+MARCELLUS BERNARDO
+
+    Arm'd, my lord.
+
+HAMLET
+
+    From top to toe?
+
+MARCELLUS BERNARDO
+
+    My lord, from head to foot.
+
+HAMLET
+
+    Then saw you not his face?
+
+HORATIO
+
+    O, yes, my lord; he wore his beaver up.
+
+HAMLET
+
+    What, look'd he frowningly?
+
+HORATIO
+
+    A countenance more in sorrow than in anger.
+
+HAMLET
+
+    Pale or red?
+
+HORATIO
+
+    Nay, very pale.
+
+HAMLET
+
+    And fix'd his eyes upon you?
+
+HORATIO
+
+    Most constantly.
+
+HAMLET
+
+    I would I had been there.
+
+HORATIO
+
+    It would have much amazed you.
+
+HAMLET
+
+    Very like, very like. Stay'd it long?
+
+HORATIO
+
+    While one with moderate haste might tell a hundred.
+
+MARCELLUS BERNARDO
+
+    Longer, longer.
+
+HORATIO
+
+    Not when I saw't.
+
+HAMLET
+
+    His beard was grizzled--no?
+
+HORATIO
+
+    It was, as I have seen it in his life,
+    A sable silver'd.
+
+HAMLET
+
+    I will watch to-night;
+    Perchance 'twill walk again.
+
+HORATIO
+
+    I warrant it will.
+
+HAMLET
+
+    If it assume my noble father's person,
+    I'll speak to it, though hell itself should gape
+    And bid me hold my peace. I pray you all,
+    If you have hitherto conceal'd this sight,
+    Let it be tenable in your silence still;
+    And whatsoever else shall hap to-night,
+    Give it an understanding, but no tongue:
+    I will requite your loves. So, fare you well:
+    Upon the platform, 'twixt eleven and twelve,
+    I'll visit you.
+
+All
+
+    Our duty to your honour.
+
+HAMLET
+
+    Your loves, as mine to you: farewell.
+
+    Exeunt all but HAMLET
+    My father's spirit in arms! all is not well;
+    I doubt some foul play: would the night were come!
+    Till then sit still, my soul: foul deeds will rise,
+    Though all the earth o'erwhelm them, to men's eyes.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene3.txt
new file mode 100644
index 0000000..6a2dc42
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene3.txt
@@ -0,0 +1,224 @@
+SCENE III. A room in Polonius' house.
+
+    Enter LAERTES and OPHELIA 
+
+LAERTES
+
+    My necessaries are embark'd: farewell:
+    And, sister, as the winds give benefit
+    And convoy is assistant, do not sleep,
+    But let me hear from you.
+
+OPHELIA
+
+    Do you doubt that?
+
+LAERTES
+
+    For Hamlet and the trifling of his favour,
+    Hold it a fashion and a toy in blood,
+    A violet in the youth of primy nature,
+    Forward, not permanent, sweet, not lasting,
+    The perfume and suppliance of a minute; No more.
+
+OPHELIA
+
+    No more but so?
+
+LAERTES
+
+    Think it no more;
+    For nature, crescent, does not grow alone
+    In thews and bulk, but, as this temple waxes,
+    The inward service of the mind and soul
+    Grows wide withal. Perhaps he loves you now,
+    And now no soil nor cautel doth besmirch
+    The virtue of his will: but you must fear,
+    His greatness weigh'd, his will is not his own;
+    For he himself is subject to his birth:
+    He may not, as unvalued persons do,
+    Carve for himself; for on his choice depends
+    The safety and health of this whole state;
+    And therefore must his choice be circumscribed
+    Unto the voice and yielding of that body
+    Whereof he is the head. Then if he says he loves you,
+    It fits your wisdom so far to believe it
+    As he in his particular act and place
+    May give his saying deed; which is no further
+    Than the main voice of Denmark goes withal.
+    Then weigh what loss your honour may sustain,
+    If with too credent ear you list his songs,
+    Or lose your heart, or your chaste treasure open
+    To his unmaster'd importunity.
+    Fear it, Ophelia, fear it, my dear sister,
+    And keep you in the rear of your affection,
+    Out of the shot and danger of desire.
+    The chariest maid is prodigal enough,
+    If she unmask her beauty to the moon:
+    Virtue itself 'scapes not calumnious strokes:
+    The canker galls the infants of the spring,
+    Too oft before their buttons be disclosed,
+    And in the morn and liquid dew of youth
+    Contagious blastments are most imminent.
+    Be wary then; best safety lies in fear:
+    Youth to itself rebels, though none else near.
+
+OPHELIA
+
+    I shall the effect of this good lesson keep,
+    As watchman to my heart. But, good my brother,
+    Do not, as some ungracious pastors do,
+    Show me the steep and thorny way to heaven;
+    Whiles, like a puff'd and reckless libertine,
+    Himself the primrose path of dalliance treads,
+    And recks not his own rede.
+
+LAERTES
+
+    O, fear me not.
+    I stay too long: but here my father comes.
+
+    Enter POLONIUS
+    A double blessing is a double grace,
+    Occasion smiles upon a second leave.
+
+LORD POLONIUS
+
+    Yet here, Laertes! aboard, aboard, for shame!
+    The wind sits in the shoulder of your sail,
+    And you are stay'd for. There; my blessing with thee!
+    And these few precepts in thy memory
+    See thou character. Give thy thoughts no tongue,
+    Nor any unproportioned thought his act.
+    Be thou familiar, but by no means vulgar.
+    Those friends thou hast, and their adoption tried,
+    Grapple them to thy soul with hoops of steel;
+    But do not dull thy palm with entertainment
+    Of each new-hatch'd, unfledged comrade. Beware
+    Of entrance to a quarrel, but being in,
+    Bear't that the opposed may beware of thee.
+    Give every man thy ear, but few thy voice;
+    Take each man's censure, but reserve thy judgment.
+    Costly thy habit as thy purse can buy,
+    But not express'd in fancy; rich, not gaudy;
+    For the apparel oft proclaims the man,
+    And they in France of the best rank and station
+    Are of a most select and generous chief in that.
+    Neither a borrower nor a lender be;
+    For loan oft loses both itself and friend,
+    And borrowing dulls the edge of husbandry.
+    This above all: to thine ownself be true,
+    And it must follow, as the night the day,
+    Thou canst not then be false to any man.
+    Farewell: my blessing season this in thee!
+
+LAERTES
+
+    Most humbly do I take my leave, my lord.
+
+LORD POLONIUS
+
+    The time invites you; go; your servants tend.
+
+LAERTES
+
+    Farewell, Ophelia; and remember well
+    What I have said to you.
+
+OPHELIA
+
+    'Tis in my memory lock'd,
+    And you yourself shall keep the key of it.
+
+LAERTES
+
+    Farewell.
+
+    Exit
+
+LORD POLONIUS
+
+    What is't, Ophelia, be hath said to you?
+
+OPHELIA
+
+    So please you, something touching the Lord Hamlet.
+
+LORD POLONIUS
+
+    Marry, well bethought:
+    'Tis told me, he hath very oft of late
+    Given private time to you; and you yourself
+    Have of your audience been most free and bounteous:
+    If it be so, as so 'tis put on me,
+    And that in way of caution, I must tell you,
+    You do not understand yourself so clearly
+    As it behoves my daughter and your honour.
+    What is between you? give me up the truth.
+
+OPHELIA
+
+    He hath, my lord, of late made many tenders
+    Of his affection to me.
+
+LORD POLONIUS
+
+    Affection! pooh! you speak like a green girl,
+    Unsifted in such perilous circumstance.
+    Do you believe his tenders, as you call them?
+
+OPHELIA
+
+    I do not know, my lord, what I should think.
+
+LORD POLONIUS
+
+    Marry, I'll teach you: think yourself a baby;
+    That you have ta'en these tenders for true pay,
+    Which are not sterling. Tender yourself more dearly;
+    Or--not to crack the wind of the poor phrase,
+    Running it thus--you'll tender me a fool.
+
+OPHELIA
+
+    My lord, he hath importuned me with love
+    In honourable fashion.
+
+LORD POLONIUS
+
+    Ay, fashion you may call it; go to, go to.
+
+OPHELIA
+
+    And hath given countenance to his speech, my lord,
+    With almost all the holy vows of heaven.
+
+LORD POLONIUS
+
+    Ay, springes to catch woodcocks. I do know,
+    When the blood burns, how prodigal the soul
+    Lends the tongue vows: these blazes, daughter,
+    Giving more light than heat, extinct in both,
+    Even in their promise, as it is a-making,
+    You must not take for fire. From this time
+    Be somewhat scanter of your maiden presence;
+    Set your entreatments at a higher rate
+    Than a command to parley. For Lord Hamlet,
+    Believe so much in him, that he is young
+    And with a larger tether may he walk
+    Than may be given you: in few, Ophelia,
+    Do not believe his vows; for they are brokers,
+    Not of that dye which their investments show,
+    But mere implorators of unholy suits,
+    Breathing like sanctified and pious bawds,
+    The better to beguile. This is for all:
+    I would not, in plain terms, from this time forth,
+    Have you so slander any moment leisure,
+    As to give words or talk with the Lord Hamlet.
+    Look to't, I charge you: come your ways.
+
+OPHELIA
+
+    I shall obey, my lord.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene4.txt
new file mode 100644
index 0000000..199809e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene4.txt
@@ -0,0 +1,201 @@
+SCENE IV. The platform.
+
+    Enter HAMLET, HORATIO, and MARCELLUS 
+
+HAMLET
+
+    The air bites shrewdly; it is very cold.
+
+HORATIO
+
+    It is a nipping and an eager air.
+
+HAMLET
+
+    What hour now?
+
+HORATIO
+
+    I think it lacks of twelve.
+
+HAMLET
+
+    No, it is struck.
+
+HORATIO
+
+    Indeed? I heard it not: then it draws near the season
+    Wherein the spirit held his wont to walk.
+
+    A flourish of trumpets, and ordnance shot off, within
+    What does this mean, my lord?
+
+HAMLET
+
+    The king doth wake to-night and takes his rouse,
+    Keeps wassail, and the swaggering up-spring reels;
+    And, as he drains his draughts of Rhenish down,
+    The kettle-drum and trumpet thus bray out
+    The triumph of his pledge.
+
+HORATIO
+
+    Is it a custom?
+
+HAMLET
+
+    Ay, marry, is't:
+    But to my mind, though I am native here
+    And to the manner born, it is a custom
+    More honour'd in the breach than the observance.
+    This heavy-headed revel east and west
+    Makes us traduced and tax'd of other nations:
+    They clepe us drunkards, and with swinish phrase
+    Soil our addition; and indeed it takes
+    From our achievements, though perform'd at height,
+    The pith and marrow of our attribute.
+    So, oft it chances in particular men,
+    That for some vicious mole of nature in them,
+    As, in their birth--wherein they are not guilty,
+    Since nature cannot choose his origin--
+    By the o'ergrowth of some complexion,
+    Oft breaking down the pales and forts of reason,
+    Or by some habit that too much o'er-leavens
+    The form of plausive manners, that these men,
+    Carrying, I say, the stamp of one defect,
+    Being nature's livery, or fortune's star,--
+    Their virtues else--be they as pure as grace,
+    As infinite as man may undergo--
+    Shall in the general censure take corruption
+    From that particular fault: the dram of eale
+    Doth all the noble substance of a doubt
+    To his own scandal.
+
+HORATIO
+
+    Look, my lord, it comes!
+
+    Enter Ghost
+
+HAMLET
+
+    Angels and ministers of grace defend us!
+    Be thou a spirit of health or goblin damn'd,
+    Bring with thee airs from heaven or blasts from hell,
+    Be thy intents wicked or charitable,
+    Thou comest in such a questionable shape
+    That I will speak to thee: I'll call thee Hamlet,
+    King, father, royal Dane: O, answer me!
+    Let me not burst in ignorance; but tell
+    Why thy canonized bones, hearsed in death,
+    Have burst their cerements; why the sepulchre,
+    Wherein we saw thee quietly inurn'd,
+    Hath oped his ponderous and marble jaws,
+    To cast thee up again. What may this mean,
+    That thou, dead corse, again in complete steel
+    Revisit'st thus the glimpses of the moon,
+    Making night hideous; and we fools of nature
+    So horridly to shake our disposition
+    With thoughts beyond the reaches of our souls?
+    Say, why is this? wherefore? what should we do?
+
+    Ghost beckons HAMLET
+
+HORATIO
+
+    It beckons you to go away with it,
+    As if it some impartment did desire
+    To you alone.
+
+MARCELLUS
+
+    Look, with what courteous action
+    It waves you to a more removed ground:
+    But do not go with it.
+
+HORATIO
+
+    No, by no means.
+
+HAMLET
+
+    It will not speak; then I will follow it.
+
+HORATIO
+
+    Do not, my lord.
+
+HAMLET
+
+    Why, what should be the fear?
+    I do not set my life in a pin's fee;
+    And for my soul, what can it do to that,
+    Being a thing immortal as itself?
+    It waves me forth again: I'll follow it.
+
+HORATIO
+
+    What if it tempt you toward the flood, my lord,
+    Or to the dreadful summit of the cliff
+    That beetles o'er his base into the sea,
+    And there assume some other horrible form,
+    Which might deprive your sovereignty of reason
+    And draw you into madness? think of it:
+    The very place puts toys of desperation,
+    Without more motive, into every brain
+    That looks so many fathoms to the sea
+    And hears it roar beneath.
+
+HAMLET
+
+    It waves me still.
+    Go on; I'll follow thee.
+
+MARCELLUS
+
+    You shall not go, my lord.
+
+HAMLET
+
+    Hold off your hands.
+
+HORATIO
+
+    Be ruled; you shall not go.
+
+HAMLET
+
+    My fate cries out,
+    And makes each petty artery in this body
+    As hardy as the Nemean lion's nerve.
+    Still am I call'd. Unhand me, gentlemen.
+    By heaven, I'll make a ghost of him that lets me!
+    I say, away! Go on; I'll follow thee.
+
+    Exeunt Ghost and HAMLET
+
+HORATIO
+
+    He waxes desperate with imagination.
+
+MARCELLUS
+
+    Let's follow; 'tis not fit thus to obey him.
+
+HORATIO
+
+    Have after. To what issue will this come?
+
+MARCELLUS
+
+    Something is rotten in the state of Denmark.
+
+HORATIO
+
+    Heaven will direct it.
+
+MARCELLUS
+
+    Nay, let's follow him.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene5.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene5.txt
new file mode 100644
index 0000000..db24ee4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act1/scene5.txt
@@ -0,0 +1,408 @@
+SCENE V. Another part of the platform.
+
+    Enter GHOST and HAMLET 
+
+HAMLET
+
+    Where wilt thou lead me? speak; I'll go no further.
+
+Ghost
+
+    Mark me.
+
+HAMLET
+
+    I will.
+
+Ghost
+
+    My hour is almost come,
+    When I to sulphurous and tormenting flames
+    Must render up myself.
+
+HAMLET
+
+    Alas, poor ghost!
+
+Ghost
+
+    Pity me not, but lend thy serious hearing
+    To what I shall unfold.
+
+HAMLET
+
+    Speak; I am bound to hear.
+
+Ghost
+
+    So art thou to revenge, when thou shalt hear.
+
+HAMLET
+
+    What?
+
+Ghost
+
+    I am thy father's spirit,
+    Doom'd for a certain term to walk the night,
+    And for the day confined to fast in fires,
+    Till the foul crimes done in my days of nature
+    Are burnt and purged away. But that I am forbid
+    To tell the secrets of my prison-house,
+    I could a tale unfold whose lightest word
+    Would harrow up thy soul, freeze thy young blood,
+    Make thy two eyes, like stars, start from their spheres,
+    Thy knotted and combined locks to part
+    And each particular hair to stand on end,
+    Like quills upon the fretful porpentine:
+    But this eternal blazon must not be
+    To ears of flesh and blood. List, list, O, list!
+    If thou didst ever thy dear father love--
+
+HAMLET
+
+    O God!
+
+Ghost
+
+    Revenge his foul and most unnatural murder.
+
+HAMLET
+
+    Murder!
+
+Ghost
+
+    Murder most foul, as in the best it is;
+    But this most foul, strange and unnatural.
+
+HAMLET
+
+    Haste me to know't, that I, with wings as swift
+    As meditation or the thoughts of love,
+    May sweep to my revenge.
+
+Ghost
+
+    I find thee apt;
+    And duller shouldst thou be than the fat weed
+    That roots itself in ease on Lethe wharf,
+    Wouldst thou not stir in this. Now, Hamlet, hear:
+    'Tis given out that, sleeping in my orchard,
+    A serpent stung me; so the whole ear of Denmark
+    Is by a forged process of my death
+    Rankly abused: but know, thou noble youth,
+    The serpent that did sting thy father's life
+    Now wears his crown.
+
+HAMLET
+
+    O my prophetic soul! My uncle!
+
+Ghost
+
+    Ay, that incestuous, that adulterate beast,
+    With witchcraft of his wit, with traitorous gifts,--
+    O wicked wit and gifts, that have the power
+    So to seduce!--won to his shameful lust
+    The will of my most seeming-virtuous queen:
+    O Hamlet, what a falling-off was there!
+    From me, whose love was of that dignity
+    That it went hand in hand even with the vow
+    I made to her in marriage, and to decline
+    Upon a wretch whose natural gifts were poor
+    To those of mine!
+    But virtue, as it never will be moved,
+    Though lewdness court it in a shape of heaven,
+    So lust, though to a radiant angel link'd,
+    Will sate itself in a celestial bed,
+    And prey on garbage.
+    But, soft! methinks I scent the morning air;
+    Brief let me be. Sleeping within my orchard,
+    My custom always of the afternoon,
+    Upon my secure hour thy uncle stole,
+    With juice of cursed hebenon in a vial,
+    And in the porches of my ears did pour
+    The leperous distilment; whose effect
+    Holds such an enmity with blood of man
+    That swift as quicksilver it courses through
+    The natural gates and alleys of the body,
+    And with a sudden vigour doth posset
+    And curd, like eager droppings into milk,
+    The thin and wholesome blood: so did it mine;
+    And a most instant tetter bark'd about,
+    Most lazar-like, with vile and loathsome crust,
+    All my smooth body.
+    Thus was I, sleeping, by a brother's hand
+    Of life, of crown, of queen, at once dispatch'd:
+    Cut off even in the blossoms of my sin,
+    Unhousel'd, disappointed, unanel'd,
+    No reckoning made, but sent to my account
+    With all my imperfections on my head:
+    O, horrible! O, horrible! most horrible!
+    If thou hast nature in thee, bear it not;
+    Let not the royal bed of Denmark be
+    A couch for luxury and damned incest.
+    But, howsoever thou pursuest this act,
+    Taint not thy mind, nor let thy soul contrive
+    Against thy mother aught: leave her to heaven
+    And to those thorns that in her bosom lodge,
+    To prick and sting her. Fare thee well at once!
+    The glow-worm shows the matin to be near,
+    And 'gins to pale his uneffectual fire:
+    Adieu, adieu! Hamlet, remember me.
+
+    Exit
+
+HAMLET
+
+    O all you host of heaven! O earth! what else?
+    And shall I couple hell? O, fie! Hold, hold, my heart;
+    And you, my sinews, grow not instant old,
+    But bear me stiffly up. Remember thee!
+    Ay, thou poor ghost, while memory holds a seat
+    In this distracted globe. Remember thee!
+    Yea, from the table of my memory
+    I'll wipe away all trivial fond records,
+    All saws of books, all forms, all pressures past,
+    That youth and observation copied there;
+    And thy commandment all alone shall live
+    Within the book and volume of my brain,
+    Unmix'd with baser matter: yes, by heaven!
+    O most pernicious woman!
+    O villain, villain, smiling, damned villain!
+    My tables,--meet it is I set it down,
+    That one may smile, and smile, and be a villain;
+    At least I'm sure it may be so in Denmark:
+
+    Writing
+    So, uncle, there you are. Now to my word;
+    It is 'Adieu, adieu! remember me.'
+    I have sworn 't.
+
+MARCELLUS HORATIO
+
+    [Within] My lord, my lord,--
+
+MARCELLUS
+
+    [Within] Lord Hamlet,--
+
+HORATIO
+
+    [Within] Heaven secure him!
+
+HAMLET
+
+    So be it!
+
+HORATIO
+
+    [Within] Hillo, ho, ho, my lord!
+
+HAMLET
+
+    Hillo, ho, ho, boy! come, bird, come.
+
+    Enter HORATIO and MARCELLUS
+
+MARCELLUS
+
+    How is't, my noble lord?
+
+HORATIO
+
+    What news, my lord?
+
+HAMLET
+
+    O, wonderful!
+
+HORATIO
+
+    Good my lord, tell it.
+
+HAMLET
+
+    No; you'll reveal it.
+
+HORATIO
+
+    Not I, my lord, by heaven.
+
+MARCELLUS
+
+    Nor I, my lord.
+
+HAMLET
+
+    How say you, then; would heart of man once think it?
+    But you'll be secret?
+
+HORATIO MARCELLUS
+
+    Ay, by heaven, my lord.
+
+HAMLET
+
+    There's ne'er a villain dwelling in all Denmark
+    But he's an arrant knave.
+
+HORATIO
+
+    There needs no ghost, my lord, come from the grave
+    To tell us this.
+
+HAMLET
+
+    Why, right; you are i' the right;
+    And so, without more circumstance at all,
+    I hold it fit that we shake hands and part:
+    You, as your business and desire shall point you;
+    For every man has business and desire,
+    Such as it is; and for mine own poor part,
+    Look you, I'll go pray.
+
+HORATIO
+
+    These are but wild and whirling words, my lord.
+
+HAMLET
+
+    I'm sorry they offend you, heartily;
+    Yes, 'faith heartily.
+
+HORATIO
+
+    There's no offence, my lord.
+
+HAMLET
+
+    Yes, by Saint Patrick, but there is, Horatio,
+    And much offence too. Touching this vision here,
+    It is an honest ghost, that let me tell you:
+    For your desire to know what is between us,
+    O'ermaster 't as you may. And now, good friends,
+    As you are friends, scholars and soldiers,
+    Give me one poor request.
+
+HORATIO
+
+    What is't, my lord? we will.
+
+HAMLET
+
+    Never make known what you have seen to-night.
+
+HORATIO MARCELLUS
+
+    My lord, we will not.
+
+HAMLET
+
+    Nay, but swear't.
+
+HORATIO
+
+    In faith,
+    My lord, not I.
+
+MARCELLUS
+
+    Nor I, my lord, in faith.
+
+HAMLET
+
+    Upon my sword.
+
+MARCELLUS
+
+    We have sworn, my lord, already.
+
+HAMLET
+
+    Indeed, upon my sword, indeed.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Ah, ha, boy! say'st thou so? art thou there,
+    truepenny?
+    Come on--you hear this fellow in the cellarage--
+    Consent to swear.
+
+HORATIO
+
+    Propose the oath, my lord.
+
+HAMLET
+
+    Never to speak of this that you have seen,
+    Swear by my sword.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Hic et ubique? then we'll shift our ground.
+    Come hither, gentlemen,
+    And lay your hands again upon my sword:
+    Never to speak of this that you have heard,
+    Swear by my sword.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Well said, old mole! canst work i' the earth so fast?
+    A worthy pioner! Once more remove, good friends.
+
+HORATIO
+
+    O day and night, but this is wondrous strange!
+
+HAMLET
+
+    And therefore as a stranger give it welcome.
+    There are more things in heaven and earth, Horatio,
+    Than are dreamt of in your philosophy. But come;
+    Here, as before, never, so help you mercy,
+    How strange or odd soe'er I bear myself,
+    As I perchance hereafter shall think meet
+    To put an antic disposition on,
+    That you, at such times seeing me, never shall,
+    With arms encumber'd thus, or this headshake,
+    Or by pronouncing of some doubtful phrase,
+    As 'Well, well, we know,' or 'We could, an if we would,'
+    Or 'If we list to speak,' or 'There be, an if they might,'
+    Or such ambiguous giving out, to note
+    That you know aught of me: this not to do,
+    So grace and mercy at your most need help you, Swear.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Rest, rest, perturbed spirit!
+
+    They swear
+    So, gentlemen,
+    With all my love I do commend me to you:
+    And what so poor a man as Hamlet is
+    May do, to express his love and friending to you,
+    God willing, shall not lack. Let us go in together;
+    And still your fingers on your lips, I pray.
+    The time is out of joint: O cursed spite,
+    That ever I was born to set it right!
+    Nay, come, let's go together.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene1.txt
new file mode 100644
index 0000000..4202de7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene1.txt
@@ -0,0 +1,252 @@
+ACT II
+SCENE I. A room in POLONIUS' house.
+
+    Enter POLONIUS and REYNALDO 
+
+LORD POLONIUS
+
+    Give him this money and these notes, Reynaldo.
+
+REYNALDO
+
+    I will, my lord.
+
+LORD POLONIUS
+
+    You shall do marvellous wisely, good Reynaldo,
+    Before you visit him, to make inquire
+    Of his behavior.
+
+REYNALDO
+
+    My lord, I did intend it.
+
+LORD POLONIUS
+
+    Marry, well said; very well said. Look you, sir,
+    Inquire me first what Danskers are in Paris;
+    And how, and who, what means, and where they keep,
+    What company, at what expense; and finding
+    By this encompassment and drift of question
+    That they do know my son, come you more nearer
+    Than your particular demands will touch it:
+    Take you, as 'twere, some distant knowledge of him;
+    As thus, 'I know his father and his friends,
+    And in part him: ' do you mark this, Reynaldo?
+
+REYNALDO
+
+    Ay, very well, my lord.
+
+LORD POLONIUS
+
+    'And in part him; but' you may say 'not well:
+    But, if't be he I mean, he's very wild;
+    Addicted so and so:' and there put on him
+    What forgeries you please; marry, none so rank
+    As may dishonour him; take heed of that;
+    But, sir, such wanton, wild and usual slips
+    As are companions noted and most known
+    To youth and liberty.
+
+REYNALDO
+
+    As gaming, my lord.
+
+LORD POLONIUS
+
+    Ay, or drinking, fencing, swearing, quarrelling,
+    Drabbing: you may go so far.
+
+REYNALDO
+
+    My lord, that would dishonour him.
+
+LORD POLONIUS
+
+    'Faith, no; as you may season it in the charge
+    You must not put another scandal on him,
+    That he is open to incontinency;
+    That's not my meaning: but breathe his faults so quaintly
+    That they may seem the taints of liberty,
+    The flash and outbreak of a fiery mind,
+    A savageness in unreclaimed blood,
+    Of general assault.
+
+REYNALDO
+
+    But, my good lord,--
+
+LORD POLONIUS
+
+    Wherefore should you do this?
+
+REYNALDO
+
+    Ay, my lord,
+    I would know that.
+
+LORD POLONIUS
+
+    Marry, sir, here's my drift;
+    And I believe, it is a fetch of wit:
+    You laying these slight sullies on my son,
+    As 'twere a thing a little soil'd i' the working, Mark you,
+    Your party in converse, him you would sound,
+    Having ever seen in the prenominate crimes
+    The youth you breathe of guilty, be assured
+    He closes with you in this consequence;
+    'Good sir,' or so, or 'friend,' or 'gentleman,'
+    According to the phrase or the addition
+    Of man and country.
+
+REYNALDO
+
+    Very good, my lord.
+
+LORD POLONIUS
+
+    And then, sir, does he this--he does--what was I
+    about to say? By the mass, I was about to say
+    something: where did I leave?
+
+REYNALDO
+
+    At 'closes in the consequence,' at 'friend or so,'
+    and 'gentleman.'
+
+LORD POLONIUS
+
+    At 'closes in the consequence,' ay, marry;
+    He closes thus: 'I know the gentleman;
+    I saw him yesterday, or t' other day,
+    Or then, or then; with such, or such; and, as you say,
+    There was a' gaming; there o'ertook in's rouse;
+    There falling out at tennis:' or perchance,
+    'I saw him enter such a house of sale,'
+    Videlicet, a brothel, or so forth.
+    See you now;
+    Your bait of falsehood takes this carp of truth:
+    And thus do we of wisdom and of reach,
+    With windlasses and with assays of bias,
+    By indirections find directions out:
+    So by my former lecture and advice,
+    Shall you my son. You have me, have you not?
+
+REYNALDO
+
+    My lord, I have.
+
+LORD POLONIUS
+
+    God be wi' you; fare you well.
+
+REYNALDO
+
+    Good my lord!
+
+LORD POLONIUS
+
+    Observe his inclination in yourself.
+
+REYNALDO
+
+    I shall, my lord.
+
+LORD POLONIUS
+
+    And let him ply his music.
+
+REYNALDO
+
+    Well, my lord.
+
+LORD POLONIUS
+
+    Farewell!
+
+    Exit REYNALDO
+
+    Enter OPHELIA
+    How now, Ophelia! what's the matter?
+
+OPHELIA
+
+    O, my lord, my lord, I have been so affrighted!
+
+LORD POLONIUS
+
+    With what, i' the name of God?
+
+OPHELIA
+
+    My lord, as I was sewing in my closet,
+    Lord Hamlet, with his doublet all unbraced;
+    No hat upon his head; his stockings foul'd,
+    Ungarter'd, and down-gyved to his ancle;
+    Pale as his shirt; his knees knocking each other;
+    And with a look so piteous in purport
+    As if he had been loosed out of hell
+    To speak of horrors,--he comes before me.
+
+LORD POLONIUS
+
+    Mad for thy love?
+
+OPHELIA
+
+    My lord, I do not know;
+    But truly, I do fear it.
+
+LORD POLONIUS
+
+    What said he?
+
+OPHELIA
+
+    He took me by the wrist and held me hard;
+    Then goes he to the length of all his arm;
+    And, with his other hand thus o'er his brow,
+    He falls to such perusal of my face
+    As he would draw it. Long stay'd he so;
+    At last, a little shaking of mine arm
+    And thrice his head thus waving up and down,
+    He raised a sigh so piteous and profound
+    As it did seem to shatter all his bulk
+    And end his being: that done, he lets me go:
+    And, with his head over his shoulder turn'd,
+    He seem'd to find his way without his eyes;
+    For out o' doors he went without their helps,
+    And, to the last, bended their light on me.
+
+LORD POLONIUS
+
+    Come, go with me: I will go seek the king.
+    This is the very ecstasy of love,
+    Whose violent property fordoes itself
+    And leads the will to desperate undertakings
+    As oft as any passion under heaven
+    That does afflict our natures. I am sorry.
+    What, have you given him any hard words of late?
+
+OPHELIA
+
+    No, my good lord, but, as you did command,
+    I did repel his fetters and denied
+    His access to me.
+
+LORD POLONIUS
+
+    That hath made him mad.
+    I am sorry that with better heed and judgment
+    I had not quoted him: I fear'd he did but trifle,
+    And meant to wreck thee; but, beshrew my jealousy!
+    By heaven, it is as proper to our age
+    To cast beyond ourselves in our opinions
+    As it is common for the younger sort
+    To lack discretion. Come, go we to the king:
+    This must be known; which, being kept close, might
+    move
+    More grief to hide than hate to utter love.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene2.txt
new file mode 100644
index 0000000..23928ed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act2/scene2.txt
@@ -0,0 +1,1153 @@
+SCENE II. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, ROSENCRANTZ, GUILDENSTERN, and Attendants 
+
+KING CLAUDIUS
+
+    Welcome, dear Rosencrantz and Guildenstern!
+    Moreover that we much did long to see you,
+    The need we have to use you did provoke
+    Our hasty sending. Something have you heard
+    Of Hamlet's transformation; so call it,
+    Sith nor the exterior nor the inward man
+    Resembles that it was. What it should be,
+    More than his father's death, that thus hath put him
+    So much from the understanding of himself,
+    I cannot dream of: I entreat you both,
+    That, being of so young days brought up with him,
+    And sith so neighbour'd to his youth and havior,
+    That you vouchsafe your rest here in our court
+    Some little time: so by your companies
+    To draw him on to pleasures, and to gather,
+    So much as from occasion you may glean,
+    Whether aught, to us unknown, afflicts him thus,
+    That, open'd, lies within our remedy.
+
+QUEEN GERTRUDE
+
+    Good gentlemen, he hath much talk'd of you;
+    And sure I am two men there are not living
+    To whom he more adheres. If it will please you
+    To show us so much gentry and good will
+    As to expend your time with us awhile,
+    For the supply and profit of our hope,
+    Your visitation shall receive such thanks
+    As fits a king's remembrance.
+
+ROSENCRANTZ
+
+    Both your majesties
+    Might, by the sovereign power you have of us,
+    Put your dread pleasures more into command
+    Than to entreaty.
+
+GUILDENSTERN
+
+    But we both obey,
+    And here give up ourselves, in the full bent
+    To lay our service freely at your feet,
+    To be commanded.
+
+KING CLAUDIUS
+
+    Thanks, Rosencrantz and gentle Guildenstern.
+
+QUEEN GERTRUDE
+
+    Thanks, Guildenstern and gentle Rosencrantz:
+    And I beseech you instantly to visit
+    My too much changed son. Go, some of you,
+    And bring these gentlemen where Hamlet is.
+
+GUILDENSTERN
+
+    Heavens make our presence and our practises
+    Pleasant and helpful to him!
+
+QUEEN GERTRUDE
+
+    Ay, amen!
+
+    Exeunt ROSENCRANTZ, GUILDENSTERN, and some Attendants
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    The ambassadors from Norway, my good lord,
+    Are joyfully return'd.
+
+KING CLAUDIUS
+
+    Thou still hast been the father of good news.
+
+LORD POLONIUS
+
+    Have I, my lord? I assure my good liege,
+    I hold my duty, as I hold my soul,
+    Both to my God and to my gracious king:
+    And I do think, or else this brain of mine
+    Hunts not the trail of policy so sure
+    As it hath used to do, that I have found
+    The very cause of Hamlet's lunacy.
+
+KING CLAUDIUS
+
+    O, speak of that; that do I long to hear.
+
+LORD POLONIUS
+
+    Give first admittance to the ambassadors;
+    My news shall be the fruit to that great feast.
+
+KING CLAUDIUS
+
+    Thyself do grace to them, and bring them in.
+
+    Exit POLONIUS
+    He tells me, my dear Gertrude, he hath found
+    The head and source of all your son's distemper.
+
+QUEEN GERTRUDE
+
+    I doubt it is no other but the main;
+    His father's death, and our o'erhasty marriage.
+
+KING CLAUDIUS
+
+    Well, we shall sift him.
+
+    Re-enter POLONIUS, with VOLTIMAND and CORNELIUS
+    Welcome, my good friends!
+    Say, Voltimand, what from our brother Norway?
+
+VOLTIMAND
+
+    Most fair return of greetings and desires.
+    Upon our first, he sent out to suppress
+    His nephew's levies; which to him appear'd
+    To be a preparation 'gainst the Polack;
+    But, better look'd into, he truly found
+    It was against your highness: whereat grieved,
+    That so his sickness, age and impotence
+    Was falsely borne in hand, sends out arrests
+    On Fortinbras; which he, in brief, obeys;
+    Receives rebuke from Norway, and in fine
+    Makes vow before his uncle never more
+    To give the assay of arms against your majesty.
+    Whereon old Norway, overcome with joy,
+    Gives him three thousand crowns in annual fee,
+    And his commission to employ those soldiers,
+    So levied as before, against the Polack:
+    With an entreaty, herein further shown,
+
+    Giving a paper
+    That it might please you to give quiet pass
+    Through your dominions for this enterprise,
+    On such regards of safety and allowance
+    As therein are set down.
+
+KING CLAUDIUS
+
+    It likes us well;
+    And at our more consider'd time well read,
+    Answer, and think upon this business.
+    Meantime we thank you for your well-took labour:
+    Go to your rest; at night we'll feast together:
+    Most welcome home!
+
+    Exeunt VOLTIMAND and CORNELIUS
+
+LORD POLONIUS
+
+    This business is well ended.
+    My liege, and madam, to expostulate
+    What majesty should be, what duty is,
+    Why day is day, night night, and time is time,
+    Were nothing but to waste night, day and time.
+    Therefore, since brevity is the soul of wit,
+    And tediousness the limbs and outward flourishes,
+    I will be brief: your noble son is mad:
+    Mad call I it; for, to define true madness,
+    What is't but to be nothing else but mad?
+    But let that go.
+
+QUEEN GERTRUDE
+
+    More matter, with less art.
+
+LORD POLONIUS
+
+    Madam, I swear I use no art at all.
+    That he is mad, 'tis true: 'tis true 'tis pity;
+    And pity 'tis 'tis true: a foolish figure;
+    But farewell it, for I will use no art.
+    Mad let us grant him, then: and now remains
+    That we find out the cause of this effect,
+    Or rather say, the cause of this defect,
+    For this effect defective comes by cause:
+    Thus it remains, and the remainder thus. Perpend.
+    I have a daughter--have while she is mine--
+    Who, in her duty and obedience, mark,
+    Hath given me this: now gather, and surmise.
+
+    Reads
+    'To the celestial and my soul's idol, the most
+    beautified Ophelia,'--
+    That's an ill phrase, a vile phrase; 'beautified' is
+    a vile phrase: but you shall hear. Thus:
+
+    Reads
+    'In her excellent white bosom, these, & c.'
+
+QUEEN GERTRUDE
+
+    Came this from Hamlet to her?
+
+LORD POLONIUS
+
+    Good madam, stay awhile; I will be faithful.
+
+    Reads
+    'Doubt thou the stars are fire;
+    Doubt that the sun doth move;
+    Doubt truth to be a liar;
+    But never doubt I love.
+    'O dear Ophelia, I am ill at these numbers;
+    I have not art to reckon my groans: but that
+    I love thee best, O most best, believe it. Adieu.
+    'Thine evermore most dear lady, whilst
+    this machine is to him, HAMLET.'
+    This, in obedience, hath my daughter shown me,
+    And more above, hath his solicitings,
+    As they fell out by time, by means and place,
+    All given to mine ear.
+
+KING CLAUDIUS
+
+    But how hath she
+    Received his love?
+
+LORD POLONIUS
+
+    What do you think of me?
+
+KING CLAUDIUS
+
+    As of a man faithful and honourable.
+
+LORD POLONIUS
+
+    I would fain prove so. But what might you think,
+    When I had seen this hot love on the wing--
+    As I perceived it, I must tell you that,
+    Before my daughter told me--what might you,
+    Or my dear majesty your queen here, think,
+    If I had play'd the desk or table-book,
+    Or given my heart a winking, mute and dumb,
+    Or look'd upon this love with idle sight;
+    What might you think? No, I went round to work,
+    And my young mistress thus I did bespeak:
+    'Lord Hamlet is a prince, out of thy star;
+    This must not be:' and then I precepts gave her,
+    That she should lock herself from his resort,
+    Admit no messengers, receive no tokens.
+    Which done, she took the fruits of my advice;
+    And he, repulsed--a short tale to make--
+    Fell into a sadness, then into a fast,
+    Thence to a watch, thence into a weakness,
+    Thence to a lightness, and, by this declension,
+    Into the madness wherein now he raves,
+    And all we mourn for.
+
+KING CLAUDIUS
+
+    Do you think 'tis this?
+
+QUEEN GERTRUDE
+
+    It may be, very likely.
+
+LORD POLONIUS
+
+    Hath there been such a time--I'd fain know that--
+    That I have positively said 'Tis so,'
+    When it proved otherwise?
+
+KING CLAUDIUS
+
+    Not that I know.
+
+LORD POLONIUS
+
+    [Pointing to his head and shoulder]
+    Take this from this, if this be otherwise:
+    If circumstances lead me, I will find
+    Where truth is hid, though it were hid indeed
+    Within the centre.
+
+KING CLAUDIUS
+
+    How may we try it further?
+
+LORD POLONIUS
+
+    You know, sometimes he walks four hours together
+    Here in the lobby.
+
+QUEEN GERTRUDE
+
+    So he does indeed.
+
+LORD POLONIUS
+
+    At such a time I'll loose my daughter to him:
+    Be you and I behind an arras then;
+    Mark the encounter: if he love her not
+    And be not from his reason fall'n thereon,
+    Let me be no assistant for a state,
+    But keep a farm and carters.
+
+KING CLAUDIUS
+
+    We will try it.
+
+QUEEN GERTRUDE
+
+    But, look, where sadly the poor wretch comes reading.
+
+LORD POLONIUS
+
+    Away, I do beseech you, both away:
+    I'll board him presently.
+
+    Exeunt KING CLAUDIUS, QUEEN GERTRUDE, and Attendants
+
+    Enter HAMLET, reading
+    O, give me leave:
+    How does my good Lord Hamlet?
+
+HAMLET
+
+    Well, God-a-mercy.
+
+LORD POLONIUS
+
+    Do you know me, my lord?
+
+HAMLET
+
+    Excellent well; you are a fishmonger.
+
+LORD POLONIUS
+
+    Not I, my lord.
+
+HAMLET
+
+    Then I would you were so honest a man.
+
+LORD POLONIUS
+
+    Honest, my lord!
+
+HAMLET
+
+    Ay, sir; to be honest, as this world goes, is to be
+    one man picked out of ten thousand.
+
+LORD POLONIUS
+
+    That's very true, my lord.
+
+HAMLET
+
+    For if the sun breed maggots in a dead dog, being a
+    god kissing carrion,--Have you a daughter?
+
+LORD POLONIUS
+
+    I have, my lord.
+
+HAMLET
+
+    Let her not walk i' the sun: conception is a
+    blessing: but not as your daughter may conceive.
+    Friend, look to 't.
+
+LORD POLONIUS
+
+    [Aside] How say you by that? Still harping on my
+    daughter: yet he knew me not at first; he said I
+    was a fishmonger: he is far gone, far gone: and
+    truly in my youth I suffered much extremity for
+    love; very near this. I'll speak to him again.
+    What do you read, my lord?
+
+HAMLET
+
+    Words, words, words.
+
+LORD POLONIUS
+
+    What is the matter, my lord?
+
+HAMLET
+
+    Between who?
+
+LORD POLONIUS
+
+    I mean, the matter that you read, my lord.
+
+HAMLET
+
+    Slanders, sir: for the satirical rogue says here
+    that old men have grey beards, that their faces are
+    wrinkled, their eyes purging thick amber and
+    plum-tree gum and that they have a plentiful lack of
+    wit, together with most weak hams: all which, sir,
+    though I most powerfully and potently believe, yet
+    I hold it not honesty to have it thus set down, for
+    yourself, sir, should be old as I am, if like a crab
+    you could go backward.
+
+LORD POLONIUS
+
+    [Aside] Though this be madness, yet there is method
+    in 't. Will you walk out of the air, my lord?
+
+HAMLET
+
+    Into my grave.
+
+LORD POLONIUS
+
+    Indeed, that is out o' the air.
+
+    Aside
+    How pregnant sometimes his replies are! a happiness
+    that often madness hits on, which reason and sanity
+    could not so prosperously be delivered of. I will
+    leave him, and suddenly contrive the means of
+    meeting between him and my daughter.--My honourable
+    lord, I will most humbly take my leave of you.
+
+HAMLET
+
+    You cannot, sir, take from me any thing that I will
+    more willingly part withal: except my life, except
+    my life, except my life.
+
+LORD POLONIUS
+
+    Fare you well, my lord.
+
+HAMLET
+
+    These tedious old fools!
+
+    Enter ROSENCRANTZ and GUILDENSTERN
+
+LORD POLONIUS
+
+    You go to seek the Lord Hamlet; there he is.
+
+ROSENCRANTZ
+
+    [To POLONIUS] God save you, sir!
+
+    Exit POLONIUS
+
+GUILDENSTERN
+
+    My honoured lord!
+
+ROSENCRANTZ
+
+    My most dear lord!
+
+HAMLET
+
+    My excellent good friends! How dost thou,
+    Guildenstern? Ah, Rosencrantz! Good lads, how do ye both?
+
+ROSENCRANTZ
+
+    As the indifferent children of the earth.
+
+GUILDENSTERN
+
+    Happy, in that we are not over-happy;
+    On fortune's cap we are not the very button.
+
+HAMLET
+
+    Nor the soles of her shoe?
+
+ROSENCRANTZ
+
+    Neither, my lord.
+
+HAMLET
+
+    Then you live about her waist, or in the middle of
+    her favours?
+
+GUILDENSTERN
+
+    'Faith, her privates we.
+
+HAMLET
+
+    In the secret parts of fortune? O, most true; she
+    is a strumpet. What's the news?
+
+ROSENCRANTZ
+
+    None, my lord, but that the world's grown honest.
+
+HAMLET
+
+    Then is doomsday near: but your news is not true.
+    Let me question more in particular: what have you,
+    my good friends, deserved at the hands of fortune,
+    that she sends you to prison hither?
+
+GUILDENSTERN
+
+    Prison, my lord!
+
+HAMLET
+
+    Denmark's a prison.
+
+ROSENCRANTZ
+
+    Then is the world one.
+
+HAMLET
+
+    A goodly one; in which there are many confines,
+    wards and dungeons, Denmark being one o' the worst.
+
+ROSENCRANTZ
+
+    We think not so, my lord.
+
+HAMLET
+
+    Why, then, 'tis none to you; for there is nothing
+    either good or bad, but thinking makes it so: to me
+    it is a prison.
+
+ROSENCRANTZ
+
+    Why then, your ambition makes it one; 'tis too
+    narrow for your mind.
+
+HAMLET
+
+    O God, I could be bounded in a nut shell and count
+    myself a king of infinite space, were it not that I
+    have bad dreams.
+
+GUILDENSTERN
+
+    Which dreams indeed are ambition, for the very
+    substance of the ambitious is merely the shadow of a dream.
+
+HAMLET
+
+    A dream itself is but a shadow.
+
+ROSENCRANTZ
+
+    Truly, and I hold ambition of so airy and light a
+    quality that it is but a shadow's shadow.
+
+HAMLET
+
+    Then are our beggars bodies, and our monarchs and
+    outstretched heroes the beggars' shadows. Shall we
+    to the court? for, by my fay, I cannot reason.
+
+ROSENCRANTZ GUILDENSTERN
+
+    We'll wait upon you.
+
+HAMLET
+
+    No such matter: I will not sort you with the rest
+    of my servants, for, to speak to you like an honest
+    man, I am most dreadfully attended. But, in the
+    beaten way of friendship, what make you at Elsinore?
+
+ROSENCRANTZ
+
+    To visit you, my lord; no other occasion.
+
+HAMLET
+
+    Beggar that I am, I am even poor in thanks; but I
+    thank you: and sure, dear friends, my thanks are
+    too dear a halfpenny. Were you not sent for? Is it
+    your own inclining? Is it a free visitation? Come,
+    deal justly with me: come, come; nay, speak.
+
+GUILDENSTERN
+
+    What should we say, my lord?
+
+HAMLET
+
+    Why, any thing, but to the purpose. You were sent
+    for; and there is a kind of confession in your looks
+    which your modesties have not craft enough to colour:
+    I know the good king and queen have sent for you.
+
+ROSENCRANTZ
+
+    To what end, my lord?
+
+HAMLET
+
+    That you must teach me. But let me conjure you, by
+    the rights of our fellowship, by the consonancy of
+    our youth, by the obligation of our ever-preserved
+    love, and by what more dear a better proposer could
+    charge you withal, be even and direct with me,
+    whether you were sent for, or no?
+
+ROSENCRANTZ
+
+    [Aside to GUILDENSTERN] What say you?
+
+HAMLET
+
+    [Aside] Nay, then, I have an eye of you.--If you
+    love me, hold not off.
+
+GUILDENSTERN
+
+    My lord, we were sent for.
+
+HAMLET
+
+    I will tell you why; so shall my anticipation
+    prevent your discovery, and your secrecy to the king
+    and queen moult no feather. I have of late--but
+    wherefore I know not--lost all my mirth, forgone all
+    custom of exercises; and indeed it goes so heavily
+    with my disposition that this goodly frame, the
+    earth, seems to me a sterile promontory, this most
+    excellent canopy, the air, look you, this brave
+    o'erhanging firmament, this majestical roof fretted
+    with golden fire, why, it appears no other thing to
+    me than a foul and pestilent congregation of vapours.
+    What a piece of work is a man! how noble in reason!
+    how infinite in faculty! in form and moving how
+    express and admirable! in action how like an angel!
+    in apprehension how like a god! the beauty of the
+    world! the paragon of animals! And yet, to me,
+    what is this quintessence of dust? man delights not
+    me: no, nor woman neither, though by your smiling
+    you seem to say so.
+
+ROSENCRANTZ
+
+    My lord, there was no such stuff in my thoughts.
+
+HAMLET
+
+    Why did you laugh then, when I said 'man delights not me'?
+
+ROSENCRANTZ
+
+    To think, my lord, if you delight not in man, what
+    lenten entertainment the players shall receive from
+    you: we coted them on the way; and hither are they
+    coming, to offer you service.
+
+HAMLET
+
+    He that plays the king shall be welcome; his majesty
+    shall have tribute of me; the adventurous knight
+    shall use his foil and target; the lover shall not
+    sigh gratis; the humourous man shall end his part
+    in peace; the clown shall make those laugh whose
+    lungs are tickled o' the sere; and the lady shall
+    say her mind freely, or the blank verse shall halt
+    for't. What players are they?
+
+ROSENCRANTZ
+
+    Even those you were wont to take delight in, the
+    tragedians of the city.
+
+HAMLET
+
+    How chances it they travel? their residence, both
+    in reputation and profit, was better both ways.
+
+ROSENCRANTZ
+
+    I think their inhibition comes by the means of the
+    late innovation.
+
+HAMLET
+
+    Do they hold the same estimation they did when I was
+    in the city? are they so followed?
+
+ROSENCRANTZ
+
+    No, indeed, are they not.
+
+HAMLET
+
+    How comes it? do they grow rusty?
+
+ROSENCRANTZ
+
+    Nay, their endeavour keeps in the wonted pace: but
+    there is, sir, an aery of children, little eyases,
+    that cry out on the top of question, and are most
+    tyrannically clapped for't: these are now the
+    fashion, and so berattle the common stages--so they
+    call them--that many wearing rapiers are afraid of
+    goose-quills and dare scarce come thither.
+
+HAMLET
+
+    What, are they children? who maintains 'em? how are
+    they escoted? Will they pursue the quality no
+    longer than they can sing? will they not say
+    afterwards, if they should grow themselves to common
+    players--as it is most like, if their means are no
+    better--their writers do them wrong, to make them
+    exclaim against their own succession?
+
+ROSENCRANTZ
+
+    'Faith, there has been much to do on both sides; and
+    the nation holds it no sin to tarre them to
+    controversy: there was, for a while, no money bid
+    for argument, unless the poet and the player went to
+    cuffs in the question.
+
+HAMLET
+
+    Is't possible?
+
+GUILDENSTERN
+
+    O, there has been much throwing about of brains.
+
+HAMLET
+
+    Do the boys carry it away?
+
+ROSENCRANTZ
+
+    Ay, that they do, my lord; Hercules and his load too.
+
+HAMLET
+
+    It is not very strange; for mine uncle is king of
+    Denmark, and those that would make mows at him while
+    my father lived, give twenty, forty, fifty, an
+    hundred ducats a-piece for his picture in little.
+    'Sblood, there is something in this more than
+    natural, if philosophy could find it out.
+
+    Flourish of trumpets within
+
+GUILDENSTERN
+
+    There are the players.
+
+HAMLET
+
+    Gentlemen, you are welcome to Elsinore. Your hands,
+    come then: the appurtenance of welcome is fashion
+    and ceremony: let me comply with you in this garb,
+    lest my extent to the players, which, I tell you,
+    must show fairly outward, should more appear like
+    entertainment than yours. You are welcome: but my
+    uncle-father and aunt-mother are deceived.
+
+GUILDENSTERN
+
+    In what, my dear lord?
+
+HAMLET
+
+    I am but mad north-north-west: when the wind is
+    southerly I know a hawk from a handsaw.
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    Well be with you, gentlemen!
+
+HAMLET
+
+    Hark you, Guildenstern; and you too: at each ear a
+    hearer: that great baby you see there is not yet
+    out of his swaddling-clouts.
+
+ROSENCRANTZ
+
+    Happily he's the second time come to them; for they
+    say an old man is twice a child.
+
+HAMLET
+
+    I will prophesy he comes to tell me of the players;
+    mark it. You say right, sir: o' Monday morning;
+    'twas so indeed.
+
+LORD POLONIUS
+
+    My lord, I have news to tell you.
+
+HAMLET
+
+    My lord, I have news to tell you.
+    When Roscius was an actor in Rome,--
+
+LORD POLONIUS
+
+    The actors are come hither, my lord.
+
+HAMLET
+
+    Buz, buz!
+
+LORD POLONIUS
+
+    Upon mine honour,--
+
+HAMLET
+
+    Then came each actor on his ass,--
+
+LORD POLONIUS
+
+    The best actors in the world, either for tragedy,
+    comedy, history, pastoral, pastoral-comical,
+    historical-pastoral, tragical-historical, tragical-
+    comical-historical-pastoral, scene individable, or
+    poem unlimited: Seneca cannot be too heavy, nor
+    Plautus too light. For the law of writ and the
+    liberty, these are the only men.
+
+HAMLET
+
+    O Jephthah, judge of Israel, what a treasure hadst thou!
+
+LORD POLONIUS
+
+    What a treasure had he, my lord?
+
+HAMLET
+
+    Why,
+    'One fair daughter and no more,
+    The which he loved passing well.'
+
+LORD POLONIUS
+
+    [Aside] Still on my daughter.
+
+HAMLET
+
+    Am I not i' the right, old Jephthah?
+
+LORD POLONIUS
+
+    If you call me Jephthah, my lord, I have a daughter
+    that I love passing well.
+
+HAMLET
+
+    Nay, that follows not.
+
+LORD POLONIUS
+
+    What follows, then, my lord?
+
+HAMLET
+
+    Why,
+    'As by lot, God wot,'
+    and then, you know,
+    'It came to pass, as most like it was,'--
+    the first row of the pious chanson will show you
+    more; for look, where my abridgement comes.
+
+    Enter four or five Players
+    You are welcome, masters; welcome, all. I am glad
+    to see thee well. Welcome, good friends. O, my old
+    friend! thy face is valenced since I saw thee last:
+    comest thou to beard me in Denmark? What, my young
+    lady and mistress! By'r lady, your ladyship is
+    nearer to heaven than when I saw you last, by the
+    altitude of a chopine. Pray God, your voice, like
+    apiece of uncurrent gold, be not cracked within the
+    ring. Masters, you are all welcome. We'll e'en
+    to't like French falconers, fly at any thing we see:
+    we'll have a speech straight: come, give us a taste
+    of your quality; come, a passionate speech.
+
+First Player
+
+    What speech, my lord?
+
+HAMLET
+
+    I heard thee speak me a speech once, but it was
+    never acted; or, if it was, not above once; for the
+    play, I remember, pleased not the million; 'twas
+    caviare to the general: but it was--as I received
+    it, and others, whose judgments in such matters
+    cried in the top of mine--an excellent play, well
+    digested in the scenes, set down with as much
+    modesty as cunning. I remember, one said there
+    were no sallets in the lines to make the matter
+    savoury, nor no matter in the phrase that might
+    indict the author of affectation; but called it an
+    honest method, as wholesome as sweet, and by very
+    much more handsome than fine. One speech in it I
+    chiefly loved: 'twas Aeneas' tale to Dido; and
+    thereabout of it especially, where he speaks of
+    Priam's slaughter: if it live in your memory, begin
+    at this line: let me see, let me see--
+    'The rugged Pyrrhus, like the Hyrcanian beast,'--
+    it is not so:--it begins with Pyrrhus:--
+    'The rugged Pyrrhus, he whose sable arms,
+    Black as his purpose, did the night resemble
+    When he lay couched in the ominous horse,
+    Hath now this dread and black complexion smear'd
+    With heraldry more dismal; head to foot
+    Now is he total gules; horridly trick'd
+    With blood of fathers, mothers, daughters, sons,
+    Baked and impasted with the parching streets,
+    That lend a tyrannous and damned light
+    To their lord's murder: roasted in wrath and fire,
+    And thus o'er-sized with coagulate gore,
+    With eyes like carbuncles, the hellish Pyrrhus
+    Old grandsire Priam seeks.'
+    So, proceed you.
+
+LORD POLONIUS
+
+    'Fore God, my lord, well spoken, with good accent and
+    good discretion.
+
+First Player
+
+    'Anon he finds him
+    Striking too short at Greeks; his antique sword,
+    Rebellious to his arm, lies where it falls,
+    Repugnant to command: unequal match'd,
+    Pyrrhus at Priam drives; in rage strikes wide;
+    But with the whiff and wind of his fell sword
+    The unnerved father falls. Then senseless Ilium,
+    Seeming to feel this blow, with flaming top
+    Stoops to his base, and with a hideous crash
+    Takes prisoner Pyrrhus' ear: for, lo! his sword,
+    Which was declining on the milky head
+    Of reverend Priam, seem'd i' the air to stick:
+    So, as a painted tyrant, Pyrrhus stood,
+    And like a neutral to his will and matter,
+    Did nothing.
+    But, as we often see, against some storm,
+    A silence in the heavens, the rack stand still,
+    The bold winds speechless and the orb below
+    As hush as death, anon the dreadful thunder
+    Doth rend the region, so, after Pyrrhus' pause,
+    Aroused vengeance sets him new a-work;
+    And never did the Cyclops' hammers fall
+    On Mars's armour forged for proof eterne
+    With less remorse than Pyrrhus' bleeding sword
+    Now falls on Priam.
+    Out, out, thou strumpet, Fortune! All you gods,
+    In general synod 'take away her power;
+    Break all the spokes and fellies from her wheel,
+    And bowl the round nave down the hill of heaven,
+    As low as to the fiends!'
+
+LORD POLONIUS
+
+    This is too long.
+
+HAMLET
+
+    It shall to the barber's, with your beard. Prithee,
+    say on: he's for a jig or a tale of bawdry, or he
+    sleeps: say on: come to Hecuba.
+
+First Player
+
+    'But who, O, who had seen the mobled queen--'
+
+HAMLET
+
+    'The mobled queen?'
+
+LORD POLONIUS
+
+    That's good; 'mobled queen' is good.
+
+First Player
+
+    'Run barefoot up and down, threatening the flames
+    With bisson rheum; a clout upon that head
+    Where late the diadem stood, and for a robe,
+    About her lank and all o'er-teemed loins,
+    A blanket, in the alarm of fear caught up;
+    Who this had seen, with tongue in venom steep'd,
+    'Gainst Fortune's state would treason have
+    pronounced:
+    But if the gods themselves did see her then
+    When she saw Pyrrhus make malicious sport
+    In mincing with his sword her husband's limbs,
+    The instant burst of clamour that she made,
+    Unless things mortal move them not at all,
+    Would have made milch the burning eyes of heaven,
+    And passion in the gods.'
+
+LORD POLONIUS
+
+    Look, whether he has not turned his colour and has
+    tears in's eyes. Pray you, no more.
+
+HAMLET
+
+    'Tis well: I'll have thee speak out the rest soon.
+    Good my lord, will you see the players well
+    bestowed? Do you hear, let them be well used; for
+    they are the abstract and brief chronicles of the
+    time: after your death you were better have a bad
+    epitaph than their ill report while you live.
+
+LORD POLONIUS
+
+    My lord, I will use them according to their desert.
+
+HAMLET
+
+    God's bodykins, man, much better: use every man
+    after his desert, and who should 'scape whipping?
+    Use them after your own honour and dignity: the less
+    they deserve, the more merit is in your bounty.
+    Take them in.
+
+LORD POLONIUS
+
+    Come, sirs.
+
+HAMLET
+
+    Follow him, friends: we'll hear a play to-morrow.
+
+    Exit POLONIUS with all the Players but the First
+    Dost thou hear me, old friend; can you play the
+    Murder of Gonzago?
+
+First Player
+
+    Ay, my lord.
+
+HAMLET
+
+    We'll ha't to-morrow night. You could, for a need,
+    study a speech of some dozen or sixteen lines, which
+    I would set down and insert in't, could you not?
+
+First Player
+
+    Ay, my lord.
+
+HAMLET
+
+    Very well. Follow that lord; and look you mock him
+    not.
+
+    Exit First Player
+    My good friends, I'll leave you till night: you are
+    welcome to Elsinore.
+
+ROSENCRANTZ
+
+    Good my lord!
+
+HAMLET
+
+    Ay, so, God be wi' ye;
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Now I am alone.
+    O, what a rogue and peasant slave am I!
+    Is it not monstrous that this player here,
+    But in a fiction, in a dream of passion,
+    Could force his soul so to his own conceit
+    That from her working all his visage wann'd,
+    Tears in his eyes, distraction in's aspect,
+    A broken voice, and his whole function suiting
+    With forms to his conceit? and all for nothing!
+    For Hecuba!
+    What's Hecuba to him, or he to Hecuba,
+    That he should weep for her? What would he do,
+    Had he the motive and the cue for passion
+    That I have? He would drown the stage with tears
+    And cleave the general ear with horrid speech,
+    Make mad the guilty and appal the free,
+    Confound the ignorant, and amaze indeed
+    The very faculties of eyes and ears. Yet I,
+    A dull and muddy-mettled rascal, peak,
+    Like John-a-dreams, unpregnant of my cause,
+    And can say nothing; no, not for a king,
+    Upon whose property and most dear life
+    A damn'd defeat was made. Am I a coward?
+    Who calls me villain? breaks my pate across?
+    Plucks off my beard, and blows it in my face?
+    Tweaks me by the nose? gives me the lie i' the throat,
+    As deep as to the lungs? who does me this?
+    Ha!
+    'Swounds, I should take it: for it cannot be
+    But I am pigeon-liver'd and lack gall
+    To make oppression bitter, or ere this
+    I should have fatted all the region kites
+    With this slave's offal: bloody, bawdy villain!
+    Remorseless, treacherous, lecherous, kindless villain!
+    O, vengeance!
+    Why, what an ass am I! This is most brave,
+    That I, the son of a dear father murder'd,
+    Prompted to my revenge by heaven and hell,
+    Must, like a whore, unpack my heart with words,
+    And fall a-cursing, like a very drab,
+    A scullion!
+    Fie upon't! foh! About, my brain! I have heard
+    That guilty creatures sitting at a play
+    Have by the very cunning of the scene
+    Been struck so to the soul that presently
+    They have proclaim'd their malefactions;
+    For murder, though it have no tongue, will speak
+    With most miraculous organ. I'll have these players
+    Play something like the murder of my father
+    Before mine uncle: I'll observe his looks;
+    I'll tent him to the quick: if he but blench,
+    I know my course. The spirit that I have seen
+    May be the devil: and the devil hath power
+    To assume a pleasing shape; yea, and perhaps
+    Out of my weakness and my melancholy,
+    As he is very potent with such spirits,
+    Abuses me to damn me: I'll have grounds
+    More relative than this: the play 's the thing
+    Wherein I'll catch the conscience of the king.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene1.txt
new file mode 100644
index 0000000..8a761a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene1.txt
@@ -0,0 +1,357 @@
+ACT III
+SCENE I. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, POLONIUS, OPHELIA, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    And can you, by no drift of circumstance,
+    Get from him why he puts on this confusion,
+    Grating so harshly all his days of quiet
+    With turbulent and dangerous lunacy?
+
+ROSENCRANTZ
+
+    He does confess he feels himself distracted;
+    But from what cause he will by no means speak.
+
+GUILDENSTERN
+
+    Nor do we find him forward to be sounded,
+    But, with a crafty madness, keeps aloof,
+    When we would bring him on to some confession
+    Of his true state.
+
+QUEEN GERTRUDE
+
+    Did he receive you well?
+
+ROSENCRANTZ
+
+    Most like a gentleman.
+
+GUILDENSTERN
+
+    But with much forcing of his disposition.
+
+ROSENCRANTZ
+
+    Niggard of question; but, of our demands,
+    Most free in his reply.
+
+QUEEN GERTRUDE
+
+    Did you assay him?
+    To any pastime?
+
+ROSENCRANTZ
+
+    Madam, it so fell out, that certain players
+    We o'er-raught on the way: of these we told him;
+    And there did seem in him a kind of joy
+    To hear of it: they are about the court,
+    And, as I think, they have already order
+    This night to play before him.
+
+LORD POLONIUS
+
+    'Tis most true:
+    And he beseech'd me to entreat your majesties
+    To hear and see the matter.
+
+KING CLAUDIUS
+
+    With all my heart; and it doth much content me
+    To hear him so inclined.
+    Good gentlemen, give him a further edge,
+    And drive his purpose on to these delights.
+
+ROSENCRANTZ
+
+    We shall, my lord.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+KING CLAUDIUS
+
+    Sweet Gertrude, leave us too;
+    For we have closely sent for Hamlet hither,
+    That he, as 'twere by accident, may here
+    Affront Ophelia:
+    Her father and myself, lawful espials,
+    Will so bestow ourselves that, seeing, unseen,
+    We may of their encounter frankly judge,
+    And gather by him, as he is behaved,
+    If 't be the affliction of his love or no
+    That thus he suffers for.
+
+QUEEN GERTRUDE
+
+    I shall obey you.
+    And for your part, Ophelia, I do wish
+    That your good beauties be the happy cause
+    Of Hamlet's wildness: so shall I hope your virtues
+    Will bring him to his wonted way again,
+    To both your honours.
+
+OPHELIA
+
+    Madam, I wish it may.
+
+    Exit QUEEN GERTRUDE
+
+LORD POLONIUS
+
+    Ophelia, walk you here. Gracious, so please you,
+    We will bestow ourselves.
+
+    To OPHELIA
+    Read on this book;
+    That show of such an exercise may colour
+    Your loneliness. We are oft to blame in this,--
+    'Tis too much proved--that with devotion's visage
+    And pious action we do sugar o'er
+    The devil himself.
+
+KING CLAUDIUS
+
+    [Aside] O, 'tis too true!
+    How smart a lash that speech doth give my conscience!
+    The harlot's cheek, beautied with plastering art,
+    Is not more ugly to the thing that helps it
+    Than is my deed to my most painted word:
+    O heavy burthen!
+
+LORD POLONIUS
+
+    I hear him coming: let's withdraw, my lord.
+
+    Exeunt KING CLAUDIUS and POLONIUS
+
+    Enter HAMLET
+
+HAMLET
+
+    To be, or not to be, that is the question,
+    Whether 'tis nobler in the mind to suffer
+    The slings and arrows of outrageous fortune,
+    Or to take arms against a sea of troubles,
+    And by opposing end them? To die: to sleep;
+    No more; and by a sleep to say we end
+    The heart-ache and the thousand natural shocks
+    That flesh is heir to, 'tis a consummation
+    Devoutly to be wish'd. To die, to sleep;
+    To sleep: perchance to dream: ay, there's the rub;
+    For in that sleep of death what dreams may come
+    When we have shuffled off this mortal coil,
+    Must give us pause: there's the respect
+    That makes calamity of so long life;
+    For who would bear the whips and scorns of time,
+    The oppressor's wrong, the proud man's contumely,
+    The pangs of despised love, the law's delay,
+    The insolence of office and the spurns
+    That patient merit of the unworthy takes,
+    When he himself might his quietus make
+    With a bare bodkin? who would fardels bear,
+    To grunt and sweat under a weary life,
+    But that the dread of something after death,
+    The undiscover'd country from whose bourn
+    No traveller returns, puzzles the will
+    And makes us rather bear those ills we have
+    Than fly to others that we know not of?
+    Thus conscience does make cowards of us all;
+    And thus the native hue of resolution
+    Is sicklied o'er with the pale cast of thought,
+    And enterprises of great pith and moment
+    With this regard their currents turn awry,
+    And lose the name of action.--Soft you now!
+    The fair Ophelia! Nymph, in thy orisons
+    Be all my sins remember'd.
+
+OPHELIA
+
+    Good my lord,
+    How does your honour for this many a day?
+
+HAMLET
+
+    I humbly thank you; well, well, well.
+
+OPHELIA
+
+    My lord, I have remembrances of yours,
+    That I have longed long to re-deliver;
+    I pray you, now receive them.
+
+HAMLET
+
+    No, not I;
+    I never gave you aught.
+
+OPHELIA
+
+    My honour'd lord, you know right well you did;
+    And, with them, words of so sweet breath composed
+    As made the things more rich: their perfume lost,
+    Take these again; for to the noble mind
+    Rich gifts wax poor when givers prove unkind.
+    There, my lord.
+
+HAMLET
+
+    Ha, ha! are you honest?
+
+OPHELIA
+
+    My lord?
+
+HAMLET
+
+    Are you fair?
+
+OPHELIA
+
+    What means your lordship?
+
+HAMLET
+
+    That if you be honest and fair, your honesty should
+    admit no discourse to your beauty.
+
+OPHELIA
+
+    Could beauty, my lord, have better commerce than
+    with honesty?
+
+HAMLET
+
+    Ay, truly; for the power of beauty will sooner
+    transform honesty from what it is to a bawd than the
+    force of honesty can translate beauty into his
+    likeness: this was sometime a paradox, but now the
+    time gives it proof. I did love you once.
+
+OPHELIA
+
+    Indeed, my lord, you made me believe so.
+
+HAMLET
+
+    You should not have believed me; for virtue cannot
+    so inoculate our old stock but we shall relish of
+    it: I loved you not.
+
+OPHELIA
+
+    I was the more deceived.
+
+HAMLET
+
+    Get thee to a nunnery: why wouldst thou be a
+    breeder of sinners? I am myself indifferent honest;
+    but yet I could accuse me of such things that it
+    were better my mother had not borne me: I am very
+    proud, revengeful, ambitious, with more offences at
+    my beck than I have thoughts to put them in,
+    imagination to give them shape, or time to act them
+    in. What should such fellows as I do crawling
+    between earth and heaven? We are arrant knaves,
+    all; believe none of us. Go thy ways to a nunnery.
+    Where's your father?
+
+OPHELIA
+
+    At home, my lord.
+
+HAMLET
+
+    Let the doors be shut upon him, that he may play the
+    fool no where but in's own house. Farewell.
+
+OPHELIA
+
+    O, help him, you sweet heavens!
+
+HAMLET
+
+    If thou dost marry, I'll give thee this plague for
+    thy dowry: be thou as chaste as ice, as pure as
+    snow, thou shalt not escape calumny. Get thee to a
+    nunnery, go: farewell. Or, if thou wilt needs
+    marry, marry a fool; for wise men know well enough
+    what monsters you make of them. To a nunnery, go,
+    and quickly too. Farewell.
+
+OPHELIA
+
+    O heavenly powers, restore him!
+
+HAMLET
+
+    I have heard of your paintings too, well enough; God
+    has given you one face, and you make yourselves
+    another: you jig, you amble, and you lisp, and
+    nick-name God's creatures, and make your wantonness
+    your ignorance. Go to, I'll no more on't; it hath
+    made me mad. I say, we will have no more marriages:
+    those that are married already, all but one, shall
+    live; the rest shall keep as they are. To a
+    nunnery, go.
+
+    Exit
+
+OPHELIA
+
+    O, what a noble mind is here o'erthrown!
+    The courtier's, soldier's, scholar's, eye, tongue, sword;
+    The expectancy and rose of the fair state,
+    The glass of fashion and the mould of form,
+    The observed of all observers, quite, quite down!
+    And I, of ladies most deject and wretched,
+    That suck'd the honey of his music vows,
+    Now see that noble and most sovereign reason,
+    Like sweet bells jangled, out of tune and harsh;
+    That unmatch'd form and feature of blown youth
+    Blasted with ecstasy: O, woe is me,
+    To have seen what I have seen, see what I see!
+
+    Re-enter KING CLAUDIUS and POLONIUS
+
+KING CLAUDIUS
+
+    Love! his affections do not that way tend;
+    Nor what he spake, though it lack'd form a little,
+    Was not like madness. There's something in his soul,
+    O'er which his melancholy sits on brood;
+    And I do doubt the hatch and the disclose
+    Will be some danger: which for to prevent,
+    I have in quick determination
+    Thus set it down: he shall with speed to England,
+    For the demand of our neglected tribute
+    Haply the seas and countries different
+    With variable objects shall expel
+    This something-settled matter in his heart,
+    Whereon his brains still beating puts him thus
+    From fashion of himself. What think you on't?
+
+LORD POLONIUS
+
+    It shall do well: but yet do I believe
+    The origin and commencement of his grief
+    Sprung from neglected love. How now, Ophelia!
+    You need not tell us what Lord Hamlet said;
+    We heard it all. My lord, do as you please;
+    But, if you hold it fit, after the play
+    Let his queen mother all alone entreat him
+    To show his grief: let her be round with him;
+    And I'll be placed, so please you, in the ear
+    Of all their conference. If she find him not,
+    To England send him, or confine him where
+    Your wisdom best shall think.
+
+KING CLAUDIUS
+
+    It shall be so:
+    Madness in great ones must not unwatch'd go.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene2.txt
new file mode 100644
index 0000000..09aca1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene2.txt
@@ -0,0 +1,863 @@
+SCENE II. A hall in the castle.
+
+    Enter HAMLET and Players 
+
+HAMLET
+
+    Speak the speech, I pray you, as I pronounced it to
+    you, trippingly on the tongue: but if you mouth it,
+    as many of your players do, I had as lief the
+    town-crier spoke my lines. Nor do not saw the air
+    too much with your hand, thus, but use all gently;
+    for in the very torrent, tempest, and, as I may say,
+    the whirlwind of passion, you must acquire and beget
+    a temperance that may give it smoothness. O, it
+    offends me to the soul to hear a robustious
+    periwig-pated fellow tear a passion to tatters, to
+    very rags, to split the ears of the groundlings, who
+    for the most part are capable of nothing but
+    inexplicable dumbshows and noise: I would have such
+    a fellow whipped for o'erdoing Termagant; it
+    out-herods Herod: pray you, avoid it.
+
+First Player
+
+    I warrant your honour.
+
+HAMLET
+
+    Be not too tame neither, but let your own discretion
+    be your tutor: suit the action to the word, the
+    word to the action; with this special o'erstep not
+    the modesty of nature: for any thing so overdone is
+    from the purpose of playing, whose end, both at the
+    first and now, was and is, to hold, as 'twere, the
+    mirror up to nature; to show virtue her own feature,
+    scorn her own image, and the very age and body of
+    the time his form and pressure. Now this overdone,
+    or come tardy off, though it make the unskilful
+    laugh, cannot but make the judicious grieve; the
+    censure of the which one must in your allowance
+    o'erweigh a whole theatre of others. O, there be
+    players that I have seen play, and heard others
+    praise, and that highly, not to speak it profanely,
+    that, neither having the accent of Christians nor
+    the gait of Christian, pagan, nor man, have so
+    strutted and bellowed that I have thought some of
+    nature's journeymen had made men and not made them
+    well, they imitated humanity so abominably.
+
+First Player
+
+    I hope we have reformed that indifferently with us,
+    sir.
+
+HAMLET
+
+    O, reform it altogether. And let those that play
+    your clowns speak no more than is set down for them;
+    for there be of them that will themselves laugh, to
+    set on some quantity of barren spectators to laugh
+    too; though, in the mean time, some necessary
+    question of the play be then to be considered:
+    that's villanous, and shows a most pitiful ambition
+    in the fool that uses it. Go, make you ready.
+
+    Exeunt Players
+
+    Enter POLONIUS, ROSENCRANTZ, and GUILDENSTERN
+    How now, my lord! I will the king hear this piece of work?
+
+LORD POLONIUS
+
+    And the queen too, and that presently.
+
+HAMLET
+
+    Bid the players make haste.
+
+    Exit POLONIUS
+    Will you two help to hasten them?
+
+ROSENCRANTZ GUILDENSTERN
+
+    We will, my lord.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+HAMLET
+
+    What ho! Horatio!
+
+    Enter HORATIO
+
+HORATIO
+
+    Here, sweet lord, at your service.
+
+HAMLET
+
+    Horatio, thou art e'en as just a man
+    As e'er my conversation coped withal.
+
+HORATIO
+
+    O, my dear lord,--
+
+HAMLET
+
+    Nay, do not think I flatter;
+    For what advancement may I hope from thee
+    That no revenue hast but thy good spirits,
+    To feed and clothe thee? Why should the poor be flatter'd?
+    No, let the candied tongue lick absurd pomp,
+    And crook the pregnant hinges of the knee
+    Where thrift may follow fawning. Dost thou hear?
+    Since my dear soul was mistress of her choice
+    And could of men distinguish, her election
+    Hath seal'd thee for herself; for thou hast been
+    As one, in suffering all, that suffers nothing,
+    A man that fortune's buffets and rewards
+    Hast ta'en with equal thanks: and blest are those
+    Whose blood and judgment are so well commingled,
+    That they are not a pipe for fortune's finger
+    To sound what stop she please. Give me that man
+    That is not passion's slave, and I will wear him
+    In my heart's core, ay, in my heart of heart,
+    As I do thee.--Something too much of this.--
+    There is a play to-night before the king;
+    One scene of it comes near the circumstance
+    Which I have told thee of my father's death:
+    I prithee, when thou seest that act afoot,
+    Even with the very comment of thy soul
+    Observe mine uncle: if his occulted guilt
+    Do not itself unkennel in one speech,
+    It is a damned ghost that we have seen,
+    And my imaginations are as foul
+    As Vulcan's stithy. Give him heedful note;
+    For I mine eyes will rivet to his face,
+    And after we will both our judgments join
+    In censure of his seeming.
+
+HORATIO
+
+    Well, my lord:
+    If he steal aught the whilst this play is playing,
+    And 'scape detecting, I will pay the theft.
+
+HAMLET
+
+    They are coming to the play; I must be idle:
+    Get you a place.
+
+    Danish march. A flourish. Enter KING CLAUDIUS, QUEEN GERTRUDE, POLONIUS, OPHELIA, ROSENCRANTZ, GUILDENSTERN, and others
+
+KING CLAUDIUS
+
+    How fares our cousin Hamlet?
+
+HAMLET
+
+    Excellent, i' faith; of the chameleon's dish: I eat
+    the air, promise-crammed: you cannot feed capons so.
+
+KING CLAUDIUS
+
+    I have nothing with this answer, Hamlet; these words
+    are not mine.
+
+HAMLET
+
+    No, nor mine now.
+
+    To POLONIUS
+    My lord, you played once i' the university, you say?
+
+LORD POLONIUS
+
+    That did I, my lord; and was accounted a good actor.
+
+HAMLET
+
+    What did you enact?
+
+LORD POLONIUS
+
+    I did enact Julius Caesar: I was killed i' the
+    Capitol; Brutus killed me.
+
+HAMLET
+
+    It was a brute part of him to kill so capital a calf
+    there. Be the players ready?
+
+ROSENCRANTZ
+
+    Ay, my lord; they stay upon your patience.
+
+QUEEN GERTRUDE
+
+    Come hither, my dear Hamlet, sit by me.
+
+HAMLET
+
+    No, good mother, here's metal more attractive.
+
+LORD POLONIUS
+
+    [To KING CLAUDIUS] O, ho! do you mark that?
+
+HAMLET
+
+    Lady, shall I lie in your lap?
+
+    Lying down at OPHELIA's feet
+
+OPHELIA
+
+    No, my lord.
+
+HAMLET
+
+    I mean, my head upon your lap?
+
+OPHELIA
+
+    Ay, my lord.
+
+HAMLET
+
+    Do you think I meant country matters?
+
+OPHELIA
+
+    I think nothing, my lord.
+
+HAMLET
+
+    That's a fair thought to lie between maids' legs.
+
+OPHELIA
+
+    What is, my lord?
+
+HAMLET
+
+    Nothing.
+
+OPHELIA
+
+    You are merry, my lord.
+
+HAMLET
+
+    Who, I?
+
+OPHELIA
+
+    Ay, my lord.
+
+HAMLET
+
+    O God, your only jig-maker. What should a man do
+    but be merry? for, look you, how cheerfully my
+    mother looks, and my father died within these two hours.
+
+OPHELIA
+
+    Nay, 'tis twice two months, my lord.
+
+HAMLET
+
+    So long? Nay then, let the devil wear black, for
+    I'll have a suit of sables. O heavens! die two
+    months ago, and not forgotten yet? Then there's
+    hope a great man's memory may outlive his life half
+    a year: but, by'r lady, he must build churches,
+    then; or else shall he suffer not thinking on, with
+    the hobby-horse, whose epitaph is 'For, O, for, O,
+    the hobby-horse is forgot.'
+
+    Hautboys play. The dumb-show enters
+
+    Enter a King and a Queen very lovingly; the Queen embracing him, and he her. She kneels, and makes show of protestation unto him. He takes her up, and declines his head upon her neck: lays him down upon a bank of flowers: she, seeing him asleep, leaves him. Anon comes in a fellow, takes off his crown, kisses it, and pours poison in the King's ears, and exit. The Queen returns; finds the King dead, and makes passionate action. The Poisoner, with some two or three Mutes, comes in again, seeming to lament with her. The dead body is carried away. The Poisoner wooes the Queen with gifts: she seems loath and unwilling awhile, but in the end accepts his love
+
+    Exeunt
+
+OPHELIA
+
+    What means this, my lord?
+
+HAMLET
+
+    Marry, this is miching mallecho; it means mischief.
+
+OPHELIA
+
+    Belike this show imports the argument of the play.
+
+    Enter Prologue
+
+HAMLET
+
+    We shall know by this fellow: the players cannot
+    keep counsel; they'll tell all.
+
+OPHELIA
+
+    Will he tell us what this show meant?
+
+HAMLET
+
+    Ay, or any show that you'll show him: be not you
+    ashamed to show, he'll not shame to tell you what it means.
+
+OPHELIA
+
+    You are naught, you are naught: I'll mark the play.
+
+Prologue
+
+    For us, and for our tragedy,
+    Here stooping to your clemency,
+    We beg your hearing patiently.
+
+    Exit
+
+HAMLET
+
+    Is this a prologue, or the posy of a ring?
+
+OPHELIA
+
+    'Tis brief, my lord.
+
+HAMLET
+
+    As woman's love.
+
+    Enter two Players, King and Queen
+
+Player King
+
+    Full thirty times hath Phoebus' cart gone round
+    Neptune's salt wash and Tellus' orbed ground,
+    And thirty dozen moons with borrow'd sheen
+    About the world have times twelve thirties been,
+    Since love our hearts and Hymen did our hands
+    Unite commutual in most sacred bands.
+
+Player Queen
+
+    So many journeys may the sun and moon
+    Make us again count o'er ere love be done!
+    But, woe is me, you are so sick of late,
+    So far from cheer and from your former state,
+    That I distrust you. Yet, though I distrust,
+    Discomfort you, my lord, it nothing must:
+    For women's fear and love holds quantity;
+    In neither aught, or in extremity.
+    Now, what my love is, proof hath made you know;
+    And as my love is sized, my fear is so:
+    Where love is great, the littlest doubts are fear;
+    Where little fears grow great, great love grows there.
+
+Player King
+
+    'Faith, I must leave thee, love, and shortly too;
+    My operant powers their functions leave to do:
+    And thou shalt live in this fair world behind,
+    Honour'd, beloved; and haply one as kind
+    For husband shalt thou--
+
+Player Queen
+
+    O, confound the rest!
+    Such love must needs be treason in my breast:
+    In second husband let me be accurst!
+    None wed the second but who kill'd the first.
+
+HAMLET
+
+    [Aside] Wormwood, wormwood.
+
+Player Queen
+
+    The instances that second marriage move
+    Are base respects of thrift, but none of love:
+    A second time I kill my husband dead,
+    When second husband kisses me in bed.
+
+Player King
+
+    I do believe you think what now you speak;
+    But what we do determine oft we break.
+    Purpose is but the slave to memory,
+    Of violent birth, but poor validity;
+    Which now, like fruit unripe, sticks on the tree;
+    But fall, unshaken, when they mellow be.
+    Most necessary 'tis that we forget
+    To pay ourselves what to ourselves is debt:
+    What to ourselves in passion we propose,
+    The passion ending, doth the purpose lose.
+    The violence of either grief or joy
+    Their own enactures with themselves destroy:
+    Where joy most revels, grief doth most lament;
+    Grief joys, joy grieves, on slender accident.
+    This world is not for aye, nor 'tis not strange
+    That even our loves should with our fortunes change;
+    For 'tis a question left us yet to prove,
+    Whether love lead fortune, or else fortune love.
+    The great man down, you mark his favourite flies;
+    The poor advanced makes friends of enemies.
+    And hitherto doth love on fortune tend;
+    For who not needs shall never lack a friend,
+    And who in want a hollow friend doth try,
+    Directly seasons him his enemy.
+    But, orderly to end where I begun,
+    Our wills and fates do so contrary run
+    That our devices still are overthrown;
+    Our thoughts are ours, their ends none of our own:
+    So think thou wilt no second husband wed;
+    But die thy thoughts when thy first lord is dead.
+
+Player Queen
+
+    Nor earth to me give food, nor heaven light!
+    Sport and repose lock from me day and night!
+    To desperation turn my trust and hope!
+    An anchor's cheer in prison be my scope!
+    Each opposite that blanks the face of joy
+    Meet what I would have well and it destroy!
+    Both here and hence pursue me lasting strife,
+    If, once a widow, ever I be wife!
+
+HAMLET
+
+    If she should break it now!
+
+Player King
+
+    'Tis deeply sworn. Sweet, leave me here awhile;
+    My spirits grow dull, and fain I would beguile
+    The tedious day with sleep.
+
+    Sleeps
+
+Player Queen
+
+    Sleep rock thy brain,
+    And never come mischance between us twain!
+
+    Exit
+
+HAMLET
+
+    Madam, how like you this play?
+
+QUEEN GERTRUDE
+
+    The lady protests too much, methinks.
+
+HAMLET
+
+    O, but she'll keep her word.
+
+KING CLAUDIUS
+
+    Have you heard the argument? Is there no offence in 't?
+
+HAMLET
+
+    No, no, they do but jest, poison in jest; no offence
+    i' the world.
+
+KING CLAUDIUS
+
+    What do you call the play?
+
+HAMLET
+
+    The Mouse-trap. Marry, how? Tropically. This play
+    is the image of a murder done in Vienna: Gonzago is
+    the duke's name; his wife, Baptista: you shall see
+    anon; 'tis a knavish piece of work: but what o'
+    that? your majesty and we that have free souls, it
+    touches us not: let the galled jade wince, our
+    withers are unwrung.
+
+    Enter LUCIANUS
+    This is one Lucianus, nephew to the king.
+
+OPHELIA
+
+    You are as good as a chorus, my lord.
+
+HAMLET
+
+    I could interpret between you and your love, if I
+    could see the puppets dallying.
+
+OPHELIA
+
+    You are keen, my lord, you are keen.
+
+HAMLET
+
+    It would cost you a groaning to take off my edge.
+
+OPHELIA
+
+    Still better, and worse.
+
+HAMLET
+
+    So you must take your husbands. Begin, murderer;
+    pox, leave thy damnable faces, and begin. Come:
+    'the croaking raven doth bellow for revenge.'
+
+LUCIANUS
+
+    Thoughts black, hands apt, drugs fit, and time agreeing;
+    Confederate season, else no creature seeing;
+    Thou mixture rank, of midnight weeds collected,
+    With Hecate's ban thrice blasted, thrice infected,
+    Thy natural magic and dire property,
+    On wholesome life usurp immediately.
+
+    Pours the poison into the sleeper's ears
+
+HAMLET
+
+    He poisons him i' the garden for's estate. His
+    name's Gonzago: the story is extant, and writ in
+    choice Italian: you shall see anon how the murderer
+    gets the love of Gonzago's wife.
+
+OPHELIA
+
+    The king rises.
+
+HAMLET
+
+    What, frighted with false fire!
+
+QUEEN GERTRUDE
+
+    How fares my lord?
+
+LORD POLONIUS
+
+    Give o'er the play.
+
+KING CLAUDIUS
+
+    Give me some light: away!
+
+All
+
+    Lights, lights, lights!
+
+    Exeunt all but HAMLET and HORATIO
+
+HAMLET
+
+    Why, let the stricken deer go weep,
+    The hart ungalled play;
+    For some must watch, while some must sleep:
+    So runs the world away.
+    Would not this, sir, and a forest of feathers-- if
+    the rest of my fortunes turn Turk with me--with two
+    Provincial roses on my razed shoes, get me a
+    fellowship in a cry of players, sir?
+
+HORATIO
+
+    Half a share.
+
+HAMLET
+
+    A whole one, I.
+    For thou dost know, O Damon dear,
+    This realm dismantled was
+    Of Jove himself; and now reigns here
+    A very, very--pajock.
+
+HORATIO
+
+    You might have rhymed.
+
+HAMLET
+
+    O good Horatio, I'll take the ghost's word for a
+    thousand pound. Didst perceive?
+
+HORATIO
+
+    Very well, my lord.
+
+HAMLET
+
+    Upon the talk of the poisoning?
+
+HORATIO
+
+    I did very well note him.
+
+HAMLET
+
+    Ah, ha! Come, some music! come, the recorders!
+    For if the king like not the comedy,
+    Why then, belike, he likes it not, perdy.
+    Come, some music!
+
+    Re-enter ROSENCRANTZ and GUILDENSTERN
+
+GUILDENSTERN
+
+    Good my lord, vouchsafe me a word with you.
+
+HAMLET
+
+    Sir, a whole history.
+
+GUILDENSTERN
+
+    The king, sir,--
+
+HAMLET
+
+    Ay, sir, what of him?
+
+GUILDENSTERN
+
+    Is in his retirement marvellous distempered.
+
+HAMLET
+
+    With drink, sir?
+
+GUILDENSTERN
+
+    No, my lord, rather with choler.
+
+HAMLET
+
+    Your wisdom should show itself more richer to
+    signify this to his doctor; for, for me to put him
+    to his purgation would perhaps plunge him into far
+    more choler.
+
+GUILDENSTERN
+
+    Good my lord, put your discourse into some frame and
+    start not so wildly from my affair.
+
+HAMLET
+
+    I am tame, sir: pronounce.
+
+GUILDENSTERN
+
+    The queen, your mother, in most great affliction of
+    spirit, hath sent me to you.
+
+HAMLET
+
+    You are welcome.
+
+GUILDENSTERN
+
+    Nay, good my lord, this courtesy is not of the right
+    breed. If it shall please you to make me a
+    wholesome answer, I will do your mother's
+    commandment: if not, your pardon and my return
+    shall be the end of my business.
+
+HAMLET
+
+    Sir, I cannot.
+
+GUILDENSTERN
+
+    What, my lord?
+
+HAMLET
+
+    Make you a wholesome answer; my wit's diseased: but,
+    sir, such answer as I can make, you shall command;
+    or, rather, as you say, my mother: therefore no
+    more, but to the matter: my mother, you say,--
+
+ROSENCRANTZ
+
+    Then thus she says; your behavior hath struck her
+    into amazement and admiration.
+
+HAMLET
+
+    O wonderful son, that can so astonish a mother! But
+    is there no sequel at the heels of this mother's
+    admiration? Impart.
+
+ROSENCRANTZ
+
+    She desires to speak with you in her closet, ere you
+    go to bed.
+
+HAMLET
+
+    We shall obey, were she ten times our mother. Have
+    you any further trade with us?
+
+ROSENCRANTZ
+
+    My lord, you once did love me.
+
+HAMLET
+
+    So I do still, by these pickers and stealers.
+
+ROSENCRANTZ
+
+    Good my lord, what is your cause of distemper? you
+    do, surely, bar the door upon your own liberty, if
+    you deny your griefs to your friend.
+
+HAMLET
+
+    Sir, I lack advancement.
+
+ROSENCRANTZ
+
+    How can that be, when you have the voice of the king
+    himself for your succession in Denmark?
+
+HAMLET
+
+    Ay, but sir, 'While the grass grows,'--the proverb
+    is something musty.
+
+    Re-enter Players with recorders
+    O, the recorders! let me see one. To withdraw with
+    you:--why do you go about to recover the wind of me,
+    as if you would drive me into a toil?
+
+GUILDENSTERN
+
+    O, my lord, if my duty be too bold, my love is too
+    unmannerly.
+
+HAMLET
+
+    I do not well understand that. Will you play upon
+    this pipe?
+
+GUILDENSTERN
+
+    My lord, I cannot.
+
+HAMLET
+
+    I pray you.
+
+GUILDENSTERN
+
+    Believe me, I cannot.
+
+HAMLET
+
+    I do beseech you.
+
+GUILDENSTERN
+
+    I know no touch of it, my lord.
+
+HAMLET
+
+    'Tis as easy as lying: govern these ventages with
+    your lingers and thumb, give it breath with your
+    mouth, and it will discourse most eloquent music.
+    Look you, these are the stops.
+
+GUILDENSTERN
+
+    But these cannot I command to any utterance of
+    harmony; I have not the skill.
+
+HAMLET
+
+    Why, look you now, how unworthy a thing you make of
+    me! You would play upon me; you would seem to know
+    my stops; you would pluck out the heart of my
+    mystery; you would sound me from my lowest note to
+    the top of my compass: and there is much music,
+    excellent voice, in this little organ; yet cannot
+    you make it speak. 'Sblood, do you think I am
+    easier to be played on than a pipe? Call me what
+    instrument you will, though you can fret me, yet you
+    cannot play upon me.
+
+    Enter POLONIUS
+    God bless you, sir!
+
+LORD POLONIUS
+
+    My lord, the queen would speak with you, and
+    presently.
+
+HAMLET
+
+    Do you see yonder cloud that's almost in shape of a camel?
+
+LORD POLONIUS
+
+    By the mass, and 'tis like a camel, indeed.
+
+HAMLET
+
+    Methinks it is like a weasel.
+
+LORD POLONIUS
+
+    It is backed like a weasel.
+
+HAMLET
+
+    Or like a whale?
+
+LORD POLONIUS
+
+    Very like a whale.
+
+HAMLET
+
+    Then I will come to my mother by and by. They fool
+    me to the top of my bent. I will come by and by.
+
+LORD POLONIUS
+
+    I will say so.
+
+HAMLET
+
+    By and by is easily said.
+
+    Exit POLONIUS
+    Leave me, friends.
+
+    Exeunt all but HAMLET
+    Tis now the very witching time of night,
+    When churchyards yawn and hell itself breathes out
+    Contagion to this world: now could I drink hot blood,
+    And do such bitter business as the day
+    Would quake to look on. Soft! now to my mother.
+    O heart, lose not thy nature; let not ever
+    The soul of Nero enter this firm bosom:
+    Let me be cruel, not unnatural:
+    I will speak daggers to her, but use none;
+    My tongue and soul in this be hypocrites;
+    How in my words soever she be shent,
+    To give them seals never, my soul, consent!
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene3.txt
new file mode 100644
index 0000000..dbac705
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene3.txt
@@ -0,0 +1,145 @@
+SCENE III. A room in the castle.
+
+    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    I like him not, nor stands it safe with us
+    To let his madness range. Therefore prepare you;
+    I your commission will forthwith dispatch,
+    And he to England shall along with you:
+    The terms of our estate may not endure
+    Hazard so dangerous as doth hourly grow
+    Out of his lunacies.
+
+GUILDENSTERN
+
+    We will ourselves provide:
+    Most holy and religious fear it is
+    To keep those many many bodies safe
+    That live and feed upon your majesty.
+
+ROSENCRANTZ
+
+    The single and peculiar life is bound,
+    With all the strength and armour of the mind,
+    To keep itself from noyance; but much more
+    That spirit upon whose weal depend and rest
+    The lives of many. The cease of majesty
+    Dies not alone; but, like a gulf, doth draw
+    What's near it with it: it is a massy wheel,
+    Fix'd on the summit of the highest mount,
+    To whose huge spokes ten thousand lesser things
+    Are mortised and adjoin'd; which, when it falls,
+    Each small annexment, petty consequence,
+    Attends the boisterous ruin. Never alone
+    Did the king sigh, but with a general groan.
+
+KING CLAUDIUS
+
+    Arm you, I pray you, to this speedy voyage;
+    For we will fetters put upon this fear,
+    Which now goes too free-footed.
+
+ROSENCRANTZ GUILDENSTERN
+
+    We will haste us.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    My lord, he's going to his mother's closet:
+    Behind the arras I'll convey myself,
+    To hear the process; and warrant she'll tax him home:
+    And, as you said, and wisely was it said,
+    'Tis meet that some more audience than a mother,
+    Since nature makes them partial, should o'erhear
+    The speech, of vantage. Fare you well, my liege:
+    I'll call upon you ere you go to bed,
+    And tell you what I know.
+
+KING CLAUDIUS
+
+    Thanks, dear my lord.
+
+    Exit POLONIUS
+    O, my offence is rank it smells to heaven;
+    It hath the primal eldest curse upon't,
+    A brother's murder. Pray can I not,
+    Though inclination be as sharp as will:
+    My stronger guilt defeats my strong intent;
+    And, like a man to double business bound,
+    I stand in pause where I shall first begin,
+    And both neglect. What if this cursed hand
+    Were thicker than itself with brother's blood,
+    Is there not rain enough in the sweet heavens
+    To wash it white as snow? Whereto serves mercy
+    But to confront the visage of offence?
+    And what's in prayer but this two-fold force,
+    To be forestalled ere we come to fall,
+    Or pardon'd being down? Then I'll look up;
+    My fault is past. But, O, what form of prayer
+    Can serve my turn? 'Forgive me my foul murder'?
+    That cannot be; since I am still possess'd
+    Of those effects for which I did the murder,
+    My crown, mine own ambition and my queen.
+    May one be pardon'd and retain the offence?
+    In the corrupted currents of this world
+    Offence's gilded hand may shove by justice,
+    And oft 'tis seen the wicked prize itself
+    Buys out the law: but 'tis not so above;
+    There is no shuffling, there the action lies
+    In his true nature; and we ourselves compell'd,
+    Even to the teeth and forehead of our faults,
+    To give in evidence. What then? what rests?
+    Try what repentance can: what can it not?
+    Yet what can it when one can not repent?
+    O wretched state! O bosom black as death!
+    O limed soul, that, struggling to be free,
+    Art more engaged! Help, angels! Make assay!
+    Bow, stubborn knees; and, heart with strings of steel,
+    Be soft as sinews of the newborn babe!
+    All may be well.
+
+    Retires and kneels
+
+    Enter HAMLET
+
+HAMLET
+
+    Now might I do it pat, now he is praying;
+    And now I'll do't. And so he goes to heaven;
+    And so am I revenged. That would be scann'd:
+    A villain kills my father; and for that,
+    I, his sole son, do this same villain send
+    To heaven.
+    O, this is hire and salary, not revenge.
+    He took my father grossly, full of bread;
+    With all his crimes broad blown, as flush as May;
+    And how his audit stands who knows save heaven?
+    But in our circumstance and course of thought,
+    'Tis heavy with him: and am I then revenged,
+    To take him in the purging of his soul,
+    When he is fit and season'd for his passage?
+    No!
+    Up, sword; and know thou a more horrid hent:
+    When he is drunk asleep, or in his rage,
+    Or in the incestuous pleasure of his bed;
+    At gaming, swearing, or about some act
+    That has no relish of salvation in't;
+    Then trip him, that his heels may kick at heaven,
+    And that his soul may be as damn'd and black
+    As hell, whereto it goes. My mother stays:
+    This physic but prolongs thy sickly days.
+
+    Exit
+
+KING CLAUDIUS
+
+    [Rising] My words fly up, my thoughts remain below:
+    Words without thoughts never to heaven go.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene4.txt
new file mode 100644
index 0000000..3d68af0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act3/scene4.txt
@@ -0,0 +1,424 @@
+SCENE IV. The Queen's closet.
+
+    Enter QUEEN GERTRUDE and POLONIUS 
+
+LORD POLONIUS
+
+    He will come straight. Look you lay home to him:
+    Tell him his pranks have been too broad to bear with,
+    And that your grace hath screen'd and stood between
+    Much heat and him. I'll sconce me even here.
+    Pray you, be round with him.
+
+HAMLET
+
+    [Within] Mother, mother, mother!
+
+QUEEN GERTRUDE
+
+    I'll warrant you,
+    Fear me not: withdraw, I hear him coming.
+
+    POLONIUS hides behind the arras
+
+    Enter HAMLET
+
+HAMLET
+
+    Now, mother, what's the matter?
+
+QUEEN GERTRUDE
+
+    Hamlet, thou hast thy father much offended.
+
+HAMLET
+
+    Mother, you have my father much offended.
+
+QUEEN GERTRUDE
+
+    Come, come, you answer with an idle tongue.
+
+HAMLET
+
+    Go, go, you question with a wicked tongue.
+
+QUEEN GERTRUDE
+
+    Why, how now, Hamlet!
+
+HAMLET
+
+    What's the matter now?
+
+QUEEN GERTRUDE
+
+    Have you forgot me?
+
+HAMLET
+
+    No, by the rood, not so:
+    You are the queen, your husband's brother's wife;
+    And--would it were not so!--you are my mother.
+
+QUEEN GERTRUDE
+
+    Nay, then, I'll set those to you that can speak.
+
+HAMLET
+
+    Come, come, and sit you down; you shall not budge;
+    You go not till I set you up a glass
+    Where you may see the inmost part of you.
+
+QUEEN GERTRUDE
+
+    What wilt thou do? thou wilt not murder me?
+    Help, help, ho!
+
+LORD POLONIUS
+
+    [Behind] What, ho! help, help, help!
+
+HAMLET
+
+    [Drawing] How now! a rat? Dead, for a ducat, dead!
+
+    Makes a pass through the arras
+
+LORD POLONIUS
+
+    [Behind] O, I am slain!
+
+    Falls and dies
+
+QUEEN GERTRUDE
+
+    O me, what hast thou done?
+
+HAMLET
+
+    Nay, I know not:
+    Is it the king?
+
+QUEEN GERTRUDE
+
+    O, what a rash and bloody deed is this!
+
+HAMLET
+
+    A bloody deed! almost as bad, good mother,
+    As kill a king, and marry with his brother.
+
+QUEEN GERTRUDE
+
+    As kill a king!
+
+HAMLET
+
+    Ay, lady, 'twas my word.
+
+    Lifts up the array and discovers POLONIUS
+    Thou wretched, rash, intruding fool, farewell!
+    I took thee for thy better: take thy fortune;
+    Thou find'st to be too busy is some danger.
+    Leave wringing of your hands: peace! sit you down,
+    And let me wring your heart; for so I shall,
+    If it be made of penetrable stuff,
+    If damned custom have not brass'd it so
+    That it is proof and bulwark against sense.
+
+QUEEN GERTRUDE
+
+    What have I done, that thou darest wag thy tongue
+    In noise so rude against me?
+
+HAMLET
+
+    Such an act
+    That blurs the grace and blush of modesty,
+    Calls virtue hypocrite, takes off the rose
+    From the fair forehead of an innocent love
+    And sets a blister there, makes marriage-vows
+    As false as dicers' oaths: O, such a deed
+    As from the body of contraction plucks
+    The very soul, and sweet religion makes
+    A rhapsody of words: heaven's face doth glow:
+    Yea, this solidity and compound mass,
+    With tristful visage, as against the doom,
+    Is thought-sick at the act.
+
+QUEEN GERTRUDE
+
+    Ay me, what act,
+    That roars so loud, and thunders in the index?
+
+HAMLET
+
+    Look here, upon this picture, and on this,
+    The counterfeit presentment of two brothers.
+    See, what a grace was seated on this brow;
+    Hyperion's curls; the front of Jove himself;
+    An eye like Mars, to threaten and command;
+    A station like the herald Mercury
+    New-lighted on a heaven-kissing hill;
+    A combination and a form indeed,
+    Where every god did seem to set his seal,
+    To give the world assurance of a man:
+    This was your husband. Look you now, what follows:
+    Here is your husband; like a mildew'd ear,
+    Blasting his wholesome brother. Have you eyes?
+    Could you on this fair mountain leave to feed,
+    And batten on this moor? Ha! have you eyes?
+    You cannot call it love; for at your age
+    The hey-day in the blood is tame, it's humble,
+    And waits upon the judgment: and what judgment
+    Would step from this to this? Sense, sure, you have,
+    Else could you not have motion; but sure, that sense
+    Is apoplex'd; for madness would not err,
+    Nor sense to ecstasy was ne'er so thrall'd
+    But it reserved some quantity of choice,
+    To serve in such a difference. What devil was't
+    That thus hath cozen'd you at hoodman-blind?
+    Eyes without feeling, feeling without sight,
+    Ears without hands or eyes, smelling sans all,
+    Or but a sickly part of one true sense
+    Could not so mope.
+    O shame! where is thy blush? Rebellious hell,
+    If thou canst mutine in a matron's bones,
+    To flaming youth let virtue be as wax,
+    And melt in her own fire: proclaim no shame
+    When the compulsive ardour gives the charge,
+    Since frost itself as actively doth burn
+    And reason panders will.
+
+QUEEN GERTRUDE
+
+    O Hamlet, speak no more:
+    Thou turn'st mine eyes into my very soul;
+    And there I see such black and grained spots
+    As will not leave their tinct.
+
+HAMLET
+
+    Nay, but to live
+    In the rank sweat of an enseamed bed,
+    Stew'd in corruption, honeying and making love
+    Over the nasty sty,--
+
+QUEEN GERTRUDE
+
+    O, speak to me no more;
+    These words, like daggers, enter in mine ears;
+    No more, sweet Hamlet!
+
+HAMLET
+
+    A murderer and a villain;
+    A slave that is not twentieth part the tithe
+    Of your precedent lord; a vice of kings;
+    A cutpurse of the empire and the rule,
+    That from a shelf the precious diadem stole,
+    And put it in his pocket!
+
+QUEEN GERTRUDE
+
+    No more!
+
+HAMLET
+
+    A king of shreds and patches,--
+
+    Enter Ghost
+    Save me, and hover o'er me with your wings,
+    You heavenly guards! What would your gracious figure?
+
+QUEEN GERTRUDE
+
+    Alas, he's mad!
+
+HAMLET
+
+    Do you not come your tardy son to chide,
+    That, lapsed in time and passion, lets go by
+    The important acting of your dread command? O, say!
+
+Ghost
+
+    Do not forget: this visitation
+    Is but to whet thy almost blunted purpose.
+    But, look, amazement on thy mother sits:
+    O, step between her and her fighting soul:
+    Conceit in weakest bodies strongest works:
+    Speak to her, Hamlet.
+
+HAMLET
+
+    How is it with you, lady?
+
+QUEEN GERTRUDE
+
+    Alas, how is't with you,
+    That you do bend your eye on vacancy
+    And with the incorporal air do hold discourse?
+    Forth at your eyes your spirits wildly peep;
+    And, as the sleeping soldiers in the alarm,
+    Your bedded hair, like life in excrements,
+    Starts up, and stands on end. O gentle son,
+    Upon the heat and flame of thy distemper
+    Sprinkle cool patience. Whereon do you look?
+
+HAMLET
+
+    On him, on him! Look you, how pale he glares!
+    His form and cause conjoin'd, preaching to stones,
+    Would make them capable. Do not look upon me;
+    Lest with this piteous action you convert
+    My stern effects: then what I have to do
+    Will want true colour; tears perchance for blood.
+
+QUEEN GERTRUDE
+
+    To whom do you speak this?
+
+HAMLET
+
+    Do you see nothing there?
+
+QUEEN GERTRUDE
+
+    Nothing at all; yet all that is I see.
+
+HAMLET
+
+    Nor did you nothing hear?
+
+QUEEN GERTRUDE
+
+    No, nothing but ourselves.
+
+HAMLET
+
+    Why, look you there! look, how it steals away!
+    My father, in his habit as he lived!
+    Look, where he goes, even now, out at the portal!
+
+    Exit Ghost
+
+QUEEN GERTRUDE
+
+    This the very coinage of your brain:
+    This bodiless creation ecstasy
+    Is very cunning in.
+
+HAMLET
+
+    Ecstasy!
+    My pulse, as yours, doth temperately keep time,
+    And makes as healthful music: it is not madness
+    That I have utter'd: bring me to the test,
+    And I the matter will re-word; which madness
+    Would gambol from. Mother, for love of grace,
+    Lay not that mattering unction to your soul,
+    That not your trespass, but my madness speaks:
+    It will but skin and film the ulcerous place,
+    Whilst rank corruption, mining all within,
+    Infects unseen. Confess yourself to heaven;
+    Repent what's past; avoid what is to come;
+    And do not spread the compost on the weeds,
+    To make them ranker. Forgive me this my virtue;
+    For in the fatness of these pursy times
+    Virtue itself of vice must pardon beg,
+    Yea, curb and woo for leave to do him good.
+
+QUEEN GERTRUDE
+
+    O Hamlet, thou hast cleft my heart in twain.
+
+HAMLET
+
+    O, throw away the worser part of it,
+    And live the purer with the other half.
+    Good night: but go not to mine uncle's bed;
+    Assume a virtue, if you have it not.
+    That monster, custom, who all sense doth eat,
+    Of habits devil, is angel yet in this,
+    That to the use of actions fair and good
+    He likewise gives a frock or livery,
+    That aptly is put on. Refrain to-night,
+    And that shall lend a kind of easiness
+    To the next abstinence: the next more easy;
+    For use almost can change the stamp of nature,
+    And either [ ] the devil, or throw him out
+    With wondrous potency. Once more, good night:
+    And when you are desirous to be bless'd,
+    I'll blessing beg of you. For this same lord,
+
+    Pointing to POLONIUS
+    I do repent: but heaven hath pleased it so,
+    To punish me with this and this with me,
+    That I must be their scourge and minister.
+    I will bestow him, and will answer well
+    The death I gave him. So, again, good night.
+    I must be cruel, only to be kind:
+    Thus bad begins and worse remains behind.
+    One word more, good lady.
+
+QUEEN GERTRUDE
+
+    What shall I do?
+
+HAMLET
+
+    Not this, by no means, that I bid you do:
+    Let the bloat king tempt you again to bed;
+    Pinch wanton on your cheek; call you his mouse;
+    And let him, for a pair of reechy kisses,
+    Or paddling in your neck with his damn'd fingers,
+    Make you to ravel all this matter out,
+    That I essentially am not in madness,
+    But mad in craft. 'Twere good you let him know;
+    For who, that's but a queen, fair, sober, wise,
+    Would from a paddock, from a bat, a gib,
+    Such dear concernings hide? who would do so?
+    No, in despite of sense and secrecy,
+    Unpeg the basket on the house's top.
+    Let the birds fly, and, like the famous ape,
+    To try conclusions, in the basket creep,
+    And break your own neck down.
+
+QUEEN GERTRUDE
+
+    Be thou assured, if words be made of breath,
+    And breath of life, I have no life to breathe
+    What thou hast said to me.
+
+HAMLET
+
+    I must to England; you know that?
+
+QUEEN GERTRUDE
+
+    Alack,
+    I had forgot: 'tis so concluded on.
+
+HAMLET
+
+    There's letters seal'd: and my two schoolfellows,
+    Whom I will trust as I will adders fang'd,
+    They bear the mandate; they must sweep my way,
+    And marshal me to knavery. Let it work;
+    For 'tis the sport to have the engineer
+    Hoist with his own petard: and 't shall go hard
+    But I will delve one yard below their mines,
+    And blow them at the moon: O, 'tis most sweet,
+    When in one line two crafts directly meet.
+    This man shall set me packing:
+    I'll lug the guts into the neighbour room.
+    Mother, good night. Indeed this counsellor
+    Is now most still, most secret and most grave,
+    Who was in life a foolish prating knave.
+    Come, sir, to draw toward an end with you.
+    Good night, mother.
+
+    Exeunt severally; HAMLET dragging in POLONIUS
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene1.txt
new file mode 100644
index 0000000..a254aed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene1.txt
@@ -0,0 +1,75 @@
+ACT IV
+SCENE I. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    There's matter in these sighs, these profound heaves:
+    You must translate: 'tis fit we understand them.
+    Where is your son?
+
+QUEEN GERTRUDE
+
+    Bestow this place on us a little while.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Ah, my good lord, what have I seen to-night!
+
+KING CLAUDIUS
+
+    What, Gertrude? How does Hamlet?
+
+QUEEN GERTRUDE
+
+    Mad as the sea and wind, when both contend
+    Which is the mightier: in his lawless fit,
+    Behind the arras hearing something stir,
+    Whips out his rapier, cries, 'A rat, a rat!'
+    And, in this brainish apprehension, kills
+    The unseen good old man.
+
+KING CLAUDIUS
+
+    O heavy deed!
+    It had been so with us, had we been there:
+    His liberty is full of threats to all;
+    To you yourself, to us, to every one.
+    Alas, how shall this bloody deed be answer'd?
+    It will be laid to us, whose providence
+    Should have kept short, restrain'd and out of haunt,
+    This mad young man: but so much was our love,
+    We would not understand what was most fit;
+    But, like the owner of a foul disease,
+    To keep it from divulging, let it feed
+    Even on the pith of Life. Where is he gone?
+
+QUEEN GERTRUDE
+
+    To draw apart the body he hath kill'd:
+    O'er whom his very madness, like some ore
+    Among a mineral of metals base,
+    Shows itself pure; he weeps for what is done.
+
+KING CLAUDIUS
+
+    O Gertrude, come away!
+    The sun no sooner shall the mountains touch,
+    But we will ship him hence: and this vile deed
+    We must, with all our majesty and skill,
+    Both countenance and excuse. Ho, Guildenstern!
+
+    Re-enter ROSENCRANTZ and GUILDENSTERN
+    Friends both, go join you with some further aid:
+    Hamlet in madness hath Polonius slain,
+    And from his mother's closet hath he dragg'd him:
+    Go seek him out; speak fair, and bring the body
+    Into the chapel. I pray you, haste in this.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Come, Gertrude, we'll call up our wisest friends;
+    And let them know, both what we mean to do,
+    And what's untimely done. O, come away!
+    My soul is full of discord and dismay.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene2.txt
new file mode 100644
index 0000000..6903d9e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene2.txt
@@ -0,0 +1,88 @@
+SCENE II. Another room in the castle.
+
+    Enter HAMLET 
+
+HAMLET
+
+    Safely stowed.
+
+ROSENCRANTZ: GUILDENSTERN:
+
+    [Within] Hamlet! Lord Hamlet!
+
+HAMLET
+
+    What noise? who calls on Hamlet?
+    O, here they come.
+
+    Enter ROSENCRANTZ and GUILDENSTERN
+
+ROSENCRANTZ
+
+    What have you done, my lord, with the dead body?
+
+HAMLET
+
+    Compounded it with dust, whereto 'tis kin.
+
+ROSENCRANTZ
+
+    Tell us where 'tis, that we may take it thence
+    And bear it to the chapel.
+
+HAMLET
+
+    Do not believe it.
+
+ROSENCRANTZ
+
+    Believe what?
+
+HAMLET
+
+    That I can keep your counsel and not mine own.
+    Besides, to be demanded of a sponge! what
+    replication should be made by the son of a king?
+
+ROSENCRANTZ
+
+    Take you me for a sponge, my lord?
+
+HAMLET
+
+    Ay, sir, that soaks up the king's countenance, his
+    rewards, his authorities. But such officers do the
+    king best service in the end: he keeps them, like
+    an ape, in the corner of his jaw; first mouthed, to
+    be last swallowed: when he needs what you have
+    gleaned, it is but squeezing you, and, sponge, you
+    shall be dry again.
+
+ROSENCRANTZ
+
+    I understand you not, my lord.
+
+HAMLET
+
+    I am glad of it: a knavish speech sleeps in a
+    foolish ear.
+
+ROSENCRANTZ
+
+    My lord, you must tell us where the body is, and go
+    with us to the king.
+
+HAMLET
+
+    The body is with the king, but the king is not with
+    the body. The king is a thing--
+
+GUILDENSTERN
+
+    A thing, my lord!
+
+HAMLET
+
+    Of nothing: bring me to him. Hide fox, and all after.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene3.txt
new file mode 100644
index 0000000..b364f04
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene3.txt
@@ -0,0 +1,171 @@
+SCENE III. Another room in the castle.
+
+    Enter KING CLAUDIUS, attended 
+
+KING CLAUDIUS
+
+    I have sent to seek him, and to find the body.
+    How dangerous is it that this man goes loose!
+    Yet must not we put the strong law on him:
+    He's loved of the distracted multitude,
+    Who like not in their judgment, but their eyes;
+    And where tis so, the offender's scourge is weigh'd,
+    But never the offence. To bear all smooth and even,
+    This sudden sending him away must seem
+    Deliberate pause: diseases desperate grown
+    By desperate appliance are relieved,
+    Or not at all.
+
+    Enter ROSENCRANTZ
+    How now! what hath befall'n?
+
+ROSENCRANTZ
+
+    Where the dead body is bestow'd, my lord,
+    We cannot get from him.
+
+KING CLAUDIUS
+
+    But where is he?
+
+ROSENCRANTZ
+
+    Without, my lord; guarded, to know your pleasure.
+
+KING CLAUDIUS
+
+    Bring him before us.
+
+ROSENCRANTZ
+
+    Ho, Guildenstern! bring in my lord.
+
+    Enter HAMLET and GUILDENSTERN
+
+KING CLAUDIUS
+
+    Now, Hamlet, where's Polonius?
+
+HAMLET
+
+    At supper.
+
+KING CLAUDIUS
+
+    At supper! where?
+
+HAMLET
+
+    Not where he eats, but where he is eaten: a certain
+    convocation of politic worms are e'en at him. Your
+    worm is your only emperor for diet: we fat all
+    creatures else to fat us, and we fat ourselves for
+    maggots: your fat king and your lean beggar is but
+    variable service, two dishes, but to one table:
+    that's the end.
+
+KING CLAUDIUS
+
+    Alas, alas!
+
+HAMLET
+
+    A man may fish with the worm that hath eat of a
+    king, and eat of the fish that hath fed of that worm.
+
+KING CLAUDIUS
+
+    What dost you mean by this?
+
+HAMLET
+
+    Nothing but to show you how a king may go a
+    progress through the guts of a beggar.
+
+KING CLAUDIUS
+
+    Where is Polonius?
+
+HAMLET
+
+    In heaven; send hither to see: if your messenger
+    find him not there, seek him i' the other place
+    yourself. But indeed, if you find him not within
+    this month, you shall nose him as you go up the
+    stairs into the lobby.
+
+KING CLAUDIUS
+
+    Go seek him there.
+
+    To some Attendants
+
+HAMLET
+
+    He will stay till ye come.
+
+    Exeunt Attendants
+
+KING CLAUDIUS
+
+    Hamlet, this deed, for thine especial safety,--
+    Which we do tender, as we dearly grieve
+    For that which thou hast done,--must send thee hence
+    With fiery quickness: therefore prepare thyself;
+    The bark is ready, and the wind at help,
+    The associates tend, and every thing is bent
+    For England.
+
+HAMLET
+
+    For England!
+
+KING CLAUDIUS
+
+    Ay, Hamlet.
+
+HAMLET
+
+    Good.
+
+KING CLAUDIUS
+
+    So is it, if thou knew'st our purposes.
+
+HAMLET
+
+    I see a cherub that sees them. But, come; for
+    England! Farewell, dear mother.
+
+KING CLAUDIUS
+
+    Thy loving father, Hamlet.
+
+HAMLET
+
+    My mother: father and mother is man and wife; man
+    and wife is one flesh; and so, my mother. Come, for England!
+
+    Exit
+
+KING CLAUDIUS
+
+    Follow him at foot; tempt him with speed aboard;
+    Delay it not; I'll have him hence to-night:
+    Away! for every thing is seal'd and done
+    That else leans on the affair: pray you, make haste.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    And, England, if my love thou hold'st at aught--
+    As my great power thereof may give thee sense,
+    Since yet thy cicatrice looks raw and red
+    After the Danish sword, and thy free awe
+    Pays homage to us--thou mayst not coldly set
+    Our sovereign process; which imports at full,
+    By letters congruing to that effect,
+    The present death of Hamlet. Do it, England;
+    For like the hectic in my blood he rages,
+    And thou must cure me: till I know 'tis done,
+    Howe'er my haps, my joys were ne'er begun.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene4.txt
new file mode 100644
index 0000000..308192a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene4.txt
@@ -0,0 +1,132 @@
+SCENE IV. A plain in Denmark.
+
+    Enter FORTINBRAS, a Captain, and Soldiers, marching 
+
+PRINCE FORTINBRAS
+
+    Go, captain, from me greet the Danish king;
+    Tell him that, by his licence, Fortinbras
+    Craves the conveyance of a promised march
+    Over his kingdom. You know the rendezvous.
+    If that his majesty would aught with us,
+    We shall express our duty in his eye;
+    And let him know so.
+
+Captain
+
+    I will do't, my lord.
+
+PRINCE FORTINBRAS
+
+    Go softly on.
+
+    Exeunt FORTINBRAS and Soldiers
+
+    Enter HAMLET, ROSENCRANTZ, GUILDENSTERN, and others
+
+HAMLET
+
+    Good sir, whose powers are these?
+
+Captain
+
+    They are of Norway, sir.
+
+HAMLET
+
+    How purposed, sir, I pray you?
+
+Captain
+
+    Against some part of Poland.
+
+HAMLET
+
+    Who commands them, sir?
+
+Captain
+
+    The nephews to old Norway, Fortinbras.
+
+HAMLET
+
+    Goes it against the main of Poland, sir,
+    Or for some frontier?
+
+Captain
+
+    Truly to speak, and with no addition,
+    We go to gain a little patch of ground
+    That hath in it no profit but the name.
+    To pay five ducats, five, I would not farm it;
+    Nor will it yield to Norway or the Pole
+    A ranker rate, should it be sold in fee.
+
+HAMLET
+
+    Why, then the Polack never will defend it.
+
+Captain
+
+    Yes, it is already garrison'd.
+
+HAMLET
+
+    Two thousand souls and twenty thousand ducats
+    Will not debate the question of this straw:
+    This is the imposthume of much wealth and peace,
+    That inward breaks, and shows no cause without
+    Why the man dies. I humbly thank you, sir.
+
+Captain
+
+    God be wi' you, sir.
+
+    Exit
+
+ROSENCRANTZ
+
+    Wilt please you go, my lord?
+
+HAMLET
+
+    I'll be with you straight go a little before.
+
+    Exeunt all except HAMLET
+    How all occasions do inform against me,
+    And spur my dull revenge! What is a man,
+    If his chief good and market of his time
+    Be but to sleep and feed? a beast, no more.
+    Sure, he that made us with such large discourse,
+    Looking before and after, gave us not
+    That capability and god-like reason
+    To fust in us unused. Now, whether it be
+    Bestial oblivion, or some craven scruple
+    Of thinking too precisely on the event,
+    A thought which, quarter'd, hath but one part wisdom
+    And ever three parts coward, I do not know
+    Why yet I live to say 'This thing's to do;'
+    Sith I have cause and will and strength and means
+    To do't. Examples gross as earth exhort me:
+    Witness this army of such mass and charge
+    Led by a delicate and tender prince,
+    Whose spirit with divine ambition puff'd
+    Makes mouths at the invisible event,
+    Exposing what is mortal and unsure
+    To all that fortune, death and danger dare,
+    Even for an egg-shell. Rightly to be great
+    Is not to stir without great argument,
+    But greatly to find quarrel in a straw
+    When honour's at the stake. How stand I then,
+    That have a father kill'd, a mother stain'd,
+    Excitements of my reason and my blood,
+    And let all sleep? while, to my shame, I see
+    The imminent death of twenty thousand men,
+    That, for a fantasy and trick of fame,
+    Go to their graves like beds, fight for a plot
+    Whereon the numbers cannot try the cause,
+    Which is not tomb enough and continent
+    To hide the slain? O, from this time forth,
+    My thoughts be bloody, or be nothing worth!
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene5.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene5.txt
new file mode 100644
index 0000000..716fae6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene5.txt
@@ -0,0 +1,466 @@
+SCENE V. Elsinore. A room in the castle.
+
+    Enter QUEEN GERTRUDE, HORATIO, and a Gentleman 
+
+QUEEN GERTRUDE
+
+    I will not speak with her.
+
+Gentleman
+
+    She is importunate, indeed distract:
+    Her mood will needs be pitied.
+
+QUEEN GERTRUDE
+
+    What would she have?
+
+Gentleman
+
+    She speaks much of her father; says she hears
+    There's tricks i' the world; and hems, and beats her heart;
+    Spurns enviously at straws; speaks things in doubt,
+    That carry but half sense: her speech is nothing,
+    Yet the unshaped use of it doth move
+    The hearers to collection; they aim at it,
+    And botch the words up fit to their own thoughts;
+    Which, as her winks, and nods, and gestures
+    yield them,
+    Indeed would make one think there might be thought,
+    Though nothing sure, yet much unhappily.
+
+HORATIO
+
+    'Twere good she were spoken with; for she may strew
+    Dangerous conjectures in ill-breeding minds.
+
+QUEEN GERTRUDE
+
+    Let her come in.
+
+    Exit HORATIO
+    To my sick soul, as sin's true nature is,
+    Each toy seems prologue to some great amiss:
+    So full of artless jealousy is guilt,
+    It spills itself in fearing to be spilt.
+
+    Re-enter HORATIO, with OPHELIA
+
+OPHELIA
+
+    Where is the beauteous majesty of Denmark?
+
+QUEEN GERTRUDE
+
+    How now, Ophelia!
+
+OPHELIA
+
+    [Sings]
+    How should I your true love know
+    From another one?
+    By his cockle hat and staff,
+    And his sandal shoon.
+
+QUEEN GERTRUDE
+
+    Alas, sweet lady, what imports this song?
+
+OPHELIA
+
+    Say you? nay, pray you, mark.
+
+    Sings
+    He is dead and gone, lady,
+    He is dead and gone;
+    At his head a grass-green turf,
+    At his heels a stone.
+
+QUEEN GERTRUDE
+
+    Nay, but, Ophelia,--
+
+OPHELIA
+
+    Pray you, mark.
+
+    Sings
+    White his shroud as the mountain snow,--
+
+    Enter KING CLAUDIUS
+
+QUEEN GERTRUDE
+
+    Alas, look here, my lord.
+
+OPHELIA
+
+    [Sings]
+    Larded with sweet flowers
+    Which bewept to the grave did go
+    With true-love showers.
+
+KING CLAUDIUS
+
+    How do you, pretty lady?
+
+OPHELIA
+
+    Well, God 'ild you! They say the owl was a baker's
+    daughter. Lord, we know what we are, but know not
+    what we may be. God be at your table!
+
+KING CLAUDIUS
+
+    Conceit upon her father.
+
+OPHELIA
+
+    Pray you, let's have no words of this; but when they
+    ask you what it means, say you this:
+
+    Sings
+    To-morrow is Saint Valentine's day,
+    All in the morning betime,
+    And I a maid at your window,
+    To be your Valentine.
+    Then up he rose, and donn'd his clothes,
+    And dupp'd the chamber-door;
+    Let in the maid, that out a maid
+    Never departed more.
+
+KING CLAUDIUS
+
+    Pretty Ophelia!
+
+OPHELIA
+
+    Indeed, la, without an oath, I'll make an end on't:
+
+    Sings
+    By Gis and by Saint Charity,
+    Alack, and fie for shame!
+    Young men will do't, if they come to't;
+    By cock, they are to blame.
+    Quoth she, before you tumbled me,
+    You promised me to wed.
+    So would I ha' done, by yonder sun,
+    An thou hadst not come to my bed.
+
+KING CLAUDIUS
+
+    How long hath she been thus?
+
+OPHELIA
+
+    I hope all will be well. We must be patient: but I
+    cannot choose but weep, to think they should lay him
+    i' the cold ground. My brother shall know of it:
+    and so I thank you for your good counsel. Come, my
+    coach! Good night, ladies; good night, sweet ladies;
+    good night, good night.
+
+    Exit
+
+KING CLAUDIUS
+
+    Follow her close; give her good watch,
+    I pray you.
+
+    Exit HORATIO
+    O, this is the poison of deep grief; it springs
+    All from her father's death. O Gertrude, Gertrude,
+    When sorrows come, they come not single spies
+    But in battalions. First, her father slain:
+    Next, your son gone; and he most violent author
+    Of his own just remove: the people muddied,
+    Thick and unwholesome in their thoughts and whispers,
+    For good Polonius' death; and we have done but greenly,
+    In hugger-mugger to inter him: poor Ophelia
+    Divided from herself and her fair judgment,
+    Without the which we are pictures, or mere beasts:
+    Last, and as much containing as all these,
+    Her brother is in secret come from France;
+    Feeds on his wonder, keeps himself in clouds,
+    And wants not buzzers to infect his ear
+    With pestilent speeches of his father's death;
+    Wherein necessity, of matter beggar'd,
+    Will nothing stick our person to arraign
+    In ear and ear. O my dear Gertrude, this,
+    Like to a murdering-piece, in many places
+    Gives me superfluous death.
+
+    A noise within
+
+QUEEN GERTRUDE
+
+    Alack, what noise is this?
+
+KING CLAUDIUS
+
+    Where are my Switzers? Let them guard the door.
+
+    Enter another Gentleman
+    What is the matter?
+
+Gentleman
+
+    Save yourself, my lord:
+    The ocean, overpeering of his list,
+    Eats not the flats with more impetuous haste
+    Than young Laertes, in a riotous head,
+    O'erbears your officers. The rabble call him lord;
+    And, as the world were now but to begin,
+    Antiquity forgot, custom not known,
+    The ratifiers and props of every word,
+    They cry 'Choose we: Laertes shall be king:'
+    Caps, hands, and tongues, applaud it to the clouds:
+    'Laertes shall be king, Laertes king!'
+
+QUEEN GERTRUDE
+
+    How cheerfully on the false trail they cry!
+    O, this is counter, you false Danish dogs!
+
+KING CLAUDIUS
+
+    The doors are broke.
+
+    Noise within
+
+    Enter LAERTES, armed; Danes following
+
+LAERTES
+
+    Where is this king? Sirs, stand you all without.
+
+Danes
+
+    No, let's come in.
+
+LAERTES
+
+    I pray you, give me leave.
+
+Danes
+
+    We will, we will.
+
+    They retire without the door
+
+LAERTES
+
+    I thank you: keep the door. O thou vile king,
+    Give me my father!
+
+QUEEN GERTRUDE
+
+    Calmly, good Laertes.
+
+LAERTES
+
+    That drop of blood that's calm proclaims me bastard,
+    Cries cuckold to my father, brands the harlot
+    Even here, between the chaste unsmirched brow
+    Of my true mother.
+
+KING CLAUDIUS
+
+    What is the cause, Laertes,
+    That thy rebellion looks so giant-like?
+    Let him go, Gertrude; do not fear our person:
+    There's such divinity doth hedge a king,
+    That treason can but peep to what it would,
+    Acts little of his will. Tell me, Laertes,
+    Why thou art thus incensed. Let him go, Gertrude.
+    Speak, man.
+
+LAERTES
+
+    Where is my father?
+
+KING CLAUDIUS
+
+    Dead.
+
+QUEEN GERTRUDE
+
+    But not by him.
+
+KING CLAUDIUS
+
+    Let him demand his fill.
+
+LAERTES
+
+    How came he dead? I'll not be juggled with:
+    To hell, allegiance! vows, to the blackest devil!
+    Conscience and grace, to the profoundest pit!
+    I dare damnation. To this point I stand,
+    That both the worlds I give to negligence,
+    Let come what comes; only I'll be revenged
+    Most thoroughly for my father.
+
+KING CLAUDIUS
+
+    Who shall stay you?
+
+LAERTES
+
+    My will, not all the world:
+    And for my means, I'll husband them so well,
+    They shall go far with little.
+
+KING CLAUDIUS
+
+    Good Laertes,
+    If you desire to know the certainty
+    Of your dear father's death, is't writ in your revenge,
+    That, swoopstake, you will draw both friend and foe,
+    Winner and loser?
+
+LAERTES
+
+    None but his enemies.
+
+KING CLAUDIUS
+
+    Will you know them then?
+
+LAERTES
+
+    To his good friends thus wide I'll ope my arms;
+    And like the kind life-rendering pelican,
+    Repast them with my blood.
+
+KING CLAUDIUS
+
+    Why, now you speak
+    Like a good child and a true gentleman.
+    That I am guiltless of your father's death,
+    And am most sensible in grief for it,
+    It shall as level to your judgment pierce
+    As day does to your eye.
+
+Danes
+
+    [Within] Let her come in.
+
+LAERTES
+
+    How now! what noise is that?
+
+    Re-enter OPHELIA
+    O heat, dry up my brains! tears seven times salt,
+    Burn out the sense and virtue of mine eye!
+    By heaven, thy madness shall be paid by weight,
+    Till our scale turn the beam. O rose of May!
+    Dear maid, kind sister, sweet Ophelia!
+    O heavens! is't possible, a young maid's wits
+    Should be as moral as an old man's life?
+    Nature is fine in love, and where 'tis fine,
+    It sends some precious instance of itself
+    After the thing it loves.
+
+OPHELIA
+
+    [Sings]
+    They bore him barefaced on the bier;
+    Hey non nonny, nonny, hey nonny;
+    And in his grave rain'd many a tear:--
+    Fare you well, my dove!
+
+LAERTES
+
+    Hadst thou thy wits, and didst persuade revenge,
+    It could not move thus.
+
+OPHELIA
+
+    [Sings]
+    You must sing a-down a-down,
+    An you call him a-down-a.
+    O, how the wheel becomes it! It is the false
+    steward, that stole his master's daughter.
+
+LAERTES
+
+    This nothing's more than matter.
+
+OPHELIA
+
+    There's rosemary, that's for remembrance; pray,
+    love, remember: and there is pansies. that's for thoughts.
+
+LAERTES
+
+    A document in madness, thoughts and remembrance fitted.
+
+OPHELIA
+
+    There's fennel for you, and columbines: there's rue
+    for you; and here's some for me: we may call it
+    herb-grace o' Sundays: O you must wear your rue with
+    a difference. There's a daisy: I would give you
+    some violets, but they withered all when my father
+    died: they say he made a good end,--
+
+    Sings
+    For bonny sweet Robin is all my joy.
+
+LAERTES
+
+    Thought and affliction, passion, hell itself,
+    She turns to favour and to prettiness.
+
+OPHELIA
+
+    [Sings]
+    And will he not come again?
+    And will he not come again?
+    No, no, he is dead:
+    Go to thy death-bed:
+    He never will come again.
+    His beard was as white as snow,
+    All flaxen was his poll:
+    He is gone, he is gone,
+    And we cast away moan:
+    God ha' mercy on his soul!
+    And of all Christian souls, I pray God. God be wi' ye.
+
+    Exit
+
+LAERTES
+
+    Do you see this, O God?
+
+KING CLAUDIUS
+
+    Laertes, I must commune with your grief,
+    Or you deny me right. Go but apart,
+    Make choice of whom your wisest friends you will.
+    And they shall hear and judge 'twixt you and me:
+    If by direct or by collateral hand
+    They find us touch'd, we will our kingdom give,
+    Our crown, our life, and all that we can ours,
+    To you in satisfaction; but if not,
+    Be you content to lend your patience to us,
+    And we shall jointly labour with your soul
+    To give it due content.
+
+LAERTES
+
+    Let this be so;
+    His means of death, his obscure funeral--
+    No trophy, sword, nor hatchment o'er his bones,
+    No noble rite nor formal ostentation--
+    Cry to be heard, as 'twere from heaven to earth,
+    That I must call't in question.
+
+KING CLAUDIUS
+
+    So you shall;
+    And where the offence is let the great axe fall.
+    I pray you, go with me.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene6.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene6.txt
new file mode 100644
index 0000000..f0fa4b7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene6.txt
@@ -0,0 +1,63 @@
+SCENE VI. Another room in the castle.
+
+    Enter HORATIO and a Servant 
+
+HORATIO
+
+    What are they that would speak with me?
+
+Servant
+
+    Sailors, sir: they say they have letters for you.
+
+HORATIO
+
+    Let them come in.
+
+    Exit Servant
+    I do not know from what part of the world
+    I should be greeted, if not from Lord Hamlet.
+
+    Enter Sailors
+
+First Sailor
+
+    God bless you, sir.
+
+HORATIO
+
+    Let him bless thee too.
+
+First Sailor
+
+    He shall, sir, an't please him. There's a letter for
+    you, sir; it comes from the ambassador that was
+    bound for England; if your name be Horatio, as I am
+    let to know it is.
+
+HORATIO
+
+    [Reads] 'Horatio, when thou shalt have overlooked
+    this, give these fellows some means to the king:
+    they have letters for him. Ere we were two days old
+    at sea, a pirate of very warlike appointment gave us
+    chase. Finding ourselves too slow of sail, we put on
+    a compelled valour, and in the grapple I boarded
+    them: on the instant they got clear of our ship; so
+    I alone became their prisoner. They have dealt with
+    me like thieves of mercy: but they knew what they
+    did; I am to do a good turn for them. Let the king
+    have the letters I have sent; and repair thou to me
+    with as much speed as thou wouldst fly death. I
+    have words to speak in thine ear will make thee
+    dumb; yet are they much too light for the bore of
+    the matter. These good fellows will bring thee
+    where I am. Rosencrantz and Guildenstern hold their
+    course for England: of them I have much to tell
+    thee. Farewell.
+    'He that thou knowest thine, HAMLET.'
+    Come, I will make you way for these your letters;
+    And do't the speedier, that you may direct me
+    To him from whom you brought them.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene7.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene7.txt
new file mode 100644
index 0000000..d24c07c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act4/scene7.txt
@@ -0,0 +1,346 @@
+SCENE VII. Another room in the castle.
+
+    Enter KING CLAUDIUS and LAERTES 
+
+KING CLAUDIUS
+
+    Now must your conscience my acquaintance seal,
+    And you must put me in your heart for friend,
+    Sith you have heard, and with a knowing ear,
+    That he which hath your noble father slain
+    Pursued my life.
+
+LAERTES
+
+    It well appears: but tell me
+    Why you proceeded not against these feats,
+    So crimeful and so capital in nature,
+    As by your safety, wisdom, all things else,
+    You mainly were stirr'd up.
+
+KING CLAUDIUS
+
+    O, for two special reasons;
+    Which may to you, perhaps, seem much unsinew'd,
+    But yet to me they are strong. The queen his mother
+    Lives almost by his looks; and for myself--
+    My virtue or my plague, be it either which--
+    She's so conjunctive to my life and soul,
+    That, as the star moves not but in his sphere,
+    I could not but by her. The other motive,
+    Why to a public count I might not go,
+    Is the great love the general gender bear him;
+    Who, dipping all his faults in their affection,
+    Would, like the spring that turneth wood to stone,
+    Convert his gyves to graces; so that my arrows,
+    Too slightly timber'd for so loud a wind,
+    Would have reverted to my bow again,
+    And not where I had aim'd them.
+
+LAERTES
+
+    And so have I a noble father lost;
+    A sister driven into desperate terms,
+    Whose worth, if praises may go back again,
+    Stood challenger on mount of all the age
+    For her perfections: but my revenge will come.
+
+KING CLAUDIUS
+
+    Break not your sleeps for that: you must not think
+    That we are made of stuff so flat and dull
+    That we can let our beard be shook with danger
+    And think it pastime. You shortly shall hear more:
+    I loved your father, and we love ourself;
+    And that, I hope, will teach you to imagine--
+
+    Enter a Messenger
+    How now! what news?
+
+Messenger
+
+    Letters, my lord, from Hamlet:
+    This to your majesty; this to the queen.
+
+KING CLAUDIUS
+
+    From Hamlet! who brought them?
+
+Messenger
+
+    Sailors, my lord, they say; I saw them not:
+    They were given me by Claudio; he received them
+    Of him that brought them.
+
+KING CLAUDIUS
+
+    Laertes, you shall hear them. Leave us.
+
+    Exit Messenger
+
+    Reads
+    'High and mighty, You shall know I am set naked on
+    your kingdom. To-morrow shall I beg leave to see
+    your kingly eyes: when I shall, first asking your
+    pardon thereunto, recount the occasion of my sudden
+    and more strange return. 'HAMLET.'
+    What should this mean? Are all the rest come back?
+    Or is it some abuse, and no such thing?
+
+LAERTES
+
+    Know you the hand?
+
+KING CLAUDIUS
+
+    'Tis Hamlets character. 'Naked!
+    And in a postscript here, he says 'alone.'
+    Can you advise me?
+
+LAERTES
+
+    I'm lost in it, my lord. But let him come;
+    It warms the very sickness in my heart,
+    That I shall live and tell him to his teeth,
+    'Thus didest thou.'
+
+KING CLAUDIUS
+
+    If it be so, Laertes--
+    As how should it be so? how otherwise?--
+    Will you be ruled by me?
+
+LAERTES
+
+    Ay, my lord;
+    So you will not o'errule me to a peace.
+
+KING CLAUDIUS
+
+    To thine own peace. If he be now return'd,
+    As checking at his voyage, and that he means
+    No more to undertake it, I will work him
+    To an exploit, now ripe in my device,
+    Under the which he shall not choose but fall:
+    And for his death no wind of blame shall breathe,
+    But even his mother shall uncharge the practise
+    And call it accident.
+
+LAERTES
+
+    My lord, I will be ruled;
+    The rather, if you could devise it so
+    That I might be the organ.
+
+KING CLAUDIUS
+
+    It falls right.
+    You have been talk'd of since your travel much,
+    And that in Hamlet's hearing, for a quality
+    Wherein, they say, you shine: your sum of parts
+    Did not together pluck such envy from him
+    As did that one, and that, in my regard,
+    Of the unworthiest siege.
+
+LAERTES
+
+    What part is that, my lord?
+
+KING CLAUDIUS
+
+    A very riband in the cap of youth,
+    Yet needful too; for youth no less becomes
+    The light and careless livery that it wears
+    Than settled age his sables and his weeds,
+    Importing health and graveness. Two months since,
+    Here was a gentleman of Normandy:--
+    I've seen myself, and served against, the French,
+    And they can well on horseback: but this gallant
+    Had witchcraft in't; he grew unto his seat;
+    And to such wondrous doing brought his horse,
+    As he had been incorpsed and demi-natured
+    With the brave beast: so far he topp'd my thought,
+    That I, in forgery of shapes and tricks,
+    Come short of what he did.
+
+LAERTES
+
+    A Norman was't?
+
+KING CLAUDIUS
+
+    A Norman.
+
+LAERTES
+
+    Upon my life, Lamond.
+
+KING CLAUDIUS
+
+    The very same.
+
+LAERTES
+
+    I know him well: he is the brooch indeed
+    And gem of all the nation.
+
+KING CLAUDIUS
+
+    He made confession of you,
+    And gave you such a masterly report
+    For art and exercise in your defence
+    And for your rapier most especially,
+    That he cried out, 'twould be a sight indeed,
+    If one could match you: the scrimers of their nation,
+    He swore, had had neither motion, guard, nor eye,
+    If you opposed them. Sir, this report of his
+    Did Hamlet so envenom with his envy
+    That he could nothing do but wish and beg
+    Your sudden coming o'er, to play with him.
+    Now, out of this,--
+
+LAERTES
+
+    What out of this, my lord?
+
+KING CLAUDIUS
+
+    Laertes, was your father dear to you?
+    Or are you like the painting of a sorrow,
+    A face without a heart?
+
+LAERTES
+
+    Why ask you this?
+
+KING CLAUDIUS
+
+    Not that I think you did not love your father;
+    But that I know love is begun by time;
+    And that I see, in passages of proof,
+    Time qualifies the spark and fire of it.
+    There lives within the very flame of love
+    A kind of wick or snuff that will abate it;
+    And nothing is at a like goodness still;
+    For goodness, growing to a plurisy,
+    Dies in his own too much: that we would do
+    We should do when we would; for this 'would' changes
+    And hath abatements and delays as many
+    As there are tongues, are hands, are accidents;
+    And then this 'should' is like a spendthrift sigh,
+    That hurts by easing. But, to the quick o' the ulcer:--
+    Hamlet comes back: what would you undertake,
+    To show yourself your father's son in deed
+    More than in words?
+
+LAERTES
+
+    To cut his throat i' the church.
+
+KING CLAUDIUS
+
+    No place, indeed, should murder sanctuarize;
+    Revenge should have no bounds. But, good Laertes,
+    Will you do this, keep close within your chamber.
+    Hamlet return'd shall know you are come home:
+    We'll put on those shall praise your excellence
+    And set a double varnish on the fame
+    The Frenchman gave you, bring you in fine together
+    And wager on your heads: he, being remiss,
+    Most generous and free from all contriving,
+    Will not peruse the foils; so that, with ease,
+    Or with a little shuffling, you may choose
+    A sword unbated, and in a pass of practise
+    Requite him for your father.
+
+LAERTES
+
+    I will do't:
+    And, for that purpose, I'll anoint my sword.
+    I bought an unction of a mountebank,
+    So mortal that, but dip a knife in it,
+    Where it draws blood no cataplasm so rare,
+    Collected from all simples that have virtue
+    Under the moon, can save the thing from death
+    That is but scratch'd withal: I'll touch my point
+    With this contagion, that, if I gall him slightly,
+    It may be death.
+
+KING CLAUDIUS
+
+    Let's further think of this;
+    Weigh what convenience both of time and means
+    May fit us to our shape: if this should fail,
+    And that our drift look through our bad performance,
+    'Twere better not assay'd: therefore this project
+    Should have a back or second, that might hold,
+    If this should blast in proof. Soft! let me see:
+    We'll make a solemn wager on your cunnings: I ha't.
+    When in your motion you are hot and dry--
+    As make your bouts more violent to that end--
+    And that he calls for drink, I'll have prepared him
+    A chalice for the nonce, whereon but sipping,
+    If he by chance escape your venom'd stuck,
+    Our purpose may hold there.
+
+    Enter QUEEN GERTRUDE
+    How now, sweet queen!
+
+QUEEN GERTRUDE
+
+    One woe doth tread upon another's heel,
+    So fast they follow; your sister's drown'd, Laertes.
+
+LAERTES
+
+    Drown'd! O, where?
+
+QUEEN GERTRUDE
+
+    There is a willow grows aslant a brook,
+    That shows his hoar leaves in the glassy stream;
+    There with fantastic garlands did she come
+    Of crow-flowers, nettles, daisies, and long purples
+    That liberal shepherds give a grosser name,
+    But our cold maids do dead men's fingers call them:
+    There, on the pendent boughs her coronet weeds
+    Clambering to hang, an envious sliver broke;
+    When down her weedy trophies and herself
+    Fell in the weeping brook. Her clothes spread wide;
+    And, mermaid-like, awhile they bore her up:
+    Which time she chanted snatches of old tunes;
+    As one incapable of her own distress,
+    Or like a creature native and indued
+    Unto that element: but long it could not be
+    Till that her garments, heavy with their drink,
+    Pull'd the poor wretch from her melodious lay
+    To muddy death.
+
+LAERTES
+
+    Alas, then, she is drown'd?
+
+QUEEN GERTRUDE
+
+    Drown'd, drown'd.
+
+LAERTES
+
+    Too much of water hast thou, poor Ophelia,
+    And therefore I forbid my tears: but yet
+    It is our trick; nature her custom holds,
+    Let shame say what it will: when these are gone,
+    The woman will be out. Adieu, my lord:
+    I have a speech of fire, that fain would blaze,
+    But that this folly douts it.
+
+    Exit
+
+KING CLAUDIUS
+
+    Let's follow, Gertrude:
+    How much I had to do to calm his rage!
+    Now fear I this will give it start again;
+    Therefore let's follow.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene1.txt
new file mode 100644
index 0000000..6c936bd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene1.txt
@@ -0,0 +1,679 @@
+ACT V
+SCENE I. A churchyard.
+
+    Enter two Clowns, with spades, & c 
+
+First Clown
+
+    Is she to be buried in Christian burial that
+    wilfully seeks her own salvation?
+
+Second Clown
+
+    I tell thee she is: and therefore make her grave
+    straight: the crowner hath sat on her, and finds it
+    Christian burial.
+
+First Clown
+
+    How can that be, unless she drowned herself in her
+    own defence?
+
+Second Clown
+
+    Why, 'tis found so.
+
+First Clown
+
+    It must be 'se offendendo;' it cannot be else. For
+    here lies the point: if I drown myself wittingly,
+    it argues an act: and an act hath three branches: it
+    is, to act, to do, to perform: argal, she drowned
+    herself wittingly.
+
+Second Clown
+
+    Nay, but hear you, goodman delver,--
+
+First Clown
+
+    Give me leave. Here lies the water; good: here
+    stands the man; good; if the man go to this water,
+    and drown himself, it is, will he, nill he, he
+    goes,--mark you that; but if the water come to him
+    and drown him, he drowns not himself: argal, he
+    that is not guilty of his own death shortens not his own life.
+
+Second Clown
+
+    But is this law?
+
+First Clown
+
+    Ay, marry, is't; crowner's quest law.
+
+Second Clown
+
+    Will you ha' the truth on't? If this had not been
+    a gentlewoman, she should have been buried out o'
+    Christian burial.
+
+First Clown
+
+    Why, there thou say'st: and the more pity that
+    great folk should have countenance in this world to
+    drown or hang themselves, more than their even
+    Christian. Come, my spade. There is no ancient
+    gentleman but gardeners, ditchers, and grave-makers:
+    they hold up Adam's profession.
+
+Second Clown
+
+    Was he a gentleman?
+
+First Clown
+
+    He was the first that ever bore arms.
+
+Second Clown
+
+    Why, he had none.
+
+First Clown
+
+    What, art a heathen? How dost thou understand the
+    Scripture? The Scripture says 'Adam digged:'
+    could he dig without arms? I'll put another
+    question to thee: if thou answerest me not to the
+    purpose, confess thyself--
+
+Second Clown
+
+    Go to.
+
+First Clown
+
+    What is he that builds stronger than either the
+    mason, the shipwright, or the carpenter?
+
+Second Clown
+
+    The gallows-maker; for that frame outlives a
+    thousand tenants.
+
+First Clown
+
+    I like thy wit well, in good faith: the gallows
+    does well; but how does it well? it does well to
+    those that do in: now thou dost ill to say the
+    gallows is built stronger than the church: argal,
+    the gallows may do well to thee. To't again, come.
+
+Second Clown
+
+    'Who builds stronger than a mason, a shipwright, or
+    a carpenter?'
+
+First Clown
+
+    Ay, tell me that, and unyoke.
+
+Second Clown
+
+    Marry, now I can tell.
+
+First Clown
+
+    To't.
+
+Second Clown
+
+    Mass, I cannot tell.
+
+    Enter HAMLET and HORATIO, at a distance
+
+First Clown
+
+    Cudgel thy brains no more about it, for your dull
+    ass will not mend his pace with beating; and, when
+    you are asked this question next, say 'a
+    grave-maker: 'the houses that he makes last till
+    doomsday. Go, get thee to Yaughan: fetch me a
+    stoup of liquor.
+
+    Exit Second Clown
+
+    He digs and sings
+    In youth, when I did love, did love,
+    Methought it was very sweet,
+    To contract, O, the time, for, ah, my behove,
+    O, methought, there was nothing meet.
+
+HAMLET
+
+    Has this fellow no feeling of his business, that he
+    sings at grave-making?
+
+HORATIO
+
+    Custom hath made it in him a property of easiness.
+
+HAMLET
+
+    'Tis e'en so: the hand of little employment hath
+    the daintier sense.
+
+First Clown
+
+    [Sings]
+    But age, with his stealing steps,
+    Hath claw'd me in his clutch,
+    And hath shipped me intil the land,
+    As if I had never been such.
+
+    Throws up a skull
+
+HAMLET
+
+    That skull had a tongue in it, and could sing once:
+    how the knave jowls it to the ground, as if it were
+    Cain's jaw-bone, that did the first murder! It
+    might be the pate of a politician, which this ass
+    now o'er-reaches; one that would circumvent God,
+    might it not?
+
+HORATIO
+
+    It might, my lord.
+
+HAMLET
+
+    Or of a courtier; which could say 'Good morrow,
+    sweet lord! How dost thou, good lord?' This might
+    be my lord such-a-one, that praised my lord
+    such-a-one's horse, when he meant to beg it; might it not?
+
+HORATIO
+
+    Ay, my lord.
+
+HAMLET
+
+    Why, e'en so: and now my Lady Worm's; chapless, and
+    knocked about the mazzard with a sexton's spade:
+    here's fine revolution, an we had the trick to
+    see't. Did these bones cost no more the breeding,
+    but to play at loggats with 'em? mine ache to think on't.
+
+First Clown
+
+    [Sings]
+    A pick-axe, and a spade, a spade,
+    For and a shrouding sheet:
+    O, a pit of clay for to be made
+    For such a guest is meet.
+
+    Throws up another skull
+
+HAMLET
+
+    There's another: why may not that be the skull of a
+    lawyer? Where be his quiddities now, his quillets,
+    his cases, his tenures, and his tricks? why does he
+    suffer this rude knave now to knock him about the
+    sconce with a dirty shovel, and will not tell him of
+    his action of battery? Hum! This fellow might be
+    in's time a great buyer of land, with his statutes,
+    his recognizances, his fines, his double vouchers,
+    his recoveries: is this the fine of his fines, and
+    the recovery of his recoveries, to have his fine
+    pate full of fine dirt? will his vouchers vouch him
+    no more of his purchases, and double ones too, than
+    the length and breadth of a pair of indentures? The
+    very conveyances of his lands will hardly lie in
+    this box; and must the inheritor himself have no more, ha?
+
+HORATIO
+
+    Not a jot more, my lord.
+
+HAMLET
+
+    Is not parchment made of sheepskins?
+
+HORATIO
+
+    Ay, my lord, and of calf-skins too.
+
+HAMLET
+
+    They are sheep and calves which seek out assurance
+    in that. I will speak to this fellow. Whose
+    grave's this, sirrah?
+
+First Clown
+
+    Mine, sir.
+
+    Sings
+    O, a pit of clay for to be made
+    For such a guest is meet.
+
+HAMLET
+
+    I think it be thine, indeed; for thou liest in't.
+
+First Clown
+
+    You lie out on't, sir, and therefore it is not
+    yours: for my part, I do not lie in't, and yet it is mine.
+
+HAMLET
+
+    'Thou dost lie in't, to be in't and say it is thine:
+    'tis for the dead, not for the quick; therefore thou liest.
+
+First Clown
+
+    'Tis a quick lie, sir; 'twill away gain, from me to
+    you.
+
+HAMLET
+
+    What man dost thou dig it for?
+
+First Clown
+
+    For no man, sir.
+
+HAMLET
+
+    What woman, then?
+
+First Clown
+
+    For none, neither.
+
+HAMLET
+
+    Who is to be buried in't?
+
+First Clown
+
+    One that was a woman, sir; but, rest her soul, she's dead.
+
+HAMLET
+
+    How absolute the knave is! we must speak by the
+    card, or equivocation will undo us. By the Lord,
+    Horatio, these three years I have taken a note of
+    it; the age is grown so picked that the toe of the
+    peasant comes so near the heel of the courtier, he
+    gaffs his kibe. How long hast thou been a
+    grave-maker?
+
+First Clown
+
+    Of all the days i' the year, I came to't that day
+    that our last king Hamlet overcame Fortinbras.
+
+HAMLET
+
+    How long is that since?
+
+First Clown
+
+    Cannot you tell that? every fool can tell that: it
+    was the very day that young Hamlet was born; he that
+    is mad, and sent into England.
+
+HAMLET
+
+    Ay, marry, why was he sent into England?
+
+First Clown
+
+    Why, because he was mad: he shall recover his wits
+    there; or, if he do not, it's no great matter there.
+
+HAMLET
+
+    Why?
+
+First Clown
+
+    'Twill, a not be seen in him there; there the men
+    are as mad as he.
+
+HAMLET
+
+    How came he mad?
+
+First Clown
+
+    Very strangely, they say.
+
+HAMLET
+
+    How strangely?
+
+First Clown
+
+    Faith, e'en with losing his wits.
+
+HAMLET
+
+    Upon what ground?
+
+First Clown
+
+    Why, here in Denmark: I have been sexton here, man
+    and boy, thirty years.
+
+HAMLET
+
+    How long will a man lie i' the earth ere he rot?
+
+First Clown
+
+    I' faith, if he be not rotten before he die--as we
+    have many pocky corses now-a-days, that will scarce
+    hold the laying in--he will last you some eight year
+    or nine year: a tanner will last you nine year.
+
+HAMLET
+
+    Why he more than another?
+
+First Clown
+
+    Why, sir, his hide is so tanned with his trade, that
+    he will keep out water a great while; and your water
+    is a sore decayer of your whoreson dead body.
+    Here's a skull now; this skull has lain in the earth
+    three and twenty years.
+
+HAMLET
+
+    Whose was it?
+
+First Clown
+
+    A whoreson mad fellow's it was: whose do you think it was?
+
+HAMLET
+
+    Nay, I know not.
+
+First Clown
+
+    A pestilence on him for a mad rogue! a' poured a
+    flagon of Rhenish on my head once. This same skull,
+    sir, was Yorick's skull, the king's jester.
+
+HAMLET
+
+    This?
+
+First Clown
+
+    E'en that.
+
+HAMLET
+
+    Let me see.
+
+    Takes the skull
+    Alas, poor Yorick! I knew him, Horatio: a fellow
+    of infinite jest, of most excellent fancy: he hath
+    borne me on his back a thousand times; and now, how
+    abhorred in my imagination it is! my gorge rims at
+    it. Here hung those lips that I have kissed I know
+    not how oft. Where be your gibes now? your
+    gambols? your songs? your flashes of merriment,
+    that were wont to set the table on a roar? Not one
+    now, to mock your own grinning? quite chap-fallen?
+    Now get you to my lady's chamber, and tell her, let
+    her paint an inch thick, to this favour she must
+    come; make her laugh at that. Prithee, Horatio, tell
+    me one thing.
+
+HORATIO
+
+    What's that, my lord?
+
+HAMLET
+
+    Dost thou think Alexander looked o' this fashion i'
+    the earth?
+
+HORATIO
+
+    E'en so.
+
+HAMLET
+
+    And smelt so? pah!
+
+    Puts down the skull
+
+HORATIO
+
+    E'en so, my lord.
+
+HAMLET
+
+    To what base uses we may return, Horatio! Why may
+    not imagination trace the noble dust of Alexander,
+    till he find it stopping a bung-hole?
+
+HORATIO
+
+    'Twere to consider too curiously, to consider so.
+
+HAMLET
+
+    No, faith, not a jot; but to follow him thither with
+    modesty enough, and likelihood to lead it: as
+    thus: Alexander died, Alexander was buried,
+    Alexander returneth into dust; the dust is earth; of
+    earth we make loam; and why of that loam, whereto he
+    was converted, might they not stop a beer-barrel?
+    Imperious Caesar, dead and turn'd to clay,
+    Might stop a hole to keep the wind away:
+    O, that that earth, which kept the world in awe,
+    Should patch a wall to expel the winter flaw!
+    But soft! but soft! aside: here comes the king.
+
+    Enter Priest, & c. in procession; the Corpse of OPHELIA, LAERTES and Mourners following; KING CLAUDIUS, QUEEN GERTRUDE, their trains, & c
+    The queen, the courtiers: who is this they follow?
+    And with such maimed rites? This doth betoken
+    The corse they follow did with desperate hand
+    Fordo its own life: 'twas of some estate.
+    Couch we awhile, and mark.
+
+    Retiring with HORATIO
+
+LAERTES
+
+    What ceremony else?
+
+HAMLET
+
+    That is Laertes,
+    A very noble youth: mark.
+
+LAERTES
+
+    What ceremony else?
+
+First Priest
+
+    Her obsequies have been as far enlarged
+    As we have warrantise: her death was doubtful;
+    And, but that great command o'ersways the order,
+    She should in ground unsanctified have lodged
+    Till the last trumpet: for charitable prayers,
+    Shards, flints and pebbles should be thrown on her;
+    Yet here she is allow'd her virgin crants,
+    Her maiden strewments and the bringing home
+    Of bell and burial.
+
+LAERTES
+
+    Must there no more be done?
+
+First Priest
+
+    No more be done:
+    We should profane the service of the dead
+    To sing a requiem and such rest to her
+    As to peace-parted souls.
+
+LAERTES
+
+    Lay her i' the earth:
+    And from her fair and unpolluted flesh
+    May violets spring! I tell thee, churlish priest,
+    A ministering angel shall my sister be,
+    When thou liest howling.
+
+HAMLET
+
+    What, the fair Ophelia!
+
+QUEEN GERTRUDE
+
+    Sweets to the sweet: farewell!
+
+    Scattering flowers
+    I hoped thou shouldst have been my Hamlet's wife;
+    I thought thy bride-bed to have deck'd, sweet maid,
+    And not have strew'd thy grave.
+
+LAERTES
+
+    O, treble woe
+    Fall ten times treble on that cursed head,
+    Whose wicked deed thy most ingenious sense
+    Deprived thee of! Hold off the earth awhile,
+    Till I have caught her once more in mine arms:
+
+    Leaps into the grave
+    Now pile your dust upon the quick and dead,
+    Till of this flat a mountain you have made,
+    To o'ertop old Pelion, or the skyish head
+    Of blue Olympus.
+
+HAMLET
+
+    [Advancing] What is he whose grief
+    Bears such an emphasis? whose phrase of sorrow
+    Conjures the wandering stars, and makes them stand
+    Like wonder-wounded hearers? This is I,
+    Hamlet the Dane.
+
+    Leaps into the grave
+
+LAERTES
+
+    The devil take thy soul!
+
+    Grappling with him
+
+HAMLET
+
+    Thou pray'st not well.
+    I prithee, take thy fingers from my throat;
+    For, though I am not splenitive and rash,
+    Yet have I something in me dangerous,
+    Which let thy wiseness fear: hold off thy hand.
+
+KING CLAUDIUS
+
+    Pluck them asunder.
+
+QUEEN GERTRUDE
+
+    Hamlet, Hamlet!
+
+All
+
+    Gentlemen,--
+
+HORATIO
+
+    Good my lord, be quiet.
+
+    The Attendants part them, and they come out of the grave
+
+HAMLET
+
+    Why I will fight with him upon this theme
+    Until my eyelids will no longer wag.
+
+QUEEN GERTRUDE
+
+    O my son, what theme?
+
+HAMLET
+
+    I loved Ophelia: forty thousand brothers
+    Could not, with all their quantity of love,
+    Make up my sum. What wilt thou do for her?
+
+KING CLAUDIUS
+
+    O, he is mad, Laertes.
+
+QUEEN GERTRUDE
+
+    For love of God, forbear him.
+
+HAMLET
+
+    'Swounds, show me what thou'lt do:
+    Woo't weep? woo't fight? woo't fast? woo't tear thyself?
+    Woo't drink up eisel? eat a crocodile?
+    I'll do't. Dost thou come here to whine?
+    To outface me with leaping in her grave?
+    Be buried quick with her, and so will I:
+    And, if thou prate of mountains, let them throw
+    Millions of acres on us, till our ground,
+    Singeing his pate against the burning zone,
+    Make Ossa like a wart! Nay, an thou'lt mouth,
+    I'll rant as well as thou.
+
+QUEEN GERTRUDE
+
+    This is mere madness:
+    And thus awhile the fit will work on him;
+    Anon, as patient as the female dove,
+    When that her golden couplets are disclosed,
+    His silence will sit drooping.
+
+HAMLET
+
+    Hear you, sir;
+    What is the reason that you use me thus?
+    I loved you ever: but it is no matter;
+    Let Hercules himself do what he may,
+    The cat will mew and dog will have his day.
+
+    Exit
+
+KING CLAUDIUS
+
+    I pray you, good Horatio, wait upon him.
+
+    Exit HORATIO
+
+    To LAERTES
+    Strengthen your patience in our last night's speech;
+    We'll put the matter to the present push.
+    Good Gertrude, set some watch over your son.
+    This grave shall have a living monument:
+    An hour of quiet shortly shall we see;
+    Till then, in patience our proceeding be.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene2.txt
new file mode 100644
index 0000000..d35e3fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/act5/scene2.txt
@@ -0,0 +1,914 @@
+SCENE II. A hall in the castle.
+
+    Enter HAMLET and HORATIO 
+
+HAMLET
+
+    So much for this, sir: now shall you see the other;
+    You do remember all the circumstance?
+
+HORATIO
+
+    Remember it, my lord?
+
+HAMLET
+
+    Sir, in my heart there was a kind of fighting,
+    That would not let me sleep: methought I lay
+    Worse than the mutines in the bilboes. Rashly,
+    And praised be rashness for it, let us know,
+    Our indiscretion sometimes serves us well,
+    When our deep plots do pall: and that should teach us
+    There's a divinity that shapes our ends,
+    Rough-hew them how we will,--
+
+HORATIO
+
+    That is most certain.
+
+HAMLET
+
+    Up from my cabin,
+    My sea-gown scarf'd about me, in the dark
+    Groped I to find out them; had my desire.
+    Finger'd their packet, and in fine withdrew
+    To mine own room again; making so bold,
+    My fears forgetting manners, to unseal
+    Their grand commission; where I found, Horatio,--
+    O royal knavery!--an exact command,
+    Larded with many several sorts of reasons
+    Importing Denmark's health and England's too,
+    With, ho! such bugs and goblins in my life,
+    That, on the supervise, no leisure bated,
+    No, not to stay the grinding of the axe,
+    My head should be struck off.
+
+HORATIO
+
+    Is't possible?
+
+HAMLET
+
+    Here's the commission: read it at more leisure.
+    But wilt thou hear me how I did proceed?
+
+HORATIO
+
+    I beseech you.
+
+HAMLET
+
+    Being thus be-netted round with villanies,--
+    Ere I could make a prologue to my brains,
+    They had begun the play--I sat me down,
+    Devised a new commission, wrote it fair:
+    I once did hold it, as our statists do,
+    A baseness to write fair and labour'd much
+    How to forget that learning, but, sir, now
+    It did me yeoman's service: wilt thou know
+    The effect of what I wrote?
+
+HORATIO
+
+    Ay, good my lord.
+
+HAMLET
+
+    An earnest conjuration from the king,
+    As England was his faithful tributary,
+    As love between them like the palm might flourish,
+    As peace should stiff her wheaten garland wear
+    And stand a comma 'tween their amities,
+    And many such-like 'As'es of great charge,
+    That, on the view and knowing of these contents,
+    Without debatement further, more or less,
+    He should the bearers put to sudden death,
+    Not shriving-time allow'd.
+
+HORATIO
+
+    How was this seal'd?
+
+HAMLET
+
+    Why, even in that was heaven ordinant.
+    I had my father's signet in my purse,
+    Which was the model of that Danish seal;
+    Folded the writ up in form of the other,
+    Subscribed it, gave't the impression, placed it safely,
+    The changeling never known. Now, the next day
+    Was our sea-fight; and what to this was sequent
+    Thou know'st already.
+
+HORATIO
+
+    So Guildenstern and Rosencrantz go to't.
+
+HAMLET
+
+    Why, man, they did make love to this employment;
+    They are not near my conscience; their defeat
+    Does by their own insinuation grow:
+    'Tis dangerous when the baser nature comes
+    Between the pass and fell incensed points
+    Of mighty opposites.
+
+HORATIO
+
+    Why, what a king is this!
+
+HAMLET
+
+    Does it not, think'st thee, stand me now upon--
+    He that hath kill'd my king and whored my mother,
+    Popp'd in between the election and my hopes,
+    Thrown out his angle for my proper life,
+    And with such cozenage--is't not perfect conscience,
+    To quit him with this arm? and is't not to be damn'd,
+    To let this canker of our nature come
+    In further evil?
+
+HORATIO
+
+    It must be shortly known to him from England
+    What is the issue of the business there.
+
+HAMLET
+
+    It will be short: the interim is mine;
+    And a man's life's no more than to say 'One.'
+    But I am very sorry, good Horatio,
+    That to Laertes I forgot myself;
+    For, by the image of my cause, I see
+    The portraiture of his: I'll court his favours.
+    But, sure, the bravery of his grief did put me
+    Into a towering passion.
+
+HORATIO
+
+    Peace! who comes here?
+
+    Enter OSRIC
+
+OSRIC
+
+    Your lordship is right welcome back to Denmark.
+
+HAMLET
+
+    I humbly thank you, sir. Dost know this water-fly?
+
+HORATIO
+
+    No, my good lord.
+
+HAMLET
+
+    Thy state is the more gracious; for 'tis a vice to
+    know him. He hath much land, and fertile: let a
+    beast be lord of beasts, and his crib shall stand at
+    the king's mess: 'tis a chough; but, as I say,
+    spacious in the possession of dirt.
+
+OSRIC
+
+    Sweet lord, if your lordship were at leisure, I
+    should impart a thing to you from his majesty.
+
+HAMLET
+
+    I will receive it, sir, with all diligence of
+    spirit. Put your bonnet to his right use; 'tis for the head.
+
+OSRIC
+
+    I thank your lordship, it is very hot.
+
+HAMLET
+
+    No, believe me, 'tis very cold; the wind is
+    northerly.
+
+OSRIC
+
+    It is indifferent cold, my lord, indeed.
+
+HAMLET
+
+    But yet methinks it is very sultry and hot for my
+    complexion.
+
+OSRIC
+
+    Exceedingly, my lord; it is very sultry,--as
+    'twere,--I cannot tell how. But, my lord, his
+    majesty bade me signify to you that he has laid a
+    great wager on your head: sir, this is the matter,--
+
+HAMLET
+
+    I beseech you, remember--
+
+    HAMLET moves him to put on his hat
+
+OSRIC
+
+    Nay, good my lord; for mine ease, in good faith.
+    Sir, here is newly come to court Laertes; believe
+    me, an absolute gentleman, full of most excellent
+    differences, of very soft society and great showing:
+    indeed, to speak feelingly of him, he is the card or
+    calendar of gentry, for you shall find in him the
+    continent of what part a gentleman would see.
+
+HAMLET
+
+    Sir, his definement suffers no perdition in you;
+    though, I know, to divide him inventorially would
+    dizzy the arithmetic of memory, and yet but yaw
+    neither, in respect of his quick sail. But, in the
+    verity of extolment, I take him to be a soul of
+    great article; and his infusion of such dearth and
+    rareness, as, to make true diction of him, his
+    semblable is his mirror; and who else would trace
+    him, his umbrage, nothing more.
+
+OSRIC
+
+    Your lordship speaks most infallibly of him.
+
+HAMLET
+
+    The concernancy, sir? why do we wrap the gentleman
+    in our more rawer breath?
+
+OSRIC
+
+    Sir?
+
+HORATIO
+
+    Is't not possible to understand in another tongue?
+    You will do't, sir, really.
+
+HAMLET
+
+    What imports the nomination of this gentleman?
+
+OSRIC
+
+    Of Laertes?
+
+HORATIO
+
+    His purse is empty already; all's golden words are spent.
+
+HAMLET
+
+    Of him, sir.
+
+OSRIC
+
+    I know you are not ignorant--
+
+HAMLET
+
+    I would you did, sir; yet, in faith, if you did,
+    it would not much approve me. Well, sir?
+
+OSRIC
+
+    You are not ignorant of what excellence Laertes is--
+
+HAMLET
+
+    I dare not confess that, lest I should compare with
+    him in excellence; but, to know a man well, were to
+    know himself.
+
+OSRIC
+
+    I mean, sir, for his weapon; but in the imputation
+    laid on him by them, in his meed he's unfellowed.
+
+HAMLET
+
+    What's his weapon?
+
+OSRIC
+
+    Rapier and dagger.
+
+HAMLET
+
+    That's two of his weapons: but, well.
+
+OSRIC
+
+    The king, sir, hath wagered with him six Barbary
+    horses: against the which he has imponed, as I take
+    it, six French rapiers and poniards, with their
+    assigns, as girdle, hangers, and so: three of the
+    carriages, in faith, are very dear to fancy, very
+    responsive to the hilts, most delicate carriages,
+    and of very liberal conceit.
+
+HAMLET
+
+    What call you the carriages?
+
+HORATIO
+
+    I knew you must be edified by the margent ere you had done.
+
+OSRIC
+
+    The carriages, sir, are the hangers.
+
+HAMLET
+
+    The phrase would be more german to the matter, if we
+    could carry cannon by our sides: I would it might
+    be hangers till then. But, on: six Barbary horses
+    against six French swords, their assigns, and three
+    liberal-conceited carriages; that's the French bet
+    against the Danish. Why is this 'imponed,' as you call it?
+
+OSRIC
+
+    The king, sir, hath laid, that in a dozen passes
+    between yourself and him, he shall not exceed you
+    three hits: he hath laid on twelve for nine; and it
+    would come to immediate trial, if your lordship
+    would vouchsafe the answer.
+
+HAMLET
+
+    How if I answer 'no'?
+
+OSRIC
+
+    I mean, my lord, the opposition of your person in trial.
+
+HAMLET
+
+    Sir, I will walk here in the hall: if it please his
+    majesty, 'tis the breathing time of day with me; let
+    the foils be brought, the gentleman willing, and the
+    king hold his purpose, I will win for him an I can;
+    if not, I will gain nothing but my shame and the odd hits.
+
+OSRIC
+
+    Shall I re-deliver you e'en so?
+
+HAMLET
+
+    To this effect, sir; after what flourish your nature will.
+
+OSRIC
+
+    I commend my duty to your lordship.
+
+HAMLET
+
+    Yours, yours.
+
+    Exit OSRIC
+    He does well to commend it himself; there are no
+    tongues else for's turn.
+
+HORATIO
+
+    This lapwing runs away with the shell on his head.
+
+HAMLET
+
+    He did comply with his dug, before he sucked it.
+    Thus has he--and many more of the same bevy that I
+    know the dressy age dotes on--only got the tune of
+    the time and outward habit of encounter; a kind of
+    yesty collection, which carries them through and
+    through the most fond and winnowed opinions; and do
+    but blow them to their trial, the bubbles are out.
+
+    Enter a Lord
+
+Lord
+
+    My lord, his majesty commended him to you by young
+    Osric, who brings back to him that you attend him in
+    the hall: he sends to know if your pleasure hold to
+    play with Laertes, or that you will take longer time.
+
+HAMLET
+
+    I am constant to my purpose; they follow the king's
+    pleasure: if his fitness speaks, mine is ready; now
+    or whensoever, provided I be so able as now.
+
+Lord
+
+    The king and queen and all are coming down.
+
+HAMLET
+
+    In happy time.
+
+Lord
+
+    The queen desires you to use some gentle
+    entertainment to Laertes before you fall to play.
+
+HAMLET
+
+    She well instructs me.
+
+    Exit Lord
+
+HORATIO
+
+    You will lose this wager, my lord.
+
+HAMLET
+
+    I do not think so: since he went into France, I
+    have been in continual practise: I shall win at the
+    odds. But thou wouldst not think how ill all's here
+    about my heart: but it is no matter.
+
+HORATIO
+
+    Nay, good my lord,--
+
+HAMLET
+
+    It is but foolery; but it is such a kind of
+    gain-giving, as would perhaps trouble a woman.
+
+HORATIO
+
+    If your mind dislike any thing, obey it: I will
+    forestall their repair hither, and say you are not
+    fit.
+
+HAMLET
+
+    Not a whit, we defy augury: there's a special
+    providence in the fall of a sparrow. If it be now,
+    'tis not to come; if it be not to come, it will be
+    now; if it be not now, yet it will come: the
+    readiness is all: since no man has aught of what he
+    leaves, what is't to leave betimes?
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, LAERTES, Lords, OSRIC, and Attendants with foils, & c
+
+KING CLAUDIUS
+
+    Come, Hamlet, come, and take this hand from me.
+
+    KING CLAUDIUS puts LAERTES' hand into HAMLET's
+
+HAMLET
+
+    Give me your pardon, sir: I've done you wrong;
+    But pardon't, as you are a gentleman.
+    This presence knows,
+    And you must needs have heard, how I am punish'd
+    With sore distraction. What I have done,
+    That might your nature, honour and exception
+    Roughly awake, I here proclaim was madness.
+    Was't Hamlet wrong'd Laertes? Never Hamlet:
+    If Hamlet from himself be ta'en away,
+    And when he's not himself does wrong Laertes,
+    Then Hamlet does it not, Hamlet denies it.
+    Who does it, then? His madness: if't be so,
+    Hamlet is of the faction that is wrong'd;
+    His madness is poor Hamlet's enemy.
+    Sir, in this audience,
+    Let my disclaiming from a purposed evil
+    Free me so far in your most generous thoughts,
+    That I have shot mine arrow o'er the house,
+    And hurt my brother.
+
+LAERTES
+
+    I am satisfied in nature,
+    Whose motive, in this case, should stir me most
+    To my revenge: but in my terms of honour
+    I stand aloof; and will no reconcilement,
+    Till by some elder masters, of known honour,
+    I have a voice and precedent of peace,
+    To keep my name ungored. But till that time,
+    I do receive your offer'd love like love,
+    And will not wrong it.
+
+HAMLET
+
+    I embrace it freely;
+    And will this brother's wager frankly play.
+    Give us the foils. Come on.
+
+LAERTES
+
+    Come, one for me.
+
+HAMLET
+
+    I'll be your foil, Laertes: in mine ignorance
+    Your skill shall, like a star i' the darkest night,
+    Stick fiery off indeed.
+
+LAERTES
+
+    You mock me, sir.
+
+HAMLET
+
+    No, by this hand.
+
+KING CLAUDIUS
+
+    Give them the foils, young Osric. Cousin Hamlet,
+    You know the wager?
+
+HAMLET
+
+    Very well, my lord
+    Your grace hath laid the odds o' the weaker side.
+
+KING CLAUDIUS
+
+    I do not fear it; I have seen you both:
+    But since he is better'd, we have therefore odds.
+
+LAERTES
+
+    This is too heavy, let me see another.
+
+HAMLET
+
+    This likes me well. These foils have all a length?
+
+    They prepare to play
+
+OSRIC
+
+    Ay, my good lord.
+
+KING CLAUDIUS
+
+    Set me the stoops of wine upon that table.
+    If Hamlet give the first or second hit,
+    Or quit in answer of the third exchange,
+    Let all the battlements their ordnance fire:
+    The king shall drink to Hamlet's better breath;
+    And in the cup an union shall he throw,
+    Richer than that which four successive kings
+    In Denmark's crown have worn. Give me the cups;
+    And let the kettle to the trumpet speak,
+    The trumpet to the cannoneer without,
+    The cannons to the heavens, the heavens to earth,
+    'Now the king dunks to Hamlet.' Come, begin:
+    And you, the judges, bear a wary eye.
+
+HAMLET
+
+    Come on, sir.
+
+LAERTES
+
+    Come, my lord.
+
+    They play
+
+HAMLET
+
+    One.
+
+LAERTES
+
+    No.
+
+HAMLET
+
+    Judgment.
+
+OSRIC
+
+    A hit, a very palpable hit.
+
+LAERTES
+
+    Well; again.
+
+KING CLAUDIUS
+
+    Stay; give me drink. Hamlet, this pearl is thine;
+    Here's to thy health.
+
+    Trumpets sound, and cannon shot off within
+    Give him the cup.
+
+HAMLET
+
+    I'll play this bout first; set it by awhile. Come.
+
+    They play
+    Another hit; what say you?
+
+LAERTES
+
+    A touch, a touch, I do confess.
+
+KING CLAUDIUS
+
+    Our son shall win.
+
+QUEEN GERTRUDE
+
+    He's fat, and scant of breath.
+    Here, Hamlet, take my napkin, rub thy brows;
+    The queen carouses to thy fortune, Hamlet.
+
+HAMLET
+
+    Good madam!
+
+KING CLAUDIUS
+
+    Gertrude, do not drink.
+
+QUEEN GERTRUDE
+
+    I will, my lord; I pray you, pardon me.
+
+KING CLAUDIUS
+
+    [Aside] It is the poison'd cup: it is too late.
+
+HAMLET
+
+    I dare not drink yet, madam; by and by.
+
+QUEEN GERTRUDE
+
+    Come, let me wipe thy face.
+
+LAERTES
+
+    My lord, I'll hit him now.
+
+KING CLAUDIUS
+
+    I do not think't.
+
+LAERTES
+
+    [Aside] And yet 'tis almost 'gainst my conscience.
+
+HAMLET
+
+    Come, for the third, Laertes: you but dally;
+    I pray you, pass with your best violence;
+    I am afeard you make a wanton of me.
+
+LAERTES
+
+    Say you so? come on.
+
+    They play
+
+OSRIC
+
+    Nothing, neither way.
+
+LAERTES
+
+    Have at you now!
+
+    LAERTES wounds HAMLET; then in scuffling, they change rapiers, and HAMLET wounds LAERTES
+
+KING CLAUDIUS
+
+    Part them; they are incensed.
+
+HAMLET
+
+    Nay, come, again.
+
+    QUEEN GERTRUDE falls
+
+OSRIC
+
+    Look to the queen there, ho!
+
+HORATIO
+
+    They bleed on both sides. How is it, my lord?
+
+OSRIC
+
+    How is't, Laertes?
+
+LAERTES
+
+    Why, as a woodcock to mine own springe, Osric;
+    I am justly kill'd with mine own treachery.
+
+HAMLET
+
+    How does the queen?
+
+KING CLAUDIUS
+
+    She swounds to see them bleed.
+
+QUEEN GERTRUDE
+
+    No, no, the drink, the drink,--O my dear Hamlet,--
+    The drink, the drink! I am poison'd.
+
+    Dies
+
+HAMLET
+
+    O villany! Ho! let the door be lock'd:
+    Treachery! Seek it out.
+
+LAERTES
+
+    It is here, Hamlet: Hamlet, thou art slain;
+    No medicine in the world can do thee good;
+    In thee there is not half an hour of life;
+    The treacherous instrument is in thy hand,
+    Unbated and envenom'd: the foul practise
+    Hath turn'd itself on me lo, here I lie,
+    Never to rise again: thy mother's poison'd:
+    I can no more: the king, the king's to blame.
+
+HAMLET
+
+    The point!--envenom'd too!
+    Then, venom, to thy work.
+
+    Stabs KING CLAUDIUS
+
+All
+
+    Treason! treason!
+
+KING CLAUDIUS
+
+    O, yet defend me, friends; I am but hurt.
+
+HAMLET
+
+    Here, thou incestuous, murderous, damned Dane,
+    Drink off this potion. Is thy union here?
+    Follow my mother.
+
+    KING CLAUDIUS dies
+
+LAERTES
+
+    He is justly served;
+    It is a poison temper'd by himself.
+    Exchange forgiveness with me, noble Hamlet:
+    Mine and my father's death come not upon thee,
+    Nor thine on me.
+
+    Dies
+
+HAMLET
+
+    Heaven make thee free of it! I follow thee.
+    I am dead, Horatio. Wretched queen, adieu!
+    You that look pale and tremble at this chance,
+    That are but mutes or audience to this act,
+    Had I but time--as this fell sergeant, death,
+    Is strict in his arrest--O, I could tell you--
+    But let it be. Horatio, I am dead;
+    Thou livest; report me and my cause aright
+    To the unsatisfied.
+
+HORATIO
+
+    Never believe it:
+    I am more an antique Roman than a Dane:
+    Here's yet some liquor left.
+
+HAMLET
+
+    As thou'rt a man,
+    Give me the cup: let go; by heaven, I'll have't.
+    O good Horatio, what a wounded name,
+    Things standing thus unknown, shall live behind me!
+    If thou didst ever hold me in thy heart
+    Absent thee from felicity awhile,
+    And in this harsh world draw thy breath in pain,
+    To tell my story.
+
+    March afar off, and shot within
+    What warlike noise is this?
+
+OSRIC
+
+    Young Fortinbras, with conquest come from Poland,
+    To the ambassadors of England gives
+    This warlike volley.
+
+HAMLET
+
+    O, I die, Horatio;
+    The potent poison quite o'er-crows my spirit:
+    I cannot live to hear the news from England;
+    But I do prophesy the election lights
+    On Fortinbras: he has my dying voice;
+    So tell him, with the occurrents, more and less,
+    Which have solicited. The rest is silence.
+
+    Dies
+
+HORATIO
+
+    Now cracks a noble heart. Good night sweet prince:
+    And flights of angels sing thee to thy rest!
+    Why does the drum come hither?
+
+    March within
+
+    Enter FORTINBRAS, the English Ambassadors, and others
+
+PRINCE FORTINBRAS
+
+    Where is this sight?
+
+HORATIO
+
+    What is it ye would see?
+    If aught of woe or wonder, cease your search.
+
+PRINCE FORTINBRAS
+
+    This quarry cries on havoc. O proud death,
+    What feast is toward in thine eternal cell,
+    That thou so many princes at a shot
+    So bloodily hast struck?
+
+First Ambassador
+
+    The sight is dismal;
+    And our affairs from England come too late:
+    The ears are senseless that should give us hearing,
+    To tell him his commandment is fulfill'd,
+    That Rosencrantz and Guildenstern are dead:
+    Where should we have our thanks?
+
+HORATIO
+
+    Not from his mouth,
+    Had it the ability of life to thank you:
+    He never gave commandment for their death.
+    But since, so jump upon this bloody question,
+    You from the Polack wars, and you from England,
+    Are here arrived give order that these bodies
+    High on a stage be placed to the view;
+    And let me speak to the yet unknowing world
+    How these things came about: so shall you hear
+    Of carnal, bloody, and unnatural acts,
+    Of accidental judgments, casual slaughters,
+    Of deaths put on by cunning and forced cause,
+    And, in this upshot, purposes mistook
+    Fall'n on the inventors' reads: all this can I
+    Truly deliver.
+
+PRINCE FORTINBRAS
+
+    Let us haste to hear it,
+    And call the noblest to the audience.
+    For me, with sorrow I embrace my fortune:
+    I have some rights of memory in this kingdom,
+    Which now to claim my vantage doth invite me.
+
+HORATIO
+
+    Of that I shall have also cause to speak,
+    And from his mouth whose voice will draw on more;
+    But let this same be presently perform'd,
+    Even while men's minds are wild; lest more mischance
+    On plots and errors, happen.
+
+PRINCE FORTINBRAS
+
+    Let four captains
+    Bear Hamlet, like a soldier, to the stage;
+    For he was likely, had he been put on,
+    To have proved most royally: and, for his passage,
+    The soldiers' music and the rites of war
+    Speak loudly for him.
+    Take up the bodies: such a sight as this
+    Becomes the field, but here shows much amiss.
+    Go, bid the soldiers shoot.
+
+    A dead march. Exeunt, bearing off the dead bodies; after which a peal of ordnance is shot off
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/bookmarks/2019-07-16 b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/bookmarks/2019-07-16
new file mode 120000
index 0000000..b7541e4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/test_fs/hamlet/bookmarks/2019-07-16
@@ -0,0 +1 @@
+../act1/scene2.txt
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/wasm-test.sh b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/wasm-test.sh
new file mode 100755
index 0000000..89523c7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-fyi/wasm-test.sh
@@ -0,0 +1,67 @@
+#!/usr/bin/env bash
+
+set -e
+
+input=$1
+
+input_dir=$(dirname $input)
+cd $input_dir
+
+input_base=$(basename $input .wasm)
+
+if [ -e "$input_base.stdin" ]; then
+  stdin="$input_base.stdin"
+else
+  stdin="/dev/null"
+fi
+
+out_dir="$(mktemp -d)"
+stdout_actual="$out_dir/stdout"
+stderr_actual="$out_dir/stderr"
+status_actual="$out_dir/status"
+
+if [ -e "$input_base.arg" ]; then
+  arg=$(cat "$input_base.arg")
+else
+  arg=""
+fi
+
+if [ -e "$input_base.dir" ]; then
+  dir="--dir $input_base.dir"
+else
+  dir=""
+fi
+
+if [ -e "$input_base.env" ]; then
+  env=$(sed -e 's/^/--env /' < "$input_base.env")
+else
+  env=""
+fi
+
+status=0
+
+"../../target/release/wasmer" --mapdir /hamlet:./test_fs/hamlet --mapdir /fyi:./test_fs/fyi "$input_base.wasm" $dir $env -- $arg \
+    < "$stdin" \
+    > "$stdout_actual" \
+    2> "$stderr_actual" \
+    || status=$?
+
+echo $status > "$status_actual"
+
+stdout_expected="$input_base.stdout"
+if [ -e "$stdout_expected" ]; then
+  diff -u "$stdout_expected" "$stdout_actual"
+fi
+
+stderr_expected="$input_base.stderr"
+if [ -e "$stderr_expected" ]; then
+  diff -u "$stderr_expected" "$stderr_actual"
+fi
+
+status_expected="$input_base.status"
+if [ -e "$input_base.status" ]; then
+  diff -u "$status_expected" "$status_actual"
+elif [ ! "$status" -eq "0" ]; then
+  cat $stderr_actual
+  exit 1
+fi
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/.gitignore
new file mode 100644
index 0000000..54466f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/.gitignore
@@ -0,0 +1,2 @@
+/target
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.lock b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.lock
new file mode 100644
index 0000000..793ea75
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.lock
@@ -0,0 +1,259 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "getrandom"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7abc8dd8451921606d809ba32e95b6111925cd2906060d2dcc29c070220503eb"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+
+[[package]]
+name = "gumdrop"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46571f5d540478cf70d2a42dd0d6d8e9f4b9cc7531544b93311e657b86568a0b"
+dependencies = [
+ "gumdrop_derive",
+]
+
+[[package]]
+name = "gumdrop_derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "915ef07c710d84733522461de2a734d4d62a3fd39a4d4f404c2f385ef8618d05"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "itoa"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"
+
+[[package]]
+name = "leb128"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+
+[[package]]
+name = "libc"
+version = "0.2.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9457b06509d27052635f90d6466700c65095fdf75409b3fbdd903e988b886f49"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom",
+ "libc",
+ "rand_chacha",
+ "rand_core",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.1.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2439c63f3f6139d1b57529d16bc3b8bb855230c8efcc5d3a896c8bea7c3b1e84"
+
+[[package]]
+name = "remove_dir_all"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+
+[[package]]
+name = "serde"
+version = "1.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736aac72d1eafe8e5962d1d1c3d99b0df526015ba40915cb3c49d042e92ec243"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf0343ce212ac0d3d6afd9391ac8e9c9efe06b533c8d33f660f6390cc4093f57"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec2c5d7e739bc07a3e73381a39d61fdb5f671c60c1df26a130690665803d8226"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "rand",
+ "redox_syscall",
+ "remove_dir_all",
+ "winapi",
+]
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi-test-generator"
+version = "0.17.0"
+dependencies = [
+ "glob",
+ "gumdrop",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "wast",
+]
+
+[[package]]
+name = "wast"
+version = "20.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fb95ce157a8c779ec301ef3e4c0a7caeb6f9f902f813f1f5f7e464367048924"
+dependencies = [
+ "leb128",
+]
+
+[[package]]
+name = "winapi"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8093091eeb260906a183e6ae1abdba2ef5ef2257a21801128899c3fc699229c6"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.toml
new file mode 100644
index 0000000..ff410ea
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "wasi-test-generator"
+version = "4.2.8"
+description = "Tests for our WASI implementation"
+license = "MIT"
+authors = ["Wasmer Engineering Team <engineering@wasmer.io>"]
+edition = "2018"
+publish = false
+
+[dependencies]
+glob = "0.3"
+gumdrop = "0.8"
+tempfile = "3.6.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+wast = "24.0"
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/README.md
new file mode 100644
index 0000000..a17321f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/README.md
@@ -0,0 +1,41 @@
+# WASI test suite
+
+WASI test files with expected output in a custom WAST format.
+
+## Setup
+
+In order to run the test generator properly you will need:
+
+- `rustup` installed and on your PATH
+- `wasm-opt` from `binaryen` and `wasm-strip` from `wabt` are installed and on your PATH
+
+## Usage
+
+```
+Positional arguments:
+  free                    if you want to specify specific tests to generate
+
+Optional arguments:
+  -a, --all-versions      Whether or not to do operations for all versions of WASI or just the latest.
+  -g, --generate-wasm     Whether or not the Wasm will be generated.
+  -s, --set-up-toolchain  Whether or not the logic to install the needed Rust compilers is run.
+  -h, --help              Print the help message
+```
+
+And here's an example of how to generate these tests:
+
+```bash
+cargo run -- -as # set up the toolchains for all targets
+cargo run -- -ag # generate the WASI tests for all targets
+```
+
+If you want to generate specific tests (it's faster when you're developing) you can use this command:
+
+```bash
+cargo run -- -g fd_rename_path # If you want to run the test in fd_rename_path.rs
+```
+
+## Updating in Wasmer
+
+Run
+`git subtree pull --prefix tests/wasi-wast git@github.com:wasmerio/wasi-tests master --squash`
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/main.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/main.rs
new file mode 100644
index 0000000..7197e8e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/main.rs
@@ -0,0 +1,64 @@
+#[macro_use]
+extern crate serde;
+
+mod set_up_toolchain;
+mod util;
+mod wasi_version;
+mod wasitests;
+
+pub use crate::set_up_toolchain::install_toolchains;
+pub use crate::wasi_version::{
+    WasiVersion, ALL_WASI_VERSIONS, LATEST_WASI_VERSION, NIGHTLY_VERSION,
+};
+pub use crate::wasitests::{build, WasiOptions, WasiTest};
+
+use gumdrop::Options;
+
+#[derive(Debug, Options)]
+pub struct TestGenOptions {
+    /// if you want to specify specific tests to generate
+    #[options(free)]
+    free: Vec<String>,
+    /// Whether to use the current nightly instead of the latest snapshot0 compiler
+    nightly: bool,
+    /// Whether or not to do operations for all versions of WASI or just the latest.
+    all_versions: bool,
+    /// Whether or not the Wasm will be generated.
+    generate_wasm: bool,
+    /// Whether or not the logic to install the needed Rust compilers is run.
+    set_up_toolchain: bool,
+    /// Print the help message
+    help: bool,
+}
+
+fn main() {
+    let opts = TestGenOptions::parse_args_default_or_exit();
+
+    if opts.help {
+        println!("{}", TestGenOptions::usage());
+        std::process::exit(0);
+    }
+
+    let generate_all = opts.all_versions;
+    let set_up_toolchain = opts.set_up_toolchain;
+    let generate_wasm = opts.generate_wasm;
+    let nightly = opts.nightly;
+    let wasi_versions = if generate_all {
+        ALL_WASI_VERSIONS
+    } else if nightly {
+        NIGHTLY_VERSION
+    } else {
+        LATEST_WASI_VERSION
+    };
+
+    // Install the Rust WASI toolchains for each of the versions
+    if set_up_toolchain {
+        install_toolchains(wasi_versions);
+    }
+
+    // Generate the WASI Wasm files
+    if generate_wasm {
+        let specific_tests: Vec<&str> = opts.free.iter().map(|st| st.as_str()).collect();
+        build(wasi_versions, &specific_tests);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/set_up_toolchain.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/set_up_toolchain.rs
new file mode 100644
index 0000000..4ff4da5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/set_up_toolchain.rs
@@ -0,0 +1,35 @@
+use super::util;
+use super::wasi_version::*;
+
+use std::process::Command;
+
+fn install_toolchain(toolchain_name: &str) {
+    println!("Installing rustup toolchain: {}", toolchain_name);
+    let rustup_out = Command::new("rustup")
+        .arg("toolchain")
+        .arg("install")
+        .arg(toolchain_name)
+        .output()
+        .expect("Failed to install toolchain with rustup");
+    util::print_info_on_error(&rustup_out, "TOOLCHAIN INSTALL FAILED");
+
+    println!("Installing rustup WASI target");
+    let rustup_out = Command::new("rustup")
+        .arg("target")
+        .arg("add")
+        .arg("wasm32-wasi")
+        .arg("--toolchain")
+        .arg(toolchain_name)
+        .output()
+        .expect("Failed to wasi target in Rust toolchain");
+    util::print_info_on_error(&rustup_out, "WASI TARGET IN TOOLCHAIN INSTALL FAILED");
+}
+
+pub fn install_toolchains(wasi_versions: &[WasiVersion]) {
+    println!("Setting up system to generate the WASI tests.");
+    println!("WARNING: this may use a lot of disk space.");
+
+    for wasi_version in wasi_versions {
+        install_toolchain(wasi_version.get_compiler_toolchain());
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/util.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/util.rs
new file mode 100644
index 0000000..7ce1e1c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/util.rs
@@ -0,0 +1,13 @@
+pub fn print_info_on_error(output: &std::process::Output, context: &str) {
+    if !output.status.success() {
+        println!("{}", context);
+        println!(
+            "stdout:\n{}",
+            std::str::from_utf8(&output.stdout[..]).unwrap()
+        );
+        eprintln!(
+            "stderr:\n{}",
+            std::str::from_utf8(&output.stderr[..]).unwrap()
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasi_version.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasi_version.rs
new file mode 100644
index 0000000..3955640
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasi_version.rs
@@ -0,0 +1,40 @@
+pub static ALL_WASI_VERSIONS: &[WasiVersion] = &[WasiVersion::Unstable, WasiVersion::Snapshot1];
+pub static LATEST_WASI_VERSION: &[WasiVersion] = &[WasiVersion::get_latest()];
+pub static NIGHTLY_VERSION: &[WasiVersion] = &[WasiVersion::current_nightly()];
+
+#[derive(Debug, Clone, Copy)]
+pub enum WasiVersion {
+    /// A.K.A. Snapshot0
+    Unstable,
+    Snapshot1,
+    /// This is for making tests pass on Apple M1 while
+    /// still keeping the old test for compatibility reasons
+    #[allow(non_camel_case_types)]
+    Nightly_2022_10_18,
+}
+
+impl WasiVersion {
+    pub const fn get_latest() -> Self {
+        Self::Snapshot1
+    }
+
+    pub const fn current_nightly() -> Self {
+        Self::Nightly_2022_10_18
+    }
+
+    pub fn get_compiler_toolchain(&self) -> &'static str {
+        match self {
+            WasiVersion::Unstable => "nightly-2019-09-13",
+            WasiVersion::Snapshot1 => "1.53.0",
+            WasiVersion::Nightly_2022_10_18 => "nightly-2022-10-18",
+        }
+    }
+
+    pub fn get_directory_name(&self) -> &'static str {
+        match self {
+            WasiVersion::Unstable => "unstable",
+            WasiVersion::Snapshot1 => "snapshot1",
+            WasiVersion::Nightly_2022_10_18 => "nightly_2022_10_18",
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasitests.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasitests.rs
new file mode 100644
index 0000000..d01d048
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/src/wasitests.rs
@@ -0,0 +1,447 @@
+//! This file will run at build time to autogenerate the WASI regression tests
+//! It will compile the files indicated in TESTS, to:executable and .wasm
+//! - Compile with the native rust target to get the expected output
+//! - Compile with the latest WASI target to get the wasm
+//! - Generate the test that will compare the output of running the .wasm file
+//!   with wasmer with the expected output
+
+use glob::glob;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+use std::io;
+use std::io::prelude::*;
+
+use super::util;
+use super::wasi_version::*;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct NativeOutput {
+    stdout: String,
+    stderr: String,
+    result: i64,
+}
+
+/// Compile and execute the test file as native code, saving the results to be
+/// compared against later.
+///
+/// This function attempts to clean up its output after it executes it.
+fn generate_native_output(
+    temp_dir: &Path,
+    file: &str,
+    normalized_name: &str,
+    args: &[String],
+    options: &WasiOptions,
+) -> io::Result<NativeOutput> {
+    let executable_path = temp_dir.join(normalized_name);
+    println!(
+        "Compiling program {} to native at {}",
+        file,
+        executable_path.to_string_lossy()
+    );
+    let native_out = Command::new("rustc")
+        .arg(file)
+        .arg("-o")
+        .args(args)
+        .arg(&executable_path)
+        .output()
+        .expect("Failed to compile program to native code");
+    util::print_info_on_error(&native_out, "COMPILATION FAILED");
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perm = executable_path
+            .metadata()
+            .expect("native executable")
+            .permissions();
+        perm.set_mode(0o766);
+        println!(
+            "Setting execute permissions on {}",
+            executable_path.to_string_lossy()
+        );
+        fs::set_permissions(&executable_path, perm)?;
+    }
+
+    println!(
+        "Executing native program at {}",
+        executable_path.to_string_lossy()
+    );
+    // workspace root
+    const EXECUTE_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/wasi");
+    let mut native_command = Command::new(&executable_path)
+        .current_dir(EXECUTE_DIR)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .unwrap();
+
+    if let Some(stdin_str) = &options.stdin {
+        write!(native_command.stdin.as_ref().unwrap(), "{}", stdin_str).unwrap();
+    }
+
+    let result = native_command
+        .wait()
+        .expect("Failed to execute native program");
+
+    let stdout_str = {
+        let mut stdout = native_command.stdout.unwrap();
+        let mut s = String::new();
+        stdout.read_to_string(&mut s).unwrap();
+        s
+    };
+    let stderr_str = {
+        let mut stderr = native_command.stderr.unwrap();
+        let mut s = String::new();
+        stderr.read_to_string(&mut s).unwrap();
+        s
+    };
+    if !result.success() {
+        println!("NATIVE PROGRAM FAILED");
+        println!("stdout:\n{}", stdout_str);
+        eprintln!("stderr:\n{}", stderr_str);
+    }
+
+    let result = result.code().unwrap() as i64;
+    Ok(NativeOutput {
+        stdout: stdout_str,
+        stderr: stderr_str,
+        result,
+    })
+}
+
+/// compile the Wasm file for the given version of WASI
+///
+/// returns the path of where the wasm file is
+fn compile_wasm_for_version(
+    temp_dir: &Path,
+    file: &str,
+    out_dir: &Path,
+    rs_mod_name: &str,
+    version: WasiVersion,
+) -> io::Result<PathBuf> {
+    //let out_dir = base_dir; //base_dir.join("..").join(version.get_directory_name());
+    if !out_dir.exists() {
+        fs::create_dir(out_dir)?;
+    }
+    let wasm_out_name = {
+        let mut wasm_out_name = out_dir.join(rs_mod_name);
+        wasm_out_name.set_extension("wasm");
+        wasm_out_name
+    };
+    println!("Reading contents from file `{}`", file);
+    let file_contents: String = {
+        let mut fc = String::new();
+        let mut f = fs::OpenOptions::new().read(true).open(file)?;
+        f.read_to_string(&mut fc)?;
+        fc
+    };
+
+    let temp_wasi_rs_file_name = temp_dir.join(format!("wasi_modified_version_{}.rs", rs_mod_name));
+    {
+        let mut actual_file = fs::OpenOptions::new()
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(&temp_wasi_rs_file_name)
+            .unwrap();
+        actual_file.write_all(file_contents.as_bytes()).unwrap();
+    }
+
+    println!(
+        "Compiling wasm module `{}` with toolchain `{}`",
+        &wasm_out_name.to_string_lossy(),
+        version.get_compiler_toolchain()
+    );
+    let mut command = Command::new("rustc");
+
+    command
+        .arg(format!("+{}", version.get_compiler_toolchain()))
+        .arg("--target=wasm32-wasi")
+        .arg("-C")
+        .arg("opt-level=z")
+        .arg(&temp_wasi_rs_file_name)
+        .arg("-o")
+        .arg(&wasm_out_name);
+    println!("Command {:?}", command);
+
+    let wasm_compilation_out = command.output().expect("Failed to compile program to wasm");
+    util::print_info_on_error(&wasm_compilation_out, "WASM COMPILATION");
+    println!(
+        "Removing file `{}`",
+        &temp_wasi_rs_file_name.to_string_lossy()
+    );
+
+    // to prevent commiting huge binary blobs forever
+    let wasm_strip_out = Command::new("wasm-strip")
+        .arg(&wasm_out_name)
+        .output()
+        .expect("Failed to strip compiled wasm module");
+    util::print_info_on_error(&wasm_strip_out, "STRIPPING WASM");
+    let wasm_opt_out = Command::new("wasm-opt")
+        .arg("-Oz")
+        .arg(&wasm_out_name)
+        .arg("-o")
+        .arg(&wasm_out_name)
+        .output()
+        .expect("Failed to optimize compiled wasm module with wasm-opt!");
+    util::print_info_on_error(&wasm_opt_out, "OPTIMIZING WASM");
+
+    Ok(wasm_out_name)
+}
+
+/// Returns the a Vec of the test modules created
+fn compile(temp_dir: &Path, file: &str, wasi_versions: &[WasiVersion]) {
+    let src_code: String = fs::read_to_string(file).unwrap();
+    let options: WasiOptions = extract_args_from_source_file(&src_code).unwrap_or_default();
+
+    assert!(file.ends_with(".rs"));
+    let rs_mod_name = {
+        Path::new(&file.to_lowercase())
+            .file_stem()
+            .unwrap()
+            .to_string_lossy()
+            .to_string()
+    };
+    let base_dir = Path::new(file).parent().unwrap();
+    let NativeOutput {
+        stdout,
+        stderr,
+        result,
+    } = generate_native_output(temp_dir, file, &rs_mod_name, &options.args, &options)
+        .expect("Generate native output");
+
+    let test = WasiTest {
+        wasm_prog_name: format!("{}.wasm", rs_mod_name),
+        stdout,
+        stderr,
+        result,
+        options,
+    };
+    let test_serialized = test.into_wasi_wast();
+    println!("Generated test output: {}", &test_serialized);
+
+    wasi_versions
+        .iter()
+        .map(|&version| {
+            let out_dir = base_dir.join("..").join(version.get_directory_name());
+            if !out_dir.exists() {
+                fs::create_dir(&out_dir).unwrap();
+            }
+            let wasm_out_name = {
+                let mut wasm_out_name = out_dir.join(rs_mod_name.clone());
+                wasm_out_name.set_extension("wast");
+                wasm_out_name
+            };
+            println!("Writing test output to {}", wasm_out_name.to_string_lossy());
+            fs::write(&wasm_out_name, test_serialized.clone()).unwrap();
+
+            println!("Compiling wasm version {:?}", version);
+            compile_wasm_for_version(temp_dir, file, &out_dir, &rs_mod_name, version)
+                .unwrap_or_else(|_| panic!("Could not compile Wasm to WASI version {:?}, perhaps you need to install the `{}` rust toolchain", version, version.get_compiler_toolchain()));
+        }).for_each(drop); // Do nothing with it, but let the iterator be consumed/iterated.
+}
+
+const WASI_TEST_SRC_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/wasi/tests/*.rs");
+pub fn build(wasi_versions: &[WasiVersion], specific_tests: &[&str]) {
+    let temp_dir = tempfile::TempDir::new().unwrap();
+    for entry in glob(WASI_TEST_SRC_DIR).unwrap() {
+        match entry {
+            Ok(path) => {
+                let test = path.to_str().unwrap();
+                if !specific_tests.is_empty() {
+                    if let Some(filename) = path.file_stem().and_then(|f| f.to_str()) {
+                        if specific_tests.contains(&filename) {
+                            compile(temp_dir.path(), test, wasi_versions);
+                        }
+                    }
+                } else {
+                    compile(temp_dir.path(), test, wasi_versions);
+                }
+            }
+            Err(e) => println!("{:?}", e),
+        }
+    }
+    println!("All modules generated.");
+}
+
+/// This is the structure of the `.wast` file
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct WasiTest {
+    /// The name of the wasm module to run
+    pub wasm_prog_name: String,
+    /// The program expected output on stdout
+    pub stdout: String,
+    /// The program expected output on stderr
+    pub stderr: String,
+    /// The program expected result
+    pub result: i64,
+    /// The program options
+    pub options: WasiOptions,
+}
+
+impl WasiTest {
+    fn into_wasi_wast(self) -> String {
+        use std::fmt::Write;
+
+        let mut out = format!(
+            ";; This file was generated by https://github.com/wasmerio/wasi-tests\n
+(wasi_test \"{}\"",
+            self.wasm_prog_name
+        );
+        if !self.options.env.is_empty() {
+            let envs = self
+                .options
+                .env
+                .iter()
+                .map(|(name, value)| format!("\"{}={}\"", name, value))
+                .collect::<Vec<String>>()
+                .join(" ");
+            let _ = write!(out, "\n  (envs {})", envs);
+        }
+        if !self.options.args.is_empty() {
+            let args = self
+                .options
+                .args
+                .iter()
+                .map(|v| format!("\"{}\"", v))
+                .collect::<Vec<String>>()
+                .join(" ");
+            let _ = write!(out, "\n  (args {})", args);
+        }
+
+        if !self.options.dir.is_empty() {
+            let preopens = self
+                .options
+                .dir
+                .iter()
+                .map(|v| format!("\"{}\"", v))
+                .collect::<Vec<String>>()
+                .join(" ");
+            let _ = write!(out, "\n  (preopens {})", preopens);
+        }
+        if !self.options.mapdir.is_empty() {
+            let map_dirs = self
+                .options
+                .mapdir
+                .iter()
+                .map(|(a, b)| format!("\"{}:{}\"", a, b))
+                .collect::<Vec<String>>()
+                .join(" ");
+            let _ = write!(out, "\n  (map_dirs {})", map_dirs);
+        }
+        if !self.options.tempdir.is_empty() {
+            let temp_dirs = self
+                .options
+                .tempdir
+                .iter()
+                .map(|td| format!("\"{}\"", td))
+                .collect::<Vec<String>>()
+                .join(" ");
+            let _ = write!(out, "\n  (temp_dirs {})", temp_dirs);
+        }
+
+        let _ = write!(out, "\n  (assert_return (i64.const {}))", self.result);
+        if let Some(stdin) = &self.options.stdin {
+            let _ = write!(out, "\n  (stdin {:?})", stdin);
+        }
+
+        if !self.stdout.is_empty() {
+            let _ = write!(out, "\n  (assert_stdout {:?})", self.stdout);
+        }
+        if !self.stderr.is_empty() {
+            let _ = write!(out, "\n  (assert_stderr {:?})", self.stderr);
+        }
+
+        let _ = write!(out, "\n)\n");
+
+        out
+    }
+}
+
+/// The options provied when executed a WASI Wasm program
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct WasiOptions {
+    /// Mapped pre-opened dirs
+    pub mapdir: Vec<(String, String)>,
+    /// Environment vars
+    pub env: Vec<(String, String)>,
+    /// Program arguments
+    pub args: Vec<String>,
+    /// Pre-opened directories
+    pub dir: Vec<String>,
+    /// The alias of the temporary directory to use
+    pub tempdir: Vec<String>,
+    /// Stdin to give to the native program and WASI program.
+    pub stdin: Option<String>,
+}
+
+/// Pulls args to the program out of a comment at the top of the file starting with "// WasiOptions:"
+fn extract_args_from_source_file(source_code: &str) -> Option<WasiOptions> {
+    if source_code.starts_with("// WASI:") {
+        let mut args = WasiOptions::default();
+        for arg_line in source_code
+            .lines()
+            .skip(1)
+            .take_while(|line| line.starts_with("// "))
+        {
+            let arg_line = arg_line.strip_prefix("// ").unwrap();
+            let arg_line = arg_line.trim();
+            let colon_idx = arg_line
+                .find(':')
+                .expect("directives provided at the top must be separated by a `:`");
+
+            let (command_name, value) = arg_line.split_at(colon_idx);
+            let value = value.strip_prefix(':').unwrap();
+            let value = value.trim();
+
+            match command_name {
+                "mapdir" =>
+                // We try first splitting by `::`
+                {
+                    if let [alias, real_dir] = value.split("::").collect::<Vec<&str>>()[..] {
+                        args.mapdir.push((alias.to_string(), real_dir.to_string()));
+                    } else if let [alias, real_dir] = value.split(':').collect::<Vec<&str>>()[..] {
+                        // And then we try splitting by `:` (for compatibility with previous API)
+                        args.mapdir.push((alias.to_string(), real_dir.to_string()));
+                    } else {
+                        eprintln!("Parse error in mapdir {} not parsed correctly", value);
+                    }
+                }
+                "env" => {
+                    if let [name, val] = value.split('=').collect::<Vec<&str>>()[..] {
+                        args.env.push((name.to_string(), val.to_string()));
+                    } else {
+                        eprintln!("Parse error in env {} not parsed correctly", value);
+                    }
+                }
+                "dir" => {
+                    args.dir.push(value.to_string());
+                }
+                "arg" => {
+                    args.args.push(value.to_string());
+                }
+                "tempdir" => {
+                    args.tempdir.push(value.to_string());
+                }
+                "stdin" => {
+                    assert!(args.stdin.is_none(), "Only the first `stdin` directive is used! Please correct this or update this code");
+                    let s = value;
+                    let s = s.strip_prefix('"').expect("expected leading '\"' in stdin");
+                    let s = s
+                        .trim_end()
+                        .strip_suffix('\"')
+                        .expect("expected trailing '\"' in stdin");
+                    args.stdin = Some(s.to_string());
+                }
+                e => {
+                    eprintln!("WARN: comment arg: `{}` is not supported", e);
+                }
+            }
+        }
+        return Some(args);
+    }
+    None
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wasm
new file mode 100755
index 0000000..15922f8
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast
new file mode 100644
index 0000000..65dda3b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/close_preopen_fd.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "close_preopen_fd.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wasm
new file mode 100755
index 0000000..8ddd6f8
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wast
new file mode 100644
index 0000000..7722640
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/create_dir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "create_dir.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "Test file exists: false\nDir exists: false\nDir exists: false\nDir exists: false\nSuccess\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wasm
new file mode 100755
index 0000000..63535d1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wast
new file mode 100644
index 0000000..fbfe0b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/envvar.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "envvar.wasm"
+  (envs "DOG=1" "CAT=2")
+  (assert_return (i64.const 0))
+  (assert_stdout "Env vars:\nCAT=2\nDOG=1\nDOG Ok(\"1\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_allocate.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_allocate.wast
new file mode 100644
index 0000000..784294e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_allocate.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_allocate.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "171\n1405\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wasm
new file mode 100755
index 0000000..44783c9
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wast
new file mode 100644
index 0000000..c006388
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_append.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_append.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 101))
+  (assert_stderr "thread 'main' panicked at 'Couldn't create file: Os { code: 2, kind: NotFound, message: \"No such file or directory\" }', /Users/fs/Development/wasmer/tests/wasi-wast/wasi/tests/fd_append.rs:27:14\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_close.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_close.wast
new file mode 100644
index 0000000..82dc9d5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_close.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_close.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "Successfully closed file!\nSuccessfully closed stderr!\nSuccessfully closed stdin!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_pread.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_pread.wast
new file mode 100644
index 0000000..d320f87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_pread.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_pread.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout " POLONIUS\n\n    He will come straight. Look you lay home to him:\n\n POLONIUS\n\n    He will come straight. Look you lay home to him:\n\nRead the same data? true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_read.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_read.wast
new file mode 100644
index 0000000..23bbb15
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_read.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_read.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE IV. The Queen's closet.\n\n    Enter QUEEN GERTRUDE and POLO\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wasm
new file mode 100755
index 0000000..8d8bd80
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wast
new file mode 100644
index 0000000..fd3e597
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rename_path.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_rename_path.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wasm
new file mode 100755
index 0000000..e970c3b
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wast
new file mode 100644
index 0000000..6499e16
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_rights.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_rights.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wasm
new file mode 100755
index 0000000..a455bd4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wast
new file mode 100644
index 0000000..ad592f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fd_sync.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_sync.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "170\n1404\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wasm
new file mode 100755
index 0000000..3d257a5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wast
new file mode 100644
index 0000000..7761ef1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/file_metadata.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "file_metadata.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "is dir: false\nfiletype: false true false\nfile info: 8866\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wasm
new file mode 100755
index 0000000..98ca61e
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wast
new file mode 100644
index 0000000..4574470
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fs_sandbox_test.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fs_sandbox_test.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Reading the parent directory was okay? false\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wasm
new file mode 100755
index 0000000..c3c3845
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wast
new file mode 100644
index 0000000..f9e9ba7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/fseek.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fseek.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE III. A room in Polonius' h\nouse.\n\n    Enter LAERTES and OPH\n    And, sister, as the winds gi\nr talk with the Lord Hamlet.\n   \nuits,\n    Breathing like sanctif\nis is for all:\n    I would not, \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wasm
new file mode 100755
index 0000000..5adae6c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wast
new file mode 100644
index 0000000..55885a8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/hello.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "hello.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Hello, world!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wasm
new file mode 100755
index 0000000..1a7e49a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wast
new file mode 100644
index 0000000..c33255a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/isatty.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "isatty.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "stdin: 1\nstdout: 1\nstderr: 1\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wasm
new file mode 100755
index 0000000..998d9b9
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wast
new file mode 100644
index 0000000..4808a8e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"./README.md\"\n\"./act1\"\n\"./act2\"\n\"./act3\"\n\"./act4\"\n\"./act5\"\n\"./bookmarks\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wasm
new file mode 100755
index 0000000..12c45ce
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wast
new file mode 100644
index 0000000..945e660
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/mapdir_with_leading_slash.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir_with_leading_slash.wasm"
+  (map_dirs "/hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "File exists? true\nSCENE III. A room in the castle.\n\n    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN \n\nKING CLAUDIUS\n\n    I like him not, nor stands it safe with us\n    To let his madness range. Therefore prepare you;\n    I your commission will forthwith dispatch,\n   \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wasm
new file mode 100755
index 0000000..a2d2c47
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wast
new file mode 100644
index 0000000..6beca4e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_link.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_link.wasm"
+  (map_dirs "act5:test_fs/hamlet/act5")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "ACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nPath still exists\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wasm
new file mode 100755
index 0000000..7d95d21
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wast
new file mode 100644
index 0000000..6177dda
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_rename.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_rename.wasm"
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "The original file does not still exist!\nFound item: path_renamed_file.txt\n柴犬\nThe original file does not still exist!\nFound item: path_renamed_file.txt\n柴犬\nrun_with_sub_dir: The original file does not still exist!\nrun_with_different_sub_dirs: The original file does not still exist!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wasm
new file mode 100755
index 0000000..131d882
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wast
new file mode 100644
index 0000000..111f88d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/path_symlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_symlink.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 101))
+  (assert_stderr "thread 'main' panicked at 'Could not open file: Os { code: 2, kind: NotFound, message: \"No such file or directory\" }', /Users/fs/Development/wasmer/tests/wasi-wast/wasi/tests/path_symlink.rs:21:44\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wasm
new file mode 100755
index 0000000..213ef60
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wast
new file mode 100644
index 0000000..efaa1ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/pipe_reverse.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "pipe_reverse.wasm"
+  (assert_return (i64.const 0))
+  (stdin "Hello, world!")
+  (assert_stdout "!dlrow ,olleH\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/poll_oneoff.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/poll_oneoff.wast
new file mode 100644
index 0000000..377ad03
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/poll_oneoff.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "poll_oneoff.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 101))
+  (assert_stderr "thread 'main' panicked at 'Could not open file: Os { code: 2, kind: NotFound, message: \"No such file or directory\" }', /Users/fs/Development/wasmer/tests/wasi-wast/wasi/tests/poll_oneoff.rs:155:14\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wasm
new file mode 100755
index 0000000..33cd385
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wast
new file mode 100644
index 0000000..c45d16b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/quine.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "quine.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants \n\nKING CLAUDIUS\n\n    Though yet of Hamlet our dear brother's death\n    The memory be green, and that it us befitted\n    To bear our hearts in grief and our whole kingdom\n    To be contracted in one brow of woe,\n    Yet so far hath discretion fought with nature\n    That we with wisest sorrow think on him,\n    Together with remembrance of ourselves.\n    Therefore our sometime sister, now our queen,\n    The imperial jointress to this warlike state,\n    Have we, as 'twere with a defeated joy,--\n    With an auspicious and a dropping eye,\n    With mirth in funeral and with dirge in marriage,\n    In equal scale weighing delight and dole,--\n    Taken to wife: nor have we herein barr'd\n    Your better wisdoms, which have freely gone\n    With this affair along. For all, our thanks.\n    Now follows, that you know, young Fortinbras,\n    Holding a weak supposal of our worth,\n    Or thinking by our late dear brother's death\n    Our state to be disjoint and out of frame,\n    Colleagued with the dream of his advantage,\n    He hath not fail'd to pester us with message,\n    Importing the surrender of those lands\n    Lost by his father, with all bonds of law,\n    To our most valiant brother. So much for him.\n    Now for ourself and for this time of meeting:\n    Thus much the business is: we have here writ\n    To Norway, uncle of young Fortinbras,--\n    Who, impotent and bed-rid, scarcely hears\n    Of this his nephew's purpose,--to suppress\n    His further gait herein; in that the levies,\n    The lists and full proportions, are all made\n    Out of his subject: and we here dispatch\n    You, good Cornelius, and you, Voltimand,\n    For bearers of this greeting to old Norway;\n    Giving to you no further personal power\n    To business with the king, more than the scope\n    Of these delated articles allow.\n    Farewell, and let your haste commend your duty.\n\nCORNELIUS VOLTIMAND\n\n    In that and all things will we show our duty.\n\nKING CLAUDIUS\n\n    We doubt it nothing: heartily farewell.\n\n    Exeunt VOLTIMAND and CORNELIUS\n    And now, Laertes, what's the news with you?\n    You told us of some suit; what is't, Laertes?\n    You cannot speak of reason to the Dane,\n    And loose your voice: what wouldst thou beg, Laertes,\n    That shall not be my offer, not thy asking?\n    The head is not more native to the heart,\n    The hand more instrumental to the mouth,\n    Than is the throne of Denmark to thy father.\n    What wouldst thou have, Laertes?\n\nLAERTES\n\n    My dread lord,\n    Your leave and favour to return to France;\n    From whence though willingly I came to Denmark,\n    To show my duty in your coronation,\n    Yet now, I must confess, that duty done,\n    My thoughts and wishes bend again toward France\n    And bow them to your gracious leave and pardon.\n\nKING CLAUDIUS\n\n    Have you your father's leave? What says Polonius?\n\nLORD POLONIUS\n\n    He hath, my lord, wrung from me my slow leave\n    By laboursome petition, and at last\n    Upon his will I seal'd my hard consent:\n    I do beseech you, give him leave to go.\n\nKING CLAUDIUS\n\n    Take thy fair hour, Laertes; time be thine,\n    And thy best graces spend it at thy will!\n    But now, my cousin Hamlet, and my son,--\n\nHAMLET\n\n    [Aside] A little more than kin, and less than kind.\n\nKING CLAUDIUS\n\n    How is it that the clouds still hang on you?\n\nHAMLET\n\n    Not so, my lord; I am too much i' the sun.\n\nQUEEN GERTRUDE\n\n    Good Hamlet, cast thy nighted colour off,\n    And let thine eye look like a friend on Denmark.\n    Do not for ever with thy vailed lids\n    Seek for thy noble father in the dust:\n    Thou know'st 'tis common; all that lives must die,\n    Passing through nature to eternity.\n\nHAMLET\n\n    Ay, madam, it is common.\n\nQUEEN GERTRUDE\n\n    If it be,\n    Why seems it so particular with thee?\n\nHAMLET\n\n    Seems, madam! nay it is; I know not 'seems.'\n    'Tis not alone my inky cloak, good mother,\n    Nor customary suits of solemn black,\n    Nor windy suspiration of forced breath,\n    No, nor the fruitful river in the eye,\n    Nor the dejected 'havior of the visage,\n    Together with all forms, moods, shapes of grief,\n    That can denote me truly: these indeed seem,\n    For they are actions that a man might play:\n    But I have that within which passeth show;\n    These but the trappings and the suits of woe.\n\nKING CLAUDIUS\n\n    'Tis sweet and commendable in your nature, Hamlet,\n    To give these mourning duties to your father:\n    But, you must know, your father lost a father;\n    That father lost, lost his, and the survivor bound\n    In filial obligation for some term\n    To do obsequious sorrow: but to persever\n    In obstinate condolement is a course\n    Of impious stubbornness; 'tis unmanly grief;\n    It shows a will most incorrect to heaven,\n    A heart unfortified, a mind impatient,\n    An understanding simple and unschool'd:\n    For what we know must be and is as common\n    As any the most vulgar thing to sense,\n    Why should we in our peevish opposition\n    Take it to heart? Fie! 'tis a fault to heaven,\n    A fault against the dead, a fault to nature,\n    To reason most absurd: whose common theme\n    Is death of fathers, and who still hath cried,\n    From the first corse till he that died to-day,\n    'This must be so.' We pray you, throw to earth\n    This unprevailing woe, and think of us\n    As of a father: for let the world take note,\n    You are the most immediate to our throne;\n    And with no less nobility of love\n    Than that which dearest father bears his son,\n    Do I impart toward you. For your intent\n    In going back to school in Wittenberg,\n    It is most retrograde to our desire:\n    And we beseech you, bend you to remain\n    Here, in the cheer and comfort of our eye,\n    Our chiefest courtier, cousin, and our son.\n\nQUEEN GERTRUDE\n\n    Let not thy mother lose her prayers, Hamlet:\n    I pray thee, stay with us; go not to Wittenberg.\n\nHAMLET\n\n    I shall in all my best obey you, madam.\n\nKING CLAUDIUS\n\n    Why, 'tis a loving and a fair reply:\n    Be as ourself in Denmark. Madam, come;\n    This gentle and unforced accord of Hamlet\n    Sits smiling to my heart: in grace whereof,\n    No jocund health that Denmark drinks to-day,\n    But the great cannon to the clouds shall tell,\n    And the king's rouse the heavens all bruit again,\n    Re-speaking earthly thunder. Come away.\n\n    Exeunt all but HAMLET\n\nHAMLET\n\n    O, that this too too solid flesh would melt\n    Thaw and resolve itself into a dew!\n    Or that the Everlasting had not fix'd\n    His canon 'gainst self-slaughter! O God! God!\n    How weary, stale, flat and unprofitable,\n    Seem to me all the uses of this world!\n    Fie on't! ah fie! 'tis an unweeded garden,\n    That grows to seed; things rank and gross in nature\n    Possess it merely. That it should come to this!\n    But two months dead: nay, not so much, not two:\n    So excellent a king; that was, to this,\n    Hyperion to a satyr; so loving to my mother\n    That he might not beteem the winds of heaven\n    Visit her face too roughly. Heaven and earth!\n    Must I remember? why, she would hang on him,\n    As if increase of appetite had grown\n    By what it fed on: and yet, within a month--\n    Let me not think on't--Frailty, thy name is woman!--\n    A little month, or ere those shoes were old\n    With which she follow'd my poor father's body,\n    Like Niobe, all tears:--why she, even she--\n    O, God! a beast, that wants discourse of reason,\n    Would have mourn'd longer--married with my uncle,\n    My father's brother, but no more like my father\n    Than I to Hercules: within a month:\n    Ere yet the salt of most unrighteous tears\n    Had left the flushing in her galled eyes,\n    She married. O, most wicked speed, to post\n    With such dexterity to incestuous sheets!\n    It is not nor it cannot come to good:\n    But break, my heart; for I must hold my tongue.\n\n    Enter HORATIO, MARCELLUS, and BERNARDO\n\nHORATIO\n\n    Hail to your lordship!\n\nHAMLET\n\n    I am glad to see you well:\n    Horatio,--or I do forget myself.\n\nHORATIO\n\n    The same, my lord, and your poor servant ever.\n\nHAMLET\n\n    Sir, my good friend; I'll change that name with you:\n    And what make you from Wittenberg, Horatio? Marcellus?\n\nMARCELLUS\n\n    My good lord--\n\nHAMLET\n\n    I am very glad to see you. Good even, sir.\n    But what, in faith, make you from Wittenberg?\n\nHORATIO\n\n    A truant disposition, good my lord.\n\nHAMLET\n\n    I would not hear your enemy say so,\n    Nor shall you do mine ear that violence,\n    To make it truster of your own report\n    Against yourself: I know you are no truant.\n    But what is your affair in Elsinore?\n    We'll teach you to drink deep ere you depart.\n\nHORATIO\n\n    My lord, I came to see your father's funeral.\n\nHAMLET\n\n    I pray thee, do not mock me, fellow-student;\n    I think it was to see my mother's wedding.\n\nHORATIO\n\n    Indeed, my lord, it follow'd hard upon.\n\nHAMLET\n\n    Thrift, thrift, Horatio! the funeral baked meats\n    Did coldly furnish forth the marriage tables.\n    Would I had met my dearest foe in heaven\n    Or ever I had seen that day, Horatio!\n    My father!--methinks I see my father.\n\nHORATIO\n\n    Where, my lord?\n\nHAMLET\n\n    In my mind's eye, Horatio.\n\nHORATIO\n\n    I saw him once; he was a goodly king.\n\nHAMLET\n\n    He was a man, take him for all in all,\n    I shall not look upon his like again.\n\nHORATIO\n\n    My lord, I think I saw him yesternight.\n\nHAMLET\n\n    Saw? who?\n\nHORATIO\n\n    My lord, the king your father.\n\nHAMLET\n\n    The king my father!\n\nHORATIO\n\n    Season your admiration for awhile\n    With an attent ear, till I may deliver,\n    Upon the witness of these gentlemen,\n    This marvel to you.\n\nHAMLET\n\n    For God's love, let me hear.\n\nHORATIO\n\n    Two nights together had these gentlemen,\n    Marcellus and Bernardo, on their watch,\n    In the dead vast and middle of the night,\n    Been thus encounter'd. A figure like your father,\n    Armed at point exactly, cap-a-pe,\n    Appears before them, and with solemn march\n    Goes slow and stately by them: thrice he walk'd\n    By their oppress'd and fear-surprised eyes,\n    Within his truncheon's length; whilst they, distilled\n    Almost to jelly with the act of fear,\n    Stand dumb and speak not to him. This to me\n    In dreadful secrecy impart they did;\n    And I with them the third night kept the watch;\n    Where, as they had deliver'd, both in time,\n    Form of the thing, each word made true and good,\n    The apparition comes: I knew your father;\n    These hands are not more like.\n\nHAMLET\n\n    But where was this?\n\nMARCELLUS\n\n    My lord, upon the platform where we watch'd.\n\nHAMLET\n\n    Did you not speak to it?\n\nHORATIO\n\n    My lord, I did;\n    But answer made it none: yet once methought\n    It lifted up its head and did address\n    Itself to motion, like as it would speak;\n    But even then the morning cock crew loud,\n    And at the sound it shrunk in haste away,\n    And vanish'd from our sight.\n\nHAMLET\n\n    'Tis very strange.\n\nHORATIO\n\n    As I do live, my honour'd lord, 'tis true;\n    And we did think it writ down in our duty\n    To let you know of it.\n\nHAMLET\n\n    Indeed, indeed, sirs, but this troubles me.\n    Hold you the watch to-night?\n\nMARCELLUS BERNARDO\n\n    We do, my lord.\n\nHAMLET\n\n    Arm'd, say you?\n\nMARCELLUS BERNARDO\n\n    Arm'd, my lord.\n\nHAMLET\n\n    From top to toe?\n\nMARCELLUS BERNARDO\n\n    My lord, from head to foot.\n\nHAMLET\n\n    Then saw you not his face?\n\nHORATIO\n\n    O, yes, my lord; he wore his beaver up.\n\nHAMLET\n\n    What, look'd he frowningly?\n\nHORATIO\n\n    A countenance more in sorrow than in anger.\n\nHAMLET\n\n    Pale or red?\n\nHORATIO\n\n    Nay, very pale.\n\nHAMLET\n\n    And fix'd his eyes upon you?\n\nHORATIO\n\n    Most constantly.\n\nHAMLET\n\n    I would I had been there.\n\nHORATIO\n\n    It would have much amazed you.\n\nHAMLET\n\n    Very like, very like. Stay'd it long?\n\nHORATIO\n\n    While one with moderate haste might tell a hundred.\n\nMARCELLUS BERNARDO\n\n    Longer, longer.\n\nHORATIO\n\n    Not when I saw't.\n\nHAMLET\n\n    His beard was grizzled--no?\n\nHORATIO\n\n    It was, as I have seen it in his life,\n    A sable silver'd.\n\nHAMLET\n\n    I will watch to-night;\n    Perchance 'twill walk again.\n\nHORATIO\n\n    I warrant it will.\n\nHAMLET\n\n    If it assume my noble father's person,\n    I'll speak to it, though hell itself should gape\n    And bid me hold my peace. I pray you all,\n    If you have hitherto conceal'd this sight,\n    Let it be tenable in your silence still;\n    And whatsoever else shall hap to-night,\n    Give it an understanding, but no tongue:\n    I will requite your loves. So, fare you well:\n    Upon the platform, 'twixt eleven and twelve,\n    I'll visit you.\n\nAll\n\n    Our duty to your honour.\n\nHAMLET\n\n    Your loves, as mine to you: farewell.\n\n    Exeunt all but HAMLET\n    My father's spirit in arms! all is not well;\n    I doubt some foul play: would the night were come!\n    Till then sit still, my soul: foul deeds will rise,\n    Though all the earth o'erwhelm them, to men's eyes.\n\n    Exit\n\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wasm
new file mode 100755
index 0000000..fbc408f
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wast
new file mode 100644
index 0000000..6eb1ffc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/readlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "readlink.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "true\n../act1/scene2.txt\nSCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELI\n")
+  (assert_stderr "[/Users/fs/Development/wasmer/tests/wasi-wast/wasi/tests/readlink.rs:10] &p = \"test_fs/hamlet/bookmarks/2019-07-16\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wasm
new file mode 100755
index 0000000..785bf2d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wast
new file mode 100644
index 0000000..7da0c83
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/unix_open_special_files.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "unix_open_special_files.wasm"
+  (map_dirs "/dev:/dev")
+  (assert_return (i64.const 0))
+  (assert_stdout "13\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wasm
new file mode 100755
index 0000000..6a7cab0
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wast
new file mode 100644
index 0000000..c60fa5f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/wasi_sees_virtual_root.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "wasi_sees_virtual_root.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\nROOT IS SAFE\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wasm
new file mode 100755
index 0000000..b8596fb
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wast
new file mode 100644
index 0000000..3835a25
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/nightly_2022_10_18/writing.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "writing.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "abcdefghijklmnopqrstuvwxyz\nfile is gone\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wasm
new file mode 100755
index 0000000..01ba842
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast
new file mode 100644
index 0000000..65dda3b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/close_preopen_fd.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "close_preopen_fd.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wasm
new file mode 100755
index 0000000..58db120
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wast
new file mode 100644
index 0000000..7722640
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/create_dir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "create_dir.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "Test file exists: false\nDir exists: false\nDir exists: false\nDir exists: false\nSuccess\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wasm
new file mode 100755
index 0000000..e87eacd
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wast
new file mode 100644
index 0000000..fbfe0b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/envvar.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "envvar.wasm"
+  (envs "DOG=1" "CAT=2")
+  (assert_return (i64.const 0))
+  (assert_stdout "Env vars:\nCAT=2\nDOG=1\nDOG Ok(\"1\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wasm
new file mode 100755
index 0000000..45a263c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wast
new file mode 100644
index 0000000..784294e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_allocate.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_allocate.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "171\n1405\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wasm
new file mode 100755
index 0000000..14b7c43
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wast
new file mode 100644
index 0000000..1c973ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_append.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_append.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"Hello, world!\\nGoodbye, world!\\n\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wasm
new file mode 100755
index 0000000..6206f3e
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wast
new file mode 100644
index 0000000..82dc9d5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_close.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_close.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "Successfully closed file!\nSuccessfully closed stderr!\nSuccessfully closed stdin!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wasm
new file mode 100755
index 0000000..ea206a1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wast
new file mode 100644
index 0000000..d320f87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_pread.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_pread.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout " POLONIUS\n\n    He will come straight. Look you lay home to him:\n\n POLONIUS\n\n    He will come straight. Look you lay home to him:\n\nRead the same data? true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wasm
new file mode 100755
index 0000000..59a4e46
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wast
new file mode 100644
index 0000000..70f4acf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_read.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_read.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE IV. The Queen\'s closet.\n\n    Enter QUEEN GERTRUDE and POLO\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wasm
new file mode 100755
index 0000000..f455c64
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wast
new file mode 100644
index 0000000..fd3e597
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_rename_path.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_rename_path.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wasm
new file mode 100755
index 0000000..9dd375b
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wast
new file mode 100644
index 0000000..ad592f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fd_sync.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_sync.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "170\n1404\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wasm
new file mode 100755
index 0000000..051af74
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wast
new file mode 100644
index 0000000..7761ef1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/file_metadata.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "file_metadata.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "is dir: false\nfiletype: false true false\nfile info: 8866\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wasm
new file mode 100755
index 0000000..00c5211
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wast
new file mode 100644
index 0000000..4574470
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fs_sandbox_test.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fs_sandbox_test.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Reading the parent directory was okay? false\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wasm
new file mode 100755
index 0000000..5588844
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wast
new file mode 100644
index 0000000..fb4c1b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/fseek.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fseek.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE III. A room in Polonius\' h\nouse.\n\n    Enter LAERTES and OPH\n    And, sister, as the winds gi\nr talk with the Lord Hamlet.\n   \nuits,\n    Breathing like sanctif\nis is for all:\n    I would not, \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wasm
new file mode 100755
index 0000000..32472f9
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wast
new file mode 100644
index 0000000..55885a8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/hello.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "hello.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Hello, world!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wasm
new file mode 100755
index 0000000..6812260
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wast
new file mode 100644
index 0000000..c7eec7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/inode.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "inode.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "all done\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wasm
new file mode 100755
index 0000000..378d8e5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wast
new file mode 100644
index 0000000..c33255a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/isatty.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "isatty.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "stdin: 1\nstdout: 1\nstderr: 1\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wasm
new file mode 100755
index 0000000..1e4351c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wast
new file mode 100644
index 0000000..4808a8e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"./README.md\"\n\"./act1\"\n\"./act2\"\n\"./act3\"\n\"./act4\"\n\"./act5\"\n\"./bookmarks\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wasm
new file mode 100755
index 0000000..6ac9ee8
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wast
new file mode 100644
index 0000000..945e660
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/mapdir_with_leading_slash.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir_with_leading_slash.wasm"
+  (map_dirs "/hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "File exists? true\nSCENE III. A room in the castle.\n\n    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN \n\nKING CLAUDIUS\n\n    I like him not, nor stands it safe with us\n    To let his madness range. Therefore prepare you;\n    I your commission will forthwith dispatch,\n   \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wasm
new file mode 100755
index 0000000..d3e4d85
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wast
new file mode 100644
index 0000000..6beca4e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_link.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_link.wasm"
+  (map_dirs "act5:test_fs/hamlet/act5")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "ACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nPath still exists\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wasm
new file mode 100755
index 0000000..ddddfcc
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wast
new file mode 100644
index 0000000..6177dda
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_rename.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_rename.wasm"
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "The original file does not still exist!\nFound item: path_renamed_file.txt\n柴犬\nThe original file does not still exist!\nFound item: path_renamed_file.txt\n柴犬\nrun_with_sub_dir: The original file does not still exist!\nrun_with_different_sub_dirs: The original file does not still exist!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wasm
new file mode 100755
index 0000000..59765ff
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wast
new file mode 100644
index 0000000..b80fb88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/path_symlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_symlink.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "ACT III\nSCENE I. A room in the castle.\n\n    Enter KING CLAUDIUS,\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wasm
new file mode 100755
index 0000000..6b996a1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wast
new file mode 100644
index 0000000..efaa1ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/pipe_reverse.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "pipe_reverse.wasm"
+  (assert_return (i64.const 0))
+  (stdin "Hello, world!")
+  (assert_stdout "!dlrow ,olleH\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wasm
new file mode 100755
index 0000000..112ad10
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wast
new file mode 100644
index 0000000..ebac877
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/poll_oneoff.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "poll_oneoff.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }\n[__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }, __wasi_event_t { userdata: 1193046, error: 0, type_: 2, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 1234, flags: 0 } } }]\nStdin: OK\nStdout: OK\nStderr: OK\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wasm
new file mode 100755
index 0000000..049d225
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wast
new file mode 100644
index 0000000..26d4c41
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/quine.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "quine.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants \n\nKING CLAUDIUS\n\n    Though yet of Hamlet our dear brother\'s death\n    The memory be green, and that it us befitted\n    To bear our hearts in grief and our whole kingdom\n    To be contracted in one brow of woe,\n    Yet so far hath discretion fought with nature\n    That we with wisest sorrow think on him,\n    Together with remembrance of ourselves.\n    Therefore our sometime sister, now our queen,\n    The imperial jointress to this warlike state,\n    Have we, as \'twere with a defeated joy,--\n    With an auspicious and a dropping eye,\n    With mirth in funeral and with dirge in marriage,\n    In equal scale weighing delight and dole,--\n    Taken to wife: nor have we herein barr\'d\n    Your better wisdoms, which have freely gone\n    With this affair along. For all, our thanks.\n    Now follows, that you know, young Fortinbras,\n    Holding a weak supposal of our worth,\n    Or thinking by our late dear brother\'s death\n    Our state to be disjoint and out of frame,\n    Colleagued with the dream of his advantage,\n    He hath not fail\'d to pester us with message,\n    Importing the surrender of those lands\n    Lost by his father, with all bonds of law,\n    To our most valiant brother. So much for him.\n    Now for ourself and for this time of meeting:\n    Thus much the business is: we have here writ\n    To Norway, uncle of young Fortinbras,--\n    Who, impotent and bed-rid, scarcely hears\n    Of this his nephew\'s purpose,--to suppress\n    His further gait herein; in that the levies,\n    The lists and full proportions, are all made\n    Out of his subject: and we here dispatch\n    You, good Cornelius, and you, Voltimand,\n    For bearers of this greeting to old Norway;\n    Giving to you no further personal power\n    To business with the king, more than the scope\n    Of these delated articles allow.\n    Farewell, and let your haste commend your duty.\n\nCORNELIUS VOLTIMAND\n\n    In that and all things will we show our duty.\n\nKING CLAUDIUS\n\n    We doubt it nothing: heartily farewell.\n\n    Exeunt VOLTIMAND and CORNELIUS\n    And now, Laertes, what\'s the news with you?\n    You told us of some suit; what is\'t, Laertes?\n    You cannot speak of reason to the Dane,\n    And loose your voice: what wouldst thou beg, Laertes,\n    That shall not be my offer, not thy asking?\n    The head is not more native to the heart,\n    The hand more instrumental to the mouth,\n    Than is the throne of Denmark to thy father.\n    What wouldst thou have, Laertes?\n\nLAERTES\n\n    My dread lord,\n    Your leave and favour to return to France;\n    From whence though willingly I came to Denmark,\n    To show my duty in your coronation,\n    Yet now, I must confess, that duty done,\n    My thoughts and wishes bend again toward France\n    And bow them to your gracious leave and pardon.\n\nKING CLAUDIUS\n\n    Have you your father\'s leave? What says Polonius?\n\nLORD POLONIUS\n\n    He hath, my lord, wrung from me my slow leave\n    By laboursome petition, and at last\n    Upon his will I seal\'d my hard consent:\n    I do beseech you, give him leave to go.\n\nKING CLAUDIUS\n\n    Take thy fair hour, Laertes; time be thine,\n    And thy best graces spend it at thy will!\n    But now, my cousin Hamlet, and my son,--\n\nHAMLET\n\n    [Aside] A little more than kin, and less than kind.\n\nKING CLAUDIUS\n\n    How is it that the clouds still hang on you?\n\nHAMLET\n\n    Not so, my lord; I am too much i\' the sun.\n\nQUEEN GERTRUDE\n\n    Good Hamlet, cast thy nighted colour off,\n    And let thine eye look like a friend on Denmark.\n    Do not for ever with thy vailed lids\n    Seek for thy noble father in the dust:\n    Thou know\'st \'tis common; all that lives must die,\n    Passing through nature to eternity.\n\nHAMLET\n\n    Ay, madam, it is common.\n\nQUEEN GERTRUDE\n\n    If it be,\n    Why seems it so particular with thee?\n\nHAMLET\n\n    Seems, madam! nay it is; I know not \'seems.\'\n    \'Tis not alone my inky cloak, good mother,\n    Nor customary suits of solemn black,\n    Nor windy suspiration of forced breath,\n    No, nor the fruitful river in the eye,\n    Nor the dejected \'havior of the visage,\n    Together with all forms, moods, shapes of grief,\n    That can denote me truly: these indeed seem,\n    For they are actions that a man might play:\n    But I have that within which passeth show;\n    These but the trappings and the suits of woe.\n\nKING CLAUDIUS\n\n    \'Tis sweet and commendable in your nature, Hamlet,\n    To give these mourning duties to your father:\n    But, you must know, your father lost a father;\n    That father lost, lost his, and the survivor bound\n    In filial obligation for some term\n    To do obsequious sorrow: but to persever\n    In obstinate condolement is a course\n    Of impious stubbornness; \'tis unmanly grief;\n    It shows a will most incorrect to heaven,\n    A heart unfortified, a mind impatient,\n    An understanding simple and unschool\'d:\n    For what we know must be and is as common\n    As any the most vulgar thing to sense,\n    Why should we in our peevish opposition\n    Take it to heart? Fie! \'tis a fault to heaven,\n    A fault against the dead, a fault to nature,\n    To reason most absurd: whose common theme\n    Is death of fathers, and who still hath cried,\n    From the first corse till he that died to-day,\n    \'This must be so.\' We pray you, throw to earth\n    This unprevailing woe, and think of us\n    As of a father: for let the world take note,\n    You are the most immediate to our throne;\n    And with no less nobility of love\n    Than that which dearest father bears his son,\n    Do I impart toward you. For your intent\n    In going back to school in Wittenberg,\n    It is most retrograde to our desire:\n    And we beseech you, bend you to remain\n    Here, in the cheer and comfort of our eye,\n    Our chiefest courtier, cousin, and our son.\n\nQUEEN GERTRUDE\n\n    Let not thy mother lose her prayers, Hamlet:\n    I pray thee, stay with us; go not to Wittenberg.\n\nHAMLET\n\n    I shall in all my best obey you, madam.\n\nKING CLAUDIUS\n\n    Why, \'tis a loving and a fair reply:\n    Be as ourself in Denmark. Madam, come;\n    This gentle and unforced accord of Hamlet\n    Sits smiling to my heart: in grace whereof,\n    No jocund health that Denmark drinks to-day,\n    But the great cannon to the clouds shall tell,\n    And the king\'s rouse the heavens all bruit again,\n    Re-speaking earthly thunder. Come away.\n\n    Exeunt all but HAMLET\n\nHAMLET\n\n    O, that this too too solid flesh would melt\n    Thaw and resolve itself into a dew!\n    Or that the Everlasting had not fix\'d\n    His canon \'gainst self-slaughter! O God! God!\n    How weary, stale, flat and unprofitable,\n    Seem to me all the uses of this world!\n    Fie on\'t! ah fie! \'tis an unweeded garden,\n    That grows to seed; things rank and gross in nature\n    Possess it merely. That it should come to this!\n    But two months dead: nay, not so much, not two:\n    So excellent a king; that was, to this,\n    Hyperion to a satyr; so loving to my mother\n    That he might not beteem the winds of heaven\n    Visit her face too roughly. Heaven and earth!\n    Must I remember? why, she would hang on him,\n    As if increase of appetite had grown\n    By what it fed on: and yet, within a month--\n    Let me not think on\'t--Frailty, thy name is woman!--\n    A little month, or ere those shoes were old\n    With which she follow\'d my poor father\'s body,\n    Like Niobe, all tears:--why she, even she--\n    O, God! a beast, that wants discourse of reason,\n    Would have mourn\'d longer--married with my uncle,\n    My father\'s brother, but no more like my father\n    Than I to Hercules: within a month:\n    Ere yet the salt of most unrighteous tears\n    Had left the flushing in her galled eyes,\n    She married. O, most wicked speed, to post\n    With such dexterity to incestuous sheets!\n    It is not nor it cannot come to good:\n    But break, my heart; for I must hold my tongue.\n\n    Enter HORATIO, MARCELLUS, and BERNARDO\n\nHORATIO\n\n    Hail to your lordship!\n\nHAMLET\n\n    I am glad to see you well:\n    Horatio,--or I do forget myself.\n\nHORATIO\n\n    The same, my lord, and your poor servant ever.\n\nHAMLET\n\n    Sir, my good friend; I\'ll change that name with you:\n    And what make you from Wittenberg, Horatio? Marcellus?\n\nMARCELLUS\n\n    My good lord--\n\nHAMLET\n\n    I am very glad to see you. Good even, sir.\n    But what, in faith, make you from Wittenberg?\n\nHORATIO\n\n    A truant disposition, good my lord.\n\nHAMLET\n\n    I would not hear your enemy say so,\n    Nor shall you do mine ear that violence,\n    To make it truster of your own report\n    Against yourself: I know you are no truant.\n    But what is your affair in Elsinore?\n    We\'ll teach you to drink deep ere you depart.\n\nHORATIO\n\n    My lord, I came to see your father\'s funeral.\n\nHAMLET\n\n    I pray thee, do not mock me, fellow-student;\n    I think it was to see my mother\'s wedding.\n\nHORATIO\n\n    Indeed, my lord, it follow\'d hard upon.\n\nHAMLET\n\n    Thrift, thrift, Horatio! the funeral baked meats\n    Did coldly furnish forth the marriage tables.\n    Would I had met my dearest foe in heaven\n    Or ever I had seen that day, Horatio!\n    My father!--methinks I see my father.\n\nHORATIO\n\n    Where, my lord?\n\nHAMLET\n\n    In my mind\'s eye, Horatio.\n\nHORATIO\n\n    I saw him once; he was a goodly king.\n\nHAMLET\n\n    He was a man, take him for all in all,\n    I shall not look upon his like again.\n\nHORATIO\n\n    My lord, I think I saw him yesternight.\n\nHAMLET\n\n    Saw? who?\n\nHORATIO\n\n    My lord, the king your father.\n\nHAMLET\n\n    The king my father!\n\nHORATIO\n\n    Season your admiration for awhile\n    With an attent ear, till I may deliver,\n    Upon the witness of these gentlemen,\n    This marvel to you.\n\nHAMLET\n\n    For God\'s love, let me hear.\n\nHORATIO\n\n    Two nights together had these gentlemen,\n    Marcellus and Bernardo, on their watch,\n    In the dead vast and middle of the night,\n    Been thus encounter\'d. A figure like your father,\n    Armed at point exactly, cap-a-pe,\n    Appears before them, and with solemn march\n    Goes slow and stately by them: thrice he walk\'d\n    By their oppress\'d and fear-surprised eyes,\n    Within his truncheon\'s length; whilst they, distilled\n    Almost to jelly with the act of fear,\n    Stand dumb and speak not to him. This to me\n    In dreadful secrecy impart they did;\n    And I with them the third night kept the watch;\n    Where, as they had deliver\'d, both in time,\n    Form of the thing, each word made true and good,\n    The apparition comes: I knew your father;\n    These hands are not more like.\n\nHAMLET\n\n    But where was this?\n\nMARCELLUS\n\n    My lord, upon the platform where we watch\'d.\n\nHAMLET\n\n    Did you not speak to it?\n\nHORATIO\n\n    My lord, I did;\n    But answer made it none: yet once methought\n    It lifted up its head and did address\n    Itself to motion, like as it would speak;\n    But even then the morning cock crew loud,\n    And at the sound it shrunk in haste away,\n    And vanish\'d from our sight.\n\nHAMLET\n\n    \'Tis very strange.\n\nHORATIO\n\n    As I do live, my honour\'d lord, \'tis true;\n    And we did think it writ down in our duty\n    To let you know of it.\n\nHAMLET\n\n    Indeed, indeed, sirs, but this troubles me.\n    Hold you the watch to-night?\n\nMARCELLUS BERNARDO\n\n    We do, my lord.\n\nHAMLET\n\n    Arm\'d, say you?\n\nMARCELLUS BERNARDO\n\n    Arm\'d, my lord.\n\nHAMLET\n\n    From top to toe?\n\nMARCELLUS BERNARDO\n\n    My lord, from head to foot.\n\nHAMLET\n\n    Then saw you not his face?\n\nHORATIO\n\n    O, yes, my lord; he wore his beaver up.\n\nHAMLET\n\n    What, look\'d he frowningly?\n\nHORATIO\n\n    A countenance more in sorrow than in anger.\n\nHAMLET\n\n    Pale or red?\n\nHORATIO\n\n    Nay, very pale.\n\nHAMLET\n\n    And fix\'d his eyes upon you?\n\nHORATIO\n\n    Most constantly.\n\nHAMLET\n\n    I would I had been there.\n\nHORATIO\n\n    It would have much amazed you.\n\nHAMLET\n\n    Very like, very like. Stay\'d it long?\n\nHORATIO\n\n    While one with moderate haste might tell a hundred.\n\nMARCELLUS BERNARDO\n\n    Longer, longer.\n\nHORATIO\n\n    Not when I saw\'t.\n\nHAMLET\n\n    His beard was grizzled--no?\n\nHORATIO\n\n    It was, as I have seen it in his life,\n    A sable silver\'d.\n\nHAMLET\n\n    I will watch to-night;\n    Perchance \'twill walk again.\n\nHORATIO\n\n    I warrant it will.\n\nHAMLET\n\n    If it assume my noble father\'s person,\n    I\'ll speak to it, though hell itself should gape\n    And bid me hold my peace. I pray you all,\n    If you have hitherto conceal\'d this sight,\n    Let it be tenable in your silence still;\n    And whatsoever else shall hap to-night,\n    Give it an understanding, but no tongue:\n    I will requite your loves. So, fare you well:\n    Upon the platform, \'twixt eleven and twelve,\n    I\'ll visit you.\n\nAll\n\n    Our duty to your honour.\n\nHAMLET\n\n    Your loves, as mine to you: farewell.\n\n    Exeunt all but HAMLET\n    My father\'s spirit in arms! all is not well;\n    I doubt some foul play: would the night were come!\n    Till then sit still, my soul: foul deeds will rise,\n    Though all the earth o\'erwhelm them, to men\'s eyes.\n\n    Exit\n\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wasm
new file mode 100755
index 0000000..aa9803a
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wast
new file mode 100644
index 0000000..02b642d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/readlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "readlink.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "true\n../act1/scene2.txt\nSCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELI\n")
+  (assert_stderr "[/Users/mark/wasi-tests/wasi/tests/readlink.rs:10] &p = \"test_fs/hamlet/bookmarks/2019-07-16\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wasm
new file mode 100755
index 0000000..ba4c713
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wast
new file mode 100644
index 0000000..7da0c83
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/unix_open_special_files.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "unix_open_special_files.wasm"
+  (map_dirs "/dev:/dev")
+  (assert_return (i64.const 0))
+  (assert_stdout "13\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wasm
new file mode 100755
index 0000000..f7041a5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wast
new file mode 100644
index 0000000..c60fa5f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/wasi_sees_virtual_root.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "wasi_sees_virtual_root.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\nROOT IS SAFE\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wasm
new file mode 100755
index 0000000..e15eddf
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wast
new file mode 100644
index 0000000..3835a25
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/snapshot1/writing.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "writing.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "abcdefghijklmnopqrstuvwxyz\nfile is gone\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/README.md
new file mode 100644
index 0000000..3384bc2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/README.md
@@ -0,0 +1,9 @@
+# Test FS
+
+This is a test "file system" used in some of the WASI integration tests.
+
+It's just a bunch of files in a tree.
+
+If you make changes here, please regenerate the tests with `make wasitests`!
+
+The contents of `temp` are deleted before each run.  If you want to test making or mutating files, do it in that sub directory.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/README.md
new file mode 100644
index 0000000..6b96137
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/README.md
@@ -0,0 +1,3 @@
+# Hamlet split in to acts and scenes
+
+From: http://shakespeare.mit.edu/hamlet/full.html
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene1.txt
new file mode 100644
index 0000000..0e0b797
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene1.txt
@@ -0,0 +1,392 @@
+
+The Tragedy of Hamlet, Prince of Denmark
+Shakespeare homepage | Hamlet | Entire play
+ACT I
+SCENE I. Elsinore. A platform before the castle.
+
+    FRANCISCO at his post. Enter to him BERNARDO 
+
+BERNARDO
+
+    Who's there?
+
+FRANCISCO
+
+    Nay, answer me: stand, and unfold yourself.
+
+BERNARDO
+
+    Long live the king!
+
+FRANCISCO
+
+    Bernardo?
+
+BERNARDO
+
+    He.
+
+FRANCISCO
+
+    You come most carefully upon your hour.
+
+BERNARDO
+
+    'Tis now struck twelve; get thee to bed, Francisco.
+
+FRANCISCO
+
+    For this relief much thanks: 'tis bitter cold,
+    And I am sick at heart.
+
+BERNARDO
+
+    Have you had quiet guard?
+
+FRANCISCO
+
+    Not a mouse stirring.
+
+BERNARDO
+
+    Well, good night.
+    If you do meet Horatio and Marcellus,
+    The rivals of my watch, bid them make haste.
+
+FRANCISCO
+
+    I think I hear them. Stand, ho! Who's there?
+
+    Enter HORATIO and MARCELLUS
+
+HORATIO
+
+    Friends to this ground.
+
+MARCELLUS
+
+    And liegemen to the Dane.
+
+FRANCISCO
+
+    Give you good night.
+
+MARCELLUS
+
+    O, farewell, honest soldier:
+    Who hath relieved you?
+
+FRANCISCO
+
+    Bernardo has my place.
+    Give you good night.
+
+    Exit
+
+MARCELLUS
+
+    Holla! Bernardo!
+
+BERNARDO
+
+    Say,
+    What, is Horatio there?
+
+HORATIO
+
+    A piece of him.
+
+BERNARDO
+
+    Welcome, Horatio: welcome, good Marcellus.
+
+MARCELLUS
+
+    What, has this thing appear'd again to-night?
+
+BERNARDO
+
+    I have seen nothing.
+
+MARCELLUS
+
+    Horatio says 'tis but our fantasy,
+    And will not let belief take hold of him
+    Touching this dreaded sight, twice seen of us:
+    Therefore I have entreated him along
+    With us to watch the minutes of this night;
+    That if again this apparition come,
+    He may approve our eyes and speak to it.
+
+HORATIO
+
+    Tush, tush, 'twill not appear.
+
+BERNARDO
+
+    Sit down awhile;
+    And let us once again assail your ears,
+    That are so fortified against our story
+    What we have two nights seen.
+
+HORATIO
+
+    Well, sit we down,
+    And let us hear Bernardo speak of this.
+
+BERNARDO
+
+    Last night of all,
+    When yond same star that's westward from the pole
+    Had made his course to illume that part of heaven
+    Where now it burns, Marcellus and myself,
+    The bell then beating one,--
+
+    Enter Ghost
+
+MARCELLUS
+
+    Peace, break thee off; look, where it comes again!
+
+BERNARDO
+
+    In the same figure, like the king that's dead.
+
+MARCELLUS
+
+    Thou art a scholar; speak to it, Horatio.
+
+BERNARDO
+
+    Looks it not like the king? mark it, Horatio.
+
+HORATIO
+
+    Most like: it harrows me with fear and wonder.
+
+BERNARDO
+
+    It would be spoke to.
+
+MARCELLUS
+
+    Question it, Horatio.
+
+HORATIO
+
+    What art thou that usurp'st this time of night,
+    Together with that fair and warlike form
+    In which the majesty of buried Denmark
+    Did sometimes march? by heaven I charge thee, speak!
+
+MARCELLUS
+
+    It is offended.
+
+BERNARDO
+
+    See, it stalks away!
+
+HORATIO
+
+    Stay! speak, speak! I charge thee, speak!
+
+    Exit Ghost
+
+MARCELLUS
+
+    'Tis gone, and will not answer.
+
+BERNARDO
+
+    How now, Horatio! you tremble and look pale:
+    Is not this something more than fantasy?
+    What think you on't?
+
+HORATIO
+
+    Before my God, I might not this believe
+    Without the sensible and true avouch
+    Of mine own eyes.
+
+MARCELLUS
+
+    Is it not like the king?
+
+HORATIO
+
+    As thou art to thyself:
+    Such was the very armour he had on
+    When he the ambitious Norway combated;
+    So frown'd he once, when, in an angry parle,
+    He smote the sledded Polacks on the ice.
+    'Tis strange.
+
+MARCELLUS
+
+    Thus twice before, and jump at this dead hour,
+    With martial stalk hath he gone by our watch.
+
+HORATIO
+
+    In what particular thought to work I know not;
+    But in the gross and scope of my opinion,
+    This bodes some strange eruption to our state.
+
+MARCELLUS
+
+    Good now, sit down, and tell me, he that knows,
+    Why this same strict and most observant watch
+    So nightly toils the subject of the land,
+    And why such daily cast of brazen cannon,
+    And foreign mart for implements of war;
+    Why such impress of shipwrights, whose sore task
+    Does not divide the Sunday from the week;
+    What might be toward, that this sweaty haste
+    Doth make the night joint-labourer with the day:
+    Who is't that can inform me?
+
+HORATIO
+
+    That can I;
+    At least, the whisper goes so. Our last king,
+    Whose image even but now appear'd to us,
+    Was, as you know, by Fortinbras of Norway,
+    Thereto prick'd on by a most emulate pride,
+    Dared to the combat; in which our valiant Hamlet--
+    For so this side of our known world esteem'd him--
+    Did slay this Fortinbras; who by a seal'd compact,
+    Well ratified by law and heraldry,
+    Did forfeit, with his life, all those his lands
+    Which he stood seized of, to the conqueror:
+    Against the which, a moiety competent
+    Was gaged by our king; which had return'd
+    To the inheritance of Fortinbras,
+    Had he been vanquisher; as, by the same covenant,
+    And carriage of the article design'd,
+    His fell to Hamlet. Now, sir, young Fortinbras,
+    Of unimproved mettle hot and full,
+    Hath in the skirts of Norway here and there
+    Shark'd up a list of lawless resolutes,
+    For food and diet, to some enterprise
+    That hath a stomach in't; which is no other--
+    As it doth well appear unto our state--
+    But to recover of us, by strong hand
+    And terms compulsatory, those foresaid lands
+    So by his father lost: and this, I take it,
+    Is the main motive of our preparations,
+    The source of this our watch and the chief head
+    Of this post-haste and romage in the land.
+
+BERNARDO
+
+    I think it be no other but e'en so:
+    Well may it sort that this portentous figure
+    Comes armed through our watch; so like the king
+    That was and is the question of these wars.
+
+HORATIO
+
+    A mote it is to trouble the mind's eye.
+    In the most high and palmy state of Rome,
+    A little ere the mightiest Julius fell,
+    The graves stood tenantless and the sheeted dead
+    Did squeak and gibber in the Roman streets:
+    As stars with trains of fire and dews of blood,
+    Disasters in the sun; and the moist star
+    Upon whose influence Neptune's empire stands
+    Was sick almost to doomsday with eclipse:
+    And even the like precurse of fierce events,
+    As harbingers preceding still the fates
+    And prologue to the omen coming on,
+    Have heaven and earth together demonstrated
+    Unto our climatures and countrymen.--
+    But soft, behold! lo, where it comes again!
+
+    Re-enter Ghost
+    I'll cross it, though it blast me. Stay, illusion!
+    If thou hast any sound, or use of voice,
+    Speak to me:
+    If there be any good thing to be done,
+    That may to thee do ease and grace to me,
+    Speak to me:
+
+    Cock crows
+    If thou art privy to thy country's fate,
+    Which, happily, foreknowing may avoid, O, speak!
+    Or if thou hast uphoarded in thy life
+    Extorted treasure in the womb of earth,
+    For which, they say, you spirits oft walk in death,
+    Speak of it: stay, and speak! Stop it, Marcellus.
+
+MARCELLUS
+
+    Shall I strike at it with my partisan?
+
+HORATIO
+
+    Do, if it will not stand.
+
+BERNARDO
+
+    'Tis here!
+
+HORATIO
+
+    'Tis here!
+
+MARCELLUS
+
+    'Tis gone!
+
+    Exit Ghost
+    We do it wrong, being so majestical,
+    To offer it the show of violence;
+    For it is, as the air, invulnerable,
+    And our vain blows malicious mockery.
+
+BERNARDO
+
+    It was about to speak, when the cock crew.
+
+HORATIO
+
+    And then it started like a guilty thing
+    Upon a fearful summons. I have heard,
+    The cock, that is the trumpet to the morn,
+    Doth with his lofty and shrill-sounding throat
+    Awake the god of day; and, at his warning,
+    Whether in sea or fire, in earth or air,
+    The extravagant and erring spirit hies
+    To his confine: and of the truth herein
+    This present object made probation.
+
+MARCELLUS
+
+    It faded on the crowing of the cock.
+    Some say that ever 'gainst that season comes
+    Wherein our Saviour's birth is celebrated,
+    The bird of dawning singeth all night long:
+    And then, they say, no spirit dares stir abroad;
+    The nights are wholesome; then no planets strike,
+    No fairy takes, nor witch hath power to charm,
+    So hallow'd and so gracious is the time.
+
+HORATIO
+
+    So have I heard and do in part believe it.
+    But, look, the morn, in russet mantle clad,
+    Walks o'er the dew of yon high eastward hill:
+    Break we our watch up; and by my advice,
+    Let us impart what we have seen to-night
+    Unto young Hamlet; for, upon my life,
+    This spirit, dumb to us, will speak to him.
+    Do you consent we shall acquaint him with it,
+    As needful in our loves, fitting our duty?
+
+MARCELLUS
+
+    Let's do't, I pray; and I this morning know
+    Where we shall find him most conveniently.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene2.txt
new file mode 100644
index 0000000..4b1ec1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene2.txt
@@ -0,0 +1,512 @@
+SCENE II. A room of state in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants 
+
+KING CLAUDIUS
+
+    Though yet of Hamlet our dear brother's death
+    The memory be green, and that it us befitted
+    To bear our hearts in grief and our whole kingdom
+    To be contracted in one brow of woe,
+    Yet so far hath discretion fought with nature
+    That we with wisest sorrow think on him,
+    Together with remembrance of ourselves.
+    Therefore our sometime sister, now our queen,
+    The imperial jointress to this warlike state,
+    Have we, as 'twere with a defeated joy,--
+    With an auspicious and a dropping eye,
+    With mirth in funeral and with dirge in marriage,
+    In equal scale weighing delight and dole,--
+    Taken to wife: nor have we herein barr'd
+    Your better wisdoms, which have freely gone
+    With this affair along. For all, our thanks.
+    Now follows, that you know, young Fortinbras,
+    Holding a weak supposal of our worth,
+    Or thinking by our late dear brother's death
+    Our state to be disjoint and out of frame,
+    Colleagued with the dream of his advantage,
+    He hath not fail'd to pester us with message,
+    Importing the surrender of those lands
+    Lost by his father, with all bonds of law,
+    To our most valiant brother. So much for him.
+    Now for ourself and for this time of meeting:
+    Thus much the business is: we have here writ
+    To Norway, uncle of young Fortinbras,--
+    Who, impotent and bed-rid, scarcely hears
+    Of this his nephew's purpose,--to suppress
+    His further gait herein; in that the levies,
+    The lists and full proportions, are all made
+    Out of his subject: and we here dispatch
+    You, good Cornelius, and you, Voltimand,
+    For bearers of this greeting to old Norway;
+    Giving to you no further personal power
+    To business with the king, more than the scope
+    Of these delated articles allow.
+    Farewell, and let your haste commend your duty.
+
+CORNELIUS VOLTIMAND
+
+    In that and all things will we show our duty.
+
+KING CLAUDIUS
+
+    We doubt it nothing: heartily farewell.
+
+    Exeunt VOLTIMAND and CORNELIUS
+    And now, Laertes, what's the news with you?
+    You told us of some suit; what is't, Laertes?
+    You cannot speak of reason to the Dane,
+    And loose your voice: what wouldst thou beg, Laertes,
+    That shall not be my offer, not thy asking?
+    The head is not more native to the heart,
+    The hand more instrumental to the mouth,
+    Than is the throne of Denmark to thy father.
+    What wouldst thou have, Laertes?
+
+LAERTES
+
+    My dread lord,
+    Your leave and favour to return to France;
+    From whence though willingly I came to Denmark,
+    To show my duty in your coronation,
+    Yet now, I must confess, that duty done,
+    My thoughts and wishes bend again toward France
+    And bow them to your gracious leave and pardon.
+
+KING CLAUDIUS
+
+    Have you your father's leave? What says Polonius?
+
+LORD POLONIUS
+
+    He hath, my lord, wrung from me my slow leave
+    By laboursome petition, and at last
+    Upon his will I seal'd my hard consent:
+    I do beseech you, give him leave to go.
+
+KING CLAUDIUS
+
+    Take thy fair hour, Laertes; time be thine,
+    And thy best graces spend it at thy will!
+    But now, my cousin Hamlet, and my son,--
+
+HAMLET
+
+    [Aside] A little more than kin, and less than kind.
+
+KING CLAUDIUS
+
+    How is it that the clouds still hang on you?
+
+HAMLET
+
+    Not so, my lord; I am too much i' the sun.
+
+QUEEN GERTRUDE
+
+    Good Hamlet, cast thy nighted colour off,
+    And let thine eye look like a friend on Denmark.
+    Do not for ever with thy vailed lids
+    Seek for thy noble father in the dust:
+    Thou know'st 'tis common; all that lives must die,
+    Passing through nature to eternity.
+
+HAMLET
+
+    Ay, madam, it is common.
+
+QUEEN GERTRUDE
+
+    If it be,
+    Why seems it so particular with thee?
+
+HAMLET
+
+    Seems, madam! nay it is; I know not 'seems.'
+    'Tis not alone my inky cloak, good mother,
+    Nor customary suits of solemn black,
+    Nor windy suspiration of forced breath,
+    No, nor the fruitful river in the eye,
+    Nor the dejected 'havior of the visage,
+    Together with all forms, moods, shapes of grief,
+    That can denote me truly: these indeed seem,
+    For they are actions that a man might play:
+    But I have that within which passeth show;
+    These but the trappings and the suits of woe.
+
+KING CLAUDIUS
+
+    'Tis sweet and commendable in your nature, Hamlet,
+    To give these mourning duties to your father:
+    But, you must know, your father lost a father;
+    That father lost, lost his, and the survivor bound
+    In filial obligation for some term
+    To do obsequious sorrow: but to persever
+    In obstinate condolement is a course
+    Of impious stubbornness; 'tis unmanly grief;
+    It shows a will most incorrect to heaven,
+    A heart unfortified, a mind impatient,
+    An understanding simple and unschool'd:
+    For what we know must be and is as common
+    As any the most vulgar thing to sense,
+    Why should we in our peevish opposition
+    Take it to heart? Fie! 'tis a fault to heaven,
+    A fault against the dead, a fault to nature,
+    To reason most absurd: whose common theme
+    Is death of fathers, and who still hath cried,
+    From the first corse till he that died to-day,
+    'This must be so.' We pray you, throw to earth
+    This unprevailing woe, and think of us
+    As of a father: for let the world take note,
+    You are the most immediate to our throne;
+    And with no less nobility of love
+    Than that which dearest father bears his son,
+    Do I impart toward you. For your intent
+    In going back to school in Wittenberg,
+    It is most retrograde to our desire:
+    And we beseech you, bend you to remain
+    Here, in the cheer and comfort of our eye,
+    Our chiefest courtier, cousin, and our son.
+
+QUEEN GERTRUDE
+
+    Let not thy mother lose her prayers, Hamlet:
+    I pray thee, stay with us; go not to Wittenberg.
+
+HAMLET
+
+    I shall in all my best obey you, madam.
+
+KING CLAUDIUS
+
+    Why, 'tis a loving and a fair reply:
+    Be as ourself in Denmark. Madam, come;
+    This gentle and unforced accord of Hamlet
+    Sits smiling to my heart: in grace whereof,
+    No jocund health that Denmark drinks to-day,
+    But the great cannon to the clouds shall tell,
+    And the king's rouse the heavens all bruit again,
+    Re-speaking earthly thunder. Come away.
+
+    Exeunt all but HAMLET
+
+HAMLET
+
+    O, that this too too solid flesh would melt
+    Thaw and resolve itself into a dew!
+    Or that the Everlasting had not fix'd
+    His canon 'gainst self-slaughter! O God! God!
+    How weary, stale, flat and unprofitable,
+    Seem to me all the uses of this world!
+    Fie on't! ah fie! 'tis an unweeded garden,
+    That grows to seed; things rank and gross in nature
+    Possess it merely. That it should come to this!
+    But two months dead: nay, not so much, not two:
+    So excellent a king; that was, to this,
+    Hyperion to a satyr; so loving to my mother
+    That he might not beteem the winds of heaven
+    Visit her face too roughly. Heaven and earth!
+    Must I remember? why, she would hang on him,
+    As if increase of appetite had grown
+    By what it fed on: and yet, within a month--
+    Let me not think on't--Frailty, thy name is woman!--
+    A little month, or ere those shoes were old
+    With which she follow'd my poor father's body,
+    Like Niobe, all tears:--why she, even she--
+    O, God! a beast, that wants discourse of reason,
+    Would have mourn'd longer--married with my uncle,
+    My father's brother, but no more like my father
+    Than I to Hercules: within a month:
+    Ere yet the salt of most unrighteous tears
+    Had left the flushing in her galled eyes,
+    She married. O, most wicked speed, to post
+    With such dexterity to incestuous sheets!
+    It is not nor it cannot come to good:
+    But break, my heart; for I must hold my tongue.
+
+    Enter HORATIO, MARCELLUS, and BERNARDO
+
+HORATIO
+
+    Hail to your lordship!
+
+HAMLET
+
+    I am glad to see you well:
+    Horatio,--or I do forget myself.
+
+HORATIO
+
+    The same, my lord, and your poor servant ever.
+
+HAMLET
+
+    Sir, my good friend; I'll change that name with you:
+    And what make you from Wittenberg, Horatio? Marcellus?
+
+MARCELLUS
+
+    My good lord--
+
+HAMLET
+
+    I am very glad to see you. Good even, sir.
+    But what, in faith, make you from Wittenberg?
+
+HORATIO
+
+    A truant disposition, good my lord.
+
+HAMLET
+
+    I would not hear your enemy say so,
+    Nor shall you do mine ear that violence,
+    To make it truster of your own report
+    Against yourself: I know you are no truant.
+    But what is your affair in Elsinore?
+    We'll teach you to drink deep ere you depart.
+
+HORATIO
+
+    My lord, I came to see your father's funeral.
+
+HAMLET
+
+    I pray thee, do not mock me, fellow-student;
+    I think it was to see my mother's wedding.
+
+HORATIO
+
+    Indeed, my lord, it follow'd hard upon.
+
+HAMLET
+
+    Thrift, thrift, Horatio! the funeral baked meats
+    Did coldly furnish forth the marriage tables.
+    Would I had met my dearest foe in heaven
+    Or ever I had seen that day, Horatio!
+    My father!--methinks I see my father.
+
+HORATIO
+
+    Where, my lord?
+
+HAMLET
+
+    In my mind's eye, Horatio.
+
+HORATIO
+
+    I saw him once; he was a goodly king.
+
+HAMLET
+
+    He was a man, take him for all in all,
+    I shall not look upon his like again.
+
+HORATIO
+
+    My lord, I think I saw him yesternight.
+
+HAMLET
+
+    Saw? who?
+
+HORATIO
+
+    My lord, the king your father.
+
+HAMLET
+
+    The king my father!
+
+HORATIO
+
+    Season your admiration for awhile
+    With an attent ear, till I may deliver,
+    Upon the witness of these gentlemen,
+    This marvel to you.
+
+HAMLET
+
+    For God's love, let me hear.
+
+HORATIO
+
+    Two nights together had these gentlemen,
+    Marcellus and Bernardo, on their watch,
+    In the dead vast and middle of the night,
+    Been thus encounter'd. A figure like your father,
+    Armed at point exactly, cap-a-pe,
+    Appears before them, and with solemn march
+    Goes slow and stately by them: thrice he walk'd
+    By their oppress'd and fear-surprised eyes,
+    Within his truncheon's length; whilst they, distilled
+    Almost to jelly with the act of fear,
+    Stand dumb and speak not to him. This to me
+    In dreadful secrecy impart they did;
+    And I with them the third night kept the watch;
+    Where, as they had deliver'd, both in time,
+    Form of the thing, each word made true and good,
+    The apparition comes: I knew your father;
+    These hands are not more like.
+
+HAMLET
+
+    But where was this?
+
+MARCELLUS
+
+    My lord, upon the platform where we watch'd.
+
+HAMLET
+
+    Did you not speak to it?
+
+HORATIO
+
+    My lord, I did;
+    But answer made it none: yet once methought
+    It lifted up its head and did address
+    Itself to motion, like as it would speak;
+    But even then the morning cock crew loud,
+    And at the sound it shrunk in haste away,
+    And vanish'd from our sight.
+
+HAMLET
+
+    'Tis very strange.
+
+HORATIO
+
+    As I do live, my honour'd lord, 'tis true;
+    And we did think it writ down in our duty
+    To let you know of it.
+
+HAMLET
+
+    Indeed, indeed, sirs, but this troubles me.
+    Hold you the watch to-night?
+
+MARCELLUS BERNARDO
+
+    We do, my lord.
+
+HAMLET
+
+    Arm'd, say you?
+
+MARCELLUS BERNARDO
+
+    Arm'd, my lord.
+
+HAMLET
+
+    From top to toe?
+
+MARCELLUS BERNARDO
+
+    My lord, from head to foot.
+
+HAMLET
+
+    Then saw you not his face?
+
+HORATIO
+
+    O, yes, my lord; he wore his beaver up.
+
+HAMLET
+
+    What, look'd he frowningly?
+
+HORATIO
+
+    A countenance more in sorrow than in anger.
+
+HAMLET
+
+    Pale or red?
+
+HORATIO
+
+    Nay, very pale.
+
+HAMLET
+
+    And fix'd his eyes upon you?
+
+HORATIO
+
+    Most constantly.
+
+HAMLET
+
+    I would I had been there.
+
+HORATIO
+
+    It would have much amazed you.
+
+HAMLET
+
+    Very like, very like. Stay'd it long?
+
+HORATIO
+
+    While one with moderate haste might tell a hundred.
+
+MARCELLUS BERNARDO
+
+    Longer, longer.
+
+HORATIO
+
+    Not when I saw't.
+
+HAMLET
+
+    His beard was grizzled--no?
+
+HORATIO
+
+    It was, as I have seen it in his life,
+    A sable silver'd.
+
+HAMLET
+
+    I will watch to-night;
+    Perchance 'twill walk again.
+
+HORATIO
+
+    I warrant it will.
+
+HAMLET
+
+    If it assume my noble father's person,
+    I'll speak to it, though hell itself should gape
+    And bid me hold my peace. I pray you all,
+    If you have hitherto conceal'd this sight,
+    Let it be tenable in your silence still;
+    And whatsoever else shall hap to-night,
+    Give it an understanding, but no tongue:
+    I will requite your loves. So, fare you well:
+    Upon the platform, 'twixt eleven and twelve,
+    I'll visit you.
+
+All
+
+    Our duty to your honour.
+
+HAMLET
+
+    Your loves, as mine to you: farewell.
+
+    Exeunt all but HAMLET
+    My father's spirit in arms! all is not well;
+    I doubt some foul play: would the night were come!
+    Till then sit still, my soul: foul deeds will rise,
+    Though all the earth o'erwhelm them, to men's eyes.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene3.txt
new file mode 100644
index 0000000..6a2dc42
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene3.txt
@@ -0,0 +1,224 @@
+SCENE III. A room in Polonius' house.
+
+    Enter LAERTES and OPHELIA 
+
+LAERTES
+
+    My necessaries are embark'd: farewell:
+    And, sister, as the winds give benefit
+    And convoy is assistant, do not sleep,
+    But let me hear from you.
+
+OPHELIA
+
+    Do you doubt that?
+
+LAERTES
+
+    For Hamlet and the trifling of his favour,
+    Hold it a fashion and a toy in blood,
+    A violet in the youth of primy nature,
+    Forward, not permanent, sweet, not lasting,
+    The perfume and suppliance of a minute; No more.
+
+OPHELIA
+
+    No more but so?
+
+LAERTES
+
+    Think it no more;
+    For nature, crescent, does not grow alone
+    In thews and bulk, but, as this temple waxes,
+    The inward service of the mind and soul
+    Grows wide withal. Perhaps he loves you now,
+    And now no soil nor cautel doth besmirch
+    The virtue of his will: but you must fear,
+    His greatness weigh'd, his will is not his own;
+    For he himself is subject to his birth:
+    He may not, as unvalued persons do,
+    Carve for himself; for on his choice depends
+    The safety and health of this whole state;
+    And therefore must his choice be circumscribed
+    Unto the voice and yielding of that body
+    Whereof he is the head. Then if he says he loves you,
+    It fits your wisdom so far to believe it
+    As he in his particular act and place
+    May give his saying deed; which is no further
+    Than the main voice of Denmark goes withal.
+    Then weigh what loss your honour may sustain,
+    If with too credent ear you list his songs,
+    Or lose your heart, or your chaste treasure open
+    To his unmaster'd importunity.
+    Fear it, Ophelia, fear it, my dear sister,
+    And keep you in the rear of your affection,
+    Out of the shot and danger of desire.
+    The chariest maid is prodigal enough,
+    If she unmask her beauty to the moon:
+    Virtue itself 'scapes not calumnious strokes:
+    The canker galls the infants of the spring,
+    Too oft before their buttons be disclosed,
+    And in the morn and liquid dew of youth
+    Contagious blastments are most imminent.
+    Be wary then; best safety lies in fear:
+    Youth to itself rebels, though none else near.
+
+OPHELIA
+
+    I shall the effect of this good lesson keep,
+    As watchman to my heart. But, good my brother,
+    Do not, as some ungracious pastors do,
+    Show me the steep and thorny way to heaven;
+    Whiles, like a puff'd and reckless libertine,
+    Himself the primrose path of dalliance treads,
+    And recks not his own rede.
+
+LAERTES
+
+    O, fear me not.
+    I stay too long: but here my father comes.
+
+    Enter POLONIUS
+    A double blessing is a double grace,
+    Occasion smiles upon a second leave.
+
+LORD POLONIUS
+
+    Yet here, Laertes! aboard, aboard, for shame!
+    The wind sits in the shoulder of your sail,
+    And you are stay'd for. There; my blessing with thee!
+    And these few precepts in thy memory
+    See thou character. Give thy thoughts no tongue,
+    Nor any unproportioned thought his act.
+    Be thou familiar, but by no means vulgar.
+    Those friends thou hast, and their adoption tried,
+    Grapple them to thy soul with hoops of steel;
+    But do not dull thy palm with entertainment
+    Of each new-hatch'd, unfledged comrade. Beware
+    Of entrance to a quarrel, but being in,
+    Bear't that the opposed may beware of thee.
+    Give every man thy ear, but few thy voice;
+    Take each man's censure, but reserve thy judgment.
+    Costly thy habit as thy purse can buy,
+    But not express'd in fancy; rich, not gaudy;
+    For the apparel oft proclaims the man,
+    And they in France of the best rank and station
+    Are of a most select and generous chief in that.
+    Neither a borrower nor a lender be;
+    For loan oft loses both itself and friend,
+    And borrowing dulls the edge of husbandry.
+    This above all: to thine ownself be true,
+    And it must follow, as the night the day,
+    Thou canst not then be false to any man.
+    Farewell: my blessing season this in thee!
+
+LAERTES
+
+    Most humbly do I take my leave, my lord.
+
+LORD POLONIUS
+
+    The time invites you; go; your servants tend.
+
+LAERTES
+
+    Farewell, Ophelia; and remember well
+    What I have said to you.
+
+OPHELIA
+
+    'Tis in my memory lock'd,
+    And you yourself shall keep the key of it.
+
+LAERTES
+
+    Farewell.
+
+    Exit
+
+LORD POLONIUS
+
+    What is't, Ophelia, be hath said to you?
+
+OPHELIA
+
+    So please you, something touching the Lord Hamlet.
+
+LORD POLONIUS
+
+    Marry, well bethought:
+    'Tis told me, he hath very oft of late
+    Given private time to you; and you yourself
+    Have of your audience been most free and bounteous:
+    If it be so, as so 'tis put on me,
+    And that in way of caution, I must tell you,
+    You do not understand yourself so clearly
+    As it behoves my daughter and your honour.
+    What is between you? give me up the truth.
+
+OPHELIA
+
+    He hath, my lord, of late made many tenders
+    Of his affection to me.
+
+LORD POLONIUS
+
+    Affection! pooh! you speak like a green girl,
+    Unsifted in such perilous circumstance.
+    Do you believe his tenders, as you call them?
+
+OPHELIA
+
+    I do not know, my lord, what I should think.
+
+LORD POLONIUS
+
+    Marry, I'll teach you: think yourself a baby;
+    That you have ta'en these tenders for true pay,
+    Which are not sterling. Tender yourself more dearly;
+    Or--not to crack the wind of the poor phrase,
+    Running it thus--you'll tender me a fool.
+
+OPHELIA
+
+    My lord, he hath importuned me with love
+    In honourable fashion.
+
+LORD POLONIUS
+
+    Ay, fashion you may call it; go to, go to.
+
+OPHELIA
+
+    And hath given countenance to his speech, my lord,
+    With almost all the holy vows of heaven.
+
+LORD POLONIUS
+
+    Ay, springes to catch woodcocks. I do know,
+    When the blood burns, how prodigal the soul
+    Lends the tongue vows: these blazes, daughter,
+    Giving more light than heat, extinct in both,
+    Even in their promise, as it is a-making,
+    You must not take for fire. From this time
+    Be somewhat scanter of your maiden presence;
+    Set your entreatments at a higher rate
+    Than a command to parley. For Lord Hamlet,
+    Believe so much in him, that he is young
+    And with a larger tether may he walk
+    Than may be given you: in few, Ophelia,
+    Do not believe his vows; for they are brokers,
+    Not of that dye which their investments show,
+    But mere implorators of unholy suits,
+    Breathing like sanctified and pious bawds,
+    The better to beguile. This is for all:
+    I would not, in plain terms, from this time forth,
+    Have you so slander any moment leisure,
+    As to give words or talk with the Lord Hamlet.
+    Look to't, I charge you: come your ways.
+
+OPHELIA
+
+    I shall obey, my lord.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene4.txt
new file mode 100644
index 0000000..199809e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene4.txt
@@ -0,0 +1,201 @@
+SCENE IV. The platform.
+
+    Enter HAMLET, HORATIO, and MARCELLUS 
+
+HAMLET
+
+    The air bites shrewdly; it is very cold.
+
+HORATIO
+
+    It is a nipping and an eager air.
+
+HAMLET
+
+    What hour now?
+
+HORATIO
+
+    I think it lacks of twelve.
+
+HAMLET
+
+    No, it is struck.
+
+HORATIO
+
+    Indeed? I heard it not: then it draws near the season
+    Wherein the spirit held his wont to walk.
+
+    A flourish of trumpets, and ordnance shot off, within
+    What does this mean, my lord?
+
+HAMLET
+
+    The king doth wake to-night and takes his rouse,
+    Keeps wassail, and the swaggering up-spring reels;
+    And, as he drains his draughts of Rhenish down,
+    The kettle-drum and trumpet thus bray out
+    The triumph of his pledge.
+
+HORATIO
+
+    Is it a custom?
+
+HAMLET
+
+    Ay, marry, is't:
+    But to my mind, though I am native here
+    And to the manner born, it is a custom
+    More honour'd in the breach than the observance.
+    This heavy-headed revel east and west
+    Makes us traduced and tax'd of other nations:
+    They clepe us drunkards, and with swinish phrase
+    Soil our addition; and indeed it takes
+    From our achievements, though perform'd at height,
+    The pith and marrow of our attribute.
+    So, oft it chances in particular men,
+    That for some vicious mole of nature in them,
+    As, in their birth--wherein they are not guilty,
+    Since nature cannot choose his origin--
+    By the o'ergrowth of some complexion,
+    Oft breaking down the pales and forts of reason,
+    Or by some habit that too much o'er-leavens
+    The form of plausive manners, that these men,
+    Carrying, I say, the stamp of one defect,
+    Being nature's livery, or fortune's star,--
+    Their virtues else--be they as pure as grace,
+    As infinite as man may undergo--
+    Shall in the general censure take corruption
+    From that particular fault: the dram of eale
+    Doth all the noble substance of a doubt
+    To his own scandal.
+
+HORATIO
+
+    Look, my lord, it comes!
+
+    Enter Ghost
+
+HAMLET
+
+    Angels and ministers of grace defend us!
+    Be thou a spirit of health or goblin damn'd,
+    Bring with thee airs from heaven or blasts from hell,
+    Be thy intents wicked or charitable,
+    Thou comest in such a questionable shape
+    That I will speak to thee: I'll call thee Hamlet,
+    King, father, royal Dane: O, answer me!
+    Let me not burst in ignorance; but tell
+    Why thy canonized bones, hearsed in death,
+    Have burst their cerements; why the sepulchre,
+    Wherein we saw thee quietly inurn'd,
+    Hath oped his ponderous and marble jaws,
+    To cast thee up again. What may this mean,
+    That thou, dead corse, again in complete steel
+    Revisit'st thus the glimpses of the moon,
+    Making night hideous; and we fools of nature
+    So horridly to shake our disposition
+    With thoughts beyond the reaches of our souls?
+    Say, why is this? wherefore? what should we do?
+
+    Ghost beckons HAMLET
+
+HORATIO
+
+    It beckons you to go away with it,
+    As if it some impartment did desire
+    To you alone.
+
+MARCELLUS
+
+    Look, with what courteous action
+    It waves you to a more removed ground:
+    But do not go with it.
+
+HORATIO
+
+    No, by no means.
+
+HAMLET
+
+    It will not speak; then I will follow it.
+
+HORATIO
+
+    Do not, my lord.
+
+HAMLET
+
+    Why, what should be the fear?
+    I do not set my life in a pin's fee;
+    And for my soul, what can it do to that,
+    Being a thing immortal as itself?
+    It waves me forth again: I'll follow it.
+
+HORATIO
+
+    What if it tempt you toward the flood, my lord,
+    Or to the dreadful summit of the cliff
+    That beetles o'er his base into the sea,
+    And there assume some other horrible form,
+    Which might deprive your sovereignty of reason
+    And draw you into madness? think of it:
+    The very place puts toys of desperation,
+    Without more motive, into every brain
+    That looks so many fathoms to the sea
+    And hears it roar beneath.
+
+HAMLET
+
+    It waves me still.
+    Go on; I'll follow thee.
+
+MARCELLUS
+
+    You shall not go, my lord.
+
+HAMLET
+
+    Hold off your hands.
+
+HORATIO
+
+    Be ruled; you shall not go.
+
+HAMLET
+
+    My fate cries out,
+    And makes each petty artery in this body
+    As hardy as the Nemean lion's nerve.
+    Still am I call'd. Unhand me, gentlemen.
+    By heaven, I'll make a ghost of him that lets me!
+    I say, away! Go on; I'll follow thee.
+
+    Exeunt Ghost and HAMLET
+
+HORATIO
+
+    He waxes desperate with imagination.
+
+MARCELLUS
+
+    Let's follow; 'tis not fit thus to obey him.
+
+HORATIO
+
+    Have after. To what issue will this come?
+
+MARCELLUS
+
+    Something is rotten in the state of Denmark.
+
+HORATIO
+
+    Heaven will direct it.
+
+MARCELLUS
+
+    Nay, let's follow him.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene5.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene5.txt
new file mode 100644
index 0000000..db24ee4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act1/scene5.txt
@@ -0,0 +1,408 @@
+SCENE V. Another part of the platform.
+
+    Enter GHOST and HAMLET 
+
+HAMLET
+
+    Where wilt thou lead me? speak; I'll go no further.
+
+Ghost
+
+    Mark me.
+
+HAMLET
+
+    I will.
+
+Ghost
+
+    My hour is almost come,
+    When I to sulphurous and tormenting flames
+    Must render up myself.
+
+HAMLET
+
+    Alas, poor ghost!
+
+Ghost
+
+    Pity me not, but lend thy serious hearing
+    To what I shall unfold.
+
+HAMLET
+
+    Speak; I am bound to hear.
+
+Ghost
+
+    So art thou to revenge, when thou shalt hear.
+
+HAMLET
+
+    What?
+
+Ghost
+
+    I am thy father's spirit,
+    Doom'd for a certain term to walk the night,
+    And for the day confined to fast in fires,
+    Till the foul crimes done in my days of nature
+    Are burnt and purged away. But that I am forbid
+    To tell the secrets of my prison-house,
+    I could a tale unfold whose lightest word
+    Would harrow up thy soul, freeze thy young blood,
+    Make thy two eyes, like stars, start from their spheres,
+    Thy knotted and combined locks to part
+    And each particular hair to stand on end,
+    Like quills upon the fretful porpentine:
+    But this eternal blazon must not be
+    To ears of flesh and blood. List, list, O, list!
+    If thou didst ever thy dear father love--
+
+HAMLET
+
+    O God!
+
+Ghost
+
+    Revenge his foul and most unnatural murder.
+
+HAMLET
+
+    Murder!
+
+Ghost
+
+    Murder most foul, as in the best it is;
+    But this most foul, strange and unnatural.
+
+HAMLET
+
+    Haste me to know't, that I, with wings as swift
+    As meditation or the thoughts of love,
+    May sweep to my revenge.
+
+Ghost
+
+    I find thee apt;
+    And duller shouldst thou be than the fat weed
+    That roots itself in ease on Lethe wharf,
+    Wouldst thou not stir in this. Now, Hamlet, hear:
+    'Tis given out that, sleeping in my orchard,
+    A serpent stung me; so the whole ear of Denmark
+    Is by a forged process of my death
+    Rankly abused: but know, thou noble youth,
+    The serpent that did sting thy father's life
+    Now wears his crown.
+
+HAMLET
+
+    O my prophetic soul! My uncle!
+
+Ghost
+
+    Ay, that incestuous, that adulterate beast,
+    With witchcraft of his wit, with traitorous gifts,--
+    O wicked wit and gifts, that have the power
+    So to seduce!--won to his shameful lust
+    The will of my most seeming-virtuous queen:
+    O Hamlet, what a falling-off was there!
+    From me, whose love was of that dignity
+    That it went hand in hand even with the vow
+    I made to her in marriage, and to decline
+    Upon a wretch whose natural gifts were poor
+    To those of mine!
+    But virtue, as it never will be moved,
+    Though lewdness court it in a shape of heaven,
+    So lust, though to a radiant angel link'd,
+    Will sate itself in a celestial bed,
+    And prey on garbage.
+    But, soft! methinks I scent the morning air;
+    Brief let me be. Sleeping within my orchard,
+    My custom always of the afternoon,
+    Upon my secure hour thy uncle stole,
+    With juice of cursed hebenon in a vial,
+    And in the porches of my ears did pour
+    The leperous distilment; whose effect
+    Holds such an enmity with blood of man
+    That swift as quicksilver it courses through
+    The natural gates and alleys of the body,
+    And with a sudden vigour doth posset
+    And curd, like eager droppings into milk,
+    The thin and wholesome blood: so did it mine;
+    And a most instant tetter bark'd about,
+    Most lazar-like, with vile and loathsome crust,
+    All my smooth body.
+    Thus was I, sleeping, by a brother's hand
+    Of life, of crown, of queen, at once dispatch'd:
+    Cut off even in the blossoms of my sin,
+    Unhousel'd, disappointed, unanel'd,
+    No reckoning made, but sent to my account
+    With all my imperfections on my head:
+    O, horrible! O, horrible! most horrible!
+    If thou hast nature in thee, bear it not;
+    Let not the royal bed of Denmark be
+    A couch for luxury and damned incest.
+    But, howsoever thou pursuest this act,
+    Taint not thy mind, nor let thy soul contrive
+    Against thy mother aught: leave her to heaven
+    And to those thorns that in her bosom lodge,
+    To prick and sting her. Fare thee well at once!
+    The glow-worm shows the matin to be near,
+    And 'gins to pale his uneffectual fire:
+    Adieu, adieu! Hamlet, remember me.
+
+    Exit
+
+HAMLET
+
+    O all you host of heaven! O earth! what else?
+    And shall I couple hell? O, fie! Hold, hold, my heart;
+    And you, my sinews, grow not instant old,
+    But bear me stiffly up. Remember thee!
+    Ay, thou poor ghost, while memory holds a seat
+    In this distracted globe. Remember thee!
+    Yea, from the table of my memory
+    I'll wipe away all trivial fond records,
+    All saws of books, all forms, all pressures past,
+    That youth and observation copied there;
+    And thy commandment all alone shall live
+    Within the book and volume of my brain,
+    Unmix'd with baser matter: yes, by heaven!
+    O most pernicious woman!
+    O villain, villain, smiling, damned villain!
+    My tables,--meet it is I set it down,
+    That one may smile, and smile, and be a villain;
+    At least I'm sure it may be so in Denmark:
+
+    Writing
+    So, uncle, there you are. Now to my word;
+    It is 'Adieu, adieu! remember me.'
+    I have sworn 't.
+
+MARCELLUS HORATIO
+
+    [Within] My lord, my lord,--
+
+MARCELLUS
+
+    [Within] Lord Hamlet,--
+
+HORATIO
+
+    [Within] Heaven secure him!
+
+HAMLET
+
+    So be it!
+
+HORATIO
+
+    [Within] Hillo, ho, ho, my lord!
+
+HAMLET
+
+    Hillo, ho, ho, boy! come, bird, come.
+
+    Enter HORATIO and MARCELLUS
+
+MARCELLUS
+
+    How is't, my noble lord?
+
+HORATIO
+
+    What news, my lord?
+
+HAMLET
+
+    O, wonderful!
+
+HORATIO
+
+    Good my lord, tell it.
+
+HAMLET
+
+    No; you'll reveal it.
+
+HORATIO
+
+    Not I, my lord, by heaven.
+
+MARCELLUS
+
+    Nor I, my lord.
+
+HAMLET
+
+    How say you, then; would heart of man once think it?
+    But you'll be secret?
+
+HORATIO MARCELLUS
+
+    Ay, by heaven, my lord.
+
+HAMLET
+
+    There's ne'er a villain dwelling in all Denmark
+    But he's an arrant knave.
+
+HORATIO
+
+    There needs no ghost, my lord, come from the grave
+    To tell us this.
+
+HAMLET
+
+    Why, right; you are i' the right;
+    And so, without more circumstance at all,
+    I hold it fit that we shake hands and part:
+    You, as your business and desire shall point you;
+    For every man has business and desire,
+    Such as it is; and for mine own poor part,
+    Look you, I'll go pray.
+
+HORATIO
+
+    These are but wild and whirling words, my lord.
+
+HAMLET
+
+    I'm sorry they offend you, heartily;
+    Yes, 'faith heartily.
+
+HORATIO
+
+    There's no offence, my lord.
+
+HAMLET
+
+    Yes, by Saint Patrick, but there is, Horatio,
+    And much offence too. Touching this vision here,
+    It is an honest ghost, that let me tell you:
+    For your desire to know what is between us,
+    O'ermaster 't as you may. And now, good friends,
+    As you are friends, scholars and soldiers,
+    Give me one poor request.
+
+HORATIO
+
+    What is't, my lord? we will.
+
+HAMLET
+
+    Never make known what you have seen to-night.
+
+HORATIO MARCELLUS
+
+    My lord, we will not.
+
+HAMLET
+
+    Nay, but swear't.
+
+HORATIO
+
+    In faith,
+    My lord, not I.
+
+MARCELLUS
+
+    Nor I, my lord, in faith.
+
+HAMLET
+
+    Upon my sword.
+
+MARCELLUS
+
+    We have sworn, my lord, already.
+
+HAMLET
+
+    Indeed, upon my sword, indeed.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Ah, ha, boy! say'st thou so? art thou there,
+    truepenny?
+    Come on--you hear this fellow in the cellarage--
+    Consent to swear.
+
+HORATIO
+
+    Propose the oath, my lord.
+
+HAMLET
+
+    Never to speak of this that you have seen,
+    Swear by my sword.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Hic et ubique? then we'll shift our ground.
+    Come hither, gentlemen,
+    And lay your hands again upon my sword:
+    Never to speak of this that you have heard,
+    Swear by my sword.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Well said, old mole! canst work i' the earth so fast?
+    A worthy pioner! Once more remove, good friends.
+
+HORATIO
+
+    O day and night, but this is wondrous strange!
+
+HAMLET
+
+    And therefore as a stranger give it welcome.
+    There are more things in heaven and earth, Horatio,
+    Than are dreamt of in your philosophy. But come;
+    Here, as before, never, so help you mercy,
+    How strange or odd soe'er I bear myself,
+    As I perchance hereafter shall think meet
+    To put an antic disposition on,
+    That you, at such times seeing me, never shall,
+    With arms encumber'd thus, or this headshake,
+    Or by pronouncing of some doubtful phrase,
+    As 'Well, well, we know,' or 'We could, an if we would,'
+    Or 'If we list to speak,' or 'There be, an if they might,'
+    Or such ambiguous giving out, to note
+    That you know aught of me: this not to do,
+    So grace and mercy at your most need help you, Swear.
+
+Ghost
+
+    [Beneath] Swear.
+
+HAMLET
+
+    Rest, rest, perturbed spirit!
+
+    They swear
+    So, gentlemen,
+    With all my love I do commend me to you:
+    And what so poor a man as Hamlet is
+    May do, to express his love and friending to you,
+    God willing, shall not lack. Let us go in together;
+    And still your fingers on your lips, I pray.
+    The time is out of joint: O cursed spite,
+    That ever I was born to set it right!
+    Nay, come, let's go together.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene1.txt
new file mode 100644
index 0000000..4202de7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene1.txt
@@ -0,0 +1,252 @@
+ACT II
+SCENE I. A room in POLONIUS' house.
+
+    Enter POLONIUS and REYNALDO 
+
+LORD POLONIUS
+
+    Give him this money and these notes, Reynaldo.
+
+REYNALDO
+
+    I will, my lord.
+
+LORD POLONIUS
+
+    You shall do marvellous wisely, good Reynaldo,
+    Before you visit him, to make inquire
+    Of his behavior.
+
+REYNALDO
+
+    My lord, I did intend it.
+
+LORD POLONIUS
+
+    Marry, well said; very well said. Look you, sir,
+    Inquire me first what Danskers are in Paris;
+    And how, and who, what means, and where they keep,
+    What company, at what expense; and finding
+    By this encompassment and drift of question
+    That they do know my son, come you more nearer
+    Than your particular demands will touch it:
+    Take you, as 'twere, some distant knowledge of him;
+    As thus, 'I know his father and his friends,
+    And in part him: ' do you mark this, Reynaldo?
+
+REYNALDO
+
+    Ay, very well, my lord.
+
+LORD POLONIUS
+
+    'And in part him; but' you may say 'not well:
+    But, if't be he I mean, he's very wild;
+    Addicted so and so:' and there put on him
+    What forgeries you please; marry, none so rank
+    As may dishonour him; take heed of that;
+    But, sir, such wanton, wild and usual slips
+    As are companions noted and most known
+    To youth and liberty.
+
+REYNALDO
+
+    As gaming, my lord.
+
+LORD POLONIUS
+
+    Ay, or drinking, fencing, swearing, quarrelling,
+    Drabbing: you may go so far.
+
+REYNALDO
+
+    My lord, that would dishonour him.
+
+LORD POLONIUS
+
+    'Faith, no; as you may season it in the charge
+    You must not put another scandal on him,
+    That he is open to incontinency;
+    That's not my meaning: but breathe his faults so quaintly
+    That they may seem the taints of liberty,
+    The flash and outbreak of a fiery mind,
+    A savageness in unreclaimed blood,
+    Of general assault.
+
+REYNALDO
+
+    But, my good lord,--
+
+LORD POLONIUS
+
+    Wherefore should you do this?
+
+REYNALDO
+
+    Ay, my lord,
+    I would know that.
+
+LORD POLONIUS
+
+    Marry, sir, here's my drift;
+    And I believe, it is a fetch of wit:
+    You laying these slight sullies on my son,
+    As 'twere a thing a little soil'd i' the working, Mark you,
+    Your party in converse, him you would sound,
+    Having ever seen in the prenominate crimes
+    The youth you breathe of guilty, be assured
+    He closes with you in this consequence;
+    'Good sir,' or so, or 'friend,' or 'gentleman,'
+    According to the phrase or the addition
+    Of man and country.
+
+REYNALDO
+
+    Very good, my lord.
+
+LORD POLONIUS
+
+    And then, sir, does he this--he does--what was I
+    about to say? By the mass, I was about to say
+    something: where did I leave?
+
+REYNALDO
+
+    At 'closes in the consequence,' at 'friend or so,'
+    and 'gentleman.'
+
+LORD POLONIUS
+
+    At 'closes in the consequence,' ay, marry;
+    He closes thus: 'I know the gentleman;
+    I saw him yesterday, or t' other day,
+    Or then, or then; with such, or such; and, as you say,
+    There was a' gaming; there o'ertook in's rouse;
+    There falling out at tennis:' or perchance,
+    'I saw him enter such a house of sale,'
+    Videlicet, a brothel, or so forth.
+    See you now;
+    Your bait of falsehood takes this carp of truth:
+    And thus do we of wisdom and of reach,
+    With windlasses and with assays of bias,
+    By indirections find directions out:
+    So by my former lecture and advice,
+    Shall you my son. You have me, have you not?
+
+REYNALDO
+
+    My lord, I have.
+
+LORD POLONIUS
+
+    God be wi' you; fare you well.
+
+REYNALDO
+
+    Good my lord!
+
+LORD POLONIUS
+
+    Observe his inclination in yourself.
+
+REYNALDO
+
+    I shall, my lord.
+
+LORD POLONIUS
+
+    And let him ply his music.
+
+REYNALDO
+
+    Well, my lord.
+
+LORD POLONIUS
+
+    Farewell!
+
+    Exit REYNALDO
+
+    Enter OPHELIA
+    How now, Ophelia! what's the matter?
+
+OPHELIA
+
+    O, my lord, my lord, I have been so affrighted!
+
+LORD POLONIUS
+
+    With what, i' the name of God?
+
+OPHELIA
+
+    My lord, as I was sewing in my closet,
+    Lord Hamlet, with his doublet all unbraced;
+    No hat upon his head; his stockings foul'd,
+    Ungarter'd, and down-gyved to his ancle;
+    Pale as his shirt; his knees knocking each other;
+    And with a look so piteous in purport
+    As if he had been loosed out of hell
+    To speak of horrors,--he comes before me.
+
+LORD POLONIUS
+
+    Mad for thy love?
+
+OPHELIA
+
+    My lord, I do not know;
+    But truly, I do fear it.
+
+LORD POLONIUS
+
+    What said he?
+
+OPHELIA
+
+    He took me by the wrist and held me hard;
+    Then goes he to the length of all his arm;
+    And, with his other hand thus o'er his brow,
+    He falls to such perusal of my face
+    As he would draw it. Long stay'd he so;
+    At last, a little shaking of mine arm
+    And thrice his head thus waving up and down,
+    He raised a sigh so piteous and profound
+    As it did seem to shatter all his bulk
+    And end his being: that done, he lets me go:
+    And, with his head over his shoulder turn'd,
+    He seem'd to find his way without his eyes;
+    For out o' doors he went without their helps,
+    And, to the last, bended their light on me.
+
+LORD POLONIUS
+
+    Come, go with me: I will go seek the king.
+    This is the very ecstasy of love,
+    Whose violent property fordoes itself
+    And leads the will to desperate undertakings
+    As oft as any passion under heaven
+    That does afflict our natures. I am sorry.
+    What, have you given him any hard words of late?
+
+OPHELIA
+
+    No, my good lord, but, as you did command,
+    I did repel his fetters and denied
+    His access to me.
+
+LORD POLONIUS
+
+    That hath made him mad.
+    I am sorry that with better heed and judgment
+    I had not quoted him: I fear'd he did but trifle,
+    And meant to wreck thee; but, beshrew my jealousy!
+    By heaven, it is as proper to our age
+    To cast beyond ourselves in our opinions
+    As it is common for the younger sort
+    To lack discretion. Come, go we to the king:
+    This must be known; which, being kept close, might
+    move
+    More grief to hide than hate to utter love.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene2.txt
new file mode 100644
index 0000000..23928ed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act2/scene2.txt
@@ -0,0 +1,1153 @@
+SCENE II. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, ROSENCRANTZ, GUILDENSTERN, and Attendants 
+
+KING CLAUDIUS
+
+    Welcome, dear Rosencrantz and Guildenstern!
+    Moreover that we much did long to see you,
+    The need we have to use you did provoke
+    Our hasty sending. Something have you heard
+    Of Hamlet's transformation; so call it,
+    Sith nor the exterior nor the inward man
+    Resembles that it was. What it should be,
+    More than his father's death, that thus hath put him
+    So much from the understanding of himself,
+    I cannot dream of: I entreat you both,
+    That, being of so young days brought up with him,
+    And sith so neighbour'd to his youth and havior,
+    That you vouchsafe your rest here in our court
+    Some little time: so by your companies
+    To draw him on to pleasures, and to gather,
+    So much as from occasion you may glean,
+    Whether aught, to us unknown, afflicts him thus,
+    That, open'd, lies within our remedy.
+
+QUEEN GERTRUDE
+
+    Good gentlemen, he hath much talk'd of you;
+    And sure I am two men there are not living
+    To whom he more adheres. If it will please you
+    To show us so much gentry and good will
+    As to expend your time with us awhile,
+    For the supply and profit of our hope,
+    Your visitation shall receive such thanks
+    As fits a king's remembrance.
+
+ROSENCRANTZ
+
+    Both your majesties
+    Might, by the sovereign power you have of us,
+    Put your dread pleasures more into command
+    Than to entreaty.
+
+GUILDENSTERN
+
+    But we both obey,
+    And here give up ourselves, in the full bent
+    To lay our service freely at your feet,
+    To be commanded.
+
+KING CLAUDIUS
+
+    Thanks, Rosencrantz and gentle Guildenstern.
+
+QUEEN GERTRUDE
+
+    Thanks, Guildenstern and gentle Rosencrantz:
+    And I beseech you instantly to visit
+    My too much changed son. Go, some of you,
+    And bring these gentlemen where Hamlet is.
+
+GUILDENSTERN
+
+    Heavens make our presence and our practises
+    Pleasant and helpful to him!
+
+QUEEN GERTRUDE
+
+    Ay, amen!
+
+    Exeunt ROSENCRANTZ, GUILDENSTERN, and some Attendants
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    The ambassadors from Norway, my good lord,
+    Are joyfully return'd.
+
+KING CLAUDIUS
+
+    Thou still hast been the father of good news.
+
+LORD POLONIUS
+
+    Have I, my lord? I assure my good liege,
+    I hold my duty, as I hold my soul,
+    Both to my God and to my gracious king:
+    And I do think, or else this brain of mine
+    Hunts not the trail of policy so sure
+    As it hath used to do, that I have found
+    The very cause of Hamlet's lunacy.
+
+KING CLAUDIUS
+
+    O, speak of that; that do I long to hear.
+
+LORD POLONIUS
+
+    Give first admittance to the ambassadors;
+    My news shall be the fruit to that great feast.
+
+KING CLAUDIUS
+
+    Thyself do grace to them, and bring them in.
+
+    Exit POLONIUS
+    He tells me, my dear Gertrude, he hath found
+    The head and source of all your son's distemper.
+
+QUEEN GERTRUDE
+
+    I doubt it is no other but the main;
+    His father's death, and our o'erhasty marriage.
+
+KING CLAUDIUS
+
+    Well, we shall sift him.
+
+    Re-enter POLONIUS, with VOLTIMAND and CORNELIUS
+    Welcome, my good friends!
+    Say, Voltimand, what from our brother Norway?
+
+VOLTIMAND
+
+    Most fair return of greetings and desires.
+    Upon our first, he sent out to suppress
+    His nephew's levies; which to him appear'd
+    To be a preparation 'gainst the Polack;
+    But, better look'd into, he truly found
+    It was against your highness: whereat grieved,
+    That so his sickness, age and impotence
+    Was falsely borne in hand, sends out arrests
+    On Fortinbras; which he, in brief, obeys;
+    Receives rebuke from Norway, and in fine
+    Makes vow before his uncle never more
+    To give the assay of arms against your majesty.
+    Whereon old Norway, overcome with joy,
+    Gives him three thousand crowns in annual fee,
+    And his commission to employ those soldiers,
+    So levied as before, against the Polack:
+    With an entreaty, herein further shown,
+
+    Giving a paper
+    That it might please you to give quiet pass
+    Through your dominions for this enterprise,
+    On such regards of safety and allowance
+    As therein are set down.
+
+KING CLAUDIUS
+
+    It likes us well;
+    And at our more consider'd time well read,
+    Answer, and think upon this business.
+    Meantime we thank you for your well-took labour:
+    Go to your rest; at night we'll feast together:
+    Most welcome home!
+
+    Exeunt VOLTIMAND and CORNELIUS
+
+LORD POLONIUS
+
+    This business is well ended.
+    My liege, and madam, to expostulate
+    What majesty should be, what duty is,
+    Why day is day, night night, and time is time,
+    Were nothing but to waste night, day and time.
+    Therefore, since brevity is the soul of wit,
+    And tediousness the limbs and outward flourishes,
+    I will be brief: your noble son is mad:
+    Mad call I it; for, to define true madness,
+    What is't but to be nothing else but mad?
+    But let that go.
+
+QUEEN GERTRUDE
+
+    More matter, with less art.
+
+LORD POLONIUS
+
+    Madam, I swear I use no art at all.
+    That he is mad, 'tis true: 'tis true 'tis pity;
+    And pity 'tis 'tis true: a foolish figure;
+    But farewell it, for I will use no art.
+    Mad let us grant him, then: and now remains
+    That we find out the cause of this effect,
+    Or rather say, the cause of this defect,
+    For this effect defective comes by cause:
+    Thus it remains, and the remainder thus. Perpend.
+    I have a daughter--have while she is mine--
+    Who, in her duty and obedience, mark,
+    Hath given me this: now gather, and surmise.
+
+    Reads
+    'To the celestial and my soul's idol, the most
+    beautified Ophelia,'--
+    That's an ill phrase, a vile phrase; 'beautified' is
+    a vile phrase: but you shall hear. Thus:
+
+    Reads
+    'In her excellent white bosom, these, & c.'
+
+QUEEN GERTRUDE
+
+    Came this from Hamlet to her?
+
+LORD POLONIUS
+
+    Good madam, stay awhile; I will be faithful.
+
+    Reads
+    'Doubt thou the stars are fire;
+    Doubt that the sun doth move;
+    Doubt truth to be a liar;
+    But never doubt I love.
+    'O dear Ophelia, I am ill at these numbers;
+    I have not art to reckon my groans: but that
+    I love thee best, O most best, believe it. Adieu.
+    'Thine evermore most dear lady, whilst
+    this machine is to him, HAMLET.'
+    This, in obedience, hath my daughter shown me,
+    And more above, hath his solicitings,
+    As they fell out by time, by means and place,
+    All given to mine ear.
+
+KING CLAUDIUS
+
+    But how hath she
+    Received his love?
+
+LORD POLONIUS
+
+    What do you think of me?
+
+KING CLAUDIUS
+
+    As of a man faithful and honourable.
+
+LORD POLONIUS
+
+    I would fain prove so. But what might you think,
+    When I had seen this hot love on the wing--
+    As I perceived it, I must tell you that,
+    Before my daughter told me--what might you,
+    Or my dear majesty your queen here, think,
+    If I had play'd the desk or table-book,
+    Or given my heart a winking, mute and dumb,
+    Or look'd upon this love with idle sight;
+    What might you think? No, I went round to work,
+    And my young mistress thus I did bespeak:
+    'Lord Hamlet is a prince, out of thy star;
+    This must not be:' and then I precepts gave her,
+    That she should lock herself from his resort,
+    Admit no messengers, receive no tokens.
+    Which done, she took the fruits of my advice;
+    And he, repulsed--a short tale to make--
+    Fell into a sadness, then into a fast,
+    Thence to a watch, thence into a weakness,
+    Thence to a lightness, and, by this declension,
+    Into the madness wherein now he raves,
+    And all we mourn for.
+
+KING CLAUDIUS
+
+    Do you think 'tis this?
+
+QUEEN GERTRUDE
+
+    It may be, very likely.
+
+LORD POLONIUS
+
+    Hath there been such a time--I'd fain know that--
+    That I have positively said 'Tis so,'
+    When it proved otherwise?
+
+KING CLAUDIUS
+
+    Not that I know.
+
+LORD POLONIUS
+
+    [Pointing to his head and shoulder]
+    Take this from this, if this be otherwise:
+    If circumstances lead me, I will find
+    Where truth is hid, though it were hid indeed
+    Within the centre.
+
+KING CLAUDIUS
+
+    How may we try it further?
+
+LORD POLONIUS
+
+    You know, sometimes he walks four hours together
+    Here in the lobby.
+
+QUEEN GERTRUDE
+
+    So he does indeed.
+
+LORD POLONIUS
+
+    At such a time I'll loose my daughter to him:
+    Be you and I behind an arras then;
+    Mark the encounter: if he love her not
+    And be not from his reason fall'n thereon,
+    Let me be no assistant for a state,
+    But keep a farm and carters.
+
+KING CLAUDIUS
+
+    We will try it.
+
+QUEEN GERTRUDE
+
+    But, look, where sadly the poor wretch comes reading.
+
+LORD POLONIUS
+
+    Away, I do beseech you, both away:
+    I'll board him presently.
+
+    Exeunt KING CLAUDIUS, QUEEN GERTRUDE, and Attendants
+
+    Enter HAMLET, reading
+    O, give me leave:
+    How does my good Lord Hamlet?
+
+HAMLET
+
+    Well, God-a-mercy.
+
+LORD POLONIUS
+
+    Do you know me, my lord?
+
+HAMLET
+
+    Excellent well; you are a fishmonger.
+
+LORD POLONIUS
+
+    Not I, my lord.
+
+HAMLET
+
+    Then I would you were so honest a man.
+
+LORD POLONIUS
+
+    Honest, my lord!
+
+HAMLET
+
+    Ay, sir; to be honest, as this world goes, is to be
+    one man picked out of ten thousand.
+
+LORD POLONIUS
+
+    That's very true, my lord.
+
+HAMLET
+
+    For if the sun breed maggots in a dead dog, being a
+    god kissing carrion,--Have you a daughter?
+
+LORD POLONIUS
+
+    I have, my lord.
+
+HAMLET
+
+    Let her not walk i' the sun: conception is a
+    blessing: but not as your daughter may conceive.
+    Friend, look to 't.
+
+LORD POLONIUS
+
+    [Aside] How say you by that? Still harping on my
+    daughter: yet he knew me not at first; he said I
+    was a fishmonger: he is far gone, far gone: and
+    truly in my youth I suffered much extremity for
+    love; very near this. I'll speak to him again.
+    What do you read, my lord?
+
+HAMLET
+
+    Words, words, words.
+
+LORD POLONIUS
+
+    What is the matter, my lord?
+
+HAMLET
+
+    Between who?
+
+LORD POLONIUS
+
+    I mean, the matter that you read, my lord.
+
+HAMLET
+
+    Slanders, sir: for the satirical rogue says here
+    that old men have grey beards, that their faces are
+    wrinkled, their eyes purging thick amber and
+    plum-tree gum and that they have a plentiful lack of
+    wit, together with most weak hams: all which, sir,
+    though I most powerfully and potently believe, yet
+    I hold it not honesty to have it thus set down, for
+    yourself, sir, should be old as I am, if like a crab
+    you could go backward.
+
+LORD POLONIUS
+
+    [Aside] Though this be madness, yet there is method
+    in 't. Will you walk out of the air, my lord?
+
+HAMLET
+
+    Into my grave.
+
+LORD POLONIUS
+
+    Indeed, that is out o' the air.
+
+    Aside
+    How pregnant sometimes his replies are! a happiness
+    that often madness hits on, which reason and sanity
+    could not so prosperously be delivered of. I will
+    leave him, and suddenly contrive the means of
+    meeting between him and my daughter.--My honourable
+    lord, I will most humbly take my leave of you.
+
+HAMLET
+
+    You cannot, sir, take from me any thing that I will
+    more willingly part withal: except my life, except
+    my life, except my life.
+
+LORD POLONIUS
+
+    Fare you well, my lord.
+
+HAMLET
+
+    These tedious old fools!
+
+    Enter ROSENCRANTZ and GUILDENSTERN
+
+LORD POLONIUS
+
+    You go to seek the Lord Hamlet; there he is.
+
+ROSENCRANTZ
+
+    [To POLONIUS] God save you, sir!
+
+    Exit POLONIUS
+
+GUILDENSTERN
+
+    My honoured lord!
+
+ROSENCRANTZ
+
+    My most dear lord!
+
+HAMLET
+
+    My excellent good friends! How dost thou,
+    Guildenstern? Ah, Rosencrantz! Good lads, how do ye both?
+
+ROSENCRANTZ
+
+    As the indifferent children of the earth.
+
+GUILDENSTERN
+
+    Happy, in that we are not over-happy;
+    On fortune's cap we are not the very button.
+
+HAMLET
+
+    Nor the soles of her shoe?
+
+ROSENCRANTZ
+
+    Neither, my lord.
+
+HAMLET
+
+    Then you live about her waist, or in the middle of
+    her favours?
+
+GUILDENSTERN
+
+    'Faith, her privates we.
+
+HAMLET
+
+    In the secret parts of fortune? O, most true; she
+    is a strumpet. What's the news?
+
+ROSENCRANTZ
+
+    None, my lord, but that the world's grown honest.
+
+HAMLET
+
+    Then is doomsday near: but your news is not true.
+    Let me question more in particular: what have you,
+    my good friends, deserved at the hands of fortune,
+    that she sends you to prison hither?
+
+GUILDENSTERN
+
+    Prison, my lord!
+
+HAMLET
+
+    Denmark's a prison.
+
+ROSENCRANTZ
+
+    Then is the world one.
+
+HAMLET
+
+    A goodly one; in which there are many confines,
+    wards and dungeons, Denmark being one o' the worst.
+
+ROSENCRANTZ
+
+    We think not so, my lord.
+
+HAMLET
+
+    Why, then, 'tis none to you; for there is nothing
+    either good or bad, but thinking makes it so: to me
+    it is a prison.
+
+ROSENCRANTZ
+
+    Why then, your ambition makes it one; 'tis too
+    narrow for your mind.
+
+HAMLET
+
+    O God, I could be bounded in a nut shell and count
+    myself a king of infinite space, were it not that I
+    have bad dreams.
+
+GUILDENSTERN
+
+    Which dreams indeed are ambition, for the very
+    substance of the ambitious is merely the shadow of a dream.
+
+HAMLET
+
+    A dream itself is but a shadow.
+
+ROSENCRANTZ
+
+    Truly, and I hold ambition of so airy and light a
+    quality that it is but a shadow's shadow.
+
+HAMLET
+
+    Then are our beggars bodies, and our monarchs and
+    outstretched heroes the beggars' shadows. Shall we
+    to the court? for, by my fay, I cannot reason.
+
+ROSENCRANTZ GUILDENSTERN
+
+    We'll wait upon you.
+
+HAMLET
+
+    No such matter: I will not sort you with the rest
+    of my servants, for, to speak to you like an honest
+    man, I am most dreadfully attended. But, in the
+    beaten way of friendship, what make you at Elsinore?
+
+ROSENCRANTZ
+
+    To visit you, my lord; no other occasion.
+
+HAMLET
+
+    Beggar that I am, I am even poor in thanks; but I
+    thank you: and sure, dear friends, my thanks are
+    too dear a halfpenny. Were you not sent for? Is it
+    your own inclining? Is it a free visitation? Come,
+    deal justly with me: come, come; nay, speak.
+
+GUILDENSTERN
+
+    What should we say, my lord?
+
+HAMLET
+
+    Why, any thing, but to the purpose. You were sent
+    for; and there is a kind of confession in your looks
+    which your modesties have not craft enough to colour:
+    I know the good king and queen have sent for you.
+
+ROSENCRANTZ
+
+    To what end, my lord?
+
+HAMLET
+
+    That you must teach me. But let me conjure you, by
+    the rights of our fellowship, by the consonancy of
+    our youth, by the obligation of our ever-preserved
+    love, and by what more dear a better proposer could
+    charge you withal, be even and direct with me,
+    whether you were sent for, or no?
+
+ROSENCRANTZ
+
+    [Aside to GUILDENSTERN] What say you?
+
+HAMLET
+
+    [Aside] Nay, then, I have an eye of you.--If you
+    love me, hold not off.
+
+GUILDENSTERN
+
+    My lord, we were sent for.
+
+HAMLET
+
+    I will tell you why; so shall my anticipation
+    prevent your discovery, and your secrecy to the king
+    and queen moult no feather. I have of late--but
+    wherefore I know not--lost all my mirth, forgone all
+    custom of exercises; and indeed it goes so heavily
+    with my disposition that this goodly frame, the
+    earth, seems to me a sterile promontory, this most
+    excellent canopy, the air, look you, this brave
+    o'erhanging firmament, this majestical roof fretted
+    with golden fire, why, it appears no other thing to
+    me than a foul and pestilent congregation of vapours.
+    What a piece of work is a man! how noble in reason!
+    how infinite in faculty! in form and moving how
+    express and admirable! in action how like an angel!
+    in apprehension how like a god! the beauty of the
+    world! the paragon of animals! And yet, to me,
+    what is this quintessence of dust? man delights not
+    me: no, nor woman neither, though by your smiling
+    you seem to say so.
+
+ROSENCRANTZ
+
+    My lord, there was no such stuff in my thoughts.
+
+HAMLET
+
+    Why did you laugh then, when I said 'man delights not me'?
+
+ROSENCRANTZ
+
+    To think, my lord, if you delight not in man, what
+    lenten entertainment the players shall receive from
+    you: we coted them on the way; and hither are they
+    coming, to offer you service.
+
+HAMLET
+
+    He that plays the king shall be welcome; his majesty
+    shall have tribute of me; the adventurous knight
+    shall use his foil and target; the lover shall not
+    sigh gratis; the humourous man shall end his part
+    in peace; the clown shall make those laugh whose
+    lungs are tickled o' the sere; and the lady shall
+    say her mind freely, or the blank verse shall halt
+    for't. What players are they?
+
+ROSENCRANTZ
+
+    Even those you were wont to take delight in, the
+    tragedians of the city.
+
+HAMLET
+
+    How chances it they travel? their residence, both
+    in reputation and profit, was better both ways.
+
+ROSENCRANTZ
+
+    I think their inhibition comes by the means of the
+    late innovation.
+
+HAMLET
+
+    Do they hold the same estimation they did when I was
+    in the city? are they so followed?
+
+ROSENCRANTZ
+
+    No, indeed, are they not.
+
+HAMLET
+
+    How comes it? do they grow rusty?
+
+ROSENCRANTZ
+
+    Nay, their endeavour keeps in the wonted pace: but
+    there is, sir, an aery of children, little eyases,
+    that cry out on the top of question, and are most
+    tyrannically clapped for't: these are now the
+    fashion, and so berattle the common stages--so they
+    call them--that many wearing rapiers are afraid of
+    goose-quills and dare scarce come thither.
+
+HAMLET
+
+    What, are they children? who maintains 'em? how are
+    they escoted? Will they pursue the quality no
+    longer than they can sing? will they not say
+    afterwards, if they should grow themselves to common
+    players--as it is most like, if their means are no
+    better--their writers do them wrong, to make them
+    exclaim against their own succession?
+
+ROSENCRANTZ
+
+    'Faith, there has been much to do on both sides; and
+    the nation holds it no sin to tarre them to
+    controversy: there was, for a while, no money bid
+    for argument, unless the poet and the player went to
+    cuffs in the question.
+
+HAMLET
+
+    Is't possible?
+
+GUILDENSTERN
+
+    O, there has been much throwing about of brains.
+
+HAMLET
+
+    Do the boys carry it away?
+
+ROSENCRANTZ
+
+    Ay, that they do, my lord; Hercules and his load too.
+
+HAMLET
+
+    It is not very strange; for mine uncle is king of
+    Denmark, and those that would make mows at him while
+    my father lived, give twenty, forty, fifty, an
+    hundred ducats a-piece for his picture in little.
+    'Sblood, there is something in this more than
+    natural, if philosophy could find it out.
+
+    Flourish of trumpets within
+
+GUILDENSTERN
+
+    There are the players.
+
+HAMLET
+
+    Gentlemen, you are welcome to Elsinore. Your hands,
+    come then: the appurtenance of welcome is fashion
+    and ceremony: let me comply with you in this garb,
+    lest my extent to the players, which, I tell you,
+    must show fairly outward, should more appear like
+    entertainment than yours. You are welcome: but my
+    uncle-father and aunt-mother are deceived.
+
+GUILDENSTERN
+
+    In what, my dear lord?
+
+HAMLET
+
+    I am but mad north-north-west: when the wind is
+    southerly I know a hawk from a handsaw.
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    Well be with you, gentlemen!
+
+HAMLET
+
+    Hark you, Guildenstern; and you too: at each ear a
+    hearer: that great baby you see there is not yet
+    out of his swaddling-clouts.
+
+ROSENCRANTZ
+
+    Happily he's the second time come to them; for they
+    say an old man is twice a child.
+
+HAMLET
+
+    I will prophesy he comes to tell me of the players;
+    mark it. You say right, sir: o' Monday morning;
+    'twas so indeed.
+
+LORD POLONIUS
+
+    My lord, I have news to tell you.
+
+HAMLET
+
+    My lord, I have news to tell you.
+    When Roscius was an actor in Rome,--
+
+LORD POLONIUS
+
+    The actors are come hither, my lord.
+
+HAMLET
+
+    Buz, buz!
+
+LORD POLONIUS
+
+    Upon mine honour,--
+
+HAMLET
+
+    Then came each actor on his ass,--
+
+LORD POLONIUS
+
+    The best actors in the world, either for tragedy,
+    comedy, history, pastoral, pastoral-comical,
+    historical-pastoral, tragical-historical, tragical-
+    comical-historical-pastoral, scene individable, or
+    poem unlimited: Seneca cannot be too heavy, nor
+    Plautus too light. For the law of writ and the
+    liberty, these are the only men.
+
+HAMLET
+
+    O Jephthah, judge of Israel, what a treasure hadst thou!
+
+LORD POLONIUS
+
+    What a treasure had he, my lord?
+
+HAMLET
+
+    Why,
+    'One fair daughter and no more,
+    The which he loved passing well.'
+
+LORD POLONIUS
+
+    [Aside] Still on my daughter.
+
+HAMLET
+
+    Am I not i' the right, old Jephthah?
+
+LORD POLONIUS
+
+    If you call me Jephthah, my lord, I have a daughter
+    that I love passing well.
+
+HAMLET
+
+    Nay, that follows not.
+
+LORD POLONIUS
+
+    What follows, then, my lord?
+
+HAMLET
+
+    Why,
+    'As by lot, God wot,'
+    and then, you know,
+    'It came to pass, as most like it was,'--
+    the first row of the pious chanson will show you
+    more; for look, where my abridgement comes.
+
+    Enter four or five Players
+    You are welcome, masters; welcome, all. I am glad
+    to see thee well. Welcome, good friends. O, my old
+    friend! thy face is valenced since I saw thee last:
+    comest thou to beard me in Denmark? What, my young
+    lady and mistress! By'r lady, your ladyship is
+    nearer to heaven than when I saw you last, by the
+    altitude of a chopine. Pray God, your voice, like
+    apiece of uncurrent gold, be not cracked within the
+    ring. Masters, you are all welcome. We'll e'en
+    to't like French falconers, fly at any thing we see:
+    we'll have a speech straight: come, give us a taste
+    of your quality; come, a passionate speech.
+
+First Player
+
+    What speech, my lord?
+
+HAMLET
+
+    I heard thee speak me a speech once, but it was
+    never acted; or, if it was, not above once; for the
+    play, I remember, pleased not the million; 'twas
+    caviare to the general: but it was--as I received
+    it, and others, whose judgments in such matters
+    cried in the top of mine--an excellent play, well
+    digested in the scenes, set down with as much
+    modesty as cunning. I remember, one said there
+    were no sallets in the lines to make the matter
+    savoury, nor no matter in the phrase that might
+    indict the author of affectation; but called it an
+    honest method, as wholesome as sweet, and by very
+    much more handsome than fine. One speech in it I
+    chiefly loved: 'twas Aeneas' tale to Dido; and
+    thereabout of it especially, where he speaks of
+    Priam's slaughter: if it live in your memory, begin
+    at this line: let me see, let me see--
+    'The rugged Pyrrhus, like the Hyrcanian beast,'--
+    it is not so:--it begins with Pyrrhus:--
+    'The rugged Pyrrhus, he whose sable arms,
+    Black as his purpose, did the night resemble
+    When he lay couched in the ominous horse,
+    Hath now this dread and black complexion smear'd
+    With heraldry more dismal; head to foot
+    Now is he total gules; horridly trick'd
+    With blood of fathers, mothers, daughters, sons,
+    Baked and impasted with the parching streets,
+    That lend a tyrannous and damned light
+    To their lord's murder: roasted in wrath and fire,
+    And thus o'er-sized with coagulate gore,
+    With eyes like carbuncles, the hellish Pyrrhus
+    Old grandsire Priam seeks.'
+    So, proceed you.
+
+LORD POLONIUS
+
+    'Fore God, my lord, well spoken, with good accent and
+    good discretion.
+
+First Player
+
+    'Anon he finds him
+    Striking too short at Greeks; his antique sword,
+    Rebellious to his arm, lies where it falls,
+    Repugnant to command: unequal match'd,
+    Pyrrhus at Priam drives; in rage strikes wide;
+    But with the whiff and wind of his fell sword
+    The unnerved father falls. Then senseless Ilium,
+    Seeming to feel this blow, with flaming top
+    Stoops to his base, and with a hideous crash
+    Takes prisoner Pyrrhus' ear: for, lo! his sword,
+    Which was declining on the milky head
+    Of reverend Priam, seem'd i' the air to stick:
+    So, as a painted tyrant, Pyrrhus stood,
+    And like a neutral to his will and matter,
+    Did nothing.
+    But, as we often see, against some storm,
+    A silence in the heavens, the rack stand still,
+    The bold winds speechless and the orb below
+    As hush as death, anon the dreadful thunder
+    Doth rend the region, so, after Pyrrhus' pause,
+    Aroused vengeance sets him new a-work;
+    And never did the Cyclops' hammers fall
+    On Mars's armour forged for proof eterne
+    With less remorse than Pyrrhus' bleeding sword
+    Now falls on Priam.
+    Out, out, thou strumpet, Fortune! All you gods,
+    In general synod 'take away her power;
+    Break all the spokes and fellies from her wheel,
+    And bowl the round nave down the hill of heaven,
+    As low as to the fiends!'
+
+LORD POLONIUS
+
+    This is too long.
+
+HAMLET
+
+    It shall to the barber's, with your beard. Prithee,
+    say on: he's for a jig or a tale of bawdry, or he
+    sleeps: say on: come to Hecuba.
+
+First Player
+
+    'But who, O, who had seen the mobled queen--'
+
+HAMLET
+
+    'The mobled queen?'
+
+LORD POLONIUS
+
+    That's good; 'mobled queen' is good.
+
+First Player
+
+    'Run barefoot up and down, threatening the flames
+    With bisson rheum; a clout upon that head
+    Where late the diadem stood, and for a robe,
+    About her lank and all o'er-teemed loins,
+    A blanket, in the alarm of fear caught up;
+    Who this had seen, with tongue in venom steep'd,
+    'Gainst Fortune's state would treason have
+    pronounced:
+    But if the gods themselves did see her then
+    When she saw Pyrrhus make malicious sport
+    In mincing with his sword her husband's limbs,
+    The instant burst of clamour that she made,
+    Unless things mortal move them not at all,
+    Would have made milch the burning eyes of heaven,
+    And passion in the gods.'
+
+LORD POLONIUS
+
+    Look, whether he has not turned his colour and has
+    tears in's eyes. Pray you, no more.
+
+HAMLET
+
+    'Tis well: I'll have thee speak out the rest soon.
+    Good my lord, will you see the players well
+    bestowed? Do you hear, let them be well used; for
+    they are the abstract and brief chronicles of the
+    time: after your death you were better have a bad
+    epitaph than their ill report while you live.
+
+LORD POLONIUS
+
+    My lord, I will use them according to their desert.
+
+HAMLET
+
+    God's bodykins, man, much better: use every man
+    after his desert, and who should 'scape whipping?
+    Use them after your own honour and dignity: the less
+    they deserve, the more merit is in your bounty.
+    Take them in.
+
+LORD POLONIUS
+
+    Come, sirs.
+
+HAMLET
+
+    Follow him, friends: we'll hear a play to-morrow.
+
+    Exit POLONIUS with all the Players but the First
+    Dost thou hear me, old friend; can you play the
+    Murder of Gonzago?
+
+First Player
+
+    Ay, my lord.
+
+HAMLET
+
+    We'll ha't to-morrow night. You could, for a need,
+    study a speech of some dozen or sixteen lines, which
+    I would set down and insert in't, could you not?
+
+First Player
+
+    Ay, my lord.
+
+HAMLET
+
+    Very well. Follow that lord; and look you mock him
+    not.
+
+    Exit First Player
+    My good friends, I'll leave you till night: you are
+    welcome to Elsinore.
+
+ROSENCRANTZ
+
+    Good my lord!
+
+HAMLET
+
+    Ay, so, God be wi' ye;
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Now I am alone.
+    O, what a rogue and peasant slave am I!
+    Is it not monstrous that this player here,
+    But in a fiction, in a dream of passion,
+    Could force his soul so to his own conceit
+    That from her working all his visage wann'd,
+    Tears in his eyes, distraction in's aspect,
+    A broken voice, and his whole function suiting
+    With forms to his conceit? and all for nothing!
+    For Hecuba!
+    What's Hecuba to him, or he to Hecuba,
+    That he should weep for her? What would he do,
+    Had he the motive and the cue for passion
+    That I have? He would drown the stage with tears
+    And cleave the general ear with horrid speech,
+    Make mad the guilty and appal the free,
+    Confound the ignorant, and amaze indeed
+    The very faculties of eyes and ears. Yet I,
+    A dull and muddy-mettled rascal, peak,
+    Like John-a-dreams, unpregnant of my cause,
+    And can say nothing; no, not for a king,
+    Upon whose property and most dear life
+    A damn'd defeat was made. Am I a coward?
+    Who calls me villain? breaks my pate across?
+    Plucks off my beard, and blows it in my face?
+    Tweaks me by the nose? gives me the lie i' the throat,
+    As deep as to the lungs? who does me this?
+    Ha!
+    'Swounds, I should take it: for it cannot be
+    But I am pigeon-liver'd and lack gall
+    To make oppression bitter, or ere this
+    I should have fatted all the region kites
+    With this slave's offal: bloody, bawdy villain!
+    Remorseless, treacherous, lecherous, kindless villain!
+    O, vengeance!
+    Why, what an ass am I! This is most brave,
+    That I, the son of a dear father murder'd,
+    Prompted to my revenge by heaven and hell,
+    Must, like a whore, unpack my heart with words,
+    And fall a-cursing, like a very drab,
+    A scullion!
+    Fie upon't! foh! About, my brain! I have heard
+    That guilty creatures sitting at a play
+    Have by the very cunning of the scene
+    Been struck so to the soul that presently
+    They have proclaim'd their malefactions;
+    For murder, though it have no tongue, will speak
+    With most miraculous organ. I'll have these players
+    Play something like the murder of my father
+    Before mine uncle: I'll observe his looks;
+    I'll tent him to the quick: if he but blench,
+    I know my course. The spirit that I have seen
+    May be the devil: and the devil hath power
+    To assume a pleasing shape; yea, and perhaps
+    Out of my weakness and my melancholy,
+    As he is very potent with such spirits,
+    Abuses me to damn me: I'll have grounds
+    More relative than this: the play 's the thing
+    Wherein I'll catch the conscience of the king.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene1.txt
new file mode 100644
index 0000000..8a761a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene1.txt
@@ -0,0 +1,357 @@
+ACT III
+SCENE I. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, POLONIUS, OPHELIA, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    And can you, by no drift of circumstance,
+    Get from him why he puts on this confusion,
+    Grating so harshly all his days of quiet
+    With turbulent and dangerous lunacy?
+
+ROSENCRANTZ
+
+    He does confess he feels himself distracted;
+    But from what cause he will by no means speak.
+
+GUILDENSTERN
+
+    Nor do we find him forward to be sounded,
+    But, with a crafty madness, keeps aloof,
+    When we would bring him on to some confession
+    Of his true state.
+
+QUEEN GERTRUDE
+
+    Did he receive you well?
+
+ROSENCRANTZ
+
+    Most like a gentleman.
+
+GUILDENSTERN
+
+    But with much forcing of his disposition.
+
+ROSENCRANTZ
+
+    Niggard of question; but, of our demands,
+    Most free in his reply.
+
+QUEEN GERTRUDE
+
+    Did you assay him?
+    To any pastime?
+
+ROSENCRANTZ
+
+    Madam, it so fell out, that certain players
+    We o'er-raught on the way: of these we told him;
+    And there did seem in him a kind of joy
+    To hear of it: they are about the court,
+    And, as I think, they have already order
+    This night to play before him.
+
+LORD POLONIUS
+
+    'Tis most true:
+    And he beseech'd me to entreat your majesties
+    To hear and see the matter.
+
+KING CLAUDIUS
+
+    With all my heart; and it doth much content me
+    To hear him so inclined.
+    Good gentlemen, give him a further edge,
+    And drive his purpose on to these delights.
+
+ROSENCRANTZ
+
+    We shall, my lord.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+KING CLAUDIUS
+
+    Sweet Gertrude, leave us too;
+    For we have closely sent for Hamlet hither,
+    That he, as 'twere by accident, may here
+    Affront Ophelia:
+    Her father and myself, lawful espials,
+    Will so bestow ourselves that, seeing, unseen,
+    We may of their encounter frankly judge,
+    And gather by him, as he is behaved,
+    If 't be the affliction of his love or no
+    That thus he suffers for.
+
+QUEEN GERTRUDE
+
+    I shall obey you.
+    And for your part, Ophelia, I do wish
+    That your good beauties be the happy cause
+    Of Hamlet's wildness: so shall I hope your virtues
+    Will bring him to his wonted way again,
+    To both your honours.
+
+OPHELIA
+
+    Madam, I wish it may.
+
+    Exit QUEEN GERTRUDE
+
+LORD POLONIUS
+
+    Ophelia, walk you here. Gracious, so please you,
+    We will bestow ourselves.
+
+    To OPHELIA
+    Read on this book;
+    That show of such an exercise may colour
+    Your loneliness. We are oft to blame in this,--
+    'Tis too much proved--that with devotion's visage
+    And pious action we do sugar o'er
+    The devil himself.
+
+KING CLAUDIUS
+
+    [Aside] O, 'tis too true!
+    How smart a lash that speech doth give my conscience!
+    The harlot's cheek, beautied with plastering art,
+    Is not more ugly to the thing that helps it
+    Than is my deed to my most painted word:
+    O heavy burthen!
+
+LORD POLONIUS
+
+    I hear him coming: let's withdraw, my lord.
+
+    Exeunt KING CLAUDIUS and POLONIUS
+
+    Enter HAMLET
+
+HAMLET
+
+    To be, or not to be, that is the question,
+    Whether 'tis nobler in the mind to suffer
+    The slings and arrows of outrageous fortune,
+    Or to take arms against a sea of troubles,
+    And by opposing end them? To die: to sleep;
+    No more; and by a sleep to say we end
+    The heart-ache and the thousand natural shocks
+    That flesh is heir to, 'tis a consummation
+    Devoutly to be wish'd. To die, to sleep;
+    To sleep: perchance to dream: ay, there's the rub;
+    For in that sleep of death what dreams may come
+    When we have shuffled off this mortal coil,
+    Must give us pause: there's the respect
+    That makes calamity of so long life;
+    For who would bear the whips and scorns of time,
+    The oppressor's wrong, the proud man's contumely,
+    The pangs of despised love, the law's delay,
+    The insolence of office and the spurns
+    That patient merit of the unworthy takes,
+    When he himself might his quietus make
+    With a bare bodkin? who would fardels bear,
+    To grunt and sweat under a weary life,
+    But that the dread of something after death,
+    The undiscover'd country from whose bourn
+    No traveller returns, puzzles the will
+    And makes us rather bear those ills we have
+    Than fly to others that we know not of?
+    Thus conscience does make cowards of us all;
+    And thus the native hue of resolution
+    Is sicklied o'er with the pale cast of thought,
+    And enterprises of great pith and moment
+    With this regard their currents turn awry,
+    And lose the name of action.--Soft you now!
+    The fair Ophelia! Nymph, in thy orisons
+    Be all my sins remember'd.
+
+OPHELIA
+
+    Good my lord,
+    How does your honour for this many a day?
+
+HAMLET
+
+    I humbly thank you; well, well, well.
+
+OPHELIA
+
+    My lord, I have remembrances of yours,
+    That I have longed long to re-deliver;
+    I pray you, now receive them.
+
+HAMLET
+
+    No, not I;
+    I never gave you aught.
+
+OPHELIA
+
+    My honour'd lord, you know right well you did;
+    And, with them, words of so sweet breath composed
+    As made the things more rich: their perfume lost,
+    Take these again; for to the noble mind
+    Rich gifts wax poor when givers prove unkind.
+    There, my lord.
+
+HAMLET
+
+    Ha, ha! are you honest?
+
+OPHELIA
+
+    My lord?
+
+HAMLET
+
+    Are you fair?
+
+OPHELIA
+
+    What means your lordship?
+
+HAMLET
+
+    That if you be honest and fair, your honesty should
+    admit no discourse to your beauty.
+
+OPHELIA
+
+    Could beauty, my lord, have better commerce than
+    with honesty?
+
+HAMLET
+
+    Ay, truly; for the power of beauty will sooner
+    transform honesty from what it is to a bawd than the
+    force of honesty can translate beauty into his
+    likeness: this was sometime a paradox, but now the
+    time gives it proof. I did love you once.
+
+OPHELIA
+
+    Indeed, my lord, you made me believe so.
+
+HAMLET
+
+    You should not have believed me; for virtue cannot
+    so inoculate our old stock but we shall relish of
+    it: I loved you not.
+
+OPHELIA
+
+    I was the more deceived.
+
+HAMLET
+
+    Get thee to a nunnery: why wouldst thou be a
+    breeder of sinners? I am myself indifferent honest;
+    but yet I could accuse me of such things that it
+    were better my mother had not borne me: I am very
+    proud, revengeful, ambitious, with more offences at
+    my beck than I have thoughts to put them in,
+    imagination to give them shape, or time to act them
+    in. What should such fellows as I do crawling
+    between earth and heaven? We are arrant knaves,
+    all; believe none of us. Go thy ways to a nunnery.
+    Where's your father?
+
+OPHELIA
+
+    At home, my lord.
+
+HAMLET
+
+    Let the doors be shut upon him, that he may play the
+    fool no where but in's own house. Farewell.
+
+OPHELIA
+
+    O, help him, you sweet heavens!
+
+HAMLET
+
+    If thou dost marry, I'll give thee this plague for
+    thy dowry: be thou as chaste as ice, as pure as
+    snow, thou shalt not escape calumny. Get thee to a
+    nunnery, go: farewell. Or, if thou wilt needs
+    marry, marry a fool; for wise men know well enough
+    what monsters you make of them. To a nunnery, go,
+    and quickly too. Farewell.
+
+OPHELIA
+
+    O heavenly powers, restore him!
+
+HAMLET
+
+    I have heard of your paintings too, well enough; God
+    has given you one face, and you make yourselves
+    another: you jig, you amble, and you lisp, and
+    nick-name God's creatures, and make your wantonness
+    your ignorance. Go to, I'll no more on't; it hath
+    made me mad. I say, we will have no more marriages:
+    those that are married already, all but one, shall
+    live; the rest shall keep as they are. To a
+    nunnery, go.
+
+    Exit
+
+OPHELIA
+
+    O, what a noble mind is here o'erthrown!
+    The courtier's, soldier's, scholar's, eye, tongue, sword;
+    The expectancy and rose of the fair state,
+    The glass of fashion and the mould of form,
+    The observed of all observers, quite, quite down!
+    And I, of ladies most deject and wretched,
+    That suck'd the honey of his music vows,
+    Now see that noble and most sovereign reason,
+    Like sweet bells jangled, out of tune and harsh;
+    That unmatch'd form and feature of blown youth
+    Blasted with ecstasy: O, woe is me,
+    To have seen what I have seen, see what I see!
+
+    Re-enter KING CLAUDIUS and POLONIUS
+
+KING CLAUDIUS
+
+    Love! his affections do not that way tend;
+    Nor what he spake, though it lack'd form a little,
+    Was not like madness. There's something in his soul,
+    O'er which his melancholy sits on brood;
+    And I do doubt the hatch and the disclose
+    Will be some danger: which for to prevent,
+    I have in quick determination
+    Thus set it down: he shall with speed to England,
+    For the demand of our neglected tribute
+    Haply the seas and countries different
+    With variable objects shall expel
+    This something-settled matter in his heart,
+    Whereon his brains still beating puts him thus
+    From fashion of himself. What think you on't?
+
+LORD POLONIUS
+
+    It shall do well: but yet do I believe
+    The origin and commencement of his grief
+    Sprung from neglected love. How now, Ophelia!
+    You need not tell us what Lord Hamlet said;
+    We heard it all. My lord, do as you please;
+    But, if you hold it fit, after the play
+    Let his queen mother all alone entreat him
+    To show his grief: let her be round with him;
+    And I'll be placed, so please you, in the ear
+    Of all their conference. If she find him not,
+    To England send him, or confine him where
+    Your wisdom best shall think.
+
+KING CLAUDIUS
+
+    It shall be so:
+    Madness in great ones must not unwatch'd go.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene2.txt
new file mode 100644
index 0000000..09aca1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene2.txt
@@ -0,0 +1,863 @@
+SCENE II. A hall in the castle.
+
+    Enter HAMLET and Players 
+
+HAMLET
+
+    Speak the speech, I pray you, as I pronounced it to
+    you, trippingly on the tongue: but if you mouth it,
+    as many of your players do, I had as lief the
+    town-crier spoke my lines. Nor do not saw the air
+    too much with your hand, thus, but use all gently;
+    for in the very torrent, tempest, and, as I may say,
+    the whirlwind of passion, you must acquire and beget
+    a temperance that may give it smoothness. O, it
+    offends me to the soul to hear a robustious
+    periwig-pated fellow tear a passion to tatters, to
+    very rags, to split the ears of the groundlings, who
+    for the most part are capable of nothing but
+    inexplicable dumbshows and noise: I would have such
+    a fellow whipped for o'erdoing Termagant; it
+    out-herods Herod: pray you, avoid it.
+
+First Player
+
+    I warrant your honour.
+
+HAMLET
+
+    Be not too tame neither, but let your own discretion
+    be your tutor: suit the action to the word, the
+    word to the action; with this special o'erstep not
+    the modesty of nature: for any thing so overdone is
+    from the purpose of playing, whose end, both at the
+    first and now, was and is, to hold, as 'twere, the
+    mirror up to nature; to show virtue her own feature,
+    scorn her own image, and the very age and body of
+    the time his form and pressure. Now this overdone,
+    or come tardy off, though it make the unskilful
+    laugh, cannot but make the judicious grieve; the
+    censure of the which one must in your allowance
+    o'erweigh a whole theatre of others. O, there be
+    players that I have seen play, and heard others
+    praise, and that highly, not to speak it profanely,
+    that, neither having the accent of Christians nor
+    the gait of Christian, pagan, nor man, have so
+    strutted and bellowed that I have thought some of
+    nature's journeymen had made men and not made them
+    well, they imitated humanity so abominably.
+
+First Player
+
+    I hope we have reformed that indifferently with us,
+    sir.
+
+HAMLET
+
+    O, reform it altogether. And let those that play
+    your clowns speak no more than is set down for them;
+    for there be of them that will themselves laugh, to
+    set on some quantity of barren spectators to laugh
+    too; though, in the mean time, some necessary
+    question of the play be then to be considered:
+    that's villanous, and shows a most pitiful ambition
+    in the fool that uses it. Go, make you ready.
+
+    Exeunt Players
+
+    Enter POLONIUS, ROSENCRANTZ, and GUILDENSTERN
+    How now, my lord! I will the king hear this piece of work?
+
+LORD POLONIUS
+
+    And the queen too, and that presently.
+
+HAMLET
+
+    Bid the players make haste.
+
+    Exit POLONIUS
+    Will you two help to hasten them?
+
+ROSENCRANTZ GUILDENSTERN
+
+    We will, my lord.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+HAMLET
+
+    What ho! Horatio!
+
+    Enter HORATIO
+
+HORATIO
+
+    Here, sweet lord, at your service.
+
+HAMLET
+
+    Horatio, thou art e'en as just a man
+    As e'er my conversation coped withal.
+
+HORATIO
+
+    O, my dear lord,--
+
+HAMLET
+
+    Nay, do not think I flatter;
+    For what advancement may I hope from thee
+    That no revenue hast but thy good spirits,
+    To feed and clothe thee? Why should the poor be flatter'd?
+    No, let the candied tongue lick absurd pomp,
+    And crook the pregnant hinges of the knee
+    Where thrift may follow fawning. Dost thou hear?
+    Since my dear soul was mistress of her choice
+    And could of men distinguish, her election
+    Hath seal'd thee for herself; for thou hast been
+    As one, in suffering all, that suffers nothing,
+    A man that fortune's buffets and rewards
+    Hast ta'en with equal thanks: and blest are those
+    Whose blood and judgment are so well commingled,
+    That they are not a pipe for fortune's finger
+    To sound what stop she please. Give me that man
+    That is not passion's slave, and I will wear him
+    In my heart's core, ay, in my heart of heart,
+    As I do thee.--Something too much of this.--
+    There is a play to-night before the king;
+    One scene of it comes near the circumstance
+    Which I have told thee of my father's death:
+    I prithee, when thou seest that act afoot,
+    Even with the very comment of thy soul
+    Observe mine uncle: if his occulted guilt
+    Do not itself unkennel in one speech,
+    It is a damned ghost that we have seen,
+    And my imaginations are as foul
+    As Vulcan's stithy. Give him heedful note;
+    For I mine eyes will rivet to his face,
+    And after we will both our judgments join
+    In censure of his seeming.
+
+HORATIO
+
+    Well, my lord:
+    If he steal aught the whilst this play is playing,
+    And 'scape detecting, I will pay the theft.
+
+HAMLET
+
+    They are coming to the play; I must be idle:
+    Get you a place.
+
+    Danish march. A flourish. Enter KING CLAUDIUS, QUEEN GERTRUDE, POLONIUS, OPHELIA, ROSENCRANTZ, GUILDENSTERN, and others
+
+KING CLAUDIUS
+
+    How fares our cousin Hamlet?
+
+HAMLET
+
+    Excellent, i' faith; of the chameleon's dish: I eat
+    the air, promise-crammed: you cannot feed capons so.
+
+KING CLAUDIUS
+
+    I have nothing with this answer, Hamlet; these words
+    are not mine.
+
+HAMLET
+
+    No, nor mine now.
+
+    To POLONIUS
+    My lord, you played once i' the university, you say?
+
+LORD POLONIUS
+
+    That did I, my lord; and was accounted a good actor.
+
+HAMLET
+
+    What did you enact?
+
+LORD POLONIUS
+
+    I did enact Julius Caesar: I was killed i' the
+    Capitol; Brutus killed me.
+
+HAMLET
+
+    It was a brute part of him to kill so capital a calf
+    there. Be the players ready?
+
+ROSENCRANTZ
+
+    Ay, my lord; they stay upon your patience.
+
+QUEEN GERTRUDE
+
+    Come hither, my dear Hamlet, sit by me.
+
+HAMLET
+
+    No, good mother, here's metal more attractive.
+
+LORD POLONIUS
+
+    [To KING CLAUDIUS] O, ho! do you mark that?
+
+HAMLET
+
+    Lady, shall I lie in your lap?
+
+    Lying down at OPHELIA's feet
+
+OPHELIA
+
+    No, my lord.
+
+HAMLET
+
+    I mean, my head upon your lap?
+
+OPHELIA
+
+    Ay, my lord.
+
+HAMLET
+
+    Do you think I meant country matters?
+
+OPHELIA
+
+    I think nothing, my lord.
+
+HAMLET
+
+    That's a fair thought to lie between maids' legs.
+
+OPHELIA
+
+    What is, my lord?
+
+HAMLET
+
+    Nothing.
+
+OPHELIA
+
+    You are merry, my lord.
+
+HAMLET
+
+    Who, I?
+
+OPHELIA
+
+    Ay, my lord.
+
+HAMLET
+
+    O God, your only jig-maker. What should a man do
+    but be merry? for, look you, how cheerfully my
+    mother looks, and my father died within these two hours.
+
+OPHELIA
+
+    Nay, 'tis twice two months, my lord.
+
+HAMLET
+
+    So long? Nay then, let the devil wear black, for
+    I'll have a suit of sables. O heavens! die two
+    months ago, and not forgotten yet? Then there's
+    hope a great man's memory may outlive his life half
+    a year: but, by'r lady, he must build churches,
+    then; or else shall he suffer not thinking on, with
+    the hobby-horse, whose epitaph is 'For, O, for, O,
+    the hobby-horse is forgot.'
+
+    Hautboys play. The dumb-show enters
+
+    Enter a King and a Queen very lovingly; the Queen embracing him, and he her. She kneels, and makes show of protestation unto him. He takes her up, and declines his head upon her neck: lays him down upon a bank of flowers: she, seeing him asleep, leaves him. Anon comes in a fellow, takes off his crown, kisses it, and pours poison in the King's ears, and exit. The Queen returns; finds the King dead, and makes passionate action. The Poisoner, with some two or three Mutes, comes in again, seeming to lament with her. The dead body is carried away. The Poisoner wooes the Queen with gifts: she seems loath and unwilling awhile, but in the end accepts his love
+
+    Exeunt
+
+OPHELIA
+
+    What means this, my lord?
+
+HAMLET
+
+    Marry, this is miching mallecho; it means mischief.
+
+OPHELIA
+
+    Belike this show imports the argument of the play.
+
+    Enter Prologue
+
+HAMLET
+
+    We shall know by this fellow: the players cannot
+    keep counsel; they'll tell all.
+
+OPHELIA
+
+    Will he tell us what this show meant?
+
+HAMLET
+
+    Ay, or any show that you'll show him: be not you
+    ashamed to show, he'll not shame to tell you what it means.
+
+OPHELIA
+
+    You are naught, you are naught: I'll mark the play.
+
+Prologue
+
+    For us, and for our tragedy,
+    Here stooping to your clemency,
+    We beg your hearing patiently.
+
+    Exit
+
+HAMLET
+
+    Is this a prologue, or the posy of a ring?
+
+OPHELIA
+
+    'Tis brief, my lord.
+
+HAMLET
+
+    As woman's love.
+
+    Enter two Players, King and Queen
+
+Player King
+
+    Full thirty times hath Phoebus' cart gone round
+    Neptune's salt wash and Tellus' orbed ground,
+    And thirty dozen moons with borrow'd sheen
+    About the world have times twelve thirties been,
+    Since love our hearts and Hymen did our hands
+    Unite commutual in most sacred bands.
+
+Player Queen
+
+    So many journeys may the sun and moon
+    Make us again count o'er ere love be done!
+    But, woe is me, you are so sick of late,
+    So far from cheer and from your former state,
+    That I distrust you. Yet, though I distrust,
+    Discomfort you, my lord, it nothing must:
+    For women's fear and love holds quantity;
+    In neither aught, or in extremity.
+    Now, what my love is, proof hath made you know;
+    And as my love is sized, my fear is so:
+    Where love is great, the littlest doubts are fear;
+    Where little fears grow great, great love grows there.
+
+Player King
+
+    'Faith, I must leave thee, love, and shortly too;
+    My operant powers their functions leave to do:
+    And thou shalt live in this fair world behind,
+    Honour'd, beloved; and haply one as kind
+    For husband shalt thou--
+
+Player Queen
+
+    O, confound the rest!
+    Such love must needs be treason in my breast:
+    In second husband let me be accurst!
+    None wed the second but who kill'd the first.
+
+HAMLET
+
+    [Aside] Wormwood, wormwood.
+
+Player Queen
+
+    The instances that second marriage move
+    Are base respects of thrift, but none of love:
+    A second time I kill my husband dead,
+    When second husband kisses me in bed.
+
+Player King
+
+    I do believe you think what now you speak;
+    But what we do determine oft we break.
+    Purpose is but the slave to memory,
+    Of violent birth, but poor validity;
+    Which now, like fruit unripe, sticks on the tree;
+    But fall, unshaken, when they mellow be.
+    Most necessary 'tis that we forget
+    To pay ourselves what to ourselves is debt:
+    What to ourselves in passion we propose,
+    The passion ending, doth the purpose lose.
+    The violence of either grief or joy
+    Their own enactures with themselves destroy:
+    Where joy most revels, grief doth most lament;
+    Grief joys, joy grieves, on slender accident.
+    This world is not for aye, nor 'tis not strange
+    That even our loves should with our fortunes change;
+    For 'tis a question left us yet to prove,
+    Whether love lead fortune, or else fortune love.
+    The great man down, you mark his favourite flies;
+    The poor advanced makes friends of enemies.
+    And hitherto doth love on fortune tend;
+    For who not needs shall never lack a friend,
+    And who in want a hollow friend doth try,
+    Directly seasons him his enemy.
+    But, orderly to end where I begun,
+    Our wills and fates do so contrary run
+    That our devices still are overthrown;
+    Our thoughts are ours, their ends none of our own:
+    So think thou wilt no second husband wed;
+    But die thy thoughts when thy first lord is dead.
+
+Player Queen
+
+    Nor earth to me give food, nor heaven light!
+    Sport and repose lock from me day and night!
+    To desperation turn my trust and hope!
+    An anchor's cheer in prison be my scope!
+    Each opposite that blanks the face of joy
+    Meet what I would have well and it destroy!
+    Both here and hence pursue me lasting strife,
+    If, once a widow, ever I be wife!
+
+HAMLET
+
+    If she should break it now!
+
+Player King
+
+    'Tis deeply sworn. Sweet, leave me here awhile;
+    My spirits grow dull, and fain I would beguile
+    The tedious day with sleep.
+
+    Sleeps
+
+Player Queen
+
+    Sleep rock thy brain,
+    And never come mischance between us twain!
+
+    Exit
+
+HAMLET
+
+    Madam, how like you this play?
+
+QUEEN GERTRUDE
+
+    The lady protests too much, methinks.
+
+HAMLET
+
+    O, but she'll keep her word.
+
+KING CLAUDIUS
+
+    Have you heard the argument? Is there no offence in 't?
+
+HAMLET
+
+    No, no, they do but jest, poison in jest; no offence
+    i' the world.
+
+KING CLAUDIUS
+
+    What do you call the play?
+
+HAMLET
+
+    The Mouse-trap. Marry, how? Tropically. This play
+    is the image of a murder done in Vienna: Gonzago is
+    the duke's name; his wife, Baptista: you shall see
+    anon; 'tis a knavish piece of work: but what o'
+    that? your majesty and we that have free souls, it
+    touches us not: let the galled jade wince, our
+    withers are unwrung.
+
+    Enter LUCIANUS
+    This is one Lucianus, nephew to the king.
+
+OPHELIA
+
+    You are as good as a chorus, my lord.
+
+HAMLET
+
+    I could interpret between you and your love, if I
+    could see the puppets dallying.
+
+OPHELIA
+
+    You are keen, my lord, you are keen.
+
+HAMLET
+
+    It would cost you a groaning to take off my edge.
+
+OPHELIA
+
+    Still better, and worse.
+
+HAMLET
+
+    So you must take your husbands. Begin, murderer;
+    pox, leave thy damnable faces, and begin. Come:
+    'the croaking raven doth bellow for revenge.'
+
+LUCIANUS
+
+    Thoughts black, hands apt, drugs fit, and time agreeing;
+    Confederate season, else no creature seeing;
+    Thou mixture rank, of midnight weeds collected,
+    With Hecate's ban thrice blasted, thrice infected,
+    Thy natural magic and dire property,
+    On wholesome life usurp immediately.
+
+    Pours the poison into the sleeper's ears
+
+HAMLET
+
+    He poisons him i' the garden for's estate. His
+    name's Gonzago: the story is extant, and writ in
+    choice Italian: you shall see anon how the murderer
+    gets the love of Gonzago's wife.
+
+OPHELIA
+
+    The king rises.
+
+HAMLET
+
+    What, frighted with false fire!
+
+QUEEN GERTRUDE
+
+    How fares my lord?
+
+LORD POLONIUS
+
+    Give o'er the play.
+
+KING CLAUDIUS
+
+    Give me some light: away!
+
+All
+
+    Lights, lights, lights!
+
+    Exeunt all but HAMLET and HORATIO
+
+HAMLET
+
+    Why, let the stricken deer go weep,
+    The hart ungalled play;
+    For some must watch, while some must sleep:
+    So runs the world away.
+    Would not this, sir, and a forest of feathers-- if
+    the rest of my fortunes turn Turk with me--with two
+    Provincial roses on my razed shoes, get me a
+    fellowship in a cry of players, sir?
+
+HORATIO
+
+    Half a share.
+
+HAMLET
+
+    A whole one, I.
+    For thou dost know, O Damon dear,
+    This realm dismantled was
+    Of Jove himself; and now reigns here
+    A very, very--pajock.
+
+HORATIO
+
+    You might have rhymed.
+
+HAMLET
+
+    O good Horatio, I'll take the ghost's word for a
+    thousand pound. Didst perceive?
+
+HORATIO
+
+    Very well, my lord.
+
+HAMLET
+
+    Upon the talk of the poisoning?
+
+HORATIO
+
+    I did very well note him.
+
+HAMLET
+
+    Ah, ha! Come, some music! come, the recorders!
+    For if the king like not the comedy,
+    Why then, belike, he likes it not, perdy.
+    Come, some music!
+
+    Re-enter ROSENCRANTZ and GUILDENSTERN
+
+GUILDENSTERN
+
+    Good my lord, vouchsafe me a word with you.
+
+HAMLET
+
+    Sir, a whole history.
+
+GUILDENSTERN
+
+    The king, sir,--
+
+HAMLET
+
+    Ay, sir, what of him?
+
+GUILDENSTERN
+
+    Is in his retirement marvellous distempered.
+
+HAMLET
+
+    With drink, sir?
+
+GUILDENSTERN
+
+    No, my lord, rather with choler.
+
+HAMLET
+
+    Your wisdom should show itself more richer to
+    signify this to his doctor; for, for me to put him
+    to his purgation would perhaps plunge him into far
+    more choler.
+
+GUILDENSTERN
+
+    Good my lord, put your discourse into some frame and
+    start not so wildly from my affair.
+
+HAMLET
+
+    I am tame, sir: pronounce.
+
+GUILDENSTERN
+
+    The queen, your mother, in most great affliction of
+    spirit, hath sent me to you.
+
+HAMLET
+
+    You are welcome.
+
+GUILDENSTERN
+
+    Nay, good my lord, this courtesy is not of the right
+    breed. If it shall please you to make me a
+    wholesome answer, I will do your mother's
+    commandment: if not, your pardon and my return
+    shall be the end of my business.
+
+HAMLET
+
+    Sir, I cannot.
+
+GUILDENSTERN
+
+    What, my lord?
+
+HAMLET
+
+    Make you a wholesome answer; my wit's diseased: but,
+    sir, such answer as I can make, you shall command;
+    or, rather, as you say, my mother: therefore no
+    more, but to the matter: my mother, you say,--
+
+ROSENCRANTZ
+
+    Then thus she says; your behavior hath struck her
+    into amazement and admiration.
+
+HAMLET
+
+    O wonderful son, that can so astonish a mother! But
+    is there no sequel at the heels of this mother's
+    admiration? Impart.
+
+ROSENCRANTZ
+
+    She desires to speak with you in her closet, ere you
+    go to bed.
+
+HAMLET
+
+    We shall obey, were she ten times our mother. Have
+    you any further trade with us?
+
+ROSENCRANTZ
+
+    My lord, you once did love me.
+
+HAMLET
+
+    So I do still, by these pickers and stealers.
+
+ROSENCRANTZ
+
+    Good my lord, what is your cause of distemper? you
+    do, surely, bar the door upon your own liberty, if
+    you deny your griefs to your friend.
+
+HAMLET
+
+    Sir, I lack advancement.
+
+ROSENCRANTZ
+
+    How can that be, when you have the voice of the king
+    himself for your succession in Denmark?
+
+HAMLET
+
+    Ay, but sir, 'While the grass grows,'--the proverb
+    is something musty.
+
+    Re-enter Players with recorders
+    O, the recorders! let me see one. To withdraw with
+    you:--why do you go about to recover the wind of me,
+    as if you would drive me into a toil?
+
+GUILDENSTERN
+
+    O, my lord, if my duty be too bold, my love is too
+    unmannerly.
+
+HAMLET
+
+    I do not well understand that. Will you play upon
+    this pipe?
+
+GUILDENSTERN
+
+    My lord, I cannot.
+
+HAMLET
+
+    I pray you.
+
+GUILDENSTERN
+
+    Believe me, I cannot.
+
+HAMLET
+
+    I do beseech you.
+
+GUILDENSTERN
+
+    I know no touch of it, my lord.
+
+HAMLET
+
+    'Tis as easy as lying: govern these ventages with
+    your lingers and thumb, give it breath with your
+    mouth, and it will discourse most eloquent music.
+    Look you, these are the stops.
+
+GUILDENSTERN
+
+    But these cannot I command to any utterance of
+    harmony; I have not the skill.
+
+HAMLET
+
+    Why, look you now, how unworthy a thing you make of
+    me! You would play upon me; you would seem to know
+    my stops; you would pluck out the heart of my
+    mystery; you would sound me from my lowest note to
+    the top of my compass: and there is much music,
+    excellent voice, in this little organ; yet cannot
+    you make it speak. 'Sblood, do you think I am
+    easier to be played on than a pipe? Call me what
+    instrument you will, though you can fret me, yet you
+    cannot play upon me.
+
+    Enter POLONIUS
+    God bless you, sir!
+
+LORD POLONIUS
+
+    My lord, the queen would speak with you, and
+    presently.
+
+HAMLET
+
+    Do you see yonder cloud that's almost in shape of a camel?
+
+LORD POLONIUS
+
+    By the mass, and 'tis like a camel, indeed.
+
+HAMLET
+
+    Methinks it is like a weasel.
+
+LORD POLONIUS
+
+    It is backed like a weasel.
+
+HAMLET
+
+    Or like a whale?
+
+LORD POLONIUS
+
+    Very like a whale.
+
+HAMLET
+
+    Then I will come to my mother by and by. They fool
+    me to the top of my bent. I will come by and by.
+
+LORD POLONIUS
+
+    I will say so.
+
+HAMLET
+
+    By and by is easily said.
+
+    Exit POLONIUS
+    Leave me, friends.
+
+    Exeunt all but HAMLET
+    Tis now the very witching time of night,
+    When churchyards yawn and hell itself breathes out
+    Contagion to this world: now could I drink hot blood,
+    And do such bitter business as the day
+    Would quake to look on. Soft! now to my mother.
+    O heart, lose not thy nature; let not ever
+    The soul of Nero enter this firm bosom:
+    Let me be cruel, not unnatural:
+    I will speak daggers to her, but use none;
+    My tongue and soul in this be hypocrites;
+    How in my words soever she be shent,
+    To give them seals never, my soul, consent!
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene3.txt
new file mode 100644
index 0000000..dbac705
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene3.txt
@@ -0,0 +1,145 @@
+SCENE III. A room in the castle.
+
+    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    I like him not, nor stands it safe with us
+    To let his madness range. Therefore prepare you;
+    I your commission will forthwith dispatch,
+    And he to England shall along with you:
+    The terms of our estate may not endure
+    Hazard so dangerous as doth hourly grow
+    Out of his lunacies.
+
+GUILDENSTERN
+
+    We will ourselves provide:
+    Most holy and religious fear it is
+    To keep those many many bodies safe
+    That live and feed upon your majesty.
+
+ROSENCRANTZ
+
+    The single and peculiar life is bound,
+    With all the strength and armour of the mind,
+    To keep itself from noyance; but much more
+    That spirit upon whose weal depend and rest
+    The lives of many. The cease of majesty
+    Dies not alone; but, like a gulf, doth draw
+    What's near it with it: it is a massy wheel,
+    Fix'd on the summit of the highest mount,
+    To whose huge spokes ten thousand lesser things
+    Are mortised and adjoin'd; which, when it falls,
+    Each small annexment, petty consequence,
+    Attends the boisterous ruin. Never alone
+    Did the king sigh, but with a general groan.
+
+KING CLAUDIUS
+
+    Arm you, I pray you, to this speedy voyage;
+    For we will fetters put upon this fear,
+    Which now goes too free-footed.
+
+ROSENCRANTZ GUILDENSTERN
+
+    We will haste us.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+
+    Enter POLONIUS
+
+LORD POLONIUS
+
+    My lord, he's going to his mother's closet:
+    Behind the arras I'll convey myself,
+    To hear the process; and warrant she'll tax him home:
+    And, as you said, and wisely was it said,
+    'Tis meet that some more audience than a mother,
+    Since nature makes them partial, should o'erhear
+    The speech, of vantage. Fare you well, my liege:
+    I'll call upon you ere you go to bed,
+    And tell you what I know.
+
+KING CLAUDIUS
+
+    Thanks, dear my lord.
+
+    Exit POLONIUS
+    O, my offence is rank it smells to heaven;
+    It hath the primal eldest curse upon't,
+    A brother's murder. Pray can I not,
+    Though inclination be as sharp as will:
+    My stronger guilt defeats my strong intent;
+    And, like a man to double business bound,
+    I stand in pause where I shall first begin,
+    And both neglect. What if this cursed hand
+    Were thicker than itself with brother's blood,
+    Is there not rain enough in the sweet heavens
+    To wash it white as snow? Whereto serves mercy
+    But to confront the visage of offence?
+    And what's in prayer but this two-fold force,
+    To be forestalled ere we come to fall,
+    Or pardon'd being down? Then I'll look up;
+    My fault is past. But, O, what form of prayer
+    Can serve my turn? 'Forgive me my foul murder'?
+    That cannot be; since I am still possess'd
+    Of those effects for which I did the murder,
+    My crown, mine own ambition and my queen.
+    May one be pardon'd and retain the offence?
+    In the corrupted currents of this world
+    Offence's gilded hand may shove by justice,
+    And oft 'tis seen the wicked prize itself
+    Buys out the law: but 'tis not so above;
+    There is no shuffling, there the action lies
+    In his true nature; and we ourselves compell'd,
+    Even to the teeth and forehead of our faults,
+    To give in evidence. What then? what rests?
+    Try what repentance can: what can it not?
+    Yet what can it when one can not repent?
+    O wretched state! O bosom black as death!
+    O limed soul, that, struggling to be free,
+    Art more engaged! Help, angels! Make assay!
+    Bow, stubborn knees; and, heart with strings of steel,
+    Be soft as sinews of the newborn babe!
+    All may be well.
+
+    Retires and kneels
+
+    Enter HAMLET
+
+HAMLET
+
+    Now might I do it pat, now he is praying;
+    And now I'll do't. And so he goes to heaven;
+    And so am I revenged. That would be scann'd:
+    A villain kills my father; and for that,
+    I, his sole son, do this same villain send
+    To heaven.
+    O, this is hire and salary, not revenge.
+    He took my father grossly, full of bread;
+    With all his crimes broad blown, as flush as May;
+    And how his audit stands who knows save heaven?
+    But in our circumstance and course of thought,
+    'Tis heavy with him: and am I then revenged,
+    To take him in the purging of his soul,
+    When he is fit and season'd for his passage?
+    No!
+    Up, sword; and know thou a more horrid hent:
+    When he is drunk asleep, or in his rage,
+    Or in the incestuous pleasure of his bed;
+    At gaming, swearing, or about some act
+    That has no relish of salvation in't;
+    Then trip him, that his heels may kick at heaven,
+    And that his soul may be as damn'd and black
+    As hell, whereto it goes. My mother stays:
+    This physic but prolongs thy sickly days.
+
+    Exit
+
+KING CLAUDIUS
+
+    [Rising] My words fly up, my thoughts remain below:
+    Words without thoughts never to heaven go.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene4.txt
new file mode 100644
index 0000000..3d68af0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act3/scene4.txt
@@ -0,0 +1,424 @@
+SCENE IV. The Queen's closet.
+
+    Enter QUEEN GERTRUDE and POLONIUS 
+
+LORD POLONIUS
+
+    He will come straight. Look you lay home to him:
+    Tell him his pranks have been too broad to bear with,
+    And that your grace hath screen'd and stood between
+    Much heat and him. I'll sconce me even here.
+    Pray you, be round with him.
+
+HAMLET
+
+    [Within] Mother, mother, mother!
+
+QUEEN GERTRUDE
+
+    I'll warrant you,
+    Fear me not: withdraw, I hear him coming.
+
+    POLONIUS hides behind the arras
+
+    Enter HAMLET
+
+HAMLET
+
+    Now, mother, what's the matter?
+
+QUEEN GERTRUDE
+
+    Hamlet, thou hast thy father much offended.
+
+HAMLET
+
+    Mother, you have my father much offended.
+
+QUEEN GERTRUDE
+
+    Come, come, you answer with an idle tongue.
+
+HAMLET
+
+    Go, go, you question with a wicked tongue.
+
+QUEEN GERTRUDE
+
+    Why, how now, Hamlet!
+
+HAMLET
+
+    What's the matter now?
+
+QUEEN GERTRUDE
+
+    Have you forgot me?
+
+HAMLET
+
+    No, by the rood, not so:
+    You are the queen, your husband's brother's wife;
+    And--would it were not so!--you are my mother.
+
+QUEEN GERTRUDE
+
+    Nay, then, I'll set those to you that can speak.
+
+HAMLET
+
+    Come, come, and sit you down; you shall not budge;
+    You go not till I set you up a glass
+    Where you may see the inmost part of you.
+
+QUEEN GERTRUDE
+
+    What wilt thou do? thou wilt not murder me?
+    Help, help, ho!
+
+LORD POLONIUS
+
+    [Behind] What, ho! help, help, help!
+
+HAMLET
+
+    [Drawing] How now! a rat? Dead, for a ducat, dead!
+
+    Makes a pass through the arras
+
+LORD POLONIUS
+
+    [Behind] O, I am slain!
+
+    Falls and dies
+
+QUEEN GERTRUDE
+
+    O me, what hast thou done?
+
+HAMLET
+
+    Nay, I know not:
+    Is it the king?
+
+QUEEN GERTRUDE
+
+    O, what a rash and bloody deed is this!
+
+HAMLET
+
+    A bloody deed! almost as bad, good mother,
+    As kill a king, and marry with his brother.
+
+QUEEN GERTRUDE
+
+    As kill a king!
+
+HAMLET
+
+    Ay, lady, 'twas my word.
+
+    Lifts up the array and discovers POLONIUS
+    Thou wretched, rash, intruding fool, farewell!
+    I took thee for thy better: take thy fortune;
+    Thou find'st to be too busy is some danger.
+    Leave wringing of your hands: peace! sit you down,
+    And let me wring your heart; for so I shall,
+    If it be made of penetrable stuff,
+    If damned custom have not brass'd it so
+    That it is proof and bulwark against sense.
+
+QUEEN GERTRUDE
+
+    What have I done, that thou darest wag thy tongue
+    In noise so rude against me?
+
+HAMLET
+
+    Such an act
+    That blurs the grace and blush of modesty,
+    Calls virtue hypocrite, takes off the rose
+    From the fair forehead of an innocent love
+    And sets a blister there, makes marriage-vows
+    As false as dicers' oaths: O, such a deed
+    As from the body of contraction plucks
+    The very soul, and sweet religion makes
+    A rhapsody of words: heaven's face doth glow:
+    Yea, this solidity and compound mass,
+    With tristful visage, as against the doom,
+    Is thought-sick at the act.
+
+QUEEN GERTRUDE
+
+    Ay me, what act,
+    That roars so loud, and thunders in the index?
+
+HAMLET
+
+    Look here, upon this picture, and on this,
+    The counterfeit presentment of two brothers.
+    See, what a grace was seated on this brow;
+    Hyperion's curls; the front of Jove himself;
+    An eye like Mars, to threaten and command;
+    A station like the herald Mercury
+    New-lighted on a heaven-kissing hill;
+    A combination and a form indeed,
+    Where every god did seem to set his seal,
+    To give the world assurance of a man:
+    This was your husband. Look you now, what follows:
+    Here is your husband; like a mildew'd ear,
+    Blasting his wholesome brother. Have you eyes?
+    Could you on this fair mountain leave to feed,
+    And batten on this moor? Ha! have you eyes?
+    You cannot call it love; for at your age
+    The hey-day in the blood is tame, it's humble,
+    And waits upon the judgment: and what judgment
+    Would step from this to this? Sense, sure, you have,
+    Else could you not have motion; but sure, that sense
+    Is apoplex'd; for madness would not err,
+    Nor sense to ecstasy was ne'er so thrall'd
+    But it reserved some quantity of choice,
+    To serve in such a difference. What devil was't
+    That thus hath cozen'd you at hoodman-blind?
+    Eyes without feeling, feeling without sight,
+    Ears without hands or eyes, smelling sans all,
+    Or but a sickly part of one true sense
+    Could not so mope.
+    O shame! where is thy blush? Rebellious hell,
+    If thou canst mutine in a matron's bones,
+    To flaming youth let virtue be as wax,
+    And melt in her own fire: proclaim no shame
+    When the compulsive ardour gives the charge,
+    Since frost itself as actively doth burn
+    And reason panders will.
+
+QUEEN GERTRUDE
+
+    O Hamlet, speak no more:
+    Thou turn'st mine eyes into my very soul;
+    And there I see such black and grained spots
+    As will not leave their tinct.
+
+HAMLET
+
+    Nay, but to live
+    In the rank sweat of an enseamed bed,
+    Stew'd in corruption, honeying and making love
+    Over the nasty sty,--
+
+QUEEN GERTRUDE
+
+    O, speak to me no more;
+    These words, like daggers, enter in mine ears;
+    No more, sweet Hamlet!
+
+HAMLET
+
+    A murderer and a villain;
+    A slave that is not twentieth part the tithe
+    Of your precedent lord; a vice of kings;
+    A cutpurse of the empire and the rule,
+    That from a shelf the precious diadem stole,
+    And put it in his pocket!
+
+QUEEN GERTRUDE
+
+    No more!
+
+HAMLET
+
+    A king of shreds and patches,--
+
+    Enter Ghost
+    Save me, and hover o'er me with your wings,
+    You heavenly guards! What would your gracious figure?
+
+QUEEN GERTRUDE
+
+    Alas, he's mad!
+
+HAMLET
+
+    Do you not come your tardy son to chide,
+    That, lapsed in time and passion, lets go by
+    The important acting of your dread command? O, say!
+
+Ghost
+
+    Do not forget: this visitation
+    Is but to whet thy almost blunted purpose.
+    But, look, amazement on thy mother sits:
+    O, step between her and her fighting soul:
+    Conceit in weakest bodies strongest works:
+    Speak to her, Hamlet.
+
+HAMLET
+
+    How is it with you, lady?
+
+QUEEN GERTRUDE
+
+    Alas, how is't with you,
+    That you do bend your eye on vacancy
+    And with the incorporal air do hold discourse?
+    Forth at your eyes your spirits wildly peep;
+    And, as the sleeping soldiers in the alarm,
+    Your bedded hair, like life in excrements,
+    Starts up, and stands on end. O gentle son,
+    Upon the heat and flame of thy distemper
+    Sprinkle cool patience. Whereon do you look?
+
+HAMLET
+
+    On him, on him! Look you, how pale he glares!
+    His form and cause conjoin'd, preaching to stones,
+    Would make them capable. Do not look upon me;
+    Lest with this piteous action you convert
+    My stern effects: then what I have to do
+    Will want true colour; tears perchance for blood.
+
+QUEEN GERTRUDE
+
+    To whom do you speak this?
+
+HAMLET
+
+    Do you see nothing there?
+
+QUEEN GERTRUDE
+
+    Nothing at all; yet all that is I see.
+
+HAMLET
+
+    Nor did you nothing hear?
+
+QUEEN GERTRUDE
+
+    No, nothing but ourselves.
+
+HAMLET
+
+    Why, look you there! look, how it steals away!
+    My father, in his habit as he lived!
+    Look, where he goes, even now, out at the portal!
+
+    Exit Ghost
+
+QUEEN GERTRUDE
+
+    This the very coinage of your brain:
+    This bodiless creation ecstasy
+    Is very cunning in.
+
+HAMLET
+
+    Ecstasy!
+    My pulse, as yours, doth temperately keep time,
+    And makes as healthful music: it is not madness
+    That I have utter'd: bring me to the test,
+    And I the matter will re-word; which madness
+    Would gambol from. Mother, for love of grace,
+    Lay not that mattering unction to your soul,
+    That not your trespass, but my madness speaks:
+    It will but skin and film the ulcerous place,
+    Whilst rank corruption, mining all within,
+    Infects unseen. Confess yourself to heaven;
+    Repent what's past; avoid what is to come;
+    And do not spread the compost on the weeds,
+    To make them ranker. Forgive me this my virtue;
+    For in the fatness of these pursy times
+    Virtue itself of vice must pardon beg,
+    Yea, curb and woo for leave to do him good.
+
+QUEEN GERTRUDE
+
+    O Hamlet, thou hast cleft my heart in twain.
+
+HAMLET
+
+    O, throw away the worser part of it,
+    And live the purer with the other half.
+    Good night: but go not to mine uncle's bed;
+    Assume a virtue, if you have it not.
+    That monster, custom, who all sense doth eat,
+    Of habits devil, is angel yet in this,
+    That to the use of actions fair and good
+    He likewise gives a frock or livery,
+    That aptly is put on. Refrain to-night,
+    And that shall lend a kind of easiness
+    To the next abstinence: the next more easy;
+    For use almost can change the stamp of nature,
+    And either [ ] the devil, or throw him out
+    With wondrous potency. Once more, good night:
+    And when you are desirous to be bless'd,
+    I'll blessing beg of you. For this same lord,
+
+    Pointing to POLONIUS
+    I do repent: but heaven hath pleased it so,
+    To punish me with this and this with me,
+    That I must be their scourge and minister.
+    I will bestow him, and will answer well
+    The death I gave him. So, again, good night.
+    I must be cruel, only to be kind:
+    Thus bad begins and worse remains behind.
+    One word more, good lady.
+
+QUEEN GERTRUDE
+
+    What shall I do?
+
+HAMLET
+
+    Not this, by no means, that I bid you do:
+    Let the bloat king tempt you again to bed;
+    Pinch wanton on your cheek; call you his mouse;
+    And let him, for a pair of reechy kisses,
+    Or paddling in your neck with his damn'd fingers,
+    Make you to ravel all this matter out,
+    That I essentially am not in madness,
+    But mad in craft. 'Twere good you let him know;
+    For who, that's but a queen, fair, sober, wise,
+    Would from a paddock, from a bat, a gib,
+    Such dear concernings hide? who would do so?
+    No, in despite of sense and secrecy,
+    Unpeg the basket on the house's top.
+    Let the birds fly, and, like the famous ape,
+    To try conclusions, in the basket creep,
+    And break your own neck down.
+
+QUEEN GERTRUDE
+
+    Be thou assured, if words be made of breath,
+    And breath of life, I have no life to breathe
+    What thou hast said to me.
+
+HAMLET
+
+    I must to England; you know that?
+
+QUEEN GERTRUDE
+
+    Alack,
+    I had forgot: 'tis so concluded on.
+
+HAMLET
+
+    There's letters seal'd: and my two schoolfellows,
+    Whom I will trust as I will adders fang'd,
+    They bear the mandate; they must sweep my way,
+    And marshal me to knavery. Let it work;
+    For 'tis the sport to have the engineer
+    Hoist with his own petard: and 't shall go hard
+    But I will delve one yard below their mines,
+    And blow them at the moon: O, 'tis most sweet,
+    When in one line two crafts directly meet.
+    This man shall set me packing:
+    I'll lug the guts into the neighbour room.
+    Mother, good night. Indeed this counsellor
+    Is now most still, most secret and most grave,
+    Who was in life a foolish prating knave.
+    Come, sir, to draw toward an end with you.
+    Good night, mother.
+
+    Exeunt severally; HAMLET dragging in POLONIUS
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene1.txt
new file mode 100644
index 0000000..a254aed
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene1.txt
@@ -0,0 +1,75 @@
+ACT IV
+SCENE I. A room in the castle.
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, ROSENCRANTZ, and GUILDENSTERN 
+
+KING CLAUDIUS
+
+    There's matter in these sighs, these profound heaves:
+    You must translate: 'tis fit we understand them.
+    Where is your son?
+
+QUEEN GERTRUDE
+
+    Bestow this place on us a little while.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Ah, my good lord, what have I seen to-night!
+
+KING CLAUDIUS
+
+    What, Gertrude? How does Hamlet?
+
+QUEEN GERTRUDE
+
+    Mad as the sea and wind, when both contend
+    Which is the mightier: in his lawless fit,
+    Behind the arras hearing something stir,
+    Whips out his rapier, cries, 'A rat, a rat!'
+    And, in this brainish apprehension, kills
+    The unseen good old man.
+
+KING CLAUDIUS
+
+    O heavy deed!
+    It had been so with us, had we been there:
+    His liberty is full of threats to all;
+    To you yourself, to us, to every one.
+    Alas, how shall this bloody deed be answer'd?
+    It will be laid to us, whose providence
+    Should have kept short, restrain'd and out of haunt,
+    This mad young man: but so much was our love,
+    We would not understand what was most fit;
+    But, like the owner of a foul disease,
+    To keep it from divulging, let it feed
+    Even on the pith of Life. Where is he gone?
+
+QUEEN GERTRUDE
+
+    To draw apart the body he hath kill'd:
+    O'er whom his very madness, like some ore
+    Among a mineral of metals base,
+    Shows itself pure; he weeps for what is done.
+
+KING CLAUDIUS
+
+    O Gertrude, come away!
+    The sun no sooner shall the mountains touch,
+    But we will ship him hence: and this vile deed
+    We must, with all our majesty and skill,
+    Both countenance and excuse. Ho, Guildenstern!
+
+    Re-enter ROSENCRANTZ and GUILDENSTERN
+    Friends both, go join you with some further aid:
+    Hamlet in madness hath Polonius slain,
+    And from his mother's closet hath he dragg'd him:
+    Go seek him out; speak fair, and bring the body
+    Into the chapel. I pray you, haste in this.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    Come, Gertrude, we'll call up our wisest friends;
+    And let them know, both what we mean to do,
+    And what's untimely done. O, come away!
+    My soul is full of discord and dismay.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene2.txt
new file mode 100644
index 0000000..6903d9e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene2.txt
@@ -0,0 +1,88 @@
+SCENE II. Another room in the castle.
+
+    Enter HAMLET 
+
+HAMLET
+
+    Safely stowed.
+
+ROSENCRANTZ: GUILDENSTERN:
+
+    [Within] Hamlet! Lord Hamlet!
+
+HAMLET
+
+    What noise? who calls on Hamlet?
+    O, here they come.
+
+    Enter ROSENCRANTZ and GUILDENSTERN
+
+ROSENCRANTZ
+
+    What have you done, my lord, with the dead body?
+
+HAMLET
+
+    Compounded it with dust, whereto 'tis kin.
+
+ROSENCRANTZ
+
+    Tell us where 'tis, that we may take it thence
+    And bear it to the chapel.
+
+HAMLET
+
+    Do not believe it.
+
+ROSENCRANTZ
+
+    Believe what?
+
+HAMLET
+
+    That I can keep your counsel and not mine own.
+    Besides, to be demanded of a sponge! what
+    replication should be made by the son of a king?
+
+ROSENCRANTZ
+
+    Take you me for a sponge, my lord?
+
+HAMLET
+
+    Ay, sir, that soaks up the king's countenance, his
+    rewards, his authorities. But such officers do the
+    king best service in the end: he keeps them, like
+    an ape, in the corner of his jaw; first mouthed, to
+    be last swallowed: when he needs what you have
+    gleaned, it is but squeezing you, and, sponge, you
+    shall be dry again.
+
+ROSENCRANTZ
+
+    I understand you not, my lord.
+
+HAMLET
+
+    I am glad of it: a knavish speech sleeps in a
+    foolish ear.
+
+ROSENCRANTZ
+
+    My lord, you must tell us where the body is, and go
+    with us to the king.
+
+HAMLET
+
+    The body is with the king, but the king is not with
+    the body. The king is a thing--
+
+GUILDENSTERN
+
+    A thing, my lord!
+
+HAMLET
+
+    Of nothing: bring me to him. Hide fox, and all after.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene3.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene3.txt
new file mode 100644
index 0000000..b364f04
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene3.txt
@@ -0,0 +1,171 @@
+SCENE III. Another room in the castle.
+
+    Enter KING CLAUDIUS, attended 
+
+KING CLAUDIUS
+
+    I have sent to seek him, and to find the body.
+    How dangerous is it that this man goes loose!
+    Yet must not we put the strong law on him:
+    He's loved of the distracted multitude,
+    Who like not in their judgment, but their eyes;
+    And where tis so, the offender's scourge is weigh'd,
+    But never the offence. To bear all smooth and even,
+    This sudden sending him away must seem
+    Deliberate pause: diseases desperate grown
+    By desperate appliance are relieved,
+    Or not at all.
+
+    Enter ROSENCRANTZ
+    How now! what hath befall'n?
+
+ROSENCRANTZ
+
+    Where the dead body is bestow'd, my lord,
+    We cannot get from him.
+
+KING CLAUDIUS
+
+    But where is he?
+
+ROSENCRANTZ
+
+    Without, my lord; guarded, to know your pleasure.
+
+KING CLAUDIUS
+
+    Bring him before us.
+
+ROSENCRANTZ
+
+    Ho, Guildenstern! bring in my lord.
+
+    Enter HAMLET and GUILDENSTERN
+
+KING CLAUDIUS
+
+    Now, Hamlet, where's Polonius?
+
+HAMLET
+
+    At supper.
+
+KING CLAUDIUS
+
+    At supper! where?
+
+HAMLET
+
+    Not where he eats, but where he is eaten: a certain
+    convocation of politic worms are e'en at him. Your
+    worm is your only emperor for diet: we fat all
+    creatures else to fat us, and we fat ourselves for
+    maggots: your fat king and your lean beggar is but
+    variable service, two dishes, but to one table:
+    that's the end.
+
+KING CLAUDIUS
+
+    Alas, alas!
+
+HAMLET
+
+    A man may fish with the worm that hath eat of a
+    king, and eat of the fish that hath fed of that worm.
+
+KING CLAUDIUS
+
+    What dost you mean by this?
+
+HAMLET
+
+    Nothing but to show you how a king may go a
+    progress through the guts of a beggar.
+
+KING CLAUDIUS
+
+    Where is Polonius?
+
+HAMLET
+
+    In heaven; send hither to see: if your messenger
+    find him not there, seek him i' the other place
+    yourself. But indeed, if you find him not within
+    this month, you shall nose him as you go up the
+    stairs into the lobby.
+
+KING CLAUDIUS
+
+    Go seek him there.
+
+    To some Attendants
+
+HAMLET
+
+    He will stay till ye come.
+
+    Exeunt Attendants
+
+KING CLAUDIUS
+
+    Hamlet, this deed, for thine especial safety,--
+    Which we do tender, as we dearly grieve
+    For that which thou hast done,--must send thee hence
+    With fiery quickness: therefore prepare thyself;
+    The bark is ready, and the wind at help,
+    The associates tend, and every thing is bent
+    For England.
+
+HAMLET
+
+    For England!
+
+KING CLAUDIUS
+
+    Ay, Hamlet.
+
+HAMLET
+
+    Good.
+
+KING CLAUDIUS
+
+    So is it, if thou knew'st our purposes.
+
+HAMLET
+
+    I see a cherub that sees them. But, come; for
+    England! Farewell, dear mother.
+
+KING CLAUDIUS
+
+    Thy loving father, Hamlet.
+
+HAMLET
+
+    My mother: father and mother is man and wife; man
+    and wife is one flesh; and so, my mother. Come, for England!
+
+    Exit
+
+KING CLAUDIUS
+
+    Follow him at foot; tempt him with speed aboard;
+    Delay it not; I'll have him hence to-night:
+    Away! for every thing is seal'd and done
+    That else leans on the affair: pray you, make haste.
+
+    Exeunt ROSENCRANTZ and GUILDENSTERN
+    And, England, if my love thou hold'st at aught--
+    As my great power thereof may give thee sense,
+    Since yet thy cicatrice looks raw and red
+    After the Danish sword, and thy free awe
+    Pays homage to us--thou mayst not coldly set
+    Our sovereign process; which imports at full,
+    By letters congruing to that effect,
+    The present death of Hamlet. Do it, England;
+    For like the hectic in my blood he rages,
+    And thou must cure me: till I know 'tis done,
+    Howe'er my haps, my joys were ne'er begun.
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene4.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene4.txt
new file mode 100644
index 0000000..308192a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene4.txt
@@ -0,0 +1,132 @@
+SCENE IV. A plain in Denmark.
+
+    Enter FORTINBRAS, a Captain, and Soldiers, marching 
+
+PRINCE FORTINBRAS
+
+    Go, captain, from me greet the Danish king;
+    Tell him that, by his licence, Fortinbras
+    Craves the conveyance of a promised march
+    Over his kingdom. You know the rendezvous.
+    If that his majesty would aught with us,
+    We shall express our duty in his eye;
+    And let him know so.
+
+Captain
+
+    I will do't, my lord.
+
+PRINCE FORTINBRAS
+
+    Go softly on.
+
+    Exeunt FORTINBRAS and Soldiers
+
+    Enter HAMLET, ROSENCRANTZ, GUILDENSTERN, and others
+
+HAMLET
+
+    Good sir, whose powers are these?
+
+Captain
+
+    They are of Norway, sir.
+
+HAMLET
+
+    How purposed, sir, I pray you?
+
+Captain
+
+    Against some part of Poland.
+
+HAMLET
+
+    Who commands them, sir?
+
+Captain
+
+    The nephews to old Norway, Fortinbras.
+
+HAMLET
+
+    Goes it against the main of Poland, sir,
+    Or for some frontier?
+
+Captain
+
+    Truly to speak, and with no addition,
+    We go to gain a little patch of ground
+    That hath in it no profit but the name.
+    To pay five ducats, five, I would not farm it;
+    Nor will it yield to Norway or the Pole
+    A ranker rate, should it be sold in fee.
+
+HAMLET
+
+    Why, then the Polack never will defend it.
+
+Captain
+
+    Yes, it is already garrison'd.
+
+HAMLET
+
+    Two thousand souls and twenty thousand ducats
+    Will not debate the question of this straw:
+    This is the imposthume of much wealth and peace,
+    That inward breaks, and shows no cause without
+    Why the man dies. I humbly thank you, sir.
+
+Captain
+
+    God be wi' you, sir.
+
+    Exit
+
+ROSENCRANTZ
+
+    Wilt please you go, my lord?
+
+HAMLET
+
+    I'll be with you straight go a little before.
+
+    Exeunt all except HAMLET
+    How all occasions do inform against me,
+    And spur my dull revenge! What is a man,
+    If his chief good and market of his time
+    Be but to sleep and feed? a beast, no more.
+    Sure, he that made us with such large discourse,
+    Looking before and after, gave us not
+    That capability and god-like reason
+    To fust in us unused. Now, whether it be
+    Bestial oblivion, or some craven scruple
+    Of thinking too precisely on the event,
+    A thought which, quarter'd, hath but one part wisdom
+    And ever three parts coward, I do not know
+    Why yet I live to say 'This thing's to do;'
+    Sith I have cause and will and strength and means
+    To do't. Examples gross as earth exhort me:
+    Witness this army of such mass and charge
+    Led by a delicate and tender prince,
+    Whose spirit with divine ambition puff'd
+    Makes mouths at the invisible event,
+    Exposing what is mortal and unsure
+    To all that fortune, death and danger dare,
+    Even for an egg-shell. Rightly to be great
+    Is not to stir without great argument,
+    But greatly to find quarrel in a straw
+    When honour's at the stake. How stand I then,
+    That have a father kill'd, a mother stain'd,
+    Excitements of my reason and my blood,
+    And let all sleep? while, to my shame, I see
+    The imminent death of twenty thousand men,
+    That, for a fantasy and trick of fame,
+    Go to their graves like beds, fight for a plot
+    Whereon the numbers cannot try the cause,
+    Which is not tomb enough and continent
+    To hide the slain? O, from this time forth,
+    My thoughts be bloody, or be nothing worth!
+
+    Exit
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene5.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene5.txt
new file mode 100644
index 0000000..716fae6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene5.txt
@@ -0,0 +1,466 @@
+SCENE V. Elsinore. A room in the castle.
+
+    Enter QUEEN GERTRUDE, HORATIO, and a Gentleman 
+
+QUEEN GERTRUDE
+
+    I will not speak with her.
+
+Gentleman
+
+    She is importunate, indeed distract:
+    Her mood will needs be pitied.
+
+QUEEN GERTRUDE
+
+    What would she have?
+
+Gentleman
+
+    She speaks much of her father; says she hears
+    There's tricks i' the world; and hems, and beats her heart;
+    Spurns enviously at straws; speaks things in doubt,
+    That carry but half sense: her speech is nothing,
+    Yet the unshaped use of it doth move
+    The hearers to collection; they aim at it,
+    And botch the words up fit to their own thoughts;
+    Which, as her winks, and nods, and gestures
+    yield them,
+    Indeed would make one think there might be thought,
+    Though nothing sure, yet much unhappily.
+
+HORATIO
+
+    'Twere good she were spoken with; for she may strew
+    Dangerous conjectures in ill-breeding minds.
+
+QUEEN GERTRUDE
+
+    Let her come in.
+
+    Exit HORATIO
+    To my sick soul, as sin's true nature is,
+    Each toy seems prologue to some great amiss:
+    So full of artless jealousy is guilt,
+    It spills itself in fearing to be spilt.
+
+    Re-enter HORATIO, with OPHELIA
+
+OPHELIA
+
+    Where is the beauteous majesty of Denmark?
+
+QUEEN GERTRUDE
+
+    How now, Ophelia!
+
+OPHELIA
+
+    [Sings]
+    How should I your true love know
+    From another one?
+    By his cockle hat and staff,
+    And his sandal shoon.
+
+QUEEN GERTRUDE
+
+    Alas, sweet lady, what imports this song?
+
+OPHELIA
+
+    Say you? nay, pray you, mark.
+
+    Sings
+    He is dead and gone, lady,
+    He is dead and gone;
+    At his head a grass-green turf,
+    At his heels a stone.
+
+QUEEN GERTRUDE
+
+    Nay, but, Ophelia,--
+
+OPHELIA
+
+    Pray you, mark.
+
+    Sings
+    White his shroud as the mountain snow,--
+
+    Enter KING CLAUDIUS
+
+QUEEN GERTRUDE
+
+    Alas, look here, my lord.
+
+OPHELIA
+
+    [Sings]
+    Larded with sweet flowers
+    Which bewept to the grave did go
+    With true-love showers.
+
+KING CLAUDIUS
+
+    How do you, pretty lady?
+
+OPHELIA
+
+    Well, God 'ild you! They say the owl was a baker's
+    daughter. Lord, we know what we are, but know not
+    what we may be. God be at your table!
+
+KING CLAUDIUS
+
+    Conceit upon her father.
+
+OPHELIA
+
+    Pray you, let's have no words of this; but when they
+    ask you what it means, say you this:
+
+    Sings
+    To-morrow is Saint Valentine's day,
+    All in the morning betime,
+    And I a maid at your window,
+    To be your Valentine.
+    Then up he rose, and donn'd his clothes,
+    And dupp'd the chamber-door;
+    Let in the maid, that out a maid
+    Never departed more.
+
+KING CLAUDIUS
+
+    Pretty Ophelia!
+
+OPHELIA
+
+    Indeed, la, without an oath, I'll make an end on't:
+
+    Sings
+    By Gis and by Saint Charity,
+    Alack, and fie for shame!
+    Young men will do't, if they come to't;
+    By cock, they are to blame.
+    Quoth she, before you tumbled me,
+    You promised me to wed.
+    So would I ha' done, by yonder sun,
+    An thou hadst not come to my bed.
+
+KING CLAUDIUS
+
+    How long hath she been thus?
+
+OPHELIA
+
+    I hope all will be well. We must be patient: but I
+    cannot choose but weep, to think they should lay him
+    i' the cold ground. My brother shall know of it:
+    and so I thank you for your good counsel. Come, my
+    coach! Good night, ladies; good night, sweet ladies;
+    good night, good night.
+
+    Exit
+
+KING CLAUDIUS
+
+    Follow her close; give her good watch,
+    I pray you.
+
+    Exit HORATIO
+    O, this is the poison of deep grief; it springs
+    All from her father's death. O Gertrude, Gertrude,
+    When sorrows come, they come not single spies
+    But in battalions. First, her father slain:
+    Next, your son gone; and he most violent author
+    Of his own just remove: the people muddied,
+    Thick and unwholesome in their thoughts and whispers,
+    For good Polonius' death; and we have done but greenly,
+    In hugger-mugger to inter him: poor Ophelia
+    Divided from herself and her fair judgment,
+    Without the which we are pictures, or mere beasts:
+    Last, and as much containing as all these,
+    Her brother is in secret come from France;
+    Feeds on his wonder, keeps himself in clouds,
+    And wants not buzzers to infect his ear
+    With pestilent speeches of his father's death;
+    Wherein necessity, of matter beggar'd,
+    Will nothing stick our person to arraign
+    In ear and ear. O my dear Gertrude, this,
+    Like to a murdering-piece, in many places
+    Gives me superfluous death.
+
+    A noise within
+
+QUEEN GERTRUDE
+
+    Alack, what noise is this?
+
+KING CLAUDIUS
+
+    Where are my Switzers? Let them guard the door.
+
+    Enter another Gentleman
+    What is the matter?
+
+Gentleman
+
+    Save yourself, my lord:
+    The ocean, overpeering of his list,
+    Eats not the flats with more impetuous haste
+    Than young Laertes, in a riotous head,
+    O'erbears your officers. The rabble call him lord;
+    And, as the world were now but to begin,
+    Antiquity forgot, custom not known,
+    The ratifiers and props of every word,
+    They cry 'Choose we: Laertes shall be king:'
+    Caps, hands, and tongues, applaud it to the clouds:
+    'Laertes shall be king, Laertes king!'
+
+QUEEN GERTRUDE
+
+    How cheerfully on the false trail they cry!
+    O, this is counter, you false Danish dogs!
+
+KING CLAUDIUS
+
+    The doors are broke.
+
+    Noise within
+
+    Enter LAERTES, armed; Danes following
+
+LAERTES
+
+    Where is this king? Sirs, stand you all without.
+
+Danes
+
+    No, let's come in.
+
+LAERTES
+
+    I pray you, give me leave.
+
+Danes
+
+    We will, we will.
+
+    They retire without the door
+
+LAERTES
+
+    I thank you: keep the door. O thou vile king,
+    Give me my father!
+
+QUEEN GERTRUDE
+
+    Calmly, good Laertes.
+
+LAERTES
+
+    That drop of blood that's calm proclaims me bastard,
+    Cries cuckold to my father, brands the harlot
+    Even here, between the chaste unsmirched brow
+    Of my true mother.
+
+KING CLAUDIUS
+
+    What is the cause, Laertes,
+    That thy rebellion looks so giant-like?
+    Let him go, Gertrude; do not fear our person:
+    There's such divinity doth hedge a king,
+    That treason can but peep to what it would,
+    Acts little of his will. Tell me, Laertes,
+    Why thou art thus incensed. Let him go, Gertrude.
+    Speak, man.
+
+LAERTES
+
+    Where is my father?
+
+KING CLAUDIUS
+
+    Dead.
+
+QUEEN GERTRUDE
+
+    But not by him.
+
+KING CLAUDIUS
+
+    Let him demand his fill.
+
+LAERTES
+
+    How came he dead? I'll not be juggled with:
+    To hell, allegiance! vows, to the blackest devil!
+    Conscience and grace, to the profoundest pit!
+    I dare damnation. To this point I stand,
+    That both the worlds I give to negligence,
+    Let come what comes; only I'll be revenged
+    Most thoroughly for my father.
+
+KING CLAUDIUS
+
+    Who shall stay you?
+
+LAERTES
+
+    My will, not all the world:
+    And for my means, I'll husband them so well,
+    They shall go far with little.
+
+KING CLAUDIUS
+
+    Good Laertes,
+    If you desire to know the certainty
+    Of your dear father's death, is't writ in your revenge,
+    That, swoopstake, you will draw both friend and foe,
+    Winner and loser?
+
+LAERTES
+
+    None but his enemies.
+
+KING CLAUDIUS
+
+    Will you know them then?
+
+LAERTES
+
+    To his good friends thus wide I'll ope my arms;
+    And like the kind life-rendering pelican,
+    Repast them with my blood.
+
+KING CLAUDIUS
+
+    Why, now you speak
+    Like a good child and a true gentleman.
+    That I am guiltless of your father's death,
+    And am most sensible in grief for it,
+    It shall as level to your judgment pierce
+    As day does to your eye.
+
+Danes
+
+    [Within] Let her come in.
+
+LAERTES
+
+    How now! what noise is that?
+
+    Re-enter OPHELIA
+    O heat, dry up my brains! tears seven times salt,
+    Burn out the sense and virtue of mine eye!
+    By heaven, thy madness shall be paid by weight,
+    Till our scale turn the beam. O rose of May!
+    Dear maid, kind sister, sweet Ophelia!
+    O heavens! is't possible, a young maid's wits
+    Should be as moral as an old man's life?
+    Nature is fine in love, and where 'tis fine,
+    It sends some precious instance of itself
+    After the thing it loves.
+
+OPHELIA
+
+    [Sings]
+    They bore him barefaced on the bier;
+    Hey non nonny, nonny, hey nonny;
+    And in his grave rain'd many a tear:--
+    Fare you well, my dove!
+
+LAERTES
+
+    Hadst thou thy wits, and didst persuade revenge,
+    It could not move thus.
+
+OPHELIA
+
+    [Sings]
+    You must sing a-down a-down,
+    An you call him a-down-a.
+    O, how the wheel becomes it! It is the false
+    steward, that stole his master's daughter.
+
+LAERTES
+
+    This nothing's more than matter.
+
+OPHELIA
+
+    There's rosemary, that's for remembrance; pray,
+    love, remember: and there is pansies. that's for thoughts.
+
+LAERTES
+
+    A document in madness, thoughts and remembrance fitted.
+
+OPHELIA
+
+    There's fennel for you, and columbines: there's rue
+    for you; and here's some for me: we may call it
+    herb-grace o' Sundays: O you must wear your rue with
+    a difference. There's a daisy: I would give you
+    some violets, but they withered all when my father
+    died: they say he made a good end,--
+
+    Sings
+    For bonny sweet Robin is all my joy.
+
+LAERTES
+
+    Thought and affliction, passion, hell itself,
+    She turns to favour and to prettiness.
+
+OPHELIA
+
+    [Sings]
+    And will he not come again?
+    And will he not come again?
+    No, no, he is dead:
+    Go to thy death-bed:
+    He never will come again.
+    His beard was as white as snow,
+    All flaxen was his poll:
+    He is gone, he is gone,
+    And we cast away moan:
+    God ha' mercy on his soul!
+    And of all Christian souls, I pray God. God be wi' ye.
+
+    Exit
+
+LAERTES
+
+    Do you see this, O God?
+
+KING CLAUDIUS
+
+    Laertes, I must commune with your grief,
+    Or you deny me right. Go but apart,
+    Make choice of whom your wisest friends you will.
+    And they shall hear and judge 'twixt you and me:
+    If by direct or by collateral hand
+    They find us touch'd, we will our kingdom give,
+    Our crown, our life, and all that we can ours,
+    To you in satisfaction; but if not,
+    Be you content to lend your patience to us,
+    And we shall jointly labour with your soul
+    To give it due content.
+
+LAERTES
+
+    Let this be so;
+    His means of death, his obscure funeral--
+    No trophy, sword, nor hatchment o'er his bones,
+    No noble rite nor formal ostentation--
+    Cry to be heard, as 'twere from heaven to earth,
+    That I must call't in question.
+
+KING CLAUDIUS
+
+    So you shall;
+    And where the offence is let the great axe fall.
+    I pray you, go with me.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene6.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene6.txt
new file mode 100644
index 0000000..f0fa4b7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene6.txt
@@ -0,0 +1,63 @@
+SCENE VI. Another room in the castle.
+
+    Enter HORATIO and a Servant 
+
+HORATIO
+
+    What are they that would speak with me?
+
+Servant
+
+    Sailors, sir: they say they have letters for you.
+
+HORATIO
+
+    Let them come in.
+
+    Exit Servant
+    I do not know from what part of the world
+    I should be greeted, if not from Lord Hamlet.
+
+    Enter Sailors
+
+First Sailor
+
+    God bless you, sir.
+
+HORATIO
+
+    Let him bless thee too.
+
+First Sailor
+
+    He shall, sir, an't please him. There's a letter for
+    you, sir; it comes from the ambassador that was
+    bound for England; if your name be Horatio, as I am
+    let to know it is.
+
+HORATIO
+
+    [Reads] 'Horatio, when thou shalt have overlooked
+    this, give these fellows some means to the king:
+    they have letters for him. Ere we were two days old
+    at sea, a pirate of very warlike appointment gave us
+    chase. Finding ourselves too slow of sail, we put on
+    a compelled valour, and in the grapple I boarded
+    them: on the instant they got clear of our ship; so
+    I alone became their prisoner. They have dealt with
+    me like thieves of mercy: but they knew what they
+    did; I am to do a good turn for them. Let the king
+    have the letters I have sent; and repair thou to me
+    with as much speed as thou wouldst fly death. I
+    have words to speak in thine ear will make thee
+    dumb; yet are they much too light for the bore of
+    the matter. These good fellows will bring thee
+    where I am. Rosencrantz and Guildenstern hold their
+    course for England: of them I have much to tell
+    thee. Farewell.
+    'He that thou knowest thine, HAMLET.'
+    Come, I will make you way for these your letters;
+    And do't the speedier, that you may direct me
+    To him from whom you brought them.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene7.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene7.txt
new file mode 100644
index 0000000..d24c07c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act4/scene7.txt
@@ -0,0 +1,346 @@
+SCENE VII. Another room in the castle.
+
+    Enter KING CLAUDIUS and LAERTES 
+
+KING CLAUDIUS
+
+    Now must your conscience my acquaintance seal,
+    And you must put me in your heart for friend,
+    Sith you have heard, and with a knowing ear,
+    That he which hath your noble father slain
+    Pursued my life.
+
+LAERTES
+
+    It well appears: but tell me
+    Why you proceeded not against these feats,
+    So crimeful and so capital in nature,
+    As by your safety, wisdom, all things else,
+    You mainly were stirr'd up.
+
+KING CLAUDIUS
+
+    O, for two special reasons;
+    Which may to you, perhaps, seem much unsinew'd,
+    But yet to me they are strong. The queen his mother
+    Lives almost by his looks; and for myself--
+    My virtue or my plague, be it either which--
+    She's so conjunctive to my life and soul,
+    That, as the star moves not but in his sphere,
+    I could not but by her. The other motive,
+    Why to a public count I might not go,
+    Is the great love the general gender bear him;
+    Who, dipping all his faults in their affection,
+    Would, like the spring that turneth wood to stone,
+    Convert his gyves to graces; so that my arrows,
+    Too slightly timber'd for so loud a wind,
+    Would have reverted to my bow again,
+    And not where I had aim'd them.
+
+LAERTES
+
+    And so have I a noble father lost;
+    A sister driven into desperate terms,
+    Whose worth, if praises may go back again,
+    Stood challenger on mount of all the age
+    For her perfections: but my revenge will come.
+
+KING CLAUDIUS
+
+    Break not your sleeps for that: you must not think
+    That we are made of stuff so flat and dull
+    That we can let our beard be shook with danger
+    And think it pastime. You shortly shall hear more:
+    I loved your father, and we love ourself;
+    And that, I hope, will teach you to imagine--
+
+    Enter a Messenger
+    How now! what news?
+
+Messenger
+
+    Letters, my lord, from Hamlet:
+    This to your majesty; this to the queen.
+
+KING CLAUDIUS
+
+    From Hamlet! who brought them?
+
+Messenger
+
+    Sailors, my lord, they say; I saw them not:
+    They were given me by Claudio; he received them
+    Of him that brought them.
+
+KING CLAUDIUS
+
+    Laertes, you shall hear them. Leave us.
+
+    Exit Messenger
+
+    Reads
+    'High and mighty, You shall know I am set naked on
+    your kingdom. To-morrow shall I beg leave to see
+    your kingly eyes: when I shall, first asking your
+    pardon thereunto, recount the occasion of my sudden
+    and more strange return. 'HAMLET.'
+    What should this mean? Are all the rest come back?
+    Or is it some abuse, and no such thing?
+
+LAERTES
+
+    Know you the hand?
+
+KING CLAUDIUS
+
+    'Tis Hamlets character. 'Naked!
+    And in a postscript here, he says 'alone.'
+    Can you advise me?
+
+LAERTES
+
+    I'm lost in it, my lord. But let him come;
+    It warms the very sickness in my heart,
+    That I shall live and tell him to his teeth,
+    'Thus didest thou.'
+
+KING CLAUDIUS
+
+    If it be so, Laertes--
+    As how should it be so? how otherwise?--
+    Will you be ruled by me?
+
+LAERTES
+
+    Ay, my lord;
+    So you will not o'errule me to a peace.
+
+KING CLAUDIUS
+
+    To thine own peace. If he be now return'd,
+    As checking at his voyage, and that he means
+    No more to undertake it, I will work him
+    To an exploit, now ripe in my device,
+    Under the which he shall not choose but fall:
+    And for his death no wind of blame shall breathe,
+    But even his mother shall uncharge the practise
+    And call it accident.
+
+LAERTES
+
+    My lord, I will be ruled;
+    The rather, if you could devise it so
+    That I might be the organ.
+
+KING CLAUDIUS
+
+    It falls right.
+    You have been talk'd of since your travel much,
+    And that in Hamlet's hearing, for a quality
+    Wherein, they say, you shine: your sum of parts
+    Did not together pluck such envy from him
+    As did that one, and that, in my regard,
+    Of the unworthiest siege.
+
+LAERTES
+
+    What part is that, my lord?
+
+KING CLAUDIUS
+
+    A very riband in the cap of youth,
+    Yet needful too; for youth no less becomes
+    The light and careless livery that it wears
+    Than settled age his sables and his weeds,
+    Importing health and graveness. Two months since,
+    Here was a gentleman of Normandy:--
+    I've seen myself, and served against, the French,
+    And they can well on horseback: but this gallant
+    Had witchcraft in't; he grew unto his seat;
+    And to such wondrous doing brought his horse,
+    As he had been incorpsed and demi-natured
+    With the brave beast: so far he topp'd my thought,
+    That I, in forgery of shapes and tricks,
+    Come short of what he did.
+
+LAERTES
+
+    A Norman was't?
+
+KING CLAUDIUS
+
+    A Norman.
+
+LAERTES
+
+    Upon my life, Lamond.
+
+KING CLAUDIUS
+
+    The very same.
+
+LAERTES
+
+    I know him well: he is the brooch indeed
+    And gem of all the nation.
+
+KING CLAUDIUS
+
+    He made confession of you,
+    And gave you such a masterly report
+    For art and exercise in your defence
+    And for your rapier most especially,
+    That he cried out, 'twould be a sight indeed,
+    If one could match you: the scrimers of their nation,
+    He swore, had had neither motion, guard, nor eye,
+    If you opposed them. Sir, this report of his
+    Did Hamlet so envenom with his envy
+    That he could nothing do but wish and beg
+    Your sudden coming o'er, to play with him.
+    Now, out of this,--
+
+LAERTES
+
+    What out of this, my lord?
+
+KING CLAUDIUS
+
+    Laertes, was your father dear to you?
+    Or are you like the painting of a sorrow,
+    A face without a heart?
+
+LAERTES
+
+    Why ask you this?
+
+KING CLAUDIUS
+
+    Not that I think you did not love your father;
+    But that I know love is begun by time;
+    And that I see, in passages of proof,
+    Time qualifies the spark and fire of it.
+    There lives within the very flame of love
+    A kind of wick or snuff that will abate it;
+    And nothing is at a like goodness still;
+    For goodness, growing to a plurisy,
+    Dies in his own too much: that we would do
+    We should do when we would; for this 'would' changes
+    And hath abatements and delays as many
+    As there are tongues, are hands, are accidents;
+    And then this 'should' is like a spendthrift sigh,
+    That hurts by easing. But, to the quick o' the ulcer:--
+    Hamlet comes back: what would you undertake,
+    To show yourself your father's son in deed
+    More than in words?
+
+LAERTES
+
+    To cut his throat i' the church.
+
+KING CLAUDIUS
+
+    No place, indeed, should murder sanctuarize;
+    Revenge should have no bounds. But, good Laertes,
+    Will you do this, keep close within your chamber.
+    Hamlet return'd shall know you are come home:
+    We'll put on those shall praise your excellence
+    And set a double varnish on the fame
+    The Frenchman gave you, bring you in fine together
+    And wager on your heads: he, being remiss,
+    Most generous and free from all contriving,
+    Will not peruse the foils; so that, with ease,
+    Or with a little shuffling, you may choose
+    A sword unbated, and in a pass of practise
+    Requite him for your father.
+
+LAERTES
+
+    I will do't:
+    And, for that purpose, I'll anoint my sword.
+    I bought an unction of a mountebank,
+    So mortal that, but dip a knife in it,
+    Where it draws blood no cataplasm so rare,
+    Collected from all simples that have virtue
+    Under the moon, can save the thing from death
+    That is but scratch'd withal: I'll touch my point
+    With this contagion, that, if I gall him slightly,
+    It may be death.
+
+KING CLAUDIUS
+
+    Let's further think of this;
+    Weigh what convenience both of time and means
+    May fit us to our shape: if this should fail,
+    And that our drift look through our bad performance,
+    'Twere better not assay'd: therefore this project
+    Should have a back or second, that might hold,
+    If this should blast in proof. Soft! let me see:
+    We'll make a solemn wager on your cunnings: I ha't.
+    When in your motion you are hot and dry--
+    As make your bouts more violent to that end--
+    And that he calls for drink, I'll have prepared him
+    A chalice for the nonce, whereon but sipping,
+    If he by chance escape your venom'd stuck,
+    Our purpose may hold there.
+
+    Enter QUEEN GERTRUDE
+    How now, sweet queen!
+
+QUEEN GERTRUDE
+
+    One woe doth tread upon another's heel,
+    So fast they follow; your sister's drown'd, Laertes.
+
+LAERTES
+
+    Drown'd! O, where?
+
+QUEEN GERTRUDE
+
+    There is a willow grows aslant a brook,
+    That shows his hoar leaves in the glassy stream;
+    There with fantastic garlands did she come
+    Of crow-flowers, nettles, daisies, and long purples
+    That liberal shepherds give a grosser name,
+    But our cold maids do dead men's fingers call them:
+    There, on the pendent boughs her coronet weeds
+    Clambering to hang, an envious sliver broke;
+    When down her weedy trophies and herself
+    Fell in the weeping brook. Her clothes spread wide;
+    And, mermaid-like, awhile they bore her up:
+    Which time she chanted snatches of old tunes;
+    As one incapable of her own distress,
+    Or like a creature native and indued
+    Unto that element: but long it could not be
+    Till that her garments, heavy with their drink,
+    Pull'd the poor wretch from her melodious lay
+    To muddy death.
+
+LAERTES
+
+    Alas, then, she is drown'd?
+
+QUEEN GERTRUDE
+
+    Drown'd, drown'd.
+
+LAERTES
+
+    Too much of water hast thou, poor Ophelia,
+    And therefore I forbid my tears: but yet
+    It is our trick; nature her custom holds,
+    Let shame say what it will: when these are gone,
+    The woman will be out. Adieu, my lord:
+    I have a speech of fire, that fain would blaze,
+    But that this folly douts it.
+
+    Exit
+
+KING CLAUDIUS
+
+    Let's follow, Gertrude:
+    How much I had to do to calm his rage!
+    Now fear I this will give it start again;
+    Therefore let's follow.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene1.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene1.txt
new file mode 100644
index 0000000..6c936bd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene1.txt
@@ -0,0 +1,679 @@
+ACT V
+SCENE I. A churchyard.
+
+    Enter two Clowns, with spades, & c 
+
+First Clown
+
+    Is she to be buried in Christian burial that
+    wilfully seeks her own salvation?
+
+Second Clown
+
+    I tell thee she is: and therefore make her grave
+    straight: the crowner hath sat on her, and finds it
+    Christian burial.
+
+First Clown
+
+    How can that be, unless she drowned herself in her
+    own defence?
+
+Second Clown
+
+    Why, 'tis found so.
+
+First Clown
+
+    It must be 'se offendendo;' it cannot be else. For
+    here lies the point: if I drown myself wittingly,
+    it argues an act: and an act hath three branches: it
+    is, to act, to do, to perform: argal, she drowned
+    herself wittingly.
+
+Second Clown
+
+    Nay, but hear you, goodman delver,--
+
+First Clown
+
+    Give me leave. Here lies the water; good: here
+    stands the man; good; if the man go to this water,
+    and drown himself, it is, will he, nill he, he
+    goes,--mark you that; but if the water come to him
+    and drown him, he drowns not himself: argal, he
+    that is not guilty of his own death shortens not his own life.
+
+Second Clown
+
+    But is this law?
+
+First Clown
+
+    Ay, marry, is't; crowner's quest law.
+
+Second Clown
+
+    Will you ha' the truth on't? If this had not been
+    a gentlewoman, she should have been buried out o'
+    Christian burial.
+
+First Clown
+
+    Why, there thou say'st: and the more pity that
+    great folk should have countenance in this world to
+    drown or hang themselves, more than their even
+    Christian. Come, my spade. There is no ancient
+    gentleman but gardeners, ditchers, and grave-makers:
+    they hold up Adam's profession.
+
+Second Clown
+
+    Was he a gentleman?
+
+First Clown
+
+    He was the first that ever bore arms.
+
+Second Clown
+
+    Why, he had none.
+
+First Clown
+
+    What, art a heathen? How dost thou understand the
+    Scripture? The Scripture says 'Adam digged:'
+    could he dig without arms? I'll put another
+    question to thee: if thou answerest me not to the
+    purpose, confess thyself--
+
+Second Clown
+
+    Go to.
+
+First Clown
+
+    What is he that builds stronger than either the
+    mason, the shipwright, or the carpenter?
+
+Second Clown
+
+    The gallows-maker; for that frame outlives a
+    thousand tenants.
+
+First Clown
+
+    I like thy wit well, in good faith: the gallows
+    does well; but how does it well? it does well to
+    those that do in: now thou dost ill to say the
+    gallows is built stronger than the church: argal,
+    the gallows may do well to thee. To't again, come.
+
+Second Clown
+
+    'Who builds stronger than a mason, a shipwright, or
+    a carpenter?'
+
+First Clown
+
+    Ay, tell me that, and unyoke.
+
+Second Clown
+
+    Marry, now I can tell.
+
+First Clown
+
+    To't.
+
+Second Clown
+
+    Mass, I cannot tell.
+
+    Enter HAMLET and HORATIO, at a distance
+
+First Clown
+
+    Cudgel thy brains no more about it, for your dull
+    ass will not mend his pace with beating; and, when
+    you are asked this question next, say 'a
+    grave-maker: 'the houses that he makes last till
+    doomsday. Go, get thee to Yaughan: fetch me a
+    stoup of liquor.
+
+    Exit Second Clown
+
+    He digs and sings
+    In youth, when I did love, did love,
+    Methought it was very sweet,
+    To contract, O, the time, for, ah, my behove,
+    O, methought, there was nothing meet.
+
+HAMLET
+
+    Has this fellow no feeling of his business, that he
+    sings at grave-making?
+
+HORATIO
+
+    Custom hath made it in him a property of easiness.
+
+HAMLET
+
+    'Tis e'en so: the hand of little employment hath
+    the daintier sense.
+
+First Clown
+
+    [Sings]
+    But age, with his stealing steps,
+    Hath claw'd me in his clutch,
+    And hath shipped me intil the land,
+    As if I had never been such.
+
+    Throws up a skull
+
+HAMLET
+
+    That skull had a tongue in it, and could sing once:
+    how the knave jowls it to the ground, as if it were
+    Cain's jaw-bone, that did the first murder! It
+    might be the pate of a politician, which this ass
+    now o'er-reaches; one that would circumvent God,
+    might it not?
+
+HORATIO
+
+    It might, my lord.
+
+HAMLET
+
+    Or of a courtier; which could say 'Good morrow,
+    sweet lord! How dost thou, good lord?' This might
+    be my lord such-a-one, that praised my lord
+    such-a-one's horse, when he meant to beg it; might it not?
+
+HORATIO
+
+    Ay, my lord.
+
+HAMLET
+
+    Why, e'en so: and now my Lady Worm's; chapless, and
+    knocked about the mazzard with a sexton's spade:
+    here's fine revolution, an we had the trick to
+    see't. Did these bones cost no more the breeding,
+    but to play at loggats with 'em? mine ache to think on't.
+
+First Clown
+
+    [Sings]
+    A pick-axe, and a spade, a spade,
+    For and a shrouding sheet:
+    O, a pit of clay for to be made
+    For such a guest is meet.
+
+    Throws up another skull
+
+HAMLET
+
+    There's another: why may not that be the skull of a
+    lawyer? Where be his quiddities now, his quillets,
+    his cases, his tenures, and his tricks? why does he
+    suffer this rude knave now to knock him about the
+    sconce with a dirty shovel, and will not tell him of
+    his action of battery? Hum! This fellow might be
+    in's time a great buyer of land, with his statutes,
+    his recognizances, his fines, his double vouchers,
+    his recoveries: is this the fine of his fines, and
+    the recovery of his recoveries, to have his fine
+    pate full of fine dirt? will his vouchers vouch him
+    no more of his purchases, and double ones too, than
+    the length and breadth of a pair of indentures? The
+    very conveyances of his lands will hardly lie in
+    this box; and must the inheritor himself have no more, ha?
+
+HORATIO
+
+    Not a jot more, my lord.
+
+HAMLET
+
+    Is not parchment made of sheepskins?
+
+HORATIO
+
+    Ay, my lord, and of calf-skins too.
+
+HAMLET
+
+    They are sheep and calves which seek out assurance
+    in that. I will speak to this fellow. Whose
+    grave's this, sirrah?
+
+First Clown
+
+    Mine, sir.
+
+    Sings
+    O, a pit of clay for to be made
+    For such a guest is meet.
+
+HAMLET
+
+    I think it be thine, indeed; for thou liest in't.
+
+First Clown
+
+    You lie out on't, sir, and therefore it is not
+    yours: for my part, I do not lie in't, and yet it is mine.
+
+HAMLET
+
+    'Thou dost lie in't, to be in't and say it is thine:
+    'tis for the dead, not for the quick; therefore thou liest.
+
+First Clown
+
+    'Tis a quick lie, sir; 'twill away gain, from me to
+    you.
+
+HAMLET
+
+    What man dost thou dig it for?
+
+First Clown
+
+    For no man, sir.
+
+HAMLET
+
+    What woman, then?
+
+First Clown
+
+    For none, neither.
+
+HAMLET
+
+    Who is to be buried in't?
+
+First Clown
+
+    One that was a woman, sir; but, rest her soul, she's dead.
+
+HAMLET
+
+    How absolute the knave is! we must speak by the
+    card, or equivocation will undo us. By the Lord,
+    Horatio, these three years I have taken a note of
+    it; the age is grown so picked that the toe of the
+    peasant comes so near the heel of the courtier, he
+    gaffs his kibe. How long hast thou been a
+    grave-maker?
+
+First Clown
+
+    Of all the days i' the year, I came to't that day
+    that our last king Hamlet overcame Fortinbras.
+
+HAMLET
+
+    How long is that since?
+
+First Clown
+
+    Cannot you tell that? every fool can tell that: it
+    was the very day that young Hamlet was born; he that
+    is mad, and sent into England.
+
+HAMLET
+
+    Ay, marry, why was he sent into England?
+
+First Clown
+
+    Why, because he was mad: he shall recover his wits
+    there; or, if he do not, it's no great matter there.
+
+HAMLET
+
+    Why?
+
+First Clown
+
+    'Twill, a not be seen in him there; there the men
+    are as mad as he.
+
+HAMLET
+
+    How came he mad?
+
+First Clown
+
+    Very strangely, they say.
+
+HAMLET
+
+    How strangely?
+
+First Clown
+
+    Faith, e'en with losing his wits.
+
+HAMLET
+
+    Upon what ground?
+
+First Clown
+
+    Why, here in Denmark: I have been sexton here, man
+    and boy, thirty years.
+
+HAMLET
+
+    How long will a man lie i' the earth ere he rot?
+
+First Clown
+
+    I' faith, if he be not rotten before he die--as we
+    have many pocky corses now-a-days, that will scarce
+    hold the laying in--he will last you some eight year
+    or nine year: a tanner will last you nine year.
+
+HAMLET
+
+    Why he more than another?
+
+First Clown
+
+    Why, sir, his hide is so tanned with his trade, that
+    he will keep out water a great while; and your water
+    is a sore decayer of your whoreson dead body.
+    Here's a skull now; this skull has lain in the earth
+    three and twenty years.
+
+HAMLET
+
+    Whose was it?
+
+First Clown
+
+    A whoreson mad fellow's it was: whose do you think it was?
+
+HAMLET
+
+    Nay, I know not.
+
+First Clown
+
+    A pestilence on him for a mad rogue! a' poured a
+    flagon of Rhenish on my head once. This same skull,
+    sir, was Yorick's skull, the king's jester.
+
+HAMLET
+
+    This?
+
+First Clown
+
+    E'en that.
+
+HAMLET
+
+    Let me see.
+
+    Takes the skull
+    Alas, poor Yorick! I knew him, Horatio: a fellow
+    of infinite jest, of most excellent fancy: he hath
+    borne me on his back a thousand times; and now, how
+    abhorred in my imagination it is! my gorge rims at
+    it. Here hung those lips that I have kissed I know
+    not how oft. Where be your gibes now? your
+    gambols? your songs? your flashes of merriment,
+    that were wont to set the table on a roar? Not one
+    now, to mock your own grinning? quite chap-fallen?
+    Now get you to my lady's chamber, and tell her, let
+    her paint an inch thick, to this favour she must
+    come; make her laugh at that. Prithee, Horatio, tell
+    me one thing.
+
+HORATIO
+
+    What's that, my lord?
+
+HAMLET
+
+    Dost thou think Alexander looked o' this fashion i'
+    the earth?
+
+HORATIO
+
+    E'en so.
+
+HAMLET
+
+    And smelt so? pah!
+
+    Puts down the skull
+
+HORATIO
+
+    E'en so, my lord.
+
+HAMLET
+
+    To what base uses we may return, Horatio! Why may
+    not imagination trace the noble dust of Alexander,
+    till he find it stopping a bung-hole?
+
+HORATIO
+
+    'Twere to consider too curiously, to consider so.
+
+HAMLET
+
+    No, faith, not a jot; but to follow him thither with
+    modesty enough, and likelihood to lead it: as
+    thus: Alexander died, Alexander was buried,
+    Alexander returneth into dust; the dust is earth; of
+    earth we make loam; and why of that loam, whereto he
+    was converted, might they not stop a beer-barrel?
+    Imperious Caesar, dead and turn'd to clay,
+    Might stop a hole to keep the wind away:
+    O, that that earth, which kept the world in awe,
+    Should patch a wall to expel the winter flaw!
+    But soft! but soft! aside: here comes the king.
+
+    Enter Priest, & c. in procession; the Corpse of OPHELIA, LAERTES and Mourners following; KING CLAUDIUS, QUEEN GERTRUDE, their trains, & c
+    The queen, the courtiers: who is this they follow?
+    And with such maimed rites? This doth betoken
+    The corse they follow did with desperate hand
+    Fordo its own life: 'twas of some estate.
+    Couch we awhile, and mark.
+
+    Retiring with HORATIO
+
+LAERTES
+
+    What ceremony else?
+
+HAMLET
+
+    That is Laertes,
+    A very noble youth: mark.
+
+LAERTES
+
+    What ceremony else?
+
+First Priest
+
+    Her obsequies have been as far enlarged
+    As we have warrantise: her death was doubtful;
+    And, but that great command o'ersways the order,
+    She should in ground unsanctified have lodged
+    Till the last trumpet: for charitable prayers,
+    Shards, flints and pebbles should be thrown on her;
+    Yet here she is allow'd her virgin crants,
+    Her maiden strewments and the bringing home
+    Of bell and burial.
+
+LAERTES
+
+    Must there no more be done?
+
+First Priest
+
+    No more be done:
+    We should profane the service of the dead
+    To sing a requiem and such rest to her
+    As to peace-parted souls.
+
+LAERTES
+
+    Lay her i' the earth:
+    And from her fair and unpolluted flesh
+    May violets spring! I tell thee, churlish priest,
+    A ministering angel shall my sister be,
+    When thou liest howling.
+
+HAMLET
+
+    What, the fair Ophelia!
+
+QUEEN GERTRUDE
+
+    Sweets to the sweet: farewell!
+
+    Scattering flowers
+    I hoped thou shouldst have been my Hamlet's wife;
+    I thought thy bride-bed to have deck'd, sweet maid,
+    And not have strew'd thy grave.
+
+LAERTES
+
+    O, treble woe
+    Fall ten times treble on that cursed head,
+    Whose wicked deed thy most ingenious sense
+    Deprived thee of! Hold off the earth awhile,
+    Till I have caught her once more in mine arms:
+
+    Leaps into the grave
+    Now pile your dust upon the quick and dead,
+    Till of this flat a mountain you have made,
+    To o'ertop old Pelion, or the skyish head
+    Of blue Olympus.
+
+HAMLET
+
+    [Advancing] What is he whose grief
+    Bears such an emphasis? whose phrase of sorrow
+    Conjures the wandering stars, and makes them stand
+    Like wonder-wounded hearers? This is I,
+    Hamlet the Dane.
+
+    Leaps into the grave
+
+LAERTES
+
+    The devil take thy soul!
+
+    Grappling with him
+
+HAMLET
+
+    Thou pray'st not well.
+    I prithee, take thy fingers from my throat;
+    For, though I am not splenitive and rash,
+    Yet have I something in me dangerous,
+    Which let thy wiseness fear: hold off thy hand.
+
+KING CLAUDIUS
+
+    Pluck them asunder.
+
+QUEEN GERTRUDE
+
+    Hamlet, Hamlet!
+
+All
+
+    Gentlemen,--
+
+HORATIO
+
+    Good my lord, be quiet.
+
+    The Attendants part them, and they come out of the grave
+
+HAMLET
+
+    Why I will fight with him upon this theme
+    Until my eyelids will no longer wag.
+
+QUEEN GERTRUDE
+
+    O my son, what theme?
+
+HAMLET
+
+    I loved Ophelia: forty thousand brothers
+    Could not, with all their quantity of love,
+    Make up my sum. What wilt thou do for her?
+
+KING CLAUDIUS
+
+    O, he is mad, Laertes.
+
+QUEEN GERTRUDE
+
+    For love of God, forbear him.
+
+HAMLET
+
+    'Swounds, show me what thou'lt do:
+    Woo't weep? woo't fight? woo't fast? woo't tear thyself?
+    Woo't drink up eisel? eat a crocodile?
+    I'll do't. Dost thou come here to whine?
+    To outface me with leaping in her grave?
+    Be buried quick with her, and so will I:
+    And, if thou prate of mountains, let them throw
+    Millions of acres on us, till our ground,
+    Singeing his pate against the burning zone,
+    Make Ossa like a wart! Nay, an thou'lt mouth,
+    I'll rant as well as thou.
+
+QUEEN GERTRUDE
+
+    This is mere madness:
+    And thus awhile the fit will work on him;
+    Anon, as patient as the female dove,
+    When that her golden couplets are disclosed,
+    His silence will sit drooping.
+
+HAMLET
+
+    Hear you, sir;
+    What is the reason that you use me thus?
+    I loved you ever: but it is no matter;
+    Let Hercules himself do what he may,
+    The cat will mew and dog will have his day.
+
+    Exit
+
+KING CLAUDIUS
+
+    I pray you, good Horatio, wait upon him.
+
+    Exit HORATIO
+
+    To LAERTES
+    Strengthen your patience in our last night's speech;
+    We'll put the matter to the present push.
+    Good Gertrude, set some watch over your son.
+    This grave shall have a living monument:
+    An hour of quiet shortly shall we see;
+    Till then, in patience our proceeding be.
+
+    Exeunt
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene2.txt b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene2.txt
new file mode 100644
index 0000000..d35e3fc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/act5/scene2.txt
@@ -0,0 +1,914 @@
+SCENE II. A hall in the castle.
+
+    Enter HAMLET and HORATIO 
+
+HAMLET
+
+    So much for this, sir: now shall you see the other;
+    You do remember all the circumstance?
+
+HORATIO
+
+    Remember it, my lord?
+
+HAMLET
+
+    Sir, in my heart there was a kind of fighting,
+    That would not let me sleep: methought I lay
+    Worse than the mutines in the bilboes. Rashly,
+    And praised be rashness for it, let us know,
+    Our indiscretion sometimes serves us well,
+    When our deep plots do pall: and that should teach us
+    There's a divinity that shapes our ends,
+    Rough-hew them how we will,--
+
+HORATIO
+
+    That is most certain.
+
+HAMLET
+
+    Up from my cabin,
+    My sea-gown scarf'd about me, in the dark
+    Groped I to find out them; had my desire.
+    Finger'd their packet, and in fine withdrew
+    To mine own room again; making so bold,
+    My fears forgetting manners, to unseal
+    Their grand commission; where I found, Horatio,--
+    O royal knavery!--an exact command,
+    Larded with many several sorts of reasons
+    Importing Denmark's health and England's too,
+    With, ho! such bugs and goblins in my life,
+    That, on the supervise, no leisure bated,
+    No, not to stay the grinding of the axe,
+    My head should be struck off.
+
+HORATIO
+
+    Is't possible?
+
+HAMLET
+
+    Here's the commission: read it at more leisure.
+    But wilt thou hear me how I did proceed?
+
+HORATIO
+
+    I beseech you.
+
+HAMLET
+
+    Being thus be-netted round with villanies,--
+    Ere I could make a prologue to my brains,
+    They had begun the play--I sat me down,
+    Devised a new commission, wrote it fair:
+    I once did hold it, as our statists do,
+    A baseness to write fair and labour'd much
+    How to forget that learning, but, sir, now
+    It did me yeoman's service: wilt thou know
+    The effect of what I wrote?
+
+HORATIO
+
+    Ay, good my lord.
+
+HAMLET
+
+    An earnest conjuration from the king,
+    As England was his faithful tributary,
+    As love between them like the palm might flourish,
+    As peace should stiff her wheaten garland wear
+    And stand a comma 'tween their amities,
+    And many such-like 'As'es of great charge,
+    That, on the view and knowing of these contents,
+    Without debatement further, more or less,
+    He should the bearers put to sudden death,
+    Not shriving-time allow'd.
+
+HORATIO
+
+    How was this seal'd?
+
+HAMLET
+
+    Why, even in that was heaven ordinant.
+    I had my father's signet in my purse,
+    Which was the model of that Danish seal;
+    Folded the writ up in form of the other,
+    Subscribed it, gave't the impression, placed it safely,
+    The changeling never known. Now, the next day
+    Was our sea-fight; and what to this was sequent
+    Thou know'st already.
+
+HORATIO
+
+    So Guildenstern and Rosencrantz go to't.
+
+HAMLET
+
+    Why, man, they did make love to this employment;
+    They are not near my conscience; their defeat
+    Does by their own insinuation grow:
+    'Tis dangerous when the baser nature comes
+    Between the pass and fell incensed points
+    Of mighty opposites.
+
+HORATIO
+
+    Why, what a king is this!
+
+HAMLET
+
+    Does it not, think'st thee, stand me now upon--
+    He that hath kill'd my king and whored my mother,
+    Popp'd in between the election and my hopes,
+    Thrown out his angle for my proper life,
+    And with such cozenage--is't not perfect conscience,
+    To quit him with this arm? and is't not to be damn'd,
+    To let this canker of our nature come
+    In further evil?
+
+HORATIO
+
+    It must be shortly known to him from England
+    What is the issue of the business there.
+
+HAMLET
+
+    It will be short: the interim is mine;
+    And a man's life's no more than to say 'One.'
+    But I am very sorry, good Horatio,
+    That to Laertes I forgot myself;
+    For, by the image of my cause, I see
+    The portraiture of his: I'll court his favours.
+    But, sure, the bravery of his grief did put me
+    Into a towering passion.
+
+HORATIO
+
+    Peace! who comes here?
+
+    Enter OSRIC
+
+OSRIC
+
+    Your lordship is right welcome back to Denmark.
+
+HAMLET
+
+    I humbly thank you, sir. Dost know this water-fly?
+
+HORATIO
+
+    No, my good lord.
+
+HAMLET
+
+    Thy state is the more gracious; for 'tis a vice to
+    know him. He hath much land, and fertile: let a
+    beast be lord of beasts, and his crib shall stand at
+    the king's mess: 'tis a chough; but, as I say,
+    spacious in the possession of dirt.
+
+OSRIC
+
+    Sweet lord, if your lordship were at leisure, I
+    should impart a thing to you from his majesty.
+
+HAMLET
+
+    I will receive it, sir, with all diligence of
+    spirit. Put your bonnet to his right use; 'tis for the head.
+
+OSRIC
+
+    I thank your lordship, it is very hot.
+
+HAMLET
+
+    No, believe me, 'tis very cold; the wind is
+    northerly.
+
+OSRIC
+
+    It is indifferent cold, my lord, indeed.
+
+HAMLET
+
+    But yet methinks it is very sultry and hot for my
+    complexion.
+
+OSRIC
+
+    Exceedingly, my lord; it is very sultry,--as
+    'twere,--I cannot tell how. But, my lord, his
+    majesty bade me signify to you that he has laid a
+    great wager on your head: sir, this is the matter,--
+
+HAMLET
+
+    I beseech you, remember--
+
+    HAMLET moves him to put on his hat
+
+OSRIC
+
+    Nay, good my lord; for mine ease, in good faith.
+    Sir, here is newly come to court Laertes; believe
+    me, an absolute gentleman, full of most excellent
+    differences, of very soft society and great showing:
+    indeed, to speak feelingly of him, he is the card or
+    calendar of gentry, for you shall find in him the
+    continent of what part a gentleman would see.
+
+HAMLET
+
+    Sir, his definement suffers no perdition in you;
+    though, I know, to divide him inventorially would
+    dizzy the arithmetic of memory, and yet but yaw
+    neither, in respect of his quick sail. But, in the
+    verity of extolment, I take him to be a soul of
+    great article; and his infusion of such dearth and
+    rareness, as, to make true diction of him, his
+    semblable is his mirror; and who else would trace
+    him, his umbrage, nothing more.
+
+OSRIC
+
+    Your lordship speaks most infallibly of him.
+
+HAMLET
+
+    The concernancy, sir? why do we wrap the gentleman
+    in our more rawer breath?
+
+OSRIC
+
+    Sir?
+
+HORATIO
+
+    Is't not possible to understand in another tongue?
+    You will do't, sir, really.
+
+HAMLET
+
+    What imports the nomination of this gentleman?
+
+OSRIC
+
+    Of Laertes?
+
+HORATIO
+
+    His purse is empty already; all's golden words are spent.
+
+HAMLET
+
+    Of him, sir.
+
+OSRIC
+
+    I know you are not ignorant--
+
+HAMLET
+
+    I would you did, sir; yet, in faith, if you did,
+    it would not much approve me. Well, sir?
+
+OSRIC
+
+    You are not ignorant of what excellence Laertes is--
+
+HAMLET
+
+    I dare not confess that, lest I should compare with
+    him in excellence; but, to know a man well, were to
+    know himself.
+
+OSRIC
+
+    I mean, sir, for his weapon; but in the imputation
+    laid on him by them, in his meed he's unfellowed.
+
+HAMLET
+
+    What's his weapon?
+
+OSRIC
+
+    Rapier and dagger.
+
+HAMLET
+
+    That's two of his weapons: but, well.
+
+OSRIC
+
+    The king, sir, hath wagered with him six Barbary
+    horses: against the which he has imponed, as I take
+    it, six French rapiers and poniards, with their
+    assigns, as girdle, hangers, and so: three of the
+    carriages, in faith, are very dear to fancy, very
+    responsive to the hilts, most delicate carriages,
+    and of very liberal conceit.
+
+HAMLET
+
+    What call you the carriages?
+
+HORATIO
+
+    I knew you must be edified by the margent ere you had done.
+
+OSRIC
+
+    The carriages, sir, are the hangers.
+
+HAMLET
+
+    The phrase would be more german to the matter, if we
+    could carry cannon by our sides: I would it might
+    be hangers till then. But, on: six Barbary horses
+    against six French swords, their assigns, and three
+    liberal-conceited carriages; that's the French bet
+    against the Danish. Why is this 'imponed,' as you call it?
+
+OSRIC
+
+    The king, sir, hath laid, that in a dozen passes
+    between yourself and him, he shall not exceed you
+    three hits: he hath laid on twelve for nine; and it
+    would come to immediate trial, if your lordship
+    would vouchsafe the answer.
+
+HAMLET
+
+    How if I answer 'no'?
+
+OSRIC
+
+    I mean, my lord, the opposition of your person in trial.
+
+HAMLET
+
+    Sir, I will walk here in the hall: if it please his
+    majesty, 'tis the breathing time of day with me; let
+    the foils be brought, the gentleman willing, and the
+    king hold his purpose, I will win for him an I can;
+    if not, I will gain nothing but my shame and the odd hits.
+
+OSRIC
+
+    Shall I re-deliver you e'en so?
+
+HAMLET
+
+    To this effect, sir; after what flourish your nature will.
+
+OSRIC
+
+    I commend my duty to your lordship.
+
+HAMLET
+
+    Yours, yours.
+
+    Exit OSRIC
+    He does well to commend it himself; there are no
+    tongues else for's turn.
+
+HORATIO
+
+    This lapwing runs away with the shell on his head.
+
+HAMLET
+
+    He did comply with his dug, before he sucked it.
+    Thus has he--and many more of the same bevy that I
+    know the dressy age dotes on--only got the tune of
+    the time and outward habit of encounter; a kind of
+    yesty collection, which carries them through and
+    through the most fond and winnowed opinions; and do
+    but blow them to their trial, the bubbles are out.
+
+    Enter a Lord
+
+Lord
+
+    My lord, his majesty commended him to you by young
+    Osric, who brings back to him that you attend him in
+    the hall: he sends to know if your pleasure hold to
+    play with Laertes, or that you will take longer time.
+
+HAMLET
+
+    I am constant to my purpose; they follow the king's
+    pleasure: if his fitness speaks, mine is ready; now
+    or whensoever, provided I be so able as now.
+
+Lord
+
+    The king and queen and all are coming down.
+
+HAMLET
+
+    In happy time.
+
+Lord
+
+    The queen desires you to use some gentle
+    entertainment to Laertes before you fall to play.
+
+HAMLET
+
+    She well instructs me.
+
+    Exit Lord
+
+HORATIO
+
+    You will lose this wager, my lord.
+
+HAMLET
+
+    I do not think so: since he went into France, I
+    have been in continual practise: I shall win at the
+    odds. But thou wouldst not think how ill all's here
+    about my heart: but it is no matter.
+
+HORATIO
+
+    Nay, good my lord,--
+
+HAMLET
+
+    It is but foolery; but it is such a kind of
+    gain-giving, as would perhaps trouble a woman.
+
+HORATIO
+
+    If your mind dislike any thing, obey it: I will
+    forestall their repair hither, and say you are not
+    fit.
+
+HAMLET
+
+    Not a whit, we defy augury: there's a special
+    providence in the fall of a sparrow. If it be now,
+    'tis not to come; if it be not to come, it will be
+    now; if it be not now, yet it will come: the
+    readiness is all: since no man has aught of what he
+    leaves, what is't to leave betimes?
+
+    Enter KING CLAUDIUS, QUEEN GERTRUDE, LAERTES, Lords, OSRIC, and Attendants with foils, & c
+
+KING CLAUDIUS
+
+    Come, Hamlet, come, and take this hand from me.
+
+    KING CLAUDIUS puts LAERTES' hand into HAMLET's
+
+HAMLET
+
+    Give me your pardon, sir: I've done you wrong;
+    But pardon't, as you are a gentleman.
+    This presence knows,
+    And you must needs have heard, how I am punish'd
+    With sore distraction. What I have done,
+    That might your nature, honour and exception
+    Roughly awake, I here proclaim was madness.
+    Was't Hamlet wrong'd Laertes? Never Hamlet:
+    If Hamlet from himself be ta'en away,
+    And when he's not himself does wrong Laertes,
+    Then Hamlet does it not, Hamlet denies it.
+    Who does it, then? His madness: if't be so,
+    Hamlet is of the faction that is wrong'd;
+    His madness is poor Hamlet's enemy.
+    Sir, in this audience,
+    Let my disclaiming from a purposed evil
+    Free me so far in your most generous thoughts,
+    That I have shot mine arrow o'er the house,
+    And hurt my brother.
+
+LAERTES
+
+    I am satisfied in nature,
+    Whose motive, in this case, should stir me most
+    To my revenge: but in my terms of honour
+    I stand aloof; and will no reconcilement,
+    Till by some elder masters, of known honour,
+    I have a voice and precedent of peace,
+    To keep my name ungored. But till that time,
+    I do receive your offer'd love like love,
+    And will not wrong it.
+
+HAMLET
+
+    I embrace it freely;
+    And will this brother's wager frankly play.
+    Give us the foils. Come on.
+
+LAERTES
+
+    Come, one for me.
+
+HAMLET
+
+    I'll be your foil, Laertes: in mine ignorance
+    Your skill shall, like a star i' the darkest night,
+    Stick fiery off indeed.
+
+LAERTES
+
+    You mock me, sir.
+
+HAMLET
+
+    No, by this hand.
+
+KING CLAUDIUS
+
+    Give them the foils, young Osric. Cousin Hamlet,
+    You know the wager?
+
+HAMLET
+
+    Very well, my lord
+    Your grace hath laid the odds o' the weaker side.
+
+KING CLAUDIUS
+
+    I do not fear it; I have seen you both:
+    But since he is better'd, we have therefore odds.
+
+LAERTES
+
+    This is too heavy, let me see another.
+
+HAMLET
+
+    This likes me well. These foils have all a length?
+
+    They prepare to play
+
+OSRIC
+
+    Ay, my good lord.
+
+KING CLAUDIUS
+
+    Set me the stoops of wine upon that table.
+    If Hamlet give the first or second hit,
+    Or quit in answer of the third exchange,
+    Let all the battlements their ordnance fire:
+    The king shall drink to Hamlet's better breath;
+    And in the cup an union shall he throw,
+    Richer than that which four successive kings
+    In Denmark's crown have worn. Give me the cups;
+    And let the kettle to the trumpet speak,
+    The trumpet to the cannoneer without,
+    The cannons to the heavens, the heavens to earth,
+    'Now the king dunks to Hamlet.' Come, begin:
+    And you, the judges, bear a wary eye.
+
+HAMLET
+
+    Come on, sir.
+
+LAERTES
+
+    Come, my lord.
+
+    They play
+
+HAMLET
+
+    One.
+
+LAERTES
+
+    No.
+
+HAMLET
+
+    Judgment.
+
+OSRIC
+
+    A hit, a very palpable hit.
+
+LAERTES
+
+    Well; again.
+
+KING CLAUDIUS
+
+    Stay; give me drink. Hamlet, this pearl is thine;
+    Here's to thy health.
+
+    Trumpets sound, and cannon shot off within
+    Give him the cup.
+
+HAMLET
+
+    I'll play this bout first; set it by awhile. Come.
+
+    They play
+    Another hit; what say you?
+
+LAERTES
+
+    A touch, a touch, I do confess.
+
+KING CLAUDIUS
+
+    Our son shall win.
+
+QUEEN GERTRUDE
+
+    He's fat, and scant of breath.
+    Here, Hamlet, take my napkin, rub thy brows;
+    The queen carouses to thy fortune, Hamlet.
+
+HAMLET
+
+    Good madam!
+
+KING CLAUDIUS
+
+    Gertrude, do not drink.
+
+QUEEN GERTRUDE
+
+    I will, my lord; I pray you, pardon me.
+
+KING CLAUDIUS
+
+    [Aside] It is the poison'd cup: it is too late.
+
+HAMLET
+
+    I dare not drink yet, madam; by and by.
+
+QUEEN GERTRUDE
+
+    Come, let me wipe thy face.
+
+LAERTES
+
+    My lord, I'll hit him now.
+
+KING CLAUDIUS
+
+    I do not think't.
+
+LAERTES
+
+    [Aside] And yet 'tis almost 'gainst my conscience.
+
+HAMLET
+
+    Come, for the third, Laertes: you but dally;
+    I pray you, pass with your best violence;
+    I am afeard you make a wanton of me.
+
+LAERTES
+
+    Say you so? come on.
+
+    They play
+
+OSRIC
+
+    Nothing, neither way.
+
+LAERTES
+
+    Have at you now!
+
+    LAERTES wounds HAMLET; then in scuffling, they change rapiers, and HAMLET wounds LAERTES
+
+KING CLAUDIUS
+
+    Part them; they are incensed.
+
+HAMLET
+
+    Nay, come, again.
+
+    QUEEN GERTRUDE falls
+
+OSRIC
+
+    Look to the queen there, ho!
+
+HORATIO
+
+    They bleed on both sides. How is it, my lord?
+
+OSRIC
+
+    How is't, Laertes?
+
+LAERTES
+
+    Why, as a woodcock to mine own springe, Osric;
+    I am justly kill'd with mine own treachery.
+
+HAMLET
+
+    How does the queen?
+
+KING CLAUDIUS
+
+    She swounds to see them bleed.
+
+QUEEN GERTRUDE
+
+    No, no, the drink, the drink,--O my dear Hamlet,--
+    The drink, the drink! I am poison'd.
+
+    Dies
+
+HAMLET
+
+    O villany! Ho! let the door be lock'd:
+    Treachery! Seek it out.
+
+LAERTES
+
+    It is here, Hamlet: Hamlet, thou art slain;
+    No medicine in the world can do thee good;
+    In thee there is not half an hour of life;
+    The treacherous instrument is in thy hand,
+    Unbated and envenom'd: the foul practise
+    Hath turn'd itself on me lo, here I lie,
+    Never to rise again: thy mother's poison'd:
+    I can no more: the king, the king's to blame.
+
+HAMLET
+
+    The point!--envenom'd too!
+    Then, venom, to thy work.
+
+    Stabs KING CLAUDIUS
+
+All
+
+    Treason! treason!
+
+KING CLAUDIUS
+
+    O, yet defend me, friends; I am but hurt.
+
+HAMLET
+
+    Here, thou incestuous, murderous, damned Dane,
+    Drink off this potion. Is thy union here?
+    Follow my mother.
+
+    KING CLAUDIUS dies
+
+LAERTES
+
+    He is justly served;
+    It is a poison temper'd by himself.
+    Exchange forgiveness with me, noble Hamlet:
+    Mine and my father's death come not upon thee,
+    Nor thine on me.
+
+    Dies
+
+HAMLET
+
+    Heaven make thee free of it! I follow thee.
+    I am dead, Horatio. Wretched queen, adieu!
+    You that look pale and tremble at this chance,
+    That are but mutes or audience to this act,
+    Had I but time--as this fell sergeant, death,
+    Is strict in his arrest--O, I could tell you--
+    But let it be. Horatio, I am dead;
+    Thou livest; report me and my cause aright
+    To the unsatisfied.
+
+HORATIO
+
+    Never believe it:
+    I am more an antique Roman than a Dane:
+    Here's yet some liquor left.
+
+HAMLET
+
+    As thou'rt a man,
+    Give me the cup: let go; by heaven, I'll have't.
+    O good Horatio, what a wounded name,
+    Things standing thus unknown, shall live behind me!
+    If thou didst ever hold me in thy heart
+    Absent thee from felicity awhile,
+    And in this harsh world draw thy breath in pain,
+    To tell my story.
+
+    March afar off, and shot within
+    What warlike noise is this?
+
+OSRIC
+
+    Young Fortinbras, with conquest come from Poland,
+    To the ambassadors of England gives
+    This warlike volley.
+
+HAMLET
+
+    O, I die, Horatio;
+    The potent poison quite o'er-crows my spirit:
+    I cannot live to hear the news from England;
+    But I do prophesy the election lights
+    On Fortinbras: he has my dying voice;
+    So tell him, with the occurrents, more and less,
+    Which have solicited. The rest is silence.
+
+    Dies
+
+HORATIO
+
+    Now cracks a noble heart. Good night sweet prince:
+    And flights of angels sing thee to thy rest!
+    Why does the drum come hither?
+
+    March within
+
+    Enter FORTINBRAS, the English Ambassadors, and others
+
+PRINCE FORTINBRAS
+
+    Where is this sight?
+
+HORATIO
+
+    What is it ye would see?
+    If aught of woe or wonder, cease your search.
+
+PRINCE FORTINBRAS
+
+    This quarry cries on havoc. O proud death,
+    What feast is toward in thine eternal cell,
+    That thou so many princes at a shot
+    So bloodily hast struck?
+
+First Ambassador
+
+    The sight is dismal;
+    And our affairs from England come too late:
+    The ears are senseless that should give us hearing,
+    To tell him his commandment is fulfill'd,
+    That Rosencrantz and Guildenstern are dead:
+    Where should we have our thanks?
+
+HORATIO
+
+    Not from his mouth,
+    Had it the ability of life to thank you:
+    He never gave commandment for their death.
+    But since, so jump upon this bloody question,
+    You from the Polack wars, and you from England,
+    Are here arrived give order that these bodies
+    High on a stage be placed to the view;
+    And let me speak to the yet unknowing world
+    How these things came about: so shall you hear
+    Of carnal, bloody, and unnatural acts,
+    Of accidental judgments, casual slaughters,
+    Of deaths put on by cunning and forced cause,
+    And, in this upshot, purposes mistook
+    Fall'n on the inventors' reads: all this can I
+    Truly deliver.
+
+PRINCE FORTINBRAS
+
+    Let us haste to hear it,
+    And call the noblest to the audience.
+    For me, with sorrow I embrace my fortune:
+    I have some rights of memory in this kingdom,
+    Which now to claim my vantage doth invite me.
+
+HORATIO
+
+    Of that I shall have also cause to speak,
+    And from his mouth whose voice will draw on more;
+    But let this same be presently perform'd,
+    Even while men's minds are wild; lest more mischance
+    On plots and errors, happen.
+
+PRINCE FORTINBRAS
+
+    Let four captains
+    Bear Hamlet, like a soldier, to the stage;
+    For he was likely, had he been put on,
+    To have proved most royally: and, for his passage,
+    The soldiers' music and the rites of war
+    Speak loudly for him.
+    Take up the bodies: such a sight as this
+    Becomes the field, but here shows much amiss.
+    Go, bid the soldiers shoot.
+
+    A dead march. Exeunt, bearing off the dead bodies; after which a peal of ordnance is shot off
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/bookmarks/2019-07-16 b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/bookmarks/2019-07-16
new file mode 120000
index 0000000..b7541e4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/test_fs/hamlet/bookmarks/2019-07-16
@@ -0,0 +1 @@
+../act1/scene2.txt
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/close_preopen_fd.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/close_preopen_fd.rs
new file mode 100644
index 0000000..a4d77a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/close_preopen_fd.rs
@@ -0,0 +1,44 @@
+// WASI:
+// mapdir: hamlet:test_fs/hamlet
+
+use std::fs;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_close(fd: u32) -> u16;
+    fn fd_fdstat_set_flags(fd: u32, flags: u16) -> u16;
+}
+
+const FIRST_PREOPEN_FD: u32 = 4;
+
+fn main() {
+    #[cfg(target_os = "wasi")]
+    {
+        let result = unsafe { fd_fdstat_set_flags(FIRST_PREOPEN_FD, 1 << 2) };
+        println!(
+            "accessing preopen fd was a {}",
+            if result == 0 { "success" } else { "failure" }
+        );
+
+        let result = unsafe { fd_close(FIRST_PREOPEN_FD) };
+        println!(
+            "Closing preopen fd was a {}",
+            if result == 0 { "success" } else { "failure" }
+        );
+
+        let result = unsafe { fd_fdstat_set_flags(FIRST_PREOPEN_FD, 1 << 2) };
+        println!(
+            "accessing closed preopen fd was an EBADF error: {}",
+            if result == 8 { "true" } else { "false" }
+        );
+    }
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        println!("accessing preopen fd was a success");
+        println!("Closing preopen fd was a success");
+        println!("accessing closed preopen fd was an EBADF error: true");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/create_dir.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/create_dir.rs
new file mode 100644
index 0000000..6590080
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/create_dir.rs
@@ -0,0 +1,40 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::path::*;
+
+fn main() {
+    let mut path = PathBuf::from("test_fs/wasitests/testing/nested/directories");
+    let test_file = path.join("test.file");
+    fs::create_dir_all(&path).unwrap();
+    {
+        let mut file = fs::OpenOptions::new()
+            .read(true)
+            .write(true)
+            .truncate(true)
+            .create(true)
+            .open(&test_file)
+            .unwrap();
+
+        assert_eq!(file.write(b"hello").unwrap(), 5);
+
+        file.flush().unwrap();
+        file.seek(SeekFrom::Start(0)).unwrap();
+        let mut in_str = String::new();
+        file.read_to_string(&mut in_str).unwrap();
+        assert_eq!(&in_str, "hello");
+    }
+    fs::remove_file(&test_file).unwrap();
+    println!("Test file exists: {}", test_file.exists());
+    assert!(!test_file.exists());
+    for _ in 0..3 {
+        fs::remove_dir_all(&path).unwrap();
+        println!("Dir exists: {}", path.exists());
+        assert!(!path.exists());
+        path.pop();
+    }
+
+    println!("Success");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/envvar.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/envvar.rs
new file mode 100644
index 0000000..1846114
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/envvar.rs
@@ -0,0 +1,38 @@
+// WASI:
+// env: DOG=1
+// env: CAT=2
+
+use std::env;
+
+fn get_env_var(var_name: &str) -> Result<String, env::VarError> {
+    #[cfg(not(target = "wasi"))]
+    match var_name {
+        "DOG" => Ok("1".to_string()),
+        "CAT" => Ok("2".to_string()),
+        _ => Err(env::VarError::NotPresent),
+    }
+    #[cfg(target = "wasi")]
+    env::var(var_name)
+}
+
+fn main() {
+    #[cfg(not(target = "wasi"))]
+    let mut env_vars = vec!["DOG=1".to_string(), "CAT=2".to_string()];
+    #[cfg(target = "wasi")]
+    let mut env_vars = env::vars()
+        .map(|(key, value)| format!("{}={}", key, value))
+        .collect::<Vec<String>>();
+
+    env_vars.sort();
+
+    println!("Env vars:");
+    for e in env_vars {
+        println!("{}", e);
+    }
+
+    env::set_var("WASI_ENVVAR_TEST", "HELLO");
+
+    println!("DOG {:?}", get_env_var("DOG"));
+    println!("DOG_TYPE {:?}", get_env_var("DOG_TYPE"));
+    println!("SET VAR {:?}", env::var("WASI_ENVVAR_TEST"));
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_allocate.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_allocate.rs
new file mode 100644
index 0000000..58b9769
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_allocate.rs
@@ -0,0 +1,58 @@
+// WASI:
+// tempdir: .
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_allocate(fd: u32, offset: u64, length: u64) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn allocate(fd: u32, offset: u64, length: u64) -> u16 {
+    unsafe { fd_allocate(fd, offset, length) }
+}
+
+fn main() {
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+    #[cfg(target_os = "wasi")]
+    {
+        base.push("fd_allocate_file.txt");
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&base)
+            .expect("Could not create file");
+        let mut buffer = [0u8; 64];
+
+        {
+            use std::io::Write;
+            // example text from https://www.un.org/en/universal-declaration-human-rights/
+            file.write_all(b"All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.\n").unwrap();
+            let raw_fd = file.as_raw_fd();
+            file.flush();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 171);
+            allocate(raw_fd, len, 1234);
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 1234 + 171);
+        }
+    }
+    #[cfg(target_os = "wasi")]
+    std::fs::remove_file(&base).unwrap();
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!("171");
+        println!("1405");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_append.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_append.rs
new file mode 100644
index 0000000..1278736
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_append.rs
@@ -0,0 +1,55 @@
+// WASI:
+// tempdir: .
+
+use std::fs::OpenOptions;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+static STR1: &str = "Hello, world!\n";
+static STR2: &str = "Goodbye, world!\n";
+
+fn main() {
+    let file = {
+        #[cfg(not(target_os = "wasi"))]
+        let mut base = PathBuf::from("test_fs/temp");
+        #[cfg(target_os = "wasi")]
+        let mut base = PathBuf::from(".");
+
+        base.push("fd_append_test");
+        base
+    };
+
+    {
+        let mut file_handle = OpenOptions::new()
+            .create_new(true)
+            .append(true)
+            .open(&file)
+            .expect("Couldn't create file");
+        file_handle.write_all(STR1.as_bytes()).unwrap();
+        file_handle.flush().unwrap();
+        file_handle.sync_all();
+    }
+    {
+        let mut file_handle = OpenOptions::new()
+            .append(true)
+            .open(&file)
+            .expect("Couldn't reopen file to append");
+        file_handle.write_all(STR2.as_bytes()).unwrap();
+        file_handle.flush().unwrap();
+        file_handle.sync_all();
+    }
+
+    {
+        let mut file_handle = OpenOptions::new()
+            .read(true)
+            .open(&file)
+            .expect("Couldn't reopen file to read");
+
+        let mut test = String::new();
+        file_handle.read_to_string(&mut test);
+
+        assert_eq!(&test, &format!("{}{}", STR1, STR2));
+        println!("{:?}", &test);
+    }
+    std::fs::remove_file(&file).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_close.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_close.rs
new file mode 100644
index 0000000..08bb308
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_close.rs
@@ -0,0 +1,63 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_close(fd: u32) -> u16;
+}
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+
+    base.push("act3/scene3.txt");
+    let file = fs::File::open(&base).expect("could not open file");
+
+    #[cfg(target_os = "wasi")]
+    {
+        let file_fd = file.as_raw_fd();
+        let stdout_fd = std::io::stdout().as_raw_fd();
+        let stderr_fd = std::io::stderr().as_raw_fd();
+        let stdin_fd = std::io::stdin().as_raw_fd();
+
+        let result = unsafe { fd_close(file_fd) };
+        if result == 0 {
+            println!("Successfully closed file!")
+        } else {
+            println!("Could not close file");
+        }
+
+        let result = unsafe { fd_close(stderr_fd) };
+        if result == 0 {
+            println!("Successfully closed stderr!")
+        } else {
+            println!("Could not close stderr");
+        }
+        let result = unsafe { fd_close(stdin_fd) };
+        if result == 0 {
+            println!("Successfully closed stdin!")
+        } else {
+            println!("Could not close stdin");
+        }
+        let result = unsafe { fd_close(stdout_fd) };
+        if result == 0 {
+            println!("Successfully closed stdout!")
+        } else {
+            println!("Could not close stdout");
+        }
+    }
+    #[cfg(not(target_os = "wasi"))]
+    {
+        println!("Successfully closed file!");
+        println!("Successfully closed stderr!");
+        println!("Successfully closed stdin!");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_pread.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_pread.rs
new file mode 100644
index 0000000..6d45bb3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_pread.rs
@@ -0,0 +1,84 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[repr(C)]
+struct WasiIovec {
+    pub buf: u32,
+    pub buf_len: u32,
+}
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_pread(fd: u32, iovs: u32, iovs_len: u32, offset: u64, nread: u32) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn pread(fd: u32, iovs: &[&mut [u8]], offset: u64) -> u32 {
+    let mut nread = 0;
+    let mut processed_iovs = vec![];
+
+    for iov in iovs {
+        processed_iovs.push(WasiIovec {
+            buf: iov.as_ptr() as usize as u32,
+            buf_len: iov.len() as u32,
+        })
+    }
+
+    unsafe {
+        fd_pread(
+            fd,
+            processed_iovs.as_ptr() as usize as u32,
+            processed_iovs.len() as u32,
+            offset,
+            &mut nread as *mut u32 as usize as u32,
+        );
+    }
+    nread
+}
+
+fn main() {
+    let mut base = PathBuf::from("test_fs/hamlet");
+
+    base.push("act3/scene4.txt");
+    let mut file = fs::File::open(&base).expect("Could not open file");
+    let mut buffer = [0u8; 64];
+
+    #[cfg(target_os = "wasi")]
+    {
+        let raw_fd = file.as_raw_fd();
+        assert_eq!(pread(raw_fd, &[&mut buffer], 75), 64);
+        let str_val = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val);
+        for i in 0..buffer.len() {
+            buffer[i] = 0;
+        }
+        assert_eq!(pread(raw_fd, &[&mut buffer], 75), 64);
+        let str_val2 = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val2);
+
+        println!("Read the same data? {}", str_val == str_val2);
+    }
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!(
+            " POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+ POLONIUS
+
+    He will come straight. Look you lay home to him:
+
+Read the same data? true"
+        );
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_read.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_read.rs
new file mode 100644
index 0000000..fbdff89
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_read.rs
@@ -0,0 +1,86 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+// this program is used in the pause/resume test
+
+use std::fs;
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[repr(C)]
+struct WasiIovec {
+    pub buf: u32,
+    pub buf_len: u32,
+}
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_read(fd: u32, iovs: u32, iovs_len: u32, nread: u32) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn read(fd: u32, iovs: &[&mut [u8]]) -> u32 {
+    let mut nread = 0;
+    let mut processed_iovs = vec![];
+
+    for iov in iovs {
+        processed_iovs.push(WasiIovec {
+            buf: iov.as_ptr() as usize as u32,
+            buf_len: iov.len() as u32,
+        })
+    }
+
+    unsafe {
+        fd_read(
+            fd,
+            processed_iovs.as_ptr() as usize as u32,
+            processed_iovs.len() as u32,
+            &mut nread as *mut u32 as usize as u32,
+        );
+    }
+    nread
+}
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+
+    base.push("act3/scene4.txt");
+    let mut file = fs::File::open(&base).expect("Could not open file");
+    let mut buffer = [0u8; 64];
+
+    #[cfg(target_os = "wasi")]
+    {
+        let raw_fd = file.as_raw_fd();
+        assert_eq!(read(raw_fd, &[&mut buffer]), 64);
+        let str_val = std::str::from_utf8(&buffer[..]).unwrap().to_string();
+        println!("{}", &str_val);
+    }
+    // leak the file handle so that we can use it later
+    std::mem::forget(file);
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!(
+            "SCENE IV. The Queen's closet.
+
+    Enter QUEEN GERTRUDE and POLO"
+        );
+    }
+}
+
+#[cfg(target_os = "wasi")]
+#[no_mangle]
+fn second_entry() -> bool {
+    let raw_fd = 5;
+    let mut buffer = [0u8; 8];
+    let result = read(raw_fd, &[&mut buffer]);
+
+    &buffer == b"NIUS \n\nL"
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rename_path.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rename_path.rs
new file mode 100644
index 0000000..9d2b4ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rename_path.rs
@@ -0,0 +1,27 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::path::PathBuf;
+
+fn main() {
+    let mut idx = 0;
+    fs::create_dir_all(PathBuf::from("test_fs/wasitests")).expect("cannot create the parent directory");
+
+    let old_path = loop {
+        let old_path = PathBuf::from(format!("test_fs/wasitests/dirtorename-{}", idx));
+        if fs::create_dir(old_path.clone()).ok().is_some() {
+            break old_path;
+        }
+        idx+=1;
+        if idx > 10 {
+            panic!("too many try at creating the folder");
+        }
+    };
+
+    let new_path = PathBuf::from(format!("test_fs/wasitests/dirrenamed-{}", idx));
+
+    fs::rename(old_path, &new_path).expect("cannot rename the directory");
+
+    fs::remove_dir(&new_path).expect("cannot remove the directory");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rights.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rights.rs
new file mode 100644
index 0000000..5ab1c20
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_rights.rs
@@ -0,0 +1,27 @@
+// WASI:
+// tempdir: .
+
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+fn main() {
+    let file = {
+        let mut base = PathBuf::from(".");
+
+        base.push("foo.txt");
+        base
+    };
+
+    let mut filehandle = std::fs::OpenOptions::new()
+        .read(false) // <- should only be writeable, not readable
+        .write(true)
+        .create(true)
+        .open(&file)
+        .unwrap();
+    filehandle.write_all(b"test");
+
+    let mut contents = String::new();
+    assert!(filehandle.read_to_string(&mut contents).is_err());
+
+    std::fs::remove_file(&file).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_sync.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_sync.rs
new file mode 100644
index 0000000..e925301
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fd_sync.rs
@@ -0,0 +1,56 @@
+// WASI:
+// tempdir: .
+
+use std::fs;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn fd_sync(fd: u32) -> u16;
+}
+
+#[cfg(target_os = "wasi")]
+fn sync(fd: u32) -> u16 {
+    unsafe { fd_sync(fd) }
+}
+
+fn main() {
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+    #[cfg(target_os = "wasi")]
+    {
+        base.push("fd_sync_file.txt");
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&base)
+            .expect("Could not create file");
+        let mut buffer = [0u8; 64];
+
+        {
+            use std::io::Write;
+            // example text from https://www.un.org/en/universal-declaration-human-rights/
+            file.write_all(b"All human beings are born free and equal in dignity and rights. They are endowed with reason and conscience and should act towards one another in a spirit of brotherhood.").unwrap();
+            file.sync_all();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 170);
+            file.set_len(170 + 1234);
+            file.sync_all();
+            let len = file.metadata().unwrap().len();
+            println!("{}", len);
+            assert_eq!(len, 1234 + 170);
+        }
+    }
+    #[cfg(target_os = "wasi")]
+    std::fs::remove_file(&base).unwrap();
+
+    #[cfg(not(target_os = "wasi"))]
+    {
+        // eh, just print the output directly
+        println!("170");
+        println!("1404");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/file_metadata.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/file_metadata.rs
new file mode 100644
index 0000000..5995ec1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/file_metadata.rs
@@ -0,0 +1,20 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io::Read;
+
+fn main() {
+    let mut this_file =
+        fs::File::open("test_fs/hamlet/act1/scene1.txt").expect("could not find file");
+    let md = this_file.metadata().unwrap();
+    println!("is dir: {}", md.is_dir());
+    let filetype = md.file_type();
+    println!(
+        "filetype: {} {} {}",
+        filetype.is_dir(),
+        filetype.is_file(),
+        filetype.is_symlink()
+    );
+    println!("file info: {}", md.len());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fs_sandbox_test.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fs_sandbox_test.rs
new file mode 100644
index 0000000..acd9dde
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fs_sandbox_test.rs
@@ -0,0 +1,10 @@
+fn main() {
+    #[cfg(target = "wasi")]
+    let result = std::fs::read_dir("..");
+    #[cfg(not(target = "wasi"))]
+    let result: Result<(), String> = Err("placeholder".to_string());
+    println!(
+        "Reading the parent directory was okay? {:?}",
+        result.is_ok()
+    );
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fseek.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fseek.rs
new file mode 100644
index 0000000..ca1a56d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/fseek.rs
@@ -0,0 +1,47 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom};
+use std::path::PathBuf;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from(".");
+
+    base.push("act1/scene3.txt");
+
+    let mut file = fs::File::open(&base).expect("Could not open file");
+
+    let mut buffer = [0u8; 32];
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Start(123)).unwrap(), 123);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::End(-123)).unwrap(), 6617);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Current(-250)).unwrap(), 6399);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    assert_eq!(file.seek(SeekFrom::Current(50)).unwrap(), 6481);
+    assert_eq!(file.read(&mut buffer).unwrap(), 32);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/hello.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/hello.rs
new file mode 100644
index 0000000..e7a11a9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/hello.rs
@@ -0,0 +1,3 @@
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/inode.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/inode.rs
new file mode 100644
index 0000000..1c2e00a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/inode.rs
@@ -0,0 +1,31 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io;
+#[cfg(target = "wasi")]
+use std::os::wasi::fs::MetadataExt;
+
+// `test_fs` will be implicit.
+// this need experimentat MetadataExt
+// this program does nothing in native
+// it only tests things in wasi
+fn main() {
+    #[cfg(target = "wasi")]
+    {
+        let meta1 = fs::metadata("test_fs/hamlet/act1/scene1.txt").expect("could not find src file");
+        let meta2 = fs::metadata("test_fs/hamlet/act1/scene2.txt").expect("could not find src file");
+        if meta1.dev() == meta2.dev() && meta1.ino() == meta2.ino() {
+            println!("Warning, different files from same folder have same dev/inod");
+        }
+        let meta3 = fs::metadata("test_fs/hamlet/act2/scene1.txt").expect("could not find src file");
+        if meta1.dev() == meta3.dev() && meta1.ino() == meta3.ino() {
+            println!("Warning, different files from different folder with same name  have same dev/inod");
+        }
+        let meta4 = fs::metadata("test_fs/hamlet/act1/../act1/scene1.txt").expect("could not find src file");
+        if meta1.dev() != meta4.dev() || meta1.ino() != meta4.ino() {
+            println!("Warning, same files have different dev/inod");
+        }
+    }
+    println!("all done");
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/isatty.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/isatty.rs
new file mode 100644
index 0000000..422880f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/isatty.rs
@@ -0,0 +1,22 @@
+// We don't have access to libc, so we just use isatty
+// as an external function
+// use libc::isatty;
+
+extern "C" {
+    pub fn isatty(fd: i32) -> i32;
+}
+
+fn main() {
+    #[cfg(target = "wasi")]
+    {
+        println!("stdin: {}", unsafe { isatty(0) });
+        println!("stdout: {}", unsafe { isatty(1) });
+        println!("stderr: {}", unsafe { isatty(2) });
+    }
+    #[cfg(not(target = "wasi"))]
+    {
+        println!("stdin: 1");
+        println!("stdout: 1");
+        println!("stderr: 1");
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir.rs
new file mode 100644
index 0000000..96c45e0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir.rs
@@ -0,0 +1,20 @@
+// WASI:
+// mapdir: .:test_fs/hamlet
+
+use std::fs;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    std::env::set_current_dir("test_fs/hamlet").unwrap();
+
+    let read_dir = fs::read_dir(".").unwrap();
+    let mut out = vec![];
+    for entry in read_dir {
+        out.push(format!("{:?}", entry.unwrap().path()));
+    }
+    out.sort();
+
+    for p in out {
+        println!("{}", p);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir_with_leading_slash.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir_with_leading_slash.rs
new file mode 100644
index 0000000..979af37
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/mapdir_with_leading_slash.rs
@@ -0,0 +1,23 @@
+// WASI:
+// mapdir: /hamlet:test_fs/hamlet
+
+use std::fs;
+use std::io::Read;
+use std::path::PathBuf;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs/hamlet");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("hamlet");
+
+    base.push("act3/scene3.txt");
+
+    println!("File exists? {}", base.exists());
+
+    let mut f = fs::File::open(&base).unwrap();
+    let mut s = String::new();
+    f.read_to_string(&mut s).unwrap();
+
+    println!("{}", s.chars().take(256).collect::<String>());
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_link.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_link.rs
new file mode 100644
index 0000000..ac5fd9c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_link.rs
@@ -0,0 +1,53 @@
+// WASI:
+// mapdir: act5:test_fs/hamlet/act5
+// tempdir: temp
+
+use std::fs;
+use std::io::Read;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    {
+        let out_str = "ACT V
+SCENE I. A churchyard.
+
+    Enter two Clowns, with spades,";
+        println!("{}", out_str);
+        println!("{}", out_str);
+        println!("Path still exists");
+    }
+
+    #[cfg(target_os = "wasi")]
+    {
+        {
+            std::fs::hard_link("act5/scene1.txt", "temp/scene_of_the_day.txt").unwrap();
+            let mut f = fs::OpenOptions::new()
+                .read(true)
+                .open("temp/scene_of_the_day.txt")
+                .unwrap();
+            let mut buffer = [0u8; 64];
+            f.read_exact(&mut buffer).unwrap();
+
+            println!("{}", std::str::from_utf8(&buffer[..]).unwrap());
+            for b in buffer.iter_mut() {
+                *b = 0;
+            }
+
+            let mut f = fs::OpenOptions::new()
+                .read(true)
+                .open("act5/scene1.txt")
+                .unwrap();
+            f.read_exact(&mut buffer).unwrap();
+            println!("{}", std::str::from_utf8(&buffer[..]).unwrap());
+        }
+
+        std::fs::remove_file("temp/scene_of_the_day.txt").unwrap();
+        let path = std::path::PathBuf::from("act5/scene1.txt");
+
+        if path.exists() {
+            println!("Path still exists");
+        } else {
+            println!("Path was deleted!");
+        }
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_rename.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_rename.rs
new file mode 100644
index 0000000..87f985f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_rename.rs
@@ -0,0 +1,248 @@
+// WASI:
+// tempdir: temp
+
+use std::fs;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+fn run_with_toplevel_dir() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("temp");
+
+    let file_to_create = base.join("path_rename_file.txt");
+    let file_to_rename_to = base.join("path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        // text from https://ja.wikipedia.org/wiki/柴犬
+        let shiba_string = "「柴犬」という名前は中央高地で使われていたもので、文献上では、昭和初期の日本犬保存会の会誌「日本犬」で用いられている。一般的には、「柴」は小ぶりな雑木を指す。
+由来には諸説があり、
+
+    柴藪を巧みにくぐり抜けて猟を助けることから
+    赤褐色の毛色が枯れ柴に似ている（柴赤）ことから
+    小さなものを表す古語の「柴」から
+
+の3つの説が代表的。";
+        let shiba_bytes: Vec<u8> = shiba_string.bytes().collect();
+        f.write_all(&shiba_bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("The original file still exists!");
+        return;
+    } else {
+        println!("The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("The moved file does not exist!");
+        return;
+    }
+
+    // TODO: add temp directory suport for native execution...
+    // until then, don't actually inspect the directory when running native code.
+    #[cfg(target_os = "wasi")]
+    for item in fs::read_dir(&base).unwrap() {
+        println!(
+            "Found item: {}",
+            item.unwrap().path().file_name().unwrap().to_str().unwrap()
+        );
+    }
+    #[cfg(not(target_os = "wasi"))]
+    {
+        println!("Found item: path_renamed_file.txt");
+    }
+
+    let mut out_str = String::new();
+    file.read_to_string(&mut out_str).unwrap();
+    let mut test_str = String::new();
+    let mut out_chars = out_str.chars();
+    out_chars.next().unwrap();
+    test_str.push(out_chars.next().unwrap());
+    test_str.push(out_chars.next().unwrap());
+
+    println!("{}", test_str);
+    std::fs::remove_file(file_to_rename_to).unwrap();
+}
+
+fn run_with_toplevel_dir_overwrite() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("temp");
+
+    let file_to_create = base.join("path_rename_file.txt");
+    let file_to_rename_to = base.join("path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        // text from https://ja.wikipedia.org/wiki/柴犬
+        let shiba_string = "「柴犬」という名前は中央高地で使われていたもので、文献上では、昭和初期の日本犬保存会の会誌「日本犬」で用いられている。一般的には、「柴」は小ぶりな雑木を指す。
+由来には諸説があり、
+
+    柴藪を巧みにくぐり抜けて猟を助けることから
+    赤褐色の毛色が枯れ柴に似ている（柴赤）ことから
+    小さなものを表す古語の「柴」から
+
+の3つの説が代表的。";
+        f.write_all(shiba_string.as_bytes()).unwrap();
+    }
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_rename_to)
+            .unwrap();
+
+        let lorem_string = "lorem ispum";
+        f.write_all(lorem_string.as_bytes()).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("The original file still exists!");
+        return;
+    } else {
+        println!("The original file does not still exist!");
+    }
+
+
+    if !file_to_rename_to.exists() {
+        println!("The moved file does not exist!");
+        return;
+    }
+
+    // TODO: add temp directory suport for native execution...
+    // until then, don't actually inspect the directory when running native code.
+    #[cfg(target_os = "wasi")]
+    for item in fs::read_dir(&base).unwrap() {
+        println!(
+            "Found item: {}",
+            item.unwrap().path().file_name().unwrap().to_str().unwrap()
+        );
+    }
+    #[cfg(not(target_os = "wasi"))]
+    {
+        println!("Found item: path_renamed_file.txt");
+    }
+
+    let mut out_str = String::new();
+    file.read_to_string(&mut out_str).unwrap();
+    let mut test_str = String::new();
+    let mut out_chars = out_str.chars();
+    out_chars.next().unwrap();
+    test_str.push(out_chars.next().unwrap());
+    test_str.push(out_chars.next().unwrap());
+
+    println!("{}", test_str);
+    std::fs::remove_file(file_to_rename_to).unwrap();
+}
+
+fn run_with_sub_dir() {
+    #[cfg(not(target_os = "wasi"))]
+    let base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("temp");
+
+    //make a sub-directory
+    fs::create_dir(base.join("sub"));
+
+    let file_to_create = base.join("sub/path_rename_file.txt");
+    let file_to_rename_to = base.join("sub/path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        let string = "Hello world";
+        let bytes: Vec<u8> = string.bytes().collect();
+        f.write_all(&bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("run_with_sub_dir: The original file still exists!");
+        return;
+    } else {
+        println!("run_with_sub_dir: The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("run_with_sub_dir: The moved file does not exist!");
+        return;
+    }
+    fs::remove_dir_all(base.join("sub"));
+}
+
+fn run_with_different_sub_dirs() {
+    #[cfg(not(target_os = "wasi"))]
+    let base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("temp");
+
+    //make sub-directories
+    fs::create_dir(base.join("a"));
+    fs::create_dir(base.join("a/b"));
+    fs::create_dir(base.join("c"));
+    fs::create_dir(base.join("c/d"));
+    fs::create_dir(base.join("c/d/e"));
+
+    let file_to_create = base.join("a/b/path_rename_file.txt");
+    let file_to_rename_to = base.join("c/d/e/path_renamed_file.txt");
+
+    {
+        let mut f = std::fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(&file_to_create)
+            .unwrap();
+
+        let string = "Hello world";
+        let bytes: Vec<u8> = string.bytes().collect();
+        f.write_all(&bytes[..]).unwrap();
+    }
+
+    std::fs::rename(&file_to_create, &file_to_rename_to).unwrap();
+    let mut file = fs::File::open(&file_to_rename_to).expect("Could not open file");
+    if file_to_create.exists() {
+        println!("run_with_different_sub_dirs: The original file still exists!");
+        return;
+    } else {
+        println!("run_with_different_sub_dirs: The original file does not still exist!");
+    }
+
+    if !file_to_rename_to.exists() {
+        println!("run_with_different_sub_dirs: The moved file does not exist!");
+        return;
+    }
+
+    fs::remove_dir_all(base.join("a"));
+    fs::remove_dir_all(base.join("c"));
+}
+
+fn main() {
+    run_with_toplevel_dir();
+    run_with_toplevel_dir_overwrite();
+    run_with_sub_dir();
+    run_with_different_sub_dirs();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_symlink.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_symlink.rs
new file mode 100644
index 0000000..55464f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/path_symlink.rs
@@ -0,0 +1,30 @@
+// WASI:
+// tempdir: temp
+// mapdir: hamlet:test_fs/hamlet
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom};
+use std::path::PathBuf;
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("/");
+
+    let symlink_loc = base.join("temp/act3");
+    let symlink_target = "../hamlet/act3";
+    let scene1 = symlink_loc.join("scene1.txt");
+
+    std::fs::soft_link(&symlink_target, &symlink_loc);
+
+    let mut file = fs::File::open(&scene1).expect("Could not open file");
+
+    let mut buffer = [0u8; 64];
+
+    assert_eq!(file.read(&mut buffer).unwrap(), 64);
+    let str_val = std::str::from_utf8(&buffer[..]).unwrap();
+    println!("{}", str_val);
+
+    std::fs::remove_file(symlink_loc).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/pipe_reverse.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/pipe_reverse.rs
new file mode 100644
index 0000000..0778cd6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/pipe_reverse.rs
@@ -0,0 +1,13 @@
+// WASI:
+// stdin: "Hello, world!"
+
+use std::io;
+
+fn main() {
+    let mut input = String::new();
+    io::stdin().read_line(&mut input).unwrap();
+
+    let output: String = input.chars().rev().collect();
+
+    println!("{}", output);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/poll_oneoff.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/poll_oneoff.rs
new file mode 100644
index 0000000..da942ff
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/poll_oneoff.rs
@@ -0,0 +1,218 @@
+// WASI:
+// mapdir: hamlet:test_fs/hamlet
+// tempdir: temp
+
+use std::fs;
+use std::io::{Read, Seek, SeekFrom};
+#[cfg(target_os = "wasi")]
+use std::os::wasi::prelude::AsRawFd;
+use std::path::PathBuf;
+
+#[cfg(target_os = "wasi")]
+#[link(wasm_import_module = "wasi_unstable")]
+extern "C" {
+    fn poll_oneoff(subscriptions: u32, events: u32, nsubscriptions: u32, nevents: u32) -> u16;
+}
+
+#[derive(Debug, Copy, Clone)]
+#[repr(C)]
+pub struct __wasi_event_t {
+    pub userdata: u64,
+    pub error: u16,
+    pub type_: __wasi_eventtype_t,
+    pub u: __wasi_event_u,
+}
+
+impl Default for __wasi_event_t {
+    fn default() -> Self {
+        __wasi_event_t {
+            userdata: 0,
+            error: 0,
+            type_: 0,
+            u: __wasi_event_u {
+                fd_readwrite: __wasi_event_fd_readwrite_t {
+                    nbytes: 0,
+                    flags: 0,
+                },
+            },
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_event_fd_readwrite_t {
+    pub nbytes: u64,
+    pub flags: u16,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __wasi_event_u {
+    pub fd_readwrite: __wasi_event_fd_readwrite_t,
+}
+
+impl std::fmt::Debug for __wasi_event_u {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "__wasi_event_u {{ ")?;
+        write!(f, "{:?} }}", unsafe { self.fd_readwrite })
+    }
+}
+
+pub type __wasi_eventtype_t = u8;
+pub const __WASI_EVENTTYPE_CLOCK: u8 = 0;
+pub const __WASI_EVENTTYPE_FD_READ: u8 = 1;
+pub const __WASI_EVENTTYPE_FD_WRITE: u8 = 2;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_subscription_clock_t {
+    pub userdata: u64,
+    pub clock_id: u32,
+    pub timeout: u64,
+    pub precision: u64,
+    pub flags: u16,
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[repr(C)]
+pub struct __wasi_subscription_fs_readwrite_t {
+    pub fd: u32,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub union __wasi_subscription_u {
+    clock: __wasi_subscription_clock_t,
+    fd_readwrite: __wasi_subscription_fs_readwrite_t,
+}
+
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct __wasi_subscription_t {
+    pub userdata: u64,
+    pub type_: __wasi_eventtype_t,
+    pub u: __wasi_subscription_u,
+}
+
+#[cfg(target_os = "wasi")]
+fn poll(fds: &[u32], read: &[bool], write: &[bool]) -> Result<Vec<__wasi_event_t>, u16> {
+    assert!(fds.len() == read.len() && read.len() == write.len());
+
+    let mut in_ = fds
+        .iter()
+        .enumerate()
+        .map(|(i, n)| {
+            let mut type_ = 0;
+            if read[i] {
+                type_ |= __WASI_EVENTTYPE_FD_READ;
+            }
+            if write[i] {
+                type_ |= __WASI_EVENTTYPE_FD_WRITE;
+            }
+            __wasi_subscription_t {
+                userdata: 0x123456,
+                type_,
+                u: __wasi_subscription_u {
+                    fd_readwrite: __wasi_subscription_fs_readwrite_t { fd: *n as u32 },
+                },
+            }
+        })
+        .collect::<Vec<_>>();
+    let mut out_ = vec![Default::default(); in_.len()];
+    let mut nsubscriptions: u32 = 0;
+    let result = unsafe {
+        poll_oneoff(
+            in_.as_ptr() as usize as u32,
+            out_.as_mut_ptr() as usize as u32,
+            in_.len() as u32,
+            (&mut nsubscriptions as *mut u32) as usize as u32,
+        )
+    };
+
+    if result == 0 {
+        Ok(out_)
+    } else {
+        Err(result)
+    }
+}
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    let mut base = PathBuf::from("test_fs");
+    #[cfg(target_os = "wasi")]
+    let mut base = PathBuf::from("/");
+
+    let path = base.join("hamlet/act4/scene1.txt");
+    let path2 = base.join("temp/poll_oneoff_write.txt");
+    {
+        let mut file = fs::File::open(&path).expect("Could not open file");
+        let mut file2 = fs::OpenOptions::new()
+            .create(true)
+            .write(true)
+            .truncate(true)
+            .open(&path2)
+            .expect("Could not open file");
+        file2.set_len(1234).unwrap();
+
+        #[cfg(target_os = "wasi")]
+        {
+            let fds = vec![file.as_raw_fd()];
+            let mut result = poll(fds.as_slice(), &[true], &[false]).expect("First poll");
+            while result[0].error != 0 {
+                result = poll(fds.as_slice(), &[true], &[false]).expect("subsequent polls");
+            }
+            println!("{:?}", result[0]);
+
+            let fds = vec![file.as_raw_fd(), file2.as_raw_fd()];
+            result = poll(fds.as_slice(), &[true, false], &[false, true]).expect("First poll");
+            while result[0].error != 0 {
+                result =
+                    poll(fds.as_slice(), &[true, false], &[false, true]).expect("subsequent polls");
+            }
+            println!("{:?}", result);
+
+            /// stdin, stdout, stderr checking
+            let fds = vec![std::io::stdin().as_raw_fd()];
+            print!("Stdin: ");
+            println!(
+                "{}",
+                if poll(fds.as_slice(), &[true], &[false]).is_ok() {
+                    "OK"
+                } else {
+                    "ERROR"
+                }
+            );
+            let fds = vec![std::io::stdout().as_raw_fd()];
+            print!("Stdout: ");
+            println!(
+                "{}",
+                if poll(fds.as_slice(), &[false], &[true]).is_ok() {
+                    "OK"
+                } else {
+                    "ERROR"
+                }
+            );
+            let fds = vec![std::io::stderr().as_raw_fd()];
+            print!("Stderr: ");
+            println!(
+                "{}",
+                if poll(fds.as_slice(), &[false], &[true]).is_ok() {
+                    "OK"
+                } else {
+                    "ERROR"
+                }
+            );
+        }
+        #[cfg(not(target_os = "wasi"))]
+        {
+            println!("{}", "__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }");
+            println!("{}", "[__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }, __wasi_event_t { userdata: 1193046, error: 0, type_: 2, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 1234, flags: 0 } } }]");
+            println!("Stdin: OK");
+            println!("Stdout: OK");
+            println!("Stderr: OK");
+        }
+    }
+
+    std::fs::remove_file(path2).unwrap();
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/quine.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/quine.rs
new file mode 100644
index 0000000..dab5a5a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/quine.rs
@@ -0,0 +1,16 @@
+// WASI:
+// dir: test_fs
+
+use std::fs;
+use std::io::Read;
+
+// NOTE: This program is no longer a quine because we want to sandbox these tests to `test_fs`, in the future
+// `test_fs` will be implicit.
+fn main() {
+    let mut this_file =
+        fs::File::open("test_fs/hamlet/act1/scene2.txt").expect("could not find src file");
+    let md = this_file.metadata().unwrap();
+    let mut in_str = String::new();
+    this_file.read_to_string(&mut in_str).unwrap();
+    println!("{}", in_str);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/readlink.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/readlink.rs
new file mode 100644
index 0000000..ff9f225
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/readlink.rs
@@ -0,0 +1,28 @@
+// WASI:
+// dir: test_fs
+
+use std::io::Read;
+
+fn main() {
+    let sym_link_path = "test_fs/hamlet/bookmarks/2019-07-16";
+
+    let p = std::path::Path::new(sym_link_path);
+    dbg!(&p);
+    println!("{}", p.exists());
+    let link_path = std::fs::read_link(sym_link_path).expect("Could not read link");
+    println!("{}", link_path.to_string_lossy());
+
+    let mut some_contents =
+        std::fs::File::open(sym_link_path).expect("Could not open file via symlink");
+
+    let mut buffer = [0; 128];
+
+    assert_eq!(
+        some_contents
+            .read(&mut buffer)
+            .expect("Could not read 128 bytes from file"),
+        128
+    );
+    let str_val = std::str::from_utf8(&buffer[..]).expect("Could not parse buffer bytes as UTF-8");
+    println!("{}", str_val);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/unix_open_special_files.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/unix_open_special_files.rs
new file mode 100644
index 0000000..d449cbe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/unix_open_special_files.rs
@@ -0,0 +1,14 @@
+// WASI:
+// mapdir: /dev:/dev
+
+use std::fs;
+use std::io::Write;
+
+fn main() {
+    let mut f = fs::OpenOptions::new()
+        .write(true)
+        .open("/dev/null")
+        .unwrap();
+    let result = f.write(b"hello, world!").unwrap();
+    println!("{}", result);
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/wasi_sees_virtual_root.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/wasi_sees_virtual_root.rs
new file mode 100644
index 0000000..ac99708
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/wasi_sees_virtual_root.rs
@@ -0,0 +1,59 @@
+// WASI:
+// mapdir: act1:test_fs/hamlet/act1
+// mapdir: act2:test_fs/hamlet/act2
+// mapdir: act1-again:test_fs/hamlet/act1
+
+use std::fs;
+
+fn main() {
+    // just cheat in this test because there is no comparison for native
+    #[cfg(not(target_os = "wasi"))]
+    let results = {
+        let start = vec!["\"/act1\"", "\"/act1-again\"", "\"/act2\""];
+
+        let mut out = vec![];
+        for _ in 0..4 {
+            for path_str in &start {
+                out.push(path_str.to_string());
+            }
+        }
+
+        out.push("ROOT IS SAFE".to_string());
+        out
+    };
+
+    #[cfg(target_os = "wasi")]
+    let results = {
+        let mut out = vec![];
+
+        let read_dir = fs::read_dir("/").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("act1/..").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("act1/../../..").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let read_dir = fs::read_dir("act1/../../act2/../act1/../../../").unwrap();
+        for entry in read_dir {
+            out.push(format!("{:?}", entry.unwrap().path()))
+        }
+        let f = fs::OpenOptions::new().write(true).open("/abc");
+
+        if f.is_ok() {
+            out.push("ROOT IS NOT SAFE".to_string());
+        } else {
+            out.push("ROOT IS SAFE".to_string());
+        }
+
+        out
+    };
+
+    for result in results {
+        println!("{}", result);
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/writing.rs b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/writing.rs
new file mode 100644
index 0000000..5887e5c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/tests/writing.rs
@@ -0,0 +1,38 @@
+// WASI:
+// mapdir: act1:test_fs/hamlet/act1
+// mapdir: act2:test_fs/hamlet/act2
+// mapdir: act1-again:test_fs/hamlet/act1
+
+use std::fs;
+use std::io::Write;
+
+pub const BYTE_STR: &'static [u8] = b"abcdefghijklmnopqrstuvwxyz";
+
+fn main() {
+    #[cfg(not(target_os = "wasi"))]
+    do_logic_on_path("test_fs/hamlet/act1/abc", "test_fs/hamlet/act1/abc");
+
+    #[cfg(target_os = "wasi")]
+    do_logic_on_path("/act1/abc", "act1-again/abc");
+}
+
+fn do_logic_on_path(path: &'static str, alt_path: &'static str) {
+    {
+        let mut f = fs::OpenOptions::new()
+            .create_new(true)
+            .write(true)
+            .open(path)
+            .unwrap();
+        f.write_all(BYTE_STR).unwrap();
+    }
+
+    println!("{}", fs::read_to_string(alt_path).unwrap());
+    fs::remove_file(path).unwrap();
+
+    let file_path = std::path::Path::new(path);
+    if file_path.exists() {
+        println!("file is here");
+    } else {
+        println!("file is gone")
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wasm
new file mode 100755
index 0000000..90e80c1
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast
new file mode 100644
index 0000000..65dda3b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/close_preopen_fd.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "close_preopen_fd.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "accessing preopen fd was a success\nClosing preopen fd was a success\naccessing closed preopen fd was an EBADF error: true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wasm
new file mode 100755
index 0000000..17c4523
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wast
new file mode 100644
index 0000000..7722640
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/create_dir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "create_dir.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "Test file exists: false\nDir exists: false\nDir exists: false\nDir exists: false\nSuccess\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wasm
new file mode 100755
index 0000000..bb2fc01
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wast
new file mode 100644
index 0000000..fbfe0b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/envvar.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "envvar.wasm"
+  (envs "DOG=1" "CAT=2")
+  (assert_return (i64.const 0))
+  (assert_stdout "Env vars:\nCAT=2\nDOG=1\nDOG Ok(\"1\")\nDOG_TYPE Err(NotPresent)\nSET VAR Ok(\"HELLO\")\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wasm
new file mode 100755
index 0000000..ac4c274
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wast
new file mode 100644
index 0000000..784294e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_allocate.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_allocate.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "171\n1405\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wasm
new file mode 100755
index 0000000..79164f4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wast
new file mode 100644
index 0000000..1c973ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_append.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_append.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"Hello, world!\\nGoodbye, world!\\n\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wasm
new file mode 100755
index 0000000..1b1e41d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wast
new file mode 100644
index 0000000..82dc9d5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_close.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_close.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "Successfully closed file!\nSuccessfully closed stderr!\nSuccessfully closed stdin!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wasm
new file mode 100755
index 0000000..cb8ceaf
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wast
new file mode 100644
index 0000000..d320f87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_pread.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_pread.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout " POLONIUS\n\n    He will come straight. Look you lay home to him:\n\n POLONIUS\n\n    He will come straight. Look you lay home to him:\n\nRead the same data? true\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wasm
new file mode 100755
index 0000000..c4be2f4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wast
new file mode 100644
index 0000000..70f4acf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_read.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_read.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE IV. The Queen\'s closet.\n\n    Enter QUEEN GERTRUDE and POLO\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wasm
new file mode 100755
index 0000000..90b811e
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wast
new file mode 100644
index 0000000..ad592f9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fd_sync.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fd_sync.wasm"
+  (temp_dirs ".")
+  (assert_return (i64.const 0))
+  (assert_stdout "170\n1404\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wasm
new file mode 100755
index 0000000..d817d19
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wast
new file mode 100644
index 0000000..7761ef1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/file_metadata.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "file_metadata.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "is dir: false\nfiletype: false true false\nfile info: 8866\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wasm
new file mode 100755
index 0000000..cb8d4b0
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wast
new file mode 100644
index 0000000..4574470
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fs_sandbox_test.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fs_sandbox_test.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Reading the parent directory was okay? false\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wasm
new file mode 100755
index 0000000..3768266
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wast
new file mode 100644
index 0000000..fb4c1b1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/fseek.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "fseek.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE III. A room in Polonius\' h\nouse.\n\n    Enter LAERTES and OPH\n    And, sister, as the winds gi\nr talk with the Lord Hamlet.\n   \nuits,\n    Breathing like sanctif\nis is for all:\n    I would not, \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wasm
new file mode 100755
index 0000000..ca8a2ff
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wast
new file mode 100644
index 0000000..55885a8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/hello.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "hello.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "Hello, world!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wasm
new file mode 100755
index 0000000..13eb63f
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wast
new file mode 100644
index 0000000..c33255a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/isatty.wast
@@ -0,0 +1,6 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "isatty.wasm"
+  (assert_return (i64.const 0))
+  (assert_stdout "stdin: 1\nstdout: 1\nstderr: 1\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wasm
new file mode 100755
index 0000000..fb5ddec
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wast
new file mode 100644
index 0000000..4808a8e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir.wasm"
+  (map_dirs ".:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"./README.md\"\n\"./act1\"\n\"./act2\"\n\"./act3\"\n\"./act4\"\n\"./act5\"\n\"./bookmarks\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wasm
new file mode 100644
index 0000000..eacc71d
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wast
new file mode 100644
index 0000000..945e660
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/mapdir_with_leading_slash.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "mapdir_with_leading_slash.wasm"
+  (map_dirs "/hamlet:test_fs/hamlet")
+  (assert_return (i64.const 0))
+  (assert_stdout "File exists? true\nSCENE III. A room in the castle.\n\n    Enter KING CLAUDIUS, ROSENCRANTZ, and GUILDENSTERN \n\nKING CLAUDIUS\n\n    I like him not, nor stands it safe with us\n    To let his madness range. Therefore prepare you;\n    I your commission will forthwith dispatch,\n   \n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wasm
new file mode 100755
index 0000000..6b1bdd3
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wast
new file mode 100644
index 0000000..6beca4e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_link.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_link.wasm"
+  (map_dirs "act5:test_fs/hamlet/act5")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "ACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nACT V\nSCENE I. A churchyard.\n\n    Enter two Clowns, with spades,\nPath still exists\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wasm
new file mode 100755
index 0000000..836bc42
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wast
new file mode 100644
index 0000000..10e6178
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_rename.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_rename.wasm"
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "The original file does not still exist!\nFound item: path_renamed_file.txt\n柴犬\nrun_with_sub_dir: The original file does not still exist!\nrun_with_different_sub_dirs: The original file does not still exist!\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wasm
new file mode 100755
index 0000000..ac2ca09
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wast
new file mode 100644
index 0000000..b80fb88
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/path_symlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "path_symlink.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "ACT III\nSCENE I. A room in the castle.\n\n    Enter KING CLAUDIUS,\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm
new file mode 100755
index 0000000..ba13ab7
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wast
new file mode 100644
index 0000000..efaa1ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/pipe_reverse.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "pipe_reverse.wasm"
+  (assert_return (i64.const 0))
+  (stdin "Hello, world!")
+  (assert_stdout "!dlrow ,olleH\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wasm
new file mode 100755
index 0000000..5ee474c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wast
new file mode 100644
index 0000000..ebac877
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/poll_oneoff.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "poll_oneoff.wasm"
+  (map_dirs "hamlet:test_fs/hamlet")
+  (temp_dirs "temp")
+  (assert_return (i64.const 0))
+  (assert_stdout "__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }\n[__wasi_event_t { userdata: 1193046, error: 0, type_: 1, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 2259, flags: 0 } } }, __wasi_event_t { userdata: 1193046, error: 0, type_: 2, u: __wasi_event_u { __wasi_event_fd_readwrite_t { nbytes: 1234, flags: 0 } } }]\nStdin: OK\nStdout: OK\nStderr: OK\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wasm
new file mode 100755
index 0000000..19dc2ee
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wast
new file mode 100644
index 0000000..26d4c41
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/quine.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "quine.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "SCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELIUS, Lords, and Attendants \n\nKING CLAUDIUS\n\n    Though yet of Hamlet our dear brother\'s death\n    The memory be green, and that it us befitted\n    To bear our hearts in grief and our whole kingdom\n    To be contracted in one brow of woe,\n    Yet so far hath discretion fought with nature\n    That we with wisest sorrow think on him,\n    Together with remembrance of ourselves.\n    Therefore our sometime sister, now our queen,\n    The imperial jointress to this warlike state,\n    Have we, as \'twere with a defeated joy,--\n    With an auspicious and a dropping eye,\n    With mirth in funeral and with dirge in marriage,\n    In equal scale weighing delight and dole,--\n    Taken to wife: nor have we herein barr\'d\n    Your better wisdoms, which have freely gone\n    With this affair along. For all, our thanks.\n    Now follows, that you know, young Fortinbras,\n    Holding a weak supposal of our worth,\n    Or thinking by our late dear brother\'s death\n    Our state to be disjoint and out of frame,\n    Colleagued with the dream of his advantage,\n    He hath not fail\'d to pester us with message,\n    Importing the surrender of those lands\n    Lost by his father, with all bonds of law,\n    To our most valiant brother. So much for him.\n    Now for ourself and for this time of meeting:\n    Thus much the business is: we have here writ\n    To Norway, uncle of young Fortinbras,--\n    Who, impotent and bed-rid, scarcely hears\n    Of this his nephew\'s purpose,--to suppress\n    His further gait herein; in that the levies,\n    The lists and full proportions, are all made\n    Out of his subject: and we here dispatch\n    You, good Cornelius, and you, Voltimand,\n    For bearers of this greeting to old Norway;\n    Giving to you no further personal power\n    To business with the king, more than the scope\n    Of these delated articles allow.\n    Farewell, and let your haste commend your duty.\n\nCORNELIUS VOLTIMAND\n\n    In that and all things will we show our duty.\n\nKING CLAUDIUS\n\n    We doubt it nothing: heartily farewell.\n\n    Exeunt VOLTIMAND and CORNELIUS\n    And now, Laertes, what\'s the news with you?\n    You told us of some suit; what is\'t, Laertes?\n    You cannot speak of reason to the Dane,\n    And loose your voice: what wouldst thou beg, Laertes,\n    That shall not be my offer, not thy asking?\n    The head is not more native to the heart,\n    The hand more instrumental to the mouth,\n    Than is the throne of Denmark to thy father.\n    What wouldst thou have, Laertes?\n\nLAERTES\n\n    My dread lord,\n    Your leave and favour to return to France;\n    From whence though willingly I came to Denmark,\n    To show my duty in your coronation,\n    Yet now, I must confess, that duty done,\n    My thoughts and wishes bend again toward France\n    And bow them to your gracious leave and pardon.\n\nKING CLAUDIUS\n\n    Have you your father\'s leave? What says Polonius?\n\nLORD POLONIUS\n\n    He hath, my lord, wrung from me my slow leave\n    By laboursome petition, and at last\n    Upon his will I seal\'d my hard consent:\n    I do beseech you, give him leave to go.\n\nKING CLAUDIUS\n\n    Take thy fair hour, Laertes; time be thine,\n    And thy best graces spend it at thy will!\n    But now, my cousin Hamlet, and my son,--\n\nHAMLET\n\n    [Aside] A little more than kin, and less than kind.\n\nKING CLAUDIUS\n\n    How is it that the clouds still hang on you?\n\nHAMLET\n\n    Not so, my lord; I am too much i\' the sun.\n\nQUEEN GERTRUDE\n\n    Good Hamlet, cast thy nighted colour off,\n    And let thine eye look like a friend on Denmark.\n    Do not for ever with thy vailed lids\n    Seek for thy noble father in the dust:\n    Thou know\'st \'tis common; all that lives must die,\n    Passing through nature to eternity.\n\nHAMLET\n\n    Ay, madam, it is common.\n\nQUEEN GERTRUDE\n\n    If it be,\n    Why seems it so particular with thee?\n\nHAMLET\n\n    Seems, madam! nay it is; I know not \'seems.\'\n    \'Tis not alone my inky cloak, good mother,\n    Nor customary suits of solemn black,\n    Nor windy suspiration of forced breath,\n    No, nor the fruitful river in the eye,\n    Nor the dejected \'havior of the visage,\n    Together with all forms, moods, shapes of grief,\n    That can denote me truly: these indeed seem,\n    For they are actions that a man might play:\n    But I have that within which passeth show;\n    These but the trappings and the suits of woe.\n\nKING CLAUDIUS\n\n    \'Tis sweet and commendable in your nature, Hamlet,\n    To give these mourning duties to your father:\n    But, you must know, your father lost a father;\n    That father lost, lost his, and the survivor bound\n    In filial obligation for some term\n    To do obsequious sorrow: but to persever\n    In obstinate condolement is a course\n    Of impious stubbornness; \'tis unmanly grief;\n    It shows a will most incorrect to heaven,\n    A heart unfortified, a mind impatient,\n    An understanding simple and unschool\'d:\n    For what we know must be and is as common\n    As any the most vulgar thing to sense,\n    Why should we in our peevish opposition\n    Take it to heart? Fie! \'tis a fault to heaven,\n    A fault against the dead, a fault to nature,\n    To reason most absurd: whose common theme\n    Is death of fathers, and who still hath cried,\n    From the first corse till he that died to-day,\n    \'This must be so.\' We pray you, throw to earth\n    This unprevailing woe, and think of us\n    As of a father: for let the world take note,\n    You are the most immediate to our throne;\n    And with no less nobility of love\n    Than that which dearest father bears his son,\n    Do I impart toward you. For your intent\n    In going back to school in Wittenberg,\n    It is most retrograde to our desire:\n    And we beseech you, bend you to remain\n    Here, in the cheer and comfort of our eye,\n    Our chiefest courtier, cousin, and our son.\n\nQUEEN GERTRUDE\n\n    Let not thy mother lose her prayers, Hamlet:\n    I pray thee, stay with us; go not to Wittenberg.\n\nHAMLET\n\n    I shall in all my best obey you, madam.\n\nKING CLAUDIUS\n\n    Why, \'tis a loving and a fair reply:\n    Be as ourself in Denmark. Madam, come;\n    This gentle and unforced accord of Hamlet\n    Sits smiling to my heart: in grace whereof,\n    No jocund health that Denmark drinks to-day,\n    But the great cannon to the clouds shall tell,\n    And the king\'s rouse the heavens all bruit again,\n    Re-speaking earthly thunder. Come away.\n\n    Exeunt all but HAMLET\n\nHAMLET\n\n    O, that this too too solid flesh would melt\n    Thaw and resolve itself into a dew!\n    Or that the Everlasting had not fix\'d\n    His canon \'gainst self-slaughter! O God! God!\n    How weary, stale, flat and unprofitable,\n    Seem to me all the uses of this world!\n    Fie on\'t! ah fie! \'tis an unweeded garden,\n    That grows to seed; things rank and gross in nature\n    Possess it merely. That it should come to this!\n    But two months dead: nay, not so much, not two:\n    So excellent a king; that was, to this,\n    Hyperion to a satyr; so loving to my mother\n    That he might not beteem the winds of heaven\n    Visit her face too roughly. Heaven and earth!\n    Must I remember? why, she would hang on him,\n    As if increase of appetite had grown\n    By what it fed on: and yet, within a month--\n    Let me not think on\'t--Frailty, thy name is woman!--\n    A little month, or ere those shoes were old\n    With which she follow\'d my poor father\'s body,\n    Like Niobe, all tears:--why she, even she--\n    O, God! a beast, that wants discourse of reason,\n    Would have mourn\'d longer--married with my uncle,\n    My father\'s brother, but no more like my father\n    Than I to Hercules: within a month:\n    Ere yet the salt of most unrighteous tears\n    Had left the flushing in her galled eyes,\n    She married. O, most wicked speed, to post\n    With such dexterity to incestuous sheets!\n    It is not nor it cannot come to good:\n    But break, my heart; for I must hold my tongue.\n\n    Enter HORATIO, MARCELLUS, and BERNARDO\n\nHORATIO\n\n    Hail to your lordship!\n\nHAMLET\n\n    I am glad to see you well:\n    Horatio,--or I do forget myself.\n\nHORATIO\n\n    The same, my lord, and your poor servant ever.\n\nHAMLET\n\n    Sir, my good friend; I\'ll change that name with you:\n    And what make you from Wittenberg, Horatio? Marcellus?\n\nMARCELLUS\n\n    My good lord--\n\nHAMLET\n\n    I am very glad to see you. Good even, sir.\n    But what, in faith, make you from Wittenberg?\n\nHORATIO\n\n    A truant disposition, good my lord.\n\nHAMLET\n\n    I would not hear your enemy say so,\n    Nor shall you do mine ear that violence,\n    To make it truster of your own report\n    Against yourself: I know you are no truant.\n    But what is your affair in Elsinore?\n    We\'ll teach you to drink deep ere you depart.\n\nHORATIO\n\n    My lord, I came to see your father\'s funeral.\n\nHAMLET\n\n    I pray thee, do not mock me, fellow-student;\n    I think it was to see my mother\'s wedding.\n\nHORATIO\n\n    Indeed, my lord, it follow\'d hard upon.\n\nHAMLET\n\n    Thrift, thrift, Horatio! the funeral baked meats\n    Did coldly furnish forth the marriage tables.\n    Would I had met my dearest foe in heaven\n    Or ever I had seen that day, Horatio!\n    My father!--methinks I see my father.\n\nHORATIO\n\n    Where, my lord?\n\nHAMLET\n\n    In my mind\'s eye, Horatio.\n\nHORATIO\n\n    I saw him once; he was a goodly king.\n\nHAMLET\n\n    He was a man, take him for all in all,\n    I shall not look upon his like again.\n\nHORATIO\n\n    My lord, I think I saw him yesternight.\n\nHAMLET\n\n    Saw? who?\n\nHORATIO\n\n    My lord, the king your father.\n\nHAMLET\n\n    The king my father!\n\nHORATIO\n\n    Season your admiration for awhile\n    With an attent ear, till I may deliver,\n    Upon the witness of these gentlemen,\n    This marvel to you.\n\nHAMLET\n\n    For God\'s love, let me hear.\n\nHORATIO\n\n    Two nights together had these gentlemen,\n    Marcellus and Bernardo, on their watch,\n    In the dead vast and middle of the night,\n    Been thus encounter\'d. A figure like your father,\n    Armed at point exactly, cap-a-pe,\n    Appears before them, and with solemn march\n    Goes slow and stately by them: thrice he walk\'d\n    By their oppress\'d and fear-surprised eyes,\n    Within his truncheon\'s length; whilst they, distilled\n    Almost to jelly with the act of fear,\n    Stand dumb and speak not to him. This to me\n    In dreadful secrecy impart they did;\n    And I with them the third night kept the watch;\n    Where, as they had deliver\'d, both in time,\n    Form of the thing, each word made true and good,\n    The apparition comes: I knew your father;\n    These hands are not more like.\n\nHAMLET\n\n    But where was this?\n\nMARCELLUS\n\n    My lord, upon the platform where we watch\'d.\n\nHAMLET\n\n    Did you not speak to it?\n\nHORATIO\n\n    My lord, I did;\n    But answer made it none: yet once methought\n    It lifted up its head and did address\n    Itself to motion, like as it would speak;\n    But even then the morning cock crew loud,\n    And at the sound it shrunk in haste away,\n    And vanish\'d from our sight.\n\nHAMLET\n\n    \'Tis very strange.\n\nHORATIO\n\n    As I do live, my honour\'d lord, \'tis true;\n    And we did think it writ down in our duty\n    To let you know of it.\n\nHAMLET\n\n    Indeed, indeed, sirs, but this troubles me.\n    Hold you the watch to-night?\n\nMARCELLUS BERNARDO\n\n    We do, my lord.\n\nHAMLET\n\n    Arm\'d, say you?\n\nMARCELLUS BERNARDO\n\n    Arm\'d, my lord.\n\nHAMLET\n\n    From top to toe?\n\nMARCELLUS BERNARDO\n\n    My lord, from head to foot.\n\nHAMLET\n\n    Then saw you not his face?\n\nHORATIO\n\n    O, yes, my lord; he wore his beaver up.\n\nHAMLET\n\n    What, look\'d he frowningly?\n\nHORATIO\n\n    A countenance more in sorrow than in anger.\n\nHAMLET\n\n    Pale or red?\n\nHORATIO\n\n    Nay, very pale.\n\nHAMLET\n\n    And fix\'d his eyes upon you?\n\nHORATIO\n\n    Most constantly.\n\nHAMLET\n\n    I would I had been there.\n\nHORATIO\n\n    It would have much amazed you.\n\nHAMLET\n\n    Very like, very like. Stay\'d it long?\n\nHORATIO\n\n    While one with moderate haste might tell a hundred.\n\nMARCELLUS BERNARDO\n\n    Longer, longer.\n\nHORATIO\n\n    Not when I saw\'t.\n\nHAMLET\n\n    His beard was grizzled--no?\n\nHORATIO\n\n    It was, as I have seen it in his life,\n    A sable silver\'d.\n\nHAMLET\n\n    I will watch to-night;\n    Perchance \'twill walk again.\n\nHORATIO\n\n    I warrant it will.\n\nHAMLET\n\n    If it assume my noble father\'s person,\n    I\'ll speak to it, though hell itself should gape\n    And bid me hold my peace. I pray you all,\n    If you have hitherto conceal\'d this sight,\n    Let it be tenable in your silence still;\n    And whatsoever else shall hap to-night,\n    Give it an understanding, but no tongue:\n    I will requite your loves. So, fare you well:\n    Upon the platform, \'twixt eleven and twelve,\n    I\'ll visit you.\n\nAll\n\n    Our duty to your honour.\n\nHAMLET\n\n    Your loves, as mine to you: farewell.\n\n    Exeunt all but HAMLET\n    My father\'s spirit in arms! all is not well;\n    I doubt some foul play: would the night were come!\n    Till then sit still, my soul: foul deeds will rise,\n    Though all the earth o\'erwhelm them, to men\'s eyes.\n\n    Exit\n\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wasm
new file mode 100755
index 0000000..0e4b3f5
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wast
new file mode 100644
index 0000000..02b642d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/readlink.wast
@@ -0,0 +1,8 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "readlink.wasm"
+  (preopens "test_fs")
+  (assert_return (i64.const 0))
+  (assert_stdout "true\n../act1/scene2.txt\nSCENE II. A room of state in the castle.\n\n    Enter KING CLAUDIUS, QUEEN GERTRUDE, HAMLET, POLONIUS, LAERTES, VOLTIMAND, CORNELI\n")
+  (assert_stderr "[/Users/mark/wasi-tests/wasi/tests/readlink.rs:10] &p = \"test_fs/hamlet/bookmarks/2019-07-16\"\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wasm
new file mode 100755
index 0000000..7b48910
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wast
new file mode 100644
index 0000000..7da0c83
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/unix_open_special_files.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "unix_open_special_files.wasm"
+  (map_dirs "/dev:/dev")
+  (assert_return (i64.const 0))
+  (assert_stdout "13\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wasm
new file mode 100755
index 0000000..59fc97c
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wast
new file mode 100644
index 0000000..c60fa5f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/wasi_sees_virtual_root.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "wasi_sees_virtual_root.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\n\"/act1\"\n\"/act1-again\"\n\"/act2\"\nROOT IS SAFE\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wasm b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wasm
new file mode 100755
index 0000000..bbdf39f
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wasm differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wast b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wast
new file mode 100644
index 0000000..3835a25
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasi-wast/wasi/unstable/writing.wast
@@ -0,0 +1,7 @@
+;; This file was generated by https://github.com/wasmerio/wasi-tests
+
+(wasi_test "writing.wasm"
+  (map_dirs "act1:test_fs/hamlet/act1" "act2:test_fs/hamlet/act2" "act1-again:test_fs/hamlet/act1")
+  (assert_return (i64.const 0))
+  (assert_stdout "abcdefghijklmnopqrstuvwxyz\nfile is gone\n")
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/Cargo.toml b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/Cargo.toml
new file mode 100644
index 0000000..2946a6b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/Cargo.toml
@@ -0,0 +1,47 @@
+[package]
+name = "wasmer-argus"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+wasmer_lib = ["dep:wasmer"]
+
+[dependencies]
+indicatif = "0.17.8"
+anyhow = "1.0.80"
+log = "0.4.21"
+cynic = "3.4.3"
+url = "2.5.0"
+futures = "0.3.30"
+tracing = "0.1.40"
+tokio = { version = "1.36.0", features = ["rt-multi-thread", "sync", "time", "fs"] }
+clap = {version = "4.4.11", features = ["derive", "string"]}
+tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+wasmer = { version = "4.2.6", path = "../../lib/api", features = ["engine", "core", "singlepass", "cranelift", "llvm"], optional = true }
+derive_more = "0.99.17"
+webc.workspace = true
+async-trait = "0.1.77"
+wasmer-api = { path = "../../lib/backend-api" }
+
+
+[target.'cfg(not(target_arch = "riscv64"))'.dependencies]
+reqwest = { version = "^0.11", default-features = false, features = [
+  "rustls-tls",
+  "json",
+  "multipart",
+  "gzip",
+] }
+
+[target.'cfg(target_arch = "riscv64")'.dependencies]
+reqwest = { version = "^0.11", default-features = false, features = [
+  "native-tls",
+  "json",
+  "multipart",
+] }
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/README.md b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/README.md
new file mode 100644
index 0000000..f319986
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/README.md
@@ -0,0 +1,55 @@
+# wasmer-argus
+
+Automatically test packages from the registry. 
+
+## Building
+If you want to use the local `wasmer` crate, you shall 
+build the project with `cargo build --package wasmer-argus --features wasmer_lib`.
+
+On macOS, you may encounter an error where the linker does not find `zstd`: a possible 
+solution to this problem is to install `zstd` using `brew` (`brew install zstd`) and 
+using the following command: 
+
+`RUSTFLAGS="-L$(brew --prefix)/lib" cargo build --package wasmer-argus --features wasmer_lib`
+
+Another possiblity is to add the your brew prefix with `/lib` (probably = `/opt/homebrew/lib/`) 
+to the global Cargo config something like:
+```
+[target.aarch64-apple-darwin]
+rustflags = ["-L/opt/homebrew/lib"]
+```
+
+## Usage
+This binary fetches packages from the graphql endpoint  of a registry. By
+default, it uses `http://registry.wasmer.io/graphql`; and the needed
+authorization token is retrieved from the environment using the `WASMER_TOKEN`. 
+Users can specify the token via CLI with the appropriate flag.
+
+This testsuite is parallelised, and the degree of parallelism available can be
+specified both by CLI flag or automatically using
+`std::thread::available_parallelism`.
+
+```
+Fetch and test packages from a WebContainer registry
+
+Usage: wasmer-argus [OPTIONS]
+
+Options:
+  -r, --registry-url <REGISTRY_URL>  
+        The GraphQL endpoint of the registry to test [default: http://registry.wasmer.io/graphql]
+  -b, --backend <COMPILER_BACKEND>   
+        The backend to test the compilation against [default: singlepass] [possible values: llvm, singlepass, cranelift]
+      --run                          
+        Whether or not to run packages during tests
+  -o, --outdir <OUTDIR>              
+        The output directory [default: /home/ecmm/sw/wasmer/wasmer/target/debug/out]
+      --auth-token <AUTH_TOKEN>      
+        The authorization token needed to see packages [default: <env::WASMER_TOKEN>]
+      --jobs <JOBS>                  
+        The number of concurrent tests (jobs) to perform [default: 12]
+  -h, --help                         Print help
+  -V, --version                      Print version
+```
+
+
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/config.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/config.rs
new file mode 100644
index 0000000..5a325f0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/config.rs
@@ -0,0 +1,64 @@
+use clap::ValueEnum;
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+fn get_default_out_path() -> PathBuf {
+    let mut path = std::env::current_dir().unwrap();
+    path.push("out");
+    path
+}
+
+fn get_default_token() -> String {
+    std::env::var("WASMER_TOKEN").unwrap_or_default()
+}
+
+fn get_default_jobs() -> usize {
+    std::thread::available_parallelism()
+        .unwrap_or(std::num::NonZeroUsize::new(2).unwrap())
+        .into()
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, ValueEnum, derive_more::Display)]
+pub enum Backend {
+    Llvm,
+    Singlepass,
+    Cranelift,
+}
+
+/// Fetch and test packages from a WebContainer registry.
+#[derive(Debug, clap::Parser, Clone, Serialize, Deserialize)]
+#[command(version, about, long_about = None)]
+pub struct ArgusConfig {
+    /// The GraphQL endpoint of the registry to test
+    #[arg(
+        short,
+        long,
+        default_value_t = String::from("http://registry.wasmer.io/graphql")
+    )]
+    pub registry_url: String,
+
+    /// The backend to test the compilation against
+    #[arg(short = 'b', long = "backend", value_enum, default_value_t = Backend::Singlepass)]
+    pub compiler_backend: Backend,
+
+    /// The output directory
+    #[arg(short = 'o', long, default_value = get_default_out_path().into_os_string())]
+    pub outdir: std::path::PathBuf,
+
+    /// The authorization token needed to see packages
+    #[arg(long, default_value_t = get_default_token())]
+    pub auth_token: String,
+
+    /// The number of concurrent tests (jobs) to perform
+    #[arg(long, default_value_t = get_default_jobs()) ]
+    pub jobs: usize,
+
+    /// The path to the CLI command to use. [default will be searched in $PATH: "wasmer"]
+    #[arg(long)]
+    pub cli_path: Option<String>,
+
+    /// Whether or not this run should use the linked [`wasmer-api`] library instead of the CLI.
+    #[cfg(feature = "wasmer_lib")]
+    #[arg(long, conflicts_with = "cli_path")]
+    pub use_lib: bool,
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/mod.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/mod.rs
new file mode 100644
index 0000000..073dc46
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/mod.rs
@@ -0,0 +1,202 @@
+mod config;
+mod packages;
+mod tester;
+
+use self::tester::{TestReport, Tester};
+pub use config::*;
+use indicatif::{MultiProgress, ProgressBar};
+use std::{fs::OpenOptions, io::Write as _, path::Path, sync::Arc, time::Duration};
+use tokio::{
+    sync::{mpsc, Semaphore},
+    task::JoinSet,
+};
+use tracing::*;
+use url::Url;
+use wasmer_api::{types::PackageVersionWithPackage, WasmerClient};
+
+#[derive(Debug, Clone)]
+pub struct Argus {
+    pub config: ArgusConfig,
+    pub client: WasmerClient,
+}
+
+impl TryFrom<ArgusConfig> for Argus {
+    type Error = anyhow::Error;
+
+    fn try_from(config: ArgusConfig) -> Result<Self, Self::Error> {
+        let client = WasmerClient::new(Url::parse(&config.registry_url)?, "wasmer-argus")?;
+
+        let client = client.with_auth_token(config.auth_token.clone());
+        Ok(Argus { client, config })
+    }
+}
+
+impl Argus {
+    /// Start the testsuite using the configuration in [`Self::config`]
+    pub async fn run(self) -> anyhow::Result<()> {
+        info!("fetching packages from {}", self.config.registry_url);
+
+        let m = MultiProgress::new();
+        let (s, mut r) = mpsc::unbounded_channel();
+
+        let mut pool = JoinSet::new();
+        let c = Arc::new(self.config.clone());
+
+        {
+            let this = self.clone();
+            let bar = m.add(ProgressBar::new(0));
+
+            pool.spawn(async move { this.fetch_packages(s, bar, c.clone()).await });
+        }
+
+        let mut count = 0;
+
+        let c = Arc::new(self.config.clone());
+        let sem = Arc::new(Semaphore::new(self.config.jobs));
+
+        while let Some(pkg) = r.recv().await {
+            let c = c.clone();
+            let bar = m.add(ProgressBar::new(0));
+            let permit = Arc::clone(&sem).acquire_owned().await;
+
+            pool.spawn(async move {
+                let _permit = permit;
+                Argus::test(count, c, &pkg, bar).await
+            });
+
+            count += 1;
+        }
+
+        while let Some(t) = pool.join_next().await {
+            if let Err(e) = t {
+                error!("task failed: {e}")
+            }
+        }
+
+        info!("done!");
+        Ok(())
+    }
+
+    /// Perform the test for a single package
+    async fn test(
+        test_id: u64,
+        config: Arc<ArgusConfig>,
+        package: &PackageVersionWithPackage,
+        p: ProgressBar,
+    ) -> anyhow::Result<()> {
+        p.set_style(
+            indicatif::ProgressStyle::with_template(&format!(
+                "[{test_id}] {{spinner:.blue}} {{msg}}"
+            ))
+            .unwrap()
+            .tick_strings(&["✶", "✸", "✹", "✺", "✹", "✷"]),
+        );
+
+        p.enable_steady_tick(Duration::from_millis(100));
+
+        let package_name = Argus::get_package_id(package);
+        let webc_url: Url = match &package.distribution.pirita_download_url {
+            Some(url) => url.parse().unwrap(),
+            None => {
+                info!("package {} has no download url, skipping", package_name);
+                p.finish_and_clear();
+                return Ok(());
+            }
+        };
+
+        p.set_message(format!("[{test_id}] testing package {package_name}",));
+
+        let path = Argus::get_path(config.clone(), package).await;
+        p.set_message(format!(
+            "testing package {package_name} -- path to download to is: {:?}",
+            path
+        ));
+
+        #[cfg(not(feature = "wasmer_lib"))]
+        let runner = Box::new(tester::cli_tester::CLIRunner::new(
+            test_id, config, &p, package,
+        )) as Box<dyn Tester>;
+
+        #[cfg(feature = "wasmer_lib")]
+        let runner = if config.use_lib {
+            Box::new(tester::lib_tester::LibRunner::new(
+                test_id, config, &p, package,
+            )) as Box<dyn Tester>
+        } else {
+            Box::new(tester::cli_tester::CLIRunner::new(
+                test_id, config, &p, package,
+            )) as Box<dyn Tester>
+        };
+
+        if !runner.is_to_test().await {
+            return Ok(());
+        }
+
+        Argus::download_package(test_id, &path, &webc_url, &p).await?;
+
+        info!("package downloaded!");
+
+        p.reset();
+        p.set_style(
+            indicatif::ProgressStyle::with_template(&format!(
+                "[{test_id}/{package_name}] {{spinner:.blue}} {{msg}}"
+            ))
+            .unwrap()
+            .tick_strings(&["✶", "✸", "✹", "✺", "✹", "✷"]),
+        );
+
+        p.enable_steady_tick(Duration::from_millis(100));
+
+        p.set_message("package downloaded");
+
+        let report = runner.run_test().await?;
+        info!("\n\n\n\ntest finished\n\n\n");
+
+        Argus::write_report(&path, report).await?;
+
+        p.finish_with_message(format!("test for package {package_name} done!"));
+        p.finish_and_clear();
+
+        Ok(())
+    }
+
+    /// Checks whether or not the package should be tested
+    async fn to_test(&self, pkg: &PackageVersionWithPackage) -> bool {
+        let name = Argus::get_package_id(pkg);
+
+        info!("checking if package {name} needs to be tested or not");
+
+        let dir_path = std::path::PathBuf::from(&self.config.outdir);
+
+        if !dir_path.exists() {
+            return true;
+        }
+
+        if pkg.distribution.pirita_sha256_hash.is_none() {
+            info!("skipping test for {name} as it has no hash");
+            return false;
+        }
+
+        true
+    }
+
+    #[tracing::instrument]
+    async fn write_report(path: &Path, result: TestReport) -> anyhow::Result<()> {
+        let test_results_path = path.join(format!(
+            "result-{}-{}--{}-{}.json",
+            result.runner_id,
+            result.runner_version,
+            std::env::consts::ARCH,
+            std::env::consts::OS,
+        ));
+
+        let mut file = OpenOptions::new()
+            .write(true)
+            .create(true)
+            .truncate(true)
+            .open(test_results_path)?;
+
+        file.write_all(serde_json::to_string(&result).unwrap().as_bytes())?;
+        Ok(())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/packages.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/packages.rs
new file mode 100644
index 0000000..5768e7a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/packages.rs
@@ -0,0 +1,218 @@
+use super::Argus;
+use crate::ArgusConfig;
+use futures::StreamExt;
+use indicatif::{ProgressBar, ProgressStyle};
+use reqwest::{header, Client};
+use std::{path::PathBuf, sync::Arc, time::Duration};
+use tokio::{fs::File, io::AsyncWriteExt, sync::mpsc::UnboundedSender};
+use tracing::*;
+use url::Url;
+use wasmer_api::{
+    query::get_package_versions_stream,
+    types::{AllPackageVersionsVars, PackageVersionSortBy, PackageVersionWithPackage},
+};
+
+impl Argus {
+    /// Fetch all packages from the registry
+    #[tracing::instrument(skip(self, s, p))]
+    pub async fn fetch_packages(
+        &self,
+        s: UnboundedSender<PackageVersionWithPackage>,
+        p: ProgressBar,
+        config: Arc<ArgusConfig>,
+    ) -> anyhow::Result<()> {
+        info!("starting to fetch packages..");
+        let vars = AllPackageVersionsVars {
+            sort_by: Some(PackageVersionSortBy::Oldest),
+            ..Default::default()
+        };
+
+        p.set_style(
+            ProgressStyle::with_template("{spinner:.blue} {msg}")
+                .unwrap()
+                .tick_strings(&["✶", "✸", "✹", "✺", "✹", "✷"]),
+        );
+        p.enable_steady_tick(Duration::from_millis(1000));
+
+        let mut count = 0;
+
+        let call = get_package_versions_stream(&self.client, vars.clone());
+        futures::pin_mut!(call);
+        p.set_message("starting to fetch packages..".to_string());
+
+        while let Some(pkgs) = call.next().await {
+            let pkgs = match pkgs {
+                Ok(pkgs) => pkgs,
+                Err(e) => {
+                    error!("failed to fetch packages: {e}");
+                    p.finish_and_clear();
+                    anyhow::bail!("failed to fetch packages: {e}")
+                }
+            };
+            p.set_message(format!("fetched {} packages", count));
+            count += pkgs.len();
+
+            for pkg in pkgs {
+                if self.to_test(&pkg).await {
+                    if let Err(e) = s.send(pkg) {
+                        error!("failed to send packages: {e}");
+                        p.finish_and_clear();
+                        anyhow::bail!("failed to send packages: {e}")
+                    };
+                }
+            }
+        }
+
+        p.finish_with_message(format!("fetched {count} packages"));
+        info!("finished fetching packages: fetched {count} packages, closing channel");
+        drop(s);
+        Ok(())
+    }
+
+    #[tracing::instrument(skip(p))]
+    pub(crate) async fn download_package<'a>(
+        test_id: u64,
+        path: &'a PathBuf,
+        url: &'a Url,
+        p: &'a ProgressBar,
+    ) -> anyhow::Result<()> {
+        info!("downloading package from {} to file {:?}", url, path);
+        static APP_USER_AGENT: &str =
+            concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
+
+        if !path.exists() {
+            tokio::fs::create_dir_all(path).await?;
+        } else if path.exists() && !path.is_dir() {
+            anyhow::bail!("path {:?} exists, but it is not a directory!", path)
+        }
+
+        let client = Client::builder().user_agent(APP_USER_AGENT).build()?;
+
+        let download_size = {
+            let resp = client.head(url.as_str()).send().await?;
+            if resp.status().is_success() {
+                resp.headers()
+                    .get(header::CONTENT_LENGTH)
+                    .and_then(|ct_len| ct_len.to_str().ok())
+                    .and_then(|ct_len| ct_len.parse().ok())
+                    .unwrap_or(0) // Fallback to 0
+            } else {
+                anyhow::bail!(
+                    "Couldn't fetch head from URL {}. Error: {:?}",
+                    url,
+                    resp.status()
+                )
+            }
+        };
+
+        let request = client.get(url.as_str());
+
+        p.set_length(download_size);
+
+        p.set_style(
+            ProgressStyle::default_bar()
+                .template(&format!(
+                    "[{test_id}] [{{bar:40.cyan/blue}}] {{bytes}}/{{total_bytes}} - {{msg}}"
+                ))
+                .unwrap()
+                .progress_chars("#>-"),
+        );
+
+        p.set_message(format!("downloading from {url}"));
+
+        let mut outfile = match File::create(&path.join("package.webc")).await {
+            Ok(o) => o,
+            Err(e) => {
+                error!(
+                    "[{test_id}] failed to create file at {:?}. Error: {e}",
+                    path.join("package.webc")
+                );
+
+                p.finish_and_clear();
+
+                anyhow::bail!(
+                    "[{test_id}] failed to create file at {:?}. Error: {e}",
+                    path.join("package.webc")
+                );
+            }
+        };
+        let mut download = match request.send().await {
+            Ok(d) => d,
+            Err(e) => {
+                error!("[{test_id}] failed to download from URL {url}. Error: {e}");
+                p.finish_and_clear();
+                anyhow::bail!("[{test_id}] failed to download from URL {url}. Error: {e}");
+            }
+        };
+
+        loop {
+            match download.chunk().await {
+                Err(e) => {
+                    error!(
+                        "[{test_id}] failed to download chunk from {:?}. Error: {e}",
+                        download
+                    );
+                    p.finish_and_clear();
+                    anyhow::bail!(
+                        "[{test_id}] failed to download chunk from {:?}. Error: {e}",
+                        download
+                    );
+                }
+                Ok(chunk) => {
+                    if let Some(chunk) = chunk {
+                        p.inc(chunk.len() as u64);
+                        if let Err(e) = outfile.write(&chunk).await {
+                            error!(
+                                "[{test_id}] failed to write chunk to file {:?}. Error: {e}",
+                                outfile
+                            );
+                            p.finish_and_clear();
+                            anyhow::bail!(
+                                "[{test_id}] failed to write chunk to file {:?}. Error: {e}",
+                                outfile
+                            );
+                        };
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+
+        outfile.flush().await?;
+        drop(outfile);
+
+        Ok(())
+    }
+
+    /// Return the complete path to the folder of the test for the package, from the outdir to the
+    /// hash
+    pub async fn get_path(config: Arc<ArgusConfig>, pkg: &PackageVersionWithPackage) -> PathBuf {
+        let hash = match &pkg.distribution.pirita_sha256_hash {
+            Some(hash) => hash,
+            None => {
+                unreachable!("no package without an hash should reach this function!")
+            }
+        };
+
+        let _namespace = match &pkg.package.namespace {
+            Some(ns) => ns.replace('/', "_"),
+            None => "unknown_namespace".to_owned(),
+        };
+
+        config.outdir.join(hash)
+    }
+
+    pub fn get_package_id(pkg: &PackageVersionWithPackage) -> String {
+        let namespace = match &pkg.package.namespace {
+            Some(namespace) => namespace.replace('/', "_"),
+            None => String::from("unknown_namespace"),
+        };
+        format!(
+            "{}/{}_v{}",
+            namespace,
+            pkg.package.package_name.replace('/', "_"),
+            pkg.version
+        )
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/cli_tester.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/cli_tester.rs
new file mode 100644
index 0000000..8cbfa76
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/cli_tester.rs
@@ -0,0 +1,238 @@
+use crate::argus::{Argus, ArgusConfig, Backend};
+use indicatif::ProgressBar;
+use std::{fs::File, io::BufReader, path::Path, process::Command, sync::Arc};
+use tokio::time::{self, Instant};
+use tracing::*;
+use wasmer_api::types::PackageVersionWithPackage;
+use webc::{
+    v1::{ParseOptions, WebCOwned},
+    v2::read::OwnedReader,
+    Container, Version,
+};
+
+use super::{TestReport, Tester};
+
+#[allow(unused)]
+pub struct CLIRunner<'a> {
+    test_id: u64,
+    config: Arc<ArgusConfig>,
+    p: &'a ProgressBar,
+    package: &'a PackageVersionWithPackage,
+}
+
+impl<'a> CLIRunner<'a> {
+    pub fn new(
+        test_id: u64,
+        config: Arc<ArgusConfig>,
+        p: &'a ProgressBar,
+        package: &'a PackageVersionWithPackage,
+    ) -> Self {
+        Self {
+            test_id,
+            config,
+            p,
+            package,
+        }
+    }
+
+    async fn test_atom(
+        &self,
+        cli_path: &String,
+        atom: &[u8],
+        dir_path: &Path,
+        atom_id: usize,
+    ) -> anyhow::Result<Result<(), String>> {
+        if let Err(e) = Command::new(cli_path).arg("-V").output() {
+            if let std::io::ErrorKind::NotFound = e.kind() {
+                anyhow::bail!("the command '{cli_path}' was not found");
+            }
+        }
+
+        let atom_path = dir_path.join(format!("atom_{atom_id}.wasm"));
+        let output_path = dir_path.join(format!("atom_{atom_id}.wasmu"));
+
+        tokio::fs::write(&atom_path, atom).await?;
+
+        let backend = match self.config.compiler_backend {
+            Backend::Llvm => "--llvm",
+            Backend::Singlepass => "--singlepass",
+            Backend::Cranelift => "--cranelift",
+        };
+
+        Ok(
+            match std::panic::catch_unwind(move || {
+                let mut cmd = Command::new(cli_path);
+
+                let cmd = cmd.args([
+                    "compile",
+                    atom_path.to_str().unwrap(),
+                    backend,
+                    "-o",
+                    output_path.to_str().unwrap(),
+                ]);
+
+                info!("running cmd: {:?}", cmd);
+
+                let out = cmd.output();
+
+                info!("run cmd that gave result: {:#?}", out);
+
+                out
+            }) {
+                Ok(r) => match r {
+                    Ok(_) => Ok(()),
+                    Err(e) => Err(e.to_string()),
+                },
+                Err(_) => Err(String::from("thread panicked")),
+            },
+        )
+    }
+
+    fn ok(&self, version: String, start_time: Instant) -> anyhow::Result<TestReport> {
+        Ok(TestReport::new(
+            self.package,
+            String::from("wasmer_cli"),
+            version,
+            self.config.compiler_backend.to_string(),
+            start_time - Instant::now(),
+            Ok(String::from("test passed")),
+        ))
+    }
+
+    fn err(
+        &self,
+        version: String,
+        start_time: Instant,
+        message: String,
+    ) -> anyhow::Result<TestReport> {
+        Ok(TestReport::new(
+            self.package,
+            String::from("wasmer_cli"),
+            version,
+            self.config.compiler_backend.to_string(),
+            start_time - Instant::now(),
+            Err(message),
+        ))
+    }
+
+    fn get_id(&self) -> String {
+        String::from("wasmer_cli")
+    }
+
+    async fn get_version(&self) -> anyhow::Result<String> {
+        let cli_path = match &self.config.cli_path {
+            Some(ref p) => p.clone(),
+            None => String::from("wasmer"),
+        };
+
+        let mut cmd = Command::new(&cli_path);
+        let cmd = cmd.arg("-V");
+
+        info!("running cmd: {:?}", cmd);
+
+        let out = cmd.output();
+
+        info!("run cmd that gave result: {:?}", out);
+
+        match out {
+            Ok(v) => Ok(String::from_utf8(v.stdout)
+                .unwrap()
+                .replace(' ', "")
+                .replace("wasmer", "")
+                .trim()
+                .to_string()),
+            Err(e) => anyhow::bail!("failed to launch cli program {cli_path}: {e}"),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl<'a> Tester for CLIRunner<'a> {
+    async fn run_test(&self) -> anyhow::Result<TestReport> {
+        let start_time = time::Instant::now();
+        let version = self.get_version().await?;
+        let cli_path = match &self.config.cli_path {
+            Some(ref p) => p.clone(),
+            None => String::from("wasmer"),
+        };
+
+        info!("starting test using CLI at {cli_path}");
+        let dir_path = Argus::get_path(self.config.clone(), self.package).await;
+        let webc_path = dir_path.join("package.webc");
+
+        self.p
+            .set_message(format!("unpacking webc at {:?}", webc_path));
+
+        let bytes = std::fs::read(&webc_path)?;
+
+        let webc = match webc::detect(bytes.as_slice()) {
+            Ok(Version::V1) => {
+                let options = ParseOptions::default();
+                let webc = WebCOwned::parse(bytes, &options)?;
+                Container::from(webc)
+            }
+            Ok(Version::V2) => Container::from(OwnedReader::parse(bytes)?),
+            Ok(other) => {
+                return self.err(version, start_time, format!("Unsupported version, {other}"))
+            }
+            Err(e) => return self.err(version, start_time, format!("An error occurred: {e}")),
+        };
+
+        for (i, atom) in webc.atoms().iter().enumerate() {
+            self.p.set_message(format!("testing atom #{i}"));
+            if let Err(e) = self
+                .test_atom(&cli_path, atom.1.as_slice(), &dir_path, i)
+                .await?
+            {
+                return self.err(version, start_time, e);
+            }
+        }
+
+        self.ok(version, start_time)
+    }
+
+    async fn is_to_test(&self) -> bool {
+        let pkg = self.package;
+        let version = match self.get_version().await {
+            Ok(version) => version,
+            Err(e) => {
+                error!("skipping test because of error while spawning wasmer CLI command: {e}");
+                return false;
+            }
+        };
+
+        let out_dir = Argus::get_path(self.config.clone(), self.package).await;
+        let test_results_path = out_dir.join(format!(
+            "result-{}-{}--{}-{}.json",
+            self.get_id(),
+            version,
+            std::env::consts::ARCH,
+            std::env::consts::OS,
+        ));
+
+        let file = match File::open(test_results_path) {
+            Ok(file) => file,
+            Err(e) => {
+                info!(
+                    "re-running test for pkg {:?} as previous-run file failed to open: {e}",
+                    pkg
+                );
+                return true;
+            }
+        };
+
+        let reader = BufReader::new(file);
+        let report: TestReport = match serde_json::from_reader(reader) {
+            Ok(p) => p,
+            Err(e) => {
+                info!(
+                    "re-running test for pkg {:?} as previous-run file failed to be deserialized: {e}",
+                    pkg
+                );
+                return true;
+            }
+        };
+
+        report.to_test(self.config.clone())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/lib_tester.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/lib_tester.rs
new file mode 100644
index 0000000..6adb5a2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/lib_tester.rs
@@ -0,0 +1,165 @@
+use super::{TestReport, Tester};
+use crate::argus::{Argus, ArgusConfig, Backend};
+use indicatif::ProgressBar;
+use std::{fs::File, io::BufReader, sync::Arc};
+use tokio::time;
+use tracing::*;
+use wasmer::{sys::Features, Engine, NativeEngineExt, Target};
+use wasmer_api::types::PackageVersionWithPackage;
+use webc::{
+    v1::{ParseOptions, WebCOwned},
+    v2::read::OwnedReader,
+    Container, Version,
+};
+
+pub struct LibRunner<'a> {
+    pub test_id: u64,
+    pub config: Arc<ArgusConfig>,
+    pub p: &'a ProgressBar,
+    pub package: &'a PackageVersionWithPackage,
+}
+
+impl<'a> LibRunner<'a> {
+    pub fn new(
+        test_id: u64,
+        config: Arc<ArgusConfig>,
+        p: &'a ProgressBar,
+        package: &'a PackageVersionWithPackage,
+    ) -> Self {
+        Self {
+            test_id,
+            config,
+            p,
+            package,
+        }
+    }
+
+    pub fn backend_to_engine(backend: &Backend) -> Engine {
+        match backend {
+            Backend::Llvm => Engine::new(
+                Box::new(wasmer::LLVM::new()),
+                Target::default(),
+                Features::default(),
+            ),
+            Backend::Singlepass => Engine::new(
+                Box::new(wasmer::Singlepass::new()),
+                Target::default(),
+                Features::default(),
+            ),
+            Backend::Cranelift => Engine::new(
+                Box::new(wasmer::Cranelift::new()),
+                Target::default(),
+                Features::default(),
+            ),
+        }
+    }
+
+    fn get_id(&self) -> String {
+        String::from("wasmer_lib")
+    }
+
+    fn get_version(&self) -> String {
+        env!("CARGO_PKG_VERSION").to_string()
+    }
+}
+
+#[async_trait::async_trait]
+impl<'a> Tester for LibRunner<'a> {
+    async fn run_test(&self) -> anyhow::Result<TestReport> {
+        let package_id = crate::Argus::get_package_id(self.package);
+
+        let start = time::Instant::now();
+        let dir_path = Argus::get_path(self.config.clone(), self.package).await;
+        let webc_path = dir_path.join("package.webc");
+
+        let test_exec_result = std::panic::catch_unwind(|| {
+            self.p.set_message("reading webc bytes from filesystem");
+            let bytes = std::fs::read(&webc_path)?;
+            let store = wasmer::Store::new(Self::backend_to_engine(&self.config.compiler_backend));
+
+            let webc = match webc::detect(bytes.as_slice()) {
+                Ok(Version::V1) => {
+                    let options = ParseOptions::default();
+                    let webc = WebCOwned::parse(bytes, &options)?;
+                    Container::from(webc)
+                }
+                Ok(Version::V2) => Container::from(OwnedReader::parse(bytes)?),
+                Ok(other) => anyhow::bail!("Unsupported version, {other}"),
+                Err(e) => anyhow::bail!("An error occurred: {e}"),
+            };
+
+            self.p.set_message("created webc");
+
+            for atom in webc.atoms().iter() {
+                info!(
+                    "creating module for atom {} with length {}",
+                    atom.0,
+                    atom.1.len()
+                );
+                self.p.set_message(format!(
+                    "[{package_id}] creating module for atom {} (has length {} bytes)",
+                    atom.0,
+                    atom.1.len()
+                ));
+                wasmer::Module::new(&store, atom.1.as_slice())?;
+            }
+
+            Ok(())
+        });
+
+        let outcome = match test_exec_result {
+            Ok(r) => match r {
+                Ok(_) => Ok(String::from("test passed")),
+                Err(e) => Err(format!("{e}")),
+            },
+            Err(e) => Err(format!("{:?}", e)),
+        };
+
+        Ok(TestReport::new(
+            self.package,
+            self.get_id(),
+            self.get_version(),
+            self.config.compiler_backend.to_string(),
+            start - time::Instant::now(),
+            outcome,
+        ))
+    }
+
+    async fn is_to_test(&self) -> bool {
+        let pkg = self.package;
+
+        let out_dir = Argus::get_path(self.config.clone(), self.package).await;
+        let test_results_path = out_dir.join(format!(
+            "result-{}-{}--{}-{}.json",
+            self.get_id(),
+            self.get_version(),
+            std::env::consts::ARCH,
+            std::env::consts::OS,
+        ));
+
+        let file = match File::open(test_results_path) {
+            Ok(file) => file,
+            Err(e) => {
+                info!(
+                    "re-running test for pkg {:?} as previous-run file failed to open: {e}",
+                    pkg
+                );
+                return true;
+            }
+        };
+
+        let reader = BufReader::new(file);
+        let report: TestReport = match serde_json::from_reader(reader) {
+            Ok(p) => p,
+            Err(e) => {
+                info!(
+                    "re-running test for pkg {:?} as previous-run file failed to be deserialized: {e}",
+                    pkg
+                );
+                return true;
+            }
+        };
+
+        report.to_test(self.config.clone())
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/mod.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/mod.rs
new file mode 100644
index 0000000..ea75446
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/argus/tester/mod.rs
@@ -0,0 +1,67 @@
+use serde::{Deserialize, Serialize};
+use std::{sync::Arc, time::Duration};
+use wasmer_api::types::PackageVersionWithPackage;
+
+use super::ArgusConfig;
+
+pub(crate) mod cli_tester;
+
+#[cfg(feature = "wasmer_lib")]
+pub(crate) mod lib_tester;
+
+#[async_trait::async_trait]
+pub(crate) trait Tester: Send + Sync {
+    async fn is_to_test(&self) -> bool;
+    async fn run_test(&self) -> anyhow::Result<TestReport>;
+}
+
+/// The result of a test run.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TestReport {
+    pub package_namespace: String,
+    pub package_name: String,
+    pub package_version: String,
+
+    /// The unique identifier of the test runner.
+    ///
+    /// In practice, it will be one of `wasmer_cli`
+    /// or `wasmer_lib`.
+    pub runner_id: String,
+    pub runner_version: String,
+
+    /// The unique identifier of the compiler backend used to perform the test.
+    pub compiler_backend: String,
+
+    pub time: Duration,
+    pub outcome: Result<String, String>,
+}
+
+impl TestReport {
+    pub fn new(
+        package: &PackageVersionWithPackage,
+        runner_id: String,
+        runner_version: String,
+        compiler_backend: String,
+        time: Duration,
+        outcome: Result<String, String>,
+    ) -> Self {
+        Self {
+            package_namespace: match &package.package.namespace {
+                Some(ns) => ns.clone(),
+                None => String::from("unknown_namespace"),
+            },
+            package_name: package.package.package_name.clone(),
+            package_version: package.version.clone(),
+            runner_id,
+            runner_version,
+            compiler_backend,
+            time,
+            outcome,
+        }
+    }
+
+    pub fn to_test(&self, _config: Arc<ArgusConfig>) -> bool {
+        // In time we will have more checks to add here.
+        true
+    }
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/main.rs b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/main.rs
new file mode 100644
index 0000000..18a684c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wasmer-argus/src/main.rs
@@ -0,0 +1,18 @@
+mod argus;
+
+use argus::*;
+use clap::Parser;
+use tracing_subscriber::{fmt, prelude::*, EnvFilter};
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    let config = ArgusConfig::parse();
+
+    let argus = Argus::try_from(config)?;
+    argus.run().await
+}
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/README.md b/arbitrator/tools/module_roots/wasmer/tests/wast/README.md
new file mode 100644
index 0000000..4c4636e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/README.md
@@ -0,0 +1,3 @@
+# WebAssembly testsuite
+
+Here is where all the `.wast` tests live.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/.gitignore b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/.gitignore
new file mode 100644
index 0000000..34e4053
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/.gitignore
@@ -0,0 +1,2 @@
+/commit_message
+/repos/
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/Contributing.md b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/Contributing.md
new file mode 100644
index 0000000..1cc607f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/Contributing.md
@@ -0,0 +1,8 @@
+# Contributing to WebAssembly
+
+Interested in participating? Please follow
+[the same contributing guidelines as the design repository][].
+
+  [the same contributing guidelines as the design repository]: https://github.com/WebAssembly/design/blob/master/Contributing.md
+
+Also, please be sure to read [the README.md](README.md) for this repository.
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/LICENSE b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/LICENSE
new file mode 100644
index 0000000..8f71f43
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/LICENSE
@@ -0,0 +1,202 @@
+                                 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/arbitrator/tools/module_roots/wasmer/tests/wast/spec/README.md b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/README.md
new file mode 100644
index 0000000..50a2541
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/README.md
@@ -0,0 +1,18 @@
+Amalgamated WebAssembly Test Suite
+==================================
+
+This repository holds a mirror of the WebAssembly core testsuite which is
+maintained [here](https://github.com/WebAssembly/spec/tree/master/test/core),
+as well as the tests from the various [proposals
+repositories](https://github.com/WebAssembly/proposals/blob/master/README.md).
+
+In addition it also contains tests from various proposals which are currently
+forks of the primary spec repo.
+
+To add new tests or report problems in existing tests, please file issues and
+PRs within the spec or individual proposal repositories rather than within this
+mirror repository.
+
+To update the tests in this repo from their upstream sources:
+
+1. Run `update-tests.sh`
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/address.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/address.wast
new file mode 100644
index 0000000..320ea36
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/address.wast
@@ -0,0 +1,610 @@
+;; Load i32 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $i i32) (result i32)
+    (i32.load8_u offset=0 (local.get $i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $i i32) (result i32)
+    (i32.load8_u align=1 (local.get $i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $i i32) (result i32)
+    (i32.load8_u offset=1 align=1 (local.get $i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $i i32) (result i32)
+    (i32.load8_u offset=2 align=1 (local.get $i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $i i32) (result i32)
+    (i32.load8_u offset=25 align=1 (local.get $i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $i i32) (result i32)
+    (i32.load8_s offset=0 (local.get $i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $i i32) (result i32)
+    (i32.load8_s align=1 (local.get $i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $i i32) (result i32)
+    (i32.load8_s offset=1 align=1 (local.get $i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $i i32) (result i32)
+    (i32.load8_s offset=2 align=1 (local.get $i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $i i32) (result i32)
+    (i32.load8_s offset=25 align=1 (local.get $i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $i i32) (result i32)
+    (i32.load16_u offset=0 (local.get $i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $i i32) (result i32)
+    (i32.load16_u align=1 (local.get $i))                   ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $i i32) (result i32)
+    (i32.load16_u offset=1 align=1 (local.get $i))          ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $i i32) (result i32)
+    (i32.load16_u offset=2 align=2 (local.get $i))          ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $i i32) (result i32)
+    (i32.load16_u offset=25 align=2 (local.get $i))         ;; 122 'z\0'
+  )
+
+  (func (export "16s_good1") (param $i i32) (result i32)
+    (i32.load16_s offset=0 (local.get $i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $i i32) (result i32)
+    (i32.load16_s align=1 (local.get $i))                   ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $i i32) (result i32)
+    (i32.load16_s offset=1 align=1 (local.get $i))          ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $i i32) (result i32)
+    (i32.load16_s offset=2 align=2 (local.get $i))          ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $i i32) (result i32)
+    (i32.load16_s offset=25 align=2 (local.get $i))         ;; 122 'z\0'
+  )
+
+  (func (export "32_good1") (param $i i32) (result i32)
+    (i32.load offset=0 (local.get $i))                      ;; 1684234849 'abcd'
+  )
+  (func (export "32_good2") (param $i i32) (result i32)
+    (i32.load align=1 (local.get $i))                       ;; 1684234849 'abcd'
+  )
+  (func (export "32_good3") (param $i i32) (result i32)
+    (i32.load offset=1 align=1 (local.get $i))              ;; 1701077858 'bcde'
+  )
+  (func (export "32_good4") (param $i i32) (result i32)
+    (i32.load offset=2 align=2 (local.get $i))              ;; 1717920867 'cdef'
+  )
+  (func (export "32_good5") (param $i i32) (result i32)
+    (i32.load offset=25 align=4 (local.get $i))             ;; 122 'z\0\0\0'
+  )
+
+  (func (export "8u_bad") (param $i i32)
+    (drop (i32.load8_u offset=4294967295 (local.get $i)))
+  )
+  (func (export "8s_bad") (param $i i32)
+    (drop (i32.load8_s offset=4294967295 (local.get $i)))
+  )
+  (func (export "16u_bad") (param $i i32)
+    (drop (i32.load16_u offset=4294967295 (local.get $i)))
+  )
+  (func (export "16s_bad") (param $i i32)
+    (drop (i32.load16_s offset=4294967295 (local.get $i)))
+  )
+  (func (export "32_bad") (param $i i32)
+    (drop (i32.load offset=4294967295 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "8u_good1" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8u_good2" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8u_good3" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "8u_good4" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "8u_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "8s_good1" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8s_good2" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8s_good3" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "8s_good4" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "8s_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "16u_good1" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16u_good2" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16u_good3" (i32.const 0)) (i32.const 25442))
+(assert_return (invoke "16u_good4" (i32.const 0)) (i32.const 25699))
+(assert_return (invoke "16u_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "16s_good1" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16s_good2" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16s_good3" (i32.const 0)) (i32.const 25442))
+(assert_return (invoke "16s_good4" (i32.const 0)) (i32.const 25699))
+(assert_return (invoke "16s_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "32_good1" (i32.const 0)) (i32.const 1684234849))
+(assert_return (invoke "32_good2" (i32.const 0)) (i32.const 1684234849))
+(assert_return (invoke "32_good3" (i32.const 0)) (i32.const 1701077858))
+(assert_return (invoke "32_good4" (i32.const 0)) (i32.const 1717920867))
+(assert_return (invoke "32_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "8u_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "32_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "8u_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "32_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good4" (i32.const 65508)) (i32.const 0))
+(assert_trap (invoke "32_good5" (i32.const 65508)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "8s_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "16u_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "16s_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (i32.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+;; Load i64 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $i i32) (result i64)
+    (i64.load8_u offset=0 (local.get $i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $i i32) (result i64)
+    (i64.load8_u align=1 (local.get $i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $i i32) (result i64)
+    (i64.load8_u offset=1 align=1 (local.get $i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $i i32) (result i64)
+    (i64.load8_u offset=2 align=1 (local.get $i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $i i32) (result i64)
+    (i64.load8_u offset=25 align=1 (local.get $i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $i i32) (result i64)
+    (i64.load8_s offset=0 (local.get $i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $i i32) (result i64)
+    (i64.load8_s align=1 (local.get $i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $i i32) (result i64)
+    (i64.load8_s offset=1 align=1 (local.get $i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $i i32) (result i64)
+    (i64.load8_s offset=2 align=1 (local.get $i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $i i32) (result i64)
+    (i64.load8_s offset=25 align=1 (local.get $i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $i i32) (result i64)
+    (i64.load16_u offset=0 (local.get $i))                 ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $i i32) (result i64)
+    (i64.load16_u align=1 (local.get $i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $i i32) (result i64)
+    (i64.load16_u offset=1 align=1 (local.get $i))         ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $i i32) (result i64)
+    (i64.load16_u offset=2 align=2 (local.get $i))         ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $i i32) (result i64)
+    (i64.load16_u offset=25 align=2 (local.get $i))        ;; 122 'z\0'
+  )
+
+  (func (export "16s_good1") (param $i i32) (result i64)
+    (i64.load16_s offset=0 (local.get $i))                 ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $i i32) (result i64)
+    (i64.load16_s align=1 (local.get $i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $i i32) (result i64)
+    (i64.load16_s offset=1 align=1 (local.get $i))         ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $i i32) (result i64)
+    (i64.load16_s offset=2 align=2 (local.get $i))         ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $i i32) (result i64)
+    (i64.load16_s offset=25 align=2 (local.get $i))        ;; 122 'z\0'
+  )
+
+  (func (export "32u_good1") (param $i i32) (result i64)
+    (i64.load32_u offset=0 (local.get $i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good2") (param $i i32) (result i64)
+    (i64.load32_u align=1 (local.get $i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good3") (param $i i32) (result i64)
+    (i64.load32_u offset=1 align=1 (local.get $i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32u_good4") (param $i i32) (result i64)
+    (i64.load32_u offset=2 align=2 (local.get $i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32u_good5") (param $i i32) (result i64)
+    (i64.load32_u offset=25 align=4 (local.get $i))        ;; 122 'z\0\0\0'
+  )
+
+  (func (export "32s_good1") (param $i i32) (result i64)
+    (i64.load32_s offset=0 (local.get $i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good2") (param $i i32) (result i64)
+    (i64.load32_s align=1 (local.get $i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good3") (param $i i32) (result i64)
+    (i64.load32_s offset=1 align=1 (local.get $i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32s_good4") (param $i i32) (result i64)
+    (i64.load32_s offset=2 align=2 (local.get $i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32s_good5") (param $i i32) (result i64)
+    (i64.load32_s offset=25 align=4 (local.get $i))        ;; 122 'z\0\0\0'
+  )
+
+  (func (export "64_good1") (param $i i32) (result i64)
+    (i64.load offset=0 (local.get $i))                     ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good2") (param $i i32) (result i64)
+    (i64.load align=1 (local.get $i))                      ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good3") (param $i i32) (result i64)
+    (i64.load offset=1 align=1 (local.get $i))             ;; 0x6968676665646362 'bcdefghi'
+  )
+  (func (export "64_good4") (param $i i32) (result i64)
+    (i64.load offset=2 align=2 (local.get $i))             ;; 0x6a69686766656463 'cdefghij'
+  )
+  (func (export "64_good5") (param $i i32) (result i64)
+    (i64.load offset=25 align=8 (local.get $i))            ;; 122 'z\0\0\0\0\0\0\0'
+  )
+
+  (func (export "8u_bad") (param $i i32)
+    (drop (i64.load8_u offset=4294967295 (local.get $i)))
+  )
+  (func (export "8s_bad") (param $i i32)
+    (drop (i64.load8_s offset=4294967295 (local.get $i)))
+  )
+  (func (export "16u_bad") (param $i i32)
+    (drop (i64.load16_u offset=4294967295 (local.get $i)))
+  )
+  (func (export "16s_bad") (param $i i32)
+    (drop (i64.load16_s offset=4294967295 (local.get $i)))
+  )
+  (func (export "32u_bad") (param $i i32)
+    (drop (i64.load32_u offset=4294967295 (local.get $i)))
+  )
+  (func (export "32s_bad") (param $i i32)
+    (drop (i64.load32_s offset=4294967295 (local.get $i)))
+  )
+  (func (export "64_bad") (param $i i32)
+    (drop (i64.load offset=4294967295 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "8u_good1" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8u_good2" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8u_good3" (i32.const 0)) (i64.const 98))
+(assert_return (invoke "8u_good4" (i32.const 0)) (i64.const 99))
+(assert_return (invoke "8u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "8s_good1" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8s_good2" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8s_good3" (i32.const 0)) (i64.const 98))
+(assert_return (invoke "8s_good4" (i32.const 0)) (i64.const 99))
+(assert_return (invoke "8s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "16u_good1" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16u_good2" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16u_good3" (i32.const 0)) (i64.const 25442))
+(assert_return (invoke "16u_good4" (i32.const 0)) (i64.const 25699))
+(assert_return (invoke "16u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "16s_good1" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16s_good2" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16s_good3" (i32.const 0)) (i64.const 25442))
+(assert_return (invoke "16s_good4" (i32.const 0)) (i64.const 25699))
+(assert_return (invoke "16s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "32u_good1" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32u_good2" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32u_good3" (i32.const 0)) (i64.const 1701077858))
+(assert_return (invoke "32u_good4" (i32.const 0)) (i64.const 1717920867))
+(assert_return (invoke "32u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "32s_good1" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32s_good2" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32s_good3" (i32.const 0)) (i64.const 1701077858))
+(assert_return (invoke "32s_good4" (i32.const 0)) (i64.const 1717920867))
+(assert_return (invoke "32s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "64_good1" (i32.const 0)) (i64.const 0x6867666564636261))
+(assert_return (invoke "64_good2" (i32.const 0)) (i64.const 0x6867666564636261))
+(assert_return (invoke "64_good3" (i32.const 0)) (i64.const 0x6968676665646362))
+(assert_return (invoke "64_good4" (i32.const 0)) (i64.const 0x6a69686766656463))
+(assert_return (invoke "64_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "8u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "32u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "32s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "64_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "8u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "32u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "32s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "64_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good4" (i32.const 65504)) (i64.const 0))
+(assert_trap (invoke "64_good5" (i32.const 65504)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "8s_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "16u_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "16s_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "32u_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "32s_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access")
+
+;; Load f32 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\00\00\00\00\00\a0\7f\01\00\d0\7f")
+
+  (func (export "32_good1") (param $i i32) (result f32)
+    (f32.load offset=0 (local.get $i))                   ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good2") (param $i i32) (result f32)
+    (f32.load align=1 (local.get $i))                    ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good3") (param $i i32) (result f32)
+    (f32.load offset=1 align=1 (local.get $i))           ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good4") (param $i i32) (result f32)
+    (f32.load offset=2 align=2 (local.get $i))           ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good5") (param $i i32) (result f32)
+    (f32.load offset=8 align=4 (local.get $i))           ;; nan:0x500001 '\01\00\d0\7f'
+  )
+  (func (export "32_bad") (param $i i32)
+    (drop (f32.load offset=4294967295 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "32_good1" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good5" (i32.const 0)) (f32.const nan:0x500001))
+
+(assert_return (invoke "32_good1" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good5" (i32.const 65524)) (f32.const 0.0))
+
+(assert_return (invoke "32_good1" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 65525)) (f32.const 0.0))
+(assert_trap (invoke "32_good5" (i32.const 65525)) "out of bounds memory access")
+
+(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "32_good3" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access")
+
+;; Load f64 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\f4\7f\01\00\00\00\00\00\fc\7f")
+
+  (func (export "64_good1") (param $i i32) (result f64)
+    (f64.load offset=0 (local.get $i))                     ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good2") (param $i i32) (result f64)
+    (f64.load align=1 (local.get $i))                      ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good3") (param $i i32) (result f64)
+    (f64.load offset=1 align=1 (local.get $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good4") (param $i i32) (result f64)
+    (f64.load offset=2 align=2 (local.get $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good5") (param $i i32) (result f64)
+    (f64.load offset=18 align=8 (local.get $i))            ;; nan:0xc000000000001 '\01\00\00\00\00\00\fc\7f'
+  )
+  (func (export "64_bad") (param $i i32)
+    (drop (f64.load offset=4294967295 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "64_good1" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good5" (i32.const 0)) (f64.const nan:0xc000000000001))
+
+(assert_return (invoke "64_good1" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good5" (i32.const 65510)) (f64.const 0.0))
+
+(assert_return (invoke "64_good1" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 65511)) (f64.const 0.0))
+(assert_trap (invoke "64_good5" (i32.const 65511)) "out of bounds memory access")
+
+(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "64_good3" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/align.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/align.wast
new file mode 100644
index 0000000..9306464
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/align.wast
@@ -0,0 +1,866 @@
+;; Test alignment annotation rules
+
+(module (memory 0) (func (drop (i32.load8_s align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load8_u align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load16_s align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load16_u align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load8_s align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load8_u align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load16_s align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load16_u align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load32_s align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load32_u align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load align=8 (i32.const 0)))))
+(module (memory 0) (func (drop (f32.load align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (f64.load align=8 (i32.const 0)))))
+(module (memory 0) (func (i32.store8 align=1 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i32.store16 align=2 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i32.store align=4 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i64.store8 align=1 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store16 align=2 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store32 align=4 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store align=8 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (f32.store align=4 (i32.const 0) (f32.const 1.0))))
+(module (memory 0) (func (f64.store align=8 (i32.const 0) (f64.const 1.0))))
+
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f32.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f32.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f64.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f64.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store8 align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store8 align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store16 align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store16 align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store8 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store8 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store16 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store16 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store32 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store32 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f32.store align=0 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f32.store align=7 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f64.store align=0 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f64.store align=7 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_s align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_u align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_s align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_u align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+
+(assert_invalid
+  (module (memory 0) (func (i32.store8 align=2 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.store16 align=4 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.store align=8 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store8 align=2 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store16 align=4 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store32 align=8 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store align=16 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (f32.store align=8 (i32.const 0) (f32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (f64.store align=16 (i32.const 0) (f64.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+
+  ;; $default: natural alignment, $1: align=1, $2: align=2, $4: align=4, $8: align=8
+
+  (func (export "f32_align_switch") (param i32) (result f32)
+    (local f32 f32)
+    (local.set 1 (f32.const 10.0))
+    (block $4
+      (block $2
+        (block $1
+          (block $default
+            (block $0
+              (br_table $0 $default $1 $2 $4 (local.get 0))
+            ) ;; 0
+            (f32.store (i32.const 0) (local.get 1))
+            (local.set 2 (f32.load (i32.const 0)))
+            (br $4)
+          ) ;; default
+          (f32.store align=1 (i32.const 0) (local.get 1))
+          (local.set 2 (f32.load align=1 (i32.const 0)))
+          (br $4)
+        ) ;; 1
+        (f32.store align=2 (i32.const 0) (local.get 1))
+        (local.set 2 (f32.load align=2 (i32.const 0)))
+        (br $4)
+      ) ;; 2
+      (f32.store align=4 (i32.const 0) (local.get 1))
+      (local.set 2 (f32.load align=4 (i32.const 0)))
+    ) ;; 4
+    (local.get 2)
+  )
+
+  (func (export "f64_align_switch") (param i32) (result f64)
+    (local f64 f64)
+    (local.set 1 (f64.const 10.0))
+    (block $8
+      (block $4
+        (block $2
+          (block $1
+            (block $default
+              (block $0
+                (br_table $0 $default $1 $2 $4 $8 (local.get 0))
+              ) ;; 0
+              (f64.store (i32.const 0) (local.get 1))
+              (local.set 2 (f64.load (i32.const 0)))
+              (br $8)
+            ) ;; default
+            (f64.store align=1 (i32.const 0) (local.get 1))
+            (local.set 2 (f64.load align=1 (i32.const 0)))
+            (br $8)
+          ) ;; 1
+          (f64.store align=2 (i32.const 0) (local.get 1))
+          (local.set 2 (f64.load align=2 (i32.const 0)))
+          (br $8)
+        ) ;; 2
+        (f64.store align=4 (i32.const 0) (local.get 1))
+        (local.set 2 (f64.load align=4 (i32.const 0)))
+        (br $8)
+      ) ;; 4
+      (f64.store align=8 (i32.const 0) (local.get 1))
+      (local.set 2 (f64.load align=8 (i32.const 0)))
+    ) ;; 8
+    (local.get 2)
+  )
+
+  ;; $8s: i32/i64.load8_s, $8u: i32/i64.load8_u, $16s: i32/i64.load16_s, $16u: i32/i64.load16_u, $32: i32.load
+  ;; $32s: i64.load32_s, $32u: i64.load32_u, $64: i64.load
+
+  (func (export "i32_align_switch") (param i32 i32) (result i32)
+    (local i32 i32)
+    (local.set 2 (i32.const 10))
+    (block $32
+      (block $16u
+        (block $16s
+          (block $8u
+            (block $8s
+              (block $0
+                (br_table $0 $8s $8u $16s $16u $32 (local.get 0))
+              ) ;; 0
+              (if (i32.eq (local.get 1) (i32.const 0))
+                (then
+                  (i32.store8 (i32.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s (i32.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 1))
+                (then
+                  (i32.store8 align=1 (i32.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s align=1 (i32.const 0)))
+                )
+              )
+              (br $32)
+            ) ;; 8s
+            (if (i32.eq (local.get 1) (i32.const 0))
+              (then
+                (i32.store8 (i32.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u (i32.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 1))
+              (then
+                (i32.store8 align=1 (i32.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u align=1 (i32.const 0)))
+              )
+            )
+            (br $32)
+          ) ;; 8u
+          (if (i32.eq (local.get 1) (i32.const 0))
+            (then
+              (i32.store16 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s (i32.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 1))
+            (then
+              (i32.store16 align=1 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=1 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 2))
+            (then
+              (i32.store16 align=2 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=2 (i32.const 0)))
+            )
+          )
+          (br $32)
+        ) ;; 16s
+        (if (i32.eq (local.get 1) (i32.const 0))
+          (then
+            (i32.store16 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u (i32.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 1))
+          (then
+            (i32.store16 align=1 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=1 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 2))
+          (then
+            (i32.store16 align=2 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=2 (i32.const 0)))
+          )
+        )
+        (br $32)
+      ) ;; 16u
+      (if (i32.eq (local.get 1) (i32.const 0))
+        (then
+          (i32.store (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 1))
+        (then
+          (i32.store align=1 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=1 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 2))
+        (then
+          (i32.store align=2 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=2 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 4))
+        (then
+          (i32.store align=4 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=4 (i32.const 0)))
+        )
+      )
+    ) ;; 32
+    (local.get 3)
+  )
+
+  (func (export "i64_align_switch") (param i32 i32) (result i64)
+    (local i64 i64)
+    (local.set 2 (i64.const 10))
+    (block $64
+      (block $32u
+        (block $32s
+          (block $16u
+            (block $16s
+              (block $8u
+                (block $8s
+                  (block $0
+                    (br_table $0 $8s $8u $16s $16u $32s $32u $64 (local.get 0))
+                  ) ;; 0
+                  (if (i32.eq (local.get 1) (i32.const 0))
+                    (then
+                      (i64.store8 (i32.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s (i32.const 0)))
+                    )
+                  )
+                  (if (i32.eq (local.get 1) (i32.const 1))
+                    (then
+                      (i64.store8 align=1 (i32.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s align=1 (i32.const 0)))
+                    )
+                  )
+                  (br $64)
+                ) ;; 8s
+                (if (i32.eq (local.get 1) (i32.const 0))
+                  (then
+                    (i64.store8 (i32.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u (i32.const 0)))
+                  )
+                )
+                (if (i32.eq (local.get 1) (i32.const 1))
+                  (then
+                    (i64.store8 align=1 (i32.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u align=1 (i32.const 0)))
+                  )
+                )
+                (br $64)
+              ) ;; 8u
+              (if (i32.eq (local.get 1) (i32.const 0))
+                (then
+                  (i64.store16 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s (i32.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 1))
+                (then
+                  (i64.store16 align=1 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=1 (i32.const 0)))
+                )
+              )
+              (if (i32.eq (local.get 1) (i32.const 2))
+                (then
+                  (i64.store16 align=2 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=2 (i32.const 0)))
+                )
+              )
+              (br $64)
+            ) ;; 16s
+            (if (i32.eq (local.get 1) (i32.const 0))
+              (then
+                (i64.store16 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u (i32.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 1))
+              (then
+                (i64.store16 align=1 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=1 (i32.const 0)))
+              )
+            )
+            (if (i32.eq (local.get 1) (i32.const 2))
+              (then
+                (i64.store16 align=2 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=2 (i32.const 0)))
+              )
+            )
+            (br $64)
+          ) ;; 16u
+          (if (i32.eq (local.get 1) (i32.const 0))
+            (then
+              (i64.store32 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s (i32.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 1))
+            (then
+              (i64.store32 align=1 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=1 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 2))
+            (then
+              (i64.store32 align=2 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=2 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (local.get 1) (i32.const 4))
+            (then
+              (i64.store32 align=4 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=4 (i32.const 0)))
+            )
+          )
+          (br $64)
+        ) ;; 32s
+        (if (i32.eq (local.get 1) (i32.const 0))
+          (then
+            (i64.store32 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u (i32.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 1))
+          (then
+            (i64.store32 align=1 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=1 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 2))
+          (then
+            (i64.store32 align=2 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=2 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (local.get 1) (i32.const 4))
+          (then
+            (i64.store32 align=4 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=4 (i32.const 0)))
+          )
+        )
+        (br $64)
+      ) ;; 32u
+      (if (i32.eq (local.get 1) (i32.const 0))
+        (then
+          (i64.store (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 1))
+        (then
+          (i64.store align=1 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=1 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 2))
+        (then
+          (i64.store align=2 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=2 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 4))
+        (then
+          (i64.store align=4 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=4 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (local.get 1) (i32.const 8))
+        (then
+          (i64.store align=8 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=8 (i32.const 0)))
+        )
+      )
+    ) ;; 64
+    (local.get 3)
+  )
+)
+
+(assert_return (invoke "f32_align_switch" (i32.const 0)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 1)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 2)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 3)) (f32.const 10.0))
+
+(assert_return (invoke "f64_align_switch" (i32.const 0)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 1)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 2)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 3)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 4)) (f64.const 10.0))
+
+(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 4)) (i32.const 10))
+
+(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 8)) (i64.const 10))
+
+;; Test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything
+
+(module
+  (memory 1)
+  (func (export "store") (param i32 i64)
+    (i64.store align=4 (local.get 0) (local.get 1))
+  )
+  (func (export "load") (param i32) (result i32)
+    (i32.load (local.get 0))
+  )
+)
+
+(assert_trap (invoke "store" (i32.const 65532) (i64.const -1)) "out of bounds memory access")
+;; No memory was changed
+(assert_return (invoke "load" (i32.const 65532)) (i32.const 0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary-leb128.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary-leb128.wast
new file mode 100644
index 0000000..1d67219
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary-leb128.wast
@@ -0,0 +1,1002 @@
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\06\01"                          ;; Memory section with 1 entry
+  "\01\82\00"                          ;; minimum 2
+  "\82\00"                             ;; max 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\09\01"                          ;; Memory section with 1 entry
+  "\01\82\00"                          ;; minimum 2
+  "\82\80\80\80\00"                    ;; max 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02"                                ;; Element with explicit table index
+  "\80\00"                             ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00"                                ;; custom section
+  "\8a\00"                             ;; section size 10, encoded with 2 bytes
+  "\01"                                ;; name byte count
+  "1"                                  ;; name
+  "23456789"                           ;; sequence of bytes
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00"                                ;; custom section
+  "\0b"                                ;; section size
+  "\88\00"                             ;; name byte count 8, encoded with 2 bytes
+  "12345678"                           ;; name
+  "9"                                  ;; sequence of bytes
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\08\01"                          ;; type section
+  "\60"                                ;; func type
+  "\82\00"                             ;; num params 2, encoded with 2 bytes
+  "\7f\7e"                             ;; param type
+  "\01"                                ;; num results
+  "\7f"                                ;; result type
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\08\01"                          ;; type section
+  "\60"                                ;; func type
+  "\02"                                ;; num params
+  "\7f\7e"                             ;; param type
+  "\81\00"                             ;; num results 1, encoded with 2 bytes
+  "\7f"                                ;; result type
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                          ;; type section
+  "\60\01\7f\00"                       ;; function type
+  "\02\17\01"                          ;; import section
+  "\88\00"                             ;; module name length 8, encoded with 2 bytes
+  "\73\70\65\63\74\65\73\74"           ;; module name
+  "\09"                                ;; entity name length
+  "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+  "\00"                                ;; import kind
+  "\00"                                ;; import signature index
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                          ;; type section
+  "\60\01\7f\00"                       ;; function type
+  "\02\17\01"                          ;; import section
+  "\08"                                ;; module name length
+  "\73\70\65\63\74\65\73\74"           ;; module name
+  "\89\00"                             ;; entity name length 9, encoded with 2 bytes
+  "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+  "\00"                                ;; import kind
+  "\00"                                ;; import signature index
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                          ;; type section
+  "\60\01\7f\00"                       ;; function type
+  "\02\17\01"                          ;; import section
+  "\08"                                ;; module name length
+  "\73\70\65\63\74\65\73\74"           ;; module name
+  "\09"                                ;; entity name length 9
+  "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+  "\00"                                ;; import kind
+  "\80\00"                             ;; import signature index, encoded with 2 bytes
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                          ;; type section
+  "\60\00\00"                          ;; function type
+  "\03\03\01"                          ;; function section
+  "\80\00"                             ;; function 0 signature index, encoded with 2 bytes
+  "\0a\04\01"                          ;; code section
+  "\02\00\0b"                          ;; function body
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                          ;; type section
+  "\60\00\00"                          ;; fun type
+  "\03\02\01\00"                       ;; function section
+  "\07\07\01"                          ;; export section
+  "\82\00"                             ;; string length 2, encoded with 2 bytes
+  "\66\31"                             ;; export name f1
+  "\00"                                ;; export kind
+  "\00"                                ;; export func index
+  "\0a\04\01"                          ;; code section
+  "\02\00\0b"                          ;; function body
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                          ;; type section
+  "\60\00\00"                          ;; fun type
+  "\03\02\01\00"                       ;; function section
+  "\07\07\01"                          ;; export section
+  "\02"                                ;; string length 2
+  "\66\31"                             ;; export name f1
+  "\00"                                ;; export kind
+  "\80\00"                             ;; export func index, encoded with 2 bytes
+  "\0a\04\01"                          ;; code section
+  "\02\00\0b"                          ;; function body
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                          ;; type section
+  "\60\00\00"                          ;; fun type
+  "\03\02\01\00"                       ;; function section
+  "\0a"                                ;; code section
+  "\05"                                ;; section size
+  "\81\00"                             ;; num functions, encoded with 2 bytes
+  "\02\00\0b"                          ;; function body
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\0a\01"                          ;; Memory section with 1 entry
+    "\01\82\00"                          ;; minimum 2
+    "\82\80\80\80\80\00"                 ;; max 2 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                          ;; Memory section with 1 entry
+    "\00\00"                             ;; no max, minimum 0
+    "\0b\0b\01"                          ;; Data section with 1 entry
+    "\80\80\80\80\80\00"                 ;; Memory index 0 with one byte too many
+    "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\04\04\01"                          ;; Table section with 1 entry
+    "\70\00\00"                          ;; no max, minimum 0, funcref
+    "\09\0b\01"                          ;; Element section with 1 entry
+    "\80\80\80\80\80\00"                 ;; Table index 0 with one byte too many
+    "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"                                ;; custom section
+    "\83\80\80\80\80\00"                 ;; section size 3 with one byte too many
+    "\01"                                ;; name byte count
+    "1"                                  ;; name
+    "2"                                  ;; sequence of bytes
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"                                ;; custom section
+    "\0A"                                ;; section size
+    "\83\80\80\80\80\00"                 ;; name byte count 3 with one byte too many
+    "123"                                ;; name
+    "4"                                  ;; sequence of bytes
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\0c\01"                          ;; type section
+    "\60"                                ;; func type
+    "\82\80\80\80\80\00"                 ;; num params 2 with one byte too many
+    "\7f\7e"                             ;; param type
+    "\01"                                ;; num result
+    "\7f"                                ;; result type
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\08\01"                          ;; type section
+    "\60"                                ;; func type
+    "\02"                                ;; num params
+    "\7f\7e"                             ;; param type
+    "\81\80\80\80\80\00"                 ;; num result 1 with one byte too many
+    "\7f"                                ;; result type
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                          ;; type section
+    "\60\01\7f\00"                       ;; function type
+    "\02\1b\01"                          ;; import section
+    "\88\80\80\80\80\00"                 ;; module name length 8 with one byte too many
+    "\73\70\65\63\74\65\73\74"           ;; module name
+    "\09"                                ;; entity name length
+    "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+    "\00"                                ;; import kind
+    "\00"                                ;; import signature index
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                          ;; type section
+    "\60\01\7f\00"                       ;; function type
+    "\02\1b\01"                          ;; import section
+    "\08"                                ;; module name length
+    "\73\70\65\63\74\65\73\74"           ;; module name
+    "\89\80\80\80\80\00"                 ;; entity name length 9 with one byte too many
+    "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+    "\00"                                ;; import kind
+    "\00"                                ;; import signature index
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                          ;; type section
+    "\60\01\7f\00"                       ;; function type
+    "\02\1b\01"                          ;; import section
+    "\08"                                ;; module name length
+    "\73\70\65\63\74\65\73\74"           ;; module name
+    "\09"                                ;; entity name length 9
+    "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+    "\00"                                ;; import kind
+    "\80\80\80\80\80\00"                 ;; import signature index 0 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; function type
+    "\03\03\01"                          ;; function section
+    "\80\80\80\80\80\00"                 ;; function 0 signature index with one byte too many
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\07\0b\01"                          ;; export section
+    "\82\80\80\80\80\00"                 ;; string length 2 with one byte too many
+    "\66\31"                             ;; export name f1
+    "\00"                                ;; export kind
+    "\00"                                ;; export func index
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\07\0b\01"                          ;; export section
+    "\02"                                ;; string length 2
+    "\66\31"                             ;; export name f1
+    "\00"                                ;; export kind
+    "\80\80\80\80\80\00"                 ;; export func index 0 with one byte too many
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\0a"                                ;; code section
+    "\05"                                ;; section size
+    "\81\80\80\80\80\00"                 ;; num functions 1 with one byte too many
+    "\02\00\0b"                          ;; function body
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\09\01"                          ;; Memory section with 1 entry
+    "\01\82\00"                          ;; minimum 2
+    "\82\80\80\80\10"                    ;; max 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\09\01"                          ;; Memory section with 1 entry
+    "\01\82\00"                          ;; minimum 2
+    "\82\80\80\80\40"                    ;; max 2 with some unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                          ;; Memory section with 1 entry
+    "\00\00"                             ;; no max, minimum 0
+    "\0b\0a\01"                          ;; Data section with 1 entry
+    "\80\80\80\80\10"                    ;; Memory index 0 with unused bits set
+    "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\04\04\01"                          ;; Table section with 1 entry
+    "\70\00\00"                          ;; no max, minimum 0, funcref
+    "\09\0a\01"                          ;; Element section with 1 entry
+    "\80\80\80\80\10"                    ;; Table index 0 with unused bits set
+    "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"                                ;; custom section
+    "\83\80\80\80\10"                    ;; section size 3 with unused bits set
+    "\01"                                ;; name byte count
+    "1"                                  ;; name
+    "2"                                  ;; sequence of bytes
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"                                ;; custom section
+    "\09"                                ;; section size
+    "\83\80\80\80\40"                    ;; name byte count 3 with unused bits set
+    "123"                                ;; name
+    "4"                                  ;; sequence of bytes
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\0b\01"                          ;; type section
+    "\60"                                ;; func type
+    "\82\80\80\80\10"                    ;; num params 2 with unused bits set
+    "\7f\7e"                             ;; param type
+    "\01"                                ;; num result
+    "\7f"                                ;; result type
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\0b\01"                          ;; type section
+    "\60"                                ;; func type
+    "\02"                                ;; num params
+    "\7f\7e"                             ;; param type
+    "\81\80\80\80\40"                    ;; num result 1 with unused bits set
+    "\7f"                                ;; result type
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                          ;; type section
+    "\60\01\7f\00"                       ;; function type
+    "\02\1a\01"                          ;; import section
+    "\88\80\80\80\10"                    ;; module name length 8 with unused bits set
+    "\73\70\65\63\74\65\73\74"           ;; module name
+    "\09"                                ;; entity name length
+    "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+    "\00"                                ;; import kind
+    "\00"                                ;; import signature index
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                          ;; type section
+    "\60\01\7f\00"                       ;; function type
+    "\02\1a\01"                          ;; import section
+    "\08"                                ;; module name length
+    "\73\70\65\63\74\65\73\74"           ;; module name
+    "\89\80\80\80\40"                    ;; entity name length 9 with unused bits set
+    "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+    "\00"                                ;; import kind
+    "\00"                                ;; import signature index
+  )
+  "integer too large"
+)
+(assert_malformed
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                          ;; type section
+  "\60\01\7f\00"                       ;; function type
+  "\02\1a\01"                          ;; import section
+  "\08"                                ;; module name length
+  "\73\70\65\63\74\65\73\74"           ;; module name
+  "\09"                                ;; entity name length 9
+  "\70\72\69\6e\74\5f\69\33\32"        ;; entity name
+  "\00"                                ;; import kind
+  "\80\80\80\80\10"                    ;; import signature index 0 with unused bits set
+)
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; function type
+    "\03\06\01"                          ;; function section
+    "\80\80\80\80\10"                    ;; function 0 signature index with unused bits set
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\07\0a\01"                          ;; export section
+    "\82\80\80\80\10"                    ;; string length 2 with unused bits set
+    "\66\31"                             ;; export name f1
+    "\00"                                ;; export kind
+    "\00"                                ;; export func index
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\07\0a\01"                          ;; export section
+    "\02"                                ;; string length 2
+    "\66\31"                             ;; export name f1
+    "\00"                                ;; export kind
+    "\80\80\80\80\10"                    ;; export func index with unused bits set
+    "\0a\04\01"                          ;; code section
+    "\02\00\0b"                          ;; function body
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; fun type
+    "\03\02\01\00"                       ;; function section
+    "\0a"                                ;; code section
+    "\08"                                ;; section size
+    "\81\80\80\80\10"                    ;; num functions 1 with unused bits set
+    "\02\00\0b"                          ;; function body
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                          ;; type section
+  "\60\00\00"                          ;; empty function type
+  "\03\02\01"                          ;; function section
+  "\00"                                ;; function 0, type 0
+  "\0a\1b\01\19"                       ;; code section
+  "\00"                                ;; no locals
+  "\00"                                ;; unreachable
+  "\fc\80\00"                          ;; i32_trunc_sat_f32_s with 2 bytes
+  "\00"                                ;; unreachable
+  "\fc\81\80\00"                       ;; i32_trunc_sat_f32_u with 3 bytes
+  "\00"                                ;; unreachable
+  "\fc\86\80\80\00"                    ;; i64_trunc_sat_f64_s with 4 bytes
+  "\00"                                ;; unreachable
+  "\fc\87\80\80\80\00"                 ;; i64_trunc_sat_f64_u with 5 bytes
+  "\00"                                ;; unreachable
+  "\0b"                                ;; end
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                          ;; type section
+    "\60\00\00"                          ;; empty function type
+    "\03\02\01"                          ;; function section
+    "\00"                                ;; function 0, type 0
+    "\0a\0d\01\0b"                       ;; code section
+    "\00"                                ;; no locals
+    "\00"                                ;; unreachable
+    "\fc\87\80\80\80\80\00"              ;; i64_trunc_sat_f64_u with 6 bytes
+    "\00"                                ;; unreachable
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary.wast
new file mode 100644
index 0000000..c6f9755
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/binary.wast
@@ -0,0 +1,1764 @@
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
+
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+
+;; Malformed binary version.
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+;; Invalid section id.
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id")
+
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\06\01"                          ;; Data section with 1 entry
+  "\00"                                ;; Memory index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\06\01"                          ;; Element section with 1 entry
+  "\00"                                ;; Table index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
+
+;; Data segment memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+
+;; Type section with signed LEB128 encoded type
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01"                     ;; Type section id
+    "\05"                     ;; Type section length
+    "\01"                     ;; Types vector length
+    "\e0\7f"                  ;; Malformed functype, -0x20 in signed LEB128 encoding
+    "\00\00"
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+;; memory.grow reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.size reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Local number is unsigned 32 bit
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\80\80\80\80\10\7f"       ;; 0x100000000 i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Local number is unsigned 32 bit
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\80\80\80\80\10\7f"       ;; 0x100000000 i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; No more than 2^32-1 locals.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\06\01\60\02\7f\7f\00" ;; Type section: (param i32 i32)
+    "\03\02\01\00"             ;; Function section
+    "\0a\1c\01"                ;; Code section
+
+    ;; function 0
+    "\1a\04"
+    "\80\80\80\80\04\7f"       ;; 0x40000000 i32
+    "\80\80\80\80\04\7e"       ;; 0x40000000 i64
+    "\80\80\80\80\04\7d"       ;; 0x40000000 f32
+    "\80\80\80\80\04\7c"       ;; 0x40000000 f64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+;; Local count can be 0.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"     ;; Type section
+  "\03\02\01\00"           ;; Function section
+  "\0a\0a\01"              ;; Code section
+
+  ;; function 0
+  "\08\03"
+  "\00\7f"                 ;; 0 i32
+  "\00\7e"                 ;; 0 i64
+  "\02\7d"                 ;; 2 f32
+  "\0b"                    ;; end
+)
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)
+
+;; Fewer passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\03"                   ;; Datacount section with value "3"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; More passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\01"                   ;; Datacount section with value "1"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; memory.init requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0e\01"                ;; Code section
+
+    ;; function 0
+    "\0c\00"
+    "\41\00"                   ;; zero args
+    "\41\00"
+    "\41\00"
+    "\fc\08\00\00"             ;; memory.init
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; data.drop requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\fc\09\00"                ;; data.drop
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; passive element segment containing opcode other than ref.func or ref.null
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\70"                   ;; Passive, funcref
+    "\01"                      ;; 1 element
+    "\d3\00\0b"                ;; bad opcode, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "illegal opcode")
+
+;; passive element segment containing type other than funcref
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\7f"                   ;; Passive, i32
+    "\01"                      ;; 1 element
+    "\d2\00\0b"                ;; ref.func, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "malformed reference type")
+
+;; passive element segment containing opcode ref.func
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d2\00\0b"                ;; ref.func, index 0, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+;; passive element segment containing opcode ref.null
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d0\70\0b"                ;; ref.null, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+
+;; Type count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\01\00"                               ;; type count can be zero
+)
+
+;; 2 type declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\02"                             ;; type section with inconsistent count (2 declared, 1 given)
+    "\60\00\00"                             ;; 1st type
+    ;; "\60\00\00"                          ;; 2nd type (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 type declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01"                             ;; type section with inconsistent count (1 declared, 2 given)
+    "\60\00\00"                             ;; 1st type
+    "\60\00\00"                             ;; 2nd type (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Import count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                             ;; type section
+    "\60\01\7f\00"                          ;; type 0
+    "\02\01\00"                             ;; import count can be zero
+)
+
+;; Malformed import kind
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\04"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\04"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\05"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\05"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\80"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\80"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+
+;; 2 import declared, 1 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\05\01"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\02\16\02"                           ;; import section with inconsistent count (2 declared, 1 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 import declared, 2 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\09\02"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\60\01\7d\00"                        ;; type 1
+      "\02\2b\01"                           ;; import section with inconsistent count (1 declared, 2 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (redundant)
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\66\33\32"         ;; print_f32
+      "\00\01"                              ;; import kind, import signature index
+  )
+  "section size mismatch"
+)
+
+;; Table count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\04\01\00"                             ;; table count can be zero
+)
+
+;; 1 table declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\01"                           ;; table section with inconsistent count (1 declared, 0 given)
+      ;; "\70\01\00\00"                     ;; table entity
+  )
+  "unexpected end of section or function"
+)
+
+;; Malformed table limits flag
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\03\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\02"                                 ;; malformed table limits flag
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\04\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\02"                                 ;; malformed table limits flag
+      "\00"                                 ;; dummy byte
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\06\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\81\00"                              ;; malformed table limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer too large"
+)
+
+;; Memory count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                             ;; memory count can be zero
+)
+
+;; 1 memory declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\01"                           ;; memory section with inconsistent count (1 declared, 0 given)
+      ;; "\00\00"                           ;; memory 0 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; Malformed memory limits flag
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\02\01"                           ;; memory section with one entry
+      "\02"                                 ;; malformed memory limits flag
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\03\01"                           ;; memory section with one entry
+      "\02"                                 ;; malformed memory limits flag
+      "\00"                                 ;; dummy byte
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\05\01"                           ;; memory section with one entry
+      "\81\00"                              ;; malformed memory limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\05\01"                           ;; memory section with one entry
+      "\81\01"                              ;; malformed memory limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer representation too long"
+)
+
+;; Global count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\01\00"                               ;; global count can be zero
+)
+
+;; 2 global declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\06\02"                             ;; global section with inconsistent count (2 declared, 1 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    ;; "\7f\00\41\00\0b"                    ;; global 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 global declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                             ;; global section with inconsistent count (1 declared, 2 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    "\7f\00\41\00\0b"                       ;; global 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Export count can be 0
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\03\02\00\00"                         ;; func section
+  "\07\01\00"                               ;; export count can be zero
+  "\0a\07\02"                               ;; code section
+  "\02\00\0b"                               ;; function body 0
+  "\02\00\0b"                               ;; function body 1
+)
+
+;; 2 export declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\06\02"                             ;; export section with inconsistent count (2 declared, 1 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    ;; "\02"                                ;; export 1 (missed)
+    ;; "\66\32"                             ;; export name
+    ;; "\00\01"                             ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 export declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\0b\01"                             ;; export section with inconsistent count (1 declared, 2 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    "\02"                                   ;; export 1 (redundant)
+    "\66\32"                                ;; export name
+    "\00\01"                                ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "section size mismatch"
+)
+
+;; elem segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\04\04\01"                               ;; table section
+  "\70\00\01"                               ;; table 0
+  "\09\01\00"                               ;; elem segment count can be zero
+  "\0a\04\01"                               ;; code section
+  "\02\00\0b"                               ;; function body
+)
+
+;; 2 elem segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    ;; "\00\41\00\0b\01\00"                 ;; elem 1 (missed)
+  )
+  "unexpected end"
+)
+
+;; 2 elem segment declared, 1.5 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00"                             ;; elem 1 (partial)
+    ;; "\0b\01\00"                          ;; elem 1 (missing part)
+  )
+  "unexpected end"
+)
+
+;; 1 elem segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\0d\01"                             ;; elem with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00\0b\01\00"                    ;; elem 1 (redundant)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "section size mismatch"
+)
+
+;; data segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                               ;; memory section
+  "\00\01"                                  ;; memory 0
+  "\0b\01\00"                               ;; data segment count can be zero
+)
+
+;; 2 data segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\07\02"                             ;; data with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    ;; "\00\41\01\0b\01\62"                 ;; data 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 data segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0d\01"                             ;; data with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    "\00\41\01\0b\01\62"                    ;; data 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; data segment has 7 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\03\0b"                          ;; data segment 0
+    "\07"                                   ;; data segment size with inconsistent lengths (7 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "unexpected end of section or function"
+)
+
+;; data segment has 5 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\00\0b"                          ;; data segment 0
+    "\05"                                   ;; data segment size with inconsistent lengths (5 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "section size mismatch"
+)
+
+;; br_table target count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\0a\11\01"                               ;; code section
+  "\0f\00"                                  ;; func 0
+  "\02\40"                                  ;; block 0
+  "\41\01"                                  ;; condition of if 0
+  "\04\40"                                  ;; if 0
+  "\41\01"                                  ;; index of br_table element
+  "\0e\00"                                  ;; br_table target count can be zero
+  "\02"                                     ;; break depth for default
+  "\0b\0b\0b"                               ;; end
+)
+
+;; 1 br_table target declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\11\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
+    "\00"                                   ;; break depth 0
+    "\01"                                   ;; break depth 1
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end"
+)
+
+;; Start section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"       ;; Type section
+  "\03\02\01\00"             ;; Function section
+  "\08\01\00"                ;; Start section: function 0
+
+  "\0a\04\01"                ;; Code section
+  ;; function 0
+  "\02\00"
+  "\0b"                      ;; end
+)
+
+;; Multiple start sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\08\01\00"                ;; Start section: function 0
+    "\08\01\00"                ;; Start section: function 0
+
+    "\0a\04\01"                ;; Code section
+    ;; function 0
+    "\02\00"
+    "\0b"                      ;; end
+  )
+  "junk after last section"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/block.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/block.wast
new file mode 100644
index 0000000..44915b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/block.wast
@@ -0,0 +1,1491 @@
+;; Test `block` operator
+
+(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty")
+    (block)
+    (block $l)
+  )
+
+  (func (export "singular") (result i32)
+    (block (nop))
+    (block (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (block (call $dummy) (call $dummy) (call $dummy) (call $dummy))
+    (block (result i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 7) (call $dummy)
+    )
+    (drop)
+    (block (result i32 i64 i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (block (result i32)
+      (block (call $dummy) (block) (nop))
+      (block (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (block (result i32) (block (result i32)
+      (block (result i32) (block (result i32)
+        (block (result i32) (block (result i32)
+          (block (result i32) (block (result i32)
+            (block (result i32) (block (result i32)
+              (block (result i32) (block (result i32)
+                (block (result i32) (block (result i32)
+                  (block (result i32) (block (result i32)
+                    (block (result i32) (block (result i32)
+                      (block (result i32) (block (result i32)
+                        (block (result i32) (block (result i32)
+                          (block (result i32) (block (result i32)
+                            (block (result i32) (block (result i32)
+                              (block (result i32) (block (result i32)
+                                (block (result i32) (block (result i32)
+                                  (block (result i32) (block (result i32)
+                                    (block (result i32) (block (result i32)
+                                      (block (result i32) (block (result i32)
+                                        (block (result i32) (block (result i32)
+                                          (call $dummy) (i32.const 150)
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (block (result i32) (i32.const 1)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (block (result i32) (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (block (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (block (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (block (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (block (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (block (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (block (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (block (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (block (result i32) (i32.const 1)))
+    (global.get $a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (block (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (block (result i32) (call $dummy) (i32.const 3))
+      (block (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (block (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (block (result f32) (call $dummy) (f32.const 3))
+      (block (result f32) (call $dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (block (result i32 i32)
+        (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (block (result f32 f32)
+        (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (block (result i32 i32)
+      (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (br 0) (unreachable))
+    (block (br_if 0 (i32.const 1)) (unreachable))
+    (block (br_table 0 (i32.const 0)) (unreachable))
+    (block (br_table 0 0 0 (i32.const 1)) (unreachable))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32) (br 0 (i32.const 18)) (i32.const 19))
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (br 0 (i32.const 18))
+      (br 0 (i32.const 19))
+      (drop (br_if 0 (i32.const 20) (i32.const 0)))
+      (drop (br_if 0 (i32.const 20) (i32.const 1)))
+      (br 0 (i32.const 21))
+      (br_table 0 (i32.const 22) (i32.const 4))
+      (br_table 0 0 0 (i32.const 23) (i32.const 1))
+      (i32.const 21)
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
+    )
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
+    )
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32) (br 0))
+    (i32.add)
+  )
+
+  (func (export "effects") (result i32)
+    (local i32)
+    (block
+      (local.set 0 (i32.const 1))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+      (br 0)
+      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (block (type $block-sig-1))
+    (block (type $block-sig-2) (i32.const 0))
+    (block (type $block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $block-sig-4))
+    (drop) (drop) (drop)
+    (block (type $block-sig-2) (result i32) (i32.const 0))
+    (block (type $block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "singular") (i32.const 7))
+(assert_return (invoke "multi") (i32.const 8))
+(assert_return (invoke "nested") (i32.const 9))
+(assert_return (invoke "deep") (i32.const 150))
+
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 1))
+(assert_return (invoke "as-loop-mid") (i32.const 1))
+(assert_return (invoke "as-loop-last") (i32.const 1))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 12))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operands") (i32.const 12))
+(assert_return (invoke "as-compare-operands") (i32.const 0))
+(assert_return (invoke "as-mixed-operands") (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value") (i32.const 18))
+(assert_return (invoke "break-multi-value")
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+(assert_return (invoke "break-repeated") (i32.const 18))
+(assert_return (invoke "break-inner") (i32.const 0xf))
+
+(assert_return (invoke "param") (i32.const 3))
+(assert_return (invoke "params") (i32.const 3))
+(assert_return (invoke "params-id") (i32.const 3))
+(assert_return (invoke "param-break") (i32.const 3))
+(assert_return (invoke "params-break") (i32.const 3))
+(assert_return (invoke "params-id-break") (i32.const 3))
+
+(assert_return (invoke "effects") (i32.const 1))
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (param i32) (type $sig) (result i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (param i32) (result i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (result i32) (type $sig) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (result i32) (param i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (block (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (i32.const 0) (block (param $x i32) (drop)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (param i32) (drop)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (param i32) (result i32)) (unreachable))"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (block (type $sig) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (block)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-i32-vs-void
+    (block (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-void
+    (block (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-void
+    (block (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-void
+    (block (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (block (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-i32 (result i32)
+    (block (result i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-i64 (result i64)
+    (block (result i64))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f32 (result f32)
+    (block (result f32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f64 (result f64)
+    (block (result f64))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-nums (result i32 i32)
+    (block (result i32 i32))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-value-empty-in-block
+      (i32.const 0)
+      (block (block (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-loop
+      (i32.const 0)
+      (loop (block (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (block (result i32)) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-i32 (result i32)
+    (block (result i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-i64 (result i64)
+    (block (result i64) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f32 (result f32)
+    (block (result f32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f64 (result f64)
+    (block (result f64) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-i64 (result i32)
+    (block (result i32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f32 (result i32)
+    (block (result i32) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f64 (result i32)
+    (block (result i32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-i32 (result i64)
+    (block (result i64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-f32 (result i64)
+    (block (result i64) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-f64 (result i64)
+    (block (result i64) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i32 (result f32)
+    (block (result f32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i64 (result f32)
+    (block (result f32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-f64 (result f32)
+    (block (result f32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i32 (result f64)
+    (block (result f64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i64 (result f64)
+    (block (result f64) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-f32 (result f32)
+    (block (result f64) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result i32)
+    (block (result i32) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-i64 (result i32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f32 (result i32)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f64 (result i32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-i32 (result i64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f32 (result i64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f64 (result i64)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i32 (result f32)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i64 (result f32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-f64 (result f32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i32 (result f64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i64 (result f64)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-f32 (result f64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-i32 (result i32)
+    (block (result i32) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-i64 (result i64)
+    (block (result i64) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f32 (result f32)
+    (block (result f32) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f64 (result f64)
+    (block (result f64) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-empty-vs-i32 (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-i64 (result i64)
+    (block (result i64) (br 0) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f32 (result f32)
+    (block (result f32) (br 0) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f64 (result f64)
+    (block (result f64) (br 0) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i32 (result f64)
+    (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (nop)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i32 (result f64)
+    (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-void
+    (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-void
+    (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-void
+    (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-void
+    (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-nums-vs-void
+    (block (result i32 i32) (block (result i32 i32) (br 1 (i32.const 1) (i32.const 2))) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i32 (result i32)
+    (block (result i32) (block (br 1)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i64 (result i64)
+    (block (result i64) (block (br 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f32 (result f32)
+    (block (result f32) (block (br 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f64 (result f64)
+    (block (result f64) (block (br 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (br 1)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-void-vs-i32 (result i32)
+    (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-i64 (result i64)
+    (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f32 (result f32)
+    (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f64 (result f64)
+    (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (result i32 i32) (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-i64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f32 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-i32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f64 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i32 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-f64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i64 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-f32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32 i32)
+      (block (result i32 i32) (br 1 (i32.const 0))) (br 0 (i32.const 1) (i32.const 2))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-i32 (result i32)
+    (i32.ctz (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-i64 (result i64)
+    (i64.ctz (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f32 (result f32)
+    (f32.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f64 (result f64)
+    (f64.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-nums (result i32)
+    (i32.add (block (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i32 (result i32)
+    (i32.ctz (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i64 (result i64)
+    (i64.ctz (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-f32 (result f32)
+    (f32.floor (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-f64 (result f64)
+    (f64.floor (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-nums (result i32)
+    (i32.add (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-i64 (result i32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f32 (result i32)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f64 (result i32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-i32 (result i64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f32 (result i64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f64 (result i64)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i32 (result f32)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i64 (result f32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-f64 (result f32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i32 (result f64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i64 (result f64)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-f32 (result f64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-num-vs-nums (result i32)
+    (i32.add (block (br 0 (i64.const 9) (i32.const 10))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (block (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (param i32 f64) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (block (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (block (param f32 i32) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (block (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (block (param i32 f64) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (block (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (block (param f32 i32) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) block (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (block (param $x i32)))")
+  "unexpected token"
+)
+
+
+(assert_malformed
+  (module quote "(func block end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func block $a end $l)")
+  "mismatching label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br.wast
new file mode 100644
index 0000000..35f707c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br.wast
@@ -0,0 +1,657 @@
+;; Test `br` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32") (block (drop (i32.ctz (br 0)))))
+  (func (export "type-i64") (block (drop (i64.ctz (br 0)))))
+  (func (export "type-f32") (block (drop (f32.neg (br 0)))))
+  (func (export "type-f64") (block (drop (f64.neg (br 0)))))
+  (func (export "type-i32-i32") (block (drop (i32.add (br 0)))))
+  (func (export "type-i64-i64") (block (drop (i64.add (br 0)))))
+  (func (export "type-f32-f32") (block (drop (f32.add (br 0)))))
+  (func (export "type-f64-f64") (block (drop (f64.add (br 0)))))
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br 0 (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br 0 (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br 0 (f64.const 4))))
+  )
+  (func (export "type-f64-f64-value") (result f64 f64)
+    (block (result f64 f64)
+      (f64.add (br 0 (f64.const 4) (f64.const 5))) (f64.const 6)
+    )
+  )
+
+  (func (export "as-block-first")
+    (block (br 0) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (br 0) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br 0))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (block (result i32)
+      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br 0)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br 0)))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br 0 (i64.const 7))))
+  )
+  (func (export "as-return-values") (result i32 i64)
+    (i32.const 2)
+    (block (result i64) (return (br 0 (i32.const 1) (i64.const 7))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (br 0 (i32.const 5)) (local.get 0) (local.get 1))
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (local.get 0) (br 0 (i32.const 6)) (local.get 1))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7)))
+    )
+  )
+  (func (export "as-select-all") (result i32)
+    (block (result i32) (select (br 0 (i32.const 8))))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
+    )
+  )
+  (func (export "as-call-all") (result i32)
+    (block (result i32) (call $f (br 0 (i32.const 15))))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (br 0 (i32.const 20))
+        (i32.const 1) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (br 0 (i32.const 21)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (i32.const 1) (br 0 (i32.const 22)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (i32.const 1) (i32.const 2) (br 0 (i32.const 23))
+      )
+    )
+  )
+  (func (export "as-call_indirect-all") (result i32)
+    (block (result i32) (call_indirect (type $sig) (br 0 (i32.const 24))))
+  )
+
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (block (result i32) (local.tee 0 (br 0 (i32.const 1))))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32) (global.set $a (br 0 (i32.const 1))))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br 0 (f32.const 1.7))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br 0 (i64.const 30))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1)
+    )
+  )
+  (func (export "as-store-both") (result i32)
+    (block (result i32)
+      (i64.store (br 0 (i32.const 32))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-both") (result i32)
+    (block (result i32)
+      (i64.store16 (br 0 (i32.const 34))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3.4))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45))))
+  )
+  (func (export "as-binary-both") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 46))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42))))
+  )
+  (func (export "as-compare-both") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br 0 (i32.const 40))))
+  )
+
+  (func (export "nested-block-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (call $dummy)
+        (i32.add (i32.const 4) (br 0 (i32.const 8)))
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br 0 (br 1 (i32.const 8)))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1)))
+            (i32.const 32)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8))))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br_table 0 (br 1 (i32.const 8)) (i32.const 1))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0 (i32.const 4) (br 0 (i32.const 8)))
+        (i32.const 16)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+(assert_return (invoke "type-i32-i32"))
+(assert_return (invoke "type-i64-i64"))
+(assert_return (invoke "type-f32-f32"))
+(assert_return (invoke "type-f64-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+(assert_return (invoke "type-f64-f64-value") (f64.const 4) (f64.const 5))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+(assert_return (invoke "as-return-values") (i32.const 2) (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+(assert_return (invoke "as-select-all") (i32.const 8))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+(assert_return (invoke "as-call-all") (i32.const 15))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 20))
+(assert_return (invoke "as-call_indirect-first") (i32.const 21))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 22))
+(assert_return (invoke "as-call_indirect-last") (i32.const 23))
+(assert_return (invoke "as-call_indirect-all") (i32.const 24))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-store-both") (i32.const 32))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+(assert_return (invoke "as-storeN-both") (i32.const 34))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+(assert_return (invoke "as-binary-both") (i32.const 46))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+(assert_return (invoke "as-compare-both") (i32.const 44))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_return (invoke "nested-block-value") (i32.const 9))
+(assert_return (invoke "nested-br-value") (i32.const 9))
+(assert_return (invoke "nested-br_if-value") (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond") (i32.const 9))
+(assert_return (invoke "nested-br_table-value") (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index") (i32.const 9))
+
+(assert_invalid
+  (module (func $type-arg-empty-vs-num (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-num (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br
+      (i32.const 0)
+      (block (result i32) (br 0 (br 0))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br_if
+      (i32.const 0)
+      (block (result i32) (br_if 0 (br 0) (i32.const 1))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br_table
+      (i32.const 0)
+      (block (result i32) (br_table 0 (br 0))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-return
+      (block (result i32)
+        (return (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-select
+      (block (result i32)
+        (select (br 0) (i32.const 1) (i32.const 2))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-call
+      (block (result i32)
+        (call 1 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-arg-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (br 0) (i32.const 0)
+        )
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-local.set
+      (local i32)
+      (block (result i32)
+        (local.set 0 (br 0)) (local.get 0)
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-local.tee
+      (local i32)
+      (block (result i32)
+        (local.tee 0 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-arg-empty-in-global.set
+      (block (result i32)
+        (global.set $x (br 0)) (global.get $x)
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-arg-empty-in-memory.grow
+      (block (result i32)
+        (memory.grow (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-arg-empty-in-load
+      (block (result i32)
+        (i32.load (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-arg-empty-in-store
+      (block (result i32)
+        (i32.store (br 0) (i32.const 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $unbound-label (br 1)))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label (block (block (br 5)))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label (br 0x10000001)))
+  "unknown label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_if.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_if.wast
new file mode 100644
index 0000000..fba5deb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_if.wast
@@ -0,0 +1,665 @@
+;; Test `br_if` operator
+
+(module
+  (func $dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1))))
+  )
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
+    (i32.const 3)
+  )
+  (func (export "as-block-last") (param i32)
+    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
+  )
+  (func (export "as-block-first-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
+    )
+  )
+  (func (export "as-block-mid-value") (param i32) (result i32)
+    (block (result i32)
+      (call $dummy)
+      (drop (br_if 0 (i32.const 20) (local.get 0)))
+      (return (i32.const 21))
+    )
+  )
+  (func (export "as-block-last-value") (param i32) (result i32)
+    (block (result i32)
+      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
+    (i32.const 4)
+  )
+  (func (export "as-loop-last") (param i32)
+    (loop (call $dummy) (br_if 1 (local.get 0)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
+      (i32.const 4)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
+      (i32.const 4)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
+    )
+  )
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32)
+    (block
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32)
+    (block
+      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (block (result i32)
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-select-second") (param i32) (result i32)
+    (block (result i32)
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10)))
+    )
+  )
+
+ (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (func $func (param i32 i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (br_if 0 (i32.const 4) (i32.const 10))
+        (i32.const 1) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (block (result i32)
+      (local.tee 0 (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (block (result i32)
+      (global.set $a (br_if 0 (i32.const 1) (local.get 0)))
+      (return (i32.const -1))
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result i32)
+    (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
+  )
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (i32.add
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0)))
+            (i32.const 16)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        ))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
+          )
+          (i32.const 1)
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0
+          (i32.const 4)
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-block-last" (i32.const 0)))
+(assert_return (invoke "as-block-last" (i32.const 1)))
+
+(assert_return (invoke "as-block-first-value" (i32.const 0)) (i32.const 11))
+(assert_return (invoke "as-block-first-value" (i32.const 1)) (i32.const 10))
+(assert_return (invoke "as-block-mid-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "as-block-mid-value" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11))
+(assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "as-loop-last" (i32.const 0)))
+(assert_return (invoke "as-loop-last" (i32.const 1)))
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 1))
+
+(assert_return (invoke "as-return-value") (i64.const 1))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-if-cond" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0)))
+(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0)))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 0)))
+(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 0)))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1)))
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-cond") (i32.const 3))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 4))
+(assert_return (invoke "as-call_indirect-first") (i32.const 4))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 4))
+(assert_return (invoke "as-call_indirect-last") (i32.const 4))
+
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 17))
+
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-address") (i32.const 1))
+(assert_return (invoke "as-loadN-address") (i32.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f64.const 1.0))
+(assert_return (invoke "as-binary-left") (i32.const 1))
+(assert_return (invoke "as-binary-right") (i32.const 1))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 5))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 9))
+
+(assert_invalid
+  (module (func $type-false-i32 (block (i32.ctz (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-i64 (block (i64.ctz (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-f32 (block (f32.neg (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-f64 (block (f64.neg (br_if 0 (i32.const 0))))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-true-i32 (block (i32.ctz (br_if 0 (i32.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-i64 (block (i64.ctz (br_if 0 (i64.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-f32 (block (f32.neg (br_if 0 (f32.const 1))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-f64 (block (f64.neg (br_if 0 (i64.const 1))))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-num-vs-void
+    (block (br_if 0 (i32.const 0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-false-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-void-vs-num (result i32)
+    (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-false-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-true-arg-num-vs-num (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-cond-empty-vs-i32
+    (block (br_if 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cond-void-vs-i32
+    (block (br_if 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cond-num-vs-i32
+    (block (br_if 0 (i64.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-cond-void-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-cond-num-vs-i32 (result i32)
+    (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-1st-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-cond-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_if 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-cond-empty-in-return
+      (block (result i32)
+        (return (br_if 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module (func $unbound-label (br_if 1 (i32.const 1))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label (block (block (br_if 5 (i32.const 1))))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label (br_if 0x10000001 (i32.const 1))))
+  "unknown label"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_table.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_table.wast
new file mode 100644
index 0000000..b70c102
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/br_table.wast
@@ -0,0 +1,1668 @@
+;; Test `br_table` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_table 0 0 (i32.const 0)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
+  )
+
+  (func (export "empty") (param i32) (result i32)
+    (block (br_table 0 (local.get 0)) (return (i32.const 21)))
+    (i32.const 22)
+  )
+  (func (export "empty-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31)
+    )
+  )
+
+  (func (export "singleton") (param i32) (result i32)
+    (block
+      (block
+        (br_table 1 0 (local.get 0))
+        (return (i32.const 21))
+      )
+      (return (i32.const 20))
+    )
+    (i32.const 22)
+  )
+
+  (func (export "singleton-value") (param i32) (result i32)
+    (block (result i32)
+      (drop
+        (block (result i32)
+          (br_table 0 1 (i32.const 33) (local.get 0))
+          (return (i32.const 31))
+        )
+      )
+      (i32.const 32)
+    )
+  )
+
+  (func (export "multiple") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (block
+            (block
+              (br_table 3 2 1 0 4 (local.get 0))
+              (return (i32.const 99))
+            )
+            (return (i32.const 100))
+          )
+          (return (i32.const 101))
+        )
+        (return (i32.const 102))
+      )
+      (return (i32.const 103))
+    )
+    (i32.const 104)
+  )
+
+  (func (export "multiple-value") (param i32) (result i32)
+    (local i32)
+    (local.set 1 (block (result i32)
+      (local.set 1 (block (result i32)
+        (local.set 1 (block (result i32)
+          (local.set 1 (block (result i32)
+            (local.set 1 (block (result i32)
+              (br_table 3 2 1 0 4 (i32.const 200) (local.get 0))
+              (return (i32.add (local.get 1) (i32.const 99)))
+            ))
+            (return (i32.add (local.get 1) (i32.const 10)))
+          ))
+          (return (i32.add (local.get 1) (i32.const 11)))
+        ))
+        (return (i32.add (local.get 1) (i32.const 12)))
+      ))
+      (return (i32.add (local.get 1) (i32.const 13)))
+    ))
+    (i32.add (local.get 1) (i32.const 14))
+  )
+
+  (func (export "large") (param i32) (result i32)
+    (block
+      (block
+        (br_table
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          (local.get 0)
+        )
+        (return (i32.const -1))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+
+  (func (export "as-block-first")
+    (block (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0)))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32)
+      (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0))
+    )
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (br_table 1 1 1 (i32.const 4) (i32.const -1))
+      (i32.const 2)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_table 0 0 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0))))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_table 0 (i32.const 1))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_table 0 (i32.const 2) (i32.const 0))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (br_table 1 (i32.const 3) (i32.const 0)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (local.get 1))
+        (else (br_table 1 0 (i32.const 4) (i32.const 0)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1))
+      )
+    )
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1))
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (i32.const 2)
+        (br_table 0 (i32.const 23) (i32.const 1))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (result i32)
+    (local f32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 17) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32)
+      (global.set $a (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1)))
+      (i32.const -1)
+     )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0)))
+      (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10))
+    )
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64)
+      (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10))
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (i32.const -1))
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (i32.add
+            (i32.const 2)
+            (block (result i32)
+              (drop (i32.const 4))
+              (i32.add
+                (i32.const 8)
+                (br_table 0 1 2 (i32.const 16) (local.get 0))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0)))
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (drop
+                (br_if 0
+                  (br_table 0 1 2 (i32.const 8) (local.get 0))
+                  (i32.const 1)
+                )
+              )
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1))
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-loop-block") (param i32) (result i32)
+    (local.set 0
+      (loop (result i32)
+        (block
+          (br_table 1 0 0 (local.get 0))
+        )
+        (i32.const 0)
+      )
+    )
+    (loop (result i32)
+      (block
+        (br_table 0 1 1 (local.get 0))
+      )
+      (i32.const 3)
+    )
+  )
+
+  (func (export "meet-externref") (param i32) (param externref) (result externref)
+    (block $l1 (result externref)
+      (block $l2 (result externref)
+        (br_table $l1 $l2 $l1 (local.get 1) (local.get 0))
+      )
+    )
+  )
+
+  ;; commenting this part out for now as it's a bit odd and we rely on wasmparser for
+  ;; wasm validation. Not meeting this requirement is okay for now
+  ;; (func (export "meet-bottom")
+  ;;   (block (result f64)
+  ;;     (block (result f32)
+  ;;       (unreachable)
+  ;;       (br_table 0 1 1 (i32.const 1))
+  ;;     )
+  ;;     (drop)
+  ;;     (f64.const 0)
+  ;;   )
+  ;;   (drop)
+  ;; )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "empty" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 11)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -100)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22))
+
+(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20))
+
+(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103))
+(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102))
+(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101))
+(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100))
+(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104))
+
+(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213))
+(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212))
+(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211))
+(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210))
+(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214))
+
+(assert_return (invoke "large" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 101)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 10000)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 10001)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 20))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 21))
+(assert_return (invoke "as-call_indirect-last") (i32.const 22))
+(assert_return (invoke "as-call_indirect-func") (i32.const 23))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19))
+(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17))
+(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16))
+
+(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17))
+
+(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "meet-externref" (i32.const 0) (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "meet-externref" (i32.const 1) (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "meet-externref" (i32.const 2) (ref.extern 1)) (ref.extern 1))
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-empty-vs-num (result i32)
+    (block (br_table 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-num (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-arg-num
+    (block
+      (block (result f32)
+        (br_table 0 1 (f32.const 0) (i32.const 0))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func
+    (block (result i32)
+      (block (result i64)
+        (br_table 0 1 (i32.const 0) (i32.const 0))
+      )
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-index-void-vs-i32
+    (block (br_table 0 0 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-index-num-vs-i32
+    (block (br_table 0 (i64.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-void-vs-i32 (result i32)
+    (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-num-vs-i32 (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-return
+      (block (result i32)
+        (return (br_table 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-return
+      (block (result i32)
+        (return (br_table 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func (param i32) (result i32)
+      (loop (result i32)
+        (block (result i32)
+          (br_table 0 1 (i32.const 1) (local.get 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (param i32) (result i32)
+      (block (result i32)
+        (loop (result i32)
+          (br_table 0 1 (i32.const 1) (local.get 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result externref)
+    (block $l1 (result externref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
+        )
+      )
+      (ref.null extern)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $unbound-label
+    (block (br_table 2 1 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label
+    (block (br_table 0 0x10000001 0 (i32.const 1)))
+  ))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $unbound-label-default
+    (block (br_table 1 2 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label-default
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label-default
+    (block (br_table 0 0 0x10000001 (i32.const 1)))
+  ))
+  "unknown label"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/bulk.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/bulk.wast
new file mode 100644
index 0000000..5dcac72
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/bulk.wast
@@ -0,0 +1,351 @@
+;; segment syntax
+(module
+  (memory 1)
+  (data "foo"))
+
+(module
+  (table 3 funcref)
+  (elem funcref (ref.func 0) (ref.null func) (ref.func 1))
+  (func)
+  (func))
+
+;; memory.fill
+(module
+  (memory 1)
+
+  (func (export "fill") (param i32 i32 i32)
+    (memory.fill
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Basic fill test.
+(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0))
+
+;; Fill value is stored as a byte.
+(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa))
+
+;; Fill all of memory
+(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000))
+
+;; Out-of-bounds writes trap, and nothing is written
+(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0))
+
+;; Succeed when writing 0 bytes at the end of the region.
+(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.copy
+(module
+  (memory (data "\aa\bb\cc\dd"))
+
+  (func (export "copy") (param i32 i32 i32)
+    (memory.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4))
+
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+
+;; Copy ending at memory limit is ok.
+(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100))
+(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100))
+
+;; Succeed when copying 0 bytes at the end of the region.
+(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0))
+
+;; Copying 0 bytes outside the memory traps.
+(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.init
+(module
+  (memory 1)
+  (data "\aa\bb\cc\dd")
+
+  (func (export "init") (param i32 i32 i32)
+    (memory.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0))
+
+;; Init ending at memory limit and segment limit is ok.
+(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4))
+
+;; Out-of-bounds writes trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd))
+
+;; Succeed when writing 0 bytes at the end of either region.
+(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds memory access")
+
+;; data.drop
+(module
+  (memory 1)
+  (data $p "x")
+  (data $a (memory 0) (i32.const 0) "x")
+
+  (func (export "drop_passive") (data.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (memory.init $p (i32.const 0) (i32.const 0) (local.get $len)))
+
+  (func (export "drop_active") (data.drop $a))
+  (func (export "init_active") (param $len i32)
+    (memory.init $a (i32.const 0) (i32.const 0) (local.get $len)))
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds memory access")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds memory access")
+(invoke "init_active" (i32.const 0))
+
+;; Test that the data segment index is properly encoded as an unsigned (not
+;; signed) LEB.
+(module
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "")
+  (func (data.drop 64)))
+
+;; No memory is required for the data.drop instruction.
+(module (data "goodbye") (func (data.drop 0)))
+
+;; table.init
+(module
+  (table 3 funcref)
+  (elem funcref
+    (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one))
+
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+
+  (func (export "init") (param i32 i32 i32)
+    (table.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Out-of-bounds stores trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2))
+    "out of bounds table access")
+(assert_trap (invoke "call" (i32.const 2))
+    "uninitialized element 2")
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 0))
+(assert_trap (invoke "call" (i32.const 2)) "uninitialized element")
+
+;; Init ending at table limit and segment limit is ok.
+(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2))
+
+;; Succeed when storing 0 elements at the end of either region.
+(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 elements outside the table traps.
+(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0))
+    "out of bounds table access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds table access")
+
+
+;; elem.drop
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem $p funcref (ref.func $f))
+  (elem $a (table 0) (i32.const 0) func $f)
+
+  (func (export "drop_passive") (elem.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (table.init $p (i32.const 0) (i32.const 0) (local.get $len))
+  )
+
+  (func (export "drop_active") (elem.drop $a))
+  (func (export "init_active") (param $len i32)
+    (table.init $a (i32.const 0) (i32.const 0) (local.get $len))
+  )
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds table access")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds table access")
+(invoke "init_active" (i32.const 0))
+
+;; Test that the elem segment index is properly encoded as an unsigned (not
+;; signed) LEB.
+(module
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (elem.drop 64)))
+
+;; No table is required for the elem.drop instruction.
+(module (elem funcref (ref.func 0)) (func (elem.drop 0)))
+
+;; table.copy
+(module
+  (table 10 funcref)
+  (elem (i32.const 0) $zero $one $two)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $two (result i32) (i32.const 2))
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3))
+;; Now [$zero, $one, $two, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 5)) (i32.const 2))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3))
+;; Now [$one, $two, $zero, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 0))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3))
+;; Now [$one, $two, $one, $two, $zero, $two, ...]
+(assert_return (invoke "call" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 0))
+
+;; Copy ending at table limit is ok.
+(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2))
+(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2))
+
+;; Succeed when copying 0 elements at the end of the region.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0))
+
+;; Fail on out-of-bounds when copying 0 elements outside of table.
+(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0))
+  "out of bounds table access")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0))
+  "out of bounds table access")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call.wast
new file mode 100644
index 0000000..e4f854f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call.wast
@@ -0,0 +1,518 @@
+;; Test `call` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+  (func $const-i32-i64 (result i32 i64) (i32.const 0x132) (i64.const 0x164))
+
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+  (func $id-i32-f64 (param i32 f64) (result i32 f64)
+    (local.get 0) (local.get 1)
+  )
+
+  (func $swap-i32-i32 (param i32 i32) (result i32 i32)
+    (local.get 1) (local.get 0)
+  )
+  (func $swap-f32-f64 (param f32 f64) (result f64 f32)
+    (local.get 1) (local.get 0)
+  )
+  (func $swap-f64-i32 (param f64 i32) (result i32 f64)
+    (local.get 1) (local.get 0)
+  )
+
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32) (call $const-i32))
+  (func (export "type-i64") (result i64) (call $const-i64))
+  (func (export "type-f32") (result f32) (call $const-f32))
+  (func (export "type-f64") (result f64) (call $const-f64))
+  (func (export "type-i32-i64") (result i32 i64) (call $const-i32-i64))
+
+  (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32)))
+  (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64)))
+  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
+  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64)))
+
+  (func (export "type-second-i32") (result i32)
+    (call $f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call $i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call $f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call $i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call $id-i32-f64 (i32.const 32) (f64.const 1.64))
+  )
+  (func (export "type-all-i32-i32") (result i32 i32)
+    (call $swap-i32-i32 (i32.const 1) (i32.const 2))
+  )
+  (func (export "type-all-f32-f64") (result f64 f32)
+    (call $swap-f32-f64 (f32.const 1) (f64.const 2))
+  )
+  (func (export "type-all-f64-i32") (result i32 f64)
+    (call $swap-f64-i32 (f64.const 1) (i32.const 2))
+  )
+
+  ;; Composition
+
+  (func (export "as-binary-all-operands") (result i32)
+    (i32.add (call $swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  (func (export "as-mixed-operands") (result i32)
+    (call $swap-i32-i32 (i32.const 3) (i32.const 4))
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "as-call-all-operands") (result i32 i32)
+    (call $swap-i32-i32 (call $swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  ;; Recursion
+
+  (func $fac (export "fac") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call $fac (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (call $fac-acc
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+        )
+      )
+    )
+  )
+
+  (func $fib (export "fib") (param i64) (result i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call $fib (i64.sub (local.get 0) (i64.const 2)))
+          (call $fib (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 44))
+      (else (call $odd (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+  (func $odd (export "odd") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 99))
+      (else (call $even (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $runaway (export "runaway") (call $runaway))
+
+  (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2))
+  (func $mutual-runaway2 (call $mutual-runaway1))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call $const-i32) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call $const-i32) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call $const-i32))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (call $const-i32) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call $const-i32)))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (call $const-i32) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (call $const-i32) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (call $const-i32)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (call $const-i32) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call $const-i32) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call $const-i32))
+  )
+  (func (export "as-return-value") (result i32)
+    (call $const-i32) (return)
+  )
+  (func (export "as-drop-operand")
+    (call $const-i32) (drop)
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (call $const-i32)))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (call $const-i32)) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (call $const-i32))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (call $const-i32))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call $const-i32))
+  )
+
+  (func $dummy (param i32) (result i32) (local.get 0))
+  (func $du (param f32) (result f32) (local.get 0))
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64) (i64.extend_i32_s (call $dummy (i32.const 1))))
+  )
+
+  ;; Test correct argument passing
+
+  (func $return-from-long-argument-list-helper (param f32 i32 i32 f64 f32 f32 f32 f64 f32 i32 i32 f32 f64 i64 i64 i32 i64 i64 f32 i64 i64 i64 i32 f32 f32 f32 f64 f32 i32 i64 f32 f64 f64 f32 i32 f32 f32 f64 i64 f64 i32 i64 f32 f64 i32 i32 i32 i64 f64 i32 i64 i64 f64 f64 f64 f64 f64 f64 i32 f32 f64 f64 i32 i64 f32 f32 f32 i32 f64 f64 f64 f64 f64 f32 i64 i64 i32 i32 i32 f32 f64 i32 i64 f32 f32 f32 i32 i32 f32 f64 i64 f32 f64 f32 f32 f32 i32 f32 i64 i32) (result i32)
+    (local.get 99)
+  )
+
+  (func (export "return-from-long-argument-list") (param i32) (result i32)
+    (call $return-from-long-argument-list-helper (f32.const 0) (i32.const 0) (i32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (i64.const 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+(assert_return (invoke "type-i32-i64") (i32.const 0x132) (i64.const 0x164))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "type-all-i32-f64") (i32.const 32) (f64.const 1.64))
+(assert_return (invoke "type-all-i32-i32") (i32.const 2) (i32.const 1))
+(assert_return (invoke "type-all-f32-f64") (f64.const 2) (f32.const 1))
+(assert_return (invoke "type-all-f64-i32") (i32.const 2) (f64.const 1))
+
+(assert_return (invoke "as-binary-all-operands") (i32.const 7))
+(assert_return (invoke "as-mixed-operands") (i32.const 32))
+(assert_return (invoke "as-call-all-operands") (i32.const 3) (i32.const 4))
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
+
+(assert_exhaustion (invoke "runaway") "call stack exhausted")
+(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
+
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i32.const 0x132))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 0x132))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 0x132))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 0x132))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 0x132))
+(assert_return (invoke "as-local.set-value") (i32.const 0x132))
+(assert_return (invoke "as-local.tee-value") (i32.const 0x132))
+(assert_return (invoke "as-global.set-value") (i32.const 0x132))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
+(assert_return (invoke "return-from-long-argument-list" (i32.const 42)) (i32.const 42))
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (func $type-void-vs-num (i32.eqz (call 1)))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-num-vs-num (i32.eqz (call 1)))
+    (func (result i64) (i64.const 1))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-0-vs-1 (call 1))
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-0-vs-2 (call 1))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-1-vs-0 (call 1 (i32.const 1)))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1)))
+    (func)
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-first-void-vs-num (call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-void-vs-num (call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-first-empty-in-block
+      (block (call 1))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-block
+      (block (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-empty-in-loop
+      (loop (call 1))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-loop
+      (loop (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-empty-in-then
+      (if (i32.const 0) (then (call 1)))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-then
+      (if (i32.const 0) (then (call 1 (i32.const 0))))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+
+
+;; Unbound function
+
+(assert_invalid
+  (module (func $unbound-func (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $large-func (call 1012321300)))
+  "unknown function"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call_indirect.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call_indirect.wast
new file mode 100644
index 0000000..1ecd9b7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/call_indirect.wast
@@ -0,0 +1,1017 @@
+;; Test `call_indirect` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $out-i32 (func (result i32)))
+  (type $out-i64 (func (result i64)))
+  (type $out-f32 (func (result f32)))
+  (type $out-f64 (func (result f64)))
+  (type $out-f64-i32 (func (result f64 i32)))
+  (type $over-i32 (func (param i32) (result i32)))
+  (type $over-i64 (func (param i64) (result i64)))
+  (type $over-f32 (func (param f32) (result f32)))
+  (type $over-f64 (func (param f64) (result f64)))
+  (type $over-i32-f64 (func (param i32 f64) (result i32 f64)))
+  (type $swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+  (type $over-i32-duplicate (func (param i32) (result i32)))
+  (type $over-i64-duplicate (func (param i64) (result i64)))
+  (type $over-f32-duplicate (func (param f32) (result f32)))
+  (type $over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+  (func $const-i64 (type $out-i64) (i64.const 0x164))
+  (func $const-f32 (type $out-f32) (f32.const 0xf32))
+  (func $const-f64 (type $out-f64) (f64.const 0xf64))
+  (func $const-f64-i32 (type $out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+  (func $id-i32 (type $over-i32) (local.get 0))
+  (func $id-i64 (type $over-i64) (local.get 0))
+  (func $id-f32 (type $over-f32) (local.get 0))
+  (func $id-f64 (type $over-f64) (local.get 0))
+  (func $id-i32-f64 (type $over-i32-f64) (local.get 0) (local.get 1))
+  (func $swap-i32-i64 (type $swap-i32-i64) (local.get 1) (local.get 0))
+
+  (func $i32-i64 (type $i32-i64) (local.get 1))
+  (func $i64-f64 (type $i64-f64) (local.get 1))
+  (func $f32-i32 (type $f32-i32) (local.get 1))
+  (func $f64-f32 (type $f64-f32) (local.get 1))
+
+  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
+  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
+  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
+  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $const-i32 $const-i64 $const-f32 $const-f64  ;; 0..3
+      $id-i32 $id-i64 $id-f32 $id-f64              ;; 4..7
+      $f32-i32 $i32-i64 $f64-f32 $i64-f64          ;; 9..11
+      $fac-i64 $fib-i64 $even $odd                 ;; 12..15
+      $runaway $mutual-runaway1 $mutual-runaway2   ;; 16..18
+      $over-i32-duplicate $over-i64-duplicate      ;; 19..20
+      $over-f32-duplicate $over-f64-duplicate      ;; 21..22
+      $fac-i32 $fac-f32 $fac-f64                   ;; 23..25
+      $fib-i32 $fib-f32 $fib-f64                   ;; 26..28
+      $const-f64-i32 $id-i32-f64 $swap-i32-i64     ;; 29..31
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $out-f64) (i32.const 3))
+  )
+  (func (export "type-f64-i32") (result f64 i32)
+    (call_indirect (type $out-f64-i32) (i32.const 29))
+  )
+
+  (func (export "type-index") (result i64)
+    (call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+  )
+
+  (func (export "type-all-f64-i32") (result f64 i32)
+    (call_indirect (type $out-f64-i32) (i32.const 29))
+  )
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call_indirect (type $over-i32-f64)
+      (i32.const 1) (f64.const 2) (i32.const 30)
+    )
+  )
+  (func (export "type-all-i32-i64") (result i64 i32)
+    (call_indirect (type $swap-i32-i64)
+      (i32.const 1) (i64.const 2) (i32.const 31)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (call_indirect (type $over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
+    (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0))
+  )
+
+  ;; Recursion
+
+  (func $fac-i64 (export "fac-i64") (type $over-i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 12)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-i64 (export "fib-i64") (type $over-i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 13)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-i32 (export "fac-i32") (type $over-i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (local.get 0)
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f32 (export "fac-f32") (type $over-f32)
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (local.get 0)
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f64 (export "fac-f64") (type $over-f64)
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (local.get 0)
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-i32 (export "fib-i32") (type $over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f32 (export "fib-f32") (type $over-f32)
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f64 (export "fib-f64") (type $over-f64)
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16)))
+
+  (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18)))
+  (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $a (mut f64) (f64.const 10.0))
+  (func (export "as-global.set-value") (result f64)
+    (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_i32_s
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+(assert_return (invoke "type-f64-i32") (f64.const 0xf64) (i32.const 32))
+
+(assert_return (invoke "type-index") (i64.const 100))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "type-all-f64-i32") (f64.const 0xf64) (i32.const 32))
+(assert_return (invoke "type-all-i32-f64") (i32.const 1) (f64.const 2))
+(assert_return (invoke "type-all-i32-i64") (i64.const 2) (i32.const 1))
+
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
+(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
+(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
+(assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2))
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 32) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
+
+(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 20)) (i64.const 9))
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 22)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 23)) (i32.const 362880))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 26)) (i32.const 55))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 9)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 21)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 24)) (f32.const 362880.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 27)) (f32.const 55.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 21)) (f32.const 9.0))
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 25)) (f64.const 362880.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 28)) (f64.const 55.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 22)) (f64.const 9.0))
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch")
+
+(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120))
+(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800))
+
+(assert_return (invoke "fac-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 5.0)) (f32.const 120.0))
+(assert_return (invoke "fac-f32" (f32.const 10.0)) (f32.const 3628800.0))
+
+(assert_return (invoke "fac-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 5.0)) (f64.const 120.0))
+(assert_return (invoke "fac-f64" (f64.const 10.0)) (f64.const 3628800.0))
+
+(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8))
+(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946))
+
+(assert_return (invoke "fib-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 2.0)) (f32.const 2.0))
+(assert_return (invoke "fib-f32" (f32.const 5.0)) (f32.const 8.0))
+(assert_return (invoke "fib-f32" (f32.const 20.0)) (f32.const 10946.0))
+
+(assert_return (invoke "fib-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 2.0)) (f64.const 2.0))
+(assert_return (invoke "fib-f64" (f64.const 5.0)) (f64.const 8.0))
+(assert_return (invoke "fib-f64" (f64.const 20.0)) (f64.const 10946.0))
+
+(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
+
+(assert_exhaustion (invoke "runaway") "call stack exhausted")
+(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
+
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i64.const 0x164))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (f32.const 0xf32))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (f32.const 1))
+(assert_return (invoke "as-local.set-value") (f64.const 1))
+(assert_return (invoke "as-local.tee-value") (f64.const 1))
+(assert_return (invoke "as-global.set-value") (f64.const 1.0))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
+
+;; Multiple tables
+
+(module
+  (type $ii-i (func (param i32 i32) (result i32)))
+
+  (table $t1 funcref (elem $f $g))
+  (table $t2 funcref (elem $h $i $j))
+  (table $t3 4 funcref)
+  (elem (table $t3) (i32.const 0) func $g $h)
+  (elem (table $t3) (i32.const 3) func $z)
+
+  (func $f (type $ii-i) (i32.add (local.get 0) (local.get 1)))
+  (func $g (type $ii-i) (i32.sub (local.get 0) (local.get 1)))
+  (func $h (type $ii-i) (i32.mul (local.get 0) (local.get 1)))
+  (func $i (type $ii-i) (i32.div_u (local.get 0) (local.get 1)))
+  (func $j (type $ii-i) (i32.rem_u (local.get 0) (local.get 1)))
+  (func $z)
+
+  (func (export "call-1") (param i32 i32 i32) (result i32)
+    (call_indirect $t1 (type $ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-2") (param i32 i32 i32) (result i32)
+    (call_indirect $t2 (type $ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "call-3") (param i32 i32 i32) (result i32)
+    (call_indirect $t3 (type $ii-i) (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+
+(assert_return (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 5))
+(assert_return (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const -1))
+(assert_trap (invoke "call-1" (i32.const 2) (i32.const 3) (i32.const 2)) "undefined element")
+
+(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 6))
+(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 2)) (i32.const 2))
+(assert_trap (invoke "call-2" (i32.const 2) (i32.const 3) (i32.const 3)) "undefined element")
+
+(assert_return (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const -1))
+(assert_return (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 1)) (i32.const 6))
+(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 3)) "indirect call type mismatch")
+(assert_trap (invoke "call-3" (i32.const 2) (i32.const 3) (i32.const 4)) "undefined element")
+
+
+;; Invalid syntax
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (type $sig) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (result i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func"
+    "  (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (param i32) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (type (func))
+    (func $no-table (call_indirect (type 0) (i32.const 0)))
+  )
+  "unknown table"
+)
+
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $arity-2-vs-0
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-first-void-vs-num
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-second-void-vs-num
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $type-first-num-vs-num
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $type-second-num-vs-num
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-block
+      (block
+        (call_indirect (type $sig) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-block
+      (block
+        (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-loop
+      (loop
+        (call_indirect (type $sig) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-loop
+      (loop
+        (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $sig) (i32.const 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Unbound type
+
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $unbound-type (call_indirect (type 1) (i32.const 0)))
+  )
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $large-type (call_indirect (type 1012321300) (i32.const 0)))
+  )
+  "unknown type"
+)
+
+
+;; Unbound function in table
+
+(assert_invalid
+  (module (table funcref (elem 0 0)))
+  "unknown function"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/comments.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/comments.wast
new file mode 100644
index 0000000..90a64b4
Binary files /dev/null and b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/comments.wast differ
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/const.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/const.wast
new file mode 100644
index 0000000..5656502
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/const.wast
@@ -0,0 +1,1061 @@
+;; Test t.const instructions
+
+;; Syntax error
+
+(module (func (i32.const 0_123_456_789) drop))
+(module (func (i32.const 0x0_9acf_fBDF) drop))
+(assert_malformed
+  (module quote "(func (i32.const) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (i32.const 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (i32.const 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (i32.const 0xg) drop)")
+  "unknown operator"
+)
+
+(module (func (i64.const 0_123_456_789) drop))
+(module (func (i64.const 0x0125_6789_ADEF_bcef) drop))
+(assert_malformed
+  (module quote "(func (i64.const) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (i64.const 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (i64.const 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (i64.const 0xg) drop)")
+  "unknown operator"
+)
+
+(module (func (f32.const 0123456789) drop))
+(module (func (f32.const 0123456789e019) drop))
+(module (func (f32.const 0123456789e+019) drop))
+(module (func (f32.const 0123456789e-019) drop))
+(module (func (f32.const 0123456789.) drop))
+(module (func (f32.const 0123456789.e019) drop))
+(module (func (f32.const 0123456789.e+019) drop))
+(module (func (f32.const 0123456789.e-019) drop))
+(module (func (f32.const 0123456789.0123456789) drop))
+(module (func (f32.const 0123456789.0123456789e019) drop))
+(module (func (f32.const 0123456789.0123456789e+019) drop))
+(module (func (f32.const 0123456789.0123456789e-019) drop))
+(module (func (f32.const 0x0123456789ABCDEF) drop))
+(module (func (f32.const 0x0123456789ABCDEFp019) drop))
+(module (func (f32.const 0x0123456789ABCDEFp+019) drop))
+(module (func (f32.const 0x0123456789ABCDEFp-019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.) drop))
+(module (func (f32.const 0x0123456789ABCDEF.p019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.p+019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.p-019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.019aF) drop))
+(module (func (f32.const 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (f32.const 0x0123456789ABCDEF.019aFp-019) drop))
+(assert_malformed
+  (module quote "(func (f32.const) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (f32.const .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x0pA) drop)")
+  "unknown operator"
+)
+
+
+(module (func (f64.const 0123456789) drop))
+(module (func (f64.const 0123456789e019) drop))
+(module (func (f64.const 0123456789e+019) drop))
+(module (func (f64.const 0123456789e-019) drop))
+(module (func (f64.const 0123456789.) drop))
+(module (func (f64.const 0123456789.e019) drop))
+(module (func (f64.const 0123456789.e+019) drop))
+(module (func (f64.const 0123456789.e-019) drop))
+(module (func (f64.const 0123456789.0123456789) drop))
+(module (func (f64.const 0123456789.0123456789e019) drop))
+(module (func (f64.const 0123456789.0123456789e+019) drop))
+(module (func (f64.const 0123456789.0123456789e-019) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9e+0_1_9) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.e+0_1_9) drop))
+(module (func (f64.const 0_1_2_3_4_5_6_7_8_9.0_1_2_3_4_5_6_7_8_9e0_1_9) drop))
+
+(module (func (f64.const 0x0123456789ABCDEFabcdef) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (f64.const 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.p0_1_9) drop))
+(module (func (f64.const 0x0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_f.0_1_2_3_4_5_6_7_8_9_A_B_C_D_E_F_a_b_c_d_e_fp0_1_9) drop))
+
+
+(assert_malformed
+  (module quote "(func (f64.const) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (f64.const .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x0pA) drop)")
+  "unknown operator"
+)
+
+
+;; Range error
+
+(module (func (i32.const 0xffffffff) drop))
+(module (func (i32.const -0x80000000) drop))
+(assert_malformed
+  (module quote "(func (i32.const 0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i32.const -0x80000001) drop)")
+  "constant out of range"
+)
+
+(module (func (i32.const 4294967295) drop))
+(module (func (i32.const -2147483648) drop))
+(assert_malformed
+  (module quote "(func (i32.const 4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i32.const -2147483649) drop)")
+  "constant out of range"
+)
+
+(module (func (i64.const 0xffffffffffffffff) drop))
+(module (func (i64.const -0x8000000000000000) drop))
+(assert_malformed
+  (module quote "(func (i64.const 0x10000000000000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i64.const -0x8000000000000001) drop)")
+  "constant out of range"
+)
+
+(module (func (i64.const 18446744073709551615) drop))
+(module (func (i64.const -9223372036854775808) drop))
+(assert_malformed
+  (module quote "(func (i64.const 18446744073709551616) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i64.const -9223372036854775809) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const 0x1p127) drop))
+(module (func (f32.const -0x1p127) drop))
+(module (func (f32.const 0x1.fffffep127) drop))
+(module (func (f32.const -0x1.fffffep127) drop))
+(module (func (f32.const 0x1.fffffe7p127) drop))
+(module (func (f32.const -0x1.fffffe7p127) drop))
+(module (func (f32.const 0x1.fffffefffffff8000000p127) drop))
+(module (func (f32.const -0x1.fffffefffffff8000000p127) drop))
+(module (func (f32.const 0x1.fffffefffffffffffffp127) drop))
+(module (func (f32.const -0x1.fffffefffffffffffffp127) drop))
+(assert_malformed
+  (module quote "(func (f32.const 0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x1.ffffffp127) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -0x1.ffffffp127) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const 1e38) drop))
+(module (func (f32.const -1e38) drop))
+(assert_malformed
+  (module quote "(func (f32.const 1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -1e39) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const 340282356779733623858607532500980858880) drop))
+(module (func (f32.const -340282356779733623858607532500980858880) drop))
+(assert_malformed
+  (module quote "(func (f32.const 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 0x1p1023) drop))
+(module (func (f64.const -0x1p1023) drop))
+(module (func (f64.const 0x1.fffffffffffffp1023) drop))
+(module (func (f64.const -0x1.fffffffffffffp1023) drop))
+(module (func (f64.const 0x1.fffffffffffff7p1023) drop))
+(module (func (f64.const -0x1.fffffffffffff7p1023) drop))
+(module (func (f64.const 0x1.fffffffffffff7ffffffp1023) drop))
+(module (func (f64.const -0x1.fffffffffffff7ffffffp1023) drop))
+(assert_malformed
+  (module quote "(func (f64.const 0x1p1024) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -0x1p1024) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x1.fffffffffffff8p1023) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -0x1.fffffffffffff8p1023) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 1e308) drop))
+(module (func (f64.const -1e308) drop))
+(assert_malformed
+  (module quote "(func (f64.const 1e309) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -1e309) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (f64.const -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(assert_malformed
+  (module quote "(func (f64.const 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const nan:0x1) drop))
+(module (func (f64.const nan:0x1) drop))
+(module (func (f32.const nan:0x7f_ffff) drop))
+(module (func (f64.const nan:0xf_ffff_ffff_ffff) drop))
+
+(assert_malformed
+  (module quote "(func (f32.const nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (f64.const nan:1) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (f32.const nan:0x0) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (f32.const nan:0x80_0000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+
+;; Rounding behaviour
+
+;; f32, small exponent
+(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (f32.const +0x1.000006p-50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (f32.const -0x1.000006p-50))
+
+(module (func (export "f") (result f32) (f32.const +0x4000.004000000p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.004000000p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.004000001p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.004000001p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.007ffffffp-64)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.007ffffffp-64)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.008000000p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.008000000p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.008000001p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.008000001p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.00bffffffp-64)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.00bffffffp-64)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.00c000000p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.00c000000p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.00c000001p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.00c000001p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.00fffffffp-64)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.00fffffffp-64)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.010000001p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.010000001p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.013ffffffp-64)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.013ffffffp-64)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const +0x4000.014000001p-64)))
+(assert_return (invoke "f") (f32.const +0x1.000006p-50))
+(module (func (export "f") (result f32) (f32.const -0x4000.014000001p-64)))
+(assert_return (invoke "f") (f32.const -0x1.000006p-50))
+
+(module (func (export "f") (result f32) (f32.const +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (f32.const +0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (f32.const -0x1.000000p-50))
+(module (func (export "f") (result f32) (f32.const +8.8817847263968443574e-16)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -8.8817847263968443574e-16)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +8.8817857851880284252e-16)))
+(assert_return (invoke "f") (f32.const +0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const -8.8817857851880284252e-16)))
+(assert_return (invoke "f") (f32.const -0x1.000002p-50))
+(module (func (export "f") (result f32) (f32.const +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (f32.const +0x1.000004p-50))
+(module (func (export "f") (result f32) (f32.const -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (f32.const -0x1.000004p-50))
+
+;; f32, large exponent
+(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (f32.const +0x1.000006p+50))
+(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (f32.const -0x1.000006p+50))
+
+(module (func (export "f") (result f32) (f32.const +0x4000004000000)))
+(assert_return (invoke "f") (f32.const +0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const -0x4000004000000)))
+(assert_return (invoke "f") (f32.const -0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const +0x4000004000001)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x4000004000001)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x4000007ffffff)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x4000007ffffff)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x4000008000000)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x4000008000000)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x4000008000001)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x4000008000001)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x400000bffffff)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -0x400000bffffff)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +0x400000c000000)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -0x400000c000000)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+
+(module (func (export "f") (result f32) (f32.const +1125899973951488)))
+(assert_return (invoke "f") (f32.const +0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const -1125899973951488)))
+(assert_return (invoke "f") (f32.const -0x1.000000p+50))
+(module (func (export "f") (result f32) (f32.const +1125899973951489)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -1125899973951489)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +1125900108169215)))
+(assert_return (invoke "f") (f32.const +0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const -1125900108169215)))
+(assert_return (invoke "f") (f32.const -0x1.000002p+50))
+(module (func (export "f") (result f32) (f32.const +1125900108169216)))
+(assert_return (invoke "f") (f32.const +0x1.000004p+50))
+(module (func (export "f") (result f32) (f32.const -1125900108169216)))
+(assert_return (invoke "f") (f32.const -0x1.000004p+50))
+
+;; f32, subnormal
+(module (func (export "f") (result f32) (f32.const +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000000p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000000p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000100000000001p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000100000000001p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.000001fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const +0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.000001fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const -0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000200000000000p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000200000000000p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000200000000001p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000200000000001p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.000002fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const +0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.000002fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const -0x0.000002p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000300000000000p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000300000000000p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000300000000001p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000300000000001p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.000003fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.000003fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000400000000000p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000400000000000p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000400000000001p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000400000000001p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.000004fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.000004fffffffffffp-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000500000000000p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000500000000000p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000004p-126))
+(module (func (export "f") (result f32) (f32.const +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (f32.const +0x0.000006p-126))
+(module (func (export "f") (result f32) (f32.const -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (f32.const -0x0.000006p-126))
+
+;; f32, round down at limit to infinity
+(module (func (export "f") (result f32) (f32.const +0x1.fffffe8p127)))
+(assert_return (invoke "f") (f32.const +0x1.fffffep127))
+(module (func (export "f") (result f32) (f32.const -0x1.fffffe8p127)))
+(assert_return (invoke "f") (f32.const -0x1.fffffep127))
+(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffff8p127)))
+(assert_return (invoke "f") (f32.const +0x1.fffffep127))
+(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffff8p127)))
+(assert_return (invoke "f") (f32.const -0x1.fffffep127))
+(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (f32.const +0x1.fffffep127))
+(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (f32.const -0x1.fffffep127))
+
+;; f64, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p+600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p+600))
+
+(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000000)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000000)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000001)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000001)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000000)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000000)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000001)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000001)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000000)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000000)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000001)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000001)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000000)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000000)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000001)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000001)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000000)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000000)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
+(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000001)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p+97))
+(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000001)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p+97))
+
+(module (func (export "f") (result f64) (f64.const +1152921504606847104)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+60))
+(module (func (export "f") (result f64) (f64.const -1152921504606847104)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+60))
+(module (func (export "f") (result f64) (f64.const +1152921504606847105)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60))
+(module (func (export "f") (result f64) (f64.const -1152921504606847105)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60))
+(module (func (export "f") (result f64) (f64.const +1152921504606847359)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60))
+(module (func (export "f") (result f64) (f64.const -1152921504606847359)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60))
+(module (func (export "f") (result f64) (f64.const +1152921504606847360)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+60))
+(module (func (export "f") (result f64) (f64.const -1152921504606847360)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+60))
+
+;; f64, subnormal
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000000p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000000p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-1022))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-1022))
+
+;; f64, round down at limit to infinity
+(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023))
+(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023))
+(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023))
+(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/conversions.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/conversions.wast
new file mode 100644
index 0000000..65d0933
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/conversions.wast
@@ -0,0 +1,702 @@
+(module
+  (func (export "i64.extend_i32_s") (param $x i32) (result i64) (i64.extend_i32_s (local.get $x)))
+  (func (export "i64.extend_i32_u") (param $x i32) (result i64) (i64.extend_i32_u (local.get $x)))
+  (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap_i64 (local.get $x)))
+  (func (export "i32.trunc_f32_s") (param $x f32) (result i32) (i32.trunc_f32_s (local.get $x)))
+  (func (export "i32.trunc_f32_u") (param $x f32) (result i32) (i32.trunc_f32_u (local.get $x)))
+  (func (export "i32.trunc_f64_s") (param $x f64) (result i32) (i32.trunc_f64_s (local.get $x)))
+  (func (export "i32.trunc_f64_u") (param $x f64) (result i32) (i32.trunc_f64_u (local.get $x)))
+  (func (export "i64.trunc_f32_s") (param $x f32) (result i64) (i64.trunc_f32_s (local.get $x)))
+  (func (export "i64.trunc_f32_u") (param $x f32) (result i64) (i64.trunc_f32_u (local.get $x)))
+  (func (export "i64.trunc_f64_s") (param $x f64) (result i64) (i64.trunc_f64_s (local.get $x)))
+  (func (export "i64.trunc_f64_u") (param $x f64) (result i64) (i64.trunc_f64_u (local.get $x)))
+  (func (export "i32.trunc_sat_f32_s") (param $x f32) (result i32) (i32.trunc_sat_f32_s (local.get $x)))
+  (func (export "i32.trunc_sat_f32_u") (param $x f32) (result i32) (i32.trunc_sat_f32_u (local.get $x)))
+  (func (export "i32.trunc_sat_f64_s") (param $x f64) (result i32) (i32.trunc_sat_f64_s (local.get $x)))
+  (func (export "i32.trunc_sat_f64_u") (param $x f64) (result i32) (i32.trunc_sat_f64_u (local.get $x)))
+  (func (export "i64.trunc_sat_f32_s") (param $x f32) (result i64) (i64.trunc_sat_f32_s (local.get $x)))
+  (func (export "i64.trunc_sat_f32_u") (param $x f32) (result i64) (i64.trunc_sat_f32_u (local.get $x)))
+  (func (export "i64.trunc_sat_f64_s") (param $x f64) (result i64) (i64.trunc_sat_f64_s (local.get $x)))
+  (func (export "i64.trunc_sat_f64_u") (param $x f64) (result i64) (i64.trunc_sat_f64_u (local.get $x)))
+  (func (export "f32.convert_i32_s") (param $x i32) (result f32) (f32.convert_i32_s (local.get $x)))
+  (func (export "f32.convert_i64_s") (param $x i64) (result f32) (f32.convert_i64_s (local.get $x)))
+  (func (export "f64.convert_i32_s") (param $x i32) (result f64) (f64.convert_i32_s (local.get $x)))
+  (func (export "f64.convert_i64_s") (param $x i64) (result f64) (f64.convert_i64_s (local.get $x)))
+  (func (export "f32.convert_i32_u") (param $x i32) (result f32) (f32.convert_i32_u (local.get $x)))
+  (func (export "f32.convert_i64_u") (param $x i64) (result f32) (f32.convert_i64_u (local.get $x)))
+  (func (export "f64.convert_i32_u") (param $x i32) (result f64) (f64.convert_i32_u (local.get $x)))
+  (func (export "f64.convert_i64_u") (param $x i64) (result f64) (f64.convert_i64_u (local.get $x)))
+  (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote_f32 (local.get $x)))
+  (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote_f64 (local.get $x)))
+  (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret_i32 (local.get $x)))
+  (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret_i64 (local.get $x)))
+  (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret_f32 (local.get $x)))
+  (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret_f64 (local.get $x)))
+)
+
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -10000)) (i64.const -10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -1)) (i64.const -1))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
+
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -1)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
+
+(assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1))
+(assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0))
+(assert_return (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001))
+
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648))
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -2147483904.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 4294967040.0)) (i32.const -256))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0))
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.9)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const  2147483647.9)) (i32.const  2147483647))
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -2147483649.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1e8)) (i32.const 100000000))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.9)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.9)) (i32.const 4294967295))
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e16)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e30)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 9223372036854775808)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -9223373136366403584.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 4294967296)) (i64.const 4294967296))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0))
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -9223372036854777856.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967296)) (i64.const 0x100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e8)) (i64.const 100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e16)) (i64.const 10000000000000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -2147483648)) (f32.const -2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
+
+;; Saturating conversions: test all the same values as the non-saturating conversions.
+
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483648.0)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483904.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const inf)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -inf)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967040.0)) (i32.const -256))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967296.0)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -1.0)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const inf)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -inf)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483648.0)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483649.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const inf)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -inf)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967295.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e8)) (i32.const 100000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967296.0)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -1.0)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e16)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e30)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const inf)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -inf)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i32.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223373136366403584.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const inf)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -inf)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan:0x200000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 4294967296)) (i64.const 4294967296))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -1.0)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const inf)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -inf)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan:0x200000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854777856.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const inf)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -inf)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967296)) (i64.const 0x100000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e8)) (i64.const 100000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e16)) (i64.const 10000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -1.0)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const inf)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -inf)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i64.const 0))
+
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777219)) (f32.const -16777220.0))
+
+(assert_return (invoke "f32.convert_i64_s" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777219)) (f32.const -16777220.0))
+
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x7fffff4000000001)) (f32.const 0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x8000004000000001)) (f32.const -0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0xffdfffffdfffffff)) (f32.const -0x1.000002p+53))
+
+(assert_return (invoke "f64.convert_i32_s" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -2147483648)) (f64.const -2147483648))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 987654321)) (f64.const 987654321))
+
+(assert_return (invoke "f64.convert_i64_s" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740993)) (f64.const -9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740995)) (f64.const -9007199254740996))
+
+(assert_return (invoke "f32.convert_i32_u" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const -2147483648)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xffffffff)) (f32.const 4294967296.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000080)) (f32.const 0x1.000000p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000081)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000082)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777219)) (f32.const 16777220.0))
+
+(assert_return (invoke "f32.convert_i64_u" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_u" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777219)) (f32.const 16777220.0))
+
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x7fffffbfffffffff)) (f32.const 0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x8000008000000001)) (f32.const 0x1.000002p+63))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0xfffffe8000000001)) (f32.const 0x1.fffffep+63))
+
+(assert_return (invoke "f64.convert_i32_u" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_u" (i32.const -2147483648)) (f64.const 2147483648))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0xffffffff)) (f64.const 4294967295.0))
+
+(assert_return (invoke "f64.convert_i64_u" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_u" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63))
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+
+(assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-149)) (f64.const 0x1p-149))
+(assert_return (invoke "f64.promote_f32" (f32.const -0x1p-149)) (f64.const -0x1p-149))
+(assert_return (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -0x1.fffffep+127)) (f64.const -0x1.fffffep+127))
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1.fffffep+127)) (f64.const 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
+(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf))
+(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const nan:0x200000)) (f64.const nan:arithmetic))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan:0x200000)) (f64.const nan:arithmetic))
+
+(assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x0.0000000000001p-1022)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x0.0000000000001p-1022)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffe0000000p-127)) (f32.const 0x1p-126))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffe0000000p-127)) (f32.const -0x1p-126))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffdfffffffp-127)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffdfffffffp-127)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000000p+127)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000000p+127)) (f32.const -0x1.fffffcp+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000001p+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000001p+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125))
+(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000050000000p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+24)) (f32.const 0x1.0p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+24)) (f32.const 0x1.000002p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+24)) (f32.const 0x1.000002p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+24)) (f32.const 0x1.000004p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.4eae4f7024c7p+108)) (f32.const 0x1.4eae5p+108))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.a12e71e358685p-113)) (f32.const 0x1.a12e72p-113))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112))
+(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0p-150)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p-150)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0000000000001p-150)) (f32.const -0x1p-149))
+
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000))
+
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000))
+
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000))
+
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (i32.wrap_i64 (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f64_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f64_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.reinterpret_f32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.extend_i32_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.extend_i32_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f32_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f32_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.reinterpret_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.demote_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.reinterpret_i32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.promote_f32 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.reinterpret_i64 (i32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/custom.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/custom.wast
new file mode 100644
index 0000000..b2394f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/custom.wast
@@ -0,0 +1,130 @@
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\24\10" "a custom section" "this is the payload"
+  "\00\20\10" "a custom section" "this is payload"
+  "\00\11\10" "a custom section" ""
+  "\00\10\00" "" "this is payload"
+  "\00\01\00" "" ""
+  "\00\24\10" "\00\00custom sectio\00" "this is the payload"
+  "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload"
+  "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload"
+  "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\01\01\00"  ;; type section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\02\01\00"  ;; import section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\03\01\00"  ;; function section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\04\01\00"  ;; table section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\05\01\00"  ;; memory section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\06\01\00"  ;; global section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\07\01\00"  ;; export section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\09\01\00"  ;; element section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0a\01\00"  ;; code section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0b\01\00"  ;; data section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\07\01\60\02\7f\7f\01\7f"                ;; type section
+  "\00\1a\06" "custom" "this is the payload"   ;; custom section
+  "\03\02\01\00"                               ;; function section
+  "\07\0a\01\06\61\64\64\54\77\6f\00\00"       ;; export section
+  "\0a\09\01\07\00\20\00\20\01\6a\0b"          ;; code section
+  "\00\1b\07" "custom2" "this is the payload"  ;; custom section
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00\00\05\01\00\07\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\26\10" "a custom section" "this is the payload"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\25\10" "a custom section" "this is the payload"
+    "\00\24\10" "a custom section" "this is the payload"
+  )
+  "malformed section id"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01\60\02\7f\7f\01\7f"                         ;; type section
+    "\00\25\10" "a custom section" "this is the payload"  ;; wrong length!
+    "\03\02\01\00"                                        ;; function section
+    "\0a\09\01\07\00\20\00\20\01\6a\0b"                   ;; code section
+    "\00\1b\07" "custom2" "this is the payload"           ;; custom section
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Test concatenated modules.
+(assert_malformed
+  (module binary
+    "\00asm\01\00\00\00"
+    "\00asm\01\00\00\00"
+  )
+  "length out of bounds"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01\00\01"                         ;; memory section
+    "\0c\01\02"                               ;; data count section (2 segments)
+    "\0b\06\01\00\41\00\0b\00"                ;; data section (1 segment)
+  )
+  "data count and data section have inconsistent lengths"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/data.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/data.wast
new file mode 100644
index 0000000..f7d1f09
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/data.wast
@@ -0,0 +1,481 @@
+;; Test the data section
+
+;; Syntax
+
+(module
+  (memory $m 1)
+  (data (i32.const 0))
+  (data (i32.const 1) "a" "" "bcd")
+  (data (offset (i32.const 0)))
+  (data (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory 0) (i32.const 0))
+  (data (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data (memory 0x000) (offset (i32.const 0)))
+  (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory $m) (i32.const 0))
+  (data (memory $m) (i32.const 1) "a" "" "bcd")
+  (data (memory $m) (offset (i32.const 0)))
+  (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d1 (i32.const 0))
+  (data $d2 (i32.const 1) "a" "" "bcd")
+  (data $d3 (offset (i32.const 0)))
+  (data $d4 (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d5 (memory 0) (i32.const 0))
+  (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data $d7 (memory 0x000) (offset (i32.const 0)))
+  (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d9 (memory $m) (i32.const 0))
+  (data $d10 (memory $m) (i32.const 1) "a" "" "bcd")
+  (data $d11 (memory $m) (offset (i32.const 0)))
+  (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+)
+
+;; Basic use
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 3) "b")
+  (data (i32.const 100) "cde")
+  (data (i32.const 5) "x")
+  (data (i32.const 3) "c")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 1) "b")
+  (data (i32.const 2) "cde")
+  (data (i32.const 3) "f")
+  (data (i32.const 2) "g")
+  (data (i32.const 1) "h")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get 0) "a")
+)
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get $g) "a")
+)
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get $g) "a")
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
+;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
+
+;; Corner cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+
+(module
+  (memory 2)
+  (data (i32.const 0x1_ffff) "a")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0))
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0))
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0))
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0x1_0000) "")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0) "" "")
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0 3))
+  (data (global.get 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 1) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 1) "a")
+)
+
+;; Invalid bounds for data
+
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 0 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 1))
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 1))
+  )
+  "out of bounds memory access"
+)
+
+;; This seems to cause a time-out on Travis.
+(;assert_unlinkable
+  (module
+    (memory 0x10000)
+    (data (i32.const 0xffffffff) "ab")
+  )
+  ""  ;; either out of memory or out of bounds
+;)
+
+(assert_trap
+  (module
+    (global (import "spectest" "global_i32") i32)
+    (memory 0)
+    (data (global.get 0) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 1 2)
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2 3)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 1)
+    (data (i32.const -1) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -1) "a")
+  )
+  "out of bounds memory access"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const -100) "a")
+  )
+  "out of bounds memory access"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -100) "a")
+  )
+  "out of bounds memory access"
+)
+
+;; Data without memory
+
+(assert_invalid
+  (module
+    (data (i32.const 0) "")
+  )
+  "unknown memory"
+)
+
+;; Data segment with memory index 1 (only memory 0 available)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\00"                                ;; memory 0
+    "\0b\07\01"                             ;; data section
+    "\02\01\41\00\0b"                       ;; active data segment 0 for memory 1
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 0 (no memory section)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\06\01"                             ;; data section
+    "\00\41\00\0b"                          ;; active data segment 0 for memory 0
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 0"
+)
+
+;; Data segment with memory index 1 (no memory section)
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\07\01"                             ;; data section
+    "\02\01\41\00\0b"                       ;; active data segment 0 for memory 1
+    "\00"                                   ;; empty vec(byte)
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 1 and vec(byte) as above,
+;; only memory 0 available.
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\00"                                ;; memory 0
+    "\0b\45\01"                             ;; data section
+    "\02"                                   ;; active segment
+    "\01"                                   ;; memory index
+    "\41\00\0b"                             ;; offset constant expression
+    "\3e"                                   ;; vec(byte) length
+    "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f"
+    "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f"
+    "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f"
+    "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d"
+  )
+  "unknown memory 1"
+)
+
+;; Data segment with memory index 1 and specially crafted vec(byte) after.
+;; This is to detect incorrect validation where memory index is interpreted
+;; as a flag followed by "\41" interpreted as the size of vec(byte)
+;; with the expected number of bytes following.
+(assert_invalid
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0b\45\01"                             ;; data section
+    "\02"                                   ;; active segment
+    "\01"                                   ;; memory index
+    "\41\00\0b"                             ;; offset constant expression
+    "\3e"                                   ;; vec(byte) length
+    "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f"
+    "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f"
+    "\20\21\22\23\24\25\26\27\28\29\2a\2b\2c\2d\2e\2f"
+    "\30\31\32\33\34\35\36\37\38\39\3a\3b\3c\3d"
+  )
+  "unknown memory 1"
+)
+
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module 
+    (memory 1)
+    (data (offset (;empty instruction sequence;)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (memory 1)
+    (data (offset (global.get 0) (global.get 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (memory 1)
+    (data (offset (global.get 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
+
+(assert_invalid
+   (module 
+     (memory 1)
+     (data (global.get 0))
+   )
+   "unknown global 0"
+)
+
+(assert_invalid
+   (module
+     (global (import "test" "global-i32") i32)
+     (memory 1)
+     (data (global.get 1))
+   )
+   "unknown global 1"
+)
+
+(assert_invalid
+   (module 
+     (global (import "test" "global-mut-i32") (mut i32))
+     (memory 1)
+     (data (global.get 0))
+   )
+   "constant expression required"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/elem.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/elem.wast
new file mode 100644
index 0000000..19b5fe9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/elem.wast
@@ -0,0 +1,529 @@
+;; Test the element section
+
+;; Syntax
+(module
+  (table $t 10 funcref)
+  (func $f)
+  (func $g)
+
+  ;; Passive
+  (elem funcref)
+  (elem funcref (ref.func $f) (item ref.func $f) (item (ref.null func)) (ref.func $g))
+  (elem func)
+  (elem func $f $f $g $g)
+
+  (elem $p1 funcref)
+  (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem $p3 func)
+  (elem $p4 func $f $f $g $g)
+
+  ;; Active
+  (elem (table $t) (i32.const 0) funcref)
+  (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $g)
+  (elem (table $t) (offset (i32.const 0)) funcref)
+  (elem (table $t) (offset (i32.const 0)) func $f $g)
+  (elem (table 0) (i32.const 0) func)
+  (elem (table 0x0) (i32.const 0) func $f $f)
+  (elem (table 0x000) (offset (i32.const 0)) func)
+  (elem (table 0) (offset (i32.const 0)) func $f $f)
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $f)
+  (elem (table $t) (offset (i32.const 0)) func)
+  (elem (table $t) (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)))
+  (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null func))
+  (elem (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)) $f $f)
+  (elem (i32.const 0))
+  (elem (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem (i32.const 0) func $f $f)
+  (elem (i32.const 0) $f $f)
+
+  (elem $a1 (table $t) (i32.const 0) funcref)
+  (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem $a3 (table $t) (i32.const 0) func)
+  (elem $a4 (table $t) (i32.const 0) func $f $g)
+  (elem $a9 (table $t) (offset (i32.const 0)) funcref)
+  (elem $a10 (table $t) (offset (i32.const 0)) func $f $g)
+  (elem $a11 (table 0) (i32.const 0) func)
+  (elem $a12 (table 0x0) (i32.const 0) func $f $f)
+  (elem $a13 (table 0x000) (offset (i32.const 0)) func)
+  (elem $a14 (table 0) (offset (i32.const 0)) func $f $f)
+  (elem $a15 (table $t) (i32.const 0) func)
+  (elem $a16 (table $t) (i32.const 0) func $f $f)
+  (elem $a17 (table $t) (offset (i32.const 0)) func)
+  (elem $a18 (table $t) (offset (i32.const 0)) func $f $f)
+  (elem $a19 (offset (i32.const 0)))
+  (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null func))
+  (elem $a21 (offset (i32.const 0)) func $f $f)
+  (elem $a22 (offset (i32.const 0)) $f $f)
+  (elem $a23 (i32.const 0))
+  (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null func))
+  (elem $a25 (i32.const 0) func $f $f)
+  (elem $a26 (i32.const 0) $f $f)
+
+  ;; Declarative
+  (elem declare funcref)
+  (elem declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem declare func)
+  (elem declare func $f $f $g $g)
+
+  (elem $d1 declare funcref)
+  (elem $d2 declare funcref (ref.func $f) (ref.func $f) (ref.null func) (ref.func $g))
+  (elem $d3 declare func)
+  (elem $d4 declare func $f $f $g $g)
+)
+
+(module
+  (func $f)
+  (func $g)
+
+  (table $t funcref (elem (ref.func $f) (ref.null func) (ref.func $g)))
+)
+
+
+;; Basic use
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 5) $f)
+  (elem (i32.const 3) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 5) $f)
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get 0) $f)
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get $g) $f)
+)
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 7) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+;; Corner cases
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+
+(module
+  (table 0 funcref)
+  (elem (i32.const 0))
+)
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (elem (i32.const 0))
+)
+
+(module
+  (table 0 0 funcref)
+  (elem (i32.const 0))
+)
+
+(module
+  (table 20 funcref)
+  (elem (i32.const 20))
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 100 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 30 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+;; Invalid bounds for elements
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 1 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (elem (i32.const 1))
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 20 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds table access"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds table access"
+)
+
+;; Implicitly dropped elements
+
+(module
+  (table 10 funcref)
+  (elem $e (i32.const 0) func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds table access")
+
+(module
+  (table 10 funcref)
+  (elem $e declare func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds table access")
+
+;; Element without table
+
+(assert_invalid
+  (module
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "unknown table"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module 
+    (table 1 funcref)
+    (elem (offset (;empty instruction sequence;)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (table 1 funcref)
+    (elem (offset (global.get 0) (global.get 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (global (import "test" "global-i32") i32)
+    (table 1 funcref)
+    (elem (offset (global.get 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
+
+(assert_invalid
+   (module 
+     (table 1 funcref)
+     (elem (global.get 0))
+   )
+   "unknown global 0"
+)
+
+(assert_invalid
+   (module
+     (global (import "test" "global-i32") i32)
+     (table 1 funcref)
+     (elem (global.get 1))
+   )
+   "unknown global 1"
+)
+
+(assert_invalid
+   (module 
+     (global (import "test" "global-mut-i32") (mut i32))
+     (table 1 funcref)
+     (elem (global.get 0))
+   )
+   "constant expression required"
+)
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten") (i32.const 66))
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 funcref))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Element sections across multiple modules change the same table
+
+(module $module1
+  (type $out-i32 (func (result i32)))
+  (table (export "shared-table") 10 funcref)
+  (elem (i32.const 8) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-8") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 8))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+
+(register "module1" $module1)
+
+(assert_trap (invoke $module1 "call-7") "uninitialized element")
+(assert_return (invoke $module1 "call-8") (i32.const 65))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module2
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 7) $const-i32-c)
+  (elem (i32.const 8) $const-i32-d)
+  (func $const-i32-c (type $out-i32) (i32.const 67))
+  (func $const-i32-d (type $out-i32) (i32.const 68))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 68))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module3
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 8) $const-i32-e)
+  (elem (i32.const 9) $const-i32-f)
+  (func $const-i32-e (type $out-i32) (i32.const 69))
+  (func $const-i32-f (type $out-i32) (i32.const 70))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 69))
+(assert_return (invoke $module1 "call-9") (i32.const 70))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/endianness.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/endianness.wast
new file mode 100644
index 0000000..4f28a16
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/endianness.wast
@@ -0,0 +1,217 @@
+(module
+  (memory 1)
+
+  ;; Stores an i16 value in little-endian-format
+  (func $i16_store_little (param $address i32) (param $value i32)
+    (i32.store8 (local.get $address) (local.get $value))
+    (i32.store8 (i32.add (local.get $address) (i32.const 1)) (i32.shr_u (local.get $value) (i32.const 8)))
+  )
+
+  ;; Stores an i32 value in little-endian format
+  (func $i32_store_little (param $address i32) (param $value i32)
+    (call $i16_store_little (local.get $address) (local.get $value))
+    (call $i16_store_little (i32.add (local.get $address) (i32.const 2)) (i32.shr_u (local.get $value) (i32.const 16)))
+  )
+
+  ;; Stores an i64 value in little-endian format
+  (func $i64_store_little (param $address i32) (param $value i64)
+    (call $i32_store_little (local.get $address) (i32.wrap_i64 (local.get $value)))
+    (call $i32_store_little (i32.add (local.get $address) (i32.const 4)) (i32.wrap_i64 (i64.shr_u (local.get $value) (i64.const 32))))
+  )
+
+  ;; Loads an i16 value in little-endian format
+  (func $i16_load_little (param $address i32) (result i32)
+    (i32.or
+      (i32.load8_u (local.get $address))
+      (i32.shl (i32.load8_u (i32.add (local.get $address) (i32.const 1))) (i32.const 8))
+    )
+  )
+
+  ;; Loads an i32 value in little-endian format
+  (func $i32_load_little (param $address i32) (result i32)
+    (i32.or
+      (call $i16_load_little (local.get $address))
+      (i32.shl (call $i16_load_little (i32.add (local.get $address) (i32.const 2))) (i32.const 16))
+    )
+  )
+
+  ;; Loads an i64 value in little-endian format
+  (func $i64_load_little (param $address i32) (result i64)
+    (i64.or
+      (i64.extend_i32_u (call $i32_load_little (local.get $address)))
+      (i64.shl (i64.extend_i32_u (call $i32_load_little (i32.add (local.get $address) (i32.const 4)))) (i64.const 32))
+    )
+  )
+
+  (func (export "i32_load16_s") (param $value i32) (result i32)
+    (call $i16_store_little (i32.const 0) (local.get $value))
+    (i32.load16_s (i32.const 0))
+  )
+
+  (func (export "i32_load16_u") (param $value i32) (result i32)
+    (call $i16_store_little (i32.const 0) (local.get $value))
+    (i32.load16_u (i32.const 0))
+  )
+
+  (func (export "i32_load") (param $value i32) (result i32)
+    (call $i32_store_little (i32.const 0) (local.get $value))
+    (i32.load (i32.const 0))
+  )
+
+  (func (export "i64_load16_s") (param $value i64) (result i64)
+    (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
+    (i64.load16_s (i32.const 0))
+  )
+
+  (func (export "i64_load16_u") (param $value i64) (result i64)
+    (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
+    (i64.load16_u (i32.const 0))
+  )
+
+  (func (export "i64_load32_s") (param $value i64) (result i64)
+    (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
+    (i64.load32_s (i32.const 0))
+  )
+
+  (func (export "i64_load32_u") (param $value i64) (result i64)
+    (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
+    (i64.load32_u (i32.const 0))
+  )
+
+  (func (export "i64_load") (param $value i64) (result i64)
+    (call $i64_store_little (i32.const 0) (local.get $value))
+    (i64.load (i32.const 0))
+  )
+
+  (func (export "f32_load") (param $value f32) (result f32)
+    (call $i32_store_little (i32.const 0) (i32.reinterpret_f32 (local.get $value)))
+    (f32.load (i32.const 0))
+  )
+
+  (func (export "f64_load") (param $value f64) (result f64)
+    (call $i64_store_little (i32.const 0) (i64.reinterpret_f64 (local.get $value)))
+    (f64.load (i32.const 0))
+  )
+
+
+  (func (export "i32_store16") (param $value i32) (result i32)
+    (i32.store16 (i32.const 0) (local.get $value))
+    (call $i16_load_little (i32.const 0))
+  )
+
+  (func (export "i32_store") (param $value i32) (result i32)
+    (i32.store (i32.const 0) (local.get $value))
+    (call $i32_load_little (i32.const 0))
+  )
+
+  (func (export "i64_store16") (param $value i64) (result i64)
+    (i64.store16 (i32.const 0) (local.get $value))
+    (i64.extend_i32_u (call $i16_load_little (i32.const 0)))
+  )
+
+  (func (export "i64_store32") (param $value i64) (result i64)
+    (i64.store32 (i32.const 0) (local.get $value))
+    (i64.extend_i32_u (call $i32_load_little (i32.const 0)))
+  )
+
+  (func (export "i64_store") (param $value i64) (result i64)
+    (i64.store (i32.const 0) (local.get $value))
+    (call $i64_load_little (i32.const 0))
+  )
+
+  (func (export "f32_store") (param $value f32) (result f32)
+    (f32.store (i32.const 0) (local.get $value))
+    (f32.reinterpret_i32 (call $i32_load_little (i32.const 0)))
+  )
+
+  (func (export "f64_store") (param $value f64) (result f64)
+    (f64.store (i32.const 0) (local.get $value))
+    (f64.reinterpret_i64 (call $i64_load_little (i32.const 0)))
+  )
+)
+
+(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load16_s" (i32.const -4242)) (i32.const -4242))
+(assert_return (invoke "i32_load16_s" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "i32_load16_s" (i32.const 0x3210)) (i32.const 0x3210))
+
+(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 0xFFFF))
+(assert_return (invoke "i32_load16_u" (i32.const -4242)) (i32.const 61294))
+(assert_return (invoke "i32_load16_u" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "i32_load16_u" (i32.const 0xCAFE)) (i32.const 0xCAFE))
+
+(assert_return (invoke "i32_load" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load" (i32.const -42424242)) (i32.const -42424242))
+(assert_return (invoke "i32_load" (i32.const 42424242)) (i32.const 42424242))
+(assert_return (invoke "i32_load" (i32.const 0xABAD1DEA)) (i32.const 0xABAD1DEA))
+
+(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load16_s" (i64.const -4242)) (i64.const -4242))
+(assert_return (invoke "i64_load16_s" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "i64_load16_s" (i64.const 0x3210)) (i64.const 0x3210))
+
+(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 0xFFFF))
+(assert_return (invoke "i64_load16_u" (i64.const -4242)) (i64.const 61294))
+(assert_return (invoke "i64_load16_u" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "i64_load16_u" (i64.const 0xCAFE)) (i64.const 0xCAFE))
+
+(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load32_s" (i64.const -42424242)) (i64.const -42424242))
+(assert_return (invoke "i64_load32_s" (i64.const 42424242)) (i64.const 42424242))
+(assert_return (invoke "i64_load32_s" (i64.const 0x12345678)) (i64.const 0x12345678))
+
+(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 0xFFFFFFFF))
+(assert_return (invoke "i64_load32_u" (i64.const -42424242)) (i64.const 4252543054))
+(assert_return (invoke "i64_load32_u" (i64.const 42424242)) (i64.const 42424242))
+(assert_return (invoke "i64_load32_u" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
+
+(assert_return (invoke "i64_load" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load" (i64.const -42424242)) (i64.const -42424242))
+(assert_return (invoke "i64_load" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
+(assert_return (invoke "i64_load" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA))
+
+(assert_return (invoke "f32_load" (f32.const -1)) (f32.const -1))
+(assert_return (invoke "f32_load" (f32.const 1234e-5)) (f32.const 1234e-5))
+(assert_return (invoke "f32_load" (f32.const 4242.4242)) (f32.const 4242.4242))
+(assert_return (invoke "f32_load" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+
+(assert_return (invoke "f64_load" (f64.const -1)) (f64.const -1))
+(assert_return (invoke "f64_load" (f64.const 123456789e-5)) (f64.const 123456789e-5))
+(assert_return (invoke "f64_load" (f64.const 424242.424242)) (f64.const 424242.424242))
+(assert_return (invoke "f64_load" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+
+
+(assert_return (invoke "i32_store16" (i32.const -1)) (i32.const 0xFFFF))
+(assert_return (invoke "i32_store16" (i32.const -4242)) (i32.const 61294))
+(assert_return (invoke "i32_store16" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "i32_store16" (i32.const 0xCAFE)) (i32.const 0xCAFE))
+
+(assert_return (invoke "i32_store" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_store" (i32.const -4242)) (i32.const -4242))
+(assert_return (invoke "i32_store" (i32.const 42424242)) (i32.const 42424242))
+(assert_return (invoke "i32_store" (i32.const 0xDEADCAFE)) (i32.const 0xDEADCAFE))
+
+(assert_return (invoke "i64_store16" (i64.const -1)) (i64.const 0xFFFF))
+(assert_return (invoke "i64_store16" (i64.const -4242)) (i64.const 61294))
+(assert_return (invoke "i64_store16" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "i64_store16" (i64.const 0xCAFE)) (i64.const 0xCAFE))
+
+(assert_return (invoke "i64_store32" (i64.const -1)) (i64.const 0xFFFFFFFF))
+(assert_return (invoke "i64_store32" (i64.const -4242)) (i64.const 4294963054))
+(assert_return (invoke "i64_store32" (i64.const 42424242)) (i64.const 42424242))
+(assert_return (invoke "i64_store32" (i64.const 0xDEADCAFE)) (i64.const 0xDEADCAFE))
+
+(assert_return (invoke "i64_store" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_store" (i64.const -42424242)) (i64.const -42424242))
+(assert_return (invoke "i64_store" (i64.const 0xABAD1DEA)) (i64.const 0xABAD1DEA))
+(assert_return (invoke "i64_store" (i64.const 0xABADCAFEDEAD1DEA)) (i64.const 0xABADCAFEDEAD1DEA))
+
+(assert_return (invoke "f32_store" (f32.const -1)) (f32.const -1))
+(assert_return (invoke "f32_store" (f32.const 1234e-5)) (f32.const 1234e-5))
+(assert_return (invoke "f32_store" (f32.const 4242.4242)) (f32.const 4242.4242))
+(assert_return (invoke "f32_store" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+
+(assert_return (invoke "f64_store" (f64.const -1)) (f64.const -1))
+(assert_return (invoke "f64_store" (f64.const 123456789e-5)) (f64.const 123456789e-5))
+(assert_return (invoke "f64_store" (f64.const 424242.424242)) (f64.const 424242.424242))
+(assert_return (invoke "f64_store" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/exports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/exports.wast
new file mode 100644
index 0000000..80d3ae0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/exports.wast
@@ -0,0 +1,238 @@
+;; Functions
+
+(module (func) (export "a" (func 0)))
+(module (func) (export "a" (func 0)) (export "b" (func 0)))
+(module (func) (func) (export "a" (func 0)) (export "b" (func 1)))
+
+(module (func (export "a")))
+(module (func (export "a") (export "b") (export "c")))
+(module (func (export "a") (export "b") (param i32)))
+(module (func) (export "a" (func 0)))
+(module (func $a (export "a")))
+(module (func $a) (export "a" (func $a)))
+(module (export "a" (func 0)) (func))
+(module (export "a" (func $a)) (func $a))
+
+(module $Func
+  (export "e" (func $f))
+  (func $f (param $n i32) (result i32)
+    (return (i32.add (local.get $n) (i32.const 1)))
+  )
+)
+(assert_return (invoke "e" (i32.const 42)) (i32.const 43))
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+(module)
+(module $Other1)
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+
+(module
+  (type (;0;) (func (result i32)))
+  (func (;0;) (type 0) (result i32) i32.const 42)
+  (export "a" (func 0))
+  (export "b" (func 0))
+  (export "c" (func 0)))
+(assert_return (invoke "a") (i32.const 42))
+(assert_return (invoke "b") (i32.const 42))
+(assert_return (invoke "c") (i32.const 42))
+
+(assert_invalid
+  (module (export "a" (func 0)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func) (export "a" (func 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (import "spectest" "print_i32" (func (param i32))) (export "a" (func 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func) (export "a" (func 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (func) (export "a" (func 0)) (export "a" (func 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Globals
+
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0)))
+(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1)))
+
+(module (global (export "a") i32 (i32.const 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global $a (export "a") i32 (i32.const 0)))
+(module (global $a i32 (i32.const 0)) (export "a" (global $a)))
+(module (export "a" (global 0)) (global i32 (i32.const 0)))
+(module (export "a" (global $a)) (global $a i32 (i32.const 0)))
+
+(module $Global
+  (export "e" (global $g))
+  (global $g i32 (i32.const 42))
+)
+(assert_return (get "e") (i32.const 42))
+(assert_return (get $Global "e") (i32.const 42))
+(module)
+(module $Other2)
+(assert_return (get $Global "e") (i32.const 42))
+
+(assert_invalid
+  (module (export "a" (global 0)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 1)))
+  "unknown global"
+)
+(assert_invalid
+  (module (import "spectest" "global_i32" (global i32)) (export "a" (global 1)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Tables
+
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0)))
+(module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1)))
+
+(module (table (export "a") 0 funcref))
+(module (table (export "a") 0 1 funcref))
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 1 funcref) (export "a" (table 0)))
+(module (table $a (export "a") 0 funcref))
+(module (table $a (export "a") 0 1 funcref))
+(module (table $a 0 funcref) (export "a" (table $a)))
+(module (table $a 0 1 funcref) (export "a" (table $a)))
+(module (export "a" (table 0)) (table 0 funcref))
+(module (export "a" (table 0)) (table 0 1 funcref))
+(module (export "a" (table $a)) (table $a 0 funcref))
+(module (export "a" (table $a)) (table $a 0 1 funcref))
+
+(; TODO: access table ;)
+
+(assert_invalid
+  (module (export "a" (table 0)))
+  "unknown table"
+)
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 1)))
+  "unknown table"
+)
+(assert_invalid
+  (module  (import "spectest" "table" (table 10 20 funcref)) (export "a" (table 1)))
+  "unknown table"
+)
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Memories
+
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0)))
+;; No multiple memories yet.
+;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1)))
+
+(module (memory (export "a") 0))
+(module (memory (export "a") 0 1))
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0 1) (export "a" (memory 0)))
+(module (memory $a (export "a") 0))
+(module (memory $a (export "a") 0 1))
+(module (memory $a 0) (export "a" (memory $a)))
+(module (memory $a 0 1) (export "a" (memory $a)))
+(module (export "a" (memory 0)) (memory 0))
+(module (export "a" (memory 0)) (memory 0 1))
+(module (export "a" (memory $a)) (memory $a 0))
+(module (export "a" (memory $a)) (memory $a 0 1))
+
+(; TODO: access memory ;)
+
+(assert_invalid
+  (module (export "a" (memory 0)))
+  "unknown memory"
+)
+(assert_invalid
+  (module (memory 0) (export "a" (memory 1)))
+  "unknown memory"
+)
+(assert_invalid
+  (module  (import "spectest" "memory" (memory 1 2)) (export "a" (memory 1)))
+  "unknown memory"
+)
+(assert_invalid
+  (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+;; No multiple memories yet.
+;; (assert_invalid
+;;   (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1)))
+;;   "duplicate export name"
+;; )
+(assert_invalid
+  (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/extract-parts.sh b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/extract-parts.sh
new file mode 100755
index 0000000..6aac1d0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/extract-parts.sh
@@ -0,0 +1,35 @@
+#!/bin/bash
+set -e
+set -u
+set -o pipefail
+
+# This script extracts the modules from the testsuite test files into
+# individual files in the following directories:
+#  - valid - valid wasm modules
+#  - invalid - wasm modules that fail to validate
+#  - malformed - wasm text tests that fail to parse
+
+wabt="../wabt"
+wabtbin="$wabt/bin"
+
+mkdir -p valid invalid malformed
+rm -f valid/*.wasm
+rm -f invalid/*.wasm
+rm -f malformed/*.wat
+
+for wast in *.wast; do
+    base="${wast##*/}"
+    json="invalid/${base%.wast}.json"
+    "$wabtbin/wast2json" "$wast" -o "$json"
+    rm "$json"
+done
+
+mv invalid/*.wat malformed
+
+for wasm in invalid/*.wasm; do
+    if "$wabtbin/wasm2wat" "$wasm" -o invalid/t.wat 2>/dev/null && \
+       "$wabtbin/wat2wasm" invalid/t.wat -o /dev/null 2>/dev/null ; then
+        mv "$wasm" valid
+    fi
+done
+rm invalid/t.wat
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32.wast
new file mode 100644
index 0000000..36d81a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32.wast
@@ -0,0 +1,2533 @@
+;; Test all the f32 operators on major boundary values and all special
+;; values (except comparison and bitwise operators, which are tested in
+;; f32_bitwise.wast and f32_cmp.wast).
+
+(module
+  (func (export "add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y)))
+  (func (export "div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y)))
+  (func (export "sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x)))
+  (func (export "min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y)))
+  (func (export "max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y)))
+  (func (export "ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
+  (func (export "floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
+  (func (export "trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
+  (func (export "nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
+)
+
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-148))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-148))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1.000002p-126))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1.000002p-126))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1.000002p-126))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1.000002p-126))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-125))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-125))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1.8p+0))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1.8p+0))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.b21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.721fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.721fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.b21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1.8p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1.8p+0))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+1))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+1))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.d21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.521fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.521fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.d21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.b21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.721fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.721fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.b21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.d21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.521fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.521fb6p+2))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.d21fb6p+2))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+3))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+3))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "add" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p-148))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p-148))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1.000002p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1.000002p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1.000002p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1.000002p-126))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p-125))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p-125))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1.8p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1.8p+0))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.721fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.b21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.b21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.721fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1.8p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1.8p+0))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+1))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+1))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.521fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.d21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.d21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.521fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.721fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.b21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.b21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.721fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.521fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.d21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.d21fb6p+2))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.521fb6p+2))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+3))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+3))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sub" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.8p-147))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.8p-147))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p-147))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p-147))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-127))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-127))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-127))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-127))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-127))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-127))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-127))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-127))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p-2))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p-2))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-2))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-2))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.8p-147))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.8p-147))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.8p-147))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.8p-147))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p-124))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+1))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep-22))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+1))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+126))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "mul" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1p-23))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1p-23))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-23))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-23))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-148))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-148))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-148))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-148))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p+23))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p+23))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p+23))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p+23))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-125))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-125))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-125))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-125))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f3p-129))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f3p-129))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f3p-129))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f3p-129))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p+125))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p+125))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p+125))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p+125))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f306p-4))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f306p-4))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f306p-4))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f306p-4))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-129))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-129))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-129))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-129))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+126))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+126))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+126))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+126))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p+1))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p+1))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+1))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+1))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f306p-3))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f306p-3))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f306p-3))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f306p-3))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-128))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-128))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-128))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-128))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+3))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+3))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+3))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+3))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb8p-126))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb8p-126))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb8p-126))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb8p-126))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.45f304p+125))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.45f304p+125))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.45f304p+125))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.45f304p+125))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "div" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "min" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -inf)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -inf)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -inf)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -inf)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const inf) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const inf) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const inf) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const inf) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x0p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-149)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-126)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p-1)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1p+0)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const inf)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "max" (f32.const nan:0x200000) (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "sqrt" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "sqrt" (f32.const -0x1p-149)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1p-149)) (f32.const 0x1.6a09e6p-75))
+(assert_return (invoke "sqrt" (f32.const -0x1p-126)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1p-126)) (f32.const 0x1p-63))
+(assert_return (invoke "sqrt" (f32.const -0x1p-1)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1p-1)) (f32.const 0x1.6a09e6p-1))
+(assert_return (invoke "sqrt" (f32.const -0x1p+0)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "sqrt" (f32.const -0x1.921fb6p+2)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.40d932p+1))
+(assert_return (invoke "sqrt" (f32.const -0x1.fffffep+127)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+63))
+(assert_return (invoke "sqrt" (f32.const -inf)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "sqrt" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "sqrt" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "floor" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "floor" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "floor" (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "floor" (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "floor" (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "floor" (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "floor" (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "floor" (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "floor" (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "floor" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "floor" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.cp+2))
+(assert_return (invoke "floor" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
+(assert_return (invoke "floor" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "floor" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "floor" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "floor" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "floor" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "floor" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "ceil" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "ceil" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "ceil" (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "ceil" (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "ceil" (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "ceil" (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "ceil" (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "ceil" (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "ceil" (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "ceil" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "ceil" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
+(assert_return (invoke "ceil" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.cp+2))
+(assert_return (invoke "ceil" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "ceil" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "ceil" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "ceil" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "ceil" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "ceil" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "trunc" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "trunc" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "trunc" (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "trunc" (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "trunc" (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "trunc" (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "trunc" (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "trunc" (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "trunc" (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "trunc" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "trunc" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
+(assert_return (invoke "trunc" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
+(assert_return (invoke "trunc" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "trunc" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "trunc" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "trunc" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "trunc" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "trunc" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "nearest" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "nearest" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "nearest" (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "nearest" (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "nearest" (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "nearest" (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "nearest" (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "nearest" (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "nearest" (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "nearest" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "nearest" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
+(assert_return (invoke "nearest" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
+(assert_return (invoke "nearest" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "nearest" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "nearest" (f32.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "nearest" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "nearest" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "nearest" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f32) (f32.add (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.div (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.max (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.min (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.mul (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.sub (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.ceil (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.floor (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.nearest (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.trunc (i64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_bitwise.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_bitwise.wast
new file mode 100644
index 0000000..8554d67
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_bitwise.wast
@@ -0,0 +1,376 @@
+;; Test all the f32 bitwise operators on major boundary values and all special
+;; values.
+
+(module
+  (func (export "abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
+  (func (export "neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
+  (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-149)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-149)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-126)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-126)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p-1)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p-1)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-126)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-126)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p-1)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p-1)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1p+0)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1p+0)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-149)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p-1)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p-1)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1p+0)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1p+0)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-126)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1p+0)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1p+0)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-126)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p-1)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p-1)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -nan)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const nan)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -nan)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const nan)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x0p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-149)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-149)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-149)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-149)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-126)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-126)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-126)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-126)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p-1)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p-1)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p-1)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p-1)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1p+0)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1p+0)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.921fb6p+2)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.921fb6p+2)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -inf)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const inf)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -inf)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const inf)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "abs" (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "abs" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "abs" (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "abs" (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "abs" (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "abs" (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "abs" (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "abs" (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "abs" (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "abs" (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "abs" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "abs" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "abs" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
+(assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "neg" (f32.const 0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "neg" (f32.const -0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "neg" (f32.const 0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "neg" (f32.const -0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "neg" (f32.const 0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "neg" (f32.const -0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "neg" (f32.const 0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "neg" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "neg" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "neg" (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f32) (f32.copysign (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.abs (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.neg (i64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_cmp.wast
new file mode 100644
index 0000000..0dd7167
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f32_cmp.wast
@@ -0,0 +1,2422 @@
+;; Test all the f32 comparison operators on major boundary values and all
+;; special values.
+
+(module
+  (func (export "eq") (param $x f32) (param $y f32) (result i32) (f32.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x f32) (param $y f32) (result i32) (f32.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x f32) (param $y f32) (result i32) (f32.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x f32) (param $y f32) (result i32) (f32.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x f32) (param $y f32) (result i32) (f32.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x f32) (param $y f32) (result i32) (f32.ge (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const nan:0x200000)) (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f32) (f32.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.ne (i64.const 0) (f64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64.wast
new file mode 100644
index 0000000..70bb477
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64.wast
@@ -0,0 +1,2533 @@
+;; Test all the f64 operators on major boundary values and all special
+;; values (except comparison and bitwise operators, which are tested in
+;; f64_bitwise.wast and f64_cmp.wast).
+
+(module
+  (func (export "add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
+  (func (export "div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
+  (func (export "sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x)))
+  (func (export "min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
+  (func (export "max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
+  (func (export "ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
+  (func (export "floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
+  (func (export "trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
+  (func (export "nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
+)
+
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1021))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1021))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1.8p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1.8p+0))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1.8p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1.8p+0))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+1))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+1))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "add" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000002p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000002p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.fffffffffffffp-1022))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.fffffffffffffp-1022))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.0000000000001p-1022))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1021))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1021))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1.8p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1.8p+0))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.721fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.b21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.b21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.721fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1.8p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1.8p+0))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+1))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+1))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.521fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.d21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.d21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.521fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.721fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.b21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.b21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.721fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.521fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.d21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.d21fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.521fb54442d18p+2))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+3))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+3))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sub" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x0.8p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-2))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-2))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-2))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-2))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000006p-1022))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p-1020))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+1))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp-51))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1022))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "mul" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-52))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-52))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-52))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-52))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000002p-1022))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000002p-1022))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000002p-1022))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000002p-1022))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+52))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+52))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1021))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1021))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1021))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1021))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.28be60db9391p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.28be60db9391p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p+1021))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-4))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-4))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+1022))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+1))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+1))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+1))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+1))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c883p-3))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c883p-3))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "div" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "min" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -inf)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -inf)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const inf) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const inf) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const inf) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "max" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "sqrt" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "sqrt" (f64.const -0x0.0000000000001p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-537))
+(assert_return (invoke "sqrt" (f64.const -0x1p-1022)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x1p-1022)) (f64.const 0x1p-511))
+(assert_return (invoke "sqrt" (f64.const -0x1p-1)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x1p-1)) (f64.const 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "sqrt" (f64.const -0x1p+0)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "sqrt" (f64.const -0x1.921fb54442d18p+2)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.40d931ff62705p+1))
+(assert_return (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+511))
+(assert_return (invoke "sqrt" (f64.const -inf)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "sqrt" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "sqrt" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "sqrt" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "floor" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "floor" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "floor" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "floor" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "floor" (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "floor" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "floor" (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "floor" (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "floor" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "floor" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "floor" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.cp+2))
+(assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
+(assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "floor" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "floor" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "floor" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "floor" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "floor" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "ceil" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "ceil" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "ceil" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "ceil" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "ceil" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "ceil" (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "ceil" (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "ceil" (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "ceil" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "ceil" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "ceil" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
+(assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2))
+(assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "ceil" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "ceil" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "ceil" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "ceil" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "ceil" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "trunc" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "trunc" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "trunc" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "trunc" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "trunc" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "trunc" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "trunc" (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "trunc" (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "trunc" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "trunc" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "trunc" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
+(assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
+(assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "trunc" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "trunc" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "trunc" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "trunc" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "trunc" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "nearest" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "nearest" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "nearest" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "nearest" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "nearest" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "nearest" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "nearest" (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "nearest" (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "nearest" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "nearest" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "nearest" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
+(assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
+(assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "nearest" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "nearest" (f64.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "nearest" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
+(assert_return (invoke "nearest" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "nearest" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f64) (f64.add (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.div (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.max (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.min (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.mul (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.sub (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.ceil (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.floor (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.nearest (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.trunc (i64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_bitwise.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_bitwise.wast
new file mode 100644
index 0000000..f268a3e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_bitwise.wast
@@ -0,0 +1,376 @@
+;; Test all the f64 bitwise operators on major boundary values and all special
+;; values.
+
+(module
+  (func (export "abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
+  (func (export "neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
+  (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p-1)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p-1)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1p+0)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1p+0)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p-1)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p-1)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -nan)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const nan)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -nan)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const nan)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1022)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1022)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p-1)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p-1)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p-1)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p-1)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1p+0)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1p+0)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -inf)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const inf)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -inf)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const inf)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "abs" (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "abs" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "abs" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "abs" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "abs" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "abs" (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "abs" (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "abs" (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "abs" (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "abs" (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "abs" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "abs" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "abs" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
+(assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "neg" (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "neg" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "neg" (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "neg" (f64.const -0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "neg" (f64.const 0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "neg" (f64.const -0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "neg" (f64.const 0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "neg" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "neg" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "neg" (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f64) (f64.copysign (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.abs (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.neg (i64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_cmp.wast
new file mode 100644
index 0000000..dd79929
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/f64_cmp.wast
@@ -0,0 +1,2422 @@
+;; Test all the f64 comparison operators on major boundary values and all
+;; special values.
+
+(module
+  (func (export "eq") (param $x f64) (param $y f64) (result i32) (f64.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x f64) (param $y f64) (result i32) (f64.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x f64) (param $y f64) (result i32) (f64.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x f64) (param $y f64) (result i32) (f64.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x f64) (param $y f64) (result i32) (f64.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x f64) (param $y f64) (result i32) (f64.ge (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const nan:0x4000000000000)) (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result f64) (f64.eq (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.ge (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.gt (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.le (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.lt (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.ne (i64.const 0) (f32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/fac.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/fac.wast
new file mode 100644
index 0000000..0e61c1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/fac.wast
@@ -0,0 +1,109 @@
+(module
+  ;; Recursive factorial
+  (func (export "fac-rec") (param i64) (result i64)
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
+      )
+    )
+  )
+
+  ;; Recursive factorial named
+  (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
+    (if (result i64) (i64.eq (local.get $n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get $n)
+          (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  ;; Iterative factorial
+  (func (export "fac-iter") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
+    (block
+      (loop
+        (if
+          (i64.eq (local.get 1) (i64.const 0))
+          (then (br 2))
+          (else
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
+          )
+        )
+        (br 0)
+      )
+    )
+    (local.get 2)
+  )
+
+  ;; Iterative factorial named
+  (func (export "fac-iter-named") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (if
+          (i64.eq (local.get $i) (i64.const 0))
+          (then (br $done))
+          (else
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  ;; Optimized factorial.
+  (func (export "fac-opt") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+      (loop
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Iterative factorial without locals.
+  (func $pick0 (param i64) (result i64 i64)
+    (local.get 0) (local.get 0)
+  )
+  (func $pick1 (param i64 i64) (result i64 i64 i64)
+    (local.get 0) (local.get 1) (local.get 0)
+  )
+  (func (export "fac-ssa") (param i64) (result i64)
+    (i64.const 1) (local.get 0)
+    (loop $l (param i64 i64) (result i64)
+      (call $pick1) (call $pick1) (i64.mul)
+      (call $pick1) (i64.const 1) (i64.sub)
+      (call $pick0) (i64.const 0) (i64.gt_u)
+      (br_if $l)
+      (drop) (return)
+    )
+  )
+)
+
+(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-ssa" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_exprs.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_exprs.wast
new file mode 100644
index 0000000..1f88299
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_exprs.wast
@@ -0,0 +1,2570 @@
+;; Test interesting floating-point "expressions". These tests contain code
+;; patterns which tempt common value-changing optimizations.
+
+;; Test that x*y+z is not done with x87-style intermediate precision.
+
+(module
+  (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.9e87ce14273afp-103) (f64.const 0x1.2515ad31db63ep+664) (f64.const 0x1.868c6685e6185p+533)) (f64.const -0x1.da94885b11493p+561))
+(assert_return (invoke "f64.no_contraction" (f64.const 0x1.da21c460a6f44p+52) (f64.const 0x1.60859d2e7714ap-321) (f64.const 0x1.e63f1b7b660e1p-302)) (f64.const 0x1.4672f256d1794p-268))
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.f3eaf43f327cp-594) (f64.const 0x1.dfcc009906b57p+533) (f64.const 0x1.5984e03c520a1p-104)) (f64.const -0x1.d4797fb3db166p-60))
+(assert_return (invoke "f64.no_contraction" (f64.const 0x1.dab6c772cb2e2p-69) (f64.const -0x1.d761663679a84p-101) (f64.const 0x1.f22f92c843226p-218)) (f64.const -0x1.b50d72dfcef68p-169))
+(assert_return (invoke "f64.no_contraction" (f64.const -0x1.87c5def1e4d3dp-950) (f64.const -0x1.50cd5dab2207fp+935) (f64.const 0x1.e629bd0da8c5dp-54)) (f64.const 0x1.01b6feb4e78a7p-14))
+
+;; Test that x*y+z is not folded to fma.
+
+(module
+  (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.a78402p+124) (f32.const 0x1.cf8548p-23) (f32.const 0x1.992adap+107)) (f32.const 0x1.a5262cp+107))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.ed15a4p-28) (f32.const -0x1.613c72p-50) (f32.const 0x1.4757bp-88)) (f32.const -0x1.5406b8p-77))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.ae63a2p+37) (f32.const 0x1.b3a59ap-13) (f32.const 0x1.c16918p+10)) (f32.const 0x1.6e385cp+25))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.2a77fap-8) (f32.const -0x1.bb7356p+22) (f32.const -0x1.32be2ap+1)) (f32.const -0x1.0286d4p+15))
+(assert_return (invoke "f32.no_fma" (f32.const 0x1.298fb6p+126) (f32.const -0x1.03080cp-70) (f32.const -0x1.418de6p+34)) (f32.const -0x1.2d15c6p+56))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.ac357ff46eed4p+557) (f64.const 0x1.852c01a5e7297p+430) (f64.const -0x1.05995704eda8ap+987)) (f64.const 0x1.855d905d338ep+987))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.e2fd6bf32010cp+749) (f64.const 0x1.01c2238d405e4p-130) (f64.const 0x1.2ecc0db4b9f94p+573)) (f64.const 0x1.e64eb07e063bcp+619))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.92b7c7439ede3p-721) (f64.const -0x1.6aa97586d3de6p+1011) (f64.const 0x1.8de4823f6358ap+237)) (f64.const -0x1.1d4139fd20ecdp+291))
+(assert_return (invoke "f64.no_fma" (f64.const -0x1.466d30bddb453p-386) (f64.const -0x1.185a4d739c7aap+443) (f64.const 0x1.5f9c436fbfc7bp+55)) (f64.const 0x1.bd61a350fcc1ap+57))
+(assert_return (invoke "f64.no_fma" (f64.const 0x1.7e2c44058a799p+52) (f64.const 0x1.c73b71765b8b2p+685) (f64.const -0x1.16c641df0b108p+690)) (f64.const 0x1.53ccb53de0bd1p+738))
+
+;; Test that x+0.0 is not folded to x.
+;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+
+(module
+  (func (export "f32.no_fold_add_zero") (param $x f32) (result f32)
+    (f32.add (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_add_zero") (param $x f64) (result f64)
+    (f64.add (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_fold_add_zero" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f32.no_fold_add_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_add_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that 0.0 - x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32)
+    (f32.sub (f32.const 0.0) (local.get $x)))
+  (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64)
+    (f64.sub (f64.const 0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f32.no_fold_zero_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x - 0.0 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32)
+    (f32.sub (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64)
+    (f64.sub (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_sub_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x*0.0 is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32)
+    (f32.mul (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64)
+    (f64.mul (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -1.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const -2.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_mul_zero" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -1.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const -2.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_mul_zero" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x*1.0 is not folded to x.
+;; See IEEE 754-2008 10.4 "Literal meaning and value-changing optimizations".
+
+(module
+  (func (export "f32.no_fold_mul_one") (param $x f32) (result f32)
+    (f32.mul (local.get $x) (f32.const 1.0)))
+  (func (export "f64.no_fold_mul_one") (param $x f64) (result f64)
+    (f64.mul (local.get $x) (f64.const 1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_mul_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that 0.0/x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_zero_div") (param $x f32) (result f32)
+    (f32.div (f32.const 0.0) (local.get $x)))
+  (func (export "f64.no_fold_zero_div") (param $x f64) (result f64)
+    (f64.div (f64.const 0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_zero_div" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const -0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_zero_div" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/1.0 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div_one") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 1.0)))
+  (func (export "f64.no_fold_div_one") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_one" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/-1.0 is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const -1.0)))
+  (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const -1.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_div_neg1" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that -0.0 - x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32)
+    (f32.sub (f32.const -0.0) (local.get $x)))
+  (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64)
+    (f64.sub (f64.const -0.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg0_sub" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that -1.0 * x is not folded to -x.
+
+(module
+  (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32)
+    (f32.mul (f32.const -1.0) (local.get $x)))
+  (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64)
+    (f64.mul (f64.const -1.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f64.no_fold_neg1_mul" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x == x is not folded to true.
+
+(module
+  (func (export "f32.no_fold_eq_self") (param $x f32) (result i32)
+    (f32.eq (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_eq_self") (param $x f64) (result i32)
+    (f64.eq (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_eq_self" (f64.const nan)) (i32.const 0))
+
+;; Test that x != x is not folded to false.
+
+(module
+  (func (export "f32.no_fold_ne_self") (param $x f32) (result i32)
+    (f32.ne (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_ne_self") (param $x f64) (result i32)
+    (f64.ne (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f64.no_fold_ne_self" (f64.const nan)) (i32.const 1))
+
+;; Test that x - x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_sub_self") (param $x f32) (result f32)
+    (f32.sub (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_sub_self") (param $x f64) (result f64)
+    (f64.sub (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_sub_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_sub_self" (f64.const nan)) (f64.const nan:canonical))
+
+;; Test that x / x is not folded to 1.0.
+
+(module
+  (func (export "f32.no_fold_div_self") (param $x f32) (result f32)
+    (f32.div (local.get $x) (local.get $x)))
+  (func (export "f64.no_fold_div_self") (param $x f64) (result f64)
+    (f64.div (local.get $x) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_div_self" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const 0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_self" (f32.const -0.0)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const 0.0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_self" (f64.const -0.0)) (f64.const nan:canonical))
+
+;; Test that x/3 is not folded to x*(1/3).
+
+(module
+  (func (export "f32.no_fold_div_3") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 3.0)))
+  (func (export "f64.no_fold_div_3") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 3.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.e45646p+93)) (f32.const -0x1.42e42ep+92))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.2a3916p-83)) (f32.const -0x1.8da172p-85))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.1f8b38p-124)) (f32.const -0x1.7f644ap-126))
+(assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.d64f64p-56)) (f32.const -0x1.398a42p-57))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.a8a88d29e2cc3p+632)) (f64.const -0x1.1b1b08c69732dp+631))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.bcf52dc950972p-167)) (f64.const -0x1.28a373db8b0f7p-168))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.bd3c0d989f7a4p-874)) (f64.const 0x1.28d2b3bb14fc3p-875))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const -0x1.0138bf530a53cp+1007)) (f64.const -0x1.56f6546eb86fbp+1005))
+(assert_return (invoke "f64.no_fold_div_3" (f64.const 0x1.052b87f9d794dp+415)) (f64.const 0x1.5c3a0aa274c67p+413))
+
+;; Test that (x*z)+(y*z) is not folded to (x+y)*z.
+
+(module
+  (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z))))
+  (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a342p-14))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651aaep+82))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa15p+55))
+(assert_return (invoke "f32.no_factor" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9cep-50))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1ap-649))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e2p+198))
+(assert_return (invoke "f64.no_factor" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f184p-512))
+(assert_return (invoke "f64.no_factor" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af53p-90))
+
+;; Test that (x+y)*z is not folded to (x*z)+(y*z).
+
+(module
+  (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.b4e7f6p-6) (f32.const 0x1.8c990cp-5) (f32.const -0x1.70cc02p-9)) (f32.const -0x1.00a34p-14))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.06722ep-41) (f32.const 0x1.eed3cep-64) (f32.const 0x1.5c5558p+123)) (f32.const -0x1.651abp+82))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.f8c6a4p-64) (f32.const 0x1.08c806p-83) (f32.const 0x1.b5ceccp+118)) (f32.const -0x1.afa14ep+55))
+(assert_return (invoke "f32.no_distribute" (f32.const -0x1.3aaa1ep-84) (f32.const 0x1.c6d5eep-71) (f32.const 0x1.8d2924p+20)) (f32.const 0x1.60c9ccp-50))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3adeda9144977p-424) (f64.const 0x1.c15af887049e1p-462) (f64.const -0x1.905179c4c4778p-225)) (f64.const -0x1.ec606bcb87b1bp-649))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.3c84821c1d348p-662) (f64.const -0x1.4ffd4c77ad037p-1009) (f64.const -0x1.dd275335c6f4p-957)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.074f372347051p-334) (f64.const -0x1.aaeef661f4c96p-282) (f64.const -0x1.9bd34abe8696dp+479)) (f64.const 0x1.5767029593e1fp+198))
+(assert_return (invoke "f64.no_distribute" (f64.const -0x1.c4ded58a6f389p-289) (f64.const 0x1.ba6fdef5d59c9p-260) (f64.const -0x1.c1201c0470205p-253)) (f64.const -0x1.841ada2e0f183p-512))
+(assert_return (invoke "f64.no_distribute" (f64.const 0x1.9d3688f8e375ap-608) (f64.const 0x1.bf91311588256p-579) (f64.const -0x1.1605a6b5d5ff8p+489)) (f64.const -0x1.e6118ca76af52p-90))
+
+;; Test that x*(y/z) is not folded to (x*y)/z.
+
+(module
+  (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z))))
+  (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.792258p+118))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df2p-89))
+(assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const inf))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
+
+;; Test that (x*y)/z is not folded to x*(y/z).
+
+(module
+  (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+  (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -inf))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -inf))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0))
+
+;; Test that x+y+z+w is not reassociated.
+
+(module
+  (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+  (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+)
+
+(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.5f7ddcp+44) (f32.const 0x1.854e1p+34) (f32.const -0x1.b2068cp+47) (f32.const -0x1.209692p+41)) (f32.const -0x1.e26c76p+47))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.da3b78p-9) (f32.const -0x1.4312fap-7) (f32.const 0x1.0395e6p-4) (f32.const -0x1.6d5ea6p-7)) (f32.const 0x1.78b31ap-5))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.fdb93ap+34) (f32.const -0x1.b6fce6p+41) (f32.const 0x1.c131d8p+44) (f32.const 0x1.8835b6p+38)) (f32.const 0x1.8ff3a2p+44))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.1739fcp+47) (f32.const 0x1.a4b186p+49) (f32.const -0x1.0c623cp+35) (f32.const 0x1.16a102p+51)) (f32.const 0x1.913ff6p+51))
+(assert_return (invoke "f32.no_reassociate_add" (f32.const 0x1.733cfap+108) (f32.const -0x1.38d30cp+108) (f32.const 0x1.2f5854p+105) (f32.const -0x1.ccb058p+94)) (f32.const 0x1.813716p+106))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.697a4d9ff19a6p+841) (f64.const 0x1.b305466238397p+847) (f64.const 0x1.e0b2d9bfb4e72p+855) (f64.const -0x1.6e1f3ae2b06bbp+857)) (f64.const -0x1.eb0e5936f087ap+856))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const 0x1.00ef6746b30e1p-543) (f64.const 0x1.cc1cfafdf3fe1p-544) (f64.const -0x1.f7726df3ecba6p-543) (f64.const -0x1.b26695f99d307p-594)) (f64.const -0x1.074892e3fad76p-547))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.e807b3bd6d854p+440) (f64.const 0x1.cedae26c2c5fp+407) (f64.const -0x1.00ab6e1442541p+437) (f64.const 0x1.28538a55997bdp+397)) (f64.const -0x1.040e90bf871ebp+441))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ba2b6f35a2402p-317) (f64.const 0x1.ad1c3fea7cd9ep-307) (f64.const -0x1.93aace2bf1261p-262) (f64.const 0x1.9fddbe472847ep-260)) (f64.const 0x1.3af30abc2c01bp-260))
+(assert_return (invoke "f64.no_reassociate_add" (f64.const -0x1.ccb9c6092fb1dp+641) (f64.const -0x1.4b7c28c108244p+614) (f64.const 0x1.8a7cefef4bde1p+646) (f64.const -0x1.901b28b08b482p+644)) (f64.const 0x1.1810579194126p+646))
+
+;; Test that x*y*z*w is not reassociated.
+
+(module
+  (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+  (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
+)
+
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.950ba8p-116) (f32.const 0x1.efdacep-33) (f32.const -0x1.5f9bcp+102) (f32.const 0x1.f04508p-56)) (f32.const -0x1.ff356ep-101))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.5990aep-56) (f32.const -0x1.7dfb04p+102) (f32.const -0x1.4f774ap-125) (f32.const -0x1.595fe6p+70)) (f32.const -0x1.c7c8fcp-8))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.6ad9a4p-48) (f32.const -0x1.9138aap+55) (f32.const -0x1.4a774ep-40) (f32.const 0x1.1ff08p+76)) (f32.const 0x1.9cd8ecp+44))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.e1caecp-105) (f32.const 0x1.af0dd2p+77) (f32.const -0x1.016eep+56) (f32.const -0x1.ab70d6p+59)) (f32.const 0x1.54870ep+89))
+(assert_return (invoke "f32.no_reassociate_mul" (f32.const -0x1.3b1dcp-99) (f32.const 0x1.4e5a34p-49) (f32.const -0x1.38ba5ap+3) (f32.const 0x1.7fb8eep+59)) (f32.const 0x1.5bbf98p-85))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const -0x1.e7842ab7181p-667) (f64.const -0x1.fabf40ceeceafp+990) (f64.const -0x1.1a38a825ab01ap-376) (f64.const -0x1.27e8ea469b14fp+664)) (f64.const 0x1.336eb428af4f3p+613))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.4ca2292a6acbcp+454) (f64.const 0x1.6ffbab850089ap-516) (f64.const -0x1.547c32e1f5b93p-899) (f64.const -0x1.c7571d9388375p+540)) (f64.const 0x1.1ac796954fc1p-419))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.73881a52e0401p-501) (f64.const -0x1.1b68dd9efb1a7p+788) (f64.const 0x1.d1c5e6a3eb27cp-762) (f64.const -0x1.56cb2fcc7546fp+88)) (f64.const 0x1.f508db92c34efp-386))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.2efa87859987cp+692) (f64.const 0x1.68e4373e241p-423) (f64.const 0x1.4e2d0fb383a57p+223) (f64.const -0x1.301d3265c737bp-23)) (f64.const -0x1.4b2b6c393f30cp+470))
+(assert_return (invoke "f64.no_reassociate_mul" (f64.const 0x1.1013f7498b95fp-234) (f64.const 0x1.d2d1c36fff138p-792) (f64.const -0x1.cbf1824ea7bfdp+728) (f64.const -0x1.440da9c8b836dp-599)) (f64.const 0x1.1a16512881c91p-895))
+
+;; Test that x/0 is not folded away.
+
+(module
+  (func (export "f32.no_fold_div_0") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const 0.0)))
+  (func (export "f64.no_fold_div_0") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const 0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that x/-0 is not folded away.
+
+(module
+  (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32)
+    (f32.div (local.get $x) (f32.const -0.0)))
+  (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64)
+    (f64.div (local.get $x) (f64.const -0.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -0)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -0)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
+
+;; Test that sqrt(x*x+y*y) is not folded to hypot.
+
+(module
+  (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32)
+    (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
+  (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64)
+    (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
+)
+
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.c38d1p-71) (f32.const -0x1.359ddp-107)) (f32.const 0x1.c36a62p-71))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.99e0cap-114) (f32.const -0x1.ed0c6cp-69)) (f32.const 0x1.ed0e48p-69))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const -0x1.1b6ceap+5) (f32.const 0x1.5440bep+17)) (f32.const 0x1.5440cp+17))
+(assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.8f019ep-76) (f32.const -0x1.182308p-71)) (f32.const 0x1.17e2bcp-71))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.1a0ac4f7c8711p-636) (f64.const 0x1.1372ebafff551p-534)) (f64.const 0x1.13463fa37014ep-534))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.b793512167499p+395) (f64.const -0x1.11cbc52af4c36p+410)) (f64.const 0x1.11cbc530783a2p+410))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.76777f44ff40bp-536) (f64.const -0x1.c3896e4dc1fbp-766)) (f64.const 0x1.8p-536))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const -0x1.889ac72cc6b5dp-521) (f64.const 0x1.8d7084e659f3bp-733)) (f64.const 0x1.889ac72ca843ap-521))
+(assert_return (invoke "f64.no_fold_to_hypot" (f64.const 0x1.5ee588c02cb08p-670) (f64.const -0x1.05ce25788d9ecp-514)) (f64.const 0x1.05ce25788d9dfp-514))
+
+;; Test that 1.0/x isn't approximated.
+
+(module
+  (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.e7212p+127)) (f32.const 0x1.0d11f8p-128))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.42a466p-93)) (f32.const -0x1.963ee6p+92))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const 0x1.5d0c32p+76)) (f32.const 0x1.778362p-77))
+(assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.601de2p-82)) (f32.const -0x1.743d7ep+81))
+
+;; Test that 1.0/sqrt(x) isn't approximated or fused.
+
+(module
+  (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.sqrt (local.get $x))))
+  (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.sqrt (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.e82fc6p-8)) (f32.const 0x1.72c376p+3))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.b9fa9cp-66)) (f32.const 0x1.85a9bap+32))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.f4f546p-44)) (f32.const 0x1.6e01c2p+21))
+(assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.5da7aap-86)) (f32.const 0x1.b618cap+42))
+
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.1568a63b55fa3p+889)) (f64.const 0x1.5bc9c74c9952p-445))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.239fcd0939cafp+311)) (f64.const 0x1.5334a922b4818p-156))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.6e36a24e11054p+104)) (f64.const 0x1.ac13f20977f29p-53))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.23ee173219f83p+668)) (f64.const 0x1.df753e055862dp-335))
+(assert_return (invoke "f64.no_fuse_reciprocal_sqrt" (f64.const 0x1.b30f74caf9babp+146)) (f64.const 0x1.88bfc3d1764a9p-74))
+
+;; Test that sqrt(1.0/x) isn't approximated.
+
+(module
+  (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32)
+    (f32.sqrt (f32.div (f32.const 1.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.50511ep-9)) (f32.const 0x1.3bdd46p+4))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.125ec2p+69)) (f32.const 0x1.5db572p-35))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.ba4c5p+13)) (f32.const 0x1.136f16p-7))
+(assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.4a5be2p+104)) (f32.const 0x1.c2b5bp-53))
+
+;; Test that converting i32/i64 to f32/f64 and back isn't folded away.
+
+(module
+  (func (export "i32.no_fold_f32_s") (param i32) (result i32)
+    (i32.trunc_f32_s (f32.convert_i32_s (local.get 0))))
+  (func (export "i32.no_fold_f32_u") (param i32) (result i32)
+    (i32.trunc_f32_u (f32.convert_i32_u (local.get 0))))
+  (func (export "i64.no_fold_f64_s") (param i64) (result i64)
+    (i64.trunc_f64_s (f64.convert_i64_s (local.get 0))))
+  (func (export "i64.no_fold_f64_u") (param i64) (result i64)
+    (i64.trunc_f64_u (f64.convert_i64_u (local.get 0))))
+)
+
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000001)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_s" (i32.const 0xf0000010)) (i32.const 0xf0000010))
+
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000000)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0x1000001)) (i32.const 0x1000000))
+(assert_return (invoke "i32.no_fold_f32_u" (i32.const 0xf0000010)) (i32.const 0xf0000000))
+
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_s" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000400))
+
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000000)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0x20000000000001)) (i64.const 0x20000000000000))
+(assert_return (invoke "i64.no_fold_f64_u" (i64.const 0xf000000000000400)) (i64.const 0xf000000000000000))
+
+;; Test that x+y-y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32)
+    (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64)
+    (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.a884dp-23) (f32.const 0x1.f2ae1ep-19)) (f32.const -0x1.a884ep-23))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.fc04fp+82) (f32.const -0x1.65403ap+101)) (f32.const -0x1p+83))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.870fa2p-78) (f32.const 0x1.c54916p-56)) (f32.const 0x1.8p-78))
+(assert_return (invoke "f32.no_fold_add_sub" (f32.const -0x1.17e966p-108) (f32.const -0x1.5fa61ap-84)) (f32.const -0x1p-107))
+
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1053ea172dba8p-874) (f64.const 0x1.113c413408ac8p-857)) (f64.const -0x1.1053ea172p-874))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const 0x1.e377d54807972p-546) (f64.const 0x1.040a0a4d1ff7p-526)) (f64.const 0x1.e377d548p-546))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.75f53cd926b62p-30) (f64.const -0x1.66b176e602bb5p-3)) (f64.const -0x1.75f53dp-30))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.c450ff28332ap-341) (f64.const 0x1.15a5855023baep-305)) (f64.const -0x1.c451p-341))
+(assert_return (invoke "f64.no_fold_add_sub" (f64.const -0x1.1ad4a596d3ea8p-619) (f64.const -0x1.17d81a41c0ea8p-588)) (f64.const -0x1.1ad4a8p-619))
+
+;; Test that x-y+y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.a31a1p-111) (f32.const 0x1.745efp-95)) (f32.const -0x1.a4p-111))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.3d5328p+26) (f32.const 0x1.58567p+35)) (f32.const 0x1.3d54p+26))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.374e26p-39) (f32.const -0x1.66a5p-27)) (f32.const 0x1.374p-39))
+(assert_return (invoke "f32.no_fold_sub_add" (f32.const 0x1.320facp-3) (f32.const -0x1.ac069ap+14)) (f32.const 0x1.34p-3))
+
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.8f92aad2c9b8dp+255) (f64.const -0x1.08cd4992266cbp+259)) (f64.const 0x1.8f92aad2c9b9p+255))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.5aaff55742c8bp-666) (f64.const 0x1.8f5f47181f46dp-647)) (f64.const 0x1.5aaff5578p-666))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.21bc52967a98dp+251) (f64.const -0x1.fcffaa32d0884p+300)) (f64.const 0x1.2p+251))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.9c78361f47374p-26) (f64.const -0x1.69d69f4edc61cp-13)) (f64.const 0x1.9c78361f48p-26))
+(assert_return (invoke "f64.no_fold_sub_add" (f64.const 0x1.4dbe68e4afab2p-367) (f64.const -0x1.dc24e5b39cd02p-361)) (f64.const 0x1.4dbe68e4afacp-367))
+
+;; Test that x*y/y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.0b56b8p-26) (f32.const 0x1.48264cp-106)) (f32.const -0x1.0b56a4p-26))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.e7555cp-48) (f32.const -0x1.9161cp+48)) (f32.const -0x1.e7555ap-48))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const 0x1.aaa50ep+52) (f32.const -0x1.dfb39ep+60)) (f32.const 0x1.aaa50cp+52))
+(assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.2b7dfap-92) (f32.const -0x1.7c4ca6p-37)) (f32.const -0x1.2b7dfep-92))
+
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.3d79ff4118a1ap-837) (f64.const -0x1.b8b5dda31808cp-205)) (f64.const -0x1.3d79ff412263ep-837))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.f894d1ee6b3a4p+384) (f64.const 0x1.8c2606d03d58ap+585)) (f64.const 0x1.f894d1ee6b3a5p+384))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.a022260acc993p+238) (f64.const -0x1.5fbc128fc8e3cp-552)) (f64.const -0x1.a022260acc992p+238))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const 0x1.9d4b8ed174f54p-166) (f64.const 0x1.ee3d467aeeac6p-906)) (f64.const 0x1.8dcc95a053b2bp-166))
+(assert_return (invoke "f64.no_fold_mul_div" (f64.const -0x1.e95ea897cdcd4p+660) (f64.const -0x1.854d5df085f2ep-327)) (f64.const -0x1.e95ea897cdcd5p+660))
+
+;; Test that x/y*y is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y)))
+  (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.1f9836p-52) (f32.const -0x1.16c4e4p-18)) (f32.const -0x1.1f9838p-52))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.c5972cp-126) (f32.const -0x1.d6659ep+7)) (f32.const 0x1.c5980ep-126))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.2e3a9ep-74) (f32.const -0x1.353994p+59)) (f32.const -0x1.2e3a4p-74))
+(assert_return (invoke "f32.no_fold_div_mul" (f32.const 0x1.d96b82p-98) (f32.const 0x1.95d908p+27)) (f32.const 0x1.d96b84p-98))
+
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const 0x1.d01f913a52481p-876) (f64.const -0x1.2cd0668b28344p+184)) (f64.const 0x1.d020daf71cdcp-876))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.81cb7d400918dp-714) (f64.const 0x1.7caa643586d6ep-53)) (f64.const -0x1.81cb7d400918ep-714))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.66904c97b5c8ep-145) (f64.const 0x1.5c3481592ad4cp+428)) (f64.const -0x1.66904c97b5c8dp-145))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278))
+(assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620))
+
+;; Test that x/2*2 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (f32.const 2.0)) (f32.const 2.0)))
+  (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (f64.const 2.0)) (f64.const 2.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125))
+(assert_return (invoke "f64.no_fold_div2_mul2" (f64.const 0x1.fffffffffffffp-1022)) (f64.const 0x1p-1021))
+
+;; Test that promote(demote(x)) is not folded to x.
+
+(module
+  (func (export "no_fold_demote_promote") (param $x f64) (result f64)
+    (f64.promote_f32 (f32.demote_f64 (local.get $x))))
+)
+
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133))
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.19e6c79938a6fp-85)) (f64.const -0x1.19e6c8p-85))
+(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.49b297ec44dc1p+107)) (f64.const 0x1.49b298p+107))
+(assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.74f5bd865163p-88)) (f64.const -0x1.74f5bep-88))
+(assert_return (invoke "no_fold_demote_promote" (f64.const 0x1.26d675662367ep+104)) (f64.const 0x1.26d676p+104))
+
+;; Test that demote(promote(x)) is not folded to x, and aside from NaN is
+;; bit-preserving.
+
+(module
+  (func (export "no_fold_promote_demote") (param $x f32) (result f32)
+    (f32.demote_f64 (f64.promote_f32 (local.get $x))))
+)
+
+(assert_return (invoke "no_fold_promote_demote" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffcp-127)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffcp-127)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf))
+
+;; Test that demote(x+promote(y)) is not folded to demote(x)+y.
+
+(module
+  (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y)))))
+  (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32)
+    (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x))))
+)
+
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95))
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.065b3d81ad8dp+37) (f32.const 0x1.758cd8p+38)) (f32.const 0x1.f8ba76p+38))
+(assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.626c80963bd17p-119) (f32.const -0x1.9bbf86p-121)) (f32.const 0x1.f6f93ep-120))
+(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.0d5110e3385bbp-20) (f32.const 0x1.096f4ap-29)) (f32.const -0x1.0ccc5ap-20))
+(assert_return (invoke "no_demote_mixed_add" (f64.const -0x1.73852db4e5075p-20) (f32.const -0x1.24e474p-41)) (f32.const -0x1.738536p-20))
+
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.3f4e9cp-119) (f64.const 0x1.f51a9d04854f9p-95)) (f32.const 0x1.f51a9ep-95))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.758cd8p+38) (f64.const 0x1.065b3d81ad8dp+37)) (f32.const 0x1.f8ba76p+38))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.9bbf86p-121) (f64.const 0x1.626c80963bd17p-119)) (f32.const 0x1.f6f93ep-120))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const 0x1.096f4ap-29) (f64.const -0x1.0d5110e3385bbp-20)) (f32.const -0x1.0ccc5ap-20))
+(assert_return (invoke "no_demote_mixed_add_commuted" (f32.const -0x1.24e474p-41) (f64.const -0x1.73852db4e5075p-20)) (f32.const -0x1.738536p-20))
+
+;; Test that demote(x-promote(y)) is not folded to demote(x)-y.
+
+(module
+  (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32)
+    (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y)))))
+)
+
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.6e2c5ac39f63ep+30) (f32.const 0x1.d48ca4p+17)) (f32.const -0x1.6e3bp+30))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const -0x1.98c74350dde6ap+6) (f32.const 0x1.9d69bcp-12)) (f32.const -0x1.98c7aap+6))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.0459f34091dbfp-54) (f32.const 0x1.61ad08p-71)) (f32.const 0x1.045942p-54))
+(assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a7498dca3fdb7p+14) (f32.const 0x1.ed21c8p+15)) (f32.const -0x1.197d02p+15))
+
+;; Test that converting between integer and float and back isn't folded away.
+
+(module
+  (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_s (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
+    (f32.convert_i32_s (i32.trunc_f32_u (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_s (local.get $x))))
+  (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
+    (f32.convert_i32_u (i32.trunc_f32_u (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_s (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
+    (f64.convert_i32_s (i32.trunc_f64_u (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_s (local.get $x))))
+  (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
+    (f64.convert_i32_u (i32.trunc_f64_u (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_s (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
+    (f32.convert_i64_s (i64.trunc_f32_u (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_s (local.get $x))))
+  (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
+    (f32.convert_i64_u (i64.trunc_f32_u (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_s (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
+    (f64.convert_i64_s (i64.trunc_f64_u (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_s (local.get $x))))
+  (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
+    (f64.convert_i64_u (i64.trunc_f64_u (local.get $x))))
+)
+
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+32))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i32.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
+
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1.fffffffep+31))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i32.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
+
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_s" (f32.const -1.5)) (f32.const -1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_s" (f32.const -0.5)) (f32.const 0.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_s_convert_u" (f32.const -1.5)) (f32.const 0x1p+64))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const 1.5)) (f32.const 1.0))
+(assert_return (invoke "f32.i64.no_fold_trunc_u_convert_u" (f32.const -0.5)) (f32.const 0.0))
+
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_s" (f64.const -1.5)) (f64.const -1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_s" (f64.const -0.5)) (f64.const 0.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_s_convert_u" (f64.const -1.5)) (f64.const 0x1p+64))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const 1.5)) (f64.const 1.0))
+(assert_return (invoke "f64.i64.no_fold_trunc_u_convert_u" (f64.const -0.5)) (f64.const 0.0))
+
+;; Test that dividing by a loop-invariant constant isn't optimized to be a
+;; multiplication by a reciprocal, which would be particularly tempting since
+;; the reciprocal computation could be hoisted.
+
+(module
+  (memory 1 1)
+  (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x)))
+
+  (func (export "run") (param $n i32) (param $z f32)
+    (local $i i32)
+    (block $exit
+      (loop $cont
+        (f32.store
+          (local.get $i)
+          (f32.div (f32.load (local.get $i)) (local.get $z))
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i)))
+)
+
+(invoke "init" (i32.const  0) (f32.const 15.1))
+(invoke "init" (i32.const  4) (f32.const 15.2))
+(invoke "init" (i32.const  8) (f32.const 15.3))
+(invoke "init" (i32.const 12) (f32.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 15.1))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 15.2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 15.3))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 15.4))
+(invoke "run" (i32.const 16) (f32.const 3.0))
+(assert_return (invoke "check" (i32.const  0)) (f32.const 0x1.422222p+2))
+(assert_return (invoke "check" (i32.const  4)) (f32.const 0x1.444444p+2))
+(assert_return (invoke "check" (i32.const  8)) (f32.const 0x1.466666p+2))
+(assert_return (invoke "check" (i32.const 12)) (f32.const 0x1.488888p+2))
+
+(module
+  (memory 1 1)
+  (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x)))
+
+  (func (export "run") (param $n i32) (param $z f64)
+    (local $i i32)
+    (block $exit
+      (loop $cont
+        (f64.store
+          (local.get $i)
+          (f64.div (f64.load (local.get $i)) (local.get $z))
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 8)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
+      )
+    )
+  )
+
+  (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i)))
+)
+
+(invoke "init" (i32.const  0) (f64.const 15.1))
+(invoke "init" (i32.const  8) (f64.const 15.2))
+(invoke "init" (i32.const 16) (f64.const 15.3))
+(invoke "init" (i32.const 24) (f64.const 15.4))
+(assert_return (invoke "check" (i32.const  0)) (f64.const 15.1))
+(assert_return (invoke "check" (i32.const  8)) (f64.const 15.2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 15.3))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 15.4))
+(invoke "run" (i32.const 32) (f64.const 3.0))
+(assert_return (invoke "check" (i32.const 0)) (f64.const 0x1.4222222222222p+2))
+(assert_return (invoke "check" (i32.const 8)) (f64.const 0x1.4444444444444p+2))
+(assert_return (invoke "check" (i32.const 16)) (f64.const 0x1.4666666666667p+2))
+(assert_return (invoke "check" (i32.const 24)) (f64.const 0x1.4888888888889p+2))
+
+;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc.
+
+(module
+  (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y))))
+  (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y))))
+  (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ult" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.ule" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 2.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.ugt" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 3.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 2.0)) (i32.const 1))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.uge" (f32.const 2.0) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ult" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 3.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.ule" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 2.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.ugt" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 3.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 2.0)) (i32.const 1))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.uge" (f64.const 2.0) (f64.const nan)) (i32.const 1))
+
+;; Test that x<y?x:y, etc. using select aren't folded to min, etc.
+
+(module
+  (func (export "f32.no_fold_lt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.lt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_le_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_gt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_ge_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.ge (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_lt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.lt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_le_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_gt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.ge (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_lt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc.
+
+(module
+  (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+  (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
+    )
+  )
+)
+
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_lt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_le_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const nan) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_le_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const nan) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that x<0?-x:x, etc. using select aren't folded to abs.
+
+(module
+  (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.lt (local.get $x) (f32.const 0.0))))
+  (func (export "f32.no_fold_le_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.le (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_gt_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.gt (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_ge_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.ge (local.get $x) (f32.const 0.0))))
+
+  (func (export "f64.no_fold_lt_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.lt (local.get $x) (f64.const 0.0))))
+  (func (export "f64.no_fold_le_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.le (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_gt_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.gt (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.ge (local.get $x) (f64.const 0.0))))
+)
+
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_select_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_select_to_abs" (f64.const -0.0)) (f64.const -0.0))
+
+;; Test that x<0?-x:x, etc. using if aren't folded to abs.
+
+(module
+  (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.lt (local.get $x) (f32.const 0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.le (local.get $x) (f32.const -0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.gt (local.get $x) (f32.const -0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
+    )
+  )
+  (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.ge (local.get $x) (f32.const 0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
+    )
+  )
+
+  (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.lt (local.get $x) (f64.const 0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.le (local.get $x) (f64.const -0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
+    )
+  )
+  (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.gt (local.get $x) (f64.const -0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
+    )
+  )
+  (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.ge (local.get $x) (f64.const 0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
+    )
+  )
+)
+
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -nan)) (f32.const -nan))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_le_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_gt_if_to_abs" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -nan)) (f32.const nan))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_ge_if_to_abs" (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_lt_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -nan)) (f64.const -nan))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_le_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_gt_if_to_abs" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const nan:0x4000000000000)) (f64.const -nan:0x4000000000000))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -nan)) (f64.const nan))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_ge_if_to_abs" (f64.const -0.0)) (f64.const -0.0))
+
+;; Test for a historic spreadsheet bug.
+;; https://support.microsoft.com/en-us/kb/78113
+
+(module
+  (func (export "f32.incorrect_correction") (result f32)
+    (f32.sub (f32.sub (f32.add (f32.const 1.333) (f32.const 1.225)) (f32.const 1.333)) (f32.const 1.225))
+  )
+  (func (export "f64.incorrect_correction") (result f64)
+    (f64.sub (f64.sub (f64.add (f64.const 1.333) (f64.const 1.225)) (f64.const 1.333)) (f64.const 1.225))
+  )
+)
+
+(assert_return (invoke "f32.incorrect_correction") (f32.const 0x1p-23))
+(assert_return (invoke "f64.incorrect_correction") (f64.const -0x1p-52))
+
+;; Test for a historical calculator bug.
+;; http://www.hpmuseum.org/cgi-sys/cgiwrap/hpmuseum/articles.cgi?read=735
+
+(module
+  (func (export "calculate") (result f32)
+    (local $x f32)
+    (local $r f32)
+    (local $q f32)
+    (local $z0 f32)
+    (local $z1 f32)
+    (local.set $x (f32.const 156.25))
+    (local.set $r (f32.const 208.333333334))
+    (local.set $q (f32.const 1.77951304201))
+    (local.set $z0 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f32.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
+  )
+)
+
+(assert_return (invoke "calculate") (f32.const -0x1.d2ed46p+8))
+
+(module
+  (func (export "calculate") (result f64)
+    (local $x f64)
+    (local $r f64)
+    (local $q f64)
+    (local $z0 f64)
+    (local $z1 f64)
+    (local.set $x (f64.const 156.25))
+    (local.set $r (f64.const 208.333333334))
+    (local.set $q (f64.const 1.77951304201))
+    (local.set $z0 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f64.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
+  )
+)
+
+(assert_return (invoke "calculate") (f64.const -0x1.d2ed4d0218c93p+8))
+
+;; Test that 0 - (-0 - x) is not optimized to x.
+;; https://llvm.org/bugs/show_bug.cgi?id=26746
+
+(module
+  (func (export "llvm_pr26746") (param $x f32) (result f32)
+    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $x)))
+  )
+)
+
+(assert_return (invoke "llvm_pr26746" (f32.const -0.0)) (f32.const 0.0))
+
+;; Test for improperly reassociating an addition and a conversion.
+;; https://llvm.org/bugs/show_bug.cgi?id=27153
+
+(module
+  (func (export "llvm_pr27153") (param $x i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.and (local.get $x) (i32.const 268435455))) (f32.const -8388608.0))
+  )
+)
+
+(assert_return (invoke "llvm_pr27153" (i32.const 33554434)) (f32.const 25165824.000000))
+
+;; Test that (float)x + (float)y is not optimized to (float)(x + y) when unsafe.
+;; https://llvm.org/bugs/show_bug.cgi?id=27036
+
+(module
+  (func (export "llvm_pr27036") (param $x i32) (param $y i32) (result f32)
+    (f32.add (f32.convert_i32_s (i32.or (local.get $x) (i32.const -25034805)))
+             (f32.convert_i32_s (i32.and (local.get $y) (i32.const 14942208))))
+  )
+)
+
+(assert_return (invoke "llvm_pr27036" (i32.const -25034805) (i32.const 14942208)) (f32.const -0x1.340068p+23))
+
+;; Test for bugs in old versions of historic IEEE 754 platforms as reported in:
+;;
+;; N. L. Schryer. 1981. A Test of a Computer's Floating-Point Arithmetic Unit.
+;; Tech. Rep. Computer Science Technical Report 89, AT&T Bell Laboratories, Feb.
+;;
+;; specifically, the appendices describing IEEE systems with "The Past" sections
+;; describing specific bugs. The 0 < 0 bug is omitted here due to being already
+;; covered elsewhere.
+(module
+  (func (export "thepast0") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
+    (f64.div (f64.mul (local.get $a) (local.get $b)) (f64.mul (local.get $c) (local.get $d)))
+  )
+
+  (func (export "thepast1") (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.sub (f64.mul (local.get $a) (local.get $b)) (local.get $c))
+  )
+
+  (func (export "thepast2") (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.mul (f32.mul (local.get $a) (local.get $b)) (local.get $c))
+  )
+)
+
+(assert_return (invoke "thepast0" (f64.const 0x1p-1021) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p1) (f64.const 0x1p-1)) (f64.const 0x1.fffffffffffffp-1022))
+(assert_return (invoke "thepast1" (f64.const 0x1p-54) (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1p-54)) (f64.const -0x1p-107))
+(assert_return (invoke "thepast2" (f32.const 0x1p-125) (f32.const 0x1p-1) (f32.const 0x1p0)) (f32.const 0x1p-126))
+
+;; Test for floating point tolerances observed in some GPUs.
+;; https://community.amd.com/thread/145582
+
+(module
+  (func (export "inverse") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (local.get $x))
+  )
+)
+
+(assert_return (invoke "inverse" (f32.const 96.0)) (f32.const 0x1.555556p-7))
+
+;; Test for incorrect rounding on sqrt(4.0).
+;; http://www.askvg.com/microsoft-windows-calculator-bug/
+
+(module
+  (func (export "f32_sqrt_minus_2") (param $x f32) (result f32)
+    (f32.sub (f32.sqrt (local.get $x)) (f32.const 2.0))
+  )
+
+  (func (export "f64_sqrt_minus_2") (param $x f64) (result f64)
+    (f64.sub (f64.sqrt (local.get $x)) (f64.const 2.0))
+  )
+)
+
+(assert_return (invoke "f32_sqrt_minus_2" (f32.const 4.0)) (f32.const 0.0))
+(assert_return (invoke "f64_sqrt_minus_2" (f64.const 4.0)) (f64.const 0.0))
+
+;; Test that 1.0 / (1.0 / x) is not optimized to x.
+
+(module
+  (func (export "f32.no_fold_recip_recip") (param $x f32) (result f32)
+    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $x))))
+
+  (func (export "f64.no_fold_recip_recip") (param $x f64) (result f64)
+    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e8bf18p+65)) (f32.const -0x1.e8bf16p+65))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.e24248p-77)) (f32.const 0x1.e24246p-77))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.caf0e8p-64)) (f32.const 0x1.caf0eap-64))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e66982p+4)) (f32.const -0x1.e66984p+4))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x1.f99916p+70)) (f32.const 0x1.f99914p+70))
+
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const inf)) (f32.const inf))
+
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.d81248dda63dp+148)) (f64.const -0x1.d81248dda63d1p+148))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.f4750312039e3p+66)) (f64.const -0x1.f4750312039e2p+66))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.fa50630eec7f6p+166)) (f64.const 0x1.fa50630eec7f5p+166))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.db0598617ba92p-686)) (f64.const 0x1.db0598617ba91p-686))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x1.85f1638a0c82bp+902)) (f64.const 0x1.85f1638a0c82ap+902))
+
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const inf)) (f64.const inf))
+
+;; Test that (x+y) * (x-y) is not optimized to x*x - y*y.
+
+(module
+  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.add (local.get $x) (local.get $y))
+             (f32.sub (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.add (local.get $x) (local.get $y))
+             (f64.sub (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.ef678ep-55) (f32.const 0x1.c160b8p-54)) (f32.const -0x1.129402p-107))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.2d76bcp+24) (f32.const 0x1.f4089cp+24)) (f32.const -0x1.36d89ap+49))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7ca2b2p+45) (f32.const -0x1.08513cp+47)) (f32.const -0x1.db10dep+93))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7d5e3p+17) (f32.const -0x1.c783b4p+7)) (f32.const 0x1.1c10a6p+35))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.daf96p+7) (f32.const -0x1.dac6bp+19)) (f32.const -0x1.b8422ep+39))
+
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.e17c0a02ac6b5p-476) (f64.const 0x1.e8f13f1fcdc14p-463)) (f64.const -0x1.d2ec518f62863p-925))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.971b55a57e3a3p-377) (f64.const 0x1.edeb4233c1b27p-399)) (f64.const 0x1.43b3f69fb258bp-753))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.c3b9dc02472fap-378) (f64.const -0x1.74e9faebaff14p-369)) (f64.const -0x1.0f9c07e8caa25p-737))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.afaf4688ed019p+179) (f64.const 0x1.b07171cb49e94p+188)) (f64.const -0x1.6d3f2e2bebcf7p+377))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.4377a98948f12p+114) (f64.const -0x1.500c05bd24c97p+90)) (f64.const 0x1.98b72dbf7bf72p+228))
+
+;; Test that x*x - y*y is not optimized to (x+y) * (x-y).
+
+(module
+  (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
+    (f32.sub (f32.mul (local.get $x) (local.get $x))
+             (f32.mul (local.get $y) (local.get $y))))
+
+  (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
+    (f64.sub (f64.mul (local.get $x) (local.get $x))
+             (f64.mul (local.get $y) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.8e2c14p-46) (f32.const 0x1.bad59ap-39)) (f32.const -0x1.7efe5p-77))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.7ef192p+41) (f32.const -0x1.db184ap+33)) (f32.const 0x1.1e6932p+83))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.7eb458p-12) (f32.const -0x1.52c498p-13)) (f32.const 0x1.cc0bc6p-24))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.2675c6p-44) (f32.const -0x1.edd31ap-46)) (f32.const 0x1.17294cp-88))
+(assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.9a5f92p+51) (f32.const -0x1.2b0098p+52)) (f32.const -0x1.7189a6p+103))
+
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.749a128f18f69p+356) (f64.const -0x1.0bc97ee1354e1p+337)) (f64.const 0x1.0f28115518d74p+713))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.2dab01b2215eap+309) (f64.const -0x1.e12b288bff2bdp+331)) (f64.const -0x1.c4319ad25d201p+663))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const 0x1.3ed898431e102p+42) (f64.const -0x1.c409183fa92e6p+39)) (f64.const 0x1.80a611103c71dp+84))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.be663e4c0e4b2p+182) (f64.const -0x1.da85703760d25p+166)) (f64.const 0x1.853434f1a2ffep+365))
+(assert_return (invoke "f64.no_algebraic_factoring" (f64.const -0x1.230e09952df1cp-236) (f64.const -0x1.fa2752adfadc9p-237)) (f64.const 0x1.42e43156bd1b8p-474))
+
+;; Test that platforms where SIMD instructions flush subnormals don't implicitly
+;; optimize using SIMD instructions.
+
+(module
+  (memory (data
+    "\01\00\00\00\01\00\00\80\01\00\00\00\01\00\00\80"
+    "\01\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00"
+    "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+  ))
+
+  (func (export "f32.simple_x4_sum")
+    (param $i i32)
+    (param $j i32)
+    (param $k i32)
+    (local $x0 f32) (local $x1 f32) (local $x2 f32) (local $x3 f32)
+    (local $y0 f32) (local $y1 f32) (local $y2 f32) (local $y3 f32)
+    (local.set $x0 (f32.load offset=0 (local.get $i)))
+    (local.set $x1 (f32.load offset=4 (local.get $i)))
+    (local.set $x2 (f32.load offset=8 (local.get $i)))
+    (local.set $x3 (f32.load offset=12 (local.get $i)))
+    (local.set $y0 (f32.load offset=0 (local.get $j)))
+    (local.set $y1 (f32.load offset=4 (local.get $j)))
+    (local.set $y2 (f32.load offset=8 (local.get $j)))
+    (local.set $y3 (f32.load offset=12 (local.get $j)))
+    (f32.store offset=0 (local.get $k) (f32.add (local.get $x0) (local.get $y0)))
+    (f32.store offset=4 (local.get $k) (f32.add (local.get $x1) (local.get $y1)))
+    (f32.store offset=8 (local.get $k) (f32.add (local.get $x2) (local.get $y2)))
+    (f32.store offset=12 (local.get $k) (f32.add (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "f32.load")
+    (param $k i32) (result f32)
+    (f32.load (local.get $k))
+  )
+)
+
+(assert_return (invoke "f32.simple_x4_sum" (i32.const 0) (i32.const 16) (i32.const 32)))
+(assert_return (invoke "f32.load" (i32.const 32)) (f32.const 0x1p-148))
+(assert_return (invoke "f32.load" (i32.const 36)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.load" (i32.const 40)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.load" (i32.const 44)) (f32.const -0x1p-149))
+
+(module
+  (memory (data
+    "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\80"
+    "\01\00\00\00\00\00\00\00\01\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+    "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00"
+  ))
+
+  (func (export "f64.simple_x4_sum")
+    (param $i i32)
+    (param $j i32)
+    (param $k i32)
+    (local $x0 f64) (local $x1 f64) (local $x2 f64) (local $x3 f64)
+    (local $y0 f64) (local $y1 f64) (local $y2 f64) (local $y3 f64)
+    (local.set $x0 (f64.load offset=0 (local.get $i)))
+    (local.set $x1 (f64.load offset=8 (local.get $i)))
+    (local.set $x2 (f64.load offset=16 (local.get $i)))
+    (local.set $x3 (f64.load offset=24 (local.get $i)))
+    (local.set $y0 (f64.load offset=0 (local.get $j)))
+    (local.set $y1 (f64.load offset=8 (local.get $j)))
+    (local.set $y2 (f64.load offset=16 (local.get $j)))
+    (local.set $y3 (f64.load offset=24 (local.get $j)))
+    (f64.store offset=0 (local.get $k) (f64.add (local.get $x0) (local.get $y0)))
+    (f64.store offset=8 (local.get $k) (f64.add (local.get $x1) (local.get $y1)))
+    (f64.store offset=16 (local.get $k) (f64.add (local.get $x2) (local.get $y2)))
+    (f64.store offset=24 (local.get $k) (f64.add (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "f64.load")
+    (param $k i32) (result f64)
+    (f64.load (local.get $k))
+  )
+)
+
+(assert_return (invoke "f64.simple_x4_sum" (i32.const 0) (i32.const 32) (i32.const 64)))
+(assert_return (invoke "f64.load" (i32.const 64)) (f64.const 0x0.0000000000001p-1021))
+(assert_return (invoke "f64.load" (i32.const 72)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.load" (i32.const 80)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "f64.load" (i32.const 88)) (f64.const -0x0.0000000000001p-1022))
+
+;; Test that plain summation is not reassociated, and that Kahan summation
+;; isn't optimized into plain summation.
+
+(module
+  (memory (data
+    "\c4\c5\57\24\a5\84\c8\0b\6d\b8\4b\2e\f2\76\17\1c\ca\4a\56\1e\1b\6e\71\22"
+    "\5d\17\1e\6e\bf\cd\14\5c\c7\21\55\51\39\9c\1f\b2\51\f0\a3\93\d7\c1\2c\ae"
+    "\7e\a8\28\3a\01\21\f4\0a\58\93\f8\42\77\9f\83\39\6a\5f\ba\f7\0a\d8\51\6a"
+    "\34\ca\ad\c6\34\0e\d8\26\dc\4c\33\1c\ed\29\90\a8\78\0f\d1\ce\76\31\23\83"
+    "\b8\35\e8\f2\44\b0\d3\a1\fc\bb\32\e1\b0\ba\69\44\09\d6\d9\7d\ff\2e\c0\5a"
+    "\36\14\33\14\3e\a9\fa\87\6d\8b\bc\ce\9d\a7\fd\c4\e9\85\3f\dd\d7\e1\18\a6"
+    "\50\26\72\6e\3f\73\0f\f8\12\93\23\34\61\76\12\48\c0\9b\05\93\eb\ac\86\de"
+    "\94\3e\55\e8\8c\e8\dd\e4\fc\95\47\be\56\03\21\20\4c\e6\bf\7b\f6\7f\d5\ba"
+    "\73\1c\c1\14\8f\c4\27\96\b3\bd\33\ff\78\41\5f\c0\5a\ce\f6\67\6e\73\9a\17"
+    "\66\70\03\f8\ce\27\a3\52\b2\9f\3b\bf\fb\ae\ed\d3\5a\f8\37\57\f0\f5\6e\ef"
+    "\b1\4d\70\3d\54\a7\01\9a\85\08\48\91\f5\9d\0c\60\87\5b\d9\54\1e\51\6d\88"
+    "\8e\08\8c\a5\71\3a\56\08\67\46\8f\8f\13\2a\2c\ec\2c\1f\b4\62\2b\6f\41\0a"
+    "\c4\65\42\a2\31\6b\2c\7d\3e\bb\75\ac\86\97\30\d9\48\cd\9a\1f\56\c4\c6\e4"
+    "\12\c0\9d\fb\ee\02\8c\ce\1c\f2\1e\a1\78\23\db\c4\1e\49\03\d3\71\cc\08\50"
+    "\c5\d8\5c\ed\d5\b5\65\ac\b5\c9\21\d2\c9\29\76\de\f0\30\1a\5b\3c\f2\3b\db"
+    "\3a\39\82\3a\16\08\6f\a8\f1\be\69\69\99\71\a6\05\d3\14\93\2a\16\f2\2f\11"
+    "\c7\7e\20\bb\91\44\ee\f8\e4\01\53\c0\b9\7f\f0\bf\f0\03\9c\6d\b1\df\a2\44"
+    "\01\6d\6b\71\2b\5c\b3\21\19\46\5e\8f\db\91\d3\7c\78\6b\b7\12\00\8f\eb\bd"
+    "\8a\f5\d4\2e\c4\c1\1e\df\73\63\59\47\49\03\0a\b7\cf\24\cf\9c\0e\44\7a\9e"
+    "\14\fb\42\bf\9d\39\30\9e\a0\ab\2f\d1\ae\9e\6a\83\43\e3\55\7d\85\bf\63\8a"
+    "\f8\96\10\1f\fe\6d\e7\22\1b\e1\69\46\8a\44\c8\c8\f9\0c\2b\19\07\a5\02\3e"
+    "\f2\30\10\9a\85\8a\5f\ef\81\45\a0\77\b1\03\10\73\4b\ae\98\9d\47\bf\9a\2d"
+    "\3a\d5\0f\03\66\e3\3d\53\d9\40\ce\1f\6f\32\2f\21\2b\23\21\6c\62\d4\a7\3e"
+    "\a8\ce\28\31\2d\00\3d\67\5e\af\a0\cf\2e\d2\b9\6b\84\eb\69\08\3c\62\36\be"
+    "\12\fd\36\7f\88\3e\ad\bc\0b\c0\41\c4\50\b6\e3\50\31\e8\ce\e2\96\65\55\9c"
+    "\16\46\e6\b0\2d\3a\e8\81\05\b0\bf\34\f7\bc\10\1c\fb\cc\3c\f1\85\97\42\9f"
+    "\eb\14\8d\3c\bf\d7\17\88\49\9d\8b\2b\b2\3a\83\d1\4f\04\9e\a1\0f\ad\08\9d"
+    "\54\af\d1\82\c3\ec\32\2f\02\8f\05\21\2d\a2\b7\e4\f4\6f\2e\81\2b\0b\9c\fc"
+    "\cb\fe\74\02\f9\db\f4\f3\ea\00\a8\ec\d1\99\74\26\dd\d6\34\d5\25\b1\46\dd"
+    "\9c\aa\71\f5\60\b0\88\c8\e0\0b\59\5a\25\4f\29\66\f9\e3\2e\fe\e9\da\e5\18"
+    "\4f\27\62\f4\ce\a4\21\95\74\c7\57\64\27\9a\4c\fd\54\7d\61\ce\c3\ac\87\46"
+    "\9c\fa\ff\09\ca\79\97\67\24\74\ca\d4\21\83\26\25\19\12\37\64\19\e5\65\e0"
+    "\74\75\8e\dd\c8\ef\74\c7\d8\21\2b\79\04\51\46\65\60\03\5d\fa\d8\f4\65\a4"
+    "\9e\5d\23\da\d7\8a\92\80\a4\de\78\3c\f1\57\42\6d\cd\c9\2f\d5\a4\9e\ab\40"
+    "\f4\cb\1b\d7\a3\ca\fc\eb\a7\01\b2\9a\69\4e\46\9b\18\4e\dd\79\a7\aa\a6\52"
+    "\39\1e\ef\30\cc\9b\bd\5b\ee\4c\21\6d\30\00\72\b0\46\5f\08\cf\c5\b9\e0\3e"
+    "\c2\b3\0c\dc\8e\64\de\19\42\79\cf\43\ea\43\5d\8e\88\f7\ab\15\dc\3f\c8\67"
+    "\20\db\b8\64\b1\47\1f\de\f2\cb\3f\59\9f\d8\46\90\dc\ae\2f\22\f9\e2\31\89"
+    "\d9\9c\1c\4c\d3\a9\4a\57\84\9c\9f\ea\2c\3c\ae\3c\c3\1e\8b\e5\4e\17\01\25"
+    "\db\34\46\5f\15\ea\05\0c\7c\d9\45\8c\19\d0\73\8a\96\16\dd\44\f9\05\b7\5b"
+    "\71\b0\e6\21\36\5f\75\89\91\73\75\ab\7d\ae\d3\73\ec\37\c6\ea\55\75\ef\ea"
+    "\ab\8b\7b\11\dc\6d\1a\b2\6a\c4\25\cf\aa\e3\9f\49\49\89\cb\37\9b\0a\a7\01"
+    "\60\70\dc\b7\c8\83\e1\42\f5\be\ad\62\94\ad\8d\a1"
+  ))
+
+  (func (export "f32.kahan_sum") (param $p i32) (param $n i32) (result f32)
+    (local $sum f32)
+    (local $c f32)
+    (local $t f32)
+    (block $exit
+      (loop $top
+        (local.set $t
+          (f32.sub
+            (f32.sub
+              (local.tee $sum
+                (f32.add
+                  (local.get $c)
+                  (local.tee $t
+                    (f32.sub (f32.load (local.get $p)) (local.get $t))
+                  )
+                )
+              )
+              (local.get $c)
+            )
+            (local.get $t)
+          )
+        )
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
+      )
+    )
+    (local.get $sum)
+  )
+
+  (func (export "f32.plain_sum") (param $p i32) (param $n i32) (result f32)
+    (local $sum f32)
+    (block $exit
+      (loop $top
+        (local.set $sum (f32.add (local.get $sum) (f32.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
+      )
+    )
+    (local.get $sum)
+  )
+)
+
+(assert_return (invoke "f32.kahan_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.101a1ap+104))
+(assert_return (invoke "f32.plain_sum" (i32.const 0) (i32.const 256)) (f32.const -0x1.a0343ap+103))
+
+(module
+  (memory (data "\13\05\84\42\5d\a2\2c\c6\43\db\55\a9\cd\da\55\e3\73\fc\58\d6\ba\d5\00\fd\83\35\42\88\8b\13\5d\38\4a\47\0d\72\73\a1\1a\ef\c4\45\17\57\d8\c9\46\e0\8d\6c\e1\37\70\c8\83\5b\55\5e\5a\2d\73\1e\56\c8\e1\6d\69\14\78\0a\8a\5a\64\3a\09\c7\a8\87\c5\f0\d3\5d\e6\03\fc\93\be\26\ca\d6\a9\91\60\bd\b0\ed\ae\f7\30\7e\92\3a\6f\a7\59\8e\aa\7d\bf\67\58\2a\54\f8\4e\fe\ed\35\58\a6\51\bf\42\e5\4b\66\27\24\6d\7f\42\2d\28\92\18\ec\08\ae\e7\55\da\b1\a6\65\a5\72\50\47\1b\b8\a9\54\d7\a6\06\5b\0f\42\58\83\8a\17\82\c6\10\43\a0\c0\2e\6d\bc\5a\85\53\72\7f\ad\44\bc\30\3c\55\b2\24\9a\74\3a\9e\e1\d8\0f\70\fc\a9\3a\cd\93\4b\ec\e3\7e\dd\5d\27\cd\f8\a0\9d\1c\11\c0\57\2e\fd\c8\13\32\cc\3a\1a\7d\a3\41\55\ed\c3\82\49\2a\04\1e\ef\73\b9\2e\2e\e3\5f\f4\df\e6\b2\33\0c\39\3f\6f\44\6a\03\c1\42\b9\fa\b1\c8\ed\a5\58\99\7f\ed\b4\72\9e\79\eb\fb\43\82\45\aa\bb\95\d2\ff\28\9e\f6\a1\ad\95\d6\55\95\0d\6f\60\11\c7\78\3e\49\f2\7e\48\f4\a2\71\d0\13\8e\b3\de\99\52\e3\45\74\ea\76\0e\1b\2a\c8\ee\14\01\c4\50\5b\36\3c\ef\ba\72\a2\a6\08\f8\7b\36\9d\f9\ef\0b\c7\56\2d\5c\f0\9d\5d\de\fc\b8\ad\0f\64\0e\97\15\32\26\c2\31\e6\05\1e\ef\cb\17\1b\6d\15\0b\74\5d\d3\2e\f8\6b\86\b4\ba\73\52\53\99\a9\76\20\45\c9\40\80\6b\14\ed\a1\fa\80\46\e6\26\d2\e6\98\c4\57\bf\c4\1c\a4\90\7a\36\94\14\ba\15\89\6e\e6\9c\37\8c\f4\de\12\22\5d\a1\79\50\67\0d\3d\7a\e9\d4\aa\2e\7f\2a\7a\30\3d\ea\5d\12\48\fe\e1\18\cd\a4\57\a2\87\3e\b6\9a\8b\db\da\9d\78\9c\cf\8d\b1\4f\90\b4\34\e0\9d\f6\ca\fe\4c\3b\78\6d\0a\5c\18\9f\61\b9\dd\b4\e0\0f\76\e0\1b\69\0d\5e\58\73\70\5e\0e\2d\a1\7d\ff\20\eb\91\34\92\ac\38\72\2a\1f\8e\71\2e\6a\f1\af\c7\27\70\d9\c4\57\f7\d2\3c\1d\b8\f0\f0\64\cf\dc\ae\be\a3\cc\3e\22\7d\4e\69\21\63\17\ed\03\02\54\9a\0f\50\4e\13\5a\35\a1\22\a4\df\86\c2\74\79\16\b8\69\69\a0\52\5d\11\64\bd\5b\93\fc\69\a0\f4\13\d0\81\51\dd\fa\0c\15\c3\7a\c9\62\7a\a9\1d\c9\e6\5a\b3\5b\97\02\3c\64\22\12\3c\22\90\64\2d\30\54\4c\b4\a1\22\09\57\22\5e\8e\38\2b\02\a8\ae\f6\be\0d\2b\f2\03\ad\fa\10\01\71\77\2a\30\02\95\f6\00\3e\d0\c4\8d\34\19\50\21\0a\bc\50\da\3c\30\d6\3a\31\94\8d\3a\fe\ef\14\57\9d\4b\93\00\96\24\0c\6f\fd\bc\23\76\02\6c\eb\52\72\80\11\7e\80\3a\13\12\38\1d\38\49\95\40\27\8a\44\7b\e8\dc\6d\8c\8c\8e\3c\b5\b3\18\0e\f6\08\1a\84\41\35\ff\8b\b8\93\40\ea\e1\51\1d\89\a5\8d\42\68\29\ea\2f\c1\7a\52\eb\90\5d\4d\d6\80\e3\d7\75\48\ce\ed\d3\01\1c\8d\5b\a5\94\0d\78\cf\f1\06\13\2f\98\02\a4\6d\2e\6c\f2\d5\74\29\89\4c\f9\03\f5\c7\18\ad\7a\f0\68\f8\5c\d6\59\87\6e\d6\3f\06\be\86\20\e3\41\91\22\f3\6e\8b\f0\68\1c\57\a7\fc\b0\7c\9e\99\0b\96\1a\89\5f\e6\0d\7c\08\51\a0\a2\67\9a\47\00\93\6b\f9\28\f0\68\db\62\f1\e0\65\2c\53\33\e0\a7\ca\11\42\30\f6\af\01\c1\65\3d\32\01\6f\ab\2e\be\d3\8b\be\14\c3\ff\ec\fb\f0\f9\c5\0c\05\6f\01\09\6b\e3\34\31\0c\1f\66\a6\42\bc\1a\87\49\16\16\8c\b0\90\0d\34\8c\0a\e1\09\5e\10\a4\6b\56\cc\f0\c9\bb\dc\b8\5c\ce\f6\cc\8d\75\7e\b3\07\88\04\2f\b4\5e\c9\e3\4a\23\73\19\62\6c\9a\03\76\44\86\9c\60\fc\db\72\8f\27\a0\dd\b3\c5\da\ff\f9\ec\6a\b1\7b\d3\cf\50\37\c9\7a\78\0c\e4\3a\b6\f5\e6\f4\98\6e\42\7d\35\73\8b\45\c0\56\97\cd\6d\ce\cf\ad\31\b3\c3\54\fa\ef\d5\c0\f4\6a\5f\54\e7\49\3e\33\0a\30\38\fd\d9\05\ff\a5\3f\57\46\14\b5\91\17\ca\6b\98\23\7a\65\b3\6c\02\b4\cc\79\5d\58\d8\b3\d5\94\ae\f4\6d\75\65\f7\92\bf\7e\47\4c\3c\ee\db\ac\f1\32\5d\fb\6f\41\1c\34\c8\83\4f\c2\58\01\be\05\3e\66\16\a6\04\6d\5d\4f\86\09\27\82\25\12\cd\3a\cd\ce\6b\bc\ca\ac\28\9b\ee\6a\25\86\9e\45\70\c6\d2\bd\3b\7d\42\e5\27\af\c7\1d\f4\81\c8\b3\76\8a\a8\36\a3\ae\2a\e6\18\e1\36\22\ad\f6\25\72\b0\39\8b\01\9a\22\7b\84\c3\2d\5f\72\a4\98\ac\15\70\e7\d4\18\e2\7d\d2\30\7c\33\08\cd\ca\c4\22\85\88\75\81\c6\4a\74\58\8d\e0\e8\ac\c5\ab\75\5a\f4\28\12\f0\18\45\52\f2\97\b2\93\41\6f\8d\7f\db\70\fb\a3\5d\1f\a7\8d\98\20\2b\22\9f\3a\01\b5\8b\1b\d2\cb\14\03\0e\14\14\d2\19\5a\1f\ce\5e\cd\81\79\15\01\ca\de\73\74\8c\56\20\9f\77\2d\25\16\f6\61\51\1d\a4\8e\9b\98\a5\c6\ec\a8\45\57\82\59\78\0d\90\b4\df\51\b0\c3\82\94\cc\b3\53\09\15\6d\96\6c\3a\40\47\b7\4a\7a\05\2f\a1\1e\8c\9d\a0\20\88\fb\52\b7\9f\f3\f3\bb\5f\e7\8a\61\a7\21\b1\ac\fa\09\aa\a4\6c\bc\24\80\ba\2a\e9\65\ff\70\ff\cc\fa\65\87\76\f3\c5\15\ce\cb\e8\42\31\00\0c\91\57\d9\e0\9d\35\54\24\ad\a4\d8\f9\08\67\63\c8\cf\81\dd\90\a2\d7\c4\07\4a\e6\10\6f\67\e7\27\d4\23\59\18\f2\a8\9d\5f\d8\94\30\aa\54\86\4f\87\9d\82\b5\26\ca\a6\96\bf\cf\55\f9\9d\37\01\19\48\43\c5\94\6c\f3\74\97\58\4c\3c\9d\08\e8\04\c2\58\30\76\e1\a0\f8\ea\e9\c5\ae\cf\78\9e\a9\0c\ac\b3\44\42\e0\bc\5d\1b\9c\49\58\4a\1c\19\49\c1\3a\ea\f5\eb\3b\81\a9\4b\70\0c\cc\9e\1a\d3\2f\b7\52\2f\20\3b\eb\64\51\1d\a0\2d\b2\3e\be\13\85\48\92\32\2e\db\5c\a1\e7\8c\45\91\35\01\0a\93\c2\eb\09\ce\f3\d2\22\24\d0\8c\cc\1d\9d\38\c8\4d\e3\82\cc\64\15\06\2d\e7\01\2f\ab\bb\b5\04\4c\92\1c\7a\d6\3f\e8\5f\31\15\0c\dc\e4\31\b4\c4\25\3e\2a\aa\00\9e\c8\e5\21\7a\7f\29\f1\c0\af\1d\5e\e8\63\39\ad\f8\7e\6c\c8\c5\7f\c2\a8\97\27\0a\d9\f4\21\6a\ea\03\09\fb\f7\96\3b\83\79\5f\7c\4b\30\9f\56\35\de\b4\73\d4\95\f0\14\c3\74\2f\0d\a3\1d\4e\8d\31\24\b3\1a\84\85\62\5a\7b\3c\14\39\17\e6\6d\eb\37\c2\00\58\5b\0b\e3\3c\8a\62\e1\f8\35\4b\56\e2\87\60\8b\be\a7\38\91\77\54\a9\5a\24\25\90\9f\a5\42\77\f3\5c\39\df\ff\74\07\76\a1\cd\1f\62\0b\81\81\68\af\05\c1\c0\7f\26\ee\c0\91\a3\6a\7d\29\61\45\27\e5\57\88\dc\0d\97\04\1a\33\a9\44\8a\da\02\10\45\3f\8e\55\a6\76\8c\4d\e3\f1\89\83\c8\d0\f8\9b\50\77\9f\47\df\4c\9c\66\0d\aa\18\b8\5f\4f\c4\01\ce\dc\84\ac\46\9e\69\e1\76\45\6b\61\89\e4\5d\94\bb\11\83\9f\78\d8\0a\d2\f5\7e\5d\43\ea\bc\10\f1\3a\c9\e2\64\fb\53\65\d0\c7\b4\a7\fb\d4\05\53\25\d0\cd\29\88\00\56\25\24\7d\5d\b4\f3\41\9f\e9\b5\f7\ae\64\2c\e3\c9\6d\d5\84\3a\72\12\b8\7a\d9\1b\09\e8\38\da\26\4f\04\ce\03\71\6e\8a\44\7b\5c\81\59\9c\d2\e4\c3\ba\59\a6\e5\28\a7\8f\9a\e4\d5\4e\b9\ca\7f\cb\75\b8\2b\43\3e\b3\15\46\b1\a5\bc\9d\9e\38\15\f1\bd\1b\21\aa\f1\82\00\95\fc\a7\77\47\39\a7\33\43\92\d7\52\40\4b\06\81\8a\a0\bd\f1\6b\99\84\42\5b\e2\3b\c5\5e\12\5c\28\4d\b6\0e\4e\c8\5c\e8\01\8a\c5\e7\e4\9d\42\ee\5d\9c\c4\eb\eb\68\09\27\92\95\9a\11\54\73\c4\12\80\fb\7d\fe\c5\08\60\7f\36\41\e0\10\ba\d6\2b\6c\f1\b4\17\fe\26\34\e3\4b\f8\a8\e3\91\be\4f\2a\fc\da\81\b8\e7\fe\d5\26\50\47\f3\1a\65\32\81\e0\05\b8\4f\32\31\26\00\4a\53\97\c2\c3\0e\2e\a1\26\54\ab\05\8e\56\2f\7d\af\22\84\68\a5\8b\97\f6\a4\fd\a8\cc\75\41\96\86\fd\27\3d\29\86\8d\7f\4c\d4\8e\73\41\f4\1e\e2\dd\58\27\97\ce\9c\94\cf\7a\04\2f\dc\ed"
+  ))
+
+  (func (export "f64.kahan_sum") (param $p i32) (param $n i32) (result f64)
+    (local $sum f64)
+    (local $c f64)
+    (local $t f64)
+    (block $exit
+      (loop $top
+        (local.set $t
+          (f64.sub
+            (f64.sub
+              (local.tee $sum
+                (f64.add
+                  (local.get $c)
+                  (local.tee $t
+                    (f64.sub (f64.load (local.get $p)) (local.get $t))
+                  )
+                )
+              )
+              (local.get $c)
+            )
+            (local.get $t)
+          )
+        )
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
+      )
+    )
+    (local.get $sum)
+  )
+
+  (func (export "f64.plain_sum") (param $p i32) (param $n i32) (result f64)
+    (local $sum f64)
+    (block $exit
+      (loop $top
+        (local.set $sum (f64.add (local.get $sum) (f64.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
+      )
+    )
+    (local.get $sum)
+  )
+)
+
+(assert_return (invoke "f64.kahan_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a5ffc88p+998))
+(assert_return (invoke "f64.plain_sum" (i32.const 0) (i32.const 256)) (f64.const 0x1.dd7cb2a63fc87p+998))
+
+;; Test that -(x - y) is not folded to y - x.
+
+(module
+  (func (export "f32.no_fold_neg_sub") (param $x f32) (param $y f32) (result f32)
+    (f32.neg (f32.sub (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_neg_sub") (param $x f64) (param $y f64) (result f64)
+    (f64.neg (f64.sub (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_neg_sub" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_neg_sub" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that -(x + y) is not folded to (-x + -y).
+
+(module
+  (func (export "f32.no_fold_neg_add") (param $x f32) (param $y f32) (result f32)
+    (f32.neg (f32.add (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_fold_neg_add") (param $x f64) (param $y f64) (result f64)
+    (f64.neg (f64.add (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const 0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.no_fold_neg_add" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const -0.0) (f64.const 0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.no_fold_neg_add" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that (-x + -y) is not folded to -(x + y).
+
+(module
+  (func (export "f32.no_fold_add_neg_neg") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.neg (local.get $x)) (f32.neg (local.get $y))))
+
+  (func (export "f64.no_fold_add_neg_neg") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.neg (local.get $x)) (f64.neg (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const 0.0) (f32.const 0.0)) (f32.const -0.0))
+
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const -0.0) (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg_neg" (f64.const 0.0) (f64.const 0.0)) (f64.const -0.0))
+
+;; Test that -x + x is not folded to 0.0.
+
+(module
+  (func (export "f32.no_fold_add_neg") (param $x f32) (result f32)
+    (f32.add (f32.neg (local.get $x)) (local.get $x)))
+
+  (func (export "f64.no_fold_add_neg") (param $x f64) (result f64)
+    (f64.add (f64.neg (local.get $x)) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const inf)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_add_neg" (f32.const -inf)) (f32.const nan:canonical))
+
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const inf)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_add_neg" (f64.const -inf)) (f64.const nan:canonical))
+
+;; Test that x+x+x+x+x+x is not folded to x * 6.
+
+(module
+  (func (export "f32.no_fold_6x_via_add") (param $x f32) (result f32)
+    (f32.add (f32.add (f32.add (f32.add (f32.add
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
+
+  (func (export "f64.no_fold_6x_via_add") (param $x f64) (result f64)
+    (f64.add (f64.add (f64.add (f64.add (f64.add
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
+)
+
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.598a0cp+99)) (f32.const -0x1.03278ap+102))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.d3e7acp-77)) (f32.const -0x1.5eedc2p-74))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const 0x1.00fa02p-77)) (f32.const 0x1.817702p-75))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.51f434p-31)) (f32.const -0x1.faee4cp-29))
+(assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.00328ap+80)) (f32.const -0x1.804bcep+82))
+
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.310e15acaffe6p+68)) (f64.const -0x1.c995208307fdap+70))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.aad62c78fa9b4p-535)) (f64.const -0x1.4020a15abbf46p-532))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.f8fbfa94f6ab2p+271)) (f64.const -0x1.7abcfbefb9005p+274))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const 0x1.756ccc2830a8ep+751)) (f64.const 0x1.1811991e247ebp+754))
+(assert_return (invoke "f64.no_fold_6x_via_add" (f64.const -0x1.8fd1ab1d2402ap+234)) (f64.const -0x1.2bdd4055db01fp+237))
+
+;; Test that (x/y)/z is not optimized to x/(y*z),
+;; which is an "allowable alternative Form" in Fortran.
+
+(module
+  (func (export "f32.no_fold_div_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.div (f32.div (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_fold_div_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.div (f64.div (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.f70228p+78) (f32.const -0x1.fbc612p-16) (f32.const -0x1.8c379p+10)) (f32.const -0x1.47b43cp+83))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.d29d2ep-70) (f32.const 0x1.f3a17ep+110) (f32.const -0x1.64d41p-112)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.867f98p+43) (f32.const 0x1.30acfcp-105) (f32.const 0x1.e210d8p+105)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.c4001ap-14) (f32.const -0x1.9beb6cp+124) (f32.const -0x1.74f34cp-43)) (f32.const -0x1.819874p-96))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.db0e6ep+46) (f32.const 0x1.55eea2p+56) (f32.const -0x1.f3134p+124)) (f32.const -0x1.6cep-135))
+
+(assert_return (invoke "f64.no_fold_div_div" (f64.const 0x1.b4dc8ec3c7777p+337) (f64.const 0x1.9f95ac2d1863p+584) (f64.const -0x1.d4318abba341ep-782)) (f64.const -0x1.2649159d87e02p+534))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.ac53af5eb445fp+791) (f64.const 0x1.8549c0a4ceb13p-29) (f64.const 0x1.64e384003c801p+316)) (f64.const -0x1.9417cdccbae91p+503))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.d2685afb27327p+2) (f64.const -0x1.abb1eeed3dbebp+880) (f64.const 0x1.a543e2e6968a3p+170)) (f64.const 0x0.0000002a69a5fp-1022))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.47ddede78ad1cp+825) (f64.const 0x1.6d932d070a367p-821) (f64.const 0x1.79cf18cc64fp+961)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.f73d4979a9379p-888) (f64.const 0x1.4d83b53e97788p-596) (f64.const -0x1.f8f86c9603b5bp-139)) (f64.const 0x1.87a7bd89c586cp-154))
+
+;; Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w), example from
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 7.4.1: FORTRAN Floating Point in a Nutshell: Philosophy
+
+(module
+  (func (export "f32.no_fold_mul_divs") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (f32.div (local.get $z) (local.get $w))))
+
+  (func (export "f64.no_fold_mul_divs") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (f64.div (local.get $z) (local.get $w))))
+)
+
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.c483bep-109) (f32.const 0x1.ee1c3cp-92) (f32.const 0x1.800756p-88) (f32.const -0x1.95b972p+4)) (f32.const 0x1.bbd30cp-110))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.0f4262p+102) (f32.const 0x1.248498p+25) (f32.const 0x1.f66a7cp-17) (f32.const 0x1.897fc8p-3)) (f32.const -0x1.2f1aa4p+63))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.df5f22p+33) (f32.const -0x1.fcee3ep+39) (f32.const -0x1.9ea914p+29) (f32.const -0x1.2c4d3p+10)) (f32.const 0x1.4cf51cp+13))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.f568bcp+109) (f32.const 0x1.d9963p-34) (f32.const 0x1.37a87ap-16) (f32.const 0x1.a1524ap+78)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const 0x1.3dd592p-53) (f32.const -0x1.332c22p-64) (f32.const 0x1.b01064p-91) (f32.const 0x1.92bb3ap-36)) (f32.const -0x1.1c2dbp-44))
+
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.363d6764f7b12p-819) (f64.const -0x1.ed5471f660b5fp-464) (f64.const -0x1.671b0a7f3a42p+547) (f64.const 0x1.0633be34ba1f2p+186)) (f64.const -0x1.b8fa2b76baeebp+5))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.37880182e0fa8p+115) (f64.const 0x1.f842631576147p-920) (f64.const -0x1.999372231d156p+362) (f64.const -0x1.d5db481ab9554p+467)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.9a747c8d4b541p+308) (f64.const -0x1.99092ad6bbdc8p+192) (f64.const -0x1.cb23755c20101p-140) (f64.const -0x1.de8716f6b0b6ap+732)) (f64.const 0x1.ecf584c8466a5p-757))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.c424b2ece903dp+129) (f64.const -0x1.568ce281db37fp-347) (f64.const 0x1.53900b99fd3dp-957) (f64.const 0x1.5c33952254dadp+223)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const 0x1.a8ec2cecb32a9p-18) (f64.const 0x1.58acab0051851p-277) (f64.const 0x1.35e87c9077f7fp-620) (f64.const -0x1.925ee37ffb386p+352)) (f64.const -0x1.e6286970b31bfp-714))
+
+;; Test that (x/z)+(y/z) is not optimized to (x+y)/z.
+
+(module
+  (func (export "f32.no_fold_add_divs") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.add (f32.div (local.get $x) (local.get $z)) (f32.div (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_divs") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.add (f64.div (local.get $x) (local.get $z)) (f64.div (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.795e7p+8) (f32.const -0x1.48a5eep-5) (f32.const -0x1.9a244cp+126)) (f32.const -0x1.d709b6p-119))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.ae89e8p-63) (f32.const -0x1.e9903ep-49) (f32.const -0x1.370a8cp+47)) (f32.const 0x1.92f3f6p-96))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.626408p-46) (f32.const 0x1.2ee5b2p-64) (f32.const -0x1.ecefaap+48)) (f32.const 0x1.701864p-95))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const -0x1.061d3p-101) (f32.const 0x1.383492p-98) (f32.const -0x1.1d92d2p+88)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.1ea39ep-10) (f32.const 0x1.a7fffep-3) (f32.const 0x1.6fc574p-123)) (f32.const 0x1.28b2dep+120))
+
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.c5fcc3273b136p+430) (f64.const 0x1.892a09eed8f6fp+434) (f64.const 0x1.8258b71e64397p+911)) (f64.const 0x1.e36eb9706ad82p-478))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.2215d4061b5b3p+53) (f64.const 0x1.fb6184d97f27cp+5) (f64.const -0x1.f3bb59dacc0ebp-957)) (f64.const 0x1.2934eb0118be3p+1009))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.e7a4533741d8ep-967) (f64.const 0x1.a519bb7feb802p-976) (f64.const 0x1.1f8a43454e51ap+504)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const 0x1.991c6cf93e2b4p+313) (f64.const -0x1.f2f7432698d11p+329) (f64.const 0x1.0d8c1b2453617p-126)) (f64.const -0x1.d9e1d84ddd1d4p+455))
+(assert_return (invoke "f64.no_fold_add_divs" (f64.const -0x1.d436849dc1271p-728) (f64.const 0x1.19d1c1450e52dp-755) (f64.const 0x1.fa1be69ea06fep-70)) (f64.const -0x1.d9a9b1c2f5623p-659))
+
+;; Test that sqrt(x*x) is not optimized to abs(x).
+
+(module
+  (func (export "f32.no_fold_sqrt_square") (param $x f32) (result f32)
+    (f32.sqrt (f32.mul (local.get $x) (local.get $x))))
+
+  (func (export "f64.no_fold_sqrt_square") (param $x f64) (result f64)
+    (f64.sqrt (f64.mul (local.get $x) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.5cb316p-66)) (f32.const 0x1.5cb322p-66))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.b0f9e4p-73)) (f32.const 0x1.b211b2p-73))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.de417cp-71)) (f32.const 0x1.de65b8p-71))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.64c872p-86)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const inf))
+
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.1759d657203fdp-529)) (f64.const 0x1.1759dd57545f3p-529))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.4c68de1c78d83p-514)) (f64.const 0x1.4c68de1c78d81p-514))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.214736edb6e1ep-521)) (f64.const 0x1.214736ed9cf8dp-521))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.0864b9f68457p-616)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const inf))
+
+;; Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y).
+
+(module
+  (func (export "f32.no_fold_mul_sqrts") (param $x f32) (param $y f32) (result f32)
+    (f32.mul (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
+
+  (func (export "f64.no_fold_mul_sqrts") (param $x f64) (param $y f64) (result f64)
+    (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.418d14p-92) (f32.const 0x1.c6535cp-32)) (f32.const 0x1.7e373ap-62))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.4de7ep-88) (f32.const 0x1.84ff18p+6)) (f32.const 0x1.686668p-41))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.78091ep+101) (f32.const 0x1.81feb8p-9)) (f32.const 0x1.7cfb98p+46))
+(assert_return (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.583ap-56) (f32.const 0x1.14ba2ap-9)) (f32.const 0x1.b47a8ep-33))
+
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const -0x1.d1144cc28cdbep-635) (f64.const -0x1.bf9bc373d3b6ap-8)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.5a7eb976bebc9p-643) (f64.const 0x1.f30cb8865a4cap-404)) (f64.const 0x1.260a1032d6e76p-523))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.711a0c1707935p-89) (f64.const 0x1.6fb5de51a20d3p-913)) (f64.const 0x1.7067ca28e31ecp-501))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.fb0bbea33b076p-363) (f64.const 0x1.d963b34894158p-573)) (f64.const 0x1.e9edc1fa624afp-468))
+(assert_return (invoke "f64.no_fold_mul_sqrts" (f64.const 0x1.8676eab7a4d0dp+24) (f64.const 0x1.75a58231ba7a5p+513)) (f64.const 0x1.0e16aebe203b3p+269))
+
+;; Test that sqrt(x)/sqrt(y) is not optimized to sqrt(x/y).
+
+(module
+  (func (export "f32.no_fold_div_sqrts") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
+
+  (func (export "f64.no_fold_div_sqrts") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)) (f32.const nan:canonical))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b983b6p+32) (f32.const 0x1.901f1ep+27)) (f32.const 0x1.7c4df6p+2))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.d45e72p-120) (f32.const 0x1.ab49ccp+15)) (f32.const 0x1.7b0b04p-68))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.b2e444p+59) (f32.const 0x1.5b8b16p-30)) (f32.const 0x1.94fca8p+44))
+(assert_return (invoke "f32.no_fold_div_sqrts" (f32.const 0x1.835aa6p-112) (f32.const 0x1.d17128p-103)) (f32.const 0x1.4a468p-5))
+
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const -0x1.509fc16411167p-711) (f64.const -0x1.9c4255f5d6517p-187)) (f64.const nan:canonical))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.b6897bddac76p-587) (f64.const 0x1.104578b4c91f3p+541)) (f64.const 0x1.44e4f21f26cc9p-564))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.ac83451b08989p+523) (f64.const 0x1.8da575c6d12b8p-109)) (f64.const 0x1.09c003991ce17p+316))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.bab7836456417p-810) (f64.const 0x1.1ff60d03ba607p+291)) (f64.const 0x1.c0e6c833bf657p-551))
+(assert_return (invoke "f64.no_fold_div_sqrts" (f64.const 0x1.a957816ad9515p-789) (f64.const 0x1.8c18a3a222ab1p+945)) (f64.const 0x1.0948539781e92p-867))
+
+;; Test that (x*sqrt(y))/y is not optimized to x/sqrt(y).
+
+(module
+  (func (export "f32.no_fold_mul_sqrt_div") (param $x f32) (param $y f32) (result f32)
+    (f32.div (f32.mul (local.get $x) (f32.sqrt (local.get $y))) (local.get $y)))
+
+  (func (export "f64.no_fold_mul_sqrt_div") (param $x f64) (param $y f64) (result f64)
+    (f64.div (f64.mul (local.get $x) (f64.sqrt (local.get $y))) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.90bf1cp-120) (f32.const 0x1.8dbe88p-97)) (f32.const -0x0p+0))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const 0x1.8570e8p+29) (f32.const 0x1.217d3p-128)) (f32.const 0x1.6e391ap+93))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.5b4652p+43) (f32.const 0x1.a9d71cp+112)) (f32.const -0x1.0d423ap-13))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.910604p+8) (f32.const 0x1.0ca912p+7)) (f32.const -0x1.14cdecp+5))
+
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.8b4f1c218e2abp-827) (f64.const 0x1.5e1ee65953b0bp-669)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.74ee531ddba38p-425) (f64.const 0x1.f370f758857f3p+560)) (f64.const 0x1.0aff34269583ep-705))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.27f216b0da6c5p+352) (f64.const 0x1.8e0b4e0b9fd7ep-483)) (f64.const -0x1.4fa558aad514ep+593))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.4c6955df9912bp+104) (f64.const 0x1.0cca42c9d371ep+842)) (f64.const 0x1.4468072f54294p-317))
+
+;; Test that subnormals are not flushed even in an intermediate value in an
+;; expression with a normal result.
+
+(module
+  (func (export "f32.no_flush_intermediate_subnormal") (param $x f32) (param $y f32) (param $z f32) (result f32)
+    (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_flush_intermediate_subnormal") (param $x f64) (param $y f64) (param $z f64) (result f64)
+    (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_flush_intermediate_subnormal" (f32.const 0x1p-126) (f32.const 0x1p-23) (f32.const 0x1p23)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.no_flush_intermediate_subnormal" (f64.const 0x1p-1022) (f64.const 0x1p-52) (f64.const 0x1p52)) (f64.const 0x1p-1022))
+
+;; Test corner cases of John Hauser's microarchitectural recoding scheme.
+;; https://github.com/riscv/riscv-tests/blob/695b86a6fcbe06ffbed8891af7e6fe7bf2062543/isa/rv64uf/recoding.S
+
+(module
+  (func (export "f32.recoding_eq") (param $x f32) (param $y f32) (result i32)
+    (f32.eq (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f32.recoding_le") (param $x f32) (param $y f32) (result i32)
+    (f32.le (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f32.recoding_lt") (param $x f32) (param $y f32) (result i32)
+    (f32.lt (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_eq") (param $x f64) (param $y f64) (result i32)
+    (f64.eq (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_le") (param $x f64) (param $y f64) (result i32)
+    (f64.le (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "f64.recoding_lt") (param $x f64) (param $y f64) (result i32)
+    (f64.lt (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
+
+  (func (export "recoding_demote") (param $x f64) (param $y f32) (result f32)
+    (f32.mul (f32.demote_f64 (local.get $x)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.recoding_eq" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_le" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_lt" (f32.const -inf) (f32.const 3.0)) (i32.const 0))
+
+(assert_return (invoke "f32.recoding_eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
+
+(assert_return (invoke "f64.recoding_eq" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_le" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_lt" (f64.const -inf) (f64.const 3.0)) (i32.const 0))
+
+(assert_return (invoke "f64.recoding_eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_lt" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 0))
+
+(assert_return (invoke "recoding_demote" (f64.const 0x1.4c8f8p-132) (f32.const 1221)) (f32.const 0x1.8c8a1cp-122))
+
+;; Test that division is not done as on an extended-base system.
+;; http://www.ucbtest.org/goldberg/addendum.html
+
+(module
+  (func (export "f32.no_extended_precision_div") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.eq (f32.div (local.get $x) (local.get $y)) (local.get $z)))
+
+  (func (export "f64.no_extended_precision_div") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.eq (f64.div (local.get $x) (local.get $y)) (local.get $z)))
+)
+
+(assert_return (invoke "f32.no_extended_precision_div" (f32.const 3.0) (f32.const 7.0) (f32.const 0x1.b6db6ep-2)) (i32.const 1))
+(assert_return (invoke "f64.no_extended_precision_div" (f64.const 3.0) (f64.const 7.0) (f64.const 0x1.b6db6db6db6dbp-2)) (i32.const 1))
+
+;; a*x + b*x == (a+b)*x for all x only if the operations a*x, b*x, and (a+b)
+;; are all exact operations, which is true only if a and b are exact powers of
+;; 2. Even then, if a==-b and x==-0, then a*x+b*x==0.0, (a+b)*x==-0.0.
+;; https://dlang.org/d-floating-point.html
+
+(module
+  (func (export "f32.no_distribute_exact") (param $x f32) (result f32)
+    (f32.add (f32.mul (f32.const -8.0) (local.get $x)) (f32.mul (f32.const 8.0) (local.get $x))))
+
+  (func (export "f64.no_distribute_exact") (param $x f64) (result f64)
+    (f64.add (f64.mul (f64.const -8.0) (local.get $x)) (f64.mul (f64.const 8.0) (local.get $x))))
+)
+
+(assert_return (invoke "f32.no_distribute_exact" (f32.const -0.0)) (f32.const 0.0))
+(assert_return (invoke "f64.no_distribute_exact" (f64.const -0.0)) (f64.const 0.0))
+
+;; Test that various approximations of sqrt(2), sqrt(3), and sqrt(5) compute the
+;; expected approximation.
+;; https://xkcd.com/1047/
+(module
+  (func (export "f32.sqrt") (param f32) (result f32)
+    (f32.sqrt (local.get 0)))
+
+  (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32)
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0))))
+
+  (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32)
+    (f32.div (f32.add (local.get 0) (f32.mul (local.get 1) (local.get 2))) (f32.sub (local.get 3) (f32.mul (local.get 1) (local.get 2)))))
+
+  (func (export "f64.sqrt") (param f64) (result f64)
+    (f64.sqrt (local.get 0)))
+
+  (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2)))))
+
+  (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2)))
+
+  (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64)
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0))))
+
+  (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64)
+    (f64.div (f64.add (local.get 0) (f64.mul (local.get 1) (local.get 2))) (f64.sub (local.get 3) (f64.mul (local.get 1) (local.get 2)))))
+)
+
+(assert_return (invoke "f32.sqrt" (f32.const 2.0)) (f32.const 0x1.6a09e6p+0))
+(assert_return (invoke "f32.xkcd_sqrt_2" (f32.const 3.0) (f32.const 5.0) (f32.const 0x1.921fb6p+1) (f32.const 7.0)) (f32.const 0x1.6a0a54p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 3.0)) (f32.const 0x1.bb67aep+0))
+(assert_return (invoke "f32.xkcd_sqrt_3" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.bb02d4p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 5.0)) (f32.const 0x1.1e377ap+1))
+(assert_return (invoke "f32.xkcd_sqrt_5" (f32.const 2.0) (f32.const 0x1.5bf0a8p+1) (f32.const 3.0)) (f32.const 0x1.1e2d58p+1))
+(assert_return (invoke "f32.xkcd_better_sqrt_5" (f32.const 13.0) (f32.const 4.0) (f32.const 0x1.921fb6p+1) (f32.const 24.0)) (f32.const 0x1.1e377ap+1))
+
+(assert_return (invoke "f64.sqrt" (f64.const 2.0)) (f64.const 0x1.6a09e667f3bcdp+0))
+(assert_return (invoke "f64.xkcd_sqrt_2" (f64.const 3.0) (f64.const 5.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 7.0)) (f64.const 0x1.6a0a5362b055fp+0))
+(assert_return (invoke "f64.sqrt" (f64.const 3.0)) (f64.const 0x1.bb67ae8584caap+0))
+(assert_return (invoke "f64.xkcd_sqrt_3" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.bb02d4eca8f95p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 5.0)) (f64.const 0x1.1e3779b97f4a8p+1))
+(assert_return (invoke "f64.xkcd_sqrt_5" (f64.const 2.0) (f64.const 0x1.5bf0a8b145769p+1) (f64.const 3.0)) (f64.const 0x1.1e2d58d8b3bcep+1))
+(assert_return (invoke "f64.xkcd_better_sqrt_5" (f64.const 13.0) (f64.const 4.0) (f64.const 0x1.921fb54442d18p+1) (f64.const 24.0)) (f64.const 0x1.1e3778509a5a3p+1))
+
+;; Compute the floating-point radix.
+;; M. A. Malcom. Algorithms to reveal properties of floating-point arithmetic.
+;; Communications of the ACM, 15(11):949-951, November 1972.
+(module
+  (func (export "f32.compute_radix") (param $0 f32) (param $1 f32) (result f32)
+    (loop $label$0
+      (br_if $label$0
+        (f32.eq
+          (f32.add
+            (f32.sub
+              (f32.add
+                (local.tee $0 (f32.add (local.get $0) (local.get $0)))
+                (f32.const 1)
+              )
+              (local.get $0)
+            )
+            (f32.const -1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (loop $label$2
+      (br_if $label$2
+        (f32.ne
+          (f32.sub
+            (f32.sub
+              (f32.add
+                (local.get $0)
+                (local.tee $1 (f32.add (local.get $1) (f32.const 1)))
+              )
+              (local.get $0)
+            )
+            (local.get $1)
+          )
+          (f32.const 0)
+        )
+      )
+    )
+    (local.get $1)
+  )
+
+  (func (export "f64.compute_radix") (param $0 f64) (param $1 f64) (result f64)
+    (loop $label$0
+      (br_if $label$0
+        (f64.eq
+          (f64.add
+            (f64.sub
+              (f64.add
+                (local.tee $0 (f64.add (local.get $0) (local.get $0)))
+                (f64.const 1)
+              )
+              (local.get $0)
+            )
+            (f64.const -1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (loop $label$2
+      (br_if $label$2
+        (f64.ne
+          (f64.sub
+            (f64.sub
+              (f64.add
+                (local.get $0)
+                (local.tee $1 (f64.add (local.get $1) (f64.const 1)))
+              )
+              (local.get $0)
+            )
+            (local.get $1)
+          )
+          (f64.const 0)
+        )
+      )
+    )
+    (local.get $1)
+  )
+)
+
+(assert_return (invoke "f32.compute_radix" (f32.const 1.0) (f32.const 1.0)) (f32.const 2.0))
+(assert_return (invoke "f64.compute_radix" (f64.const 1.0) (f64.const 1.0)) (f64.const 2.0))
+
+;; Test that (x - 1) * y + y is not optimized to x * y.
+;; http://blog.frama-c.com/index.php?post/2013/05/14/Contrarianism
+
+(module
+  (func (export "f32.no_fold_sub1_mul_add") (param $x f32) (param $y f32) (result f32)
+    (f32.add (f32.mul (f32.sub (local.get $x) (f32.const 1.0)) (local.get $y)) (local.get $y)))
+
+  (func (export "f64.no_fold_sub1_mul_add") (param $x f64) (param $y f64) (result f64)
+    (f64.add (f64.mul (f64.sub (local.get $x) (f64.const 1.0)) (local.get $y)) (local.get $y)))
+)
+
+(assert_return (invoke "f32.no_fold_sub1_mul_add" (f32.const 0x1p-32) (f32.const 1.0)) (f32.const 0x0p+0))
+(assert_return (invoke "f64.no_fold_sub1_mul_add" (f64.const 0x1p-64) (f64.const 1.0)) (f64.const 0x0p+0))
+
+;; Test that x+z >= y+z is not optimized to x >= y (monotonicity).
+;; http://cs.nyu.edu/courses/spring13/CSCI-UA.0201-003/lecture6.pdf
+
+(module
+  (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
+
+  (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
+    (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
+
+  (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
+    (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
+)
+
+(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const inf) (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const inf) (f64.const -inf) (f64.const inf)) (i32.const 0))
+
+;; Test that !(x < y) and friends are not optimized to x >= y and friends.
+
+(module
+  (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.le (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.gt (local.get $x) (local.get $y))))
+
+  (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32)
+    (i32.eqz (f32.ge (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.le (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.gt (local.get $x) (local.get $y))))
+
+  (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32)
+    (i32.eqz (f64.ge (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_le" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_gt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f32.not_ge" (f32.const nan) (f32.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_lt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_le" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_gt" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+(assert_return (invoke "f64.not_ge" (f64.const nan) (f64.const 0.0)) (i32.const 1))
+
+;; Test that a method for approximating a "machine epsilon" produces the expected
+;; approximation.
+;; http://blogs.mathworks.com/cleve/2014/07/07/floating-point-numbers/#24cb4f4d-b8a9-4c19-b22b-9d2a9f7f3812
+
+(module
+  (func (export "f32.epsilon") (result f32)
+    (f32.sub (f32.const 1.0) (f32.mul (f32.const 3.0) (f32.sub (f32.div (f32.const 4.0) (f32.const 3.0)) (f32.const 1.0)))))
+
+  (func (export "f64.epsilon") (result f64)
+    (f64.sub (f64.const 1.0) (f64.mul (f64.const 3.0) (f64.sub (f64.div (f64.const 4.0) (f64.const 3.0)) (f64.const 1.0)))))
+)
+
+(assert_return (invoke "f32.epsilon") (f32.const -0x1p-23))
+(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52))
+
+;; Test that a method for computing a "machine epsilon" produces the expected
+;; result.
+;; https://www.math.utah.edu/~beebe/software/ieee/
+
+(module
+  (func (export "f32.epsilon") (result f32)
+    (local $x f32)
+    (local $result f32)
+    (local.set $x (f32.const 1))
+    (loop $loop
+      (br_if $loop
+        (f32.gt
+          (f32.add
+            (local.tee $x
+              (f32.mul
+                (local.tee $result (local.get $x))
+                (f32.const 0.5)
+              )
+            )
+            (f32.const 1)
+          )
+          (f32.const 1)
+        )
+      )
+    )
+    (local.get $result)
+  )
+
+  (func (export "f64.epsilon") (result f64)
+    (local $x f64)
+    (local $result f64)
+    (local.set $x (f64.const 1))
+    (loop $loop
+      (br_if $loop
+        (f64.gt
+          (f64.add
+            (local.tee $x
+              (f64.mul
+                (local.tee $result (local.get $x))
+                (f64.const 0.5)
+              )
+            )
+            (f64.const 1)
+          )
+          (f64.const 1)
+        )
+      )
+    )
+    (local.get $result)
+  )
+)
+
+(assert_return (invoke "f32.epsilon") (f32.const 0x1p-23))
+(assert_return (invoke "f64.epsilon") (f64.const 0x1p-52))
+
+;; Test that floating-point numbers are not optimized as if they form a
+;; trichotomy.
+
+(module
+  (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32)
+    (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y))))
+
+  (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32)
+    (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y))))
+)
+
+(assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_le" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_gt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f32.no_trichotomy_ge" (f32.const 0.0) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_lt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_le" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_gt" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "f64.no_trichotomy_ge" (f64.const 0.0) (f64.const nan)) (i32.const 0))
+
+;; Some test harnesses which can run this testsuite are unable to perform tests
+;; of NaN bitpatterns. The following tests whether the underlying platform is
+;; generally producing the kinds of NaNs expected.
+(module
+  (func (export "f32.arithmetic_nan_bitpattern")
+        (param $x i32) (param $y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.canonical_nan_bitpattern")
+        (param $x i32) (param $y i32) (result i32)
+    (i32.and (i32.reinterpret_f32
+               (f32.div
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
+             (i32.const 0x7fffffff)))
+  (func (export "f32.nonarithmetic_nan_bitpattern")
+        (param $x i32) (result i32)
+    (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $x)))))
+
+  (func (export "f64.arithmetic_nan_bitpattern")
+        (param $x i64) (param $y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.canonical_nan_bitpattern")
+        (param $x i64) (param $y i64) (result i64)
+    (i64.and (i64.reinterpret_f64
+               (f64.div
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
+             (i64.const 0x7fffffffffffffff)))
+  (func (export "f64.nonarithmetic_nan_bitpattern")
+        (param $x i64) (result i64)
+    (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $x)))))
+
+  ;; Versions of no_fold testcases that only care about NaN bitpatterns.
+  (func (export "f32.no_fold_sub_zero") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $x)) (f32.const 0.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg0_sub") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_mul_one") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_neg1_mul") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $x))))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_one") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f32.no_fold_div_neg1") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const -1.0)))
+             (i32.const 0x7fc00000)))
+  (func (export "f64.no_fold_sub_zero") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $x)) (f64.const 0.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg0_sub") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_mul_one") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_neg1_mul") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $x))))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_one") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "f64.no_fold_div_neg1") (param $x i64) (result i64)
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const -1.0)))
+             (i64.const 0x7ff8000000000000)))
+  (func (export "no_fold_promote_demote") (param $x i32) (result i32)
+    (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $x)))))
+             (i32.const 0x7fc00000)))
+)
+
+(assert_return (invoke "f32.arithmetic_nan_bitpattern" (i32.const 0x7f803210) (i32.const 0x7f803210)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0) (i32.const 0)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0x7fc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0x7fc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.canonical_nan_bitpattern" (i32.const 0xffc00000) (i32.const 0xffc00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7fc03210)) (i32.const 0xffc03210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xffc03210)) (i32.const 0x7fc03210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0x7f803210)) (i32.const 0xff803210))
+(assert_return (invoke "f32.nonarithmetic_nan_bitpattern" (i32.const 0xff803210)) (i32.const 0x7f803210))
+(assert_return (invoke "f64.arithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210) (i64.const 0x7ff0000000003210)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0) (i64.const 0)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0x7ff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0x7ff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.canonical_nan_bitpattern" (i64.const 0xfff8000000000000) (i64.const 0xfff8000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff8000000003210)) (i64.const 0xfff8000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff8000000003210)) (i64.const 0x7ff8000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0x7ff0000000003210)) (i64.const 0xfff0000000003210))
+(assert_return (invoke "f64.nonarithmetic_nan_bitpattern" (i64.const 0xfff0000000003210)) (i64.const 0x7ff0000000003210))
+(assert_return (invoke "f32.no_fold_sub_zero" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_neg0_sub" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_mul_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_neg1_mul" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_div_one" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f32.no_fold_div_neg1" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+(assert_return (invoke "f64.no_fold_sub_zero" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_neg0_sub" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_mul_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_neg1_mul" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_div_one" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.no_fold_div_neg1" (i64.const 0x7ff4000000000000)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "no_fold_promote_demote" (i32.const 0x7fa00000)) (i32.const 0x7fc00000))
+
+;; Test that IEEE 754 double precision does, in fact, compute a certain dot
+;; product correctly.
+
+(module
+  (func (export "dot_product_example")
+        (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64)
+        (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
+        (result f64)
+    (f64.add (f64.add (f64.add
+      (f64.mul (local.get $x0) (local.get $y0))
+      (f64.mul (local.get $x1) (local.get $y1)))
+      (f64.mul (local.get $x2) (local.get $y2)))
+      (f64.mul (local.get $x3) (local.get $y3)))
+  )
+
+  (func (export "with_binary_sum_collapse")
+        (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64)
+        (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
+        (result f64)
+      (f64.add (f64.add (f64.mul (local.get $x0) (local.get $y0))
+                        (f64.mul (local.get $x1) (local.get $y1)))
+               (f64.add (f64.mul (local.get $x2) (local.get $y2))
+                        (f64.mul (local.get $x3) (local.get $y3))))
+  )
+)
+
+(assert_return (invoke "dot_product_example"
+    (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7)
+    (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7))
+  (f64.const 2.0))
+(assert_return (invoke "with_binary_sum_collapse"
+    (f64.const 3.2e7) (f64.const 1.0) (f64.const -1.0) (f64.const 8.0e7)
+    (f64.const 4.0e7) (f64.const 1.0) (f64.const -1.0) (f64.const -1.6e7))
+  (f64.const 2.0))
+
+;; http://www.vinc17.org/research/fptest.en.html#contract2fma
+
+(module
+  (func (export "f32.contract2fma")
+        (param $x f32) (param $y f32) (result f32)
+    (f32.sqrt (f32.sub (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
+  (func (export "f64.contract2fma")
+        (param $x f64) (param $y f64) (result f64)
+    (f64.sqrt (f64.sub (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
+)
+
+(assert_return (invoke "f32.contract2fma" (f32.const 1.0) (f32.const 1.0)) (f32.const 0.0))
+(assert_return (invoke "f32.contract2fma" (f32.const 0x1.19999ap+0) (f32.const 0x1.19999ap+0)) (f32.const 0.0))
+(assert_return (invoke "f32.contract2fma" (f32.const 0x1.333332p+0) (f32.const 0x1.333332p+0)) (f32.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 1.0) (f64.const 1.0)) (f64.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 0x1.199999999999ap+0) (f64.const 0x1.199999999999ap+0)) (f64.const 0.0))
+(assert_return (invoke "f64.contract2fma" (f64.const 0x1.3333333333333p+0) (f64.const 0x1.3333333333333p+0)) (f64.const 0.0))
+
+;; Test that floating-point isn't implemented with QuickBasic for MS-DOS.
+;; https://support.microsoft.com/en-us/help/42980/-complete-tutorial-to-understand-ieee-floating-point-errors
+
+(module
+  (func (export "f32.division_by_small_number")
+        (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.sub (local.get $a) (f32.div (local.get $b) (local.get $c))))
+  (func (export "f64.division_by_small_number")
+        (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.sub (local.get $a) (f64.div (local.get $b) (local.get $c))))
+)
+
+(assert_return (invoke "f32.division_by_small_number" (f32.const 112000000) (f32.const 100000) (f32.const 0.0009)) (f32.const 888888))
+(assert_return (invoke "f64.division_by_small_number" (f64.const 112000000) (f64.const 100000) (f64.const 0.0009)) (f64.const 888888.8888888806))
+
+;; Test a simple golden ratio computation.
+;; http://mathworld.wolfram.com/GoldenRatio.html
+
+(module
+  (func (export "f32.golden_ratio") (param $a f32) (param $b f32) (param $c f32) (result f32)
+    (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2)))))
+  (func (export "f64.golden_ratio") (param $a f64) (param $b f64) (param $c f64) (result f64)
+    (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2)))))
+)
+
+(assert_return (invoke "f32.golden_ratio" (f32.const 0.5) (f32.const 1.0) (f32.const 5.0)) (f32.const 1.618034))
+(assert_return (invoke "f64.golden_ratio" (f64.const 0.5) (f64.const 1.0) (f64.const 5.0)) (f64.const 1.618033988749895))
+
+;; Test some silver means computations.
+;; http://mathworld.wolfram.com/SilverRatio.html
+
+(module
+  (func (export "f32.silver_means") (param $n f32) (result f32)
+    (f32.mul (f32.const 0.5)
+             (f32.add (local.get $n)
+                      (f32.sqrt (f32.add (f32.mul (local.get $n) (local.get $n))
+                                         (f32.const 4.0))))))
+  (func (export "f64.silver_means") (param $n f64) (result f64)
+    (f64.mul (f64.const 0.5)
+             (f64.add (local.get $n)
+                      (f64.sqrt (f64.add (f64.mul (local.get $n) (local.get $n))
+                                         (f64.const 4.0))))))
+)
+
+(assert_return (invoke "f32.silver_means" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "f32.silver_means" (f32.const 1.0)) (f32.const 1.6180340))
+(assert_return (invoke "f32.silver_means" (f32.const 2.0)) (f32.const 2.4142136))
+(assert_return (invoke "f32.silver_means" (f32.const 3.0)) (f32.const 3.3027756))
+(assert_return (invoke "f32.silver_means" (f32.const 4.0)) (f32.const 4.2360680))
+(assert_return (invoke "f32.silver_means" (f32.const 5.0)) (f32.const 5.1925821))
+(assert_return (invoke "f64.silver_means" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "f64.silver_means" (f64.const 1.0)) (f64.const 1.618033988749895))
+(assert_return (invoke "f64.silver_means" (f64.const 2.0)) (f64.const 2.414213562373095))
+(assert_return (invoke "f64.silver_means" (f64.const 3.0)) (f64.const 3.302775637731995))
+(assert_return (invoke "f64.silver_means" (f64.const 4.0)) (f64.const 4.236067977499790))
+(assert_return (invoke "f64.silver_means" (f64.const 5.0)) (f64.const 5.192582403567252))
+
+;; Test that an f64 0.4 isn't double-rounded as via extended precision.
+;; https://bugs.llvm.org/show_bug.cgi?id=11200
+
+(module
+  (func (export "point_four") (param $four f64) (param $ten f64) (result i32)
+    (f64.lt (f64.div (local.get $four) (local.get $ten)) (f64.const 0.4)))
+)
+
+(assert_return (invoke "point_four" (f64.const 4.0) (f64.const 10.0)) (i32.const 0))
+
+;; Test an approximation function for tau; it should produces the correctly
+;; rounded result after (and only after) the expected number of iterations.
+
+(module
+  (func (export "tau") (param i32) (result f64)
+    (local f64 f64 f64 f64)
+    f64.const 0x0p+0
+    local.set 1
+    block
+      local.get 0
+      i32.const 1
+      i32.lt_s
+      br_if 0
+      f64.const 0x1p+0
+      local.set 2
+      f64.const 0x0p+0
+      local.set 3
+      loop
+        local.get 1
+        local.get 2
+        f64.const 0x1p+3
+        local.get 3
+        f64.const 0x1p+3
+        f64.mul
+        local.tee 4
+        f64.const 0x1p+0
+        f64.add
+        f64.div
+        f64.const 0x1p+2
+        local.get 4
+        f64.const 0x1p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.4p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.const 0x1p+1
+        local.get 4
+        f64.const 0x1.8p+2
+        f64.add
+        f64.div
+        f64.sub
+        f64.mul
+        f64.add
+        local.set 1
+        local.get 3
+        f64.const 0x1p+0
+        f64.add
+        local.set 3
+        local.get 2
+        f64.const 0x1p-4
+        f64.mul
+        local.set 2
+        local.get 0
+        i32.const -1
+        i32.add
+        local.tee 0
+        br_if 0
+      end
+    end
+    local.get 1
+  )
+)
+
+(assert_return (invoke "tau" (i32.const 10)) (f64.const 0x1.921fb54442d14p+2))
+(assert_return (invoke "tau" (i32.const 11)) (f64.const 0x1.921fb54442d18p+2))
+
+;; Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0).
+
+(module
+  (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32)
+    (select (local.get $x)
+            (f32.add (local.get $x) (f32.const 1.0))
+            (f32.lt (local.get $y) (f32.const 0.0))))
+  (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64)
+    (select (local.get $x)
+            (f64.add (local.get $x) (f64.const 1.0))
+            (f64.lt (local.get $y) (f64.const 0.0))))
+)
+
+(assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_conditional_inc" (f64.const -0.0) (f64.const -1.0)) (f64.const -0.0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_literals.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_literals.wast
new file mode 100644
index 0000000..fefb91f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_literals.wast
@@ -0,0 +1,507 @@
+;; Test floating-point literal parsing.
+
+(module
+  ;; f32 special values
+  (func (export "f32.nan") (result i32) (i32.reinterpret_f32 (f32.const nan)))
+  (func (export "f32.positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan)))
+  (func (export "f32.negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan)))
+  (func (export "f32.plain_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x400000)))
+  (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x200000)))
+  (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x7fffff)))
+  (func (export "f32.misc_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x012345)))
+  (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan:0x304050)))
+  (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x2abcde)))
+  (func (export "f32.infinity") (result i32) (i32.reinterpret_f32 (f32.const inf)))
+  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret_f32 (f32.const +inf)))
+  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret_f32 (f32.const -inf)))
+
+  ;; f32 numbers
+  (func (export "f32.zero") (result i32) (i32.reinterpret_f32 (f32.const 0x0.0p0)))
+  (func (export "f32.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0x0.0p0)))
+  (func (export "f32.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0x0.0p0)))
+  (func (export "f32.misc") (result i32) (i32.reinterpret_f32 (f32.const 0x1.921fb6p+2)))
+  (func (export "f32.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-149)))
+  (func (export "f32.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-126)))
+  (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127)))
+  (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127)))
+  (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10)))
+
+  ;; f32 in decimal format
+  (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0)))
+  (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0.0e0)))
+  (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0.0e0)))
+  (func (export "f32_dec.misc") (result i32) (i32.reinterpret_f32 (f32.const 6.28318548202514648)))
+  (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 1.4013e-45)))
+  (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754944e-38)))
+  (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38)))
+  (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38)))
+  (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10)))
+
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret_f32 (f32.const 1.000000119)))
+
+  ;; f64 special values
+  (func (export "f64.nan") (result i64) (i64.reinterpret_f64 (f64.const nan)))
+  (func (export "f64.positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan)))
+  (func (export "f64.negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan)))
+  (func (export "f64.plain_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x8000000000000)))
+  (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x4000000000000)))
+  (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0xfffffffffffff)))
+  (func (export "f64.misc_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x0123456789abc)))
+  (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan:0x3040506070809)))
+  (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0x2abcdef012345)))
+  (func (export "f64.infinity") (result i64) (i64.reinterpret_f64 (f64.const inf)))
+  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret_f64 (f64.const +inf)))
+  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret_f64 (f64.const -inf)))
+
+  ;; f64 numbers
+  (func (export "f64.zero") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0p0)))
+  (func (export "f64.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0x0.0p0)))
+  (func (export "f64.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0x0.0p0)))
+  (func (export "f64.misc") (result i64) (i64.reinterpret_f64 (f64.const 0x1.921fb54442d18p+2)))
+  (func (export "f64.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0000000000001p-1022)))
+  (func (export "f64.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 0x1p-1022)))
+  (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022)))
+  (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023)))
+  (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100)))
+
+  ;; f64 numbers in decimal format
+  (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0)))
+  (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0.0e0)))
+  (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0.0e0)))
+  (func (export "f64_dec.misc") (result i64) (i64.reinterpret_f64 (f64.const 6.28318530717958623)))
+  (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 4.94066e-324)))
+  (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072012e-308)))
+  (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308)))
+  (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308)))
+  (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100)))
+
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret_f64 (f64.const 1.000000119)))
+
+  (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000))
+  (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0))
+  (func (export "f32-dec-sep3") (result f32) (f32.const 100_3.141_592))
+  (func (export "f32-dec-sep4") (result f32) (f32.const 99e+1_3))
+  (func (export "f32-dec-sep5") (result f32) (f32.const 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result f32) (f32.const 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result f32) (f32.const 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result f32) (f32.const 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result f32) (f32.const 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result f32) (f32.const 0x2a_f00a.1f_3_eep2_3))
+
+  (func (export "f64-dec-sep1") (result f64) (f64.const 1_000_000))
+  (func (export "f64-dec-sep2") (result f64) (f64.const 1_0_0_0))
+  (func (export "f64-dec-sep3") (result f64) (f64.const 100_3.141_592))
+  (func (export "f64-dec-sep4") (result f64) (f64.const 99e-1_23))
+  (func (export "f64-dec-sep5") (result f64) (f64.const 122_000.11_3_54e0_2_3))
+  (func (export "f64-hex-sep1") (result f64) (f64.const 0xa_f00f_0000_9999))
+  (func (export "f64-hex-sep2") (result f64) (f64.const 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result f64) (f64.const 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result f64) (f64.const 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result f64) (f64.const 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32.nan") (i32.const 0x7fc00000))
+(assert_return (invoke "f32.positive_nan") (i32.const 0x7fc00000))
+(assert_return (invoke "f32.negative_nan") (i32.const 0xffc00000))
+(assert_return (invoke "f32.plain_nan") (i32.const 0x7fc00000))
+(assert_return (invoke "f32.informally_known_as_plain_snan") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.all_ones_nan") (i32.const 0xffffffff))
+(assert_return (invoke "f32.misc_nan") (i32.const 0x7f812345))
+(assert_return (invoke "f32.misc_positive_nan") (i32.const 0x7fb04050))
+(assert_return (invoke "f32.misc_negative_nan") (i32.const 0xffaabcde))
+(assert_return (invoke "f32.infinity") (i32.const 0x7f800000))
+(assert_return (invoke "f32.positive_infinity") (i32.const 0x7f800000))
+(assert_return (invoke "f32.negative_infinity") (i32.const 0xff800000))
+(assert_return (invoke "f32.zero") (i32.const 0))
+(assert_return (invoke "f32.positive_zero") (i32.const 0))
+(assert_return (invoke "f32.negative_zero") (i32.const 0x80000000))
+(assert_return (invoke "f32.misc") (i32.const 0x40c90fdb))
+(assert_return (invoke "f32.min_positive") (i32.const 1))
+(assert_return (invoke "f32.min_normal") (i32.const 0x800000))
+(assert_return (invoke "f32.max_subnormal") (i32.const 0x7fffff))
+(assert_return (invoke "f32.max_finite") (i32.const 0x7f7fffff))
+(assert_return (invoke "f32.trailing_dot") (i32.const 0x44800000))
+(assert_return (invoke "f32_dec.zero") (i32.const 0))
+(assert_return (invoke "f32_dec.positive_zero") (i32.const 0))
+(assert_return (invoke "f32_dec.negative_zero") (i32.const 0x80000000))
+(assert_return (invoke "f32_dec.misc") (i32.const 0x40c90fdb))
+(assert_return (invoke "f32_dec.min_positive") (i32.const 1))
+(assert_return (invoke "f32_dec.min_normal") (i32.const 0x800000))
+(assert_return (invoke "f32_dec.max_subnormal") (i32.const 0x7fffff))
+(assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff))
+(assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9))
+(assert_return (invoke "f32_dec.root_beer_float") (i32.const 0x3f800001))
+
+(assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.negative_nan") (i64.const 0xfff8000000000000))
+(assert_return (invoke "f64.plain_nan") (i64.const 0x7ff8000000000000))
+(assert_return (invoke "f64.informally_known_as_plain_snan") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.all_ones_nan") (i64.const 0xffffffffffffffff))
+(assert_return (invoke "f64.misc_nan") (i64.const 0x7ff0123456789abc))
+(assert_return (invoke "f64.misc_positive_nan") (i64.const 0x7ff3040506070809))
+(assert_return (invoke "f64.misc_negative_nan") (i64.const 0xfff2abcdef012345))
+(assert_return (invoke "f64.infinity") (i64.const 0x7ff0000000000000))
+(assert_return (invoke "f64.positive_infinity") (i64.const 0x7ff0000000000000))
+(assert_return (invoke "f64.negative_infinity") (i64.const 0xfff0000000000000))
+(assert_return (invoke "f64.zero") (i64.const 0))
+(assert_return (invoke "f64.positive_zero") (i64.const 0))
+(assert_return (invoke "f64.negative_zero") (i64.const 0x8000000000000000))
+(assert_return (invoke "f64.misc") (i64.const 0x401921fb54442d18))
+(assert_return (invoke "f64.min_positive") (i64.const 1))
+(assert_return (invoke "f64.min_normal") (i64.const 0x10000000000000))
+(assert_return (invoke "f64.max_subnormal") (i64.const 0xfffffffffffff))
+(assert_return (invoke "f64.max_finite") (i64.const 0x7fefffffffffffff))
+(assert_return (invoke "f64.trailing_dot") (i64.const 0x4630000000000000))
+(assert_return (invoke "f64_dec.zero") (i64.const 0))
+(assert_return (invoke "f64_dec.positive_zero") (i64.const 0))
+(assert_return (invoke "f64_dec.negative_zero") (i64.const 0x8000000000000000))
+(assert_return (invoke "f64_dec.misc") (i64.const 0x401921fb54442d18))
+(assert_return (invoke "f64_dec.min_positive") (i64.const 1))
+(assert_return (invoke "f64_dec.min_normal") (i64.const 0x10000000000000))
+(assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff))
+(assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
+(assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))
+(assert_return (invoke "f64_dec.root_beer_float") (i64.const 0x3ff000001ff19e24))
+
+(assert_return (invoke "f32-dec-sep1") (f32.const 1000000))
+(assert_return (invoke "f32-dec-sep2") (f32.const 1000))
+(assert_return (invoke "f32-dec-sep3") (f32.const 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (f32.const 99e+13))
+(assert_return (invoke "f32-dec-sep5") (f32.const 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (f32.const 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (f32.const 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (f32.const 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (f32.const 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (f32.const 0x2af00a.1f3eep23))
+
+(assert_return (invoke "f64-dec-sep1") (f64.const 1000000))
+(assert_return (invoke "f64-dec-sep2") (f64.const 1000))
+(assert_return (invoke "f64-dec-sep3") (f64.const 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (f64.const 99e-123))
+(assert_return (invoke "f64-dec-sep5") (f64.const 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (f64.const 0xaf00f00009999))
+(assert_return (invoke "f64-hex-sep2") (f64.const 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (f64.const 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (f64.const 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (f64.const 0x2af00a.1f3eep23))
+
+;; Test parsing a float from binary
+(module binary
+  ;; (func (export "4294967249") (result f64) (f64.const 4294967249))
+  "\00\61\73\6d\01\00\00\00\01\85\80\80\80\00\01\60"
+  "\00\01\7c\03\82\80\80\80\00\01\00\07\8e\80\80\80"
+  "\00\01\0a\34\32\39\34\39\36\37\32\34\39\00\00\0a"
+  "\91\80\80\80\00\01\8b\80\80\80\00\00\44\00\00\20"
+  "\fa\ff\ff\ef\41\0b"
+)
+
+(assert_return (invoke "4294967249") (f64.const 4294967249))
+
+(assert_malformed
+  (module quote "(global f32 (f32.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global f64 (f64.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p_+1))")
+  "unknown operator"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_memory.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_memory.wast
new file mode 100644
index 0000000..3801158
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_memory.wast
@@ -0,0 +1,157 @@
+;; Test that floating-point load and store are bit-preserving.
+
+;; Test that load and store do not canonicalize NaNs as x87 does.
+
+(module
+  (memory (data "\00\00\a0\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 0)))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i32.const 0) (i32.const 0)))
+)
+
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "f32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "i32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+
+(module
+  (memory (data "\00\00\00\00\00\00\f4\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 0)))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i32.const 0) (i64.const 0)))
+)
+
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "f64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "i64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+
+;; Test that unaligned load and store do not canonicalize NaNs.
+
+(module
+  (memory (data "\00\00\00\a0\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 1)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 1)))
+  (func (export "f32.store") (f32.store (i32.const 1) (f32.const nan:0x200000)))
+  (func (export "i32.store") (i32.store (i32.const 1) (i32.const 0x7fa00000)))
+  (func (export "reset") (i32.store (i32.const 1) (i32.const 0)))
+)
+
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "f32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "i32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fa00000))
+(assert_return (invoke "f32.load") (f32.const nan:0x200000))
+
+(module
+  (memory (data "\00\00\00\00\00\00\00\f4\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 1)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 1)))
+  (func (export "f64.store") (f64.store (i32.const 1) (f64.const nan:0x4000000000000)))
+  (func (export "i64.store") (i64.store (i32.const 1) (i64.const 0x7ff4000000000000)))
+  (func (export "reset") (i64.store (i32.const 1) (i64.const 0)))
+)
+
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "f64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "i64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ff4000000000000))
+(assert_return (invoke "f64.load") (f64.const nan:0x4000000000000))
+
+;; Test that load and store do not canonicalize NaNs as some JS engines do.
+
+(module
+  (memory (data "\01\00\d0\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+  (func (export "i32.load") (result i32) (i32.load (i32.const 0)))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x500001)))
+  (func (export "i32.store") (i32.store (i32.const 0) (i32.const 0x7fd00001)))
+  (func (export "reset") (i32.store (i32.const 0) (i32.const 0)))
+)
+
+(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
+(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "f32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
+(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+(invoke "reset")
+(assert_return (invoke "i32.load") (i32.const 0x0))
+(assert_return (invoke "f32.load") (f32.const 0.0))
+(invoke "i32.store")
+(assert_return (invoke "i32.load") (i32.const 0x7fd00001))
+(assert_return (invoke "f32.load") (f32.const nan:0x500001))
+
+(module
+  (memory (data "\01\00\00\00\00\00\fc\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+  (func (export "i64.load") (result i64) (i64.load (i32.const 0)))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0xc000000000001)))
+  (func (export "i64.store") (i64.store (i32.const 0) (i64.const 0x7ffc000000000001)))
+  (func (export "reset") (i64.store (i32.const 0) (i64.const 0)))
+)
+
+(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
+(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "f64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
+(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
+(invoke "reset")
+(assert_return (invoke "i64.load") (i64.const 0x0))
+(assert_return (invoke "f64.load") (f64.const 0.0))
+(invoke "i64.store")
+(assert_return (invoke "i64.load") (i64.const 0x7ffc000000000001))
+(assert_return (invoke "f64.load") (f64.const nan:0xc000000000001))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_misc.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_misc.wast
new file mode 100644
index 0000000..3d83281
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/float_misc.wast
@@ -0,0 +1,678 @@
+;; Platforms intended to run WebAssembly must support IEEE 754 arithmetic.
+;; This testsuite is not currently sufficient for full IEEE 754 conformance
+;; testing; platforms are currently expected to meet these requirements in
+;; their own way (widely-used hardware platforms already do this).
+;;
+;; What this testsuite does test is that (a) the platform is basically IEEE 754
+;; rather than something else entirely, (b) it's configured correctly for
+;; WebAssembly (rounding direction, exception masks, precision level, subnormal
+;; mode, etc.), (c) the WebAssembly implementation doesn't perform any common
+;; value-changing optimizations, and (d) that the WebAssembly implementation
+;; doesn't exhibit any known implementation bugs.
+;;
+;; This file supplements f32.wast, f64.wast, f32_bitwise.wast, f64_bitwise.wast,
+;; f32_cmp.wast, and f64_cmp.wast with additional single-instruction tests
+;; covering additional miscellaneous interesting cases.
+
+(module
+  (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y)))
+  (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y)))
+  (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y)))
+  (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y)))
+  (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x)))
+  (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
+  (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
+  (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y)))
+  (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
+  (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
+  (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
+  (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
+  (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y)))
+  (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y)))
+
+  (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
+  (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
+  (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
+  (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
+  (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x)))
+  (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
+  (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
+  (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y)))
+  (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
+  (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
+  (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
+  (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
+  (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
+  (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
+)
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.add" (f32.const 1.1234567890) (f32.const 1.2345e-10)) (f32.const 1.123456789))
+(assert_return (invoke "f64.add" (f64.const 1.1234567890) (f64.const 1.2345e-10)) (f64.const 0x1.1f9add37c11f7p+0))
+
+;; Test adding the greatest value to 1.0 that rounds back to 1.0, and the
+;; least that rounds to something greater.
+(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1p-24)) (f32.const 0x1.0p+0))
+(assert_return (invoke "f32.add" (f32.const 1.0) (f32.const 0x1.000002p-24)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1p-53)) (f64.const 0x1.0p+0))
+(assert_return (invoke "f64.add" (f64.const 1.0) (f64.const 0x1.0000000000001p-53)) (f64.const 0x1.0000000000001p+0))
+
+;; Max subnormal + min subnormal = min normal.
+(assert_return (invoke "f32.add" (f32.const 0x1p-149) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1p-1022))
+
+;; Test for a case of double rounding, example from:
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 3.3.1: A typical problem: "double rounding"
+(assert_return (invoke "f32.add" (f32.const 0x1p+31) (f32.const 1024.25)) (f32.const 0x1.000008p+31))
+(assert_return (invoke "f64.add" (f64.const 0x1p+63) (f64.const 1024.25)) (f64.const 0x1.0000000000001p+63))
+
+;; Test a case that was "tricky" on MMIX.
+;; http://mmix.cs.hm.edu/bugs/bug_rounding.html
+(assert_return (invoke "f64.add" (f64.const -0x1p-1008) (f64.const 0x0.0000000001716p-1022)) (f64.const -0x1.fffffffffffffp-1009))
+
+;; http://www.vinc17.org/software/tst-ieee754.xsl
+(assert_return (invoke "f64.add" (f64.const 9007199254740992) (f64.const 1.00001)) (f64.const 9007199254740994))
+
+;; http://www.vinc17.org/software/test.java
+(assert_return (invoke "f64.add" (f64.const 9007199254740994) (f64.const 0x1.fffep-1)) (f64.const 9007199254740994))
+
+;; Computations that round differently in ties-to-odd mode.
+(assert_return (invoke "f32.add" (f32.const 0x1p23) (f32.const 0x1p-1)) (f32.const 0x1p23))
+(assert_return (invoke "f32.add" (f32.const 0x1.000002p+23) (f32.const 0x1p-1)) (f32.const 0x1.000004p+23))
+(assert_return (invoke "f64.add" (f64.const 0x1p52) (f64.const 0x1p-1)) (f64.const 0x1p52))
+(assert_return (invoke "f64.add" (f64.const 0x1.0000000000001p+52) (f64.const 0x1p-1)) (f64.const 0x1.0000000000002p+52))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.39675ap+102) (f32.const 0x1.76c94cp-99)) (f32.const -0x1.39675ap+102))
+(assert_return (invoke "f32.add" (f32.const 0x1.6c0f24p+67) (f32.const -0x1.2b92dp+52)) (f32.const 0x1.6c0cccp+67))
+(assert_return (invoke "f32.add" (f32.const 0x1.e62318p-83) (f32.const 0x1.f74abep-125)) (f32.const 0x1.e62318p-83))
+(assert_return (invoke "f32.add" (f32.const 0x1.2a71d4p+39) (f32.const -0x1.c9f10cp+55)) (f32.const -0x1.c9efe2p+55))
+(assert_return (invoke "f32.add" (f32.const 0x1.f8f736p-15) (f32.const 0x1.7bd45ep+106)) (f32.const 0x1.7bd45ep+106))
+(assert_return (invoke "f64.add" (f64.const 0x1.f33e1fbca27aap-413) (f64.const -0x1.6b192891ed61p+249)) (f64.const -0x1.6b192891ed61p+249))
+(assert_return (invoke "f64.add" (f64.const -0x1.46f75d130eeb1p+76) (f64.const 0x1.25275d6f7a4acp-184)) (f64.const -0x1.46f75d130eeb1p+76))
+(assert_return (invoke "f64.add" (f64.const 0x1.04dec9265a731p-148) (f64.const -0x1.11eed4e8c127cp-12)) (f64.const -0x1.11eed4e8c127cp-12))
+(assert_return (invoke "f64.add" (f64.const 0x1.05773b7166b0ap+497) (f64.const 0x1.134022f2da37bp+66)) (f64.const 0x1.05773b7166b0ap+497))
+(assert_return (invoke "f64.add" (f64.const 0x1.ef4f794282a82p+321) (f64.const 0x1.14a82266badep+394)) (f64.const 0x1.14a82266badep+394))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.add" (f32.const 0x1.1bf976p+72) (f32.const -0x1.7f5868p+20)) (f32.const 0x1.1bf976p+72))
+(assert_return (invoke "f32.add" (f32.const 0x1.7f9c6cp-45) (f32.const -0x1.b9bb0ep-78)) (f32.const 0x1.7f9c6cp-45))
+(assert_return (invoke "f32.add" (f32.const -0x1.32d1bcp-42) (f32.const 0x1.f7d214p+125)) (f32.const 0x1.f7d214p+125))
+(assert_return (invoke "f32.add" (f32.const -0x1.8e5c0ep-44) (f32.const -0x1.3afa4cp-106)) (f32.const -0x1.8e5c0ep-44))
+(assert_return (invoke "f32.add" (f32.const 0x1.13cd78p-10) (f32.const -0x1.3af316p-107)) (f32.const 0x1.13cd78p-10))
+(assert_return (invoke "f64.add" (f64.const 0x1.f8dd15ca97d4ap+179) (f64.const -0x1.367317d1fe8bfp-527)) (f64.const 0x1.f8dd15ca97d4ap+179))
+(assert_return (invoke "f64.add" (f64.const 0x1.5db08d739228cp+155) (f64.const -0x1.fb316fa147dcbp-61)) (f64.const 0x1.5db08d739228cp+155))
+(assert_return (invoke "f64.add" (f64.const 0x1.bbb403cb85c07p-404) (f64.const -0x1.7e44046b8bbf3p-979)) (f64.const 0x1.bbb403cb85c07p-404))
+(assert_return (invoke "f64.add" (f64.const -0x1.34d38af291831p+147) (f64.const -0x1.9890b47439953p+139)) (f64.const -0x1.366c1ba705bcap+147))
+(assert_return (invoke "f64.add" (f64.const -0x1.b61dedf4e0306p+3) (f64.const 0x1.09e2f31773c4ap+290)) (f64.const 0x1.09e2f31773c4ap+290))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.add" (f32.const -0x1.129bd8p-117) (f32.const 0x1.c75012p-43)) (f32.const 0x1.c75012p-43))
+(assert_return (invoke "f32.add" (f32.const -0x1.c204a2p-16) (f32.const 0x1.80b132p-27)) (f32.const -0x1.c1d48cp-16))
+(assert_return (invoke "f32.add" (f32.const -0x1.decc1cp+36) (f32.const 0x1.c688dap-109)) (f32.const -0x1.decc1cp+36))
+(assert_return (invoke "f32.add" (f32.const 0x1.61ce6ap-118) (f32.const -0x1.772892p+30)) (f32.const -0x1.772892p+30))
+(assert_return (invoke "f32.add" (f32.const -0x1.3dc826p-120) (f32.const 0x1.fc3f66p+95)) (f32.const 0x1.fc3f66p+95))
+(assert_return (invoke "f64.add" (f64.const 0x1.bf68acc263a0fp-777) (f64.const -0x1.5f9352965e5a6p+1004)) (f64.const -0x1.5f9352965e5a6p+1004))
+(assert_return (invoke "f64.add" (f64.const -0x1.76eaa70911f51p+516) (f64.const -0x1.2d746324ce47ap+493)) (f64.const -0x1.76eaa963fabb6p+516))
+(assert_return (invoke "f64.add" (f64.const -0x1.b637d82c15a7ap-967) (f64.const 0x1.cc654ccab4152p-283)) (f64.const 0x1.cc654ccab4152p-283))
+(assert_return (invoke "f64.add" (f64.const -0x1.a5b1fb66e846ep-509) (f64.const 0x1.4bdd36f0bb5ccp-860)) (f64.const -0x1.a5b1fb66e846ep-509))
+(assert_return (invoke "f64.add" (f64.const -0x1.14108da880f9ep+966) (f64.const 0x1.417f35701e89fp+800)) (f64.const -0x1.14108da880f9ep+966))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.add" (f64.const -0x1.fa0caf21ffebcp+804) (f64.const 0x1.4ca8fdcff89f9p+826)) (f64.const 0x1.4ca8f5e7c5e31p+826))
+(assert_return (invoke "f64.add" (f64.const 0x1.016f1fcbdfd38p+784) (f64.const 0x1.375dffcbc9a2cp+746)) (f64.const 0x1.016f1fcbe4b0fp+784))
+(assert_return (invoke "f64.add" (f64.const -0x1.dffda6d5bff3ap+624) (f64.const 0x1.f9e8cc2dff782p+674)) (f64.const 0x1.f9e8cc2dff77bp+674))
+(assert_return (invoke "f64.add" (f64.const 0x1.fff4b43687dfbp+463) (f64.const 0x1.0fd5617c4a809p+517)) (f64.const 0x1.0fd5617c4a809p+517))
+(assert_return (invoke "f64.add" (f64.const 0x1.535d380035da2p-995) (f64.const 0x1.cce37dddbb73bp-963)) (f64.const 0x1.cce37ddf0ed0fp-963))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.add" (f64.const -0x1.d91cd3fc0c66fp+752) (f64.const -0x1.4e18c80229734p+952)) (f64.const -0x1.4e18c80229734p+952))
+(assert_return (invoke "f64.add" (f64.const 0x1.afc70fd36e372p+193) (f64.const -0x1.bd10a9b377b46p+273)) (f64.const -0x1.bd10a9b377b46p+273))
+(assert_return (invoke "f64.add" (f64.const -0x1.2abd570b078b2p+302) (f64.const 0x1.b3c1ad759cb5bp-423)) (f64.const -0x1.2abd570b078b2p+302))
+(assert_return (invoke "f64.add" (f64.const -0x1.5b2ae84c0686cp-317) (f64.const -0x1.dba7a1c022823p+466)) (f64.const -0x1.dba7a1c022823p+466))
+(assert_return (invoke "f64.add" (f64.const -0x1.ac627bd7cbf38p-198) (f64.const 0x1.2312e265b8d59p-990)) (f64.const -0x1.ac627bd7cbf38p-198))
+
+;; Computations that utilize the maximum exponent value to avoid overflow.
+(assert_return (invoke "f32.add" (f32.const 0x1.2b91ap+116) (f32.const 0x1.cbcd52p+127)) (f32.const 0x1.cbf2c4p+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.96f392p+127) (f32.const -0x1.6b3fecp+107)) (f32.const 0x1.96f37cp+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.132f1cp+118) (f32.const -0x1.63d632p+127)) (f32.const -0x1.634c9ap+127))
+(assert_return (invoke "f32.add" (f32.const -0x1.1dda64p+120) (f32.const -0x1.ef02ep+127)) (f32.const -0x1.f13e94p+127))
+(assert_return (invoke "f32.add" (f32.const -0x1.4ad8dap+127) (f32.const -0x1.eae082p+125)) (f32.const -0x1.c590fap+127))
+(assert_return (invoke "f64.add" (f64.const 0x1.017099f2a4b8bp+1023) (f64.const 0x1.1f63b28f05454p+981)) (f64.const 0x1.017099f2a5009p+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.d88b6c74984efp+1023) (f64.const 0x1.33b444775eabcp+990)) (f64.const 0x1.d88b6c7532291p+1023))
+(assert_return (invoke "f64.add" (f64.const -0x1.84576422fdf5p+1023) (f64.const 0x1.60ee6aa12fb9cp+1012)) (f64.const -0x1.842b4655a9cf1p+1023))
+(assert_return (invoke "f64.add" (f64.const -0x1.9aaace3e79f7dp+1001) (f64.const 0x1.e4068af295cb6p+1023)) (f64.const 0x1.e4068487ea926p+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.06cdae79f27b9p+1023) (f64.const -0x1.e05cb0c96f975p+991)) (f64.const 0x1.06cdae78121eep+1023))
+
+;; Computations that utilize the minimum exponent value.
+(assert_return (invoke "f32.add" (f32.const 0x1.6a1a2p-127) (f32.const 0x1.378p-140)) (f32.const 0x1.6a23dcp-127))
+(assert_return (invoke "f32.add" (f32.const 0x1.28p-144) (f32.const -0x1p-148)) (f32.const 0x1.18p-144))
+(assert_return (invoke "f32.add" (f32.const -0x1p-146) (f32.const 0x1.c3cap-128)) (f32.const 0x1.c3c9cp-128))
+(assert_return (invoke "f32.add" (f32.const -0x1.4p-145) (f32.const 0x1.424052p-122)) (f32.const 0x1.42405p-122))
+(assert_return (invoke "f32.add" (f32.const 0x1.c5p-141) (f32.const -0x1.72f8p-135)) (f32.const -0x1.6be4p-135))
+(assert_return (invoke "f64.add" (f64.const 0x1.4774c681d1e21p-1022) (f64.const -0x1.271e58e9f58cap-1021)) (f64.const -0x1.06c7eb5219373p-1022))
+(assert_return (invoke "f64.add" (f64.const 0x1.10b3a75e31916p-1021) (f64.const -0x1.ffb82b0e868a7p-1021)) (f64.const -0x1.de090760a9f22p-1022))
+(assert_return (invoke "f64.add" (f64.const -0x0.6b58448b8098ap-1022) (f64.const -0x1.579796ed04cbep-1022)) (f64.const -0x1.c2efdb7885648p-1022))
+(assert_return (invoke "f64.add" (f64.const 0x1.9eb9e7baae8d1p-1020) (f64.const -0x1.d58e136f8c6eep-1020)) (f64.const -0x0.db50aed377874p-1022))
+(assert_return (invoke "f64.add" (f64.const -0x1.f1115deeafa0bp-1022) (f64.const 0x1.221b1c87dca29p-1022)) (f64.const -0x0.cef64166d2fe2p-1022))
+
+;; Test an add of the second-greatest finite value with the distance to greatest
+;; finite value.
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffcp+127) (f32.const 0x1p+104)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f64.add" (f64.const 0x1.ffffffffffffep+1023) (f64.const 0x1p+971)) (f64.const 0x1.fffffffffffffp+1023))
+
+;; http://news.harvard.edu/gazette/story/2013/09/dawn-of-a-revolution/
+(assert_return (invoke "f32.add" (f32.const 2.0) (f32.const 2.0)) (f32.const 4.0))
+(assert_return (invoke "f64.add" (f64.const 2.0) (f64.const 2.0)) (f64.const 4.0))
+
+;; Test rounding above the greatest finite value.
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf))
+(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf))
+
+;; Test for a historic spreadsheet bug.
+;; https://blogs.office.com/2007/09/25/calculation-issue-update/
+(assert_return (invoke "f32.sub" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 65536.0))
+(assert_return (invoke "f64.sub" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1.fffffffffffffp+15))
+
+;; Test subtracting the greatest value from 1.0 that rounds back to 1.0, and the
+;; least that rounds to something less.
+(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1p-25)) (f32.const 0x1.0p+0))
+(assert_return (invoke "f32.sub" (f32.const 1.0) (f32.const 0x1.000002p-25)) (f32.const 0x1.fffffep-1))
+(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1p-54)) (f64.const 0x1.0p+0))
+(assert_return (invoke "f64.sub" (f64.const 1.0) (f64.const 0x1.0000000000001p-54)) (f64.const 0x1.fffffffffffffp-1))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ee2466p-106) (f32.const -0x1.16277ep+119)) (f32.const 0x1.16277ep+119))
+(assert_return (invoke "f32.sub" (f32.const -0x1.446f9ep+119) (f32.const -0x1.4396a4p+43)) (f32.const -0x1.446f9ep+119))
+(assert_return (invoke "f32.sub" (f32.const 0x1.74773cp+0) (f32.const -0x1.a25512p-82)) (f32.const 0x1.74773cp+0))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9345c4p-117) (f32.const 0x1.6792c2p-76)) (f32.const -0x1.6792c2p-76))
+(assert_return (invoke "f32.sub" (f32.const 0x1.9ecfa4p-18) (f32.const -0x1.864b44p-107)) (f32.const 0x1.9ecfa4p-18))
+(assert_return (invoke "f64.sub" (f64.const -0x1.5b798875e7845p-333) (f64.const -0x1.b5147117452fep-903)) (f64.const -0x1.5b798875e7845p-333))
+(assert_return (invoke "f64.sub" (f64.const -0x1.6c87baeb6d72dp+552) (f64.const -0x1.64fb35d4b5571p-158)) (f64.const -0x1.6c87baeb6d72dp+552))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b3d369fcf74bp-461) (f64.const -0x1.ea1668c0dec93p-837)) (f64.const 0x1.b3d369fcf74bp-461))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0abd449353eadp-1005) (f64.const -0x1.0422ea3e82ee9p+154)) (f64.const 0x1.0422ea3e82ee9p+154))
+(assert_return (invoke "f64.sub" (f64.const -0x1.aadbc6b43cc3dp-143) (f64.const -0x1.e7f922ef1ee58p-539)) (f64.const -0x1.aadbc6b43cc3dp-143))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sub" (f32.const -0x1.61e262p+108) (f32.const -0x1.baf3e4p+112)) (f32.const 0x1.a4d5bep+112))
+(assert_return (invoke "f32.sub" (f32.const -0x1.62c2f6p+109) (f32.const 0x1.6e514ap+6)) (f32.const -0x1.62c2f6p+109))
+(assert_return (invoke "f32.sub" (f32.const -0x1.287c94p-83) (f32.const 0x1.0f2f9cp-24)) (f32.const -0x1.0f2f9cp-24))
+(assert_return (invoke "f32.sub" (f32.const -0x1.c8825cp-77) (f32.const -0x1.4aead6p-12)) (f32.const 0x1.4aead6p-12))
+(assert_return (invoke "f32.sub" (f32.const -0x1.2976a4p+99) (f32.const 0x1.c6e3b8p-59)) (f32.const -0x1.2976a4p+99))
+(assert_return (invoke "f64.sub" (f64.const -0x1.76cb28ae6c045p+202) (f64.const -0x1.0611f2af4e9b9p+901)) (f64.const 0x1.0611f2af4e9b9p+901))
+(assert_return (invoke "f64.sub" (f64.const 0x1.baf35eff22e9ep-368) (f64.const 0x1.5c3e08ecf73ecp-451)) (f64.const 0x1.baf35eff22e9ep-368))
+(assert_return (invoke "f64.sub" (f64.const -0x1.8fd354b376f1fp-200) (f64.const 0x1.513c860f386ffp-508)) (f64.const -0x1.8fd354b376f1fp-200))
+(assert_return (invoke "f64.sub" (f64.const -0x1.760d447230ae6p-992) (f64.const -0x1.16f788438ae3ep-328)) (f64.const 0x1.16f788438ae3ep-328))
+(assert_return (invoke "f64.sub" (f64.const -0x1.73aab4fcfc7ap+112) (f64.const 0x1.7c589f990b884p+171)) (f64.const -0x1.7c589f990b884p+171))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sub" (f32.const 0x1.ea264cp+95) (f32.const 0x1.852988p-15)) (f32.const 0x1.ea264cp+95))
+(assert_return (invoke "f32.sub" (f32.const -0x1.14ec7cp+19) (f32.const -0x1.0ad3fep-35)) (f32.const -0x1.14ec7cp+19))
+(assert_return (invoke "f32.sub" (f32.const -0x1.3251dap-36) (f32.const -0x1.49c97ep-56)) (f32.const -0x1.3251c6p-36))
+(assert_return (invoke "f32.sub" (f32.const -0x1.13565ep-14) (f32.const 0x1.2f89a8p-13)) (f32.const -0x1.b934d8p-13))
+(assert_return (invoke "f32.sub" (f32.const -0x1.6032b6p-33) (f32.const -0x1.bb5196p-104)) (f32.const -0x1.6032b6p-33))
+(assert_return (invoke "f64.sub" (f64.const -0x1.b5b0797af491p-157) (f64.const -0x1.694b8348189e8p+722)) (f64.const 0x1.694b8348189e8p+722))
+(assert_return (invoke "f64.sub" (f64.const -0x1.72b142826ed73p+759) (f64.const -0x1.010477bc9afbdp+903)) (f64.const 0x1.010477bc9afbdp+903))
+(assert_return (invoke "f64.sub" (f64.const 0x1.83273b6bb94cfp-796) (f64.const 0x1.1a93f948a2abbp+181)) (f64.const -0x1.1a93f948a2abbp+181))
+(assert_return (invoke "f64.sub" (f64.const -0x1.207e7156cbf2p-573) (f64.const 0x1.cf3f12fd3814dp-544)) (f64.const -0x1.cf3f13063c086p-544))
+(assert_return (invoke "f64.sub" (f64.const -0x1.837e6844f1718p-559) (f64.const -0x1.1c29b757f98abp-14)) (f64.const 0x1.1c29b757f98abp-14))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.sub" (f64.const 0x1.c21151a709b6cp-78) (f64.const 0x1.0a12fff8910f6p-115)) (f64.const 0x1.c21151a701663p-78))
+(assert_return (invoke "f64.sub" (f64.const 0x1.c57912aae2f64p-982) (f64.const 0x1.dbfbd4800b7cfp-1010)) (f64.const 0x1.c579128d2338fp-982))
+(assert_return (invoke "f64.sub" (f64.const 0x1.ffef4399af9c6p-254) (f64.const 0x1.edb96dfaea8b1p-200)) (f64.const -0x1.edb96dfaea8b1p-200))
+(assert_return (invoke "f64.sub" (f64.const -0x1.363eee391cde2p-39) (f64.const -0x1.a65462000265fp-69)) (f64.const -0x1.363eee32838c9p-39))
+(assert_return (invoke "f64.sub" (f64.const 0x1.59016dba002a1p-25) (f64.const 0x1.5d4374f124cccp-3)) (f64.const -0x1.5d436f8d1f15dp-3))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.sub" (f64.const -0x1.18196bca005cfp-814) (f64.const -0x1.db7b01ce3f52fp-766)) (f64.const 0x1.db7b01ce3f51dp-766))
+(assert_return (invoke "f64.sub" (f64.const -0x1.d17b3528d219p+33) (f64.const 0x1.fd739d4ea220ap+367)) (f64.const -0x1.fd739d4ea220ap+367))
+(assert_return (invoke "f64.sub" (f64.const 0x1.dea46994de319p+114) (f64.const 0x1.b5b19cd55c7d3p-590)) (f64.const 0x1.dea46994de319p+114))
+(assert_return (invoke "f64.sub" (f64.const 0x1.b60f9b2fbd9ecp-489) (f64.const -0x1.6f81c59ec5b8ep-694)) (f64.const 0x1.b60f9b2fbd9ecp-489))
+(assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57))
+
+;; pow(e, π) - π
+;; https://xkcd.com/217/
+(assert_return (invoke "f32.sub" (f32.const 0x1.724046p+4) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.3ffc5p+4))
+(assert_return (invoke "f64.sub" (f64.const 0x1.724046eb0933ap+4) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.3ffc504280d97p+4))
+
+;; https://www.cnet.com/news/googles-calculator-muffs-some-math-problems/
+(assert_return (invoke "f32.sub" (f32.const 2999999) (f32.const 2999998)) (f32.const 1.0))
+(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999995)) (f32.const 4.0))
+(assert_return (invoke "f32.sub" (f32.const 1999999) (f32.const 1999993)) (f32.const 6.0))
+(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400001)) (f32.const 1.0))
+(assert_return (invoke "f32.sub" (f32.const 400002) (f32.const 400000)) (f32.const 2.0))
+(assert_return (invoke "f64.sub" (f64.const 2999999999999999) (f64.const 2999999999999998)) (f64.const 1.0))
+(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999995)) (f64.const 4.0))
+(assert_return (invoke "f64.sub" (f64.const 1999999999999999) (f64.const 1999999999999993)) (f64.const 6.0))
+(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000001)) (f64.const 1.0))
+(assert_return (invoke "f64.sub" (f64.const 400000000000002) (f64.const 400000000000000)) (f64.const 2.0))
+
+;; Min normal - max subnormal = min subnormal.
+(assert_return (invoke "f32.sub" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.sub" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test subtraction of numbers very close to 1.
+(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.8p-23))
+(assert_return (invoke "f32.sub" (f32.const 0x1.000002p+0) (f32.const 0x1.0p+0)) (f32.const 0x1p-23))
+(assert_return (invoke "f32.sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p-24))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.8p-52))
+(assert_return (invoke "f64.sub" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0p+0)) (f64.const 0x1p-52))
+(assert_return (invoke "f64.sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p-53))
+
+;; Test the least value that can be subtracted from the max value to produce a
+;; different value.
+(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.sub" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64.sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const 0x1.ffffffffffffep+1023))
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99))
+(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf))
+(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf))
+(assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99))
+(assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132))
+(assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166))
+
+;; Test for a case of double rounding, example from:
+;; http://perso.ens-lyon.fr/jean-michel.muller/Handbook.html
+;; section 3.3.1: A typical problem: "double rounding"
+(assert_return (invoke "f32.mul" (f32.const 1848874880.0) (f32.const 19954563072.0)) (f32.const 0x1.000002p+65))
+(assert_return (invoke "f64.mul" (f64.const 1848874847.0) (f64.const 19954562207.0)) (f64.const 3.6893488147419111424e+19))
+
+;; Test for a historic spreadsheet bug.
+;; http://www.joelonsoftware.com/items/2007/09/26b.html
+(assert_return (invoke "f32.mul" (f32.const 77.1) (f32.const 850)) (f32.const 65535))
+(assert_return (invoke "f64.mul" (f64.const 77.1) (f64.const 850)) (f64.const 65534.99999999999272404))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.14df2ep+61) (f32.const 0x1.748878p-36)) (f32.const -0x1.92e7e8p+25))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5629e2p+102) (f32.const -0x1.c33012p-102)) (f32.const 0x1.2d8604p+1))
+(assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4))
+(assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59))
+(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf))
+(assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713))
+(assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270))
+(assert_return (invoke "f64.mul" (f64.const 0x1.37dab12d3afa2p+795) (f64.const 0x1.81e156bd393f1p-858)) (f64.const 0x1.d6126554b8298p-63))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.3f57a2p-89) (f32.const -0x1.041d68p+92)) (f32.const 0x1.4479bp+3))
+(assert_return (invoke "f32.mul" (f32.const 0x1.4d0582p+73) (f32.const 0x1.6e043ap+19)) (f32.const 0x1.dc236p+92))
+(assert_return (invoke "f32.mul" (f32.const -0x1.2fdap-32) (f32.const -0x1.e1731cp+74)) (f32.const 0x1.1db89ep+43))
+(assert_return (invoke "f32.mul" (f32.const 0x1.7bc8fep+67) (f32.const -0x1.3ad592p+15)) (f32.const -0x1.d3115ep+82))
+(assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952))
+(assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911))
+(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508))
+(assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf))
+(assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101))
+(assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87))
+(assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39))
+(assert_return (invoke "f32.mul" (f32.const -0x1.fb7f12p+16) (f32.const 0x1.3a701ap-119)) (f32.const -0x1.37ac0cp-102))
+(assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.mul" (f64.const 0x1.f99fb602c89b7p-341) (f64.const 0x1.6caab46a31a2ep-575)) (f64.const 0x1.68201f986e9d7p-915))
+(assert_return (invoke "f64.mul" (f64.const -0x1.86999c5eee379p-9) (f64.const 0x1.6e3b9e0d53e0dp+723)) (f64.const -0x1.17654a0ef35f5p+715))
+(assert_return (invoke "f64.mul" (f64.const -0x1.069571b176f9p+367) (f64.const -0x1.e248b6ab0a0e3p-652)) (f64.const 0x1.eeaff575cae1dp-285))
+(assert_return (invoke "f64.mul" (f64.const 0x1.c217645777dd2p+775) (f64.const 0x1.d93f5715dd646p+60)) (f64.const 0x1.a0064aa1d920dp+836))
+(assert_return (invoke "f64.mul" (f64.const -0x1.848981b6e694ap-276) (f64.const 0x1.f5aacb64a0d19p+896)) (f64.const -0x1.7cb2296e6c2e5p+621))
+
+;; Computations that round differently on x87 in double-precision mode.
+(assert_return (invoke "f64.mul" (f64.const 0x1.db3bd2a286944p-599) (f64.const 0x1.ce910af1d55cap-425)) (f64.const 0x0.d6accdd538a39p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.aca223916012p-57) (f64.const -0x1.2b2b4958dd228p-966)) (f64.const 0x0.fa74eccae5615p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.bd062def16cffp-488) (f64.const -0x1.7ddd91a0c4c0ep-536)) (f64.const 0x0.a5f4d7769d90dp-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.c6a56169e9cep-772) (f64.const 0x1.517d55a474122p-255)) (f64.const -0x0.12baf260afb77p-1022))
+(assert_return (invoke "f64.mul" (f64.const -0x1.08951b0b41705p-516) (f64.const -0x1.102dc27168d09p-507)) (f64.const 0x0.8ca6dbf3f592bp-1022))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.mul" (f64.const 0x1.8d0dea50c8c9bp+852) (f64.const 0x1.21cac31d87a24p-881)) (f64.const 0x1.c177311f7cd73p-29))
+(assert_return (invoke "f64.mul" (f64.const 0x1.98049118e3063p-7) (f64.const 0x1.6362525151b58p-149)) (f64.const 0x1.1b358514103f9p-155))
+(assert_return (invoke "f64.mul" (f64.const -0x1.ea65cb0631323p+1) (f64.const 0x1.fce683201a19bp-41)) (f64.const -0x1.e76dc8c223667p-39))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e4d235961d543p-373) (f64.const 0x1.bc56f20ef9a48p-205)) (f64.const 0x1.a4c09efcb71d6p-577))
+(assert_return (invoke "f64.mul" (f64.const -0x1.b9612e66faba8p+77) (f64.const 0x1.e2bc6aa782273p-348)) (f64.const -0x1.a026ea4f81db1p-270))
+
+;; Test the least positive value with a positive square.
+(assert_return (invoke "f32.mul" (f32.const 0x1p-75) (f32.const 0x1p-75)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p-75) (f32.const 0x1.000002p-75)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bccp-538) (f64.const 0x1.6a09e667f3bccp-538)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.6a09e667f3bcdp-538) (f64.const 0x1.6a09e667f3bcdp-538)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test the greatest positive value with a finite square.
+(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf))
+(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023))
+(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf))
+
+;; Test the squares of values very close to 1.
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.fffffep-1) (f32.const 0x1.fffffep-1)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.0000000000002p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test multiplication of numbers very close to 1.
+(assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1p+0))
+(assert_return (invoke "f32.mul" (f32.const 0x1.000004p+0) (f32.const 0x1.fffffcp-1)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1p+0))
+(assert_return (invoke "f64.mul" (f64.const 0x1.0000000000002p+0) (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.0000000000001p+0))
+
+;; Test MIN * EPSILON.
+;; http://www.mpfr.org/mpfr-2.0.1/patch2
+(assert_return (invoke "f32.mul" (f32.const 0x1p-126) (f32.const 0x1p-23)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.mul" (f64.const 0x1p-1022) (f64.const 0x1p-52)) (f64.const 0x0.0000000000001p-1022))
+
+;; http://opencores.org/bug,view,2454
+(assert_return (invoke "f32.mul" (f32.const -0x1.0006p+4) (f32.const 0x1.ap-132)) (f32.const -0x1.a009cp-128))
+
+;; Miscellaneous values.
+(assert_return (invoke "f32.div" (f32.const 1.123456789) (f32.const 100)) (f32.const 0x1.702264p-7))
+(assert_return (invoke "f32.div" (f32.const 8391667.0) (f32.const 12582905.0)) (f32.const 0x1.55754p-1))
+(assert_return (invoke "f32.div" (f32.const 65536.0) (f32.const 0x1p-37)) (f32.const 0x1p+53))
+(assert_return (invoke "f32.div" (f32.const 0x1.dcbf6ap+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.dcbf68p-128))
+(assert_return (invoke "f32.div" (f32.const 4) (f32.const 3)) (f32.const 0x1.555556p+0))
+(assert_return (invoke "f64.div" (f64.const 1.123456789) (f64.const 100)) (f64.const 0.01123456789))
+(assert_return (invoke "f64.div" (f64.const 8391667.0) (f64.const 12582905.0)) (f64.const 0x1.55753f1d9ba27p-1))
+(assert_return (invoke "f64.div" (f64.const 65536.0) (f64.const 0x1p-37)) (f64.const 0x1p+53))
+(assert_return (invoke "f64.div" (f64.const 0x1.dcbf6ap+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda8p-1022))
+(assert_return (invoke "f64.div" (f64.const 4) (f64.const 3)) (f64.const 0x1.5555555555555p+0))
+
+;; Test for a historic hardware bug.
+;; https://en.wikipedia.org/wiki/Pentium_FDIV_bug
+(assert_return (invoke "f32.div" (f32.const 4195835) (f32.const 3145727)) (f32.const 0x1.557542p+0))
+(assert_return (invoke "f64.div" (f64.const 4195835) (f64.const 3145727)) (f64.const 0x1.557541c7c6b43p+0))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.6a6c5ap-48) (f32.const 0x1.fa0b7p+127)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.616fb2p-87) (f32.const 0x1.332172p+68)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const -0x1.96e778p+16) (f32.const 0x1.eb0c56p-80)) (f32.const -0x1.a8440ap+95))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2624p-76) (f32.const -0x1.ed236ep-122)) (f32.const 0x1.f4d584p+45))
+(assert_return (invoke "f32.div" (f32.const -0x1.e2374ep+41) (f32.const 0x1.71fcdcp-80)) (f32.const -0x1.4da706p+121))
+(assert_return (invoke "f64.div" (f64.const 0x1.163c09d0c38c1p+147) (f64.const 0x1.e04cc737348e6p+223)) (f64.const 0x1.289921caeed23p-77))
+(assert_return (invoke "f64.div" (f64.const 0x1.d6867e741e0a9p-626) (f64.const 0x1.335eb19a9aae4p-972)) (f64.const 0x1.87e342d11f519p+346))
+(assert_return (invoke "f64.div" (f64.const -0x1.d5edf648aeb98p+298) (f64.const 0x1.0dda15b079355p+640)) (f64.const -0x1.bdceaf9734b5cp-342))
+(assert_return (invoke "f64.div" (f64.const -0x1.b683e3934aedap+691) (f64.const 0x1.c364e1df00dffp+246)) (f64.const -0x1.f16456e7afe3bp+444))
+(assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90))
+(assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89))
+(assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77))
+(assert_return (invoke "f32.div" (f32.const 0x1.78599p+90) (f32.const 0x1.534144p+87)) (f32.const 0x1.1bfddcp+3))
+(assert_return (invoke "f64.div" (f64.const 0x0.f331c4f47eb51p-1022) (f64.const -0x1.c7ff45bf6f03ap+362)) (f64.const -0x0p+0))
+(assert_return (invoke "f64.div" (f64.const -0x1.0fc8707b9d19cp-987) (f64.const 0x1.77524d5f4a563p-536)) (f64.const -0x1.72c1a937d231p-452))
+(assert_return (invoke "f64.div" (f64.const -0x1.edb3aa64bb338p-403) (f64.const -0x1.1c7c164320e4p+45)) (f64.const 0x1.bc44cc1c5ae63p-448))
+(assert_return (invoke "f64.div" (f64.const -0x1.6534b34e8686bp+80) (f64.const 0x1.c34a7fc59e3c3p-791)) (f64.const -0x1.95421bf291b66p+870))
+(assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49))
+(assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58))
+(assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101))
+(assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78))
+(assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35))
+(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf))
+(assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682))
+(assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905))
+(assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.div" (f64.const -0x1.9c52726aed366p+585) (f64.const -0x1.7d0568c75660fp+195)) (f64.const 0x1.1507ca2a65f23p+390))
+(assert_return (invoke "f64.div" (f64.const -0x1.522672f461667p+546) (f64.const -0x1.36d36572c9f71p+330)) (f64.const 0x1.1681369370619p+216))
+(assert_return (invoke "f64.div" (f64.const 0x1.01051b4e8cd61p+185) (f64.const -0x1.2cbb5ca3d33ebp+965)) (f64.const -0x1.b59471598a2f3p-781))
+(assert_return (invoke "f64.div" (f64.const 0x1.5f93bb80fc2cbp+217) (f64.const 0x1.7e051aae9f0edp+427)) (f64.const 0x1.d732fa926ba4fp-211))
+(assert_return (invoke "f64.div" (f64.const -0x1.e251d762163ccp+825) (f64.const 0x1.3ee63581e1796p+349)) (f64.const -0x1.8330077d90a07p+476))
+
+;; Computations that round differently on x87 in double-precision mode.
+(assert_return (invoke "f64.div" (f64.const 0x1.dcbf69f10006dp+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.772fda7c4001bp-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.e14169442fbcap-1011) (f64.const 0x1.505451d62ff7dp+12)) (f64.const 0x0.b727e85f38b39p-1022))
+(assert_return (invoke "f64.div" (f64.const -0x1.d3ebe726ec964p-144) (f64.const -0x1.4a7bfc0b83608p+880)) (f64.const 0x0.5a9d8c50cbf87p-1022))
+(assert_return (invoke "f64.div" (f64.const -0x1.6c3def770aee1p-393) (f64.const -0x1.8b84724347598p+631)) (f64.const 0x0.3af0707fcd0c7p-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.16abda1bb3cb3p-856) (f64.const 0x1.6c9c7198eb1e6p+166)) (f64.const 0x0.c3a8fd6741649p-1022))
+(assert_return (invoke "f64.div" (f64.const 0x1.7057d6ab553cap-1005) (f64.const -0x1.2abf1e98660ebp+23)) (f64.const -0x0.04ee8d8ec01cdp-1022))
+
+;; Computations that round differently when div is mul by reciprocal.
+(assert_return (invoke "f32.div" (f32.const 0x1.ada9aap+89) (f32.const 0x1.69884cp+42)) (f32.const 0x1.303e2ep+47))
+(assert_return (invoke "f32.div" (f32.const 0x1.8281c8p+90) (f32.const -0x1.62883cp+106)) (f32.const -0x1.17169cp-16))
+(assert_return (invoke "f32.div" (f32.const 0x1.5c6be2p+81) (f32.const 0x1.d01dfep-1)) (f32.const 0x1.805e32p+81))
+(assert_return (invoke "f32.div" (f32.const -0x1.bbd252p+19) (f32.const -0x1.fba95p+33)) (f32.const 0x1.bf9d56p-15))
+(assert_return (invoke "f32.div" (f32.const -0x1.0f41d6p-42) (f32.const -0x1.3f2dbep+56)) (f32.const 0x1.b320d8p-99))
+(assert_return (invoke "f64.div" (f64.const 0x1.b2348a1c81899p+61) (f64.const -0x1.4a58aad903dd3p-861)) (f64.const -0x1.507c1e2a41b35p+922))
+(assert_return (invoke "f64.div" (f64.const 0x1.23fa5137a918ap-130) (f64.const -0x1.7268db1951263p-521)) (f64.const -0x1.93965e0d896bep+390))
+(assert_return (invoke "f64.div" (f64.const 0x1.dcb3915d82deep+669) (f64.const 0x1.50caaa1dc6b19p+638)) (f64.const 0x1.6a58ec814b09dp+31))
+(assert_return (invoke "f64.div" (f64.const -0x1.046e378c0cc46p+182) (f64.const 0x1.ac925009a922bp+773)) (f64.const -0x1.3720aa94dab18p-592))
+(assert_return (invoke "f64.div" (f64.const -0x1.8945fd69d8e11p-871) (f64.const -0x1.0a37870af809ap-646)) (f64.const 0x1.7a2e286c62382p-225))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.div" (f64.const 0x1.82002af0ea1f3p-57) (f64.const 0x1.d0a9b0c2fa339p+0)) (f64.const 0x1.a952fbd1fc17cp-58))
+(assert_return (invoke "f64.div" (f64.const 0x1.1e12b515db471p-102) (f64.const -0x1.41fc3c94fba5p-42)) (f64.const -0x1.c6e50cccb7cb6p-61))
+(assert_return (invoke "f64.div" (f64.const 0x1.aba5adcd6f583p-41) (f64.const 0x1.17dfac639ce0fp-112)) (f64.const 0x1.872b0a008c326p+71))
+(assert_return (invoke "f64.div" (f64.const 0x1.cf82510d0ae6bp+89) (f64.const 0x1.0207d86498053p+97)) (f64.const 0x1.cbdc804e2cf14p-8))
+(assert_return (invoke "f64.div" (f64.const 0x1.4c82cbb508e21p-11) (f64.const -0x1.6b57208c2d5d5p+52)) (f64.const -0x1.d48e8b369129ap-64))
+
+;; Division involving the maximum subnormal value and the minimum normal value.
+(assert_return (invoke "f32.div" (f32.const 0x1p-126) (f32.const 0x1.fffffcp-127)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffcp-127) (f32.const 0x1p-126)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1p-1022) (f64.const 0x0.fffffffffffffp-1022)) (f64.const 0x1.0000000000001p+0))
+(assert_return (invoke "f64.div" (f64.const 0x0.fffffffffffffp-1022) (f64.const 0x1p-1022)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test the least positive value with a positive quotient with the maximum value.
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-23) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1p-22) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
+(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-52) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
+
+;; Test the least positive value with a finite reciprocal.
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf))
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023))
+
+;; Test the least positive value that has a subnormal reciprocal.
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000002p+126)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p+126)) (f32.const 0x1p-126))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1.0000000000001p+1022)) (f64.const 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x1p+1022)) (f64.const 0x1p-1022))
+
+;; Test that the last binary digit of 1.0/3.0 is even in f32,
+;; https://en.wikipedia.org/wiki/Single-precision_floating-point_format#Single-precision_examples
+;;
+;; and odd in f64,
+;; https://en.wikipedia.org/wiki/Double-precision_floating-point_format#Double-precision_examples
+;;
+;; and that 1.0/3.0, 3.0/9.0, and 9.0/27.0 all agree.
+;; http://www.netlib.org/paranoia
+(assert_return (invoke "f32.div" (f32.const 0x1p+0) (f32.const 0x1.8p+1)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f32.div" (f32.const 0x3p+0) (f32.const 0x1.2p+3)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f32.div" (f32.const 0x1.2p+3) (f32.const 0x1.bp+4)) (f32.const 0x1.555556p-2))
+(assert_return (invoke "f64.div" (f64.const 0x1p+0) (f64.const 0x1.8p+1)) (f64.const 0x1.5555555555555p-2))
+(assert_return (invoke "f64.div" (f64.const 0x3p+0) (f64.const 0x1.2p+3)) (f64.const 0x1.5555555555555p-2))
+(assert_return (invoke "f64.div" (f64.const 0x1.2p+3) (f64.const 0x1.bp+4)) (f64.const 0x1.5555555555555p-2))
+
+;; Test division of numbers very close to 1.
+(assert_return (invoke "f32.div" (f32.const 0x1.000002p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.fffffep-1) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffap-1))
+(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.fffffep-1)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.div" (f32.const 0x1.0p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1.0000000000001p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000002p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1.fffffffffffffp-1) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffdp-1))
+(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.0000000000001p+0))
+(assert_return (invoke "f64.div" (f64.const 0x1.0p+0) (f64.const 0x1.0000000000001p+0)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test for bugs found in an early RISC-V implementation.
+;; https://github.com/riscv/riscv-tests/pull/8
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.56p+7)) (f32.const 0x1.a2744cp+3))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.594dfcp-23)) (f32.const 0x1.a4789cp-12))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.56p+7)) (f64.const 0x1.a2744ce9674f5p+3))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.594dfc70aa105p-23)) (f64.const 0x1.a4789c0e37f99p-12))
+
+;; Computations that round differently on x87.
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0263fcc94f259p-164)) (f64.const 0x1.0131485de579fp-82))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.352dfa278c43dp+338)) (f64.const 0x1.195607dac5417p+169))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.b15daa23924fap+402)) (f64.const 0x1.4d143db561493p+201))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.518c8e68cb753p-37)) (f64.const 0x1.9fb8ef1ad5bfdp-19))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.86d8b6518078ep-370)) (f64.const 0x1.3c5142a48fcadp-185))
+
+;; Test another sqrt case on x87.
+;; https://gcc.gnu.org/bugzilla/show_bug.cgi?id=52593
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.fffffffffffffp-1)) (f64.const 0x1.fffffffffffffp-1))
+
+;; Computations that round differently in round-upward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.098064p-3)) (f32.const 0x1.70b23p-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d9befp+100)) (f32.const 0x1.5c4052p+50))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.42b5b6p-4)) (f32.const 0x1.1f6d0ep-2))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3684dp-71)) (f32.const 0x1.8ebae2p-36))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.d8bc4ep-11)) (f32.const 0x1.ebf9eap-6))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.5c39f220d5704p-924)) (f64.const 0x1.2a92bc24ceae9p-462))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.53521a635745cp+727)) (f64.const 0x1.a0cfdc4ef8ff1p+363))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.dfd5bbc9f4678p+385)) (f64.const 0x1.efa817117c94cp+192))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.33f9640811cd4p+105)) (f64.const 0x1.8d17c9243baa3p+52))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.6c0ef0267ff45p+999)) (f64.const 0x1.afbcfae3f2b4p+499))
+
+;; Computations that round differently in round-downward mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.26a62ep+27)) (f32.const 0x1.84685p+13))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.166002p-113)) (f32.const 0x1.798762p-57))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.3dfb5p-15)) (f32.const 0x1.937e38p-8))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.30eb2cp-120)) (f32.const 0x1.176406p-60))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.cb705cp-123)) (f32.const 0x1.e5020ap-62))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.edae8aea0543p+695)) (f64.const 0x1.f6c1ea4fc8dd2p+347))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.f7ee4bda5c9c3p-763)) (f64.const 0x1.fbf30bdaf11c5p-382))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a48f348266ad1p-30)) (f64.const 0x1.481ee7540baf7p-15))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.feb5a1ce3ed9cp-242)) (f64.const 0x1.6995060c20d46p-121))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.957d9796e3834p+930)) (f64.const 0x1.42305213157bap+465))
+
+;; Computations that round differently in round-toward-zero mode.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.65787cp+118)) (f32.const 0x1.2e82a4p+59))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.736044p+15)) (f32.const 0x1.b40e4p+7))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.a00edp-1)) (f32.const 0x1.cd8aecp-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.7a4c8p-87)) (f32.const 0x1.b819e4p-44))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.5d24d4p-94)) (f32.const 0x1.2af75ep-47))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.a008948ead274p+738)) (f64.const 0x1.4659b37c39b19p+369))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.70f6199ed21f5p-381)) (f64.const 0x1.b2a2bddf3300dp-191))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.35c1d49f2a352p+965)) (f64.const 0x1.8e3d9f01a9716p+482))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.3fbdcfb2b2a15p-45)) (f64.const 0x1.949ba4feca42ap-23))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.c201b94757145p-492)) (f64.const 0x1.5369ee6bf2967p-246))
+
+;; Computations that round differently when computed via f32.
+(assert_return (invoke "f64.sqrt" (f64.const -0x1.360e8d0032adp-963)) (f64.const nan:canonical))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.d9a6f5eef0503p+103)) (f64.const 0x1.ec73f56c166f6p+51))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.aa051a5c4ec27p-760)) (f64.const 0x1.4a3e771ff5149p-380))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.e5522a741babep-276)) (f64.const 0x1.607ae2b6feb7dp-138))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.4832badc0c061p+567)) (f64.const 0x1.99ec7934139b2p+283))
+
+;; Test the least value with a sqrt that rounds to one.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000002p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.000004p+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000001p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.0000000000002p+0)) (f64.const 0x1.0000000000001p+0))
+
+;; Test the greatest value less than one for which sqrt is not an identity.
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffcp-1)) (f32.const 0x1.fffffep-1))
+(assert_return (invoke "f32.sqrt" (f32.const 0x1.fffffap-1)) (f32.const 0x1.fffffcp-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffep-1)) (f64.const 0x1.fffffffffffffp-1))
+(assert_return (invoke "f64.sqrt" (f64.const 0x1.ffffffffffffdp-1)) (f64.const 0x1.ffffffffffffep-1))
+
+;; Test that the bitwise floating point operators are bitwise on NaN.
+
+(assert_return (invoke "f32.abs" (f32.const nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.abs" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f64.abs" (f64.const nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.abs" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+
+(assert_return (invoke "f32.neg" (f32.const nan:0x0f1e2)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f32.neg" (f32.const -nan:0x0f1e2)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f64.neg" (f64.const nan:0x0f1e27a6b)) (f64.const -nan:0x0f1e27a6b))
+(assert_return (invoke "f64.neg" (f64.const -nan:0x0f1e27a6b)) (f64.const nan:0x0f1e27a6b))
+
+(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const nan)) (f32.const nan:0x0f1e2))
+(assert_return (invoke "f32.copysign" (f32.const -nan:0x0f1e2) (f32.const -nan)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const nan)) (f64.const nan:0x0f1e27a6b))
+(assert_return (invoke "f64.copysign" (f64.const -nan:0x0f1e27a6b) (f64.const -nan)) (f64.const -nan:0x0f1e27a6b))
+
+;; Test values close to 1.0.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep-1)) (f32.const 1.0))
+(assert_return (invoke "f32.ceil" (f32.const 0x1.000002p+0)) (f32.const 2.0))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp-1)) (f64.const 1.0))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.0000000000001p+0)) (f64.const 2.0))
+
+;; Test the maximum and minimum value for which ceil is not an identity operator.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23))
+(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52))
+(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51))
+
+;; Test that implementations don't do the x+0x1p52-0x1p52 trick outside the
+;; range where it's safe.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+23)) (f32.const 0x1.fffffep+23))
+(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+23)) (f32.const -0x1.fffffep+23))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+52)) (f64.const 0x1.fffffffffffffp+52))
+(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+52)) (f64.const -0x1.fffffffffffffp+52))
+
+;; Test values close to -1.0.
+(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0))
+(assert_return (invoke "f32.floor" (f32.const -0x1.000002p+0)) (f32.const -2.0))
+(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp-1)) (f64.const -1.0))
+(assert_return (invoke "f64.floor" (f64.const -0x1.0000000000001p+0)) (f64.const -2.0))
+
+;; Test the maximum and minimum value for which floor is not an identity operator.
+(assert_return (invoke "f32.floor" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23))
+(assert_return (invoke "f32.floor" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22))
+(assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52))
+(assert_return (invoke "f64.floor" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51))
+
+;; Test that floor isn't implemented as XMVectorFloor.
+;; http://dss.stephanierct.com/DevBlog/?p=8#comment-4
+(assert_return (invoke "f32.floor" (f32.const 88607.0)) (f32.const 88607.0))
+(assert_return (invoke "f64.floor" (f64.const 88607.0)) (f64.const 88607.0))
+
+;; Test the maximum and minimum value for which trunc is not an identity operator.
+(assert_return (invoke "f32.trunc" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22))
+(assert_return (invoke "f32.trunc" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22))
+(assert_return (invoke "f64.trunc" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51))
+(assert_return (invoke "f64.trunc" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51))
+
+;; Test that nearest isn't implemented naively.
+;; http://blog.frama-c.com/index.php?post/2013/05/02/nearbyintf1
+;; http://blog.frama-c.com/index.php?post/2013/05/04/nearbyintf3
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000002p+23)) (f32.const 0x1.000002p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.000004p+23)) (f32.const 0x1.000004p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep-2)) (f32.const 0.0))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+47)) (f32.const 0x1.fffffep+47))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000001p+52)) (f64.const 0x1.0000000000001p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.0000000000002p+52)) (f64.const 0x1.0000000000002p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp-2)) (f64.const 0.0))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+105)) (f64.const 0x1.fffffffffffffp+105))
+
+;; Nearest should not round halfway cases away from zero (as C's round(3) does)
+;; or up (as JS's Math.round does).
+(assert_return (invoke "f32.nearest" (f32.const 4.5)) (f32.const 4.0))
+(assert_return (invoke "f32.nearest" (f32.const -4.5)) (f32.const -4.0))
+(assert_return (invoke "f32.nearest" (f32.const -3.5)) (f32.const -4.0))
+(assert_return (invoke "f64.nearest" (f64.const 4.5)) (f64.const 4.0))
+(assert_return (invoke "f64.nearest" (f64.const -4.5)) (f64.const -4.0))
+(assert_return (invoke "f64.nearest" (f64.const -3.5)) (f64.const -4.0))
+
+;; Test the maximum and minimum value for which nearest is not an identity operator.
+(assert_return (invoke "f32.nearest" (f32.const -0x1.fffffep+22)) (f32.const -0x1p+23))
+(assert_return (invoke "f32.nearest" (f32.const 0x1.fffffep+22)) (f32.const 0x1p+23))
+(assert_return (invoke "f64.nearest" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52))
+(assert_return (invoke "f64.nearest" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/forward.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/forward.wast
new file mode 100644
index 0000000..7bb3770
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/forward.wast
@@ -0,0 +1,20 @@
+(module
+  (func $even (export "even") (param $n i32) (result i32)
+    (if (result i32) (i32.eq (local.get $n) (i32.const 0))
+      (then (i32.const 1))
+      (else (call $odd (i32.sub (local.get $n) (i32.const 1))))
+    )
+  )
+
+  (func $odd (export "odd") (param $n i32) (result i32)
+    (if (result i32) (i32.eq (local.get $n) (i32.const 0))
+      (then (i32.const 0))
+      (else (call $even (i32.sub (local.get $n) (i32.const 1))))
+    )
+  )
+)
+
+(assert_return (invoke "even" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "even" (i32.const 20)) (i32.const 1))
+(assert_return (invoke "odd" (i32.const 13)) (i32.const 1))
+(assert_return (invoke "odd" (i32.const 20)) (i32.const 0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func.wast
new file mode 100644
index 0000000..7189257
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func.wast
@@ -0,0 +1,961 @@
+;; Test `func` declarations, i.e. functions
+
+(module
+  ;; Auxiliary definition
+  (type $sig (func))
+  (func $dummy)
+
+  ;; Syntax
+
+  (func)
+  (func (export "f"))
+  (func $f)
+  (func $h (export "g"))
+
+  (func (local))
+  (func (local) (local))
+  (func (local i32))
+  (func (local $x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param) (param))
+  (func (param i32))
+  (func (param $x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $x i64) (param) (param i32 f64))
+
+  (func (result))
+  (func (result) (result))
+  (func (result i32) (unreachable))
+  (func (result i32 f64 f32) (unreachable))
+  (func (result i32) (result f64) (unreachable))
+  (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable))
+
+  (type $sig-1 (func))
+  (type $sig-2 (func (result i32)))
+  (type $sig-3 (func (param $x i32)))
+  (type $sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $sig-1))
+  (func (export "type-use-2") (type $sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $sig-3))
+  (func (export "type-use-4") (type $sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
+  (func (type $sig))
+  (func (type $forward))  ;; forward reference
+
+  (func $complex
+    (param i32 f32) (param $x i64) (param) (param i32)
+    (result) (result i32) (result) (result i64 i32)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $complex-sig
+    (type $sig)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+  (type $forward (func))
+
+  ;; Typing of locals
+
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
+  (func (export "local-mixed") (result f64)
+    (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of parameters
+
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
+  (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32)
+    (result f64)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of results
+
+  (func (export "empty"))
+  (func (export "value-void") (call $dummy))
+  (func (export "value-i32") (result i32) (i32.const 77))
+  (func (export "value-i64") (result i64) (i64.const 7777))
+  (func (export "value-f32") (result f32) (f32.const 77.7))
+  (func (export "value-f64") (result f64) (f64.const 77.77))
+  (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7))
+  (func (export "value-i32-i32-i32") (result i32 i32 i32)
+    (i32.const 1) (i32.const 2) (i32.const 3)
+  )
+  (func (export "value-block-void") (block (call $dummy) (call $dummy)))
+  (func (export "value-block-i32") (result i32)
+    (block (result i32) (call $dummy) (i32.const 77))
+  )
+  (func (export "value-block-i32-i64") (result i32 i64)
+    (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))
+  )
+
+  (func (export "return-empty") (return))
+  (func (export "return-i32") (result i32) (return (i32.const 78)))
+  (func (export "return-i64") (result i64) (return (i64.const 7878)))
+  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
+  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
+  (func (export "return-i32-f64") (result i32 f64)
+    (return (i32.const 78) (f64.const 78.78))
+  )
+  (func (export "return-i32-i32-i32") (result i32 i32 i32)
+    (return (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "return-block-i32") (result i32)
+    (return (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "return-block-i32-i64") (result i32 i64)
+    (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-empty") (br 0))
+  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
+  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
+  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
+  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
+  (func (export "break-i32-f64") (result i32 f64)
+    (br 0 (i32.const 79) (f64.const 79.79))
+  )
+  (func (export "break-i32-i32-i32") (result i32 i32 i32)
+    (br 0 (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "break-block-i32") (result i32)
+    (br 0 (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "break-block-i32-i64") (result i32 i64)
+    (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-br_if-empty") (param i32)
+    (br_if 0 (local.get 0))
+  )
+  (func (export "break-br_if-num") (param i32) (result i32)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
+  )
+  (func (export "break-br_if-num-num") (param i32) (result i32 i64)
+    (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0))))
+    (i32.const 51) (i64.const 52)
+  )
+
+  (func (export "break-br_table-empty") (param i32)
+    (br_table 0 0 0 (local.get 0))
+  )
+  (func (export "break-br_table-num") (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
+  )
+  (func (export "break-br_table-num-num") (param i32) (result i32 i64)
+    (br_table 0 0 (i32.const 50) (i64.const 51) (local.get 0))
+    (i32.const 51) (i64.const 52)
+  )
+  (func (export "break-br_table-nested-empty") (param i32)
+    (block (br_table 0 1 0 (local.get 0)))
+  )
+  (func (export "break-br_table-nested-num") (param i32) (result i32)
+    (i32.add
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
+      )
+      (i32.const 2)
+    )
+  )
+  (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32)
+    (i32.add
+      (block (result i32 i32)
+        (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0))
+        (i32.const 51) (i32.const -3)
+      )
+    )
+    (i32.const 52)
+  )
+
+  ;; Large signatures
+
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+
+  ;; Default initialization of locals
+
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
+)
+
+(assert_return (invoke "type-use-1"))
+(assert_return (invoke "type-use-2") (i32.const 0))
+(assert_return (invoke "type-use-3" (i32.const 1)))
+(assert_return
+  (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+(assert_return (invoke "type-use-5") (i32.const 0))
+(assert_return (invoke "type-use-6" (i32.const 1)))
+(assert_return
+  (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+
+(assert_return (invoke "local-first-i32") (i32.const 0))
+(assert_return (invoke "local-first-i64") (i64.const 0))
+(assert_return (invoke "local-first-f32") (f32.const 0))
+(assert_return (invoke "local-first-f64") (f64.const 0))
+(assert_return (invoke "local-second-i32") (i32.const 0))
+(assert_return (invoke "local-second-i64") (i64.const 0))
+(assert_return (invoke "local-second-f32") (f32.const 0))
+(assert_return (invoke "local-second-f64") (f64.const 0))
+(assert_return (invoke "local-mixed") (f64.const 0))
+
+(assert_return
+  (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)
+)
+(assert_return
+  (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)
+)
+(assert_return
+  (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)
+)
+(assert_return
+  (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)
+)
+(assert_return
+  (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)
+)
+(assert_return
+  (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)
+)
+(assert_return
+  (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)
+)
+(assert_return
+  (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)
+)
+
+(assert_return
+  (invoke "param-mixed"
+    (f32.const 1) (i32.const 2) (i64.const 3)
+    (i32.const 4) (f64.const 5.5) (i32.const 6)
+  )
+  (f64.const 5.5)
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "value-void"))
+(assert_return (invoke "value-i32") (i32.const 77))
+(assert_return (invoke "value-i64") (i64.const 7777))
+(assert_return (invoke "value-f32") (f32.const 77.7))
+(assert_return (invoke "value-f64") (f64.const 77.77))
+(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7))
+(assert_return (invoke "value-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "value-block-void"))
+(assert_return (invoke "value-block-i32") (i32.const 77))
+(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "return-empty"))
+(assert_return (invoke "return-i32") (i32.const 78))
+(assert_return (invoke "return-i64") (i64.const 7878))
+(assert_return (invoke "return-f32") (f32.const 78.7))
+(assert_return (invoke "return-f64") (f64.const 78.78))
+(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78))
+(assert_return (invoke "return-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "return-block-i32") (i32.const 77))
+(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-empty"))
+(assert_return (invoke "break-i32") (i32.const 79))
+(assert_return (invoke "break-i64") (i64.const 7979))
+(assert_return (invoke "break-f32") (f32.const 79.9))
+(assert_return (invoke "break-f64") (f64.const 79.79))
+(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79))
+(assert_return (invoke "break-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "break-block-i32") (i32.const 77))
+(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-br_if-empty" (i32.const 0)))
+(assert_return (invoke "break-br_if-empty" (i32.const 2)))
+(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
+(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_if-num-num" (i32.const 0))
+  (i32.const 51) (i64.const 52)
+)
+(assert_return (invoke "break-br_if-num-num" (i32.const 1))
+  (i32.const 50) (i64.const 51)
+)
+
+(assert_return (invoke "break-br_table-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-empty" (i32.const 5)))
+(assert_return (invoke "break-br_table-empty" (i32.const -1)))
+(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
+(assert_return (invoke "break-br_table-num-num" (i32.const 0))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 1))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 10))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const -100))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 3)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const -2)))
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 0))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 1))
+  (i32.const 50) (i32.const 51)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 2))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const -3))
+  (i32.const 101) (i32.const 52)
+)
+
+(assert_return
+  (invoke "large-sig"
+    (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3)
+    (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7)
+    (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11)
+    (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15)
+    (f32.const 16)
+  )
+  (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8)
+  (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9)
+  (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11)
+  (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12)
+)
+
+(assert_return (invoke "init-local-i32") (i32.const 0))
+(assert_return (invoke "init-local-i64") (i64.const 0))
+(assert_return (invoke "init-local-f32") (f32.const 0))
+(assert_return (invoke "init-local-f64") (f64.const 0))
+
+
+;; Expansion of inline function types
+
+(module
+  (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $g (param i32))                 ;; reuses explicit type definition
+  (type $t (func (param i32)))
+
+  (func $i32->void (type 0))                ;; (param i32)
+  (func $void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $check
+    (call $i32->void (i32.const 0))
+    (drop (call $void->f64))
+  )
+)
+
+(assert_invalid
+  (module
+    (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $g (param i32))                 ;; reuses explicit type definition
+    (func $h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )
+  "unknown type"
+)
+
+(assert_malformed
+  (module quote
+    "(func $f (result f64) (f64.const 0))"  ;; adds implicit type definition
+    "(func $g (param i32))"                 ;; reuses explicit type definition
+    "(func $h (result f64) (f64.const 1))"  ;; reuses implicit type definition
+    "(type $t (func (param i32)))"
+
+    "(func (type 2) (param i32))"  ;; does not exist
+  )
+  "unknown type"
+)
+
+(module
+  (type $proc (func (result i32)))
+  (type $sig (func (param i32) (result i32)))
+
+  (func (export "f") (type $sig)
+    (local $var i32)
+    (local.get $var)
+  )
+
+  (func $g (type $sig)
+    (local $var i32)
+    (local.get $var)
+  )
+  (func (export "g") (type $sig)
+    (call $g (local.get 0))
+  )
+
+  (func (export "p") (type $proc)
+    (local $var i32)
+    (local.set 0 (i32.const 42))
+    (local.get $var)
+  )
+)
+
+(assert_return (invoke "f" (i32.const 42)) (i32.const 0))
+(assert_return (invoke "g" (i32.const 42)) (i32.const 0))
+(assert_return (invoke "p") (i32.const 42))
+
+
+(module
+  (type $sig (func))
+
+  (func $empty-sig-1)  ;; should be assigned type $sig
+  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $empty-sig-2)  ;; should be assigned type $sig
+  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $empty-sig-duplicate (func))
+  (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table funcref
+    (elem
+      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
+      $complex-sig-4 $complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect (type $sig) (i32.const 1))
+    (call_indirect (type $sig) (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect (type $empty-sig-duplicate) (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)
+
+(assert_return (invoke "signature-explicit-reused"))
+(assert_return (invoke "signature-implicit-reused"))
+(assert_return (invoke "signature-explicit-duplicate"))
+(assert_return (invoke "signature-implicit-duplicate"))
+
+
+;; Malformed type use
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (type $sig) (result i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (result i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (type $sig) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (param i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (param i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (type $sig) (param i32) (result i32) (unreachable))"
+  )
+  "inline function type"
+)
+
+
+;; Invalid typing of locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of result
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64-i32 (result f64 i32)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-void
+    (i32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (i32.const 0) (i64.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result f32 f32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result f32)
+    (f32.const 0) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-last-empty-vs-num (result i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-empty-vs-nums (result i32 i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-num (result i32)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-nums (result i32 i64)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-num (result i32)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-nums (result i64 i64)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-empty-vs-num (result i32)
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-empty-vs-nums (result i32 i32)
+    (return) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-partial-vs-nums (result i32 i32)
+    (i32.const 1) (return) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-num (result i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-nums (result i32 i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-nums (result i32 i32)
+    (return (i64.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-nums (result i32 i32)
+    (return (i32.const 1)) (return (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-nums (result i32 i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-num (result i32)
+    (br 0 (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-nums (result i32 i32)
+    (br 0) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-nums (result i32 i32)
+    (block (br 1)) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-num (result i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-nums (result i32 i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func (nop) (local i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (result i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (result i32) (local.get 0))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (param i32) (local.get 0))")
+  "unexpected token"
+)
+
+;; Duplicate name errors
+
+(assert_malformed (module quote
+  "(func $foo)"
+  "(func $foo)")
+  "duplicate func")
+(assert_malformed (module quote
+  "(import \"\" \"\" (func $foo))"
+  "(func $foo)")
+  "duplicate func")
+(assert_malformed (module quote
+  "(import \"\" \"\" (func $foo))"
+  "(import \"\" \"\" (func $foo))")
+  "duplicate func")
+
+(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))")
+  "duplicate local")
+(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))")
+  "duplicate local")
+(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))")
+  "duplicate local")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func_ptrs.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func_ptrs.wast
new file mode 100644
index 0000000..f6f8e2c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/func_ptrs.wast
@@ -0,0 +1,106 @@
+(module
+  (type    (func))                           ;; 0: void -> void
+  (type $S (func))                           ;; 1: void -> void
+  (type    (func (param)))                   ;; 2: void -> void
+  (type    (func (result i32)))              ;; 3: void -> i32
+  (type    (func (param) (result i32)))      ;; 4: void -> i32
+  (type $T (func (param i32) (result i32)))  ;; 5: i32 -> i32
+  (type $U (func (param i32)))               ;; 6: i32 -> void
+
+  (func $print (import "spectest" "print_i32") (type 6))
+
+  (func (type 0))
+  (func (type $S))
+
+  (func (export "one") (type 4) (i32.const 13))
+  (func (export "two") (type $T) (i32.add (local.get 0) (i32.const 1)))
+
+  ;; Both signature and parameters are allowed (and required to match)
+  ;; since this allows the naming of parameters.
+  (func (export "three") (type $T) (param $a i32) (result i32)
+    (i32.sub (local.get 0) (i32.const 2))
+  )
+
+  (func (export "four") (type $U) (call $print (local.get 0)))
+)
+
+(assert_return (invoke "one") (i32.const 13))
+(assert_return (invoke "two" (i32.const 13)) (i32.const 14))
+(assert_return (invoke "three" (i32.const 13)) (i32.const 11))
+(invoke "four" (i32.const 83))
+
+(assert_invalid (module (elem (i32.const 0))) "unknown table")
+(assert_invalid (module (elem (i32.const 0) 0) (func)) "unknown table")
+
+(assert_invalid
+  (module (table 1 funcref) (elem (i64.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (table 1 funcref) (elem (i32.ctz (i32.const 0))))
+  "constant expression required"
+)
+(assert_invalid
+  (module (table 1 funcref) (elem (nop)))
+  "constant expression required"
+)
+
+(assert_invalid (module (func (type 42))) "unknown type")
+(assert_invalid (module (import "spectest" "print_i32" (func (type 43)))) "unknown type")
+
+(module
+  (type $T (func (param) (result i32)))
+  (type $U (func (param) (result i32)))
+  (table funcref (elem $t1 $t2 $t3 $u1 $u2 $t1 $t3))
+
+  (func $t1 (type $T) (i32.const 1))
+  (func $t2 (type $T) (i32.const 2))
+  (func $t3 (type $T) (i32.const 3))
+  (func $u1 (type $U) (i32.const 4))
+  (func $u2 (type $U) (i32.const 5))
+
+  (func (export "callt") (param $i i32) (result i32)
+    (call_indirect (type $T) (local.get $i))
+  )
+
+  (func (export "callu") (param $i i32) (result i32)
+    (call_indirect (type $U) (local.get $i))
+  )
+)
+
+(assert_return (invoke "callt" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "callt" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "callt" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "callt" (i32.const 3)) (i32.const 4))
+(assert_return (invoke "callt" (i32.const 4)) (i32.const 5))
+(assert_return (invoke "callt" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "callt" (i32.const 6)) (i32.const 3))
+(assert_trap (invoke "callt" (i32.const 7)) "undefined element")
+(assert_trap (invoke "callt" (i32.const 100)) "undefined element")
+(assert_trap (invoke "callt" (i32.const -1)) "undefined element")
+
+(assert_return (invoke "callu" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "callu" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "callu" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "callu" (i32.const 3)) (i32.const 4))
+(assert_return (invoke "callu" (i32.const 4)) (i32.const 5))
+(assert_return (invoke "callu" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "callu" (i32.const 6)) (i32.const 3))
+(assert_trap (invoke "callu" (i32.const 7)) "undefined element")
+(assert_trap (invoke "callu" (i32.const 100)) "undefined element")
+(assert_trap (invoke "callu" (i32.const -1)) "undefined element")
+
+(module
+  (type $T (func (result i32)))
+  (table funcref (elem 0 1))
+
+  (func $t1 (type $T) (i32.const 1))
+  (func $t2 (type $T) (i32.const 2))
+
+  (func (export "callt") (param $i i32) (result i32)
+    (call_indirect (type $T) (local.get $i))
+  )
+)
+
+(assert_return (invoke "callt" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "callt" (i32.const 1)) (i32.const 2))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/global.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/global.wast
new file mode 100644
index 0000000..9fa5e22
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/global.wast
@@ -0,0 +1,624 @@
+;; Test globals
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $a i32 (i32.const -2))
+  (global (;3;) f32 (f32.const -3))
+  (global (;4;) f64 (f64.const -4))
+  (global $b i64 (i64.const -5))
+
+  (global $x (mut i32) (i32.const -12))
+  (global (;7;) (mut f32) (f32.const -13))
+  (global (;8;) (mut f64) (f64.const -14))
+  (global $y (mut i64) (i64.const -15))
+
+  (global $z1 i32 (global.get 0))
+  (global $z2 i64 (global.get 1))
+
+  (global $r externref (ref.null extern))
+  (global $mr (mut externref) (ref.null extern))
+  (global funcref (ref.null func))
+
+  (func (export "get-a") (result i32) (global.get $a))
+  (func (export "get-b") (result i64) (global.get $b))
+  (func (export "get-r") (result externref) (global.get $r))
+  (func (export "get-mr") (result externref) (global.get $mr))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i64) (global.get $y))
+  (func (export "get-z1") (result i32) (global.get $z1))
+  (func (export "get-z2") (result i64) (global.get $z2))
+  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
+  (func (export "set-mr") (param externref) (global.set $mr (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get 3))
+  (func (export "get-4") (result f64) (global.get 4))
+  (func (export "get-7") (result f32) (global.get 7))
+  (func (export "get-8") (result f64) (global.get 8))
+  (func (export "set-7") (param f32) (global.set 7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set 8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $x) (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy) (global.get $x) (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy) (global.get $x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $x)
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $x) (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (global.get $x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (global.get $x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0) (global.get $x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $x))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (global.get $x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $x (global.get $x))
+    (global.get $x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $x) (global.get $x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)
+
+(assert_return (invoke "get-a") (i32.const -2))
+(assert_return (invoke "get-b") (i64.const -5))
+(assert_return (invoke "get-r") (ref.null extern))
+(assert_return (invoke "get-mr") (ref.null extern))
+(assert_return (invoke "get-x") (i32.const -12))
+(assert_return (invoke "get-y") (i64.const -15))
+(assert_return (invoke "get-z1") (i32.const 666))
+(assert_return (invoke "get-z2") (i64.const 666))
+
+(assert_return (invoke "get-3") (f32.const -3))
+(assert_return (invoke "get-4") (f64.const -4))
+(assert_return (invoke "get-7") (f32.const -13))
+(assert_return (invoke "get-8") (f64.const -14))
+
+(assert_return (invoke "set-x" (i32.const 6)))
+(assert_return (invoke "set-y" (i64.const 7)))
+
+(assert_return (invoke "set-7" (f32.const 8)))
+(assert_return (invoke "set-8" (f64.const 9)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-7") (f32.const 8))
+(assert_return (invoke "get-8") (f64.const 9))
+
+(assert_return (invoke "set-7" (f32.const 8)))
+(assert_return (invoke "set-8" (f64.const 9)))
+(assert_return (invoke "set-mr" (ref.extern 10)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-7") (f32.const 8))
+(assert_return (invoke "get-8") (f64.const 9))
+(assert_return (invoke "get-mr") (ref.extern 10))
+
+(assert_return (invoke "as-select-first") (i32.const 6))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 6))
+(assert_return (invoke "as-loop-mid") (i32.const 6))
+(assert_return (invoke "as-loop-last") (i32.const 6))
+
+(assert_return (invoke "as-if-condition") (i32.const 2))
+(assert_return (invoke "as-if-then") (i32.const 6))
+(assert_return (invoke "as-if-else") (i32.const 6))
+
+(assert_return (invoke "as-br_if-first") (i32.const 6))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 6))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 6))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+
+(assert_return (invoke "as-call-value") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 6))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 6))
+
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-global.set-value") (i32.const 6))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 36))
+(assert_return (invoke "as-compare-operand") (i32.const 1))
+
+(assert_invalid
+  (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))
+  "global is immutable"
+)
+
+(assert_invalid
+  (module (import "spectest" "global_i32" (global i32)) (func (global.set 0 (i32.const 1))))
+  "global is immutable"
+)
+
+;; mutable globals can be exported
+(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
+(module (global (export "a") (mut f32) (f32.const 0)))
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (local.get 0)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 1))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.ctz (i32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (f32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (i32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (;empty instruction sequence;)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "" "") externref) (global funcref (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (global.get 0) (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (i32.const 0) (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-i32") i32) (global i32 (global.get 2)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global (import "test" "global-mut-i32") (mut i32)) (global i32 (global.get 0)))
+  "constant expression required"
+)
+
+(module
+  (import "spectest" "global_i32" (global i32))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\02"                          ;; malformed mutability
+  )
+  "malformed mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\ff"                          ;; malformed mutability
+  )
+  "malformed mutability"
+)
+
+(module
+  (global i32 (i32.const 0))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\02"               ;; malformed mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "malformed mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\ff"               ;; malformed mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "malformed mutability"
+)
+
+;; global.get with invalid index
+(assert_invalid
+  (module (func (result i32) (global.get 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (func (result i32) (global.get 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (result i32) (global.get 2))
+  )
+  "unknown global"
+)
+
+;; global.set with invalid index
+(assert_invalid
+  (module (func (i32.const 0) (global.set 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (func (i32.const 0) (global.set 1))
+  )
+  "unknown global"
+)
+
+(assert_invalid
+  (module
+    (import "spectest" "global_i32" (global i32))
+    (global i32 (i32.const 0))
+    (func (i32.const 0) (global.set 2))
+  )
+  "unknown global"
+)
+
+
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty
+      (global.set $x)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-return
+      (return (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-select
+      (select (global.set $x) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-call
+      (call 1 (global.set $x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (global.set $x) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+;; Duplicate identifier errors
+
+(assert_malformed (module quote
+  "(global $foo i32 (i32.const 0))"
+  "(global $foo i32 (i32.const 0))")
+  "duplicate global")
+(assert_malformed (module quote
+  "(import \"\" \"\" (global $foo i32))"
+  "(global $foo i32 (i32.const 0))")
+  "duplicate global")
+(assert_malformed (module quote
+  "(import \"\" \"\" (global $foo i32))"
+  "(import \"\" \"\" (global $foo i32))")
+  "duplicate global")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i32.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i32.wast
new file mode 100644
index 0000000..32862c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i32.wast
@@ -0,0 +1,976 @@
+;; i32 operations
+
+(module
+  (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x)))
+  (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x)))
+  (func (export "extend8_s") (param $x i32) (result i32) (i32.extend8_s (local.get $x)))
+  (func (export "extend16_s") (param $x i32) (result i32) (i32.extend16_s (local.get $x)))
+  (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x)))
+  (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2))
+(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff))
+(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000))
+
+(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff))
+(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000))
+
+(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001))
+(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470))
+(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+
+(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
+(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
+(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
+(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2))
+
+(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000))
+(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef))
+(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b))
+(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd))
+(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2))
+
+(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647))
+(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3))
+
+(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001))
+(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649))
+(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5))
+(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5))
+(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3))
+
+(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff))
+(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0))
+(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+
+(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
+(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
+(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff))
+(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+
+(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
+(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
+(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff))
+(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
+(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f))
+(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0))
+
+(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe))
+(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe))
+(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2))
+(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
+
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
+(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000))
+(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
+
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff))
+(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
+(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000))
+(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
+
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "rotl" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed))
+(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f))
+(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x183a5c76))
+(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000))
+(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x183a5c76))
+(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0x579beed3))
+(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
+(assert_return (invoke "rotl" (i32.const 0x80000000) (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "rotr" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600))
+(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000))
+(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x1d860e97))
+(assert_return (invoke "rotr" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00000400))
+(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97))
+(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5))
+(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0xe6fbb4d5))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 31)) (i32.const 2))
+(assert_return (invoke "rotr" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
+
+(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0))
+(assert_return (invoke "clz" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16))
+(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24))
+(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "clz" (i32.const 1)) (i32.const 31))
+(assert_return (invoke "clz" (i32.const 2)) (i32.const 30))
+(assert_return (invoke "clz" (i32.const 0x7fffffff)) (i32.const 1))
+
+(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15))
+(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16))
+(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31))
+(assert_return (invoke "ctz" (i32.const 0x7fffffff)) (i32.const 0))
+
+(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32))
+(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1))
+(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2))
+(assert_return (invoke "popcnt" (i32.const 0x7fffffff)) (i32.const 31))
+(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16))
+(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16))
+(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24))
+
+(assert_return (invoke "extend8_s" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "extend8_s" (i32.const 0x7f)) (i32.const 127))
+(assert_return (invoke "extend8_s" (i32.const 0x80)) (i32.const -128))
+(assert_return (invoke "extend8_s" (i32.const 0xff)) (i32.const -1))
+(assert_return (invoke "extend8_s" (i32.const 0x012345_00)) (i32.const 0))
+(assert_return (invoke "extend8_s" (i32.const 0xfedcba_80)) (i32.const -0x80))
+(assert_return (invoke "extend8_s" (i32.const -1)) (i32.const -1))
+
+(assert_return (invoke "extend16_s" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "extend16_s" (i32.const 0x7fff)) (i32.const 32767))
+(assert_return (invoke "extend16_s" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "extend16_s" (i32.const 0xffff)) (i32.const -1))
+(assert_return (invoke "extend16_s" (i32.const 0x0123_0000)) (i32.const 0))
+(assert_return (invoke "extend16_s" (i32.const 0xfedc_8000)) (i32.const -0x8000))
+(assert_return (invoke "extend16_s" (i32.const -1)) (i32.const -1))
+
+(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.eqz) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.eqz) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.eqz) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.eqz)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.eqz) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.eqz)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-return
+      (return (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-select
+      (select (i32.eqz) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-call
+      (call 1 (i32.eqz)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-unary-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.eqz) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.eqz)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-unary-operand-empty-in-global.set
+      (global.set $x (i32.eqz)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-unary-operand-empty-in-memory.grow
+      (memory.grow (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-unary-operand-empty-in-load
+      (i32.load (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-unary-operand-empty-in-store
+      (i32.store (i32.eqz) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty
+      (i32.add) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty
+      (i32.const 0) (i32.add) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-if
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (i32.add) (then (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (i32.const 0) (then (i32.add)) (else (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-else
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0)))
+      (drop) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add)))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br
+      (i32.const 0) (i32.const 0)
+      (block (br 0 (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br_if
+      (i32.const 0) (i32.const 0)
+      (block (br_if 0 (i32.add) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.const 0) (i32.add) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br_table
+      (i32.const 0) (i32.const 0)
+      (block (br_table 0 (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-return
+      (return (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-return
+      (return (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-select
+      (select (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-select
+      (select (i32.const 0) (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-call
+      (call 1 (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-call
+      (call 1 (i32.const 0) (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-binary-1st-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-binary-2nd-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.const 0) (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.add)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.const 0) (i32.add)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-binary-1st-operand-empty-in-global.set
+      (global.set $x (i32.add)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-binary-2nd-operand-empty-in-global.set
+      (global.set $x (i32.const 0) (i32.add)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-1st-operand-empty-in-memory.grow
+      (memory.grow (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-2nd-operand-empty-in-memory.grow
+      (memory.grow (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-1st-operand-empty-in-load
+      (i32.load (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-2nd-operand-empty-in-load
+      (i32.load (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-binary-1st-operand-empty-in-store
+      (i32.store (i32.add) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-binary-2nd-operand-empty-in-store
+      (i32.store (i32.const 1) (i32.add) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (i32.add (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.and (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.div_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.div_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.mul (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.or (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rem_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rem_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rotl (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rotr (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shl (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shr_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shr_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.sub (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.xor (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.eqz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.clz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ctz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.popcnt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.eq (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ge_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ge_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.gt_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.gt_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.le_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.le_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i64.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i64.wast
new file mode 100644
index 0000000..baeed0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/i64.wast
@@ -0,0 +1,485 @@
+;; i64 operations
+
+(module
+  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x)))
+  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x)))
+  (func (export "extend8_s") (param $x i64) (result i64) (i64.extend8_s (local.get $x)))
+  (func (export "extend16_s") (param $x i64) (result i64) (i64.extend16_s (local.get $x)))
+  (func (export "extend32_s") (param $x i64) (result i64) (i64.extend32_s (local.get $x)))
+  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x)))
+  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
+(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
+
+(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
+
+(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
+(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
+(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
+(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
+(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
+(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
+(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
+(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
+(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
+(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d))
+(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1))
+
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567))
+(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2))
+(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+
+(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
+(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
+(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
+(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
+(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
+(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
+(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
+(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
+(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
+(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
+(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
+(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63))
+(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
+
+(assert_return (invoke "extend8_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend8_s" (i64.const 0x7f)) (i64.const 127))
+(assert_return (invoke "extend8_s" (i64.const 0x80)) (i64.const -128))
+(assert_return (invoke "extend8_s" (i64.const 0xff)) (i64.const -1))
+(assert_return (invoke "extend8_s" (i64.const 0x01234567_89abcd_00)) (i64.const 0))
+(assert_return (invoke "extend8_s" (i64.const 0xfedcba98_765432_80)) (i64.const -0x80))
+(assert_return (invoke "extend8_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "extend16_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend16_s" (i64.const 0x7fff)) (i64.const 32767))
+(assert_return (invoke "extend16_s" (i64.const 0x8000)) (i64.const -32768))
+(assert_return (invoke "extend16_s" (i64.const 0xffff)) (i64.const -1))
+(assert_return (invoke "extend16_s" (i64.const 0x12345678_9abc_0000)) (i64.const 0))
+(assert_return (invoke "extend16_s" (i64.const 0xfedcba98_7654_8000)) (i64.const -0x8000))
+(assert_return (invoke "extend16_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "extend32_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend32_s" (i64.const 0x7fff)) (i64.const 32767))
+(assert_return (invoke "extend32_s" (i64.const 0x8000)) (i64.const 32768))
+(assert_return (invoke "extend32_s" (i64.const 0xffff)) (i64.const 65535))
+(assert_return (invoke "extend32_s" (i64.const 0x7fffffff)) (i64.const 0x7fffffff))
+(assert_return (invoke "extend32_s" (i64.const 0x80000000)) (i64.const -0x80000000))
+(assert_return (invoke "extend32_s" (i64.const 0xffffffff)) (i64.const -1))
+(assert_return (invoke "extend32_s" (i64.const 0x01234567_00000000)) (i64.const 0))
+(assert_return (invoke "extend32_s" (i64.const 0xfedcba98_80000000)) (i64.const -0x80000000))
+(assert_return (invoke "extend32_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
+
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result i64) (i64.add (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.and (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.div_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.div_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.mul (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.or (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rem_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rem_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rotl (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rotr (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shl (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shr_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shr_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.sub (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.xor (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.eqz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.clz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ctz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.popcnt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/if.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/if.wast
new file mode 100644
index 0000000..1cbb617
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/if.wast
@@ -0,0 +1,1550 @@
+;; Test `if` operator
+
+(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty") (param i32)
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $l (local.get 0) (then))
+    (if $l (local.get 0) (then) (else))
+  )
+
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+
+  (func (export "multi") (param i32) (result i32 i32)
+    (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy)))
+    (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+      (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy))
+    )
+    (if (result i32 i64 i32) (local.get 0)
+      (then
+        (call $dummy) (call $dummy) (i32.const 1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const 2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const 3) (call $dummy)
+      )
+      (else
+        (call $dummy) (call $dummy) (i32.const -1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const -2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const -3) (call $dummy)
+      )
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 9))
+          (else (call $dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 10))
+          (else (call $dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (local.get 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (local.set 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (local.get 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.ctz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const -13))
+      )
+    )
+  )
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 3))
+        (else (call $dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const -5))
+      )
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-compare-operand") (param i32 i32) (result i32)
+    (f32.gt
+      (if (result f32) (local.get 0)
+        (then (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -3))
+      )
+      (if (result f32) (local.get 1)
+        (then (call $dummy) (f32.const 4))
+        (else (call $dummy) (f32.const -4))
+      )
+    )
+  )
+  (func (export "as-binary-operands") (param i32) (result i32)
+    (i32.mul
+      (if (result i32 i32) (local.get 0)
+        (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4))
+      )
+    )
+  )
+  (func (export "as-compare-operands") (param i32) (result i32)
+    (f32.gt
+      (if (result f32 f32) (local.get 0)
+        (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3))
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (param i32) (result i32)
+    (if (result i32 i32) (local.get 0)
+      (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+      (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4))
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (if (i32.const 1) (then (br 0) (unreachable)))
+    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
+    (i32.const 19)
+  )
+
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+  (func (export "break-multi-value") (param i32) (result i32 i32 i64)
+    (if (result i32 i32 i64) (local.get 0)
+      (then
+        (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+        (i32.const 19) (i32.const -19) (i64.const 19)
+      )
+      (else
+        (br 0 (i32.const -18) (i32.const 18) (i64.const -18))
+        (i32.const -19) (i32.const 19) (i64.const -19)
+      )
+    )
+  )
+
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+  (func (export "params") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add))
+      (else (i32.sub))
+    )
+  )
+  (func (export "params-id") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then))
+    (i32.add)
+  )
+  (func (export "param-break") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add) (br 0))
+      (else (i32.const -2) (i32.add) (br 0))
+    )
+  )
+  (func (export "params-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add) (br 0))
+      (else (i32.sub) (br 0))
+    )
+  )
+  (func (export "params-id-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0)))
+    (i32.add)
+  )
+
+  (func (export "effects") (param i32) (result i32)
+    (local i32)
+    (if
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
+      (then
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
+      )
+      (else
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Examples
+
+  (func $add64_u_with_carry (export "add64_u_with_carry")
+    (param $i i64) (param $j i64) (param $c i32) (result i64 i32)
+    (local $k i64)
+    (local.set $k
+      (i64.add
+        (i64.add (local.get $i) (local.get $j))
+        (i64.extend_i32_u (local.get $c))
+      )
+    )
+    (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i)))
+  )
+
+  (func $add64_u_saturated (export "add64_u_saturated")
+    (param i64 i64) (result i64)
+    (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
+    (if (param i64) (result i64)
+      (then (drop) (i64.const -1))
+    )
+  )
+
+  ;; Block signature syntax
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (if (type $block-sig-1) (i32.const 1) (then))
+    (if (type $block-sig-2) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop)))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4) (i32.const 1) (then))
+    (drop) (drop) (drop)
+    (if (type $block-sig-2) (result i32) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (param i32) (i32.const 1)
+      (then (drop)) (else (drop))
+    )
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+      (i32.const 1) (then)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty" (i32.const 0)))
+(assert_return (invoke "empty" (i32.const 1)))
+(assert_return (invoke "empty" (i32.const 100)))
+(assert_return (invoke "empty" (i32.const -2)))
+
+(assert_return (invoke "singular" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "singular" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const -10)) (i32.const 7))
+
+(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1))
+(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1))
+
+(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11))
+(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9))
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15))
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12))
+(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3))
+(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18))
+(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "break-multi-value" (i32.const 0))
+  (i32.const -18) (i32.const 18) (i64.const -18)
+)
+(assert_return (invoke "break-multi-value" (i32.const 1))
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+
+(assert_return (invoke "param" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "effects" (i32.const 1)) (i32.const -14))
+(assert_return (invoke "effects" (i32.const 0)) (i32.const -6))
+
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0))
+  (i64.const 0) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0))
+  (i64.const 224) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0))
+  (i64.const -1) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0))
+  (i64.const -2) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1))
+  (i64.const 1) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1)
+)
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (type $sig) (result i32) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (type $sig) (result i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (result i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (type $sig) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (param i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (param $x i32) (then (drop)) (else (drop)))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (then (drop)) (else (drop)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (result i32) (then)) (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (i32.const 1) (if (type $sig) (i32.const 0) (then)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-num-vs-void-else
+    (if (i32.const 1) (then (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void-else
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-no-else-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-no-else-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-both-different-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-different-value-nums-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 0)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (i64.const 0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (i64.const 0))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-condition-empty
+      (if (then))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-block
+      (i32.const 0)
+      (block (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-loop
+      (i32.const 0)
+      (loop (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (if (then))))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br
+      (i32.const 0)
+      (block (br 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (if(then)) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-return
+      (return (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-select
+      (select (if(then)) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-call
+      (call 1 (if(then))) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-condition-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (if(then)) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.set
+      (local i32)
+      (local.set 0 (if(then))) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-condition-empty-in-global.set
+      (global.set $x (if(then))) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-memory.grow
+      (memory.grow (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-load
+      (i32.load (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-condition-empty-in-store
+      (i32.store (if(then)) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (if (param i32 f64) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (if (param i32 f64) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) if (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func i32.const 0 if end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l1 end $l2)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end $l)")
+  "mismatching label"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/imports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/imports.wast
new file mode 100644
index 0000000..35e8c91
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/imports.wast
@@ -0,0 +1,696 @@
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (global (export "global-mut-i64") (mut i64) (i64.const 66))
+  (table (export "table-10-inf") 10 funcref)
+  (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; Multiple memories are not yet supported
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    ;; JavaScript can't handle i64 yet.
+    ;; (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    ;; JavaScript can't handle i64 yet.
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+;; Export sharing name with import
+(module
+  (import "spectest" "print_i32" (func $imported_print (param i32)))
+  (func (export "print_i32") (param $i i32)
+    (call $imported_print (local.get $i))
+  )
+)
+
+(assert_return (invoke "print_i32" (i32.const 13)))
+
+;; Export sharing name with import
+(module
+  (import "spectest" "print_i32" (func $imported_print (param i32)))
+  (func (export "print_i32") (param $i i32) (param $j i32) (result i32)
+    (i32.add (local.get $i) (local.get $j))
+  )
+)
+
+(assert_return (invoke "print_i32" (i32.const 5) (i32.const 11)) (i32.const 16))
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+(module (import "test" "global-mut-i64" (global (mut i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (global i64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global f32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global f64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (global (mut i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global i64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global f64)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-f32" (global (mut f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global (mut f64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-mut-i64" (global i64)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table $tab 10 20 funcref))
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table $tab (import "spectest" "table") 10 20 funcref)
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (import "spectest" "table" (table 0 funcref))
+  (table 10 funcref)
+  (table 10 funcref)
+)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 funcref)))
+(module (import "test" "table-10-20" (table 5 funcref)))
+(module (import "test" "table-10-20" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 20 funcref)))
+(module (import "test" "table-10-20" (table 5 20 funcref)))
+(module (import "test" "table-10-20" (table 0 20 funcref)))
+(module (import "test" "table-10-20" (table 10 25 funcref)))
+(module (import "test" "table-10-20" (table 5 25 funcref)))
+(module (import "test" "table-10-20" (table 0 25 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 12 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 10 18 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+(module $Mgm
+  (memory (export "memory") 1) ;; initial size is 1
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-memory" $Mgm)
+(assert_return (invoke $Mgm "grow") (i32.const 1)) ;; now size is 2
+(module $Mgim1
+  ;; imported memory limits should match, because external memory size is 2 now
+  (memory (export "memory") (import "grown-memory" "memory") 2) 
+  (func (export "grow") (result i32) (memory.grow (i32.const 1)))
+)
+(register "grown-imported-memory" $Mgim1)
+(assert_return (invoke $Mgim1 "grow") (i32.const 2)) ;; now size is 3
+(module $Mgim2
+  ;; imported memory limits should match, because external memory size is 3 now
+  (import "grown-imported-memory" "memory" (memory 3))
+  (func (export "size") (result i32) (memory.size))
+)
+(assert_return (invoke $Mgim2 "size") (i32.const 3))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/inline-module.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/inline-module.wast
new file mode 100644
index 0000000..dc7ead7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/inline-module.wast
@@ -0,0 +1 @@
+(func) (memory 0) (func (export "f"))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_exprs.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_exprs.wast
new file mode 100644
index 0000000..22e1fbc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_exprs.wast
@@ -0,0 +1,350 @@
+;; Test interesting integer "expressions". These tests contain code
+;; patterns which tempt common value-changing optimizations.
+
+;; Test that x+1<y+1 is not folded to x<y.
+
+(module
+  (func (export "i32.no_fold_cmp_s_offset") (param $x i32) (param $y i32) (result i32)
+    (i32.lt_s (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
+  (func (export "i32.no_fold_cmp_u_offset") (param $x i32) (param $y i32) (result i32)
+    (i32.lt_u (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
+
+  (func (export "i64.no_fold_cmp_s_offset") (param $x i64) (param $y i64) (result i32)
+    (i64.lt_s (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
+  (func (export "i64.no_fold_cmp_u_offset") (param $x i64) (param $y i64) (result i32)
+    (i64.lt_u (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
+)
+
+(assert_return (invoke "i32.no_fold_cmp_s_offset" (i32.const 0x7fffffff) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "i32.no_fold_cmp_u_offset" (i32.const 0xffffffff) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "i64.no_fold_cmp_s_offset" (i64.const 0x7fffffffffffffff) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "i64.no_fold_cmp_u_offset" (i64.const 0xffffffffffffffff) (i64.const 0)) (i32.const 1))
+
+;; Test that wrap(extend_s(x)) is not folded to x.
+
+(module
+  (func (export "i64.no_fold_wrap_extend_s") (param $x i64) (result i64)
+    (i64.extend_i32_s (i32.wrap_i64 (local.get $x))))
+)
+
+(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
+(assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x00a0b0c0d0e0f0a0)) (i64.const 0xffffffffd0e0f0a0))
+
+;; Test that wrap(extend_u(x)) is not folded to x.
+
+(module
+  (func (export "i64.no_fold_wrap_extend_u") (param $x i64) (result i64)
+    (i64.extend_i32_u (i32.wrap_i64 (local.get $x))))
+)
+
+(assert_return (invoke "i64.no_fold_wrap_extend_u" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
+
+;; Test that x<<n>>n is not folded to x.
+
+(module
+  (func (export "i32.no_fold_shl_shr_s") (param $x i32) (result i32)
+    (i32.shr_s (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
+  (func (export "i32.no_fold_shl_shr_u") (param $x i32) (result i32)
+    (i32.shr_u (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
+
+  (func (export "i64.no_fold_shl_shr_s") (param $x i64) (result i64)
+    (i64.shr_s (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
+  (func (export "i64.no_fold_shl_shr_u") (param $x i64) (result i64)
+    (i64.shr_u (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
+)
+
+(assert_return (invoke "i32.no_fold_shl_shr_s" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "i32.no_fold_shl_shr_u" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "i64.no_fold_shl_shr_s" (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "i64.no_fold_shl_shr_u" (i64.const 0x8000000000000000)) (i64.const 0))
+
+;; Test that x>>n<<n is not folded to x.
+
+(module
+  (func (export "i32.no_fold_shr_s_shl") (param $x i32) (result i32)
+    (i32.shl (i32.shr_s (local.get $x) (i32.const 1)) (i32.const 1)))
+  (func (export "i32.no_fold_shr_u_shl") (param $x i32) (result i32)
+    (i32.shl (i32.shr_u (local.get $x) (i32.const 1)) (i32.const 1)))
+
+  (func (export "i64.no_fold_shr_s_shl") (param $x i64) (result i64)
+    (i64.shl (i64.shr_s (local.get $x) (i64.const 1)) (i64.const 1)))
+  (func (export "i64.no_fold_shr_u_shl") (param $x i64) (result i64)
+    (i64.shl (i64.shr_u (local.get $x) (i64.const 1)) (i64.const 1)))
+)
+
+(assert_return (invoke "i32.no_fold_shr_s_shl" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "i32.no_fold_shr_u_shl" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "i64.no_fold_shr_s_shl" (i64.const 1)) (i64.const 0))
+(assert_return (invoke "i64.no_fold_shr_u_shl" (i64.const 1)) (i64.const 0))
+
+;; Test that x/n*n is not folded to x.
+
+(module
+  (func (export "i32.no_fold_div_s_mul") (param $x i32) (result i32)
+    (i32.mul (i32.div_s (local.get $x) (i32.const 6)) (i32.const 6)))
+  (func (export "i32.no_fold_div_u_mul") (param $x i32) (result i32)
+    (i32.mul (i32.div_u (local.get $x) (i32.const 6)) (i32.const 6)))
+
+  (func (export "i64.no_fold_div_s_mul") (param $x i64) (result i64)
+    (i64.mul (i64.div_s (local.get $x) (i64.const 6)) (i64.const 6)))
+  (func (export "i64.no_fold_div_u_mul") (param $x i64) (result i64)
+    (i64.mul (i64.div_u (local.get $x) (i64.const 6)) (i64.const 6)))
+)
+
+(assert_return (invoke "i32.no_fold_div_s_mul" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "i32.no_fold_div_u_mul" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "i64.no_fold_div_s_mul" (i64.const 1)) (i64.const 0))
+(assert_return (invoke "i64.no_fold_div_u_mul" (i64.const 1)) (i64.const 0))
+
+;; Test that x/x is not folded to 1.
+
+(module
+  (func (export "i32.no_fold_div_s_self") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (local.get $x)))
+  (func (export "i32.no_fold_div_u_self") (param $x i32) (result i32)
+    (i32.div_u (local.get $x) (local.get $x)))
+
+  (func (export "i64.no_fold_div_s_self") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (local.get $x)))
+  (func (export "i64.no_fold_div_u_self") (param $x i64) (result i64)
+    (i64.div_u (local.get $x) (local.get $x)))
+)
+
+(assert_trap (invoke "i32.no_fold_div_s_self" (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "i32.no_fold_div_u_self" (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "i64.no_fold_div_s_self" (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "i64.no_fold_div_u_self" (i64.const 0)) "integer divide by zero")
+
+;; Test that x%x is not folded to 0.
+
+(module
+  (func (export "i32.no_fold_rem_s_self") (param $x i32) (result i32)
+    (i32.rem_s (local.get $x) (local.get $x)))
+  (func (export "i32.no_fold_rem_u_self") (param $x i32) (result i32)
+    (i32.rem_u (local.get $x) (local.get $x)))
+
+  (func (export "i64.no_fold_rem_s_self") (param $x i64) (result i64)
+    (i64.rem_s (local.get $x) (local.get $x)))
+  (func (export "i64.no_fold_rem_u_self") (param $x i64) (result i64)
+    (i64.rem_u (local.get $x) (local.get $x)))
+)
+
+(assert_trap (invoke "i32.no_fold_rem_s_self" (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "i32.no_fold_rem_u_self" (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "i64.no_fold_rem_s_self" (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "i64.no_fold_rem_u_self" (i64.const 0)) "integer divide by zero")
+
+;; Test that x*n/n is not folded to x.
+
+(module
+  (func (export "i32.no_fold_mul_div_s") (param $x i32) (result i32)
+    (i32.div_s (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
+  (func (export "i32.no_fold_mul_div_u") (param $x i32) (result i32)
+    (i32.div_u (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
+
+  (func (export "i64.no_fold_mul_div_s") (param $x i64) (result i64)
+    (i64.div_s (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
+  (func (export "i64.no_fold_mul_div_u") (param $x i64) (result i64)
+    (i64.div_u (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
+)
+
+(assert_return (invoke "i32.no_fold_mul_div_s" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "i32.no_fold_mul_div_u" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "i64.no_fold_mul_div_s" (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "i64.no_fold_mul_div_u" (i64.const 0x8000000000000000)) (i64.const 0))
+
+;; Test that x/n where n is a known power of 2 is not folded to shr_s.
+
+(module
+  (func (export "i32.no_fold_div_s_2") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const 2)))
+
+  (func (export "i64.no_fold_div_s_2") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const 2)))
+)
+
+(assert_return (invoke "i32.no_fold_div_s_2" (i32.const -11)) (i32.const -5))
+(assert_return (invoke "i64.no_fold_div_s_2" (i64.const -11)) (i64.const -5))
+
+;; Test that x%n where n is a known power of 2 is not folded to and.
+
+(module
+  (func (export "i32.no_fold_rem_s_2") (param $x i32) (result i32)
+    (i32.rem_s (local.get $x) (i32.const 2)))
+
+  (func (export "i64.no_fold_rem_s_2") (param $x i64) (result i64)
+    (i64.rem_s (local.get $x) (i64.const 2)))
+)
+
+(assert_return (invoke "i32.no_fold_rem_s_2" (i32.const -11)) (i32.const -1))
+(assert_return (invoke "i64.no_fold_rem_s_2" (i64.const -11)) (i64.const -1))
+
+;; Test that x/0 works.
+
+(module
+  (func (export "i32.div_s_0") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const 0)))
+  (func (export "i32.div_u_0") (param $x i32) (result i32)
+    (i32.div_u (local.get $x) (i32.const 0)))
+
+  (func (export "i64.div_s_0") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const 0)))
+  (func (export "i64.div_u_0") (param $x i64) (result i64)
+    (i64.div_u (local.get $x) (i64.const 0)))
+)
+
+(assert_trap (invoke "i32.div_s_0" (i32.const 71)) "integer divide by zero")
+(assert_trap (invoke "i32.div_u_0" (i32.const 71)) "integer divide by zero")
+(assert_trap (invoke "i64.div_s_0" (i64.const 71)) "integer divide by zero")
+(assert_trap (invoke "i64.div_u_0" (i64.const 71)) "integer divide by zero")
+
+;; Test that x/3 works.
+
+(module
+  (func (export "i32.div_s_3") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const 3)))
+  (func (export "i32.div_u_3") (param $x i32) (result i32)
+    (i32.div_u (local.get $x) (i32.const 3)))
+
+  (func (export "i64.div_s_3") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const 3)))
+  (func (export "i64.div_u_3") (param $x i64) (result i64)
+    (i64.div_u (local.get $x) (i64.const 3)))
+)
+
+(assert_return (invoke "i32.div_s_3" (i32.const 71)) (i32.const 23))
+(assert_return (invoke "i32.div_s_3" (i32.const 0x60000000)) (i32.const 0x20000000))
+(assert_return (invoke "i32.div_u_3" (i32.const 71)) (i32.const 23))
+(assert_return (invoke "i32.div_u_3" (i32.const 0xc0000000)) (i32.const 0x40000000))
+(assert_return (invoke "i64.div_s_3" (i64.const 71)) (i64.const 23))
+(assert_return (invoke "i64.div_s_3" (i64.const 0x3000000000000000)) (i64.const 0x1000000000000000))
+(assert_return (invoke "i64.div_u_3" (i64.const 71)) (i64.const 23))
+(assert_return (invoke "i64.div_u_3" (i64.const 0xc000000000000000)) (i64.const 0x4000000000000000))
+
+;; Test that x/5 works.
+
+(module
+  (func (export "i32.div_s_5") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const 5)))
+  (func (export "i32.div_u_5") (param $x i32) (result i32)
+    (i32.div_u (local.get $x) (i32.const 5)))
+
+  (func (export "i64.div_s_5") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const 5)))
+  (func (export "i64.div_u_5") (param $x i64) (result i64)
+    (i64.div_u (local.get $x) (i64.const 5)))
+)
+
+(assert_return (invoke "i32.div_s_5" (i32.const 71)) (i32.const 14))
+(assert_return (invoke "i32.div_s_5" (i32.const 0x50000000)) (i32.const 0x10000000))
+(assert_return (invoke "i32.div_u_5" (i32.const 71)) (i32.const 14))
+(assert_return (invoke "i32.div_u_5" (i32.const 0xa0000000)) (i32.const 0x20000000))
+(assert_return (invoke "i64.div_s_5" (i64.const 71)) (i64.const 14))
+(assert_return (invoke "i64.div_s_5" (i64.const 0x5000000000000000)) (i64.const 0x1000000000000000))
+(assert_return (invoke "i64.div_u_5" (i64.const 71)) (i64.const 14))
+(assert_return (invoke "i64.div_u_5" (i64.const 0xa000000000000000)) (i64.const 0x2000000000000000))
+
+;; Test that x/7 works.
+
+(module
+  (func (export "i32.div_s_7") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const 7)))
+  (func (export "i32.div_u_7") (param $x i32) (result i32)
+    (i32.div_u (local.get $x) (i32.const 7)))
+
+  (func (export "i64.div_s_7") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const 7)))
+  (func (export "i64.div_u_7") (param $x i64) (result i64)
+    (i64.div_u (local.get $x) (i64.const 7)))
+)
+
+(assert_return (invoke "i32.div_s_7" (i32.const 71)) (i32.const 10))
+(assert_return (invoke "i32.div_s_7" (i32.const 0x70000000)) (i32.const 0x10000000))
+(assert_return (invoke "i32.div_u_7" (i32.const 71)) (i32.const 10))
+(assert_return (invoke "i32.div_u_7" (i32.const 0xe0000000)) (i32.const 0x20000000))
+(assert_return (invoke "i64.div_s_7" (i64.const 71)) (i64.const 10))
+(assert_return (invoke "i64.div_s_7" (i64.const 0x7000000000000000)) (i64.const 0x1000000000000000))
+(assert_return (invoke "i64.div_u_7" (i64.const 71)) (i64.const 10))
+(assert_return (invoke "i64.div_u_7" (i64.const 0xe000000000000000)) (i64.const 0x2000000000000000))
+
+;; Test that x%3 works.
+
+(module
+  (func (export "i32.rem_s_3") (param $x i32) (result i32)
+    (i32.rem_s (local.get $x) (i32.const 3)))
+  (func (export "i32.rem_u_3") (param $x i32) (result i32)
+    (i32.rem_u (local.get $x) (i32.const 3)))
+
+  (func (export "i64.rem_s_3") (param $x i64) (result i64)
+    (i64.rem_s (local.get $x) (i64.const 3)))
+  (func (export "i64.rem_u_3") (param $x i64) (result i64)
+    (i64.rem_u (local.get $x) (i64.const 3)))
+)
+
+(assert_return (invoke "i32.rem_s_3" (i32.const 71)) (i32.const 2))
+(assert_return (invoke "i32.rem_s_3" (i32.const 0x60000000)) (i32.const 0))
+(assert_return (invoke "i32.rem_u_3" (i32.const 71)) (i32.const 2))
+(assert_return (invoke "i32.rem_u_3" (i32.const 0xc0000000)) (i32.const 0))
+(assert_return (invoke "i64.rem_s_3" (i64.const 71)) (i64.const 2))
+(assert_return (invoke "i64.rem_s_3" (i64.const 0x3000000000000000)) (i64.const 0))
+(assert_return (invoke "i64.rem_u_3" (i64.const 71)) (i64.const 2))
+(assert_return (invoke "i64.rem_u_3" (i64.const 0xc000000000000000)) (i64.const 0))
+
+;; Test that x%5 works.
+
+(module
+  (func (export "i32.rem_s_5") (param $x i32) (result i32)
+    (i32.rem_s (local.get $x) (i32.const 5)))
+  (func (export "i32.rem_u_5") (param $x i32) (result i32)
+    (i32.rem_u (local.get $x) (i32.const 5)))
+
+  (func (export "i64.rem_s_5") (param $x i64) (result i64)
+    (i64.rem_s (local.get $x) (i64.const 5)))
+  (func (export "i64.rem_u_5") (param $x i64) (result i64)
+    (i64.rem_u (local.get $x) (i64.const 5)))
+)
+
+(assert_return (invoke "i32.rem_s_5" (i32.const 71)) (i32.const 1))
+(assert_return (invoke "i32.rem_s_5" (i32.const 0x50000000)) (i32.const 0))
+(assert_return (invoke "i32.rem_u_5" (i32.const 71)) (i32.const 1))
+(assert_return (invoke "i32.rem_u_5" (i32.const 0xa0000000)) (i32.const 0))
+(assert_return (invoke "i64.rem_s_5" (i64.const 71)) (i64.const 1))
+(assert_return (invoke "i64.rem_s_5" (i64.const 0x5000000000000000)) (i64.const 0))
+(assert_return (invoke "i64.rem_u_5" (i64.const 71)) (i64.const 1))
+(assert_return (invoke "i64.rem_u_5" (i64.const 0xa000000000000000)) (i64.const 0))
+
+;; Test that x%7 works.
+
+(module
+  (func (export "i32.rem_s_7") (param $x i32) (result i32)
+    (i32.rem_s (local.get $x) (i32.const 7)))
+  (func (export "i32.rem_u_7") (param $x i32) (result i32)
+    (i32.rem_u (local.get $x) (i32.const 7)))
+
+  (func (export "i64.rem_s_7") (param $x i64) (result i64)
+    (i64.rem_s (local.get $x) (i64.const 7)))
+  (func (export "i64.rem_u_7") (param $x i64) (result i64)
+    (i64.rem_u (local.get $x) (i64.const 7)))
+)
+
+(assert_return (invoke "i32.rem_s_7" (i32.const 71)) (i32.const 1))
+(assert_return (invoke "i32.rem_s_7" (i32.const 0x70000000)) (i32.const 0))
+(assert_return (invoke "i32.rem_u_7" (i32.const 71)) (i32.const 1))
+(assert_return (invoke "i32.rem_u_7" (i32.const 0xe0000000)) (i32.const 0))
+(assert_return (invoke "i64.rem_s_7" (i64.const 71)) (i64.const 1))
+(assert_return (invoke "i64.rem_s_7" (i64.const 0x7000000000000000)) (i64.const 0))
+(assert_return (invoke "i64.rem_u_7" (i64.const 71)) (i64.const 1))
+(assert_return (invoke "i64.rem_u_7" (i64.const 0xe000000000000000)) (i64.const 0))
+
+;; Test that x/-1 is not folded to -x.
+
+(module
+  (func (export "i32.no_fold_div_neg1") (param $x i32) (result i32)
+    (i32.div_s (local.get $x) (i32.const -1)))
+
+  (func (export "i64.no_fold_div_neg1") (param $x i64) (result i64)
+    (i64.div_s (local.get $x) (i64.const -1)))
+)
+
+(assert_trap (invoke "i32.no_fold_div_neg1" (i32.const 0x80000000)) "integer overflow")
+(assert_trap (invoke "i64.no_fold_div_neg1" (i64.const 0x8000000000000000)) "integer overflow")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_literals.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_literals.wast
new file mode 100644
index 0000000..73b37cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/int_literals.wast
@@ -0,0 +1,151 @@
+(module
+  (func (export "i32.test") (result i32) (return (i32.const 0x0bAdD00D)))
+  (func (export "i32.umax") (result i32) (return (i32.const 0xffffffff)))
+  (func (export "i32.smax") (result i32) (return (i32.const 0x7fffffff)))
+  (func (export "i32.neg_smax") (result i32) (return (i32.const -0x7fffffff)))
+  (func (export "i32.smin") (result i32) (return (i32.const -0x80000000)))
+  (func (export "i32.alt_smin") (result i32) (return (i32.const 0x80000000)))
+  (func (export "i32.inc_smin") (result i32) (return (i32.add (i32.const -0x80000000) (i32.const 1))))
+  (func (export "i32.neg_zero") (result i32) (return (i32.const -0x0)))
+  (func (export "i32.not_octal") (result i32) (return (i32.const 010)))
+  (func (export "i32.unsigned_decimal") (result i32) (return (i32.const 4294967295)))
+  (func (export "i32.plus_sign") (result i32) (return (i32.const +42)))
+
+  (func (export "i64.test") (result i64) (return (i64.const 0x0CABBA6E0ba66a6e)))
+  (func (export "i64.umax") (result i64) (return (i64.const 0xffffffffffffffff)))
+  (func (export "i64.smax") (result i64) (return (i64.const 0x7fffffffffffffff)))
+  (func (export "i64.neg_smax") (result i64) (return (i64.const -0x7fffffffffffffff)))
+  (func (export "i64.smin") (result i64) (return (i64.const -0x8000000000000000)))
+  (func (export "i64.alt_smin") (result i64) (return (i64.const 0x8000000000000000)))
+  (func (export "i64.inc_smin") (result i64) (return (i64.add (i64.const -0x8000000000000000) (i64.const 1))))
+  (func (export "i64.neg_zero") (result i64) (return (i64.const -0x0)))
+  (func (export "i64.not_octal") (result i64) (return (i64.const 010)))
+  (func (export "i64.unsigned_decimal") (result i64) (return (i64.const 18446744073709551615)))
+  (func (export "i64.plus_sign") (result i64) (return (i64.const +42)))
+
+  (func (export "i32-dec-sep1") (result i32) (i32.const 1_000_000))
+  (func (export "i32-dec-sep2") (result i32) (i32.const 1_0_0_0))
+  (func (export "i32-hex-sep1") (result i32) (i32.const 0xa_0f_00_99))
+  (func (export "i32-hex-sep2") (result i32) (i32.const 0x1_a_A_0_f))
+
+  (func (export "i64-dec-sep1") (result i64) (i64.const 1_000_000))
+  (func (export "i64-dec-sep2") (result i64) (i64.const 1_0_0_0))
+  (func (export "i64-hex-sep1") (result i64) (i64.const 0xa_f00f_0000_9999))
+  (func (export "i64-hex-sep2") (result i64) (i64.const 0x1_a_A_0_f))
+)
+
+(assert_return (invoke "i32.test") (i32.const 195940365))
+(assert_return (invoke "i32.umax") (i32.const -1))
+(assert_return (invoke "i32.smax") (i32.const 2147483647))
+(assert_return (invoke "i32.neg_smax") (i32.const -2147483647))
+(assert_return (invoke "i32.smin") (i32.const -2147483648))
+(assert_return (invoke "i32.alt_smin") (i32.const -2147483648))
+(assert_return (invoke "i32.inc_smin") (i32.const -2147483647))
+(assert_return (invoke "i32.neg_zero") (i32.const 0))
+(assert_return (invoke "i32.not_octal") (i32.const 10))
+(assert_return (invoke "i32.unsigned_decimal") (i32.const -1))
+(assert_return (invoke "i32.plus_sign") (i32.const 42))
+
+(assert_return (invoke "i64.test") (i64.const 913028331277281902))
+(assert_return (invoke "i64.umax") (i64.const -1))
+(assert_return (invoke "i64.smax") (i64.const 9223372036854775807))
+(assert_return (invoke "i64.neg_smax") (i64.const -9223372036854775807))
+(assert_return (invoke "i64.smin") (i64.const -9223372036854775808))
+(assert_return (invoke "i64.alt_smin") (i64.const -9223372036854775808))
+(assert_return (invoke "i64.inc_smin") (i64.const -9223372036854775807))
+(assert_return (invoke "i64.neg_zero") (i64.const 0))
+(assert_return (invoke "i64.not_octal") (i64.const 10))
+(assert_return (invoke "i64.unsigned_decimal") (i64.const -1))
+(assert_return (invoke "i64.plus_sign") (i64.const 42))
+
+(assert_return (invoke "i32-dec-sep1") (i32.const 1000000))
+(assert_return (invoke "i32-dec-sep2") (i32.const 1000))
+(assert_return (invoke "i32-hex-sep1") (i32.const 0xa0f0099))
+(assert_return (invoke "i32-hex-sep2") (i32.const 0x1aa0f))
+
+(assert_return (invoke "i64-dec-sep1") (i64.const 1000000))
+(assert_return (invoke "i64-dec-sep2") (i64.const 1000))
+(assert_return (invoke "i64-hex-sep1") (i64.const 0xaf00f00009999))
+(assert_return (invoke "i64-hex-sep2") (i64.const 0x1aa0f))
+
+(assert_malformed
+  (module quote "(global i32 (i32.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0xff__ffff))")
+  "unknown operator"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/labels.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/labels.wast
new file mode 100644
index 0000000..6fbf629
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/labels.wast
@@ -0,0 +1,328 @@
+(module
+  (func (export "block") (result i32)
+    (block $exit (result i32)
+      (br $exit (i32.const 1))
+      (i32.const 0)
+    )
+  )
+
+  (func (export "loop1") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block $exit (result i32)
+      (loop $cont (result i32)
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
+          (then (br $exit (local.get $i)))
+        )
+        (br $cont)
+      )
+    )
+  )
+
+  (func (export "loop2") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block $exit (result i32)
+      (loop $cont (result i32)
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
+          (then (br $cont))
+        )
+        (if (i32.eq (local.get $i) (i32.const 8))
+          (then (br $exit (local.get $i)))
+        )
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (br $cont)
+      )
+    )
+  )
+
+  (func (export "loop3") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block $exit (result i32)
+      (loop $cont (result i32)
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
+          (then (br $exit (local.get $i)))
+        )
+        (local.get $i)
+      )
+    )
+  )
+
+  (func (export "loop4") (param $max i32) (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 1))
+    (block $exit (result i32)
+      (loop $cont (result i32)
+        (local.set $i (i32.add (local.get $i) (local.get $i)))
+        (if (i32.gt_u (local.get $i) (local.get $max))
+          (then (br $exit (local.get $i)))
+        )
+        (br $cont)
+      )
+    )
+  )
+
+  (func (export "loop5") (result i32)
+    (i32.add
+      (loop $l (result i32) (i32.const 1))
+      (i32.const 1)
+    )
+  )
+
+  (func (export "loop6") (result i32)
+    (loop (result i32)
+      (br_if 0 (i32.const 0))
+      (i32.const 3)
+    )
+  )
+
+  (func (export "if") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block
+      (if $l
+        (i32.const 1)
+        (then (br $l) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if $l
+        (i32.const 1)
+        (then (br $l) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if $l
+        (i32.const 1)
+        (then (br $l) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if $l
+        (i32.const 0)
+        (then (local.set $i (i32.const 888)))
+        (else (br $l) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if $l
+        (i32.const 0)
+        (then (local.set $i (i32.const 888)))
+        (else (br $l) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+    )
+    (local.get $i)
+  )
+
+  (func (export "if2") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if
+        (i32.const 1)
+        (then (br 0) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if
+        (i32.const 0)
+        (then (local.set $i (i32.const 888)))
+        (else (br 0) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+      (if
+        (i32.const 0)
+        (then (local.set $i (i32.const 888)))
+        (else (br 0) (local.set $i (i32.const 666)))
+      )
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
+    )
+    (local.get $i)
+  )
+
+  (func (export "switch") (param i32) (result i32)
+    (block $ret (result i32)
+      (i32.mul (i32.const 10)
+        (block $exit (result i32)
+          (block $0
+            (block $default
+              (block $3
+                (block $2
+                  (block $1
+                    (br_table $0 $1 $2 $3 $default (local.get 0))
+                  ) ;; 1
+                ) ;; 2
+                (br $exit (i32.const 2))
+              ) ;; 3
+              (br $ret (i32.const 3))
+            ) ;; default
+          ) ;; 0
+          (i32.const 5)
+        )
+      )
+    )
+  )
+
+  (func (export "return") (param i32) (result i32)
+    (block $default
+      (block $1
+        (block $0
+          (br_table $0 $1 (local.get 0))
+          (br $default)
+        ) ;; 0
+        (return (i32.const 0))
+      ) ;; 1
+    ) ;; default
+    (i32.const 2)
+  )
+
+  (func (export "br_if0") (result i32)
+    (local $i i32)
+    (local.set $i (i32.const 0))
+    (block $outer (result i32)
+      (block $inner
+        (br_if $inner (i32.const 0))
+        (local.set $i (i32.or (local.get $i) (i32.const 0x1)))
+        (br_if $inner (i32.const 1))
+        (local.set $i (i32.or (local.get $i) (i32.const 0x2)))
+      )
+      (drop (br_if $outer
+        (block (result i32)
+          (local.set $i (i32.or (local.get $i) (i32.const 0x4)))
+          (local.get $i)
+        )
+        (i32.const 0)
+      ))
+      (local.set $i (i32.or (local.get $i) (i32.const 0x8)))
+      (drop (br_if $outer
+        (block (result i32)
+          (local.set $i (i32.or (local.get $i) (i32.const 0x10)))
+          (local.get $i)
+        )
+        (i32.const 1)
+      ))
+      (local.set $i (i32.or (local.get $i) (i32.const 0x20))) (local.get $i)
+    )
+  )
+
+  (func (export "br_if1") (result i32)
+    (block $l0 (result i32)
+      (drop
+        (br_if $l0
+          (block $l1 (result i32) (br $l1 (i32.const 1)))
+          (i32.const 1)
+        )
+      )
+      (i32.const 0)
+    )
+  )
+
+  (func (export "br_if2") (result i32)
+    (block $l0 (result i32)
+      (if (i32.const 1)
+        (then
+          (drop
+            (br_if $l0
+              (block $l1 (result i32) (br $l1 (i32.const 1)))
+              (i32.const 1)
+            )
+          )
+        )
+      )
+      (i32.const 0)
+    )
+  )
+
+  (func (export "br_if3") (result i32)
+    (local $i1 i32)
+    (drop
+      (i32.add
+        (block $l0 (result i32)
+          (drop (br_if $l0
+            (block (result i32) (local.set $i1 (i32.const 1)) (local.get $i1))
+            (block (result i32) (local.set $i1 (i32.const 2)) (local.get $i1))
+          ))
+          (i32.const 0)
+        )
+        (i32.const 0)
+      )
+    )
+    (local.get $i1)
+  )
+
+  (func (export "br") (result i32)
+    (block $l0 (result i32)
+      (if (i32.const 1)
+        (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1)))))
+        (else (block (drop (block $l1 (result i32) (br $l1 (i32.const 1))))))
+      )
+      (i32.const 1)
+    )
+  )
+
+  (func (export "shadowing") (result i32)
+    (block $l1 (result i32) (i32.xor (br $l1 (i32.const 1)) (i32.const 2)))
+  )
+
+  (func (export "redefinition") (result i32)
+    (block $l1 (result i32)
+      (i32.add
+        (block $l1 (result i32) (i32.const 2))
+        (block $l1 (result i32) (br $l1 (i32.const 3)))
+      )
+    )
+  )
+)
+
+(assert_return (invoke "block") (i32.const 1))
+(assert_return (invoke "loop1") (i32.const 5))
+(assert_return (invoke "loop2") (i32.const 8))
+(assert_return (invoke "loop3") (i32.const 1))
+(assert_return (invoke "loop4" (i32.const 8)) (i32.const 16))
+(assert_return (invoke "loop5") (i32.const 2))
+(assert_return (invoke "loop6") (i32.const 3))
+(assert_return (invoke "if") (i32.const 5))
+(assert_return (invoke "if2") (i32.const 5))
+(assert_return (invoke "switch" (i32.const 0)) (i32.const 50))
+(assert_return (invoke "switch" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "switch" (i32.const 2)) (i32.const 20))
+(assert_return (invoke "switch" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "switch" (i32.const 4)) (i32.const 50))
+(assert_return (invoke "switch" (i32.const 5)) (i32.const 50))
+(assert_return (invoke "return" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "return" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "return" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "br_if0") (i32.const 0x1d))
+(assert_return (invoke "br_if1") (i32.const 1))
+(assert_return (invoke "br_if2") (i32.const 1))
+(assert_return (invoke "br_if3") (i32.const 2))
+(assert_return (invoke "br") (i32.const 1))
+(assert_return (invoke "shadowing") (i32.const 1))
+(assert_return (invoke "redefinition") (i32.const 5))
+
+(assert_invalid
+  (module (func (block $l (f32.neg (br_if $l (i32.const 1))) (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (block $l (br_if $l (f32.const 0) (i32.const 1)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (block $l (br_if $l (f32.const 0) (i32.const 1)))))
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/left-to-right.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/left-to-right.wast
new file mode 100644
index 0000000..634aa9c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/left-to-right.wast
@@ -0,0 +1,233 @@
+(module
+  (memory 1)
+
+  (type $i32_T (func (param i32 i32) (result i32)))
+  (type $i64_T (func (param i64 i64) (result i32)))
+  (type $f32_T (func (param f32 f32) (result i32)))
+  (type $f64_T (func (param f64 f64) (result i32)))
+  (table funcref
+    (elem $i32_t0 $i32_t1 $i64_t0 $i64_t1 $f32_t0 $f32_t1 $f64_t0 $f64_t1)
+  )
+
+  (func $i32_t0 (type $i32_T) (i32.const -1))
+  (func $i32_t1 (type $i32_T) (i32.const -2))
+  (func $i64_t0 (type $i64_T) (i32.const -1))
+  (func $i64_t1 (type $i64_T) (i32.const -2))
+  (func $f32_t0 (type $f32_T) (i32.const -1))
+  (func $f32_t1 (type $f32_T) (i32.const -2))
+  (func $f64_t0 (type $f64_T) (i32.const -1))
+  (func $f64_t1 (type $f64_T) (i32.const -2))
+
+  ;; The idea is: We reset the memory, then the instruction call $*_left,
+  ;; $*_right, $*_another, $*_callee (for indirect calls), and $*_bool (when a
+  ;; boolean value is needed). These functions all call bump, which shifts the
+  ;; memory starting at address 8 up a byte, and then store a unique value at
+  ;; address 8. Then we read the 4-byte value at address 8. It should contain
+  ;; the correct sequence of unique values if the calls were evaluated in the
+  ;; correct order.
+
+  (func $reset (i32.store (i32.const 8) (i32.const 0)))
+
+  (func $bump
+    (i32.store8 (i32.const 11) (i32.load8_u (i32.const 10)))
+    (i32.store8 (i32.const 10) (i32.load8_u (i32.const 9)))
+    (i32.store8 (i32.const 9) (i32.load8_u (i32.const 8)))
+    (i32.store8 (i32.const 8) (i32.const -3)))
+
+  (func $get (result i32) (i32.load (i32.const 8)))
+
+  (func $i32_left (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (i32.const 0))
+  (func $i32_right (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (i32.const 1))
+  (func $i32_another (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (i32.const 1))
+  (func $i32_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 0))
+  (func $i32_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $i64_left (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (i64.const 0))
+  (func $i64_right (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (i64.const 1))
+  (func $i64_another (result i64) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (i64.const 1))
+  (func $i64_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 2))
+  (func $i64_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $f32_left (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (f32.const 0))
+  (func $f32_right (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (f32.const 1))
+  (func $f32_another (result f32) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (f32.const 1))
+  (func $f32_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 4))
+  (func $f32_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $f64_left (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 1)) (f64.const 0))
+  (func $f64_right (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 2)) (f64.const 1))
+  (func $f64_another (result f64) (call $bump) (i32.store8 (i32.const 8) (i32.const 3)) (f64.const 1))
+  (func $f64_callee (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 4)) (i32.const 6))
+  (func $f64_bool (result i32) (call $bump) (i32.store8 (i32.const 8) (i32.const 5)) (i32.const 0))
+  (func $i32_dummy (param i32 i32))
+  (func $i64_dummy (param i64 i64))
+  (func $f32_dummy (param f32 f32))
+  (func $f64_dummy (param f64 f64))
+
+  (func (export "i32_add") (result i32) (call $reset) (drop (i32.add (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_sub") (result i32) (call $reset) (drop (i32.sub (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_mul") (result i32) (call $reset) (drop (i32.mul (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_div_s") (result i32) (call $reset) (drop (i32.div_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_div_u") (result i32) (call $reset) (drop (i32.div_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_rem_s") (result i32) (call $reset) (drop (i32.rem_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_rem_u") (result i32) (call $reset) (drop (i32.rem_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_and") (result i32) (call $reset) (drop (i32.and (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_or") (result i32) (call $reset) (drop (i32.or (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_xor") (result i32) (call $reset) (drop (i32.xor (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_shl") (result i32) (call $reset) (drop (i32.shl (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_shr_u") (result i32) (call $reset) (drop (i32.shr_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_shr_s") (result i32) (call $reset) (drop (i32.shr_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_eq") (result i32) (call $reset) (drop (i32.eq (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_ne") (result i32) (call $reset) (drop (i32.ne (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_lt_s") (result i32) (call $reset) (drop (i32.lt_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_le_s") (result i32) (call $reset) (drop (i32.le_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_lt_u") (result i32) (call $reset) (drop (i32.lt_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_le_u") (result i32) (call $reset) (drop (i32.le_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_gt_s") (result i32) (call $reset) (drop (i32.gt_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_ge_s") (result i32) (call $reset) (drop (i32.ge_s (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_gt_u") (result i32) (call $reset) (drop (i32.gt_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_ge_u") (result i32) (call $reset) (drop (i32.ge_u (call $i32_left) (call $i32_right))) (call $get))
+  (func (export "i32_store") (result i32) (call $reset) (i32.store (call $i32_left) (call $i32_right)) (call $get))
+  (func (export "i32_store8") (result i32) (call $reset) (i32.store8 (call $i32_left) (call $i32_right)) (call $get))
+  (func (export "i32_store16") (result i32) (call $reset) (i32.store16 (call $i32_left) (call $i32_right)) (call $get))
+  (func (export "i32_call") (result i32) (call $reset) (call $i32_dummy (call $i32_left) (call $i32_right)) (call $get))
+  (func (export "i32_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $i32_T) (call $i32_left) (call $i32_right) (call $i32_callee))) (call $get))
+  (func (export "i32_select") (result i32) (call $reset) (drop (select (call $i32_left) (call $i32_right) (call $i32_bool))) (call $get))
+
+  (func (export "i64_add") (result i32) (call $reset) (drop (i64.add (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_sub") (result i32) (call $reset) (drop (i64.sub (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_mul") (result i32) (call $reset) (drop (i64.mul (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_div_s") (result i32) (call $reset) (drop (i64.div_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_div_u") (result i32) (call $reset) (drop (i64.div_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_rem_s") (result i32) (call $reset) (drop (i64.rem_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_rem_u") (result i32) (call $reset) (drop (i64.rem_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_and") (result i32) (call $reset) (drop (i64.and (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_or") (result i32) (call $reset) (drop (i64.or (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_xor") (result i32) (call $reset) (drop (i64.xor (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_shl") (result i32) (call $reset) (drop (i64.shl (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_shr_u") (result i32) (call $reset) (drop (i64.shr_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_shr_s") (result i32) (call $reset) (drop (i64.shr_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_eq") (result i32) (call $reset) (drop (i64.eq (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_ne") (result i32) (call $reset) (drop (i64.ne (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_lt_s") (result i32) (call $reset) (drop (i64.lt_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_le_s") (result i32) (call $reset) (drop (i64.le_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_lt_u") (result i32) (call $reset) (drop (i64.lt_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_le_u") (result i32) (call $reset) (drop (i64.le_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_gt_s") (result i32) (call $reset) (drop (i64.gt_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_ge_s") (result i32) (call $reset) (drop (i64.ge_s (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_gt_u") (result i32) (call $reset) (drop (i64.gt_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_ge_u") (result i32) (call $reset) (drop (i64.ge_u (call $i64_left) (call $i64_right))) (call $get))
+  (func (export "i64_store") (result i32) (call $reset) (i64.store (call $i32_left) (call $i64_right)) (call $get))
+  (func (export "i64_store8") (result i32) (call $reset) (i64.store8 (call $i32_left) (call $i64_right)) (call $get))
+  (func (export "i64_store16") (result i32) (call $reset) (i64.store16 (call $i32_left) (call $i64_right)) (call $get))
+  (func (export "i64_store32") (result i32) (call $reset) (i64.store32 (call $i32_left) (call $i64_right)) (call $get))
+  (func (export "i64_call") (result i32) (call $reset) (call $i64_dummy (call $i64_left) (call $i64_right)) (call $get))
+  (func (export "i64_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $i64_T) (call $i64_left) (call $i64_right) (call $i64_callee))) (call $get))
+  (func (export "i64_select") (result i32) (call $reset) (drop (select (call $i64_left) (call $i64_right) (call $i64_bool))) (call $get))
+
+  (func (export "f32_add") (result i32) (call $reset) (drop (f32.add (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_sub") (result i32) (call $reset) (drop (f32.sub (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_mul") (result i32) (call $reset) (drop (f32.mul (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_div") (result i32) (call $reset) (drop (f32.div (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_copysign") (result i32) (call $reset) (drop (f32.copysign (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_eq") (result i32) (call $reset) (drop (f32.eq (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_ne") (result i32) (call $reset) (drop (f32.ne (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_lt") (result i32) (call $reset) (drop (f32.lt (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_le") (result i32) (call $reset) (drop (f32.le (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_gt") (result i32) (call $reset) (drop (f32.gt (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_ge") (result i32) (call $reset) (drop (f32.ge (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_min") (result i32) (call $reset) (drop (f32.min (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_max") (result i32) (call $reset) (drop (f32.max (call $f32_left) (call $f32_right))) (call $get))
+  (func (export "f32_store") (result i32) (call $reset) (f32.store (call $i32_left) (call $f32_right)) (call $get))
+  (func (export "f32_call") (result i32) (call $reset) (call $f32_dummy (call $f32_left) (call $f32_right)) (call $get))
+  (func (export "f32_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $f32_T) (call $f32_left) (call $f32_right) (call $f32_callee))) (call $get))
+  (func (export "f32_select") (result i32) (call $reset) (drop (select (call $f32_left) (call $f32_right) (call $f32_bool))) (call $get))
+
+  (func (export "f64_add") (result i32) (call $reset) (drop (f64.add (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_sub") (result i32) (call $reset) (drop (f64.sub (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_mul") (result i32) (call $reset) (drop (f64.mul (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_div") (result i32) (call $reset) (drop (f64.div (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_copysign") (result i32) (call $reset) (drop (f64.copysign (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_eq") (result i32) (call $reset) (drop (f64.eq (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_ne") (result i32) (call $reset) (drop (f64.ne (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_lt") (result i32) (call $reset) (drop (f64.lt (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_le") (result i32) (call $reset) (drop (f64.le (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_gt") (result i32) (call $reset) (drop (f64.gt (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_ge") (result i32) (call $reset) (drop (f64.ge (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_min") (result i32) (call $reset) (drop (f64.min (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_max") (result i32) (call $reset) (drop (f64.max (call $f64_left) (call $f64_right))) (call $get))
+  (func (export "f64_store") (result i32) (call $reset) (f64.store (call $i32_left) (call $f64_right)) (call $get))
+  (func (export "f64_call") (result i32) (call $reset) (call $f64_dummy (call $f64_left) (call $f64_right)) (call $get))
+  (func (export "f64_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $f64_T) (call $f64_left) (call $f64_right) (call $f64_callee))) (call $get))
+  (func (export "f64_select") (result i32) (call $reset) (drop (select (call $f64_left) (call $f64_right) (call $f64_bool))) (call $get))
+
+  (func (export "br_if") (result i32)
+    (block (result i32)
+      (call $reset)
+      (drop (br_if 0 (call $i32_left) (i32.and (call $i32_right) (i32.const 0))))
+      (call $get)
+    )
+  )
+  (func (export "br_table") (result i32)
+    (block $a (result i32)
+      (call $reset)
+      (drop
+        (block $b (result i32)
+          (br_table $a $b (call $i32_left) (call $i32_right))
+        )
+      )
+      (call $get)
+    )
+  )
+)
+
+(assert_return (invoke "i32_add") (i32.const 0x0102))     (assert_return (invoke "i64_add") (i32.const 0x0102))
+(assert_return (invoke "i32_sub") (i32.const 0x0102))     (assert_return (invoke "i64_sub") (i32.const 0x0102))
+(assert_return (invoke "i32_mul") (i32.const 0x0102))     (assert_return (invoke "i64_mul") (i32.const 0x0102))
+(assert_return (invoke "i32_div_s") (i32.const 0x0102))   (assert_return (invoke "i64_div_s") (i32.const 0x0102))
+(assert_return (invoke "i32_div_u") (i32.const 0x0102))   (assert_return (invoke "i64_div_u") (i32.const 0x0102))
+(assert_return (invoke "i32_rem_s") (i32.const 0x0102))   (assert_return (invoke "i64_rem_s") (i32.const 0x0102))
+(assert_return (invoke "i32_rem_u") (i32.const 0x0102))   (assert_return (invoke "i64_rem_u") (i32.const 0x0102))
+(assert_return (invoke "i32_and") (i32.const 0x0102))     (assert_return (invoke "i64_and") (i32.const 0x0102))
+(assert_return (invoke "i32_or") (i32.const 0x0102))      (assert_return (invoke "i64_or") (i32.const 0x0102))
+(assert_return (invoke "i32_xor") (i32.const 0x0102))     (assert_return (invoke "i64_xor") (i32.const 0x0102))
+(assert_return (invoke "i32_shl") (i32.const 0x0102))     (assert_return (invoke "i64_shl") (i32.const 0x0102))
+(assert_return (invoke "i32_shr_u") (i32.const 0x0102))   (assert_return (invoke "i64_shr_u") (i32.const 0x0102))
+(assert_return (invoke "i32_shr_s") (i32.const 0x0102))   (assert_return (invoke "i64_shr_s") (i32.const 0x0102))
+(assert_return (invoke "i32_eq") (i32.const 0x0102))      (assert_return (invoke "i64_eq") (i32.const 0x0102))
+(assert_return (invoke "i32_ne") (i32.const 0x0102))      (assert_return (invoke "i64_ne") (i32.const 0x0102))
+(assert_return (invoke "i32_lt_s") (i32.const 0x0102))    (assert_return (invoke "i64_lt_s") (i32.const 0x0102))
+(assert_return (invoke "i32_le_s") (i32.const 0x0102))    (assert_return (invoke "i64_le_s") (i32.const 0x0102))
+(assert_return (invoke "i32_lt_u") (i32.const 0x0102))    (assert_return (invoke "i64_lt_u") (i32.const 0x0102))
+(assert_return (invoke "i32_le_u") (i32.const 0x0102))    (assert_return (invoke "i64_le_u") (i32.const 0x0102))
+(assert_return (invoke "i32_gt_s") (i32.const 0x0102))    (assert_return (invoke "i64_gt_s") (i32.const 0x0102))
+(assert_return (invoke "i32_ge_s") (i32.const 0x0102))    (assert_return (invoke "i64_ge_s") (i32.const 0x0102))
+(assert_return (invoke "i32_gt_u") (i32.const 0x0102))    (assert_return (invoke "i64_gt_u") (i32.const 0x0102))
+(assert_return (invoke "i32_ge_u") (i32.const 0x0102))    (assert_return (invoke "i64_ge_u") (i32.const 0x0102))
+(assert_return (invoke "i32_store") (i32.const 0x0102))   (assert_return (invoke "i64_store") (i32.const 0x0102))
+(assert_return (invoke "i32_store8") (i32.const 0x0102))  (assert_return (invoke "i64_store8") (i32.const 0x0102))
+(assert_return (invoke "i32_store16") (i32.const 0x0102)) (assert_return (invoke "i64_store16") (i32.const 0x0102))
+(assert_return (invoke "i64_store32") (i32.const 0x0102))
+(assert_return (invoke "i32_call") (i32.const 0x0102))    (assert_return (invoke "i64_call") (i32.const 0x0102))
+(assert_return (invoke "i32_call_indirect") (i32.const 0x010204))
+(assert_return (invoke "i64_call_indirect") (i32.const 0x010204))
+(assert_return (invoke "i32_select") (i32.const 0x010205))  (assert_return (invoke "i64_select") (i32.const 0x010205))
+
+(assert_return (invoke "f32_add") (i32.const 0x0102))     (assert_return (invoke "f64_add") (i32.const 0x0102))
+(assert_return (invoke "f32_sub") (i32.const 0x0102))     (assert_return (invoke "f64_sub") (i32.const 0x0102))
+(assert_return (invoke "f32_mul") (i32.const 0x0102))     (assert_return (invoke "f64_mul") (i32.const 0x0102))
+(assert_return (invoke "f32_div") (i32.const 0x0102))     (assert_return (invoke "f64_div") (i32.const 0x0102))
+(assert_return (invoke "f32_copysign") (i32.const 0x0102))(assert_return (invoke "f64_copysign") (i32.const 0x0102))
+(assert_return (invoke "f32_eq") (i32.const 0x0102))      (assert_return (invoke "f64_eq") (i32.const 0x0102))
+(assert_return (invoke "f32_ne") (i32.const 0x0102))      (assert_return (invoke "f64_ne") (i32.const 0x0102))
+(assert_return (invoke "f32_lt") (i32.const 0x0102))      (assert_return (invoke "f64_lt") (i32.const 0x0102))
+(assert_return (invoke "f32_le") (i32.const 0x0102))      (assert_return (invoke "f64_le") (i32.const 0x0102))
+(assert_return (invoke "f32_gt") (i32.const 0x0102))      (assert_return (invoke "f64_gt") (i32.const 0x0102))
+(assert_return (invoke "f32_ge") (i32.const 0x0102))      (assert_return (invoke "f64_ge") (i32.const 0x0102))
+(assert_return (invoke "f32_min") (i32.const 0x0102))     (assert_return (invoke "f64_min") (i32.const 0x0102))
+(assert_return (invoke "f32_max") (i32.const 0x0102))     (assert_return (invoke "f64_max") (i32.const 0x0102))
+(assert_return (invoke "f32_store") (i32.const 0x0102))   (assert_return (invoke "f64_store") (i32.const 0x0102))
+(assert_return (invoke "f32_call") (i32.const 0x0102))    (assert_return (invoke "f64_call") (i32.const 0x0102))
+(assert_return (invoke "f32_call_indirect") (i32.const 0x010204))
+(assert_return (invoke "f64_call_indirect") (i32.const 0x010204))
+(assert_return (invoke "f32_select") (i32.const 0x010205))  (assert_return (invoke "f64_select") (i32.const 0x010205))
+
+(assert_return (invoke "br_if") (i32.const 0x0102))
+(assert_return (invoke "br_table") (i32.const 0x0102))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/linking.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/linking.wast
new file mode 100644
index 0000000..371913c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/linking.wast
@@ -0,0 +1,456 @@
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (global.get $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (global.get $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+
+(module $Mref_ex
+  (global (export "g-const-func") funcref (ref.null func))
+  (global (export "g-var-func") (mut funcref) (ref.null func))
+  (global (export "g-const-extern") externref (ref.null extern))
+  (global (export "g-var-extern") (mut externref) (ref.null extern))
+)
+(register "Mref_ex" $Mref_ex)
+
+(module $Mref_im
+  (global (import "Mref_ex" "g-const-func") funcref)
+  (global (import "Mref_ex" "g-const-extern") externref)
+
+  (global (import "Mref_ex" "g-var-func") (mut funcref))
+  (global (import "Mref_ex" "g-var-extern") (mut externref))
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-extern") funcref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-func") externref))
+  "incompatible import type"
+)
+
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-func") (mut externref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-extern") (mut funcref)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 funcref)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table funcref (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (local.get 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized element")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined element")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined element")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined element")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call type mismatch")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 funcref)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized element")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined element")
+
+(module
+  (table (import "Mt" "tab") 0 funcref)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (global.get 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 0 funcref)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized element")
+
+;; TODO: This test is temporarily disabled because Wasmer doesn't properly
+;; handle Instance lifetimes when funcrefs are involved.
+
+;; Unlike in the v1 spec, active element segments stored before an
+;; out-of-bounds access persist after the instantiation failure.
+;; (assert_trap
+;;   (module
+;;     (table (import "Mt" "tab") 10 funcref)
+;;     (func $f (result i32) (i32.const 0))
+;;     (elem (i32.const 7) $f)
+;;     (elem (i32.const 8) $f $f $f $f $f)  ;; (partially) out of bounds
+;;   )
+;;   "out of bounds table access"
+;; )
+;; (assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+;; (assert_trap (invoke $Mt "call" (i32.const 8)) "uninitialized element")
+;;
+;; (assert_trap
+;;   (module
+;;     (table (import "Mt" "tab") 10 funcref)
+;;     (func $f (result i32) (i32.const 0))
+;;     (elem (i32.const 7) $f)
+;;     (memory 1)
+;;     (data (i32.const 0x10000) "d")  ;; out of bounds
+;;   )
+;;   "out of bounds memory access"
+;; )
+;; (assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+
+(module $Mtable_ex
+  (table $t1 (export "t-func") 1 funcref)
+  (table $t2 (export "t-extern") 1 externref)
+)
+(register "Mtable_ex" $Mtable_ex)
+
+(module
+  (table (import "Mtable_ex" "t-func") 1 funcref)
+  (table (import "Mtable_ex" "t-extern") 1 externref)
+)
+
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-func") 1 externref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-extern") 1 funcref))
+  "incompatible import type"
+)
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+;; Unlike in v1 spec, active data segments written before an
+;; out-of-bounds access persist after the instantiation failure.
+(assert_trap
+  (module
+    ;; Note: the memory is 5 pages large by the time we get here.
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 327670) "zzzzzzzzzzzzzzzzzz") ;; (partially) out of bounds
+  )
+  "out of bounds memory access"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+(assert_return (invoke $Mm "load" (i32.const 327670)) (i32.const 0))
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 funcref)
+    (func)
+    (elem (i32.const 0) 0)  ;; out of bounds
+  )
+  "out of bounds table access"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+;; Store is modified if the start function traps.
+(module $Ms
+  (type $t (func (result i32)))
+  (memory (export "memory") 1)
+  (table (export "table") 1 funcref)
+  (func (export "get memory[0]") (type $t)
+    (i32.load8_u (i32.const 0))
+  )
+  (func (export "get table[0]") (type $t)
+    (call_indirect (type $t) (i32.const 0))
+  )
+)
+(register "Ms" $Ms)
+
+(assert_trap
+  (module
+    (import "Ms" "memory" (memory 1))
+    (import "Ms" "table" (table 1 funcref))
+    (data (i32.const 0) "hello")
+    (elem (i32.const 0) $f)
+    (func $f (result i32)
+      (i32.const 0xdead)
+    )
+    (func $main
+      (unreachable)
+    )
+    (start $main)
+  )
+  "unreachable"
+)
+
+(assert_return (invoke $Ms "get memory[0]") (i32.const 104))  ;; 'h'
+;; (assert_return (invoke $Ms "get table[0]") (i32.const 0xdead))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/load.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/load.wast
new file mode 100644
index 0000000..ef5ec7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/load.wast
@@ -0,0 +1,567 @@
+;; Load operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.load (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (i32.load (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i32.load (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (i32.load (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (i32.load (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.load (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (i32.load (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (i32.load (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (i32.load (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (i32.load (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (i32.load (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.load (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.load (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (i32.load (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (i32.load (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (i32.load (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (i32.load (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (i32.load8_s (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (i32.load (i32.const 100)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 0))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 0))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 7))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 0))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 0))
+
+(assert_return (invoke "as-if-cond") (i32.const 1))
+(assert_return (invoke "as-if-then") (i32.const 0))
+(assert_return (invoke "as-if-else") (i32.const 0))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-cond") (i32.const 1))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_return (invoke "as-call_indirect-index") (i32.const -1))
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 0))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 32))
+
+(assert_return (invoke "as-binary-left") (i32.const 10))
+(assert_return (invoke "as-binary-right") (i32.const 10))
+
+(assert_return (invoke "as-test-operand") (i32.const 1))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32 (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_u (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_s (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64 (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_u (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_s (local.get 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64 (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_u (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_s (local.get 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load32 (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load64 (local.get 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load32 (local.get 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load64 (local.get 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; load should have retval
+
+(assert_invalid
+  (module (memory 1) (func $load_i32 (i32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i32 (i32.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i32 (i32.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i32 (i32.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i32 (i32.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_i64 (i64.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i64 (i64.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i64 (i64.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i64 (i64.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i64 (i64.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_s_i64 (i64.load32_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_u_i64 (i64.load32_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f32 (f32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f64 (f64.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type check
+
+(assert_invalid (module (memory 1) (func (result i32) (i32.load (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i32) (i32.load8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i32) (i32.load8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i32) (i32.load16_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i32) (i32.load16_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load16_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load16_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load32_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result i64) (i64.load32_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result f32) (f32.load (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (result f64) (f64.load (f32.const 0)))) "type mismatch")
+
+
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty
+      (i32.load) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-block
+      (i32.const 0)
+      (block (i32.load) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-loop
+      (i32.const 0)
+      (loop (i32.load) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.load) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.load))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.load)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.load) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.load)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-return
+      (return (i32.load)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-select
+      (select (i32.load) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-call
+      (call 1 (i32.load)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-address-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.load) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.load)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.load)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (global $x (mut i32) (i32.const 0))
+    (func $type-address-empty-in-global.set
+      (global.set $x (i32.load)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-memory.grow
+      (memory.grow (i32.load)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-address-empty-in-load
+      (i32.load (i32.load)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-store
+      (i32.store (i32.load) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_get.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_get.wast
new file mode 100644
index 0000000..6acab39
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_get.wast
@@ -0,0 +1,226 @@
+;; Test `local.get` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "type-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "type-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "type-local-f64") (result f64) (local f64) (local.get 0))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.get 0))
+  (func (export "type-param-i64") (param i64) (result i64) (local.get 0))
+  (func (export "type-param-f32") (param f32) (result f32) (local.get 0))
+  (func (export "type-param-f64") (param f64) (result f64) (local.get 0))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
+    (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.get 0)))
+    (drop (f32.neg (local.get 1)))
+    (drop (f64.neg (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (i32.eqz (local.get 4)))
+    (drop (f32.neg (local.get 5)))
+    (drop (i64.eqz (local.get 6)))
+    (drop (i64.eqz (local.get 7)))
+    (drop (f64.neg (local.get 8)))
+  )
+
+  ;; Reading
+
+  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (f64.add
+      (f64.convert_i64_u (local.get 0))
+      (f64.add
+        (f64.promote_f32 (local.get 1))
+        (f64.add
+          (local.get 2)
+          (f64.add
+            (f64.convert_i32_u (local.get 3))
+            (f64.add
+              (f64.convert_i32_s (local.get 4))
+              (f64.add
+                (f64.promote_f32 (local.get 5))
+                (f64.add
+                  (f64.convert_i64_u (local.get 6))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 7))
+                    (local.get 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32) (result i32)
+    (block (result i32) (local.get 0))
+  )
+  (func (export "as-loop-value") (param i32) (result i32)
+    (loop (result i32) (local.get 0))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.get 0)))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block $l0 (result i32) (br_if $l0 (local.get 0) (i32.const 1)))
+  )
+
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0 (local.get 0) (local.get 0))
+    )
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (br_table 0 1 2 (local.get 0))
+          (return (i32.const 0))
+        )
+        (return (i32.const 1))
+      )
+      (return (i32.const 2))
+    )
+    (i32.const 3)
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.get 0))
+  )
+
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 0)) (else (i32.const 0)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0) (then (i32.const 1)) (else (local.get 0)))
+  )
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5))
+
+(assert_return (invoke "as-block-value" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-loop-value" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-br-value" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "as-br_if-value" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "as-br_table-value" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 0))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "read"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i32) (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (result f64) (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (result i32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (result f64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; local.set should have retval
+
+(assert_invalid
+  (module (func $type-empty-vs-i32 (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-i64 (local i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f32 (local f32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f64 (local f64) (local.get 0)))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.get 3) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.get 14324343) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.get 2) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (param i32 i64) (local.get 714324343) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.get 3) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343) drop))
+  "unknown local"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_set.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_set.wast
new file mode 100644
index 0000000..ce9cf77
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_set.wast
@@ -0,0 +1,362 @@
+;; Test `local.set` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (local i32) (local.set 0 (i32.const 0)))
+  (func (export "type-local-i64") (local i64) (local.set 0 (i64.const 0)))
+  (func (export "type-local-f32") (local f32) (local.set 0 (f32.const 0)))
+  (func (export "type-local-f64") (local f64) (local.set 0 (f64.const 0)))
+
+  (func (export "type-param-i32") (param i32) (local.set 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (local.set 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (local.set 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (local.set 0 (f64.const 12.2)))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (local.set 0 (i64.const 0))
+    (local.set 1 (f32.const 0))
+    (local.set 2 (f64.const 0))
+    (local.set 3 (i32.const 0))
+    (local.set 4 (i32.const 0))
+    (local.set 5 (f32.const 0))
+    (local.set 6 (i64.const 0))
+    (local.set 7 (i64.const 0))
+    (local.set 8 (f64.const 0))
+  )
+
+  ;; Writing
+
+  (func (export "write") (param i64 f32 f64 i32 i32) (result i64)
+    (local f32 i64 i64 f64)
+    (local.set 1 (f32.const -0.3))
+    (local.set 3 (i32.const 40))
+    (local.set 4 (i32.const -7))
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (i64.trunc_f64_s
+      (f64.add
+        (f64.convert_i64_u (local.get 0))
+        (f64.add
+          (f64.promote_f32 (local.get 1))
+          (f64.add
+            (local.get 2)
+            (f64.add
+              (f64.convert_i32_u (local.get 3))
+              (f64.add
+                (f64.convert_i32_s (local.get 4))
+                (f64.add
+                  (f64.promote_f32 (local.get 5))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 6))
+                    (f64.add
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32)
+    (block (local.set 0 (i32.const 1)))
+  )
+  (func (export "as-loop-value") (param i32)
+    (loop (local.set 0 (i32.const 3)))
+  )
+
+  (func (export "as-br-value") (param i32)
+    (block (br 0 (local.set 0 (i32.const 9))))
+  )
+  (func (export "as-br_if-value") (param i32)
+    (block
+      (br_if 0 (local.set 0 (i32.const 8)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32)
+    (block
+      (br_if 0 (i32.const 6) (local.set 0 (i32.const 9)))
+    )
+  )
+  (func (export "as-br_table-value") (param i32)
+    (block
+      (br_table 0 (local.set 0 (i32.const 10)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value") (param i32)
+    (return (local.set 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-then") (param i32)
+    (if (local.get 0) (then (local.set 0 (i32.const 3))))
+  )
+  (func (export "as-if-else") (param i32)
+    (if (local.get 0) (then) (else (local.set 0 (i32.const 1))))
+  )
+)
+
+(assert_return (invoke "type-local-i32"))
+(assert_return (invoke "type-local-i64"))
+(assert_return (invoke "type-local-f32"))
+(assert_return (invoke "type-local-f64"))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)))
+(assert_return (invoke "type-param-i64" (i64.const 3)))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)))
+
+(assert_return (invoke "as-block-value" (i32.const 0)))
+(assert_return (invoke "as-loop-value" (i32.const 0)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)))
+(assert_return (invoke "as-br_if-value" (i32.const 0)))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)))
+(assert_return (invoke "as-br_table-value" (i32.const 0)))
+
+(assert_return (invoke "as-return-value" (i32.const 0)))
+
+(assert_return (invoke "as-if-then" (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 0)))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "write"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (i64.const 56)
+)
+
+
+;; Invalid typing of access to locals
+
+
+(assert_invalid
+  (module (func $type-local-arg-void-vs-num (local i32) (local.set 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local i32) (local.set 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f32) (local.set 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (local.set 1 (f64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+
+(assert_invalid
+  (module (func $type-param-arg-void-vs-num (param i32) (local.set 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param i32) (local.set 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f32) (local.set 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (local.set 1 (f64.const 0))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num (param i32)
+      (local.set 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-block (param i32)
+      (i32.const 0)
+      (block (local.set 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-loop (param i32)
+      (i32.const 0)
+      (loop (local.set 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-then (param i32)
+      (i32.const 0)
+      (if (i32.const 1) (then (local.set 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-else (param i32)
+      (i32.const 0)
+      (if (result i32) (i32.const 0) (then (i32.const 0)) (else (local.set 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br (param i32)
+      (i32.const 0)
+      (block (br 0 (local.set 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_if (param i32)
+      (i32.const 0)
+      (block (br_if 0 (local.set 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_table (param i32)
+      (i32.const 0)
+      (block (br_table 0 (local.set 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-return (param i32)
+      (return (local.set 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-select (param i32)
+      (select (local.set 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-call (param i32)
+      (call 1 (local.set 0))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-param-arg-empty-vs-num-in-call_indirect (param i32)
+      (block (result i32)
+        (call_indirect (type $sig)
+          (local.set 0) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to mixed args
+
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.set 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.set 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.set 1 (i64.const 0))))
+  "type mismatch"
+)
+
+
+;; local.set should have no retval
+
+(assert_invalid
+  (module (func $type-empty-vs-i32 (param i32) (result i32) (local.set 0 (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-i64 (param i64) (result i64) (local.set 0 (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f32 (param f32) (result f32) (local.set 0 (f32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-vs-f64 (param f64) (result f64) (local.set 0 (f64.const 1))))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.set 3 (i32.const 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.set 14324343 (i32.const 0))))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.set 2 (i32.const 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (param i32 i64) (local.set 714324343 (i32.const 0))))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.set 3 (i32.const 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.set 214324343 (i32.const 0))))
+  "unknown local"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_tee.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_tee.wast
new file mode 100644
index 0000000..a158f0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/local_tee.wast
@@ -0,0 +1,639 @@
+;; Test `local.tee` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0)))
+  (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0)))
+  (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0)))
+  (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0)))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2)))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.tee 0 (i64.const 0))))
+    (drop (f32.neg (local.tee 1 (f32.const 0))))
+    (drop (f64.neg (local.tee 2 (f64.const 0))))
+    (drop (i32.eqz (local.tee 3 (i32.const 0))))
+    (drop (i32.eqz (local.tee 4 (i32.const 0))))
+    (drop (f32.neg (local.tee 5 (f32.const 0))))
+    (drop (i64.eqz (local.tee 6 (i64.const 0))))
+    (drop (i64.eqz (local.tee 7 (i64.const 0))))
+    (drop (f64.neg (local.tee 8 (f64.const 0))))
+  )
+
+  ;; Writing
+
+  (func (export "write") (param i64 f32 f64 i32 i32) (result i64) (local f32 i64 i64 f64)
+    (drop (local.tee 1 (f32.const -0.3)))
+    (drop (local.tee 3 (i32.const 40)))
+    (drop (local.tee 4 (i32.const -7)))
+    (drop (local.tee 5 (f32.const 5.5)))
+    (drop (local.tee 6 (i64.const 6)))
+    (drop (local.tee 8 (f64.const 8)))
+    (i64.trunc_f64_s
+      (f64.add
+        (f64.convert_i64_u (local.get 0))
+        (f64.add
+          (f64.promote_f32 (local.get 1))
+          (f64.add
+            (local.get 2)
+            (f64.add
+              (f64.convert_i32_u (local.get 3))
+              (f64.add
+                (f64.convert_i32_s (local.get 4))
+                (f64.add
+                  (f64.promote_f32 (local.get 5))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 6))
+                    (f64.add
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Result
+
+  (func (export "result") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (f64.add
+      (f64.convert_i64_u (local.tee 0 (i64.const 1)))
+      (f64.add
+        (f64.promote_f32 (local.tee 1 (f32.const 2)))
+        (f64.add
+          (local.tee 2 (f64.const 3.3))
+          (f64.add
+            (f64.convert_i32_u (local.tee 3 (i32.const 4)))
+            (f64.add
+              (f64.convert_i32_s (local.tee 4 (i32.const 5)))
+              (f64.add
+                (f64.promote_f32 (local.tee 5 (f32.const 5.5)))
+                (f64.add
+                  (f64.convert_i64_u (local.tee 6 (i64.const 6)))
+                  (f64.add
+                    (f64.convert_i64_u (local.tee 7 (i64.const 0)))
+                    (local.tee 8 (f64.const 8))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func $dummy)
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (result i32) (local.tee 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (result i32) (call $dummy) (local.tee 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-last") (param i32) (result i32)
+    (block (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (local.tee 0 (i32.const 3)) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (local.tee 0 (i32.const 4)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (local.tee 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond") (param i32)
+    (block (br_if 0 (local.tee 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (param i32)
+    (block (br_table 0 0 0 (local.tee 0 (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (local.tee 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (if (result i32) (local.tee 0 (i32.const 2))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.tee 0 (i32.const 3))) (else (local.get 0))
+    )
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (local.get 0)) (else (local.tee 0 (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (local.tee 0 (i32.const 5)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (local.tee 0 (i32.const 6)) (local.get 1))
+  )
+  (func (export "as-select-cond") (param i32) (result i32)
+    (select (i32.const 0) (i32.const 1) (local.tee 0 (i32.const 7)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (param i32) (result i32)
+    (call $f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (param i32) (result i32)
+    (call $f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (param i32) (result i32)
+    (call $f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (local.tee 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (local.tee 0 (i32.const 2)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 3)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (local.tee 0 (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (local.tee 0 (i32.const 1)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (local.tee 0 (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (param i32) (result i32)
+    (i32.load (local.tee 0 (i32.const 1)))
+  )
+  (func (export "as-loadN-address") (param i32) (result i32)
+    (i32.load8_s (local.tee 0 (i32.const 3)))
+  )
+
+  (func (export "as-store-address") (param i32)
+    (i32.store (local.tee 0 (i32.const 30)) (i32.const 7))
+  )
+  (func (export "as-store-value") (param i32)
+    (i32.store (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-storeN-address") (param i32)
+    (i32.store8 (local.tee 0 (i32.const 1)) (i32.const 7))
+  )
+  (func (export "as-storeN-value") (param i32)
+    (i32.store16 (i32.const 2) (local.tee 0 (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (param f32) (result f32)
+    (f32.neg (local.tee 0 (f32.const nan:0x0f1e2)))
+  )
+
+  (func (export "as-binary-left") (param i32) (result i32)
+    (i32.add (local.tee 0 (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (param i32) (result i32)
+    (i32.sub (i32.const 10) (local.tee 0 (i32.const 4)))
+  )
+
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz (local.tee 0 (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (i32.ne (i32.const 10) (local.tee 0 (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (param i64) (result i32)
+    (i32.wrap_i64 (local.tee 0 (i64.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (param i32) (result i32)
+    (memory.grow (local.tee 0 (i32.const 40)))
+  )
+
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2))
+
+(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-last" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 5))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond" (i32.const 0)))
+(assert_return (invoke "as-br_if-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-br_table-index" (i32.const 0)))
+(assert_return (invoke "as-br_table-value" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "as-br_table-value-index" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 7))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 4))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-select-cond" (i32.const 0)) (i32.const 0))
+
+(assert_return (invoke "as-call-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-last" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-index" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loadN-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-store-address" (i32.const 0)))
+(assert_return (invoke "as-store-value" (i32.const 0)))
+(assert_return (invoke "as-storeN-address" (i32.const 0)))
+(assert_return (invoke "as-storeN-value" (i32.const 0)))
+
+(assert_return (invoke "as-unary-operand" (f32.const 0)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "as-binary-left" (i32.const 0)) (i32.const 13))
+(assert_return (invoke "as-binary-right" (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i64.const 0)) (i32.const 41))
+(assert_return (invoke "as-memory.grow-size" (i32.const 0)) (i32.const 1))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "write"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (i64.const 56)
+)
+
+(assert_return
+  (invoke "result"
+    (i64.const -1) (f32.const -2) (f64.const -3.3) (i32.const -4) (i32.const -5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.tee 0 (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.tee 0 (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.tee 1 (i64.const 0)))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-local-arg-void-vs-num (local i32) (local.tee 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local i32) (local.tee 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f32) (local.tee 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (local.tee 1 (f64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-arg-void-vs-num (param i32) (local.tee 0 (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param i32) (local.tee 0 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f32) (local.tee 0 (f64.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (local.tee 1 (f64.const 0))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num (param i32)
+      (local.tee 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-block (param i32)
+      (i32.const 0)
+      (block (local.tee 0) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-loop (param i32)
+      (i32.const 0)
+      (loop (local.tee 0) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-then (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (then (local.tee 0) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-else (param i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (local.tee 0))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br (param i32)
+      (i32.const 0)
+      (block (br 0 (local.tee 0)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_if (param i32)
+      (i32.const 0)
+      (block (br_if 0 (local.tee 0) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-br_table (param i32)
+      (i32.const 0)
+      (block (br_table 0 (local.tee 0)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-return (param i32)
+      (return (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-select (param i32)
+      (select (local.tee 0) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-call (param i32)
+      (call 1 (local.tee 0)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-param-arg-empty-vs-num-in-call_indirect (param i32)
+      (block (result i32)
+        (call_indirect (type $sig)
+          (local.tee 0) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-local.set (param i32)
+      (local.set 0 (local.tee 0)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-param-arg-empty-vs-num-in-local.tee (param i32)
+      (local.tee 0 (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-param-arg-empty-vs-num-in-global.set (param i32)
+      (global.set $x (local.tee 0)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-param-arg-empty-vs-num-in-memory.grow (param i32)
+      (memory.grow (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-param-arg-empty-vs-num-in-load (param i32)
+      (i32.load (local.tee 0)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-param-arg-empty-vs-num-in-store (param i32)
+      (i32.store (local.tee 0) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.tee 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.tee 1 (f32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.tee 1 (i64.const 0))))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.tee 3 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.tee 14324343 (i32.const 0)) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.tee 2 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (param i32 i64) (local.tee 714324343 (i32.const 0)) drop))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.tee 3 (i32.const 0)) drop))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.tee 214324343 (i32.const 0)) drop))
+  "unknown local"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/loop.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/loop.wast
new file mode 100644
index 0000000..4557869
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/loop.wast
@@ -0,0 +1,785 @@
+;; Test `loop` opcode
+
+(module
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty")
+    (loop)
+    (loop $l)
+  )
+
+  (func (export "singular") (result i32)
+    (loop (nop))
+    (loop (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
+    (loop (result i32) (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+    (drop)
+    (loop (result i32 i64 i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (loop (result i32)
+      (loop (call $dummy) (block) (nop))
+      (loop (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (loop (result i32) (block (result i32)
+      (loop (result i32) (block (result i32)
+        (loop (result i32) (block (result i32)
+          (loop (result i32) (block (result i32)
+            (loop (result i32) (block (result i32)
+              (loop (result i32) (block (result i32)
+                (loop (result i32) (block (result i32)
+                  (loop (result i32) (block (result i32)
+                    (loop (result i32) (block (result i32)
+                      (loop (result i32) (block (result i32)
+                        (loop (result i32) (block (result i32)
+                          (loop (result i32) (block (result i32)
+                            (loop (result i32) (block (result i32)
+                              (loop (result i32) (block (result i32)
+                                (loop (result i32) (block (result i32)
+                                  (loop (result i32) (block (result i32)
+                                    (loop (result i32) (block (result i32)
+                                      (loop (result i32) (block (result i32)
+                                        (loop (result i32) (block (result i32)
+                                          (loop (result i32) (block (result i32)
+                                            (call $dummy) (i32.const 150)
+                                          ))
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (loop (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (loop (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (loop (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (loop (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (loop (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (loop (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (loop (result i32) (i32.const 1)))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (loop (result i32) (call $dummy) (i32.const 3))
+      (loop (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (loop (result f32) (call $dummy) (f32.const 3))
+      (loop (result f32) (call $dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (loop (result i32 i32)
+        (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (loop (result f32 f32)
+        (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (loop (result i32 i32)
+      (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (loop (br 1) (br 0) (unreachable)))
+    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
+    (block (loop (br_table 1 (i32.const 0)) (unreachable)))
+    (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable)))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32)
+      (i32.const 0)
+      (loop (param i32)
+        (block (br 2 (i32.const 18)))
+        (br 0 (i32.const 20))
+      )
+      (i32.const 19)
+    )
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (i32.const 0) (i32.const 0) (i64.const 0)
+      (loop (param i32 i32 i64)
+        (block (br 2 (i32.const 18) (i32.const -18) (i64.const 18)))
+        (br 0 (i32.const 20) (i32.const -20) (i64.const 20))
+      )
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (br 1 (i32.const 18))
+        (br 1 (i32.const 19))
+        (drop (br_if 1 (i32.const 20) (i32.const 0)))
+        (drop (br_if 1 (i32.const 20) (i32.const 1)))
+        (br 1 (i32.const 21))
+        (br_table 1 (i32.const 22) (i32.const 0))
+        (br_table 1 1 1 (i32.const 23) (i32.const 1))
+        (i32.const 21)
+      )
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
+    (local.get 0)
+  )
+  (func (export "cont-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 4)
+      (i32.add)
+      (local.tee $x)
+      (local.get $x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+      (local.tee $x)
+      (i32.const 3)
+      (local.get $x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+      (drop)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (local $x i32)
+    (local.set $x (i32.const 0))
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32)
+      (local.set $x (i32.add (local.get $x) (i32.const 1)))
+      (br_if 0 (i32.lt_u (local.get $x) (i32.const 10)))
+    )
+    (i32.add)
+  )
+
+  (func $fx (export "effects") (result i32)
+    (local i32)
+    (block
+      (loop
+        (local.set 0 (i32.const 1))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+        (br 1)
+        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+      )
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (func (export "while") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (loop
+        (br_if 1 (i64.eqz (local.get 0)))
+        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
+        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "for") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (i64.const 1))
+    (local.set 2 (i64.const 2))
+    (block
+      (loop
+        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
+        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "nesting") (param f32 f32) (result f32)
+    (local f32 f32)
+    (block
+      (loop
+        (br_if 1 (f32.eq (local.get 0) (f32.const 0)))
+        (local.set 2 (local.get 1))
+        (block
+          (loop
+            (br_if 1 (f32.eq (local.get 2) (f32.const 0)))
+            (br_if 3 (f32.lt (local.get 2) (f32.const 0)))
+            (local.set 3 (f32.add (local.get 3) (local.get 2)))
+            (local.set 2 (f32.sub (local.get 2) (f32.const 2)))
+            (br 0)
+          )
+        )
+        (local.set 3 (f32.div (local.get 3) (local.get 0)))
+        (local.set 0 (f32.sub (local.get 0) (f32.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 3)
+  )
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (loop (type $block-sig-1))
+    (loop (type $block-sig-2) (i32.const 0))
+    (loop (type $block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $block-sig-4))
+    (drop) (drop) (drop)
+    (loop (type $block-sig-2) (result i32) (i32.const 0))
+    (loop (type $block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "singular") (i32.const 7))
+(assert_return (invoke "multi") (i32.const 8))
+(assert_return (invoke "nested") (i32.const 9))
+(assert_return (invoke "deep") (i32.const 150))
+
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 12))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operands") (i32.const 12))
+(assert_return (invoke "as-compare-operands") (i32.const 0))
+(assert_return (invoke "as-mixed-operands") (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value") (i32.const 18))
+(assert_return (invoke "break-multi-value")
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+(assert_return (invoke "break-repeated") (i32.const 18))
+(assert_return (invoke "break-inner") (i32.const 0x1f))
+
+(assert_return (invoke "param") (i32.const 3))
+(assert_return (invoke "params") (i32.const 3))
+(assert_return (invoke "params-id") (i32.const 3))
+(assert_return (invoke "param-break") (i32.const 13))
+(assert_return (invoke "params-break") (i32.const 12))
+(assert_return (invoke "params-id-break") (i32.const 3))
+
+(assert_return (invoke "effects") (i32.const 1))
+
+(assert_return (invoke "while" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "while" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "while" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "while" (i64.const 3)) (i64.const 6))
+(assert_return (invoke "while" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "while" (i64.const 20)) (i64.const 2432902008176640000))
+
+(assert_return (invoke "for" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "for" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "for" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "for" (i64.const 3)) (i64.const 6))
+(assert_return (invoke "for" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "for" (i64.const 20)) (i64.const 2432902008176640000))
+
+(assert_return (invoke "nesting" (f32.const 0) (f32.const 7)) (f32.const 0))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 0)) (f32.const 0))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 2)) (f32.const 2))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 3)) (f32.const 4))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 4)) (f32.const 6))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 100)) (f32.const 2550))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 101)) (f32.const 2601))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 3) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 10) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 2)) (f32.const 3))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 3)) (f32.const 4))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 4)) (f32.const 10.3095235825))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 100)) (f32.const 4381.54785156))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 101)) (f32.const 2601))
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (param i32) (type $sig) (result i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (param i32) (result i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (result i32) (type $sig) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (result i32) (param i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (loop (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (i32.const 0) (loop (param $x i32) (drop)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (param i32) (drop)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (param i32) (result i32)) (unreachable))"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (loop (type $sig) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (loop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-num-vs-void
+    (loop (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (loop (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-num (result i32)
+    (loop (result i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-nums (result i32 i32)
+    (loop (result i32 i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (loop (result i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (loop (result i32 i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (loop (result i32) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result i32 i32)
+    (loop (result i32 i32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (loop (result i32 i32) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result i32)
+    (loop (result i32) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select (result i32)
+    (loop (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-value-empty-in-block
+      (i32.const 0)
+      (block (loop (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-loop
+      (i32.const 0)
+      (loop (loop (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (loop (result i32)) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (loop (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (loop (param i32 f64) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (loop (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (loop (param f32 i32) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (loop (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (loop (param i32 f64) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (loop (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (loop (param f32 i32) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) loop (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (loop (param $x i32)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func loop end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func loop $a end $l)")
+  "mismatching label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory.wast
new file mode 100644
index 0000000..497b69f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory.wast
@@ -0,0 +1,242 @@
+;; Test memory section structure
+
+(module (memory 0))
+(module (memory 1))
+(module (memory 0 0))
+(module (memory 0 1))
+(module (memory 1 256))
+(module (memory 0 65536))
+
+(assert_invalid (module (memory 0) (memory 0)) "multiple memories")
+(assert_invalid (module (memory (import "spectest" "memory") 0) (memory 0)) "multiple memories")
+
+(module (memory (data)) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 0))
+(module (memory (data "")) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 0))
+(module (memory (data "x")) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 1))
+
+(assert_invalid (module (data (i32.const 0))) "unknown memory")
+(assert_invalid (module (data (i32.const 0) "")) "unknown memory")
+(assert_invalid (module (data (i32.const 0) "x")) "unknown memory")
+
+(assert_invalid
+  (module (func (drop (f32.load (i32.const 0)))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (f32.store (i32.const 0) (f32.const 0))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (i32.load8_s (i32.const 0)))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (i32.store8 (i32.const 0) (i32.const 0))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (memory.size))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (memory.grow (i32.const 0)))))
+  "unknown memory"
+)
+
+
+(assert_invalid
+  (module (memory 1 0))
+  "size minimum must not be greater than maximum"
+)
+(assert_invalid
+  (module (memory 65537))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 2147483648))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 4294967295))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 65537))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 2147483648))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 4294967295))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+
+(assert_malformed
+  (module quote "(memory 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(memory 0x1_0000_0000 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(memory 0 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "ABC\a7D") (data (i32.const 20) "WASM")
+
+  ;; Data section
+  (func (export "data") (result i32)
+    (i32.and
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 0)) (i32.const 65))
+          (i32.eq (i32.load8_u (i32.const 3)) (i32.const 167))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 6)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 19)) (i32.const 0))
+        )
+      )
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 20)) (i32.const 87))
+          (i32.eq (i32.load8_u (i32.const 23)) (i32.const 77))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 24)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 1023)) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  ;; Memory cast
+  (func (export "cast") (result f64)
+    (i64.store (i32.const 8) (i64.const -12345))
+    (if
+      (f64.eq
+        (f64.load (i32.const 8))
+        (f64.reinterpret_i64 (i64.const -12345))
+      )
+      (then (return (f64.const 0)))
+    )
+    (i64.store align=1 (i32.const 9) (i64.const 0))
+    (i32.store16 align=1 (i32.const 15) (i32.const 16453))
+    (f64.load align=1 (i32.const 9))
+  )
+
+  ;; Sign and zero extending memory loads
+  (func (export "i32_load8_s") (param $i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $i))
+	(i32.load8_s (i32.const 8))
+  )
+  (func (export "i32_load8_u") (param $i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $i))
+	(i32.load8_u (i32.const 8))
+  )
+  (func (export "i32_load16_s") (param $i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $i))
+	(i32.load16_s (i32.const 8))
+  )
+  (func (export "i32_load16_u") (param $i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $i))
+	(i32.load16_u (i32.const 8))
+  )
+  (func (export "i64_load8_s") (param $i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $i))
+	(i64.load8_s (i32.const 8))
+  )
+  (func (export "i64_load8_u") (param $i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $i))
+	(i64.load8_u (i32.const 8))
+  )
+  (func (export "i64_load16_s") (param $i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $i))
+	(i64.load16_s (i32.const 8))
+  )
+  (func (export "i64_load16_u") (param $i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $i))
+	(i64.load16_u (i32.const 8))
+  )
+  (func (export "i64_load32_s") (param $i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $i))
+	(i64.load32_s (i32.const 8))
+  )
+  (func (export "i64_load32_u") (param $i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $i))
+	(i64.load32_u (i32.const 8))
+  )
+)
+
+(assert_return (invoke "data") (i32.const 1))
+(assert_return (invoke "cast") (f64.const 42.0))
+
+(assert_return (invoke "i32_load8_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load8_u" (i32.const -1)) (i32.const 255))
+(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 65535))
+
+(assert_return (invoke "i32_load8_s" (i32.const 100)) (i32.const 100))
+(assert_return (invoke "i32_load8_u" (i32.const 200)) (i32.const 200))
+(assert_return (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000))
+(assert_return (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000))
+
+(assert_return (invoke "i32_load8_s" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_s" (i32.const 0x3456cdef)) (i32.const 0xffffffef))
+(assert_return (invoke "i32_load8_u" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_u" (i32.const 0x3456cdef)) (i32.const 0xef))
+(assert_return (invoke "i32_load16_s" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_s" (i32.const 0x3456cdef)) (i32.const 0xffffcdef))
+(assert_return (invoke "i32_load16_u" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_u" (i32.const 0x3456cdef)) (i32.const 0xcdef))
+
+(assert_return (invoke "i64_load8_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load8_u" (i64.const -1)) (i64.const 255))
+(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 65535))
+(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 4294967295))
+
+(assert_return (invoke "i64_load8_s" (i64.const 100)) (i64.const 100))
+(assert_return (invoke "i64_load8_u" (i64.const 200)) (i64.const 200))
+(assert_return (invoke "i64_load16_s" (i64.const 20000)) (i64.const 20000))
+(assert_return (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000))
+(assert_return (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000))
+(assert_return (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000))
+
+(assert_return (invoke "i64_load8_s" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffffef))
+(assert_return (invoke "i64_load8_u" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_u" (i64.const 0x3456436598bacdef)) (i64.const 0xef))
+(assert_return (invoke "i64_load16_s" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffcdef))
+(assert_return (invoke "i64_load16_u" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_u" (i64.const 0x3456436598bacdef)) (i64.const 0xcdef))
+(assert_return (invoke "i64_load32_s" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef))
+(assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))
+
+;; Duplicate identifier errors
+
+(assert_malformed (module quote
+  "(memory $foo 1)"
+  "(memory $foo 1)")
+  "duplicate memory")
+(assert_malformed (module quote
+  "(import \"\" \"\" (memory $foo 1))"
+  "(memory $foo 1)")
+  "duplicate memory")
+(assert_malformed (module quote
+  "(import \"\" \"\" (memory $foo 1))"
+  "(import \"\" \"\" (memory $foo 1))")
+  "duplicate memory")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_copy.wast
new file mode 100644
index 0000000..472995d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_copy.wast
@@ -0,0 +1,5578 @@
+;;
+;; Generated by ../meta/generate_memory_copy.js
+;; DO NOT EDIT THIS FILE.  CHANGE THE SOURCE AND REGENERATE.
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 0) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65515) (i32.const 0) (i32.const 39))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 20))
+(assert_return (invoke "load8_u" (i32.const 219)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 418)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 617)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 816)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1015)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1214)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1413)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1612)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1811)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2010)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2209)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2408)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2607)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2806)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3005)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3204)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3403)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3602)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3801)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4000)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4199)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4398)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4597)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4796)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4995)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5194)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5393)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5592)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5791)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5990)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6189)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6388)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6587)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6786)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6985)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7184)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7383)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7582)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7781)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7980)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8179)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8378)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8577)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8776)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8975)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9174)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9373)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9572)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9771)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9970)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10169)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10368)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10567)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10766)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10965)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11164)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11363)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11562)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11761)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11960)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12159)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12358)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12557)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12756)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12955)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13154)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13353)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13552)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13751)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13950)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14149)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14348)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14547)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14746)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14945)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15144)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15343)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15542)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15741)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15940)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16139)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16338)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16537)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16736)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16935)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17134)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17333)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17532)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17731)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17930)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18129)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18328)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18527)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18726)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18925)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19124)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19323)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19522)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19721)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19920)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20119)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20318)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20517)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20716)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20915)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21114)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21313)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21512)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21711)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21910)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22109)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22308)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22507)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22706)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22905)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23104)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23303)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23502)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23701)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23900)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24099)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24298)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24497)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24696)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24895)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25094)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25293)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25492)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25691)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25890)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26089)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26288)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26487)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26686)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26885)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27084)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27283)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27482)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27681)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27880)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28079)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28278)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28477)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28676)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28875)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29074)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29273)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29472)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29671)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29870)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30069)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30268)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30467)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30666)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30865)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31064)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31263)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31462)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31661)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31860)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32059)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32258)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32457)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32656)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32855)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33054)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33253)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33452)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33651)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33850)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34049)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34248)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34447)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34646)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34845)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35044)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35243)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35442)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35641)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35840)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36039)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36238)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36437)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36636)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36835)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37034)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37233)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37432)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37631)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37830)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38029)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38228)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38427)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38626)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38825)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39024)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39223)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39422)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39621)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39820)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40019)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65515) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65515) (i32.const 39))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 20))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65486) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65486) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65487)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65488)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65489)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65492)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65493)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65494)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65495)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65496)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65497)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65498)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65499)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65500)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65501)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65502)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65503)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65504)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65505)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65486) (i32.const 65516) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65506) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65506) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65507)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65508)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65509)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65510)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65511)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65512)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65513)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65514)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65506) (i32.const 65516) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65516) (i32.const 40))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1  )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 4294963200))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 61440) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 61440) (i32.const 4294967040))
+             "out of bounds memory access")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61440)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61441)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 61442)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 61443)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 61444)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 61445)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 61446)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 61447)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 61448)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 61449)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 61450)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 61451)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 61452)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 61453)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 61454)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 61455)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 61456)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 61457)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 61458)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 61459)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 9) (i32.const 10) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 9) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9) (i32.const 20) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 16) (i32.const 15) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 10) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+ (memory 1 1)
+ (func (export "test")
+   (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000))
+    (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000))
+    (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 32768) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32768) (i32.const 65536) (i32.const 170))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344))
+    (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055))
+    (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988))
+    (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322))
+    (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994))
+    (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036))
+    (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372))
+    (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835))
+    (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393))
+    (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758))
+    (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098))
+    (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741))
+    (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823))
+    (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280))
+    (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466))
+    (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158))
+    (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544))
+    (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669))
+    (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651))
+    (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570))
+    (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691))
+    (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646))
+    (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858))
+    (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657))
+    (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981))
+    (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807))
+    (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487))
+    (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530))
+    (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943))
+    (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381))
+    (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089))
+    (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658))
+    (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702))
+    (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092))
+    (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410))
+    (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204))
+    (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394))
+    (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250))
+    (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097))
+    (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264))
+    (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299))
+    (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796))
+    (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070))
+    (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763))
+    (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312))
+    (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192))
+    (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596))
+    (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501))
+    (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686))
+    (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385))
+    (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903))
+    (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390))
+    (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441))
+    (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162))
+    (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135))
+    (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519))
+    (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280))
+    (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678))
+    (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168))
+    (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441))
+    (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663))
+    (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671))
+    (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721))
+    (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84))
+    (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029))
+    (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29))
+    (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034))
+    (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043))
+    (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324))
+    (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091))
+    (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997))
+    (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259))
+    (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189))
+    (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968))
+    (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455))
+    (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177))
+    (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568))
+    (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642))
+    (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284))
+    (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223))
+    (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171))
+    (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322))
+    (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648))
+    (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045))
+    (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097))
+    (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796))
+    (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010))
+    (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0))
+    (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069))
+    (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896))
+    (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192))
+    (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195))
+    (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24))
+    (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577))
+    (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089))
+    (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436))
+    (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765))
+    (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830))
+    (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938))
+    (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750))
+    (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098))
+    (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230))
+    (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300))
+    (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639))
+    (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097))
+    (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197))
+    (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100))
+    (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717))
+    (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119))
+    (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658))
+    (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269))
+    (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833))
+    (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300))
+    (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281))
+    (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572))
+    (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328))
+    (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670))
+    (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33))
+    (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427))
+    (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434))
+    (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834))
+    (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317))
+    (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201))
+    (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452))
+    (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346))
+    (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430))
+    (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300))
+    (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153))
+    (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281))
+    (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943))
+    (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887))
+    (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738))
+    (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122))
+    (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755))
+    (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702))
+    (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830))
+    (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064))
+    (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631))
+    (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113))
+    (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975))
+    (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336))
+    (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872))
+    (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197))
+    (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958))
+    (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186))
+    (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037))
+    (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650))
+    (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986))
+    (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955))
+    (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368))
+    (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356))
+    (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382))
+    (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900))
+    (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807))
+    (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323))
+    (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670))
+    (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341))
+    (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644))
+    (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496))
+    (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784))
+    (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350))
+    (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475))
+    (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467))
+    (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895))
+    (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751))
+    (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127))
+    (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063))
+    (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766))
+    (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520))
+    (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014))
+    (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011))
+    (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034))
+    (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320))
+    (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308))
+    (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155))
+    (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722))
+    (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370))
+    (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926))
+    (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607))
+    (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045))
+    (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596))
+    (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168))
+    (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137))
+    (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649))
+    (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52))
+    (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441))
+    (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445))
+    (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785))
+    (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406))
+    (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381))
+    (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136))
+    (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045))
+    (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389))
+    (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877))
+    (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447))
+    (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854))
+    (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377))
+    (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594))
+    (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987))
+    (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406))
+  )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 124) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 124) (i32.const 1517) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1517) (i32.const 2132) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2132) (i32.const 2827) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2827) (i32.const 2921) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2921) (i32.const 3538) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3538) (i32.const 3786) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3786) (i32.const 4042) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4042) (i32.const 4651) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4651) (i32.const 5057) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5057) (i32.const 5109) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5109) (i32.const 5291) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5291) (i32.const 5524) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5524) (i32.const 5691) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5691) (i32.const 6552) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 6552) (i32.const 7133) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7133) (i32.const 7665) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7665) (i32.const 8314) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8314) (i32.const 8360) (i32.const 62))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8360) (i32.const 8793) (i32.const 86))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8793) (i32.const 8979) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8979) (i32.const 9373) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9373) (i32.const 9518) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9518) (i32.const 9934) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9934) (i32.const 10087) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10087) (i32.const 10206) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10206) (i32.const 10230) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10230) (i32.const 10249) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10249) (i32.const 11148) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11148) (i32.const 11356) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11356) (i32.const 11380) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11380) (i32.const 11939) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11939) (i32.const 12159) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12159) (i32.const 12575) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12575) (i32.const 12969) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12969) (i32.const 13114) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 13114) (i32.const 14133) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14133) (i32.const 14404) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14404) (i32.const 14428) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14428) (i32.const 14458) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14458) (i32.const 14580) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14580) (i32.const 14777) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14777) (i32.const 15124) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15124) (i32.const 15126) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15126) (i32.const 15192) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15192) (i32.const 15871) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15871) (i32.const 15998) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15998) (i32.const 17017) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17017) (i32.const 17288) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17288) (i32.const 17312) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17312) (i32.const 17342) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17342) (i32.const 17464) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17464) (i32.const 17661) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17661) (i32.const 17727) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17727) (i32.const 17733) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17733) (i32.const 17893) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17893) (i32.const 18553) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18553) (i32.const 18744) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18744) (i32.const 18801) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18801) (i32.const 18825) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18825) (i32.const 18876) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18876) (i32.const 18885) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18885) (i32.const 18904) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18904) (i32.const 19567) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 19567) (i32.const 20403) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20403) (i32.const 21274) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21274) (i32.const 21364) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21364) (i32.const 21468) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21468) (i32.const 21492) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21492) (i32.const 22051) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22051) (i32.const 22480) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22480) (i32.const 22685) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22685) (i32.const 22694) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22694) (i32.const 22821) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22821) (i32.const 22869) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22869) (i32.const 24107) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24107) (i32.const 24111) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24111) (i32.const 24236) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24236) (i32.const 24348) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24348) (i32.const 24515) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24515) (i32.const 24900) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24900) (i32.const 25136) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25136) (i32.const 25182) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25182) (i32.const 25426) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25426) (i32.const 25613) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25613) (i32.const 25830) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25830) (i32.const 26446) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26446) (i32.const 26517) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26517) (i32.const 27468) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27468) (i32.const 27503) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27503) (i32.const 27573) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27573) (i32.const 28245) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28245) (i32.const 28280) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28280) (i32.const 29502) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29502) (i32.const 29629) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29629) (i32.const 30387) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30387) (i32.const 30646) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30646) (i32.const 31066) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31066) (i32.const 31131) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31131) (i32.const 31322) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31322) (i32.const 31379) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31379) (i32.const 31403) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31403) (i32.const 31454) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31454) (i32.const 31463) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31463) (i32.const 31482) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31482) (i32.const 31649) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31649) (i32.const 31978) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31978) (i32.const 32145) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32145) (i32.const 32530) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32530) (i32.const 32766) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32766) (i32.const 32812) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32812) (i32.const 33056) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33056) (i32.const 33660) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33660) (i32.const 33752) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33752) (i32.const 33775) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33775) (i32.const 33778) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33778) (i32.const 34603) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 34603) (i32.const 35218) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35218) (i32.const 35372) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35372) (i32.const 35486) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35486) (i32.const 35605) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35605) (i32.const 35629) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35629) (i32.const 35648) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35648) (i32.const 36547) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36547) (i32.const 36755) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36755) (i32.const 36767) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36767) (i32.const 36810) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36810) (i32.const 36839) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36839) (i32.const 37444) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 37444) (i32.const 38060) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38060) (i32.const 38131) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38131) (i32.const 39082) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39082) (i32.const 39117) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39117) (i32.const 39187) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39187) (i32.const 39859) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39859) (i32.const 39894) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39894) (i32.const 40257) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40257) (i32.const 40344) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40344) (i32.const 40371) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40371) (i32.const 40804) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40804) (i32.const 40909) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40909) (i32.const 42259) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42259) (i32.const 42511) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42511) (i32.const 42945) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42945) (i32.const 43115) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43115) (i32.const 43306) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43306) (i32.const 43363) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43363) (i32.const 43387) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43387) (i32.const 43438) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43438) (i32.const 43447) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43447) (i32.const 43466) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43466) (i32.const 44129) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44129) (i32.const 44958) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44958) (i32.const 45570) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45570) (i32.const 45575) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45575) (i32.const 45640) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45640) (i32.const 45742) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45742) (i32.const 45832) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45832) (i32.const 45999) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45999) (i32.const 46384) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46384) (i32.const 46596) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46596) (i32.const 46654) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46654) (i32.const 47515) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47515) (i32.const 47620) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47620) (i32.const 47817) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47817) (i32.const 47951) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47951) (i32.const 48632) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48632) (i32.const 48699) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48699) (i32.const 48703) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48703) (i32.const 49764) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49764) (i32.const 49955) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49955) (i32.const 50012) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50012) (i32.const 50036) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50036) (i32.const 50087) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50087) (i32.const 50096) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50096) (i32.const 50115) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50115) (i32.const 50370) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50370) (i32.const 51358) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51358) (i32.const 51610) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51610) (i32.const 51776) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51776) (i32.const 51833) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51833) (i32.const 52895) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 52895) (i32.const 53029) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53029) (i32.const 53244) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53244) (i32.const 54066) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54066) (i32.const 54133) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54133) (i32.const 54137) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54137) (i32.const 55198) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55198) (i32.const 55389) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55389) (i32.const 55446) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55446) (i32.const 55470) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55470) (i32.const 55521) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55521) (i32.const 55530) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55530) (i32.const 55549) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55549) (i32.const 56212) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 56212) (i32.const 57048) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 57048) (i32.const 58183) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58183) (i32.const 58202) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58202) (i32.const 58516) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58516) (i32.const 58835) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58835) (i32.const 58855) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58855) (i32.const 59089) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59089) (i32.const 59145) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59145) (i32.const 59677) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59677) (i32.const 60134) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60134) (i32.const 60502) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60502) (i32.const 60594) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60594) (i32.const 60617) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60617) (i32.const 60618) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60618) (i32.const 60777) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60777) (i32.const 60834) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60834) (i32.const 60858) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60858) (i32.const 60909) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60909) (i32.const 60918) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60918) (i32.const 60937) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60937) (i32.const 61600) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 61600) (i32.const 62436) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 62436) (i32.const 63307) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63307) (i32.const 63397) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63397) (i32.const 63501) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63501) (i32.const 63525) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63525) (i32.const 63605) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63605) (i32.const 63704) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63704) (i32.const 63771) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63771) (i32.const 63775) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63775) (i32.const 64311) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64311) (i32.const 64331) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64331) (i32.const 64518) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64518) (i32.const 64827) (i32.const 11))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64827) (i32.const 64834) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64834) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_fill.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_fill.wast
new file mode 100644
index 0000000..98374a1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_fill.wast
@@ -0,0 +1,686 @@
+;;
+;; Generated by ../meta/generate_memory_fill.js
+;; DO NOT EDIT THIS FILE.  CHANGE THE SOURCE AND REGENERATE.
+;;
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65280) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65280) (i32.const 65536) (i32.const 85))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1) (i32.const 65535) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65535) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+     (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10))
+     (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 18) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 25) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25) (i32.const 28) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65280) (i32.const 37) (i32.const 512))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 514))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 4294967295))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_grow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_grow.wast
new file mode 100644
index 0000000..aa56297
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_grow.wast
@@ -0,0 +1,379 @@
+(module
+    (memory 0)
+
+    (func (export "load_at_zero") (result i32) (i32.load (i32.const 0)))
+    (func (export "store_at_zero") (i32.store (i32.const 0) (i32.const 2)))
+
+    (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
+    (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
+
+    (func (export "grow") (param $sz i32) (result i32) (memory.grow (local.get $sz)))
+    (func (export "size") (result i32) (memory.size))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "store_at_zero") "out of bounds memory access")
+(assert_trap (invoke "load_at_zero") "out of bounds memory access")
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "load_at_zero") (i32.const 0))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "load_at_page_size") (i32.const 0))
+(assert_return (invoke "store_at_page_size"))
+(assert_return (invoke "load_at_page_size") (i32.const 3))
+
+
+(module
+  (memory 0)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 64736)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 803))
+
+(module
+  (memory 0 10)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+;; Test that newly allocated memory (program start and memory.grow) is zeroed
+
+(module
+  (memory 1)
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+  (func (export "check-memory-zero") (param i32 i32) (result i32)
+    (local i32)
+    (local.set 2 (i32.const 1))
+    (block
+      (loop
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-memory-zero" (i32.const 0) (i32.const 0xffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "check-memory-zero" (i32.const 0x10000) (i32.const 0x1_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "check-memory-zero" (i32.const 0x20000) (i32.const 0x2_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "check-memory-zero" (i32.const 0x30000) (i32.const 0x3_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 5))
+(assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0))
+
+;; As the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (memory.grow (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (memory.grow (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (memory.grow (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (memory.grow (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (memory.grow (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (memory.grow (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (memory.grow (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (memory.grow (i32.const 0)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 6))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 1))
+
+(assert_return (invoke "as-if-cond") (i32.const 0))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 1))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-cond") (i32.const 0))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_trap (invoke "as-call_indirect-index") "undefined element")
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 31))
+
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+
+(assert_return (invoke "as-test-operand") (i32.const 0))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32 (result i32)
+      (memory.grow)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-block (result i32)
+      (i32.const 0)
+      (block (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-loop (result i32)
+      (i32.const 0)
+      (loop (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (memory.grow)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-size-f32-vs-i32 (result i32)
+      (memory.grow (f32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-empty
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-f32 (result f32)
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_init.wast
new file mode 100644
index 0000000..672b1c5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_init.wast
@@ -0,0 +1,967 @@
+;;
+;; Generated by ../meta/generate_memory_init.js
+;; DO NOT EDIT THIS FILE.  CHANGE THE SOURCE AND REGENERATE.
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (data.drop 1)
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (data.drop 3)
+    (memory.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (memory.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (memory.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (memory.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (memory.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+(assert_invalid
+   (module
+     (func (export "test")
+       (data.drop 0)))
+   "unknown data segment")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (data.drop 4)))
+  "unknown data segment")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (data.drop 0)))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+   (memory 1)
+   (data (i32.const 0) "\37")
+   (func (export "test")
+     (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown data segment 1")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 16))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65527) (i32.const 16))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65472) (i32.const 30))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65473) (i32.const 31))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 4294967040))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292))
+              "out of bounds memory access")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1)
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "")
+  (func (memory.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_redundancy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_redundancy.wast
new file mode 100644
index 0000000..dd31731
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_redundancy.wast
@@ -0,0 +1,65 @@
+;; Test that optimizers don't do redundant-load, store-to-load, or dead-store
+;; optimizations when there are interfering stores, even of different types
+;; and to non-identical addresses.
+
+(module
+  (memory 1 1)
+
+  (func (export "zero_everything")
+    (i32.store (i32.const 0) (i32.const 0))
+    (i32.store (i32.const 4) (i32.const 0))
+    (i32.store (i32.const 8) (i32.const 0))
+    (i32.store (i32.const 12) (i32.const 0))
+  )
+
+  (func (export "test_store_to_load") (result i32)
+    (i32.store (i32.const 8) (i32.const 0))
+    (f32.store (i32.const 5) (f32.const -0.0))
+    (i32.load (i32.const 8))
+  )
+
+  (func (export "test_redundant_load") (result i32)
+    (local $t i32)
+    (local $s i32)
+    (local.set $t (i32.load (i32.const 8)))
+    (i32.store (i32.const 5) (i32.const 0x80000000))
+    (local.set $s (i32.load (i32.const 8)))
+    (i32.add (local.get $t) (local.get $s))
+  )
+
+  (func (export "test_dead_store") (result f32)
+    (local $t f32)
+    (i32.store (i32.const 8) (i32.const 0x23232323))
+    (local.set $t (f32.load (i32.const 11)))
+    (i32.store (i32.const 8) (i32.const 0))
+    (local.get $t)
+  )
+
+  ;; A function named "malloc" which implementations nonetheless shouldn't
+  ;; assume behaves like C malloc.
+  (func $malloc (export "malloc")
+     (param $size i32)
+     (result i32)
+     (i32.const 16)
+  )
+
+  ;; Call malloc twice, but unlike C malloc, we don't get non-aliasing pointers.
+  (func (export "malloc_aliasing")
+     (result i32)
+     (local $x i32)
+     (local $y i32)
+     (local.set $x (call $malloc (i32.const 4)))
+     (local.set $y (call $malloc (i32.const 4)))
+     (i32.store (local.get $x) (i32.const 42))
+     (i32.store (local.get $y) (i32.const 43))
+     (i32.load (local.get $x))
+  )
+)
+
+(assert_return (invoke "test_store_to_load") (i32.const 0x00000080))
+(invoke "zero_everything")
+(assert_return (invoke "test_redundant_load") (i32.const 0x00000080))
+(invoke "zero_everything")
+(assert_return (invoke "test_dead_store") (f32.const 0x1.18p-144))
+(invoke "zero_everything")
+(assert_return (invoke "malloc_aliasing") (i32.const 43))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_size.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_size.wast
new file mode 100644
index 0000000..239e66d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_size.wast
@@ -0,0 +1,85 @@
+(module
+  (memory 0)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $sz i32) (drop (memory.grow (local.get $sz))))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "grow" (i32.const 4)))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "grow" (i32.const 0)))
+(assert_return (invoke "size") (i32.const 5))
+
+(module
+  (memory 1)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $sz i32) (drop (memory.grow (local.get $sz))))
+)
+
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 2))
+(assert_return (invoke "grow" (i32.const 4)))
+(assert_return (invoke "size") (i32.const 6))
+(assert_return (invoke "grow" (i32.const 0)))
+(assert_return (invoke "size") (i32.const 6))
+
+(module
+  (memory 0 2)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $sz i32) (drop (memory.grow (local.get $sz))))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_return (invoke "grow" (i32.const 3)))
+(assert_return (invoke "size") (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "grow" (i32.const 4)))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 2))
+
+(module
+  (memory 3 8)
+  (func (export "size") (result i32) (memory.size))
+  (func (export "grow") (param $sz i32) (drop (memory.grow (local.get $sz))))
+)
+
+(assert_return (invoke "size") (i32.const 3))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 4))
+(assert_return (invoke "grow" (i32.const 3)))
+(assert_return (invoke "size") (i32.const 7))
+(assert_return (invoke "grow" (i32.const 0)))
+(assert_return (invoke "size") (i32.const 7))
+(assert_return (invoke "grow" (i32.const 2)))
+(assert_return (invoke "size") (i32.const 7))
+(assert_return (invoke "grow" (i32.const 1)))
+(assert_return (invoke "size") (i32.const 8))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-empty
+      (memory.size)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-f32 (result f32)
+      (memory.size)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_trap.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_trap.wast
new file mode 100644
index 0000000..a4156fe
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/memory_trap.wast
@@ -0,0 +1,270 @@
+(module
+    (memory 1)
+
+    (func $addr_limit (result i32)
+      (i32.mul (memory.size) (i32.const 0x10000))
+    )
+
+    (func (export "store") (param $i i32) (param $v i32)
+      (i32.store (i32.add (call $addr_limit) (local.get $i)) (local.get $v))
+    )
+
+    (func (export "load") (param $i i32) (result i32)
+      (i32.load (i32.add (call $addr_limit) (local.get $i)))
+    )
+
+    (func (export "memory.grow") (param i32) (result i32)
+      (memory.grow (local.get 0))
+    )
+)
+
+(assert_return (invoke "store" (i32.const -4) (i32.const 42)))
+(assert_return (invoke "load" (i32.const -4)) (i32.const 42))
+(assert_trap (invoke "store" (i32.const -3) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const -2) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const -1) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const 0) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "load" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "store" (i32.const 0x80000000) (i32.const 13)) "out of bounds memory access")
+(assert_trap (invoke "load" (i32.const 0x80000000)) "out of bounds memory access")
+(assert_return (invoke "memory.grow" (i32.const 0x10001)) (i32.const -1))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "abcdefgh")
+  (data (i32.const 0xfff8) "abcdefgh")
+
+  (func (export "i32.load") (param $a i32) (result i32)
+    (i32.load (local.get $a))
+  )
+  (func (export "i64.load") (param $a i32) (result i64)
+    (i64.load (local.get $a))
+  )
+  (func (export "f32.load") (param $a i32) (result f32)
+    (f32.load (local.get $a))
+  )
+  (func (export "f64.load") (param $a i32) (result f64)
+    (f64.load (local.get $a))
+  )
+  (func (export "i32.load8_s") (param $a i32) (result i32)
+    (i32.load8_s (local.get $a))
+  )
+  (func (export "i32.load8_u") (param $a i32) (result i32)
+    (i32.load8_u (local.get $a))
+  )
+  (func (export "i32.load16_s") (param $a i32) (result i32)
+    (i32.load16_s (local.get $a))
+  )
+  (func (export "i32.load16_u") (param $a i32) (result i32)
+    (i32.load16_u (local.get $a))
+  )
+  (func (export "i64.load8_s") (param $a i32) (result i64)
+    (i64.load8_s (local.get $a))
+  )
+  (func (export "i64.load8_u") (param $a i32) (result i64)
+    (i64.load8_u (local.get $a))
+  )
+  (func (export "i64.load16_s") (param $a i32) (result i64)
+    (i64.load16_s (local.get $a))
+  )
+  (func (export "i64.load16_u") (param $a i32) (result i64)
+    (i64.load16_u (local.get $a))
+  )
+  (func (export "i64.load32_s") (param $a i32) (result i64)
+    (i64.load32_s (local.get $a))
+  )
+  (func (export "i64.load32_u") (param $a i32) (result i64)
+    (i64.load32_u (local.get $a))
+  )
+  (func (export "i32.store") (param $a i32) (param $v i32)
+    (i32.store (local.get $a) (local.get $v))
+  )
+  (func (export "i64.store") (param $a i32) (param $v i64)
+    (i64.store (local.get $a) (local.get $v))
+  )
+  (func (export "f32.store") (param $a i32) (param $v f32)
+    (f32.store (local.get $a) (local.get $v))
+  )
+  (func (export "f64.store") (param $a i32) (param $v f64)
+    (f64.store (local.get $a) (local.get $v))
+  )
+  (func (export "i32.store8") (param $a i32) (param $v i32)
+    (i32.store8 (local.get $a) (local.get $v))
+  )
+  (func (export "i32.store16") (param $a i32) (param $v i32)
+    (i32.store16 (local.get $a) (local.get $v))
+  )
+  (func (export "i64.store8") (param $a i32) (param $v i64)
+    (i64.store8 (local.get $a) (local.get $v))
+  )
+  (func (export "i64.store16") (param $a i32) (param $v i64)
+    (i64.store16 (local.get $a) (local.get $v))
+  )
+  (func (export "i64.store32") (param $a i32) (param $v i64)
+    (i64.store32 (local.get $a) (local.get $v))
+  )
+)
+
+(assert_trap (invoke "i32.store" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xffff) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xfffe) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xfffd) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -2) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -3) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -4) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffe) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffd) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffc) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffb) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffa) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfff9) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -3) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -4) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -5) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -6) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -7) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -8) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0x10000) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xffff) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xfffe) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xfffd) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -1) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -2) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -3) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -4) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0x10000) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xffff) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffe) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffd) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffc) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffb) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffa) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfff9) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -1) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -2) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -3) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -4) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -5) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -6) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -7) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -8) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store8" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store8" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const 0xffff) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const -2) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store8" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store8" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xfffe) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xfffd) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -3) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -4) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffc)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffb)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffa)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfff9)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -5)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -6)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -7)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -8)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffc)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffb)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffa)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfff9)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -5)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -6)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -7)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -8)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -4)) "out of bounds memory access")
+
+;; No memory was changed
+(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0x6867666564636261))
+(assert_return (invoke "i64.load" (i32.const 0)) (i64.const 0x6867666564636261))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/names.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/names.wast
new file mode 100644
index 0000000..9c53234
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/names.wast
@@ -0,0 +1,1107 @@
+;; Test files can define multiple modules. Test that implementations treat
+;; each module independently from the other.
+
+(module
+  (func (export "foo") (result i32) (i32.const 0))
+)
+
+(assert_return (invoke "foo") (i32.const 0))
+
+;; Another module, same function name, different contents.
+
+(module
+  (func (export "foo") (result i32) (i32.const 1))
+)
+
+(assert_return (invoke "foo") (i32.const 1))
+
+
+(module
+  ;; Test that we can use the empty string as a symbol.
+  (func (export "") (result i32) (i32.const 0))
+
+  ;; Test that we can use names beginning with a digit.
+  (func (export "0") (result i32) (i32.const 1))
+
+  ;; Test that we can use names beginning with a dash.
+  (func (export "-0") (result i32) (i32.const 2))
+
+  ;; Test that we can use names beginning with an underscore.
+  (func (export "_") (result i32) (i32.const 3))
+
+  ;; Test that we can use names beginning with a dollar sign.
+  (func (export "$") (result i32) (i32.const 4))
+
+  ;; Test that we can use names beginning with an at sign.
+  (func (export "@") (result i32) (i32.const 5))
+
+  ;; Test that we can use non-alphanumeric names.
+  (func (export "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (result i32) (i32.const 6))
+
+  ;; Test that we can use names that have special meaning in JS.
+  (func (export "NaN") (result i32) (i32.const 7))
+  (func (export "Infinity") (result i32) (i32.const 8))
+  (func (export "if") (result i32) (i32.const 9))
+
+  ;; Test that we can use common libc names without conflict.
+  (func (export "malloc") (result i32) (i32.const 10))
+
+  ;; Test that we can use some libc hidden names without conflict.
+  (func (export "_malloc") (result i32) (i32.const 11))
+  (func (export "__malloc") (result i32) (i32.const 12))
+
+  ;; Test that names are case-sensitive.
+  (func (export "a") (result i32) (i32.const 13))
+  (func (export "A") (result i32) (i32.const 14))
+
+  ;; Test that UTF-8 BOM code points can appear in identifiers.
+  (func (export "") (result i32) (i32.const 15))
+
+  ;; Test that Unicode normalization is not applied. These function names
+  ;; contain different codepoints which normalize to the same thing under
+  ;; NFC or NFD.
+  (func (export "Å") (result i32) (i32.const 16))
+  (func (export "Å") (result i32) (i32.const 17))
+  (func (export "Å") (result i32) (i32.const 18))
+
+  ;; Test that Unicode compatibility normalization is not applied. These
+  ;; function names contain different codepoints which normalize to the
+  ;; same thing under NFKC or NFKD.
+  (func (export "ffi") (result i32) (i32.const 19))
+  (func (export "ffi") (result i32) (i32.const 20))
+  (func (export "ffi") (result i32) (i32.const 21))
+
+  ;; Test the C0 control codes.
+  (func (export "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (result i32) (i32.const 22))
+  (func (export "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (result i32) (i32.const 23))
+  ;; Test miscellaneous control codes.
+  (func (export " \7f") (result i32) (i32.const 24))
+  ;; Test the C1 control codes.
+  (func (export "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (result i32) (i32.const 25))
+  (func (export "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (result i32) (i32.const 26))
+  ;; Test the Unicode Specials.
+  (func (export "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (result i32) (i32.const 27))
+  (func (export "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (result i32) (i32.const 28))
+
+  ;; Test that the control pictures are distinct from the control codes they
+  ;; depict. These correspond to the C0 and miscellaneous control code tests
+  ;; above.
+  (func (export "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (result i32) (i32.const 29))
+  (func (export "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (result i32) (i32.const 30))
+  (func (export "␠␡") (result i32) (i32.const 31))
+
+  ;; Test the Unicode Specials in non-escaped form (excluding U+FFFE and
+  ;; U+FFFF, so that generic tools don't detect this file as non-UTF-8).
+  (func (export "￰￱￲￳￴￵￶￷￸�") (result i32) (i32.const 32))
+
+  ;; Test a bare ZWJ code point.
+  (func (export "‍") (result i32) (i32.const 33))
+  ;; Test a bare ZWNJ code point.
+  (func (export "‌") (result i32) (i32.const 34))
+
+  ;; Test various bare joiner code points.
+  (func (export "͏") (result i32) (i32.const 35))
+  (func (export "⁠") (result i32) (i32.const 36))
+  (func (export "⵿") (result i32) (i32.const 37))
+  (func (export "𑁿") (result i32) (i32.const 38))
+  (func (export "᠎") (result i32) (i32.const 39))
+
+  ;; Test various interesting code points: reverse BOM, zero-width space,
+  ;; no-break space, soft hyphen, word joiner, ogham space mark,
+  ;; right-to-left override, left-to-right override.
+  (func (export "￯​ ­⁠ ‮‭") (result i32) (i32.const 40))
+
+  ;; Test more interesting code points: left-to-right mark, right-to-left mark,
+  ;; non-breaking hyphen, line separator, paragraph separator,
+  ;; left-to-right embedding, right-to-left embedding,
+  ;; pop directional formatting, narrow no-break space, left-to-right isolate,
+  ;; right-to-left isolate, first strong isolate, pop directional isolate.
+  (func (export "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (result i32) (i32.const 41))
+
+  ;; Test some deprecated code points: inhibit symmetric swapping,
+  ;; activate symmetric swapping, inhibit arabic form shaping,
+  ;; activate arabic form shaping, national digit shapes, nominal digit shapes.
+  (func (export "") (result i32) (i32.const 42))
+
+  ;; Test "invisible" operator code points.
+  (func (export "⁡⁢⁣⁤") (result i32) (i32.const 43))
+
+  ;; Test that code points outside the BMP are supported.
+  (func (export "𐀀󟿿􏿿") (result i32) (i32.const 44))
+
+  ;; Test that WebAssembly implementations cope in the presence of Zalgo.
+  (func (export "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (result i32) (i32.const 45))
+
+  ;; Test Hangul filler code points.
+  (func (export "ᅟᅠㅤﾠ") (result i32) (i32.const 46))
+
+  ;; Test variation selectors (which are also ID_Continue code points).
+  (func (export "︀") (result i32) (i32.const 47))
+  (func (export "︄") (result i32) (i32.const 48))
+  (func (export "󠄀") (result i32) (i32.const 49))
+  (func (export "󠇯") (result i32) (i32.const 50))
+
+  ;; Test an uncombined combining code point.
+  (func (export "̈") (result i32) (i32.const 51))
+
+  ;; Test that numerous different present and historical representations of the
+  ;; "newline" concept are distinct. Tests largely inspired by:
+  ;;   https://en.wikipedia.org/wiki/Newline#Representations
+  ;;   https://en.wikipedia.org/wiki/Newline#Unicode and
+  ;;   https://en.wikipedia.org/wiki/Newline#Reverse_and_partial_line_feeds
+  (func (export "\0a") (result i32) (i32.const 52))
+  (func (export "␤") (result i32) (i32.const 53))
+  (func (export "
") (result i32) (i32.const 54))
+  (func (export "\0d") (result i32) (i32.const 55))
+  (func (export "\0d\0a") (result i32) (i32.const 56))
+  (func (export "\0a\0d") (result i32) (i32.const 57))
+  (func (export "\1e") (result i32) (i32.const 58))
+  (func (export "\0b") (result i32) (i32.const 59))
+  (func (export "\0c") (result i32) (i32.const 60))
+  (func (export "\c2\85") (result i32) (i32.const 61))
+  (func (export "
") (result i32) (i32.const 62))
+  (func (export "…") (result i32) (i32.const 63))
+  (func (export "⏎") (result i32) (i32.const 64))
+  (func (export "\c2\8b") (result i32) (i32.const 65))
+  (func (export "\c2\8c") (result i32) (i32.const 66))
+  (func (export "\c2\8d") (result i32) (i32.const 67))
+  (func (export "↵") (result i32) (i32.const 68))
+  (func (export "↩") (result i32) (i32.const 69))
+  (func (export "⌤") (result i32) (i32.const 70))
+  (func (export "⤶") (result i32) (i32.const 71))
+  (func (export "↲") (result i32) (i32.const 72))
+  (func (export "⮨") (result i32) (i32.const 73))
+  (func (export "⮰") (result i32) (i32.const 74))
+
+  ;; Test that non-characters are not replaced by the replacement character.
+  (func (export "�") (result i32) (i32.const 75))
+  (func (export "\ef\b7\90") (result i32) (i32.const 76))
+  (func (export "\ef\b7\91") (result i32) (i32.const 77))
+  (func (export "\ef\b7\92") (result i32) (i32.const 78))
+  (func (export "\ef\b7\93") (result i32) (i32.const 79))
+  (func (export "\ef\b7\94") (result i32) (i32.const 80))
+  (func (export "\ef\b7\95") (result i32) (i32.const 81))
+  (func (export "\ef\b7\96") (result i32) (i32.const 82))
+  (func (export "\ef\b7\97") (result i32) (i32.const 83))
+  (func (export "\ef\b7\98") (result i32) (i32.const 84))
+  (func (export "\ef\b7\99") (result i32) (i32.const 85))
+  (func (export "\ef\b7\9a") (result i32) (i32.const 86))
+  (func (export "\ef\b7\9b") (result i32) (i32.const 87))
+  (func (export "\ef\b7\9c") (result i32) (i32.const 88))
+  (func (export "\ef\b7\9d") (result i32) (i32.const 89))
+  (func (export "\ef\b7\9e") (result i32) (i32.const 90))
+  (func (export "\ef\b7\9f") (result i32) (i32.const 91))
+  (func (export "\ef\b7\a0") (result i32) (i32.const 92))
+  (func (export "\ef\b7\a1") (result i32) (i32.const 93))
+  (func (export "\ef\b7\a2") (result i32) (i32.const 94))
+  (func (export "\ef\b7\a3") (result i32) (i32.const 95))
+  (func (export "\ef\b7\a4") (result i32) (i32.const 96))
+  (func (export "\ef\b7\a5") (result i32) (i32.const 97))
+  (func (export "\ef\b7\a6") (result i32) (i32.const 98))
+  (func (export "\ef\b7\a7") (result i32) (i32.const 99))
+  (func (export "\ef\b7\a8") (result i32) (i32.const 100))
+  (func (export "\ef\b7\a9") (result i32) (i32.const 101))
+  (func (export "\ef\b7\aa") (result i32) (i32.const 102))
+  (func (export "\ef\b7\ab") (result i32) (i32.const 103))
+  (func (export "\ef\b7\ac") (result i32) (i32.const 104))
+  (func (export "\ef\b7\ad") (result i32) (i32.const 105))
+  (func (export "\ef\b7\ae") (result i32) (i32.const 106))
+  (func (export "\ef\b7\af") (result i32) (i32.const 107))
+  (func (export "\ef\bf\be") (result i32) (i32.const 108))
+  (func (export "\ef\bf\bf") (result i32) (i32.const 109))
+  (func (export "\f0\9f\bf\be") (result i32) (i32.const 110))
+  (func (export "\f0\9f\bf\bf") (result i32) (i32.const 111))
+  (func (export "\f0\af\bf\be") (result i32) (i32.const 112))
+  (func (export "\f0\af\bf\bf") (result i32) (i32.const 113))
+  (func (export "\f0\bf\bf\be") (result i32) (i32.const 114))
+  (func (export "\f0\bf\bf\bf") (result i32) (i32.const 115))
+  (func (export "\f1\8f\bf\be") (result i32) (i32.const 116))
+  (func (export "\f1\8f\bf\bf") (result i32) (i32.const 117))
+  (func (export "\f1\9f\bf\be") (result i32) (i32.const 118))
+  (func (export "\f1\9f\bf\bf") (result i32) (i32.const 119))
+  (func (export "\f1\af\bf\be") (result i32) (i32.const 120))
+  (func (export "\f1\af\bf\bf") (result i32) (i32.const 121))
+  (func (export "\f1\bf\bf\be") (result i32) (i32.const 122))
+  (func (export "\f1\bf\bf\bf") (result i32) (i32.const 123))
+  (func (export "\f2\8f\bf\be") (result i32) (i32.const 124))
+  (func (export "\f2\8f\bf\bf") (result i32) (i32.const 125))
+  (func (export "\f2\9f\bf\be") (result i32) (i32.const 126))
+  (func (export "\f2\9f\bf\bf") (result i32) (i32.const 127))
+  (func (export "\f2\af\bf\be") (result i32) (i32.const 128))
+  (func (export "\f2\af\bf\bf") (result i32) (i32.const 129))
+  (func (export "\f2\bf\bf\be") (result i32) (i32.const 130))
+  (func (export "\f2\bf\bf\bf") (result i32) (i32.const 131))
+  (func (export "\f3\8f\bf\be") (result i32) (i32.const 132))
+  (func (export "\f3\8f\bf\bf") (result i32) (i32.const 133))
+  (func (export "\f3\9f\bf\be") (result i32) (i32.const 134))
+  (func (export "\f3\9f\bf\bf") (result i32) (i32.const 135))
+  (func (export "\f3\af\bf\be") (result i32) (i32.const 136))
+  (func (export "\f3\af\bf\bf") (result i32) (i32.const 137))
+  (func (export "\f3\bf\bf\be") (result i32) (i32.const 138))
+  (func (export "\f3\bf\bf\bf") (result i32) (i32.const 139))
+  (func (export "\f4\8f\bf\be") (result i32) (i32.const 140))
+  (func (export "\f4\8f\bf\bf") (result i32) (i32.const 141))
+
+  ;; Test an interrobang with combining diacritical marks above.
+  ;; https://xkcd.com/1209/
+  (func (export "̈‽̈̉") (result i32) (i32.const 142))
+
+  ;; Test that RLM/LRM don't change the logical byte order.
+  (func (export "abc") (result i32) (i32.const 143))
+  (func (export "‭abc") (result i32) (i32.const 144))
+  (func (export "‮cba") (result i32) (i32.const 145))
+  (func (export "‭abc‮") (result i32) (i32.const 146))
+  (func (export "‮cba‭") (result i32) (i32.const 147))
+
+  ;; Test that Unicode font variations are preserved.
+  (func (export "𝑨") (result i32) (i32.const 148))
+  (func (export "𝐴") (result i32) (i32.const 149))
+  (func (export "𝘈") (result i32) (i32.const 150))
+  (func (export "𝘼") (result i32) (i32.const 151))
+  (func (export "𝐀") (result i32) (i32.const 152))
+  (func (export "𝓐") (result i32) (i32.const 153))
+  (func (export "𝕬") (result i32) (i32.const 154))
+  (func (export "𝗔") (result i32) (i32.const 155))
+  (func (export "𝒜") (result i32) (i32.const 156))
+  (func (export "𝔄") (result i32) (i32.const 157))
+  (func (export "𝔸") (result i32) (i32.const 158))
+  (func (export "𝖠") (result i32) (i32.const 159))
+  (func (export "𝙰") (result i32) (i32.const 160))
+  (func (export "ᴀ") (result i32) (i32.const 161))
+
+  ;; Test that various additional letter variations are preserved.
+  ;; (U+0040, U+0061, U+0041, U+00C5, U+0041 U+030A, U+212B, and the font
+  ;; variations are covered above.)
+  (func (export "ᴬ") (result i32) (i32.const 162))
+  (func (export "Ⓐ") (result i32) (i32.const 163))
+  (func (export "Ａ") (result i32) (i32.const 164))
+  (func (export "🄐") (result i32) (i32.const 165))
+  (func (export "🄰") (result i32) (i32.const 166))
+  (func (export "󠁁") (result i32) (i32.const 167))
+  (func (export "U+0041") (result i32) (i32.const 168))
+  (func (export "A​") (result i32) (i32.const 169))
+  (func (export "А") (result i32) (i32.const 170))
+  (func (export "Ꙗ") (result i32) (i32.const 171))
+  (func (export "ⷼ") (result i32) (i32.const 172))
+  (func (export "ⷶ") (result i32) (i32.const 173))
+  (func (export "Ɐ") (result i32) (i32.const 174))
+  (func (export "🅐") (result i32) (i32.const 175))
+  (func (export "🅰") (result i32) (i32.const 176))
+  (func (export "Ⱝ") (result i32) (i32.const 177))
+  (func (export "𐐂") (result i32) (i32.const 178))
+  (func (export "𐐈") (result i32) (i32.const 179))
+  (func (export "𐒰") (result i32) (i32.const 180))
+  (func (export "À") (result i32) (i32.const 181))
+  (func (export "Á") (result i32) (i32.const 182))
+  (func (export "Â") (result i32) (i32.const 183))
+  (func (export "Ã") (result i32) (i32.const 184))
+  (func (export "Ä") (result i32) (i32.const 185))
+  (func (export "Ā") (result i32) (i32.const 186))
+  (func (export "Ă") (result i32) (i32.const 187))
+  (func (export "Ą") (result i32) (i32.const 188))
+  (func (export "Ǎ") (result i32) (i32.const 189))
+  (func (export "Ǟ") (result i32) (i32.const 190))
+  (func (export "Ǡ") (result i32) (i32.const 191))
+  (func (export "Ǻ") (result i32) (i32.const 192))
+  (func (export "Ȁ") (result i32) (i32.const 193))
+  (func (export "Ȃ") (result i32) (i32.const 194))
+  (func (export "Ȧ") (result i32) (i32.const 195))
+  (func (export "Ⱥ") (result i32) (i32.const 196))
+  (func (export "Ӑ") (result i32) (i32.const 197))
+  (func (export "Ӓ") (result i32) (i32.const 198))
+  (func (export "ߊ") (result i32) (i32.const 199))
+  (func (export "ࠡ") (result i32) (i32.const 200))
+  (func (export "ࠢ") (result i32) (i32.const 201))
+  (func (export "ࠣ") (result i32) (i32.const 202))
+  (func (export "ࠤ") (result i32) (i32.const 203))
+  (func (export "ࠥ") (result i32) (i32.const 204))
+  (func (export "ऄ") (result i32) (i32.const 205))
+  (func (export "अ") (result i32) (i32.const 206))
+  (func (export "ॲ") (result i32) (i32.const 207))
+  (func (export "অ") (result i32) (i32.const 208))
+  (func (export "ਅ") (result i32) (i32.const 209))
+  (func (export "અ") (result i32) (i32.const 210))
+  (func (export "ଅ") (result i32) (i32.const 211))
+  (func (export "அ") (result i32) (i32.const 212))
+  (func (export "అ") (result i32) (i32.const 213))
+  (func (export "ಅ") (result i32) (i32.const 214))
+  (func (export "അ") (result i32) (i32.const 215))
+  (func (export "ะ") (result i32) (i32.const 216))
+  (func (export "ະ") (result i32) (i32.const 217))
+  (func (export "༁") (result i32) (i32.const 218))
+  (func (export "ཨ") (result i32) (i32.const 219))
+  (func (export "ྸ") (result i32) (i32.const 220))
+  (func (export "အ") (result i32) (i32.const 221))
+  (func (export "ဢ") (result i32) (i32.const 222))
+  (func (export "ႜ") (result i32) (i32.const 223))
+  (func (export "ᅡ") (result i32) (i32.const 224))
+  (func (export "አ") (result i32) (i32.const 225))
+  (func (export "ዐ") (result i32) (i32.const 226))
+  (func (export "Ꭰ") (result i32) (i32.const 227))
+  (func (export "ᐊ") (result i32) (i32.const 228))
+  (func (export "ᖳ") (result i32) (i32.const 229))
+  (func (export "ᚨ") (result i32) (i32.const 230))
+  (func (export "ᚪ") (result i32) (i32.const 231))
+  (func (export "ᛆ") (result i32) (i32.const 232))
+  (func (export "ᜀ") (result i32) (i32.const 233))
+  (func (export "ᜠ") (result i32) (i32.const 234))
+  (func (export "ᝀ") (result i32) (i32.const 235))
+  (func (export "ᝠ") (result i32) (i32.const 236))
+  (func (export "ᠠ") (result i32) (i32.const 237))
+  (func (export "ᢇ") (result i32) (i32.const 238))
+  (func (export "ᤠ") (result i32) (i32.const 239))
+  (func (export "ᥣ") (result i32) (i32.const 240))
+  (func (export "ᨕ") (result i32) (i32.const 241))
+  (func (export "ᩋ") (result i32) (i32.const 242))
+  (func (export "ᩡ") (result i32) (i32.const 243))
+  (func (export "ᮃ") (result i32) (i32.const 244))
+  (func (export "ᯀ") (result i32) (i32.const 245))
+  (func (export "ᯁ") (result i32) (i32.const 246))
+  (func (export "ᰣ") (result i32) (i32.const 247))
+  (func (export "Ḁ") (result i32) (i32.const 248))
+  (func (export "Ạ") (result i32) (i32.const 249))
+  (func (export "Ả") (result i32) (i32.const 250))
+  (func (export "Ấ") (result i32) (i32.const 251))
+  (func (export "Ầ") (result i32) (i32.const 252))
+  (func (export "Ẩ") (result i32) (i32.const 253))
+  (func (export "Ẫ") (result i32) (i32.const 254))
+  (func (export "Ậ") (result i32) (i32.const 255))
+  (func (export "Ắ") (result i32) (i32.const 256))
+  (func (export "Ằ") (result i32) (i32.const 257))
+  (func (export "Ẳ") (result i32) (i32.const 258))
+  (func (export "Ẵ") (result i32) (i32.const 259))
+  (func (export "Ặ") (result i32) (i32.const 260))
+  (func (export "あ") (result i32) (i32.const 261))
+  (func (export "ア") (result i32) (i32.const 262))
+  (func (export "ㄚ") (result i32) (i32.const 263))
+  (func (export "ㅏ") (result i32) (i32.const 264))
+  (func (export "㈎") (result i32) (i32.const 265))
+  (func (export "㈏") (result i32) (i32.const 266))
+  (func (export "㈐") (result i32) (i32.const 267))
+  (func (export "㈑") (result i32) (i32.const 268))
+  (func (export "㈒") (result i32) (i32.const 269))
+  (func (export "㈓") (result i32) (i32.const 270))
+  (func (export "㈔") (result i32) (i32.const 271))
+  (func (export "㈕") (result i32) (i32.const 272))
+  (func (export "㈖") (result i32) (i32.const 273))
+  (func (export "㈗") (result i32) (i32.const 274))
+  (func (export "㈘") (result i32) (i32.const 275))
+  (func (export "㈙") (result i32) (i32.const 276))
+  (func (export "㈚") (result i32) (i32.const 277))
+  (func (export "㈛") (result i32) (i32.const 278))
+  (func (export "㉮") (result i32) (i32.const 279))
+  (func (export "㉯") (result i32) (i32.const 280))
+  (func (export "㉰") (result i32) (i32.const 281))
+  (func (export "㉱") (result i32) (i32.const 282))
+  (func (export "㉲") (result i32) (i32.const 283))
+  (func (export "㉳") (result i32) (i32.const 284))
+  (func (export "㉴") (result i32) (i32.const 285))
+  (func (export "㉵") (result i32) (i32.const 286))
+  (func (export "㉶") (result i32) (i32.const 287))
+  (func (export "㉷") (result i32) (i32.const 288))
+  (func (export "㉸") (result i32) (i32.const 289))
+  (func (export "㉹") (result i32) (i32.const 290))
+  (func (export "㉺") (result i32) (i32.const 291))
+  (func (export "㉻") (result i32) (i32.const 292))
+  (func (export "㋐") (result i32) (i32.const 293))
+  (func (export "ꀊ") (result i32) (i32.const 294))
+  (func (export "ꓮ") (result i32) (i32.const 295))
+  (func (export "ꕉ") (result i32) (i32.const 296))
+  (func (export "ꚠ") (result i32) (i32.const 297))
+  (func (export "ꠀ") (result i32) (i32.const 298))
+  (func (export "ꠣ") (result i32) (i32.const 299))
+  (func (export "ꡝ") (result i32) (i32.const 300))
+  (func (export "ꢂ") (result i32) (i32.const 301))
+  (func (export "꣪") (result i32) (i32.const 302))
+  (func (export "ꤢ") (result i32) (i32.const 303))
+  (func (export "ꥆ") (result i32) (i32.const 304))
+  (func (export "ꦄ") (result i32) (i32.const 305))
+  (func (export "ꨀ") (result i32) (i32.const 306))
+  (func (export "ｱ") (result i32) (i32.const 307))
+  (func (export "ￂ") (result i32) (i32.const 308))
+  (func (export "𐀀") (result i32) (i32.const 309))
+  (func (export "𐊀") (result i32) (i32.const 310))
+  (func (export "𐊠") (result i32) (i32.const 311))
+  (func (export "𐌀") (result i32) (i32.const 312))
+  (func (export "𐎠") (result i32) (i32.const 313))
+  (func (export "𐒖") (result i32) (i32.const 314))
+  (func (export "𐔀") (result i32) (i32.const 315))
+  (func (export "𐝀") (result i32) (i32.const 316))
+  (func (export "𐠀") (result i32) (i32.const 317))
+  (func (export "𐤠") (result i32) (i32.const 318))
+  (func (export "𐦀") (result i32) (i32.const 319))
+  (func (export "𐦠") (result i32) (i32.const 320))
+  (func (export "𐨀") (result i32) (i32.const 321))
+  (func (export "𐬀") (result i32) (i32.const 322))
+  (func (export "𐰀") (result i32) (i32.const 323))
+  (func (export "𐰁") (result i32) (i32.const 324))
+  (func (export "𐲀") (result i32) (i32.const 325))
+  (func (export "𑀅") (result i32) (i32.const 326))
+  (func (export "𑂃") (result i32) (i32.const 327))
+  (func (export "𑄧") (result i32) (i32.const 328))
+  (func (export "𑅐") (result i32) (i32.const 329))
+  (func (export "𑆃") (result i32) (i32.const 330))
+  (func (export "𑈀") (result i32) (i32.const 331))
+  (func (export "𑊀") (result i32) (i32.const 332))
+  (func (export "𑊰") (result i32) (i32.const 333))
+  (func (export "𑌅") (result i32) (i32.const 334))
+  (func (export "𑍰") (result i32) (i32.const 335))
+  (func (export "𑐀") (result i32) (i32.const 336))
+  (func (export "𑒁") (result i32) (i32.const 337))
+  (func (export "𑖀") (result i32) (i32.const 338))
+  (func (export "𑘀") (result i32) (i32.const 339))
+  (func (export "𑚀") (result i32) (i32.const 340))
+  (func (export "𑜒") (result i32) (i32.const 341))
+  (func (export "𑜠") (result i32) (i32.const 342))
+  (func (export "𑢡") (result i32) (i32.const 343))
+  (func (export "𑫕") (result i32) (i32.const 344))
+  (func (export "𑰀") (result i32) (i32.const 345))
+  (func (export "𑲏") (result i32) (i32.const 346))
+  (func (export "𑲯") (result i32) (i32.const 347))
+  (func (export "𒀀") (result i32) (i32.const 348))
+  (func (export "𖧕") (result i32) (i32.const 349))
+  (func (export "𖩆") (result i32) (i32.const 350))
+  (func (export "𖫧") (result i32) (i32.const 351))
+  (func (export "𖽔") (result i32) (i32.const 352))
+  (func (export "𛱁") (result i32) (i32.const 353))
+  (func (export "𛱤") (result i32) (i32.const 354))
+  (func (export "𞠣") (result i32) (i32.const 355))
+  (func (export "🇦") (result i32) (i32.const 356))
+  (func (export "Ɑ") (result i32) (i32.const 357))
+  (func (export "Λ") (result i32) (i32.const 358))
+  (func (export "Ɒ") (result i32) (i32.const 359))
+  (func (export "ª") (result i32) (i32.const 360))
+  (func (export "∀") (result i32) (i32.const 361))
+  (func (export "₳") (result i32) (i32.const 362))
+  (func (export "𐤀") (result i32) (i32.const 363))
+  (func (export "Ⲁ") (result i32) (i32.const 364))
+  (func (export "𐌰") (result i32) (i32.const 365))
+  (func (export "Ά") (result i32) (i32.const 366))
+  (func (export "Α") (result i32) (i32.const 367))
+  (func (export "Ἀ") (result i32) (i32.const 368))
+  (func (export "Ἁ") (result i32) (i32.const 369))
+  (func (export "Ἂ") (result i32) (i32.const 370))
+  (func (export "Ἃ") (result i32) (i32.const 371))
+  (func (export "Ἄ") (result i32) (i32.const 372))
+  (func (export "Ἅ") (result i32) (i32.const 373))
+  (func (export "Ἆ") (result i32) (i32.const 374))
+  (func (export "Ἇ") (result i32) (i32.const 375))
+  (func (export "ᾈ") (result i32) (i32.const 376))
+  (func (export "ᾉ") (result i32) (i32.const 377))
+  (func (export "ᾊ") (result i32) (i32.const 378))
+  (func (export "ᾋ") (result i32) (i32.const 379))
+  (func (export "ᾌ") (result i32) (i32.const 380))
+  (func (export "ᾍ") (result i32) (i32.const 381))
+  (func (export "ᾎ") (result i32) (i32.const 382))
+  (func (export "ᾏ") (result i32) (i32.const 383))
+  (func (export "Ᾰ") (result i32) (i32.const 384))
+  (func (export "Ᾱ") (result i32) (i32.const 385))
+  (func (export "Ὰ") (result i32) (i32.const 386))
+  (func (export "Ά") (result i32) (i32.const 387))
+  (func (export "ᾼ") (result i32) (i32.const 388))
+  (func (export "𝚨") (result i32) (i32.const 389))
+  (func (export "𝛢") (result i32) (i32.const 390))
+  (func (export "𝜜") (result i32) (i32.const 391))
+  (func (export "𝝖") (result i32) (i32.const 392))
+  (func (export "𝞐") (result i32) (i32.const 393))
+  (func (export "⍶") (result i32) (i32.const 394))
+  (func (export "⍺") (result i32) (i32.const 395))
+  (func (export "⩜") (result i32) (i32.const 396))
+  (func (export "ᗅ") (result i32) (i32.const 397))
+  (func (export "Ꭺ") (result i32) (i32.const 398))
+
+  ;; Test unmatched "closing" and "opening" code points.
+  (func (export ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (result i32) (i32.const 399))
+  (func (export "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (result i32) (i32.const 400))
+  (func (export "𝪋𝪤") (result i32) (i32.const 401))
+  (func (export "𝪋") (result i32) (i32.const 402))
+
+  ;; Test that Unicode fraction normalization is not applied.
+  (func (export "½") (result i32) (i32.const 403))
+  (func (export "1⁄2") (result i32) (i32.const 404))
+  (func (export "1/2") (result i32) (i32.const 405))
+  (func (export "୳") (result i32) (i32.const 406))
+  (func (export "൴") (result i32) (i32.const 407))
+  (func (export "⳽") (result i32) (i32.const 408))
+  (func (export "꠱") (result i32) (i32.const 409))
+  (func (export "𐅁") (result i32) (i32.const 410))
+  (func (export "𐅵") (result i32) (i32.const 411))
+  (func (export "𐅶") (result i32) (i32.const 412))
+  (func (export "𐦽") (result i32) (i32.const 413))
+  (func (export "𐹻") (result i32) (i32.const 414))
+
+  ;; Test a full-width quote.
+  (func (export "＂") (result i32) (i32.const 415))
+
+  ;; Test that different present and historical representations of the "delete"
+  ;; concept are distinct.
+  (func (export "\7f") (result i32) (i32.const 416))
+  (func (export "\08") (result i32) (i32.const 417))
+  (func (export "⌫") (result i32) (i32.const 418))
+  (func (export "⌦") (result i32) (i32.const 419))
+  (func (export "␈") (result i32) (i32.const 420))
+  (func (export "␡") (result i32) (i32.const 421))
+  (func (export "᷻") (result i32) (i32.const 422))
+  (func (export "\0f") (result i32) (i32.const 423))
+  (func (export "←") (result i32) (i32.const 424))
+  (func (export "⌧") (result i32) (i32.const 425))
+  (func (export "⍒") (result i32) (i32.const 426))
+  (func (export "⍔") (result i32) (i32.const 427))
+  (func (export "⍢") (result i32) (i32.const 428))
+  (func (export "⍫") (result i32) (i32.const 429))
+
+  ;; Test that different representations of the "substitute" concept are
+  ;; distinct. (U+FFFD is covered above.)
+  (func (export "\1a") (result i32) (i32.const 430))
+  (func (export "␦") (result i32) (i32.const 431))
+  (func (export "␚") (result i32) (i32.const 432))
+  (func (export "") (result i32) (i32.const 433))
+  (func (export "?") (result i32) (i32.const 434))
+  (func (export "¿") (result i32) (i32.const 435))
+  (func (export "᥅") (result i32) (i32.const 436))
+  (func (export ";") (result i32) (i32.const 437))
+  (func (export "՞") (result i32) (i32.const 438))
+  (func (export "؟") (result i32) (i32.const 439))
+  (func (export "፧") (result i32) (i32.const 440))
+  (func (export "⁇") (result i32) (i32.const 441))
+  (func (export "⍰") (result i32) (i32.const 442))
+  (func (export "❓") (result i32) (i32.const 443))
+  (func (export "❔") (result i32) (i32.const 444))
+  (func (export "⳺") (result i32) (i32.const 445))
+  (func (export "⳻") (result i32) (i32.const 446))
+  (func (export "⸮") (result i32) (i32.const 447))
+  (func (export "㉄") (result i32) (i32.const 448))
+  (func (export "꘏") (result i32) (i32.const 449))
+  (func (export "꛷") (result i32) (i32.const 450))
+  (func (export "︖") (result i32) (i32.const 451))
+  (func (export "﹖") (result i32) (i32.const 452))
+  (func (export "？") (result i32) (i32.const 453))
+  (func (export "𑅃") (result i32) (i32.const 454))
+  (func (export "𞥟") (result i32) (i32.const 455))
+  (func (export "󠀿") (result i32) (i32.const 456))
+  (func (export "𖡄") (result i32) (i32.const 457))
+  (func (export "⯑") (result i32) (i32.const 458))
+
+  ;; Test that different present and historical representations of the
+  ;; "paragraph" concept are distinct. (U+2029 is covered above).
+  (func (export "¶") (result i32) (i32.const 459))
+  (func (export "⁋") (result i32) (i32.const 460))
+  (func (export "܀") (result i32) (i32.const 461))
+  (func (export "჻") (result i32) (i32.const 462))
+  (func (export "፨") (result i32) (i32.const 463))
+  (func (export "〷") (result i32) (i32.const 464))
+  (func (export "❡") (result i32) (i32.const 465))
+  (func (export "⸏") (result i32) (i32.const 466))
+  (func (export "⸐") (result i32) (i32.const 467))
+  (func (export "⸑") (result i32) (i32.const 468))
+  (func (export "⸎") (result i32) (i32.const 469))
+  (func (export "\14") (result i32) (i32.const 470)) ;; ¶ in CP437
+  (func (export "☙") (result i32) (i32.const 471))
+  (func (export "⸿") (result i32) (i32.const 472))
+  (func (export "〇") (result i32) (i32.const 473))
+  (func (export "๛") (result i32) (i32.const 474))
+
+  ;; Test an unusual character.
+  (func (export "ꙮ") (result i32) (i32.const 475))
+
+  ;; Test the three characters whose normalization forms under NFC, NFD, NFKC,
+  ;; and NFKD are all different.
+  ;; http://unicode.org/faq/normalization.html#6
+  (func (export "ϓ") (result i32) (i32.const 476))
+  (func (export "ϔ") (result i32) (i32.const 477))
+  (func (export "ẛ") (result i32) (i32.const 478))
+)
+
+(assert_return (invoke "") (i32.const 0))
+(assert_return (invoke "0") (i32.const 1))
+(assert_return (invoke "-0") (i32.const 2))
+(assert_return (invoke "_") (i32.const 3))
+(assert_return (invoke "$") (i32.const 4))
+(assert_return (invoke "@") (i32.const 5))
+(assert_return (invoke "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (i32.const 6))
+(assert_return (invoke "NaN") (i32.const 7))
+(assert_return (invoke "Infinity") (i32.const 8))
+(assert_return (invoke "if") (i32.const 9))
+(assert_return (invoke "malloc") (i32.const 10))
+(assert_return (invoke "_malloc") (i32.const 11))
+(assert_return (invoke "__malloc") (i32.const 12))
+(assert_return (invoke "a") (i32.const 13))
+(assert_return (invoke "A") (i32.const 14))
+(assert_return (invoke "") (i32.const 15))
+(assert_return (invoke "Å") (i32.const 16))
+(assert_return (invoke "Å") (i32.const 17))
+(assert_return (invoke "Å") (i32.const 18))
+(assert_return (invoke "ffi") (i32.const 19))
+(assert_return (invoke "ffi") (i32.const 20))
+(assert_return (invoke "ffi") (i32.const 21))
+(assert_return (invoke "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (i32.const 22))
+(assert_return (invoke "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (i32.const 23))
+(assert_return (invoke " \7f") (i32.const 24))
+(assert_return (invoke "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (i32.const 25))
+(assert_return (invoke "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (i32.const 26))
+(assert_return (invoke "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (i32.const 27))
+(assert_return (invoke "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (i32.const 28))
+(assert_return (invoke "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (i32.const 29))
+(assert_return (invoke "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (i32.const 30))
+(assert_return (invoke "␠␡") (i32.const 31))
+(assert_return (invoke "￰￱￲￳￴￵￶￷￸�") (i32.const 32))
+(assert_return (invoke "‍") (i32.const 33))
+(assert_return (invoke "‌") (i32.const 34))
+(assert_return (invoke "͏") (i32.const 35))
+(assert_return (invoke "⁠") (i32.const 36))
+(assert_return (invoke "⵿") (i32.const 37))
+(assert_return (invoke "𑁿") (i32.const 38))
+(assert_return (invoke "᠎") (i32.const 39))
+(assert_return (invoke "￯​ ­⁠ ‮‭") (i32.const 40))
+(assert_return (invoke "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (i32.const 41))
+(assert_return (invoke "") (i32.const 42))
+(assert_return (invoke "⁡⁢⁣⁤") (i32.const 43))
+(assert_return (invoke "𐀀󟿿􏿿") (i32.const 44))
+(assert_return (invoke "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (i32.const 45))
+(assert_return (invoke "ᅟᅠㅤﾠ") (i32.const 46))
+(assert_return (invoke "︀") (i32.const 47))
+(assert_return (invoke "︄") (i32.const 48))
+(assert_return (invoke "󠄀") (i32.const 49))
+(assert_return (invoke "󠇯") (i32.const 50))
+(assert_return (invoke "̈") (i32.const 51))
+(assert_return (invoke "\0a") (i32.const 52))
+(assert_return (invoke "␤") (i32.const 53))
+(assert_return (invoke "
") (i32.const 54))
+(assert_return (invoke "\0d") (i32.const 55))
+(assert_return (invoke "\0d\0a") (i32.const 56))
+(assert_return (invoke "\0a\0d") (i32.const 57))
+(assert_return (invoke "\1e") (i32.const 58))
+(assert_return (invoke "\0b") (i32.const 59))
+(assert_return (invoke "\0c") (i32.const 60))
+(assert_return (invoke "\c2\85") (i32.const 61))
+(assert_return (invoke "
") (i32.const 62))
+(assert_return (invoke "…") (i32.const 63))
+(assert_return (invoke "⏎") (i32.const 64))
+(assert_return (invoke "\c2\8b") (i32.const 65))
+(assert_return (invoke "\c2\8c") (i32.const 66))
+(assert_return (invoke "\c2\8d") (i32.const 67))
+(assert_return (invoke "↵") (i32.const 68))
+(assert_return (invoke "↩") (i32.const 69))
+(assert_return (invoke "⌤") (i32.const 70))
+(assert_return (invoke "⤶") (i32.const 71))
+(assert_return (invoke "↲") (i32.const 72))
+(assert_return (invoke "⮨") (i32.const 73))
+(assert_return (invoke "⮰") (i32.const 74))
+(assert_return (invoke "�") (i32.const 75))
+(assert_return (invoke "\ef\b7\90") (i32.const 76))
+(assert_return (invoke "\ef\b7\91") (i32.const 77))
+(assert_return (invoke "\ef\b7\92") (i32.const 78))
+(assert_return (invoke "\ef\b7\93") (i32.const 79))
+(assert_return (invoke "\ef\b7\94") (i32.const 80))
+(assert_return (invoke "\ef\b7\95") (i32.const 81))
+(assert_return (invoke "\ef\b7\96") (i32.const 82))
+(assert_return (invoke "\ef\b7\97") (i32.const 83))
+(assert_return (invoke "\ef\b7\98") (i32.const 84))
+(assert_return (invoke "\ef\b7\99") (i32.const 85))
+(assert_return (invoke "\ef\b7\9a") (i32.const 86))
+(assert_return (invoke "\ef\b7\9b") (i32.const 87))
+(assert_return (invoke "\ef\b7\9c") (i32.const 88))
+(assert_return (invoke "\ef\b7\9d") (i32.const 89))
+(assert_return (invoke "\ef\b7\9e") (i32.const 90))
+(assert_return (invoke "\ef\b7\9f") (i32.const 91))
+(assert_return (invoke "\ef\b7\a0") (i32.const 92))
+(assert_return (invoke "\ef\b7\a1") (i32.const 93))
+(assert_return (invoke "\ef\b7\a2") (i32.const 94))
+(assert_return (invoke "\ef\b7\a3") (i32.const 95))
+(assert_return (invoke "\ef\b7\a4") (i32.const 96))
+(assert_return (invoke "\ef\b7\a5") (i32.const 97))
+(assert_return (invoke "\ef\b7\a6") (i32.const 98))
+(assert_return (invoke "\ef\b7\a7") (i32.const 99))
+(assert_return (invoke "\ef\b7\a8") (i32.const 100))
+(assert_return (invoke "\ef\b7\a9") (i32.const 101))
+(assert_return (invoke "\ef\b7\aa") (i32.const 102))
+(assert_return (invoke "\ef\b7\ab") (i32.const 103))
+(assert_return (invoke "\ef\b7\ac") (i32.const 104))
+(assert_return (invoke "\ef\b7\ad") (i32.const 105))
+(assert_return (invoke "\ef\b7\ae") (i32.const 106))
+(assert_return (invoke "\ef\b7\af") (i32.const 107))
+(assert_return (invoke "\ef\bf\be") (i32.const 108))
+(assert_return (invoke "\ef\bf\bf") (i32.const 109))
+(assert_return (invoke "\f0\9f\bf\be") (i32.const 110))
+(assert_return (invoke "\f0\9f\bf\bf") (i32.const 111))
+(assert_return (invoke "\f0\af\bf\be") (i32.const 112))
+(assert_return (invoke "\f0\af\bf\bf") (i32.const 113))
+(assert_return (invoke "\f0\bf\bf\be") (i32.const 114))
+(assert_return (invoke "\f0\bf\bf\bf") (i32.const 115))
+(assert_return (invoke "\f1\8f\bf\be") (i32.const 116))
+(assert_return (invoke "\f1\8f\bf\bf") (i32.const 117))
+(assert_return (invoke "\f1\9f\bf\be") (i32.const 118))
+(assert_return (invoke "\f1\9f\bf\bf") (i32.const 119))
+(assert_return (invoke "\f1\af\bf\be") (i32.const 120))
+(assert_return (invoke "\f1\af\bf\bf") (i32.const 121))
+(assert_return (invoke "\f1\bf\bf\be") (i32.const 122))
+(assert_return (invoke "\f1\bf\bf\bf") (i32.const 123))
+(assert_return (invoke "\f2\8f\bf\be") (i32.const 124))
+(assert_return (invoke "\f2\8f\bf\bf") (i32.const 125))
+(assert_return (invoke "\f2\9f\bf\be") (i32.const 126))
+(assert_return (invoke "\f2\9f\bf\bf") (i32.const 127))
+(assert_return (invoke "\f2\af\bf\be") (i32.const 128))
+(assert_return (invoke "\f2\af\bf\bf") (i32.const 129))
+(assert_return (invoke "\f2\bf\bf\be") (i32.const 130))
+(assert_return (invoke "\f2\bf\bf\bf") (i32.const 131))
+(assert_return (invoke "\f3\8f\bf\be") (i32.const 132))
+(assert_return (invoke "\f3\8f\bf\bf") (i32.const 133))
+(assert_return (invoke "\f3\9f\bf\be") (i32.const 134))
+(assert_return (invoke "\f3\9f\bf\bf") (i32.const 135))
+(assert_return (invoke "\f3\af\bf\be") (i32.const 136))
+(assert_return (invoke "\f3\af\bf\bf") (i32.const 137))
+(assert_return (invoke "\f3\bf\bf\be") (i32.const 138))
+(assert_return (invoke "\f3\bf\bf\bf") (i32.const 139))
+(assert_return (invoke "\f4\8f\bf\be") (i32.const 140))
+(assert_return (invoke "\f4\8f\bf\bf") (i32.const 141))
+(assert_return (invoke "̈‽̈̉") (i32.const 142))
+(assert_return (invoke "abc") (i32.const 143))
+(assert_return (invoke "‭abc") (i32.const 144))
+(assert_return (invoke "‮cba") (i32.const 145))
+(assert_return (invoke "‭abc‮") (i32.const 146))
+(assert_return (invoke "‮cba‭") (i32.const 147))
+(assert_return (invoke "𝑨") (i32.const 148))
+(assert_return (invoke "𝐴") (i32.const 149))
+(assert_return (invoke "𝘈") (i32.const 150))
+(assert_return (invoke "𝘼") (i32.const 151))
+(assert_return (invoke "𝐀") (i32.const 152))
+(assert_return (invoke "𝓐") (i32.const 153))
+(assert_return (invoke "𝕬") (i32.const 154))
+(assert_return (invoke "𝗔") (i32.const 155))
+(assert_return (invoke "𝒜") (i32.const 156))
+(assert_return (invoke "𝔄") (i32.const 157))
+(assert_return (invoke "𝔸") (i32.const 158))
+(assert_return (invoke "𝖠") (i32.const 159))
+(assert_return (invoke "𝙰") (i32.const 160))
+(assert_return (invoke "ᴀ") (i32.const 161))
+(assert_return (invoke "ᴬ") (i32.const 162))
+(assert_return (invoke "Ⓐ") (i32.const 163))
+(assert_return (invoke "Ａ") (i32.const 164))
+(assert_return (invoke "🄐") (i32.const 165))
+(assert_return (invoke "🄰") (i32.const 166))
+(assert_return (invoke "󠁁") (i32.const 167))
+(assert_return (invoke "U+0041") (i32.const 168))
+(assert_return (invoke "A​") (i32.const 169))
+(assert_return (invoke "А") (i32.const 170))
+(assert_return (invoke "Ꙗ") (i32.const 171))
+(assert_return (invoke "ⷼ") (i32.const 172))
+(assert_return (invoke "ⷶ") (i32.const 173))
+(assert_return (invoke "Ɐ") (i32.const 174))
+(assert_return (invoke "🅐") (i32.const 175))
+(assert_return (invoke "🅰") (i32.const 176))
+(assert_return (invoke "Ⱝ") (i32.const 177))
+(assert_return (invoke "𐐂") (i32.const 178))
+(assert_return (invoke "𐐈") (i32.const 179))
+(assert_return (invoke "𐒰") (i32.const 180))
+(assert_return (invoke "À") (i32.const 181))
+(assert_return (invoke "Á") (i32.const 182))
+(assert_return (invoke "Â") (i32.const 183))
+(assert_return (invoke "Ã") (i32.const 184))
+(assert_return (invoke "Ä") (i32.const 185))
+(assert_return (invoke "Ā") (i32.const 186))
+(assert_return (invoke "Ă") (i32.const 187))
+(assert_return (invoke "Ą") (i32.const 188))
+(assert_return (invoke "Ǎ") (i32.const 189))
+(assert_return (invoke "Ǟ") (i32.const 190))
+(assert_return (invoke "Ǡ") (i32.const 191))
+(assert_return (invoke "Ǻ") (i32.const 192))
+(assert_return (invoke "Ȁ") (i32.const 193))
+(assert_return (invoke "Ȃ") (i32.const 194))
+(assert_return (invoke "Ȧ") (i32.const 195))
+(assert_return (invoke "Ⱥ") (i32.const 196))
+(assert_return (invoke "Ӑ") (i32.const 197))
+(assert_return (invoke "Ӓ") (i32.const 198))
+(assert_return (invoke "ߊ") (i32.const 199))
+(assert_return (invoke "ࠡ") (i32.const 200))
+(assert_return (invoke "ࠢ") (i32.const 201))
+(assert_return (invoke "ࠣ") (i32.const 202))
+(assert_return (invoke "ࠤ") (i32.const 203))
+(assert_return (invoke "ࠥ") (i32.const 204))
+(assert_return (invoke "ऄ") (i32.const 205))
+(assert_return (invoke "अ") (i32.const 206))
+(assert_return (invoke "ॲ") (i32.const 207))
+(assert_return (invoke "অ") (i32.const 208))
+(assert_return (invoke "ਅ") (i32.const 209))
+(assert_return (invoke "અ") (i32.const 210))
+(assert_return (invoke "ଅ") (i32.const 211))
+(assert_return (invoke "அ") (i32.const 212))
+(assert_return (invoke "అ") (i32.const 213))
+(assert_return (invoke "ಅ") (i32.const 214))
+(assert_return (invoke "അ") (i32.const 215))
+(assert_return (invoke "ะ") (i32.const 216))
+(assert_return (invoke "ະ") (i32.const 217))
+(assert_return (invoke "༁") (i32.const 218))
+(assert_return (invoke "ཨ") (i32.const 219))
+(assert_return (invoke "ྸ") (i32.const 220))
+(assert_return (invoke "အ") (i32.const 221))
+(assert_return (invoke "ဢ") (i32.const 222))
+(assert_return (invoke "ႜ") (i32.const 223))
+(assert_return (invoke "ᅡ") (i32.const 224))
+(assert_return (invoke "አ") (i32.const 225))
+(assert_return (invoke "ዐ") (i32.const 226))
+(assert_return (invoke "Ꭰ") (i32.const 227))
+(assert_return (invoke "ᐊ") (i32.const 228))
+(assert_return (invoke "ᖳ") (i32.const 229))
+(assert_return (invoke "ᚨ") (i32.const 230))
+(assert_return (invoke "ᚪ") (i32.const 231))
+(assert_return (invoke "ᛆ") (i32.const 232))
+(assert_return (invoke "ᜀ") (i32.const 233))
+(assert_return (invoke "ᜠ") (i32.const 234))
+(assert_return (invoke "ᝀ") (i32.const 235))
+(assert_return (invoke "ᝠ") (i32.const 236))
+(assert_return (invoke "ᠠ") (i32.const 237))
+(assert_return (invoke "ᢇ") (i32.const 238))
+(assert_return (invoke "ᤠ") (i32.const 239))
+(assert_return (invoke "ᥣ") (i32.const 240))
+(assert_return (invoke "ᨕ") (i32.const 241))
+(assert_return (invoke "ᩋ") (i32.const 242))
+(assert_return (invoke "ᩡ") (i32.const 243))
+(assert_return (invoke "ᮃ") (i32.const 244))
+(assert_return (invoke "ᯀ") (i32.const 245))
+(assert_return (invoke "ᯁ") (i32.const 246))
+(assert_return (invoke "ᰣ") (i32.const 247))
+(assert_return (invoke "Ḁ") (i32.const 248))
+(assert_return (invoke "Ạ") (i32.const 249))
+(assert_return (invoke "Ả") (i32.const 250))
+(assert_return (invoke "Ấ") (i32.const 251))
+(assert_return (invoke "Ầ") (i32.const 252))
+(assert_return (invoke "Ẩ") (i32.const 253))
+(assert_return (invoke "Ẫ") (i32.const 254))
+(assert_return (invoke "Ậ") (i32.const 255))
+(assert_return (invoke "Ắ") (i32.const 256))
+(assert_return (invoke "Ằ") (i32.const 257))
+(assert_return (invoke "Ẳ") (i32.const 258))
+(assert_return (invoke "Ẵ") (i32.const 259))
+(assert_return (invoke "Ặ") (i32.const 260))
+(assert_return (invoke "あ") (i32.const 261))
+(assert_return (invoke "ア") (i32.const 262))
+(assert_return (invoke "ㄚ") (i32.const 263))
+(assert_return (invoke "ㅏ") (i32.const 264))
+(assert_return (invoke "㈎") (i32.const 265))
+(assert_return (invoke "㈏") (i32.const 266))
+(assert_return (invoke "㈐") (i32.const 267))
+(assert_return (invoke "㈑") (i32.const 268))
+(assert_return (invoke "㈒") (i32.const 269))
+(assert_return (invoke "㈓") (i32.const 270))
+(assert_return (invoke "㈔") (i32.const 271))
+(assert_return (invoke "㈕") (i32.const 272))
+(assert_return (invoke "㈖") (i32.const 273))
+(assert_return (invoke "㈗") (i32.const 274))
+(assert_return (invoke "㈘") (i32.const 275))
+(assert_return (invoke "㈙") (i32.const 276))
+(assert_return (invoke "㈚") (i32.const 277))
+(assert_return (invoke "㈛") (i32.const 278))
+(assert_return (invoke "㉮") (i32.const 279))
+(assert_return (invoke "㉯") (i32.const 280))
+(assert_return (invoke "㉰") (i32.const 281))
+(assert_return (invoke "㉱") (i32.const 282))
+(assert_return (invoke "㉲") (i32.const 283))
+(assert_return (invoke "㉳") (i32.const 284))
+(assert_return (invoke "㉴") (i32.const 285))
+(assert_return (invoke "㉵") (i32.const 286))
+(assert_return (invoke "㉶") (i32.const 287))
+(assert_return (invoke "㉷") (i32.const 288))
+(assert_return (invoke "㉸") (i32.const 289))
+(assert_return (invoke "㉹") (i32.const 290))
+(assert_return (invoke "㉺") (i32.const 291))
+(assert_return (invoke "㉻") (i32.const 292))
+(assert_return (invoke "㋐") (i32.const 293))
+(assert_return (invoke "ꀊ") (i32.const 294))
+(assert_return (invoke "ꓮ") (i32.const 295))
+(assert_return (invoke "ꕉ") (i32.const 296))
+(assert_return (invoke "ꚠ") (i32.const 297))
+(assert_return (invoke "ꠀ") (i32.const 298))
+(assert_return (invoke "ꠣ") (i32.const 299))
+(assert_return (invoke "ꡝ") (i32.const 300))
+(assert_return (invoke "ꢂ") (i32.const 301))
+(assert_return (invoke "꣪") (i32.const 302))
+(assert_return (invoke "ꤢ") (i32.const 303))
+(assert_return (invoke "ꥆ") (i32.const 304))
+(assert_return (invoke "ꦄ") (i32.const 305))
+(assert_return (invoke "ꨀ") (i32.const 306))
+(assert_return (invoke "ｱ") (i32.const 307))
+(assert_return (invoke "ￂ") (i32.const 308))
+(assert_return (invoke "𐀀") (i32.const 309))
+(assert_return (invoke "𐊀") (i32.const 310))
+(assert_return (invoke "𐊠") (i32.const 311))
+(assert_return (invoke "𐌀") (i32.const 312))
+(assert_return (invoke "𐎠") (i32.const 313))
+(assert_return (invoke "𐒖") (i32.const 314))
+(assert_return (invoke "𐔀") (i32.const 315))
+(assert_return (invoke "𐝀") (i32.const 316))
+(assert_return (invoke "𐠀") (i32.const 317))
+(assert_return (invoke "𐤠") (i32.const 318))
+(assert_return (invoke "𐦀") (i32.const 319))
+(assert_return (invoke "𐦠") (i32.const 320))
+(assert_return (invoke "𐨀") (i32.const 321))
+(assert_return (invoke "𐬀") (i32.const 322))
+(assert_return (invoke "𐰀") (i32.const 323))
+(assert_return (invoke "𐰁") (i32.const 324))
+(assert_return (invoke "𐲀") (i32.const 325))
+(assert_return (invoke "𑀅") (i32.const 326))
+(assert_return (invoke "𑂃") (i32.const 327))
+(assert_return (invoke "𑄧") (i32.const 328))
+(assert_return (invoke "𑅐") (i32.const 329))
+(assert_return (invoke "𑆃") (i32.const 330))
+(assert_return (invoke "𑈀") (i32.const 331))
+(assert_return (invoke "𑊀") (i32.const 332))
+(assert_return (invoke "𑊰") (i32.const 333))
+(assert_return (invoke "𑌅") (i32.const 334))
+(assert_return (invoke "𑍰") (i32.const 335))
+(assert_return (invoke "𑐀") (i32.const 336))
+(assert_return (invoke "𑒁") (i32.const 337))
+(assert_return (invoke "𑖀") (i32.const 338))
+(assert_return (invoke "𑘀") (i32.const 339))
+(assert_return (invoke "𑚀") (i32.const 340))
+(assert_return (invoke "𑜒") (i32.const 341))
+(assert_return (invoke "𑜠") (i32.const 342))
+(assert_return (invoke "𑢡") (i32.const 343))
+(assert_return (invoke "𑫕") (i32.const 344))
+(assert_return (invoke "𑰀") (i32.const 345))
+(assert_return (invoke "𑲏") (i32.const 346))
+(assert_return (invoke "𑲯") (i32.const 347))
+(assert_return (invoke "𒀀") (i32.const 348))
+(assert_return (invoke "𖧕") (i32.const 349))
+(assert_return (invoke "𖩆") (i32.const 350))
+(assert_return (invoke "𖫧") (i32.const 351))
+(assert_return (invoke "𖽔") (i32.const 352))
+(assert_return (invoke "𛱁") (i32.const 353))
+(assert_return (invoke "𛱤") (i32.const 354))
+(assert_return (invoke "𞠣") (i32.const 355))
+(assert_return (invoke "🇦") (i32.const 356))
+(assert_return (invoke "Ɑ") (i32.const 357))
+(assert_return (invoke "Λ") (i32.const 358))
+(assert_return (invoke "Ɒ") (i32.const 359))
+(assert_return (invoke "ª") (i32.const 360))
+(assert_return (invoke "∀") (i32.const 361))
+(assert_return (invoke "₳") (i32.const 362))
+(assert_return (invoke "𐤀") (i32.const 363))
+(assert_return (invoke "Ⲁ") (i32.const 364))
+(assert_return (invoke "𐌰") (i32.const 365))
+(assert_return (invoke "Ά") (i32.const 366))
+(assert_return (invoke "Α") (i32.const 367))
+(assert_return (invoke "Ἀ") (i32.const 368))
+(assert_return (invoke "Ἁ") (i32.const 369))
+(assert_return (invoke "Ἂ") (i32.const 370))
+(assert_return (invoke "Ἃ") (i32.const 371))
+(assert_return (invoke "Ἄ") (i32.const 372))
+(assert_return (invoke "Ἅ") (i32.const 373))
+(assert_return (invoke "Ἆ") (i32.const 374))
+(assert_return (invoke "Ἇ") (i32.const 375))
+(assert_return (invoke "ᾈ") (i32.const 376))
+(assert_return (invoke "ᾉ") (i32.const 377))
+(assert_return (invoke "ᾊ") (i32.const 378))
+(assert_return (invoke "ᾋ") (i32.const 379))
+(assert_return (invoke "ᾌ") (i32.const 380))
+(assert_return (invoke "ᾍ") (i32.const 381))
+(assert_return (invoke "ᾎ") (i32.const 382))
+(assert_return (invoke "ᾏ") (i32.const 383))
+(assert_return (invoke "Ᾰ") (i32.const 384))
+(assert_return (invoke "Ᾱ") (i32.const 385))
+(assert_return (invoke "Ὰ") (i32.const 386))
+(assert_return (invoke "Ά") (i32.const 387))
+(assert_return (invoke "ᾼ") (i32.const 388))
+(assert_return (invoke "𝚨") (i32.const 389))
+(assert_return (invoke "𝛢") (i32.const 390))
+(assert_return (invoke "𝜜") (i32.const 391))
+(assert_return (invoke "𝝖") (i32.const 392))
+(assert_return (invoke "𝞐") (i32.const 393))
+(assert_return (invoke "⍶") (i32.const 394))
+(assert_return (invoke "⍺") (i32.const 395))
+(assert_return (invoke "⩜") (i32.const 396))
+(assert_return (invoke "ᗅ") (i32.const 397))
+(assert_return (invoke "Ꭺ") (i32.const 398))
+(assert_return (invoke ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (i32.const 399))
+(assert_return (invoke "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (i32.const 400))
+(assert_return (invoke "𝪋𝪤") (i32.const 401))
+(assert_return (invoke "𝪋") (i32.const 402))
+(assert_return (invoke "½") (i32.const 403))
+(assert_return (invoke "1⁄2") (i32.const 404))
+(assert_return (invoke "1/2") (i32.const 405))
+(assert_return (invoke "୳") (i32.const 406))
+(assert_return (invoke "൴") (i32.const 407))
+(assert_return (invoke "⳽") (i32.const 408))
+(assert_return (invoke "꠱") (i32.const 409))
+(assert_return (invoke "𐅁") (i32.const 410))
+(assert_return (invoke "𐅵") (i32.const 411))
+(assert_return (invoke "𐅶") (i32.const 412))
+(assert_return (invoke "𐦽") (i32.const 413))
+(assert_return (invoke "𐹻") (i32.const 414))
+(assert_return (invoke "＂") (i32.const 415))
+(assert_return (invoke "\7f") (i32.const 416))
+(assert_return (invoke "\08") (i32.const 417))
+(assert_return (invoke "⌫") (i32.const 418))
+(assert_return (invoke "⌦") (i32.const 419))
+(assert_return (invoke "␈") (i32.const 420))
+(assert_return (invoke "␡") (i32.const 421))
+(assert_return (invoke "᷻") (i32.const 422))
+(assert_return (invoke "\0f") (i32.const 423))
+(assert_return (invoke "←") (i32.const 424))
+(assert_return (invoke "⌧") (i32.const 425))
+(assert_return (invoke "⍒") (i32.const 426))
+(assert_return (invoke "⍔") (i32.const 427))
+(assert_return (invoke "⍢") (i32.const 428))
+(assert_return (invoke "⍫") (i32.const 429))
+(assert_return (invoke "\1a") (i32.const 430))
+(assert_return (invoke "␦") (i32.const 431))
+(assert_return (invoke "␚") (i32.const 432))
+(assert_return (invoke "") (i32.const 433))
+(assert_return (invoke "?") (i32.const 434))
+(assert_return (invoke "¿") (i32.const 435))
+(assert_return (invoke "᥅") (i32.const 436))
+(assert_return (invoke ";") (i32.const 437))
+(assert_return (invoke "՞") (i32.const 438))
+(assert_return (invoke "؟") (i32.const 439))
+(assert_return (invoke "፧") (i32.const 440))
+(assert_return (invoke "⁇") (i32.const 441))
+(assert_return (invoke "⍰") (i32.const 442))
+(assert_return (invoke "❓") (i32.const 443))
+(assert_return (invoke "❔") (i32.const 444))
+(assert_return (invoke "⳺") (i32.const 445))
+(assert_return (invoke "⳻") (i32.const 446))
+(assert_return (invoke "⸮") (i32.const 447))
+(assert_return (invoke "㉄") (i32.const 448))
+(assert_return (invoke "꘏") (i32.const 449))
+(assert_return (invoke "꛷") (i32.const 450))
+(assert_return (invoke "︖") (i32.const 451))
+(assert_return (invoke "﹖") (i32.const 452))
+(assert_return (invoke "？") (i32.const 453))
+(assert_return (invoke "𑅃") (i32.const 454))
+(assert_return (invoke "𞥟") (i32.const 455))
+(assert_return (invoke "󠀿") (i32.const 456))
+(assert_return (invoke "𖡄") (i32.const 457))
+(assert_return (invoke "⯑") (i32.const 458))
+(assert_return (invoke "¶") (i32.const 459))
+(assert_return (invoke "⁋") (i32.const 460))
+(assert_return (invoke "܀") (i32.const 461))
+(assert_return (invoke "჻") (i32.const 462))
+(assert_return (invoke "፨") (i32.const 463))
+(assert_return (invoke "〷") (i32.const 464))
+(assert_return (invoke "❡") (i32.const 465))
+(assert_return (invoke "⸏") (i32.const 466))
+(assert_return (invoke "⸐") (i32.const 467))
+(assert_return (invoke "⸑") (i32.const 468))
+(assert_return (invoke "⸎") (i32.const 469))
+(assert_return (invoke "\14") (i32.const 470))
+(assert_return (invoke "☙") (i32.const 471))
+(assert_return (invoke "⸿") (i32.const 472))
+(assert_return (invoke "〇") (i32.const 473))
+(assert_return (invoke "๛") (i32.const 474))
+(assert_return (invoke "ꙮ") (i32.const 475))
+(assert_return (invoke "ϓ") (i32.const 476))
+(assert_return (invoke "ϔ") (i32.const 477))
+(assert_return (invoke "ẛ") (i32.const 478))
+
+(module
+  ;; Test that we can use indices instead of names to reference imports,
+  ;; exports, functions and parameters.
+  (import "spectest" "print_i32" (func (param i32)))
+  (func (import "spectest" "print_i32") (param i32))
+  (func (param i32) (param i32)
+    (call 0 (local.get 0))
+    (call 1 (local.get 1))
+  )
+  (export "print32" (func 2))
+)
+
+(assert_return (invoke "print32" (i32.const 42) (i32.const 123)))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/nop.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/nop.wast
new file mode 100644
index 0000000..e8fe2de
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/nop.wast
@@ -0,0 +1,426 @@
+;; Test `nop` operator.
+
+(module
+  ;; Auxiliary definitions
+  (func $dummy)
+  (func $3-ary (param i32 i32 i32) (result i32)
+    local.get 0 local.get 1 local.get 2 i32.sub i32.add
+  )
+  (memory 1)
+
+  (func (export "as-func-first") (result i32)
+    (nop) (i32.const 1)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $dummy) (nop) (i32.const 2)
+  )
+  (func (export "as-func-last") (result i32)
+    (call $dummy) (i32.const 3) (nop)
+  )
+  (func (export "as-func-everywhere") (result i32)
+    (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
+  )
+
+  (func (export "as-drop-first") (param i32)
+    (nop) (local.get 0) (drop)
+  )
+  (func (export "as-drop-last") (param i32)
+    (local.get 0) (nop) (drop)
+  )
+  (func (export "as-drop-everywhere") (param i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (drop)
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (local.get 0) (select)
+  )
+  (func (export "as-select-mid1") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (local.get 0) (select)
+  )
+  (func (export "as-select-mid2") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (local.get 0) (select)
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (local.get 0) (nop) (select)
+  )
+  (func (export "as-select-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0)
+    (nop) (nop) (local.get 0) (nop) (nop) (select)
+  )
+
+  (func (export "as-block-first") (result i32)
+    (block (result i32) (nop) (i32.const 2))
+  )
+  (func (export "as-block-mid") (result i32)
+    (block (result i32) (call $dummy) (nop) (i32.const 2))
+  )
+  (func (export "as-block-last") (result i32)
+    (block (result i32) (nop) (call $dummy) (i32.const 3) (nop))
+  )
+  (func (export "as-block-everywhere") (result i32)
+    (block (result i32)
+      (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
+    )
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (nop) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (nop) (i32.const 2))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $dummy) (i32.const 3) (nop))
+  )
+  (func (export "as-loop-everywhere") (result i32)
+    (loop (result i32)
+      (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
+    )
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (local.get 0) (nop) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (param i32)
+    (if (local.get 0) (then (nop)) (else (call $dummy)))
+  )
+  (func (export "as-if-else") (param i32)
+    (if (local.get 0) (then (call $dummy)) (else (nop)))
+  )
+
+  (func (export "as-br-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (br 0))
+  )
+  (func (export "as-br-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (br 0))
+  )
+  (func (export "as-br-everywhere") (param i32) (result i32)
+    (block (result i32) (nop) (nop) (local.get 0) (nop) (nop) (br 0))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_if 0))
+  )
+  (func (export "as-br_if-mid") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_if 0))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_if 0))
+  )
+  (func (export "as-br_if-everywhere") (param i32) (result i32)
+    (block (result i32)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
+      (br_if 0)
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_table 0 0))
+  )
+  (func (export "as-br_table-mid") (param i32) (result i32)
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_table 0 0))
+  )
+  (func (export "as-br_table-everywhere") (param i32) (result i32)
+    (block (result i32)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
+      (br_table 0 0)
+    )
+  )
+
+  (func (export "as-return-first") (param i32) (result i32)
+    (nop) (local.get 0) (return)
+  )
+  (func (export "as-return-last") (param i32) (result i32)
+    (local.get 0) (nop) (return)
+  )
+  (func (export "as-return-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (return)
+  )
+
+  (func (export "as-call-first") (param i32 i32 i32) (result i32)
+    (nop) (local.get 0) (local.get 1) (local.get 2) (call $3-ary)
+  )
+  (func (export "as-call-mid1") (param i32 i32 i32) (result i32)
+    (local.get 0) (nop) (local.get 1) (local.get 2) (call $3-ary)
+  )
+  (func (export "as-call-mid2") (param i32 i32 i32) (result i32)
+    (local.get 0) (local.get 1) (nop) (local.get 2) (call $3-ary)
+  )
+  (func (export "as-call-last") (param i32 i32 i32) (result i32)
+    (local.get 0) (local.get 1) (local.get 2) (nop) (call $3-ary)
+  )
+  (func (export "as-call-everywhere") (param i32 i32 i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1)
+    (nop) (nop) (local.get 2) (nop) (nop) (call $3-ary)
+  )
+
+  (func (export "as-unary-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.ctz)
+  )
+  (func (export "as-unary-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.ctz)
+  )
+  (func (export "as-unary-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.ctz)
+  )
+
+  (func (export "as-binary-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (i32.add)
+  )
+  (func (export "as-binary-mid") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (i32.add)
+  )
+  (func (export "as-binary-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (i32.add)
+  )
+  (func (export "as-binary-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.add)
+  )
+
+  (func (export "as-test-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.eqz)
+  )
+  (func (export "as-test-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.eqz)
+  )
+  (func (export "as-test-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) i32.eqz
+  )
+
+  (func (export "as-compare-first") (param i32) (result i32)
+    (nop) (local.get 0) (local.get 0) (i32.ne)
+  )
+  (func (export "as-compare-mid") (param i32) (result i32)
+    (local.get 0) (nop) (local.get 0) (i32.ne)
+  )
+  (func (export "as-compare-last") (param i32) (result i32)
+    (local.get 0) (local.get 0) (nop) (i32.lt_u)
+  )
+  (func (export "as-compare-everywhere") (param i32) (result i32)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.le_s)
+  )
+
+  (func (export "as-memory.grow-first") (param i32) (result i32)
+    (nop) (local.get 0) (memory.grow)
+  )
+  (func (export "as-memory.grow-last") (param i32) (result i32)
+    (local.get 0) (nop) (memory.grow)
+  )
+  (func (export "as-memory.grow-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (memory.grow)
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (nop) (i32.const 1) (i32.const 2) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-mid1") (result i32)
+    (block (result i32)
+      (i32.const 1) (nop) (i32.const 2) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-mid2") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (nop) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (i32.const 0) (nop)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-everywhere") (result i32)
+    (block (result i32)
+      (nop) (nop) (i32.const 1) (nop) (nop) (i32.const 2) (nop) (nop) (i32.const 0) (nop) (nop)
+      (call_indirect (type $check))
+    )
+  )
+
+  (func (export "as-local.set-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.set 0) (local.get 0)
+  )
+  (func (export "as-local.set-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.set 0) (local.get 0)
+  )
+  (func (export "as-local.set-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.set 0) (local.get 0)
+  )
+
+  (func (export "as-local.tee-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.tee 0)
+  )
+  (func (export "as-local.tee-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.tee 0)
+  )
+  (func (export "as-local.tee-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.tee 0)
+  )
+
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-global.set-first") (result i32)
+    (nop) (i32.const 2) (global.set $a) (global.get $a)
+  )
+  (func (export "as-global.set-last") (result i32)
+    (i32.const 2) (nop) (global.set $a) (global.get $a)
+  )
+  (func (export "as-global.set-everywhere") (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (global.set 0)
+    (global.get $a)
+  )
+
+  (func (export "as-load-first") (param i32) (result i32)
+    (nop) (local.get 0) (i32.load)
+  )
+  (func (export "as-load-last") (param i32) (result i32)
+    (local.get 0) (nop) (i32.load)
+  )
+  (func (export "as-load-everywhere") (param i32) (result i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.load)
+  )
+
+  (func (export "as-store-first") (param i32 i32)
+    (nop) (local.get 0) (local.get 1) (i32.store)
+  )
+  (func (export "as-store-mid") (param i32 i32)
+    (local.get 0) (nop) (local.get 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32 i32)
+    (local.get 0) (local.get 1) (nop) (i32.store)
+  )
+  (func (export "as-store-everywhere") (param i32 i32)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1) (nop) (nop) (i32.store)
+  )
+)
+
+(assert_return (invoke "as-func-first") (i32.const 1))
+(assert_return (invoke "as-func-mid") (i32.const 2))
+(assert_return (invoke "as-func-last") (i32.const 3))
+(assert_return (invoke "as-func-everywhere") (i32.const 4))
+
+(assert_return (invoke "as-drop-first" (i32.const 0)))
+(assert_return (invoke "as-drop-last" (i32.const 0)))
+(assert_return (invoke "as-drop-everywhere" (i32.const 0)))
+
+(assert_return (invoke "as-select-first" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "as-select-mid1" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "as-select-mid2" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "as-select-last" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "as-select-everywhere" (i32.const 3)) (i32.const 3))
+
+(assert_return (invoke "as-block-first") (i32.const 2))
+(assert_return (invoke "as-block-mid") (i32.const 2))
+(assert_return (invoke "as-block-last") (i32.const 3))
+(assert_return (invoke "as-block-everywhere") (i32.const 4))
+
+(assert_return (invoke "as-loop-first") (i32.const 2))
+(assert_return (invoke "as-loop-mid") (i32.const 2))
+(assert_return (invoke "as-loop-last") (i32.const 3))
+(assert_return (invoke "as-loop-everywhere") (i32.const 4))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)))
+(assert_return (invoke "as-if-condition" (i32.const -1)))
+(assert_return (invoke "as-if-then" (i32.const 0)))
+(assert_return (invoke "as-if-then" (i32.const 4)))
+(assert_return (invoke "as-if-else" (i32.const 0)))
+(assert_return (invoke "as-if-else" (i32.const 3)))
+
+(assert_return (invoke "as-br-first" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "as-br-last" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-br-everywhere" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-br_if-first" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "as-br_if-mid" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "as-br_if-last" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-br_if-everywhere" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-br_table-first" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "as-br_table-mid" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "as-br_table-last" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-br_table-everywhere" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-return-first" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "as-return-last" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-return-everywhere" (i32.const 7)) (i32.const 7))
+
+(assert_return (invoke "as-call-first" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "as-call-mid1" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "as-call-mid2" (i32.const 0) (i32.const 3) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call-last" (i32.const 10) (i32.const 9) (i32.const -1)) (i32.const 20))
+(assert_return (invoke "as-call-everywhere" (i32.const 2) (i32.const 1) (i32.const 5)) (i32.const -2))
+
+(assert_return (invoke "as-unary-first" (i32.const 30)) (i32.const 1))
+(assert_return (invoke "as-unary-last" (i32.const 30)) (i32.const 1))
+(assert_return (invoke "as-unary-everywhere" (i32.const 12)) (i32.const 2))
+
+(assert_return (invoke "as-binary-first" (i32.const 3)) (i32.const 6))
+(assert_return (invoke "as-binary-mid" (i32.const 3)) (i32.const 6))
+(assert_return (invoke "as-binary-last" (i32.const 3)) (i32.const 6))
+(assert_return (invoke "as-binary-everywhere" (i32.const 3)) (i32.const 6))
+
+(assert_return (invoke "as-test-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-test-last" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-test-everywhere" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "as-compare-first" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "as-compare-mid" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "as-compare-last" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "as-compare-everywhere" (i32.const 3)) (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-last" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-everywhere" (i32.const 12)) (i32.const 3))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid1") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid2") (i32.const 1))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+(assert_return (invoke "as-call_indirect-everywhere") (i32.const 1))
+
+(assert_return (invoke "as-local.set-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.set-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.set-everywhere" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-local.tee-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.tee-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.tee-everywhere" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-global.set-first") (i32.const 2))
+(assert_return (invoke "as-global.set-last") (i32.const 2))
+(assert_return (invoke "as-global.set-everywhere") (i32.const 2))
+
+(assert_return (invoke "as-load-first" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "as-load-last" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "as-load-everywhere" (i32.const 100)) (i32.const 0))
+
+(assert_return (invoke "as-store-first" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-store-mid" (i32.const 0) (i32.const 2)))
+(assert_return (invoke "as-store-last" (i32.const 0) (i32.const 3)))
+(assert_return (invoke "as-store-everywhere" (i32.const 0) (i32.const 4)))
+
+(assert_invalid
+  (module (func $type-i32 (result i32) (nop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-i64 (result i64) (nop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-f32 (result f32) (nop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-f64 (result f64) (nop)))
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/annotations/annotations.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/annotations/annotations.wast
new file mode 100644
index 0000000..ce538d9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/annotations/annotations.wast
@@ -0,0 +1,195 @@
+(@a)
+
+(@aas-3!@$d-@#4)
+(@@) (@$) (@+) (@0) (@.) (@!$@#$23414@#$)
+(@a x y z)
+(@a x-y $yz "aa" -2 0.3 0x3)
+(@a x-y$yz"aa"-2)
+(@a block func module i32.add)
+(@a 0x 8q 0xfa #4g0-.@f#^&@#$*0sf -- @#)
+(@a , ; ] [ }} }x{ ({) ,{{};}] ;)
+(@a (bla) () (5-g) ("aa" a) ($x) (bla bla) (x (y)) ")" "(" x")"y)
+(@a @ @x (@x) (@x y) (@) (@ x) (@(@(@(@)))))
+(@a (;bla;) (; ) ;)
+  ;; bla)
+  ;; bla (@x
+)
+
+(assert_malformed (module quote "(@a \00)") "illegal character")
+(assert_malformed (module quote "(@a \01)") "illegal character")
+(assert_malformed (module quote "(@a \02)") "illegal character")
+(assert_malformed (module quote "(@a \03)") "illegal character")
+(assert_malformed (module quote "(@a \04)") "illegal character")
+(assert_malformed (module quote "(@a \05)") "illegal character")
+(assert_malformed (module quote "(@a \06)") "illegal character")
+(assert_malformed (module quote "(@a \07)") "illegal character")
+(assert_malformed (module quote "(@a \08)") "illegal character")
+(module quote "(@a \09)")  ;; \t
+(module quote "(@a \0a)")  ;; \n
+(assert_malformed (module quote "(@a \0b)") "illegal character")
+(assert_malformed (module quote "(@a \0c)") "illegal character")
+(module quote "(@a \0d)")  ;; \r
+(assert_malformed (module quote "(@a \0e)") "illegal character")
+(assert_malformed (module quote "(@a \0f)") "illegal character")
+(assert_malformed (module quote "(@a \10)") "illegal character")
+(assert_malformed (module quote "(@a \11)") "illegal character")
+(assert_malformed (module quote "(@a \12)") "illegal character")
+(assert_malformed (module quote "(@a \13)") "illegal character")
+(assert_malformed (module quote "(@a \14)") "illegal character")
+(assert_malformed (module quote "(@a \15)") "illegal character")
+(assert_malformed (module quote "(@a \16)") "illegal character")
+(assert_malformed (module quote "(@a \17)") "illegal character")
+(assert_malformed (module quote "(@a \18)") "illegal character")
+(assert_malformed (module quote "(@a \19)") "illegal character")
+(assert_malformed (module quote "(@a \1a)") "illegal character")
+(assert_malformed (module quote "(@a \1b)") "illegal character")
+(assert_malformed (module quote "(@a \1c)") "illegal character")
+(assert_malformed (module quote "(@a \1d)") "illegal character")
+(assert_malformed (module quote "(@a \1e)") "illegal character")
+(assert_malformed (module quote "(@a \1f)") "illegal character")
+(module quote "(@a \20)")  ;; space
+(assert_malformed (module quote "(@a \7f)") "illegal character")
+(assert_malformed (module quote "(@a \80)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \81)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \90)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \a0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \b0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \c0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \d0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \e0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \f0)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a \ff)") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(@a Heiße Würstchen)") "illegal character")
+(assert_malformed (module quote "(@a )") "illegal character")
+
+(assert_malformed (module quote "( @a)") "unknown operator")
+
+(assert_malformed (module quote "(@)") "malformed annotation id")
+(assert_malformed (module quote "(@ )") "malformed annotation id")
+(assert_malformed (module quote "(@ x)") "malformed annotation id")
+(assert_malformed (module quote "(@(@a)x)") "malformed annotation id")
+
+(assert_malformed (module quote "(@x ") "unclosed annotation")
+(assert_malformed (module quote "(@x ()") "unclosed annotation")
+(assert_malformed (module quote "(@x (y (z))") "unclosed annotation")
+(assert_malformed (module quote "(@x (@y )") "unclosed annotation")
+
+(assert_malformed (module quote "(@x))") "unexpected token")
+(assert_malformed (module quote "(@x ()))") "unexpected token")
+(assert_malformed (module quote "(@x (y (z))))") "unexpected token")
+(assert_malformed (module quote "(@x (@y )))") "unexpected token")
+
+(assert_malformed (module quote "(@x \"") "unclosed string")
+(assert_malformed (module quote "(@x \")") "unclosed string")
+
+(assert_malformed (module quote "((@a)@b)") "unknown operator")
+(assert_malformed (module quote "(func $(@a))") "unknown operator")
+(assert_malformed (module quote "(func $(@a)f)") "unknown operator")
+
+((@a) module (@a) $m (@a) (@a)
+  ((@a) import (@a) "spectest" (@a) "global_i32" (@a)
+    ((@a) global (@a) $g (@a) i32 (@a)) (@a)
+  ) (@a)
+  ((@a) import (@a) "spectest" (@a) "table" (@a)
+    ((@a) table (@a) $t (@a) 10 (@a) 20 (@a) funcref (@a)) (@a)
+  ) (@a)
+  ((@a) import (@a) "spectest" (@a) "memory" (@a)
+    ((@a) memory (@a) $m (@a) 1 (@a) 2 (@a)) (@a)
+  ) (@a)
+  ((@a) import (@a) "spectest" (@a) "print_i32_f32" (@a)
+    ((@a) func (@a) $f (@a)
+      ((@a) param (@a) i32 (@a) f32 (@a)) (@a)
+      ((@a) result (@a)) (@a)
+    ) (@a)
+  ) (@a)
+
+  ((@a) export (@a) "g" (@a)
+    ((@a) global (@a) $g (@a)) (@a)
+  ) (@a)
+  ((@a) export (@a) "t" (@a)
+    ((@a) table (@a) $t (@a)) (@a)
+  ) (@a)
+  ((@a) export (@a) "m" (@a)
+    ((@a) memory (@a) $m (@a)) (@a)
+  ) (@a)
+  ((@a) export (@a) "f" (@a)
+    ((@a) func (@a) $f (@a)) (@a)
+  ) (@a)
+) (@a)
+
+((@a) module (@a) $m (@a) (@a)
+  ((@a) global (@a) $g (@a)
+    ((@a) export (@a) "g" (@a)) (@a)
+    ((@a) import (@a) "spectest" (@a) "global_i32" (@a)) (@a)
+    i32 (@a)
+  ) (@a)
+  ((@a) table (@a) $t (@a)
+    ((@a) export (@a) "t" (@a)) (@a)
+    ((@a) import (@a) "spectest" (@a) "table" (@a)) (@a)
+    10 (@a) 20 (@a)
+    funcref (@a)
+  ) (@a)
+  ((@a) memory (@a) $m (@a)
+    ((@a) export (@a) "m" (@a)) (@a)
+    ((@a) import (@a) "spectest" (@a) "memory" (@a)) (@a)
+    1 (@a) 2 (@a)
+  ) (@a)
+  ((@a) func (@a) $f (@a)
+    ((@a) export (@a) "f" (@a)) (@a)
+    ((@a) import (@a) "spectest" (@a) "print_i32_f32" (@a)) (@a)
+    ((@a) param (@a) i32 (@a) f32 (@a)) (@a)
+    ((@a) result (@a)) (@a)
+  ) (@a)
+) (@a)
+
+((@a) module (@a) $m (@a) (@a)
+  ((@a) type (@a) $T (@a)
+    ((@a) func (@a)
+      ((@a) param (@a) i32 (@a) i64 (@a)) (@a)
+      ((@a) param (@a) $x (@a) i32 (@a)) (@a)
+      ((@a) result (@a) i32 (@a)) (@a)
+    ) (@a)
+  ) (@a)
+
+  ((@a) global (@a) $g (@a)
+    ((@a) export (@a) "g" (@a)) (@a)
+    i32 (@a)
+    ((@a) i32.const (@a) 42 (@a)) (@a)
+  ) (@a)
+  ((@a) table (@a) $t (@a)
+    ((@a) export (@a) "t" (@a)) (@a)
+    10 (@a) 20 (@a)
+    funcref (@a)
+  ) (@a)
+  ((@a) memory (@a) $m (@a)
+    ((@a) export (@a) "m" (@a)) (@a)
+    1 (@a) 2 (@a)
+  ) (@a)
+  ((@a) func (@a) $f (@a)
+    ((@a) export (@a) "f" (@a)) (@a)
+    ((@a) param (@a) i32 (@a) i64 (@a)) (@a)
+    ((@a) param (@a) $x (@a) i32 (@a)) (@a)
+    ((@a) result (@a) i32 (@a)) (@a)
+    ((@a) local (@a) i32 (@a) i32 (@a)) (@a)
+    ((@a) local (@a) $y (@a) i32 (@a)) (@a)
+    ((@a) block (@a)
+      ((@a) result (@a) i32 (@a)) (@a)
+      ((@a) i32.add (@a)
+        ((@a) local.get (@a) $x (@a)) (@a)
+        ((@a) local.get (@a) 0 (@a)) (@a)
+      )
+    )
+  ) (@a)
+
+  ((@a) elem (@a)
+    ((@a) offset (@a) ((@a) i32.const (@a) 0 (@a)) (@a)) (@a)
+    $f (@a) $f (@a) (@a) $f (@a)
+  ) (@a)
+  ((@a) data (@a)
+    ((@a) offset (@a) ((@a) i32.const (@a) 0 (@a)) (@a)) (@a)
+    "bla" (@a) "\43" (@a) (@a) "" (@a)
+  ) (@a)
+
+  (func $s)
+  ((@a) start (@a) $s (@a)) (@a)
+) (@a)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/binary.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/binary.wast
new file mode 100644
index 0000000..8385826
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/binary.wast
@@ -0,0 +1,1218 @@
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
+
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+
+;; Malformed binary version.
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+;; Data segment memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+
+;; call_indirect reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\09\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\01"                      ;; call_indirect reserved byte is not equal to zero!
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; call_indirect reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0a\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\00"                   ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0b\01"               ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\00"                ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0c\01"               ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\00"             ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0d\01"               ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\80\00"          ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.grow reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; No more than 2^32 locals.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+;; Local count can be 0.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"     ;; Type section
+  "\03\02\01\00"           ;; Function section
+  "\0a\0a\01"              ;; Code section
+
+  ;; function 0
+  "\08\03"
+  "\00\7f"                 ;; 0 i32
+  "\00\7e"                 ;; 0 i64
+  "\02\7d"                 ;; 2 f32
+  "\0b"                    ;; end
+)
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)
+
+;; Fewer passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\03"                   ;; Datacount section with value "3"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; More passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\01"                   ;; Datacount section with value "1"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; memory.init requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0e\01"                ;; Code section
+
+    ;; function 0
+    "\0c\00"
+    "\41\00"                   ;; zero args
+    "\41\00"
+    "\41\00"
+    "\fc\08\00\00"             ;; memory.init
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; data.drop requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\fc\09\00"                ;; data.drop
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; passive element segment containing opcode other than ref.func or ref.null
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\70"                   ;; Passive, funcref
+    "\01"                      ;; 1 element
+    "\d3\00\0b"                ;; bad opcode, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "invalid elem")
+
+;; passive element segment containing type other than funcref
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\7f"                   ;; Passive, i32
+    "\01"                      ;; 1 element
+    "\d2\00\0b"                ;; ref.func, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "malformed element type")
+
+;; passive element segment containing opcode ref.func
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d2\00\0b"                ;; ref.func, index 0, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+;; passive element segment containing opcode ref.null
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\06\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d0\0b"                   ;; ref.null, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+
+;; Type count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\01\00"                               ;; type count can be zero
+)
+
+;; 2 type declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\02"                             ;; type section with inconsistent count (2 declared, 1 given)
+    "\60\00\00"                             ;; 1st type
+    ;; "\60\00\00"                          ;; 2nd type (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 type declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01"                             ;; type section with inconsistent count (1 declared, 2 given)
+    "\60\00\00"                             ;; 1st type
+    "\60\00\00"                             ;; 2nd type (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Import count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                             ;; type section
+    "\60\01\7f\00"                          ;; type 0
+    "\02\01\00"                             ;; import count can be zero
+)
+
+;; 2 import declared, 1 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\05\01"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\02\16\02"                           ;; import section with inconsistent count (2 declared, 1 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 import declared, 2 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\09\02"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\60\01\7d\00"                        ;; type 1
+      "\02\2b\01"                           ;; import section with inconsistent count (1 declared, 2 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (redundant)
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\66\33\32"         ;; print_f32
+      "\00\01"                              ;; import kind, import signature index
+  )
+  "section size mismatch"
+)
+
+;; Table count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\04\01\00"                             ;; table count can be zero
+)
+
+;; 1 table declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\01"                           ;; table section with inconsistent count (1 declared, 0 given)
+      ;; "\70\01\00\00"                     ;; table entity
+  )
+  "unexpected end of section or function"
+)
+
+;; Memory count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                             ;; memory count can be zero
+)
+
+;; 1 memory declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\01"                           ;; memory section with inconsistent count (1 declared, 0 given)
+      ;; "\00\00"                           ;; memory 0 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; Global count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\01\00"                               ;; global count can be zero
+)
+
+;; 2 global declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\06\02"                             ;; global section with inconsistent count (2 declared, 1 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    ;; "\7f\00\41\00\0b"                    ;; global 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 global declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                             ;; global section with inconsistent count (1 declared, 2 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    "\7f\00\41\00\0b"                       ;; global 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Export count can be 0
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\03\02\00\00"                         ;; func section
+  "\07\01\00"                               ;; export count can be zero
+  "\0a\07\02"                               ;; code section
+  "\02\00\0b"                               ;; function body 0
+  "\02\00\0b"                               ;; function body 1
+)
+
+;; 2 export declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\06\02"                             ;; export section with inconsistent count (2 declared, 1 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    ;; "\02"                                ;; export 1 (missed)
+    ;; "\66\32"                             ;; export name
+    ;; "\00\01"                             ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 export declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\0b\01"                             ;; export section with inconsistent count (1 declared, 2 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    "\02"                                   ;; export 1 (redundant)
+    "\66\32"                                ;; export name
+    "\00\01"                                ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "section size mismatch"
+)
+
+;; elem segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\04\04\01"                               ;; table section
+  "\70\00\01"                               ;; table 0
+  "\09\01\00"                               ;; elem segment count can be zero
+  "\0a\04\01"                               ;; code section
+  "\02\00\0b"                               ;; function body
+)
+
+;; 2 elem segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    ;; "\00\41\00\0b\01\00"                 ;; elem 1 (missed)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "invalid elements segment kind"
+)
+
+;; 1 elem segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\0d\01"                             ;; elem with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00\0b\01\00"                    ;; elem 1 (redundant)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "section size mismatch"
+)
+
+;; data segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                               ;; memory section
+  "\00\01"                                  ;; memory 0
+  "\0b\01\00"                               ;; data segment count can be zero
+)
+
+;; 2 data segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\07\02"                             ;; data with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    ;; "\00\41\01\0b\01\62"                 ;; data 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 data segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0d\01"                             ;; data with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    "\00\41\01\0b\01\62"                    ;; data 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; data segment has 7 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\03\0b"                          ;; data segment 0
+    "\07"                                   ;; data segment size with inconsistent lengths (7 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "unexpected end of section or function"
+)
+
+;; data segment has 5 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\00\0b"                          ;; data segment 0
+    "\05"                                   ;; data segment size with inconsistent lengths (5 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "section size mismatch"
+)
+
+;; br_table target count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\0a\11\01"                               ;; code section
+  "\0f\00"                                  ;; func 0
+  "\02\40"                                  ;; block 0
+  "\41\01"                                  ;; condition of if 0
+  "\04\40"                                  ;; if 0
+  "\41\01"                                  ;; index of br_table element
+  "\0e\00"                                  ;; br_table target count can be zero
+  "\02"                                     ;; break depth for default
+  "\0b\0b\0b"                               ;; end
+)
+
+;; 2 br_table target declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\10\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\02"                                ;; br_table with inconsistent target count (2 declared, 1 given)
+    "\00"                                   ;; break depth 0
+    ;; "\01"                                ;; break depth 1 (missed)
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 br_table target declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\11\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
+    "\00"                                   ;; break depth 0
+    "\01"                                   ;; break depth 1
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "malformed value type"
+)
+
+;; Start section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"       ;; Type section
+  "\03\02\01\00"             ;; Function section
+  "\08\01\00"                ;; Start section: function 0
+
+  "\0a\04\01"                ;; Code section
+  ;; function 0
+  "\02\00"
+  "\0b"                      ;; end
+)
+
+;; Multiple start sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\08\01\00"                ;; Start section: function 0
+    "\08\01\00"                ;; Start section: function 0
+
+    "\0a\04\01"                ;; Code section
+    ;; function 0
+    "\02\00"
+    "\0b"                      ;; end
+  )
+  "junk after last section"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast
new file mode 100644
index 0000000..6fb1f0d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/bulk.wast
@@ -0,0 +1,351 @@
+;; segment syntax
+(module
+  (memory 1)
+  (data "foo"))
+
+(module
+  (table 3 funcref)
+  (elem funcref (ref.func 0) (ref.null) (ref.func 1))
+  (func)
+  (func))
+
+;; memory.fill
+(module
+  (memory 1)
+
+  (func (export "fill") (param i32 i32 i32)
+    (memory.fill
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Basic fill test.
+(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0))
+
+;; Fill value is stored as a byte.
+(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa))
+
+;; Fill all of memory
+(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000))
+
+;; Out-of-bounds writes trap, and nothing is written
+(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0))
+
+;; Succeed when writing 0 bytes at the end of the region.
+(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.copy
+(module
+  (memory (data "\aa\bb\cc\dd"))
+
+  (func (export "copy") (param i32 i32 i32)
+    (memory.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4))
+
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+
+;; Copy ending at memory limit is ok.
+(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100))
+(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100))
+
+;; Succeed when copying 0 bytes at the end of the region.
+(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0))
+
+;; Copying 0 bytes outside the memory traps.
+(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.init
+(module
+  (memory 1)
+  (data "\aa\bb\cc\dd")
+
+  (func (export "init") (param i32 i32 i32)
+    (memory.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0))
+
+;; Init ending at memory limit and segment limit is ok.
+(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4))
+
+;; Out-of-bounds writes trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd))
+
+;; Succeed when writing 0 bytes at the end of either region.
+(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds memory access")
+
+;; data.drop
+(module
+  (memory 1)
+  (data $p "x")
+  (data $a (memory 0) (i32.const 0) "x")
+
+  (func (export "drop_passive") (data.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (memory.init $p (i32.const 0) (i32.const 0) (local.get $len)))
+
+  (func (export "drop_active") (data.drop $a))
+  (func (export "init_active") (param $len i32)
+    (memory.init $a (i32.const 0) (i32.const 0) (local.get $len)))
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds")
+(invoke "init_active" (i32.const 0))
+
+;; Test that the data segment index is properly encoded as an unsigned (not
+;; signed) LEB.
+(module
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "")
+  (func (data.drop 64)))
+
+;; No memory is required for the data.drop instruction.
+(module (data "goodbye") (func (data.drop 0)))
+
+;; table.init
+(module
+  (table 3 funcref)
+  (elem funcref
+    (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one))
+
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+
+  (func (export "init") (param i32 i32 i32)
+    (table.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Out-of-bounds stores trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2))
+    "out of bounds table access")
+(assert_trap (invoke "call" (i32.const 2))
+    "uninitialized element 2")
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 0))
+(assert_trap (invoke "call" (i32.const 2)) "uninitialized element")
+
+;; Init ending at table limit and segment limit is ok.
+(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2))
+
+;; Succeed when storing 0 elements at the end of either region.
+(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 elements outside the table traps.
+(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0))
+    "out of bounds table access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds table access")
+
+
+;; elem.drop
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem $p funcref (ref.func $f))
+  (elem $a (table 0) (i32.const 0) func $f)
+
+  (func (export "drop_passive") (elem.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (table.init $p (i32.const 0) (i32.const 0) (local.get $len))
+  )
+
+  (func (export "drop_active") (elem.drop $a))
+  (func (export "init_active") (param $len i32)
+    (table.init $a (i32.const 0) (i32.const 0) (local.get $len))
+  )
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds")
+(invoke "init_active" (i32.const 0))
+
+;; Test that the elem segment index is properly encoded as an unsigned (not
+;; signed) LEB.
+(module
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (elem.drop 64)))
+
+;; No table is required for the elem.drop instruction.
+(module (elem funcref (ref.func 0)) (func (elem.drop 0)))
+
+;; table.copy
+(module
+  (table 10 funcref)
+  (elem (i32.const 0) $zero $one $two)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $two (result i32) (i32.const 2))
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3))
+;; Now [$zero, $one, $two, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 5)) (i32.const 2))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3))
+;; Now [$one, $two, $zero, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 0))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3))
+;; Now [$one, $two, $one, $two, $zero, $two, ...]
+(assert_return (invoke "call" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 0))
+
+;; Copy ending at table limit is ok.
+(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2))
+(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2))
+
+;; Succeed when copying 0 elements at the end of the region.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0))
+
+;; Fail on out-of-bounds when copying 0 elements outside of table.
+(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0))
+  "out of bounds")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0))
+  "out of bounds")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/custom.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/custom.wast
new file mode 100644
index 0000000..b2394f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/custom.wast
@@ -0,0 +1,130 @@
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\24\10" "a custom section" "this is the payload"
+  "\00\20\10" "a custom section" "this is payload"
+  "\00\11\10" "a custom section" ""
+  "\00\10\00" "" "this is payload"
+  "\00\01\00" "" ""
+  "\00\24\10" "\00\00custom sectio\00" "this is the payload"
+  "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload"
+  "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload"
+  "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\01\01\00"  ;; type section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\02\01\00"  ;; import section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\03\01\00"  ;; function section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\04\01\00"  ;; table section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\05\01\00"  ;; memory section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\06\01\00"  ;; global section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\07\01\00"  ;; export section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\09\01\00"  ;; element section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0a\01\00"  ;; code section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0b\01\00"  ;; data section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\07\01\60\02\7f\7f\01\7f"                ;; type section
+  "\00\1a\06" "custom" "this is the payload"   ;; custom section
+  "\03\02\01\00"                               ;; function section
+  "\07\0a\01\06\61\64\64\54\77\6f\00\00"       ;; export section
+  "\0a\09\01\07\00\20\00\20\01\6a\0b"          ;; code section
+  "\00\1b\07" "custom2" "this is the payload"  ;; custom section
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00\00\05\01\00\07\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\26\10" "a custom section" "this is the payload"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\25\10" "a custom section" "this is the payload"
+    "\00\24\10" "a custom section" "this is the payload"
+  )
+  "malformed section id"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01\60\02\7f\7f\01\7f"                         ;; type section
+    "\00\25\10" "a custom section" "this is the payload"  ;; wrong length!
+    "\03\02\01\00"                                        ;; function section
+    "\0a\09\01\07\00\20\00\20\01\6a\0b"                   ;; code section
+    "\00\1b\07" "custom2" "this is the payload"           ;; custom section
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Test concatenated modules.
+(assert_malformed
+  (module binary
+    "\00asm\01\00\00\00"
+    "\00asm\01\00\00\00"
+  )
+  "length out of bounds"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01\00\01"                         ;; memory section
+    "\0c\01\02"                               ;; data count section (2 segments)
+    "\0b\06\01\00\41\00\0b\00"                ;; data section (1 segment)
+  )
+  "data count and data section have inconsistent lengths"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/data.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/data.wast
new file mode 100644
index 0000000..aabe102
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/data.wast
@@ -0,0 +1,345 @@
+;; Test the data section
+
+;; Syntax
+
+(module
+  (memory $m 1)
+  (data (i32.const 0))
+  (data (i32.const 1) "a" "" "bcd")
+  (data (offset (i32.const 0)))
+  (data (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory 0) (i32.const 0))
+  (data (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data (memory 0x000) (offset (i32.const 0)))
+  (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory $m) (i32.const 0))
+  (data (memory $m) (i32.const 1) "a" "" "bcd")
+  (data (memory $m) (offset (i32.const 0)))
+  (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d1 (i32.const 0))
+  (data $d2 (i32.const 1) "a" "" "bcd")
+  (data $d3 (offset (i32.const 0)))
+  (data $d4 (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d5 (memory 0) (i32.const 0))
+  (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data $d7 (memory 0x000) (offset (i32.const 0)))
+  (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d9 (memory $m) (i32.const 0))
+  (data $d10 (memory $m) (i32.const 1) "a" "" "bcd")
+  (data $d11 (memory $m) (offset (i32.const 0)))
+  (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+)
+
+;; Basic use
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 3) "b")
+  (data (i32.const 100) "cde")
+  (data (i32.const 5) "x")
+  (data (i32.const 3) "c")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 1) "b")
+  (data (i32.const 2) "cde")
+  (data (i32.const 3) "f")
+  (data (i32.const 2) "g")
+  (data (i32.const 1) "h")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get 0) "a")
+)
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get $g) "a")
+)
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get $g) "a")
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
+;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
+
+;; Corner cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+
+(module
+  (memory 2)
+  (data (i32.const 0x1_ffff) "a")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0))
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0))
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0))
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0x1_0000) "")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0) "" "")
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0 3))
+  (data (global.get 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 1) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 1) "a")
+)
+
+;; Invalid bounds for data
+
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 0 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 1))
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 1))
+  )
+  "out of bounds"
+)
+
+;; This seems to cause a time-out on Travis.
+(;assert_unlinkable
+  (module
+    (memory 0x10000)
+    (data (i32.const 0xffffffff) "ab")
+  )
+  ""  ;; either out of memory or out of bounds
+;)
+
+(assert_trap
+  (module
+    (global (import "spectest" "global_i32") i32)
+    (memory 0)
+    (data (global.get 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 1 2)
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2 3)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 1)
+    (data (i32.const -1) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -1) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const -100) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -100) "a")
+  )
+  "out of bounds"
+)
+
+;; Data without memory
+
+(assert_invalid
+  (module
+    (data (i32.const 0) "")
+  )
+  "unknown memory"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/elem.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/elem.wast
new file mode 100644
index 0000000..bb622ee
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/elem.wast
@@ -0,0 +1,433 @@
+;; Test the element section
+
+;; Syntax
+(module
+  (table $t 10 funcref)
+  (func $f)
+  (func $g)
+
+  ;; Passive
+  (elem funcref)
+  (elem funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g))
+  (elem func)
+  (elem func $f $f $g $g)
+
+  (elem $p1 funcref)
+  (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g))
+  (elem $p3 func)
+  (elem $p4 func $f $f $g $g)
+
+  ;; Active
+  (elem (table $t) (i32.const 0) funcref)
+  (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $g)
+  (elem (table $t) (offset (i32.const 0)) funcref)
+  (elem (table $t) (offset (i32.const 0)) func $f $g)
+  (elem (table 0) (i32.const 0) func)
+  (elem (table 0x0) (i32.const 0) func $f $f)
+  (elem (table 0x000) (offset (i32.const 0)) func)
+  (elem (table 0) (offset (i32.const 0)) func $f $f)
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $f)
+  (elem (table $t) (offset (i32.const 0)) func)
+  (elem (table $t) (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)))
+  (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null))
+  (elem (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)) $f $f)
+  (elem (i32.const 0))
+  (elem (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem (i32.const 0) func $f $f)
+  (elem (i32.const 0) $f $f)
+
+  (elem $a1 (table $t) (i32.const 0) funcref)
+  (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem $a3 (table $t) (i32.const 0) func)
+  (elem $a4 (table $t) (i32.const 0) func $f $g)
+  (elem $a9 (table $t) (offset (i32.const 0)) funcref)
+  (elem $a10 (table $t) (offset (i32.const 0)) func $f $g)
+  (elem $a11 (table 0) (i32.const 0) func)
+  (elem $a12 (table 0x0) (i32.const 0) func $f $f)
+  (elem $a13 (table 0x000) (offset (i32.const 0)) func)
+  (elem $a14 (table 0) (offset (i32.const 0)) func $f $f)
+  (elem $a15 (table $t) (i32.const 0) func)
+  (elem $a16 (table $t) (i32.const 0) func $f $f)
+  (elem $a17 (table $t) (offset (i32.const 0)) func)
+  (elem $a18 (table $t) (offset (i32.const 0)) func $f $f)
+  (elem $a19 (offset (i32.const 0)))
+  (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null))
+  (elem $a21 (offset (i32.const 0)) func $f $f)
+  (elem $a22 (offset (i32.const 0)) $f $f)
+  (elem $a23 (i32.const 0))
+  (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem $a25 (i32.const 0) func $f $f)
+  (elem $a26 (i32.const 0) $f $f)
+)
+
+(module
+  (func $f)
+  (func $g)
+
+  (table $t funcref (elem (ref.func $f) (ref.null) (ref.func $g)))
+)
+;; Basic use
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 5) $f)
+  (elem (i32.const 3) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 5) $f)
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get 0) $f)
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get $g) $f)
+)
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 7) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+;; Corner cases
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+
+(module
+  (table 0 funcref)
+  (elem (i32.const 0))
+)
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (elem (i32.const 0))
+)
+
+(module
+  (table 0 0 funcref)
+  (elem (i32.const 0))
+)
+
+(module
+  (table 20 funcref)
+  (elem (i32.const 20))
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 100 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 30 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+;; Invalid bounds for elements
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 1 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (elem (i32.const 1))
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 20 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds"
+)
+
+;; Element without table
+
+(assert_invalid
+  (module
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "unknown table"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten") (i32.const 66))
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 funcref))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Element sections across multiple modules change the same table
+
+(module $module1
+  (type $out-i32 (func (result i32)))
+  (table (export "shared-table") 10 funcref)
+  (elem (i32.const 8) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-8") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 8))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+
+(register "module1" $module1)
+
+(assert_trap (invoke $module1 "call-7") "uninitialized element")
+(assert_return (invoke $module1 "call-8") (i32.const 65))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module2
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 7) $const-i32-c)
+  (elem (i32.const 8) $const-i32-d)
+  (func $const-i32-c (type $out-i32) (i32.const 67))
+  (func $const-i32-d (type $out-i32) (i32.const 68))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 68))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module3
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 8) $const-i32-e)
+  (elem (i32.const 9) $const-i32-f)
+  (func $const-i32-e (type $out-i32) (i32.const 69))
+  (func $const-i32-f (type $out-i32) (i32.const 70))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 69))
+(assert_return (invoke $module1 "call-9") (i32.const 70))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/imports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/imports.wast
new file mode 100644
index 0000000..d987775
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/imports.wast
@@ -0,0 +1,593 @@
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (table (export "table-10-inf") 10 funcref)
+  ;; (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    ;; JavaScript can't handle i64 yet.
+    ;; (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    ;; JavaScript can't handle i64 yet.
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table 10 20 funcref))
+  (elem (table 0) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table (import "spectest" "table") 10 20 funcref)
+  (elem (table 0) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(assert_invalid
+  (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref)))
+  "multiple tables"
+)
+(assert_invalid
+  (module (import "" "" (table 10 funcref)) (table 10 funcref))
+  "multiple tables"
+)
+(assert_invalid
+  (module (table 10 funcref) (table 10 funcref))
+  "multiple tables"
+)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/linking.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/linking.wast
new file mode 100644
index 0000000..2d92078
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/linking.wast
@@ -0,0 +1,392 @@
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (global.get $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (global.get $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 funcref)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table funcref (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (local.get 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 funcref)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
+
+(module
+  (table (import "Mt" "tab") 0 funcref)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (global.get 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 0 funcref)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "out of bounds"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+;; Unlike in the v1 spec, the elements stored before an out-of-bounds access
+;; persist after the instantiation failure.
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 12) $f)  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (memory 1)
+    (data (i32.const 0x10000) "d")  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "out of bounds"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+;; Unlike in v1 spec, bytes written before an out-of-bounds access persist
+;; after the instantiation failure.
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 0x50000) "d") ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 funcref)
+    (func)
+    (elem (i32.const 0) 0)  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+;; Store is modified if the start function traps.
+(module $Ms
+  (type $t (func (result i32)))
+  (memory (export "memory") 1)
+  (table (export "table") 1 funcref)
+  (func (export "get memory[0]") (type $t)
+    (i32.load8_u (i32.const 0))
+  )
+  (func (export "get table[0]") (type $t)
+    (call_indirect (type $t) (i32.const 0))
+  )
+)
+(register "Ms" $Ms)
+
+(assert_trap
+  (module
+    (import "Ms" "memory" (memory 1))
+    (import "Ms" "table" (table 1 funcref))
+    (data (i32.const 0) "hello")
+    (elem (i32.const 0) $f)
+    (func $f (result i32)
+      (i32.const 0xdead)
+    )
+    (func $main
+      (unreachable)
+    )
+    (start $main)
+  )
+  "unreachable"
+)
+
+(assert_return (invoke $Ms "get memory[0]") (i32.const 104))  ;; 'h'
+(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast
new file mode 100644
index 0000000..692e1ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_copy.wast
@@ -0,0 +1,5577 @@
+;;
+;; Generated by ../meta/generate_memory_copy.js
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 0) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65515) (i32.const 0) (i32.const 39))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 20))
+(assert_return (invoke "load8_u" (i32.const 219)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 418)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 617)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 816)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1015)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1214)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1413)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1612)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1811)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2010)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2209)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2408)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2607)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2806)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3005)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3204)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3403)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3602)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3801)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4000)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4199)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4398)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4597)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4796)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4995)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5194)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5393)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5592)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5791)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5990)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6189)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6388)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6587)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6786)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6985)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7184)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7383)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7582)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7781)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7980)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8179)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8378)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8577)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8776)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8975)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9174)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9373)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9572)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9771)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9970)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10169)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10368)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10567)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10766)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10965)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11164)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11363)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11562)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11761)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11960)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12159)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12358)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12557)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12756)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12955)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13154)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13353)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13552)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13751)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13950)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14149)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14348)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14547)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14746)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14945)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15144)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15343)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15542)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15741)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15940)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16139)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16338)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16537)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16736)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16935)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17134)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17333)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17532)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17731)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17930)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18129)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18328)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18527)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18726)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18925)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19124)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19323)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19522)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19721)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19920)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20119)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20318)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20517)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20716)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20915)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21114)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21313)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21512)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21711)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21910)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22109)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22308)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22507)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22706)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22905)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23104)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23303)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23502)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23701)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23900)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24099)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24298)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24497)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24696)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24895)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25094)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25293)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25492)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25691)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25890)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26089)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26288)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26487)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26686)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26885)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27084)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27283)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27482)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27681)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27880)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28079)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28278)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28477)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28676)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28875)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29074)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29273)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29472)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29671)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29870)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30069)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30268)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30467)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30666)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30865)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31064)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31263)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31462)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31661)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31860)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32059)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32258)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32457)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32656)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32855)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33054)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33253)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33452)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33651)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33850)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34049)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34248)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34447)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34646)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34845)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35044)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35243)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35442)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35641)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35840)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36039)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36238)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36437)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36636)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36835)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37034)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37233)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37432)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37631)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37830)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38029)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38228)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38427)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38626)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38825)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39024)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39223)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39422)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39621)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39820)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40019)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65515) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65515) (i32.const 39))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 20))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65486) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65486) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65487)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65488)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65489)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65492)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65493)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65494)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65495)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65496)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65497)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65498)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65499)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65500)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65501)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65502)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65503)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65504)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65505)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65486) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65506) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65506) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65507)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65508)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65509)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65510)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65511)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65512)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65513)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65514)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65506) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1  )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 4294963200))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 61440) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 61440) (i32.const 4294967040))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61440)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61441)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 61442)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 61443)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 61444)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 61445)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 61446)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 61447)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 61448)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 61449)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 61450)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 61451)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 61452)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 61453)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 61454)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 61455)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 61456)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 61457)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 61458)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 61459)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 9) (i32.const 10) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 9) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9) (i32.const 20) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 16) (i32.const 15) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 10) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+ (memory 1 1)
+ (func (export "test")
+   (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000))
+    (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000))
+    (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 32768) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32768) (i32.const 65536) (i32.const 170))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344))
+    (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055))
+    (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988))
+    (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322))
+    (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994))
+    (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036))
+    (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372))
+    (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835))
+    (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393))
+    (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758))
+    (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098))
+    (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741))
+    (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823))
+    (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280))
+    (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466))
+    (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158))
+    (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544))
+    (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669))
+    (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651))
+    (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570))
+    (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691))
+    (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646))
+    (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858))
+    (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657))
+    (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981))
+    (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807))
+    (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487))
+    (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530))
+    (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943))
+    (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381))
+    (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089))
+    (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658))
+    (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702))
+    (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092))
+    (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410))
+    (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204))
+    (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394))
+    (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250))
+    (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097))
+    (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264))
+    (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299))
+    (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796))
+    (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070))
+    (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763))
+    (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312))
+    (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192))
+    (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596))
+    (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501))
+    (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686))
+    (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385))
+    (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903))
+    (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390))
+    (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441))
+    (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162))
+    (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135))
+    (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519))
+    (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280))
+    (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678))
+    (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168))
+    (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441))
+    (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663))
+    (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671))
+    (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721))
+    (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84))
+    (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029))
+    (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29))
+    (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034))
+    (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043))
+    (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324))
+    (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091))
+    (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997))
+    (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259))
+    (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189))
+    (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968))
+    (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455))
+    (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177))
+    (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568))
+    (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642))
+    (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284))
+    (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223))
+    (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171))
+    (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322))
+    (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648))
+    (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045))
+    (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097))
+    (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796))
+    (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010))
+    (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0))
+    (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069))
+    (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896))
+    (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192))
+    (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195))
+    (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24))
+    (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577))
+    (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089))
+    (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436))
+    (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765))
+    (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830))
+    (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938))
+    (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750))
+    (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098))
+    (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230))
+    (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300))
+    (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639))
+    (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097))
+    (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197))
+    (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100))
+    (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717))
+    (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119))
+    (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658))
+    (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269))
+    (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833))
+    (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300))
+    (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281))
+    (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572))
+    (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328))
+    (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670))
+    (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33))
+    (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427))
+    (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434))
+    (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834))
+    (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317))
+    (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201))
+    (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452))
+    (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346))
+    (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430))
+    (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300))
+    (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153))
+    (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281))
+    (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943))
+    (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887))
+    (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738))
+    (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122))
+    (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755))
+    (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702))
+    (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830))
+    (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064))
+    (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631))
+    (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113))
+    (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975))
+    (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336))
+    (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872))
+    (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197))
+    (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958))
+    (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186))
+    (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037))
+    (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650))
+    (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986))
+    (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955))
+    (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368))
+    (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356))
+    (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382))
+    (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900))
+    (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807))
+    (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323))
+    (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670))
+    (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341))
+    (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644))
+    (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496))
+    (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784))
+    (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350))
+    (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475))
+    (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467))
+    (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895))
+    (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751))
+    (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127))
+    (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063))
+    (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766))
+    (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520))
+    (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014))
+    (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011))
+    (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034))
+    (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320))
+    (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308))
+    (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155))
+    (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722))
+    (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370))
+    (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926))
+    (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607))
+    (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045))
+    (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596))
+    (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168))
+    (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137))
+    (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649))
+    (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52))
+    (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441))
+    (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445))
+    (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785))
+    (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406))
+    (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381))
+    (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136))
+    (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045))
+    (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389))
+    (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877))
+    (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447))
+    (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854))
+    (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377))
+    (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594))
+    (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987))
+    (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406))
+  )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 124) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 124) (i32.const 1517) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1517) (i32.const 2132) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2132) (i32.const 2827) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2827) (i32.const 2921) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2921) (i32.const 3538) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3538) (i32.const 3786) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3786) (i32.const 4042) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4042) (i32.const 4651) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4651) (i32.const 5057) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5057) (i32.const 5109) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5109) (i32.const 5291) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5291) (i32.const 5524) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5524) (i32.const 5691) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5691) (i32.const 6552) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 6552) (i32.const 7133) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7133) (i32.const 7665) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7665) (i32.const 8314) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8314) (i32.const 8360) (i32.const 62))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8360) (i32.const 8793) (i32.const 86))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8793) (i32.const 8979) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8979) (i32.const 9373) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9373) (i32.const 9518) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9518) (i32.const 9934) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9934) (i32.const 10087) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10087) (i32.const 10206) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10206) (i32.const 10230) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10230) (i32.const 10249) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10249) (i32.const 11148) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11148) (i32.const 11356) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11356) (i32.const 11380) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11380) (i32.const 11939) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11939) (i32.const 12159) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12159) (i32.const 12575) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12575) (i32.const 12969) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12969) (i32.const 13114) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 13114) (i32.const 14133) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14133) (i32.const 14404) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14404) (i32.const 14428) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14428) (i32.const 14458) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14458) (i32.const 14580) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14580) (i32.const 14777) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14777) (i32.const 15124) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15124) (i32.const 15126) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15126) (i32.const 15192) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15192) (i32.const 15871) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15871) (i32.const 15998) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15998) (i32.const 17017) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17017) (i32.const 17288) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17288) (i32.const 17312) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17312) (i32.const 17342) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17342) (i32.const 17464) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17464) (i32.const 17661) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17661) (i32.const 17727) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17727) (i32.const 17733) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17733) (i32.const 17893) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17893) (i32.const 18553) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18553) (i32.const 18744) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18744) (i32.const 18801) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18801) (i32.const 18825) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18825) (i32.const 18876) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18876) (i32.const 18885) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18885) (i32.const 18904) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18904) (i32.const 19567) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 19567) (i32.const 20403) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20403) (i32.const 21274) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21274) (i32.const 21364) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21364) (i32.const 21468) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21468) (i32.const 21492) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21492) (i32.const 22051) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22051) (i32.const 22480) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22480) (i32.const 22685) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22685) (i32.const 22694) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22694) (i32.const 22821) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22821) (i32.const 22869) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22869) (i32.const 24107) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24107) (i32.const 24111) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24111) (i32.const 24236) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24236) (i32.const 24348) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24348) (i32.const 24515) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24515) (i32.const 24900) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24900) (i32.const 25136) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25136) (i32.const 25182) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25182) (i32.const 25426) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25426) (i32.const 25613) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25613) (i32.const 25830) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25830) (i32.const 26446) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26446) (i32.const 26517) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26517) (i32.const 27468) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27468) (i32.const 27503) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27503) (i32.const 27573) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27573) (i32.const 28245) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28245) (i32.const 28280) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28280) (i32.const 29502) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29502) (i32.const 29629) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29629) (i32.const 30387) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30387) (i32.const 30646) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30646) (i32.const 31066) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31066) (i32.const 31131) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31131) (i32.const 31322) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31322) (i32.const 31379) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31379) (i32.const 31403) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31403) (i32.const 31454) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31454) (i32.const 31463) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31463) (i32.const 31482) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31482) (i32.const 31649) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31649) (i32.const 31978) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31978) (i32.const 32145) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32145) (i32.const 32530) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32530) (i32.const 32766) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32766) (i32.const 32812) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32812) (i32.const 33056) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33056) (i32.const 33660) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33660) (i32.const 33752) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33752) (i32.const 33775) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33775) (i32.const 33778) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33778) (i32.const 34603) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 34603) (i32.const 35218) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35218) (i32.const 35372) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35372) (i32.const 35486) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35486) (i32.const 35605) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35605) (i32.const 35629) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35629) (i32.const 35648) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35648) (i32.const 36547) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36547) (i32.const 36755) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36755) (i32.const 36767) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36767) (i32.const 36810) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36810) (i32.const 36839) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36839) (i32.const 37444) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 37444) (i32.const 38060) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38060) (i32.const 38131) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38131) (i32.const 39082) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39082) (i32.const 39117) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39117) (i32.const 39187) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39187) (i32.const 39859) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39859) (i32.const 39894) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39894) (i32.const 40257) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40257) (i32.const 40344) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40344) (i32.const 40371) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40371) (i32.const 40804) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40804) (i32.const 40909) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40909) (i32.const 42259) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42259) (i32.const 42511) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42511) (i32.const 42945) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42945) (i32.const 43115) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43115) (i32.const 43306) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43306) (i32.const 43363) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43363) (i32.const 43387) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43387) (i32.const 43438) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43438) (i32.const 43447) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43447) (i32.const 43466) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43466) (i32.const 44129) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44129) (i32.const 44958) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44958) (i32.const 45570) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45570) (i32.const 45575) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45575) (i32.const 45640) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45640) (i32.const 45742) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45742) (i32.const 45832) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45832) (i32.const 45999) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45999) (i32.const 46384) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46384) (i32.const 46596) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46596) (i32.const 46654) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46654) (i32.const 47515) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47515) (i32.const 47620) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47620) (i32.const 47817) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47817) (i32.const 47951) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47951) (i32.const 48632) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48632) (i32.const 48699) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48699) (i32.const 48703) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48703) (i32.const 49764) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49764) (i32.const 49955) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49955) (i32.const 50012) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50012) (i32.const 50036) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50036) (i32.const 50087) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50087) (i32.const 50096) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50096) (i32.const 50115) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50115) (i32.const 50370) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50370) (i32.const 51358) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51358) (i32.const 51610) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51610) (i32.const 51776) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51776) (i32.const 51833) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51833) (i32.const 52895) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 52895) (i32.const 53029) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53029) (i32.const 53244) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53244) (i32.const 54066) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54066) (i32.const 54133) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54133) (i32.const 54137) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54137) (i32.const 55198) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55198) (i32.const 55389) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55389) (i32.const 55446) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55446) (i32.const 55470) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55470) (i32.const 55521) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55521) (i32.const 55530) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55530) (i32.const 55549) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55549) (i32.const 56212) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 56212) (i32.const 57048) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 57048) (i32.const 58183) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58183) (i32.const 58202) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58202) (i32.const 58516) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58516) (i32.const 58835) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58835) (i32.const 58855) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58855) (i32.const 59089) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59089) (i32.const 59145) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59145) (i32.const 59677) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59677) (i32.const 60134) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60134) (i32.const 60502) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60502) (i32.const 60594) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60594) (i32.const 60617) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60617) (i32.const 60618) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60618) (i32.const 60777) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60777) (i32.const 60834) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60834) (i32.const 60858) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60858) (i32.const 60909) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60909) (i32.const 60918) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60918) (i32.const 60937) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60937) (i32.const 61600) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 61600) (i32.const 62436) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 62436) (i32.const 63307) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63307) (i32.const 63397) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63397) (i32.const 63501) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63501) (i32.const 63525) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63525) (i32.const 63605) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63605) (i32.const 63704) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63704) (i32.const 63771) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63771) (i32.const 63775) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63775) (i32.const 64311) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64311) (i32.const 64331) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64331) (i32.const 64518) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64518) (i32.const 64827) (i32.const 11))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64827) (i32.const 64834) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64834) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast
new file mode 100644
index 0000000..caca80b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_fill.wast
@@ -0,0 +1,685 @@
+;;
+;; Generated by ../meta/generate_memory_fill.js
+;;
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65280) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65280) (i32.const 65536) (i32.const 85))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1) (i32.const 65535) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65535) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+     (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10))
+     (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 18) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 25) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25) (i32.const 28) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65280) (i32.const 37) (i32.const 512))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 514))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 4294967295))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast
new file mode 100644
index 0000000..60b6057
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/memory_init.wast
@@ -0,0 +1,967 @@
+;;
+;; Generated by ../meta/generate_memory_init.js
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (data.drop 1)
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (data.drop 3)
+    (memory.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (memory.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (memory.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (memory.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (memory.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+(assert_invalid
+   (module
+     (func (export "test")
+       (data.drop 0)))
+   "unknown data segment")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (data.drop 4)))
+  "unknown data segment")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (data.drop 0)))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+   (memory 1)
+   (data (i32.const 0) "\37")
+   (func (export "test")
+     (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown data segment 1")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 16))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65527) (i32.const 16))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65472) (i32.const 30))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65473) (i32.const 31))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 4294967040))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1)
+  ;; 65 data segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "") (data "") (data "") (data "") (data "") (data "") (data "") (data "")
+  (data "")
+  (func (memory.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast
new file mode 100644
index 0000000..d0aa77b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_copy.wast
@@ -0,0 +1,1595 @@
+;;
+;; Generated by ../meta/generate_table_copy.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 27)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 18)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 6))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 15) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 15) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 23)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 8))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 11)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 16)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 17)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 18)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 10))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 112)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 112)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 113)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 114)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 115)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 116)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 117)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 118)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 119)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 120)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 121)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 122)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 123)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 124)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 125)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 126)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 127)) (i32.const 15))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 15))
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast
new file mode 100644
index 0000000..90f86ac
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/bulk-memory-operations/table_init.wast
@@ -0,0 +1,1776 @@
+;;
+;; Generated by ../meta/generate_table_init.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (elem.drop 1)
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (elem.drop 3)
+    (table.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (table.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (table.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (table.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (table.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 21)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "check" (i32.const 24)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+(assert_invalid
+  (module
+    (func (export "test")
+      (elem.drop 0)))
+  "unknown elem segment 0")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (elem.drop 4)))
+  "unknown elem segment 4")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 2)
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))
+    (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (elem.drop 1)))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 2) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 2) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 24) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 25) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 96) (i32.const 32)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 97) (i32.const 31)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 64 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 48) (i32.const 4294967280)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 16 16 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 8) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+
+(module
+  (table 1 funcref)
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/array.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/array.wast
new file mode 100644
index 0000000..48a5810
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/array.wast
@@ -0,0 +1,144 @@
+;; Type syntax
+
+(module
+  (type (array i8))
+  (type (array i16))
+  (type (array i32))
+  (type (array i64))
+  (type (array f32))
+  (type (array f64))
+  (type (array anyref))
+  (type (array (ref data)))
+  (type (array (ref 0)))
+  (type (array (ref null 1)))
+  (type (array (rtt 1)))
+  (type (array (rtt 10 1)))
+  (type (array (mut i8)))
+  (type (array (mut i16)))
+  (type (array (mut i32)))
+  (type (array (mut i64)))
+  (type (array (mut i32)))
+  (type (array (mut i64)))
+  (type (array (mut anyref)))
+  (type (array (mut (ref data))))
+  (type (array (mut (ref 0))))
+  (type (array (mut (ref null i31))))
+  (type (array (mut (rtt 0))))
+  (type (array (mut (rtt 10 0))))
+)
+
+
+(assert_invalid
+  (module
+    (type (array (mut (ref null 10))))
+  )
+  "unknown type"
+)
+
+
+;; Binding structure
+
+(module
+  (type $s0 (array (ref $s1)))
+  (type $s1 (array (ref $s0)))
+
+  (func (param (ref $forward)))
+
+  (type $forward (array i32))
+)
+
+(assert_invalid
+  (module (type (array (ref 1))))
+  "unknown type"
+)
+(assert_invalid
+  (module (type (array (mut (ref 1)))))
+  "unknown type"
+)
+
+
+;; Basic instructions
+
+(module
+  (type $vec (array f32))
+  (type $mvec (array (mut f32)))
+
+  (func $get (param $i i32) (param $v (ref $vec)) (result f32)
+    (array.get $vec (local.get $v) (local.get $i))
+  )
+  (func (export "get") (param $i i32) (result f32)
+    (call $get (local.get $i)
+      (array.new_default $vec (i32.const 3) (rtt.canon $vec))
+    )
+  )
+
+  (func $set_get (param $i i32) (param $v (ref $mvec)) (param $y f32) (result f32)
+    (array.set $mvec (local.get $v) (local.get $i) (local.get $y))
+    (array.get $mvec (local.get $v) (local.get $i))
+  )
+  (func (export "set_get") (param $i i32) (param $y f32) (result f32)
+    (call $set_get (local.get $i)
+      (array.new_default $mvec (i32.const 3) (rtt.canon $mvec))
+      (local.get $y)
+    )
+  )
+
+  (func $len (param $v (ref $vec)) (result i32)
+    (array.len $vec (local.get $v))
+  )
+  (func (export "len") (result i32)
+    (call $len (array.new_default $vec (i32.const 3) (rtt.canon $vec)))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 0)) (f32.const 0))
+(assert_return (invoke "set_get" (i32.const 1) (f32.const 7)) (f32.const 7))
+(assert_return (invoke "len") (i32.const 3))
+
+(assert_trap (invoke "get" (i32.const 10)) "out of bounds")
+(assert_trap (invoke "set_get" (i32.const 10) (f32.const 7)) "out of bounds")
+
+(assert_invalid
+  (module
+    (type $a (array i64))
+    (func (export "array.set-immutable") (param $a (ref $a))
+      (array.set $a (local.get $a) (i32.const 0) (i64.const 1))
+    )
+  )
+  "array is immutable"
+)
+
+
+;; Null dereference
+
+(module
+  (type $t (array (mut i32)))
+  (func (export "array.get-null")
+    (local (ref null $t)) (drop (array.get $t (local.get 0) (i32.const 0)))
+  )
+  (func (export "array.set-null")
+    (local (ref null $t)) (array.set $t (local.get 0) (i32.const 0) (i32.const 0))
+  )
+)
+
+(assert_trap (invoke "array.get-null") "null array")
+(assert_trap (invoke "array.set-null") "null array")
+
+(assert_invalid
+  (module
+    (type $t (array i32))
+    (func (export "array.new-null")
+      (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 1) (i32.const 3) (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (array (mut i32)))
+    (func (export "array.new_default-null")
+      (local (ref null (rtt $t))) (drop (array.new_default $t (i32.const 3) (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/binary.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/binary.wast
new file mode 100644
index 0000000..1f76dc1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/binary.wast
@@ -0,0 +1,1765 @@
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
+
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+
+;; Malformed binary version.
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+;; Invalid section id.
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\0d\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\7f\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\80\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\81\00\01\00") "malformed section id")
+(assert_malformed (module binary "\00asm" "\01\00\00\00" "\ff\00\01\00") "malformed section id")
+
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\06\01"                          ;; Data section with 1 entry
+  "\00"                                ;; Memory index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\06\01"                          ;; Element section with 1 entry
+  "\00"                                ;; Table index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
+
+;; Data segment memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+
+;; Type section with signed LEB128 encoded type
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01"                     ;; Type section id
+    "\05"                     ;; Type section length
+    "\01"                     ;; Types vector length
+    "\e0\7f"                  ;; Malformed functype, -0x20 in signed LEB128 encoding
+    "\00\00"
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+;; memory.grow reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.size reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero byte expected"
+)
+
+;; Local number is unsigned 32 bit
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\80\80\80\80\10\7f"       ;; 0x100000000 i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Local number is unsigned 32 bit
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\80\80\80\80\10\7f"       ;; 0x100000000 i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; No more than 2^32-1 locals.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\06\01\60\02\7f\7f\00" ;; Type section: (param i32 i32)
+    "\03\02\01\00"             ;; Function section
+    "\0a\1c\01"                ;; Code section
+
+    ;; function 0
+    "\1a\04"
+    "\80\80\80\80\04\7f"       ;; 0x40000000 i32
+    "\80\80\80\80\04\7e"       ;; 0x40000000 i64
+    "\80\80\80\80\04\7d"       ;; 0x40000000 f32
+    "\80\80\80\80\04\7c"       ;; 0x40000000 f64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+;; Local count can be 0.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"     ;; Type section
+  "\03\02\01\00"           ;; Function section
+  "\0a\0a\01"              ;; Code section
+
+  ;; function 0
+  "\08\03"
+  "\00\7f"                 ;; 0 i32
+  "\00\7e"                 ;; 0 i64
+  "\02\7d"                 ;; 2 f32
+  "\0b"                    ;; end
+)
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)
+
+;; Fewer passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\03"                   ;; Datacount section with value "3"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; More passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\01"                   ;; Datacount section with value "1"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; memory.init requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0e\01"                ;; Code section
+
+    ;; function 0
+    "\0c\00"
+    "\41\00"                   ;; zero args
+    "\41\00"
+    "\41\00"
+    "\fc\08\00\00"             ;; memory.init
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; data.drop requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\fc\09\00"                ;; data.drop
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; passive element segment containing opcode other than ref.func or ref.null
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\70"                   ;; Passive, funcref
+    "\01"                      ;; 1 element
+    "\ff\00\0b"                ;; bad opcode, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "illegal opcode")
+
+;; passive element segment containing type other than funcref
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\7f"                   ;; Passive, i32
+    "\01"                      ;; 1 element
+    "\d2\00\0b"                ;; ref.func, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "malformed reference type")
+
+;; passive element segment containing opcode ref.func
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d2\00\0b"                ;; ref.func, index 0, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+;; passive element segment containing opcode ref.null
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d0\70\0b"                ;; ref.null, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+
+;; Type count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\01\00"                               ;; type count can be zero
+)
+
+;; 2 type declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\02"                             ;; type section with inconsistent count (2 declared, 1 given)
+    "\60\00\00"                             ;; 1st type
+    ;; "\60\00\00"                          ;; 2nd type (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 type declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01"                             ;; type section with inconsistent count (1 declared, 2 given)
+    "\60\00\00"                             ;; 1st type
+    "\60\00\00"                             ;; 2nd type (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Import count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                             ;; type section
+    "\60\01\7f\00"                          ;; type 0
+    "\02\01\00"                             ;; import count can be zero
+)
+
+;; Malformed import kind
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\04"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\04"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\05"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\05"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\04\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\80"                                 ;; malformed import kind
+  )
+  "malformed import kind"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\02\05\01"                           ;; import section with single entry
+      "\00"                                 ;; string length 0
+      "\00"                                 ;; string length 0
+      "\80"                                 ;; malformed import kind
+      "\00"                                 ;; dummy byte
+  )
+  "malformed import kind"
+)
+
+;; 2 import declared, 1 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\05\01"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\02\16\02"                           ;; import section with inconsistent count (2 declared, 1 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 import declared, 2 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\09\02"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\60\01\7d\00"                        ;; type 1
+      "\02\2b\01"                           ;; import section with inconsistent count (1 declared, 2 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (redundant)
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\66\33\32"         ;; print_f32
+      "\00\01"                              ;; import kind, import signature index
+  )
+  "section size mismatch"
+)
+
+;; Table count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\04\01\00"                             ;; table count can be zero
+)
+
+;; 1 table declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\01"                           ;; table section with inconsistent count (1 declared, 0 given)
+      ;; "\70\01\00\00"                     ;; table entity
+  )
+  "unexpected end of section or function"
+)
+
+;; Malformed table limits flag
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\03\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\02"                                 ;; malformed table limits flag
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\04\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\02"                                 ;; malformed table limits flag
+      "\00"                                 ;; dummy byte
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\06\01"                           ;; table section with one entry
+      "\70"                                 ;; anyfunc
+      "\81\00"                              ;; malformed table limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer too large"
+)
+
+;; Memory count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                             ;; memory count can be zero
+)
+
+;; 1 memory declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\01"                           ;; memory section with inconsistent count (1 declared, 0 given)
+      ;; "\00\00"                           ;; memory 0 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; Malformed memory limits flag
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\02\01"                           ;; memory section with one entry
+      "\02"                                 ;; malformed memory limits flag
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\03\01"                           ;; memory section with one entry
+      "\02"                                 ;; malformed memory limits flag
+      "\00"                                 ;; dummy byte
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\05\01"                           ;; memory section with one entry
+      "\81\00"                              ;; malformed memory limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\05\01"                           ;; memory section with one entry
+      "\81\01"                              ;; malformed memory limits flag as LEB128
+      "\00\00"                              ;; dummy bytes
+  )
+  "integer representation too long"
+)
+
+;; Global count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\01\00"                               ;; global count can be zero
+)
+
+;; 2 global declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\06\02"                             ;; global section with inconsistent count (2 declared, 1 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    ;; "\7f\00\41\00\0b"                    ;; global 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 global declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                             ;; global section with inconsistent count (1 declared, 2 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    "\7f\00\41\00\0b"                       ;; global 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Export count can be 0
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\03\02\00\00"                         ;; func section
+  "\07\01\00"                               ;; export count can be zero
+  "\0a\07\02"                               ;; code section
+  "\02\00\0b"                               ;; function body 0
+  "\02\00\0b"                               ;; function body 1
+)
+
+;; 2 export declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\06\02"                             ;; export section with inconsistent count (2 declared, 1 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    ;; "\02"                                ;; export 1 (missed)
+    ;; "\66\32"                             ;; export name
+    ;; "\00\01"                             ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 export declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\0b\01"                             ;; export section with inconsistent count (1 declared, 2 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    "\02"                                   ;; export 1 (redundant)
+    "\66\32"                                ;; export name
+    "\00\01"                                ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "section size mismatch"
+)
+
+;; elem segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\04\04\01"                               ;; table section
+  "\70\00\01"                               ;; table 0
+  "\09\01\00"                               ;; elem segment count can be zero
+  "\0a\04\01"                               ;; code section
+  "\02\00\0b"                               ;; function body
+)
+
+;; 2 elem segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    ;; "\00\41\00\0b\01\00"                 ;; elem 1 (missed)
+  )
+  "unexpected end"
+)
+
+;; 2 elem segment declared, 1.5 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00"                             ;; elem 1 (partial)
+    ;; "\0b\01\00"                          ;; elem 1 (missing part)
+  )
+  "unexpected end"
+)
+
+;; 1 elem segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\0d\01"                             ;; elem with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00\0b\01\00"                    ;; elem 1 (redundant)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "section size mismatch"
+)
+
+;; data segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                               ;; memory section
+  "\00\01"                                  ;; memory 0
+  "\0b\01\00"                               ;; data segment count can be zero
+)
+
+;; 2 data segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\07\02"                             ;; data with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    ;; "\00\41\01\0b\01\62"                 ;; data 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 data segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0d\01"                             ;; data with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    "\00\41\01\0b\01\62"                    ;; data 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; data segment has 7 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\03\0b"                          ;; data segment 0
+    "\07"                                   ;; data segment size with inconsistent lengths (7 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "unexpected end of section or function"
+)
+
+;; data segment has 5 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\00\0b"                          ;; data segment 0
+    "\05"                                   ;; data segment size with inconsistent lengths (5 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "section size mismatch"
+)
+
+;; br_table target count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\0a\11\01"                               ;; code section
+  "\0f\00"                                  ;; func 0
+  "\02\40"                                  ;; block 0
+  "\41\01"                                  ;; condition of if 0
+  "\04\40"                                  ;; if 0
+  "\41\01"                                  ;; index of br_table element
+  "\0e\00"                                  ;; br_table target count can be zero
+  "\02"                                     ;; break depth for default
+  "\0b\0b\0b"                               ;; end
+)
+
+;; 1 br_table target declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\11\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
+    "\00"                                   ;; break depth 0
+    "\01"                                   ;; break depth 1
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end of section or function"
+)
+
+;; Start section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"       ;; Type section
+  "\03\02\01\00"             ;; Function section
+  "\08\01\00"                ;; Start section: function 0
+
+  "\0a\04\01"                ;; Code section
+  ;; function 0
+  "\02\00"
+  "\0b"                      ;; end
+)
+
+;; Multiple start sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\08\01\00"                ;; Start section: function 0
+    "\08\01\00"                ;; Start section: function 0
+
+    "\0a\04\01"                ;; Code section
+    ;; function 0
+    "\02\00"
+    "\0b"                      ;; end
+  )
+  "junk after last section"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on.wast
new file mode 100644
index 0000000..370eb93
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on.wast
@@ -0,0 +1,92 @@
+(module
+  (type $ft (func (result i32)))
+  (type $st (struct (field i16)))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f (result i32) (i32.const 9))
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (i31.new (i32.const 7)))
+    (table.set (i32.const 2) (struct.new $st (i32.const 6) (rtt.canon $st)))
+    (table.set (i32.const 3) (array.new $at (i32.const 5) (i32.const 1) (rtt.canon $at)))
+    (table.set (i32.const 4) (ref.func $f))
+    (table.set (i32.const 5) (rtt.canon $ft))
+    (table.set (i32.const 6) (local.get $x))
+  )
+
+  (func (export "br_on_null") (param $i i32) (result i32)
+    (block $l
+      (br_on_null $l (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (i32.const 0)
+  )
+  (func (export "br_on_i31") (param $i i32) (result i32)
+    (block $l (result (ref i31))
+      (br_on_i31 $l (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (i31.get_u)
+  )
+  (func (export "br_on_data") (param $i i32) (result i32)
+    (block $l (result (ref data))
+      (br_on_data $l (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (block $l2 (param dataref) (result (ref $st))
+      (block $l3 (param dataref) (result (ref $at))
+        (br_on_cast $l2 (rtt.canon $st))
+        (br_on_cast $l3 (rtt.canon $at))
+        (return (i32.const -2))
+      )
+      (return (array.get_u $at (i32.const 0)))
+    )
+    (struct.get_s $st 0)
+  )
+  (func (export "br_on_func") (param $i i32) (result i32)
+    (block $l (result (ref func))
+      (br_on_func $l (table.get (local.get $i)))
+      (return (i32.const -1))
+    )
+    (ref.cast (rtt.canon $ft))
+    (call_ref)
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "br_on_null" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "br_on_null" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 4)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 5)) (i32.const -1))
+(assert_return (invoke "br_on_null" (i32.const 6)) (i32.const -1))
+
+(assert_return (invoke "br_on_i31" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "br_on_i31" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 4)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 5)) (i32.const -1))
+(assert_return (invoke "br_on_i31" (i32.const 6)) (i32.const -1))
+
+(assert_return (invoke "br_on_data" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_data" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_data" (i32.const 2)) (i32.const 6))
+(assert_return (invoke "br_on_data" (i32.const 3)) (i32.const 5))
+(assert_return (invoke "br_on_data" (i32.const 4)) (i32.const -1))
+(assert_return (invoke "br_on_data" (i32.const 5)) (i32.const -1))
+(assert_return (invoke "br_on_data" (i32.const 6)) (i32.const -1))
+
+(assert_return (invoke "br_on_func" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "br_on_func" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "br_on_func" (i32.const 2)) (i32.const -1))
+(assert_return (invoke "br_on_func" (i32.const 3)) (i32.const -1))
+(assert_return (invoke "br_on_func" (i32.const 4)) (i32.const 9))
+(assert_return (invoke "br_on_func" (i32.const 5)) (i32.const -1))
+(assert_return (invoke "br_on_func" (i32.const 6)) (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_cast.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_cast.wast
new file mode 100644
index 0000000..89ebc60
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_cast.wast
@@ -0,0 +1,110 @@
+(module
+  (type $t0 (struct))
+  (type $t1 (struct (field i32)))
+  (type $t1' (struct (field i32)))
+  (type $t2 (struct (field i32 i32)))
+  (type $t2' (struct (field i32 i32)))
+  (type $t3 (struct (field i32 i32)))
+
+  (global $t0 (rtt $t0) (rtt.canon $t0))
+  (global $t0' (rtt $t0) (rtt.canon $t0))
+  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
+  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
+  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
+  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
+  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
+  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
+
+  (table 20 dataref)
+
+  (func $init
+    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
+    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
+    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
+    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
+    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
+    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
+    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
+    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+  )
+
+  (func (export "test-sub")
+    (call $init)
+    (block $l (result dataref)
+      ;; must succeed
+      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0))))
+
+      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t1))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1))))
+
+      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t2))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2))))
+
+      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t3))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t3))))
+
+      (drop (block (result dataref) (br_on_cast 0 (ref.null data) (global.get $t4))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t4))))
+
+      ;; must not succeed
+      (br_on_cast $l (table.get (i32.const 0)) (global.get $t1))
+      (br_on_cast $l (table.get (i32.const 3)) (global.get $t1))
+      (br_on_cast $l (table.get (i32.const 4)) (global.get $t1))
+
+      (br_on_cast $l (table.get (i32.const 0)) (global.get $t2))
+      (br_on_cast $l (table.get (i32.const 1)) (global.get $t2))
+      (br_on_cast $l (table.get (i32.const 3)) (global.get $t2))
+      (br_on_cast $l (table.get (i32.const 4)) (global.get $t2))
+
+      (br_on_cast $l (table.get (i32.const 0)) (global.get $t3))
+      (br_on_cast $l (table.get (i32.const 1)) (global.get $t3))
+      (br_on_cast $l (table.get (i32.const 2)) (global.get $t3))
+      (br_on_cast $l (table.get (i32.const 4)) (global.get $t3))
+
+      (br_on_cast $l (table.get (i32.const 0)) (global.get $t4))
+      (br_on_cast $l (table.get (i32.const 1)) (global.get $t4))
+      (br_on_cast $l (table.get (i32.const 2)) (global.get $t4))
+      (br_on_cast $l (table.get (i32.const 3)) (global.get $t4))
+
+      (return)
+    )
+    (unreachable)
+  )
+
+  (func (export "test-canon")
+    (call $init)
+    (block $l
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 0)) (global.get $t0'))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t0'))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t0'))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 3)) (global.get $t0'))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 4)) (global.get $t0'))))
+
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 10)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t0))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t0))))
+
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 1)) (global.get $t1'))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t1'))))
+
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 11)) (global.get $t1))))
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t1))))
+
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 2)) (global.get $t2'))))
+
+      (drop (block (result dataref) (br_on_cast 0 (table.get (i32.const 12)) (global.get $t2))))
+
+      (return)
+    )
+    (unreachable)
+  )
+)
+
+(invoke "test-sub")
+(invoke "test-canon")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_null.wast
new file mode 100644
index 0000000..3bae850
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_on_null.wast
@@ -0,0 +1,75 @@
+(module
+  (type $t (func (result i32)))
+
+  (func $nn (param $r (ref $t)) (result i32)
+    (block $l
+      (return (call_ref (br_on_null $l (local.get $r))))
+    )
+    (i32.const -1)
+  )
+  (func $n (param $r (ref null $t)) (result i32)
+    (block $l
+      (return (call_ref (br_on_null $l (local.get $r))))
+    )
+    (i32.const -1)
+  )
+
+  (elem func $f)
+  (func $f (result i32) (i32.const 7))
+
+  (func (export "nullable-null") (result i32) (call $n (ref.null $t)))
+  (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f)))
+  (func (export "nullable-f") (result i32) (call $n (ref.func $f)))
+
+  (func (export "unreachable") (result i32)
+    (block $l
+      (return (call_ref (br_on_null $l (unreachable))))
+    )
+    (i32.const -1)
+  )
+)
+
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_return (invoke "nullable-null") (i32.const -1))
+(assert_return (invoke "nonnullable-f") (i32.const 7))
+(assert_return (invoke "nullable-f") (i32.const 7))
+
+(assert_invalid
+  (module
+    (type $t (func (result i32)))
+    (func $g (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
+    (func (call $g (ref.null $t)))
+  )
+  "type mismatch"
+)
+
+(module
+  (type $t (func))
+  (func (param $r (ref $t)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref func)) (drop (br_on_null 0 (local.get $r))))
+  (func (param $r (ref extern)) (drop (br_on_null 0 (local.get $r))))
+)
+
+
+(module
+  (type $t (func (param i32) (result i32)))
+  (elem func $f)
+  (func $f (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+
+  (func $a (param $n i32) (param $r (ref null $t)) (result i32)
+    (block $l (result i32)
+      (return (call_ref (br_on_null $l (local.get $n) (local.get $r))))
+    )
+  )
+
+  (func (export "args-null") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.null $t))
+  )
+  (func (export "args-f") (param $n i32) (result i32)
+    (call $a (local.get $n) (ref.func $f))
+  )
+)
+
+(assert_return (invoke "args-null" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "args-f" (i32.const 3)) (i32.const 9))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_table.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_table.wast
new file mode 100644
index 0000000..33650e2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/br_table.wast
@@ -0,0 +1,1728 @@
+;; Test `br_table` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_table 0 0 (i32.const 0)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
+  )
+
+  (func (export "empty") (param i32) (result i32)
+    (block (br_table 0 (local.get 0)) (return (i32.const 21)))
+    (i32.const 22)
+  )
+  (func (export "empty-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31)
+    )
+  )
+
+  (func (export "singleton") (param i32) (result i32)
+    (block
+      (block
+        (br_table 1 0 (local.get 0))
+        (return (i32.const 21))
+      )
+      (return (i32.const 20))
+    )
+    (i32.const 22)
+  )
+
+  (func (export "singleton-value") (param i32) (result i32)
+    (block (result i32)
+      (drop
+        (block (result i32)
+          (br_table 0 1 (i32.const 33) (local.get 0))
+          (return (i32.const 31))
+        )
+      )
+      (i32.const 32)
+    )
+  )
+
+  (func (export "multiple") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (block
+            (block
+              (br_table 3 2 1 0 4 (local.get 0))
+              (return (i32.const 99))
+            )
+            (return (i32.const 100))
+          )
+          (return (i32.const 101))
+        )
+        (return (i32.const 102))
+      )
+      (return (i32.const 103))
+    )
+    (i32.const 104)
+  )
+
+  (func (export "multiple-value") (param i32) (result i32)
+    (local i32)
+    (local.set 1 (block (result i32)
+      (local.set 1 (block (result i32)
+        (local.set 1 (block (result i32)
+          (local.set 1 (block (result i32)
+            (local.set 1 (block (result i32)
+              (br_table 3 2 1 0 4 (i32.const 200) (local.get 0))
+              (return (i32.add (local.get 1) (i32.const 99)))
+            ))
+            (return (i32.add (local.get 1) (i32.const 10)))
+          ))
+          (return (i32.add (local.get 1) (i32.const 11)))
+        ))
+        (return (i32.add (local.get 1) (i32.const 12)))
+      ))
+      (return (i32.add (local.get 1) (i32.const 13)))
+    ))
+    (i32.add (local.get 1) (i32.const 14))
+  )
+
+  (func (export "large") (param i32) (result i32)
+    (block
+      (block
+        (br_table
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          (local.get 0)
+        )
+        (return (i32.const -1))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+
+  (func (export "as-block-first")
+    (block (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0)))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32)
+      (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0))
+    )
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (br_table 1 1 1 (i32.const 4) (i32.const -1))
+      (i32.const 2)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_table 0 0 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0))))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_table 0 (i32.const 1))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_table 0 (i32.const 2) (i32.const 0))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (br_table 1 (i32.const 3) (i32.const 0)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (local.get 1))
+        (else (br_table 1 0 (i32.const 4) (i32.const 0)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1))
+      )
+    )
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1))
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (i32.const 2)
+        (br_table 0 (i32.const 23) (i32.const 1))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (result i32)
+    (local f32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 17) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32)
+      (global.set $a (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1)))
+      (i32.const -1)
+     )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0)))
+      (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10))
+    )
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64)
+      (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10))
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (i32.const -1))
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (i32.add
+            (i32.const 2)
+            (block (result i32)
+              (drop (i32.const 4))
+              (i32.add
+                (i32.const 8)
+                (br_table 0 1 2 (i32.const 16) (local.get 0))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0)))
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (drop
+                (br_if 0
+                  (br_table 0 1 2 (i32.const 8) (local.get 0))
+                  (i32.const 1)
+                )
+              )
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1))
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-loop-block") (param i32) (result i32)
+    (local.set 0
+      (loop (result i32)
+        (block
+          (br_table 1 0 0 (local.get 0))
+        )
+        (i32.const 0)
+      )
+    )
+    (loop (result i32)
+      (block
+        (br_table 0 1 1 (local.get 0))
+      )
+      (i32.const 3)
+    )
+  )
+
+  (func (export "meet-externref") (param i32) (param externref) (result externref)
+    (block $l1 (result externref)
+      (block $l2 (result externref)
+        (br_table $l1 $l2 $l1 (local.get 1) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-bottom")
+    (block (result f64)
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 1 (i32.const 1))
+      )
+      (drop)
+      (f64.const 0)
+    )
+    (drop)
+  )
+
+  (type $t (func))
+  (func $tf)
+  (table $t (ref null $t) (elem $tf))
+  (func (export "meet-funcref-1") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (br_table $l1 $l1 $l2 (table.get $t (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-2") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (br_table $l2 $l2 $l1 (table.get $t (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-3") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (br_table $l2 $l1 $l2 (table.get $t (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-4") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (br_table $l1 $l2 $l1 (table.get $t (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-nullref") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (br_table $l1 $l2 $l1 (ref.null $t) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-multi-ref") (param i32) (result (ref null func))
+    (block $l1 (result (ref null func))
+      (block $l2 (result (ref null $t))
+        (block $l3 (result (ref $t))
+          (br_table $l3 $l2 $l1 (ref.func $tf) (local.get 0))
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "empty" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 11)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -100)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22))
+
+(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20))
+
+(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103))
+(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102))
+(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101))
+(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100))
+(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104))
+
+(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213))
+(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212))
+(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211))
+(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210))
+(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214))
+
+(assert_return (invoke "large" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 101)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 10000)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 10001)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 20))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 21))
+(assert_return (invoke "as-call_indirect-last") (i32.const 22))
+(assert_return (invoke "as-call_indirect-func") (i32.const 23))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19))
+(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17))
+(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16))
+
+(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17))
+
+(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "meet-externref" (i32.const 0) (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "meet-externref" (i32.const 1) (ref.extern 1)) (ref.extern 1))
+(assert_return (invoke "meet-externref" (i32.const 2) (ref.extern 1)) (ref.extern 1))
+
+(assert_return (invoke "meet-funcref-1" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-1" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-1" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 2)) (ref.func))
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-empty-vs-num (result i32)
+    (block (br_table 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-num (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-arg-num
+    (block
+      (block (result f32)
+        (br_table 0 1 (f32.const 0) (i32.const 0))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func
+    (block (result i32)
+      (block (result i64)
+        (br_table 0 1 (i32.const 0) (i32.const 0))
+      )
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-index-void-vs-i32
+    (block (br_table 0 0 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-index-num-vs-i32
+    (block (br_table 0 (i64.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-void-vs-i32 (result i32)
+    (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-num-vs-i32 (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-return
+      (block (result i32)
+        (return (br_table 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-return
+      (block (result i32)
+        (return (br_table 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func (param i32) (result i32)
+      (loop (result i32)
+        (block (result i32)
+          (br_table 0 1 (i32.const 1) (local.get 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (param i32) (result i32)
+      (block (result i32)
+        (loop (result i32)
+          (br_table 0 1 (i32.const 1) (local.get 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result externref)
+    (block $l1 (result externref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null extern) (local.get 0))
+        )
+      )
+      (ref.null extern)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $unbound-label
+    (block (br_table 2 1 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label
+    (block (br_table 0 0x10000001 0 (i32.const 1)))
+  ))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $unbound-label-default
+    (block (br_table 1 2 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label-default
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label-default
+    (block (br_table 0 0 0x10000001 (i32.const 1)))
+  ))
+  "unknown label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/call_ref.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/call_ref.wast
new file mode 100644
index 0000000..503c4e8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/call_ref.wast
@@ -0,0 +1,202 @@
+(module
+  (type $ii (func (param i32) (result i32)))
+
+  (func $apply (param $f (ref $ii)) (param $x i32) (result i32)
+    (call_ref (local.get $x) (local.get $f))
+  )
+
+  (func $f (type $ii) (i32.mul (local.get 0) (local.get 0)))
+  (func $g (type $ii) (i32.sub (i32.const 0) (local.get 0)))
+
+  (elem declare func $f $g)
+
+  (func (export "run") (param $x i32) (result i32)
+    (local $rf (ref null $ii))
+    (local $rg (ref null $ii))
+    (local.set $rf (ref.func $f))
+    (local.set $rg (ref.func $g))
+    (call_ref (call_ref (local.get $x) (local.get $rf)) (local.get $rg))
+  )
+
+  (func (export "null") (result i32)
+    (call_ref (i32.const 1) (ref.null $ii))
+  )
+
+  ;; Recursion
+
+  (type $ll (func (param i64) (result i64)))
+  (type $lll (func (param i64 i64) (result i64)))
+
+  (elem declare func $fac)
+  (global $fac (ref $ll) (ref.func $fac))
+
+  (func $fac (export "fac") (type $ll)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fac))
+        )
+      )
+    )
+  )
+
+  (elem declare func $fac-acc)
+  (global $fac-acc (ref $lll) (ref.func $fac-acc))
+
+  (func $fac-acc (export "fac-acc") (type $lll)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (call_ref
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+          (global.get $fac-acc)
+        )
+      )
+    )
+  )
+
+  (elem declare func $fib)
+  (global $fib (ref $ll) (ref.func $fib))
+
+  (func $fib (export "fib") (type $ll)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_ref (i64.sub (local.get 0) (i64.const 2)) (global.get $fib))
+          (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $fib))
+        )
+      )
+    )
+  )
+
+  (elem declare func $even $odd)
+  (global $even (ref $ll) (ref.func $even))
+  (global $odd (ref $ll) (ref.func $odd))
+
+  (func $even (export "even") (type $ll)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 44))
+      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $odd)))
+    )
+  )
+  (func $odd (export "odd") (type $ll)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 99))
+      (else (call_ref (i64.sub (local.get 0) (i64.const 1)) (global.get $even)))
+    )
+  )
+)
+
+(assert_return (invoke "run" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "run" (i32.const 3)) (i32.const -9))
+
+(assert_trap (invoke "null") "null function")
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "even" (i64.const 0)) (i64.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i64.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i64.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i64.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i64.const 44))
+
+
+;; Unreachable typing.
+
+(module
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (call_ref)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(module
+  (elem declare func $f)
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (ref.func $f)
+    (call_ref)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(module
+  (elem declare func $f)
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (i32.const 0)
+    (ref.func $f)
+    (call_ref)
+    (drop)
+    (i32.const 0)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_invalid
+  (module
+    (elem declare func $f)
+    (func $f (param i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result i32)
+      (unreachable)
+      (i64.const 0)
+      (ref.func $f)
+      (call_ref)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (elem declare func $f)
+    (func $f (param i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result i32)
+      (unreachable)
+      (ref.func $f)
+      (call_ref)
+      (drop)
+      (i64.const 0)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f (param $r externref)
+      (call_ref (local.get $r))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func.wast
new file mode 100644
index 0000000..a5e0ec7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func.wast
@@ -0,0 +1,988 @@
+;; Test `func` declarations, i.e. functions
+
+(module
+  ;; Auxiliary definition
+  (type $sig (func))
+  (func $dummy)
+
+  ;; Syntax
+
+  (func)
+  (func (export "f"))
+  (func $f)
+  (func $h (export "g"))
+
+  (func (local))
+  (func (local) (local))
+  (func (local i32))
+  (func (local $x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param) (param))
+  (func (param i32))
+  (func (param $x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $x i64) (param) (param i32 f64))
+
+  (func (result))
+  (func (result) (result))
+  (func (result i32) (unreachable))
+  (func (result i32 f64 f32) (unreachable))
+  (func (result i32) (result f64) (unreachable))
+  (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable))
+
+  (type $sig-1 (func))
+  (type $sig-2 (func (result i32)))
+  (type $sig-3 (func (param $x i32)))
+  (type $sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $sig-1))
+  (func (export "type-use-2") (type $sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $sig-3))
+  (func (export "type-use-4") (type $sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
+  (func (type $sig))
+  (func (type $forward))  ;; forward reference
+
+  (func $complex
+    (param i32 f32) (param $x i64) (param) (param i32)
+    (result) (result i32) (result) (result i64 i32)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $complex-sig
+    (type $sig)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+  (type $forward (func))
+
+  ;; Typing of locals
+
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
+  (func (export "local-mixed") (result f64)
+    (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of parameters
+
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
+  (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32)
+    (result f64)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of results
+
+  (func (export "empty"))
+  (func (export "value-void") (call $dummy))
+  (func (export "value-i32") (result i32) (i32.const 77))
+  (func (export "value-i64") (result i64) (i64.const 7777))
+  (func (export "value-f32") (result f32) (f32.const 77.7))
+  (func (export "value-f64") (result f64) (f64.const 77.77))
+  (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7))
+  (func (export "value-i32-i32-i32") (result i32 i32 i32)
+    (i32.const 1) (i32.const 2) (i32.const 3)
+  )
+  (func (export "value-block-void") (block (call $dummy) (call $dummy)))
+  (func (export "value-block-i32") (result i32)
+    (block (result i32) (call $dummy) (i32.const 77))
+  )
+  (func (export "value-block-i32-i64") (result i32 i64)
+    (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))
+  )
+
+  (func (export "return-empty") (return))
+  (func (export "return-i32") (result i32) (return (i32.const 78)))
+  (func (export "return-i64") (result i64) (return (i64.const 7878)))
+  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
+  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
+  (func (export "return-i32-f64") (result i32 f64)
+    (return (i32.const 78) (f64.const 78.78))
+  )
+  (func (export "return-i32-i32-i32") (result i32 i32 i32)
+    (return (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "return-block-i32") (result i32)
+    (return (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "return-block-i32-i64") (result i32 i64)
+    (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-empty") (br 0))
+  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
+  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
+  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
+  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
+  (func (export "break-i32-f64") (result i32 f64)
+    (br 0 (i32.const 79) (f64.const 79.79))
+  )
+  (func (export "break-i32-i32-i32") (result i32 i32 i32)
+    (br 0 (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "break-block-i32") (result i32)
+    (br 0 (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "break-block-i32-i64") (result i32 i64)
+    (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-br_if-empty") (param i32)
+    (br_if 0 (local.get 0))
+  )
+  (func (export "break-br_if-num") (param i32) (result i32)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
+  )
+  (func (export "break-br_if-num-num") (param i32) (result i32 i64)
+    (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0))))
+    (i32.const 51) (i64.const 52)
+  )
+
+  (func (export "break-br_table-empty") (param i32)
+    (br_table 0 0 0 (local.get 0))
+  )
+  (func (export "break-br_table-num") (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
+  )
+  (func (export "break-br_table-num-num") (param i32) (result f32 i64)
+    (br_table 0 0 (f32.const 50) (i64.const 51) (local.get 0))
+    (f32.const 51) (i64.const 52)
+  )
+  (func (export "break-br_table-nested-empty") (param i32)
+    (block (br_table 0 1 0 (local.get 0)))
+  )
+  (func (export "break-br_table-nested-num") (param i32) (result i32)
+    (i32.add
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
+      )
+      (i32.const 2)
+    )
+  )
+  (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32)
+    (i32.add
+      (block (result i32 i32)
+        (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0))
+        (i32.const 51) (i32.const -3)
+      )
+    )
+    (i32.const 52)
+  )
+
+  ;; Large signatures
+
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+
+  ;; Default initialization of locals
+
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
+)
+
+(assert_return (invoke "type-use-1"))
+(assert_return (invoke "type-use-2") (i32.const 0))
+(assert_return (invoke "type-use-3" (i32.const 1)))
+(assert_return
+  (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+(assert_return (invoke "type-use-5") (i32.const 0))
+(assert_return (invoke "type-use-6" (i32.const 1)))
+(assert_return
+  (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+
+(assert_return (invoke "local-first-i32") (i32.const 0))
+(assert_return (invoke "local-first-i64") (i64.const 0))
+(assert_return (invoke "local-first-f32") (f32.const 0))
+(assert_return (invoke "local-first-f64") (f64.const 0))
+(assert_return (invoke "local-second-i32") (i32.const 0))
+(assert_return (invoke "local-second-i64") (i64.const 0))
+(assert_return (invoke "local-second-f32") (f32.const 0))
+(assert_return (invoke "local-second-f64") (f64.const 0))
+(assert_return (invoke "local-mixed") (f64.const 0))
+
+(assert_return
+  (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)
+)
+(assert_return
+  (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)
+)
+(assert_return
+  (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)
+)
+(assert_return
+  (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)
+)
+(assert_return
+  (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)
+)
+(assert_return
+  (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)
+)
+(assert_return
+  (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)
+)
+(assert_return
+  (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)
+)
+
+(assert_return
+  (invoke "param-mixed"
+    (f32.const 1) (i32.const 2) (i64.const 3)
+    (i32.const 4) (f64.const 5.5) (i32.const 6)
+  )
+  (f64.const 5.5)
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "value-void"))
+(assert_return (invoke "value-i32") (i32.const 77))
+(assert_return (invoke "value-i64") (i64.const 7777))
+(assert_return (invoke "value-f32") (f32.const 77.7))
+(assert_return (invoke "value-f64") (f64.const 77.77))
+(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7))
+(assert_return (invoke "value-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "value-block-void"))
+(assert_return (invoke "value-block-i32") (i32.const 77))
+(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "return-empty"))
+(assert_return (invoke "return-i32") (i32.const 78))
+(assert_return (invoke "return-i64") (i64.const 7878))
+(assert_return (invoke "return-f32") (f32.const 78.7))
+(assert_return (invoke "return-f64") (f64.const 78.78))
+(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78))
+(assert_return (invoke "return-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "return-block-i32") (i32.const 77))
+(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-empty"))
+(assert_return (invoke "break-i32") (i32.const 79))
+(assert_return (invoke "break-i64") (i64.const 7979))
+(assert_return (invoke "break-f32") (f32.const 79.9))
+(assert_return (invoke "break-f64") (f64.const 79.79))
+(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79))
+(assert_return (invoke "break-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "break-block-i32") (i32.const 77))
+(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-br_if-empty" (i32.const 0)))
+(assert_return (invoke "break-br_if-empty" (i32.const 2)))
+(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
+(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_if-num-num" (i32.const 0))
+  (i32.const 51) (i64.const 52)
+)
+(assert_return (invoke "break-br_if-num-num" (i32.const 1))
+  (i32.const 50) (i64.const 51)
+)
+
+(assert_return (invoke "break-br_table-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-empty" (i32.const 5)))
+(assert_return (invoke "break-br_table-empty" (i32.const -1)))
+(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
+(assert_return (invoke "break-br_table-num-num" (i32.const 0))
+  (f32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 1))
+  (f32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 10))
+  (f32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const -100))
+  (f32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 3)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const -2)))
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 0))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 1))
+  (i32.const 50) (i32.const 51)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 2))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const -3))
+  (i32.const 101) (i32.const 52)
+)
+
+(assert_return
+  (invoke "large-sig"
+    (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3)
+    (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7)
+    (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11)
+    (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15)
+    (f32.const 16)
+  )
+  (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8)
+  (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9)
+  (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11)
+  (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12)
+)
+
+(assert_return (invoke "init-local-i32") (i32.const 0))
+(assert_return (invoke "init-local-i64") (i64.const 0))
+(assert_return (invoke "init-local-f32") (f32.const 0))
+(assert_return (invoke "init-local-f64") (f64.const 0))
+
+
+;; Expansion of inline function types
+
+(module
+  (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $g (param i32))                 ;; reuses explicit type definition
+  (type $t (func (param i32)))
+
+  (func $i32->void (type 0))                ;; (param i32)
+  (func $void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $check
+    (call $i32->void (i32.const 0))
+    (drop (call $void->f64))
+  )
+)
+
+(assert_invalid
+  (module
+    (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $g (param i32))                 ;; reuses explicit type definition
+    (func $h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )
+  "unknown type"
+)
+
+(assert_malformed
+  (module quote
+    "(func $f (result f64) (f64.const 0))"  ;; adds implicit type definition
+    "(func $g (param i32))"                 ;; reuses explicit type definition
+    "(func $h (result f64) (f64.const 1))"  ;; reuses implicit type definition
+    "(type $t (func (param i32)))"
+
+    "(func (type 2) (param i32))"  ;; does not exist
+  )
+  "unknown type"
+)
+
+(module
+  (type $proc (func (result i32)))
+  (type $sig (func (param i32) (result i32)))
+
+  (func (export "f") (type $sig)
+    (local $var i32)
+    (local.get $var)
+  )
+
+  (func $g (type $sig)
+    (local $var i32)
+    (local.get $var)
+  )
+  (func (export "g") (type $sig)
+    (call $g (local.get 0))
+  )
+
+  (func (export "p") (type $proc)
+    (local $var i32)
+    (local.set 0 (i32.const 42))
+    (local.get $var)
+  )
+)
+
+(assert_return (invoke "f" (i32.const 42)) (i32.const 0))
+(assert_return (invoke "g" (i32.const 42)) (i32.const 0))
+(assert_return (invoke "p") (i32.const 42))
+
+
+(module
+  (type $sig (func))
+
+  (func $empty-sig-1)  ;; should be assigned type $sig
+  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $empty-sig-2)  ;; should be assigned type $sig
+  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $empty-sig-duplicate (func))
+  (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table funcref
+    (elem
+      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
+      $complex-sig-4 $complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect (type $sig) (i32.const 1))
+    (call_indirect (type $sig) (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect (type $empty-sig-duplicate) (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)
+
+(assert_return (invoke "signature-explicit-reused"))
+(assert_return (invoke "signature-implicit-reused"))
+(assert_return (invoke "signature-explicit-duplicate"))
+(assert_return (invoke "signature-implicit-duplicate"))
+
+
+;; Malformed type use
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (type $sig) (result i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (result i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (type $sig) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (param i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (param i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (type $sig) (param i32) (result i32) (unreachable))"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module (func $g (type 4)))
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (func $f (drop (ref.func $g)))
+    (func $g (type 4))
+    (elem declare func $g)
+  )
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (drop (let (result (ref $t)) (ref.func $g))))
+    (func $g (type 4))
+    (elem declare func $g)
+  )
+  "unknown type"
+)
+
+
+;; Invalid typing of locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (type $t (func)) (func $type-local-no-default (local (ref $t))))
+  "non-defaultable local type"
+)
+
+
+;; Invalid typing of parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of result
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64-i32 (result f64 i32)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-void
+    (i32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (i32.const 0) (i64.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result f32 f32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result f32)
+    (f32.const 0) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-last-empty-vs-num (result i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-empty-vs-nums (result i32 i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-num (result i32)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-nums (result i32 i64)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-num (result i32)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-nums (result i64 i64)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-empty-vs-num (result i32)
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-empty-vs-nums (result i32 i32)
+    (return) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-partial-vs-nums (result i32 i32)
+    (i32.const 1) (return) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-num (result i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-nums (result i32 i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-nums (result i32 i32)
+    (return (i64.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-nums (result i32 i32)
+    (return (i32.const 1)) (return (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-nums (result i32 i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-num (result i32)
+    (br 0 (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-nums (result i32 i32)
+    (br 0) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-nums (result i32 i32)
+    (block (br 1)) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-num (result i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-nums (result i32 i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func (nop) (local i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (result i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (result i32) (local.get 0))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (param i32) (local.get 0))")
+  "unexpected token"
+)
+
+;; Duplicate name errors
+
+(assert_malformed (module quote
+  "(func $foo)"
+  "(func $foo)")
+  "duplicate func")
+(assert_malformed (module quote
+  "(import \"\" \"\" (func $foo))"
+  "(func $foo)")
+  "duplicate func")
+(assert_malformed (module quote
+  "(import \"\" \"\" (func $foo))"
+  "(import \"\" \"\" (func $foo))")
+  "duplicate func")
+
+(assert_malformed (module quote "(func (param $foo i32) (param $foo i32))")
+  "duplicate local")
+(assert_malformed (module quote "(func (param $foo i32) (local $foo i32))")
+  "duplicate local")
+(assert_malformed (module quote "(func (local $foo i32) (local $foo i32))")
+  "duplicate local")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func_bind.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func_bind.wast
new file mode 100644
index 0000000..1874321
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/func_bind.wast
@@ -0,0 +1,540 @@
+(module
+  (type $unop (func (param i32) (result i32)))
+
+  (elem func $add)
+  (func $add (param i32 i32) (result i32) (i32.add (local.get 0) (local.get 1)))
+
+  (func $mk-adder (param $i i32) (result (ref $unop))
+    (func.bind (type $unop) (local.get $i) (ref.func $add))
+  )
+
+  (global $f (mut (ref null $unop)) (ref.null $unop))
+
+  (func (export "make") (param $i i32)
+    (global.set $f (call $mk-adder (local.get $i)))
+  )
+
+  (func (export "call") (param $j i32) (result i32)
+    (call_ref (local.get $j) (global.get $f))
+  )
+
+  (func (export "call2") (param $i i32) (param $j i32) (param $k i32) (result i32)
+    (call $mk-adder (local.get $k))
+    (let (result i32) (local $f (ref $unop))  ;; binds $f to top of stack
+      (i32.mul
+        (call_ref (local.get $i) (local.get $f))
+        (call_ref (local.get $j) (local.get $f))
+      )
+    )
+  )
+
+  (func (export "null") (result i32)
+    (func.bind (type $unop) (i32.const 1) (ref.null $unop))
+    (drop)
+  )
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "null function")
+
+(assert_return (invoke "make" (i32.const 3)))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke "call" (i32.const 10)) (i32.const 13))
+
+(assert_return (invoke "make" (i32.const 0)))
+(assert_return (invoke "call" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "make" (i32.const -3)))
+(assert_return (invoke "call" (i32.const 10)) (i32.const 7))
+
+(assert_return (invoke "call2" (i32.const 2) (i32.const 3) (i32.const 0)) (i32.const 6))
+(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 1)) (i32.const 18))
+(assert_return (invoke "call2" (i32.const 2) (i32.const 5) (i32.const 7)) (i32.const 108))
+
+(assert_trap (invoke "null") "null function")
+
+(module
+  (elem declare func $p $f)
+  (func $p (import "spectest" "print_f64_f64") (param f64 f64))
+  (func $f (param f64 f64 f64 f64) (result f64)
+    (f64.const 0)
+    (f64.add (f64.mul (local.get 0) (f64.const 1000)))
+    (f64.add (f64.mul (local.get 1) (f64.const 100)))
+    (f64.add (f64.mul (local.get 2) (f64.const 10)))
+    (f64.add (f64.mul (local.get 3) (f64.const 1)))
+  )
+
+  (type $p0 (func (param)))
+  (type $p1 (func (param f64)))
+  (type $p2 (func (param f64 f64)))
+  (type $f0 (func (param) (result f64)))
+  (type $f1 (func (param f64) (result f64)))
+  (type $f2 (func (param f64 f64) (result f64)))
+  (type $f3 (func (param f64 f64 f64) (result f64)))
+  (type $f4 (func (param f64 f64 f64 f64) (result f64)))
+
+  (table $tp 30 funcref)
+  (table $tf 50 funcref)
+
+  (func (export "call-p0") (param $i i32)
+    (call_indirect $tp (type $p0) (local.get $i))
+  )
+  (func (export "call-p1") (param $i i32) (param f64)
+    (call_indirect $tp (type $p1) (local.get 1) (local.get $i))
+  )
+  (func (export "call-p2") (param $i i32) (param f64 f64)
+    (call_indirect $tp (type $p2) (local.get 1) (local.get 2) (local.get $i))
+  )
+
+  (func (export "call-f0") (param $i i32) (result f64)
+    (call_indirect $tf (type $f0) (local.get $i))
+  )
+  (func (export "call-f1") (param $i i32) (param f64) (result f64)
+    (call_indirect $tf (type $f1) (local.get 1) (local.get $i))
+  )
+  (func (export "call-f2") (param $i i32) (param f64 f64) (result f64)
+    (call_indirect $tf (type $f2) (local.get 1) (local.get 2) (local.get $i))
+  )
+  (func (export "call-f3") (param $i i32) (param f64 f64 f64) (result f64)
+    (call_indirect $tf (type $f3) (local.get 1) (local.get 2) (local.get 3) (local.get $i))
+  )
+  (func (export "call-f4") (param $i i32) (param f64 f64 f64 f64) (result f64)
+    (call_indirect $tf (type $f4) (local.get 1) (local.get 2) (local.get 3) (local.get 4) (local.get $i))
+  )
+
+  (func (export "init")
+    ;; Host closures with arity 2
+    (table.set $tp (i32.const 20)
+      (ref.func $p)
+    )
+    (table.set $tp (i32.const 21)
+      (func.bind (type $p2)
+        (ref.func $p))
+    )
+
+    ;; Host closures with arity 1
+    (table.set $tp (i32.const 10)
+      (func.bind (type $p1) (f64.const 1)
+        (ref.func $p))
+    )
+    (table.set $tp (i32.const 11)
+      (func.bind (type $p1) (f64.const 1)
+        (func.bind (type $p2)
+          (ref.func $p)))
+    )
+    (table.set $tp (i32.const 12)
+      (func.bind (type $p1)
+        (func.bind (type $p1) (f64.const 1)
+          (func.bind (type $p2)
+            (ref.func $p))))
+    )
+
+    ;; Host closures with arity 0
+    (table.set $tp (i32.const 00)
+      (func.bind (type $p0) (f64.const 1) (f64.const 2)
+        (ref.func $p))
+    )
+    (table.set $tp (i32.const 01)
+      (func.bind (type $p0) (f64.const 2)
+       (func.bind (type $p1) (f64.const 1)
+         (ref.func $p)))
+    )
+    (table.set $tp (i32.const 02)
+      (func.bind (type $p0)
+        (func.bind (type $p0) (f64.const 2)
+          (func.bind (type $p1)
+            (func.bind (type $p1) (f64.const 1)
+              (func.bind (type $p2)
+                (func.bind (type $p2)
+                  (ref.func $p)))))))
+    )
+
+    ;; Wasm closures with arity 4
+    (table.set $tf (i32.const 40)
+      (ref.func $f)
+    )
+    (table.set $tf (i32.const 41)
+      (func.bind (type $f4)
+        (ref.func $f))
+    )
+
+    ;; Wasm closures with arity 3
+    (table.set $tf (i32.const 30)
+      (func.bind (type $f3) (f64.const 1)
+        (ref.func $f))
+    )
+    (table.set $tf (i32.const 31)
+      (func.bind (type $f3) (f64.const 1)
+        (func.bind (type $f4)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 32)
+      (func.bind (type $f3)
+        (func.bind (type $f3) (f64.const 1)
+          (func.bind (type $f4)
+            (ref.func $f))))
+    )
+
+    ;; Wasm closures with arity 2
+    (table.set $tf (i32.const 20)
+      (func.bind (type $f2) (f64.const 1) (f64.const 2)
+        (ref.func $f))
+    )
+    (table.set $tf (i32.const 21)
+      (func.bind (type $f2) (f64.const 2)
+        (func.bind (type $f3) (f64.const 1)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 22)
+      (func.bind (type $f2)
+        (func.bind (type $f2) (f64.const 2)
+          (func.bind (type $f3)
+            (func.bind (type $f3) (f64.const 1)
+              (func.bind (type $f4)
+                (func.bind (type $f4)
+                  (ref.func $f)))))))
+    )
+
+    ;; Wasm closures with arity 1
+    (table.set $tf (i32.const 10)
+      (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3)
+        (ref.func $f))
+    )
+    (table.set $tf (i32.const 11)
+      (func.bind (type $f1) (f64.const 2) (f64.const 3)
+        (func.bind (type $f3) (f64.const 1)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 12)
+      (func.bind (type $f1) (f64.const 3)
+        (func.bind (type $f2) (f64.const 1) (f64.const 2)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 13)
+      (func.bind (type $f1) (f64.const 3)
+        (func.bind (type $f2) (f64.const 2)
+          (func.bind (type $f3) (f64.const 1)
+            (ref.func $f))))
+    )
+    (table.set $tf (i32.const 14)
+      (func.bind (type $f1)
+        (func.bind (type $f1)
+          (func.bind (type $f1) (f64.const 3)
+            (func.bind (type $f2)
+              (func.bind (type $f2)
+                (func.bind (type $f2) (f64.const 2)
+                  (func.bind (type $f3)
+                    (func.bind (type $f3)
+                      (func.bind (type $f3) (f64.const 1)
+                        (func.bind (type $f4)
+                          (func.bind (type $f4)
+                            (ref.func $f))))))))))))
+    )
+
+    ;; Wasm closures with arity 0
+    (table.set $tf (i32.const 00)
+      (func.bind (type $f0) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)
+        (ref.func $f))
+    )
+    (table.set $tf (i32.const 01)
+      (func.bind (type $f0) (f64.const 2) (f64.const 3) (f64.const 4)
+        (func.bind (type $f3) (f64.const 1)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 02)
+      (func.bind (type $f0) (f64.const 3) (f64.const 4)
+        (func.bind (type $f2) (f64.const 1) (f64.const 2)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 03)
+      (func.bind (type $f0) (f64.const 4)
+        (func.bind (type $f1) (f64.const 1) (f64.const 2) (f64.const 3)
+          (ref.func $f)))
+    )
+    (table.set $tf (i32.const 04)
+      (func.bind (type $f0) (f64.const 3) (f64.const 4)
+        (func.bind (type $f2) (f64.const 2)
+          (func.bind (type $f3) (f64.const 1)
+            (ref.func $f))))
+    )
+    (table.set $tf (i32.const 05)
+      (func.bind (type $f0) (f64.const 4)
+        (func.bind (type $f1) (f64.const 2) (f64.const 3)
+          (func.bind (type $f3) (f64.const 1)
+            (ref.func $f))))
+    )
+    (table.set $tf (i32.const 06)
+      (func.bind (type $f0) (f64.const 4)
+        (func.bind (type $f1) (f64.const 3)
+          (func.bind (type $f2) (f64.const 1) (f64.const 2)
+            (ref.func $f))))
+    )
+    (table.set $tf (i32.const 07)
+      (func.bind (type $f0) (f64.const 4)
+        (func.bind (type $f1) (f64.const 3)
+          (func.bind (type $f2) (f64.const 2)
+            (func.bind (type $f3) (f64.const 1)
+              (func.bind (type $f4)
+                (ref.func $f))))))
+    )
+    (table.set $tf (i32.const 08)
+      (func.bind (type $f0)
+        (func.bind (type $f0)
+          (func.bind (type $f0) (f64.const 4)
+            (func.bind (type $f1)
+              (func.bind (type $f1)
+                (func.bind (type $f1) (f64.const 2) (f64.const 3)
+                  (func.bind (type $f3)
+                    (func.bind (type $f3)
+                      (func.bind (type $f3) (f64.const 1)
+                        (func.bind (type $f4)
+                          (func.bind (type $f4)
+                            (ref.func $f))))))))))))
+    )
+  )
+)
+
+(invoke "init")
+
+(assert_return (invoke "call-p0" (i32.const 00)))
+(assert_return (invoke "call-p0" (i32.const 01)))
+(assert_return (invoke "call-p0" (i32.const 02)))
+(assert_return (invoke "call-p1" (i32.const 10) (f64.const 2)))
+(assert_return (invoke "call-p1" (i32.const 11) (f64.const 2)))
+(assert_return (invoke "call-p1" (i32.const 12) (f64.const 2)))
+(assert_return (invoke "call-p2" (i32.const 20) (f64.const 1) (f64.const 2)))
+(assert_return (invoke "call-p2" (i32.const 21) (f64.const 1) (f64.const 2)))
+
+(assert_return (invoke "call-f0" (i32.const 00)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 01)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 02)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 03)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 04)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 05)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 06)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 07)) (f64.const 1234))
+(assert_return (invoke "call-f0" (i32.const 08)) (f64.const 1234))
+(assert_return (invoke "call-f1" (i32.const 10) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f1" (i32.const 11) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f1" (i32.const 12) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f1" (i32.const 13) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f1" (i32.const 14) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f2" (i32.const 20) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f2" (i32.const 21) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f2" (i32.const 22) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f3" (i32.const 30) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f3" (i32.const 31) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f3" (i32.const 32) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f4" (i32.const 40) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
+(assert_return (invoke "call-f4" (i32.const 41) (f64.const 1) (f64.const 2) (f64.const 3) (f64.const 4)) (f64.const 1234))
+
+
+(; Once we allow subtyping on function types:
+;; The runtime type of a closure is its internal one,
+;; not the static bind annotation.
+(module
+  (type $ii (func (param i32) (result i32)))
+  (type $fl (func (param i32 anyref) (result (ref null $ii))))
+  (type $fu (func (param i32 (ref $ii)) (result anyref)))
+  (type $fl' (func (param anyref) (result (ref null $ii))))
+  (type $fu' (func (param (ref $ii)) (result anyref)))
+
+  (elem declare func $sqr $f)
+  (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+  (func $f (type $fl) (ref.func $sqr))
+
+  (table $t 10 funcref)
+
+  (func (export "run") (result i32)
+    (table.set $t (i32.const 0) (func.bind (type $fu) (ref.func $f)))
+    (table.set $t (i32.const 1) (func.bind (type $fu') (i32.const 0) (ref.func $f)))
+
+    (i32.add
+      (call_ref (i32.const 2)
+        (call_indirect $t (type $fl) (i32.const 0) (ref.null $fl) (i32.const 0))
+      )
+      (call_ref (i32.const 3)
+        (call_indirect $t (type $fl') (ref.null $fl') (i32.const 1))
+      )
+    )
+  )
+)
+
+(assert_return (invoke "run") (i32.const 13))
+;)
+
+(; Instead, for now: ;)
+(assert_invalid
+  (module
+    (type $ii (func (param i32) (result i32)))
+    (type $fl (func (param i32 funcref) (result (ref null $ii))))
+    (type $fu (func (param i32 (ref $ii)) (result funcref)))
+
+    (elem declare func $sqr $f)
+    (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+    (func $f (type $fl) (ref.func $sqr))
+
+    (func (drop (func.bind (type $fu) (ref.func $f))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $ii (func (param i32) (result i32)))
+    (type $fl (func (param i32 funcref) (result (ref null $ii))))
+    (type $fu' (func (param (ref $ii)) (result funcref)))
+
+    (elem declare func $sqr $f)
+    (func $sqr (param i32) (result i32) (i32.mul (local.get 0) (local.get 0)))
+    (func $f (type $fl) (ref.func $sqr))
+
+    (func (drop (func.bind (type $fu') (i32.const 0) (ref.func $f))))
+  )
+  "type mismatch"
+)
+
+
+;; Null and unreachable typing.
+
+(module
+  (type $t (func))
+  (func (export "null") (result (ref $t))
+    (ref.null $t)
+    (func.bind)
+  )
+)
+(assert_trap (invoke "null") "null function")
+
+(module
+  (type $t (func (param f32)))
+  (func (export "null") (result (ref $t))
+    (ref.null $t)
+    (func.bind (type $t))
+  )
+)
+(assert_trap (invoke "null") "null function")
+
+(module
+  (type $t0 (func))
+  (type $t1 (func (param i64)))
+  (func (export "null") (result (ref $t0))
+    (i64.const 0)
+    (ref.null $t1)
+    (func.bind)
+  )
+)
+(assert_trap (invoke "null") "null function")
+
+(module
+  (type $t0 (func))
+  (type $t1 (func (param i64)))
+  (func (export "null") (result (ref $t0))
+    (i64.const 0)
+    (ref.null $t1)
+    (func.bind (type $t0))
+  )
+)
+(assert_trap (invoke "null") "null function")
+
+(assert_invalid
+  (module
+    (type $t (func (result f32)))
+    (func (export "null") (result i32)
+      (ref.null $t)
+      (func.bind)
+    )
+  )
+  "type mismatch"
+)
+
+
+(module
+  (type $t (func (param f32)))
+  (func (export "unreachable") (result (ref $t))
+    (unreachable)
+    (func.bind (type $t))
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(module
+  (type $t (func (param f32) (result i32)))
+  (elem declare func $f)
+  (func $f (param i32 f32) (result i32) (local.get 0))
+
+  (func (export "unreachable") (result (ref $t))
+    (unreachable)
+    (ref.func $f)
+    (func.bind (type $t))
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_invalid
+  (module
+    (type $t (func (param f32)))
+    (elem declare func $f)
+    (func $f (param i32 f32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result (ref $t))
+      (unreachable)
+      (i64.const 0)
+      (ref.func $f)
+      (func.bind (type $t))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f)
+    (func $f (param i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result (ref $t))
+      (unreachable)
+      (ref.func $f)
+      (func.bind (type $t))
+      (drop)
+      (i64.const 0)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func (export "null") (result i32)
+      (unreachable)
+      (func.bind)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func (param f32)))
+    (elem declare func $f)
+    (func $f (param i32 i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result (ref $t))
+      (unreachable)
+      (ref.func $f)
+      (func.bind (type $t))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param $r externref)
+      (func.bind (type $t) (local.get $r))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/i31.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/i31.wast
new file mode 100644
index 0000000..ade957f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/i31.wast
@@ -0,0 +1,32 @@
+(module
+  (func (export "new") (param $i i32) (result (ref i31))
+    (i31.new (local.get $i))
+  )
+
+  (func (export "get_u") (param $i i32) (result i32)
+    (i31.get_u (i31.new (local.get $i)))
+  )
+  (func (export "get_s") (param $i i32) (result i32)
+    (i31.get_s (i31.new (local.get $i)))
+  )
+)
+
+(assert_return (invoke "new" (i32.const 1)) (ref.i31))
+
+(assert_return (invoke "get_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "get_u" (i32.const 100)) (i32.const 100))
+(assert_return (invoke "get_u" (i32.const -1)) (i32.const 0x7fff_ffff))
+(assert_return (invoke "get_u" (i32.const 0x3fff_ffff)) (i32.const 0x3fff_ffff))
+(assert_return (invoke "get_u" (i32.const 0x4000_0000)) (i32.const 0x4000_0000))
+(assert_return (invoke "get_u" (i32.const 0x7fff_ffff)) (i32.const 0x7fff_ffff))
+(assert_return (invoke "get_u" (i32.const 0xaaaa_aaaa)) (i32.const 0x2aaa_aaaa))
+(assert_return (invoke "get_u" (i32.const 0xcaaa_aaaa)) (i32.const 0x4aaa_aaaa))
+
+(assert_return (invoke "get_s" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "get_s" (i32.const 100)) (i32.const 100))
+(assert_return (invoke "get_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "get_s" (i32.const 0x3fff_ffff)) (i32.const 0x3fff_ffff))
+(assert_return (invoke "get_s" (i32.const 0x4000_0000)) (i32.const -0x4000_0000))
+(assert_return (invoke "get_s" (i32.const 0x7fff_ffff)) (i32.const -1))
+(assert_return (invoke "get_s" (i32.const 0xaaaa_aaaa)) (i32.const 0x2aaa_aaaa))
+(assert_return (invoke "get_s" (i32.const 0xcaaa_aaaa)) (i32.const 0xcaaa_aaaa))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/if.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/if.wast
new file mode 100644
index 0000000..553f90d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/if.wast
@@ -0,0 +1,1550 @@
+;; Test `if` operator
+
+(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty") (param i32)
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $l (local.get 0) (then))
+    (if $l (local.get 0) (then) (else))
+  )
+
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+
+  (func (export "multi") (param i32) (result i32 i32)
+    (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy)))
+    (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+      (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy))
+    )
+    (if (result i32 i64 i32) (local.get 0)
+      (then
+        (call $dummy) (call $dummy) (i32.const 1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const 2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const 3) (call $dummy)
+      )
+      (else
+        (call $dummy) (call $dummy) (i32.const -1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const -2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const -3) (call $dummy)
+      )
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 9))
+          (else (call $dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 10))
+          (else (call $dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (local.get 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (local.set 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (local.get 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.ctz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const -13))
+      )
+    )
+  )
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 3))
+        (else (call $dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const -5))
+      )
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-compare-operand") (param i32 i32) (result i32)
+    (f32.gt
+      (if (result f32) (local.get 0)
+        (then (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -3))
+      )
+      (if (result f32) (local.get 1)
+        (then (call $dummy) (f32.const 4))
+        (else (call $dummy) (f32.const -4))
+      )
+    )
+  )
+  (func (export "as-binary-operands") (param i32) (result i32)
+    (i32.mul
+      (if (result i32 i32) (local.get 0)
+        (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4))
+      )
+    )
+  )
+  (func (export "as-compare-operands") (param i32) (result i32)
+    (f32.gt
+      (if (result f32 f32) (local.get 0)
+        (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3))
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (param i32) (result i32)
+    (if (result i32 i32) (local.get 0)
+      (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+      (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4))
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (if (i32.const 1) (then (br 0) (unreachable)))
+    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
+    (i32.const 19)
+  )
+
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+  (func (export "break-multi-value") (param i32) (result i32 i32 i64)
+    (if (result i32 i32 i64) (local.get 0)
+      (then
+        (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+        (i32.const 19) (i32.const -19) (i64.const 19)
+      )
+      (else
+        (br 0 (i32.const -18) (i32.const 18) (i64.const -18))
+        (i32.const -19) (i32.const 19) (i64.const -19)
+      )
+    )
+  )
+
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+  (func (export "params") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add))
+      (else (i32.sub))
+    )
+  )
+  (func (export "params-id") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then))
+    (i32.add)
+  )
+  (func (export "param-break") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add) (br 0))
+      (else (i32.const -2) (i32.add) (br 0))
+    )
+  )
+  (func (export "params-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add) (br 0))
+      (else (i32.sub) (br 0))
+    )
+  )
+  (func (export "params-id-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0)))
+    (i32.add)
+  )
+
+  (func (export "effects") (param i32) (result i32)
+    (local i32)
+    (if
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
+      (then
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
+      )
+      (else
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Examples
+
+  (func $add64_u_with_carry (export "add64_u_with_carry")
+    (param $i i64) (param $j i64) (param $c i32) (result i64 i32)
+    (local $k i64)
+    (local.set $k
+      (i64.add
+        (i64.add (local.get $i) (local.get $j))
+        (i64.extend_i32_u (local.get $c))
+      )
+    )
+    (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i)))
+  )
+
+  (func $add64_u_saturated (export "add64_u_saturated")
+    (param i64 i64) (result i64)
+    (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
+    (if (param i64) (result i64)
+      (then (drop) (i64.const -1))
+    )
+  )
+
+  ;; Block signature syntax
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (if (type $block-sig-1) (i32.const 1) (then))
+    (if (type $block-sig-2) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop)))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4) (i32.const 1) (then))
+    (drop) (drop) (drop)
+    (if (type $block-sig-2) (result i32) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (param i32) (i32.const 1)
+      (then (drop)) (else (drop))
+    )
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+      (i32.const 1) (then)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty" (i32.const 0)))
+(assert_return (invoke "empty" (i32.const 1)))
+(assert_return (invoke "empty" (i32.const 100)))
+(assert_return (invoke "empty" (i32.const -2)))
+
+(assert_return (invoke "singular" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "singular" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const -10)) (i32.const 7))
+
+(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1))
+(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1))
+
+(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11))
+(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9))
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15))
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12))
+(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3))
+(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18))
+(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "break-multi-value" (i32.const 0))
+  (i32.const -18) (i32.const 18) (i64.const -18)
+)
+(assert_return (invoke "break-multi-value" (i32.const 1))
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+
+(assert_return (invoke "param" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "effects" (i32.const 1)) (i32.const -14))
+(assert_return (invoke "effects" (i32.const 0)) (i32.const -6))
+
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0))
+  (i64.const 0) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0))
+  (i64.const 224) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0))
+  (i64.const -1) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0))
+  (i64.const -2) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1))
+  (i64.const 1) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1)
+)
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (type $sig) (result i32) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (type $sig) (result i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (result i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (type $sig) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (param i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (param $x i32) (then (drop)) (else (drop)))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (then (drop)) (else (drop)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (result i32) (then)) (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (i32.const 1) (if (type $sig) (i32.const 0) (then)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-num-vs-void-else
+    (if (i32.const 1) (then (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void-else
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-no-else-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-no-else-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-both-different-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-different-value-nums-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 0)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (i64.const 0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (i64.const 0))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-condition-empty
+      (if (then))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-block
+      (i32.const 0)
+      (block (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-loop
+      (i32.const 0)
+      (loop (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (if (then))))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br
+      (i32.const 0)
+      (block (br 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (if(then)) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-return
+      (return (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-select
+      (select (if(then)) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-call
+      (call 1 (if(then))) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-condition-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (if(then)) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.set
+      (local i32)
+      (local.set 0 (if(then))) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-condition-empty-in-global.set
+      (global.set $x (if(then))) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-memory.grow
+      (memory.grow (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-load
+      (i32.load (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-condition-empty-in-store
+      (i32.store (if(then)) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (if (param i32 f64) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (if (param i32 f64) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) if (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func i32.const 0 if end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l1 end $l2)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end $l)")
+  "mismatching label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/let.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/let.wast
new file mode 100644
index 0000000..451bc5d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/let.wast
@@ -0,0 +1,302 @@
+(module
+  ;; Auxiliary
+  (type $dummy (func))
+  (elem declare func $dummy)
+  (func $dummy)
+  (func $consume (param i32))
+  (func $produce (result i32) (i32.const 7))
+
+  (func (export "syntax") (param $x1 i32) (param $x2 i64)
+    (local $y1 i64)
+    (local $y2 i32)
+    (local.set $y2 (i32.const 5))
+
+    (let)
+    (let $l)
+    (let (local))
+    (let $l (local))
+
+    (let (result) (local))
+    (let $l (result) (local))
+
+    (let (call $dummy) (call $consume (local.get $x1)))
+    (let $l (call $dummy) (call $consume (local.get $y2)))
+    (let (local) (call $dummy) (call $consume (local.get $y2)))
+    (let $l (local) (call $dummy) (call $consume (local.get $x1)))
+
+    (let (call $dummy) (call $dummy) (br 0))
+    (let $l (call $dummy) (call $dummy) (br $l))
+    (let (local) (call $dummy) (call $dummy) (br 0))
+    (let $l (local) (call $dummy) (call $dummy) (br $l))
+
+    (i32.const 1)
+    (f32.const 2)
+    (let $l (param i32) (result i64) (local f32) (br $l (i64.const 3)))
+    (drop)
+
+    (let (result i32) (call $dummy) (call $produce) (call $dummy))
+    (drop)
+    (let $l (result i32) (call $dummy) (call $produce) (call $dummy))
+    (drop)
+    (let (result i32) (local) (call $dummy) (call $produce) (call $dummy))
+    (drop)
+    (let $l (result i32) (local) (call $dummy) (call $produce) (call $dummy))
+    (drop)
+
+    (i32.const 1)
+    (let (local i32) (call $dummy) (call $consume (local.get 0)))
+    (i32.const 2)
+    (let $l (local i32) (call $dummy) (call $consume (local.get 0)))
+    (i32.const 3)
+    (let (local i32) (call $dummy) (call $consume (local.get 0)))
+    (i32.const 4)
+    (let $l (local i32) (call $dummy) (call $consume (local.get 0)))
+
+    (i32.const 1) (f32.const 2) (i32.const 3) (i64.const 4)
+    (let (local i32 f32) (local) (local $z i32) (local i64)
+      (call $consume (local.get 0))
+      (call $consume (local.get 2))  ;; $z
+      (call $consume (local.get 4))  ;; $x1
+      (call $consume (local.get 7))  ;; $y2
+      (call $consume (local.get $z))
+      (call $consume (local.get $x1))
+      (call $consume (local.get $y2))
+    )
+
+    (f32.const 1) (i32.const 2) (i64.const 3) (i32.const 4)
+    (let (result i32) (local $z1 f32) (local $z2 i32) (local) (local i64 i32)
+      (call $produce)
+      (call $consume (local.get 1))  ;; $z2
+      (call $consume (local.get 3))
+      (call $consume (local.get 4))  ;; $x1
+      (call $consume (local.get 7))  ;; $y2
+      (call $consume (local.get $z2))
+      (call $consume (local.get $x1))
+      (call $consume (local.get $y2))
+    )
+    (drop)
+
+    (ref.func $dummy)
+    (let (local (ref $dummy)))
+  )
+
+  (func $pow (export "pow") (param $x i64) (param $n i32) (result i64)
+    (local $y i64)
+    (local.set $y 
+      (if (result i64) (i32.and (local.get $n) (i32.const 1))
+        (then (local.get $x)) (else (i64.const 1))
+      )
+    )
+    (i64.mul
+      (local.get $y)
+      (if (result i64) (i32.le_u (local.get $n) (i32.const 1))
+        (then (i64.const 1))
+        (else
+          (call $pow
+            (i64.mul (local.get $x) (local.get $x))
+            (i32.shr_u (local.get $n) (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "semantics-idx") (param i64 i64) (result i64)
+    (local i64 i64)
+    (local.set 2 (i64.const 5))
+    (local.set 3 (i64.const 7))
+
+    (i64.const 11) (i64.const 13)
+    (let (result i64) (local i64 i64)
+      (i64.const 17) (i64.const 19)
+      (let (result i64) (local i64 i64)
+        (i64.const 0)
+        (i64.add (call $pow (local.get 0) (i32.const 0)))  ;; 17^0 =      1
+        (i64.add (call $pow (local.get 1) (i32.const 1)))  ;; 19^1 =     19
+        (i64.add (call $pow (local.get 2) (i32.const 2)))  ;; 11^2 =    121
+        (i64.add (call $pow (local.get 3) (i32.const 3)))  ;; 13^3 =   2197
+        (i64.add (call $pow (local.get 4) (i32.const 4)))  ;;  2^4 =     16
+        (i64.add (call $pow (local.get 5) (i32.const 5)))  ;;  3^5 =    243
+        (i64.add (call $pow (local.get 6) (i32.const 6)))  ;;  5^6 =  15625
+        (i64.add (call $pow (local.get 7) (i32.const 7)))  ;;  7^7 = 823543
+      )
+    )
+  )
+
+  (func (export "semantics-sym") (param $x1 i64) (param $x2 i64) (result i64)
+    (local $y1 i64)
+    (local $y2 i64)
+    (local.set $y1 (i64.const 5))
+    (local.set $y2 (i64.const 7))
+
+    (i64.const 11) (i64.const 13)
+    (let (result i64) (local $z1 i64) (local $z2 i64)
+      (i64.const 17) (i64.const 19)
+      (let (result i64) (local $u1 i64) (local $u2 i64)
+        (i64.const 0)
+        (i64.add (call $pow (local.get $u1) (i32.const 0)))  ;; 17^0 =      1
+        (i64.add (call $pow (local.get $u2) (i32.const 1)))  ;; 19^1 =     19
+        (i64.add (call $pow (local.get $z1) (i32.const 2)))  ;; 11^2 =    121
+        (i64.add (call $pow (local.get $z2) (i32.const 3)))  ;; 13^3 =   2197
+        (i64.add (call $pow (local.get $x1) (i32.const 4)))  ;;  2^4 =     16
+        (i64.add (call $pow (local.get $x2) (i32.const 5)))  ;;  3^5 =    243
+        (i64.add (call $pow (local.get $y1) (i32.const 6)))  ;;  5^6 =  15625
+        (i64.add (call $pow (local.get $y2) (i32.const 7)))  ;;  7^7 = 823543
+      )
+    )
+  )
+
+  (func (export "mutate") (param $x1 i64) (param $x2 i64) (result i64)
+    (local $y1 i64)
+    (local $y2 i64)
+
+    (i64.const 0) (i64.const 0)
+    (let (result i64) (local $z1 i64) (local $z2 i64)
+      (i64.const 0) (i64.const 0)
+      (let (result i64) (local $u1 i64) (local $u2 i64)
+        (local.set $y1 (i64.const 5))
+        (local.set $y2 (i64.const 7))
+        (local.set $z1 (i64.const 11))
+        (local.set $z2 (i64.const 13))
+        (local.set $u1 (i64.const 17))
+        (local.set $u2 (i64.const 19))
+        (i64.const 0)
+        (i64.add (call $pow (local.get $u1) (i32.const 0)))  ;; 17^0 =      1
+        (i64.add (call $pow (local.get $u2) (i32.const 1)))  ;; 19^1 =     19
+        (i64.add (call $pow (local.get $z1) (i32.const 2)))  ;; 11^2 =    121
+        (i64.add (call $pow (local.get $z2) (i32.const 3)))  ;; 13^3 =   2197
+        (i64.add (call $pow (local.get $x1) (i32.const 4)))  ;;  2^4 =     16
+        (i64.add (call $pow (local.get $x2) (i32.const 5)))  ;;  3^5 =    243
+        (i64.add (call $pow (local.get $y1) (i32.const 6)))  ;;  5^6 =  15625
+        (i64.add (call $pow (local.get $y2) (i32.const 7)))  ;;  7^7 = 823543
+      )
+    )
+  )
+)
+
+(assert_return (invoke "syntax" (i32.const 1) (i64.const 2)))
+
+(assert_return (invoke "pow" (i64.const 17) (i32.const 0)) (i64.const 1))
+(assert_return (invoke "pow" (i64.const 19) (i32.const 1)) (i64.const 19))
+(assert_return (invoke "pow" (i64.const 11) (i32.const 2)) (i64.const 121))
+(assert_return (invoke "pow" (i64.const 13) (i32.const 3)) (i64.const 2197))
+(assert_return (invoke "pow" (i64.const 2) (i32.const 4)) (i64.const 16))
+(assert_return (invoke "pow" (i64.const 3) (i32.const 5)) (i64.const 243))
+(assert_return (invoke "pow" (i64.const 5) (i32.const 6)) (i64.const 15625))
+(assert_return (invoke "pow" (i64.const 7) (i32.const 7)) (i64.const 823543))
+
+(assert_return (invoke "semantics-idx" (i64.const 2) (i64.const 3)) (i64.const 841_765))
+(assert_return (invoke "semantics-sym" (i64.const 2) (i64.const 3)) (i64.const 841_765))
+(assert_return (invoke "mutate" (i64.const 2) (i64.const 3)) (i64.const 841_765))
+
+
+;; Shadowing.
+
+;; Shadowing is fine across nested let blocks (analogous to labels).
+(module
+  (func (export "f1") (param $x i32) (result i32)
+    (i32.const 1)
+    (let (local $x i32) (return (local.get $x)))
+    (unreachable)
+  )
+  (func (export "f2") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (let (local $x i32) (return (local.get $x)))
+    (unreachable)
+  )
+  (func (export "f3") (result i32)
+    (i32.const 0)
+    (let (local $x i32)
+      (i32.const 1)
+      (let (local $x i32) (return (local.get $x)))
+    )
+    (unreachable)
+  )
+  (func (export "f4") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (let (local $x i32)
+      (i32.const 2)
+      (let (local $x i32) (return (local.get $x)))
+    )
+    (unreachable)
+  )
+)
+
+(assert_return (invoke "f1" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "f2") (i32.const 1))
+(assert_return (invoke "f3") (i32.const 1))
+(assert_return (invoke "f4") (i32.const 2))
+
+;; Duplicate labels within a single let block are still disallowed.
+(assert_malformed
+  (module quote "(func (let (local $x i32) (local $x i64)))")
+  "duplicate local"
+)
+
+
+;; Syntax
+
+(assert_malformed
+  (module quote "(func (let (local) (param)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func"
+    "  (i32.const 0) (i32.const 0)"
+    "  (let (local i32) (param i32) (drop))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (let (local) (result)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32)"
+    "  (i32.const 0)"
+    "  (let (local i32) (result i32) (local.get 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32)"
+    "  (let (local $x i32) (result i32) (local.get 0))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (let (result) (param)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32)"
+    "  (i32.const 0)"
+    "  (let (result i32) (param i32))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (let (param) $l))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (let (result) $l))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (let (local) $l))")
+  "unexpected token"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/linking.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/linking.wast
new file mode 100644
index 0000000..85de43d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/linking.wast
@@ -0,0 +1,627 @@
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (global.get $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (global.get $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+
+(module $Mref_ex
+  (type $t (func))
+  (func $f) (elem declare func $f)
+  (global (export "g-const-funcnull") (ref null func) (ref.null func))
+  (global (export "g-const-func") (ref func) (ref.func $f))
+  (global (export "g-const-refnull") (ref null $t) (ref.null $t))
+  (global (export "g-const-ref") (ref $t) (ref.func $f))
+  (global (export "g-const-extern") externref (ref.null extern))
+  (global (export "g-var-funcnull") (mut (ref null func)) (ref.null func))
+  (global (export "g-var-func") (mut (ref func)) (ref.func $f))
+  (global (export "g-var-refnull") (mut (ref null $t)) (ref.null $t))
+  (global (export "g-var-ref") (mut (ref $t)) (ref.func $f))
+  (global (export "g-var-extern") (mut externref) (ref.null extern))
+)
+(register "Mref_ex" $Mref_ex)
+
+(module $Mref_im
+  (type $t (func))
+  (global (import "Mref_ex" "g-const-funcnull") (ref null func))
+  (global (import "Mref_ex" "g-const-func") (ref null func))
+  (global (import "Mref_ex" "g-const-refnull") (ref null func))
+  (global (import "Mref_ex" "g-const-ref") (ref null func))
+  (global (import "Mref_ex" "g-const-func") (ref func))
+  (global (import "Mref_ex" "g-const-ref") (ref func))
+  (global (import "Mref_ex" "g-const-refnull") (ref null $t))
+  (global (import "Mref_ex" "g-const-ref") (ref null $t))
+  (global (import "Mref_ex" "g-const-ref") (ref $t))
+  (global (import "Mref_ex" "g-const-extern") externref)
+
+  (global (import "Mref_ex" "g-var-funcnull") (mut (ref null func)))
+  (global (import "Mref_ex" "g-var-func") (mut (ref func)))
+  (global (import "Mref_ex" "g-var-refnull") (mut (ref null $t)))
+  (global (import "Mref_ex" "g-var-ref") (mut (ref $t)))
+  (global (import "Mref_ex" "g-var-extern") (mut externref))
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-extern") (ref null func)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-refnull") (ref func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref func)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref null $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-func") (ref null $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref null $t)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-funcnull") (ref $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-func") (ref $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-refnull") (ref $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-const-extern") (ref $t)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-funcnull") externref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-func") externref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-refnull") externref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-ref") externref))
+  "incompatible import type"
+)
+
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-func") (mut (ref null func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-refnull") (mut (ref null func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-ref") (mut (ref null func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-extern") (mut (ref null func))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-funcnull") (mut (ref func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-refnull") (mut (ref func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-ref") (mut (ref func))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-extern") (mut (ref func))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-funcnull") (mut (ref null $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-func") (mut (ref null $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-ref") (mut (ref null $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-extern") (mut (ref null $t))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-funcnull") (mut (ref $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-func") (mut (ref $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-refnull") (mut (ref $t))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (global (import "Mref_ex" "g-var-extern") (mut (ref $t))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-funcnull") (mut externref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-func") (mut externref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-refnull") (mut externref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-ref") (mut externref)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 funcref)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table funcref (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (local.get 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized element")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined element")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined element")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined element")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call type mismatch")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 funcref)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized element")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined element")
+
+(module
+  (table (import "Mt" "tab") 0 funcref)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (global.get 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 0 funcref)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "out of bounds table access"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized element")
+
+;; Unlike in the v1 spec, active element segments stored before an
+;; out-of-bounds access persist after the instantiation failure.
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 8) $f $f $f $f $f)  ;; (partially) out of bounds
+  )
+  "out of bounds table access"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+(assert_trap (invoke $Mt "call" (i32.const 8)) "uninitialized element")
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (memory 1)
+    (data (i32.const 0x10000) "d")  ;; out of bounds
+  )
+  "out of bounds memory access"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+
+(module $Mtable_ex
+  (type $t (func))
+  (table (export "t-funcnull") 1 (ref null func))
+  (table (export "t-refnull") 1 (ref null $t))
+  (table (export "t-extern") 1 externref)
+)
+(register "Mtable_ex" $Mtable_ex)
+
+(module
+  (type $t (func))
+  (table (import "Mtable_ex" "t-funcnull") 1 (ref null func))
+  (table (import "Mtable_ex" "t-refnull") 1 (ref null $t))
+  (table (import "Mtable_ex" "t-extern") 1 externref)
+)
+
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-refnull") 1 (ref null func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-extern") 1 (ref null func)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (type $t (func)) (table (import "Mtable_ex" "t-funcnull") 1 (ref null $t)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (type $t (func)) (table (import "Mtable_ex" "t-extern") 1 (ref null $t)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-funcnull") 1 externref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-refnull") 1 externref))
+  "incompatible import type"
+)
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "out of bounds memory access"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+;; Unlike in v1 spec, active data segments written before an
+;; out-of-bounds access persist after the instantiation failure.
+(assert_trap
+  (module
+    ;; Note: the memory is 5 pages large by the time we get here.
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 327670) "zzzzzzzzzzzzzzzzzz") ;; (partially) out of bounds
+  )
+  "out of bounds memory access"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+(assert_return (invoke $Mm "load" (i32.const 327670)) (i32.const 0))
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 funcref)
+    (func)
+    (elem (i32.const 0) 0)  ;; out of bounds
+  )
+  "out of bounds table access"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+;; Store is modified if the start function traps.
+(module $Ms
+  (type $t (func (result i32)))
+  (memory (export "memory") 1)
+  (table (export "table") 1 funcref)
+  (func (export "get memory[0]") (type $t)
+    (i32.load8_u (i32.const 0))
+  )
+  (func (export "get table[0]") (type $t)
+    (call_indirect (type $t) (i32.const 0))
+  )
+)
+(register "Ms" $Ms)
+
+(assert_trap
+  (module
+    (import "Ms" "memory" (memory 1))
+    (import "Ms" "table" (table 1 funcref))
+    (data (i32.const 0) "hello")
+    (elem (i32.const 0) $f)
+    (func $f (result i32)
+      (i32.const 0xdead)
+    )
+    (func $main
+      (unreachable)
+    )
+    (start $main)
+  )
+  "unreachable"
+)
+
+(assert_return (invoke $Ms "get memory[0]") (i32.const 104))  ;; 'h'
+(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref.wast
new file mode 100644
index 0000000..aef1b39
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref.wast
@@ -0,0 +1,80 @@
+;; Syntax
+
+(module
+  (type $t (func))
+
+  (func
+    (param
+      funcref
+      externref
+      (ref func)
+      (ref extern)
+      (ref 0)
+      (ref $t)
+      (ref 0)
+      (ref $t)
+      (ref null func)
+      (ref null extern)
+      (ref null 0)
+      (ref null $t)
+    )
+  )
+)
+
+
+;; Undefined type index.
+
+(assert_invalid
+  (module (type $type-func-param-invalid (func (param (ref 1)))))
+  "unknown type"
+)
+(assert_invalid
+  (module (type $type-func-result-invalid (func (result (ref 1)))))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (global $global-invalid (ref null 1) (ref.null 1)))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (table $table-invalid 10 (ref null 1)))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (elem $elem-invalid (ref 1)))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (func $func-param-invalid (param (ref 1))))
+  "unknown type"
+)
+(assert_invalid
+  (module (func $func-result-invalid (result (ref 1))))
+  "unknown type"
+)
+(assert_invalid
+  (module (func $func-local-invalid (local (ref null 1))))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (func $block-result-invalid (drop (block (result (ref 1)) (unreachable)))))
+  "unknown type"
+)
+(assert_invalid
+  (module (func $loop-result-invalid (drop (loop (result (ref 1)) (unreachable)))))
+  "unknown type"
+)
+(assert_invalid
+  (module (func $if-invalid (drop (if (result (ref 1)) (then) (else)))))
+  "unknown type"
+)
+
+(assert_invalid
+  (module (func $select-result-invalid (drop (select (result (ref 1)) (unreachable)))))
+  "unknown type"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as.wast
new file mode 100644
index 0000000..47064c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as.wast
@@ -0,0 +1,67 @@
+(module
+  (type $ft (func))
+  (type $st (struct))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f)
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (i31.new (i32.const 7)))
+    (table.set (i32.const 2) (struct.new_default $st (rtt.canon $st)))
+    (table.set (i32.const 3) (array.new_default $at (i32.const 0) (rtt.canon $at)))
+    (table.set (i32.const 4) (ref.func $f))
+    (table.set (i32.const 5) (rtt.canon $ft))
+    (table.set (i32.const 6) (local.get $x))
+  )
+
+  (func (export "ref_as_non_null") (param $i i32)
+    (drop (ref.as_non_null (table.get (local.get $i))))
+  )
+  (func (export "ref_as_i31") (param $i i32)
+    (drop (ref.as_i31 (table.get (local.get $i))))
+  )
+  (func (export "ref_as_data") (param $i i32)
+    (drop (ref.as_data (table.get (local.get $i))))
+  )
+  (func (export "ref_as_func") (param $i i32)
+    (drop (ref.as_func (table.get (local.get $i))))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_trap (invoke "ref_as_non_null" (i32.const 0)) "null reference")
+(assert_return (invoke "ref_as_non_null" (i32.const 1)))
+(assert_return (invoke "ref_as_non_null" (i32.const 2)))
+(assert_return (invoke "ref_as_non_null" (i32.const 3)))
+(assert_return (invoke "ref_as_non_null" (i32.const 4)))
+(assert_return (invoke "ref_as_non_null" (i32.const 5)))
+(assert_return (invoke "ref_as_non_null" (i32.const 6)))
+
+(assert_trap (invoke "ref_as_i31" (i32.const 0)) "cast failure")
+(assert_return (invoke "ref_as_i31" (i32.const 1)))
+(assert_trap (invoke "ref_as_i31" (i32.const 2)) "cast failure")
+(assert_trap (invoke "ref_as_i31" (i32.const 3)) "cast failure")
+(assert_trap (invoke "ref_as_i31" (i32.const 4)) "cast failure")
+(assert_trap (invoke "ref_as_i31" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_as_i31" (i32.const 6)) "cast failure")
+
+(assert_trap (invoke "ref_as_data" (i32.const 0)) "cast failure")
+(assert_trap (invoke "ref_as_data" (i32.const 1)) "cast failure")
+(assert_return (invoke "ref_as_data" (i32.const 2)))
+(assert_return (invoke "ref_as_data" (i32.const 3)))
+(assert_trap (invoke "ref_as_data" (i32.const 4)) "cast failure")
+(assert_trap (invoke "ref_as_data" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_as_data" (i32.const 6)) "cast failure")
+
+(assert_trap (invoke "ref_as_func" (i32.const 0)) "cast failure")
+(assert_trap (invoke "ref_as_func" (i32.const 1)) "cast failure")
+(assert_trap (invoke "ref_as_func" (i32.const 2)) "cast failure")
+(assert_trap (invoke "ref_as_func" (i32.const 3)) "cast failure")
+(assert_return (invoke "ref_as_func" (i32.const 4)))
+(assert_trap (invoke "ref_as_func" (i32.const 5)) "cast failure")
+(assert_trap (invoke "ref_as_func" (i32.const 6)) "cast failure")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as_non_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as_non_null.wast
new file mode 100644
index 0000000..ba5c454
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_as_non_null.wast
@@ -0,0 +1,46 @@
+(module
+  (type $t (func (result i32)))
+
+  (func $nn (param $r (ref $t)) (result i32)
+    (call_ref (ref.as_non_null (local.get $r)))
+  )
+  (func $n (param $r (ref null $t)) (result i32)
+    (call_ref (ref.as_non_null (local.get $r)))
+  )
+
+  (elem func $f)
+  (func $f (result i32) (i32.const 7))
+
+  (func (export "nullable-null") (result i32) (call $n (ref.null $t)))
+  (func (export "nonnullable-f") (result i32) (call $nn (ref.func $f)))
+  (func (export "nullable-f") (result i32) (call $n (ref.func $f)))
+
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (ref.as_non_null)
+    (call $nn)
+  )
+)
+
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_trap (invoke "nullable-null") "null reference")
+(assert_return (invoke "nonnullable-f") (i32.const 7))
+(assert_return (invoke "nullable-f") (i32.const 7))
+
+(assert_invalid
+  (module
+    (type $t (func (result i32)))
+    (func $g (param $r (ref $t)) (drop (ref.as_non_null (local.get $r))))
+    (func (call $g (ref.null $t)))
+  )
+  "type mismatch"
+)
+
+
+(module
+  (type $t (func))
+  (func (param $r (ref $t)) (drop (ref.as_non_null (local.get $r))))
+  (func (param $r (ref func)) (drop (ref.as_non_null (local.get $r))))
+  (func (param $r (ref extern)) (drop (ref.as_non_null (local.get $r))))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_cast.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_cast.wast
new file mode 100644
index 0000000..9a74a28
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_cast.wast
@@ -0,0 +1,81 @@
+(module
+  (type $t0 (struct))
+  (type $t1 (struct (field i32)))
+  (type $t1' (struct (field i32)))
+  (type $t2 (struct (field i32 i32)))
+  (type $t2' (struct (field i32 i32)))
+  (type $t3 (struct (field i32 i32)))
+
+  (global $t0 (rtt $t0) (rtt.canon $t0))
+  (global $t0' (rtt $t0) (rtt.canon $t0))
+  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
+  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
+  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
+  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
+  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
+  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
+
+  (table 20 dataref)
+
+  (func $init
+    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
+    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
+    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
+    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
+    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
+    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
+    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
+    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+  )
+
+  (func (export "test-sub")
+    (call $init)
+
+    (drop (ref.cast (ref.null data) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 0)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 1)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 3)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 4)) (global.get $t0)))
+
+    (drop (ref.cast (ref.null data) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 1)) (global.get $t1)))
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t1)))
+
+    (drop (ref.cast (ref.null data) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t2)))
+
+    (drop (ref.cast (ref.null data) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 3)) (global.get $t3)))
+
+    (drop (ref.cast (ref.null data) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 4)) (global.get $t4)))
+  )
+
+  (func (export "test-canon")
+    (call $init)
+
+    (drop (ref.cast (table.get (i32.const 0)) (global.get $t0')))
+    (drop (ref.cast (table.get (i32.const 1)) (global.get $t0')))
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t0')))
+    (drop (ref.cast (table.get (i32.const 3)) (global.get $t0')))
+    (drop (ref.cast (table.get (i32.const 4)) (global.get $t0')))
+
+    (drop (ref.cast (table.get (i32.const 10)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 11)) (global.get $t0)))
+    (drop (ref.cast (table.get (i32.const 12)) (global.get $t0)))
+
+    (drop (ref.cast (table.get (i32.const 1)) (global.get $t1')))
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t1')))
+
+    (drop (ref.cast (table.get (i32.const 11)) (global.get $t1)))
+    (drop (ref.cast (table.get (i32.const 12)) (global.get $t1)))
+
+    (drop (ref.cast (table.get (i32.const 2)) (global.get $t2')))
+
+    (drop (ref.cast (table.get (i32.const 12)) (global.get $t2)))
+  )
+)
+
+(invoke "test-sub")
+(invoke "test-canon")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_eq.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_eq.wast
new file mode 100644
index 0000000..5542f26
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_eq.wast
@@ -0,0 +1,353 @@
+(module
+  (type $st (struct))
+  (type $st' (struct (field i32)))
+  (type $at (array i8))
+
+  (table 20 (ref null eq))
+
+  (func (export "init")
+    (table.set (i32.const 0) (ref.null eq))
+    (table.set (i32.const 1) (ref.null i31))
+    (table.set (i32.const 2) (i31.new (i32.const 7)))
+    (table.set (i32.const 3) (i31.new (i32.const 7)))
+    (table.set (i32.const 4) (i31.new (i32.const 8)))
+    (table.set (i32.const 5) (struct.new_default $st (rtt.canon $st)))
+    (table.set (i32.const 6) (struct.new_default $st (rtt.canon $st)))
+    (table.set (i32.const 7) (array.new_default $at (i32.const 0) (rtt.canon $at)))
+    (table.set (i32.const 8) (array.new_default $at (i32.const 0) (rtt.canon $at)))
+    (table.set (i32.const 9) (rtt.canon $st))
+    (table.set (i32.const 10) (rtt.canon $st))
+    (table.set (i32.const 11) (rtt.canon $at))
+    (table.set (i32.const 12) (rtt.sub $st (rtt.canon $st)))
+    (table.set (i32.const 13) (rtt.sub $st (rtt.canon $st)))
+    (table.set (i32.const 14) (rtt.sub $st' (rtt.canon $st)))
+    (table.set (i32.const 15) (rtt.sub $st' (rtt.canon $st)))
+  )
+
+  (func (export "eq") (param $i i32) (param $j i32) (result i32)
+    (ref.eq (table.get (local.get $i)) (table.get (local.get $j)))
+  )
+)
+
+(invoke "init")
+
+(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 2) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 2) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 3) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 3) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 4) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 4)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 4) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 5) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 5)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 5) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 6) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 6)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 6) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 7) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 7)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 7) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 8) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 8)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 8) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 9) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 9)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 10)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 9) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 10) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 9)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 10)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 10) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 11) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 11)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 11) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 12) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 12)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 13)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 12) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 13) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 12)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 13)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 14)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 13) (i32.const 15)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 14) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 14)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 14) (i32.const 15)) (i32.const 1))
+
+(assert_return (invoke "eq" (i32.const 15) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 3)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 4)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 5)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 6)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 7)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 8)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 9)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 10)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 11)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 12)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 13)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 14)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 15) (i32.const 15)) (i32.const 1))
+
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref any)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref null any)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref func)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref null func)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref extern)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func (export "eq") (param $r (ref null extern)) (result i32)
+      (ref.eq (local.get $r) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is.wast
new file mode 100644
index 0000000..bfdc728
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is.wast
@@ -0,0 +1,67 @@
+(module
+  (type $ft (func))
+  (type $st (struct))
+  (type $at (array i8))
+
+  (table 10 anyref)
+
+  (elem declare func $f)
+  (func $f)
+
+  (func (export "init") (param $x externref)
+    (table.set (i32.const 0) (ref.null any))
+    (table.set (i32.const 1) (i31.new (i32.const 7)))
+    (table.set (i32.const 2) (struct.new_default $st (rtt.canon $st)))
+    (table.set (i32.const 3) (array.new_default $at (i32.const 0) (rtt.canon $at)))
+    (table.set (i32.const 4) (ref.func $f))
+    (table.set (i32.const 5) (rtt.canon $ft))
+    (table.set (i32.const 6) (local.get $x))
+  )
+
+  (func (export "ref_is_null") (param $i i32) (result i32)
+    (ref.is_null (table.get (local.get $i)))
+  )
+  (func (export "ref_is_i31") (param $i i32) (result i32)
+    (ref.is_i31 (table.get (local.get $i)))
+  )
+  (func (export "ref_is_data") (param $i i32) (result i32)
+    (ref.is_data (table.get (local.get $i)))
+  )
+  (func (export "ref_is_func") (param $i i32) (result i32)
+    (ref.is_func (table.get (local.get $i)))
+  )
+)
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "ref_is_null" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref_is_null" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ref_is_null" (i32.const 2)) (i32.const 0))
+(assert_return (invoke "ref_is_null" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_is_null" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_is_null" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_is_null" (i32.const 6)) (i32.const 0))
+
+(assert_return (invoke "ref_is_i31" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ref_is_i31" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref_is_i31" (i32.const 2)) (i32.const 0))
+(assert_return (invoke "ref_is_i31" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_is_i31" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_is_i31" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_is_i31" (i32.const 6)) (i32.const 0))
+
+(assert_return (invoke "ref_is_data" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ref_is_data" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ref_is_data" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "ref_is_data" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "ref_is_data" (i32.const 4)) (i32.const 0))
+(assert_return (invoke "ref_is_data" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_is_data" (i32.const 6)) (i32.const 0))
+
+(assert_return (invoke "ref_is_func" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ref_is_func" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ref_is_func" (i32.const 2)) (i32.const 0))
+(assert_return (invoke "ref_is_func" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "ref_is_func" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "ref_is_func" (i32.const 5)) (i32.const 0))
+(assert_return (invoke "ref_is_func" (i32.const 6)) (i32.const 0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is_null.wast
new file mode 100644
index 0000000..730170d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_is_null.wast
@@ -0,0 +1,85 @@
+(module
+  (type $t (func))
+  (func $dummy)
+
+  (func $f1 (export "funcref") (param $x funcref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f2 (export "externref") (param $x externref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f3 (param $x (ref null $t)) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f3' (export "ref-null") (result i32)
+    (call $f3 (ref.null $t))
+  )
+
+  (table $t1 2 funcref)
+  (table $t2 2 externref)
+  (table $t3 2 (ref null $t))
+  (elem (table $t1) (i32.const 1) func $dummy)
+  (elem (table $t3) (i32.const 1) (ref $t) (ref.func $dummy))
+
+  (func (export "init") (param $r externref)
+    (table.set $t2 (i32.const 1) (local.get $r))
+  )
+  (func (export "deinit")
+    (table.set $t1 (i32.const 1) (ref.null func))
+    (table.set $t2 (i32.const 1) (ref.null extern))
+    (table.set $t3 (i32.const 1) (ref.null $t))
+  )
+
+  (func (export "funcref-elem") (param $x i32) (result i32)
+    (call $f1 (table.get $t1 (local.get $x)))
+  )
+  (func (export "externref-elem") (param $x i32) (result i32)
+    (call $f2 (table.get $t2 (local.get $x)))
+  )
+  (func (export "ref-elem") (param $x i32) (result i32)
+    (call $f3 (table.get $t3 (local.get $x)))
+  )
+)
+
+(assert_return (invoke "funcref" (ref.null func)) (i32.const 1))
+(assert_return (invoke "externref" (ref.null extern)) (i32.const 1))
+(assert_return (invoke "ref-null") (i32.const 1))
+
+(assert_return (invoke "externref" (ref.extern 1)) (i32.const 0))
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ref-elem" (i32.const 1)) (i32.const 0))
+
+(invoke "deinit")
+
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ref-elem" (i32.const 1)) (i32.const 1))
+
+
+(module
+  (type $t (func))
+  (func (param $r (ref $t)) (drop (ref.is_null (local.get $r))))
+  (func (param $r (ref func)) (drop (ref.is_null (local.get $r))))
+  (func (param $r (ref extern)) (drop (ref.is_null (local.get $r))))
+)
+
+(assert_invalid
+  (module (func $ref-vs-num (param i32) (ref.is_null (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $ref-vs-empty (ref.is_null)))
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_null.wast
new file mode 100644
index 0000000..ab3a8b4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_null.wast
@@ -0,0 +1,14 @@
+(module
+  (type $t (func))
+  (func (export "externref") (result externref) (ref.null extern))
+  (func (export "funcref") (result funcref) (ref.null func))
+  (func (export "ref") (result (ref null $t)) (ref.null $t))
+
+  (global externref (ref.null extern))
+  (global funcref (ref.null func))
+  (global (ref null $t) (ref.null $t))
+)
+
+(assert_return (invoke "externref") (ref.null extern))
+(assert_return (invoke "funcref") (ref.null func))
+(assert_return (invoke "ref") (ref.null))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_test.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_test.wast
new file mode 100644
index 0000000..7012939
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/ref_test.wast
@@ -0,0 +1,111 @@
+(module
+  (type $t0 (struct))
+  (type $t1 (struct (field i32)))
+  (type $t1' (struct (field i32)))
+  (type $t2 (struct (field i32 i32)))
+  (type $t2' (struct (field i32 i32)))
+  (type $t3 (struct (field i32 i32)))
+
+  (global $t0 (rtt $t0) (rtt.canon $t0))
+  (global $t0' (rtt $t0) (rtt.canon $t0))
+  (global $t1 (rtt $t1) (rtt.sub $t1 (global.get $t0)))
+  (global $t1' (rtt $t1') (rtt.sub $t1' (global.get $t0)))
+  (global $t2 (rtt $t2) (rtt.sub $t2 (global.get $t1)))
+  (global $t2' (rtt $t2') (rtt.sub $t2' (global.get $t1')))
+  (global $t3 (rtt $t3) (rtt.sub $t3 (global.get $t0)))
+  (global $t4 (rtt $t3) (rtt.sub $t3 (rtt.sub $t0 (global.get $t0))))
+
+  (table 20 dataref)
+
+  (func $init
+    (table.set (i32.const 0) (struct.new_default $t0 (global.get $t0)))
+    (table.set (i32.const 10) (struct.new_default $t0 (global.get $t0')))
+    (table.set (i32.const 1) (struct.new_default $t1 (global.get $t1)))
+    (table.set (i32.const 11) (struct.new_default $t1' (global.get $t1')))
+    (table.set (i32.const 2) (struct.new_default $t2 (global.get $t2)))
+    (table.set (i32.const 12) (struct.new_default $t2' (global.get $t2')))
+    (table.set (i32.const 3) (struct.new_default $t3 (global.get $t3)))
+    (table.set (i32.const 4) (struct.new_default $t3 (global.get $t4)))
+  )
+
+  (func (export "test-sub")
+    (call $init)
+    (block $l
+      ;; must hold
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t3))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t4))))
+
+      ;; must not hold
+      (br_if $l (ref.test (ref.null data) (global.get $t0)))
+      (br_if $l (ref.test (ref.null data) (global.get $t1)))
+      (br_if $l (ref.test (ref.null data) (global.get $t2)))
+      (br_if $l (ref.test (ref.null data) (global.get $t3)))
+      (br_if $l (ref.test (ref.null data) (global.get $t4)))
+
+      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t1)))
+      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t1)))
+      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t1)))
+
+      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t2)))
+      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t2)))
+      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t2)))
+      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t2)))
+
+      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t3)))
+      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t3)))
+      (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t3)))
+      (br_if $l (ref.test (table.get (i32.const 4)) (global.get $t3)))
+
+      (br_if $l (ref.test (table.get (i32.const 0)) (global.get $t4)))
+      (br_if $l (ref.test (table.get (i32.const 1)) (global.get $t4)))
+      (br_if $l (ref.test (table.get (i32.const 2)) (global.get $t4)))
+      (br_if $l (ref.test (table.get (i32.const 3)) (global.get $t4)))
+
+      (return)
+    )
+    (unreachable)
+  )
+
+  (func (export "test-canon")
+    (call $init)
+    (block $l
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 0)) (global.get $t0'))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t0'))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t0'))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 3)) (global.get $t0'))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 4)) (global.get $t0'))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 10)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t0))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t0))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 1)) (global.get $t1'))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t1'))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 11)) (global.get $t1))))
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t1))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 2)) (global.get $t2'))))
+
+      (br_if $l (i32.eqz (ref.test (table.get (i32.const 12)) (global.get $t2))))
+
+      (return)
+    )
+    (unreachable)
+  )
+)
+
+(invoke "test-sub")
+(invoke "test-canon")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/return_call_ref.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/return_call_ref.wast
new file mode 100644
index 0000000..8e7aac8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/return_call_ref.wast
@@ -0,0 +1,360 @@
+;; Test `return_call_ref` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $-i32 (func (result i32)))
+  (type $-i64 (func (result i64)))
+  (type $-f32 (func (result f32)))
+  (type $-f64 (func (result f64)))
+
+  (type $i32-i32 (func (param i32) (result i32)))
+  (type $i64-i64 (func (param i64) (result i64)))
+  (type $f32-f32 (func (param f32) (result f32)))
+  (type $f64-f64 (func (param f64) (result f64)))
+
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+
+  (type $i64i64-i64 (func (param i64 i64) (result i64)))
+
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  (global $const-i32 (ref $-i32) (ref.func $const-i32))
+  (global $const-i64 (ref $-i64) (ref.func $const-i64))
+  (global $const-f32 (ref $-f32) (ref.func $const-f32))
+  (global $const-f64 (ref $-f64) (ref.func $const-f64))
+
+  (global $id-i32 (ref $i32-i32) (ref.func $id-i32))
+  (global $id-i64 (ref $i64-i64) (ref.func $id-i64))
+  (global $id-f32 (ref $f32-f32) (ref.func $id-f32))
+  (global $id-f64 (ref $f64-f64) (ref.func $id-f64))
+
+  (global $f32-i32 (ref $f32-i32) (ref.func $f32-i32))
+  (global $i32-i64 (ref $i32-i64) (ref.func $i32-i64))
+  (global $f64-f32 (ref $f64-f32) (ref.func $f64-f32))
+  (global $i64-f64 (ref $i64-f64) (ref.func $i64-f64))
+
+  (elem declare func
+    $const-i32 $const-i64 $const-f32 $const-f64
+    $id-i32 $id-i64 $id-f32 $id-f64
+    $f32-i32 $i32-i64 $f64-f32 $i64-f64
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (return_call_ref (global.get $const-i32))
+  )
+  (func (export "type-i64") (result i64)
+    (return_call_ref (global.get $const-i64))
+  )
+  (func (export "type-f32") (result f32)
+    (return_call_ref (global.get $const-f32))
+  )
+  (func (export "type-f64") (result f64)
+    (return_call_ref (global.get $const-f64))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (return_call_ref (i32.const 32) (global.get $id-i32))
+  )
+  (func (export "type-first-i64") (result i64)
+    (return_call_ref (i64.const 64) (global.get $id-i64))
+  )
+  (func (export "type-first-f32") (result f32)
+    (return_call_ref (f32.const 1.32) (global.get $id-f32))
+  )
+  (func (export "type-first-f64") (result f64)
+    (return_call_ref (f64.const 1.64) (global.get $id-f64))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (return_call_ref (f32.const 32.1) (i32.const 32) (global.get $f32-i32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (return_call_ref (i32.const 32) (i64.const 64) (global.get $i32-i64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (return_call_ref (f64.const 64) (f32.const 32) (global.get $f64-f32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (return_call_ref (i64.const 64) (f64.const 64.1) (global.get $i64-f64))
+  )
+
+  ;; Null
+
+  (func (export "null")
+    (return_call_ref (ref.null $proc))
+  )
+
+  ;; Recursion
+
+  (global $fac-acc (ref $i64i64-i64) (ref.func $fac-acc))
+
+  (elem declare func $fac-acc)
+  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (return_call_ref
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+          (global.get $fac-acc)
+        )
+      )
+    )
+  )
+
+  (global $count (ref $i64-i64) (ref.func $count))
+
+  (elem declare func $count)
+  (func $count (export "count") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 0))
+      (else
+        (return_call_ref
+          (i64.sub (local.get 0) (i64.const 1))
+          (global.get $count)
+        )
+      )
+    )
+  )
+
+  (global $even (ref $i64-i64) (ref.func $even))
+  (global $odd (ref $i64-i64) (ref.func $odd))
+
+  (elem declare func $even)
+  (func $even (export "even") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 44))
+      (else
+        (return_call_ref
+          (i64.sub (local.get 0) (i64.const 1))
+          (global.get $odd)
+        )
+      )
+    )
+  )
+  (elem declare func $odd)
+  (func $odd (export "odd") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 99))
+      (else
+        (return_call_ref
+          (i64.sub (local.get 0) (i64.const 1))
+          (global.get $even)
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_trap (invoke "null") "null function")
+
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "count" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1000)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1_000_000)) (i64.const 0))
+
+(assert_return (invoke "even" (i64.const 0)) (i64.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i64.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i64.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i64.const 99))
+(assert_return (invoke "even" (i64.const 1_000_000)) (i64.const 44))
+(assert_return (invoke "even" (i64.const 1_000_001)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i64.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i64.const 44))
+(assert_return (invoke "odd" (i64.const 1_000_000)) (i64.const 99))
+(assert_return (invoke "odd" (i64.const 999_999)) (i64.const 44))
+
+
+;; More typing
+
+(module
+  (type $t (func))
+  (elem declare func $f11 $f22 $f33 $f44)
+  (func $f11 (result (ref $t)) (return_call_ref (ref.func $f11)))
+  (func $f21 (result (ref null $t)) (return_call_ref (ref.func $f11)))
+  (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
+  (func $f31 (result (ref func)) (return_call_ref (ref.func $f11)))
+  (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+  (func $f41 (result (ref null func)) (return_call_ref (ref.func $f11)))
+  (func $f42 (result (ref null func)) (return_call_ref (ref.func $f22)))
+  (func $f43 (result (ref null func)) (return_call_ref (ref.func $f33)))
+  (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f22)
+    (func $f12 (result (ref $t)) (return_call_ref (ref.func $f22)))
+    (func $f22 (result (ref null $t)) (return_call_ref (ref.func $f22)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f33)
+    (func $f13 (result (ref $t)) (return_call_ref (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f44)
+    (func $f14 (result (ref $t)) (return_call_ref (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f33)
+    (func $f23 (result (ref null $t)) (return_call_ref (ref.func $f33)))
+    (func $f33 (result (ref func)) (return_call_ref (ref.func $f33)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (elem declare func $f44)
+    (func $f24 (result (ref null $t)) (return_call_ref (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (elem declare func $f44)
+    (func $f34 (result (ref func)) (return_call_ref (ref.func $f44)))
+    (func $f44 (result (ref null func)) (return_call_ref (ref.func $f44)))
+  )
+  "type mismatch"
+)
+
+
+;; Unreachable typing.
+
+(module
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (return_call_ref)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(module
+  (elem declare func $f)
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (ref.func $f)
+    (return_call_ref)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(module
+  (elem declare func $f)
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "unreachable") (result i32)
+    (unreachable)
+    (i32.const 0)
+    (ref.func $f)
+    (return_call_ref)
+    (i32.const 0)
+  )
+)
+(assert_trap (invoke "unreachable") "unreachable")
+
+(assert_invalid
+  (module
+    (elem declare func $f)
+    (func $f (param i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result i32)
+      (unreachable)
+      (i64.const 0)
+      (ref.func $f)
+      (return_call_ref)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (elem declare func $f)
+    (func $f (param i32) (result i32) (local.get 0))
+
+    (func (export "unreachable") (result i32)
+      (unreachable)
+      (ref.func $f)
+      (return_call_ref)
+      (i64.const 0)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f (param $r externref)
+      (return_call_ref (local.get $r))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/select.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/select.wast
new file mode 100644
index 0000000..e8130ba
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/select.wast
@@ -0,0 +1,625 @@
+(module
+  ;; Auxiliary
+  (func $dummy)
+  (table $tab funcref (elem $dummy))
+  (memory 1)
+
+  (func (export "select-i32") (param i32 i32 i32) (result i32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64") (param i64 i64 i32) (result i64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32") (param f32 f32 i32) (result f32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64") (param f64 f64 i32) (result f64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "select-i32-t") (param i32 i32 i32) (result i32)
+    (select (result i32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64-t") (param i64 i64 i32) (result i64)
+    (select (result i64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32-t") (param f32 f32 i32) (result f32)
+    (select (result f32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64-t") (param f64 f64 i32) (result f64)
+    (select (result f64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-funcref") (param funcref funcref i32) (result funcref)
+    (select (result funcref) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-externref") (param externref externref i32) (result externref)
+    (select (result externref) (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (type $t (func))
+  (func $tf) (elem declare func $tf)
+  (func (export "join-funcnull") (param i32) (result (ref null func))
+    (select (result (ref null func))
+      (ref.func $tf)
+      (ref.null func)
+      (local.get 0)
+    )
+  )
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+  (func (export "select_unreached_result_1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select_unreached_result_2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  ;; As the argument of control constructs and instructions
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)))
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (select (i32.const 2) (i32.const 3) (local.get 0)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (local.get 0))) (else (i32.const 4)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 4)))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table $t funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 1) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (select (i32.const 1) (i32.const 2) (local.get 0)) (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (local.get 0))))
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32) (local.set 0 (select (i32.const 1) (i32.const 2) (local.get 0))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a (select (i32.const 1) (i32.const 2) (local.get 0)))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load (select (i32.const 0) (i32.const 4) (local.get 0)))
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+  (func (export "as-binary-operand") (param i32) (result i32)
+    (i32.mul
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (block (result i32)
+      (i32.le_s (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (block (result i32)
+      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
+    )
+  )
+
+  (func (export "unreachable-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (func (export "unreachable-ref")
+    (unreachable)
+    (select)
+    (ref.is_null)
+    (drop)
+  )
+)
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+(assert_return (invoke "select-funcref" (ref.null func) (ref.null func) (i32.const 1)) (ref.null func))
+(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 1)) (ref.extern 1))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32-t" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "select-externref" (ref.extern 2) (ref.extern 1) (i32.const 0)) (ref.extern 1))
+
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_return (invoke "join-funcnull" (i32.const 1)) (ref.func))
+(assert_return (invoke "join-funcnull" (i32.const 0)) (ref.null))
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)))
+(assert_return (invoke "as-if-condition" (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
+;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-left" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-convert-operand" (i32.const 1)) (i32.const 1))
+
+(assert_invalid
+  (module (func $arity-0-implicit (select (nop) (nop) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $arity-0 (select (result) (nop) (nop) (i32.const 1))))
+  "invalid result arity"
+)
+(assert_invalid
+  (module (func $arity-2 (result i32 i32)
+    (select (result i32 i32)
+      (i32.const 0) (i32.const 0)
+      (i32.const 0) (i32.const 0)
+      (i32.const 1)
+    )
+  ))
+  "invalid result arity"
+)
+
+
+(assert_invalid
+  (module (type $t (func))
+    (func $type-ref-implicit (param $r (ref $t))
+      (drop (select (local.get $r) (local.get $r) (i32.const 1)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-funcref-implicit (param $r funcref)
+    (drop (select (local.get $r) (local.get $r) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-externref-implicit (param $r externref)
+    (drop (select (local.get $r) (local.get $r) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (i64.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f32.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f64.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f64.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty
+      (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty
+      (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty
+      (i32.const 0) (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (block (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (loop (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-then
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (then (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-then
+      (i32.const 0)
+      (if (then (i32.const 0) (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+;; Third operand must be i32
+
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (f32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (f64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands
+
+(assert_invalid
+  (module (func (result i32) (select (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+;; Validation after unreachable
+
+;; The first two operands should have the same type as each other
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Third operand must be i32
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands (type of second operand when first one is omitted)
+(assert_invalid
+  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+;; select always has non-empty result
+(assert_invalid
+  (module (func (unreachable) (select)))
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/struct.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/struct.wast
new file mode 100644
index 0000000..50a0e1d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/struct.wast
@@ -0,0 +1,127 @@
+;; Type syntax
+
+(module
+  (type (struct))
+  (type (struct (field)))
+  (type (struct (field i8)))
+  (type (struct (field i8 i8 i8 i8)))
+  (type (struct (field $x1 i32) (field $y1 i32)))
+  (type (struct (field i8 i16 i32 i64 f32 f64 anyref funcref (ref 0) (ref null 1))))
+  (type (struct (field i32 i64 i8) (field) (field) (field (ref null i31) anyref)))
+  (type (struct (field $x2 i32) (field f32 f64) (field $y2 i32)))
+)
+
+
+(assert_malformed
+  (module quote
+    "(type (struct (field $x i32) (field $x i32)))"
+  )
+  "duplicate field"
+)
+(assert_malformed
+  (module quote
+    "(type (struct (field $x i32)))"
+    "(type (struct (field $x i32)))"
+  )
+  "duplicate field"
+)
+
+
+;; Binding structure
+
+(module
+  (type $s0 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+  (type $s1 (struct (field (ref 0) (ref 1) (ref $s0) (ref $s1))))
+
+  (func (param (ref $forward)))
+
+  (type $forward (struct))
+)
+
+(assert_invalid
+  (module (type (struct (field (ref 1)))))
+  "unknown type"
+)
+(assert_invalid
+  (module (type (struct (field (mut (ref 1))))))
+  "unknown type"
+)
+
+
+;; Basic instructions
+
+(module
+  (type $vec (struct (field f32) (field $y (mut f32)) (field $z f32)))
+
+  (func $get_0 (param $v (ref $vec)) (result f32)
+    (struct.get $vec 0 (local.get $v))
+  )
+  (func (export "get_0") (result f32)
+    (call $get_0 (struct.new_default $vec (rtt.canon $vec)))
+  )
+
+  (func $set_get_y (param $v (ref $vec)) (param $y f32) (result f32)
+    (struct.set $vec $y (local.get $v) (local.get $y))
+    (struct.get $vec $y (local.get $v))
+  )
+  (func (export "set_get_y") (param $y f32) (result f32)
+    (call $set_get_y (struct.new_default $vec (rtt.canon $vec)) (local.get $y))
+  )
+
+  (func $set_get_1 (param $v (ref $vec)) (param $y f32) (result f32)
+    (struct.set $vec 1 (local.get $v) (local.get $y))
+    (struct.get $vec $y (local.get $v))
+  )
+  (func (export "set_get_1") (param $y f32) (result f32)
+    (call $set_get_1 (struct.new_default $vec (rtt.canon $vec)) (local.get $y))
+  )
+)
+
+(assert_return (invoke "get_0") (f32.const 0))
+(assert_return (invoke "set_get_y" (f32.const 7)) (f32.const 7))
+(assert_return (invoke "set_get_1" (f32.const 7)) (f32.const 7))
+
+(assert_invalid
+  (module
+    (type $s (struct (field i64)))
+    (func (export "struct.set-immutable") (param $s (ref $s))
+      (struct.set $s 0 (local.get $s) (i64.const 1))
+    )
+  )
+  "field is immutable"
+)
+
+
+;; Null dereference
+
+(module
+  (type $t (struct (field i32 (mut i32))))
+  (func (export "struct.get-null")
+    (local (ref null $t)) (drop (struct.get $t 1 (local.get 0)))
+  )
+  (func (export "struct.set-null")
+    (local (ref null $t)) (struct.set $t 1 (local.get 0) (i32.const 0))
+  )
+)
+
+(assert_trap (invoke "struct.get-null") "null structure")
+(assert_trap (invoke "struct.set-null") "null structure")
+
+(assert_invalid
+  (module
+    (type $t (struct (field i32 (mut i32))))
+    (func (export "struct.new-null")
+      (local (ref null (rtt $t))) (drop (struct.new $t (i32.const 1) (i32.const 2) (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (struct (field i32 (mut i32))))
+    (func (export "struct.new_default-null")
+      (local (ref null (rtt $t))) (drop (struct.new_default $t (local.get 0)))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table-sub.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table-sub.wast
new file mode 100644
index 0000000..c3a7440
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table-sub.wast
@@ -0,0 +1,32 @@
+(module
+  (type $t (func))
+  (table $t1 10 (ref null func))
+  (table $t2 10 (ref null $t))
+  (elem $el funcref)
+  (func $f
+    (table.init $t1 $el (i32.const 0) (i32.const 1) (i32.const 2))
+    (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2))
+  )
+)
+
+(assert_invalid
+  (module
+    (table $t1 10 funcref)
+    (table $t2 10 externref)
+    (func $f
+      (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 funcref)
+    (elem $el externref)
+    (func $f
+      (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table.wast
new file mode 100644
index 0000000..532c13d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/table.wast
@@ -0,0 +1,70 @@
+;; Test table section structure
+
+(module (table 0 funcref))
+(module (table 1 funcref))
+(module (table 0 0 funcref))
+(module (table 0 1 funcref))
+(module (table 1 256 funcref))
+(module (table 0 65536 funcref))
+(module (table 0 0xffff_ffff funcref))
+
+(module (table 1 (ref null func)))
+(module (table 1 (ref null extern)))
+(module (table 1 (ref null $t)) (type $t (func)))
+
+(module (table 0 funcref) (table 0 funcref))
+(module (table (import "spectest" "table") 0 funcref) (table 0 funcref))
+
+(assert_invalid (module (elem (i32.const 0))) "unknown table")
+(assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table")
+
+
+(assert_invalid
+  (module (table 1 0 funcref))
+  "size minimum must not be greater than maximum"
+)
+(assert_invalid
+  (module (table 0xffff_ffff 0 funcref))
+  "size minimum must not be greater than maximum"
+)
+
+(assert_malformed
+  (module quote "(table 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(table 0x1_0000_0000 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(table 0 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+
+(assert_invalid
+  (module (table 0 (ref func)))
+  "non-defaultable element type"
+)
+(assert_invalid
+  (module (table 0 (ref extern)))
+  "non-defaultable element type"
+)
+(assert_invalid
+  (module (type $t (func)) (table 0 (ref $t)))
+  "non-defaultable element type"
+)
+
+;; Duplicate table identifiers
+
+(assert_malformed (module quote
+  "(table $foo 1 funcref)"
+  "(table $foo 1 funcref)")
+  "duplicate table")
+(assert_malformed (module quote
+  "(import \"\" \"\" (table $foo 1 funcref))"
+  "(table $foo 1 funcref)")
+  "duplicate table")
+(assert_malformed (module quote
+  "(import \"\" \"\" (table $foo 1 funcref))"
+  "(import \"\" \"\" (table $foo 1 funcref))")
+  "duplicate table")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/type-equivalence.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/type-equivalence.wast
new file mode 100644
index 0000000..e43871a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/type-equivalence.wast
@@ -0,0 +1,447 @@
+;; Syntactic types (validation time)
+
+;; Simple types.
+
+(module
+  (type $t1 (func (param f32 f32) (result f32)))
+  (type $t2 (func (param $x f32) (param $y f32) (result f32)))
+
+  (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r)))
+  (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r)))
+)
+
+
+;; Indirect types.
+
+(module
+  (type $s0 (func (param i32) (result f32)))
+  (type $s1 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $s2 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $t1 (func (param (ref $s1)) (result (ref $s2))))
+  (type $t2 (func (param (ref $s2)) (result (ref $s1))))
+
+  (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r)))
+  (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r)))
+)
+
+
+;; Recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t2))))
+
+  (func $f1 (param $r (ref $t1)) (call $f2 (local.get $r)))
+  (func $f2 (param $r (ref $t2)) (call $f1 (local.get $r)))
+)
+
+
+;; Isomorphic recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $t2))))
+
+  (func $f1 (param $r (ref $t1))
+    (call $f2 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f2 (param $r (ref $t2))
+    (call $f1 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f3 (param $r (ref $t3))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+  )
+)
+
+(module
+  (type $t1 (func (param i32 (ref $t3))))
+  (type $t2 (func (param i32 (ref $t1))))
+  (type $t3 (func (param i32 (ref $t2))))
+
+  (func $f1 (param $r (ref $t1))
+    (call $f2 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f2 (param $r (ref $t2))
+    (call $f1 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f3 (param $r (ref $t3))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+  )
+)
+
+(module
+  (type $t1 (func (param i32 (ref $u1))))
+  (type $u1 (func (param f32 (ref $t1))))
+
+  (type $t2 (func (param i32 (ref $u3))))
+  (type $u2 (func (param f32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $u2))))
+  (type $u3 (func (param f32 (ref $t2))))
+
+  (func $f1 (param $r (ref $t1))
+    (call $f2 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f2 (param $r (ref $t2))
+    (call $f1 (local.get $r))
+    (call $f3 (local.get $r))
+  )
+  (func $f3 (param $r (ref $t3))
+    (call $f1 (local.get $r))
+    (call $f2 (local.get $r))
+  )
+)
+
+
+;; Semantic types (run time)
+
+;; Simple types.
+
+(module
+  (type $t1 (func (param f32 f32)))
+  (type $t2 (func (param $x f32) (param $y f32)))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (table funcref (elem $f1 $f2))
+
+  (func (export "run")
+    (call_indirect (type $t1) (f32.const 1) (f32.const 2) (i32.const 1))
+    (call_indirect (type $t2) (f32.const 1) (f32.const 2) (i32.const 0))
+  )
+)
+(assert_return (invoke "run"))
+
+
+;; Indirect types.
+
+(module
+  (type $s0 (func (param i32)))
+  (type $s1 (func (param i32 (ref $s0))))
+  (type $s2 (func (param i32 (ref $s0))))
+  (type $t1 (func (param (ref $s1))))
+  (type $t2 (func (param (ref $s2))))
+
+  (func $s1 (type $s1))
+  (func $s2 (type $s2))
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (table funcref (elem $f1 $f2 $s1 $s2))
+
+  (func (export "run")
+    (call_indirect (type $t1) (ref.func $s1) (i32.const 0))
+    (call_indirect (type $t1) (ref.func $s1) (i32.const 1))
+    (call_indirect (type $t1) (ref.func $s2) (i32.const 0))
+    (call_indirect (type $t1) (ref.func $s2) (i32.const 1))
+    (call_indirect (type $t2) (ref.func $s1) (i32.const 0))
+    (call_indirect (type $t2) (ref.func $s1) (i32.const 1))
+    (call_indirect (type $t2) (ref.func $s2) (i32.const 0))
+    (call_indirect (type $t2) (ref.func $s2) (i32.const 1))
+  )
+)
+(assert_return (invoke "run"))
+
+
+;; Recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t2))))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (table funcref (elem $f1 $f2))
+
+  (func (export "run")
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
+  )
+)
+(assert_return (invoke "run"))
+
+
+;; Isomorphic recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $t2))))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (func $f3 (type $t3))
+  (table funcref (elem $f1 $f2 $f3))
+
+  (func (export "run")
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
+  )
+)
+(assert_return (invoke "run"))
+
+(module
+  (type $t1 (func (param i32 (ref $t3))))
+  (type $t2 (func (param i32 (ref $t1))))
+  (type $t3 (func (param i32 (ref $t2))))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (func $f3 (type $t3))
+  (table funcref (elem $f1 $f2 $f3))
+
+  (func (export "run")
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $f3) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $f3) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f1) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f2) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $f3) (i32.const 2))
+  )
+)
+(assert_return (invoke "run"))
+
+(module
+  (type $t1 (func (param i32 (ref $u1))))
+  (type $u1 (func (param f32 (ref $t1))))
+
+  (type $t2 (func (param i32 (ref $u3))))
+  (type $u2 (func (param f32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $u2))))
+  (type $u3 (func (param f32 (ref $t2))))
+
+  (func $f1 (type $t1))
+  (func $f2 (type $t2))
+  (func $f3 (type $t3))
+  (func $g1 (type $u1))
+  (func $g2 (type $u2))
+  (func $g3 (type $u3))
+  (table funcref (elem $f1 $f2 $f3 $g1 $g2 $g3))
+
+  (func (export "run")
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g1) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g2) (i32.const 2))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 0))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 1))
+    (call_indirect (type $t1) (i32.const 1) (ref.func $g3) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g1) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g2) (i32.const 2))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 0))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 1))
+    (call_indirect (type $t2) (i32.const 1) (ref.func $g3) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g1) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g2) (i32.const 2))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 0))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 1))
+    (call_indirect (type $t3) (i32.const 1) (ref.func $g3) (i32.const 2))
+  )
+)
+(assert_return (invoke "run"))
+
+
+;; Semantic types (link time)
+
+;; Simple types.
+
+(module
+  (type $t1 (func (param f32 f32) (result f32)))
+  (func (export "f") (param (ref $t1)))
+)
+(register "M")
+(module
+  (type $t2 (func (param $x f32) (param $y f32) (result f32)))
+  (func (import "M" "f") (param (ref $t2)))
+)
+
+
+;; Indirect types.
+
+(module
+  (type $s0 (func (param i32) (result f32)))
+  (type $s1 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $s2 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $t1 (func (param (ref $s1)) (result (ref $s2))))
+  (type $t2 (func (param (ref $s2)) (result (ref $s1))))
+  (func (export "f1") (param (ref $t1)))
+  (func (export "f2") (param (ref $t1)))
+)
+(register "M")
+(module
+  (type $s0 (func (param i32) (result f32)))
+  (type $s1 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $s2 (func (param i32 (ref $s0)) (result (ref $s0))))
+  (type $t1 (func (param (ref $s1)) (result (ref $s2))))
+  (type $t2 (func (param (ref $s2)) (result (ref $s1))))
+  (func (import "M" "f1") (param (ref $t1)))
+  (func (import "M" "f1") (param (ref $t2)))
+  (func (import "M" "f2") (param (ref $t1)))
+  (func (import "M" "f2") (param (ref $t1)))
+)
+
+
+;; Recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (func (export "f") (param (ref $t1)))
+)
+(register "M")
+(module
+  (type $t2 (func (param i32 (ref $t2))))
+  (func (import "M" "f") (param (ref $t2)))
+)
+
+
+;; Isomorphic recursive types.
+
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $t2))))
+  (func (export "f1") (param (ref $t1)))
+  (func (export "f2") (param (ref $t2)))
+  (func (export "f3") (param (ref $t3)))
+)
+(register "M")
+(module
+  (type $t1 (func (param i32 (ref $t1))))
+  (type $t2 (func (param i32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $t2))))
+  (func (import "M" "f1") (param (ref $t1)))
+  (func (import "M" "f1") (param (ref $t2)))
+  (func (import "M" "f1") (param (ref $t3)))
+  (func (import "M" "f2") (param (ref $t1)))
+  (func (import "M" "f2") (param (ref $t2)))
+  (func (import "M" "f2") (param (ref $t3)))
+  (func (import "M" "f3") (param (ref $t1)))
+  (func (import "M" "f3") (param (ref $t2)))
+  (func (import "M" "f3") (param (ref $t3)))
+)
+
+(module
+  (type $t1 (func (param i32 (ref $t3))))
+  (type $t2 (func (param i32 (ref $t1))))
+  (type $t3 (func (param i32 (ref $t2))))
+  (func (export "f1") (param (ref $t1)))
+  (func (export "f2") (param (ref $t2)))
+  (func (export "f3") (param (ref $t3)))
+)
+(register "M")
+(module
+  (type $t1 (func (param i32 (ref $t3))))
+  (type $t2 (func (param i32 (ref $t1))))
+  (type $t3 (func (param i32 (ref $t2))))
+  (func (import "M" "f1") (param (ref $t1)))
+  (func (import "M" "f1") (param (ref $t2)))
+  (func (import "M" "f1") (param (ref $t3)))
+  (func (import "M" "f2") (param (ref $t1)))
+  (func (import "M" "f2") (param (ref $t2)))
+  (func (import "M" "f2") (param (ref $t3)))
+  (func (import "M" "f3") (param (ref $t1)))
+  (func (import "M" "f3") (param (ref $t2)))
+  (func (import "M" "f3") (param (ref $t3)))
+)
+
+(module
+  (type $t1 (func (param i32 (ref $u1))))
+  (type $u1 (func (param f32 (ref $t1))))
+
+  (type $t2 (func (param i32 (ref $u3))))
+  (type $u2 (func (param f32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $u2))))
+  (type $u3 (func (param f32 (ref $t2))))
+
+  (func (export "f1") (param (ref $t1)))
+  (func (export "f2") (param (ref $t2)))
+  (func (export "f3") (param (ref $t3)))
+)
+(register "M")
+(module
+  (type $t1 (func (param i32 (ref $u1))))
+  (type $u1 (func (param f32 (ref $t1))))
+
+  (type $t2 (func (param i32 (ref $u3))))
+  (type $u2 (func (param f32 (ref $t3))))
+  (type $t3 (func (param i32 (ref $u2))))
+  (type $u3 (func (param f32 (ref $t2))))
+
+  (func (import "M" "f1") (param (ref $t1)))
+  (func (import "M" "f1") (param (ref $t2)))
+  (func (import "M" "f1") (param (ref $t3)))
+  (func (import "M" "f2") (param (ref $t1)))
+  (func (import "M" "f2") (param (ref $t2)))
+  (func (import "M" "f2") (param (ref $t3)))
+  (func (import "M" "f3") (param (ref $t1)))
+  (func (import "M" "f3") (param (ref $t2)))
+  (func (import "M" "f3") (param (ref $t3)))
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/unreached-invalid.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/unreached-invalid.wast
new file mode 100644
index 0000000..5196563
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/gc/unreached-invalid.wast
@@ -0,0 +1,706 @@
+;; Failures in unreachable code.
+
+(assert_invalid
+  (module (func $local-index (unreachable) (drop (local.get 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $global-index (unreachable) (drop (global.get 0))))
+  "unknown global"
+)
+(assert_invalid
+  (module (func $func-index (unreachable) (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $label-index (unreachable) (br 1)))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (unreachable) (drop (i64.eqz (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-num-vs-num (result i32)
+    (unreachable) (i64.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-transitive-num-vs-num (result i32)
+    (unreachable)
+    (i64.const 0) (i32.const 0) (select)
+    (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unconsumed-const (unreachable) (i32.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result (unreachable) (i32.eqz)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result2
+    (unreachable) (i32.const 0) (i32.add)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly0 (unreachable) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly2
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-break
+    (block (br 0) (block (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-break
+    (block (br 0) (drop (i32.eqz (f32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-break
+    (block (br 0) (block (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-break
+    (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-break
+    (block (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-break (result i32)
+    (block (result i32) (i32.const 1) (br 0) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-break
+    (block (loop (br 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-break (result i32)
+    (loop (result i32) (br 1 (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-break
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-break (result i32)
+    (br 0 (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-return
+    (return) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-return
+    (return) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-return
+    (return) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-return
+    (return) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-return
+    (block (return) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-return (result i32)
+    (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-return
+    (block (loop (return) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-return (result i32)
+    (loop (result i32) (return (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-return
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-return (result i32)
+    (return (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-loop-after-unreachable
+    (unreachable) (loop (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable
+    (unreachable) (loop (result i32) (i32.eqz (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-unreachable
+    (unreachable) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-unreachable
+    (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-unreachable
+    (block (unreachable) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (i32.const 1) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-unreachable
+    (block (loop (unreachable) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-unreachable (result i32)
+    (loop (result i32) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-unreachable
+    (unreachable) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-unreachable (result i32)
+    (unreachable) (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-if-after-unreachable
+    (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable
+    (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable-if
+    (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-nested-unreachable
+    (block (block (unreachable)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-nested-unreachable
+    (block (loop (block (unreachable)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (loop (result i32) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (unreachable)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-infinite-loop
+    (block (loop (br 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32)
+    (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-infinite-loop
+    (block (loop (loop (br 0)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (result i32) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-infinite-loop
+    (loop (br 0)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (br 0)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (f32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (block (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (loop (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-second-num-vs-num (result i32)
+    (return (i32.const 1)) (return (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br-second-num-vs-num (result i32)
+    (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br_if-cond-num-vs-num-after-unreachable
+    (block (br_if 0 (unreachable) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-void-after-unreachable (result i32)
+    (block (result i32)
+      (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+      (drop) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num2-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-num-vs-num-after-unreachable
+    (block (br_table 0 (unreachable) (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-label-void-after-unreachable
+    (block
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 0 (i32.const 1))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-void
+    (block (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-void-vs-num (result i32)
+    (block (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-void
+    (block (i32.const 3) (block (br 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-void-vs-num (result i32)
+    (block (result i32) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-num (result i32)
+    (block (result i32) (i64.const 0) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-void
+    (block (block (i32.const 3) (block (br 2))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-void-vs-num (result i32)
+    (block (result i32) (block (block (br 2 (i32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-num (result i32)
+    (block (result i32)
+      (block (result i64) (i64.const 0) (block (br 2 (i32.const 0))))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-void
+    (block (i32.const 3) (block (return)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-void-vs-num (result i32)
+    (block (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (return (i32.const 0))))
+    (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-void
+    (loop (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32)
+    (loop (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32)
+    (loop (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-cont-last-void-vs-empty (result i32)
+    (loop (br 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cont-last-num-vs-empty (result i32)
+    (loop (br 0 (i32.const 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $tee-local-unreachable-value
+    (local i32)
+    (local.tee 0 (unreachable))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $br_if-unreachable (result i32)
+    (block (result i32)
+      (block
+        (br_if 1 (unreachable) (i32.const 0))
+      )
+      (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid 
+  (module
+    (func $type-br_if-after-unreachable (result i64)
+      (unreachable)
+      (br_if 0)
+      (i64.extend_i32_u)
+    )
+  )
+ "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-after-ref.as_non_null
+      (unreachable)
+      (ref.as_non_null)
+      (f32.abs)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/binary.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/binary.wast
new file mode 100644
index 0000000..de625bf
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/binary.wast
@@ -0,0 +1,811 @@
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
+
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+
+;; Malformed binary version.
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+
+;; call_indirect reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\09\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\01"                      ;; call_indirect reserved byte is not equal to zero!
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; call_indirect reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0a\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\00"                   ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0b\01"               ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\00"                ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0c\01"               ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\00"             ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0d\01"               ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\80\00"          ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.grow reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; No more than 2^32 locals.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+;; Local count can be 0.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"     ;; Type section
+  "\03\02\01\00"           ;; Function section
+  "\0a\0a\01"              ;; Code section
+
+  ;; function 0
+  "\08\03"
+  "\00\7f"                 ;; 0 i32
+  "\00\7e"                 ;; 0 i64
+  "\02\7d"                 ;; 2 f32
+  "\0b"                    ;; end
+)
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)
+
+;; Type count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\01\00"                               ;; type count can be zero
+)
+
+;; 2 type declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\02"                             ;; type section with inconsistent count (2 declared, 1 given)
+    "\60\00\00"                             ;; 1st type
+    ;; "\60\00\00"                          ;; 2nd type (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 type declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01"                             ;; type section with inconsistent count (1 declared, 2 given)
+    "\60\00\00"                             ;; 1st type
+    "\60\00\00"                             ;; 2nd type (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Import count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                             ;; type section
+    "\60\01\7f\00"                          ;; type 0
+    "\02\01\00"                             ;; import count can be zero
+)
+
+;; 2 import declared, 1 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\05\01"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\02\16\02"                           ;; import section with inconsistent count (2 declared, 1 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 import declared, 2 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\09\02"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\60\01\7d\00"                        ;; type 1
+      "\02\2b\01"                           ;; import section with inconsistent count (1 declared, 2 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (redundant)
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\66\33\32"         ;; print_f32
+      "\00\01"                              ;; import kind, import signature index
+  )
+  "section size mismatch"
+)
+
+;; Table count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\04\01\00"                             ;; table count can be zero
+)
+
+;; 1 table declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\01"                           ;; table section with inconsistent count (1 declared, 0 given)
+      ;; "\70\01\00\00"                     ;; table entity
+  )
+  "unexpected end of section or function"
+)
+
+;; Memory count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                             ;; memory count can be zero
+)
+
+;; 1 memory declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\01"                           ;; memory section with inconsistent count (1 declared, 0 given)
+      ;; "\00\00"                           ;; memory 0 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; Global count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\01\00"                               ;; global count can be zero
+)
+
+;; 2 global declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\06\02"                             ;; global section with inconsistent count (2 declared, 1 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    ;; "\7f\00\41\00\0b"                    ;; global 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 global declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                             ;; global section with inconsistent count (1 declared, 2 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    "\7f\00\41\00\0b"                       ;; global 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Export count can be 0
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\03\02\00\00"                         ;; func section
+  "\07\01\00"                               ;; export count can be zero
+  "\0a\07\02"                               ;; code section
+  "\02\00\0b"                               ;; function body 0
+  "\02\00\0b"                               ;; function body 1
+)
+
+;; 2 export declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\06\02"                             ;; export section with inconsistent count (2 declared, 1 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    ;; "\02"                                ;; export 1 (missed)
+    ;; "\66\32"                             ;; export name
+    ;; "\00\01"                             ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 export declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\0b\01"                             ;; export section with inconsistent count (1 declared, 2 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    "\02"                                   ;; export 1 (redundant)
+    "\66\32"                                ;; export name
+    "\00\01"                                ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "section size mismatch"
+)
+
+;; elem segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\04\04\01"                               ;; table section
+  "\70\00\01"                               ;; table 0
+  "\09\01\00"                               ;; elem segment count can be zero
+  "\0a\04\01"                               ;; code section
+  "\02\00\0b"                               ;; function body
+)
+
+;; 2 elem segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    ;; "\00\41\00\0b\01\00"                 ;; elem 1 (missed)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "unexpected end"
+)
+
+;; 1 elem segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\0d\01"                             ;; elem with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00\0b\01\00"                    ;; elem 1 (redundant)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "section size mismatch"
+)
+
+;; data segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                               ;; memory section
+  "\00\01"                                  ;; memory 0
+  "\0b\01\00"                               ;; data segment count can be zero
+)
+
+;; 2 data segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\07\02"                             ;; data with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    ;; "\00\41\01\0b\01\62"                 ;; data 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 data segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0d\01"                             ;; data with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    "\00\41\01\0b\01\62"                    ;; data 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; data segment has 7 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\03\0b"                          ;; data segment 0
+    "\07"                                   ;; data segment size with inconsistent lengths (7 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "unexpected end of section or function"
+)
+
+;; data segment has 5 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\00\0b"                          ;; data segment 0
+    "\05"                                   ;; data segment size with inconsistent lengths (5 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "section size mismatch"
+)
+
+;; br_table target count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\0a\11\01"                               ;; code section
+  "\0f\00"                                  ;; func 0
+  "\02\40"                                  ;; block 0
+  "\41\01"                                  ;; condition of if 0
+  "\04\40"                                  ;; if 0
+  "\41\01"                                  ;; index of br_table element
+  "\0e\00"                                  ;; br_table target count can be zero
+  "\02"                                     ;; break depth for default
+  "\0b\0b\0b"                               ;; end
+)
+
+;; 2 br_table target declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\10\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\02"                                ;; br_table with inconsistent target count (2 declared, 1 given)
+    "\00"                                   ;; break depth 0
+    ;; "\01"                                ;; break depth 1 (missed)
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 br_table target declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\11\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
+    "\00"                                   ;; break depth 0
+    "\01"                                   ;; break depth 1
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end"
+)
+
+;; Start section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"       ;; Type section
+  "\03\02\01\00"             ;; Function section
+  "\08\01\00"                ;; Start section: function 0
+
+  "\0a\04\01"                ;; Code section
+  ;; function 0
+  "\02\00"
+  "\0b"                      ;; end
+)
+
+;; Multiple start sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\08\01\00"                ;; Start section: function 0
+    "\08\01\00"                ;; Start section: function 0
+
+    "\0a\04\01"                ;; Code section
+    ;; function 0
+    "\02\00"
+    "\0b"                      ;; end
+  )
+  "junk after last section"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/block.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/block.wast
new file mode 100644
index 0000000..44915b9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/block.wast
@@ -0,0 +1,1491 @@
+;; Test `block` operator
+
+(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty")
+    (block)
+    (block $l)
+  )
+
+  (func (export "singular") (result i32)
+    (block (nop))
+    (block (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (block (call $dummy) (call $dummy) (call $dummy) (call $dummy))
+    (block (result i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 7) (call $dummy)
+    )
+    (drop)
+    (block (result i32 i64 i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (block (result i32)
+      (block (call $dummy) (block) (nop))
+      (block (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (block (result i32) (block (result i32)
+      (block (result i32) (block (result i32)
+        (block (result i32) (block (result i32)
+          (block (result i32) (block (result i32)
+            (block (result i32) (block (result i32)
+              (block (result i32) (block (result i32)
+                (block (result i32) (block (result i32)
+                  (block (result i32) (block (result i32)
+                    (block (result i32) (block (result i32)
+                      (block (result i32) (block (result i32)
+                        (block (result i32) (block (result i32)
+                          (block (result i32) (block (result i32)
+                            (block (result i32) (block (result i32)
+                              (block (result i32) (block (result i32)
+                                (block (result i32) (block (result i32)
+                                  (block (result i32) (block (result i32)
+                                    (block (result i32) (block (result i32)
+                                      (block (result i32) (block (result i32)
+                                        (block (result i32) (block (result i32)
+                                          (call $dummy) (i32.const 150)
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (block (result i32) (i32.const 1)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (block (result i32) (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (block (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (block (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (block (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (block (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (block (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (block (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (block (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (block (result i32) (i32.const 1)))
+    (global.get $a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (block (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (block (result i32) (call $dummy) (i32.const 3))
+      (block (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (block (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (block (result f32) (call $dummy) (f32.const 3))
+      (block (result f32) (call $dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (block (result i32 i32)
+        (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (block (result f32 f32)
+        (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (block (result i32 i32)
+      (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (br 0) (unreachable))
+    (block (br_if 0 (i32.const 1)) (unreachable))
+    (block (br_table 0 (i32.const 0)) (unreachable))
+    (block (br_table 0 0 0 (i32.const 1)) (unreachable))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32) (br 0 (i32.const 18)) (i32.const 19))
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (br 0 (i32.const 18))
+      (br 0 (i32.const 19))
+      (drop (br_if 0 (i32.const 20) (i32.const 0)))
+      (drop (br_if 0 (i32.const 20) (i32.const 1)))
+      (br 0 (i32.const 21))
+      (br_table 0 (i32.const 22) (i32.const 4))
+      (br_table 0 0 0 (i32.const 23) (i32.const 1))
+      (i32.const 21)
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
+    )
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
+    )
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (i32.const 1)
+    (block (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32)
+      (i32.add)
+      (br 0)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (block (param i32 i32) (result i32 i32) (br 0))
+    (i32.add)
+  )
+
+  (func (export "effects") (result i32)
+    (local i32)
+    (block
+      (local.set 0 (i32.const 1))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+      (br 0)
+      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (block (type $block-sig-1))
+    (block (type $block-sig-2) (i32.const 0))
+    (block (type $block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $block-sig-4))
+    (drop) (drop) (drop)
+    (block (type $block-sig-2) (result i32) (i32.const 0))
+    (block (type $block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (block (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "singular") (i32.const 7))
+(assert_return (invoke "multi") (i32.const 8))
+(assert_return (invoke "nested") (i32.const 9))
+(assert_return (invoke "deep") (i32.const 150))
+
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 1))
+(assert_return (invoke "as-loop-mid") (i32.const 1))
+(assert_return (invoke "as-loop-last") (i32.const 1))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 12))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operands") (i32.const 12))
+(assert_return (invoke "as-compare-operands") (i32.const 0))
+(assert_return (invoke "as-mixed-operands") (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value") (i32.const 18))
+(assert_return (invoke "break-multi-value")
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+(assert_return (invoke "break-repeated") (i32.const 18))
+(assert_return (invoke "break-inner") (i32.const 0xf))
+
+(assert_return (invoke "param") (i32.const 3))
+(assert_return (invoke "params") (i32.const 3))
+(assert_return (invoke "params-id") (i32.const 3))
+(assert_return (invoke "param-break") (i32.const 3))
+(assert_return (invoke "params-break") (i32.const 3))
+(assert_return (invoke "params-id-break") (i32.const 3))
+
+(assert_return (invoke "effects") (i32.const 1))
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (param i32) (type $sig) (result i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (param i32) (result i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (result i32) (type $sig) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (result i32) (param i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (block (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (i32.const 0) (block (param $x i32) (drop)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (block (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (param i32) (drop)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (block (type $sig) (param i32) (result i32)) (unreachable))"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (block (type $sig) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (block)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (block)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-i32-vs-void
+    (block (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-void
+    (block (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-void
+    (block (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-void
+    (block (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (block (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-i32 (result i32)
+    (block (result i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-i64 (result i64)
+    (block (result i64))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f32 (result f32)
+    (block (result f32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f64 (result f64)
+    (block (result f64))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-nums (result i32 i32)
+    (block (result i32 i32))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-value-empty-in-block
+      (i32.const 0)
+      (block (block (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-loop
+      (i32.const 0)
+      (loop (block (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (block (result i32)) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-i32 (result i32)
+    (block (result i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-i64 (result i64)
+    (block (result i64) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f32 (result f32)
+    (block (result f32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f64 (result f64)
+    (block (result f64) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-i64 (result i32)
+    (block (result i32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f32 (result i32)
+    (block (result i32) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f64 (result i32)
+    (block (result i32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-i32 (result i64)
+    (block (result i64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-f32 (result i64)
+    (block (result i64) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-f64 (result i64)
+    (block (result i64) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i32 (result f32)
+    (block (result f32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i64 (result f32)
+    (block (result f32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-f64 (result f32)
+    (block (result f32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i32 (result f64)
+    (block (result f64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i64 (result f64)
+    (block (result f64) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-f32 (result f32)
+    (block (result f64) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result i32)
+    (block (result i32) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-i64 (result i32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f32 (result i32)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f64 (result i32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-i32 (result i64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f32 (result i64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f64 (result i64)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i32 (result f32)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i64 (result f32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-f64 (result f32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i32 (result f64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i64 (result f64)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-f32 (result f64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-i32 (result i32)
+    (block (result i32) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-i64 (result i64)
+    (block (result i64) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f32 (result f32)
+    (block (result f32) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f64 (result f64)
+    (block (result f64) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-empty-vs-i32 (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-i64 (result i64)
+    (block (result i64) (br 0) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f32 (result f32)
+    (block (result f32) (br 0) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f64 (result f64)
+    (block (result f64) (br 0) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i32 (result f64)
+    (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-partial-vs-nums (result i32 i32)
+    (i32.const 1) (block (result i32 i32) (br 0 (i32.const 0)) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-void-vs-i32 (result i32)
+    (block (result i32) (br 0 (nop)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (nop)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-i32-vs-i64 (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i32 (result f64)
+    (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-nums (result i32 i32)
+    (block (result i32 i32) (br 0 (i32.const 0)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-void
+    (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-void
+    (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-void
+    (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-void
+    (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-nums-vs-void
+    (block (result i32 i32) (block (result i32 i32) (br 1 (i32.const 1) (i32.const 2))) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i32 (result i32)
+    (block (result i32) (block (br 1)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i64 (result i64)
+    (block (result i64) (block (br 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f32 (result f32)
+    (block (result f32) (block (br 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f64 (result f64)
+    (block (result f64) (block (br 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (br 1)) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-void-vs-i32 (result i32)
+    (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-i64 (result i64)
+    (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f32 (result f32)
+    (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f64 (result f64)
+    (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-nums (result i32 i32)
+    (block (result i32 i32) (block (result i32 i32) (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-i64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f32 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-i32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f64 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i32 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-f64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i64 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-f32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32 i32)
+      (block (result i32 i32) (br 1 (i32.const 0))) (br 0 (i32.const 1) (i32.const 2))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-i32 (result i32)
+    (i32.ctz (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-i64 (result i64)
+    (i64.ctz (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f32 (result f32)
+    (f32.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f64 (result f64)
+    (f64.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-nums (result i32)
+    (i32.add (block (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i32 (result i32)
+    (i32.ctz (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i64 (result i64)
+    (i64.ctz (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-f32 (result f32)
+    (f32.floor (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-f64 (result f64)
+    (f64.floor (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-nums (result i32)
+    (i32.add (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-i64 (result i32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f32 (result i32)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f64 (result i32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-i32 (result i64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f32 (result i64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f64 (result i64)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i32 (result f32)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i64 (result f32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-f64 (result f32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i32 (result f64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i64 (result f64)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-f32 (result f64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-num-vs-nums (result i32)
+    (i32.add (block (br 0 (i64.const 9) (i32.const 10))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (block (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (param i32 f64) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (block (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (block (param f32 i32) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (block (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (block (param i32 f64) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (block (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (block (param f32 i32) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) block (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (block (param $x i32)))")
+  "unexpected token"
+)
+
+
+(assert_malformed
+  (module quote "(func block end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func block $a end $l)")
+  "mismatching label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/br.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/br.wast
new file mode 100644
index 0000000..35f707c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/br.wast
@@ -0,0 +1,657 @@
+;; Test `br` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32") (block (drop (i32.ctz (br 0)))))
+  (func (export "type-i64") (block (drop (i64.ctz (br 0)))))
+  (func (export "type-f32") (block (drop (f32.neg (br 0)))))
+  (func (export "type-f64") (block (drop (f64.neg (br 0)))))
+  (func (export "type-i32-i32") (block (drop (i32.add (br 0)))))
+  (func (export "type-i64-i64") (block (drop (i64.add (br 0)))))
+  (func (export "type-f32-f32") (block (drop (f32.add (br 0)))))
+  (func (export "type-f64-f64") (block (drop (f64.add (br 0)))))
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br 0 (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br 0 (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br 0 (f64.const 4))))
+  )
+  (func (export "type-f64-f64-value") (result f64 f64)
+    (block (result f64 f64)
+      (f64.add (br 0 (f64.const 4) (f64.const 5))) (f64.const 6)
+    )
+  )
+
+  (func (export "as-block-first")
+    (block (br 0) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (br 0) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br 0))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (block (result i32)
+      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br 0)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br 0)))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br 0 (i64.const 7))))
+  )
+  (func (export "as-return-values") (result i32 i64)
+    (i32.const 2)
+    (block (result i64) (return (br 0 (i32.const 1) (i64.const 7))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (br 0 (i32.const 5)) (local.get 0) (local.get 1))
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select (local.get 0) (br 0 (i32.const 6)) (local.get 1))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7)))
+    )
+  )
+  (func (export "as-select-all") (result i32)
+    (block (result i32) (select (br 0 (i32.const 8))))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
+    )
+  )
+  (func (export "as-call-all") (result i32)
+    (block (result i32) (call $f (br 0 (i32.const 15))))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (br 0 (i32.const 20))
+        (i32.const 1) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (br 0 (i32.const 21)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (i32.const 1) (br 0 (i32.const 22)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0)
+        (i32.const 1) (i32.const 2) (br 0 (i32.const 23))
+      )
+    )
+  )
+  (func (export "as-call_indirect-all") (result i32)
+    (block (result i32) (call_indirect (type $sig) (br 0 (i32.const 24))))
+  )
+
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (block (result i32) (local.tee 0 (br 0 (i32.const 1))))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32) (global.set $a (br 0 (i32.const 1))))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br 0 (f32.const 1.7))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br 0 (i64.const 30))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1)
+    )
+  )
+  (func (export "as-store-both") (result i32)
+    (block (result i32)
+      (i64.store (br 0 (i32.const 32))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-both") (result i32)
+    (block (result i32)
+      (i64.store16 (br 0 (i32.const 34))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br 0 (f32.const 3.4))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45))))
+  )
+  (func (export "as-binary-both") (result i32)
+    (block (result i32) (i32.add (br 0 (i32.const 46))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42))))
+  )
+  (func (export "as-compare-both") (result i32)
+    (block (result i32) (f64.le (br 0 (i32.const 44))))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41))))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br 0 (i32.const 40))))
+  )
+
+  (func (export "nested-block-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (call $dummy)
+        (i32.add (i32.const 4) (br 0 (i32.const 8)))
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br 0 (br 1 (i32.const 8)))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1)))
+            (i32.const 32)
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8))))
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (drop
+          (block (result i32)
+            (drop (i32.const 4))
+            (br_table 0 (br 1 (i32.const 8)) (i32.const 1))
+          )
+        )
+        (i32.const 16)
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (result i32)
+    (i32.add
+      (i32.const 1)
+      (block (result i32)
+        (drop (i32.const 2))
+        (br_table 0 (i32.const 4) (br 0 (i32.const 8)))
+        (i32.const 16)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+(assert_return (invoke "type-i32-i32"))
+(assert_return (invoke "type-i64-i64"))
+(assert_return (invoke "type-f32-f32"))
+(assert_return (invoke "type-f64-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+(assert_return (invoke "type-f64-f64-value") (f64.const 4) (f64.const 5))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+(assert_return (invoke "as-return-values") (i32.const 2) (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+(assert_return (invoke "as-select-all") (i32.const 8))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+(assert_return (invoke "as-call-all") (i32.const 15))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 20))
+(assert_return (invoke "as-call_indirect-first") (i32.const 21))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 22))
+(assert_return (invoke "as-call_indirect-last") (i32.const 23))
+(assert_return (invoke "as-call_indirect-all") (i32.const 24))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-store-both") (i32.const 32))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+(assert_return (invoke "as-storeN-both") (i32.const 34))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+(assert_return (invoke "as-binary-both") (i32.const 46))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+(assert_return (invoke "as-compare-both") (i32.const 44))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_return (invoke "nested-block-value") (i32.const 9))
+(assert_return (invoke "nested-br-value") (i32.const 9))
+(assert_return (invoke "nested-br_if-value") (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond") (i32.const 9))
+(assert_return (invoke "nested-br_table-value") (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index") (i32.const 9))
+
+(assert_invalid
+  (module (func $type-arg-empty-vs-num (result i32)
+    (block (result i32) (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (result i32) (br 0 (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-num (result i32)
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br
+      (i32.const 0)
+      (block (result i32) (br 0 (br 0))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br_if
+      (i32.const 0)
+      (block (result i32) (br_if 0 (br 0) (i32.const 1))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-br_table
+      (i32.const 0)
+      (block (result i32) (br_table 0 (br 0))) (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-return
+      (block (result i32)
+        (return (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-select
+      (block (result i32)
+        (select (br 0) (i32.const 1) (i32.const 2))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-call
+      (block (result i32)
+        (call 1 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-arg-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (br 0) (i32.const 0)
+        )
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-local.set
+      (local i32)
+      (block (result i32)
+        (local.set 0 (br 0)) (local.get 0)
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-empty-in-local.tee
+      (local i32)
+      (block (result i32)
+        (local.tee 0 (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-arg-empty-in-global.set
+      (block (result i32)
+        (global.set $x (br 0)) (global.get $x)
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-arg-empty-in-memory.grow
+      (block (result i32)
+        (memory.grow (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-arg-empty-in-load
+      (block (result i32)
+        (i32.load (br 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-arg-empty-in-store
+      (block (result i32)
+        (i32.store (br 0) (i32.const 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $unbound-label (br 1)))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label (block (block (br 5)))))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label (br 0x10000001)))
+  "unknown label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call.wast
new file mode 100644
index 0000000..e4f854f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call.wast
@@ -0,0 +1,518 @@
+;; Test `call` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+  (func $const-i32-i64 (result i32 i64) (i32.const 0x132) (i64.const 0x164))
+
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+  (func $id-i32-f64 (param i32 f64) (result i32 f64)
+    (local.get 0) (local.get 1)
+  )
+
+  (func $swap-i32-i32 (param i32 i32) (result i32 i32)
+    (local.get 1) (local.get 0)
+  )
+  (func $swap-f32-f64 (param f32 f64) (result f64 f32)
+    (local.get 1) (local.get 0)
+  )
+  (func $swap-f64-i32 (param f64 i32) (result i32 f64)
+    (local.get 1) (local.get 0)
+  )
+
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32) (call $const-i32))
+  (func (export "type-i64") (result i64) (call $const-i64))
+  (func (export "type-f32") (result f32) (call $const-f32))
+  (func (export "type-f64") (result f64) (call $const-f64))
+  (func (export "type-i32-i64") (result i32 i64) (call $const-i32-i64))
+
+  (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32)))
+  (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64)))
+  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
+  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64)))
+
+  (func (export "type-second-i32") (result i32)
+    (call $f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call $i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call $f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call $i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call $id-i32-f64 (i32.const 32) (f64.const 1.64))
+  )
+  (func (export "type-all-i32-i32") (result i32 i32)
+    (call $swap-i32-i32 (i32.const 1) (i32.const 2))
+  )
+  (func (export "type-all-f32-f64") (result f64 f32)
+    (call $swap-f32-f64 (f32.const 1) (f64.const 2))
+  )
+  (func (export "type-all-f64-i32") (result i32 f64)
+    (call $swap-f64-i32 (f64.const 1) (i32.const 2))
+  )
+
+  ;; Composition
+
+  (func (export "as-binary-all-operands") (result i32)
+    (i32.add (call $swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  (func (export "as-mixed-operands") (result i32)
+    (call $swap-i32-i32 (i32.const 3) (i32.const 4))
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "as-call-all-operands") (result i32 i32)
+    (call $swap-i32-i32 (call $swap-i32-i32 (i32.const 3) (i32.const 4)))
+  )
+
+  ;; Recursion
+
+  (func $fac (export "fac") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call $fac (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (call $fac-acc
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+        )
+      )
+    )
+  )
+
+  (func $fib (export "fib") (param i64) (result i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call $fib (i64.sub (local.get 0) (i64.const 2)))
+          (call $fib (i64.sub (local.get 0) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 44))
+      (else (call $odd (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+  (func $odd (export "odd") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 99))
+      (else (call $even (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $runaway (export "runaway") (call $runaway))
+
+  (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2))
+  (func $mutual-runaway2 (call $mutual-runaway1))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call $const-i32) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call $const-i32) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call $const-i32))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (call $const-i32) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call $const-i32)))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (call $const-i32) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (call $const-i32) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (call $const-i32)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (call $const-i32) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call $const-i32) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call $const-i32))
+  )
+  (func (export "as-return-value") (result i32)
+    (call $const-i32) (return)
+  )
+  (func (export "as-drop-operand")
+    (call $const-i32) (drop)
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (call $const-i32)))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (call $const-i32)) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (call $const-i32))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (call $const-i32))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call $const-i32))
+  )
+
+  (func $dummy (param i32) (result i32) (local.get 0))
+  (func $du (param f32) (result f32) (local.get 0))
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64) (i64.extend_i32_s (call $dummy (i32.const 1))))
+  )
+
+  ;; Test correct argument passing
+
+  (func $return-from-long-argument-list-helper (param f32 i32 i32 f64 f32 f32 f32 f64 f32 i32 i32 f32 f64 i64 i64 i32 i64 i64 f32 i64 i64 i64 i32 f32 f32 f32 f64 f32 i32 i64 f32 f64 f64 f32 i32 f32 f32 f64 i64 f64 i32 i64 f32 f64 i32 i32 i32 i64 f64 i32 i64 i64 f64 f64 f64 f64 f64 f64 i32 f32 f64 f64 i32 i64 f32 f32 f32 i32 f64 f64 f64 f64 f64 f32 i64 i64 i32 i32 i32 f32 f64 i32 i64 f32 f32 f32 i32 i32 f32 f64 i64 f32 f64 f32 f32 f32 i32 f32 i64 i32) (result i32)
+    (local.get 99)
+  )
+
+  (func (export "return-from-long-argument-list") (param i32) (result i32)
+    (call $return-from-long-argument-list-helper (f32.const 0) (i32.const 0) (i32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f64.const 0) (f32.const 0) (i64.const 0) (i64.const 0) (i32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (i32.const 0) (f32.const 0) (f64.const 0) (i64.const 0) (f32.const 0) (f64.const 0) (f32.const 0) (f32.const 0) (f32.const 0) (i32.const 0) (f32.const 0) (i64.const 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+(assert_return (invoke "type-i32-i64") (i32.const 0x132) (i64.const 0x164))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "type-all-i32-f64") (i32.const 32) (f64.const 1.64))
+(assert_return (invoke "type-all-i32-i32") (i32.const 2) (i32.const 1))
+(assert_return (invoke "type-all-f32-f64") (f64.const 2) (f32.const 1))
+(assert_return (invoke "type-all-f64-i32") (i32.const 2) (f64.const 1))
+
+(assert_return (invoke "as-binary-all-operands") (i32.const 7))
+(assert_return (invoke "as-mixed-operands") (i32.const 32))
+(assert_return (invoke "as-call-all-operands") (i32.const 3) (i32.const 4))
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
+
+(assert_exhaustion (invoke "runaway") "call stack exhausted")
+(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
+
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i32.const 0x132))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 0x132))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 0x132))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 0x132))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 0x132))
+(assert_return (invoke "as-local.set-value") (i32.const 0x132))
+(assert_return (invoke "as-local.tee-value") (i32.const 0x132))
+(assert_return (invoke "as-global.set-value") (i32.const 0x132))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
+(assert_return (invoke "return-from-long-argument-list" (i32.const 42)) (i32.const 42))
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (func $type-void-vs-num (i32.eqz (call 1)))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-num-vs-num (i32.eqz (call 1)))
+    (func (result i64) (i64.const 1))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-0-vs-1 (call 1))
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-0-vs-2 (call 1))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-1-vs-0 (call 1 (i32.const 1)))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-2-vs-0 (call 1 (f64.const 2) (i32.const 1)))
+    (func)
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-first-void-vs-num (call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-void-vs-num (call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-num-vs-num (call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-num-vs-num (call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-first-empty-in-block
+      (block (call 1))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-block
+      (block (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-empty-in-loop
+      (loop (call 1))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-loop
+      (loop (call 1 (i32.const 0)))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-empty-in-then
+      (if (i32.const 0) (then (call 1)))
+    )
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-empty-in-then
+      (if (i32.const 0) (then (call 1 (i32.const 0))))
+    )
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+
+
+;; Unbound function
+
+(assert_invalid
+  (module (func $unbound-func (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $large-func (call 1012321300)))
+  "unknown function"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call_indirect.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call_indirect.wast
new file mode 100644
index 0000000..224e3be
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/call_indirect.wast
@@ -0,0 +1,971 @@
+;; Test `call_indirect` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $out-i32 (func (result i32)))
+  (type $out-i64 (func (result i64)))
+  (type $out-f32 (func (result f32)))
+  (type $out-f64 (func (result f64)))
+  (type $out-f64-i32 (func (result f64 i32)))
+  (type $over-i32 (func (param i32) (result i32)))
+  (type $over-i64 (func (param i64) (result i64)))
+  (type $over-f32 (func (param f32) (result f32)))
+  (type $over-f64 (func (param f64) (result f64)))
+  (type $over-i32-f64 (func (param i32 f64) (result i32 f64)))
+  (type $swap-i32-i64 (func (param i32 i64) (result i64 i32)))
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+  (type $over-i32-duplicate (func (param i32) (result i32)))
+  (type $over-i64-duplicate (func (param i64) (result i64)))
+  (type $over-f32-duplicate (func (param f32) (result f32)))
+  (type $over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+  (func $const-i64 (type $out-i64) (i64.const 0x164))
+  (func $const-f32 (type $out-f32) (f32.const 0xf32))
+  (func $const-f64 (type $out-f64) (f64.const 0xf64))
+  (func $const-f64-i32 (type $out-f64-i32) (f64.const 0xf64) (i32.const 32))
+
+  (func $id-i32 (type $over-i32) (local.get 0))
+  (func $id-i64 (type $over-i64) (local.get 0))
+  (func $id-f32 (type $over-f32) (local.get 0))
+  (func $id-f64 (type $over-f64) (local.get 0))
+  (func $id-i32-f64 (type $over-i32-f64) (local.get 0) (local.get 1))
+  (func $swap-i32-i64 (type $swap-i32-i64) (local.get 1) (local.get 0))
+
+  (func $i32-i64 (type $i32-i64) (local.get 1))
+  (func $i64-f64 (type $i64-f64) (local.get 1))
+  (func $f32-i32 (type $f32-i32) (local.get 1))
+  (func $f64-f32 (type $f64-f32) (local.get 1))
+
+  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
+  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
+  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
+  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $const-i32 $const-i64 $const-f32 $const-f64  ;; 0..3
+      $id-i32 $id-i64 $id-f32 $id-f64              ;; 4..7
+      $f32-i32 $i32-i64 $f64-f32 $i64-f64          ;; 9..11
+      $fac-i64 $fib-i64 $even $odd                 ;; 12..15
+      $runaway $mutual-runaway1 $mutual-runaway2   ;; 16..18
+      $over-i32-duplicate $over-i64-duplicate      ;; 19..20
+      $over-f32-duplicate $over-f64-duplicate      ;; 21..22
+      $fac-i32 $fac-f32 $fac-f64                   ;; 23..25
+      $fib-i32 $fib-f32 $fib-f64                   ;; 26..28
+      $const-f64-i32 $id-i32-f64 $swap-i32-i64     ;; 29..31
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $out-f64) (i32.const 3))
+  )
+  (func (export "type-f64-i32") (result f64 i32)
+    (call_indirect (type $out-f64-i32) (i32.const 29))
+  )
+
+  (func (export "type-index") (result i64)
+    (call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
+  )
+  (func (export "type-second-i64") (result i64)
+    (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
+  )
+  (func (export "type-second-f32") (result f32)
+    (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
+  )
+  (func (export "type-second-f64") (result f64)
+    (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
+  )
+
+  (func (export "type-all-f64-i32") (result f64 i32)
+    (call_indirect (type $out-f64-i32) (i32.const 29))
+  )
+  (func (export "type-all-i32-f64") (result i32 f64)
+    (call_indirect (type $over-i32-f64)
+      (i32.const 1) (f64.const 2) (i32.const 30)
+    )
+  )
+  (func (export "type-all-i32-i64") (result i64 i32)
+    (call_indirect (type $swap-i32-i64)
+      (i32.const 1) (i64.const 2) (i32.const 31)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (call_indirect (type $over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
+    (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0))
+  )
+
+  ;; Recursion
+
+  (func $fac-i64 (export "fac-i64") (type $over-i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get 0)
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 12)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-i64 (export "fib-i64") (type $over-i64)
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect (type $over-i64)
+            (i64.sub (local.get 0) (i64.const 1))
+            (i32.const 13)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-i32 (export "fac-i32") (type $over-i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (local.get 0)
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f32 (export "fac-f32") (type $over-f32)
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (local.get 0)
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f64 (export "fac-f64") (type $over-f64)
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (local.get 0)
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-i32 (export "fib-i32") (type $over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f32 (export "fib-f32") (type $over-f32)
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $over-f32)
+            (f32.sub (local.get 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f64 (export "fib-f64") (type $over-f64)
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $over-f64)
+            (f64.sub (local.get 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+
+  ;; Stack exhaustion
+
+  ;; Implementations are required to have every call consume some abstract
+  ;; resource towards exhausting some abstract finite limit, such that
+  ;; infinitely recursive test cases reliably trap in finite time. This is
+  ;; because otherwise applications could come to depend on it on those
+  ;; implementations and be incompatible with implementations that don't do
+  ;; it (or don't do it under the same circumstances).
+
+  (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16)))
+
+  (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18)))
+  (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $a (mut f64) (f64.const 10.0))
+  (func (export "as-global.set-value") (result f64)
+    (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $a)
+  )
+
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_i32_s
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+(assert_return (invoke "type-f64-i32") (f64.const 0xf64) (i32.const 32))
+
+(assert_return (invoke "type-index") (i64.const 100))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "type-all-f64-i32") (f64.const 0xf64) (i32.const 32))
+(assert_return (invoke "type-all-i32-f64") (i32.const 1) (f64.const 2))
+(assert_return (invoke "type-all-i32-i64") (i64.const 2) (i32.const 1))
+
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
+(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
+(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
+(assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2))
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 32) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
+
+(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 20)) (i64.const 9))
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 22)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 23)) (i32.const 362880))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 26)) (i32.const 55))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 9)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 21)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 24)) (f32.const 362880.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 27)) (f32.const 55.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 21)) (f32.const 9.0))
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 25)) (f64.const 362880.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 28)) (f64.const 55.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 22)) (f64.const 9.0))
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch")
+
+(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120))
+(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800))
+
+(assert_return (invoke "fac-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 5.0)) (f32.const 120.0))
+(assert_return (invoke "fac-f32" (f32.const 10.0)) (f32.const 3628800.0))
+
+(assert_return (invoke "fac-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 5.0)) (f64.const 120.0))
+(assert_return (invoke "fac-f64" (f64.const 10.0)) (f64.const 3628800.0))
+
+(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8))
+(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946))
+
+(assert_return (invoke "fib-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 2.0)) (f32.const 2.0))
+(assert_return (invoke "fib-f32" (f32.const 5.0)) (f32.const 8.0))
+(assert_return (invoke "fib-f32" (f32.const 20.0)) (f32.const 10946.0))
+
+(assert_return (invoke "fib-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 2.0)) (f64.const 2.0))
+(assert_return (invoke "fib-f64" (f64.const 5.0)) (f64.const 8.0))
+(assert_return (invoke "fib-f64" (f64.const 20.0)) (f64.const 10946.0))
+
+(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
+
+(assert_exhaustion (invoke "runaway") "call stack exhausted")
+(assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
+
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i64.const 0x164))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (f32.const 0xf32))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (f32.const 1))
+(assert_return (invoke "as-local.set-value") (f64.const 1))
+(assert_return (invoke "as-local.tee-value") (f64.const 1))
+(assert_return (invoke "as-global.set-value") (f64.const 1.0))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
+;; Invalid syntax
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (type $sig) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (result i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func"
+    "  (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (param i32) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (type (func))
+    (func $no-table (call_indirect (type 0) (i32.const 0)))
+  )
+  "unknown table"
+)
+
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $arity-2-vs-0
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-first-void-vs-num
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-second-void-vs-num
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $type-first-num-vs-num
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $type-second-num-vs-num
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-block
+      (block
+        (call_indirect (type $sig) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-block
+      (block
+        (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-loop
+      (loop
+        (call_indirect (type $sig) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-loop
+      (loop
+        (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32))
+    (type $sig (func (param i32)))
+    (table funcref (elem $f))
+    (func $type-first-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $sig) (i32.const 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32 i32))
+    (type $sig (func (param i32 i32)))
+    (table funcref (elem $f))
+    (func $type-second-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if
+        (then
+          (call_indirect (type $sig) (i32.const 0) (i32.const 0))
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Unbound type
+
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $unbound-type (call_indirect (type 1) (i32.const 0)))
+  )
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $large-type (call_indirect (type 1012321300) (i32.const 0)))
+  )
+  "unknown type"
+)
+
+
+;; Unbound function in table
+
+(assert_invalid
+  (module (table funcref (elem 0 0)))
+  "unknown function"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/fac.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/fac.wast
new file mode 100644
index 0000000..0e61c1f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/fac.wast
@@ -0,0 +1,109 @@
+(module
+  ;; Recursive factorial
+  (func (export "fac-rec") (param i64) (result i64)
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
+      )
+    )
+  )
+
+  ;; Recursive factorial named
+  (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
+    (if (result i64) (i64.eq (local.get $n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get $n)
+          (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  ;; Iterative factorial
+  (func (export "fac-iter") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
+    (block
+      (loop
+        (if
+          (i64.eq (local.get 1) (i64.const 0))
+          (then (br 2))
+          (else
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
+          )
+        )
+        (br 0)
+      )
+    )
+    (local.get 2)
+  )
+
+  ;; Iterative factorial named
+  (func (export "fac-iter-named") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (if
+          (i64.eq (local.get $i) (i64.const 0))
+          (then (br $done))
+          (else
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  ;; Optimized factorial.
+  (func (export "fac-opt") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+      (loop
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Iterative factorial without locals.
+  (func $pick0 (param i64) (result i64 i64)
+    (local.get 0) (local.get 0)
+  )
+  (func $pick1 (param i64 i64) (result i64 i64 i64)
+    (local.get 0) (local.get 1) (local.get 0)
+  )
+  (func (export "fac-ssa") (param i64) (result i64)
+    (i64.const 1) (local.get 0)
+    (loop $l (param i64 i64) (result i64)
+      (call $pick1) (call $pick1) (i64.mul)
+      (call $pick1) (i64.const 1) (i64.sub)
+      (call $pick0) (i64.const 0) (i64.gt_u)
+      (br_if $l)
+      (drop) (return)
+    )
+  )
+)
+
+(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-ssa" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/func.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/func.wast
new file mode 100644
index 0000000..5cc5d74
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/func.wast
@@ -0,0 +1,899 @@
+;; Test `func` declarations, i.e. functions
+
+(module
+  ;; Auxiliary definition
+  (type $sig (func))
+  (func $dummy)
+
+  ;; Syntax
+
+  (func)
+  (func (export "f"))
+  (func $f)
+  (func $h (export "g"))
+
+  (func (local))
+  (func (local) (local))
+  (func (local i32))
+  (func (local $x i32))
+  (func (local i32 f64 i64))
+  (func (local i32) (local f64))
+  (func (local i32 f32) (local $x i64) (local) (local i32 f64))
+
+  (func (param))
+  (func (param) (param))
+  (func (param i32))
+  (func (param $x i32))
+  (func (param i32 f64 i64))
+  (func (param i32) (param f64))
+  (func (param i32 f32) (param $x i64) (param) (param i32 f64))
+
+  (func (result))
+  (func (result) (result))
+  (func (result i32) (unreachable))
+  (func (result i32 f64 f32) (unreachable))
+  (func (result i32) (result f64) (unreachable))
+  (func (result i32 f32) (result i64) (result) (result i32 f64) (unreachable))
+
+  (type $sig-1 (func))
+  (type $sig-2 (func (result i32)))
+  (type $sig-3 (func (param $x i32)))
+  (type $sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $sig-1))
+  (func (export "type-use-2") (type $sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $sig-3))
+  (func (export "type-use-4") (type $sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
+  (func (type $sig))
+  (func (type $forward))  ;; forward reference
+
+  (func $complex
+    (param i32 f32) (param $x i64) (param) (param i32)
+    (result) (result i32) (result) (result i64 i32)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+  (func $complex-sig
+    (type $sig)
+    (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
+    (unreachable) (unreachable)
+  )
+
+  (type $forward (func))
+
+  ;; Typing of locals
+
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
+  (func (export "local-mixed") (result f64)
+    (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of parameters
+
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
+  (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32)
+    (result f64)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
+  )
+
+  ;; Typing of results
+
+  (func (export "empty"))
+  (func (export "value-void") (call $dummy))
+  (func (export "value-i32") (result i32) (i32.const 77))
+  (func (export "value-i64") (result i64) (i64.const 7777))
+  (func (export "value-f32") (result f32) (f32.const 77.7))
+  (func (export "value-f64") (result f64) (f64.const 77.77))
+  (func (export "value-i32-f64") (result i32 f64) (i32.const 77) (f64.const 7))
+  (func (export "value-i32-i32-i32") (result i32 i32 i32)
+    (i32.const 1) (i32.const 2) (i32.const 3)
+  )
+  (func (export "value-block-void") (block (call $dummy) (call $dummy)))
+  (func (export "value-block-i32") (result i32)
+    (block (result i32) (call $dummy) (i32.const 77))
+  )
+  (func (export "value-block-i32-i64") (result i32 i64)
+    (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2))
+  )
+
+  (func (export "return-empty") (return))
+  (func (export "return-i32") (result i32) (return (i32.const 78)))
+  (func (export "return-i64") (result i64) (return (i64.const 7878)))
+  (func (export "return-f32") (result f32) (return (f32.const 78.7)))
+  (func (export "return-f64") (result f64) (return (f64.const 78.78)))
+  (func (export "return-i32-f64") (result i32 f64)
+    (return (i32.const 78) (f64.const 78.78))
+  )
+  (func (export "return-i32-i32-i32") (result i32 i32 i32)
+    (return (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "return-block-i32") (result i32)
+    (return (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "return-block-i32-i64") (result i32 i64)
+    (return (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-empty") (br 0))
+  (func (export "break-i32") (result i32) (br 0 (i32.const 79)))
+  (func (export "break-i64") (result i64) (br 0 (i64.const 7979)))
+  (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
+  (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
+  (func (export "break-i32-f64") (result i32 f64)
+    (br 0 (i32.const 79) (f64.const 79.79))
+  )
+  (func (export "break-i32-i32-i32") (result i32 i32 i32)
+    (br 0 (i32.const 1) (i32.const 2) (i32.const 3))
+  )
+  (func (export "break-block-i32") (result i32)
+    (br 0 (block (result i32) (call $dummy) (i32.const 77)))
+  )
+  (func (export "break-block-i32-i64") (result i32 i64)
+    (br 0 (block (result i32 i64) (call $dummy) (i32.const 1) (i64.const 2)))
+  )
+
+  (func (export "break-br_if-empty") (param i32)
+    (br_if 0 (local.get 0))
+  )
+  (func (export "break-br_if-num") (param i32) (result i32)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
+  )
+  (func (export "break-br_if-num-num") (param i32) (result i32 i64)
+    (drop (drop (br_if 0 (i32.const 50) (i64.const 51) (local.get 0))))
+    (i32.const 51) (i64.const 52)
+  )
+
+  (func (export "break-br_table-empty") (param i32)
+    (br_table 0 0 0 (local.get 0))
+  )
+  (func (export "break-br_table-num") (param i32) (result i32)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
+  )
+  (func (export "break-br_table-num-num") (param i32) (result i32 i64)
+    (br_table 0 0 (i32.const 50) (i64.const 51) (local.get 0))
+    (i32.const 51) (i64.const 52)
+  )
+  (func (export "break-br_table-nested-empty") (param i32)
+    (block (br_table 0 1 0 (local.get 0)))
+  )
+  (func (export "break-br_table-nested-num") (param i32) (result i32)
+    (i32.add
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
+      )
+      (i32.const 2)
+    )
+  )
+  (func (export "break-br_table-nested-num-num") (param i32) (result i32 i32)
+    (i32.add
+      (block (result i32 i32)
+        (br_table 0 1 0 (i32.const 50) (i32.const 51) (local.get 0))
+        (i32.const 51) (i32.const -3)
+      )
+    )
+    (i32.const 52)
+  )
+
+  ;; Large signatures
+
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+
+  ;; Default initialization of locals
+
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
+)
+
+(assert_return (invoke "type-use-1"))
+(assert_return (invoke "type-use-2") (i32.const 0))
+(assert_return (invoke "type-use-3" (i32.const 1)))
+(assert_return
+  (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+(assert_return (invoke "type-use-5") (i32.const 0))
+(assert_return (invoke "type-use-6" (i32.const 1)))
+(assert_return
+  (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+
+(assert_return (invoke "local-first-i32") (i32.const 0))
+(assert_return (invoke "local-first-i64") (i64.const 0))
+(assert_return (invoke "local-first-f32") (f32.const 0))
+(assert_return (invoke "local-first-f64") (f64.const 0))
+(assert_return (invoke "local-second-i32") (i32.const 0))
+(assert_return (invoke "local-second-i64") (i64.const 0))
+(assert_return (invoke "local-second-f32") (f32.const 0))
+(assert_return (invoke "local-second-f64") (f64.const 0))
+(assert_return (invoke "local-mixed") (f64.const 0))
+
+(assert_return
+  (invoke "param-first-i32" (i32.const 2) (i32.const 3)) (i32.const 2)
+)
+(assert_return
+  (invoke "param-first-i64" (i64.const 2) (i64.const 3)) (i64.const 2)
+)
+(assert_return
+  (invoke "param-first-f32" (f32.const 2) (f32.const 3)) (f32.const 2)
+)
+(assert_return
+  (invoke "param-first-f64" (f64.const 2) (f64.const 3)) (f64.const 2)
+)
+(assert_return
+  (invoke "param-second-i32" (i32.const 2) (i32.const 3)) (i32.const 3)
+)
+(assert_return
+  (invoke "param-second-i64" (i64.const 2) (i64.const 3)) (i64.const 3)
+)
+(assert_return
+  (invoke "param-second-f32" (f32.const 2) (f32.const 3)) (f32.const 3)
+)
+(assert_return
+  (invoke "param-second-f64" (f64.const 2) (f64.const 3)) (f64.const 3)
+)
+
+(assert_return
+  (invoke "param-mixed"
+    (f32.const 1) (i32.const 2) (i64.const 3)
+    (i32.const 4) (f64.const 5.5) (i32.const 6)
+  )
+  (f64.const 5.5)
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "value-void"))
+(assert_return (invoke "value-i32") (i32.const 77))
+(assert_return (invoke "value-i64") (i64.const 7777))
+(assert_return (invoke "value-f32") (f32.const 77.7))
+(assert_return (invoke "value-f64") (f64.const 77.77))
+(assert_return (invoke "value-i32-f64") (i32.const 77) (f64.const 7))
+(assert_return (invoke "value-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "value-block-void"))
+(assert_return (invoke "value-block-i32") (i32.const 77))
+(assert_return (invoke "value-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "return-empty"))
+(assert_return (invoke "return-i32") (i32.const 78))
+(assert_return (invoke "return-i64") (i64.const 7878))
+(assert_return (invoke "return-f32") (f32.const 78.7))
+(assert_return (invoke "return-f64") (f64.const 78.78))
+(assert_return (invoke "return-i32-f64") (i32.const 78) (f64.const 78.78))
+(assert_return (invoke "return-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "return-block-i32") (i32.const 77))
+(assert_return (invoke "return-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-empty"))
+(assert_return (invoke "break-i32") (i32.const 79))
+(assert_return (invoke "break-i64") (i64.const 7979))
+(assert_return (invoke "break-f32") (f32.const 79.9))
+(assert_return (invoke "break-f64") (f64.const 79.79))
+(assert_return (invoke "break-i32-f64") (i32.const 79) (f64.const 79.79))
+(assert_return (invoke "break-i32-i32-i32")
+  (i32.const 1) (i32.const 2) (i32.const 3)
+)
+(assert_return (invoke "break-block-i32") (i32.const 77))
+(assert_return (invoke "break-block-i32-i64") (i32.const 1) (i64.const 2))
+
+(assert_return (invoke "break-br_if-empty" (i32.const 0)))
+(assert_return (invoke "break-br_if-empty" (i32.const 2)))
+(assert_return (invoke "break-br_if-num" (i32.const 0)) (i32.const 51))
+(assert_return (invoke "break-br_if-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_if-num-num" (i32.const 0))
+  (i32.const 51) (i64.const 52)
+)
+(assert_return (invoke "break-br_if-num-num" (i32.const 1))
+  (i32.const 50) (i64.const 51)
+)
+
+(assert_return (invoke "break-br_table-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-empty" (i32.const 5)))
+(assert_return (invoke "break-br_table-empty" (i32.const -1)))
+(assert_return (invoke "break-br_table-num" (i32.const 0)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 1)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const 10)) (i32.const 50))
+(assert_return (invoke "break-br_table-num" (i32.const -100)) (i32.const 50))
+(assert_return (invoke "break-br_table-num-num" (i32.const 0))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 1))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const 10))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-num-num" (i32.const -100))
+  (i32.const 50) (i64.const 51)
+)
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 0)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 1)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const 3)))
+(assert_return (invoke "break-br_table-nested-empty" (i32.const -2)))
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 0)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 1)) (i32.const 50)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const 2)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num" (i32.const -3)) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 0))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 1))
+  (i32.const 50) (i32.const 51)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const 2))
+  (i32.const 101) (i32.const 52)
+)
+(assert_return
+  (invoke "break-br_table-nested-num-num" (i32.const -3))
+  (i32.const 101) (i32.const 52)
+)
+
+(assert_return
+  (invoke "large-sig"
+    (i32.const 0) (i64.const 1) (f32.const 2) (f32.const 3)
+    (i32.const 4) (f64.const 5) (f32.const 6) (i32.const 7)
+    (i32.const 8) (i32.const 9) (f32.const 10) (f64.const 11)
+    (f64.const 12) (f64.const 13) (i32.const 14) (i32.const 15)
+    (f32.const 16)
+  )
+  (f64.const 5) (f32.const 2) (i32.const 0) (i32.const 8)
+  (i32.const 7) (i64.const 1) (f32.const 3) (i32.const 9)
+  (i32.const 4) (f32.const 6) (f64.const 13) (f64.const 11)
+  (i32.const 15) (f32.const 16) (i32.const 14) (f64.const 12)
+)
+
+(assert_return (invoke "init-local-i32") (i32.const 0))
+(assert_return (invoke "init-local-i64") (i64.const 0))
+(assert_return (invoke "init-local-f32") (f32.const 0))
+(assert_return (invoke "init-local-f64") (f64.const 0))
+
+
+;; Expansion of inline function types
+
+(module
+  (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $g (param i32))                 ;; reuses explicit type definition
+  (type $t (func (param i32)))
+
+  (func $i32->void (type 0))                ;; (param i32)
+  (func $void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $check
+    (call $i32->void (i32.const 0))
+    (drop (call $void->f64))
+  )
+)
+
+(assert_invalid
+  (module
+    (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $g (param i32))                 ;; reuses explicit type definition
+    (func $h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )
+  "unknown type"
+)
+
+
+(module
+  (type $sig (func))
+
+  (func $empty-sig-1)  ;; should be assigned type $sig
+  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $empty-sig-2)  ;; should be assigned type $sig
+  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $empty-sig-duplicate (func))
+  (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table funcref
+    (elem
+      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
+      $complex-sig-4 $complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect (type $sig) (i32.const 1))
+    (call_indirect (type $sig) (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect (type 3)
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect (type $empty-sig-duplicate) (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect (type $complex-sig-duplicate)
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)
+
+(assert_return (invoke "signature-explicit-reused"))
+(assert_return (invoke "signature-implicit-reused"))
+(assert_return (invoke "signature-explicit-duplicate"))
+(assert_return (invoke "signature-implicit-duplicate"))
+
+
+;; Malformed type use
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (type $sig) (result i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (result i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (type $sig) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (param i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (param i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (type $sig) (param i32) (result i32) (unreachable))"
+  )
+  "inline function type"
+)
+
+
+;; Invalid typing of locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of result
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64-i32 (result f64 i32)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (nop)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-void
+    (i32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (i32.const 0) (i64.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result f32 f32)
+    (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result f32)
+    (f32.const 0) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-last-empty-vs-num (result i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-empty-vs-nums (result i32 i32)
+    (return)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-num (result i32)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-void-vs-nums (result i32 i64)
+    (return (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-num (result i32)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-last-num-vs-nums (result i64 i64)
+    (return (i64.const 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-empty-vs-num (result i32)
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-empty-vs-nums (result i32 i32)
+    (return) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-partial-vs-nums (result i32 i32)
+    (i32.const 1) (return) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-num (result i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-void-vs-nums (result i32 i32)
+    (return (nop)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-num (result i32)
+    (return (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-num-vs-nums (result i32 i32)
+    (return (i64.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-num (result i32)
+    (return (i64.const 1)) (return (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-return-first-num-vs-nums (result i32 i32)
+    (return (i32.const 1)) (return (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-last-void-vs-num (result i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-nums (result i32 i32)
+    (br 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-num (result i32)
+    (br 0 (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-num (result i32)
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-nums (result i32 i32)
+    (br 0) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-num-vs-nums (result i32 i32)
+    (br 0 (i32.const 1)) (i32.const 1) (i32.const 2)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-num-vs-num (result i32)
+    (br 0 (i64.const 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-num (result i32)
+    (block (br 1)) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-nums (result i32 i32)
+    (block (br 1)) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-num (result i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-nums (result i32 i32)
+    (block (br 1 (nop))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-num (result i32)
+    (block (br 1 (i64.const 1))) (br 0 (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-num-vs-nums (result i32 i32)
+    (block (result i32) (br 1 (i32.const 1))) (br 0 (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func (nop) (local i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (result i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (result i32) (local.get 0))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (param i32) (local.get 0))")
+  "unexpected token"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/if.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/if.wast
new file mode 100644
index 0000000..1cbb617
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/if.wast
@@ -0,0 +1,1550 @@
+;; Test `if` operator
+
+(module
+  ;; Auxiliary definition
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty") (param i32)
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $l (local.get 0) (then))
+    (if $l (local.get 0) (then) (else))
+  )
+
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+
+  (func (export "multi") (param i32) (result i32 i32)
+    (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy)))
+    (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+      (else (call $dummy) (call $dummy) (i32.const 9) (call $dummy))
+    )
+    (if (result i32 i64 i32) (local.get 0)
+      (then
+        (call $dummy) (call $dummy) (i32.const 1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const 2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const 3) (call $dummy)
+      )
+      (else
+        (call $dummy) (call $dummy) (i32.const -1) (call $dummy)
+        (call $dummy) (call $dummy) (i64.const -2) (call $dummy)
+        (call $dummy) (call $dummy) (i32.const -3) (call $dummy)
+      )
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 9))
+          (else (call $dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 10))
+          (else (call $dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (local.get 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (local.get 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32)
+    (local.set 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a
+      (if (result i32) (local.get 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (local.get 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.ctz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const -13))
+      )
+    )
+  )
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 3))
+        (else (call $dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const -5))
+      )
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-compare-operand") (param i32 i32) (result i32)
+    (f32.gt
+      (if (result f32) (local.get 0)
+        (then (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -3))
+      )
+      (if (result f32) (local.get 1)
+        (then (call $dummy) (f32.const 4))
+        (else (call $dummy) (f32.const -4))
+      )
+    )
+  )
+  (func (export "as-binary-operands") (param i32) (result i32)
+    (i32.mul
+      (if (result i32 i32) (local.get 0)
+        (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const 3) (call $dummy) (i32.const -4))
+      )
+    )
+  )
+  (func (export "as-compare-operands") (param i32) (result i32)
+    (f32.gt
+      (if (result f32 f32) (local.get 0)
+        (then (call $dummy) (f32.const 3) (call $dummy) (f32.const 3))
+        (else (call $dummy) (f32.const -2) (call $dummy) (f32.const -3))
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (param i32) (result i32)
+    (if (result i32 i32) (local.get 0)
+      (then (call $dummy) (i32.const 3) (call $dummy) (i32.const 4))
+      (else (call $dummy) (i32.const -3) (call $dummy) (i32.const -4))
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (if (i32.const 1) (then (br 0) (unreachable)))
+    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
+    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
+    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
+    (i32.const 19)
+  )
+
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+  (func (export "break-multi-value") (param i32) (result i32 i32 i64)
+    (if (result i32 i32 i64) (local.get 0)
+      (then
+        (br 0 (i32.const 18) (i32.const -18) (i64.const 18))
+        (i32.const 19) (i32.const -19) (i64.const 19)
+      )
+      (else
+        (br 0 (i32.const -18) (i32.const 18) (i64.const -18))
+        (i32.const -19) (i32.const 19) (i64.const -19)
+      )
+    )
+  )
+
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+  (func (export "params") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add))
+      (else (i32.sub))
+    )
+  )
+  (func (export "params-id") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then))
+    (i32.add)
+  )
+  (func (export "param-break") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add) (br 0))
+      (else (i32.const -2) (i32.add) (br 0))
+    )
+  )
+  (func (export "params-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32) (local.get 0)
+      (then (i32.add) (br 0))
+      (else (i32.sub) (br 0))
+    )
+  )
+  (func (export "params-id-break") (param i32) (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (if (param i32 i32) (result i32 i32) (local.get 0) (then (br 0)))
+    (i32.add)
+  )
+
+  (func (export "effects") (param i32) (result i32)
+    (local i32)
+    (if
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
+      (then
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
+      )
+      (else
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (br 0)
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
+      )
+    )
+    (local.get 1)
+  )
+
+  ;; Examples
+
+  (func $add64_u_with_carry (export "add64_u_with_carry")
+    (param $i i64) (param $j i64) (param $c i32) (result i64 i32)
+    (local $k i64)
+    (local.set $k
+      (i64.add
+        (i64.add (local.get $i) (local.get $j))
+        (i64.extend_i32_u (local.get $c))
+      )
+    )
+    (return (local.get $k) (i64.lt_u (local.get $k) (local.get $i)))
+  )
+
+  (func $add64_u_saturated (export "add64_u_saturated")
+    (param i64 i64) (result i64)
+    (call $add64_u_with_carry (local.get 0) (local.get 1) (i32.const 0))
+    (if (param i64) (result i64)
+      (then (drop) (i64.const -1))
+    )
+  )
+
+  ;; Block signature syntax
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (if (type $block-sig-1) (i32.const 1) (then))
+    (if (type $block-sig-2) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (i32.const 1) (then (drop)) (else (drop)))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4) (i32.const 1) (then))
+    (drop) (drop) (drop)
+    (if (type $block-sig-2) (result i32) (i32.const 1)
+      (then (i32.const 0)) (else (i32.const 2))
+    )
+    (if (type $block-sig-3) (param i32) (i32.const 1)
+      (then (drop)) (else (drop))
+    )
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (if (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+      (i32.const 1) (then)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty" (i32.const 0)))
+(assert_return (invoke "empty" (i32.const 1)))
+(assert_return (invoke "empty" (i32.const 100)))
+(assert_return (invoke "empty" (i32.const -2)))
+
+(assert_return (invoke "singular" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "singular" (i32.const 1)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "singular" (i32.const -10)) (i32.const 7))
+
+(assert_return (invoke "multi" (i32.const 0)) (i32.const 9) (i32.const -1))
+(assert_return (invoke "multi" (i32.const 1)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const 13)) (i32.const 8) (i32.const 1))
+(assert_return (invoke "multi" (i32.const -5)) (i32.const 8) (i32.const 1))
+
+(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11))
+(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9))
+(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10))
+(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9))
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15))
+(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15))
+(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operand" (i32.const 1) (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-binary-operands" (i32.const 0)) (i32.const -12))
+(assert_return (invoke "as-binary-operands" (i32.const 1)) (i32.const 12))
+
+(assert_return (invoke "as-compare-operands" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-operands" (i32.const 1)) (i32.const 0))
+
+(assert_return (invoke "as-mixed-operands" (i32.const 0)) (i32.const -3))
+(assert_return (invoke "as-mixed-operands" (i32.const 1)) (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18))
+(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "break-multi-value" (i32.const 0))
+  (i32.const -18) (i32.const 18) (i64.const -18)
+)
+(assert_return (invoke "break-multi-value" (i32.const 1))
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+
+(assert_return (invoke "param" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "param-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "param-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-break" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "params-break" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "params-id-break" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "effects" (i32.const 1)) (i32.const -14))
+(assert_return (invoke "effects" (i32.const 0)) (i32.const -6))
+
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0) (i64.const 0) (i32.const 0))
+  (i64.const 0) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 100) (i64.const 124) (i32.const 0))
+  (i64.const 224) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 0))
+  (i64.const -1) (i32.const 0)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const -1) (i32.const 0))
+  (i64.const -2) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 0) (i32.const 1))
+  (i64.const 0) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const -1) (i64.const 1) (i32.const 1))
+  (i64.const 1) (i32.const 1)
+)
+(assert_return
+  (invoke "add64_u_with_carry" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000) (i32.const 0))
+  (i64.const 0) (i32.const 1)
+)
+
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0) (i64.const 0)) (i64.const 0)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 1230) (i64.const 23)) (i64.const 1253)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 0)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const 1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const -1) (i64.const -1)) (i64.const -1)
+)
+(assert_return
+  (invoke "add64_u_saturated" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const -1)
+)
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (type $sig) (result i32) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (type $sig) (result i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (param i32) (result i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (type $sig) (param i32) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0)"
+    "  (if (result i32) (param i32) (type $sig) (i32.const 1) (then))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (if (result i32) (param i32) (i32.const 1) (then)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (param $x i32) (then (drop)) (else (drop)))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 1)"
+    "  (if (type $sig) (result i32) (then (i32.const 0)) (else (i32.const 2)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (then (drop)) (else (drop)))"
+    "  (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (i32.const 1)"
+    "  (if (type $sig) (param i32) (result i32) (then)) (unreachable)"
+    ")"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (i32.const 1) (if (type $sig) (i32.const 0) (then)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (if (i32.const 0) (then) (else))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-num-vs-void-else
+    (if (i32.const 1) (then (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-void
+    (if (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-value-nums-vs-void-else
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-void
+    (if (i32.const 1) (then) (else (i32.const 1) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-void
+    (if (i32.const 1) (then (i32.const 1) (i32.const 2)) (else (i32.const 2) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else (i32.const 0) (i32.const 2)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 1)) (else))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then) (else))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-no-else-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-no-else-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (i32.const 0) (i32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 0) (i32.const 0)) (else (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (nop)) (else (nop)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-partial-vs-nums (result i32 i32)
+    (i32.const 0)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-value-nums-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-both-different-value-num-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-both-different-value-nums-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1) (i32.const 1)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 0)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (i64.const 0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (i64.const 0))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-value-unreached-select (result i32)
+    (if (result i64)
+      (i32.const 1)
+      (then (select (unreachable) (unreachable) (unreachable)))
+      (else (select (unreachable) (unreachable) (unreachable)))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-num (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (br 0)) (else (i32.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-last-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1) (then (i32.const 1) (i32.const 1)) (else (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-empty-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-void-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-then-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-num (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+      (else (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-num-vs-nums (result i32 i32)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1) (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-then-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-else-break-partial-vs-nums (result i32 i32)
+    (i32.const 1)
+    (if (result i32 i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-condition-empty
+      (if (then))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-block
+      (i32.const 0)
+      (block (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-loop
+      (i32.const 0)
+      (loop (if (then)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (if (then))))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br
+      (i32.const 0)
+      (block (br 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (if(then)) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (if(then))) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-return
+      (return (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-select
+      (select (if(then)) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-call
+      (call 1 (if(then))) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-condition-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (if(then)) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.set
+      (local i32)
+      (local.set 0 (if(then))) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-condition-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-condition-empty-in-global.set
+      (global.set $x (if(then))) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-memory.grow
+      (memory.grow (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-condition-empty-in-load
+      (i32.load (if(then))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-condition-empty-in-store
+      (i32.store (if(then)) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (if (param i32 f64) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (if (param i32) (i32.const 1) (then (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (if (param i32 f64) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (if (param i32) (i32.const 1) (then (drop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (if (param f32 i32) (i32.const 1) (then (drop) (drop))))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) if (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (if (param $x i32) (then)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func i32.const 0 if end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if else $l1 end $l2)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func i32.const 0 if $a else $l end $l)")
+  "mismatching label"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/loop.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/loop.wast
new file mode 100644
index 0000000..4557869
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/loop.wast
@@ -0,0 +1,785 @@
+;; Test `loop` opcode
+
+(module
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "empty")
+    (loop)
+    (loop $l)
+  )
+
+  (func (export "singular") (result i32)
+    (loop (nop))
+    (loop (result i32) (i32.const 7))
+  )
+
+  (func (export "multi") (result i32)
+    (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
+    (loop (result i32) (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+    (drop)
+    (loop (result i32 i64 i32)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 8) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i64.const 7) (call $dummy)
+      (call $dummy) (call $dummy) (call $dummy) (i32.const 9) (call $dummy)
+    )
+    (drop) (drop)
+  )
+
+  (func (export "nested") (result i32)
+    (loop (result i32)
+      (loop (call $dummy) (block) (nop))
+      (loop (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+
+  (func (export "deep") (result i32)
+    (loop (result i32) (block (result i32)
+      (loop (result i32) (block (result i32)
+        (loop (result i32) (block (result i32)
+          (loop (result i32) (block (result i32)
+            (loop (result i32) (block (result i32)
+              (loop (result i32) (block (result i32)
+                (loop (result i32) (block (result i32)
+                  (loop (result i32) (block (result i32)
+                    (loop (result i32) (block (result i32)
+                      (loop (result i32) (block (result i32)
+                        (loop (result i32) (block (result i32)
+                          (loop (result i32) (block (result i32)
+                            (loop (result i32) (block (result i32)
+                              (loop (result i32) (block (result i32)
+                                (loop (result i32) (block (result i32)
+                                  (loop (result i32) (block (result i32)
+                                    (loop (result i32) (block (result i32)
+                                      (loop (result i32) (block (result i32)
+                                        (loop (result i32) (block (result i32)
+                                          (loop (result i32) (block (result i32)
+                                            (call $dummy) (i32.const 150)
+                                          ))
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+
+  (func (export "as-select-first") (result i32)
+    (select (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (loop (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (loop (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (loop (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (loop (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (loop (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
+  )
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (loop (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (loop (result i32) (i32.const 1)))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (loop (result i32) (call $dummy) (i32.const 3))
+      (loop (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+  (func (export "as-compare-operand") (result i32)
+    (f32.gt
+      (loop (result f32) (call $dummy) (f32.const 3))
+      (loop (result f32) (call $dummy) (f32.const 3))
+    )
+  )
+  (func (export "as-binary-operands") (result i32)
+    (i32.mul
+      (loop (result i32 i32)
+        (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+      )
+    )
+  )
+  (func (export "as-compare-operands") (result i32)
+    (f32.gt
+      (loop (result f32 f32)
+        (call $dummy) (f32.const 3) (call $dummy) (f32.const 3)
+      )
+    )
+  )
+  (func (export "as-mixed-operands") (result i32)
+    (loop (result i32 i32)
+      (call $dummy) (i32.const 3) (call $dummy) (i32.const 4)
+    )
+    (i32.const 5)
+    (i32.add)
+    (i32.mul)
+  )
+
+  (func (export "break-bare") (result i32)
+    (block (loop (br 1) (br 0) (unreachable)))
+    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
+    (block (loop (br_table 1 (i32.const 0)) (unreachable)))
+    (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable)))
+    (i32.const 19)
+  )
+  (func (export "break-value") (result i32)
+    (block (result i32)
+      (i32.const 0)
+      (loop (param i32)
+        (block (br 2 (i32.const 18)))
+        (br 0 (i32.const 20))
+      )
+      (i32.const 19)
+    )
+  )
+  (func (export "break-multi-value") (result i32 i32 i64)
+    (block (result i32 i32 i64)
+      (i32.const 0) (i32.const 0) (i64.const 0)
+      (loop (param i32 i32 i64)
+        (block (br 2 (i32.const 18) (i32.const -18) (i64.const 18)))
+        (br 0 (i32.const 20) (i32.const -20) (i64.const 20))
+      )
+      (i32.const 19) (i32.const -19) (i64.const 19)
+    )
+  )
+  (func (export "break-repeated") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (br 1 (i32.const 18))
+        (br 1 (i32.const 19))
+        (drop (br_if 1 (i32.const 20) (i32.const 0)))
+        (drop (br_if 1 (i32.const 20) (i32.const 1)))
+        (br 1 (i32.const 21))
+        (br_table 1 (i32.const 22) (i32.const 0))
+        (br_table 1 1 1 (i32.const 23) (i32.const 1))
+        (i32.const 21)
+      )
+    )
+  )
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
+    (local.get 0)
+  )
+  (func (export "cont-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
+    (local.get 0)
+  )
+
+  (func (export "param") (result i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 2)
+      (i32.add)
+    )
+  )
+  (func (export "params") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+    )
+  )
+  (func (export "params-id") (result i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32))
+    (i32.add)
+  )
+  (func (export "param-break") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (loop (param i32) (result i32)
+      (i32.const 4)
+      (i32.add)
+      (local.tee $x)
+      (local.get $x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+    )
+  )
+  (func (export "params-break") (result i32)
+    (local $x i32)
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32)
+      (i32.add)
+      (local.tee $x)
+      (i32.const 3)
+      (local.get $x)
+      (i32.const 10)
+      (i32.lt_u)
+      (br_if 0)
+      (drop)
+    )
+  )
+  (func (export "params-id-break") (result i32)
+    (local $x i32)
+    (local.set $x (i32.const 0))
+    (i32.const 1)
+    (i32.const 2)
+    (loop (param i32 i32) (result i32 i32)
+      (local.set $x (i32.add (local.get $x) (i32.const 1)))
+      (br_if 0 (i32.lt_u (local.get $x) (i32.const 10)))
+    )
+    (i32.add)
+  )
+
+  (func $fx (export "effects") (result i32)
+    (local i32)
+    (block
+      (loop
+        (local.set 0 (i32.const 1))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+        (br 1)
+        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+      )
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+
+  (func (export "while") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (loop
+        (br_if 1 (i64.eqz (local.get 0)))
+        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
+        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "for") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (i64.const 1))
+    (local.set 2 (i64.const 2))
+    (block
+      (loop
+        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
+        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+
+  (func (export "nesting") (param f32 f32) (result f32)
+    (local f32 f32)
+    (block
+      (loop
+        (br_if 1 (f32.eq (local.get 0) (f32.const 0)))
+        (local.set 2 (local.get 1))
+        (block
+          (loop
+            (br_if 1 (f32.eq (local.get 2) (f32.const 0)))
+            (br_if 3 (f32.lt (local.get 2) (f32.const 0)))
+            (local.set 3 (f32.add (local.get 3) (local.get 2)))
+            (local.set 2 (f32.sub (local.get 2) (f32.const 2)))
+            (br 0)
+          )
+        )
+        (local.set 3 (f32.div (local.get 3) (local.get 0)))
+        (local.set 0 (f32.sub (local.get 0) (f32.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 3)
+  )
+
+  (type $block-sig-1 (func))
+  (type $block-sig-2 (func (result i32)))
+  (type $block-sig-3 (func (param $x i32)))
+  (type $block-sig-4 (func (param i32 f64 i32) (result i32 f64 i32)))
+
+  (func (export "type-use")
+    (loop (type $block-sig-1))
+    (loop (type $block-sig-2) (i32.const 0))
+    (loop (type $block-sig-3) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $block-sig-4))
+    (drop) (drop) (drop)
+    (loop (type $block-sig-2) (result i32) (i32.const 0))
+    (loop (type $block-sig-3) (param i32) (drop))
+    (i32.const 0) (f64.const 0) (i32.const 0)
+    (loop (type $block-sig-4)
+      (param i32) (param f64 i32) (result i32 f64) (result i32)
+    )
+    (drop) (drop) (drop)
+  )
+)
+
+(assert_return (invoke "empty"))
+(assert_return (invoke "singular") (i32.const 7))
+(assert_return (invoke "multi") (i32.const 8))
+(assert_return (invoke "nested") (i32.const 9))
+(assert_return (invoke "deep") (i32.const 150))
+
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 12))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operands") (i32.const 12))
+(assert_return (invoke "as-compare-operands") (i32.const 0))
+(assert_return (invoke "as-mixed-operands") (i32.const 27))
+
+(assert_return (invoke "break-bare") (i32.const 19))
+(assert_return (invoke "break-value") (i32.const 18))
+(assert_return (invoke "break-multi-value")
+  (i32.const 18) (i32.const -18) (i64.const 18)
+)
+(assert_return (invoke "break-repeated") (i32.const 18))
+(assert_return (invoke "break-inner") (i32.const 0x1f))
+
+(assert_return (invoke "param") (i32.const 3))
+(assert_return (invoke "params") (i32.const 3))
+(assert_return (invoke "params-id") (i32.const 3))
+(assert_return (invoke "param-break") (i32.const 13))
+(assert_return (invoke "params-break") (i32.const 12))
+(assert_return (invoke "params-id-break") (i32.const 3))
+
+(assert_return (invoke "effects") (i32.const 1))
+
+(assert_return (invoke "while" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "while" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "while" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "while" (i64.const 3)) (i64.const 6))
+(assert_return (invoke "while" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "while" (i64.const 20)) (i64.const 2432902008176640000))
+
+(assert_return (invoke "for" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "for" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "for" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "for" (i64.const 3)) (i64.const 6))
+(assert_return (invoke "for" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "for" (i64.const 20)) (i64.const 2432902008176640000))
+
+(assert_return (invoke "nesting" (f32.const 0) (f32.const 7)) (f32.const 0))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 0)) (f32.const 0))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 2)) (f32.const 2))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 3)) (f32.const 4))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 4)) (f32.const 6))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 100)) (f32.const 2550))
+(assert_return (invoke "nesting" (f32.const 1) (f32.const 101)) (f32.const 2601))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 3) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 10) (f32.const 1)) (f32.const 1))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 2)) (f32.const 3))
+(assert_return (invoke "nesting" (f32.const 2) (f32.const 3)) (f32.const 4))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 4)) (f32.const 10.3095235825))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 100)) (f32.const 4381.54785156))
+(assert_return (invoke "nesting" (f32.const 7) (f32.const 101)) (f32.const 2601))
+
+(assert_return (invoke "type-use"))
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (param i32) (type $sig) (result i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (param i32) (result i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (result i32) (type $sig) (param i32)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (result i32) (param i32) (type $sig)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (i32.const 0) (loop (result i32) (param i32)))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (i32.const 0) (loop (param $x i32) (drop)))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (loop (type $sig) (result i32) (i32.const 0)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (param i32) (drop)) (unreachable))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (i32.const 0) (loop (type $sig) (param i32) (result i32)) (unreachable))"
+  )
+  "inline function type"
+)
+
+(assert_invalid
+  (module
+    (type $sig (func))
+    (func (loop (type $sig) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-empty-i32 (result i32) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-i64 (result i64) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f32 (result f32) (loop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-empty-f64 (result f64) (loop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-num-vs-void
+    (loop (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-void
+    (loop (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-num (result i32)
+    (loop (result i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-nums (result i32 i32)
+    (loop (result i32 i32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-num (result i32)
+    (loop (result i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-nums (result i32 i32)
+    (loop (result i32 i32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result i32)
+    (loop (result i32) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-nums (result i32 i32)
+    (loop (result i32 i32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-partial-vs-nums (result i32 i32)
+    (i32.const 1) (loop (result i32 i32) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-nums-vs-num (result i32)
+    (loop (result i32) (i32.const 1) (i32.const 2))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select (result i32)
+    (loop (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-value-empty-in-block
+      (i32.const 0)
+      (block (loop (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-loop
+      (i32.const 0)
+      (loop (loop (result i32)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (loop (result i32)) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-param-void-vs-num
+    (loop (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (loop (param i32 f64) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (f32.const 0) (loop (param i32) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (f32.const 0) (loop (param f32 i32) (drop) (drop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-nested-void-vs-num
+    (block (loop (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-void-vs-nums
+    (block (loop (param i32 f64) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num
+    (block (f32.const 0) (loop (param i32) (drop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-nums
+    (block (f32.const 0) (loop (param f32 i32) (drop) (drop)))
+  ))
+  "type mismatch"
+)
+
+(assert_malformed
+  (module quote "(func (param i32) (result i32) loop (param $x i32) end)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (param i32) (result i32) (loop (param $x i32)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func loop end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func loop $a end $l)")
+  "mismatching label"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/type.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/type.wast
new file mode 100644
index 0000000..b94063e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/multi-value/type.wast
@@ -0,0 +1,50 @@
+;; Test type definitions
+
+(module
+  (type (func))
+  (type $t (func))
+
+  (type (func (param i32)))
+  (type (func (param $x i32)))
+  (type (func (result i32)))
+  (type (func (param i32) (result i32)))
+  (type (func (param $x i32) (result i32)))
+
+  (type (func (param f32 f64)))
+  (type (func (result i64 f32)))
+  (type (func (param i32 i64) (result f32 f64)))
+
+  (type (func (param f32) (param f64)))
+  (type (func (param $x f32) (param f64)))
+  (type (func (param f32) (param $y f64)))
+  (type (func (param $x f32) (param $y f64)))
+  (type (func (result i64) (result f32)))
+  (type (func (param i32) (param i64) (result f32) (result f64)))
+  (type (func (param $x i32) (param $y i64) (result f32) (result f64)))
+
+  (type (func (param f32 f64) (param $x i32) (param f64 i32 i32)))
+  (type (func (result i64 i64 f32) (result f32 i32)))
+  (type
+    (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
+  )
+
+  (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param)))
+  (type
+    (func (result) (result) (result i64 i64) (result) (result f32) (result))
+  )
+  (type
+    (func
+      (param i32 i32) (param i64 i32) (param) (param $x i32) (param)
+      (result) (result f32 f64) (result f64 i32) (result)
+    )
+  )
+)
+
+(assert_malformed
+  (module quote "(type (func (result i32) (param i32)))")
+  "result before parameter"
+)
+(assert_malformed
+  (module quote "(type (func (result $x i32)))")
+  "unexpected token"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/globals.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/globals.wast
new file mode 100644
index 0000000..175af36
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/globals.wast
@@ -0,0 +1,164 @@
+;; Test globals
+
+(module
+  (global $a i32 (i32.const -2))
+  (global (;1;) f32 (f32.const -3))
+  (global (;2;) f64 (f64.const -4))
+  (global $b i64 (i64.const -5))
+
+  (global $x (mut i32) (i32.const -12))
+  (global (;5;) (mut f32) (f32.const -13))
+  (global (;6;) (mut f64) (f64.const -14))
+  (global $y (mut i64) (i64.const -15))
+
+  (func (export "get-a") (result i32) (get_global $a))
+  (func (export "get-b") (result i64) (get_global $b))
+  (func (export "get-x") (result i32) (get_global $x))
+  (func (export "get-y") (result i64) (get_global $y))
+  (func (export "set-x") (param i32) (set_global $x (get_local 0)))
+  (func (export "set-y") (param i64) (set_global $y (get_local 0)))
+
+  (func (export "get-1") (result f32) (get_global 1))
+  (func (export "get-2") (result f64) (get_global 2))
+  (func (export "get-5") (result f32) (get_global 5))
+  (func (export "get-6") (result f64) (get_global 6))
+  (func (export "set-5") (param f32) (set_global 5 (get_local 0)))
+  (func (export "set-6") (param f64) (set_global 6 (get_local 0)))
+)
+
+(assert_return (invoke "get-a") (i32.const -2))
+(assert_return (invoke "get-b") (i64.const -5))
+(assert_return (invoke "get-x") (i32.const -12))
+(assert_return (invoke "get-y") (i64.const -15))
+
+(assert_return (invoke "get-1") (f32.const -3))
+(assert_return (invoke "get-2") (f64.const -4))
+(assert_return (invoke "get-5") (f32.const -13))
+(assert_return (invoke "get-6") (f64.const -14))
+
+(assert_return (invoke "set-x" (i32.const 6)))
+(assert_return (invoke "set-y" (i64.const 7)))
+(assert_return (invoke "set-5" (f32.const 8)))
+(assert_return (invoke "set-6" (f64.const 9)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-5") (f32.const 8))
+(assert_return (invoke "get-6") (f64.const 9))
+
+(assert_invalid
+  (module (global f32 (f32.const 0)) (func (set_global 0 (i32.const 1))))
+  "global is immutable"
+)
+
+;; mutable globals can be exported
+(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
+(module (global (export "a") (mut f32) (f32.const 0)))
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (get_local 0)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 1))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (f32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (i32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (;empty instruction sequence;)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (get_global 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global i32 (get_global 1)) (global i32 (i32.const 0)))
+  "unknown global"
+)
+
+(module
+  (import "spectest" "global_i32" (global i32))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\94\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\02"                          ;; invalid mutability
+  )
+  "invalid mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\94\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\ff"                          ;; invalid mutability
+  )
+  "invalid mutability"
+)
+
+(module
+  (global i32 (i32.const 0))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\02"               ;; invalid mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "invalid mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\ff"               ;; invalid mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "invalid mutability"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/linking.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/linking.wast
new file mode 100644
index 0000000..e2fc8b8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/mutable-global/linking.wast
@@ -0,0 +1,354 @@
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (get_global $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (get_global $mut_glob))
+  (func (export "set_mut") (param i32) (set_global $mut_glob (get_local 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (get_global $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 anyfunc)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (get_local 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table anyfunc (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (get_local 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (get_local 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 anyfunc)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (get_local 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
+
+(module
+  (table (import "Mt" "tab") 0 anyfunc)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (get_global 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 0 anyfunc)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 anyfunc)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 anyfunc)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 12) $f)  ;; out of bounds
+  )
+  "elements segment does not fit"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 anyfunc)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (memory 1)
+    (data (i32.const 0x10000) "d") ;; out of bounds
+  )
+  "data segment does not fit"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (get_local 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (get_local 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (get_local 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_unlinkable
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "data segment does not fit"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (get_local 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 anyfunc)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+(assert_unlinkable
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 0x50000) "d") ;; out of bounds
+  )
+  "data segment does not fit"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+(assert_unlinkable
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 anyfunc)
+    (func)
+    (elem (i32.const 0) 0) ;; out of bounds
+  )
+  "elements segment does not fit"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast
new file mode 100644
index 0000000..99355a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/nontrapping-float-to-int-conversions/conversions.wast
@@ -0,0 +1,698 @@
+(module
+  (func (export "i64.extend_i32_s") (param $x i32) (result i64) (i64.extend_i32_s (local.get $x)))
+  (func (export "i64.extend_i32_u") (param $x i32) (result i64) (i64.extend_i32_u (local.get $x)))
+  (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap_i64 (local.get $x)))
+  (func (export "i32.trunc_f32_s") (param $x f32) (result i32) (i32.trunc_f32_s (local.get $x)))
+  (func (export "i32.trunc_f32_u") (param $x f32) (result i32) (i32.trunc_f32_u (local.get $x)))
+  (func (export "i32.trunc_f64_s") (param $x f64) (result i32) (i32.trunc_f64_s (local.get $x)))
+  (func (export "i32.trunc_f64_u") (param $x f64) (result i32) (i32.trunc_f64_u (local.get $x)))
+  (func (export "i64.trunc_f32_s") (param $x f32) (result i64) (i64.trunc_f32_s (local.get $x)))
+  (func (export "i64.trunc_f32_u") (param $x f32) (result i64) (i64.trunc_f32_u (local.get $x)))
+  (func (export "i64.trunc_f64_s") (param $x f64) (result i64) (i64.trunc_f64_s (local.get $x)))
+  (func (export "i64.trunc_f64_u") (param $x f64) (result i64) (i64.trunc_f64_u (local.get $x)))
+  (func (export "i32.trunc_sat_f32_s") (param $x f32) (result i32) (i32.trunc_sat_f32_s (local.get $x)))
+  (func (export "i32.trunc_sat_f32_u") (param $x f32) (result i32) (i32.trunc_sat_f32_u (local.get $x)))
+  (func (export "i32.trunc_sat_f64_s") (param $x f64) (result i32) (i32.trunc_sat_f64_s (local.get $x)))
+  (func (export "i32.trunc_sat_f64_u") (param $x f64) (result i32) (i32.trunc_sat_f64_u (local.get $x)))
+  (func (export "i64.trunc_sat_f32_s") (param $x f32) (result i64) (i64.trunc_sat_f32_s (local.get $x)))
+  (func (export "i64.trunc_sat_f32_u") (param $x f32) (result i64) (i64.trunc_sat_f32_u (local.get $x)))
+  (func (export "i64.trunc_sat_f64_s") (param $x f64) (result i64) (i64.trunc_sat_f64_s (local.get $x)))
+  (func (export "i64.trunc_sat_f64_u") (param $x f64) (result i64) (i64.trunc_sat_f64_u (local.get $x)))
+  (func (export "f32.convert_i32_s") (param $x i32) (result f32) (f32.convert_i32_s (local.get $x)))
+  (func (export "f32.convert_i64_s") (param $x i64) (result f32) (f32.convert_i64_s (local.get $x)))
+  (func (export "f64.convert_i32_s") (param $x i32) (result f64) (f64.convert_i32_s (local.get $x)))
+  (func (export "f64.convert_i64_s") (param $x i64) (result f64) (f64.convert_i64_s (local.get $x)))
+  (func (export "f32.convert_i32_u") (param $x i32) (result f32) (f32.convert_i32_u (local.get $x)))
+  (func (export "f32.convert_i64_u") (param $x i64) (result f32) (f32.convert_i64_u (local.get $x)))
+  (func (export "f64.convert_i32_u") (param $x i32) (result f64) (f64.convert_i32_u (local.get $x)))
+  (func (export "f64.convert_i64_u") (param $x i64) (result f64) (f64.convert_i64_u (local.get $x)))
+  (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote_f32 (local.get $x)))
+  (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote_f64 (local.get $x)))
+  (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret_i32 (local.get $x)))
+  (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret_i64 (local.get $x)))
+  (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret_f32 (local.get $x)))
+  (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret_f64 (local.get $x)))
+)
+
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -10000)) (i64.const -10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -1)) (i64.const -1))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
+
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -1)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
+
+(assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1))
+(assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x80000000)) (i32.const 0x80000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff7fffffff)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000000)) (i32.const 0x00000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xfffffffeffffffff)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0xffffffff00000001)) (i32.const 0x00000001))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0)) (i32.const 0))
+(assert_return (invoke "i32.wrap_i64" (i64.const 1311768467463790320)) (i32.const 0x9abcdef0))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x00000000ffffffff)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000))
+(assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001))
+
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648))
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -2147483904.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 4294967040.0)) (i32.const -256))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0))
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648))
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -2147483649.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1e8)) (i32.const 100000000))
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e16)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e30)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 9223372036854775808)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -9223373136366403584.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 4294967296)) (i64.const 4294967296))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0))
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -9223372036854777856.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967296)) (i64.const 0x100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e8)) (i64.const 100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e16)) (i64.const 10000000000000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -2147483648)) (f32.const -2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
+
+;; Saturating conversions: test all the same values as the non-saturating conversions.
+
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const 2147483648.0)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -2147483904.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const inf)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -inf)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967040.0)) (i32.const -256))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const 4294967296.0)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -1.0)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const inf)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -inf)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const 2147483648.0)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -2147483649.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const inf)) (i32.const 0x7fffffff))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -inf)) (i32.const 0x80000000))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i32.const 0))
+
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967295.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e8)) (i32.const 100000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 4294967296.0)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -1.0)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e16)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 1e30)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const inf)) (i32.const 0xffffffff))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -inf)) (i32.const 0x00000000))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "i32.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i32.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -9223373136366403584.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const inf)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -inf)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const nan:0x200000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_s" (f32.const -nan:0x200000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 4294967296)) (i64.const 4294967296))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -1.0)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const inf)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -inf)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const nan:0x200000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f32_u" (f32.const -nan:0x200000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const 9223372036854775808.0)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -9223372036854777856.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const inf)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -inf)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const nan:0x4000000000000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_s" (f64.const -nan:0x4000000000000)) (i64.const 0))
+
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 4294967296)) (i64.const 0x100000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e8)) (i64.const 100000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 1e16)) (i64.const 10000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const 18446744073709551616.0)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -1.0)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const inf)) (i64.const 0xffffffffffffffff))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -inf)) (i64.const 0x0000000000000000))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const nan:0x4000000000000)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan)) (i64.const 0))
+(assert_return (invoke "i64.trunc_sat_f64_u" (f64.const -nan:0x4000000000000)) (i64.const 0))
+
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777219)) (f32.const -16777220.0))
+
+(assert_return (invoke "f32.convert_i64_s" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777219)) (f32.const -16777220.0))
+
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x7fffff4000000001)) (f32.const 0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x8000004000000001)) (f32.const -0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0xffdfffffdfffffff)) (f32.const -0x1.000002p+53))
+
+(assert_return (invoke "f64.convert_i32_s" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -2147483648)) (f64.const -2147483648))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 987654321)) (f64.const 987654321))
+
+(assert_return (invoke "f64.convert_i64_s" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740993)) (f64.const -9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740995)) (f64.const -9007199254740996))
+
+(assert_return (invoke "f32.convert_i32_u" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const -2147483648)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xffffffff)) (f32.const 4294967296.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000080)) (f32.const 0x1.000000p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000081)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000082)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777219)) (f32.const 16777220.0))
+
+(assert_return (invoke "f32.convert_i64_u" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_u" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
+;; Test rounding directions.
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777219)) (f32.const 16777220.0))
+
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x0020000020000001)) (f32.const 0x1.000002p+53))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x7fffffbfffffffff)) (f32.const 0x1.fffffep+62))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0x8000008000000001)) (f32.const 0x1.000002p+63))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0xfffffe8000000001)) (f32.const 0x1.fffffep+63))
+
+(assert_return (invoke "f64.convert_i32_u" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_u" (i32.const -2147483648)) (f64.const 2147483648))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0xffffffff)) (f64.const 4294967295.0))
+
+(assert_return (invoke "f64.convert_i64_u" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_u" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63))
+;; Test rounding directions.
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+
+(assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-149)) (f64.const 0x1p-149))
+(assert_return (invoke "f64.promote_f32" (f32.const -0x1p-149)) (f64.const -0x1p-149))
+(assert_return (invoke "f64.promote_f32" (f32.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -1.0)) (f64.const -1.0))
+(assert_return (invoke "f64.promote_f32" (f32.const -0x1.fffffep+127)) (f64.const -0x1.fffffep+127))
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1.fffffep+127)) (f64.const 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
+(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf))
+(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.promote_f32" (f32.const nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const nan:0x200000)) (f64.const nan:arithmetic))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan)) (f64.const nan:canonical))
+(assert_return (invoke "f64.promote_f32" (f32.const -nan:0x200000)) (f64.const nan:arithmetic))
+
+(assert_return (invoke "f32.demote_f64" (f64.const 0.0)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0.0)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x0.0000000000001p-1022)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x0.0000000000001p-1022)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -1.0)) (f32.const -1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffe0000000p-127)) (f32.const 0x1p-126))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffe0000000p-127)) (f32.const -0x1p-126))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffdfffffffp-127)) (f32.const 0x1.fffffcp-127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffdfffffffp-127)) (f32.const -0x1.fffffcp-127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000000p+127)) (f32.const 0x1.fffffcp+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000000p+127)) (f32.const -0x1.fffffcp+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffd0000001p+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffd0000001p+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125))
+(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+0)) (f32.const 0x1.000002p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000050000000p+0)) (f32.const 0x1.000004p+0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+24)) (f32.const 0x1.0p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000001p+24)) (f32.const 0x1.000002p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.000002fffffffp+24)) (f32.const 0x1.000002p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000030000000p+24)) (f32.const 0x1.000004p+24))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.4eae4f7024c7p+108)) (f32.const 0x1.4eae5p+108))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.a12e71e358685p-113)) (f32.const 0x1.a12e72p-113))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.cb98354d521ffp-127)) (f32.const 0x1.cb9834p-127))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.6972b30cfb562p+1)) (f32.const -0x1.6972b4p+1))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.bedbe4819d4c4p+112)) (f32.const -0x1.bedbe4p+112))
+(assert_return (invoke "f32.demote_f64" (f64.const nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const nan:0x4000000000000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan)) (f32.const nan:canonical))
+(assert_return (invoke "f32.demote_f64" (f64.const -nan:0x4000000000000)) (f32.const nan:arithmetic))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1p-1022)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1p-1022)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0p-150)) (f32.const 0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0p-150)) (f32.const -0.0))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p-150)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.0000000000001p-150)) (f32.const -0x1p-149))
+
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x80000000)) (f32.const -0.0))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 1)) (f32.const 0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffa00000)) (f32.const -nan:0x200000))
+
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 1)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const -1)) (f64.const -nan:0xfffffffffffff))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff4000000000000)) (f64.const -nan:0x4000000000000))
+
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0.0)) (i32.const 0x80000000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x7fffff)) (i32.const -1))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1p-149)) (i32.const 0x80000001))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 1.0)) (i32.const 1065353216))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -nan:0x200000)) (i32.const 0xffa00000))
+
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0.0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 1))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0xfffffffffffff)) (i64.const -1))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0x8000000000000001))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 1.0)) (i64.const 4607182418800017408))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -nan:0x4000000000000)) (i64.const 0xfff4000000000000))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (i32.wrap_i64 (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f64_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.trunc_f64_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.reinterpret_f32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.extend_i32_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.extend_i32_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f32_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f32_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.trunc_f64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.reinterpret_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.demote_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32.reinterpret_i32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.promote_f32 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64.reinterpret_i64 (i32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/binary.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/binary.wast
new file mode 100644
index 0000000..002a9f2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/binary.wast
@@ -0,0 +1,1525 @@
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
+
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+
+;; Malformed binary version.
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\06\01"                          ;; Data section with 1 entry
+  "\00"                                ;; Memory index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\06\01"                          ;; Element section with 1 entry
+  "\00"                                ;; Table index 0
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
+
+;; Data segment memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, funcref
+  "\09\09\01"                          ;; Element section with 1 entry
+  "\02\80\00"                          ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00\00"                    ;; (i32.const 0) with no elements
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\80\00"       ;; alignment 2 with one byte too many
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\12\01"                ;; Code section
+    ;; function 0
+    "\10\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\80\00"       ;; offset 2 with one byte too many
+    "\0b"                      ;; end
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\07\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\10\01"                ;; Code section
+    ;; function 0
+    "\0e\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\28"                      ;; i32.load
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\00"                      ;; offset 0
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\10"          ;; alignment 2 with unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\82\80\80\80\40"          ;; alignment 2 with some unused bits set
+    "\03"                      ;; offset 3
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\03"                      ;; alignment 2
+    "\82\80\80\80\10"          ;; offset 2 with unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\01"          ;; Memory section
+    "\0a\11\01"                ;; Code section
+
+    ;; function 0
+    "\0f\01\01"                ;; local type count
+    "\7f"                      ;; i32
+    "\41\00"                   ;; i32.const 0
+    "\41\03"                   ;; i32.const 3
+    "\36"                      ;; i32.store
+    "\02"                      ;; alignment 2
+    "\82\80\80\80\40"          ;; offset 2 with some unused bits set
+    "\0b"                      ;; end
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+;; memory.grow reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; No more than 2^32 locals.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)
+
+;; Local count can be 0.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"     ;; Type section
+  "\03\02\01\00"           ;; Function section
+  "\0a\0a\01"              ;; Code section
+
+  ;; function 0
+  "\08\03"
+  "\00\7f"                 ;; 0 i32
+  "\00\7e"                 ;; 0 i64
+  "\02\7d"                 ;; 2 f32
+  "\0b"                    ;; end
+)
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)
+
+;; Fewer passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\03"                   ;; Datacount section with value "3"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; More passive segments than datacount
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0c\01\01"                   ;; Datacount section with value "1"
+    "\0b\05\02"                   ;; Data section with two entries
+    "\01\00"                      ;; Passive data section
+    "\01\00")                     ;; Passive data section
+  "data count and data section have inconsistent lengths")
+
+;; memory.init requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0e\01"                ;; Code section
+
+    ;; function 0
+    "\0c\00"
+    "\41\00"                   ;; zero args
+    "\41\00"
+    "\41\00"
+    "\fc\08\00\00"             ;; memory.init
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; data.drop requires a datacount section
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\fc\09\00"                ;; data.drop
+    "\0b"
+
+    "\0b\03\01\01\00"          ;; Data section
+  )                            ;; end
+  "data count section required")
+
+;; passive element segment containing opcode other than ref.func or ref.null
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\70"                   ;; Passive, funcref
+    "\01"                      ;; 1 element
+    "\d3\00\0b"                ;; bad opcode, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "illegal opcode")
+
+;; passive element segment containing type other than funcref
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+
+    "\01\04\01\60\00\00"       ;; Type section
+
+    "\03\02\01\00"             ;; Function section
+
+    "\04\04\01"                ;; Table section with 1 entry
+    "\70\00\00"                ;; no max, minimum 0, funcref
+
+    "\05\03\01\00\00"          ;; Memory section
+
+    "\09\07\01"                ;; Element section with one segment
+    "\05\7f"                   ;; Passive, i32
+    "\01"                      ;; 1 element
+    "\d2\00\0b"                ;; ref.func, index 0, end
+
+    "\0a\04\01"                ;; Code section
+
+    ;; function 0
+    "\02\00"
+    "\0b")                     ;; end
+  "invalid reference type")
+
+;; passive element segment containing opcode ref.func
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\07\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d2\00\0b"                ;; ref.func, index 0, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+;; passive element segment containing opcode ref.null
+(module binary
+  "\00asm" "\01\00\00\00"
+
+  "\01\04\01\60\00\00"       ;; Type section
+
+  "\03\02\01\00"             ;; Function section
+
+  "\04\04\01"                ;; Table section with 1 entry
+  "\70\00\00"                ;; no max, minimum 0, funcref
+
+  "\05\03\01\00\00"          ;; Memory section
+
+  "\09\06\01"                ;; Element section with one segment
+  "\05\70"                   ;; Passive, funcref
+  "\01"                      ;; 1 element
+  "\d0\0b"                   ;; ref.null, end
+
+  "\0a\04\01"                ;; Code section
+
+  ;; function 0
+  "\02\00"
+  "\0b")                     ;; end
+
+
+;; Type count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\01\00"                               ;; type count can be zero
+)
+
+;; 2 type declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\02"                             ;; type section with inconsistent count (2 declared, 1 given)
+    "\60\00\00"                             ;; 1st type
+    ;; "\60\00\00"                          ;; 2nd type (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 type declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01"                             ;; type section with inconsistent count (1 declared, 2 given)
+    "\60\00\00"                             ;; 1st type
+    "\60\00\00"                             ;; 2nd type (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Import count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\01\05\01"                             ;; type section
+    "\60\01\7f\00"                          ;; type 0
+    "\02\01\00"                             ;; import count can be zero
+)
+
+;; 2 import declared, 1 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\05\01"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\02\16\02"                           ;; import section with inconsistent count (2 declared, 1 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 import declared, 2 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\01\09\02"                           ;; type section
+      "\60\01\7f\00"                        ;; type 0
+      "\60\01\7d\00"                        ;; type 1
+      "\02\2b\01"                           ;; import section with inconsistent count (1 declared, 2 given)
+      ;; 1st import
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\69\33\32"         ;; print_i32
+      "\00\00"                              ;; import kind, import signature index
+      ;; 2nd import
+      ;; (redundant)
+      "\08"                                 ;; string length
+      "\73\70\65\63\74\65\73\74"            ;; spectest
+      "\09"                                 ;; string length
+      "\70\72\69\6e\74\5f\66\33\32"         ;; print_f32
+      "\00\01"                              ;; import kind, import signature index
+  )
+  "section size mismatch"
+)
+
+;; Table count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\04\01\00"                             ;; table count can be zero
+)
+
+;; 1 table declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\04\01\01"                           ;; table section with inconsistent count (1 declared, 0 given)
+      ;; "\70\01\00\00"                     ;; table entity
+  )
+  "unexpected end of section or function"
+)
+
+;; Memory count can be zero
+(module binary
+    "\00asm" "\01\00\00\00"
+    "\05\01\00"                             ;; memory count can be zero
+)
+
+;; 1 memory declared, 0 given
+(assert_malformed
+  (module binary
+      "\00asm" "\01\00\00\00"
+      "\05\01\01"                           ;; memory section with inconsistent count (1 declared, 0 given)
+      ;; "\00\00"                           ;; memory 0 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; Global count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\01\00"                               ;; global count can be zero
+)
+
+;; 2 global declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\06\02"                             ;; global section with inconsistent count (2 declared, 1 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    ;; "\7f\00\41\00\0b"                    ;; global 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 global declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                             ;; global section with inconsistent count (1 declared, 2 given)
+    "\7f\00\41\00\0b"                       ;; global 0
+    "\7f\00\41\00\0b"                       ;; global 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; Export count can be 0
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\03\02\00\00"                         ;; func section
+  "\07\01\00"                               ;; export count can be zero
+  "\0a\07\02"                               ;; code section
+  "\02\00\0b"                               ;; function body 0
+  "\02\00\0b"                               ;; function body 1
+)
+
+;; 2 export declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\06\02"                             ;; export section with inconsistent count (2 declared, 1 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    ;; "\02"                                ;; export 1 (missed)
+    ;; "\66\32"                             ;; export name
+    ;; "\00\01"                             ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 export declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\03\02\00\00"                       ;; func section
+    "\07\0b\01"                             ;; export section with inconsistent count (1 declared, 2 given)
+    "\02"                                   ;; export 0
+    "\66\31"                                ;; export name
+    "\00\00"                                ;; export kind, export func index
+    "\02"                                   ;; export 1 (redundant)
+    "\66\32"                                ;; export name
+    "\00\01"                                ;; export kind, export func index
+    "\0a\07\02"                             ;; code section
+    "\02\00\0b"                             ;; function body 0
+    "\02\00\0b"                             ;; function body 1
+  )
+  "section size mismatch"
+)
+
+;; elem segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\04\04\01"                               ;; table section
+  "\70\00\01"                               ;; table 0
+  "\09\01\00"                               ;; elem segment count can be zero
+  "\0a\04\01"                               ;; code section
+  "\02\00\0b"                               ;; function body
+)
+
+;; 2 elem segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\07\02"                             ;; elem with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    ;; "\00\41\00\0b\01\00"                 ;; elem 1 (missed)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "invalid elements segment kind"
+)
+
+;; 1 elem segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\04\04\01"                             ;; table section
+    "\70\00\01"                             ;; table 0
+    "\09\0d\01"                             ;; elem with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\00"                    ;; elem 0
+    "\00\41\00\0b\01\00"                    ;; elem 1 (redundant)
+    "\0a\04\01"                             ;; code section
+    "\02\00\0b"                             ;; function body
+  )
+  "section size mismatch"
+)
+
+;; data segment count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                               ;; memory section
+  "\00\01"                                  ;; memory 0
+  "\0b\01\00"                               ;; data segment count can be zero
+)
+
+;; 2 data segment declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\07\02"                             ;; data with inconsistent segment count (2 declared, 1 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    ;; "\00\41\01\0b\01\62"                 ;; data 1 (missed)
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 data segment declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0d\01"                             ;; data with inconsistent segment count (1 declared, 2 given)
+    "\00\41\00\0b\01\61"                    ;; data 0
+    "\00\41\01\0b\01\62"                    ;; data 1 (redundant)
+  )
+  "section size mismatch"
+)
+
+;; data segment has 7 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\03\0b"                          ;; data segment 0
+    "\07"                                   ;; data segment size with inconsistent lengths (7 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "unexpected end of section or function"
+)
+
+;; data segment has 5 bytes declared, but 6 bytes given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01"                             ;; memory section
+    "\00\01"                                ;; memory 0
+    "\0b\0c\01"                             ;; data section
+    "\00\41\00\0b"                          ;; data segment 0
+    "\05"                                   ;; data segment size with inconsistent lengths (5 declared, 6 given)
+    "\61\62\63\64\65\66"                    ;; 6 bytes given
+  )
+  "section size mismatch"
+)
+
+;; br_table target count can be zero
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01"                               ;; type section
+  "\60\00\00"                               ;; type 0
+  "\03\02\01\00"                            ;; func section
+  "\0a\11\01"                               ;; code section
+  "\0f\00"                                  ;; func 0
+  "\02\40"                                  ;; block 0
+  "\41\01"                                  ;; condition of if 0
+  "\04\40"                                  ;; if 0
+  "\41\01"                                  ;; index of br_table element
+  "\0e\00"                                  ;; br_table target count can be zero
+  "\02"                                     ;; break depth for default
+  "\0b\0b\0b"                               ;; end
+)
+
+;; 2 br_table target declared, 1 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\10\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\02"                                ;; br_table with inconsistent target count (2 declared, 1 given)
+    "\00"                                   ;; break depth 0
+    ;; "\01"                                ;; break depth 1 (missed)
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "unexpected end of section or function"
+)
+
+;; 1 br_table target declared, 2 given
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01"                             ;; type section
+    "\60\00\00"                             ;; type 0
+    "\03\02\01\00"                          ;; func section
+    "\0a\12\01"                             ;; code section
+    "\11\00"                                ;; func 0
+    "\02\40"                                ;; block 0
+    "\41\01"                                ;; condition of if 0
+    "\04\40"                                ;; if 0
+    "\41\01"                                ;; index of br_table element
+    "\0e\01"                                ;; br_table with inconsistent target count (1 declared, 2 given)
+    "\00"                                   ;; break depth 0
+    "\01"                                   ;; break depth 1
+    "\02"                                   ;; break depth for default
+    "\0b\0b\0b"                             ;; end
+  )
+  "invalid reference type"
+)
+
+;; Start section
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\04\01\60\00\00"       ;; Type section
+  "\03\02\01\00"             ;; Function section
+  "\08\01\00"                ;; Start section: function 0
+
+  "\0a\04\01"                ;; Code section
+  ;; function 0
+  "\02\00"
+  "\0b"                      ;; end
+)
+
+;; Multiple start sections
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\08\01\00"                ;; Start section: function 0
+    "\08\01\00"                ;; Start section: function 0
+
+    "\0a\04\01"                ;; Code section
+    ;; function 0
+    "\02\00"
+    "\0b"                      ;; end
+  )
+  "junk after last section"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/br_table.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/br_table.wast
new file mode 100644
index 0000000..48e7a87
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/br_table.wast
@@ -0,0 +1,1690 @@
+;; Test `br_table` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_table 0 0 (i32.const 0)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
+  )
+
+  (func (export "empty") (param i32) (result i32)
+    (block (br_table 0 (local.get 0)) (return (i32.const 21)))
+    (i32.const 22)
+  )
+  (func (export "empty-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31)
+    )
+  )
+
+  (func (export "singleton") (param i32) (result i32)
+    (block
+      (block
+        (br_table 1 0 (local.get 0))
+        (return (i32.const 21))
+      )
+      (return (i32.const 20))
+    )
+    (i32.const 22)
+  )
+
+  (func (export "singleton-value") (param i32) (result i32)
+    (block (result i32)
+      (drop
+        (block (result i32)
+          (br_table 0 1 (i32.const 33) (local.get 0))
+          (return (i32.const 31))
+        )
+      )
+      (i32.const 32)
+    )
+  )
+
+  (func (export "multiple") (param i32) (result i32)
+    (block
+      (block
+        (block
+          (block
+            (block
+              (br_table 3 2 1 0 4 (local.get 0))
+              (return (i32.const 99))
+            )
+            (return (i32.const 100))
+          )
+          (return (i32.const 101))
+        )
+        (return (i32.const 102))
+      )
+      (return (i32.const 103))
+    )
+    (i32.const 104)
+  )
+
+  (func (export "multiple-value") (param i32) (result i32)
+    (local i32)
+    (local.set 1 (block (result i32)
+      (local.set 1 (block (result i32)
+        (local.set 1 (block (result i32)
+          (local.set 1 (block (result i32)
+            (local.set 1 (block (result i32)
+              (br_table 3 2 1 0 4 (i32.const 200) (local.get 0))
+              (return (i32.add (local.get 1) (i32.const 99)))
+            ))
+            (return (i32.add (local.get 1) (i32.const 10)))
+          ))
+          (return (i32.add (local.get 1) (i32.const 11)))
+        ))
+        (return (i32.add (local.get 1) (i32.const 12)))
+      ))
+      (return (i32.add (local.get 1) (i32.const 13)))
+    ))
+    (i32.add (local.get 1) (i32.const 14))
+  )
+
+  (func (export "large") (param i32) (result i32)
+    (block
+      (block
+        (br_table
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          (local.get 0)
+        )
+        (return (i32.const -1))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+
+  (func (export "as-block-first")
+    (block (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (br_table 0 0 0 (i32.const 0)) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0)))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32)
+      (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0))
+    )
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (br_table 1 1 1 (i32.const 4) (i32.const -1))
+      (i32.const 2)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_table 0 0 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0))))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_table 0 (i32.const 1))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1))
+      (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1)))
+      (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0))))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_table 0 (i32.const 2) (i32.const 0))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (br_table 1 (i32.const 3) (i32.const 0)))
+        (else (local.get 1))
+      )
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (local.get 0)
+        (then (local.get 1))
+        (else (br_table 1 0 (i32.const 4) (i32.const 0)))
+      )
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (block (result i32)
+      (select
+        (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1)
+      )
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1))
+      )
+    )
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2)
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1))
+        (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $sig)
+        (i32.const 0) (i32.const 1) (i32.const 2)
+        (br_table 0 (i32.const 23) (i32.const 1))
+      )
+    )
+  )
+
+  (func (export "as-local.set-value") (result i32)
+    (local f32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 17) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-local.tee-value") (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32)
+      (global.set $a (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1)))
+      (i32.const -1)
+     )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0)))
+      (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10))
+    )
+  )
+  (func (export "as-binary-right") (result i64)
+    (block (result i64)
+      (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10))
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0)))
+    )
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0))))
+  )
+
+  (func (export "nested-block-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (i32.const -1))
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (i32.add
+            (i32.const 2)
+            (block (result i32)
+              (drop (i32.const 4))
+              (i32.add
+                (i32.const 8)
+                (br_table 0 1 2 (i32.const 16) (local.get 0))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0)))
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (drop
+                (br_if 0
+                  (br_table 0 1 2 (i32.const 8) (local.get 0))
+                  (i32.const 1)
+                )
+              )
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (drop
+            (block (result i32)
+              (drop (i32.const 4))
+              (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1))
+              (i32.const 32)
+            )
+          )
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (i32.add
+        (i32.const 1)
+        (block (result i32)
+          (drop (i32.const 2))
+          (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
+          (i32.const 16)
+        )
+      )
+    )
+  )
+
+  (func (export "nested-br_table-loop-block") (param i32) (result i32)
+    (local.set 0
+      (loop (result i32)
+        (block
+          (br_table 1 0 0 (local.get 0))
+        )
+        (i32.const 0)
+      )
+    )
+    (loop (result i32)
+      (block
+        (br_table 0 1 1 (local.get 0))
+      )
+      (i32.const 3)
+    )
+  )
+
+  (func (export "meet-anyref") (param i32) (param anyref) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result anyref)
+        (br_table $l1 $l2 $l1 (local.get 1) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-funcref-1") (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result funcref)
+        (br_table $l1 $l1 $l2 (table.get 0 (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-2") (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result funcref)
+        (br_table $l2 $l2 $l1 (table.get 0 (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-3") (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result funcref)
+        (br_table $l2 $l1 $l2 (table.get 0 (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+  (func (export "meet-funcref-4") (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result funcref)
+        (br_table $l1 $l2 $l1 (table.get 0 (i32.const 0)) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-nullref") (param i32) (result funcref)
+    (block $l1 (result funcref)
+      (block $l2 (result nullref)
+        (br_table $l1 $l2 $l1 (ref.null) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "meet-multi-ref") (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (block $l2 (result funcref)
+        (block $l3 (result nullref)
+          (br_table $l3 $l2 $l1 (ref.null) (local.get 0))
+        )
+      )
+    )
+  )
+
+  (func (export "meet-bottom")
+    (block (result f64)
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 1 (i32.const 1))
+      )
+      (drop)
+      (f64.const 0)
+    )
+    (drop)
+  )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "empty" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 11)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -1)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const -100)) (i32.const 22))
+(assert_return (invoke "empty" (i32.const 0xffffffff)) (i32.const 22))
+
+(assert_return (invoke "empty-value" (i32.const 0)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "empty-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "singleton" (i32.const 0)) (i32.const 22))
+(assert_return (invoke "singleton" (i32.const 1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 11)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -1)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const -100)) (i32.const 20))
+(assert_return (invoke "singleton" (i32.const 0xffffffff)) (i32.const 20))
+
+(assert_return (invoke "singleton-value" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "singleton-value" (i32.const 1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 11)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -1)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const -100)) (i32.const 33))
+(assert_return (invoke "singleton-value" (i32.const 0xffffffff)) (i32.const 33))
+
+(assert_return (invoke "multiple" (i32.const 0)) (i32.const 103))
+(assert_return (invoke "multiple" (i32.const 1)) (i32.const 102))
+(assert_return (invoke "multiple" (i32.const 2)) (i32.const 101))
+(assert_return (invoke "multiple" (i32.const 3)) (i32.const 100))
+(assert_return (invoke "multiple" (i32.const 4)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 5)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 6)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 10)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const -1)) (i32.const 104))
+(assert_return (invoke "multiple" (i32.const 0xffffffff)) (i32.const 104))
+
+(assert_return (invoke "multiple-value" (i32.const 0)) (i32.const 213))
+(assert_return (invoke "multiple-value" (i32.const 1)) (i32.const 212))
+(assert_return (invoke "multiple-value" (i32.const 2)) (i32.const 211))
+(assert_return (invoke "multiple-value" (i32.const 3)) (i32.const 210))
+(assert_return (invoke "multiple-value" (i32.const 4)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 5)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 6)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 10)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const -1)) (i32.const 214))
+(assert_return (invoke "multiple-value" (i32.const 0xffffffff)) (i32.const 214))
+
+(assert_return (invoke "large" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 101)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 10000)) (i32.const 0))
+(assert_return (invoke "large" (i32.const 10001)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000000)) (i32.const 1))
+(assert_return (invoke "large" (i32.const 1000001)) (i32.const 1))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 20))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 21))
+(assert_return (invoke "as-call_indirect-last") (i32.const 22))
+(assert_return (invoke "as-call_indirect-func") (i32.const 23))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19))
+(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17))
+(assert_return (invoke "nested-block-value" (i32.const 2)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const -1)) (i32.const 16))
+(assert_return (invoke "nested-block-value" (i32.const 100000)) (i32.const 16))
+
+(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br-value" (i32.const 2)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 11)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const -4)) (i32.const 17))
+(assert_return (invoke "nested-br-value" (i32.const 10213210)) (i32.const 17))
+
+(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_if-value-cond" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 17))
+(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value" (i32.const 2)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const -9)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value" (i32.const 999999)) (i32.const 8))
+
+(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 8))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 2)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 3)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const -1000000)) (i32.const 9))
+(assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9))
+
+(assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "meet-anyref" (i32.const 0) (ref.host 1)) (ref.host 1))
+(assert_return (invoke "meet-anyref" (i32.const 1) (ref.host 1)) (ref.host 1))
+(assert_return (invoke "meet-anyref" (i32.const 2) (ref.host 1)) (ref.host 1))
+
+(assert_return (invoke "meet-funcref-1" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-1" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-1" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-2" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-3" (i32.const 2)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 0)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 1)) (ref.func))
+(assert_return (invoke "meet-funcref-4" (i32.const 2)) (ref.func))
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-empty-vs-num (result i32)
+    (block (br_table 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-num (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-num-vs-arg-num
+    (block
+      (block (result f32)
+        (br_table 0 1 (f32.const 0) (i32.const 0))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-index-void-vs-i32
+    (block (br_table 0 0 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-index-num-vs-i32
+    (block (br_table 0 (i64.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-void-vs-i32 (result i32)
+    (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-void-vs-num-nested (result i32)
+    (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-arg-index-num-vs-i32 (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-arg-void-vs-num (result i32)
+    (block (br_table 0 (i32.const 1)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-then
+      (block
+        (i32.const 0) (i32.const 0)
+        (if (result i32) (then (br_table 0 (i32.const 1))))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-index-empty-in-return
+      (block (result i32)
+        (return (br_table 0))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-arg-value-empty-in-return
+      (block (result i32)
+        (return (br_table 0 (i32.const 1)))
+      )
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $meet-bottom (param i32) (result anyref)
+    (block $l1 (result anyref)
+      (drop
+        (block $l2 (result i32)
+          (br_table $l2 $l1 $l2 (ref.null) (local.get 0))
+        )
+      )
+      (ref.null)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $unbound-label
+    (block (br_table 2 1 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label
+    (block (br_table 0 0x10000001 0 (i32.const 1)))
+  ))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $unbound-label-default
+    (block (br_table 1 2 (i32.const 1)))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $unbound-nested-label-default
+    (block (block (br_table 0 5 (i32.const 1))))
+  ))
+  "unknown label"
+)
+(assert_invalid
+  (module (func $large-label-default
+    (block (br_table 0 0 0x10000001 (i32.const 1)))
+  ))
+  "unknown label"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/bulk.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/bulk.wast
new file mode 100644
index 0000000..fe71939
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/bulk.wast
@@ -0,0 +1,307 @@
+;; segment syntax
+(module
+  (memory 1)
+  (data "foo"))
+
+(module
+  (table 3 funcref)
+  (elem funcref (ref.func 0) (ref.null) (ref.func 1))
+  (func)
+  (func))
+
+;; memory.fill
+(module
+  (memory 1)
+
+  (func (export "fill") (param i32 i32 i32)
+    (memory.fill
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Basic fill test.
+(invoke "fill" (i32.const 1) (i32.const 0xff) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 0xff))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 0))
+
+;; Fill value is stored as a byte.
+(invoke "fill" (i32.const 0) (i32.const 0xbbaa) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xaa))
+
+;; Fill all of memory
+(invoke "fill" (i32.const 0) (i32.const 0) (i32.const 0x10000))
+
+;; Out-of-bounds writes trap, and nothing is written
+(assert_trap (invoke "fill" (i32.const 0xff00) (i32.const 1) (i32.const 0x101))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xff00)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0))
+
+;; Succeed when writing 0 bytes at the end of the region.
+(invoke "fill" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "fill" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.copy
+(module
+  (memory (data "\aa\bb\cc\dd"))
+
+  (func (export "copy") (param i32 i32 i32)
+    (memory.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 4))
+
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 8) (i32.const 10) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xdd))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 10) (i32.const 7) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0xaa))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0xdd))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+
+;; Copy ending at memory limit is ok.
+(invoke "copy" (i32.const 0xff00) (i32.const 0) (i32.const 0x100))
+(invoke "copy" (i32.const 0xfe00) (i32.const 0xff00) (i32.const 0x100))
+
+;; Succeed when copying 0 bytes at the end of the region.
+(invoke "copy" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 0x10000) (i32.const 0))
+
+;; Copying 0 bytes outside the memory traps.
+(assert_trap (invoke "copy" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 0x10001) (i32.const 0))
+    "out of bounds memory access")
+
+
+;; memory.init
+(module
+  (memory 1)
+  (data "\aa\bb\cc\dd")
+
+  (func (export "init") (param i32 i32 i32)
+    (memory.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0)))
+)
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0xbb))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 0))
+
+;; Init ending at memory limit and segment limit is ok.
+(invoke "init" (i32.const 0xfffc) (i32.const 0) (i32.const 4))
+
+;; Out-of-bounds writes trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 0xfffe) (i32.const 0) (i32.const 3))
+    "out of bounds memory access")
+(assert_return (invoke "load8_u" (i32.const 0xfffe)) (i32.const 0xcc))
+(assert_return (invoke "load8_u" (i32.const 0xffff)) (i32.const 0xdd))
+
+;; Succeed when writing 0 bytes at the end of either region.
+(invoke "init" (i32.const 0x10000) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 bytes outside the memory traps.
+(assert_trap (invoke "init" (i32.const 0x10001) (i32.const 0) (i32.const 0))
+    "out of bounds memory access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds memory access")
+
+;; data.drop
+(module
+  (memory 1)
+  (data $p "x")
+  (data $a (memory 0) (i32.const 0) "x")
+
+  (func (export "drop_passive") (data.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (memory.init $p (i32.const 0) (i32.const 0) (local.get $len)))
+
+  (func (export "drop_active") (data.drop $a))
+  (func (export "init_active") (param $len i32)
+    (memory.init $a (i32.const 0) (i32.const 0) (local.get $len)))
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds")
+(invoke "init_active" (i32.const 0))
+
+
+;; table.init
+(module
+  (table 3 funcref)
+  (elem funcref
+    (ref.func $zero) (ref.func $one) (ref.func $zero) (ref.func $one))
+
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+
+  (func (export "init") (param i32 i32 i32)
+    (table.init 0
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Out-of-bounds stores trap, and nothing is written.
+(assert_trap (invoke "init" (i32.const 2) (i32.const 0) (i32.const 2))
+    "out of bounds table access")
+(assert_trap (invoke "call" (i32.const 2))
+    "uninitialized element 2")
+
+(invoke "init" (i32.const 0) (i32.const 1) (i32.const 2))
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 0))
+(assert_trap (invoke "call" (i32.const 2)) "uninitialized element")
+
+;; Init ending at table limit and segment limit is ok.
+(invoke "init" (i32.const 1) (i32.const 2) (i32.const 2))
+
+;; Succeed when storing 0 elements at the end of either region.
+(invoke "init" (i32.const 3) (i32.const 0) (i32.const 0))
+(invoke "init" (i32.const 0) (i32.const 4) (i32.const 0))
+
+;; Writing 0 elements outside the table traps.
+(assert_trap (invoke "init" (i32.const 4) (i32.const 0) (i32.const 0))
+    "out of bounds table access")
+(assert_trap (invoke "init" (i32.const 0) (i32.const 5) (i32.const 0))
+    "out of bounds table access")
+
+
+;; elem.drop
+(module
+  (table 1 funcref)
+  (func $f)
+  (elem $p funcref (ref.func $f))
+  (elem $a (table 0) (i32.const 0) func $f)
+
+  (func (export "drop_passive") (elem.drop $p))
+  (func (export "init_passive") (param $len i32)
+    (table.init $p (i32.const 0) (i32.const 0) (local.get $len))
+  )
+
+  (func (export "drop_active") (elem.drop $a))
+  (func (export "init_active") (param $len i32)
+    (table.init $a (i32.const 0) (i32.const 0) (local.get $len))
+  )
+)
+
+(invoke "init_passive" (i32.const 1))
+(invoke "drop_passive")
+(invoke "drop_passive")
+(assert_return (invoke "init_passive" (i32.const 0)))
+(assert_trap (invoke "init_passive" (i32.const 1)) "out of bounds")
+(invoke "init_passive" (i32.const 0))
+(invoke "drop_active")
+(assert_return (invoke "init_active" (i32.const 0)))
+(assert_trap (invoke "init_active" (i32.const 1)) "out of bounds")
+(invoke "init_active" (i32.const 0))
+
+
+;; table.copy
+(module
+  (table 10 funcref)
+  (elem (i32.const 0) $zero $one $two)
+  (func $zero (result i32) (i32.const 0))
+  (func $one (result i32) (i32.const 1))
+  (func $two (result i32) (i32.const 2))
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy
+      (local.get 0)
+      (local.get 1)
+      (local.get 2)))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (result i32)
+      (local.get 0)))
+)
+
+;; Non-overlapping copy.
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 3))
+;; Now [$zero, $one, $two, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 3)) (i32.const 0))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 5)) (i32.const 2))
+
+;; Overlap, source > dest
+(invoke "copy" (i32.const 0) (i32.const 1) (i32.const 3))
+;; Now [$one, $two, $zero, $zero, $one, $two, ...]
+(assert_return (invoke "call" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 0))
+
+;; Overlap, source < dest
+(invoke "copy" (i32.const 2) (i32.const 0) (i32.const 3))
+;; Now [$one, $two, $one, $two, $zero, $two, ...]
+(assert_return (invoke "call" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "call" (i32.const 3)) (i32.const 2))
+(assert_return (invoke "call" (i32.const 4)) (i32.const 0))
+
+;; Copy ending at table limit is ok.
+(invoke "copy" (i32.const 6) (i32.const 8) (i32.const 2))
+(invoke "copy" (i32.const 8) (i32.const 6) (i32.const 2))
+
+;; Succeed when copying 0 elements at the end of the region.
+(invoke "copy" (i32.const 10) (i32.const 0) (i32.const 0))
+(invoke "copy" (i32.const 0) (i32.const 10) (i32.const 0))
+
+;; Fail on out-of-bounds when copying 0 elements outside of table.
+(assert_trap (invoke "copy" (i32.const 11) (i32.const 0) (i32.const 0))
+  "out of bounds")
+(assert_trap (invoke "copy" (i32.const 0) (i32.const 11) (i32.const 0))
+  "out of bounds")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/custom.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/custom.wast
new file mode 100644
index 0000000..0310f76
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/custom.wast
@@ -0,0 +1,130 @@
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\24\10" "a custom section" "this is the payload"
+  "\00\20\10" "a custom section" "this is payload"
+  "\00\11\10" "a custom section" ""
+  "\00\10\00" "" "this is payload"
+  "\00\01\00" "" ""
+  "\00\24\10" "\00\00custom sectio\00" "this is the payload"
+  "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload"
+  "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload"
+  "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\01\01\00"  ;; type section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\02\01\00"  ;; import section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\03\01\00"  ;; function section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\04\01\00"  ;; table section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\05\01\00"  ;; memory section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\06\01\00"  ;; global section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\07\01\00"  ;; export section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\09\01\00"  ;; element section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0a\01\00"  ;; code section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+  "\0b\01\00"  ;; data section
+  "\00\0e\06" "custom" "payload"
+  "\00\0e\06" "custom" "payload"
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\07\01\60\02\7f\7f\01\7f"                ;; type section
+  "\00\1a\06" "custom" "this is the payload"   ;; custom section
+  "\03\02\01\00"                               ;; function section
+  "\07\0a\01\06\61\64\64\54\77\6f\00\00"       ;; export section
+  "\0a\09\01\07\00\20\00\20\01\6a\0b"          ;; code section
+  "\00\1b\07" "custom2" "this is the payload"  ;; custom section
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00\00\05\01\00\07\00\00"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\26\10" "a custom section" "this is the payload"
+  )
+  "unexpected end"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\25\10" "a custom section" "this is the payload"
+    "\00\24\10" "a custom section" "this is the payload"
+  )
+  "invalid section id"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\07\01\60\02\7f\7f\01\7f"                         ;; type section
+    "\00\25\10" "a custom section" "this is the payload"  ;; invalid length!
+    "\03\02\01\00"                                        ;; function section
+    "\0a\09\01\07\00\20\00\20\01\6a\0b"                   ;; code section
+    "\00\1b\07" "custom2" "this is the payload"           ;; custom section
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Test concatenated modules.
+(assert_malformed
+  (module binary
+    "\00asm\01\00\00\00"
+    "\00asm\01\00\00\00"
+  )
+  "length out of bounds"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\03\01\00\01"                         ;; memory section
+    "\0c\01\02"                               ;; data count section (2 segments)
+    "\0b\06\01\00\41\00\0b\00"                ;; data section (1 segment)
+  )
+  "data count and data section have inconsistent lengths"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/data.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/data.wast
new file mode 100644
index 0000000..aabe102
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/data.wast
@@ -0,0 +1,345 @@
+;; Test the data section
+
+;; Syntax
+
+(module
+  (memory $m 1)
+  (data (i32.const 0))
+  (data (i32.const 1) "a" "" "bcd")
+  (data (offset (i32.const 0)))
+  (data (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory 0) (i32.const 0))
+  (data (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data (memory 0x000) (offset (i32.const 0)))
+  (data (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data (memory $m) (i32.const 0))
+  (data (memory $m) (i32.const 1) "a" "" "bcd")
+  (data (memory $m) (offset (i32.const 0)))
+  (data (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d1 (i32.const 0))
+  (data $d2 (i32.const 1) "a" "" "bcd")
+  (data $d3 (offset (i32.const 0)))
+  (data $d4 (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d5 (memory 0) (i32.const 0))
+  (data $d6 (memory 0x0) (i32.const 1) "a" "" "bcd")
+  (data $d7 (memory 0x000) (offset (i32.const 0)))
+  (data $d8 (memory 0) (offset (i32.const 0)) "" "a" "bc" "")
+  (data $d9 (memory $m) (i32.const 0))
+  (data $d10 (memory $m) (i32.const 1) "a" "" "bcd")
+  (data $d11 (memory $m) (offset (i32.const 0)))
+  (data $d12 (memory $m) (offset (i32.const 0)) "" "a" "bc" "")
+)
+
+;; Basic use
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 3) "b")
+  (data (i32.const 100) "cde")
+  (data (i32.const 5) "x")
+  (data (i32.const 3) "c")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 1) "b")
+  (data (i32.const 2) "cde")
+  (data (i32.const 3) "f")
+  (data (i32.const 2) "g")
+  (data (i32.const 1) "h")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get 0) "a")
+)
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (global.get $g) "a")
+)
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (global.get $g) "a")
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
+;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
+
+;; Corner cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+
+(module
+  (memory 2)
+  (data (i32.const 0x1_ffff) "a")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0))
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0))
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0))
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0x1_0000) "")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0) "" "")
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0))
+  (data (global.get 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0 3))
+  (data (global.get 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 1) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 1) "a")
+)
+
+;; Invalid bounds for data
+
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 0 0)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 0) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (memory 0)
+    (data (i32.const 1))
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (memory 0 1)
+    (data (i32.const 1))
+  )
+  "out of bounds"
+)
+
+;; This seems to cause a time-out on Travis.
+(;assert_unlinkable
+  (module
+    (memory 0x10000)
+    (data (i32.const 0xffffffff) "ab")
+  )
+  ""  ;; either out of memory or out of bounds
+;)
+
+(assert_trap
+  (module
+    (global (import "spectest" "global_i32") i32)
+    (memory 0)
+    (data (global.get 0) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 1 2)
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const 0x1_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2 3)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 1)
+    (data (i32.const -1) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -1) "a")
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (memory 2)
+    (data (i32.const -100) "a")
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -100) "a")
+  )
+  "out of bounds"
+)
+
+;; Data without memory
+
+(assert_invalid
+  (module
+    (data (i32.const 0) "")
+  )
+  "unknown memory"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/elem.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/elem.wast
new file mode 100644
index 0000000..6661c9a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/elem.wast
@@ -0,0 +1,468 @@
+;; Test the element section
+
+;; Syntax
+(module
+  (table $t 10 funcref)
+  (func $f)
+  (func $g)
+
+  ;; Passive
+  (elem funcref)
+  (elem funcref (ref.func $f) (item ref.func $f) (item (ref.null)) (ref.func $g))
+  (elem func)
+  (elem func $f $f $g $g)
+
+  (elem $p1 funcref)
+  (elem $p2 funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g))
+  (elem $p3 func)
+  (elem $p4 func $f $f $g $g)
+
+  ;; Active
+  (elem (table $t) (i32.const 0) funcref)
+  (elem (table $t) (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $g)
+  (elem (table $t) (offset (i32.const 0)) funcref)
+  (elem (table $t) (offset (i32.const 0)) func $f $g)
+  (elem (table 0) (i32.const 0) func)
+  (elem (table 0x0) (i32.const 0) func $f $f)
+  (elem (table 0x000) (offset (i32.const 0)) func)
+  (elem (table 0) (offset (i32.const 0)) func $f $f)
+  (elem (table $t) (i32.const 0) func)
+  (elem (table $t) (i32.const 0) func $f $f)
+  (elem (table $t) (offset (i32.const 0)) func)
+  (elem (table $t) (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)))
+  (elem (offset (i32.const 0)) funcref (ref.func $f) (ref.null))
+  (elem (offset (i32.const 0)) func $f $f)
+  (elem (offset (i32.const 0)) $f $f)
+  (elem (i32.const 0))
+  (elem (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem (i32.const 0) func $f $f)
+  (elem (i32.const 0) $f $f)
+
+  (elem $a1 (table $t) (i32.const 0) funcref)
+  (elem $a2 (table $t) (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem $a3 (table $t) (i32.const 0) func)
+  (elem $a4 (table $t) (i32.const 0) func $f $g)
+  (elem $a9 (table $t) (offset (i32.const 0)) funcref)
+  (elem $a10 (table $t) (offset (i32.const 0)) func $f $g)
+  (elem $a11 (table 0) (i32.const 0) func)
+  (elem $a12 (table 0x0) (i32.const 0) func $f $f)
+  (elem $a13 (table 0x000) (offset (i32.const 0)) func)
+  (elem $a14 (table 0) (offset (i32.const 0)) func $f $f)
+  (elem $a15 (table $t) (i32.const 0) func)
+  (elem $a16 (table $t) (i32.const 0) func $f $f)
+  (elem $a17 (table $t) (offset (i32.const 0)) func)
+  (elem $a18 (table $t) (offset (i32.const 0)) func $f $f)
+  (elem $a19 (offset (i32.const 0)))
+  (elem $a20 (offset (i32.const 0)) funcref (ref.func $f) (ref.null))
+  (elem $a21 (offset (i32.const 0)) func $f $f)
+  (elem $a22 (offset (i32.const 0)) $f $f)
+  (elem $a23 (i32.const 0))
+  (elem $a24 (i32.const 0) funcref (ref.func $f) (ref.null))
+  (elem $a25 (i32.const 0) func $f $f)
+  (elem $a26 (i32.const 0) $f $f)
+
+  ;; Declarative
+  (elem declare funcref)
+  (elem declare funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g))
+  (elem declare func)
+  (elem declare func $f $f $g $g)
+
+  (elem $d1 declare funcref)
+  (elem $d2 declare funcref (ref.func $f) (ref.func $f) (ref.null) (ref.func $g))
+  (elem $d3 declare func)
+  (elem $d4 declare func $f $f $g $g)
+)
+
+(module
+  (func $f)
+  (func $g)
+
+  (table $t funcref (elem (ref.func $f) (ref.null) (ref.func $g)))
+)
+
+
+;; Basic use
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 0) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 5) $f)
+  (elem (i32.const 3) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 5) $f)
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get 0) $f)
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (table 1000 funcref)
+  (func $f)
+  (elem (global.get $g) $f)
+)
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 7) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+;; Corner cases
+
+(module
+  (table 10 funcref)
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+(module
+  (import "spectest" "table" (table 10 funcref))
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+
+(module
+  (table 0 funcref)
+  (elem (i32.const 0))
+)
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (elem (i32.const 0))
+)
+
+(module
+  (table 0 0 funcref)
+  (elem (i32.const 0))
+)
+
+(module
+  (table 20 funcref)
+  (elem (i32.const 20))
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 100 funcref))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 30 funcref))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+;; Invalid bounds for elements
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 0 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 1 funcref)
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 0 funcref)
+    (elem (i32.const 1))
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 20 funcref)
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const 10) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -1) $f)
+  )
+  "out of bounds"
+)
+
+(assert_trap
+  (module
+    (table 10 funcref)
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds"
+)
+(assert_trap
+  (module
+    (import "spectest" "table" (table 10 funcref))
+    (func $f)
+    (elem (i32.const -10) $f)
+  )
+  "out of bounds"
+)
+
+;; Implicitly dropped elements
+
+(module
+  (table 10 funcref)
+  (elem $e (i32.const 0) func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds")
+
+(module
+  (table 10 funcref)
+  (elem $e declare func $f)
+  (func $f)
+  (func (export "init")
+    (table.init $e (i32.const 0) (i32.const 0) (i32.const 1))
+  )
+)
+(assert_trap (invoke "init") "out of bounds")
+
+;; Element without table
+
+(assert_invalid
+  (module
+    (func $f)
+    (elem (i32.const 0) $f)
+  )
+  "unknown table"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 funcref)
+    (elem (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 funcref)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten") (i32.const 66))
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 funcref))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Element sections across multiple modules change the same table
+
+(module $module1
+  (type $out-i32 (func (result i32)))
+  (table (export "shared-table") 10 funcref)
+  (elem (i32.const 8) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 7))
+  )
+  (func (export "call-8") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 8))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+
+(register "module1" $module1)
+
+(assert_trap (invoke $module1 "call-7") "uninitialized element")
+(assert_return (invoke $module1 "call-8") (i32.const 65))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module2
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 7) $const-i32-c)
+  (elem (i32.const 8) $const-i32-d)
+  (func $const-i32-c (type $out-i32) (i32.const 67))
+  (func $const-i32-d (type $out-i32) (i32.const 68))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 68))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
+
+(module $module3
+  (type $out-i32 (func (result i32)))
+  (import "module1" "shared-table" (table 10 funcref))
+  (elem (i32.const 8) $const-i32-e)
+  (elem (i32.const 9) $const-i32-f)
+  (func $const-i32-e (type $out-i32) (i32.const 69))
+  (func $const-i32-f (type $out-i32) (i32.const 70))
+)
+
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 69))
+(assert_return (invoke $module1 "call-9") (i32.const 70))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/exports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/exports.wast
new file mode 100644
index 0000000..a099172
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/exports.wast
@@ -0,0 +1,196 @@
+;; Functions
+
+(module (func) (export "a" (func 0)))
+(module (func) (export "a" (func 0)) (export "b" (func 0)))
+(module (func) (func) (export "a" (func 0)) (export "b" (func 1)))
+
+(module (func (export "a")))
+(module (func (export "a") (export "b") (export "c")))
+(module (func (export "a") (export "b") (param i32)))
+(module (func) (export "a" (func 0)))
+(module (func $a (export "a")))
+(module (func $a) (export "a" (func $a)))
+(module (export "a" (func 0)) (func))
+(module (export "a" (func $a)) (func $a))
+
+(module $Func
+  (export "e" (func $f))
+  (func $f (param $n i32) (result i32)
+    (return (i32.add (local.get $n) (i32.const 1)))
+  )
+)
+(assert_return (invoke "e" (i32.const 42)) (i32.const 43))
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+(module)
+(module $Other1)
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+
+(assert_invalid
+  (module (func) (export "a" (func 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func) (export "a" (func 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (func) (export "a" (func 0)) (export "a" (func 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Globals
+
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0)))
+(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1)))
+
+(module (global (export "a") i32 (i32.const 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global $a (export "a") i32 (i32.const 0)))
+(module (global $a i32 (i32.const 0)) (export "a" (global $a)))
+(module (export "a" (global 0)) (global i32 (i32.const 0)))
+(module (export "a" (global $a)) (global $a i32 (i32.const 0)))
+
+(module $Global
+  (export "e" (global $g))
+  (global $g i32 (i32.const 42))
+)
+(assert_return (get "e") (i32.const 42))
+(assert_return (get $Global "e") (i32.const 42))
+(module)
+(module $Other2)
+(assert_return (get $Global "e") (i32.const 42))
+
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 1)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Tables
+
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0)))
+(module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1)))
+
+(module (table (export "a") 0 funcref))
+(module (table (export "a") 0 1 funcref))
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 1 funcref) (export "a" (table 0)))
+(module (table $a (export "a") 0 funcref))
+(module (table $a (export "a") 0 1 funcref))
+(module (table $a 0 funcref) (export "a" (table $a)))
+(module (table $a 0 1 funcref) (export "a" (table $a)))
+(module (export "a" (table 0)) (table 0 funcref))
+(module (export "a" (table 0)) (table 0 1 funcref))
+(module (export "a" (table $a)) (table $a 0 funcref))
+(module (export "a" (table $a)) (table $a 0 1 funcref))
+
+(; TODO: access table ;)
+
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 1)))
+  "unknown table"
+)
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Memories
+
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0)))
+;; No multiple memories yet.
+;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1)))
+
+(module (memory (export "a") 0))
+(module (memory (export "a") 0 1))
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0 1) (export "a" (memory 0)))
+(module (memory $a (export "a") 0))
+(module (memory $a (export "a") 0 1))
+(module (memory $a 0) (export "a" (memory $a)))
+(module (memory $a 0 1) (export "a" (memory $a)))
+(module (export "a" (memory 0)) (memory 0))
+(module (export "a" (memory 0)) (memory 0 1))
+(module (export "a" (memory $a)) (memory $a 0))
+(module (export "a" (memory $a)) (memory $a 0 1))
+
+(; TODO: access memory ;)
+
+(assert_invalid
+  (module (memory 0) (export "a" (memory 1)))
+  "unknown memory"
+)
+(assert_invalid
+  (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+;; No multiple memories yet.
+;; (assert_invalid
+;;   (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1)))
+;;   "duplicate export name"
+;; )
+(assert_invalid
+  (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/globals.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/globals.wast
new file mode 100644
index 0000000..63aabb9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/globals.wast
@@ -0,0 +1,492 @@
+;; Test globals
+
+(module
+  (global $a i32 (i32.const -2))
+  (global (;1;) f32 (f32.const -3))
+  (global (;2;) f64 (f64.const -4))
+  (global $b i64 (i64.const -5))
+
+  (global $x (mut i32) (i32.const -12))
+  (global (;5;) (mut f32) (f32.const -13))
+  (global (;6;) (mut f64) (f64.const -14))
+  (global $y (mut i64) (i64.const -15))
+
+  (global $r anyref (ref.null))
+  (global funcref (ref.null))
+
+  (func (export "get-a") (result i32) (global.get $a))
+  (func (export "get-b") (result i64) (global.get $b))
+  (func (export "get-r") (result anyref) (global.get $r))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i64) (global.get $y))
+  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
+
+  (func (export "get-1") (result f32) (global.get 1))
+  (func (export "get-2") (result f64) (global.get 2))
+  (func (export "get-5") (result f32) (global.get 5))
+  (func (export "get-6") (result f64) (global.get 6))
+  (func (export "set-5") (param f32) (global.set 5 (local.get 0)))
+  (func (export "set-6") (param f64) (global.set 6 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (global.get $x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (global.get $x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (global.get $x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $x) (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy) (global.get $x) (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy) (global.get $x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $x)
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $x) (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table funcref (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (global.get $x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (global.get $x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0) (global.get $x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (global.get $x))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (global.get $x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (global.get $x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $x (global.get $x))
+    (global.get $x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $x) (global.get $x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+)
+
+(assert_return (invoke "get-a") (i32.const -2))
+(assert_return (invoke "get-b") (i64.const -5))
+(assert_return (invoke "get-r") (ref.null))
+(assert_return (invoke "get-x") (i32.const -12))
+(assert_return (invoke "get-y") (i64.const -15))
+
+(assert_return (invoke "get-1") (f32.const -3))
+(assert_return (invoke "get-2") (f64.const -4))
+(assert_return (invoke "get-5") (f32.const -13))
+(assert_return (invoke "get-6") (f64.const -14))
+
+(assert_return (invoke "set-x" (i32.const 6)))
+(assert_return (invoke "set-y" (i64.const 7)))
+(assert_return (invoke "set-5" (f32.const 8)))
+(assert_return (invoke "set-6" (f64.const 9)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+(assert_return (invoke "get-5") (f32.const 8))
+(assert_return (invoke "get-6") (f64.const 9))
+
+(assert_return (invoke "as-select-first") (i32.const 6))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 6))
+(assert_return (invoke "as-loop-mid") (i32.const 6))
+(assert_return (invoke "as-loop-last") (i32.const 6))
+
+(assert_return (invoke "as-if-condition") (i32.const 2))
+(assert_return (invoke "as-if-then") (i32.const 6))
+(assert_return (invoke "as-if-else") (i32.const 6))
+
+(assert_return (invoke "as-br_if-first") (i32.const 6))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 6))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 6))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+
+(assert_return (invoke "as-call-value") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 6))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 6))
+
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-global.set-value") (i32.const 6))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 36))
+(assert_return (invoke "as-compare-operand") (i32.const 1))
+
+(assert_invalid
+  (module (global f32 (f32.const 0)) (func (global.set 0 (f32.const 1))))
+  "global is immutable"
+)
+
+;; mutable globals can be exported
+(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
+(module (global (export "a") (mut f32) (f32.const 0)))
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 0))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (local.get 0)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 1))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (f32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (i32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (;empty instruction sequence;)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global (import "" "") anyref) (global funcref (global.get 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 0)))
+  "unknown global"
+)
+
+(assert_invalid
+  (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
+  "unknown global"
+)
+
+(module
+  (import "spectest" "global_i32" (global i32))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\02"                          ;; invalid mutability
+  )
+  "invalid mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\98\80\80\80\00"             ;; import section
+      "\01"                          ;; length 1
+      "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
+      "\03"                          ;; GlobalImport
+      "\7f"                          ;; i32
+      "\ff"                          ;; invalid mutability
+  )
+  "invalid mutability"
+)
+
+(module
+  (global i32 (i32.const 0))
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\02"               ;; invalid mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "invalid mutability"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\86\80\80\80\00"  ;; global section
+      "\01"               ;; length 1
+      "\7f"               ;; i32
+      "\ff"               ;; invalid mutability
+      "\41\00"            ;; i32.const 0
+      "\0b"               ;; end
+  )
+  "invalid mutability"
+)
+
+
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty
+      (global.set $x)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-block
+      (i32.const 0)
+      (block (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-loop
+      (i32.const 0)
+      (loop (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (global.set $x)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-return
+      (return (global.set $x))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-select
+      (select (global.set $x) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-global.set-value-empty-in-call
+      (call 1 (global.set $x))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-global.set-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (global.set $x) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/imports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/imports.wast
new file mode 100644
index 0000000..c3a011d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/imports.wast
@@ -0,0 +1,605 @@
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (table (export "table-10-inf") 10 funcref)
+  (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; Multiple memories are not yet supported
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    ;; JavaScript can't handle i64 yet.
+    ;; (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    ;; JavaScript can't handle i64 yet.
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table $tab 10 20 funcref))
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table $tab (import "spectest" "table") 10 20 funcref)
+  (elem (table $tab) (i32.const 1) func $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect $tab (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (import "spectest" "table" (table 0 funcref))
+  (import "spectest" "table" (table 0 funcref))
+  (table 10 funcref)
+  (table 10 funcref)
+)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 funcref)))
+(module (import "test" "table-10-20" (table 5 funcref)))
+(module (import "test" "table-10-20" (table 0 funcref)))
+(module (import "test" "table-10-20" (table 10 20 funcref)))
+(module (import "test" "table-10-20" (table 5 20 funcref)))
+(module (import "test" "table-10-20" (table 0 20 funcref)))
+(module (import "test" "table-10-20" (table 10 25 funcref)))
+(module (import "test" "table-10-20" (table 5 25 funcref)))
+(module (import "test" "table-10-20" (table 0 25 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 12 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-20" (table 10 18 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data (memory 0) (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/linking.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/linking.wast
new file mode 100644
index 0000000..49d5572
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/linking.wast
@@ -0,0 +1,495 @@
+;; Functions
+
+(module $Mf
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 2))
+)
+(register "Mf" $Mf)
+
+(module $Nf
+  (func $f (import "Mf" "call") (result i32))
+  (export "Mf.call" (func $f))
+  (func (export "call Mf.call") (result i32) (call $f))
+  (func (export "call") (result i32) (call $g))
+  (func $g (result i32) (i32.const 3))
+)
+
+(assert_return (invoke $Mf "call") (i32.const 2))
+(assert_return (invoke $Nf "Mf.call") (i32.const 2))
+(assert_return (invoke $Nf "call") (i32.const 3))
+(assert_return (invoke $Nf "call Mf.call") (i32.const 2))
+
+(module
+  (import "spectest" "print_i32" (func $f (param i32)))
+  (export "print" (func $f))
+)
+(register "reexport_f")
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "reexport_f" "print" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module $Mg
+  (global $glob (export "glob") i32 (i32.const 42))
+  (func (export "get") (result i32) (global.get $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
+)
+(register "Mg" $Mg)
+
+(module $Ng
+  (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
+  (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
+  (export "Mg.glob" (global $x))
+  (export "Mg.get" (func $f))
+  (global $glob (export "glob") i32 (i32.const 43))
+  (func (export "get") (result i32) (global.get $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
+)
+
+(assert_return (get $Mg "glob") (i32.const 42))
+(assert_return (get $Ng "Mg.glob") (i32.const 42))
+(assert_return (get $Ng "glob") (i32.const 43))
+(assert_return (invoke $Mg "get") (i32.const 42))
+(assert_return (invoke $Ng "Mg.get") (i32.const 42))
+(assert_return (invoke $Ng "get") (i32.const 43))
+
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
+
+
+(module $Mref_ex
+  (global (export "g-const-null") nullref (ref.null))
+  (global (export "g-var-null") (mut nullref) (ref.null))
+  (global (export "g-const-func") funcref (ref.null))
+  (global (export "g-var-func") (mut funcref) (ref.null))
+  (global (export "g-const-any") anyref (ref.null))
+  (global (export "g-var-any") (mut anyref) (ref.null))
+)
+(register "Mref_ex" $Mref_ex)
+
+(module $Mref_im
+  (global (import "Mref_ex" "g-const-null") nullref)
+  (global (import "Mref_ex" "g-const-null") funcref)
+  (global (import "Mref_ex" "g-const-null") anyref)
+  (global (import "Mref_ex" "g-const-func") funcref)
+  (global (import "Mref_ex" "g-const-func") anyref)
+  (global (import "Mref_ex" "g-const-any") anyref)
+
+  (global (import "Mref_ex" "g-var-null") (mut nullref))
+  (global (import "Mref_ex" "g-var-func") (mut funcref))
+  (global (import "Mref_ex" "g-var-any") (mut anyref))
+)
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-func") nullref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-any") nullref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-const-any") funcref))
+  "incompatible import type"
+)
+
+
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-null") (mut funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-null") (mut anyref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-func") (mut nullref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-func") (mut anyref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-any") (mut nullref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (global (import "Mref_ex" "g-var-any") (mut funcref)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module $Mt
+  (type (func (result i32)))
+  (type (func))
+
+  (table (export "tab") 10 funcref)
+  (elem (i32.const 2) $g $g $g $g)
+  (func $g (result i32) (i32.const 4))
+  (func (export "h") (result i32) (i32.const -4))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+(register "Mt" $Mt)
+
+(module $Nt
+  (type (func))
+  (type (func (result i32)))
+
+  (func $f (import "Mt" "call") (param i32) (result i32))
+  (func $h (import "Mt" "h") (result i32))
+
+  (table funcref (elem $g $g $g $h $f))
+  (func $g (result i32) (i32.const 5))
+
+  (export "Mt.call" (func $f))
+  (func (export "call Mt.call") (param i32) (result i32)
+    (call $f (local.get 0))
+  )
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 1) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const 4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const 4))
+
+(assert_trap (invoke $Mt "call" (i32.const 1)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 1)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 1)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Mt "call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 20)) "undefined")
+(assert_trap (invoke $Nt "call" (i32.const 7)) "undefined")
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 20)) "undefined")
+
+(assert_return (invoke $Nt "call" (i32.const 3)) (i32.const -4))
+(assert_trap (invoke $Nt "call" (i32.const 4)) "indirect call")
+
+(module $Ot
+  (type (func (result i32)))
+
+  (func $h (import "Mt" "h") (result i32))
+  (table (import "Mt" "tab") 5 funcref)
+  (elem (i32.const 1) $i $h)
+  (func $i (result i32) (i32.const 6))
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mt "call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 3)) (i32.const 4))
+(assert_return (invoke $Ot "call" (i32.const 3)) (i32.const 4))
+
+(assert_return (invoke $Mt "call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Nt "call" (i32.const 2)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 2)) (i32.const -4))
+(assert_return (invoke $Ot "call" (i32.const 2)) (i32.const -4))
+
+(assert_return (invoke $Mt "call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Nt "call" (i32.const 1)) (i32.const 5))
+(assert_return (invoke $Nt "call Mt.call" (i32.const 1)) (i32.const 6))
+(assert_return (invoke $Ot "call" (i32.const 1)) (i32.const 6))
+
+(assert_trap (invoke $Mt "call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Nt "Mt.call" (i32.const 0)) "uninitialized")
+(assert_return (invoke $Nt "call" (i32.const 0)) (i32.const 5))
+(assert_trap (invoke $Nt "call Mt.call" (i32.const 0)) "uninitialized")
+(assert_trap (invoke $Ot "call" (i32.const 0)) "uninitialized")
+
+(assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
+
+(module
+  (table (import "Mt" "tab") 0 funcref)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (global.get 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 0 funcref)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "out of bounds"
+)
+
+(assert_unlinkable
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (memory (import "Mt" "mem") 1)  ;; does not exist
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 9) $f)
+  )
+  "unknown import"
+)
+(assert_trap (invoke $Mt "call" (i32.const 7)) "uninitialized")
+
+;; Unlike in the v1 spec, active element segments stored before an
+;; out-of-bounds access persist after the instantiation failure.
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (elem (i32.const 12) $f)  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+(assert_trap
+  (module
+    (table (import "Mt" "tab") 10 funcref)
+    (func $f (result i32) (i32.const 0))
+    (elem (i32.const 7) $f)
+    (memory 1)
+    (data (i32.const 0x10000) "d")  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mt "call" (i32.const 7)) (i32.const 0))
+
+
+(module $Mtable_ex
+  (table $t1 (export "t-null") 1 nullref)
+  (table $t2 (export "t-func") 1 funcref)
+  (table $t3 (export "t-any") 1 anyref)
+)
+(register "Mtable_ex" $Mtable_ex)
+
+(module
+  (table (import "Mtable_ex" "t-null") 1 nullref)
+  (table (import "Mtable_ex" "t-func") 1 funcref)
+  (table (import "Mtable_ex" "t-any") 1 anyref)
+)
+
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-null") 1 funcref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-null") 1 anyref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-func") 1 nullref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-func") 1 anyref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-any") 1 nullref))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (table (import "Mtable_ex" "t-any") 1 funcref))
+  "incompatible import type"
+)
+
+
+;; Memories
+
+(module $Mm
+  (memory (export "mem") 1 5)
+  (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+(register "Mm" $Mm)
+
+(module $Nm
+  (func $loadM (import "Mm" "load") (param i32) (result i32))
+
+  (memory 1)
+  (data (i32.const 10) "\f0\f1\f2\f3\f4\f5")
+
+  (export "Mm.load" (func $loadM))
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 2))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+
+(module $Om
+  (memory (import "Mm" "mem") 1)
+  (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
+
+  (func (export "load") (param $a i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+)
+
+(assert_return (invoke $Mm "load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "Mm.load" (i32.const 12)) (i32.const 0xa7))
+(assert_return (invoke $Nm "load" (i32.const 12)) (i32.const 0xf2))
+(assert_return (invoke $Om "load" (i32.const 12)) (i32.const 0xa7))
+
+(module
+  (memory (import "Mm" "mem") 0)
+  (data (i32.const 0xffff) "a")
+)
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 0)
+    (data (i32.const 0x10000) "a")
+  )
+  "out of bounds"
+)
+
+(module $Pm
+  (memory (import "Mm" "mem") 1 8)
+
+  (func (export "grow") (param $a i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+(assert_return (invoke $Pm "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke $Pm "grow" (i32.const 0)) (i32.const 5))
+
+(assert_unlinkable
+  (module
+    (func $host (import "spectest" "print"))
+    (memory (import "Mm" "mem") 1)
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
+    (data (i32.const 0) "abc")
+  )
+  "unknown import"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 0))
+
+;; Unlike in v1 spec, active data segments written before an
+;; out-of-bounds access persist after the instantiation failure.
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (data (i32.const 0x50000) "d") ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+(assert_trap
+  (module
+    (memory (import "Mm" "mem") 1)
+    (data (i32.const 0) "abc")
+    (table 0 funcref)
+    (func)
+    (elem (i32.const 0) 0)  ;; out of bounds
+  )
+  "out of bounds"
+)
+(assert_return (invoke $Mm "load" (i32.const 0)) (i32.const 97))
+
+;; Store is modified if the start function traps.
+(module $Ms
+  (type $t (func (result i32)))
+  (memory (export "memory") 1)
+  (table (export "table") 1 funcref)
+  (func (export "get memory[0]") (type $t)
+    (i32.load8_u (i32.const 0))
+  )
+  (func (export "get table[0]") (type $t)
+    (call_indirect (type $t) (i32.const 0))
+  )
+)
+(register "Ms" $Ms)
+
+(assert_trap
+  (module
+    (import "Ms" "memory" (memory 1))
+    (import "Ms" "table" (table 1 funcref))
+    (data (i32.const 0) "hello")
+    (elem (i32.const 0) $f)
+    (func $f (result i32)
+      (i32.const 0xdead)
+    )
+    (func $main
+      (unreachable)
+    )
+    (start $main)
+  )
+  "unreachable"
+)
+
+(assert_return (invoke $Ms "get memory[0]") (i32.const 104))  ;; 'h'
+(assert_return (invoke $Ms "get table[0]") (i32.const 0xdead))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_copy.wast
new file mode 100644
index 0000000..692e1ad
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_copy.wast
@@ -0,0 +1,5577 @@
+;;
+;; Generated by ../meta/generate_memory_copy.js
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (func (export "test")
+    (memory.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 0) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65515) (i32.const 0) (i32.const 39))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 20))
+(assert_return (invoke "load8_u" (i32.const 219)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 418)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 617)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 816)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1015)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1214)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1413)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1612)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1811)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2010)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2209)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2408)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2607)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2806)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3005)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3204)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3403)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3602)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3801)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4000)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4199)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4398)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4597)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4796)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4995)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5194)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5393)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5592)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5791)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5990)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6189)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6388)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6587)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6786)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6985)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7184)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7383)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7582)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7781)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7980)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8179)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8378)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8577)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8776)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8975)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9174)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9373)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9572)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9771)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9970)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10169)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10368)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10567)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10766)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10965)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11164)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11363)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11562)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11761)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11960)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12159)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12358)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12557)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12756)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12955)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13154)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13353)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13552)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13751)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13950)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14149)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14348)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14547)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14746)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14945)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15144)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15343)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15542)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15741)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15940)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16139)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16338)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16537)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16736)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16935)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17134)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17333)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17532)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17731)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17930)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18129)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18328)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18527)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18726)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18925)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19124)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19323)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19522)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19721)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19920)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20119)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20318)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20517)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20716)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20915)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21114)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21313)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21512)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21711)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21910)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22109)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22308)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22507)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22706)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22905)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23104)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23303)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23502)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23701)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23900)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24099)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24298)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24497)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24696)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24895)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25094)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25293)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25492)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25691)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25890)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26089)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26288)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26487)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26686)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26885)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27084)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27283)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27482)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27681)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27880)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28079)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28278)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28477)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28676)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28875)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29074)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29273)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29472)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29671)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29870)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30069)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30268)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30467)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30666)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30865)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31064)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31263)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31462)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31661)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31860)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32059)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32258)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32457)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32656)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32855)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33054)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33253)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33452)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33651)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33850)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34049)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34248)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34447)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34646)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34845)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35044)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35243)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35442)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35641)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35840)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36039)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36238)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36437)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36636)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36835)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37034)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37233)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37432)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37631)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37830)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38029)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38228)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38427)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38626)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38825)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39024)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39223)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39422)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39621)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39820)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40019)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40218)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40417)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40616)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40815)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41014)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41213)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41412)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41611)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41810)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42009)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42208)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42407)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42606)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42805)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43004)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43203)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43402)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43601)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43800)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43999)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 0))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65515) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13\14")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65515) (i32.const 39))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 20))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65486) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65486) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65487)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65488)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65489)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65491)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65492)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65493)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65494)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65495)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65496)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65497)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65498)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65499)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65500)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65501)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65502)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65503)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65504)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65505)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65486) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65506) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65506) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65507)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65508)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65509)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65510)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65511)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65512)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65513)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65514)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65515)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65506) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 65516) (i32.const 40))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1  )
+  (data (i32.const 65516) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 65516) (i32.const 4294963200))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61490)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61689)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61888)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62087)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62286)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62485)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62684)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62883)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63082)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63281)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63480)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63679)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63878)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64077)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64276)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64475)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64674)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64873)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65072)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65271)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65470)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65517)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 65518)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 65519)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 65520)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 65521)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 65522)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 65523)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 65524)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 65525)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 65526)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 65527)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 65528)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 65529)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 65530)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 65531)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 65532)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 65533)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 65534)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 65535)) (i32.const 19))
+
+(module
+  (memory (export "mem") 1 1 )
+  (data (i32.const 61440) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\10\11\12\13")
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (memory.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(assert_trap (invoke "run" (i32.const 65516) (i32.const 61440) (i32.const 4294967040))
+             "out of bounds")
+
+(assert_return (invoke "load8_u" (i32.const 198)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 397)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 596)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 795)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 994)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1193)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1392)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1591)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1790)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1989)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2188)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2387)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2586)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2785)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2984)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3183)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3382)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3581)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3780)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 3979)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4178)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4377)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4576)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4775)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 4974)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5173)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5372)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5571)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5770)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 5969)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6168)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6367)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6566)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6765)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 6964)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7163)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7362)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7561)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7760)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7959)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8158)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8357)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8556)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8755)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8954)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9153)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9352)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9551)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9750)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9949)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10148)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10347)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10546)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10745)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10944)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11143)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11342)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11541)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11740)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11939)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12138)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12337)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12536)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12735)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12934)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13133)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13332)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13531)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13730)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 13929)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14128)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14327)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14526)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14725)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14924)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15123)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15322)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15521)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15720)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 15919)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16118)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16317)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16516)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16715)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 16914)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17113)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17312)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17511)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17710)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 17909)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18108)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18307)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18506)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18705)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18904)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19103)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19302)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19501)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19700)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19899)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20098)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20297)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20496)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20695)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20894)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21093)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21292)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21491)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21690)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21889)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22088)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22287)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22486)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22685)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22884)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23083)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23282)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23481)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23680)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23879)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24078)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24277)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24476)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24675)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24874)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25073)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25272)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25471)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25670)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25869)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26068)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26267)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26466)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26665)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26864)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27063)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27262)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27461)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27660)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27859)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28058)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28257)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28456)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28655)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28854)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29053)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29252)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29451)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29650)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29849)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30048)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30247)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30446)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30645)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 30844)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31043)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31242)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31441)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31640)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 31839)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32038)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32237)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32436)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32635)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 32834)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33033)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33232)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33431)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33630)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 33829)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34028)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34227)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34426)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34625)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 34824)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35023)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35222)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35421)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35620)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 35819)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36018)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36217)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36416)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36615)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 36814)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37013)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37212)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37411)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37610)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 37809)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38008)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38207)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38406)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38605)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 38804)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39003)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39202)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39401)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39600)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39799)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 39998)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40197)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40396)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40595)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40794)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 40993)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41192)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41391)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41590)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41789)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 41988)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42187)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42386)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42585)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42784)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 42983)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43182)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43381)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43580)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43779)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 43978)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44177)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44376)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44575)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44774)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 44973)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45172)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45371)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45570)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45769)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 45968)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46167)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46366)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46565)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46764)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 46963)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47162)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47361)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47560)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47759)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 47958)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48157)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48356)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48555)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48754)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 48953)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49152)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49351)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49550)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49749)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 49948)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50147)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50346)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50545)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50744)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 50943)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51142)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51341)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51540)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51739)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 51938)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52137)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52336)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52535)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52734)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 52933)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53132)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53331)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53530)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53729)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 53928)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54127)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54326)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54525)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54724)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 54923)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55122)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55321)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55520)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55719)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 55918)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56117)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56316)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56515)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56714)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 56913)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57112)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57311)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 57908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 58903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 59898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 60893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61440)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61441)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 61442)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 61443)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 61444)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 61445)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 61446)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 61447)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 61448)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 61449)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 61450)) (i32.const 10))
+(assert_return (invoke "load8_u" (i32.const 61451)) (i32.const 11))
+(assert_return (invoke "load8_u" (i32.const 61452)) (i32.const 12))
+(assert_return (invoke "load8_u" (i32.const 61453)) (i32.const 13))
+(assert_return (invoke "load8_u" (i32.const 61454)) (i32.const 14))
+(assert_return (invoke "load8_u" (i32.const 61455)) (i32.const 15))
+(assert_return (invoke "load8_u" (i32.const 61456)) (i32.const 16))
+(assert_return (invoke "load8_u" (i32.const 61457)) (i32.const 17))
+(assert_return (invoke "load8_u" (i32.const 61458)) (i32.const 18))
+(assert_return (invoke "load8_u" (i32.const 61459)) (i32.const 19))
+(assert_return (invoke "load8_u" (i32.const 61510)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61709)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 61908)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62107)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62306)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62505)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62704)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 62903)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63102)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63301)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63500)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63699)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 63898)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64097)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64296)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64495)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64694)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 64893)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65092)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65291)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 65490)) (i32.const 0))
+
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.copy (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 9) (i32.const 10) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 9) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9) (i32.const 20) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 10) (i32.const 0x55) (i32.const 10))
+    (memory.copy (i32.const 16) (i32.const 15) (i32.const 5)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 10) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFF00) (i32.const 0x8000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0xFFFFFF00) (i32.const 0x4000) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x8000) (i32.const 0xFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+ (memory 1 1)
+ (func (export "test")
+   (memory.copy (i32.const 0x4000) (i32.const 0xFFFFFF00) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 0x0000) (i32.const 0x55) (i32.const 0x8000))
+    (memory.fill (i32.const 0x8000) (i32.const 0xAA) (i32.const 0x8000))
+    (memory.copy (i32.const 0x9000) (i32.const 0x7000) (i32.const 0)))
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 32768) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32768) (i32.const 65536) (i32.const 170))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x7000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x7000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x9000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x10000) (i32.const 0x10000) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.copy (i32.const 0x20000) (i32.const 0x20000) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  (func (export "test")
+    (memory.fill (i32.const 17767) (i32.const 1) (i32.const 1344))
+    (memory.fill (i32.const 39017) (i32.const 2) (i32.const 1055))
+    (memory.fill (i32.const 56401) (i32.const 3) (i32.const 988))
+    (memory.fill (i32.const 37962) (i32.const 4) (i32.const 322))
+    (memory.fill (i32.const 7977) (i32.const 5) (i32.const 1994))
+    (memory.fill (i32.const 22714) (i32.const 6) (i32.const 3036))
+    (memory.fill (i32.const 16882) (i32.const 7) (i32.const 2372))
+    (memory.fill (i32.const 43491) (i32.const 8) (i32.const 835))
+    (memory.fill (i32.const 124) (i32.const 9) (i32.const 1393))
+    (memory.fill (i32.const 2132) (i32.const 10) (i32.const 2758))
+    (memory.fill (i32.const 8987) (i32.const 11) (i32.const 3098))
+    (memory.fill (i32.const 52711) (i32.const 12) (i32.const 741))
+    (memory.fill (i32.const 3958) (i32.const 13) (i32.const 2823))
+    (memory.fill (i32.const 49715) (i32.const 14) (i32.const 1280))
+    (memory.fill (i32.const 50377) (i32.const 15) (i32.const 1466))
+    (memory.fill (i32.const 20493) (i32.const 16) (i32.const 3158))
+    (memory.fill (i32.const 47665) (i32.const 17) (i32.const 544))
+    (memory.fill (i32.const 12451) (i32.const 18) (i32.const 2669))
+    (memory.fill (i32.const 24869) (i32.const 19) (i32.const 2651))
+    (memory.fill (i32.const 45317) (i32.const 20) (i32.const 1570))
+    (memory.fill (i32.const 43096) (i32.const 21) (i32.const 1691))
+    (memory.fill (i32.const 33886) (i32.const 22) (i32.const 646))
+    (memory.fill (i32.const 48555) (i32.const 23) (i32.const 1858))
+    (memory.fill (i32.const 53453) (i32.const 24) (i32.const 2657))
+    (memory.fill (i32.const 30363) (i32.const 25) (i32.const 981))
+    (memory.fill (i32.const 9300) (i32.const 26) (i32.const 1807))
+    (memory.fill (i32.const 50190) (i32.const 27) (i32.const 487))
+    (memory.fill (i32.const 62753) (i32.const 28) (i32.const 530))
+    (memory.fill (i32.const 36316) (i32.const 29) (i32.const 943))
+    (memory.fill (i32.const 6768) (i32.const 30) (i32.const 381))
+    (memory.fill (i32.const 51262) (i32.const 31) (i32.const 3089))
+    (memory.fill (i32.const 49729) (i32.const 32) (i32.const 658))
+    (memory.fill (i32.const 44540) (i32.const 33) (i32.const 1702))
+    (memory.fill (i32.const 33342) (i32.const 34) (i32.const 1092))
+    (memory.fill (i32.const 50814) (i32.const 35) (i32.const 1410))
+    (memory.fill (i32.const 47594) (i32.const 36) (i32.const 2204))
+    (memory.fill (i32.const 54123) (i32.const 37) (i32.const 2394))
+    (memory.fill (i32.const 55183) (i32.const 38) (i32.const 250))
+    (memory.fill (i32.const 22620) (i32.const 39) (i32.const 2097))
+    (memory.fill (i32.const 17132) (i32.const 40) (i32.const 3264))
+    (memory.fill (i32.const 54331) (i32.const 41) (i32.const 3299))
+    (memory.fill (i32.const 39474) (i32.const 42) (i32.const 2796))
+    (memory.fill (i32.const 36156) (i32.const 43) (i32.const 2070))
+    (memory.fill (i32.const 35308) (i32.const 44) (i32.const 2763))
+    (memory.fill (i32.const 32731) (i32.const 45) (i32.const 312))
+    (memory.fill (i32.const 63746) (i32.const 46) (i32.const 192))
+    (memory.fill (i32.const 30974) (i32.const 47) (i32.const 596))
+    (memory.fill (i32.const 16635) (i32.const 48) (i32.const 501))
+    (memory.fill (i32.const 57002) (i32.const 49) (i32.const 686))
+    (memory.fill (i32.const 34299) (i32.const 50) (i32.const 385))
+    (memory.fill (i32.const 60881) (i32.const 51) (i32.const 903))
+    (memory.fill (i32.const 61445) (i32.const 52) (i32.const 2390))
+    (memory.fill (i32.const 46972) (i32.const 53) (i32.const 1441))
+    (memory.fill (i32.const 25973) (i32.const 54) (i32.const 3162))
+    (memory.fill (i32.const 5566) (i32.const 55) (i32.const 2135))
+    (memory.fill (i32.const 35977) (i32.const 56) (i32.const 519))
+    (memory.fill (i32.const 44892) (i32.const 57) (i32.const 3280))
+    (memory.fill (i32.const 46760) (i32.const 58) (i32.const 1678))
+    (memory.fill (i32.const 46607) (i32.const 59) (i32.const 3168))
+    (memory.fill (i32.const 22449) (i32.const 60) (i32.const 1441))
+    (memory.fill (i32.const 58609) (i32.const 61) (i32.const 663))
+    (memory.fill (i32.const 32261) (i32.const 62) (i32.const 1671))
+    (memory.fill (i32.const 3063) (i32.const 63) (i32.const 721))
+    (memory.fill (i32.const 34025) (i32.const 64) (i32.const 84))
+    (memory.fill (i32.const 33338) (i32.const 65) (i32.const 2029))
+    (memory.fill (i32.const 36810) (i32.const 66) (i32.const 29))
+    (memory.fill (i32.const 19147) (i32.const 67) (i32.const 3034))
+    (memory.fill (i32.const 12616) (i32.const 68) (i32.const 1043))
+    (memory.fill (i32.const 18276) (i32.const 69) (i32.const 3324))
+    (memory.fill (i32.const 4639) (i32.const 70) (i32.const 1091))
+    (memory.fill (i32.const 16158) (i32.const 71) (i32.const 1997))
+    (memory.fill (i32.const 18204) (i32.const 72) (i32.const 2259))
+    (memory.fill (i32.const 50532) (i32.const 73) (i32.const 3189))
+    (memory.fill (i32.const 11028) (i32.const 74) (i32.const 1968))
+    (memory.fill (i32.const 15962) (i32.const 75) (i32.const 1455))
+    (memory.fill (i32.const 45406) (i32.const 76) (i32.const 1177))
+    (memory.fill (i32.const 54137) (i32.const 77) (i32.const 1568))
+    (memory.fill (i32.const 33083) (i32.const 78) (i32.const 1642))
+    (memory.fill (i32.const 61028) (i32.const 79) (i32.const 3284))
+    (memory.fill (i32.const 51729) (i32.const 80) (i32.const 223))
+    (memory.fill (i32.const 4361) (i32.const 81) (i32.const 2171))
+    (memory.fill (i32.const 57514) (i32.const 82) (i32.const 1322))
+    (memory.fill (i32.const 55724) (i32.const 83) (i32.const 2648))
+    (memory.fill (i32.const 24091) (i32.const 84) (i32.const 1045))
+    (memory.fill (i32.const 43183) (i32.const 85) (i32.const 3097))
+    (memory.fill (i32.const 32307) (i32.const 86) (i32.const 2796))
+    (memory.fill (i32.const 3811) (i32.const 87) (i32.const 2010))
+    (memory.fill (i32.const 54856) (i32.const 88) (i32.const 0))
+    (memory.fill (i32.const 49941) (i32.const 89) (i32.const 2069))
+    (memory.fill (i32.const 20411) (i32.const 90) (i32.const 2896))
+    (memory.fill (i32.const 33826) (i32.const 91) (i32.const 192))
+    (memory.fill (i32.const 9402) (i32.const 92) (i32.const 2195))
+    (memory.fill (i32.const 12413) (i32.const 93) (i32.const 24))
+    (memory.fill (i32.const 14091) (i32.const 94) (i32.const 577))
+    (memory.fill (i32.const 44058) (i32.const 95) (i32.const 2089))
+    (memory.fill (i32.const 36735) (i32.const 96) (i32.const 3436))
+    (memory.fill (i32.const 23288) (i32.const 97) (i32.const 2765))
+    (memory.fill (i32.const 6392) (i32.const 98) (i32.const 830))
+    (memory.fill (i32.const 33307) (i32.const 99) (i32.const 1938))
+    (memory.fill (i32.const 21941) (i32.const 100) (i32.const 2750))
+    (memory.copy (i32.const 59214) (i32.const 54248) (i32.const 2098))
+    (memory.copy (i32.const 63026) (i32.const 39224) (i32.const 230))
+    (memory.copy (i32.const 51833) (i32.const 23629) (i32.const 2300))
+    (memory.copy (i32.const 6708) (i32.const 23996) (i32.const 639))
+    (memory.copy (i32.const 6990) (i32.const 33399) (i32.const 1097))
+    (memory.copy (i32.const 19403) (i32.const 10348) (i32.const 3197))
+    (memory.copy (i32.const 27308) (i32.const 54406) (i32.const 100))
+    (memory.copy (i32.const 27221) (i32.const 43682) (i32.const 1717))
+    (memory.copy (i32.const 60528) (i32.const 8629) (i32.const 119))
+    (memory.copy (i32.const 5947) (i32.const 2308) (i32.const 658))
+    (memory.copy (i32.const 4787) (i32.const 51631) (i32.const 2269))
+    (memory.copy (i32.const 12617) (i32.const 19197) (i32.const 833))
+    (memory.copy (i32.const 11854) (i32.const 46505) (i32.const 3300))
+    (memory.copy (i32.const 11376) (i32.const 45012) (i32.const 2281))
+    (memory.copy (i32.const 34186) (i32.const 6697) (i32.const 2572))
+    (memory.copy (i32.const 4936) (i32.const 1690) (i32.const 1328))
+    (memory.copy (i32.const 63164) (i32.const 7637) (i32.const 1670))
+    (memory.copy (i32.const 44568) (i32.const 18344) (i32.const 33))
+    (memory.copy (i32.const 43918) (i32.const 22348) (i32.const 1427))
+    (memory.copy (i32.const 46637) (i32.const 49819) (i32.const 1434))
+    (memory.copy (i32.const 63684) (i32.const 8755) (i32.const 834))
+    (memory.copy (i32.const 33485) (i32.const 20131) (i32.const 3317))
+    (memory.copy (i32.const 40575) (i32.const 54317) (i32.const 3201))
+    (memory.copy (i32.const 25812) (i32.const 59254) (i32.const 2452))
+    (memory.copy (i32.const 19678) (i32.const 56882) (i32.const 346))
+    (memory.copy (i32.const 15852) (i32.const 35914) (i32.const 2430))
+    (memory.copy (i32.const 11824) (i32.const 35574) (i32.const 300))
+    (memory.copy (i32.const 59427) (i32.const 13957) (i32.const 3153))
+    (memory.copy (i32.const 34299) (i32.const 60594) (i32.const 1281))
+    (memory.copy (i32.const 8964) (i32.const 12276) (i32.const 943))
+    (memory.copy (i32.const 2827) (i32.const 10425) (i32.const 1887))
+    (memory.copy (i32.const 43194) (i32.const 43910) (i32.const 738))
+    (memory.copy (i32.const 63038) (i32.const 18949) (i32.const 122))
+    (memory.copy (i32.const 24044) (i32.const 44761) (i32.const 1755))
+    (memory.copy (i32.const 22608) (i32.const 14755) (i32.const 702))
+    (memory.copy (i32.const 11284) (i32.const 26579) (i32.const 1830))
+    (memory.copy (i32.const 23092) (i32.const 20471) (i32.const 1064))
+    (memory.copy (i32.const 57248) (i32.const 54770) (i32.const 2631))
+    (memory.copy (i32.const 25492) (i32.const 1025) (i32.const 3113))
+    (memory.copy (i32.const 49588) (i32.const 44220) (i32.const 975))
+    (memory.copy (i32.const 28280) (i32.const 41722) (i32.const 2336))
+    (memory.copy (i32.const 61289) (i32.const 230) (i32.const 2872))
+    (memory.copy (i32.const 22480) (i32.const 52506) (i32.const 2197))
+    (memory.copy (i32.const 40553) (i32.const 9578) (i32.const 1958))
+    (memory.copy (i32.const 29004) (i32.const 20862) (i32.const 2186))
+    (memory.copy (i32.const 53029) (i32.const 43955) (i32.const 1037))
+    (memory.copy (i32.const 25476) (i32.const 35667) (i32.const 1650))
+    (memory.copy (i32.const 58516) (i32.const 45819) (i32.const 1986))
+    (memory.copy (i32.const 38297) (i32.const 5776) (i32.const 1955))
+    (memory.copy (i32.const 28503) (i32.const 55364) (i32.const 2368))
+    (memory.copy (i32.const 62619) (i32.const 18108) (i32.const 1356))
+    (memory.copy (i32.const 50149) (i32.const 13861) (i32.const 382))
+    (memory.copy (i32.const 16904) (i32.const 36341) (i32.const 1900))
+    (memory.copy (i32.const 48098) (i32.const 11358) (i32.const 2807))
+    (memory.copy (i32.const 28512) (i32.const 40362) (i32.const 323))
+    (memory.copy (i32.const 35506) (i32.const 27856) (i32.const 1670))
+    (memory.copy (i32.const 62970) (i32.const 53332) (i32.const 1341))
+    (memory.copy (i32.const 14133) (i32.const 46312) (i32.const 644))
+    (memory.copy (i32.const 29030) (i32.const 19074) (i32.const 496))
+    (memory.copy (i32.const 44952) (i32.const 47577) (i32.const 2784))
+    (memory.copy (i32.const 39559) (i32.const 44661) (i32.const 1350))
+    (memory.copy (i32.const 10352) (i32.const 29274) (i32.const 1475))
+    (memory.copy (i32.const 46911) (i32.const 46178) (i32.const 1467))
+    (memory.copy (i32.const 4905) (i32.const 28740) (i32.const 1895))
+    (memory.copy (i32.const 38012) (i32.const 57253) (i32.const 1751))
+    (memory.copy (i32.const 26446) (i32.const 27223) (i32.const 1127))
+    (memory.copy (i32.const 58835) (i32.const 24657) (i32.const 1063))
+    (memory.copy (i32.const 61356) (i32.const 38790) (i32.const 766))
+    (memory.copy (i32.const 44160) (i32.const 2284) (i32.const 1520))
+    (memory.copy (i32.const 32740) (i32.const 47237) (i32.const 3014))
+    (memory.copy (i32.const 11148) (i32.const 21260) (i32.const 1011))
+    (memory.copy (i32.const 7665) (i32.const 31612) (i32.const 3034))
+    (memory.copy (i32.const 18044) (i32.const 12987) (i32.const 3320))
+    (memory.copy (i32.const 57306) (i32.const 55905) (i32.const 308))
+    (memory.copy (i32.const 24675) (i32.const 16815) (i32.const 1155))
+    (memory.copy (i32.const 19900) (i32.const 10115) (i32.const 722))
+    (memory.copy (i32.const 2921) (i32.const 5935) (i32.const 2370))
+    (memory.copy (i32.const 32255) (i32.const 50095) (i32.const 2926))
+    (memory.copy (i32.const 15126) (i32.const 17299) (i32.const 2607))
+    (memory.copy (i32.const 45575) (i32.const 28447) (i32.const 2045))
+    (memory.copy (i32.const 55149) (i32.const 36113) (i32.const 2596))
+    (memory.copy (i32.const 28461) (i32.const 54157) (i32.const 1168))
+    (memory.copy (i32.const 47951) (i32.const 53385) (i32.const 3137))
+    (memory.copy (i32.const 30646) (i32.const 45155) (i32.const 2649))
+    (memory.copy (i32.const 5057) (i32.const 4295) (i32.const 52))
+    (memory.copy (i32.const 6692) (i32.const 24195) (i32.const 441))
+    (memory.copy (i32.const 32984) (i32.const 27117) (i32.const 3445))
+    (memory.copy (i32.const 32530) (i32.const 59372) (i32.const 2785))
+    (memory.copy (i32.const 34361) (i32.const 8962) (i32.const 2406))
+    (memory.copy (i32.const 17893) (i32.const 54538) (i32.const 3381))
+    (memory.copy (i32.const 22685) (i32.const 44151) (i32.const 136))
+    (memory.copy (i32.const 59089) (i32.const 7077) (i32.const 1045))
+    (memory.copy (i32.const 42945) (i32.const 55028) (i32.const 2389))
+    (memory.copy (i32.const 44693) (i32.const 20138) (i32.const 877))
+    (memory.copy (i32.const 36810) (i32.const 25196) (i32.const 3447))
+    (memory.copy (i32.const 45742) (i32.const 31888) (i32.const 854))
+    (memory.copy (i32.const 24236) (i32.const 31866) (i32.const 1377))
+    (memory.copy (i32.const 33778) (i32.const 692) (i32.const 1594))
+    (memory.copy (i32.const 60618) (i32.const 18585) (i32.const 2987))
+    (memory.copy (i32.const 50370) (i32.const 41271) (i32.const 1406))
+  )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+)
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 124) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 124) (i32.const 1517) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1517) (i32.const 2132) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2132) (i32.const 2827) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2827) (i32.const 2921) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 2921) (i32.const 3538) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3538) (i32.const 3786) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 3786) (i32.const 4042) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4042) (i32.const 4651) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 4651) (i32.const 5057) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5057) (i32.const 5109) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5109) (i32.const 5291) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5291) (i32.const 5524) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5524) (i32.const 5691) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 5691) (i32.const 6552) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 6552) (i32.const 7133) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7133) (i32.const 7665) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 7665) (i32.const 8314) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8314) (i32.const 8360) (i32.const 62))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8360) (i32.const 8793) (i32.const 86))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8793) (i32.const 8979) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 8979) (i32.const 9373) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9373) (i32.const 9518) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9518) (i32.const 9934) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 9934) (i32.const 10087) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10087) (i32.const 10206) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10206) (i32.const 10230) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10230) (i32.const 10249) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 10249) (i32.const 11148) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11148) (i32.const 11356) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11356) (i32.const 11380) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11380) (i32.const 11939) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 11939) (i32.const 12159) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12159) (i32.const 12575) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12575) (i32.const 12969) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 12969) (i32.const 13114) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 13114) (i32.const 14133) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14133) (i32.const 14404) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14404) (i32.const 14428) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14428) (i32.const 14458) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14458) (i32.const 14580) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14580) (i32.const 14777) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 14777) (i32.const 15124) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15124) (i32.const 15126) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15126) (i32.const 15192) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15192) (i32.const 15871) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15871) (i32.const 15998) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 15998) (i32.const 17017) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17017) (i32.const 17288) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17288) (i32.const 17312) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17312) (i32.const 17342) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17342) (i32.const 17464) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17464) (i32.const 17661) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17661) (i32.const 17727) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17727) (i32.const 17733) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17733) (i32.const 17893) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 17893) (i32.const 18553) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18553) (i32.const 18744) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18744) (i32.const 18801) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18801) (i32.const 18825) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18825) (i32.const 18876) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18876) (i32.const 18885) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18885) (i32.const 18904) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18904) (i32.const 19567) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 19567) (i32.const 20403) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 20403) (i32.const 21274) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21274) (i32.const 21364) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21364) (i32.const 21468) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21468) (i32.const 21492) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21492) (i32.const 22051) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22051) (i32.const 22480) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22480) (i32.const 22685) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22685) (i32.const 22694) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22694) (i32.const 22821) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22821) (i32.const 22869) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 22869) (i32.const 24107) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24107) (i32.const 24111) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24111) (i32.const 24236) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24236) (i32.const 24348) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24348) (i32.const 24515) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24515) (i32.const 24900) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 24900) (i32.const 25136) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25136) (i32.const 25182) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25182) (i32.const 25426) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25426) (i32.const 25613) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25613) (i32.const 25830) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25830) (i32.const 26446) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26446) (i32.const 26517) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 26517) (i32.const 27468) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27468) (i32.const 27503) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27503) (i32.const 27573) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 27573) (i32.const 28245) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28245) (i32.const 28280) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28280) (i32.const 29502) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29502) (i32.const 29629) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 29629) (i32.const 30387) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30387) (i32.const 30646) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 30646) (i32.const 31066) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31066) (i32.const 31131) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31131) (i32.const 31322) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31322) (i32.const 31379) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31379) (i32.const 31403) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31403) (i32.const 31454) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31454) (i32.const 31463) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31463) (i32.const 31482) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31482) (i32.const 31649) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31649) (i32.const 31978) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 31978) (i32.const 32145) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32145) (i32.const 32530) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32530) (i32.const 32766) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32766) (i32.const 32812) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 32812) (i32.const 33056) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33056) (i32.const 33660) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33660) (i32.const 33752) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33752) (i32.const 33775) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33775) (i32.const 33778) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 33778) (i32.const 34603) (i32.const 9))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 34603) (i32.const 35218) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35218) (i32.const 35372) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35372) (i32.const 35486) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35486) (i32.const 35605) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35605) (i32.const 35629) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35629) (i32.const 35648) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 35648) (i32.const 36547) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36547) (i32.const 36755) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36755) (i32.const 36767) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36767) (i32.const 36810) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36810) (i32.const 36839) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 36839) (i32.const 37444) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 37444) (i32.const 38060) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38060) (i32.const 38131) (i32.const 10))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 38131) (i32.const 39082) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39082) (i32.const 39117) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39117) (i32.const 39187) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39187) (i32.const 39859) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39859) (i32.const 39894) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 39894) (i32.const 40257) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40257) (i32.const 40344) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40344) (i32.const 40371) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40371) (i32.const 40804) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40804) (i32.const 40909) (i32.const 5))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 40909) (i32.const 42259) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42259) (i32.const 42511) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42511) (i32.const 42945) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 42945) (i32.const 43115) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43115) (i32.const 43306) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43306) (i32.const 43363) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43363) (i32.const 43387) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43387) (i32.const 43438) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43438) (i32.const 43447) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43447) (i32.const 43466) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 43466) (i32.const 44129) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44129) (i32.const 44958) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 44958) (i32.const 45570) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45570) (i32.const 45575) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45575) (i32.const 45640) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45640) (i32.const 45742) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45742) (i32.const 45832) (i32.const 72))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45832) (i32.const 45999) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 45999) (i32.const 46384) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46384) (i32.const 46596) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46596) (i32.const 46654) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 46654) (i32.const 47515) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47515) (i32.const 47620) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47620) (i32.const 47817) (i32.const 79))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47817) (i32.const 47951) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 47951) (i32.const 48632) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48632) (i32.const 48699) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48699) (i32.const 48703) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 48703) (i32.const 49764) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49764) (i32.const 49955) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 49955) (i32.const 50012) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50012) (i32.const 50036) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50036) (i32.const 50087) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50087) (i32.const 50096) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50096) (i32.const 50115) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50115) (i32.const 50370) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 50370) (i32.const 51358) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51358) (i32.const 51610) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51610) (i32.const 51776) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51776) (i32.const 51833) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 51833) (i32.const 52895) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 52895) (i32.const 53029) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53029) (i32.const 53244) (i32.const 68))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 53244) (i32.const 54066) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54066) (i32.const 54133) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54133) (i32.const 54137) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 54137) (i32.const 55198) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55198) (i32.const 55389) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55389) (i32.const 55446) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55446) (i32.const 55470) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55470) (i32.const 55521) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55521) (i32.const 55530) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55530) (i32.const 55549) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 55549) (i32.const 56212) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 56212) (i32.const 57048) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 57048) (i32.const 58183) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58183) (i32.const 58202) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58202) (i32.const 58516) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58516) (i32.const 58835) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58835) (i32.const 58855) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 58855) (i32.const 59089) (i32.const 95))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59089) (i32.const 59145) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59145) (i32.const 59677) (i32.const 99))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 59677) (i32.const 60134) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60134) (i32.const 60502) (i32.const 89))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60502) (i32.const 60594) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60594) (i32.const 60617) (i32.const 36))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60617) (i32.const 60618) (i32.const 32))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60618) (i32.const 60777) (i32.const 42))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60777) (i32.const 60834) (i32.const 76))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60834) (i32.const 60858) (i32.const 57))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60858) (i32.const 60909) (i32.const 59))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60909) (i32.const 60918) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60918) (i32.const 60937) (i32.const 41))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 60937) (i32.const 61600) (i32.const 83))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 61600) (i32.const 62436) (i32.const 96))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 62436) (i32.const 63307) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63307) (i32.const 63397) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63397) (i32.const 63501) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63501) (i32.const 63525) (i32.const 93))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63525) (i32.const 63605) (i32.const 74))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63605) (i32.const 63704) (i32.const 100))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63704) (i32.const 63771) (i32.const 97))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63771) (i32.const 63775) (i32.const 37))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 63775) (i32.const 64311) (i32.const 77))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64311) (i32.const 64331) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64331) (i32.const 64518) (i32.const 92))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64518) (i32.const 64827) (i32.const 11))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64827) (i32.const 64834) (i32.const 26))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 64834) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_fill.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_fill.wast
new file mode 100644
index 0000000..caca80b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_fill.wast
@@ -0,0 +1,685 @@
+;;
+;; Generated by ../meta/generate_memory_fill.js
+;;
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 256))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65280) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65280) (i32.const 65536) (i32.const 85))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0xFFFFFF00) (i32.const 0x55) (i32.const 257))))
+(assert_trap (invoke "test") "out of bounds memory access")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x10000) (i32.const 0x55) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x20000) (i32.const 0x55) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+    (memory.fill (i32.const 0x1) (i32.const 0xAA) (i32.const 0xFFFE))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 1) (i32.const 65535) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 65535) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+
+(module
+  (memory 1 1)
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "test")
+     (memory.fill (i32.const 0x12) (i32.const 0x55) (i32.const 10))
+     (memory.fill (i32.const 0x15) (i32.const 0xAA) (i32.const 4))))
+(invoke "test")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 18) (i32.const 0))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 18) (i32.const 21) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 21) (i32.const 25) (i32.const 170))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 25) (i32.const 28) (i32.const 85))
+               (i32.const -1))
+(assert_return (invoke "checkRange" (i32.const 28) (i32.const 65536) (i32.const 0))
+               (i32.const -1))
+(assert_invalid
+  (module
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i32.const 30))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f32.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (i64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f32.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (i64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f32.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (i64.const 30))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1 1)
+    (func (export "testfn")
+      (memory.fill (f64.const 10) (f64.const 20) (f64.const 30))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65280) (i32.const 37) (i32.const 512))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 514))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $val i32) (param $len i32)
+    (memory.fill (local.get $offs) (local.get $val) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65279) (i32.const 37) (i32.const 4294967295))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_grow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_grow.wast
new file mode 100644
index 0000000..aa56297
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_grow.wast
@@ -0,0 +1,379 @@
+(module
+    (memory 0)
+
+    (func (export "load_at_zero") (result i32) (i32.load (i32.const 0)))
+    (func (export "store_at_zero") (i32.store (i32.const 0) (i32.const 2)))
+
+    (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
+    (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
+
+    (func (export "grow") (param $sz i32) (result i32) (memory.grow (local.get $sz)))
+    (func (export "size") (result i32) (memory.size))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "store_at_zero") "out of bounds memory access")
+(assert_trap (invoke "load_at_zero") "out of bounds memory access")
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "load_at_zero") (i32.const 0))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_trap (invoke "store_at_page_size") "out of bounds memory access")
+(assert_trap (invoke "load_at_page_size") "out of bounds memory access")
+(assert_return (invoke "grow" (i32.const 4)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "store_at_zero"))
+(assert_return (invoke "load_at_zero") (i32.const 2))
+(assert_return (invoke "load_at_page_size") (i32.const 0))
+(assert_return (invoke "store_at_page_size"))
+(assert_return (invoke "load_at_page_size") (i32.const 3))
+
+
+(module
+  (memory 0)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 64736)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 803))
+
+(module
+  (memory 0 10)
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+;; Test that newly allocated memory (program start and memory.grow) is zeroed
+
+(module
+  (memory 1)
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+  (func (export "check-memory-zero") (param i32 i32) (result i32)
+    (local i32)
+    (local.set 2 (i32.const 1))
+    (block
+      (loop
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-memory-zero" (i32.const 0) (i32.const 0xffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "check-memory-zero" (i32.const 0x10000) (i32.const 0x1_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "check-memory-zero" (i32.const 0x20000) (i32.const 0x2_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "check-memory-zero" (i32.const 0x30000) (i32.const 0x3_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 5))
+(assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0))
+
+;; As the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (memory.grow (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (memory.grow (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (memory.grow (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (memory.grow (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0))
+    )
+  )
+
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (memory.grow (i32.const 0)))
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (memory.grow (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (memory.grow (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (memory.grow (i32.const 0)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 6))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 1))
+
+(assert_return (invoke "as-if-cond") (i32.const 0))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 1))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-cond") (i32.const 0))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_trap (invoke "as-call_indirect-index") "undefined element")
+
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 31))
+
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+
+(assert_return (invoke "as-test-operand") (i32.const 0))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32 (result i32)
+      (memory.grow)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-block (result i32)
+      (i32.const 0)
+      (block (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-loop (result i32)
+      (i32.const 0)
+      (loop (result i32) (memory.grow))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-size-empty-vs-i32-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (memory.grow)))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-size-f32-vs-i32 (result i32)
+      (memory.grow (f32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-empty
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-result-i32-vs-f32 (result f32)
+      (memory.grow (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_init.wast
new file mode 100644
index 0000000..c647079
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/memory_init.wast
@@ -0,0 +1,951 @@
+;;
+;; Generated by ../meta/generate_memory_init.js
+;;
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (nop))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 6))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+
+(module
+  (memory (export "memory0") 1 1)
+  (data (i32.const 2) "\03\01\04\01")
+  (data "\02\07\01\08")
+  (data (i32.const 12) "\07\05\02\03\06")
+  (data "\05\09\02\07\06")
+  (func (export "test")
+    (memory.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (data.drop 1)
+    (memory.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (data.drop 3)
+    (memory.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (memory.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (memory.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (memory.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (memory.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "load8_u") (param i32) (result i32)
+    (i32.load8_u (local.get 0))))
+
+(invoke "test")
+
+(assert_return (invoke "load8_u" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "load8_u" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "load8_u" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 6)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "load8_u" (i32.const 10)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 13)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "load8_u" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "load8_u" (i32.const 17)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 18)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 19)) (i32.const 9))
+(assert_return (invoke "load8_u" (i32.const 20)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 21)) (i32.const 7))
+(assert_return (invoke "load8_u" (i32.const 22)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 24)) (i32.const 8))
+(assert_return (invoke "load8_u" (i32.const 25)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 26)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 27)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 28)) (i32.const 0))
+(assert_return (invoke "load8_u" (i32.const 29)) (i32.const 0))
+(assert_invalid
+   (module
+     (func (export "test")
+       (data.drop 0)))
+   "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (data.drop 4)))
+  "unknown data segment")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (data.drop 0)))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (data.drop 0)
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+   (memory 1)
+   (data (i32.const 0) "\37")
+   (func (export "test")
+     (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown memory 0")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 1 (i32.const 1234) (i32.const 1) (i32.const 1))))
+  "unknown data segment 1")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))
+    (memory.init 0 (i32.const 1) (i32.const 0) (i32.const 1))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 0) (i32.const 5))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 2) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0xFFFE) (i32.const 1) (i32.const 3))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 1234) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 0) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 0) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10000) (i32.const 1) (i32.const 0))))
+(invoke "test")
+
+(module
+  (memory 1)
+    (data "\37")
+  (func (export "test")
+    (memory.init 0 (i32.const 0x10001) (i32.const 4) (i32.const 0))))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data "\37")
+    (func (export "test")
+      (memory.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 16))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65527) (i32.const 16))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65472) (i32.const 30))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1 1 )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65473) (i32.const 31))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 65528) (i32.const 4294967040))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
+(module
+  (memory 1  )
+  (data "\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42\42")
+   
+  (func (export "checkRange") (param $from i32) (param $to i32) (param $expected i32) (result i32)
+    (loop $cont
+      (if (i32.eq (local.get $from) (local.get $to))
+        (then
+          (return (i32.const -1))))
+      (if (i32.eq (i32.load8_u (local.get $from)) (local.get $expected))
+        (then
+          (local.set $from (i32.add (local.get $from) (i32.const 1)))
+          (br $cont))))
+    (return (local.get $from)))
+
+  (func (export "run") (param $offs i32) (param $len i32)
+    (memory.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292))
+              "out of bounds")
+
+(assert_return (invoke "checkRange" (i32.const 0) (i32.const 1) (i32.const 0))
+               (i32.const -1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_func.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_func.wast
new file mode 100644
index 0000000..e9033a3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_func.wast
@@ -0,0 +1,86 @@
+(module
+  (func (export "f") (param $x i32) (result i32) (local.get $x))
+)
+(register "M")
+
+(module
+  (func $f (import "M" "f") (param i32) (result i32))
+  (func $g (param $x i32) (result i32)
+    (i32.add (local.get $x) (i32.const 1))
+  )
+
+  (global anyref (ref.func $f))
+  (global anyref (ref.func $g))
+  (global funcref (ref.func $f))
+  (global funcref (ref.func $g))
+  (global $v (mut funcref) (ref.func $f))
+
+  (global funcref (ref.func $gf1))
+  (global funcref (ref.func $gf2))
+  (func (drop (ref.func $ff1)) (drop (ref.func $ff2)))
+  (elem declare func $gf1 $ff1)
+  (elem declare funcref (ref.func $gf2) (ref.func $ff2))
+  (func $gf1)
+  (func $gf2)
+  (func $ff1)
+  (func $ff2)
+
+  (func (export "is_null-f") (result i32)
+    (ref.is_null (ref.func $f))
+  )
+  (func (export "is_null-g") (result i32)
+    (ref.is_null (ref.func $g))
+  )
+  (func (export "is_null-v") (result i32)
+    (ref.is_null (global.get $v))
+  )
+
+  (func (export "set-f") (global.set $v (ref.func $f)))
+  (func (export "set-g") (global.set $v (ref.func $g)))
+
+  (table $t 1 funcref)
+  (elem declare func $f $g)
+
+  (func (export "call-f") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (ref.func $f))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+  (func (export "call-g") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (ref.func $g))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+  (func (export "call-v") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (global.get $v))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+)
+
+(assert_return (invoke "is_null-f") (i32.const 0))
+(assert_return (invoke "is_null-g") (i32.const 0))
+(assert_return (invoke "is_null-v") (i32.const 0))
+
+(assert_return (invoke "call-f" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "call-g" (i32.const 4)) (i32.const 5))
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4))
+(invoke "set-g")
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 5))
+(invoke "set-f")
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4))
+
+(assert_invalid
+  (module
+    (func $f (import "M" "f") (param i32) (result i32))
+    (func $g (import "M" "g") (param i32) (result i32))
+    (global funcref (ref.func 7))
+  )
+  "unknown function 7"
+)
+
+(assert_invalid
+  (module (func $f) (global funcref (ref.func $f)))
+  "undeclared function reference"
+)
+(assert_invalid
+  (module (func $f (drop (ref.func $f))))
+  "undeclared function reference"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_is_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_is_null.wast
new file mode 100644
index 0000000..7a42ca7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_is_null.wast
@@ -0,0 +1,62 @@
+(module
+  (func $f1 (export "nullref") (param $x nullref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f2 (export "anyref") (param $x anyref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f3 (export "funcref") (param $x funcref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+
+  (table $t1 2 nullref)
+  (table $t2 2 anyref)
+  (table $t3 2 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "init") (param $r anyref)
+    (table.set $t2 (i32.const 1) (local.get $r))
+  )
+  (func (export "deinit")
+    (table.set $t1 (i32.const 1) (ref.null))
+    (table.set $t2 (i32.const 1) (ref.null))
+    (table.set $t3 (i32.const 1) (ref.null))
+  )
+
+  (func (export "nullref-elem") (param $x i32) (result i32)
+    (call $f1 (table.get $t1 (local.get $x)))
+  )
+  (func (export "anyref-elem") (param $x i32) (result i32)
+    (call $f2 (table.get $t2 (local.get $x)))
+  )
+  (func (export "funcref-elem") (param $x i32) (result i32)
+    (call $f3 (table.get $t3 (local.get $x)))
+  )
+)
+
+(assert_return (invoke "nullref" (ref.null)) (i32.const 1))
+(assert_return (invoke "anyref" (ref.null)) (i32.const 1))
+(assert_return (invoke "funcref" (ref.null)) (i32.const 1))
+
+(assert_return (invoke "anyref" (ref.host 1)) (i32.const 0))
+
+(invoke "init" (ref.host 0))
+
+(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "anyref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "nullref-elem" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "anyref-elem" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0))
+
+(invoke "deinit")
+
+(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "anyref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "nullref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "anyref-elem" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_null.wast
new file mode 100644
index 0000000..96cac31
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/ref_null.wast
@@ -0,0 +1,13 @@
+(module
+  (func (export "anyref") (result anyref) (ref.null))
+  (func (export "funcref") (result funcref) (ref.null))
+  (func (export "nullref") (result nullref) (ref.null))
+
+  (global anyref (ref.null))
+  (global funcref (ref.null))
+  (global nullref (ref.null))
+)
+
+(assert_return (invoke "anyref") (ref.null))
+(assert_return (invoke "funcref") (ref.null))
+(assert_return (invoke "nullref") (ref.null))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/select.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/select.wast
new file mode 100644
index 0000000..267dd57
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/select.wast
@@ -0,0 +1,529 @@
+(module
+  ;; Auxiliary
+  (func $dummy)
+  (table $tab funcref (elem $dummy))
+  (memory 1)
+
+  (func (export "select-i32") (param i32 i32 i32) (result i32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64") (param i64 i64 i32) (result i64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32") (param f32 f32 i32) (result f32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64") (param f64 f64 i32) (result f64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "select-i32-t") (param i32 i32 i32) (result i32)
+    (select (result i32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64-t") (param i64 i64 i32) (result i64)
+    (select (result i64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32-t") (param f32 f32 i32) (result f32)
+    (select (result f32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64-t") (param f64 f64 i32) (result f64)
+    (select (result f64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-nullref") (param nullref nullref i32) (result nullref)
+    (select (result nullref) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-funcref") (param funcref funcref i32) (result funcref)
+    (select (result funcref) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-anyref") (param anyref anyref i32) (result anyref)
+    (select (result anyref) (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "join-nullref") (param i32) (result anyref)
+    (select (result nullref) (ref.null) (ref.null) (local.get 0))
+  )
+  (func (export "join-funcref") (param i32) (result anyref)
+    (select (result funcref)
+      (table.get $tab (i32.const 0))
+      (ref.null)
+      (local.get 0)
+    )
+  )
+  (func (export "join-anyref") (param i32) (param anyref) (result anyref)
+    (select (result anyref)
+      (table.get $tab (i32.const 0))
+      (local.get 1)
+      (local.get 0)
+    )
+  )
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+
+  ;; As the argument of control constructs and instructions
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)))
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (select (i32.const 2) (i32.const 3) (local.get 0)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (local.get 0))) (else (i32.const 4)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 4)))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table $t funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 1) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (select (i32.const 1) (i32.const 2) (local.get 0)) (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (local.get 0))))
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32) (local.set 0 (select (i32.const 1) (i32.const 2) (local.get 0))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a (select (i32.const 1) (i32.const 2) (local.get 0)))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load (select (i32.const 0) (i32.const 4) (local.get 0)))
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+  (func (export "as-binary-operand") (param i32) (result i32)
+    (i32.mul
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (block (result i32)
+      (i32.le_s (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (block (result i32)
+      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
+    )
+  )
+)
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+(assert_return (invoke "select-nullref" (ref.null) (ref.null) (i32.const 1)) (ref.null))
+(assert_return (invoke "select-funcref" (ref.null) (ref.null) (i32.const 1)) (ref.null))
+(assert_return (invoke "select-anyref" (ref.host 1) (ref.host 2) (i32.const 1)) (ref.host 1))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32-t" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+(assert_return (invoke "select-anyref" (ref.host 1) (ref.host 2) (i32.const 0)) (ref.host 2))
+(assert_return (invoke "select-anyref" (ref.host 2) (ref.host 1) (i32.const 0)) (ref.host 1))
+
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_return (invoke "join-nullref" (i32.const 1)) (ref.null))
+(assert_return (invoke "join-nullref" (i32.const 0)) (ref.null))
+
+(assert_return (invoke "join-funcref" (i32.const 1)) (ref.func))
+(assert_return (invoke "join-funcref" (i32.const 0)) (ref.null))
+
+(assert_return (invoke "join-anyref" (i32.const 1) (ref.host 1)) (ref.func))
+(assert_return (invoke "join-anyref" (i32.const 0) (ref.host 1)) (ref.host 1))
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)))
+(assert_return (invoke "as-if-condition" (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
+;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-left" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-convert-operand" (i32.const 1)) (i32.const 1))
+
+(assert_invalid
+  (module (func $arity-0-implicit (select (nop) (nop) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $arity-0 (select (result) (nop) (nop) (i32.const 1))))
+  "invalid result arity"
+)
+(assert_invalid
+  (module (func $arity-2 (result i32 i32)
+    (select (result i32 i32)
+      (i32.const 0) (i32.const 0)
+      (i32.const 0) (i32.const 0)
+      (i32.const 1)
+    )
+  ))
+  "invalid result arity"
+)
+
+
+(assert_invalid
+  (module (func $type-nullref-implicit
+    (drop (select (ref.null) (ref.null) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-anyref-implicit (param $r anyref)
+    (drop (select (local.get $r) (local.get $r) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (i64.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f32.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f64.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty
+      (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty
+      (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty
+      (i32.const 0) (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (block (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (loop (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-then
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (then (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-then
+      (i32.const 0)
+      (if (then (i32.const 0) (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table-sub.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table-sub.wast
new file mode 100644
index 0000000..66f1831
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table-sub.wast
@@ -0,0 +1,31 @@
+(module
+  (table $t1 10 anyref)
+  (table $t2 10 funcref)
+  (elem $el funcref)
+  (func $f
+    (table.init $t1 $el (i32.const 0) (i32.const 1) (i32.const 2))
+    (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2))
+  )
+)
+
+(assert_invalid
+  (module
+    (table $t1 10 funcref)
+    (table $t2 10 anyref)
+    (func $f
+      (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 funcref)
+    (elem $el anyref)
+    (func $f
+      (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_copy.wast
new file mode 100644
index 0000000..d0aa77b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_copy.wast
@@ -0,0 +1,1595 @@
+;;
+;; Generated by ../meta/generate_table_copy.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 27)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 18)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 6))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 25) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 15) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 15) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 15) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 30) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy (i32.const 31) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 23)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 8))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 11)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 16)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 17)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 18)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 10))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 112)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264))
+             "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 112)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 113)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 114)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 115)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 116)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 117)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 118)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 119)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 120)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 121)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 122)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 123)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 124)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 125)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 126)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 127)) (i32.const 15))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264))
+             "out of bounds")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 15))
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_fill.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_fill.wast
new file mode 100644
index 0000000..7aff202
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_fill.wast
@@ -0,0 +1,153 @@
+(module
+  (table $t 10 anyref)
+
+  (func (export "fill") (param $i i32) (param $r anyref) (param $n i32)
+    (table.fill $t (local.get $i) (local.get $r) (local.get $n))
+  )
+
+  (func (export "get") (param $i i32) (result anyref)
+    (table.get $t (local.get $i))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 1)) (ref.null))
+(assert_return (invoke "get" (i32.const 2)) (ref.null))
+(assert_return (invoke "get" (i32.const 3)) (ref.null))
+(assert_return (invoke "get" (i32.const 4)) (ref.null))
+(assert_return (invoke "get" (i32.const 5)) (ref.null))
+
+(assert_return (invoke "fill" (i32.const 2) (ref.host 1) (i32.const 3)))
+(assert_return (invoke "get" (i32.const 1)) (ref.null))
+(assert_return (invoke "get" (i32.const 2)) (ref.host 1))
+(assert_return (invoke "get" (i32.const 3)) (ref.host 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.host 1))
+(assert_return (invoke "get" (i32.const 5)) (ref.null))
+
+(assert_return (invoke "fill" (i32.const 4) (ref.host 2) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 3)) (ref.host 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.host 2))
+(assert_return (invoke "get" (i32.const 5)) (ref.host 2))
+(assert_return (invoke "get" (i32.const 6)) (ref.null))
+
+(assert_return (invoke "fill" (i32.const 4) (ref.host 3) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 3)) (ref.host 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.host 2))
+(assert_return (invoke "get" (i32.const 5)) (ref.host 2))
+
+(assert_return (invoke "fill" (i32.const 8) (ref.host 4) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 7)) (ref.null))
+(assert_return (invoke "get" (i32.const 8)) (ref.host 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.host 4))
+
+(assert_return (invoke "fill" (i32.const 9) (ref.null) (i32.const 1)))
+(assert_return (invoke "get" (i32.const 8)) (ref.host 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.null))
+
+(assert_return (invoke "fill" (i32.const 10) (ref.host 5) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 9)) (ref.null))
+
+(assert_trap
+  (invoke "fill" (i32.const 8) (ref.host 6) (i32.const 3))
+  "out of bounds"
+)
+(assert_return (invoke "get" (i32.const 7)) (ref.null))
+(assert_return (invoke "get" (i32.const 8)) (ref.host 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.null))
+
+(assert_trap
+  (invoke "fill" (i32.const 11) (ref.null) (i32.const 0))
+  "out of bounds"
+)
+
+(assert_trap
+  (invoke "fill" (i32.const 11) (ref.null) (i32.const 10))
+  "out of bounds"
+)
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-value-length-empty-vs-i32-i32
+      (table.fill $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-empty-vs-i32
+      (table.fill $t (ref.null) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-value-empty-vs
+      (table.fill $t (i32.const 1) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-length-empty-vs-i32
+      (table.fill $t (i32.const 1) (ref.null))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-index-f32-vs-i32
+      (table.fill $t (f32.const 1) (ref.null) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 funcref)
+    (func $type-value-vs-funcref (param $r anyref)
+      (table.fill $t (i32.const 1) (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-length-f32-vs-i32
+      (table.fill $t (i32.const 1) (ref.null) (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 anyref)
+    (table $t2 1 funcref)
+    (func $type-value-anyref-vs-funcref-multi (param $r anyref)
+      (table.fill $t2 (i32.const 0) (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 anyref)
+    (func $type-result-empty-vs-num (result i32)
+      (table.fill $t (i32.const 0) (ref.null) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_get.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_get.wast
new file mode 100644
index 0000000..c95fce7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_get.wast
@@ -0,0 +1,88 @@
+(module
+  (table $t2 2 anyref)
+  (table $t3 3 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "init") (param $r anyref)
+    (table.set $t2 (i32.const 1) (local.get $r))
+    (table.set $t3 (i32.const 2) (table.get $t3 (i32.const 1)))
+  )
+
+  (func (export "get-anyref") (param $i i32) (result anyref)
+    (table.get $t2 (local.get $i))
+  )
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+
+  (func (export "is_null-funcref") (param $i i32) (result i32)
+    (ref.is_null (call $f3 (local.get $i)))
+  )
+)
+
+(invoke "init" (ref.host 1))
+
+(assert_return (invoke "get-anyref" (i32.const 0)) (ref.null))
+(assert_return (invoke "get-anyref" (i32.const 1)) (ref.host 1))
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null))
+(assert_return (invoke "is_null-funcref" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "is_null-funcref" (i32.const 2)) (i32.const 0))
+
+(assert_trap (invoke "get-anyref" (i32.const 2)) "out of bounds")
+(assert_trap (invoke "get-funcref" (i32.const 3)) "out of bounds")
+(assert_trap (invoke "get-anyref" (i32.const -1)) "out of bounds")
+(assert_trap (invoke "get-funcref" (i32.const -1)) "out of bounds")
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-empty-vs-i32 (result anyref)
+      (table.get $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-f32-vs-i32 (result anyref)
+      (table.get $t (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-result-anyref-vs-empty
+      (table.get $t (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-result-anyref-vs-funcref (result funcref)
+      (table.get $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 funcref)
+    (table $t2 1 anyref)
+    (func $type-result-anyref-vs-funcref-multi (result funcref)
+      (table.get $t2 (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_grow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_grow.wast
new file mode 100644
index 0000000..91fc096
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_grow.wast
@@ -0,0 +1,173 @@
+(module
+  (table $t 0 anyref)
+
+  (func (export "get") (param $i i32) (result anyref) (table.get $t (local.get $i)))
+  (func (export "set") (param $i i32) (param $r anyref) (table.set $t (local.get $i) (local.get $r)))
+
+  (func (export "grow") (param $sz i32) (param $init anyref) (result i32)
+    (table.grow $t (local.get $init) (local.get $sz))
+  )
+  (func (export "size") (result i32) (table.size $t))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "set" (i32.const 0) (ref.host 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 0)) "out of bounds table access")
+
+(assert_return (invoke "grow" (i32.const 1) (ref.null)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "get" (i32.const 0)) (ref.null))
+(assert_return (invoke "set" (i32.const 0) (ref.host 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.host 2))
+(assert_trap (invoke "set" (i32.const 1) (ref.host 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 1)) "out of bounds table access")
+
+(assert_return (invoke "grow" (i32.const 4) (ref.host 3)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 0)) (ref.host 2))
+(assert_return (invoke "set" (i32.const 0) (ref.host 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.host 2))
+(assert_return (invoke "get" (i32.const 1)) (ref.host 3))
+(assert_return (invoke "get" (i32.const 4)) (ref.host 3))
+(assert_return (invoke "set" (i32.const 4) (ref.host 4)))
+(assert_return (invoke "get" (i32.const 4)) (ref.host 4))
+(assert_trap (invoke "set" (i32.const 5) (ref.host 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 5)) "out of bounds table access")
+
+
+;; Reject growing to size outside i32 value range
+(module
+  (table $t 0x10 anyref)
+  (elem declare func $f)
+  (func $f (export "grow") (result i32)
+    (table.grow $t (ref.func $f) (i32.const 0xffff_fff0))
+  )
+)
+
+(assert_return (invoke "grow") (i32.const -1))
+
+
+(module
+  (table $t 0 anyref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+
+
+(module
+  (table $t 0 10 anyref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+
+(module
+  (table $t 10 anyref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result anyref)
+    (local anyref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 9)) (ref.null))
+(assert_return (invoke "grow" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-init-size-empty-vs-i32-anyref (result i32)
+      (table.grow $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-size-empty-vs-i32 (result i32)
+      (table.grow $t (ref.null))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-init-empty-vs-anyref (result i32)
+      (table.grow $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 anyref)
+    (func $type-size-f32-vs-i32 (result i32)
+      (table.grow $t (ref.null) (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 funcref)
+    (func $type-init-anyref-vs-funcref (param $r anyref) (result i32)
+      (table.grow $t (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 anyref)
+    (func $type-result-i32-vs-empty
+      (table.grow $t (ref.null) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 1 anyref)
+    (func $type-result-i32-vs-f32 (result f32)
+      (table.grow $t (ref.null) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_init.wast
new file mode 100644
index 0000000..80eaf06
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_init.wast
@@ -0,0 +1,1752 @@
+;;
+;; Generated by ../meta/generate_table_init.js
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init 1 (i32.const 7) (i32.const 0) (i32.const 4))
+    (elem.drop 1)
+    (table.init 3 (i32.const 15) (i32.const 1) (i32.const 3))
+    (elem.drop 3)
+    (table.copy (i32.const 20) (i32.const 15) (i32.const 5))
+    (table.copy (i32.const 21) (i32.const 29) (i32.const 1))
+    (table.copy (i32.const 24) (i32.const 10) (i32.const 1))
+    (table.copy (i32.const 13) (i32.const 11) (i32.const 4))
+    (table.copy (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 21)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "check" (i32.const 24)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+(assert_invalid
+  (module
+    (func (export "test")
+      (elem.drop 0)))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (elem.drop 4)))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 2)
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))
+    (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (elem.drop 1)))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 2) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 2) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 30) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table 30 30 funcref)
+  (elem (i32.const 2) 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (i32.const 12) 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 31) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 24) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 25) (i32.const 16)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 96) (i32.const 32)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 97) (i32.const 31)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 64 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 48) (i32.const 4294967280)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 16 16 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 8) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) "out of bounds")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_set.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_set.wast
new file mode 100644
index 0000000..848830e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_set.wast
@@ -0,0 +1,119 @@
+(module
+  (table $t2 1 anyref)
+  (table $t3 2 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "get-anyref") (param $i i32) (result anyref)
+    (table.get $t2 (local.get $i))
+  )
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+
+  (func (export "set-anyref") (param $i i32) (param $r anyref)
+    (table.set $t2 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref") (param $i i32) (param $r funcref)
+    (table.set $t3 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref-from") (param $i i32) (param $j i32)
+    (table.set $t3 (local.get $i) (table.get $t3 (local.get $j)))
+  )
+
+  (func (export "is_null-funcref") (param $i i32) (result i32)
+    (ref.is_null (call $f3 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "get-anyref" (i32.const 0)) (ref.null))
+(assert_return (invoke "set-anyref" (i32.const 0) (ref.host 1)))
+(assert_return (invoke "get-anyref" (i32.const 0)) (ref.host 1))
+(assert_return (invoke "set-anyref" (i32.const 0) (ref.null)))
+(assert_return (invoke "get-anyref" (i32.const 0)) (ref.null))
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null))
+(assert_return (invoke "set-funcref-from" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "is_null-funcref" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "set-funcref" (i32.const 0) (ref.null)))
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null))
+
+(assert_trap (invoke "set-anyref" (i32.const 2) (ref.null)) "out of bounds")
+(assert_trap (invoke "set-funcref" (i32.const 3) (ref.null)) "out of bounds")
+(assert_trap (invoke "set-anyref" (i32.const -1) (ref.null)) "out of bounds")
+(assert_trap (invoke "set-funcref" (i32.const -1) (ref.null)) "out of bounds")
+
+(assert_trap (invoke "set-anyref" (i32.const 2) (ref.host 0)) "out of bounds")
+(assert_trap (invoke "set-funcref-from" (i32.const 3) (i32.const 1)) "out of bounds")
+(assert_trap (invoke "set-anyref" (i32.const -1) (ref.host 0)) "out of bounds")
+(assert_trap (invoke "set-funcref-from" (i32.const -1) (i32.const 1)) "out of bounds")
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-value-empty-vs-i32-anyref 
+      (table.set $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-index-empty-vs-i32
+      (table.set $t (ref.null))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-value-empty-vs-anyref
+      (table.set $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-size-f32-vs-i32
+      (table.set $t (f32.const 1) (ref.null))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 funcref)
+    (func $type-value-anyref-vs-funcref (param $r anyref)
+      (table.set $t (i32.const 1) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 anyref)
+    (table $t2 1 funcref)
+    (func $type-value-anyref-vs-funcref-multi (param $r anyref)
+      (table.set $t2 (i32.const 0) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 anyref)
+    (func $type-result-empty-vs-num (result i32)
+      (table.set $t (i32.const 0) (ref.null))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_size.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_size.wast
new file mode 100644
index 0000000..5817104
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/table_size.wast
@@ -0,0 +1,86 @@
+(module
+  (table $t0 0 anyref)
+  (table $t1 1 anyref)
+  (table $t2 0 2 anyref)
+  (table $t3 3 8 anyref)
+
+  (func (export "size-t0") (result i32) (table.size $t0))
+  (func (export "size-t1") (result i32) (table.size $t1))
+  (func (export "size-t2") (result i32) (table.size $t2))
+  (func (export "size-t3") (result i32) (table.size $t3))
+
+  (func (export "grow-t0") (param $sz i32)
+    (drop (table.grow $t0 (ref.null) (local.get $sz)))
+  )
+  (func (export "grow-t1") (param $sz i32)
+    (drop (table.grow $t1 (ref.null) (local.get $sz)))
+  )
+  (func (export "grow-t2") (param $sz i32)
+    (drop (table.grow $t2 (ref.null) (local.get $sz)))
+  )
+  (func (export "grow-t3") (param $sz i32)
+    (drop (table.grow $t3 (ref.null) (local.get $sz)))
+  )
+)
+
+(assert_return (invoke "size-t0") (i32.const 0))
+(assert_return (invoke "grow-t0" (i32.const 1)))
+(assert_return (invoke "size-t0") (i32.const 1))
+(assert_return (invoke "grow-t0" (i32.const 4)))
+(assert_return (invoke "size-t0") (i32.const 5))
+(assert_return (invoke "grow-t0" (i32.const 0)))
+(assert_return (invoke "size-t0") (i32.const 5))
+
+(assert_return (invoke "size-t1") (i32.const 1))
+(assert_return (invoke "grow-t1" (i32.const 1)))
+(assert_return (invoke "size-t1") (i32.const 2))
+(assert_return (invoke "grow-t1" (i32.const 4)))
+(assert_return (invoke "size-t1") (i32.const 6))
+(assert_return (invoke "grow-t1" (i32.const 0)))
+(assert_return (invoke "size-t1") (i32.const 6))
+
+(assert_return (invoke "size-t2") (i32.const 0))
+(assert_return (invoke "grow-t2" (i32.const 3)))
+(assert_return (invoke "size-t2") (i32.const 0))
+(assert_return (invoke "grow-t2" (i32.const 1)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 0)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 4)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 1)))
+(assert_return (invoke "size-t2") (i32.const 2))
+
+(assert_return (invoke "size-t3") (i32.const 3))
+(assert_return (invoke "grow-t3" (i32.const 1)))
+(assert_return (invoke "size-t3") (i32.const 4))
+(assert_return (invoke "grow-t3" (i32.const 3)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 0)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 2)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 1)))
+(assert_return (invoke "size-t3") (i32.const 8))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 1 anyref)
+    (func $type-result-i32-vs-empty
+      (table.size $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 1 anyref)
+    (func $type-result-i32-vs-f32 (result f32)
+      (table.size $t)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/unreached-invalid.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/unreached-invalid.wast
new file mode 100644
index 0000000..3ddd773
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/reference-types/unreached-invalid.wast
@@ -0,0 +1,695 @@
+;; Failures in unreachable code.
+
+(assert_invalid
+  (module (func $local-index (unreachable) (drop (local.get 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $global-index (unreachable) (drop (global.get 0))))
+  "unknown global"
+)
+(assert_invalid
+  (module (func $func-index (unreachable) (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $label-index (unreachable) (br 1)))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (unreachable) (drop (i64.eqz (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-num-vs-num (result i32)
+    (unreachable) (i64.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-transitive-num-vs-num (result i32)
+    (unreachable)
+    (i64.const 0) (i32.const 0) (select)
+    (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unconsumed-const (unreachable) (i32.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result (unreachable) (i32.eqz)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result2
+    (unreachable) (i32.const 0) (i32.add)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly0 (unreachable) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly2
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-break
+    (block (br 0) (block (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-break
+    (block (br 0) (drop (i32.eqz (f32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-break
+    (block (br 0) (block (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-break
+    (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-break
+    (block (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-break (result i32)
+    (block (result i32) (i32.const 1) (br 0) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-break
+    (block (loop (br 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-break (result i32)
+    (loop (result i32) (br 1 (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-break
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-break (result i32)
+    (br 0 (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-return
+    (return) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-return
+    (return) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-return
+    (return) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-return
+    (return) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-return
+    (block (return) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-return (result i32)
+    (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-return
+    (block (loop (return) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-return (result i32)
+    (loop (result i32) (return (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-return
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-return (result i32)
+    (return (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-loop-after-unreachable
+    (unreachable) (loop (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable
+    (unreachable) (loop (result i32) (i32.eqz (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-unreachable
+    (unreachable) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-unreachable
+    (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-unreachable
+    (block (unreachable) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (i32.const 1) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-unreachable
+    (block (loop (unreachable) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-unreachable (result i32)
+    (loop (result i32) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-unreachable
+    (unreachable) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-unreachable (result i32)
+    (unreachable) (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-if-after-unreachable
+    (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable
+    (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable-if
+    (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-nested-unreachable
+    (block (block (unreachable)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-nested-unreachable
+    (block (loop (block (unreachable)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (loop (result i32) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (unreachable)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-infinite-loop
+    (block (loop (br 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32)
+    (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-infinite-loop
+    (block (loop (loop (br 0)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (result i32) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-infinite-loop
+    (loop (br 0)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (br 0)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (f32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (block (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (loop (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-second-num-vs-num (result i32)
+    (return (i32.const 1)) (return (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br-second-num-vs-num (result i32)
+    (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br_if-cond-num-vs-num-after-unreachable
+    (block (br_if 0 (unreachable) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-void-after-unreachable (result i32)
+    (block (result i32)
+      (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+      (drop) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num2-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-num-vs-num-after-unreachable
+    (block (br_table 0 (unreachable) (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-label-void-after-unreachable
+    (block
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 0 (i32.const 1))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-void
+    (block (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-void-vs-num (result i32)
+    (block (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-void
+    (block (i32.const 3) (block (br 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-void-vs-num (result i32)
+    (block (result i32) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-num (result i32)
+    (block (result i32) (i64.const 0) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-void
+    (block (block (i32.const 3) (block (br 2))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-void-vs-num (result i32)
+    (block (result i32) (block (block (br 2 (i32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-num (result i32)
+    (block (result i32)
+      (block (result i64) (i64.const 0) (block (br 2 (i32.const 0))))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-void
+    (block (i32.const 3) (block (return)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-void-vs-num (result i32)
+    (block (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (return (i32.const 0))))
+    (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-void
+    (loop (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32)
+    (loop (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32)
+    (loop (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-cont-last-void-vs-empty (result i32)
+    (loop (br 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cont-last-num-vs-empty (result i32)
+    (loop (br 0 (i32.const 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $tee-local-unreachable-value
+    (local i32)
+    (local.tee 0 (unreachable))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $br_if-unreachable (result i32)
+    (block (result i32)
+      (block
+        (br_if 1 (unreachable) (i32.const 0))
+      )
+      (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid 
+  (module
+    (func $type-br_if-after-unreachable (result i64)
+      unreachable
+      br_if 0
+      i64.extend_i32_u
+    )
+  )
+ "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i32.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i32.wast
new file mode 100644
index 0000000..32862c3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i32.wast
@@ -0,0 +1,976 @@
+;; i32 operations
+
+(module
+  (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x)))
+  (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x)))
+  (func (export "extend8_s") (param $x i32) (result i32) (i32.extend8_s (local.get $x)))
+  (func (export "extend16_s") (param $x i32) (result i32) (i32.extend16_s (local.get $x)))
+  (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x)))
+  (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2))
+(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff))
+(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000))
+
+(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff))
+(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000))
+
+(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001))
+(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470))
+(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+
+(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
+(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
+(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
+(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2))
+(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2))
+(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2))
+
+(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000))
+(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef))
+(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b))
+(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd))
+(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0))
+(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2))
+(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2))
+
+(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647))
+(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1))
+(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1))
+(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3))
+
+(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
+(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001))
+(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649))
+(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5))
+(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5))
+(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1))
+(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3))
+
+(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff))
+(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0))
+(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+
+(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
+(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
+(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff))
+(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
+
+(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
+(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
+(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff))
+(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
+(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f))
+(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0))
+
+(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe))
+(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe))
+(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2))
+(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000))
+(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
+
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
+(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000))
+(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1))
+(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
+
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff))
+(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
+(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000))
+(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
+
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 1)) (i32.const 2))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "rotl" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed))
+(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f))
+(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x183a5c76))
+(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000))
+(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x183a5c76))
+(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0x579beed3))
+(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3))
+(assert_return (invoke "rotl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
+(assert_return (invoke "rotl" (i32.const 0x80000000) (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 1)) (i32.const 0x80000000))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "rotr" (i32.const -1) (i32.const 1)) (i32.const -1))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 32)) (i32.const 1))
+(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600))
+(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000))
+(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x1d860e97))
+(assert_return (invoke "rotr" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00000400))
+(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97))
+(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5))
+(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0xe6fbb4d5))
+(assert_return (invoke "rotr" (i32.const 1) (i32.const 31)) (i32.const 2))
+(assert_return (invoke "rotr" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
+
+(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0))
+(assert_return (invoke "clz" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16))
+(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24))
+(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "clz" (i32.const 1)) (i32.const 31))
+(assert_return (invoke "clz" (i32.const 2)) (i32.const 30))
+(assert_return (invoke "clz" (i32.const 0x7fffffff)) (i32.const 1))
+
+(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32))
+(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15))
+(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16))
+(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31))
+(assert_return (invoke "ctz" (i32.const 0x7fffffff)) (i32.const 0))
+
+(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32))
+(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1))
+(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2))
+(assert_return (invoke "popcnt" (i32.const 0x7fffffff)) (i32.const 31))
+(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16))
+(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16))
+(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24))
+
+(assert_return (invoke "extend8_s" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "extend8_s" (i32.const 0x7f)) (i32.const 127))
+(assert_return (invoke "extend8_s" (i32.const 0x80)) (i32.const -128))
+(assert_return (invoke "extend8_s" (i32.const 0xff)) (i32.const -1))
+(assert_return (invoke "extend8_s" (i32.const 0x012345_00)) (i32.const 0))
+(assert_return (invoke "extend8_s" (i32.const 0xfedcba_80)) (i32.const -0x80))
+(assert_return (invoke "extend8_s" (i32.const -1)) (i32.const -1))
+
+(assert_return (invoke "extend16_s" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "extend16_s" (i32.const 0x7fff)) (i32.const 32767))
+(assert_return (invoke "extend16_s" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "extend16_s" (i32.const 0xffff)) (i32.const -1))
+(assert_return (invoke "extend16_s" (i32.const 0x0123_0000)) (i32.const 0))
+(assert_return (invoke "extend16_s" (i32.const 0xfedc_8000)) (i32.const -0x8000))
+(assert_return (invoke "extend16_s" (i32.const -1)) (i32.const -1))
+
+(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0))
+
+(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
+(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
+
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
+
+
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty
+      (i32.eqz) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.eqz) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.eqz) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.eqz) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.eqz)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.eqz) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.eqz)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-return
+      (return (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-select
+      (select (i32.eqz) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-call
+      (call 1 (i32.eqz)) (drop)
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-unary-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.eqz) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.eqz)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-unary-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-unary-operand-empty-in-global.set
+      (global.set $x (i32.eqz)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-unary-operand-empty-in-memory.grow
+      (memory.grow (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-unary-operand-empty-in-load
+      (i32.load (i32.eqz)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-unary-operand-empty-in-store
+      (i32.store (i32.eqz) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty
+      (i32.add) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty
+      (i32.const 0) (i32.add) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.add) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-if
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (i32.add) (then (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-if
+      (i32.const 0) (i32.const 0)
+      (if (i32.const 0) (then (i32.add)) (else (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-else
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0)))
+      (drop) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.add)))
+      (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br
+      (i32.const 0) (i32.const 0)
+      (block (br 0 (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br_if
+      (i32.const 0) (i32.const 0)
+      (block (br_if 0 (i32.add) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.const 0) (i32.add) (i32.const 1)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-br_table
+      (i32.const 0) (i32.const 0)
+      (block (br_table 0 (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.const 0) (i32.add)) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-return
+      (return (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-return
+      (return (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-select
+      (select (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-select
+      (select (i32.const 0) (i32.add) (i32.const 1) (i32.const 2)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-call
+      (call 1 (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-call
+      (call 1 (i32.const 0) (i32.add)) (drop)
+    )
+    (func (param i32 i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-binary-1st-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-binary-2nd-operand-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.const 0) (i32.add) (i32.const 0)
+        )
+        (drop)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.add)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-local.set
+      (local i32)
+      (local.set 0 (i32.const 0) (i32.add)) (local.get 0) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-1st-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-binary-2nd-operand-empty-in-local.tee
+      (local i32)
+      (local.tee 0 (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-binary-1st-operand-empty-in-global.set
+      (global.set $x (i32.add)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-binary-2nd-operand-empty-in-global.set
+      (global.set $x (i32.const 0) (i32.add)) (global.get $x) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-1st-operand-empty-in-memory.grow
+      (memory.grow (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-2nd-operand-empty-in-memory.grow
+      (memory.grow (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-1st-operand-empty-in-load
+      (i32.load (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-binary-2nd-operand-empty-in-load
+      (i32.load (i32.const 0) (i32.add)) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-binary-1st-operand-empty-in-store
+      (i32.store (i32.add) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-binary-2nd-operand-empty-in-store
+      (i32.store (i32.const 1) (i32.add) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (i32.add (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.and (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.div_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.div_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.mul (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.or (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rem_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rem_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rotl (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.rotr (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shl (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shr_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.shr_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.sub (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.xor (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.eqz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.clz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ctz (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.popcnt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.eq (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ge_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ge_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.gt_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.gt_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.le_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.le_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.lt_s (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.lt_u (i64.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32.ne (i64.const 0) (f32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i64.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i64.wast
new file mode 100644
index 0000000..baeed0c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/sign-extension-ops/i64.wast
@@ -0,0 +1,485 @@
+;; i64 operations
+
+(module
+  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x)))
+  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x)))
+  (func (export "extend8_s") (param $x i64) (result i64) (i64.extend8_s (local.get $x)))
+  (func (export "extend16_s") (param $x i64) (result i64) (i64.extend16_s (local.get $x)))
+  (func (export "extend32_s") (param $x i64) (result i64) (i64.extend32_s (local.get $x)))
+  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x)))
+  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y)))
+)
+
+(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
+(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
+
+(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
+
+(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
+(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
+(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
+(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
+(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
+(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
+(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
+(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
+(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
+(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
+(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
+
+(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
+(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
+(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
+(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
+(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
+(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
+(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
+(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
+
+(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
+(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
+(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
+
+(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
+(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
+(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
+(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
+(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
+(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
+
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
+(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
+(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
+(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
+(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
+(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
+
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d))
+(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf))
+(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea))
+(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
+(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1))
+
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1))
+(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567))
+(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
+(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b))
+(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139))
+(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2))
+(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
+
+(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
+(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
+(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
+(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
+(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
+(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1))
+
+(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
+(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
+(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
+(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
+(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
+(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0))
+
+(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
+(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
+(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
+(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63))
+(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
+(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
+
+(assert_return (invoke "extend8_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend8_s" (i64.const 0x7f)) (i64.const 127))
+(assert_return (invoke "extend8_s" (i64.const 0x80)) (i64.const -128))
+(assert_return (invoke "extend8_s" (i64.const 0xff)) (i64.const -1))
+(assert_return (invoke "extend8_s" (i64.const 0x01234567_89abcd_00)) (i64.const 0))
+(assert_return (invoke "extend8_s" (i64.const 0xfedcba98_765432_80)) (i64.const -0x80))
+(assert_return (invoke "extend8_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "extend16_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend16_s" (i64.const 0x7fff)) (i64.const 32767))
+(assert_return (invoke "extend16_s" (i64.const 0x8000)) (i64.const -32768))
+(assert_return (invoke "extend16_s" (i64.const 0xffff)) (i64.const -1))
+(assert_return (invoke "extend16_s" (i64.const 0x12345678_9abc_0000)) (i64.const 0))
+(assert_return (invoke "extend16_s" (i64.const 0xfedcba98_7654_8000)) (i64.const -0x8000))
+(assert_return (invoke "extend16_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "extend32_s" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "extend32_s" (i64.const 0x7fff)) (i64.const 32767))
+(assert_return (invoke "extend32_s" (i64.const 0x8000)) (i64.const 32768))
+(assert_return (invoke "extend32_s" (i64.const 0xffff)) (i64.const 65535))
+(assert_return (invoke "extend32_s" (i64.const 0x7fffffff)) (i64.const 0x7fffffff))
+(assert_return (invoke "extend32_s" (i64.const 0x80000000)) (i64.const -0x80000000))
+(assert_return (invoke "extend32_s" (i64.const 0xffffffff)) (i64.const -1))
+(assert_return (invoke "extend32_s" (i64.const 0x01234567_00000000)) (i64.const 0))
+(assert_return (invoke "extend32_s" (i64.const 0xfedcba98_80000000)) (i64.const -0x80000000))
+(assert_return (invoke "extend32_s" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
+
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
+(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
+
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
+(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
+(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result i64) (i64.add (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.and (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.div_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.div_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.mul (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.or (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rem_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rem_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rotl (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.rotr (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shl (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shr_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.shr_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.sub (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.xor (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.eqz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.clz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ctz (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.popcnt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64.ne (i32.const 0) (f32.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_address.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_address.wast
new file mode 100644
index 0000000..9e02300
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_address.wast
@@ -0,0 +1,157 @@
+;; Load/Store v128 data with different valid offset/alignment
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15")
+  (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31")
+
+  (func (export "load_data_1") (param $i i32) (result v128)
+    (v128.load offset=0 (local.get $i))                   ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_2") (param $i i32) (result v128)
+    (v128.load align=1 (local.get $i))                    ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_3") (param $i i32) (result v128)
+    (v128.load offset=1 align=1 (local.get $i))           ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00
+  )
+  (func (export "load_data_4") (param $i i32) (result v128)
+    (v128.load offset=2 align=1 (local.get $i))           ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00
+  )
+  (func (export "load_data_5") (param $i i32) (result v128)
+    (v128.load offset=15 align=1 (local.get $i))          ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+  )
+
+  (func (export "store_data_0") (result v128)
+    (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load offset=0 (i32.const 0))
+  )
+  (func (export "store_data_1") (result v128)
+    (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=1 (i32.const 0))
+  )
+  (func (export "store_data_2") (result v128)
+    (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load offset=1 align=1 (i32.const 0))
+  )
+  (func (export "store_data_3") (result v128)
+    (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load offset=2 align=1 (i32.const 0))
+  )
+  (func (export "store_data_4") (result v128)
+    (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=15 (i32.const 0))
+  )
+  (func (export "store_data_5") (result v128)
+    (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=65520 (i32.const 0))
+  )
+  (func (export "store_data_6") (param $i i32)
+    (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access")
+
+(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3))
+
+(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access")
+
+;; Load/Store v128 data with invalid offset
+
+(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)
+(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (drop (v128.load offset=-1 (i32.const 0)))"
+    ")"
+  )
+  "unknown operator"
+)
+
+(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)
+(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unknown operator"
+)
+
+
+;; Offset constant out of range
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (v128.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "i32 constant"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_align.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_align.wast
new file mode 100644
index 0000000..ed91ed5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_align.wast
@@ -0,0 +1,355 @@
+;; Valid alignment
+
+(module (memory 1) (func (drop (v128.load align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load align=16 (i32.const 0)))))
+
+(module (memory 1) (func (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=4 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=8 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+(module (memory 1) (func (v128.store align=16 (i32.const 0) (v128.const i32x4 0 1 2 3))))
+
+(module (memory 1) (func (drop (v128.load8x8_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load8x8_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16x4_u align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_s align=8 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32x2_u align=8 (i32.const 0)))))
+
+(module (memory 1) (func (drop (v128.load8_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load16_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load32_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=1 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=2 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=4 (i32.const 0)))))
+(module (memory 1) (func (drop (v128.load64_splat align=8 (i32.const 0)))))
+
+;; Invalid alignment
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load align=32 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func(v128.store align=32 (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8x8_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16x4_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_s align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32x2_u align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load8_splat align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load16_splat align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load32_splat align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.load64_splat align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Malformed alignment
+
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=-1 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=0 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (drop (v128.load align=7 (i32.const 0))))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (v128.store align=-1 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=0 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 0) (func (v128.store align=7 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8x8_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16x4_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_s align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32x2_u align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load8_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load16_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load32_splat align=3 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=-1 (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=0 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+(assert_malformed
+  (module quote
+    "(memory 1) (func (result v128) (v128.load64_splat align=7 (i32.const 0)))"
+  )
+  "alignment must be a power of two"
+)
+
+;; Test that misaligned SIMD loads/stores don't trap
+
+(module
+  (memory 1 1)
+  (func (export "v128.load align=16") (param $address i32) (result v128)
+    (v128.load align=16 (local.get $address))
+  )
+  (func (export "v128.store align=16") (param $address i32) (param $value v128)
+    (v128.store align=16 (local.get $address) (local.get $value))
+  )
+)
+
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.load align=16" (i32.const 1)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "v128.store align=16" (i32.const 1) (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)))
+(assert_return (invoke "v128.load align=16" (i32.const 0)) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+  (func (export "v128_unaligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load align=2  (i32.const 0))
+  )
+  (func (export "v128_aligned_read_and_unaligned_write") (result v128)
+    (local v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=2 (i32.const 0))
+  )
+  (func (export "v128_unaligned_read_and_aligned_write") (result v128)
+    (local v128)
+    (v128.store align=2 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128_unaligned_read_and_write") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128_aligned_read_and_write") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128_aligned_read_and_unaligned_write") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128_unaligned_read_and_aligned_write") (v128.const i32x4 0 1 2 3))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bit_shift.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bit_shift.wast
new file mode 100644
index 0000000..98e1556
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bit_shift.wast
@@ -0,0 +1,1104 @@
+;; Test all the bit shift operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.shl") (param $0 v128) (param $1 i32) (result v128) (i8x16.shl (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_s") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_s (local.get $0) (local.get $1)))
+  (func (export "i8x16.shr_u") (param $0 v128) (param $1 i32) (result v128) (i8x16.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i16x8.shl") (param $0 v128) (param $1 i32) (result v128) (i16x8.shl (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_s") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_s (local.get $0) (local.get $1)))
+  (func (export "i16x8.shr_u") (param $0 v128) (param $1 i32) (result v128) (i16x8.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i32x4.shl") (param $0 v128) (param $1 i32) (result v128) (i32x4.shl (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_s") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_s (local.get $0) (local.get $1)))
+  (func (export "i32x4.shr_u") (param $0 v128) (param $1 i32) (result v128) (i32x4.shr_u (local.get $0) (local.get $1)))
+
+  (func (export "i64x2.shl") (param $0 v128) (param $1 i32) (result v128) (i64x2.shl (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_s") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_s (local.get $0) (local.get $1)))
+  (func (export "i64x2.shr_u") (param $0 v128) (param $1 i32) (result v128) (i64x2.shr_u (local.get $0) (local.get $1)))
+
+  ;; shifting by a constant amount
+  ;; i8x16
+  (func (export "i8x16.shl_1") (param $0 v128) (result v128) (i8x16.shl (local.get $0) (i32.const 1)))
+  (func (export "i8x16.shr_u_8") (param $0 v128) (result v128) (i8x16.shr_u (local.get $0) (i32.const 8)))
+  (func (export "i8x16.shr_s_9") (param $0 v128) (result v128) (i8x16.shr_s (local.get $0) (i32.const 9)))
+
+  ;; i16x8
+  (func (export "i16x8.shl_1") (param $0 v128) (result v128) (i16x8.shl (local.get $0) (i32.const 1)))
+  (func (export "i16x8.shr_u_16") (param $0 v128) (result v128) (i16x8.shr_u (local.get $0) (i32.const 16)))
+  (func (export "i16x8.shr_s_17") (param $0 v128) (result v128) (i16x8.shr_s (local.get $0) (i32.const 17)))
+
+  ;; i32x4
+  (func (export "i32x4.shl_1") (param $0 v128) (result v128) (i32x4.shl (local.get $0) (i32.const 1)))
+  (func (export "i32x4.shr_u_32") (param $0 v128) (result v128) (i32x4.shr_u (local.get $0) (i32.const 32)))
+  (func (export "i32x4.shr_s_33") (param $0 v128) (result v128) (i32x4.shr_s (local.get $0) (i32.const 33)))
+
+  ;; i64x2
+  (func (export "i64x2.shl_1") (param $0 v128) (result v128) (i64x2.shl (local.get $0) (i32.const 1)))
+  (func (export "i64x2.shr_u_64") (param $0 v128) (result v128) (i64x2.shr_u (local.get $0) (i32.const 64)))
+  (func (export "i64x2.shr_s_65") (param $0 v128) (result v128) (i64x2.shr_s (local.get $0) (i32.const 65)))
+)
+
+;; i8x16 shl
+;; amount less than lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 1))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 4))
+                                   (v128.const i8x16 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x00 0x00 0x00 0x00 0x00 0x00 0xA0 0xB0 0xC0 0xD0))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 -128 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 9))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 17))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shl" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i8x16 0 4 8 12 16 20 24 28 32 36 0x28 0x2C 0x30 0x34 0x38 0x3C))
+;; i8x16 shr_u
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 64 96 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; i8x16 shr_s
+;; amount less than lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0xAA 0xBB 0xCC 0xDD 0xEE 0xFF 0xA0 0xB0 0xC0 0xD0 0xE0 0xF0 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 4))
+                                     (v128.const i8x16 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0xFA 0xFB 0xFC 0xFD 0xFE 0xFF 0x00 0x00 0x00 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 -128 -64 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D)
+                                     (i32.const 9))
+                                     (v128.const i8x16 192 224 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 9))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 17))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+(assert_return (invoke "i8x16.shr_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 0x02 0x02 0x03 0x03 0x03 0x03))
+;; shifting by a constant amount
+(assert_return (invoke "i8x16.shl_1" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                     (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 0x14 0x16 0x18 0x1A 0x1C 0x1E))
+(assert_return (invoke "i8x16.shr_u_8" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+(assert_return (invoke "i8x16.shr_s_9" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 0x0A 0x0B 0x0C 0x0D 0x0e 0x0F))
+                                       (v128.const i8x16 0 0 1 1 2 2 3 3 4 4 0x05 0x05 0x06 0x06 0x07 0x07))
+
+;; i16x8 shl
+;; amount less than lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 1))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (i32.const 2))
+                                   (v128.const i16x8 49380 49380 49380 49380 49380 49380 49380 49380))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (i32.const 2))
+                                   (v128.const i16x8 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0 0x48d0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                   (i32.const 4))
+                                   (v128.const i16x8 0xABB0 0xCDD0 0xEFF0 0xB00 0xD00 0xF00 0xA0B0 0xC0D0))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 8))
+                                   (v128.const i16x8 0 256 512 768 1024 1280 1536 1792))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 32))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 128))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 256))
+                                   (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                   (i32.const 17))
+                                   (v128.const i16x8 65280 65408 0 2 4 6 8 10))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 17))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 33))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 129))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 257))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 513))
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shl" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (i32.const 514))
+                                   (v128.const i16x8 0 4 8 12 16 20 24 28))
+
+;; i16x8 shr_u
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a 0x242a))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xAAB 0xCCD 0xEEF 0xA0B 0xC0D 0xE0F 0x0A0 0x0C0))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 32704 32736 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; i16x8 shr_s
+;; amount less than lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 1))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                     (i32.const 2))
+                                     (v128.const i16x8 3086 3086 3086 3086 3086 3086 3086 3086))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                     (i32.const 2))
+                                     (v128.const i16x8 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a 0xe42a))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0xAABB 0xCCDD 0xEEFF 0xA0B0 0xC0D0 0xE0F0 0x0A0B 0x0C0D)
+                                     (i32.const 4))
+                                     (v128.const i16x8 0xFAAB 0xFCCD 0xFEEF 0xFA0B 0xFC0D 0xFE0F 0x00A0 0x00C0))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 8))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+;; amount is multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 32))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 128))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 256))
+                                     (v128.const i16x8 0 1 2 3 4 5 6 7))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 -128 -64 0 1 2 3 4 5)
+                                     (i32.const 17))
+                                     (v128.const i16x8 65472 65504 0 0 1 1 2 2))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 17))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 33))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 129))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 257))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 513))
+                                     (v128.const i16x8 0 0 1 1 2 2 3 3))
+(assert_return (invoke "i16x8.shr_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                     (i32.const 514))
+                                     (v128.const i16x8 0 0 0 0 1 1 1 1))
+
+;; shifting by a constant amount
+(assert_return (invoke "i16x8.shl_1" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                     (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.shr_u_16" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "i16x8.shr_s_17" (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                        (v128.const i16x8 0 0 1 1 2 2 3 3))
+
+;; i32x4 shl
+;; amount less than lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 1))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (i32.const 2))
+                                   (v128.const i32x4 643304264 643304264 643304264 643304264))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (i32.const 2))
+                                   (v128.const i32x4 0x48d159e0 0x48d159e0 0x48d159e0 0x48d159e0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i32x4 0xABBCCDD0 0xEFFA0B00 0x0D0E0F00 0xA0B0C0D0))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 8))
+                                   (v128.const i32x4 0 256 0x00000E00 0x00000F00))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 -2147483648 -32768 0 0x0A0B0C0D)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 4294901760 0 0x1416181A))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 33))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i32x4 0 2 0x1C 0x1E))
+(assert_return (invoke "i32x4.shl" (v128.const i32x4 0 1 0x0E 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i32x4 0 4 0x38 0x3C))
+
+;; i32x4 shr_u
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0x242af37b 0x242af37b 0x242af37b 0x242af37b))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0x0AABBCCD 0x0EEFFA0B 0x0C0D0E0F 0x00A0B0C0))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 -2147483648 -32768 0x0000000C 0x0000000D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 1073741824 2147467264 0x00000006 0x00000006))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_u" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; i32x4 shr_s
+;; amount less than lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 1))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                     (i32.const 2))
+                                     (v128.const i32x4 308641972 308641972 308641972 308641972))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                     (i32.const 2))
+                                     (v128.const i32x4 0xe42af37b 0xe42af37b 0xe42af37b 0xe42af37b))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0xAABBCCDD 0xEEFFA0B0 0xC0D0E0F0 0x0A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i32x4 0xfaabbccd 0xFEEFFA0B 0xFC0D0E0F 0x00A0B0C0))
+;; amount is multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 8))
+                                     (v128.const i32x4 0 0 0x00000000 0x00000000))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i32x4 0 1 0x0E 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 -2147483648 -32768 0x0C 0x0D)
+                                     (i32.const 33))
+                                     (v128.const i32x4 3221225472 4294950912 0x06 0x06))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 33))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i32x4 0 0 0x07 0x07))
+(assert_return (invoke "i32x4.shr_s" (v128.const i32x4 0 1 0x0E 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i32x4 0 0 0x03 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i32x4.shl_1" (v128.const i32x4 0 1 0x0E 0x0F))
+                                     (v128.const i32x4 0 2 28 30))
+(assert_return (invoke "i32x4.shr_u_32" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 1 0x0E 0x0F))
+(assert_return (invoke "i32x4.shr_s_33" (v128.const i32x4 0 1 0x0E 0x0F))
+                                        (v128.const i32x4 0 0 7 7))
+
+;; i64x2 shl
+;; amount less than lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                   (i32.const 1))
+                                   (v128.const i64x2 0 18446744069414584320))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (i32.const 2))
+                                   (v128.const i64x2 4938271560493827156 4938271560493827156))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (i32.const 2))
+                                   (v128.const i64x2 0x48d159e242af37bc 0x48d159e242af37bc))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 4))
+                                   (v128.const i64x2 0xABBCCDDEEFFA0B00 0xD0E0F00A0B0C0D0))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                   (i32.const 8))
+                                   (v128.const i64x2 0xBBCCDDEEFFA0B000 0xD0E0F00A0B0C0D00))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 16))
+                                   (v128.const i64x2 65536 0xF0000))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 32))
+                                   (v128.const i64x2 4294967296 0xF00000000))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 128))
+                                   (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 256))
+                                   (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 65))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 129))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 257))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 513))
+                                   (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shl" (v128.const i64x2 1 0x0F)
+                                   (i32.const 514))
+                                   (v128.const i64x2 4 0x3C))
+
+;; i64x2 shr_u
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 4611686018427387904 9223372035781033984))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0x242af37be1d950c8 0x242af37be1d950c8))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0B 0xC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xAABBCCDDEEFFA0 0xC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_u" (v128.const i64x2 0 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; i64x2 shr_s
+;; amount less than lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 1))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                     (i32.const 2))
+                                     (v128.const i64x2 308641972530864197 308641972530864197))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                     (i32.const 2))
+                                     (v128.const i64x2 0xe42af37be1d950c8 0xe42af37be1d950c8))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xAABBCCDDEEFFA0B0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 4))
+                                     (v128.const i64x2 0xFAABBCCDDEEFFA0B 0xFC0D0E0F00A0B0C0))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0xFFAABBCCDDEEFFA0 0xC0D0E0F00A0B0C0D)
+                                     (i32.const 8))
+                                     (v128.const i64x2 0xFFFFAABBCCDDEEFF 0xFFC0D0E0F00A0B0C))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 16))
+                                     (v128.const i64x2 0 0x00))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 32))
+                                     (v128.const i64x2 0 0x00))
+;; amount is multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 128))
+                                     (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 256))
+                                     (v128.const i64x2 1 0x0F))
+;; amount greater than but not a multiple of lane width
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 -9223372036854775808 -2147483648)
+                                     (i32.const 65))
+                                     (v128.const i64x2 13835058055282163712 18446744072635809792))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 0x0C 0x0D)
+                                     (i32.const 65))
+                                     (v128.const i64x2 0x06 0x06))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 129))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 257))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 513))
+                                     (v128.const i64x2 0 0x07))
+(assert_return (invoke "i64x2.shr_s" (v128.const i64x2 1 0x0F)
+                                     (i32.const 514))
+                                     (v128.const i64x2 0 0x03))
+
+;; shifting by a constant amount
+(assert_return (invoke "i64x2.shl_1" (v128.const i64x2 1 0x0F))
+                                     (v128.const i64x2 2 0x1E))
+(assert_return (invoke "i64x2.shr_u_64" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 1 0x0F))
+(assert_return (invoke "i64x2.shr_s_65" (v128.const i64x2 1 0x0F))
+                                        (v128.const i64x2 0 0x07))
+
+;; Combination
+
+(module (memory 1)
+  (func (export "i8x16.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i8x16.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i16x8.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i32x4.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shl-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shl
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_s
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "i64x2.shr_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i64x2.shr_u
+            (block (result v128) (v128.load (i32.const 0))) (i32.const 1)
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-i8x16.shl")
+    (drop
+      (i8x16.shl
+        (i8x16.shl
+          (i8x16.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_s")
+    (drop
+      (i8x16.shr_s
+        (i8x16.shr_s
+          (i8x16.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i8x16.shr_u")
+    (drop
+      (i8x16.shr_u
+        (i8x16.shr_u
+          (i8x16.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shl")
+    (drop
+      (i16x8.shl
+        (i16x8.shl
+          (i16x8.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_s")
+    (drop
+      (i16x8.shr_s
+        (i16x8.shr_s
+          (i16x8.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i16x8.shr_u")
+    (drop
+      (i16x8.shr_u
+        (i16x8.shr_u
+          (i16x8.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shl")
+    (drop
+      (i32x4.shl
+        (i32x4.shl
+          (i32x4.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_s")
+    (drop
+      (i32x4.shr_s
+        (i32x4.shr_s
+          (i32x4.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i32x4.shr_u")
+    (drop
+      (i32x4.shr_u
+        (i32x4.shr_u
+          (i32x4.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shl")
+    (drop
+      (i64x2.shl
+        (i64x2.shl
+          (i64x2.shl
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_s")
+    (drop
+      (i64x2.shr_s
+        (i64x2.shr_s
+          (i64x2.shr_s
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+  (func (export "nested-i64x2.shr_u")
+    (drop
+      (i64x2.shr_u
+        (i64x2.shr_u
+          (i64x2.shr_u
+            (v128.load (i32.const 0)) (i32.const 1)
+          )
+          (i32.const 1)
+        )
+        (i32.const 1)
+      )
+    )
+  )
+)
+
+(assert_return (invoke "i8x16.shl-in-block"))
+(assert_return (invoke "i8x16.shr_s-in-block"))
+(assert_return (invoke "i8x16.shr_u-in-block"))
+(assert_return (invoke "i16x8.shl-in-block"))
+(assert_return (invoke "i16x8.shr_s-in-block"))
+(assert_return (invoke "i16x8.shr_u-in-block"))
+(assert_return (invoke "i32x4.shl-in-block"))
+(assert_return (invoke "i32x4.shr_s-in-block"))
+(assert_return (invoke "i32x4.shr_u-in-block"))
+(assert_return (invoke "i64x2.shl-in-block"))
+(assert_return (invoke "i64x2.shr_s-in-block"))
+(assert_return (invoke "i64x2.shr_u-in-block"))
+(assert_return (invoke "nested-i8x16.shl"))
+(assert_return (invoke "nested-i8x16.shr_s"))
+(assert_return (invoke "nested-i8x16.shr_u"))
+(assert_return (invoke "nested-i16x8.shl"))
+(assert_return (invoke "nested-i16x8.shr_s"))
+(assert_return (invoke "nested-i16x8.shr_u"))
+(assert_return (invoke "nested-i32x4.shl"))
+(assert_return (invoke "nested-i32x4.shr_s"))
+(assert_return (invoke "nested-i32x4.shr_u"))
+(assert_return (invoke "nested-i64x2.shl"))
+(assert_return (invoke "nested-i64x2.shr_s"))
+(assert_return (invoke "nested-i64x2.shr_u"))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shl   (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_s (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.shr_u (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shl_r (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.shr   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shl   (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_s (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.shr_u (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.shl-1st-arg-empty (result v128)
+      (i8x16.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-last-arg-empty (result v128)
+      (i8x16.shl (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shl-arg-empty (result v128)
+      (i8x16.shl)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-1st-arg-empty (result v128)
+      (i16x8.shr_u (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-last-arg-empty (result v128)
+      (i16x8.shr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.shr_u-arg-empty (result v128)
+      (i16x8.shr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-1st-arg-empty (result v128)
+      (i32x4.shr_s (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-last-arg-empty (result v128)
+      (i32x4.shr_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.shr_s-arg-empty (result v128)
+      (i32x4.shr_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shl-1st-arg-empty (result v128)
+      (i64x2.shl (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_u-last-arg-empty (result v128)
+      (i64x2.shr_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.shr_s-arg-empty (result v128)
+      (i64x2.shr_s)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bitwise.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bitwise.wast
new file mode 100644
index 0000000..f646bf6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_bitwise.wast
@@ -0,0 +1,812 @@
+;; Test all the bitwise operators on major boundary values and all special values.
+
+(module
+  (func (export "not") (param $0 v128) (result v128) (v128.not (local.get $0)))
+  (func (export "and") (param $0 v128) (param $1 v128) (result v128) (v128.and (local.get $0) (local.get $1)))
+  (func (export "or") (param $0 v128) (param $1 v128) (result v128) (v128.or (local.get $0) (local.get $1)))
+  (func (export "xor") (param $0 v128) (param $1 v128) (result v128) (v128.xor (local.get $0) (local.get $1)))
+  (func (export "bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result v128)
+    (v128.bitselect (local.get $0) (local.get $1) (local.get $2))
+  )
+  (func (export "andnot") (param $0 v128) (param $1 v128) (result v128) (v128.andnot (local.get $0) (local.get $1)))
+)
+
+;; i32x4
+(assert_return (invoke "not" (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "not" (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "not" (v128.const i32x4 -1 0 -1 0))
+                             (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "not" (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "not" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "not" (v128.const i32x4 3435973836 3435973836 3435973836 3435973836))
+                             (v128.const i32x4 858993459 858993459 858993459 858993459))
+(assert_return (invoke "not" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 3060399405 3060399405 3060399405 3060399405))
+(assert_return (invoke "not" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                             (v128.const i32x4 0xedcba987 0xedcba987 0xedcba987 0xedcba987))
+(assert_return (invoke "and" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "and" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 85 85 85 85))
+(assert_return (invoke "and" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "and" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 10 128 0 160))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "and" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+(assert_return (invoke "and" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x5555 0x5555 0x5555 0x5555))
+(assert_return (invoke "and" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "and" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x10204468 0x10204468 0x10204468 0x10204468))
+(assert_return (invoke "or" (v128.const i32x4 0 0 -1 -1)
+                            (v128.const i32x4 0 -1 0 -1))
+                            (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "or" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 1 1 1 1)
+                            (v128.const i32x4 1 1 1 1))
+                            (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 85 85 85 85))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 255 255 255 255)
+                            (v128.const i32x4 128 128 128 128))
+                            (v128.const i32x4 255 255 255 255))
+(assert_return (invoke "or" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                            (v128.const i32x4 10 128 5 165))
+                            (v128.const i32x4 2863311530 2863311530 2863311535 2863311535))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x0 0x0 0x0 0x0))
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "or" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                            (v128.const i32x4 0x55555555 0x5555ffff 0x555555ff 0x55555fff))
+(assert_return (invoke "or" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                            (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                            (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+(assert_return (invoke "or" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                            (v128.const i32x4 0x92bfdfff 0x92bfdfff 0x92bfdfff 0x92bfdfff))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 -1 -1)
+                             (v128.const i32x4 0 -1 0 -1))
+                             (v128.const i32x4 0 -1 -1 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0 0 0 0))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 -1 -1 -1 -1))
+                             (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "xor" (v128.const i32x4 0 0 0 0)
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 1 1 1 1)
+                             (v128.const i32x4 1 1 1 1))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 85 85 85 85))
+                             (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "xor" (v128.const i32x4 255 255 255 255)
+                             (v128.const i32x4 128 128 128 128))
+                             (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "xor" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                             (v128.const i32x4 10 128 5 165))
+                             (v128.const i32x4 2863311520 2863311402 2863311535 2863311375))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                             (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "xor" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                             (v128.const i32x4 0x0 0x0 0x0 0x0))
+                             (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "xor" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                             (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                             (v128.const i32x4 0x55550000 0x5555AAAA 0x555500AA 0x55550AAA))
+(assert_return (invoke "xor" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                             (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                             (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                             (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                             (v128.const i32x4 0x829f9b97 0x829f9b97 0x829f9b97 0x829f9b97))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00112345 0xF00FFFFF 0x10112021 0xBBAABBAA))
+                                   (v128.const i32x4 0xBBAABABA 0xABBAAAAA 0xABAABBBA 0xAABBAABB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x11111111 0x11111111 0x11111111 0x11111111))
+                                   (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB 0xBBBBBBBB)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0xBABABABA 0xBABABABA 0xABABABAB 0xABABABAB))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x01234567 0x89ABCDEF 0xFEDCBA98 0x76543210))
+                                   (v128.const i32x4 0x54761032 0xDCFE98BA 0xAB89EFCD 0x23016745))
+(assert_return (invoke "bitselect" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                                   (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                   (v128.const i32x4 0x55555555 0xAAAAAAAA 0x00000000 0xFFFFFFFF))
+                                   (v128.const i32x4 0x00000000 0xFFFFFFFF 0x55555555 0xAAAAAAAA))
+(assert_return (invoke "bitselect" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 03_060_399_406 03_060_399_406 03_060_399_406 03_060_399_406)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 2072391874 2072391874 2072391874 2072391874))
+(assert_return (invoke "bitselect" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0xcdefcdef 0xcdefcdef 0xcdefcdef 0xcdefcdef))
+                                   (v128.const i32x4 0x10244468 0x10244468 0x10244468 0x10244468))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 -1 -1)
+                                (v128.const i32x4 0 -1 0 -1))
+                                (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0 0 0 0))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 -1 -1 -1 -1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0 0 0 0)
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 1 1 1 1)
+                                (v128.const i32x4 1 1 1 1))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 85 85 85 85))
+                                (v128.const i32x4 170 170 170 170))
+(assert_return (invoke "andnot" (v128.const i32x4 255 255 255 255)
+                                (v128.const i32x4 128 128 128 128))
+                                (v128.const i32x4 127 127 127 127))
+(assert_return (invoke "andnot" (v128.const i32x4 2863311530 2863311530 2863311530 2863311530)
+                                (v128.const i32x4 10 128 5 165))
+                                (v128.const i32x4 2863311520 2863311402 2863311530 2863311370))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                                (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555))
+(assert_return (invoke "andnot" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                                (v128.const i32x4 0x0 0x0 0x0 0x0))
+                                (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+(assert_return (invoke "andnot" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                                (v128.const i32x4 0x5555 0xFFFF 0x55FF 0x5FFF))
+                                (v128.const i32x4 0x55550000 0x55550000 0x55550000 0x55550000))
+(assert_return (invoke "andnot" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "andnot" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                (v128.const i32x4 0x02141210 0x02141210 0x02141210 0x02141210))
+
+;; for float special data [e.g. -nan nan -inf inf]
+(assert_return (invoke "not" (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 5.87747e-39 5.87747e-39 5.87747e-39 5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -5.87747e-39 -5.87747e-39 -5.87747e-39 -5.87747e-39))
+(assert_return (invoke "not" (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x007fffff 0x007fffff 0x007fffff 0x007fffff))
+(assert_return (invoke "not" (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x807fffff 0x807fffff 0x807fffff 0x807fffff))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "and" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "and" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "or" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "or" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -nan -nan -nan -nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -nan -nan -nan -nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 nan nan nan nan))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "xor" (v128.const f32x4 nan nan nan nan)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 -inf -inf -inf -inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "xor" (v128.const f32x4 -inf -inf -inf -inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "xor" (v128.const f32x4 inf inf inf inf)
+                             (v128.const f32x4 inf inf inf inf))
+                             (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const i32x4 0xffc00000 0xffc00000 0xffc00000 0xffc00000))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "bitselect" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5 0xA5A5A5A5))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -nan -nan -nan -nan))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -nan -nan -nan -nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80400000 0x80400000 0x80400000 0x80400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 nan nan nan nan))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 nan nan nan nan)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00400000 0x00400000 0x00400000 0x00400000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 -inf -inf -inf -inf))
+                                (v128.const f32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "andnot" (v128.const f32x4 -inf -inf -inf -inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "andnot" (v128.const f32x4 inf inf inf inf)
+                                (v128.const f32x4 inf inf inf inf))
+                                (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+
+;; Type check
+
+;; not
+(assert_invalid (module (func (result v128) (v128.not (i32.const 0)))) "type mismatch")
+;; and
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.and (i32.const 0) (i32.const 0)))) "type mismatch")
+;; or
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.or (i32.const 0) (i32.const 0)))) "type mismatch")
+;; xor
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.xor (i32.const 0) (i32.const 0)))) "type mismatch")
+;; bitselect
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.bitselect (i32.const 0) (i32.const 0) (i32.const 0)))) "type mismatch")
+;; andnot
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (v128.const i32x4 0 0 0 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (v128.andnot (i32.const 0) (i32.const 0)))) "type mismatch")
+
+;; Combination
+
+(module (memory 1)
+  (func (export "v128.not-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.not
+            (block (result v128) (v128.load (i32.const 0)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.and-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.and
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.or-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.or
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.xor-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.xor
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.bitselect-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.bitselect
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+            (block (result v128) (v128.load (i32.const 2)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "v128.andnot-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (v128.andnot
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.not")
+    (drop
+      (v128.not
+        (v128.not
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.and")
+    (drop
+      (v128.and
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.and
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.and
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.or")
+    (drop
+      (v128.or
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.or
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.or
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.xor")
+    (drop
+      (v128.xor
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.xor
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.bitselect")
+    (drop
+      (v128.bitselect
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+        (v128.bitselect
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-v128.andnot")
+    (drop
+      (v128.andnot
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.andnot
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (v128.or
+        (v128.and
+          (v128.not
+            (v128.load (i32.const 0))
+          )
+          (v128.not
+            (v128.load (i32.const 1))
+          )
+        )
+        (v128.xor
+          (v128.bitselect
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+            (v128.load (i32.const 2))
+          )
+          (v128.andnot
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "v128.not-in-block"))
+(assert_return (invoke "v128.and-in-block"))
+(assert_return (invoke "v128.or-in-block"))
+(assert_return (invoke "v128.xor-in-block"))
+(assert_return (invoke "v128.bitselect-in-block"))
+(assert_return (invoke "v128.andnot-in-block"))
+(assert_return (invoke "nested-v128.not"))
+(assert_return (invoke "nested-v128.and"))
+(assert_return (invoke "nested-v128.or"))
+(assert_return (invoke "nested-v128.xor"))
+(assert_return (invoke "nested-v128.bitselect"))
+(assert_return (invoke "nested-v128.andnot"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.not-arg-empty (result v128)
+      (v128.not)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-1st-arg-empty (result v128)
+      (v128.and (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.and-arg-empty (result v128)
+      (v128.and)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-1st-arg-empty (result v128)
+      (v128.or (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.or-arg-empty (result v128)
+      (v128.or)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-1st-arg-empty (result v128)
+      (v128.xor (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.xor-arg-empty (result v128)
+      (v128.xor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-1st-arg-empty (result v128)
+      (v128.andnot (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.andnot-arg-empty (result v128)
+      (v128.andnot)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-1st-arg-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-two-args-empty (result v128)
+      (v128.bitselect (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.bitselect-arg-empty (result v128)
+      (v128.bitselect)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_boolean.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_boolean.wast
new file mode 100644
index 0000000..6ab330f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_boolean.wast
@@ -0,0 +1,1058 @@
+;; Test all the boolean operators on major boundary values and all special values.
+
+(module
+  (func (export "i8x16.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i8x16.all_true") (param $0 v128) (result i32) (i8x16.all_true (local.get $0)))
+  (func (export "i8x16.bitmask") (param $0 v128) (result i32) (i8x16.bitmask (local.get $0)))
+
+  (func (export "i16x8.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i16x8.all_true") (param $0 v128) (result i32) (i16x8.all_true (local.get $0)))
+  (func (export "i16x8.bitmask") (param $0 v128) (result i32) (i16x8.bitmask (local.get $0)))
+
+  (func (export "i32x4.any_true") (param $0 v128) (result i32) (v128.any_true (local.get $0)))
+  (func (export "i32x4.all_true") (param $0 v128) (result i32) (i32x4.all_true (local.get $0)))
+  (func (export "i32x4.bitmask") (param $0 v128) (result i32) (i32x4.bitmask (local.get $0)))
+
+  (func (export "i64x2.all_true") (param $0 v128) (result i32) (i64x2.all_true (local.get $0)))
+  (func (export "i64x2.bitmask") (param $0 v128) (result i32) (i64x2.bitmask (local.get $0)))
+)
+
+;; i8x16
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.any_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.all_true" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 0x0000FFFF))
+(assert_return (invoke "i8x16.bitmask" (v128.const i8x16 -1 0 1 2 3 4 5 6 7 8 9 0xA 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i16x8
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.any_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.all_true" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                        (i32.const 1))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                                        (i32.const 0x000000FF))
+(assert_return (invoke "i16x8.bitmask" (v128.const i16x8 -1 0 1 2 0xB 0xC 0xD 0xF))
+                                        (i32.const 0x00000001))
+
+;; i32x4
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.any_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0 0 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 1 1 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x00 0x00 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xFF 0xFF 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0xAB 0xAB 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.all_true" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                        (i32.const 1))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                                        (i32.const 0x0000000F))
+(assert_return (invoke "i32x4.bitmask" (v128.const i32x4 -1 0 1 0xF))
+                                        (i32.const 0x00000001))
+
+;; i64x2
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0 1))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 1 1))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 -1 0))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x00 0x00))
+                                        (i32.const 0))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xFF 0xFF))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0xAB 0xAB))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.all_true" (v128.const i64x2 0x55 0x55))
+                                        (i32.const 1))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 0xFFFFFFFF_FFFFFFFF 0xFFFFFFFF_FFFFFFFF))
+                                        (i32.const 0x00000003))
+(assert_return (invoke "i64x2.bitmask" (v128.const i64x2 -1 0xF))
+                                        (i32.const 0x00000001))
+
+;; Combination
+
+(module (memory 1)
+    ;; as if condition
+    (func (export "i8x16_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_any_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (v128.any_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i8x16_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i8x16.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i16x8_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i16x8.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    (func (export "i32x4_all_true_as_if_cond") (param v128) (result i32)
+        (if (result i32) (i32x4.all_true (local.get 0))
+            (then (i32.const 1))
+            (else (i32.const 0))
+        )
+    )
+    ;; any_true as select condition
+    (func (export "i8x16_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i16x8_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    (func (export "i32x4_any_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (v128.any_true (local.get 0)))
+    )
+    ;; all_true as select condition
+    (func (export "i8x16_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i8x16.all_true (local.get 0)))
+    )
+    (func (export "i16x8_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i16x8.all_true (local.get 0)))
+    )
+    (func (export "i32x4_all_true_as_select_cond") (param v128) (result i32)
+     (select (i32.const 1) (i32.const 0) (i32x4.all_true (local.get 0)))
+    )
+    ;; any_true as br_if condition
+    (func (export "i8x16_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_any_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (v128.any_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; all_true as br_if condition
+    (func (export "i8x16_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i8x16.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i16x8_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i16x8.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    (func (export "i32x4_all_true_as_br_if_cond") (param $0 v128) (result i32)
+      (local $1 i32)
+      (local.set $1 (i32.const 2))
+      (block
+        (local.set $1 (i32.const 1))
+        (br_if 0 (i32x4.all_true (local.get $0)))
+        (local.set $1 (i32.const 0))
+      )
+      (local.get $1)
+    )
+    ;; any_true as i32.and operand
+    (func (export "i8x16_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.or operand
+    (func (export "i8x16_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; any_true as i32.xor operand
+    (func (export "i8x16_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i16x8_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+    (func (export "i32x4_any_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (v128.any_true (local.get $0)) (v128.any_true (local.get $1)))
+    )
+     ;; all_true as i32.and operand
+    (func (export "i8x16_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.and_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.and (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.or operand
+    (func (export "i8x16_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.or_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.or (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+     ;; all_true as i32.xor operand
+    (func (export "i8x16_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i8x16.all_true (local.get $0)) (i8x16.all_true (local.get $1)))
+    )
+    (func (export "i16x8_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i16x8.all_true (local.get $0)) (i16x8.all_true (local.get $1)))
+    )
+    (func (export "i32x4_all_true_as_i32.xor_operand") (param $0 v128) (param $1 v128) (result i32)
+      (i32.xor (i32x4.all_true (local.get $0)) (i32x4.all_true (local.get $1)))
+    )
+    ;; any_true with v128.not
+    (func (export "i8x16_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_any_true_with_v128.not") (param $0 v128) (result i32)
+       (v128.any_true (v128.not (local.get $0)))
+    )
+    ;; any_true with v128.and
+    (func (export "i8x16_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.or
+    (func (export "i8x16_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.xor
+    (func (export "i8x16_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_any_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (v128.any_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; any_true with v128.bitselect
+    (func (export "i8x16_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_any_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (v128.any_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    ;; all_true with v128.not
+    (func (export "i8x16_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i8x16.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i16x8_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i16x8.all_true (v128.not (local.get $0)))
+    )
+    (func (export "i32x4_all_true_with_v128.not") (param $0 v128) (result i32)
+       (i32x4.all_true (v128.not (local.get $0)))
+    )
+    ;; all_true with v128.and
+    (func (export "i8x16_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.and") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.and (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.or
+    (func (export "i8x16_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.or") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.or (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.xor
+    (func (export "i8x16_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i8x16.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i16x8_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i16x8.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    (func (export "i32x4_all_true_with_v128.xor") (param $0 v128) (param $1 v128) (result i32)
+       (i32x4.all_true (v128.xor (local.get $0) (local.get $1)))
+    )
+    ;; all_true with v128.bitselect
+    (func (export "i8x16_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i8x16.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i16x8_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i16x8.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+    (func (export "i32x4_all_true_with_v128.bitselect") (param $0 v128) (param $1 v128) (param $2 v128) (result i32)
+       (i32x4.all_true (v128.bitselect (local.get $0) (local.get $1) (local.get $2)))
+    )
+)
+
+;; 'any_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 0 0 1 0 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 0 0 1 0))
+                                                   (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; 'all_true' as 'if' condition
+;; i8x16
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i16x8
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 0 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (i32.const 1))
+;; i32x4
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 0 0 0 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 0))
+                                                   (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_if_cond" (v128.const i32x4 1 1 1 1))
+                                                   (i32.const 1))
+
+;; any_true as select condition
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_select_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_select_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 0 0))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_select_cond" (v128.const i32x4 0 0 1 0))
+                                                       (i32.const 1))
+;; all_true as select condition
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_select_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_select_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                       (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 1 1))
+                                                       (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_select_cond" (v128.const i32x4 1 1 0 1))
+                                                       (i32.const 0))
+;; any_true as br_if condition
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_br_if_cond" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_br_if_cond" (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_br_if_cond" (v128.const i32x4 0 0 1 0))
+                                                      (i32.const 1))
+;; all_true as br_if condition
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_br_if_cond" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_br_if_cond" (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 1 1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_br_if_cond" (v128.const i32x4 1 1 0 1))
+                                                      (i32.const 0))
+;; any_true as and operand
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.and_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+;; any_true as or operand
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.or_operand" (v128.const i32x4 0 0 1 0)
+                                                          (v128.const i32x4 0 0 1 0))
+                                                          (i32.const 1))
+;; any_true as xor operand
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_any_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_any_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 1 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_any_true_as_i32.xor_operand" (v128.const i32x4 0 0 1 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as and operand
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.and_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.and_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 1 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.and_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 1 0))
+                                                           (i32.const 0))
+;; all_true as or operand
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                          (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.or_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                          (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                          (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.or_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                          (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                          (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 1 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 1 1 1 1)
+                                                          (v128.const i32x4 1 1 0 1))
+                                                          (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.or_operand" (v128.const i32x4 0 0 0 0)
+                                                          (v128.const i32x4 0 0 0 0))
+                                                          (i32.const 0))
+;; all_true as xor operand
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                           (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i8x16_all_true_as_i32.xor_operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                           (v128.const i16x8 1 1 1 1 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i16x8_all_true_as_i32.xor_operand" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 1 1))
+                                                           (i32.const 0))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 1 1 1 1)
+                                                           (v128.const i32x4 1 1 0 1))
+                                                           (i32.const 1))
+(assert_return (invoke "i32x4_all_true_as_i32.xor_operand" (v128.const i32x4 0 0 0 0)
+                                                           (v128.const i32x4 0 0 0 0))
+                                                           (i32.const 0))
+;; any_true with v128.not
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.and
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.or
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_any_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 1))
+;; any_true with v128.xor
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 1))
+;; any_true with v128.bitselect
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_any_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_any_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_any_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0xFF 0x55))
+                                                            (i32.const 1))
+;; all_true with v128.not
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.not" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.not" (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.not" (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.and
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.and" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.and" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.and" (v128.const i32x4 0 0 -1 0)
+                                                      (v128.const i32x4 0 0 -1 0))
+                                                      (i32.const 0))
+;; all_true with v128.or
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i8x16_all_true_with_v128.or" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.or" (v128.const i16x8 0 0 0 0 0 0 -1 0)
+                                                     (v128.const i16x8 0 0 0 0 0 0 -1 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 0 0)
+                                                     (v128.const i32x4 0 0 0 0))
+                                                     (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 -1 -1 -1 -1)
+                                                     (v128.const i32x4 -1 -1 -1 -1))
+                                                     (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.or" (v128.const i32x4 0 0 -1 0)
+                                                     (v128.const i32x4 0 0 -1 0))
+                                                     (i32.const 0))
+;; all_true with v128.xor
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.xor" (v128.const i8x16 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i8x16 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.xor" (v128.const i16x8 0 -1 0 -1 0 -1 0 -1)
+                                                      (v128.const i16x8 -1 0 -1 0 -1 0 -1 0))
+                                                      (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 0 0 0)
+                                                      (v128.const i32x4 0 0 0 0))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 -1 -1 -1 -1)
+                                                      (v128.const i32x4 -1 -1 -1 -1))
+                                                      (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.xor" (v128.const i32x4 0 -1 0 -1)
+                                                      (v128.const i32x4 -1 0 -1 0))
+                                                      (i32.const 1))
+;; all_true with v128.bitselect
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i8x16_all_true_with_v128.bitselect" (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i16x8_all_true_with_v128.bitselect" (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i16x8 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                                                            (v128.const i16x8 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55))
+                                                            (i32.const 0))
+(assert_return (invoke "i32x4_all_true_with_v128.bitselect" (v128.const i32x4 0xAA 0xAA 0xAA 0xAA)
+                                                            (v128.const i32x4 0x55 0x55 0x55 0x55)
+                                                            (v128.const i32x4 0xAA 0xAA 0xAA 0xAA))
+                                                            (i32.const 1))
+
+;; Type check
+
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i16x8.all_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (v128.any_true (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.all_true (i32.const 0)))) "type mismatch")
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f32x4.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.any_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result i32) (f64x2.all_true (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.all_true-arg-empty (result v128)
+      (i8x16.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.all_true-arg-empty (result v128)
+      (i16x8.all_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $v128.any_true-arg-empty (result v128)
+      (v128.any_true)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.all_true-arg-empty (result v128)
+      (i32x4.all_true)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_const.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_const.wast
new file mode 100644
index 0000000..8080cfb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_const.wast
@@ -0,0 +1,1664 @@
+;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4))
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))
+(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))
+(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))
+(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))
+(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))
+(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))
+(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))
+(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))
+(module (func (v128.const i16x8  0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop))
+(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))
+(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))
+(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))
+(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))
+(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))
+(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))
+(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))
+(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))
+(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))
+(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))
+(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))
+(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))
+(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))
+(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))
+(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))
+(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))
+(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))
+(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))
+(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))
+(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))
+(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))
+(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))
+(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))
+(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))
+(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))
+(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))
+(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))
+(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))
+(module (func (v128.const f64x2  1e308  1e308) drop))
+(module (func (v128.const f64x2 -1e308 -1e308) drop))
+(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))
+(module (func (v128.const f64x2 0123456789 0123456789) drop))
+(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f64x2 0123456789. 0123456789.) drop))
+(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+
+;; Non-splat cases
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))
+(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))
+(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))
+(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))
+(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan -nan inf -inf) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))
+(module (func (v128.const f64x2 0x1p1023 -1e308) drop))
+(module (func (v128.const f64x2 nan -inf) drop))
+
+;; Constant out of range (int literal is too large)
+
+(module (memory 1))
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448"
+                "                         340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448"
+                "                        -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                         269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                        -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+;; More malformed v128.const forms
+(assert_malformed
+  (module quote "(func (v128.const) drop)")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const 0 0 0 0) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i16x8) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+;; too little arguments
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)")
+  "wrong number of lane literals"
+)
+
+;; too many arguments
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)")
+  "wrong number of lane literals"
+)
+
+;; Rounding behaviour
+
+;; f32x4, small exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50))
+
+;; f32x4, large exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+;; f32x4, subnormal
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126))
+
+;; f32x4, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+
+;; f64x2, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60))
+
+;; f64x2, subnormal
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022))
+
+;; f64x2, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+
+;; As parameters of control constructs
+
+(module (memory 1)
+  (func (export "as-br-retval") (result v128)
+    (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)))
+  )
+  (func (export "as-br_if-retval") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval") (result v128)
+    (return (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-if-then-retval") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3))
+  (func (export "as-call-param") (result v128)
+    (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-block-retval") (result v128)
+    (block (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-loop-retval") (result v128)
+    (loop (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-drop-operand")
+    (drop (v128.const i32x4 0 1 2 3))
+  )
+
+  (func (export "as-br-retval2") (result v128)
+    (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)))
+  )
+  (func (export "as-br_if-retval2") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i64x2 0 1) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval2") (result v128)
+    (return (v128.const i64x2 0 1))
+  )
+  (func (export "as-if-then-retval2") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval2") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1))
+  (func (export "as-call-param2") (result v128)
+    (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1))
+  )
+
+  (type $sig (func (param v128 v128 v128) (result v128)))
+  (table funcref (elem $f $f2))
+  (func (export "as-call_indirect-param") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-param2") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1)
+    )
+  )
+  (func (export "as-block-retval2") (result v128)
+    (block (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-loop-retval2") (result v128)
+    (loop (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-drop-operand2")
+    (drop (v128.const i64x2 0 1))
+  )
+)
+
+(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0))
+(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))
+(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0))
+(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-drop-operand2"))
+
+;; v128 locals
+
+(module (memory 1)
+  (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 3)
+  )
+  (func (export "as-local.tee-value") (result v128)
+    (local v128)
+    (local.tee 0 (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3))
+
+
+;; v128 globals
+
+(module (memory 1)
+  (global $g0 (mut v128) (v128.const i32x4 0 1 2 3))
+  (global $g1 (mut v128) (v128.const i32x4 4 5 6 7))
+  (global $g2 (mut v128) (v128.const i32x4 8 9 10 11))
+  (global $g3 (mut v128) (v128.const i32x4 12 13 14 15))
+  (global $g4 (mut v128) (v128.const i32x4 16 17 18 19))
+
+  (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128)
+    (global.set $g0 (local.get $0))
+  )
+  (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128)
+    (global.set $g1 (local.get $0))
+    (global.set $g2 (local.get $1))
+  )
+  (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128)
+    (call $set_g0 (local.get $0))
+    (call $set_g1_g2 (local.get $1) (local.get $2))
+    (global.set $g3 (local.get $3))
+  )
+  (func (export "global.get_g0") (result v128)
+    (global.get $g0)
+  )
+  (func (export "global.get_g1") (result v128)
+    (global.get $g1)
+  )
+  (func (export "global.get_g2") (result v128)
+    (global.get $g2)
+  )
+  (func (export "global.get_g3") (result v128)
+    (global.get $g3)
+  )
+)
+
+(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1)
+                                                             (v128.const i32x4 2 2 2 2)
+                                                             (v128.const i32x4 3 3 3 3)
+                                                             (v128.const i32x4 4 4 4 4)))
+(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3))
+(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4))
+
+
+;; Test integer literal parsing.
+
+(module
+  (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D)))
+  (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)))
+  (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)))
+  (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1))))
+  (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0)))
+  (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010)))
+  (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42)))
+
+  (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+
+  (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D)))
+  (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)))
+  (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)))
+  (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1))))
+  (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0)))
+  (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010)))
+  (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42)))
+
+  (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000))
+  (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0))
+  (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99))
+  (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f))
+)
+
+(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365))
+(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10))
+(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42))
+
+(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000))
+(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+
+(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405))
+(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010))
+(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42))
+
+(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000))
+(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000))
+(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099))
+(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))")
+  "unknown operator"
+)
+
+;; Test floating-point literal parsing.
+
+(module
+  (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592))
+  (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3))
+  (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+  (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000))
+  (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0))
+  (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592))
+  (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3))
+  (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000))
+(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13))
+(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000))
+(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000))
+(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13))
+(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+;; Test parsing an integer from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\38\78\31\36\00\00"  ;; export name (parse_i8x16)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0~3   (0,    0,    0,    0)
+  "\80\80\80\80"                             ;; data lane 4~7   (-128, -128, -128, -128)
+  "\ff\ff\ff\ff"                             ;; data lane 8~11  (0xff, 0xff, 0xff, 0xff)
+  "\ff\ff\ff\ff"                             ;; data lane 12~15 (255,  255,  255,  255)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\31\36\78\38\00\00"  ;; export name (parse_i16x8)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0, 1 (0,      0)
+  "\00\80\00\80"                             ;; data lane 2, 3 (-32768, -32768)
+  "\ff\ff\ff\ff"                             ;; data lane 4, 5 (65535,  65535)
+  "\ff\ff\ff\ff"                             ;; data lane 6, 7 (0xffff, 0xffff)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\33\32\78\34\00\00"  ;; export name (parse_i32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\d1\ff\ff\ff"                             ;; data lane 0 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 1 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 2 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\36\34\78\32\00\00"  ;; export name (parse_i64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 0 (9223372036854775807)
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 1 (9223372036854775807)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807))
+
+;; Test parsing a float from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\33\32\78\34\00\00"  ;; export name (parse_f32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\80\4f"                             ;; data lane 0 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 1 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 2 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\36\34\78\32\00\00"  ;; export name (parse_f64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 0 (0x1.fffffffffffffp+1023)
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 1 (0x1.fffffffffffffp+1023)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_conversions.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_conversions.wast
new file mode 100644
index 0000000..552e943
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_conversions.wast
@@ -0,0 +1,899 @@
+;; Web Assembly SIMD-related type conversion tests
+
+(module
+  ;; Integer to floating point
+  (func (export "f32x4.convert_i32x4_s") (param v128) (result v128)
+    (f32x4.convert_i32x4_s (local.get 0)))
+  (func (export "f32x4.convert_i32x4_u") (param v128) (result v128)
+    (f32x4.convert_i32x4_u (local.get 0)))
+
+  (func (export "f64x2.convert_low_i32x4_s") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_s (local.get 0)))
+  (func (export "f64x2.convert_low_i32x4_u") (param v128) (result v128)
+    (f64x2.convert_low_i32x4_u (local.get 0)))
+
+  ;; Integer to integer narrowing
+  (func (export "i8x16.narrow_i16x8_s") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.narrow_i16x8_u") (param v128 v128) (result v128)
+    (i8x16.narrow_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_s") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.narrow_i32x4_u") (param v128 v128) (result v128)
+    (i16x8.narrow_i32x4_u (local.get 0)(local.get 1)))
+
+  ;; Float to float promote/demote
+  (func (export "f64x2.promote_low_f32x4") (param v128) (result v128)
+    (f64x2.promote_low_f32x4 (local.get 0)))
+  (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128)
+    (f32x4.demote_f64x2_zero (local.get 0)))
+)
+
+;; f64x2.promote_low_f32x4
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const f64x2 0x1p-149 0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const f64x2 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+;; Generated randomly by picking a random int and reinterpret it to float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1p-119 0x1p-119 0x1p-119 0x1p-119))
+                                                 (v128.const f64x2 0x1p-119 0x1p-119))
+;; Generated randomly by picking a random float.
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f64x2 6.6382536710104395e+37 6.6382536710104395e+37))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 inf inf inf inf))
+                                                 (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan nan nan nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.promote_low_f32x4" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                                 (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+;; f32x4.demote_f64x2_zero
+;; Float constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0.0 0.0))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0.0 -0.0))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 1.0 1.0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -1.0 -1.0))
+                                                 (v128.const f32x4 -1.0 -1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffe0000000p-127 0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 0x1p-126 0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffe0000000p-127 -0x1.fffffe0000000p-127))
+                                                 (v128.const f32x4 -0x1p-126 -0x1p-126 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffdfffffffp-127 0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 0x1.fffffcp-127 0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffdfffffffp-127 -0x1.fffffdfffffffp-127))
+                                                 (v128.const f32x4 -0x1.fffffcp-127 -0x1.fffffcp-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000000p+127 0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 0x1.fffffcp+127 0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000000p+127 -0x1.fffffd0000000p+127))
+                                                 (v128.const f32x4 -0x1.fffffcp+127 -0x1.fffffcp+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffd0000001p+127 0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffd0000001p+127 -0x1.fffffd0000001p+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffefffffffp+127 0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.fffffefffffffp+127 -0x1.fffffefffffffp+127))
+                                                 (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.ffffffp+127 0x1.ffffffp+127))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.ffffffp+127 -0x1.ffffffp+127))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-119 0x1p-119))
+                                                 (v128.const f32x4 0x1p-119 0x1p-119 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.8f867ep+125 0x1.8f867ep+125))
+                                                 (v128.const f32x4 0x1.8f867ep+125 0x1.8f867ep+125 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 inf inf))
+                                                 (v128.const f32x4 inf inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -inf -inf))
+                                                 (v128.const f32x4 -inf -inf 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p+0 0x1.0000000000001p+0))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.fffffffffffffp-1 0x1.fffffffffffffp-1))
+                                                 (v128.const f32x4 1.0 1.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+0 0x1.0000010000000p+0))
+                                                 (v128.const f32x4 0x1.000000p+0 0x1.000000p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+0 0x1.0000010000001p+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+0 0x1.000002fffffffp+0))
+                                                 (v128.const f32x4 0x1.000002p+0 0x1.000002p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+0 0x1.0000030000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000050000000p+0 0x1.0000050000000p+0))
+                                                 (v128.const f32x4 0x1.000004p+0 0x1.000004p+0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000000p+24 0x1.0000010000000p+24))
+                                                 (v128.const f32x4 0x1.0p+24 0x1.0p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000010000001p+24 0x1.0000010000001p+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.000002fffffffp+24 0x1.000002fffffffp+24))
+                                                 (v128.const f32x4 0x1.000002p+24 0x1.000002p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000030000000p+24 0x1.0000030000000p+24))
+                                                 (v128.const f32x4 0x1.000004p+24 0x1.000004p+24 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.4eae4f7024c7p+108 0x1.4eae4f7024c7p+108))
+                                                 (v128.const f32x4 0x1.4eae5p+108 0x1.4eae5p+108 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.a12e71e358685p-113 0x1.a12e71e358685p-113))
+                                                 (v128.const f32x4 0x1.a12e72p-113 0x1.a12e72p-113 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.cb98354d521ffp-127 0x1.cb98354d521ffp-127))
+                                                 (v128.const f32x4 0x1.cb9834p-127 0x1.cb9834p-127 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.6972b30cfb562p+1 -0x1.6972b30cfb562p+1))
+                                                 (v128.const f32x4 -0x1.6972b4p+1 -0x1.6972b4p+1 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.bedbe4819d4c4p+112 -0x1.bedbe4819d4c4p+112))
+                                                 (v128.const f32x4 -0x1.bedbe4p+112 -0x1.bedbe4p+112 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan -nan))
+                                                 (v128.const f32x4 nan:canonical nan:canonical 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                                 (v128.const f32x4 nan:arithmetic nan:arithmetic 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0p-150 0x1.0p-150))
+                                                 (v128.const f32x4 0.0 0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0p-150 -0x1.0p-150))
+                                                 (v128.const f32x4 -0.0 -0.0 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 0x1.0000000000001p-150 0x1.0000000000001p-150))
+                                                 (v128.const f32x4 0x1p-149 0x1p-149 0 0))
+(assert_return (invoke "f32x4.demote_f64x2_zero" (v128.const f64x2 -0x1.0000000000001p-150 -0x1.0000000000001p-150))
+                                                 (v128.const f32x4 -0x1p-149 -0x1p-149 0 0))
+
+
+;; Integer to floating point
+;; f32x4.convert_i32x4_s
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 1234567890 1234567890 1234567890 1234567890))
+                                               (v128.const f32x4 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30 0x1.26580cp+30))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680 0x0_1234_5680))
+                                               (v128.const f32x4 305419904.0 305419904.0 305419904.0 305419904.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777217 -16777217 -16777217 -16777217))
+                                               (v128.const f32x4 -16777216.0 -16777216.0 -16777216.0 -16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 -16777219 -16777219 -16777219 -16777219))
+                                               (v128.const f32x4 -16777220.0 -16777220.0 -16777220.0 -16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_s" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 -1.0 2147483647.0 -2147483648.0))
+
+;; f32x4.convert_i32x4_u
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                               (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 1 1 1 1))
+                                               (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                               (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                                               (v128.const f32x4 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28 0x1.234568p+28))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000080 0x80000080 0x80000080 0x80000080))
+                                               (v128.const f32x4 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31 0x1.000000p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000081 0x80000081 0x80000081 0x80000081))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x80000082 0x80000082 0x80000082 0x80000082))
+                                               (v128.const f32x4 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31 0x1.000002p+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe80 0xfffffe80 0xfffffe80 0xfffffe80))
+                                               (v128.const f32x4 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31 0x1.fffffcp+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe81 0xfffffe81 0xfffffe81 0xfffffe81))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0xfffffe82 0xfffffe82 0xfffffe82 0xfffffe82))
+                                               (v128.const f32x4 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31 0x1.fffffep+31))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0_123_456_792 0_123_456_792 0_123_456_792 0_123_456_792))
+                                               (v128.const f32x4 123456792.0 123456792.0 123456792.0 123456792.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                               (v128.const f32x4 2427178496.0 2427178496.0 2427178496.0 2427178496.0))
+;; Test rounding directions.
+
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777217 16777217 16777217 16777217))
+                                               (v128.const f32x4 16777216.0 16777216.0 16777216.0 16777216.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 16777219 16777219 16777219 16777219))
+                                               (v128.const f32x4 16777220.0 16777220.0 16777220.0 16777220.0))
+(assert_return (invoke "f32x4.convert_i32x4_u" (v128.const i32x4 0 -1 0x7fffffff 0x80000000))
+                                               (v128.const f32x4 0.0 4294967295.0 2147483647.0 2147483648.0))
+
+;; f64x2.convert_i32x4_s
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 -2147483648 -2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_s" (v128.const i32x4 987654321 987654321 0 0))
+                                                   (v128.const f64x2 987654321 987654321))
+
+;; f64x2.convert_i32x4_u
+;; constants copied from test/core/conversions.wast.
+
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 0 0))
+                                                   (v128.const f64x2 2147483647 2147483647))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 0 0))
+                                                   (v128.const f64x2 2147483648 2147483648))
+(assert_return (invoke "f64x2.convert_low_i32x4_u" (v128.const i32x4 0xffffffff 0xffffffff 0 0))
+                                                   (v128.const f64x2 4294967295.0 4294967295.0))
+
+;; Integer to integer narrowing
+;; i8x16.narrow_i16x8_s
+
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x81 0x81 0x81 0x81 0x81 0x81 0x81 0x81))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                              (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                              (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+;; i8x16.narrow_i16x8_u
+
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                              (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e 0x7e))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                              (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                              (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                              (v128.const i16x8 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                              (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe 0xfe))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                              (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                              (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.narrow_i16x8_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                              (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                              (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+;; i16x8.narrow_i32x4_s
+
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7ffe 0x7ffe 0x7ffe 0x7ffe 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7ffe 0x7ffe 0x7ffe 0x7ffe))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8001 0x8001 0x8001 0x8001 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x7fff -0x7fff -0x7fff -0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8001 0x8001 0x8001 0x8001))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0x8000 0x8000 0x8000 0x8000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x7fff 0x7fff 0x7fff 0x7fff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000 -0x8000 -0x8000 -0x8000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8001 -0x8001 -0x8001 -0x8001)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 -0x8000000 -0x8000000 -0x8000000 -0x8000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.narrow_i32x4_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x7fff 0x7fff 0x7fff 0x7fff))
+;; i16x8.narrow_i32x4_u
+
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0 0 0 0))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                              (v128.const i32x4 -1 -1 -1 -1))
+                                              (v128.const i16x8 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 1 1 1 1))
+                                              (v128.const i16x8 0 0 0 0 1 1 1 1))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xfffe 0xfffe 0xfffe 0xfffe 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xfffe 0xfffe 0xfffe 0xfffe))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xfffe 0xfffe 0xfffe 0xfffe))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0xffff 0xffff 0xffff 0xffff)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x10000 0x10000 0x10000 0x10000)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0xffff 0xffff 0xffff 0xffff))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                              (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000)
+                                              (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                              (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                              (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.narrow_i32x4_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                              (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                              (v128.const i16x8 0 0 0 0 0xffff 0xffff 0xffff 0xffff))
+
+
+;; Unknown operator
+
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_sat_f32x4 (v128.const f32x4 0.0 0.0 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_s_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.trunc_u_sat_f32x4 (v128.const f32x4 -2.0 -1.0 1.0 2.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_s_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i32x4.convert_u_f32x4 (v128.const f32x4 -1 0 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_s (v128.const f64x2 0.0 0.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (i64x2.trunc_sat_f64x2_u (v128.const f64x2 -2.0 -1.0)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_s (v128.const i64x2 1 2)))")
+  "unknown operator")
+(assert_malformed (module quote
+  "(func (result v128) (f64x2.convert_i64x2_u (v128.const i64x2 1 2)))")
+  "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i8x16_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.narrow_i32x4 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.narrow_i16x8_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_low_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i8x16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.extend_high_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_low_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_low_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.extend_high_i16x8 (v128.const i16x8 0 0 0 0 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_s (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.extend_high_i32x4_u (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+
+
+;; Type mismatch
+
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.convert_i32x4_u (i64.const 0)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_s (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.narrow_i16x8_u (i32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.narrow_i32x4_s (f32.const 0.0) (f64.const 0.0)))) "type mismatch")
+
+
+;; Combinations
+
+(module
+  (func (export "f32x4_convert_i32x4_s_add") (param v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.add (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_s_sub") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.sub (local.get 0) (local.get 1))))
+  (func (export "f32x4_convert_i32x4_u_mul") (param  v128 v128) (result v128)
+    (f32x4.convert_i32x4_u (i32x4.mul (local.get 0) (local.get 1))))
+
+  (func (export "i16x8_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_s (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_u (local.get 0) (local.get 1))))
+  (func (export "i16x8_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i16x8.extend_low_i8x16_u (i8x16.narrow_i16x8_s (local.get 0) (local.get 1))))
+
+  (func (export "i32x4_low_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_ss") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_su") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_s (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_low_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_uu") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_u (local.get 0) (local.get 1))))
+  (func (export "i32x4_high_extend_narrow_us") (param v128 v128) (result v128)
+    (i32x4.extend_low_i16x8_u (i16x8.narrow_i32x4_s (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "f32x4_convert_i32x4_s_add" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 2 3 4 5))
+                                                   (v128.const f32x4 3.0 5.0 7.0 9.0))
+(assert_return (invoke "f32x4_convert_i32x4_s_sub" (v128.const i32x4 0 1 2 3)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const f32x4 -1.0 0.0 1.0 2.0))
+(assert_return (invoke "f32x4_convert_i32x4_u_mul" (v128.const i32x4 1 2 3 4)
+                                                   (v128.const i32x4 1 2 3 4))
+                                                   (v128.const f32x4 1.0 4.0 9.0 16.0))
+
+(assert_return (invoke "i16x8_low_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_low_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                    (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_ss" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0xff80 0xff80 0x7f 0xff80 0xff80 0xff80 0x7f 0xff80))
+(assert_return (invoke "i16x8_high_extend_narrow_su" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xffff 0 0 0 0xffff 0))
+(assert_return (invoke "i16x8_low_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x8000 0xffff -0x8000 -0x7fff 0x8000 0xffff))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_low_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                    (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                    (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+(assert_return (invoke "i16x8_high_extend_narrow_uu" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0xffff -0x8000 -0x7fff 0x7fff 0xffff))
+                                                     (v128.const i16x8 0 0 0xff 0 0 0 0xff 0))
+(assert_return (invoke "i16x8_high_extend_narrow_us" (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000)
+                                                     (v128.const i16x8 -0x8000 -0x7fff 0x7fff 0x8000 -0x8000 -0x7fff 0x7fff 0x8000))
+                                                     (v128.const i16x8 0x80 0x80 0x7f 0x80 0x80 0x80 0x7f 0x80))
+
+(assert_return (invoke "i32x4_low_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_low_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_ss" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0xffff8000 0xffff8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_su" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffffffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                    (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_low_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                    (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                    (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+(assert_return (invoke "i32x4_high_extend_narrow_uu" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0xffffffff))
+                                                     (v128.const i32x4 0 0 0xffff 0))
+(assert_return (invoke "i32x4_high_extend_narrow_us" (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000)
+                                                     (v128.const i32x4 -0x80000000 -0x7fffffff 0x7fffffff 0x8000000))
+                                                     (v128.const i32x4 0x8000 0x8000 0x7fff 0x7fff))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_s-arg-empty (result v128)
+      (f32x4.convert_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.convert_i32x4_u-arg-empty (result v128)
+      (f32x4.convert_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_s-arg-empty (result v128)
+      (i8x16.narrow_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-1st-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.narrow_i16x8_u-arg-empty (result v128)
+      (i8x16.narrow_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_s-arg-empty (result v128)
+      (i16x8.narrow_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-1st-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.narrow_i32x4_u-arg-empty (result v128)
+      (i16x8.narrow_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4.wast
new file mode 100644
index 0000000..819db8c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4.wast
@@ -0,0 +1,2407 @@
+;; Tests for f32x4 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.min") (param v128 v128) (result v128) (f32x4.min (local.get 0) (local.get 1)))
+  (func (export "f32x4.max") (param v128 v128) (result v128) (f32x4.max (local.get 0) (local.get 1)))
+  (func (export "f32x4.abs") (param v128) (result v128) (f32x4.abs (local.get 0)))
+  ;; f32x4.min const vs const
+  (func (export "f32x4.min_with_const_0") (result v128) (f32x4.min (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.min_with_const_1") (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.min_with_const_2") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.min_with_const_3") (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.min param vs const
+  (func (export "f32x4.min_with_const_5")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.min_with_const_6")(param v128) (result v128) (f32x4.min (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.min_with_const_7")(param v128) (result v128) (f32x4.min (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.min_with_const_8")(param v128) (result v128) (f32x4.min (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max const vs const
+  (func (export "f32x4.max_with_const_10") (result v128) (f32x4.max (v128.const f32x4 0 1 2 -3) (v128.const f32x4 0 2 1 3)))
+  (func (export "f32x4.max_with_const_11") (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (v128.const f32x4 0 1 2 3)))
+  (func (export "f32x4.max_with_const_12") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x02 0x01 2147483648)))
+  (func (export "f32x4.max_with_const_13") (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+  ;; f32x4.max param vs const
+  (func (export "f32x4.max_with_const_15")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0 1 2 -3)))
+  (func (export "f32x4.max_with_const_16")(param v128) (result v128) (f32x4.max (v128.const f32x4 0 1 2 3) (local.get 0)))
+  (func (export "f32x4.max_with_const_17")(param v128) (result v128) (f32x4.max (v128.const f32x4 0x00 0x01 0x02 0x80000000) (local.get 0)))
+  (func (export "f32x4.max_with_const_18")(param v128) (result v128) (f32x4.max (local.get 0) (v128.const f32x4 0x00 0x01 0x02 0x80000000)))
+
+  (func (export "f32x4.abs_with_const") (result v128) (f32x4.abs (v128.const f32x4 -0 -1 -2 -3)))
+)
+
+;; f32x4.min const vs const
+(assert_return (invoke "f32x4.min_with_const_0") (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_1") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_2") (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_3") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.min param vs const
+(assert_return (invoke "f32x4.min_with_const_5" (v128.const f32x4 0 2 1 3))
+                                                (v128.const f32x4 0 1 1 -3))
+(assert_return (invoke "f32x4.min_with_const_6" (v128.const f32x4 0 1 2 3))
+                                                (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.min_with_const_7" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                (v128.const f32x4 0x00 0x01 0x01 0x80000000))
+(assert_return (invoke "f32x4.min_with_const_8" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max const vs const
+(assert_return (invoke "f32x4.max_with_const_10") (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_11") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_12") (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_13") (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+;; f32x4.max param vs const
+(assert_return (invoke "f32x4.max_with_const_15" (v128.const f32x4 0 2 1 3))
+                                                 (v128.const f32x4 0 2 2 3))
+(assert_return (invoke "f32x4.max_with_const_16" (v128.const f32x4 0 1 2 3))
+                                                 (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "f32x4.max_with_const_17" (v128.const f32x4 0x00 0x02 0x01 2147483648))
+                                                 (v128.const f32x4 0x00 0x02 0x02 2147483648))
+(assert_return (invoke "f32x4.max_with_const_18" (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+                                                 (v128.const f32x4 0x00 0x01 0x02 0x80000000))
+
+(assert_return (invoke "f32x4.abs_with_const") (v128.const f32x4 0 1 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.min
+(assert_return
+  (invoke "f32x4.min"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 0 0)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 1)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 1)
+)
+;; f32x4.max
+(assert_return
+  (invoke "f32x4.max"
+    (v128.const f32x4 nan 0 0 0)
+    (v128.const f32x4 0 -nan 1 0)
+  )
+  (v128.const f32x4 nan:canonical nan:canonical 1 0)
+)
+
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789)
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f32x4.min" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 -0 -0 -0))
+(assert_return (invoke "f32x4.min" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 -0 -0 -0 -0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 0 0 -0 +0)
+                                   (v128.const f32x4 +0 -0 +0 -0))
+                                   (v128.const f32x4 0 0 0 0))
+(assert_return (invoke "f32x4.max" (v128.const f32x4 -0 -0 -0 -0)
+                                   (v128.const f32x4 +0 +0 +0 +0))
+                                   (v128.const f32x4 +0 +0 +0 +0))
+
+
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.abs" (v128.const f32x4 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789 -0123456789.0123456789))
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.abs-arg-empty (result v128)
+      (f32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-1st-arg-empty (result v128)
+      (f32x4.min (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.min-arg-empty (result v128)
+      (f32x4.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-1st-arg-empty (result v128)
+      (f32x4.max (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.max-arg-empty (result v128)
+      (f32x4.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f32x4.max (f32x4.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f32x4.min (f32x4.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f32x4.max (f32x4.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f32x4.min (f32x4.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f32x4 -1.125 -1.125 -1.125 -1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast
new file mode 100644
index 0000000..56f80f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_arith.wast
@@ -0,0 +1,5476 @@
+;; Tests for f32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.add") (param v128 v128) (result v128) (f32x4.add (local.get 0) (local.get 1)))
+  (func (export "f32x4.sub") (param v128 v128) (result v128) (f32x4.sub (local.get 0) (local.get 1)))
+  (func (export "f32x4.mul") (param v128 v128) (result v128) (f32x4.mul (local.get 0) (local.get 1)))
+  (func (export "f32x4.div") (param v128 v128) (result v128) (f32x4.div (local.get 0) (local.get 1)))
+  (func (export "f32x4.neg") (param v128) (result v128) (f32x4.neg (local.get 0)))
+  (func (export "f32x4.sqrt") (param v128) (result v128) (f32x4.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 246913578.0 246913578.0 246913578.0 246913578.0))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 2.46913578e+27 2.46913578e+27 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 2.46913578e-11 2.46913578e-11 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 246913578.02469134 246913578.02469134 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57 0x1.23456789abcdfp+57))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76 0x1.23456789abcdfp+76))
+(assert_return (invoke "f32x4.add" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38 0x1.23456789abcdfp+38))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127 0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126 0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126 -0x1.0000020000000p-126))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127 -0x1.fffffc0000000p-127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2 0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2 0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2 0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2 0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2 -0x1.b21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2 -0x1.721fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2 -0x1.d21fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2 -0x1.521fb60000000p+2))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sub" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298 -0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298 0x1.0000000000000p-298))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275 -0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275 0x1.0000000000000p-275))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252 -0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252 0x1.0000000000000p-252))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150 -0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150 0x1.0000000000000p-150))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127 -0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127 0x1.0000000000000p-127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147 -0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147 0x1.921fb60000000p-147))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124 -0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124 0x1.921fb60000000p-124))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1 -0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1 0x1.921fb60000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5 -0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5 0x1.3bd3cdc2cab20p+5))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22 -0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22 0x1.fffffe0000000p-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1 -0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1 0x1.fffffe0000000p+1))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126 -0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126 0x1.fffffe0000000p+126))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16 1.5241579434344448e+16))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22 1.5241579025420272e-22))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112 0x1.4b66de0000000p+112))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.mul" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74 0x1.4b66de0000000p+74))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23 -0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23 0x1.0000000000000p-23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148 -0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148 0x1.0000000000000p-148))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152 -0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152 0x1.45f306446f9b4p-152))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277 -0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277 0x1.0000010000010p-277))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23 -0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23 0x1.0000000000000p+23))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125 -0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125 0x1.0000000000000p-125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129 -0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129 0x1.45f306446f9b4p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254 -0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254 0x1.0000010000010p-254))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125 -0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125 0x1.0000000000000p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4 -0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4 0x1.45f306446f9b4p-4))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129 -0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129 0x1.0000010000010p-129))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126 -0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126 0x1.0000000000000p+126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3 -0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3 0x1.45f306446f9b4p-3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128 -0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128 0x1.0000010000010p-128))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3 -0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3 0x1.921fb60000000p+3))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126 -0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126 0x1.921fb7921fb79p-126))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125 -0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125 0x1.45f304fe7c950p+125))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan nan nan nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan -nan -nan -nan)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 inf inf inf inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -inf -inf -inf -inf)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                   (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                   (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                   (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                   (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                   (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                   (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                   (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                   (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.div" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                   (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75 0x1.6a09e667f3bcdp-75))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63 0x1.0000000000000p-63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1 0x1.40d9324a48138p+1))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63 0x1.fffffeffffffcp+63))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 11111.111060555555 11111.111060555555 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 35136418286444.62 35136418286444.62 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 11111.11106111111 11111.11106111111 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 35136418288201.445 35136418288201.445 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28 0x1.1111111111111p+28))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37 0x1.822cb17ff2eb8p+37))
+(assert_return (invoke "f32x4.sqrt" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18 0x1.822cb17ff2eb8p+18))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                   (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                   (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                   (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                   (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                   (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                   (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                   (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                   (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                   (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                   (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                   (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                   (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                   (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                   (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 inf inf inf inf))
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan nan nan nan))
+                                   (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan -nan -nan -nan))
+                                   (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                   (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                   (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                   (v128.const f32x4 -123456789.0 -123456789.0 -123456789.0 -123456789.0))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f32x4 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f32x4 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f32x4 -123456789.01234567 -123456789.01234567 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f32x4 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f32x4 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56 -0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75 -0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.neg" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                   (v128.const f32x4 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37 -0x1.23456789abcdfp+37))
+
+
+;; Mixed f32x4 tests when some lanes are NaNs
+(module
+
+  (func (export "f32x4_sqrt_arith") (result v128)
+    (f32x4.sqrt (v128.const f32x4 nan:0x200000 -nan:0x200000 16.0 25.0)))
+  (func (export "f32x4_sqrt_canon") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -1.0 nan 4.0 9.0)))
+  (func (export "f32x4_sqrt_mixed") (result v128)
+    (f32x4.sqrt (v128.const f32x4 -inf nan:0x200000 36.0 49.0)))
+)
+
+(assert_return (invoke "f32x4_sqrt_arith") (v128.const f32x4 nan:arithmetic nan:arithmetic 4.0 5.0))
+(assert_return (invoke "f32x4_sqrt_canon") (v128.const f32x4 nan:canonical nan:canonical 2.0 3.0))
+(assert_return (invoke "f32x4_sqrt_mixed") (v128.const f32x4 nan:canonical nan:arithmetic 6.0 7.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sqrt (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.div (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.neg-arg-empty (result v128)
+      (f32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sqrt-arg-empty (result v128)
+      (f32x4.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-1st-arg-empty (result v128)
+      (f32x4.add (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.add-arg-empty (result v128)
+      (f32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-1st-arg-empty (result v128)
+      (f32x4.sub (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.sub-arg-empty (result v128)
+      (f32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-1st-arg-empty (result v128)
+      (f32x4.mul (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.mul-arg-empty (result v128)
+      (f32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-1st-arg-empty (result v128)
+      (f32x4.div (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.div-arg-empty (result v128)
+      (f32x4.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f32x4.add (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f32x4.div (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f32x4.mul (f32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f32x4.sub (f32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f32x4.add (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f32x4.div (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f32x4.mul (f32x4.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f32x4.sub (f32x4.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 5.0 5.0 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 4 4 4 4)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 18.0 18.0 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 4.0 4.0 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f32x4 1.25 1.25 1.25 1.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 2.25 2.25 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 1.25 1.25 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.75 1.75 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -6 -6 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 6 6 6 6))
+(assert_return (invoke "mul-neg" (v128.const f32x4 1.5 1.5 1.5 1.5)
+                                 (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                 (v128.const f32x4 -0.375 -0.375 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 0.375 0.375 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f32x4 1.125 1.125 1.125 1.125)
+                                 (v128.const f32x4 0.125 0.125 0.125 0.125))
+                                 (v128.const f32x4 -1.25 -1.25 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f32x4 2.25 2.25 2.25 2.25)
+                                  (v128.const f32x4 0.25 0.25 0.25 0.25))
+                                  (v128.const f32x4 1.25 1.25 1.25 1.25))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast
new file mode 100644
index 0000000..9e9a873
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_cmp.wast
@@ -0,0 +1,8167 @@
+;; Test all the f32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (f32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (f32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x v128) (param $y v128) (result v128) (f32x4.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x v128) (param $y v128) (result v128) (f32x4.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x v128) (param $y v128) (result v128) (f32x4.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x v128) (param $y v128) (result v128) (f32x4.ge (local.get $x) (local.get $y)))
+)
+
+;; eq
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+
+;; ge
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan nan nan nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -inf -inf -inf -inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -nan -nan -nan -nan)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 inf inf inf inf)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan nan nan nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -inf -inf -inf -inf))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -nan -nan -nan -nan))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 inf inf inf inf))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                            (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                            (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; eq
+
+;; f32x4.eq  (f32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.eq  (f32x4) (i32x4)
+(assert_return (invoke "eq" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0 ))
+
+;; ne
+
+;; f32x4.ne  (f32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 -1 0 -1 -1))
+
+;; f32x4.ne  (f32x4) (i32x4)
+(assert_return (invoke "ne" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; lt
+
+;; f32x4.lt  (f32x4) (i8x16)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i16x8)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; f32x4.lt  (f32x4) (i32x4)
+(assert_return (invoke "lt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 0 0))
+
+;; le
+
+;; f32x4.le  (f32x4) (i8x16)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i16x8)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 0 0))
+
+;; f32x4.le  (f32x4) (i32x4)
+(assert_return (invoke "le" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 0 0))
+
+;; gt
+
+;; f32x4.gt  (f32x4) (i8x16)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i16x8)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; f32x4.gt  (f32x4) (i32x4)
+(assert_return (invoke "gt" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 0 0 -1 -1))
+
+;; ge
+
+;; f32x4.ge  (f32x4) (i8x16)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i8x16 -1 -1 -1 -1 0 0 0 0 1 1 1 1 2 2 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i16x8)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i16x8 -1 -1 0 0 1 1 2 2))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; f32x4.ge  (f32x4) (i32x4)
+(assert_return (invoke "ge" (v128.const f32x4 -1 0 1 2.0)
+                            (v128.const i32x4 3212836864 0 1 2))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (f32x4.eq (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ge (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.gt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.le (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.lt (i64.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.ne (i64.const 0) (f64.const 0)))) "type mismatch")
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ge (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (f4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+
+
+;; Combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f32x4.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (f32x4.eq
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.eq
+          (f32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (f32x4.ne
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt")
+    (drop
+      (f32x4.lt
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.lt
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le")
+    (drop
+      (f32x4.le
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.le
+          (f32x4.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt")
+    (drop
+      (f32x4.gt
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.gt
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge")
+    (drop
+      (f32x4.ge
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ge
+          (f32x4.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f32x4.ge
+        (f32x4.eq
+          (f32x4.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f32x4.ne
+          (f32x4.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f32x4.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt-in-block"))
+(assert_return (invoke "le-in-block"))
+(assert_return (invoke "gt-in-block"))
+(assert_return (invoke "ge-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt"))
+(assert_return (invoke "nested-le"))
+(assert_return (invoke "nested-gt"))
+(assert_return (invoke "nested-ge"))
+(assert_return (invoke "as-param"))
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.eq-1st-arg-empty (result v128)
+      (f32x4.eq (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.eq-arg-empty (result v128)
+      (f32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-1st-arg-empty (result v128)
+      (f32x4.ne (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ne-arg-empty (result v128)
+      (f32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-1st-arg-empty (result v128)
+      (f32x4.lt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.lt-arg-empty (result v128)
+      (f32x4.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-1st-arg-empty (result v128)
+      (f32x4.le (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.le-arg-empty (result v128)
+      (f32x4.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-1st-arg-empty (result v128)
+      (f32x4.gt (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.gt-arg-empty (result v128)
+      (f32x4.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-1st-arg-empty (result v128)
+      (f32x4.ge (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.ge-arg-empty (result v128)
+      (f32x4.ge)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast
new file mode 100644
index 0000000..b0f47b3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f32x4 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.pmin") (param v128 v128) (result v128) (f32x4.pmin (local.get 0) (local.get 1)))
+  (func (export "f32x4.pmax") (param v128 v128) (result v128) (f32x4.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmin" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149 0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149 -0x1.0000000000000p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126 0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126 -0x1.0000000000000p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2 -0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2 0x1.921fb60000000p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56 0x1.23456789abcdfp+56))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75 0x1.23456789abcdfp+75))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37 0x1.23456789abcdfp+37))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan nan nan nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan -nan -nan -nan)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 inf inf inf inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 -inf -inf -inf -inf)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+(assert_return (invoke "f32x4.pmax" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019)
+                                    (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.pmin-1st-arg-empty (result v128)
+      (f32x4.pmin (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmin-arg-empty (result v128)
+      (f32x4.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-1st-arg-empty (result v128)
+      (f32x4.pmax (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.pmax-arg-empty (result v128)
+      (f32x4.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast
new file mode 100644
index 0000000..e59f99a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f32x4_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f32x4 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f32x4.ceil") (param v128) (result v128) (f32x4.ceil (local.get 0)))
+  (func (export "f32x4.floor") (param v128) (result v128) (f32x4.floor (local.get 0)))
+  (func (export "f32x4.trunc") (param v128) (result v128) (f32x4.trunc (local.get 0)))
+  (func (export "f32x4.nearest") (param v128) (result v128) (f32x4.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                    (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                    (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                    (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                    (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                    (v128.const f32x4 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                    (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                    (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                    (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 inf inf inf inf))
+                                    (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -inf -inf -inf -inf))
+                                    (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                    (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f32x4 123456790.0 123456790.0 123456790.0 123456790.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                    (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                    (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                    (v128.const f32x4 156374987062.0 156374987062.0 156374987062.0 156374987062.0))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan nan nan nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan -nan -nan -nan))
+                                    (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.ceil" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                    (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.floor" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                     (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                     (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                     (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                     (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                     (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                     (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                     (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                     (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 inf inf inf inf))
+                                     (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -inf -inf -inf -inf))
+                                     (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                     (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                     (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                     (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan nan nan nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan -nan -nan -nan))
+                                     (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.trunc" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                     (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0p+0 0x0p+0 0x0p+0 0x0p+0))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x0p+0 -0x0p+0 -0x0p+0 -0x0p+0))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                       (v128.const f32x4 0x0.0p+0 0x0.0p+0 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                       (v128.const f32x4 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                       (v128.const f32x4 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                       (v128.const f32x4 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                       (v128.const f32x4 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                       (v128.const f32x4 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                       (v128.const f32x4 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127 0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                       (v128.const f32x4 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127 -0x1.fffffe0000000p+127))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 inf inf inf inf))
+                                       (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -inf -inf -inf -inf))
+                                       (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f32x4 1.23456789e+27 1.23456789e+27 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f32x4 123456789.0 123456789.0 123456789.0 123456789.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f32x4 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF))
+                                       (v128.const f32x4 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16 8.19855292164869e+16))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019))
+                                       (v128.const f32x4 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22 4.298402914185348e+22))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019))
+                                       (v128.const f32x4 156374987061.0 156374987061.0 156374987061.0 156374987061.0))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan nan nan nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan -nan -nan -nan))
+                                       (v128.const f32x4 nan:canonical nan:canonical nan:canonical nan:canonical))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 nan:0x200000 nan:0x200000 nan:0x200000 nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f32x4.nearest" (v128.const f32x4 -nan:0x200000 -nan:0x200000 -nan:0x200000 -nan:0x200000))
+                                       (v128.const f32x4 nan:arithmetic nan:arithmetic nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f32x4.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f32x4.ceil-arg-empty (result v128)
+      (f32x4.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.floor-arg-empty (result v128)
+      (f32x4.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.trunc-arg-empty (result v128)
+      (f32x4.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.nearest-arg-empty (result v128)
+      (f32x4.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2.wast
new file mode 100644
index 0000000..8ebd33b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2.wast
@@ -0,0 +1,2459 @@
+;; Tests for f64x2 [abs, min, max] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.min") (param v128 v128) (result v128) (f64x2.min (local.get 0) (local.get 1)))
+  (func (export "f64x2.max") (param v128 v128) (result v128) (f64x2.max (local.get 0) (local.get 1)))
+  (func (export "f64x2.abs") (param v128) (result v128) (f64x2.abs (local.get 0)))
+  ;; f64x2.min const vs const
+  (func (export "f64x2.min_with_const_0") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.min_with_const_1") (result v128) (f64x2.min (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.min_with_const_2") (result v128) (f64x2.min (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_3") (result v128) (f64x2.min (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_4") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.min_with_const_5") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.min_with_const_6") (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.min_with_const_7") (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.min param vs const
+  (func (export "f64x2.min_with_const_9") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.min_with_const_10") (param v128) (result v128) (f64x2.min (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.min_with_const_11") (param v128) (result v128) (f64x2.min (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.min_with_const_12") (param v128) (result v128) (f64x2.min (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.min_with_const_13") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_14") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.min_with_const_15") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.min_with_const_16") (param v128) (result v128) (f64x2.min (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  ;; f64x2.max const vs const
+  (func (export "f64x2.max_with_const_18") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 2)))
+  (func (export "f64x2.max_with_const_19") (result v128) (f64x2.max (v128.const f64x2 2 -3) (v128.const f64x2 1 3)))
+  (func (export "f64x2.max_with_const_20") (result v128) (f64x2.max (v128.const f64x2 0 1) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_21") (result v128) (f64x2.max (v128.const f64x2 2 3) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_22") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x02)))
+  (func (export "f64x2.max_with_const_23") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x01 2147483648)))
+  (func (export "f64x2.max_with_const_24") (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (v128.const f64x2 0x00 0x01)))
+  (func (export "f64x2.max_with_const_25") (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (v128.const f64x2 0x02 0x80000000)))
+  ;; f64x2.max param vs const
+  (func (export "f64x2.max_with_const_27") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 0 1)))
+  (func (export "f64x2.max_with_const_28") (param v128) (result v128) (f64x2.max (v128.const f64x2 2 -3) (local.get 0)))
+  (func (export "f64x2.max_with_const_29") (param v128) (result v128) (f64x2.max (v128.const f64x2 0 1) (local.get 0)))
+  (func (export "f64x2.max_with_const_30") (param v128) (result v128) (f64x2.max (local.get 0) (v128.const f64x2 2 3)))
+  (func (export "f64x2.max_with_const_31") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_32") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+  (func (export "f64x2.max_with_const_33") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x00 0x01) (local.get 0)))
+  (func (export "f64x2.max_with_const_34") (param v128) (result v128) (f64x2.max (v128.const f64x2 0x02 0x80000000) (local.get 0)))
+
+  (func (export "f64x2.abs_with_const_35") (result v128) (f64x2.abs (v128.const f64x2 -0 -1)))
+  (func (export "f64x2.abs_with_const_36") (result v128) (f64x2.abs (v128.const f64x2 -2 -3)))
+)
+
+;; f64x2.min const vs const
+(assert_return (invoke "f64x2.min_with_const_0") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_1") (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_2") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_3") (v128.const f64x2 2 3))
+;; f64x2.min param vs const
+(assert_return (invoke "f64x2.min_with_const_4") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_5") (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_6") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_7") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_9" (v128.const f64x2 0 2))
+                                                (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_10" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 1 -3))
+(assert_return (invoke "f64x2.min_with_const_11" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.min_with_const_12" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.min_with_const_13" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_14" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x01 0x80000000))
+(assert_return (invoke "f64x2.min_with_const_15" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.min_with_const_16" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+;; f64x2.max const vs const
+(assert_return (invoke "f64x2.max_with_const_18") (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_19") (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_20") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_21") (v128.const f64x2 2 3))
+;; f64x2.max param vs const
+(assert_return (invoke "f64x2.max_with_const_22") (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_23") (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_24") (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_25") (v128.const f64x2 0x02 0x80000000))
+(assert_return (invoke "f64x2.max_with_const_27" (v128.const f64x2 0 2))
+                                                 (v128.const f64x2 0 2))
+(assert_return (invoke "f64x2.max_with_const_28" (v128.const f64x2 1 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_29" (v128.const f64x2 0 1))
+                                                 (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.max_with_const_30" (v128.const f64x2 2 3))
+                                                 (v128.const f64x2 2 3))
+(assert_return (invoke "f64x2.max_with_const_31" (v128.const f64x2 0x00 0x02))
+                                                 (v128.const f64x2 0x00 0x02))
+(assert_return (invoke "f64x2.max_with_const_32" (v128.const f64x2 0x01 2147483648))
+                                                 (v128.const f64x2 0x02 2147483648))
+(assert_return (invoke "f64x2.max_with_const_33" (v128.const f64x2 0x00 0x01))
+                                                 (v128.const f64x2 0x00 0x01))
+(assert_return (invoke "f64x2.max_with_const_34" (v128.const f64x2 0x02 0x80000000))
+                                                 (v128.const f64x2 0x02 0x80000000))
+
+(assert_return (invoke "f64x2.abs_with_const_35") (v128.const f64x2 0 1))
+(assert_return (invoke "f64x2.abs_with_const_36") (v128.const f64x2 2 3))
+
+;; Test different lanes go through different if-then clauses
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 0)
+)
+;; f64x2.min
+(assert_return
+  (invoke "f64x2.min"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 nan 0)
+    (v128.const f64x2 0 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 0)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+;; f64x2.max
+(assert_return
+  (invoke "f64x2.max"
+    (v128.const f64x2 0 1)
+    (v128.const f64x2 -nan 1)
+  )
+  (v128.const f64x2 nan:canonical 1)
+)
+
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789)
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+
+;; Test opposite signs of zero
+(assert_return (invoke "f64x2.min" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.min" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 -0 -0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 0 0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 +0)
+                                   (v128.const f64x2 +0 -0))
+                                   (v128.const f64x2 0 0))
+(assert_return (invoke "f64x2.max" (v128.const f64x2 -0 -0)
+                                   (v128.const f64x2 +0 +0))
+                                   (v128.const f64x2 +0 +0))
+
+
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                   (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                   (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                   (v128.const f64x2 0123456789.e038 0123456789.e038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                   (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+(assert_return (invoke "f64x2.abs" (v128.const f64x2 -01234567890123456789.01234567890123456789 -01234567890123456789.01234567890123456789))
+                                   (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.abs (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.min (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.max (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.abs-arg-empty (result v128)
+      (f64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-1st-arg-empty (result v128)
+      (f64x2.min (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.min-arg-empty (result v128)
+      (f64x2.min)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-1st-arg-empty (result v128)
+      (f64x2.max (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.max-arg-empty (result v128)
+      (f64x2.max)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "max-min") (param v128 v128 v128) (result v128)
+    (f64x2.max (f64x2.min (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "min-max") (param v128 v128 v128) (result v128)
+    (f64x2.min (f64x2.max (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "max-abs") (param v128 v128) (result v128)
+    (f64x2.max (f64x2.abs (local.get 0)) (local.get 1)))
+  (func (export "min-abs") (param v128 v128) (result v128)
+    (f64x2.min (f64x2.abs (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "max-min" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "min-max" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
+(assert_return (invoke "max-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.125 1.125))
+(assert_return (invoke "min-abs" (v128.const f64x2 -1.125 -1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 0.125 0.125))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast
new file mode 100644
index 0000000..4ab3b01
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_arith.wast
@@ -0,0 +1,5483 @@
+;; Tests for f64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.add") (param v128 v128) (result v128) (f64x2.add (local.get 0) (local.get 1)))
+  (func (export "f64x2.sub") (param v128 v128) (result v128) (f64x2.sub (local.get 0) (local.get 1)))
+  (func (export "f64x2.mul") (param v128 v128) (result v128) (f64x2.mul (local.get 0) (local.get 1)))
+  (func (export "f64x2.div") (param v128 v128) (result v128) (f64x2.div (local.get 0) (local.get 1)))
+  (func (export "f64x2.neg") (param v128) (result v128) (f64x2.neg (local.get 0)))
+  (func (export "f64x2.sqrt") (param v128) (result v128) (f64x2.sqrt (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 246913578.0 246913578.0))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 2.46913578e+27 2.46913578e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 2.46913578e-11 2.46913578e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 246913578.02469134 246913578.02469134))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 2.4691357802469137e+27 2.4691357802469137e+27))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 2.4691357802469137e-11 2.4691357802469137e-11))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.23456789abcdfp+81 0x1.23456789abcdfp+81))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+100 0x1.23456789abcdfp+100))
+(assert_return (invoke "f64x2.add" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.23456789abcdfp+62 0x1.23456789abcdfp+62))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.fffffffffffffp-1022 0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000001p-1022 -0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.8000000000000p+0 0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.8000000000000p+0 -0x1.8000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.721fb54442d18p+2 0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.b21fb54442d18p+2 0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.521fb54442d18p+2 0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.d21fb54442d18p+2 0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.b21fb54442d18p+2 -0x1.b21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.721fb54442d18p+2 -0x1.721fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.d21fb54442d18p+2 -0x1.d21fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.521fb54442d18p+2 -0x1.521fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.fffffffffffffp-1022 -0x0.fffffffffffffp-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000001p-1022 0x1.0000000000001p-1022))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sub" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.8000000000000p-1022 -0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.8000000000000p-1022 0x0.8000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-2 -0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-2 0x1.0000000000000p-2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.921fb54442d18p-1020 -0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.921fb54442d18p-1020 0x1.921fb54442d18p-1020))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+1 -0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+1 0x1.921fb54442d18p+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.3bd3cc9be45dep+5 -0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.3bd3cc9be45dep+5 0x1.3bd3cc9be45dep+5))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1 -0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1 0x1.fffffffffffffp+1))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1022 -0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1022 0x1.fffffffffffffp+1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0000000000006p-1022 0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0000000000006p-1022 -0x0.0000000000006p-1022))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp-51 0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp-51 -0x1.fffffffffffffp-51))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.524157875019052e+16 1.524157875019052e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.524157875019052e+54 1.524157875019052e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.524157875019052e-22 1.524157875019052e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.5241578753238834e+16 1.5241578753238834e+16))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.5241578753238838e+54 1.5241578753238838e+54))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.524157875323884e-22 1.524157875323884e-22))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+160 0x1.4b66dc33f6acep+160))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+198 0x1.4b66dc33f6acep+198))
+(assert_return (invoke "f64x2.mul" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.4b66dc33f6acep+122 0x1.4b66dc33f6acep+122))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+52 0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1021 -0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1021 0x1.0000000000000p-1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.28be60db93910p-1022 -0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.28be60db93910p-1022 0x0.28be60db93910p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+52 -0x1.0000000000000p+52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1021 -0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1021 0x1.0000000000000p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-4 -0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-4 0x1.45f306dc9c883p-4))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.2000000000000p-1022 -0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.2000000000000p-1022 0x0.2000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p+1022 -0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+1022 0x1.0000000000000p+1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p+1 -0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p+1 0x1.0000000000000p+1))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c883p-3 -0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c883p-3 0x1.45f306dc9c883p-3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.4000000000000p-1022 -0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.4000000000000p-1022 0x0.4000000000000p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+3 -0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.921fb54442d18p+3 0x1.921fb54442d18p+3))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.921fb54442d19p-1022 -0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.921fb54442d19p-1022 0x1.921fb54442d19p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.45f306dc9c882p+1021 -0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.45f306dc9c882p+1021 0x1.45f306dc9c882p+1021))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-52 0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-52 -0x1.0000000000000p-52))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 0x0.0000000000002p-1022 0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan -nan)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0p+0 0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p-1 0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1p+0 0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 inf inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -inf -inf)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789 0123456789)
+                                   (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e019 0123456789e019)
+                                   (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                   (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                   (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789. 0123456789.)
+                                   (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                   (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                   (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                   (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                   (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                   (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                   (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                   (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.div" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                   (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-511 0x1.0000000000000p-511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.6a09e667f3bcdp-1 0x1.6a09e667f3bcdp-1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.40d931ff62705p+1 0x1.40d931ff62705p+1))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+511 0x1.fffffffffffffp+511))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-537 0x1.0000000000000p-537))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 11111.111060555555 11111.111060555555))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 35136418286444.62 35136418286444.62))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 3.5136418286444623e-06 3.5136418286444623e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 11111.11106111111 11111.11106111111))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 35136418288201.445 35136418288201.445))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 3.513641828820144e-06 3.513641828820144e-06))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.1111111111111p+40 0x1.1111111111111p+40))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+49 0x1.822cb17ff2eb8p+49))
+(assert_return (invoke "f64x2.sqrt" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.822cb17ff2eb8p+30 0x1.822cb17ff2eb8p+30))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0p+0 0x0p+0))
+                                   (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                   (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                   (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                   (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p-1 0x1p-1))
+                                   (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                   (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1p+0 0x1p+0))
+                                   (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                   (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                   (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                   (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                   (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 inf inf))
+                                   (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -inf -inf))
+                                   (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan nan))
+                                   (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan -nan))
+                                   (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                   (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                   (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789 0123456789))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e019 0123456789e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789. 0123456789.))
+                                   (v128.const f64x2 -123456789.0 -123456789.0))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                   (v128.const f64x2 -1.23456789e+27 -1.23456789e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                   (v128.const f64x2 -1.23456789e-11 -1.23456789e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                   (v128.const f64x2 -123456789.01234567 -123456789.01234567))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                   (v128.const f64x2 -1.2345678901234569e+27 -1.2345678901234569e+27))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                   (v128.const f64x2 -1.2345678901234568e-11 -1.2345678901234568e-11))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+80 -0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+99 -0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.neg" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                   (v128.const f64x2 -0x1.23456789abcdfp+61 -0x1.23456789abcdfp+61))
+
+;; Mixed f64x2 tests when some lanes are NaNs
+(module
+  (func (export "f64x2_add_arith") (result v128)
+    (f64x2.add (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_div_mixed") (result v128)
+    (f64x2.div (v128.const f64x2 nan 1.0) (v128.const f64x2 2.0 -nan:0x8000000000000)))
+  (func (export "f64x2_mul_mixed") (result v128)
+    (f64x2.mul (v128.const f64x2 nan:0x8000000000000 1.0) (v128.const f64x2 2.0 nan)))
+  (func (export "f64x2_neg_canon") (result v128)
+    (f64x2.neg (v128.const f64x2 nan 1.0)))
+  (func (export "f64x2_sqrt_canon") (result v128)
+    (f64x2.sqrt (v128.const f64x2 4.0 -nan)))
+  (func (export "f64x2_sub_arith") (result v128)
+    (f64x2.sub (v128.const f64x2 1.0 -1.0) (v128.const f64x2 -nan 1.0)))
+)
+
+(assert_return (invoke "f64x2_add_arith") (v128.const f64x2 nan:arithmetic 2.0))
+(assert_return (invoke "f64x2_div_mixed") (v128.const f64x2 nan:canonical nan:arithmetic))
+(assert_return (invoke "f64x2_mul_mixed") (v128.const f64x2 nan:arithmetic nan:canonical))
+(assert_return (invoke "f64x2_neg_canon") (v128.const f64x2 nan:canonical -1.0))
+(assert_return (invoke "f64x2_sqrt_canon") (v128.const f64x2 2.0 nan:canonical))
+(assert_return (invoke "f64x2_sub_arith") (v128.const f64x2 nan:canonical -2.0))
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.neg (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sqrt (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.add (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.sub (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.mul (i64.const 0) (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.div (i64.const 0) (f64.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.neg-arg-empty (result v128)
+      (f64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sqrt-arg-empty (result v128)
+      (f64x2.sqrt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-1st-arg-empty (result v128)
+      (f64x2.add (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.add-arg-empty (result v128)
+      (f64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-1st-arg-empty (result v128)
+      (f64x2.sub (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.sub-arg-empty (result v128)
+      (f64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-1st-arg-empty (result v128)
+      (f64x2.mul (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.mul-arg-empty (result v128)
+      (f64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-1st-arg-empty (result v128)
+      (f64x2.div (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.div-arg-empty (result v128)
+      (f64x2.div)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (f64x2.add (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-add") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-mul") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.mul (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "div-sub") (param v128 v128 v128) (result v128)
+    (f64x2.div (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-div") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.div (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (f64x2.mul (f64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (f64x2.sub (f64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "add-sqrt") (param v128 v128) (result v128)
+    (f64x2.add (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "div-neg") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "div-sqrt") (param v128 v128) (result v128)
+    (f64x2.div (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-sqrt") (param v128 v128) (result v128)
+    (f64x2.mul (f64x2.sqrt (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-sqrt") (param v128 v128) (result v128)
+    (f64x2.sub (f64x2.sqrt (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "div-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 5.0 5.0))
+(assert_return (invoke "div-mul" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 4 4)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 18.0 18.0))
+(assert_return (invoke "div-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 4.0 4.0))
+(assert_return (invoke "mul-add" (v128.const f64x2 1.25 1.25)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "mul-div" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 2.25 2.25))
+(assert_return (invoke "mul-sub" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 0.25 0.25))
+(assert_return (invoke "sub-add" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.25 0.25)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 1.25 1.25))
+(assert_return (invoke "add-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.0 -1.0))
+(assert_return (invoke "add-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.75 1.75))
+(assert_return (invoke "div-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -6 -6))
+(assert_return (invoke "div-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 6 6))
+(assert_return (invoke "mul-neg" (v128.const f64x2 1.5 1.5)
+                                 (v128.const f64x2 0.25 0.25))
+                                 (v128.const f64x2 -0.375 -0.375))
+(assert_return (invoke "mul-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 0.375 0.375))
+(assert_return (invoke "sub-neg" (v128.const f64x2 1.125 1.125)
+                                 (v128.const f64x2 0.125 0.125))
+                                 (v128.const f64x2 -1.25 -1.25))
+(assert_return (invoke "sub-sqrt" (v128.const f64x2 2.25 2.25)
+                                  (v128.const f64x2 0.25 0.25))
+                                  (v128.const f64x2 1.25 1.25))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast
new file mode 100644
index 0000000..cab815e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_cmp.wast
@@ -0,0 +1,8337 @@
+;; Tests for f64x2 comparison operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.eq") (param v128 v128) (result v128) (f64x2.eq (local.get 0) (local.get 1)))
+  (func (export "f64x2.ne") (param v128 v128) (result v128) (f64x2.ne (local.get 0) (local.get 1)))
+  (func (export "f64x2.lt") (param v128 v128) (result v128) (f64x2.lt (local.get 0) (local.get 1)))
+  (func (export "f64x2.le") (param v128 v128) (result v128) (f64x2.le (local.get 0) (local.get 1)))
+  (func (export "f64x2.gt") (param v128 v128) (result v128) (f64x2.gt (local.get 0) (local.get 1)))
+  (func (export "f64x2.ge") (param v128 v128) (result v128) (f64x2.ge (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1074 0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -inf -inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p+0 0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1074 -0x1p-1074)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1 0x1p-1)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x0p+0 0x0p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 inf inf)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e038 01234567890123456789e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e038 0123456789.e038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0123456789.e+038 0123456789.e+038)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e038 01234567890123456789e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789e-038 01234567890123456789e-038))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e038 0123456789.e038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 0123456789.e+038 0123456789.e+038))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789)
+                                  (v128.const f64x2 01234567890123456789.01234567890123456789 01234567890123456789.01234567890123456789))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan -nan)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1074 0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -inf -inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p+0 0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1074 -0x1p-1074))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1 0x1p-1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x0p+0 0x0p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 inf inf))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan -nan))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                  (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.eq" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ne" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.lt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.le" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.gt" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 -1 -1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 0 0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 1 1)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 0 0))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 -1 -1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 0 0))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 1 1))
+                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "f64x2.ge" (v128.const f64x2 2.0 2.0)
+                                  (v128.const f64x2 2.0 2.0))
+                                  (v128.const i64x2 -1 -1))
+
+
+;; unknown operators
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.lt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.le (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.gt (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func  (param $x v128) (param $y v128) (result v128) (f2x64.ge (local.get $x) (local.get $y)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.eq (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ne (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.lt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.le (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.gt (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.ge (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.eq-1st-arg-empty (result v128)
+      (f64x2.eq (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.eq-arg-empty (result v128)
+      (f64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-1st-arg-empty (result v128)
+      (f64x2.ne (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ne-arg-empty (result v128)
+      (f64x2.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-1st-arg-empty (result v128)
+      (f64x2.lt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.lt-arg-empty (result v128)
+      (f64x2.lt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-1st-arg-empty (result v128)
+      (f64x2.le (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.le-arg-empty (result v128)
+      (f64x2.le)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-1st-arg-empty (result v128)
+      (f64x2.gt (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.gt-arg-empty (result v128)
+      (f64x2.gt)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-1st-arg-empty (result v128)
+      (f64x2.ge (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.ge-arg-empty (result v128)
+      (f64x2.ge)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module (memory 1)
+  (func (export "f64x2.eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.lt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.lt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.le-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.le
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.gt-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.gt
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "f64x2.ge-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (f64x2.ge
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.eq")
+    (drop
+      (f64x2.eq
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.eq
+          (f64x2.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ne")
+    (drop
+      (f64x2.ne
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ne
+          (f64x2.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.lt")
+    (drop
+      (f64x2.lt
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.lt
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.lt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.le")
+    (drop
+      (f64x2.le
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.le
+          (f64x2.le
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.gt")
+    (drop
+      (f64x2.gt
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.gt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.gt
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-f64x2.ge")
+    (drop
+      (f64x2.ge
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.ge
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.ge
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (f64x2.eq
+        (f64x2.ne
+          (f64x2.lt
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.le
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (f64x2.gt
+          (f64x2.ge
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (f64x2.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "f64x2.eq-in-block"))
+(assert_return (invoke "f64x2.ne-in-block"))
+(assert_return (invoke "f64x2.lt-in-block"))
+(assert_return (invoke "f64x2.le-in-block"))
+(assert_return (invoke "f64x2.gt-in-block"))
+(assert_return (invoke "f64x2.ge-in-block"))
+(assert_return (invoke "nested-f64x2.eq"))
+(assert_return (invoke "nested-f64x2.ne"))
+(assert_return (invoke "nested-f64x2.lt"))
+(assert_return (invoke "nested-f64x2.le"))
+(assert_return (invoke "nested-f64x2.gt"))
+(assert_return (invoke "nested-f64x2.ge"))
+(assert_return (invoke "as-param"))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast
new file mode 100644
index 0000000..e8167b0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_pmin_pmax.wast
@@ -0,0 +1,11676 @@
+;; Tests for f64x2 [pmin, pmax] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.pmin") (param v128 v128) (result v128) (f64x2.pmin (local.get 0) (local.get 1)))
+  (func (export "f64x2.pmax") (param v128 v128) (result v128) (f64x2.pmax (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmin" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p-1022 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x1.0000000000000p-1022 -0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x1.0000000000000p-1 -0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd62b4311p-37 0x1.b25ffd62b4311p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p-1 0x1.0000000000000p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.d6f3454000000p+26 0x1.d6f3454000000p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.d6f34540ca458p+26 0x1.d6f34540ca458p+26))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.b25ffd636ec12p-37 0x1.b25ffd636ec12p-37))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 0x1.fe9af5b5e16fap+89 0x1.fe9af5b5e16fap+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 0x1.fe9af5b6bcbd5p+89 0x1.fe9af5b6bcbd5p+89))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 0x1.23456789abcdfp+80 0x1.23456789abcdfp+80))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+99 0x1.23456789abcdfp+99))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 0x1.23456789abcdfp+61 0x1.23456789abcdfp+61))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan -nan)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0p+0 0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0p+0 0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x0p+0 -0x0p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x0p+0 -0x0p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1022 0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1022 -0x1p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p-1 0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p-1 -0x1p-1)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1p+0 0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1p+0 -0x1p+0)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 inf inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 -inf -inf)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789 0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e019 0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e+019 0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789e-019 0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789e-019 0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789. 0123456789.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e019 0123456789.e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e019 0123456789.e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e+019 0123456789.e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.e-019 0123456789.e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+(assert_return (invoke "f64x2.pmax" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019)
+                                    (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmin (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.pmax (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.pmin (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.pmax (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.pmin-1st-arg-empty (result v128)
+      (f64x2.pmin (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmin-arg-empty (result v128)
+      (f64x2.pmin)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-1st-arg-empty (result v128)
+      (f64x2.pmax (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.pmax-arg-empty (result v128)
+      (f64x2.pmax)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast
new file mode 100644
index 0000000..f82c6d2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_f64x2_rounding.wast
@@ -0,0 +1,424 @@
+;; Tests for f64x2 [ceil, floor, trunc, nearest] operations on major boundary values and all special values.
+
+
+(module
+  (func (export "f64x2.ceil") (param v128) (result v128) (f64x2.ceil (local.get 0)))
+  (func (export "f64x2.floor") (param v128) (result v128) (f64x2.floor (local.get 0)))
+  (func (export "f64x2.trunc") (param v128) (result v128) (f64x2.trunc (local.get 0)))
+  (func (export "f64x2.nearest") (param v128) (result v128) (f64x2.nearest (local.get 0)))
+)
+
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0p+0 0x0p+0))
+                                    (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p-1 0x1p-1))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                    (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1p+0 0x1p+0))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                    (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 0x1.c000000000000p+2 0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                    (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                    (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                    (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 inf inf))
+                                    (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -inf -inf))
+                                    (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789 0123456789))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e019 0123456789e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789. 0123456789.))
+                                    (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                    (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                    (v128.const f64x2 123456790.0 123456790.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                    (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                    (v128.const f64x2 1.0 1.0))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                    (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                    (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                    (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan -nan))
+                                    (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.ceil" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                    (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.c000000000000p+2 -0x1.c000000000000p+2))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.floor" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0p+0 0x0p+0))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p-1 0x1p-1))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                     (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1p+0 0x1p+0))
+                                     (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                     (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                     (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                     (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                     (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 inf inf))
+                                     (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -inf -inf))
+                                     (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789 0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e019 0123456789e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789. 0123456789.))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                     (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                     (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                     (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                     (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                     (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                     (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                     (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan -nan))
+                                     (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.trunc" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                     (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0p+0 0x0p+0))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x0p+0 -0x0p+0))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1022 0x1p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p-1 0x1p-1))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                       (v128.const f64x2 -0x0.0p+0 -0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1p+0 0x1p+0))
+                                       (v128.const f64x2 0x1.0000000000000p+0 0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                       (v128.const f64x2 -0x1.0000000000000p+0 -0x1.0000000000000p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 0x1.8000000000000p+2 0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+                                       (v128.const f64x2 -0x1.8000000000000p+2 -0x1.8000000000000p+2))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+                                       (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+                                       (v128.const f64x2 0x0.0p+0 0x0.0p+0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 inf inf))
+                                       (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -inf -inf))
+                                       (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789 0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e019 0123456789e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e+019 0123456789e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789e-019 0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789. 0123456789.))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e019 0123456789.e019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e+019 0123456789.e+019))
+                                       (v128.const f64x2 1.23456789e+27 1.23456789e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.e-019 0123456789.e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789 0123456789.0123456789))
+                                       (v128.const f64x2 123456789.0 123456789.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019))
+                                       (v128.const f64x2 1.2345678901234569e+27 1.2345678901234569e+27))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019))
+                                       (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef))
+                                       (v128.const f64x2 1.3754889325393114e+24 1.3754889325393114e+24))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019))
+                                       (v128.const f64x2 7.211523414631705e+29 7.211523414631705e+29))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+                                       (v128.const f64x2 2.6235369349275807e+18 2.6235369349275807e+18))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan -nan))
+                                       (v128.const f64x2 nan:canonical nan:canonical))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+(assert_return (invoke "f64x2.nearest" (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+                                       (v128.const f64x2 nan:arithmetic nan:arithmetic))
+
+
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.ceil (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.floor (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.trunc (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.nearest (v128.const i32x4 0 0 0 0)))") "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (f64x2.ceil (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.floor (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.trunc (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.nearest (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $f64x2.ceil-arg-empty (result v128)
+      (f64x2.ceil)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.floor-arg-empty (result v128)
+      (f64x2.floor)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.trunc-arg-empty (result v128)
+      (f64x2.trunc)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.nearest-arg-empty (result v128)
+      (f64x2.nearest)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast
new file mode 100644
index 0000000..3dc4d5e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add") (param v128 v128) (result v128) (i16x8.add (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub") (param v128 v128) (result v128) (i16x8.sub (local.get 0) (local.get 1)))
+  (func (export "i16x8.mul") (param v128 v128) (result v128) (i16x8.mul (local.get 0) (local.get 1)))
+  (func (export "i16x8.neg") (param v128) (result v128) (i16x8.neg (local.get 0)))
+)
+
+
+;; i16x8.add
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80 0x8000 0xbf80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80 0x8000 0x3f80))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                   (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+
+;; i16x8.sub
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i8x16 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80 0 0x80))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i32x4 0x80008000 0x80008000 0x80008000 0x80008000))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x02 0x02 0x02 0x02 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080 0x8000 0x4080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080 0x8000 0xc080))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                   (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+                                   (v128.const i16x8 044_444 044_444 044_444 044_444 044_444 044_444 044_444 044_444))
+(assert_return (invoke "i16x8.sub" (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678)
+                                   (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+                                   (v128.const i16x8 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444 0x0_4444))
+
+;; i16x8.mul
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                   (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                   (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000 0x1000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const i32x4 0x00020002 0x00020002 0x00020002 0x00020002))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i16x8 0 0x7f80 0 0x7f80 0 0x7f80 0 0x7f80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i16x8 0 0xff80 0 0xff80 0 0xff80 0 0xff80))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i16x8 0 0x7fc0 0 0x7fc0 0 0x7fc0 0 0x7fc0))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                   (v128.const i16x8 0 0xffff 0xfffc 0xfff7 0xfff0 0xffe7 0xffdc 0xffcf))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                   (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                   (v128.const i16x8 0 0x02 0x08 0x12 0x20 0x32 0x48 0x62))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                   (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                   (v128.const i16x8 021_613 021_613 021_613 021_613 021_613 021_613 021_613 021_613))
+(assert_return (invoke "i16x8.mul" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                   (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                   (v128.const i16x8 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c 0x0_a28c))
+
+;; i16x8.neg
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                   (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff -0x7fff))
+                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.neg" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.neg-arg-empty (result v128)
+      (i16x8.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-1st-arg-empty (result v128)
+      (i16x8.add (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add-arg-empty (result v128)
+      (i16x8.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-1st-arg-empty (result v128)
+      (i16x8.sub (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub-arg-empty (result v128)
+      (i16x8.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-1st-arg-empty (result v128)
+      (i16x8.mul (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.mul-arg-empty (result v128)
+      (i16x8.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i16x8.add (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i16x8.mul (i16x8.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i16x8.sub (i16x8.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i16x8.add (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i16x8.mul (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i16x8.sub (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "mul-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 4 8 12 16 20 24 28))
+(assert_return (invoke "mul-sub" (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 1 4 9 16 25 36 49))
+(assert_return (invoke "sub-add" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14)
+                                 (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "add-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
+(assert_return (invoke "sub-neg" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                 (v128.const i16x8 0 1 2 3 4 5 6 7))
+                                 (v128.const i16x8 0 -2 -4 -6 -8 -10 -12 -14))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast
new file mode 100644
index 0000000..454f598
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_arith2.wast
@@ -0,0 +1,610 @@
+;; Tests for i16x8 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i16x8.min_s") (param v128 v128) (result v128) (i16x8.min_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.min_u") (param v128 v128) (result v128) (i16x8.min_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_s") (param v128 v128) (result v128) (i16x8.max_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.max_u") (param v128 v128) (result v128) (i16x8.max_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.abs") (param v128) (result v128) (i16x8.abs (local.get 0)))
+  (func (export "i16x8.min_s_with_const_0") (result v128) (i16x8.min_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_s_with_const_1") (result v128) (i16x8.min_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.min_u_with_const_2") (result v128) (i16x8.min_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.min_u_with_const_3") (result v128) (i16x8.min_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_s_with_const_4") (result v128) (i16x8.max_s (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_s_with_const_5") (result v128) (i16x8.max_s (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.max_u_with_const_6") (result v128) (i16x8.max_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.max_u_with_const_7") (result v128) (i16x8.max_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.avgr_u_with_const_8") (result v128) (i16x8.avgr_u (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535) (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768)))
+  (func (export "i16x8.avgr_u_with_const_9") (result v128) (i16x8.avgr_u (v128.const i16x8 0 0 1 1 2 2 3 3) (v128.const i16x8 3 3 2 2 1 1 0 0)))
+  (func (export "i16x8.abs_with_const_10") (result v128) (i16x8.abs (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_11") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_s_with_const_12") (param v128) (result v128) (i16x8.min_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.min_u_with_const_13") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.min_u_with_const_14") (param v128) (result v128) (i16x8.min_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_s_with_const_15") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_s_with_const_16") (param v128) (result v128) (i16x8.max_s (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.max_u_with_const_17") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.max_u_with_const_18") (param v128) (result v128) (i16x8.max_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+  (func (export "i16x8.avgr_u_with_const_19") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)))
+  (func (export "i16x8.avgr_u_with_const_20") (param v128) (result v128) (i16x8.avgr_u (local.get 0) (v128.const i16x8 0 0 1 1 2 2 3 3)))
+)
+
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 0 0 0 0 -1 -1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                     (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                     (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                     (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                     (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                     (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                     (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                     (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                     (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                     (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1)
+                                      (v128.const i16x8 0 0 -1 -1 0 0 -1 -1))
+                                      (v128.const i16x8 0 0 32768 32768 32768 32768 65535 65535))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                      (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                      (v128.const i16x8 128 128 128 128 128 128 128 128))
+                                      (v128.const i16x8 32832 32832 32832 32832 32832 32832 32832 32832))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                      (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                      (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 123 123 123 123 123 123 123 123)
+                                      (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i16x8 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                   (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                   (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i16x8 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i16x8 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i16x8 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i16x8 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i16x8.min_s_with_const_0") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_1") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_2") (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_3") (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_4") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_5") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_6") (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_7") (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_8") (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_9") (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.abs_with_const_10") (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Param vs const
+(assert_return (invoke "i16x8.min_s_with_const_11" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s_with_const_12" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.min_u_with_const_13" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u_with_const_14" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 0 0 1 1 1 1 0 0))
+(assert_return (invoke "i16x8.max_s_with_const_15" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s_with_const_16" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.max_u_with_const_17" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                   (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u_with_const_18" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                   (v128.const i16x8 3 3 2 2 2 2 3 3))
+(assert_return (invoke "i16x8.avgr_u_with_const_19" (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                                    (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u_with_const_20" (v128.const i16x8 3 3 2 2 1 1 0 0))
+                                                    (v128.const i16x8 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 -32768 -32768 16384 16384 16384 16384 -32768 -32768))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 1 1 1 1 128 128))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                     (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                     (v128.const i16x8 65535 65535 32767 32767 32767 32767 65535 65535))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                     (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                     (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535)
+                                      (v128.const i16x8 65535 65535 16384 16384 32767 32767 -32768 -32768))
+                                      (v128.const i16x8 49152 49152 24576 24576 24576 24576 49152 49152))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 0 0 1 1 2 2 128 128)
+                                      (v128.const i16x8 0 0 2 2 1 1 128 128))
+                                      (v128.const i16x8 0 0 2 2 2 2 128 128))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -32768 -32768 32767 32767 16384 16384 65535 65535))
+                                   (v128.const i16x8 32768 32768 32767 32767 16384 16384 1 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.min_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_s" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                     (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                     (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.max_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0)
+                                      (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.avgr_u" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+                                   (v128.const i16x8 -0 -0 -0 -0 +0 +0 +0 +0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+                                   (v128.const i16x8 +0 +0 0 0 -0 -0 0 0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i16x8 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i16x8.abs" (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i16x8 +0 +0 +0 +0 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i16x8.avgr_s (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i16x8.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.min_s-1st-arg-empty (result v128)
+      (i16x8.min_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_s-arg-empty (result v128)
+      (i16x8.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-1st-arg-empty (result v128)
+      (i16x8.min_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.min_u-arg-empty (result v128)
+      (i16x8.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-1st-arg-empty (result v128)
+      (i16x8.max_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_s-arg-empty (result v128)
+      (i16x8.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-1st-arg-empty (result v128)
+      (i16x8.max_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.max_u-arg-empty (result v128)
+      (i16x8.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-1st-arg-empty (result v128)
+      (i16x8.avgr_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.avgr_u-arg-empty (result v128)
+      (i16x8.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.abs-arg-empty (result v128)
+      (i16x8.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i16x8.min_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.min_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.min_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.min_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.min_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.min_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.min_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_s-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_s (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_s-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_s (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_s") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_s (local.get 0) (local.get 1))))
+  (func (export "i16x8.max_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.max_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.max_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.max_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.max_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.max_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.avgr_u-i16x8.avgr_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.max_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_u") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.min_s") (param v128 v128 v128) (result v128) (i16x8.avgr_u (i16x8.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i16x8.avgr_u-i16x8.abs") (param v128 v128) (result v128) (i16x8.avgr_u (i16x8.abs (local.get 0))(local.get 1)))
+  (func (export "i16x8.abs-i16x8.avgr_u") (param v128 v128) (result v128) (i16x8.abs (i16x8.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i16x8.abs-i16x8.abs") (param v128) (result v128) (i16x8.abs (i16x8.abs (local.get 0))))
+)
+
+(assert_return (invoke "i16x8.min_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.min_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.min_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.abs-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_s-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_s-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.max_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                 (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                 (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.max_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                               (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                   (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.max_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.min_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 2 2 2 2 2 2 2 2))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.avgr_u-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.abs-i16x8.avgr_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.abs-i16x8.abs" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast
new file mode 100644
index 0000000..24068ce
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_cmp.wast
@@ -0,0 +1,1901 @@
+
+;; Test all the i16x8 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i16x8.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i16x8.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i16x8.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i16x8.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i16x8.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i16x8.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i16x8.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i16x8.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i16x8.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i16x8.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i16x8.eq  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                            (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                            (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                            (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+
+;; i16x8.eq  (i16x8) (i8x16)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 0 0 -1 -1 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.eq  (i16x8) (i32x4)
+(assert_return (invoke "eq" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                            (v128.const i32x4 65535 0 1 32768))
+                            (v128.const i16x8 -1 0 -1 -1 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ne
+
+;; i16x8.ne  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                            (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                            (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                            (v128.const i16x8 255 255 255 255 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                            (v128.const i16x8 0 0 0 0 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                            (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                            (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                            (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                            (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                            (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i8x16)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ne  (i16x8) (i32x4)
+(assert_return (invoke "ne" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i16x8 0 -1 0 0 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                            (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                            (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_s
+
+;; i16x8.lt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 -1 -1 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.lt_s  (i16x8) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i16x8.lt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 255 255 255 0 0 0 0)
+                              (v128.const i16x8 255 255 255 255 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 255 255 255 255)
+                              (v128.const i16x8 0 0 0 0 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 255 32767 -0 0 1 2 65534 65535)
+                              (v128.const i16x8 255 32767 0 0 1 2 -2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x8081 0x8283 0xFDFE 0xFF00 0x0001 0x027F 0x80FD 0xFEFF)
+                              (v128.const i16x8 65279 33021 639 1 65280 65022 33411 32897))
+                              (v128.const i16x8 -1 0 0 0 -1 -1 -1 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 128 129 130 131 -0 255 32766 32767)
+                              (v128.const i16x8 32767 32766 255 -0 131 130 129 28))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 0 0))
+
+;; i16x8.lt_u  (i16x8) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.lt_u  (i16x8) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; le_s
+
+;; i16x8.le_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 -1 0 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+
+;; i16x8.le_s  (i16x8) (i8x16)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.le_s  (i16x8) (i32x4)
+(assert_return (invoke "le_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_u
+
+;; i16x8.le_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 -1 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 -1 0 -1 0 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i8x16)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 0 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.le_u  (i16x8) (i32x4)
+(assert_return (invoke "le_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i16x8 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb 0x0_edcb)
+                              (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i16x8.gt_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 0 0))
+
+;; i16x8.gt_s  (i16x8) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.gt_s  (i16x8) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; gt_u
+
+;; i16x8.gt_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                            (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                            (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                            (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                            (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 0 0 0 -1 0 -1 0 0))
+
+;; i16x8.gt_u  (i16x8) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.gt_u  (i16x8) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i16x8.ge_s  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 -1 -1 0 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 0 -1 -1 -1 -1))
+
+;; i16x8.ge_s  (i16x8) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; i16x8.ge_s  (i16x8) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 65535 0 1 32768))
+                              (v128.const i16x8 -1 0 -1 -1 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i16x8.ge_u  (i16x8) (i16x8)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB)
+                              (v128.const i16x8 0x0100 0x0302 0x0904 0x1110 0x0A12 0x1A0B 0xAA1B 0xFFAB))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 32896 32896 32896 32896 32896 32896 32896 32896))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080)
+                              (v128.const i16x8 -32640 -32640 -32640 -32640 -32640 -32640 -32640 -32640))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8180 0x8382 0xFEFD 0x00FF 0x0100 0x7F02 0xFD80 0xFFFE)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 0 0 0 0)
+                              (v128.const i16x8 65535 65535 65535 65535 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 65535 65535 65535 65535)
+                              (v128.const i16x8 0 0 0 0 65535 65535 65535 65535))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -32768 65534 -1 -0 0 1 2 65535)
+                              (v128.const i16x8 32768 -2 -1 -0 0 1 2 -1))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0xc300 0x0000 0xc2fe 0x0000 0xbf80 0x0000 0x0000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x3f80 0x0000 0x42fe 0x0000 0x4300 0x0000 0x437f)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F 0x0F0F)
+                              (v128.const i16x8 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0 0xF0F0))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0x0000 0x0000 0x0000 0x0000))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0001 0x0203 0x0409 0x1011 0x120A 0x0B1A 0x1BAA 0xABFF)
+                              (v128.const i16x8 0xFFAB 0xAA1B 0x1A0B 0x0A12 0x1110 0x0904 0x0302 0x0100))
+                              (v128.const i16x8 0 0 0 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x8000 0x8001 0x8002 0x8003 0x8004 0x8005 0x8006 0x8007)
+                              (v128.const i16x8 32775 32774 32773 32772 32771 32770 32769 32768))
+                              (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 32768 32769 65534 65535 0 -1 -32767 -32768)
+                              (v128.const i16x8 -32768 -32767 -1 0 65535 65534 32769 32768))
+                              (v128.const i16x8 -1 -1 0 -1 0 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 -128 -128 0 0 1 1 255 255)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i16x8.ge_u  (i16x8) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 65535 65535 0 0 1 1 32768 32768)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                              (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                              (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+                              (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i16x8.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i16x8.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i16x8.eq
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.eq
+          (i16x8.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i16x8.ne
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i16x8.lt_s
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.lt_s
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i16x8.le_u
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.le_u
+          (i16x8.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i16x8.gt_u
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.gt_u
+          (i16x8.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i16x8.ge_s
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ge_s
+          (i16x8.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i16x8.ge_u
+        (i16x8.eq
+          (i16x8.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i16x8.ne
+          (i16x8.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i16x8.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.eq-1st-arg-empty (result v128)
+      (i16x8.eq (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.eq-arg-empty (result v128)
+      (i16x8.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-1st-arg-empty (result v128)
+      (i16x8.ne (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ne-arg-empty (result v128)
+      (i16x8.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-1st-arg-empty (result v128)
+      (i16x8.lt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_s-arg-empty (result v128)
+      (i16x8.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-1st-arg-empty (result v128)
+      (i16x8.lt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.lt_u-arg-empty (result v128)
+      (i16x8.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-1st-arg-empty (result v128)
+      (i16x8.le_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_s-arg-empty (result v128)
+      (i16x8.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-1st-arg-empty (result v128)
+      (i16x8.le_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.le_u-arg-empty (result v128)
+      (i16x8.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-1st-arg-empty (result v128)
+      (i16x8.gt_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_s-arg-empty (result v128)
+      (i16x8.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-1st-arg-empty (result v128)
+      (i16x8.gt_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.gt_u-arg-empty (result v128)
+      (i16x8.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-1st-arg-empty (result v128)
+      (i16x8.ge_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_s-arg-empty (result v128)
+      (i16x8.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-1st-arg-empty (result v128)
+      (i16x8.ge_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.ge_u-arg-empty (result v128)
+      (i16x8.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast
new file mode 100644
index 0000000..c2267de
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extadd_pairwise_i8x16.wast
@@ -0,0 +1,68 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extadd_pairwise_i8x16_s") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_s (local.get 0)))
+  (func (export "i16x8.extadd_pairwise_i8x16_u") (param v128) (result v128) (i16x8.extadd_pairwise_i8x16_u (local.get 0)))
+)
+
+
+;; i16x8.extadd_pairwise_i8x16_s
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 -254 -254 -254 -254 -254 -254 -254 -254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 -256 -256 -256 -256 -256 -256 -256 -256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+
+;; i16x8.extadd_pairwise_i8x16_u
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                       (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                       (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                                       (v128.const i16x8 252 252 252 252 252 252 252 252))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                       (v128.const i16x8 258 258 258 258 258 258 258 258))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                       (v128.const i16x8 256 256 256 256 256 256 256 256))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                       (v128.const i16x8 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i16x8.extadd_pairwise_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                       (v128.const i16x8 510 510 510 510 510 510 510 510))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extadd_pairwise_i8x16_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_s-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extadd_pairwise_i8x16_u-arg-empty (result v128)
+      (i16x8.extadd_pairwise_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast
new file mode 100644
index 0000000..cc8cf8f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_extmul_i8x16.wast
@@ -0,0 +1,404 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.extmul_low_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_s") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_low_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_low_i8x16_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.extmul_high_i8x16_u") (param v128 v128) (result v128) (i16x8.extmul_high_i8x16_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.extmul_low_i8x16_s
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_high_i8x16_s
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 4160 4160 4160 4160 4160 4160 4160 4160))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16256 16256 16256 16256 16256 16256 16256 16256))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+
+;; i16x8.extmul_low_i8x16_u
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                  (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                  (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                  (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                  (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                  (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_low_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                  (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                  (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; i16x8.extmul_high_i8x16_u
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4032 4032 4032 4032 4032 4032 4032 4032))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                                   (v128.const i16x8 4096 4096 4096 4096 4096 4096 4096 4096))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28480 -28480 -28480 -28480 -28480 -28480 -28480 -28480))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28672 -28672 -28672 -28672 -28672 -28672 -28672 -28672))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                                   (v128.const i16x8 -28864 -28864 -28864 -28864 -28864 -28864 -28864 -28864))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32386 -32386 -32386 -32386 -32386 -32386 -32386 -32386))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -32641 -32641 -32641 -32641 -32641 -32641 -32641 -32641))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 16129 16129 16129 16129 16129 16129 16129 16129))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 16512 16512 16512 16512 16512 16512 16512 16512))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 32385 32385 32385 32385 32385 32385 32385 32385))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 32640 32640 32640 32640 32640 32640 32640 32640))
+(assert_return (invoke "i16x8.extmul_high_i8x16_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                                   (v128.const i16x8 -511 -511 -511 -511 -511 -511 -511 -511))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_low_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extmul_high_i8x16_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-1st-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extmul_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extmul_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast
new file mode 100644
index 0000000..2cea8cc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_q15mulr_sat_s.wast
@@ -0,0 +1,110 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.q15mulr_sat_s") (param v128 v128) (result v128) (i16x8.q15mulr_sat_s (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.q15mulr_sat_s
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                             (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8192 8192 8192 8192 8192 8192 8192 8192))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                             (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                             (v128.const i16x8 8193 8193 8193 8193 8193 8193 8193 8193))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                             (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                             (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                             (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.q15mulr_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                             (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                             (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.q15mulr_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-1st-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.q15mulr_sat_s-arg-empty (result v128)
+      (i16x8.q15mulr_sat_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast
new file mode 100644
index 0000000..cea4ebb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i16x8_sat_arith.wast
@@ -0,0 +1,742 @@
+;; Tests for i16x8 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i16x8.add_sat_s") (param v128 v128) (result v128) (i16x8.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.add_sat_u") (param v128 v128) (result v128) (i16x8.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_s") (param v128 v128) (result v128) (i16x8.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i16x8.sub_sat_u") (param v128 v128) (result v128) (i16x8.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i16x8.add_sat_s
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1 0x01 0xffc1))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 032_123 032_123 032_123 032_123 032_123 032_123 032_123 032_123))
+                                         (v128.const i16x8 032_767 032_767 032_767 032_767 032_767 032_767 032_767 032_767))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000 -0x0_8000))
+
+;; i16x8.add_sat_u
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32769 32769 32769 32769 32769 32769 32769 32769))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff 0x8000 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81 0x01 0x7f81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0xff81 0x01 0xff81 0x01 0xff81 0x01 0xff81))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1 0x01 0x7fc1))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 3 6 9 12 15 18 21))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 065_535 065_535 065_535 065_535 065_535 065_535 065_535 065_535))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac 0x0_68ac))
+(assert_return (invoke "i16x8.add_sat_u" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef))
+                                         (v128.const i16x8 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff 0x0_ffff))
+
+;; i16x8.sub_sat_s
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32765 -32765 -32765 -32765 -32765 -32765 -32765 -32765))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0x8081 0x01 0x8081 0x01 0x8081 0x01 0x8081))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0x81 0x01 0x81 0x01 0x81 0x01 0x81))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0x8041 0x01 0x8041 0x01 0x8041 0x01 0x8041))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0x41 0x01 0x41 0x01 0x41 0x01 0x41))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 -1 -2 -3 -4 -5 -6 -7))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 021_092 021_092 021_092 021_092 021_092 021_092 021_092 021_092))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345 -012_345))
+                                         (v128.const i16x8 024_690 024_690 024_690 024_690 024_690 024_690 024_690 024_690))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678 0x0_5678))
+                                         (v128.const i16x8 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc 0x0_bbbc))
+(assert_return (invoke "i16x8.sub_sat_s" (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB)
+                                         (v128.const i16x8 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234 -0x1234))
+                                         (v128.const i16x8 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df 0xa2df))
+
+;; i16x8.sub_sat_u
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                         (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32764 32764 32764 32764 32764 32764 32764 32764))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff 0x3fff)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000)
+                                         (v128.const i16x8 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000 0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff -0x3fff)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000 -0x4000)
+                                         (v128.const i16x8 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001 -0x4001))
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff)
+                                         (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i16x8 0x8000 0 0x8000 0 0x8000 0 0x8000 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i16x8 0x01 0 0x01 0 0x01 0 0x01 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 0xffff 0xfffe 0xfffd 0xfffc 0xfffb 0xfffa 0xfff9))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0 1 2 3 4 5 6 7)
+                                         (v128.const i16x8 0 2 4 6 8 10 12 14))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345)
+                                         (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 056_789 056_789 056_789 056_789 056_789 056_789 056_789 056_789)
+                                         (v128.const i16x8 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345 -12_345))
+                                         (v128.const i16x8 03_598 03_598 03_598 03_598 03_598 03_598 03_598 03_598))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234)
+                                         (v128.const i16x8 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678 -0x0_5678))
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.sub_sat_u" (v128.const i16x8 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef 0x0_cdef)
+                                         (v128.const i16x8 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB 0x0_90AB))
+                                         (v128.const i16x8 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44 0x0_3d44))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.add_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.sub_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.mul_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i16x8.div_sat (v128.const i16x8 1 1 1 1 1 1 1 1) (v128.const i16x8 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-1st-arg-empty (result v128)
+      (i16x8.add_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_s-arg-empty (result v128)
+      (i16x8.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-1st-arg-empty (result v128)
+      (i16x8.add_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.add_sat_u-arg-empty (result v128)
+      (i16x8.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-1st-arg-empty (result v128)
+      (i16x8.sub_sat_s (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_s-arg-empty (result v128)
+      (i16x8.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-1st-arg-empty (result v128)
+      (i16x8.sub_sat_u (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.sub_sat_u-arg-empty (result v128)
+      (i16x8.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i16x8.add_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_s (i16x8.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i16x8.sub_sat_u (i16x8.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                         (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                         (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                         (v128.const i16x8 65534 65534 65534 65534 65534 65534 65534 65534))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                         (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                         (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                         (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-add_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                       (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                       (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                       (v128.const i16x8 1 1 1 1 1 1 1 1))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast
new file mode 100644
index 0000000..f0e09b8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith.wast
@@ -0,0 +1,634 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.add") (param v128 v128) (result v128) (i32x4.add (local.get 0) (local.get 1)))
+  (func (export "i32x4.sub") (param v128 v128) (result v128) (i32x4.sub (local.get 0) (local.get 1)))
+  (func (export "i32x4.mul") (param v128 v128) (result v128) (i32x4.mul (local.get 0) (local.get 1)))
+  (func (export "i32x4.neg") (param v128) (result v128) (i32x4.neg (local.get 0)))
+)
+
+
+;; i32x4.add
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0xbf800000 0xbf800000 0xbf800000 0xbf800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0x3f800000 0x3f800000 0x3f800000 0x3f800000))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800001 0x7f800001 0x7f800001 0x7f800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800001 0xff800001 0xff800001 0xff800001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00001 0x7fc00001 0x7fc00001 0x7fc00001))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 3 6 9))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890)
+                                   (v128.const i32x4 01_234_567_890 01_234_567_890 01_234_567_890 01_234_567_890))
+                                   (v128.const i32x4 02_469_135_780 02_469_135_780 02_469_135_780 02_469_135_780))
+(assert_return (invoke "i32x4.add" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467 0x0_a2e0_2467))
+
+;; i32x4.sub
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483644 2147483644 2147483644 2147483644))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483645 -2147483645 -2147483645 -2147483645))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i8x16 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80 0 0 0 0x80))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i16x8 0 0x8000 0 0x8000 0 0x8000 0 0x8000))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 0x02 0x02 0x02 0x02))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0x40800000 0x40800000 0x40800000 0x40800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0xc0800000 0xc0800000 0xc0800000 0xc0800000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x80800001 0x80800001 0x80800001 0x80800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0x00800001 0x00800001 0x00800001 0x00800001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x80400001 0x80400001 0x80400001 0x80400001))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0x02 0x04 0x06))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 -1 -2 -3))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 03_214_567_890  03_214_567_890  03_214_567_890  03_214_567_890 )
+                                   (v128.const i32x4 01_234_567_890  01_234_567_890  01_234_567_890  01_234_567_890 ))
+                                   (v128.const i32x4 01_980_000_000 01_980_000_000 01_980_000_000 01_980_000_000))
+(assert_return (invoke "i32x4.sub" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                                   (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+                                   (v128.const i32x4 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777 0x0_7e77_7777))
+
+;; i32x4.mul
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 0 0 0)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1 1 1 1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1 -1 -1 -1)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483645 2147483645 2147483645 2147483645))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x3fffffff 0x3fffffff 0x3fffffff 0x3fffffff)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000)
+                                   (v128.const i32x4 0x40000000 0x40000000 0x40000000 0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x3fffffff -0x3fffffff -0x3fffffff -0x3fffffff)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 -0x40000000 -0x40000000 -0x40000000 -0x40000000)
+                                   (v128.const i32x4 -0x40000001 -0x40000001 -0x40000001 -0x40000001))
+                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x10000000 0x10000000 0x10000000 0x10000000)
+                                   (v128.const i8x16 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10 0x10))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                   (v128.const i16x8 0 0x02 0 0x02 0 0x02 0 0x02))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x8000 0x8000 0x8000 0x8000)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i32x4 0x7f800000 0x7f800000 0x7f800000 0x7f800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i32x4 0xff800000 0xff800000 0xff800000 0xff800000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x1 0x1 0x1 0x1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i32x4 0x7fc00000 0x7fc00000 0x7fc00000 0x7fc00000))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffe 0xfffffffd))
+                                   (v128.const i32x4 0 0xffffffff 0xfffffffc 0xfffffff7))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0 1 2 3)
+                                   (v128.const i32x4 0 2 4 6))
+                                   (v128.const i32x4 0 0x02 0x08 0x12))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                                   (v128.const i32x4 0_987_654_321 0_987_654_321 0_987_654_321 0_987_654_321))
+                                   (v128.const i32x4 04_227_814_277 04_227_814_277 04_227_814_277 04_227_814_277))
+(assert_return (invoke "i32x4.mul" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                                   (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef))
+                                   (v128.const i32x4 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208 0x0_2a42_d208))
+
+;; i32x4.neg
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0 0 0 0))
+                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646))
+                                   (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x01 0x01 0x01 0x01))
+                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff))
+                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.neg" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.neg-arg-empty (result v128)
+      (i32x4.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-1st-arg-empty (result v128)
+      (i32x4.add (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.add-arg-empty (result v128)
+      (i32x4.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-1st-arg-empty (result v128)
+      (i32x4.sub (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.sub-arg-empty (result v128)
+      (i32x4.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-1st-arg-empty (result v128)
+      (i32x4.mul (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.mul-arg-empty (result v128)
+      (i32x4.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i32x4.add (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i32x4.mul (i32x4.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i32x4.sub (i32x4.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i32x4.add (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i32x4.mul (i32x4.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i32x4.sub (i32x4.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "mul-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 4 8 12))
+(assert_return (invoke "mul-sub" (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 1 4 9))
+(assert_return (invoke "sub-add" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 2 4 6)
+                                 (v128.const i32x4 0 2 4 6))
+                                 (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "add-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "mul-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 2 2 2 2))
+                                 (v128.const i32x4 0 -2 -4 -6))
+(assert_return (invoke "sub-neg" (v128.const i32x4 0 1 2 3)
+                                 (v128.const i32x4 0 1 2 3))
+                                 (v128.const i32x4 0 -2 -4 -6))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast
new file mode 100644
index 0000000..63c3f4a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_arith2.wast
@@ -0,0 +1,494 @@
+;; Tests for i32x4 [min_s, min_u, max_s, max_u, abs] operations.
+
+(module
+  (func (export "i32x4.min_s") (param v128 v128) (result v128) (i32x4.min_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.min_u") (param v128 v128) (result v128) (i32x4.min_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_s") (param v128 v128) (result v128) (i32x4.max_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.max_u") (param v128 v128) (result v128) (i32x4.max_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.abs") (param v128) (result v128) (i32x4.abs (local.get 0)))
+  (func (export "i32x4.min_s_with_const_0") (result v128) (i32x4.min_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_s_with_const_1") (result v128) (i32x4.min_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.min_u_with_const_2") (result v128) (i32x4.min_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.min_u_with_const_3") (result v128) (i32x4.min_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_s_with_const_4") (result v128) (i32x4.max_s (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_s_with_const_5") (result v128) (i32x4.max_s (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.max_u_with_const_6") (result v128) (i32x4.max_u (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295) (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648)))
+  (func (export "i32x4.max_u_with_const_7") (result v128) (i32x4.max_u (v128.const i32x4 0 1 2 3) (v128.const i32x4 3 2 1 0)))
+  (func (export "i32x4.abs_with_const_8") (result v128) (i32x4.abs (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_9") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_s_with_const_10") (param v128) (result v128) (i32x4.min_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.min_u_with_const_11") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.min_u_with_const_12") (param v128) (result v128) (i32x4.min_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_s_with_const_13") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_s_with_const_14") (param v128) (result v128) (i32x4.max_s (local.get 0) (v128.const i32x4 0 1 2 3)))
+  (func (export "i32x4.max_u_with_const_15") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)))
+  (func (export "i32x4.max_u_with_const_16") (param v128) (result v128) (i32x4.max_u (local.get 0) (v128.const i32x4 0 1 2 3)))
+)
+
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 128 128 128 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0 0 0 0))
+                                     (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 -1 -1 -1 -1))
+                                     (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 -1 -1)
+                                     (v128.const i32x4 0 -1 0 -1))
+                                     (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                     (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 1 1 1 1)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 1 1 1 1))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                     (v128.const i32x4 128 128 128 128))
+                                     (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000)
+                                     (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                     (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 123 123 123 123)
+                                     (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0x80 0x80 0x80 0x80)
+                                     (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 1 1 1 1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i32x4 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                   (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+                                   (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i32x4 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i32x4 123 123 123 123))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x80 0x80 0x80 0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i32x4 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i32x4 0x80 0x80 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i32x4.min_s_with_const_0") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_1") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_2") (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_3") (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_4") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_5") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_6") (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_7") (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.abs_with_const_8") (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Param vs const
+(assert_return (invoke "i32x4.min_s_with_const_9" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                  (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s_with_const_10" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.min_u_with_const_11" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u_with_const_12" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 0 1 1 0))
+(assert_return (invoke "i32x4.max_s_with_const_13" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s_with_const_14" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+(assert_return (invoke "i32x4.max_u_with_const_15" (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                                   (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u_with_const_16" (v128.const i32x4 3 2 1 0))
+                                                   (v128.const i32x4 3 2 2 3))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 -2147483648 1073741824 1073741824 -2147483648))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 1 1 128))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295)
+                                     (v128.const i32x4 4294967295 1073741824 2147483647 -2147483648))
+                                     (v128.const i32x4 4294967295 2147483647 2147483647 4294967295))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 0 1 2 128)
+                                     (v128.const i32x4 0 2 1 128))
+                                     (v128.const i32x4 0 2 2 128))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -2147483648 2147483647 1073741824 4294967295))
+                                   (v128.const i32x4 2147483648 2147483647 1073741824 1))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.min_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_s" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 +0 +0)
+                                     (v128.const i32x4 +0 0 -0 0))
+                                     (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.max_u" (v128.const i32x4 -0 -0 -0 -0)
+                                     (v128.const i32x4 +0 +0 +0 +0))
+                                     (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 +0 +0))
+                                   (v128.const i32x4 -0 -0 +0 +0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 0 -0 0))
+                                   (v128.const i32x4 +0 0 -0 0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 -0 -0 -0 -0))
+                                   (v128.const i32x4 -0 -0 -0 -0))
+(assert_return (invoke "i32x4.abs" (v128.const i32x4 +0 +0 +0 +0))
+                                   (v128.const i32x4 +0 +0 +0 +0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.min_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.max_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i32x4.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.min_s-1st-arg-empty (result v128)
+      (i32x4.min_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_s-arg-empty (result v128)
+      (i32x4.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-1st-arg-empty (result v128)
+      (i32x4.min_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.min_u-arg-empty (result v128)
+      (i32x4.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-1st-arg-empty (result v128)
+      (i32x4.max_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_s-arg-empty (result v128)
+      (i32x4.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-1st-arg-empty (result v128)
+      (i32x4.max_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.max_u-arg-empty (result v128)
+      (i32x4.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.abs-arg-empty (result v128)
+      (i32x4.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i32x4.min_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.min_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.min_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.min_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.min_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.min_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.min_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_s-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_s (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_s-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_s (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_s") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_s (local.get 0) (local.get 1))))
+  (func (export "i32x4.max_u-i32x4.max_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.max_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_u") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.min_s") (param v128 v128 v128) (result v128) (i32x4.max_u (i32x4.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i32x4.max_u-i32x4.abs") (param v128 v128) (result v128) (i32x4.max_u (i32x4.abs (local.get 0))(local.get 1)))
+  (func (export "i32x4.abs-i32x4.max_u") (param v128 v128) (result v128) (i32x4.abs (i32x4.max_u (local.get 0) (local.get 1))))
+  (func (export "i32x4.abs-i32x4.abs") (param v128) (result v128) (i32x4.abs (i32x4.abs (local.get 0))))
+)
+
+(assert_return (invoke "i32x4.min_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.min_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.min_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.abs-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_s-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_s-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.max_u-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.max_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_u" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.min_s" (v128.const i32x4 0 0 0 0)
+                                                 (v128.const i32x4 1 1 1 1)
+                                                 (v128.const i32x4 2 2 2 2))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.max_u-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1)
+                                               (v128.const i32x4 0 0 0 0))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.max_u" (v128.const i32x4 0 0 0 0)
+                                               (v128.const i32x4 -1 -1 -1 -1))
+                                               (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.abs-i32x4.abs" (v128.const i32x4 -1 -1 -1 -1))
+                                             (v128.const i32x4 1 1 1 1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast
new file mode 100644
index 0000000..fca45ab
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_cmp.wast
@@ -0,0 +1,1920 @@
+
+;; Test all the i32x4 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i32x4.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i32x4.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i32x4.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i32x4.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i32x4.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i32x4.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i32x4.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i32x4.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i32x4.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i32x4.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i32x4.eq  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 -1 0 0 0))
+
+;; i32x4.eq  (i32x4) (i8x16)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 0 -1 0 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 0 0 0 0))
+
+;; i32x4.eq  (i32x4) (i16x8)
+(assert_return (invoke "eq" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 4294967295 0 1 65535)
+                            (v128.const i16x8 65535 65535 0 0 1 0 65535 65535))
+                            (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "eq" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; ne
+
+;; i32x4.ne  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                            (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                            (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                            (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i32x4 -1 -1 -1 -1)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i32x4 -1 -1 -1 -1))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 0 0)
+                            (v128.const i32x4 4294967295 4294967295 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 4294967295 4294967295)
+                            (v128.const i32x4 0 0 4294967295 4294967295))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                            (v128.const i32x4 2147483649 -1 0 -1))
+                            (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                            (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                            (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                            (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 2147483648 2147483647 0 -1)
+                            (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                            (v128.const i32x4 0 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i8x16)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -8323200 0 1 4294967295)
+                            (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                            (v128.const i32x4 -1 0 -1 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                            (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                            (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ne  (i32x4) (i16x8)
+(assert_return (invoke "ne" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 -128 0 1 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i32x4 -1 0 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                            (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                            (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                            (v128.const i32x4 123456789 123456789 123456789 123456789))
+                            (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                            (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                            (v128.const i32x4 0 0 0 0))
+
+;; lt_s
+
+;; i32x4.lt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.lt_s  (i32x4) (i8x16)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.lt_s  (i32x4) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; lt_u
+
+;; i32x4.lt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.lt_u  (i32x4) (i8x16)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 0 -1 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.lt_u  (i32x4) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543210 -0x6f543210 -0x6f543210 -0x6f543210))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_s
+
+;; i32x4.le_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 0 0 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.le_s  (i32x4)(i8x16)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.le_s  (i32x4) (i16x8)
+(assert_return (invoke "le_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; le_u
+
+;; i32x4.le_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.le_u  (i32x4) (i8x16)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.le_u  (i32x4) (i16x8)
+(assert_return (invoke "le_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 0x90ABcdef 0x90ABcdef 0x90ABcdef 0x90ABcdef))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i32x4.gt_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 -1 -1 0))
+
+;; i32x4.gt_s  (i32x4) (i8x16)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.gt_s  (i32x4) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 0 0 -1))
+(assert_return (invoke "gt_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i32x4 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef 0x0_90AB_cdef)
+                              (v128.const i32x4 -0x6f543211 -0x6f543211 -0x6f543211 -0x6f543211))
+                              (v128.const i32x4 0 0 0 0))
+
+;; gt_u
+
+;; i32x4.gt_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 0 0 0 -1))
+
+;; i32x4.gt_u  (i32x4) (i8x16)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA))
+                              (v128.const i32x4 0 0 0 0))
+
+;; i32x4.gt_u  (i32x4) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 0 0 0 0))
+
+;; ge_s
+
+;; i32x4.ge_s  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 -1 -1 -1 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 -1 -1 0))
+
+;; i32x4.ge_s  (i32x4) (i8x16)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x55555555 0x55555555 0x55555555 0x55555555)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_s  (i32x4) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 65535 0 1 32768)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i32x4.ge_u  (i32x4) (i32x4)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000)
+                              (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B)
+                              (v128.const i32x4 0x03020100 0x11100904 0x1A0B0A12 0xFFABAA1B))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 2155905152 2155905152 2155905152 2155905152))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080)
+                              (v128.const i32x4 -2139062144 -2139062144 -2139062144 -2139062144))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x83828180 0x00FFFEFD 0x7F020100 0xFFFEFD80)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i32x4 -1 -1 -1 -1)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i32x4 -1 -1 -1 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 0 0)
+                              (v128.const i32x4 4294967295 4294967295 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 4294967295 4294967295)
+                              (v128.const i32x4 0 0 4294967295 4294967295))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -2147483647 4294967295 0 -1)
+                              (v128.const i32x4 2147483649 -1 0 -1))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i32x4 0xc3000000 0xc2fe0000 0xbf800000 0x00000000)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x3f800000 0x42fe0000 0x43000000 0x437f0000)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F 0x0F0F0F0F)
+                              (v128.const i32x4 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0 0xF0F0F0F0))
+                              (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x00000000 0x00000000 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0x00000000 0x00000000))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x02030001 0x10110409 0x0B1A120A 0xABFF1BAA)
+                              (v128.const i32x4 0xAA1BFFAB 0x0A121A0B 0x09041110 0x01000302))
+                              (v128.const i32x4 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x80018000 0x80038002 0x80058004 0x80078006)
+                              (v128.const i32x4 2147975174 2147844100 2147713026 2147581952))
+                              (v128.const i32x4 0 0 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2147483648 2147483647 0 -1)
+                              (v128.const i32x4 -2147483648 -2147483647 -1 0))
+                              (v128.const i32x4 -1 0 0 -1))
+
+;; i32x4.ge_u  (i32x4) (i8x16)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -8323200 0 1 4294967295)
+                              (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255))
+                              (v128.const i32x4 -1 -1 0 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+;; i32x4.ge_u  (i32x4) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 2206368128 16776957 2130837760 4294901120)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 -128 0 1 255)
+                              (v128.const i16x8 65535 65535 0 0 1 1 32768 32768))
+                              (v128.const i32x4 0 -1 0 0))
+(assert_return (invoke "ge_u" (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA)
+                              (v128.const i16x8 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555 0x5555))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789)
+                              (v128.const i32x4 123456789 123456789 123456789 123456789))
+                              (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678)
+                              (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+                              (v128.const i32x4 -1 -1 -1 -1))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i32x4.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i32x4.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i32x4.eq
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.eq
+          (i32x4.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i32x4.ne
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i32x4.lt_s
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.lt_s
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i32x4.le_u
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.le_u
+          (i32x4.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i32x4.gt_u
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.gt_u
+          (i32x4.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i32x4.ge_s
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ge_s
+          (i32x4.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i32x4.ge_u
+        (i32x4.eq
+          (i32x4.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i32x4.ne
+          (i32x4.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i32x4.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.eq-1st-arg-empty (result v128)
+      (i32x4.eq (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.eq-arg-empty (result v128)
+      (i32x4.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-1st-arg-empty (result v128)
+      (i32x4.ne (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ne-arg-empty (result v128)
+      (i32x4.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-1st-arg-empty (result v128)
+      (i32x4.lt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_s-arg-empty (result v128)
+      (i32x4.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-1st-arg-empty (result v128)
+      (i32x4.lt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.lt_u-arg-empty (result v128)
+      (i32x4.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-1st-arg-empty (result v128)
+      (i32x4.le_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_s-arg-empty (result v128)
+      (i32x4.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-1st-arg-empty (result v128)
+      (i32x4.le_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.le_u-arg-empty (result v128)
+      (i32x4.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-1st-arg-empty (result v128)
+      (i32x4.gt_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_s-arg-empty (result v128)
+      (i32x4.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-1st-arg-empty (result v128)
+      (i32x4.gt_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.gt_u-arg-empty (result v128)
+      (i32x4.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-1st-arg-empty (result v128)
+      (i32x4.ge_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_s-arg-empty (result v128)
+      (i32x4.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-1st-arg-empty (result v128)
+      (i32x4.ge_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.ge_u-arg-empty (result v128)
+      (i32x4.ge_u)
+    )
+  )
+  "type mismatch"
+)
+;; Unknown operators
+
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.eq (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ne (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.lt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.le_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.gt_u (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_s (local.get $x) (local.get $y)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (param $x v128) (param $y v128) (result v128) (i4x32.ge_u (local.get $x) (local.get $y)))") "unknown operator")
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast
new file mode 100644
index 0000000..b41de74
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_dot_i16x8.wast
@@ -0,0 +1,110 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.dot_i16x8_s") (param v128 v128) (result v128) (i32x4.dot_i16x8_s (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.dot_i16x8_s
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                           (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536838144 536838144 536838144 536838144))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536870912 536870912 536870912 536870912))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                           (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                           (v128.const i32x4 536903680 536903680 536903680 536903680))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65530 65530 65530 65530))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 2147352578 2147352578 2147352578 2147352578))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                           (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                           (v128.const i32x4 2147418112 2147418112 2147418112 2147418112))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                           (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                           (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                           (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                           (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                           (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.dot_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                           (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                           (v128.const i32x4 2 2 2 2))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.dot_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.dot_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.dot_i16x8_s-arg-empty (result v128)
+      (i32x4.dot_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast
new file mode 100644
index 0000000..2d1682d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extadd_pairwise_i16x8.wast
@@ -0,0 +1,68 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extadd_pairwise_i16x8_s") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_s (local.get 0)))
+  (func (export "i32x4.extadd_pairwise_i16x8_u") (param v128) (result v128) (i32x4.extadd_pairwise_i16x8_u (local.get 0)))
+)
+
+
+;; i32x4.extadd_pairwise_i16x8_s
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 -65534 -65534 -65534 -65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 -65536 -65536 -65536 -65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 -2 -2 -2 -2))
+
+;; i32x4.extadd_pairwise_i16x8_u
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                       (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                       (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766))
+                                                       (v128.const i32x4 65532 65532 65532 65532))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                       (v128.const i32x4 65538 65538 65538 65538))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                       (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                       (v128.const i32x4 65534 65534 65534 65534))
+(assert_return (invoke "i32x4.extadd_pairwise_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                       (v128.const i32x4 131070 131070 131070 131070))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extadd_pairwise_i16x8_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_s-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extadd_pairwise_i16x8_u-arg-empty (result v128)
+      (i32x4.extadd_pairwise_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast
new file mode 100644
index 0000000..f04db67
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_extmul_i16x8.wast
@@ -0,0 +1,404 @@
+;; Tests for i32x4 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i32x4.extmul_low_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_s") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_s (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_low_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_low_i16x8_u (local.get 0) (local.get 1)))
+  (func (export "i32x4.extmul_high_i16x8_u") (param v128 v128) (result v128) (i32x4.extmul_high_i16x8_u (local.get 0) (local.get 1)))
+)
+
+
+;; i32x4.extmul_low_i16x8_s
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_high_i16x8_s
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 268451840 268451840 268451840 268451840))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073709056 1073709056 1073709056 1073709056))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_s" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 1 1 1 1))
+
+;; i32x4.extmul_low_i16x8_u
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                  (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                  (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                  (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                  (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                  (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_low_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                  (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                  (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; i32x4.extmul_high_i16x8_u
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 1 1 1 1 1 1 1 1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16383 16383 16383 16383 16383 16383 16383 16383)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268419072 268419072 268419072 268419072))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384)
+                                                   (v128.const i16x8 16384 16384 16384 16384 16384 16384 16384 16384))
+                                                   (v128.const i32x4 268435456 268435456 268435456 268435456))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16383 -16383 -16383 -16383 -16383 -16383 -16383 -16383)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1878999040 -1878999040 -1878999040 -1878999040))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879048192 -1879048192 -1879048192 -1879048192))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -16385 -16385 -16385 -16385 -16385 -16385 -16385 -16385)
+                                                   (v128.const i16x8 -16384 -16384 -16384 -16384 -16384 -16384 -16384 -16384))
+                                                   (v128.const i32x4 -1879097344 -1879097344 -1879097344 -1879097344))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32765 32765 32765 32765 32765 32765 32765 32765)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32765 32765 32765 32765))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32766 32766 32766 32766)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32768 32768 32768 32768 32768 32768 32768 32768)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32766 -32766 -32766 -32766 -32766 -32766 -32766 -32766)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147385346 -2147385346 -2147385346 -2147385346))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -2147450881 -2147450881 -2147450881 -2147450881))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 1073676289 1073676289 1073676289 1073676289))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768)
+                                                   (v128.const i16x8 -32767 -32767 -32767 -32767 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 1073774592 1073774592 1073774592 1073774592))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 2147385345 2147385345 2147385345 2147385345))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 2147450880 2147450880 2147450880 2147450880))
+(assert_return (invoke "i32x4.extmul_high_i16x8_u" (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535)
+                                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                                   (v128.const i32x4 -131071 -131071 -131071 -131071))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_low_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extmul_high_i16x8_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-1st-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extmul_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extmul_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast
new file mode 100644
index 0000000..40af590
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f32x4.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f32x4_s") (param v128) (result v128) (i32x4.trunc_sat_f32x4_s (local.get 0)))
+  (func (export "i32x4.trunc_sat_f32x4_u") (param v128) (result v128) (i32x4.trunc_sat_f32x4_u (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f32x4_s
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 -2 -2 -2 -2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 -2147483520 -2147483520 -2147483520 -2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 -6 -6 -6 -6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 -42 -42 -42 -42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_s" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; i32x4.trunc_sat_f32x4_u
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0.0 0.0 0.0 0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.5 1.5 1.5 1.5))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.5 -1.5 -1.5 -1.5))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 1.9 1.9 1.9 1.9))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2.0 2.0 2.0 2.0))
+                                                 (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -1.9 -1.9 -1.9 -1.9))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2.0 -2.0 -2.0 -2.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483520.0 2147483520.0 2147483520.0 2147483520.0))
+                                                 (v128.const i32x4 2147483520 2147483520 2147483520 2147483520))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483520.0 -2147483520.0 -2147483520.0 -2147483520.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483648.0 2147483648.0 2147483648.0 2147483648.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483648.0 -2147483648.0 -2147483648.0 -2147483648.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -4294967294.0 -4294967294.0 -4294967294.0 -4294967294.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 2147483647.0 2147483647.0 2147483647.0 2147483647.0))
+                                                 (v128.const i32x4 2147483648 2147483648 2147483648 2147483648))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -2147483647.0 -2147483647.0 -2147483647.0 -2147483647.0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967294.0 4294967294.0 4294967294.0 4294967294.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967295.0 4294967295.0 4294967295.0 4294967295.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 4294967296.0 4294967296.0 4294967296.0 4294967296.0))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-149 0x1p-149 0x1p-149 0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-149 -0x1p-149 -0x1p-149 -0x1p-149))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-126 0x1p-126 0x1p-126 0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-126 -0x1p-126 -0x1p-126 -0x1p-126))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p-1 0x1p-1 0x1p-1 0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p-1 -0x1p-1 -0x1p-1 -0x1p-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1p+0 0x1p+0 0x1p+0 0x1p+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1p+0 -0x1p+0 -0x1p+0 -0x1p+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0 0x1.19999ap+0))
+                                                 (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1 0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                 (v128.const i32x4 6 6 6 6))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127 0x1.fffffep+127))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +inf +inf +inf +inf))
+                                                 (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -inf -inf -inf -inf))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 +nan +nan +nan +nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan -nan -nan -nan))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 nan:0x444444 nan:0x444444 nan:0x444444 nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -nan:0x444444 -nan:0x444444 -nan:0x444444 -nan:0x444444))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 42 42 42 42))
+                                                 (v128.const i32x4 42 42 42 42))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 -42 -42 -42 -42))
+                                                 (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 0123456792.0 0123456792.0 0123456792.0 0123456792.0))
+                                                 (v128.const i32x4 123456792 123456792 123456792 123456792))
+(assert_return (invoke "i32x4.trunc_sat_f32x4_u" (v128.const f32x4 01234567890.0 01234567890.0 01234567890.0 01234567890.0))
+                                                 (v128.const i32x4 1234567936 1234567936 1234567936 1234567936))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_s-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f32x4_u-arg-empty (result v128)
+      (i32x4.trunc_sat_f32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast
new file mode 100644
index 0000000..9bf507d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i32x4_trunc_sat_f64x2.wast
@@ -0,0 +1,239 @@
+;; Tests for i32x4 trunc sat conversions from float.
+
+(module
+  (func (export "i32x4.trunc_sat_f64x2_s_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_s_zero (local.get 0)))
+  (func (export "i32x4.trunc_sat_f64x2_u_zero") (param v128) (result v128) (i32x4.trunc_sat_f64x2_u_zero (local.get 0)))
+)
+
+
+;; i32x4.trunc_sat_f64x2_s_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 -2 -2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 -2147483520 -2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 -2147483647 -2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 -1 -1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 -6 -6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 -2147483648 -2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 -42 -42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_s_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; i32x4.trunc_sat_f64x2_u_zero
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0.0 0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0.0 -0.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.5 1.5))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.5 -1.5))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 1.9 1.9))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2.0 2.0))
+                                                      (v128.const i32x4 2 2 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -1.9 -1.9))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2.0 -2.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483520.0 2147483520.0))
+                                                      (v128.const i32x4 2147483520 2147483520 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483520.0 -2147483520.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483648.0 2147483648.0))
+                                                      (v128.const i32x4 2147483648 2147483648 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483648.0 -2147483648.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -4294967294.0 -4294967294.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 2147483647.0 2147483647.0))
+                                                      (v128.const i32x4 2147483647 2147483647 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -2147483647.0 -2147483647.0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967294.0 4294967294.0))
+                                                      (v128.const i32x4 4294967294 4294967294 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967295.0 4294967295.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 4294967296.0 4294967296.0))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-149 0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-149 -0x1p-149))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-126 0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-126 -0x1p-126))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p-1 0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p-1 -0x1p-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1p+0 0x1p+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1p+0 -0x1p+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.19999ap+0 0x1.19999ap+0))
+                                                      (v128.const i32x4 1 1 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.19999ap+0 -0x1.19999ap+0))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.ccccccp-1 0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.ccccccp-1 -0x1.ccccccp-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep-1 0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep-1 -0x1.fffffep-1))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.921fb6p+2 0x1.921fb6p+2))
+                                                      (v128.const i32x4 6 6 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.921fb6p+2 -0x1.921fb6p+2))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0x1.fffffep+127 0x1.fffffep+127))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -0x1.fffffep+127 -0x1.fffffep+127))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +inf +inf))
+                                                      (v128.const i32x4 4294967295 4294967295 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -inf -inf))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 +nan +nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan -nan))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 nan:0x444444 nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -nan:0x444444 -nan:0x444444))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 42 42))
+                                                      (v128.const i32x4 42 42 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 -42 -42))
+                                                      (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 0123456792.0 0123456792.0))
+                                                      (v128.const i32x4 123456792 123456792 0 0))
+(assert_return (invoke "i32x4.trunc_sat_f64x2_u_zero" (v128.const f64x2 01234567890.0 01234567890.0))
+                                                      (v128.const i32x4 1234567890 1234567890 0 0))
+
+;; type check
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_s_zero (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.trunc_sat_f64x2_u_zero (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_s_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_s_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.trunc_sat_f64x2_u_zero-arg-empty (result v128)
+      (i32x4.trunc_sat_f64x2_u_zero)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast
new file mode 100644
index 0000000..00963a0
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith.wast
@@ -0,0 +1,652 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.add") (param v128 v128) (result v128) (i64x2.add (local.get 0) (local.get 1)))
+  (func (export "i64x2.sub") (param v128 v128) (result v128) (i64x2.sub (local.get 0) (local.get 1)))
+  (func (export "i64x2.mul") (param v128 v128) (result v128) (i64x2.mul (local.get 0) (local.get 1)))
+  (func (export "i64x2.neg") (param v128) (result v128) (i64x2.neg (local.get 0)))
+)
+
+
+;; i64x2.add
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535102 -4899916394847535102))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4899916394579099648 -4899916394579099648))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4899916394579099649 -4899916394579099649))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 -8646911284551352322 -8646911284551352322))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0xbff0000000000000 0xbff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0x3ff0000000000000 0x3ff0000000000000))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000001 0x7ff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000001 0xfff0000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 1 1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000001 0x7ff8000000000001))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 3))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 02_469_135_780_246_913_578 02_469_135_780_246_913_578))
+(assert_return (invoke "i64x2.add" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_1234_5678 0x0_90AB_cdef_1234_5678))
+                                   (v128.const i64x2 0x0_a2e0_2467_a2e0_2467 0x0_a2e0_2467_a2e0_2467))
+
+;; i64x2.sub
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775804 9223372036854775804))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775805 -9223372036854775805))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4323455642007240704 -4323455642007240704))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 -4323455642275676160 -4323455642275676160))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 -4323455642275676159 -4323455642275676159))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352320 8646911284551352320))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -2 -2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0x80 0 0 0 0 0 0 0 0x80))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i16x8 0 0 0 0x8000 0 0 0 0x8000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i32x4 0 0x80000000 0 0x80000000))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 2 2))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0x4010000000000000 0x4010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0xc010000000000000 0xc010000000000000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x8010000000000001 0x8010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0x0010000000000001 0x0010000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x8008000000000001 0x8008000000000001))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 -1))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 03_214_567_890_123_456_789 03_214_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 01_980_000_000_000_000_000 01_980_000_000_000_000_000))
+(assert_return (invoke "i64x2.sub" (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321)
+                                   (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+                                   (v128.const i64x2 0x0_7e77_7776_f6b9_7532 0x0_7e77_7776_f6b9_7532))
+
+;; i64x2.mul
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 0)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 1 1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -1 -1)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387903 4611686018427387903)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 4611686018427387904 4611686018427387904)
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387903 -4611686018427387903)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387904 -4611686018427387904)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -4611686018427387905 -4611686018427387905)
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775805 9223372036854775805)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775805 9223372036854775805))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775806 9223372036854775806)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775808 9223372036854775808)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775806 -9223372036854775806)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775806 9223372036854775806))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775807 -9223372036854775807)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 9223372036854775807 9223372036854775807)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -9223372036854775808 -9223372036854775808)
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                                   (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x3fffffffffffffff 0x3fffffffffffffff)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 -4611686018427387904 -4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x4000000000000000 0x4000000000000000)
+                                   (v128.const i64x2 0x4000000000000000 0x4000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x3fffffffffffffff -0x3fffffffffffffff)
+                                   (v128.const i64x2 -0x40000000fffffff -0x40000000fffffff))
+                                   (v128.const i64x2 -4899916394847535103 -4899916394847535103))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000000 -0x400000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 -0x4000000000000000 -0x4000000000000000)
+                                   (v128.const i64x2 -0x400000000000001 -0x400000000000001))
+                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x7ffffffffffffff 0x7ffffffffffffff))
+                                   (v128.const i64x2 8646911284551352321 8646911284551352321))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i8x16 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2 0x2))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i16x8 0 0 0 0x02 0 0 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x8000000000000000 0x8000000000000000)
+                                   (v128.const i32x4 0 0x02 0 0x02))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 +0.0 +0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -0.0 -0.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 1.0 1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x80000000 0x80000000)
+                                   (v128.const f64x2 -1.0 -1.0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 +inf +inf))
+                                   (v128.const i64x2 0x7ff0000000000000 0x7ff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 -inf -inf))
+                                   (v128.const i64x2 0xfff0000000000000 0xfff0000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x1 0x1)
+                                   (v128.const f64x2 nan nan))
+                                   (v128.const i64x2 0x7ff8000000000000 0x7ff8000000000000))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+                                   (v128.const i64x2 0 0xffffffffffffffff))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0 1)
+                                   (v128.const i64x2 0 2))
+                                   (v128.const i64x2 0 0x02))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789)
+                                   (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+                                   (v128.const i64x2 09_710_478_858_155_731_897 09_710_478_858_155_731_897))
+(assert_return (invoke "i64x2.mul" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef)
+                                   (v128.const i64x2 0x0_90AB_cdef_8765_4321 0x0_90AB_cdef_8765_4321))
+                                   (v128.const i64x2 0x0_602f_05e9_e556_18cf 0x0_602f_05e9_e556_18cf))
+
+;; i64x2.neg
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0 0))
+                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775806 9223372036854775806))
+                                   (v128.const i64x2 -9223372036854775806 -9223372036854775806))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 9223372036854775807 9223372036854775807))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x01 0x01))
+                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x01 -0x01))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff))
+                                   (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+                                   (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.neg" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.mul (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.neg-arg-empty (result v128)
+      (i64x2.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-1st-arg-empty (result v128)
+      (i64x2.add (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.add-arg-empty (result v128)
+      (i64x2.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-1st-arg-empty (result v128)
+      (i64x2.sub (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.sub-arg-empty (result v128)
+      (i64x2.sub)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-1st-arg-empty (result v128)
+      (i64x2.mul (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.mul-arg-empty (result v128)
+      (i64x2.mul)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i64x2.add (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-add") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "mul-sub") (param v128 v128 v128) (result v128)
+    (i64x2.mul (i64x2.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i64x2.sub (i64x2.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i64x2.add (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "mul-neg") (param v128 v128) (result v128)
+    (i64x2.mul (i64x2.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i64x2.sub (i64x2.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "mul-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 4))
+(assert_return (invoke "mul-sub" (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "sub-add" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 2)
+                                 (v128.const i64x2 0 2))
+                                 (v128.const i64x2 0 1))
+(assert_return (invoke "add-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 0))
+(assert_return (invoke "mul-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 2 2))
+                                 (v128.const i64x2 0 -2))
+(assert_return (invoke "sub-neg" (v128.const i64x2 0 1)
+                                 (v128.const i64x2 0 1))
+                                 (v128.const i64x2 0 -2))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast
new file mode 100644
index 0000000..14398d8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_arith2.wast
@@ -0,0 +1,78 @@
+;; Tests for i64x2 [abs] operations.
+
+(module
+  (func (export "i64x2.abs") (param v128) (result v128) (i64x2.abs (local.get 0)))
+  (func (export "i64x2.abs_with_const_0") (result v128) (i64x2.abs (v128.const i64x2 -9223372036854775808 9223372036854775807)))
+)
+
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 1 1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -1 -1))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 18446744073709551615 18446744073709551615))
+                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0xffffffffffffffff 0xffffffffffffffff))
+                                   (v128.const i64x2 0x1 0x1))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 9223372036854775808 9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+                                   (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 01_2_3 01_2_3))
+                                   (v128.const i64x2 01_2_3 01_2_3))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -01_2_3 -01_2_3))
+                                   (v128.const i64x2 123 123))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x80 0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x80 -0x80))
+                                   (v128.const i64x2 0x80 0x80))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 0x0_8_0 0x0_8_0))
+                                   (v128.const i64x2 0x0_8_0 0x0_8_0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i64x2 0x80 0x80))
+
+;; Const vs const
+(assert_return (invoke "i64x2.abs_with_const_0") (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Param vs const
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -9223372036854775808 9223372036854775807))
+                                   (v128.const i64x2 9223372036854775808 9223372036854775807))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 0))
+                                   (v128.const i64x2 +0 0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 -0 -0))
+                                   (v128.const i64x2 -0 -0))
+(assert_return (invoke "i64x2.abs" (v128.const i64x2 +0 +0))
+                                   (v128.const i64x2 +0 +0))
+
+;; Unknown operators
+
+;; Type check
+(assert_invalid (module (func (result v128) (i64x2.abs (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.abs-arg-empty (result v128)
+      (i64x2.abs)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i64x2.abs-i64x2.abs") (param v128) (result v128) (i64x2.abs (i64x2.abs (local.get 0))))
+)
+
+(assert_return (invoke "i64x2.abs-i64x2.abs" (v128.const i64x2 -1 -1))
+                                             (v128.const i64x2 1 1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast
new file mode 100644
index 0000000..50e58b6
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_cmp.wast
@@ -0,0 +1,420 @@
+
+;; Test all the i64x2 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i64x2.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i64x2.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i64x2.lt_s (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i64x2.le_s (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i64x2.gt_s (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i64x2.ge_s (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i64x2.eq  (i64x2) (i64x2)
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 -1 -1))
+(assert_return (invoke "eq" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0FFFFFFFFFFFFFFF 0x0FFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "eq" (v128.const i64x2 0x1 0x1)
+                            (v128.const i64x2 0x2 0x2))
+                            (v128.const i64x2 0 0))
+
+;; ne
+
+;; i64x2.ne  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                            (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                            (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                            (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                            (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                            (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                            (v128.const i64x2 0 0))
+(assert_return (invoke "ne" (v128.const i64x2 0x03020100 0x11100904)
+                            (v128.const i64x2 0x03020100 0x11100904))
+                            (v128.const i64x2 0 0))
+
+;; lt_s
+
+;; i64x2.lt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "lt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; le_s
+
+;; i64x2.le_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 -1 0))
+(assert_return (invoke "le_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "le_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; gt_s
+
+;; i64x2.gt_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 0 0))
+(assert_return (invoke "gt_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 0 0))
+
+;; ge_s
+
+;; i64x2.ge_s  (i64x2) (i64x2)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0x0000000000000000)
+                              (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0)
+                              (v128.const i64x2 0xF0F0F0F0F0F0F0F0 0xF0F0F0F0F0F0F0F0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F)
+                              (v128.const i64x2 0x0F0F0F0F0F0F0F0F 0x0F0F0F0F0F0F0F0F))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000)
+                              (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0x0000000000000000))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 0x0000000000000000 0xFFFFFFFFFFFFFFFF))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B)
+                              (v128.const i64x2 0x0302010011100904 0x1A0B0A12FFABAA1B))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0xFFFFFFFFFFFFFFFF 0xFFFFFFFFFFFFFFFF)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 9259542123273814144 9259542123273814144))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8080808080808080 0x8080808080808080)
+                              (v128.const i64x2 -9187201950435737472 -9187201950435737472))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x8382818000FFFEFD 0x7F020100FFFEFD80)
+                              (v128.const i64x2 -8970465120996032771 9151878496576798080))
+                              (v128.const i64x2 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -1 -1)
+                              (v128.const i64x2 0 -1))
+                              (v128.const i64x2 0 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 0)
+                              (v128.const i64x2 0 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 18446744073709551615 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 18446744073709551615)
+                              (v128.const i64x2 -1 -1))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 18446744073709551615 0)
+                              (v128.const i64x2 18446744073709551615 0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0 18446744073709551615)
+                              (v128.const i64x2 0 18446744073709551615))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 -9223372036854775807 18446744073709551615)
+                              (v128.const i64x2 9223372036854775809 -1))
+                              (v128.const i64x2 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i64x2 0xc060000000000000 0xc05fc00000000000)
+                              (v128.const f64x2 -128.0 -127.0))
+                              (v128.const i64x2 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i64x2 0x3ff0000000000000 0x405fc00000000000)
+                              (v128.const f64x2 1.0 127.0))
+                              (v128.const i64x2 -1 -1))
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i64x2.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.eq-1st-arg-empty (result v128)
+      (i64x2.eq (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.eq-arg-empty (result v128)
+      (i64x2.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-1st-arg-empty (result v128)
+      (i64x2.ne (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.ne-arg-empty (result v128)
+      (i64x2.ne)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast
new file mode 100644
index 0000000..9259279
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i64x2_extmul_i32x4.wast
@@ -0,0 +1,404 @@
+;; Tests for i64x2 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i64x2.extmul_low_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_s") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_s (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_low_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_low_i32x4_u (local.get 0) (local.get 1)))
+  (func (export "i64x2.extmul_high_i32x4_u") (param v128 v128) (result v128) (i64x2.extmul_high_i32x4_u (local.get 0) (local.get 1)))
+)
+
+
+;; i64x2.extmul_low_i32x4_s
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 1 1))
+
+;; i64x2.extmul_high_i32x4_s
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 1152921505680588800 1152921505680588800))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686016279904256 4611686016279904256))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_s" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 1 1))
+
+;; i64x2.extmul_low_i32x4_u
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                  (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                  (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                  (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                  (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                  (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                  (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 1 1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_low_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                  (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                  (v128.const i64x2 -8589934591 -8589934591))
+
+;; i64x2.extmul_high_i32x4_u
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 0 0 0 0)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1 1 1 1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1 -1 -1 -1)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741823 1073741823 1073741823 1073741823)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921503533105152 1152921503533105152))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 1073741824 1073741824 1073741824 1073741824)
+                                                   (v128.const i32x4 1073741824 1073741824 1073741824 1073741824))
+                                                   (v128.const i64x2 1152921504606846976 1152921504606846976))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741823 -1073741823 -1073741823 -1073741823)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450529026703360 -8070450529026703360))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450532247928832 -8070450532247928832))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -1073741825 -1073741825 -1073741825 -1073741825)
+                                                   (v128.const i32x4 -1073741824 -1073741824 -1073741824 -1073741824))
+                                                   (v128.const i64x2 -8070450535469154304 -8070450535469154304))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483645 2147483645 2147483645 2147483645)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483645 2147483645))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483646 2147483646)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483648 2147483648 2147483648 2147483648)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483646 -2147483646 -2147483646 -2147483646)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372030412324866 -9223372030412324866))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -9223372034707292161 -9223372034707292161))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 4611686014132420609 4611686014132420609))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 4611686018427387904 4611686018427387904))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648)
+                                                   (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+                                                   (v128.const i64x2 4611686020574871552 4611686020574871552))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 1 1 1 1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 9223372030412324865 9223372030412324865))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 9223372034707292160 9223372034707292160))
+(assert_return (invoke "i64x2.extmul_high_i32x4_u" (v128.const i32x4 4294967295 4294967295 4294967295 4294967295)
+                                                   (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                                                   (v128.const i64x2 -8589934591 -8589934591))
+
+;; type check
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_low_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extmul_high_i32x4_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-1st-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extmul_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extmul_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast
new file mode 100644
index 0000000..1e56b4c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith.wast
@@ -0,0 +1,426 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add") (param v128 v128) (result v128) (i8x16.add (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub") (param v128 v128) (result v128) (i8x16.sub (local.get 0) (local.get 1)))
+  (func (export "i8x16.neg") (param v128) (result v128) (i8x16.neg (local.get 0)))
+)
+
+
+;; i8x16.add
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf 0x80 0x80 0 0xbf))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f 0x80 0x80 0 0x3f))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                   (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                   (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                   (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                   (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                   (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                   (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i16x8 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080 0x8080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                   (v128.const i32x4 0x80808080 0x80808080 0x80808080 0x80808080))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 +0.0 +0.0 +0.0 +0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 1.0 1.0 1.0 1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41 0x80 0x80 0 0x41))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                   (v128.const f32x4 -1.0 -1.0 -1.0 -1.0))
+                                   (v128.const i8x16 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1 0x80 0x80 0 0xc1))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 +inf +inf +inf +inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82 0x01 0x01 0x81 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 -inf -inf -inf -inf))
+                                   (v128.const i8x16 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02 0x01 0x01 0x81 0x02))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                   (v128.const f32x4 nan nan nan nan))
+                                   (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                   (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                   (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                   (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.neg
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+                                   (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f -0x7f))
+                                   (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                   (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.neg" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.neg (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.neg-arg-empty (result v128)
+      (i8x16.neg)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-1st-arg-empty (result v128)
+      (i8x16.add (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add-arg-empty (result v128)
+      (i8x16.add)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-1st-arg-empty (result v128)
+      (i8x16.sub (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub-arg-empty (result v128)
+      (i8x16.sub)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "add-sub") (param v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.sub (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sub-add") (param v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.add (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "add-neg") (param v128 v128) (result v128)
+    (i8x16.add (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sub-neg") (param v128 v128) (result v128)
+    (i8x16.sub (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "add-sub" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "sub-add" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30)
+                                 (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "add-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "sub-neg" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+                                 (v128.const i8x16 0 -2 -4 -6 -8 -10 -12 -14 -16 -18 -20 -22 -24 -26 -28 -30))
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast
new file mode 100644
index 0000000..991ec14
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_arith2.wast
@@ -0,0 +1,713 @@
+;; Tests for i8x16 [min_s, min_u, max_s, max_u, avgr_u, abs] operations.
+
+(module
+  (func (export "i8x16.min_s") (param v128 v128) (result v128) (i8x16.min_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.min_u") (param v128 v128) (result v128) (i8x16.min_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_s") (param v128 v128) (result v128) (i8x16.max_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.max_u") (param v128 v128) (result v128) (i8x16.max_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.avgr_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.abs") (param v128) (result v128) (i8x16.abs (local.get 0)))
+  (func (export "i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (local.get 0)))
+  (func (export "i8x16.min_s_with_const_0") (result v128) (i8x16.min_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_s_with_const_1") (result v128) (i8x16.min_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.min_u_with_const_2") (result v128) (i8x16.min_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.min_u_with_const_3") (result v128) (i8x16.min_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_s_with_const_4") (result v128) (i8x16.max_s (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_s_with_const_5") (result v128) (i8x16.max_s (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.max_u_with_const_6") (result v128) (i8x16.max_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.max_u_with_const_7") (result v128) (i8x16.max_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.avgr_u_with_const_8") (result v128) (i8x16.avgr_u (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255) (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128)))
+  (func (export "i8x16.avgr_u_with_const_9") (result v128) (i8x16.avgr_u (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3) (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0)))
+  (func (export "i8x16.abs_with_const_10") (result v128) (i8x16.abs (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.popcnt_with_const_11") (result v128) (i8x16.popcnt (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_12") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_s_with_const_13") (param v128) (result v128) (i8x16.min_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.min_u_with_const_14") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.min_u_with_const_15") (param v128) (result v128) (i8x16.min_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_s_with_const_16") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_s_with_const_17") (param v128) (result v128) (i8x16.max_s (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.max_u_with_const_18") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.max_u_with_const_19") (param v128) (result v128) (i8x16.max_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+  (func (export "i8x16.avgr_u_with_const_20") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)))
+  (func (export "i8x16.avgr_u_with_const_21") (param v128) (result v128) (i8x16.avgr_u (local.get 0) (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 3 3 3 3)))
+)
+
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                     (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                     (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                     (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                     (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                     (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                     (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                     (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                     (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1)
+                                      (v128.const i8x16 0 0 0 0 -1 -1 -1 -1 0 0 0 0 -1 -1 -1 -1))
+                                      (v128.const i8x16 0 0 0 0 128 128 128 128 128 128 128 128 255 255 255 255))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                      (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123)
+                                      (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                      (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                   (v128.const i8x16 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1 0x1))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                   (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                   (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                   (v128.const i8x16 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123 123))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                   (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                      (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3 01_2_3))
+                                      (v128.const i8x16 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3 -01_2_3))
+                                      (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0 0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0 -0x0_8_0))
+                                      (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+
+;; Const vs const
+(assert_return (invoke "i8x16.min_s_with_const_0") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_1") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_2") (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_3") (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_4") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_5") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_6") (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_7") (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_8") (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_9") (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.abs_with_const_10") (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt_with_const_11") (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Param vs const
+(assert_return (invoke "i8x16.min_s_with_const_12" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s_with_const_13" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.min_u_with_const_14" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u_with_const_15" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0))
+(assert_return (invoke "i8x16.max_s_with_const_16" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s_with_const_17" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.max_u_with_const_18" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                   (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u_with_const_19" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                   (v128.const i8x16 3 3 3 3 2 2 2 2 2 2 2 2 3 3 3 3))
+(assert_return (invoke "i8x16.avgr_u_with_const_20" (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                                    (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u_with_const_21" (v128.const i8x16 3 3 3 3 2 2 2 2 1 1 1 1 0 0 0 0))
+                                                    (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+
+;; Test different lanes go through different if-then clauses
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 -128 -128 -128 -128 64 64 64 64 64 64 64 64 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 1 1 1 1 1 1 1 1 128 128 128 128))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                     (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                     (v128.const i8x16 255 255 255 255 127 127 127 127 127 127 127 127 255 255 255 255))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                     (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255)
+                                      (v128.const i8x16 255 255 255 255 64 64 64 64 127 127 127 127 -128 -128 -128 -128))
+                                      (v128.const i8x16 192 192 192 192 96 96 96 96 96 96 96 96 192 192 192 192))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 0 0 0 0 1 1 1 1 2 2 2 2 128 128 128 128)
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 1 1 1 1 128 128 128 128))
+                                      (v128.const i8x16 0 0 0 0 2 2 2 2 2 2 2 2 128 128 128 128))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                   (v128.const i8x16 128 128 128 128 127 127 127 127 64 64 64 64 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -128 -128 -128 -128 127 127 127 127 64 64 64 64 255 255 255 255))
+                                      (v128.const i8x16 1 1 1 1 7 7 7 7 1 1 1 1 8 8 8 8))
+
+;; Test opposite signs of zero
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.min_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_s" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                     (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.max_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                     (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                     (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0)
+                                      (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.avgr_u" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0)
+                                      (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                   (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                   (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+(assert_return (invoke "i8x16.abs" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                   (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 0 0 0 0 -0 -0 -0 -0 0 0 0 0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0 -0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt" (v128.const i8x16 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0 +0))
+                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Unknown operators
+(assert_malformed (module quote "(memory 1) (func (result v128) (i32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f32x4.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (f64x2.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (result v128) (i8x16.avgr_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)))") "unknown operator")
+
+;; Type check
+(assert_invalid (module (func (result v128) (i8x16.min_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.min_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.max_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.avgr_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.abs (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.popcnt (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.min_s-1st-arg-empty (result v128)
+      (i8x16.min_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_s-arg-empty (result v128)
+      (i8x16.min_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-1st-arg-empty (result v128)
+      (i8x16.min_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.min_u-arg-empty (result v128)
+      (i8x16.min_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-1st-arg-empty (result v128)
+      (i8x16.max_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_s-arg-empty (result v128)
+      (i8x16.max_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-1st-arg-empty (result v128)
+      (i8x16.max_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.max_u-arg-empty (result v128)
+      (i8x16.max_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-1st-arg-empty (result v128)
+      (i8x16.avgr_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.avgr_u-arg-empty (result v128)
+      (i8x16.avgr_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.abs-arg-empty (result v128)
+      (i8x16.abs)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.popcnt-arg-empty (result v128)
+      (i8x16.popcnt)
+    )
+  )
+  "type mismatch"
+)
+
+;; Combination
+(module
+  (func (export "i8x16.min_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.min_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.min_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.min_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.min_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.min_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.min_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.min_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.min_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_s (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_s-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_s (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_s") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_s-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_s (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_s") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_s (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.max_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.max_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.max_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.max_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.max_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.max_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.max_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.max_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.avgr_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.avgr_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.max_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.max_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_u") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.min_s") (param v128 v128 v128) (result v128) (i8x16.avgr_u (i8x16.min_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "i8x16.avgr_u-i8x16.abs") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.abs (local.get 0))(local.get 1)))
+  (func (export "i8x16.abs-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.abs (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.avgr_u-i8x16.popcnt") (param v128 v128) (result v128) (i8x16.avgr_u (i8x16.popcnt (local.get 0))(local.get 1)))
+  (func (export "i8x16.popcnt-i8x16.avgr_u") (param v128 v128) (result v128) (i8x16.popcnt (i8x16.avgr_u (local.get 0) (local.get 1))))
+  (func (export "i8x16.abs-i8x16.popcnt") (param v128) (result v128) (i8x16.abs (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.abs-i8x16.abs") (param v128) (result v128) (i8x16.abs (i8x16.abs (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.popcnt") (param v128) (result v128) (i8x16.popcnt (i8x16.popcnt (local.get 0))))
+  (func (export "i8x16.popcnt-i8x16.abs") (param v128) (result v128) (i8x16.popcnt (i8x16.abs (local.get 0))))
+)
+
+(assert_return (invoke "i8x16.min_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.min_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.min_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.abs-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.min_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.popcnt-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_s-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_s-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.max_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                 (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                 (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.max_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                               (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                               (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                               (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.max_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                  (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.popcnt-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.avgr_u-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                   (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.max_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.min_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                                  (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+                                                  (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.avgr_u-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.avgr_u-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "i8x16.popcnt-i8x16.avgr_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                                   (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.abs-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8))
+(assert_return (invoke "i8x16.abs-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                             (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.popcnt" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.popcnt-i8x16.abs" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast
new file mode 100644
index 0000000..8683acc
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_cmp.wast
@@ -0,0 +1,1847 @@
+
+;; Test all the i8x16 comparison operators on major boundary values and all special values.
+
+(module
+  (func (export "eq") (param $x v128) (param $y v128) (result v128) (i8x16.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x v128) (param $y v128) (result v128) (i8x16.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x v128) (param $y v128) (result v128) (i8x16.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x v128) (param $y v128) (result v128) (i8x16.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x v128) (param $y v128) (result v128) (i8x16.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x v128) (param $y v128) (result v128) (i8x16.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x v128) (param $y v128) (result v128) (i8x16.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x v128) (param $y v128) (result v128) (i8x16.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x v128) (param $y v128) (result v128) (i8x16.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x v128) (param $y v128) (result v128) (i8x16.ge_u (local.get $x) (local.get $y)))
+)
+
+
+;; eq
+
+;; i8x16.eq  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "eq" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "eq" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 -1 -1 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i16x8)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.eq  (i8x16) (i32x4)
+(assert_return (invoke "eq" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "eq" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "eq" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ne
+
+;; i8x16.ne  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                            (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "ne" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                            (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                            (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                            (v128.const f32x4 1.0 127.0 128.0 255.0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "ne" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                            (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                            (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                            (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 0 0 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne (i8x16) (i16x8)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                            (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ne  (i8x16) (i32x4)
+(assert_return (invoke "ne" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                            (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                            (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                            (v128.const i32x4 0 0 0 0))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                            (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                            (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ne" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                            (v128.const i32x4 -128 0 1 255))
+                            (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ne" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                            (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                            (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; lt_s
+
+;; i8x16.lt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 0 0 0 0 0 -1 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i16x8)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 -1 0 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.lt_s  (i8x16) (i32x4)
+(assert_return (invoke "lt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "lt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; lt_u
+
+;; i8x16.lt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "lt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "lt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.lt_u  (i8x16) (i16x8)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 -1 0 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.lt_u  (i8x16) (i32x4)
+(assert_return (invoke "lt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 -1 -1 -1 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "lt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; le_s
+
+;; i8x16.le_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 0 -1 0 -1 0 0 0 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i16x8)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.le_s  (i8x16) (i32x4)
+(assert_return (invoke "le_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 -1 -1 -1))
+(assert_return (invoke "le_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; le_u
+
+;; i8x16.le_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "le_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "le_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 0 0 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0))
+
+;; i8x16.le_u  (i8x16) (i16x8)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0 -1 0 -1 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.le_u  (i8x16) (i32x4)
+(assert_return (invoke "le_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "le_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 -1 0 0 0))
+(assert_return (invoke "le_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_s
+
+;; i8x16.gt_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i16x8)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.gt_s  (i8x16) (i32x4)
+(assert_return (invoke "gt_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 0 0 0))
+(assert_return (invoke "gt_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; gt_u
+
+;; i8x16.gt_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; dec vs dec
+(assert_return (invoke "gt_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; hex vs float
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; not equal
+(assert_return (invoke "gt_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 0 0 0 0 0 0 -1 -1 -1))
+
+;; i8x16.gt_u  (i8x16) (i16x8)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 0 -1 0 -1 0 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.gt_u  (i8x16) (i32x4)
+(assert_return (invoke "gt_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "gt_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "gt_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; ge_s
+
+;; i8x16.ge_s  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_s" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 -1 -1 -1 0 0 0 -1 0 -1 0 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 0 0 0 -1 -1 -1 -1 -1 0 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i16x8)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 -1 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; i8x16.ge_s  (i8x16) (i32x4)
+(assert_return (invoke "ge_s" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_s" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0))
+(assert_return (invoke "ge_s" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; ge_u
+
+;; i8x16.ge_u  (i8x16) (i8x16)
+
+;; hex vs hex
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                              (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; dec vs dec
+(assert_return (invoke "ge_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0)
+                              (v128.const i8x16 255 255 255 255 255 255 255 255 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255)
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 255 255 255 255 255 255 255 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 -0 0 1 2 127 128 253 254 255))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; hex vs float
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0xc3 0x00 0x00 0xfe 0xc2 0x00 0x00 0x80 0xbf 0x00 0x00 0x00 0x00)
+                              (v128.const f32x4 -128.0 -127.0 -1.0 0.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x80 0x3f 0x00 0x00 0xfe 0x42 0x00 0x00 0x00 0x43 0x00 0x00 0x7f 0x43)
+                              (v128.const f32x4 1.0 127.0 128.0 255.0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+
+;; not equal
+(assert_return (invoke "ge_u" (v128.const i8x16 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F 0x0F)
+                              (v128.const i8x16 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0 0xF0))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x09 0x10 0x11 0x12 0x0A 0x0B 0x1A 0x1B 0xAA 0xAB 0xFF)
+                              (v128.const i8x16 0xFF 0xAB 0xAA 0x1B 0x1A 0x0B 0x0A 0x12 0x11 0x10 0x09 0x04 0x03 0x02 0x01 0x00))
+                              (v128.const i8x16 0 0 0 0 0 0 -1 0 -1 0 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x80 0x81 0x82 0x83 0xFD 0xFE 0xFF 0x00 0x00 0x01 0x02 0x7F 0x80 0xFD 0xFE 0xFF)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 128 129 130 131 253 254 255 -0 0 1 2 127 128 253 254 255)
+                              (v128.const i8x16 255 254 253 128 127 2 1 0 -0 -1 -2 -3 -125 -126 -127 -128))
+                              (v128.const i8x16 0 0 0 -1 -1 -1 -1 -1 -1 0 0 0 0 -1 -1 -1))
+
+;; i8x16.ge_u (i8x16) (i16x8)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i16x8 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF 0xFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i16x8 65535 65535 65535 65535 65535 65535 65535 65535))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i16x8 0 0 0 0 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0B0A 0x0D0C 0x0F0E))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i16x8 33152 33666 65277 255 256 32514 64896 65534))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i16x8 -128 -128 0 0 1 1 255 255))
+                              (v128.const i8x16 -1 0 -1 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i16x8 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA 0xAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; i8x16.ge_u (i8x16) (i32x4)
+(assert_return (invoke "ge_u" (v128.const i8x16 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF)
+                              (v128.const i32x4 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF 0xFFFFFFFF))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                              (v128.const i32x4 4294967295 4294967295 4294967295 4294967295))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                              (v128.const i32x4 0 0 0 0))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0A 0x0B 0x0C 0x0D 0x0E 0x0F)
+                              (v128.const i32x4 0x03020100 0x07060504 0x0B0A0908 0x0F0E0D0C))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -127 -126 -125 -3 -2 -1 0 0 1 2 127 128 253 254 255)
+                              (v128.const i32x4 2206368128 16776957 2130837760 4294901120))
+                              (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 -128 -128 -128 -128 0 0 0 0 1 1 1 1 255 255 255 255)
+                              (v128.const i32x4 -128 0 1 255))
+                              (v128.const i8x16 -1 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "ge_u" (v128.const i8x16 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55 0x55)
+                              (v128.const i32x4 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA 0xAAAAAAAA))
+                              (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+
+;; Type check
+
+(assert_invalid (module (func (result v128) (i8x16.eq (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ge_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.gt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.le_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_s (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.lt_u (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.ne (i32.const 0) (f32.const 0)))) "type mismatch")
+
+
+;; combination
+
+(module (memory 1)
+  (func (export "eq-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.eq
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ne-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ne
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "lt_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.lt_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "le_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.le_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "gt_u-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.gt_u
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "ge_s-in-block")
+    (block
+      (drop
+        (block (result v128)
+          (i8x16.ge_s
+            (block (result v128) (v128.load (i32.const 0)))
+            (block (result v128) (v128.load (i32.const 1)))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-eq")
+    (drop
+      (i8x16.eq
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.eq
+          (i8x16.eq
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.eq
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ne")
+    (drop
+      (i8x16.ne
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.ne
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ne
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-lt_s")
+    (drop
+      (i8x16.lt_s
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.lt_s
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-le_u")
+    (drop
+      (i8x16.le_u
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.le_u
+          (i8x16.le_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-gt_u")
+    (drop
+      (i8x16.gt_u
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.gt_u
+          (i8x16.gt_u
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.gt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "nested-ge_s")
+    (drop
+      (i8x16.ge_s
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ge_s
+          (i8x16.ge_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.ge_s
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+  (func (export "as-param")
+    (drop
+      (i8x16.ge_u
+        (i8x16.eq
+          (i8x16.lt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.le_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+        (i8x16.ne
+          (i8x16.gt_s
+            (v128.load (i32.const 0))
+            (v128.load (i32.const 1))
+          )
+          (i8x16.lt_u
+            (v128.load (i32.const 2))
+            (v128.load (i32.const 3))
+          )
+        )
+      )
+    )
+  )
+)
+(assert_return (invoke "eq-in-block"))
+(assert_return (invoke "ne-in-block"))
+(assert_return (invoke "lt_s-in-block"))
+(assert_return (invoke "le_u-in-block"))
+(assert_return (invoke "gt_u-in-block"))
+(assert_return (invoke "ge_s-in-block"))
+(assert_return (invoke "nested-eq"))
+(assert_return (invoke "nested-ne"))
+(assert_return (invoke "nested-lt_s"))
+(assert_return (invoke "nested-le_u"))
+(assert_return (invoke "nested-gt_u"))
+(assert_return (invoke "nested-ge_s"))
+(assert_return (invoke "as-param"))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.eq-1st-arg-empty (result v128)
+      (i8x16.eq (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.eq-arg-empty (result v128)
+      (i8x16.eq)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-1st-arg-empty (result v128)
+      (i8x16.ne (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ne-arg-empty (result v128)
+      (i8x16.ne)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-1st-arg-empty (result v128)
+      (i8x16.lt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_s-arg-empty (result v128)
+      (i8x16.lt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-1st-arg-empty (result v128)
+      (i8x16.lt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.lt_u-arg-empty (result v128)
+      (i8x16.lt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-1st-arg-empty (result v128)
+      (i8x16.le_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_s-arg-empty (result v128)
+      (i8x16.le_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-1st-arg-empty (result v128)
+      (i8x16.le_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.le_u-arg-empty (result v128)
+      (i8x16.le_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-1st-arg-empty (result v128)
+      (i8x16.gt_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_s-arg-empty (result v128)
+      (i8x16.gt_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-1st-arg-empty (result v128)
+      (i8x16.gt_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.gt_u-arg-empty (result v128)
+      (i8x16.gt_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-1st-arg-empty (result v128)
+      (i8x16.ge_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_s-arg-empty (result v128)
+      (i8x16.ge_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-1st-arg-empty (result v128)
+      (i8x16.ge_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.ge_u-arg-empty (result v128)
+      (i8x16.ge_u)
+    )
+  )
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast
new file mode 100644
index 0000000..a799a8b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_i8x16_sat_arith.wast
@@ -0,0 +1,718 @@
+;; Tests for i8x16 arithmetic operations on major boundary values and all special values.
+
+
+(module
+  (func (export "i8x16.add_sat_s") (param v128 v128) (result v128) (i8x16.add_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.add_sat_u") (param v128 v128) (result v128) (i8x16.add_sat_u (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_s") (param v128 v128) (result v128) (i8x16.sub_sat_s (local.get 0) (local.get 1)))
+  (func (export "i8x16.sub_sat_u") (param v128 v128) (result v128) (i8x16.sub_sat_u (local.get 0) (local.get 1)))
+)
+
+
+;; i8x16.add_sat_s
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f 0x01 0x01 0x81 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0 0x01 0x01 0x81 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f 0x01 0x01 0xc1 0x7f))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0 0x01 0x01 0xc1 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.add_sat_u
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff 0x80 0x80 0x80 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80 0x01 0x01 0x81 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff 0x01 0x01 0x81 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80 0x01 0x01 0xc1 0x80))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff 0x01 0x01 0xc1 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+(assert_return (invoke "i8x16.add_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 3 6 9 12 15 18 21 24 27 30 33 36 39 42 45))
+
+;; i8x16.sub_sat_s
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125 -125))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82 0x01 0x01 0x7f 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02 0x01 0x01 0x7f 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82 0x01 0x01 0x41 0x82))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02 0x01 0x01 0x41 0x02))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0x02 0x04 0x06 0x08 0x0a 0x0c 0x0e 0x10 0x12 0x14 0x16 0x18 0x1a 0x1c 0x1e))
+(assert_return (invoke "i8x16.sub_sat_s" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15))
+
+;; i8x16.sub_sat_u
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63 63)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63 -63)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65 -65)
+                                         (v128.const i8x16 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64 -64))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124 124))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125 125))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126 -126)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127 -127))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f 0x3f)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40)
+                                         (v128.const i8x16 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40 0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f -0x3f)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40 -0x40)
+                                         (v128.const i8x16 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41 -0x41))
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01 -0x01))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01 0x01))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff)
+                                         (v128.const i8x16 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80)
+                                         (v128.const f32x4 -0.0 -0.0 -0.0 -0.0))
+                                         (v128.const i8x16 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0 0x80 0x80 0x80 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 +inf +inf +inf +inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -inf -inf -inf -inf))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 nan nan nan nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
+                                         (v128.const f32x4 -nan -nan -nan -nan))
+                                         (v128.const i8x16 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0 0x01 0x01 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 0xff 0xfe 0xfd 0xfc 0xfb 0xfa 0xf9 0xf8 0xf7 0xf6 0xf5 0xf4 0xf3 0xf2 0xf1))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.sub_sat_u" (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+                                         (v128.const i8x16 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30))
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+;; Malformed cases: non-existent op names
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.add_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.sub_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.mul_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i8x16.div_sat (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.add_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_s (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (i32x4.sub_sat_u (v128.const i32x4 0 0 0 0) (v128.const i32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.add_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_s (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+(assert_malformed (module quote
+    "(func (result v128) (f32x4.sub_sat_u (v128.const f32x4 0 0 0 0) (v128.const f32x4 0 0 0 0)))")
+    "unknown operator")
+
+;; type check
+(assert_invalid (module (func (result v128) (i8x16.add_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.add_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_s (i32.const 0) (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.sub_sat_u (i32.const 0) (f32.const 0.0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-1st-arg-empty (result v128)
+      (i8x16.add_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_s-arg-empty (result v128)
+      (i8x16.add_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-1st-arg-empty (result v128)
+      (i8x16.add_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.add_sat_u-arg-empty (result v128)
+      (i8x16.add_sat_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-1st-arg-empty (result v128)
+      (i8x16.sub_sat_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_s-arg-empty (result v128)
+      (i8x16.sub_sat_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-1st-arg-empty (result v128)
+      (i8x16.sub_sat_u (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.sub_sat_u-arg-empty (result v128)
+      (i8x16.sub_sat_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; combination
+(module
+  (func (export "sat-add_s-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_s") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_s (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_u-sub_u") (param v128 v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.sub_sat_u (local.get 0) (local.get 1))(local.get 2)))
+  (func (export "sat-add_s-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-add_u-neg") (param v128 v128) (result v128)
+    (i8x16.add_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_s-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_s (i8x16.neg (local.get 0)) (local.get 1)))
+  (func (export "sat-sub_u-neg") (param v128 v128) (result v128)
+    (i8x16.sub_sat_u (i8x16.neg (local.get 0)) (local.get 1)))
+)
+
+(assert_return (invoke "sat-add_s-sub_s" (v128.const i8x16 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64 64)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-add_s-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                         (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-sub_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                         (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)
+                                         (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                         (v128.const i8x16 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254 254))
+(assert_return (invoke "sat-add_u-sub_u" (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255)
+                                         (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+                                         (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+                                         (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-add_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "sat-add_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255 255))
+(assert_return (invoke "sat-sub_s-neg" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128)
+                                       (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "sat-sub_u-neg" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127)
+                                       (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                       (v128.const i8x16 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/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast
new file mode 100644
index 0000000..be8d554
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_int_to_int_extend.wast
@@ -0,0 +1,599 @@
+;; Tests for int-to-int extension operations.
+
+(module
+  (func (export "i16x8.extend_high_i8x16_s") (param v128) (result v128) (i16x8.extend_high_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_high_i8x16_u") (param v128) (result v128) (i16x8.extend_high_i8x16_u (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_s") (param v128) (result v128) (i16x8.extend_low_i8x16_s (local.get 0)))
+  (func (export "i16x8.extend_low_i8x16_u") (param v128) (result v128) (i16x8.extend_low_i8x16_u (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_s") (param v128) (result v128) (i32x4.extend_high_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_high_i16x8_u") (param v128) (result v128) (i32x4.extend_high_i16x8_u (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_s") (param v128) (result v128) (i32x4.extend_low_i16x8_s (local.get 0)))
+  (func (export "i32x4.extend_low_i16x8_u") (param v128) (result v128) (i32x4.extend_low_i16x8_u (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_s") (param v128) (result v128) (i64x2.extend_high_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_high_i32x4_u") (param v128) (result v128) (i64x2.extend_high_i32x4_u (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_s") (param v128) (result v128) (i64x2.extend_low_i32x4_s (local.get 0)))
+  (func (export "i64x2.extend_low_i32x4_u") (param v128) (result v128) (i64x2.extend_low_i32x4_u (local.get 0)))
+)
+
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_high_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                   (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                   (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                   (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                   (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                   (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                   (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_high_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                   (v128.const i16x8 128 128 128 128 128 128 128 128))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -127 -127 -127 -127 -127 -127 -127 -127))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i16x8.extend_low_i8x16_s" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 0 0 0 0 0 0 0 0 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 0 0 0 0 0 0 0 0))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 1 1 1 1 1 1 1 1 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 1 1 1 1 1 1 1 1))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 126 126 126 126 126 126 126 126 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 126 126 126 126 126 126 126 126))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 126 126 126 126 126 126 126 126))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 127 127 127 127 127 127 127 127 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 127 127 127 127 127 127 127 127))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -127 -127 -127 -127 -127 -127 -127 -127 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -127 -127 -127 -127 -127 -127 -127 -127))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -1 -1 -1 -1 -1 -1 -1 -1))
+                                                  (v128.const i16x8 128 128 128 128 128 128 128 128))
+(assert_return (invoke "i16x8.extend_low_i8x16_u" (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -128 -128 -128 -128 -128 -128 -128 -128))
+                                                  (v128.const i16x8 255 255 255 255 255 255 255 255))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_high_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 -32768 -32768 -32768 -32768))
+
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                   (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                   (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                   (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                   (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                   (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                   (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_high_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                   (v128.const i32x4 32768 32768 32768 32768))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -32767 -32767 -32767 -32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_s" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 1 1 1 1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 0 0 0 0 -1 -1 -1 -1))
+                                                  (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 0 0 0 0))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 1 1 1 1 -1 -1 -1 -1))
+                                                  (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 1 1 1 1))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32766 32766 32766 32766 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32766 32766 32766 32766))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32766 32766 32766 32766))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 32767 32767 32767 32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 32767 32767 32767 32767 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32767 32767 32767 32767))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 32767 32767 32767 32767))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32767 -32767 -32767 -32767 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 32769 32769 32769 32769))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -32767 -32767 -32767 -32767))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -32768 -32768 -32768 -32768 -1 -1 -1 -1))
+                                                  (v128.const i32x4 32768 32768 32768 32768))
+(assert_return (invoke "i32x4.extend_low_i16x8_u" (v128.const i16x8 -1 -1 -1 -1 -32768 -32768 -32768 -32768))
+                                                  (v128.const i32x4 65535 65535 65535 65535))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_high_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 -2147483648 -2147483648))
+
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                   (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                   (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                   (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                   (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                   (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                   (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_high_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                   (v128.const i64x2 2147483648 2147483648))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -2147483647 -2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 -2147483648 -2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_s" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 0 0))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 1 1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 0 0 -1 -1))
+                                                  (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 0 0))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 0 0))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 1 1 -1 -1))
+                                                  (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 1 1))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483646 2147483646 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483646 2147483646))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483646 2147483646))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 2147483647 2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 2147483647 2147483647 -1 -1))
+                                                  (v128.const i64x2 2147483647 2147483647))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 2147483647 2147483647))
+                                                  (v128.const i64x2 4294967295 4294967295))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483647 -2147483647 -2147483648 -2147483648))
+                                                  (v128.const i64x2 2147483649 2147483649))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -2147483647 -2147483647))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -2147483648 -2147483648 -1 -1))
+                                                  (v128.const i64x2 2147483648 2147483648))
+(assert_return (invoke "i64x2.extend_low_i32x4_u" (v128.const i32x4 -1 -1 -2147483648 -2147483648))
+                                                  (v128.const i64x2 4294967295 4294967295))
+
+
+;; type check
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_high_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.extend_low_i8x16_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_high_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.extend_low_i16x8_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_high_i32x4_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i64x2.extend_low_i32x4_u (i32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_high_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_high_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_s-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extend_low_i8x16_u-arg-empty (result v128)
+      (i16x8.extend_low_i8x16_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_high_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_high_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_s-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extend_low_i16x8_u-arg-empty (result v128)
+      (i32x4.extend_low_i16x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_high_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_high_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_s-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extend_low_i32x4_u-arg-empty (result v128)
+      (i64x2.extend_low_i32x4_u)
+    )
+  )
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_lane.wast
new file mode 100644
index 0000000..9d4b5fd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_lane.wast
@@ -0,0 +1,1265 @@
+;; Tests for the extract_lane, replace_lane, swizzle and shuffle group instructions
+
+
+(module
+  (func (export "i8x16_extract_lane_s-first") (param v128) (result i32)
+    (i8x16.extract_lane_s 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_s-last") (param v128) (result i32)
+    (i8x16.extract_lane_s 15 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-first") (param v128) (result i32)
+    (i8x16.extract_lane_u 0 (local.get 0)))
+  (func (export "i8x16_extract_lane_u-last") (param v128) (result i32)
+    (i8x16.extract_lane_u 15 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-first") (param v128) (result i32)
+    (i16x8.extract_lane_s 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_s-last") (param v128) (result i32)
+    (i16x8.extract_lane_s 7 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-first") (param v128) (result i32)
+    (i16x8.extract_lane_u 0 (local.get 0)))
+  (func (export "i16x8_extract_lane_u-last") (param v128) (result i32)
+    (i16x8.extract_lane_u 7 (local.get 0)))
+  (func (export "i32x4_extract_lane-first") (param v128) (result i32)
+    (i32x4.extract_lane 0 (local.get 0)))
+  (func (export "i32x4_extract_lane-last") (param v128) (result i32)
+    (i32x4.extract_lane 3 (local.get 0)))
+  (func (export "f32x4_extract_lane-first") (param v128) (result f32)
+    (f32x4.extract_lane 0 (local.get 0)))
+  (func (export "f32x4_extract_lane-last") (param v128) (result f32)
+    (f32x4.extract_lane 3 (local.get 0)))
+  (func (export "i8x16_replace_lane-first") (param v128 i32) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i8x16_replace_lane-last") (param v128 i32) (result v128)
+    (i8x16.replace_lane 15 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-first") (param v128 i32) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i16x8_replace_lane-last") (param v128 i32) (result v128)
+    (i16x8.replace_lane 7 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-first") (param v128 i32) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i32x4_replace_lane-last") (param v128 i32) (result v128)
+    (i32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-first") (param v128 f32) (result v128)
+    (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f32x4_replace_lane-last") (param v128 f32) (result v128)
+    (f32x4.replace_lane 3 (local.get 0) (local.get 1)))
+  (func (export "i64x2_extract_lane-first") (param v128) (result i64)
+    (i64x2.extract_lane 0 (local.get 0)))
+  (func (export "i64x2_extract_lane-last") (param v128) (result i64)
+    (i64x2.extract_lane 1 (local.get 0)))
+  (func (export "f64x2_extract_lane-first") (param v128) (result f64)
+    (f64x2.extract_lane 0 (local.get 0)))
+  (func (export "f64x2_extract_lane-last") (param v128) (result f64)
+    (f64x2.extract_lane 1 (local.get 0)))
+  (func (export "i64x2_replace_lane-first") (param v128 i64) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "i64x2_replace_lane-last") (param v128 i64) (result v128)
+    (i64x2.replace_lane 1 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-first") (param v128 f64) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+  (func (export "f64x2_replace_lane-last") (param v128 f64) (result v128)
+    (f64x2.replace_lane 1 (local.get 0) (local.get 1)))
+
+  ;; Swizzle and shuffle
+  (func (export "v8x16_swizzle") (param v128 v128) (result v128)
+    (i8x16.swizzle (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-1") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-2") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-3") (param v128 v128) (result v128)
+    (i8x16.shuffle 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-4") (param v128 v128) (result v128)
+    (i8x16.shuffle 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-5") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-6") (param v128 v128) (result v128)
+    (i8x16.shuffle 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+  (func (export "v8x16_shuffle-7") (param v128 v128) (result v128)
+    (i8x16.shuffle  0  0  0  0  0  0  0  0 16 16 16 16 16 16 16 16 (local.get 0) (local.get 1)))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0x7f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 127))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_s-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-first" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_s-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const -128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff)) (i32.const 255))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128)) (i32.const 128))
+(assert_return (invoke "i8x16_extract_lane_u-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (i32.const 128))
+
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 32767 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0x7fff 0 0 0 0 0 0 0)) (i32.const 32767))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const -1))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_s-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const -0x1234))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 65535 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 0xffff 0 0 0 0 0 0 0)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 012_345 0 0 0 0 0 0 0)) (i32.const 12345))
+(assert_return (invoke "i16x8_extract_lane_u-first" (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0)) (i32.const 60876))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const -32768))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_s-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const -0x6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -1)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0xffff)) (i32.const 65535))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -32768)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i32.const 32768))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 06_789)) (i32.const 6789))
+(assert_return (invoke "i16x8_extract_lane_u-last" (v128.const i16x8 0 0 0 0 0 0 0 -0x0_6789)) (i32.const 39031))
+
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 2147483647 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0x7fffffff 0 0 0)) (i32.const 2147483647))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 4294967295 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 0xffffffff 0 0 0)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 01_234_567_890 0 0 0)) (i32.const 1234567890))
+(assert_return (invoke "i32x4_extract_lane-first" (v128.const i32x4 -0x0_1234_5678 0 0 0)) (i32.const -0x12345678))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -2147483648)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -1)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0xffffffff)) (i32.const -1))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 0_987_654_321)) (i32.const 987654321))
+(assert_return (invoke "i32x4_extract_lane-last" (v128.const i32x4 0 0 0 -0x0_1234_5678)) (i32.const -0x12345678))
+
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 9223372036854775807 0)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x7ffffffffffffffe 0)) (i64.const 0x7ffffffffffffffe))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 18446744073709551615 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0xffffffffffffffff 0)) (i64.const -1))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 01_234_567_890_123_456_789 0)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-first" (v128.const i64x2 0x0_1234_5678_90AB_cdef 0)) (i64.const 0x1234567890abcdef))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const -0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x8000000000000000)) (i64.const 0x8000000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0x7f)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x8000)) (i64.const -9223372036854775808))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fffffff)) (i64.const 9223372036854775807))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const f64x2 -inf +inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 01_234_567_890_123_456_789)) (i64.const 1234567890123456789))
+(assert_return (invoke "i64x2_extract_lane-last" (v128.const i64x2 0 0x0_1234_5678_90AB_cdef)) (i64.const 0x1234567890abcdef))
+
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 -5.0 0.0 0.0 0.0)) (f32.const -5.0))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 1e38 0.0 0.0 0.0)) (f32.const 1e38))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0)) (f32.const 0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x1p127 0.0 0.0 0.0)) (f32.const 0x1p127))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0)) (f32.const inf))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 nan inf 0.0 0.0)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0123456789.0123456789e+019 0.0 0.0 0.0)) (f32.const 123456789.0123456789e+019))
+(assert_return (invoke "f32x4_extract_lane-first" (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0.0 0.0 0.0)) (f32.const 0x123456789ABCDEF.019aFp-019))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -1e38)) (f32.const -1e38))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127)) (f32.const -0x1.fffffep127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -0x1p127)) (f32.const -0x1p127))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf)) (f32.const -inf))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 -inf nan)) (f32.const nan))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0123456789.)) (f32.const 123456789.0))
+(assert_return (invoke "f32x4_extract_lane-last" (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.)) (f32.const 0x123456789ABCDEF.0p0))
+
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.5 0.0)) (f64.const -1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.5 0.0)) (f64.const 1.5))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -1.7976931348623157e-308 0x0p+0)) (f64.const -1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 1.7976931348623157e-308 0x0p-0)) (f64.const 1.7976931348623157e-308))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -0x1.fffffffffffffp-1023 0x0p+0)) (f64.const -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x1.fffffffffffffp-1023 0x0p-0)) (f64.const 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -inf 0.0)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 inf 0.0)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 -nan -0.0)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 nan 0.0)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0123456789.0123456789e+019 0.0)) (f64.const 123456789.0123456789e+019))
+(assert_return (invoke "f64x2_extract_lane-first" (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0.0)) (f64.const 0x123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 2.25)) (f64.const 2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 -2.25)) (f64.const -2.25))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -1.7976931348623157e+308)) (f64.const -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 1.7976931348623157e+308)) (f64.const 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p-0 -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0x0p+0 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -inf)) (f64.const -inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 inf)) (f64.const inf))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 -0.0 -nan)) (f64.const -nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 nan)) (f64.const nan))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0123456789.)) (f64.const 123456789.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const f64x2 0.0 0x0123456789ABCDEFabcdef.)) (f64.const 0x123456789ABCDEFabcdef.0))
+
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (f64.const 0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x80)) (f64.const -0.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0x4000)) (f64.const 2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0xc000)) (f64.const -2.0))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x7fefffff)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0 0x00100000)) (f64.const 0x1.0000000000000p-1022))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 0xffffffff 0x000fffff)) (f64.const 0x1.ffffffffffffep-1023))
+(assert_return (invoke "f64x2_extract_lane-last" (v128.const i32x4 0 0 1 0)) (f64.const 0x0.0000000000002p-1023))
+
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 127)) (v128.const i8x16 127 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 128)) (v128.const i8x16 -128 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-first" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -128)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -128))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -129)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 127))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0xff))
+(assert_return (invoke "i8x16_replace_lane-last" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32767)) (v128.const i16x8 32767 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 32768)) (v128.const i16x8 -32768 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65536)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 012345)) (v128.const i16x8 012_345 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-first" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x01234)) (v128.const i16x8 -0x0_1234 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32768)) (v128.const i16x8 0 0 0 0 0 0 0 -32768))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -32769)) (v128.const i16x8 0 0 0 0 0 0 0 32767))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x7fffffff)) (v128.const i16x8 0 0 0 0 0 0 0 0xffff))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 0x80000000)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 054321)) (v128.const i16x8 0 0 0 0 0 0 0 054_321))
+(assert_return (invoke "i16x8_replace_lane-last" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const -0x04321)) (v128.const i16x8 0 0 0 0 0 0 0 -0x0_4321))
+
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 2147483647)) (v128.const i32x4 2147483647 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 4294967295)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 01_234_567_890 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-first" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 -0x0_1234_5678 0 0 0))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 2147483648)) (v128.const i32x4 0 0 0 2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -2147483648)) (v128.const i32x4 0 0 0 -2147483648))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const 01234567890)) (v128.const i32x4 0 0 0 01_234_567_890))
+(assert_return (invoke "i32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (i32.const -0x012345678)) (v128.const i32x4 0 0 0 -0x0_1234_5678))
+
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const i32x4 0 0 0 0 ) (f32.const 53.0)) (v128.const f32x4 53.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 nan 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const inf)) (v128.const f32x4 inf 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 nan 0.0 0.0 0.0) (f32.const 3.14)) (v128.const f32x4 3.14 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 1e38)) (v128.const f32x4 1e38 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 inf 0.0 0.0 0.0) (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789)) (v128.const f32x4 0123456789 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-first" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0.0 0.0 0.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const i32x4 0 0 0 0) (f32.const -53.0)) (v128.const f32x4 0.0 0.0 0.0 -53.0))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const nan)) (v128.const f32x4 0.0 0.0 0.0 nan))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const -inf)) (v128.const f32x4 0.0 0.0 0.0 -inf))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 nan) (f32.const 3.14)) (v128.const f32x4 0.0 0.0 0.0 3.14))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -1e38)) (v128.const f32x4 0.0 0.0 0.0 -1e38))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1.fffffep127)) (v128.const f32x4 0.0 0.0 0.0 -0x1.fffffep127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 -inf) (f32.const -0x1p127)) (v128.const f32x4 0.0 0.0 0.0 -0x1p127))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789e019)) (v128.const f32x4 0.0 0.0 0.0 0123456789e019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0123456789.e+019)) (v128.const f32x4 0.0 0.0 0.0 0123456789.e+019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4_replace_lane-last" (v128.const f32x4 0.0 0.0 0.0 0.0) (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0.0 0.0 0.0 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 18446744073709551615)) (v128.const i64x2 -1 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 0))
+(assert_return (invoke "i64x2_replace_lane-first" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 9223372036854775808)) (v128.const i64x2 0 -9223372036854775808))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 01234567890123456789)) (v128.const i64x2 0 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2_replace_lane-last" (v128.const i64x2 0 0) (i64.const 0x01234567890abcdef)) (v128.const i64x2 0 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 1.0 1.0) (f64.const 0x0p+0)) (v128.const f64x2 0.0 1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -1.0 -1.0) (f64.const -0x0p-0)) (v128.const f64x2 -0.0 -1.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 1.25)) (v128.const f64x2 1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -1.25)) (v128.const f64x2 -1.25 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -nan 0.0) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 -1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 nan 0.0) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 1.7976931348623157e+308 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 -inf 0.0) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 -0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 inf 0.0) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0x1.fffffffffffffp-1023 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 -nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 nan 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 -inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 inf 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789)) (v128.const f64x2 0123456789 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0.0))
+(assert_return (invoke "f64x2_replace_lane-first" (v128.const f64x2 0.0 0.0) (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 2.0 2.0) (f64.const 0.0)) (v128.const f64x2 2.0 0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 -2.0 -2.0) (f64.const -0.0)) (v128.const f64x2 -2.0 -0.0))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 2.25)) (v128.const f64x2 0.0 2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -2.25)) (v128.const f64x2 0.0 -2.25))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -nan) (f64.const -1.7976931348623157e+308)) (v128.const f64x2 0.0 -1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 nan) (f64.const 1.7976931348623157e+308)) (v128.const f64x2 0.0 1.7976931348623157e+308))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 -inf) (f64.const -0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 -0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 inf) (f64.const 0x1.fffffffffffffp-1023)) (v128.const f64x2 0.0 0x1.fffffffffffffp-1023))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -nan)) (v128.const f64x2 0.0 -nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const nan)) (v128.const f64x2 0.0 nan))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const -inf)) (v128.const f64x2 0.0 -inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const inf)) (v128.const f64x2 0.0 inf))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e019)) (v128.const f64x2 0.0 0123456789e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789e+019)) (v128.const f64x2 0.0 0123456789e+019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e019)) (v128.const f64x2 0.0 0123456789.e019))
+(assert_return (invoke "f64x2_replace_lane-last" (v128.const f64x2 0.0 0.0) (f64.const 0123456789.e-019)) (v128.const f64x2 0.0 0123456789.e-019))
+
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
+  (v128.const i8x16  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16  -8  -7  -6  -5  -4  -3  -2 -1 16 17 18 19 20 21 22 23))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0))
+  (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16  -1   1  -2   2  -3   3  -4   4  -5   5  -6   6  -7   7  -8   8))
+  (v128.const i8x16   0 101   0 102   0 103   0 104   0 105   0 106   0 107   0 108))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115)
+  (v128.const i8x16   9  16  10  17  11  18  12  19  13  20  14  21  15  22  16  23))
+  (v128.const i8x16 109   0 110   0 111   0 112   0 113   0 114   0 115   0   0   0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16    9   16   10   17  11    18   12   19  13    20   14   21   15   22   16   23))
+  (v128.const i8x16 0x6d    0 0x6e    0 0x6f    0 0x70    0 0x71    0 0x72    0 0x73    0    0    0))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i16x8 0x6465 0x6667 0x6869 0x6a6b 0x6c6d 0x6e6f 0x7071 0x7273))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x64656667 0x68696a6b 0x6c6d6e6f 0x70717273)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i32x4 0x73727170 0x6f6e6d6c 0x6b6a6968 0x67666564))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const f32x4 nan -nan inf -inf)
+  (v128.const i8x16 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15))
+  (v128.const i32x4 0x7fc00000 0xffc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 0x67666564 0x6b6a6968 0x6f6e6d5c 0x73727170)
+  (v128.const f32x4 0.0 -0.0 inf -inf))
+  (v128.const i32x4 0x64646464 0x00646464 0x00006464 0x00006464))
+
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31))
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+(assert_return (invoke "v8x16_shuffle-3"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16  -1  -2  -3  -4  -5  -6  -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "v8x16_shuffle-4"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16  15  14  13  12  11  10   9  8  7  6  5  4  3  2  1  0))
+(assert_return (invoke "v8x16_shuffle-5"
+  (v128.const i8x16   0   1   2   3   4   5   6  7  8  9 10 11 12 13 14 15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1))
+  (v128.const i8x16   0   0   0   0   0   0   0  0  0  0  0  0  0  0  0  0))
+(assert_return (invoke "v8x16_shuffle-6"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-7"
+  (v128.const i8x16   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i8x16   0   0   0   0   0   0   0   0 -16 -16 -16 -16 -16 -16 -16 -16))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73)
+  (v128.const i8x16 0xf0 0xf1 0xf2 0xf3 0xf4 0xf5 0xf6 0xf7 0xf8 0xf9 0xfa 0xfb 0xfc 0xfd 0xfe 0xff))
+  (v128.const i8x16 0x64 0x65 0x66 0x67 0x68 0x69 0x6a 0x6b 0x6c 0x6d 0x6e 0x6f 0x70 0x71 0x72 0x73))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1))
+  (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v8x16_shuffle-2"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+  (v128.const i32x4 0xf3f2f1f0 0xf7f6f5f4 0xfbfaf9f8 0xfffefdfc))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const f32x4 1.0 nan inf -inf)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x3f800000 0x7fc00000 0x7f800000 0xff800000))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f)
+  (v128.const f32x4 -0.0 nan inf -inf))
+  (v128.const i32x4 0x10203 0x4050607 0x8090a0b 0xc0d0e0f))
+
+;; More literals
+(assert_return (invoke "v8x16_swizzle"
+  (v128.const i32x4 1_234_567_890 0x1234_5678 01_234_567_890 0x0_1234_5678)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+  (v128.const i32x4 0x4996_02d2 0x1234_5678 0x4996_02d2 0x1234_5678))
+(assert_return (invoke "v8x16_shuffle-1"
+  (v128.const i64x2 1_234_567_890_123_456_789_0 0x1234_5678_90AB_cdef)
+  (v128.const i64x2 01_234_567_890_123_456_789_0 0x0_1234_5678_90AB_cdef))
+  (v128.const i32x4 0xeb1f_0ad2 0xab54_a98c 0x90ab_cdef 0x1234_5678))
+
+;; Syntax errors for negative values
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u  -1 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane  -1 (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane  -1 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane  -1 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane  -1 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane  -1 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane  -1 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane  -1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane  -1 (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane  -1 (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane  -1 (v128.const f64x2 0 0) (f64.const 1)))") "unexpected token")
+
+;; Malformed lane index value
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u 256 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane 256 (v128.const i32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane 256 (v128.const f32x4 0 0 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane 256 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane 256 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane 256 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane 256 (v128.const f32x4 0 0 0 0) (i32.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane 256 (v128.const i64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result f64) (f64x2.extract_lane 256 (v128.const f64x2 0 0)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (i64x2.replace_lane 256 (v128.const i64x2 0 0) (i64.const 1)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane 256 (v128.const f64x2 0 0) (f64.const 1)))") "malformed lane index")
+
+;; Invalid lane index value
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 255 (v128.const i16x8 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 255 (v128.const i32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 4 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 255 (v128.const f32x4 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 16 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 255 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 16 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 255 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 255 (v128.const i32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 255 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 255 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 255 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 255 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 255 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Lane index is determined by the instruction's interpretation only.
+
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_s 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i16x8.extract_lane_u 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result i32) (f32x4.extract_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 8 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 4 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 2 (v128.const i64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 2 (v128.const f64x2 0 0)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 2 (v128.const i64x2 0 0) (i64.const 1)))) "invalid lane index")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 2 (v128.const f64x2 0 0) (f64.const 1.0)))) "invalid lane index")
+
+;; Invalid parameters: required v128 but pass other types
+
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_s 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i8x16.extract_lane_u 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result i32) (i32x4.extract_lane 0 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f32) (f32x4.extract_lane 0 (f32.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (i64.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result i64) (i64x2.extract_lane 0 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (result f64) (f64x2.extract_lane 0 (f64.const 0.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (i32.const 0) (i32.const 1)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (f32.const 0.0) (i32.const 1)))) "type mismatch")
+
+;; Invalid types for the replaced value
+
+(assert_invalid (module (func (result v128) (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0) (f32.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0) (i32.const 1)))) "type mismatch")
+
+(assert_invalid (module (func (result v128) (i64x2.replace_lane 0 (v128.const i64x2 0 0) (f64.const 1.0)))) "type mismatch")
+(assert_invalid (module (func (result v128) (f64x2.replace_lane 0 (v128.const f64x2 0 0) (i64.const 1)))) "type mismatch")
+
+;; Invalid types for swizzle and shuffle values
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (i32.const 1) (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.swizzle (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (i32.const 2)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (f32.const 3.0)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))) "type mismatch")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) (f32.const 4.0)))) "type mismatch")
+
+;; i8x16.shuffle: the 1st argument must be 16-byte literals in 0..32
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (param v128) (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 (local.get 0) (local.get 0)))")
+  "invalid lane length")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 -1"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128)"
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 256"
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)"
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_invalid (module (func (result v128)
+  (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 255
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))) "invalid lane index")
+
+;; Possible wrong instruction names that'd be used
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_s 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane_u 0 (v128.const i32x4 0 0 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_s 0 (v128.const i64x2 0 0)))") "unknown operator")
+(assert_malformed (module quote "(func (result i32) (i64x2.extract_lane_u 0 (v128.const i64x2 0 0)))") "unknown operator")
+
+
+;; Old shuffle instruction names will not work
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle1 (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle2_imm  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+;; i8x16 not v8x16
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.swizzle (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)))")
+  "unknown operator")
+(assert_malformed (module quote "(func (result v128) "
+  "(v8x16.shuffle  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)))")
+  "unknown operator")
+
+
+;; Malformed lane index
+
+;; Pass params as the lane index
+
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_s (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i8x16.extract_lane_u (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_s (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i16x8.extract_lane_u (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result i32) (i32x4.extract_lane (local.get 0) (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f32) (f32x4.extract_lane (local.get 0) (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i8x16.replace_lane (local.get 0) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i16x8.replace_lane (local.get 0) (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i32x4.replace_lane (local.get 0) (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f32x4.replace_lane (local.get 0) (v128.const f32x4 0 0 0 0) (f32.const 1.0)))") "unexpected token")
+
+(assert_malformed (module quote "(func (param i32) (result i64) (i64x2.extract_lane (local.get 0) (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result f64) (f64x2.extract_lane (local.get 0) (v128.const f64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (i64x2.replace_lane (local.get 0) (v128.const i64x2 0 0) (i64.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (param i32) (result v128) (f64x2.replace_lane (local.get 0) (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Pass non-literal as the lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u nan (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_s inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i16x8.extract_lane_u -inf (v128.const i16x8 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i32) (i32x4.extract_lane nan (v128.const i32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane nan (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane -2.5 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane nan (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane inf (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f32x4.replace_lane -inf (v128.const f32x4 0 0 0 0) (f32.const 1.1)))") "unexpected token")
+
+;; i8x16.shuffle expects a 16-byte literals as first argument
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle (v128.const i8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "invalid lane length")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15.0) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0.5 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle -inf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 inf) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+(assert_malformed (module quote "(func (result v128) "
+  "(i8x16.shuffle nan 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) "
+  "(v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0) "
+  "(v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)))") "malformed lane index")
+
+
+;; Combination with each other
+
+(module
+  ;; as *.replace_lane's operand
+  (func (export "i8x16_extract_lane_s") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_s 0 (local.get 1))))
+  (func (export "i8x16_extract_lane_u") (param v128 v128) (result v128)
+    (i8x16.replace_lane 0 (local.get 0) (i8x16.extract_lane_u 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_s") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_s 0 (local.get 1))))
+  (func (export "i16x8_extract_lane_u") (param v128 v128) (result v128)
+    (i16x8.replace_lane 0 (local.get 0) (i16x8.extract_lane_u 0 (local.get 1))))
+  (func (export "i32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "f32x4_extract_lane") (param v128 v128) (result v128)
+    (i32x4.replace_lane 0 (local.get 0) (i32x4.extract_lane 0 (local.get 1))))
+  (func (export "i64x2_extract_lane") (param v128 v128) (result v128)
+    (i64x2.replace_lane 0 (local.get 0) (i64x2.extract_lane 0 (local.get 1))))
+  (func (export "f64x2_extract_lane") (param v128 v128) (result v128)
+    (f64x2.replace_lane 0 (local.get 0) (f64x2.extract_lane 0 (local.get 1))))
+
+  ;; as *.extract_lane's operand
+  (func (export "i8x16_replace_lane-s") (param v128 i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i8x16_replace_lane-u") (param v128 i32) (result i32)
+    (i8x16.extract_lane_u 15 (i8x16.replace_lane 15 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-s") (param v128 i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i16x8_replace_lane-u") (param v128 i32) (result i32)
+    (i16x8.extract_lane_u 7 (i16x8.replace_lane 7 (local.get 0) (local.get 1))))
+  (func (export "i32x4_replace_lane") (param v128 i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "f32x4_replace_lane") (param v128 f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.replace_lane 3 (local.get 0) (local.get 1))))
+  (func (export "i64x2_replace_lane") (param v128 i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.replace_lane 1 (local.get 0) (local.get 1))))
+  (func (export "f64x2_replace_lane") (param v128 f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.replace_lane 1 (local.get 0) (local.get 1))))
+
+  ;; i8x16.replace outputs as shuffle operand
+  (func (export "as-v8x16_swizzle-operand") (param v128 i32 v128) (result v128)
+    (i8x16.swizzle (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (local.get 2)))
+  (func (export "as-v8x16_shuffle-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.shuffle 16 1 18 3 20 5 22 7 24 9 26 11 28 13 30 15
+      (i8x16.replace_lane 0 (local.get 0) (local.get 1))
+      (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+)
+
+(assert_return (invoke "i8x16_extract_lane_s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 -1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16_extract_lane_u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i8x16 255 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_s" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 -1 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8_extract_lane_u" (v128.const i16x8 0 0 0 0 0 0 0 0) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1)) (v128.const i16x8 65535 0 0 0 0 0 0 0))
+(assert_return (invoke "i32x4_extract_lane" (v128.const i32x4 0 0 0 0) (v128.const i32x4 0x10000 -1 -1 -1)) (v128.const i32x4 65536 0 0 0))
+(assert_return (invoke "f32x4_extract_lane" (v128.const f32x4 0 0 0 0) (v128.const f32x4 1e38 nan nan nan)) (v128.const f32x4 1e38 0 0 0))
+(assert_return (invoke "i8x16_replace_lane-s" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const -1))
+(assert_return (invoke "i8x16_replace_lane-u" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 255)) (i32.const 255))
+(assert_return (invoke "i16x8_replace_lane-s" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const -1))
+(assert_return (invoke "i16x8_replace_lane-u" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 65535)) (i32.const 65535))
+(assert_return (invoke "i32x4_replace_lane" (v128.const i32x4 0 0 0 0) (i32.const -1)) (i32.const -1))
+(assert_return (invoke "f32x4_replace_lane" (v128.const f32x4 0 0 0 0) (f32.const 1.25)) (f32.const 1.25))
+
+(assert_return (invoke "i64x2_extract_lane" (v128.const i64x2 0 0) (v128.const i64x2 0xffffffffffffffff -1)) (v128.const i64x2 0xffffffffffffffff 0))
+(assert_return (invoke "f64x2_extract_lane" (v128.const f64x2 0 0) (v128.const f64x2 1e308 nan)) (v128.const f64x2 1e308 0))
+(assert_return (invoke "i64x2_replace_lane" (v128.const i64x2 0 0) (i64.const -1)) (i64.const -1))
+(assert_return (invoke "f64x2_replace_lane" (v128.const f64x2 0 0) (f64.const 2.5)) (f64.const 2.5))
+
+(assert_return (invoke "as-v8x16_swizzle-operand"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) (i32.const 255)
+  (v128.const i8x16 -1 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 0 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+(assert_return (invoke "as-v8x16_shuffle-operands"
+  (v128.const i8x16 0 255 0 255 15 255 0 255 255 255 0 255 127 255 0 255) (i32.const 1)
+  (v128.const i8x16 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 0 0x55 1 0x55 -1) (i32.const 0))
+  (v128.const i8x16 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff 0x55 0xff))
+
+;; Combination with other SIMD instructions
+
+(module
+  ;; Constructing SIMD values
+  (func (export "as-i8x16_splat-operand") (param v128) (result v128)
+    (i8x16.splat (i8x16.extract_lane_s 0 (local.get 0))))
+  (func (export "as-i16x8_splat-operand") (param v128) (result v128)
+    (i16x8.splat (i16x8.extract_lane_u 0 (local.get 0))))
+  (func (export "as-i32x4_splat-operand") (param v128) (result v128)
+    (i32x4.splat (i32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-f32x4_splat-operand") (param v128) (result v128)
+    (f32x4.splat (f32x4.extract_lane 0 (local.get 0))))
+  (func (export "as-i64x2_splat-operand") (param v128) (result v128)
+    (i64x2.splat (i64x2.extract_lane 0 (local.get 0))))
+  (func (export "as-f64x2_splat-operand") (param v128) (result v128)
+    (f64x2.splat (f64x2.extract_lane 0 (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i8x16.add (i8x16.replace_lane 0 (local.get 0) (local.get 1)) (i8x16.replace_lane 15 (local.get 2) (local.get 3))))
+  (func (export "as-i16x8_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i16x8.add (i16x8.replace_lane 0 (local.get 0) (local.get 1)) (i16x8.replace_lane 7 (local.get 2) (local.get 3))))
+  (func (export "as-i32x4_add-operands") (param v128 i32 v128 i32) (result v128)
+    (i32x4.add (i32x4.replace_lane 0 (local.get 0) (local.get 1)) (i32x4.replace_lane 3 (local.get 2) (local.get 3))))
+  (func (export "as-i64x2_add-operands") (param v128 i64 v128 i64) (result v128)
+    (i64x2.add (i64x2.replace_lane 0 (local.get 0) (local.get 1)) (i64x2.replace_lane 1 (local.get 2) (local.get 3))))
+
+  (func (export "swizzle-as-i8x16_add-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.add (i8x16.swizzle (local.get 0) (local.get 1)) (i8x16.swizzle (local.get 2) (local.get 3))))
+  (func (export "shuffle-as-i8x16_sub-operands") (param v128 v128 v128 v128) (result v128)
+    (i8x16.sub (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))
+      (i8x16.shuffle 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 (local.get 2) (local.get 3))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i8x16.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i16x8_any_true-operand") (param v128 i32) (result i32)
+    (v128.any_true (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand1") (param v128 i32) (result i32)
+    (v128.any_true (i32x4.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-i32x4_any_true-operand2") (param v128 i64) (result i32)
+    (v128.any_true (i64x2.replace_lane 0 (local.get 0) (local.get 1))))
+
+  (func (export "swizzle-as-i8x16_all_true-operands") (param v128 v128) (result i32)
+    (i8x16.all_true (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "shuffle-as-i8x16_any_true-operands") (param v128 v128) (result i32)
+    (v128.any_true (i8x16.shuffle 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 (local.get 0) (local.get 1))))
+)
+
+(assert_return (invoke "as-i8x16_splat-operand" (v128.const i8x16 0xff 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i16x8_splat-operand" (v128.const i16x8 -1 -1 -1 -1 0 0 0 0)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "as-i32x4_splat-operand" (v128.const i32x4 0x10000 0 0 0)) (v128.const i32x4 65536 65536 65536 65536))
+(assert_return (invoke "as-f32x4_splat-operand" (v128.const f32x4 3.14 nan nan nan)) (v128.const f32x4 3.14 3.14 3.14 3.14))
+(assert_return (invoke "as-i64x2_splat-operand" (v128.const i64x2 -1 0)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "as-f64x2_splat-operand" (v128.const f64x2 inf nan)) (v128.const f64x2 inf inf))
+(assert_return (invoke "as-i8x16_add-operands"
+  (v128.const i8x16 0xff 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16) (i32.const 1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 0xff) (i32.const 1))
+  (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-i16x8_add-operands"
+  (v128.const i16x8 -1 4 9 16 25 36 49 64) (i32.const 1)
+  (v128.const i16x8 64 49 36 25 16 9 4 -1) (i32.const 1))
+  (v128.const i16x8 65 53 45 41 41 45 53 65))
+(assert_return (invoke "as-i32x4_add-operands"
+  (v128.const i32x4 -1 8 27 64) (i32.const 1) (v128.const i32x4 64 27 8 -1) (i32.const 1)) (v128.const i32x4 65 35 35 65))
+(assert_return (invoke "as-i64x2_add-operands"
+  (v128.const i64x2 -1 8) (i64.const 1) (v128.const i64x2 64 27) (i64.const 1)) (v128.const i64x2 65 9))
+
+(assert_return (invoke "swizzle-as-i8x16_add-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "shuffle-as-i8x16_sub-operands"
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0)
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -15 -13 -11 -9 -7 -5 -3 -1 1 3 5 7 9 11 13 15))
+
+(assert_return (invoke "as-i8x16_any_true-operand" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i16x8_any_true-operand" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-i32x4_any_true-operand1" (v128.const i32x4 1 0 0 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i32x4_any_true-operand2" (v128.const i64x2 1 0) (i64.const 0)) (i32.const 0))
+
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+(assert_return (invoke "swizzle-as-i8x16_all_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16)) (i32.const 0))
+(assert_return (invoke "shuffle-as-i8x16_any_true-operands"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)) (i32.const 1))
+
+;; Load and store
+
+(module
+  (memory 1)
+  (func (export "as-v128_store-operand-1") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param v128 i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param v128 f32) (result v128)
+    (v128.store (i32.const 0) (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param v128 i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-6") (param v128 f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i8x16 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-2" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 256)) (v128.const i16x8 0x100 0 0 0 0 0 0 0))
+(assert_return (invoke "as-v128_store-operand-3" (v128.const i32x4 0 0 0 0) (i32.const 0xffffffff)) (v128.const i32x4 -1 0 0 0))
+(assert_return (invoke "as-v128_store-operand-4" (v128.const f32x4 0 0 0 0) (f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+(assert_return (invoke "as-v128_store-operand-5" (v128.const i64x2 0 0) (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 0))
+(assert_return (invoke "as-v128_store-operand-6" (v128.const f64x2 0 0) (f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; As the argument of wasm core ops
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (global $h (mut v128) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+  (func (export "as-if-condition-value") (param v128) (result i32)
+    (if (result i32) (i8x16.extract_lane_s 0 (local.get 0)) (then (i32.const 0xff)) (else (i32.const 0))))
+  (func (export "as-return-value-1") (param v128 i32) (result v128)
+    (return (i16x8.replace_lane 0 (local.get 0) (local.get 1))))
+  (func (export "as-local_set-value") (param v128) (result i32) (local i32)
+    (local.set 1 (i32x4.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-1") (param v128 f32) (result v128)
+    (global.set $g (f32x4.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+
+   (func (export "as-return-value-2") (param v128 v128) (result v128)
+    (return (i8x16.swizzle (local.get 0) (local.get 1))))
+  (func (export "as-global_set-value-2") (param v128 v128) (result v128)
+    (global.set $h (i8x16.shuffle 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 (local.get 0) (local.get 1)))
+    (return (global.get $h)))
+
+  (func (export "as-local_set-value-1") (param v128) (result i64) (local i64)
+    (local.set 1 (i64x2.extract_lane 0 (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value-3") (param v128 f64) (result v128)
+    (global.set $g (f64x2.replace_lane 0 (local.get 0) (local.get 1)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-if-condition-value" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)) (i32.const 0))
+(assert_return (invoke "as-return-value-1" (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)) (v128.const i16x8 1 0 0 0 0 0 0 0))
+(assert_return (invoke "as-local_set-value" (v128.const i32x4 -1 -1 -1 -1)) (i32.const -1))
+(assert_return (invoke "as-global_set-value-1" (v128.const f32x4 0 0 0 0)(f32.const 3.14)) (v128.const f32x4 3.14 0 0 0))
+
+(assert_return (invoke "as-return-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0))
+  (v128.const i8x16 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16))
+(assert_return (invoke "as-global_set-value-2"
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1)
+  (v128.const i8x16 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1))
+  (v128.const i8x16 -16 -15 -14 -13 -12 -11 -10 -9 8 7 6 5 4 3 2 1))
+
+(assert_return (invoke "as-local_set-value-1" (v128.const i64x2 -1 -1)) (i64.const -1))
+(assert_return (invoke "as-global_set-value-3" (v128.const f64x2 0 0)(f64.const 3.14)) (v128.const f64x2 3.14 0))
+
+;; Non-nat lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_u +0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result f32) (f32x4.extract_lane +03 (v128.const f32x4 0 0 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result i64) (i64x2.extract_lane +1 (v128.const i64x2 0 0)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i8x16.replace_lane +015 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i16x8.replace_lane +0x7 (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (i32x4.replace_lane +3 (v128.const i32x4 0 0 0 0) (i32.const 1)))") "unexpected token")
+(assert_malformed (module quote "(func (result v128) (f64x2.replace_lane +0x01 (v128.const f64x2 0 0) (f64.const 1.0)))") "unexpected token")
+
+;; Lane index literal
+
+(module (func (result i32) (i8x16.extract_lane_s 0x0f (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_s 0x07 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i16x8.extract_lane_u 0x0_7 (v128.const i16x8 0 0 0 0 0 0 0 0))))
+(module (func (result i32) (i32x4.extract_lane 03 (v128.const i32x4 0 0 0 0))))
+(module (func (result f64) (f64x2.extract_lane 0x1 (v128.const f64x2 0 0))))
+(module (func (result v128) (f32x4.replace_lane 0x3 (v128.const f32x4 0 0 0 0) (f32.const 1.0))))
+(module (func (result v128) (i64x2.replace_lane 01 (v128.const i64x2 0 0) (i64.const 1))))
+
+;; 1.0 is malformed lane index
+
+(assert_malformed (module quote "(func (result i32) (i8x16.extract_lane_s 1.0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))") "unexpected token")
+
+;; Test operation with empty argument
+
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-1st-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.extract_lane_s-2nd-arg-empty (result i32)
+      (i8x16.extract_lane_s 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.extract_lane_s-arg-empty (result i32)"
+    "  (i8x16.extract_lane_s)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-1st-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u (v128.const i16x8 0 0 0 0 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.extract_lane_u-2nd-arg-empty (result i32)
+      (i16x8.extract_lane_u 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.extract_lane_u-arg-empty (result i32)"
+    "  (i16x8.extract_lane_u)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-1st-arg-empty (result i32)"
+    "  (i32x4.extract_lane (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.extract_lane-2nd-arg-empty (result i32)
+      (i32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.extract_lane-arg-empty (result i32)"
+    "  (i32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-1st-arg-empty (result i64)"
+    "  (i64x2.extract_lane (v128.const i64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.extract_lane-2nd-arg-empty (result i64)
+      (i64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.extract_lane-arg-empty (result i64)"
+    "  (i64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-1st-arg-empty (result f32)"
+    "  (f32x4.extract_lane (v128.const f32x4 0 0 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.extract_lane-2nd-arg-empty (result f32)
+      (f32x4.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.extract_lane-arg-empty (result f32)"
+    "  (f32x4.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-1st-arg-empty (result f64)"
+    "  (f64x2.extract_lane (v128.const f64x2 0 0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.extract_lane-2nd-arg-empty (result f64)
+      (f64x2.extract_lane 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.extract_lane-arg-empty (result f64)"
+    "  (f64x2.extract_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-1st-arg-empty (result v128)"
+    "  (i8x16.replace_lane (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-2nd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i8x16.replace_lane-3rd-arg-empty (result v128)
+      (i8x16.replace_lane 0 (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.replace_lane-arg-empty (result v128)"
+    "  (i8x16.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-1st-arg-empty (result v128)"
+    "  (i16x8.replace_lane (v128.const i16x8 0 0 0 0 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-2nd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.replace_lane-3rd-arg-empty (result v128)
+      (i16x8.replace_lane 0 (v128.const i16x8 0 0 0 0 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i16x8.replace_lane-arg-empty (result v128)"
+    "  (i16x8.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (i32x4.replace_lane (v128.const i32x4 0 0 0 0) (i32.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-2nd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.replace_lane-3rd-arg-empty (result v128)
+      (i32x4.replace_lane 0 (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i32x4.replace_lane-arg-empty (result v128)"
+    "  (i32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-1st-arg-empty (result v128)"
+    "  (f32x4.replace_lane (v128.const f32x4 0 0 0 0) (f32.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-2nd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (f32.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.replace_lane-3rd-arg-empty (result v128)
+      (f32x4.replace_lane 0 (v128.const f32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f32x4.replace_lane-arg-empty (result v128)"
+    "  (f32x4.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (i64x2.replace_lane (v128.const i64x2 0 0) (i64.const 1))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-2nd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (i64.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.replace_lane-3rd-arg-empty (result v128)
+      (i64x2.replace_lane 0 (v128.const i64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i64x2.replace_lane-arg-empty (result v128)"
+    "  (i64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-1st-arg-empty (result v128)"
+    "  (f64x2.replace_lane (v128.const f64x2 0 0) (f64.const 1.0))"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-2nd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (f64.const 1.0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.replace_lane-3rd-arg-empty (result v128)
+      (f64x2.replace_lane 0 (v128.const f64x2 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $f64x2.replace_lane-arg-empty (result v128)"
+    "  (f64x2.replace_lane)"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-1st-arg-empty (result v128)"
+    "  (i8x16.shuffle"
+    "    (v128.const i8x16 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15)"
+    "    (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)"
+    "  )"
+    ")"
+  )
+  "invalid lane length"
+)
+(assert_invalid
+  (module
+    (func $i8x16.shuffle-2nd-arg-empty (result v128)
+      (i8x16.shuffle 0 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15
+        (v128.const i8x16 1 2 3 5 6 6 7 8 9 10 11 12 13 14 15 16)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_malformed
+  (module quote
+    "(func $i8x16.shuffle-arg-empty (result v128)"
+    "  (i8x16.shuffle)"
+    ")"
+  )
+  "invalid lane length"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load.wast
new file mode 100644
index 0000000..4b2edc1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operater as the argument of other SIMD instructions
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-i8x16.eq-operand") (result v128)
+    (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-v128.not-operand") (result v128)
+    (v128.not (v128.load (i32.const 0)))
+  )
+  (func (export "as-i8x16.all_true-operand") (result i32)
+    (i8x16.all_true (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+(assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+  (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+  (func (export "as-v128.bitselect-operand") (result v128)
+    (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+  )
+)
+(assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (func (export "as-i8x16.shl-operand") (result v128)
+    (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+  )
+)
+(assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+  (func (export "as-add/sub-operand") (result v128)
+    ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+    ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+    (i8x16.sub
+      (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+      (v128.load (i32.const 16))
+    )
+  )
+)
+(assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+  (func (export "as-f32x4.mul-operand") (result v128)
+    (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+  )
+)
+(assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+  (func (export "as-f32x4.abs-operand") (result v128)
+    (f32x4.abs (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+  (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.min-operand") (result v128)
+    (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+  )
+)
+(assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+(module (memory 1)
+  (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+  (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+    (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+  (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+    (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+  )
+)
+(assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+(module (memory 1)
+  (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+  (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+  (func (export "as-i8x16.swizzle-operand") (result v128)
+    (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+  )
+)
+(assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load16_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load16_lane.wast
new file mode 100644
index 0000000..8c72a57
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load16_lane.wast
@@ -0,0 +1,211 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load16_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load16_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load16_lane align=2 7 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load16_lane_0" (i32.const 0)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1" (i32.const 1)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2" (i32.const 2)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3" (i32.const 3)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4" (i32.const 4)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5" (i32.const 5)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6" (i32.const 6)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7" (i32.const 7)
+                                            (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                            (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_offset_0" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_offset_1" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_offset_2" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_offset_3" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 256 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 513 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 770 0 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 1027 0 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_4_align_2" (i32.const 4)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 1284 0 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_5_align_2" (i32.const 5)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 1541 0 0))
+(assert_return (invoke "v128.load16_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_6_align_2" (i32.const 6)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 1798 0))
+(assert_return (invoke "v128.load16_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+(assert_return (invoke "v128.load16_lane_7_align_2" (i32.const 7)
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 0))
+                                                    (v128.const i16x8 0 0 0 0 0 0 0 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load32_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load32_lane.wast
new file mode 100644
index 0000000..e67690f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load32_lane.wast
@@ -0,0 +1,143 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load32_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load32_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=2 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load32_lane align=4 3 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load32_lane_0" (i32.const 0)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1" (i32.const 1)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2" (i32.const 2)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3" (i32.const 3)
+                                            (v128.const i32x4 0 0 0 0))
+                                            (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_offset_0" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_offset_1" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_offset_2" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_offset_3" (v128.const i32x4 0 0 0 0))
+                                                     (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 50462976 0 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 67305985 0 0))
+(assert_return (invoke "v128.load32_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_2" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_2_align_4" (i32.const 2)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 84148994 0))
+(assert_return (invoke "v128.load32_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_2" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+(assert_return (invoke "v128.load32_lane_3_align_4" (i32.const 3)
+                                                    (v128.const i32x4 0 0 0 0))
+                                                    (v128.const i32x4 0 0 0 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load64_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load64_lane.wast
new file mode 100644
index 0000000..5883a6e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load64_lane.wast
@@ -0,0 +1,97 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load64_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load64_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=2 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=4 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load64_lane align=8 1 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load64_lane_0" (i32.const 0)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1" (i32.const 1)
+                                            (v128.const i64x2 0 0))
+                                            (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_offset_0" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_offset_1" (v128.const i64x2 0 0))
+                                                     (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_2" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_4" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_0_align_8" (i32.const 0)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 506097522914230528 0))
+(assert_return (invoke "v128.load64_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_2" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_4" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+(assert_return (invoke "v128.load64_lane_1_align_8" (i32.const 1)
+                                                    (v128.const i64x2 0 0))
+                                                    (v128.const i64x2 0 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load8_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load8_lane.wast
new file mode 100644
index 0000000..d0706f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load8_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for load lane operations.
+
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (func (export "v128.load8_lane_0")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane 15 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_0_offset_0")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=0 0 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_1_offset_1")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=1 1 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_2_offset_2")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=2 2 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_3_offset_3")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=3 3 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_4_offset_4")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=4 4 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_5_offset_5")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=5 5 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_6_offset_6")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=6 6 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_7_offset_7")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=7 7 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_8_offset_8")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=8 8 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_9_offset_9")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=9 9 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_10_offset_10")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=10 10 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_11_offset_11")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=11 11 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_12_offset_12")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=12 12 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_13_offset_13")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=13 13 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_14_offset_14")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=14 14 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_15_offset_15")
+    (param $x v128) (result v128)
+    (v128.load8_lane offset=15 15 (i32.const 0) (local.get $x)))
+  (func (export "v128.load8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 0 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 1 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 2 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 3 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 4 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 5 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 6 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 7 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 8 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 9 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 10 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 11 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 12 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 13 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 14 (local.get $address) (local.get $x)))
+  (func (export "v128.load8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result v128)
+    (v128.load8_lane align=1 15 (local.get $address) (local.get $x)))
+)
+
+(assert_return (invoke "v128.load8_lane_0" (i32.const 0)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1" (i32.const 1)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2" (i32.const 2)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3" (i32.const 3)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4" (i32.const 4)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5" (i32.const 5)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6" (i32.const 6)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7" (i32.const 7)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8" (i32.const 8)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9" (i32.const 9)
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                           (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10" (i32.const 10)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11" (i32.const 11)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12" (i32.const 12)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13" (i32.const 13)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14" (i32.const 14)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15" (i32.const 15)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_offset_1" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_offset_2" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_offset_3" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                      (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+(assert_return (invoke "v128.load8_lane_0_align_1" (i32.const 0)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_1_align_1" (i32.const 1)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_2_align_1" (i32.const 2)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_3_align_1" (i32.const 3)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_4_align_1" (i32.const 4)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_5_align_1" (i32.const 5)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_6_align_1" (i32.const 6)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_7_align_1" (i32.const 7)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_8_align_1" (i32.const 8)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_9_align_1" (i32.const 9)
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                   (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_10_align_1" (i32.const 10)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_11_align_1" (i32.const 11)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+(assert_return (invoke "v128.load8_lane_12_align_1" (i32.const 12)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+(assert_return (invoke "v128.load8_lane_13_align_1" (i32.const 13)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+(assert_return (invoke "v128.load8_lane_14_align_1" (i32.const 14)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+(assert_return (invoke "v128.load8_lane_15_align_1" (i32.const 15)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.load8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.load8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_extend.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_extend.wast
new file mode 100644
index 0000000..b9982bb
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_extend.wast
@@ -0,0 +1,384 @@
+;; Load and Extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load8x8_s") (param $0 i32) (result v128)
+    (v128.load8x8_s (local.get $0))
+  )
+  (func (export "v128.load8x8_u") (param $0 i32) (result v128)
+    (v128.load8x8_u (local.get $0))
+  )
+  (func (export "v128.load16x4_s") (param $0 i32) (result v128)
+    (v128.load16x4_s (local.get $0))
+  )
+  (func (export "v128.load16x4_u") (param $0 i32) (result v128)
+    (v128.load16x4_u (local.get $0))
+  )
+  (func (export "v128.load32x2_s") (param $0 i32) (result v128)
+    (v128.load32x2_s (local.get $0))
+  )
+  (func (export "v128.load32x2_u") (param $0 i32) (result v128)
+    (v128.load32x2_u (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load8x8_s_const0") (result v128)
+    (v128.load8x8_s (i32.const 0))
+  )
+  (func (export "v128.load8x8_u_const8") (result v128)
+    (v128.load8x8_u (i32.const 8))
+  )
+  (func (export "v128.load16x4_s_const10") (result v128)
+    (v128.load16x4_s (i32.const 10))
+  )
+  (func (export "v128.load16x4_u_const20") (result v128)
+    (v128.load16x4_u (i32.const 20))
+  )
+  (func (export "v128.load32x2_s_const65520") (result v128)
+    (v128.load32x2_s (i32.const 65520))
+  )
+  (func (export "v128.load32x2_u_const65526") (result v128)
+    (v128.load32x2_u (i32.const 65526))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load8x8_s_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load8x8_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load8x8_u offset=20 align=8 (local.get $0))
+  )
+  ;; i32x4
+  (func (export "v128.load16x4_s_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load16x4_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load16x4_u offset=20 align=8 (local.get $0))
+  )
+  ;; i64x2
+  (func (export "v128.load32x2_s_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_s_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_s offset=20 align=8 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load32x2_u_offset20_align8") (param $0 i32) (result v128)
+    (v128.load32x2_u offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load8x8_s" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load16x4_s" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load32x2_s" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load8x8_s" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0xFF80 0xFF81))
+(assert_return (invoke "v128.load8x8_u" (i32.const 10)) (v128.const i16x8 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F 0x0080 0x0081))
+(assert_return (invoke "v128.load16x4_s" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u" (i32.const 10)) (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0x00008180))
+(assert_return (invoke "v128.load32x2_s" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u" (i32.const 10)) (v128.const i64x2 0x000000000D0C0B0A 0x0000000081800F0E))
+(assert_return (invoke "v128.load8x8_s" (i32.const 20)) (v128.const i16x8 0xff84 0xff85 0xff86 0xff87 0xff88 0xff89 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u" (i32.const 20)) (v128.const i16x8 0x0084 0x0085 0x0086 0x0087 0x0088 0x0089 0x0000 0x0000))
+(assert_return (invoke "v128.load16x4_s" (i32.const 20)) (v128.const i32x4 0xffff8584 0xffff8786 0xffff8988 0x00000000))
+(assert_return (invoke "v128.load16x4_u" (i32.const 20)) (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s" (i32.const 20)) (v128.const i64x2 0xFFFFFFFF87868584 0x0000000000008988))
+(assert_return (invoke "v128.load32x2_u" (i32.const 20)) (v128.const i64x2 0x0000000087868584 0x0000000000008988))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load8x8_s_const0") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_const8") (v128.const i16x8 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E 0x000F))
+(assert_return (invoke "v128.load16x4_s_const10") (v128.const i32x4 0x00000B0A 0x00000D0C 0x00000F0E 0xFFFF8180))
+(assert_return (invoke "v128.load16x4_u_const20") (v128.const i32x4 0x00008584 0x00008786 0x00008988 0x00000000))
+(assert_return (invoke "v128.load32x2_s_const65520") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u_const65526") (v128.const i64x2 0x0000000083828180 0x0000000087868584))
+
+;; load data with different offset/align arguments
+;; i16x8
+(assert_return (invoke "v128.load8x8_s_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_s_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_s_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_s_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0xFF80 0xFF81 0xFF82 0xFF83 0xFF84))
+(assert_return (invoke "v128.load8x8_s_offset20_align8" (i32.const 4)) (v128.const i16x8 0xFF88 0xFF89 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v128.load8x8_u_offset0" (i32.const 0)) (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u_align1" (i32.const 1)) (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load8x8_u_offset0_align1" (i32.const 2)) (v128.const i16x8 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008 0x0009))
+(assert_return (invoke "v128.load8x8_u_offset10_align4" (i32.const 3)) (v128.const i16x8 0x000D 0x000E 0x000F 0x0080 0x0081 0x0082 0x0083 0x0084))
+(assert_return (invoke "v128.load8x8_u_offset20_align8" (i32.const 4)) (v128.const i16x8 0x0088 0x0089 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+;; i32x4
+(assert_return (invoke "v128.load16x4_s_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_s_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_s_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_s_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0xFFFF800F 0xFFFF8281 0xFFFF8483))
+(assert_return (invoke "v128.load16x4_s_offset20_align8" (i32.const 4)) (v128.const i32x4 0xFFFF8988 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load16x4_u_offset0" (i32.const 0)) (v128.const i32x4 0x00000100 0x00000302 0x00000504 0x00000706))
+(assert_return (invoke "v128.load16x4_u_align1" (i32.const 1)) (v128.const i32x4 0x00000201 0x00000403 0x00000605 0x00000807))
+(assert_return (invoke "v128.load16x4_u_offset0_align1" (i32.const 2)) (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u_offset10_align4" (i32.const 3)) (v128.const i32x4 0x00000E0D 0x0000800F 0x00008281 0x00008483))
+(assert_return (invoke "v128.load16x4_u_offset20_align8" (i32.const 4)) (v128.const i32x4 0x00008988 0x00000000 0x00000000 0x00000000))
+;; i64x2
+(assert_return (invoke "v128.load32x2_s_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_s_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_s_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_s_offset10_align4" (i32.const 3)) (v128.const i64x2 0xFFFFFFFF800F0E0D 0xFFFFFFFF84838281))
+(assert_return (invoke "v128.load32x2_s_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+(assert_return (invoke "v128.load32x2_u_offset0" (i32.const 0)) (v128.const i64x2 0x0000000003020100 0x0000000007060504))
+(assert_return (invoke "v128.load32x2_u_align1" (i32.const 1)) (v128.const i64x2 0x0000000004030201 0x0000000008070605))
+(assert_return (invoke "v128.load32x2_u_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0000000005040302 0x0000000009080706))
+(assert_return (invoke "v128.load32x2_u_offset10_align4" (i32.const 3)) (v128.const i64x2 0x00000000800F0E0D 0x0000000084838281))
+(assert_return (invoke "v128.load32x2_u_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load8x8_s" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u" (i32.const 65536))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s" (i32.const 65529))  "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u" (i32.const 65529))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load8x8_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8x8_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16x4_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_s_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32x2_u_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8x8_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_s (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16x4_u (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_s (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32x2_u (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_s-arg-empty (result v128)
+      (v128.load8x8_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8x8_u-arg-empty (result v128)
+      (v128.load8x8_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_s-arg-empty (result v128)
+      (v128.load16x4_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16x4_u-arg-empty (result v128)
+      (v128.load16x4_u)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_s-arg-empty (result v128)
+      (v128.load32x2_s)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32x2_u-arg-empty (result v128)
+      (v128.load32x2_u)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load8x8_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_s (i32.const 0))))
+  )
+  (func (export "v128.load8x8_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load8x8_u (i32.const 1))))
+  )
+  (func (export "v128.load16x4_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_s (i32.const 2))))
+  )
+  (func (export "v128.load16x4_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load16x4_u (i32.const 3))))
+  )
+  (func (export "v128.load32x2_s-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_s (i32.const 4))))
+  )
+  (func (export "v128.load32x2_u-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32x2_u (i32.const 5))))
+  )
+  (func (export "v128.load8x8_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_s (i32.const 6))))
+  )
+  (func (export "v128.load8x8_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8x8_u (i32.const 7))))
+  )
+  (func (export "v128.load16x4_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_s (i32.const 8))))
+  )
+  (func (export "v128.load16x4_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16x4_u (i32.const 9))))
+  )
+  (func (export "v128.load32x2_s-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_s (i32.const 10))))
+  )
+  (func (export "v128.load32x2_u-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32x2_u (i32.const 11))))
+  )
+  (func (export "v128.load8x8_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_s (i32.const 12)))
+  )
+  (func (export "v128.load8x8_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8x8_u (i32.const 13)))
+  )
+  (func (export "v128.load16x4_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_s (i32.const 14)))
+  )
+  (func (export "v128.load16x4_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16x4_u (i32.const 15)))
+  )
+  (func (export "v128.load32x2_s-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_s (i32.const 16)))
+  )
+  (func (export "v128.load32x2_u-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32x2_u (i32.const 17)))
+  )
+)
+(assert_return (invoke "v128.load8x8_s-in-block") (v128.const i16x8 0x0000 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007))
+(assert_return (invoke "v128.load8x8_u-in-block") (v128.const i16x8 0x0001 0x0002 0x0003 0x0004 0x0005 0x0006 0x0007 0x0008))
+(assert_return (invoke "v128.load16x4_s-in-block") (v128.const i32x4 0x00000302 0x00000504 0x00000706 0x00000908))
+(assert_return (invoke "v128.load16x4_u-in-block") (v128.const i32x4 0x00000403 0x00000605 0x00000807 0x00000A09))
+(assert_return (invoke "v128.load32x2_s-in-block") (v128.const i64x2 0x0000000007060504 0x000000000B0A0908))
+(assert_return (invoke "v128.load32x2_u-in-block") (v128.const i64x2 0x0000000008070605 0x000000000C0B0A09))
+(assert_return (invoke "v128.load8x8_s-as-br-value") (v128.const i16x8 0x0006 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D))
+(assert_return (invoke "v128.load8x8_u-as-br-value") (v128.const i16x8 0x0007 0x0008 0x0009 0x000A 0x000B 0x000C 0x000D 0x000E))
+(assert_return (invoke "v128.load16x4_s-as-br-value") (v128.const i32x4 0x00000908 0x00000B0A 0x00000D0C 0x00000F0E))
+(assert_return (invoke "v128.load16x4_u-as-br-value") (v128.const i32x4 0x00000A09 0x00000C0B 0x00000E0D 0x0000800F))
+(assert_return (invoke "v128.load32x2_s-as-br-value") (v128.const i64x2 0x000000000D0C0B0A 0xFFFFFFFF81800F0E))
+(assert_return (invoke "v128.load32x2_u-as-br-value") (v128.const i64x2 0x000000000E0D0C0B 0x000000008281800F))
+(assert_return (invoke "v128.load8x8_s-extract_lane_s-operand") (i32.const 12))
+(assert_return (invoke "v128.load8x8_u-extract_lane_s-operand") (i32.const 13))
+(assert_return (invoke "v128.load16x4_s-extract_lane_s-operand") (i32.const 14))
+(assert_return (invoke "v128.load16x4_u-extract_lane_s-operand") (i32.const 15))
+(assert_return (invoke "v128.load32x2_s-extract_lane_s-operand") (i32.const -128))
+(assert_return (invoke "v128.load32x2_u-extract_lane_s-operand") (i32.const -127))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_splat.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_splat.wast
new file mode 100644
index 0000000..d9642f8
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_splat.wast
@@ -0,0 +1,261 @@
+;; Tests for the load_splat instructions
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F")
+  (data (i32.const 65520) "\10\11\12\13\14\15\16\17\18\19\1A\1B\1C\1D\1E\1F")
+
+  (func (export "v128.load8_splat") (param $address i32) (result v128) (v128.load8_splat (local.get $address)))
+  (func (export "v128.load16_splat") (param $address i32) (result v128) (v128.load16_splat (local.get $address)))
+  (func (export "v128.load32_splat") (param $address i32) (result v128) (v128.load32_splat (local.get $address)))
+  (func (export "v128.load64_splat") (param $address i32) (result v128) (v128.load64_splat (local.get $address)))
+
+  ;; Load data with different offset/align arguments
+  (func (export "v8x16.offset0") (param $address i32) (result v128) (v128.load8_splat offset=0 (local.get $address)))
+  (func (export "v8x16.align1") (param $address i32) (result v128) (v128.load8_splat align=1 (local.get $address)))
+  (func (export "v8x16.offset1_align1") (param $address i32) (result v128) (v128.load8_splat offset=1 align=1 (local.get $address)))
+  (func (export "v8x16.offset2_align1") (param $address i32) (result v128) (v128.load8_splat offset=2 align=1 (local.get $address)))
+  (func (export "v8x16.offset15_align1") (param $address i32) (result v128) (v128.load8_splat offset=15 align=1 (local.get $address)))
+
+  (func (export "v16x8.offset0") (param $address i32) (result v128) (v128.load16_splat offset=0 (local.get $address)))
+  (func (export "v16x8.align1") (param $address i32) (result v128) (v128.load16_splat align=1 (local.get $address)))
+  (func (export "v16x8.offset1_align1") (param $address i32) (result v128) (v128.load16_splat offset=1 align=1 (local.get $address)))
+  (func (export "v16x8.offset2_align1") (param $address i32) (result v128) (v128.load16_splat offset=2 align=1 (local.get $address)))
+  (func (export "v16x8.offset15_align2") (param $address i32) (result v128) (v128.load16_splat offset=15 align=2 (local.get $address)))
+
+  (func (export "v32x4.offset0") (param $address i32) (result v128) (v128.load32_splat offset=0 (local.get $address)))
+  (func (export "v32x4.align1") (param $address i32) (result v128) (v128.load32_splat align=1 (local.get $address)))
+  (func (export "v32x4.offset1_align1") (param $address i32) (result v128) (v128.load32_splat offset=1 align=1 (local.get $address)))
+  (func (export "v32x4.offset2_align2") (param $address i32) (result v128) (v128.load32_splat offset=2 align=2 (local.get $address)))
+  (func (export "v32x4.offset15_align4") (param $address i32) (result v128) (v128.load32_splat offset=15 align=4 (local.get $address)))
+
+  (func (export "v64x2.offset0") (param $address i32) (result v128) (v128.load64_splat offset=0 (local.get $address)))
+  (func (export "v64x2.align1") (param $address i32) (result v128) (v128.load64_splat align=1 (local.get $address)))
+  (func (export "v64x2.offset1_align2") (param $address i32) (result v128) (v128.load64_splat offset=1 align=2 (local.get $address)))
+  (func (export "v64x2.offset2_align4") (param $address i32) (result v128) (v128.load64_splat offset=2 align=4 (local.get $address)))
+  (func (export "v64x2.offset15_align8") (param $address i32) (result v128) (v128.load64_splat offset=15 align=8 (local.get $address)))
+
+  (func (export "v8x16.offset65536") (param $address i32) (result v128) (v128.load8_splat offset=65536 (local.get $address)))
+  (func (export "v16x8.offset65535") (param $address i32) (result v128) (v128.load16_splat offset=65535 (local.get $address)))
+  (func (export "v32x4.offset65533") (param $address i32) (result v128) (v128.load32_splat offset=65533 (local.get $address)))
+  (func (export "v64x2.offset65529") (param $address i32) (result v128) (v128.load64_splat offset=65529 (local.get $address)))
+)
+(assert_return (invoke "v128.load8_splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load8_splat" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v128.load8_splat" (i32.const 2)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v128.load8_splat" (i32.const 3)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load8_splat" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v128.load16_splat" (i32.const 4)) (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load16_splat" (i32.const 5)) (v128.const i16x8 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605 0x0605))
+(assert_return (invoke "v128.load16_splat" (i32.const 6)) (v128.const i16x8 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706 0x0706))
+(assert_return (invoke "v128.load16_splat" (i32.const 7)) (v128.const i16x8 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807 0x0807))
+(assert_return (invoke "v128.load16_splat" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v128.load32_splat" (i32.const 8)) (v128.const i32x4 0x0B0A0908 0x0B0A0908 0x0B0A0908 0x0B0A0908))
+(assert_return (invoke "v128.load32_splat" (i32.const 9)) (v128.const i32x4 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09 0x0C0B0A09))
+(assert_return (invoke "v128.load32_splat" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A 0x0D0C0B0A))
+(assert_return (invoke "v128.load32_splat" (i32.const 11)) (v128.const i32x4 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B 0x0E0D0C0B))
+(assert_return (invoke "v128.load32_splat" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v128.load64_splat" (i32.const 12)) (v128.const i64x2 0x000000000F0E0D0C 0x000000000F0E0D0C))
+(assert_return (invoke "v128.load64_splat" (i32.const 13)) (v128.const i64x2 0x00000000000F0E0D 0x00000000000F0E0D))
+(assert_return (invoke "v128.load64_splat" (i32.const 14)) (v128.const i64x2 0x0000000000000F0E 0x0000000000000F0E))
+(assert_return (invoke "v128.load64_splat" (i32.const 15)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v128.load64_splat" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+;; v8x16
+(assert_return (invoke "v8x16.offset0" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.align1" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 0)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 0)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 0)) (v128.const i8x16 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15))
+(assert_return (invoke "v8x16.offset0" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.align1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "v8x16.offset1_align1" (i32.const 1)) (v128.const i8x16 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2))
+(assert_return (invoke "v8x16.offset2_align1" (i32.const 1)) (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v8x16.offset15_align1" (i32.const 1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v8x16.offset0" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+(assert_return (invoke "v8x16.align1" (i32.const 65535)) (v128.const i8x16 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31 31))
+;; v16x8
+(assert_return (invoke "v16x8.offset0" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.align1" (i32.const 0)) (v128.const i16x8 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100 0x0100))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 0)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 0)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 0)) (v128.const i16x8 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F 0x000F))
+(assert_return (invoke "v16x8.offset0" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.align1" (i32.const 1)) (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v16x8.offset1_align1" (i32.const 1)) (v128.const i16x8 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302 0x0302))
+(assert_return (invoke "v16x8.offset2_align1" (i32.const 1)) (v128.const i16x8 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403 0x0403))
+(assert_return (invoke "v16x8.offset15_align2" (i32.const 1)) (v128.const i16x8 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+(assert_return (invoke "v16x8.offset0" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+(assert_return (invoke "v16x8.align1" (i32.const 65534)) (v128.const i16x8 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E 0x1F1E))
+;; v32x4
+(assert_return (invoke "v32x4.offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.align1" (i32.const 0)) (v128.const i32x4 0x03020100 0x03020100 0x03020100 0x03020100))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 0)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 0)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 0)) (v128.const i32x4 0x0000000F 0x0000000F 0x0000000F 0x0000000F))
+(assert_return (invoke "v32x4.offset0" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x04030201 0x04030201 0x04030201))
+(assert_return (invoke "v32x4.offset1_align1" (i32.const 1)) (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v32x4.offset2_align2" (i32.const 1)) (v128.const i32x4 0x06050403 0x06050403 0x06050403 0x06050403))
+(assert_return (invoke "v32x4.offset15_align4" (i32.const 1)) (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v32x4.offset0" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+(assert_return (invoke "v32x4.align1" (i32.const 65532)) (v128.const i32x4 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C 0x1F1E1D1C))
+;; v64x2
+(assert_return (invoke "v64x2.offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.align1" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0706050403020100))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 0)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 0)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 0)) (v128.const i64x2 0x000000000000000F 0x000000000000000F))
+(assert_return (invoke "v64x2.offset0" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0807060504030201))
+(assert_return (invoke "v64x2.offset1_align2" (i32.const 1)) (v128.const i64x2 0x0908070605040302 0x0908070605040302))
+(assert_return (invoke "v64x2.offset2_align4" (i32.const 1)) (v128.const i64x2 0x0A09080706050403 0x0A09080706050403))
+(assert_return (invoke "v64x2.offset15_align8" (i32.const 1)) (v128.const i64x2 0x0000000000000000 0x0000000000000000))
+(assert_return (invoke "v64x2.offset0" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+(assert_return (invoke "v64x2.align1" (i32.const 65528)) (v128.const i64x2 0x1F1E1D1C1B1A1918 0x1F1E1D1C1B1A1918))
+
+
+;; Out of bounds memory access
+(assert_trap (invoke "v128.load8_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load8_splat" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "v128.load16_splat" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v128.load32_splat" (i32.const 65533)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_splat" (i32.const 65529)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset2_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset15_align1" (i32.const 65535)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset2_align1" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset15_align2" (i32.const 65534)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset2_align2" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset15_align4" (i32.const 65532)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset2_align4" (i32.const 65528)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset15_align8" (i32.const 65528)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset1_align2" (i32.const -1)) "out of bounds memory access")
+
+(assert_trap (invoke "v8x16.offset65536" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "v8x16.offset65536" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v16x8.offset65535" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v32x4.offset65533" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "v64x2.offset65529" (i32.const 1)) "out of bounds memory access")
+
+
+;; Combination
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A")
+
+  (func (export "v128.load8_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load8_splat (i32.const 0))))
+  )
+  (func (export "v128.load16_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load16_splat (i32.const 1))))
+  )
+  (func (export "v128.load32_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load32_splat (i32.const 2))))
+  )
+  (func (export "v128.load64_splat-in-block") (result v128)
+      (block (result v128) (block (result v128) (v128.load64_splat (i32.const 9))))
+  )
+  (func (export "v128.load8_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load8_splat (i32.const 3))))
+  )
+  (func (export "v128.load16_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load16_splat (i32.const 4))))
+  )
+  (func (export "v128.load32_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_splat (i32.const 5))))
+  )
+  (func (export "v128.load64_splat-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_splat (i32.const 10))))
+  )
+  (func (export "v128.load8_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load8_splat (i32.const 6)))
+  )
+  (func (export "v128.load16_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load16_splat (i32.const 7)))
+  )
+  (func (export "v128.load32_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load32_splat (i32.const 8)))
+  )
+  (func (export "v128.load64_splat-extract_lane_s-operand") (result i32)
+    (i8x16.extract_lane_s 0 (v128.load64_splat (i32.const 11)))
+  )
+)
+(assert_return (invoke "v128.load8_splat-in-block") (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "v128.load16_splat-in-block") (v128.const i16x8 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201 0x0201))
+(assert_return (invoke "v128.load32_splat-in-block") (v128.const i32x4 0x05040302 0x05040302 0x05040302 0x05040302))
+(assert_return (invoke "v128.load64_splat-in-block") (v128.const i64x2 0x0000000000000A09 0x0000000000000A09))
+(assert_return (invoke "v128.load8_splat-as-br-value") (v128.const i8x16 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3))
+(assert_return (invoke "v128.load16_splat-as-br-value") (v128.const i16x8 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504 0x0504))
+(assert_return (invoke "v128.load32_splat-as-br-value") (v128.const i32x4 0x08070605 0x08070605 0x08070605 0x08070605))
+(assert_return (invoke "v128.load64_splat-as-br-value") (v128.const i64x2 0x000000000000000A 0x000000000000000A))
+(assert_return (invoke "v128.load8_splat-extract_lane_s-operand") (i32.const 6))
+(assert_return (invoke "v128.load16_splat-extract_lane_s-operand") (i32.const 7))
+(assert_return (invoke "v128.load32_splat-extract_lane_s-operand") (i32.const 8))
+(assert_return (invoke "v128.load64_splat-extract_lane_s-operand") (i32.const 0))
+
+
+;; Type check
+
+(assert_invalid (module (memory 0) (func (result v128) (v128.load8_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load16_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_splat (v128.const i32x4 0 0 0 0)))) "type mismatch")
+
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i8x16.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load_splat (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load_splat (i32.const 0))))") "unknown operator")
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load8_splat-arg-empty (result v128)
+      (v128.load8_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load16_splat-arg-empty (result v128)
+      (v128.load16_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_splat-arg-empty (result v128)
+      (v128.load32_splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_splat-arg-empty (result v128)
+      (v128.load64_splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_zero.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_zero.wast
new file mode 100644
index 0000000..6276a68
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_load_zero.wast
@@ -0,0 +1,154 @@
+;; Load and Zero extend test cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (data (i32.const 65520) "\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+
+  (func (export "v128.load32_zero") (param $0 i32) (result v128)
+    (v128.load32_zero (local.get $0))
+  )
+  (func (export "v128.load64_zero") (param $0 i32) (result v128)
+    (v128.load64_zero (local.get $0))
+  )
+
+  ;; load by a constant amount
+  (func (export "v128.load32_zero_const0") (result v128)
+    (v128.load32_zero (i32.const 0))
+  )
+  (func (export "v128.load64_zero_const8") (result v128)
+    (v128.load64_zero (i32.const 8))
+  )
+
+  ;; load data with different offset/align arguments
+  ;; i16x8
+  (func (export "v128.load32_zero_offset0") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load32_zero_align1") (param $0 i32) (result v128)
+    (v128.load32_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load32_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load32_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load32_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 (local.get $0))
+  )
+  (func (export "v128.load64_zero_align1") (param $0 i32) (result v128)
+    (v128.load64_zero align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset0_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=0 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset1_align1") (param $0 i32) (result v128)
+    (v128.load64_zero offset=1 align=1 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset10_align4") (param $0 i32) (result v128)
+    (v128.load64_zero offset=10 align=4 (local.get $0))
+  )
+  (func (export "v128.load64_zero_offset20_align8") (param $0 i32) (result v128)
+    (v128.load64_zero offset=20 align=8 (local.get $0))
+  )
+)
+
+
+;; normal
+(assert_return (invoke "v128.load32_zero" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 10)) (v128.const i32x4 0x0D0C0B0A 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 10)) (v128.const i64x2 0x81800F0E0D0C0B0A 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero" (i32.const 20)) (v128.const i32x4 0x87868584 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero" (i32.const 20)) (v128.const i64x2 0x0000898887868584 0x0000000000000000))
+
+;; load by a constant amount
+(assert_return (invoke "v128.load32_zero_const0") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero_const8") (v128.const i64x2 0x0F0E0D0C0B0A0908 0x0000000000000000))
+
+;; load data with different offset/align arguments
+;; load32_zero
+(assert_return (invoke "v128.load32_zero_offset0" (i32.const 0)) (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_align1" (i32.const 1)) (v128.const i32x4 0x04030201 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset0_align1" (i32.const 2)) (v128.const i32x4 0x05040302 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load32_zero_offset10_align4" (i32.const 3)) (v128.const i32x4 0x800F0E0D 0x00000000 0x00000000 0x00000000))
+
+;; load64_zero
+(assert_return (invoke "v128.load64_zero_offset0" (i32.const 0)) (v128.const i64x2 0x0706050403020100 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_align1" (i32.const 1)) (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset0_align1" (i32.const 2)) (v128.const i64x2 0x0908070605040302 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset10_align4" (i32.const 3)) (v128.const i64x2 0x84838281800F0E0D 0x0000000000000000))
+(assert_return (invoke "v128.load64_zero_offset20_align8" (i32.const 4)) (v128.const i64x2 0x0000000000008988 0x0000000000000000))
+
+;; out of bounds memory access
+(assert_trap (invoke "v128.load32_zero" (i32.const -1))  "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero" (i32.const -1))  "out of bounds memory access")
+
+(assert_trap (invoke "v128.load32_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "v128.load64_zero_offset1_align1" (i32.const -1)) "out of bounds memory access")
+
+;; type check
+(assert_invalid (module (memory 0) (func (result v128) (v128.load32_zero (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 0) (func (result v128) (v128.load64_zero (f32.const 0)))) "type mismatch")
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load32_zero-arg-empty (result v128)
+      (v128.load32_zero)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.load64_zero-arg-empty (result v128)
+      (v128.load64_zero)
+    )
+  )
+  "type mismatch"
+)
+
+;; Unknown operator
+
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i16x8.load16x4_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i32x4.load32x2_u (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_s (i32.const 0))))") "unknown operator")
+(assert_malformed (module quote "(memory 1) (func (drop (i64x2.load64x1_u (i32.const 0))))") "unknown operator")
+
+;; combination
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0A\0B\0C\0D\0E\0F\80\81\82\83\84\85\86\87\88\89")
+  (func (export "v128.load32_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load32_zero (i32.const 0))))
+  )
+  (func (export "v128.load64_zero-in-block") (result v128)
+    (block (result v128) (block (result v128) (v128.load64_zero (i32.const 1))))
+  )
+  (func (export "v128.load32_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load32_zero (i32.const 6))))
+  )
+  (func (export "v128.load64_zero-as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load64_zero (i32.const 7))))
+  )
+  (func (export "v128.load32_zero-extract_lane_s-operand") (result i32)
+    (i32x4.extract_lane 0 (v128.load32_zero (i32.const 12)))
+  )
+  (func (export "v128.load64_zero-extract_lane_s-operand") (result i64)
+    (i64x2.extract_lane 0 (v128.load64_zero (i32.const 13)))
+  )
+)
+(assert_return (invoke "v128.load32_zero-in-block") (v128.const i32x4 0x03020100 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-in-block") (v128.const i64x2 0x0807060504030201 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-as-br-value") (v128.const i32x4 0x09080706 0x00000000 0x00000000 0x00000000))
+(assert_return (invoke "v128.load64_zero-as-br-value") (v128.const i64x2 0x0E0D0C0B0A090807 0x0000000000000000))
+(assert_return (invoke "v128.load32_zero-extract_lane_s-operand") (i32.const 0x0F0E0D0C))
+(assert_return (invoke "v128.load64_zero-extract_lane_s-operand") (i64.const 0x84838281800F0E0D))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_splat.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_splat.wast
new file mode 100644
index 0000000..4be04ef
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_splat.wast
@@ -0,0 +1,430 @@
+;; Tests for the *_splat instructions
+
+(module
+  (func (export "i8x16.splat") (param i32) (result v128) (i8x16.splat (local.get 0)))
+  (func (export "i16x8.splat") (param i32) (result v128) (i16x8.splat (local.get 0)))
+  (func (export "i32x4.splat") (param i32) (result v128) (i32x4.splat (local.get 0)))
+  (func (export "f32x4.splat") (param f32) (result v128) (f32x4.splat (local.get 0)))
+  (func (export "i64x2.splat") (param i64) (result v128) (i64x2.splat (local.get 0)))
+  (func (export "f64x2.splat") (param f64) (result v128) (f64x2.splat (local.get 0)))
+)
+
+(assert_return (invoke "i8x16.splat" (i32.const 0)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i8x16.splat" (i32.const 5)) (v128.const i8x16 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i8x16.splat" (i32.const -5)) (v128.const i8x16 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i8x16.splat" (i32.const 257)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff)) (v128.const i8x16 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i8x16.splat" (i32.const -128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 127)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const -129)) (v128.const i8x16 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127 127))
+(assert_return (invoke "i8x16.splat" (i32.const 128)) (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128))
+(assert_return (invoke "i8x16.splat" (i32.const 0xff7f)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "i8x16.splat" (i32.const 0x80)) (v128.const i8x16 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80 0x80))
+(assert_return (invoke "i8x16.splat" (i32.const 0xAB)) (v128.const i32x4 0xABABABAB 0xABABABAB 0xABABABAB 0xABABABAB))
+
+(assert_return (invoke "i16x8.splat" (i32.const 0)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+(assert_return (invoke "i16x8.splat" (i32.const 5)) (v128.const i16x8 5 5 5 5 5 5 5 5))
+(assert_return (invoke "i16x8.splat" (i32.const -5)) (v128.const i16x8 -5 -5 -5 -5 -5 -5 -5 -5))
+(assert_return (invoke "i16x8.splat" (i32.const 65537)) (v128.const i16x8 1 1 1 1 1 1 1 1))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff)) (v128.const i16x8 -1 -1 -1 -1 -1 -1 -1 -1))
+(assert_return (invoke "i16x8.splat" (i32.const -32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 32767)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const -32769)) (v128.const i16x8 32767 32767 32767 32767 32767 32767 32767 32767))
+(assert_return (invoke "i16x8.splat" (i32.const 32768)) (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768))
+(assert_return (invoke "i16x8.splat" (i32.const 0xffff7fff)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "i16x8.splat" (i32.const 0x8000)) (v128.const i16x8 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000 0x8000))
+(assert_return (invoke "i16x8.splat" (i32.const 0xABCD)) (v128.const i32x4 0xABCDABCD 0xABCDABCD 0xABCDABCD 0xABCDABCD))
+(assert_return (invoke "i16x8.splat" (i32.const 012345)) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+(assert_return (invoke "i16x8.splat" (i32.const 0x01234)) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+
+(assert_return (invoke "i32x4.splat" (i32.const 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.splat" (i32.const 5)) (v128.const i32x4 5 5 5 5))
+(assert_return (invoke "i32x4.splat" (i32.const -5)) (v128.const i32x4 -5 -5 -5 -5))
+(assert_return (invoke "i32x4.splat" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const 4294967295)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "i32x4.splat" (i32.const -2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483647)) (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff))
+(assert_return (invoke "i32x4.splat" (i32.const 2147483648)) (v128.const i32x4 0x80000000 0x80000000 0x80000000 0x80000000))
+(assert_return (invoke "i32x4.splat" (i32.const 01234567890)) (v128.const i32x4 012_3456_7890 012_3456_7890 012_3456_7890 012_3456_7890))
+(assert_return (invoke "i32x4.splat" (i32.const 0x012345678)) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+
+(assert_return (invoke "f32x4.splat" (f32.const 0.0)) (v128.const f32x4 0.0 0.0 0.0 0.0))
+(assert_return (invoke "f32x4.splat" (f32.const 1.1)) (v128.const f32x4 1.1 1.1 1.1 1.1))
+(assert_return (invoke "f32x4.splat" (f32.const -1.1)) (v128.const f32x4 -1.1 -1.1 -1.1 -1.1))
+(assert_return (invoke "f32x4.splat" (f32.const 1e38)) (v128.const f32x4 1e38 1e38 1e38 1e38))
+(assert_return (invoke "f32x4.splat" (f32.const -1e38)) (v128.const f32x4 -1e38 -1e38 -1e38 -1e38))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1.fffffep127)) (v128.const f32x4 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127 0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1.fffffep127)) (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(assert_return (invoke "f32x4.splat" (f32.const 0x1p127)) (v128.const f32x4 0x1p127 0x1p127 0x1p127 0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const -0x1p127)) (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127))
+(assert_return (invoke "f32x4.splat" (f32.const inf)) (v128.const f32x4 inf inf inf inf))
+(assert_return (invoke "f32x4.splat" (f32.const -inf)) (v128.const f32x4 -inf -inf -inf -inf))
+(assert_return (invoke "f32x4.splat" (f32.const nan)) (v128.const f32x4 nan nan nan nan))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x1)) (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1))
+(assert_return (invoke "f32x4.splat" (f32.const nan:0x7f_ffff)) (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789)) (v128.const f32x4 0123456789 0123456789 0123456789 0123456789))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.)) (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF)) (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.)) (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789e019)) (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019))
+(assert_return (invoke "f32x4.splat" (f32.const 0123456789.e+019)) (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEFp019)) (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019))
+(assert_return (invoke "f32x4.splat" (f32.const 0x0123456789ABCDEF.p-019)) (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019))
+
+(assert_return (invoke "i64x2.splat" (i64.const 0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const -0)) (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.splat" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "i64x2.splat" (i64.const -1)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 -9223372036854775808 -9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const -9223372036854775808)) (v128.const i64x2 9223372036854775808 9223372036854775808))
+(assert_return (invoke "i64x2.splat" (i64.const 9223372036854775807)) (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.splat" (i64.const 18446744073709551615)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const 0x7fffffffffffffff)) (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff))
+(assert_return (invoke "i64x2.splat" (i64.const 0xffffffffffffffff)) (v128.const i64x2 -1 -1))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 -0x8000000000000000 -0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const -0x8000000000000000)) (v128.const i64x2 0x8000000000000000 0x8000000000000000))
+(assert_return (invoke "i64x2.splat" (i64.const 01234567890123456789)) (v128.const i64x2 01_234_567_890_123_456_789 01_234_567_890_123_456_789))
+(assert_return (invoke "i64x2.splat" (i64.const 0x01234567890ABcdef)) (v128.const i64x2 0x0_1234_5678_90AB_cdef 0x0_1234_5678_90AB_cdef))
+
+(assert_return (invoke "f64x2.splat" (f64.const 0.0)) (v128.const f64x2 0.0 0.0))
+(assert_return (invoke "f64x2.splat" (f64.const -0.0)) (v128.const f64x2 -0.0 -0.0))
+(assert_return (invoke "f64x2.splat" (f64.const 1.1)) (v128.const f64x2 1.1 1.1))
+(assert_return (invoke "f64x2.splat" (f64.const -1.1)) (v128.const f64x2 -1.1 -1.1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0.0000000000001p-1022)) (v128.const f64x2 0x0.0000000000001p-1022 0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x0.0000000000001p-1022)) (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1022)) (v128.const f64x2 0x1p-1022 0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1022)) (v128.const f64x2 -0x1p-1022 -0x1p-1022))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p-1)) (v128.const f64x2 0x1p-1 0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p-1)) (v128.const f64x2 -0x1p-1 -0x1p-1))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1p+0)) (v128.const f64x2 0x1p+0 0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.921fb54442d18p+2)) (v128.const f64x2 0x1.921fb54442d18p+2 0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.921fb54442d18p+2)) (v128.const f64x2 -0x1.921fb54442d18p+2 -0x1.921fb54442d18p+2))
+(assert_return (invoke "f64x2.splat" (f64.const 0x1.fffffffffffffp+1023)) (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const -0x1.fffffffffffffp+1023)) (v128.const f64x2 -0x1.fffffffffffffp+1023 -0x1.fffffffffffffp+1023))
+(assert_return (invoke "f64x2.splat" (f64.const inf)) (v128.const f64x2 inf inf))
+(assert_return (invoke "f64x2.splat" (f64.const -inf)) (v128.const f64x2 -inf -inf))
+(assert_return (invoke "f64x2.splat" (f64.const nan)) (v128.const f64x2 nan nan))
+(assert_return (invoke "f64x2.splat" (f64.const -nan)) (v128.const f64x2 -nan -nan))
+(assert_return (invoke "f64x2.splat" (f64.const nan:0x4000000000000)) (v128.const f64x2 nan:0x4000000000000 nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const -nan:0x4000000000000)) (v128.const f64x2 -nan:0x4000000000000 -nan:0x4000000000000))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789)) (v128.const f64x2 0123456789 0123456789))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789.)) (v128.const f64x2 0123456789. 0123456789.))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef)) (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.)) (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e019)) (v128.const f64x2 0123456789e019 0123456789e019))
+(assert_return (invoke "f64x2.splat" (f64.const 0123456789e+019)) (v128.const f64x2 0123456789e+019 0123456789e+019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019))
+(assert_return (invoke "f64x2.splat" (f64.const 0x0123456789ABCDEFabcdef.p-019)) (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019))
+
+;; Unknown operator
+
+(assert_malformed (module quote "(func (result v128) (v128.splat (i32.const 0)))") "unknown operator")
+
+
+;; Type mismatched
+
+(assert_invalid (module (func (result v128) i8x16.splat (i64.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f32.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i8x16.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (i64.const 1))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f32.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i16x8.splat (f64.const 1.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (i64.const 2))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f32.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i32x4.splat (f64.const 2.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i32.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (i64.const 4))) "type mismatch")
+(assert_invalid (module (func (result v128) f32x4.splat (f64.const 4.0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) i64x2.splat (f64.const 0.0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (i32.const 0))) "type mismatch")
+(assert_invalid (module (func (result v128) f64x2.splat (f32.const 0.0))) "type mismatch")
+
+
+;; V128 splat operators as the argument of other SIMD instructions
+
+;; v128.store and v128.load
+(module (memory 1)
+  (func (export "as-v128_store-operand-1") (param i32) (result v128)
+    (v128.store (i32.const 0) (i8x16.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-2") (param i32) (result v128)
+    (v128.store (i32.const 0) (i16x8.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-3") (param i32) (result v128)
+    (v128.store (i32.const 0) (i32x4.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-4") (param i64) (result v128)
+    (v128.store (i32.const 0) (i64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+  (func (export "as-v128_store-operand-5") (param f64) (result v128)
+    (v128.store (i32.const 0) (f64x2.splat (local.get 0)))
+    (v128.load (i32.const 0)))
+)
+
+(assert_return (invoke "as-v128_store-operand-1" (i32.const 1)) (v128.const i8x16 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1))
+(assert_return (invoke "as-v128_store-operand-2" (i32.const 256)) (v128.const i16x8 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100))
+(assert_return (invoke "as-v128_store-operand-3" (i32.const 0xffffffff)) (v128.const i32x4 -1 -1 -1 -1))
+(assert_return (invoke "as-v128_store-operand-4" (i64.const 1)) (v128.const i64x2 1 1))
+(assert_return (invoke "as-v128_store-operand-5" (f64.const -0x1p+0)) (v128.const f64x2 -0x1p+0 -0x1p+0))
+
+(module
+  ;; Accessing lane
+  (func (export "as-i8x16_extract_lane_s-operand-first") (param i32) (result i32)
+    (i8x16.extract_lane_s 0 (i8x16.splat (local.get 0))))
+  (func (export "as-i8x16_extract_lane_s-operand-last") (param i32) (result i32)
+    (i8x16.extract_lane_s 15 (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-first") (param i32) (result i32)
+    (i16x8.extract_lane_s 0 (i16x8.splat (local.get 0))))
+  (func (export "as-i16x8_extract_lane_s-operand-last") (param i32) (result i32)
+    (i16x8.extract_lane_s 7 (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-first") (param i32) (result i32)
+    (i32x4.extract_lane 0 (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_extract_lane_s-operand-last") (param i32) (result i32)
+    (i32x4.extract_lane 3 (i32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-first") (param f32) (result f32)
+    (f32x4.extract_lane 0 (f32x4.splat (local.get 0))))
+  (func (export "as-f32x4_extract_lane_s-operand-last") (param f32) (result f32)
+    (f32x4.extract_lane 3 (f32x4.splat (local.get 0))))
+  (func (export "as-v8x16_swizzle-operands") (param i32) (param i32) (result v128)
+    (i8x16.swizzle (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i64x2_extract_lane-operand-first") (param i64) (result i64)
+    (i64x2.extract_lane 0 (i64x2.splat (local.get 0))))
+  (func (export "as-i64x2_extract_lane-operand-last") (param i64) (result i64)
+    (i64x2.extract_lane 1 (i64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-first") (param f64) (result f64)
+    (f64x2.extract_lane 0 (f64x2.splat (local.get 0))))
+  (func (export "as-f64x2_extract_lane-operand-last") (param f64) (result f64)
+    (f64x2.extract_lane 1 (f64x2.splat (local.get 0))))
+
+  ;; Integer arithmetic
+  (func (export "as-i8x16_add_sub-operands") (param i32 i32 i32) (result v128)
+    (i8x16.add (i8x16.splat (local.get 0))
+      (i8x16.sub (i8x16.splat (local.get 1)) (i8x16.splat (local.get 2)))))
+  (func (export "as-i16x8_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i16x8.add (i16x8.splat (local.get 0))
+      (i16x8.sub (i16x8.splat (local.get 1))
+        (i16x8.mul (i16x8.splat (local.get 2)) (i16x8.splat (local.get 3))))))
+  (func (export "as-i32x4_add_sub_mul-operands") (param i32 i32 i32 i32) (result v128)
+    (i32x4.add (i32x4.splat (local.get 0))
+      (i32x4.sub (i32x4.splat (local.get 1))
+        (i32x4.mul (i32x4.splat (local.get 2)) (i32x4.splat (local.get 3))))))
+
+  (func (export "as-i64x2_add_sub_mul-operands") (param i64 i64 i64 i64) (result v128)
+    (i64x2.add (i64x2.splat (local.get 0))
+      (i64x2.sub (i64x2.splat (local.get 1))
+        (i64x2.mul (i64x2.splat (local.get 2)) (i64x2.splat (local.get 3))))))
+  (func (export "as-f64x2_add_sub_mul-operands") (param f64 f64 f64 f64) (result v128)
+    (f64x2.add (f64x2.splat (local.get 0))
+      (f64x2.sub (f64x2.splat (local.get 1))
+        (f64x2.mul (f64x2.splat (local.get 2)) (f64x2.splat (local.get 3))))))
+
+  ;; Saturating integer arithmetic
+  (func (export "as-i8x16_add_sat_s-operands") (param i32 i32) (result v128)
+    (i8x16.add_sat_s (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_add_sat_s-operands") (param i32 i32) (result v128)
+    (i16x8.add_sat_s (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i8x16_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i8x16.sub_sat_u (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_sub_sat_u-operands") (param i32 i32) (result v128)
+    (i16x8.sub_sat_u (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+
+  ;; Bit shifts
+  (func (export "as-i8x16_shr_s-operand") (param i32 i32) (result v128)
+    (i8x16.shr_s (i8x16.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i16x8_shr_s-operand") (param i32 i32) (result v128)
+    (i16x8.shr_s (i16x8.splat (local.get 0)) (local.get 1)))
+  (func (export "as-i32x4_shr_s-operand") (param i32 i32) (result v128)
+    (i32x4.shr_s (i32x4.splat (local.get 0)) (local.get 1)))
+
+  ;; Bitwise operantions
+  (func (export "as-v128_and-operands") (param i32 i32) (result v128)
+    (v128.and (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-v128_or-operands") (param i32 i32) (result v128)
+    (v128.or (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-v128_xor-operands") (param i32 i32) (result v128)
+    (v128.xor (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+
+  ;; Boolean horizontal reductions
+  (func (export "as-i8x16_all_true-operand") (param i32) (result i32)
+    (i8x16.all_true (i8x16.splat (local.get 0))))
+  (func (export "as-i16x8_all_true-operand") (param i32) (result i32)
+    (i16x8.all_true (i16x8.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand1") (param i32) (result i32)
+    (i32x4.all_true (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_all_true-operand2") (param i64) (result i32)
+    (i32x4.all_true (i64x2.splat (local.get 0))))
+
+  ;; Comparisons
+  (func (export "as-i8x16_eq-operands") (param i32 i32) (result v128)
+    (i8x16.eq (i8x16.splat (local.get 0)) (i8x16.splat (local.get 1))))
+  (func (export "as-i16x8_eq-operands") (param i32 i32) (result v128)
+    (i16x8.eq (i16x8.splat (local.get 0)) (i16x8.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands1") (param i32 i32) (result v128)
+    (i32x4.eq (i32x4.splat (local.get 0)) (i32x4.splat (local.get 1))))
+  (func (export "as-i32x4_eq-operands2") (param i64 i64) (result v128)
+    (i32x4.eq (i64x2.splat (local.get 0)) (i64x2.splat (local.get 1))))
+  (func (export "as-f32x4_eq-operands") (param f32 f32) (result v128)
+    (f32x4.eq (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+  (func (export "as-f64x2_eq-operands") (param f64 f64) (result v128)
+    (f64x2.eq (f64x2.splat (local.get 0)) (f64x2.splat (local.get 1))))
+
+  ;; Floating-point sign bit operations
+  (func (export "as-f32x4_abs-operand") (param f32) (result v128)
+    (f32x4.abs (f32x4.splat (local.get 0))))
+
+  ;; Floating-point min
+  (func (export "as-f32x4_min-operands") (param f32 f32) (result v128)
+    (f32x4.min (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Floating-point arithmetic
+  (func (export "as-f32x4_div-operands") (param f32 f32) (result v128)
+    (f32x4.div (f32x4.splat (local.get 0)) (f32x4.splat (local.get 1))))
+
+  ;; Conversions
+  (func (export "as-f32x4_convert_s_i32x4-operand") (param i32) (result v128)
+    (f32x4.convert_i32x4_s (i32x4.splat (local.get 0))))
+  (func (export "as-i32x4_trunc_s_f32x4_sat-operand") (param f32) (result v128)
+    (i32x4.trunc_sat_f32x4_s (f32x4.splat (local.get 0))))
+)
+
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-first" (i32.const 42)) (i32.const 42))
+(assert_return (invoke "as-i8x16_extract_lane_s-operand-last" (i32.const -42)) (i32.const -42))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-first" (i32.const 0xffff7fff)) (i32.const 32767))
+(assert_return (invoke "as-i16x8_extract_lane_s-operand-last" (i32.const 0x8000)) (i32.const -32768))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-first" (i32.const 0x7fffffff)) (i32.const 2147483647))
+(assert_return (invoke "as-i32x4_extract_lane_s-operand-last" (i32.const 0x80000000)) (i32.const -2147483648))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-first" (f32.const 1.5)) (f32.const 1.5))
+(assert_return (invoke "as-f32x4_extract_lane_s-operand-last" (f32.const -0.25)) (f32.const -0.25))
+(assert_return (invoke "as-v8x16_swizzle-operands" (i32.const 1) (i32.const -1)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i64x2_extract_lane-operand-last" (i64.const -42)) (i64.const -42))
+(assert_return (invoke "as-i64x2_extract_lane-operand-first" (i64.const 42)) (i64.const 42))
+(assert_return (invoke "as-f64x2_extract_lane-operand-first" (f64.const 1.5)) (f64.const 1.5))
+(assert_return (invoke "as-f64x2_extract_lane-operand-last" (f64.const -0x1p+0)) (f64.const -0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sub-operands" (i32.const 3) (i32.const 2) (i32.const 1)) (v128.const i8x16 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4))
+(assert_return (invoke "as-i16x8_add_sub_mul-operands" (i32.const 257) (i32.const 128) (i32.const 16) (i32.const 16)) (v128.const i16x8 129 129 129 129 129 129 129 129))
+(assert_return (invoke "as-i32x4_add_sub_mul-operands" (i32.const 65535) (i32.const 65537) (i32.const 256) (i32.const 256)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-i64x2_add_sub_mul-operands" (i64.const 0x7fffffff) (i64.const 0x1_0000_0001) (i64.const 65536) (i64.const 65536)) (v128.const i64x2 0x8000_0000 0x8000_0000))
+(assert_return (invoke "as-f64x2_add_sub_mul-operands" (f64.const 0x1p-1) (f64.const 0.75) (f64.const 0x1p-1) (f64.const 0.5)) (v128.const f64x2 0x1p+0 0x1p+0))
+
+(assert_return (invoke "as-i8x16_add_sat_s-operands" (i32.const 0x7f) (i32.const 1)) (v128.const i8x16 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f 0x7f))
+(assert_return (invoke "as-i16x8_add_sat_s-operands" (i32.const 0x7fff) (i32.const 1)) (v128.const i16x8 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff 0x7fff))
+(assert_return (invoke "as-i8x16_sub_sat_u-operands" (i32.const 0x7f) (i32.const 0xff)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_sub_sat_u-operands" (i32.const 0x7fff) (i32.const 0xffff)) (v128.const i16x8 0 0 0 0 0 0 0 0))
+
+(assert_return (invoke "as-i8x16_shr_s-operand" (i32.const 0xf0) (i32.const 3)) (v128.const i8x16 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2 -2))
+(assert_return (invoke "as-i16x8_shr_s-operand" (i32.const 0x100) (i32.const 4)) (v128.const i16x8 16 16 16 16 16 16 16 16))
+(assert_return (invoke "as-i32x4_shr_s-operand" (i32.const -1) (i32.const 16)) (v128.const i32x4 -1 -1 -1 -1))
+
+(assert_return (invoke "as-v128_and-operands" (i32.const 0x11) (i32.const 0xff)) (v128.const i8x16 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17 17))
+(assert_return (invoke "as-v128_or-operands" (i32.const 0) (i32.const 0xffff)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-v128_xor-operands" (i32.const 0xf0f0f0f0) (i32.const 0xffffffff)) (v128.const i32x4 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f 0xf0f0f0f))
+
+(assert_return (invoke "as-i8x16_all_true-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-i16x8_all_true-operand" (i32.const 0xffff)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand1" (i32.const 0xf0f0f0f0)) (i32.const 1))
+(assert_return (invoke "as-i32x4_all_true-operand2" (i64.const -1)) (i32.const 1))
+
+(assert_return (invoke "as-i8x16_eq-operands" (i32.const 1) (i32.const 2)) (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+(assert_return (invoke "as-i16x8_eq-operands" (i32.const -1) (i32.const 65535)) (v128.const i16x8 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff 0xffff))
+(assert_return (invoke "as-i32x4_eq-operands1" (i32.const -1) (i32.const 0xffffffff)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-f32x4_eq-operands" (f32.const +0.0) (f32.const -0.0)) (v128.const i32x4 0xffffffff 0xffffffff 0xffffffff 0xffffffff))
+(assert_return (invoke "as-i32x4_eq-operands2" (i64.const 1) (i64.const 2)) (v128.const i64x2 0xffffffff00000000 0xffffffff00000000))
+(assert_return (invoke "as-f64x2_eq-operands" (f64.const +0.0) (f64.const -0.0)) (v128.const i64x2 -1 -1))
+
+(assert_return (invoke "as-f32x4_abs-operand" (f32.const -1.125)) (v128.const f32x4 1.125 1.125 1.125 1.125))
+(assert_return (invoke "as-f32x4_min-operands" (f32.const 0.25) (f32.const 1e-38)) (v128.const f32x4 1e-38 1e-38 1e-38 1e-38))
+(assert_return (invoke "as-f32x4_div-operands" (f32.const 1.0) (f32.const 8.0)) (v128.const f32x4 0.125 0.125 0.125 0.125))
+
+(assert_return (invoke "as-f32x4_convert_s_i32x4-operand" (i32.const 12345)) (v128.const f32x4 12345.0 12345.0 12345.0 12345.0))
+(assert_return (invoke "as-i32x4_trunc_s_f32x4_sat-operand" (f32.const 1.1)) (v128.const i32x4 1 1 1 1))
+
+
+;; As the argument of control constructs and WASM instructions
+
+(module
+  (global $g (mut v128) (v128.const f32x4 0.0 0.0 0.0 0.0))
+  (func (export "as-br-value1") (param i32) (result v128)
+    (block (result v128) (br 0 (i8x16.splat (local.get 0)))))
+  (func (export "as-return-value1") (param i32) (result v128)
+    (return (i16x8.splat (local.get 0))))
+  (func (export "as-local_set-value1") (param i32) (result v128) (local v128)
+    (local.set 1 (i32x4.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value1") (param f32) (result v128)
+    (global.set $g (f32x4.splat (local.get 0)))
+    (return (global.get $g)))
+  (func (export "as-br-value2") (param i64) (result v128)
+    (block (result v128) (br 0 (i64x2.splat (local.get 0)))))
+  (func (export "as-return-value2") (param i64) (result v128)
+    (return (i64x2.splat (local.get 0))))
+  (func (export "as-local_set-value2") (param i64) (result v128) (local v128)
+    (local.set 1 (i64x2.splat (local.get 0)))
+    (return (local.get 1)))
+  (func (export "as-global_set-value2") (param f64) (result v128)
+    (global.set $g (f64x2.splat (local.get 0)))
+    (return (global.get $g)))
+)
+
+(assert_return (invoke "as-br-value1" (i32.const 0xAB)) (v128.const i8x16 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB 0xAB))
+(assert_return (invoke "as-return-value1" (i32.const 0xABCD)) (v128.const i16x8 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value1" (i32.const 0x10000)) (v128.const i32x4 0x10000 0x10000 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value1" (f32.const 1.0)) (v128.const f32x4 1.0 1.0 1.0 1.0))
+(assert_return (invoke "as-br-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-return-value2" (i64.const 0xABCD)) (v128.const i64x2 0xABCD 0xABCD))
+(assert_return (invoke "as-local_set-value2" (i64.const 0x10000)) (v128.const i64x2 0x10000 0x10000))
+(assert_return (invoke "as-global_set-value2" (f64.const 1.0)) (v128.const f64x2 1.0 1.0))
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module
+    (func $i8x16.splat-arg-empty (result v128)
+      (i8x16.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i16x8.splat-arg-empty (result v128)
+      (i16x8.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i32x4.splat-arg-empty (result v128)
+      (i32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f32x4.splat-arg-empty (result v128)
+      (f32x4.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $i64x2.splat-arg-empty (result v128)
+      (i64x2.splat)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f64x2.splat-arg-empty (result v128)
+      (f64x2.splat)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store.wast
new file mode 100644
index 0000000..50349c4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store16_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store16_lane.wast
new file mode 100644
index 0000000..d8ea35c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store16_lane.wast
@@ -0,0 +1,299 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store16_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store16_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_4_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_5_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_6_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store16_lane_7_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store16_lane align=2 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store16_lane_0" (i32.const 0)
+                                             (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                             (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1" (i32.const 1)
+                                             (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                             (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2" (i32.const 2)
+                                             (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                             (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3" (i32.const 3)
+                                             (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                             (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4" (i32.const 4)
+                                             (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                             (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5" (i32.const 5)
+                                             (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                             (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6" (i32.const 6)
+                                             (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                             (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7" (i32.const 7)
+                                             (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                             (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_offset_0" (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                      (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_offset_1" (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                      (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_offset_2" (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                      (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_offset_3" (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                      (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_offset_4" (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                      (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_offset_5" (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                      (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_offset_6" (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                      (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_offset_7" (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                      (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i16x8 256 0 0 0 0 0 0 0))
+                                                     (i64.const 256))
+(assert_return (invoke "v128.store16_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i16x8 0 513 0 0 0 0 0 0))
+                                                     (i64.const 513))
+(assert_return (invoke "v128.store16_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i16x8 0 0 770 0 0 0 0 0))
+                                                     (i64.const 770))
+(assert_return (invoke "v128.store16_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i16x8 0 0 0 1027 0 0 0 0))
+                                                     (i64.const 1027))
+(assert_return (invoke "v128.store16_lane_4_align_1" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_4_align_2" (i32.const 4)
+                                                     (v128.const i16x8 0 0 0 0 1284 0 0 0))
+                                                     (i64.const 1284))
+(assert_return (invoke "v128.store16_lane_5_align_1" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_5_align_2" (i32.const 5)
+                                                     (v128.const i16x8 0 0 0 0 0 1541 0 0))
+                                                     (i64.const 1541))
+(assert_return (invoke "v128.store16_lane_6_align_1" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_6_align_2" (i32.const 6)
+                                                     (v128.const i16x8 0 0 0 0 0 0 1798 0))
+                                                     (i64.const 1798))
+(assert_return (invoke "v128.store16_lane_7_align_1" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+(assert_return (invoke "v128.store16_lane_7_align_2" (i32.const 7)
+                                                     (v128.const i16x8 0 0 0 0 0 0 0 2055))
+                                                     (i64.const 2055))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store16_lane 8 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store16_lane align=4 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store32_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store32_lane.wast
new file mode 100644
index 0000000..847bab9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store32_lane.wast
@@ -0,0 +1,199 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store32_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store32_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_2_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=2 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store32_lane_3_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store32_lane align=4 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store32_lane_0" (i32.const 0)
+                                             (v128.const i32x4 50462976 0 0 0))
+                                             (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1" (i32.const 1)
+                                             (v128.const i32x4 0 67305985 0 0))
+                                             (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2" (i32.const 2)
+                                             (v128.const i32x4 0 0 84148994 0))
+                                             (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3" (i32.const 3)
+                                             (v128.const i32x4 0 0 0 100992003))
+                                             (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_offset_0" (v128.const i32x4 50462976 0 0 0))
+                                                      (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_offset_1" (v128.const i32x4 0 67305985 0 0))
+                                                      (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_offset_2" (v128.const i32x4 0 0 84148994 0))
+                                                      (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_offset_3" (v128.const i32x4 0 0 0 100992003))
+                                                      (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i32x4 50462976 0 0 0))
+                                                     (i64.const 50462976))
+(assert_return (invoke "v128.store32_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i32x4 0 67305985 0 0))
+                                                     (i64.const 67305985))
+(assert_return (invoke "v128.store32_lane_2_align_1" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_2" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_2_align_4" (i32.const 2)
+                                                     (v128.const i32x4 0 0 84148994 0))
+                                                     (i64.const 84148994))
+(assert_return (invoke "v128.store32_lane_3_align_1" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_2" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+(assert_return (invoke "v128.store32_lane_3_align_4" (i32.const 3)
+                                                     (v128.const i32x4 0 0 0 100992003))
+                                                     (i64.const 100992003))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store32_lane 4 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store32_lane align=8 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store64_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store64_lane.wast
new file mode 100644
index 0000000..2ed1dcd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store64_lane.wast
@@ -0,0 +1,131 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store64_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store64_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_0_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=2 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=4 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store64_lane_1_align_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store64_lane align=8 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store64_lane_0" (i32.const 0)
+                                             (v128.const i64x2 506097522914230528 0))
+                                             (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1" (i32.const 1)
+                                             (v128.const i64x2 0 578437695752307201))
+                                             (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_offset_0" (v128.const i64x2 506097522914230528 0))
+                                                      (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_offset_1" (v128.const i64x2 0 578437695752307201))
+                                                      (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_0_align_1" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_2" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_4" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_0_align_8" (i32.const 0)
+                                                     (v128.const i64x2 506097522914230528 0))
+                                                     (i64.const 506097522914230528))
+(assert_return (invoke "v128.store64_lane_1_align_1" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_2" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_4" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+(assert_return (invoke "v128.store64_lane_1_align_8" (i32.const 1)
+                                                     (v128.const i64x2 0 578437695752307201))
+                                                     (i64.const 578437695752307201))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store64_lane 2 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store64_lane align=16 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store8_lane.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store8_lane.wast
new file mode 100644
index 0000000..7258a40
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/simd/simd_store8_lane.wast
@@ -0,0 +1,427 @@
+;; Tests for store lane operations.
+
+
+(module
+  (memory 1)
+  (global $zero (mut v128) (v128.const i32x4 0 0 0 0))
+  (func (export "v128.store8_lane_0")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_2")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_3")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_4")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_5")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_6")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_7")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_8")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_9")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_10")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_11")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_12")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_13")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_14")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_15")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store (local.get $address) (global.get $zero))    (local.get $ret))
+  (func (export "v128.store8_lane_0_offset_0")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=0 0 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=0 (i32.const 0)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_offset_1")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=1 1 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=1 (i32.const 0)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_offset_2")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=2 2 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=2 (i32.const 0)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_offset_3")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=3 3 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=3 (i32.const 0)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_offset_4")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=4 4 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=4 (i32.const 0)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_offset_5")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=5 5 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=5 (i32.const 0)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_offset_6")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=6 6 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=6 (i32.const 0)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_offset_7")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=7 7 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=7 (i32.const 0)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_offset_8")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=8 8 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=8 (i32.const 0)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_offset_9")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=9 9 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=9 (i32.const 0)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_offset_10")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=10 10 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=10 (i32.const 0)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_offset_11")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=11 11 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=11 (i32.const 0)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_offset_12")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=12 12 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=12 (i32.const 0)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_offset_13")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=13 13 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=13 (i32.const 0)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_offset_14")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=14 14 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=14 (i32.const 0)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_offset_15")
+    (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane offset=15 15 (i32.const 0) (local.get $x))
+    (local.set $ret (i64.load offset=15 (i32.const 0)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_0_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 0 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=0 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_1_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 1 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=1 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_2_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 2 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=2 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_3_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 3 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=3 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_4_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 4 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=4 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_5_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 5 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=5 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_6_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 6 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=6 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_7_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 7 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=7 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_8_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 8 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=8 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_9_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 9 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=9 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_10_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 10 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=10 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_11_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 11 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=11 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_12_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 12 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=12 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_13_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 13 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=13 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_14_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 14 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=14 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+  (func (export "v128.store8_lane_15_align_1")
+    (param $address i32) (param $x v128) (result i64) (local $ret i64)
+    (v128.store8_lane align=1 15 (local.get $address) (local.get $x))
+    (local.set $ret (i64.load (local.get $address)))
+    (v128.store offset=15 (i32.const 0) (global.get $zero))
+    (local.get $ret))
+)
+
+(assert_return (invoke "v128.store8_lane_0" (i32.const 0)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1" (i32.const 1)
+                                            (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2" (i32.const 2)
+                                            (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3" (i32.const 3)
+                                            (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4" (i32.const 4)
+                                            (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5" (i32.const 5)
+                                            (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6" (i32.const 6)
+                                            (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                            (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7" (i32.const 7)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                            (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8" (i32.const 8)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                            (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9" (i32.const 9)
+                                            (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                            (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10" (i32.const 10)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                             (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11" (i32.const 11)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                             (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12" (i32.const 12)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                             (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13" (i32.const 13)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                             (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14" (i32.const 14)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                             (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15" (i32.const 15)
+                                             (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                             (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_offset_0" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_offset_1" (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_offset_2" (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_offset_3" (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_offset_4" (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_offset_5" (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_offset_6" (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                     (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_offset_7" (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                     (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_offset_8" (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                     (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_offset_9" (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                     (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_offset_10" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                       (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_offset_11" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                       (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_offset_12" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                       (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_offset_13" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                       (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_offset_14" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                       (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_offset_15" (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                       (i64.const 15))
+(assert_return (invoke "v128.store8_lane_0_align_1" (i32.const 0)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 0))
+(assert_return (invoke "v128.store8_lane_1_align_1" (i32.const 1)
+                                                    (v128.const i8x16 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 1))
+(assert_return (invoke "v128.store8_lane_2_align_1" (i32.const 2)
+                                                    (v128.const i8x16 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 2))
+(assert_return (invoke "v128.store8_lane_3_align_1" (i32.const 3)
+                                                    (v128.const i8x16 0 0 0 3 0 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 3))
+(assert_return (invoke "v128.store8_lane_4_align_1" (i32.const 4)
+                                                    (v128.const i8x16 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 4))
+(assert_return (invoke "v128.store8_lane_5_align_1" (i32.const 5)
+                                                    (v128.const i8x16 0 0 0 0 0 5 0 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 5))
+(assert_return (invoke "v128.store8_lane_6_align_1" (i32.const 6)
+                                                    (v128.const i8x16 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0))
+                                                    (i64.const 6))
+(assert_return (invoke "v128.store8_lane_7_align_1" (i32.const 7)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 7 0 0 0 0 0 0 0 0))
+                                                    (i64.const 7))
+(assert_return (invoke "v128.store8_lane_8_align_1" (i32.const 8)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 8 0 0 0 0 0 0 0))
+                                                    (i64.const 8))
+(assert_return (invoke "v128.store8_lane_9_align_1" (i32.const 9)
+                                                    (v128.const i8x16 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0))
+                                                    (i64.const 9))
+(assert_return (invoke "v128.store8_lane_10_align_1" (i32.const 10)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 10 0 0 0 0 0))
+                                                     (i64.const 10))
+(assert_return (invoke "v128.store8_lane_11_align_1" (i32.const 11)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 11 0 0 0 0))
+                                                     (i64.const 11))
+(assert_return (invoke "v128.store8_lane_12_align_1" (i32.const 12)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 12 0 0 0))
+                                                     (i64.const 12))
+(assert_return (invoke "v128.store8_lane_13_align_1" (i32.const 13)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 13 0 0))
+                                                     (i64.const 13))
+(assert_return (invoke "v128.store8_lane_14_align_1" (i32.const 14)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 14 0))
+                                                     (i64.const 14))
+(assert_return (invoke "v128.store8_lane_15_align_1" (i32.const 15)
+                                                     (v128.const i8x16 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 15))
+                                                     (i64.const 15))
+
+;; type check
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 0 (local.get $x) (i32.const 0))))
+  "type mismatch")
+
+;; invalid lane index
+(assert_invalid  (module (memory 1)
+          (func (param $x v128) (result v128)
+            (v128.store8_lane 16 (i32.const 0) (local.get $x))))
+  "invalid lane index")
+
+;; invalid memarg alignment
+(assert_invalid
+  (module (memory 1)
+          (func (param $x v128) (result v128)
+          (v128.store8_lane align=2 0 (i32.const 0) (local.get $x))))
+  "alignment must not be larger than natural")
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call.wast
new file mode 100644
index 0000000..2f91f4d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call.wast
@@ -0,0 +1,202 @@
+;; Test `return_call` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $const-i32 (result i32) (i32.const 0x132))
+  (func $const-i64 (result i64) (i64.const 0x164))
+  (func $const-f32 (result f32) (f32.const 0xf32))
+  (func $const-f64 (result f64) (f64.const 0xf64))
+
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32) (return_call $const-i32))
+  (func (export "type-i64") (result i64) (return_call $const-i64))
+  (func (export "type-f32") (result f32) (return_call $const-f32))
+  (func (export "type-f64") (result f64) (return_call $const-f64))
+
+  (func (export "type-first-i32") (result i32) (return_call $id-i32 (i32.const 32)))
+  (func (export "type-first-i64") (result i64) (return_call $id-i64 (i64.const 64)))
+  (func (export "type-first-f32") (result f32) (return_call $id-f32 (f32.const 1.32)))
+  (func (export "type-first-f64") (result f64) (return_call $id-f64 (f64.const 1.64)))
+
+  (func (export "type-second-i32") (result i32)
+    (return_call $f32-i32 (f32.const 32.1) (i32.const 32))
+  )
+  (func (export "type-second-i64") (result i64)
+    (return_call $i32-i64 (i32.const 32) (i64.const 64))
+  )
+  (func (export "type-second-f32") (result f32)
+    (return_call $f64-f32 (f64.const 64) (f32.const 32))
+  )
+  (func (export "type-second-f64") (result f64)
+    (return_call $i64-f64 (i64.const 64) (f64.const 64.1))
+  )
+
+  ;; Recursion
+
+  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (return_call $fac-acc
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+        )
+      )
+    )
+  )
+
+  (func $count (export "count") (param i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 0))
+      (else (return_call $count (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+
+  (func $even (export "even") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 44))
+      (else (return_call $odd (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+  (func $odd (export "odd") (param i64) (result i32)
+    (if (result i32) (i64.eqz (local.get 0))
+      (then (i32.const 99))
+      (else (return_call $even (i64.sub (local.get 0) (i64.const 1))))
+    )
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
+(assert_return
+  (invoke "fac-acc" (i64.const 25) (i64.const 1))
+  (i64.const 7034535277573963776)
+)
+
+(assert_return (invoke "count" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1000)) (i64.const 0))
+(assert_return (invoke "count" (i64.const 1_000_000)) (i64.const 0))
+
+(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
+(assert_return (invoke "even" (i64.const 1_000_000)) (i32.const 44))
+(assert_return (invoke "even" (i64.const 1_000_001)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
+(assert_return (invoke "odd" (i64.const 1_000_000)) (i32.const 99))
+(assert_return (invoke "odd" (i64.const 999_999)) (i32.const 44))
+
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (func $type-void-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func)
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-num-vs-num (result i32) (return_call 1) (i32.const 0))
+    (func (result i64) (i64.const 1))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (func $arity-0-vs-1 (return_call 1))
+    (func (param i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $arity-0-vs-2 (return_call 1))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+(module
+  (func $arity-1-vs-0 (i32.const 1) (return_call 1))
+  (func)
+)
+
+(module
+  (func $arity-2-vs-0 (f64.const 2) (i32.const 1) (return_call 1))
+  (func)
+)
+
+(assert_invalid
+  (module
+    (func $type-first-void-vs-num (return_call 1 (nop) (i32.const 1)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-void-vs-num (return_call 1 (i32.const 1) (nop)))
+    (func (param i32 i32))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-first-num-vs-num (return_call 1 (f64.const 1) (i32.const 1)))
+    (func (param i32 f64))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-second-num-vs-num (return_call 1 (i32.const 1) (f64.const 1)))
+    (func (param f64 i32))
+  )
+  "type mismatch"
+)
+
+
+;; Unbound function
+
+(assert_invalid
+  (module (func $unbound-func (return_call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $large-func (return_call 1012321300)))
+  "unknown function"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call_indirect.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call_indirect.wast
new file mode 100644
index 0000000..acf0a72
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/tail-call/return_call_indirect.wast
@@ -0,0 +1,536 @@
+;; Test `return_call_indirect` operator
+
+(module
+  ;; Auxiliary definitions
+  (type $proc (func))
+  (type $out-i32 (func (result i32)))
+  (type $out-i64 (func (result i64)))
+  (type $out-f32 (func (result f32)))
+  (type $out-f64 (func (result f64)))
+  (type $over-i32 (func (param i32) (result i32)))
+  (type $over-i64 (func (param i64) (result i64)))
+  (type $over-f32 (func (param f32) (result f32)))
+  (type $over-f64 (func (param f64) (result f64)))
+  (type $f32-i32 (func (param f32 i32) (result i32)))
+  (type $i32-i64 (func (param i32 i64) (result i64)))
+  (type $f64-f32 (func (param f64 f32) (result f32)))
+  (type $i64-f64 (func (param i64 f64) (result f64)))
+  (type $over-i32-duplicate (func (param i32) (result i32)))
+  (type $over-i64-duplicate (func (param i64) (result i64)))
+  (type $over-f32-duplicate (func (param f32) (result f32)))
+  (type $over-f64-duplicate (func (param f64) (result f64)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+  (func $const-i64 (type $out-i64) (i64.const 0x164))
+  (func $const-f32 (type $out-f32) (f32.const 0xf32))
+  (func $const-f64 (type $out-f64) (f64.const 0xf64))
+
+  (func $id-i32 (type $over-i32) (local.get 0))
+  (func $id-i64 (type $over-i64) (local.get 0))
+  (func $id-f32 (type $over-f32) (local.get 0))
+  (func $id-f64 (type $over-f64) (local.get 0))
+
+  (func $i32-i64 (type $i32-i64) (local.get 1))
+  (func $i64-f64 (type $i64-f64) (local.get 1))
+  (func $f32-i32 (type $f32-i32) (local.get 1))
+  (func $f64-f32 (type $f64-f32) (local.get 1))
+
+  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
+  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
+  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
+  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
+
+  (table funcref
+    (elem
+      $const-i32 $const-i64 $const-f32 $const-f64
+      $id-i32 $id-i64 $id-f32 $id-f64
+      $f32-i32 $i32-i64 $f64-f32 $i64-f64
+      $fac $fac-acc $even $odd
+      $over-i32-duplicate $over-i64-duplicate
+      $over-f32-duplicate $over-f64-duplicate
+    )
+  )
+
+  ;; Syntax
+
+  (func
+    (return_call_indirect (i32.const 0))
+    (return_call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (return_call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (return_call_indirect (result) (i32.const 0))
+  )
+
+  (func (result i32)
+    (return_call_indirect (result i32) (i32.const 0))
+    (return_call_indirect (result i32) (result) (i32.const 0))
+    (return_call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    (return_call_indirect
+      (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+      (result) (result i32) (result) (result)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+  )
+
+  (func (result i64)
+    (return_call_indirect (type $over-i64) (param i64) (result i64)
+      (i64.const 0) (i32.const 0)
+    )
+  )
+
+  ;; Typing
+
+  (func (export "type-i32") (result i32)
+    (return_call_indirect (type $out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (return_call_indirect (type $out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (return_call_indirect (type $out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (return_call_indirect (type $out-f64) (i32.const 3))
+  )
+
+  (func (export "type-index") (result i64)
+    (return_call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
+  )
+
+  (func (export "type-first-i32") (result i32)
+    (return_call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
+  )
+  (func (export "type-first-i64") (result i64)
+    (return_call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
+  )
+  (func (export "type-first-f32") (result f32)
+    (return_call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
+  )
+  (func (export "type-first-f64") (result f64)
+    (return_call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
+  )
+
+  (func (export "type-second-i32") (result i32)
+    (return_call_indirect (type $f32-i32)
+      (f32.const 32.1) (i32.const 32) (i32.const 8)
+    )
+  )
+  (func (export "type-second-i64") (result i64)
+    (return_call_indirect (type $i32-i64)
+      (i32.const 32) (i64.const 64) (i32.const 9)
+    )
+  )
+  (func (export "type-second-f32") (result f32)
+    (return_call_indirect (type $f64-f32)
+      (f64.const 64) (f32.const 32) (i32.const 10)
+    )
+  )
+  (func (export "type-second-f64") (result f64)
+    (return_call_indirect (type $i64-f64)
+      (i64.const 64) (f64.const 64.1) (i32.const 11)
+    )
+  )
+
+  ;; Dispatch
+
+  (func (export "dispatch") (param i32 i64) (result i64)
+    (return_call_indirect (type $over-i64) (local.get 1) (local.get 0))
+  )
+
+  (func (export "dispatch-structural") (param i32) (result i64)
+    (return_call_indirect (type $over-i64-duplicate)
+      (i64.const 9) (local.get 0)
+    )
+  )
+
+  ;; Multiple tables
+
+  (table $tab2 funcref (elem $tab-f1))
+  (table $tab3 funcref (elem $tab-f2))
+
+  (func $tab-f1 (result i32) (i32.const 0x133))
+  (func $tab-f2 (result i32) (i32.const 0x134))
+
+  (func (export "call-tab") (param $i i32) (result i32)
+    (if (i32.eq (local.get $i) (i32.const 0))
+      (then (return_call_indirect (type $out-i32) (i32.const 0)))
+    )
+    (if (i32.eq (local.get $i) (i32.const 1))
+      (then (return_call_indirect 1 (type $out-i32) (i32.const 0)))
+    )
+    (if (i32.eq (local.get $i) (i32.const 2))
+      (then (return_call_indirect $tab3 (type $out-i32) (i32.const 0)))
+    )
+    (i32.const 0)
+  )
+
+  ;; Recursion
+
+  (func $fac (export "fac") (type $over-i64)
+    (return_call_indirect (param i64 i64) (result i64)
+      (local.get 0) (i64.const 1) (i32.const 13)
+    )
+  )
+
+  (func $fac-acc (param i64 i64) (result i64)
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
+      (else
+        (return_call_indirect (param i64 i64) (result i64)
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
+          (i32.const 13)
+        )
+      )
+    )
+  )
+
+  (func $even (export "even") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 44))
+      (else
+        (return_call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 15)
+        )
+      )
+    )
+  )
+  (func $odd (export "odd") (param i32) (result i32)
+    (if (result i32) (i32.eqz (local.get 0))
+      (then (i32.const 99))
+      (else
+        (return_call_indirect (type $over-i32)
+          (i32.sub (local.get 0) (i32.const 1))
+          (i32.const 14)
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-i32") (i32.const 0x132))
+(assert_return (invoke "type-i64") (i64.const 0x164))
+(assert_return (invoke "type-f32") (f32.const 0xf32))
+(assert_return (invoke "type-f64") (f64.const 0xf64))
+
+(assert_return (invoke "type-index") (i64.const 100))
+
+(assert_return (invoke "type-first-i32") (i32.const 32))
+(assert_return (invoke "type-first-i64") (i64.const 64))
+(assert_return (invoke "type-first-f32") (f32.const 1.32))
+(assert_return (invoke "type-first-f64") (f64.const 1.64))
+
+(assert_return (invoke "type-second-i32") (i32.const 32))
+(assert_return (invoke "type-second-i64") (i64.const 64))
+(assert_return (invoke "type-second-f32") (f32.const 32))
+(assert_return (invoke "type-second-f64") (f64.const 64.1))
+
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
+(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
+(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
+(assert_return (invoke "dispatch" (i32.const 17) (i64.const 2)) (i64.const 2))
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 20) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
+
+(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880))
+(assert_return (invoke "dispatch-structural" (i32.const 17)) (i64.const 9))
+(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural" (i32.const 16)) "indirect call type mismatch")
+
+(assert_return (invoke "call-tab" (i32.const 0)) (i32.const 0x132))
+(assert_return (invoke "call-tab" (i32.const 1)) (i32.const 0x133))
+(assert_return (invoke "call-tab" (i32.const 2)) (i32.const 0x134))
+
+(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
+(assert_return (invoke "even" (i32.const 100_000)) (i32.const 44))
+(assert_return (invoke "even" (i32.const 111_111)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
+(assert_return (invoke "odd" (i32.const 200_002)) (i32.const 99))
+(assert_return (invoke "odd" (i32.const 300_003)) (i32.const 44))
+
+
+;; Invalid syntax
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (param i32) (type $sig) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (param i32) (result i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (param i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(table 0 funcref)"
+    "(func (return_call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func"
+    "  (return_call_indirect (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(table 0 funcref)"
+    "(func (result i32)"
+    "  (return_call_indirect (type $sig) (param i32) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+
+;; Invalid typing
+
+(assert_invalid
+  (module
+    (type (func))
+    (func $no-table (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "unknown table"
+)
+
+(assert_invalid
+  (module
+    (type (func))
+    (table 0 funcref)
+    (func $type-void-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (result i64)))
+    (table 0 funcref)
+    (func $type-num-vs-num (i32.eqz (return_call_indirect (type 0) (i32.const 0))))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-1 (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $arity-0-vs-2 (return_call_indirect (type 0) (i32.const 0)))
+  )
+  "type mismatch"
+)
+
+(module
+  (type (func))
+  (table 0 funcref)
+  (func $arity-1-vs-0 (return_call_indirect (type 0) (i32.const 1) (i32.const 0)))
+)
+
+(module
+  (type (func))
+  (table 0 funcref)
+  (func $arity-2-vs-0
+    (return_call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
+  )
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-void-vs-i32 (return_call_indirect (type 0) (i32.const 1) (nop)))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32)))
+    (table 0 funcref)
+    (func $type-func-num-vs-i32 (return_call_indirect (type 0) (i32.const 0) (i64.const 1)))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-first-void-vs-num
+      (return_call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 i32)))
+    (table 0 funcref)
+    (func $type-second-void-vs-num
+      (return_call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param i32 f64)))
+    (table 0 funcref)
+    (func $type-first-num-vs-num
+      (return_call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type (func (param f64 i32)))
+    (table 0 funcref)
+    (func $type-second-num-vs-num
+      (return_call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Unbound type
+
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $unbound-type (return_call_indirect (type 1) (i32.const 0)))
+  )
+  "unknown type"
+)
+(assert_invalid
+  (module
+    (table 0 funcref)
+    (func $large-type (return_call_indirect (type 1012321300) (i32.const 0)))
+  )
+  "unknown type"
+)
+
+
+;; Unbound function in table
+
+(assert_invalid
+  (module (table funcref (elem 0 0)))
+  "unknown function 0"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/atomic.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/atomic.wast
new file mode 100644
index 0000000..9f3cd65
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/atomic.wast
@@ -0,0 +1,539 @@
+;; atomic operations
+
+(module
+  (memory 1 1 shared)
+
+  (func (export "init") (param $value i64) (i64.store (i32.const 0) (local.get $value)))
+
+  (func (export "i32.atomic.load") (param $addr i32) (result i32) (i32.atomic.load (local.get $addr)))
+  (func (export "i64.atomic.load") (param $addr i32) (result i64) (i64.atomic.load (local.get $addr)))
+  (func (export "i32.atomic.load8_u") (param $addr i32) (result i32) (i32.atomic.load8_u (local.get $addr)))
+  (func (export "i32.atomic.load16_u") (param $addr i32) (result i32) (i32.atomic.load16_u (local.get $addr)))
+  (func (export "i64.atomic.load8_u") (param $addr i32) (result i64) (i64.atomic.load8_u (local.get $addr)))
+  (func (export "i64.atomic.load16_u") (param $addr i32) (result i64) (i64.atomic.load16_u (local.get $addr)))
+  (func (export "i64.atomic.load32_u") (param $addr i32) (result i64) (i64.atomic.load32_u (local.get $addr)))
+
+  (func (export "i32.atomic.store") (param $addr i32) (param $value i32) (i32.atomic.store (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.store") (param $addr i32) (param $value i64) (i64.atomic.store (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.store8") (param $addr i32) (param $value i32) (i32.atomic.store8 (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.store16") (param $addr i32) (param $value i32) (i32.atomic.store16 (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.store8") (param $addr i32) (param $value i64) (i64.atomic.store8 (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.store16") (param $addr i32) (param $value i64) (i64.atomic.store16 (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.store32") (param $addr i32) (param $value i64) (i64.atomic.store32 (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.add") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.add (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.add") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.add (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.add_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.add_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.add_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.add_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.add_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.add_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.add_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.sub") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.sub (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.sub") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.sub (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.sub_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.sub_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.sub_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.sub_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.sub_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.sub_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.sub_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.and") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.and (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.and") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.and (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.and_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.and_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.and_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.and_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.and_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.and_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.and_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.or") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.or (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.or") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.or (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.or_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.or_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.or_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.or_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.or_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.or_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.or_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.xor") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xor (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.xor") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xor (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xor_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.xor_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xor_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xor_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xor_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.xor_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xor_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.xchg") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw.xchg (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw.xchg") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw.xchg (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw8.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw8.xchg_u (local.get $addr) (local.get $value)))
+  (func (export "i32.atomic.rmw16.xchg_u") (param $addr i32) (param $value i32) (result i32) (i32.atomic.rmw16.xchg_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw8.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw8.xchg_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw16.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw16.xchg_u (local.get $addr) (local.get $value)))
+  (func (export "i64.atomic.rmw32.xchg_u") (param $addr i32) (param $value i64) (result i64) (i64.atomic.rmw32.xchg_u (local.get $addr) (local.get $value)))
+
+  (func (export "i32.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i32) (param $value i32) (result i32) (i32.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i64.atomic.rmw.cmpxchg") (param $addr i32) (param $expected i64)  (param $value i64) (result i64) (i64.atomic.rmw.cmpxchg (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i32.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i32)  (param $value i32) (result i32) (i32.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i32.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i32)  (param $value i32) (result i32) (i32.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i64.atomic.rmw8.cmpxchg_u") (param $addr i32) (param $expected i64)  (param $value i64) (result i64) (i64.atomic.rmw8.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i64.atomic.rmw16.cmpxchg_u") (param $addr i32) (param $expected i64)  (param $value i64) (result i64) (i64.atomic.rmw16.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value)))
+  (func (export "i64.atomic.rmw32.cmpxchg_u") (param $addr i32) (param $expected i64)  (param $value i64) (result i64) (i64.atomic.rmw32.cmpxchg_u (local.get $addr) (local.get $expected) (local.get $value)))
+
+)
+
+;; *.atomic.load*
+
+(invoke "init" (i64.const 0x0706050403020100))
+
+(assert_return (invoke "i32.atomic.load" (i32.const 0)) (i32.const 0x03020100))
+(assert_return (invoke "i32.atomic.load" (i32.const 4)) (i32.const 0x07060504))
+
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0706050403020100))
+
+(assert_return (invoke "i32.atomic.load8_u" (i32.const 0)) (i32.const 0x00))
+(assert_return (invoke "i32.atomic.load8_u" (i32.const 5)) (i32.const 0x05))
+
+(assert_return (invoke "i32.atomic.load16_u" (i32.const 0)) (i32.const 0x0100))
+(assert_return (invoke "i32.atomic.load16_u" (i32.const 6)) (i32.const 0x0706))
+
+(assert_return (invoke "i64.atomic.load8_u" (i32.const 0)) (i64.const 0x00))
+(assert_return (invoke "i64.atomic.load8_u" (i32.const 5)) (i64.const 0x05))
+
+(assert_return (invoke "i64.atomic.load16_u" (i32.const 0)) (i64.const 0x0100))
+(assert_return (invoke "i64.atomic.load16_u" (i32.const 6)) (i64.const 0x0706))
+
+(assert_return (invoke "i64.atomic.load32_u" (i32.const 0)) (i64.const 0x03020100))
+(assert_return (invoke "i64.atomic.load32_u" (i32.const 4)) (i64.const 0x07060504))
+
+;; *.atomic.store*
+
+(invoke "init" (i64.const 0x0000000000000000))
+
+(assert_return (invoke "i32.atomic.store" (i32.const 0) (i32.const 0xffeeddcc)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x00000000ffeeddcc))
+
+(assert_return (invoke "i64.atomic.store" (i32.const 0) (i64.const 0x0123456789abcdef)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789abcdef))
+
+(assert_return (invoke "i32.atomic.store8" (i32.const 1) (i32.const 0x42)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123456789ab42ef))
+
+(assert_return (invoke "i32.atomic.store16" (i32.const 4) (i32.const 0x8844)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab42ef))
+
+(assert_return (invoke "i64.atomic.store8" (i32.const 1) (i64.const 0x99)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123884489ab99ef))
+
+(assert_return (invoke "i64.atomic.store16" (i32.const 4) (i64.const 0xcafe)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0123cafe89ab99ef))
+
+(assert_return (invoke "i64.atomic.store32" (i32.const 4) (i64.const 0xdeadbeef)))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0xdeadbeef89ab99ef))
+
+;; *.atomic.rmw*.add
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.add" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111123456789))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.add" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1212121213131313))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.add_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111de))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.add_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dc0f))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.add_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.add_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111d000))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.add_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbccb7f6))
+
+;; *.atomic.rmw*.sub
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.sub" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111fedcba99))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.sub" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x101010100f0f0f0f))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.sub_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111144))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.sub_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111114613))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.sub_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cf))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.sub_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111115222))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.sub_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111146556a2c))
+
+;; *.atomic.rmw*.and
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.and" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111110101010))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.and" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010100000000))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.and_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111101))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.and_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111110010))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.and_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111100))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.and_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111001))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.and_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111100110001))
+
+;; *.atomic.rmw*.or
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.or" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113355779))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.or" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111113131313))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.or_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dd))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.or_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbff))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.or_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.or_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111bfff))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.or_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbbbb7f5))
+
+;; *.atomic.rmw*.xor
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.xor" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111103254769))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.xor" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1010101013131313))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.xor_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111dc))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.xor_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111dbef))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.xor_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111153))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.xor_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111affe))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.xor_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111dbaab7f4))
+
+;; *.atomic.rmw*.xchg
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.xchg" (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.xchg" (i32.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.xchg_u" (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.xchg_u" (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.xchg_u" (i32.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.xchg_u" (i32.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.xchg_u" (i32.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5))
+
+;; *.atomic.rmw*.cmpxchg (compare false)
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111111))
+
+;; *.atomic.rmw*.cmpxchg (compare true)
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw.cmpxchg" (i32.const 0) (i32.const 0x11111111) (i32.const 0x12345678)) (i32.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111112345678))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw.cmpxchg" (i32.const 0) (i64.const 0x1111111111111111) (i64.const 0x0101010102020202)) (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x0101010102020202))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw8.cmpxchg_u" (i32.const 0) (i32.const 0x11) (i32.const 0xcdcdcdcd)) (i32.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111111111cd))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 0) (i32.const 0x1111) (i32.const 0xcafecafe)) (i32.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111cafe))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw8.cmpxchg_u" (i32.const 0) (i64.const 0x11) (i64.const 0x4242424242424242)) (i64.const 0x11))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x1111111111111142))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 0) (i64.const 0x1111) (i64.const 0xbeefbeefbeefbeef)) (i64.const 0x1111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x111111111111beef))
+
+(invoke "init" (i64.const 0x1111111111111111))
+(assert_return (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 0) (i64.const 0x11111111) (i64.const 0xcabba6e5cabba6e5)) (i64.const 0x11111111))
+(assert_return (invoke "i64.atomic.load" (i32.const 0)) (i64.const 0x11111111cabba6e5))
+
+
+;; unaligned accesses
+
+(assert_trap (invoke "i32.atomic.load" (i32.const 1)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.load" (i32.const 1)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.load16_u" (i32.const 1)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.load16_u" (i32.const 1)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.load32_u" (i32.const 1)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.store" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.store" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.store16" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.store16" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.store32" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.add" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.add" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.add_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.add_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.sub" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.sub" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.sub_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.sub_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.and" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.and" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.and_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.and_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.or" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.or" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.or_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.or_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.xor" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.xor" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.xor_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.xor_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.xchg" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.xchg" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.xchg_u" (i32.const 1) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.xchg_u" (i32.const 1) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw.cmpxchg" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw.cmpxchg" (i32.const 1) (i64.const 0)  (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i32.atomic.rmw16.cmpxchg_u" (i32.const 1) (i32.const 0) (i32.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw16.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic")
+(assert_trap (invoke "i64.atomic.rmw32.cmpxchg_u" (i32.const 1) (i64.const 0) (i64.const 0)) "unaligned atomic")
+
+(module
+  (memory 1 1 shared)
+
+  (func (export "init") (param $value i64) (i64.store (i32.const 0) (local.get $value)))
+
+  (func (export "memory.atomic.notify") (param $addr i32) (param $count i32) (result i32)
+      (memory.atomic.notify (local.get 0) (local.get 1)))
+  (func (export "memory.atomic.wait32") (param $addr i32) (param $expected i32) (param $timeout i64) (result i32)
+      (memory.atomic.wait32 (local.get 0) (local.get 1) (local.get 2)))
+  (func (export "memory.atomic.wait64") (param $addr i32) (param $expected i64) (param $timeout i64) (result i32)
+      (memory.atomic.wait64 (local.get 0) (local.get 1) (local.get 2)))
+)
+
+(invoke "init" (i64.const 0xffffffffffff))
+(assert_return (invoke "memory.atomic.wait32" (i32.const 0) (i32.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "memory.atomic.wait64" (i32.const 0) (i64.const 0) (i64.const 0)) (i32.const 1))
+(assert_return (invoke "memory.atomic.notify" (i32.const 0) (i32.const 0)) (i32.const 0))
+
+;; unshared memory is OK
+(module
+  (memory 1 1)
+  (func (drop (memory.atomic.notify (i32.const 0) (i32.const 0))))
+  (func (drop (memory.atomic.wait32 (i32.const 0) (i32.const 0) (i64.const 0))))
+  (func (drop (memory.atomic.wait64 (i32.const 0) (i64.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.load (i32.const 0))))
+  (func (drop (i64.atomic.load (i32.const 0))))
+  (func (drop (i32.atomic.load16_u (i32.const 0))))
+  (func (drop (i64.atomic.load16_u (i32.const 0))))
+  (func (drop (i64.atomic.load32_u (i32.const 0))))
+  (func       (i32.atomic.store (i32.const 0) (i32.const 0)))
+  (func       (i64.atomic.store (i32.const 0) (i64.const 0)))
+  (func       (i32.atomic.store16 (i32.const 0) (i32.const 0)))
+  (func       (i64.atomic.store16 (i32.const 0) (i64.const 0)))
+  (func       (i64.atomic.store32 (i32.const 0) (i64.const 0)))
+  (func (drop (i32.atomic.rmw.add (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.add (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.add_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.add_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.add_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.sub (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.sub (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.sub_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.sub_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.sub_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.and (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.and (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.and_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.and_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.and_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.or (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.or (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.or_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.or_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.or_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.xor (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.xor (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.xor_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.xor_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.xor_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.xchg (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.xchg (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.xchg_u (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.xchg_u (i32.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.xchg_u (i32.const 0) (i64.const 0))))
+  (func (drop (i32.atomic.rmw.cmpxchg (i32.const 0) (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw.cmpxchg (i32.const 0) (i64.const 0)  (i64.const 0))))
+  (func (drop (i32.atomic.rmw16.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0))))
+  (func (drop (i64.atomic.rmw16.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))
+  (func (drop (i64.atomic.rmw32.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))
+)
+
+;; Fails with no memory
+(assert_invalid (module (func (drop (memory.atomic.notify (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (memory.atomic.wait32 (i32.const 0) (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (memory.atomic.wait64 (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.load (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.load (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.load16_u (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.load16_u (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.load32_u (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func       (i32.atomic.store (i32.const 0) (i32.const 0)))) "unknown memory")
+(assert_invalid (module (func       (i64.atomic.store (i32.const 0) (i64.const 0)))) "unknown memory")
+(assert_invalid (module (func       (i32.atomic.store16 (i32.const 0) (i32.const 0)))) "unknown memory")
+(assert_invalid (module (func       (i64.atomic.store16 (i32.const 0) (i64.const 0)))) "unknown memory")
+(assert_invalid (module (func       (i64.atomic.store32 (i32.const 0) (i64.const 0)))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.add (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.add (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.add_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.add_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.add_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.sub (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.sub (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.sub_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.sub_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.sub_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.and (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.and (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.and_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.and_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.and_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.or (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.or (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.or_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.or_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.or_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.xor (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.xor (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.xor_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.xor_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.xor_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.xchg (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.xchg (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.xchg_u (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.xchg_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.xchg_u (i32.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw.cmpxchg (i32.const 0) (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw.cmpxchg (i32.const 0) (i64.const 0)  (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i32.atomic.rmw16.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw16.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory")
+(assert_invalid (module (func (drop (i64.atomic.rmw32.cmpxchg_u (i32.const 0) (i64.const 0) (i64.const 0))))) "unknown memory")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/exports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/exports.wast
new file mode 100644
index 0000000..4a34734
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/exports.wast
@@ -0,0 +1,205 @@
+;; Functions
+
+(module (func) (export "a" (func 0)))
+(module (func) (export "a" (func 0)) (export "b" (func 0)))
+(module (func) (func) (export "a" (func 0)) (export "b" (func 1)))
+
+(module (func (export "a")))
+(module (func (export "a") (export "b") (export "c")))
+(module (func (export "a") (export "b") (param i32)))
+(module (func) (export "a" (func 0)))
+(module (func $a (export "a")))
+(module (func $a) (export "a" (func $a)))
+(module (export "a" (func 0)) (func))
+(module (export "a" (func $a)) (func $a))
+
+(module $Func
+  (export "e" (func $f))
+  (func $f (param $n i32) (result i32)
+    (return (i32.add (local.get $n) (i32.const 1)))
+  )
+)
+(assert_return (invoke "e" (i32.const 42)) (i32.const 43))
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+(module)
+(module $Other1)
+(assert_return (invoke $Func "e" (i32.const 42)) (i32.const 43))
+
+(assert_invalid
+  (module (func) (export "a" (func 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func) (export "a" (func 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (func) (export "a" (func 0)) (export "a" (func 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (global i32 (i32.const 0)) (export "a" (func 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Globals
+
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 0)))
+(module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "b" (global 1)))
+
+(module (global (export "a") i32 (i32.const 0)))
+(module (global i32 (i32.const 0)) (export "a" (global 0)))
+(module (global $a (export "a") i32 (i32.const 0)))
+(module (global $a i32 (i32.const 0)) (export "a" (global $a)))
+(module (export "a" (global 0)) (global i32 (i32.const 0)))
+(module (export "a" (global $a)) (global $a i32 (i32.const 0)))
+
+(module $Global
+  (export "e" (global $g))
+  (global $g i32 (i32.const 42))
+)
+(assert_return (get "e") (i32.const 42))
+(assert_return (get $Global "e") (i32.const 42))
+(module)
+(module $Other2)
+(assert_return (get $Global "e") (i32.const 42))
+
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 1)))
+  "unknown global"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (global i32 (i32.const 0)) (export "a" (global 0)) (export "a" (global 1)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (func) (export "a" (global 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (global i32 (i32.const 0)) (memory 0) (export "a" (global 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Tables
+
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0)))
+;; No multiple tables yet.
+;; (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1)))
+
+(module (table (export "a") 0 funcref))
+(module (table (export "a") 0 1 funcref))
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 1 funcref) (export "a" (table 0)))
+(module (table $a (export "a") 0 funcref))
+(module (table $a (export "a") 0 1 funcref))
+(module (table $a 0 funcref) (export "a" (table $a)))
+(module (table $a 0 1 funcref) (export "a" (table $a)))
+(module (export "a" (table 0)) (table 0 funcref))
+(module (export "a" (table 0)) (table 0 1 funcref))
+(module (export "a" (table $a)) (table $a 0 funcref))
+(module (export "a" (table $a)) (table $a 0 1 funcref))
+
+(; TODO: access table ;)
+
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 1)))
+  "unknown table"
+)
+(assert_invalid
+  (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
+;; No multiple tables yet.
+;; (assert_invalid
+;;   (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1)))
+;;   "duplicate export name"
+;; )
+(assert_invalid
+  (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+
+
+;; Memories
+
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0) (export "a" (memory 0)) (export "b" (memory 0)))
+;; No multiple memories yet.
+;; (module (memory 0) (memory 0) (export "a" (memory 0)) (export "b" (memory 1)))
+
+(module (memory (export "a") 0))
+(module (memory (export "a") 0 1))
+(module (memory 0) (export "a" (memory 0)))
+(module (memory 0 1) (export "a" (memory 0)))
+(module (memory $a (export "a") 0))
+(module (memory $a (export "a") 0 1))
+(module (memory $a 0) (export "a" (memory $a)))
+(module (memory $a 0 1) (export "a" (memory $a)))
+(module (export "a" (memory 0)) (memory 0))
+(module (export "a" (memory 0)) (memory 0 1))
+(module (export "a" (memory $a)) (memory $a 0))
+(module (export "a" (memory $a)) (memory $a 0 1))
+
+(module (memory (export "a") 0 1 shared))
+(module (memory 0 1 shared) (export "a" (memory 0)))
+(module (memory $a (export "a") 0 1 shared))
+(module (memory $a 0 1 shared) (export "a" (memory $a)))
+(module (export "a" (memory 0)) (memory 0 1 shared))
+(module (export "a" (memory $a)) (memory $a 0 1 shared))
+
+(; TODO: access memory ;)
+
+(assert_invalid
+  (module (memory 0) (export "a" (memory 1)))
+  "unknown memory"
+)
+(assert_invalid
+  (module (memory 0) (export "a" (memory 0)) (export "a" (memory 0)))
+  "duplicate export name"
+)
+;; No multiple memories yet.
+;; (assert_invalid
+;;   (module (memory 0) (memory 0) (export "a" (memory 0)) (export "a" (memory 1)))
+;;   "duplicate export name"
+;; )
+(assert_invalid
+  (module (memory 0) (func) (export "a" (memory 0)) (export "a" (func 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (global i32 (i32.const 0)) (export "a" (memory 0)) (export "a" (global 0)))
+  "duplicate export name"
+)
+(assert_invalid
+  (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0)))
+  "duplicate export name"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/imports.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/imports.wast
new file mode 100644
index 0000000..4567171
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/imports.wast
@@ -0,0 +1,605 @@
+;; Auxiliary module to import from
+
+(module
+  (func (export "func"))
+  (func (export "func-i32") (param i32))
+  (func (export "func-f32") (param f32))
+  (func (export "func->i32") (result i32) (i32.const 22))
+  (func (export "func->f32") (result f32) (f32.const 11))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
+  (global (export "global-i32") i32 (i32.const 55))
+  (global (export "global-f32") f32 (f32.const 44))
+  (table (export "table-10-inf") 10 funcref)
+  ;; (table (export "table-10-20") 10 20 funcref)
+  (memory (export "memory-2-inf") 2)
+  ;; (memory (export "memory-2-4") 2 4)
+)
+
+(register "test")
+
+
+;; Functions
+
+(module
+  (type $func_i32 (func (param i32)))
+  (type $func_i64 (func (param i64)))
+  (type $func_f32 (func (param f32)))
+  (type $func_f64 (func (param f64)))
+
+  (import "spectest" "print_i32" (func (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
+  (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
+
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
+
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
+  (type $forward (func (param i32)))
+
+  (table funcref (elem $print_i32 $print_f64))
+
+  (func (export "print32") (param $i i32)
+    (local $x f32)
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
+    (call $print_i32_f32
+      (i32.add (local.get $i) (i32.const 1))
+      (f32.const 42)
+    )
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
+  )
+
+  (func (export "print64") (param $i i64)
+    (local $x f64)
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
+    ;; JavaScript can't handle i64 yet.
+    ;; (call 1 (local.get $i))
+    (call $print_f64_f64
+      (f64.add (local.get $x) (f64.const 1))
+      (f64.const 53)
+    )
+    ;; JavaScript can't handle i64 yet.
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
+  )
+)
+
+(assert_return (invoke "print32" (i32.const 13)))
+(assert_return (invoke "print64" (i64.const 24)))
+
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
+(module (import "test" "func" (func)))
+(module (import "test" "func-i32" (func (param i32))))
+(module (import "test" "func-f32" (func (param f32))))
+(module (import "test" "func->i32" (func (result i32))))
+(module (import "test" "func->f32" (func (result f32))))
+(module (import "test" "func-i32->i32" (func (param i32) (result i32))))
+(module (import "test" "func-i64->i64" (func (param i64) (result i64))))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (func)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (func)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result f32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (result i64))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func->i32" (func (param i32) (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (param i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "func-i32->i32" (func (result i32))))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "global-i32" (func (result i32))))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (func)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (func)))
+  "incompatible import type"
+)
+
+
+;; Globals
+
+(module
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
+
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
+
+  ;; JavaScript can't handle i64 yet.
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
+
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
+)
+
+(assert_return (invoke "get-0") (i32.const 666))
+(assert_return (invoke "get-1") (i32.const 666))
+(assert_return (invoke "get-x") (i32.const 666))
+(assert_return (invoke "get-y") (i32.const 666))
+
+(module (import "test" "global-i32" (global i32)))
+(module (import "test" "global-f32" (global f32)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (global i32)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (global i32)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (global i32)))
+  "incompatible import type"
+)
+
+
+;; Tables
+
+(module
+  (type (func (result i32)))
+  (import "spectest" "table" (table 10 20 funcref))
+  (elem 0 (i32.const 1) $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+
+(module
+  (type (func (result i32)))
+  (table (import "spectest" "table") 10 20 funcref)
+  (elem 0 (i32.const 1) $f $g)
+
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (local.get 0))
+  )
+  (func $f (result i32) (i32.const 11))
+  (func $g (result i32) (i32.const 22))
+)
+
+(assert_trap (invoke "call" (i32.const 0)) "uninitialized element")
+(assert_return (invoke "call" (i32.const 1)) (i32.const 11))
+(assert_return (invoke "call" (i32.const 2)) (i32.const 22))
+(assert_trap (invoke "call" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "call" (i32.const 100)) "undefined element")
+
+;; No multiple table yet.
+;;(assert_invalid
+;;  (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref)))
+;;  "multiple tables"
+;;)
+;;(assert_invalid
+;;  (module (import "" "" (table 10 funcref)) (table 10 funcref))
+;;  "multiple tables"
+;;)
+;;(assert_invalid
+;;  (module (table 10 funcref) (table 10 funcref))
+;;  "multiple tables"
+;;)
+
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (table 10 funcref)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 12 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (table 10 15 funcref)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (table 10 funcref)))
+  "incompatible import type"
+)
+
+
+
+;; Memories
+
+(module
+  (import "spectest" "memory" (memory 1 2))
+  (data 0 (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(module
+  (memory (import "spectest" "memory") 1 2)
+  (data 0 (i32.const 10) "\10")
+
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
+)
+(assert_return (invoke "load" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "load" (i32.const 10)) (i32.const 16))
+(assert_return (invoke "load" (i32.const 8)) (i32.const 0x100000))
+(assert_trap (invoke "load" (i32.const 1000000)) "out of bounds memory access")
+
+(assert_invalid
+  (module (import "" "" (memory 1)) (import "" "" (memory 1)))
+  "multiple memories"
+)
+(assert_invalid
+  (module (import "" "" (memory 1)) (memory 0))
+  "multiple memories"
+)
+(assert_invalid
+  (module (memory 0) (memory 0))
+  "multiple memories"
+)
+
+(module (import "test" "memory-2-inf" (memory 2)))
+(module (import "test" "memory-2-inf" (memory 1)))
+(module (import "test" "memory-2-inf" (memory 0)))
+(module (import "spectest" "memory" (memory 1)))
+(module (import "spectest" "memory" (memory 0)))
+(module (import "spectest" "memory" (memory 1 2)))
+(module (import "spectest" "memory" (memory 0 2)))
+(module (import "spectest" "memory" (memory 1 3)))
+(module (import "spectest" "memory" (memory 0 3)))
+
+(assert_unlinkable
+  (module (import "test" "unknown" (memory 1)))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (import "spectest" "unknown" (memory 1)))
+  "unknown import"
+)
+
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "memory-2-inf" (memory 2 3)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "test" "func-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "global-i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "test" "table-10-inf" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "print_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "global_i32" (memory 1)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "table" (memory 1)))
+  "incompatible import type"
+)
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 2)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 1)))
+  "incompatible import type"
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
+)
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+;; Shared Memory
+
+(module (import "spectest" "shared_memory" (memory 1 2 shared)))
+
+(assert_unlinkable
+  (module (import "spectest" "shared_memory" (memory 1 2)))
+  "incompatible import type")
+
+(assert_unlinkable
+  (module (import "spectest" "memory" (memory 1 2 shared)))
+  "incompatible import type")
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(module)
+(register "not wasm")
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 funcref))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/memory.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/memory.wast
new file mode 100644
index 0000000..e10c349
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/proposals/threads/memory.wast
@@ -0,0 +1,246 @@
+;; Test memory section structure
+
+(module (memory 0))
+(module (memory 1))
+(module (memory 0 0))
+(module (memory 0 1))
+(module (memory 1 256))
+(module (memory 0 65536))
+(module (memory 0 0 shared))
+(module (memory 1 2 shared))
+
+(assert_invalid (module (memory 1 shared)) "shared memory must have maximum")
+
+(assert_invalid (module (memory 0) (memory 0)) "multiple memories")
+(assert_invalid (module (memory (import "spectest" "memory") 0) (memory 0)) "multiple memories")
+
+(module (memory (data)) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 0))
+(module (memory (data "")) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 0))
+(module (memory (data "x")) (func (export "memsize") (result i32) (memory.size)))
+(assert_return (invoke "memsize") (i32.const 1))
+
+(assert_invalid (module (data (i32.const 0))) "unknown memory")
+(assert_invalid (module (data (i32.const 0) "")) "unknown memory")
+(assert_invalid (module (data (i32.const 0) "x")) "unknown memory")
+
+(assert_invalid
+  (module (func (drop (f32.load (i32.const 0)))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (f32.store (i32.const 0) (f32.const 0))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (i32.load8_s (i32.const 0)))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (i32.store8 (i32.const 0) (i32.const 0))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (memory.size))))
+  "unknown memory"
+)
+(assert_invalid
+  (module (func (drop (memory.grow (i32.const 0)))))
+  "unknown memory"
+)
+
+
+(assert_invalid
+  (module (memory 1 0))
+  "size minimum must not be greater than maximum"
+)
+(assert_invalid
+  (module (memory 65537))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 2147483648))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 4294967295))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 65537))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 2147483648))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+(assert_invalid
+  (module (memory 0 4294967295))
+  "memory size must be at most 65536 pages (4GiB)"
+)
+
+(assert_malformed
+  (module quote "(memory 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(memory 0x1_0000_0000 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(memory 0 0x1_0000_0000)")
+  "i32 constant out of range"
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "ABC\a7D") (data (i32.const 20) "WASM")
+
+  ;; Data section
+  (func (export "data") (result i32)
+    (i32.and
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 0)) (i32.const 65))
+          (i32.eq (i32.load8_u (i32.const 3)) (i32.const 167))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 6)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 19)) (i32.const 0))
+        )
+      )
+      (i32.and
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 20)) (i32.const 87))
+          (i32.eq (i32.load8_u (i32.const 23)) (i32.const 77))
+        )
+        (i32.and
+          (i32.eq (i32.load8_u (i32.const 24)) (i32.const 0))
+          (i32.eq (i32.load8_u (i32.const 1023)) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  ;; Memory cast
+  (func (export "cast") (result f64)
+    (i64.store (i32.const 8) (i64.const -12345))
+    (if
+      (f64.eq
+        (f64.load (i32.const 8))
+        (f64.reinterpret_i64 (i64.const -12345))
+      )
+      (then (return (f64.const 0)))
+    )
+    (i64.store align=1 (i32.const 9) (i64.const 0))
+    (i32.store16 align=1 (i32.const 15) (i32.const 16453))
+    (f64.load align=1 (i32.const 9))
+  )
+
+  ;; Sign and zero extending memory loads
+  (func (export "i32_load8_s") (param $i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $i))
+	(i32.load8_s (i32.const 8))
+  )
+  (func (export "i32_load8_u") (param $i i32) (result i32)
+	(i32.store8 (i32.const 8) (local.get $i))
+	(i32.load8_u (i32.const 8))
+  )
+  (func (export "i32_load16_s") (param $i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $i))
+	(i32.load16_s (i32.const 8))
+  )
+  (func (export "i32_load16_u") (param $i i32) (result i32)
+	(i32.store16 (i32.const 8) (local.get $i))
+	(i32.load16_u (i32.const 8))
+  )
+  (func (export "i64_load8_s") (param $i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $i))
+	(i64.load8_s (i32.const 8))
+  )
+  (func (export "i64_load8_u") (param $i i64) (result i64)
+	(i64.store8 (i32.const 8) (local.get $i))
+	(i64.load8_u (i32.const 8))
+  )
+  (func (export "i64_load16_s") (param $i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $i))
+	(i64.load16_s (i32.const 8))
+  )
+  (func (export "i64_load16_u") (param $i i64) (result i64)
+	(i64.store16 (i32.const 8) (local.get $i))
+	(i64.load16_u (i32.const 8))
+  )
+  (func (export "i64_load32_s") (param $i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $i))
+	(i64.load32_s (i32.const 8))
+  )
+  (func (export "i64_load32_u") (param $i i64) (result i64)
+	(i64.store32 (i32.const 8) (local.get $i))
+	(i64.load32_u (i32.const 8))
+  )
+)
+
+(assert_return (invoke "data") (i32.const 1))
+(assert_return (invoke "cast") (f64.const 42.0))
+
+(assert_return (invoke "i32_load8_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load8_u" (i32.const -1)) (i32.const 255))
+(assert_return (invoke "i32_load16_s" (i32.const -1)) (i32.const -1))
+(assert_return (invoke "i32_load16_u" (i32.const -1)) (i32.const 65535))
+
+(assert_return (invoke "i32_load8_s" (i32.const 100)) (i32.const 100))
+(assert_return (invoke "i32_load8_u" (i32.const 200)) (i32.const 200))
+(assert_return (invoke "i32_load16_s" (i32.const 20000)) (i32.const 20000))
+(assert_return (invoke "i32_load16_u" (i32.const 40000)) (i32.const 40000))
+
+(assert_return (invoke "i32_load8_s" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_s" (i32.const 0x3456cdef)) (i32.const 0xffffffef))
+(assert_return (invoke "i32_load8_u" (i32.const 0xfedc6543)) (i32.const 0x43))
+(assert_return (invoke "i32_load8_u" (i32.const 0x3456cdef)) (i32.const 0xef))
+(assert_return (invoke "i32_load16_s" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_s" (i32.const 0x3456cdef)) (i32.const 0xffffcdef))
+(assert_return (invoke "i32_load16_u" (i32.const 0xfedc6543)) (i32.const 0x6543))
+(assert_return (invoke "i32_load16_u" (i32.const 0x3456cdef)) (i32.const 0xcdef))
+
+(assert_return (invoke "i64_load8_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load8_u" (i64.const -1)) (i64.const 255))
+(assert_return (invoke "i64_load16_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load16_u" (i64.const -1)) (i64.const 65535))
+(assert_return (invoke "i64_load32_s" (i64.const -1)) (i64.const -1))
+(assert_return (invoke "i64_load32_u" (i64.const -1)) (i64.const 4294967295))
+
+(assert_return (invoke "i64_load8_s" (i64.const 100)) (i64.const 100))
+(assert_return (invoke "i64_load8_u" (i64.const 200)) (i64.const 200))
+(assert_return (invoke "i64_load16_s" (i64.const 20000)) (i64.const 20000))
+(assert_return (invoke "i64_load16_u" (i64.const 40000)) (i64.const 40000))
+(assert_return (invoke "i64_load32_s" (i64.const 20000)) (i64.const 20000))
+(assert_return (invoke "i64_load32_u" (i64.const 40000)) (i64.const 40000))
+
+(assert_return (invoke "i64_load8_s" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffffef))
+(assert_return (invoke "i64_load8_u" (i64.const 0xfedcba9856346543)) (i64.const 0x43))
+(assert_return (invoke "i64_load8_u" (i64.const 0x3456436598bacdef)) (i64.const 0xef))
+(assert_return (invoke "i64_load16_s" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffffffffcdef))
+(assert_return (invoke "i64_load16_u" (i64.const 0xfedcba9856346543)) (i64.const 0x6543))
+(assert_return (invoke "i64_load16_u" (i64.const 0x3456436598bacdef)) (i64.const 0xcdef))
+(assert_return (invoke "i64_load32_s" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef))
+(assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
+(assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))
+
+;; Duplicate identifier errors
+
+(assert_malformed (module quote
+  "(memory $foo 1)"
+  "(memory $foo 1)")
+  "duplicate memory")
+(assert_malformed (module quote
+  "(import \"\" \"\" (memory $foo 1))"
+  "(memory $foo 1)")
+  "duplicate memory")
+(assert_malformed (module quote
+  "(import \"\" \"\" (memory $foo 1))"
+  "(import \"\" \"\" (memory $foo 1))")
+  "duplicate memory")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_func.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_func.wast
new file mode 100644
index 0000000..adb5cb7
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_func.wast
@@ -0,0 +1,115 @@
+(module
+  (func (export "f") (param $x i32) (result i32) (local.get $x))
+)
+(register "M")
+
+(module
+  (func $f (import "M" "f") (param i32) (result i32))
+  (func $g (param $x i32) (result i32)
+    (i32.add (local.get $x) (i32.const 1))
+  )
+
+  (global funcref (ref.func $f))
+  (global funcref (ref.func $g))
+  (global $v (mut funcref) (ref.func $f))
+
+  (global funcref (ref.func $gf1))
+  (global funcref (ref.func $gf2))
+  (func (drop (ref.func $ff1)) (drop (ref.func $ff2)))
+  (elem declare func $gf1 $ff1)
+  (elem declare funcref (ref.func $gf2) (ref.func $ff2))
+  (func $gf1)
+  (func $gf2)
+  (func $ff1)
+  (func $ff2)
+
+  (func (export "is_null-f") (result i32)
+    (ref.is_null (ref.func $f))
+  )
+  (func (export "is_null-g") (result i32)
+    (ref.is_null (ref.func $g))
+  )
+  (func (export "is_null-v") (result i32)
+    (ref.is_null (global.get $v))
+  )
+
+  (func (export "set-f") (global.set $v (ref.func $f)))
+  (func (export "set-g") (global.set $v (ref.func $g)))
+
+  (table $t 1 funcref)
+  (elem declare func $f $g)
+
+  (func (export "call-f") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (ref.func $f))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+  (func (export "call-g") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (ref.func $g))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+  (func (export "call-v") (param $x i32) (result i32)
+    (table.set $t (i32.const 0) (global.get $v))
+    (call_indirect $t (param i32) (result i32) (local.get $x) (i32.const 0))
+  )
+)
+
+(assert_return (invoke "is_null-f") (i32.const 0))
+(assert_return (invoke "is_null-g") (i32.const 0))
+(assert_return (invoke "is_null-v") (i32.const 0))
+
+(assert_return (invoke "call-f" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "call-g" (i32.const 4)) (i32.const 5))
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4))
+(invoke "set-g")
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 5))
+(invoke "set-f")
+(assert_return (invoke "call-v" (i32.const 4)) (i32.const 4))
+
+(assert_invalid
+  (module
+    (func $f (import "M" "f") (param i32) (result i32))
+    (func $g (import "M" "g") (param i32) (result i32))
+    (global funcref (ref.func 7))
+  )
+  "unknown function 7"
+)
+
+
+;; Reference declaration
+
+(module
+  (func $f1)
+  (func $f2)
+  (func $f3)
+  (func $f4)
+  (func $f5)
+  (func $f6)
+
+  (table $t 1 funcref)
+
+  (global funcref (ref.func $f1))
+  (export "f" (func $f2))
+  (elem (table $t) (i32.const 0) func $f3)
+  (elem (table $t) (i32.const 0) funcref (ref.func $f4))
+  (elem func $f5)
+  (elem funcref (ref.func $f6))
+
+  (func
+    (ref.func $f1)
+    (ref.func $f2)
+    (ref.func $f3)
+    (ref.func $f4)
+    (ref.func $f5)
+    (ref.func $f6)
+    (return)
+  )
+)
+
+(assert_invalid
+  (module (func $f (drop (ref.func $f))))
+  "undeclared function reference"
+)
+(assert_invalid
+  (module (start $f) (func $f (drop (ref.func $f))))
+  "undeclared function reference"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_is_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_is_null.wast
new file mode 100644
index 0000000..8396da4
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_is_null.wast
@@ -0,0 +1,58 @@
+(module
+  (func $f1 (export "funcref") (param $x funcref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+  (func $f2 (export "externref") (param $x externref) (result i32)
+    (ref.is_null (local.get $x))
+  )
+
+  (table $t1 2 funcref)
+  (table $t2 2 externref)
+  (elem (table $t1) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "init") (param $r externref)
+    (table.set $t2 (i32.const 1) (local.get $r))
+  )
+  (func (export "deinit")
+    (table.set $t1 (i32.const 1) (ref.null func))
+    (table.set $t2 (i32.const 1) (ref.null extern))
+  )
+
+  (func (export "funcref-elem") (param $x i32) (result i32)
+    (call $f1 (table.get $t1 (local.get $x)))
+  )
+  (func (export "externref-elem") (param $x i32) (result i32)
+    (call $f2 (table.get $t2 (local.get $x)))
+  )
+)
+
+(assert_return (invoke "funcref" (ref.null func)) (i32.const 1))
+(assert_return (invoke "externref" (ref.null extern)) (i32.const 1))
+
+(assert_return (invoke "externref" (ref.extern 1)) (i32.const 0))
+
+(invoke "init" (ref.extern 0))
+
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 0))
+
+(invoke "deinit")
+
+(assert_return (invoke "funcref-elem" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "funcref-elem" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "externref-elem" (i32.const 1)) (i32.const 1))
+
+(assert_invalid
+  (module (func $ref-vs-num (param i32) (ref.is_null (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $ref-vs-empty (ref.is_null)))
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_null.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_null.wast
new file mode 100644
index 0000000..b88b088
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/ref_null.wast
@@ -0,0 +1,10 @@
+(module
+  (func (export "externref") (result externref) (ref.null extern))
+  (func (export "funcref") (result funcref) (ref.null func))
+
+  (global externref (ref.null extern))
+  (global funcref (ref.null func))
+)
+
+(assert_return (invoke "externref") (ref.null extern))
+(assert_return (invoke "funcref") (ref.null func))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/return.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/return.wast
new file mode 100644
index 0000000..7077f25
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/return.wast
@@ -0,0 +1,479 @@
+;; Test `return` operator
+
+(module
+  ;; Auxiliary definition
+  (func $dummy)
+
+  (func (export "type-i32") (drop (i32.ctz (return))))
+  (func (export "type-i64") (drop (i64.ctz (return))))
+  (func (export "type-f32") (drop (f32.neg (return))))
+  (func (export "type-f64") (drop (f64.neg (return))))
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (return (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (return (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (return (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (return (f64.const 4))))
+  )
+
+  (func (export "nullary") (return))
+  (func (export "unary") (result f64) (return (f64.const 3)))
+
+  (func (export "as-func-first") (result i32)
+    (return (i32.const 1)) (i32.const 2)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $dummy) (return (i32.const 2)) (i32.const 3)
+  )
+  (func (export "as-func-last")
+    (nop) (call $dummy) (return)
+  )
+  (func (export "as-func-value") (result i32)
+    (nop) (call $dummy) (return (i32.const 3))
+  )
+
+  (func (export "as-block-first")
+    (block (return) (call $dummy))
+  )
+  (func (export "as-block-mid")
+    (block (call $dummy) (return) (call $dummy))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (return))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (return (i32.const 2)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (return (i32.const 3)) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (nop) (call $dummy) (return (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (return (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (return)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (return (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (return (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (result i64)
+    (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1)
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i64)
+    (return (return (i64.const 7)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32)
+      (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (if (result i32)
+      (local.get 0) (then (return (i32.const 3))) (else (local.get 1))
+    )
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (if (result i32)
+      (local.get 0) (then (local.get 1)) (else (return (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (return (i32.const 5)) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (return (i32.const 6)) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (return (i32.const 7)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (return (i32.const 14)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table funcref (elem $f))
+  (func (export "as-call_indirect-func") (result i32)
+    (call_indirect (type $sig)
+      (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23))
+    )
+  )
+
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (local.set 0 (return (i32.const 17))) (i32.const -1)
+  )
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (return (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (return (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (f32.load (return (f32.const 1.7)))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (i64.load8_s (return (i64.const 30)))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (f64.store (return (i32.const 30)) (f64.const 7)) (i32.const -1)
+  )
+  (func (export "as-store-value") (result i32)
+    (i64.store (i32.const 2) (return (i32.const 31))) (i32.const -1)
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (i32.store8 (return (i32.const 32)) (i32.const 7)) (i32.const -1)
+  )
+  (func (export "as-storeN-value") (result i32)
+    (i64.store16 (i32.const 2) (return (i32.const 33))) (i32.const -1)
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (f32.neg (return (f32.const 3.4)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (return (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i64)
+    (i64.sub (i64.const 10) (return (i64.const 45)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (return (i32.const 44)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (f64.le (return (i32.const 43)) (f64.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (f32.ne (f32.const 10) (return (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (i32.wrap_i64 (return (i32.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (return (i32.const 40)))
+  )
+)
+
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
+(assert_return (invoke "nullary"))
+(assert_return (invoke "unary") (f64.const 3))
+
+(assert_return (invoke "as-func-first") (i32.const 1))
+(assert_return (invoke "as-func-mid") (i32.const 2))
+(assert_return (invoke "as-func-last"))
+(assert_return (invoke "as-func-value") (i32.const 3))
+
+(assert_return (invoke "as-block-first"))
+(assert_return (invoke "as-block-mid"))
+(assert_return (invoke "as-block-last"))
+(assert_return (invoke "as-block-value") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 3))
+(assert_return (invoke "as-loop-mid") (i32.const 4))
+(assert_return (invoke "as-loop-last") (i32.const 5))
+
+(assert_return (invoke "as-br-value") (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
+
+(assert_return (invoke "as-br_table-index") (i64.const 9))
+(assert_return (invoke "as-br_table-value") (i32.const 10))
+(assert_return (invoke "as-br_table-value-index") (i32.const 11))
+
+(assert_return (invoke "as-return-value") (i64.const 7))
+
+(assert_return (invoke "as-if-cond") (i32.const 2))
+(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-first" (i32.const 1) (i32.const 6)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-second" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_return (invoke "as-select-cond") (i32.const 7))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 20))
+(assert_return (invoke "as-call_indirect-first") (i32.const 21))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 22))
+(assert_return (invoke "as-call_indirect-last") (i32.const 23))
+
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
+(assert_return (invoke "as-unary-operand") (f32.const 3.4))
+
+(assert_return (invoke "as-binary-left") (i32.const 3))
+(assert_return (invoke "as-binary-right") (i64.const 45))
+
+(assert_return (invoke "as-test-operand") (i32.const 44))
+
+(assert_return (invoke "as-compare-left") (i32.const 43))
+(assert_return (invoke "as-compare-right") (i32.const 42))
+
+(assert_return (invoke "as-convert-operand") (i32.const 41))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
+
+(assert_invalid
+  (module (func $type-value-empty-vs-num (result i32) (return)))
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-block (result i32)
+      (i32.const 0)
+      (block (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-loop (result i32)
+      (i32.const 0)
+      (loop (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-then (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (then (return)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-else (result i32)
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (return))) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-br (result i32)
+      (i32.const 0)
+      (block (br 0 (return)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-br_if (result i32)
+      (i32.const 0)
+      (block (br_if 0 (return) (i32.const 1)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-br_table (result i32)
+      (i32.const 0)
+      (block (br_table 0 (return)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-return (result i32)
+      (return (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-select (result i32)
+      (select (return) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-call (result i32)
+      (call 1 (return))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-value-empty-vs-num-in-call_indirect (result i32)
+      (block (result i32)
+        (call_indirect (type $sig)
+          (return) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-local.set (result i32)
+      (local i32)
+      (local.set 0 (return)) (local.get 0)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-value-empty-vs-num-in-local.tee (result i32)
+      (local i32)
+      (local.tee 0 (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (global $x (mut i32) (i32.const 0))
+    (func $type-value-empty-vs-num-in-global.set (result i32)
+      (global.set $x (return)) (global.get $x)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-value-empty-vs-num-in-memory.grow (result i32)
+      (memory.grow (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 0)
+    (func $type-value-empty-vs-num-in-load (result i32)
+      (i32.load (return))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-vs-num-in-store (result i32)
+      (i32.store (return) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-num (result f64) (return (nop))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-num-vs-num (result f64) (return (i64.const 1))))
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/select.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/select.wast
new file mode 100644
index 0000000..b343bf9
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/select.wast
@@ -0,0 +1,598 @@
+(module
+  ;; Auxiliary
+  (func $dummy)
+  (table $tab funcref (elem $dummy))
+  (memory 1)
+
+  (func (export "select-i32") (param i32 i32 i32) (result i32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64") (param i64 i64 i32) (result i64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32") (param f32 f32 i32) (result f32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64") (param f64 f64 i32) (result f64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "select-i32-t") (param i32 i32 i32) (result i32)
+    (select (result i32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-i64-t") (param i64 i64 i32) (result i64)
+    (select (result i64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f32-t") (param f32 f32 i32) (result f32)
+    (select (result f32) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-f64-t") (param f64 f64 i32) (result f64)
+    (select (result f64) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-funcref") (param funcref funcref i32) (result funcref)
+    (select (result funcref) (local.get 0) (local.get 1) (local.get 2))
+  )
+  (func (export "select-externref") (param externref externref i32) (result externref)
+    (select (result externref) (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  ;; Check that both sides of the select are evaluated
+  (func (export "select-trap-left") (param $cond i32) (result i32)
+    (select (unreachable) (i32.const 0) (local.get $cond))
+  )
+  (func (export "select-trap-right") (param $cond i32) (result i32)
+    (select (i32.const 0) (unreachable) (local.get $cond))
+  )
+
+  (func (export "select-unreached")
+    (unreachable) (select)
+    (unreachable) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (i32.const 0) (i32.const 0) (i32.const 0) (select)
+    (unreachable) (f32.const 0) (i32.const 0) (select)
+    (unreachable)
+  )
+
+  (func (export "select_unreached_result_1") (result i32)
+    (unreachable) (i32.add (select))
+  )
+
+  (func (export "select_unreached_result_2") (result i64)
+    (unreachable) (i64.add (select (i64.const 0) (i32.const 0)))
+  )
+
+  ;; As the argument of control constructs and instructions
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)))
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (select (i32.const 2) (i32.const 3) (local.get 0)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (local.get 0))) (else (i32.const 4)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 4)))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0))))
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (local.get 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table $t funcref (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 1) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect $t (type $check)
+        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (local.get 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (select (i32.const 1) (i32.const 2) (local.get 0)) (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (local.get 0))))
+  )
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32) (local.set 0 (select (i32.const 1) (i32.const 2) (local.get 0))) (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (select (i32.const 1) (i32.const 2) (local.get 0)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a (select (i32.const 1) (i32.const 2) (local.get 0)))
+    (global.get $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load (select (i32.const 0) (i32.const 4) (local.get 0)))
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+  )
+  (func (export "as-binary-operand") (param i32) (result i32)
+    (i32.mul
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+    )
+  )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (block (result i32)
+      (i32.le_s (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (block (result i32)
+      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
+    )
+  )
+
+  (func (export "unreachable-num")
+    (unreachable)
+    (select)
+    (i32.eqz)
+    (drop)
+  )
+  (func (export "unreachable-ref")
+    (unreachable)
+    (select)
+    (ref.is_null)
+    (drop)
+  )
+)
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+
+(assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 1)) (i64.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 1) (f32.const 2) (i32.const 1)) (f32.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 1) (f64.const 2) (i32.const 1)) (f64.const 1))
+(assert_return (invoke "select-funcref" (ref.null func) (ref.null func) (i32.const 1)) (ref.null func))
+(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 1)) (ref.extern 1))
+
+(assert_return (invoke "select-i32-t" (i32.const 1) (i32.const 2) (i32.const 0)) (i32.const 2))
+(assert_return (invoke "select-i32-t" (i32.const 2) (i32.const 1) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const -1)) (i64.const 2))
+(assert_return (invoke "select-i64-t" (i64.const 2) (i64.const 1) (i32.const 0xf0f0f0f0)) (i64.const 2))
+(assert_return (invoke "select-externref" (ref.extern 1) (ref.extern 2) (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "select-externref" (ref.extern 2) (ref.extern 1) (i32.const 0)) (ref.extern 1))
+
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 1)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 1)) (f32.const nan:0x20304))
+(assert_return (invoke "select-f32-t" (f32.const nan) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const nan:0x20304) (f32.const 1) (i32.const 0)) (f32.const 1))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 1)) (f32.const 2))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan) (i32.const 0)) (f32.const nan))
+(assert_return (invoke "select-f32-t" (f32.const 2) (f32.const nan:0x20304) (i32.const 0)) (f32.const nan:0x20304))
+
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 1)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 1)) (f64.const nan:0x20304))
+(assert_return (invoke "select-f64-t" (f64.const nan) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const nan:0x20304) (f64.const 1) (i32.const 0)) (f64.const 1))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 1)) (f64.const 2))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan) (i32.const 0)) (f64.const nan))
+(assert_return (invoke "select-f64-t" (f64.const 2) (f64.const nan:0x20304) (i32.const 0)) (f64.const nan:0x20304))
+
+(assert_trap (invoke "select-trap-left" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-left" (i32.const 0)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 1)) "unreachable")
+(assert_trap (invoke "select-trap-right" (i32.const 0)) "unreachable")
+
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)))
+(assert_return (invoke "as-if-condition" (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
+;;(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-left" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-convert-operand" (i32.const 1)) (i32.const 1))
+
+(assert_invalid
+  (module (func $arity-0-implicit (select (nop) (nop) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $arity-0 (select (result) (nop) (nop) (i32.const 1))))
+  "invalid result arity"
+)
+(assert_invalid
+  (module (func $arity-2 (result i32 i32)
+    (select (result i32 i32)
+      (i32.const 0) (i32.const 0)
+      (i32.const 0) (i32.const 0)
+      (i32.const 1)
+    )
+  ))
+  "invalid result arity"
+)
+
+
+(assert_invalid
+  (module (func $type-externref-implicit (param $r externref)
+    (drop (select (local.get $r) (local.get $r) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (i64.const 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f32.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num
+    (drop (select (i32.const 1) (f64.const 1.0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f64.const 1.0) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty
+      (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty
+      (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty
+      (i32.const 0) (i32.const 0) (select) (drop)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-block
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (block (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-loop
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (loop (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.const 0) (select) (drop))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-1st-operand-empty-in-then
+      (i32.const 0) (i32.const 0) (i32.const 0)
+      (if (then (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-2nd-operand-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (func $type-3rd-operand-empty-in-then
+      (i32.const 0)
+      (if (then (i32.const 0) (i32.const 0) (select) (drop)))
+    )
+  )
+  "type mismatch"
+)
+
+;; Third operand must be i32
+
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (f32.const 1)) (drop)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (select (i32.const 1) (i32.const 1) (f64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands
+
+(assert_invalid
+  (module (func (result i32) (select (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+;; Validation after unreachable
+
+;; The first two operands should have the same type as each other
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1) (i32.const 1) (i32.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Third operand must be i32
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i32.const 1) (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func (unreachable) (select (i64.const 1)) (drop)))
+  "type mismatch"
+)
+
+;; Result of select has type of first two operands (type of second operand when first one is omitted)
+(assert_invalid
+  (module (func (result i32) (unreachable) (select (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+
+;; select always has non-empty result
+(assert_invalid
+  (module (func (unreachable) (select)))
+  "type mismatch"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/skip-stack-guard-page.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/skip-stack-guard-page.wast
new file mode 100644
index 0000000..a472e68
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/skip-stack-guard-page.wast
@@ -0,0 +1,2284 @@
+;; This tests that the stack overflow guard page can't be skipped by a function with more than a page of locals.
+(module
+  (memory 1)
+  (export "test-guard-page-skip" (func $test-guard-page-skip))
+
+  (func $test-guard-page-skip
+    (param $depth i32)
+    (if (i32.eq (local.get $depth) (i32.const 0))
+      (then (call $function-with-many-locals))
+      (else (call $test-guard-page-skip (i32.sub (local.get $depth) (i32.const 1))))
+    )
+  )
+
+  (func $function-with-many-locals
+
+    ;; 1056 i64 = 8448 bytes of locals
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x000-0x007
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x008-0x00f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x010-0x017
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x018-0x01f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x020-0x027
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x028-0x02f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x030-0x037
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x038-0x03f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x040-0x047
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x048-0x04f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x050-0x057
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x058-0x05f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x060-0x067
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x068-0x06f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x070-0x077
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x078-0x07f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x080-0x087
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x088-0x08f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x090-0x097
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x098-0x09f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a0-0x0a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0a8-0x0af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b0-0x0b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0b8-0x0bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c0-0x0c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0c8-0x0cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d0-0x0d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0d8-0x0df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e0-0x0e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0e8-0x0ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f0-0x0f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x0f8-0x0ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x100-0x107
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x108-0x10f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x110-0x117
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x118-0x11f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x120-0x127
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x128-0x12f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x130-0x137
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x138-0x13f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x140-0x147
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x148-0x14f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x150-0x157
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x158-0x15f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x160-0x167
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x168-0x16f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x170-0x177
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x178-0x17f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x180-0x187
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x188-0x18f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x190-0x197
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x198-0x19f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a0-0x1a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1a8-0x1af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b0-0x1b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1b8-0x1bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c0-0x1c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1c8-0x1cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d0-0x1d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1d8-0x1df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e0-0x1e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1e8-0x1ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f0-0x1f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x1f8-0x1ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x200-0x207
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x208-0x20f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x210-0x217
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x218-0x21f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x220-0x227
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x228-0x22f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x230-0x237
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x238-0x23f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x240-0x247
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x248-0x24f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x250-0x257
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x258-0x25f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x260-0x267
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x268-0x26f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x270-0x277
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x278-0x27f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x280-0x287
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x288-0x28f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x290-0x297
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x298-0x29f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a0-0x2a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2a8-0x2af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b0-0x2b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2b8-0x2bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c0-0x2c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2c8-0x2cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d0-0x2d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2d8-0x2df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e0-0x2e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2e8-0x2ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f0-0x2f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x2f8-0x2ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x300-0x307
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x308-0x30f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x310-0x317
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x318-0x31f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x320-0x327
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x328-0x32f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x330-0x337
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x338-0x33f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x340-0x347
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x348-0x34f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x350-0x357
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x358-0x35f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x360-0x367
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x368-0x36f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x370-0x377
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x378-0x37f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x380-0x387
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x388-0x38f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x390-0x397
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x398-0x39f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a0-0x3a7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3a8-0x3af
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b0-0x3b7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3b8-0x3bf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c0-0x3c7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3c8-0x3cf
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d0-0x3d7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3d8-0x3df
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e0-0x3e7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3e8-0x3ef
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f0-0x3f7
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x3f8-0x3ff
+
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x400-0x407
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x408-0x40f
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x410-0x417
+    (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) (local i64) ;; 0x418-0x41f
+
+    ;; recurse first to try to make the callee access the stack below the space allocated for the locals before the locals themselves have been initialized.
+    (call $function-with-many-locals)
+
+    ;; load from memory into the locals
+    (local.set 0x000 (i64.load offset=0x000 align=1 (i32.const 0)))
+    (local.set 0x001 (i64.load offset=0x001 align=1 (i32.const 0)))
+    (local.set 0x002 (i64.load offset=0x002 align=1 (i32.const 0)))
+    (local.set 0x003 (i64.load offset=0x003 align=1 (i32.const 0)))
+    (local.set 0x004 (i64.load offset=0x004 align=1 (i32.const 0)))
+    (local.set 0x005 (i64.load offset=0x005 align=1 (i32.const 0)))
+    (local.set 0x006 (i64.load offset=0x006 align=1 (i32.const 0)))
+    (local.set 0x007 (i64.load offset=0x007 align=1 (i32.const 0)))
+    (local.set 0x008 (i64.load offset=0x008 align=1 (i32.const 0)))
+    (local.set 0x009 (i64.load offset=0x009 align=1 (i32.const 0)))
+    (local.set 0x00a (i64.load offset=0x00a align=1 (i32.const 0)))
+    (local.set 0x00b (i64.load offset=0x00b align=1 (i32.const 0)))
+    (local.set 0x00c (i64.load offset=0x00c align=1 (i32.const 0)))
+    (local.set 0x00d (i64.load offset=0x00d align=1 (i32.const 0)))
+    (local.set 0x00e (i64.load offset=0x00e align=1 (i32.const 0)))
+    (local.set 0x00f (i64.load offset=0x00f align=1 (i32.const 0)))
+    (local.set 0x010 (i64.load offset=0x010 align=1 (i32.const 0)))
+    (local.set 0x011 (i64.load offset=0x011 align=1 (i32.const 0)))
+    (local.set 0x012 (i64.load offset=0x012 align=1 (i32.const 0)))
+    (local.set 0x013 (i64.load offset=0x013 align=1 (i32.const 0)))
+    (local.set 0x014 (i64.load offset=0x014 align=1 (i32.const 0)))
+    (local.set 0x015 (i64.load offset=0x015 align=1 (i32.const 0)))
+    (local.set 0x016 (i64.load offset=0x016 align=1 (i32.const 0)))
+    (local.set 0x017 (i64.load offset=0x017 align=1 (i32.const 0)))
+    (local.set 0x018 (i64.load offset=0x018 align=1 (i32.const 0)))
+    (local.set 0x019 (i64.load offset=0x019 align=1 (i32.const 0)))
+    (local.set 0x01a (i64.load offset=0x01a align=1 (i32.const 0)))
+    (local.set 0x01b (i64.load offset=0x01b align=1 (i32.const 0)))
+    (local.set 0x01c (i64.load offset=0x01c align=1 (i32.const 0)))
+    (local.set 0x01d (i64.load offset=0x01d align=1 (i32.const 0)))
+    (local.set 0x01e (i64.load offset=0x01e align=1 (i32.const 0)))
+    (local.set 0x01f (i64.load offset=0x01f align=1 (i32.const 0)))
+    (local.set 0x020 (i64.load offset=0x020 align=1 (i32.const 0)))
+    (local.set 0x021 (i64.load offset=0x021 align=1 (i32.const 0)))
+    (local.set 0x022 (i64.load offset=0x022 align=1 (i32.const 0)))
+    (local.set 0x023 (i64.load offset=0x023 align=1 (i32.const 0)))
+    (local.set 0x024 (i64.load offset=0x024 align=1 (i32.const 0)))
+    (local.set 0x025 (i64.load offset=0x025 align=1 (i32.const 0)))
+    (local.set 0x026 (i64.load offset=0x026 align=1 (i32.const 0)))
+    (local.set 0x027 (i64.load offset=0x027 align=1 (i32.const 0)))
+    (local.set 0x028 (i64.load offset=0x028 align=1 (i32.const 0)))
+    (local.set 0x029 (i64.load offset=0x029 align=1 (i32.const 0)))
+    (local.set 0x02a (i64.load offset=0x02a align=1 (i32.const 0)))
+    (local.set 0x02b (i64.load offset=0x02b align=1 (i32.const 0)))
+    (local.set 0x02c (i64.load offset=0x02c align=1 (i32.const 0)))
+    (local.set 0x02d (i64.load offset=0x02d align=1 (i32.const 0)))
+    (local.set 0x02e (i64.load offset=0x02e align=1 (i32.const 0)))
+    (local.set 0x02f (i64.load offset=0x02f align=1 (i32.const 0)))
+    (local.set 0x030 (i64.load offset=0x030 align=1 (i32.const 0)))
+    (local.set 0x031 (i64.load offset=0x031 align=1 (i32.const 0)))
+    (local.set 0x032 (i64.load offset=0x032 align=1 (i32.const 0)))
+    (local.set 0x033 (i64.load offset=0x033 align=1 (i32.const 0)))
+    (local.set 0x034 (i64.load offset=0x034 align=1 (i32.const 0)))
+    (local.set 0x035 (i64.load offset=0x035 align=1 (i32.const 0)))
+    (local.set 0x036 (i64.load offset=0x036 align=1 (i32.const 0)))
+    (local.set 0x037 (i64.load offset=0x037 align=1 (i32.const 0)))
+    (local.set 0x038 (i64.load offset=0x038 align=1 (i32.const 0)))
+    (local.set 0x039 (i64.load offset=0x039 align=1 (i32.const 0)))
+    (local.set 0x03a (i64.load offset=0x03a align=1 (i32.const 0)))
+    (local.set 0x03b (i64.load offset=0x03b align=1 (i32.const 0)))
+    (local.set 0x03c (i64.load offset=0x03c align=1 (i32.const 0)))
+    (local.set 0x03d (i64.load offset=0x03d align=1 (i32.const 0)))
+    (local.set 0x03e (i64.load offset=0x03e align=1 (i32.const 0)))
+    (local.set 0x03f (i64.load offset=0x03f align=1 (i32.const 0)))
+    (local.set 0x040 (i64.load offset=0x040 align=1 (i32.const 0)))
+    (local.set 0x041 (i64.load offset=0x041 align=1 (i32.const 0)))
+    (local.set 0x042 (i64.load offset=0x042 align=1 (i32.const 0)))
+    (local.set 0x043 (i64.load offset=0x043 align=1 (i32.const 0)))
+    (local.set 0x044 (i64.load offset=0x044 align=1 (i32.const 0)))
+    (local.set 0x045 (i64.load offset=0x045 align=1 (i32.const 0)))
+    (local.set 0x046 (i64.load offset=0x046 align=1 (i32.const 0)))
+    (local.set 0x047 (i64.load offset=0x047 align=1 (i32.const 0)))
+    (local.set 0x048 (i64.load offset=0x048 align=1 (i32.const 0)))
+    (local.set 0x049 (i64.load offset=0x049 align=1 (i32.const 0)))
+    (local.set 0x04a (i64.load offset=0x04a align=1 (i32.const 0)))
+    (local.set 0x04b (i64.load offset=0x04b align=1 (i32.const 0)))
+    (local.set 0x04c (i64.load offset=0x04c align=1 (i32.const 0)))
+    (local.set 0x04d (i64.load offset=0x04d align=1 (i32.const 0)))
+    (local.set 0x04e (i64.load offset=0x04e align=1 (i32.const 0)))
+    (local.set 0x04f (i64.load offset=0x04f align=1 (i32.const 0)))
+    (local.set 0x050 (i64.load offset=0x050 align=1 (i32.const 0)))
+    (local.set 0x051 (i64.load offset=0x051 align=1 (i32.const 0)))
+    (local.set 0x052 (i64.load offset=0x052 align=1 (i32.const 0)))
+    (local.set 0x053 (i64.load offset=0x053 align=1 (i32.const 0)))
+    (local.set 0x054 (i64.load offset=0x054 align=1 (i32.const 0)))
+    (local.set 0x055 (i64.load offset=0x055 align=1 (i32.const 0)))
+    (local.set 0x056 (i64.load offset=0x056 align=1 (i32.const 0)))
+    (local.set 0x057 (i64.load offset=0x057 align=1 (i32.const 0)))
+    (local.set 0x058 (i64.load offset=0x058 align=1 (i32.const 0)))
+    (local.set 0x059 (i64.load offset=0x059 align=1 (i32.const 0)))
+    (local.set 0x05a (i64.load offset=0x05a align=1 (i32.const 0)))
+    (local.set 0x05b (i64.load offset=0x05b align=1 (i32.const 0)))
+    (local.set 0x05c (i64.load offset=0x05c align=1 (i32.const 0)))
+    (local.set 0x05d (i64.load offset=0x05d align=1 (i32.const 0)))
+    (local.set 0x05e (i64.load offset=0x05e align=1 (i32.const 0)))
+    (local.set 0x05f (i64.load offset=0x05f align=1 (i32.const 0)))
+    (local.set 0x060 (i64.load offset=0x060 align=1 (i32.const 0)))
+    (local.set 0x061 (i64.load offset=0x061 align=1 (i32.const 0)))
+    (local.set 0x062 (i64.load offset=0x062 align=1 (i32.const 0)))
+    (local.set 0x063 (i64.load offset=0x063 align=1 (i32.const 0)))
+    (local.set 0x064 (i64.load offset=0x064 align=1 (i32.const 0)))
+    (local.set 0x065 (i64.load offset=0x065 align=1 (i32.const 0)))
+    (local.set 0x066 (i64.load offset=0x066 align=1 (i32.const 0)))
+    (local.set 0x067 (i64.load offset=0x067 align=1 (i32.const 0)))
+    (local.set 0x068 (i64.load offset=0x068 align=1 (i32.const 0)))
+    (local.set 0x069 (i64.load offset=0x069 align=1 (i32.const 0)))
+    (local.set 0x06a (i64.load offset=0x06a align=1 (i32.const 0)))
+    (local.set 0x06b (i64.load offset=0x06b align=1 (i32.const 0)))
+    (local.set 0x06c (i64.load offset=0x06c align=1 (i32.const 0)))
+    (local.set 0x06d (i64.load offset=0x06d align=1 (i32.const 0)))
+    (local.set 0x06e (i64.load offset=0x06e align=1 (i32.const 0)))
+    (local.set 0x06f (i64.load offset=0x06f align=1 (i32.const 0)))
+    (local.set 0x070 (i64.load offset=0x070 align=1 (i32.const 0)))
+    (local.set 0x071 (i64.load offset=0x071 align=1 (i32.const 0)))
+    (local.set 0x072 (i64.load offset=0x072 align=1 (i32.const 0)))
+    (local.set 0x073 (i64.load offset=0x073 align=1 (i32.const 0)))
+    (local.set 0x074 (i64.load offset=0x074 align=1 (i32.const 0)))
+    (local.set 0x075 (i64.load offset=0x075 align=1 (i32.const 0)))
+    (local.set 0x076 (i64.load offset=0x076 align=1 (i32.const 0)))
+    (local.set 0x077 (i64.load offset=0x077 align=1 (i32.const 0)))
+    (local.set 0x078 (i64.load offset=0x078 align=1 (i32.const 0)))
+    (local.set 0x079 (i64.load offset=0x079 align=1 (i32.const 0)))
+    (local.set 0x07a (i64.load offset=0x07a align=1 (i32.const 0)))
+    (local.set 0x07b (i64.load offset=0x07b align=1 (i32.const 0)))
+    (local.set 0x07c (i64.load offset=0x07c align=1 (i32.const 0)))
+    (local.set 0x07d (i64.load offset=0x07d align=1 (i32.const 0)))
+    (local.set 0x07e (i64.load offset=0x07e align=1 (i32.const 0)))
+    (local.set 0x07f (i64.load offset=0x07f align=1 (i32.const 0)))
+    (local.set 0x080 (i64.load offset=0x080 align=1 (i32.const 0)))
+    (local.set 0x081 (i64.load offset=0x081 align=1 (i32.const 0)))
+    (local.set 0x082 (i64.load offset=0x082 align=1 (i32.const 0)))
+    (local.set 0x083 (i64.load offset=0x083 align=1 (i32.const 0)))
+    (local.set 0x084 (i64.load offset=0x084 align=1 (i32.const 0)))
+    (local.set 0x085 (i64.load offset=0x085 align=1 (i32.const 0)))
+    (local.set 0x086 (i64.load offset=0x086 align=1 (i32.const 0)))
+    (local.set 0x087 (i64.load offset=0x087 align=1 (i32.const 0)))
+    (local.set 0x088 (i64.load offset=0x088 align=1 (i32.const 0)))
+    (local.set 0x089 (i64.load offset=0x089 align=1 (i32.const 0)))
+    (local.set 0x08a (i64.load offset=0x08a align=1 (i32.const 0)))
+    (local.set 0x08b (i64.load offset=0x08b align=1 (i32.const 0)))
+    (local.set 0x08c (i64.load offset=0x08c align=1 (i32.const 0)))
+    (local.set 0x08d (i64.load offset=0x08d align=1 (i32.const 0)))
+    (local.set 0x08e (i64.load offset=0x08e align=1 (i32.const 0)))
+    (local.set 0x08f (i64.load offset=0x08f align=1 (i32.const 0)))
+    (local.set 0x090 (i64.load offset=0x090 align=1 (i32.const 0)))
+    (local.set 0x091 (i64.load offset=0x091 align=1 (i32.const 0)))
+    (local.set 0x092 (i64.load offset=0x092 align=1 (i32.const 0)))
+    (local.set 0x093 (i64.load offset=0x093 align=1 (i32.const 0)))
+    (local.set 0x094 (i64.load offset=0x094 align=1 (i32.const 0)))
+    (local.set 0x095 (i64.load offset=0x095 align=1 (i32.const 0)))
+    (local.set 0x096 (i64.load offset=0x096 align=1 (i32.const 0)))
+    (local.set 0x097 (i64.load offset=0x097 align=1 (i32.const 0)))
+    (local.set 0x098 (i64.load offset=0x098 align=1 (i32.const 0)))
+    (local.set 0x099 (i64.load offset=0x099 align=1 (i32.const 0)))
+    (local.set 0x09a (i64.load offset=0x09a align=1 (i32.const 0)))
+    (local.set 0x09b (i64.load offset=0x09b align=1 (i32.const 0)))
+    (local.set 0x09c (i64.load offset=0x09c align=1 (i32.const 0)))
+    (local.set 0x09d (i64.load offset=0x09d align=1 (i32.const 0)))
+    (local.set 0x09e (i64.load offset=0x09e align=1 (i32.const 0)))
+    (local.set 0x09f (i64.load offset=0x09f align=1 (i32.const 0)))
+    (local.set 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0)))
+    (local.set 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0)))
+    (local.set 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0)))
+    (local.set 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0)))
+    (local.set 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0)))
+    (local.set 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0)))
+    (local.set 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0)))
+    (local.set 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0)))
+    (local.set 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0)))
+    (local.set 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0)))
+    (local.set 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0)))
+    (local.set 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0)))
+    (local.set 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0)))
+    (local.set 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0)))
+    (local.set 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0)))
+    (local.set 0x0af (i64.load offset=0x0af align=1 (i32.const 0)))
+    (local.set 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0)))
+    (local.set 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0)))
+    (local.set 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0)))
+    (local.set 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0)))
+    (local.set 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0)))
+    (local.set 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0)))
+    (local.set 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0)))
+    (local.set 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0)))
+    (local.set 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0)))
+    (local.set 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0)))
+    (local.set 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0)))
+    (local.set 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0)))
+    (local.set 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0)))
+    (local.set 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0)))
+    (local.set 0x0be (i64.load offset=0x0be align=1 (i32.const 0)))
+    (local.set 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0)))
+    (local.set 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0)))
+    (local.set 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0)))
+    (local.set 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0)))
+    (local.set 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0)))
+    (local.set 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0)))
+    (local.set 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0)))
+    (local.set 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0)))
+    (local.set 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0)))
+    (local.set 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0)))
+    (local.set 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0)))
+    (local.set 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0)))
+    (local.set 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0)))
+    (local.set 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0)))
+    (local.set 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0)))
+    (local.set 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0)))
+    (local.set 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0)))
+    (local.set 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0)))
+    (local.set 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0)))
+    (local.set 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0)))
+    (local.set 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0)))
+    (local.set 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0)))
+    (local.set 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0)))
+    (local.set 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0)))
+    (local.set 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0)))
+    (local.set 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0)))
+    (local.set 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0)))
+    (local.set 0x0da (i64.load offset=0x0da align=1 (i32.const 0)))
+    (local.set 0x0db (i64.load offset=0x0db align=1 (i32.const 0)))
+    (local.set 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0)))
+    (local.set 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0)))
+    (local.set 0x0de (i64.load offset=0x0de align=1 (i32.const 0)))
+    (local.set 0x0df (i64.load offset=0x0df align=1 (i32.const 0)))
+    (local.set 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0)))
+    (local.set 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0)))
+    (local.set 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0)))
+    (local.set 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0)))
+    (local.set 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0)))
+    (local.set 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0)))
+    (local.set 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0)))
+    (local.set 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0)))
+    (local.set 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0)))
+    (local.set 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0)))
+    (local.set 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0)))
+    (local.set 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0)))
+    (local.set 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0)))
+    (local.set 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0)))
+    (local.set 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0)))
+    (local.set 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0)))
+    (local.set 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0)))
+    (local.set 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0)))
+    (local.set 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0)))
+    (local.set 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0)))
+    (local.set 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0)))
+    (local.set 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0)))
+    (local.set 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0)))
+    (local.set 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0)))
+    (local.set 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0)))
+    (local.set 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0)))
+    (local.set 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0)))
+    (local.set 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0)))
+    (local.set 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0)))
+    (local.set 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0)))
+    (local.set 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0)))
+    (local.set 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0)))
+    (local.set 0x100 (i64.load offset=0x100 align=1 (i32.const 0)))
+    (local.set 0x101 (i64.load offset=0x101 align=1 (i32.const 0)))
+    (local.set 0x102 (i64.load offset=0x102 align=1 (i32.const 0)))
+    (local.set 0x103 (i64.load offset=0x103 align=1 (i32.const 0)))
+    (local.set 0x104 (i64.load offset=0x104 align=1 (i32.const 0)))
+    (local.set 0x105 (i64.load offset=0x105 align=1 (i32.const 0)))
+    (local.set 0x106 (i64.load offset=0x106 align=1 (i32.const 0)))
+    (local.set 0x107 (i64.load offset=0x107 align=1 (i32.const 0)))
+    (local.set 0x108 (i64.load offset=0x108 align=1 (i32.const 0)))
+    (local.set 0x109 (i64.load offset=0x109 align=1 (i32.const 0)))
+    (local.set 0x10a (i64.load offset=0x10a align=1 (i32.const 0)))
+    (local.set 0x10b (i64.load offset=0x10b align=1 (i32.const 0)))
+    (local.set 0x10c (i64.load offset=0x10c align=1 (i32.const 0)))
+    (local.set 0x10d (i64.load offset=0x10d align=1 (i32.const 0)))
+    (local.set 0x10e (i64.load offset=0x10e align=1 (i32.const 0)))
+    (local.set 0x10f (i64.load offset=0x10f align=1 (i32.const 0)))
+    (local.set 0x110 (i64.load offset=0x110 align=1 (i32.const 0)))
+    (local.set 0x111 (i64.load offset=0x111 align=1 (i32.const 0)))
+    (local.set 0x112 (i64.load offset=0x112 align=1 (i32.const 0)))
+    (local.set 0x113 (i64.load offset=0x113 align=1 (i32.const 0)))
+    (local.set 0x114 (i64.load offset=0x114 align=1 (i32.const 0)))
+    (local.set 0x115 (i64.load offset=0x115 align=1 (i32.const 0)))
+    (local.set 0x116 (i64.load offset=0x116 align=1 (i32.const 0)))
+    (local.set 0x117 (i64.load offset=0x117 align=1 (i32.const 0)))
+    (local.set 0x118 (i64.load offset=0x118 align=1 (i32.const 0)))
+    (local.set 0x119 (i64.load offset=0x119 align=1 (i32.const 0)))
+    (local.set 0x11a (i64.load offset=0x11a align=1 (i32.const 0)))
+    (local.set 0x11b (i64.load offset=0x11b align=1 (i32.const 0)))
+    (local.set 0x11c (i64.load offset=0x11c align=1 (i32.const 0)))
+    (local.set 0x11d (i64.load offset=0x11d align=1 (i32.const 0)))
+    (local.set 0x11e (i64.load offset=0x11e align=1 (i32.const 0)))
+    (local.set 0x11f (i64.load offset=0x11f align=1 (i32.const 0)))
+    (local.set 0x120 (i64.load offset=0x120 align=1 (i32.const 0)))
+    (local.set 0x121 (i64.load offset=0x121 align=1 (i32.const 0)))
+    (local.set 0x122 (i64.load offset=0x122 align=1 (i32.const 0)))
+    (local.set 0x123 (i64.load offset=0x123 align=1 (i32.const 0)))
+    (local.set 0x124 (i64.load offset=0x124 align=1 (i32.const 0)))
+    (local.set 0x125 (i64.load offset=0x125 align=1 (i32.const 0)))
+    (local.set 0x126 (i64.load offset=0x126 align=1 (i32.const 0)))
+    (local.set 0x127 (i64.load offset=0x127 align=1 (i32.const 0)))
+    (local.set 0x128 (i64.load offset=0x128 align=1 (i32.const 0)))
+    (local.set 0x129 (i64.load offset=0x129 align=1 (i32.const 0)))
+    (local.set 0x12a (i64.load offset=0x12a align=1 (i32.const 0)))
+    (local.set 0x12b (i64.load offset=0x12b align=1 (i32.const 0)))
+    (local.set 0x12c (i64.load offset=0x12c align=1 (i32.const 0)))
+    (local.set 0x12d (i64.load offset=0x12d align=1 (i32.const 0)))
+    (local.set 0x12e (i64.load offset=0x12e align=1 (i32.const 0)))
+    (local.set 0x12f (i64.load offset=0x12f align=1 (i32.const 0)))
+    (local.set 0x130 (i64.load offset=0x130 align=1 (i32.const 0)))
+    (local.set 0x131 (i64.load offset=0x131 align=1 (i32.const 0)))
+    (local.set 0x132 (i64.load offset=0x132 align=1 (i32.const 0)))
+    (local.set 0x133 (i64.load offset=0x133 align=1 (i32.const 0)))
+    (local.set 0x134 (i64.load offset=0x134 align=1 (i32.const 0)))
+    (local.set 0x135 (i64.load offset=0x135 align=1 (i32.const 0)))
+    (local.set 0x136 (i64.load offset=0x136 align=1 (i32.const 0)))
+    (local.set 0x137 (i64.load offset=0x137 align=1 (i32.const 0)))
+    (local.set 0x138 (i64.load offset=0x138 align=1 (i32.const 0)))
+    (local.set 0x139 (i64.load offset=0x139 align=1 (i32.const 0)))
+    (local.set 0x13a (i64.load offset=0x13a align=1 (i32.const 0)))
+    (local.set 0x13b (i64.load offset=0x13b align=1 (i32.const 0)))
+    (local.set 0x13c (i64.load offset=0x13c align=1 (i32.const 0)))
+    (local.set 0x13d (i64.load offset=0x13d align=1 (i32.const 0)))
+    (local.set 0x13e (i64.load offset=0x13e align=1 (i32.const 0)))
+    (local.set 0x13f (i64.load offset=0x13f align=1 (i32.const 0)))
+    (local.set 0x140 (i64.load offset=0x140 align=1 (i32.const 0)))
+    (local.set 0x141 (i64.load offset=0x141 align=1 (i32.const 0)))
+    (local.set 0x142 (i64.load offset=0x142 align=1 (i32.const 0)))
+    (local.set 0x143 (i64.load offset=0x143 align=1 (i32.const 0)))
+    (local.set 0x144 (i64.load offset=0x144 align=1 (i32.const 0)))
+    (local.set 0x145 (i64.load offset=0x145 align=1 (i32.const 0)))
+    (local.set 0x146 (i64.load offset=0x146 align=1 (i32.const 0)))
+    (local.set 0x147 (i64.load offset=0x147 align=1 (i32.const 0)))
+    (local.set 0x148 (i64.load offset=0x148 align=1 (i32.const 0)))
+    (local.set 0x149 (i64.load offset=0x149 align=1 (i32.const 0)))
+    (local.set 0x14a (i64.load offset=0x14a align=1 (i32.const 0)))
+    (local.set 0x14b (i64.load offset=0x14b align=1 (i32.const 0)))
+    (local.set 0x14c (i64.load offset=0x14c align=1 (i32.const 0)))
+    (local.set 0x14d (i64.load offset=0x14d align=1 (i32.const 0)))
+    (local.set 0x14e (i64.load offset=0x14e align=1 (i32.const 0)))
+    (local.set 0x14f (i64.load offset=0x14f align=1 (i32.const 0)))
+    (local.set 0x150 (i64.load offset=0x150 align=1 (i32.const 0)))
+    (local.set 0x151 (i64.load offset=0x151 align=1 (i32.const 0)))
+    (local.set 0x152 (i64.load offset=0x152 align=1 (i32.const 0)))
+    (local.set 0x153 (i64.load offset=0x153 align=1 (i32.const 0)))
+    (local.set 0x154 (i64.load offset=0x154 align=1 (i32.const 0)))
+    (local.set 0x155 (i64.load offset=0x155 align=1 (i32.const 0)))
+    (local.set 0x156 (i64.load offset=0x156 align=1 (i32.const 0)))
+    (local.set 0x157 (i64.load offset=0x157 align=1 (i32.const 0)))
+    (local.set 0x158 (i64.load offset=0x158 align=1 (i32.const 0)))
+    (local.set 0x159 (i64.load offset=0x159 align=1 (i32.const 0)))
+    (local.set 0x15a (i64.load offset=0x15a align=1 (i32.const 0)))
+    (local.set 0x15b (i64.load offset=0x15b align=1 (i32.const 0)))
+    (local.set 0x15c (i64.load offset=0x15c align=1 (i32.const 0)))
+    (local.set 0x15d (i64.load offset=0x15d align=1 (i32.const 0)))
+    (local.set 0x15e (i64.load offset=0x15e align=1 (i32.const 0)))
+    (local.set 0x15f (i64.load offset=0x15f align=1 (i32.const 0)))
+    (local.set 0x160 (i64.load offset=0x160 align=1 (i32.const 0)))
+    (local.set 0x161 (i64.load offset=0x161 align=1 (i32.const 0)))
+    (local.set 0x162 (i64.load offset=0x162 align=1 (i32.const 0)))
+    (local.set 0x163 (i64.load offset=0x163 align=1 (i32.const 0)))
+    (local.set 0x164 (i64.load offset=0x164 align=1 (i32.const 0)))
+    (local.set 0x165 (i64.load offset=0x165 align=1 (i32.const 0)))
+    (local.set 0x166 (i64.load offset=0x166 align=1 (i32.const 0)))
+    (local.set 0x167 (i64.load offset=0x167 align=1 (i32.const 0)))
+    (local.set 0x168 (i64.load offset=0x168 align=1 (i32.const 0)))
+    (local.set 0x169 (i64.load offset=0x169 align=1 (i32.const 0)))
+    (local.set 0x16a (i64.load offset=0x16a align=1 (i32.const 0)))
+    (local.set 0x16b (i64.load offset=0x16b align=1 (i32.const 0)))
+    (local.set 0x16c (i64.load offset=0x16c align=1 (i32.const 0)))
+    (local.set 0x16d (i64.load offset=0x16d align=1 (i32.const 0)))
+    (local.set 0x16e (i64.load offset=0x16e align=1 (i32.const 0)))
+    (local.set 0x16f (i64.load offset=0x16f align=1 (i32.const 0)))
+    (local.set 0x170 (i64.load offset=0x170 align=1 (i32.const 0)))
+    (local.set 0x171 (i64.load offset=0x171 align=1 (i32.const 0)))
+    (local.set 0x172 (i64.load offset=0x172 align=1 (i32.const 0)))
+    (local.set 0x173 (i64.load offset=0x173 align=1 (i32.const 0)))
+    (local.set 0x174 (i64.load offset=0x174 align=1 (i32.const 0)))
+    (local.set 0x175 (i64.load offset=0x175 align=1 (i32.const 0)))
+    (local.set 0x176 (i64.load offset=0x176 align=1 (i32.const 0)))
+    (local.set 0x177 (i64.load offset=0x177 align=1 (i32.const 0)))
+    (local.set 0x178 (i64.load offset=0x178 align=1 (i32.const 0)))
+    (local.set 0x179 (i64.load offset=0x179 align=1 (i32.const 0)))
+    (local.set 0x17a (i64.load offset=0x17a align=1 (i32.const 0)))
+    (local.set 0x17b (i64.load offset=0x17b align=1 (i32.const 0)))
+    (local.set 0x17c (i64.load offset=0x17c align=1 (i32.const 0)))
+    (local.set 0x17d (i64.load offset=0x17d align=1 (i32.const 0)))
+    (local.set 0x17e (i64.load offset=0x17e align=1 (i32.const 0)))
+    (local.set 0x17f (i64.load offset=0x17f align=1 (i32.const 0)))
+    (local.set 0x180 (i64.load offset=0x180 align=1 (i32.const 0)))
+    (local.set 0x181 (i64.load offset=0x181 align=1 (i32.const 0)))
+    (local.set 0x182 (i64.load offset=0x182 align=1 (i32.const 0)))
+    (local.set 0x183 (i64.load offset=0x183 align=1 (i32.const 0)))
+    (local.set 0x184 (i64.load offset=0x184 align=1 (i32.const 0)))
+    (local.set 0x185 (i64.load offset=0x185 align=1 (i32.const 0)))
+    (local.set 0x186 (i64.load offset=0x186 align=1 (i32.const 0)))
+    (local.set 0x187 (i64.load offset=0x187 align=1 (i32.const 0)))
+    (local.set 0x188 (i64.load offset=0x188 align=1 (i32.const 0)))
+    (local.set 0x189 (i64.load offset=0x189 align=1 (i32.const 0)))
+    (local.set 0x18a (i64.load offset=0x18a align=1 (i32.const 0)))
+    (local.set 0x18b (i64.load offset=0x18b align=1 (i32.const 0)))
+    (local.set 0x18c (i64.load offset=0x18c align=1 (i32.const 0)))
+    (local.set 0x18d (i64.load offset=0x18d align=1 (i32.const 0)))
+    (local.set 0x18e (i64.load offset=0x18e align=1 (i32.const 0)))
+    (local.set 0x18f (i64.load offset=0x18f align=1 (i32.const 0)))
+    (local.set 0x190 (i64.load offset=0x190 align=1 (i32.const 0)))
+    (local.set 0x191 (i64.load offset=0x191 align=1 (i32.const 0)))
+    (local.set 0x192 (i64.load offset=0x192 align=1 (i32.const 0)))
+    (local.set 0x193 (i64.load offset=0x193 align=1 (i32.const 0)))
+    (local.set 0x194 (i64.load offset=0x194 align=1 (i32.const 0)))
+    (local.set 0x195 (i64.load offset=0x195 align=1 (i32.const 0)))
+    (local.set 0x196 (i64.load offset=0x196 align=1 (i32.const 0)))
+    (local.set 0x197 (i64.load offset=0x197 align=1 (i32.const 0)))
+    (local.set 0x198 (i64.load offset=0x198 align=1 (i32.const 0)))
+    (local.set 0x199 (i64.load offset=0x199 align=1 (i32.const 0)))
+    (local.set 0x19a (i64.load offset=0x19a align=1 (i32.const 0)))
+    (local.set 0x19b (i64.load offset=0x19b align=1 (i32.const 0)))
+    (local.set 0x19c (i64.load offset=0x19c align=1 (i32.const 0)))
+    (local.set 0x19d (i64.load offset=0x19d align=1 (i32.const 0)))
+    (local.set 0x19e (i64.load offset=0x19e align=1 (i32.const 0)))
+    (local.set 0x19f (i64.load offset=0x19f align=1 (i32.const 0)))
+    (local.set 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0)))
+    (local.set 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0)))
+    (local.set 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0)))
+    (local.set 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0)))
+    (local.set 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0)))
+    (local.set 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0)))
+    (local.set 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0)))
+    (local.set 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0)))
+    (local.set 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0)))
+    (local.set 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0)))
+    (local.set 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0)))
+    (local.set 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0)))
+    (local.set 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0)))
+    (local.set 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0)))
+    (local.set 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0)))
+    (local.set 0x1af (i64.load offset=0x1af align=1 (i32.const 0)))
+    (local.set 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0)))
+    (local.set 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0)))
+    (local.set 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0)))
+    (local.set 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0)))
+    (local.set 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0)))
+    (local.set 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0)))
+    (local.set 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0)))
+    (local.set 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0)))
+    (local.set 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0)))
+    (local.set 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0)))
+    (local.set 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0)))
+    (local.set 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0)))
+    (local.set 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0)))
+    (local.set 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0)))
+    (local.set 0x1be (i64.load offset=0x1be align=1 (i32.const 0)))
+    (local.set 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0)))
+    (local.set 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0)))
+    (local.set 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0)))
+    (local.set 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0)))
+    (local.set 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0)))
+    (local.set 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0)))
+    (local.set 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0)))
+    (local.set 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0)))
+    (local.set 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0)))
+    (local.set 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0)))
+    (local.set 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0)))
+    (local.set 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0)))
+    (local.set 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0)))
+    (local.set 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0)))
+    (local.set 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0)))
+    (local.set 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0)))
+    (local.set 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0)))
+    (local.set 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0)))
+    (local.set 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0)))
+    (local.set 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0)))
+    (local.set 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0)))
+    (local.set 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0)))
+    (local.set 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0)))
+    (local.set 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0)))
+    (local.set 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0)))
+    (local.set 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0)))
+    (local.set 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0)))
+    (local.set 0x1da (i64.load offset=0x1da align=1 (i32.const 0)))
+    (local.set 0x1db (i64.load offset=0x1db align=1 (i32.const 0)))
+    (local.set 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0)))
+    (local.set 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0)))
+    (local.set 0x1de (i64.load offset=0x1de align=1 (i32.const 0)))
+    (local.set 0x1df (i64.load offset=0x1df align=1 (i32.const 0)))
+    (local.set 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0)))
+    (local.set 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0)))
+    (local.set 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0)))
+    (local.set 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0)))
+    (local.set 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0)))
+    (local.set 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0)))
+    (local.set 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0)))
+    (local.set 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0)))
+    (local.set 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0)))
+    (local.set 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0)))
+    (local.set 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0)))
+    (local.set 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0)))
+    (local.set 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0)))
+    (local.set 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0)))
+    (local.set 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0)))
+    (local.set 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0)))
+    (local.set 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0)))
+    (local.set 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0)))
+    (local.set 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0)))
+    (local.set 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0)))
+    (local.set 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0)))
+    (local.set 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0)))
+    (local.set 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0)))
+    (local.set 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0)))
+    (local.set 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0)))
+    (local.set 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0)))
+    (local.set 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0)))
+    (local.set 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0)))
+    (local.set 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0)))
+    (local.set 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0)))
+    (local.set 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0)))
+    (local.set 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0)))
+    (local.set 0x200 (i64.load offset=0x200 align=1 (i32.const 0)))
+    (local.set 0x201 (i64.load offset=0x201 align=1 (i32.const 0)))
+    (local.set 0x202 (i64.load offset=0x202 align=1 (i32.const 0)))
+    (local.set 0x203 (i64.load offset=0x203 align=1 (i32.const 0)))
+    (local.set 0x204 (i64.load offset=0x204 align=1 (i32.const 0)))
+    (local.set 0x205 (i64.load offset=0x205 align=1 (i32.const 0)))
+    (local.set 0x206 (i64.load offset=0x206 align=1 (i32.const 0)))
+    (local.set 0x207 (i64.load offset=0x207 align=1 (i32.const 0)))
+    (local.set 0x208 (i64.load offset=0x208 align=1 (i32.const 0)))
+    (local.set 0x209 (i64.load offset=0x209 align=1 (i32.const 0)))
+    (local.set 0x20a (i64.load offset=0x20a align=1 (i32.const 0)))
+    (local.set 0x20b (i64.load offset=0x20b align=1 (i32.const 0)))
+    (local.set 0x20c (i64.load offset=0x20c align=1 (i32.const 0)))
+    (local.set 0x20d (i64.load offset=0x20d align=1 (i32.const 0)))
+    (local.set 0x20e (i64.load offset=0x20e align=1 (i32.const 0)))
+    (local.set 0x20f (i64.load offset=0x20f align=1 (i32.const 0)))
+    (local.set 0x210 (i64.load offset=0x210 align=1 (i32.const 0)))
+    (local.set 0x211 (i64.load offset=0x211 align=1 (i32.const 0)))
+    (local.set 0x212 (i64.load offset=0x212 align=1 (i32.const 0)))
+    (local.set 0x213 (i64.load offset=0x213 align=1 (i32.const 0)))
+    (local.set 0x214 (i64.load offset=0x214 align=1 (i32.const 0)))
+    (local.set 0x215 (i64.load offset=0x215 align=1 (i32.const 0)))
+    (local.set 0x216 (i64.load offset=0x216 align=1 (i32.const 0)))
+    (local.set 0x217 (i64.load offset=0x217 align=1 (i32.const 0)))
+    (local.set 0x218 (i64.load offset=0x218 align=1 (i32.const 0)))
+    (local.set 0x219 (i64.load offset=0x219 align=1 (i32.const 0)))
+    (local.set 0x21a (i64.load offset=0x21a align=1 (i32.const 0)))
+    (local.set 0x21b (i64.load offset=0x21b align=1 (i32.const 0)))
+    (local.set 0x21c (i64.load offset=0x21c align=1 (i32.const 0)))
+    (local.set 0x21d (i64.load offset=0x21d align=1 (i32.const 0)))
+    (local.set 0x21e (i64.load offset=0x21e align=1 (i32.const 0)))
+    (local.set 0x21f (i64.load offset=0x21f align=1 (i32.const 0)))
+    (local.set 0x220 (i64.load offset=0x220 align=1 (i32.const 0)))
+    (local.set 0x221 (i64.load offset=0x221 align=1 (i32.const 0)))
+    (local.set 0x222 (i64.load offset=0x222 align=1 (i32.const 0)))
+    (local.set 0x223 (i64.load offset=0x223 align=1 (i32.const 0)))
+    (local.set 0x224 (i64.load offset=0x224 align=1 (i32.const 0)))
+    (local.set 0x225 (i64.load offset=0x225 align=1 (i32.const 0)))
+    (local.set 0x226 (i64.load offset=0x226 align=1 (i32.const 0)))
+    (local.set 0x227 (i64.load offset=0x227 align=1 (i32.const 0)))
+    (local.set 0x228 (i64.load offset=0x228 align=1 (i32.const 0)))
+    (local.set 0x229 (i64.load offset=0x229 align=1 (i32.const 0)))
+    (local.set 0x22a (i64.load offset=0x22a align=1 (i32.const 0)))
+    (local.set 0x22b (i64.load offset=0x22b align=1 (i32.const 0)))
+    (local.set 0x22c (i64.load offset=0x22c align=1 (i32.const 0)))
+    (local.set 0x22d (i64.load offset=0x22d align=1 (i32.const 0)))
+    (local.set 0x22e (i64.load offset=0x22e align=1 (i32.const 0)))
+    (local.set 0x22f (i64.load offset=0x22f align=1 (i32.const 0)))
+    (local.set 0x230 (i64.load offset=0x230 align=1 (i32.const 0)))
+    (local.set 0x231 (i64.load offset=0x231 align=1 (i32.const 0)))
+    (local.set 0x232 (i64.load offset=0x232 align=1 (i32.const 0)))
+    (local.set 0x233 (i64.load offset=0x233 align=1 (i32.const 0)))
+    (local.set 0x234 (i64.load offset=0x234 align=1 (i32.const 0)))
+    (local.set 0x235 (i64.load offset=0x235 align=1 (i32.const 0)))
+    (local.set 0x236 (i64.load offset=0x236 align=1 (i32.const 0)))
+    (local.set 0x237 (i64.load offset=0x237 align=1 (i32.const 0)))
+    (local.set 0x238 (i64.load offset=0x238 align=1 (i32.const 0)))
+    (local.set 0x239 (i64.load offset=0x239 align=1 (i32.const 0)))
+    (local.set 0x23a (i64.load offset=0x23a align=1 (i32.const 0)))
+    (local.set 0x23b (i64.load offset=0x23b align=1 (i32.const 0)))
+    (local.set 0x23c (i64.load offset=0x23c align=1 (i32.const 0)))
+    (local.set 0x23d (i64.load offset=0x23d align=1 (i32.const 0)))
+    (local.set 0x23e (i64.load offset=0x23e align=1 (i32.const 0)))
+    (local.set 0x23f (i64.load offset=0x23f align=1 (i32.const 0)))
+    (local.set 0x240 (i64.load offset=0x240 align=1 (i32.const 0)))
+    (local.set 0x241 (i64.load offset=0x241 align=1 (i32.const 0)))
+    (local.set 0x242 (i64.load offset=0x242 align=1 (i32.const 0)))
+    (local.set 0x243 (i64.load offset=0x243 align=1 (i32.const 0)))
+    (local.set 0x244 (i64.load offset=0x244 align=1 (i32.const 0)))
+    (local.set 0x245 (i64.load offset=0x245 align=1 (i32.const 0)))
+    (local.set 0x246 (i64.load offset=0x246 align=1 (i32.const 0)))
+    (local.set 0x247 (i64.load offset=0x247 align=1 (i32.const 0)))
+    (local.set 0x248 (i64.load offset=0x248 align=1 (i32.const 0)))
+    (local.set 0x249 (i64.load offset=0x249 align=1 (i32.const 0)))
+    (local.set 0x24a (i64.load offset=0x24a align=1 (i32.const 0)))
+    (local.set 0x24b (i64.load offset=0x24b align=1 (i32.const 0)))
+    (local.set 0x24c (i64.load offset=0x24c align=1 (i32.const 0)))
+    (local.set 0x24d (i64.load offset=0x24d align=1 (i32.const 0)))
+    (local.set 0x24e (i64.load offset=0x24e align=1 (i32.const 0)))
+    (local.set 0x24f (i64.load offset=0x24f align=1 (i32.const 0)))
+    (local.set 0x250 (i64.load offset=0x250 align=1 (i32.const 0)))
+    (local.set 0x251 (i64.load offset=0x251 align=1 (i32.const 0)))
+    (local.set 0x252 (i64.load offset=0x252 align=1 (i32.const 0)))
+    (local.set 0x253 (i64.load offset=0x253 align=1 (i32.const 0)))
+    (local.set 0x254 (i64.load offset=0x254 align=1 (i32.const 0)))
+    (local.set 0x255 (i64.load offset=0x255 align=1 (i32.const 0)))
+    (local.set 0x256 (i64.load offset=0x256 align=1 (i32.const 0)))
+    (local.set 0x257 (i64.load offset=0x257 align=1 (i32.const 0)))
+    (local.set 0x258 (i64.load offset=0x258 align=1 (i32.const 0)))
+    (local.set 0x259 (i64.load offset=0x259 align=1 (i32.const 0)))
+    (local.set 0x25a (i64.load offset=0x25a align=1 (i32.const 0)))
+    (local.set 0x25b (i64.load offset=0x25b align=1 (i32.const 0)))
+    (local.set 0x25c (i64.load offset=0x25c align=1 (i32.const 0)))
+    (local.set 0x25d (i64.load offset=0x25d align=1 (i32.const 0)))
+    (local.set 0x25e (i64.load offset=0x25e align=1 (i32.const 0)))
+    (local.set 0x25f (i64.load offset=0x25f align=1 (i32.const 0)))
+    (local.set 0x260 (i64.load offset=0x260 align=1 (i32.const 0)))
+    (local.set 0x261 (i64.load offset=0x261 align=1 (i32.const 0)))
+    (local.set 0x262 (i64.load offset=0x262 align=1 (i32.const 0)))
+    (local.set 0x263 (i64.load offset=0x263 align=1 (i32.const 0)))
+    (local.set 0x264 (i64.load offset=0x264 align=1 (i32.const 0)))
+    (local.set 0x265 (i64.load offset=0x265 align=1 (i32.const 0)))
+    (local.set 0x266 (i64.load offset=0x266 align=1 (i32.const 0)))
+    (local.set 0x267 (i64.load offset=0x267 align=1 (i32.const 0)))
+    (local.set 0x268 (i64.load offset=0x268 align=1 (i32.const 0)))
+    (local.set 0x269 (i64.load offset=0x269 align=1 (i32.const 0)))
+    (local.set 0x26a (i64.load offset=0x26a align=1 (i32.const 0)))
+    (local.set 0x26b (i64.load offset=0x26b align=1 (i32.const 0)))
+    (local.set 0x26c (i64.load offset=0x26c align=1 (i32.const 0)))
+    (local.set 0x26d (i64.load offset=0x26d align=1 (i32.const 0)))
+    (local.set 0x26e (i64.load offset=0x26e align=1 (i32.const 0)))
+    (local.set 0x26f (i64.load offset=0x26f align=1 (i32.const 0)))
+    (local.set 0x270 (i64.load offset=0x270 align=1 (i32.const 0)))
+    (local.set 0x271 (i64.load offset=0x271 align=1 (i32.const 0)))
+    (local.set 0x272 (i64.load offset=0x272 align=1 (i32.const 0)))
+    (local.set 0x273 (i64.load offset=0x273 align=1 (i32.const 0)))
+    (local.set 0x274 (i64.load offset=0x274 align=1 (i32.const 0)))
+    (local.set 0x275 (i64.load offset=0x275 align=1 (i32.const 0)))
+    (local.set 0x276 (i64.load offset=0x276 align=1 (i32.const 0)))
+    (local.set 0x277 (i64.load offset=0x277 align=1 (i32.const 0)))
+    (local.set 0x278 (i64.load offset=0x278 align=1 (i32.const 0)))
+    (local.set 0x279 (i64.load offset=0x279 align=1 (i32.const 0)))
+    (local.set 0x27a (i64.load offset=0x27a align=1 (i32.const 0)))
+    (local.set 0x27b (i64.load offset=0x27b align=1 (i32.const 0)))
+    (local.set 0x27c (i64.load offset=0x27c align=1 (i32.const 0)))
+    (local.set 0x27d (i64.load offset=0x27d align=1 (i32.const 0)))
+    (local.set 0x27e (i64.load offset=0x27e align=1 (i32.const 0)))
+    (local.set 0x27f (i64.load offset=0x27f align=1 (i32.const 0)))
+    (local.set 0x280 (i64.load offset=0x280 align=1 (i32.const 0)))
+    (local.set 0x281 (i64.load offset=0x281 align=1 (i32.const 0)))
+    (local.set 0x282 (i64.load offset=0x282 align=1 (i32.const 0)))
+    (local.set 0x283 (i64.load offset=0x283 align=1 (i32.const 0)))
+    (local.set 0x284 (i64.load offset=0x284 align=1 (i32.const 0)))
+    (local.set 0x285 (i64.load offset=0x285 align=1 (i32.const 0)))
+    (local.set 0x286 (i64.load offset=0x286 align=1 (i32.const 0)))
+    (local.set 0x287 (i64.load offset=0x287 align=1 (i32.const 0)))
+    (local.set 0x288 (i64.load offset=0x288 align=1 (i32.const 0)))
+    (local.set 0x289 (i64.load offset=0x289 align=1 (i32.const 0)))
+    (local.set 0x28a (i64.load offset=0x28a align=1 (i32.const 0)))
+    (local.set 0x28b (i64.load offset=0x28b align=1 (i32.const 0)))
+    (local.set 0x28c (i64.load offset=0x28c align=1 (i32.const 0)))
+    (local.set 0x28d (i64.load offset=0x28d align=1 (i32.const 0)))
+    (local.set 0x28e (i64.load offset=0x28e align=1 (i32.const 0)))
+    (local.set 0x28f (i64.load offset=0x28f align=1 (i32.const 0)))
+    (local.set 0x290 (i64.load offset=0x290 align=1 (i32.const 0)))
+    (local.set 0x291 (i64.load offset=0x291 align=1 (i32.const 0)))
+    (local.set 0x292 (i64.load offset=0x292 align=1 (i32.const 0)))
+    (local.set 0x293 (i64.load offset=0x293 align=1 (i32.const 0)))
+    (local.set 0x294 (i64.load offset=0x294 align=1 (i32.const 0)))
+    (local.set 0x295 (i64.load offset=0x295 align=1 (i32.const 0)))
+    (local.set 0x296 (i64.load offset=0x296 align=1 (i32.const 0)))
+    (local.set 0x297 (i64.load offset=0x297 align=1 (i32.const 0)))
+    (local.set 0x298 (i64.load offset=0x298 align=1 (i32.const 0)))
+    (local.set 0x299 (i64.load offset=0x299 align=1 (i32.const 0)))
+    (local.set 0x29a (i64.load offset=0x29a align=1 (i32.const 0)))
+    (local.set 0x29b (i64.load offset=0x29b align=1 (i32.const 0)))
+    (local.set 0x29c (i64.load offset=0x29c align=1 (i32.const 0)))
+    (local.set 0x29d (i64.load offset=0x29d align=1 (i32.const 0)))
+    (local.set 0x29e (i64.load offset=0x29e align=1 (i32.const 0)))
+    (local.set 0x29f (i64.load offset=0x29f align=1 (i32.const 0)))
+    (local.set 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0)))
+    (local.set 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0)))
+    (local.set 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0)))
+    (local.set 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0)))
+    (local.set 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0)))
+    (local.set 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0)))
+    (local.set 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0)))
+    (local.set 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0)))
+    (local.set 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0)))
+    (local.set 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0)))
+    (local.set 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0)))
+    (local.set 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0)))
+    (local.set 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0)))
+    (local.set 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0)))
+    (local.set 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0)))
+    (local.set 0x2af (i64.load offset=0x2af align=1 (i32.const 0)))
+    (local.set 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0)))
+    (local.set 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0)))
+    (local.set 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0)))
+    (local.set 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0)))
+    (local.set 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0)))
+    (local.set 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0)))
+    (local.set 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0)))
+    (local.set 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0)))
+    (local.set 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0)))
+    (local.set 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0)))
+    (local.set 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0)))
+    (local.set 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0)))
+    (local.set 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0)))
+    (local.set 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0)))
+    (local.set 0x2be (i64.load offset=0x2be align=1 (i32.const 0)))
+    (local.set 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0)))
+    (local.set 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0)))
+    (local.set 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0)))
+    (local.set 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0)))
+    (local.set 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0)))
+    (local.set 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0)))
+    (local.set 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0)))
+    (local.set 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0)))
+    (local.set 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0)))
+    (local.set 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0)))
+    (local.set 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0)))
+    (local.set 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0)))
+    (local.set 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0)))
+    (local.set 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0)))
+    (local.set 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0)))
+    (local.set 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0)))
+    (local.set 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0)))
+    (local.set 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0)))
+    (local.set 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0)))
+    (local.set 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0)))
+    (local.set 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0)))
+    (local.set 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0)))
+    (local.set 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0)))
+    (local.set 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0)))
+    (local.set 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0)))
+    (local.set 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0)))
+    (local.set 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0)))
+    (local.set 0x2da (i64.load offset=0x2da align=1 (i32.const 0)))
+    (local.set 0x2db (i64.load offset=0x2db align=1 (i32.const 0)))
+    (local.set 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0)))
+    (local.set 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0)))
+    (local.set 0x2de (i64.load offset=0x2de align=1 (i32.const 0)))
+    (local.set 0x2df (i64.load offset=0x2df align=1 (i32.const 0)))
+    (local.set 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0)))
+    (local.set 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0)))
+    (local.set 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0)))
+    (local.set 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0)))
+    (local.set 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0)))
+    (local.set 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0)))
+    (local.set 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0)))
+    (local.set 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0)))
+    (local.set 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0)))
+    (local.set 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0)))
+    (local.set 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0)))
+    (local.set 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0)))
+    (local.set 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0)))
+    (local.set 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0)))
+    (local.set 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0)))
+    (local.set 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0)))
+    (local.set 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0)))
+    (local.set 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0)))
+    (local.set 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0)))
+    (local.set 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0)))
+    (local.set 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0)))
+    (local.set 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0)))
+    (local.set 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0)))
+    (local.set 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0)))
+    (local.set 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0)))
+    (local.set 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0)))
+    (local.set 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0)))
+    (local.set 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0)))
+    (local.set 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0)))
+    (local.set 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0)))
+    (local.set 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0)))
+    (local.set 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0)))
+    (local.set 0x300 (i64.load offset=0x300 align=1 (i32.const 0)))
+    (local.set 0x301 (i64.load offset=0x301 align=1 (i32.const 0)))
+    (local.set 0x302 (i64.load offset=0x302 align=1 (i32.const 0)))
+    (local.set 0x303 (i64.load offset=0x303 align=1 (i32.const 0)))
+    (local.set 0x304 (i64.load offset=0x304 align=1 (i32.const 0)))
+    (local.set 0x305 (i64.load offset=0x305 align=1 (i32.const 0)))
+    (local.set 0x306 (i64.load offset=0x306 align=1 (i32.const 0)))
+    (local.set 0x307 (i64.load offset=0x307 align=1 (i32.const 0)))
+    (local.set 0x308 (i64.load offset=0x308 align=1 (i32.const 0)))
+    (local.set 0x309 (i64.load offset=0x309 align=1 (i32.const 0)))
+    (local.set 0x30a (i64.load offset=0x30a align=1 (i32.const 0)))
+    (local.set 0x30b (i64.load offset=0x30b align=1 (i32.const 0)))
+    (local.set 0x30c (i64.load offset=0x30c align=1 (i32.const 0)))
+    (local.set 0x30d (i64.load offset=0x30d align=1 (i32.const 0)))
+    (local.set 0x30e (i64.load offset=0x30e align=1 (i32.const 0)))
+    (local.set 0x30f (i64.load offset=0x30f align=1 (i32.const 0)))
+    (local.set 0x310 (i64.load offset=0x310 align=1 (i32.const 0)))
+    (local.set 0x311 (i64.load offset=0x311 align=1 (i32.const 0)))
+    (local.set 0x312 (i64.load offset=0x312 align=1 (i32.const 0)))
+    (local.set 0x313 (i64.load offset=0x313 align=1 (i32.const 0)))
+    (local.set 0x314 (i64.load offset=0x314 align=1 (i32.const 0)))
+    (local.set 0x315 (i64.load offset=0x315 align=1 (i32.const 0)))
+    (local.set 0x316 (i64.load offset=0x316 align=1 (i32.const 0)))
+    (local.set 0x317 (i64.load offset=0x317 align=1 (i32.const 0)))
+    (local.set 0x318 (i64.load offset=0x318 align=1 (i32.const 0)))
+    (local.set 0x319 (i64.load offset=0x319 align=1 (i32.const 0)))
+    (local.set 0x31a (i64.load offset=0x31a align=1 (i32.const 0)))
+    (local.set 0x31b (i64.load offset=0x31b align=1 (i32.const 0)))
+    (local.set 0x31c (i64.load offset=0x31c align=1 (i32.const 0)))
+    (local.set 0x31d (i64.load offset=0x31d align=1 (i32.const 0)))
+    (local.set 0x31e (i64.load offset=0x31e align=1 (i32.const 0)))
+    (local.set 0x31f (i64.load offset=0x31f align=1 (i32.const 0)))
+    (local.set 0x320 (i64.load offset=0x320 align=1 (i32.const 0)))
+    (local.set 0x321 (i64.load offset=0x321 align=1 (i32.const 0)))
+    (local.set 0x322 (i64.load offset=0x322 align=1 (i32.const 0)))
+    (local.set 0x323 (i64.load offset=0x323 align=1 (i32.const 0)))
+    (local.set 0x324 (i64.load offset=0x324 align=1 (i32.const 0)))
+    (local.set 0x325 (i64.load offset=0x325 align=1 (i32.const 0)))
+    (local.set 0x326 (i64.load offset=0x326 align=1 (i32.const 0)))
+    (local.set 0x327 (i64.load offset=0x327 align=1 (i32.const 0)))
+    (local.set 0x328 (i64.load offset=0x328 align=1 (i32.const 0)))
+    (local.set 0x329 (i64.load offset=0x329 align=1 (i32.const 0)))
+    (local.set 0x32a (i64.load offset=0x32a align=1 (i32.const 0)))
+    (local.set 0x32b (i64.load offset=0x32b align=1 (i32.const 0)))
+    (local.set 0x32c (i64.load offset=0x32c align=1 (i32.const 0)))
+    (local.set 0x32d (i64.load offset=0x32d align=1 (i32.const 0)))
+    (local.set 0x32e (i64.load offset=0x32e align=1 (i32.const 0)))
+    (local.set 0x32f (i64.load offset=0x32f align=1 (i32.const 0)))
+    (local.set 0x330 (i64.load offset=0x330 align=1 (i32.const 0)))
+    (local.set 0x331 (i64.load offset=0x331 align=1 (i32.const 0)))
+    (local.set 0x332 (i64.load offset=0x332 align=1 (i32.const 0)))
+    (local.set 0x333 (i64.load offset=0x333 align=1 (i32.const 0)))
+    (local.set 0x334 (i64.load offset=0x334 align=1 (i32.const 0)))
+    (local.set 0x335 (i64.load offset=0x335 align=1 (i32.const 0)))
+    (local.set 0x336 (i64.load offset=0x336 align=1 (i32.const 0)))
+    (local.set 0x337 (i64.load offset=0x337 align=1 (i32.const 0)))
+    (local.set 0x338 (i64.load offset=0x338 align=1 (i32.const 0)))
+    (local.set 0x339 (i64.load offset=0x339 align=1 (i32.const 0)))
+    (local.set 0x33a (i64.load offset=0x33a align=1 (i32.const 0)))
+    (local.set 0x33b (i64.load offset=0x33b align=1 (i32.const 0)))
+    (local.set 0x33c (i64.load offset=0x33c align=1 (i32.const 0)))
+    (local.set 0x33d (i64.load offset=0x33d align=1 (i32.const 0)))
+    (local.set 0x33e (i64.load offset=0x33e align=1 (i32.const 0)))
+    (local.set 0x33f (i64.load offset=0x33f align=1 (i32.const 0)))
+    (local.set 0x340 (i64.load offset=0x340 align=1 (i32.const 0)))
+    (local.set 0x341 (i64.load offset=0x341 align=1 (i32.const 0)))
+    (local.set 0x342 (i64.load offset=0x342 align=1 (i32.const 0)))
+    (local.set 0x343 (i64.load offset=0x343 align=1 (i32.const 0)))
+    (local.set 0x344 (i64.load offset=0x344 align=1 (i32.const 0)))
+    (local.set 0x345 (i64.load offset=0x345 align=1 (i32.const 0)))
+    (local.set 0x346 (i64.load offset=0x346 align=1 (i32.const 0)))
+    (local.set 0x347 (i64.load offset=0x347 align=1 (i32.const 0)))
+    (local.set 0x348 (i64.load offset=0x348 align=1 (i32.const 0)))
+    (local.set 0x349 (i64.load offset=0x349 align=1 (i32.const 0)))
+    (local.set 0x34a (i64.load offset=0x34a align=1 (i32.const 0)))
+    (local.set 0x34b (i64.load offset=0x34b align=1 (i32.const 0)))
+    (local.set 0x34c (i64.load offset=0x34c align=1 (i32.const 0)))
+    (local.set 0x34d (i64.load offset=0x34d align=1 (i32.const 0)))
+    (local.set 0x34e (i64.load offset=0x34e align=1 (i32.const 0)))
+    (local.set 0x34f (i64.load offset=0x34f align=1 (i32.const 0)))
+    (local.set 0x350 (i64.load offset=0x350 align=1 (i32.const 0)))
+    (local.set 0x351 (i64.load offset=0x351 align=1 (i32.const 0)))
+    (local.set 0x352 (i64.load offset=0x352 align=1 (i32.const 0)))
+    (local.set 0x353 (i64.load offset=0x353 align=1 (i32.const 0)))
+    (local.set 0x354 (i64.load offset=0x354 align=1 (i32.const 0)))
+    (local.set 0x355 (i64.load offset=0x355 align=1 (i32.const 0)))
+    (local.set 0x356 (i64.load offset=0x356 align=1 (i32.const 0)))
+    (local.set 0x357 (i64.load offset=0x357 align=1 (i32.const 0)))
+    (local.set 0x358 (i64.load offset=0x358 align=1 (i32.const 0)))
+    (local.set 0x359 (i64.load offset=0x359 align=1 (i32.const 0)))
+    (local.set 0x35a (i64.load offset=0x35a align=1 (i32.const 0)))
+    (local.set 0x35b (i64.load offset=0x35b align=1 (i32.const 0)))
+    (local.set 0x35c (i64.load offset=0x35c align=1 (i32.const 0)))
+    (local.set 0x35d (i64.load offset=0x35d align=1 (i32.const 0)))
+    (local.set 0x35e (i64.load offset=0x35e align=1 (i32.const 0)))
+    (local.set 0x35f (i64.load offset=0x35f align=1 (i32.const 0)))
+    (local.set 0x360 (i64.load offset=0x360 align=1 (i32.const 0)))
+    (local.set 0x361 (i64.load offset=0x361 align=1 (i32.const 0)))
+    (local.set 0x362 (i64.load offset=0x362 align=1 (i32.const 0)))
+    (local.set 0x363 (i64.load offset=0x363 align=1 (i32.const 0)))
+    (local.set 0x364 (i64.load offset=0x364 align=1 (i32.const 0)))
+    (local.set 0x365 (i64.load offset=0x365 align=1 (i32.const 0)))
+    (local.set 0x366 (i64.load offset=0x366 align=1 (i32.const 0)))
+    (local.set 0x367 (i64.load offset=0x367 align=1 (i32.const 0)))
+    (local.set 0x368 (i64.load offset=0x368 align=1 (i32.const 0)))
+    (local.set 0x369 (i64.load offset=0x369 align=1 (i32.const 0)))
+    (local.set 0x36a (i64.load offset=0x36a align=1 (i32.const 0)))
+    (local.set 0x36b (i64.load offset=0x36b align=1 (i32.const 0)))
+    (local.set 0x36c (i64.load offset=0x36c align=1 (i32.const 0)))
+    (local.set 0x36d (i64.load offset=0x36d align=1 (i32.const 0)))
+    (local.set 0x36e (i64.load offset=0x36e align=1 (i32.const 0)))
+    (local.set 0x36f (i64.load offset=0x36f align=1 (i32.const 0)))
+    (local.set 0x370 (i64.load offset=0x370 align=1 (i32.const 0)))
+    (local.set 0x371 (i64.load offset=0x371 align=1 (i32.const 0)))
+    (local.set 0x372 (i64.load offset=0x372 align=1 (i32.const 0)))
+    (local.set 0x373 (i64.load offset=0x373 align=1 (i32.const 0)))
+    (local.set 0x374 (i64.load offset=0x374 align=1 (i32.const 0)))
+    (local.set 0x375 (i64.load offset=0x375 align=1 (i32.const 0)))
+    (local.set 0x376 (i64.load offset=0x376 align=1 (i32.const 0)))
+    (local.set 0x377 (i64.load offset=0x377 align=1 (i32.const 0)))
+    (local.set 0x378 (i64.load offset=0x378 align=1 (i32.const 0)))
+    (local.set 0x379 (i64.load offset=0x379 align=1 (i32.const 0)))
+    (local.set 0x37a (i64.load offset=0x37a align=1 (i32.const 0)))
+    (local.set 0x37b (i64.load offset=0x37b align=1 (i32.const 0)))
+    (local.set 0x37c (i64.load offset=0x37c align=1 (i32.const 0)))
+    (local.set 0x37d (i64.load offset=0x37d align=1 (i32.const 0)))
+    (local.set 0x37e (i64.load offset=0x37e align=1 (i32.const 0)))
+    (local.set 0x37f (i64.load offset=0x37f align=1 (i32.const 0)))
+    (local.set 0x380 (i64.load offset=0x380 align=1 (i32.const 0)))
+    (local.set 0x381 (i64.load offset=0x381 align=1 (i32.const 0)))
+    (local.set 0x382 (i64.load offset=0x382 align=1 (i32.const 0)))
+    (local.set 0x383 (i64.load offset=0x383 align=1 (i32.const 0)))
+    (local.set 0x384 (i64.load offset=0x384 align=1 (i32.const 0)))
+    (local.set 0x385 (i64.load offset=0x385 align=1 (i32.const 0)))
+    (local.set 0x386 (i64.load offset=0x386 align=1 (i32.const 0)))
+    (local.set 0x387 (i64.load offset=0x387 align=1 (i32.const 0)))
+    (local.set 0x388 (i64.load offset=0x388 align=1 (i32.const 0)))
+    (local.set 0x389 (i64.load offset=0x389 align=1 (i32.const 0)))
+    (local.set 0x38a (i64.load offset=0x38a align=1 (i32.const 0)))
+    (local.set 0x38b (i64.load offset=0x38b align=1 (i32.const 0)))
+    (local.set 0x38c (i64.load offset=0x38c align=1 (i32.const 0)))
+    (local.set 0x38d (i64.load offset=0x38d align=1 (i32.const 0)))
+    (local.set 0x38e (i64.load offset=0x38e align=1 (i32.const 0)))
+    (local.set 0x38f (i64.load offset=0x38f align=1 (i32.const 0)))
+    (local.set 0x390 (i64.load offset=0x390 align=1 (i32.const 0)))
+    (local.set 0x391 (i64.load offset=0x391 align=1 (i32.const 0)))
+    (local.set 0x392 (i64.load offset=0x392 align=1 (i32.const 0)))
+    (local.set 0x393 (i64.load offset=0x393 align=1 (i32.const 0)))
+    (local.set 0x394 (i64.load offset=0x394 align=1 (i32.const 0)))
+    (local.set 0x395 (i64.load offset=0x395 align=1 (i32.const 0)))
+    (local.set 0x396 (i64.load offset=0x396 align=1 (i32.const 0)))
+    (local.set 0x397 (i64.load offset=0x397 align=1 (i32.const 0)))
+    (local.set 0x398 (i64.load offset=0x398 align=1 (i32.const 0)))
+    (local.set 0x399 (i64.load offset=0x399 align=1 (i32.const 0)))
+    (local.set 0x39a (i64.load offset=0x39a align=1 (i32.const 0)))
+    (local.set 0x39b (i64.load offset=0x39b align=1 (i32.const 0)))
+    (local.set 0x39c (i64.load offset=0x39c align=1 (i32.const 0)))
+    (local.set 0x39d (i64.load offset=0x39d align=1 (i32.const 0)))
+    (local.set 0x39e (i64.load offset=0x39e align=1 (i32.const 0)))
+    (local.set 0x39f (i64.load offset=0x39f align=1 (i32.const 0)))
+    (local.set 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0)))
+    (local.set 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0)))
+    (local.set 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0)))
+    (local.set 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0)))
+    (local.set 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0)))
+    (local.set 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0)))
+    (local.set 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0)))
+    (local.set 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0)))
+    (local.set 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0)))
+    (local.set 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0)))
+    (local.set 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0)))
+    (local.set 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0)))
+    (local.set 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0)))
+    (local.set 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0)))
+    (local.set 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0)))
+    (local.set 0x3af (i64.load offset=0x3af align=1 (i32.const 0)))
+    (local.set 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0)))
+    (local.set 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0)))
+    (local.set 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0)))
+    (local.set 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0)))
+    (local.set 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0)))
+    (local.set 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0)))
+    (local.set 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0)))
+    (local.set 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0)))
+    (local.set 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0)))
+    (local.set 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0)))
+    (local.set 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0)))
+    (local.set 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0)))
+    (local.set 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0)))
+    (local.set 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0)))
+    (local.set 0x3be (i64.load offset=0x3be align=1 (i32.const 0)))
+    (local.set 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0)))
+    (local.set 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0)))
+    (local.set 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0)))
+    (local.set 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0)))
+    (local.set 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0)))
+    (local.set 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0)))
+    (local.set 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0)))
+    (local.set 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0)))
+    (local.set 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0)))
+    (local.set 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0)))
+    (local.set 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0)))
+    (local.set 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0)))
+    (local.set 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0)))
+    (local.set 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0)))
+    (local.set 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0)))
+    (local.set 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0)))
+    (local.set 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0)))
+    (local.set 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0)))
+    (local.set 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0)))
+    (local.set 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0)))
+    (local.set 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0)))
+    (local.set 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0)))
+    (local.set 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0)))
+    (local.set 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0)))
+    (local.set 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0)))
+    (local.set 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0)))
+    (local.set 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0)))
+    (local.set 0x3da (i64.load offset=0x3da align=1 (i32.const 0)))
+    (local.set 0x3db (i64.load offset=0x3db align=1 (i32.const 0)))
+    (local.set 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0)))
+    (local.set 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0)))
+    (local.set 0x3de (i64.load offset=0x3de align=1 (i32.const 0)))
+    (local.set 0x3df (i64.load offset=0x3df align=1 (i32.const 0)))
+    (local.set 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0)))
+    (local.set 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0)))
+    (local.set 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0)))
+    (local.set 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0)))
+    (local.set 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0)))
+    (local.set 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0)))
+    (local.set 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0)))
+    (local.set 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0)))
+    (local.set 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0)))
+    (local.set 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0)))
+    (local.set 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0)))
+    (local.set 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0)))
+    (local.set 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0)))
+    (local.set 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0)))
+    (local.set 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0)))
+    (local.set 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0)))
+    (local.set 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0)))
+    (local.set 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0)))
+    (local.set 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0)))
+    (local.set 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0)))
+    (local.set 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0)))
+    (local.set 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0)))
+    (local.set 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0)))
+    (local.set 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0)))
+    (local.set 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0)))
+    (local.set 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0)))
+    (local.set 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0)))
+    (local.set 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0)))
+    (local.set 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0)))
+    (local.set 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0)))
+    (local.set 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0)))
+    (local.set 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0)))
+    (local.set 0x400 (i64.load offset=0x400 align=1 (i32.const 0)))
+    (local.set 0x401 (i64.load offset=0x401 align=1 (i32.const 0)))
+    (local.set 0x402 (i64.load offset=0x402 align=1 (i32.const 0)))
+    (local.set 0x403 (i64.load offset=0x403 align=1 (i32.const 0)))
+    (local.set 0x404 (i64.load offset=0x404 align=1 (i32.const 0)))
+    (local.set 0x405 (i64.load offset=0x405 align=1 (i32.const 0)))
+    (local.set 0x406 (i64.load offset=0x406 align=1 (i32.const 0)))
+    (local.set 0x407 (i64.load offset=0x407 align=1 (i32.const 0)))
+    (local.set 0x408 (i64.load offset=0x408 align=1 (i32.const 0)))
+    (local.set 0x409 (i64.load offset=0x409 align=1 (i32.const 0)))
+    (local.set 0x40a (i64.load offset=0x40a align=1 (i32.const 0)))
+    (local.set 0x40b (i64.load offset=0x40b align=1 (i32.const 0)))
+    (local.set 0x40c (i64.load offset=0x40c align=1 (i32.const 0)))
+    (local.set 0x40d (i64.load offset=0x40d align=1 (i32.const 0)))
+    (local.set 0x40e (i64.load offset=0x40e align=1 (i32.const 0)))
+    (local.set 0x40f (i64.load offset=0x40f align=1 (i32.const 0)))
+    (local.set 0x410 (i64.load offset=0x410 align=1 (i32.const 0)))
+    (local.set 0x411 (i64.load offset=0x411 align=1 (i32.const 0)))
+    (local.set 0x412 (i64.load offset=0x412 align=1 (i32.const 0)))
+    (local.set 0x413 (i64.load offset=0x413 align=1 (i32.const 0)))
+    (local.set 0x414 (i64.load offset=0x414 align=1 (i32.const 0)))
+    (local.set 0x415 (i64.load offset=0x415 align=1 (i32.const 0)))
+    (local.set 0x416 (i64.load offset=0x416 align=1 (i32.const 0)))
+    (local.set 0x417 (i64.load offset=0x417 align=1 (i32.const 0)))
+    (local.set 0x418 (i64.load offset=0x418 align=1 (i32.const 0)))
+    (local.set 0x419 (i64.load offset=0x419 align=1 (i32.const 0)))
+    (local.set 0x41a (i64.load offset=0x41a align=1 (i32.const 0)))
+    (local.set 0x41b (i64.load offset=0x41b align=1 (i32.const 0)))
+    (local.set 0x41c (i64.load offset=0x41c align=1 (i32.const 0)))
+    (local.set 0x41d (i64.load offset=0x41d align=1 (i32.const 0)))
+    (local.set 0x41e (i64.load offset=0x41e align=1 (i32.const 0)))
+    (local.set 0x41f (i64.load offset=0x41f align=1 (i32.const 0)))
+
+    ;; store the locals back to memory
+    (i64.store offset=0x000 align=1 (i32.const 0) (local.get 0x000))
+    (i64.store offset=0x001 align=1 (i32.const 0) (local.get 0x001))
+    (i64.store offset=0x002 align=1 (i32.const 0) (local.get 0x002))
+    (i64.store offset=0x003 align=1 (i32.const 0) (local.get 0x003))
+    (i64.store offset=0x004 align=1 (i32.const 0) (local.get 0x004))
+    (i64.store offset=0x005 align=1 (i32.const 0) (local.get 0x005))
+    (i64.store offset=0x006 align=1 (i32.const 0) (local.get 0x006))
+    (i64.store offset=0x007 align=1 (i32.const 0) (local.get 0x007))
+    (i64.store offset=0x008 align=1 (i32.const 0) (local.get 0x008))
+    (i64.store offset=0x009 align=1 (i32.const 0) (local.get 0x009))
+    (i64.store offset=0x00a align=1 (i32.const 0) (local.get 0x00a))
+    (i64.store offset=0x00b align=1 (i32.const 0) (local.get 0x00b))
+    (i64.store offset=0x00c align=1 (i32.const 0) (local.get 0x00c))
+    (i64.store offset=0x00d align=1 (i32.const 0) (local.get 0x00d))
+    (i64.store offset=0x00e align=1 (i32.const 0) (local.get 0x00e))
+    (i64.store offset=0x00f align=1 (i32.const 0) (local.get 0x00f))
+    (i64.store offset=0x010 align=1 (i32.const 0) (local.get 0x010))
+    (i64.store offset=0x011 align=1 (i32.const 0) (local.get 0x011))
+    (i64.store offset=0x012 align=1 (i32.const 0) (local.get 0x012))
+    (i64.store offset=0x013 align=1 (i32.const 0) (local.get 0x013))
+    (i64.store offset=0x014 align=1 (i32.const 0) (local.get 0x014))
+    (i64.store offset=0x015 align=1 (i32.const 0) (local.get 0x015))
+    (i64.store offset=0x016 align=1 (i32.const 0) (local.get 0x016))
+    (i64.store offset=0x017 align=1 (i32.const 0) (local.get 0x017))
+    (i64.store offset=0x018 align=1 (i32.const 0) (local.get 0x018))
+    (i64.store offset=0x019 align=1 (i32.const 0) (local.get 0x019))
+    (i64.store offset=0x01a align=1 (i32.const 0) (local.get 0x01a))
+    (i64.store offset=0x01b align=1 (i32.const 0) (local.get 0x01b))
+    (i64.store offset=0x01c align=1 (i32.const 0) (local.get 0x01c))
+    (i64.store offset=0x01d align=1 (i32.const 0) (local.get 0x01d))
+    (i64.store offset=0x01e align=1 (i32.const 0) (local.get 0x01e))
+    (i64.store offset=0x01f align=1 (i32.const 0) (local.get 0x01f))
+    (i64.store offset=0x020 align=1 (i32.const 0) (local.get 0x020))
+    (i64.store offset=0x021 align=1 (i32.const 0) (local.get 0x021))
+    (i64.store offset=0x022 align=1 (i32.const 0) (local.get 0x022))
+    (i64.store offset=0x023 align=1 (i32.const 0) (local.get 0x023))
+    (i64.store offset=0x024 align=1 (i32.const 0) (local.get 0x024))
+    (i64.store offset=0x025 align=1 (i32.const 0) (local.get 0x025))
+    (i64.store offset=0x026 align=1 (i32.const 0) (local.get 0x026))
+    (i64.store offset=0x027 align=1 (i32.const 0) (local.get 0x027))
+    (i64.store offset=0x028 align=1 (i32.const 0) (local.get 0x028))
+    (i64.store offset=0x029 align=1 (i32.const 0) (local.get 0x029))
+    (i64.store offset=0x02a align=1 (i32.const 0) (local.get 0x02a))
+    (i64.store offset=0x02b align=1 (i32.const 0) (local.get 0x02b))
+    (i64.store offset=0x02c align=1 (i32.const 0) (local.get 0x02c))
+    (i64.store offset=0x02d align=1 (i32.const 0) (local.get 0x02d))
+    (i64.store offset=0x02e align=1 (i32.const 0) (local.get 0x02e))
+    (i64.store offset=0x02f align=1 (i32.const 0) (local.get 0x02f))
+    (i64.store offset=0x030 align=1 (i32.const 0) (local.get 0x030))
+    (i64.store offset=0x031 align=1 (i32.const 0) (local.get 0x031))
+    (i64.store offset=0x032 align=1 (i32.const 0) (local.get 0x032))
+    (i64.store offset=0x033 align=1 (i32.const 0) (local.get 0x033))
+    (i64.store offset=0x034 align=1 (i32.const 0) (local.get 0x034))
+    (i64.store offset=0x035 align=1 (i32.const 0) (local.get 0x035))
+    (i64.store offset=0x036 align=1 (i32.const 0) (local.get 0x036))
+    (i64.store offset=0x037 align=1 (i32.const 0) (local.get 0x037))
+    (i64.store offset=0x038 align=1 (i32.const 0) (local.get 0x038))
+    (i64.store offset=0x039 align=1 (i32.const 0) (local.get 0x039))
+    (i64.store offset=0x03a align=1 (i32.const 0) (local.get 0x03a))
+    (i64.store offset=0x03b align=1 (i32.const 0) (local.get 0x03b))
+    (i64.store offset=0x03c align=1 (i32.const 0) (local.get 0x03c))
+    (i64.store offset=0x03d align=1 (i32.const 0) (local.get 0x03d))
+    (i64.store offset=0x03e align=1 (i32.const 0) (local.get 0x03e))
+    (i64.store offset=0x03f align=1 (i32.const 0) (local.get 0x03f))
+    (i64.store offset=0x040 align=1 (i32.const 0) (local.get 0x040))
+    (i64.store offset=0x041 align=1 (i32.const 0) (local.get 0x041))
+    (i64.store offset=0x042 align=1 (i32.const 0) (local.get 0x042))
+    (i64.store offset=0x043 align=1 (i32.const 0) (local.get 0x043))
+    (i64.store offset=0x044 align=1 (i32.const 0) (local.get 0x044))
+    (i64.store offset=0x045 align=1 (i32.const 0) (local.get 0x045))
+    (i64.store offset=0x046 align=1 (i32.const 0) (local.get 0x046))
+    (i64.store offset=0x047 align=1 (i32.const 0) (local.get 0x047))
+    (i64.store offset=0x048 align=1 (i32.const 0) (local.get 0x048))
+    (i64.store offset=0x049 align=1 (i32.const 0) (local.get 0x049))
+    (i64.store offset=0x04a align=1 (i32.const 0) (local.get 0x04a))
+    (i64.store offset=0x04b align=1 (i32.const 0) (local.get 0x04b))
+    (i64.store offset=0x04c align=1 (i32.const 0) (local.get 0x04c))
+    (i64.store offset=0x04d align=1 (i32.const 0) (local.get 0x04d))
+    (i64.store offset=0x04e align=1 (i32.const 0) (local.get 0x04e))
+    (i64.store offset=0x04f align=1 (i32.const 0) (local.get 0x04f))
+    (i64.store offset=0x050 align=1 (i32.const 0) (local.get 0x050))
+    (i64.store offset=0x051 align=1 (i32.const 0) (local.get 0x051))
+    (i64.store offset=0x052 align=1 (i32.const 0) (local.get 0x052))
+    (i64.store offset=0x053 align=1 (i32.const 0) (local.get 0x053))
+    (i64.store offset=0x054 align=1 (i32.const 0) (local.get 0x054))
+    (i64.store offset=0x055 align=1 (i32.const 0) (local.get 0x055))
+    (i64.store offset=0x056 align=1 (i32.const 0) (local.get 0x056))
+    (i64.store offset=0x057 align=1 (i32.const 0) (local.get 0x057))
+    (i64.store offset=0x058 align=1 (i32.const 0) (local.get 0x058))
+    (i64.store offset=0x059 align=1 (i32.const 0) (local.get 0x059))
+    (i64.store offset=0x05a align=1 (i32.const 0) (local.get 0x05a))
+    (i64.store offset=0x05b align=1 (i32.const 0) (local.get 0x05b))
+    (i64.store offset=0x05c align=1 (i32.const 0) (local.get 0x05c))
+    (i64.store offset=0x05d align=1 (i32.const 0) (local.get 0x05d))
+    (i64.store offset=0x05e align=1 (i32.const 0) (local.get 0x05e))
+    (i64.store offset=0x05f align=1 (i32.const 0) (local.get 0x05f))
+    (i64.store offset=0x060 align=1 (i32.const 0) (local.get 0x060))
+    (i64.store offset=0x061 align=1 (i32.const 0) (local.get 0x061))
+    (i64.store offset=0x062 align=1 (i32.const 0) (local.get 0x062))
+    (i64.store offset=0x063 align=1 (i32.const 0) (local.get 0x063))
+    (i64.store offset=0x064 align=1 (i32.const 0) (local.get 0x064))
+    (i64.store offset=0x065 align=1 (i32.const 0) (local.get 0x065))
+    (i64.store offset=0x066 align=1 (i32.const 0) (local.get 0x066))
+    (i64.store offset=0x067 align=1 (i32.const 0) (local.get 0x067))
+    (i64.store offset=0x068 align=1 (i32.const 0) (local.get 0x068))
+    (i64.store offset=0x069 align=1 (i32.const 0) (local.get 0x069))
+    (i64.store offset=0x06a align=1 (i32.const 0) (local.get 0x06a))
+    (i64.store offset=0x06b align=1 (i32.const 0) (local.get 0x06b))
+    (i64.store offset=0x06c align=1 (i32.const 0) (local.get 0x06c))
+    (i64.store offset=0x06d align=1 (i32.const 0) (local.get 0x06d))
+    (i64.store offset=0x06e align=1 (i32.const 0) (local.get 0x06e))
+    (i64.store offset=0x06f align=1 (i32.const 0) (local.get 0x06f))
+    (i64.store offset=0x070 align=1 (i32.const 0) (local.get 0x070))
+    (i64.store offset=0x071 align=1 (i32.const 0) (local.get 0x071))
+    (i64.store offset=0x072 align=1 (i32.const 0) (local.get 0x072))
+    (i64.store offset=0x073 align=1 (i32.const 0) (local.get 0x073))
+    (i64.store offset=0x074 align=1 (i32.const 0) (local.get 0x074))
+    (i64.store offset=0x075 align=1 (i32.const 0) (local.get 0x075))
+    (i64.store offset=0x076 align=1 (i32.const 0) (local.get 0x076))
+    (i64.store offset=0x077 align=1 (i32.const 0) (local.get 0x077))
+    (i64.store offset=0x078 align=1 (i32.const 0) (local.get 0x078))
+    (i64.store offset=0x079 align=1 (i32.const 0) (local.get 0x079))
+    (i64.store offset=0x07a align=1 (i32.const 0) (local.get 0x07a))
+    (i64.store offset=0x07b align=1 (i32.const 0) (local.get 0x07b))
+    (i64.store offset=0x07c align=1 (i32.const 0) (local.get 0x07c))
+    (i64.store offset=0x07d align=1 (i32.const 0) (local.get 0x07d))
+    (i64.store offset=0x07e align=1 (i32.const 0) (local.get 0x07e))
+    (i64.store offset=0x07f align=1 (i32.const 0) (local.get 0x07f))
+    (i64.store offset=0x080 align=1 (i32.const 0) (local.get 0x080))
+    (i64.store offset=0x081 align=1 (i32.const 0) (local.get 0x081))
+    (i64.store offset=0x082 align=1 (i32.const 0) (local.get 0x082))
+    (i64.store offset=0x083 align=1 (i32.const 0) (local.get 0x083))
+    (i64.store offset=0x084 align=1 (i32.const 0) (local.get 0x084))
+    (i64.store offset=0x085 align=1 (i32.const 0) (local.get 0x085))
+    (i64.store offset=0x086 align=1 (i32.const 0) (local.get 0x086))
+    (i64.store offset=0x087 align=1 (i32.const 0) (local.get 0x087))
+    (i64.store offset=0x088 align=1 (i32.const 0) (local.get 0x088))
+    (i64.store offset=0x089 align=1 (i32.const 0) (local.get 0x089))
+    (i64.store offset=0x08a align=1 (i32.const 0) (local.get 0x08a))
+    (i64.store offset=0x08b align=1 (i32.const 0) (local.get 0x08b))
+    (i64.store offset=0x08c align=1 (i32.const 0) (local.get 0x08c))
+    (i64.store offset=0x08d align=1 (i32.const 0) (local.get 0x08d))
+    (i64.store offset=0x08e align=1 (i32.const 0) (local.get 0x08e))
+    (i64.store offset=0x08f align=1 (i32.const 0) (local.get 0x08f))
+    (i64.store offset=0x090 align=1 (i32.const 0) (local.get 0x090))
+    (i64.store offset=0x091 align=1 (i32.const 0) (local.get 0x091))
+    (i64.store offset=0x092 align=1 (i32.const 0) (local.get 0x092))
+    (i64.store offset=0x093 align=1 (i32.const 0) (local.get 0x093))
+    (i64.store offset=0x094 align=1 (i32.const 0) (local.get 0x094))
+    (i64.store offset=0x095 align=1 (i32.const 0) (local.get 0x095))
+    (i64.store offset=0x096 align=1 (i32.const 0) (local.get 0x096))
+    (i64.store offset=0x097 align=1 (i32.const 0) (local.get 0x097))
+    (i64.store offset=0x098 align=1 (i32.const 0) (local.get 0x098))
+    (i64.store offset=0x099 align=1 (i32.const 0) (local.get 0x099))
+    (i64.store offset=0x09a align=1 (i32.const 0) (local.get 0x09a))
+    (i64.store offset=0x09b align=1 (i32.const 0) (local.get 0x09b))
+    (i64.store offset=0x09c align=1 (i32.const 0) (local.get 0x09c))
+    (i64.store offset=0x09d align=1 (i32.const 0) (local.get 0x09d))
+    (i64.store offset=0x09e align=1 (i32.const 0) (local.get 0x09e))
+    (i64.store offset=0x09f align=1 (i32.const 0) (local.get 0x09f))
+    (i64.store offset=0x0a0 align=1 (i32.const 0) (local.get 0x0a0))
+    (i64.store offset=0x0a1 align=1 (i32.const 0) (local.get 0x0a1))
+    (i64.store offset=0x0a2 align=1 (i32.const 0) (local.get 0x0a2))
+    (i64.store offset=0x0a3 align=1 (i32.const 0) (local.get 0x0a3))
+    (i64.store offset=0x0a4 align=1 (i32.const 0) (local.get 0x0a4))
+    (i64.store offset=0x0a5 align=1 (i32.const 0) (local.get 0x0a5))
+    (i64.store offset=0x0a6 align=1 (i32.const 0) (local.get 0x0a6))
+    (i64.store offset=0x0a7 align=1 (i32.const 0) (local.get 0x0a7))
+    (i64.store offset=0x0a8 align=1 (i32.const 0) (local.get 0x0a8))
+    (i64.store offset=0x0a9 align=1 (i32.const 0) (local.get 0x0a9))
+    (i64.store offset=0x0aa align=1 (i32.const 0) (local.get 0x0aa))
+    (i64.store offset=0x0ab align=1 (i32.const 0) (local.get 0x0ab))
+    (i64.store offset=0x0ac align=1 (i32.const 0) (local.get 0x0ac))
+    (i64.store offset=0x0ad align=1 (i32.const 0) (local.get 0x0ad))
+    (i64.store offset=0x0ae align=1 (i32.const 0) (local.get 0x0ae))
+    (i64.store offset=0x0af align=1 (i32.const 0) (local.get 0x0af))
+    (i64.store offset=0x0b0 align=1 (i32.const 0) (local.get 0x0b0))
+    (i64.store offset=0x0b1 align=1 (i32.const 0) (local.get 0x0b1))
+    (i64.store offset=0x0b2 align=1 (i32.const 0) (local.get 0x0b2))
+    (i64.store offset=0x0b3 align=1 (i32.const 0) (local.get 0x0b3))
+    (i64.store offset=0x0b4 align=1 (i32.const 0) (local.get 0x0b4))
+    (i64.store offset=0x0b5 align=1 (i32.const 0) (local.get 0x0b5))
+    (i64.store offset=0x0b6 align=1 (i32.const 0) (local.get 0x0b6))
+    (i64.store offset=0x0b7 align=1 (i32.const 0) (local.get 0x0b7))
+    (i64.store offset=0x0b8 align=1 (i32.const 0) (local.get 0x0b8))
+    (i64.store offset=0x0b9 align=1 (i32.const 0) (local.get 0x0b9))
+    (i64.store offset=0x0ba align=1 (i32.const 0) (local.get 0x0ba))
+    (i64.store offset=0x0bb align=1 (i32.const 0) (local.get 0x0bb))
+    (i64.store offset=0x0bc align=1 (i32.const 0) (local.get 0x0bc))
+    (i64.store offset=0x0bd align=1 (i32.const 0) (local.get 0x0bd))
+    (i64.store offset=0x0be align=1 (i32.const 0) (local.get 0x0be))
+    (i64.store offset=0x0bf align=1 (i32.const 0) (local.get 0x0bf))
+    (i64.store offset=0x0c0 align=1 (i32.const 0) (local.get 0x0c0))
+    (i64.store offset=0x0c1 align=1 (i32.const 0) (local.get 0x0c1))
+    (i64.store offset=0x0c2 align=1 (i32.const 0) (local.get 0x0c2))
+    (i64.store offset=0x0c3 align=1 (i32.const 0) (local.get 0x0c3))
+    (i64.store offset=0x0c4 align=1 (i32.const 0) (local.get 0x0c4))
+    (i64.store offset=0x0c5 align=1 (i32.const 0) (local.get 0x0c5))
+    (i64.store offset=0x0c6 align=1 (i32.const 0) (local.get 0x0c6))
+    (i64.store offset=0x0c7 align=1 (i32.const 0) (local.get 0x0c7))
+    (i64.store offset=0x0c8 align=1 (i32.const 0) (local.get 0x0c8))
+    (i64.store offset=0x0c9 align=1 (i32.const 0) (local.get 0x0c9))
+    (i64.store offset=0x0ca align=1 (i32.const 0) (local.get 0x0ca))
+    (i64.store offset=0x0cb align=1 (i32.const 0) (local.get 0x0cb))
+    (i64.store offset=0x0cc align=1 (i32.const 0) (local.get 0x0cc))
+    (i64.store offset=0x0cd align=1 (i32.const 0) (local.get 0x0cd))
+    (i64.store offset=0x0ce align=1 (i32.const 0) (local.get 0x0ce))
+    (i64.store offset=0x0cf align=1 (i32.const 0) (local.get 0x0cf))
+    (i64.store offset=0x0d0 align=1 (i32.const 0) (local.get 0x0d0))
+    (i64.store offset=0x0d1 align=1 (i32.const 0) (local.get 0x0d1))
+    (i64.store offset=0x0d2 align=1 (i32.const 0) (local.get 0x0d2))
+    (i64.store offset=0x0d3 align=1 (i32.const 0) (local.get 0x0d3))
+    (i64.store offset=0x0d4 align=1 (i32.const 0) (local.get 0x0d4))
+    (i64.store offset=0x0d5 align=1 (i32.const 0) (local.get 0x0d5))
+    (i64.store offset=0x0d6 align=1 (i32.const 0) (local.get 0x0d6))
+    (i64.store offset=0x0d7 align=1 (i32.const 0) (local.get 0x0d7))
+    (i64.store offset=0x0d8 align=1 (i32.const 0) (local.get 0x0d8))
+    (i64.store offset=0x0d9 align=1 (i32.const 0) (local.get 0x0d9))
+    (i64.store offset=0x0da align=1 (i32.const 0) (local.get 0x0da))
+    (i64.store offset=0x0db align=1 (i32.const 0) (local.get 0x0db))
+    (i64.store offset=0x0dc align=1 (i32.const 0) (local.get 0x0dc))
+    (i64.store offset=0x0dd align=1 (i32.const 0) (local.get 0x0dd))
+    (i64.store offset=0x0de align=1 (i32.const 0) (local.get 0x0de))
+    (i64.store offset=0x0df align=1 (i32.const 0) (local.get 0x0df))
+    (i64.store offset=0x0e0 align=1 (i32.const 0) (local.get 0x0e0))
+    (i64.store offset=0x0e1 align=1 (i32.const 0) (local.get 0x0e1))
+    (i64.store offset=0x0e2 align=1 (i32.const 0) (local.get 0x0e2))
+    (i64.store offset=0x0e3 align=1 (i32.const 0) (local.get 0x0e3))
+    (i64.store offset=0x0e4 align=1 (i32.const 0) (local.get 0x0e4))
+    (i64.store offset=0x0e5 align=1 (i32.const 0) (local.get 0x0e5))
+    (i64.store offset=0x0e6 align=1 (i32.const 0) (local.get 0x0e6))
+    (i64.store offset=0x0e7 align=1 (i32.const 0) (local.get 0x0e7))
+    (i64.store offset=0x0e8 align=1 (i32.const 0) (local.get 0x0e8))
+    (i64.store offset=0x0e9 align=1 (i32.const 0) (local.get 0x0e9))
+    (i64.store offset=0x0ea align=1 (i32.const 0) (local.get 0x0ea))
+    (i64.store offset=0x0eb align=1 (i32.const 0) (local.get 0x0eb))
+    (i64.store offset=0x0ec align=1 (i32.const 0) (local.get 0x0ec))
+    (i64.store offset=0x0ed align=1 (i32.const 0) (local.get 0x0ed))
+    (i64.store offset=0x0ee align=1 (i32.const 0) (local.get 0x0ee))
+    (i64.store offset=0x0ef align=1 (i32.const 0) (local.get 0x0ef))
+    (i64.store offset=0x0f0 align=1 (i32.const 0) (local.get 0x0f0))
+    (i64.store offset=0x0f1 align=1 (i32.const 0) (local.get 0x0f1))
+    (i64.store offset=0x0f2 align=1 (i32.const 0) (local.get 0x0f2))
+    (i64.store offset=0x0f3 align=1 (i32.const 0) (local.get 0x0f3))
+    (i64.store offset=0x0f4 align=1 (i32.const 0) (local.get 0x0f4))
+    (i64.store offset=0x0f5 align=1 (i32.const 0) (local.get 0x0f5))
+    (i64.store offset=0x0f6 align=1 (i32.const 0) (local.get 0x0f6))
+    (i64.store offset=0x0f7 align=1 (i32.const 0) (local.get 0x0f7))
+    (i64.store offset=0x0f8 align=1 (i32.const 0) (local.get 0x0f8))
+    (i64.store offset=0x0f9 align=1 (i32.const 0) (local.get 0x0f9))
+    (i64.store offset=0x0fa align=1 (i32.const 0) (local.get 0x0fa))
+    (i64.store offset=0x0fb align=1 (i32.const 0) (local.get 0x0fb))
+    (i64.store offset=0x0fc align=1 (i32.const 0) (local.get 0x0fc))
+    (i64.store offset=0x0fd align=1 (i32.const 0) (local.get 0x0fd))
+    (i64.store offset=0x0fe align=1 (i32.const 0) (local.get 0x0fe))
+    (i64.store offset=0x0ff align=1 (i32.const 0) (local.get 0x0ff))
+    (i64.store offset=0x100 align=1 (i32.const 0) (local.get 0x100))
+    (i64.store offset=0x101 align=1 (i32.const 0) (local.get 0x101))
+    (i64.store offset=0x102 align=1 (i32.const 0) (local.get 0x102))
+    (i64.store offset=0x103 align=1 (i32.const 0) (local.get 0x103))
+    (i64.store offset=0x104 align=1 (i32.const 0) (local.get 0x104))
+    (i64.store offset=0x105 align=1 (i32.const 0) (local.get 0x105))
+    (i64.store offset=0x106 align=1 (i32.const 0) (local.get 0x106))
+    (i64.store offset=0x107 align=1 (i32.const 0) (local.get 0x107))
+    (i64.store offset=0x108 align=1 (i32.const 0) (local.get 0x108))
+    (i64.store offset=0x109 align=1 (i32.const 0) (local.get 0x109))
+    (i64.store offset=0x10a align=1 (i32.const 0) (local.get 0x10a))
+    (i64.store offset=0x10b align=1 (i32.const 0) (local.get 0x10b))
+    (i64.store offset=0x10c align=1 (i32.const 0) (local.get 0x10c))
+    (i64.store offset=0x10d align=1 (i32.const 0) (local.get 0x10d))
+    (i64.store offset=0x10e align=1 (i32.const 0) (local.get 0x10e))
+    (i64.store offset=0x10f align=1 (i32.const 0) (local.get 0x10f))
+    (i64.store offset=0x110 align=1 (i32.const 0) (local.get 0x110))
+    (i64.store offset=0x111 align=1 (i32.const 0) (local.get 0x111))
+    (i64.store offset=0x112 align=1 (i32.const 0) (local.get 0x112))
+    (i64.store offset=0x113 align=1 (i32.const 0) (local.get 0x113))
+    (i64.store offset=0x114 align=1 (i32.const 0) (local.get 0x114))
+    (i64.store offset=0x115 align=1 (i32.const 0) (local.get 0x115))
+    (i64.store offset=0x116 align=1 (i32.const 0) (local.get 0x116))
+    (i64.store offset=0x117 align=1 (i32.const 0) (local.get 0x117))
+    (i64.store offset=0x118 align=1 (i32.const 0) (local.get 0x118))
+    (i64.store offset=0x119 align=1 (i32.const 0) (local.get 0x119))
+    (i64.store offset=0x11a align=1 (i32.const 0) (local.get 0x11a))
+    (i64.store offset=0x11b align=1 (i32.const 0) (local.get 0x11b))
+    (i64.store offset=0x11c align=1 (i32.const 0) (local.get 0x11c))
+    (i64.store offset=0x11d align=1 (i32.const 0) (local.get 0x11d))
+    (i64.store offset=0x11e align=1 (i32.const 0) (local.get 0x11e))
+    (i64.store offset=0x11f align=1 (i32.const 0) (local.get 0x11f))
+    (i64.store offset=0x120 align=1 (i32.const 0) (local.get 0x120))
+    (i64.store offset=0x121 align=1 (i32.const 0) (local.get 0x121))
+    (i64.store offset=0x122 align=1 (i32.const 0) (local.get 0x122))
+    (i64.store offset=0x123 align=1 (i32.const 0) (local.get 0x123))
+    (i64.store offset=0x124 align=1 (i32.const 0) (local.get 0x124))
+    (i64.store offset=0x125 align=1 (i32.const 0) (local.get 0x125))
+    (i64.store offset=0x126 align=1 (i32.const 0) (local.get 0x126))
+    (i64.store offset=0x127 align=1 (i32.const 0) (local.get 0x127))
+    (i64.store offset=0x128 align=1 (i32.const 0) (local.get 0x128))
+    (i64.store offset=0x129 align=1 (i32.const 0) (local.get 0x129))
+    (i64.store offset=0x12a align=1 (i32.const 0) (local.get 0x12a))
+    (i64.store offset=0x12b align=1 (i32.const 0) (local.get 0x12b))
+    (i64.store offset=0x12c align=1 (i32.const 0) (local.get 0x12c))
+    (i64.store offset=0x12d align=1 (i32.const 0) (local.get 0x12d))
+    (i64.store offset=0x12e align=1 (i32.const 0) (local.get 0x12e))
+    (i64.store offset=0x12f align=1 (i32.const 0) (local.get 0x12f))
+    (i64.store offset=0x130 align=1 (i32.const 0) (local.get 0x130))
+    (i64.store offset=0x131 align=1 (i32.const 0) (local.get 0x131))
+    (i64.store offset=0x132 align=1 (i32.const 0) (local.get 0x132))
+    (i64.store offset=0x133 align=1 (i32.const 0) (local.get 0x133))
+    (i64.store offset=0x134 align=1 (i32.const 0) (local.get 0x134))
+    (i64.store offset=0x135 align=1 (i32.const 0) (local.get 0x135))
+    (i64.store offset=0x136 align=1 (i32.const 0) (local.get 0x136))
+    (i64.store offset=0x137 align=1 (i32.const 0) (local.get 0x137))
+    (i64.store offset=0x138 align=1 (i32.const 0) (local.get 0x138))
+    (i64.store offset=0x139 align=1 (i32.const 0) (local.get 0x139))
+    (i64.store offset=0x13a align=1 (i32.const 0) (local.get 0x13a))
+    (i64.store offset=0x13b align=1 (i32.const 0) (local.get 0x13b))
+    (i64.store offset=0x13c align=1 (i32.const 0) (local.get 0x13c))
+    (i64.store offset=0x13d align=1 (i32.const 0) (local.get 0x13d))
+    (i64.store offset=0x13e align=1 (i32.const 0) (local.get 0x13e))
+    (i64.store offset=0x13f align=1 (i32.const 0) (local.get 0x13f))
+    (i64.store offset=0x140 align=1 (i32.const 0) (local.get 0x140))
+    (i64.store offset=0x141 align=1 (i32.const 0) (local.get 0x141))
+    (i64.store offset=0x142 align=1 (i32.const 0) (local.get 0x142))
+    (i64.store offset=0x143 align=1 (i32.const 0) (local.get 0x143))
+    (i64.store offset=0x144 align=1 (i32.const 0) (local.get 0x144))
+    (i64.store offset=0x145 align=1 (i32.const 0) (local.get 0x145))
+    (i64.store offset=0x146 align=1 (i32.const 0) (local.get 0x146))
+    (i64.store offset=0x147 align=1 (i32.const 0) (local.get 0x147))
+    (i64.store offset=0x148 align=1 (i32.const 0) (local.get 0x148))
+    (i64.store offset=0x149 align=1 (i32.const 0) (local.get 0x149))
+    (i64.store offset=0x14a align=1 (i32.const 0) (local.get 0x14a))
+    (i64.store offset=0x14b align=1 (i32.const 0) (local.get 0x14b))
+    (i64.store offset=0x14c align=1 (i32.const 0) (local.get 0x14c))
+    (i64.store offset=0x14d align=1 (i32.const 0) (local.get 0x14d))
+    (i64.store offset=0x14e align=1 (i32.const 0) (local.get 0x14e))
+    (i64.store offset=0x14f align=1 (i32.const 0) (local.get 0x14f))
+    (i64.store offset=0x150 align=1 (i32.const 0) (local.get 0x150))
+    (i64.store offset=0x151 align=1 (i32.const 0) (local.get 0x151))
+    (i64.store offset=0x152 align=1 (i32.const 0) (local.get 0x152))
+    (i64.store offset=0x153 align=1 (i32.const 0) (local.get 0x153))
+    (i64.store offset=0x154 align=1 (i32.const 0) (local.get 0x154))
+    (i64.store offset=0x155 align=1 (i32.const 0) (local.get 0x155))
+    (i64.store offset=0x156 align=1 (i32.const 0) (local.get 0x156))
+    (i64.store offset=0x157 align=1 (i32.const 0) (local.get 0x157))
+    (i64.store offset=0x158 align=1 (i32.const 0) (local.get 0x158))
+    (i64.store offset=0x159 align=1 (i32.const 0) (local.get 0x159))
+    (i64.store offset=0x15a align=1 (i32.const 0) (local.get 0x15a))
+    (i64.store offset=0x15b align=1 (i32.const 0) (local.get 0x15b))
+    (i64.store offset=0x15c align=1 (i32.const 0) (local.get 0x15c))
+    (i64.store offset=0x15d align=1 (i32.const 0) (local.get 0x15d))
+    (i64.store offset=0x15e align=1 (i32.const 0) (local.get 0x15e))
+    (i64.store offset=0x15f align=1 (i32.const 0) (local.get 0x15f))
+    (i64.store offset=0x160 align=1 (i32.const 0) (local.get 0x160))
+    (i64.store offset=0x161 align=1 (i32.const 0) (local.get 0x161))
+    (i64.store offset=0x162 align=1 (i32.const 0) (local.get 0x162))
+    (i64.store offset=0x163 align=1 (i32.const 0) (local.get 0x163))
+    (i64.store offset=0x164 align=1 (i32.const 0) (local.get 0x164))
+    (i64.store offset=0x165 align=1 (i32.const 0) (local.get 0x165))
+    (i64.store offset=0x166 align=1 (i32.const 0) (local.get 0x166))
+    (i64.store offset=0x167 align=1 (i32.const 0) (local.get 0x167))
+    (i64.store offset=0x168 align=1 (i32.const 0) (local.get 0x168))
+    (i64.store offset=0x169 align=1 (i32.const 0) (local.get 0x169))
+    (i64.store offset=0x16a align=1 (i32.const 0) (local.get 0x16a))
+    (i64.store offset=0x16b align=1 (i32.const 0) (local.get 0x16b))
+    (i64.store offset=0x16c align=1 (i32.const 0) (local.get 0x16c))
+    (i64.store offset=0x16d align=1 (i32.const 0) (local.get 0x16d))
+    (i64.store offset=0x16e align=1 (i32.const 0) (local.get 0x16e))
+    (i64.store offset=0x16f align=1 (i32.const 0) (local.get 0x16f))
+    (i64.store offset=0x170 align=1 (i32.const 0) (local.get 0x170))
+    (i64.store offset=0x171 align=1 (i32.const 0) (local.get 0x171))
+    (i64.store offset=0x172 align=1 (i32.const 0) (local.get 0x172))
+    (i64.store offset=0x173 align=1 (i32.const 0) (local.get 0x173))
+    (i64.store offset=0x174 align=1 (i32.const 0) (local.get 0x174))
+    (i64.store offset=0x175 align=1 (i32.const 0) (local.get 0x175))
+    (i64.store offset=0x176 align=1 (i32.const 0) (local.get 0x176))
+    (i64.store offset=0x177 align=1 (i32.const 0) (local.get 0x177))
+    (i64.store offset=0x178 align=1 (i32.const 0) (local.get 0x178))
+    (i64.store offset=0x179 align=1 (i32.const 0) (local.get 0x179))
+    (i64.store offset=0x17a align=1 (i32.const 0) (local.get 0x17a))
+    (i64.store offset=0x17b align=1 (i32.const 0) (local.get 0x17b))
+    (i64.store offset=0x17c align=1 (i32.const 0) (local.get 0x17c))
+    (i64.store offset=0x17d align=1 (i32.const 0) (local.get 0x17d))
+    (i64.store offset=0x17e align=1 (i32.const 0) (local.get 0x17e))
+    (i64.store offset=0x17f align=1 (i32.const 0) (local.get 0x17f))
+    (i64.store offset=0x180 align=1 (i32.const 0) (local.get 0x180))
+    (i64.store offset=0x181 align=1 (i32.const 0) (local.get 0x181))
+    (i64.store offset=0x182 align=1 (i32.const 0) (local.get 0x182))
+    (i64.store offset=0x183 align=1 (i32.const 0) (local.get 0x183))
+    (i64.store offset=0x184 align=1 (i32.const 0) (local.get 0x184))
+    (i64.store offset=0x185 align=1 (i32.const 0) (local.get 0x185))
+    (i64.store offset=0x186 align=1 (i32.const 0) (local.get 0x186))
+    (i64.store offset=0x187 align=1 (i32.const 0) (local.get 0x187))
+    (i64.store offset=0x188 align=1 (i32.const 0) (local.get 0x188))
+    (i64.store offset=0x189 align=1 (i32.const 0) (local.get 0x189))
+    (i64.store offset=0x18a align=1 (i32.const 0) (local.get 0x18a))
+    (i64.store offset=0x18b align=1 (i32.const 0) (local.get 0x18b))
+    (i64.store offset=0x18c align=1 (i32.const 0) (local.get 0x18c))
+    (i64.store offset=0x18d align=1 (i32.const 0) (local.get 0x18d))
+    (i64.store offset=0x18e align=1 (i32.const 0) (local.get 0x18e))
+    (i64.store offset=0x18f align=1 (i32.const 0) (local.get 0x18f))
+    (i64.store offset=0x190 align=1 (i32.const 0) (local.get 0x190))
+    (i64.store offset=0x191 align=1 (i32.const 0) (local.get 0x191))
+    (i64.store offset=0x192 align=1 (i32.const 0) (local.get 0x192))
+    (i64.store offset=0x193 align=1 (i32.const 0) (local.get 0x193))
+    (i64.store offset=0x194 align=1 (i32.const 0) (local.get 0x194))
+    (i64.store offset=0x195 align=1 (i32.const 0) (local.get 0x195))
+    (i64.store offset=0x196 align=1 (i32.const 0) (local.get 0x196))
+    (i64.store offset=0x197 align=1 (i32.const 0) (local.get 0x197))
+    (i64.store offset=0x198 align=1 (i32.const 0) (local.get 0x198))
+    (i64.store offset=0x199 align=1 (i32.const 0) (local.get 0x199))
+    (i64.store offset=0x19a align=1 (i32.const 0) (local.get 0x19a))
+    (i64.store offset=0x19b align=1 (i32.const 0) (local.get 0x19b))
+    (i64.store offset=0x19c align=1 (i32.const 0) (local.get 0x19c))
+    (i64.store offset=0x19d align=1 (i32.const 0) (local.get 0x19d))
+    (i64.store offset=0x19e align=1 (i32.const 0) (local.get 0x19e))
+    (i64.store offset=0x19f align=1 (i32.const 0) (local.get 0x19f))
+    (i64.store offset=0x1a0 align=1 (i32.const 0) (local.get 0x1a0))
+    (i64.store offset=0x1a1 align=1 (i32.const 0) (local.get 0x1a1))
+    (i64.store offset=0x1a2 align=1 (i32.const 0) (local.get 0x1a2))
+    (i64.store offset=0x1a3 align=1 (i32.const 0) (local.get 0x1a3))
+    (i64.store offset=0x1a4 align=1 (i32.const 0) (local.get 0x1a4))
+    (i64.store offset=0x1a5 align=1 (i32.const 0) (local.get 0x1a5))
+    (i64.store offset=0x1a6 align=1 (i32.const 0) (local.get 0x1a6))
+    (i64.store offset=0x1a7 align=1 (i32.const 0) (local.get 0x1a7))
+    (i64.store offset=0x1a8 align=1 (i32.const 0) (local.get 0x1a8))
+    (i64.store offset=0x1a9 align=1 (i32.const 0) (local.get 0x1a9))
+    (i64.store offset=0x1aa align=1 (i32.const 0) (local.get 0x1aa))
+    (i64.store offset=0x1ab align=1 (i32.const 0) (local.get 0x1ab))
+    (i64.store offset=0x1ac align=1 (i32.const 0) (local.get 0x1ac))
+    (i64.store offset=0x1ad align=1 (i32.const 0) (local.get 0x1ad))
+    (i64.store offset=0x1ae align=1 (i32.const 0) (local.get 0x1ae))
+    (i64.store offset=0x1af align=1 (i32.const 0) (local.get 0x1af))
+    (i64.store offset=0x1b0 align=1 (i32.const 0) (local.get 0x1b0))
+    (i64.store offset=0x1b1 align=1 (i32.const 0) (local.get 0x1b1))
+    (i64.store offset=0x1b2 align=1 (i32.const 0) (local.get 0x1b2))
+    (i64.store offset=0x1b3 align=1 (i32.const 0) (local.get 0x1b3))
+    (i64.store offset=0x1b4 align=1 (i32.const 0) (local.get 0x1b4))
+    (i64.store offset=0x1b5 align=1 (i32.const 0) (local.get 0x1b5))
+    (i64.store offset=0x1b6 align=1 (i32.const 0) (local.get 0x1b6))
+    (i64.store offset=0x1b7 align=1 (i32.const 0) (local.get 0x1b7))
+    (i64.store offset=0x1b8 align=1 (i32.const 0) (local.get 0x1b8))
+    (i64.store offset=0x1b9 align=1 (i32.const 0) (local.get 0x1b9))
+    (i64.store offset=0x1ba align=1 (i32.const 0) (local.get 0x1ba))
+    (i64.store offset=0x1bb align=1 (i32.const 0) (local.get 0x1bb))
+    (i64.store offset=0x1bc align=1 (i32.const 0) (local.get 0x1bc))
+    (i64.store offset=0x1bd align=1 (i32.const 0) (local.get 0x1bd))
+    (i64.store offset=0x1be align=1 (i32.const 0) (local.get 0x1be))
+    (i64.store offset=0x1bf align=1 (i32.const 0) (local.get 0x1bf))
+    (i64.store offset=0x1c0 align=1 (i32.const 0) (local.get 0x1c0))
+    (i64.store offset=0x1c1 align=1 (i32.const 0) (local.get 0x1c1))
+    (i64.store offset=0x1c2 align=1 (i32.const 0) (local.get 0x1c2))
+    (i64.store offset=0x1c3 align=1 (i32.const 0) (local.get 0x1c3))
+    (i64.store offset=0x1c4 align=1 (i32.const 0) (local.get 0x1c4))
+    (i64.store offset=0x1c5 align=1 (i32.const 0) (local.get 0x1c5))
+    (i64.store offset=0x1c6 align=1 (i32.const 0) (local.get 0x1c6))
+    (i64.store offset=0x1c7 align=1 (i32.const 0) (local.get 0x1c7))
+    (i64.store offset=0x1c8 align=1 (i32.const 0) (local.get 0x1c8))
+    (i64.store offset=0x1c9 align=1 (i32.const 0) (local.get 0x1c9))
+    (i64.store offset=0x1ca align=1 (i32.const 0) (local.get 0x1ca))
+    (i64.store offset=0x1cb align=1 (i32.const 0) (local.get 0x1cb))
+    (i64.store offset=0x1cc align=1 (i32.const 0) (local.get 0x1cc))
+    (i64.store offset=0x1cd align=1 (i32.const 0) (local.get 0x1cd))
+    (i64.store offset=0x1ce align=1 (i32.const 0) (local.get 0x1ce))
+    (i64.store offset=0x1cf align=1 (i32.const 0) (local.get 0x1cf))
+    (i64.store offset=0x1d0 align=1 (i32.const 0) (local.get 0x1d0))
+    (i64.store offset=0x1d1 align=1 (i32.const 0) (local.get 0x1d1))
+    (i64.store offset=0x1d2 align=1 (i32.const 0) (local.get 0x1d2))
+    (i64.store offset=0x1d3 align=1 (i32.const 0) (local.get 0x1d3))
+    (i64.store offset=0x1d4 align=1 (i32.const 0) (local.get 0x1d4))
+    (i64.store offset=0x1d5 align=1 (i32.const 0) (local.get 0x1d5))
+    (i64.store offset=0x1d6 align=1 (i32.const 0) (local.get 0x1d6))
+    (i64.store offset=0x1d7 align=1 (i32.const 0) (local.get 0x1d7))
+    (i64.store offset=0x1d8 align=1 (i32.const 0) (local.get 0x1d8))
+    (i64.store offset=0x1d9 align=1 (i32.const 0) (local.get 0x1d9))
+    (i64.store offset=0x1da align=1 (i32.const 0) (local.get 0x1da))
+    (i64.store offset=0x1db align=1 (i32.const 0) (local.get 0x1db))
+    (i64.store offset=0x1dc align=1 (i32.const 0) (local.get 0x1dc))
+    (i64.store offset=0x1dd align=1 (i32.const 0) (local.get 0x1dd))
+    (i64.store offset=0x1de align=1 (i32.const 0) (local.get 0x1de))
+    (i64.store offset=0x1df align=1 (i32.const 0) (local.get 0x1df))
+    (i64.store offset=0x1e0 align=1 (i32.const 0) (local.get 0x1e0))
+    (i64.store offset=0x1e1 align=1 (i32.const 0) (local.get 0x1e1))
+    (i64.store offset=0x1e2 align=1 (i32.const 0) (local.get 0x1e2))
+    (i64.store offset=0x1e3 align=1 (i32.const 0) (local.get 0x1e3))
+    (i64.store offset=0x1e4 align=1 (i32.const 0) (local.get 0x1e4))
+    (i64.store offset=0x1e5 align=1 (i32.const 0) (local.get 0x1e5))
+    (i64.store offset=0x1e6 align=1 (i32.const 0) (local.get 0x1e6))
+    (i64.store offset=0x1e7 align=1 (i32.const 0) (local.get 0x1e7))
+    (i64.store offset=0x1e8 align=1 (i32.const 0) (local.get 0x1e8))
+    (i64.store offset=0x1e9 align=1 (i32.const 0) (local.get 0x1e9))
+    (i64.store offset=0x1ea align=1 (i32.const 0) (local.get 0x1ea))
+    (i64.store offset=0x1eb align=1 (i32.const 0) (local.get 0x1eb))
+    (i64.store offset=0x1ec align=1 (i32.const 0) (local.get 0x1ec))
+    (i64.store offset=0x1ed align=1 (i32.const 0) (local.get 0x1ed))
+    (i64.store offset=0x1ee align=1 (i32.const 0) (local.get 0x1ee))
+    (i64.store offset=0x1ef align=1 (i32.const 0) (local.get 0x1ef))
+    (i64.store offset=0x1f0 align=1 (i32.const 0) (local.get 0x1f0))
+    (i64.store offset=0x1f1 align=1 (i32.const 0) (local.get 0x1f1))
+    (i64.store offset=0x1f2 align=1 (i32.const 0) (local.get 0x1f2))
+    (i64.store offset=0x1f3 align=1 (i32.const 0) (local.get 0x1f3))
+    (i64.store offset=0x1f4 align=1 (i32.const 0) (local.get 0x1f4))
+    (i64.store offset=0x1f5 align=1 (i32.const 0) (local.get 0x1f5))
+    (i64.store offset=0x1f6 align=1 (i32.const 0) (local.get 0x1f6))
+    (i64.store offset=0x1f7 align=1 (i32.const 0) (local.get 0x1f7))
+    (i64.store offset=0x1f8 align=1 (i32.const 0) (local.get 0x1f8))
+    (i64.store offset=0x1f9 align=1 (i32.const 0) (local.get 0x1f9))
+    (i64.store offset=0x1fa align=1 (i32.const 0) (local.get 0x1fa))
+    (i64.store offset=0x1fb align=1 (i32.const 0) (local.get 0x1fb))
+    (i64.store offset=0x1fc align=1 (i32.const 0) (local.get 0x1fc))
+    (i64.store offset=0x1fd align=1 (i32.const 0) (local.get 0x1fd))
+    (i64.store offset=0x1fe align=1 (i32.const 0) (local.get 0x1fe))
+    (i64.store offset=0x1ff align=1 (i32.const 0) (local.get 0x1ff))
+    (i64.store offset=0x200 align=1 (i32.const 0) (local.get 0x200))
+    (i64.store offset=0x201 align=1 (i32.const 0) (local.get 0x201))
+    (i64.store offset=0x202 align=1 (i32.const 0) (local.get 0x202))
+    (i64.store offset=0x203 align=1 (i32.const 0) (local.get 0x203))
+    (i64.store offset=0x204 align=1 (i32.const 0) (local.get 0x204))
+    (i64.store offset=0x205 align=1 (i32.const 0) (local.get 0x205))
+    (i64.store offset=0x206 align=1 (i32.const 0) (local.get 0x206))
+    (i64.store offset=0x207 align=1 (i32.const 0) (local.get 0x207))
+    (i64.store offset=0x208 align=1 (i32.const 0) (local.get 0x208))
+    (i64.store offset=0x209 align=1 (i32.const 0) (local.get 0x209))
+    (i64.store offset=0x20a align=1 (i32.const 0) (local.get 0x20a))
+    (i64.store offset=0x20b align=1 (i32.const 0) (local.get 0x20b))
+    (i64.store offset=0x20c align=1 (i32.const 0) (local.get 0x20c))
+    (i64.store offset=0x20d align=1 (i32.const 0) (local.get 0x20d))
+    (i64.store offset=0x20e align=1 (i32.const 0) (local.get 0x20e))
+    (i64.store offset=0x20f align=1 (i32.const 0) (local.get 0x20f))
+    (i64.store offset=0x210 align=1 (i32.const 0) (local.get 0x210))
+    (i64.store offset=0x211 align=1 (i32.const 0) (local.get 0x211))
+    (i64.store offset=0x212 align=1 (i32.const 0) (local.get 0x212))
+    (i64.store offset=0x213 align=1 (i32.const 0) (local.get 0x213))
+    (i64.store offset=0x214 align=1 (i32.const 0) (local.get 0x214))
+    (i64.store offset=0x215 align=1 (i32.const 0) (local.get 0x215))
+    (i64.store offset=0x216 align=1 (i32.const 0) (local.get 0x216))
+    (i64.store offset=0x217 align=1 (i32.const 0) (local.get 0x217))
+    (i64.store offset=0x218 align=1 (i32.const 0) (local.get 0x218))
+    (i64.store offset=0x219 align=1 (i32.const 0) (local.get 0x219))
+    (i64.store offset=0x21a align=1 (i32.const 0) (local.get 0x21a))
+    (i64.store offset=0x21b align=1 (i32.const 0) (local.get 0x21b))
+    (i64.store offset=0x21c align=1 (i32.const 0) (local.get 0x21c))
+    (i64.store offset=0x21d align=1 (i32.const 0) (local.get 0x21d))
+    (i64.store offset=0x21e align=1 (i32.const 0) (local.get 0x21e))
+    (i64.store offset=0x21f align=1 (i32.const 0) (local.get 0x21f))
+    (i64.store offset=0x220 align=1 (i32.const 0) (local.get 0x220))
+    (i64.store offset=0x221 align=1 (i32.const 0) (local.get 0x221))
+    (i64.store offset=0x222 align=1 (i32.const 0) (local.get 0x222))
+    (i64.store offset=0x223 align=1 (i32.const 0) (local.get 0x223))
+    (i64.store offset=0x224 align=1 (i32.const 0) (local.get 0x224))
+    (i64.store offset=0x225 align=1 (i32.const 0) (local.get 0x225))
+    (i64.store offset=0x226 align=1 (i32.const 0) (local.get 0x226))
+    (i64.store offset=0x227 align=1 (i32.const 0) (local.get 0x227))
+    (i64.store offset=0x228 align=1 (i32.const 0) (local.get 0x228))
+    (i64.store offset=0x229 align=1 (i32.const 0) (local.get 0x229))
+    (i64.store offset=0x22a align=1 (i32.const 0) (local.get 0x22a))
+    (i64.store offset=0x22b align=1 (i32.const 0) (local.get 0x22b))
+    (i64.store offset=0x22c align=1 (i32.const 0) (local.get 0x22c))
+    (i64.store offset=0x22d align=1 (i32.const 0) (local.get 0x22d))
+    (i64.store offset=0x22e align=1 (i32.const 0) (local.get 0x22e))
+    (i64.store offset=0x22f align=1 (i32.const 0) (local.get 0x22f))
+    (i64.store offset=0x230 align=1 (i32.const 0) (local.get 0x230))
+    (i64.store offset=0x231 align=1 (i32.const 0) (local.get 0x231))
+    (i64.store offset=0x232 align=1 (i32.const 0) (local.get 0x232))
+    (i64.store offset=0x233 align=1 (i32.const 0) (local.get 0x233))
+    (i64.store offset=0x234 align=1 (i32.const 0) (local.get 0x234))
+    (i64.store offset=0x235 align=1 (i32.const 0) (local.get 0x235))
+    (i64.store offset=0x236 align=1 (i32.const 0) (local.get 0x236))
+    (i64.store offset=0x237 align=1 (i32.const 0) (local.get 0x237))
+    (i64.store offset=0x238 align=1 (i32.const 0) (local.get 0x238))
+    (i64.store offset=0x239 align=1 (i32.const 0) (local.get 0x239))
+    (i64.store offset=0x23a align=1 (i32.const 0) (local.get 0x23a))
+    (i64.store offset=0x23b align=1 (i32.const 0) (local.get 0x23b))
+    (i64.store offset=0x23c align=1 (i32.const 0) (local.get 0x23c))
+    (i64.store offset=0x23d align=1 (i32.const 0) (local.get 0x23d))
+    (i64.store offset=0x23e align=1 (i32.const 0) (local.get 0x23e))
+    (i64.store offset=0x23f align=1 (i32.const 0) (local.get 0x23f))
+    (i64.store offset=0x240 align=1 (i32.const 0) (local.get 0x240))
+    (i64.store offset=0x241 align=1 (i32.const 0) (local.get 0x241))
+    (i64.store offset=0x242 align=1 (i32.const 0) (local.get 0x242))
+    (i64.store offset=0x243 align=1 (i32.const 0) (local.get 0x243))
+    (i64.store offset=0x244 align=1 (i32.const 0) (local.get 0x244))
+    (i64.store offset=0x245 align=1 (i32.const 0) (local.get 0x245))
+    (i64.store offset=0x246 align=1 (i32.const 0) (local.get 0x246))
+    (i64.store offset=0x247 align=1 (i32.const 0) (local.get 0x247))
+    (i64.store offset=0x248 align=1 (i32.const 0) (local.get 0x248))
+    (i64.store offset=0x249 align=1 (i32.const 0) (local.get 0x249))
+    (i64.store offset=0x24a align=1 (i32.const 0) (local.get 0x24a))
+    (i64.store offset=0x24b align=1 (i32.const 0) (local.get 0x24b))
+    (i64.store offset=0x24c align=1 (i32.const 0) (local.get 0x24c))
+    (i64.store offset=0x24d align=1 (i32.const 0) (local.get 0x24d))
+    (i64.store offset=0x24e align=1 (i32.const 0) (local.get 0x24e))
+    (i64.store offset=0x24f align=1 (i32.const 0) (local.get 0x24f))
+    (i64.store offset=0x250 align=1 (i32.const 0) (local.get 0x250))
+    (i64.store offset=0x251 align=1 (i32.const 0) (local.get 0x251))
+    (i64.store offset=0x252 align=1 (i32.const 0) (local.get 0x252))
+    (i64.store offset=0x253 align=1 (i32.const 0) (local.get 0x253))
+    (i64.store offset=0x254 align=1 (i32.const 0) (local.get 0x254))
+    (i64.store offset=0x255 align=1 (i32.const 0) (local.get 0x255))
+    (i64.store offset=0x256 align=1 (i32.const 0) (local.get 0x256))
+    (i64.store offset=0x257 align=1 (i32.const 0) (local.get 0x257))
+    (i64.store offset=0x258 align=1 (i32.const 0) (local.get 0x258))
+    (i64.store offset=0x259 align=1 (i32.const 0) (local.get 0x259))
+    (i64.store offset=0x25a align=1 (i32.const 0) (local.get 0x25a))
+    (i64.store offset=0x25b align=1 (i32.const 0) (local.get 0x25b))
+    (i64.store offset=0x25c align=1 (i32.const 0) (local.get 0x25c))
+    (i64.store offset=0x25d align=1 (i32.const 0) (local.get 0x25d))
+    (i64.store offset=0x25e align=1 (i32.const 0) (local.get 0x25e))
+    (i64.store offset=0x25f align=1 (i32.const 0) (local.get 0x25f))
+    (i64.store offset=0x260 align=1 (i32.const 0) (local.get 0x260))
+    (i64.store offset=0x261 align=1 (i32.const 0) (local.get 0x261))
+    (i64.store offset=0x262 align=1 (i32.const 0) (local.get 0x262))
+    (i64.store offset=0x263 align=1 (i32.const 0) (local.get 0x263))
+    (i64.store offset=0x264 align=1 (i32.const 0) (local.get 0x264))
+    (i64.store offset=0x265 align=1 (i32.const 0) (local.get 0x265))
+    (i64.store offset=0x266 align=1 (i32.const 0) (local.get 0x266))
+    (i64.store offset=0x267 align=1 (i32.const 0) (local.get 0x267))
+    (i64.store offset=0x268 align=1 (i32.const 0) (local.get 0x268))
+    (i64.store offset=0x269 align=1 (i32.const 0) (local.get 0x269))
+    (i64.store offset=0x26a align=1 (i32.const 0) (local.get 0x26a))
+    (i64.store offset=0x26b align=1 (i32.const 0) (local.get 0x26b))
+    (i64.store offset=0x26c align=1 (i32.const 0) (local.get 0x26c))
+    (i64.store offset=0x26d align=1 (i32.const 0) (local.get 0x26d))
+    (i64.store offset=0x26e align=1 (i32.const 0) (local.get 0x26e))
+    (i64.store offset=0x26f align=1 (i32.const 0) (local.get 0x26f))
+    (i64.store offset=0x270 align=1 (i32.const 0) (local.get 0x270))
+    (i64.store offset=0x271 align=1 (i32.const 0) (local.get 0x271))
+    (i64.store offset=0x272 align=1 (i32.const 0) (local.get 0x272))
+    (i64.store offset=0x273 align=1 (i32.const 0) (local.get 0x273))
+    (i64.store offset=0x274 align=1 (i32.const 0) (local.get 0x274))
+    (i64.store offset=0x275 align=1 (i32.const 0) (local.get 0x275))
+    (i64.store offset=0x276 align=1 (i32.const 0) (local.get 0x276))
+    (i64.store offset=0x277 align=1 (i32.const 0) (local.get 0x277))
+    (i64.store offset=0x278 align=1 (i32.const 0) (local.get 0x278))
+    (i64.store offset=0x279 align=1 (i32.const 0) (local.get 0x279))
+    (i64.store offset=0x27a align=1 (i32.const 0) (local.get 0x27a))
+    (i64.store offset=0x27b align=1 (i32.const 0) (local.get 0x27b))
+    (i64.store offset=0x27c align=1 (i32.const 0) (local.get 0x27c))
+    (i64.store offset=0x27d align=1 (i32.const 0) (local.get 0x27d))
+    (i64.store offset=0x27e align=1 (i32.const 0) (local.get 0x27e))
+    (i64.store offset=0x27f align=1 (i32.const 0) (local.get 0x27f))
+    (i64.store offset=0x280 align=1 (i32.const 0) (local.get 0x280))
+    (i64.store offset=0x281 align=1 (i32.const 0) (local.get 0x281))
+    (i64.store offset=0x282 align=1 (i32.const 0) (local.get 0x282))
+    (i64.store offset=0x283 align=1 (i32.const 0) (local.get 0x283))
+    (i64.store offset=0x284 align=1 (i32.const 0) (local.get 0x284))
+    (i64.store offset=0x285 align=1 (i32.const 0) (local.get 0x285))
+    (i64.store offset=0x286 align=1 (i32.const 0) (local.get 0x286))
+    (i64.store offset=0x287 align=1 (i32.const 0) (local.get 0x287))
+    (i64.store offset=0x288 align=1 (i32.const 0) (local.get 0x288))
+    (i64.store offset=0x289 align=1 (i32.const 0) (local.get 0x289))
+    (i64.store offset=0x28a align=1 (i32.const 0) (local.get 0x28a))
+    (i64.store offset=0x28b align=1 (i32.const 0) (local.get 0x28b))
+    (i64.store offset=0x28c align=1 (i32.const 0) (local.get 0x28c))
+    (i64.store offset=0x28d align=1 (i32.const 0) (local.get 0x28d))
+    (i64.store offset=0x28e align=1 (i32.const 0) (local.get 0x28e))
+    (i64.store offset=0x28f align=1 (i32.const 0) (local.get 0x28f))
+    (i64.store offset=0x290 align=1 (i32.const 0) (local.get 0x290))
+    (i64.store offset=0x291 align=1 (i32.const 0) (local.get 0x291))
+    (i64.store offset=0x292 align=1 (i32.const 0) (local.get 0x292))
+    (i64.store offset=0x293 align=1 (i32.const 0) (local.get 0x293))
+    (i64.store offset=0x294 align=1 (i32.const 0) (local.get 0x294))
+    (i64.store offset=0x295 align=1 (i32.const 0) (local.get 0x295))
+    (i64.store offset=0x296 align=1 (i32.const 0) (local.get 0x296))
+    (i64.store offset=0x297 align=1 (i32.const 0) (local.get 0x297))
+    (i64.store offset=0x298 align=1 (i32.const 0) (local.get 0x298))
+    (i64.store offset=0x299 align=1 (i32.const 0) (local.get 0x299))
+    (i64.store offset=0x29a align=1 (i32.const 0) (local.get 0x29a))
+    (i64.store offset=0x29b align=1 (i32.const 0) (local.get 0x29b))
+    (i64.store offset=0x29c align=1 (i32.const 0) (local.get 0x29c))
+    (i64.store offset=0x29d align=1 (i32.const 0) (local.get 0x29d))
+    (i64.store offset=0x29e align=1 (i32.const 0) (local.get 0x29e))
+    (i64.store offset=0x29f align=1 (i32.const 0) (local.get 0x29f))
+    (i64.store offset=0x2a0 align=1 (i32.const 0) (local.get 0x2a0))
+    (i64.store offset=0x2a1 align=1 (i32.const 0) (local.get 0x2a1))
+    (i64.store offset=0x2a2 align=1 (i32.const 0) (local.get 0x2a2))
+    (i64.store offset=0x2a3 align=1 (i32.const 0) (local.get 0x2a3))
+    (i64.store offset=0x2a4 align=1 (i32.const 0) (local.get 0x2a4))
+    (i64.store offset=0x2a5 align=1 (i32.const 0) (local.get 0x2a5))
+    (i64.store offset=0x2a6 align=1 (i32.const 0) (local.get 0x2a6))
+    (i64.store offset=0x2a7 align=1 (i32.const 0) (local.get 0x2a7))
+    (i64.store offset=0x2a8 align=1 (i32.const 0) (local.get 0x2a8))
+    (i64.store offset=0x2a9 align=1 (i32.const 0) (local.get 0x2a9))
+    (i64.store offset=0x2aa align=1 (i32.const 0) (local.get 0x2aa))
+    (i64.store offset=0x2ab align=1 (i32.const 0) (local.get 0x2ab))
+    (i64.store offset=0x2ac align=1 (i32.const 0) (local.get 0x2ac))
+    (i64.store offset=0x2ad align=1 (i32.const 0) (local.get 0x2ad))
+    (i64.store offset=0x2ae align=1 (i32.const 0) (local.get 0x2ae))
+    (i64.store offset=0x2af align=1 (i32.const 0) (local.get 0x2af))
+    (i64.store offset=0x2b0 align=1 (i32.const 0) (local.get 0x2b0))
+    (i64.store offset=0x2b1 align=1 (i32.const 0) (local.get 0x2b1))
+    (i64.store offset=0x2b2 align=1 (i32.const 0) (local.get 0x2b2))
+    (i64.store offset=0x2b3 align=1 (i32.const 0) (local.get 0x2b3))
+    (i64.store offset=0x2b4 align=1 (i32.const 0) (local.get 0x2b4))
+    (i64.store offset=0x2b5 align=1 (i32.const 0) (local.get 0x2b5))
+    (i64.store offset=0x2b6 align=1 (i32.const 0) (local.get 0x2b6))
+    (i64.store offset=0x2b7 align=1 (i32.const 0) (local.get 0x2b7))
+    (i64.store offset=0x2b8 align=1 (i32.const 0) (local.get 0x2b8))
+    (i64.store offset=0x2b9 align=1 (i32.const 0) (local.get 0x2b9))
+    (i64.store offset=0x2ba align=1 (i32.const 0) (local.get 0x2ba))
+    (i64.store offset=0x2bb align=1 (i32.const 0) (local.get 0x2bb))
+    (i64.store offset=0x2bc align=1 (i32.const 0) (local.get 0x2bc))
+    (i64.store offset=0x2bd align=1 (i32.const 0) (local.get 0x2bd))
+    (i64.store offset=0x2be align=1 (i32.const 0) (local.get 0x2be))
+    (i64.store offset=0x2bf align=1 (i32.const 0) (local.get 0x2bf))
+    (i64.store offset=0x2c0 align=1 (i32.const 0) (local.get 0x2c0))
+    (i64.store offset=0x2c1 align=1 (i32.const 0) (local.get 0x2c1))
+    (i64.store offset=0x2c2 align=1 (i32.const 0) (local.get 0x2c2))
+    (i64.store offset=0x2c3 align=1 (i32.const 0) (local.get 0x2c3))
+    (i64.store offset=0x2c4 align=1 (i32.const 0) (local.get 0x2c4))
+    (i64.store offset=0x2c5 align=1 (i32.const 0) (local.get 0x2c5))
+    (i64.store offset=0x2c6 align=1 (i32.const 0) (local.get 0x2c6))
+    (i64.store offset=0x2c7 align=1 (i32.const 0) (local.get 0x2c7))
+    (i64.store offset=0x2c8 align=1 (i32.const 0) (local.get 0x2c8))
+    (i64.store offset=0x2c9 align=1 (i32.const 0) (local.get 0x2c9))
+    (i64.store offset=0x2ca align=1 (i32.const 0) (local.get 0x2ca))
+    (i64.store offset=0x2cb align=1 (i32.const 0) (local.get 0x2cb))
+    (i64.store offset=0x2cc align=1 (i32.const 0) (local.get 0x2cc))
+    (i64.store offset=0x2cd align=1 (i32.const 0) (local.get 0x2cd))
+    (i64.store offset=0x2ce align=1 (i32.const 0) (local.get 0x2ce))
+    (i64.store offset=0x2cf align=1 (i32.const 0) (local.get 0x2cf))
+    (i64.store offset=0x2d0 align=1 (i32.const 0) (local.get 0x2d0))
+    (i64.store offset=0x2d1 align=1 (i32.const 0) (local.get 0x2d1))
+    (i64.store offset=0x2d2 align=1 (i32.const 0) (local.get 0x2d2))
+    (i64.store offset=0x2d3 align=1 (i32.const 0) (local.get 0x2d3))
+    (i64.store offset=0x2d4 align=1 (i32.const 0) (local.get 0x2d4))
+    (i64.store offset=0x2d5 align=1 (i32.const 0) (local.get 0x2d5))
+    (i64.store offset=0x2d6 align=1 (i32.const 0) (local.get 0x2d6))
+    (i64.store offset=0x2d7 align=1 (i32.const 0) (local.get 0x2d7))
+    (i64.store offset=0x2d8 align=1 (i32.const 0) (local.get 0x2d8))
+    (i64.store offset=0x2d9 align=1 (i32.const 0) (local.get 0x2d9))
+    (i64.store offset=0x2da align=1 (i32.const 0) (local.get 0x2da))
+    (i64.store offset=0x2db align=1 (i32.const 0) (local.get 0x2db))
+    (i64.store offset=0x2dc align=1 (i32.const 0) (local.get 0x2dc))
+    (i64.store offset=0x2dd align=1 (i32.const 0) (local.get 0x2dd))
+    (i64.store offset=0x2de align=1 (i32.const 0) (local.get 0x2de))
+    (i64.store offset=0x2df align=1 (i32.const 0) (local.get 0x2df))
+    (i64.store offset=0x2e0 align=1 (i32.const 0) (local.get 0x2e0))
+    (i64.store offset=0x2e1 align=1 (i32.const 0) (local.get 0x2e1))
+    (i64.store offset=0x2e2 align=1 (i32.const 0) (local.get 0x2e2))
+    (i64.store offset=0x2e3 align=1 (i32.const 0) (local.get 0x2e3))
+    (i64.store offset=0x2e4 align=1 (i32.const 0) (local.get 0x2e4))
+    (i64.store offset=0x2e5 align=1 (i32.const 0) (local.get 0x2e5))
+    (i64.store offset=0x2e6 align=1 (i32.const 0) (local.get 0x2e6))
+    (i64.store offset=0x2e7 align=1 (i32.const 0) (local.get 0x2e7))
+    (i64.store offset=0x2e8 align=1 (i32.const 0) (local.get 0x2e8))
+    (i64.store offset=0x2e9 align=1 (i32.const 0) (local.get 0x2e9))
+    (i64.store offset=0x2ea align=1 (i32.const 0) (local.get 0x2ea))
+    (i64.store offset=0x2eb align=1 (i32.const 0) (local.get 0x2eb))
+    (i64.store offset=0x2ec align=1 (i32.const 0) (local.get 0x2ec))
+    (i64.store offset=0x2ed align=1 (i32.const 0) (local.get 0x2ed))
+    (i64.store offset=0x2ee align=1 (i32.const 0) (local.get 0x2ee))
+    (i64.store offset=0x2ef align=1 (i32.const 0) (local.get 0x2ef))
+    (i64.store offset=0x2f0 align=1 (i32.const 0) (local.get 0x2f0))
+    (i64.store offset=0x2f1 align=1 (i32.const 0) (local.get 0x2f1))
+    (i64.store offset=0x2f2 align=1 (i32.const 0) (local.get 0x2f2))
+    (i64.store offset=0x2f3 align=1 (i32.const 0) (local.get 0x2f3))
+    (i64.store offset=0x2f4 align=1 (i32.const 0) (local.get 0x2f4))
+    (i64.store offset=0x2f5 align=1 (i32.const 0) (local.get 0x2f5))
+    (i64.store offset=0x2f6 align=1 (i32.const 0) (local.get 0x2f6))
+    (i64.store offset=0x2f7 align=1 (i32.const 0) (local.get 0x2f7))
+    (i64.store offset=0x2f8 align=1 (i32.const 0) (local.get 0x2f8))
+    (i64.store offset=0x2f9 align=1 (i32.const 0) (local.get 0x2f9))
+    (i64.store offset=0x2fa align=1 (i32.const 0) (local.get 0x2fa))
+    (i64.store offset=0x2fb align=1 (i32.const 0) (local.get 0x2fb))
+    (i64.store offset=0x2fc align=1 (i32.const 0) (local.get 0x2fc))
+    (i64.store offset=0x2fd align=1 (i32.const 0) (local.get 0x2fd))
+    (i64.store offset=0x2fe align=1 (i32.const 0) (local.get 0x2fe))
+    (i64.store offset=0x2ff align=1 (i32.const 0) (local.get 0x2ff))
+    (i64.store offset=0x300 align=1 (i32.const 0) (local.get 0x300))
+    (i64.store offset=0x301 align=1 (i32.const 0) (local.get 0x301))
+    (i64.store offset=0x302 align=1 (i32.const 0) (local.get 0x302))
+    (i64.store offset=0x303 align=1 (i32.const 0) (local.get 0x303))
+    (i64.store offset=0x304 align=1 (i32.const 0) (local.get 0x304))
+    (i64.store offset=0x305 align=1 (i32.const 0) (local.get 0x305))
+    (i64.store offset=0x306 align=1 (i32.const 0) (local.get 0x306))
+    (i64.store offset=0x307 align=1 (i32.const 0) (local.get 0x307))
+    (i64.store offset=0x308 align=1 (i32.const 0) (local.get 0x308))
+    (i64.store offset=0x309 align=1 (i32.const 0) (local.get 0x309))
+    (i64.store offset=0x30a align=1 (i32.const 0) (local.get 0x30a))
+    (i64.store offset=0x30b align=1 (i32.const 0) (local.get 0x30b))
+    (i64.store offset=0x30c align=1 (i32.const 0) (local.get 0x30c))
+    (i64.store offset=0x30d align=1 (i32.const 0) (local.get 0x30d))
+    (i64.store offset=0x30e align=1 (i32.const 0) (local.get 0x30e))
+    (i64.store offset=0x30f align=1 (i32.const 0) (local.get 0x30f))
+    (i64.store offset=0x310 align=1 (i32.const 0) (local.get 0x310))
+    (i64.store offset=0x311 align=1 (i32.const 0) (local.get 0x311))
+    (i64.store offset=0x312 align=1 (i32.const 0) (local.get 0x312))
+    (i64.store offset=0x313 align=1 (i32.const 0) (local.get 0x313))
+    (i64.store offset=0x314 align=1 (i32.const 0) (local.get 0x314))
+    (i64.store offset=0x315 align=1 (i32.const 0) (local.get 0x315))
+    (i64.store offset=0x316 align=1 (i32.const 0) (local.get 0x316))
+    (i64.store offset=0x317 align=1 (i32.const 0) (local.get 0x317))
+    (i64.store offset=0x318 align=1 (i32.const 0) (local.get 0x318))
+    (i64.store offset=0x319 align=1 (i32.const 0) (local.get 0x319))
+    (i64.store offset=0x31a align=1 (i32.const 0) (local.get 0x31a))
+    (i64.store offset=0x31b align=1 (i32.const 0) (local.get 0x31b))
+    (i64.store offset=0x31c align=1 (i32.const 0) (local.get 0x31c))
+    (i64.store offset=0x31d align=1 (i32.const 0) (local.get 0x31d))
+    (i64.store offset=0x31e align=1 (i32.const 0) (local.get 0x31e))
+    (i64.store offset=0x31f align=1 (i32.const 0) (local.get 0x31f))
+    (i64.store offset=0x320 align=1 (i32.const 0) (local.get 0x320))
+    (i64.store offset=0x321 align=1 (i32.const 0) (local.get 0x321))
+    (i64.store offset=0x322 align=1 (i32.const 0) (local.get 0x322))
+    (i64.store offset=0x323 align=1 (i32.const 0) (local.get 0x323))
+    (i64.store offset=0x324 align=1 (i32.const 0) (local.get 0x324))
+    (i64.store offset=0x325 align=1 (i32.const 0) (local.get 0x325))
+    (i64.store offset=0x326 align=1 (i32.const 0) (local.get 0x326))
+    (i64.store offset=0x327 align=1 (i32.const 0) (local.get 0x327))
+    (i64.store offset=0x328 align=1 (i32.const 0) (local.get 0x328))
+    (i64.store offset=0x329 align=1 (i32.const 0) (local.get 0x329))
+    (i64.store offset=0x32a align=1 (i32.const 0) (local.get 0x32a))
+    (i64.store offset=0x32b align=1 (i32.const 0) (local.get 0x32b))
+    (i64.store offset=0x32c align=1 (i32.const 0) (local.get 0x32c))
+    (i64.store offset=0x32d align=1 (i32.const 0) (local.get 0x32d))
+    (i64.store offset=0x32e align=1 (i32.const 0) (local.get 0x32e))
+    (i64.store offset=0x32f align=1 (i32.const 0) (local.get 0x32f))
+    (i64.store offset=0x330 align=1 (i32.const 0) (local.get 0x330))
+    (i64.store offset=0x331 align=1 (i32.const 0) (local.get 0x331))
+    (i64.store offset=0x332 align=1 (i32.const 0) (local.get 0x332))
+    (i64.store offset=0x333 align=1 (i32.const 0) (local.get 0x333))
+    (i64.store offset=0x334 align=1 (i32.const 0) (local.get 0x334))
+    (i64.store offset=0x335 align=1 (i32.const 0) (local.get 0x335))
+    (i64.store offset=0x336 align=1 (i32.const 0) (local.get 0x336))
+    (i64.store offset=0x337 align=1 (i32.const 0) (local.get 0x337))
+    (i64.store offset=0x338 align=1 (i32.const 0) (local.get 0x338))
+    (i64.store offset=0x339 align=1 (i32.const 0) (local.get 0x339))
+    (i64.store offset=0x33a align=1 (i32.const 0) (local.get 0x33a))
+    (i64.store offset=0x33b align=1 (i32.const 0) (local.get 0x33b))
+    (i64.store offset=0x33c align=1 (i32.const 0) (local.get 0x33c))
+    (i64.store offset=0x33d align=1 (i32.const 0) (local.get 0x33d))
+    (i64.store offset=0x33e align=1 (i32.const 0) (local.get 0x33e))
+    (i64.store offset=0x33f align=1 (i32.const 0) (local.get 0x33f))
+    (i64.store offset=0x340 align=1 (i32.const 0) (local.get 0x340))
+    (i64.store offset=0x341 align=1 (i32.const 0) (local.get 0x341))
+    (i64.store offset=0x342 align=1 (i32.const 0) (local.get 0x342))
+    (i64.store offset=0x343 align=1 (i32.const 0) (local.get 0x343))
+    (i64.store offset=0x344 align=1 (i32.const 0) (local.get 0x344))
+    (i64.store offset=0x345 align=1 (i32.const 0) (local.get 0x345))
+    (i64.store offset=0x346 align=1 (i32.const 0) (local.get 0x346))
+    (i64.store offset=0x347 align=1 (i32.const 0) (local.get 0x347))
+    (i64.store offset=0x348 align=1 (i32.const 0) (local.get 0x348))
+    (i64.store offset=0x349 align=1 (i32.const 0) (local.get 0x349))
+    (i64.store offset=0x34a align=1 (i32.const 0) (local.get 0x34a))
+    (i64.store offset=0x34b align=1 (i32.const 0) (local.get 0x34b))
+    (i64.store offset=0x34c align=1 (i32.const 0) (local.get 0x34c))
+    (i64.store offset=0x34d align=1 (i32.const 0) (local.get 0x34d))
+    (i64.store offset=0x34e align=1 (i32.const 0) (local.get 0x34e))
+    (i64.store offset=0x34f align=1 (i32.const 0) (local.get 0x34f))
+    (i64.store offset=0x350 align=1 (i32.const 0) (local.get 0x350))
+    (i64.store offset=0x351 align=1 (i32.const 0) (local.get 0x351))
+    (i64.store offset=0x352 align=1 (i32.const 0) (local.get 0x352))
+    (i64.store offset=0x353 align=1 (i32.const 0) (local.get 0x353))
+    (i64.store offset=0x354 align=1 (i32.const 0) (local.get 0x354))
+    (i64.store offset=0x355 align=1 (i32.const 0) (local.get 0x355))
+    (i64.store offset=0x356 align=1 (i32.const 0) (local.get 0x356))
+    (i64.store offset=0x357 align=1 (i32.const 0) (local.get 0x357))
+    (i64.store offset=0x358 align=1 (i32.const 0) (local.get 0x358))
+    (i64.store offset=0x359 align=1 (i32.const 0) (local.get 0x359))
+    (i64.store offset=0x35a align=1 (i32.const 0) (local.get 0x35a))
+    (i64.store offset=0x35b align=1 (i32.const 0) (local.get 0x35b))
+    (i64.store offset=0x35c align=1 (i32.const 0) (local.get 0x35c))
+    (i64.store offset=0x35d align=1 (i32.const 0) (local.get 0x35d))
+    (i64.store offset=0x35e align=1 (i32.const 0) (local.get 0x35e))
+    (i64.store offset=0x35f align=1 (i32.const 0) (local.get 0x35f))
+    (i64.store offset=0x360 align=1 (i32.const 0) (local.get 0x360))
+    (i64.store offset=0x361 align=1 (i32.const 0) (local.get 0x361))
+    (i64.store offset=0x362 align=1 (i32.const 0) (local.get 0x362))
+    (i64.store offset=0x363 align=1 (i32.const 0) (local.get 0x363))
+    (i64.store offset=0x364 align=1 (i32.const 0) (local.get 0x364))
+    (i64.store offset=0x365 align=1 (i32.const 0) (local.get 0x365))
+    (i64.store offset=0x366 align=1 (i32.const 0) (local.get 0x366))
+    (i64.store offset=0x367 align=1 (i32.const 0) (local.get 0x367))
+    (i64.store offset=0x368 align=1 (i32.const 0) (local.get 0x368))
+    (i64.store offset=0x369 align=1 (i32.const 0) (local.get 0x369))
+    (i64.store offset=0x36a align=1 (i32.const 0) (local.get 0x36a))
+    (i64.store offset=0x36b align=1 (i32.const 0) (local.get 0x36b))
+    (i64.store offset=0x36c align=1 (i32.const 0) (local.get 0x36c))
+    (i64.store offset=0x36d align=1 (i32.const 0) (local.get 0x36d))
+    (i64.store offset=0x36e align=1 (i32.const 0) (local.get 0x36e))
+    (i64.store offset=0x36f align=1 (i32.const 0) (local.get 0x36f))
+    (i64.store offset=0x370 align=1 (i32.const 0) (local.get 0x370))
+    (i64.store offset=0x371 align=1 (i32.const 0) (local.get 0x371))
+    (i64.store offset=0x372 align=1 (i32.const 0) (local.get 0x372))
+    (i64.store offset=0x373 align=1 (i32.const 0) (local.get 0x373))
+    (i64.store offset=0x374 align=1 (i32.const 0) (local.get 0x374))
+    (i64.store offset=0x375 align=1 (i32.const 0) (local.get 0x375))
+    (i64.store offset=0x376 align=1 (i32.const 0) (local.get 0x376))
+    (i64.store offset=0x377 align=1 (i32.const 0) (local.get 0x377))
+    (i64.store offset=0x378 align=1 (i32.const 0) (local.get 0x378))
+    (i64.store offset=0x379 align=1 (i32.const 0) (local.get 0x379))
+    (i64.store offset=0x37a align=1 (i32.const 0) (local.get 0x37a))
+    (i64.store offset=0x37b align=1 (i32.const 0) (local.get 0x37b))
+    (i64.store offset=0x37c align=1 (i32.const 0) (local.get 0x37c))
+    (i64.store offset=0x37d align=1 (i32.const 0) (local.get 0x37d))
+    (i64.store offset=0x37e align=1 (i32.const 0) (local.get 0x37e))
+    (i64.store offset=0x37f align=1 (i32.const 0) (local.get 0x37f))
+    (i64.store offset=0x380 align=1 (i32.const 0) (local.get 0x380))
+    (i64.store offset=0x381 align=1 (i32.const 0) (local.get 0x381))
+    (i64.store offset=0x382 align=1 (i32.const 0) (local.get 0x382))
+    (i64.store offset=0x383 align=1 (i32.const 0) (local.get 0x383))
+    (i64.store offset=0x384 align=1 (i32.const 0) (local.get 0x384))
+    (i64.store offset=0x385 align=1 (i32.const 0) (local.get 0x385))
+    (i64.store offset=0x386 align=1 (i32.const 0) (local.get 0x386))
+    (i64.store offset=0x387 align=1 (i32.const 0) (local.get 0x387))
+    (i64.store offset=0x388 align=1 (i32.const 0) (local.get 0x388))
+    (i64.store offset=0x389 align=1 (i32.const 0) (local.get 0x389))
+    (i64.store offset=0x38a align=1 (i32.const 0) (local.get 0x38a))
+    (i64.store offset=0x38b align=1 (i32.const 0) (local.get 0x38b))
+    (i64.store offset=0x38c align=1 (i32.const 0) (local.get 0x38c))
+    (i64.store offset=0x38d align=1 (i32.const 0) (local.get 0x38d))
+    (i64.store offset=0x38e align=1 (i32.const 0) (local.get 0x38e))
+    (i64.store offset=0x38f align=1 (i32.const 0) (local.get 0x38f))
+    (i64.store offset=0x390 align=1 (i32.const 0) (local.get 0x390))
+    (i64.store offset=0x391 align=1 (i32.const 0) (local.get 0x391))
+    (i64.store offset=0x392 align=1 (i32.const 0) (local.get 0x392))
+    (i64.store offset=0x393 align=1 (i32.const 0) (local.get 0x393))
+    (i64.store offset=0x394 align=1 (i32.const 0) (local.get 0x394))
+    (i64.store offset=0x395 align=1 (i32.const 0) (local.get 0x395))
+    (i64.store offset=0x396 align=1 (i32.const 0) (local.get 0x396))
+    (i64.store offset=0x397 align=1 (i32.const 0) (local.get 0x397))
+    (i64.store offset=0x398 align=1 (i32.const 0) (local.get 0x398))
+    (i64.store offset=0x399 align=1 (i32.const 0) (local.get 0x399))
+    (i64.store offset=0x39a align=1 (i32.const 0) (local.get 0x39a))
+    (i64.store offset=0x39b align=1 (i32.const 0) (local.get 0x39b))
+    (i64.store offset=0x39c align=1 (i32.const 0) (local.get 0x39c))
+    (i64.store offset=0x39d align=1 (i32.const 0) (local.get 0x39d))
+    (i64.store offset=0x39e align=1 (i32.const 0) (local.get 0x39e))
+    (i64.store offset=0x39f align=1 (i32.const 0) (local.get 0x39f))
+    (i64.store offset=0x3a0 align=1 (i32.const 0) (local.get 0x3a0))
+    (i64.store offset=0x3a1 align=1 (i32.const 0) (local.get 0x3a1))
+    (i64.store offset=0x3a2 align=1 (i32.const 0) (local.get 0x3a2))
+    (i64.store offset=0x3a3 align=1 (i32.const 0) (local.get 0x3a3))
+    (i64.store offset=0x3a4 align=1 (i32.const 0) (local.get 0x3a4))
+    (i64.store offset=0x3a5 align=1 (i32.const 0) (local.get 0x3a5))
+    (i64.store offset=0x3a6 align=1 (i32.const 0) (local.get 0x3a6))
+    (i64.store offset=0x3a7 align=1 (i32.const 0) (local.get 0x3a7))
+    (i64.store offset=0x3a8 align=1 (i32.const 0) (local.get 0x3a8))
+    (i64.store offset=0x3a9 align=1 (i32.const 0) (local.get 0x3a9))
+    (i64.store offset=0x3aa align=1 (i32.const 0) (local.get 0x3aa))
+    (i64.store offset=0x3ab align=1 (i32.const 0) (local.get 0x3ab))
+    (i64.store offset=0x3ac align=1 (i32.const 0) (local.get 0x3ac))
+    (i64.store offset=0x3ad align=1 (i32.const 0) (local.get 0x3ad))
+    (i64.store offset=0x3ae align=1 (i32.const 0) (local.get 0x3ae))
+    (i64.store offset=0x3af align=1 (i32.const 0) (local.get 0x3af))
+    (i64.store offset=0x3b0 align=1 (i32.const 0) (local.get 0x3b0))
+    (i64.store offset=0x3b1 align=1 (i32.const 0) (local.get 0x3b1))
+    (i64.store offset=0x3b2 align=1 (i32.const 0) (local.get 0x3b2))
+    (i64.store offset=0x3b3 align=1 (i32.const 0) (local.get 0x3b3))
+    (i64.store offset=0x3b4 align=1 (i32.const 0) (local.get 0x3b4))
+    (i64.store offset=0x3b5 align=1 (i32.const 0) (local.get 0x3b5))
+    (i64.store offset=0x3b6 align=1 (i32.const 0) (local.get 0x3b6))
+    (i64.store offset=0x3b7 align=1 (i32.const 0) (local.get 0x3b7))
+    (i64.store offset=0x3b8 align=1 (i32.const 0) (local.get 0x3b8))
+    (i64.store offset=0x3b9 align=1 (i32.const 0) (local.get 0x3b9))
+    (i64.store offset=0x3ba align=1 (i32.const 0) (local.get 0x3ba))
+    (i64.store offset=0x3bb align=1 (i32.const 0) (local.get 0x3bb))
+    (i64.store offset=0x3bc align=1 (i32.const 0) (local.get 0x3bc))
+    (i64.store offset=0x3bd align=1 (i32.const 0) (local.get 0x3bd))
+    (i64.store offset=0x3be align=1 (i32.const 0) (local.get 0x3be))
+    (i64.store offset=0x3bf align=1 (i32.const 0) (local.get 0x3bf))
+    (i64.store offset=0x3c0 align=1 (i32.const 0) (local.get 0x3c0))
+    (i64.store offset=0x3c1 align=1 (i32.const 0) (local.get 0x3c1))
+    (i64.store offset=0x3c2 align=1 (i32.const 0) (local.get 0x3c2))
+    (i64.store offset=0x3c3 align=1 (i32.const 0) (local.get 0x3c3))
+    (i64.store offset=0x3c4 align=1 (i32.const 0) (local.get 0x3c4))
+    (i64.store offset=0x3c5 align=1 (i32.const 0) (local.get 0x3c5))
+    (i64.store offset=0x3c6 align=1 (i32.const 0) (local.get 0x3c6))
+    (i64.store offset=0x3c7 align=1 (i32.const 0) (local.get 0x3c7))
+    (i64.store offset=0x3c8 align=1 (i32.const 0) (local.get 0x3c8))
+    (i64.store offset=0x3c9 align=1 (i32.const 0) (local.get 0x3c9))
+    (i64.store offset=0x3ca align=1 (i32.const 0) (local.get 0x3ca))
+    (i64.store offset=0x3cb align=1 (i32.const 0) (local.get 0x3cb))
+    (i64.store offset=0x3cc align=1 (i32.const 0) (local.get 0x3cc))
+    (i64.store offset=0x3cd align=1 (i32.const 0) (local.get 0x3cd))
+    (i64.store offset=0x3ce align=1 (i32.const 0) (local.get 0x3ce))
+    (i64.store offset=0x3cf align=1 (i32.const 0) (local.get 0x3cf))
+    (i64.store offset=0x3d0 align=1 (i32.const 0) (local.get 0x3d0))
+    (i64.store offset=0x3d1 align=1 (i32.const 0) (local.get 0x3d1))
+    (i64.store offset=0x3d2 align=1 (i32.const 0) (local.get 0x3d2))
+    (i64.store offset=0x3d3 align=1 (i32.const 0) (local.get 0x3d3))
+    (i64.store offset=0x3d4 align=1 (i32.const 0) (local.get 0x3d4))
+    (i64.store offset=0x3d5 align=1 (i32.const 0) (local.get 0x3d5))
+    (i64.store offset=0x3d6 align=1 (i32.const 0) (local.get 0x3d6))
+    (i64.store offset=0x3d7 align=1 (i32.const 0) (local.get 0x3d7))
+    (i64.store offset=0x3d8 align=1 (i32.const 0) (local.get 0x3d8))
+    (i64.store offset=0x3d9 align=1 (i32.const 0) (local.get 0x3d9))
+    (i64.store offset=0x3da align=1 (i32.const 0) (local.get 0x3da))
+    (i64.store offset=0x3db align=1 (i32.const 0) (local.get 0x3db))
+    (i64.store offset=0x3dc align=1 (i32.const 0) (local.get 0x3dc))
+    (i64.store offset=0x3dd align=1 (i32.const 0) (local.get 0x3dd))
+    (i64.store offset=0x3de align=1 (i32.const 0) (local.get 0x3de))
+    (i64.store offset=0x3df align=1 (i32.const 0) (local.get 0x3df))
+    (i64.store offset=0x3e0 align=1 (i32.const 0) (local.get 0x3e0))
+    (i64.store offset=0x3e1 align=1 (i32.const 0) (local.get 0x3e1))
+    (i64.store offset=0x3e2 align=1 (i32.const 0) (local.get 0x3e2))
+    (i64.store offset=0x3e3 align=1 (i32.const 0) (local.get 0x3e3))
+    (i64.store offset=0x3e4 align=1 (i32.const 0) (local.get 0x3e4))
+    (i64.store offset=0x3e5 align=1 (i32.const 0) (local.get 0x3e5))
+    (i64.store offset=0x3e6 align=1 (i32.const 0) (local.get 0x3e6))
+    (i64.store offset=0x3e7 align=1 (i32.const 0) (local.get 0x3e7))
+    (i64.store offset=0x3e8 align=1 (i32.const 0) (local.get 0x3e8))
+    (i64.store offset=0x3e9 align=1 (i32.const 0) (local.get 0x3e9))
+    (i64.store offset=0x3ea align=1 (i32.const 0) (local.get 0x3ea))
+    (i64.store offset=0x3eb align=1 (i32.const 0) (local.get 0x3eb))
+    (i64.store offset=0x3ec align=1 (i32.const 0) (local.get 0x3ec))
+    (i64.store offset=0x3ed align=1 (i32.const 0) (local.get 0x3ed))
+    (i64.store offset=0x3ee align=1 (i32.const 0) (local.get 0x3ee))
+    (i64.store offset=0x3ef align=1 (i32.const 0) (local.get 0x3ef))
+    (i64.store offset=0x3f0 align=1 (i32.const 0) (local.get 0x3f0))
+    (i64.store offset=0x3f1 align=1 (i32.const 0) (local.get 0x3f1))
+    (i64.store offset=0x3f2 align=1 (i32.const 0) (local.get 0x3f2))
+    (i64.store offset=0x3f3 align=1 (i32.const 0) (local.get 0x3f3))
+    (i64.store offset=0x3f4 align=1 (i32.const 0) (local.get 0x3f4))
+    (i64.store offset=0x3f5 align=1 (i32.const 0) (local.get 0x3f5))
+    (i64.store offset=0x3f6 align=1 (i32.const 0) (local.get 0x3f6))
+    (i64.store offset=0x3f7 align=1 (i32.const 0) (local.get 0x3f7))
+    (i64.store offset=0x3f8 align=1 (i32.const 0) (local.get 0x3f8))
+    (i64.store offset=0x3f9 align=1 (i32.const 0) (local.get 0x3f9))
+    (i64.store offset=0x3fa align=1 (i32.const 0) (local.get 0x3fa))
+    (i64.store offset=0x3fb align=1 (i32.const 0) (local.get 0x3fb))
+    (i64.store offset=0x3fc align=1 (i32.const 0) (local.get 0x3fc))
+    (i64.store offset=0x3fd align=1 (i32.const 0) (local.get 0x3fd))
+    (i64.store offset=0x3fe align=1 (i32.const 0) (local.get 0x3fe))
+    (i64.store offset=0x3ff align=1 (i32.const 0) (local.get 0x3ff))
+    (i64.store offset=0x400 align=1 (i32.const 0) (local.get 0x400))
+    (i64.store offset=0x401 align=1 (i32.const 0) (local.get 0x401))
+    (i64.store offset=0x402 align=1 (i32.const 0) (local.get 0x402))
+    (i64.store offset=0x403 align=1 (i32.const 0) (local.get 0x403))
+    (i64.store offset=0x404 align=1 (i32.const 0) (local.get 0x404))
+    (i64.store offset=0x405 align=1 (i32.const 0) (local.get 0x405))
+    (i64.store offset=0x406 align=1 (i32.const 0) (local.get 0x406))
+    (i64.store offset=0x407 align=1 (i32.const 0) (local.get 0x407))
+    (i64.store offset=0x408 align=1 (i32.const 0) (local.get 0x408))
+    (i64.store offset=0x409 align=1 (i32.const 0) (local.get 0x409))
+    (i64.store offset=0x40a align=1 (i32.const 0) (local.get 0x40a))
+    (i64.store offset=0x40b align=1 (i32.const 0) (local.get 0x40b))
+    (i64.store offset=0x40c align=1 (i32.const 0) (local.get 0x40c))
+    (i64.store offset=0x40d align=1 (i32.const 0) (local.get 0x40d))
+    (i64.store offset=0x40e align=1 (i32.const 0) (local.get 0x40e))
+    (i64.store offset=0x40f align=1 (i32.const 0) (local.get 0x40f))
+    (i64.store offset=0x410 align=1 (i32.const 0) (local.get 0x410))
+    (i64.store offset=0x411 align=1 (i32.const 0) (local.get 0x411))
+    (i64.store offset=0x412 align=1 (i32.const 0) (local.get 0x412))
+    (i64.store offset=0x413 align=1 (i32.const 0) (local.get 0x413))
+    (i64.store offset=0x414 align=1 (i32.const 0) (local.get 0x414))
+    (i64.store offset=0x415 align=1 (i32.const 0) (local.get 0x415))
+    (i64.store offset=0x416 align=1 (i32.const 0) (local.get 0x416))
+    (i64.store offset=0x417 align=1 (i32.const 0) (local.get 0x417))
+    (i64.store offset=0x418 align=1 (i32.const 0) (local.get 0x418))
+    (i64.store offset=0x419 align=1 (i32.const 0) (local.get 0x419))
+    (i64.store offset=0x41a align=1 (i32.const 0) (local.get 0x41a))
+    (i64.store offset=0x41b align=1 (i32.const 0) (local.get 0x41b))
+    (i64.store offset=0x41c align=1 (i32.const 0) (local.get 0x41c))
+    (i64.store offset=0x41d align=1 (i32.const 0) (local.get 0x41d))
+    (i64.store offset=0x41e align=1 (i32.const 0) (local.get 0x41e))
+    (i64.store offset=0x41f align=1 (i32.const 0) (local.get 0x41f))
+  )
+)
+
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 0)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 100)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 200)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 300)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 400)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 500)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 600)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 700)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 800)) "call stack exhausted")
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 900)) "call stack exhausted")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/stack.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/stack.wast
new file mode 100644
index 0000000..5da5043
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/stack.wast
@@ -0,0 +1,239 @@
+(module
+  (func (export "fac-expr") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (if
+          (i64.eq (local.get $i) (i64.const 0))
+          (then (br $done))
+          (else
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  (func (export "fac-stack") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.get $n)
+    (local.set $i)
+    (i64.const 1)
+    (local.set $res)
+    (block $done
+      (loop $loop
+        (local.get $i)
+        (i64.const 0)
+        (i64.eq)
+        (if
+          (then (br $done))
+          (else
+            (local.get $i)
+            (local.get $res)
+            (i64.mul)
+            (local.set $res)
+            (local.get $i)
+            (i64.const 1)
+            (i64.sub)
+            (local.set $i)
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  (func (export "fac-stack-raw") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    local.get $n
+    local.set $i
+    i64.const 1
+    local.set $res
+    block $done
+      loop $loop
+        local.get $i
+        i64.const 0
+        i64.eq
+        if $body
+          br $done
+        else $body
+          local.get $i
+          local.get $res
+          i64.mul
+          local.set $res
+          local.get $i
+          i64.const 1
+          i64.sub
+          local.set $i
+        end $body
+        br $loop
+      end $loop
+    end $done
+    local.get $res
+  )
+
+  (func (export "fac-mixed") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (i64.eq (local.get $i) (i64.const 0))
+        (if
+          (then (br $done))
+          (else
+            (i64.mul (local.get $i) (local.get $res))
+            (local.set $res)
+            (i64.sub (local.get $i) (i64.const 1))
+            (local.set $i)
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  (func (export "fac-mixed-raw") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    block $done
+      loop $loop
+        (i64.eq (local.get $i) (i64.const 0))
+        if
+          br $done
+        else
+          (i64.mul (local.get $i) (local.get $res))
+          local.set $res
+          (i64.sub (local.get $i) (i64.const 1))
+          local.set $i
+        end
+        br $loop
+      end
+    end
+    local.get $res
+  )
+
+  (global $temp (mut i32) (i32.const 0))
+  (func $add_one_to_global (result i32)
+    (local i32)
+    (global.set $temp (i32.add (i32.const 1) (global.get $temp)))
+    (global.get $temp)
+  )
+  (func $add_one_to_global_and_drop
+    (drop (call $add_one_to_global))
+  )
+  (func (export "not-quite-a-tree") (result i32)
+    call $add_one_to_global
+    call $add_one_to_global
+    call $add_one_to_global_and_drop
+    i32.add
+  )
+)
+
+(assert_return (invoke "fac-expr" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-stack" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-mixed" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "not-quite-a-tree") (i32.const 3))
+(assert_return (invoke "not-quite-a-tree") (i32.const 9))
+
+
+;; Syntax of flat call_indirect
+
+(module
+  (type $proc (func))
+  (table 1 funcref)
+
+  (func
+    (block i32.const 0 call_indirect)
+    (loop i32.const 0 call_indirect)
+    (if (i32.const 0) (then i32.const 0 call_indirect))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect)
+      (else i32.const 0 call_indirect)
+    )
+    (block i32.const 0 call_indirect (type $proc))
+    (loop i32.const 0 call_indirect (type $proc))
+    (if (i32.const 0) (then i32.const 0 call_indirect (type $proc)))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc))
+      (else i32.const 0 call_indirect (type $proc))
+    )
+    (block i32.const 0 i32.const 0 call_indirect (param i32))
+    (loop i32.const 0 i32.const 0 call_indirect (param i32))
+    (if (i32.const 0) (then i32.const 0 i32.const 0 call_indirect (param i32)))
+    (if (i32.const 0)
+      (then i32.const 0 i32.const 0 call_indirect (param i32))
+      (else i32.const 0 i32.const 0 call_indirect (param i32))
+    )
+    (block (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (loop (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (if (result i32) (i32.const 0)
+      (then i32.const 0 call_indirect (result i32))
+      (else i32.const 0 call_indirect (result i32))
+    ) (drop)
+    (block i32.const 0 call_indirect (type $proc) (param) (result))
+    (loop i32.const 0 call_indirect (type $proc) (param) (result))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc) (param) (result))
+    )
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc) (param) (param) (result))
+      (else i32.const 0 call_indirect (type $proc) (param) (result) (result))
+    )
+
+    block i32.const 0 call_indirect end
+    loop i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect else i32.const 0 call_indirect end
+    block i32.const 0 call_indirect (type $proc) end
+    loop i32.const 0 call_indirect (type $proc) end
+    i32.const 0 if i32.const 0 call_indirect (type $proc) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $proc)
+    else
+      i32.const 0 call_indirect (type $proc)
+    end
+    block i32.const 0 i32.const 0 call_indirect (param i32) end
+    loop i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0 if i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0
+    if
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    else
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    end
+    block (result i32) i32.const 0 call_indirect (result i32) end drop
+    loop (result i32) i32.const 0 call_indirect (result i32) end drop
+    i32.const 0
+    if (result i32)
+      i32.const 0 call_indirect (result i32)
+    else
+      i32.const 0 call_indirect (result i32)
+    end drop
+    block i32.const 0 call_indirect (type $proc) (param) (result) end
+    loop i32.const 0 call_indirect (type $proc) (param) (result) end
+    i32.const 0 if i32.const 0 call_indirect (type $proc) (param) (result) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $proc) (param) (result)
+    else
+      i32.const 0 call_indirect (type $proc) (param) (param) (result) (result)
+    end
+    i32.const 0 call_indirect
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/start.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/start.wast
new file mode 100644
index 0000000..bf88a6a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/start.wast
@@ -0,0 +1,105 @@
+(assert_invalid
+  (module (func) (start 1))
+  "unknown function"
+)
+
+(assert_invalid
+  (module
+    (func $main (result i32) (return (i32.const 0)))
+    (start $main)
+  )
+  "start function"
+)
+(assert_invalid
+  (module
+    (func $main (param $a i32))
+    (start $main)
+  )
+  "start function"
+)
+
+(module
+  (memory (data "A"))
+  (func $inc
+    (i32.store8
+      (i32.const 0)
+      (i32.add
+        (i32.load8_u (i32.const 0))
+        (i32.const 1)
+      )
+    )
+  )
+  (func $get (result i32)
+    (return (i32.load8_u (i32.const 0)))
+  )
+  (func $main
+    (call $inc)
+    (call $inc)
+    (call $inc)
+  )
+
+  (start $main)
+  (export "inc" (func $inc))
+  (export "get" (func $get))
+)
+(assert_return (invoke "get") (i32.const 68))
+(invoke "inc")
+(assert_return (invoke "get") (i32.const 69))
+(invoke "inc")
+(assert_return (invoke "get") (i32.const 70))
+
+(module
+  (memory (data "A"))
+  (func $inc
+    (i32.store8
+      (i32.const 0)
+      (i32.add
+        (i32.load8_u (i32.const 0))
+        (i32.const 1)
+      )
+    )
+  )
+  (func $get (result i32)
+    (return (i32.load8_u (i32.const 0)))
+  )
+  (func $main
+    (call $inc)
+    (call $inc)
+    (call $inc)
+  )
+  (start 2)
+  (export "inc" (func $inc))
+  (export "get" (func $get))
+)
+(assert_return (invoke "get") (i32.const 68))
+(invoke "inc")
+(assert_return (invoke "get") (i32.const 69))
+(invoke "inc")
+(assert_return (invoke "get") (i32.const 70))
+
+(module
+  (func $print_i32 (import "spectest" "print_i32") (param i32))
+  (func $main (call $print_i32 (i32.const 1)))
+  (start 1)
+)
+
+(module
+  (func $print_i32 (import "spectest" "print_i32") (param i32))
+  (func $main (call $print_i32 (i32.const 2)))
+  (start $main)
+)
+
+(module
+  (func $print (import "spectest" "print"))
+  (start $print)
+)
+
+(assert_trap
+  (module (func $main (unreachable)) (start $main))
+  "unreachable"
+)
+
+(assert_malformed
+  (module quote "(module (func $a (unreachable)) (func $b (unreachable)) (start $a) (start $b))")
+  "multiple start sections"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/store.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/store.wast
new file mode 100644
index 0000000..01c3a2d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/store.wast
@@ -0,0 +1,417 @@
+;; Store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+  (func (export "as-loop-value")
+    (loop (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-br-value")
+    (block (br 0 (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value")
+    (return (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+
+(assert_return (invoke "as-return-value"))
+
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store32 (local.get 0) (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store64 (local.get 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i64.store64 (local.get 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store32 (local.get 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store64 (local.get 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store32 (local.get 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store64 (local.get 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
+;; store should have no retval
+
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+
+
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty
+      (i32.store)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty
+     (i32.const 0) (i32.store)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-block
+      (i32.const 0) (i32.const 0)
+      (block (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-block
+      (i32.const 0)
+      (block (i32.const 0) (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-loop
+      (i32.const 0) (i32.const 0)
+      (loop (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-loop
+      (i32.const 0)
+      (loop (i32.const 0) (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-then
+      (i32.const 0) (i32.const 0)
+      (if (then (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-then
+      (i32.const 0)
+      (if (then (i32.const 0) (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-else
+      (i32.const 0) (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-else
+      (i32.const 0)
+      (if (result i32) (then (i32.const 0)) (else (i32.const 0) (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-br
+      (i32.const 0) (i32.const 0)
+      (block (br 0 (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-br
+      (i32.const 0)
+      (block (br 0 (i32.const 0) (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-br_if
+      (i32.const 0) (i32.const 0)
+      (block (br_if 0 (i32.store) (i32.const 1)) )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-br_if
+      (i32.const 0)
+      (block (br_if 0 (i32.const 0) (i32.store) (i32.const 1)) )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-br_table
+      (i32.const 0) (i32.const 0)
+      (block (br_table 0 (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-br_table
+      (i32.const 0)
+      (block (br_table 0 (i32.const 0) (i32.store)))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-return
+      (return (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-return
+      (return (i32.const 0) (i32.store))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-select
+      (select (i32.store) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-select
+      (select (i32.const 0) (i32.store) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-address-empty-in-call
+      (call 1 (i32.store))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $type-value-empty-in-call
+      (call 1 (i32.const 0) (i32.store))
+    )
+    (func (param i32) (result i32) (local.get 0))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-address-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.store) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (memory 1)
+    (func $f (param i32) (result i32) (local.get 0))
+    (type $sig (func (param i32) (result i32)))
+    (table funcref (elem $f))
+    (func $type-value-empty-in-call_indirect
+      (block (result i32)
+        (call_indirect (type $sig)
+          (i32.const 0) (i32.store) (i32.const 0)
+        )
+      )
+    )
+  )
+  "type mismatch"
+)
+
+
+;; Type check
+
+(assert_invalid (module (memory 1) (func (i32.store (f32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i32.store8 (f32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i32.store16 (f32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store (f32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store8 (f32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store16 (f32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store32 (f32.const 0) (i64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (f32.store (f32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (f64.store (f32.const 0) (f64.const 0)))) "type mismatch")
+
+(assert_invalid (module (memory 1) (func (i32.store (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i32.store8 (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i32.store16 (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store (i32.const 0) (f32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store8 (i32.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store16 (i32.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (i64.store32 (i32.const 0) (f64.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (f32.store (i32.const 0) (i32.const 0)))) "type mismatch")
+(assert_invalid (module (memory 1) (func (f64.store (i32.const 0) (i64.const 0)))) "type mismatch")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/switch.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/switch.wast
new file mode 100644
index 0000000..e9ae24d
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/switch.wast
@@ -0,0 +1,150 @@
+(module
+  ;; Statement switch
+  (func (export "stmt") (param $i i32) (result i32)
+    (local $j i32)
+    (local.set $j (i32.const 100))
+    (block $switch
+      (block $7
+        (block $default
+          (block $6
+            (block $5
+              (block $4
+                (block $3
+                  (block $2
+                    (block $1
+                      (block $0
+                        (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
+                          (local.get $i)
+                        )
+                      ) ;; 0
+                      (return (local.get $i))
+                    ) ;; 1
+                    (nop)
+                    ;; fallthrough
+                  ) ;; 2
+                  ;; fallthrough
+                ) ;; 3
+                (local.set $j (i32.sub (i32.const 0) (local.get $i)))
+                (br $switch)
+              ) ;; 4
+              (br $switch)
+            ) ;; 5
+            (local.set $j (i32.const 101))
+            (br $switch)
+          ) ;; 6
+          (local.set $j (i32.const 101))
+          ;; fallthrough
+        ) ;; default
+        (local.set $j (i32.const 102))
+      ) ;; 7
+      ;; fallthrough
+    )
+    (return (local.get $j))
+  )
+
+  ;; Expression switch
+  (func (export "expr") (param $i i64) (result i64)
+    (local $j i64)
+    (local.set $j (i64.const 100))
+    (return
+      (block $switch (result i64)
+        (block $7
+          (block $default
+            (block $4
+              (block $5
+                (block $6
+                  (block $3
+                    (block $2
+                      (block $1
+                        (block $0
+                          (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
+                            (i32.wrap_i64 (local.get $i))
+                          )
+                        ) ;; 0
+                        (return (local.get $i))
+                      ) ;; 1
+                      (nop)
+                      ;; fallthrough
+                    ) ;; 2
+                    ;; fallthrough
+                  ) ;; 3
+                  (br $switch (i64.sub (i64.const 0) (local.get $i)))
+                ) ;; 6
+                (local.set $j (i64.const 101))
+                ;; fallthrough
+              ) ;; 4
+              ;; fallthrough
+            ) ;; 5
+            ;; fallthrough
+          ) ;; default
+          (br $switch (local.get $j))
+        ) ;; 7
+        (i64.const -5)
+      )
+    )
+  )
+
+  ;; Argument switch
+  (func (export "arg") (param $i i32) (result i32)
+    (return
+      (block $2 (result i32)
+        (i32.add (i32.const 10)
+          (block $1 (result i32)
+            (i32.add (i32.const 100)
+              (block $0 (result i32)
+                (i32.add (i32.const 1000)
+                  (block $default (result i32)
+                    (br_table $0 $1 $2 $default
+                      (i32.mul (i32.const 2) (local.get $i))
+                      (i32.and (i32.const 3) (local.get $i))
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+  ;; Corner cases
+  (func (export "corner") (result i32)
+    (block
+      (br_table 0 (i32.const 0))
+    )
+    (i32.const 1)
+  )
+)
+
+(assert_return (invoke "stmt" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "stmt" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "stmt" (i32.const 2)) (i32.const -2))
+(assert_return (invoke "stmt" (i32.const 3)) (i32.const -3))
+(assert_return (invoke "stmt" (i32.const 4)) (i32.const 100))
+(assert_return (invoke "stmt" (i32.const 5)) (i32.const 101))
+(assert_return (invoke "stmt" (i32.const 6)) (i32.const 102))
+(assert_return (invoke "stmt" (i32.const 7)) (i32.const 100))
+(assert_return (invoke "stmt" (i32.const -10)) (i32.const 102))
+
+(assert_return (invoke "expr" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "expr" (i64.const 1)) (i64.const -1))
+(assert_return (invoke "expr" (i64.const 2)) (i64.const -2))
+(assert_return (invoke "expr" (i64.const 3)) (i64.const -3))
+(assert_return (invoke "expr" (i64.const 6)) (i64.const 101))
+(assert_return (invoke "expr" (i64.const 7)) (i64.const -5))
+(assert_return (invoke "expr" (i64.const -10)) (i64.const 100))
+
+(assert_return (invoke "arg" (i32.const 0)) (i32.const 110))
+(assert_return (invoke "arg" (i32.const 1)) (i32.const 12))
+(assert_return (invoke "arg" (i32.const 2)) (i32.const 4))
+(assert_return (invoke "arg" (i32.const 3)) (i32.const 1116))
+(assert_return (invoke "arg" (i32.const 4)) (i32.const 118))
+(assert_return (invoke "arg" (i32.const 5)) (i32.const 20))
+(assert_return (invoke "arg" (i32.const 6)) (i32.const 12))
+(assert_return (invoke "arg" (i32.const 7)) (i32.const 1124))
+(assert_return (invoke "arg" (i32.const 8)) (i32.const 126))
+
+(assert_return (invoke "corner") (i32.const 1))
+
+(assert_invalid (module (func (br_table 3 (i32.const 0)))) "unknown label")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table-sub.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table-sub.wast
new file mode 100644
index 0000000..08787bd
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table-sub.wast
@@ -0,0 +1,21 @@
+(assert_invalid
+  (module
+    (table $t1 10 funcref)
+    (table $t2 10 externref)
+    (func $f
+      (table.copy $t1 $t2 (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 funcref)
+    (elem $el externref)
+    (func $f
+      (table.init $t $el (i32.const 0) (i32.const 1) (i32.const 2))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table.wast
new file mode 100644
index 0000000..0bd04f5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table.wast
@@ -0,0 +1,54 @@
+;; Test table section structure
+
+(module (table 0 funcref))
+(module (table 1 funcref))
+(module (table 0 0 funcref))
+(module (table 0 1 funcref))
+(module (table 1 256 funcref))
+(module (table 0 65536 funcref))
+(module (table 0 0xffff_ffff funcref))
+
+(module (table 0 funcref) (table 0 funcref))
+(module (table (import "spectest" "table") 0 funcref) (table 0 funcref))
+
+(assert_invalid (module (elem (i32.const 0))) "unknown table")
+(assert_invalid (module (elem (i32.const 0) $f) (func $f)) "unknown table")
+
+
+(assert_invalid
+  (module (table 1 0 funcref))
+  "size minimum must not be greater than maximum"
+)
+(assert_invalid
+  (module (table 0xffff_ffff 0 funcref))
+  "size minimum must not be greater than maximum"
+)
+
+(assert_malformed
+  (module quote "(table 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(table 0x1_0000_0000 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+(assert_malformed
+  (module quote "(table 0 0x1_0000_0000 funcref)")
+  "i32 constant out of range"
+)
+
+
+;; Duplicate table identifiers
+
+(assert_malformed (module quote
+  "(table $foo 1 funcref)"
+  "(table $foo 1 funcref)")
+  "duplicate table")
+(assert_malformed (module quote
+  "(import \"\" \"\" (table $foo 1 funcref))"
+  "(table $foo 1 funcref)")
+  "duplicate table")
+(assert_malformed (module quote
+  "(import \"\" \"\" (table $foo 1 funcref))"
+  "(import \"\" \"\" (table $foo 1 funcref))")
+  "duplicate table")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_copy.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_copy.wast
new file mode 100644
index 0000000..380e84e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_copy.wast
@@ -0,0 +1,3082 @@
+;;
+;; Generated by ../meta/generate_table_copy.js
+;; DO NOT EDIT THIS FILE.  CHANGE THE SOURCE AND REGENERATE.
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 27)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 18)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t1) (i32.const 3) func 1 3 1 4)
+  (elem (table $t1) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 10) (i32.const 0) (i32.const 20)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 4))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 1))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 22)) (i32.const 7))
+(assert_return (invoke "check_t1" (i32.const 23)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 24)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (nop))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 13) (i32.const 2) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 25) (i32.const 15) (i32.const 2)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 13) (i32.const 25) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 20) (i32.const 22) (i32.const 4)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 25) (i32.const 1) (i32.const 3)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 27)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 10) (i32.const 12) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 10)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 11)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t1 $t1 (i32.const 12) (i32.const 10) (i32.const 7)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 17)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 18)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 11)) (i32.const 6))
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 7))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (elem (table $t0) (i32.const 3) func 1 3 1 4)
+  (elem (table $t0) (i32.const 11) func 6 3 2 5 7)
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.copy $t0 $t1 (i32.const 10) (i32.const 0) (i32.const 20)))
+  (func (export "check_t0") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+  (func (export "check_t1") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check_t0" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t0" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check_t0" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check_t0" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t0" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check_t0" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check_t0" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check_t0" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check_t0" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check_t0" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t0" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 2)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 4)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 5)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 6)) (i32.const 4))
+(assert_trap (invoke "check_t1" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 13)) (i32.const 1))
+(assert_return (invoke "check_t1" (i32.const 14)) (i32.const 4))
+(assert_return (invoke "check_t1" (i32.const 15)) (i32.const 1))
+(assert_trap (invoke "check_t1" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 21)) "uninitialized element")
+(assert_return (invoke "check_t1" (i32.const 22)) (i32.const 7))
+(assert_return (invoke "check_t1" (i32.const 23)) (i32.const 5))
+(assert_return (invoke "check_t1" (i32.const 24)) (i32.const 2))
+(assert_return (invoke "check_t1" (i32.const 25)) (i32.const 3))
+(assert_return (invoke "check_t1" (i32.const 26)) (i32.const 6))
+(assert_trap (invoke "check_t1" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check_t1" (i32.const 29)) "uninitialized element")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 15) (i32.const 25) (i32.const 6))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 15) (i32.const 25) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 30) (i32.const 15) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 31) (i32.const 15) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 15) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 15) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 30) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t0 $t0 (i32.const 31) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 0xFFFFFFFE) (i32.const 1) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 15) (i32.const 25) (i32.const 6))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 15) (i32.const 0xFFFFFFFE) (i32.const 2))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 15) (i32.const 25) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 30) (i32.const 15) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 31) (i32.const 15) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 15) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 15) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 30) (i32.const 30) (i32.const 0))
+    ))
+
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.copy $t1 $t0 (i32.const 31) (i32.const 31) (i32.const 0))
+    ))
+
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 0) (i32.const 16))
+             "out of bounds table access")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 23) (i32.const 0) (i32.const 15))
+             "out of bounds table access")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 24) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 23)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 23) (i32.const 15))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 23)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 8))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 11)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 11) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 11)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 16)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 17)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 18)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 11) (i32.const 24) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 24) (i32.const 21) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 24)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 24) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 24)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 7))
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem (i32.const 21)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 21) (i32.const 21) (i32.const 16))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 21)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 22)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 23)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 24)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 25)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 26)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 27)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 28)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 29)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 30)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 31)) (i32.const 10))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 112)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 0) (i32.const 112) (i32.const 4294967264))
+             "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_return (invoke "test" (i32.const 112)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 113)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 114)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 115)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 116)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 117)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 118)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 119)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 120)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 121)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 122)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 123)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 124)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 125)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 126)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 127)) (i32.const 15))
+
+(module
+  (type (func (result i32)))
+  (table 128 128 funcref)
+  (elem (i32.const 0)
+         $f0 $f1 $f2 $f3 $f4 $f5 $f6 $f7 $f8 $f9 $f10 $f11 $f12 $f13 $f14 $f15)
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $targetOffs i32) (param $srcOffs i32) (param $len i32)
+    (table.copy (local.get $targetOffs) (local.get $srcOffs) (local.get $len))))
+
+(assert_trap (invoke "run" (i32.const 112) (i32.const 0) (i32.const 4294967264))
+             "out of bounds table access")
+(assert_return (invoke "test" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "test" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "test" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "test" (i32.const 3)) (i32.const 3))
+(assert_return (invoke "test" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "test" (i32.const 5)) (i32.const 5))
+(assert_return (invoke "test" (i32.const 6)) (i32.const 6))
+(assert_return (invoke "test" (i32.const 7)) (i32.const 7))
+(assert_return (invoke "test" (i32.const 8)) (i32.const 8))
+(assert_return (invoke "test" (i32.const 9)) (i32.const 9))
+(assert_return (invoke "test" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "test" (i32.const 11)) (i32.const 11))
+(assert_return (invoke "test" (i32.const 12)) (i32.const 12))
+(assert_return (invoke "test" (i32.const 13)) (i32.const 13))
+(assert_return (invoke "test" (i32.const 14)) (i32.const 14))
+(assert_return (invoke "test" (i32.const 15)) (i32.const 15))
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_fill.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_fill.wast
new file mode 100644
index 0000000..3df64da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_fill.wast
@@ -0,0 +1,153 @@
+(module
+  (table $t 10 externref)
+
+  (func (export "fill") (param $i i32) (param $r externref) (param $n i32)
+    (table.fill $t (local.get $i) (local.get $r) (local.get $n))
+  )
+
+  (func (export "get") (param $i i32) (result externref)
+    (table.get $t (local.get $i))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 1)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 2)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 3)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 4)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 5)) (ref.null extern))
+
+(assert_return (invoke "fill" (i32.const 2) (ref.extern 1) (i32.const 3)))
+(assert_return (invoke "get" (i32.const 1)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 2)) (ref.extern 1))
+(assert_return (invoke "get" (i32.const 3)) (ref.extern 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 1))
+(assert_return (invoke "get" (i32.const 5)) (ref.null extern))
+
+(assert_return (invoke "fill" (i32.const 4) (ref.extern 2) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 3)) (ref.extern 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 2))
+(assert_return (invoke "get" (i32.const 5)) (ref.extern 2))
+(assert_return (invoke "get" (i32.const 6)) (ref.null extern))
+
+(assert_return (invoke "fill" (i32.const 4) (ref.extern 3) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 3)) (ref.extern 1))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 2))
+(assert_return (invoke "get" (i32.const 5)) (ref.extern 2))
+
+(assert_return (invoke "fill" (i32.const 8) (ref.extern 4) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 7)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.extern 4))
+
+(assert_return (invoke "fill" (i32.const 9) (ref.null extern) (i32.const 1)))
+(assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.null extern))
+
+(assert_return (invoke "fill" (i32.const 10) (ref.extern 5) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 9)) (ref.null extern))
+
+(assert_trap
+  (invoke "fill" (i32.const 8) (ref.extern 6) (i32.const 3))
+  "out of bounds table access"
+)
+(assert_return (invoke "get" (i32.const 7)) (ref.null extern))
+(assert_return (invoke "get" (i32.const 8)) (ref.extern 4))
+(assert_return (invoke "get" (i32.const 9)) (ref.null extern))
+
+(assert_trap
+  (invoke "fill" (i32.const 11) (ref.null extern) (i32.const 0))
+  "out of bounds table access"
+)
+
+(assert_trap
+  (invoke "fill" (i32.const 11) (ref.null extern) (i32.const 10))
+  "out of bounds table access"
+)
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-value-length-empty-vs-i32-i32
+      (table.fill $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-empty-vs-i32
+      (table.fill $t (ref.null extern) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-value-empty-vs
+      (table.fill $t (i32.const 1) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-length-empty-vs-i32
+      (table.fill $t (i32.const 1) (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-index-f32-vs-i32
+      (table.fill $t (f32.const 1) (ref.null extern) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 funcref)
+    (func $type-value-vs-funcref (param $r externref)
+      (table.fill $t (i32.const 1) (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-length-f32-vs-i32
+      (table.fill $t (i32.const 1) (ref.null extern) (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 externref)
+    (table $t2 1 funcref)
+    (func $type-value-externref-vs-funcref-multi (param $r externref)
+      (table.fill $t2 (i32.const 0) (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-empty-vs-num (result i32)
+      (table.fill $t (i32.const 0) (ref.null extern) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_get.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_get.wast
new file mode 100644
index 0000000..5d57c31
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_get.wast
@@ -0,0 +1,88 @@
+(module
+  (table $t2 2 externref)
+  (table $t3 3 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "init") (param $r externref)
+    (table.set $t2 (i32.const 1) (local.get $r))
+    (table.set $t3 (i32.const 2) (table.get $t3 (i32.const 1)))
+  )
+
+  (func (export "get-externref") (param $i i32) (result externref)
+    (table.get $t2 (local.get $i))
+  )
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+
+  (func (export "is_null-funcref") (param $i i32) (result i32)
+    (ref.is_null (call $f3 (local.get $i)))
+  )
+)
+
+(invoke "init" (ref.extern 1))
+
+(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern))
+(assert_return (invoke "get-externref" (i32.const 1)) (ref.extern 1))
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+(assert_return (invoke "is_null-funcref" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "is_null-funcref" (i32.const 2)) (i32.const 0))
+
+(assert_trap (invoke "get-externref" (i32.const 2)) "out of bounds table access")
+(assert_trap (invoke "get-funcref" (i32.const 3)) "out of bounds table access")
+(assert_trap (invoke "get-externref" (i32.const -1)) "out of bounds table access")
+(assert_trap (invoke "get-funcref" (i32.const -1)) "out of bounds table access")
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-empty-vs-i32 (result externref)
+      (table.get $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-f32-vs-i32 (result externref)
+      (table.get $t (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-result-externref-vs-empty
+      (table.get $t (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-result-externref-vs-funcref (result funcref)
+      (table.get $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 funcref)
+    (table $t2 1 externref)
+    (func $type-result-externref-vs-funcref-multi (result funcref)
+      (table.get $t2 (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_grow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_grow.wast
new file mode 100644
index 0000000..7d5b563
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_grow.wast
@@ -0,0 +1,173 @@
+(module
+  (table $t 0 externref)
+
+  (func (export "get") (param $i i32) (result externref) (table.get $t (local.get $i)))
+  (func (export "set") (param $i i32) (param $r externref) (table.set $t (local.get $i) (local.get $r)))
+
+  (func (export "grow") (param $sz i32) (param $init externref) (result i32)
+    (table.grow $t (local.get $init) (local.get $sz))
+  )
+  (func (export "size") (result i32) (table.size $t))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "set" (i32.const 0) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 0)) "out of bounds table access")
+
+(assert_return (invoke "grow" (i32.const 1) (ref.null extern)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 1))
+(assert_return (invoke "get" (i32.const 0)) (ref.null extern))
+(assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_trap (invoke "set" (i32.const 1) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 1)) "out of bounds table access")
+
+(assert_return (invoke "grow" (i32.const 4) (ref.extern 3)) (i32.const 1))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "set" (i32.const 0) (ref.extern 2)))
+(assert_return (invoke "get" (i32.const 0)) (ref.extern 2))
+(assert_return (invoke "get" (i32.const 1)) (ref.extern 3))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 3))
+(assert_return (invoke "set" (i32.const 4) (ref.extern 4)))
+(assert_return (invoke "get" (i32.const 4)) (ref.extern 4))
+(assert_trap (invoke "set" (i32.const 5) (ref.extern 2)) "out of bounds table access")
+(assert_trap (invoke "get" (i32.const 5)) "out of bounds table access")
+
+
+;; Reject growing to size outside i32 value range
+(module
+  (table $t 0x10 funcref)
+  (elem declare func $f)
+  (func $f (export "grow") (result i32)
+    (table.grow $t (ref.func $f) (i32.const 0xffff_fff0))
+  )
+)
+
+(assert_return (invoke "grow") (i32.const -1))
+
+
+(module
+  (table $t 0 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null extern) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
+
+
+(module
+  (table $t 0 10 externref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null extern) (local.get 0))
+  )
+)
+
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "grow" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "grow" (i32.const 6)) (i32.const 4))
+(assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+
+(module
+  (table $t 10 funcref)
+  (func (export "grow") (param i32) (result i32)
+    (table.grow $t (ref.null func) (local.get 0))
+  )
+  (elem declare func 1)
+  (func (export "check-table-null") (param i32 i32) (result funcref)
+    (local funcref)
+    (local.set 2 (ref.func 1))
+    (block
+      (loop
+        (local.set 2 (table.get $t (local.get 0)))
+        (br_if 1 (i32.eqz (ref.is_null (local.get 2))))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
+      )
+    )
+    (local.get 2)
+  )
+)
+
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 9)) (ref.null func))
+(assert_return (invoke "grow" (i32.const 10)) (i32.const 10))
+(assert_return (invoke "check-table-null" (i32.const 0) (i32.const 19)) (ref.null func))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-init-size-empty-vs-i32-externref (result i32)
+      (table.grow $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-size-empty-vs-i32 (result i32)
+      (table.grow $t (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-init-empty-vs-externref (result i32)
+      (table.grow $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 externref)
+    (func $type-size-f32-vs-i32 (result i32)
+      (table.grow $t (ref.null extern) (f32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 0 funcref)
+    (func $type-init-externref-vs-funcref (param $r externref) (result i32)
+      (table.grow $t (local.get $r) (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-empty
+      (table.grow $t (ref.null extern) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-f32 (result f32)
+      (table.grow $t (ref.null extern) (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_init.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_init.wast
new file mode 100644
index 0000000..0b2d26f
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_init.wast
@@ -0,0 +1,2143 @@
+;;
+;; Generated by ../meta/generate_table_init.js
+;; DO NOT EDIT THIS FILE.  CHANGE THE SOURCE AND REGENERATE.
+;;
+
+(module
+  (func (export "ef0") (result i32) (i32.const 0))
+  (func (export "ef1") (result i32) (i32.const 1))
+  (func (export "ef2") (result i32) (i32.const 2))
+  (func (export "ef3") (result i32) (i32.const 3))
+  (func (export "ef4") (result i32) (i32.const 4))
+)
+(register "a")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t0 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t0 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t0 1 (i32.const 7) (i32.const 0) (i32.const 4))
+         (elem.drop 1)
+         (table.init $t0 3 (i32.const 15) (i32.const 1) (i32.const 3))
+         (elem.drop 3)
+         (table.copy $t0 0 (i32.const 20) (i32.const 15) (i32.const 5))
+         (table.copy $t0 0 (i32.const 21) (i32.const 29) (i32.const 1))
+         (table.copy $t0 0 (i32.const 24) (i32.const 10) (i32.const 1))
+         (table.copy $t0 0 (i32.const 13) (i32.const 11) (i32.const 4))
+         (table.copy $t0 0 (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 21)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "check" (i32.const 24)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t1 1 (i32.const 7) (i32.const 0) (i32.const 4)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 6))
+(assert_trap (invoke "check" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t1 3 (i32.const 15) (i32.const 1) (i32.const 3)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 13)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 14)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 9))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t1 1 (i32.const 7) (i32.const 0) (i32.const 4))
+         (elem.drop 1)
+         (table.init $t1 3 (i32.const 15) (i32.const 1) (i32.const 3))
+         (elem.drop 3)
+         (table.copy $t1 1 (i32.const 20) (i32.const 15) (i32.const 5))
+         (table.copy $t1 1 (i32.const 21) (i32.const 29) (i32.const 1))
+         (table.copy $t1 1 (i32.const 24) (i32.const 10) (i32.const 1))
+         (table.copy $t1 1 (i32.const 13) (i32.const 11) (i32.const 4))
+         (table.copy $t1 1 (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t1 (type 0) (local.get 0)))
+)
+
+(invoke "test")
+(assert_trap (invoke "check" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 1)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 2)) (i32.const 3))
+(assert_return (invoke "check" (i32.const 3)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 4)) (i32.const 4))
+(assert_return (invoke "check" (i32.const 5)) (i32.const 1))
+(assert_trap (invoke "check" (i32.const 6)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 7)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 8)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 9)) (i32.const 1))
+(assert_return (invoke "check" (i32.const 10)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 11)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 12)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 13)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 14)) (i32.const 7))
+(assert_return (invoke "check" (i32.const 15)) (i32.const 5))
+(assert_return (invoke "check" (i32.const 16)) (i32.const 2))
+(assert_return (invoke "check" (i32.const 17)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 18)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "check" (i32.const 20)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 21)) (i32.const 7))
+(assert_trap (invoke "check" (i32.const 22)) "uninitialized element")
+(assert_return (invoke "check" (i32.const 23)) (i32.const 8))
+(assert_return (invoke "check" (i32.const 24)) (i32.const 8))
+(assert_trap (invoke "check" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "check" (i32.const 29)) "uninitialized element")
+(assert_invalid
+  (module
+    (func (export "test")
+      (elem.drop 0)))
+  "unknown elem segment 0")
+
+(assert_invalid
+  (module
+    (func (export "test")
+      (table.init 0 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (elem.drop 4)))
+  "unknown elem segment 4")
+
+(assert_invalid
+  (module
+    (elem funcref (ref.func 0))
+    (func (result i32) (i32.const 0))
+    (func (export "test")
+      (table.init 4 (i32.const 12) (i32.const 1) (i32.const 1))))
+  "unknown table 0")
+
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 2)
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 2 (i32.const 12) (i32.const 1) (i32.const 1))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))
+    (table.init 1 (i32.const 21) (i32.const 1) (i32.const 1))))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (elem.drop 1)))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (elem.drop 1)
+    (table.init 1 (i32.const 12) (i32.const 1) (i32.const 1))))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 0) (i32.const 5))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init 1 (i32.const 12) (i32.const 2) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 28) (i32.const 1) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 30) (i32.const 2) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 31) (i32.const 2) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 30) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t0 1 (i32.const 31) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 26) (i32.const 1) (i32.const 3))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 12) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 12) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 28) (i32.const 2) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 29) (i32.const 2) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 28) (i32.const 4) (i32.const 0))
+    ))
+(invoke "test")
+
+(module
+  (table $t0 30 30 funcref)
+  (table $t1 28 28 funcref)
+  (elem (table $t1) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t1) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 0))
+  (func (result i32) (i32.const 1))
+  (func (result i32) (i32.const 2))
+  (func (result i32) (i32.const 3))
+  (func (result i32) (i32.const 4))
+  (func (result i32) (i32.const 5))
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))
+  (func (export "test")
+    (table.init $t1 1 (i32.const 29) (i32.const 5) (i32.const 0))
+    ))
+(assert_trap (invoke "test") "out of bounds table access")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f32.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (i64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f32.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (i64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f32.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (i64.const 1))))
+  "type mismatch")
+
+(assert_invalid
+  (module
+    (table 10 funcref)
+    (elem funcref (ref.func $f0) (ref.func $f0) (ref.func $f0))
+    (func $f0)
+    (func (export "test")
+      (table.init 0 (f64.const 1) (f64.const 1) (f64.const 1))))
+  "type mismatch")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 24) (i32.const 16)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 32 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 25) (i32.const 16)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 96) (i32.const 32)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 160 320 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 97) (i32.const 31)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 64)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 65)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 66)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 67)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 68)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 69)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 70)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 71)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 72)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 73)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 74)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 75)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 76)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 77)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 78)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 79)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 80)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 81)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 82)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 83)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 84)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 85)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 86)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 87)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 88)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 89)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 90)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 91)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 92)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 93)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 94)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 95)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 96)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 97)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 98)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 99)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 100)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 101)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 102)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 103)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 104)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 105)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 106)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 107)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 108)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 109)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 110)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 111)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 112)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 113)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 114)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 115)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 116)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 117)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 118)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 119)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 120)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 121)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 122)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 123)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 124)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 125)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 126)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 127)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 128)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 129)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 130)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 131)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 132)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 133)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 134)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 135)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 136)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 137)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 138)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 139)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 140)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 141)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 142)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 143)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 144)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 145)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 146)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 147)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 148)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 149)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 150)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 151)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 152)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 153)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 154)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 155)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 156)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 157)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 158)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 159)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 64 64 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 0) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 48) (i32.const 4294967280)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 16)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 17)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 18)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 19)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 20)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 21)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 22)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 23)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 24)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 25)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 26)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 27)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 28)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 29)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 30)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 31)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 32)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 33)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 34)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 35)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 36)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 37)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 38)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 39)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 40)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 41)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 42)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 43)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 44)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 45)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 46)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 47)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 48)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 49)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 50)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 51)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 52)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 53)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 54)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 55)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 56)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 57)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 58)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 59)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 60)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 61)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 62)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 63)) "uninitialized element")
+
+(module
+  (type (func (result i32)))
+  (table 16 16 funcref)
+  (elem funcref
+    (ref.func $f0) (ref.func $f1) (ref.func $f2) (ref.func $f3)
+    (ref.func $f4) (ref.func $f5) (ref.func $f6) (ref.func $f7)
+    (ref.func $f8) (ref.func $f9) (ref.func $f10) (ref.func $f11)
+    (ref.func $f12) (ref.func $f13) (ref.func $f14) (ref.func $f15))
+  (func $f0 (export "f0") (result i32) (i32.const 0))
+  (func $f1 (export "f1") (result i32) (i32.const 1))
+  (func $f2 (export "f2") (result i32) (i32.const 2))
+  (func $f3 (export "f3") (result i32) (i32.const 3))
+  (func $f4 (export "f4") (result i32) (i32.const 4))
+  (func $f5 (export "f5") (result i32) (i32.const 5))
+  (func $f6 (export "f6") (result i32) (i32.const 6))
+  (func $f7 (export "f7") (result i32) (i32.const 7))
+  (func $f8 (export "f8") (result i32) (i32.const 8))
+  (func $f9 (export "f9") (result i32) (i32.const 9))
+  (func $f10 (export "f10") (result i32) (i32.const 10))
+  (func $f11 (export "f11") (result i32) (i32.const 11))
+  (func $f12 (export "f12") (result i32) (i32.const 12))
+  (func $f13 (export "f13") (result i32) (i32.const 13))
+  (func $f14 (export "f14") (result i32) (i32.const 14))
+  (func $f15 (export "f15") (result i32) (i32.const 15))
+  (func (export "test") (param $n i32) (result i32)
+    (call_indirect (type 0) (local.get $n)))
+  (func (export "run") (param $offs i32) (param $len i32)
+    (table.init 0 (local.get $offs) (i32.const 8) (local.get $len))))
+(assert_trap (invoke "run" (i32.const 0) (i32.const 4294967292)) "out of bounds table access")
+(assert_trap (invoke "test" (i32.const 0)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 2)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 3)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 4)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 5)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 6)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 7)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 8)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 9)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 10)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 11)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 12)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 13)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 14)) "uninitialized element")
+(assert_trap (invoke "test" (i32.const 15)) "uninitialized element")
+
+(module
+  (table 1 funcref)
+  ;; 65 elem segments. 64 is the smallest positive number that is encoded
+  ;; differently as a signed LEB.
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref) (elem funcref) (elem funcref) (elem funcref)
+  (elem funcref)
+  (func (table.init 64 (i32.const 0) (i32.const 0) (i32.const 0))))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_set.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_set.wast
new file mode 100644
index 0000000..5a9cfa3
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_set.wast
@@ -0,0 +1,119 @@
+(module
+  (table $t2 1 externref)
+  (table $t3 2 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "get-externref") (param $i i32) (result externref)
+    (table.get $t2 (local.get $i))
+  )
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+
+  (func (export "set-externref") (param $i i32) (param $r externref)
+    (table.set $t2 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref") (param $i i32) (param $r funcref)
+    (table.set $t3 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref-from") (param $i i32) (param $j i32)
+    (table.set $t3 (local.get $i) (table.get $t3 (local.get $j)))
+  )
+
+  (func (export "is_null-funcref") (param $i i32) (result i32)
+    (ref.is_null (call $f3 (local.get $i)))
+  )
+)
+
+(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern))
+(assert_return (invoke "set-externref" (i32.const 0) (ref.extern 1)))
+(assert_return (invoke "get-externref" (i32.const 0)) (ref.extern 1))
+(assert_return (invoke "set-externref" (i32.const 0) (ref.null extern)))
+(assert_return (invoke "get-externref" (i32.const 0)) (ref.null extern))
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+(assert_return (invoke "set-funcref-from" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "is_null-funcref" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "set-funcref" (i32.const 0) (ref.null func)))
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+
+(assert_trap (invoke "set-externref" (i32.const 2) (ref.null extern)) "out of bounds table access")
+(assert_trap (invoke "set-funcref" (i32.const 3) (ref.null func)) "out of bounds table access")
+(assert_trap (invoke "set-externref" (i32.const -1) (ref.null extern)) "out of bounds table access")
+(assert_trap (invoke "set-funcref" (i32.const -1) (ref.null func)) "out of bounds table access")
+
+(assert_trap (invoke "set-externref" (i32.const 2) (ref.extern 0)) "out of bounds table access")
+(assert_trap (invoke "set-funcref-from" (i32.const 3) (i32.const 1)) "out of bounds table access")
+(assert_trap (invoke "set-externref" (i32.const -1) (ref.extern 0)) "out of bounds table access")
+(assert_trap (invoke "set-funcref-from" (i32.const -1) (i32.const 1)) "out of bounds table access")
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-value-empty-vs-i32-externref
+      (table.set $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-index-empty-vs-i32
+      (table.set $t (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-value-empty-vs-externref
+      (table.set $t (i32.const 1))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-size-f32-vs-i32
+      (table.set $t (f32.const 1) (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 10 funcref)
+    (func $type-value-externref-vs-funcref (param $r externref)
+      (table.set $t (i32.const 1) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t1 1 externref)
+    (table $t2 1 funcref)
+    (func $type-value-externref-vs-funcref-multi (param $r externref)
+      (table.set $t2 (i32.const 0) (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table $t 10 externref)
+    (func $type-result-empty-vs-num (result i32)
+      (table.set $t (i32.const 0) (ref.null extern))
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_size.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_size.wast
new file mode 100644
index 0000000..ad293b5
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/table_size.wast
@@ -0,0 +1,86 @@
+(module
+  (table $t0 0 externref)
+  (table $t1 1 externref)
+  (table $t2 0 2 externref)
+  (table $t3 3 8 externref)
+
+  (func (export "size-t0") (result i32) (table.size $t0))
+  (func (export "size-t1") (result i32) (table.size $t1))
+  (func (export "size-t2") (result i32) (table.size $t2))
+  (func (export "size-t3") (result i32) (table.size $t3))
+
+  (func (export "grow-t0") (param $sz i32)
+    (drop (table.grow $t0 (ref.null extern) (local.get $sz)))
+  )
+  (func (export "grow-t1") (param $sz i32)
+    (drop (table.grow $t1 (ref.null extern) (local.get $sz)))
+  )
+  (func (export "grow-t2") (param $sz i32)
+    (drop (table.grow $t2 (ref.null extern) (local.get $sz)))
+  )
+  (func (export "grow-t3") (param $sz i32)
+    (drop (table.grow $t3 (ref.null extern) (local.get $sz)))
+  )
+)
+
+(assert_return (invoke "size-t0") (i32.const 0))
+(assert_return (invoke "grow-t0" (i32.const 1)))
+(assert_return (invoke "size-t0") (i32.const 1))
+(assert_return (invoke "grow-t0" (i32.const 4)))
+(assert_return (invoke "size-t0") (i32.const 5))
+(assert_return (invoke "grow-t0" (i32.const 0)))
+(assert_return (invoke "size-t0") (i32.const 5))
+
+(assert_return (invoke "size-t1") (i32.const 1))
+(assert_return (invoke "grow-t1" (i32.const 1)))
+(assert_return (invoke "size-t1") (i32.const 2))
+(assert_return (invoke "grow-t1" (i32.const 4)))
+(assert_return (invoke "size-t1") (i32.const 6))
+(assert_return (invoke "grow-t1" (i32.const 0)))
+(assert_return (invoke "size-t1") (i32.const 6))
+
+(assert_return (invoke "size-t2") (i32.const 0))
+(assert_return (invoke "grow-t2" (i32.const 3)))
+(assert_return (invoke "size-t2") (i32.const 0))
+(assert_return (invoke "grow-t2" (i32.const 1)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 0)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 4)))
+(assert_return (invoke "size-t2") (i32.const 1))
+(assert_return (invoke "grow-t2" (i32.const 1)))
+(assert_return (invoke "size-t2") (i32.const 2))
+
+(assert_return (invoke "size-t3") (i32.const 3))
+(assert_return (invoke "grow-t3" (i32.const 1)))
+(assert_return (invoke "size-t3") (i32.const 4))
+(assert_return (invoke "grow-t3" (i32.const 3)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 0)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 2)))
+(assert_return (invoke "size-t3") (i32.const 7))
+(assert_return (invoke "grow-t3" (i32.const 1)))
+(assert_return (invoke "size-t3") (i32.const 8))
+
+
+;; Type errors
+
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-empty
+      (table.size $t)
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (table $t 1 externref)
+    (func $type-result-i32-vs-f32 (result f32)
+      (table.size $t)
+    )
+  )
+  "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/token.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/token.wast
new file mode 100644
index 0000000..1dcd32e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/token.wast
@@ -0,0 +1,10 @@
+;; Test tokenization
+
+(assert_malformed
+  (module quote "(func (drop (i32.const0)))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func br 0drop)")
+  "unknown operator"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/traps.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/traps.wast
new file mode 100644
index 0000000..142fa22
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/traps.wast
@@ -0,0 +1,91 @@
+;; Test that traps are preserved even in instructions which might otherwise
+;; be dead-code-eliminated. These functions all perform an operation and
+;; discard its return value.
+
+(module
+  (func (export "no_dce.i32.div_s") (param $x i32) (param $y i32)
+    (drop (i32.div_s (local.get $x) (local.get $y))))
+  (func (export "no_dce.i32.div_u") (param $x i32) (param $y i32)
+    (drop (i32.div_u (local.get $x) (local.get $y))))
+  (func (export "no_dce.i64.div_s") (param $x i64) (param $y i64)
+    (drop (i64.div_s (local.get $x) (local.get $y))))
+  (func (export "no_dce.i64.div_u") (param $x i64) (param $y i64)
+    (drop (i64.div_u (local.get $x) (local.get $y))))
+)
+
+(assert_trap (invoke "no_dce.i32.div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i32.div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i64.div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i64.div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i32.div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
+(assert_trap (invoke "no_dce.i64.div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
+
+(module
+  (func (export "no_dce.i32.rem_s") (param $x i32) (param $y i32)
+    (drop (i32.rem_s (local.get $x) (local.get $y))))
+  (func (export "no_dce.i32.rem_u") (param $x i32) (param $y i32)
+    (drop (i32.rem_u (local.get $x) (local.get $y))))
+  (func (export "no_dce.i64.rem_s") (param $x i64) (param $y i64)
+    (drop (i64.rem_s (local.get $x) (local.get $y))))
+  (func (export "no_dce.i64.rem_u") (param $x i64) (param $y i64)
+    (drop (i64.rem_u (local.get $x) (local.get $y))))
+)
+
+(assert_trap (invoke "no_dce.i32.rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i32.rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i64.rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i64.rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+
+(module
+  (func (export "no_dce.i32.trunc_f32_s") (param $x f32) (drop (i32.trunc_f32_s (local.get $x))))
+  (func (export "no_dce.i32.trunc_f32_u") (param $x f32) (drop (i32.trunc_f32_u (local.get $x))))
+  (func (export "no_dce.i32.trunc_f64_s") (param $x f64) (drop (i32.trunc_f64_s (local.get $x))))
+  (func (export "no_dce.i32.trunc_f64_u") (param $x f64) (drop (i32.trunc_f64_u (local.get $x))))
+  (func (export "no_dce.i64.trunc_f32_s") (param $x f32) (drop (i64.trunc_f32_s (local.get $x))))
+  (func (export "no_dce.i64.trunc_f32_u") (param $x f32) (drop (i64.trunc_f32_u (local.get $x))))
+  (func (export "no_dce.i64.trunc_f64_s") (param $x f64) (drop (i64.trunc_f64_s (local.get $x))))
+  (func (export "no_dce.i64.trunc_f64_u") (param $x f64) (drop (i64.trunc_f64_u (local.get $x))))
+)
+
+(assert_trap (invoke "no_dce.i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "no_dce.i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+
+(module
+    (memory 1)
+
+    (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (local.get $i))))
+    (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (local.get $i))))
+    (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (local.get $i))))
+    (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (local.get $i))))
+    (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (local.get $i))))
+    (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (local.get $i))))
+    (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (local.get $i))))
+    (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (local.get $i))))
+    (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (local.get $i))))
+    (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (local.get $i))))
+    (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (local.get $i))))
+    (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (local.get $i))))
+    (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (local.get $i))))
+    (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (local.get $i))))
+)
+
+(assert_trap (invoke "no_dce.i32.load" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i32.load16_s" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i32.load16_u" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i32.load8_s" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i32.load8_u" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load32_s" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load32_u" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load16_s" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load16_u" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load8_s" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.i64.load8_u" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.f32.load" (i32.const 65536)) "out of bounds memory access")
+(assert_trap (invoke "no_dce.f64.load" (i32.const 65536)) "out of bounds memory access")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/type.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/type.wast
new file mode 100644
index 0000000..b94063e
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/type.wast
@@ -0,0 +1,50 @@
+;; Test type definitions
+
+(module
+  (type (func))
+  (type $t (func))
+
+  (type (func (param i32)))
+  (type (func (param $x i32)))
+  (type (func (result i32)))
+  (type (func (param i32) (result i32)))
+  (type (func (param $x i32) (result i32)))
+
+  (type (func (param f32 f64)))
+  (type (func (result i64 f32)))
+  (type (func (param i32 i64) (result f32 f64)))
+
+  (type (func (param f32) (param f64)))
+  (type (func (param $x f32) (param f64)))
+  (type (func (param f32) (param $y f64)))
+  (type (func (param $x f32) (param $y f64)))
+  (type (func (result i64) (result f32)))
+  (type (func (param i32) (param i64) (result f32) (result f64)))
+  (type (func (param $x i32) (param $y i64) (result f32) (result f64)))
+
+  (type (func (param f32 f64) (param $x i32) (param f64 i32 i32)))
+  (type (func (result i64 i64 f32) (result f32 i32)))
+  (type
+    (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
+  )
+
+  (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param)))
+  (type
+    (func (result) (result) (result i64 i64) (result) (result f32) (result))
+  )
+  (type
+    (func
+      (param i32 i32) (param i64 i32) (param) (param $x i32) (param)
+      (result) (result f32 f64) (result f64 i32) (result)
+    )
+  )
+)
+
+(assert_malformed
+  (module quote "(type (func (result i32) (param i32)))")
+  "result before parameter"
+)
+(assert_malformed
+  (module quote "(type (func (result $x i32)))")
+  "unexpected token"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreachable.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreachable.wast
new file mode 100644
index 0000000..3074847
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreachable.wast
@@ -0,0 +1,304 @@
+;; Test `unreachable` operator
+
+(module
+  ;; Auxiliary definitions
+  (func $dummy)
+  (func $dummy3 (param i32 i32 i32))
+
+  (func (export "type-i32") (result i32) (unreachable))
+  (func (export "type-i64") (result i32) (unreachable))
+  (func (export "type-f32") (result f64) (unreachable))
+  (func (export "type-f64") (result f64) (unreachable))
+
+  (func (export "as-func-first") (result i32)
+    (unreachable) (i32.const -1)
+  )
+  (func (export "as-func-mid") (result i32)
+    (call $dummy) (unreachable) (i32.const -1)
+  )
+  (func (export "as-func-last")
+    (call $dummy) (unreachable)
+  )
+  (func (export "as-func-value") (result i32)
+    (call $dummy) (unreachable)
+  )
+
+  (func (export "as-block-first") (result i32)
+    (block (result i32) (unreachable) (i32.const 2))
+  )
+  (func (export "as-block-mid") (result i32)
+    (block (result i32) (call $dummy) (unreachable) (i32.const 2))
+  )
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (unreachable))
+  )
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (unreachable))
+  )
+  (func (export "as-block-broke") (result i32)
+    (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (unreachable) (i32.const 2))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (unreachable) (i32.const 2))
+  )
+  (func (export "as-loop-last")
+    (loop (nop) (call $dummy) (unreachable))
+  )
+  (func (export "as-loop-broke") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable))
+    )
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (unreachable)))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (unreachable)))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (unreachable)))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-2") (result i32)
+    (block (result i32)
+      (block (result i32) (br_table 0 1 (unreachable) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-and-index") (result i32)
+    (block (result i32) (br_table 0 0 (unreachable)) (i32.const 8))
+  )
+
+  (func (export "as-return-value") (result i64)
+    (return (unreachable))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
+  )
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1)))
+  )
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable)))
+  )
+  (func (export "as-if-then-no-else") (param i32 i32) (result i32)
+    (if (local.get 0) (then (unreachable))) (local.get 1)
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (unreachable) (local.get 0) (local.get 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (local.get 0) (unreachable) (local.get 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (unreachable))
+  )
+
+  (func (export "as-call-first")
+    (call $dummy3 (unreachable) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid")
+    (call $dummy3 (i32.const 1) (unreachable) (i32.const 3))
+  )
+  (func (export "as-call-last")
+    (call $dummy3 (i32.const 1) (i32.const 2) (unreachable))
+  )
+
+  (type $sig (func (param i32 i32 i32)))
+  (table funcref (elem $dummy3))
+  (func (export "as-call_indirect-func")
+    (call_indirect (type $sig)
+      (unreachable) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-first")
+    (call_indirect (type $sig)
+      (i32.const 0) (unreachable) (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-mid")
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (unreachable) (i32.const 3)
+    )
+  )
+  (func (export "as-call_indirect-last")
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (unreachable)
+    )
+  )
+
+  (func (export "as-local.set-value") (local f32)
+    (local.set 0 (unreachable))
+  )
+  (func (export "as-local.tee-value") (result f32) (local f32)
+    (local.tee 0 (unreachable))
+  )
+  (global $a (mut f32) (f32.const 0))
+  (func (export "as-global.set-value") (result f32)
+    (global.set $a (unreachable))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (f32.load (unreachable))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (i64.load8_s (unreachable))
+  )
+
+  (func (export "as-store-address")
+    (f64.store (unreachable) (f64.const 7))
+  )
+  (func (export "as-store-value")
+    (i64.store (i32.const 2) (unreachable))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (unreachable) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i64.store16 (i32.const 2) (unreachable))
+  )
+
+  (func (export "as-unary-operand") (result f32)
+    (f32.neg (unreachable))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (unreachable) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i64)
+    (i64.sub (i64.const 10) (unreachable))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (unreachable))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (f64.le (unreachable) (f64.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (f32.ne (f32.const 10) (unreachable))
+  )
+
+  (func (export "as-convert-operand") (result i32)
+    (i32.wrap_i64 (unreachable))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (unreachable))
+  )
+)
+
+(assert_trap (invoke "type-i32") "unreachable")
+(assert_trap (invoke "type-i64") "unreachable")
+(assert_trap (invoke "type-f32") "unreachable")
+(assert_trap (invoke "type-f64") "unreachable")
+
+(assert_trap (invoke "as-func-first") "unreachable")
+(assert_trap (invoke "as-func-mid") "unreachable")
+(assert_trap (invoke "as-func-last") "unreachable")
+(assert_trap (invoke "as-func-value") "unreachable")
+
+(assert_trap (invoke "as-block-first") "unreachable")
+(assert_trap (invoke "as-block-mid") "unreachable")
+(assert_trap (invoke "as-block-last") "unreachable")
+(assert_trap (invoke "as-block-value") "unreachable")
+(assert_return (invoke "as-block-broke") (i32.const 1))
+
+(assert_trap (invoke "as-loop-first") "unreachable")
+(assert_trap (invoke "as-loop-mid") "unreachable")
+(assert_trap (invoke "as-loop-last") "unreachable")
+(assert_return (invoke "as-loop-broke") (i32.const 1))
+
+(assert_trap (invoke "as-br-value") "unreachable")
+
+(assert_trap (invoke "as-br_if-cond") "unreachable")
+(assert_trap (invoke "as-br_if-value") "unreachable")
+(assert_trap (invoke "as-br_if-value-cond") "unreachable")
+
+(assert_trap (invoke "as-br_table-index") "unreachable")
+(assert_trap (invoke "as-br_table-value") "unreachable")
+(assert_trap (invoke "as-br_table-value-2") "unreachable")
+(assert_trap (invoke "as-br_table-value-index") "unreachable")
+(assert_trap (invoke "as-br_table-value-and-index") "unreachable")
+
+(assert_trap (invoke "as-return-value") "unreachable")
+
+(assert_trap (invoke "as-if-cond") "unreachable")
+(assert_trap (invoke "as-if-then" (i32.const 1) (i32.const 6)) "unreachable")
+(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
+(assert_trap (invoke "as-if-else" (i32.const 0) (i32.const 6)) "unreachable")
+(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
+(assert_trap (invoke "as-if-then-no-else" (i32.const 1) (i32.const 6)) "unreachable")
+(assert_return (invoke "as-if-then-no-else" (i32.const 0) (i32.const 6)) (i32.const 6))
+
+(assert_trap (invoke "as-select-first" (i32.const 0) (i32.const 6)) "unreachable")
+(assert_trap (invoke "as-select-first" (i32.const 1) (i32.const 6)) "unreachable")
+(assert_trap (invoke "as-select-second" (i32.const 0) (i32.const 6)) "unreachable")
+(assert_trap (invoke "as-select-second" (i32.const 1) (i32.const 6)) "unreachable")
+(assert_trap (invoke "as-select-cond") "unreachable")
+
+(assert_trap (invoke "as-call-first") "unreachable")
+(assert_trap (invoke "as-call-mid") "unreachable")
+(assert_trap (invoke "as-call-last") "unreachable")
+
+(assert_trap (invoke "as-call_indirect-func") "unreachable")
+(assert_trap (invoke "as-call_indirect-first") "unreachable")
+(assert_trap (invoke "as-call_indirect-mid") "unreachable")
+(assert_trap (invoke "as-call_indirect-last") "unreachable")
+
+(assert_trap (invoke "as-local.set-value") "unreachable")
+(assert_trap (invoke "as-local.tee-value") "unreachable")
+(assert_trap (invoke "as-global.set-value") "unreachable")
+
+(assert_trap (invoke "as-load-address") "unreachable")
+(assert_trap (invoke "as-loadN-address") "unreachable")
+
+(assert_trap (invoke "as-store-address") "unreachable")
+(assert_trap (invoke "as-store-value") "unreachable")
+(assert_trap (invoke "as-storeN-address") "unreachable")
+(assert_trap (invoke "as-storeN-value") "unreachable")
+
+(assert_trap (invoke "as-unary-operand") "unreachable")
+
+(assert_trap (invoke "as-binary-left") "unreachable")
+(assert_trap (invoke "as-binary-right") "unreachable")
+
+(assert_trap (invoke "as-test-operand") "unreachable")
+
+(assert_trap (invoke "as-compare-left") "unreachable")
+(assert_trap (invoke "as-compare-right") "unreachable")
+
+(assert_trap (invoke "as-convert-operand") "unreachable")
+
+(assert_trap (invoke "as-memory.grow-size") "unreachable")
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreached-invalid.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreached-invalid.wast
new file mode 100644
index 0000000..3ddd773
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unreached-invalid.wast
@@ -0,0 +1,695 @@
+;; Failures in unreachable code.
+
+(assert_invalid
+  (module (func $local-index (unreachable) (drop (local.get 0))))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $global-index (unreachable) (drop (global.get 0))))
+  "unknown global"
+)
+(assert_invalid
+  (module (func $func-index (unreachable) (call 1)))
+  "unknown function"
+)
+(assert_invalid
+  (module (func $label-index (unreachable) (br 1)))
+  "unknown label"
+)
+
+(assert_invalid
+  (module (func $type-num-vs-num
+    (unreachable) (drop (i64.eqz (i32.const 0))))
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-num-vs-num (result i32)
+    (unreachable) (i64.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-poly-transitive-num-vs-num (result i32)
+    (unreachable)
+    (i64.const 0) (i32.const 0) (select)
+    (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unconsumed-const (unreachable) (i32.const 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result (unreachable) (i32.eqz)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-result2
+    (unreachable) (i32.const 0) (i32.add)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly0 (unreachable) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly1 (unreachable) (i32.const 0) (select)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unconsumed-poly2
+    (unreachable) (i32.const 0) (i32.const 0) (select)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-break
+    (block (br 0) (block (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-break
+    (block (br 0) (drop (i32.eqz (f32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-break
+    (block (br 0) (block (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-break
+    (block (br 0) (drop (f32.eq (i32.const 1) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-break
+    (block (br 0) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-break (result i32)
+    (block (result i32) (i32.const 1) (br 0) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-break
+    (block (loop (br 1) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-break (result i32)
+    (loop (result i32) (br 1 (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-break
+    (br 0) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-break (result i32)
+    (br 0 (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-return
+    (return) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-return
+    (return) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-return
+    (return) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-return
+    (return) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-return
+    (block (return) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-return (result i32)
+    (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-return
+    (block (loop (return) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-return (result i32)
+    (loop (result i32) (return (i32.const 1)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-return
+    (return) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-return (result i32)
+    (return (i32.const 1)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-loop-after-unreachable
+    (unreachable) (loop (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable
+    (unreachable) (loop (result i32) (i32.eqz (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-unreachable
+    (unreachable) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-unreachable
+    (unreachable) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-unreachable
+    (unreachable) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-unreachable
+    (block (unreachable) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (i32.const 1) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-unreachable
+    (block (loop (unreachable) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-unreachable (result i32)
+    (loop (result i32) (unreachable) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-unreachable
+    (unreachable) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-unreachable (result i32)
+    (unreachable) (f32.const 0)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-if-after-unreachable
+    (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable
+    (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable-if
+    (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-nested-unreachable
+    (block (unreachable)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-nested-unreachable
+    (block (block (unreachable)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-nested-unreachable
+    (block (loop (block (unreachable)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (loop (result i32) (block (unreachable)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-nested-unreachable
+    (block (unreachable)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-nested-unreachable
+    (result i32)
+    (block (unreachable)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (i32.eqz (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-after-infinite-loop
+    (loop (br 0)) (block (drop (f32.eq (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-after-infinite-loop
+    (loop (br 0)) (drop (f32.eq (i32.const 1) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-after-infinite-loop
+    (block (loop (br 0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32)
+    (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-void-after-infinite-loop
+    (block (loop (loop (br 0)) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (result i32) (loop (br 0)) (f32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-void-after-infinite-loop
+    (loop (br 0)) (i32.const 1)
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-func-value-num-vs-num-after-infinite-loop (result i32)
+    (loop (br 0)) (f32.const 0)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (i32.eqz (f32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-binary-num-vs-num-in-dead-body
+    (if (i32.const 0) (then (drop (f32.eq (i32.const 1) (f32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-if-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (block (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-void-in-dead-body
+    (if (i32.const 0) (then (loop (i32.const 1))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
+    (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-return-second-num-vs-num (result i32)
+    (return (i32.const 1)) (return (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br-second-num-vs-num (result i32)
+    (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-br_if-cond-num-vs-num-after-unreachable
+    (block (br_if 0 (unreachable) (f32.const 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-void-after-unreachable (result i32)
+    (block (result i32)
+      (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+      (drop) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num2-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-num-vs-num-after-unreachable
+    (block (br_table 0 (unreachable) (f32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32)
+    (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_table-label-num-vs-label-void-after-unreachable
+    (block
+      (block (result f32)
+        (unreachable)
+        (br_table 0 1 0 (i32.const 1))
+      )
+      (drop)
+    )
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-void
+    (block (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-void-vs-num (result i32)
+    (block (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-unreachable-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (unreachable))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-void
+    (block (i32.const 3) (block (br 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-void-vs-num (result i32)
+    (block (result i32) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-br-num-vs-num (result i32)
+    (block (result i32) (i64.const 0) (block (br 1 (i32.const 0))))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-void
+    (block (block (i32.const 3) (block (br 2))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-void-vs-num (result i32)
+    (block (result i32) (block (block (br 2 (i32.const 0)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num-vs-num (result i32)
+    (block (result i32)
+      (block (result i64) (i64.const 0) (block (br 2 (i32.const 0))))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested2-br-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (br 1))) (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-void
+    (block (i32.const 3) (block (return)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-void-vs-num (result i32)
+    (block (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num-vs-num (result i32)
+    (block (result i64) (i64.const 0) (block (return (i32.const 0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-block-value-nested-return-num2-vs-void (result i32)
+    (block (i32.const 3) (block (i64.const 1) (return (i32.const 0))))
+    (i32.const 9)
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-void
+    (loop (i32.const 3) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-void-vs-num (result i32)
+    (loop (block (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32)
+    (loop (result i64) (i64.const 0) (block (unreachable)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-cont-last-void-vs-empty (result i32)
+    (loop (br 0 (nop)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-cont-last-num-vs-empty (result i32)
+    (loop (br 0 (i32.const 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $tee-local-unreachable-value
+    (local i32)
+    (local.tee 0 (unreachable))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $br_if-unreachable (result i32)
+    (block (result i32)
+      (block
+        (br_if 1 (unreachable) (i32.const 0))
+      )
+      (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid 
+  (module
+    (func $type-br_if-after-unreachable (result i64)
+      unreachable
+      br_if 0
+      i64.extend_i32_u
+    )
+  )
+ "type mismatch"
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unwind.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unwind.wast
new file mode 100644
index 0000000..85db60b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/unwind.wast
@@ -0,0 +1,267 @@
+;; Test that control-flow transfer unwinds stack and it can be anything after.
+
+(module
+  (func (export "func-unwind-by-unreachable")
+    (i32.const 3) (i64.const 1) (unreachable)
+  )
+  (func (export "func-unwind-by-br")
+    (i32.const 3) (i64.const 1) (br 0)
+  )
+  (func (export "func-unwind-by-br-value") (result i32)
+    (i32.const 3) (i64.const 1) (br 0 (i32.const 9))
+  )
+  (func (export "func-unwind-by-br_if")
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))
+  )
+  (func (export "func-unwind-by-br_if-value") (result i32)
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+  )
+  (func (export "func-unwind-by-br_table")
+    (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))
+  )
+  (func (export "func-unwind-by-br_table-value") (result i32)
+    (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+  )
+  (func (export "func-unwind-by-return") (result i32)
+    (i32.const 3) (i64.const 1) (return (i32.const 9))
+  )
+
+  (func (export "block-unwind-by-unreachable")
+    (block (i32.const 3) (i64.const 1) (unreachable))
+  )
+  (func (export "block-unwind-by-br") (result i32)
+    (block (i32.const 3) (i64.const 1) (br 0)) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br-value") (result i32)
+    (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9)))
+  )
+  (func (export "block-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+    )
+  )
+  (func (export "block-unwind-by-br_table") (result i32)
+    (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br_table-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+    )
+  )
+  (func (export "block-unwind-by-return") (result i32)
+    (block (result i32) (i32.const 3) (i64.const 1) (return (i32.const 9)))
+  )
+
+  (func (export "block-nested-unwind-by-unreachable") (result i32)
+    (block (result i32) (i32.const 3) (block (i64.const 1) (unreachable)))
+  )
+  (func (export "block-nested-unwind-by-br") (result i32)
+    (block (i32.const 3) (block (i64.const 1) (br 1)) (drop)) (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9)))
+    )
+  )
+  (func (export "block-nested-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (block (i64.const 1) (drop (br_if 1 (i32.const 1)))) (drop)) (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (drop (drop (br_if 1 (i32.const 9) (i32.const 1)))))
+    )
+  )
+  (func (export "block-nested-unwind-by-br_table") (result i32)
+    (block
+      (i32.const 3) (block (i64.const 1) (br_table 1 (i32.const 1)))
+      (drop)
+    )
+    (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br_table-value") (result i32)
+    (block (result i32)
+      (i32.const 3)
+      (block (i64.const 1) (br_table 1 (i32.const 9) (i32.const 1)))
+    )
+  )
+  (func (export "block-nested-unwind-by-return") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (return (i32.const 9)))
+    )
+  )
+
+  (func (export "unary-after-unreachable") (result i32)
+    (f32.const 0) (unreachable) (i64.eqz)
+  )
+  (func (export "unary-after-br") (result i32)
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz))
+  )
+  (func (export "unary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1))) (i64.eqz)
+    )
+  )
+  (func (export "unary-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz)
+    )
+  )
+  (func (export "unary-after-return") (result i32)
+    (f32.const 0) (return (i32.const 9)) (i64.eqz)
+  )
+
+  (func (export "binary-after-unreachable") (result i32)
+    (f32.const 0) (f64.const 1) (unreachable) (i64.eq)
+  )
+  (func (export "binary-after-br") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq)
+    )
+  )
+  (func (export "binary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (i64.const 1) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (i64.eq)
+    )
+  )
+  (func (export "binary-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
+      (i64.eq)
+    )
+  )
+  (func (export "binary-after-return") (result i32)
+    (f32.const 0) (f64.const 1) (return (i32.const 9)) (i64.eq)
+  )
+
+  (func (export "select-after-unreachable") (result i32)
+    (f32.const 0) (f64.const 1) (i64.const 0) (unreachable) (select)
+  )
+  (func (export "select-after-br") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select)
+    )
+  )
+  (func (export "select-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (i32.const 1) (i32.const 0)
+      (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (select)
+    )
+  )
+  (func (export "select-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (i64.const 0)
+      (br_table 0 (i32.const 9) (i32.const 0))
+      (select)
+    )
+  )
+  (func (export "select-after-return") (result i32)
+    (f32.const 0) (f64.const 1) (i64.const 1) (return (i32.const 9)) (select)
+  )
+
+  (func (export "block-value-after-unreachable") (result i32)
+    (block (result i32) (f32.const 0) (unreachable))
+  )
+  (func (export "block-value-after-br") (result i32)
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)))
+  )
+  (func (export "block-value-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+    )
+  )
+  (func (export "block-value-after-br_table") (result i32)
+    (block (result i32)
+      (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0))
+    )
+  )
+  (func (export "block-value-after-return") (result i32)
+    (block (result i32) (f32.const 0) (return (i32.const 9)))
+  )
+
+  (func (export "loop-value-after-unreachable") (result i32)
+    (loop (result i32) (f32.const 0) (unreachable))
+  )
+  (func (export "loop-value-after-br") (result i32)
+    (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9))))
+  )
+  (func (export "loop-value-after-br_if") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (i32.const 0) (drop (br_if 1 (i32.const 9) (i32.const 1)))
+      )
+    )
+  )
+
+  (func (export "loop-value-after-br_table") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0))
+      )
+    )
+  )
+  (func (export "loop-value-after-return") (result i32)
+    (loop (result i32) (f32.const 0) (return (i32.const 9)))
+  )
+)
+
+(assert_trap (invoke "func-unwind-by-unreachable") "unreachable")
+(assert_return (invoke "func-unwind-by-br"))
+(assert_return (invoke "func-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "func-unwind-by-br_if"))
+(assert_return (invoke "func-unwind-by-br_if-value") (i32.const 9))
+(assert_return (invoke "func-unwind-by-br_table"))
+(assert_return (invoke "func-unwind-by-br_table-value") (i32.const 9))
+(assert_return (invoke "func-unwind-by-return") (i32.const 9))
+
+(assert_trap (invoke "block-unwind-by-unreachable") "unreachable")
+(assert_return (invoke "block-unwind-by-br") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_if") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_if-value") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_table") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_table-value") (i32.const 9))
+(assert_return (invoke "block-unwind-by-return") (i32.const 9))
+
+(assert_trap (invoke "block-nested-unwind-by-unreachable") "unreachable")
+(assert_return (invoke "block-nested-unwind-by-br") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_if") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_if-value") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_table") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_table-value") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-return") (i32.const 9))
+
+(assert_trap (invoke "unary-after-unreachable") "unreachable")
+(assert_return (invoke "unary-after-br") (i32.const 9))
+(assert_return (invoke "unary-after-br_if") (i32.const 9))
+(assert_return (invoke "unary-after-br_table") (i32.const 9))
+(assert_return (invoke "unary-after-return") (i32.const 9))
+
+(assert_trap (invoke "binary-after-unreachable") "unreachable")
+(assert_return (invoke "binary-after-br") (i32.const 9))
+(assert_return (invoke "binary-after-br_if") (i32.const 9))
+(assert_return (invoke "binary-after-br_table") (i32.const 9))
+(assert_return (invoke "binary-after-return") (i32.const 9))
+
+(assert_trap (invoke "select-after-unreachable") "unreachable")
+(assert_return (invoke "select-after-br") (i32.const 9))
+(assert_return (invoke "select-after-br_if") (i32.const 9))
+(assert_return (invoke "select-after-br_table") (i32.const 9))
+(assert_return (invoke "select-after-return") (i32.const 9))
+
+(assert_trap (invoke "block-value-after-unreachable") "unreachable")
+(assert_return (invoke "block-value-after-br") (i32.const 9))
+(assert_return (invoke "block-value-after-br_if") (i32.const 9))
+(assert_return (invoke "block-value-after-br_table") (i32.const 9))
+(assert_return (invoke "block-value-after-return") (i32.const 9))
+
+(assert_trap (invoke "loop-value-after-unreachable") "unreachable")
+(assert_return (invoke "loop-value-after-br") (i32.const 9))
+(assert_return (invoke "loop-value-after-br_if") (i32.const 9))
+(assert_return (invoke "loop-value-after-br_table") (i32.const 9))
+(assert_return (invoke "loop-value-after-return") (i32.const 9))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/update-testsuite.sh b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/update-testsuite.sh
new file mode 100755
index 0000000..8f4a819
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/update-testsuite.sh
@@ -0,0 +1,152 @@
+#!/bin/bash
+# Update tests based on upstream repositories.
+set -e
+set -u
+set -o pipefail
+
+repos='
+  spec
+  threads
+  simd
+  exception-handling
+  gc
+  bulk-memory-operations
+  tail-call
+  nontrapping-float-to-int-conversions
+  multi-value
+  host-bindings
+  sign-extension-ops
+  reference-types
+  annotations
+'
+
+log_and_run() {
+    echo ">>" $*
+    if ! $*; then
+        echo "sub-command failed: $*"
+        exit
+    fi
+}
+
+try_log_and_run() {
+    echo ">>" $*
+    $*
+}
+
+pushdir() {
+    pushd $1 >/dev/null || exit
+}
+
+popdir() {
+    popd >/dev/null || exit
+}
+
+update_repo() {
+    local repo=$1
+    pushdir repos
+        if [ -d ${repo} ]; then
+            log_and_run git -C ${repo} fetch origin
+            log_and_run git -C ${repo} reset origin/master --hard
+        else
+            log_and_run git clone https://github.com/WebAssembly/${repo}
+        fi
+
+        # Add upstream spec as "spec" remote.
+        if [ "${repo}" != "spec" ]; then
+            pushdir ${repo}
+                if ! git remote | grep spec >/dev/null; then
+                    log_and_run git remote add spec https://github.com/WebAssembly/spec
+                fi
+
+                log_and_run git fetch spec
+            popdir
+        fi
+    popdir
+}
+
+merge_with_spec() {
+    local repo=$1
+
+    [ "${repo}" == "spec" ] && return
+
+    pushdir repos/${repo}
+        # Create and checkout "try-merge" branch.
+        if ! git branch | grep try-merge >/dev/null; then
+            log_and_run git branch try-merge origin/master
+        fi
+        log_and_run git checkout try-merge
+
+        # Attempt to merge with spec/master.
+        log_and_run git reset origin/master --hard
+        try_log_and_run git merge -q spec/master -m "merged"
+        if [ $? -ne 0 ]; then
+            # Ignore merge conflicts in non-test directories.
+            # We don't care about those changes.
+            try_log_and_run git checkout --ours document interpreter
+            try_log_and_run git add document interpreter
+            try_log_and_run git -c core.editor=true merge --continue
+            if [ $? -ne 0 ]; then
+                git merge --abort
+                popdir
+                return 1
+            fi
+        fi
+    popdir
+    return 0
+}
+
+
+echo -e "Update repos\n" > commit_message
+
+failed_repos=
+
+for repo in ${repos}; do
+    echo "++ updating ${repo}"
+    update_repo ${repo}
+
+    if ! merge_with_spec ${repo}; then
+        echo -e "!! error merging ${repo}, skipping\n"
+        failed_repos="${failed_repos} ${repo}"
+        continue
+    fi
+
+    if [ "${repo}" = "spec" ]; then
+        wast_dir=.
+        log_and_run cp $(find repos/${repo}/test/core -name \*.wast) ${wast_dir}
+    else
+        wast_dir=proposals/${repo}
+        mkdir -p ${wast_dir}
+
+        # Don't add tests from propsoal that are the same as spec.
+        pushdir repos/${repo}
+            for new in $(find test/core -name \*.wast); do
+                old=../../repos/spec/${new}
+                if [[ ! -f ${old} ]] || ! diff ${old} ${new} >/dev/null; then
+                    log_and_run cp ${new} ../../${wast_dir}
+                fi
+            done
+        popdir
+    fi
+
+    # Check whether any files were updated.
+    if [ $(git status -s ${wast_dir}/*.wast | wc -l) -ne 0 ]; then
+        log_and_run git add ${wast_dir}/*.wast
+
+        repo_sha=$(git -C repos/${repo} log --max-count=1 --oneline origin/master| sed -e 's/ .*//')
+        echo "  ${repo}:" >> commit_message
+        echo "    https://github.com/WebAssembly/${repo}/commit/${repo_sha}" >> commit_message
+    fi
+
+    echo -e "-- ${repo}\n"
+done
+
+echo "" >> commit_message
+echo "This change was automatically generated by \`update-testsuite.sh\`" >> commit_message
+git commit -a -F commit_message
+# git push
+
+echo "done"
+
+if [ -n "${failed_repos}" ]; then
+  echo "!! failed to update repos: ${failed_repos}"
+fi
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-custom-section-id.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-custom-section-id.wast
new file mode 100644
index 0000000..ee5fd7c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-custom-section-id.wast
@@ -0,0 +1,1792 @@
+;;;;;; Invalid UTF-8 custom section names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\80"                       ;; "\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\8f"                       ;; "\8f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\90"                       ;; "\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\9f"                       ;; "\9f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\a0"                       ;; "\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\bf"                       ;; "\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\c2"                       ;; "\c2"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\2e"                    ;; "\c2."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\80"                    ;; "\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\bf"                    ;; "\c0\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\80"                    ;; "\c1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\bf"                    ;; "\c1\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\00"                    ;; "\c2\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\7f"                    ;; "\c2\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\c0"                    ;; "\c2\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\fd"                    ;; "\c2\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\00"                    ;; "\df\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\7f"                    ;; "\df\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\c0"                    ;; "\df\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\fd"                    ;; "\df\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\80"                    ;; "\e1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\2e"                 ;; "\e1\80."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\e1"                       ;; "\e1"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\2e"                    ;; "\e1."
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\80"                    ;; "\f1\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\23"                 ;; "\f1\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f1"                       ;; "\f1"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\23"                    ;; "\f1#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\80"                    ;; "\f8\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\23"                 ;; "\f8\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f8"                       ;; "\f8"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\23"                    ;; "\f8#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\08"                       ;; custom section
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\80"                    ;; "\fc\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\23"                 ;; "\fc\80#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fc"                       ;; "\fc"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\23"                    ;; "\fc#"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fe"                       ;; "\fe"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\ff"                       ;; "\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fe\ff"                    ;; "\fe\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\ff\fe"                    ;; "\ff\fe"
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-field.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-field.wast
new file mode 100644
index 0000000..0d030da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-field.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import field names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\80"                       ;; "\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\8f"                       ;; "\8f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\90"                       ;; "\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\9f"                       ;; "\9f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\a0"                       ;; "\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\bf"                       ;; "\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\c2"                       ;; "\c2"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\2e"                    ;; "\c2."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\80"                    ;; "\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\80"                    ;; "\c1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\00"                    ;; "\c2\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\00"                    ;; "\df\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\7f"                    ;; "\df\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\c0"                    ;; "\df\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\fd"                    ;; "\df\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\80"                    ;; "\e1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\e1"                       ;; "\e1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\2e"                    ;; "\e1."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\80"                    ;; "\f1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f1"                       ;; "\f1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\23"                    ;; "\f1#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\80"                    ;; "\f8\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f8"                       ;; "\f8"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\23"                    ;; "\f8#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\80"                    ;; "\fc\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fc"                       ;; "\fc"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\23"                    ;; "\fc#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fe"                       ;; "\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\ff"                       ;; "\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-module.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-module.wast
new file mode 100644
index 0000000..5a092da
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-import-module.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import module names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\80"                       ;; "\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\8f"                       ;; "\8f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\90"                       ;; "\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\9f"                       ;; "\9f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\a0"                       ;; "\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\bf"                       ;; "\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\c2"                       ;; "\c2"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\2e"                    ;; "\c2."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\80"                    ;; "\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\80"                    ;; "\c1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\00"                    ;; "\c2\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\00"                    ;; "\df\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\7f"                    ;; "\df\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\c0"                    ;; "\df\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\fd"                    ;; "\df\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\80"                    ;; "\e1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\e1"                       ;; "\e1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\2e"                    ;; "\e1."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\80"                    ;; "\f1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f1"                       ;; "\f1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\23"                    ;; "\f1#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed code point
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (first) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 4-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\80"                    ;; "\f8\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f8"                       ;; "\f8"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\23"                    ;; "\f8#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 5-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\80"                    ;; "\fc\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fc"                       ;; "\fc"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\23"                    ;; "\fc#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; (last) malformed 6-byte prefix
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;;;; Miscellaneous malformed bytes
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fe"                       ;; "\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; malformed byte
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\ff"                       ;; "\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "malformed UTF-8 encoding"
+)
+
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-invalid-encoding.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-invalid-encoding.wast
new file mode 100644
index 0000000..cfd5969
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/spec/utf8-invalid-encoding.wast
@@ -0,0 +1,176 @@
+(assert_malformed (module quote "(func (export \"\\00\\00\\fe\\ff\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\8f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\9f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c0\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c1\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c1\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\2e\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\00\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\7f\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\80\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\9f\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\9f\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\c0\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\fd\\a0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\2e\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\2e\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\a0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\a0\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\bf\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\bf\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\00\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\7f\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\80\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\8f\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\8f\\bf\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\00\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\7f\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\c0\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\fd\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\c0\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\fd\\90\\90\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\00\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\7f\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\c0\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\fd\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\00\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\7f\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\c0\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\fd\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\00\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\7f\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\00\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\7f\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\7f\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\c0\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\fd\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\c0\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\fd\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\90\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\bf\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\c0\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\fd\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f5\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f7\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f7\\bf\\bf\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fb\\bf\\bf\\bf\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\23\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fd\\bf\\bf\\bf\\bf\\bf\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fe\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fe\\ff\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\\fe\\00\\00\"))") "malformed UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\\fe\"))") "malformed UTF-8 encoding")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/README.md b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/README.md
new file mode 100644
index 0000000..17d398c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/README.md
@@ -0,0 +1,38 @@
+# Custom wast tests
+
+In this directory we have created wast tests for different cases
+where we want to test other scenarios than the ones offered
+by the standard WebAssembly spectests.
+
+## NaN canonicalization: `nan-canonicalization.wast`
+
+This is an extra set of tests that assure that operations with NaNs
+are deterministic regardless of the environment/chipset where it executes in.
+
+## Call Indirect Spilled Stack: `call-indirect-spilledd-stack.wast`
+
+We had an issue occuring that was making singlepass not working properly
+on the WebAssembly benchmark: https://00f.net/2019/10/22/updated-webassembly-benchmark/.
+
+This is a test case to ensure it doesn't reproduce again in the future.
+
+## Multiple Traps: `multiple-traps.wast`
+
+This is a test assuring functions that trap can be called multiple times.
+
+## Fac: `fac.wast`
+
+This is a simple factorial program.
+
+## Check that struct-return on the stack doesn't overflow: `stack-overflow-sret.wast`
+
+Stack space for a structure returning function call should be allocated once up
+front, not once in each call.
+
+## Divide by Zero: `divide.wast`
+
+This is a simple test to check that a divide by zero is correctly trapped
+
+## Atomic Load: `atomic_load.wast`
+
+This is a simple test to check that load an atomic "to far" in memory trigger a OutOfBound trap
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/atomic_load.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/atomic_load.wast
new file mode 100755
index 0000000..932b39a
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/atomic_load.wast
@@ -0,0 +1,9 @@
+(module
+    (memory 1)
+    (func (export "atomic_load")
+        i32.const 0xffff_fff0
+        i32.atomic.load offset=16
+        drop
+    )
+)
+(assert_trap (invoke "atomic_load") "out of bound")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/call-indirect-spilled-stack.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/call-indirect-spilled-stack.wast
new file mode 100644
index 0000000..95df771
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/call-indirect-spilled-stack.wast
@@ -0,0 +1,35 @@
+;; Spilled stack tests
+;; https://github.com/wasmerio/wasmer/pull/1191
+
+(module
+  ;; Auxiliary definitions
+  (type $out-i32 (func (result i32)))
+
+  (func $const-i32 (type $out-i32) (i32.const 0x132))
+
+  (table funcref
+    (elem
+      $const-i32
+    )
+  )
+
+  (memory 1)
+
+  (func (export "call-indirect-from-spilled-stack") (result i32)
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0x100000000) (i64.const 0))
+    (i32.wrap_i64)
+    (call_indirect (type $out-i32))
+    (return)
+  )
+)
+
+(assert_return (invoke "call-indirect-from-spilled-stack") (i32.const 0x132))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/divide.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/divide.wast
new file mode 100644
index 0000000..92258df
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/divide.wast
@@ -0,0 +1,4 @@
+(module
+  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y)))
+)
+(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/fac.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/fac.wast
new file mode 100644
index 0000000..ef10991
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/fac.wast
@@ -0,0 +1,89 @@
+(module
+  ;; Recursive factorial
+  (func (export "fac-rec") (param i64) (result i64)
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
+      )
+    )
+  )
+
+  ;; Recursive factorial named
+  (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
+    (if (result i64) (i64.eq (local.get $n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (local.get $n)
+          (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1)))
+        )
+      )
+    )
+  )
+
+  ;; Iterative factorial
+  (func (export "fac-iter") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
+    (block
+      (loop
+        (if
+          (i64.eq (local.get 1) (i64.const 0))
+          (then (br 2))
+          (else
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
+          )
+        )
+        (br 0)
+      )
+    )
+    (local.get 2)
+  )
+
+  ;; Iterative factorial named
+  (func (export "fac-iter-named") (param $n i64) (result i64)
+    (local $i i64)
+    (local $res i64)
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
+    (block $done
+      (loop $loop
+        (if
+          (i64.eq (local.get $i) (i64.const 0))
+          (then (br $done))
+          (else
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
+          )
+        )
+        (br $loop)
+      )
+    )
+    (local.get $res)
+  )
+
+  ;; Optimized factorial.
+  (func (export "fac-opt") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
+      (loop
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
+      )
+    )
+    (local.get 1)
+  )
+)
+
+(assert_return (invoke "fac-rec" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-rec-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-iter-named" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_return (invoke "fac-opt" (i64.const 25)) (i64.const 7034535277573963776))
+(assert_exhaustion (invoke "fac-rec" (i64.const 1073741824)) "call stack exhausted")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/int-extend-garbage.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/int-extend-garbage.wast
new file mode 100644
index 0000000..9b290d2
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/int-extend-garbage.wast
@@ -0,0 +1,35 @@
+;; https://github.com/wasmerio/wasmer/pull/1436
+;;
+;; When doing an I64ExtendI32U or other integer extension operations, the
+;; upper bits in the underlying storage must be cleared.
+;;
+;; On x86 sign extension is done with its own instruction, `movsx`, so here we only
+;; test the unsigned extension case.
+
+(module
+
+  (func (export "i64-extend-i32-u") (result i64)
+    ;; fill in stack slots allocated to registers
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+    (i64.add (i64.const 0) (i64.const 0))
+
+    ;; push an i64 to produce garbage on the higher 32 bits
+    (i64.add (i64.const -1) (i64.const 0))
+
+    ;; pop it
+    (drop)
+
+    ;; push an i32
+    (i32.add (i32.const 0) (i32.const 0))
+
+    ;; extend
+    (i64.extend_i32_u)
+    (return)
+  )
+)
+
+(assert_return (invoke "i64-extend-i32-u") (i64.const 0))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/max_size_of_memory.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/max_size_of_memory.wast
new file mode 100644
index 0000000..99116d1
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/max_size_of_memory.wast
@@ -0,0 +1 @@
+(module (memory 65536))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/multiple-traps.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/multiple-traps.wast
new file mode 100644
index 0000000..99b8e7b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/multiple-traps.wast
@@ -0,0 +1,10 @@
+;; We assert that we can call a function that traps repeatedly
+
+(module
+  (func (export "throw_trap")
+    unreachable
+  ))
+
+(assert_trap (invoke "throw_trap") "unreachable")
+(assert_trap (invoke "throw_trap") "unreachable")
+(assert_trap (invoke "throw_trap") "unreachable")
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2159.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2159.wast
new file mode 100644
index 0000000..6a1253c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2159.wast
@@ -0,0 +1,10 @@
+;; https://github.com/wasmerio/wasmer/issues/2159
+(module
+  (func (export "_start") (result f64)
+    f64.const 0x0p+0 (;=0;)
+    f64.const 0x0p+0 (;=0;)
+    f64.const 0x0p+0 (;=0;)
+    f64.div
+    f64.copysign
+  )
+)
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2347.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2347.wast
new file mode 100644
index 0000000..575d33c
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization-issue-2347.wast
@@ -0,0 +1,14 @@
+;; https://github.com/wasmerio/wasmer/issues/2347
+(module
+    (type (;0;) (func (param f64) (result i32)))
+    (func (;0;) (type 0) (param f64) (result i32)
+        unreachable)
+    (func (;1;) (type 0) (param f64) (result i32)
+        i32.const -16579585
+        f64.convert_i32_s
+        f64.ceil
+        f64.ceil
+        local.get 0
+        f64.copysign
+    unreachable))
+    
\ No newline at end of file
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization.wast
new file mode 100644
index 0000000..748029b
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/nan-canonicalization.wast
@@ -0,0 +1,221 @@
+;; NaN canonicalization tests.
+;;
+;; Things that are covered by spectests canonicalization
+;; (`fabs`, `fneg`, `fcopysign`, `reinterpret`, `const`)
+;; won't be duplicated here.
+
+(module
+  ;; Auxiliary definitions
+  (type $f32-id (func (param f32) (result f32)))
+  (type $f64-id (func (param f64) (result f64)))
+
+  (table funcref
+    (elem
+      $nan-canonicalization-f32-func-call-target
+      $nan-canonicalization-f64-func-call-target
+    )
+  )
+
+  (memory 1)
+
+  (func (export "nan-canonicalization-f32-add") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-sub") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-mul") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-div") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+  )
+  (func (export "nan-canonicalization-f32-max") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.max (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+  )
+  (func (export "nan-canonicalization-f32-min") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.min (f32.reinterpret_i32 (get_local 0)) (f32.const 1)))
+  )
+  (func (export "nan-canonicalization-f32-nearest") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.nearest (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-floor") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.floor (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-ceil") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.ceil (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-trunc") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.trunc (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-sqrt") (param i32) (result i32)
+    (i32.reinterpret_f32 (f32.sqrt (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-mem") (param i32) (result i32)
+    (f32.store (i32.const 0) (f32.reinterpret_i32 (get_local 0)))
+    (i32.reinterpret_f32 (f32.load (i32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-mem-cncl") (param i32) (result i32)
+    (f32.store (i32.const 0) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (f32.load (i32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-local") (param i32) (result i32)
+    (local f32)
+    (set_local 1 (f32.reinterpret_i32 (get_local 0)))
+    (i32.reinterpret_f32 (get_local 1))
+  )
+  (func (export "nan-canonicalization-f32-local-cncl") (param i32) (result i32)
+    (local f32)
+    (set_local 1 (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)))
+    (i32.reinterpret_f32 (get_local 1))
+  )
+  (func $nan-canonicalization-f32-func-call-target (param f32) (result f32)
+    (get_local 0)
+  )
+  (func (export "nan-canonicalization-f32-func-call") (param i32) (result i32)
+    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.reinterpret_i32 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f32-func-call-cncl") (param i32) (result i32)
+    (i32.reinterpret_f32 (call $nan-canonicalization-f32-func-call-target (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0))))
+  )
+  (func (export "nan-canonicalization-f32-func-call-indirect") (param i32) (result i32)
+    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.reinterpret_i32 (get_local 0)) (i32.const 0)))
+  )
+  (func (export "nan-canonicalization-f32-func-call-indirect-cncl") (param i32) (result i32)
+    (i32.reinterpret_f32 (call_indirect (type $f32-id) (f32.add (f32.reinterpret_i32 (get_local 0)) (f32.const 0)) (i32.const 0)))
+  )
+
+  (func (export "nan-canonicalization-f64-add") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+  )
+  (func (export "nan-canonicalization-f64-sub") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+  )
+  (func (export "nan-canonicalization-f64-mul") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+  )
+  (func (export "nan-canonicalization-f64-div") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+  )
+  (func (export "nan-canonicalization-f64-max") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.max (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+  )
+  (func (export "nan-canonicalization-f64-min") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.min (f64.reinterpret_i64 (get_local 0)) (f64.const 1)))
+  )
+  (func (export "nan-canonicalization-f64-nearest") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.nearest (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-floor") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.floor (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-ceil") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.ceil (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-trunc") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.trunc (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-sqrt") (param i64) (result i64)
+    (i64.reinterpret_f64 (f64.sqrt (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-mem") (param i64) (result i64)
+    (f64.store (i32.const 0) (f64.reinterpret_i64 (get_local 0)))
+    (i64.reinterpret_f64 (f64.load (i32.const 0)))
+  )
+  (func (export "nan-canonicalization-f64-mem-cncl") (param i64) (result i64)
+    (f64.store (i32.const 0) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (f64.load (i32.const 0)))
+  )
+  (func (export "nan-canonicalization-f64-local") (param i64) (result i64)
+    (local f64)
+    (set_local 1 (f64.reinterpret_i64 (get_local 0)))
+    (i64.reinterpret_f64 (get_local 1))
+  )
+  (func (export "nan-canonicalization-f64-local-cncl") (param i64) (result i64)
+    (local f64)
+    (set_local 1 (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)))
+    (i64.reinterpret_f64 (get_local 1))
+  )
+  (func $nan-canonicalization-f64-func-call-target (param f64) (result f64)
+    (get_local 0)
+  )
+  (func (export "nan-canonicalization-f64-func-call") (param i64) (result i64)
+    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.reinterpret_i64 (get_local 0))))
+  )
+  (func (export "nan-canonicalization-f64-func-call-cncl") (param i64) (result i64)
+    (i64.reinterpret_f64 (call $nan-canonicalization-f64-func-call-target (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0))))
+  )
+  (func (export "nan-canonicalization-f64-func-call-indirect") (param i64) (result i64)
+    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.reinterpret_i64 (get_local 0)) (i32.const 1)))
+  )
+  (func (export "nan-canonicalization-f64-func-call-indirect-cncl") (param i64) (result i64)
+    (i64.reinterpret_f64 (call_indirect (type $f64-id) (f64.add (f64.reinterpret_i64 (get_local 0)) (f64.const 0)) (i32.const 1)))
+  )
+)
+
+(assert_return (invoke "nan-canonicalization-f32-add" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-sub" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-mul" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-div" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-max" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-min" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-nearest" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-floor" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-ceil" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-trunc" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-sqrt" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-mem" (i32.const 0x7fc00001)) (i32.const 0x7fc00001))
+(assert_return (invoke "nan-canonicalization-f32-mem-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-local" (i32.const 0x7fc00001)) (i32.const 0x7fc00001))
+(assert_return (invoke "nan-canonicalization-f32-local-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-func-call" (i32.const 0x7fc00001)) (i32.const 0x7fc00001))
+(assert_return (invoke "nan-canonicalization-f32-func-call-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+(assert_return (invoke "nan-canonicalization-f32-func-call-indirect" (i32.const 0x7fc00001)) (i32.const 0x7fc00001))
+(assert_return (invoke "nan-canonicalization-f32-func-call-indirect-cncl" (i32.const 0x7fc00001)) (i32.const 0x7fc00000))
+
+(assert_return (invoke "nan-canonicalization-f64-add" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-sub" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-mul" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-div" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-max" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-min" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-nearest" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-floor" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-ceil" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-trunc" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-sqrt" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-mem" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001))
+(assert_return (invoke "nan-canonicalization-f64-mem-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-local" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001))
+(assert_return (invoke "nan-canonicalization-f64-local-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-func-call" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001))
+(assert_return (invoke "nan-canonicalization-f64-func-call-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+(assert_return (invoke "nan-canonicalization-f64-func-call-indirect" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000001))
+(assert_return (invoke "nan-canonicalization-f64-func-call-indirect-cncl" (i64.const 0x7ff8000000000001)) (i64.const 0x7ff8000000000000))
+
+;; Test canonicalization is done before branch in `else` operator.
+(module
+  (func (;0;)
+    (local f64)
+    i32.const 1
+    if (result f64)
+      local.get 0
+      f64.const 0x1p+0 (;=1;)
+      f64.add
+    else
+      f64.const 0x0p+0 (;=0;)
+    end
+    return
+  )
+)
+
+;; Test canonicalization is done before branch in `return` operator.
+(module
+  (func (;0;) (result f64)
+    (local f64)
+    f64.const 0x0p+0
+    local.get 0
+    f64.mul
+    return
+  )
+)
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/rotate-shift-overflow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/rotate-shift-overflow.wast
new file mode 100644
index 0000000..456ea41
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/rotate-shift-overflow.wast
@@ -0,0 +1,334 @@
+;; Test that constant folding an operation that overflows doesn't produce an
+;; undefined value. Changing these tests to move the constants to the
+;; assert_return line hides the bug.
+
+(module
+  ;; shl i32
+  (func (export "shl1_i32") (result i32)
+    i32.const 235
+    i32.const 0
+    i32.shl
+  )
+  (func (export "shl2_i32") (result i32)
+    i32.const 235
+    i32.const 32
+    i32.shl
+  )
+  (func (export "shl3_i32") (result i32)
+    i32.const 235
+    i32.const 100
+    i32.shl
+  )
+  (func (export "shl4_i32") (result i32)
+    i32.const 235
+    i32.const -32
+    i32.shl
+  )
+  (func (export "shl5_i32") (result i32)
+    i32.const 235
+    i32.const -100
+    i32.shl
+  )
+  ;; shl i64
+  (func (export "shl1_i64") (result i64)
+    i64.const 235
+    i64.const 0
+    i64.shl
+  )
+  (func (export "shl2_i64") (result i64)
+    i64.const 235
+    i64.const 64
+    i64.shl
+  )
+  (func (export "shl3_i64") (result i64)
+    i64.const 235
+    i64.const 100
+    i64.shl
+  )
+  (func (export "shl4_i64") (result i64)
+    i64.const 235
+    i64.const -64
+    i64.shl
+  )
+  (func (export "shl5_i64") (result i64)
+    i64.const 235
+    i64.const -100
+    i64.shl
+  )
+
+  ;; shr_u i32
+  (func (export "shr_u1_i32") (result i32)
+    i32.const 235
+    i32.const 0
+    i32.shr_u
+  )
+  (func (export "shr_u2_i32") (result i32)
+    i32.const 235
+    i32.const 32
+    i32.shr_u
+  )
+  (func (export "shr_u3_i32") (result i32)
+    i32.const 235
+    i32.const 100
+    i32.shr_u
+  )
+  (func (export "shr_u4_i32") (result i32)
+    i32.const 235
+    i32.const -32
+    i32.shr_u
+  )
+  (func (export "shr_u5_i32") (result i32)
+    i32.const 235
+    i32.const -100
+    i32.shr_u
+  )
+
+  ;; shr_u i64
+  (func (export "shr_u1_i64") (result i64)
+    i64.const 235
+    i64.const 0
+    i64.shr_u
+  )
+  (func (export "shr_u2_i64") (result i64)
+    i64.const 235
+    i64.const 64
+    i64.shr_u
+  )
+  (func (export "shr_u3_i64") (result i64)
+    i64.const 235
+    i64.const 100
+    i64.shr_u
+  )
+  (func (export "shr_u4_i64") (result i64)
+    i64.const 235
+    i64.const -64
+    i64.shr_u
+  )
+  (func (export "shr_u5_i64") (result i64)
+    i64.const 235
+    i64.const -100
+    i64.shr_u
+  )
+
+  ;; shr_s i32
+  (func (export "shr_s1_i32") (result i32)
+    i32.const 235
+    i32.const 0
+    i32.shr_s
+  )
+  (func (export "shr_s2_i32") (result i32)
+    i32.const 235
+    i32.const 32
+    i32.shr_s
+  )
+  (func (export "shr_s3_i32") (result i32)
+    i32.const 235
+    i32.const 100
+    i32.shr_s
+  )
+  (func (export "shr_s4_i32") (result i32)
+    i32.const 235
+    i32.const -32
+    i32.shr_s
+  )
+  (func (export "shr_s5_i32") (result i32)
+    i32.const 235
+    i32.const -100
+    i32.shr_s
+  )
+
+  ;; shr_s i64
+  (func (export "shr_s1_i64") (result i64)
+    i64.const 235
+    i64.const 0
+    i64.shr_s
+  )
+  (func (export "shr_s2_i64") (result i64)
+    i64.const 235
+    i64.const 64
+    i64.shr_s
+  )
+  (func (export "shr_s3_i64") (result i64)
+    i64.const 235
+    i64.const 100
+    i64.shr_s
+  )
+  (func (export "shr_s4_i64") (result i64)
+    i64.const 235
+    i64.const -64
+    i64.shr_s
+  )
+  (func (export "shr_s5_i64") (result i64)
+    i64.const 235
+    i64.const -100
+    i64.shr_s
+  )
+
+  ;; rotl i32
+  (func (export "rotl1_i32") (result i32)
+    i32.const 235
+    i32.const 0
+    i32.rotl
+  )
+  (func (export "rotl2_i32") (result i32)
+    i32.const 235
+    i32.const 32
+    i32.rotl
+  )
+  (func (export "rotl3_i32") (result i32)
+    i32.const 235
+    i32.const 100
+    i32.rotl
+  )
+  (func (export "rotl4_i32") (result i32)
+    i32.const 235
+    i32.const -32
+    i32.rotl
+  )
+  (func (export "rotl5_i32") (result i32)
+    i32.const 235
+    i32.const -100
+    i32.rotl
+  )
+
+  ;; rotl i64
+  (func (export "rotl1_i64") (result i64)
+    i64.const 235
+    i64.const 0
+    i64.rotl
+  )
+  (func (export "rotl2_i64") (result i64)
+    i64.const 235
+    i64.const 64
+    i64.rotl
+  )
+  (func (export "rotl3_i64") (result i64)
+    i64.const 235
+    i64.const 100
+    i64.rotl
+  )
+  (func (export "rotl4_i64") (result i64)
+    i64.const 235
+    i64.const -64
+    i64.rotl
+  )
+  (func (export "rotl5_i64") (result i64)
+    i64.const 235
+    i64.const -100
+    i64.rotl
+  )
+
+  ;; rotr i32
+  (func (export "rotr1_i32") (result i32)
+    i32.const 235
+    i32.const 0
+    i32.rotr
+  )
+  (func (export "rotr2_i32") (result i32)
+    i32.const 235
+    i32.const 32
+    i32.rotr
+  )
+  (func (export "rotr3_i32") (result i32)
+    i32.const 235
+    i32.const 100
+    i32.rotr
+  )
+  (func (export "rotr4_i32") (result i32)
+    i32.const 235
+    i32.const -32
+    i32.rotr
+  )
+  (func (export "rotr5_i32") (result i32)
+    i32.const 235
+    i32.const -100
+    i32.rotr
+  )
+
+  ;; rotr i64
+  (func (export "rotr1_i64") (result i64)
+    i64.const 235
+    i64.const 0
+    i64.rotr
+  )
+  (func (export "rotr2_i64") (result i64)
+    i64.const 235
+    i64.const 64
+    i64.rotr
+  )
+  (func (export "rotr3_i64") (result i64)
+    i64.const 235
+    i64.const 100
+    i64.rotr
+  )
+  (func (export "rotr4_i64") (result i64)
+    i64.const 235
+    i64.const -64
+    i64.rotr
+  )
+  (func (export "rotr5_i64") (result i64)
+    i64.const 235
+    i64.const -100
+    i64.rotr
+  )
+)
+
+(assert_return (invoke "shl1_i32") (i32.const 235))
+(assert_return (invoke "shl2_i32") (i32.const 235))
+(assert_return (invoke "shl3_i32") (i32.const 3760))
+(assert_return (invoke "shl4_i32") (i32.const 235))
+(assert_return (invoke "shl5_i32") (i32.const -1342177280))
+
+(assert_return (invoke "shl1_i64") (i64.const 235))
+(assert_return (invoke "shl2_i64") (i64.const 235))
+(assert_return (invoke "shl3_i64") (i64.const 16149077032960))
+(assert_return (invoke "shl4_i64") (i64.const 235))
+(assert_return (invoke "shl5_i64") (i64.const 63082332160))
+
+(assert_return (invoke "shr_u1_i32") (i32.const 235))
+(assert_return (invoke "shr_u2_i32") (i32.const 235))
+(assert_return (invoke "shr_u3_i32") (i32.const 14))
+(assert_return (invoke "shr_u4_i32") (i32.const 235))
+(assert_return (invoke "shr_u5_i32") (i32.const 0))
+
+(assert_return (invoke "shr_u1_i64") (i64.const 235))
+(assert_return (invoke "shr_u2_i64") (i64.const 235))
+(assert_return (invoke "shr_u3_i64") (i64.const 0))
+(assert_return (invoke "shr_u4_i64") (i64.const 235))
+(assert_return (invoke "shr_u5_i64") (i64.const 0))
+
+(assert_return (invoke "shr_s1_i32") (i32.const 235))
+(assert_return (invoke "shr_s2_i32") (i32.const 235))
+(assert_return (invoke "shr_s3_i32") (i32.const 14))
+(assert_return (invoke "shr_s4_i32") (i32.const 235))
+(assert_return (invoke "shr_s5_i32") (i32.const 0))
+
+(assert_return (invoke "shr_s1_i64") (i64.const 235))
+(assert_return (invoke "shr_s2_i64") (i64.const 235))
+(assert_return (invoke "shr_s3_i64") (i64.const 0))
+(assert_return (invoke "shr_s4_i64") (i64.const 235))
+(assert_return (invoke "shr_s5_i64") (i64.const 0))
+
+(assert_return (invoke "rotl1_i32") (i32.const 235))
+(assert_return (invoke "rotl2_i32") (i32.const 235))
+(assert_return (invoke "rotl3_i32") (i32.const 3760))
+(assert_return (invoke "rotl4_i32") (i32.const 235))
+(assert_return (invoke "rotl5_i32") (i32.const -1342177266))
+
+(assert_return (invoke "rotl1_i64") (i64.const 235))
+(assert_return (invoke "rotl2_i64") (i64.const 235))
+(assert_return (invoke "rotl3_i64") (i64.const 16149077032960))
+(assert_return (invoke "rotl4_i64") (i64.const 235))
+(assert_return (invoke "rotl5_i64") (i64.const 63082332160))
+
+(assert_return (invoke "rotr1_i32") (i32.const 235))
+(assert_return (invoke "rotr2_i32") (i32.const 235))
+(assert_return (invoke "rotr3_i32") (i32.const -1342177266))
+(assert_return (invoke "rotr4_i32") (i32.const 235))
+(assert_return (invoke "rotr5_i32") (i32.const 3760))
+
+(assert_return (invoke "rotr1_i64") (i64.const 235))
+(assert_return (invoke "rotr2_i64") (i64.const 235))
+(assert_return (invoke "rotr3_i64") (i64.const 63082332160))
+(assert_return (invoke "rotr4_i64") (i64.const 235))
+(assert_return (invoke "rotr5_i64") (i64.const 16149077032960))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow-sret.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow-sret.wast
new file mode 100644
index 0000000..dc75d77
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow-sret.wast
@@ -0,0 +1,47 @@
+(module
+  (func $sret
+    (result i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+            i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+            i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64
+            i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64 i64)
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+      i64.const 0 i64.const 0 i64.const 0 i64.const 0 
+    )
+
+  (func (export "long-loop")
+    (local i32)
+    i32.const 1000000
+    local.set 0
+    (loop
+      call $sret
+      drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop
+      drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop
+      drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop
+      drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop drop
+      local.get 0
+      i32.const -1
+      i32.add
+      local.tee 0
+      br_if 0
+    )
+  )
+)
+
+(assert_return (invoke "long-loop"))
diff --git a/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow.wast b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow.wast
new file mode 100644
index 0000000..fc11c08
--- /dev/null
+++ b/arbitrator/tools/module_roots/wasmer/tests/wast/wasmer/stack-overflow.wast
@@ -0,0 +1,10 @@
+(module
+      (type (;0;) (func))
+      (func (;0;) (type 0)
+        i32.const 0
+        call_indirect (type 0))
+      (table (;0;) 1 anyfunc)
+      (export "stack-overflow" (func 0))
+      (elem (;0;) (i32.const 0) 0))
+
+(assert_exhaustion (invoke "stack-overflow") "call stack exhausted")
diff --git a/arbitrator/wasm-libraries/Cargo.lock b/arbitrator/wasm-libraries/Cargo.lock
index 7620ff5..a5a066e 100644
--- a/arbitrator/wasm-libraries/Cargo.lock
+++ b/arbitrator/wasm-libraries/Cargo.lock
@@ -31,6 +31,21 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -91,6 +106,12 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@@ -203,6 +224,15 @@ dependencies = [
  "rand_pcg",
 ]
 
+[[package]]
+name = "cc"
+version = "1.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9540e661f81799159abee814118cc139a2004b3a3aa3ea37724a1b66530b90e0"
+dependencies = [
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -215,6 +245,19 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-targets",
+]
+
 [[package]]
 name = "clap"
 version = "2.34.0"
@@ -236,6 +279,12 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "cpufeatures"
 version = "0.2.12"
@@ -261,38 +310,14 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "darling"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
-dependencies = [
- "darling_core 0.13.4",
- "darling_macro 0.13.4",
-]
-
 [[package]]
 name = "darling"
 version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989"
 dependencies = [
- "darling_core 0.20.10",
- "darling_macro 0.20.10",
-]
-
-[[package]]
-name = "darling_core"
-version = "0.13.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
-dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim 0.10.0",
- "syn 1.0.109",
+ "darling_core",
+ "darling_macro",
 ]
 
 [[package]]
@@ -305,29 +330,29 @@ dependencies = [
  "ident_case",
  "proc-macro2",
  "quote",
+ "strsim 0.11.1",
  "syn 2.0.72",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.13.4"
+version = "0.20.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
+checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
 dependencies = [
- "darling_core 0.13.4",
+ "darling_core",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.72",
 ]
 
 [[package]]
-name = "darling_macro"
-version = "0.20.10"
+name = "deranged"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
- "darling_core 0.20.10",
- "quote",
- "syn 2.0.72",
+ "powerfmt",
+ "serde",
 ]
 
 [[package]]
@@ -434,7 +459,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "59c3b24c345d8c314966bdc1832f6c2635bfcce8e7cf363bd115987bba2ee242"
 dependencies = [
- "darling 0.20.10",
+ "darling",
  "proc-macro2",
  "quote",
  "syn 2.0.72",
@@ -548,6 +573,29 @@ dependencies = [
  "caller-env",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "ident_case"
 version = "1.0.1"
@@ -568,6 +616,7 @@ checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 dependencies = [
  "autocfg",
  "hashbrown 0.12.3",
+ "serde",
 ]
 
 [[package]]
@@ -578,6 +627,7 @@ checksum = "de3fc2e30ba82dd1b3911c8de1ffc143c74a914a14e99514d7637e3099df5ea0"
 dependencies = [
  "equivalent",
  "hashbrown 0.14.5",
+ "serde",
 ]
 
 [[package]]
@@ -595,6 +645,15 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "js-sys"
+version = "0.3.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+dependencies = [
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "keccak"
 version = "0.1.5"
@@ -632,6 +691,12 @@ dependencies = [
  "scopeguard",
 ]
 
+[[package]]
+name = "log"
+version = "0.4.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+
 [[package]]
 name = "lru"
 version = "0.12.4"
@@ -719,6 +784,12 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-derive"
 version = "0.4.2"
@@ -832,6 +903,12 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "proc-macro-crate"
 version = "3.1.0"
@@ -1115,24 +1192,32 @@ dependencies = [
 
 [[package]]
 name = "serde_with"
-version = "1.14.0"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678b5a069e50bf00ecd22d0cd8ddf7c236f68581b03db652061ed5eb13a312ff"
+checksum = "69cecfa94848272156ea67b2b1a53f20fc7bc638c4a46d2f8abde08f05f4b857"
 dependencies = [
+ "base64",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.3.0",
  "serde",
+ "serde_derive",
+ "serde_json",
  "serde_with_macros",
+ "time",
 ]
 
 [[package]]
 name = "serde_with_macros"
-version = "1.5.2"
+version = "3.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082"
+checksum = "a8fee4991ef4f274617a51ad4af30519438dacb2f56ac773b08a1922ff743350"
 dependencies = [
- "darling 0.13.4",
+ "darling",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.72",
 ]
 
 [[package]]
@@ -1181,6 +1266,12 @@ dependencies = [
  "keccak",
 ]
 
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
 [[package]]
 name = "simdutf8"
 version = "0.1.4"
@@ -1216,9 +1307,9 @@ checksum = "8ea5119cdb4c55b55d432abb513a0429384878c15dde60cc77b1c99de1a95a6a"
 
 [[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 = "structopt"
@@ -1307,6 +1398,37 @@ dependencies = [
  "syn 2.0.72",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
+
+[[package]]
+name = "time-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -1445,6 +1567,61 @@ dependencies = [
  "wee_alloc",
 ]
 
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+dependencies = [
+ "cfg-if 1.0.0",
+ "once_cell",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+dependencies = [
+ "bumpalo",
+ "log",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.72",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+
 [[package]]
 name = "wasm-encoder"
 version = "0.215.0"
@@ -1535,6 +1712,15 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
diff --git a/arbitrator/wasm-libraries/forward/src/main.rs b/arbitrator/wasm-libraries/forward/src/main.rs
index 05a949e..f978a87 100644
--- a/arbitrator/wasm-libraries/forward/src/main.rs
+++ b/arbitrator/wasm-libraries/forward/src/main.rs
@@ -191,7 +191,8 @@ fn forward_stub(file: &mut File) -> Result<()> {
         "{s};; allows user_host to request a trap\n\
         {s}(global $trap (mut i32) (i32.const 0))\n\
         {s}(func $check unreachable)\n\
-        {s}(func (export \"forward__set_trap\") unreachable)"
+        {s};; stub for the forward__set_trap function\n\
+        {s}(func $forward__set_trap unreachable)"
     );
 
     wln!("{s};; user linkage");
diff --git a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
index 0191718..12a6bdb 100644
--- a/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
+++ b/arbitrator/wasm-libraries/user-host-trait/src/lib.rs
@@ -8,7 +8,7 @@ use arbutil::{
         api::{DataReader, EvmApi},
         storage::StorageCache,
         user::UserOutcomeKind,
-        EvmData,
+        EvmData, ARBOS_VERSION_STYLUS_CHARGING_FIXES,
     },
     pricing::{self, EVM_API_INK, HOSTIO_INK, PTR_INK},
     Bytes20, Bytes32,
@@ -143,11 +143,20 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     /// [`SLOAD`]: https://www.evm.codes/#54
     fn storage_load_bytes32(&mut self, key: GuestPtr, dest: GuestPtr) -> Result<(), Self::Err> {
         self.buy_ink(HOSTIO_INK + 2 * PTR_INK)?;
-        self.require_gas(evm::COLD_SLOAD_GAS + EVM_API_INK + StorageCache::REQUIRED_ACCESS_GAS)?; // cache-miss case
+        let arbos_version = self.evm_data().arbos_version;
 
+        // require for cache-miss case, preserve wrong behavior for old arbos
+        let evm_api_gas_to_use = if arbos_version < ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            EVM_API_INK
+        } else {
+            self.pricing().ink_to_gas(EVM_API_INK)
+        };
+        self.require_gas(
+            evm::COLD_SLOAD_GAS + StorageCache::REQUIRED_ACCESS_GAS + evm_api_gas_to_use,
+        )?;
         let key = self.read_bytes32(key)?;
 
-        let (value, gas_cost) = self.evm_api().get_bytes32(key);
+        let (value, gas_cost) = self.evm_api().get_bytes32(key, evm_api_gas_to_use);
         self.buy_gas(gas_cost)?;
         self.write_bytes32(dest, value)?;
         trace!("storage_load_bytes32", self, key, value)
@@ -185,7 +194,10 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         self.require_gas(evm::SSTORE_SENTRY_GAS)?; // see operations_acl_arbitrum.go
 
         let gas_left = self.gas_left()?;
-        self.evm_api().flush_storage_cache(clear, gas_left)?;
+        let gas_cost = self.evm_api().flush_storage_cache(clear, gas_left)?;
+        if self.evm_data().arbos_version >= ARBOS_VERSION_STYLUS_CHARGING_FIXES {
+            self.buy_gas(gas_cost)?;
+        }
         trace!("storage_flush_cache", self, [be!(clear as u8)], &[])
     }
 
@@ -534,7 +546,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     fn return_data_size(&mut self) -> Result<u32, Self::Err> {
         self.buy_ink(HOSTIO_INK)?;
         let len = *self.evm_return_data_len();
-        trace!("return_data_size", self, be!(len), &[], len)
+        trace!("return_data_size", self, &[], be!(len), len)
     }
 
     /// Emits an EVM log with the given number of topics and data, the first bytes of which should
@@ -629,7 +641,8 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
         self.buy_gas(gas_cost)?;
 
         let code = code.slice();
-        trace!("account_code_size", self, address, &[], code.len() as u32)
+        let len = code.len() as u32;
+        trace!("account_code_size", self, address, be!(len), len)
     }
 
     /// Gets the code hash of the account at the given address. The semantics are equivalent
@@ -735,7 +748,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     fn evm_gas_left(&mut self) -> Result<u64, Self::Err> {
         self.buy_ink(HOSTIO_INK)?;
         let gas = self.gas_left()?;
-        trace!("evm_gas_left", self, be!(gas), &[], gas)
+        trace!("evm_gas_left", self, &[], be!(gas), gas)
     }
 
     /// Gets the amount of ink remaining after paying for the cost of this hostio. The semantics
@@ -747,7 +760,7 @@ pub trait UserHost<DR: DataReader>: GasMeteredMachine {
     fn evm_ink_left(&mut self) -> Result<u64, Self::Err> {
         self.buy_ink(HOSTIO_INK)?;
         let ink = self.ink_ready()?;
-        trace!("evm_ink_left", self, be!(ink), &[], ink)
+        trace!("evm_ink_left", self, &[], be!(ink), ink)
     }
 
     /// Computes `value ÷ exponent` using 256-bit math, writing the result to the first.
diff --git a/arbitrator/wasm-libraries/user-host/src/link.rs b/arbitrator/wasm-libraries/user-host/src/link.rs
index 4286111..f4c402f 100644
--- a/arbitrator/wasm-libraries/user-host/src/link.rs
+++ b/arbitrator/wasm-libraries/user-host/src/link.rs
@@ -37,14 +37,15 @@ struct MemoryLeaf([u8; 32]);
 ///
 /// pages_ptr: starts pointing to max allowed pages, returns number of pages used
 #[no_mangle]
-pub unsafe extern "C" fn programs__activate(
+pub unsafe extern "C" fn programs__activate_v2(
     wasm_ptr: GuestPtr,
     wasm_size: usize,
     pages_ptr: GuestPtr,
     asm_estimate_ptr: GuestPtr,
     init_cost_ptr: GuestPtr,
     cached_init_cost_ptr: GuestPtr,
-    version: u16,
+    stylus_version: u16,
+    arbos_version_for_gas: u64,
     debug: u32,
     codehash: GuestPtr,
     module_hash_ptr: GuestPtr,
@@ -58,7 +59,15 @@ pub unsafe extern "C" fn programs__activate(
 
     let page_limit = STATIC_MEM.read_u16(pages_ptr);
     let gas_left = &mut STATIC_MEM.read_u64(gas_ptr);
-    match Module::activate(&wasm, codehash, version, page_limit, debug, gas_left) {
+    match Module::activate(
+        &wasm,
+        codehash,
+        stylus_version,
+        arbos_version_for_gas,
+        page_limit,
+        debug,
+        gas_left,
+    ) {
         Ok((module, data)) => {
             STATIC_MEM.write_u64(gas_ptr, *gas_left);
             STATIC_MEM.write_u16(pages_ptr, data.footprint);
@@ -242,7 +251,8 @@ pub unsafe extern "C" fn programs__create_stylus_config(
 /// Creates an `EvmData` handler from its component parts.
 ///
 #[no_mangle]
-pub unsafe extern "C" fn programs__create_evm_data(
+pub unsafe extern "C" fn programs__create_evm_data_v2(
+    arbos_version: u64,
     block_basefee_ptr: GuestPtr,
     chainid: u64,
     block_coinbase_ptr: GuestPtr,
@@ -259,6 +269,7 @@ pub unsafe extern "C" fn programs__create_evm_data(
     reentrant: u32,
 ) -> u64 {
     let evm_data = EvmData {
+        arbos_version,
         block_basefee: read_bytes32(block_basefee_ptr),
         cached: cached != 0,
         chainid,
diff --git a/arbitrator/wasm-libraries/user-test/src/program.rs b/arbitrator/wasm-libraries/user-test/src/program.rs
index c56ea52..85b522e 100644
--- a/arbitrator/wasm-libraries/user-test/src/program.rs
+++ b/arbitrator/wasm-libraries/user-test/src/program.rs
@@ -102,7 +102,7 @@ impl Program {
 pub struct MockEvmApi;
 
 impl EvmApi<VecReader> for MockEvmApi {
-    fn get_bytes32(&mut self, key: Bytes32) -> (Bytes32, u64) {
+    fn get_bytes32(&mut self, key: Bytes32, _evm_api_gas_to_use: u64) -> (Bytes32, u64) {
         let value = KEYS.lock().get(&key).cloned().unwrap_or_default();
         (value, 2100) // pretend worst case
     }
diff --git a/arbnode/api.go b/arbnode/api.go
index 228ad51..2dabd41 100644
--- a/arbnode/api.go
+++ b/arbnode/api.go
@@ -7,9 +7,11 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/staker"
 	"github.com/offchainlabs/nitro/validator"
+	"github.com/offchainlabs/nitro/validator/server_api"
 )
 
 type BlockValidatorAPI struct {
@@ -54,3 +56,8 @@ func (a *BlockValidatorDebugAPI) ValidateMessageNumber(
 	result.Valid = valid
 	return result, err
 }
+
+func (a *BlockValidatorDebugAPI) ValidationInputsAt(ctx context.Context, msgNum hexutil.Uint64, target ethdb.WasmTarget,
+) (server_api.InputJSON, error) {
+	return a.val.ValidationInputsAt(ctx, arbutil.MessageIndex(msgNum), target)
+}
diff --git a/arbnode/batch_poster.go b/arbnode/batch_poster.go
index 71239ef..44b360e 100644
--- a/arbnode/batch_poster.go
+++ b/arbnode/batch_poster.go
@@ -121,7 +121,7 @@ type BatchPoster struct {
 	nextRevertCheckBlock int64       // the last parent block scanned for reverting batches
 	postedFirstBatch     bool        // indicates if batch poster has posted the first batch
 
-	accessList func(SequencerInboxAccs, AfterDelayedMessagesRead int) types.AccessList
+	accessList func(SequencerInboxAccs, AfterDelayedMessagesRead uint64) types.AccessList
 }
 
 type l1BlockBound int
@@ -168,7 +168,7 @@ type BatchPosterConfig struct {
 	L1BlockBound                   string                      `koanf:"l1-block-bound" reload:"hot"`
 	L1BlockBoundBypass             time.Duration               `koanf:"l1-block-bound-bypass" reload:"hot"`
 	UseAccessLists                 bool                        `koanf:"use-access-lists" reload:"hot"`
-	GasEstimateBaseFeeMultipleBips arbmath.Bips                `koanf:"gas-estimate-base-fee-multiple-bips"`
+	GasEstimateBaseFeeMultipleBips arbmath.UBips               `koanf:"gas-estimate-base-fee-multiple-bips"`
 	Dangerous                      BatchPosterDangerousConfig  `koanf:"dangerous"`
 	ReorgResistanceMargin          time.Duration               `koanf:"reorg-resistance-margin" reload:"hot"`
 	CheckBatchCorrectness          bool                        `koanf:"check-batch-correctness"`
@@ -253,7 +253,7 @@ var DefaultBatchPosterConfig = BatchPosterConfig{
 	L1BlockBoundBypass:             time.Hour,
 	UseAccessLists:                 true,
 	RedisLock:                      redislock.DefaultCfg,
-	GasEstimateBaseFeeMultipleBips: arbmath.OneInBips * 3 / 2,
+	GasEstimateBaseFeeMultipleBips: arbmath.OneInUBips * 3 / 2,
 	ReorgResistanceMargin:          10 * time.Minute,
 	CheckBatchCorrectness:          true,
 }
@@ -285,7 +285,7 @@ var TestBatchPosterConfig = BatchPosterConfig{
 	L1BlockBound:                   "",
 	L1BlockBoundBypass:             time.Hour,
 	UseAccessLists:                 true,
-	GasEstimateBaseFeeMultipleBips: arbmath.OneInBips * 3 / 2,
+	GasEstimateBaseFeeMultipleBips: arbmath.OneInUBips * 3 / 2,
 	CheckBatchCorrectness:          true,
 }
 
@@ -374,7 +374,7 @@ func NewBatchPoster(ctx context.Context, opts *BatchPosterOpts) (*BatchPoster, e
 	}
 	// Dataposter sender may be external signer address, so we should initialize
 	// access list after initializing dataposter.
-	b.accessList = func(SequencerInboxAccs, AfterDelayedMessagesRead int) types.AccessList {
+	b.accessList = func(SequencerInboxAccs, AfterDelayedMessagesRead uint64) types.AccessList {
 		if !b.config().UseAccessLists || opts.L1Reader.IsParentChainArbitrum() {
 			// Access lists cost gas instead of saving gas when posting to L2s,
 			// because data is expensive in comparison to computation.
@@ -433,8 +433,8 @@ type AccessListOpts struct {
 	BridgeAddr               common.Address
 	DataPosterAddr           common.Address
 	GasRefunderAddr          common.Address
-	SequencerInboxAccs       int
-	AfterDelayedMessagesRead int
+	SequencerInboxAccs       uint64
+	AfterDelayedMessagesRead uint64
 }
 
 // AccessList returns access list (contracts, storage slots) for batchposter.
@@ -476,12 +476,12 @@ func AccessList(opts *AccessListOpts) types.AccessList {
 		},
 	}
 
-	for _, v := range []struct{ slotIdx, val int }{
+	for _, v := range []struct{ slotIdx, val uint64 }{
 		{7, opts.SequencerInboxAccs - 1},       // - sequencerInboxAccs[sequencerInboxAccs.length - 1]; (keccak256(7, sequencerInboxAccs.length - 1))
 		{7, opts.SequencerInboxAccs},           // - sequencerInboxAccs.push(...); (keccak256(7, sequencerInboxAccs.length))
 		{6, opts.AfterDelayedMessagesRead - 1}, // - delayedInboxAccs[afterDelayedMessagesRead - 1]; (keccak256(6, afterDelayedMessagesRead - 1))
 	} {
-		sb := arbutil.SumBytes(arbutil.PaddedKeccak256([]byte{byte(v.slotIdx)}), big.NewInt(int64(v.val)).Bytes())
+		sb := arbutil.SumBytes(arbutil.PaddedKeccak256([]byte{byte(v.slotIdx)}), new(big.Int).SetUint64(v.val).Bytes())
 		l[1].StorageKeys = append(l[1].StorageKeys, common.Hash(sb))
 	}
 
@@ -603,9 +603,12 @@ func (b *BatchPoster) pollForL1PriceData(ctx context.Context) {
 						l1GasPrice = blobFeePerByte.Uint64() / 16
 					}
 				}
+				// #nosec G115
 				blobGasUsedGauge.Update(int64(*h.BlobGasUsed))
 			}
+			// #nosec G115
 			blockGasUsedGauge.Update(int64(h.GasUsed))
+			// #nosec G115
 			blockGasLimitGauge.Update(int64(h.GasLimit))
 			suggestedTipCap, err := b.l1Reader.Client().SuggestGasTipCap(ctx)
 			if err != nil {
@@ -613,6 +616,7 @@ func (b *BatchPoster) pollForL1PriceData(ctx context.Context) {
 			} else {
 				suggestedTipCapGauge.Update(suggestedTipCap.Int64())
 			}
+			// #nosec G115
 			l1GasPriceGauge.Update(int64(l1GasPrice))
 		case <-ctx.Done():
 			return
@@ -1031,7 +1035,7 @@ func (b *BatchPoster) estimateGas(ctx context.Context, sequencerMessage []byte,
 	if err != nil {
 		return 0, err
 	}
-	maxFeePerGas := arbmath.BigMulByBips(latestHeader.BaseFee, config.GasEstimateBaseFeeMultipleBips)
+	maxFeePerGas := arbmath.BigMulByUBips(latestHeader.BaseFee, config.GasEstimateBaseFeeMultipleBips)
 	if useNormalEstimation {
 		_, realBlobHashes, err := blobs.ComputeCommitmentsAndHashes(realBlobs)
 		if err != nil {
@@ -1176,6 +1180,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 	if err != nil {
 		return false, err
 	}
+	// #nosec G115
 	firstMsgTime := time.Unix(int64(firstMsg.Message.Header.Timestamp), 0)
 
 	lastPotentialMsg, err := b.streamer.GetMessage(msgCount - 1)
@@ -1245,7 +1250,9 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 		l1BoundMinTimestamp = arbmath.SaturatingUSub(latestHeader.Time, arbmath.BigToUintSaturating(maxTimeVariationDelaySeconds))
 
 		if config.L1BlockBoundBypass > 0 {
+			// #nosec G115
 			blockNumberWithPadding := arbmath.SaturatingUAdd(latestBlockNumber, uint64(config.L1BlockBoundBypass/ethPosBlockTime))
+			// #nosec G115
 			timestampWithPadding := arbmath.SaturatingUAdd(latestHeader.Time, uint64(config.L1BlockBoundBypass/time.Second))
 			l1BoundMinBlockNumberWithBypass = arbmath.SaturatingUSub(blockNumberWithPadding, arbmath.BigToUintSaturating(maxTimeVariationDelayBlocks))
 			l1BoundMinTimestampWithBypass = arbmath.SaturatingUSub(timestampWithPadding, arbmath.BigToUintSaturating(maxTimeVariationDelaySeconds))
@@ -1311,7 +1318,9 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 	if hasL1Bound && config.ReorgResistanceMargin > 0 {
 		firstMsgBlockNumber := firstMsg.Message.Header.BlockNumber
 		firstMsgTimeStamp := firstMsg.Message.Header.Timestamp
+		// #nosec G115
 		batchNearL1BoundMinBlockNumber := firstMsgBlockNumber <= arbmath.SaturatingUAdd(l1BoundMinBlockNumber, uint64(config.ReorgResistanceMargin/ethPosBlockTime))
+		// #nosec G115
 		batchNearL1BoundMinTimestamp := firstMsgTimeStamp <= arbmath.SaturatingUAdd(l1BoundMinTimestamp, uint64(config.ReorgResistanceMargin/time.Second))
 		if batchNearL1BoundMinTimestamp || batchNearL1BoundMinBlockNumber {
 			log.Error(
@@ -1356,6 +1365,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 			batchPosterDAFailureCounter.Inc(1)
 			return false, fmt.Errorf("%w: nonce changed from %d to %d while creating batch", storage.ErrStorageRace, nonce, gotNonce)
 		}
+		// #nosec G115
 		sequencerMsg, err = b.dapWriter.Store(ctx, sequencerMsg, uint64(time.Now().Add(config.DASRetentionPeriod).Unix()), config.DisableDapFallbackStoreDataOnChain)
 		if err != nil {
 			batchPosterDAFailureCounter.Inc(1)
@@ -1403,7 +1413,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 	if len(kzgBlobs)*params.BlobTxBlobGasPerBlob > params.MaxBlobGasPerBlock {
 		return false, fmt.Errorf("produced %v blobs for batch but a block can only hold %v (compressed batch was %v bytes long)", len(kzgBlobs), params.MaxBlobGasPerBlock/params.BlobTxBlobGasPerBlob, len(sequencerMsg))
 	}
-	accessList := b.accessList(int(batchPosition.NextSeqNum), int(b.building.segments.delayedMsg))
+	accessList := b.accessList(batchPosition.NextSeqNum, b.building.segments.delayedMsg)
 	// On restart, we may be trying to estimate gas for a batch whose successor has
 	// already made it into pending state, if not latest state.
 	// In that case, we might get a revert with `DelayedBackwards()`.
@@ -1439,7 +1449,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 		b.building.muxBackend.delayedInboxStart = batchPosition.DelayedMessageCount
 		b.building.muxBackend.SetPositionWithinMessage(0)
 		simMux := arbstate.NewInboxMultiplexer(b.building.muxBackend, batchPosition.DelayedMessageCount, dapReaders, daprovider.KeysetValidate)
-		log.Info("Begin checking the correctness of batch against inbox multiplexer", "startMsgSeqNum", batchPosition.MessageCount, "endMsgSeqNum", b.building.msgCount-1)
+		log.Debug("Begin checking the correctness of batch against inbox multiplexer", "startMsgSeqNum", batchPosition.MessageCount, "endMsgSeqNum", b.building.msgCount-1)
 		for i := batchPosition.MessageCount; i < b.building.msgCount; i++ {
 			msg, err := simMux.Pop(ctx)
 			if err != nil {
@@ -1505,6 +1515,7 @@ func (b *BatchPoster) maybePostSequencerBatch(ctx context.Context) (bool, error)
 		messagesPerBatch = 1
 	}
 	backlog := uint64(unpostedMessages) / messagesPerBatch
+	// #nosec G115
 	batchPosterEstimatedBatchBacklogGauge.Update(int64(backlog))
 	if backlog > 10 {
 		logLevel := log.Warn
diff --git a/arbnode/dataposter/data_poster.go b/arbnode/dataposter/data_poster.go
index 15446fe..acbf9c4 100644
--- a/arbnode/dataposter/data_poster.go
+++ b/arbnode/dataposter/data_poster.go
@@ -26,6 +26,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/misc/eip4844"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
@@ -39,7 +40,6 @@ import (
 	"github.com/offchainlabs/nitro/arbnode/dataposter/noop"
 	"github.com/offchainlabs/nitro/arbnode/dataposter/slice"
 	"github.com/offchainlabs/nitro/arbnode/dataposter/storage"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/util/arbmath"
 	"github.com/offchainlabs/nitro/util/blobs"
 	"github.com/offchainlabs/nitro/util/headerreader"
@@ -69,7 +69,7 @@ var (
 type DataPoster struct {
 	stopwaiter.StopWaiter
 	headerReader      *headerreader.HeaderReader
-	client            arbutil.L1Interface
+	client            *ethclient.Client
 	auth              *bind.TransactOpts
 	signer            signerFn
 	config            ConfigFetcher
@@ -359,6 +359,7 @@ func (p *DataPoster) canPostWithNonce(ctx context.Context, nextNonce uint64, thi
 		if err != nil {
 			return fmt.Errorf("getting nonce of a dataposter sender: %w", err)
 		}
+		// #nosec G115
 		latestUnconfirmedNonceGauge.Update(int64(unconfirmedNonce))
 		if nextNonce >= cfg.MaxMempoolTransactions+unconfirmedNonce {
 			return fmt.Errorf("%w: transaction nonce: %d, unconfirmed nonce: %d, max mempool size: %d", ErrExceedsMaxMempoolSize, nextNonce, unconfirmedNonce, cfg.MaxMempoolTransactions)
@@ -371,6 +372,7 @@ func (p *DataPoster) canPostWithNonce(ctx context.Context, nextNonce uint64, thi
 		if err != nil {
 			return fmt.Errorf("getting nonce of a dataposter sender: %w", err)
 		}
+		// #nosec G115
 		latestUnconfirmedNonceGauge.Update(int64(unconfirmedNonce))
 		if unconfirmedNonce > nextNonce {
 			return fmt.Errorf("latest on-chain nonce %v is greater than to next nonce %v", unconfirmedNonce, nextNonce)
@@ -525,6 +527,7 @@ func (p *DataPoster) feeAndTipCaps(ctx context.Context, nonce uint64, gasLimit u
 	if err != nil {
 		return nil, nil, nil, fmt.Errorf("failed to get latest nonce %v blocks ago (block %v): %w", config.NonceRbfSoftConfs, softConfBlock, err)
 	}
+	// #nosec G115
 	latestSoftConfirmedNonceGauge.Update(int64(softConfNonce))
 
 	suggestedTip, err := p.client.SuggestGasTipCap(ctx)
@@ -635,11 +638,11 @@ func (p *DataPoster) feeAndTipCaps(ctx context.Context, nonce uint64, gasLimit u
 
 	if config.MaxFeeBidMultipleBips > 0 {
 		// Limit the fee caps to be no greater than max(MaxFeeBidMultipleBips, minRbf)
-		maxNonBlobFee := arbmath.BigMulByBips(currentNonBlobFee, config.MaxFeeBidMultipleBips)
+		maxNonBlobFee := arbmath.BigMulByUBips(currentNonBlobFee, config.MaxFeeBidMultipleBips)
 		if lastTx != nil {
 			maxNonBlobFee = arbmath.BigMax(maxNonBlobFee, arbmath.BigMulByBips(lastTx.GasFeeCap(), minRbfIncrease))
 		}
-		maxBlobFee := arbmath.BigMulByBips(currentBlobFee, config.MaxFeeBidMultipleBips)
+		maxBlobFee := arbmath.BigMulByUBips(currentBlobFee, config.MaxFeeBidMultipleBips)
 		if lastTx != nil && lastTx.BlobGasFeeCap() != nil {
 			maxBlobFee = arbmath.BigMax(maxBlobFee, arbmath.BigMulByBips(lastTx.BlobGasFeeCap(), minRbfIncrease))
 		}
@@ -1052,6 +1055,7 @@ func (p *DataPoster) updateNonce(ctx context.Context) error {
 		}
 		return nil
 	}
+	// #nosec G115
 	latestFinalizedNonceGauge.Update(int64(nonce))
 	log.Info("Data poster transactions confirmed", "previousNonce", p.nonce, "newNonce", nonce, "previousL1Block", p.lastBlock, "newL1Block", header.Number)
 	if len(p.errorCount) > 0 {
@@ -1132,6 +1136,7 @@ func (p *DataPoster) Start(ctxIn context.Context) {
 			log.Warn("Failed to get latest nonce", "err", err)
 			return minWait
 		}
+		// #nosec G115
 		latestUnconfirmedNonceGauge.Update(int64(unconfirmedNonce))
 		// We use unconfirmedNonce here to replace-by-fee transactions that aren't in a block,
 		// excluding those that are in an unconfirmed block. If a reorg occurs, we'll continue
@@ -1143,7 +1148,7 @@ func (p *DataPoster) Start(ctxIn context.Context) {
 		}
 		latestQueued, err := p.queue.FetchLast(ctx)
 		if err != nil {
-			log.Error("Failed to fetch lastest queued tx", "err", err)
+			log.Error("Failed to fetch last queued tx", "err", err)
 			return minWait
 		}
 		var latestCumulativeWeight, latestNonce uint64
@@ -1154,43 +1159,38 @@ func (p *DataPoster) Start(ctxIn context.Context) {
 			confirmedNonce := unconfirmedNonce - 1
 			confirmedMeta, err := p.queue.Get(ctx, confirmedNonce)
 			if err == nil && confirmedMeta != nil {
+				// #nosec G115
 				totalQueueWeightGauge.Update(int64(arbmath.SaturatingUSub(latestCumulativeWeight, confirmedMeta.CumulativeWeight())))
+				// #nosec G115
 				totalQueueLengthGauge.Update(int64(arbmath.SaturatingUSub(latestNonce, confirmedNonce)))
 			} else {
-				log.Error("Failed to fetch latest confirmed tx from queue", "err", err, "confirmedMeta", confirmedMeta)
+				log.Error("Failed to fetch latest confirmed tx from queue", "confirmedNonce", confirmedNonce, "err", err, "confirmedMeta", confirmedMeta)
 			}
 
 		}
 
 		for _, tx := range queueContents {
-			previouslyUnsent := !tx.Sent
-			sendAttempted := false
 			if now.After(tx.NextReplacement) {
 				weightBacklog := arbmath.SaturatingUSub(latestCumulativeWeight, tx.CumulativeWeight())
 				nonceBacklog := arbmath.SaturatingUSub(latestNonce, tx.FullTx.Nonce())
 				err := p.replaceTx(ctx, tx, arbmath.MaxInt(nonceBacklog, weightBacklog))
-				sendAttempted = true
 				p.maybeLogError(err, tx, "failed to replace-by-fee transaction")
+			} else {
+				err := p.sendTx(ctx, tx, tx)
+				p.maybeLogError(err, tx, "failed to re-send transaction")
+			}
+			tx, err = p.queue.Get(ctx, tx.FullTx.Nonce())
+			if err != nil {
+				log.Error("Failed to fetch tx from queue to check updated status", "nonce", tx.FullTx.Nonce(), "err", err)
+				return minWait
 			}
 			if nextCheck.After(tx.NextReplacement) {
 				nextCheck = tx.NextReplacement
 			}
-			if !sendAttempted && previouslyUnsent {
-				err := p.sendTx(ctx, tx, tx)
-				sendAttempted = true
-				p.maybeLogError(err, tx, "failed to re-send transaction")
-				if err != nil {
-					nextSend := time.Now().Add(time.Minute)
-					if nextCheck.After(nextSend) {
-						nextCheck = nextSend
-					}
-				}
-			}
-			if previouslyUnsent && sendAttempted {
-				// Don't try to send more than 1 unsent transaction, to play nicely with parent chain mempools.
-				// Transactions will be unsent if there was some error when originally sending them,
-				// or if transaction type changes and the prior tx is not yet reorg resistant.
-				break
+			if !tx.Sent {
+				// We can't progress any further if we failed to send this tx
+				// Retry sending this tx soon
+				return minWait
 			}
 		}
 		wait := time.Until(nextCheck)
@@ -1241,7 +1241,7 @@ type DataPosterConfig struct {
 	MinBlobTxTipCapGwei    float64           `koanf:"min-blob-tx-tip-cap-gwei" reload:"hot"`
 	MaxTipCapGwei          float64           `koanf:"max-tip-cap-gwei" reload:"hot"`
 	MaxBlobTxTipCapGwei    float64           `koanf:"max-blob-tx-tip-cap-gwei" reload:"hot"`
-	MaxFeeBidMultipleBips  arbmath.Bips      `koanf:"max-fee-bid-multiple-bips" reload:"hot"`
+	MaxFeeBidMultipleBips  arbmath.UBips     `koanf:"max-fee-bid-multiple-bips" reload:"hot"`
 	NonceRbfSoftConfs      uint64            `koanf:"nonce-rbf-soft-confs" reload:"hot"`
 	AllocateMempoolBalance bool              `koanf:"allocate-mempool-balance" reload:"hot"`
 	UseDBStorage           bool              `koanf:"use-db-storage"`
@@ -1343,9 +1343,9 @@ var DefaultDataPosterConfig = DataPosterConfig{
 	MaxMempoolWeight:       18,
 	MinTipCapGwei:          0.05,
 	MinBlobTxTipCapGwei:    1, // default geth minimum, and relays aren't likely to accept lower values given propagation time
-	MaxTipCapGwei:          5,
+	MaxTipCapGwei:          1.2,
 	MaxBlobTxTipCapGwei:    1, // lower than normal because 4844 rbf is a minimum of a 2x
-	MaxFeeBidMultipleBips:  arbmath.OneInBips * 10,
+	MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 	NonceRbfSoftConfs:      1,
 	AllocateMempoolBalance: true,
 	UseDBStorage:           true,
@@ -1380,7 +1380,7 @@ var TestDataPosterConfig = DataPosterConfig{
 	MinBlobTxTipCapGwei:    1,
 	MaxTipCapGwei:          5,
 	MaxBlobTxTipCapGwei:    1,
-	MaxFeeBidMultipleBips:  arbmath.OneInBips * 10,
+	MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 	NonceRbfSoftConfs:      1,
 	AllocateMempoolBalance: true,
 	UseDBStorage:           false,
diff --git a/arbnode/dataposter/dataposter_test.go b/arbnode/dataposter/dataposter_test.go
index 7f2f61c..7bf0f86 100644
--- a/arbnode/dataposter/dataposter_test.go
+++ b/arbnode/dataposter/dataposter_test.go
@@ -2,17 +2,18 @@ package dataposter
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"testing"
 	"time"
 
 	"github.com/Knetic/govaluate"
-	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -152,46 +153,36 @@ func TestMaxFeeCapFormulaCalculation(t *testing.T) {
 	}
 }
 
-type stubL1Client struct {
+type stubL1ClientInner struct {
 	senderNonce        uint64
 	suggestedGasTipCap *big.Int
-
-	// Define most of the required methods that aren't used by feeAndTipCaps
-	backends.SimulatedBackend
-}
-
-func (c *stubL1Client) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
-	return c.senderNonce, nil
-}
-
-func (c *stubL1Client) SuggestGasTipCap(ctx context.Context) (*big.Int, error) {
-	return c.suggestedGasTipCap, nil
-}
-
-// Not used but we need to define
-func (c *stubL1Client) BlockNumber(ctx context.Context) (uint64, error) {
-	return 0, nil
-}
-
-func (c *stubL1Client) CallContractAtHash(ctx context.Context, msg ethereum.CallMsg, blockHash common.Hash) ([]byte, error) {
-	return []byte{}, nil
 }
 
-func (c *stubL1Client) CodeAtHash(ctx context.Context, address common.Address, blockHash common.Hash) ([]byte, error) {
-	return []byte{}, nil
+func (c *stubL1ClientInner) CallContext(ctx_in context.Context, result interface{}, method string, args ...interface{}) error {
+	switch method {
+	case "eth_getTransactionCount":
+		ptr, ok := result.(*hexutil.Uint64)
+		if !ok {
+			return errors.New("result is not a *hexutil.Uint64")
+		}
+		*ptr = hexutil.Uint64(c.senderNonce)
+	case "eth_maxPriorityFeePerGas":
+		ptr, ok := result.(*hexutil.Big)
+		if !ok {
+			return errors.New("result is not a *hexutil.Big")
+		}
+		*ptr = hexutil.Big(*c.suggestedGasTipCap)
+	}
+	return nil
 }
 
-func (c *stubL1Client) ChainID(ctx context.Context) (*big.Int, error) {
+func (c *stubL1ClientInner) EthSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
 	return nil, nil
 }
-
-func (c *stubL1Client) Client() rpc.ClientInterface {
+func (c *stubL1ClientInner) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error {
 	return nil
 }
-
-func (c *stubL1Client) TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error) {
-	return common.Address{}, nil
-}
+func (c *stubL1ClientInner) Close() {}
 
 func TestFeeAndTipCaps_EnoughBalance_NoBacklog_NoUnconfirmed_BlobTx(t *testing.T) {
 	conf := func() *DataPosterConfig {
@@ -204,7 +195,7 @@ func TestFeeAndTipCaps_EnoughBalance_NoBacklog_NoUnconfirmed_BlobTx(t *testing.T
 			MinBlobTxTipCapGwei:    1,
 			MaxTipCapGwei:          5,
 			MaxBlobTxTipCapGwei:    10,
-			MaxFeeBidMultipleBips:  arbmath.OneInBips * 10,
+			MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 			AllocateMempoolBalance: true,
 
 			UrgencyGwei:           2.,
@@ -223,10 +214,10 @@ func TestFeeAndTipCaps_EnoughBalance_NoBacklog_NoUnconfirmed_BlobTx(t *testing.T
 		extraBacklog:     func() uint64 { return 0 },
 		balance:          big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(10)),
 		usingNoOpStorage: false,
-		client: &stubL1Client{
+		client: ethclient.NewClient(&stubL1ClientInner{
 			senderNonce:        1,
 			suggestedGasTipCap: big.NewInt(2 * params.GWei),
-		},
+		}),
 		auth: &bind.TransactOpts{
 			From: common.Address{},
 		},
@@ -335,7 +326,7 @@ func TestFeeAndTipCaps_RBF_RisingBlobFee_FallingBaseFee(t *testing.T) {
 			MinBlobTxTipCapGwei:    1,
 			MaxTipCapGwei:          5,
 			MaxBlobTxTipCapGwei:    10,
-			MaxFeeBidMultipleBips:  arbmath.OneInBips * 10,
+			MaxFeeBidMultipleBips:  arbmath.OneInUBips * 10,
 			AllocateMempoolBalance: true,
 
 			UrgencyGwei:           2.,
@@ -354,10 +345,10 @@ func TestFeeAndTipCaps_RBF_RisingBlobFee_FallingBaseFee(t *testing.T) {
 		extraBacklog:     func() uint64 { return 0 },
 		balance:          big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(10)),
 		usingNoOpStorage: false,
-		client: &stubL1Client{
+		client: ethclient.NewClient(&stubL1ClientInner{
 			senderNonce:        1,
 			suggestedGasTipCap: big.NewInt(2 * params.GWei),
-		},
+		}),
 		auth: &bind.TransactOpts{
 			From: common.Address{},
 		},
diff --git a/arbnode/dataposter/dbstorage/storage.go b/arbnode/dataposter/dbstorage/storage.go
index 9705519..6a6cd3c 100644
--- a/arbnode/dataposter/dbstorage/storage.go
+++ b/arbnode/dataposter/dbstorage/storage.go
@@ -42,7 +42,7 @@ func (s *Storage) FetchContents(_ context.Context, startingIndex uint64, maxResu
 	var res []*storage.QueuedTransaction
 	it := s.db.NewIterator([]byte(""), idxToKey(startingIndex))
 	defer it.Release()
-	for i := 0; i < int(maxResults); i++ {
+	for i := uint64(0); i < maxResults; i++ {
 		if !it.Next() {
 			break
 		}
@@ -95,11 +95,11 @@ func (s *Storage) PruneAll(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("pruning all keys: %w", err)
 	}
-	until, err := strconv.Atoi(string(idx))
+	until, err := strconv.ParseUint(string(idx), 10, 64)
 	if err != nil {
 		return fmt.Errorf("converting last item index bytes to integer: %w", err)
 	}
-	return s.Prune(ctx, uint64(until+1))
+	return s.Prune(ctx, until+1)
 }
 
 func (s *Storage) Prune(ctx context.Context, until uint64) error {
diff --git a/arbnode/dataposter/slice/slicestorage.go b/arbnode/dataposter/slice/slicestorage.go
index 69de756..8685ed6 100644
--- a/arbnode/dataposter/slice/slicestorage.go
+++ b/arbnode/dataposter/slice/slicestorage.go
@@ -89,8 +89,8 @@ func (s *Storage) Put(_ context.Context, index uint64, prev, new *storage.Queued
 		}
 		s.queue = append(s.queue, newEnc)
 	} else if index >= s.firstNonce {
-		queueIdx := int(index - s.firstNonce)
-		if queueIdx > len(s.queue) {
+		queueIdx := index - s.firstNonce
+		if queueIdx > uint64(len(s.queue)) {
 			return fmt.Errorf("attempted to set out-of-bounds index %v in queue starting at %v of length %v", index, s.firstNonce, len(s.queue))
 		}
 		prevEnc, err := s.encDec().Encode(prev)
diff --git a/arbnode/dataposter/storage/time.go b/arbnode/dataposter/storage/time.go
index aa15f29..82f8a3d 100644
--- a/arbnode/dataposter/storage/time.go
+++ b/arbnode/dataposter/storage/time.go
@@ -34,11 +34,13 @@ func (b *RlpTime) DecodeRLP(s *rlp.Stream) error {
 	if err != nil {
 		return err
 	}
+	// #nosec G115
 	*b = RlpTime(time.Unix(int64(enc.Seconds), int64(enc.Nanos)))
 	return nil
 }
 
 func (b RlpTime) EncodeRLP(w io.Writer) error {
+	// #nosec G115
 	return rlp.Encode(w, rlpTimeEncoding{
 		Seconds: uint64(time.Time(b).Unix()),
 		Nanos:   uint64(time.Time(b).Nanosecond()),
diff --git a/arbnode/dataposter/storage_test.go b/arbnode/dataposter/storage_test.go
index e2aa321..c6316ca 100644
--- a/arbnode/dataposter/storage_test.go
+++ b/arbnode/dataposter/storage_test.go
@@ -72,24 +72,29 @@ func newRedisStorage(ctx context.Context, t *testing.T, encF storage.EncoderDeco
 
 func valueOf(t *testing.T, i int) *storage.QueuedTransaction {
 	t.Helper()
+	// #nosec G115
 	meta, err := rlp.EncodeToBytes(storage.BatchPosterPosition{DelayedMessageCount: uint64(i)})
 	if err != nil {
 		t.Fatalf("Encoding batch poster position, error: %v", err)
 	}
 	return &storage.QueuedTransaction{
 		FullTx: types.NewTransaction(
+			// #nosec G115
 			uint64(i),
 			common.Address{},
 			big.NewInt(int64(i)),
+			// #nosec G115
 			uint64(i),
 			big.NewInt(int64(i)),
 			[]byte{byte(i)}),
 		Meta: meta,
 		DeprecatedData: types.DynamicFeeTx{
-			ChainID:    big.NewInt(int64(i)),
-			Nonce:      uint64(i),
-			GasTipCap:  big.NewInt(int64(i)),
-			GasFeeCap:  big.NewInt(int64(i)),
+			ChainID: big.NewInt(int64(i)),
+			// #nosec G115
+			Nonce:     uint64(i),
+			GasTipCap: big.NewInt(int64(i)),
+			GasFeeCap: big.NewInt(int64(i)),
+			// #nosec G115
 			Gas:        uint64(i),
 			Value:      big.NewInt(int64(i)),
 			Data:       []byte{byte(i % 8)},
@@ -113,6 +118,7 @@ func values(t *testing.T, from, to int) []*storage.QueuedTransaction {
 func initStorage(ctx context.Context, t *testing.T, s QueueStorage) QueueStorage {
 	t.Helper()
 	for i := 0; i < 20; i++ {
+		// #nosec G115
 		if err := s.Put(ctx, uint64(i), nil, valueOf(t, i)); err != nil {
 			t.Fatalf("Error putting a key/value: %v", err)
 		}
@@ -153,6 +159,7 @@ func TestPruneAll(t *testing.T) {
 	s := newLevelDBStorage(t, func() storage.EncoderDecoderInterface { return &storage.EncoderDecoder{} })
 	ctx := context.Background()
 	for i := 0; i < 20; i++ {
+		// #nosec G115
 		if err := s.Put(ctx, uint64(i), nil, valueOf(t, i)); err != nil {
 			t.Fatalf("Error putting a key/value: %v", err)
 		}
@@ -236,6 +243,7 @@ func TestLast(t *testing.T) {
 			ctx := context.Background()
 			for i := 0; i < cnt; i++ {
 				val := valueOf(t, i)
+				// #nosec G115
 				if err := s.Put(ctx, uint64(i), nil, val); err != nil {
 					t.Fatalf("Error putting a key/value: %v", err)
 				}
@@ -255,6 +263,7 @@ func TestLast(t *testing.T) {
 			for i := 0; i < cnt-1; i++ {
 				prev := valueOf(t, i)
 				newVal := valueOf(t, cnt+i)
+				// #nosec G115
 				if err := s.Put(ctx, uint64(i), prev, newVal); err != nil {
 					t.Fatalf("Error putting a key/value: %v, prev: %v, new: %v", err, prev, newVal)
 				}
@@ -362,6 +371,7 @@ func TestLength(t *testing.T) {
 				if err != nil {
 					t.Fatalf("Length() unexpected error: %v", err)
 				}
+				// #nosec G115
 				if want := arbmath.MaxInt(0, 20-int(tc.pruneFrom)); got != want {
 					t.Errorf("Length() = %d want %d", got, want)
 				}
diff --git a/arbnode/delayed.go b/arbnode/delayed.go
index c166aa2..354fa67 100644
--- a/arbnode/delayed.go
+++ b/arbnode/delayed.go
@@ -19,6 +19,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
 
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -58,11 +59,11 @@ type DelayedBridge struct {
 	con              *bridgegen.IBridge
 	address          common.Address
 	fromBlock        uint64
-	client           arbutil.L1Interface
+	client           *ethclient.Client
 	messageProviders map[common.Address]*bridgegen.IDelayedMessageProvider
 }
 
-func NewDelayedBridge(client arbutil.L1Interface, addr common.Address, fromBlock uint64) (*DelayedBridge, error) {
+func NewDelayedBridge(client *ethclient.Client, addr common.Address, fromBlock uint64) (*DelayedBridge, error) {
 	con, err := bridgegen.NewIBridge(addr, client)
 	if err != nil {
 		return nil, err
@@ -215,7 +216,7 @@ func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []type
 	}
 
 	messages := make([]*DelayedInboxMessage, 0, len(logs))
-	var lastParentChainBlockNumber uint64
+	var lastParentChainBlockHash common.Hash
 	var lastL1BlockNumber uint64
 	for _, parsedLog := range parsedLogs {
 		msgKey := common.BigToHash(parsedLog.MessageIndex)
@@ -228,17 +229,17 @@ func (b *DelayedBridge) logsToDeliveredMessages(ctx context.Context, logs []type
 		}
 
 		requestId := common.BigToHash(parsedLog.MessageIndex)
-		parentChainBlockNumber := parsedLog.Raw.BlockNumber
+		parentChainBlockHash := parsedLog.Raw.BlockHash
 		var l1BlockNumber uint64
-		if lastParentChainBlockNumber == parentChainBlockNumber && lastParentChainBlockNumber > 0 {
+		if lastParentChainBlockHash == parentChainBlockHash && lastParentChainBlockHash != (common.Hash{}) {
 			l1BlockNumber = lastL1BlockNumber
 		} else {
-			var err error
-			l1BlockNumber, err = arbutil.CorrespondingL1BlockNumber(ctx, b.client, parentChainBlockNumber)
+			parentChainHeader, err := b.client.HeaderByHash(ctx, parentChainBlockHash)
 			if err != nil {
 				return nil, err
 			}
-			lastParentChainBlockNumber = parentChainBlockNumber
+			l1BlockNumber = arbutil.ParentHeaderToL1BlockNumber(parentChainHeader)
+			lastParentChainBlockHash = parentChainBlockHash
 			lastL1BlockNumber = l1BlockNumber
 		}
 		msg := &DelayedInboxMessage{
diff --git a/arbnode/delayed_sequencer.go b/arbnode/delayed_sequencer.go
index 4f18531..b29a66d 100644
--- a/arbnode/delayed_sequencer.go
+++ b/arbnode/delayed_sequencer.go
@@ -121,6 +121,7 @@ func (d *DelayedSequencer) sequenceWithoutLockout(ctx context.Context, lastBlock
 		if currentNum < config.FinalizeDistance {
 			return nil
 		}
+		// #nosec G115
 		finalized = uint64(currentNum - config.FinalizeDistance)
 	}
 
@@ -189,6 +190,7 @@ func (d *DelayedSequencer) sequenceWithoutLockout(ctx context.Context, lastBlock
 			return fmt.Errorf("inbox reader at delayed message %v db accumulator %v doesn't match delayed bridge accumulator %v at L1 block %v", pos-1, lastDelayedAcc, delayedBridgeAcc, finalized)
 		}
 		for i, msg := range messages {
+			// #nosec G115
 			err = d.exec.SequenceDelayedMessage(msg, startPos+uint64(i))
 			if err != nil {
 				return err
diff --git a/arbnode/inbox_reader.go b/arbnode/inbox_reader.go
index 77a0b6e..98104b2 100644
--- a/arbnode/inbox_reader.go
+++ b/arbnode/inbox_reader.go
@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	flag "github.com/spf13/pflag"
 
@@ -93,7 +94,7 @@ type InboxReader struct {
 	delayedBridge  *DelayedBridge
 	sequencerInbox *SequencerInbox
 	caughtUpChan   chan struct{}
-	client         arbutil.L1Interface
+	client         *ethclient.Client
 	l1Reader       *headerreader.HeaderReader
 
 	// Atomic
@@ -101,7 +102,7 @@ type InboxReader struct {
 	lastReadBatchCount atomic.Uint64
 }
 
-func NewInboxReader(tracker *InboxTracker, client arbutil.L1Interface, l1Reader *headerreader.HeaderReader, firstMessageBlock *big.Int, delayedBridge *DelayedBridge, sequencerInbox *SequencerInbox, config InboxReaderConfigFetcher) (*InboxReader, error) {
+func NewInboxReader(tracker *InboxTracker, client *ethclient.Client, l1Reader *headerreader.HeaderReader, firstMessageBlock *big.Int, delayedBridge *DelayedBridge, sequencerInbox *SequencerInbox, config InboxReaderConfigFetcher) (*InboxReader, error) {
 	err := config().Validate()
 	if err != nil {
 		return nil, err
@@ -437,8 +438,8 @@ func (r *InboxReader) run(ctx context.Context, hadError bool) error {
 			}
 			delayedMessages, err := r.delayedBridge.LookupMessagesInRange(ctx, from, to, func(batchNum uint64) ([]byte, error) {
 				if len(sequencerBatches) > 0 && batchNum >= sequencerBatches[0].SequenceNumber {
-					idx := int(batchNum - sequencerBatches[0].SequenceNumber)
-					if idx < len(sequencerBatches) {
+					idx := batchNum - sequencerBatches[0].SequenceNumber
+					if idx < uint64(len(sequencerBatches)) {
 						return sequencerBatches[idx].Serialize(ctx, r.l1Reader.Client())
 					}
 					log.Warn("missing mentioned batch in L1 message lookup", "batch", batchNum)
@@ -542,6 +543,7 @@ func (r *InboxReader) run(ctx context.Context, hadError bool) error {
 			} else {
 				from = arbmath.BigAddByUint(to, 1)
 			}
+			// #nosec G115
 			haveMessages := uint64(len(delayedMessages) + len(sequencerBatches))
 			if haveMessages <= (config.TargetMessagesRead / 2) {
 				blocksToFetch += (blocksToFetch + 4) / 5
diff --git a/arbnode/inbox_test.go b/arbnode/inbox_test.go
index 7039259..e588ef3 100644
--- a/arbnode/inbox_test.go
+++ b/arbnode/inbox_test.go
@@ -72,7 +72,11 @@ func NewTransactionStreamerForTest(t *testing.T, ownerAddress common.Address) (*
 	if err != nil {
 		Fail(t, err)
 	}
-	execEngine.Initialize(gethexec.DefaultCachingConfig.StylusLRUCache)
+	stylusTargetConfig := &gethexec.DefaultStylusTargetConfig
+	Require(t, stylusTargetConfig.Validate()) // pre-processes config (i.a. parses wasmTargets)
+	if err := execEngine.Initialize(gethexec.DefaultCachingConfig.StylusLRUCacheCapacity, &gethexec.DefaultStylusTargetConfig); err != nil {
+		Fail(t, err)
+	}
 	execSeq := &execClientWrapper{execEngine, t}
 	inbox, err := NewTransactionStreamer(arbDb, bc.Config(), execSeq, nil, make(chan error, 1), transactionStreamerConfigFetcher, &DefaultSnapSyncConfig)
 	if err != nil {
diff --git a/arbnode/inbox_tracker.go b/arbnode/inbox_tracker.go
index 23b81bd..7686fe4 100644
--- a/arbnode/inbox_tracker.go
+++ b/arbnode/inbox_tracker.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
@@ -599,7 +600,7 @@ type multiplexerBackend struct {
 	positionWithinMessage uint64
 
 	ctx    context.Context
-	client arbutil.L1Interface
+	client *ethclient.Client
 	inbox  *InboxTracker
 }
 
@@ -639,7 +640,7 @@ func (b *multiplexerBackend) ReadDelayedInbox(seqNum uint64) (*arbostypes.L1Inco
 
 var delayedMessagesMismatch = errors.New("sequencer batch delayed messages missing or different")
 
-func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client arbutil.L1Interface, batches []*SequencerInboxBatch) error {
+func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client *ethclient.Client, batches []*SequencerInboxBatch) error {
 	var nextAcc common.Hash
 	var prevbatchmeta BatchMetadata
 	sequenceNumberToKeep := uint64(0)
@@ -804,6 +805,7 @@ func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client arbutil.L
 	if len(messages) > 0 {
 		latestTimestamp = messages[len(messages)-1].Message.Header.Timestamp
 	}
+	// #nosec G115
 	log.Info(
 		"InboxTracker",
 		"sequencerBatchCount", pos,
@@ -811,7 +813,9 @@ func (t *InboxTracker) AddSequencerBatches(ctx context.Context, client arbutil.L
 		"l1Block", latestL1Block,
 		"l1Timestamp", time.Unix(int64(latestTimestamp), 0),
 	)
+	// #nosec G115
 	inboxLatestBatchGauge.Update(int64(pos))
+	// #nosec G115
 	inboxLatestBatchMessageGauge.Update(int64(newMessageCount))
 
 	if t.validator != nil {
diff --git a/arbnode/node.go b/arbnode/node.go
index 0676d63..c5b3bbe 100644
--- a/arbnode/node.go
+++ b/arbnode/node.go
@@ -18,6 +18,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -339,6 +340,29 @@ func checkArbDbSchemaVersion(arbDb ethdb.Database) error {
 	return nil
 }
 
+func DataposterOnlyUsedToCreateValidatorWalletContract(
+	ctx context.Context,
+	l1Reader *headerreader.HeaderReader,
+	transactOpts *bind.TransactOpts,
+	cfg *dataposter.DataPosterConfig,
+	parentChainID *big.Int,
+) (*dataposter.DataPoster, error) {
+	cfg.UseNoOpStorage = true
+	return dataposter.NewDataPoster(ctx,
+		&dataposter.DataPosterOpts{
+			HeaderReader: l1Reader,
+			Auth:         transactOpts,
+			Config: func() *dataposter.DataPosterConfig {
+				return cfg
+			},
+			MetadataRetriever: func(ctx context.Context, blockNum *big.Int) ([]byte, error) {
+				return nil, nil
+			},
+			ParentChainID: parentChainID,
+		},
+	)
+}
+
 func StakerDataposter(
 	ctx context.Context, db ethdb.Database, l1Reader *headerreader.HeaderReader,
 	transactOpts *bind.TransactOpts, cfgFetcher ConfigFetcher, syncMonitor *SyncMonitor,
@@ -384,7 +408,7 @@ func createNodeImpl(
 	arbDb ethdb.Database,
 	configFetcher ConfigFetcher,
 	l2Config *params.ChainConfig,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 	deployInfo *chaininfo.RollupAddresses,
 	txOptsValidator *bind.TransactOpts,
 	txOptsBatchPoster *bind.TransactOpts,
@@ -515,6 +539,7 @@ func createNodeImpl(
 	if err != nil {
 		return nil, err
 	}
+	// #nosec G115
 	sequencerInbox, err := NewSequencerInbox(l1client, deployInfo.SequencerInbox, int64(deployInfo.DeployedAt))
 	if err != nil {
 		return nil, err
@@ -639,6 +664,7 @@ func createNodeImpl(
 					tmpAddress := common.HexToAddress(config.Staker.ContractWalletAddress)
 					existingWalletAddress = &tmpAddress
 				}
+				// #nosec G115
 				wallet, err = validatorwallet.NewContract(dp, existingWalletAddress, deployInfo.ValidatorWalletCreator, deployInfo.Rollup, l1Reader, txOptsValidator, int64(deployInfo.DeployedAt), func(common.Address) {}, getExtraGas)
 				if err != nil {
 					return nil, err
@@ -660,7 +686,7 @@ func createNodeImpl(
 			confirmedNotifiers = append(confirmedNotifiers, messagePruner)
 		}
 
-		stakerObj, err = staker.NewStaker(l1Reader, wallet, bind.CallOpts{}, config.Staker, blockValidator, statelessBlockValidator, nil, confirmedNotifiers, deployInfo.ValidatorUtils, fatalErrChan)
+		stakerObj, err = staker.NewStaker(l1Reader, wallet, bind.CallOpts{}, func() *staker.L1ValidatorConfig { return &configFetcher.Get().Staker }, blockValidator, statelessBlockValidator, nil, confirmedNotifiers, deployInfo.ValidatorUtils, fatalErrChan)
 		if err != nil {
 			return nil, err
 		}
@@ -756,7 +782,7 @@ func CreateNode(
 	arbDb ethdb.Database,
 	configFetcher ConfigFetcher,
 	l2Config *params.ChainConfig,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 	deployInfo *chaininfo.RollupAddresses,
 	txOptsValidator *bind.TransactOpts,
 	txOptsBatchPoster *bind.TransactOpts,
diff --git a/arbnode/resourcemanager/resource_management.go b/arbnode/resourcemanager/resource_management.go
index aba823c..249b689 100644
--- a/arbnode/resourcemanager/resource_management.go
+++ b/arbnode/resourcemanager/resource_management.go
@@ -256,6 +256,7 @@ func readIntFromFile(fileName string) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	defer file.Close()
 
 	var limit int
 	if _, err = fmt.Fscanf(file, "%d", &limit); err != nil {
@@ -269,6 +270,7 @@ func readFromMemStats(fileName string, re *regexp.Regexp) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
diff --git a/arbnode/seq_coordinator.go b/arbnode/seq_coordinator.go
index a582b64..176ace1 100644
--- a/arbnode/seq_coordinator.go
+++ b/arbnode/seq_coordinator.go
@@ -491,7 +491,7 @@ func (c *SeqCoordinator) updateWithLockout(ctx context.Context, nextChosen strin
 		// Before proceeding, first try deleting finalized messages from redis and setting the finalizedMsgCount key
 		finalized, err := c.sync.GetFinalizedMsgCount(ctx)
 		if err != nil {
-			log.Warn("Error getting finalizedMessageCount from syncMonitor: %w", err)
+			log.Warn("Error getting finalizedMessageCount from syncMonitor", "err", err)
 		} else if finalized == 0 {
 			log.Warn("SyncMonitor returned zero finalizedMessageCount")
 		} else if err := c.deleteFinalizedMsgsFromRedis(ctx, finalized); err != nil {
diff --git a/arbnode/sequencer_inbox.go b/arbnode/sequencer_inbox.go
index 73e52de..81146ed 100644
--- a/arbnode/sequencer_inbox.go
+++ b/arbnode/sequencer_inbox.go
@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
 	"github.com/offchainlabs/nitro/arbutil"
 
@@ -52,10 +53,10 @@ type SequencerInbox struct {
 	con       *bridgegen.SequencerInbox
 	address   common.Address
 	fromBlock int64
-	client    arbutil.L1Interface
+	client    *ethclient.Client
 }
 
-func NewSequencerInbox(client arbutil.L1Interface, addr common.Address, fromBlock int64) (*SequencerInbox, error) {
+func NewSequencerInbox(client *ethclient.Client, addr common.Address, fromBlock int64) (*SequencerInbox, error) {
 	con, err := bridgegen.NewSequencerInbox(addr, client)
 	if err != nil {
 		return nil, err
@@ -111,7 +112,7 @@ type SequencerInboxBatch struct {
 	serialized             []byte // nil if serialization isn't cached yet
 }
 
-func (m *SequencerInboxBatch) getSequencerData(ctx context.Context, client arbutil.L1Interface) ([]byte, error) {
+func (m *SequencerInboxBatch) getSequencerData(ctx context.Context, client *ethclient.Client) ([]byte, error) {
 	switch m.dataLocation {
 	case batchDataTxInput:
 		data, err := arbutil.GetLogEmitterTxData(ctx, client, m.rawLog)
@@ -169,7 +170,7 @@ func (m *SequencerInboxBatch) getSequencerData(ctx context.Context, client arbut
 	}
 }
 
-func (m *SequencerInboxBatch) Serialize(ctx context.Context, client arbutil.L1Interface) ([]byte, error) {
+func (m *SequencerInboxBatch) Serialize(ctx context.Context, client *ethclient.Client) ([]byte, error) {
 	if m.serialized != nil {
 		return m.serialized, nil
 	}
diff --git a/arbnode/transaction_streamer.go b/arbnode/transaction_streamer.go
index 90e7fed..38b1c00 100644
--- a/arbnode/transaction_streamer.go
+++ b/arbnode/transaction_streamer.go
@@ -279,6 +279,7 @@ func (s *TransactionStreamer) reorg(batch ethdb.Batch, count arbutil.MessageInde
 		return err
 	}
 	config := s.config()
+	// #nosec G115
 	maxResequenceMsgCount := count + arbutil.MessageIndex(config.MaxReorgResequenceDepth)
 	if config.MaxReorgResequenceDepth >= 0 && maxResequenceMsgCount < targetMsgCount {
 		log.Error(
@@ -388,6 +389,7 @@ func (s *TransactionStreamer) reorg(batch ethdb.Batch, count arbutil.MessageInde
 	}
 
 	for i := 0; i < len(messagesResults); i++ {
+		// #nosec G115
 		pos := count + arbutil.MessageIndex(i)
 		err = s.storeResult(pos, *messagesResults[i], batch)
 		if err != nil {
@@ -680,7 +682,7 @@ func (s *TransactionStreamer) AddMessagesAndEndBatch(pos arbutil.MessageIndex, m
 		if err != nil {
 			return err
 		}
-		if dups == len(messages) {
+		if dups == uint64(len(messages)) {
 			return endBatch(batch)
 		}
 		// cant keep reorg lock when catching insertionMutex.
@@ -715,10 +717,10 @@ func (s *TransactionStreamer) countDuplicateMessages(
 	pos arbutil.MessageIndex,
 	messages []arbostypes.MessageWithMetadataAndBlockHash,
 	batch *ethdb.Batch,
-) (int, bool, *arbostypes.MessageWithMetadata, error) {
-	curMsg := 0
+) (uint64, bool, *arbostypes.MessageWithMetadata, error) {
+	var curMsg uint64
 	for {
-		if len(messages) == curMsg {
+		if uint64(len(messages)) == curMsg {
 			break
 		}
 		key := dbKey(messagePrefix, uint64(pos))
@@ -818,7 +820,7 @@ func (s *TransactionStreamer) addMessagesAndEndBatchImpl(messageStartPos arbutil
 	broadcastStartPos := arbutil.MessageIndex(s.broadcasterQueuedMessagesPos.Load())
 
 	if messagesAreConfirmed {
-		var duplicates int
+		var duplicates uint64
 		var err error
 		duplicates, confirmedReorg, oldMsg, err = s.countDuplicateMessages(messageStartPos, messages, &batch)
 		if err != nil {
@@ -840,6 +842,7 @@ func (s *TransactionStreamer) addMessagesAndEndBatchImpl(messageStartPos arbutil
 		// Active broadcast reorg and L1 messages at or before start of broadcast messages
 		// Or no active broadcast reorg and broadcast messages start before or immediately after last L1 message
 		if messagesAfterPos >= broadcastStartPos {
+			// #nosec G115
 			broadcastSliceIndex := int(messagesAfterPos - broadcastStartPos)
 			messagesOldLen := len(messages)
 			if broadcastSliceIndex < len(s.broadcasterQueuedMessages) {
@@ -856,7 +859,7 @@ func (s *TransactionStreamer) addMessagesAndEndBatchImpl(messageStartPos arbutil
 
 	var feedReorg bool
 	if !hasNewConfirmedMessages {
-		var duplicates int
+		var duplicates uint64
 		var err error
 		duplicates, feedReorg, oldMsg, err = s.countDuplicateMessages(messageStartPos, messages, nil)
 		if err != nil {
@@ -888,6 +891,7 @@ func (s *TransactionStreamer) addMessagesAndEndBatchImpl(messageStartPos arbutil
 
 	// Validate delayed message counts of remaining messages
 	for i, msg := range messages {
+		// #nosec G115
 		msgPos := messageStartPos + arbutil.MessageIndex(i)
 		diff := msg.MessageWithMeta.DelayedMessagesRead - lastDelayedRead
 		if diff != 0 && diff != 1 {
@@ -923,6 +927,7 @@ func (s *TransactionStreamer) addMessagesAndEndBatchImpl(messageStartPos arbutil
 		// Check if new messages were added at the end of cache, if they were, then dont remove those particular messages
 		if len(s.broadcasterQueuedMessages) > cacheClearLen {
 			s.broadcasterQueuedMessages = s.broadcasterQueuedMessages[cacheClearLen:]
+			// #nosec G115
 			s.broadcasterQueuedMessagesPos.Store(uint64(broadcastStartPos) + uint64(cacheClearLen))
 		} else {
 			s.broadcasterQueuedMessages = s.broadcasterQueuedMessages[:0]
@@ -1043,6 +1048,7 @@ func (s *TransactionStreamer) writeMessages(pos arbutil.MessageIndex, messages [
 		batch = s.db.NewBatch()
 	}
 	for i, msg := range messages {
+		// #nosec G115
 		err := s.writeMessage(pos+arbutil.MessageIndex(i), msg, batch)
 		if err != nil {
 			return err
@@ -1134,7 +1140,7 @@ func (s *TransactionStreamer) storeResult(
 
 // exposed for testing
 // return value: true if should be called again immediately
-func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context, exec execution.ExecutionSequencer) bool {
+func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context) bool {
 	if ctx.Err() != nil {
 		return false
 	}
@@ -1206,7 +1212,7 @@ func (s *TransactionStreamer) ExecuteNextMsg(ctx context.Context, exec execution
 }
 
 func (s *TransactionStreamer) executeMessages(ctx context.Context, ignored struct{}) time.Duration {
-	if s.ExecuteNextMsg(ctx, s.exec) {
+	if s.ExecuteNextMsg(ctx) {
 		return 0
 	}
 	return s.config().ExecuteMessageLoopDelay
diff --git a/arbos/activate_test.go b/arbos/activate_test.go
index 55440bb..a89a386 100644
--- a/arbos/activate_test.go
+++ b/arbos/activate_test.go
@@ -20,6 +20,7 @@ func TestActivationDataFee(t *testing.T) {
 	rand.Seed(time.Now().UTC().UnixNano())
 	state, _ := arbosState.NewArbosMemoryBackedArbOSState()
 	pricer := state.Programs().DataPricer()
+	// #nosec G115
 	time := uint64(time.Now().Unix())
 
 	assert := func(cond bool) {
diff --git a/arbos/addressSet/addressSet.go b/arbos/addressSet/addressSet.go
index 1f09ff1..156f36e 100644
--- a/arbos/addressSet/addressSet.go
+++ b/arbos/addressSet/addressSet.go
@@ -79,6 +79,7 @@ func (as *AddressSet) AllMembers(maxNumToReturn uint64) ([]common.Address, error
 	}
 	ret := make([]common.Address, size)
 	for i := range ret {
+		// #nosec G115
 		sba := as.backingStorage.OpenStorageBackedAddress(uint64(i + 1))
 		ret[i], err = sba.Get()
 		if err != nil {
diff --git a/arbos/addressSet/addressSet_test.go b/arbos/addressSet/addressSet_test.go
index 7d06c74..d32e07a 100644
--- a/arbos/addressSet/addressSet_test.go
+++ b/arbos/addressSet/addressSet_test.go
@@ -316,6 +316,7 @@ func checkIfRectifyMappingWorks(t *testing.T, aset *AddressSet, owners []common.
 			Fail(t, "RectifyMapping did not fix the mismatch")
 		}
 
+		// #nosec G115
 		if clearList && int(size(t, aset)) != index+1 {
 			Fail(t, "RectifyMapping did not fix the mismatch")
 		}
diff --git a/arbos/addressTable/addressTable.go b/arbos/addressTable/addressTable.go
index 3fbb7b3..6ae2710 100644
--- a/arbos/addressTable/addressTable.go
+++ b/arbos/addressTable/addressTable.go
@@ -103,6 +103,7 @@ func (atab *AddressTable) Decompress(buf []byte) (common.Address, uint64, error)
 		return common.Address{}, 0, err
 	}
 	if len(input) == 20 {
+		// #nosec G115
 		numBytesRead := uint64(rd.Size() - int64(rd.Len()))
 		return common.BytesToAddress(input), numBytesRead, nil
 	} else {
@@ -118,6 +119,7 @@ func (atab *AddressTable) Decompress(buf []byte) (common.Address, uint64, error)
 		if !exists {
 			return common.Address{}, 0, errors.New("invalid index in compressed address")
 		}
+		// #nosec G115
 		numBytesRead := uint64(rd.Size() - int64(rd.Len()))
 		return addr, numBytesRead, nil
 	}
diff --git a/arbos/arbosState/arbosstate.go b/arbos/arbosState/arbosstate.go
index 91c2207..f53d9c8 100644
--- a/arbos/arbosState/arbosstate.go
+++ b/arbos/arbosState/arbosstate.go
@@ -41,28 +41,29 @@ import (
 // persisted beyond the end of the test.)
 
 type ArbosState struct {
-	arbosVersion                  uint64                      // version of the ArbOS storage format and semantics
-	maxArbosVersionSupported      uint64                      // maximum ArbOS version supported by this code
-	maxDebugArbosVersionSupported uint64                      // maximum ArbOS version supported by this code in debug mode
-	upgradeVersion                storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade
-	upgradeTimestamp              storage.StorageBackedUint64 // when to do the planned upgrade
-	networkFeeAccount             storage.StorageBackedAddress
-	l1PricingState                *l1pricing.L1PricingState
-	l2PricingState                *l2pricing.L2PricingState
-	retryableState                *retryables.RetryableState
-	addressTable                  *addressTable.AddressTable
-	chainOwners                   *addressSet.AddressSet
-	sendMerkle                    *merkleAccumulator.MerkleAccumulator
-	programs                      *programs.Programs
-	blockhashes                   *blockhash.Blockhashes
-	chainId                       storage.StorageBackedBigInt
-	chainConfig                   storage.StorageBackedBytes
-	genesisBlockNum               storage.StorageBackedUint64
-	infraFeeAccount               storage.StorageBackedAddress
-	brotliCompressionLevel        storage.StorageBackedUint64 // brotli compression level used for pricing
-	backingStorage                *storage.Storage
-	Burner                        burn.Burner
-}
+	arbosVersion           uint64                      // version of the ArbOS storage format and semantics
+	upgradeVersion         storage.StorageBackedUint64 // version we're planning to upgrade to, or 0 if not planning to upgrade
+	upgradeTimestamp       storage.StorageBackedUint64 // when to do the planned upgrade
+	networkFeeAccount      storage.StorageBackedAddress
+	l1PricingState         *l1pricing.L1PricingState
+	l2PricingState         *l2pricing.L2PricingState
+	retryableState         *retryables.RetryableState
+	addressTable           *addressTable.AddressTable
+	chainOwners            *addressSet.AddressSet
+	sendMerkle             *merkleAccumulator.MerkleAccumulator
+	programs               *programs.Programs
+	blockhashes            *blockhash.Blockhashes
+	chainId                storage.StorageBackedBigInt
+	chainConfig            storage.StorageBackedBytes
+	genesisBlockNum        storage.StorageBackedUint64
+	infraFeeAccount        storage.StorageBackedAddress
+	brotliCompressionLevel storage.StorageBackedUint64 // brotli compression level used for pricing
+	backingStorage         *storage.Storage
+	Burner                 burn.Burner
+}
+
+const MaxArbosVersionSupported uint64 = params.ArbosVersion_StylusChargingFixes
+const MaxDebugArbosVersionSupported uint64 = params.ArbosVersion_StylusChargingFixes
 
 var ErrUninitializedArbOS = errors.New("ArbOS uninitialized")
 var ErrAlreadyInitialized = errors.New("ArbOS is already initialized")
@@ -78,8 +79,6 @@ func OpenArbosState(stateDB vm.StateDB, burner burn.Burner) (*ArbosState, error)
 	}
 	return &ArbosState{
 		arbosVersion,
-		31,
-		31,
 		backingStorage.OpenStorageBackedUint64(uint64(upgradeVersionOffset)),
 		backingStorage.OpenStorageBackedUint64(uint64(upgradeTimestampOffset)),
 		backingStorage.OpenStorageBackedAddress(uint64(networkFeeAccountOffset)),
@@ -332,6 +331,9 @@ func (state *ArbosState) UpgradeArbosVersion(
 			ensure(params.UpgradeToVersion(2))
 			ensure(params.Save())
 
+		case 32:
+			// no change state needed
+
 		default:
 			return fmt.Errorf(
 				"the chain is upgrading to unsupported ArbOS version %v, %w",
@@ -416,14 +418,6 @@ func (state *ArbosState) RetryableState() *retryables.RetryableState {
 	return state.retryableState
 }
 
-func (state *ArbosState) MaxArbosVersionSupported() uint64 {
-	return state.maxArbosVersionSupported
-}
-
-func (state *ArbosState) MaxDebugArbosVersionSupported() uint64 {
-	return state.maxDebugArbosVersionSupported
-}
-
 func (state *ArbosState) L1PricingState() *l1pricing.L1PricingState {
 	return state.l1PricingState
 }
diff --git a/arbos/arbosState/initialization_test.go b/arbos/arbosState/initialization_test.go
index 3480239..5e605b8 100644
--- a/arbos/arbosState/initialization_test.go
+++ b/arbos/arbosState/initialization_test.go
@@ -109,6 +109,7 @@ func pseudorandomAccountInitInfoForTesting(prand *testhelpers.PseudoRandomDataSo
 }
 
 func pseudorandomHashHashMapForTesting(prand *testhelpers.PseudoRandomDataSource, maxItems uint64) map[common.Hash]common.Hash {
+	// #nosec G115
 	size := int(prand.GetUint64() % maxItems)
 	ret := make(map[common.Hash]common.Hash)
 	for i := 0; i < size; i++ {
@@ -125,6 +126,7 @@ func checkAddressTable(arbState *ArbosState, addrTable []common.Address, t *test
 		Fail(t)
 	}
 	for i, addr := range addrTable {
+		// #nosec G115
 		res, exists, err := atab.LookupIndex(uint64(i))
 		Require(t, err)
 		if !exists {
diff --git a/arbos/arbosState/initialize.go b/arbos/arbosState/initialize.go
index c44febf..427bdc3 100644
--- a/arbos/arbosState/initialize.go
+++ b/arbos/arbosState/initialize.go
@@ -6,10 +6,12 @@ package arbosState
 import (
 	"errors"
 	"math/big"
+	"regexp"
 	"sort"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethdb"
@@ -64,6 +66,8 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 		log.Crit("failed to init empty statedb", "error", err)
 	}
 
+	noStateTrieChangesToCommitError := regexp.MustCompile("^triedb layer .+ is disk layer$")
+
 	// commit avoids keeping the entire state in memory while importing the state.
 	// At some time it was also used to avoid reprocessing the whole import in case of a crash.
 	commit := func() (common.Hash, error) {
@@ -73,7 +77,11 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 		}
 		err = stateDatabase.TrieDB().Commit(root, true)
 		if err != nil {
-			return common.Hash{}, err
+			// pathdb returns an error when there are no state trie changes to commit and we try to commit.
+			// This checks if the error is the expected one and ignores it.
+			if (cacheConfig.StateScheme != rawdb.PathScheme) || !noStateTrieChangesToCommitError.MatchString(err.Error()) {
+				return common.Hash{}, err
+			}
 		}
 		statedb, err = state.New(root, stateDatabase, nil)
 		if err != nil {
@@ -100,7 +108,7 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 	if err != nil {
 		return common.Hash{}, err
 	}
-	for i := 0; addressReader.More(); i++ {
+	for i := uint64(0); addressReader.More(); i++ {
 		addr, err := addressReader.GetNext()
 		if err != nil {
 			return common.Hash{}, err
@@ -109,7 +117,7 @@ func InitializeArbosInDatabase(db ethdb.Database, cacheConfig *core.CacheConfig,
 		if err != nil {
 			return common.Hash{}, err
 		}
-		if uint64(i) != slot {
+		if i != slot {
 			return common.Hash{}, errors.New("address table slot mismatch")
 		}
 	}
diff --git a/arbos/arbostypes/incomingmessage.go b/arbos/arbostypes/incomingmessage.go
index 04ce8eb..c4c2dc0 100644
--- a/arbos/arbostypes/incomingmessage.go
+++ b/arbos/arbostypes/incomingmessage.go
@@ -182,6 +182,17 @@ func (msg *L1IncomingMessage) FillInBatchGasCost(batchFetcher FallibleBatchFetch
 	return nil
 }
 
+func (msg *L1IncomingMessage) PastBatchesRequired() ([]uint64, error) {
+	if msg.Header.Kind != L1MessageType_BatchPostingReport {
+		return nil, nil
+	}
+	_, _, _, batchNum, _, _, err := ParseBatchPostingReportMessageFields(bytes.NewReader(msg.L2msg))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse batch posting report: %w", err)
+	}
+	return []uint64{batchNum}, nil
+}
+
 func ParseIncomingL1Message(rd io.Reader, batchFetcher FallibleBatchFetcher) (*L1IncomingMessage, error) {
 	var kindBuf [1]byte
 	_, err := rd.Read(kindBuf[:])
diff --git a/arbos/l1pricing/l1pricing.go b/arbos/l1pricing/l1pricing.go
index 9e00eeb..392bf36 100644
--- a/arbos/l1pricing/l1pricing.go
+++ b/arbos/l1pricing/l1pricing.go
@@ -509,7 +509,7 @@ func (ps *L1PricingState) getPosterUnitsWithoutCache(tx *types.Transaction, post
 		return 0
 	}
 
-	l1Bytes, err := byteCountAfterBrotliLevel(txBytes, int(brotliCompressionLevel))
+	l1Bytes, err := byteCountAfterBrotliLevel(txBytes, brotliCompressionLevel)
 	if err != nil {
 		panic(fmt.Sprintf("failed to compress tx: %v", err))
 	}
@@ -594,7 +594,7 @@ func (ps *L1PricingState) PosterDataCost(message *core.Message, poster common.Ad
 	return am.BigMulByUint(pricePerUnit, units), units
 }
 
-func byteCountAfterBrotliLevel(input []byte, level int) (uint64, error) {
+func byteCountAfterBrotliLevel(input []byte, level uint64) (uint64, error) {
 	compressed, err := arbcompress.CompressLevel(input, level)
 	if err != nil {
 		return 0, err
diff --git a/arbos/l1pricing_test.go b/arbos/l1pricing_test.go
index 6e2b1b7..6f9e3ec 100644
--- a/arbos/l1pricing_test.go
+++ b/arbos/l1pricing_test.go
@@ -100,7 +100,7 @@ func expectedResultsForL1Test(input *l1PricingTest) *l1TestExpectedResults {
 			availableFunds = availableFundsCap
 		}
 	}
-	fundsWantedForRewards := big.NewInt(int64(input.unitReward * input.unitsPerSecond))
+	fundsWantedForRewards := new(big.Int).SetUint64(input.unitReward * input.unitsPerSecond)
 	unitsAllocated := arbmath.UintToBig(input.unitsPerSecond)
 	if arbmath.BigLessThan(availableFunds, fundsWantedForRewards) {
 		ret.rewardRecipientBalance = availableFunds
@@ -111,7 +111,7 @@ func expectedResultsForL1Test(input *l1PricingTest) *l1TestExpectedResults {
 	uncappedAvailableFunds = arbmath.BigSub(uncappedAvailableFunds, ret.rewardRecipientBalance)
 	ret.unitsRemaining = (3 * input.unitsPerSecond) - unitsAllocated.Uint64()
 
-	maxCollectable := big.NewInt(int64(input.fundsSpent))
+	maxCollectable := new(big.Int).SetUint64(input.fundsSpent)
 	if arbmath.BigLessThan(availableFunds, maxCollectable) {
 		maxCollectable = availableFunds
 	}
@@ -170,7 +170,7 @@ func _testL1PricingFundsDue(t *testing.T, testParams *l1PricingTest, expectedRes
 	Require(t, err)
 
 	// create some fake collection
-	balanceAdded := big.NewInt(int64(testParams.fundsCollectedPerSecond * 3))
+	balanceAdded := new(big.Int).SetUint64(testParams.fundsCollectedPerSecond * 3)
 	unitsAdded := testParams.unitsPerSecond * 3
 	evm.StateDB.AddBalance(l1pricing.L1PricerFundsPoolAddress, uint256.MustFromBig(balanceAdded))
 	err = l1p.SetL1FeesAvailable(balanceAdded)
@@ -279,7 +279,9 @@ func _testL1PriceEquilibration(t *testing.T, initialL1BasefeeEstimate *big.Int,
 			evm.StateDB,
 			evm,
 			3,
+			// #nosec G115
 			uint64(10*(i+1)),
+			// #nosec G115
 			uint64(10*(i+1)+5),
 			bpAddr,
 			arbmath.BigMulByUint(equilibriumL1BasefeeEstimate, unitsToAdd),
diff --git a/arbos/l2pricing/l2pricing_test.go b/arbos/l2pricing/l2pricing_test.go
index 57759d7..aa1e785 100644
--- a/arbos/l2pricing/l2pricing_test.go
+++ b/arbos/l2pricing/l2pricing_test.go
@@ -40,6 +40,7 @@ func TestPricingModelExp(t *testing.T) {
 	// show that running at the speed limit with a full pool is a steady-state
 	colors.PrintBlue("full pool & speed limit")
 	for seconds := 0; seconds < 4; seconds++ {
+		// #nosec G115
 		fakeBlockUpdate(t, pricing, int64(seconds)*int64(limit), uint64(seconds))
 		if getPrice(t, pricing) != minPrice {
 			Fail(t, "price changed when it shouldn't have")
@@ -50,6 +51,7 @@ func TestPricingModelExp(t *testing.T) {
 	// note that for large enough spans of time the price will rise a miniscule amount due to the pool's avg
 	colors.PrintBlue("pool target & speed limit")
 	for seconds := 0; seconds < 4; seconds++ {
+		// #nosec G115
 		fakeBlockUpdate(t, pricing, int64(seconds)*int64(limit), uint64(seconds))
 		if getPrice(t, pricing) != minPrice {
 			Fail(t, "price changed when it shouldn't have")
@@ -59,6 +61,7 @@ func TestPricingModelExp(t *testing.T) {
 	// show that running over the speed limit escalates the price before the pool drains
 	colors.PrintBlue("exceeding the speed limit")
 	for {
+		// #nosec G115
 		fakeBlockUpdate(t, pricing, 8*int64(limit), 1)
 		newPrice := getPrice(t, pricing)
 		if newPrice < price {
diff --git a/arbos/l2pricing/model.go b/arbos/l2pricing/model.go
index 131af2c..476effa 100644
--- a/arbos/l2pricing/model.go
+++ b/arbos/l2pricing/model.go
@@ -30,22 +30,26 @@ func (ps *L2PricingState) AddToGasPool(gas int64) error {
 		return err
 	}
 	// pay off some of the backlog with the added gas, stopping at 0
-	backlog = arbmath.SaturatingUCast[uint64](arbmath.SaturatingSub(int64(backlog), gas))
+	if gas > 0 {
+		backlog = arbmath.SaturatingUSub(backlog, uint64(gas))
+	} else {
+		backlog = arbmath.SaturatingUAdd(backlog, uint64(-gas))
+	}
 	return ps.SetGasBacklog(backlog)
 }
 
 // UpdatePricingModel updates the pricing model with info from the last block
 func (ps *L2PricingState) UpdatePricingModel(l2BaseFee *big.Int, timePassed uint64, debug bool) {
 	speedLimit, _ := ps.SpeedLimitPerSecond()
-	_ = ps.AddToGasPool(int64(timePassed * speedLimit))
+	_ = ps.AddToGasPool(arbmath.SaturatingCast[int64](arbmath.SaturatingUMul(timePassed, speedLimit)))
 	inertia, _ := ps.PricingInertia()
 	tolerance, _ := ps.BacklogTolerance()
 	backlog, _ := ps.GasBacklog()
 	minBaseFee, _ := ps.MinBaseFeeWei()
 	baseFee := minBaseFee
 	if backlog > tolerance*speedLimit {
-		excess := int64(backlog - tolerance*speedLimit)
-		exponentBips := arbmath.NaturalToBips(excess) / arbmath.Bips(inertia*speedLimit)
+		excess := arbmath.SaturatingCast[int64](backlog - tolerance*speedLimit)
+		exponentBips := arbmath.NaturalToBips(excess) / arbmath.SaturatingCast[arbmath.Bips](inertia*speedLimit)
 		baseFee = arbmath.BigMulByBips(minBaseFee, arbmath.ApproxExpBasisPoints(exponentBips, 4))
 	}
 	_ = ps.SetBaseFeeWei(baseFee)
diff --git a/arbos/merkleAccumulator/merkleAccumulator.go b/arbos/merkleAccumulator/merkleAccumulator.go
index 2e060c5..e62303e 100644
--- a/arbos/merkleAccumulator/merkleAccumulator.go
+++ b/arbos/merkleAccumulator/merkleAccumulator.go
@@ -97,6 +97,7 @@ func (acc *MerkleAccumulator) GetPartials() ([]*common.Hash, error) {
 	}
 	partials := make([]*common.Hash, CalcNumPartials(size))
 	for i := range partials {
+		// #nosec G115
 		p, err := acc.getPartial(uint64(i))
 		if err != nil {
 			return nil, err
diff --git a/arbos/programs/api.go b/arbos/programs/api.go
index 5042893..3e59031 100644
--- a/arbos/programs/api.go
+++ b/arbos/programs/api.go
@@ -400,9 +400,9 @@ func newApiClosures(
 			}
 			startInk := takeU64()
 			endInk := takeU64()
-			nameLen := takeU16()
-			argsLen := takeU16()
-			outsLen := takeU16()
+			nameLen := takeU32()
+			argsLen := takeU32()
+			outsLen := takeU32()
 			name := string(takeFixed(int(nameLen)))
 			args := takeFixed(int(argsLen))
 			outs := takeFixed(int(outsLen))
diff --git a/arbos/programs/cgo_test.go b/arbos/programs/cgo_test.go
new file mode 100644
index 0000000..e16c362
--- /dev/null
+++ b/arbos/programs/cgo_test.go
@@ -0,0 +1,52 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+//go:build !wasm
+// +build !wasm
+
+package programs
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestConstants(t *testing.T) {
+	err := testConstants()
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+// normal test will not write anything to disk
+// to test cross-compilation:
+// * run test with TEST_COMPILE=STORE on one machine
+// * copy target/testdata to the other machine
+// * run test with TEST_COMPILE=LOAD on the other machine
+func TestCompileArch(t *testing.T) {
+	compile_env := os.Getenv("TEST_COMPILE")
+	if compile_env == "" {
+		fmt.Print("use TEST_COMPILE=[STORE|LOAD] to allow store/load in compile test")
+	}
+	store := strings.Contains(compile_env, "STORE")
+	err := testCompileArch(store)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if store || strings.Contains(compile_env, "LOAD") {
+		err = testCompileLoad()
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = resetNativeTarget()
+		if err != nil {
+			t.Fatal(err)
+		}
+		err = testCompileLoad()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/arbos/programs/data_pricer.go b/arbos/programs/data_pricer.go
index ed7c985..d82aa81 100644
--- a/arbos/programs/data_pricer.go
+++ b/arbos/programs/data_pricer.go
@@ -83,8 +83,8 @@ func (p *DataPricer) UpdateModel(tempBytes uint32, time uint64) (*big.Int, error
 	}
 
 	exponent := arbmath.OneInBips * arbmath.Bips(demand) / arbmath.Bips(inertia)
-	multiplier := arbmath.ApproxExpBasisPoints(exponent, 12).Uint64()
-	costPerByte := arbmath.SaturatingUMul(uint64(minPrice), multiplier) / 10000
+	multiplier := arbmath.ApproxExpBasisPoints(exponent, 12)
+	costPerByte := arbmath.UintSaturatingMulByBips(uint64(minPrice), multiplier)
 	costInWei := arbmath.SaturatingUMul(costPerByte, uint64(tempBytes))
 	return arbmath.UintToBig(costInWei), nil
 }
diff --git a/arbos/programs/native.go b/arbos/programs/native.go
index a0976af..5fbc512 100644
--- a/arbos/programs/native.go
+++ b/arbos/programs/native.go
@@ -7,7 +7,7 @@
 package programs
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 
@@ -27,7 +27,9 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/offchainlabs/nitro/arbos/burn"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -44,21 +46,30 @@ type bytes32 = C.Bytes32
 type rustBytes = C.RustBytes
 type rustSlice = C.RustSlice
 
+var (
+	stylusLRUCacheSizeBytesGauge        = metrics.NewRegisteredGauge("arb/arbos/stylus/cache/lru/size_bytes", nil)
+	stylusLRUCacheSizeCountGauge        = metrics.NewRegisteredGauge("arb/arbos/stylus/cache/lru/count", nil)
+	stylusLRUCacheSizeHitsCounter       = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/hits", nil)
+	stylusLRUCacheSizeMissesCounter     = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/misses", nil)
+	stylusLRUCacheSizeDoesNotFitCounter = metrics.NewRegisteredCounter("arb/arbos/stylus/cache/lru/does_not_fit", nil)
+)
+
 func activateProgram(
 	db vm.StateDB,
 	program common.Address,
 	codehash common.Hash,
 	wasm []byte,
 	page_limit uint16,
-	version uint16,
+	stylusVersion uint16,
+	arbosVersionForGas uint64,
 	debug bool,
 	burner burn.Burner,
 ) (*activationInfo, error) {
-	info, asm, module, err := activateProgramInternal(db, program, codehash, wasm, page_limit, version, debug, burner.GasLeft())
+	info, asmMap, err := activateProgramInternal(db, program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft())
 	if err != nil {
 		return nil, err
 	}
-	db.ActivateWasm(info.moduleHash, asm, module)
+	db.ActivateWasm(info.moduleHash, asmMap)
 	return info, nil
 }
 
@@ -68,44 +79,90 @@ func activateProgramInternal(
 	codehash common.Hash,
 	wasm []byte,
 	page_limit uint16,
-	version uint16,
+	stylusVersion uint16,
+	arbosVersionForGas uint64,
 	debug bool,
 	gasLeft *uint64,
-) (*activationInfo, []byte, []byte, error) {
+) (*activationInfo, map[ethdb.WasmTarget][]byte, error) {
 	output := &rustBytes{}
-	asmLen := usize(0)
 	moduleHash := &bytes32{}
 	stylusData := &C.StylusData{}
 	codeHash := hashToBytes32(codehash)
 
-	status := userStatus(C.stylus_activate(
+	status_mod := userStatus(C.stylus_activate(
 		goSlice(wasm),
 		u16(page_limit),
-		u16(version),
+		u16(stylusVersion),
+		u64(arbosVersionForGas),
 		cbool(debug),
 		output,
-		&asmLen,
 		&codeHash,
 		moduleHash,
 		stylusData,
 		(*u64)(gasLeft),
 	))
 
-	data, msg, err := status.toResult(output.intoBytes(), debug)
+	module, msg, err := status_mod.toResult(output.intoBytes(), debug)
 	if err != nil {
 		if debug {
 			log.Warn("activation failed", "err", err, "msg", msg, "program", addressForLogging)
 		}
 		if errors.Is(err, vm.ErrExecutionReverted) {
-			return nil, nil, nil, fmt.Errorf("%w: %s", ErrProgramActivation, msg)
+			return nil, nil, fmt.Errorf("%w: %s", ErrProgramActivation, msg)
 		}
-		return nil, nil, nil, err
+		return nil, nil, err
 	}
-
 	hash := moduleHash.toHash()
-	split := int(asmLen)
-	asm := data[:split]
-	module := data[split:]
+	targets := db.Database().WasmTargets()
+	type result struct {
+		target ethdb.WasmTarget
+		asm    []byte
+		err    error
+	}
+	results := make(chan result, len(targets))
+	for _, target := range targets {
+		target := target
+		if target == rawdb.TargetWavm {
+			results <- result{target, module, nil}
+		} else {
+			go func() {
+				output := &rustBytes{}
+				status_asm := C.stylus_compile(
+					goSlice(wasm),
+					u16(stylusVersion),
+					cbool(debug),
+					goSlice([]byte(target)),
+					output,
+				)
+				asm := output.intoBytes()
+				if status_asm != 0 {
+					results <- result{target, nil, fmt.Errorf("%w: %s", ErrProgramActivation, string(asm))}
+					return
+				}
+				results <- result{target, asm, nil}
+			}()
+		}
+	}
+	asmMap := make(map[ethdb.WasmTarget][]byte, len(targets))
+	for range targets {
+		res := <-results
+		if res.err != nil {
+			err = errors.Join(res.err, err)
+		} else {
+			asmMap[res.target] = res.asm
+		}
+	}
+	if err != nil {
+		log.Error(
+			"Compilation failed for one or more targets despite activation succeeding",
+			"address", addressForLogging,
+			"codeHash", codeHash,
+			"moduleHash", hash,
+			"targets", targets,
+			"err", err,
+		)
+		panic(fmt.Sprintf("Compilation of %v failed for one or more targets despite activation succeeding: %v", addressForLogging, err))
+	}
 
 	info := &activationInfo{
 		moduleHash:    hash,
@@ -114,11 +171,12 @@ func activateProgramInternal(
 		asmEstimate:   uint32(stylusData.asm_estimate),
 		footprint:     uint16(stylusData.footprint),
 	}
-	return info, asm, module, err
+	return info, asmMap, err
 }
 
 func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codeHash common.Hash, pagelimit uint16, time uint64, debugMode bool, program Program) ([]byte, error) {
-	localAsm, err := statedb.TryGetActivatedAsm(moduleHash)
+	localTarget := rawdb.LocalTarget()
+	localAsm, err := statedb.TryGetActivatedAsm(localTarget, moduleHash)
 	if err == nil && len(localAsm) > 0 {
 		return localAsm, nil
 	}
@@ -130,9 +188,12 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
 	}
 
-	unlimitedGas := uint64(0xffffffffffff)
+	// don't charge gas
+	zeroArbosVersion := uint64(0)
+	zeroGas := uint64(0)
+
 	// we know program is activated, so it must be in correct version and not use too much memory
-	info, asm, module, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, debugMode, &unlimitedGas)
+	info, asmMap, err := activateProgramInternal(statedb, addressForLogging, codeHash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
 	if err != nil {
 		log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err)
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
@@ -148,14 +209,23 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 		// stylus program is active on-chain, and was activated in the past
 		// so we store it directly to database
 		batch := statedb.Database().WasmStore().NewBatch()
-		rawdb.WriteActivation(batch, moduleHash, asm, module)
+		rawdb.WriteActivation(batch, moduleHash, asmMap)
 		if err := batch.Write(); err != nil {
 			log.Error("failed writing re-activation to state", "address", addressForLogging, "err", err)
 		}
 	} else {
 		// program activated recently, possibly in this eth_call
 		// store it to statedb. It will be stored to database if statedb is commited
-		statedb.ActivateWasm(info.moduleHash, asm, module)
+		statedb.ActivateWasm(info.moduleHash, asmMap)
+	}
+	asm, exists := asmMap[localTarget]
+	if !exists {
+		var availableTargets []ethdb.WasmTarget
+		for target := range asmMap {
+			availableTargets = append(availableTargets, target)
+		}
+		log.Error("failed to reactivate program - missing asm for local target", "address", addressForLogging, "local target", localTarget, "available targets", availableTargets)
+		return nil, fmt.Errorf("failed to reactivate program - missing asm for local target, address: %v, local target: %v, available targets: %v", addressForLogging, localTarget, availableTargets)
 	}
 	return asm, nil
 }
@@ -181,8 +251,8 @@ func callProgram(
 		panic("missing asm")
 	}
 
-	if db, ok := db.(*state.StateDB); ok {
-		db.RecordProgram(moduleHash)
+	if stateDb, ok := db.(*state.StateDB); ok {
+		stateDb.RecordProgram(db.Database().WasmTargets(), moduleHash)
 	}
 
 	evmApi := newApi(interpreter, tracingInfo, scope, memoryModel)
@@ -259,8 +329,58 @@ func init() {
 	}
 }
 
-func ResizeWasmLruCache(size uint32) {
-	C.stylus_cache_lru_resize(u32(size))
+func SetWasmLruCacheCapacity(capacityBytes uint64) {
+	C.stylus_set_cache_lru_capacity(u64(capacityBytes))
+}
+
+// exported for testing
+type WasmLruCacheMetrics struct {
+	SizeBytes uint64
+	Count     uint32
+}
+
+func GetWasmLruCacheMetrics() *WasmLruCacheMetrics {
+	metrics := C.stylus_get_lru_cache_metrics()
+
+	stylusLRUCacheSizeBytesGauge.Update(int64(metrics.size_bytes))
+	stylusLRUCacheSizeCountGauge.Update(int64(metrics.count))
+	stylusLRUCacheSizeHitsCounter.Inc(int64(metrics.hits))
+	stylusLRUCacheSizeMissesCounter.Inc(int64(metrics.misses))
+	stylusLRUCacheSizeDoesNotFitCounter.Inc(int64(metrics.does_not_fit))
+
+	return &WasmLruCacheMetrics{
+		SizeBytes: uint64(metrics.size_bytes),
+		Count:     uint32(metrics.count),
+	}
+}
+
+// Used for testing
+func ClearWasmLruCache() {
+	C.stylus_clear_lru_cache()
+}
+
+// Used for testing
+func GetLruEntrySizeEstimateBytes(module []byte, version uint16, debug bool) uint64 {
+	return uint64(C.stylus_get_lru_entry_size_estimate_bytes(goSlice(module), u16(version), cbool(debug)))
+}
+
+const DefaultTargetDescriptionArm = "arm64-linux-unknown+neon"
+const DefaultTargetDescriptionX86 = "x86_64-linux-unknown+sse4.2+lzcnt+bmi"
+
+func SetTarget(name ethdb.WasmTarget, description string, native bool) error {
+	output := &rustBytes{}
+	status := userStatus(C.stylus_target_set(
+		goSlice([]byte(name)),
+		goSlice([]byte(description)),
+		output,
+		cbool(native),
+	))
+	if status != userSuccess {
+		msg := arbutil.ToStringOrHex(output.intoBytes())
+		log.Error("failed to set stylus compilation target", "status", status, "msg", msg)
+		return fmt.Errorf("failed to set stylus compilation target, status %v: %v", status, msg)
+	}
+	return nil
 }
 
 func (value bytes32) toHash() common.Hash {
@@ -325,6 +445,7 @@ func (params *ProgParams) encode() C.StylusConfig {
 
 func (data *EvmData) encode() C.EvmData {
 	return C.EvmData{
+		arbos_version:    u64(data.arbosVersion),
 		block_basefee:    hashToBytes32(data.blockBasefee),
 		chainid:          u64(data.chainId),
 		block_coinbase:   addressToBytes20(data.blockCoinbase),
diff --git a/arbos/programs/native_api.go b/arbos/programs/native_api.go
index 6fbb630..6cecb8e 100644
--- a/arbos/programs/native_api.go
+++ b/arbos/programs/native_api.go
@@ -7,7 +7,7 @@
 package programs
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 
diff --git a/arbos/programs/programs.go b/arbos/programs/programs.go
index 12102ba..06ff413 100644
--- a/arbos/programs/programs.go
+++ b/arbos/programs/programs.go
@@ -82,7 +82,7 @@ func (p Programs) CacheManagers() *addressSet.AddressSet {
 	return p.cacheManagers
 }
 
-func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode core.MessageRunMode, debugMode bool) (
+func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, arbosVersion uint64, runMode core.MessageRunMode, debugMode bool) (
 	uint16, common.Hash, common.Hash, *big.Int, bool, error,
 ) {
 	statedb := evm.StateDB
@@ -116,7 +116,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 	// require the program's footprint not exceed the remaining memory budget
 	pageLimit := am.SaturatingUSub(params.PageLimit, statedb.GetStylusPagesOpen())
 
-	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, debugMode, burner)
+	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, arbosVersion, debugMode, burner)
 	if err != nil {
 		return 0, codeHash, common.Hash{}, nil, true, err
 	}
@@ -127,6 +127,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 		if err != nil {
 			return 0, codeHash, common.Hash{}, nil, true, err
 		}
+
 		evictProgram(statedb, oldModuleHash, currentVersion, debugMode, runMode, expired)
 	}
 	if err := p.moduleHashes.Set(codeHash, info.moduleHash); err != nil {
@@ -222,6 +223,7 @@ func (p Programs) CallProgram(
 	}
 
 	evmData := &EvmData{
+		arbosVersion:    evm.Context.ArbOSVersion,
 		blockBasefee:    common.BigToHash(evm.Context.BaseFee),
 		chainId:         evm.ChainConfig().ChainID.Uint64(),
 		blockCoinbase:   evm.Context.Coinbase,
@@ -517,6 +519,7 @@ func (p Programs) progParams(version uint16, debug bool, params *StylusParams) *
 }
 
 type EvmData struct {
+	arbosVersion    uint64
 	blockBasefee    common.Hash
 	chainId         uint64
 	blockCoinbase   common.Address
diff --git a/arbos/programs/testcompile.go b/arbos/programs/testcompile.go
new file mode 100644
index 0000000..615b0f3
--- /dev/null
+++ b/arbos/programs/testcompile.go
@@ -0,0 +1,268 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+//go:build !wasm
+// +build !wasm
+
+package programs
+
+// This file exists because cgo isn't allowed in tests
+
+/*
+#cgo CFLAGS: -g -I../../target/include/
+#include "arbitrator.h"
+
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef size_t usize;
+
+void handleReqWrap(usize api, u32 req_type, RustSlice *data, u64 *out_cost, GoSliceData *out_result, GoSliceData *out_raw_data);
+*/
+import "C"
+import (
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/ethereum/go-ethereum/core/rawdb"
+)
+
+func Wat2Wasm(wat []byte) ([]byte, error) {
+	output := &rustBytes{}
+
+	status := C.wat_to_wasm(goSlice(wat), output)
+
+	if status != 0 {
+		return nil, fmt.Errorf("failed reading wat file: %v", string(output.intoBytes()))
+	}
+
+	return output.intoBytes(), nil
+}
+
+func testCompileArch(store bool) error {
+
+	localTarget := rawdb.LocalTarget()
+	nativeArm64 := localTarget == rawdb.TargetArm64
+	nativeAmd64 := localTarget == rawdb.TargetAmd64
+
+	arm64CompileName := []byte(rawdb.TargetArm64)
+	amd64CompileName := []byte(rawdb.TargetAmd64)
+
+	arm64TargetString := []byte(DefaultTargetDescriptionArm)
+	amd64TargetString := []byte(DefaultTargetDescriptionX86)
+
+	output := &rustBytes{}
+
+	_, err := fmt.Print("starting test.. native arm? ", nativeArm64, " amd? ", nativeAmd64, " GOARCH/GOOS: ", runtime.GOARCH+"/"+runtime.GOOS, "\n")
+	if err != nil {
+		return err
+	}
+
+	status := C.stylus_target_set(goSlice(arm64CompileName),
+		goSlice(arm64TargetString),
+		output,
+		cbool(nativeArm64))
+
+	if status != 0 {
+		return fmt.Errorf("failed setting compilation target arm: %v", string(output.intoBytes()))
+	}
+
+	status = C.stylus_target_set(goSlice(amd64CompileName),
+		goSlice(amd64TargetString),
+		output,
+		cbool(nativeAmd64))
+
+	if status != 0 {
+		return fmt.Errorf("failed setting compilation target amd: %v", string(output.intoBytes()))
+	}
+
+	source, err := os.ReadFile("../../arbitrator/stylus/tests/add.wat")
+	if err != nil {
+		return fmt.Errorf("failed reading stylus contract: %w", err)
+	}
+
+	wasm, err := Wat2Wasm(source)
+	if err != nil {
+		return err
+	}
+
+	if store {
+		_, err := fmt.Print("storing compiled files to ../../target/testdata/\n")
+		if err != nil {
+			return err
+		}
+		err = os.MkdirAll("../../target/testdata", 0755)
+		if err != nil {
+			return err
+		}
+	}
+
+	status = C.stylus_compile(
+		goSlice(wasm),
+		u16(1),
+		cbool(true),
+		goSlice([]byte("booga")),
+		output,
+	)
+	if status == 0 {
+		return fmt.Errorf("succeeded compiling non-existent arch: %v", string(output.intoBytes()))
+	}
+
+	status = C.stylus_compile(
+		goSlice(wasm),
+		u16(1),
+		cbool(true),
+		goSlice([]byte{}),
+		output,
+	)
+	if status != 0 {
+		return fmt.Errorf("failed compiling native: %v", string(output.intoBytes()))
+	}
+	if store && !nativeAmd64 && !nativeArm64 {
+		_, err := fmt.Printf("writing host file\n")
+		if err != nil {
+			return err
+		}
+
+		err = os.WriteFile("../../target/testdata/host.bin", output.intoBytes(), 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	status = C.stylus_compile(
+		goSlice(wasm),
+		u16(1),
+		cbool(true),
+		goSlice(arm64CompileName),
+		output,
+	)
+	if status != 0 {
+		return fmt.Errorf("failed compiling arm: %v", string(output.intoBytes()))
+	}
+	if store {
+		_, err := fmt.Printf("writing arm file\n")
+		if err != nil {
+			return err
+		}
+
+		err = os.WriteFile("../../target/testdata/arm64.bin", output.intoBytes(), 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	status = C.stylus_compile(
+		goSlice(wasm),
+		u16(1),
+		cbool(true),
+		goSlice(amd64CompileName),
+		output,
+	)
+	if status != 0 {
+		return fmt.Errorf("failed compiling amd: %v", string(output.intoBytes()))
+	}
+	if store {
+		_, err := fmt.Printf("writing amd64 file\n")
+		if err != nil {
+			return err
+		}
+
+		err = os.WriteFile("../../target/testdata/amd64.bin", output.intoBytes(), 0644)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func resetNativeTarget() error {
+	output := &rustBytes{}
+
+	_, err := fmt.Print("resetting native target\n")
+	if err != nil {
+		return err
+	}
+
+	localCompileName := []byte("local")
+
+	status := C.stylus_target_set(goSlice(localCompileName),
+		goSlice([]byte{}),
+		output,
+		cbool(true))
+
+	if status != 0 {
+		return fmt.Errorf("failed setting compilation target arm: %v", string(output.intoBytes()))
+	}
+
+	return nil
+}
+
+func testCompileLoad() error {
+	filePath := "../../target/testdata/host.bin"
+	localTarget := rawdb.LocalTarget()
+	if localTarget == rawdb.TargetArm64 {
+		filePath = "../../target/testdata/arm64.bin"
+	}
+	if localTarget == rawdb.TargetAmd64 {
+		filePath = "../../target/testdata/amd64.bin"
+	}
+
+	_, err := fmt.Print("starting load test. FilePath: ", filePath, " GOARCH/GOOS: ", runtime.GOARCH+"/"+runtime.GOOS, "\n")
+	if err != nil {
+		return err
+	}
+
+	localAsm, err := os.ReadFile(filePath)
+	if err != nil {
+		return err
+	}
+
+	calldata := []byte{}
+
+	evmData := EvmData{}
+	progParams := ProgParams{
+		MaxDepth:  10000,
+		InkPrice:  1,
+		DebugMode: true,
+	}
+	reqHandler := C.NativeRequestHandler{
+		handle_request_fptr: (*[0]byte)(C.handleReqWrap),
+		id:                  0,
+	}
+
+	inifiniteGas := u64(0xfffffffffffffff)
+
+	output := &rustBytes{}
+
+	_, err = fmt.Print("launching program..\n")
+	if err != nil {
+		return err
+	}
+
+	status := userStatus(C.stylus_call(
+		goSlice(localAsm),
+		goSlice(calldata),
+		progParams.encode(),
+		reqHandler,
+		evmData.encode(),
+		cbool(true),
+		output,
+		&inifiniteGas,
+		u32(0),
+	))
+
+	_, err = fmt.Print("returned: ", status, "\n")
+	if err != nil {
+		return err
+	}
+
+	_, msg, err := status.toResult(output.intoBytes(), true)
+	if status == userFailure {
+		err = fmt.Errorf("%w: %v", err, msg)
+	}
+
+	return err
+}
diff --git a/arbos/programs/testconstants.go b/arbos/programs/testconstants.go
index 1ab0e6e..44f69a5 100644
--- a/arbos/programs/testconstants.go
+++ b/arbos/programs/testconstants.go
@@ -9,7 +9,7 @@ package programs
 // This file exists because cgo isn't allowed in tests
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 */
 import "C"
diff --git a/arbos/programs/wasm.go b/arbos/programs/wasm.go
index f7191dc..12c23a7 100644
--- a/arbos/programs/wasm.go
+++ b/arbos/programs/wasm.go
@@ -36,7 +36,7 @@ type rustConfig byte
 type rustModule byte
 type rustEvmData byte
 
-//go:wasmimport programs activate
+//go:wasmimport programs activate_v2
 func programActivate(
 	wasm_ptr unsafe.Pointer,
 	wasm_size uint32,
@@ -44,7 +44,8 @@ func programActivate(
 	asm_estimation_ptr unsafe.Pointer,
 	init_gas_ptr unsafe.Pointer,
 	cached_init_gas_ptr unsafe.Pointer,
-	version uint32,
+	stylusVersion uint32,
+	arbosVersion uint64,
 	debug uint32,
 	codehash unsafe.Pointer,
 	module_hash_ptr unsafe.Pointer,
@@ -59,7 +60,8 @@ func activateProgram(
 	codehash common.Hash,
 	wasm []byte,
 	pageLimit u16,
-	version u16,
+	stylusVersion u16,
+	arbosVersion uint64,
 	debug bool,
 	burner burn.Burner,
 ) (*activationInfo, error) {
@@ -79,7 +81,8 @@ func activateProgram(
 		unsafe.Pointer(&asmEstimate),
 		unsafe.Pointer(&initGas),
 		unsafe.Pointer(&cachedInitGas),
-		uint32(version),
+		uint32(stylusVersion),
+		arbosVersion,
 		debugMode,
 		arbutil.SliceToUnsafePointer(codehash[:]),
 		arbutil.SliceToUnsafePointer(moduleHash[:]),
@@ -151,6 +154,8 @@ func callProgram(
 	return retData, err
 }
 
+func GetWasmLruCacheMetrics() {}
+
 func CallProgramLoop(
 	moduleHash common.Hash,
 	calldata []byte,
diff --git a/arbos/programs/wasm_api.go b/arbos/programs/wasm_api.go
index d7bac05..a4ebc1f 100644
--- a/arbos/programs/wasm_api.go
+++ b/arbos/programs/wasm_api.go
@@ -20,8 +20,9 @@ func createStylusConfig(version uint32, max_depth uint32, ink_price uint32, debu
 
 type evmDataHandler uint64
 
-//go:wasmimport programs create_evm_data
+//go:wasmimport programs create_evm_data_v2
 func createEvmData(
+	arbosVersion uint64,
 	blockBaseFee unsafe.Pointer,
 	chainid uint64,
 	blockCoinbase unsafe.Pointer,
@@ -45,6 +46,7 @@ func (params *ProgParams) createHandler() stylusConfigHandler {
 
 func (data *EvmData) createHandler() evmDataHandler {
 	return createEvmData(
+		data.arbosVersion,
 		arbutil.SliceToUnsafePointer(data.blockBasefee[:]),
 		data.chainId,
 		arbutil.SliceToUnsafePointer(data.blockCoinbase[:]),
diff --git a/arbos/programs/wasmstorehelper.go b/arbos/programs/wasmstorehelper.go
index 9e69178..c2d1aa6 100644
--- a/arbos/programs/wasmstorehelper.go
+++ b/arbos/programs/wasmstorehelper.go
@@ -17,12 +17,12 @@ import (
 
 // SaveActiveProgramToWasmStore is used to save active stylus programs to wasm store during rebuilding
 func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash common.Hash, code []byte, time uint64, debugMode bool, rebuildingStartBlockTime uint64) error {
-	params, err := p.Params()
+	progParams, err := p.Params()
 	if err != nil {
 		return err
 	}
 
-	program, err := p.getActiveProgram(codeHash, time, params)
+	program, err := p.getActiveProgram(codeHash, time, progParams)
 	if err != nil {
 		// The program is not active so return early
 		log.Info("program is not active, getActiveProgram returned error, hence do not include in rebuilding", "err", err)
@@ -43,9 +43,10 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash
 		return err
 	}
 
+	targets := statedb.Database().WasmTargets()
 	// If already in wasm store then return early
-	localAsm, err := statedb.TryGetActivatedAsm(moduleHash)
-	if err == nil && len(localAsm) > 0 {
+	_, err = statedb.TryGetActivatedAsmMap(targets, moduleHash)
+	if err == nil {
 		return nil
 	}
 
@@ -55,10 +56,13 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash
 		return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err)
 	}
 
-	unlimitedGas := uint64(0xffffffffffff)
+	// don't charge gas
+	zeroArbosVersion := uint64(0)
+	zeroGas := uint64(0)
+
 	// We know program is activated, so it must be in correct version and not use too much memory
 	// Empty program address is supplied because we dont have access to this during rebuilding of wasm store
-	info, asm, module, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, params.PageLimit, program.version, debugMode, &unlimitedGas)
+	info, asmMap, err := activateProgramInternal(statedb, common.Address{}, codeHash, wasm, progParams.PageLimit, program.version, zeroArbosVersion, debugMode, &zeroGas)
 	if err != nil {
 		log.Error("failed to reactivate program while rebuilding wasm store", "expected moduleHash", moduleHash, "err", err)
 		return fmt.Errorf("failed to reactivate program while rebuilding wasm store: %w", err)
@@ -70,7 +74,7 @@ func (p Programs) SaveActiveProgramToWasmStore(statedb *state.StateDB, codeHash
 	}
 
 	batch := statedb.Database().WasmStore().NewBatch()
-	rawdb.WriteActivation(batch, moduleHash, asm, module)
+	rawdb.WriteActivation(batch, moduleHash, asmMap)
 	if err := batch.Write(); err != nil {
 		log.Error("failed writing re-activation to state while rebuilding wasm store", "err", err)
 		return err
diff --git a/arbos/retryable_test.go b/arbos/retryable_test.go
index ddb8834..2eccaea 100644
--- a/arbos/retryable_test.go
+++ b/arbos/retryable_test.go
@@ -38,6 +38,7 @@ func TestRetryableLifecycle(t *testing.T) {
 	retryableState := state.RetryableState()
 
 	lifetime := uint64(retryables.RetryableLifetimeSeconds)
+	// #nosec G115
 	timestampAtCreation := uint64(rand.Int63n(1 << 16))
 	timeoutAtCreation := timestampAtCreation + lifetime
 	currentTime := timeoutAtCreation
@@ -57,6 +58,7 @@ func TestRetryableLifecycle(t *testing.T) {
 	checkQueueSize := func(expected int, message string) {
 		timeoutQueueSize, err := retryableState.TimeoutQueue.Size()
 		Require(t, err)
+		// #nosec G115
 		if timeoutQueueSize != uint64(expected) {
 			Fail(t, currentTime, message, timeoutQueueSize)
 		}
@@ -167,6 +169,7 @@ func TestRetryableCleanup(t *testing.T) {
 	callvalue := big.NewInt(0)
 	calldata := testhelpers.RandomizeSlice(make([]byte, rand.Intn(1<<12)))
 
+	// #nosec G115
 	timeout := uint64(rand.Int63n(1 << 16))
 	timestamp := 2 * timeout
 
diff --git a/arbos/retryables/retryable.go b/arbos/retryables/retryable.go
index e1cfe48..5938244 100644
--- a/arbos/retryables/retryable.go
+++ b/arbos/retryables/retryable.go
@@ -367,5 +367,7 @@ func RetryableEscrowAddress(ticketId common.Hash) common.Address {
 }
 
 func RetryableSubmissionFee(calldataLengthInBytes int, l1BaseFee *big.Int) *big.Int {
-	return arbmath.BigMulByUint(l1BaseFee, uint64(1400+6*calldataLengthInBytes))
+	// This can't overflow because calldataLengthInBytes would need to be 3 exabytes
+	// #nosec G115
+	return arbmath.BigMulByUint(l1BaseFee, 1400+6*uint64(calldataLengthInBytes))
 }
diff --git a/arbos/storage/storage.go b/arbos/storage/storage.go
index 6e6c976..bc16491 100644
--- a/arbos/storage/storage.go
+++ b/arbos/storage/storage.go
@@ -156,11 +156,6 @@ func (s *Storage) GetUint64ByUint64(key uint64) (uint64, error) {
 	return s.GetUint64(util.UintToHash(key))
 }
 
-func (s *Storage) GetUint32(key common.Hash) (uint32, error) {
-	value, err := s.Get(key)
-	return uint32(value.Big().Uint64()), err
-}
-
 func (s *Storage) Set(key common.Hash, value common.Hash) error {
 	if s.burner.ReadOnly() {
 		log.Error("Read-only burner attempted to mutate state", "key", key, "value", value)
@@ -327,11 +322,11 @@ func (s *Storage) Burner() burn.Burner {
 }
 
 func (s *Storage) Keccak(data ...[]byte) ([]byte, error) {
-	byteCount := 0
+	var byteCount uint64
 	for _, part := range data {
-		byteCount += len(part)
+		byteCount += uint64(len(part))
 	}
-	cost := 30 + 6*arbmath.WordsForBytes(uint64(byteCount))
+	cost := 30 + 6*arbmath.WordsForBytes(byteCount)
 	if err := s.burner.Burn(cost); err != nil {
 		return nil, err
 	}
@@ -420,10 +415,12 @@ func (sbu *StorageBackedInt64) Get() (int64, error) {
 	if !raw.Big().IsUint64() {
 		panic("invalid value found in StorageBackedInt64 storage")
 	}
+	// #nosec G115
 	return int64(raw.Big().Uint64()), err // see implementation note above
 }
 
 func (sbu *StorageBackedInt64) Set(value int64) error {
+	// #nosec G115
 	return sbu.StorageSlot.Set(util.UintToHash(uint64(value))) // see implementation note above
 }
 
@@ -460,7 +457,7 @@ func (sbu *StorageBackedUBips) Get() (arbmath.UBips, error) {
 }
 
 func (sbu *StorageBackedUBips) Set(bips arbmath.UBips) error {
-	return sbu.backing.Set(bips.Uint64())
+	return sbu.backing.Set(uint64(bips))
 }
 
 type StorageBackedUint16 struct {
@@ -477,6 +474,7 @@ func (sbu *StorageBackedUint16) Get() (uint16, error) {
 	if !big.IsUint64() || big.Uint64() > math.MaxUint16 {
 		panic("expected uint16 compatible value in storage")
 	}
+	// #nosec G115
 	return uint16(big.Uint64()), err
 }
 
@@ -517,6 +515,7 @@ func (sbu *StorageBackedUint32) Get() (uint32, error) {
 	if !big.IsUint64() || big.Uint64() > math.MaxUint32 {
 		panic("expected uint32 compatible value in storage")
 	}
+	// #nosec G115
 	return uint32(big.Uint64()), err
 }
 
diff --git a/arbos/tx_processor.go b/arbos/tx_processor.go
index b08c7c5..d6c3533 100644
--- a/arbos/tx_processor.go
+++ b/arbos/tx_processor.go
@@ -532,6 +532,20 @@ func (p *TxProcessor) EndTxHook(gasLeft uint64, success bool) {
 		refund := func(refundFrom common.Address, amount *big.Int) {
 			const errLog = "fee address doesn't have enough funds to give user refund"
 
+			logMissingRefund := func(err error) {
+				if !errors.Is(err, vm.ErrInsufficientBalance) {
+					log.Error("unexpected error refunding balance", "err", err, "feeAddress", refundFrom)
+					return
+				}
+				logLevel := log.Error
+				isContract := p.evm.StateDB.GetCodeSize(refundFrom) > 0
+				if isContract {
+					// It's expected that the balance might not still be in this address if it's a contract.
+					logLevel = log.Debug
+				}
+				logLevel(errLog, "err", err, "feeAddress", refundFrom)
+			}
+
 			// Refund funds to the fee refund address without overdrafting the L1 deposit.
 			toRefundAddr := takeFunds(maxRefund, amount)
 			err = util.TransferBalance(&refundFrom, &inner.RefundTo, toRefundAddr, p.evm, scenario, "refund")
@@ -539,13 +553,13 @@ func (p *TxProcessor) EndTxHook(gasLeft uint64, success bool) {
 				// Normally the network fee address should be holding any collected fees.
 				// However, in theory, they could've been transferred out during the redeem attempt.
 				// If the network fee address doesn't have the necessary balance, log an error and don't give a refund.
-				log.Error(errLog, "err", err, "feeAddress", refundFrom)
+				logMissingRefund(err)
 			}
 			// Any extra refund can't be given to the fee refund address if it didn't come from the L1 deposit.
 			// Instead, give the refund to the retryable from address.
 			err = util.TransferBalance(&refundFrom, &inner.From, arbmath.BigSub(amount, toRefundAddr), p.evm, scenario, "refund")
 			if err != nil {
-				log.Error(errLog, "err", err, "feeAddress", refundFrom)
+				logMissingRefund(err)
 			}
 		}
 
diff --git a/arbos/util/storage_cache.go b/arbos/util/storage_cache.go
index bf05a58..9573d1f 100644
--- a/arbos/util/storage_cache.go
+++ b/arbos/util/storage_cache.go
@@ -5,6 +5,7 @@ package util
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"slices"
 )
 
 type storageCacheEntry struct {
@@ -67,6 +68,10 @@ func (s *storageCache) Flush() []storageCacheStores {
 			})
 		}
 	}
+	sortFunc := func(a, b storageCacheStores) int {
+		return a.Key.Cmp(b.Key)
+	}
+	slices.SortFunc(stores, sortFunc)
 	return stores
 }
 
diff --git a/arbos/util/storage_cache_test.go b/arbos/util/storage_cache_test.go
index 1cc4ea1..9fd4528 100644
--- a/arbos/util/storage_cache_test.go
+++ b/arbos/util/storage_cache_test.go
@@ -4,7 +4,6 @@
 package util
 
 import (
-	"bytes"
 	"slices"
 	"testing"
 
@@ -76,7 +75,7 @@ func TestStorageCache(t *testing.T) {
 			{Key: keys[2], Value: values[2]},
 		}
 		sortFunc := func(a, b storageCacheStores) int {
-			return bytes.Compare(a.Key.Bytes(), b.Key.Bytes())
+			return a.Key.Cmp(b.Key)
 		}
 		slices.SortFunc(stores, sortFunc)
 		slices.SortFunc(expected, sortFunc)
diff --git a/arbstate/inbox.go b/arbstate/inbox.go
index 753ca19..b58a742 100644
--- a/arbstate/inbox.go
+++ b/arbstate/inbox.go
@@ -246,7 +246,7 @@ func (r *inboxMultiplexer) IsCachedSegementLast() bool {
 	if r.delayedMessagesRead < seqMsg.afterDelayedMessages {
 		return false
 	}
-	for segmentNum := int(r.cachedSegmentNum) + 1; segmentNum < len(seqMsg.segments); segmentNum++ {
+	for segmentNum := r.cachedSegmentNum + 1; segmentNum < uint64(len(seqMsg.segments)); segmentNum++ {
 		segment := seqMsg.segments[segmentNum]
 		if len(segment) == 0 {
 			continue
@@ -276,7 +276,7 @@ func (r *inboxMultiplexer) getNextMsg() (*arbostypes.MessageWithMetadata, error)
 		if segmentNum >= uint64(len(seqMsg.segments)) {
 			break
 		}
-		segment = seqMsg.segments[int(segmentNum)]
+		segment = seqMsg.segments[segmentNum]
 		if len(segment) == 0 {
 			segmentNum++
 			continue
@@ -322,7 +322,7 @@ func (r *inboxMultiplexer) getNextMsg() (*arbostypes.MessageWithMetadata, error)
 		log.Warn("reading virtual delayed message segment", "delayedMessagesRead", r.delayedMessagesRead, "afterDelayedMessages", seqMsg.afterDelayedMessages)
 		segment = []byte{BatchSegmentKindDelayedMessages}
 	} else {
-		segment = seqMsg.segments[int(segmentNum)]
+		segment = seqMsg.segments[segmentNum]
 	}
 	if len(segment) == 0 {
 		log.Error("empty sequencer message segment", "sequence", r.cachedSegmentNum, "segmentNum", segmentNum)
diff --git a/arbutil/block_message_relation.go b/arbutil/block_message_relation.go
index a69f907..dcf4c86 100644
--- a/arbutil/block_message_relation.go
+++ b/arbutil/block_message_relation.go
@@ -11,9 +11,11 @@ func BlockNumberToMessageCount(blockNumber uint64, genesisBlockNumber uint64) Me
 
 // Block number must correspond to a message count, meaning it may not be less than -1
 func SignedBlockNumberToMessageCount(blockNumber int64, genesisBlockNumber uint64) MessageIndex {
+	// #nosec G115
 	return MessageIndex(uint64(blockNumber+1) - genesisBlockNumber)
 }
 
 func MessageCountToBlockNumber(messageCount MessageIndex, genesisBlockNumber uint64) int64 {
+	// #nosec G115
 	return int64(uint64(messageCount)+genesisBlockNumber) - 1
 }
diff --git a/arbutil/correspondingl1blocknumber.go b/arbutil/correspondingl1blocknumber.go
index 05323ed..c8770e2 100644
--- a/arbutil/correspondingl1blocknumber.go
+++ b/arbutil/correspondingl1blocknumber.go
@@ -19,7 +19,12 @@ func ParentHeaderToL1BlockNumber(header *types.Header) uint64 {
 	return header.Number.Uint64()
 }
 
-func CorrespondingL1BlockNumber(ctx context.Context, client L1Interface, parentBlockNumber uint64) (uint64, error) {
+type ParentHeaderFetcher interface {
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+}
+
+func CorrespondingL1BlockNumber(ctx context.Context, client ParentHeaderFetcher, parentBlockNumber uint64) (uint64, error) {
+	// #nosec G115
 	header, err := client.HeaderByNumber(ctx, big.NewInt(int64(parentBlockNumber)))
 	if err != nil {
 		return 0, fmt.Errorf("error getting L1 block number %d header : %w", parentBlockNumber, err)
diff --git a/arbutil/transaction_data.go b/arbutil/transaction_data.go
index 8270a62..c572896 100644
--- a/arbutil/transaction_data.go
+++ b/arbutil/transaction_data.go
@@ -8,9 +8,10 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-func GetLogTransaction(ctx context.Context, client L1Interface, log types.Log) (*types.Transaction, error) {
+func GetLogTransaction(ctx context.Context, client *ethclient.Client, log types.Log) (*types.Transaction, error) {
 	tx, err := client.TransactionInBlock(ctx, log.BlockHash, log.TxIndex)
 	if err != nil {
 		return nil, err
@@ -22,7 +23,7 @@ func GetLogTransaction(ctx context.Context, client L1Interface, log types.Log) (
 }
 
 // GetLogEmitterTxData requires that the tx's data is at least 4 bytes long
-func GetLogEmitterTxData(ctx context.Context, client L1Interface, log types.Log) ([]byte, error) {
+func GetLogEmitterTxData(ctx context.Context, client *ethclient.Client, log types.Log) ([]byte, error) {
 	tx, err := GetLogTransaction(ctx, client, log)
 	if err != nil {
 		return nil, err
diff --git a/arbutil/wait_for_l1.go b/arbutil/wait_for_l1.go
index 4b48191..80dd356 100644
--- a/arbutil/wait_for_l1.go
+++ b/arbutil/wait_for_l1.go
@@ -10,27 +10,13 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-type L1Interface interface {
-	bind.ContractBackend
-	bind.BlockHashContractCaller
-	ethereum.ChainReader
-	ethereum.ChainStateReader
-	ethereum.TransactionReader
-	TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error)
-	BlockNumber(ctx context.Context) (uint64, error)
-	PendingCallContract(ctx context.Context, msg ethereum.CallMsg) ([]byte, error)
-	ChainID(ctx context.Context) (*big.Int, error)
-	Client() rpc.ClientInterface
-}
-
-func SendTxAsCall(ctx context.Context, client L1Interface, tx *types.Transaction, from common.Address, blockNum *big.Int, unlimitedGas bool) ([]byte, error) {
+func SendTxAsCall(ctx context.Context, client *ethclient.Client, tx *types.Transaction, from common.Address, blockNum *big.Int, unlimitedGas bool) ([]byte, error) {
 	var gas uint64
 	if unlimitedGas {
 		gas = 0
@@ -50,7 +36,7 @@ func SendTxAsCall(ctx context.Context, client L1Interface, tx *types.Transaction
 	return client.CallContract(ctx, callMsg, blockNum)
 }
 
-func GetPendingCallBlockNumber(ctx context.Context, client L1Interface) (*big.Int, error) {
+func GetPendingCallBlockNumber(ctx context.Context, client *ethclient.Client) (*big.Int, error) {
 	msg := ethereum.CallMsg{
 		// Pretend to be a contract deployment to execute EVM code without calling a contract.
 		To: nil,
@@ -70,7 +56,7 @@ func GetPendingCallBlockNumber(ctx context.Context, client L1Interface) (*big.In
 	return new(big.Int).SetBytes(callRes), nil
 }
 
-func DetailTxError(ctx context.Context, client L1Interface, tx *types.Transaction, txRes *types.Receipt) error {
+func DetailTxError(ctx context.Context, client *ethclient.Client, tx *types.Transaction, txRes *types.Receipt) error {
 	// Re-execute the transaction as a call to get a better error
 	if ctx.Err() != nil {
 		return ctx.Err()
@@ -96,7 +82,7 @@ func DetailTxError(ctx context.Context, client L1Interface, tx *types.Transactio
 	return fmt.Errorf("SendTxAsCall got: %w for tx hash %v", err, tx.Hash())
 }
 
-func DetailTxErrorUsingCallMsg(ctx context.Context, client L1Interface, txHash common.Hash, txRes *types.Receipt, callMsg ethereum.CallMsg) error {
+func DetailTxErrorUsingCallMsg(ctx context.Context, client *ethclient.Client, txHash common.Hash, txRes *types.Receipt, callMsg ethereum.CallMsg) error {
 	// Re-execute the transaction as a call to get a better error
 	if ctx.Err() != nil {
 		return ctx.Err()
diff --git a/blocks_reexecutor/blocks_reexecutor.go b/blocks_reexecutor/blocks_reexecutor.go
index 1e4a06f..b43999a 100644
--- a/blocks_reexecutor/blocks_reexecutor.go
+++ b/blocks_reexecutor/blocks_reexecutor.go
@@ -102,7 +102,8 @@ func New(c *Config, blockchain *core.BlockChain, fatalErrChan chan error) *Block
 		if rng > end-start {
 			rng = end - start
 		}
-		start += uint64(rand.Intn(int(end - start - rng + 1)))
+		// #nosec G115
+		start += uint64(rand.Int63n(int64(end - start - rng + 1)))
 		end = start + rng
 	}
 	// Inclusive of block reexecution [start, end]
@@ -112,6 +113,7 @@ func New(c *Config, blockchain *core.BlockChain, fatalErrChan chan error) *Block
 	}
 	// Divide work equally among available threads when BlocksPerThread is zero
 	if c.BlocksPerThread == 0 {
+		// #nosec G115
 		work := (end - start) / uint64(c.Room)
 		if work > 0 {
 			blocksPerThread = work
diff --git a/broadcastclient/broadcastclient_test.go b/broadcastclient/broadcastclient_test.go
index 44b4819..a499628 100644
--- a/broadcastclient/broadcastclient_test.go
+++ b/broadcastclient/broadcastclient_test.go
@@ -105,6 +105,7 @@ func testReceiveMessages(t *testing.T, clientCompression bool, serverCompression
 
 	go func() {
 		for i := 0; i < messageCount; i++ {
+			// #nosec G115
 			Require(t, b.BroadcastSingle(arbostypes.TestMessageWithMetadataAndRequestId, arbutil.MessageIndex(i), nil))
 		}
 	}()
@@ -156,6 +157,7 @@ func TestInvalidSignature(t *testing.T) {
 
 	go func() {
 		for i := 0; i < messageCount; i++ {
+			// #nosec G115
 			Require(t, b.BroadcastSingle(arbostypes.TestMessageWithMetadataAndRequestId, arbutil.MessageIndex(i), nil))
 		}
 	}()
diff --git a/broadcaster/backlog/backlog.go b/broadcaster/backlog/backlog.go
index f650110..b7b935f 100644
--- a/broadcaster/backlog/backlog.go
+++ b/broadcaster/backlog/backlog.go
@@ -97,6 +97,7 @@ func (b *backlog) Append(bm *m.BroadcastMessage) error {
 		if err != nil {
 			log.Warn("error calculating backlogSizeInBytes", "err", err)
 		} else {
+			// #nosec G115
 			backlogSizeInBytesGauge.Update(int64(size))
 		}
 	}
@@ -108,6 +109,7 @@ func (b *backlog) Append(bm *m.BroadcastMessage) error {
 			segment = newBacklogSegment()
 			b.head.Store(segment)
 			b.tail.Store(segment)
+			// #nosec G115
 			confirmedSequenceNumberGauge.Update(int64(msg.SequenceNumber))
 		}
 
@@ -143,9 +145,11 @@ func (b *backlog) Append(bm *m.BroadcastMessage) error {
 		}
 		lookupByIndex.Store(uint64(msg.SequenceNumber), segment)
 		b.messageCount.Add(1)
+		// #nosec G115
 		backlogSizeInBytesGauge.Inc(int64(msg.Size()))
 	}
 
+	// #nosec G115
 	backlogSizeGauge.Update(int64(b.Count()))
 	return nil
 }
@@ -174,7 +178,7 @@ func (b *backlog) Get(start, end uint64) (*m.BroadcastMessage, error) {
 	}
 
 	bm := &m.BroadcastMessage{Version: 1}
-	required := int(end-start) + 1
+	required := end - start + 1
 	for {
 		segMsgs, err := segment.Get(arbmath.MaxInt(start, segment.Start()), arbmath.MinInt(end, segment.End()))
 		if err != nil {
@@ -183,7 +187,7 @@ func (b *backlog) Get(start, end uint64) (*m.BroadcastMessage, error) {
 
 		bm.Messages = append(bm.Messages, segMsgs...)
 		segment = segment.Next()
-		if len(bm.Messages) == required {
+		if uint64(len(bm.Messages)) == required {
 			break
 		} else if segment == nil {
 			return nil, errOutOfBounds
@@ -213,6 +217,7 @@ func (b *backlog) delete(confirmed uint64) {
 		return
 	}
 
+	// #nosec G115
 	confirmedSequenceNumberGauge.Update(int64(confirmed))
 
 	// find the segment containing the confirmed message
diff --git a/broadcaster/backlog/backlog_test.go b/broadcaster/backlog/backlog_test.go
index ee712de..d74389f 100644
--- a/broadcaster/backlog/backlog_test.go
+++ b/broadcaster/backlog/backlog_test.go
@@ -33,8 +33,8 @@ func validateBacklog(t *testing.T, b *backlog, count, start, end uint64, lookupK
 		}
 	}
 
-	expLen := len(lookupKeys)
-	actualLen := int(b.Count())
+	expLen := uint64(len(lookupKeys))
+	actualLen := b.Count()
 	if expLen != actualLen {
 		t.Errorf("expected length of lookupByIndex map (%d) does not equal actual length (%d)", expLen, actualLen)
 	}
diff --git a/broadcaster/broadcaster.go b/broadcaster/broadcaster.go
index ba95f2d..4fe8657 100644
--- a/broadcaster/broadcaster.go
+++ b/broadcaster/broadcaster.go
@@ -104,6 +104,7 @@ func (b *Broadcaster) BroadcastMessages(
 	}()
 	var feedMessages []*m.BroadcastFeedMessage
 	for i, msg := range messagesWithBlockHash {
+		// #nosec G115
 		bfm, err := b.NewBroadcastFeedMessage(msg.MessageWithMeta, seq+arbutil.MessageIndex(i), msg.BlockHash)
 		if err != nil {
 			return err
@@ -145,6 +146,7 @@ func (b *Broadcaster) ListenerAddr() net.Addr {
 }
 
 func (b *Broadcaster) GetCachedMessageCount() int {
+	// #nosec G115
 	return int(b.backlog.Count())
 }
 
diff --git a/broadcaster/message/message.go b/broadcaster/message/message.go
index aca9598..1e26e6d 100644
--- a/broadcaster/message/message.go
+++ b/broadcaster/message/message.go
@@ -41,6 +41,7 @@ type BroadcastFeedMessage struct {
 }
 
 func (m *BroadcastFeedMessage) Size() uint64 {
+	// #nosec G115
 	return uint64(len(m.Signature) + len(m.Message.Message.L2msg) + 160)
 }
 
diff --git a/cmd/chaininfo/arbitrum_chain_info.json b/cmd/chaininfo/arbitrum_chain_info.json
index 524433a..f862c6d 100644
--- a/cmd/chaininfo/arbitrum_chain_info.json
+++ b/cmd/chaininfo/arbitrum_chain_info.json
@@ -164,7 +164,7 @@
         "EnableArbOS": true,
         "AllowDebugPrecompiles": true,
         "DataAvailabilityCommittee": false,
-        "InitialArbOSVersion": 31,
+        "InitialArbOSVersion": 32,
         "InitialChainOwner": "0x0000000000000000000000000000000000000000",
         "GenesisBlockNum": 0
       }
@@ -196,7 +196,7 @@
         "EnableArbOS": true,
         "AllowDebugPrecompiles": true,
         "DataAvailabilityCommittee": true,
-        "InitialArbOSVersion": 31,
+        "InitialArbOSVersion": 32,
         "InitialChainOwner": "0x0000000000000000000000000000000000000000",
         "GenesisBlockNum": 0
       }
diff --git a/cmd/conf/init.go b/cmd/conf/init.go
index d88bcdd..f01d99f 100644
--- a/cmd/conf/init.go
+++ b/cmd/conf/init.go
@@ -22,6 +22,7 @@ type InitConfig struct {
 	DevInitAddress           string        `koanf:"dev-init-address"`
 	DevInitBlockNum          uint64        `koanf:"dev-init-blocknum"`
 	Empty                    bool          `koanf:"empty"`
+	ImportWasm               bool          `koanf:"import-wasm"`
 	AccountsPerSync          uint          `koanf:"accounts-per-sync"`
 	ImportFile               string        `koanf:"import-file"`
 	ThenQuit                 bool          `koanf:"then-quit"`
@@ -30,7 +31,7 @@ type InitConfig struct {
 	PruneThreads             int           `koanf:"prune-threads"`
 	PruneTrieCleanCache      int           `koanf:"prune-trie-clean-cache"`
 	RecreateMissingStateFrom uint64        `koanf:"recreate-missing-state-from"`
-	RebuildLocalWasm         bool          `koanf:"rebuild-local-wasm"`
+	RebuildLocalWasm         string        `koanf:"rebuild-local-wasm"`
 	ReorgToBatch             int64         `koanf:"reorg-to-batch"`
 	ReorgToMessageBatch      int64         `koanf:"reorg-to-message-batch"`
 	ReorgToBlockBatch        int64         `koanf:"reorg-to-block-batch"`
@@ -48,6 +49,7 @@ var InitConfigDefault = InitConfig{
 	DevInitAddress:           "",
 	DevInitBlockNum:          0,
 	Empty:                    false,
+	ImportWasm:               false,
 	ImportFile:               "",
 	AccountsPerSync:          100000,
 	ThenQuit:                 false,
@@ -56,7 +58,7 @@ var InitConfigDefault = InitConfig{
 	PruneThreads:             runtime.NumCPU(),
 	PruneTrieCleanCache:      600,
 	RecreateMissingStateFrom: 0, // 0 = disabled
-	RebuildLocalWasm:         true,
+	RebuildLocalWasm:         "auto",
 	ReorgToBatch:             -1,
 	ReorgToMessageBatch:      -1,
 	ReorgToBlockBatch:        -1,
@@ -74,6 +76,7 @@ func InitConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.String(prefix+".dev-init-address", InitConfigDefault.DevInitAddress, "Address of dev-account. Leave empty to use the dev-wallet.")
 	f.Uint64(prefix+".dev-init-blocknum", InitConfigDefault.DevInitBlockNum, "Number of preinit blocks. Must exist in ancient database.")
 	f.Bool(prefix+".empty", InitConfigDefault.Empty, "init with empty state")
+	f.Bool(prefix+".import-wasm", InitConfigDefault.ImportWasm, "if set, import the wasm directory when downloading a database (contains executable code - only use with highly trusted source)")
 	f.Bool(prefix+".then-quit", InitConfigDefault.ThenQuit, "quit after init is done")
 	f.String(prefix+".import-file", InitConfigDefault.ImportFile, "path for json data to import")
 	f.Uint(prefix+".accounts-per-sync", InitConfigDefault.AccountsPerSync, "during init - sync database every X accounts. Lower value for low-memory systems. 0 disables.")
@@ -82,10 +85,14 @@ func InitConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.Int(prefix+".prune-threads", InitConfigDefault.PruneThreads, "the number of threads to use when pruning")
 	f.Int(prefix+".prune-trie-clean-cache", InitConfigDefault.PruneTrieCleanCache, "amount of memory in megabytes to cache unchanged state trie nodes with when traversing state database during pruning")
 	f.Uint64(prefix+".recreate-missing-state-from", InitConfigDefault.RecreateMissingStateFrom, "block number to start recreating missing states from (0 = disabled)")
-	f.Bool(prefix+".rebuild-local-wasm", InitConfigDefault.RebuildLocalWasm, "rebuild local wasm database on boot if needed (otherwise-will be done lazily)")
 	f.Int64(prefix+".reorg-to-batch", InitConfigDefault.ReorgToBatch, "rolls back the blockchain to a specified batch number")
 	f.Int64(prefix+".reorg-to-message-batch", InitConfigDefault.ReorgToMessageBatch, "rolls back the blockchain to the first batch at or before a given message index")
 	f.Int64(prefix+".reorg-to-block-batch", InitConfigDefault.ReorgToBlockBatch, "rolls back the blockchain to the first batch at or before a given block number")
+	f.String(prefix+".rebuild-local-wasm", InitConfigDefault.RebuildLocalWasm, "rebuild local wasm database on boot if needed (otherwise-will be done lazily). Three modes are supported \n"+
+		"\"auto\"- (enabled by default) if any previous rebuilding attempt was successful then rebuilding is disabled else continues to rebuild,\n"+
+		"\"force\"- force rebuilding which would commence rebuilding despite the status of previous attempts,\n"+
+		"\"false\"- do not rebuild on startup",
+	)
 }
 
 func (c *InitConfig) Validate() error {
@@ -110,6 +117,10 @@ func (c *InitConfig) Validate() error {
 			}
 		}
 	}
+	c.RebuildLocalWasm = strings.ToLower(c.RebuildLocalWasm)
+	if c.RebuildLocalWasm != "auto" && c.RebuildLocalWasm != "force" && c.RebuildLocalWasm != "false" {
+		return fmt.Errorf("invalid value of rebuild-local-wasm, want: auto or force or false, got: %s", c.RebuildLocalWasm)
+	}
 	return nil
 }
 
diff --git a/cmd/datool/datool.go b/cmd/datool/datool.go
index ba60cbb..f791d8c 100644
--- a/cmd/datool/datool.go
+++ b/cmd/datool/datool.go
@@ -166,8 +166,10 @@ func startClientStore(args []string) error {
 		if err != nil {
 			return err
 		}
+		// #nosec G115
 		cert, err = client.Store(ctx, message, uint64(time.Now().Add(config.DASRetentionPeriod).Unix()))
 	} else if len(config.Message) > 0 {
+		// #nosec G115
 		cert, err = client.Store(ctx, []byte(config.Message), uint64(time.Now().Add(config.DASRetentionPeriod).Unix()))
 	} else {
 		return errors.New("--message or --random-message-size must be specified")
@@ -363,6 +365,7 @@ func dumpKeyset(args []string) error {
 		return err
 	}
 
+	// #nosec G115
 	keysetHash, keysetBytes, err := das.KeysetHashFromServices(services, uint64(config.Keyset.AssumedHonest))
 	if err != nil {
 		return err
diff --git a/cmd/dbconv/dbconv/config.go b/cmd/dbconv/dbconv/config.go
index 74623bc..917f342 100644
--- a/cmd/dbconv/dbconv/config.go
+++ b/cmd/dbconv/dbconv/config.go
@@ -71,7 +71,7 @@ var DefaultDBConvConfig = DBConvConfig{
 func DBConvConfigAddOptions(f *flag.FlagSet) {
 	DBConfigAddOptions("src", f, &DefaultDBConvConfig.Src)
 	DBConfigAddOptions("dst", f, &DefaultDBConvConfig.Dst)
-	f.Int("ideal-batch-size", DefaultDBConvConfig.IdealBatchSize, "ideal write batch size")
+	f.Int("ideal-batch-size", DefaultDBConvConfig.IdealBatchSize, "ideal write batch size in bytes")
 	f.Bool("convert", DefaultDBConvConfig.Convert, "enables conversion step")
 	f.Bool("compact", DefaultDBConvConfig.Compact, "enables compaction step")
 	f.String("verify", DefaultDBConvConfig.Verify, "enables verification step (\"\" = disabled, \"keys\" = only keys, \"full\" = keys and values)")
diff --git a/cmd/dbconv/dbconv/dbconv_test.go b/cmd/dbconv/dbconv/dbconv_test.go
index f31dd68..31aa0c3 100644
--- a/cmd/dbconv/dbconv/dbconv_test.go
+++ b/cmd/dbconv/dbconv/dbconv_test.go
@@ -4,12 +4,10 @@ import (
 	"context"
 	"testing"
 
-	"github.com/ethereum/go-ethereum/log"
 	"github.com/offchainlabs/nitro/util/testhelpers"
 )
 
 func TestConversion(t *testing.T) {
-	_ = testhelpers.InitTestLog(t, log.LvlTrace)
 	oldDBConfig := DBConfigDefaultSrc
 	oldDBConfig.Data = t.TempDir()
 
diff --git a/cmd/dbconv/main.go b/cmd/dbconv/main.go
index c0b5c8f..2d61c96 100644
--- a/cmd/dbconv/main.go
+++ b/cmd/dbconv/main.go
@@ -85,7 +85,7 @@ func main() {
 			os.Exit(1)
 		}
 		stats := conv.Stats()
-		log.Info("Conversion finished.", "entries", stats.Entries(), "MB", stats.Bytes()/1024/1024, "avg Ke/s", stats.AverageEntriesPerSecond()/1000, "avg MB/s", stats.AverageBytesPerSecond()/1024/1024, "elapsed", stats.Elapsed())
+		log.Info("Conversion finished.", "entries", stats.Entries(), "MB", stats.Bytes()/1024/1024, "avg entries/s", fmt.Sprintf("%.3e", stats.AverageEntriesPerSecond()/1000), "avg MB/s", stats.AverageBytesPerSecond()/1024/1024, "elapsed", stats.Elapsed())
 	}
 
 	if config.Compact {
diff --git a/cmd/deploy/deploy.go b/cmd/deploy/deploy.go
index d8c0aee..c70ceb1 100644
--- a/cmd/deploy/deploy.go
+++ b/cmd/deploy/deploy.go
@@ -61,7 +61,6 @@ func main() {
 	authorizevalidators := flag.Uint64("authorizevalidators", 0, "Number of validators to preemptively authorize")
 	txTimeout := flag.Duration("txtimeout", 10*time.Minute, "Timeout when waiting for a transaction to be included in a block")
 	prod := flag.Bool("prod", false, "Whether to configure the rollup for production or testing")
-	isUsingFeeToken := flag.Bool("isUsingFeeToken", false, "true if the chain uses custom fee token")
 	flag.Parse()
 	l1ChainId := new(big.Int).SetUint64(*l1ChainIdUint)
 	maxDataSize := new(big.Int).SetUint64(*maxDataSizeUint)
@@ -180,7 +179,7 @@ func main() {
 	defer l1Reader.StopAndWait()
 
 	nativeToken := common.HexToAddress(*nativeTokenAddressString)
-	deployedAddresses, err := deploycode.DeployOnL1(
+	deployedAddresses, err := deploycode.DeployOnParentChain(
 		ctx,
 		l1Reader,
 		l1TransactionOpts,
@@ -190,7 +189,7 @@ func main() {
 		arbnode.GenerateRollupConfig(*prod, moduleRoot, ownerAddress, &chainConfig, chainConfigJson, loserEscrowAddress),
 		nativeToken,
 		maxDataSize,
-		*isUsingFeeToken,
+		true,
 	)
 	if err != nil {
 		flag.Usage()
diff --git a/cmd/nitro/init.go b/cmd/nitro/init.go
index c364da5..9e3ecec 100644
--- a/cmd/nitro/init.go
+++ b/cmd/nitro/init.go
@@ -24,11 +24,12 @@ import (
 	"time"
 
 	"github.com/cavaliergopher/grab/v3"
-	extract "github.com/codeclysm/extract/v3"
+	"github.com/codeclysm/extract/v3"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -37,7 +38,6 @@ import (
 	"github.com/offchainlabs/nitro/arbnode"
 	"github.com/offchainlabs/nitro/arbos/arbosState"
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/conf"
 	"github.com/offchainlabs/nitro/cmd/ipfshelper"
@@ -301,6 +301,7 @@ func setLatestSnapshotUrl(ctx context.Context, initConfig *conf.InitConfig, chai
 		return fmt.Errorf("failed to parse latest mirror \"%s\": %w", initConfig.LatestBase, err)
 	}
 	latestFileUrl := baseUrl.JoinPath(chain, "latest-"+initConfig.Latest+".txt").String()
+	latestFileUrl = strings.ToLower(latestFileUrl)
 	latestFileBytes, err := httpGet(ctx, latestFileUrl)
 	if err != nil {
 		return fmt.Errorf("failed to get latest file at \"%s\": %w", latestFileUrl, err)
@@ -312,6 +313,7 @@ func setLatestSnapshotUrl(ctx context.Context, initConfig *conf.InitConfig, chai
 	} else {
 		initConfig.Url = baseUrl.JoinPath(latestFile).String()
 	}
+	initConfig.Url = strings.ToLower(initConfig.Url)
 	log.Info("Set latest snapshot url", "url", initConfig.Url)
 	return nil
 }
@@ -352,12 +354,12 @@ func validateBlockChain(blockChain *core.BlockChain, chainConfig *params.ChainCo
 	}
 	// Make sure we don't allow accidentally downgrading ArbOS
 	if chainConfig.DebugMode() {
-		if currentArbosState.ArbOSVersion() > currentArbosState.MaxDebugArbosVersionSupported() {
-			return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxDebugArbosVersionSupported(), currentArbosState.ArbOSVersion())
+		if currentArbosState.ArbOSVersion() > arbosState.MaxDebugArbosVersionSupported {
+			return fmt.Errorf("attempted to launch node in debug mode with ArbOS version %v on ArbOS state with version %v", arbosState.MaxDebugArbosVersionSupported, currentArbosState.ArbOSVersion())
 		}
 	} else {
-		if currentArbosState.ArbOSVersion() > currentArbosState.MaxArbosVersionSupported() {
-			return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", currentArbosState.MaxArbosVersionSupported(), currentArbosState.ArbOSVersion())
+		if currentArbosState.ArbOSVersion() > arbosState.MaxArbosVersionSupported {
+			return fmt.Errorf("attempted to launch node with ArbOS version %v on ArbOS state with version %v", arbosState.MaxArbosVersionSupported, currentArbosState.ArbOSVersion())
 		}
 
 	}
@@ -397,7 +399,168 @@ func checkEmptyDatabaseDir(dir string, force bool) error {
 	return nil
 }
 
-func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeConfig, chainId *big.Int, cacheConfig *core.CacheConfig, persistentConfig *conf.PersistentConfig, l1Client arbutil.L1Interface, rollupAddrs chaininfo.RollupAddresses) (ethdb.Database, *core.BlockChain, error) {
+func databaseIsEmpty(db ethdb.Database) bool {
+	it := db.NewIterator(nil, nil)
+	defer it.Release()
+	return !it.Next()
+}
+
+func isWasmDb(path string) bool {
+	path = strings.ToLower(path) // lowers the path to handle case-insensitive file systems
+	path = filepath.Clean(path)
+	parts := strings.Split(path, string(filepath.Separator))
+	if len(parts) >= 1 && parts[0] == "wasm" {
+		return true
+	}
+	if len(parts) >= 2 && parts[0] == "" && parts[1] == "wasm" { // Cover "/wasm" case
+		return true
+	}
+	return false
+}
+
+func extractSnapshot(archive string, location string, importWasm bool) error {
+	reader, err := os.Open(archive)
+	if err != nil {
+		return fmt.Errorf("couln't open init '%v' archive: %w", archive, err)
+	}
+	defer reader.Close()
+	stat, err := reader.Stat()
+	if err != nil {
+		return err
+	}
+	log.Info("extracting downloaded init archive", "size", fmt.Sprintf("%dMB", stat.Size()/1024/1024))
+	var rename extract.Renamer
+	if !importWasm {
+		rename = func(path string) string {
+			if isWasmDb(path) {
+				return "" // do not extract wasm files
+			}
+			return path
+		}
+	}
+	err = extract.Archive(context.Background(), reader, location, rename)
+	if err != nil {
+		return fmt.Errorf("couln't extract init archive '%v' err: %w", archive, err)
+	}
+	return nil
+}
+
+// removes all entries with keys prefixed with prefixes and of length used in initial version of wasm store schema
+func purgeVersion0WasmStoreEntries(db ethdb.Database) error {
+	prefixes, keyLength := rawdb.DeprecatedPrefixesV0()
+	batch := db.NewBatch()
+	notMatchingLengthKeyLogged := false
+	for _, prefix := range prefixes {
+		it := db.NewIterator(prefix, nil)
+		defer it.Release()
+		for it.Next() {
+			key := it.Key()
+			if len(key) != keyLength {
+				if !notMatchingLengthKeyLogged {
+					log.Warn("Found key with deprecated prefix but not matching length, skipping removal. (this warning is logged only once)", "key", key)
+					notMatchingLengthKeyLogged = true
+				}
+				continue
+			}
+			if err := batch.Delete(key); err != nil {
+				return fmt.Errorf("Failed to remove key %v : %w", key, err)
+			}
+
+			// Recreate the iterator after every batch commit in order
+			// to allow the underlying compactor to delete the entries.
+			if batch.ValueSize() >= ethdb.IdealBatchSize {
+				if err := batch.Write(); err != nil {
+					return fmt.Errorf("Failed to write batch: %w", err)
+				}
+				batch.Reset()
+				it.Release()
+				it = db.NewIterator(prefix, key)
+			}
+		}
+	}
+	if batch.ValueSize() > 0 {
+		if err := batch.Write(); err != nil {
+			return fmt.Errorf("Failed to write batch: %w", err)
+		}
+		batch.Reset()
+	}
+	return nil
+}
+
+// if db is not empty, validates if wasm database schema version matches current version
+// otherwise persists current version
+func validateOrUpgradeWasmStoreSchemaVersion(db ethdb.Database) error {
+	if !databaseIsEmpty(db) {
+		version, err := rawdb.ReadWasmSchemaVersion(db)
+		if err != nil {
+			if dbutil.IsErrNotFound(err) {
+				version = []byte{0}
+			} else {
+				return fmt.Errorf("Failed to retrieve wasm schema version: %w", err)
+			}
+		}
+		if len(version) != 1 || version[0] > rawdb.WasmSchemaVersion {
+			return fmt.Errorf("Unsupported wasm database schema version, current version: %v, read from wasm database: %v", rawdb.WasmSchemaVersion, version)
+		}
+		// special step for upgrading from version 0 - remove all entries added in version 0
+		if version[0] == 0 {
+			log.Warn("Detected wasm store schema version 0 - removing all old wasm store entries")
+			if err := purgeVersion0WasmStoreEntries(db); err != nil {
+				return fmt.Errorf("Failed to purge wasm store version 0 entries: %w", err)
+			}
+			log.Info("Wasm store schama version 0 entries successfully removed.")
+		}
+	}
+	rawdb.WriteWasmSchemaVersion(db)
+	return nil
+}
+
+func rebuildLocalWasm(ctx context.Context, config *gethexec.Config, l2BlockChain *core.BlockChain, chainDb, wasmDb ethdb.Database, rebuildMode string) (ethdb.Database, *core.BlockChain, error) {
+	var err error
+	latestBlock := l2BlockChain.CurrentBlock()
+	if latestBlock == nil || latestBlock.Number.Uint64() <= l2BlockChain.Config().ArbitrumChainParams.GenesisBlockNum ||
+		types.DeserializeHeaderExtraInformation(latestBlock).ArbOSFormatVersion < params.ArbosVersion_Stylus {
+		// If there is only genesis block or no blocks in the blockchain, set Rebuilding of wasm store to Done
+		// If Stylus upgrade hasn't yet happened, skipping rebuilding of wasm store
+		log.Info("Setting rebuilding of wasm store to done")
+		if err = gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingPositionKey, gethexec.RebuildingDone); err != nil {
+			return nil, nil, fmt.Errorf("unable to set rebuilding status of wasm store to done: %w", err)
+		}
+	} else if rebuildMode != "false" {
+		var position common.Hash
+		if rebuildMode == "force" {
+			log.Info("Commencing force rebuilding of wasm store by setting codehash position in rebuilding to beginning")
+			if err := gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingPositionKey, common.Hash{}); err != nil {
+				return nil, nil, fmt.Errorf("unable to initialize codehash position in rebuilding of wasm store to beginning: %w", err)
+			}
+		} else {
+			position, err = gethexec.ReadFromKeyValueStore[common.Hash](wasmDb, gethexec.RebuildingPositionKey)
+			if err != nil {
+				log.Info("Unable to get codehash position in rebuilding of wasm store, its possible it isnt initialized yet, so initializing it and starting rebuilding", "err", err)
+				if err := gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingPositionKey, common.Hash{}); err != nil {
+					return nil, nil, fmt.Errorf("unable to initialize codehash position in rebuilding of wasm store to beginning: %w", err)
+				}
+			}
+		}
+		if position != gethexec.RebuildingDone {
+			startBlockHash, err := gethexec.ReadFromKeyValueStore[common.Hash](wasmDb, gethexec.RebuildingStartBlockHashKey)
+			if err != nil {
+				log.Info("Unable to get start block hash in rebuilding of wasm store, its possible it isnt initialized yet, so initializing it to latest block hash", "err", err)
+				if err := gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingStartBlockHashKey, latestBlock.Hash()); err != nil {
+					return nil, nil, fmt.Errorf("unable to initialize start block hash in rebuilding of wasm store to latest block hash: %w", err)
+				}
+				startBlockHash = latestBlock.Hash()
+			}
+			log.Info("Starting or continuing rebuilding of wasm store", "codeHash", position, "startBlockHash", startBlockHash)
+			if err := gethexec.RebuildWasmStore(ctx, wasmDb, chainDb, config.RPC.MaxRecreateStateDepth, &config.StylusTarget, l2BlockChain, position, startBlockHash); err != nil {
+				return nil, nil, fmt.Errorf("error rebuilding of wasm store: %w", err)
+			}
+		}
+	}
+	return chainDb, l2BlockChain, nil
+}
+
+func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeConfig, chainId *big.Int, cacheConfig *core.CacheConfig, targetConfig *gethexec.StylusTargetConfig, persistentConfig *conf.PersistentConfig, l1Client *ethclient.Client, rollupAddrs chaininfo.RollupAddresses) (ethdb.Database, *core.BlockChain, error) {
 	if !config.Init.Force {
 		if readOnlyDb, err := stack.OpenDatabaseWithFreezerWithExtraOptions("l2chaindata", 0, 0, config.Persistent.Ancient, "l2chaindata/", true, persistentConfig.Pebble.ExtraOptions("l2chaindata")); err == nil {
 			if chainConfig := gethexec.TryReadStoredChainConfig(readOnlyDb); chainConfig != nil {
@@ -416,10 +579,13 @@ func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeCo
 				if err != nil {
 					return nil, nil, err
 				}
+				if err := validateOrUpgradeWasmStoreSchemaVersion(wasmDb); err != nil {
+					return nil, nil, err
+				}
 				if err := dbutil.UnfinishedConversionCheck(wasmDb); err != nil {
 					return nil, nil, fmt.Errorf("wasm unfinished database conversion check error: %w", err)
 				}
-				chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmDb, 1)
+				chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmDb, 1, targetConfig.WasmTargets())
 				_, err = rawdb.ParseStateScheme(cacheConfig.StateScheme, chainDb)
 				if err != nil {
 					return nil, nil, err
@@ -442,39 +608,7 @@ func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeCo
 						return chainDb, l2BlockChain, fmt.Errorf("failed to recreate missing states: %w", err)
 					}
 				}
-				latestBlock := l2BlockChain.CurrentBlock()
-				if latestBlock == nil || latestBlock.Number.Uint64() <= chainConfig.ArbitrumChainParams.GenesisBlockNum ||
-					types.DeserializeHeaderExtraInformation(latestBlock).ArbOSFormatVersion < params.ArbosVersion_Stylus {
-					// If there is only genesis block or no blocks in the blockchain, set Rebuilding of wasm store to Done
-					// If Stylus upgrade hasn't yet happened, skipping rebuilding of wasm store
-					log.Info("Setting rebuilding of wasm store to done")
-					if err = gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingPositionKey, gethexec.RebuildingDone); err != nil {
-						return nil, nil, fmt.Errorf("unable to set rebuilding status of wasm store to done: %w", err)
-					}
-				} else if config.Init.RebuildLocalWasm {
-					position, err := gethexec.ReadFromKeyValueStore[common.Hash](wasmDb, gethexec.RebuildingPositionKey)
-					if err != nil {
-						log.Info("Unable to get codehash position in rebuilding of wasm store, its possible it isnt initialized yet, so initializing it and starting rebuilding", "err", err)
-						if err := gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingPositionKey, common.Hash{}); err != nil {
-							return nil, nil, fmt.Errorf("unable to initialize codehash position in rebuilding of wasm store to beginning: %w", err)
-						}
-					}
-					if position != gethexec.RebuildingDone {
-						startBlockHash, err := gethexec.ReadFromKeyValueStore[common.Hash](wasmDb, gethexec.RebuildingStartBlockHashKey)
-						if err != nil {
-							log.Info("Unable to get start block hash in rebuilding of wasm store, its possible it isnt initialized yet, so initializing it to latest block hash", "err", err)
-							if err := gethexec.WriteToKeyValueStore(wasmDb, gethexec.RebuildingStartBlockHashKey, latestBlock.Hash()); err != nil {
-								return nil, nil, fmt.Errorf("unable to initialize start block hash in rebuilding of wasm store to latest block hash: %w", err)
-							}
-							startBlockHash = latestBlock.Hash()
-						}
-						log.Info("Starting or continuing rebuilding of wasm store", "codeHash", position, "startBlockHash", startBlockHash)
-						if err := gethexec.RebuildWasmStore(ctx, wasmDb, chainDb, config.Execution.RPC.MaxRecreateStateDepth, l2BlockChain, position, startBlockHash); err != nil {
-							return nil, nil, fmt.Errorf("error rebuilding of wasm store: %w", err)
-						}
-					}
-				}
-				return chainDb, l2BlockChain, nil
+				return rebuildLocalWasm(ctx, &config.Execution, l2BlockChain, chainDb, wasmDb, config.Init.RebuildLocalWasm)
 			}
 			readOnlyDb.Close()
 		} else if !dbutil.IsNotExistError(err) {
@@ -508,19 +642,9 @@ func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeCo
 	}
 
 	if initFile != "" {
-		reader, err := os.Open(initFile)
-		if err != nil {
-			return nil, nil, fmt.Errorf("couln't open init '%v' archive: %w", initFile, err)
-		}
-		stat, err := reader.Stat()
-		if err != nil {
+		if err := extractSnapshot(initFile, stack.InstanceDir(), config.Init.ImportWasm); err != nil {
 			return nil, nil, err
 		}
-		log.Info("extracting downloaded init archive", "size", fmt.Sprintf("%dMB", stat.Size()/1024/1024))
-		err = extract.Archive(context.Background(), reader, stack.InstanceDir(), nil)
-		if err != nil {
-			return nil, nil, fmt.Errorf("couln't extract init archive '%v' err:%w", initFile, err)
-		}
 	}
 
 	var initDataReader statetransfer.InitDataReader = nil
@@ -533,7 +657,10 @@ func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeCo
 	if err != nil {
 		return nil, nil, err
 	}
-	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmDb, 1)
+	if err := validateOrUpgradeWasmStoreSchemaVersion(wasmDb); err != nil {
+		return nil, nil, err
+	}
+	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmDb, 1, targetConfig.WasmTargets())
 	_, err = rawdb.ParseStateScheme(cacheConfig.StateScheme, chainDb)
 	if err != nil {
 		return nil, nil, err
@@ -703,7 +830,7 @@ func openInitializeChainDb(ctx context.Context, stack *node.Node, config *NodeCo
 		return chainDb, l2BlockChain, err
 	}
 
-	return chainDb, l2BlockChain, nil
+	return rebuildLocalWasm(ctx, &config.Execution, l2BlockChain, chainDb, wasmDb, config.Init.RebuildLocalWasm)
 }
 
 func testTxIndexUpdated(chainDb ethdb.Database, lastBlock uint64) bool {
@@ -749,6 +876,7 @@ func testUpdateTxIndex(chainDb ethdb.Database, chainConfig *params.ChainConfig,
 		localWg.Add(1)
 		go func() {
 			batch := chainDb.NewBatch()
+			// #nosec G115
 			for blockNum := uint64(thread); blockNum <= lastBlock; blockNum += uint64(threads) {
 				blockHash := rawdb.ReadCanonicalHash(chainDb, blockNum)
 				block := rawdb.ReadBlock(chainDb, blockHash, blockNum)
diff --git a/cmd/nitro/init_test.go b/cmd/nitro/init_test.go
index 95a4b20..48d969f 100644
--- a/cmd/nitro/init_test.go
+++ b/cmd/nitro/init_test.go
@@ -4,30 +4,36 @@
 package main
 
 import (
+	"archive/tar"
 	"bytes"
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"io"
 	"math/big"
 	"net"
 	"net/http"
 	"os"
 	"path"
 	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/node"
+	"github.com/google/go-cmp/cmp"
 	"github.com/offchainlabs/nitro/arbnode"
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/conf"
 	"github.com/offchainlabs/nitro/execution/gethexec"
 	"github.com/offchainlabs/nitro/util/testhelpers"
+	"github.com/offchainlabs/nitro/util/testhelpers/env"
 )
 
 const (
@@ -207,6 +213,7 @@ func TestSetLatestSnapshotUrl(t *testing.T) {
 
 	testCases := []struct {
 		name           string
+		chain          string
 		latestContents string
 		wantUrl        func(string) string
 	}{
@@ -230,6 +237,12 @@ func TestSetLatestSnapshotUrl(t *testing.T) {
 			latestContents: "https://some.domain.com/arb1/2024/21/archive.tar.gz",
 			wantUrl:        func(serverAddr string) string { return "https://some.domain.com/arb1/2024/21/archive.tar.gz" },
 		},
+		{
+			name:           "chain and contents with upper case",
+			chain:          "ARB1",
+			latestContents: "ARB1/2024/21/ARCHIVE.TAR.GZ",
+			wantUrl:        func(serverAddr string) string { return serverAddr + "/arb1/2024/21/archive.tar.gz" },
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -237,6 +250,7 @@ func TestSetLatestSnapshotUrl(t *testing.T) {
 
 		// Create latest file
 		serverDir := t.TempDir()
+
 		err := os.Mkdir(filepath.Join(serverDir, chain), dirPerm)
 		Require(t, err)
 		err = os.WriteFile(filepath.Join(serverDir, chain, latestFile), []byte(testCase.latestContents), filePerm)
@@ -251,7 +265,11 @@ func TestSetLatestSnapshotUrl(t *testing.T) {
 		initConfig := conf.InitConfigDefault
 		initConfig.Latest = snapshotKind
 		initConfig.LatestBase = addr
-		err = setLatestSnapshotUrl(ctx, &initConfig, chain)
+		configChain := testCase.chain
+		if configChain == "" {
+			configChain = chain
+		}
+		err = setLatestSnapshotUrl(ctx, &initConfig, configChain)
 		Require(t, err)
 
 		// Check url
@@ -336,6 +354,12 @@ func TestEmptyDatabaseDir(t *testing.T) {
 	}
 }
 
+func defaultStylusTargetConfigForTest(t *testing.T) *gethexec.StylusTargetConfig {
+	targetConfig := gethexec.DefaultStylusTargetConfig
+	Require(t, targetConfig.Validate())
+	return &targetConfig
+}
+
 func TestOpenInitializeChainDbIncompatibleStateScheme(t *testing.T) {
 	t.Parallel()
 
@@ -363,6 +387,7 @@ func TestOpenInitializeChainDbIncompatibleStateScheme(t *testing.T) {
 		&nodeConfig,
 		new(big.Int).SetUint64(nodeConfig.Chain.ID),
 		gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching),
+		defaultStylusTargetConfigForTest(t),
 		&nodeConfig.Persistent,
 		l1Client,
 		chaininfo.RollupAddresses{},
@@ -379,6 +404,7 @@ func TestOpenInitializeChainDbIncompatibleStateScheme(t *testing.T) {
 		&nodeConfig,
 		new(big.Int).SetUint64(nodeConfig.Chain.ID),
 		gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching),
+		defaultStylusTargetConfigForTest(t),
 		&nodeConfig.Persistent,
 		l1Client,
 		chaininfo.RollupAddresses{},
@@ -396,6 +422,7 @@ func TestOpenInitializeChainDbIncompatibleStateScheme(t *testing.T) {
 		&nodeConfig,
 		new(big.Int).SetUint64(nodeConfig.Chain.ID),
 		gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching),
+		defaultStylusTargetConfigForTest(t),
 		&nodeConfig.Persistent,
 		l1Client,
 		chaininfo.RollupAddresses{},
@@ -404,3 +431,289 @@ func TestOpenInitializeChainDbIncompatibleStateScheme(t *testing.T) {
 		t.Fatalf("Failed to detect incompatible state scheme")
 	}
 }
+
+func writeKeys(t *testing.T, db ethdb.Database, keys [][]byte) {
+	t.Helper()
+	batch := db.NewBatch()
+	for _, key := range keys {
+		err := batch.Put(key, []byte("some data"))
+		if err != nil {
+			t.Fatal("Internal test error - failed to insert key:", err)
+		}
+	}
+	err := batch.Write()
+	if err != nil {
+		t.Fatal("Internal test error - failed to write batch:", err)
+	}
+	batch.Reset()
+}
+
+func checkKeys(t *testing.T, db ethdb.Database, keys [][]byte, shouldExist bool) {
+	t.Helper()
+	for _, key := range keys {
+		has, err := db.Has(key)
+		if err != nil {
+			t.Fatal("Failed to check key existence, key: ", key)
+		}
+		if shouldExist && !has {
+			t.Fatal("Key not found:", key)
+		}
+		if !shouldExist && has {
+			t.Fatal("Key found:", key, "k3:", string(key[:3]), "len", len(key))
+		}
+	}
+}
+
+func TestPurgeVersion0WasmStoreEntries(t *testing.T) {
+	stackConf := node.DefaultConfig
+	stackConf.DataDir = t.TempDir()
+	stack, err := node.New(&stackConf)
+	if err != nil {
+		t.Fatalf("Failed to create test stack: %v", err)
+	}
+	defer stack.Close()
+	db, err := stack.OpenDatabaseWithExtraOptions("wasm", NodeConfigDefault.Execution.Caching.DatabaseCache, NodeConfigDefault.Persistent.Handles, "wasm/", false, nil)
+	if err != nil {
+		t.Fatalf("Failed to open test db: %v", err)
+	}
+	var version0Keys [][]byte
+	for i := 0; i < 20; i++ {
+		version0Keys = append(version0Keys,
+			append([]byte{0x00, 'w', 'a'}, testhelpers.RandomSlice(32)...))
+		version0Keys = append(version0Keys,
+			append([]byte{0x00, 'w', 'm'}, testhelpers.RandomSlice(32)...))
+	}
+	var collidedKeys [][]byte
+	for i := 0; i < 5; i++ {
+		collidedKeys = append(collidedKeys,
+			append([]byte{0x00, 'w', 'a'}, testhelpers.RandomSlice(31)...))
+		collidedKeys = append(collidedKeys,
+			append([]byte{0x00, 'w', 'm'}, testhelpers.RandomSlice(31)...))
+		collidedKeys = append(collidedKeys,
+			append([]byte{0x00, 'w', 'a'}, testhelpers.RandomSlice(33)...))
+		collidedKeys = append(collidedKeys,
+			append([]byte{0x00, 'w', 'm'}, testhelpers.RandomSlice(33)...))
+	}
+	var otherKeys [][]byte
+	for i := 0x00; i <= 0xff; i++ {
+		if byte(i) == 'a' || byte(i) == 'm' {
+			continue
+		}
+		otherKeys = append(otherKeys,
+			append([]byte{0x00, 'w', byte(i)}, testhelpers.RandomSlice(32)...))
+		otherKeys = append(otherKeys,
+			append([]byte{0x00, 'w', byte(i)}, testhelpers.RandomSlice(32)...))
+	}
+	for i := 0; i < 10; i++ {
+		var randomSlice []byte
+		var j int
+		for j = 0; j < 10; j++ {
+			randomSlice = testhelpers.RandomSlice(testhelpers.RandomUint64(1, 40))
+			if len(randomSlice) >= 3 && !bytes.Equal(randomSlice[:3], []byte{0x00, 'w', 'm'}) && !bytes.Equal(randomSlice[:3], []byte{0x00, 'w', 'm'}) {
+				break
+			}
+		}
+		if j == 10 {
+			t.Fatal("Internal test error - failed to generate random key")
+		}
+		otherKeys = append(otherKeys, randomSlice)
+	}
+	writeKeys(t, db, version0Keys)
+	writeKeys(t, db, collidedKeys)
+	writeKeys(t, db, otherKeys)
+	checkKeys(t, db, version0Keys, true)
+	checkKeys(t, db, collidedKeys, true)
+	checkKeys(t, db, otherKeys, true)
+	err = purgeVersion0WasmStoreEntries(db)
+	if err != nil {
+		t.Fatal("Failed to purge version 0 keys, err:", err)
+	}
+	checkKeys(t, db, version0Keys, false)
+	checkKeys(t, db, collidedKeys, true)
+	checkKeys(t, db, otherKeys, true)
+}
+
+func TestOpenInitializeChainDbEmptyInit(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	stackConfig := testhelpers.CreateStackConfigForTest(t.TempDir())
+	stack, err := node.New(stackConfig)
+	defer stack.Close()
+	Require(t, err)
+
+	nodeConfig := NodeConfigDefault
+	nodeConfig.Execution.Caching.StateScheme = env.GetTestStateScheme()
+	nodeConfig.Chain.ID = 42161
+	nodeConfig.Node = *arbnode.ConfigDefaultL2Test()
+	nodeConfig.Init.Empty = true
+
+	l1Client := ethclient.NewClient(stack.Attach())
+
+	chainDb, blockchain, err := openInitializeChainDb(
+		ctx,
+		stack,
+		&nodeConfig,
+		new(big.Int).SetUint64(nodeConfig.Chain.ID),
+		gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching),
+		defaultStylusTargetConfigForTest(t),
+		&nodeConfig.Persistent,
+		l1Client,
+		chaininfo.RollupAddresses{},
+	)
+	Require(t, err)
+	blockchain.Stop()
+	err = chainDb.Close()
+	Require(t, err)
+}
+
+func TestExtractSnapshot(t *testing.T) {
+	testCases := []struct {
+		name         string
+		archiveFiles []string
+		importWasm   bool
+		wantFiles    []string
+	}{
+		{
+			name:       "extractAll",
+			importWasm: true,
+			archiveFiles: []string{
+				"arbitrumdata/000001.ldb",
+				"l2chaindata/000001.ldb",
+				"l2chaindata/ancients/000001.ldb",
+				"nodes/000001.ldb",
+				"wasm/000001.ldb",
+			},
+			wantFiles: []string{
+				"arbitrumdata/000001.ldb",
+				"l2chaindata/000001.ldb",
+				"l2chaindata/ancients/000001.ldb",
+				"nodes/000001.ldb",
+				"wasm/000001.ldb",
+			},
+		},
+		{
+			name:       "extractAllButWasm",
+			importWasm: false,
+			archiveFiles: []string{
+				"arbitrumdata/000001.ldb",
+				"l2chaindata/000001.ldb",
+				"nodes/000001.ldb",
+				"wasm/000001.ldb",
+			},
+			wantFiles: []string{
+				"arbitrumdata/000001.ldb",
+				"l2chaindata/000001.ldb",
+				"nodes/000001.ldb",
+			},
+		},
+		{
+			name:       "extractAllButWasmWithPrefixDot",
+			importWasm: false,
+			archiveFiles: []string{
+				"./arbitrumdata/000001.ldb",
+				"./l2chaindata/000001.ldb",
+				"./nodes/000001.ldb",
+				"./wasm/000001.ldb",
+			},
+			wantFiles: []string{
+				"arbitrumdata/000001.ldb",
+				"l2chaindata/000001.ldb",
+				"nodes/000001.ldb",
+			},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			// Create archive with dummy files
+			archiveDir := t.TempDir()
+			archivePath := path.Join(archiveDir, "archive.tar")
+			{
+				// Create context to close the file handlers
+				archiveFile, err := os.Create(archivePath)
+				Require(t, err)
+				defer archiveFile.Close()
+				tarWriter := tar.NewWriter(archiveFile)
+				defer tarWriter.Close()
+				for _, relativePath := range testCase.archiveFiles {
+					filePath := path.Join(archiveDir, relativePath)
+					dir := filepath.Dir(filePath)
+					const dirPerm = 0700
+					err := os.MkdirAll(dir, dirPerm)
+					Require(t, err)
+					const filePerm = 0600
+					err = os.WriteFile(filePath, []byte{0xbe, 0xef}, filePerm)
+					Require(t, err)
+					file, err := os.Open(filePath)
+					Require(t, err)
+					info, err := file.Stat()
+					Require(t, err)
+					header, err := tar.FileInfoHeader(info, "")
+					Require(t, err)
+					header.Name = relativePath
+					err = tarWriter.WriteHeader(header)
+					Require(t, err)
+					_, err = io.Copy(tarWriter, file)
+					Require(t, err)
+				}
+			}
+
+			// Extract archive and compare contents
+			targetDir := t.TempDir()
+			err := extractSnapshot(archivePath, targetDir, testCase.importWasm)
+			Require(t, err, "failed to extract snapshot")
+			gotFiles := []string{}
+			err = filepath.WalkDir(targetDir, func(path string, d os.DirEntry, err error) error {
+				if err != nil {
+					return err
+				}
+				if !d.IsDir() {
+					gotFiles = append(gotFiles, path)
+				}
+				return nil
+			})
+			Require(t, err)
+			slices.Sort(gotFiles)
+			for i, f := range testCase.wantFiles {
+				testCase.wantFiles[i] = path.Join(targetDir, f)
+			}
+			if diff := cmp.Diff(gotFiles, testCase.wantFiles); diff != "" {
+				t.Fatal("extracted files don't match", diff)
+			}
+		})
+	}
+}
+
+func TestIsWasmDb(t *testing.T) {
+	testCases := []struct {
+		path string
+		want bool
+	}{
+		{"wasm", true},
+		{"wasm/", true},
+		{"wasm/something", true},
+		{"/wasm", true},
+		{"./wasm", true},
+		{"././wasm", true},
+		{"/./wasm", true},
+		{"WASM", true},
+		{"wAsM", true},
+		{"nitro/../wasm", true},
+		{"/nitro/../wasm", true},
+		{".//nitro/.//../wasm", true},
+		{"not-wasm", false},
+		{"l2chaindata/example@@", false},
+		{"somedir/wasm", false},
+	}
+	for _, testCase := range testCases {
+		name := fmt.Sprintf("%q", testCase.path)
+		t.Run(name, func(t *testing.T) {
+			got := isWasmDb(testCase.path)
+			if testCase.want != got {
+				t.Fatalf("want %v, but got %v", testCase.want, got)
+			}
+		})
+	}
+}
diff --git a/cmd/nitro/nitro.go b/cmd/nitro/nitro.go
index ab6bf31..bc2155a 100644
--- a/cmd/nitro/nitro.go
+++ b/cmd/nitro/nitro.go
@@ -249,7 +249,7 @@ func mainImpl() int {
 	// If sequencer and signing is enabled or batchposter is enabled without
 	// external signing sequencer will need a key.
 	sequencerNeedsKey := (nodeConfig.Node.Sequencer && !nodeConfig.Node.Feed.Output.DisableSigning) ||
-		(nodeConfig.Node.BatchPoster.Enable && nodeConfig.Node.BatchPoster.DataPoster.ExternalSigner.URL == "")
+		(nodeConfig.Node.BatchPoster.Enable && (nodeConfig.Node.BatchPoster.DataPoster.ExternalSigner.URL == "" || nodeConfig.Node.DataAvailability.Enable))
 	validatorNeedsKey := nodeConfig.Node.Staker.OnlyCreateWalletContract ||
 		(nodeConfig.Node.Staker.Enable && !strings.EqualFold(nodeConfig.Node.Staker.Strategy, "watchtower") && nodeConfig.Node.Staker.DataPoster.ExternalSigner.URL == "")
 
@@ -371,7 +371,21 @@ func mainImpl() int {
 		if err != nil {
 			log.Crit("error getting rollup addresses config", "err", err)
 		}
-		addr, err := validatorwallet.GetValidatorWalletContract(ctx, deployInfo.ValidatorWalletCreator, int64(deployInfo.DeployedAt), l1TransactionOptsValidator, l1Reader, true)
+
+		dataPoster, err := arbnode.DataposterOnlyUsedToCreateValidatorWalletContract(
+			ctx,
+			l1Reader,
+			l1TransactionOptsValidator,
+			&nodeConfig.Node.Staker.DataPoster,
+			new(big.Int).SetUint64(nodeConfig.ParentChain.ID),
+		)
+		if err != nil {
+			log.Crit("error creating data poster to create validator wallet contract", "err", err)
+		}
+		getExtraGas := func() uint64 { return nodeConfig.Node.Staker.ExtraGas }
+
+		// #nosec G115
+		addr, err := validatorwallet.GetValidatorWalletContract(ctx, deployInfo.ValidatorWalletCreator, int64(deployInfo.DeployedAt), l1Reader, true, dataPoster, getExtraGas)
 		if err != nil {
 			log.Crit("error creating validator wallet contract", "error", err, "address", l1TransactionOptsValidator.From.Hex())
 		}
@@ -423,65 +437,13 @@ func mainImpl() int {
 
 	// Check that node is compatible with on-chain WASM module root on startup and before any ArbOS upgrades take effect to prevent divergences
 	if nodeConfig.Node.ParentChainReader.Enable && nodeConfig.Validation.Wasm.EnableWasmrootsCheck {
-		// Fetch current on-chain WASM module root
-		rollupUserLogic, err := rollupgen.NewRollupUserLogic(rollupAddrs.Rollup, l1Client)
+		err := checkWasmModuleRootCompatibility(ctx, nodeConfig.Validation.Wasm, l1Client, rollupAddrs)
 		if err != nil {
-			log.Error("failed to create rollupUserLogic", "err", err)
-			return 1
-		}
-		moduleRoot, err := rollupUserLogic.WasmModuleRoot(&bind.CallOpts{Context: ctx})
-		if err != nil {
-			log.Error("failed to get on-chain WASM module root", "err", err)
-			return 1
-		}
-		if (moduleRoot == common.Hash{}) {
-			log.Error("on-chain WASM module root is zero")
-			return 1
-		}
-		// Check if the on-chain WASM module root belongs to the set of allowed module roots
-		allowedWasmModuleRoots := nodeConfig.Validation.Wasm.AllowedWasmModuleRoots
-		if len(allowedWasmModuleRoots) > 0 {
-			moduleRootMatched := false
-			for _, root := range allowedWasmModuleRoots {
-				bytes, err := hex.DecodeString(strings.TrimPrefix(root, "0x"))
-				if err == nil {
-					if common.HexToHash(root) == common.BytesToHash(bytes) {
-						moduleRootMatched = true
-						break
-					}
-					continue
-				}
-				locator, locatorErr := server_common.NewMachineLocator(root)
-				if locatorErr != nil {
-					log.Warn("allowed-wasm-module-roots: value not a hex nor valid path:", "value", root, "locatorErr", locatorErr, "decodeErr", err)
-					continue
-				}
-				path := locator.GetMachinePath(moduleRoot)
-				if _, err := os.Stat(path); err == nil {
-					moduleRootMatched = true
-					break
-				}
-			}
-			if !moduleRootMatched {
-				log.Error("on-chain WASM module root did not match with any of the allowed WASM module roots")
-				return 1
-			}
-		} else {
-			// If no allowed module roots were provided in config, check if we have a validator machine directory for the on-chain WASM module root
-			locator, err := server_common.NewMachineLocator(nodeConfig.Validation.Wasm.RootPath)
-			if err != nil {
-				log.Warn("failed to create machine locator. Skipping the check for compatibility with on-chain WASM module root", "err", err)
-			} else {
-				path := locator.GetMachinePath(moduleRoot)
-				if _, err := os.Stat(path); err != nil {
-					log.Error("unable to find validator machine directory for the on-chain WASM module root", "err", err)
-					return 1
-				}
-			}
+			log.Warn("failed to check if node is compatible with on-chain WASM module root", "err", err)
 		}
 	}
 
-	chainDb, l2BlockChain, err := openInitializeChainDb(ctx, stack, nodeConfig, new(big.Int).SetUint64(nodeConfig.Chain.ID), gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching), &nodeConfig.Persistent, l1Client, rollupAddrs)
+	chainDb, l2BlockChain, err := openInitializeChainDb(ctx, stack, nodeConfig, new(big.Int).SetUint64(nodeConfig.Chain.ID), gethexec.DefaultCacheConfigFor(stack, &nodeConfig.Execution.Caching), &nodeConfig.Execution.StylusTarget, &nodeConfig.Persistent, l1Client, rollupAddrs)
 	if l2BlockChain != nil {
 		deferFuncs = append(deferFuncs, func() { l2BlockChain.Stop() })
 	}
@@ -510,6 +472,10 @@ func mainImpl() int {
 	if nodeConfig.BlocksReExecutor.Enable && l2BlockChain != nil {
 		blocksReExecutor = blocksreexecutor.New(&nodeConfig.BlocksReExecutor, l2BlockChain, fatalErrChan)
 		if nodeConfig.Init.ThenQuit {
+			if err := gethexec.PopulateStylusTargetCache(&nodeConfig.Execution.StylusTarget); err != nil {
+				log.Error("error populating stylus target cache", "err", err)
+				return 1
+			}
 			success := make(chan struct{})
 			blocksReExecutor.Start(ctx, success)
 			deferFuncs = append(deferFuncs, func() { blocksReExecutor.StopAndWait() })
@@ -582,7 +548,7 @@ func mainImpl() int {
 		l1TransactionOptsBatchPoster,
 		dataSigner,
 		fatalErrChan,
-		big.NewInt(int64(nodeConfig.ParentChain.ID)),
+		new(big.Int).SetUint64(nodeConfig.ParentChain.ID),
 		blobReader,
 	)
 	if err != nil {
@@ -878,6 +844,7 @@ func ParseNode(ctx context.Context, args []string) (*NodeConfig, *genericconf.Wa
 	l2ChainInfoIpfsDownloadPath := k.String("chain.info-ipfs-download-path")
 	l2ChainInfoFiles := k.Strings("chain.info-files")
 	l2ChainInfoJson := k.String("chain.info-json")
+	// #nosec G115
 	err = applyChainParameters(ctx, k, uint64(l2ChainId), l2ChainName, l2ChainInfoFiles, l2ChainInfoJson, l2ChainInfoIpfsUrl, l2ChainInfoIpfsDownloadPath)
 	if err != nil {
 		return nil, nil, err
@@ -900,10 +867,12 @@ func ParseNode(ctx context.Context, args []string) (*NodeConfig, *genericconf.Wa
 	// Don't print wallet passwords
 	if nodeConfig.Conf.Dump {
 		err = confighelpers.DumpConfig(k, map[string]interface{}{
-			"parent-chain.wallet.password":    "",
-			"parent-chain.wallet.private-key": "",
-			"chain.dev-wallet.password":       "",
-			"chain.dev-wallet.private-key":    "",
+			"node.batch-poster.parent-chain-wallet.password":    "",
+			"node.batch-poster.parent-chain-wallet.private-key": "",
+			"node.staker.parent-chain-wallet.password":          "",
+			"node.staker.parent-chain-wallet.private-key":       "",
+			"chain.dev-wallet.password":                         "",
+			"chain.dev-wallet.private-key":                      "",
 		})
 		if err != nil {
 			return nil, nil, err
@@ -1021,13 +990,16 @@ func applyChainParameters(ctx context.Context, k *koanf.Koanf, chainId uint64, c
 func initReorg(initConfig conf.InitConfig, chainConfig *params.ChainConfig, inboxTracker *arbnode.InboxTracker) error {
 	var batchCount uint64
 	if initConfig.ReorgToBatch >= 0 {
+		// #nosec G115
 		batchCount = uint64(initConfig.ReorgToBatch) + 1
 	} else {
 		var messageIndex arbutil.MessageIndex
 		if initConfig.ReorgToMessageBatch >= 0 {
+			// #nosec G115
 			messageIndex = arbutil.MessageIndex(initConfig.ReorgToMessageBatch)
 		} else if initConfig.ReorgToBlockBatch > 0 {
 			genesis := chainConfig.ArbitrumChainParams.GenesisBlockNum
+			// #nosec G115
 			blockNum := uint64(initConfig.ReorgToBlockBatch)
 			if blockNum < genesis {
 				return fmt.Errorf("ReorgToBlockBatch %d before genesis %d", blockNum, genesis)
@@ -1038,14 +1010,15 @@ func initReorg(initConfig conf.InitConfig, chainConfig *params.ChainConfig, inbo
 			return nil
 		}
 		// Reorg out the batch containing the next message
-		var missing bool
+		var found bool
 		var err error
-		batchCount, missing, err = inboxTracker.FindInboxBatchContainingMessage(messageIndex + 1)
+		batchCount, found, err = inboxTracker.FindInboxBatchContainingMessage(messageIndex + 1)
 		if err != nil {
 			return err
 		}
-		if missing {
-			return fmt.Errorf("cannot reorg to unknown message index %v", messageIndex)
+		if !found {
+			log.Warn("init-reorg: no need to reorg, because message ahead of chain", "messageIndex", messageIndex)
+			return nil
 		}
 	}
 	return inboxTracker.ReorgBatchesTo(batchCount)
@@ -1058,3 +1031,57 @@ type NodeConfigFetcher struct {
 func (f *NodeConfigFetcher) Get() *arbnode.Config {
 	return &f.LiveConfig.Get().Node
 }
+
+func checkWasmModuleRootCompatibility(ctx context.Context, wasmConfig valnode.WasmConfig, l1Client *ethclient.Client, rollupAddrs chaininfo.RollupAddresses) error {
+	// Fetch current on-chain WASM module root
+	rollupUserLogic, err := rollupgen.NewRollupUserLogic(rollupAddrs.Rollup, l1Client)
+	if err != nil {
+		return fmt.Errorf("failed to create RollupUserLogic: %w", err)
+	}
+	moduleRoot, err := rollupUserLogic.WasmModuleRoot(&bind.CallOpts{Context: ctx})
+	if err != nil {
+		return fmt.Errorf("failed to get on-chain WASM module root: %w", err)
+	}
+	if (moduleRoot == common.Hash{}) {
+		return errors.New("on-chain WASM module root is zero")
+	}
+	// Check if the on-chain WASM module root belongs to the set of allowed module roots
+	allowedWasmModuleRoots := wasmConfig.AllowedWasmModuleRoots
+	if len(allowedWasmModuleRoots) > 0 {
+		moduleRootMatched := false
+		for _, root := range allowedWasmModuleRoots {
+			bytes, err := hex.DecodeString(strings.TrimPrefix(root, "0x"))
+			if err == nil {
+				if common.HexToHash(root) == common.BytesToHash(bytes) {
+					moduleRootMatched = true
+					break
+				}
+				continue
+			}
+			locator, locatorErr := server_common.NewMachineLocator(root)
+			if locatorErr != nil {
+				log.Warn("allowed-wasm-module-roots: value not a hex nor valid path:", "value", root, "locatorErr", locatorErr, "decodeErr", err)
+				continue
+			}
+			path := locator.GetMachinePath(moduleRoot)
+			if _, err := os.Stat(path); err == nil {
+				moduleRootMatched = true
+				break
+			}
+		}
+		if !moduleRootMatched {
+			return errors.New("on-chain WASM module root did not match with any of the allowed WASM module roots")
+		}
+	} else {
+		// If no allowed module roots were provided in config, check if we have a validator machine directory for the on-chain WASM module root
+		locator, err := server_common.NewMachineLocator(wasmConfig.RootPath)
+		if err != nil {
+			return fmt.Errorf("failed to create machine locator: %w", err)
+		}
+		path := locator.GetMachinePath(moduleRoot)
+		if _, err := os.Stat(path); err != nil {
+			return fmt.Errorf("unable to find validator machine directory for the on-chain WASM module root: %w", err)
+		}
+	}
+	return nil
+}
diff --git a/cmd/pruning/pruning.go b/cmd/pruning/pruning.go
index 096bb4b..0755f5f 100644
--- a/cmd/pruning/pruning.go
+++ b/cmd/pruning/pruning.go
@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state/pruner"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
@@ -80,7 +81,7 @@ func (r *importantRoots) addHeader(header *types.Header, overwrite bool) error {
 var hashListRegex = regexp.MustCompile("^(0x)?[0-9a-fA-F]{64}(,(0x)?[0-9a-fA-F]{64})*$")
 
 // Finds important roots to retain while proving
-func findImportantRoots(ctx context.Context, chainDb ethdb.Database, stack *node.Node, initConfig *conf.InitConfig, cacheConfig *core.CacheConfig, persistentConfig *conf.PersistentConfig, l1Client arbutil.L1Interface, rollupAddrs chaininfo.RollupAddresses, validatorRequired bool) ([]common.Hash, error) {
+func findImportantRoots(ctx context.Context, chainDb ethdb.Database, stack *node.Node, initConfig *conf.InitConfig, cacheConfig *core.CacheConfig, persistentConfig *conf.PersistentConfig, l1Client *ethclient.Client, rollupAddrs chaininfo.RollupAddresses, validatorRequired bool) ([]common.Hash, error) {
 	chainConfig := gethexec.TryReadStoredChainConfig(chainDb)
 	if chainConfig == nil {
 		return nil, errors.New("database doesn't have a chain config (was this node initialized?)")
@@ -212,6 +213,7 @@ func findImportantRoots(ctx context.Context, chainDb ethdb.Database, stack *node
 			}
 			if meta.ParentChainBlock <= l1BlockNum {
 				signedBlockNum := arbutil.MessageCountToBlockNumber(meta.MessageCount, genesisNum)
+				// #nosec G115
 				blockNum := uint64(signedBlockNum)
 				l2Hash := rawdb.ReadCanonicalHash(chainDb, blockNum)
 				l2Header := rawdb.ReadHeader(chainDb, l2Hash, blockNum)
@@ -232,7 +234,7 @@ func findImportantRoots(ctx context.Context, chainDb ethdb.Database, stack *node
 	return roots.roots, nil
 }
 
-func PruneChainDb(ctx context.Context, chainDb ethdb.Database, stack *node.Node, initConfig *conf.InitConfig, cacheConfig *core.CacheConfig, persistentConfig *conf.PersistentConfig, l1Client arbutil.L1Interface, rollupAddrs chaininfo.RollupAddresses, validatorRequired bool) error {
+func PruneChainDb(ctx context.Context, chainDb ethdb.Database, stack *node.Node, initConfig *conf.InitConfig, cacheConfig *core.CacheConfig, persistentConfig *conf.PersistentConfig, l1Client *ethclient.Client, rollupAddrs chaininfo.RollupAddresses, validatorRequired bool) error {
 	if cacheConfig.StateScheme == rawdb.PathScheme {
 		return nil
 	}
diff --git a/cmd/staterecovery/staterecovery.go b/cmd/staterecovery/staterecovery.go
index bb01477..5486ba3 100644
--- a/cmd/staterecovery/staterecovery.go
+++ b/cmd/staterecovery/staterecovery.go
@@ -60,6 +60,7 @@ func RecreateMissingStates(chainDb ethdb.Database, bc *core.BlockChain, cacheCon
 			break
 		}
 		if time.Since(logged) > 1*time.Minute {
+			// #nosec G115
 			log.Info("Recreating missing states", "block", current, "target", target, "remaining", int64(target)-int64(current), "elapsed", time.Since(start), "recreated", recreated)
 			logged = time.Now()
 		}
diff --git a/cmd/util/confighelpers/configuration.go b/cmd/util/confighelpers/configuration.go
index 55c9ec3..19b5b1a 100644
--- a/cmd/util/confighelpers/configuration.go
+++ b/cmd/util/confighelpers/configuration.go
@@ -13,7 +13,6 @@ import (
 
 	"github.com/knadh/koanf"
 	"github.com/knadh/koanf/parsers/json"
-	koanfjson "github.com/knadh/koanf/parsers/json"
 	"github.com/knadh/koanf/providers/confmap"
 	"github.com/knadh/koanf/providers/env"
 	"github.com/knadh/koanf/providers/file"
@@ -215,15 +214,17 @@ func devFlagArgs() []string {
 }
 
 func BeginCommonParse(f *flag.FlagSet, args []string) (*koanf.Koanf, error) {
+	var expandedArgs []string
 	for _, arg := range args {
 		if arg == "--version" || arg == "-v" {
 			return nil, ErrVersion
 		} else if arg == "--dev" {
-			args = devFlagArgs()
-			break
+			expandedArgs = append(expandedArgs, devFlagArgs()...)
+		} else {
+			expandedArgs = append(expandedArgs, arg)
 		}
 	}
-	if err := f.Parse(args); err != nil {
+	if err := f.Parse(expandedArgs); err != nil {
 		return nil, err
 	}
 
@@ -305,7 +306,7 @@ func DumpConfig(k *koanf.Koanf, extraOverrideFields map[string]interface{}) erro
 		return fmt.Errorf("error removing extra parameters before dump: %w", err)
 	}
 
-	c, err := k.Marshal(koanfjson.Parser())
+	c, err := k.Marshal(json.Parser())
 	if err != nil {
 		return fmt.Errorf("unable to marshal config file to JSON: %w", err)
 	}
diff --git a/das/aggregator.go b/das/aggregator.go
index d944f8d..372e448 100644
--- a/das/aggregator.go
+++ b/das/aggregator.go
@@ -15,11 +15,11 @@ import (
 	flag "github.com/spf13/pflag"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/blsSignatures"
 	"github.com/offchainlabs/nitro/das/dastree"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
@@ -114,7 +114,7 @@ func NewAggregator(ctx context.Context, config DataAvailabilityConfig, services
 func NewAggregatorWithL1Info(
 	config DataAvailabilityConfig,
 	services []ServiceDetails,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 	seqInboxAddress common.Address,
 ) (*Aggregator, error) {
 	seqInboxCaller, err := bridgegen.NewSequencerInboxCaller(seqInboxAddress, l1client)
@@ -130,6 +130,7 @@ func NewAggregatorWithSeqInboxCaller(
 	seqInboxCaller *bridgegen.SequencerInboxCaller,
 ) (*Aggregator, error) {
 
+	// #nosec G115
 	keysetHash, keysetBytes, err := KeysetHashFromServices(services, uint64(config.RPCAggregator.AssumedHonest))
 	if err != nil {
 		return nil, err
@@ -166,6 +167,7 @@ type storeResponse struct {
 // If Store gets not enough successful responses by the time its context is canceled
 // (eg via TimeoutWrapper) then it also returns an error.
 func (a *Aggregator) Store(ctx context.Context, message []byte, timeout uint64) (*daprovider.DataAvailabilityCertificate, error) {
+	// #nosec G115
 	log.Trace("das.Aggregator.Store", "message", pretty.FirstFewBytes(message), "timeout", time.Unix(int64(timeout), 0))
 
 	allBackendsSucceeded := false
diff --git a/das/chain_fetch_das.go b/das/chain_fetch_das.go
index 465b54f..4de6c98 100644
--- a/das/chain_fetch_das.go
+++ b/das/chain_fetch_das.go
@@ -12,8 +12,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/das/dastree"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 )
@@ -42,7 +42,7 @@ type KeysetFetcher struct {
 	keysetCache      syncedKeysetCache
 }
 
-func NewKeysetFetcher(l1client arbutil.L1Interface, seqInboxAddr common.Address) (*KeysetFetcher, error) {
+func NewKeysetFetcher(l1client *ethclient.Client, seqInboxAddr common.Address) (*KeysetFetcher, error) {
 	seqInbox, err := bridgegen.NewSequencerInbox(seqInboxAddr, l1client)
 	if err != nil {
 		return nil, err
diff --git a/das/dasRpcClient.go b/das/dasRpcClient.go
index ca2ee8e..241f219 100644
--- a/das/dasRpcClient.go
+++ b/das/dasRpcClient.go
@@ -12,6 +12,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/metrics"
 	"golang.org/x/sync/errgroup"
 
 	"github.com/ethereum/go-ethereum/rpc"
@@ -21,6 +22,17 @@ import (
 	"github.com/offchainlabs/nitro/util/signature"
 )
 
+var (
+	rpcClientStoreRequestGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/requests", nil)
+	rpcClientStoreSuccessGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/success", nil)
+	rpcClientStoreFailureGauge      = metrics.NewRegisteredGauge("arb/das/rpcclient/store/failure", nil)
+	rpcClientStoreStoredBytesGauge  = metrics.NewRegisteredGauge("arb/das/rpcclient/store/bytes", nil)
+	rpcClientStoreDurationHistogram = metrics.NewRegisteredHistogram("arb/das/rpcclient/store/duration", nil, metrics.NewBoundedHistogramSample())
+
+	rpcClientSendChunkSuccessGauge = metrics.NewRegisteredGauge("arb/das/rpcclient/sendchunk/success", nil)
+	rpcClientSendChunkFailureGauge = metrics.NewRegisteredGauge("arb/das/rpcclient/sendchunk/failure", nil)
+)
+
 type DASRPCClient struct { // implements DataAvailabilityService
 	clnt      *rpc.Client
 	url       string
@@ -58,7 +70,20 @@ func NewDASRPCClient(target string, signer signature.DataSignerFunc, maxStoreChu
 }
 
 func (c *DASRPCClient) Store(ctx context.Context, message []byte, timeout uint64) (*daprovider.DataAvailabilityCertificate, error) {
-	timestamp := uint64(time.Now().Unix())
+	rpcClientStoreRequestGauge.Inc(1)
+	start := time.Now()
+	success := false
+	defer func() {
+		if success {
+			rpcClientStoreSuccessGauge.Inc(1)
+		} else {
+			rpcClientStoreFailureGauge.Inc(1)
+		}
+		rpcClientStoreDurationHistogram.Update(time.Since(start).Nanoseconds())
+	}()
+
+	// #nosec G115
+	timestamp := uint64(start.Unix())
 	nChunks := uint64(len(message)) / c.chunkSize
 	lastChunkSize := uint64(len(message)) % c.chunkSize
 	if lastChunkSize > 0 {
@@ -115,6 +140,9 @@ func (c *DASRPCClient) Store(ctx context.Context, message []byte, timeout uint64
 		return nil, err
 	}
 
+	rpcClientStoreStoredBytesGauge.Inc(int64(len(message)))
+	success = true
+
 	return &daprovider.DataAvailabilityCertificate{
 		DataHash:    common.BytesToHash(storeResult.DataHash),
 		Timeout:     uint64(storeResult.Timeout),
@@ -132,12 +160,15 @@ func (c *DASRPCClient) sendChunk(ctx context.Context, batchId, i uint64, chunk [
 	}
 
 	if err := c.clnt.CallContext(ctx, nil, "das_sendChunk", hexutil.Uint64(batchId), hexutil.Uint64(i), hexutil.Bytes(chunk), hexutil.Bytes(chunkReqSig)); err != nil {
+		rpcClientSendChunkFailureGauge.Inc(1)
 		return err
 	}
+	rpcClientSendChunkSuccessGauge.Inc(1)
 	return nil
 }
 
 func (c *DASRPCClient) legacyStore(ctx context.Context, message []byte, timeout uint64) (*daprovider.DataAvailabilityCertificate, error) {
+	// #nosec G115
 	log.Trace("das.DASRPCClient.Store(...)", "message", pretty.FirstFewBytes(message), "timeout", time.Unix(int64(timeout), 0), "this", *c)
 
 	reqSig, err := applyDasSigner(c.signer, message, timeout)
diff --git a/das/dasRpcServer.go b/das/dasRpcServer.go
index 9e6228c..bb1be03 100644
--- a/das/dasRpcServer.go
+++ b/das/dasRpcServer.go
@@ -108,6 +108,7 @@ type StoreResult struct {
 }
 
 func (s *DASRPCServer) Store(ctx context.Context, message hexutil.Bytes, timeout hexutil.Uint64, sig hexutil.Bytes) (*StoreResult, error) {
+	// #nosec G115
 	log.Trace("dasRpc.DASRPCServer.Store", "message", pretty.FirstFewBytes(message), "message length", len(message), "timeout", time.Unix(int64(timeout), 0), "sig", pretty.FirstFewBytes(sig), "this", s)
 	rpcStoreRequestGauge.Inc(1)
 	start := time.Now()
@@ -152,7 +153,7 @@ type SendChunkResult struct {
 type batch struct {
 	chunks                          [][]byte
 	expectedChunks                  uint64
-	seenChunks                      atomic.Int64
+	seenChunks                      atomic.Uint64
 	expectedChunkSize, expectedSize uint64
 	timeout                         uint64
 	startTime                       time.Time
@@ -247,7 +248,7 @@ func (b *batchBuilder) close(id uint64) ([]byte, uint64, time.Time, error) {
 		return nil, 0, time.Time{}, fmt.Errorf("unknown batch(%d)", id)
 	}
 
-	if batch.expectedChunks != uint64(batch.seenChunks.Load()) {
+	if batch.expectedChunks != batch.seenChunks.Load() {
 		return nil, 0, time.Time{}, fmt.Errorf("incomplete batch(%d): got %d/%d chunks", id, batch.seenChunks.Load(), batch.expectedChunks)
 	}
 
@@ -277,6 +278,7 @@ func (s *DASRPCServer) StartChunkedStore(ctx context.Context, timestamp, nChunks
 	}
 
 	// Prevent replay of old messages
+	// #nosec G115
 	if time.Since(time.Unix(int64(timestamp), 0)).Abs() > time.Minute {
 		return nil, errors.New("too much time has elapsed since request was signed")
 	}
diff --git a/das/das_test.go b/das/das_test.go
index 179734c..4971d45 100644
--- a/das/das_test.go
+++ b/das/das_test.go
@@ -55,6 +55,7 @@ func testDASStoreRetrieveMultipleInstances(t *testing.T, storageType string) {
 	Require(t, err, "no das")
 	var daReader DataAvailabilityServiceReader = storageService
 
+	// #nosec G115
 	timeout := uint64(time.Now().Add(time.Hour * 24).Unix())
 	messageSaved := []byte("hello world")
 	cert, err := daWriter.Store(firstCtx, messageSaved, timeout)
@@ -146,6 +147,7 @@ func testDASMissingMessage(t *testing.T, storageType string) {
 	var daReader DataAvailabilityServiceReader = storageService
 
 	messageSaved := []byte("hello world")
+	// #nosec G115
 	timeout := uint64(time.Now().Add(time.Hour * 24).Unix())
 	cert, err := daWriter.Store(ctx, messageSaved, timeout)
 	Require(t, err, "Error storing message")
diff --git a/das/dastree/dastree.go b/das/dastree/dastree.go
index d873f05..2bcbcca 100644
--- a/das/dastree/dastree.go
+++ b/das/dastree/dastree.go
@@ -61,12 +61,13 @@ func RecordHash(record func(bytes32, []byte, arbutil.PreimageType), preimage ...
 		return arbmath.FlipBit(keccord(prepend(LeafByte, keccord([]byte{}).Bytes())), 0)
 	}
 
-	length := uint32(len(unrolled))
+	length := len(unrolled)
 	leaves := []node{}
-	for bin := uint32(0); bin < length; bin += BinSize {
+	for bin := 0; bin < length; bin += BinSize {
 		end := arbmath.MinInt(bin+BinSize, length)
 		hash := keccord(prepend(LeafByte, keccord(unrolled[bin:end]).Bytes()))
-		leaves = append(leaves, node{hash, end - bin})
+		// #nosec G115
+		leaves = append(leaves, node{hash, uint32(end - bin)})
 	}
 
 	layer := leaves
@@ -186,7 +187,9 @@ func Content(root bytes32, oracle func(bytes32) ([]byte, error)) ([]byte, error)
 			leaves = append(leaves, leaf)
 		case NodeByte:
 			count := binary.BigEndian.Uint32(data[64:])
-			power := uint32(arbmath.NextOrCurrentPowerOf2(uint64(count)))
+			power := arbmath.NextOrCurrentPowerOf2(uint64(count))
+			// #nosec G115
+			halfPower := uint32(power / 2)
 
 			if place.size != count {
 				return nil, fmt.Errorf("invalid size data: %v vs %v for %v", count, place.size, data)
@@ -194,11 +197,11 @@ func Content(root bytes32, oracle func(bytes32) ([]byte, error)) ([]byte, error)
 
 			prior := node{
 				hash: common.BytesToHash(data[:32]),
-				size: power / 2,
+				size: halfPower,
 			}
 			after := node{
 				hash: common.BytesToHash(data[32:64]),
-				size: count - power/2,
+				size: count - halfPower,
 			}
 
 			// we want to expand leftward so we reverse their order
diff --git a/das/db_storage_service.go b/das/db_storage_service.go
index e3b6183..74bf12b 100644
--- a/das/db_storage_service.go
+++ b/das/db_storage_service.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"os"
 	"path/filepath"
 	"time"
@@ -172,7 +173,8 @@ func (dbs *DBStorageService) Put(ctx context.Context, data []byte, timeout uint6
 
 	return dbs.db.Update(func(txn *badger.Txn) error {
 		e := badger.NewEntry(dastree.HashBytes(data), data)
-		if dbs.discardAfterTimeout {
+		if dbs.discardAfterTimeout && timeout <= math.MaxInt64 {
+			// #nosec G115
 			e = e.WithTTL(time.Until(time.Unix(int64(timeout), 0)))
 		}
 		return txn.SetEntry(e)
@@ -265,6 +267,7 @@ func (dbs *DBStorageService) String() string {
 
 func (dbs *DBStorageService) HealthCheck(ctx context.Context) error {
 	testData := []byte("Test-Data")
+	// #nosec G115
 	err := dbs.Put(ctx, testData, uint64(time.Now().Add(time.Minute).Unix()))
 	if err != nil {
 		return err
diff --git a/das/factory.go b/das/factory.go
index 5742a39..7a7b3fb 100644
--- a/das/factory.go
+++ b/das/factory.go
@@ -7,11 +7,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"math"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
 
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/util/headerreader"
 	"github.com/offchainlabs/nitro/util/signature"
@@ -113,7 +112,7 @@ func CreateBatchPosterDAS(
 	ctx context.Context,
 	config *DataAvailabilityConfig,
 	dataSigner signature.DataSignerFunc,
-	l1Reader arbutil.L1Interface,
+	l1Reader *ethclient.Client,
 	sequencerInboxAddr common.Address,
 ) (DataAvailabilityServiceWriter, DataAvailabilityServiceReader, *KeysetFetcher, *LifecycleManager, error) {
 	if !config.Enable {
@@ -187,12 +186,7 @@ func CreateDAComponentsForDaserver(
 		dasLifecycleManager.Register(restAgg)
 
 		syncConf := &config.RestAggregator.SyncToStorage
-		var retentionPeriodSeconds uint64
-		if uint64(syncConf.RetentionPeriod) == math.MaxUint64 {
-			retentionPeriodSeconds = math.MaxUint64
-		} else {
-			retentionPeriodSeconds = uint64(syncConf.RetentionPeriod.Seconds())
-		}
+		retentionPeriodSeconds := uint64(syncConf.RetentionPeriod.Seconds())
 
 		if syncConf.Eager {
 			if l1Reader == nil || seqInboxAddress == nil {
diff --git a/das/fallback_storage_service.go b/das/fallback_storage_service.go
index 49f961d..0a45167 100644
--- a/das/fallback_storage_service.go
+++ b/das/fallback_storage_service.go
@@ -85,6 +85,7 @@ func (f *FallbackStorageService) GetByHash(ctx context.Context, key common.Hash)
 		}
 		if dastree.ValidHash(key, data) {
 			putErr := f.StorageService.Put(
+				// #nosec G115
 				ctx, data, arbmath.SaturatingUAdd(uint64(time.Now().Unix()), f.backupRetentionSeconds),
 			)
 			if putErr != nil && !f.ignoreRetentionWriteErrors {
diff --git a/das/local_file_storage_service.go b/das/local_file_storage_service.go
index 65ca6fe..5e64c34 100644
--- a/das/local_file_storage_service.go
+++ b/das/local_file_storage_service.go
@@ -9,6 +9,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"os"
 	"path"
 	"path/filepath"
@@ -133,6 +134,10 @@ func (s *LocalFileStorageService) GetByHash(ctx context.Context, key common.Hash
 
 func (s *LocalFileStorageService) Put(ctx context.Context, data []byte, expiry uint64) error {
 	logPut("das.LocalFileStorageService.Store", data, expiry, s)
+	if expiry > math.MaxInt64 {
+		return fmt.Errorf("request expiry time (%v) exceeds max int64", expiry)
+	}
+	// #nosec G115
 	expiryTime := time.Unix(int64(expiry), 0)
 	currentTimePlusRetention := time.Now().Add(s.config.MaxRetention)
 	if expiryTime.After(currentTimePlusRetention) {
@@ -182,6 +187,7 @@ func (s *LocalFileStorageService) Put(ctx context.Context, data []byte, expiry u
 	// new flat layout files, set their modification time accordingly.
 	if s.enableLegacyLayout {
 		tv := syscall.Timeval{
+			// #nosec G115
 			Sec:  int64(expiry - uint64(s.legacyLayout.retention.Seconds())),
 			Usec: 0,
 		}
@@ -371,6 +377,7 @@ func migrate(fl *flatLayout, tl *trieLayout) error {
 				return err
 			}
 
+			// #nosec G115
 			expiryPath := tl.expiryPath(batch.key, uint64(batch.expiry.Unix()))
 			if err = createHardLink(newPath, expiryPath); err != nil {
 				return err
diff --git a/das/local_file_storage_service_test.go b/das/local_file_storage_service_test.go
index cc27e29..8a36664 100644
--- a/das/local_file_storage_service_test.go
+++ b/das/local_file_storage_service_test.go
@@ -78,6 +78,7 @@ func TestMigrationNoExpiry(t *testing.T) {
 	Require(t, err)
 	s.enableLegacyLayout = true
 
+	// #nosec G115
 	now := uint64(time.Now().Unix())
 
 	err = s.Put(ctx, []byte("a"), now+1)
@@ -99,6 +100,7 @@ func TestMigrationNoExpiry(t *testing.T) {
 	getByHashAndCheck(t, s, "a", "b", "c", "d")
 
 	// Can still iterate by timestamp even if expiry disabled
+	// #nosec G115
 	countTimestampEntries(t, &s.layout, time.Unix(int64(now+11), 0), 4)
 
 }
@@ -120,14 +122,19 @@ func TestMigrationExpiry(t *testing.T) {
 	now := time.Now()
 
 	// Use increments of expiry divisor in order to span multiple by-expiry-timestamp dirs
+	// #nosec G115
 	err = s.Put(ctx, []byte("a"), uint64(now.Add(-2*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("b"), uint64(now.Add(-1*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("c"), uint64(now.Add(time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("d"), uint64(now.Add(time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("e"), uint64(now.Add(2*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
 
@@ -170,19 +177,26 @@ func TestExpiryDuplicates(t *testing.T) {
 	now := time.Now()
 
 	// Use increments of expiry divisor in order to span multiple by-expiry-timestamp dirs
+	// #nosec G115
 	err = s.Put(ctx, []byte("a"), uint64(now.Add(-2*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("a"), uint64(now.Add(-1*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("a"), uint64(now.Add(time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("d"), uint64(now.Add(time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("e"), uint64(now.Add(2*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = s.Put(ctx, []byte("f"), uint64(now.Add(3*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
 	// Put the same entry and expiry again, should have no effect
+	// #nosec G115
 	err = s.Put(ctx, []byte("f"), uint64(now.Add(3*time.Second*expiryDivisor).Unix()))
 	Require(t, err)
 
diff --git a/das/redis_storage_service_test.go b/das/redis_storage_service_test.go
index 55f3ecd..77d3e8c 100644
--- a/das/redis_storage_service_test.go
+++ b/das/redis_storage_service_test.go
@@ -16,6 +16,7 @@ import (
 
 func TestRedisStorageService(t *testing.T) {
 	ctx := context.Background()
+	// #nosec G115
 	timeout := uint64(time.Now().Add(time.Hour).Unix())
 	baseStorageService := NewMemoryBackedStorageService(ctx)
 	server, err := miniredis.Run()
diff --git a/das/redundant_storage_test.go b/das/redundant_storage_test.go
index b56f62e..11d3b58 100644
--- a/das/redundant_storage_test.go
+++ b/das/redundant_storage_test.go
@@ -17,6 +17,7 @@ const NumServices = 3
 
 func TestRedundantStorageService(t *testing.T) {
 	ctx := context.Background()
+	// #nosec G115
 	timeout := uint64(time.Now().Add(time.Hour).Unix())
 	services := []StorageService{}
 	for i := 0; i < NumServices; i++ {
diff --git a/das/restful_server_test.go b/das/restful_server_test.go
index 1d36757..e6982f9 100644
--- a/das/restful_server_test.go
+++ b/das/restful_server_test.go
@@ -48,6 +48,7 @@ func TestRestfulClientServer(t *testing.T) {
 	server, port, err := NewRestfulDasServerOnRandomPort(LocalServerAddressForTest, storage)
 	Require(t, err)
 
+	// #nosec G115
 	err = storage.Put(ctx, data, uint64(time.Now().Add(time.Hour).Unix()))
 	Require(t, err)
 
diff --git a/das/rpc_aggregator.go b/das/rpc_aggregator.go
index 24a470b..9cf481e 100644
--- a/das/rpc_aggregator.go
+++ b/das/rpc_aggregator.go
@@ -21,7 +21,7 @@ import (
 	"github.com/offchainlabs/nitro/util/signature"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/ethereum/go-ethereum/ethclient"
 )
 
 type BackendConfig struct {
@@ -83,7 +83,7 @@ func NewRPCAggregator(ctx context.Context, config DataAvailabilityConfig, signer
 	return NewAggregator(ctx, config, services)
 }
 
-func NewRPCAggregatorWithL1Info(config DataAvailabilityConfig, l1client arbutil.L1Interface, seqInboxAddress common.Address, signer signature.DataSignerFunc) (*Aggregator, error) {
+func NewRPCAggregatorWithL1Info(config DataAvailabilityConfig, l1client *ethclient.Client, seqInboxAddress common.Address, signer signature.DataSignerFunc) (*Aggregator, error) {
 	services, err := ParseServices(config.RPCAggregator, signer)
 	if err != nil {
 		return nil, err
@@ -119,7 +119,7 @@ func ParseServices(config AggregatorConfig, signer signature.DataSignerFunc) ([]
 			return nil, err
 		}
 
-		d, err := NewServiceDetails(service, *pubKey, 1<<uint64(i), metricName)
+		d, err := NewServiceDetails(service, *pubKey, 1<<i, metricName)
 		if err != nil {
 			return nil, err
 		}
diff --git a/das/s3_storage_service.go b/das/s3_storage_service.go
index a1de200..d251f12 100644
--- a/das/s3_storage_service.go
+++ b/das/s3_storage_service.go
@@ -8,6 +8,7 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"math"
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
@@ -110,7 +111,8 @@ func (s3s *S3StorageService) Put(ctx context.Context, value []byte, timeout uint
 		Bucket: aws.String(s3s.bucket),
 		Key:    aws.String(s3s.objectPrefix + EncodeStorageServiceKey(dastree.Hash(value))),
 		Body:   bytes.NewReader(value)}
-	if !s3s.discardAfterTimeout {
+	if s3s.discardAfterTimeout && timeout <= math.MaxInt64 {
+		// #nosec G115
 		expires := time.Unix(int64(timeout), 0)
 		putObjectInput.Expires = &expires
 	}
diff --git a/das/s3_storage_service_test.go b/das/s3_storage_service_test.go
index 183b6f9..d7a715b 100644
--- a/das/s3_storage_service_test.go
+++ b/das/s3_storage_service_test.go
@@ -64,6 +64,7 @@ func NewTestS3StorageService(ctx context.Context, s3Config genericconf.S3Config)
 
 func TestS3StorageService(t *testing.T) {
 	ctx := context.Background()
+	// #nosec G115
 	timeout := uint64(time.Now().Add(time.Hour).Unix())
 	s3Service, err := NewTestS3StorageService(ctx, genericconf.DefaultS3Config)
 	Require(t, err)
diff --git a/das/sign_after_store_das_writer.go b/das/sign_after_store_das_writer.go
index 0e31d30..40b0384 100644
--- a/das/sign_after_store_das_writer.go
+++ b/das/sign_after_store_das_writer.go
@@ -105,6 +105,7 @@ func NewSignAfterStoreDASWriter(ctx context.Context, config DataAvailabilityConf
 }
 
 func (d *SignAfterStoreDASWriter) Store(ctx context.Context, message []byte, timeout uint64) (c *daprovider.DataAvailabilityCertificate, err error) {
+	// #nosec G115
 	log.Trace("das.SignAfterStoreDASWriter.Store", "message", pretty.FirstFewBytes(message), "timeout", time.Unix(int64(timeout), 0), "this", d)
 	c = &daprovider.DataAvailabilityCertificate{
 		Timeout:     timeout,
diff --git a/das/simple_das_reader_aggregator.go b/das/simple_das_reader_aggregator.go
index dc6147a..f45c56a 100644
--- a/das/simple_das_reader_aggregator.go
+++ b/das/simple_das_reader_aggregator.go
@@ -50,8 +50,8 @@ var DefaultRestfulClientAggregatorConfig = RestfulClientAggregatorConfig{
 }
 
 type SimpleExploreExploitStrategyConfig struct {
-	ExploreIterations int `koanf:"explore-iterations"`
-	ExploitIterations int `koanf:"exploit-iterations"`
+	ExploreIterations uint32 `koanf:"explore-iterations"`
+	ExploitIterations uint32 `koanf:"exploit-iterations"`
 }
 
 var DefaultSimpleExploreExploitStrategyConfig = SimpleExploreExploitStrategyConfig{
@@ -73,8 +73,8 @@ func RestfulClientAggregatorConfigAddOptions(prefix string, f *flag.FlagSet) {
 }
 
 func SimpleExploreExploitStrategyConfigAddOptions(prefix string, f *flag.FlagSet) {
-	f.Int(prefix+".explore-iterations", DefaultSimpleExploreExploitStrategyConfig.ExploreIterations, "number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode")
-	f.Int(prefix+".exploit-iterations", DefaultSimpleExploreExploitStrategyConfig.ExploitIterations, "number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode")
+	f.Uint32(prefix+".explore-iterations", DefaultSimpleExploreExploitStrategyConfig.ExploreIterations, "number of consecutive GetByHash calls to the aggregator where each call will cause it to randomly select from REST endpoints until one returns successfully, before switching to exploit mode")
+	f.Uint32(prefix+".exploit-iterations", DefaultSimpleExploreExploitStrategyConfig.ExploitIterations, "number of consecutive GetByHash calls to the aggregator where each call will cause it to select from REST endpoints in order of best latency and success rate, before switching to explore mode")
 }
 
 func NewRestfulClientAggregator(ctx context.Context, config *RestfulClientAggregatorConfig) (*SimpleDASReaderAggregator, error) {
@@ -120,8 +120,8 @@ func NewRestfulClientAggregator(ctx context.Context, config *RestfulClientAggreg
 	switch strings.ToLower(config.Strategy) {
 	case "simple-explore-exploit":
 		a.strategy = &simpleExploreExploitStrategy{
-			exploreIterations: uint32(config.SimpleExploreExploitStrategy.ExploreIterations),
-			exploitIterations: uint32(config.SimpleExploreExploitStrategy.ExploitIterations),
+			exploreIterations: config.SimpleExploreExploitStrategy.ExploreIterations,
+			exploitIterations: config.SimpleExploreExploitStrategy.ExploitIterations,
 		}
 	case "testing-sequential":
 		a.strategy = &testingSequentialStrategy{}
diff --git a/das/simple_das_reader_aggregator_test.go b/das/simple_das_reader_aggregator_test.go
index d189568..58f4d99 100644
--- a/das/simple_das_reader_aggregator_test.go
+++ b/das/simple_das_reader_aggregator_test.go
@@ -33,10 +33,13 @@ func TestSimpleDASReaderAggregator(t *testing.T) { //nolint
 	server3, port3, err := NewRestfulDasServerOnRandomPort(LocalServerAddressForTest, storage3)
 	Require(t, err)
 
+	// #nosec G115
 	err = storage1.Put(ctx, data1, uint64(time.Now().Add(time.Hour).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = storage2.Put(ctx, data1, uint64(time.Now().Add(time.Hour).Unix()))
 	Require(t, err)
+	// #nosec G115
 	err = storage3.Put(ctx, data1, uint64(time.Now().Add(time.Hour).Unix()))
 	Require(t, err)
 
@@ -67,6 +70,7 @@ func TestSimpleDASReaderAggregator(t *testing.T) { //nolint
 	data2 := []byte("Testing data that is only on the last REST endpoint.")
 	dataHash2 := dastree.Hash(data2)
 
+	// #nosec G115
 	err = storage3.Put(ctx, data2, uint64(time.Now().Add(time.Hour).Unix()))
 	Require(t, err)
 
diff --git a/das/store_signing_test.go b/das/store_signing_test.go
index a50d1c3..1cb2edf 100644
--- a/das/store_signing_test.go
+++ b/das/store_signing_test.go
@@ -19,6 +19,7 @@ func TestStoreSigning(t *testing.T) {
 	addr := crypto.PubkeyToAddress(privateKey.PublicKey)
 
 	weirdMessage := []byte("The quick brown fox jumped over the lazy dog.")
+	// #nosec G115
 	timeout := uint64(time.Now().Unix())
 
 	signer := signature.DataSignerFromPrivateKey(privateKey)
diff --git a/das/syncing_fallback_storage.go b/das/syncing_fallback_storage.go
index ee0ddc6..0670a29 100644
--- a/das/syncing_fallback_storage.go
+++ b/das/syncing_fallback_storage.go
@@ -17,6 +17,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -105,9 +106,9 @@ type l1SyncService struct {
 	lastBatchAcc   common.Hash
 }
 
-// The original syncing process had a bug, so the file was renamed to cause any mirrors
-// in the wild to re-sync from their configured starting block number.
-const nextBlockNoFilename = "nextBlockNumberV2"
+// The filename has been updated when we have discovered bugs that may have impacted
+// syncing, to cause mirrors to re-sync.
+const nextBlockNoFilename = "nextBlockNumberV3"
 
 func readSyncStateOrDefault(syncDir string, dflt uint64) uint64 {
 	if syncDir == "" {
@@ -193,6 +194,7 @@ func (s *l1SyncService) processBatchDelivered(ctx context.Context, batchDelivere
 	}
 	log.Info("BatchDelivered", "log", batchDeliveredLog, "event", deliveredEvent)
 	storeUntil := arbmath.SaturatingUAdd(deliveredEvent.TimeBounds.MaxTimestamp, uint64(s.config.RetentionPeriod.Seconds()))
+	// #nosec G115
 	if !s.config.SyncExpiredData && storeUntil < uint64(time.Now().Unix()) {
 		// old batch - no need to store
 		return nil
@@ -242,7 +244,7 @@ func FindDASDataFromLog(
 	inboxContract *bridgegen.SequencerInbox,
 	deliveredEvent *bridgegen.SequencerInboxSequencerBatchDelivered,
 	inboxAddr common.Address,
-	l1Client arbutil.L1Interface,
+	l1Client *ethclient.Client,
 	batchDeliveredLog types.Log) ([]byte, error) {
 	data := []byte{}
 	if deliveredEvent.DataLocation == uint8(batchDataSeparateEvent) {
diff --git a/das/util.go b/das/util.go
index de266c4..114e075 100644
--- a/das/util.go
+++ b/das/util.go
@@ -13,11 +13,13 @@ import (
 
 func logPut(store string, data []byte, timeout uint64, reader daprovider.DASReader, more ...interface{}) {
 	if len(more) == 0 {
+		// #nosec G115
 		log.Trace(
 			store, "message", pretty.FirstFewBytes(data), "timeout", time.Unix(int64(timeout), 0),
 			"this", reader,
 		)
 	} else {
+		// #nosec G115
 		log.Trace(
 			store, "message", pretty.FirstFewBytes(data), "timeout", time.Unix(int64(timeout), 0),
 			"this", reader, more,
diff --git a/deploy/deploy.go b/deploy/deploy.go
index 5e7755c..bb4b2e6 100644
--- a/deploy/deploy.go
+++ b/deploy/deploy.go
@@ -20,59 +20,67 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 )
 
-func andTxSucceeded(ctx context.Context, l1Reader *headerreader.HeaderReader, tx *types.Transaction, err error) error {
+func andTxSucceeded(ctx context.Context, parentChainReader *headerreader.HeaderReader, tx *types.Transaction, err error) error {
 	if err != nil {
 		return fmt.Errorf("error submitting tx: %w", err)
 	}
-	_, err = l1Reader.WaitForTxApproval(ctx, tx)
+	_, err = parentChainReader.WaitForTxApproval(ctx, tx)
 	if err != nil {
 		return fmt.Errorf("error executing tx: %w", err)
 	}
 	return nil
 }
 
-func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, isUsingFeeToken bool) (common.Address, error) {
-	client := l1Reader.Client()
+func deployBridgeCreator(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, chainSupportsBlobs bool) (common.Address, error) {
+	client := parentChainReader.Client()
 
 	/// deploy eth based templates
 	bridgeTemplate, tx, _, err := bridgegen.DeployBridge(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge deploy error: %w", err)
 	}
 
-	reader4844, tx, _, err := yulgen.DeployReader4844(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	var reader4844 common.Address
+	if chainSupportsBlobs {
+		reader4844, tx, _, err = yulgen.DeployReader4844(auth, client)
+		err = andTxSucceeded(ctx, parentChainReader, tx, err)
+		if err != nil {
+			return common.Address{}, fmt.Errorf("blob basefee reader deploy error: %w", err)
+		}
+	}
+	seqInboxTemplateEthBased, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, false)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
-		return common.Address{}, fmt.Errorf("blob basefee reader deploy error: %w", err)
+		return common.Address{}, fmt.Errorf("sequencer inbox eth based deploy error: %w", err)
 	}
-	seqInboxTemplate, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, isUsingFeeToken)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	seqInboxTemplateERC20Based, tx, _, err := bridgegen.DeploySequencerInbox(auth, client, maxDataSize, reader4844, true)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
-		return common.Address{}, fmt.Errorf("sequencer inbox deploy error: %w", err)
+		return common.Address{}, fmt.Errorf("sequencer inbox erc20 based deploy error: %w", err)
 	}
 
 	inboxTemplate, tx, _, err := bridgegen.DeployInbox(auth, client, maxDataSize)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("inbox deploy error: %w", err)
 	}
 
 	rollupEventBridgeTemplate, tx, _, err := rollupgen.DeployRollupEventInbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("rollup event bridge deploy error: %w", err)
 	}
 
 	outboxTemplate, tx, _, err := bridgegen.DeployOutbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("outbox deploy error: %w", err)
 	}
 
 	ethBasedTemplates := rollupgen.BridgeCreatorBridgeContracts{
 		Bridge:           bridgeTemplate,
-		SequencerInbox:   seqInboxTemplate,
+		SequencerInbox:   seqInboxTemplateEthBased,
 		Inbox:            inboxTemplate,
 		RollupEventInbox: rollupEventBridgeTemplate,
 		Outbox:           outboxTemplate,
@@ -80,39 +88,39 @@ func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 
 	/// deploy ERC20 based templates
 	erc20BridgeTemplate, tx, _, err := bridgegen.DeployERC20Bridge(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge deploy error: %w", err)
 	}
 
 	erc20InboxTemplate, tx, _, err := bridgegen.DeployERC20Inbox(auth, client, maxDataSize)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("inbox deploy error: %w", err)
 	}
 
 	erc20RollupEventBridgeTemplate, tx, _, err := rollupgen.DeployERC20RollupEventInbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("rollup event bridge deploy error: %w", err)
 	}
 
 	erc20OutboxTemplate, tx, _, err := bridgegen.DeployERC20Outbox(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("outbox deploy error: %w", err)
 	}
 
 	erc20BasedTemplates := rollupgen.BridgeCreatorBridgeContracts{
 		Bridge:           erc20BridgeTemplate,
-		SequencerInbox:   seqInboxTemplate,
+		SequencerInbox:   seqInboxTemplateERC20Based,
 		Inbox:            erc20InboxTemplate,
 		RollupEventInbox: erc20RollupEventBridgeTemplate,
 		Outbox:           erc20OutboxTemplate,
 	}
 
 	bridgeCreatorAddr, tx, _, err := rollupgen.DeployBridgeCreator(auth, client, ethBasedTemplates, erc20BasedTemplates)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("bridge creator deploy error: %w", err)
 	}
@@ -120,40 +128,40 @@ func deployBridgeCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 	return bridgeCreatorAddr, nil
 }
 
-func deployChallengeFactory(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts) (common.Address, common.Address, error) {
-	client := l1Reader.Client()
+func deployChallengeFactory(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts) (common.Address, common.Address, error) {
+	client := parentChainReader.Client()
 	osp0, tx, _, err := ospgen.DeployOneStepProver0(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("osp0 deploy error: %w", err)
 	}
 
 	ospMem, tx, _, err := ospgen.DeployOneStepProverMemory(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospMemory deploy error: %w", err)
 	}
 
 	ospMath, tx, _, err := ospgen.DeployOneStepProverMath(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospMath deploy error: %w", err)
 	}
 
 	ospHostIo, tx, _, err := ospgen.DeployOneStepProverHostIo(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospHostIo deploy error: %w", err)
 	}
 
 	challengeManagerAddr, tx, _, err := challengegen.DeployChallengeManager(auth, client)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("challenge manager deploy error: %w", err)
 	}
 
 	ospEntryAddr, tx, _, err := ospgen.DeployOneStepProofEntry(auth, client, osp0, ospMem, ospMath, ospHostIo)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return common.Address{}, common.Address{}, fmt.Errorf("ospEntry deploy error: %w", err)
 	}
@@ -161,55 +169,55 @@ func deployChallengeFactory(ctx context.Context, l1Reader *headerreader.HeaderRe
 	return ospEntryAddr, challengeManagerAddr, nil
 }
 
-func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, isUsingFeeToken bool) (*rollupgen.RollupCreator, common.Address, common.Address, common.Address, error) {
-	bridgeCreator, err := deployBridgeCreator(ctx, l1Reader, auth, maxDataSize, isUsingFeeToken)
+func deployRollupCreator(ctx context.Context, parentChainReader *headerreader.HeaderReader, auth *bind.TransactOpts, maxDataSize *big.Int, chainSupportsBlobs bool) (*rollupgen.RollupCreator, common.Address, common.Address, common.Address, error) {
+	bridgeCreator, err := deployBridgeCreator(ctx, parentChainReader, auth, maxDataSize, chainSupportsBlobs)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("bridge creator deploy error: %w", err)
 	}
 
-	ospEntryAddr, challengeManagerAddr, err := deployChallengeFactory(ctx, l1Reader, auth)
+	ospEntryAddr, challengeManagerAddr, err := deployChallengeFactory(ctx, parentChainReader, auth)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, err
 	}
 
-	rollupAdminLogic, tx, _, err := rollupgen.DeployRollupAdminLogic(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupAdminLogic, tx, _, err := rollupgen.DeployRollupAdminLogic(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup admin logic deploy error: %w", err)
 	}
 
-	rollupUserLogic, tx, _, err := rollupgen.DeployRollupUserLogic(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupUserLogic, tx, _, err := rollupgen.DeployRollupUserLogic(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup user logic deploy error: %w", err)
 	}
 
-	rollupCreatorAddress, tx, rollupCreator, err := rollupgen.DeployRollupCreator(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	rollupCreatorAddress, tx, rollupCreator, err := rollupgen.DeployRollupCreator(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup creator deploy error: %w", err)
 	}
 
-	upgradeExecutor, tx, _, err := upgrade_executorgen.DeployUpgradeExecutor(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	upgradeExecutor, tx, _, err := upgrade_executorgen.DeployUpgradeExecutor(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("upgrade executor deploy error: %w", err)
 	}
 
-	validatorUtils, tx, _, err := rollupgen.DeployValidatorUtils(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	validatorUtils, tx, _, err := rollupgen.DeployValidatorUtils(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("validator utils deploy error: %w", err)
 	}
 
-	validatorWalletCreator, tx, _, err := rollupgen.DeployValidatorWalletCreator(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	validatorWalletCreator, tx, _, err := rollupgen.DeployValidatorWalletCreator(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("validator wallet creator deploy error: %w", err)
 	}
 
-	l2FactoriesDeployHelper, tx, _, err := rollupgen.DeployDeployHelper(auth, l1Reader.Client())
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	l2FactoriesDeployHelper, tx, _, err := rollupgen.DeployDeployHelper(auth, parentChainReader.Client())
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("deploy helper creator deploy error: %w", err)
 	}
@@ -226,7 +234,7 @@ func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 		validatorWalletCreator,
 		l2FactoriesDeployHelper,
 	)
-	err = andTxSucceeded(ctx, l1Reader, tx, err)
+	err = andTxSucceeded(ctx, parentChainReader, tx, err)
 	if err != nil {
 		return nil, common.Address{}, common.Address{}, common.Address{}, fmt.Errorf("rollup set template error: %w", err)
 	}
@@ -234,12 +242,12 @@ func deployRollupCreator(ctx context.Context, l1Reader *headerreader.HeaderReade
 	return rollupCreator, rollupCreatorAddress, validatorUtils, validatorWalletCreator, nil
 }
 
-func DeployOnL1(ctx context.Context, parentChainReader *headerreader.HeaderReader, deployAuth *bind.TransactOpts, batchPosters []common.Address, batchPosterManager common.Address, authorizeValidators uint64, config rollupgen.Config, nativeToken common.Address, maxDataSize *big.Int, isUsingFeeToken bool) (*chaininfo.RollupAddresses, error) {
+func DeployOnParentChain(ctx context.Context, parentChainReader *headerreader.HeaderReader, deployAuth *bind.TransactOpts, batchPosters []common.Address, batchPosterManager common.Address, authorizeValidators uint64, config rollupgen.Config, nativeToken common.Address, maxDataSize *big.Int, chainSupportsBlobs bool) (*chaininfo.RollupAddresses, error) {
 	if config.WasmModuleRoot == (common.Hash{}) {
 		return nil, errors.New("no machine specified")
 	}
 
-	rollupCreator, _, validatorUtils, validatorWalletCreator, err := deployRollupCreator(ctx, parentChainReader, deployAuth, maxDataSize, isUsingFeeToken)
+	rollupCreator, _, validatorUtils, validatorWalletCreator, err := deployRollupCreator(ctx, parentChainReader, deployAuth, maxDataSize, chainSupportsBlobs)
 	if err != nil {
 		return nil, fmt.Errorf("error deploying rollup creator: %w", err)
 	}
diff --git a/execution/gethexec/api.go b/execution/gethexec/api.go
index c19072a..4fa6069 100644
--- a/execution/gethexec/api.go
+++ b/execution/gethexec/api.go
@@ -78,6 +78,7 @@ func (api *ArbDebugAPI) evenlySpaceBlocks(start, end rpc.BlockNumber) (uint64, u
 	end, _ = api.blockchain.ClipToPostNitroGenesis(end)
 
 	blocks := end.Int64() - start.Int64() + 1
+	// #nosec G115
 	bound := int64(api.blockRangeBound)
 	step := int64(1)
 	if blocks > bound {
@@ -88,7 +89,9 @@ func (api *ArbDebugAPI) evenlySpaceBlocks(start, end rpc.BlockNumber) (uint64, u
 		return 0, 0, 0, 0, fmt.Errorf("invalid block range: %v to %v", start.Int64(), end.Int64())
 	}
 
+	// #nosec G115
 	first := uint64(end.Int64() - step*(blocks-1)) // minus 1 to include the fact that we start from the last
+	// #nosec G115
 	return first, uint64(step), uint64(end), uint64(blocks), nil
 }
 
@@ -222,11 +225,13 @@ func (api *ArbDebugAPI) TimeoutQueue(ctx context.Context, blockNum rpc.BlockNumb
 	blockNum, _ = api.blockchain.ClipToPostNitroGenesis(blockNum)
 
 	queue := TimeoutQueue{
+		// #nosec G115
 		BlockNumber: uint64(blockNum),
 		Tickets:     []common.Hash{},
 		Timeouts:    []uint64{},
 	}
 
+	// #nosec G115
 	state, _, err := stateAndHeader(api.blockchain, uint64(blockNum))
 	if err != nil {
 		return queue, err
diff --git a/execution/gethexec/block_recorder.go b/execution/gethexec/block_recorder.go
index 8879c90..a31b6b3 100644
--- a/execution/gethexec/block_recorder.go
+++ b/execution/gethexec/block_recorder.go
@@ -16,6 +16,7 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/execution"
+	flag "github.com/spf13/pflag"
 )
 
 // BlockRecorder uses a separate statedatabase from the blockchain.
@@ -25,6 +26,8 @@ import (
 // Most recent/advanced header we ever computed (lastHdr)
 // Hopefully - some recent valid block. For that we always keep one candidate block until it becomes validated.
 type BlockRecorder struct {
+	config *BlockRecorderConfig
+
 	recordingDatabase *arbitrum.RecordingDatabase
 	execEngine        *ExecutionEngine
 
@@ -39,10 +42,33 @@ type BlockRecorder struct {
 	preparedLock  sync.Mutex
 }
 
-func NewBlockRecorder(config *arbitrum.RecordingDatabaseConfig, execEngine *ExecutionEngine, ethDb ethdb.Database) *BlockRecorder {
+type BlockRecorderConfig struct {
+	TrieDirtyCache int `koanf:"trie-dirty-cache"`
+	TrieCleanCache int `koanf:"trie-clean-cache"`
+	MaxPrepared    int `koanf:"max-prepared"`
+}
+
+var DefaultBlockRecorderConfig = BlockRecorderConfig{
+	TrieDirtyCache: 1024,
+	TrieCleanCache: 16,
+	MaxPrepared:    1000,
+}
+
+func BlockRecorderConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.Int(prefix+".trie-dirty-cache", DefaultBlockRecorderConfig.TrieDirtyCache, "like trie-dirty-cache for the separate, recording database (used for validation)")
+	f.Int(prefix+".trie-clean-cache", DefaultBlockRecorderConfig.TrieCleanCache, "like trie-clean-cache for the separate, recording database (used for validation)")
+	f.Int(prefix+".max-prepared", DefaultBlockRecorderConfig.MaxPrepared, "max references to store in the recording database")
+}
+
+func NewBlockRecorder(config *BlockRecorderConfig, execEngine *ExecutionEngine, ethDb ethdb.Database) *BlockRecorder {
+	dbConfig := arbitrum.RecordingDatabaseConfig{
+		TrieDirtyCache: config.TrieDirtyCache,
+		TrieCleanCache: config.TrieCleanCache,
+	}
 	recorder := &BlockRecorder{
+		config:            config,
 		execEngine:        execEngine,
-		recordingDatabase: arbitrum.NewRecordingDatabase(config, ethDb, execEngine.bc),
+		recordingDatabase: arbitrum.NewRecordingDatabase(&dbConfig, ethDb, execEngine.bc),
 	}
 	execEngine.SetRecorder(recorder)
 	return recorder
@@ -303,7 +329,7 @@ func (r *BlockRecorder) PrepareForRecord(ctx context.Context, start, end arbutil
 		r.updateLastHdr(header)
 		hdrNum++
 	}
-	r.preparedAddTrim(references, 1000)
+	r.preparedAddTrim(references, r.config.MaxPrepared)
 	return nil
 }
 
diff --git a/execution/gethexec/blockchain.go b/execution/gethexec/blockchain.go
index 996b87a..9b0c1a6 100644
--- a/execution/gethexec/blockchain.go
+++ b/execution/gethexec/blockchain.go
@@ -37,7 +37,7 @@ type CachingConfig struct {
 	SnapshotRestoreGasLimit            uint64        `koanf:"snapshot-restore-gas-limit"`
 	MaxNumberOfBlocksToSkipStateSaving uint32        `koanf:"max-number-of-blocks-to-skip-state-saving"`
 	MaxAmountOfGasToSkipStateSaving    uint64        `koanf:"max-amount-of-gas-to-skip-state-saving"`
-	StylusLRUCache                     uint32        `koanf:"stylus-lru-cache"`
+	StylusLRUCacheCapacity             uint32        `koanf:"stylus-lru-cache-capacity"`
 	StateScheme                        string        `koanf:"state-scheme"`
 	StateHistory                       uint64        `koanf:"state-history"`
 }
@@ -54,12 +54,13 @@ func CachingConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Uint64(prefix+".snapshot-restore-gas-limit", DefaultCachingConfig.SnapshotRestoreGasLimit, "maximum gas rolled back to recover snapshot")
 	f.Uint32(prefix+".max-number-of-blocks-to-skip-state-saving", DefaultCachingConfig.MaxNumberOfBlocksToSkipStateSaving, "maximum number of blocks to skip state saving to persistent storage (archive node only) -- warning: this option seems to cause issues")
 	f.Uint64(prefix+".max-amount-of-gas-to-skip-state-saving", DefaultCachingConfig.MaxAmountOfGasToSkipStateSaving, "maximum amount of gas in blocks to skip saving state to Persistent storage (archive node only) -- warning: this option seems to cause issues")
-	f.Uint32(prefix+".stylus-lru-cache", DefaultCachingConfig.StylusLRUCache, "initialized stylus programs to keep in LRU cache")
+	f.Uint32(prefix+".stylus-lru-cache-capacity", DefaultCachingConfig.StylusLRUCacheCapacity, "capacity, in megabytes, of the LRU cache that keeps initialized stylus programs")
 	f.String(prefix+".state-scheme", DefaultCachingConfig.StateScheme, "scheme to use for state trie storage (hash, path)")
 	f.Uint64(prefix+".state-history", DefaultCachingConfig.StateHistory, "number of recent blocks to retain state history for (path state-scheme only)")
 }
 
 func getStateHistory(maxBlockSpeed time.Duration) uint64 {
+	// #nosec G115
 	return uint64(24 * time.Hour / maxBlockSpeed)
 }
 
@@ -75,7 +76,7 @@ var DefaultCachingConfig = CachingConfig{
 	SnapshotRestoreGasLimit:            300_000_000_000,
 	MaxNumberOfBlocksToSkipStateSaving: 0,
 	MaxAmountOfGasToSkipStateSaving:    0,
-	StylusLRUCache:                     256,
+	StylusLRUCacheCapacity:             256,
 	StateScheme:                        rawdb.HashScheme,
 	StateHistory:                       getStateHistory(DefaultSequencerConfig.MaxBlockSpeed),
 }
diff --git a/execution/gethexec/executionengine.go b/execution/gethexec/executionengine.go
index d8a5927..a0f3a2f 100644
--- a/execution/gethexec/executionengine.go
+++ b/execution/gethexec/executionengine.go
@@ -7,7 +7,7 @@
 package gethexec
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 */
@@ -27,6 +27,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
@@ -137,7 +138,7 @@ func (s *ExecutionEngine) MarkFeedStart(to arbutil.MessageIndex) {
 	defer s.cachedL1PriceData.mutex.Unlock()
 
 	if to < s.cachedL1PriceData.startOfL1PriceDataCache {
-		log.Info("trying to trim older cache which doesnt exist anymore")
+		log.Debug("trying to trim older L1 price data cache which doesnt exist anymore")
 	} else if to >= s.cachedL1PriceData.endOfL1PriceDataCache {
 		s.cachedL1PriceData.startOfL1PriceDataCache = 0
 		s.cachedL1PriceData.endOfL1PriceDataCache = 0
@@ -149,10 +150,46 @@ func (s *ExecutionEngine) MarkFeedStart(to arbutil.MessageIndex) {
 	}
 }
 
-func (s *ExecutionEngine) Initialize(rustCacheSize uint32) {
-	if rustCacheSize != 0 {
-		programs.ResizeWasmLruCache(rustCacheSize)
+func PopulateStylusTargetCache(targetConfig *StylusTargetConfig) error {
+	localTarget := rawdb.LocalTarget()
+	targets := targetConfig.WasmTargets()
+	var nativeSet bool
+	for _, target := range targets {
+		var effectiveStylusTarget string
+		switch target {
+		case rawdb.TargetWavm:
+			// skip wavm target
+			continue
+		case rawdb.TargetArm64:
+			effectiveStylusTarget = targetConfig.Arm64
+		case rawdb.TargetAmd64:
+			effectiveStylusTarget = targetConfig.Amd64
+		case rawdb.TargetHost:
+			effectiveStylusTarget = targetConfig.Host
+		default:
+			return fmt.Errorf("unsupported stylus target: %v", target)
+		}
+		isNative := target == localTarget
+		err := programs.SetTarget(target, effectiveStylusTarget, isNative)
+		if err != nil {
+			return fmt.Errorf("failed to set stylus target: %w", err)
+		}
+		nativeSet = nativeSet || isNative
+	}
+	if !nativeSet {
+		return fmt.Errorf("local target %v missing in list of archs %v", localTarget, targets)
 	}
+	return nil
+}
+
+func (s *ExecutionEngine) Initialize(rustCacheCapacityMB uint32, targetConfig *StylusTargetConfig) error {
+	if rustCacheCapacityMB != 0 {
+		programs.SetWasmLruCacheCapacity(arbmath.SaturatingUMul(uint64(rustCacheCapacityMB), 1024*1024))
+	}
+	if err := PopulateStylusTargetCache(targetConfig); err != nil {
+		return fmt.Errorf("error populating stylus target cache: %w", err)
+	}
+	return nil
 }
 
 func (s *ExecutionEngine) SetRecorder(recorder *BlockRecorder) {
@@ -926,4 +963,15 @@ func (s *ExecutionEngine) Start(ctx_in context.Context) {
 			}
 		}
 	})
+	// periodically update stylus lru cache metrics
+	s.LaunchThread(func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-time.After(time.Minute):
+				programs.GetWasmLruCacheMetrics()
+			}
+		}
+	})
 }
diff --git a/execution/gethexec/node.go b/execution/gethexec/node.go
index af40b4b..cb06a58 100644
--- a/execution/gethexec/node.go
+++ b/execution/gethexec/node.go
@@ -5,20 +5,24 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"sort"
 	"sync/atomic"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/arbitrum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/eth"
 	"github.com/ethereum/go-ethereum/eth/filters"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
+	"github.com/offchainlabs/nitro/arbos/programs"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/execution"
 	"github.com/offchainlabs/nitro/solgen/go/precompilesgen"
@@ -27,19 +31,73 @@ import (
 	flag "github.com/spf13/pflag"
 )
 
+type StylusTargetConfig struct {
+	Arm64      string   `koanf:"arm64"`
+	Amd64      string   `koanf:"amd64"`
+	Host       string   `koanf:"host"`
+	ExtraArchs []string `koanf:"extra-archs"`
+
+	wasmTargets []ethdb.WasmTarget
+}
+
+func (c *StylusTargetConfig) WasmTargets() []ethdb.WasmTarget {
+	return c.wasmTargets
+}
+
+func (c *StylusTargetConfig) Validate() error {
+	targetsSet := make(map[ethdb.WasmTarget]bool, len(c.ExtraArchs))
+	for _, arch := range c.ExtraArchs {
+		target := ethdb.WasmTarget(arch)
+		if !rawdb.IsSupportedWasmTarget(target) {
+			return fmt.Errorf("unsupported architecture: %v, possible values: %s, %s, %s, %s", arch, rawdb.TargetWavm, rawdb.TargetArm64, rawdb.TargetAmd64, rawdb.TargetHost)
+		}
+		targetsSet[target] = true
+	}
+	if !targetsSet[rawdb.TargetWavm] {
+		return fmt.Errorf("%s target not found in archs list, archs: %v", rawdb.TargetWavm, c.ExtraArchs)
+	}
+	targetsSet[rawdb.LocalTarget()] = true
+	targets := make([]ethdb.WasmTarget, 0, len(c.ExtraArchs)+1)
+	for target := range targetsSet {
+		targets = append(targets, target)
+	}
+	sort.Slice(
+		targets,
+		func(i, j int) bool {
+			return targets[i] < targets[j]
+		})
+	c.wasmTargets = targets
+	return nil
+}
+
+var DefaultStylusTargetConfig = StylusTargetConfig{
+	Arm64:      programs.DefaultTargetDescriptionArm,
+	Amd64:      programs.DefaultTargetDescriptionX86,
+	Host:       "",
+	ExtraArchs: []string{string(rawdb.TargetWavm)},
+}
+
+func StylusTargetConfigAddOptions(prefix string, f *flag.FlagSet) {
+	f.String(prefix+".arm64", DefaultStylusTargetConfig.Arm64, "stylus programs compilation target for arm64 linux")
+	f.String(prefix+".amd64", DefaultStylusTargetConfig.Amd64, "stylus programs compilation target for amd64 linux")
+	f.String(prefix+".host", DefaultStylusTargetConfig.Host, "stylus programs compilation target for system other than 64-bit ARM or 64-bit x86")
+	f.StringSlice(prefix+".extra-archs", DefaultStylusTargetConfig.ExtraArchs, fmt.Sprintf("Comma separated list of extra architectures to cross-compile stylus program to and cache in wasm store (additionally to local target). Currently must include at least %s. (supported targets: %s, %s, %s, %s)", rawdb.TargetWavm, rawdb.TargetWavm, rawdb.TargetArm64, rawdb.TargetAmd64, rawdb.TargetHost))
+}
+
 type Config struct {
-	ParentChainReader         headerreader.Config              `koanf:"parent-chain-reader" reload:"hot"`
-	Sequencer                 SequencerConfig                  `koanf:"sequencer" reload:"hot"`
-	RecordingDatabase         arbitrum.RecordingDatabaseConfig `koanf:"recording-database"`
-	TxPreChecker              TxPreCheckerConfig               `koanf:"tx-pre-checker" reload:"hot"`
-	Forwarder                 ForwarderConfig                  `koanf:"forwarder"`
-	ForwardingTarget          string                           `koanf:"forwarding-target"`
-	SecondaryForwardingTarget []string                         `koanf:"secondary-forwarding-target"`
-	Caching                   CachingConfig                    `koanf:"caching"`
-	RPC                       arbitrum.Config                  `koanf:"rpc"`
-	TxLookupLimit             uint64                           `koanf:"tx-lookup-limit"`
-	EnablePrefetchBlock       bool                             `koanf:"enable-prefetch-block"`
-	SyncMonitor               SyncMonitorConfig                `koanf:"sync-monitor"`
+	ParentChainReader         headerreader.Config `koanf:"parent-chain-reader" reload:"hot"`
+	Sequencer                 SequencerConfig     `koanf:"sequencer" reload:"hot"`
+	RecordingDatabase         BlockRecorderConfig `koanf:"recording-database"`
+	TxPreChecker              TxPreCheckerConfig  `koanf:"tx-pre-checker" reload:"hot"`
+	Forwarder                 ForwarderConfig     `koanf:"forwarder"`
+	ForwardingTarget          string              `koanf:"forwarding-target"`
+	SecondaryForwardingTarget []string            `koanf:"secondary-forwarding-target"`
+	Caching                   CachingConfig       `koanf:"caching"`
+	RPC                       arbitrum.Config     `koanf:"rpc"`
+	TxLookupLimit             uint64              `koanf:"tx-lookup-limit"`
+	EnablePrefetchBlock       bool                `koanf:"enable-prefetch-block"`
+	SyncMonitor               SyncMonitorConfig   `koanf:"sync-monitor"`
+	StylusTarget              StylusTargetConfig  `koanf:"stylus-target"`
 
 	forwardingTarget string
 }
@@ -62,6 +120,9 @@ func (c *Config) Validate() error {
 	if c.forwardingTarget != "" && c.Sequencer.Enable {
 		return errors.New("ForwardingTarget set and sequencer enabled")
 	}
+	if err := c.StylusTarget.Validate(); err != nil {
+		return err
+	}
 	return nil
 }
 
@@ -69,7 +130,7 @@ func ConfigAddOptions(prefix string, f *flag.FlagSet) {
 	arbitrum.ConfigAddOptions(prefix+".rpc", f)
 	SequencerConfigAddOptions(prefix+".sequencer", f)
 	headerreader.AddOptions(prefix+".parent-chain-reader", f)
-	arbitrum.RecordingDatabaseConfigAddOptions(prefix+".recording-database", f)
+	BlockRecorderConfigAddOptions(prefix+".recording-database", f)
 	f.String(prefix+".forwarding-target", ConfigDefault.ForwardingTarget, "transaction forwarding target URL, or \"null\" to disable forwarding (iff not sequencer)")
 	f.StringSlice(prefix+".secondary-forwarding-target", ConfigDefault.SecondaryForwardingTarget, "secondary transaction forwarding target URL")
 	AddOptionsForNodeForwarderConfig(prefix+".forwarder", f)
@@ -78,13 +139,14 @@ func ConfigAddOptions(prefix string, f *flag.FlagSet) {
 	SyncMonitorConfigAddOptions(prefix+".sync-monitor", f)
 	f.Uint64(prefix+".tx-lookup-limit", ConfigDefault.TxLookupLimit, "retain the ability to lookup transactions by hash for the past N blocks (0 = all blocks)")
 	f.Bool(prefix+".enable-prefetch-block", ConfigDefault.EnablePrefetchBlock, "enable prefetching of blocks")
+	StylusTargetConfigAddOptions(prefix+".stylus-target", f)
 }
 
 var ConfigDefault = Config{
 	RPC:                       arbitrum.DefaultConfig,
 	Sequencer:                 DefaultSequencerConfig,
 	ParentChainReader:         headerreader.DefaultConfig,
-	RecordingDatabase:         arbitrum.DefaultRecordingDatabaseConfig,
+	RecordingDatabase:         DefaultBlockRecorderConfig,
 	ForwardingTarget:          "",
 	SecondaryForwardingTarget: []string{},
 	TxPreChecker:              DefaultTxPreCheckerConfig,
@@ -92,6 +154,7 @@ var ConfigDefault = Config{
 	Caching:                   DefaultCachingConfig,
 	Forwarder:                 DefaultNodeForwarderConfig,
 	EnablePrefetchBlock:       true,
+	StylusTarget:              DefaultStylusTargetConfig,
 }
 
 type ConfigFetcher func() *Config
@@ -117,7 +180,7 @@ func CreateExecutionNode(
 	stack *node.Node,
 	chainDB ethdb.Database,
 	l2BlockChain *core.BlockChain,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 	configFetcher ConfigFetcher,
 ) (*ExecutionNode, error) {
 	config := configFetcher()
@@ -251,9 +314,13 @@ func (n *ExecutionNode) MarkFeedStart(to arbutil.MessageIndex) {
 }
 
 func (n *ExecutionNode) Initialize(ctx context.Context) error {
-	n.ExecEngine.Initialize(n.ConfigFetcher().Caching.StylusLRUCache)
+	config := n.ConfigFetcher()
+	err := n.ExecEngine.Initialize(config.Caching.StylusLRUCacheCapacity, &config.StylusTarget)
+	if err != nil {
+		return fmt.Errorf("error initializing execution engine: %w", err)
+	}
 	n.ArbInterface.Initialize(n)
-	err := n.Backend.Start()
+	err = n.Backend.Start()
 	if err != nil {
 		return fmt.Errorf("error starting geth backend: %w", err)
 	}
diff --git a/execution/gethexec/sequencer.go b/execution/gethexec/sequencer.go
index 90e3082..cc98c79 100644
--- a/execution/gethexec/sequencer.go
+++ b/execution/gethexec/sequencer.go
@@ -887,11 +887,12 @@ func (s *Sequencer) createBlock(ctx context.Context) (returnValue bool) {
 		for _, queueItem := range queueItems {
 			s.txRetryQueue.Push(queueItem)
 		}
+		// #nosec G115
 		log.Error(
 			"cannot sequence: unknown L1 block or L1 timestamp too far from local clock time",
 			"l1Block", l1Block,
 			"l1Timestamp", time.Unix(int64(l1Timestamp), 0),
-			"localTimestamp", time.Unix(int64(timestamp), 0),
+			"localTimestamp", time.Unix(timestamp, 0),
 		)
 		return true
 	}
@@ -900,7 +901,7 @@ func (s *Sequencer) createBlock(ctx context.Context) (returnValue bool) {
 		Kind:        arbostypes.L1MessageType_L2Message,
 		Poster:      l1pricing.BatchPosterAddress,
 		BlockNumber: l1Block,
-		Timestamp:   uint64(timestamp),
+		Timestamp:   arbmath.SaturatingUCast[uint64](timestamp),
 		RequestId:   nil,
 		L1BaseFee:   nil,
 	}
@@ -1037,10 +1038,14 @@ func (s *Sequencer) updateExpectedSurplus(ctx context.Context) (int64, error) {
 	if err != nil {
 		return 0, fmt.Errorf("error encountered getting l1 pricing surplus while updating expectedSurplus: %w", err)
 	}
+	// #nosec G115
 	backlogL1GasCharged := int64(s.execEngine.backlogL1GasCharged())
+	// #nosec G115
 	backlogCallDataUnits := int64(s.execEngine.backlogCallDataUnits())
+	// #nosec G115
 	expectedSurplus := int64(surplus) + backlogL1GasCharged - backlogCallDataUnits*int64(l1GasPrice)
 	// update metrics
+	// #nosec G115
 	l1GasPriceGauge.Update(int64(l1GasPrice))
 	callDataUnitsBacklogGauge.Update(backlogCallDataUnits)
 	unusedL1GasChargeGauge.Update(backlogL1GasCharged)
diff --git a/execution/gethexec/stylus_tracer.go b/execution/gethexec/stylus_tracer.go
new file mode 100644
index 0000000..4c18bb2
--- /dev/null
+++ b/execution/gethexec/stylus_tracer.go
@@ -0,0 +1,199 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+package gethexec
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"math/big"
+	"strings"
+	"sync/atomic"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/eth/tracers"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/offchainlabs/nitro/util/containers"
+)
+
+func init() {
+	tracers.DefaultDirectory.Register("stylusTracer", newStylusTracer, false)
+}
+
+// stylusTracer captures Stylus HostIOs and returns them in a structured format to be used in Cargo
+// Stylus Replay.
+type stylusTracer struct {
+	open      *containers.Stack[HostioTraceInfo]
+	stack     *containers.Stack[*containers.Stack[HostioTraceInfo]]
+	interrupt atomic.Bool
+	reason    error
+}
+
+// HostioTraceInfo contains the captured HostIO log returned by stylusTracer.
+type HostioTraceInfo struct {
+	// Name of the HostIO.
+	Name string `json:"name"`
+
+	// Arguments of the HostIO encoded as binary.
+	// For details about the encoding check the HostIO implemenation on
+	// arbitrator/wasm-libraries/user-host-trait.
+	Args hexutil.Bytes `json:"args"`
+
+	// Outputs of the HostIO encoded as binary.
+	// For details about the encoding check the HostIO implemenation on
+	// arbitrator/wasm-libraries/user-host-trait.
+	Outs hexutil.Bytes `json:"outs"`
+
+	// Amount of Ink before executing the HostIO.
+	StartInk uint64 `json:"startInk"`
+
+	// Amount of Ink after executing the HostIO.
+	EndInk uint64 `json:"endInk"`
+
+	// For *call HostIOs, the address of the called contract.
+	Address *common.Address `json:"address,omitempty"`
+
+	// For *call HostIOs, the steps performed by the called contract.
+	Steps *containers.Stack[HostioTraceInfo] `json:"steps,omitempty"`
+}
+
+// nestsHostios contains the hostios with nested calls.
+var nestsHostios = map[string]bool{
+	"call_contract":          true,
+	"delegate_call_contract": true,
+	"static_call_contract":   true,
+}
+
+func newStylusTracer(ctx *tracers.Context, _ json.RawMessage) (tracers.Tracer, error) {
+	return &stylusTracer{
+		open:  containers.NewStack[HostioTraceInfo](),
+		stack: containers.NewStack[*containers.Stack[HostioTraceInfo]](),
+	}, nil
+}
+
+func (t *stylusTracer) CaptureStylusHostio(name string, args, outs []byte, startInk, endInk uint64) {
+	if t.interrupt.Load() {
+		return
+	}
+	info := HostioTraceInfo{
+		Name:     name,
+		Args:     args,
+		Outs:     outs,
+		StartInk: startInk,
+		EndInk:   endInk,
+	}
+	if nestsHostios[name] {
+		last, err := t.open.Pop()
+		if err != nil {
+			t.Stop(err)
+			return
+		}
+		if !strings.HasPrefix(last.Name, "evm_") || last.Name[4:] != info.Name {
+			t.Stop(fmt.Errorf("trace inconsistency for %v: last opcode is %v", info.Name, last.Name))
+			return
+		}
+		if last.Steps == nil {
+			t.Stop(fmt.Errorf("trace inconsistency for %v: nil steps", info.Name))
+			return
+		}
+		info.Address = last.Address
+		info.Steps = last.Steps
+	}
+	t.open.Push(info)
+}
+
+func (t *stylusTracer) CaptureEnter(typ vm.OpCode, from common.Address, to common.Address, input []byte, gas uint64, value *big.Int) {
+	if t.interrupt.Load() {
+		return
+	}
+
+	// This function adds the prefix evm_ because it assumes the opcode came from the EVM.
+	// If the opcode comes from WASM, the CaptureStylusHostio function will remove the evm prefix.
+	var name string
+	switch typ {
+	case vm.CALL:
+		name = "evm_call_contract"
+	case vm.DELEGATECALL:
+		name = "evm_delegate_call_contract"
+	case vm.STATICCALL:
+		name = "evm_static_call_contract"
+	case vm.CREATE:
+		name = "evm_create1"
+	case vm.CREATE2:
+		name = "evm_create2"
+	case vm.SELFDESTRUCT:
+		name = "evm_self_destruct"
+	}
+
+	inner := containers.NewStack[HostioTraceInfo]()
+	info := HostioTraceInfo{
+		Name:    name,
+		Address: &to,
+		Steps:   inner,
+	}
+	t.open.Push(info)
+	t.stack.Push(t.open)
+	t.open = inner
+}
+
+func (t *stylusTracer) CaptureExit(output []byte, gasUsed uint64, _ error) {
+	if t.interrupt.Load() {
+		return
+	}
+	var err error
+	t.open, err = t.stack.Pop()
+	if err != nil {
+		t.Stop(err)
+	}
+}
+
+func (t *stylusTracer) GetResult() (json.RawMessage, error) {
+	if t.reason != nil {
+		return nil, t.reason
+	}
+
+	var internalErr error
+	if t.open == nil {
+		internalErr = errors.Join(internalErr, fmt.Errorf("tracer.open is nil"))
+	}
+	if t.stack == nil {
+		internalErr = errors.Join(internalErr, fmt.Errorf("tracer.stack is nil"))
+	}
+	if !t.stack.Empty() {
+		internalErr = errors.Join(internalErr, fmt.Errorf("tracer.stack should be empty, but has %d values", t.stack.Len()))
+	}
+	if internalErr != nil {
+		log.Error("stylusTracer: internal error when generating a trace", "error", internalErr)
+		return nil, fmt.Errorf("internal error: %w", internalErr)
+	}
+
+	msg, err := json.Marshal(t.open)
+	if err != nil {
+		return nil, err
+	}
+	return msg, nil
+}
+
+func (t *stylusTracer) Stop(err error) {
+	t.reason = err
+	t.interrupt.Store(true)
+}
+
+// Unimplemented EVMLogger interface methods
+
+func (t *stylusTracer) CaptureArbitrumTransfer(env *vm.EVM, from, to *common.Address, value *big.Int, before bool, purpose string) {
+}
+func (t *stylusTracer) CaptureArbitrumStorageGet(key common.Hash, depth int, before bool)        {}
+func (t *stylusTracer) CaptureArbitrumStorageSet(key, value common.Hash, depth int, before bool) {}
+func (t *stylusTracer) CaptureStart(env *vm.EVM, from common.Address, to common.Address, create bool, input []byte, gas uint64, value *big.Int) {
+}
+func (t *stylusTracer) CaptureEnd(output []byte, gasUsed uint64, err error) {}
+func (t *stylusTracer) CaptureState(pc uint64, op vm.OpCode, gas, cost uint64, scope *vm.ScopeContext, rData []byte, depth int, err error) {
+}
+func (t *stylusTracer) CaptureFault(pc uint64, op vm.OpCode, gas, cost uint64, _ *vm.ScopeContext, depth int, err error) {
+}
+func (t *stylusTracer) CaptureTxStart(gasLimit uint64) {}
+func (t *stylusTracer) CaptureTxEnd(restGas uint64)    {}
diff --git a/execution/gethexec/tx_pre_checker.go b/execution/gethexec/tx_pre_checker.go
index dacfd32..e0ae330 100644
--- a/execution/gethexec/tx_pre_checker.go
+++ b/execution/gethexec/tx_pre_checker.go
@@ -43,7 +43,7 @@ type TxPreCheckerConfig struct {
 type TxPreCheckerConfigFetcher func() *TxPreCheckerConfig
 
 var DefaultTxPreCheckerConfig = TxPreCheckerConfig{
-	Strictness:             TxPreCheckerStrictnessNone,
+	Strictness:             TxPreCheckerStrictnessLikelyCompatible,
 	RequiredStateAge:       2,
 	RequiredStateMaxBlocks: 4,
 }
@@ -161,6 +161,7 @@ func PreCheckTx(bc *core.BlockChain, chainConfig *params.ChainConfig, header *ty
 			oldHeader := header
 			blocksTraversed := uint(0)
 			// find a block that's old enough
+			// #nosec G115
 			for now-int64(oldHeader.Time) < config.RequiredStateAge &&
 				(config.RequiredStateMaxBlocks <= 0 || blocksTraversed < config.RequiredStateMaxBlocks) &&
 				oldHeader.Number.Uint64() > 0 {
diff --git a/execution/gethexec/wasmstorerebuilder.go b/execution/gethexec/wasmstorerebuilder.go
index dcbee45..e3eb8e9 100644
--- a/execution/gethexec/wasmstorerebuilder.go
+++ b/execution/gethexec/wasmstorerebuilder.go
@@ -59,9 +59,14 @@ func WriteToKeyValueStore[T any](store ethdb.KeyValueStore, key []byte, val T) e
 // It also stores a special value that is only set once when rebuilding commenced in RebuildingStartBlockHashKey as the block
 // time of the latest block when rebuilding was first called, this is used to avoid recomputing of assembly and module of
 // contracts that were created after rebuilding commenced since they would anyway already be added during sync.
-func RebuildWasmStore(ctx context.Context, wasmStore ethdb.KeyValueStore, chainDb ethdb.Database, maxRecreateStateDepth int64, l2Blockchain *core.BlockChain, position, rebuildingStartBlockHash common.Hash) error {
+func RebuildWasmStore(ctx context.Context, wasmStore ethdb.KeyValueStore, chainDb ethdb.Database, maxRecreateStateDepth int64, targetConfig *StylusTargetConfig, l2Blockchain *core.BlockChain, position, rebuildingStartBlockHash common.Hash) error {
 	var err error
 	var stateDb *state.StateDB
+
+	if err := PopulateStylusTargetCache(targetConfig); err != nil {
+		return fmt.Errorf("error populating stylus target cache: %w", err)
+	}
+
 	latestHeader := l2Blockchain.CurrentBlock()
 	// Attempt to get state at the start block when rebuilding commenced, if not available (in case of non-archival nodes) use latest state
 	rebuildingStartHeader := l2Blockchain.GetHeaderByHash(rebuildingStartBlockHash)
diff --git a/execution/nodeInterface/NodeInterface.go b/execution/nodeInterface/NodeInterface.go
index 9179a52..71ebbcc 100644
--- a/execution/nodeInterface/NodeInterface.go
+++ b/execution/nodeInterface/NodeInterface.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"math"
 	"math/big"
 	"sort"
 
@@ -234,6 +235,7 @@ func (n NodeInterface) ConstructOutboxProof(c ctx, evm mech, size, leaf uint64)
 	}
 
 	balanced := size == arbmath.NextPowerOf2(size)/2
+	// #nosec G115
 	treeLevels := int(arbmath.Log2ceil(size)) // the # of levels in the tree
 	proofLevels := treeLevels - 1             // the # of levels where a hash is needed (all but root)
 	walkLevels := treeLevels                  // the # of levels we need to consider when building walks
@@ -249,6 +251,7 @@ func (n NodeInterface) ConstructOutboxProof(c ctx, evm mech, size, leaf uint64)
 	place := leaf                             // where we are in the tree
 	for level := 0; level < walkLevels; level++ {
 		sibling := place ^ which
+		// #nosec G115
 		position := merkletree.NewLevelAndLeaf(uint64(level), sibling)
 
 		if sibling < size {
@@ -272,6 +275,7 @@ func (n NodeInterface) ConstructOutboxProof(c ctx, evm mech, size, leaf uint64)
 				total += power    // The leaf for a given partial is the sum of the powers
 				leaf := total - 1 // of 2 preceding it. It's 1 less since we count from 0
 
+				// #nosec G115
 				partial := merkletree.NewLevelAndLeaf(uint64(level), leaf)
 
 				query = append(query, partial)
@@ -297,6 +301,7 @@ func (n NodeInterface) ConstructOutboxProof(c ctx, evm mech, size, leaf uint64)
 
 		mid := (lo + hi) / 2
 
+		// #nosec G115
 		block, err := n.backend.BlockByNumber(n.context, rpc.BlockNumber(mid))
 		if err != nil {
 			searchErr = err
@@ -405,6 +410,7 @@ func (n NodeInterface) ConstructOutboxProof(c ctx, evm mech, size, leaf uint64)
 		step.Leaf += 1 << step.Level // we start on the min partial's zero-hash sibling
 		known[step] = hash0
 
+		// #nosec G115
 		for step.Level < uint64(treeLevels) {
 
 			curr, ok := known[step]
@@ -643,6 +649,10 @@ func (n NodeInterface) LegacyLookupMessageBatchProof(c ctx, evm mech, batchNum h
 // L2BlockRangeForL1 fetches the L1 block number of a given l2 block number.
 // c ctx and evm mech arguments are not used but supplied to match the precompile function type in NodeInterface contract
 func (n NodeInterface) BlockL1Num(c ctx, evm mech, l2BlockNum uint64) (uint64, error) {
+	if l2BlockNum > math.MaxInt64 {
+		return 0, fmt.Errorf("requested l2 block number %d out of range for int64", l2BlockNum)
+	}
+	// #nosec G115
 	blockHeader, err := n.backend.HeaderByNumber(n.context, rpc.BlockNumber(l2BlockNum))
 	if err != nil {
 		return 0, err
diff --git a/gethhook/geth-hook.go b/gethhook/geth-hook.go
index 8bd99fd..09a140b 100644
--- a/gethhook/geth-hook.go
+++ b/gethhook/geth-hook.go
@@ -20,15 +20,12 @@ type ArbosPrecompileWrapper struct {
 	inner precompiles.ArbosPrecompile
 }
 
-type PrecompileAccessibleState interface {
-	Interpreter() *vm.EVMInterpreter
-}
-
-func (p ArbosPrecompileWrapper) RequiredGas(accessibleState vm.PrecompileAccessibleState, input []byte) uint64 {
+func (p ArbosPrecompileWrapper) RequiredGas(state vm.PrecompileAccessibleState, input []byte) uint64 {
+	// Implement the logic here if needed, or keep the panic if it's not supposed to be called.
 	panic("Non-advanced precompile method called")
 }
 
-func (p ArbosPrecompileWrapper) Run(accessibleState vm.PrecompileAccessibleState, caller common.Address, addr common.Address, input []byte, readOnly bool) ([]byte, error) {
+func (p ArbosPrecompileWrapper) Run(state vm.PrecompileAccessibleState, precompileAddr common.Address, actingAsAddr common.Address, input []byte, readOnly bool) ([]byte, error) {
 	panic("Non-advanced precompile method called")
 }
 
@@ -38,8 +35,8 @@ func (p ArbosPrecompileWrapper) RunAdvanced(
 	info *vm.AdvancedPrecompileCall,
 ) (ret []byte, gasLeft uint64, err error) {
 
-	// Precompiles don't actually enter evm execution like normal calls do,
-	// so we need to increment the depth here to simulate the callstack change.
+	// Precompiles don't actually enter EVM execution like normal calls do,
+	// so we need to increment the depth here to simulate the call stack change.
 	info.Evm.IncrementDepth()
 	defer info.Evm.DecrementDepth()
 
diff --git a/go-ethereum b/go-ethereum
index 7425948..e6a1032 160000
--- a/go-ethereum
+++ b/go-ethereum
@@ -1 +1 @@
-Subproject commit 7425948f3ec19b35c8c4476a9c4950a60b1efc3d
+Subproject commit e6a1032f93b6fd6cd09dd3d94270512d0a6b2f34
diff --git a/go.mod b/go.mod
index cd2dd9a..2552c12 100644
--- a/go.mod
+++ b/go.mod
@@ -8,6 +8,12 @@ replace github.com/ethereum/go-ethereum => ./go-ethereum
 
 replace github.com/zama-ai/fhevm-go v0.5.1 => ./fhevm-go
 
+
+replace github.com/offchainlabs/nitro/solgen/go/bridgegen => ./solgen/go/bridgegen
+replace github.com/offchainlabs/nitro/solgen/go/rollupgen => ./solgen/go/rollupgen
+replace github.com/offchainlabs/nitro/solgen/go/challengegen => ./solgen/go/challengegen
+replace github.com/offchainlabs/nitro/solgen/go/node_interfacegen => ./solgen/go/node_interfacegen
+
 require (
 	github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible
 	github.com/Shopify/toxiproxy v2.1.4+incompatible
@@ -43,7 +49,6 @@ require (
 	github.com/rivo/tview v0.0.0-20240307173318-e804876934a1
 	github.com/spf13/pflag v1.0.5
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
-	github.com/wasmerio/wasmer-go v1.0.4
 	github.com/wealdtech/go-merkletree v1.0.0
 	golang.org/x/crypto v0.21.0
 	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa
@@ -57,7 +62,7 @@ require (
 	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/google/go-querystring v1.1.0 // indirect
-	github.com/zama-ai/fhevm-go v0.5.1 // indirect
+	github.com/pelletier/go-toml v1.9.3 // indirect
 	go.opentelemetry.io/otel v1.23.1 // indirect
 	go.opentelemetry.io/otel/metric v1.23.1 // indirect
 	go.opentelemetry.io/otel/trace v1.23.1 // indirect
@@ -107,7 +112,6 @@ require (
 	github.com/dop251/goja v0.0.0-20230806174421-c933cf95e127 // indirect
 	github.com/dustin/go-humanize v1.0.0 // indirect
 	github.com/ethereum/c-kzg-4844 v0.4.0 // indirect
-	github.com/fjl/memsize v0.0.2 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
 	github.com/gammazero/deque v0.2.1 // indirect
 	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
@@ -172,7 +176,8 @@ require (
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yuin/gopher-lua v1.1.1 // indirect
-	go.opencensus.io v0.22.5 // indirect
+	github.com/zama-ai/fhevm-go v0.5.1 // indirect
+	go.opencensus.io v0.23.0 // indirect
 	golang.org/x/mod v0.14.0 // indirect
 	golang.org/x/net v0.23.0 // indirect
 	golang.org/x/oauth2 v0.22.0
diff --git a/go.sum b/go.sum
index 9fce96e..bef29b6 100644
--- a/go.sum
+++ b/go.sum
@@ -116,6 +116,7 @@ github.com/chzyer/readline v1.5.0/go.mod h1:x22KAscuvRqlLoK9CsoYsmxoXZMMFVyOl86c
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/chzyer/test v0.0.0-20210722231415-061457976a23/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
 github.com/cockroachdb/datadriven v1.0.2/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
 github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
@@ -182,6 +183,7 @@ github.com/enescakir/emoji v1.0.0 h1:W+HsNql8swfCQFtioDGDHCHri8nudlK1n5p2rHCJoog
 github.com/enescakir/emoji v1.0.0/go.mod h1:Bt1EKuLnKDTYpLALApstIkAjdDrS/8IAgTkKp+WKFD0=
 github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
 github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
@@ -192,8 +194,6 @@ github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5Kwzbycv
 github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
 github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4=
 github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94=
-github.com/fjl/memsize v0.0.2 h1:27txuSD9or+NZlnOWdKUxeBzTAUkWCVh+4Gf2dWFOzA=
-github.com/fjl/memsize v0.0.2/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY=
@@ -258,7 +258,6 @@ github.com/golang-jwt/jwt/v4 v4.5.0/go.mod h1:m21LjoU+eqJr34lmDMbreY2eSTRJ1cv77w
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/glog v1.1.2 h1:DVjP2PbBOzHyzA+dn3WhHIq4NdVu3Q+pvivFICf/7fo=
 github.com/golang/glog v1.1.2/go.mod h1:zR+okUeTbrL6EL3xHUDxZuEtGv04p5shwip1+mL/rLQ=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
 github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
@@ -272,6 +271,7 @@ github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:W
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
@@ -291,6 +291,7 @@ github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMyw
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
@@ -497,8 +498,9 @@ github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsq
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pelletier/go-toml v1.7.0 h1:7utD74fnzVc/cpcyy8sjrlFr5vYpypUixARcHIMIGuI=
 github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
+github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ=
+github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
 github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
@@ -591,8 +593,6 @@ github.com/vmihailenco/msgpack/v5 v5.3.5 h1:5gO0H1iULLWGhs2H5tbAHIZTV8/cYafcFOr9
 github.com/vmihailenco/msgpack/v5 v5.3.5/go.mod h1:7xyJ9e+0+9SaZT0Wt1RGleJXzli6Q/V5KbhBonMG9jc=
 github.com/vmihailenco/tagparser/v2 v2.0.0 h1:y09buUbR+b5aycVFQs/g70pqKVZNBmxwAhO7/IwNM9g=
 github.com/vmihailenco/tagparser/v2 v2.0.0/go.mod h1:Wri+At7QHww0WTrCBeu4J6bNtoV6mEfg5OIWRZA9qds=
-github.com/wasmerio/wasmer-go v1.0.4 h1:MnqHoOGfiQ8MMq2RF6wyCeebKOe84G88h5yv+vmxJgs=
-github.com/wasmerio/wasmer-go v1.0.4/go.mod h1:0gzVdSfg6pysA6QVp6iVRPTagC6Wq9pOE8J86WKb2Fk=
 github.com/wealdtech/go-merkletree v1.0.0 h1:DsF1xMzj5rK3pSQM6mPv8jlyJyHXhFxpnA2bwEjMMBY=
 github.com/wealdtech/go-merkletree v1.0.0/go.mod h1:cdil512d/8ZC7Kx3bfrDvGMQXB25NTKbsm0rFrmDax4=
 github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
@@ -611,8 +611,8 @@ github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-go.opencensus.io v0.22.5 h1:dntmOdLpSpHlVqbW5Eay97DelsZHe+55D+xC6i0dDS0=
-go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
+go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M=
+go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/otel v1.23.1 h1:Za4UzOqJYS+MUczKI320AtqZHZb7EqxO00jAHE0jmQY=
 go.opentelemetry.io/otel v1.23.1/go.mod h1:Td0134eafDLcTS4y+zQ26GE8u3dEuRBiBCTUIRHaikA=
 go.opentelemetry.io/otel/metric v1.23.1 h1:PQJmqJ9u2QaJLBOELl1cxIdPcpbwzbkjfEyelTl2rlo=
@@ -662,6 +662,7 @@ golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLL
 golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
 golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
@@ -694,7 +695,6 @@ golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190403152447-81d4e9dc473e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -780,7 +780,6 @@ google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7
 google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190404172233-64821d5d2107/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24=
@@ -789,11 +788,11 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20230822172742-b8732ec3820d/go.
 google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
 google.golang.org/grpc v1.22.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
 google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM=
 google.golang.org/grpc v1.59.0 h1:Z5Iec2pjwb+LEOqzpB2MR12/eKFhDPhuqW91O+4bwUk=
 google.golang.org/grpc v1.59.0/go.mod h1:aUPDwccQo6OTjy7Hct4AfBPD1GptF4fyUjIkQ9YtF98=
diff --git a/nitro-testnode b/nitro-testnode
index 43861b0..2c2a97c 160000
--- a/nitro-testnode
+++ b/nitro-testnode
@@ -1 +1 @@
-Subproject commit 43861b001713db3526b74e905e383d41e9272760
+Subproject commit 2c2a97c2608ab0c83f2322af2a0dc2bf0b15ea31
diff --git a/precompiles/ArbAddressTable.go b/precompiles/ArbAddressTable.go
index 05f2275..102fd55 100644
--- a/precompiles/ArbAddressTable.go
+++ b/precompiles/ArbAddressTable.go
@@ -33,7 +33,7 @@ func (con ArbAddressTable) Decompress(c ctx, evm mech, buf []uint8, offset huge)
 		return addr{}, nil, errors.New("invalid offset in ArbAddressTable.Decompress")
 	}
 	result, nbytes, err := c.State.AddressTable().Decompress(buf[ioffset:])
-	return result, big.NewInt(int64(nbytes)), err
+	return result, new(big.Int).SetUint64(nbytes), err
 }
 
 // Lookup the index of an address in the table
@@ -45,7 +45,7 @@ func (con ArbAddressTable) Lookup(c ctx, evm mech, addr addr) (huge, error) {
 	if !exists {
 		return nil, errors.New("address does not exist in AddressTable")
 	}
-	return big.NewInt(int64(result)), nil
+	return new(big.Int).SetUint64(result), nil
 }
 
 // LookupIndex for  an address in the table by index
@@ -66,11 +66,11 @@ func (con ArbAddressTable) LookupIndex(c ctx, evm mech, index huge) (addr, error
 // Register adds an account to the table, shrinking its compressed representation
 func (con ArbAddressTable) Register(c ctx, evm mech, addr addr) (huge, error) {
 	slot, err := c.State.AddressTable().Register(addr)
-	return big.NewInt(int64(slot)), err
+	return new(big.Int).SetUint64(slot), err
 }
 
 // Size gets the number of addresses in the table
 func (con ArbAddressTable) Size(c ctx, evm mech) (huge, error) {
 	size, err := c.State.AddressTable().Size()
-	return big.NewInt(int64(size)), err
+	return new(big.Int).SetUint64(size), err
 }
diff --git a/precompiles/ArbOwner.go b/precompiles/ArbOwner.go
index 066fc0a..8b87445 100644
--- a/precompiles/ArbOwner.go
+++ b/precompiles/ArbOwner.go
@@ -69,6 +69,9 @@ func (con ArbOwner) SetL2BaseFee(c ctx, evm mech, priceInWei huge) error {
 
 // SetMinimumL2BaseFee sets the minimum base fee needed for a transaction to succeed
 func (con ArbOwner) SetMinimumL2BaseFee(c ctx, evm mech, priceInWei huge) error {
+	if c.txProcessor.MsgIsNonMutating() && priceInWei.Sign() == 0 {
+		return errors.New("minimum base fee must be nonzero")
+	}
 	return c.State.L2PricingState().SetMinBaseFeeWei(priceInWei)
 }
 
diff --git a/precompiles/ArbRetryableTx.go b/precompiles/ArbRetryableTx.go
index d508d75..93e8023 100644
--- a/precompiles/ArbRetryableTx.go
+++ b/precompiles/ArbRetryableTx.go
@@ -149,7 +149,7 @@ func (con ArbRetryableTx) GetTimeout(c ctx, evm mech, ticketId bytes32) (huge, e
 	if err != nil {
 		return nil, err
 	}
-	return big.NewInt(int64(timeout)), nil
+	return new(big.Int).SetUint64(timeout), nil
 }
 
 // Keepalive adds one lifetime period to the ticket's expiry
@@ -176,8 +176,9 @@ func (con ArbRetryableTx) Keepalive(c ctx, evm mech, ticketId bytes32) (huge, er
 		return big.NewInt(0), err
 	}
 
-	err = con.LifetimeExtended(c, evm, ticketId, big.NewInt(int64(newTimeout)))
-	return big.NewInt(int64(newTimeout)), err
+	bigNewTimeout := new(big.Int).SetUint64(newTimeout)
+	err = con.LifetimeExtended(c, evm, ticketId, bigNewTimeout)
+	return bigNewTimeout, err
 }
 
 // GetBeneficiary gets the beneficiary of the ticket
diff --git a/precompiles/ArbSys.go b/precompiles/ArbSys.go
index 13f56d3..d55067a 100644
--- a/precompiles/ArbSys.go
+++ b/precompiles/ArbSys.go
@@ -162,7 +162,7 @@ func (con *ArbSys) SendTxToL1(c ctx, evm mech, value huge, destination addr, cal
 		}
 	}
 
-	leafNum := big.NewInt(int64(size - 1))
+	leafNum := new(big.Int).SetUint64(size - 1)
 
 	var blockTime big.Int
 	blockTime.SetUint64(evm.Context.Time)
@@ -199,7 +199,7 @@ func (con ArbSys) SendMerkleTreeState(c ctx, evm mech) (huge, bytes32, []bytes32
 	for i, par := range rawPartials {
 		partials[i] = par
 	}
-	return big.NewInt(int64(size)), rootHash, partials, nil
+	return new(big.Int).SetUint64(size), rootHash, partials, nil
 }
 
 // WithdrawEth send paid eth to the destination on L1
diff --git a/precompiles/ArbWasm.go b/precompiles/ArbWasm.go
index 9f42cac..bc24c8a 100644
--- a/precompiles/ArbWasm.go
+++ b/precompiles/ArbWasm.go
@@ -5,6 +5,8 @@ package precompiles
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	gethparams "github.com/ethereum/go-ethereum/params"
 	"github.com/offchainlabs/nitro/arbos/programs"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -32,12 +34,13 @@ func (con ArbWasm) ActivateProgram(c ctx, evm mech, value huge, program addr) (u
 	debug := evm.ChainConfig().DebugMode()
 	runMode := c.txProcessor.RunMode()
 	programs := c.State.Programs()
+	arbosVersion := c.State.ArbOSVersion()
 
 	// charge a fixed cost up front to begin activation
 	if err := c.Burn(1659168); err != nil {
 		return 0, nil, err
 	}
-	version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, runMode, debug)
+	version, codeHash, moduleHash, dataFee, takeAllGas, err := programs.ActivateProgram(evm, program, arbosVersion, runMode, debug)
 	if takeAllGas {
 		_ = c.BurnOut()
 	}
@@ -133,6 +136,9 @@ func (con ArbWasm) MinInitGas(c ctx, _ mech) (uint64, uint64, error) {
 	params, err := c.State.Programs().Params()
 	init := uint64(params.MinInitGas) * programs.MinInitGasUnits
 	cached := uint64(params.MinCachedInitGas) * programs.MinCachedGasUnits
+	if c.State.ArbOSVersion() < gethparams.ArbosVersion_StylusChargingFixes {
+		return 0, 0, vm.ErrExecutionReverted
+	}
 	return init, cached, err
 }
 
diff --git a/precompiles/precompile.go b/precompiles/precompile.go
index f1faa51..9a356c5 100644
--- a/precompiles/precompile.go
+++ b/precompiles/precompile.go
@@ -329,6 +329,7 @@ func MakePrecompile(metadata *bind.MetaData, implementer interface{}) (addr, *Pr
 		gascost := func(args []reflect.Value) []reflect.Value {
 
 			cost := params.LogGas
+			// #nosec G115
 			cost += params.LogTopicGas * uint64(1+len(topicInputs))
 
 			var dataValues []interface{}
@@ -540,9 +541,6 @@ func Precompiles() map[addr]ArbosPrecompile {
 	ArbGasInfo.methodsByName["GetLastL1PricingSurplus"].arbosVersion = 20
 	insert(MakePrecompile(pgen.ArbAggregatorMetaData, &ArbAggregator{Address: types.ArbAggregatorAddress}))
 	insert(MakePrecompile(pgen.ArbStatisticsMetaData, &ArbStatistics{Address: types.ArbStatisticsAddress}))
-	// FheLibPrecompileImpl := &FheLibPrecompile{Address: types.FheLibAddress}
-	// FheAddress, FheLunPrecimpoileMake := MakePrecompile(pgen.FheLibMetaData, FheLibPrecompileImpl)
-	// insert(FheAddress, FheLunPrecimpoileMake)
 
 	eventCtx := func(gasLimit uint64, err error) *Context {
 		if err != nil {
@@ -715,6 +713,8 @@ func (p *Precompile) Call(
 		tracingInfo: util.NewTracingInfo(evm, caller, precompileAddress, util.TracingDuringEVM),
 	}
 
+	// len(input) must be at least 4 because of the check near the start of this function
+	// #nosec G115
 	argsCost := params.CopyGas * arbmath.WordsForBytes(uint64(len(input)-4))
 	if err := callerCtx.Burn(argsCost); err != nil {
 		// user cannot afford the argument data supplied
diff --git a/precompiles/precompile_test.go b/precompiles/precompile_test.go
index ecce770..18b3371 100644
--- a/precompiles/precompile_test.go
+++ b/precompiles/precompile_test.go
@@ -91,6 +91,7 @@ func TestEvents(t *testing.T) {
 		if log.Address != debugContractAddr {
 			Fail(t, "address mismatch:", log.Address, "vs", debugContractAddr)
 		}
+		// #nosec G115
 		if log.BlockNumber != uint64(blockNumber) {
 			Fail(t, "block number mismatch:", log.BlockNumber, "vs", blockNumber)
 		}
@@ -170,6 +171,7 @@ func TestEventCosts(t *testing.T) {
 		offsetBytes := 32
 		storeBytes := sizeBytes + offsetBytes + len(bytes)
 		storeBytes = storeBytes + 31 - (storeBytes+31)%32 // round up to a multiple of 32
+		// #nosec G115
 		storeCost := uint64(storeBytes) * params.LogDataGas
 
 		expected[i] = baseCost + addrCost + hashCost + storeCost
diff --git a/pubsub/consumer.go b/pubsub/consumer.go
index df36956..bd73e72 100644
--- a/pubsub/consumer.go
+++ b/pubsub/consumer.go
@@ -77,6 +77,10 @@ func (c *Consumer[Request, Response]) Start(ctx context.Context) {
 	)
 }
 
+func (c *Consumer[Request, Response]) Id() string {
+	return c.id
+}
+
 func (c *Consumer[Request, Response]) StopAndWait() {
 	c.StopWaiter.StopAndWait()
 	c.deleteHeartBeat(c.GetParentContext())
@@ -164,10 +168,12 @@ func (c *Consumer[Request, Response]) SetResult(ctx context.Context, messageID s
 	if err != nil {
 		return fmt.Errorf("marshaling result: %w", err)
 	}
+	log.Debug("consumer: setting result", "cid", c.id, "messageId", messageID)
 	acquired, err := c.client.SetNX(ctx, messageID, resp, c.cfg.ResponseEntryTimeout).Result()
 	if err != nil || !acquired {
 		return fmt.Errorf("setting result for  message: %v, error: %w", messageID, err)
 	}
+	log.Debug("consumer: xack", "cid", c.id, "messageId", messageID)
 	if _, err := c.client.XAck(ctx, c.redisStream, c.redisGroup, messageID).Result(); err != nil {
 		return fmt.Errorf("acking message: %v, error: %w", messageID, err)
 	}
diff --git a/pubsub/producer.go b/pubsub/producer.go
index 2b1cdb5..5eec3a4 100644
--- a/pubsub/producer.go
+++ b/pubsub/producer.go
@@ -205,35 +205,39 @@ func setMinIdInt(min *[2]uint64, id string) error {
 // checkResponses checks iteratively whether response for the promise is ready.
 func (p *Producer[Request, Response]) checkResponses(ctx context.Context) time.Duration {
 	minIdInt := [2]uint64{math.MaxUint64, math.MaxUint64}
+	log.Debug("redis producer: check responses starting")
 	p.promisesLock.Lock()
 	defer p.promisesLock.Unlock()
 	responded := 0
 	errored := 0
+	checked := 0
 	for id, promise := range p.promises {
 		if ctx.Err() != nil {
 			return 0
 		}
+		checked++
 		res, err := p.client.Get(ctx, id).Result()
 		if err != nil {
 			errSetId := setMinIdInt(&minIdInt, id)
 			if errSetId != nil {
-				log.Error("error setting minId", "err", err)
+				log.Error("redis producer: error setting minId", "err", err)
 				return p.cfg.CheckResultInterval
 			}
 			if !errors.Is(err, redis.Nil) {
-				log.Error("Error reading value in redis", "key", id, "error", err)
+				log.Error("redis producer: Error reading value in redis", "key", id, "error", err)
 			}
 			continue
 		}
 		var resp Response
 		if err := json.Unmarshal([]byte(res), &resp); err != nil {
 			promise.ProduceError(fmt.Errorf("error unmarshalling: %w", err))
-			log.Error("Error unmarshaling", "value", res, "error", err)
+			log.Error("redis producer: Error unmarshaling", "value", res, "error", err)
 			errored++
 		} else {
 			promise.Produce(resp)
 			responded++
 		}
+		p.client.Del(ctx, id)
 		delete(p.promises, id)
 	}
 	var trimmed int64
@@ -245,7 +249,7 @@ func (p *Producer[Request, Response]) checkResponses(ctx context.Context) time.D
 	} else {
 		trimmed, trimErr = p.client.XTrimMaxLen(ctx, p.redisStream, 0).Result()
 	}
-	log.Trace("trimming", "id", minId, "trimmed", trimmed, "responded", responded, "errored", errored, "trim-err", trimErr)
+	log.Debug("trimming", "id", minId, "trimmed", trimmed, "responded", responded, "errored", errored, "trim-err", trimErr, "checked", checked)
 	return p.cfg.CheckResultInterval
 }
 
diff --git a/relay/relay_stress_test.go b/relay/relay_stress_test.go
index 9a8875a..575a77e 100644
--- a/relay/relay_stress_test.go
+++ b/relay/relay_stress_test.go
@@ -47,6 +47,7 @@ func (r *DummyUpStream) PopulateFeedBacklogByNumber(ctx context.Context, backlog
 	was := r.broadcaster.GetCachedMessageCount()
 	var seqNums []arbutil.MessageIndex
 	for i := was; i < was+backlogSize; i++ {
+		// #nosec G115
 		seqNums = append(seqNums, arbutil.MessageIndex(i))
 	}
 
@@ -160,7 +161,7 @@ func largeBacklogRelayTestImpl(t *testing.T, numClients, backlogSize, l2MsgSize
 			connected++
 		}
 	}
-	if int32(connected) != int32(numClients) {
+	if connected != numClients {
 		t.Fail()
 	}
 	log.Info("number of clients connected", "expected", numClients, "got", connected)
diff --git a/safe-smart-account b/safe-smart-account
index 1cec0e7..0142ec8 160000
--- a/safe-smart-account
+++ b/safe-smart-account
@@ -1 +1 @@
-Subproject commit 1cec0e7a6e740c72bbe566ee4f497c9ddc71a6ae
+Subproject commit 0142ec8a4a05f03167daba9e7231b7e858aabd32
diff --git a/scripts/build-brotli.sh b/scripts/build-brotli.sh
index 7160936..1a23a88 100755
--- a/scripts/build-brotli.sh
+++ b/scripts/build-brotli.sh
@@ -2,7 +2,7 @@
 
 set -e
 
-mydir=`dirname $0`
+mydir=$(dirname "$0")
 cd "$mydir"
 
 BUILD_WASM=false
@@ -35,7 +35,7 @@ usage(){
     echo "all relative paths are relative to script location"
 }
 
-while getopts "s:t:c:D:wldhf" option; do
+while getopts "n:s:t:c:D:wldhf" option; do
     case $option in
         h)
             usage
@@ -62,6 +62,9 @@ while getopts "s:t:c:D:wldhf" option; do
         s)
             SOURCE_DIR="$OPTARG"
             ;;
+        *)
+            usage
+            ;;
     esac
 done
 
@@ -74,7 +77,7 @@ if [ ! -d "$TARGET_DIR" ]; then
     mkdir -p "${TARGET_DIR}lib"
     ln -s "lib" "${TARGET_DIR}lib64" # Fedora build
 fi
-TARGET_DIR_ABS=`cd -P "$TARGET_DIR"; pwd`
+TARGET_DIR_ABS=$(cd -P "$TARGET_DIR"; pwd)
 
 
 if $USE_DOCKER; then
@@ -94,9 +97,9 @@ cd "$SOURCE_DIR"
 if $BUILD_WASM; then
     mkdir -p buildfiles/build-wasm
     mkdir -p buildfiles/install-wasm
-    TEMP_INSTALL_DIR_ABS=`cd -P buildfiles/install-wasm; pwd`
+    TEMP_INSTALL_DIR_ABS=$(cd -P buildfiles/install-wasm; pwd)
     cd buildfiles/build-wasm
-    cmake ../../ -DCMAKE_C_COMPILER=emcc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-fPIC -DCMAKE_INSTALL_PREFIX="$TEMP_INSTALL_DIR_ABS" -DCMAKE_AR=`which emar` -DCMAKE_RANLIB=`which touch`
+    cmake ../../ -DCMAKE_C_COMPILER=emcc -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS=-fPIC -DCMAKE_INSTALL_PREFIX="$TEMP_INSTALL_DIR_ABS" -DCMAKE_AR="$(which emar)" -DCMAKE_RANLIB="$(which touch)"
     make -j
     make install
     cp -rv "$TEMP_INSTALL_DIR_ABS/lib" "$TARGET_DIR_ABS/lib-wasm"
diff --git a/scripts/convert-databases.bash b/scripts/convert-databases.bash
index bd898c2..baddcdc 100755
--- a/scripts/convert-databases.bash
+++ b/scripts/convert-databases.bash
@@ -33,7 +33,7 @@ printStatus() {
 }
 
 printUsage() {
-echo Usage: $0 \[OPTIONS..\]
+echo Usage: "$0" \[OPTIONS..\]
     echo
     echo OPTIONS:
     echo "--dbconv          dbconv binary path (default: \"$DEFAULT_DBCONV\")"
@@ -42,15 +42,15 @@ echo Usage: $0 \[OPTIONS..\]
     echo "--force           remove destination directory if it exists"
     echo "--skip-existing   skip convertion of databases which directories already exist in the destination directory"
     echo "--clean           sets what should be removed in case of error, possible values:"
-	echo "                      \"failed\" - remove database which conversion failed (default)"
+    echo "                      \"failed\" - remove database which conversion failed (default)"
     echo "                      \"none\"   - remove nothing, leave unfinished and potentially corrupted databases"
     echo "                      \"all\"    - remove whole destination directory"
 }
 
 removeDir() {
     cmd="rm -r \"$1\""
-    echo $cmd
-    eval $cmd
+    echo "$cmd"
+    eval "$cmd"
     return $?
 }
 
@@ -62,7 +62,7 @@ cleanup() {
             ;;
         failed)
             echo "== Note: removing only failed destination directory"
-            dstdir=$(echo $dst/$1 | tr -s /)
+            dstdir=$(echo "$dst"/"$1" | tr -s /)
             removeDir "$dstdir"
             ;;
         none)
@@ -127,8 +127,8 @@ if $force && $skip_existing; then
     exit 1
 fi
 
-if [ $clean != "all" ] && [ $clean != "failed" ] && [ $clean != "none" ] ; then
-    echo Error: Invalid --clean value: $clean
+if [ "$clean" != "all" ] && [ "$clean" != "failed" ] && [ "$clean" != "none" ] ; then
+    echo Error: Invalid --clean value: "$clean"
     printUsage
     exit 1
 fi
@@ -138,8 +138,8 @@ if ! [ -e "$dbconv" ]; then
     exit 1
 fi
 
-if ! [ -n "$dst" ]; then
-    echo Error: Missing destination directory \(\-\-dst\)
+if [ -z "$dst" ]; then
+    echo "Error: Missing destination directory (--dst)"
     printUsage
     exit 1
 fi
@@ -168,9 +168,8 @@ fi
 
 if [ -e "$dst" ] && ! $skip_existing; then
     if $force; then
-        echo == Warning! Destination already exists, --force is set, removing all files under path: "$dst"
-        removeDir "$dst"
-        if [ $? -ne 0 ]; then
+        echo "== Warning! Destination already exists, --force is set, removing all files under path: $dst"
+        if ! removeDir "$dst"; then
             echo Error: failed to remove "$dst"
             exit 1
         fi
@@ -182,15 +181,14 @@ fi
 
 convert_result=
 convert () {
-    srcdir=$(echo $src/$1 | tr -s /)
-    dstdir=$(echo $dst/$1 | tr -s /)
-    if ! [ -e $dstdir ]; then
+    srcdir="$src"/$1
+    dstdir=$(echo "$dst"/"$1" | tr -s /)
+    if ! [ -e "$dstdir" ]; then
         echo "== Converting $1 db"
         cmd="$dbconv --src.db-engine=leveldb --src.data \"$srcdir\" --dst.db-engine=pebble --dst.data \"$dstdir\" --convert --compact"
-        echo $cmd
-        eval $cmd
-        if [ $? -ne 0 ]; then
-            cleanup $1
+        echo "$cmd"
+        if ! eval "$cmd"; then
+            cleanup "$1"
             convert_result="FAILED"
             return 1
         fi
@@ -221,9 +219,8 @@ if ! [ -e "$dst"/l2chaindata/ancient ]; then
     ancient_dst=$(echo "$dst"/l2chaindata/ | tr -s /)
     echo "== Copying l2chaindata ancients"
     cmd="cp -r \"$ancient_src\" \"$ancient_dst\""
-    echo $cmd
-    eval $cmd
-    if [ $? -ne 0 ]; then
+    echo "$cmd"
+    if ! eval "$cmd"; then
         l2chaindata_ancient_status="FAILED (failed to copy)"
         cleanup "l2chaindata"
         printStatus
@@ -249,7 +246,7 @@ if [ $res -ne 0 ]; then
     exit 1
 fi
 
-if [ -e $src/wasm ]; then
+if [ -e "$src"/wasm ]; then
     convert "wasm"
     res=$?
     wasm_status=$convert_result
@@ -262,7 +259,7 @@ else
     wasm_status="not found in source directory"
 fi
 
-if [ -e $src/classic-msg ]; then
+if [ -e "$src"/classic-msg ]; then
     convert "classic-msg"
     res=$?
     classicmsg_status=$convert_result
diff --git a/scripts/fuzz.bash b/scripts/fuzz.bash
index 6271b91..a73c208 100755
--- a/scripts/fuzz.bash
+++ b/scripts/fuzz.bash
@@ -2,12 +2,12 @@
 
 set -e
 
-mydir=`dirname $0`
+mydir=$(dirname "$0")
 cd "$mydir"
 
 function printusage {
-    echo Usage: $0 --build \[--binary-path PATH\]
-    echo "      "  $0 \<fuzzer-name\> \[--binary-path PATH\] \[--fuzzcache-path PATH\]  \[--nitro-path PATH\] \[--duration DURATION\]
+    echo Usage: "$0" --build \[--binary-path PATH\]
+    echo "      "  "$0" \<fuzzer-name\> \[--binary-path PATH\] \[--fuzzcache-path PATH\]  \[--nitro-path PATH\] \[--duration DURATION\]
     echo
     echo fuzzer names:
     echo "   " FuzzPrecompiles
@@ -22,7 +22,6 @@ if [[ $# -eq 0 ]]; then
     exit
 fi
 
-fuzz_executable=../target/bin/system_test.fuzz
 binpath=../target/bin/
 fuzzcachepath=../target/var/fuzz-cache
 nitropath=../
@@ -72,7 +71,7 @@ while [[ $# -gt 0 ]]; do
             shift
             ;;
         FuzzPrecompiles | FuzzStateTransition)
-            if [[ ! -z "$test_name" ]]; then
+            if [[ -n "$test_name" ]]; then
                 echo can only run one fuzzer at a time
                 exit 1
             fi
@@ -81,7 +80,7 @@ while [[ $# -gt 0 ]]; do
             shift
             ;;
         FuzzInboxMultiplexer)
-            if [[ ! -z "$test_name" ]]; then
+            if [[ -n "$test_name" ]]; then
                 echo can only run one fuzzer at a time
                 exit 1
             fi
@@ -102,17 +101,17 @@ fi
 
 if $run_build; then
     for build_group in system_tests arbstate; do
-        go test -c ${nitropath}/${build_group} -fuzz Fuzz -o "$binpath"/${build_group}.fuzz
+        go test -c "${nitropath}"/${build_group} -fuzz Fuzz -o "$binpath"/${build_group}.fuzz
     done
 fi
 
-if [[ ! -z $test_group ]]; then
-    timeout "$((60 * duration))" "$binpath"/${test_group}.fuzz -test.run "^$" -test.fuzzcachedir "$fuzzcachepath" -test.fuzz $test_name || exit_status=$?
+if [[ -n $test_group ]]; then
+    timeout "$((60 * duration))" "$binpath"/${test_group}.fuzz -test.run "^$" -test.fuzzcachedir "$fuzzcachepath" -test.fuzz "$test_name" || exit_status=$?
 fi
 
-if  [ -n "$exit_status" ] && [ $exit_status -ne 0 ] && [ $exit_status -ne 124 ]; then
+if  [ -n "$exit_status" ] && [ "$exit_status" -ne 0 ] && [ "$exit_status" -ne 124 ]; then
     echo "Fuzzing failed."
-    exit $exit_status
+    exit "$exit_status"
 fi
 
 echo "Fuzzing succeeded."
diff --git a/scripts/startup-testnode.bash b/scripts/startup-testnode.bash
index 701e7ff..5313a9e 100755
--- a/scripts/startup-testnode.bash
+++ b/scripts/startup-testnode.bash
@@ -5,9 +5,9 @@
 
 timeout 60 ./nitro-testnode/test-node.bash --init --dev || exit_status=$?
 
-if  [ -n "$exit_status" ] && [ $exit_status -ne 0 ] && [ $exit_status -ne 124 ]; then
+if  [ -n "$exit_status" ] && [ "$exit_status" -ne 0 ] && [ "$exit_status" -ne 124 ]; then
     echo "Startup failed."
-    exit $exit_status
+    exit "$exit_status"
 fi
 
 echo "Startup succeeded."
diff --git a/staker/block_challenge_backend.go b/staker/block_challenge_backend.go
index 4235178..0dd8986 100644
--- a/staker/block_challenge_backend.go
+++ b/staker/block_challenge_backend.go
@@ -219,6 +219,6 @@ func (b *BlockChallengeBackend) IssueExecChallenge(
 		},
 		machineStatuses,
 		globalStateHashes,
-		big.NewInt(int64(numsteps)),
+		new(big.Int).SetUint64(numsteps),
 	)
 }
diff --git a/staker/block_validator.go b/staker/block_validator.go
index df465cc..5a1f123 100644
--- a/staker/block_validator.go
+++ b/staker/block_validator.go
@@ -17,6 +17,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
@@ -28,6 +29,8 @@ import (
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 	"github.com/offchainlabs/nitro/validator"
 	"github.com/offchainlabs/nitro/validator/client/redis"
+	"github.com/offchainlabs/nitro/validator/inputs"
+	"github.com/offchainlabs/nitro/validator/server_api"
 	"github.com/spf13/pflag"
 )
 
@@ -55,12 +58,12 @@ type BlockValidator struct {
 	chainCaughtUp bool
 
 	// can only be accessed from creation thread or if holding reorg-write
-	nextCreateBatch          []byte
-	nextCreateBatchBlockHash common.Hash
-	nextCreateBatchMsgCount  arbutil.MessageIndex
-	nextCreateBatchReread    bool
-	nextCreateStartGS        validator.GoGlobalState
-	nextCreatePrevDelayed    uint64
+	nextCreateBatch       *FullBatchInfo
+	nextCreateBatchReread bool
+	prevBatchCache        map[uint64][]byte
+
+	nextCreateStartGS     validator.GoGlobalState
+	nextCreatePrevDelayed uint64
 
 	// can only be accessed from from validation thread or if holding reorg-write
 	lastValidGS     validator.GoGlobalState
@@ -93,6 +96,9 @@ type BlockValidator struct {
 	// for testing only
 	testingProgressMadeChan chan struct{}
 
+	// For troubleshooting failed validations
+	validationInputsWriter *inputs.Writer
+
 	fatalErr chan<- error
 
 	MemoryFreeLimitChecker resourcemanager.LimitChecker
@@ -105,13 +111,18 @@ type BlockValidatorConfig struct {
 	ValidationServerConfigs     []rpcclient.ClientConfig      `koanf:"validation-server-configs"`
 	ValidationPoll              time.Duration                 `koanf:"validation-poll" reload:"hot"`
 	PrerecordedBlocks           uint64                        `koanf:"prerecorded-blocks" reload:"hot"`
+	RecordingIterLimit          uint64                        `koanf:"recording-iter-limit"`
 	ForwardBlocks               uint64                        `koanf:"forward-blocks" reload:"hot"`
+	BatchCacheLimit             uint32                        `koanf:"batch-cache-limit"`
 	CurrentModuleRoot           string                        `koanf:"current-module-root"`         // TODO(magic) requires reinitialization on hot reload
 	PendingUpgradeModuleRoot    string                        `koanf:"pending-upgrade-module-root"` // TODO(magic) requires StatelessBlockValidator recreation on hot reload
 	FailureIsFatal              bool                          `koanf:"failure-is-fatal" reload:"hot"`
 	Dangerous                   BlockValidatorDangerousConfig `koanf:"dangerous"`
 	MemoryFreeLimit             string                        `koanf:"memory-free-limit" reload:"hot"`
 	ValidationServerConfigsList string                        `koanf:"validation-server-configs-list"`
+	// The directory to which the BlockValidator will write the
+	// block_inputs_<id>.json files when WriteToFile() is called.
+	BlockInputsFilePath string `koanf:"block-inputs-file-path"`
 
 	memoryFreeLimit int
 }
@@ -126,6 +137,9 @@ func (c *BlockValidatorConfig) Validate() error {
 		}
 		c.memoryFreeLimit = limit
 	}
+	if err := c.RedisValidationClientConfig.Validate(); err != nil {
+		return fmt.Errorf("failed to validate redis validation client config: %w", err)
+	}
 	streamsEnabled := c.RedisValidationClientConfig.Enabled()
 	if len(c.ValidationServerConfigs) == 0 {
 		c.ValidationServerConfigs = []rpcclient.ClientConfig{c.ValidationServer}
@@ -167,13 +181,16 @@ func BlockValidatorConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	redis.ValidationClientConfigAddOptions(prefix+".redis-validation-client-config", f)
 	f.String(prefix+".validation-server-configs-list", DefaultBlockValidatorConfig.ValidationServerConfigsList, "array of execution rpc configs given as a json string. time duration should be supplied in number indicating nanoseconds")
 	f.Duration(prefix+".validation-poll", DefaultBlockValidatorConfig.ValidationPoll, "poll time to check validations")
-	f.Uint64(prefix+".forward-blocks", DefaultBlockValidatorConfig.ForwardBlocks, "prepare entries for up to that many blocks ahead of validation (small footprint)")
+	f.Uint64(prefix+".forward-blocks", DefaultBlockValidatorConfig.ForwardBlocks, "prepare entries for up to that many blocks ahead of validation (stores batch-copy per block)")
 	f.Uint64(prefix+".prerecorded-blocks", DefaultBlockValidatorConfig.PrerecordedBlocks, "record that many blocks ahead of validation (larger footprint)")
+	f.Uint32(prefix+".batch-cache-limit", DefaultBlockValidatorConfig.BatchCacheLimit, "limit number of old batches to keep in block-validator")
 	f.String(prefix+".current-module-root", DefaultBlockValidatorConfig.CurrentModuleRoot, "current wasm module root ('current' read from chain, 'latest' from machines/latest dir, or provide hash)")
+	f.Uint64(prefix+".recording-iter-limit", DefaultBlockValidatorConfig.RecordingIterLimit, "limit on block recordings sent per iteration")
 	f.String(prefix+".pending-upgrade-module-root", DefaultBlockValidatorConfig.PendingUpgradeModuleRoot, "pending upgrade wasm module root to additionally validate (hash, 'latest' or empty)")
 	f.Bool(prefix+".failure-is-fatal", DefaultBlockValidatorConfig.FailureIsFatal, "failing a validation is treated as a fatal error")
 	BlockValidatorDangerousConfigAddOptions(prefix+".dangerous", f)
 	f.String(prefix+".memory-free-limit", DefaultBlockValidatorConfig.MemoryFreeLimit, "minimum free-memory limit after reaching which the blockvalidator pauses validation. Enabled by default as 1GB, to disable provide empty string")
+	f.String(prefix+".block-inputs-file-path", DefaultBlockValidatorConfig.BlockInputsFilePath, "directory to write block validation inputs files")
 }
 
 func BlockValidatorDangerousConfigAddOptions(prefix string, f *pflag.FlagSet) {
@@ -186,13 +203,16 @@ var DefaultBlockValidatorConfig = BlockValidatorConfig{
 	ValidationServer:            rpcclient.DefaultClientConfig,
 	RedisValidationClientConfig: redis.DefaultValidationClientConfig,
 	ValidationPoll:              time.Second,
-	ForwardBlocks:               1024,
+	ForwardBlocks:               128,
 	PrerecordedBlocks:           uint64(2 * runtime.NumCPU()),
+	BatchCacheLimit:             20,
 	CurrentModuleRoot:           "current",
 	PendingUpgradeModuleRoot:    "latest",
 	FailureIsFatal:              true,
 	Dangerous:                   DefaultBlockValidatorDangerousConfig,
+	BlockInputsFilePath:         "./target/validation_inputs",
 	MemoryFreeLimit:             "default",
+	RecordingIterLimit:          20,
 }
 
 var TestBlockValidatorConfig = BlockValidatorConfig{
@@ -202,11 +222,14 @@ var TestBlockValidatorConfig = BlockValidatorConfig{
 	RedisValidationClientConfig: redis.TestValidationClientConfig,
 	ValidationPoll:              100 * time.Millisecond,
 	ForwardBlocks:               128,
+	BatchCacheLimit:             20,
 	PrerecordedBlocks:           uint64(2 * runtime.NumCPU()),
+	RecordingIterLimit:          20,
 	CurrentModuleRoot:           "latest",
 	PendingUpgradeModuleRoot:    "latest",
 	FailureIsFatal:              true,
 	Dangerous:                   DefaultBlockValidatorDangerousConfig,
+	BlockInputsFilePath:         "./target/validation_inputs",
 	MemoryFreeLimit:             "default",
 }
 
@@ -263,7 +286,15 @@ func NewBlockValidator(
 		progressValidationsChan: make(chan struct{}, 1),
 		config:                  config,
 		fatalErr:                fatalErr,
+		prevBatchCache:          make(map[uint64][]byte),
+	}
+	valInputsWriter, err := inputs.NewWriter(
+		inputs.WithBaseDir(ret.stack.InstanceDir()),
+		inputs.WithSlug("BlockValidator"))
+	if err != nil {
+		return nil, err
 	}
+	ret.validationInputsWriter = valInputsWriter
 	if !config().Dangerous.ResetBlockValidation {
 		validated, err := ret.ReadLastValidatedInfo()
 		if err != nil {
@@ -311,6 +342,7 @@ func NewBlockValidator(
 
 func atomicStorePos(addr *atomic.Uint64, val arbutil.MessageIndex, metr metrics.Gauge) {
 	addr.Store(uint64(val))
+	// #nosec G115
 	metr.Update(int64(val))
 }
 
@@ -494,18 +526,16 @@ func (v *BlockValidator) sendRecord(s *validationStatus) error {
 }
 
 //nolint:gosec
-func (v *BlockValidator) writeToFile(validationEntry *validationEntry, moduleRoot common.Hash) error {
-	input, err := validationEntry.ToInput([]string{"wavm"})
+func (v *BlockValidator) writeToFile(validationEntry *validationEntry) error {
+	input, err := validationEntry.ToInput([]ethdb.WasmTarget{rawdb.TargetWavm})
 	if err != nil {
 		return err
 	}
-	for _, spawner := range v.execSpawners {
-		if validator.SpawnerSupportsModule(spawner, moduleRoot) {
-			_, err = spawner.WriteToFile(input, validationEntry.End, moduleRoot).Await(v.GetContext())
-			return err
-		}
+	inputJson := server_api.ValidationInputToJson(input)
+	if err := v.validationInputsWriter.Write(inputJson); err != nil {
+		return err
 	}
-	return errors.New("did not find exec spawner for wasmModuleRoot")
+	return nil
 }
 
 func (v *BlockValidator) SetCurrentWasmModuleRoot(hash common.Hash) error {
@@ -562,32 +592,63 @@ func (v *BlockValidator) createNextValidationEntry(ctx context.Context) (bool, e
 	}
 	if v.nextCreateStartGS.PosInBatch == 0 || v.nextCreateBatchReread {
 		// new batch
-		found, batch, batchBlockHash, count, err := v.readBatch(ctx, v.nextCreateStartGS.Batch)
+		found, fullBatchInfo, err := v.readFullBatch(ctx, v.nextCreateStartGS.Batch)
 		if !found {
 			return false, err
 		}
-		v.nextCreateBatch = batch
-		v.nextCreateBatchBlockHash = batchBlockHash
-		v.nextCreateBatchMsgCount = count
-		validatorMsgCountCurrentBatch.Update(int64(count))
+		if v.nextCreateBatch != nil {
+			v.prevBatchCache[v.nextCreateBatch.Number] = v.nextCreateBatch.PostedData
+		}
+		v.nextCreateBatch = fullBatchInfo
+		// #nosec G115
+		validatorMsgCountCurrentBatch.Update(int64(fullBatchInfo.MsgCount))
+		batchCacheLimit := v.config().BatchCacheLimit
+		if len(v.prevBatchCache) > int(batchCacheLimit) {
+			for num := range v.prevBatchCache {
+				if num+uint64(batchCacheLimit) < v.nextCreateStartGS.Batch {
+					delete(v.prevBatchCache, num)
+				}
+			}
+		}
 		v.nextCreateBatchReread = false
 	}
 	endGS := validator.GoGlobalState{
 		BlockHash: endRes.BlockHash,
 		SendRoot:  endRes.SendRoot,
 	}
-	if pos+1 < v.nextCreateBatchMsgCount {
+	if pos+1 < v.nextCreateBatch.MsgCount {
 		endGS.Batch = v.nextCreateStartGS.Batch
 		endGS.PosInBatch = v.nextCreateStartGS.PosInBatch + 1
-	} else if pos+1 == v.nextCreateBatchMsgCount {
+	} else if pos+1 == v.nextCreateBatch.MsgCount {
 		endGS.Batch = v.nextCreateStartGS.Batch + 1
 		endGS.PosInBatch = 0
 	} else {
-		return false, fmt.Errorf("illegal batch msg count %d pos %d batch %d", v.nextCreateBatchMsgCount, pos, endGS.Batch)
+		return false, fmt.Errorf("illegal batch msg count %d pos %d batch %d", v.nextCreateBatch.MsgCount, pos, endGS.Batch)
 	}
 	chainConfig := v.streamer.ChainConfig()
+	prevBatchNums, err := msg.Message.PastBatchesRequired()
+	if err != nil {
+		return false, err
+	}
+	prevBatches := make([]validator.BatchInfo, 0, len(prevBatchNums))
+	// prevBatchNums are only used for batch reports, each is only used once
+	for _, batchNum := range prevBatchNums {
+		data, found := v.prevBatchCache[batchNum]
+		if found {
+			delete(v.prevBatchCache, batchNum)
+		} else {
+			data, err = v.readPostedBatch(ctx, batchNum)
+			if err != nil {
+				return false, err
+			}
+		}
+		prevBatches = append(prevBatches, validator.BatchInfo{
+			Number: batchNum,
+			Data:   data,
+		})
+	}
 	entry, err := newValidationEntry(
-		pos, v.nextCreateStartGS, endGS, msg, v.nextCreateBatch, v.nextCreateBatchBlockHash, v.nextCreatePrevDelayed, chainConfig,
+		pos, v.nextCreateStartGS, endGS, msg, v.nextCreateBatch, prevBatches, v.nextCreatePrevDelayed, chainConfig,
 	)
 	if err != nil {
 		return false, err
@@ -646,6 +707,10 @@ func (v *BlockValidator) sendNextRecordRequests(ctx context.Context) (bool, erro
 	if recordUntil < pos {
 		return false, nil
 	}
+	recordUntilLimit := pos + arbutil.MessageIndex(v.config().RecordingIterLimit)
+	if recordUntil > recordUntilLimit {
+		recordUntil = recordUntilLimit
+	}
 	log.Trace("preparing to record", "pos", pos, "until", recordUntil)
 	// prepare could take a long time so we do it without a lock
 	err := v.recorder.PrepareForRecord(ctx, pos, recordUntil)
@@ -719,6 +784,7 @@ func (v *BlockValidator) iterativeValidationPrint(ctx context.Context) time.Dura
 	if err != nil {
 		printedCount = -1
 	} else {
+		// #nosec G115
 		printedCount = int64(batchMsgs) + int64(validated.GlobalState.PosInBatch)
 	}
 	log.Info("validated execution", "messageCount", printedCount, "globalstate", validated.GlobalState, "WasmRoots", validated.WasmRoots)
@@ -773,7 +839,7 @@ validationsLoop:
 				runEnd, err := run.Current()
 				if err == nil && runEnd != validationStatus.Entry.End {
 					err = fmt.Errorf("validation failed: expected %v got %v", validationStatus.Entry.End, runEnd)
-					writeErr := v.writeToFile(validationStatus.Entry, run.WasmModuleRoot())
+					writeErr := v.writeToFile(validationStatus.Entry)
 					if writeErr != nil {
 						log.Warn("failed to write debug results file", "err", writeErr)
 					}
@@ -982,14 +1048,19 @@ func (v *BlockValidator) UpdateLatestStaked(count arbutil.MessageIndex, globalSt
 		v.nextCreateStartGS = globalState
 		v.nextCreatePrevDelayed = msg.DelayedMessagesRead
 		v.nextCreateBatchReread = true
+		if v.nextCreateBatch != nil {
+			v.prevBatchCache[v.nextCreateBatch.Number] = v.nextCreateBatch.PostedData
+		}
 		v.createdA.Store(countUint64)
 	}
 	// under the reorg mutex we don't need atomic access
 	if v.recordSentA.Load() < countUint64 {
 		v.recordSentA.Store(countUint64)
 	}
+	// #nosec G115
 	v.validatedA.Store(countUint64)
 	v.valLoopPos = count
+	// #nosec G115
 	validatorMsgCountValidatedGauge.Update(int64(countUint64))
 	err = v.writeLastValidated(globalState, nil) // we don't know which wasm roots were validated
 	if err != nil {
@@ -1006,6 +1077,7 @@ func (v *BlockValidator) ReorgToBatchCount(count uint64) {
 	defer v.reorgMutex.Unlock()
 	if v.nextCreateStartGS.Batch >= count {
 		v.nextCreateBatchReread = true
+		v.prevBatchCache = make(map[uint64][]byte)
 	}
 }
 
@@ -1046,6 +1118,7 @@ func (v *BlockValidator) Reorg(ctx context.Context, count arbutil.MessageIndex)
 	v.nextCreateStartGS = buildGlobalState(*res, endPosition)
 	v.nextCreatePrevDelayed = msg.DelayedMessagesRead
 	v.nextCreateBatchReread = true
+	v.prevBatchCache = make(map[uint64][]byte)
 	countUint64 := uint64(count)
 	v.createdA.Store(countUint64)
 	// under the reorg mutex we don't need atomic access
@@ -1054,6 +1127,7 @@ func (v *BlockValidator) Reorg(ctx context.Context, count arbutil.MessageIndex)
 	}
 	if v.validatedA.Load() > countUint64 {
 		v.validatedA.Store(countUint64)
+		// #nosec G115
 		validatorMsgCountValidatedGauge.Update(int64(countUint64))
 		err := v.writeLastValidated(v.nextCreateStartGS, nil) // we don't know which wasm roots were validated
 		if err != nil {
@@ -1245,6 +1319,7 @@ func (v *BlockValidator) checkValidatedGSCaughtUp() (bool, error) {
 	atomicStorePos(&v.createdA, count, validatorMsgCountCreatedGauge)
 	atomicStorePos(&v.recordSentA, count, validatorMsgCountRecordSentGauge)
 	atomicStorePos(&v.validatedA, count, validatorMsgCountValidatedGauge)
+	// #nosec G115
 	validatorMsgCountValidatedGauge.Update(int64(count))
 	v.chainCaughtUp = true
 	return true, nil
diff --git a/staker/challenge-cache/cache.go b/staker/challenge-cache/cache.go
index ed4fad6..5dca276 100644
--- a/staker/challenge-cache/cache.go
+++ b/staker/challenge-cache/cache.go
@@ -187,12 +187,12 @@ func (c *Cache) Prune(ctx context.Context, messageNumber uint64) error {
 		if info.IsDir() {
 			matches := pattern.FindStringSubmatch(info.Name())
 			if len(matches) > 1 {
-				dirNameMessageNum, err := strconv.Atoi(matches[1])
+				dirNameMessageNum, err := strconv.ParseUint(matches[1], 10, 64)
 				if err != nil {
 					return err
 				}
 				// Collect the directory path if the message number is <= the specified value.
-				if dirNameMessageNum <= int(messageNumber) {
+				if dirNameMessageNum <= messageNumber {
 					pathsToDelete = append(pathsToDelete, path)
 				}
 			}
diff --git a/staker/challenge-cache/cache_test.go b/staker/challenge-cache/cache_test.go
index af0a058..40be627 100644
--- a/staker/challenge-cache/cache_test.go
+++ b/staker/challenge-cache/cache_test.go
@@ -166,8 +166,9 @@ func TestPrune(t *testing.T) {
 				}
 				key = &Key{
 					WavmModuleRoot: root,
-					MessageHeight:  uint64(i),
-					StepHeights:    []uint64{0},
+					// #nosec G115
+					MessageHeight: uint64(i),
+					StepHeights:   []uint64{0},
 				}
 				if err = cache.Put(key, hashes); err != nil {
 					t.Fatal(err)
@@ -182,8 +183,9 @@ func TestPrune(t *testing.T) {
 			for i := 0; i <= 5; i++ {
 				key = &Key{
 					WavmModuleRoot: root,
-					MessageHeight:  uint64(i),
-					StepHeights:    []uint64{0},
+					// #nosec G115
+					MessageHeight: uint64(i),
+					StepHeights:   []uint64{0},
 				}
 				if _, err = cache.Get(key, 3); !errors.Is(err, ErrNotFoundInCache) {
 					t.Error(err)
@@ -193,8 +195,9 @@ func TestPrune(t *testing.T) {
 			for i := 6; i < totalMessages; i++ {
 				key = &Key{
 					WavmModuleRoot: root,
-					MessageHeight:  uint64(i),
-					StepHeights:    []uint64{0},
+					// #nosec G115
+					MessageHeight: uint64(i),
+					StepHeights:   []uint64{0},
 				}
 				items, err := cache.Get(key, 3)
 				if err != nil {
diff --git a/staker/challenge_manager.go b/staker/challenge_manager.go
index 80cafcc..27cb92a 100644
--- a/staker/challenge_manager.go
+++ b/staker/challenge_manager.go
@@ -14,7 +14,9 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -293,7 +295,7 @@ func (m *ChallengeManager) bisect(ctx context.Context, backend ChallengeBackend,
 	if newChallengeLength < bisectionDegree {
 		bisectionDegree = newChallengeLength
 	}
-	newSegments := make([][32]byte, int(bisectionDegree+1))
+	newSegments := make([][32]byte, bisectionDegree+1)
 	position := startSegmentPosition
 	normalSegmentLength := newChallengeLength / bisectionDegree
 	for i := range newSegments {
@@ -467,7 +469,7 @@ func (m *ChallengeManager) createExecutionBackend(ctx context.Context, step uint
 	if err != nil {
 		return fmt.Errorf("error creating validation entry for challenge %v msg %v for execution challenge: %w", m.challengeIndex, initialCount, err)
 	}
-	input, err := entry.ToInput([]string{"wavm"})
+	input, err := entry.ToInput([]ethdb.WasmTarget{rawdb.TargetWavm})
 	if err != nil {
 		return fmt.Errorf("error getting validation entry input of challenge %v msg %v: %w", m.challengeIndex, initialCount, err)
 	}
@@ -564,6 +566,7 @@ func (m *ChallengeManager) Act(ctx context.Context) (*types.Transaction, error)
 			nextMovePos,
 		)
 	}
+	// #nosec G115
 	err = m.createExecutionBackend(ctx, uint64(nextMovePos))
 	if err != nil {
 		return nil, fmt.Errorf("error creating execution backend: %w", err)
diff --git a/staker/challenge_test.go b/staker/challenge_test.go
index 4534b04..33f1644 100644
--- a/staker/challenge_test.go
+++ b/staker/challenge_test.go
@@ -77,7 +77,7 @@ func CreateChallenge(
 		resultReceiverAddr,
 		maxInboxMessage,
 		[2][32]byte{startHashBytes, endHashBytes},
-		big.NewInt(int64(endMachineSteps)),
+		new(big.Int).SetUint64(endMachineSteps),
 		asserter,
 		challenger,
 		big.NewInt(100),
diff --git a/staker/fast_confirm.go b/staker/fast_confirm.go
index 88f457f..5dc7f01 100644
--- a/staker/fast_confirm.go
+++ b/staker/fast_confirm.go
@@ -121,10 +121,12 @@ func (f *FastConfirmSafe) tryFastConfirmation(ctx context.Context, blockHash com
 		return err
 	}
 	if alreadyApproved.Cmp(common.Big1) == 0 {
+		log.Info("Already approved Safe tx hash for fast confirmation, checking if we can execute the Safe tx", "safeHash", safeTxHash, "nodeHash", nodeHash)
 		_, err = f.checkApprovedHashAndExecTransaction(ctx, fastConfirmCallData, safeTxHash)
 		return err
 	}
 
+	log.Info("Approving Safe tx hash to fast confirm", "safeHash", safeTxHash, "nodeHash", nodeHash)
 	auth, err := f.builder.Auth(ctx)
 	if err != nil {
 		return err
@@ -231,6 +233,7 @@ func (f *FastConfirmSafe) checkApprovedHashAndExecTransaction(ctx context.Contex
 		if err != nil {
 			return false, err
 		}
+		log.Info("Executing Safe tx to fast confirm", "safeHash", safeTxHash)
 		_, err = f.safe.ExecTransaction(
 			auth,
 			f.wallet.RollupAddress(),
@@ -249,5 +252,6 @@ func (f *FastConfirmSafe) checkApprovedHashAndExecTransaction(ctx context.Contex
 		}
 		return true, nil
 	}
+	log.Info("Not enough Safe tx approvals yet to fast confirm", "safeHash", safeTxHash)
 	return false, nil
 }
diff --git a/staker/l1_validator.go b/staker/l1_validator.go
index dd9673e..5b0c211 100644
--- a/staker/l1_validator.go
+++ b/staker/l1_validator.go
@@ -19,6 +19,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
@@ -45,7 +46,7 @@ type L1Validator struct {
 	rollup         *RollupWatcher
 	rollupAddress  common.Address
 	validatorUtils *rollupgen.ValidatorUtils
-	client         arbutil.L1Interface
+	client         *ethclient.Client
 	builder        *txbuilder.Builder
 	wallet         ValidatorWalletInterface
 	callOpts       bind.CallOpts
@@ -57,7 +58,7 @@ type L1Validator struct {
 }
 
 func NewL1Validator(
-	client arbutil.L1Interface,
+	client *ethclient.Client,
 	wallet ValidatorWalletInterface,
 	validatorUtilsAddress common.Address,
 	callOpts bind.CallOpts,
@@ -247,6 +248,7 @@ func (v *L1Validator) generateNodeAction(
 			startStateProposedParentChain, err,
 		)
 	}
+	// #nosec G115
 	startStateProposedTime := time.Unix(int64(startStateProposedHeader.Time), 0)
 
 	v.txStreamer.PauseReorgs()
@@ -375,6 +377,7 @@ func (v *L1Validator) generateNodeAction(
 		return nil, false, fmt.Errorf("error getting rollup minimum assertion period: %w", err)
 	}
 
+	// #nosec G115
 	timeSinceProposed := big.NewInt(int64(l1BlockNumber) - int64(startStateProposedL1))
 	if timeSinceProposed.Cmp(minAssertionPeriod) < 0 {
 		// Too soon to assert
diff --git a/staker/rollup_watcher.go b/staker/rollup_watcher.go
index b35bebd..4d7db52 100644
--- a/staker/rollup_watcher.go
+++ b/staker/rollup_watcher.go
@@ -4,16 +4,19 @@
 package staker
 
 import (
+	"bytes"
 	"context"
 	"encoding/binary"
 	"errors"
 	"fmt"
 	"math/big"
+	"strings"
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
 	"github.com/offchainlabs/nitro/util/headerreader"
@@ -48,12 +51,19 @@ type RollupWatcher struct {
 	*rollupgen.RollupUserLogic
 	address             common.Address
 	fromBlock           *big.Int
-	client              arbutil.L1Interface
+	client              RollupWatcherL1Interface
 	baseCallOpts        bind.CallOpts
 	unSupportedL3Method atomic.Bool
+	supportedL3Method   atomic.Bool
 }
 
-func NewRollupWatcher(address common.Address, client arbutil.L1Interface, callOpts bind.CallOpts) (*RollupWatcher, error) {
+type RollupWatcherL1Interface interface {
+	bind.ContractBackend
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+	FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error)
+}
+
+func NewRollupWatcher(address common.Address, client RollupWatcherL1Interface, callOpts bind.CallOpts) (*RollupWatcher, error) {
 	con, err := rollupgen.NewRollupUserLogic(address, client)
 	if err != nil {
 		return nil, err
@@ -73,15 +83,41 @@ func (r *RollupWatcher) getCallOpts(ctx context.Context) *bind.CallOpts {
 	return &opts
 }
 
+const noNodeErr string = "NO_NODE"
+
+func looksLikeNoNodeError(err error) bool {
+	if err == nil {
+		return false
+	}
+	if strings.Contains(err.Error(), noNodeErr) {
+		return true
+	}
+	var errWithData rpc.DataError
+	ok := errors.As(err, &errWithData)
+	if !ok {
+		return false
+	}
+	dataString, ok := errWithData.ErrorData().(string)
+	if !ok {
+		return false
+	}
+	data := common.FromHex(dataString)
+	return bytes.Contains(data, []byte(noNodeErr))
+}
+
 func (r *RollupWatcher) getNodeCreationBlock(ctx context.Context, nodeNum uint64) (*big.Int, error) {
 	callOpts := r.getCallOpts(ctx)
 	if !r.unSupportedL3Method.Load() {
 		createdAtBlock, err := r.GetNodeCreationBlockForLogLookup(callOpts, nodeNum)
 		if err == nil {
+			r.supportedL3Method.Store(true)
 			return createdAtBlock, nil
 		}
-		log.Trace("failed to call getNodeCreationBlockForLogLookup, falling back on node CreatedAtBlock field", "err", err)
-		if headerreader.ExecutionRevertedRegexp.MatchString(err.Error()) {
+		if headerreader.ExecutionRevertedRegexp.MatchString(err.Error()) && !looksLikeNoNodeError(err) {
+			if r.supportedL3Method.Load() {
+				return nil, fmt.Errorf("getNodeCreationBlockForLogLookup failed despite previously succeeding: %w", err)
+			}
+			log.Info("getNodeCreationBlockForLogLookup does not seem to exist, falling back on node CreatedAtBlock field", "err", err)
 			r.unSupportedL3Method.Store(true)
 		} else {
 			return nil, err
@@ -196,7 +232,7 @@ func (r *RollupWatcher) LookupNodeChildren(ctx context.Context, nodeNum uint64,
 		if logQueryRangeSize == 0 {
 			query.ToBlock = toBlock
 		} else {
-			query.ToBlock = new(big.Int).Add(fromBlock, big.NewInt(int64(logQueryRangeSize)))
+			query.ToBlock = new(big.Int).Add(fromBlock, new(big.Int).SetUint64(logQueryRangeSize))
 		}
 		if query.ToBlock.Cmp(toBlock) > 0 {
 			query.ToBlock = toBlock
diff --git a/staker/staker.go b/staker/staker.go
index 9d917d1..2489bbb 100644
--- a/staker/staker.go
+++ b/staker/staker.go
@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -142,6 +143,8 @@ func (c *L1ValidatorConfig) Validate() error {
 	return nil
 }
 
+type L1ValidatorConfigFetcher func() *L1ValidatorConfig
+
 var DefaultL1ValidatorConfig = L1ValidatorConfig{
 	Enable:                    true,
 	Strategy:                  "Watchtower",
@@ -257,7 +260,7 @@ type Staker struct {
 	confirmedNotifiers      []LatestConfirmedNotifier
 	activeChallenge         *ChallengeManager
 	baseCallOpts            bind.CallOpts
-	config                  L1ValidatorConfig
+	config                  L1ValidatorConfigFetcher
 	highGasBlocksBuffer     *big.Int
 	lastActCalledBlock      *big.Int
 	inactiveLastCheckedNode *nodeAndHash
@@ -266,7 +269,6 @@ type Staker struct {
 	inboxReader             InboxReaderInterface
 	statelessBlockValidator *StatelessBlockValidator
 	fatalErr                chan<- error
-	enableFastConfirmation  bool
 	fastConfirmSafe         *FastConfirmSafe
 }
 
@@ -279,7 +281,7 @@ type ValidatorWalletInterface interface {
 	TxSenderAddress() *common.Address
 	RollupAddress() common.Address
 	ChallengeManagerAddress() common.Address
-	L1Client() arbutil.L1Interface
+	L1Client() *ethclient.Client
 	TestTransactions(context.Context, []*types.Transaction) error
 	ExecuteTransactions(context.Context, *txbuilder.Builder, common.Address) (*types.Transaction, error)
 	TimeoutChallenges(context.Context, []uint64) (*types.Transaction, error)
@@ -295,7 +297,7 @@ func NewStaker(
 	l1Reader *headerreader.HeaderReader,
 	wallet ValidatorWalletInterface,
 	callOpts bind.CallOpts,
-	config L1ValidatorConfig,
+	config L1ValidatorConfigFetcher,
 	blockValidator *BlockValidator,
 	statelessBlockValidator *StatelessBlockValidator,
 	stakedNotifiers []LatestStakedNotifier,
@@ -304,7 +306,7 @@ func NewStaker(
 	fatalErr chan<- error,
 ) (*Staker, error) {
 
-	if err := config.Validate(); err != nil {
+	if err := config().Validate(); err != nil {
 		return nil, err
 	}
 	client := l1Reader.Client()
@@ -314,7 +316,7 @@ func NewStaker(
 		return nil, err
 	}
 	stakerLastSuccessfulActionGauge.Update(time.Now().Unix())
-	if config.StartValidationFromStaked && blockValidator != nil {
+	if config().StartValidationFromStaked && blockValidator != nil {
 		stakedNotifiers = append(stakedNotifiers, blockValidator)
 	}
 	inactiveValidatedNodes := btree.NewG(2, func(a, b validatedNode) bool {
@@ -327,7 +329,7 @@ func NewStaker(
 		confirmedNotifiers:      confirmedNotifiers,
 		baseCallOpts:            callOpts,
 		config:                  config,
-		highGasBlocksBuffer:     big.NewInt(config.PostingStrategy.HighGasDelayBlocks),
+		highGasBlocksBuffer:     big.NewInt(config().PostingStrategy.HighGasDelayBlocks),
 		lastActCalledBlock:      nil,
 		inboxReader:             statelessBlockValidator.inboxReader,
 		statelessBlockValidator: statelessBlockValidator,
@@ -345,11 +347,12 @@ func (s *Staker) Initialize(ctx context.Context) error {
 	if walletAddressOrZero != (common.Address{}) {
 		s.updateStakerBalanceMetric(ctx)
 	}
-	if s.blockValidator != nil && s.config.StartValidationFromStaked {
+	if s.blockValidator != nil && s.config().StartValidationFromStaked {
 		latestStaked, _, err := s.validatorUtils.LatestStaked(&s.baseCallOpts, s.rollupAddress, walletAddressOrZero)
 		if err != nil {
 			return err
 		}
+		// #nosec G115
 		stakerLatestStakedNodeGauge.Update(int64(latestStaked))
 		if latestStaked == 0 {
 			return nil
@@ -360,7 +363,10 @@ func (s *Staker) Initialize(ctx context.Context) error {
 			return err
 		}
 
-		return s.blockValidator.InitAssumeValid(stakedInfo.AfterState().GlobalState)
+		err = s.blockValidator.InitAssumeValid(stakedInfo.AfterState().GlobalState)
+		if err != nil {
+			return err
+		}
 	}
 	return s.setupFastConfirmation(ctx)
 }
@@ -369,7 +375,8 @@ func (s *Staker) Initialize(ctx context.Context) error {
 // based on the config, the wallet address, and the on-chain rollup designated fast confirmer.
 // Before this function, both variables should be their default (i.e. fast confirmation is disabled).
 func (s *Staker) setupFastConfirmation(ctx context.Context) error {
-	if !s.config.EnableFastConfirmation {
+	cfg := s.config()
+	if !cfg.EnableFastConfirmation {
 		return nil
 	}
 	if s.wallet.Address() == nil {
@@ -386,9 +393,9 @@ func (s *Staker) setupFastConfirmation(ctx context.Context) error {
 	if err != nil {
 		return fmt.Errorf("getting rollup fast confirmer address: %w", err)
 	}
+	log.Info("Setting up fast confirmation", "wallet", walletAddress, "fastConfirmer", fastConfirmer)
 	if fastConfirmer == walletAddress {
 		// We can directly fast confirm nodes
-		s.enableFastConfirmation = true
 		return nil
 	} else if fastConfirmer == (common.Address{}) {
 		// No fast confirmer enabled
@@ -400,7 +407,7 @@ func (s *Staker) setupFastConfirmation(ctx context.Context) error {
 		fastConfirmer,
 		s.builder,
 		s.wallet,
-		s.config.gasRefunder,
+		cfg.gasRefunder,
 		s.l1Reader,
 	)
 	if err != nil {
@@ -415,13 +422,12 @@ func (s *Staker) setupFastConfirmation(ctx context.Context) error {
 	if !isOwner {
 		return fmt.Errorf("staker wallet address %v is not an owner of the fast confirm safe %v", walletAddress, fastConfirmer)
 	}
-	s.enableFastConfirmation = true
 	s.fastConfirmSafe = fastConfirmSafe
 	return nil
 }
 
 func (s *Staker) tryFastConfirmationNodeNumber(ctx context.Context, number uint64, hash common.Hash) error {
-	if !s.enableFastConfirmation {
+	if !s.config().EnableFastConfirmation {
 		return nil
 	}
 	nodeInfo, err := s.rollup.LookupNode(ctx, number)
@@ -432,7 +438,7 @@ func (s *Staker) tryFastConfirmationNodeNumber(ctx context.Context, number uint6
 }
 
 func (s *Staker) tryFastConfirmation(ctx context.Context, blockHash common.Hash, sendRoot common.Hash, nodeHash common.Hash) error {
-	if !s.enableFastConfirmation {
+	if !s.config().EnableFastConfirmation {
 		return nil
 	}
 	if s.fastConfirmSafe != nil {
@@ -442,6 +448,7 @@ func (s *Staker) tryFastConfirmation(ctx context.Context, blockHash common.Hash,
 	if err != nil {
 		return err
 	}
+	log.Info("Fast confirming node with wallet", "wallet", auth.From, "nodeHash", nodeHash)
 	_, err = s.rollup.FastConfirmNextNode(auth, blockHash, sendRoot, nodeHash)
 	return err
 }
@@ -516,8 +523,9 @@ func (s *Staker) Start(ctxIn context.Context) {
 			}
 		}()
 		var err error
-		if common.HexToAddress(s.config.GasRefunderAddress) != (common.Address{}) {
-			gasRefunderBalance, err := s.client.BalanceAt(ctx, common.HexToAddress(s.config.GasRefunderAddress), nil)
+		cfg := s.config()
+		if common.HexToAddress(cfg.GasRefunderAddress) != (common.Address{}) {
+			gasRefunderBalance, err := s.client.BalanceAt(ctx, common.HexToAddress(cfg.GasRefunderAddress), nil)
 			if err != nil {
 				log.Warn("error fetching validator gas refunder balance", "err", err)
 			} else {
@@ -546,7 +554,7 @@ func (s *Staker) Start(ctxIn context.Context) {
 				// Try to create another tx
 				return 0
 			}
-			return s.config.StakerInterval
+			return cfg.StakerInterval
 		}
 		stakerActionFailureCounter.Inc(1)
 		backoff *= 2
@@ -566,6 +574,7 @@ func (s *Staker) Start(ctxIn context.Context) {
 		if err != nil && ctx.Err() == nil {
 			log.Error("staker: error checking latest staked", "err", err)
 		}
+		// #nosec G115
 		stakerLatestStakedNodeGauge.Update(int64(staked))
 		if stakedGlobalState != nil {
 			for _, notifier := range s.stakedNotifiers {
@@ -581,13 +590,14 @@ func (s *Staker) Start(ctxIn context.Context) {
 				log.Error("staker: error checking latest confirmed", "err", err)
 			}
 		}
+		// #nosec G115
 		stakerLatestConfirmedNodeGauge.Update(int64(confirmed))
 		if confirmedGlobalState != nil {
 			for _, notifier := range s.confirmedNotifiers {
 				notifier.UpdateLatestConfirmed(confirmedMsgCount, *confirmedGlobalState)
 			}
 		}
-		return s.config.StakerInterval
+		return s.config().StakerInterval
 	})
 }
 
@@ -608,6 +618,7 @@ func (s *Staker) IsWhitelisted(ctx context.Context) (bool, error) {
 }
 
 func (s *Staker) shouldAct(ctx context.Context) bool {
+	cfg := s.config()
 	var gasPriceHigh = false
 	var gasPriceFloat float64
 	gasPrice, err := s.client.SuggestGasPrice(ctx)
@@ -615,7 +626,7 @@ func (s *Staker) shouldAct(ctx context.Context) bool {
 		log.Warn("error getting gas price", "err", err)
 	} else {
 		gasPriceFloat = float64(gasPrice.Int64()) / 1e9
-		if gasPriceFloat >= s.config.PostingStrategy.HighGasThreshold {
+		if gasPriceFloat >= cfg.PostingStrategy.HighGasThreshold {
 			gasPriceHigh = true
 		}
 	}
@@ -640,14 +651,14 @@ func (s *Staker) shouldAct(ctx context.Context) bool {
 	// Clamp `s.highGasBlocksBuffer` to between 0 and HighGasDelayBlocks
 	if s.highGasBlocksBuffer.Sign() < 0 {
 		s.highGasBlocksBuffer.SetInt64(0)
-	} else if s.highGasBlocksBuffer.Cmp(big.NewInt(s.config.PostingStrategy.HighGasDelayBlocks)) > 0 {
-		s.highGasBlocksBuffer.SetInt64(s.config.PostingStrategy.HighGasDelayBlocks)
+	} else if s.highGasBlocksBuffer.Cmp(big.NewInt(cfg.PostingStrategy.HighGasDelayBlocks)) > 0 {
+		s.highGasBlocksBuffer.SetInt64(cfg.PostingStrategy.HighGasDelayBlocks)
 	}
 	if gasPriceHigh && s.highGasBlocksBuffer.Sign() > 0 {
 		log.Warn(
 			"not acting yet as gas price is high",
 			"gasPrice", gasPriceFloat,
-			"highGasPriceConfig", s.config.PostingStrategy.HighGasThreshold,
+			"highGasPriceConfig", cfg.PostingStrategy.HighGasThreshold,
 			"highGasBuffer", s.highGasBlocksBuffer,
 		)
 		return false
@@ -678,7 +689,8 @@ func (s *Staker) confirmDataPosterIsReady(ctx context.Context) error {
 }
 
 func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
-	if s.config.strategy != WatchtowerStrategy {
+	cfg := s.config()
+	if cfg.strategy != WatchtowerStrategy {
 		err := s.confirmDataPosterIsReady(ctx)
 		if err != nil {
 			return nil, err
@@ -720,6 +732,7 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 	if err != nil {
 		return nil, fmt.Errorf("error getting latest staked node of own wallet %v: %w", walletAddressOrZero, err)
 	}
+	// #nosec G115
 	stakerLatestStakedNodeGauge.Update(int64(latestStakedNodeNum))
 	if rawInfo != nil {
 		rawInfo.LatestStakedNode = latestStakedNodeNum
@@ -732,7 +745,7 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 		StakeExists:          rawInfo != nil,
 	}
 
-	effectiveStrategy := s.config.strategy
+	effectiveStrategy := cfg.strategy
 	nodesLinear, err := s.validatorUtils.AreUnresolvedNodesLinear(callOpts, s.rollupAddress)
 	if err != nil {
 		return nil, fmt.Errorf("error checking for rollup assertion fork: %w", err)
@@ -760,7 +773,7 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 		info.LatestStakedNodeHash = s.inactiveLastCheckedNode.hash
 	}
 
-	if s.config.EnableFastConfirmation {
+	if cfg.EnableFastConfirmation {
 		firstUnresolvedNode, err := s.rollup.FirstUnresolvedNode(callOpts)
 		if err != nil {
 			return nil, err
@@ -792,14 +805,14 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 				confirmedCorrect = stakedOnNode
 			}
 			if confirmedCorrect {
+				log.Info("trying to fast confirm previous node", "node", firstUnresolvedNode, "nodeHash", nodeInfo.NodeHash)
 				err = s.tryFastConfirmationNodeNumber(ctx, firstUnresolvedNode, nodeInfo.NodeHash)
 				if err != nil {
 					return nil, err
 				}
 				if s.builder.BuildingTransactionCount() > 0 {
 					// Try to fast confirm previous nodes before working on new ones
-					log.Info("fast confirming previous node", "node", firstUnresolvedNode)
-					return s.wallet.ExecuteTransactions(ctx, s.builder, s.config.gasRefunder)
+					return s.wallet.ExecuteTransactions(ctx, s.builder, cfg.gasRefunder)
 				}
 			}
 		}
@@ -886,7 +899,7 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 				return nil, fmt.Errorf("error withdrawing staker funds from our staker %v: %w", walletAddressOrZero, err)
 			}
 			log.Info("removing old stake and withdrawing funds")
-			return s.wallet.ExecuteTransactions(ctx, s.builder, s.config.gasRefunder)
+			return s.wallet.ExecuteTransactions(ctx, s.builder, cfg.gasRefunder)
 		}
 	}
 
@@ -940,7 +953,7 @@ func (s *Staker) Act(ctx context.Context) (*types.Transaction, error) {
 	if info.StakerInfo == nil && info.StakeExists {
 		log.Info("staking to execute transactions")
 	}
-	return s.wallet.ExecuteTransactions(ctx, s.builder, s.config.gasRefunder)
+	return s.wallet.ExecuteTransactions(ctx, s.builder, cfg.gasRefunder)
 }
 
 func (s *Staker) handleConflict(ctx context.Context, info *StakerInfo) error {
@@ -966,7 +979,7 @@ func (s *Staker) handleConflict(ctx context.Context, info *StakerInfo) error {
 			*info.CurrentChallenge,
 			s.statelessBlockValidator,
 			latestConfirmedCreated,
-			s.config.ConfirmationBlocks,
+			s.config().ConfirmationBlocks,
 		)
 		if err != nil {
 			return fmt.Errorf("error creating challenge manager: %w", err)
@@ -980,8 +993,9 @@ func (s *Staker) handleConflict(ctx context.Context, info *StakerInfo) error {
 }
 
 func (s *Staker) advanceStake(ctx context.Context, info *OurStakerInfo, effectiveStrategy StakerStrategy) error {
+	cfg := s.config()
 	active := effectiveStrategy >= StakeLatestStrategy
-	action, wrongNodesExist, err := s.generateNodeAction(ctx, info, effectiveStrategy, &s.config)
+	action, wrongNodesExist, err := s.generateNodeAction(ctx, info, effectiveStrategy, cfg)
 	if err != nil {
 		return fmt.Errorf("error generating node action: %w", err)
 	}
@@ -995,7 +1009,7 @@ func (s *Staker) advanceStake(ctx context.Context, info *OurStakerInfo, effectiv
 
 	switch action := action.(type) {
 	case createNodeAction:
-		if wrongNodesExist && s.config.DisableChallenge {
+		if wrongNodesExist && cfg.DisableChallenge {
 			log.Error("refusing to challenge assertion as config disables challenges")
 			info.CanProgress = false
 			return nil
@@ -1192,7 +1206,7 @@ func (s *Staker) createConflict(ctx context.Context, info *StakerInfo) error {
 }
 
 func (s *Staker) Strategy() StakerStrategy {
-	return s.config.strategy
+	return s.config().strategy
 }
 
 func (s *Staker) Rollup() *RollupWatcher {
diff --git a/staker/stateless_block_validator.go b/staker/stateless_block_validator.go
index e823226..9257c55 100644
--- a/staker/stateless_block_validator.go
+++ b/staker/stateless_block_validator.go
@@ -7,7 +7,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"runtime"
 	"testing"
 
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
@@ -24,6 +23,7 @@ import (
 	"github.com/offchainlabs/nitro/util/rpcclient"
 	"github.com/offchainlabs/nitro/validator"
 	"github.com/offchainlabs/nitro/validator/client/redis"
+	"github.com/offchainlabs/nitro/validator/server_api"
 
 	validatorclient "github.com/offchainlabs/nitro/validator/client"
 )
@@ -41,6 +41,7 @@ type StatelessBlockValidator struct {
 	streamer     TransactionStreamerInterface
 	db           ethdb.Database
 	dapReaders   []daprovider.Reader
+	stack        *node.Node
 }
 
 type BlockValidatorRegistrer interface {
@@ -115,6 +116,13 @@ const (
 	Ready
 )
 
+type FullBatchInfo struct {
+	Number     uint64
+	PostedData []byte
+	MsgCount   arbutil.MessageIndex
+	Preimages  map[arbutil.PreimageType]map[common.Hash][]byte
+}
+
 type validationEntry struct {
 	Stage ValidationEntryStage
 	// Valid since ReadyforRecord:
@@ -134,7 +142,7 @@ type validationEntry struct {
 	DelayedMsg []byte
 }
 
-func (e *validationEntry) ToInput(stylusArchs []string) (*validator.ValidationInput, error) {
+func (e *validationEntry) ToInput(stylusArchs []ethdb.WasmTarget) (*validator.ValidationInput, error) {
 	if e.Stage != Ready {
 		return nil, errors.New("cannot create input from non-ready entry")
 	}
@@ -143,21 +151,22 @@ func (e *validationEntry) ToInput(stylusArchs []string) (*validator.ValidationIn
 		HasDelayedMsg: e.HasDelayedMsg,
 		DelayedMsgNr:  e.DelayedMsgNr,
 		Preimages:     e.Preimages,
-		UserWasms:     make(map[string]map[common.Hash][]byte, len(e.UserWasms)),
+		UserWasms:     make(map[ethdb.WasmTarget]map[common.Hash][]byte, len(e.UserWasms)),
 		BatchInfo:     e.BatchInfo,
 		DelayedMsg:    e.DelayedMsg,
 		StartState:    e.Start,
 		DebugChain:    e.ChainConfig.DebugMode(),
 	}
+	if len(stylusArchs) == 0 && len(e.UserWasms) > 0 {
+		return nil, fmt.Errorf("stylus support is required")
+	}
 	for _, stylusArch := range stylusArchs {
 		res.UserWasms[stylusArch] = make(map[common.Hash][]byte)
 	}
-	for hash, info := range e.UserWasms {
+	for hash, asmMap := range e.UserWasms {
 		for _, stylusArch := range stylusArchs {
-			if stylusArch == "wavm" {
-				res.UserWasms[stylusArch][hash] = info.Module
-			} else if stylusArch == runtime.GOARCH {
-				res.UserWasms[stylusArch][hash] = info.Asm
+			if asm, exists := asmMap[stylusArch]; exists {
+				res.UserWasms[stylusArch][hash] = asm
 			} else {
 				return nil, fmt.Errorf("stylusArch not supported by block validator: %v", stylusArch)
 			}
@@ -171,16 +180,28 @@ func newValidationEntry(
 	start validator.GoGlobalState,
 	end validator.GoGlobalState,
 	msg *arbostypes.MessageWithMetadata,
-	batch []byte,
-	batchBlockHash common.Hash,
+	fullBatchInfo *FullBatchInfo,
+	prevBatches []validator.BatchInfo,
 	prevDelayed uint64,
 	chainConfig *params.ChainConfig,
 ) (*validationEntry, error) {
-	batchInfo := validator.BatchInfo{
-		Number:    start.Batch,
-		BlockHash: batchBlockHash,
-		Data:      batch,
+	preimages := make(map[arbutil.PreimageType]map[common.Hash][]byte)
+	if fullBatchInfo == nil {
+		return nil, fmt.Errorf("fullbatchInfo cannot be nil")
+	}
+	if fullBatchInfo.Number != start.Batch {
+		return nil, fmt.Errorf("got wrong batch expected: %d got: %d", start.Batch, fullBatchInfo.Number)
+	}
+	valBatches := []validator.BatchInfo{
+		{
+			Number: fullBatchInfo.Number,
+			Data:   fullBatchInfo.PostedData,
+		},
 	}
+	valBatches = append(valBatches, prevBatches...)
+
+	copyPreimagesInto(preimages, fullBatchInfo.Preimages)
+
 	hasDelayed := false
 	var delayedNum uint64
 	if msg.DelayedMessagesRead == prevDelayed+1 {
@@ -189,6 +210,7 @@ func newValidationEntry(
 	} else if msg.DelayedMessagesRead != prevDelayed {
 		return nil, fmt.Errorf("illegal validation entry delayedMessage %d, previous %d", msg.DelayedMessagesRead, prevDelayed)
 	}
+
 	return &validationEntry{
 		Stage:         ReadyForRecord,
 		Pos:           pos,
@@ -197,8 +219,9 @@ func newValidationEntry(
 		HasDelayedMsg: hasDelayed,
 		DelayedMsgNr:  delayedNum,
 		msg:           msg,
-		BatchInfo:     []validator.BatchInfo{batchInfo},
+		BatchInfo:     valBatches,
 		ChainConfig:   chainConfig,
+		Preimages:     preimages,
 	}, nil
 }
 
@@ -243,33 +266,88 @@ func NewStatelessBlockValidator(
 		db:             arbdb,
 		dapReaders:     dapReaders,
 		execSpawners:   executionSpawners,
+		stack:          stack,
 	}, nil
 }
 
-func (v *StatelessBlockValidator) readBatch(ctx context.Context, batchNum uint64) (bool, []byte, common.Hash, arbutil.MessageIndex, error) {
+func (v *StatelessBlockValidator) readPostedBatch(ctx context.Context, batchNum uint64) ([]byte, error) {
 	batchCount, err := v.inboxTracker.GetBatchCount()
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return nil, err
 	}
 	if batchCount <= batchNum {
-		return false, nil, common.Hash{}, 0, nil
+		return nil, fmt.Errorf("batch not found: %d", batchNum)
+	}
+	postedData, _, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+	return postedData, err
+}
+
+func (v *StatelessBlockValidator) readFullBatch(ctx context.Context, batchNum uint64) (bool, *FullBatchInfo, error) {
+	batchCount, err := v.inboxTracker.GetBatchCount()
+	if err != nil {
+		return false, nil, err
+	}
+	if batchCount <= batchNum {
+		return false, nil, nil
 	}
 	batchMsgCount, err := v.inboxTracker.GetBatchMessageCount(batchNum)
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return false, nil, err
 	}
-	batch, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
+	postedData, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, batchNum)
 	if err != nil {
-		return false, nil, common.Hash{}, 0, err
+		return false, nil, err
+	}
+	preimages := make(map[arbutil.PreimageType]map[common.Hash][]byte)
+	if len(postedData) > 40 {
+		foundDA := false
+		for _, dapReader := range v.dapReaders {
+			if dapReader != nil && dapReader.IsValidHeaderByte(postedData[40]) {
+				preimageRecorder := daprovider.RecordPreimagesTo(preimages)
+				_, err := dapReader.RecoverPayloadFromBatch(ctx, batchNum, batchBlockHash, postedData, preimageRecorder, true)
+				if err != nil {
+					// Matches the way keyset validation was done inside DAS readers i.e logging the error
+					//  But other daproviders might just want to return the error
+					if errors.Is(err, daprovider.ErrSeqMsgValidation) && daprovider.IsDASMessageHeaderByte(postedData[40]) {
+						log.Error(err.Error())
+					} else {
+						return false, nil, err
+					}
+				}
+				foundDA = true
+				break
+			}
+		}
+		if !foundDA {
+			if daprovider.IsDASMessageHeaderByte(postedData[40]) {
+				log.Error("No DAS Reader configured, but sequencer message found with DAS header")
+			}
+		}
+	}
+	fullInfo := FullBatchInfo{
+		Number:     batchNum,
+		PostedData: postedData,
+		MsgCount:   batchMsgCount,
+		Preimages:  preimages,
+	}
+	return true, &fullInfo, nil
+}
+
+func copyPreimagesInto(dest, source map[arbutil.PreimageType]map[common.Hash][]byte) {
+	for piType, piMap := range source {
+		if dest[piType] == nil {
+			dest[piType] = make(map[common.Hash][]byte, len(piMap))
+		}
+		for hash, preimage := range piMap {
+			dest[piType][hash] = preimage
+		}
 	}
-	return true, batch, batchBlockHash, batchMsgCount, nil
 }
 
 func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *validationEntry) error {
 	if e.Stage != ReadyForRecord {
 		return fmt.Errorf("validation entry should be ReadyForRecord, is: %v", e.Stage)
 	}
-	e.Preimages = make(map[arbutil.PreimageType]map[common.Hash][]byte)
 	if e.Pos != 0 {
 		recording, err := v.recorder.RecordBlockCreation(ctx, e.Pos, e.msg)
 		if err != nil {
@@ -278,30 +356,11 @@ func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *
 		if recording.BlockHash != e.End.BlockHash {
 			return fmt.Errorf("recording failed: pos %d, hash expected %v, got %v", e.Pos, e.End.BlockHash, recording.BlockHash)
 		}
-		// record any additional batch fetching
-		batchFetcher := func(batchNum uint64) ([]byte, error) {
-			found, data, hash, _, err := v.readBatch(ctx, batchNum)
-			if err != nil {
-				return nil, err
-			}
-			if !found {
-				return nil, errors.New("batch not found")
-			}
-			e.BatchInfo = append(e.BatchInfo, validator.BatchInfo{
-				Number:    batchNum,
-				BlockHash: hash,
-				Data:      data,
-			})
-			return data, nil
-		}
-		e.msg.Message.BatchGasCost = nil
-		err = e.msg.Message.FillInBatchGasCost(batchFetcher)
-		if err != nil {
-			return err
-		}
-
 		if recording.Preimages != nil {
-			e.Preimages[arbutil.Keccak256PreimageType] = recording.Preimages
+			recordingPreimages := map[arbutil.PreimageType]map[common.Hash][]byte{
+				arbutil.Keccak256PreimageType: recording.Preimages,
+			}
+			copyPreimagesInto(e.Preimages, recordingPreimages)
 		}
 		e.UserWasms = recording.UserWasms
 	}
@@ -316,35 +375,6 @@ func (v *StatelessBlockValidator) ValidationEntryRecord(ctx context.Context, e *
 		}
 		e.DelayedMsg = delayedMsg
 	}
-	for _, batch := range e.BatchInfo {
-		if len(batch.Data) <= 40 {
-			continue
-		}
-		foundDA := false
-		for _, dapReader := range v.dapReaders {
-			if dapReader != nil && dapReader.IsValidHeaderByte(batch.Data[40]) {
-				preimageRecorder := daprovider.RecordPreimagesTo(e.Preimages)
-				_, err := dapReader.RecoverPayloadFromBatch(ctx, batch.Number, batch.BlockHash, batch.Data, preimageRecorder, true)
-				if err != nil {
-					// Matches the way keyset validation was done inside DAS readers i.e logging the error
-					//  But other daproviders might just want to return the error
-					if errors.Is(err, daprovider.ErrSeqMsgValidation) && daprovider.IsDASMessageHeaderByte(batch.Data[40]) {
-						log.Error(err.Error())
-					} else {
-						return err
-					}
-				}
-				foundDA = true
-				break
-			}
-		}
-		if !foundDA {
-			if daprovider.IsDASMessageHeaderByte(batch.Data[40]) {
-				log.Error("No DAS Reader configured, but sequencer message found with DAS header")
-			}
-		}
-	}
-
 	e.msg = nil // no longer needed
 	e.Stage = Ready
 	return nil
@@ -404,11 +434,30 @@ func (v *StatelessBlockValidator) CreateReadyValidationEntry(ctx context.Context
 	}
 	start := buildGlobalState(*prevResult, startPos)
 	end := buildGlobalState(*result, endPos)
-	seqMsg, batchBlockHash, err := v.inboxReader.GetSequencerMessageBytes(ctx, startPos.BatchNumber)
+	found, fullBatchInfo, err := v.readFullBatch(ctx, start.Batch)
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return nil, fmt.Errorf("batch %d not found", startPos.BatchNumber)
+	}
+
+	prevBatchNums, err := msg.Message.PastBatchesRequired()
 	if err != nil {
 		return nil, err
 	}
-	entry, err := newValidationEntry(pos, start, end, msg, seqMsg, batchBlockHash, prevDelayed, v.streamer.ChainConfig())
+	prevBatches := make([]validator.BatchInfo, 0, len(prevBatchNums))
+	for _, batchNum := range prevBatchNums {
+		data, err := v.readPostedBatch(ctx, batchNum)
+		if err != nil {
+			return nil, err
+		}
+		prevBatches = append(prevBatches, validator.BatchInfo{
+			Number: batchNum,
+			Data:   data,
+		})
+	}
+	entry, err := newValidationEntry(pos, start, end, msg, fullBatchInfo, prevBatches, prevDelayed, v.streamer.ChainConfig())
 	if err != nil {
 		return nil, err
 	}
@@ -462,6 +511,18 @@ func (v *StatelessBlockValidator) ValidateResult(
 	return true, &entry.End, nil
 }
 
+func (v *StatelessBlockValidator) ValidationInputsAt(ctx context.Context, pos arbutil.MessageIndex, target ethdb.WasmTarget) (server_api.InputJSON, error) {
+	entry, err := v.CreateReadyValidationEntry(ctx, pos)
+	if err != nil {
+		return server_api.InputJSON{}, err
+	}
+	input, err := entry.ToInput([]ethdb.WasmTarget{target})
+	if err != nil {
+		return server_api.InputJSON{}, err
+	}
+	return *server_api.ValidationInputToJson(input), nil
+}
+
 func (v *StatelessBlockValidator) OverrideRecorder(t *testing.T, recorder execution.ExecutionRecorder) {
 	v.recorder = recorder
 }
diff --git a/staker/txbuilder/builder.go b/staker/txbuilder/builder.go
index 9a5e9df..f52b03a 100644
--- a/staker/txbuilder/builder.go
+++ b/staker/txbuilder/builder.go
@@ -12,13 +12,13 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/offchainlabs/nitro/arbutil"
+	"github.com/ethereum/go-ethereum/ethclient"
 )
 
 type ValidatorWalletInterface interface {
 	// Address must be able to be called concurrently with other functions
 	Address() *common.Address
-	L1Client() arbutil.L1Interface
+	L1Client() *ethclient.Client
 	TestTransactions(context.Context, []*types.Transaction) error
 	ExecuteTransactions(context.Context, *Builder, common.Address) (*types.Transaction, error)
 	AuthIfEoa() *bind.TransactOpts
@@ -27,10 +27,10 @@ type ValidatorWalletInterface interface {
 // Builder combines any transactions sent to it via SendTransaction into one batch,
 // which is then sent to the validator wallet.
 // This lets the validator make multiple atomic transactions.
-// This inherits from an eth client so it can be used as an L1Interface,
-// where it transparently intercepts calls to SendTransaction and queues them for the next batch.
+// This inherits from an ethclient.Client so it can be used to transparently
+// intercept calls to SendTransaction and queue them for the next batch.
 type Builder struct {
-	arbutil.L1Interface
+	*ethclient.Client
 	transactions []*types.Transaction
 	builderAuth  *bind.TransactOpts
 	isAuthFake   bool
@@ -55,7 +55,7 @@ func NewBuilder(wallet ValidatorWalletInterface) (*Builder, error) {
 	return &Builder{
 		builderAuth: builderAuth,
 		wallet:      wallet,
-		L1Interface: wallet.L1Client(),
+		Client:      wallet.L1Client(),
 		isAuthFake:  isAuthFake,
 	}, nil
 }
@@ -70,7 +70,7 @@ func (b *Builder) ClearTransactions() {
 
 func (b *Builder) EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) {
 	if len(b.transactions) == 0 && !b.isAuthFake {
-		return b.L1Interface.EstimateGas(ctx, call)
+		return b.Client.EstimateGas(ctx, call)
 	}
 	return 0, nil
 }
diff --git a/staker/validatorwallet/contract.go b/staker/validatorwallet/contract.go
index 77b403b..3202d58 100644
--- a/staker/validatorwallet/contract.go
+++ b/staker/validatorwallet/contract.go
@@ -16,18 +16,21 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/offchainlabs/nitro/arbnode/dataposter"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
 	"github.com/offchainlabs/nitro/staker/txbuilder"
 	"github.com/offchainlabs/nitro/util/arbmath"
 	"github.com/offchainlabs/nitro/util/headerreader"
 )
 
-var validatorABI abi.ABI
-var walletCreatedID common.Hash
+var (
+	validatorABI              abi.ABI
+	validatorWalletCreatorABI abi.ABI
+	walletCreatedID           common.Hash
+)
 
 func init() {
 	parsedValidator, err := abi.JSON(strings.NewReader(rollupgen.ValidatorWalletABI))
@@ -40,6 +43,7 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
+	validatorWalletCreatorABI = parsedValidatorWalletCreator
 	walletCreatedID = parsedValidatorWalletCreator.Events["WalletCreated"].ID
 }
 
@@ -151,16 +155,19 @@ func (v *Contract) From() common.Address {
 }
 
 // nil value == 0 value
-func (v *Contract) getAuth(ctx context.Context, value *big.Int) (*bind.TransactOpts, error) {
-	newAuth := *v.auth
-	newAuth.Context = ctx
-	newAuth.Value = value
-	nonce, err := v.L1Client().NonceAt(ctx, v.auth.From, nil)
+func getAuthWithUpdatedNonceFromL1(ctx context.Context, l1Reader *headerreader.HeaderReader, auth bind.TransactOpts, value *big.Int) (*bind.TransactOpts, error) {
+	auth.Context = ctx
+	auth.Value = value
+	nonce, err := l1Reader.Client().NonceAt(ctx, auth.From, nil)
 	if err != nil {
 		return nil, err
 	}
-	newAuth.Nonce = new(big.Int).SetUint64(nonce)
-	return &newAuth, nil
+	auth.Nonce = new(big.Int).SetUint64(nonce)
+	return &auth, nil
+}
+
+func (v *Contract) getAuth(ctx context.Context, value *big.Int) (*bind.TransactOpts, error) {
+	return getAuthWithUpdatedNonceFromL1(ctx, v.l1Reader, *v.auth, value)
 }
 
 func (v *Contract) executeTransaction(ctx context.Context, tx *types.Transaction, gasRefunder common.Address) (*types.Transaction, error) {
@@ -179,6 +186,35 @@ func (v *Contract) executeTransaction(ctx context.Context, tx *types.Transaction
 	return v.dataPoster.PostSimpleTransaction(ctx, auth.Nonce.Uint64(), *v.Address(), data, gas, auth.Value)
 }
 
+func createWalletContract(
+	ctx context.Context,
+	l1Reader *headerreader.HeaderReader,
+	auth *bind.TransactOpts,
+	dataPoster *dataposter.DataPoster,
+	getExtraGas func() uint64,
+	validatorWalletFactoryAddr common.Address,
+) (*types.Transaction, error) {
+	var initialExecutorAllowedDests []common.Address
+	txData, err := validatorWalletCreatorABI.Pack("createWallet", initialExecutorAllowedDests)
+	if err != nil {
+		return nil, err
+	}
+
+	gas, err := gasForTxData(
+		ctx,
+		l1Reader,
+		auth,
+		&validatorWalletFactoryAddr,
+		txData,
+		getExtraGas,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("getting gas for tx data when creating validator wallet, validatorWalletFactory=%v: %w", validatorWalletFactoryAddr, err)
+	}
+
+	return dataPoster.PostSimpleTransaction(ctx, auth.Nonce.Uint64(), validatorWalletFactoryAddr, txData, gas, common.Big0)
+}
+
 func (v *Contract) populateWallet(ctx context.Context, createIfMissing bool) error {
 	if v.con != nil {
 		return nil
@@ -190,11 +226,10 @@ func (v *Contract) populateWallet(ctx context.Context, createIfMissing bool) err
 		return nil
 	}
 	if v.address.Load() == nil {
-		auth, err := v.getAuth(ctx, nil)
-		if err != nil {
-			return err
-		}
-		addr, err := GetValidatorWalletContract(ctx, v.walletFactoryAddr, v.rollupFromBlock, auth, v.l1Reader, createIfMissing)
+		// By passing v.dataPoster as a parameter to GetValidatorWalletContract we force to create a validator wallet through the Staker's DataPoster object.
+		// DataPoster keeps in its internal state information related to the transactions sent through it, which is used to infer the expected nonce in a transaction for example.
+		// If a transaction is sent using the Staker's DataPoster key, but not through the Staker's DataPoster object, DataPoster's internal state will be outdated, which can compromise the expected nonce inference.
+		addr, err := GetValidatorWalletContract(ctx, v.walletFactoryAddr, v.rollupFromBlock, v.l1Reader, createIfMissing, v.dataPoster, v.getExtraGas)
 		if err != nil {
 			return err
 		}
@@ -295,25 +330,29 @@ func (v *Contract) ExecuteTransactions(ctx context.Context, builder *txbuilder.B
 	return arbTx, nil
 }
 
-func (v *Contract) estimateGas(ctx context.Context, value *big.Int, data []byte) (uint64, error) {
-	h, err := v.l1Reader.LastHeader(ctx)
+func gasForTxData(ctx context.Context, l1Reader *headerreader.HeaderReader, auth *bind.TransactOpts, to *common.Address, data []byte, getExtraGas func() uint64) (uint64, error) {
+	if auth.GasLimit != 0 {
+		return auth.GasLimit, nil
+	}
+
+	h, err := l1Reader.LastHeader(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("getting the last header: %w", err)
 	}
 	gasFeeCap := new(big.Int).Mul(h.BaseFee, big.NewInt(2))
 	gasFeeCap = arbmath.BigMax(gasFeeCap, arbmath.FloatToBig(params.GWei))
 
-	gasTipCap, err := v.l1Reader.Client().SuggestGasTipCap(ctx)
+	gasTipCap, err := l1Reader.Client().SuggestGasTipCap(ctx)
 	if err != nil {
 		return 0, fmt.Errorf("getting suggested gas tip cap: %w", err)
 	}
 	gasFeeCap.Add(gasFeeCap, gasTipCap)
-	g, err := v.l1Reader.Client().EstimateGas(
+	g, err := l1Reader.Client().EstimateGas(
 		ctx,
 		ethereum.CallMsg{
-			From:      v.auth.From,
-			To:        v.Address(),
-			Value:     value,
+			From:      auth.From,
+			To:        to,
+			Value:     auth.Value,
 			Data:      data,
 			GasFeeCap: gasFeeCap,
 			GasTipCap: gasTipCap,
@@ -322,7 +361,11 @@ func (v *Contract) estimateGas(ctx context.Context, value *big.Int, data []byte)
 	if err != nil {
 		return 0, fmt.Errorf("estimating gas: %w", err)
 	}
-	return g + v.getExtraGas(), nil
+	return g + getExtraGas(), nil
+}
+
+func (v *Contract) gasForTxData(ctx context.Context, auth *bind.TransactOpts, data []byte) (uint64, error) {
+	return gasForTxData(ctx, v.l1Reader, auth, v.Address(), data, v.getExtraGas)
 }
 
 func (v *Contract) TimeoutChallenges(ctx context.Context, challenges []uint64) (*types.Transaction, error) {
@@ -341,15 +384,7 @@ func (v *Contract) TimeoutChallenges(ctx context.Context, challenges []uint64) (
 	return v.dataPoster.PostSimpleTransaction(ctx, auth.Nonce.Uint64(), *v.Address(), data, gas, auth.Value)
 }
 
-// gasForTxData returns auth.GasLimit if it's nonzero, otherwise returns estimate.
-func (v *Contract) gasForTxData(ctx context.Context, auth *bind.TransactOpts, data []byte) (uint64, error) {
-	if auth.GasLimit != 0 {
-		return auth.GasLimit, nil
-	}
-	return v.estimateGas(ctx, auth.Value, data)
-}
-
-func (v *Contract) L1Client() arbutil.L1Interface {
+func (v *Contract) L1Client() *ethclient.Client {
 	return v.l1Reader.Client()
 }
 
@@ -400,15 +435,22 @@ func (b *Contract) DataPoster() *dataposter.DataPoster {
 	return b.dataPoster
 }
 
+// Exported for testing
+func (b *Contract) GetExtraGas() func() uint64 {
+	return b.getExtraGas
+}
+
 func GetValidatorWalletContract(
 	ctx context.Context,
 	validatorWalletFactoryAddr common.Address,
 	fromBlock int64,
-	transactAuth *bind.TransactOpts,
 	l1Reader *headerreader.HeaderReader,
 	createIfMissing bool,
+	dataPoster *dataposter.DataPoster,
+	getExtraGas func() uint64,
 ) (*common.Address, error) {
 	client := l1Reader.Client()
+	transactAuth := dataPoster.Auth()
 
 	// TODO: If we just save a mapping in the wallet creator we won't need log search
 	walletCreator, err := rollupgen.NewValidatorWalletCreator(validatorWalletFactoryAddr, client)
@@ -443,8 +485,12 @@ func GetValidatorWalletContract(
 		return nil, nil
 	}
 
-	var initialExecutorAllowedDests []common.Address
-	tx, err := walletCreator.CreateWallet(transactAuth, initialExecutorAllowedDests)
+	transactAuth, err = getAuthWithUpdatedNonceFromL1(ctx, l1Reader, *transactAuth, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	tx, err := createWalletContract(ctx, l1Reader, transactAuth, dataPoster, getExtraGas, validatorWalletFactoryAddr)
 	if err != nil {
 		return nil, err
 	}
diff --git a/staker/validatorwallet/eoa.go b/staker/validatorwallet/eoa.go
index 3ae305b..7c7f472 100644
--- a/staker/validatorwallet/eoa.go
+++ b/staker/validatorwallet/eoa.go
@@ -10,8 +10,8 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/offchainlabs/nitro/arbnode/dataposter"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/challengegen"
 	"github.com/offchainlabs/nitro/solgen/go/rollupgen"
 	"github.com/offchainlabs/nitro/staker/txbuilder"
@@ -19,7 +19,7 @@ import (
 
 type EOA struct {
 	auth                    *bind.TransactOpts
-	client                  arbutil.L1Interface
+	client                  *ethclient.Client
 	rollupAddress           common.Address
 	challengeManager        *challengegen.ChallengeManager
 	challengeManagerAddress common.Address
@@ -27,7 +27,7 @@ type EOA struct {
 	getExtraGas             func() uint64
 }
 
-func NewEOA(dataPoster *dataposter.DataPoster, rollupAddress common.Address, l1Client arbutil.L1Interface, getExtraGas func() uint64) (*EOA, error) {
+func NewEOA(dataPoster *dataposter.DataPoster, rollupAddress common.Address, l1Client *ethclient.Client, getExtraGas func() uint64) (*EOA, error) {
 	return &EOA{
 		auth:          dataPoster.Auth(),
 		client:        l1Client,
@@ -63,7 +63,7 @@ func (w *EOA) TxSenderAddress() *common.Address {
 	return &w.auth.From
 }
 
-func (w *EOA) L1Client() arbutil.L1Interface {
+func (w *EOA) L1Client() *ethclient.Client {
 	return w.client
 }
 
diff --git a/staker/validatorwallet/noop.go b/staker/validatorwallet/noop.go
index b050ebe..fec39ac 100644
--- a/staker/validatorwallet/noop.go
+++ b/staker/validatorwallet/noop.go
@@ -10,18 +10,18 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/offchainlabs/nitro/arbnode/dataposter"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/staker/txbuilder"
 )
 
 // NoOp validator wallet is used for watchtower mode.
 type NoOp struct {
-	l1Client      arbutil.L1Interface
+	l1Client      *ethclient.Client
 	rollupAddress common.Address
 }
 
-func NewNoOp(l1Client arbutil.L1Interface, rollupAddress common.Address) *NoOp {
+func NewNoOp(l1Client *ethclient.Client, rollupAddress common.Address) *NoOp {
 	return &NoOp{
 		l1Client:      l1Client,
 		rollupAddress: rollupAddress,
@@ -46,7 +46,7 @@ func (*NoOp) TimeoutChallenges(ctx context.Context, challenges []uint64) (*types
 	return nil, errors.New("no op validator wallet cannot timeout challenges")
 }
 
-func (n *NoOp) L1Client() arbutil.L1Interface { return n.l1Client }
+func (n *NoOp) L1Client() *ethclient.Client { return n.l1Client }
 
 func (n *NoOp) RollupAddress() common.Address { return n.rollupAddress }
 
diff --git a/system_tests/block_validator_test.go b/system_tests/block_validator_test.go
index bd0a1f3..9125c39 100644
--- a/system_tests/block_validator_test.go
+++ b/system_tests/block_validator_test.go
@@ -63,7 +63,6 @@ func testBlockValidatorSimple(t *testing.T, opts Options) {
 
 	var delayEvery int
 	if opts.workloadLoops > 1 {
-		l1NodeConfigA.BatchPoster.MaxDelay = time.Millisecond * 500
 		delayEvery = opts.workloadLoops / 3
 	}
 
@@ -259,6 +258,7 @@ func testBlockValidatorSimple(t *testing.T, opts Options) {
 	Require(t, err)
 	// up to 3 extra references: awaiting validation, recently valid, lastValidatedHeader
 	largestRefCount := lastBlockNow.NumberU64() - lastBlock.NumberU64() + 3
+	// #nosec G115
 	if finalRefCount < 0 || finalRefCount > int64(largestRefCount) {
 		Fatal(t, "unexpected refcount:", finalRefCount)
 	}
@@ -284,6 +284,20 @@ func TestBlockValidatorSimpleOnchain(t *testing.T) {
 	testBlockValidatorSimple(t, opts)
 }
 
+func TestBlockValidatorSimpleJITOnchainWithPublishedMachine(t *testing.T) {
+	cr, err := github.LatestConsensusRelease(context.Background())
+	Require(t, err)
+	machPath := populateMachineDir(t, cr)
+	opts := Options{
+		dasModeString: "onchain",
+		workloadLoops: 1,
+		workload:      ethSend,
+		arbitrator:    false,
+		wasmRootDir:   machPath,
+	}
+	testBlockValidatorSimple(t, opts)
+}
+
 func TestBlockValidatorSimpleOnchainWithPublishedMachine(t *testing.T) {
 	cr, err := github.LatestConsensusRelease(context.Background())
 	Require(t, err)
diff --git a/system_tests/bloom_test.go b/system_tests/bloom_test.go
index a3cab74..68fb7c3 100644
--- a/system_tests/bloom_test.go
+++ b/system_tests/bloom_test.go
@@ -48,11 +48,13 @@ func TestBloom(t *testing.T) {
 	nullEventCounts := make(map[uint64]struct{})
 
 	for i := 0; i < eventsNum; i++ {
+		// #nosec G115
 		count := uint64(rand.Int() % countsNum)
 		eventCounts[count] = struct{}{}
 	}
 
 	for i := 0; i < nullEventsNum; i++ {
+		// #nosec G115
 		count := uint64(rand.Int() % countsNum)
 		nullEventCounts[count] = struct{}{}
 	}
@@ -60,6 +62,7 @@ func TestBloom(t *testing.T) {
 	for i := 0; i <= countsNum; i++ {
 		var tx *types.Transaction
 		var err error
+		// #nosec G115
 		_, sendNullEvent := nullEventCounts[uint64(i)]
 		if sendNullEvent {
 			tx, err = simple.EmitNullEvent(&ownerTxOpts)
@@ -68,6 +71,7 @@ func TestBloom(t *testing.T) {
 			Require(t, err)
 		}
 
+		// #nosec G115
 		_, sendEvent := eventCounts[uint64(i)]
 		if sendEvent {
 			tx, err = simple.IncrementEmit(&ownerTxOpts)
@@ -86,7 +90,9 @@ func TestBloom(t *testing.T) {
 		if sectionSize != 256 {
 			Fatal(t, "unexpected section size: ", sectionSize)
 		}
+		// #nosec G115
 		t.Log("sections: ", sectionNum, "/", uint64(countsNum)/sectionSize)
+		// #nosec G115
 		if sectionSize*(sectionNum+1) > uint64(countsNum) && sectionNum > 1 {
 			break
 		}
diff --git a/system_tests/common_test.go b/system_tests/common_test.go
index e14eb45..67bc01c 100644
--- a/system_tests/common_test.go
+++ b/system_tests/common_test.go
@@ -25,6 +25,7 @@ import (
 	"github.com/offchainlabs/nitro/arbos/arbostypes"
 	"github.com/offchainlabs/nitro/arbos/util"
 	"github.com/offchainlabs/nitro/arbstate/daprovider"
+	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/blsSignatures"
 	"github.com/offchainlabs/nitro/cmd/chaininfo"
 	"github.com/offchainlabs/nitro/cmd/conf"
@@ -36,6 +37,7 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 	"github.com/offchainlabs/nitro/util/redisutil"
 	"github.com/offchainlabs/nitro/util/signature"
+	"github.com/offchainlabs/nitro/validator/inputs"
 	"github.com/offchainlabs/nitro/validator/server_api"
 	"github.com/offchainlabs/nitro/validator/server_common"
 	"github.com/offchainlabs/nitro/validator/valnode"
@@ -69,7 +71,6 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 
 	"github.com/offchainlabs/nitro/arbnode"
-	"github.com/offchainlabs/nitro/arbutil"
 	_ "github.com/offchainlabs/nitro/execution/nodeInterface"
 	"github.com/offchainlabs/nitro/solgen/go/bridgegen"
 	"github.com/offchainlabs/nitro/solgen/go/mocksgen"
@@ -83,7 +84,6 @@ import (
 )
 
 type info = *BlockchainTestInfo
-type client = arbutil.L1Interface
 
 type SecondNodeParams struct {
 	nodeConfig  *arbnode.Config
@@ -166,7 +166,7 @@ var TestCachingConfig = gethexec.CachingConfig{
 	SnapshotRestoreGasLimit:            300_000_000_000,
 	MaxNumberOfBlocksToSkipStateSaving: 0,
 	MaxAmountOfGasToSkipStateSaving:    0,
-	StylusLRUCache:                     0,
+	StylusLRUCacheCapacity:             0,
 	StateScheme:                        env.GetTestStateScheme(),
 }
 
@@ -197,27 +197,29 @@ var TestSequencerConfig = gethexec.SequencerConfig{
 	EnableProfiling:              false,
 }
 
-func ExecConfigDefaultNonSequencerTest() *gethexec.Config {
+func ExecConfigDefaultNonSequencerTest(t *testing.T) *gethexec.Config {
 	config := gethexec.ConfigDefault
 	config.Caching = TestCachingConfig
 	config.ParentChainReader = headerreader.TestConfig
 	config.Sequencer.Enable = false
 	config.Forwarder = DefaultTestForwarderConfig
 	config.ForwardingTarget = "null"
+	config.TxPreChecker.Strictness = gethexec.TxPreCheckerStrictnessNone
 
-	_ = config.Validate()
+	Require(t, config.Validate())
 
 	return &config
 }
 
-func ExecConfigDefaultTest() *gethexec.Config {
+func ExecConfigDefaultTest(t *testing.T) *gethexec.Config {
 	config := gethexec.ConfigDefault
 	config.Caching = TestCachingConfig
 	config.Sequencer = TestSequencerConfig
 	config.ParentChainReader = headerreader.TestConfig
 	config.ForwardingTarget = "null"
+	config.TxPreChecker.Strictness = gethexec.TxPreCheckerStrictnessNone
 
-	_ = config.Validate()
+	Require(t, config.Validate())
 
 	return &config
 }
@@ -231,21 +233,73 @@ type NodeBuilder struct {
 	l1StackConfig *node.Config
 	l2StackConfig *node.Config
 	valnodeConfig *valnode.Config
+	l3Config      *NitroConfig
 	L1Info        info
 	L2Info        info
+	L3Info        info
 
-	// L1, L2 Node parameters
+	// L1, L2, L3 Node parameters
 	dataDir                     string
 	isSequencer                 bool
 	takeOwnership               bool
 	withL1                      bool
 	addresses                   *chaininfo.RollupAddresses
+	l3Addresses                 *chaininfo.RollupAddresses
 	initMessage                 *arbostypes.ParsedInitMessage
+	l3InitMessage               *arbostypes.ParsedInitMessage
 	withProdConfirmPeriodBlocks bool
 
 	// Created nodes
 	L1 *TestClient
 	L2 *TestClient
+	L3 *TestClient
+}
+
+type NitroConfig struct {
+	chainConfig   *params.ChainConfig
+	nodeConfig    *arbnode.Config
+	execConfig    *gethexec.Config
+	stackConfig   *node.Config
+	valnodeConfig *valnode.Config
+
+	withProdConfirmPeriodBlocks bool
+	isSequencer                 bool
+}
+
+func L3NitroConfigDefaultTest(t *testing.T) *NitroConfig {
+	chainConfig := &params.ChainConfig{
+		ChainID:             big.NewInt(333333),
+		HomesteadBlock:      big.NewInt(0),
+		DAOForkBlock:        nil,
+		DAOForkSupport:      true,
+		EIP150Block:         big.NewInt(0),
+		EIP155Block:         big.NewInt(0),
+		EIP158Block:         big.NewInt(0),
+		ByzantiumBlock:      big.NewInt(0),
+		ConstantinopleBlock: big.NewInt(0),
+		PetersburgBlock:     big.NewInt(0),
+		IstanbulBlock:       big.NewInt(0),
+		MuirGlacierBlock:    big.NewInt(0),
+		BerlinBlock:         big.NewInt(0),
+		LondonBlock:         big.NewInt(0),
+		ArbitrumChainParams: params.ArbitrumDevTestParams(),
+		Clique: &params.CliqueConfig{
+			Period: 0,
+			Epoch:  0,
+		},
+	}
+
+	valnodeConfig := valnode.TestValidationConfig
+	return &NitroConfig{
+		chainConfig:   chainConfig,
+		nodeConfig:    arbnode.ConfigDefaultL1Test(),
+		execConfig:    ExecConfigDefaultTest(t),
+		stackConfig:   testhelpers.CreateStackConfigForTest(t.TempDir()),
+		valnodeConfig: &valnodeConfig,
+
+		withProdConfirmPeriodBlocks: false,
+		isSequencer:                 true,
+	}
 }
 
 func NewNodeBuilder(ctx context.Context) *NodeBuilder {
@@ -270,7 +324,8 @@ func (b *NodeBuilder) DefaultConfig(t *testing.T, withL1 bool) *NodeBuilder {
 	b.l2StackConfig = testhelpers.CreateStackConfigForTest(b.dataDir)
 	cp := valnode.TestValidationConfig
 	b.valnodeConfig = &cp
-	b.execConfig = ExecConfigDefaultTest()
+	b.execConfig = ExecConfigDefaultTest(t)
+	b.l3Config = L3NitroConfigDefaultTest(t)
 	return b
 }
 
@@ -291,6 +346,11 @@ func (b *NodeBuilder) WithWasmRootDir(wasmRootDir string) *NodeBuilder {
 	return b
 }
 
+func (b *NodeBuilder) WithExtraArchs(targets []string) *NodeBuilder {
+	b.execConfig.StylusTarget.ExtraArchs = targets
+	return b
+}
+
 func (b *NodeBuilder) Build(t *testing.T) func() {
 	b.CheckConfig(t)
 	if b.withL1 {
@@ -308,7 +368,7 @@ func (b *NodeBuilder) CheckConfig(t *testing.T) {
 		b.nodeConfig = arbnode.ConfigDefaultL1Test()
 	}
 	if b.execConfig == nil {
-		b.execConfig = ExecConfigDefaultTest()
+		b.execConfig = ExecConfigDefaultTest(t)
 	}
 	if b.L1Info == nil {
 		b.L1Info = NewL1TestInfo(t)
@@ -330,64 +390,169 @@ func (b *NodeBuilder) BuildL1(t *testing.T) {
 	b.L1Info, b.L1.Client, b.L1.L1Backend, b.L1.Stack = createTestL1BlockChain(t, b.L1Info)
 	locator, err := server_common.NewMachineLocator(b.valnodeConfig.Wasm.RootPath)
 	Require(t, err)
-	b.addresses, b.initMessage = DeployOnTestL1(t, b.ctx, b.L1Info, b.L1.Client, b.chainConfig, locator.LatestWasmModuleRoot(), b.withProdConfirmPeriodBlocks)
+	b.addresses, b.initMessage = deployOnParentChain(
+		t,
+		b.ctx,
+		b.L1Info,
+		b.L1.Client,
+		&headerreader.TestConfig,
+		b.chainConfig,
+		locator.LatestWasmModuleRoot(),
+		b.withProdConfirmPeriodBlocks,
+		true,
+	)
 	b.L1.cleanup = func() { requireClose(t, b.L1.Stack) }
 }
 
-func (b *NodeBuilder) BuildL2OnL1(t *testing.T) func() {
-	if b.L1 == nil {
-		t.Fatal("must build L1 before building L2")
+func buildOnParentChain(
+	t *testing.T,
+	ctx context.Context,
+
+	dataDir string,
+
+	parentChainInfo info,
+	parentChainTestClient *TestClient,
+	parentChainId *big.Int,
+
+	chainConfig *params.ChainConfig,
+	stackConfig *node.Config,
+	execConfig *gethexec.Config,
+	nodeConfig *arbnode.Config,
+	valnodeConfig *valnode.Config,
+	isSequencer bool,
+	chainInfo info,
+
+	initMessage *arbostypes.ParsedInitMessage,
+	addresses *chaininfo.RollupAddresses,
+) *TestClient {
+	if parentChainTestClient == nil {
+		t.Fatal("must build parent chain before building chain")
 	}
-	b.L2 = NewTestClient(b.ctx)
 
-	var l2chainDb ethdb.Database
-	var l2arbDb ethdb.Database
-	var l2blockchain *core.BlockChain
-	_, b.L2.Stack, l2chainDb, l2arbDb, l2blockchain = createL2BlockChainWithStackConfig(
-		t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, &b.execConfig.Caching)
+	chainTestClient := NewTestClient(ctx)
+
+	var chainDb ethdb.Database
+	var arbDb ethdb.Database
+	var blockchain *core.BlockChain
+	_, chainTestClient.Stack, chainDb, arbDb, blockchain = createNonL1BlockChainWithStackConfig(
+		t, chainInfo, dataDir, chainConfig, initMessage, stackConfig, execConfig)
 
 	var sequencerTxOptsPtr *bind.TransactOpts
 	var dataSigner signature.DataSignerFunc
-	if b.isSequencer {
-		sequencerTxOpts := b.L1Info.GetDefaultTransactOpts("Sequencer", b.ctx)
+	if isSequencer {
+		sequencerTxOpts := parentChainInfo.GetDefaultTransactOpts("Sequencer", ctx)
 		sequencerTxOptsPtr = &sequencerTxOpts
-		dataSigner = signature.DataSignerFromPrivateKey(b.L1Info.GetInfoWithPrivKey("Sequencer").PrivateKey)
+		dataSigner = signature.DataSignerFromPrivateKey(parentChainInfo.GetInfoWithPrivKey("Sequencer").PrivateKey)
 	} else {
-		b.nodeConfig.BatchPoster.Enable = false
-		b.nodeConfig.Sequencer = false
-		b.nodeConfig.DelayedSequencer.Enable = false
-		b.execConfig.Sequencer.Enable = false
+		nodeConfig.BatchPoster.Enable = false
+		nodeConfig.Sequencer = false
+		nodeConfig.DelayedSequencer.Enable = false
+		execConfig.Sequencer.Enable = false
 	}
 
 	var validatorTxOptsPtr *bind.TransactOpts
-	if b.nodeConfig.Staker.Enable {
-		validatorTxOpts := b.L1Info.GetDefaultTransactOpts("Validator", b.ctx)
+	if nodeConfig.Staker.Enable {
+		validatorTxOpts := parentChainInfo.GetDefaultTransactOpts("Validator", ctx)
 		validatorTxOptsPtr = &validatorTxOpts
 	}
 
-	AddValNodeIfNeeded(t, b.ctx, b.nodeConfig, true, "", b.valnodeConfig.Wasm.RootPath)
+	AddValNodeIfNeeded(t, ctx, nodeConfig, true, "", valnodeConfig.Wasm.RootPath)
 
-	Require(t, b.execConfig.Validate())
-	execConfig := b.execConfig
-	execConfigFetcher := func() *gethexec.Config { return execConfig }
-	execNode, err := gethexec.CreateExecutionNode(b.ctx, b.L2.Stack, l2chainDb, l2blockchain, b.L1.Client, execConfigFetcher)
+	Require(t, execConfig.Validate())
+	execConfigToBeUsedInConfigFetcher := execConfig
+	execConfigFetcher := func() *gethexec.Config { return execConfigToBeUsedInConfigFetcher }
+	execNode, err := gethexec.CreateExecutionNode(ctx, chainTestClient.Stack, chainDb, blockchain, parentChainTestClient.Client, execConfigFetcher)
 	Require(t, err)
 
 	fatalErrChan := make(chan error, 10)
-	b.L2.ConsensusNode, err = arbnode.CreateNode(
-		b.ctx, b.L2.Stack, execNode, l2arbDb, NewFetcherFromConfig(b.nodeConfig), l2blockchain.Config(), b.L1.Client,
-		b.addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, big.NewInt(1337), nil)
+	chainTestClient.ConsensusNode, err = arbnode.CreateNode(
+		ctx, chainTestClient.Stack, execNode, arbDb, NewFetcherFromConfig(nodeConfig), blockchain.Config(), parentChainTestClient.Client,
+		addresses, validatorTxOptsPtr, sequencerTxOptsPtr, dataSigner, fatalErrChan, parentChainId, nil)
 	Require(t, err)
 
-	err = b.L2.ConsensusNode.Start(b.ctx)
+	err = chainTestClient.ConsensusNode.Start(ctx)
 	Require(t, err)
 
-	b.L2.Client = ClientForStack(t, b.L2.Stack)
+	chainTestClient.Client = ClientForStack(t, chainTestClient.Stack)
 
-	StartWatchChanErr(t, b.ctx, fatalErrChan, b.L2.ConsensusNode)
+	StartWatchChanErr(t, ctx, fatalErrChan, chainTestClient.ConsensusNode)
+
+	chainTestClient.ExecNode = getExecNode(t, chainTestClient.ConsensusNode)
+	chainTestClient.cleanup = func() { chainTestClient.ConsensusNode.StopAndWait() }
+
+	return chainTestClient
+}
+
+func (b *NodeBuilder) BuildL3OnL2(t *testing.T) func() {
+	b.L3Info = NewArbTestInfo(t, b.l3Config.chainConfig.ChainID)
+
+	locator, err := server_common.NewMachineLocator(b.l3Config.valnodeConfig.Wasm.RootPath)
+	Require(t, err)
+
+	parentChainReaderConfig := headerreader.TestConfig
+	parentChainReaderConfig.Dangerous.WaitForTxApprovalSafePoll = 0
+	b.l3Addresses, b.l3InitMessage = deployOnParentChain(
+		t,
+		b.ctx,
+		b.L2Info,
+		b.L2.Client,
+		&parentChainReaderConfig,
+		b.l3Config.chainConfig,
+		locator.LatestWasmModuleRoot(),
+		b.l3Config.withProdConfirmPeriodBlocks,
+		false,
+	)
+
+	b.L3 = buildOnParentChain(
+		t,
+		b.ctx,
+
+		b.dataDir,
+
+		b.L2Info,
+		b.L2,
+		b.chainConfig.ChainID,
+
+		b.l3Config.chainConfig,
+		b.l3Config.stackConfig,
+		b.l3Config.execConfig,
+		b.l3Config.nodeConfig,
+		b.l3Config.valnodeConfig,
+		b.l3Config.isSequencer,
+		b.L3Info,
+
+		b.l3InitMessage,
+		b.l3Addresses,
+	)
+
+	return func() {
+		b.L3.cleanup()
+	}
+}
+
+func (b *NodeBuilder) BuildL2OnL1(t *testing.T) func() {
+	b.L2 = buildOnParentChain(
+		t,
+		b.ctx,
+
+		b.dataDir,
+
+		b.L1Info,
+		b.L1,
+		big.NewInt(1337),
+
+		b.chainConfig,
+		b.l2StackConfig,
+		b.execConfig,
+		b.nodeConfig,
+		b.valnodeConfig,
+		b.isSequencer,
+		b.L2Info,
+
+		b.initMessage,
+		b.addresses,
+	)
 
-	b.L2.ExecNode = getExecNode(t, b.L2.ConsensusNode)
-	b.L2.cleanup = func() { b.L2.ConsensusNode.StopAndWait() }
 	return func() {
 		b.L2.cleanup()
 		if b.L1 != nil && b.L1.cleanup != nil {
@@ -407,7 +572,7 @@ func (b *NodeBuilder) BuildL2(t *testing.T) func() {
 	var arbDb ethdb.Database
 	var blockchain *core.BlockChain
 	b.L2Info, b.L2.Stack, chainDb, arbDb, blockchain = createL2BlockChain(
-		t, b.L2Info, b.dataDir, b.chainConfig, &b.execConfig.Caching)
+		t, b.L2Info, b.dataDir, b.chainConfig, b.execConfig)
 
 	Require(t, b.execConfig.Validate())
 	execConfig := b.execConfig
@@ -458,7 +623,7 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	}
 	b.L2.cleanup()
 
-	l2info, stack, chainDb, arbDb, blockchain := createL2BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, &b.execConfig.Caching)
+	l2info, stack, chainDb, arbDb, blockchain := createNonL1BlockChainWithStackConfig(t, b.L2Info, b.dataDir, b.chainConfig, b.initMessage, b.l2StackConfig, b.execConfig)
 
 	execConfigFetcher := func() *gethexec.Config { return b.execConfig }
 	execNode, err := gethexec.CreateExecutionNode(b.ctx, stack, chainDb, blockchain, nil, execConfigFetcher)
@@ -483,13 +648,25 @@ func (b *NodeBuilder) RestartL2Node(t *testing.T) {
 	b.L2Info = l2info
 }
 
-func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
-	if b.L2 == nil {
-		t.Fatal("builder did not previously build a L2 Node")
-	}
-	if b.withL1 && b.L1 == nil {
-		t.Fatal("builder did not previously build a L1 Node")
-	}
+func build2ndNode(
+	t *testing.T,
+	ctx context.Context,
+
+	firstNodeStackConfig *node.Config,
+	firsNodeExecConfig *gethexec.Config,
+	firstNodeNodeConfig *arbnode.Config,
+	firstNodeInfo info,
+	firstNodeTestClient *TestClient,
+	valnodeConfig *valnode.Config,
+
+	parentChainTestClient *TestClient,
+	parentChainInfo info,
+
+	params *SecondNodeParams,
+
+	addresses *chaininfo.RollupAddresses,
+	initMessage *arbostypes.ParsedInitMessage,
+) (*TestClient, func()) {
 	if params.nodeConfig == nil {
 		params.nodeConfig = arbnode.ConfigDefaultL1NonSequencerTest()
 	}
@@ -497,18 +674,18 @@ func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*Tes
 		params.nodeConfig.DataAvailability = *params.dasConfig
 	}
 	if params.stackConfig == nil {
-		params.stackConfig = b.l2StackConfig
+		params.stackConfig = firstNodeStackConfig
 		// should use different dataDir from the previously used ones
 		params.stackConfig.DataDir = t.TempDir()
 	}
 	if params.initData == nil {
-		params.initData = &b.L2Info.ArbInitData
+		params.initData = &firstNodeInfo.ArbInitData
 	}
 	if params.execConfig == nil {
-		params.execConfig = b.execConfig
+		params.execConfig = firsNodeExecConfig
 	}
 	if params.addresses == nil {
-		params.addresses = b.addresses
+		params.addresses = addresses
 	}
 	if params.execConfig.RPC.MaxRecreateStateDepth == arbitrum.UninitializedMaxRecreateStateDepth {
 		if params.execConfig.Caching.Archive {
@@ -517,23 +694,76 @@ func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*Tes
 			params.execConfig.RPC.MaxRecreateStateDepth = arbitrum.DefaultNonArchiveNodeMaxRecreateStateDepth
 		}
 	}
-	if b.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.RedisUrl == "" {
+	if firstNodeNodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.Enable && params.nodeConfig.BatchPoster.RedisUrl == "" {
 		t.Fatal("The batch poster must use Redis when enabled for multiple nodes")
 	}
 
-	l2 := NewTestClient(b.ctx)
-	l2.Client, l2.ConsensusNode =
-		Create2ndNodeWithConfig(t, b.ctx, b.L2.ConsensusNode, b.L1.Stack, b.L1Info, params.initData, params.nodeConfig, params.execConfig, params.stackConfig, b.valnodeConfig, params.addresses, b.initMessage)
-	l2.ExecNode = getExecNode(t, l2.ConsensusNode)
-	l2.cleanup = func() { l2.ConsensusNode.StopAndWait() }
-	return l2, func() { l2.cleanup() }
+	testClient := NewTestClient(ctx)
+	testClient.Client, testClient.ConsensusNode =
+		Create2ndNodeWithConfig(t, ctx, firstNodeTestClient.ConsensusNode, parentChainTestClient.Stack, parentChainInfo, params.initData, params.nodeConfig, params.execConfig, params.stackConfig, valnodeConfig, params.addresses, initMessage)
+	testClient.ExecNode = getExecNode(t, testClient.ConsensusNode)
+	testClient.cleanup = func() { testClient.ConsensusNode.StopAndWait() }
+	return testClient, func() { testClient.cleanup() }
+}
+
+func (b *NodeBuilder) Build2ndNode(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
+	if b.L2 == nil {
+		t.Fatal("builder did not previously built an L2 Node")
+	}
+	if b.withL1 && b.L1 == nil {
+		t.Fatal("builder did not previously built an L1 Node")
+	}
+	return build2ndNode(
+		t,
+		b.ctx,
+
+		b.l2StackConfig,
+		b.execConfig,
+		b.nodeConfig,
+		b.L2Info,
+		b.L2,
+		b.valnodeConfig,
+
+		b.L1,
+		b.L1Info,
+
+		params,
+
+		b.addresses,
+		b.initMessage,
+	)
+}
+
+func (b *NodeBuilder) Build2ndNodeOnL3(t *testing.T, params *SecondNodeParams) (*TestClient, func()) {
+	if b.L3 == nil {
+		t.Fatal("builder did not previously built an L3 Node")
+	}
+	return build2ndNode(
+		t,
+		b.ctx,
+
+		b.l3Config.stackConfig,
+		b.l3Config.execConfig,
+		b.l3Config.nodeConfig,
+		b.L3Info,
+		b.L3,
+		b.l3Config.valnodeConfig,
+
+		b.L2,
+		b.L2Info,
+
+		params,
+
+		b.l3Addresses,
+		b.l3InitMessage,
+	)
 }
 
 func (b *NodeBuilder) BridgeBalance(t *testing.T, account string, amount *big.Int) (*types.Transaction, *types.Receipt) {
 	return BridgeBalance(t, account, amount, b.L1Info, b.L2Info, b.L1.Client, b.L2.Client, b.ctx)
 }
 
-func SendWaitTestTransactions(t *testing.T, ctx context.Context, client client, txs []*types.Transaction) {
+func SendWaitTestTransactions(t *testing.T, ctx context.Context, client *ethclient.Client, txs []*types.Transaction) {
 	t.Helper()
 	for _, tx := range txs {
 		Require(t, client.SendTransaction(ctx, tx))
@@ -545,14 +775,14 @@ func SendWaitTestTransactions(t *testing.T, ctx context.Context, client client,
 }
 
 func TransferBalance(
-	t *testing.T, from, to string, amount *big.Int, l2info info, client client, ctx context.Context,
+	t *testing.T, from, to string, amount *big.Int, l2info info, client *ethclient.Client, ctx context.Context,
 ) (*types.Transaction, *types.Receipt) {
 	t.Helper()
 	return TransferBalanceTo(t, from, l2info.GetAddress(to), amount, l2info, client, ctx)
 }
 
 func TransferBalanceTo(
-	t *testing.T, from string, to common.Address, amount *big.Int, l2info info, client client, ctx context.Context,
+	t *testing.T, from string, to common.Address, amount *big.Int, l2info info, client *ethclient.Client, ctx context.Context,
 ) (*types.Transaction, *types.Receipt) {
 	t.Helper()
 	tx := l2info.PrepareTxTo(from, &to, l2info.TransferGas, amount, nil)
@@ -565,7 +795,7 @@ func TransferBalanceTo(
 
 // if l2client is not nil - will wait until balance appears in l2
 func BridgeBalance(
-	t *testing.T, account string, amount *big.Int, l1info info, l2info info, l1client client, l2client client, ctx context.Context,
+	t *testing.T, account string, amount *big.Int, l1info info, l2info info, l1client *ethclient.Client, l2client *ethclient.Client, ctx context.Context,
 ) (*types.Transaction, *types.Receipt) {
 	t.Helper()
 
@@ -611,7 +841,7 @@ func BridgeBalance(
 				break
 			}
 			TransferBalance(t, "Faucet", "User", big.NewInt(1), l1info, l1client, ctx)
-			if i > 20 {
+			if i > 200 {
 				Fatal(t, "bridging failed")
 			}
 			<-time.After(time.Millisecond * 100)
@@ -625,8 +855,8 @@ func SendSignedTxesInBatchViaL1(
 	t *testing.T,
 	ctx context.Context,
 	l1info *BlockchainTestInfo,
-	l1client arbutil.L1Interface,
-	l2client arbutil.L1Interface,
+	l1client *ethclient.Client,
+	l2client *ethclient.Client,
 	delayedTxes types.Transactions,
 ) types.Receipts {
 	delayedInboxContract, err := bridgegen.NewInbox(l1info.GetAddress("Inbox"), l1client)
@@ -664,7 +894,7 @@ func l2MessageBatchDataFromTxes(txes types.Transactions) ([]byte, error) {
 		if err != nil {
 			return nil, err
 		}
-		binary.BigEndian.PutUint64(sizeBuf, uint64(len(txBytes)+1))
+		binary.BigEndian.PutUint64(sizeBuf, uint64(len(txBytes))+1)
 		l2Message = append(l2Message, sizeBuf...)
 		l2Message = append(l2Message, arbos.L2MessageKind_SignedTx)
 		l2Message = append(l2Message, txBytes...)
@@ -676,8 +906,8 @@ func SendSignedTxViaL1(
 	t *testing.T,
 	ctx context.Context,
 	l1info *BlockchainTestInfo,
-	l1client arbutil.L1Interface,
-	l2client arbutil.L1Interface,
+	l1client *ethclient.Client,
+	l2client *ethclient.Client,
 	delayedTx *types.Transaction,
 ) *types.Receipt {
 	delayedInboxContract, err := bridgegen.NewInbox(l1info.GetAddress("Inbox"), l1client)
@@ -707,8 +937,8 @@ func SendUnsignedTxViaL1(
 	t *testing.T,
 	ctx context.Context,
 	l1info *BlockchainTestInfo,
-	l1client arbutil.L1Interface,
-	l2client arbutil.L1Interface,
+	l1client *ethclient.Client,
+	l2client *ethclient.Client,
 	templateTx *types.Transaction,
 ) *types.Receipt {
 	delayedInboxContract, err := bridgegen.NewInbox(l1info.GetAddress("Inbox"), l1client)
@@ -754,13 +984,13 @@ func SendUnsignedTxViaL1(
 	return receipt
 }
 
-func GetBaseFee(t *testing.T, client client, ctx context.Context) *big.Int {
+func GetBaseFee(t *testing.T, client *ethclient.Client, ctx context.Context) *big.Int {
 	header, err := client.HeaderByNumber(ctx, nil)
 	Require(t, err)
 	return header.BaseFee
 }
 
-func GetBaseFeeAt(t *testing.T, client client, ctx context.Context, blockNum *big.Int) *big.Int {
+func GetBaseFeeAt(t *testing.T, client *ethclient.Client, ctx context.Context, blockNum *big.Int) *big.Int {
 	header, err := client.HeaderByNumber(ctx, blockNum)
 	Require(t, err)
 	return header.BaseFee
@@ -982,8 +1212,8 @@ func createTestL1BlockChain(t *testing.T, l1info info) (info, *ethclient.Client,
 	return l1info, l1Client, l1backend, stack
 }
 
-func getInitMessage(ctx context.Context, t *testing.T, l1client client, addresses *chaininfo.RollupAddresses) *arbostypes.ParsedInitMessage {
-	bridge, err := arbnode.NewDelayedBridge(l1client, addresses.Bridge, addresses.DeployedAt)
+func getInitMessage(ctx context.Context, t *testing.T, parentChainClient *ethclient.Client, addresses *chaininfo.RollupAddresses) *arbostypes.ParsedInitMessage {
+	bridge, err := arbnode.NewDelayedBridge(parentChainClient, addresses.Bridge, addresses.DeployedAt)
 	Require(t, err)
 	deployedAtBig := arbmath.UintToBig(addresses.DeployedAt)
 	messages, err := bridge.LookupMessagesInRange(ctx, deployedAtBig, deployedAtBig, nil)
@@ -997,82 +1227,92 @@ func getInitMessage(ctx context.Context, t *testing.T, l1client client, addresse
 	return initMessage
 }
 
-func DeployOnTestL1(
-	t *testing.T, ctx context.Context, l1info info, l1client client, chainConfig *params.ChainConfig, wasmModuleRoot common.Hash, prodConfirmPeriodBlocks bool,
+func deployOnParentChain(
+	t *testing.T,
+	ctx context.Context,
+	parentChainInfo info,
+	parentChainClient *ethclient.Client,
+	parentChainReaderConfig *headerreader.Config,
+	chainConfig *params.ChainConfig,
+	wasmModuleRoot common.Hash,
+	prodConfirmPeriodBlocks bool,
+	chainSupportsBlobs bool,
 ) (*chaininfo.RollupAddresses, *arbostypes.ParsedInitMessage) {
-	l1info.GenerateAccount("RollupOwner")
-	l1info.GenerateAccount("Sequencer")
-	l1info.GenerateAccount("Validator")
-	l1info.GenerateAccount("User")
-
-	SendWaitTestTransactions(t, ctx, l1client, []*types.Transaction{
-		l1info.PrepareTx("Faucet", "RollupOwner", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "Sequencer", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "Validator", 30000, big.NewInt(9223372036854775807), nil),
-		l1info.PrepareTx("Faucet", "User", 30000, big.NewInt(9223372036854775807), nil)})
-
-	l1TransactionOpts := l1info.GetDefaultTransactOpts("RollupOwner", ctx)
+	parentChainInfo.GenerateAccount("RollupOwner")
+	parentChainInfo.GenerateAccount("Sequencer")
+	parentChainInfo.GenerateAccount("Validator")
+	parentChainInfo.GenerateAccount("User")
+
+	SendWaitTestTransactions(t, ctx, parentChainClient, []*types.Transaction{
+		parentChainInfo.PrepareTx("Faucet", "RollupOwner", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "Sequencer", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "Validator", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil),
+		parentChainInfo.PrepareTx("Faucet", "User", parentChainInfo.TransferGas, big.NewInt(9223372036854775807), nil)})
+
+	parentChainTransactionOpts := parentChainInfo.GetDefaultTransactOpts("RollupOwner", ctx)
 	serializedChainConfig, err := json.Marshal(chainConfig)
 	Require(t, err)
 
-	arbSys, _ := precompilesgen.NewArbSys(types.ArbSysAddress, l1client)
-	l1Reader, err := headerreader.New(ctx, l1client, func() *headerreader.Config { return &headerreader.TestConfig }, arbSys)
+	arbSys, _ := precompilesgen.NewArbSys(types.ArbSysAddress, parentChainClient)
+	parentChainReader, err := headerreader.New(ctx, parentChainClient, func() *headerreader.Config { return parentChainReaderConfig }, arbSys)
 	Require(t, err)
-	l1Reader.Start(ctx)
-	defer l1Reader.StopAndWait()
+	parentChainReader.Start(ctx)
+	defer parentChainReader.StopAndWait()
 
 	nativeToken := common.Address{}
 	maxDataSize := big.NewInt(117964)
-	addresses, err := deploy.DeployOnL1(
+	addresses, err := deploy.DeployOnParentChain(
 		ctx,
-		l1Reader,
-		&l1TransactionOpts,
-		[]common.Address{l1info.GetAddress("Sequencer")},
-		l1info.GetAddress("RollupOwner"),
+		parentChainReader,
+		&parentChainTransactionOpts,
+		[]common.Address{parentChainInfo.GetAddress("Sequencer")},
+		parentChainInfo.GetAddress("RollupOwner"),
 		0,
-		arbnode.GenerateRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, l1info.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}),
+		arbnode.GenerateRollupConfig(prodConfirmPeriodBlocks, wasmModuleRoot, parentChainInfo.GetAddress("RollupOwner"), chainConfig, serializedChainConfig, common.Address{}),
 		nativeToken,
 		maxDataSize,
-		false,
+		chainSupportsBlobs,
 	)
 	Require(t, err)
-	l1info.SetContract("Bridge", addresses.Bridge)
-	l1info.SetContract("SequencerInbox", addresses.SequencerInbox)
-	l1info.SetContract("Inbox", addresses.Inbox)
-	l1info.SetContract("UpgradeExecutor", addresses.UpgradeExecutor)
-	initMessage := getInitMessage(ctx, t, l1client, addresses)
+	parentChainInfo.SetContract("Bridge", addresses.Bridge)
+	parentChainInfo.SetContract("SequencerInbox", addresses.SequencerInbox)
+	parentChainInfo.SetContract("Inbox", addresses.Inbox)
+	parentChainInfo.SetContract("UpgradeExecutor", addresses.UpgradeExecutor)
+	initMessage := getInitMessage(ctx, t, parentChainClient, addresses)
 	return addresses, initMessage
 }
 
 func createL2BlockChain(
-	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, cacheConfig *gethexec.CachingConfig,
+	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, execConfig *gethexec.Config,
 ) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
-	return createL2BlockChainWithStackConfig(t, l2info, dataDir, chainConfig, nil, nil, cacheConfig)
+	return createNonL1BlockChainWithStackConfig(t, l2info, dataDir, chainConfig, nil, nil, execConfig)
 }
 
-func createL2BlockChainWithStackConfig(
-	t *testing.T, l2info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, cacheConfig *gethexec.CachingConfig,
+func createNonL1BlockChainWithStackConfig(
+	t *testing.T, info *BlockchainTestInfo, dataDir string, chainConfig *params.ChainConfig, initMessage *arbostypes.ParsedInitMessage, stackConfig *node.Config, execConfig *gethexec.Config,
 ) (*BlockchainTestInfo, *node.Node, ethdb.Database, ethdb.Database, *core.BlockChain) {
-	if l2info == nil {
-		l2info = NewArbTestInfo(t, chainConfig.ChainID)
+	if info == nil {
+		info = NewArbTestInfo(t, chainConfig.ChainID)
 	}
-	var stack *node.Node
-	var err error
 	if stackConfig == nil {
 		stackConfig = testhelpers.CreateStackConfigForTest(dataDir)
 	}
-	stack, err = node.New(stackConfig)
+	if execConfig == nil {
+		execConfig = ExecConfigDefaultTest(t)
+	}
+
+	stack, err := node.New(stackConfig)
 	Require(t, err)
 
 	chainData, err := stack.OpenDatabaseWithExtraOptions("l2chaindata", 0, 0, "l2chaindata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata"))
 	Require(t, err)
 	wasmData, err := stack.OpenDatabaseWithExtraOptions("wasm", 0, 0, "wasm/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"))
 	Require(t, err)
-	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmData, 0)
+	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmData, 0, execConfig.StylusTarget.WasmTargets())
 	arbDb, err := stack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
 	Require(t, err)
 
-	initReader := statetransfer.NewMemoryInitDataReader(&l2info.ArbInitData)
+	initReader := statetransfer.NewMemoryInitDataReader(&info.ArbInitData)
 	if initMessage == nil {
 		serializedChainConfig, err := json.Marshal(chainConfig)
 		Require(t, err)
@@ -1083,14 +1323,11 @@ func createL2BlockChainWithStackConfig(
 			SerializedChainConfig: serializedChainConfig,
 		}
 	}
-	var coreCacheConfig *core.CacheConfig
-	if cacheConfig != nil {
-		coreCacheConfig = gethexec.DefaultCacheConfigFor(stack, cacheConfig)
-	}
-	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest().TxLookupLimit, 0)
+	coreCacheConfig := gethexec.DefaultCacheConfigFor(stack, &execConfig.Caching)
+	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest(t).TxLookupLimit, 0)
 	Require(t, err)
 
-	return l2info, stack, chainDb, arbDb, blockchain
+	return info, stack, chainDb, arbDb, blockchain
 }
 
 func ClientForStack(t *testing.T, backend *node.Node) *ethclient.Client {
@@ -1133,9 +1370,9 @@ func Create2ndNodeWithConfig(
 	t *testing.T,
 	ctx context.Context,
 	first *arbnode.Node,
-	l1stack *node.Node,
-	l1info *BlockchainTestInfo,
-	l2InitData *statetransfer.ArbosInitializationInfo,
+	parentChainStack *node.Node,
+	parentChainInfo *BlockchainTestInfo,
+	chainInitData *statetransfer.ArbosInitializationInfo,
 	nodeConfig *arbnode.Config,
 	execConfig *gethexec.Config,
 	stackConfig *node.Config,
@@ -1147,37 +1384,37 @@ func Create2ndNodeWithConfig(
 		nodeConfig = arbnode.ConfigDefaultL1NonSequencerTest()
 	}
 	if execConfig == nil {
-		execConfig = ExecConfigDefaultNonSequencerTest()
+		execConfig = ExecConfigDefaultNonSequencerTest(t)
 	}
 	feedErrChan := make(chan error, 10)
-	l1rpcClient := l1stack.Attach()
-	l1client := ethclient.NewClient(l1rpcClient)
+	parentChainRpcClient := parentChainStack.Attach()
+	parentChainClient := ethclient.NewClient(parentChainRpcClient)
 
 	if stackConfig == nil {
 		stackConfig = testhelpers.CreateStackConfigForTest(t.TempDir())
 	}
-	l2stack, err := node.New(stackConfig)
+	chainStack, err := node.New(stackConfig)
 	Require(t, err)
 
-	l2chainData, err := l2stack.OpenDatabaseWithExtraOptions("l2chaindata", 0, 0, "l2chaindata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata"))
+	chainData, err := chainStack.OpenDatabaseWithExtraOptions("l2chaindata", 0, 0, "l2chaindata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("l2chaindata"))
 	Require(t, err)
-	wasmData, err := l2stack.OpenDatabaseWithExtraOptions("wasm", 0, 0, "wasm/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"))
+	wasmData, err := chainStack.OpenDatabaseWithExtraOptions("wasm", 0, 0, "wasm/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("wasm"))
 	Require(t, err)
-	l2chainDb := rawdb.WrapDatabaseWithWasm(l2chainData, wasmData, 0)
+	chainDb := rawdb.WrapDatabaseWithWasm(chainData, wasmData, 0, execConfig.StylusTarget.WasmTargets())
 
-	l2arbDb, err := l2stack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
+	arbDb, err := chainStack.OpenDatabaseWithExtraOptions("arbitrumdata", 0, 0, "arbitrumdata/", false, conf.PersistentConfigDefault.Pebble.ExtraOptions("arbitrumdata"))
 	Require(t, err)
-	initReader := statetransfer.NewMemoryInitDataReader(l2InitData)
+	initReader := statetransfer.NewMemoryInitDataReader(chainInitData)
 
-	dataSigner := signature.DataSignerFromPrivateKey(l1info.GetInfoWithPrivKey("Sequencer").PrivateKey)
-	sequencerTxOpts := l1info.GetDefaultTransactOpts("Sequencer", ctx)
-	validatorTxOpts := l1info.GetDefaultTransactOpts("Validator", ctx)
+	dataSigner := signature.DataSignerFromPrivateKey(parentChainInfo.GetInfoWithPrivKey("Sequencer").PrivateKey)
+	sequencerTxOpts := parentChainInfo.GetDefaultTransactOpts("Sequencer", ctx)
+	validatorTxOpts := parentChainInfo.GetDefaultTransactOpts("Validator", ctx)
 	firstExec := getExecNode(t, first)
 
 	chainConfig := firstExec.ArbInterface.BlockChain().Config()
 
-	coreCacheConfig := gethexec.DefaultCacheConfigFor(l2stack, &execConfig.Caching)
-	l2blockchain, err := gethexec.WriteOrTestBlockChain(l2chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest().TxLookupLimit, 0)
+	coreCacheConfig := gethexec.DefaultCacheConfigFor(chainStack, &execConfig.Caching)
+	blockchain, err := gethexec.WriteOrTestBlockChain(chainDb, coreCacheConfig, initReader, chainConfig, initMessage, ExecConfigDefaultTest(t).TxLookupLimit, 0)
 	Require(t, err)
 
 	AddValNodeIfNeeded(t, ctx, nodeConfig, true, "", valnodeConfig.Wasm.RootPath)
@@ -1185,19 +1422,19 @@ func Create2ndNodeWithConfig(
 	Require(t, execConfig.Validate())
 	Require(t, nodeConfig.Validate())
 	configFetcher := func() *gethexec.Config { return execConfig }
-	currentExec, err := gethexec.CreateExecutionNode(ctx, l2stack, l2chainDb, l2blockchain, l1client, configFetcher)
+	currentExec, err := gethexec.CreateExecutionNode(ctx, chainStack, chainDb, blockchain, parentChainClient, configFetcher)
 	Require(t, err)
 
-	currentNode, err := arbnode.CreateNode(ctx, l2stack, currentExec, l2arbDb, NewFetcherFromConfig(nodeConfig), l2blockchain.Config(), l1client, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil)
+	currentNode, err := arbnode.CreateNode(ctx, chainStack, currentExec, arbDb, NewFetcherFromConfig(nodeConfig), blockchain.Config(), parentChainClient, addresses, &validatorTxOpts, &sequencerTxOpts, dataSigner, feedErrChan, big.NewInt(1337), nil)
 	Require(t, err)
 
 	err = currentNode.Start(ctx)
 	Require(t, err)
-	l2client := ClientForStack(t, l2stack)
+	chainClient := ClientForStack(t, chainStack)
 
 	StartWatchChanErr(t, ctx, feedErrChan, currentNode)
 
-	return l2client, currentNode
+	return chainClient, currentNode
 }
 
 func GetBalance(t *testing.T, ctx context.Context, client *ethclient.Client, account common.Address) *big.Int {
@@ -1217,7 +1454,7 @@ func authorizeDASKeyset(
 	ctx context.Context,
 	dasSignerKey *blsSignatures.PublicKey,
 	l1info info,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 ) {
 	if dasSignerKey == nil {
 		return
@@ -1457,6 +1694,34 @@ func logParser[T any](t *testing.T, source string, name string) func(*types.Log)
 	}
 }
 
+// recordBlock writes a json file with all of the data needed to validate a block.
+//
+// This can be used as an input to the arbitrator prover to validate a block.
+func recordBlock(t *testing.T, block uint64, builder *NodeBuilder) {
+	t.Helper()
+	ctx := builder.ctx
+	inboxPos := arbutil.MessageIndex(block)
+	for {
+		time.Sleep(250 * time.Millisecond)
+		batches, err := builder.L2.ConsensusNode.InboxTracker.GetBatchCount()
+		Require(t, err)
+		haveMessages, err := builder.L2.ConsensusNode.InboxTracker.GetBatchMessageCount(batches - 1)
+		Require(t, err)
+		if haveMessages >= inboxPos {
+			break
+		}
+	}
+	validationInputsWriter, err := inputs.NewWriter(inputs.WithSlug(t.Name()))
+	Require(t, err)
+	inputJson, err := builder.L2.ConsensusNode.StatelessBlockValidator.ValidationInputsAt(ctx, inboxPos, rawdb.TargetWavm)
+	if err != nil {
+		Fatal(t, "failed to get validation inputs", block, err)
+	}
+	if err := validationInputsWriter.Write(&inputJson); err != nil {
+		Fatal(t, "failed to write validation inputs", block, err)
+	}
+}
+
 func populateMachineDir(t *testing.T, cr *github.ConsensusRelease) string {
 	baseDir := t.TempDir()
 	machineDir := baseDir + "/machines"
diff --git a/system_tests/contract_tx_test.go b/system_tests/contract_tx_test.go
index 7d66e51..c1ef840 100644
--- a/system_tests/contract_tx_test.go
+++ b/system_tests/contract_tx_test.go
@@ -51,6 +51,7 @@ func TestContractTxDeploy(t *testing.T) {
 			0xF3, // RETURN
 		}
 		var requestId common.Hash
+		// #nosec G115
 		requestId[0] = uint8(stateNonce)
 		contractTx := &types.ArbitrumContractTx{
 			ChainId:   params.ArbitrumDevTestChainConfig().ChainID,
diff --git a/system_tests/das_test.go b/system_tests/das_test.go
index 9f4d153..69872b3 100644
--- a/system_tests/das_test.go
+++ b/system_tests/das_test.go
@@ -22,7 +22,6 @@ import (
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/offchainlabs/nitro/arbnode"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/blsSignatures"
 	"github.com/offchainlabs/nitro/cmd/genericconf"
 	"github.com/offchainlabs/nitro/das"
@@ -37,7 +36,7 @@ func startLocalDASServer(
 	t *testing.T,
 	ctx context.Context,
 	dataDir string,
-	l1client arbutil.L1Interface,
+	l1client *ethclient.Client,
 	seqInboxAddress common.Address,
 ) (*http.Server, *blsSignatures.PublicKey, das.BackendConfig, *das.RestfulDasServer, string) {
 	keyDir := t.TempDir()
diff --git a/system_tests/estimation_test.go b/system_tests/estimation_test.go
index 284c709..6285702 100644
--- a/system_tests/estimation_test.go
+++ b/system_tests/estimation_test.go
@@ -214,7 +214,7 @@ func TestComponentEstimate(t *testing.T) {
 
 	userBalance := big.NewInt(1e16)
 	maxPriorityFeePerGas := big.NewInt(0)
-	maxFeePerGas := arbmath.BigMulByUfrac(l2BaseFee, 3, 2)
+	maxFeePerGas := arbmath.BigMulByUFrac(l2BaseFee, 3, 2)
 
 	builder.L2Info.GenerateAccount("User")
 	builder.L2.TransferBalance(t, "Owner", "User", userBalance, builder.L2Info)
diff --git a/system_tests/eth_sync_test.go b/system_tests/eth_sync_test.go
index 1f07f7c..ce9994f 100644
--- a/system_tests/eth_sync_test.go
+++ b/system_tests/eth_sync_test.go
@@ -71,7 +71,7 @@ func TestEthSyncing(t *testing.T) {
 	if progress == nil {
 		Fatal(t, "eth_syncing returned nil but shouldn't have")
 	}
-	for testClientB.ConsensusNode.TxStreamer.ExecuteNextMsg(ctx, testClientB.ExecNode) {
+	for testClientB.ConsensusNode.TxStreamer.ExecuteNextMsg(ctx) {
 	}
 	progress, err = testClientB.Client.SyncProgress(ctx)
 	Require(t, err)
diff --git a/system_tests/fast_confirm_test.go b/system_tests/fast_confirm_test.go
index f05219d..dae2699 100644
--- a/system_tests/fast_confirm_test.go
+++ b/system_tests/fast_confirm_test.go
@@ -79,15 +79,6 @@ func TestFastConfirmation(t *testing.T) {
 	builder.L1.TransferBalance(t, "Faucet", "Validator", balance, builder.L1Info)
 	l1auth := builder.L1Info.GetDefaultTransactOpts("Validator", ctx)
 
-	valWalletAddrPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2node.DeployInfo.ValidatorWalletCreator, 0, &l1auth, l2node.L1Reader, true)
-	Require(t, err)
-	valWalletAddr := *valWalletAddrPtr
-	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2node.DeployInfo.ValidatorWalletCreator, 0, &l1auth, l2node.L1Reader, true)
-	Require(t, err)
-	if valWalletAddr == *valWalletAddrCheck {
-		Require(t, err, "didn't cache validator wallet address", valWalletAddr.String(), "vs", valWalletAddrCheck.String())
-	}
-
 	rollup, err := rollupgen.NewRollupAdminLogic(l2node.DeployInfo.Rollup, builder.L1.Client)
 	Require(t, err)
 
@@ -96,27 +87,13 @@ func TestFastConfirmation(t *testing.T) {
 	rollupABI, err := abi.JSON(strings.NewReader(rollupgen.RollupAdminLogicABI))
 	Require(t, err, "unable to parse rollup ABI")
 
-	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddr, srv.Address}, []bool{true, true})
-	Require(t, err, "unable to generate setValidator calldata")
-	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setValidatorCalldata)
-	Require(t, err, "unable to set validators")
-	_, err = builder.L1.EnsureTxSucceeded(tx)
-	Require(t, err)
-
 	setMinAssertPeriodCalldata, err := rollupABI.Pack("setMinimumAssertionPeriod", big.NewInt(1))
 	Require(t, err, "unable to generate setMinimumAssertionPeriod calldata")
-	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setMinAssertPeriodCalldata)
+	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setMinAssertPeriodCalldata)
 	Require(t, err, "unable to set minimum assertion period")
 	_, err = builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
 
-	setAnyTrustFastConfirmerCalldata, err := rollupABI.Pack("setAnyTrustFastConfirmer", valWalletAddr)
-	Require(t, err, "unable to generate setAnyTrustFastConfirmer calldata")
-	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setAnyTrustFastConfirmerCalldata)
-	Require(t, err, "unable to set anytrust fast confirmer")
-	_, err = builder.L1.EnsureTxSucceeded(tx)
-	Require(t, err)
-
 	valConfig := staker.TestL1ValidatorConfig
 	valConfig.EnableFastConfirmation = true
 	parentChainID, err := builder.L1.Client.ChainID(ctx)
@@ -138,6 +115,29 @@ func TestFastConfirmation(t *testing.T) {
 	Require(t, err)
 	valConfig.Strategy = "MakeNodes"
 
+	valWalletAddrPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2node.DeployInfo.ValidatorWalletCreator, 0, l2node.L1Reader, true, valWallet.DataPoster(), valWallet.GetExtraGas())
+	Require(t, err)
+	valWalletAddr := *valWalletAddrPtr
+	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2node.DeployInfo.ValidatorWalletCreator, 0, l2node.L1Reader, true, valWallet.DataPoster(), valWallet.GetExtraGas())
+	Require(t, err)
+	if valWalletAddr == *valWalletAddrCheck {
+		Require(t, err, "didn't cache validator wallet address", valWalletAddr.String(), "vs", valWalletAddrCheck.String())
+	}
+
+	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddr, srv.Address}, []bool{true, true})
+	Require(t, err, "unable to generate setValidator calldata")
+	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setValidatorCalldata)
+	Require(t, err, "unable to set validators")
+	_, err = builder.L1.EnsureTxSucceeded(tx)
+	Require(t, err)
+
+	setAnyTrustFastConfirmerCalldata, err := rollupABI.Pack("setAnyTrustFastConfirmer", valWalletAddr)
+	Require(t, err, "unable to generate setAnyTrustFastConfirmer calldata")
+	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2node.DeployInfo.Rollup, setAnyTrustFastConfirmerCalldata)
+	Require(t, err, "unable to set anytrust fast confirmer")
+	_, err = builder.L1.EnsureTxSucceeded(tx)
+	Require(t, err)
+
 	_, valStack := createTestValidationNode(t, ctx, &valnode.TestValidationConfig)
 	blockValidatorConfig := staker.TestBlockValidatorConfig
 
@@ -160,7 +160,7 @@ func TestFastConfirmation(t *testing.T) {
 		l2node.L1Reader,
 		valWallet,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfig },
 		nil,
 		stateless,
 		nil,
@@ -278,15 +278,6 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 	builder.L1.TransferBalance(t, "Faucet", "ValidatorB", balance, builder.L1Info)
 	l1authB := builder.L1Info.GetDefaultTransactOpts("ValidatorB", ctx)
 
-	valWalletAddrAPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, &l1authA, l2nodeA.L1Reader, true)
-	Require(t, err)
-	valWalletAddrA := *valWalletAddrAPtr
-	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, &l1authA, l2nodeA.L1Reader, true)
-	Require(t, err)
-	if valWalletAddrA == *valWalletAddrCheck {
-		Require(t, err, "didn't cache validator wallet address", valWalletAddrA.String(), "vs", valWalletAddrCheck.String())
-	}
-
 	rollup, err := rollupgen.NewRollupAdminLogic(l2nodeA.DeployInfo.Rollup, builder.L1.Client)
 	Require(t, err)
 
@@ -295,30 +286,15 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 	rollupABI, err := abi.JSON(strings.NewReader(rollupgen.RollupAdminLogicABI))
 	Require(t, err, "unable to parse rollup ABI")
 
-	safeAddress := deploySafe(t, builder.L1, builder.L1.Client, deployAuth, []common.Address{valWalletAddrA, srv.Address})
-	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddrA, l1authB.From, srv.Address, safeAddress}, []bool{true, true, true, true})
-	Require(t, err, "unable to generate setValidator calldata")
-	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setValidatorCalldata)
-	Require(t, err, "unable to set validators")
-	_, err = builder.L1.EnsureTxSucceeded(tx)
-	Require(t, err)
-
 	setMinAssertPeriodCalldata, err := rollupABI.Pack("setMinimumAssertionPeriod", big.NewInt(1))
 	Require(t, err, "unable to generate setMinimumAssertionPeriod calldata")
-	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setMinAssertPeriodCalldata)
+	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setMinAssertPeriodCalldata)
 	Require(t, err, "unable to set minimum assertion period")
 	_, err = builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
 
-	setAnyTrustFastConfirmerCalldata, err := rollupABI.Pack("setAnyTrustFastConfirmer", safeAddress)
-	Require(t, err, "unable to generate setAnyTrustFastConfirmer calldata")
-	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setAnyTrustFastConfirmerCalldata)
-	Require(t, err, "unable to set anytrust fast confirmer")
-	_, err = builder.L1.EnsureTxSucceeded(tx)
-	Require(t, err)
-
-	valConfig := staker.TestL1ValidatorConfig
-	valConfig.EnableFastConfirmation = true
+	valConfigA := staker.TestL1ValidatorConfig
+	valConfigA.EnableFastConfirmation = true
 
 	parentChainID, err := builder.L1.Client.ChainID(ctx)
 	if err != nil {
@@ -335,9 +311,33 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Error creating validator dataposter: %v", err)
 	}
-	valWalletA, err := validatorwallet.NewContract(dpA, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {}, func() uint64 { return valConfig.ExtraGas })
+	valWalletA, err := validatorwallet.NewContract(dpA, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {}, func() uint64 { return valConfigA.ExtraGas })
+	Require(t, err)
+	valConfigA.Strategy = "MakeNodes"
+
+	valWalletAddrAPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, l2nodeA.L1Reader, true, valWalletA.DataPoster(), valWalletA.GetExtraGas())
+	Require(t, err)
+	valWalletAddrA := *valWalletAddrAPtr
+	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, l2nodeA.L1Reader, true, valWalletA.DataPoster(), valWalletA.GetExtraGas())
+	Require(t, err)
+	if valWalletAddrA == *valWalletAddrCheck {
+		Require(t, err, "didn't cache validator wallet address", valWalletAddrA.String(), "vs", valWalletAddrCheck.String())
+	}
+
+	safeAddress := deploySafe(t, builder.L1, builder.L1.Client, deployAuth, []common.Address{valWalletAddrA, srv.Address})
+	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddrA, l1authB.From, srv.Address, safeAddress}, []bool{true, true, true, true})
+	Require(t, err, "unable to generate setValidator calldata")
+	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setValidatorCalldata)
+	Require(t, err, "unable to set validators")
+	_, err = builder.L1.EnsureTxSucceeded(tx)
+	Require(t, err)
+
+	setAnyTrustFastConfirmerCalldata, err := rollupABI.Pack("setAnyTrustFastConfirmer", safeAddress)
+	Require(t, err, "unable to generate setAnyTrustFastConfirmer calldata")
+	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setAnyTrustFastConfirmerCalldata)
+	Require(t, err, "unable to set anytrust fast confirmer")
+	_, err = builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
-	valConfig.Strategy = "MakeNodes"
 
 	_, valStack := createTestValidationNode(t, ctx, &valnode.TestValidationConfig)
 	blockValidatorConfig := staker.TestBlockValidatorConfig
@@ -361,7 +361,7 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 		l2nodeA.L1Reader,
 		valWalletA,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfigA },
 		nil,
 		statelessA,
 		nil,
@@ -391,7 +391,9 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 	}
 	valWalletB, err := validatorwallet.NewEOA(dpB, l2nodeB.DeployInfo.Rollup, l2nodeB.L1Reader.Client(), func() uint64 { return 0 })
 	Require(t, err)
-	valConfig.Strategy = "watchtower"
+	valConfigB := staker.TestL1ValidatorConfig
+	valConfigB.EnableFastConfirmation = true
+	valConfigB.Strategy = "watchtower"
 	statelessB, err := staker.NewStatelessBlockValidator(
 		l2nodeB.InboxReader,
 		l2nodeB.InboxTracker,
@@ -411,7 +413,7 @@ func TestFastConfirmationWithSafe(t *testing.T) {
 		l2nodeB.L1Reader,
 		valWalletB,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfigB },
 		nil,
 		statelessB,
 		nil,
diff --git a/system_tests/forwarder_test.go b/system_tests/forwarder_test.go
index 9fe4195..57381ca 100644
--- a/system_tests/forwarder_test.go
+++ b/system_tests/forwarder_test.go
@@ -38,7 +38,7 @@ func TestStaticForwarder(t *testing.T) {
 	clientA := builder.L2.Client
 
 	nodeConfigB := arbnode.ConfigDefaultL1Test()
-	execConfigB := ExecConfigDefaultTest()
+	execConfigB := ExecConfigDefaultTest(t)
 	execConfigB.Sequencer.Enable = false
 	nodeConfigB.Sequencer = false
 	nodeConfigB.DelayedSequencer.Enable = false
@@ -109,7 +109,7 @@ func createForwardingNode(t *testing.T, builder *NodeBuilder, ipcPath string, re
 	nodeConfig.Sequencer = false
 	nodeConfig.DelayedSequencer.Enable = false
 	nodeConfig.BatchPoster.Enable = false
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.Sequencer.Enable = false
 	execConfig.Forwarder.RedisUrl = redisUrl
 	execConfig.ForwardingTarget = fallbackPath
@@ -246,6 +246,7 @@ func TestRedisForwarder(t *testing.T) {
 	for i := range seqClients {
 		userA := user("A", i)
 		builder.L2Info.GenerateAccount(userA)
+		// #nosec G115
 		tx := builder.L2Info.PrepareTx("Owner", userA, builder.L2Info.TransferGas, big.NewInt(1e12+int64(builder.L2Info.TransferGas)*builder.L2Info.GasPrice.Int64()), nil)
 		err := fallbackClient.SendTransaction(ctx, tx)
 		Require(t, err)
diff --git a/system_tests/full_challenge_impl_test.go b/system_tests/full_challenge_impl_test.go
index ddc2290..bf30c92 100644
--- a/system_tests/full_challenge_impl_test.go
+++ b/system_tests/full_challenge_impl_test.go
@@ -27,7 +27,6 @@ import (
 	"github.com/offchainlabs/nitro/arbnode"
 	"github.com/offchainlabs/nitro/arbos"
 	"github.com/offchainlabs/nitro/arbstate"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/solgen/go/challengegen"
 	"github.com/offchainlabs/nitro/solgen/go/mocksgen"
 	"github.com/offchainlabs/nitro/solgen/go/ospgen"
@@ -178,7 +177,7 @@ func makeBatch(t *testing.T, l2Node *arbnode.Node, l2Info *BlockchainTestInfo, b
 	Require(t, err, "failed to get batch metadata after adding batch:")
 }
 
-func confirmLatestBlock(ctx context.Context, t *testing.T, l1Info *BlockchainTestInfo, backend arbutil.L1Interface) {
+func confirmLatestBlock(ctx context.Context, t *testing.T, l1Info *BlockchainTestInfo, backend *ethclient.Client) {
 	t.Helper()
 	// With SimulatedBeacon running in on-demand block production mode, the
 	// finalized block is considered to be be the nearest multiple of 32 less
@@ -190,7 +189,7 @@ func confirmLatestBlock(ctx context.Context, t *testing.T, l1Info *BlockchainTes
 	}
 }
 
-func setupSequencerInboxStub(ctx context.Context, t *testing.T, l1Info *BlockchainTestInfo, l1Client arbutil.L1Interface, chainConfig *params.ChainConfig) (common.Address, *mocksgen.SequencerInboxStub, common.Address) {
+func setupSequencerInboxStub(ctx context.Context, t *testing.T, l1Info *BlockchainTestInfo, l1Client *ethclient.Client, chainConfig *params.ChainConfig) (common.Address, *mocksgen.SequencerInboxStub, common.Address) {
 	txOpts := l1Info.GetDefaultTransactOpts("deployer", ctx)
 	bridgeAddr, tx, bridge, err := mocksgen.DeployBridgeUnproxied(&txOpts, l1Client)
 	Require(t, err)
diff --git a/system_tests/initialization_test.go b/system_tests/initialization_test.go
index f079740..17e020e 100644
--- a/system_tests/initialization_test.go
+++ b/system_tests/initialization_test.go
@@ -21,6 +21,7 @@ func InitOneContract(prand *testhelpers.PseudoRandomDataSource) (*statetransfer.
 	storageMap := make(map[common.Hash]common.Hash)
 	code := []byte{0x60, 0x0} // PUSH1 0
 	sum := big.NewInt(0)
+	// #nosec G115
 	numCells := int(prand.GetUint64() % 1000)
 	for i := 0; i < numCells; i++ {
 		storageAddr := prand.GetHash()
diff --git a/system_tests/l3_test.go b/system_tests/l3_test.go
new file mode 100644
index 0000000..97eabce
--- /dev/null
+++ b/system_tests/l3_test.go
@@ -0,0 +1,53 @@
+package arbtest
+
+import (
+	"context"
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/offchainlabs/nitro/arbnode"
+)
+
+func TestSimpleL3(t *testing.T) {
+	t.Parallel()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	cleanupL1AndL2 := builder.Build(t)
+	defer cleanupL1AndL2()
+
+	cleanupL3FirstNode := builder.BuildL3OnL2(t)
+	defer cleanupL3FirstNode()
+	firstNodeTestClient := builder.L3
+
+	secondNodeNodeConfig := arbnode.ConfigDefaultL1NonSequencerTest()
+	secondNodeTestClient, cleanupL3SecondNode := builder.Build2ndNodeOnL3(t, &SecondNodeParams{nodeConfig: secondNodeNodeConfig})
+	defer cleanupL3SecondNode()
+
+	accountName := "User2"
+	builder.L3Info.GenerateAccount(accountName)
+	tx := builder.L3Info.PrepareTx("Owner", accountName, builder.L3Info.TransferGas, big.NewInt(1e12), nil)
+
+	err := firstNodeTestClient.Client.SendTransaction(ctx, tx)
+	Require(t, err)
+
+	// Checks that first node has the correct balance
+	_, err = firstNodeTestClient.EnsureTxSucceeded(tx)
+	Require(t, err)
+	l2balance, err := firstNodeTestClient.Client.BalanceAt(ctx, builder.L3Info.GetAddress(accountName), nil)
+	Require(t, err)
+	if l2balance.Cmp(big.NewInt(1e12)) != 0 {
+		t.Fatal("Unexpected balance:", l2balance)
+	}
+
+	// Checks that second node has the correct balance
+	_, err = WaitForTx(ctx, secondNodeTestClient.Client, tx.Hash(), time.Second*15)
+	Require(t, err)
+	l2balance, err = secondNodeTestClient.Client.BalanceAt(ctx, builder.L3Info.GetAddress(accountName), nil)
+	Require(t, err)
+	if l2balance.Cmp(big.NewInt(1e12)) != 0 {
+		t.Fatal("Unexpected balance:", l2balance)
+	}
+}
diff --git a/system_tests/nodeinterface_test.go b/system_tests/nodeinterface_test.go
index 17bfb18..927dc1b 100644
--- a/system_tests/nodeinterface_test.go
+++ b/system_tests/nodeinterface_test.go
@@ -163,6 +163,7 @@ func TestGetL1Confirmations(t *testing.T) {
 
 	numTransactions := 200
 
+	// #nosec G115
 	if l1Confs >= uint64(numTransactions) {
 		t.Fatalf("L1Confirmations for latest block %v is already %v (over %v)", genesisBlock.Number(), l1Confs, numTransactions)
 	}
@@ -175,6 +176,7 @@ func TestGetL1Confirmations(t *testing.T) {
 	Require(t, err)
 
 	// Allow a gap of 10 for asynchronicity, just in case
+	// #nosec G115
 	if l1Confs+10 < uint64(numTransactions) {
 		t.Fatalf("L1Confirmations for latest block %v is only %v (did not hit expected %v)", genesisBlock.Number(), l1Confs, numTransactions)
 	}
diff --git a/system_tests/outbox_test.go b/system_tests/outbox_test.go
index 739d756..25c5239 100644
--- a/system_tests/outbox_test.go
+++ b/system_tests/outbox_test.go
@@ -146,6 +146,7 @@ func TestOutboxProofs(t *testing.T) {
 		treeSize := root.size
 
 		balanced := treeSize == arbmath.NextPowerOf2(treeSize)/2
+		// #nosec G115
 		treeLevels := int(arbmath.Log2ceil(treeSize)) // the # of levels in the tree
 		proofLevels := treeLevels - 1                 // the # of levels where a hash is needed (all but root)
 		walkLevels := treeLevels                      // the # of levels we need to consider when building walks
@@ -174,6 +175,7 @@ func TestOutboxProofs(t *testing.T) {
 				sibling := place ^ which
 
 				position := merkletree.LevelAndLeaf{
+					// #nosec G115
 					Level: uint64(level),
 					Leaf:  sibling,
 				}
@@ -200,6 +202,7 @@ func TestOutboxProofs(t *testing.T) {
 						leaf := total - 1 // preceding it. We subtract 1 since we count from 0
 
 						partial := merkletree.LevelAndLeaf{
+							// #nosec G115
 							Level: uint64(level),
 							Leaf:  leaf,
 						}
@@ -288,6 +291,7 @@ func TestOutboxProofs(t *testing.T) {
 				step.Leaf += 1 << step.Level // we start on the min partial's zero-hash sibling
 				known[step] = zero
 
+				// #nosec G115
 				for step.Level < uint64(treeLevels) {
 
 					curr, ok := known[step]
diff --git a/system_tests/program_recursive_test.go b/system_tests/program_recursive_test.go
index dbf527a..e928f9f 100644
--- a/system_tests/program_recursive_test.go
+++ b/system_tests/program_recursive_test.go
@@ -154,6 +154,7 @@ func testProgramResursiveCalls(t *testing.T, tests [][]multiCallRecurse, jit boo
 	// execute transactions
 	blockNum := uint64(0)
 	for {
+		// #nosec G115
 		item := int(rander.GetUint64()/4) % len(tests)
 		blockNum = testProgramRecursiveCall(t, builder, slotVals, rander, tests[item])
 		tests[item] = tests[len(tests)-1]
diff --git a/system_tests/program_test.go b/system_tests/program_test.go
index ae34c6c..cf8cd72 100644
--- a/system_tests/program_test.go
+++ b/system_tests/program_test.go
@@ -41,23 +41,35 @@ import (
 	"github.com/offchainlabs/nitro/util/colors"
 	"github.com/offchainlabs/nitro/util/testhelpers"
 	"github.com/offchainlabs/nitro/validator/valnode"
-	"github.com/wasmerio/wasmer-go/wasmer"
 )
 
 var oneEth = arbmath.UintToBig(1e18)
 
+var allWasmTargets = []string{string(rawdb.TargetWavm), string(rawdb.TargetArm64), string(rawdb.TargetAmd64), string(rawdb.TargetHost)}
+
 func TestProgramKeccak(t *testing.T) {
 	t.Parallel()
-	keccakTest(t, true)
+	t.Run("WithDefaultWasmTargets", func(t *testing.T) {
+		keccakTest(t, true)
+	})
+
+	t.Run("WithAllWasmTargets", func(t *testing.T) {
+		keccakTest(t, true, func(builder *NodeBuilder) {
+			builder.WithExtraArchs(allWasmTargets)
+		})
+	})
 }
 
-func keccakTest(t *testing.T, jit bool) {
-	builder, auth, cleanup := setupProgramTest(t, jit)
+func keccakTest(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
+	builder, auth, cleanup := setupProgramTest(t, jit, builderOpts...)
 	ctx := builder.ctx
 	l2client := builder.L2.Client
 	defer cleanup()
 	programAddress := deployWasm(t, ctx, auth, l2client, rustFile("keccak"))
 
+	wasmDb := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().StateCache().WasmStore()
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+
 	wasm, _ := readWasmFile(t, rustFile("keccak"))
 	otherAddressSameCode := deployContract(t, ctx, auth, l2client, wasm)
 	arbWasm, err := pgen.NewArbWasm(types.ArbWasmAddress, l2client)
@@ -69,6 +81,7 @@ func keccakTest(t *testing.T, jit bool) {
 			Fatal(t, "activate should have failed with ProgramUpToDate", err)
 		}
 	})
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
 
 	if programAddress == otherAddressSameCode {
 		Fatal(t, "expected to deploy at two separate program addresses")
@@ -142,11 +155,18 @@ func keccakTest(t *testing.T, jit bool) {
 
 func TestProgramActivateTwice(t *testing.T) {
 	t.Parallel()
-	testActivateTwice(t, true)
+	t.Run("WithDefaultWasmTargets", func(t *testing.T) {
+		testActivateTwice(t, true)
+	})
+	t.Run("WithAllWasmTargets", func(t *testing.T) {
+		testActivateTwice(t, true, func(builder *NodeBuilder) {
+			builder.WithExtraArchs(allWasmTargets)
+		})
+	})
 }
 
-func testActivateTwice(t *testing.T, jit bool) {
-	builder, auth, cleanup := setupProgramTest(t, jit)
+func testActivateTwice(t *testing.T, jit bool, builderOpts ...func(*NodeBuilder)) {
+	builder, auth, cleanup := setupProgramTest(t, jit, builderOpts...)
 	ctx := builder.ctx
 	l2info := builder.L2Info
 	l2client := builder.L2.Client
@@ -172,6 +192,10 @@ func testActivateTwice(t *testing.T, jit bool) {
 	colors.PrintBlue("keccak program B deployed to ", keccakB)
 
 	multiAddr := deployWasm(t, ctx, auth, l2client, rustFile("multicall"))
+
+	wasmDb := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().StateCache().WasmStore()
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
+
 	preimage := []byte("it's time to du-du-du-du d-d-d-d-d-d-d de-duplicate")
 
 	keccakArgs := []byte{0x01} // keccak the preimage once
@@ -195,6 +219,7 @@ func testActivateTwice(t *testing.T, jit bool) {
 
 	// Calling the contract pre-activation should fail.
 	checkReverts()
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
 
 	// mechanisms for creating calldata
 	activateProgram, _ := util.NewCallParser(pgen.ArbWasmABI, "activateProgram")
@@ -217,6 +242,7 @@ func testActivateTwice(t *testing.T, jit bool) {
 
 	// Ensure the revert also reverted keccak's activation
 	checkReverts()
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
 
 	// Activate keccak program A, then call into B, which should succeed due to being the same codehash
 	args = argsForMulticall(vm.CALL, types.ArbWasmAddress, oneEth, pack(activateProgram(keccakA)))
@@ -224,6 +250,7 @@ func testActivateTwice(t *testing.T, jit bool) {
 
 	tx = l2info.PrepareTxTo("Owner", &multiAddr, 1e9, oneEth, args)
 	ensure(tx, l2client.SendTransaction(ctx, tx))
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 2)
 
 	validateBlocks(t, 7, jit, builder)
 }
@@ -390,10 +417,15 @@ func storageTest(t *testing.T, jit bool) {
 	key := testhelpers.RandomHash()
 	value := testhelpers.RandomHash()
 	tx := l2info.PrepareTxTo("Owner", &programAddress, l2info.TransferGas, nil, argsForStorageWrite(key, value))
-	ensure(tx, l2client.SendTransaction(ctx, tx))
+	receipt := ensure(tx, l2client.SendTransaction(ctx, tx))
+
 	assertStorageAt(t, ctx, l2client, programAddress, key, value)
 
 	validateBlocks(t, 2, jit, builder)
+
+	// Captures a block_input_<id>.json file for the block that included the
+	// storage write transaction.
+	recordBlock(t, receipt.BlockNumber.Uint64(), builder)
 }
 
 func TestProgramTransientStorage(t *testing.T) {
@@ -583,6 +615,7 @@ func testCalls(t *testing.T, jit bool) {
 
 			for i := 0; i < 2; i++ {
 				inner := nest(level - 1)
+				// #nosec G115
 				args = append(args, arbmath.Uint32ToBytes(uint32(len(inner)))...)
 				args = append(args, inner...)
 			}
@@ -638,6 +671,7 @@ func testCalls(t *testing.T, jit bool) {
 	colors.PrintBlue("Calling the ArbosTest precompile (Rust => precompile)")
 	testPrecompile := func(gas uint64) uint64 {
 		// Call the burnArbGas() precompile from Rust
+		// #nosec G115
 		burn := pack(burnArbGas(big.NewInt(int64(gas))))
 		args := argsForMulticall(vm.CALL, types.ArbosTestAddress, nil, burn)
 		tx := l2info.PrepareTxTo("Owner", &callsAddr, 1e9, nil, args)
@@ -651,6 +685,7 @@ func testCalls(t *testing.T, jit bool) {
 	large := testPrecompile(largeGas)
 
 	if !arbmath.Within(large-small, largeGas-smallGas, 2) {
+		// #nosec G115
 		ratio := float64(int64(large)-int64(small)) / float64(int64(largeGas)-int64(smallGas))
 		Fatal(t, "inconsistent burns", large, small, largeGas, smallGas, ratio)
 	}
@@ -1528,9 +1563,10 @@ func readWasmFile(t *testing.T, file string) ([]byte, []byte) {
 	Require(t, err)
 
 	// chose a random dictionary for testing, but keep the same files consistent
+	// #nosec G115
 	randDict := arbcompress.Dictionary((len(file) + len(t.Name())) % 2)
 
-	wasmSource, err := wasmer.Wat2Wasm(string(source))
+	wasmSource, err := programs.Wat2Wasm(source)
 	Require(t, err)
 	wasm, err := arbcompress.Compress(wasmSource, arbcompress.LEVEL_WELL, randDict)
 	Require(t, err)
@@ -1598,6 +1634,7 @@ func argsForMulticall(opcode vm.OpCode, address common.Address, value *big.Int,
 	if opcode == vm.CALL {
 		length += 32
 	}
+	// #nosec G115
 	args = append(args, arbmath.Uint32ToBytes(uint32(length))...)
 	args = append(args, kinds[opcode])
 	if opcode == vm.CALL {
@@ -1830,7 +1867,9 @@ func createMapFromDb(db ethdb.KeyValueStore) (map[string][]byte, error) {
 }
 
 func TestWasmStoreRebuilding(t *testing.T) {
-	builder, auth, cleanup := setupProgramTest(t, true)
+	builder, auth, cleanup := setupProgramTest(t, true, func(b *NodeBuilder) {
+		b.WithExtraArchs(allWasmTargets)
+	})
 	ctx := builder.ctx
 	l2info := builder.L2Info
 	l2client := builder.L2.Client
@@ -1867,6 +1906,7 @@ func TestWasmStoreRebuilding(t *testing.T) {
 	storeMap, err := createMapFromDb(wasmDb)
 	Require(t, err)
 
+	checkWasmStoreContent(t, wasmDb, builder.execConfig.StylusTarget.ExtraArchs, 1)
 	// close nodeB
 	cleanupB()
 
@@ -1892,7 +1932,8 @@ func TestWasmStoreRebuilding(t *testing.T) {
 
 	// Start rebuilding and wait for it to finish
 	log.Info("starting rebuilding of wasm store")
-	Require(t, gethexec.RebuildWasmStore(ctx, wasmDbAfterDelete, nodeB.ExecNode.ChainDB, nodeB.ExecNode.ConfigFetcher().RPC.MaxRecreateStateDepth, bc, common.Hash{}, bc.CurrentBlock().Hash()))
+	execConfig := nodeB.ExecNode.ConfigFetcher()
+	Require(t, gethexec.RebuildWasmStore(ctx, wasmDbAfterDelete, nodeB.ExecNode.ChainDB, execConfig.RPC.MaxRecreateStateDepth, &execConfig.StylusTarget, bc, common.Hash{}, bc.CurrentBlock().Hash()))
 
 	wasmDbAfterRebuild := nodeB.ExecNode.Backend.ArbInterface().BlockChain().StateCache().WasmStore()
 
@@ -1922,5 +1963,177 @@ func TestWasmStoreRebuilding(t *testing.T) {
 		}
 	}
 
+	checkWasmStoreContent(t, wasmDbAfterRebuild, builder.execConfig.StylusTarget.ExtraArchs, 1)
 	cleanupB()
 }
+
+func readModuleHashes(t *testing.T, wasmDb ethdb.KeyValueStore) []common.Hash {
+	modulesSet := make(map[common.Hash]struct{})
+	asmPrefix := []byte{0x00, 'w'}
+	it := wasmDb.NewIterator(asmPrefix, nil)
+	defer it.Release()
+	for it.Next() {
+		key := it.Key()
+		if len(key) != rawdb.WasmKeyLen {
+			t.Fatalf("unexpected activated module key length, len: %d, key: %v", len(key), key)
+		}
+		moduleHash := key[rawdb.WasmPrefixLen:]
+		if len(moduleHash) != common.HashLength {
+			t.Fatalf("Invalid moduleHash length in key: %v, moduleHash: %v", key, moduleHash)
+		}
+		modulesSet[common.BytesToHash(moduleHash)] = struct{}{}
+	}
+	modules := make([]common.Hash, 0, len(modulesSet))
+	for module := range modulesSet {
+		modules = append(modules, module)
+	}
+	return modules
+}
+
+func checkWasmStoreContent(t *testing.T, wasmDb ethdb.KeyValueStore, targets []string, numModules int) {
+	modules := readModuleHashes(t, wasmDb)
+	if len(modules) != numModules {
+		t.Fatalf("Unexpected number of module hashes found in wasm store, want: %d, have: %d", numModules, len(modules))
+	}
+	for _, module := range modules {
+		for _, target := range targets {
+			wasmTarget := ethdb.WasmTarget(target)
+			if !rawdb.IsSupportedWasmTarget(wasmTarget) {
+				t.Fatalf("internal test error - unsupported target passed to checkWasmStoreContent: %v", target)
+			}
+			func() {
+				defer func() {
+					if r := recover(); r != nil {
+						t.Fatalf("Failed to read activated asm for target: %v, module: %v", target, module)
+					}
+				}()
+				_ = rawdb.ReadActivatedAsm(wasmDb, wasmTarget, module)
+			}()
+		}
+	}
+}
+
+func deployWasmAndGetLruEntrySizeEstimateBytes(
+	t *testing.T,
+	builder *NodeBuilder,
+	auth bind.TransactOpts,
+	wasmName string,
+) (common.Address, uint64) {
+	ctx := builder.ctx
+	l2client := builder.L2.Client
+
+	wasm, _ := readWasmFile(t, rustFile(wasmName))
+	arbWasm, err := pgen.NewArbWasm(types.ArbWasmAddress, l2client)
+	Require(t, err, ", wasmName:", wasmName)
+
+	programAddress := deployContract(t, ctx, auth, l2client, wasm)
+	tx, err := arbWasm.ActivateProgram(&auth, programAddress)
+	Require(t, err, ", wasmName:", wasmName)
+	receipt, err := EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err, ", wasmName:", wasmName)
+
+	if len(receipt.Logs) != 1 {
+		Fatal(t, "expected 1 log while activating, got ", len(receipt.Logs), ", wasmName:", wasmName)
+	}
+	log, err := arbWasm.ParseProgramActivated(*receipt.Logs[0])
+	Require(t, err, ", wasmName:", wasmName)
+
+	statedb, err := builder.L2.ExecNode.Backend.ArbInterface().BlockChain().State()
+	Require(t, err, ", wasmName:", wasmName)
+
+	module, err := statedb.TryGetActivatedAsm(rawdb.LocalTarget(), log.ModuleHash)
+	Require(t, err, ", wasmName:", wasmName)
+
+	lruEntrySizeEstimateBytes := programs.GetLruEntrySizeEstimateBytes(module, log.Version, true)
+	// just a sanity check
+	if lruEntrySizeEstimateBytes == 0 {
+		Fatal(t, "lruEntrySizeEstimateBytes is 0, wasmName:", wasmName)
+	}
+	return programAddress, lruEntrySizeEstimateBytes
+}
+
+func TestWasmLruCache(t *testing.T) {
+	builder, auth, cleanup := setupProgramTest(t, true)
+	ctx := builder.ctx
+	l2info := builder.L2Info
+	l2client := builder.L2.Client
+	defer cleanup()
+
+	auth.GasLimit = 32000000
+	auth.Value = oneEth
+
+	fallibleProgramAddress, fallibleLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "fallible")
+	keccakProgramAddress, keccakLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "keccak")
+	mathProgramAddress, mathLruEntrySizeEstimateBytes := deployWasmAndGetLruEntrySizeEstimateBytes(t, builder, auth, "math")
+	t.Log(
+		"lruEntrySizeEstimateBytes, ",
+		"fallible:", fallibleLruEntrySizeEstimateBytes,
+		"keccak:", keccakLruEntrySizeEstimateBytes,
+		"math:", mathLruEntrySizeEstimateBytes,
+	)
+
+	programs.ClearWasmLruCache()
+	lruMetrics := programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 0 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 0, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != 0 {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", 0, lruMetrics.SizeBytes)
+	}
+
+	programs.SetWasmLruCacheCapacity(fallibleLruEntrySizeEstimateBytes - 1)
+	// fallible wasm program will not be cached since its size is greater than lru cache capacity
+	tx := l2info.PrepareTxTo("Owner", &fallibleProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err := EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 0 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 0, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != 0 {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", 0, lruMetrics.SizeBytes)
+	}
+
+	programs.SetWasmLruCacheCapacity(
+		fallibleLruEntrySizeEstimateBytes + keccakLruEntrySizeEstimateBytes + mathLruEntrySizeEstimateBytes - 1,
+	)
+	// fallible wasm program will be cached
+	tx = l2info.PrepareTxTo("Owner", &fallibleProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 1 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 1, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != fallibleLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", fallibleLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+
+	// keccak wasm program will be cached
+	tx = l2info.PrepareTxTo("Owner", &keccakProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 2 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 2, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != fallibleLruEntrySizeEstimateBytes+keccakLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", fallibleLruEntrySizeEstimateBytes+keccakLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+
+	// math wasm program will be cached, but fallible will be evicted since (fallible + keccak + math) > lruCacheCapacity
+	tx = l2info.PrepareTxTo("Owner", &mathProgramAddress, l2info.TransferGas, nil, []byte{0x01})
+	Require(t, l2client.SendTransaction(ctx, tx))
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err)
+	lruMetrics = programs.GetWasmLruCacheMetrics()
+	if lruMetrics.Count != 2 {
+		t.Fatalf("lruMetrics.Count, expected: %v, actual: %v", 2, lruMetrics.Count)
+	}
+	if lruMetrics.SizeBytes != keccakLruEntrySizeEstimateBytes+mathLruEntrySizeEstimateBytes {
+		t.Fatalf("lruMetrics.SizeBytes, expected: %v, actual: %v", keccakLruEntrySizeEstimateBytes+mathLruEntrySizeEstimateBytes, lruMetrics.SizeBytes)
+	}
+}
diff --git a/system_tests/recreatestate_rpc_test.go b/system_tests/recreatestate_rpc_test.go
index 09d5366..4833d35 100644
--- a/system_tests/recreatestate_rpc_test.go
+++ b/system_tests/recreatestate_rpc_test.go
@@ -95,7 +95,7 @@ func removeStatesFromDb(t *testing.T, bc *core.BlockChain, db ethdb.Database, fr
 func TestRecreateStateForRPCNoDepthLimit(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = arbitrum.InfiniteMaxRecreateStateDepth
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -132,8 +132,9 @@ func TestRecreateStateForRPCNoDepthLimit(t *testing.T) {
 func TestRecreateStateForRPCBigEnoughDepthLimit(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
+	// #nosec G115
 	depthGasLimit := int64(256 * util.NormalizeL2GasForL1GasInitial(800_000, params.GWei))
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = depthGasLimit
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -170,7 +171,7 @@ func TestRecreateStateForRPCBigEnoughDepthLimit(t *testing.T) {
 func TestRecreateStateForRPCDepthLimitExceeded(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = int64(200)
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -207,7 +208,7 @@ func TestRecreateStateForRPCMissingBlockParent(t *testing.T) {
 	var headerCacheLimit uint64 = 512
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = arbitrum.InfiniteMaxRecreateStateDepth
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -255,7 +256,7 @@ func TestRecreateStateForRPCBeyondGenesis(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = arbitrum.InfiniteMaxRecreateStateDepth
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -293,7 +294,7 @@ func TestRecreateStateForRPCBlockNotFoundWhileRecreating(t *testing.T) {
 	var blockCacheLimit uint64 = 256
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = arbitrum.InfiniteMaxRecreateStateDepth
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -341,7 +342,7 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.RPC.MaxRecreateStateDepth = maxRecreateStateDepth
 	execConfig.Sequencer.MaxBlockSpeed = 0
 	execConfig.Sequencer.MaxTxDataSize = 150 // 1 test tx ~= 110
@@ -361,12 +362,14 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 	Require(t, err)
 
 	l2info.GenerateAccount("User2")
+	// #nosec G115
 	for i := genesis; i < uint64(txCount)+genesis; i++ {
 		tx := l2info.PrepareTx("Owner", "User2", l2info.TransferGas, common.Big1, nil)
 		err := client.SendTransaction(ctx, tx)
 		Require(t, err)
 		receipt, err := EnsureTxSucceeded(ctx, client, tx)
 		Require(t, err)
+		// #nosec G115
 		if have, want := receipt.BlockNumber.Uint64(), uint64(i)+1; have != want {
 			Fatal(t, "internal test error - tx got included in unexpected block number, have:", have, "want:", want)
 		}
@@ -377,6 +380,7 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 		Fatal(t, "missing current block")
 	}
 	lastBlock := currentHeader.Number.Uint64()
+	// #nosec G115
 	if want := genesis + uint64(txCount); lastBlock < want {
 		Fatal(t, "internal test error - not enough blocks produced during preparation, want:", want, "have:", lastBlock)
 	}
@@ -390,6 +394,7 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 	bc = builder.L2.ExecNode.Backend.ArbInterface().BlockChain()
 	gas := skipGas
 	blocks := skipBlocks
+	// #nosec G115
 	for i := genesis; i <= genesis+uint64(txCount); i++ {
 		block := bc.GetBlockByNumber(i)
 		if block == nil {
@@ -407,6 +412,7 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 			gas = 0
 			blocks = 0
 		} else {
+			// #nosec G115
 			if int(i) >= int(lastBlock)-int(cacheConfig.BlockCount) {
 				// skipping nonexistence check - the state might have been saved on node shutdown
 				continue
@@ -421,6 +427,7 @@ func testSkippingSavingStateAndRecreatingAfterRestart(t *testing.T, cacheConfig
 			}
 		}
 	}
+	// #nosec G115
 	for i := genesis + 1; i <= genesis+uint64(txCount); i += i % 10 {
 		_, err = client.BalanceAt(ctx, GetTestAddressForAccountName(t, "User2"), new(big.Int).SetUint64(i))
 		if err != nil {
@@ -471,6 +478,7 @@ func TestSkippingSavingStateAndRecreatingAfterRestart(t *testing.T) {
 	for _, skipGas := range skipGasValues {
 		for _, skipBlocks := range skipBlockValues[:len(skipBlockValues)-2] {
 			cacheConfig.MaxAmountOfGasToSkipStateSaving = skipGas
+			// #nosec G115
 			cacheConfig.MaxNumberOfBlocksToSkipStateSaving = uint32(skipBlocks)
 			testSkippingSavingStateAndRecreatingAfterRestart(t, &cacheConfig, 100)
 		}
@@ -480,7 +488,7 @@ func TestSkippingSavingStateAndRecreatingAfterRestart(t *testing.T) {
 func TestGettingStateForRPCFullNode(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.Caching.SnapshotCache = 0 // disable snapshots
 	execConfig.Caching.BlockAge = 0      // use only Caching.BlockCount to keep only last N blocks in dirties cache, no matter how new they are
 	execConfig.Sequencer.MaxBlockSpeed = 0
@@ -495,6 +503,7 @@ func TestGettingStateForRPCFullNode(t *testing.T) {
 	if header == nil {
 		Fatal(t, "failed to get current block header")
 	}
+	// #nosec G115
 	state, _, err := api.StateAndHeaderByNumber(ctx, rpc.BlockNumber(header.Number.Uint64()))
 	Require(t, err)
 	addr := builder.L2Info.GetAddress("User2")
@@ -505,6 +514,7 @@ func TestGettingStateForRPCFullNode(t *testing.T) {
 		Fatal(t, "User2 address does not exist in the state")
 	}
 	// Get the state again to avoid caching
+	// #nosec G115
 	state, _, err = api.StateAndHeaderByNumber(ctx, rpc.BlockNumber(header.Number.Uint64()))
 	Require(t, err)
 
@@ -522,7 +532,7 @@ func TestGettingStateForRPCFullNode(t *testing.T) {
 func TestGettingStateForRPCHybridArchiveNode(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
-	execConfig := ExecConfigDefaultTest()
+	execConfig := ExecConfigDefaultTest(t)
 	execConfig.Caching.Archive = true
 	// For now Archive node should use HashScheme
 	execConfig.Caching.StateScheme = rawdb.HashScheme
@@ -542,6 +552,7 @@ func TestGettingStateForRPCHybridArchiveNode(t *testing.T) {
 	if header == nil {
 		Fatal(t, "failed to get current block header")
 	}
+	// #nosec G115
 	state, _, err := api.StateAndHeaderByNumber(ctx, rpc.BlockNumber(header.Number.Uint64()))
 	Require(t, err)
 	addr := builder.L2Info.GetAddress("User2")
@@ -552,6 +563,7 @@ func TestGettingStateForRPCHybridArchiveNode(t *testing.T) {
 		Fatal(t, "User2 address does not exist in the state")
 	}
 	// Get the state again to avoid caching
+	// #nosec G115
 	state, _, err = api.StateAndHeaderByNumber(ctx, rpc.BlockNumber(header.Number.Uint64()))
 	Require(t, err)
 
diff --git a/system_tests/retryable_test.go b/system_tests/retryable_test.go
index 106dfc6..aa9fbfd 100644
--- a/system_tests/retryable_test.go
+++ b/system_tests/retryable_test.go
@@ -1042,7 +1042,7 @@ func elevateL2Basefee(t *testing.T, ctx context.Context, builder *NodeBuilder) {
 	_, err = precompilesgen.NewArbosTest(common.HexToAddress("0x69"), builder.L2.Client)
 	Require(t, err, "failed to deploy ArbosTest")
 
-	burnAmount := ExecConfigDefaultTest().RPC.RPCGasCap
+	burnAmount := ExecConfigDefaultTest(t).RPC.RPCGasCap
 	burnTarget := uint64(5 * l2pricing.InitialSpeedLimitPerSecondV6 * l2pricing.InitialBacklogTolerance)
 	for i := uint64(0); i < (burnTarget+burnAmount)/burnAmount; i++ {
 		burnArbGas := arbosTestAbi.Methods["burnArbGas"]
diff --git a/system_tests/seq_nonce_test.go b/system_tests/seq_nonce_test.go
index 72629e1..c099563 100644
--- a/system_tests/seq_nonce_test.go
+++ b/system_tests/seq_nonce_test.go
@@ -111,6 +111,7 @@ func TestSequencerNonceTooHighQueueFull(t *testing.T) {
 	}
 
 	for wait := 9; wait >= 0; wait-- {
+		// #nosec G115
 		got := int(completed.Load())
 		expected := count - builder.execConfig.Sequencer.NonceFailureCacheSize
 		if got == expected {
diff --git a/system_tests/seqfeed_test.go b/system_tests/seqfeed_test.go
index 5e70fdf..21f0755 100644
--- a/system_tests/seqfeed_test.go
+++ b/system_tests/seqfeed_test.go
@@ -164,12 +164,12 @@ func compareAllMsgResultsFromConsensusAndExecution(
 	}
 
 	var lastResult *execution.MessageResult
-	for msgCount := 1; arbutil.MessageIndex(msgCount) <= consensusMsgCount; msgCount++ {
+	for msgCount := arbutil.MessageIndex(1); msgCount <= consensusMsgCount; msgCount++ {
 		pos := msgCount - 1
 		resultExec, err := testClient.ExecNode.ResultAtPos(arbutil.MessageIndex(pos))
 		Require(t, err)
 
-		resultConsensus, err := testClient.ConsensusNode.TxStreamer.ResultAtCount(arbutil.MessageIndex(msgCount))
+		resultConsensus, err := testClient.ConsensusNode.TxStreamer.ResultAtCount(msgCount)
 		Require(t, err)
 
 		if !reflect.DeepEqual(resultExec, resultConsensus) {
diff --git a/system_tests/seqinbox_test.go b/system_tests/seqinbox_test.go
index 4dc8f4a..a9f66b0 100644
--- a/system_tests/seqinbox_test.go
+++ b/system_tests/seqinbox_test.go
@@ -229,6 +229,7 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 			reorgTargetNumber := blockStates[reorgTo].l1BlockNumber
 			currentHeader, err := builder.L1.Client.HeaderByNumber(ctx, nil)
 			Require(t, err)
+			// #nosec G115
 			if currentHeader.Number.Int64()-int64(reorgTargetNumber) < 65 {
 				Fatal(t, "Less than 65 blocks of difference between current block", currentHeader.Number, "and target", reorgTargetNumber)
 			}
@@ -264,6 +265,7 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 			for j := 0; j < numMessages; j++ {
 				sourceNum := rand.Int() % len(state.accounts)
 				source := state.accounts[sourceNum]
+				// #nosec G115
 				amount := new(big.Int).SetUint64(uint64(rand.Int()) % state.balances[source].Uint64())
 				reserveAmount := new(big.Int).SetUint64(l2pricing.InitialBaseFeeWei * 100000000)
 				if state.balances[source].Cmp(new(big.Int).Add(amount, reserveAmount)) < 0 {
@@ -313,6 +315,7 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 			for j := 0; ; j++ {
 				haveNonce, err := builder.L1.Client.PendingNonceAt(ctx, seqOpts.From)
 				Require(t, err)
+				// #nosec G115
 				if haveNonce == uint64(seqNonce) {
 					break
 				}
@@ -346,7 +349,7 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 				BridgeAddr:               builder.L1Info.GetAddress("Bridge"),
 				DataPosterAddr:           seqOpts.From,
 				GasRefunderAddr:          gasRefunderAddr,
-				SequencerInboxAccs:       len(blockStates),
+				SequencerInboxAccs:       uint64(len(blockStates)),
 				AfterDelayedMessagesRead: 1,
 			})
 			if diff := diffAccessList(accessed, *wantAL); diff != "" {
@@ -374,10 +377,12 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 				t.Fatalf("BalanceAt(%v) unexpected error: %v", seqOpts.From, err)
 			}
 			txCost := txRes.EffectiveGasPrice.Uint64() * txRes.GasUsed
+			// #nosec G115
 			if diff := before.Int64() - after.Int64(); diff >= int64(txCost) {
 				t.Errorf("Transaction: %v was not refunded, balance diff: %v, cost: %v", tx.Hash(), diff, txCost)
 			}
 
+			// #nosec G115
 			state.l2BlockNumber += uint64(numMessages)
 			state.l1BlockNumber = txRes.BlockNumber.Uint64()
 			blockStates = append(blockStates, state)
@@ -424,11 +429,13 @@ func testSequencerInboxReaderImpl(t *testing.T, validator bool) {
 		}
 
 		for _, state := range blockStates {
+			// #nosec G115
 			block, err := l2Backend.APIBackend().BlockByNumber(ctx, rpc.BlockNumber(state.l2BlockNumber))
 			Require(t, err)
 			if block == nil {
 				Fatal(t, "missing state block", state.l2BlockNumber)
 			}
+			// #nosec G115
 			stateDb, _, err := l2Backend.APIBackend().StateAndHeaderByNumber(ctx, rpc.BlockNumber(state.l2BlockNumber))
 			Require(t, err)
 			for acct, expectedBalance := range state.balances {
diff --git a/system_tests/snap_sync_test.go b/system_tests/snap_sync_test.go
index a04d9f5..7462b5f 100644
--- a/system_tests/snap_sync_test.go
+++ b/system_tests/snap_sync_test.go
@@ -92,8 +92,10 @@ func TestSnapSync(t *testing.T) {
 	waitForBlockToCatchupToMessageCount(ctx, t, nodeC.Client, finalMessageCount)
 	// Fetching message count - 1 instead on the latest block number as the latest block number might not be
 	// present in the snap sync node since it does not have the sequencer feed.
+	// #nosec G115
 	header, err := builder.L2.Client.HeaderByNumber(ctx, big.NewInt(int64(finalMessageCount)-1))
 	Require(t, err)
+	// #nosec G115
 	headerNodeC, err := nodeC.Client.HeaderByNumber(ctx, big.NewInt(int64(finalMessageCount)-1))
 	Require(t, err)
 	// Once the node is synced up, check if the block hash is the same for the last block
diff --git a/system_tests/staker_test.go b/system_tests/staker_test.go
index f57b68a..67ce260 100644
--- a/system_tests/staker_test.go
+++ b/system_tests/staker_test.go
@@ -37,6 +37,7 @@ import (
 	"github.com/offchainlabs/nitro/util"
 	"github.com/offchainlabs/nitro/util/arbmath"
 	"github.com/offchainlabs/nitro/util/colors"
+	"github.com/offchainlabs/nitro/util/testhelpers"
 	"github.com/offchainlabs/nitro/validator/valnode"
 )
 
@@ -57,7 +58,8 @@ func makeBackgroundTxs(ctx context.Context, builder *NodeBuilder) error {
 }
 
 func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool) {
-	t.Parallel()
+	logHandler := testhelpers.InitTestLog(t, log.LvlTrace)
+
 	ctx, cancelCtx := context.WithCancel(context.Background())
 	defer cancelCtx()
 	srv := externalsignertest.NewServer(t)
@@ -132,15 +134,6 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	builder.L1.TransferBalance(t, "Faucet", "ValidatorB", balance, builder.L1Info)
 	l1authB := builder.L1Info.GetDefaultTransactOpts("ValidatorB", ctx)
 
-	valWalletAddrAPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, &l1authA, l2nodeA.L1Reader, true)
-	Require(t, err)
-	valWalletAddrA := *valWalletAddrAPtr
-	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, &l1authA, l2nodeA.L1Reader, true)
-	Require(t, err)
-	if valWalletAddrA == *valWalletAddrCheck {
-		Require(t, err, "didn't cache validator wallet address", valWalletAddrA.String(), "vs", valWalletAddrCheck.String())
-	}
-
 	rollup, err := rollupgen.NewRollupAdminLogic(l2nodeA.DeployInfo.Rollup, builder.L1.Client)
 	Require(t, err)
 
@@ -149,16 +142,9 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	rollupABI, err := abi.JSON(strings.NewReader(rollupgen.RollupAdminLogicABI))
 	Require(t, err, "unable to parse rollup ABI")
 
-	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddrA, l1authB.From, srv.Address}, []bool{true, true, true})
-	Require(t, err, "unable to generate setValidator calldata")
-	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setValidatorCalldata)
-	Require(t, err, "unable to set validators")
-	_, err = builder.L1.EnsureTxSucceeded(tx)
-	Require(t, err)
-
 	setMinAssertPeriodCalldata, err := rollupABI.Pack("setMinimumAssertionPeriod", big.NewInt(1))
 	Require(t, err, "unable to generate setMinimumAssertionPeriod calldata")
-	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setMinAssertPeriodCalldata)
+	tx, err := upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setMinAssertPeriodCalldata)
 	Require(t, err, "unable to set minimum assertion period")
 	_, err = builder.L1.EnsureTxSucceeded(tx)
 	Require(t, err)
@@ -166,7 +152,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	validatorUtils, err := rollupgen.NewValidatorUtils(l2nodeA.DeployInfo.ValidatorUtils, builder.L1.Client)
 	Require(t, err)
 
-	valConfig := staker.TestL1ValidatorConfig
+	valConfigA := staker.TestL1ValidatorConfig
 	parentChainID, err := builder.L1.Client.ChainID(ctx)
 	if err != nil {
 		t.Fatalf("Failed to get parent chain id: %v", err)
@@ -182,14 +168,30 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	if err != nil {
 		t.Fatalf("Error creating validator dataposter: %v", err)
 	}
-	valWalletA, err := validatorwallet.NewContract(dpA, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {}, func() uint64 { return valConfig.ExtraGas })
+	valWalletA, err := validatorwallet.NewContract(dpA, nil, l2nodeA.DeployInfo.ValidatorWalletCreator, l2nodeA.DeployInfo.Rollup, l2nodeA.L1Reader, &l1authA, 0, func(common.Address) {}, func() uint64 { return valConfigA.ExtraGas })
 	Require(t, err)
 	if honestStakerInactive {
-		valConfig.Strategy = "Defensive"
+		valConfigA.Strategy = "Defensive"
 	} else {
-		valConfig.Strategy = "MakeNodes"
+		valConfigA.Strategy = "MakeNodes"
 	}
 
+	valWalletAddrAPtr, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, l2nodeA.L1Reader, true, valWalletA.DataPoster(), valWalletA.GetExtraGas())
+	Require(t, err)
+	valWalletAddrA := *valWalletAddrAPtr
+	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, l2nodeA.DeployInfo.ValidatorWalletCreator, 0, l2nodeA.L1Reader, true, valWalletA.DataPoster(), valWalletA.GetExtraGas())
+	Require(t, err)
+	if valWalletAddrA == *valWalletAddrCheck {
+		Require(t, err, "didn't cache validator wallet address", valWalletAddrA.String(), "vs", valWalletAddrCheck.String())
+	}
+
+	setValidatorCalldata, err := rollupABI.Pack("setValidator", []common.Address{valWalletAddrA, l1authB.From, srv.Address}, []bool{true, true, true})
+	Require(t, err, "unable to generate setValidator calldata")
+	tx, err = upgradeExecutor.ExecuteCall(&deployAuth, l2nodeA.DeployInfo.Rollup, setValidatorCalldata)
+	Require(t, err, "unable to set validators")
+	_, err = builder.L1.EnsureTxSucceeded(tx)
+	Require(t, err)
+
 	_, valStack := createTestValidationNode(t, ctx, &valnode.TestValidationConfig)
 	blockValidatorConfig := staker.TestBlockValidatorConfig
 
@@ -210,7 +212,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 		l2nodeA.L1Reader,
 		valWalletA,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfigA },
 		nil,
 		statelessA,
 		nil,
@@ -244,7 +246,8 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	}
 	valWalletB, err := validatorwallet.NewEOA(dpB, l2nodeB.DeployInfo.Rollup, l2nodeB.L1Reader.Client(), func() uint64 { return 0 })
 	Require(t, err)
-	valConfig.Strategy = "MakeNodes"
+	valConfigB := staker.TestL1ValidatorConfig
+	valConfigB.Strategy = "MakeNodes"
 	statelessB, err := staker.NewStatelessBlockValidator(
 		l2nodeB.InboxReader,
 		l2nodeB.InboxTracker,
@@ -262,7 +265,7 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 		l2nodeB.L1Reader,
 		valWalletB,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfigB },
 		nil,
 		statelessB,
 		nil,
@@ -278,12 +281,13 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 		Require(t, err)
 	}
 	valWalletC := validatorwallet.NewNoOp(builder.L1.Client, l2nodeA.DeployInfo.Rollup)
-	valConfig.Strategy = "Watchtower"
+	valConfigC := staker.TestL1ValidatorConfig
+	valConfigC.Strategy = "Watchtower"
 	stakerC, err := staker.NewStaker(
 		l2nodeA.L1Reader,
 		valWalletC,
 		bind.CallOpts{},
-		valConfig,
+		func() *staker.L1ValidatorConfig { return &valConfigC },
 		nil,
 		statelessA,
 		nil,
@@ -462,8 +466,53 @@ func stakerTestImpl(t *testing.T, faultyStaker bool, honestStakerInactive bool)
 	if !stakerBWasStaked {
 		Fatal(t, "staker B was never staked")
 	}
+
+	if logHandler.WasLogged("data poster expected next transaction to have nonce \\d+ but was requested to post transaction with nonce \\d+") {
+		Fatal(t, "Staker's DataPoster inferred nonce incorrectly")
+	}
 }
 
 func TestStakersCooperative(t *testing.T) {
 	stakerTestImpl(t, false, false)
 }
+
+func TestGetValidatorWalletContractWithDataposterOnlyUsedToCreateValidatorWalletContract(t *testing.T) {
+	t.Parallel()
+
+	ctx, cancelCtx := context.WithCancel(context.Background())
+	defer cancelCtx()
+
+	builder := NewNodeBuilder(ctx).DefaultConfig(t, true)
+	cleanup := builder.Build(t)
+	defer cleanup()
+
+	balance := big.NewInt(params.Ether)
+	balance.Mul(balance, big.NewInt(100))
+	builder.L1Info.GenerateAccount("ValidatorA")
+	builder.L1.TransferBalance(t, "Faucet", "ValidatorA", balance, builder.L1Info)
+	l1auth := builder.L1Info.GetDefaultTransactOpts("ValidatorA", ctx)
+
+	parentChainID, err := builder.L1.Client.ChainID(ctx)
+	Require(t, err)
+
+	dataPoster, err := arbnode.DataposterOnlyUsedToCreateValidatorWalletContract(
+		ctx,
+		builder.L2.ConsensusNode.L1Reader,
+		&l1auth,
+		&builder.nodeConfig.Staker.DataPoster,
+		parentChainID,
+	)
+	if err != nil {
+		log.Crit("error creating data poster to create validator wallet contract", "err", err)
+	}
+	getExtraGas := func() uint64 { return builder.nodeConfig.Staker.ExtraGas }
+
+	valWalletAddrAPtr, err := validatorwallet.GetValidatorWalletContract(ctx, builder.L2.ConsensusNode.DeployInfo.ValidatorWalletCreator, 0, builder.L2.ConsensusNode.L1Reader, true, dataPoster, getExtraGas)
+	Require(t, err)
+	valWalletAddrA := *valWalletAddrAPtr
+	valWalletAddrCheck, err := validatorwallet.GetValidatorWalletContract(ctx, builder.L2.ConsensusNode.DeployInfo.ValidatorWalletCreator, 0, builder.L2.ConsensusNode.L1Reader, true, dataPoster, getExtraGas)
+	Require(t, err)
+	if valWalletAddrA == *valWalletAddrCheck {
+		Require(t, err, "didn't cache validator wallet address", valWalletAddrA.String(), "vs", valWalletAddrCheck.String())
+	}
+}
diff --git a/system_tests/stylus_trace_test.go b/system_tests/stylus_trace_test.go
index cb30387..52039df 100644
--- a/system_tests/stylus_trace_test.go
+++ b/system_tests/stylus_trace_test.go
@@ -6,6 +6,7 @@ package arbtest
 import (
 	"bytes"
 	"encoding/binary"
+	"math"
 	"math/big"
 	"testing"
 
@@ -76,6 +77,7 @@ func sendAndTraceTransaction(
 }
 
 func intToBytes(v int) []byte {
+	// #nosec G115
 	return binary.BigEndian.AppendUint64(nil, uint64(v))
 }
 
@@ -477,3 +479,17 @@ func TestStylusOpcodeTraceEquivalence(t *testing.T) {
 	checkOpcode(t, wasmResult, 12, vm.RETURN, offset, returnLen)
 	checkOpcode(t, evmResult, 5078, vm.RETURN, offset, returnLen)
 }
+
+func TestStylusHugeWriteResultTrace(t *testing.T) {
+	const jit = false
+	builder, auth, cleanup := setupProgramTest(t, jit)
+	ctx := builder.ctx
+	l2client := builder.L2.Client
+	defer cleanup()
+
+	program := deployWasm(t, ctx, auth, l2client, watFile("write-result-len"))
+	const returnLen = math.MaxUint16 + 1
+	args := binary.LittleEndian.AppendUint32(nil, returnLen)
+	result := sendAndTraceTransaction(t, builder, program, nil, args)
+	checkOpcode(t, result, 3, vm.RETURN, nil, intToBe32(returnLen))
+}
diff --git a/system_tests/stylus_tracer_test.go b/system_tests/stylus_tracer_test.go
new file mode 100644
index 0000000..7fda39f
--- /dev/null
+++ b/system_tests/stylus_tracer_test.go
@@ -0,0 +1,244 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+package arbtest
+
+import (
+	"encoding/binary"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/google/go-cmp/cmp"
+	"github.com/offchainlabs/nitro/execution/gethexec"
+	"github.com/offchainlabs/nitro/solgen/go/mocksgen"
+	"github.com/offchainlabs/nitro/util/containers"
+	"github.com/offchainlabs/nitro/util/testhelpers"
+)
+
+func TestStylusTracer(t *testing.T) {
+	const jit = false
+	builder, auth, cleanup := setupProgramTest(t, jit)
+	ctx := builder.ctx
+	l2client := builder.L2.Client
+	l2info := builder.L2Info
+	rpcClient := builder.L2.Client.Client()
+	defer cleanup()
+
+	traceTransaction := func(tx common.Hash, tracer string) []gethexec.HostioTraceInfo {
+		traceOpts := struct {
+			Tracer string `json:"tracer"`
+		}{
+			Tracer: tracer,
+		}
+		var result []gethexec.HostioTraceInfo
+		err := rpcClient.CallContext(ctx, &result, "debug_traceTransaction", tx, traceOpts)
+		Require(t, err, "trace transaction")
+		return result
+	}
+
+	// Deploy contracts
+	stylusMulticall := deployWasm(t, ctx, auth, l2client, rustFile("multicall"))
+	evmMulticall, tx, _, err := mocksgen.DeployMultiCallTest(&auth, builder.L2.Client)
+	Require(t, err, "deploy evm multicall")
+	_, err = EnsureTxSucceeded(ctx, l2client, tx)
+	Require(t, err, "ensure evm multicall deployment")
+
+	// Args for tests
+	key := testhelpers.RandomHash()
+	value := testhelpers.RandomHash()
+	loadStoreArgs := multicallEmptyArgs()
+	loadStoreArgs = multicallAppendStore(loadStoreArgs, key, value, false)
+	loadStoreArgs = multicallAppendLoad(loadStoreArgs, key, false)
+	callArgs := argsForMulticall(vm.CALL, stylusMulticall, nil, []byte{0})
+	evmCall := argsForMulticall(vm.CALL, evmMulticall, nil, []byte{0})
+
+	for _, testCase := range []struct {
+		name     string
+		contract common.Address
+		args     []byte
+		want     []gethexec.HostioTraceInfo
+	}{
+		{
+			name:     "non-recursive hostios",
+			contract: stylusMulticall,
+			args:     loadStoreArgs,
+			want: []gethexec.HostioTraceInfo{
+				{Name: "user_entrypoint", Args: intToBe32(len(loadStoreArgs))},
+				{Name: "pay_for_memory_grow", Args: []byte{0x00, 0x01}},
+				{Name: "read_args", Outs: loadStoreArgs},
+				{Name: "storage_cache_bytes32", Args: append(key.Bytes(), value.Bytes()...)},
+				{Name: "storage_flush_cache", Args: []byte{0x00}},
+				{Name: "storage_load_bytes32", Args: key.Bytes(), Outs: value.Bytes()},
+				{Name: "storage_flush_cache", Args: []byte{0x00}},
+				{Name: "write_result", Args: value.Bytes()},
+				{Name: "user_returned", Outs: intToBe32(0)},
+			},
+		},
+
+		{
+			name:     "call stylus contract",
+			contract: stylusMulticall,
+			args:     callArgs,
+			want: []gethexec.HostioTraceInfo{
+				{Name: "user_entrypoint", Args: intToBe32(len(callArgs))},
+				{Name: "pay_for_memory_grow", Args: []byte{0x00, 0x01}},
+				{Name: "read_args", Outs: callArgs},
+				{
+					Name:    "call_contract",
+					Args:    append(stylusMulticall.Bytes(), common.Hex2Bytes("ffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000")...),
+					Outs:    common.Hex2Bytes("0000000000"),
+					Address: &stylusMulticall,
+					Steps: (*containers.Stack[gethexec.HostioTraceInfo])(&[]gethexec.HostioTraceInfo{
+						{Name: "user_entrypoint", Args: intToBe32(1)},
+						{Name: "pay_for_memory_grow", Args: []byte{0x00, 0x01}},
+						{Name: "read_args", Outs: []byte{0x00}},
+						{Name: "storage_flush_cache", Args: []byte{0x00}},
+						{Name: "write_result"},
+						{Name: "user_returned", Outs: intToBe32(0)},
+					}),
+				},
+				{Name: "storage_flush_cache", Args: []byte{0x00}},
+				{Name: "write_result"},
+				{Name: "user_returned", Outs: intToBe32(0)},
+			},
+		},
+
+		{
+			name:     "call evm contract",
+			contract: stylusMulticall,
+			args:     evmCall,
+			want: []gethexec.HostioTraceInfo{
+				{Name: "user_entrypoint", Args: intToBe32(len(callArgs))},
+				{Name: "pay_for_memory_grow", Args: []byte{0x00, 0x01}},
+				{Name: "read_args", Outs: evmCall},
+				{
+					Name:    "call_contract",
+					Args:    append(evmMulticall.Bytes(), common.Hex2Bytes("ffffffffffffffff000000000000000000000000000000000000000000000000000000000000000000")...),
+					Outs:    common.Hex2Bytes("0000000000"),
+					Address: &evmMulticall,
+					Steps:   containers.NewStack[gethexec.HostioTraceInfo](),
+				},
+				{Name: "storage_flush_cache", Args: []byte{0x00}},
+				{Name: "write_result"},
+				{Name: "user_returned", Outs: intToBe32(0)},
+			},
+		},
+
+		{
+			name:     "evm contract calling wasm",
+			contract: evmMulticall,
+			args:     callArgs,
+			want: []gethexec.HostioTraceInfo{
+				{
+					Name:    "evm_call_contract",
+					Address: &stylusMulticall,
+					Steps: (*containers.Stack[gethexec.HostioTraceInfo])(&[]gethexec.HostioTraceInfo{
+						{Name: "user_entrypoint", Args: intToBe32(1)},
+						{Name: "pay_for_memory_grow", Args: []byte{0x00, 0x01}},
+						{Name: "read_args", Outs: []byte{0x00}},
+						{Name: "storage_flush_cache", Args: []byte{0x00}},
+						{Name: "write_result"},
+						{Name: "user_returned", Outs: intToBe32(0)},
+					}),
+				},
+			},
+		},
+	} {
+		t.Run(testCase.name, func(t *testing.T) {
+			to := testCase.contract
+			tx := l2info.PrepareTxTo("Owner", &to, l2info.TransferGas, nil, testCase.args)
+			err := l2client.SendTransaction(ctx, tx)
+			Require(t, err, "send transaction")
+
+			nativeResult := traceTransaction(tx.Hash(), "stylusTracer")
+			normalizeHostioTrace(nativeResult)
+			if diff := cmp.Diff(testCase.want, nativeResult); diff != "" {
+				Fatal(t, "native tracer don't match wanted result", diff)
+			}
+
+			jsResult := traceTransaction(tx.Hash(), jsStylusTracer)
+			normalizeHostioTrace(jsResult)
+			if diff := cmp.Diff(jsResult, nativeResult); diff != "" {
+				Fatal(t, "native tracer don't match js trace", diff)
+			}
+		})
+	}
+}
+
+func intToBe32(v int) []byte {
+	// #nosec G115
+	return binary.BigEndian.AppendUint32(nil, uint32(v))
+}
+
+// normalize removes the start and end ink values from the trace so we can compare them.
+// In Arbitrum, the gas used by the transaction varies depending on the L1 fees, so the trace
+// returns different gas values and we can't hardcode them.
+func normalizeHostioTrace(trace []gethexec.HostioTraceInfo) {
+	for i := range trace {
+		trace[i].StartInk = 0
+		trace[i].EndInk = 0
+		if len(trace[i].Args) == 0 {
+			trace[i].Args = nil
+		}
+		if len(trace[i].Outs) == 0 {
+			trace[i].Outs = nil
+		}
+		if trace[i].Steps != nil {
+			normalizeHostioTrace(*trace[i].Steps)
+		}
+	}
+}
+
+var jsStylusTracer = `
+{
+    "hostio": function(info) {
+        info.args = toHex(info.args);
+        info.outs = toHex(info.outs);
+        if (this.nests.includes(info.name)) {
+            Object.assign(info, this.open.pop());
+            info.name = info.name.substring(4) // remove evm_
+        }
+        this.open.push(info);
+    },
+    "enter": function(frame) {
+        let inner = [];
+        let name = "";
+        switch (frame.getType()) {
+        case "CALL":
+                name = "evm_call_contract";
+                break;
+        case "DELEGATECALL":
+                name = "evm_delegate_call_contract";
+                break;
+        case "STATICCALL":
+                name = "evm_static_call_contract";
+                break;
+        case "CREATE":
+                name = "evm_create1";
+                break;
+        case "CREATE2":
+                name = "evm_create2";
+                break;
+        case "SELFDESTRUCT":
+                name = "evm_self_destruct";
+                break;
+        }
+        this.open.push({
+            address: toHex(frame.getTo()),
+            steps: inner,
+            name: name,
+        });
+        this.stack.push(this.open); // save where we were
+        this.open = inner;
+    },
+    "exit": function(result) {
+        this.open = this.stack.pop();
+    },
+    "result": function() { return this.open; },
+    "fault":  function() { return this.open; },
+    stack: [],
+    open: [],
+    nests: ["call_contract", "delegate_call_contract", "static_call_contract"]
+}
+`
diff --git a/system_tests/twonodeslong_test.go b/system_tests/twonodeslong_test.go
index 83cd975..60707b8 100644
--- a/system_tests/twonodeslong_test.go
+++ b/system_tests/twonodeslong_test.go
@@ -63,6 +63,7 @@ func testTwoNodesLong(t *testing.T, dasModeStr string) {
 	builder.L2Info.GenerateAccount("ErrorTxSender")
 
 	builder.L2.SendWaitTestTransactions(t, []*types.Transaction{
+		// #nosec G115
 		builder.L2Info.PrepareTx("Faucet", "ErrorTxSender", builder.L2Info.TransferGas, big.NewInt(l2pricing.InitialBaseFeeWei*int64(builder.L2Info.TransferGas)), nil),
 	})
 
diff --git a/system_tests/unsupported_txtypes_test.go b/system_tests/unsupported_txtypes_test.go
index 4c3c866..a228cb2 100644
--- a/system_tests/unsupported_txtypes_test.go
+++ b/system_tests/unsupported_txtypes_test.go
@@ -112,8 +112,8 @@ func TestBlobAndInternalTxsAsDelayedMsgReject(t *testing.T) {
 
 	blocknum, err := builder.L2.Client.BlockNumber(ctx)
 	Require(t, err)
-	for i := int64(0); i <= int64(blocknum); i++ {
-		block, err := builder.L2.Client.BlockByNumber(ctx, big.NewInt(i))
+	for i := uint64(0); i <= blocknum; i++ {
+		block, err := builder.L2.Client.BlockByNumber(ctx, new(big.Int).SetUint64(i))
 		Require(t, err)
 		for _, tx := range block.Transactions() {
 			if _, ok := txAcceptStatus[tx.Hash()]; ok {
diff --git a/system_tests/validation_mock_test.go b/system_tests/validation_mock_test.go
index 2c6321d..912b48e 100644
--- a/system_tests/validation_mock_test.go
+++ b/system_tests/validation_mock_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbnode"
@@ -60,8 +61,8 @@ func (s *mockSpawner) WasmModuleRoots() ([]common.Hash, error) {
 	return mockWasmModuleRoots, nil
 }
 
-func (s *mockSpawner) StylusArchs() []string {
-	return []string{"mock"}
+func (s *mockSpawner) StylusArchs() []ethdb.WasmTarget {
+	return []ethdb.WasmTarget{"mock"}
 }
 
 func (s *mockSpawner) Launch(entry *validator.ValidationInput, moduleRoot common.Hash) validator.ValidationRun {
@@ -95,10 +96,6 @@ func (s *mockSpawner) LatestWasmModuleRoot() containers.PromiseInterface[common.
 	return containers.NewReadyPromise[common.Hash](mockWasmModuleRoots[0], nil)
 }
 
-func (s *mockSpawner) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	return containers.NewReadyPromise[struct{}](struct{}{}, nil)
-}
-
 type mockValRun struct {
 	containers.Promise[validator.GoGlobalState]
 	root common.Hash
diff --git a/system_tests/wrap_transaction_test.go b/system_tests/wrap_transaction_test.go
index bd561ad..36052fb 100644
--- a/system_tests/wrap_transaction_test.go
+++ b/system_tests/wrap_transaction_test.go
@@ -15,6 +15,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -22,7 +23,7 @@ import (
 	"github.com/offchainlabs/nitro/util/headerreader"
 )
 
-func GetPendingBlockNumber(ctx context.Context, client arbutil.L1Interface) (*big.Int, error) {
+func GetPendingBlockNumber(ctx context.Context, client *ethclient.Client) (*big.Int, error) {
 	// Attempt to get the block number from ArbSys, if it exists
 	arbSys, err := precompilesgen.NewArbSys(common.BigToAddress(big.NewInt(100)), client)
 	if err != nil {
@@ -37,7 +38,7 @@ func GetPendingBlockNumber(ctx context.Context, client arbutil.L1Interface) (*bi
 }
 
 // Will wait until txhash is in the blockchain and return its receipt
-func WaitForTx(ctxinput context.Context, client arbutil.L1Interface, txhash common.Hash, timeout time.Duration) (*types.Receipt, error) {
+func WaitForTx(ctxinput context.Context, client *ethclient.Client, txhash common.Hash, timeout time.Duration) (*types.Receipt, error) {
 	ctx, cancel := context.WithTimeout(ctxinput, timeout)
 	defer cancel()
 
@@ -75,11 +76,11 @@ func WaitForTx(ctxinput context.Context, client arbutil.L1Interface, txhash comm
 	}
 }
 
-func EnsureTxSucceeded(ctx context.Context, client arbutil.L1Interface, tx *types.Transaction) (*types.Receipt, error) {
+func EnsureTxSucceeded(ctx context.Context, client *ethclient.Client, tx *types.Transaction) (*types.Receipt, error) {
 	return EnsureTxSucceededWithTimeout(ctx, client, tx, time.Second*5)
 }
 
-func EnsureTxSucceededWithTimeout(ctx context.Context, client arbutil.L1Interface, tx *types.Transaction, timeout time.Duration) (*types.Receipt, error) {
+func EnsureTxSucceededWithTimeout(ctx context.Context, client *ethclient.Client, tx *types.Transaction, timeout time.Duration) (*types.Receipt, error) {
 	receipt, err := WaitForTx(ctx, client, tx.Hash(), timeout)
 	if err != nil {
 		return nil, fmt.Errorf("waitFoxTx (tx=%s) got: %w", tx.Hash().Hex(), err)
@@ -103,12 +104,12 @@ func EnsureTxSucceededWithTimeout(ctx context.Context, client arbutil.L1Interfac
 	return receipt, arbutil.DetailTxError(ctx, client, tx, receipt)
 }
 
-func EnsureTxFailed(t *testing.T, ctx context.Context, client arbutil.L1Interface, tx *types.Transaction) *types.Receipt {
+func EnsureTxFailed(t *testing.T, ctx context.Context, client *ethclient.Client, tx *types.Transaction) *types.Receipt {
 	t.Helper()
 	return EnsureTxFailedWithTimeout(t, ctx, client, tx, time.Second*5)
 }
 
-func EnsureTxFailedWithTimeout(t *testing.T, ctx context.Context, client arbutil.L1Interface, tx *types.Transaction, timeout time.Duration) *types.Receipt {
+func EnsureTxFailedWithTimeout(t *testing.T, ctx context.Context, client *ethclient.Client, tx *types.Transaction, timeout time.Duration) *types.Receipt {
 	t.Helper()
 	receipt, err := WaitForTx(ctx, client, tx.Hash(), timeout)
 	Require(t, err)
diff --git a/util/arbmath/bips.go b/util/arbmath/bips.go
index 8b7c47d..39b014f 100644
--- a/util/arbmath/bips.go
+++ b/util/arbmath/bips.go
@@ -20,36 +20,47 @@ func PercentToBips(percentage int64) Bips {
 }
 
 func BigToBips(natural *big.Int) Bips {
-	return Bips(natural.Uint64())
+	return Bips(natural.Int64())
 }
 
 func BigMulByBips(value *big.Int, bips Bips) *big.Int {
 	return BigMulByFrac(value, int64(bips), int64(OneInBips))
 }
 
+func BigMulByUBips(value *big.Int, bips UBips) *big.Int {
+	return BigMulByUFrac(value, uint64(bips), uint64(OneInUBips))
+}
+
 func IntMulByBips(value int64, bips Bips) int64 {
 	return value * int64(bips) / int64(OneInBips)
 }
 
+// UintMulByBips multiplies a uint value by a bips value
+// bips must be positive and not cause an overflow
 func UintMulByBips(value uint64, bips Bips) uint64 {
+	// #nosec G115
 	return value * uint64(bips) / uint64(OneInBips)
 }
 
-func SaturatingCastToBips(value uint64) Bips {
-	return Bips(SaturatingCast[int64](value))
-}
-
-func (bips UBips) Uint64() uint64 {
-	return uint64(bips)
+// UintSaturatingMulByBips multiplies a uint value by a bips value,
+// saturating at the maximum bips value (not the maximum uint64 result),
+// then rounding down and returning a uint64.
+// Returns 0 if bips is less than or equal to zero
+func UintSaturatingMulByBips(value uint64, bips Bips) uint64 {
+	if bips <= 0 {
+		return 0
+	}
+	// #nosec G115
+	return SaturatingUMul(value, uint64(bips)) / uint64(OneInBips)
 }
 
-func (bips Bips) Uint64() uint64 {
-	return uint64(bips)
+func SaturatingCastToBips(value uint64) Bips {
+	return Bips(SaturatingCast[int64](value))
 }
 
 // BigDivToBips returns dividend/divisor as bips, saturating if out of bounds
 func BigDivToBips(dividend, divisor *big.Int) Bips {
 	value := BigMulByInt(dividend, int64(OneInBips))
 	value.Div(value, divisor)
-	return Bips(BigToUintSaturating(value))
+	return Bips(BigToIntSaturating(value))
 }
diff --git a/util/arbmath/math.go b/util/arbmath/math.go
index 62af1e2..07a9941 100644
--- a/util/arbmath/math.go
+++ b/util/arbmath/math.go
@@ -29,6 +29,7 @@ func NextOrCurrentPowerOf2(value uint64) uint64 {
 
 // Log2ceil the log2 of the int, rounded up
 func Log2ceil(value uint64) uint64 {
+	// #nosec G115
 	return uint64(64 - bits.LeadingZeros64(value))
 }
 
@@ -117,6 +118,18 @@ func BigToUintSaturating(value *big.Int) uint64 {
 	return value.Uint64()
 }
 
+// BigToUintSaturating casts a huge to an int, saturating if out of bounds
+func BigToIntSaturating(value *big.Int) int64 {
+	if !value.IsInt64() {
+		if value.Sign() < 0 {
+			return math.MinInt64
+		} else {
+			return math.MaxInt64
+		}
+	}
+	return value.Int64()
+}
+
 // BigToUintOrPanic casts a huge to a uint, panicking if out of bounds
 func BigToUintOrPanic(value *big.Int) uint64 {
 	if value.Sign() < 0 {
@@ -216,8 +229,8 @@ func BigMulByFrac(value *big.Int, numerator, denominator int64) *big.Int {
 	return value
 }
 
-// BigMulByUfrac multiply a huge by a rational whose components are non-negative
-func BigMulByUfrac(value *big.Int, numerator, denominator uint64) *big.Int {
+// BigMulByUFrac multiply a huge by a rational whose components are non-negative
+func BigMulByUFrac(value *big.Int, numerator, denominator uint64) *big.Int {
 	value = new(big.Int).Set(value)
 	value.Mul(value, new(big.Int).SetUint64(numerator))
 	value.Div(value, new(big.Int).SetUint64(denominator))
@@ -260,10 +273,12 @@ func BigFloatMulByUint(multiplicand *big.Float, multiplier uint64) *big.Float {
 }
 
 func MaxSignedValue[T Signed]() T {
+	// #nosec G115
 	return T((uint64(1) << (8*unsafe.Sizeof(T(0)) - 1)) - 1)
 }
 
 func MinSignedValue[T Signed]() T {
+	// #nosec G115
 	return T(uint64(1) << ((8 * unsafe.Sizeof(T(0))) - 1))
 }
 
@@ -393,6 +408,8 @@ func ApproxExpBasisPoints(value Bips, accuracy uint64) Bips {
 	if negative {
 		input = -value
 	}
+	// This cast is safe because input is always positive
+	// #nosec G115
 	x := uint64(input)
 	bips := uint64(OneInBips)
 
diff --git a/util/arbmath/math_test.go b/util/arbmath/math_test.go
index 1be60dc..3660f36 100644
--- a/util/arbmath/math_test.go
+++ b/util/arbmath/math_test.go
@@ -35,6 +35,7 @@ func TestMath(t *testing.T) {
 		input := rand.Uint64() / 256
 		approx := ApproxSquareRoot(input)
 		correct := math.Sqrt(float64(input))
+		// #nosec G115
 		diff := int(approx) - int(correct)
 		if diff < -1 || diff > 1 {
 			Fail(t, "sqrt approximation off by too much", diff, input, approx, correct)
@@ -43,9 +44,11 @@ func TestMath(t *testing.T) {
 
 	// try the first million sqrts
 	for i := 0; i < 1000000; i++ {
+		// #nosec G115
 		input := uint64(i)
 		approx := ApproxSquareRoot(input)
 		correct := math.Sqrt(float64(input))
+		// #nosec G115
 		diff := int(approx) - int(correct)
 		if diff < 0 || diff > 1 {
 			Fail(t, "sqrt approximation off by too much", diff, input, approx, correct)
@@ -57,6 +60,7 @@ func TestMath(t *testing.T) {
 		input := uint64(1 << i)
 		approx := ApproxSquareRoot(input)
 		correct := math.Sqrt(float64(input))
+		// #nosec G115
 		diff := int(approx) - int(correct)
 		if diff != 0 {
 			Fail(t, "incorrect", "2^", i, diff, approx, correct)
diff --git a/util/arbmath/uint24.go b/util/arbmath/uint24.go
index 818f871..a0c5aa2 100644
--- a/util/arbmath/uint24.go
+++ b/util/arbmath/uint24.go
@@ -9,10 +9,10 @@ import (
 	"math/big"
 )
 
-const MaxUint24 = 1<<24 - 1 // 16777215
-
 type Uint24 uint32
 
+const MaxUint24 = 1<<24 - 1 // 16777215
+
 func (value Uint24) ToBig() *big.Int {
 	return UintToBig(uint64(value))
 }
@@ -26,8 +26,9 @@ func (value Uint24) ToUint64() uint64 {
 }
 
 func IntToUint24[T uint32 | uint64](value T) (Uint24, error) {
+	// #nosec G115
 	if value > T(MaxUint24) {
-		return Uint24(MaxUint24), errors.New("value out of range")
+		return MaxUint24, errors.New("value out of range")
 	}
 	return Uint24(value), nil
 }
@@ -40,6 +41,7 @@ func BigToUint24OrPanic(value *big.Int) Uint24 {
 	if !value.IsUint64() || value.Uint64() > MaxUint24 {
 		panic("big.Int value exceeds the max Uint24")
 	}
+	// #nosec G115
 	return Uint24(value.Uint64())
 }
 
diff --git a/util/blobs/blobs.go b/util/blobs/blobs.go
index 405c776..f5914ed 100644
--- a/util/blobs/blobs.go
+++ b/util/blobs/blobs.go
@@ -41,6 +41,7 @@ func fillBlobBits(blob []byte, data []byte) ([]byte, error) {
 			accBits += 8
 			data = data[1:]
 		}
+		// #nosec G115
 		blob[fieldElement*32] = uint8(acc & ((1 << spareBlobBits) - 1))
 		accBits -= spareBlobBits
 		if accBits < 0 {
@@ -88,6 +89,7 @@ func DecodeBlobs(blobs []kzg4844.Blob) ([]byte, error) {
 			acc |= uint16(blob[fieldIndex*32]) << accBits
 			accBits += spareBlobBits
 			if accBits >= 8 {
+				// #nosec G115
 				rlpData = append(rlpData, uint8(acc))
 				acc >>= 8
 				accBits -= 8
diff --git a/util/containers/stack.go b/util/containers/stack.go
new file mode 100644
index 0000000..ea7f310
--- /dev/null
+++ b/util/containers/stack.go
@@ -0,0 +1,50 @@
+// Copyright 2024, Offchain Labs, Inc.
+// For license information, see https://github.com/OffchainLabs/nitro/blob/master/LICENSE
+
+package containers
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type Stack[T any] []T
+
+func NewStack[T any]() *Stack[T] {
+	return &Stack[T]{}
+}
+
+func (s *Stack[T]) Push(v T) {
+	if s == nil {
+		log.Warn("trying to push nil stack")
+		return
+	}
+	*s = append(*s, v)
+}
+
+func (s *Stack[T]) Pop() (T, error) {
+	if s == nil {
+		var zeroVal T
+		return zeroVal, fmt.Errorf("trying to pop nil stack")
+	}
+	if s.Empty() {
+		var zeroVal T
+		return zeroVal, fmt.Errorf("trying to pop empty stack")
+	}
+	i := len(*s) - 1
+	val := (*s)[i]
+	*s = (*s)[:i]
+	return val, nil
+}
+
+func (s *Stack[T]) Empty() bool {
+	return s == nil || len(*s) == 0
+}
+
+func (s *Stack[T]) Len() int {
+	if s == nil {
+		return 0
+	}
+	return len(*s)
+}
diff --git a/util/dbutil/dbutil.go b/util/dbutil/dbutil.go
index ca0f5aa..6573c57 100644
--- a/util/dbutil/dbutil.go
+++ b/util/dbutil/dbutil.go
@@ -6,7 +6,7 @@ package dbutil
 import (
 	"errors"
 	"fmt"
-	"os"
+	"io/fs"
 	"regexp"
 
 	"github.com/cockroachdb/pebble"
@@ -22,13 +22,15 @@ func IsErrNotFound(err error) bool {
 var pebbleNotExistErrorRegex = regexp.MustCompile("pebble: database .* does not exist")
 
 func isPebbleNotExistError(err error) bool {
-	return pebbleNotExistErrorRegex.MatchString(err.Error())
+	return err != nil && pebbleNotExistErrorRegex.MatchString(err.Error())
 }
 
 func isLeveldbNotExistError(err error) bool {
-	return os.IsNotExist(err)
+	return errors.Is(err, fs.ErrNotExist)
 }
 
+// IsNotExistError returns true if the error is a "database not found" error.
+// It must return false if err is nil.
 func IsNotExistError(err error) bool {
 	return isLeveldbNotExistError(err) || isPebbleNotExistError(err)
 }
diff --git a/util/dbutil/dbutil_test.go b/util/dbutil/dbutil_test.go
index b28f8a2..b303bb5 100644
--- a/util/dbutil/dbutil_test.go
+++ b/util/dbutil/dbutil_test.go
@@ -28,6 +28,9 @@ func testIsNotExistError(t *testing.T, dbEngine string, isNotExist func(error) b
 	if isNotExist(err) {
 		t.Fatalf("Classified other error as not exist, err: %v", err)
 	}
+	if isNotExist(nil) {
+		t.Fatal("Classified nil as not exist")
+	}
 }
 
 func TestIsNotExistError(t *testing.T) {
diff --git a/util/headerreader/blob_client.go b/util/headerreader/blob_client.go
index 2b47a94..4831994 100644
--- a/util/headerreader/blob_client.go
+++ b/util/headerreader/blob_client.go
@@ -18,8 +18,8 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
-	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/util/blobs"
 	"github.com/offchainlabs/nitro/util/jsonapi"
 	"github.com/offchainlabs/nitro/util/pretty"
@@ -28,7 +28,7 @@ import (
 )
 
 type BlobClient struct {
-	ec                 arbutil.L1Interface
+	ec                 *ethclient.Client
 	beaconUrl          *url.URL
 	secondaryBeaconUrl *url.URL
 	httpClient         *http.Client
@@ -63,7 +63,7 @@ func BlobClientAddOptions(prefix string, f *pflag.FlagSet) {
 	f.String(prefix+".authorization", DefaultBlobClientConfig.Authorization, "Value to send with the HTTP Authorization: header for Beacon REST requests, must include both scheme and scheme parameters")
 }
 
-func NewBlobClient(config BlobClientConfig, ec arbutil.L1Interface) (*BlobClient, error) {
+func NewBlobClient(config BlobClientConfig, ec *ethclient.Client) (*BlobClient, error) {
 	beaconUrl, err := url.Parse(config.BeaconUrl)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse beacon chain URL: %w", err)
@@ -191,6 +191,7 @@ func (b *BlobClient) blobSidecars(ctx context.Context, slot uint64, versionedHas
 	rawData, err := beaconRequest[json.RawMessage](b, ctx, fmt.Sprintf("/eth/v1/beacon/blob_sidecars/%d", slot))
 	if err != nil || len(rawData) == 0 {
 		// blobs are pruned after 4096 epochs (1 epoch = 32 slots), we determine if the requested slot were to be pruned by a non-archive endpoint
+		// #nosec G115
 		roughAgeOfSlot := uint64(time.Now().Unix()) - (b.genesisTime + slot*b.secondsPerSlot)
 		if roughAgeOfSlot > b.secondsPerSlot*32*4096 {
 			return nil, fmt.Errorf("beacon client in blobSidecars got error or empty response fetching older blobs in slot: %d, an archive endpoint is required, please refer to https://docs.arbitrum.io/run-arbitrum-node/l1-ethereum-beacon-chain-rpc-providers, err: %w", slot, err)
diff --git a/util/headerreader/header_reader.go b/util/headerreader/header_reader.go
index 074d243..98f778d 100644
--- a/util/headerreader/header_reader.go
+++ b/util/headerreader/header_reader.go
@@ -16,6 +16,7 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/offchainlabs/nitro/arbutil"
@@ -33,7 +34,7 @@ type ArbSysInterface interface {
 type HeaderReader struct {
 	stopwaiter.StopWaiter
 	config                ConfigFetcher
-	client                arbutil.L1Interface
+	client                *ethclient.Client
 	isParentChainArbitrum bool
 	arbSys                ArbSysInterface
 
@@ -120,7 +121,7 @@ var TestConfig = Config{
 	},
 }
 
-func New(ctx context.Context, client arbutil.L1Interface, config ConfigFetcher, arbSysPrecompile ArbSysInterface) (*HeaderReader, error) {
+func New(ctx context.Context, client *ethclient.Client, config ConfigFetcher, arbSysPrecompile ArbSysInterface) (*HeaderReader, error) {
 	isParentChainArbitrum := false
 	var arbSys ArbSysInterface
 	if arbSysPrecompile != nil {
@@ -340,6 +341,7 @@ func (s *HeaderReader) logIfHeaderIsOld() {
 	if storedHeader == nil {
 		return
 	}
+	// #nosec G115
 	l1Timetamp := time.Unix(int64(storedHeader.Time), 0)
 	headerTime := time.Since(l1Timetamp)
 	if headerTime >= s.config().OldHeaderTimeout {
@@ -521,7 +523,7 @@ func (s *HeaderReader) LatestFinalizedBlockNr(ctx context.Context) (uint64, erro
 	return header.Number.Uint64(), nil
 }
 
-func (s *HeaderReader) Client() arbutil.L1Interface {
+func (s *HeaderReader) Client() *ethclient.Client {
 	return s.client
 }
 
diff --git a/util/merkletree/merkleEventProof_test.go b/util/merkletree/merkleEventProof_test.go
index b64cc88..6af8479 100644
--- a/util/merkletree/merkleEventProof_test.go
+++ b/util/merkletree/merkleEventProof_test.go
@@ -22,6 +22,7 @@ func initializedMerkleAccumulatorForTesting() *merkleAccumulator.MerkleAccumulat
 func TestProofForNext(t *testing.T) {
 	leaves := make([]common.Hash, 13)
 	for i := range leaves {
+		// #nosec G115
 		leaves[i] = pseudorandomForTesting(uint64(i))
 	}
 
diff --git a/util/merkletree/merkleTree.go b/util/merkletree/merkleTree.go
index 1b15d51..fffa9bc 100644
--- a/util/merkletree/merkleTree.go
+++ b/util/merkletree/merkleTree.go
@@ -43,8 +43,8 @@ func NewLevelAndLeaf(level, leaf uint64) LevelAndLeaf {
 
 func (place LevelAndLeaf) ToBigInt() *big.Int {
 	return new(big.Int).Add(
-		new(big.Int).Lsh(big.NewInt(int64(place.Level)), 192),
-		big.NewInt(int64(place.Leaf)),
+		new(big.Int).Lsh(new(big.Int).SetUint64(place.Level), 192),
+		new(big.Int).SetUint64(place.Leaf),
 	)
 }
 
diff --git a/util/rpcclient/rpcclient.go b/util/rpcclient/rpcclient.go
index be5825a..a35d4b6 100644
--- a/util/rpcclient/rpcclient.go
+++ b/util/rpcclient/rpcclient.go
@@ -101,7 +101,7 @@ func (c *RpcClient) Close() {
 }
 
 type limitedMarshal struct {
-	limit int
+	limit uint
 	value any
 }
 
@@ -113,16 +113,18 @@ func (m limitedMarshal) String() string {
 	} else {
 		str = string(marshalled)
 	}
-	if m.limit == 0 || len(str) <= m.limit {
+	// #nosec G115
+	limit := int(m.limit)
+	if m.limit <= 0 || len(str) <= limit {
 		return str
 	}
 	prefix := str[:m.limit/2-1]
-	postfix := str[len(str)-m.limit/2+1:]
+	postfix := str[len(str)-limit/2+1:]
 	return fmt.Sprintf("%v..%v", prefix, postfix)
 }
 
 type limitedArgumentsMarshal struct {
-	limit int
+	limit uint
 	args  []any
 }
 
@@ -162,9 +164,9 @@ func (c *RpcClient) CallContext(ctx_in context.Context, result interface{}, meth
 		return errors.New("not connected")
 	}
 	logId := c.logId.Add(1)
-	log.Trace("sending RPC request", "method", method, "logId", logId, "args", limitedArgumentsMarshal{int(c.config().ArgLogLimit), args})
+	log.Trace("sending RPC request", "method", method, "logId", logId, "args", limitedArgumentsMarshal{c.config().ArgLogLimit, args})
 	var err error
-	for i := 0; i < int(c.config().Retries)+1; i++ {
+	for i := uint(0); i < c.config().Retries+1; i++ {
 		retryDelay := c.config().RetryDelay
 		if i > 0 && retryDelay > 0 {
 			select {
@@ -188,7 +190,7 @@ func (c *RpcClient) CallContext(ctx_in context.Context, result interface{}, meth
 
 		cancelCtx()
 		logger := log.Trace
-		limit := int(c.config().ArgLogLimit)
+		limit := c.config().ArgLogLimit
 		if err != nil && !IsAlreadyKnownError(err) {
 			logger = log.Info
 		}
diff --git a/util/sharedmetrics/sharedmetrics.go b/util/sharedmetrics/sharedmetrics.go
index 377eef5..9b4b360 100644
--- a/util/sharedmetrics/sharedmetrics.go
+++ b/util/sharedmetrics/sharedmetrics.go
@@ -11,8 +11,10 @@ var (
 )
 
 func UpdateSequenceNumberGauge(sequenceNumber arbutil.MessageIndex) {
+	// #nosec G115
 	latestSequenceNumberGauge.Update(int64(sequenceNumber))
 }
 func UpdateSequenceNumberInBlockGauge(sequenceNumber arbutil.MessageIndex) {
+	// #nosec G115
 	sequenceNumberInBlockGauge.Update(int64(sequenceNumber))
 }
diff --git a/util/testhelpers/testhelpers.go b/util/testhelpers/testhelpers.go
index b1b0870..d681b42 100644
--- a/util/testhelpers/testhelpers.go
+++ b/util/testhelpers/testhelpers.go
@@ -65,6 +65,7 @@ func RandomCallValue(limit int64) *big.Int {
 
 // Computes a psuedo-random uint64 on the interval [min, max]
 func RandomUint32(min, max uint32) uint32 {
+	//#nosec G115
 	return uint32(RandomUint64(uint64(min), uint64(max)))
 }
 
diff --git a/validator/client/redis/producer.go b/validator/client/redis/producer.go
index b3ad0f8..adc2f34 100644
--- a/validator/client/redis/producer.go
+++ b/validator/client/redis/producer.go
@@ -6,6 +6,8 @@ import (
 	"sync/atomic"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-redis/redis/v8"
 	"github.com/offchainlabs/nitro/pubsub"
@@ -32,11 +34,20 @@ func (c ValidationClientConfig) Enabled() bool {
 	return c.RedisURL != ""
 }
 
+func (c ValidationClientConfig) Validate() error {
+	for _, arch := range c.StylusArchs {
+		if !rawdb.IsSupportedWasmTarget(ethdb.WasmTarget(arch)) {
+			return fmt.Errorf("Invalid stylus arch: %v", arch)
+		}
+	}
+	return nil
+}
+
 var DefaultValidationClientConfig = ValidationClientConfig{
 	Name:           "redis validation client",
 	Room:           2,
 	RedisURL:       "",
-	StylusArchs:    []string{"wavm"},
+	StylusArchs:    []string{string(rawdb.TargetWavm)},
 	ProducerConfig: pubsub.DefaultProducerConfig,
 	CreateStreams:  true,
 }
@@ -46,7 +57,7 @@ var TestValidationClientConfig = ValidationClientConfig{
 	Room:           2,
 	RedisURL:       "",
 	StreamPrefix:   "test-",
-	StylusArchs:    []string{"wavm"},
+	StylusArchs:    []string{string(rawdb.TargetWavm)},
 	ProducerConfig: pubsub.TestProducerConfig,
 	CreateStreams:  false,
 }
@@ -152,8 +163,12 @@ func (c *ValidationClient) Name() string {
 	return c.config.Name
 }
 
-func (c *ValidationClient) StylusArchs() []string {
-	return c.config.StylusArchs
+func (c *ValidationClient) StylusArchs() []ethdb.WasmTarget {
+	stylusArchs := make([]ethdb.WasmTarget, 0, len(c.config.StylusArchs))
+	for _, arch := range c.config.StylusArchs {
+		stylusArchs = append(stylusArchs, ethdb.WasmTarget(arch))
+	}
+	return stylusArchs
 }
 
 func (c *ValidationClient) Room() int {
diff --git a/validator/client/validation_client.go b/validator/client/validation_client.go
index 05d947d..934362f 100644
--- a/validator/client/validation_client.go
+++ b/validator/client/validation_client.go
@@ -8,7 +8,6 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	"runtime"
 	"sync/atomic"
 	"time"
 
@@ -22,6 +21,8 @@ import (
 	"github.com/offchainlabs/nitro/validator/server_common"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/node"
 	"github.com/ethereum/go-ethereum/rpc"
@@ -31,7 +32,7 @@ type ValidationClient struct {
 	stopwaiter.StopWaiter
 	client          *rpcclient.RpcClient
 	name            string
-	stylusArchs     []string
+	stylusArchs     []ethdb.WasmTarget
 	room            atomic.Int32
 	wasmModuleRoots []common.Hash
 }
@@ -40,7 +41,7 @@ func NewValidationClient(config rpcclient.ClientConfigFetcher, stack *node.Node)
 	return &ValidationClient{
 		client:      rpcclient.NewRpcClient(config, stack),
 		name:        "not started",
-		stylusArchs: []string{"not started"},
+		stylusArchs: []ethdb.WasmTarget{"not started"},
 	}
 }
 
@@ -67,20 +68,20 @@ func (c *ValidationClient) Start(ctx context.Context) error {
 	if len(name) == 0 {
 		return errors.New("couldn't read name from server")
 	}
-	var stylusArchs []string
+	var stylusArchs []ethdb.WasmTarget
 	if err := c.client.CallContext(ctx, &stylusArchs, server_api.Namespace+"_stylusArchs"); err != nil {
 		var rpcError rpc.Error
 		ok := errors.As(err, &rpcError)
 		if !ok || rpcError.ErrorCode() != -32601 {
 			return fmt.Errorf("could not read stylus arch from server: %w", err)
 		}
-		stylusArchs = []string{"pre-stylus"} // validation does not support stylus
+		stylusArchs = []ethdb.WasmTarget{ethdb.WasmTarget("pre-stylus")} // invalid, will fail if trying to validate block with stylus
 	} else {
 		if len(stylusArchs) == 0 {
 			return fmt.Errorf("could not read stylus archs from validation server")
 		}
 		for _, stylusArch := range stylusArchs {
-			if stylusArch != "wavm" && stylusArch != runtime.GOARCH && stylusArch != "mock" {
+			if !rawdb.IsSupportedWasmTarget(ethdb.WasmTarget(stylusArch)) && stylusArch != "mock" {
 				return fmt.Errorf("unsupported stylus architecture: %v", stylusArch)
 			}
 		}
@@ -102,6 +103,7 @@ func (c *ValidationClient) Start(ctx context.Context) error {
 	} else {
 		log.Info("connected to validation server", "name", name, "room", room)
 	}
+	// #nosec G115
 	c.room.Store(int32(room))
 	c.wasmModuleRoots = moduleRoots
 	c.name = name
@@ -117,11 +119,11 @@ func (c *ValidationClient) WasmModuleRoots() ([]common.Hash, error) {
 	return nil, errors.New("not started")
 }
 
-func (c *ValidationClient) StylusArchs() []string {
+func (c *ValidationClient) StylusArchs() []ethdb.WasmTarget {
 	if c.Started() {
 		return c.stylusArchs
 	}
-	return []string{"not started"}
+	return []ethdb.WasmTarget{"not started"}
 }
 
 func (c *ValidationClient) Stop() {
@@ -186,19 +188,6 @@ func (c *ExecutionClient) LatestWasmModuleRoot() containers.PromiseInterface[com
 	})
 }
 
-func (c *ExecutionClient) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	jsonInput := server_api.ValidationInputToJson(input)
-	if err := jsonInput.WriteToFile(); err != nil {
-		return stopwaiter.LaunchPromiseThread[struct{}](c, func(ctx context.Context) (struct{}, error) {
-			return struct{}{}, err
-		})
-	}
-	return stopwaiter.LaunchPromiseThread[struct{}](c, func(ctx context.Context) (struct{}, error) {
-		err := c.client.CallContext(ctx, nil, server_api.Namespace+"_writeToFile", jsonInput, expOut, moduleRoot)
-		return struct{}{}, err
-	})
-}
-
 func (r *ExecutionClientRun) SendKeepAlive(ctx context.Context) time.Duration {
 	err := r.client.client.CallContext(ctx, nil, server_api.Namespace+"_execKeepAlive", r.id)
 	if err != nil {
diff --git a/validator/inputs/writer.go b/validator/inputs/writer.go
new file mode 100644
index 0000000..a45e584
--- /dev/null
+++ b/validator/inputs/writer.go
@@ -0,0 +1,141 @@
+package inputs
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/offchainlabs/nitro/validator/server_api"
+)
+
+// Writer is a configurable writer of InputJSON files.
+//
+// The default Writer will write to a path like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+//
+// The path can be nested under a slug directory so callers can provide a
+// recognizable name to differentiate various contexts in which the InputJSON
+// is being written. If the Writer is configured by calling SetSlug, then the
+// path will be like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+//
+// The inclusion of a timestamp directory is on by default to avoid conflicts which
+// would result in files being overwritten. However, the Writer can be configured
+// to not use a timestamp directory.  If the Writer is configured by calling
+// SetUseTimestampDir(false), then the path will be like:
+//
+//	$HOME/.arbuitrum/validation-inputs/<slug>/block_inputs_<id>.json
+//
+// Finally, to give complete control to the clients, the base directory can be
+// set directly with SetBaseDir. In which case, the path will be like:
+//
+//	<baseDir>/block_inputs_<id>.json
+//	  or
+//	<baseDir>/<slug>/block_inputs_<id>.json
+//	  or
+//	<baseDir>/<slug>/<YYYMMDD_HHMMSS>/block_inputs_<id>.json
+type Writer struct {
+	clock           Clock
+	baseDir         string
+	slug            string
+	useTimestampDir bool
+}
+
+// WriterOption is a function that configures a Writer.
+type WriterOption func(*Writer)
+
+// Clock is an interface for getting the current time.
+type Clock interface {
+	Now() time.Time
+}
+
+type realClock struct{}
+
+func (realClock) Now() time.Time {
+	return time.Now()
+}
+
+// NewWriter creates a new Writer with default settings.
+func NewWriter(options ...WriterOption) (*Writer, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return nil, err
+	}
+	baseDir := filepath.Join(homeDir, ".arbitrum", "validation-inputs")
+	w := &Writer{
+		clock:           realClock{},
+		baseDir:         baseDir,
+		slug:            "",
+		useTimestampDir: true,
+	}
+	for _, o := range options {
+		o(w)
+	}
+	return w, nil
+}
+
+// withTestClock configures the Writer to use the given clock.
+//
+// This is only intended for testing.
+func withTestClock(clock Clock) WriterOption {
+	return func(w *Writer) {
+		w.clock = clock
+	}
+}
+
+// WithSlug configures the Writer to use the given slug as a directory name.
+func WithSlug(slug string) WriterOption {
+	return func(w *Writer) {
+		w.slug = slug
+	}
+}
+
+// WithoutSlug clears the slug configuration.
+//
+// This is equivalent to the WithSlug("") option but is more readable.
+func WithoutSlug() WriterOption {
+	return WithSlug("")
+}
+
+// WithBaseDir configures the Writer to use the given base directory.
+func WithBaseDir(baseDir string) WriterOption {
+	return func(w *Writer) {
+		w.baseDir = baseDir
+	}
+}
+
+// WithTimestampDirEnabled controls the addition of a timestamp directory.
+func WithTimestampDirEnabled(useTimestampDir bool) WriterOption {
+	return func(w *Writer) {
+		w.useTimestampDir = useTimestampDir
+	}
+}
+
+// Write writes the given InputJSON to a file in JSON format.
+func (w *Writer) Write(json *server_api.InputJSON) error {
+	dir := w.baseDir
+	if w.slug != "" {
+		dir = filepath.Join(dir, w.slug)
+	}
+	if w.useTimestampDir {
+		t := w.clock.Now()
+		tStr := t.Format("20060102_150405")
+		dir = filepath.Join(dir, tStr)
+	}
+	if err := os.MkdirAll(dir, 0700); err != nil {
+		return err
+	}
+	contents, err := json.Marshal()
+	if err != nil {
+		return err
+	}
+	if err = os.WriteFile(
+		filepath.Join(dir, fmt.Sprintf("block_inputs_%d.json", json.Id)),
+		contents, 0600); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/validator/inputs/writer_test.go b/validator/inputs/writer_test.go
new file mode 100644
index 0000000..59cb63d
--- /dev/null
+++ b/validator/inputs/writer_test.go
@@ -0,0 +1,92 @@
+package inputs
+
+import (
+	"os"
+	"testing"
+	"time"
+
+	"github.com/offchainlabs/nitro/validator/server_api"
+)
+
+func TestDefaultBaseDir(t *testing.T) {
+	// Simply testing that the default baseDir is set relative to the user's home directory.
+	// This way, the other tests can all override the baseDir to a temporary directory.
+	w, err := NewWriter()
+	if err != nil {
+		t.Fatal(err)
+	}
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if w.baseDir != homeDir+"/.arbitrum/validation-inputs" {
+		t.Errorf("unexpected baseDir: %v", w.baseDir)
+	}
+}
+
+type fakeClock struct {
+	now time.Time
+}
+
+func (c fakeClock) Now() time.Time {
+	return c.now
+}
+
+func TestWriting(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/20210102_030405/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestWritingWithSlug(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+		WithSlug("foo"),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/foo/20210102_030405/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestWritingWithoutTimestampDir(t *testing.T) {
+	dir := t.TempDir()
+	w, err := NewWriter(
+		withTestClock(fakeClock{now: time.Date(2021, 1, 2, 3, 4, 5, 0, time.UTC)}),
+		WithBaseDir(dir),
+		WithTimestampDirEnabled(false),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = w.Write(&server_api.InputJSON{Id: 24601})
+	if err != nil {
+		t.Fatal(err)
+	}
+	// The file should exist.
+	if _, err := os.Stat(dir + "/block_inputs_24601.json"); err != nil {
+		t.Error(err)
+	}
+}
diff --git a/validator/interface.go b/validator/interface.go
index 80aa2c1..9fb831c 100644
--- a/validator/interface.go
+++ b/validator/interface.go
@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/util/containers"
 )
 
@@ -13,7 +14,7 @@ type ValidationSpawner interface {
 	Start(context.Context) error
 	Stop()
 	Name() string
-	StylusArchs() []string
+	StylusArchs() []ethdb.WasmTarget
 	Room() int
 }
 
@@ -26,7 +27,6 @@ type ExecutionSpawner interface {
 	ValidationSpawner
 	CreateExecutionRun(wasmModuleRoot common.Hash, input *ValidationInput) containers.PromiseInterface[ExecutionRun]
 	LatestWasmModuleRoot() containers.PromiseInterface[common.Hash]
-	WriteToFile(input *ValidationInput, expOut GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}]
 }
 
 type ExecutionRun interface {
diff --git a/validator/server_api/json.go b/validator/server_api/json.go
index 90746e4..8dfbc84 100644
--- a/validator/server_api/json.go
+++ b/validator/server_api/json.go
@@ -8,9 +8,9 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/arbcompress"
 	"github.com/offchainlabs/nitro/arbutil"
 
@@ -63,19 +63,13 @@ type InputJSON struct {
 	BatchInfo     []BatchInfoJson
 	DelayedMsgB64 string
 	StartState    validator.GoGlobalState
-	UserWasms     map[string]map[common.Hash]string
+	UserWasms     map[ethdb.WasmTarget]map[common.Hash]string
 	DebugChain    bool
 }
 
-func (i *InputJSON) WriteToFile() error {
-	contents, err := json.MarshalIndent(i, "", "    ")
-	if err != nil {
-		return err
-	}
-	if err = os.WriteFile(fmt.Sprintf("block_inputs_%d.json", i.Id), contents, 0600); err != nil {
-		return err
-	}
-	return nil
+// Marshal returns the JSON encoding of the InputJSON.
+func (i *InputJSON) Marshal() ([]byte, error) {
+	return json.MarshalIndent(i, "", "    ")
 }
 
 type BatchInfoJson struct {
@@ -95,14 +89,14 @@ func ValidationInputToJson(entry *validator.ValidationInput) *InputJSON {
 		DelayedMsgB64: base64.StdEncoding.EncodeToString(entry.DelayedMsg),
 		StartState:    entry.StartState,
 		PreimagesB64:  jsonPreimagesMap,
-		UserWasms:     make(map[string]map[common.Hash]string),
+		UserWasms:     make(map[ethdb.WasmTarget]map[common.Hash]string),
 		DebugChain:    entry.DebugChain,
 	}
 	for _, binfo := range entry.BatchInfo {
 		encData := base64.StdEncoding.EncodeToString(binfo.Data)
 		res.BatchInfo = append(res.BatchInfo, BatchInfoJson{Number: binfo.Number, DataB64: encData})
 	}
-	for arch, wasms := range entry.UserWasms {
+	for target, wasms := range entry.UserWasms {
 		archWasms := make(map[common.Hash]string)
 		for moduleHash, data := range wasms {
 			compressed, err := arbcompress.CompressLevel(data, 1)
@@ -111,7 +105,7 @@ func ValidationInputToJson(entry *validator.ValidationInput) *InputJSON {
 			}
 			archWasms[moduleHash] = base64.StdEncoding.EncodeToString(compressed)
 		}
-		res.UserWasms[arch] = archWasms
+		res.UserWasms[target] = archWasms
 	}
 	return res
 }
@@ -127,7 +121,7 @@ func ValidationInputFromJson(entry *InputJSON) (*validator.ValidationInput, erro
 		DelayedMsgNr:  entry.DelayedMsgNr,
 		StartState:    entry.StartState,
 		Preimages:     preimages,
-		UserWasms:     make(map[string]map[common.Hash][]byte),
+		UserWasms:     make(map[ethdb.WasmTarget]map[common.Hash][]byte),
 		DebugChain:    entry.DebugChain,
 	}
 	delayed, err := base64.StdEncoding.DecodeString(entry.DelayedMsgB64)
@@ -146,7 +140,7 @@ func ValidationInputFromJson(entry *InputJSON) (*validator.ValidationInput, erro
 		}
 		valInput.BatchInfo = append(valInput.BatchInfo, decInfo)
 	}
-	for arch, wasms := range entry.UserWasms {
+	for target, wasms := range entry.UserWasms {
 		archWasms := make(map[common.Hash][]byte)
 		for moduleHash, encoded := range wasms {
 			decoded, err := base64.StdEncoding.DecodeString(encoded)
@@ -171,7 +165,7 @@ func ValidationInputFromJson(entry *InputJSON) (*validator.ValidationInput, erro
 			}
 			archWasms[moduleHash] = uncompressed
 		}
-		valInput.UserWasms[arch] = archWasms
+		valInput.UserWasms[target] = archWasms
 	}
 	return valInput, nil
 }
diff --git a/validator/server_arb/execution_run_test.go b/validator/server_arb/execution_run_test.go
index bdc1eef..479db58 100644
--- a/validator/server_arb/execution_run_test.go
+++ b/validator/server_arb/execution_run_test.go
@@ -194,7 +194,7 @@ func Test_machineHashesWithStep(t *testing.T) {
 			Batch:      1,
 			PosInBatch: mm.totalSteps - 1,
 		}))
-		if len(hashes) >= int(maxIterations) {
+		if uint64(len(hashes)) >= maxIterations {
 			t.Fatal("Wanted fewer hashes than the max iterations")
 		}
 		for i := range hashes {
diff --git a/validator/server_arb/machine.go b/validator/server_arb/machine.go
index adca969..1e73e6b 100644
--- a/validator/server_arb/machine.go
+++ b/validator/server_arb/machine.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 
 ResolvedPreimage preimageResolverC(size_t context, uint8_t preimageType, const uint8_t* hash);
diff --git a/validator/server_arb/machine_cache.go b/validator/server_arb/machine_cache.go
index 23fcdef..35f3406 100644
--- a/validator/server_arb/machine_cache.go
+++ b/validator/server_arb/machine_cache.go
@@ -31,7 +31,7 @@ type MachineCache struct {
 }
 
 type MachineCacheConfig struct {
-	CachedChallengeMachines int    `koanf:"cached-challenge-machines"`
+	CachedChallengeMachines uint64 `koanf:"cached-challenge-machines"`
 	InitialSteps            uint64 `koanf:"initial-steps"`
 }
 
@@ -42,7 +42,7 @@ var DefaultMachineCacheConfig = MachineCacheConfig{
 
 func MachineCacheConfigConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Uint64(prefix+".initial-steps", DefaultMachineCacheConfig.InitialSteps, "initial steps between machines")
-	f.Int(prefix+".cached-challenge-machines", DefaultMachineCacheConfig.CachedChallengeMachines, "how many machines to store in cache while working on a challenge (should be even)")
+	f.Uint64(prefix+".cached-challenge-machines", DefaultMachineCacheConfig.CachedChallengeMachines, "how many machines to store in cache while working on a challenge (should be even)")
 }
 
 // `initialMachine` won't be mutated by this function.
@@ -140,7 +140,7 @@ func (c *MachineCache) unlockBuild(err error) {
 }
 
 func (c *MachineCache) setRangeLocked(ctx context.Context, start uint64, end uint64) error {
-	newInterval := (end - start) / uint64(c.config.CachedChallengeMachines)
+	newInterval := (end - start) / c.config.CachedChallengeMachines
 	if newInterval == 0 {
 		newInterval = 2
 	}
@@ -150,7 +150,7 @@ func (c *MachineCache) setRangeLocked(ctx context.Context, start uint64, end uin
 	if end >= c.finalMachineStep {
 		end = c.finalMachineStep - newInterval/2
 	}
-	newInterval = (end - start) / uint64(c.config.CachedChallengeMachines)
+	newInterval = (end - start) / c.config.CachedChallengeMachines
 	if newInterval == 0 {
 		newInterval = 1
 	}
@@ -212,7 +212,7 @@ func (c *MachineCache) populateCache(ctx context.Context) error {
 		if nextMachine.GetStepCount()+c.machineStepInterval >= c.finalMachineStep {
 			break
 		}
-		if len(c.machines) >= c.config.CachedChallengeMachines {
+		if uint64(len(c.machines)) >= c.config.CachedChallengeMachines {
 			break
 		}
 		nextMachine = nextMachine.CloneMachineInterface()
@@ -236,9 +236,11 @@ func (c *MachineCache) getClosestMachine(stepCount uint64) (int, MachineInterfac
 	}
 	stepsFromStart := stepCount - c.firstMachineStep
 	var index int
+	// #nosec G115
 	if c.machineStepInterval == 0 || stepsFromStart > c.machineStepInterval*uint64(len(c.machines)-1) {
 		index = len(c.machines) - 1
 	} else {
+		// #nosec G115
 		index = int(stepsFromStart / c.machineStepInterval)
 	}
 	return index, c.machines[index]
diff --git a/validator/server_arb/nitro_machine.go b/validator/server_arb/nitro_machine.go
index 2b2cb23..926b1e8 100644
--- a/validator/server_arb/nitro_machine.go
+++ b/validator/server_arb/nitro_machine.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 #include <stdlib.h>
 */
diff --git a/validator/server_arb/preimage_resolver.go b/validator/server_arb/preimage_resolver.go
index cd4ea40..f01d79f 100644
--- a/validator/server_arb/preimage_resolver.go
+++ b/validator/server_arb/preimage_resolver.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../../target/include/
+#cgo CFLAGS: -g -I../../target/include/
 #include "arbitrator.h"
 
 extern ResolvedPreimage preimageResolver(size_t context, uint8_t preimageType, const uint8_t* hash);
diff --git a/validator/server_arb/prover_interface.go b/validator/server_arb/prover_interface.go
index bdd81ed..3010d21 100644
--- a/validator/server_arb/prover_interface.go
+++ b/validator/server_arb/prover_interface.go
@@ -4,7 +4,7 @@
 package server_arb
 
 /*
-#cgo CFLAGS: -g -Wall -I../target/include/
+#cgo CFLAGS: -g -I../target/include/
 #cgo LDFLAGS: ${SRCDIR}/../../target/lib/libstylus.a -ldl -lm
 #include "arbitrator.h"
 #include <stdlib.h>
diff --git a/validator/server_arb/validator_spawner.go b/validator/server_arb/validator_spawner.go
index 1d4126d..07971e2 100644
--- a/validator/server_arb/validator_spawner.go
+++ b/validator/server_arb/validator_spawner.go
@@ -2,17 +2,15 @@ package server_arb
 
 import (
 	"context"
-	"encoding/binary"
 	"errors"
 	"fmt"
-	"os"
-	"path/filepath"
 	"runtime"
 	"sync/atomic"
 	"time"
 
 	"github.com/spf13/pflag"
 
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/util/containers"
 	"github.com/offchainlabs/nitro/util/stopwaiter"
@@ -21,6 +19,7 @@ import (
 	"github.com/offchainlabs/nitro/validator/valnode/redis"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 )
@@ -88,15 +87,15 @@ func (s *ArbitratorSpawner) WasmModuleRoots() ([]common.Hash, error) {
 	return s.locator.ModuleRoots(), nil
 }
 
-func (s *ArbitratorSpawner) StylusArchs() []string {
-	return []string{"wavm"}
+func (s *ArbitratorSpawner) StylusArchs() []ethdb.WasmTarget {
+	return []ethdb.WasmTarget{rawdb.TargetWavm}
 }
 
 func (s *ArbitratorSpawner) Name() string {
 	return "arbitrator"
 }
 
-func (v *ArbitratorSpawner) loadEntryToMachine(ctx context.Context, entry *validator.ValidationInput, mach *ArbitratorMachine) error {
+func (v *ArbitratorSpawner) loadEntryToMachine(_ context.Context, entry *validator.ValidationInput, mach *ArbitratorMachine) error {
 	resolver := func(ty arbutil.PreimageType, hash common.Hash) ([]byte, error) {
 		// Check if it's a known preimage
 		if preimage, ok := entry.Preimages[ty][hash]; ok {
@@ -122,14 +121,14 @@ func (v *ArbitratorSpawner) loadEntryToMachine(ctx context.Context, entry *valid
 			return fmt.Errorf("error while trying to add sequencer msg for proving: %w", err)
 		}
 	}
-	if len(entry.UserWasms["wavm"]) == 0 {
+	if len(entry.UserWasms[rawdb.TargetWavm]) == 0 {
 		for stylusArch, wasms := range entry.UserWasms {
 			if len(wasms) > 0 {
 				return fmt.Errorf("bad stylus arch loaded to machine. Expected wavm. Got: %s", stylusArch)
 			}
 		}
 	}
-	for moduleHash, module := range entry.UserWasms["wavm"] {
+	for moduleHash, module := range entry.UserWasms[rawdb.TargetWavm] {
 		err = mach.AddUserWasm(moduleHash, module)
 		if err != nil {
 			log.Error(
@@ -178,7 +177,10 @@ func (v *ArbitratorSpawner) execute(
 		}
 		steps += count
 	}
+
+	// #nosec G115
 	arbitratorValidationSteps.Update(int64(mach.GetStepCount()))
+
 	if mach.IsErrored() {
 		log.Error("machine entered errored state during attempted validation", "block", entry.Id)
 		return validator.GoGlobalState{}, errors.New("machine entered errored state during attempted validation")
@@ -187,6 +189,7 @@ func (v *ArbitratorSpawner) execute(
 }
 
 func (v *ArbitratorSpawner) Launch(entry *validator.ValidationInput, moduleRoot common.Hash) validator.ValidationRun {
+	println("LAUCHING ARBITRATOR VALIDATION")
 	v.count.Add(1)
 	promise := stopwaiter.LaunchPromiseThread[validator.GoGlobalState](v, func(ctx context.Context) (validator.GoGlobalState, error) {
 		defer v.count.Add(-1)
@@ -203,139 +206,6 @@ func (v *ArbitratorSpawner) Room() int {
 	return avail
 }
 
-var launchTime = time.Now().Format("2006_01_02__15_04")
-
-//nolint:gosec
-func (v *ArbitratorSpawner) writeToFile(ctx context.Context, input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) error {
-	outDirPath := filepath.Join(v.locator.RootPath(), v.config().OutputPath, launchTime, fmt.Sprintf("block_%d", input.Id))
-	err := os.MkdirAll(outDirPath, 0755)
-	if err != nil {
-		return err
-	}
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	rootPathAssign := ""
-	if executable, err := os.Executable(); err == nil {
-		rootPathAssign = "ROOTPATH=\"" + filepath.Dir(executable) + "\"\n"
-	}
-	cmdFile, err := os.OpenFile(filepath.Join(outDirPath, "run-prover.sh"), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
-	if err != nil {
-		return err
-	}
-	defer cmdFile.Close()
-	_, err = cmdFile.WriteString("#!/bin/bash\n" +
-		fmt.Sprintf("# expected output: batch %d, postion %d, hash %s\n", expOut.Batch, expOut.PosInBatch, expOut.BlockHash) +
-		"MACHPATH=\"" + v.locator.GetMachinePath(moduleRoot) + "\"\n" +
-		rootPathAssign +
-		"if (( $# > 1 )); then\n" +
-		"	if [[ $1 == \"-m\" ]]; then\n" +
-		"		MACHPATH=$2\n" +
-		"		shift\n" +
-		"		shift\n" +
-		"	fi\n" +
-		"fi\n" +
-		"${ROOTPATH}/bin/prover ${MACHPATH}/replay.wasm")
-	if err != nil {
-		return err
-	}
-	if ctx.Err() != nil {
-		return ctx.Err()
-	}
-
-	libraries := []string{"soft-float.wasm", "wasi_stub.wasm", "go_stub.wasm", "host_io.wasm", "brotli.wasm"}
-	for _, module := range libraries {
-		_, err = cmdFile.WriteString(" -l " + "${MACHPATH}/" + module)
-		if err != nil {
-			return err
-		}
-	}
-	_, err = cmdFile.WriteString(fmt.Sprintf(" --inbox-position %d --position-within-message %d --last-block-hash %s", input.StartState.Batch, input.StartState.PosInBatch, input.StartState.BlockHash))
-	if err != nil {
-		return err
-	}
-
-	for _, msg := range input.BatchInfo {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		sequencerFileName := fmt.Sprintf("sequencer_%d.bin", msg.Number)
-		err = os.WriteFile(filepath.Join(outDirPath, sequencerFileName), msg.Data, 0644)
-		if err != nil {
-			return err
-		}
-		_, err = cmdFile.WriteString(" --inbox " + sequencerFileName)
-		if err != nil {
-			return err
-		}
-	}
-
-	preimageFile, err := os.Create(filepath.Join(outDirPath, "preimages.bin"))
-	if err != nil {
-		return err
-	}
-	defer preimageFile.Close()
-	for ty, preimages := range input.Preimages {
-		_, err = preimageFile.Write([]byte{byte(ty)})
-		if err != nil {
-			return err
-		}
-		for _, data := range preimages {
-			if ctx.Err() != nil {
-				return ctx.Err()
-			}
-			lenbytes := make([]byte, 8)
-			binary.LittleEndian.PutUint64(lenbytes, uint64(len(data)))
-			_, err := preimageFile.Write(lenbytes)
-			if err != nil {
-				return err
-			}
-			_, err = preimageFile.Write(data)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	_, err = cmdFile.WriteString(" --preimages preimages.bin")
-	if err != nil {
-		return err
-	}
-
-	if input.HasDelayedMsg {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-		_, err = cmdFile.WriteString(fmt.Sprintf(" --delayed-inbox-position %d", input.DelayedMsgNr))
-		if err != nil {
-			return err
-		}
-		filename := fmt.Sprintf("delayed_%d.bin", input.DelayedMsgNr)
-		err = os.WriteFile(filepath.Join(outDirPath, filename), input.DelayedMsg, 0644)
-		if err != nil {
-			return err
-		}
-		_, err = cmdFile.WriteString(fmt.Sprintf(" --delayed-inbox %s", filename))
-		if err != nil {
-			return err
-		}
-	}
-
-	_, err = cmdFile.WriteString(" \"$@\"\n")
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (v *ArbitratorSpawner) WriteToFile(input *validator.ValidationInput, expOut validator.GoGlobalState, moduleRoot common.Hash) containers.PromiseInterface[struct{}] {
-	return stopwaiter.LaunchPromiseThread[struct{}](v, func(ctx context.Context) (struct{}, error) {
-		err := v.writeToFile(ctx, input, expOut, moduleRoot)
-		return struct{}{}, err
-	})
-}
-
 func (v *ArbitratorSpawner) CreateExecutionRun(wasmModuleRoot common.Hash, input *validator.ValidationInput) containers.PromiseInterface[validator.ExecutionRun] {
 	getMachine := func(ctx context.Context) (MachineInterface, error) {
 		initialFrozenMachine, err := v.machineLoader.GetZeroStepMachine(ctx, wasmModuleRoot)
diff --git a/validator/server_jit/jit_machine.go b/validator/server_jit/jit_machine.go
index e4fb840..0748101 100644
--- a/validator/server_jit/jit_machine.go
+++ b/validator/server_jit/jit_machine.go
@@ -9,13 +9,14 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math"
 	"net"
 	"os"
 	"os/exec"
-	"runtime"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 	"github.com/offchainlabs/nitro/util/arbmath"
@@ -29,9 +30,10 @@ type JitMachine struct {
 	process              *exec.Cmd
 	stdin                io.WriteCloser
 	wasmMemoryUsageLimit int
+	maxExecutionTime     time.Duration
 }
 
-func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmMemoryUsageLimit int, moduleRoot common.Hash, fatalErrChan chan error) (*JitMachine, error) {
+func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmMemoryUsageLimit int, maxExecutionTime time.Duration, _ common.Hash, fatalErrChan chan error) (*JitMachine, error) {
 	invocation := []string{"--binary", binaryPath, "--forks"}
 	if cranelift {
 		invocation = append(invocation, "--cranelift")
@@ -54,6 +56,7 @@ func createJitMachine(jitBinary string, binaryPath string, cranelift bool, wasmM
 		process:              process,
 		stdin:                stdin,
 		wasmMemoryUsageLimit: wasmMemoryUsageLimit,
+		maxExecutionTime:     maxExecutionTime,
 	}
 	return machine, nil
 }
@@ -72,7 +75,7 @@ func (machine *JitMachine) prove(
 	defer cancel() // ensure our cleanup functions run when we're done
 	state := validator.GoGlobalState{}
 
-	timeout := time.Now().Add(60 * time.Second)
+	timeout := time.Now().Add(machine.maxExecutionTime)
 	tcp, err := net.ListenTCP("tcp4", &net.TCPAddr{
 		IP: []byte{127, 0, 0, 1},
 	})
@@ -125,6 +128,13 @@ func (machine *JitMachine) prove(
 	writeUint32 := func(data uint32) error {
 		return writeExact(arbmath.Uint32ToBytes(data))
 	}
+	writeIntAsUint32 := func(data int) error {
+		if data < 0 || data > math.MaxUint32 {
+			return fmt.Errorf("attempted to write out-of-bounds int %v as uint32", data)
+		}
+		// #nosec G115
+		return writeUint32(uint32(data))
+	}
 	writeUint64 := func(data uint64) error {
 		return writeExact(arbmath.UintToBytes(data))
 	}
@@ -192,14 +202,14 @@ func (machine *JitMachine) prove(
 
 	// send known preimages
 	preimageTypes := entry.Preimages
-	if err := writeUint32(uint32(len(preimageTypes))); err != nil {
+	if err := writeIntAsUint32(len(preimageTypes)); err != nil {
 		return state, err
 	}
 	for ty, preimages := range preimageTypes {
 		if err := writeUint8(uint8(ty)); err != nil {
 			return state, err
 		}
-		if err := writeUint32(uint32(len(preimages))); err != nil {
+		if err := writeIntAsUint32(len(preimages)); err != nil {
 			return state, err
 		}
 		for hash, preimage := range preimages {
@@ -212,18 +222,19 @@ func (machine *JitMachine) prove(
 		}
 	}
 
-	userWasms := entry.UserWasms[runtime.GOARCH]
+	localTarget := rawdb.LocalTarget()
+	userWasms := entry.UserWasms[localTarget]
 
 	// if there are user wasms, but only for wrong architecture - error
 	if len(userWasms) == 0 {
 		for arch, userWasms := range entry.UserWasms {
 			if len(userWasms) != 0 {
-				return state, fmt.Errorf("bad stylus arch for validation input. got: %v, expected: %v", arch, runtime.GOARCH)
+				return state, fmt.Errorf("bad stylus arch for validation input. got: %v, expected: %v", arch, localTarget)
 			}
 		}
 	}
 
-	if err := writeUint32(uint32(len(userWasms))); err != nil {
+	if err := writeIntAsUint32(len(userWasms)); err != nil {
 		return state, err
 	}
 	for moduleHash, program := range userWasms {
@@ -297,9 +308,11 @@ func (machine *JitMachine) prove(
 			if err != nil {
 				return state, fmt.Errorf("failed to read memory usage from Jit machine: %w", err)
 			}
+			// #nosec G115
 			if memoryUsed > uint64(machine.wasmMemoryUsageLimit) {
 				log.Warn("memory used by jit wasm exceeds the wasm memory usage limit", "limit", machine.wasmMemoryUsageLimit, "memoryUsed", memoryUsed)
 			}
+			// #nosec G115
 			jitWasmMemoryUsage.Update(int64(memoryUsed))
 			return state, nil
 		default:
diff --git a/validator/server_jit/machine_loader.go b/validator/server_jit/machine_loader.go
index cfa4753..3d8b013 100644
--- a/validator/server_jit/machine_loader.go
+++ b/validator/server_jit/machine_loader.go
@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/offchainlabs/nitro/validator/server_common"
@@ -52,14 +53,14 @@ type JitMachineLoader struct {
 	stopped bool
 }
 
-func NewJitMachineLoader(config *JitMachineConfig, locator *server_common.MachineLocator, fatalErrChan chan error) (*JitMachineLoader, error) {
+func NewJitMachineLoader(config *JitMachineConfig, locator *server_common.MachineLocator, maxExecutionTime time.Duration, fatalErrChan chan error) (*JitMachineLoader, error) {
 	jitPath, err := getJitPath()
 	if err != nil {
 		return nil, err
 	}
 	createMachineThreadFunc := func(ctx context.Context, moduleRoot common.Hash) (*JitMachine, error) {
 		binPath := filepath.Join(locator.GetMachinePath(moduleRoot), config.ProverBinPath)
-		return createJitMachine(jitPath, binPath, config.JitCranelift, config.WasmMemoryUsageLimit, moduleRoot, fatalErrChan)
+		return createJitMachine(jitPath, binPath, config.JitCranelift, config.WasmMemoryUsageLimit, maxExecutionTime, moduleRoot, fatalErrChan)
 	}
 	return &JitMachineLoader{
 		MachineLoader: *server_common.NewMachineLoader[JitMachine](locator, createMachineThreadFunc),
diff --git a/validator/server_jit/spawner.go b/validator/server_jit/spawner.go
index 5ba3664..f30b6e1 100644
--- a/validator/server_jit/spawner.go
+++ b/validator/server_jit/spawner.go
@@ -3,12 +3,14 @@ package server_jit
 import (
 	"context"
 	"fmt"
+	flag "github.com/spf13/pflag"
 	"runtime"
 	"sync/atomic"
-
-	flag "github.com/spf13/pflag"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/ethdb"
 
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 	"github.com/offchainlabs/nitro/validator"
@@ -16,8 +18,9 @@ import (
 )
 
 type JitSpawnerConfig struct {
-	Workers   int  `koanf:"workers" reload:"hot"`
-	Cranelift bool `koanf:"cranelift"`
+	Workers          int           `koanf:"workers" reload:"hot"`
+	Cranelift        bool          `koanf:"cranelift"`
+	MaxExecutionTime time.Duration `koanf:"max-execution-time" reload:"hot"`
 
 	// TODO: change WasmMemoryUsageLimit to a string and use resourcemanager.ParseMemLimit
 	WasmMemoryUsageLimit int `koanf:"wasm-memory-usage-limit"`
@@ -28,6 +31,7 @@ type JitSpawnerConfigFecher func() *JitSpawnerConfig
 var DefaultJitSpawnerConfig = JitSpawnerConfig{
 	Workers:              0,
 	Cranelift:            true,
+	MaxExecutionTime:     time.Minute * 10,
 	WasmMemoryUsageLimit: 4294967296, // 2^32 WASM memeory limit
 }
 
@@ -35,6 +39,7 @@ func JitSpawnerConfigAddOptions(prefix string, f *flag.FlagSet) {
 	f.Int(prefix+".workers", DefaultJitSpawnerConfig.Workers, "number of concurrent validation threads")
 	f.Bool(prefix+".cranelift", DefaultJitSpawnerConfig.Cranelift, "use Cranelift instead of LLVM when validating blocks using the jit-accelerated block validator")
 	f.Int(prefix+".wasm-memory-usage-limit", DefaultJitSpawnerConfig.WasmMemoryUsageLimit, "if memory used by a jit wasm exceeds this limit, a warning is logged")
+	f.Duration(prefix+".max-execution-time", DefaultJitSpawnerConfig.MaxExecutionTime, "if execution time used by a jit wasm exceeds this limit, a rpc error is returned")
 }
 
 type JitSpawner struct {
@@ -50,7 +55,8 @@ func NewJitSpawner(locator *server_common.MachineLocator, config JitSpawnerConfi
 	machineConfig := DefaultJitMachineConfig
 	machineConfig.JitCranelift = config().Cranelift
 	machineConfig.WasmMemoryUsageLimit = config().WasmMemoryUsageLimit
-	loader, err := NewJitMachineLoader(&machineConfig, locator, fatalErrChan)
+	maxExecutionTime := config().MaxExecutionTime
+	loader, err := NewJitMachineLoader(&machineConfig, locator, maxExecutionTime, fatalErrChan)
 	if err != nil {
 		return nil, err
 	}
@@ -71,8 +77,8 @@ func (v *JitSpawner) WasmModuleRoots() ([]common.Hash, error) {
 	return v.locator.ModuleRoots(), nil
 }
 
-func (v *JitSpawner) StylusArchs() []string {
-	return []string{runtime.GOARCH}
+func (v *JitSpawner) StylusArchs() []ethdb.WasmTarget {
+	return []ethdb.WasmTarget{rawdb.LocalTarget()}
 }
 
 func (v *JitSpawner) execute(
diff --git a/validator/validation_entry.go b/validator/validation_entry.go
index 133a67a..4ec6919 100644
--- a/validator/validation_entry.go
+++ b/validator/validation_entry.go
@@ -2,13 +2,13 @@ package validator
 
 import (
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/offchainlabs/nitro/arbutil"
 )
 
 type BatchInfo struct {
-	Number    uint64
-	BlockHash common.Hash
-	Data      []byte
+	Number uint64
+	Data   []byte
 }
 
 type ValidationInput struct {
@@ -16,7 +16,7 @@ type ValidationInput struct {
 	HasDelayedMsg bool
 	DelayedMsgNr  uint64
 	Preimages     map[arbutil.PreimageType]map[common.Hash][]byte
-	UserWasms     map[string]map[common.Hash][]byte
+	UserWasms     map[ethdb.WasmTarget]map[common.Hash][]byte
 	BatchInfo     []BatchInfo
 	DelayedMsg    []byte
 	StartState    GoGlobalState
diff --git a/validator/valnode/redis/consumer.go b/validator/valnode/redis/consumer.go
index fb7db1e..e0d53ff 100644
--- a/validator/valnode/redis/consumer.go
+++ b/validator/valnode/redis/consumer.go
@@ -3,6 +3,7 @@ package redis
 import (
 	"context"
 	"fmt"
+	"runtime"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -22,8 +23,9 @@ type ValidationServer struct {
 	spawner validator.ValidationSpawner
 
 	// consumers stores moduleRoot to consumer mapping.
-	consumers     map[common.Hash]*pubsub.Consumer[*validator.ValidationInput, validator.GoGlobalState]
-	streamTimeout time.Duration
+	consumers map[common.Hash]*pubsub.Consumer[*validator.ValidationInput, validator.GoGlobalState]
+
+	config *ValidationServerConfig
 }
 
 func NewValidationServer(cfg *ValidationServerConfig, spawner validator.ValidationSpawner) (*ValidationServer, error) {
@@ -44,9 +46,9 @@ func NewValidationServer(cfg *ValidationServerConfig, spawner validator.Validati
 		consumers[mr] = c
 	}
 	return &ValidationServer{
-		consumers:     consumers,
-		spawner:       spawner,
-		streamTimeout: cfg.StreamTimeout,
+		consumers: consumers,
+		spawner:   spawner,
+		config:    cfg,
 	}, nil
 }
 
@@ -54,6 +56,23 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 	s.StopWaiter.Start(ctx_in, s)
 	// Channel that all consumers use to indicate their readiness.
 	readyStreams := make(chan struct{}, len(s.consumers))
+	type workUnit struct {
+		req        *pubsub.Message[*validator.ValidationInput]
+		moduleRoot common.Hash
+	}
+	workers := s.config.Workers
+	if workers == 0 {
+		workers = runtime.NumCPU()
+	}
+	workQueue := make(chan workUnit, workers)
+	tokensCount := workers
+	if s.config.BufferReads {
+		tokensCount += workers
+	}
+	requestTokenQueue := make(chan struct{}, tokensCount)
+	for i := 0; i < tokensCount; i++ {
+		requestTokenQueue <- struct{}{}
+	}
 	for moduleRoot, c := range s.consumers {
 		c := c
 		moduleRoot := moduleRoot
@@ -84,26 +103,31 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 			case <-ready: // Wait until the stream exists and start consuming iteratively.
 			}
 			s.StopWaiter.CallIteratively(func(ctx context.Context) time.Duration {
+				log.Debug("waiting for request token", "cid", c.Id())
+				select {
+				case <-ctx.Done():
+					return 0
+				case <-requestTokenQueue:
+				}
+				log.Debug("got request token", "cid", c.Id())
 				req, err := c.Consume(ctx)
 				if err != nil {
 					log.Error("Consuming request", "error", err)
+					requestTokenQueue <- struct{}{}
 					return 0
 				}
 				if req == nil {
-					// There's nothing in the queue.
+					log.Debug("consumed nil", "cid", c.Id())
+					// There's nothing in the queue
+					requestTokenQueue <- struct{}{}
 					return time.Second
 				}
-				valRun := s.spawner.Launch(req.Value, moduleRoot)
-				res, err := valRun.Await(ctx)
-				if err != nil {
-					log.Error("Error validating", "request value", req.Value, "error", err)
-					return 0
-				}
-				if err := c.SetResult(ctx, req.ID, res); err != nil {
-					log.Error("Error setting result for request", "id", req.ID, "result", res, "error", err)
-					return 0
+				log.Debug("forwarding work", "cid", c.Id(), "workid", req.ID)
+				select {
+				case <-ctx.Done():
+				case workQueue <- workUnit{req, moduleRoot}:
 				}
-				return time.Second
+				return 0
 			})
 		})
 	}
@@ -111,9 +135,9 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 		for {
 			select {
 			case <-readyStreams:
-				log.Trace("At least one stream is ready")
+				log.Debug("At least one stream is ready")
 				return // Don't block Start if at least one of the stream is ready.
-			case <-time.After(s.streamTimeout):
+			case <-time.After(s.config.StreamTimeout):
 				log.Error("Waiting for redis streams timed out")
 			case <-ctx.Done():
 				log.Info("Context done while waiting redis streams to be ready, failed to start")
@@ -121,6 +145,37 @@ func (s *ValidationServer) Start(ctx_in context.Context) {
 			}
 		}
 	})
+	for i := 0; i < workers; i++ {
+		i := i
+		s.StopWaiter.LaunchThread(func(ctx context.Context) {
+			for {
+				log.Debug("waiting for work", "thread", i)
+				var work workUnit
+				select {
+				case <-ctx.Done():
+					return
+				case work = <-workQueue:
+				}
+				log.Debug("got work", "thread", i, "workid", work.req.ID)
+				valRun := s.spawner.Launch(work.req.Value, work.moduleRoot)
+				res, err := valRun.Await(ctx)
+				if err != nil {
+					log.Error("Error validating", "request value", work.req.Value, "error", err)
+				} else {
+					log.Debug("done work", "thread", i, "workid", work.req.ID)
+					if err := s.consumers[work.moduleRoot].SetResult(ctx, work.req.ID, res); err != nil {
+						log.Error("Error setting result for request", "id", work.req.ID, "result", res, "error", err)
+					}
+					log.Debug("set result", "thread", i, "workid", work.req.ID)
+				}
+				select {
+				case <-ctx.Done():
+					return
+				case requestTokenQueue <- struct{}{}:
+				}
+			}
+		})
+	}
 }
 
 type ValidationServerConfig struct {
@@ -131,6 +186,8 @@ type ValidationServerConfig struct {
 	// Timeout on polling for existence of each redis stream.
 	StreamTimeout time.Duration `koanf:"stream-timeout"`
 	StreamPrefix  string        `koanf:"stream-prefix"`
+	Workers       int           `koanf:"workers"`
+	BufferReads   bool          `koanf:"buffer-reads"`
 }
 
 var DefaultValidationServerConfig = ValidationServerConfig{
@@ -139,6 +196,8 @@ var DefaultValidationServerConfig = ValidationServerConfig{
 	ConsumerConfig: pubsub.DefaultConsumerConfig,
 	ModuleRoots:    []string{},
 	StreamTimeout:  10 * time.Minute,
+	Workers:        0,
+	BufferReads:    true,
 }
 
 var TestValidationServerConfig = ValidationServerConfig{
@@ -147,6 +206,8 @@ var TestValidationServerConfig = ValidationServerConfig{
 	ConsumerConfig: pubsub.TestConsumerConfig,
 	ModuleRoots:    []string{},
 	StreamTimeout:  time.Minute,
+	Workers:        1,
+	BufferReads:    true,
 }
 
 func ValidationServerConfigAddOptions(prefix string, f *pflag.FlagSet) {
@@ -155,6 +216,8 @@ func ValidationServerConfigAddOptions(prefix string, f *pflag.FlagSet) {
 	f.String(prefix+".redis-url", DefaultValidationServerConfig.RedisURL, "url of redis server")
 	f.String(prefix+".stream-prefix", DefaultValidationServerConfig.StreamPrefix, "prefix for stream name")
 	f.Duration(prefix+".stream-timeout", DefaultValidationServerConfig.StreamTimeout, "Timeout on polling for existence of redis streams")
+	f.Int(prefix+".workers", DefaultValidationServerConfig.Workers, "number of validation threads (0 to use number of CPUs)")
+	f.Bool(prefix+".buffer-reads", DefaultValidationServerConfig.BufferReads, "buffer reads (read next while working)")
 }
 
 func (cfg *ValidationServerConfig) Enabled() bool {
diff --git a/validator/valnode/validation_api.go b/validator/valnode/validation_api.go
index 6245ffc..ef3e1b2 100644
--- a/validator/valnode/validation_api.go
+++ b/validator/valnode/validation_api.go
@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
 
 	"github.com/offchainlabs/nitro/util/stopwaiter"
 	"github.com/offchainlabs/nitro/validator"
@@ -44,7 +45,7 @@ func (a *ValidationServerAPI) WasmModuleRoots() ([]common.Hash, error) {
 	return a.spawner.WasmModuleRoots()
 }
 
-func (a *ValidationServerAPI) StylusArchs() ([]string, error) {
+func (a *ValidationServerAPI) StylusArchs() ([]ethdb.WasmTarget, error) {
 	return a.spawner.StylusArchs(), nil
 }
 
@@ -117,15 +118,6 @@ func (a *ExecServerAPI) Start(ctx_in context.Context) {
 	a.CallIteratively(a.removeOldRuns)
 }
 
-func (a *ExecServerAPI) WriteToFile(ctx context.Context, jsonInput *server_api.InputJSON, expOut validator.GoGlobalState, moduleRoot common.Hash) error {
-	input, err := server_api.ValidationInputFromJson(jsonInput)
-	if err != nil {
-		return err
-	}
-	_, err = a.execSpawner.WriteToFile(input, expOut, moduleRoot).Await(ctx)
-	return err
-}
-
 var errRunNotFound error = errors.New("run not found")
 
 func (a *ExecServerAPI) getRun(id uint64) (validator.ExecutionRun, error) {
diff --git a/wavmio/stub.go b/wavmio/stub.go
index 7fd29e2..0c82506 100644
--- a/wavmio/stub.go
+++ b/wavmio/stub.go
@@ -60,13 +60,14 @@ func parsePreimageBytes(path string) {
 		if read != len(lenBuf) {
 			panic(fmt.Sprintf("missing bytes reading len got %d", read))
 		}
-		fieldSize := int(binary.LittleEndian.Uint64(lenBuf))
+		fieldSize := binary.LittleEndian.Uint64(lenBuf)
 		dataBuf := make([]byte, fieldSize)
 		read, err = file.Read(dataBuf)
 		if err != nil {
 			panic(err)
 		}
-		if read != fieldSize {
+		// #nosec G115
+		if uint64(read) != fieldSize {
 			panic("missing bytes reading data")
 		}
 		hash := crypto.Keccak256Hash(dataBuf)
@@ -77,18 +78,18 @@ func parsePreimageBytes(path string) {
 func StubInit() {
 	preimages = make(map[common.Hash][]byte)
 	var delayedMsgPath arrayFlags
-	seqMsgPosFlag := flag.Int("inbox-position", 0, "position for sequencer inbox message")
-	posWithinMsgFlag := flag.Int("position-within-message", 0, "position inside sequencer inbox message")
-	delayedPositionFlag := flag.Int("delayed-inbox-position", 0, "position for first delayed inbox message")
+	seqMsgPosFlag := flag.Uint64("inbox-position", 0, "position for sequencer inbox message")
+	posWithinMsgFlag := flag.Uint64("position-within-message", 0, "position inside sequencer inbox message")
+	delayedPositionFlag := flag.Uint64("delayed-inbox-position", 0, "position for first delayed inbox message")
 	lastBlockFlag := flag.String("last-block-hash", "0000000000000000000000000000000000000000000000000000000000000000", "lastBlockHash")
 	flag.Var(&delayedMsgPath, "delayed-inbox", "delayed inbox messages (multiple values)")
 	inboxPath := flag.String("inbox", "", "file to load sequencer message")
 	preimagesPath := flag.String("preimages", "", "file to load preimages from")
 	flag.Parse()
 
-	seqMsgPos = uint64(*seqMsgPosFlag)
-	posWithinMsg = uint64(*posWithinMsgFlag)
-	delayedMsgFirstPos = uint64(*delayedPositionFlag)
+	seqMsgPos = *seqMsgPosFlag
+	posWithinMsg = *posWithinMsgFlag
+	delayedMsgFirstPos = *delayedPositionFlag
 	lastBlockHash = common.HexToHash(*lastBlockFlag)
 	for _, path := range delayedMsgPath {
 		msg, err := os.ReadFile(path)
@@ -125,7 +126,7 @@ func ReadInboxMessage(msgNum uint64) []byte {
 }
 
 func ReadDelayedInboxMessage(seqNum uint64) []byte {
-	if seqNum < delayedMsgFirstPos || (int(seqNum-delayedMsgFirstPos) > len(delayedMsgs)) {
+	if seqNum < delayedMsgFirstPos || (seqNum-delayedMsgFirstPos > uint64(len(delayedMsgs))) {
 		panic(fmt.Sprintf("trying to read bad delayed msg %d", seqNum))
 	}
 	return delayedMsgs[seqNum-delayedMsgFirstPos]
diff --git a/wsbroadcastserver/clientconnection.go b/wsbroadcastserver/clientconnection.go
index 16a8f64..00ae0f0 100644
--- a/wsbroadcastserver/clientconnection.go
+++ b/wsbroadcastserver/clientconnection.go
@@ -135,6 +135,7 @@ func (cc *ClientConnection) writeBacklog(ctx context.Context, segment backlog.Ba
 
 		msgs := prevSegment.Messages()
 		if isFirstSegment && prevSegment.Contains(uint64(cc.requestedSeqNum)) {
+			// #nosec G115
 			requestedIdx := int(cc.requestedSeqNum) - int(prevSegment.Start())
 			// This might be false if messages were added after we fetched the segment's messages
 			if len(msgs) >= requestedIdx {